void usb_write_port_cancel(_adapter *padapter)
{
sint i,j;
struct dvobj_priv *pdev = &padapter->dvobjpriv;
struct xmit_priv *pxmitpriv=&padapter->xmitpriv;
struct xmit_frame *pxmitframe;
_rtw_spinlock(&pxmitpriv->lock);
pxmitpriv->txirp_cnt--; //decrease 1 for Initialize ++
_rtw_spinunlock(&pxmitpriv->lock);
if (pxmitpriv->txirp_cnt)
{
// Canceling Pending Recv Irp
pxmitframe= (struct xmit_frame *)pxmitpriv->pxmit_frame_buf;
for( i = 0; i < NR_XMITFRAME; i++ )
{
for(j=0;j<8;j++)
{
if (pxmitframe->bpending[j]==_TRUE)
{
RT_TRACE(_module_hci_ops_os_c_,_drv_err_,(" usb_write_port_cancel() :IoCancelIrp\n"));
}
}
pxmitframe++;
}
_rtw_down_sema(&(pxmitpriv->tx_retevt));
}
}
// using pstapriv->sta_hash_lock to protect
u32 rtw_free_stainfo(_adapter *padapter , struct sta_info *psta)
{
int i;
_irqL irqL0;
_queue *pfree_sta_queue;
struct recv_reorder_ctrl *preorder_ctrl;
struct sta_xmit_priv *pstaxmitpriv;
struct xmit_priv *pxmitpriv= &padapter->xmitpriv;
struct sta_priv *pstapriv = &padapter->stapriv;
_func_enter_;
if (psta == NULL)
goto exit;
pfree_sta_queue = &pstapriv->free_sta_queue;
pstaxmitpriv = &psta->sta_xmitpriv;
//list_delete(&psta->sleep_list);
//list_delete(&psta->wakeup_list);
_enter_critical_bh(&(pxmitpriv->vo_pending.lock), &irqL0);
rtw_free_xmitframe_queue( pxmitpriv, &pstaxmitpriv->vo_q.sta_pending);
list_delete(&(pstaxmitpriv->vo_q.tx_pending));
_exit_critical_bh(&(pxmitpriv->vo_pending.lock), &irqL0);
_enter_critical_bh(&(pxmitpriv->vi_pending.lock), &irqL0);
rtw_free_xmitframe_queue( pxmitpriv, &pstaxmitpriv->vi_q.sta_pending);
list_delete(&(pstaxmitpriv->vi_q.tx_pending));
_exit_critical_bh(&(pxmitpriv->vi_pending.lock), &irqL0);
_enter_critical_bh(&(pxmitpriv->bk_pending.lock), &irqL0);
rtw_free_xmitframe_queue( pxmitpriv, &pstaxmitpriv->bk_q.sta_pending);
list_delete(&(pstaxmitpriv->bk_q.tx_pending));
_exit_critical_bh(&(pxmitpriv->bk_pending.lock), &irqL0);
_enter_critical_bh(&(pxmitpriv->be_pending.lock), &irqL0);
rtw_free_xmitframe_queue( pxmitpriv, &pstaxmitpriv->be_q.sta_pending);
list_delete(&(pstaxmitpriv->be_q.tx_pending));
_exit_critical_bh(&(pxmitpriv->be_pending.lock), &irqL0);
list_delete(&psta->hash_list);
RT_TRACE(_module_rtl871x_sta_mgt_c_,_drv_err_,("\n free number_%d stainfo with hwaddr = 0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x \n",pstapriv->asoc_sta_count , psta->hwaddr[0], psta->hwaddr[1], psta->hwaddr[2],psta->hwaddr[3],psta->hwaddr[4],psta->hwaddr[5]));
pstapriv->asoc_sta_count --;
// re-init sta_info; 20061114
_rtw_init_sta_xmit_priv(&psta->sta_xmitpriv);
_rtw_init_sta_recv_priv(&psta->sta_recvpriv);
_cancel_timer_ex(&psta->addba_retry_timer);
//for A-MPDU Rx reordering buffer control, cancel reordering_ctrl_timer
for(i=0; i < 16 ; i++)
{
preorder_ctrl = &psta->recvreorder_ctrl[i];
_cancel_timer_ex(&preorder_ctrl->reordering_ctrl_timer);
}
_rtw_spinlock(&(pfree_sta_queue->lock));
// insert into free_sta_queue; 20061114
rtw_list_insert_tail(&psta->list, get_list_head(pfree_sta_queue));
_rtw_spinunlock(&(pfree_sta_queue->lock));
exit:
_func_exit_;
return _SUCCESS;
}
//struct sta_info *rtw_alloc_stainfo(_queue *pfree_sta_queue, unsigned char *hwaddr)
struct sta_info *rtw_alloc_stainfo(struct sta_priv *pstapriv, u8 *hwaddr)
{
uint tmp_aid;
s32 index;
_list *phash_list;
struct sta_info *psta;
_queue *pfree_sta_queue;
struct recv_reorder_ctrl *preorder_ctrl;
int i = 0;
u16 wRxSeqInitialValue = 0xffff;
_func_enter_;
pfree_sta_queue = &pstapriv->free_sta_queue;
_rtw_spinlock(&(pfree_sta_queue->lock));
if (_rtw_queue_empty(pfree_sta_queue) == _TRUE)
{
psta = NULL;
}
else
{
psta = LIST_CONTAINOR(get_next(&pfree_sta_queue->queue), struct sta_info, list);
list_delete(&(psta->list));
tmp_aid = psta->aid;
_init_stainfo(psta);
_rtw_memcpy(psta->hwaddr, hwaddr, ETH_ALEN);
index = wifi_mac_hash(hwaddr);
RT_TRACE(_module_rtl871x_sta_mgt_c_,_drv_info_,("rtw_alloc_stainfo: index = %x", index));
if(index >= NUM_STA){
RT_TRACE(_module_rtl871x_sta_mgt_c_,_drv_err_,("ERROR=> rtw_alloc_stainfo: index >= NUM_STA"));
psta= NULL;
goto exit;
}
phash_list = &(pstapriv->sta_hash[index]);
_rtw_spinlock(&(pstapriv->sta_hash_lock));
rtw_list_insert_tail(&psta->hash_list, phash_list);
pstapriv->asoc_sta_count ++ ;
_rtw_spinunlock(&(pstapriv->sta_hash_lock));
// Commented by Albert 2009/08/13
// For the SMC router, the sequence number of first packet of WPS handshake will be 0.
// In this case, this packet will be dropped by recv_decache function if we use the 0x00 as the default value for tid_rxseq variable.
// So, we initialize the tid_rxseq variable as the 0xffff.
for( i = 0; i < 16; i++ )
{
_rtw_memcpy( &psta->sta_recvpriv.rxcache.tid_rxseq[ i ], &wRxSeqInitialValue, 2 );
}
RT_TRACE(_module_rtl871x_sta_mgt_c_,_drv_info_,("alloc number_%d stainfo with hwaddr = %x %x %x %x %x %x \n",
pstapriv->asoc_sta_count , hwaddr[0], hwaddr[1], hwaddr[2],hwaddr[3],hwaddr[4],hwaddr[5]));
init_addba_retry_timer(pstapriv->padapter, psta);
//for A-MPDU Rx reordering buffer control
for(i=0; i < 16 ; i++)
{
preorder_ctrl = &psta->recvreorder_ctrl[i];
preorder_ctrl->padapter = pstapriv->padapter;
preorder_ctrl->enable = _FALSE;
preorder_ctrl->indicate_seq = 0xffff;
preorder_ctrl->wend_b= 0xffff;
//preorder_ctrl->wsize_b = (NR_RECVBUFF-2);
preorder_ctrl->wsize_b = 64;//64;
_rtw_init_queue(&preorder_ctrl->pending_recvframe_queue);
rtw_init_recv_timer(preorder_ctrl);
}
}
exit:
_rtw_spinunlock(&(pfree_sta_queue->lock));
_func_exit_;
return psta;
}
u32 usb_write_port(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *wmem)
{
u32 i, bwritezero = _FALSE;
u32 ac_tag = addr;
u8* ptr;
struct intf_priv * pintfpriv = pintfhdl->pintfpriv;
struct dvobj_priv * pdvobj_priv = (struct dvobj_priv*)pintfpriv->intf_dev;
_adapter * padapter = pdvobj_priv->padapter;
struct xmit_priv * pxmitpriv = &padapter->xmitpriv;
struct xmit_frame * pxmitframe = (struct xmit_frame *)wmem;
LPCUSB_FUNCS usb_funcs_vp = pdvobj_priv->usb_extension._lpUsbFuncs;
USB_PIPE hPipe;
u32 bResult = _FALSE;
_func_enter_;
RT_TRACE( _module_hci_ops_os_c_, _drv_info_, ("+usb_write_port\n"));
#if (CONFIG_PWRCTRL == 1)
if(padapter->pwrctrlpriv.pnp_bstop_trx==_TRUE){
RT_TRACE( _module_hci_ops_os_c_, _drv_err_, ("\npadapter->pwrctrlpriv.pnp_bstop_trx==_TRUE\n"));
}
#endif
if((padapter->bDriverStopped) || (padapter->bSurpriseRemoved) ||(padapter->pwrctrlpriv.pnp_bstop_trx))
{
RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_write_port:( padapter->bDriverStopped ||padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n"));
bResult = _FALSE;
goto exit;
}
RT_TRACE( _module_hci_ops_os_c_, _drv_info_, ("usb_write_port(%u)\n", __LINE__));
for(i=0; i<8; i++)
{
if(pxmitframe->bpending[i] == _FALSE)
{
_rtw_spinlock(&pxmitpriv->lock);
pxmitpriv->txirp_cnt++;
pxmitframe->bpending[i] = _TRUE;
_rtw_spinunlock(&pxmitpriv->lock);
pxmitframe->sz[i] = cnt;
pxmitframe->ac_tag[i] = ac_tag;
break;
}
}
//TODO:
if (pdvobj_priv->ishighspeed)
{
if(cnt> 0 && cnt%512 == 0)
{
RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("ishighspeed, cnt=%d\n", cnt));
// cnt=cnt+1;
bwritezero = _TRUE;
}
}
else
{
if(cnt > 0 && cnt%64 == 0)
{
RT_TRACE(_module_hci_ops_os_c_,_drv_info_,("cnt=%d\n", cnt));
// cnt=cnt+1;
bwritezero = _TRUE;
}
}
RT_TRACE( _module_hci_ops_os_c_, _drv_info_, ("usb_write_port: pipe handle convert\n"));
//translate DMA FIFO addr to pipehandle
hPipe = ffaddr2pipehdl(pdvobj_priv, addr);
#if 0
// for tx fifo, the maximum payload number is 8,
// we workaround this issue here by separate whole fifo into 8 segments.
if (cnt <= 500)
cnt = 500;
#endif
RT_TRACE( _module_hci_ops_os_c_, _drv_info_,
("usb_write_port(%u): pxmitframe %X pxmitframe->padapter %X\n",__LINE__, pxmitframe, pxmitframe->padapter));
pxmitpriv->usb_transfer_write_port = (*usb_funcs_vp->lpIssueBulkTransfer)(
hPipe, usb_write_port_complete,
pxmitframe, USB_OUT_TRANSFER,
cnt, pxmitframe->mem_addr, 0);
RT_TRACE( _module_hci_ops_os_c_, _drv_info_, ("%s(%u)\n",__FUNCTION__, __LINE__));
ptr=(u8 *)&pxmitframe->mem;
#if 0
if (pdvobj_priv->ishighspeed)
{
ptr=ptr+512;
}
else
{
ptr=ptr+64;
}
#endif
if(bwritezero == _TRUE)
{
usb_bulkout_zero(pintfhdl, addr);
}
// if (!pxmitframe->usb_transfer_xmit)
// padapter->bSurpriseRemoved=_TRUE;
RT_TRACE( _module_hci_ops_os_c_, _drv_info_, ("%s(%u)\n",__FUNCTION__, __LINE__));
bResult = _SUCCESS;
exit:
_func_exit_;
return bResult;
}
/*! \brief USB RX IRP Complete Routine.
@param Context pointer of RT_RFD
*/
u32 usb_read_port(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *rmem)
{
struct intf_priv *pintfpriv = pintfhdl->pintfpriv;
struct dvobj_priv *pdvobj_priv = (struct dvobj_priv*)pintfpriv->intf_dev;
_adapter *adapter = (_adapter *)pdvobj_priv->padapter;
struct recv_priv *precvpriv = &adapter->recvpriv;
struct recv_buf *precvbuf = (struct recv_buf *)rmem;
DWORD dwErr = ERROR_SUCCESS ;
DWORD dwBytesTransferred = 0 ;
USB_TRANSFER hTransfer = NULL;
USB_PIPE hPipe;
LPCUSB_FUNCS usb_funcs_vp = pdvobj_priv->usb_extension._lpUsbFuncs;
_func_enter_;
RT_TRACE( _module_hci_ops_os_c_, _drv_info_, ("usb_read_port(%u)\n", __LINE__));
#if (CONFIG_PWRCTRL == 1)
if (adapter->pwrctrlpriv.pnp_bstop_trx)
{
return _FALSE;
}
#endif
if(adapter->bDriverStopped || adapter->bSurpriseRemoved)
{
RT_TRACE(_module_hci_ops_os_c_, _drv_info_,("usb_read_port:( padapter->bDriverStopped ||padapter->bSurpriseRemoved)!!!\n"));
return _FALSE;
}
if(precvbuf !=NULL)
{
// get a recv buffer
rtw_init_recvbuf(adapter, precvbuf);
_rtw_spinlock(&precvpriv->lock);
precvpriv->rx_pending_cnt++;
precvbuf->irp_pending = _TRUE;
_rtw_spinunlock(&precvpriv->lock);
//translate DMA FIFO addr to pipehandle
hPipe = ffaddr2pipehdl(pdvobj_priv, addr);
RT_TRACE( _module_hci_ops_os_c_, _drv_info_, ("usb_read_port(%u)\n", __LINE__));
precvbuf->usb_transfer_read_port = (*usb_funcs_vp->lpIssueBulkTransfer)(
hPipe,
usb_read_port_complete,
precvbuf,
USB_IN_TRANSFER|USB_SHORT_TRANSFER_OK,
MAX_RECVBUF_SZ,
precvbuf->pbuf,
0);
if(precvbuf->usb_transfer_read_port)
{
// GetTransferStatus(usb_funcs_vp, hTransfer, &dwBytesTransferred,&UsbRc);
// CloseTransferHandle(usb_funcs_vp, hTransfer);
}
else
{
dwErr = GetLastError();
//RT_TRACE( _module_hci_ops_os_c_, _drv_err_, ("usb_read_port ERROR : %d\n", dwErr));
}
// if ( USB_NO_ERROR != UsbRc && ERROR_SUCCESS == dwErr) {
// dwErr = ERROR_GEN_FAILURE;
// }
if ( ERROR_SUCCESS != dwErr ) {
SetLastError(dwErr);
RT_TRACE( _module_hci_ops_os_c_, _drv_err_, ("usb_read_port ERROR : %d\n", dwErr));
}
RT_TRACE( _module_hci_ops_os_c_, _drv_info_, ("-usb_read_port(%u)\n", __LINE__));
}
else // if(precvbuf !=NULL)
{
RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port:precv_frame ==NULL\n"));
}
return _TRUE;
}
