drivers/staging/r8188eu/hal/usb_ops_linux.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright(c) 2007 - 2011 Realtek Corporation. */
   3
   4 #define _HCI_OPS_OS_C_
   5
   6 #include <osdep_service.h>
   7 #include <drv_types.h>
   8 #include <osdep_intf.h>
   9 #include <usb_ops.h>
  10 #include <recv_osdep.h>
  11 #include <rtl8188e_hal.h>
  12
  13 static int usbctrl_vendorreq(struct intf_hdl *pintfhdl, u8 request, u16 value, u16 index, void *pdata, u16 len, u8 requesttype)
  14 {
  15         struct adapter  *adapt = pintfhdl->padapter;
  16         struct dvobj_priv  *dvobjpriv = adapter_to_dvobj(adapt);
  17         struct usb_device *udev = dvobjpriv->pusbdev;
  18         unsigned int pipe;
  19         int status = 0;
  20         u8 reqtype;
  21         u8 *pIo_buf;
  22         int vendorreq_times = 0;
  23
  24         if ((adapt->bSurpriseRemoved) || (adapt->pwrctrlpriv.pnp_bstop_trx)) {
  25                 RT_TRACE(_module_hci_ops_os_c_, _drv_err_, ("usbctrl_vendorreq:(adapt->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n"));
  26                 status = -EPERM;
  27                 goto exit;
  28         }
  29
  30         if (len > MAX_VENDOR_REQ_CMD_SIZE) {
  31                 DBG_88E("[%s] Buffer len error ,vendor request failed\n", __func__);
  32                 status = -EINVAL;
  33                 goto exit;
  34         }
  35
  36         _enter_critical_mutex(&dvobjpriv->usb_vendor_req_mutex, NULL);
  37
  38         /*  Acquire IO memory for vendorreq */
  39         pIo_buf = dvobjpriv->usb_vendor_req_buf;
  40
  41         if (pIo_buf == NULL) {
  42                 DBG_88E("[%s] pIo_buf == NULL\n", __func__);
  43                 status = -ENOMEM;
  44                 goto release_mutex;
  45         }
  46
  47         while (++vendorreq_times <= MAX_USBCTRL_VENDORREQ_TIMES) {
  48                 memset(pIo_buf, 0, len);
  49
  50                 if (requesttype == 0x01) {
  51                         pipe = usb_rcvctrlpipe(udev, 0);/* read_in */
  52                         reqtype =  REALTEK_USB_VENQT_READ;
  53                 } else {
  54                         pipe = usb_sndctrlpipe(udev, 0);/* write_out */
  55                         reqtype =  REALTEK_USB_VENQT_WRITE;
  56                         memcpy(pIo_buf, pdata, len);
  57                 }
  58
  59                 status = usb_control_msg(udev, pipe, request, reqtype, value, index, pIo_buf, len, RTW_USB_CONTROL_MSG_TIMEOUT);
  60
  61                 if (status == len) {   /*  Success this control transfer. */
  62                         rtw_reset_continual_urb_error(dvobjpriv);
  63                         if (requesttype == 0x01)
  64                                 memcpy(pdata, pIo_buf,  len);
  65                 } else { /*  error cases */
  66                         DBG_88E("reg 0x%x, usb %s %u fail, status:%d value=0x%x, vendorreq_times:%d\n",
  67                                 value, (requesttype == 0x01) ? "read" : "write",
  68                                 len, status, *(u32 *)pdata, vendorreq_times);
  69
  70                         if (status < 0) {
  71                                 if (status == (-ESHUTDOWN) || status == -ENODEV) {
  72                                         adapt->bSurpriseRemoved = true;
  73                                 } else {
  74                                         struct hal_data_8188e   *haldata = GET_HAL_DATA(adapt);
  75                                         haldata->srestpriv.Wifi_Error_Status = USB_VEN_REQ_CMD_FAIL;
  76                                 }
  77                         } else { /*  status != len && status >= 0 */
  78                                 if (status > 0) {
  79                                         if (requesttype == 0x01) {
  80                                                 /*  For Control read transfer, we have to copy the read data from pIo_buf to pdata. */
  81                                                 memcpy(pdata, pIo_buf,  len);
  82                                         }
  83                                 }
  84                         }
  85
  86                         if (rtw_inc_and_chk_continual_urb_error(dvobjpriv)) {
  87                                 adapt->bSurpriseRemoved = true;
  88                                 break;
  89                         }
  90
  91                 }
  92
  93                 /*  firmware download is checksumed, don't retry */
  94                 if ((value >= FW_8188E_START_ADDRESS && value <= FW_8188E_END_ADDRESS) || status == len)
  95                         break;
  96         }
  97 release_mutex:
  98         _exit_critical_mutex(&dvobjpriv->usb_vendor_req_mutex, NULL);
  99 exit:
 100         return status;
 101 }
 102
 103 static u8 usb_read8(struct intf_hdl *pintfhdl, u32 addr)
 104 {
 105         u8 request;
 106         u8 requesttype;
 107         u16 wvalue;
 108         u16 index;
 109         u16 len;
 110         u8 data = 0;
 111
 112
 113
 114         request = 0x05;
 115         requesttype = 0x01;/* read_in */
 116         index = 0;/* n/a */
 117
 118         wvalue = (u16)(addr&0x0000ffff);
 119         len = 1;
 120
 121         usbctrl_vendorreq(pintfhdl, request, wvalue, index, &data, len, requesttype);
 122
 123
 124
 125         return data;
 126
 127 }
 128
 129 static u16 usb_read16(struct intf_hdl *pintfhdl, u32 addr)
 130 {
 131         u8 request;
 132         u8 requesttype;
 133         u16 wvalue;
 134         u16 index;
 135         u16 len;
 136         __le32 data;
 137
 138         request = 0x05;
 139         requesttype = 0x01;/* read_in */
 140         index = 0;/* n/a */
 141         wvalue = (u16)(addr&0x0000ffff);
 142         len = 2;
 143         usbctrl_vendorreq(pintfhdl, request, wvalue, index, &data, len, requesttype);
 144
 145         return (u16)(le32_to_cpu(data)&0xffff);
 146 }
 147
 148 static u32 usb_read32(struct intf_hdl *pintfhdl, u32 addr)
 149 {
 150         u8 request;
 151         u8 requesttype;
 152         u16 wvalue;
 153         u16 index;
 154         u16 len;
 155         __le32 data;
 156
 157         request = 0x05;
 158         requesttype = 0x01;/* read_in */
 159         index = 0;/* n/a */
 160
 161         wvalue = (u16)(addr&0x0000ffff);
 162         len = 4;
 163
 164         usbctrl_vendorreq(pintfhdl, request, wvalue, index, &data, len, requesttype);
 165
 166         return le32_to_cpu(data);
 167 }
 168
 169 static int usb_write8(struct intf_hdl *pintfhdl, u32 addr, u8 val)
 170 {
 171         u8 request;
 172         u8 requesttype;
 173         u16 wvalue;
 174         u16 index;
 175         u16 len;
 176         u8 data;
 177         int ret;
 178
 179
 180         request = 0x05;
 181         requesttype = 0x00;/* write_out */
 182         index = 0;/* n/a */
 183         wvalue = (u16)(addr&0x0000ffff);
 184         len = 1;
 185         data = val;
 186         ret = usbctrl_vendorreq(pintfhdl, request, wvalue, index, &data, len, requesttype);
 187
 188         return ret;
 189 }
 190
 191 static int usb_write16(struct intf_hdl *pintfhdl, u32 addr, u16 val)
 192 {
 193         u8 request;
 194         u8 requesttype;
 195         u16 wvalue;
 196         u16 index;
 197         u16 len;
 198         __le32 data;
 199         int ret;
 200
 201
 202
 203         request = 0x05;
 204         requesttype = 0x00;/* write_out */
 205         index = 0;/* n/a */
 206
 207         wvalue = (u16)(addr&0x0000ffff);
 208         len = 2;
 209
 210         data = cpu_to_le32(val & 0x0000ffff);
 211
 212         ret = usbctrl_vendorreq(pintfhdl, request, wvalue, index, &data, len, requesttype);
 213
 214
 215
 216         return ret;
 217 }
 218
 219 static int usb_write32(struct intf_hdl *pintfhdl, u32 addr, u32 val)
 220 {
 221         u8 request;
 222         u8 requesttype;
 223         u16 wvalue;
 224         u16 index;
 225         u16 len;
 226         __le32 data;
 227         int ret;
 228
 229
 230
 231         request = 0x05;
 232         requesttype = 0x00;/* write_out */
 233         index = 0;/* n/a */
 234
 235         wvalue = (u16)(addr&0x0000ffff);
 236         len = 4;
 237         data = cpu_to_le32(val);
 238
 239         ret = usbctrl_vendorreq(pintfhdl, request, wvalue, index, &data, len, requesttype);
 240
 241
 242
 243         return ret;
 244 }
 245
 246 static int usb_writeN(struct intf_hdl *pintfhdl, u32 addr, u32 length, u8 *pdata)
 247 {
 248         u8 request;
 249         u8 requesttype;
 250         u16 wvalue;
 251         u16 index;
 252         u16 len;
 253         u8 buf[VENDOR_CMD_MAX_DATA_LEN] = {0};
 254         int ret;
 255
 256
 257
 258         request = 0x05;
 259         requesttype = 0x00;/* write_out */
 260         index = 0;/* n/a */
 261
 262         wvalue = (u16)(addr&0x0000ffff);
 263         len = length;
 264          memcpy(buf, pdata, len);
 265
 266         ret = usbctrl_vendorreq(pintfhdl, request, wvalue, index, buf, len, requesttype);
 267
 268
 269
 270         return ret;
 271 }
 272
 273 static void interrupt_handler_8188eu(struct adapter *adapt, u16 pkt_len, u8 *pbuf)
 274 {
 275         struct hal_data_8188e   *haldata = GET_HAL_DATA(adapt);
 276
 277         if (pkt_len != INTERRUPT_MSG_FORMAT_LEN) {
 278                 DBG_88E("%s Invalid interrupt content length (%d)!\n", __func__, pkt_len);
 279                 return;
 280         }
 281
 282         /*  HISR */
 283         memcpy(&(haldata->IntArray[0]), &(pbuf[USB_INTR_CONTENT_HISR_OFFSET]), 4);
 284         memcpy(&(haldata->IntArray[1]), &(pbuf[USB_INTR_CONTENT_HISRE_OFFSET]), 4);
 285
 286         /*  C2H Event */
 287         if (pbuf[0] != 0)
 288                 memcpy(&(haldata->C2hArray[0]), &(pbuf[USB_INTR_CONTENT_C2H_OFFSET]), 16);
 289 }
 290
 291 static int recvbuf2recvframe(struct adapter *adapt, struct sk_buff *pskb)
 292 {
 293         u8      *pbuf;
 294         u8      shift_sz = 0;
 295         u16     pkt_cnt;
 296         u32     pkt_offset, skb_len, alloc_sz;
 297         s32     transfer_len;
 298         struct recv_stat        *prxstat;
 299         struct phy_stat *pphy_status = NULL;
 300         struct sk_buff *pkt_copy = NULL;
 301         struct recv_frame       *precvframe = NULL;
 302         struct rx_pkt_attrib    *pattrib = NULL;
 303         struct hal_data_8188e   *haldata = GET_HAL_DATA(adapt);
 304         struct recv_priv        *precvpriv = &adapt->recvpriv;
 305         struct __queue *pfree_recv_queue = &precvpriv->free_recv_queue;
 306
 307         transfer_len = (s32)pskb->len;
 308         pbuf = pskb->data;
 309
 310         prxstat = (struct recv_stat *)pbuf;
 311         pkt_cnt = (le32_to_cpu(prxstat->rxdw2) >> 16) & 0xff;
 312
 313         do {
 314                 RT_TRACE(_module_rtl871x_recv_c_, _drv_info_,
 315                          ("recvbuf2recvframe: rxdesc=offsset 0:0x%08x, 4:0x%08x, 8:0x%08x, C:0x%08x\n",
 316                           prxstat->rxdw0, prxstat->rxdw1, prxstat->rxdw2, prxstat->rxdw4));
 317
 318                 prxstat = (struct recv_stat *)pbuf;
 319
 320                 precvframe = rtw_alloc_recvframe(pfree_recv_queue);
 321                 if (precvframe == NULL) {
 322                         RT_TRACE(_module_rtl871x_recv_c_, _drv_err_, ("recvbuf2recvframe: precvframe==NULL\n"));
 323                         DBG_88E("%s()-%d: rtw_alloc_recvframe() failed! RX Drop!\n", __func__, __LINE__);
 324                         goto _exit_recvbuf2recvframe;
 325                 }
 326
 327                 INIT_LIST_HEAD(&precvframe->list);
 328                 precvframe->precvbuf = NULL;    /* can't access the precvbuf for new arch. */
 329                 precvframe->len = 0;
 330
 331                 update_recvframe_attrib_88e(precvframe, prxstat);
 332
 333                 pattrib = &precvframe->attrib;
 334
 335                 if ((pattrib->crc_err) || (pattrib->icv_err)) {
 336                         DBG_88E("%s: RX Warning! crc_err=%d icv_err=%d, skip!\n", __func__, pattrib->crc_err, pattrib->icv_err);
 337
 338                         rtw_free_recvframe(precvframe, pfree_recv_queue);
 339                         goto _exit_recvbuf2recvframe;
 340                 }
 341
 342                 if ((pattrib->physt) && (pattrib->pkt_rpt_type == NORMAL_RX))
 343                         pphy_status = (struct phy_stat *)(pbuf + RXDESC_OFFSET);
 344
 345                 pkt_offset = RXDESC_SIZE + pattrib->drvinfo_sz + pattrib->shift_sz + pattrib->pkt_len;
 346
 347                 if ((pattrib->pkt_len <= 0) || (pkt_offset > transfer_len)) {
 348                         RT_TRACE(_module_rtl871x_recv_c_, _drv_info_, ("recvbuf2recvframe: pkt_len<=0\n"));
 349                         DBG_88E("%s()-%d: RX Warning!,pkt_len<=0 or pkt_offset> transfoer_len\n", __func__, __LINE__);
 350                         rtw_free_recvframe(precvframe, pfree_recv_queue);
 351                         goto _exit_recvbuf2recvframe;
 352                 }
 353
 354                 /*      Modified by Albert 20101213 */
 355                 /*      For 8 bytes IP header alignment. */
 356                 if (pattrib->qos)       /*      Qos data, wireless lan header length is 26 */
 357                         shift_sz = 6;
 358                 else
 359                         shift_sz = 0;
 360
 361                 skb_len = pattrib->pkt_len;
 362
 363                 /*  for first fragment packet, driver need allocate 1536+drvinfo_sz+RXDESC_SIZE to defrag packet. */
 364                 /*  modify alloc_sz for recvive crc error packet by thomas 2011-06-02 */
 365                 if ((pattrib->mfrag == 1) && (pattrib->frag_num == 0)) {
 366                         if (skb_len <= 1650)
 367                                 alloc_sz = 1664;
 368                         else
 369                                 alloc_sz = skb_len + 14;
 370                 } else {
 371                         alloc_sz = skb_len;
 372                         /*      6 is for IP header 8 bytes alignment in QoS packet case. */
 373                         /*      8 is for skb->data 4 bytes alignment. */
 374                         alloc_sz += 14;
 375                 }
 376
 377                 pkt_copy = netdev_alloc_skb(adapt->pnetdev, alloc_sz);
 378                 if (pkt_copy) {
 379                         pkt_copy->dev = adapt->pnetdev;
 380                         precvframe->pkt = pkt_copy;
 381                         precvframe->rx_head = pkt_copy->data;
 382                         precvframe->rx_end = pkt_copy->data + alloc_sz;
 383                         skb_reserve(pkt_copy, 8 - ((size_t)(pkt_copy->data) & 7));/* force pkt_copy->data at 8-byte alignment address */
 384                         skb_reserve(pkt_copy, shift_sz);/* force ip_hdr at 8-byte alignment address according to shift_sz. */
 385                         memcpy(pkt_copy->data, (pbuf + pattrib->drvinfo_sz + RXDESC_SIZE), skb_len);
 386                         precvframe->rx_tail = pkt_copy->data;
 387                         precvframe->rx_data = pkt_copy->data;
 388                 } else {
 389                         if ((pattrib->mfrag == 1) && (pattrib->frag_num == 0)) {
 390                                 DBG_88E("recvbuf2recvframe: alloc_skb fail , drop frag frame\n");
 391                                 rtw_free_recvframe(precvframe, pfree_recv_queue);
 392                                 goto _exit_recvbuf2recvframe;
 393                         }
 394                         precvframe->pkt = skb_clone(pskb, GFP_ATOMIC);
 395                         if (precvframe->pkt) {
 396                                 precvframe->rx_tail = pbuf + pattrib->drvinfo_sz + RXDESC_SIZE;
 397                                 precvframe->rx_head = precvframe->rx_tail;
 398                                 precvframe->rx_data = precvframe->rx_tail;
 399                                 precvframe->rx_end =  pbuf + pattrib->drvinfo_sz + RXDESC_SIZE + alloc_sz;
 400                         } else {
 401                                 DBG_88E("recvbuf2recvframe: skb_clone fail\n");
 402                                 rtw_free_recvframe(precvframe, pfree_recv_queue);
 403                                 goto _exit_recvbuf2recvframe;
 404                         }
 405                 }
 406
 407                 recvframe_put(precvframe, skb_len);
 408
 409                 switch (haldata->UsbRxAggMode) {
 410                 case USB_RX_AGG_DMA:
 411                 case USB_RX_AGG_MIX:
 412                         pkt_offset = (u16)_RND128(pkt_offset);
 413                         break;
 414                 case USB_RX_AGG_USB:
 415                         pkt_offset = (u16)_RND4(pkt_offset);
 416                         break;
 417                 case USB_RX_AGG_DISABLE:
 418                 default:
 419                         break;
 420                 }
 421                 if (pattrib->pkt_rpt_type == NORMAL_RX) { /* Normal rx packet */
 422                         if (pattrib->physt)
 423                                 update_recvframe_phyinfo_88e(precvframe, (struct phy_stat *)pphy_status);
 424                         if (rtw_recv_entry(precvframe) != _SUCCESS) {
 425                                 RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
 426                                         ("recvbuf2recvframe: rtw_recv_entry(precvframe) != _SUCCESS\n"));
 427                         }
 428                 } else {
 429                         /* enqueue recvframe to txrtp queue */
 430                         if (pattrib->pkt_rpt_type == TX_REPORT1) {
 431                                 /* CCX-TXRPT ack for xmit mgmt frames. */
 432                                 handle_txrpt_ccx_88e(adapt, precvframe->rx_data);
 433                         } else if (pattrib->pkt_rpt_type == TX_REPORT2) {
 434                                 ODM_RA_TxRPT2Handle_8188E(
 435                                                         &haldata->odmpriv,
 436                                                         precvframe->rx_data,
 437                                                         pattrib->pkt_len,
 438                                                         pattrib->MacIDValidEntry[0],
 439                                                         pattrib->MacIDValidEntry[1]
 440                                                         );
 441                         } else if (pattrib->pkt_rpt_type == HIS_REPORT) {
 442                                 interrupt_handler_8188eu(adapt, pattrib->pkt_len, precvframe->rx_data);
 443                         }
 444                         rtw_free_recvframe(precvframe, pfree_recv_queue);
 445                 }
 446                 pkt_cnt--;
 447                 transfer_len -= pkt_offset;
 448                 pbuf += pkt_offset;
 449                 precvframe = NULL;
 450                 pkt_copy = NULL;
 451
 452                 if (transfer_len > 0 && pkt_cnt == 0)
 453                         pkt_cnt = (le32_to_cpu(prxstat->rxdw2)>>16) & 0xff;
 454
 455         } while ((transfer_len > 0) && (pkt_cnt > 0));
 456
 457 _exit_recvbuf2recvframe:
 458
 459         return _SUCCESS;
 460 }
 461
 462 void rtl8188eu_recv_tasklet(void *priv)
 463 {
 464         struct sk_buff *pskb;
 465         struct adapter *adapt = (struct adapter *)priv;
 466         struct recv_priv *precvpriv = &adapt->recvpriv;
 467
 468         while (NULL != (pskb = skb_dequeue(&precvpriv->rx_skb_queue))) {
 469                 if ((adapt->bDriverStopped) || (adapt->bSurpriseRemoved)) {
 470                         DBG_88E("recv_tasklet => bDriverStopped or bSurpriseRemoved\n");
 471                         dev_kfree_skb_any(pskb);
 472                         break;
 473                 }
 474                 recvbuf2recvframe(adapt, pskb);
 475                 skb_reset_tail_pointer(pskb);
 476                 pskb->len = 0;
 477                 skb_queue_tail(&precvpriv->free_recv_skb_queue, pskb);
 478         }
 479 }
 480
 481 static void usb_read_port_complete(struct urb *purb, struct pt_regs *regs)
 482 {
 483         struct recv_buf *precvbuf = (struct recv_buf *)purb->context;
 484         struct adapter  *adapt = (struct adapter *)precvbuf->adapter;
 485         struct recv_priv *precvpriv = &adapt->recvpriv;
 486
 487         RT_TRACE(_module_hci_ops_os_c_, _drv_err_, ("usb_read_port_complete!!!\n"));
 488
 489         precvpriv->rx_pending_cnt--;
 490
 491         if (adapt->bSurpriseRemoved || adapt->bDriverStopped || adapt->bReadPortCancel) {
 492                 RT_TRACE(_module_hci_ops_os_c_, _drv_err_,
 493                          ("usb_read_port_complete:bDriverStopped(%d) OR bSurpriseRemoved(%d)\n",
 494                          adapt->bDriverStopped, adapt->bSurpriseRemoved));
 495
 496                 precvbuf->reuse = true;
 497                 DBG_88E("%s() RX Warning! bDriverStopped(%d) OR bSurpriseRemoved(%d) bReadPortCancel(%d)\n",
 498                         __func__, adapt->bDriverStopped,
 499                         adapt->bSurpriseRemoved, adapt->bReadPortCancel);
 500                 return;
 501         }
 502
 503         if (purb->status == 0) { /* SUCCESS */
 504                 if ((purb->actual_length > MAX_RECVBUF_SZ) || (purb->actual_length < RXDESC_SIZE)) {
 505                         RT_TRACE(_module_hci_ops_os_c_, _drv_err_,
 506                                  ("usb_read_port_complete: (purb->actual_length > MAX_RECVBUF_SZ) || (purb->actual_length < RXDESC_SIZE)\n"));
 507                         precvbuf->reuse = true;
 508                         rtw_read_port(adapt, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
 509                         DBG_88E("%s()-%d: RX Warning!\n", __func__, __LINE__);
 510                 } else {
 511                         rtw_reset_continual_urb_error(adapter_to_dvobj(adapt));
 512
 513                         precvbuf->transfer_len = purb->actual_length;
 514                         skb_put(precvbuf->pskb, purb->actual_length);
 515                         skb_queue_tail(&precvpriv->rx_skb_queue, precvbuf->pskb);
 516
 517                         if (skb_queue_len(&precvpriv->rx_skb_queue) <= 1)
 518                                 tasklet_schedule(&precvpriv->recv_tasklet);
 519
 520                         precvbuf->pskb = NULL;
 521                         precvbuf->reuse = false;
 522                         rtw_read_port(adapt, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
 523                 }
 524         } else {
 525                 RT_TRACE(_module_hci_ops_os_c_, _drv_err_, ("usb_read_port_complete : purb->status(%d) != 0\n", purb->status));
 526
 527                 DBG_88E("###=> usb_read_port_complete => urb status(%d)\n", purb->status);
 528                 skb_put(precvbuf->pskb, purb->actual_length);
 529                 precvbuf->pskb = NULL;
 530
 531                 if (rtw_inc_and_chk_continual_urb_error(adapter_to_dvobj(adapt)))
 532                         adapt->bSurpriseRemoved = true;
 533
 534                 switch (purb->status) {
 535                 case -EINVAL:
 536                 case -EPIPE:
 537                 case -ENODEV:
 538                 case -ESHUTDOWN:
 539                         RT_TRACE(_module_hci_ops_os_c_, _drv_err_, ("usb_read_port_complete:bSurpriseRemoved=true\n"));
 540                         __attribute__((__fallthrough__));
 541                 case -ENOENT:
 542                         adapt->bDriverStopped = true;
 543                         RT_TRACE(_module_hci_ops_os_c_, _drv_err_, ("usb_read_port_complete:bDriverStopped=true\n"));
 544                         break;
 545                 case -EPROTO:
 546                 case -EOVERFLOW:
 547                         {
 548                                 struct hal_data_8188e   *haldata = GET_HAL_DATA(adapt);
 549                                 haldata->srestpriv.Wifi_Error_Status = USB_READ_PORT_FAIL;
 550                         }
 551                         precvbuf->reuse = true;
 552                         rtw_read_port(adapt, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
 553                         break;
 554                 case -EINPROGRESS:
 555                         DBG_88E("ERROR: URB IS IN PROGRESS!/n");
 556                         break;
 557                 default:
 558                         break;
 559                 }
 560         }
 561 }
 562
 563 static u32 usb_read_port(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *rmem)
 564 {
 565         struct urb *purb = NULL;
 566         struct recv_buf *precvbuf = (struct recv_buf *)rmem;
 567         struct adapter          *adapter = pintfhdl->padapter;
 568         struct dvobj_priv       *pdvobj = adapter_to_dvobj(adapter);
 569         struct recv_priv        *precvpriv = &adapter->recvpriv;
 570         struct usb_device       *pusbd = pdvobj->pusbdev;
 571         int err;
 572         unsigned int pipe;
 573         size_t tmpaddr = 0;
 574         size_t alignment = 0;
 575         u32 ret = _SUCCESS;
 576
 577         if (adapter->bDriverStopped || adapter->bSurpriseRemoved ||
 578             adapter->pwrctrlpriv.pnp_bstop_trx) {
 579                 RT_TRACE(_module_hci_ops_os_c_, _drv_err_,
 580                          ("usb_read_port:(adapt->bDriverStopped ||adapt->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n"));
 581                 return _FAIL;
 582         }
 583
 584         if (!precvbuf) {
 585                 RT_TRACE(_module_hci_ops_os_c_, _drv_err_,
 586                          ("usb_read_port:precvbuf==NULL\n"));
 587                 return _FAIL;
 588         }
 589
 590         if ((!precvbuf->reuse) || (precvbuf->pskb == NULL)) {
 591                 precvbuf->pskb = skb_dequeue(&precvpriv->free_recv_skb_queue);
 592                 if (NULL != precvbuf->pskb)
 593                         precvbuf->reuse = true;
 594         }
 595
 596                 rtl8188eu_init_recvbuf(adapter, precvbuf);
 597
 598                 /* re-assign for linux based on skb */
 599                 if ((!precvbuf->reuse) || (precvbuf->pskb == NULL)) {
 600                         precvbuf->pskb = netdev_alloc_skb(adapter->pnetdev, MAX_RECVBUF_SZ + RECVBUFF_ALIGN_SZ);
 601                         if (precvbuf->pskb == NULL) {
 602                                 RT_TRACE(_module_hci_ops_os_c_, _drv_err_, ("init_recvbuf(): alloc_skb fail!\n"));
 603                                 DBG_88E("#### usb_read_port() alloc_skb fail!#####\n");
 604                                 return _FAIL;
 605                         }
 606
 607                         tmpaddr = (size_t)precvbuf->pskb->data;
 608                         alignment = tmpaddr & (RECVBUFF_ALIGN_SZ-1);
 609                         skb_reserve(precvbuf->pskb, (RECVBUFF_ALIGN_SZ - alignment));
 610
 611                         precvbuf->phead = precvbuf->pskb->head;
 612                         precvbuf->pdata = precvbuf->pskb->data;
 613                         precvbuf->ptail = skb_tail_pointer(precvbuf->pskb);
 614                         precvbuf->pend = skb_end_pointer(precvbuf->pskb);
 615                         precvbuf->pbuf = precvbuf->pskb->data;
 616                 } else { /* reuse skb */
 617                         precvbuf->phead = precvbuf->pskb->head;
 618                         precvbuf->pdata = precvbuf->pskb->data;
 619                         precvbuf->ptail = skb_tail_pointer(precvbuf->pskb);
 620                         precvbuf->pend = skb_end_pointer(precvbuf->pskb);
 621                         precvbuf->pbuf = precvbuf->pskb->data;
 622
 623                         precvbuf->reuse = false;
 624                 }
 625
 626                 precvpriv->rx_pending_cnt++;
 627
 628                 purb = precvbuf->purb;
 629
 630                 /* translate DMA FIFO addr to pipehandle */
 631                 pipe = ffaddr2pipehdl(pdvobj, addr);
 632
 633                 usb_fill_bulk_urb(purb, pusbd, pipe,
 634                                   precvbuf->pbuf,
 635                                   MAX_RECVBUF_SZ,
 636                                   usb_read_port_complete,
 637                                   precvbuf);/* context is precvbuf */
 638
 639                 err = usb_submit_urb(purb, GFP_ATOMIC);
 640                 if ((err) && (err != (-EPERM))) {
 641                         RT_TRACE(_module_hci_ops_os_c_, _drv_err_,
 642                                  ("cannot submit rx in-token(err=0x%.8x), URB_STATUS =0x%.8x",
 643                                  err, purb->status));
 644                         DBG_88E("cannot submit rx in-token(err = 0x%08x),urb_status = %d\n",
 645                                 err, purb->status);
 646                         ret = _FAIL;
 647                 }
 648
 649         return ret;
 650 }
 651
 652 void rtl8188eu_xmit_tasklet(void *priv)
 653 {
 654         int ret = false;
 655         struct adapter *adapt = (struct adapter *)priv;
 656         struct xmit_priv *pxmitpriv = &adapt->xmitpriv;
 657
 658         if (check_fwstate(&adapt->mlmepriv, _FW_UNDER_SURVEY))
 659                 return;
 660
 661         while (1) {
 662                 if ((adapt->bDriverStopped) ||
 663                     (adapt->bSurpriseRemoved) ||
 664                     (adapt->bWritePortCancel)) {
 665                         DBG_88E("xmit_tasklet => bDriverStopped or bSurpriseRemoved or bWritePortCancel\n");
 666                         break;
 667                 }
 668
 669                 ret = rtl8188eu_xmitframe_complete(adapt, pxmitpriv, NULL);
 670
 671                 if (!ret)
 672                         break;
 673         }
 674 }
 675
 676 void rtl8188eu_set_intf_ops(struct _io_ops      *pops)
 677 {
 678
 679         memset((u8 *)pops, 0, sizeof(struct _io_ops));
 680         pops->_read8 = &usb_read8;
 681         pops->_read16 = &usb_read16;
 682         pops->_read32 = &usb_read32;
 683         pops->_read_mem = &usb_read_mem;
 684         pops->_read_port = &usb_read_port;
 685         pops->_write8 = &usb_write8;
 686         pops->_write16 = &usb_write16;
 687         pops->_write32 = &usb_write32;
 688         pops->_writeN = &usb_writeN;
 689         pops->_write_mem = &usb_write_mem;
 690         pops->_write_port = &usb_write_port;
 691         pops->_read_port_cancel = &usb_read_port_cancel;
 692         pops->_write_port_cancel = &usb_write_port_cancel;
 693
 694 }
 695
 696 void rtl8188eu_set_hw_type(struct adapter *adapt)
 697 {
 698         adapt->chip_type = RTL8188E;
 699         adapt->HardwareType = HARDWARE_TYPE_RTL8188EU;
 700         DBG_88E("CHIP TYPE: RTL8188E\n");
 701 }