drivers/net/wireless/rtlwifi/usb.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2009-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  * The full GNU General Public License is included in this distribution in the
  19  * file called LICENSE.
  20  *
  21  * Contact Information:
  22  * wlanfae <wlanfae@realtek.com>
  23  * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
  24  * Hsinchu 300, Taiwan.
  25  *
  26  *****************************************************************************/
  27
  28 #include "wifi.h"
  29 #include "core.h"
  30 #include "usb.h"
  31 #include "base.h"
  32 #include "ps.h"
  33 #include "rtl8192c/fw_common.h"
  34 #include <linux/export.h>
  35
  36 #define REALTEK_USB_VENQT_READ                  0xC0
  37 #define REALTEK_USB_VENQT_WRITE                 0x40
  38 #define REALTEK_USB_VENQT_CMD_REQ               0x05
  39 #define REALTEK_USB_VENQT_CMD_IDX               0x00
  40
  41 #define MAX_USBCTRL_VENDORREQ_TIMES             10
  42
  43 static void usbctrl_async_callback(struct urb *urb)
  44 {
  45         if (urb)
  46                 kfree(urb->context);
  47 }
  48
  49 static int _usbctrl_vendorreq_async_write(struct usb_device *udev, u8 request,
  50                                           u16 value, u16 index, void *pdata,
  51                                           u16 len)
  52 {
  53         int rc;
  54         unsigned int pipe;
  55         u8 reqtype;
  56         struct usb_ctrlrequest *dr;
  57         struct urb *urb;
  58         struct rtl819x_async_write_data {
  59                 u8 data[REALTEK_USB_VENQT_MAX_BUF_SIZE];
  60                 struct usb_ctrlrequest dr;
  61         } *buf;
  62
  63         pipe = usb_sndctrlpipe(udev, 0); /* write_out */
  64         reqtype =  REALTEK_USB_VENQT_WRITE;
  65
  66         buf = kmalloc(sizeof(*buf), GFP_ATOMIC);
  67         if (!buf)
  68                 return -ENOMEM;
  69
  70         urb = usb_alloc_urb(0, GFP_ATOMIC);
  71         if (!urb) {
  72                 kfree(buf);
  73                 return -ENOMEM;
  74         }
  75
  76         dr = &buf->dr;
  77
  78         dr->bRequestType = reqtype;
  79         dr->bRequest = request;
  80         dr->wValue = cpu_to_le16(value);
  81         dr->wIndex = cpu_to_le16(index);
  82         dr->wLength = cpu_to_le16(len);
  83         /* data are already in little-endian order */
  84         memcpy(buf, pdata, len);
  85         usb_fill_control_urb(urb, udev, pipe,
  86                              (unsigned char *)dr, buf, len,
  87                              usbctrl_async_callback, buf);
  88         rc = usb_submit_urb(urb, GFP_ATOMIC);
  89         if (rc < 0)
  90                 kfree(buf);
  91         usb_free_urb(urb);
  92         return rc;
  93 }
  94
  95 static int _usbctrl_vendorreq_sync_read(struct usb_device *udev, u8 request,
  96                                         u16 value, u16 index, void *pdata,
  97                                         u16 len)
  98 {
  99         unsigned int pipe;
 100         int status;
 101         u8 reqtype;
 102         int vendorreq_times = 0;
 103         static int count;
 104
 105         pipe = usb_rcvctrlpipe(udev, 0); /* read_in */
 106         reqtype =  REALTEK_USB_VENQT_READ;
 107
 108         do {
 109                 status = usb_control_msg(udev, pipe, request, reqtype, value,
 110                                          index, pdata, len, 0); /*max. timeout*/
 111                 if (status < 0) {
 112                         /* firmware download is checksumed, don't retry */
 113                         if ((value >= FW_8192C_START_ADDRESS &&
 114                             value <= FW_8192C_END_ADDRESS))
 115                                 break;
 116                 } else {
 117                         break;
 118                 }
 119         } while (++vendorreq_times < MAX_USBCTRL_VENDORREQ_TIMES);
 120
 121         if (status < 0 && count++ < 4)
 122                 pr_err("reg 0x%x, usbctrl_vendorreq TimeOut! status:0x%x value=0x%x\n",
 123                        value, status, *(u32 *)pdata);
 124         return status;
 125 }
 126
 127 static u32 _usb_read_sync(struct rtl_priv *rtlpriv, u32 addr, u16 len)
 128 {
 129         struct device *dev = rtlpriv->io.dev;
 130         struct usb_device *udev = to_usb_device(dev);
 131         u8 request;
 132         u16 wvalue;
 133         u16 index;
 134         __le32 *data;
 135         unsigned long flags;
 136
 137         spin_lock_irqsave(&rtlpriv->locks.usb_lock, flags);
 138         if (++rtlpriv->usb_data_index >= RTL_USB_MAX_RX_COUNT)
 139                 rtlpriv->usb_data_index = 0;
 140         data = &rtlpriv->usb_data[rtlpriv->usb_data_index];
 141         spin_unlock_irqrestore(&rtlpriv->locks.usb_lock, flags);
 142         request = REALTEK_USB_VENQT_CMD_REQ;
 143         index = REALTEK_USB_VENQT_CMD_IDX; /* n/a */
 144
 145         wvalue = (u16)addr;
 146         _usbctrl_vendorreq_sync_read(udev, request, wvalue, index, data, len);
 147         return le32_to_cpu(*data);
 148 }
 149
 150 static u8 _usb_read8_sync(struct rtl_priv *rtlpriv, u32 addr)
 151 {
 152         return (u8)_usb_read_sync(rtlpriv, addr, 1);
 153 }
 154
 155 static u16 _usb_read16_sync(struct rtl_priv *rtlpriv, u32 addr)
 156 {
 157         return (u16)_usb_read_sync(rtlpriv, addr, 2);
 158 }
 159
 160 static u32 _usb_read32_sync(struct rtl_priv *rtlpriv, u32 addr)
 161 {
 162         return _usb_read_sync(rtlpriv, addr, 4);
 163 }
 164
 165 static void _usb_write_async(struct usb_device *udev, u32 addr, u32 val,
 166                              u16 len)
 167 {
 168         u8 request;
 169         u16 wvalue;
 170         u16 index;
 171         __le32 data;
 172
 173         request = REALTEK_USB_VENQT_CMD_REQ;
 174         index = REALTEK_USB_VENQT_CMD_IDX; /* n/a */
 175         wvalue = (u16)(addr&0x0000ffff);
 176         data = cpu_to_le32(val);
 177         _usbctrl_vendorreq_async_write(udev, request, wvalue, index, &data,
 178                                        len);
 179 }
 180
 181 static void _usb_write8_async(struct rtl_priv *rtlpriv, u32 addr, u8 val)
 182 {
 183         struct device *dev = rtlpriv->io.dev;
 184
 185         _usb_write_async(to_usb_device(dev), addr, val, 1);
 186 }
 187
 188 static void _usb_write16_async(struct rtl_priv *rtlpriv, u32 addr, u16 val)
 189 {
 190         struct device *dev = rtlpriv->io.dev;
 191
 192         _usb_write_async(to_usb_device(dev), addr, val, 2);
 193 }
 194
 195 static void _usb_write32_async(struct rtl_priv *rtlpriv, u32 addr, u32 val)
 196 {
 197         struct device *dev = rtlpriv->io.dev;
 198
 199         _usb_write_async(to_usb_device(dev), addr, val, 4);
 200 }
 201
 202 static void _usb_writeN_sync(struct rtl_priv *rtlpriv, u32 addr, void *data,
 203                              u16 len)
 204 {
 205         struct device *dev = rtlpriv->io.dev;
 206         struct usb_device *udev = to_usb_device(dev);
 207         u8 request = REALTEK_USB_VENQT_CMD_REQ;
 208         u8 reqtype =  REALTEK_USB_VENQT_WRITE;
 209         u16 wvalue;
 210         u16 index = REALTEK_USB_VENQT_CMD_IDX;
 211         int pipe = usb_sndctrlpipe(udev, 0); /* write_out */
 212         u8 *buffer;
 213         dma_addr_t dma_addr;
 214
 215         wvalue = (u16)(addr&0x0000ffff);
 216         buffer = usb_alloc_coherent(udev, (size_t)len, GFP_ATOMIC, &dma_addr);
 217         if (!buffer)
 218                 return;
 219         memcpy(buffer, data, len);
 220         usb_control_msg(udev, pipe, request, reqtype, wvalue,
 221                         index, buffer, len, 50);
 222
 223         usb_free_coherent(udev, (size_t)len, buffer, dma_addr);
 224 }
 225
 226 static void _rtl_usb_io_handler_init(struct device *dev,
 227                                      struct ieee80211_hw *hw)
 228 {
 229         struct rtl_priv *rtlpriv = rtl_priv(hw);
 230
 231         rtlpriv->io.dev = dev;
 232         mutex_init(&rtlpriv->io.bb_mutex);
 233         rtlpriv->io.write8_async        = _usb_write8_async;
 234         rtlpriv->io.write16_async       = _usb_write16_async;
 235         rtlpriv->io.write32_async       = _usb_write32_async;
 236         rtlpriv->io.read8_sync          = _usb_read8_sync;
 237         rtlpriv->io.read16_sync         = _usb_read16_sync;
 238         rtlpriv->io.read32_sync         = _usb_read32_sync;
 239         rtlpriv->io.writeN_sync         = _usb_writeN_sync;
 240 }
 241
 242 static void _rtl_usb_io_handler_release(struct ieee80211_hw *hw)
 243 {
 244         struct rtl_priv __maybe_unused *rtlpriv = rtl_priv(hw);
 245
 246         mutex_destroy(&rtlpriv->io.bb_mutex);
 247 }
 248
 249 /**
 250  *
 251  *      Default aggregation handler. Do nothing and just return the oldest skb.
 252  */
 253 static struct sk_buff *_none_usb_tx_aggregate_hdl(struct ieee80211_hw *hw,
 254                                                   struct sk_buff_head *list)
 255 {
 256         return skb_dequeue(list);
 257 }
 258
 259 #define IS_HIGH_SPEED_USB(udev) \
 260                 ((USB_SPEED_HIGH == (udev)->speed) ? true : false)
 261
 262 static int _rtl_usb_init_tx(struct ieee80211_hw *hw)
 263 {
 264         u32 i;
 265         struct rtl_priv *rtlpriv = rtl_priv(hw);
 266         struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
 267
 268         rtlusb->max_bulk_out_size = IS_HIGH_SPEED_USB(rtlusb->udev)
 269                                                     ? USB_HIGH_SPEED_BULK_SIZE
 270                                                     : USB_FULL_SPEED_BULK_SIZE;
 271
 272         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "USB Max Bulk-out Size=%d\n",
 273                  rtlusb->max_bulk_out_size);
 274
 275         for (i = 0; i < __RTL_TXQ_NUM; i++) {
 276                 u32 ep_num = rtlusb->ep_map.ep_mapping[i];
 277                 if (!ep_num) {
 278                         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
 279                                  "Invalid endpoint map setting!\n");
 280                         return -EINVAL;
 281                 }
 282         }
 283
 284         rtlusb->usb_tx_post_hdl =
 285                  rtlpriv->cfg->usb_interface_cfg->usb_tx_post_hdl;
 286         rtlusb->usb_tx_cleanup  =
 287                  rtlpriv->cfg->usb_interface_cfg->usb_tx_cleanup;
 288         rtlusb->usb_tx_aggregate_hdl =
 289                  (rtlpriv->cfg->usb_interface_cfg->usb_tx_aggregate_hdl)
 290                  ? rtlpriv->cfg->usb_interface_cfg->usb_tx_aggregate_hdl
 291                  : &_none_usb_tx_aggregate_hdl;
 292
 293         init_usb_anchor(&rtlusb->tx_submitted);
 294         for (i = 0; i < RTL_USB_MAX_EP_NUM; i++) {
 295                 skb_queue_head_init(&rtlusb->tx_skb_queue[i]);
 296                 init_usb_anchor(&rtlusb->tx_pending[i]);
 297         }
 298         return 0;
 299 }
 300
 301 static int _rtl_usb_init_rx(struct ieee80211_hw *hw)
 302 {
 303         struct rtl_priv *rtlpriv = rtl_priv(hw);
 304         struct rtl_usb_priv *usb_priv = rtl_usbpriv(hw);
 305         struct rtl_usb *rtlusb = rtl_usbdev(usb_priv);
 306
 307         rtlusb->rx_max_size = rtlpriv->cfg->usb_interface_cfg->rx_max_size;
 308         rtlusb->rx_urb_num = rtlpriv->cfg->usb_interface_cfg->rx_urb_num;
 309         rtlusb->in_ep = rtlpriv->cfg->usb_interface_cfg->in_ep_num;
 310         rtlusb->usb_rx_hdl = rtlpriv->cfg->usb_interface_cfg->usb_rx_hdl;
 311         rtlusb->usb_rx_segregate_hdl =
 312                 rtlpriv->cfg->usb_interface_cfg->usb_rx_segregate_hdl;
 313
 314         pr_info("rx_max_size %d, rx_urb_num %d, in_ep %d\n",
 315                 rtlusb->rx_max_size, rtlusb->rx_urb_num, rtlusb->in_ep);
 316         init_usb_anchor(&rtlusb->rx_submitted);
 317         return 0;
 318 }
 319
 320 static int _rtl_usb_init(struct ieee80211_hw *hw)
 321 {
 322         struct rtl_priv *rtlpriv = rtl_priv(hw);
 323         struct rtl_usb_priv *usb_priv = rtl_usbpriv(hw);
 324         struct rtl_usb *rtlusb = rtl_usbdev(usb_priv);
 325         int err;
 326         u8 epidx;
 327         struct usb_interface    *usb_intf = rtlusb->intf;
 328         u8 epnums = usb_intf->cur_altsetting->desc.bNumEndpoints;
 329
 330         rtlusb->out_ep_nums = rtlusb->in_ep_nums = 0;
 331         for (epidx = 0; epidx < epnums; epidx++) {
 332                 struct usb_endpoint_descriptor *pep_desc;
 333                 pep_desc = &usb_intf->cur_altsetting->endpoint[epidx].desc;
 334
 335                 if (usb_endpoint_dir_in(pep_desc))
 336                         rtlusb->in_ep_nums++;
 337                 else if (usb_endpoint_dir_out(pep_desc))
 338                         rtlusb->out_ep_nums++;
 339
 340                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
 341                          "USB EP(0x%02x), MaxPacketSize=%d, Interval=%d\n",
 342                          pep_desc->bEndpointAddress, pep_desc->wMaxPacketSize,
 343                          pep_desc->bInterval);
 344         }
 345         if (rtlusb->in_ep_nums <  rtlpriv->cfg->usb_interface_cfg->in_ep_num) {
 346                 pr_err("Too few input end points found\n");
 347                 return -EINVAL;
 348         }
 349         if (rtlusb->out_ep_nums == 0) {
 350                 pr_err("No output end points found\n");
 351                 return -EINVAL;
 352         }
 353         /* usb endpoint mapping */
 354         err = rtlpriv->cfg->usb_interface_cfg->usb_endpoint_mapping(hw);
 355         rtlusb->usb_mq_to_hwq =  rtlpriv->cfg->usb_interface_cfg->usb_mq_to_hwq;
 356         _rtl_usb_init_tx(hw);
 357         _rtl_usb_init_rx(hw);
 358         return err;
 359 }
 360
 361 static void rtl_usb_init_sw(struct ieee80211_hw *hw)
 362 {
 363         struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
 364         struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
 365         struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
 366         struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
 367
 368         rtlhal->hw = hw;
 369         ppsc->inactiveps = false;
 370         ppsc->leisure_ps = false;
 371         ppsc->fwctrl_lps = false;
 372         ppsc->reg_fwctrl_lps = 3;
 373         ppsc->reg_max_lps_awakeintvl = 5;
 374         ppsc->fwctrl_psmode = FW_PS_DTIM_MODE;
 375
 376          /* IBSS */
 377         mac->beacon_interval = 100;
 378
 379          /* AMPDU */
 380         mac->min_space_cfg = 0;
 381         mac->max_mss_density = 0;
 382
 383         /* set sane AMPDU defaults */
 384         mac->current_ampdu_density = 7;
 385         mac->current_ampdu_factor = 3;
 386
 387         /* QOS */
 388         rtlusb->acm_method = eAcmWay2_SW;
 389
 390         /* IRQ */
 391         /* HIMR - turn all on */
 392         rtlusb->irq_mask[0] = 0xFFFFFFFF;
 393         /* HIMR_EX - turn all on */
 394         rtlusb->irq_mask[1] = 0xFFFFFFFF;
 395         rtlusb->disableHWSM =  true;
 396 }
 397
 398 #define __RADIO_TAP_SIZE_RSV    32
 399
 400 static void _rtl_rx_completed(struct urb *urb);
 401
 402 static struct sk_buff *_rtl_prep_rx_urb(struct ieee80211_hw *hw,
 403                                         struct rtl_usb *rtlusb,
 404                                         struct urb *urb,
 405                                         gfp_t gfp_mask)
 406 {
 407         struct sk_buff *skb;
 408         struct rtl_priv *rtlpriv = rtl_priv(hw);
 409
 410         skb = __dev_alloc_skb((rtlusb->rx_max_size + __RADIO_TAP_SIZE_RSV),
 411                                gfp_mask);
 412         if (!skb) {
 413                 RT_TRACE(rtlpriv, COMP_USB, DBG_EMERG,
 414                          "Failed to __dev_alloc_skb!!\n");
 415                 return ERR_PTR(-ENOMEM);
 416         }
 417
 418         /* reserve some space for mac80211's radiotap */
 419         skb_reserve(skb, __RADIO_TAP_SIZE_RSV);
 420         usb_fill_bulk_urb(urb, rtlusb->udev,
 421                           usb_rcvbulkpipe(rtlusb->udev, rtlusb->in_ep),
 422                           skb->data, min(skb_tailroom(skb),
 423                           (int)rtlusb->rx_max_size),
 424                           _rtl_rx_completed, skb);
 425
 426         _rtl_install_trx_info(rtlusb, skb, rtlusb->in_ep);
 427         return skb;
 428 }
 429
 430 #undef __RADIO_TAP_SIZE_RSV
 431
 432 static void _rtl_usb_rx_process_agg(struct ieee80211_hw *hw,
 433                                     struct sk_buff *skb)
 434 {
 435         struct rtl_priv *rtlpriv = rtl_priv(hw);
 436         u8 *rxdesc = skb->data;
 437         struct ieee80211_hdr *hdr;
 438         bool unicast = false;
 439         __le16 fc;
 440         struct ieee80211_rx_status rx_status = {0};
 441         struct rtl_stats stats = {
 442                 .signal = 0,
 443                 .noise = -98,
 444                 .rate = 0,
 445         };
 446
 447         skb_pull(skb, RTL_RX_DESC_SIZE);
 448         rtlpriv->cfg->ops->query_rx_desc(hw, &stats, &rx_status, rxdesc, skb);
 449         skb_pull(skb, (stats.rx_drvinfo_size + stats.rx_bufshift));
 450         hdr = (struct ieee80211_hdr *)(skb->data);
 451         fc = hdr->frame_control;
 452         if (!stats.crc) {
 453                 memcpy(IEEE80211_SKB_RXCB(skb), &rx_status, sizeof(rx_status));
 454
 455                 if (is_broadcast_ether_addr(hdr->addr1)) {
 456                         /*TODO*/;
 457                 } else if (is_multicast_ether_addr(hdr->addr1)) {
 458                         /*TODO*/
 459                 } else {
 460                         unicast = true;
 461                         rtlpriv->stats.rxbytesunicast +=  skb->len;
 462                 }
 463
 464                 rtl_is_special_data(hw, skb, false);
 465
 466                 if (ieee80211_is_data(fc)) {
 467                         rtlpriv->cfg->ops->led_control(hw, LED_CTL_RX);
 468
 469                         if (unicast)
 470                                 rtlpriv->link_info.num_rx_inperiod++;
 471                 }
 472         }
 473 }
 474
 475 static void _rtl_usb_rx_process_noagg(struct ieee80211_hw *hw,
 476                                       struct sk_buff *skb)
 477 {
 478         struct rtl_priv *rtlpriv = rtl_priv(hw);
 479         u8 *rxdesc = skb->data;
 480         struct ieee80211_hdr *hdr;
 481         bool unicast = false;
 482         __le16 fc;
 483         struct ieee80211_rx_status rx_status = {0};
 484         struct rtl_stats stats = {
 485                 .signal = 0,
 486                 .noise = -98,
 487                 .rate = 0,
 488         };
 489
 490         skb_pull(skb, RTL_RX_DESC_SIZE);
 491         rtlpriv->cfg->ops->query_rx_desc(hw, &stats, &rx_status, rxdesc, skb);
 492         skb_pull(skb, (stats.rx_drvinfo_size + stats.rx_bufshift));
 493         hdr = (struct ieee80211_hdr *)(skb->data);
 494         fc = hdr->frame_control;
 495         if (!stats.crc) {
 496                 memcpy(IEEE80211_SKB_RXCB(skb), &rx_status, sizeof(rx_status));
 497
 498                 if (is_broadcast_ether_addr(hdr->addr1)) {
 499                         /*TODO*/;
 500                 } else if (is_multicast_ether_addr(hdr->addr1)) {
 501                         /*TODO*/
 502                 } else {
 503                         unicast = true;
 504                         rtlpriv->stats.rxbytesunicast +=  skb->len;
 505                 }
 506
 507                 rtl_is_special_data(hw, skb, false);
 508
 509                 if (ieee80211_is_data(fc)) {
 510                         rtlpriv->cfg->ops->led_control(hw, LED_CTL_RX);
 511
 512                         if (unicast)
 513                                 rtlpriv->link_info.num_rx_inperiod++;
 514                 }
 515                 if (likely(rtl_action_proc(hw, skb, false))) {
 516                         struct sk_buff *uskb = NULL;
 517                         u8 *pdata;
 518
 519                         uskb = dev_alloc_skb(skb->len + 128);
 520                         if (uskb) {     /* drop packet on allocation failure */
 521                                 memcpy(IEEE80211_SKB_RXCB(uskb), &rx_status,
 522                                        sizeof(rx_status));
 523                                 pdata = (u8 *)skb_put(uskb, skb->len);
 524                                 memcpy(pdata, skb->data, skb->len);
 525                                 ieee80211_rx_irqsafe(hw, uskb);
 526                         }
 527                         dev_kfree_skb_any(skb);
 528                 } else {
 529                         dev_kfree_skb_any(skb);
 530                 }
 531         }
 532 }
 533
 534 static void _rtl_rx_pre_process(struct ieee80211_hw *hw, struct sk_buff *skb)
 535 {
 536         struct sk_buff *_skb;
 537         struct sk_buff_head rx_queue;
 538         struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
 539
 540         skb_queue_head_init(&rx_queue);
 541         if (rtlusb->usb_rx_segregate_hdl)
 542                 rtlusb->usb_rx_segregate_hdl(hw, skb, &rx_queue);
 543         WARN_ON(skb_queue_empty(&rx_queue));
 544         while (!skb_queue_empty(&rx_queue)) {
 545                 _skb = skb_dequeue(&rx_queue);
 546                 _rtl_usb_rx_process_agg(hw, skb);
 547                 ieee80211_rx_irqsafe(hw, skb);
 548         }
 549 }
 550
 551 static void _rtl_rx_completed(struct urb *_urb)
 552 {
 553         struct sk_buff *skb = (struct sk_buff *)_urb->context;
 554         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 555         struct rtl_usb *rtlusb = (struct rtl_usb *)info->rate_driver_data[0];
 556         struct ieee80211_hw *hw = usb_get_intfdata(rtlusb->intf);
 557         struct rtl_priv *rtlpriv = rtl_priv(hw);
 558         int err = 0;
 559
 560         if (unlikely(IS_USB_STOP(rtlusb)))
 561                 goto free;
 562
 563         if (likely(0 == _urb->status)) {
 564                 /* If this code were moved to work queue, would CPU
 565                  * utilization be improved?  NOTE: We shall allocate another skb
 566                  * and reuse the original one.
 567                  */
 568                 skb_put(skb, _urb->actual_length);
 569
 570                 if (likely(!rtlusb->usb_rx_segregate_hdl)) {
 571                         struct sk_buff *_skb;
 572                         _rtl_usb_rx_process_noagg(hw, skb);
 573                         _skb = _rtl_prep_rx_urb(hw, rtlusb, _urb, GFP_ATOMIC);
 574                         if (IS_ERR(_skb)) {
 575                                 err = PTR_ERR(_skb);
 576                                 RT_TRACE(rtlpriv, COMP_USB, DBG_EMERG,
 577                                          "Can't allocate skb for bulk IN!\n");
 578                                 return;
 579                         }
 580                         skb = _skb;
 581                 } else{
 582                         /* TO DO */
 583                         _rtl_rx_pre_process(hw, skb);
 584                         pr_err("rx agg not supported\n");
 585                 }
 586                 goto resubmit;
 587         }
 588
 589         switch (_urb->status) {
 590         /* disconnect */
 591         case -ENOENT:
 592         case -ECONNRESET:
 593         case -ENODEV:
 594         case -ESHUTDOWN:
 595                 goto free;
 596         default:
 597                 break;
 598         }
 599
 600 resubmit:
 601         skb_reset_tail_pointer(skb);
 602         skb_trim(skb, 0);
 603
 604         usb_anchor_urb(_urb, &rtlusb->rx_submitted);
 605         err = usb_submit_urb(_urb, GFP_ATOMIC);
 606         if (unlikely(err)) {
 607                 usb_unanchor_urb(_urb);
 608                 goto free;
 609         }
 610         return;
 611
 612 free:
 613         dev_kfree_skb_irq(skb);
 614 }
 615
 616 static int _rtl_usb_receive(struct ieee80211_hw *hw)
 617 {
 618         struct urb *urb;
 619         struct sk_buff *skb;
 620         int err;
 621         int i;
 622         struct rtl_priv *rtlpriv = rtl_priv(hw);
 623         struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
 624
 625         WARN_ON(0 == rtlusb->rx_urb_num);
 626         /* 1600 == 1514 + max WLAN header + rtk info */
 627         WARN_ON(rtlusb->rx_max_size < 1600);
 628
 629         for (i = 0; i < rtlusb->rx_urb_num; i++) {
 630                 err = -ENOMEM;
 631                 urb = usb_alloc_urb(0, GFP_KERNEL);
 632                 if (!urb) {
 633                         RT_TRACE(rtlpriv, COMP_USB, DBG_EMERG,
 634                                  "Failed to alloc URB!!\n");
 635                         goto err_out;
 636                 }
 637
 638                 skb = _rtl_prep_rx_urb(hw, rtlusb, urb, GFP_KERNEL);
 639                 if (IS_ERR(skb)) {
 640                         RT_TRACE(rtlpriv, COMP_USB, DBG_EMERG,
 641                                  "Failed to prep_rx_urb!!\n");
 642                         err = PTR_ERR(skb);
 643                         goto err_out;
 644                 }
 645
 646                 usb_anchor_urb(urb, &rtlusb->rx_submitted);
 647                 err = usb_submit_urb(urb, GFP_KERNEL);
 648                 if (err)
 649                         goto err_out;
 650                 usb_free_urb(urb);
 651         }
 652         return 0;
 653
 654 err_out:
 655         usb_kill_anchored_urbs(&rtlusb->rx_submitted);
 656         return err;
 657 }
 658
 659 static int rtl_usb_start(struct ieee80211_hw *hw)
 660 {
 661         int err;
 662         struct rtl_priv *rtlpriv = rtl_priv(hw);
 663         struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
 664         struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
 665
 666         err = rtlpriv->cfg->ops->hw_init(hw);
 667         if (!err) {
 668                 rtl_init_rx_config(hw);
 669
 670                 /* Enable software */
 671                 SET_USB_START(rtlusb);
 672                 /* should after adapter start and interrupt enable. */
 673                 set_hal_start(rtlhal);
 674
 675                 /* Start bulk IN */
 676                 err = _rtl_usb_receive(hw);
 677         }
 678
 679         return err;
 680 }
 681 /**
 682  *
 683  *
 684  */
 685
 686 /*=======================  tx =========================================*/
 687 static void rtl_usb_cleanup(struct ieee80211_hw *hw)
 688 {
 689         u32 i;
 690         struct sk_buff *_skb;
 691         struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
 692         struct ieee80211_tx_info *txinfo;
 693
 694         SET_USB_STOP(rtlusb);
 695
 696         /* clean up rx stuff. */
 697         usb_kill_anchored_urbs(&rtlusb->rx_submitted);
 698
 699         /* clean up tx stuff */
 700         for (i = 0; i < RTL_USB_MAX_EP_NUM; i++) {
 701                 while ((_skb = skb_dequeue(&rtlusb->tx_skb_queue[i]))) {
 702                         rtlusb->usb_tx_cleanup(hw, _skb);
 703                         txinfo = IEEE80211_SKB_CB(_skb);
 704                         ieee80211_tx_info_clear_status(txinfo);
 705                         txinfo->flags |= IEEE80211_TX_STAT_ACK;
 706                         ieee80211_tx_status_irqsafe(hw, _skb);
 707                 }
 708                 usb_kill_anchored_urbs(&rtlusb->tx_pending[i]);
 709         }
 710         usb_kill_anchored_urbs(&rtlusb->tx_submitted);
 711 }
 712
 713 /**
 714  *
 715  * We may add some struct into struct rtl_usb later. Do deinit here.
 716  *
 717  */
 718 static void rtl_usb_deinit(struct ieee80211_hw *hw)
 719 {
 720         rtl_usb_cleanup(hw);
 721 }
 722
 723 static void rtl_usb_stop(struct ieee80211_hw *hw)
 724 {
 725         struct rtl_priv *rtlpriv = rtl_priv(hw);
 726         struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
 727         struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
 728
 729         /* should after adapter start and interrupt enable. */
 730         set_hal_stop(rtlhal);
 731         /* Enable software */
 732         SET_USB_STOP(rtlusb);
 733         rtl_usb_deinit(hw);
 734         rtlpriv->cfg->ops->hw_disable(hw);
 735 }
 736
 737 static void _rtl_submit_tx_urb(struct ieee80211_hw *hw, struct urb *_urb)
 738 {
 739         int err;
 740         struct rtl_priv *rtlpriv = rtl_priv(hw);
 741         struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
 742
 743         usb_anchor_urb(_urb, &rtlusb->tx_submitted);
 744         err = usb_submit_urb(_urb, GFP_ATOMIC);
 745         if (err < 0) {
 746                 struct sk_buff *skb;
 747
 748                 RT_TRACE(rtlpriv, COMP_USB, DBG_EMERG,
 749                          "Failed to submit urb\n");
 750                 usb_unanchor_urb(_urb);
 751                 skb = (struct sk_buff *)_urb->context;
 752                 kfree_skb(skb);
 753         }
 754         usb_free_urb(_urb);
 755 }
 756
 757 static int _usb_tx_post(struct ieee80211_hw *hw, struct urb *urb,
 758                         struct sk_buff *skb)
 759 {
 760         struct rtl_priv *rtlpriv = rtl_priv(hw);
 761         struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
 762         struct ieee80211_tx_info *txinfo;
 763
 764         rtlusb->usb_tx_post_hdl(hw, urb, skb);
 765         skb_pull(skb, RTL_TX_HEADER_SIZE);
 766         txinfo = IEEE80211_SKB_CB(skb);
 767         ieee80211_tx_info_clear_status(txinfo);
 768         txinfo->flags |= IEEE80211_TX_STAT_ACK;
 769
 770         if (urb->status) {
 771                 RT_TRACE(rtlpriv, COMP_USB, DBG_EMERG,
 772                          "Urb has error status 0x%X\n", urb->status);
 773                 goto out;
 774         }
 775         /*  TODO:       statistics */
 776 out:
 777         ieee80211_tx_status_irqsafe(hw, skb);
 778         return urb->status;
 779 }
 780
 781 static void _rtl_tx_complete(struct urb *urb)
 782 {
 783         struct sk_buff *skb = (struct sk_buff *)urb->context;
 784         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 785         struct rtl_usb *rtlusb = (struct rtl_usb *)info->rate_driver_data[0];
 786         struct ieee80211_hw *hw = usb_get_intfdata(rtlusb->intf);
 787         int err;
 788
 789         if (unlikely(IS_USB_STOP(rtlusb)))
 790                 return;
 791         err = _usb_tx_post(hw, urb, skb);
 792         if (err) {
 793                 /* Ignore error and keep issuiing other urbs */
 794                 return;
 795         }
 796 }
 797
 798 static struct urb *_rtl_usb_tx_urb_setup(struct ieee80211_hw *hw,
 799                                 struct sk_buff *skb, u32 ep_num)
 800 {
 801         struct rtl_priv *rtlpriv = rtl_priv(hw);
 802         struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
 803         struct urb *_urb;
 804
 805         WARN_ON(NULL == skb);
 806         _urb = usb_alloc_urb(0, GFP_ATOMIC);
 807         if (!_urb) {
 808                 RT_TRACE(rtlpriv, COMP_USB, DBG_EMERG,
 809                          "Can't allocate URB for bulk out!\n");
 810                 kfree_skb(skb);
 811                 return NULL;
 812         }
 813         _rtl_install_trx_info(rtlusb, skb, ep_num);
 814         usb_fill_bulk_urb(_urb, rtlusb->udev, usb_sndbulkpipe(rtlusb->udev,
 815                           ep_num), skb->data, skb->len, _rtl_tx_complete, skb);
 816         _urb->transfer_flags |= URB_ZERO_PACKET;
 817         return _urb;
 818 }
 819
 820 static void _rtl_usb_transmit(struct ieee80211_hw *hw, struct sk_buff *skb,
 821                        enum rtl_txq qnum)
 822 {
 823         struct rtl_priv *rtlpriv = rtl_priv(hw);
 824         struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
 825         u32 ep_num;
 826         struct urb *_urb = NULL;
 827         struct sk_buff *_skb = NULL;
 828         struct sk_buff_head *skb_list;
 829         struct usb_anchor *urb_list;
 830
 831         WARN_ON(NULL == rtlusb->usb_tx_aggregate_hdl);
 832         if (unlikely(IS_USB_STOP(rtlusb))) {
 833                 RT_TRACE(rtlpriv, COMP_USB, DBG_EMERG,
 834                          "USB device is stopping...\n");
 835                 kfree_skb(skb);
 836                 return;
 837         }
 838         ep_num = rtlusb->ep_map.ep_mapping[qnum];
 839         skb_list = &rtlusb->tx_skb_queue[ep_num];
 840         _skb = skb;
 841         _urb = _rtl_usb_tx_urb_setup(hw, _skb, ep_num);
 842         if (unlikely(!_urb)) {
 843                 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
 844                          "Can't allocate urb. Drop skb!\n");
 845                 return;
 846         }
 847         urb_list = &rtlusb->tx_pending[ep_num];
 848         _rtl_submit_tx_urb(hw, _urb);
 849 }
 850
 851 static void _rtl_usb_tx_preprocess(struct ieee80211_hw *hw,
 852                                    struct ieee80211_sta *sta,
 853                                    struct sk_buff *skb,
 854                                    u16 hw_queue)
 855 {
 856         struct rtl_priv *rtlpriv = rtl_priv(hw);
 857         struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
 858         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 859         struct rtl_tx_desc *pdesc = NULL;
 860         struct rtl_tcb_desc tcb_desc;
 861         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)(skb->data);
 862         __le16 fc = hdr->frame_control;
 863         u8 *pda_addr = hdr->addr1;
 864         /* ssn */
 865         u8 *qc = NULL;
 866         u8 tid = 0;
 867         u16 seq_number = 0;
 868
 869         memset(&tcb_desc, 0, sizeof(struct rtl_tcb_desc));
 870         if (ieee80211_is_auth(fc)) {
 871                 RT_TRACE(rtlpriv, COMP_SEND, DBG_DMESG, "MAC80211_LINKING\n");
 872                 rtl_ips_nic_on(hw);
 873         }
 874
 875         if (rtlpriv->psc.sw_ps_enabled) {
 876                 if (ieee80211_is_data(fc) && !ieee80211_is_nullfunc(fc) &&
 877                     !ieee80211_has_pm(fc))
 878                         hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
 879         }
 880
 881         rtl_action_proc(hw, skb, true);
 882         if (is_multicast_ether_addr(pda_addr))
 883                 rtlpriv->stats.txbytesmulticast += skb->len;
 884         else if (is_broadcast_ether_addr(pda_addr))
 885                 rtlpriv->stats.txbytesbroadcast += skb->len;
 886         else
 887                 rtlpriv->stats.txbytesunicast += skb->len;
 888         if (ieee80211_is_data_qos(fc)) {
 889                 qc = ieee80211_get_qos_ctl(hdr);
 890                 tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
 891                 seq_number = (le16_to_cpu(hdr->seq_ctrl) &
 892                              IEEE80211_SCTL_SEQ) >> 4;
 893                 seq_number += 1;
 894                 seq_number <<= 4;
 895         }
 896         rtlpriv->cfg->ops->fill_tx_desc(hw, hdr, (u8 *)pdesc, info, sta, skb,
 897                                         hw_queue, &tcb_desc);
 898         if (!ieee80211_has_morefrags(hdr->frame_control)) {
 899                 if (qc)
 900                         mac->tids[tid].seq_number = seq_number;
 901         }
 902         if (ieee80211_is_data(fc))
 903                 rtlpriv->cfg->ops->led_control(hw, LED_CTL_TX);
 904 }
 905
 906 static int rtl_usb_tx(struct ieee80211_hw *hw,
 907                       struct ieee80211_sta *sta,
 908                       struct sk_buff *skb,
 909                       struct rtl_tcb_desc *dummy)
 910 {
 911         struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
 912         struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
 913         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)(skb->data);
 914         __le16 fc = hdr->frame_control;
 915         u16 hw_queue;
 916
 917         if (unlikely(is_hal_stop(rtlhal)))
 918                 goto err_free;
 919         hw_queue = rtlusb->usb_mq_to_hwq(fc, skb_get_queue_mapping(skb));
 920         _rtl_usb_tx_preprocess(hw, sta, skb, hw_queue);
 921         _rtl_usb_transmit(hw, skb, hw_queue);
 922         return NETDEV_TX_OK;
 923
 924 err_free:
 925         dev_kfree_skb_any(skb);
 926         return NETDEV_TX_OK;
 927 }
 928
 929 static bool rtl_usb_tx_chk_waitq_insert(struct ieee80211_hw *hw,
 930                                         struct ieee80211_sta *sta,
 931                                         struct sk_buff *skb)
 932 {
 933         return false;
 934 }
 935
 936 static struct rtl_intf_ops rtl_usb_ops = {
 937         .adapter_start = rtl_usb_start,
 938         .adapter_stop = rtl_usb_stop,
 939         .adapter_tx = rtl_usb_tx,
 940         .waitq_insert = rtl_usb_tx_chk_waitq_insert,
 941 };
 942
 943 int __devinit rtl_usb_probe(struct usb_interface *intf,
 944                         const struct usb_device_id *id)
 945 {
 946         int err;
 947         struct ieee80211_hw *hw = NULL;
 948         struct rtl_priv *rtlpriv = NULL;
 949         struct usb_device       *udev;
 950         struct rtl_usb_priv *usb_priv;
 951
 952         hw = ieee80211_alloc_hw(sizeof(struct rtl_priv) +
 953                                 sizeof(struct rtl_usb_priv), &rtl_ops);
 954         if (!hw) {
 955                 RT_ASSERT(false, "ieee80211 alloc failed\n");
 956                 return -ENOMEM;
 957         }
 958         rtlpriv = hw->priv;
 959         rtlpriv->usb_data = kzalloc(RTL_USB_MAX_RX_COUNT * sizeof(u32),
 960                                     GFP_KERNEL);
 961         if (!rtlpriv->usb_data)
 962                 return -ENOMEM;
 963
 964         /* this spin lock must be initialized early */
 965         spin_lock_init(&rtlpriv->locks.usb_lock);
 966
 967         rtlpriv->usb_data_index = 0;
 968         init_completion(&rtlpriv->firmware_loading_complete);
 969         SET_IEEE80211_DEV(hw, &intf->dev);
 970         udev = interface_to_usbdev(intf);
 971         usb_get_dev(udev);
 972         usb_priv = rtl_usbpriv(hw);
 973         memset(usb_priv, 0, sizeof(*usb_priv));
 974         usb_priv->dev.intf = intf;
 975         usb_priv->dev.udev = udev;
 976         usb_set_intfdata(intf, hw);
 977         /* init cfg & intf_ops */
 978         rtlpriv->rtlhal.interface = INTF_USB;
 979         rtlpriv->cfg = (struct rtl_hal_cfg *)(id->driver_info);
 980         rtlpriv->intf_ops = &rtl_usb_ops;
 981         rtl_dbgp_flag_init(hw);
 982         /* Init IO handler */
 983         _rtl_usb_io_handler_init(&udev->dev, hw);
 984         rtlpriv->cfg->ops->read_chip_version(hw);
 985         /*like read eeprom and so on */
 986         rtlpriv->cfg->ops->read_eeprom_info(hw);
 987         err = _rtl_usb_init(hw);
 988         if (err)
 989                 goto error_out;
 990         rtl_usb_init_sw(hw);
 991         /* Init mac80211 sw */
 992         err = rtl_init_core(hw);
 993         if (err) {
 994                 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
 995                          "Can't allocate sw for mac80211\n");
 996                 goto error_out;
 997         }
 998         if (rtlpriv->cfg->ops->init_sw_vars(hw)) {
 999                 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG, "Can't init_sw_vars\n");
1000                 goto error_out;
1001         }
1002         rtlpriv->cfg->ops->init_sw_leds(hw);
1003
1004         return 0;
1005 error_out:
1006         rtl_deinit_core(hw);
1007         _rtl_usb_io_handler_release(hw);
1008         usb_put_dev(udev);
1009         complete(&rtlpriv->firmware_loading_complete);
1010         return -ENODEV;
1011 }
1012 EXPORT_SYMBOL(rtl_usb_probe);
1013
1014 void rtl_usb_disconnect(struct usb_interface *intf)
1015 {
1016         struct ieee80211_hw *hw = usb_get_intfdata(intf);
1017         struct rtl_priv *rtlpriv = rtl_priv(hw);
1018         struct rtl_mac *rtlmac = rtl_mac(rtl_priv(hw));
1019         struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
1020
1021         if (unlikely(!rtlpriv))
1022                 return;
1023
1024         /* just in case driver is removed before firmware callback */
1025         wait_for_completion(&rtlpriv->firmware_loading_complete);
1026         /*ieee80211_unregister_hw will call ops_stop */
1027         if (rtlmac->mac80211_registered == 1) {
1028                 ieee80211_unregister_hw(hw);
1029                 rtlmac->mac80211_registered = 0;
1030         } else {
1031                 rtl_deinit_deferred_work(hw);
1032                 rtlpriv->intf_ops->adapter_stop(hw);
1033         }
1034         /*deinit rfkill */
1035         /* rtl_deinit_rfkill(hw); */
1036         rtl_usb_deinit(hw);
1037         rtl_deinit_core(hw);
1038         kfree(rtlpriv->usb_data);
1039         rtlpriv->cfg->ops->deinit_sw_leds(hw);
1040         rtlpriv->cfg->ops->deinit_sw_vars(hw);
1041         _rtl_usb_io_handler_release(hw);
1042         usb_put_dev(rtlusb->udev);
1043         usb_set_intfdata(intf, NULL);
1044         ieee80211_free_hw(hw);
1045 }
1046 EXPORT_SYMBOL(rtl_usb_disconnect);
1047
1048 int rtl_usb_suspend(struct usb_interface *pusb_intf, pm_message_t message)
1049 {
1050         return 0;
1051 }
1052 EXPORT_SYMBOL(rtl_usb_suspend);
1053
1054 int rtl_usb_resume(struct usb_interface *pusb_intf)
1055 {
1056         return 0;
1057 }
1058 EXPORT_SYMBOL(rtl_usb_resume);