Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
usb.c
Go to the documentation of this file.
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 <[email protected]>
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 {
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;
211  int pipe = usb_sndctrlpipe(udev, 0); /* write_out */
212  u8 *buffer;
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 
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)
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;
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 
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 
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:
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 }
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. */
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  }
711 }
712 
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);
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:
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))
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 
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);
1010  return -ENODEV;
1011 }
1013 
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 */
1026  /*ieee80211_unregister_hw will call ops_stop */
1027  if (rtlmac->mac80211_registered == 1) {
1029  rtlmac->mac80211_registered = 0;
1030  } else {
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 }
1047 
1049 {
1050  return 0;
1051 }
1053 
1054 int rtl_usb_resume(struct usb_interface *pusb_intf)
1055 {
1056  return 0;
1057 }