/* This function is only used for retrive exception log*/
static kal_uint8 USB2UART_GetUARTByte(UART_PORT port)
{
kal_uint32 real_count = 0;
kal_uint32 RoomLeft = 0;
kal_uint8 data;
/* This function can only be called after exception*/
if(INT_Exception_Enter == 0)
ASSERT(0);
if ((gUsbDevice.device_type != USB_CDC_ACM)||(USB2UARTPort.initialized == KAL_FALSE))
{
/* This function should only be called when assertion, if not CDC_ACM type, trap in while loop*/
while(1);
}
Buf_GetBytesAvail(&(USB2UARTPort.Rx_Buffer),real_count);
while(real_count==0)
{
/* polling received data*/
USB2UART_Polling_Recv_Data();
Buf_GetBytesAvail(&(USB2UARTPort.Rx_Buffer),real_count);
}
Buf_Pop(&(USB2UARTPort.Rx_Buffer),data); /* one byte at a time */
/* set unmask flag if room left is larger than USB_EP_BULK_MAXP */
Buf_GetRoomLeft(&(USB2UARTPort.Rx_Buffer),RoomLeft);
/* only unmask IRQ if ring buffer romm left >= MAX BULK PKt SIZE */
#ifdef USB_20_ENABLE
if(USB_Is_High_Speed() == KAL_TRUE)
{
if(RoomLeft >= USB_EP_BULK_MAXP_HS)
{
USB_Set_UnMask_Irq(KAL_TRUE);
}
}
else
{
if(RoomLeft >= USB_EP_BULK_MAXP_FS)
{
USB_Set_UnMask_Irq(KAL_TRUE);
}
}
#else
if(RoomLeft >= USB_EP_BULK_MAXP)
{
USB_Set_UnMask_Irq(KAL_TRUE);
}
#endif
return data;
}
/* data interface speed reset function, enable EP's speed-specific descriptor */
void USB_Acm_DataIf_Speed_Reset(kal_bool b_other_speed)
{
#ifdef USB_20_ENABLE
if(USB_Is_High_Speed() == KAL_TRUE)
{
if(b_other_speed == KAL_FALSE)
{
g_UsbACM.data_ep_in_info->epdesc.stdep.wMaxPacketSize[0] = USB_EP_BULK_MAXP_HS&0xff;
g_UsbACM.data_ep_in_info->epdesc.stdep.wMaxPacketSize[1] = (USB_EP_BULK_MAXP_HS>>8)&0xff;
g_UsbACM.data_ep_out_info->epdesc.stdep.wMaxPacketSize[0] = USB_EP_BULK_MAXP_HS&0xff;
g_UsbACM.data_ep_out_info->epdesc.stdep.wMaxPacketSize[1] = (USB_EP_BULK_MAXP_HS>>8)&0xff;
}
else
{
/************************************************************
Bulk EP OUT handle functions (clear rx fifo data, read them out and drop)
*************************************************************/
void USB_Acm_Rx_ClrFifo(void)
{
kal_uint32 nCount;
#ifdef USB_20_ENABLE
kal_uint32 max_bulk_pkt_size;
kal_uint8 data[USB_EP_BULK_MAXP_HS];
#else
kal_uint8 data[USB_EP_BULK_MAXP];
#endif
/* check if data received */
nCount = USB_EP_Rx_Pkt_Len(g_UsbACM.rxpipe->byEP);
#ifdef USB_20_ENABLE
if(USB_Is_High_Speed() == KAL_TRUE)
max_bulk_pkt_size = USB_EP_BULK_MAXP_HS;
else
max_bulk_pkt_size = USB_EP_BULK_MAXP_FS;
#ifdef __PRODUCTION_RELEASE__
if(nCount > max_bulk_pkt_size)
{
nCount = max_bulk_pkt_size;
}
#else
EXT_ASSERT((nCount <= max_bulk_pkt_size), nCount, max_bulk_pkt_size, 0);
#endif
#else /* USB_20_ENABLE */
#ifdef __PRODUCTION_RELEASE__
if(nCount > USB_EP_BULK_MAXP)
{
nCount = USB_EP_BULK_MAXP;
}
#else
EXT_ASSERT((nCount <= USB_EP_BULK_MAXP), nCount, USB_EP_BULK_MAXP, 0);
#endif
#endif /* USB_20_ENABLE */
if(nCount>0)
{
/* get the data from fifo */
USB_EPFIFORead(g_UsbACM.rxpipe->byEP, nCount, data);
/* Clear RxPktRdy */
USB_EP_Bulk_Rx_Ready(g_UsbACM.rxpipe->byEP);
}
}
/* get bytes from rx buffer, parameter status shows escape and break status
return value is the actually get bytes */
static kal_uint16 USB2UART_GetBytes(UART_PORT port, kal_uint8 *buffaddr, kal_uint16 length,
kal_uint8 *status, module_type ownerid)
{
kal_uint16 real_count;
// kal_uint16 index;
kal_uint16 RoomLeft;
kal_uint32 savedMask;
kal_uint32 error_count;
kal_int32 remain;
BUFFER_INFO *rx_info = &(USB2UARTPort.Rx_Buffer);
if(ownerid != USB2UARTPort.ownerid)
{
#ifdef __PRODUCTION_RELEASE__
return 0;
#else /* __PRODUCTION_RELEASE__ */
EXT_ASSERT( 0, (kal_uint32) ownerid, USB2UARTPort.ownerid, 0);
#endif
}
/* return directly if not match condition */
if ( (gUsbDevice.device_type != USB_CDC_ACM) ||
(USB2UARTPort.initialized == KAL_FALSE) || (gUsbDevice.nDevState!=DEVSTATE_CONFIG))
return 0;
/* determine real data count */
/* Note that the area to determine send_Rxilm must also contain in critical section.
Otherwise if USB HISR activated before send_Rxilm setting as true,
this message will be lost */
savedMask = SaveAndSetIRQMask();
Buf_GetBytesAvail(rx_info, real_count);
if(real_count >= length)
{
real_count = length;
}
else
{
g_UsbACM.send_Rxilm = KAL_TRUE; /*After this time get byte, buffer will be empty */
}
RestoreIRQMask(savedMask);
#ifndef __PRODUCTION_RELEASE__
if(g_UsbACM.send_Rxilm == KAL_TRUE)
{
drv_trace1(TRACE_FUNC, USBACM_GET_BYTES_BUF_EMPTY, ownerid);
// kal_prompt_trace(MOD_USB, "RDY R %d", ownerid);
}
#endif
if(real_count != 0)
{
remain = (BRead(rx_info) + real_count) - BLength(rx_info);
if(remain < 0)
{
/* dest, src, len */
kal_mem_cpy(buffaddr, BuffRead(rx_info), real_count);
BRead(rx_info) += real_count;
}
else
{
kal_mem_cpy(buffaddr, BuffRead(rx_info), real_count-remain);
kal_mem_cpy((kal_uint8 *)(buffaddr+real_count-remain), BStartAddr(rx_info), remain);
BRead(rx_info) = remain;
}
}
/* pop data from ring buffer to caller buffer */
/*
for (index = 0; index < real_count; index++)
{
Buf_Pop(rx_info, *(buffaddr+index));
}
*/
/* update status */
if (status != NULL)
{
*status = 0;
if (USB2UARTPort.EscFound)
{
*status |= UART_STAT_EscDet;
USB2UARTPort.EscFound = KAL_FALSE;
}
if (USB2UARTPort.breakDet)
{
*status |= UART_STAT_Break;
USB2UARTPort.breakDet = KAL_FALSE;
}
}
IRQMask(IRQ_USB_CODE);
Buf_GetRoomLeft(rx_info, RoomLeft);
#ifdef USB_20_ENABLE
/* only unmask IRQ if ring buffer room left >= MAX BULK PKT SIZE */
if((USB_Is_High_Speed() == KAL_TRUE)&&(RoomLeft >= USB_EP_BULK_MAXP_HS)
||(USB_Is_High_Speed() == KAL_FALSE)&&(RoomLeft >= USB_EP_BULK_MAXP_FS))
{
error_count = USB_Get_HW_Error_Count();
if(error_count <= 8)
{
USB_Set_UnMask_Irq(KAL_TRUE);
IRQUnmask(IRQ_USB_CODE);
}
else
{
drv_trace0(TRACE_FUNC, USBACM_FAIL_NOT_UNMASK);
// kal_prompt_trace(MOD_USB, "UNMASK USB FAIL");
}
}
#else
/* only unmask IRQ if ring buffer room left >= 64 */
if(RoomLeft >= USB_EP_BULK_MAXP)
{
error_count = USB_Get_HW_Error_Count();
if(error_count <= 8)
{
USB_Set_UnMask_Irq(KAL_TRUE);
IRQUnmask(IRQ_USB_CODE);
}
else
{
drv_trace0(TRACE_FUNC, USBACM_FAIL_NOT_UNMASK);
// kal_prompt_trace(MOD_USB, "UNMASK USB FAIL");
}
}
#endif
#ifndef __PRODUCTION_RELEASE__
if(ownerid != USB2UARTPort.ownerid)
{
EXT_ASSERT( 0, (kal_uint32) ownerid, (kal_uint32)USB2UARTPort.ownerid, 0);
}
drv_trace1(TRACE_FUNC, USBACM_GET_BYTES, real_count);
// kal_prompt_trace(MOD_USB, "Get %d", real_count);
#endif /* __PRODUCTION_RELEASE__ */
return real_count;
}
static void USB2UART_CtrlDCD(UART_PORT port, IO_level SDCD, module_type ownerid)
{
kal_uint32 savedMask;
kal_bool b_set_intr;
kal_uint8 ep_num = 0;
#ifdef USB_20_ENABLE
kal_uint32 max_intr_pkt_size;
#endif
#ifndef __PRODUCTION_RELEASE__
USB_Dbg_Trace(USB_ACM_SEND_INTERRUPT, drv_get_current_time(), g_UsbACM.intr_state, 0);
if(ownerid != USB2UARTPort.ownerid)
{
EXT_ASSERT( 0, (kal_uint32) ownerid, USB2UARTPort.ownerid, 0);
}
#endif
savedMask = SaveAndSetIRQMask();
if((g_UsbACM.intr_state == ACM_INTR_IDLE)&&(gUsbDevice.is_configured_now == KAL_TRUE))
{
b_set_intr = KAL_TRUE;
g_UsbACM.is_intr_pending_pkt = KAL_FALSE;
ep_num = g_UsbACM.intrpipe->byEP;
}
else
{
b_set_intr = KAL_FALSE;
g_UsbACM.is_intr_pending_pkt = KAL_TRUE;
}
if(SDCD == io_high)
g_UsbACM.intr_pkt.Data = SERIAL_STATE_BRXCARRIER;
else if (SDCD == io_low)
g_UsbACM.intr_pkt.Data = 0x00;
else
ASSERT(0);
RestoreIRQMask(savedMask);
if(b_set_intr == KAL_TRUE)
{
#ifdef USB_20_ENABLE
if(USB_Is_High_Speed() == KAL_TRUE)
max_intr_pkt_size = USB_EP_INTR_MAXP_HS;
else
max_intr_pkt_size = USB_EP_INTR_MAXP_FS;
if(max_intr_pkt_size > sizeof(UsbAcm_Intr_Pkt))
#else
if(USB_EP_INTR_MAXP > sizeof(UsbAcm_Intr_Pkt))
#endif
{
g_UsbACM.intr_state = ACM_INTR_SEND_LAST_PKT;
#ifndef __PRODUCTION_RELEASE__
/* send only one short packet */
USB_Dbg_Trace(USB_ACM_SEND_INTERRUPT2, drv_get_current_time(), g_UsbACM.intr_state, 0);
drv_trace1(TRACE_FUNC, USBACM_INTR, g_UsbACM.intr_pkt.Data);
// kal_prompt_trace(MOD_USB, "ACM INTR %d", g_UsbACM.intr_pkt.Data);
#endif
USB_EPFIFOWrite(ep_num, sizeof(UsbAcm_Intr_Pkt), (kal_uint8 *)&g_UsbACM.intr_pkt);
USB_EP_Bulk_Tx_Ready(ep_num);
}
else
{
g_UsbACM.intr_state = ACM_INTR_SEND_ONE_PKT;
#ifndef __PRODUCTION_RELEASE__
/* send one max packet */
USB_Dbg_Trace(USB_ACM_SEND_INTERRUPT1, drv_get_current_time(), g_UsbACM.intr_state, 0);
drv_trace1(TRACE_FUNC, USBACM_INTR, g_UsbACM.intr_pkt.Data);
// kal_prompt_trace(MOD_USB, "ACM INTR %d", g_UsbACM.intr_pkt.Data);
#endif
#ifdef USB_20_ENABLE
USB_EPFIFOWrite(ep_num, max_intr_pkt_size, (kal_uint8 *)&g_UsbACM.intr_pkt);
#else
USB_EPFIFOWrite(ep_num, USB_EP_INTR_MAXP, (kal_uint8 *)&g_UsbACM.intr_pkt);
#endif
USB_EP_Bulk_Tx_Ready(ep_num);
}
}
}
