void rtw_os_read_port(_adapter *padapter, struct recv_buf *precvbuf)
{
struct recv_priv *precvpriv = &padapter->recvpriv;
#ifdef CONFIG_USB_HCI
precvbuf->ref_cnt--;
//free skb in recv_buf
rtw_skb_free(precvbuf->pskb);
precvbuf->pskb = NULL;
if(precvbuf->irp_pending == _FALSE)
{
rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
}
#endif
#if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
precvbuf->pskb = NULL;
#endif
}
void usb_recv_tasklet(void *priv)
{
_pkt *pskb;
_adapter *padapter = (_adapter*)priv;
struct recv_priv *precvpriv = &padapter->recvpriv;
struct recv_buf *precvbuf = NULL;
while (NULL != (pskb = skb_dequeue(&precvpriv->rx_skb_queue))) {
if ((padapter->bDriverStopped == _TRUE)||(padapter->bSurpriseRemoved== _TRUE)) {
DBG_8192C("recv_tasklet => bDriverStopped or bSurpriseRemoved \n");
#ifdef CONFIG_PREALLOC_RX_SKB_BUFFER
if (rtw_free_skb_premem(pskb) != 0)
#endif //CONFIG_PREALLOC_RX_SKB_BUFFER
rtw_skb_free(pskb);
break;
}
recvbuf2recvframe(padapter, pskb);
skb_reset_tail_pointer(pskb);
pskb->len = 0;
skb_queue_tail(&precvpriv->free_recv_skb_queue, pskb);
if (NULL != (precvbuf = rtw_dequeue_recvbuf(&precvpriv->recv_buf_pending_queue))) {
precvbuf->pskb = NULL;
rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
}
}
}
void usb_recv_tasklet(void *priv)
{
_pkt *pskb;
_adapter *padapter = (_adapter *)priv;
struct recv_priv *precvpriv = &padapter->recvpriv;
struct recv_buf *precvbuf = NULL;
while (NULL != (pskb = skb_dequeue(&precvpriv->rx_skb_queue))) {
if (RTW_CANNOT_RUN(padapter)) {
RTW_INFO("recv_tasklet => bDriverStopped(%s) OR bSurpriseRemoved(%s)\n"
, rtw_is_drv_stopped(padapter) ? "True" : "False"
, rtw_is_surprise_removed(padapter) ? "True" : "False");
#ifdef CONFIG_PREALLOC_RX_SKB_BUFFER
if (rtw_free_skb_premem(pskb) != 0)
#endif /* CONFIG_PREALLOC_RX_SKB_BUFFER */
rtw_skb_free(pskb);
break;
}
recvbuf2recvframe(padapter, pskb);
skb_reset_tail_pointer(pskb);
pskb->len = 0;
skb_queue_tail(&precvpriv->free_recv_skb_queue, pskb);
precvbuf = rtw_dequeue_recvbuf(&precvpriv->recv_buf_pending_queue);
if (NULL != precvbuf) {
precvbuf->pskb = NULL;
rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
}
}
}
void rtw_os_read_port23a(struct rtw_adapter *padapter, struct recv_buf *precvbuf)
{
struct recv_priv *precvpriv = &padapter->recvpriv;
/* free skb in recv_buf */
dev_kfree_skb_any(precvbuf->pskb);
precvbuf->pskb = NULL;
rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, precvbuf);
}
void rtw_os_read_port(struct adapter *padapter, struct recv_buf *precvbuf)
{
struct recv_priv *precvpriv = &padapter->recvpriv;
precvbuf->ref_cnt--;
/* free skb in recv_buf */
dev_kfree_skb_any(precvbuf->pskb);
precvbuf->pskb = NULL;
precvbuf->reuse = false;
if (!precvbuf->irp_pending)
rtw_read_port(padapter, precvpriv->ff_hwaddr, 0,
(unsigned char *)precvbuf);
}
void rtw_os_read_port(_adapter *padapter, struct recv_buf *precvbuf)
{
struct recv_priv *precvpriv = &padapter->recvpriv;
precvbuf->ref_cnt--;
//free skb in recv_buf
rtw_skb_free(precvbuf->pskb);
precvbuf->pskb = NULL;
precvbuf->reuse = _FALSE;
if(precvbuf->irp_pending == _FALSE)
{
rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
}
}
void usb_recv_tasklet(void *priv)
{
struct recv_buf *precvbuf = NULL;
_adapter *padapter = (_adapter *)priv;
struct recv_priv *precvpriv = &padapter->recvpriv;
while (NULL != (precvbuf = rtw_dequeue_recvbuf(&precvpriv->recv_buf_pending_queue))) {
if (RTW_CANNOT_RUN(padapter)) {
RTW_INFO("recv_tasklet => bDriverStopped(%s) OR bSurpriseRemoved(%s)\n"
, rtw_is_drv_stopped(padapter)? "True" : "False"
, rtw_is_surprise_removed(padapter)? "True" : "False");
break;
}
recvbuf2recvframe(padapter, precvbuf);
rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
}
}
void usb_recv_tasklet(void *priv)
{
struct recv_buf *precvbuf = NULL;
_adapter *padapter = (_adapter*)priv;
struct recv_priv *precvpriv = &padapter->recvpriv;
while (NULL != (precvbuf = rtw_dequeue_recvbuf(&precvpriv->recv_buf_pending_queue))) {
if ((padapter->bDriverStopped == _TRUE)||(padapter->bSurpriseRemoved== _TRUE)) {
DBG_8192C("recv_tasklet => bDriverStopped or bSurpriseRemoved \n");
break;
}
recvbuf2recvframe(padapter, precvbuf);
rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
}
}
void usb_read_port_complete(struct urb *purb, struct pt_regs *regs)
{
struct recv_buf *precvbuf = (struct recv_buf *)purb->context;
_adapter *padapter =(_adapter *)precvbuf->adapter;
struct recv_priv *precvpriv = &padapter->recvpriv;
RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete!!!\n"));
ATOMIC_DEC(&(precvpriv->rx_pending_cnt));
if(RTW_CANNOT_RX(padapter)) {
RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete:bDriverStopped(%d) OR bSurpriseRemoved(%d)\n", padapter->bDriverStopped, padapter->bSurpriseRemoved));
DBG_8192C("%s() RX Warning! bDriverStopped(%d) OR bSurpriseRemoved(%d) \n",
__FUNCTION__,padapter->bDriverStopped, padapter->bSurpriseRemoved);
goto exit;
}
if(purb->status==0) { //SUCCESS
if ((purb->actual_length > MAX_RECVBUF_SZ) || (purb->actual_length < RXDESC_SIZE)) {
RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete: (purb->actual_length > MAX_RECVBUF_SZ) || (purb->actual_length < RXDESC_SIZE)\n"));
rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
DBG_8192C("%s()-%d: RX Warning!\n", __FUNCTION__, __LINE__);
} else {
rtw_reset_continual_io_error(adapter_to_dvobj(padapter));
precvbuf->transfer_len = purb->actual_length;
skb_put(precvbuf->pskb, purb->actual_length);
skb_queue_tail(&precvpriv->rx_skb_queue, precvbuf->pskb);
#ifndef CONFIG_FIX_NR_BULKIN_BUFFER
if (skb_queue_len(&precvpriv->rx_skb_queue)<=1)
#endif
tasklet_schedule(&precvpriv->recv_tasklet);
precvbuf->pskb = NULL;
rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
}
} else {
RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete : purb->status(%d) != 0 \n", purb->status));
DBG_8192C("###=> usb_read_port_complete => urb status(%d)\n", purb->status);
if(rtw_inc_and_chk_continual_io_error(adapter_to_dvobj(padapter)) == _TRUE ) {
padapter->bSurpriseRemoved = _TRUE;
}
switch(purb->status) {
case -EINVAL:
case -EPIPE:
case -ENODEV:
case -ESHUTDOWN:
//padapter->bSurpriseRemoved=_TRUE;
//RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete:bSurpriseRemoved=TRUE\n"));
case -ENOENT:
padapter->bDriverStopped=_TRUE;
RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete:bDriverStopped=TRUE\n"));
break;
case -EPROTO:
case -EILSEQ:
case -ETIME:
case -ECOMM:
case -EOVERFLOW:
#ifdef DBG_CONFIG_ERROR_DETECT
{
HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);
pHalData->srestpriv.Wifi_Error_Status = USB_READ_PORT_FAIL;
}
#endif
rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
break;
case -EINPROGRESS:
DBG_8192C("ERROR: URB IS IN PROGRESS!/n");
break;
default:
break;
}
}
exit:
_func_exit_;
}
void usb_read_port_complete(struct urb *purb, struct pt_regs *regs)
{
struct recv_buf *precvbuf = (struct recv_buf *)purb->context;
_adapter *padapter = (_adapter *)precvbuf->adapter;
struct recv_priv *precvpriv = &padapter->recvpriv;
ATOMIC_DEC(&(precvpriv->rx_pending_cnt));
if (RTW_CANNOT_RX(padapter)) {
RTW_INFO("%s() RX Warning! bDriverStopped(%s) OR bSurpriseRemoved(%s)\n"
, __func__
, rtw_is_drv_stopped(padapter) ? "True" : "False"
, rtw_is_surprise_removed(padapter) ? "True" : "False");
goto exit;
}
if (purb->status == 0) {
if ((purb->actual_length > MAX_RECVBUF_SZ) || (purb->actual_length < RXDESC_SIZE)) {
RTW_INFO("%s()-%d: urb->actual_length:%u, MAX_RECVBUF_SZ:%u, RXDESC_SIZE:%u\n"
, __FUNCTION__, __LINE__, purb->actual_length, MAX_RECVBUF_SZ, RXDESC_SIZE);
rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
} else {
rtw_reset_continual_io_error(adapter_to_dvobj(padapter));
precvbuf->transfer_len = purb->actual_length;
skb_put(precvbuf->pskb, purb->actual_length);
skb_queue_tail(&precvpriv->rx_skb_queue, precvbuf->pskb);
#ifndef CONFIG_FIX_NR_BULKIN_BUFFER
if (skb_queue_len(&precvpriv->rx_skb_queue) <= 1)
#endif
tasklet_schedule(&precvpriv->recv_tasklet);
precvbuf->pskb = NULL;
rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
}
} else {
RTW_INFO("###=> usb_read_port_complete => urb.status(%d)\n", purb->status);
if (rtw_inc_and_chk_continual_io_error(adapter_to_dvobj(padapter)) == _TRUE)
rtw_set_surprise_removed(padapter);
switch (purb->status) {
case -EINVAL:
case -EPIPE:
case -ENODEV:
case -ESHUTDOWN:
case -ENOENT:
rtw_set_drv_stopped(padapter);
break;
case -EPROTO:
case -EILSEQ:
case -ETIME:
case -ECOMM:
case -EOVERFLOW:
#ifdef DBG_CONFIG_ERROR_DETECT
{
HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);
pHalData->srestpriv.Wifi_Error_Status = USB_READ_PORT_FAIL;
}
#endif
rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
break;
case -EINPROGRESS:
RTW_INFO("ERROR: URB IS IN PROGRESS!/n");
break;
default:
break;
}
}
exit:
return;
}
void sd_c2h_hdl(PADAPTER padapter)
{
u8 cmd_seq, pkt_num = 0;
u16 tmp16, sz, cmd_len = 0;
u32 rd_sz=0, cmd_sz = 0;//,ptr;
struct evt_priv *pevtpriv = &padapter->evtpriv;
pkt_num = rtw_read8(padapter, 0x102500BF);
// RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("@ sd_c2h_hdl:pkt_num=%d",pkt_num));
get_next:
// ptr=rtw_read32(padapter,0x102500e8);
// RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("@ sd_c2h_hdl:C2H fifo RDPTR=0x%x",ptr));
// ptr=rtw_read32(padapter,0x102500ec);
// RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("@ sd_c2h_hdl:C2H fifo WTPTR=0x%x",ptr));
// if(pkt_num==0x0 ){
// RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("@ sd_c2h_hdl:cmd_pkt num=0x%x!",pkt_num));
// return;
// }
RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("@ sd_c2h_hdl:pkt_num=%d",pkt_num));
//memset(pevtpriv->c2h_mem,0,512);
rtw_read_port(padapter, RTL8712_DMA_C2HCMD, 512, pevtpriv->c2h_mem);
cmd_sz = *(u16 *)&pevtpriv->c2h_mem[0];
cmd_sz &= 0x3fff;
RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("sd_c2h_hdl: cmd_sz=%d[0x%x]!",cmd_sz,cmd_sz));
tmp16 = *(u16 *)&pevtpriv->c2h_mem[4];
tmp16 &= 0x01ff;
if (tmp16 !=0x1ff) {
RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("sd_c2h_hdl: 0x1ff error[0x%x]!",pevtpriv->c2h_mem[4]));
goto exit;
}
if((cmd_sz+24) >512){
rtw_read_port(padapter, RTL8712_DMA_C2HCMD, (cmd_sz+24-512), pevtpriv->c2h_mem+512);
RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("sd_c2h_hdl: read the second part of c2h event!"));
}
cmd_seq = pevtpriv->c2h_mem[27];
cmd_seq &= 0x7f;
if (pevtpriv->event_seq != cmd_seq) {
RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("sd_c2h_hdl: pevtpriv->event_seq (%d) != c2hbuf seq(%d)",pevtpriv->event_seq,cmd_seq));
} else {
RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("sd_c2h_hdl: pevtpriv->event_seq (%d) == c2hbuf seq(%d)",pevtpriv->event_seq,cmd_seq));
}
cmd_len = *(u16 *)&pevtpriv->c2h_mem[0];
cmd_len &= 0x3ff;
RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("@sd_c2h_hdl: cmd_len=%d",cmd_len));
// if(cmd_len){
// memset(pevtpriv->c2h_mem+cmd_len,0,cmd_len);
// rtw_read_port(padapter, RTL8712_DMA_C2HCMD, cmd_len, pevtpriv->c2h_mem+cmd_len);
// }
// pevtpriv->event_seq=pevtpriv->event_seq++;
// if(pevtpriv->event_seq>127)
// pevtpriv->event_seq=0;
RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("sd_c2h_hdl:!"));
rxcmd_event_hdl(padapter,pevtpriv->c2h_mem);
if (pkt_num > 1) {
pkt_num--;
RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("sd_c2h_hdl: pkt_num=%d",pkt_num));
goto get_next;
}
exit:
return;
}
void sd_recv_rxfifo(PADAPTER padapter)
{
// u8 *pdata, *ptail, *pfixed_tail,*pfixed_head,*pfixed_end,blk_shift_bit;
u16 rx_blknum;
u32 blk_sz, cnt;//,remain,tmp_cnt;
struct recv_priv *precvpriv;
// struct recv_stat *prxstat;
//union recv_frame *precvframe, *ppreframe = NULL;
// _queue *pfree_recv_queue, *ppending_recv_queue;
// u8 tmp[2048];
struct recv_buf *precvbuf;
_list *precvbuf_head, *precvbuf_list;
_irqL irql, rx_proc_irq;
// uint pkt_len;
// u16 drvinfo_sz;
precvpriv = &padapter->recvpriv;
blk_sz = padapter->dvobjpriv.block_transfer_len;
// blk_shift_bit= (u8)padapter->dvobjpriv.blk_shiftbits;
// pfree_recv_queue = &(precvpriv->free_recv_queue);
// ppending_recv_queue = &(precvpriv->recv_pending_queue);
rx_blknum = padapter->dvobjpriv.rxblknum;
// _enter_critical_mutex(&padapter->dvobjpriv.rx_protect, &rx_proc_irq);
// padapter->dvobjpriv.rxblknum=rtw_read16(padapter, SDIO_RX0_RDYBLK_NUM);
sdio_read_int(padapter, SDIO_RX0_RDYBLK_NUM, 2, &padapter->dvobjpriv.rxblknum);
if (rx_blknum>padapter->dvobjpriv.rxblknum) {
cnt = (0x10000 - rx_blknum + padapter->dvobjpriv.rxblknum) * blk_sz;
} else {
cnt = (padapter->dvobjpriv.rxblknum-rx_blknum) * blk_sz;
}
RT_TRACE(_module_hci_intfs_c_,_drv_notice_,("=====================sd_recv_rxfifo padapter->dvobjpriv.rxblknum=%x Blk_Num = %x cnt=%d",padapter->dvobjpriv.rxblknum, rx_blknum,cnt));
if (cnt == 0) {
// remain = 0;
precvbuf = NULL;
RT_TRACE(_module_hci_intfs_c_,_drv_info_,("---===============sd_recv_rxfifo padapter->dvobjpriv.rxblknum=0x%x padapter->dvobjpriv.rxblknum_rd=0x%x", padapter->dvobjpriv.rxblknum,padapter->dvobjpriv.rxblknum_rd));
goto drop_pkt;
}
if(_rtw_queue_empty(&precvpriv->free_recv_buf_queue) == _TRUE)
{
precvbuf = NULL;
RT_TRACE(_module_hci_intfs_c_,_drv_emerg_,("\n sd_recv_rxfifo : precvbuf= NULL precvpriv->free_recv_buf_queue_cnt=%d \n",precvpriv->free_recv_buf_queue_cnt));
goto drop_pkt;
}
else
{
_enter_critical(&precvpriv->free_recv_buf_queue.lock, &irql);
precvbuf_head = get_list_head(&precvpriv->free_recv_buf_queue);
precvbuf_list = get_next(precvbuf_head);
precvbuf = LIST_CONTAINOR(precvbuf_list, struct recv_buf, list);
list_delete(&precvbuf->list);
precvpriv->free_recv_buf_queue_cnt--;
RT_TRACE(_module_hci_intfs_c_,_drv_notice_,("\n sd_recv_rxfifo : precvbuf= 0x%p dequeue: free_recv_buf_queue_cnt=%d\n",precvbuf,precvpriv->free_recv_buf_queue_cnt));
_exit_critical(&precvpriv->free_recv_buf_queue.lock, &irql);
}
read_pkt2recvbuf(padapter, cnt, precvbuf);
return;
drop_pkt:
if (cnt >0) {
do{
if (cnt > MAX_RECVBUF_SZ) {
rtw_read_port(padapter, 0x10380000, MAX_RECVBUF_SZ, (u8 *)precvpriv->recvbuf_drop);
RT_TRACE(_module_hci_intfs_c_,_drv_notice_,("=========sd_recv_rxfifo precvbuf= NULL no recvbuf cnt=%d tmp read %d",cnt,MAX_RECVBUF_SZ));
cnt=cnt-MAX_RECVBUF_SZ;
} else {
rtw_read_port(padapter, 0x10380000, cnt, (u8 *)precvpriv->recvbuf_drop);
RT_TRACE(_module_hci_intfs_c_,_drv_notice_,("=========sd_recv_rxfifo precvbuf= NULL no recvbuf cnt=%d tmp read(@) %d",cnt,cnt));
cnt=0;
}
} while(cnt > 0);
}
return;
}
u32 read_pkt2recvbuf(PADAPTER padapter, u32 rd_cnt, struct recv_buf *precvbuf)
{
struct recv_priv *precvpriv = &padapter->recvpriv;
u32 skb_buf_sz;
if (rd_cnt < 1600)
skb_buf_sz = 1600;
else
skb_buf_sz = rd_cnt;
RT_TRACE(_module_rtl871x_recv_c_,_drv_info_,("\n read_pkt2recvbuf------skb_buf_sz=%d rd_cnt=%d\n",skb_buf_sz,rd_cnt));
// if (precvbuf->pskb != NULL) {
// dev_kfree_skb_any(precvbuf->pskb );
// }
//alloc skb
{
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)) // http://www.mail-archive.com/[email protected]/msg17214.html
precvbuf->pskb = dev_alloc_skb(skb_buf_sz);
#else
precvbuf->pskb = netdev_alloc_skb(padapter->pnetdev, skb_buf_sz);
#endif
if (precvbuf->pskb == NULL) {
RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("==================rtw_init_recvbuf(): alloc_skb fail!\n"));
return _FAIL;
}
precvbuf->phead = precvbuf->pskb->head;
precvbuf->pdata = precvbuf->pskb->data;
precvbuf->ptail = precvbuf->pskb->tail;
precvbuf->pend = precvbuf->pskb->end;
precvbuf->pbuf = precvbuf->pskb->data;
}
// else {
// RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("after rtw_init_recvbuf(): skb !=NULL!\n"));
// }
rtw_read_port(padapter, RTL8712_DMA_RX0FF, rd_cnt, (u8*)precvbuf);
precvbuf->ptail = precvbuf->ptail + rd_cnt;
precvbuf->len = rd_cnt;
/*{
u32 i;
printk("-----After read port[%d]-----\n",skb_buf_sz);
for (i = 0; i < skb_buf_sz; i = i + 8) {
printk("0x%x:0x%x:0x%x:0x%x:0x%x:0x%x:0x%x:0x%x\n",precvbuf->pbuf[i],precvbuf->pbuf[i+1],precvbuf->pbuf[i+2],precvbuf->pbuf[i+3],precvbuf->pbuf[i+4],precvbuf->pbuf[i+5],precvbuf->pbuf[i+6],precvbuf->pbuf[i+7]);
}
printk("-----------\n");
}*/
#if 1
recvbuf2recvframe_s(padapter, precvbuf);
#else
{
dev_kfree_skb_any(precvbuf->pskb);
precvbuf->pskb = NULL;
list_delete(&(precvbuf->list));
rtw_list_insert_tail(&precvbuf->list, get_list_head(&precvpriv->free_recv_buf_queue));
precvpriv->free_recv_buf_queue_cnt++;
}
#endif
return _SUCCESS;
}
DWORD usb_read_port_complete( PVOID context )
{
struct recv_buf *precvbuf = (struct recv_buf *)context;
_adapter *adapter = (_adapter *)precvbuf->adapter;
struct recv_priv *precvpriv = &adapter->recvpriv;
struct intf_hdl *pintfhdl = &adapter->pio_queue->intf;
struct intf_priv *pintfpriv = pintfhdl->pintfpriv;
struct dvobj_priv *pdvobj_priv = (struct dvobj_priv*)pintfpriv->intf_dev;
LPCUSB_FUNCS usb_funcs_vp = pdvobj_priv->usb_extension._lpUsbFuncs;
DWORD dwBytesTransferred = 0;
DWORD dwErr = USB_CANCELED_ERROR;
uint isevt, *pbuf;
int fComplete =_FALSE;
RT_TRACE( _module_hci_ops_os_c_, _drv_info_, ("usb_read_port_complete(%u)\n", __LINE__));
_func_enter_;
_rtw_spinlock_ex(&precvpriv->lock);
precvbuf->irp_pending=_FALSE;
precvpriv->rx_pending_cnt --;
_rtw_spinunlock_ex(&precvpriv->lock);
#if 1
(*usb_funcs_vp->lpGetTransferStatus)(precvbuf->usb_transfer_read_port, &dwBytesTransferred, &dwErr);
fComplete = (*usb_funcs_vp->lpIsTransferComplete)(precvbuf->usb_transfer_read_port);
if(fComplete!=_TRUE)
{
RT_TRACE( _module_hci_ops_os_c_, _drv_err_, ("usb_read_port_complete CloseTransfer before complete\n"));
}
(*usb_funcs_vp->lpCloseTransfer)(precvbuf->usb_transfer_read_port);
#endif
if(USB_NO_ERROR != dwErr)
RT_TRACE( _module_hci_ops_os_c_, _drv_err_, ("usb_read_port_complete Fail :%d\n",dwErr));
{
if ( dwBytesTransferred > MAX_RECVBUF_SZ || dwBytesTransferred < RXDESC_SIZE )
{
RT_TRACE(_module_hci_ops_os_c_,_drv_err_,
("\n usb_read_port_complete: (pbulkurb->TransferBufferLength > MAX_RECVBUF_SZ) || (pbulkurb->TransferBufferLength < RXDESC_SIZE): %d\n",dwBytesTransferred));
rtw_read_port(adapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
//usb_read_port(pintfhdl, 0, 0, (unsigned char *)precvframe);
}
else
{
precvbuf->transfer_len = dwBytesTransferred;
pbuf = (uint*)precvbuf->pbuf;
if((isevt = *(pbuf+1)&0x1ff) == 0x1ff)
{
RT_TRACE(_module_hci_ops_os_c_,_drv_info_,
("\n usb_read_port_complete: get a event\n"));
rxcmd_event_hdl(adapter, pbuf);//rx c2h events
rtw_read_port(adapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
}
else
{
if(recvbuf2recvframe(adapter, precvbuf)==_FAIL)//rx packets
{
//precvbuf->reuse = _TRUE;
rtw_read_port(adapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
}
}
}
}
RT_TRACE( _module_hci_ops_os_c_, _drv_info_, ("-usb_read_port_complete(%u)\n", __LINE__));
_func_exit_;
return ERROR_SUCCESS;
// return STATUS_MORE_PROCESSING_REQUIRED;
}
