drivers/net/wireless/rockchip_wlan/rtl8188eu/os_dep/linux/usb_ops_linux.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of version 2 of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  17  *
  18  *******************************************************************************/
  19 #define _USB_OPS_LINUX_C_
  20
  21 #include <drv_types.h>
  22 #include <hal_data.h>
  23 #include <rtw_sreset.h>
  24
  25 struct rtw_async_write_data {
  26         u8 data[VENDOR_CMD_MAX_DATA_LEN];
  27         struct usb_ctrlrequest dr;
  28 };
  29
  30 int usbctrl_vendorreq(struct intf_hdl *pintfhdl, u8 request, u16 value, u16 index, void *pdata, u16 len, u8 requesttype)
  31 {
  32         _adapter        *padapter = pintfhdl->padapter;
  33         struct dvobj_priv  *pdvobjpriv = adapter_to_dvobj(padapter);
  34         struct pwrctrl_priv *pwrctl = dvobj_to_pwrctl(pdvobjpriv);
  35         struct usb_device *udev=pdvobjpriv->pusbdev;
  36
  37         unsigned int pipe;
  38         int status = 0;
  39         u32 tmp_buflen=0;
  40         u8 reqtype;
  41         u8 *pIo_buf;
  42         int vendorreq_times = 0;
  43
  44         #ifdef CONFIG_USB_VENDOR_REQ_BUFFER_DYNAMIC_ALLOCATE
  45         u8 *tmp_buf;
  46         #else // use stack memory
  47         u8 tmp_buf[MAX_USB_IO_CTL_SIZE];
  48         #endif
  49
  50 #ifdef CONFIG_CONCURRENT_MODE
  51         if(padapter->adapter_type > PRIMARY_ADAPTER)
  52         {
  53                 padapter = padapter->pbuddy_adapter;
  54                 pdvobjpriv = adapter_to_dvobj(padapter);
  55                 udev = pdvobjpriv->pusbdev;
  56         }
  57 #endif
  58
  59         //DBG_871X("%s %s:%d\n",__FUNCTION__, current->comm, current->pid);
  60
  61         if (RTW_CANNOT_IO(padapter)){
  62                 RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usbctrl_vendorreq:(RTW_CANNOT_IO)!!!\n"));
  63                 status = -EPERM;
  64                 goto exit;
  65         }
  66
  67         if(len>MAX_VENDOR_REQ_CMD_SIZE){
  68                 DBG_8192C( "[%s] Buffer len error ,vendor request failed\n", __FUNCTION__ );
  69                 status = -EINVAL;
  70                 goto exit;
  71         }
  72
  73         #ifdef CONFIG_USB_VENDOR_REQ_MUTEX
  74         _enter_critical_mutex(&pdvobjpriv->usb_vendor_req_mutex, NULL);
  75         #endif
  76
  77
  78         // Acquire IO memory for vendorreq
  79 #ifdef CONFIG_USB_VENDOR_REQ_BUFFER_PREALLOC
  80         pIo_buf = pdvobjpriv->usb_vendor_req_buf;
  81 #else
  82         #ifdef CONFIG_USB_VENDOR_REQ_BUFFER_DYNAMIC_ALLOCATE
  83         tmp_buf = rtw_malloc( (u32) len + ALIGNMENT_UNIT);
  84         tmp_buflen =  (u32)len + ALIGNMENT_UNIT;
  85         #else // use stack memory
  86         tmp_buflen = MAX_USB_IO_CTL_SIZE;
  87         #endif
  88
  89         // Added by Albert 2010/02/09
  90         // For mstar platform, mstar suggests the address for USB IO should be 16 bytes alignment.
  91         // Trying to fix it here.
  92         pIo_buf = (tmp_buf==NULL)?NULL:tmp_buf + ALIGNMENT_UNIT -((SIZE_PTR)(tmp_buf) & 0x0f );
  93 #endif
  94
  95         if ( pIo_buf== NULL) {
  96                 DBG_8192C( "[%s] pIo_buf == NULL \n", __FUNCTION__ );
  97                 status = -ENOMEM;
  98                 goto release_mutex;
  99         }
 100
 101         while(++vendorreq_times<= MAX_USBCTRL_VENDORREQ_TIMES)
 102         {
 103                 _rtw_memset(pIo_buf, 0, len);
 104
 105                 if (requesttype == 0x01)
 106                 {
 107                         pipe = usb_rcvctrlpipe(udev, 0);//read_in
 108                         reqtype =  REALTEK_USB_VENQT_READ;
 109                 }
 110                 else
 111                 {
 112                         pipe = usb_sndctrlpipe(udev, 0);//write_out
 113                         reqtype =  REALTEK_USB_VENQT_WRITE;
 114                         _rtw_memcpy( pIo_buf, pdata, len);
 115                 }
 116
 117                 status = rtw_usb_control_msg(udev, pipe, request, reqtype, value, index, pIo_buf, len, RTW_USB_CONTROL_MSG_TIMEOUT);
 118
 119                 if ( status == len)   // Success this control transfer.
 120                 {
 121                         rtw_reset_continual_io_error(pdvobjpriv);
 122                         if ( requesttype == 0x01 )
 123                         {   // For Control read transfer, we have to copy the read data from pIo_buf to pdata.
 124                                 _rtw_memcpy( pdata, pIo_buf,  len );
 125                         }
 126                 }
 127                 else { // error cases
 128                         DBG_8192C("reg 0x%x, usb %s %u fail, status:%d value=0x%x, vendorreq_times:%d\n"
 129                                 , value,(requesttype == 0x01)?"read":"write" , len, status, *(u32*)pdata, vendorreq_times);
 130
 131                         if (status < 0) {
 132                                 if(status == (-ESHUTDOWN)       || status == -ENODEV    )
 133                                 {
 134                                         rtw_set_surprise_removed(padapter);
 135                                 } else {
 136                                         #ifdef DBG_CONFIG_ERROR_DETECT
 137                                         {
 138                                                 HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
 139                                                 pHalData->srestpriv.Wifi_Error_Status = USB_VEN_REQ_CMD_FAIL;
 140                                         }
 141                                         #endif
 142                                 }
 143                         }
 144                         else // status != len && status >= 0
 145                         {
 146                                 if(status > 0) {
 147                                         if ( requesttype == 0x01 )
 148                                         {   // For Control read transfer, we have to copy the read data from pIo_buf to pdata.
 149                                                 _rtw_memcpy( pdata, pIo_buf,  len );
 150                                         }
 151                                 }
 152                         }
 153
 154                         if(rtw_inc_and_chk_continual_io_error(pdvobjpriv) == _TRUE ){
 155                                 rtw_set_surprise_removed(padapter);
 156                                 break;
 157                         }
 158
 159                 }
 160
 161                 // firmware download is checksumed, don't retry
 162                 if( (value >= FW_START_ADDRESS ) || status == len )
 163                         break;
 164
 165         }
 166
 167         // release IO memory used by vendorreq
 168         #ifdef CONFIG_USB_VENDOR_REQ_BUFFER_DYNAMIC_ALLOCATE
 169         rtw_mfree(tmp_buf, tmp_buflen);
 170         #endif
 171
 172 release_mutex:
 173         #ifdef CONFIG_USB_VENDOR_REQ_MUTEX
 174         _exit_critical_mutex(&pdvobjpriv->usb_vendor_req_mutex, NULL);
 175         #endif
 176 exit:
 177         return status;
 178
 179 }
 180
 181 #ifdef CONFIG_USB_SUPPORT_ASYNC_VDN_REQ
 182 static void _usbctrl_vendorreq_async_callback(struct urb *urb, struct pt_regs *regs)
 183 {
 184         if (urb) {
 185                 if (urb->context) {
 186                         rtw_mfree(urb->context, sizeof(struct rtw_async_write_data));
 187                 }
 188                 usb_free_urb(urb);
 189         }
 190 }
 191
 192 int _usbctrl_vendorreq_async_write(struct usb_device *udev, u8 request,
 193         u16 value, u16 index, void *pdata, u16 len, u8 requesttype)
 194 {
 195         int rc;
 196         unsigned int pipe;
 197         u8 reqtype;
 198         struct usb_ctrlrequest *dr;
 199         struct urb *urb;
 200         struct rtw_async_write_data *buf;
 201
 202
 203         if (requesttype == VENDOR_READ) {
 204                 pipe = usb_rcvctrlpipe(udev, 0);//read_in
 205                 reqtype =  REALTEK_USB_VENQT_READ;
 206         }
 207         else {
 208                 pipe = usb_sndctrlpipe(udev, 0);//write_out
 209                 reqtype =  REALTEK_USB_VENQT_WRITE;
 210         }
 211
 212         buf = (struct rtl819x_async_write_data *)rtw_zmalloc(sizeof(*buf));
 213         if (!buf) {
 214                 rc = -ENOMEM;
 215                 goto exit;
 216         }
 217
 218         urb = usb_alloc_urb(0, GFP_ATOMIC);
 219         if (!urb) {
 220                 rtw_mfree((u8*)buf, sizeof(*buf));
 221                 rc = -ENOMEM;
 222                 goto exit;
 223         }
 224
 225         dr = &buf->dr;
 226
 227         dr->bRequestType = reqtype;
 228         dr->bRequest = request;
 229         dr->wValue = cpu_to_le16(value);
 230         dr->wIndex = cpu_to_le16(index);
 231         dr->wLength = cpu_to_le16(len);
 232
 233         _rtw_memcpy(buf, pdata, len);
 234
 235         usb_fill_control_urb(urb, udev, pipe, (unsigned char *)dr, buf, len,
 236                 _usbctrl_vendorreq_async_callback, buf);
 237
 238         rc = usb_submit_urb(urb, GFP_ATOMIC);
 239         if (rc < 0) {
 240                 rtw_mfree((u8*)buf, sizeof(*buf));
 241                 usb_free_urb(urb);
 242         }
 243
 244 exit:
 245         return rc;
 246 }
 247
 248
 249 #endif /* CONFIG_USB_SUPPORT_ASYNC_VDN_REQ */
 250
 251 unsigned int ffaddr2pipehdl(struct dvobj_priv *pdvobj, u32 addr)
 252 {
 253         unsigned int pipe=0, ep_num=0;
 254         struct usb_device *pusbd = pdvobj->pusbdev;
 255
 256         if (addr == RECV_BULK_IN_ADDR) {
 257                 pipe=usb_rcvbulkpipe(pusbd, pdvobj->RtInPipe[0]);
 258
 259         } else if (addr == RECV_INT_IN_ADDR) {
 260                 pipe=usb_rcvintpipe(pusbd, pdvobj->RtInPipe[1]);
 261
 262         } else if (addr < HW_QUEUE_ENTRY) {
 263                 ep_num = pdvobj->Queue2Pipe[addr];
 264                 pipe = usb_sndbulkpipe(pusbd, ep_num);
 265         }
 266
 267         return pipe;
 268 }
 269
 270 struct zero_bulkout_context{
 271         void *pbuf;
 272         void *purb;
 273         void *pirp;
 274         void *padapter;
 275 };
 276
 277 static void usb_bulkout_zero_complete(struct urb *purb, struct pt_regs *regs)
 278 {
 279         struct zero_bulkout_context *pcontext = (struct zero_bulkout_context *)purb->context;
 280
 281         //DBG_8192C("+usb_bulkout_zero_complete\n");
 282
 283         if(pcontext)
 284         {
 285                 if(pcontext->pbuf)
 286                 {
 287                         rtw_mfree(pcontext->pbuf, sizeof(int));
 288                 }
 289
 290                 if(pcontext->purb && (pcontext->purb==purb))
 291                 {
 292                         usb_free_urb(pcontext->purb);
 293                 }
 294
 295
 296                 rtw_mfree((u8*)pcontext, sizeof(struct zero_bulkout_context));
 297         }
 298
 299
 300 }
 301
 302 static u32 usb_bulkout_zero(struct intf_hdl *pintfhdl, u32 addr)
 303 {
 304         int pipe, status, len;
 305         u32 ret;
 306         unsigned char *pbuf;
 307         struct zero_bulkout_context *pcontext;
 308         PURB    purb = NULL;
 309         _adapter *padapter = (_adapter *)pintfhdl->padapter;
 310         struct dvobj_priv *pdvobj = adapter_to_dvobj(padapter);
 311         struct pwrctrl_priv *pwrctl = dvobj_to_pwrctl(pdvobj);
 312         struct usb_device *pusbd = pdvobj->pusbdev;
 313
 314         //DBG_871X("%s\n", __func__);
 315
 316
 317         if (RTW_CANNOT_TX(padapter))
 318         {
 319                 return _FAIL;
 320         }
 321
 322
 323         pcontext = (struct zero_bulkout_context *)rtw_zmalloc(sizeof(struct zero_bulkout_context));
 324         if (pcontext == NULL) {
 325                 return _FAIL;
 326         }
 327
 328         pbuf = (unsigned char *)rtw_zmalloc(sizeof(int));
 329         purb = usb_alloc_urb(0, GFP_ATOMIC);
 330
 331         //translate DMA FIFO addr to pipehandle
 332         pipe = ffaddr2pipehdl(pdvobj, addr);
 333
 334         len = 0;
 335         pcontext->pbuf = pbuf;
 336         pcontext->purb = purb;
 337         pcontext->pirp = NULL;
 338         pcontext->padapter = padapter;
 339
 340
 341         //translate DMA FIFO addr to pipehandle
 342         //pipe = ffaddr2pipehdl(pdvobj, addr);
 343
 344         usb_fill_bulk_urb(purb, pusbd, pipe,
 345                                 pbuf,
 346                                 len,
 347                                 usb_bulkout_zero_complete,
 348                                 pcontext);//context is pcontext
 349
 350         status = usb_submit_urb(purb, GFP_ATOMIC);
 351
 352         if (!status)
 353         {
 354                 ret= _SUCCESS;
 355         }
 356         else
 357         {
 358                 ret= _FAIL;
 359         }
 360
 361
 362         return _SUCCESS;
 363
 364 }
 365
 366 void usb_read_mem(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *rmem)
 367 {
 368
 369 }
 370
 371 void usb_write_mem(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *wmem)
 372 {
 373
 374 }
 375
 376
 377 void usb_read_port_cancel(struct intf_hdl *pintfhdl)
 378 {
 379         int i;
 380         struct recv_buf *precvbuf;
 381         _adapter        *padapter = pintfhdl->padapter;
 382         precvbuf = (struct recv_buf *)padapter->recvpriv.precv_buf;
 383
 384         DBG_871X("%s\n", __func__);
 385
 386         for (i=0; i < NR_RECVBUFF ; i++) {
 387
 388                 if (precvbuf->purb)      {
 389                         //DBG_8192C("usb_read_port_cancel : usb_kill_urb \n");
 390                         usb_kill_urb(precvbuf->purb);
 391                 }
 392                 precvbuf++;
 393         }
 394
 395 #ifdef CONFIG_USB_INTERRUPT_IN_PIPE
 396         usb_kill_urb(padapter->recvpriv.int_in_urb);
 397 #endif
 398 }
 399
 400 static void usb_write_port_complete(struct urb *purb, struct pt_regs *regs)
 401 {
 402         _irqL irqL;
 403         int i;
 404         struct xmit_buf *pxmitbuf = (struct xmit_buf *)purb->context;
 405         //struct xmit_frame *pxmitframe = (struct xmit_frame *)pxmitbuf->priv_data;
 406         //_adapter                      *padapter = pxmitframe->padapter;
 407         _adapter        *padapter = pxmitbuf->padapter;
 408        struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
 409         //struct pkt_attrib *pattrib = &pxmitframe->attrib;
 410
 411 _func_enter_;
 412
 413         switch(pxmitbuf->flags)
 414         {
 415                 case VO_QUEUE_INX:
 416                         pxmitpriv->voq_cnt--;
 417                         break;
 418                 case VI_QUEUE_INX:
 419                         pxmitpriv->viq_cnt--;
 420                         break;
 421                 case BE_QUEUE_INX:
 422                         pxmitpriv->beq_cnt--;
 423                         break;
 424                 case BK_QUEUE_INX:
 425                         pxmitpriv->bkq_cnt--;
 426                         break;
 427                 default:
 428                         break;
 429         }
 430
 431
 432 /*
 433         _enter_critical(&pxmitpriv->lock, &irqL);
 434
 435         pxmitpriv->txirp_cnt--;
 436
 437         switch(pattrib->priority)
 438         {
 439                 case 1:
 440                 case 2:
 441                         pxmitpriv->bkq_cnt--;
 442                         //DBG_8192C("pxmitpriv->bkq_cnt=%d\n", pxmitpriv->bkq_cnt);
 443                         break;
 444                 case 4:
 445                 case 5:
 446                         pxmitpriv->viq_cnt--;
 447                         //DBG_8192C("pxmitpriv->viq_cnt=%d\n", pxmitpriv->viq_cnt);
 448                         break;
 449                 case 6:
 450                 case 7:
 451                         pxmitpriv->voq_cnt--;
 452                         //DBG_8192C("pxmitpriv->voq_cnt=%d\n", pxmitpriv->voq_cnt);
 453                         break;
 454                 case 0:
 455                 case 3:
 456                 default:
 457                         pxmitpriv->beq_cnt--;
 458                         //DBG_8192C("pxmitpriv->beq_cnt=%d\n", pxmitpriv->beq_cnt);
 459                         break;
 460
 461         }
 462
 463         _exit_critical(&pxmitpriv->lock, &irqL);
 464
 465
 466         if(pxmitpriv->txirp_cnt==0)
 467         {
 468                 RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_write_port_complete: txirp_cnt== 0, set allrxreturnevt!\n"));
 469                 _rtw_up_sema(&(pxmitpriv->tx_retevt));
 470         }
 471 */
 472         //rtw_free_xmitframe(pxmitpriv, pxmitframe);
 473
 474         if (RTW_CANNOT_TX(padapter))
 475         {
 476                 DBG_8192C("%s(): TX Warning! bDriverStopped(%s) OR bSurpriseRemoved(%s) pxmitbuf->buf_tag(%x)\n"
 477                 , __func__
 478                 , rtw_is_drv_stopped(padapter)?"True":"False"
 479                 , rtw_is_surprise_removed(padapter)?"True":"False"
 480                 , pxmitbuf->buf_tag);
 481
 482                 goto check_completion;
 483         }
 484
 485
 486         if (purb->status==0) {
 487
 488         } else {
 489                 RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_write_port_complete : purb->status(%d) != 0 \n", purb->status));
 490                 DBG_871X("###=> urb_write_port_complete status(%d)\n",purb->status);
 491                 if((purb->status==-EPIPE)||(purb->status==-EPROTO))
 492                 {
 493                         //usb_clear_halt(pusbdev, purb->pipe);
 494                         //msleep(10);
 495                         sreset_set_wifi_error_status(padapter, USB_WRITE_PORT_FAIL);
 496                 } else if (purb->status == -EINPROGRESS) {
 497                         RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_write_port_complete: EINPROGESS\n"));
 498                         goto check_completion;
 499
 500                 } else if (purb->status == -ENOENT) {
 501                         DBG_871X("%s: -ENOENT\n", __func__);
 502                         goto check_completion;
 503
 504                 } else if (purb->status == -ECONNRESET) {
 505                         DBG_871X("%s: -ECONNRESET\n", __func__);
 506                         goto check_completion;
 507
 508                 } else if (purb->status == -ESHUTDOWN) {
 509                         RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_write_port_complete: ESHUTDOWN\n"));
 510                         rtw_set_drv_stopped(padapter);
 511                         RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_write_port_complete:bDriverStopped=TRUE\n"));
 512
 513                         goto check_completion;
 514                 }
 515                 else
 516                 {
 517                         rtw_set_surprise_removed(padapter);
 518                         DBG_8192C("bSurpriseRemoved=TRUE\n");
 519                         RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_write_port_complete:bSurpriseRemoved=TRUE\n"));
 520
 521                         goto check_completion;
 522                 }
 523         }
 524
 525         #ifdef DBG_CONFIG_ERROR_DETECT
 526         {
 527                 HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
 528                 pHalData->srestpriv.last_tx_complete_time = rtw_get_current_time();
 529         }
 530         #endif
 531
 532 check_completion:
 533         _enter_critical(&pxmitpriv->lock_sctx, &irqL);
 534         rtw_sctx_done_err(&pxmitbuf->sctx,
 535         purb->status ? RTW_SCTX_DONE_WRITE_PORT_ERR : RTW_SCTX_DONE_SUCCESS);
 536         _exit_critical(&pxmitpriv->lock_sctx, &irqL);
 537
 538         rtw_free_xmitbuf(pxmitpriv, pxmitbuf);
 539
 540         //if(rtw_txframes_pending(padapter))
 541         {
 542                 tasklet_hi_schedule(&pxmitpriv->xmit_tasklet);
 543         }
 544
 545 _func_exit_;
 546
 547 }
 548
 549 u32 usb_write_port(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *wmem)
 550 {
 551         _irqL irqL;
 552         unsigned int pipe;
 553         int status;
 554         u32 ret = _FAIL, bwritezero = _FALSE;
 555         PURB    purb = NULL;
 556         _adapter *padapter = (_adapter *)pintfhdl->padapter;
 557         struct dvobj_priv       *pdvobj = adapter_to_dvobj(padapter);
 558         struct pwrctrl_priv *pwrctl = dvobj_to_pwrctl(pdvobj);
 559         struct xmit_priv        *pxmitpriv = &padapter->xmitpriv;
 560         struct xmit_buf *pxmitbuf = (struct xmit_buf *)wmem;
 561         struct xmit_frame *pxmitframe = (struct xmit_frame *)pxmitbuf->priv_data;
 562         struct usb_device *pusbd = pdvobj->pusbdev;
 563         struct pkt_attrib *pattrib = &pxmitframe->attrib;
 564
 565 _func_enter_;
 566
 567         RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("+usb_write_port\n"));
 568
 569         if (RTW_CANNOT_TX(padapter)) {
 570                 #ifdef DBG_TX
 571                 DBG_871X(" DBG_TX %s:%d bDriverStopped%s, bSurpriseRemoved:%s\n", __func__, __LINE__
 572                         , rtw_is_drv_stopped(padapter)?"True":"False"
 573                         , rtw_is_surprise_removed(padapter)?"True":"False");
 574                 #endif
 575                 RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_write_port:( padapter->bDriverStopped ||padapter->bSurpriseRemoved )!!!\n"));
 576                 rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_TX_DENY);
 577                 goto exit;
 578         }
 579
 580         _enter_critical(&pxmitpriv->lock, &irqL);
 581
 582         switch(addr)
 583         {
 584                 case VO_QUEUE_INX:
 585                         pxmitpriv->voq_cnt++;
 586                         pxmitbuf->flags = VO_QUEUE_INX;
 587                         break;
 588                 case VI_QUEUE_INX:
 589                         pxmitpriv->viq_cnt++;
 590                         pxmitbuf->flags = VI_QUEUE_INX;
 591                         break;
 592                 case BE_QUEUE_INX:
 593                         pxmitpriv->beq_cnt++;
 594                         pxmitbuf->flags = BE_QUEUE_INX;
 595                         break;
 596                 case BK_QUEUE_INX:
 597                         pxmitpriv->bkq_cnt++;
 598                         pxmitbuf->flags = BK_QUEUE_INX;
 599                         break;
 600                 case HIGH_QUEUE_INX:
 601                         pxmitbuf->flags = HIGH_QUEUE_INX;
 602                         break;
 603                 default:
 604                         pxmitbuf->flags = MGT_QUEUE_INX;
 605                         break;
 606         }
 607
 608         _exit_critical(&pxmitpriv->lock, &irqL);
 609
 610         purb    = pxmitbuf->pxmit_urb[0];
 611
 612         //translate DMA FIFO addr to pipehandle
 613         pipe = ffaddr2pipehdl(pdvobj, addr);
 614
 615 #ifdef CONFIG_REDUCE_USB_TX_INT
 616         if ( (pxmitpriv->free_xmitbuf_cnt%NR_XMITBUFF == 0)
 617                 || (pxmitbuf->buf_tag > XMITBUF_DATA) )
 618         {
 619                 purb->transfer_flags  &=  (~URB_NO_INTERRUPT);
 620         } else {
 621                 purb->transfer_flags  |=  URB_NO_INTERRUPT;
 622                 //DBG_8192C("URB_NO_INTERRUPT ");
 623         }
 624 #endif
 625
 626
 627         usb_fill_bulk_urb(purb, pusbd, pipe,
 628                                 pxmitframe->buf_addr, //= pxmitbuf->pbuf
 629                                 cnt,
 630                                 usb_write_port_complete,
 631                                 pxmitbuf);//context is pxmitbuf
 632
 633 #ifdef CONFIG_USE_USB_BUFFER_ALLOC_TX
 634         purb->transfer_dma = pxmitbuf->dma_transfer_addr;
 635         purb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 636         purb->transfer_flags |= URB_ZERO_PACKET;
 637 #endif  // CONFIG_USE_USB_BUFFER_ALLOC_TX
 638
 639 #ifdef USB_PACKET_OFFSET_SZ
 640 #if (USB_PACKET_OFFSET_SZ == 0)
 641         purb->transfer_flags |= URB_ZERO_PACKET;
 642 #endif
 643 #endif
 644
 645 #if 0
 646         if (bwritezero)
 647         {
 648             purb->transfer_flags |= URB_ZERO_PACKET;
 649         }
 650 #endif
 651
 652         status = usb_submit_urb(purb, GFP_ATOMIC);
 653         if (!status) {
 654                 #ifdef DBG_CONFIG_ERROR_DETECT
 655                 {
 656                         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
 657                         pHalData->srestpriv.last_tx_time = rtw_get_current_time();
 658                 }
 659                 #endif
 660         } else {
 661                 rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_WRITE_PORT_ERR);
 662                 DBG_871X("usb_write_port, status=%d\n", status);
 663                 RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_write_port(): usb_submit_urb, status=%x\n", status));
 664
 665                 switch (status) {
 666                 case -ENODEV:
 667                         rtw_set_drv_stopped(padapter);
 668                         break;
 669                 default:
 670                         break;
 671                 }
 672                 goto exit;
 673         }
 674
 675         ret= _SUCCESS;
 676
 677 //   Commented by Albert 2009/10/13
 678 //   We add the URB_ZERO_PACKET flag to urb so that the host will send the zero packet automatically.
 679 /*
 680         if(bwritezero == _TRUE)
 681         {
 682                 usb_bulkout_zero(pintfhdl, addr);
 683         }
 684 */
 685
 686         RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("-usb_write_port\n"));
 687
 688 exit:
 689         if (ret != _SUCCESS)
 690                 rtw_free_xmitbuf(pxmitpriv, pxmitbuf);
 691 _func_exit_;
 692         return ret;
 693
 694 }
 695
 696 void usb_write_port_cancel(struct intf_hdl *pintfhdl)
 697 {
 698         int i, j;
 699         _adapter        *padapter = pintfhdl->padapter;
 700         struct xmit_buf *pxmitbuf = (struct xmit_buf *)padapter->xmitpriv.pxmitbuf;
 701
 702         DBG_871X("%s \n", __func__);
 703
 704         for (i=0; i<NR_XMITBUFF; i++) {
 705                 for (j=0; j<8; j++) {
 706                         if (pxmitbuf->pxmit_urb[j]) {
 707                                 usb_kill_urb(pxmitbuf->pxmit_urb[j]);
 708                         }
 709                 }
 710                 pxmitbuf++;
 711         }
 712
 713         pxmitbuf = (struct xmit_buf*)padapter->xmitpriv.pxmit_extbuf;
 714         for (i = 0; i < NR_XMIT_EXTBUFF ; i++) {
 715                 for (j=0; j<8; j++) {
 716                         if(pxmitbuf->pxmit_urb[j]) {
 717                                 usb_kill_urb(pxmitbuf->pxmit_urb[j]);
 718                         }
 719                 }
 720                 pxmitbuf++;
 721         }
 722 }
 723
 724 void usb_init_recvbuf(_adapter *padapter, struct recv_buf *precvbuf)
 725 {
 726
 727         precvbuf->transfer_len = 0;
 728
 729         precvbuf->len = 0;
 730
 731         precvbuf->ref_cnt = 0;
 732
 733         if(precvbuf->pbuf)
 734         {
 735                 precvbuf->pdata = precvbuf->phead = precvbuf->ptail = precvbuf->pbuf;
 736                 precvbuf->pend = precvbuf->pdata + MAX_RECVBUF_SZ;
 737         }
 738
 739 }
 740
 741 int recvbuf2recvframe(PADAPTER padapter, void *ptr);
 742
 743 #ifdef CONFIG_USE_USB_BUFFER_ALLOC_RX
 744 void usb_recv_tasklet(void *priv)
 745 {
 746         struct recv_buf *precvbuf = NULL;
 747         _adapter        *padapter = (_adapter*)priv;
 748         struct recv_priv        *precvpriv = &padapter->recvpriv;
 749
 750         while (NULL != (precvbuf = rtw_dequeue_recvbuf(&precvpriv->recv_buf_pending_queue)))
 751         {
 752                 if (RTW_CANNOT_RUN(padapter)) {
 753                         DBG_8192C("recv_tasklet => bDriverStopped or bSurpriseRemoved\n");
 754                         break;
 755                 }
 756
 757
 758                 recvbuf2recvframe(padapter, precvbuf);
 759
 760                 rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
 761         }
 762
 763 }
 764
 765 void usb_read_port_complete(struct urb *purb, struct pt_regs *regs)
 766 {
 767         struct recv_buf *precvbuf = (struct recv_buf *)purb->context;
 768         _adapter                        *padapter =(_adapter *)precvbuf->adapter;
 769         struct recv_priv        *precvpriv = &padapter->recvpriv;
 770
 771         RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete!!!\n"));
 772
 773         ATOMIC_DEC(&(precvpriv->rx_pending_cnt));
 774
 775         if (RTW_CANNOT_RX(padapter))
 776         {
 777                 DBG_8192C("%s() RX Warning! bDriverStopped(%s) OR bSurpriseRemoved(%s)\n"
 778                 , __func__
 779                 , rtw_is_drv_stopped(padapter)?"True":"False"
 780                 , rtw_is_surprise_removed(padapter)?"True":"False");
 781                 goto exit;
 782         }
 783
 784         if(purb->status==0)//SUCCESS
 785         {
 786                 if ((purb->actual_length > MAX_RECVBUF_SZ) || (purb->actual_length < RXDESC_SIZE))
 787                 {
 788                         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"));
 789
 790                         rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
 791                 }
 792                 else
 793                 {
 794                         rtw_reset_continual_io_error(adapter_to_dvobj(padapter));
 795
 796                         precvbuf->transfer_len = purb->actual_length;
 797
 798                         //rtw_enqueue_rx_transfer_buffer(precvpriv, rx_transfer_buf);
 799                         rtw_enqueue_recvbuf(precvbuf, &precvpriv->recv_buf_pending_queue);
 800
 801                         tasklet_schedule(&precvpriv->recv_tasklet);
 802                 }
 803         }
 804         else
 805         {
 806                 RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete : purb->status(%d) != 0 \n", purb->status));
 807
 808                 DBG_8192C("###=> usb_read_port_complete => urb status(%d)\n", purb->status);
 809
 810                 if (rtw_inc_and_chk_continual_io_error(adapter_to_dvobj(padapter)) == _TRUE)
 811                         rtw_set_surprise_removed(padapter);
 812
 813                 switch(purb->status) {
 814                         case -EINVAL:
 815                         case -EPIPE:
 816                         case -ENODEV:
 817                         case -ESHUTDOWN:
 818                                 /*rtw_set_surprise_removed(padapter);*/
 819                                 //RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete:bSurpriseRemoved=TRUE\n"));
 820                         case -ENOENT:
 821                                 rtw_set_drv_stopped(padapter);
 822                                 RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete:bDriverStopped=TRUE\n"));
 823                                 break;
 824                         case -EPROTO:
 825                         case -EILSEQ:
 826                         case -ETIME:
 827                         case -ECOMM:
 828                         case -EOVERFLOW:
 829                                 #ifdef DBG_CONFIG_ERROR_DETECT
 830                                 {
 831                                         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
 832                                         pHalData->srestpriv.Wifi_Error_Status = USB_READ_PORT_FAIL;
 833                                 }
 834                                 #endif
 835                                 rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
 836                                 break;
 837                         case -EINPROGRESS:
 838                                 DBG_8192C("ERROR: URB IS IN PROGRESS!/n");
 839                                 break;
 840                         default:
 841                                 break;
 842                 }
 843
 844         }
 845
 846 exit:
 847
 848 _func_exit_;
 849 }
 850
 851 u32 usb_read_port(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *rmem)
 852 {
 853         int err;
 854         unsigned int pipe;
 855         u32 ret = _SUCCESS;
 856         PURB purb = NULL;
 857         struct recv_buf *precvbuf = (struct recv_buf *)rmem;
 858         _adapter                *adapter = pintfhdl->padapter;
 859         struct dvobj_priv       *pdvobj = adapter_to_dvobj(adapter);
 860         struct pwrctrl_priv *pwrctl = dvobj_to_pwrctl(pdvobj);
 861         struct recv_priv        *precvpriv = &adapter->recvpriv;
 862         struct usb_device       *pusbd = pdvobj->pusbdev;
 863
 864 _func_enter_;
 865
 866         if (RTW_CANNOT_RX(adapter) || (precvbuf == NULL))
 867         {
 868                 RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port:( RTW_CANNOT_RX ) || precvbuf == NULL!!!\n"));
 869                 return _FAIL;
 870         }
 871
 872         usb_init_recvbuf(adapter, precvbuf);
 873
 874         if(precvbuf->pbuf)
 875         {
 876                 ATOMIC_INC(&(precvpriv->rx_pending_cnt));
 877                 purb = precvbuf->purb;
 878
 879                 //translate DMA FIFO addr to pipehandle
 880                 pipe = ffaddr2pipehdl(pdvobj, addr);
 881
 882                 usb_fill_bulk_urb(purb, pusbd, pipe,
 883                                         precvbuf->pbuf,
 884                                         MAX_RECVBUF_SZ,
 885                                         usb_read_port_complete,
 886                                         precvbuf);//context is precvbuf
 887
 888                 purb->transfer_dma = precvbuf->dma_transfer_addr;
 889                 purb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 890
 891                 err = usb_submit_urb(purb, GFP_ATOMIC);
 892                 if((err) && (err != (-EPERM)))
 893                 {
 894                         RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("cannot submit rx in-token(err=0x%.8x), URB_STATUS =0x%.8x", err, purb->status));
 895                         DBG_8192C("cannot submit rx in-token(err = 0x%08x),urb_status = %d\n",err,purb->status);
 896                         ret = _FAIL;
 897                 }
 898
 899         }
 900
 901 _func_exit_;
 902
 903         return ret;
 904 }
 905 #else   // CONFIG_USE_USB_BUFFER_ALLOC_RX
 906
 907 void usb_recv_tasklet(void *priv)
 908 {
 909         _pkt                    *pskb;
 910         _adapter                *padapter = (_adapter*)priv;
 911         struct recv_priv        *precvpriv = &padapter->recvpriv;
 912         struct recv_buf *precvbuf = NULL;
 913
 914         while (NULL != (pskb = skb_dequeue(&precvpriv->rx_skb_queue))) {
 915
 916                 if (RTW_CANNOT_RUN(padapter)) {
 917                         DBG_8192C("recv_tasklet => bDriverStopped or bSurpriseRemoved\n");
 918                         #ifdef CONFIG_PREALLOC_RX_SKB_BUFFER
 919                         if (rtw_free_skb_premem(pskb) != 0)
 920                         #endif //CONFIG_PREALLOC_RX_SKB_BUFFER
 921                                 rtw_skb_free(pskb);
 922                         break;
 923                 }
 924
 925                 recvbuf2recvframe(padapter, pskb);
 926
 927                 skb_reset_tail_pointer(pskb);
 928                 pskb->len = 0;
 929
 930                 skb_queue_tail(&precvpriv->free_recv_skb_queue, pskb);
 931
 932                 if (NULL != (precvbuf = rtw_dequeue_recvbuf(&precvpriv->recv_buf_pending_queue))) {
 933                         precvbuf->pskb = NULL;
 934                         rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
 935                 }
 936         }
 937 }
 938
 939 void usb_read_port_complete(struct urb *purb, struct pt_regs *regs)
 940 {
 941         struct recv_buf *precvbuf = (struct recv_buf *)purb->context;
 942         _adapter                        *padapter =(_adapter *)precvbuf->adapter;
 943         struct recv_priv        *precvpriv = &padapter->recvpriv;
 944
 945         RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete!!!\n"));
 946
 947         ATOMIC_DEC(&(precvpriv->rx_pending_cnt));
 948
 949         if(RTW_CANNOT_RX(padapter))
 950         {
 951                 DBG_8192C("%s() RX Warning! bDriverStopped(%s) OR bSurpriseRemoved(%s)\n"
 952                         , __func__
 953                         , rtw_is_drv_stopped(padapter)?"True":"False"
 954                         , rtw_is_surprise_removed(padapter)?"True":"False");
 955                 goto exit;
 956         }
 957
 958         if(purb->status==0)//SUCCESS
 959         {
 960                 if ((purb->actual_length > MAX_RECVBUF_SZ) || (purb->actual_length < RXDESC_SIZE))
 961                 {
 962                         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"));
 963                         rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
 964                         DBG_8192C("%s()-%d: RX Warning!\n", __FUNCTION__, __LINE__);
 965                 }
 966                 else
 967                 {
 968                         rtw_reset_continual_io_error(adapter_to_dvobj(padapter));
 969
 970                         precvbuf->transfer_len = purb->actual_length;
 971                         skb_put(precvbuf->pskb, purb->actual_length);
 972                         skb_queue_tail(&precvpriv->rx_skb_queue, precvbuf->pskb);
 973
 974                         #ifndef CONFIG_FIX_NR_BULKIN_BUFFER
 975                         if (skb_queue_len(&precvpriv->rx_skb_queue)<=1)
 976                         #endif
 977                                 tasklet_schedule(&precvpriv->recv_tasklet);
 978
 979                         precvbuf->pskb = NULL;
 980                         rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
 981                 }
 982         }
 983         else
 984         {
 985                 RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete : purb->status(%d) != 0 \n", purb->status));
 986
 987                 DBG_8192C("###=> usb_read_port_complete => urb status(%d)\n", purb->status);
 988
 989                 if (rtw_inc_and_chk_continual_io_error(adapter_to_dvobj(padapter)) == _TRUE)
 990                         rtw_set_surprise_removed(padapter);
 991
 992
 993                 switch(purb->status) {
 994                         case -EINVAL:
 995                         case -EPIPE:
 996                         case -ENODEV:
 997                         case -ESHUTDOWN:
 998                                 /*rtw_set_surprise_removed(padapter);*/
 999                                 //RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete:bSurpriseRemoved=TRUE\n"));
1000                         case -ENOENT:
1001                                 rtw_set_drv_stopped(padapter);
1002                                 RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete:bDriverStopped=TRUE\n"));
1003                                 break;
1004                         case -EPROTO:
1005                         case -EILSEQ:
1006                         case -ETIME:
1007                         case -ECOMM:
1008                         case -EOVERFLOW:
1009                                 #ifdef DBG_CONFIG_ERROR_DETECT
1010                                 {
1011                                         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
1012                                         pHalData->srestpriv.Wifi_Error_Status = USB_READ_PORT_FAIL;
1013                                 }
1014                                 #endif
1015                                 rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
1016                                 break;
1017                         case -EINPROGRESS:
1018                                 DBG_8192C("ERROR: URB IS IN PROGRESS!/n");
1019                                 break;
1020                         default:
1021                                 break;
1022                 }
1023
1024         }
1025
1026 exit:
1027
1028 _func_exit_;
1029
1030 }
1031
1032 u32 usb_read_port(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *rmem)
1033 {
1034         int err;
1035         unsigned int pipe;
1036         u32 ret = _FAIL;
1037         PURB purb = NULL;
1038         struct recv_buf *precvbuf = (struct recv_buf *)rmem;
1039         _adapter                *adapter = pintfhdl->padapter;
1040         struct dvobj_priv       *pdvobj = adapter_to_dvobj(adapter);
1041         struct pwrctrl_priv *pwrctl = dvobj_to_pwrctl(pdvobj);
1042         struct recv_priv        *precvpriv = &adapter->recvpriv;
1043         struct usb_device       *pusbd = pdvobj->pusbdev;
1044
1045 _func_enter_;
1046
1047         if (RTW_CANNOT_RX(adapter) || (precvbuf == NULL)) {
1048                 RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port:( RTW_CANNOT_RX ) || precvbuf == NULL!!!\n"));
1049                 goto exit;
1050         }
1051
1052         usb_init_recvbuf(adapter, precvbuf);
1053
1054         if (precvbuf->pskb == NULL) {
1055                 SIZE_PTR tmpaddr = 0;
1056                 SIZE_PTR alignment = 0;
1057
1058                 if (NULL != (precvbuf->pskb = skb_dequeue(&precvpriv->free_recv_skb_queue)))
1059                         goto recv_buf_hook;
1060
1061                 #ifndef CONFIG_FIX_NR_BULKIN_BUFFER
1062                 precvbuf->pskb = rtw_skb_alloc(MAX_RECVBUF_SZ + RECVBUFF_ALIGN_SZ);
1063                 #endif
1064
1065                 if (precvbuf->pskb == NULL) {
1066                         if (0)
1067                                 DBG_871X("usb_read_port() enqueue precvbuf=%p \n", precvbuf);
1068                         /* enqueue precvbuf and wait for free skb */
1069                         rtw_enqueue_recvbuf(precvbuf, &precvpriv->recv_buf_pending_queue);
1070                         goto exit;
1071                 }
1072
1073                 tmpaddr = (SIZE_PTR)precvbuf->pskb->data;
1074                 alignment = tmpaddr & (RECVBUFF_ALIGN_SZ-1);
1075                 skb_reserve(precvbuf->pskb, (RECVBUFF_ALIGN_SZ - alignment));
1076         }
1077
1078 recv_buf_hook:
1079         precvbuf->phead = precvbuf->pskb->head;
1080         precvbuf->pdata = precvbuf->pskb->data;
1081         precvbuf->ptail = skb_tail_pointer(precvbuf->pskb);
1082         precvbuf->pend = skb_end_pointer(precvbuf->pskb);
1083         precvbuf->pbuf = precvbuf->pskb->data;
1084
1085         purb = precvbuf->purb;
1086
1087         /* translate DMA FIFO addr to pipehandle */
1088         pipe = ffaddr2pipehdl(pdvobj, addr);
1089
1090         usb_fill_bulk_urb(purb, pusbd, pipe,
1091                 precvbuf->pbuf,
1092                 MAX_RECVBUF_SZ,
1093                 usb_read_port_complete,
1094                 precvbuf);
1095
1096         err = usb_submit_urb(purb, GFP_ATOMIC);
1097         if (err && err != (-EPERM)) {
1098                 DBG_871X("cannot submit rx in-token(err = 0x%08x),urb_status = %d\n"
1099                         , err, purb->status);
1100                 goto exit;
1101         }
1102
1103         ATOMIC_INC(&(precvpriv->rx_pending_cnt));
1104         ret = _SUCCESS;
1105
1106 exit:
1107
1108 _func_exit_;
1109
1110         return ret;
1111 }
1112 #endif  // CONFIG_USE_USB_BUFFER_ALLOC_RX
1113
1114 #ifdef CONFIG_USB_INTERRUPT_IN_PIPE
1115 void usb_read_interrupt_complete(struct urb *purb, struct pt_regs *regs)
1116 {
1117         int     err;
1118         _adapter        *padapter = (_adapter *)purb->context;
1119
1120         if (RTW_CANNOT_RX(padapter)) {
1121                 DBG_8192C("%s() RX Warning! bDriverStopped(%s) OR bSurpriseRemoved(%s)\n"
1122                 , __func__
1123                 , rtw_is_drv_stopped(padapter)?"True":"False"
1124                 , rtw_is_surprise_removed(padapter)?"True":"False");
1125
1126                 return;
1127         }
1128
1129         if (purb->status == 0) {/*SUCCESS*/
1130                 if (purb->actual_length > INTERRUPT_MSG_FORMAT_LEN)
1131                         DBG_8192C("usb_read_interrupt_complete: purb->actual_length > INTERRUPT_MSG_FORMAT_LEN(%d)\n", INTERRUPT_MSG_FORMAT_LEN);
1132
1133                 rtw_hal_interrupt_handler(padapter, purb->actual_length, purb->transfer_buffer);
1134
1135                 err = usb_submit_urb(purb, GFP_ATOMIC);
1136                 if ((err) && (err != (-EPERM)))
1137                         DBG_8192C("cannot submit interrupt in-token(err = 0x%08x),urb_status = %d\n", err, purb->status);
1138         } else {
1139                 DBG_8192C("###=> usb_read_interrupt_complete => urb status(%d)\n", purb->status);
1140
1141                 switch (purb->status) {
1142                 case -EINVAL:
1143                 case -EPIPE:
1144                 case -ENODEV:
1145                 case -ESHUTDOWN:
1146                         /*rtw_set_surprise_removed(padapter);*/
1147                         /*RT_TRACE(_module_hci_ops_os_c_, _drv_err_, ("usb_read_port_complete:bSurpriseRemoved=TRUE\n"));*/
1148                 case -ENOENT:
1149                         rtw_set_drv_stopped(padapter);
1150                         RT_TRACE(_module_hci_ops_os_c_, _drv_err_, ("usb_read_port_complete:bDriverStopped=TRUE\n"));
1151                         break;
1152                 case -EPROTO:
1153                         break;
1154                 case -EINPROGRESS:
1155                         DBG_8192C("ERROR: URB IS IN PROGRESS!/n");
1156                         break;
1157                 default:
1158                         break;
1159                 }
1160         }
1161 }
1162
1163 u32 usb_read_interrupt(struct intf_hdl *pintfhdl, u32 addr)
1164 {
1165         int     err;
1166         unsigned int pipe;
1167         u32     ret = _SUCCESS;
1168         _adapter                        *adapter = pintfhdl->padapter;
1169         struct dvobj_priv       *pdvobj = adapter_to_dvobj(adapter);
1170         struct recv_priv        *precvpriv = &adapter->recvpriv;
1171         struct usb_device       *pusbd = pdvobj->pusbdev;
1172
1173 _func_enter_;
1174
1175         if (RTW_CANNOT_RX(adapter)) {
1176                 RT_TRACE(_module_hci_ops_os_c_, _drv_err_, ("usb_read_interrupt:( RTW_CANNOT_RX )!!!\n"));
1177                 return _FAIL;
1178         }
1179
1180         /*translate DMA FIFO addr to pipehandle*/
1181         pipe = ffaddr2pipehdl(pdvobj, addr);
1182
1183         usb_fill_int_urb(precvpriv->int_in_urb, pusbd, pipe,
1184                                                 precvpriv->int_in_buf,
1185                                                 INTERRUPT_MSG_FORMAT_LEN,
1186                                                 usb_read_interrupt_complete,
1187                                                 adapter,
1188                                                 1);
1189
1190         err = usb_submit_urb(precvpriv->int_in_urb, GFP_ATOMIC);
1191         if ((err) && (err != (-EPERM))) {
1192                 DBG_8192C("cannot submit interrupt in-token(err = 0x%08x), urb_status = %d\n", err, precvpriv->int_in_urb->status);
1193                 ret = _FAIL;
1194         }
1195
1196 _func_exit_;
1197         return ret;
1198 }
1199 #endif /* CONFIG_USB_INTERRUPT_IN_PIPE */
1200