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 rtl8812au_recv_tasklet(void *priv)
{
struct sk_buff *pskb;
struct rtl_priv *rtlpriv = (struct rtl_priv *)priv;
struct recv_priv *precvpriv = &rtlpriv->recvpriv;
while (NULL != (pskb = skb_dequeue(&precvpriv->rx_skb_queue))) {
if ((rtlpriv->bDriverStopped == _TRUE)
|| (rtlpriv->bSurpriseRemoved == _TRUE)) {
DBG_8192C("recv_tasklet => bDriverStopped or bSurpriseRemoved \n");
dev_kfree_skb_any(pskb);
break;
}
recvbuf2recvframe(rtlpriv, pskb);
#ifdef CONFIG_PREALLOC_RECV_SKB
skb_reset_tail_pointer(pskb);
pskb->len = 0;
skb_queue_tail(&precvpriv->free_recv_skb_queue, pskb);
#else
dev_kfree_skb_any(pskb);
#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 (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 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);
}
}
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;
}
static void usb_read_port_complete(struct urb *purb, struct pt_regs *regs)
#endif
{
_irqL irqL;
uint isevt, *pbuf;
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"));
//Useless for linux usb driver.
//2010-03-10 by Thomas
//_enter_critical(&precvpriv->lock, &irqL);
//precvbuf->irp_pending=_FALSE;
//precvpriv->rx_pending_cnt --;
//_exit_critical(&precvpriv->lock, &irqL);
//if(precvpriv->rx_pending_cnt== 0)
//{
// RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete: rx_pending_cnt== 0, set allrxreturnevt!\n"));
// _up_sema(&precvpriv->allrxreturnevt);
//}
if(padapter->bSurpriseRemoved ||padapter->bDriverStopped)
{
RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete:bDriverStopped(%d) OR bSurpriseRemoved(%d)\n", 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"));
precvbuf->reuse = _TRUE;
read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
}
else
{
precvbuf->transfer_len = purb->actual_length;
pbuf = (uint*)precvbuf->pbuf;
if((isevt = le32_to_cpu(*(pbuf+1))&0x1ff) == 0x1ff)
{
//_irqL irqL;
//_enter_critical( &padapter->lockRxFF0Filter, &irqL );
//if ( padapter->blnEnableRxFF0Filter )
//{
// padapter->blnEnableRxFF0Filter = 0;
//}
//_exit_critical( &padapter->lockRxFF0Filter, &irqL );
//MSG_8712("usb_read_port_complete():rxcmd_event_hdl\n");
rxcmd_event_hdl(padapter, pbuf);//rx c2h events
precvbuf->reuse = _TRUE;
read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
}
else
{
#ifdef CONFIG_RECV_TASKLET
_pkt *pskb = precvbuf->pskb;
skb_put(pskb, purb->actual_length);
skb_queue_tail(&precvpriv->rx_skb_queue, pskb);
tasklet_hi_schedule(&precvpriv->recv_tasklet);
precvbuf->pskb = NULL;
precvbuf->reuse = _FALSE;
read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
#else
if(recvbuf2recvframe(padapter, precvbuf)==_FAIL)//rx packets
{
precvbuf->reuse = _TRUE;
read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
}
#endif
}
}
}
else
{
RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete : purb->status(%d) != 0 \n", purb->status));
printk( "[%s] purb->status(%d) != 0\n", __FUNCTION__, purb->status );
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:
precvbuf->reuse = _TRUE;
read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
break;
case -EINPROGRESS:
printk("ERROR: URB IS IN PROGRESS!/n");
break;
default:
break;
}
}
exit:
_func_exit_;
}
