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