/* 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;
}
/*get the left bytes for tx buffer*/
static kal_uint16 USB2UART_GetTxRoomLeft(UART_PORT port)
{
kal_uint16 real_count;
kal_uint32 savedMask;
savedMask = SaveAndSetIRQMask();
Buf_GetRoomLeft(&(USB2UARTPort.Tx_Buffer),real_count);
RestoreIRQMask(savedMask);
return real_count;
}
/*
* task context
* write user data to UART tx buffer
* uint8 *Buffaddr:pointer to user's data
* uint16 Length: user's data length
* return:real length write to tx buffer
*/
uint16 uart_put_bytes(volatile uint8 *pBufAdr, volatile uint16 BufLen)
{
uint16 len, i;
volatile uint16 roomleft = 0;
uint8 *ptr = pBufAdr;
volatile uint16 size = BufLen;
/*UART TX interrupt mode*/
if (UART_TX_POLL_ENABLE == FALSE) {
/*when litter tx buff, should use polling*/
while (size) {
len = 0;
Buf_GetRoomLeft(&(UARTPort.Tx_Buffer), roomleft);
if (roomleft) {
if (size <= roomleft)
len = size;
else if (size > roomleft)
len = roomleft;
for (i = 0; i < len; i++ )
Buf_Push(&(UARTPort.Tx_Buffer),*(ptr++));
size -= len;
}
UART_EnableTX();
}
return BufLen;
} else {
/*UART TX polling mode*/
i = 0;
while (i < BufLen) {
UART_PutUARTByte(*(pBufAdr + i));
i++;
}
return BufLen;
}
}
/*put bytes to tx buffer, return value is the actually put out bytes*/
static kal_uint16 USB2UART_PutBytes(UART_PORT port, kal_uint8 *buffaddr, kal_uint16 length, module_type ownerid)
{
kal_uint16 real_count;
// kal_uint16 index;
kal_uint32 savedMask;
kal_uint8 ep_num = 0;
kal_bool setup_dma = KAL_FALSE;
kal_int32 remain;
BUFFER_INFO *tx_info = &(USB2UARTPort.Tx_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))
{
if(((gUsbDevice.device_type == USB_CDC_ACM)||(gUsbDevice.usb_comport_boot == KAL_TRUE))
&& (USB2UARTPort.initialized == KAL_TRUE)&&(gUsbDevice.nDevState != DEVSTATE_CONFIG))
{
g_UsbACM.config_send_Txilm = KAL_TRUE; /* for PC set config later then can issue the first message */
}
return 0;
}
/* The same issue as USB2UART_GetBytes()
The area to determine send_Txilm must also contain in critical section.
Otherwise if DMA callback activated before send_Txilm setting as true,
this message will be lost */
savedMask = SaveAndSetIRQMask();
Buf_GetRoomLeft(tx_info, real_count);
/* determine real sent data count */
if (real_count > length)
{
real_count = length;
}
else
{
g_UsbACM.send_Txilm = KAL_TRUE; /*After this time put bytes, buffer will be full */
g_UsbACM.config_send_Txilm = KAL_TRUE; /* if be reseted, then it can issue the message waited for*/
}
RestoreIRQMask(savedMask);
if(g_UsbACM.send_Txilm == KAL_TRUE)
{
if(ownerid != MOD_TST_READER)
{
drv_trace1(TRACE_FUNC, USBACM_PUT_BYTES_BUF_FULL, ownerid);
// kal_prompt_trace(MOD_USB, "RDY W %d", ownerid);
}
}
if(real_count != 0)
{
remain = (BWrite(tx_info) + real_count) - BLength(tx_info);
if(remain < 0)
{
/* dest, src, len */
kal_mem_cpy(BuffWrite(tx_info), buffaddr, real_count);
BWrite(tx_info) += real_count;
}
else
{
kal_mem_cpy(BuffWrite(tx_info), buffaddr, real_count-remain);
kal_mem_cpy(BStartAddr(tx_info), (kal_uint8 *)(buffaddr+real_count-remain), remain);
BWrite(tx_info) = remain;
}
}
/* push data from caller buffer to ring buffer */
/*
for (index = 0; index < real_count; index++)
{
Buf_Push(&(USB2UARTPort.Tx_Buffer), *(buffaddr+index));
}
*/
savedMask = SaveAndSetIRQMask();
/* in case usb is plugged out just before this critical section */
if(gUsbDevice.device_type == USB_CDC_ACM)
{
// if(USB_DMA_Get_Run_Status(g_UsbACM.txpipe->byEP) == KAL_FALSE)
if(g_UsbACM.setup_dma == KAL_FALSE)
{
g_UsbACM.setup_dma = KAL_TRUE;
setup_dma = KAL_TRUE;
ep_num = g_UsbACM.txpipe->byEP;
}
}
RestoreIRQMask(savedMask);
if(setup_dma == KAL_TRUE)
{
USB_Dbg_Trace(USB_ACM_DMA_SETUP_1, drv_get_current_time(), ep_num, 0);
USB2UART_DMATransmit(ep_num, KAL_FALSE);
}
#ifndef __PRODUCTION_RELEASE__
if(ownerid != USB2UARTPort.ownerid)
{
EXT_ASSERT( 0, (kal_uint32) ownerid, (kal_uint32)USB2UARTPort.ownerid, 0);
}
if(ownerid != MOD_TST_READER)
{
drv_trace1(TRACE_FUNC, USBACM_PUT_BYTES, real_count);
// kal_prompt_trace(MOD_USB, "Put %d", real_count);
}
#endif
return real_count;
}
/* 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;
}
/* put bytes to ISR tx buffer, handle the special character in this function(add escape character)
return value is the actually put out bytes*/
static kal_uint16 USB2UART_SendISRData(UART_PORT port, kal_uint8 *buffaddr, kal_uint16 length,
kal_uint8 mode, kal_uint8 escape_char, module_type ownerid)
{
kal_int16 real_count, index;
kal_uint8 data;
kal_uint32 savedMask;
kal_uint8 ep_num = 0;
kal_bool setup_dma = KAL_FALSE;
BUFFER_INFO *tx_isr_info = &(USB2UARTPort.Tx_Buffer_ISR);
if(ownerid != USB2UARTPort.ownerid)
{
#ifdef __PRODUCTION_RELEASE__
return 0;
#else
EXT_ASSERT( 0, (kal_uint32) ownerid, USB2UARTPort.ownerid, 0);
#endif
}
if ( (gUsbDevice.device_type != USB_CDC_ACM) ||
(USB2UARTPort.initialized == KAL_FALSE) || (gUsbDevice.nDevState!=DEVSTATE_CONFIG))
return 0;
if (mode == 0)
{
real_count = USB2UART_PutISRBytes(port, buffaddr, length, ownerid);
}
else
{
savedMask = SaveAndSetIRQMask();
Buf_GetRoomLeft(tx_isr_info, real_count);
RestoreIRQMask(savedMask);
/* determine real sent data count */
if (real_count > length)
real_count = length;
for (index = 0; index < real_count; index++)
{
kal_uint16 roomleft;
savedMask = SaveAndSetIRQMask();
Buf_GetRoomLeft(tx_isr_info, roomleft);
RestoreIRQMask(savedMask);
data = *(buffaddr + index);
/* if the character is special character, translate it. PC has the ability to distinguish it*/
if (data == USB2UARTPort.DCB.xonChar)
{
if ( roomleft >= 2 )
{
Buf_Push(tx_isr_info, escape_char);
Buf_Push(tx_isr_info, 0x01);
}
else
{
break;
}
}
else if (data == USB2UARTPort.DCB.xoffChar)
{
if ( roomleft >= 2 )
{
Buf_Push(tx_isr_info, escape_char);
Buf_Push(tx_isr_info, 0x02);
}
else
{
break;
}
}
else if (data == escape_char)
{
if ( roomleft >= 2 )
{
Buf_Push(tx_isr_info, escape_char);
Buf_Push(tx_isr_info, 0x03);
}
else
{
break;
}
}
else
{
if (roomleft)
{
Buf_Push(tx_isr_info, data);
}
else
{
break;
}
}
}
real_count = index;
savedMask = SaveAndSetIRQMask();
/* in case usb is plugged out just before this critical section */
if(gUsbDevice.device_type == USB_CDC_ACM)
{
// if(USB_DMA_Get_Run_Status(g_UsbACM.txpipe->byEP) == KAL_FALSE)
if(g_UsbACM.setup_dma == KAL_FALSE)
{
g_UsbACM.setup_dma = KAL_TRUE;
setup_dma = KAL_TRUE;
ep_num = g_UsbACM.txpipe->byEP;
}
}
RestoreIRQMask(savedMask);
if(setup_dma == KAL_TRUE)
{
USB_Dbg_Trace(USB_ACM_DMA_SETUP_3, drv_get_current_time(), ep_num, 0);
USB2UART_DMATransmit(ep_num, KAL_FALSE);
}
}
#ifndef __PRODUCTION_RELEASE__
if(ownerid != USB2UARTPort.ownerid)
{
EXT_ASSERT( 0, (kal_uint32) ownerid, (kal_uint32)USB2UARTPort.ownerid, 0);
}
#endif
if(ownerid != MOD_TST_READER)
{
drv_trace1(TRACE_FUNC, USBACM_SEND_ISR_DATA, real_count);
// kal_prompt_trace(MOD_USB, "SendISR %d", real_count);
}
return real_count;
}
/* put bytes to ISR tx buffer, return value is the actually put out bytes */
static kal_uint16 USB2UART_PutISRBytes(UART_PORT port, kal_uint8 *buffaddr, kal_uint16 length, module_type ownerid)
{
kal_uint16 real_count;
// kal_uint16 index;
kal_uint32 savedMask;
kal_uint8 ep_num = 0;
kal_bool setup_dma = KAL_FALSE;
kal_int32 remain;
BUFFER_INFO *tx_isr_info = &(USB2UARTPort.Tx_Buffer_ISR);
if(ownerid != USB2UARTPort.ownerid)
{
#ifdef __PRODUCTION_RELEASE__
return 0;
#else /* __PRODUCTION_RELEASE__ */
EXT_ASSERT( 0, (kal_uint32) ownerid, USB2UARTPort.ownerid, 0);
#endif
}
if ( (gUsbDevice.device_type != USB_CDC_ACM) ||
(USB2UARTPort.initialized == KAL_FALSE) || (gUsbDevice.nDevState!=DEVSTATE_CONFIG))
return 0;
savedMask = SaveAndSetIRQMask();
Buf_GetRoomLeft(tx_isr_info, real_count);
RestoreIRQMask(savedMask);
/* determine real sent data count */
if (real_count > length)
real_count = length;
if(real_count != 0)
{
remain = (BWrite(tx_isr_info) + real_count) - BLength(tx_isr_info);
if(remain < 0)
{
/* dest, src, len */
kal_mem_cpy(BuffWrite(tx_isr_info), buffaddr, real_count);
BWrite(tx_isr_info) += real_count;
}
else
{
kal_mem_cpy(BuffWrite(tx_isr_info), buffaddr, real_count-remain);
kal_mem_cpy(BStartAddr(tx_isr_info), (kal_uint8 *)(buffaddr+real_count-remain), remain);
BWrite(tx_isr_info) = remain;
}
}
/* push data from caller buffer to ring buffer */
/*
for (index = 0; index < real_count; index++)
{
Buf_Push(tx_isr_info, *(buffaddr+index));
}
*/
savedMask = SaveAndSetIRQMask();
/* in case usb is plugged out just before this critical section */
if(gUsbDevice.device_type == USB_CDC_ACM)
{
// if(USB_DMA_Get_Run_Status(g_UsbACM.txpipe->byEP) == KAL_FALSE)
if(g_UsbACM.setup_dma == KAL_FALSE)
{
g_UsbACM.setup_dma = KAL_TRUE;
setup_dma = KAL_TRUE;
ep_num = g_UsbACM.txpipe->byEP;
}
}
RestoreIRQMask(savedMask);
if(setup_dma == KAL_TRUE)
{
USB_Dbg_Trace(USB_ACM_DMA_SETUP_2, drv_get_current_time(), ep_num, 0);
USB2UART_DMATransmit(ep_num, KAL_FALSE);
}
#ifndef __PRODUCTION_RELEASE__
if(ownerid != USB2UARTPort.ownerid)
{
EXT_ASSERT( 0, (kal_uint32) ownerid, (kal_uint32)USB2UARTPort.ownerid, 0);
}
#endif
if(ownerid != MOD_TST_READER)
{
drv_trace1(TRACE_FUNC, USBACM_PUT_ISR_BYTES, real_count);
// kal_prompt_trace(MOD_USB, "PutISR %d", real_count);
}
return real_count;
}
/*
* ISR context
* uart_rx_cb() will be called when UART rx interrupt assert,
* then we should featch data from HW FIFO quickly.
* fucntion: fetch data from HW FIFO to rx ring buffer
* we should use uart_get_byte(&ch) to fetch byte from HW FIFO as quickly as possible
*/
void uart_rx_cb(void)
{
uint16 roomleft = 0;
PKT_FIFO *infor;
PKT_FIFO *temp_info;
uint8 ch = 0;
PKT_DESC *rx_desc = &(UARTPort.Rx_desc);
BUFFER_INFO *rx_ring = &(UARTPort.Rx_Buffer);
static uint8 ATMatchNum = 0;
static uint8 IWMatchNum = 0;
/*
* MCU only forward uart rx data to air
* here,copy to rx ring and return
*/
#if (UARTRX_TO_AIR_LEVEL == 2)
if (iot_uart_rx_mode == UARTRX_PUREDATA_MODE) {
while (uart_get_byte(&ch)) {
Buf_Push(rx_ring,ch);
}
return;
}
#endif
/*
* MCU should collect data to be packet
*/
//normal case
Buf_GetRoomLeft(rx_ring,roomleft);
while (uart_get_byte(&ch)) {
//new receive begin,detect packet header at first
switch (rx_desc->cur_type) {
case PKT_UNKNOWN: {
/**************** detect packet type ***************/
//support more ATcmd prefix analysis
/*case 1:AT#*/
if (ATCmdPrefixAT[ATMatchNum] == ch) {
ATMatchNum++;
} else {
ATMatchNum = 0;
}
/*case 2:iwpriv ra0*/
if (ATCmdPrefixIW[IWMatchNum] == ch) {
IWMatchNum++;
} else {
IWMatchNum = 0;
}
if ((ATMatchNum == sizeof(ATCmdPrefixAT)-1) || //match case 1: AT#
(IWMatchNum == sizeof(ATCmdPrefixIW)-1)) { //match case 2:iwpriv ra0
rx_desc->cur_num = rx_desc->pkt_num;
infor = &(rx_desc->infor[rx_desc->cur_num]);
infor->pkt_len = 0;
if (ATMatchNum == sizeof(ATCmdPrefixAT)-1) {
rx_desc->cur_type = PKT_ATCMD; //match case 1: AT#
} else if (IWMatchNum == sizeof(ATCmdPrefixIW)-1) {
rx_desc->cur_type = PKT_IWCMD; //match case 2:iwpriv ra0
}
ATMatchNum = 0;
IWMatchNum = 0;
continue;
}
}
break;
case PKT_ATCMD:
case PKT_IWCMD: {
infor = &(rx_desc->infor[rx_desc->cur_num]);
/*received one complete packet*/
if (ch == '\n' || ch == '\r') {
//if task has consumed some packets
if (rx_desc->cur_num != rx_desc->pkt_num) {
temp_info = infor;
infor = &(rx_desc->infor[rx_desc->pkt_num]);
infor->pkt_len = temp_info->pkt_len;
temp_info->pkt_len = 0;
temp_info->pkt_type = PKT_UNKNOWN;
}
infor->pkt_type = rx_desc->cur_type; // PKT_ATCMD / PKT_IWCMD;
rx_desc->pkt_num++;
rx_desc->cur_type = PKT_UNKNOWN;
} else {
/*continue to receiving packet */
Buf_Push(rx_ring,ch);
roomleft--;
infor->pkt_len++;
}
/*
* if overflow,we discard the current packet
* example1:packet length > ring size
* example2:rx ring buff can no be freed by task as quickly as rx interrupt coming
*/
if ((!roomleft) || (rx_desc->pkt_num >= NUM_DESCS)) {
//rollback
Buff_RollBack(rx_ring,infor->pkt_len);
roomleft += infor->pkt_len;
infor->pkt_type = PKT_UNKNOWN;
infor->pkt_len = 0;
rx_desc->cur_type = PKT_UNKNOWN;
if (rx_desc->pkt_num >= NUM_DESCS) {
rx_desc->pkt_num--;
}
}
}
break;
default:
break;
}
}
}
/*********************************************************************************************************
** Function name: UartProcessMsg()
** Descriptions: 处理串口消息
** input parameters: 无
** Output parameters:: 无
** Returned value: 无
** Created by:
** Created Date: 2014.10.03
**--------------------------------------------------------------------------------------------------------
** Modified by:
** Modified date: 2014.10.03
**--------------------------------------------------------------------------------------------------------
*********************************************************************************************************/
void UartProcessMsg(u8 ch)
{
u16 roomleft = 0;
PKT_FIFO *infor;
PKT_FIFO *temp_info;
PKT_DESC *rx_desc = &(UART1Port.Rx_desc);
BUFFER_INFO *rx_ring = &(UART1Port.Rx_Buffer);
static u16 AMHeadLen = sizeof(RCTRL_STRU_MSGHEAD);
static u16 AMBodyLen =0;
static u8 PDMatchNum = 0;
static u8 PrintMatchNum = 0;
Buf_GetRoomLeft(rx_ring,roomleft);
switch (rx_desc->cur_type)
{
case PKT_UNKNOWN:
{
/**************** detect packet type ***************/
if (PureDataPrefix[PDMatchNum] == ch)
{
PDMatchNum++;
}
else
{
PDMatchNum = 0;
}
if (PrintCmdPrefix[PrintMatchNum] == ch)
{
PrintMatchNum++;
}
else
{
PrintMatchNum = 0;
}
if ((PDMatchNum == sizeof(PureDataPrefix)-1) ||
(PrintMatchNum == sizeof(PrintCmdPrefix)-1)) //match case 3:arm data
{
rx_desc->cur_num = rx_desc->pkt_num;
infor = &(rx_desc->infor[rx_desc->cur_num]);
infor->pkt_len = 0;
if (PrintMatchNum == sizeof(PrintCmdPrefix)-1)
{
rx_desc->cur_type = PKT_PRINTCMD; //match case 2:iwpriv ra0
}
else if (PDMatchNum == sizeof(PureDataPrefix)-1)
{
u8 i= 0;
rx_desc->cur_type = PKT_PUREDATA; //match case 2:iwpriv ra0
if(roomleft<AMHeadLen)
{
rx_desc->cur_type= PKT_UNKNOWN;
}
else
{
for(i = 0;i < sizeof(PureDataPrefix)-1;i++)
{
Buf_Push(rx_ring,PureDataPrefix[i]);
}
roomleft= roomleft-sizeof(PureDataPrefix)+1;
infor = &(rx_desc->infor[rx_desc->cur_num]);
infor->pkt_len = infor->pkt_len + i;
}
}
PrintMatchNum = 0;
PDMatchNum = 0;
}
}
break;
case PKT_PRINTCMD:
{
/*
* received one complete packet
*/
if(ch == '\0'||ch == '\n' || ch == '\r')
{
rx_desc->cur_type = PKT_UNKNOWN;
return;
}
}
break;
case PKT_PUREDATA:
{
infor = &(rx_desc->infor[rx_desc->cur_num]);
Buf_Push(rx_ring,ch);
roomleft--;
infor->pkt_len++;
if(infor->pkt_len==AC_PAYLOADLENOFFSET)
{
AMBodyLen = ch;
}
else if(infor->pkt_len==(AC_PAYLOADLENOFFSET +1))
{
AMBodyLen = (AMBodyLen<<8) + ch;
}
/*
* if overflow,we discard the current packet
* example1:packet length > ring size
* example2:rx ring buff can no be freed by task as quickly as rx interrupt coming
*/
if ((!roomleft) || (rx_desc->pkt_num >= NUM_DESCS))
{
//rollback
Buff_RollBack(rx_ring,infor->pkt_len);
roomleft += infor->pkt_len;
infor->pkt_type = PKT_UNKNOWN;
infor->pkt_len = 0;
rx_desc->cur_type = PKT_UNKNOWN;
if (rx_desc->pkt_num >= NUM_DESCS)
{
rx_desc->pkt_num--;
}
}
/*
* received one complete packet
*/
if(AMHeadLen+AMBodyLen==infor->pkt_len)
{
//if task has consumed some packets
if (rx_desc->cur_num != rx_desc->pkt_num)
{
temp_info = infor;
infor = &(rx_desc->infor[rx_desc->pkt_num]);
infor->pkt_len = temp_info->pkt_len;
temp_info->pkt_len = 0;
temp_info->pkt_type = PKT_UNKNOWN;
}
infor->pkt_type = rx_desc->cur_type; // PKT_ATCMD / PKT_IWCMD;
rx_desc->pkt_num++;
rx_desc->cur_type = PKT_UNKNOWN;
AMBodyLen =0;
return;
}
}
break;
default:
break;
}
}
