void usb_write_mem(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *wmem) { _irqL irqL; int status, pipe; struct io_req *pio_req=NULL; _adapter *padapter = (_adapter *)pintfhdl->adapter; struct intf_priv *pintfpriv = pintfhdl->pintfpriv; struct io_queue *pio_queue = (struct io_queue *)padapter->pio_queue; struct dvobj_priv *pdvobj = (struct dvobj_priv *)pintfpriv->intf_dev; struct usb_device *pusbd = pdvobj->pusbdev; PURB piorw_urb = pintfpriv->piorw_urb; _func_enter_; RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("+usb_write_mem\n")); if((padapter->bDriverStopped) || (padapter->bSurpriseRemoved) ||(padapter->pwrctrlpriv.pnp_bstop_trx)) { RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_write_mem:( padapter->bDriverStopped ||padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n")); goto exit; } //translate DMA FIFO addr to pipehandle pipe = ffaddr2pipehdl(pdvobj, addr); if(pipe==0) { RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_write_mem, pipe=%x\n", pipe)); goto exit; } usb_fill_bulk_urb(piorw_urb, pusbd, pipe, wmem, cnt, usb_write_mem_complete, pio_queue); //piorw_urb->transfer_flags |= URB_ZERO_PACKET; status = usb_submit_urb(piorw_urb, GFP_ATOMIC); if (!status) { } else { //TODO: RT_TRACE(_module_rtl871x_mlme_c_,_drv_err_,("usb_write_mem(): usb_submit_urb err, status=%x\n", status)); } _down_sema(&pintfpriv->io_retevt); RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("-usb_write_mem\n")); exit: _func_exit_; }
u32 usb_read_interrupt(struct intf_hdl *pintfhdl, u32 addr) { int err; unsigned int pipe; u32 ret = _SUCCESS; _adapter *adapter = pintfhdl->padapter; struct dvobj_priv *pdvobj = adapter_to_dvobj(adapter); struct recv_priv *precvpriv = &adapter->recvpriv; struct usb_device *pusbd = pdvobj->pusbdev; if (RTW_CANNOT_RX(adapter)) { return _FAIL; } /*translate DMA FIFO addr to pipehandle*/ pipe = ffaddr2pipehdl(pdvobj, addr); usb_fill_int_urb(precvpriv->int_in_urb, pusbd, pipe, precvpriv->int_in_buf, INTERRUPT_MSG_FORMAT_LEN, usb_read_interrupt_complete, adapter, 1); err = usb_submit_urb(precvpriv->int_in_urb, GFP_ATOMIC); if ((err) && (err != (-EPERM))) { RTW_INFO("cannot submit interrupt in-token(err = 0x%08x), urb_status = %d\n", err, precvpriv->int_in_urb->status); ret = _FAIL; } return ret; }
static inline u32 usb_bulkout_zero(struct intf_hdl *pintfhdl, u32 addr) { int pipe, status, len; u32 ret; unsigned char *pbuf; struct zero_bulkout_context *pcontext; PURB purb = NULL; _adapter *padapter = (_adapter *)pintfhdl->padapter; struct dvobj_priv *pdvobj = adapter_to_dvobj(padapter); //struct pwrctrl_priv *pwrctl = dvobj_to_pwrctl(pdvobj); struct usb_device *pusbd = pdvobj->pusbdev; //DBG_871X("%s\n", __func__); if (RTW_CANNOT_TX(padapter)) { return _FAIL; } pcontext = (struct zero_bulkout_context *)rtw_zmalloc(sizeof(struct zero_bulkout_context)); if (pcontext == NULL) { return _FAIL; } pbuf = (unsigned char *)rtw_zmalloc(sizeof(int)); purb = usb_alloc_urb(0, GFP_ATOMIC); //translate DMA FIFO addr to pipehandle pipe = ffaddr2pipehdl(pdvobj, addr); len = 0; pcontext->pbuf = pbuf; pcontext->purb = purb; pcontext->pirp = NULL; pcontext->padapter = padapter; //translate DMA FIFO addr to pipehandle //pipe = ffaddr2pipehdl(pdvobj, addr); usb_fill_bulk_urb(purb, pusbd, pipe, pbuf, len, usb_bulkout_zero_complete, pcontext);//context is pcontext status = usb_submit_urb(purb, GFP_ATOMIC); if (!status) { ret= _SUCCESS; } else { ret= _FAIL; } return _SUCCESS; }
u32 usb_bulkout_zero(struct intf_hdl *pintfhdl, u32 addr) { int pipe, status, len; u32 ret; unsigned char *pbuf; struct zero_bulkout_context *pcontext; PURB purb = NULL; _adapter *padapter = (_adapter *)pintfhdl->adapter; struct dvobj_priv *pdvobj = (struct dvobj_priv *)&padapter->dvobjpriv; struct usb_device *pusbd = pdvobj->pusbdev; //printk("+usb_bulkout_zero\n"); if((padapter->bDriverStopped) || (padapter->bSurpriseRemoved) ||(padapter->pwrctrlpriv.pnp_bstop_trx)) { return _FAIL; } pcontext = (struct zero_bulkout_context *)_malloc(sizeof(struct zero_bulkout_context)); pbuf = (unsigned char *)_malloc(sizeof(int)); purb = usb_alloc_urb(0, GFP_ATOMIC); len = 0; pcontext->pbuf = pbuf; pcontext->purb = purb; pcontext->pirp = NULL; pcontext->padapter = padapter; //translate DMA FIFO addr to pipehandle pipe = ffaddr2pipehdl(pdvobj, addr); usb_fill_bulk_urb(purb, pusbd, pipe, pbuf, len, usb_bulkout_zero_complete, pcontext);//context is pcontext status = usb_submit_urb(purb, GFP_ATOMIC); if (!status) { ret= _SUCCESS; } else { ret= _FAIL; } return _SUCCESS; }
u32 r8712_usb_read_port(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *rmem) { unsigned int pipe; int err; u32 tmpaddr = 0; int alignment = 0; u32 ret = _SUCCESS; struct urb *purb = NULL; struct recv_buf *precvbuf = (struct recv_buf *)rmem; struct intf_priv *pintfpriv = pintfhdl->pintfpriv; struct dvobj_priv *pdvobj = (struct dvobj_priv *)pintfpriv->intf_dev; struct _adapter *adapter = pdvobj->padapter; struct recv_priv *precvpriv = &adapter->recvpriv; struct usb_device *pusbd = pdvobj->pusbdev; if (adapter->bDriverStopped || adapter->bSurpriseRemoved || adapter->pwrctrlpriv.pnp_bstop_trx || !precvbuf) return _FAIL; r8712_init_recvbuf(adapter, precvbuf); /* Try to use skb from the free queue */ precvbuf->pskb = skb_dequeue(&precvpriv->free_recv_skb_queue); if (!precvbuf->pskb) { precvbuf->pskb = netdev_alloc_skb(adapter->pnetdev, MAX_RECVBUF_SZ + RECVBUFF_ALIGN_SZ); if (!precvbuf->pskb) return _FAIL; tmpaddr = (addr_t)precvbuf->pskb->data; alignment = tmpaddr & (RECVBUFF_ALIGN_SZ - 1); skb_reserve(precvbuf->pskb, (RECVBUFF_ALIGN_SZ - alignment)); precvbuf->phead = precvbuf->pskb->head; precvbuf->pdata = precvbuf->pskb->data; precvbuf->ptail = skb_tail_pointer(precvbuf->pskb); precvbuf->pend = skb_end_pointer(precvbuf->pskb); precvbuf->pbuf = precvbuf->pskb->data; } else { /* skb is reused */ precvbuf->phead = precvbuf->pskb->head; precvbuf->pdata = precvbuf->pskb->data; precvbuf->ptail = skb_tail_pointer(precvbuf->pskb); precvbuf->pend = skb_end_pointer(precvbuf->pskb); precvbuf->pbuf = precvbuf->pskb->data; } purb = precvbuf->purb; /* translate DMA FIFO addr to pipehandle */ pipe = ffaddr2pipehdl(pdvobj, addr); usb_fill_bulk_urb(purb, pusbd, pipe, precvbuf->pbuf, MAX_RECVBUF_SZ, r8712_usb_read_port_complete, precvbuf); err = usb_submit_urb(purb, GFP_ATOMIC); if ((err) && (err != (-EPERM))) ret = _FAIL; return ret; }
u32 usb_read_port(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *rmem) { int err; unsigned int pipe; u32 ret = _SUCCESS; PURB purb = NULL; struct recv_buf *precvbuf = (struct recv_buf *)rmem; _adapter *adapter = pintfhdl->padapter; struct dvobj_priv *pdvobj = adapter_to_dvobj(adapter); struct pwrctrl_priv *pwrctl = dvobj_to_pwrctl(pdvobj); struct recv_priv *precvpriv = &adapter->recvpriv; struct usb_device *pusbd = pdvobj->pusbdev; _func_enter_; if (RTW_CANNOT_RX(adapter) || (precvbuf == NULL)) { RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port:( RTW_CANNOT_RX ) || precvbuf == NULL!!!\n")); return _FAIL; } usb_init_recvbuf(adapter, precvbuf); if(precvbuf->pbuf) { ATOMIC_INC(&(precvpriv->rx_pending_cnt)); purb = precvbuf->purb; //translate DMA FIFO addr to pipehandle pipe = ffaddr2pipehdl(pdvobj, addr); usb_fill_bulk_urb(purb, pusbd, pipe, precvbuf->pbuf, MAX_RECVBUF_SZ, usb_read_port_complete, precvbuf);//context is precvbuf purb->transfer_dma = precvbuf->dma_transfer_addr; purb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; err = usb_submit_urb(purb, GFP_ATOMIC); if((err) && (err != (-EPERM))) { RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("cannot submit rx in-token(err=0x%.8x), URB_STATUS =0x%.8x", err, purb->status)); DBG_8192C("cannot submit rx in-token(err = 0x%08x),urb_status = %d\n",err,purb->status); ret = _FAIL; } } _func_exit_; return ret; }
u32 usb_bulkout_zero(struct intf_hdl *pintfhdl, u32 addr) { struct zero_bulkout_context *pcontext; unsigned char *pbuf; u8 len = 0 ; _adapter *padapter = (_adapter *)pintfhdl->adapter; struct dvobj_priv *pdvobj = (struct dvobj_priv *)&padapter->dvobjpriv; struct xmit_priv * pxmitpriv = &padapter->xmitpriv; LPCUSB_FUNCS usb_funcs_vp = pdvobj->usb_extension._lpUsbFuncs; USB_PIPE hPipe; _func_enter_; if((padapter->bDriverStopped) || (padapter->bSurpriseRemoved) ||(padapter->pwrctrlpriv.pnp_bstop_trx)) { return _FAIL; } pcontext = (struct zero_bulkout_context *)rtw_zmalloc(sizeof(struct zero_bulkout_context)); pbuf = (unsigned char *)rtw_zmalloc(sizeof(int)); len = 0; pcontext->pbuf = pbuf; pcontext->purb = NULL; pcontext->pirp = NULL; pcontext->padapter = padapter; //translate DMA FIFO addr to pipehandle hPipe = ffaddr2pipehdl(pdvobj, addr); pxmitpriv->usb_transfer_write_port = (*usb_funcs_vp->lpIssueBulkTransfer)( hPipe, usb_bulkout_zero_complete, pcontext, USB_OUT_TRANSFER, len, pbuf, 0); _func_exit_; return _SUCCESS; }
static u32 usb_read_interrupt(struct intf_hdl *pintfhdl, u32 addr) { int err; unsigned int pipe; u32 ret = _SUCCESS; _adapter *adapter = pintfhdl->padapter; struct dvobj_priv *pdvobj = adapter_to_dvobj(adapter); struct recv_priv *precvpriv = &adapter->recvpriv; struct usb_device *pusbd = pdvobj->pusbdev; _func_enter_; if (RTW_CANNOT_RX(adapter)) { RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_interrupt:( RTW_CANNOT_RX )!!!\n")); return _FAIL; } //translate DMA FIFO addr to pipehandle pipe = ffaddr2pipehdl(pdvobj, addr); usb_fill_int_urb(precvpriv->int_in_urb, pusbd, pipe, precvpriv->int_in_buf, INTERRUPT_MSG_FORMAT_LEN, usb_read_interrupt_complete, adapter, 1); err = usb_submit_urb(precvpriv->int_in_urb, GFP_ATOMIC); if((err) && (err != (-EPERM))) { DBG_8192C("cannot submit interrupt in-token(err = 0x%08x),urb_status = %d\n",err, precvpriv->int_in_urb->status); ret = _FAIL; } _func_exit_; return ret; }
void r8712_usb_write_mem(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *wmem) { unsigned int pipe; struct _adapter *padapter = (struct _adapter *)pintfhdl->adapter; struct intf_priv *pintfpriv = pintfhdl->pintfpriv; struct io_queue *pio_queue = padapter->pio_queue; struct dvobj_priv *pdvobj = (struct dvobj_priv *)pintfpriv->intf_dev; struct usb_device *pusbd = pdvobj->pusbdev; struct urb *piorw_urb = pintfpriv->piorw_urb; if ((padapter->bDriverStopped) || (padapter->bSurpriseRemoved) || (padapter->pwrctrlpriv.pnp_bstop_trx)) return; /* translate DMA FIFO addr to pipehandle */ pipe = ffaddr2pipehdl(pdvobj, addr); if (pipe == 0) return; usb_fill_bulk_urb(piorw_urb, pusbd, pipe, wmem, cnt, usb_write_mem_complete, pio_queue); usb_submit_urb(piorw_urb, GFP_ATOMIC); wait_for_completion_interruptible(&pintfpriv->io_retevt_comp); }
u32 r8712_usb_write_port(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *wmem) { unsigned long irqL; int i, status; unsigned int pipe; u32 ret, bwritezero; struct urb *purb = NULL; struct _adapter *padapter = (struct _adapter *)pintfhdl->adapter; struct dvobj_priv *pdvobj = (struct dvobj_priv *)&padapter->dvobjpriv; struct xmit_priv *pxmitpriv = &padapter->xmitpriv; struct xmit_frame *pxmitframe = (struct xmit_frame *)wmem; struct usb_device *pusbd = pdvobj->pusbdev; struct pkt_attrib *pattrib = &pxmitframe->attrib; if ((padapter->bDriverStopped) || (padapter->bSurpriseRemoved) || (padapter->pwrctrlpriv.pnp_bstop_trx)) return _FAIL; for (i = 0; i < 8; i++) { if (pxmitframe->bpending[i] == false) { spin_lock_irqsave(&pxmitpriv->lock, irqL); pxmitpriv->txirp_cnt++; pxmitframe->bpending[i] = true; switch (pattrib->priority) { case 1: case 2: pxmitpriv->bkq_cnt++; break; case 4: case 5: pxmitpriv->viq_cnt++; break; case 6: case 7: pxmitpriv->voq_cnt++; break; case 0: case 3: default: pxmitpriv->beq_cnt++; break; } spin_unlock_irqrestore(&pxmitpriv->lock, irqL); pxmitframe->sz[i] = (u16)cnt; purb = pxmitframe->pxmit_urb[i]; break; } } bwritezero = false; if (pdvobj->ishighspeed) { if (cnt > 0 && cnt % 512 == 0) bwritezero = true; } else { if (cnt > 0 && cnt % 64 == 0) bwritezero = true; } /* translate DMA FIFO addr to pipehandle */ pipe = ffaddr2pipehdl(pdvobj, addr); if (pxmitpriv->free_xmitbuf_cnt%NR_XMITBUFF == 0) purb->transfer_flags &= (~URB_NO_INTERRUPT); else purb->transfer_flags |= URB_NO_INTERRUPT; if (bwritezero) cnt += 8; usb_fill_bulk_urb(purb, pusbd, pipe, pxmitframe->mem_addr, cnt, usb_write_port_complete, pxmitframe); /* context is xmit_frame */ status = usb_submit_urb(purb, GFP_ATOMIC); if (!status) ret = _SUCCESS; else ret = _FAIL; return ret; }
u32 usb_write_port(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *wmem) { unsigned long irqL; unsigned int pipe; int status; u32 ret = _FAIL; struct urb *purb = NULL; struct adapter *padapter = (struct adapter *)pintfhdl->padapter; struct dvobj_priv *pdvobj = adapter_to_dvobj(padapter); struct xmit_priv *pxmitpriv = &padapter->xmitpriv; struct xmit_buf *pxmitbuf = (struct xmit_buf *)wmem; struct xmit_frame *pxmitframe = (struct xmit_frame *)pxmitbuf->priv_data; struct usb_device *pusbd = pdvobj->pusbdev; RT_TRACE(_module_hci_ops_os_c_, _drv_err_, ("+usb_write_port\n")); 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")); rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_TX_DENY); goto exit; } spin_lock_irqsave(&pxmitpriv->lock, irqL); switch (addr) { case VO_QUEUE_INX: pxmitpriv->voq_cnt++; pxmitbuf->flags = VO_QUEUE_INX; break; case VI_QUEUE_INX: pxmitpriv->viq_cnt++; pxmitbuf->flags = VI_QUEUE_INX; break; case BE_QUEUE_INX: pxmitpriv->beq_cnt++; pxmitbuf->flags = BE_QUEUE_INX; break; case BK_QUEUE_INX: pxmitpriv->bkq_cnt++; pxmitbuf->flags = BK_QUEUE_INX; break; case HIGH_QUEUE_INX: pxmitbuf->flags = HIGH_QUEUE_INX; break; default: pxmitbuf->flags = MGT_QUEUE_INX; break; } spin_unlock_irqrestore(&pxmitpriv->lock, irqL); purb = pxmitbuf->pxmit_urb[0]; /* translate DMA FIFO addr to pipehandle */ pipe = ffaddr2pipehdl(pdvobj, addr); usb_fill_bulk_urb(purb, pusbd, pipe, pxmitframe->buf_addr, /* pxmitbuf->pbuf */ cnt, usb_write_port_complete, pxmitbuf);/* context is pxmitbuf */ status = usb_submit_urb(purb, GFP_ATOMIC); if (!status) { struct hal_data_8188e *haldata = GET_HAL_DATA(padapter); haldata->srestpriv.last_tx_time = jiffies; } else { rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_WRITE_PORT_ERR); DBG_88E("usb_write_port, status =%d\n", status); RT_TRACE(_module_hci_ops_os_c_, _drv_err_, ("usb_write_port(): usb_submit_urb, status =%x\n", status)); switch (status) { case -ENODEV: padapter->bDriverStopped = true; break; default: break; } goto exit; } ret = _SUCCESS; /* We add the URB_ZERO_PACKET flag to urb so that the host will send the zero packet automatically. */ RT_TRACE(_module_hci_ops_os_c_, _drv_err_, ("-usb_write_port\n")); exit: if (ret != _SUCCESS) rtw_free_xmitbuf(pxmitpriv, pxmitbuf); return ret; }
u32 usb_write_port(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *wmem) { _irqL irqL; unsigned int pipe; int status; u32 ret = _FAIL, bwritezero = _FALSE; PURB purb = NULL; _adapter *padapter = (_adapter *)pintfhdl->padapter; struct dvobj_priv *pdvobj = adapter_to_dvobj(padapter); struct xmit_priv *pxmitpriv = &padapter->xmitpriv; struct xmit_buf *pxmitbuf = (struct xmit_buf *)wmem; struct xmit_frame *pxmitframe = (struct xmit_frame *)pxmitbuf->priv_data; struct usb_device *pusbd = pdvobj->pusbdev; struct pkt_attrib *pattrib = &pxmitframe->attrib; _func_enter_; RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("+usb_write_port\n")); if ((padapter->bDriverStopped) || (padapter->bSurpriseRemoved) ||(padapter->pwrctrlpriv.pnp_bstop_trx)) { #ifdef DBG_TX DBG_871X(" DBG_TX %s:%d bDriverStopped%d, bSurpriseRemoved:%d, pnp_bstop_trx:%d\n",__FUNCTION__, __LINE__ ,padapter->bDriverStopped, padapter->bSurpriseRemoved, padapter->pwrctrlpriv.pnp_bstop_trx ); #endif RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_write_port:( padapter->bDriverStopped ||padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n")); rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_TX_DENY); goto exit; } _enter_critical(&pxmitpriv->lock, &irqL); switch(addr) { case VO_QUEUE_INX: pxmitpriv->voq_cnt++; pxmitbuf->flags = VO_QUEUE_INX; break; case VI_QUEUE_INX: pxmitpriv->viq_cnt++; pxmitbuf->flags = VI_QUEUE_INX; break; case BE_QUEUE_INX: pxmitpriv->beq_cnt++; pxmitbuf->flags = BE_QUEUE_INX; break; case BK_QUEUE_INX: pxmitpriv->bkq_cnt++; pxmitbuf->flags = BK_QUEUE_INX; break; case HIGH_QUEUE_INX: pxmitbuf->flags = HIGH_QUEUE_INX; break; default: pxmitbuf->flags = MGT_QUEUE_INX; break; } _exit_critical(&pxmitpriv->lock, &irqL); purb = pxmitbuf->pxmit_urb[0]; #if 0 if(pdvobj->ishighspeed) { if(cnt> 0 && cnt%512 == 0) { //DBG_8192C("ishighspeed, cnt=%d\n", cnt); bwritezero = _TRUE; } } else { if(cnt > 0 && cnt%64 == 0) { //DBG_8192C("cnt=%d\n", cnt); bwritezero = _TRUE; } } #endif //translate DMA FIFO addr to pipehandle pipe = ffaddr2pipehdl(pdvobj, addr); #ifdef CONFIG_REDUCE_USB_TX_INT if ( (pxmitpriv->free_xmitbuf_cnt%NR_XMITBUFF == 0) || (pxmitbuf->ext_tag == _TRUE) ) { purb->transfer_flags &= (~URB_NO_INTERRUPT); } else { purb->transfer_flags |= URB_NO_INTERRUPT; //DBG_8192C("URB_NO_INTERRUPT "); } #endif usb_fill_bulk_urb(purb, pusbd, pipe, pxmitframe->buf_addr, //= pxmitbuf->pbuf cnt, usb_write_port_complete, pxmitbuf);//context is pxmitbuf #ifdef CONFIG_USE_USB_BUFFER_ALLOC_TX purb->transfer_dma = pxmitbuf->dma_transfer_addr; purb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; purb->transfer_flags |= URB_ZERO_PACKET; #endif // CONFIG_USE_USB_BUFFER_ALLOC_TX #if 0 if (bwritezero) { purb->transfer_flags |= URB_ZERO_PACKET; } #endif status = usb_submit_urb(purb, GFP_ATOMIC); if (!status) { #ifdef DBG_CONFIG_ERROR_DETECT { HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter); pHalData->srestpriv.last_tx_time = rtw_get_current_time(); } #endif } else { rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_WRITE_PORT_ERR); DBG_871X("usb_write_port, status=%d\n", status); RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_write_port(): usb_submit_urb, status=%x\n", status)); switch (status) { case -ENODEV: padapter->bDriverStopped=_TRUE; break; default: break; } goto exit; } ret= _SUCCESS; // Commented by Albert 2009/10/13 // We add the URB_ZERO_PACKET flag to urb so that the host will send the zero packet automatically. /* if(bwritezero == _TRUE) { usb_bulkout_zero(pintfhdl, addr); } */ RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("-usb_write_port\n")); exit: if (ret != _SUCCESS) rtw_free_xmitbuf(pxmitpriv, pxmitbuf); _func_exit_; return ret; }
u32 usb_read_port(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *rmem) { _irqL irqL; int err, pipe; u32 tmpaddr=0; int alignment=0; u32 ret = _SUCCESS; PURB purb = NULL; struct recv_buf *precvbuf = (struct recv_buf *)rmem; struct intf_priv *pintfpriv = pintfhdl->pintfpriv; struct dvobj_priv *pdvobj = (struct dvobj_priv *)pintfpriv->intf_dev; _adapter *adapter = (_adapter *)pdvobj->padapter; struct recv_priv *precvpriv = &adapter->recvpriv; struct usb_device *pusbd = pdvobj->pusbdev; _func_enter_; if(adapter->bDriverStopped || adapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx) { RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port:( padapter->bDriverStopped ||padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n")); return _FAIL; } #ifdef CONFIG_PREALLOC_RECV_SKB if((precvbuf->reuse == _FALSE) || (precvbuf->pskb == NULL)) { if (NULL != (precvbuf->pskb = skb_dequeue(&precvpriv->free_recv_skb_queue))) { precvbuf->reuse = _TRUE; } } #endif if(precvbuf !=NULL) { init_recvbuf(adapter, precvbuf); //re-assign for linux based on skb if((precvbuf->reuse == _FALSE) || (precvbuf->pskb == NULL)) { //precvbuf->pskb = alloc_skb(MAX_RECVBUF_SZ, GFP_ATOMIC);//don't use this after v2.6.25 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)) // http://www.mail-archive.com/[email protected]/msg17214.html precvbuf->pskb = dev_alloc_skb(MAX_RECVBUF_SZ + RECVBUFF_ALIGN_SZ); #else precvbuf->pskb = netdev_alloc_skb(adapter->pnetdev, MAX_RECVBUF_SZ + RECVBUFF_ALIGN_SZ); #endif if(precvbuf->pskb == NULL) { RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("init_recvbuf(): alloc_skb fail!\n")); return _FAIL; } tmpaddr = (u32)precvbuf->pskb->data; alignment = tmpaddr & (RECVBUFF_ALIGN_SZ-1); skb_reserve(precvbuf->pskb, (RECVBUFF_ALIGN_SZ - alignment)); 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//reuse skb { 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; precvbuf->reuse = _FALSE; } //Useless for linux usb driver. //2010-03-10 by Thomas //_enter_critical(&precvpriv->lock, &irqL); //precvpriv->rx_pending_cnt++; //precvbuf->irp_pending = _TRUE; //_exit_critical(&precvpriv->lock, &irqL); purb = precvbuf->purb; //translate DMA FIFO addr to pipehandle pipe = ffaddr2pipehdl(pdvobj, addr); usb_fill_bulk_urb(purb, pusbd, pipe, precvbuf->pbuf, MAX_RECVBUF_SZ, usb_read_port_complete, precvbuf);//context is precvbuf err = usb_submit_urb(purb, GFP_ATOMIC); if((err) && (err != (-EPERM))) { RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("cannot submit rx in-token(err=0x%.8x), URB_STATUS =0x%.8x", err, purb->status)); ret = _FAIL; } } else { RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port:precvbuf ==NULL\n")); ret = _FAIL; } _func_exit_; return ret; }
u32 usb_read_port(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *rmem) { int err; unsigned int pipe; u32 ret = _FAIL; PURB purb = NULL; struct recv_buf *precvbuf = (struct recv_buf *)rmem; _adapter *adapter = pintfhdl->padapter; struct dvobj_priv *pdvobj = adapter_to_dvobj(adapter); //struct pwrctrl_priv *pwrctl = dvobj_to_pwrctl(pdvobj); struct recv_priv *precvpriv = &adapter->recvpriv; struct usb_device *pusbd = pdvobj->pusbdev; _func_enter_; if (RTW_CANNOT_RX(adapter) || (precvbuf == NULL)) { RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port:( RTW_CANNOT_RX ) || precvbuf == NULL!!!\n")); goto exit; } usb_init_recvbuf(adapter, precvbuf); if (precvbuf->pskb == NULL) { SIZE_PTR tmpaddr = 0; SIZE_PTR alignment = 0; if (NULL != (precvbuf->pskb = skb_dequeue(&precvpriv->free_recv_skb_queue))) goto recv_buf_hook; #ifndef CONFIG_FIX_NR_BULKIN_BUFFER precvbuf->pskb = rtw_skb_alloc(MAX_RECVBUF_SZ + RECVBUFF_ALIGN_SZ); #endif if (precvbuf->pskb == NULL) { if (0) DBG_871X("usb_read_port() enqueue precvbuf=%p \n", precvbuf); /* enqueue precvbuf and wait for free skb */ rtw_enqueue_recvbuf(precvbuf, &precvpriv->recv_buf_pending_queue); goto exit; } tmpaddr = (SIZE_PTR)precvbuf->pskb->data; alignment = tmpaddr & (RECVBUFF_ALIGN_SZ-1); skb_reserve(precvbuf->pskb, (RECVBUFF_ALIGN_SZ - alignment)); } recv_buf_hook: precvbuf->phead = precvbuf->pskb->head; precvbuf->pdata = precvbuf->pskb->data; precvbuf->ptail = skb_tail_pointer(precvbuf->pskb); precvbuf->pend = skb_end_pointer(precvbuf->pskb); precvbuf->pbuf = precvbuf->pskb->data; purb = precvbuf->purb; /* translate DMA FIFO addr to pipehandle */ pipe = ffaddr2pipehdl(pdvobj, addr); usb_fill_bulk_urb(purb, pusbd, pipe, precvbuf->pbuf, MAX_RECVBUF_SZ, usb_read_port_complete, precvbuf); err = usb_submit_urb(purb, GFP_ATOMIC); if (err && err != (-EPERM)) { DBG_871X("cannot submit rx in-token(err = 0x%08x),urb_status = %d\n" , err, purb->status); goto exit; } ATOMIC_INC(&(precvpriv->rx_pending_cnt)); ret = _SUCCESS; exit: _func_exit_; return ret; }
u32 usb_write_port(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *wmem) { _irqL irqL; int i, pipe, status; u32 ret, bwritezero; PURB purb = NULL; _adapter *padapter = (_adapter *)pintfhdl->adapter; struct dvobj_priv *pdvobj = (struct dvobj_priv *)&padapter->dvobjpriv; struct xmit_priv *pxmitpriv = &padapter->xmitpriv; struct xmit_frame *pxmitframe = (struct xmit_frame *)wmem; struct usb_device *pusbd = pdvobj->pusbdev; struct pkt_attrib *pattrib = &pxmitframe->attrib; _func_enter_; RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("+usb_write_port\n")); 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")); return _FAIL; } for(i=0; i<8; i++) { if(pxmitframe->bpending[i] == _FALSE) { _enter_critical(&pxmitpriv->lock, &irqL); pxmitpriv->txirp_cnt++; pxmitframe->bpending[i] = _TRUE; switch(pattrib->priority) { case 1: case 2: pxmitpriv->bkq_cnt++; break; case 4: case 5: pxmitpriv->viq_cnt++; break; case 6: case 7: pxmitpriv->voq_cnt++; break; case 0: case 3: default: pxmitpriv->beq_cnt++; break; } _exit_critical(&pxmitpriv->lock, &irqL); pxmitframe->sz[i] = (u16)cnt; purb = pxmitframe->pxmit_urb[i]; break; } } bwritezero = _FALSE; if(pdvobj->ishighspeed) { if(cnt> 0 && cnt%512 == 0) { //printk("ishighspeed, cnt=%d\n", cnt); bwritezero = _TRUE; } } else { if(cnt > 0 && cnt%64 == 0) { //printk("cnt=%d\n", cnt); bwritezero = _TRUE; } } //translate DMA FIFO addr to pipehandle pipe = ffaddr2pipehdl(pdvobj, addr); #ifdef CONFIG_REDUCE_USB_TX_INT //if ( (pxmitpriv->free_xmitbuf_cnt%2 == 0)) if ( pxmitpriv->free_xmitbuf_cnt%NR_XMITBUFF == 0 ) { purb->transfer_flags &= (~URB_NO_INTERRUPT); } else { purb->transfer_flags |= URB_NO_INTERRUPT; //printk("URB_NO_INTERRUPT "); } #endif if ( bwritezero ) { cnt += 8; } usb_fill_bulk_urb(purb, pusbd, pipe, pxmitframe->mem_addr, cnt, usb_write_port_complete, pxmitframe);//context is xmit_frame status = usb_submit_urb(purb, GFP_ATOMIC); if (!status) { ret= _SUCCESS; } else { RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_write_port(): usb_submit_urb, status=%x\n", status)); ret= _FAIL; } // Commented by Albert 2009/10/13 // We add the URB_ZERO_PACKET flag to urb so that the host will send the zero packet automatically. /* if(bwritezero == _TRUE) { usb_bulkout_zero(pintfhdl, addr); } */ _func_exit_; RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("-usb_write_port\n")); return ret; }
u32 usb_write_port(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *wmem) { _irqL irqL; unsigned int pipe; int status; u32 ret = _FAIL, bwritezero = _FALSE; PURB purb = NULL; _adapter *padapter = (_adapter *)pintfhdl->padapter; struct dvobj_priv *pdvobj = adapter_to_dvobj(padapter); struct pwrctrl_priv *pwrctl = dvobj_to_pwrctl(pdvobj); struct xmit_priv *pxmitpriv = &padapter->xmitpriv; struct xmit_buf *pxmitbuf = (struct xmit_buf *)wmem; struct xmit_frame *pxmitframe = (struct xmit_frame *)pxmitbuf->priv_data; struct usb_device *pusbd = pdvobj->pusbdev; struct pkt_attrib *pattrib = &pxmitframe->attrib; if (RTW_CANNOT_TX(padapter)) { #ifdef DBG_TX RTW_INFO(" DBG_TX %s:%d bDriverStopped%s, bSurpriseRemoved:%s\n", __func__, __LINE__ , rtw_is_drv_stopped(padapter) ? "True" : "False" , rtw_is_surprise_removed(padapter) ? "True" : "False"); #endif rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_TX_DENY); goto exit; } _enter_critical(&pxmitpriv->lock, &irqL); switch (addr) { case VO_QUEUE_INX: pxmitpriv->voq_cnt++; pxmitbuf->flags = VO_QUEUE_INX; break; case VI_QUEUE_INX: pxmitpriv->viq_cnt++; pxmitbuf->flags = VI_QUEUE_INX; break; case BE_QUEUE_INX: pxmitpriv->beq_cnt++; pxmitbuf->flags = BE_QUEUE_INX; break; case BK_QUEUE_INX: pxmitpriv->bkq_cnt++; pxmitbuf->flags = BK_QUEUE_INX; break; case HIGH_QUEUE_INX: pxmitbuf->flags = HIGH_QUEUE_INX; break; default: pxmitbuf->flags = MGT_QUEUE_INX; break; } _exit_critical(&pxmitpriv->lock, &irqL); purb = pxmitbuf->pxmit_urb[0]; /* translate DMA FIFO addr to pipehandle */ #ifdef RTW_HALMAC pipe = ffaddr2pipehdl(pdvobj, pxmitbuf->bulkout_id); #else pipe = ffaddr2pipehdl(pdvobj, addr); #endif #ifdef CONFIG_REDUCE_USB_TX_INT if ((pxmitpriv->free_xmitbuf_cnt % NR_XMITBUFF == 0) || (pxmitbuf->buf_tag > XMITBUF_DATA)) purb->transfer_flags &= (~URB_NO_INTERRUPT); else { purb->transfer_flags |= URB_NO_INTERRUPT; /* RTW_INFO("URB_NO_INTERRUPT "); */ } #endif usb_fill_bulk_urb(purb, pusbd, pipe, pxmitframe->buf_addr, /* = pxmitbuf->pbuf */ cnt, usb_write_port_complete, pxmitbuf);/* context is pxmitbuf */ #ifdef CONFIG_USE_USB_BUFFER_ALLOC_TX purb->transfer_dma = pxmitbuf->dma_transfer_addr; purb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; purb->transfer_flags |= URB_ZERO_PACKET; #endif /* CONFIG_USE_USB_BUFFER_ALLOC_TX */ #ifdef USB_PACKET_OFFSET_SZ #if (USB_PACKET_OFFSET_SZ == 0) purb->transfer_flags |= URB_ZERO_PACKET; #endif #endif #if 0 if (bwritezero) purb->transfer_flags |= URB_ZERO_PACKET; #endif status = usb_submit_urb(purb, GFP_ATOMIC); if (!status) { #ifdef DBG_CONFIG_ERROR_DETECT { HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter); pHalData->srestpriv.last_tx_time = rtw_get_current_time(); } #endif } else { rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_WRITE_PORT_ERR); RTW_INFO("usb_write_port, status=%d\n", status); switch (status) { case -ENODEV: rtw_set_drv_stopped(padapter); break; default: break; } goto exit; } ret = _SUCCESS; /* Commented by Albert 2009/10/13 * We add the URB_ZERO_PACKET flag to urb so that the host will send the zero packet automatically. */ /* if(bwritezero == _TRUE) { usb_bulkout_zero(pintfhdl, addr); } */ exit: if (ret != _SUCCESS) rtw_free_xmitbuf(pxmitpriv, pxmitbuf); return ret; }
/*! \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; }
u32 usb_write_port(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *wmem) { _irqL irqL; unsigned int pipe; int status; u32 ret = _FAIL, bwritezero = _FALSE; PURB purb = NULL; _adapter *padapter = (_adapter *)pintfhdl->padapter; struct dvobj_priv *pdvobj = adapter_to_dvobj(padapter); struct pwrctrl_priv *pwrctl = dvobj_to_pwrctl(pdvobj); struct xmit_priv *pxmitpriv = &padapter->xmitpriv; struct xmit_buf *pxmitbuf = (struct xmit_buf *)wmem; struct xmit_frame *pxmitframe = (struct xmit_frame *)pxmitbuf->priv_data; struct usb_device *pusbd = pdvobj->pusbdev; struct pkt_attrib *pattrib = &pxmitframe->attrib; RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("+usb_write_port\n")); if (RTW_CANNOT_TX(padapter)) { #ifdef DBG_TX DBG_871X(" DBG_TX %s:%d bDriverStopped%d, bSurpriseRemoved:%d\n",__FUNCTION__, __LINE__ ,padapter->bDriverStopped, padapter->bSurpriseRemoved); #endif RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_write_port:( padapter->bDriverStopped ||padapter->bSurpriseRemoved )!!!\n")); rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_TX_DENY); goto exit; } SPIN_LOCK_IRQ(pxmitpriv->lock, &irqL); switch(addr) { case VO_QUEUE_INX: pxmitpriv->voq_cnt++; pxmitbuf->flags = VO_QUEUE_INX; break; case VI_QUEUE_INX: pxmitpriv->viq_cnt++; pxmitbuf->flags = VI_QUEUE_INX; break; case BE_QUEUE_INX: pxmitpriv->beq_cnt++; pxmitbuf->flags = BE_QUEUE_INX; break; case BK_QUEUE_INX: pxmitpriv->bkq_cnt++; pxmitbuf->flags = BK_QUEUE_INX; break; case HIGH_QUEUE_INX: pxmitbuf->flags = HIGH_QUEUE_INX; break; default: pxmitbuf->flags = MGT_QUEUE_INX; break; } SPIN_UNLOCK_IRQ(pxmitpriv->lock, &irqL); purb = pxmitbuf->pxmit_urb[0]; //translate DMA FIFO addr to pipehandle pipe = ffaddr2pipehdl(pdvobj, addr); #ifdef CONFIG_REDUCE_USB_TX_INT if ( (pxmitpriv->free_xmitbuf_cnt%NR_XMITBUFF == 0) || (pxmitbuf->buf_tag > XMITBUF_DATA) ) { purb->transfer_flags &= (~URB_NO_INTERRUPT); } else { purb->transfer_flags |= URB_NO_INTERRUPT; //DBG_8192C("URB_NO_INTERRUPT "); } #endif usb_fill_bulk_urb(purb, pusbd, pipe, pxmitframe->buf_addr, //= pxmitbuf->pbuf cnt, usb_write_port_complete, pxmitbuf);//context is pxmitbuf #ifdef CONFIG_USE_USB_BUFFER_ALLOC_TX purb->transfer_dma = pxmitbuf->dma_transfer_addr; purb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; purb->transfer_flags |= URB_ZERO_PACKET; #endif // CONFIG_USE_USB_BUFFER_ALLOC_TX #ifdef USB_PACKET_OFFSET_SZ #if (USB_PACKET_OFFSET_SZ == 0) purb->transfer_flags |= URB_ZERO_PACKET; #endif #endif status = usb_submit_urb(purb, GFP_ATOMIC); if (!status) { #ifdef DBG_CONFIG_ERROR_DETECT { HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter); pHalData->srestpriv.last_tx_time = rtw_get_current_time(); } #endif } else { rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_WRITE_PORT_ERR); DBG_871X("usb_write_port, status=%d\n", status); RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_write_port(): usb_submit_urb, status=%x\n", status)); switch (status) { case -ENODEV: padapter->bDriverStopped=_TRUE; break; default: break; } goto exit; } ret= _SUCCESS; RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("-usb_write_port\n")); exit: if (ret != _SUCCESS) rtw_free_xmitbuf(pxmitpriv, pxmitbuf); return ret; }
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; }
void usb_write_mem(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *wmem) { NTSTATUS NtStatus = STATUS_SUCCESS; USB_PIPE hPipe; _irqL irqL; int fComplete = _FALSE; DWORD dwBytes = 0; DWORD dwErr = USB_CANCELED_ERROR; struct io_req *pio_req; _adapter *adapter = (_adapter *)pintfhdl->adapter; struct intf_priv *pintfpriv = pintfhdl->pintfpriv; struct dvobj_priv * pdvobj_priv = (struct dvobj_priv*)pintfpriv->intf_dev; struct xmit_priv *pxmitpriv = &adapter->xmitpriv; struct io_queue *pio_queue = (struct io_queue *)adapter->pio_queue; LPCUSB_FUNCS usb_funcs_vp = pdvobj_priv->usb_extension._lpUsbFuncs; _func_enter_; RT_TRACE( _module_hci_ops_os_c_, _drv_info_, ("usb_write_mem(%u) pintfhdl %p wmem %p\n", __LINE__, pintfhdl, wmem)); // fetch a io_request from the io_queue pio_req = alloc_ioreq(pio_queue); if ((pio_req == NULL)||(adapter->bSurpriseRemoved)) { RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("async_irp_write32 : pio_req =0x%x adapter->bSurpriseRemoved=0x%x",pio_req,adapter->bSurpriseRemoved )); goto exit; } _enter_critical_bh(&(pio_queue->lock), &irqL); // insert the io_request into processing io_queue rtw_list_insert_tail(&(pio_req->list),&(pio_queue->processing)); if((adapter->bDriverStopped) || (adapter->bSurpriseRemoved) ||(adapter->pwrctrlpriv.pnp_bstop_trx)) { RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("\npadapter->pwrctrlpriv.pnp_bstop_trx==_TRUE\n")); goto exit; } //translate DMA FIFO addr to pipehandle hPipe = ffaddr2pipehdl(pdvobj_priv, addr); RT_TRACE( _module_hci_ops_os_c_, _drv_info_,("usb_write_mem(%u)\n",__LINE__)); pio_req->usb_transfer_write_mem = (*usb_funcs_vp->lpIssueBulkTransfer)( hPipe, usb_write_mem_complete, pio_queue, USB_OUT_TRANSFER, cnt, wmem, 0); #if 0 (*usb_funcs_vp->lpGetTransferStatus)(pio_req->usb_transfer_write_mem , &dwBytes, &dwErr); while( fComplete != _TRUE) { fComplete = (*usb_funcs_vp->lpIsTransferComplete)(pio_req->usb_transfer_write_mem); if(fComplete==_TRUE) { (*usb_funcs_vp->lpCloseTransfer)(pio_req->usb_transfer_write_mem ); RT_TRACE( _module_hci_ops_os_c_, _drv_err_, ("usb_write_mem finished\n")); break; } else { RT_TRACE( _module_hci_ops_os_c_, _drv_err_, ("usb_write_mem not yet finished %X\n", pio_req->usb_transfer_write_mem)); rtw_msleep_os(10); } } #endif // _rtw_down_sema(&pio_req->sema); RT_TRACE( _module_hci_ops_os_c_, _drv_info_, ("-usb_write_mem(%X)\n",pio_req->usb_transfer_write_mem)); _exit_critical_bh(&(pio_queue->lock), &irqL); _rtw_down_sema(&pio_req->sema); free_ioreq(pio_req, pio_queue); exit: _func_exit_; return; }