Bool sbc_read_capacity (void)
{
U32 mem_size_nb_sector;
switch (mem_read_capacity (usb_LUN, &mem_size_nb_sector))
{
case CTRL_GOOD:
Usb_reset_endpoint_fifo_access (g_scsi_ep_ms_in);
// Return nb block.
Usb_write_endpoint_data (g_scsi_ep_ms_in, 32, sbc_format_mcu_to_scsi_data (32, mem_size_nb_sector));
// Return block size (= 512 bytes).
Usb_write_endpoint_data (g_scsi_ep_ms_in, 32, Sbc_format_mcu_to_scsi_data (32, 512));
Sbc_valid_write_usb (SBC_READ_CAPACITY_LENGTH);
sbc_lun_status_is_good ();
return TRUE;
case CTRL_NO_PRESENT:
sbc_lun_status_is_not_present ();
break;
case CTRL_BUSY:
sbc_lun_status_is_busy_or_change ();
break;
case CTRL_FAIL:
default:
sbc_lun_status_is_fail ();
break;
}
return FALSE;
}
//!
//! @brief USB Command Status Wrapper (CSW) management
//!
//! This function sends the status in relation with the last CBW.
//!
static void usb_mass_storage_csw(void)
{
while (Is_usb_endpoint_stall_requested(EP_MS_IN))
{
if (Is_usb_setup_received()) usb_process_request();
}
while (Is_usb_endpoint_stall_requested(EP_MS_OUT))
{
if (Is_usb_setup_received()) usb_process_request();
}
while (!Is_usb_in_ready(EP_MS_IN));
Usb_reset_endpoint_fifo_access(EP_MS_IN);
//! Write CSW Signature
Usb_write_endpoint_data(EP_MS_IN, 32, *(U32 *)&"USBS");
//! Write stored CBW Tag
Usb_write_endpoint_data(EP_MS_IN, 32, dCBWTag);
//! Write data residual value
Usb_write_endpoint_data(EP_MS_IN, 32,
usb_format_mcu_to_usb_data(32, g_scsi_data_remaining));
//! Write command status
Usb_write_endpoint_data(EP_MS_IN, 8, g_scsi_status);
Usb_ack_in_ready_send(EP_MS_IN);
}
void audio_micro_get_vol_cur(void)
{
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 8, LSB(s16_micro_volume));
Usb_write_endpoint_data(EP_CONTROL, 8, MSB(s16_micro_volume));
Usb_ack_control_in_ready_send();
while(!Is_usb_control_out_received()) // send a ZLP
{
TASKS_SCHEDULE();
}
Usb_ack_control_out_received_free();
}
//!
//! @brief USB Command Status Wrapper (CSW) management
//!
//! This function sends the status in relation with the last CBW.
//!
static void usb_mass_storage_csw(void)
{
while (Is_usb_endpoint_stall_requested(EP_MS_IN))
{
if (Is_usb_setup_received()) usb_process_request();
}
while (Is_usb_endpoint_stall_requested(EP_MS_OUT))
{
if (Is_usb_setup_received()) usb_process_request();
}
// MSC Compliance - Free BAD out receive during SCSI command
while( Is_usb_out_received(EP_MS_OUT) ) {
Usb_ack_out_received_free(EP_MS_OUT);
}
while (!Is_usb_in_ready(EP_MS_IN));
Usb_reset_endpoint_fifo_access(EP_MS_IN);
//! Write CSW Signature
Usb_write_endpoint_data(EP_MS_IN, 32, *(U32 *)&"USBS");
//! Write stored CBW Tag
Usb_write_endpoint_data(EP_MS_IN, 32, dCBWTag);
//! Write data residual value
Usb_write_endpoint_data(EP_MS_IN, 32,
usb_format_mcu_to_usb_data(32, g_scsi_data_remaining));
//! Write command status
Usb_write_endpoint_data(EP_MS_IN, 8, g_scsi_status);
Usb_ack_in_ready_send(EP_MS_IN);
// MSC Compliance - Wait end of all transmissions on USB line
while( 0 != Usb_nb_busy_bank(EP_MS_IN) )
{
if (Is_usb_setup_received()) usb_process_request();
}
// Release the USB Mutex.
if( true == xGiveUsbMutex )
{
x_supervisor_SemaphoreGive( xUSBMutex );
}
}
static void sbc_header_mode_sense (Bool b_sense_10, U8 u8_data_length)
{
Usb_reset_endpoint_fifo_access (g_scsi_ep_ms_in);
// Send data length.
if (b_sense_10)
{
Usb_write_endpoint_data (g_scsi_ep_ms_in, 8, 0);
}
Usb_write_endpoint_data (g_scsi_ep_ms_in, 8, u8_data_length);
// Send device type.
Usb_write_endpoint_data (g_scsi_ep_ms_in, 8, SBC_MEDIUM_TYPE);
// Write protect status.
Usb_write_endpoint_data (g_scsi_ep_ms_in, 8, (mem_wr_protect (usb_LUN)) ? SBC_DEV_SPEC_PARAM_WR_PROTECT : SBC_DEV_SPEC_PARAM_WR_ENABLE);
if (b_sense_10)
{
// Reserved.
Usb_write_endpoint_data (g_scsi_ep_ms_in, 16, 0);
}
// Send block descriptor length.
if (b_sense_10)
{
Usb_write_endpoint_data (g_scsi_ep_ms_in, 8, 0);
}
Usb_write_endpoint_data (g_scsi_ep_ms_in, 8, SBC_BLOCK_DESCRIPTOR_LENGTH);
}
//! This function is called by the standard USB read request function when
//! the USB request is not supported. This function returns true when the
//! request is processed. This function returns false if the request is not
//! supported. In this case, a STALL handshake will be automatically
//! sent by the standard USB read request function.
//!
bool usb_user_read_request(U8 type, U8 request)
{
Usb_read_endpoint_data(EP_CONTROL, 8); // string_type
Usb_read_endpoint_data(EP_CONTROL, 8); // descriptor_type
switch (request)
{
#if( EVK1101_CTRL_PANEL_PID==EVK1101_CTRL_PANEL_DEMO_HID_MS_PID )
case MASS_STORAGE_RESET:
Usb_ack_setup_received_free();
Usb_ack_control_in_ready_send();
return true;
case GET_MAX_LUN:
Usb_ack_setup_received_free();
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 8, get_nb_lun() - 1);
Usb_ack_control_in_ready_send();
while (!Is_usb_control_in_ready());
while(!Is_usb_control_out_received());
Usb_ack_control_out_received_free();
ms_multiple_drive = true;
return true;
#endif
/*
case HID_SET_REPORT:
switch (descriptor_type)
{
case HID_REPORT_OUTPUT:
Usb_ack_setup_received_free();
while (!Is_usb_control_out_received());
Usb_ack_control_out_received_free();
Usb_ack_control_in_ready_send();
while (!Is_usb_control_in_ready());
return true;
default:
break;
}
break;
case HID_SET_IDLE:
Usb_ack_setup_received_free();
Usb_ack_control_in_ready_send();
while (!Is_usb_control_in_ready());
return true;
*/
default:
break;
}
return false;
}
int uart_usb_putchar(int data_to_send)
{
while( !uart_usb_tx_ready() ); // Wait Endpoint ready
Usb_write_endpoint_data(TX_EP, 8, data_to_send);
if( !Is_usb_write_enabled(TX_EP) ) // If Endpoint full -> flush
{
uart_usb_flush();
}
return data_to_send;
}
//! This function is called by the standard USB read request function when
//! the USB request is not supported. This function returns true when the
//! request is processed. This function returns false if the request is not
//! supported. In this case, a STALL handshake will be automatically
//! sent by the standard USB read request function.
//!
bool usb_user_read_request(uint8_t type, uint8_t request)
{
uint16_t wInterface;
uint8_t wValue_msb;
uint8_t wValue_lsb;
wValue_lsb = Usb_read_endpoint_data(EP_CONTROL, 8);
wValue_msb = Usb_read_endpoint_data(EP_CONTROL, 8);
//** Specific request from Class MassStorage
if( USB_SETUP_SET_CLASS_INTER == type )
{
switch( request )
{
case MASS_STORAGE_RESET:
// wValue must be 0
// wIndex = Interface
if( (0!=wValue_lsb) || (0!=wValue_msb) )
break;
wInterface=Usb_read_endpoint_data(EP_CONTROL, 16);
if( INTERFACE_NB != wInterface )
break;
Usb_ack_setup_received_free();
Usb_ack_control_in_ready_send();
return true;
}
}
if( USB_SETUP_GET_CLASS_INTER == type )
{
switch( request )
{
case GET_MAX_LUN:
// wValue must be 0
// wIndex = Interface
if( (0!=wValue_lsb) || (0!=wValue_msb) )
break;
wInterface=Usb_read_endpoint_data(EP_CONTROL, 16);
if( INTERFACE_NB != wInterface )
break;
Usb_ack_setup_received_free();
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 8, get_nb_lun() - 1);
Usb_ack_control_in_ready_send();
while (!Is_usb_control_in_ready());
while(!Is_usb_control_out_received());
Usb_ack_control_out_received_free();
ms_multiple_drive = true;
return true;
}
}
return false;
}
void audio_speaker_get_vol_max(void)
{
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 16, Usb_format_mcu_to_usb_data(16, USB_SPEAKER_VOL_MAX));
Usb_ack_control_in_ready_send();
while(!Is_usb_control_out_received()) // send a ZLP
{
TASKS_SCHEDULE();
}
Usb_ack_control_out_received_free();
}
static void USB_CCID_SendDataToUSB (void)
{
int USB_Datalen_s32;
int i;
while (Is_usb_endpoint_stall_requested (EP_CCID_IN))
{
if (Is_usb_setup_received ())
usb_process_request ();
}
while (Is_usb_endpoint_stall_requested (EP_CCID_OUT))
{
if (Is_usb_setup_received ())
usb_process_request ();
}
// MSC Compliance - Free BAD out receive during SCSI command
while (Is_usb_out_received (EP_CCID_OUT))
{
Usb_ack_out_received_free (EP_CCID_OUT);
}
while (!Is_usb_in_ready (EP_CCID_IN))
{
if (!Is_usb_endpoint_enabled (EP_CCID_IN))
{
i = 0; // todo USB Reset
}
}
Usb_reset_endpoint_fifo_access (EP_CCID_IN);
USB_Datalen_s32 = USB_CCID_data_st.CCID_datalen + 10;
for (i = 0; i < USB_Datalen_s32; i++)
{
Usb_write_endpoint_data (EP_CCID_IN, 8, USB_CCID_data_st.USB_data[i]);
}
Usb_ack_in_ready_send (EP_CCID_IN);
USB_Log_st.CCID_ReadCalls_u32++;
USB_Log_st.CCID_BytesRead_u32 += USB_Datalen_s32;
// MSC Compliance - Wait end of all transmitions on USB line
while (0 != Usb_nb_busy_bank (EP_CCID_IN))
{
if (Is_usb_setup_received ())
usb_process_request ();
}
}
void audio_speaker_get_mute(void)
{
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 8, b_speaker_mute);
Usb_ack_control_in_ready_send();
while(!Is_usb_control_out_received()) // send a ZLP
{
TASKS_SCHEDULE();
}
Usb_ack_control_out_received_free();
}
//! This function manages the GET CONFIGURATION request. The current
//! configuration number is returned.
//!
void usb_get_configuration(void)
{
Usb_ack_setup_received_free();
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 8, usb_configuration_nb);
Usb_ack_control_in_ready_send();
while (!Is_usb_control_out_received());
Usb_ack_control_out_received_free();
}
void audio_micro_get_vol_res(void)
{
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 16, Usb_format_mcu_to_usb_data(16, MICRO_VOL_RES));
Usb_ack_control_in_ready_send();
while(!Is_usb_control_out_received()) // send a ZLP
{
TASKS_SCHEDULE();
}
Usb_ack_control_out_received_free();
}
void adc_sample_sent_cb(void)
{
uint32_t i;
uint8_t old_mic_buf_id=mic_buf_id;
if (!b_microphone_pause && Is_usb_write_enabled(EP_AUDIO_IN) && audio_mixer_dacs_input(NULL, 0) ) // Endpoint buffer free ?
{
mic_frame_id++;
if( mic_frame_id>=10 )
{
mic_frame_id=0;
microphone[mic_buf_id].size = 45;
}
else
microphone[mic_buf_id].size = 44;
Usb_reset_endpoint_fifo_access(EP_AUDIO_IN);
if(!mute)
{
for(i = 0; i < microphone[old_mic_buf_id].size; i++)
{
Usb_write_endpoint_data(EP_AUDIO_IN, 8, LSB(microphone[old_mic_buf_id].buffer[2 * i]));
Usb_write_endpoint_data(EP_AUDIO_IN, 8, MSB(microphone[old_mic_buf_id].buffer[2 * i]));
}
}
else
{
for(i = 0; i < 2*microphone[old_mic_buf_id].size; i++)
{
Usb_write_endpoint_data(EP_AUDIO_IN, 8, 0);
}
}
Usb_ack_in_ready_send(EP_AUDIO_IN);
audio_mixer_dacs_input(microphone[mic_buf_id].buffer, 45/*microphone[mic_buf_id].size*/);
// Let's switch to the next buffer.
mic_buf_id^=1;
}
else
b_microphone_started=false;
}
//! This function manages the GET STATUS request. The device, interface or
//! endpoint status is returned.
//!
void usb_get_status(void)
{
U8 wIndex;
switch (bmRequestType)
{
case REQUEST_DEVICE_STATUS:
Usb_ack_setup_received_free();
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 8, device_status);
break;
case REQUEST_INTERFACE_STATUS:
Usb_ack_setup_received_free();
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 8, INTERFACE_STATUS);
break;
case REQUEST_ENDPOINT_STATUS:
Usb_read_endpoint_data(EP_CONTROL, 16); //!< dummy read (wValue)
wIndex = Usb_read_endpoint_data(EP_CONTROL, 8);
wIndex = Get_desc_ep_nbr(wIndex);
Usb_ack_setup_received_free();
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 8, Is_usb_endpoint_stall_requested(wIndex) );
break;
default:
Usb_enable_stall_handshake(EP_CONTROL);
Usb_ack_setup_received_free();
return;
}
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_ack_control_in_ready_send();
while (!Is_usb_control_out_received());
Usb_ack_control_out_received_free();
}
void device_mouse_hid_task(void)
#endif
{
#ifdef FREERTOS_USED
portTickType xLastWakeTime;
xLastWakeTime = xTaskGetTickCount();
while (true)
{
vTaskDelayUntil(&xLastWakeTime, configTSK_USB_DHID_MOUSE_PERIOD);
// First, check the device enumeration state
if (!Is_device_enumerated()) continue;
#else
// First, check the device enumeration state
if (!Is_device_enumerated()) return;
#endif // FREERTOS_USED
if( is_usb_mouse_event() )
{
if( Is_usb_in_ready(EP_HID_MOUSE_IN) )
{
Usb_reset_endpoint_fifo_access(EP_HID_MOUSE_IN);
//! Write report
Usb_write_endpoint_data(EP_HID_MOUSE_IN, 8, u8_report_buttons);
Usb_write_endpoint_data(EP_HID_MOUSE_IN, 8, u8_report_disp_x);
Usb_write_endpoint_data(EP_HID_MOUSE_IN, 8, u8_report_disp_y);
Usb_write_endpoint_data(EP_HID_MOUSE_IN, 8, u8_report_disp_wheel);
Usb_ack_in_ready_send(EP_HID_MOUSE_IN);
}
}
#ifdef FREERTOS_USED
}
#endif
}
//!
//! @brief Entry point of the device HID task management
//!
void device_hid_task(void)
{
// First, check the device enumeration state
if (!Is_device_enumerated()) {
return;
}
if (Is_usb_in_ready(EP_KBD_IN)) {
if (is_usb_hid_event()) {
Usb_reset_endpoint_fifo_access(EP_KBD_IN);
//! Write report
Usb_write_endpoint_data(EP_KBD_IN, 8, key);
Usb_ack_in_ready_send(EP_KBD_IN);
}
}
}
//! @brief This function manages hid get idle request.
//!
//! @param u8_report_id 0 the idle rate applies to all input reports, else only applies to the Report ID
//!
void usb_hid_get_idle (U8 u8_report_id)
{
U16 wLength;
U16 wInterface;
// Get interface number to put in idle mode
wInterface=Usb_read_endpoint_data(EP_CONTROL, 16);
wLength =Usb_read_endpoint_data(EP_CONTROL, 16);
Usb_ack_setup_received_free();
if( (wLength != 0) && (wInterface == INTERFACE_NB) )
{
Usb_write_endpoint_data(EP_CONTROL, 8, g_u8_report_rate);
Usb_ack_control_in_ready_send();
}
while (!Is_usb_control_out_received());
Usb_ack_control_out_received_free();
}
//! @brief This function manages hid get idle request.
//!
//! @param u8_report_id 0 the idle rate applies to all input reports, else only applies to the Report ID
//!
static void usb_hid_get_idle (uint8_t u8_report_id)
{
uint16_t wLength;
uint16_t wInterface;
// Get interface number to put in idle mode
wInterface=usb_format_usb_to_mcu_data(16, Usb_read_endpoint_data(EP_CONTROL, 16));
wLength =usb_format_usb_to_mcu_data(16, Usb_read_endpoint_data(EP_CONTROL, 16));
Usb_ack_setup_received_free();
if( (wLength != 0) && (wInterface == INTERFACE_NB_KBD) )
{
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 8, g_u8_report_rate);
Usb_ack_control_in_ready_send();
}
while (!Is_usb_control_out_received());
Usb_ack_control_out_received_free();
}
void cdc_get_line_coding(void)
{
Usb_ack_setup_received_free();
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 8, LSB0(line_coding.dwDTERate));
Usb_write_endpoint_data(EP_CONTROL, 8, LSB1(line_coding.dwDTERate));
Usb_write_endpoint_data(EP_CONTROL, 8, LSB2(line_coding.dwDTERate));
Usb_write_endpoint_data(EP_CONTROL, 8, LSB3(line_coding.dwDTERate));
Usb_write_endpoint_data(EP_CONTROL, 8, line_coding.bCharFormat);
Usb_write_endpoint_data(EP_CONTROL, 8, line_coding.bParityType);
Usb_write_endpoint_data(EP_CONTROL, 8, line_coding.bDataBits );
Usb_ack_control_in_ready_send();
while (!Is_usb_control_in_ready());
while(!Is_usb_control_out_received());
Usb_ack_control_out_received_free();
}
static void send_informational_exceptions_page (void)
{
// Page Code: Informational Exceptions Control mode page.
Usb_write_endpoint_data (g_scsi_ep_ms_in, 8, SBC_PAGE_CODE_INFORMATIONAL_EXCEPTIONS);
// Page Length.
Usb_write_endpoint_data (g_scsi_ep_ms_in, 8, SBC_PAGE_LENGTH_INFORMATIONAL_EXCEPTIONS);
// ..., test bit = 0, ...
Usb_write_endpoint_data (g_scsi_ep_ms_in, 8, 0x00);
// MRIE = 0x05.
Usb_write_endpoint_data (g_scsi_ep_ms_in, 8, SBC_MRIE_GENERATE_NO_SENSE);
// Interval Timer.
Usb_write_endpoint_data (g_scsi_ep_ms_in, 32, Sbc_format_mcu_to_scsi_data (32, 0x00000000));
// Report Count.
Usb_write_endpoint_data (g_scsi_ep_ms_in, 32, Sbc_format_mcu_to_scsi_data (32, 0x00000001));
}
void USB_CCID_send_INT_Message (void)
{
unsigned short Message_u16;
int i, i1;
/* todo while (Is_usb_endpoint_stall_requested(EP_CCID_IN)) { if (Is_usb_setup_received()) usb_process_request(); }
while (Is_usb_endpoint_stall_requested(EP_CCID_OUT)) { if (Is_usb_setup_received()) usb_process_request(); }
// MSC Compliance - Free BAD out receive during SCSI command while( Is_usb_out_received(EP_CCID_OUT) ) {
Usb_ack_out_received_free(EP_CCID_OUT); } */
while (!Is_usb_in_ready (EP_CCID_INT));
Usb_reset_endpoint_fifo_access (EP_CCID_INT);
Message_u16 = 0x5003;
i = Usb_byte_count (EP_CCID_INT);
Usb_write_endpoint_data (EP_CCID_INT, 16, Message_u16);
i1 = Usb_byte_count (EP_CCID_INT);
Usb_ack_in_ready_send (EP_CCID_INT);
// MSC Compliance - Wait end of all transmitions on USB line
for (i = 0; i < 100; i++)
{
if (0 != Usb_nb_busy_bank (EP_CCID_INT))
{
if (Is_usb_setup_received ())
usb_process_request ();
}
else
{
break;
}
}
}
//! This function manages the SETUP_GET_INTERFACE request.
//!
bool usb_get_interface (void)
{
U16 wInterface;
U16 wValue;
// Read wValue
wValue = usb_format_usb_to_mcu_data(16, Usb_read_endpoint_data(EP_CONTROL, 16));
// wValue = Alternate Setting
// wIndex = Interface
wInterface=usb_format_usb_to_mcu_data(16, Usb_read_endpoint_data(EP_CONTROL, 16));
if(0!=wValue)
return false;
Usb_ack_setup_received_free();
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 8, usb_interface_status[wInterface] );
Usb_ack_control_in_ready_send();
while( !Is_usb_control_out_received() );
Usb_ack_control_out_received_free();
return true;
}
static void send_read_write_error_recovery_page (U8 length)
{
Usb_write_endpoint_data (g_scsi_ep_ms_in, 8, SBC_PAGE_CODE_READ_WRITE_ERROR_RECOVERY);
// Page Length.
Usb_write_endpoint_data (g_scsi_ep_ms_in, 8, SBC_PAGE_LENGTH_READ_WRITE_ERROR_RECOVERY);
Usb_write_endpoint_data (g_scsi_ep_ms_in, 8, 0x80);
Usb_write_endpoint_data (g_scsi_ep_ms_in, 8, SBC_READ_RETRY_COUNT);
Usb_write_endpoint_data (g_scsi_ep_ms_in, 8, 0x00);
Usb_write_endpoint_data (g_scsi_ep_ms_in, 8, 0x00);
Usb_write_endpoint_data (g_scsi_ep_ms_in, 8, 0x00);
// Reserved.
Usb_write_endpoint_data (g_scsi_ep_ms_in, 8, 0x00);
if (length > 12)
{
Usb_write_endpoint_data (g_scsi_ep_ms_in, 8, SBC_WRITE_RETRY_COUNT);
Usb_write_endpoint_data (g_scsi_ep_ms_in, 8, 0x00);
Usb_write_endpoint_data (g_scsi_ep_ms_in, 16, Sbc_format_mcu_to_scsi_data (16, SBC_RECOVERY_TIME_LIMIT));
}
}
//! This function is called by the standard USB read request function when
//! the USB request is not supported. This function returns TRUE when the
//! request is processed. This function returns FALSE if the request is not
//! supported. In this case, a STALL handshake will be automatically
//! sent by the standard USB read request function.
//!
Bool uac2_user_read_request(U8 type, U8 request)
{ int i;
// Read wValue
// why are these file statics?
wValue_lsb = Usb_read_endpoint_data(EP_CONTROL, 8);
wValue_msb = Usb_read_endpoint_data(EP_CONTROL, 8);
wIndex = usb_format_usb_to_mcu_data(16, Usb_read_endpoint_data(EP_CONTROL, 16));
wLength = usb_format_usb_to_mcu_data(16, Usb_read_endpoint_data(EP_CONTROL, 16));
if (type == IN_CL_INTERFACE || type == OUT_CL_INTERFACE){ // process Class Specific Interface
// request for AUDIO interfaces
if (wIndex == DSC_INTERFACE_AS){ // Audio Streaming Interface
if (type == IN_CL_INTERFACE){ // get controls
if (wValue_msb == AUDIO_AS_VAL_ALT_SETTINGS && wValue_lsb == 0
&& request == AUDIO_CS_REQUEST_CUR){
Usb_ack_setup_received_free();
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x01);
Usb_write_endpoint_data(EP_CONTROL, 8, 0b00000011); // alt 0 and 1 valid
Usb_ack_control_in_ready_send();
while (!Is_usb_control_out_received());
Usb_ack_control_out_received_free();
return TRUE;
} else if (wValue_msb == AUDIO_AS_ACT_ALT_SETTINGS && wValue_lsb == 0
&& request == AUDIO_CS_REQUEST_CUR){
Usb_ack_setup_received_free();
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 8, usb_alternate_setting);
Usb_ack_control_in_ready_send();
while (!Is_usb_control_out_received());
Usb_ack_control_out_received_free();
return TRUE;
} else if (wValue_msb == AUDIO_AS_AUDIO_DATA_FORMAT && wValue_lsb == 0
&& request == AUDIO_CS_REQUEST_CUR){
Usb_ack_setup_received_free();
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x01);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00); // only PCM format
Usb_ack_control_in_ready_send();
while (!Is_usb_control_out_received());
Usb_ack_control_out_received_free();
return TRUE;
} else return FALSE;
} else if (type == OUT_CL_INTERFACE){ // set controls
if (wValue_msb == AUDIO_AS_ACT_ALT_SETTINGS
&& request == AUDIO_CS_REQUEST_CUR){
Usb_ack_setup_received_free();
while (!Is_usb_control_out_received());
Usb_reset_endpoint_fifo_access(EP_CONTROL);
usb_alternate_setting = Usb_read_endpoint_data(EP_CONTROL, 8);
usb_alternate_setting_changed = TRUE;
Usb_ack_control_out_received_free();
Usb_ack_control_in_ready_send(); //!< send a ZLP for STATUS phase
while (!Is_usb_control_in_ready()); //!< waits for status phase done
return FALSE;
}
} // end OUT_CL_INTERFACE
} // end DSC_INTERFACE_AS
if (wIndex == DSC_INTERFACE_AS_OUT){ // Playback Audio Streaming Interface
if (type == IN_CL_INTERFACE){ // get controls
if (wValue_msb == AUDIO_AS_VAL_ALT_SETTINGS && wValue_lsb == 0
&& request == AUDIO_CS_REQUEST_CUR){
Usb_ack_setup_received_free();
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x01);
Usb_write_endpoint_data(EP_CONTROL, 8, 0b00000011); // alt 0 and 1 valid
Usb_ack_control_in_ready_send();
while (!Is_usb_control_out_received());
Usb_ack_control_out_received_free();
return TRUE;
} else if (wValue_msb == AUDIO_AS_ACT_ALT_SETTINGS && wValue_lsb == 0
&& request == AUDIO_CS_REQUEST_CUR){
Usb_ack_setup_received_free();
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 8, usb_alternate_setting_out);
Usb_ack_control_in_ready_send();
while (!Is_usb_control_out_received());
Usb_ack_control_out_received_free();
return TRUE;
} else if (wValue_msb == AUDIO_AS_AUDIO_DATA_FORMAT && wValue_lsb == 0
&& request == AUDIO_CS_REQUEST_CUR){
Usb_ack_setup_received_free();
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x01);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00); // only PCM format
Usb_ack_control_in_ready_send();
while (!Is_usb_control_out_received());
Usb_ack_control_out_received_free();
return TRUE;
} else return FALSE;
} else if (type == OUT_CL_INTERFACE){ // set controls
if (wValue_msb == AUDIO_AS_ACT_ALT_SETTINGS
&& request == AUDIO_CS_REQUEST_CUR){
Usb_ack_setup_received_free();
while (!Is_usb_control_out_received());
Usb_reset_endpoint_fifo_access(EP_CONTROL);
usb_alternate_setting_out = Usb_read_endpoint_data(EP_CONTROL, 8);
usb_alternate_setting_out_changed = TRUE;
Usb_ack_control_out_received_free();
Usb_ack_control_in_ready_send(); //!< send a ZLP for STATUS phase
while (!Is_usb_control_in_ready()); //!< waits for status phase done
return FALSE;
}
} // end OUT_CL_INTERFACE
} // end DSC_INTERFACE_AS_OUT
if ( (wIndex % 256) == DSC_INTERFACE_AUDIO){// low byte wIndex is Interface number
// high byte is for EntityID
if (type == IN_CL_INTERFACE){ // get controls
switch (wIndex /256){
case CSD_ID_1:
if (wValue_msb == AUDIO_CS_CONTROL_SAM_FREQ && wValue_lsb == 0
&& request == AUDIO_CS_REQUEST_CUR){
Usb_ack_setup_received_free();
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 8, current_freq.freq_bytes[3]); // 0x0000bb80 is 48khz
Usb_write_endpoint_data(EP_CONTROL, 8, current_freq.freq_bytes[2]); // 0x00017700 is 96khz
Usb_write_endpoint_data(EP_CONTROL, 8, current_freq.freq_bytes[1]); // 0x0002ee00 is 192khz
Usb_write_endpoint_data(EP_CONTROL, 8, current_freq.freq_bytes[0]);
Usb_ack_control_in_ready_send();
while (!Is_usb_control_out_received());
Usb_ack_control_out_received_free();
return TRUE;
}
else if (wValue_msb == AUDIO_CS_CONTROL_CLOCK_VALID && wValue_lsb == 0
&& request == AUDIO_CS_REQUEST_CUR){
Usb_ack_setup_received_free();
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 8, TRUE); // always valid
// temp hack to give total # of bytes requested
for (i = 0; i < (wLength - 1); i++)
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_ack_control_in_ready_send();
while (!Is_usb_control_out_received());
Usb_ack_control_out_received_free();
return TRUE;
}
else if (wValue_msb == AUDIO_CS_CONTROL_SAM_FREQ && wValue_lsb == 0
&& request == AUDIO_CS_REQUEST_RANGE){
Usb_ack_setup_received_free();
Usb_reset_endpoint_fifo_access(EP_CONTROL);
// give total # of bytes requested
for (i = 0; i < (wLength); i++){
if (FEATURE_DAC_ES9022)
Usb_write_endpoint_data(EP_CONTROL, 8, Speedx_1[i]);
else Usb_write_endpoint_data(EP_CONTROL, 8, Speedx_2[i]);
}
Usb_ack_control_in_ready_send();
while (!Is_usb_control_out_received());
Usb_ack_control_out_received_free();
return TRUE;
} else return FALSE;
case CSD_ID_2:
if (wValue_msb == AUDIO_CS_CONTROL_SAM_FREQ && wValue_lsb == 0
&& request == AUDIO_CS_REQUEST_CUR){
Usb_ack_setup_received_free();
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 8, current_freq.freq_bytes[3]); // 0x0000bb80 is 48khz
Usb_write_endpoint_data(EP_CONTROL, 8, current_freq.freq_bytes[2]); // 0x00017700 is 96khz
Usb_write_endpoint_data(EP_CONTROL, 8, current_freq.freq_bytes[1]); // 0x0002ee00 is 192khz
Usb_write_endpoint_data(EP_CONTROL, 8, current_freq.freq_bytes[0]);
Usb_ack_control_in_ready_send();
while (!Is_usb_control_out_received());
Usb_ack_control_out_received_free();
return TRUE;
}
else if (wValue_msb == AUDIO_CS_CONTROL_CLOCK_VALID && wValue_lsb == 0
&& request == AUDIO_CS_REQUEST_CUR){
Usb_ack_setup_received_free();
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 8, TRUE); // always valid
// temp hack to give total # of bytes requested
for (i = 0; i < (wLength - 1); i++)
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_ack_control_in_ready_send();
while (!Is_usb_control_out_received());
Usb_ack_control_out_received_free();
return TRUE;
}
else if (wValue_msb == AUDIO_CS_CONTROL_SAM_FREQ && wValue_lsb == 0
&& request == AUDIO_CS_REQUEST_RANGE){
Usb_ack_setup_received_free();
Usb_reset_endpoint_fifo_access(EP_CONTROL);
// give total # of bytes requested
for (i = 0; i < (wLength); i++)
Usb_write_endpoint_data(EP_CONTROL, 8, Speedx_2[i]);
// LED_Toggle(LED0);
Usb_ack_control_in_ready_send();
while (!Is_usb_control_out_received());
Usb_ack_control_out_received_free();
return TRUE;
} else return FALSE;
case CSX_ID:
if (wValue_msb == AUDIO_CX_CLOCK_SELECTOR && wValue_lsb == 0
&& request == AUDIO_CS_REQUEST_CUR){
Usb_ack_setup_received_free();
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 8, clock_selected);
// temp hack to give total # of bytes requested
for (i = 0; i < (wLength - 1); i++)
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_ack_control_in_ready_send();
while (!Is_usb_control_out_received());
Usb_ack_control_out_received_free();
return TRUE;
} else return FALSE;
case MIC_FEATURE_UNIT_ID:
if (wValue_msb == AUDIO_FU_CONTROL_CS_MUTE
&& request == AUDIO_CS_REQUEST_CUR){
Usb_ack_setup_received_free();
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 8, mute);
// temp hack to give total # of bytes requested
for (i = 0; i < (wLength - 1); i++)
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_ack_control_in_ready_send();
while (!Is_usb_control_out_received());
Usb_ack_control_out_received_free();
return TRUE;
} else return FALSE;
case SPK_FEATURE_UNIT_ID:
if (wValue_msb == AUDIO_FU_CONTROL_CS_MUTE
&& request == AUDIO_CS_REQUEST_CUR){
Usb_ack_setup_received_free();
Usb_reset_endpoint_fifo_access(EP_CONTROL);
Usb_write_endpoint_data(EP_CONTROL, 8, spk_mute);
// temp hack to give total # of bytes requested
for (i = 0; i < (wLength - 1); i++)
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_ack_control_in_ready_send();
while (!Is_usb_control_out_received());
Usb_ack_control_out_received_free();
return TRUE;
} else return FALSE;
case INPUT_TERMINAL_ID:
if (wValue_msb == AUDIO_TE_CONTROL_CS_CLUSTER && wValue_lsb == 0
&& request == AUDIO_CS_REQUEST_CUR){
Usb_ack_setup_received_free();
Usb_reset_endpoint_fifo_access(EP_CONTROL);
if (usb_alternate_setting == 1) {
Usb_write_endpoint_data(EP_CONTROL, 8, INPUT_TERMINAL_NB_CHANNELS);
Usb_write_endpoint_data(EP_CONTROL, 8, (U8) INPUT_TERMINAL_CHANNEL_CONF);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_write_endpoint_data(EP_CONTROL, 8, INPUT_TERMINAL_STRING_DESC);
}
else { // zero's at startup alt setting 0
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
};
Usb_ack_control_in_ready_send();
while (!Is_usb_control_out_received());
Usb_ack_control_out_received_free();
return TRUE;
} else return FALSE;
case SPK_INPUT_TERMINAL_ID:
if (wValue_msb == AUDIO_TE_CONTROL_CS_CLUSTER && wValue_lsb == 0
&& request == AUDIO_CS_REQUEST_CUR){
Usb_ack_setup_received_free();
Usb_reset_endpoint_fifo_access(EP_CONTROL);
if (usb_alternate_setting_out == 1) {
Usb_write_endpoint_data(EP_CONTROL, 8, SPK_INPUT_TERMINAL_NB_CHANNELS);
Usb_write_endpoint_data(EP_CONTROL, 8, (U8) SPK_INPUT_TERMINAL_CHANNEL_CONF);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_write_endpoint_data(EP_CONTROL, 8, INPUT_TERMINAL_STRING_DESC);
}
else { // zero's at startup alt setting 0
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
Usb_write_endpoint_data(EP_CONTROL, 8, 0x00);
};
Usb_ack_control_in_ready_send();
while (!Is_usb_control_out_received());
Usb_ack_control_out_received_free();
return TRUE;
} else return FALSE;
default:
return FALSE;
} // end switch EntityID
} else if (type == OUT_CL_INTERFACE){ // set controls
switch (wIndex /256){
case CSD_ID_1: // set CUR freq
case CSD_ID_2:
if (wValue_msb == AUDIO_CS_CONTROL_SAM_FREQ && wValue_lsb == 0
&& request == AUDIO_CS_REQUEST_CUR){
Usb_ack_setup_received_free();
while (!Is_usb_control_out_received());
Usb_reset_endpoint_fifo_access(EP_CONTROL);
current_freq.freq_bytes[3]=Usb_read_endpoint_data(EP_CONTROL, 8); // read 4 bytes freq to set
current_freq.freq_bytes[2]=Usb_read_endpoint_data(EP_CONTROL, 8);
current_freq.freq_bytes[1]=Usb_read_endpoint_data(EP_CONTROL, 8);
current_freq.freq_bytes[0]=Usb_read_endpoint_data(EP_CONTROL, 8);
freq_changed = TRUE;
Usb_ack_control_out_received_free();
Usb_ack_control_in_ready_send(); //!< send a ZLP for STATUS phase
while (!Is_usb_control_in_ready()); //!< waits for status phase done
return TRUE;
}
else return FALSE;
case CSX_ID:
if (wValue_msb == AUDIO_CX_CLOCK_SELECTOR && wValue_lsb == 0
&& request == AUDIO_CS_REQUEST_CUR){
Usb_ack_setup_received_free();
while (!Is_usb_control_out_received());
Usb_reset_endpoint_fifo_access(EP_CONTROL);
clock_selected = Usb_read_endpoint_data(EP_CONTROL, 8);
clock_changed = TRUE;
Usb_ack_control_out_received_free();
Usb_ack_control_in_ready_send(); //!< send a ZLP for STATUS phase
while (!Is_usb_control_in_ready()); //!< waits for status phase done
if (clock_selected < 1 || clock_selected > CSX_INPUT_PINS)
clock_selected = 1;
return TRUE;
} else return FALSE;
case MIC_FEATURE_UNIT_ID:
if (wValue_msb == AUDIO_FU_CONTROL_CS_MUTE
&& request == AUDIO_CS_REQUEST_CUR){
Usb_ack_setup_received_free();
while (!Is_usb_control_out_received());
Usb_reset_endpoint_fifo_access(EP_CONTROL);
mute = Usb_read_endpoint_data(EP_CONTROL, 8);
Usb_ack_control_out_received_free();
Usb_ack_control_in_ready_send(); //!< send a ZLP for STATUS phase
while (!Is_usb_control_in_ready()); //!< waits for status phase done
return TRUE;
} else return FALSE;
case SPK_FEATURE_UNIT_ID:
if (wValue_msb == AUDIO_FU_CONTROL_CS_MUTE
&& request == AUDIO_CS_REQUEST_CUR){
Usb_ack_setup_received_free();
while (!Is_usb_control_out_received());
Usb_reset_endpoint_fifo_access(EP_CONTROL);
spk_mute = Usb_read_endpoint_data(EP_CONTROL, 8);
Usb_ack_control_out_received_free();
Usb_ack_control_in_ready_send(); //!< send a ZLP for STATUS phase
while (!Is_usb_control_in_ready()); //!< waits for status phase done
return TRUE;
} else return FALSE;
default:
return FALSE;
}
} // end OUT_CL_INTERFACE
} // end Audio Control Interface
} // end CL_INTERFACE
return FALSE; // No supported request
}
// !
// ! @brief USB Command Status Wrapper (CSW) management
// !
// ! This function sends the status in relation with the last CBW.
// !
static void usb_mass_storage_csw (void)
{
int i;
/*
i = 1; while (1 == i) { i = 0; if (Is_usb_endpoint_stall_requested(EP_MS_IN)) { i = 1; if (Is_usb_setup_received()) { usb_process_request(); }
}
if (Is_usb_endpoint_stall_requested(EP_MS_OUT)) { i = 1; if (Is_usb_setup_received()) { usb_process_request(); } } } */
while (Is_usb_endpoint_stall_requested (EP_MS_IN))
{
if (Is_usb_setup_received ())
usb_process_request ();
}
while (Is_usb_endpoint_stall_requested (EP_MS_OUT))
{
if (Is_usb_setup_received ())
usb_process_request ();
}
// MSC Compliance - Free BAD out receiv during SCSI command
while (Is_usb_out_received (EP_MS_OUT))
{
Usb_ack_out_received_free (EP_MS_OUT);
}
while (!Is_usb_in_ready (EP_MS_IN));
/*
// for (i=0;i<100000;i++) // Make break out { if (Is_usb_in_ready(EP_MS_IN)) { break; } } */
Usb_reset_endpoint_fifo_access (EP_MS_IN);
// ! Write CSW Signature
Usb_write_endpoint_data (EP_MS_IN, 32, *(U32 *) & "USBS");
// ! Write stored CBW Tag
Usb_write_endpoint_data (EP_MS_IN, 32, dCBWTag);
// ! Write data residual value
Usb_write_endpoint_data (EP_MS_IN, 32, usb_format_mcu_to_usb_data (32, g_scsi_data_remaining));
// ! Write command status
Usb_write_endpoint_data (EP_MS_IN, 8, g_scsi_status);
Usb_ack_in_ready_send (EP_MS_IN);
// MSC Compliance - Wait end of all transmitions on USB line
for (i = 0; i < 1000; i++)
{
if (0 != Usb_nb_busy_bank (EP_MS_IN))
{
if (Is_usb_setup_received ())
usb_process_request ();
}
else
{
break;
}
}
/*
while( 0 != Usb_nb_busy_bank(EP_MS_IN) ) { if (Is_usb_setup_received()) usb_process_request(); } */
}
static void usb_mass_storage_csw(void)
{
volatile U32 timeoutTickCount = g_lifetimeHalfSecondTickCount + 6;
while (Is_usb_endpoint_stall_requested(EP_MS_IN))
{
if (!Is_usb_endpoint_enabled(g_scsi_ep_ms_in)) { return; } // USB Reset
if ((volatile U32)timeoutTickCount == (volatile U32)g_lifetimeHalfSecondTickCount) { return; }
if (Is_usb_setup_received())
{
usb_process_request();
timeoutTickCount = (volatile U32)g_lifetimeHalfSecondTickCount + 6;
}
}
timeoutTickCount = (volatile U32)g_lifetimeHalfSecondTickCount + 6;
while (Is_usb_endpoint_stall_requested(EP_MS_OUT))
{
if (!Is_usb_endpoint_enabled(g_scsi_ep_ms_in)) { return; } // USB Reset
if ((volatile U32)timeoutTickCount == (volatile U32)g_lifetimeHalfSecondTickCount) { return; }
if (Is_usb_setup_received())
{
usb_process_request();
timeoutTickCount = (volatile U32)g_lifetimeHalfSecondTickCount + 6;
}
}
// MSC Compliance - Free BAD out receive during SCSI command
while( Is_usb_out_received(EP_MS_OUT) ) {
Usb_ack_out_received_free(EP_MS_OUT);
}
timeoutTickCount = (volatile U32)g_lifetimeHalfSecondTickCount + 6;
while (!Is_usb_in_ready(EP_MS_IN))
{
if (!Is_usb_endpoint_enabled(g_scsi_ep_ms_in)) { return; } // USB Reset
if ((volatile U32)timeoutTickCount == (volatile U32)g_lifetimeHalfSecondTickCount) { return; }
}
Usb_reset_endpoint_fifo_access(EP_MS_IN);
//! Write CSW Signature
Usb_write_endpoint_data(EP_MS_IN, 32, *(uint32_t *)&"USBS");
//! Write stored CBW Tag
Usb_write_endpoint_data(EP_MS_IN, 32, dCBWTag);
//! Write data residual value
Usb_write_endpoint_data(EP_MS_IN, 32,
usb_format_mcu_to_usb_data(32, g_scsi_data_remaining));
//! Write command status
Usb_write_endpoint_data(EP_MS_IN, 8, g_scsi_status);
Usb_ack_in_ready_send(EP_MS_IN);
// MSC Compliance - Wait end of all transmissions on USB line
while( 0 != Usb_nb_busy_bank(EP_MS_IN) )
{
if (Is_usb_setup_received()) usb_process_request();
}
}
void device_audio_task(void)
#endif
{
#if( BOARD!=EVK1105) || (DEFAULT_DACS!=AUDIO_MIXER_DAC_AIC23B)
uint32_t i;
#endif
uint32_t fifo_cnt;
int stream_status;
#ifdef FREERTOS_USED
portTickType xLastWakeTime;
xLastWakeTime = xTaskGetTickCount();
LED_On(LED0);
while (true)
{
vTaskDelayUntil(&xLastWakeTime, configTSK_USB_DAUDIO_PERIOD);
// First, check the device enumeration state
if (!Is_device_enumerated()) { mmi_state=0; continue; }
#else
// First, check the device enumeration state
if (!Is_device_enumerated()) { mmi_state=0; return; }
#endif // FREERTOS_USED
mmi_display();
#if( BOARD!=EVK1105) || (DEFAULT_DACS!=AUDIO_MIXER_DAC_AIC23B)
// Microphone emulation
//
if ( is_joystick_pressed() )
{
if (Is_usb_write_enabled(EP_AUDIO_IN)) // Endpoint buffer free ?
{
Usb_reset_endpoint_fifo_access(EP_AUDIO_IN);
for( i=0 ; i<EP_SIZE_IN ; i++ ) // Fill endpoint with sample raw
{
if(mute==false)
{
uint8_t sample;
sample = sample_sound[dat_sample_index++];
LED_Set_Intensity(LED0, sample);
Usb_write_endpoint_data(EP_AUDIO_IN, 8, sample);
if (dat_sample_index >= SAMPLE_SOUND_LEN)
{ dat_sample_index=0; }
}
else
{
LED_Set_Intensity(LED0, 0);
Usb_write_endpoint_data(EP_AUDIO_IN, 8, 0x00);
}
}
Usb_ack_in_ready_send(EP_AUDIO_IN);
}
}
#else
// Handle input stream from microphone
if( !b_microphone_started && (Is_usb_write_enabled(EP_AUDIO_IN)) && audio_mixer_dacs_input(NULL, 0) )
{
// Start ADC conversion. This will launch the IRL in background...
mic_buf_id = 0;
mic_frame_id=2;
microphone[mic_buf_id].size=45;
audio_mixer_dacs_input(microphone[0].buffer, 45 /*microphone[mic_buf_id].size*/);
audio_mixer_dacs_input(microphone[1].buffer, 45 /*microphone[mic_buf_id].size*/);
b_microphone_started=true;
}
#endif
// Handle incoming audio samples
//
if((Is_usb_out_received(EP_AUDIO_OUT) )
/*&& (Is_usb_stall(EP_AUDIO_OUT)==false)*/)
{
stream_status = usb_stream_input(USB_STREAM_DEVICE, EP_AUDIO_OUT, &fifo_cnt);
Usb_ack_out_received_free(EP_AUDIO_OUT);
mmi_activity_display(false, fifo_cnt);
}
#if USB_RESYNC_AUDIO_STREAM && (USB_RESYNC_AUDIO_STREAM==true)
usb_stream_resync();
#endif
#ifdef FREERTOS_USED
}
#endif
}
