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; }