Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
rt2x00dev.c
Go to the documentation of this file.
1 /*
2  Copyright (C) 2010 Willow Garage <http://www.willowgarage.com>
3  Copyright (C) 2004 - 2010 Ivo van Doorn <[email protected]>
4  <http://rt2x00.serialmonkey.com>
5 
6  This program is free software; you can redistribute it and/or modify
7  it under the terms of the GNU General Public License as published by
8  the Free Software Foundation; either version 2 of the License, or
9  (at your option) any later version.
10 
11  This program is distributed in the hope that it will be useful,
12  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  GNU General Public License for more details.
15 
16  You should have received a copy of the GNU General Public License
17  along with this program; if not, write to the
18  Free Software Foundation, Inc.,
19  59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20  */
21 
22 /*
23  Module: rt2x00lib
24  Abstract: rt2x00 generic device routines.
25  */
26 
27 #include <linux/kernel.h>
28 #include <linux/module.h>
29 #include <linux/slab.h>
30 #include <linux/log2.h>
31 
32 #include "rt2x00.h"
33 #include "rt2x00lib.h"
34 
35 /*
36  * Utility functions.
37  */
39  struct ieee80211_vif *vif)
40 {
41  /*
42  * When in STA mode, bssidx is always 0 otherwise local_address[5]
43  * contains the bss number, see BSS_ID_MASK comments for details.
44  */
45  if (rt2x00dev->intf_sta_count)
46  return 0;
47  return vif->addr[5] & (rt2x00dev->ops->max_ap_intf - 1);
48 }
50 
51 /*
52  * Radio control handlers.
53  */
54 int rt2x00lib_enable_radio(struct rt2x00_dev *rt2x00dev)
55 {
56  int status;
57 
58  /*
59  * Don't enable the radio twice.
60  * And check if the hardware button has been disabled.
61  */
62  if (test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
63  return 0;
64 
65  /*
66  * Initialize all data queues.
67  */
68  rt2x00queue_init_queues(rt2x00dev);
69 
70  /*
71  * Enable radio.
72  */
73  status =
74  rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_ON);
75  if (status)
76  return status;
77 
78  rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_IRQ_ON);
79 
80  rt2x00leds_led_radio(rt2x00dev, true);
81  rt2x00led_led_activity(rt2x00dev, true);
82 
84 
85  /*
86  * Enable queues.
87  */
88  rt2x00queue_start_queues(rt2x00dev);
89  rt2x00link_start_tuner(rt2x00dev);
90  rt2x00link_start_agc(rt2x00dev);
92  rt2x00link_start_vcocal(rt2x00dev);
93 
94  /*
95  * Start watchdog monitoring.
96  */
97  rt2x00link_start_watchdog(rt2x00dev);
98 
99  return 0;
100 }
101 
102 void rt2x00lib_disable_radio(struct rt2x00_dev *rt2x00dev)
103 {
105  return;
106 
107  /*
108  * Stop watchdog monitoring.
109  */
110  rt2x00link_stop_watchdog(rt2x00dev);
111 
112  /*
113  * Stop all queues
114  */
115  rt2x00link_stop_agc(rt2x00dev);
117  rt2x00link_stop_vcocal(rt2x00dev);
118  rt2x00link_stop_tuner(rt2x00dev);
119  rt2x00queue_stop_queues(rt2x00dev);
120  rt2x00queue_flush_queues(rt2x00dev, true);
121 
122  /*
123  * Disable radio.
124  */
125  rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_OFF);
126  rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_IRQ_OFF);
127  rt2x00led_led_activity(rt2x00dev, false);
128  rt2x00leds_led_radio(rt2x00dev, false);
129 }
130 
131 static void rt2x00lib_intf_scheduled_iter(void *data, u8 *mac,
132  struct ieee80211_vif *vif)
133 {
134  struct rt2x00_dev *rt2x00dev = data;
135  struct rt2x00_intf *intf = vif_to_intf(vif);
136 
137  /*
138  * It is possible the radio was disabled while the work had been
139  * scheduled. If that happens we should return here immediately,
140  * note that in the spinlock protected area above the delayed_flags
141  * have been cleared correctly.
142  */
143  if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
144  return;
145 
147  rt2x00queue_update_beacon(rt2x00dev, vif);
148 }
149 
150 static void rt2x00lib_intf_scheduled(struct work_struct *work)
151 {
152  struct rt2x00_dev *rt2x00dev =
153  container_of(work, struct rt2x00_dev, intf_work);
154 
155  /*
156  * Iterate over each interface and perform the
157  * requested configurations.
158  */
160  rt2x00lib_intf_scheduled_iter,
161  rt2x00dev);
162 }
163 
164 static void rt2x00lib_autowakeup(struct work_struct *work)
165 {
166  struct rt2x00_dev *rt2x00dev =
167  container_of(work, struct rt2x00_dev, autowakeup_work.work);
168 
169  if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
170  return;
171 
172  if (rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_AWAKE))
173  ERROR(rt2x00dev, "Device failed to wakeup.\n");
174  clear_bit(CONFIG_POWERSAVING, &rt2x00dev->flags);
175 }
176 
177 /*
178  * Interrupt context handlers.
179  */
180 static void rt2x00lib_bc_buffer_iter(void *data, u8 *mac,
181  struct ieee80211_vif *vif)
182 {
183  struct rt2x00_dev *rt2x00dev = data;
184  struct sk_buff *skb;
185 
186  /*
187  * Only AP mode interfaces do broad- and multicast buffering
188  */
189  if (vif->type != NL80211_IFTYPE_AP)
190  return;
191 
192  /*
193  * Send out buffered broad- and multicast frames
194  */
195  skb = ieee80211_get_buffered_bc(rt2x00dev->hw, vif);
196  while (skb) {
197  rt2x00mac_tx(rt2x00dev->hw, NULL, skb);
198  skb = ieee80211_get_buffered_bc(rt2x00dev->hw, vif);
199  }
200 }
201 
202 static void rt2x00lib_beaconupdate_iter(void *data, u8 *mac,
203  struct ieee80211_vif *vif)
204 {
205  struct rt2x00_dev *rt2x00dev = data;
206 
207  if (vif->type != NL80211_IFTYPE_AP &&
208  vif->type != NL80211_IFTYPE_ADHOC &&
210  vif->type != NL80211_IFTYPE_WDS)
211  return;
212 
213  /*
214  * Update the beacon without locking. This is safe on PCI devices
215  * as they only update the beacon periodically here. This should
216  * never be called for USB devices.
217  */
218  WARN_ON(rt2x00_is_usb(rt2x00dev));
219  rt2x00queue_update_beacon_locked(rt2x00dev, vif);
220 }
221 
222 void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev)
223 {
224  if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
225  return;
226 
227  /* send buffered bc/mc frames out for every bssid */
229  rt2x00lib_bc_buffer_iter,
230  rt2x00dev);
231  /*
232  * Devices with pre tbtt interrupt don't need to update the beacon
233  * here as they will fetch the next beacon directly prior to
234  * transmission.
235  */
237  return;
238 
239  /* fetch next beacon */
241  rt2x00lib_beaconupdate_iter,
242  rt2x00dev);
243 }
245 
246 void rt2x00lib_pretbtt(struct rt2x00_dev *rt2x00dev)
247 {
248  if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
249  return;
250 
251  /* fetch next beacon */
253  rt2x00lib_beaconupdate_iter,
254  rt2x00dev);
255 }
257 
258 void rt2x00lib_dmastart(struct queue_entry *entry)
259 {
260  set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
262 }
264 
265 void rt2x00lib_dmadone(struct queue_entry *entry)
266 {
267  set_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags);
268  clear_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
270 }
272 
273 void rt2x00lib_txdone(struct queue_entry *entry,
274  struct txdone_entry_desc *txdesc)
275 {
276  struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
277  struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(entry->skb);
278  struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb);
279  unsigned int header_length, i;
280  u8 rate_idx, rate_flags, retry_rates;
281  u8 skbdesc_flags = skbdesc->flags;
282  bool success;
283 
284  /*
285  * Unmap the skb.
286  */
287  rt2x00queue_unmap_skb(entry);
288 
289  /*
290  * Remove the extra tx headroom from the skb.
291  */
292  skb_pull(entry->skb, rt2x00dev->ops->extra_tx_headroom);
293 
294  /*
295  * Signal that the TX descriptor is no longer in the skb.
296  */
297  skbdesc->flags &= ~SKBDESC_DESC_IN_SKB;
298 
299  /*
300  * Determine the length of 802.11 header.
301  */
302  header_length = ieee80211_get_hdrlen_from_skb(entry->skb);
303 
304  /*
305  * Remove L2 padding which was added during
306  */
307  if (test_bit(REQUIRE_L2PAD, &rt2x00dev->cap_flags))
308  rt2x00queue_remove_l2pad(entry->skb, header_length);
309 
310  /*
311  * If the IV/EIV data was stripped from the frame before it was
312  * passed to the hardware, we should now reinsert it again because
313  * mac80211 will expect the same data to be present it the
314  * frame as it was passed to us.
315  */
316  if (test_bit(CAPABILITY_HW_CRYPTO, &rt2x00dev->cap_flags))
317  rt2x00crypto_tx_insert_iv(entry->skb, header_length);
318 
319  /*
320  * Send frame to debugfs immediately, after this call is completed
321  * we are going to overwrite the skb->cb array.
322  */
323  rt2x00debug_dump_frame(rt2x00dev, DUMP_FRAME_TXDONE, entry->skb);
324 
325  /*
326  * Determine if the frame has been successfully transmitted.
327  */
328  success =
329  test_bit(TXDONE_SUCCESS, &txdesc->flags) ||
330  test_bit(TXDONE_UNKNOWN, &txdesc->flags);
331 
332  /*
333  * Update TX statistics.
334  */
335  rt2x00dev->link.qual.tx_success += success;
336  rt2x00dev->link.qual.tx_failed += !success;
337 
338  rate_idx = skbdesc->tx_rate_idx;
339  rate_flags = skbdesc->tx_rate_flags;
340  retry_rates = test_bit(TXDONE_FALLBACK, &txdesc->flags) ?
341  (txdesc->retry + 1) : 1;
342 
343  /*
344  * Initialize TX status
345  */
346  memset(&tx_info->status, 0, sizeof(tx_info->status));
347  tx_info->status.ack_signal = 0;
348 
349  /*
350  * Frame was send with retries, hardware tried
351  * different rates to send out the frame, at each
352  * retry it lowered the rate 1 step except when the
353  * lowest rate was used.
354  */
355  for (i = 0; i < retry_rates && i < IEEE80211_TX_MAX_RATES; i++) {
356  tx_info->status.rates[i].idx = rate_idx - i;
357  tx_info->status.rates[i].flags = rate_flags;
358 
359  if (rate_idx - i == 0) {
360  /*
361  * The lowest rate (index 0) was used until the
362  * number of max retries was reached.
363  */
364  tx_info->status.rates[i].count = retry_rates - i;
365  i++;
366  break;
367  }
368  tx_info->status.rates[i].count = 1;
369  }
370  if (i < (IEEE80211_TX_MAX_RATES - 1))
371  tx_info->status.rates[i].idx = -1; /* terminate */
372 
373  if (!(tx_info->flags & IEEE80211_TX_CTL_NO_ACK)) {
374  if (success)
375  tx_info->flags |= IEEE80211_TX_STAT_ACK;
376  else
377  rt2x00dev->low_level_stats.dot11ACKFailureCount++;
378  }
379 
380  /*
381  * Every single frame has it's own tx status, hence report
382  * every frame as ampdu of size 1.
383  *
384  * TODO: if we can find out how many frames were aggregated
385  * by the hw we could provide the real ampdu_len to mac80211
386  * which would allow the rc algorithm to better decide on
387  * which rates are suitable.
388  */
389  if (test_bit(TXDONE_AMPDU, &txdesc->flags) ||
390  tx_info->flags & IEEE80211_TX_CTL_AMPDU) {
391  tx_info->flags |= IEEE80211_TX_STAT_AMPDU;
392  tx_info->status.ampdu_len = 1;
393  tx_info->status.ampdu_ack_len = success ? 1 : 0;
394  /*
395  * TODO: Need to tear down BA session here
396  * if not successful.
397  */
398  }
399 
400  if (rate_flags & IEEE80211_TX_RC_USE_RTS_CTS) {
401  if (success)
402  rt2x00dev->low_level_stats.dot11RTSSuccessCount++;
403  else
404  rt2x00dev->low_level_stats.dot11RTSFailureCount++;
405  }
406 
407  /*
408  * Only send the status report to mac80211 when it's a frame
409  * that originated in mac80211. If this was a extra frame coming
410  * through a mac80211 library call (RTS/CTS) then we should not
411  * send the status report back.
412  */
413  if (!(skbdesc_flags & SKBDESC_NOT_MAC80211)) {
414  if (test_bit(REQUIRE_TASKLET_CONTEXT, &rt2x00dev->cap_flags))
415  ieee80211_tx_status(rt2x00dev->hw, entry->skb);
416  else
417  ieee80211_tx_status_ni(rt2x00dev->hw, entry->skb);
418  } else
419  dev_kfree_skb_any(entry->skb);
420 
421  /*
422  * Make this entry available for reuse.
423  */
424  entry->skb = NULL;
425  entry->flags = 0;
426 
427  rt2x00dev->ops->lib->clear_entry(entry);
428 
430 
431  /*
432  * If the data queue was below the threshold before the txdone
433  * handler we must make sure the packet queue in the mac80211 stack
434  * is reenabled when the txdone handler has finished. This has to be
435  * serialized with rt2x00mac_tx(), otherwise we can wake up queue
436  * before it was stopped.
437  */
438  spin_lock_bh(&entry->queue->tx_lock);
439  if (!rt2x00queue_threshold(entry->queue))
440  rt2x00queue_unpause_queue(entry->queue);
441  spin_unlock_bh(&entry->queue->tx_lock);
442 }
444 
445 void rt2x00lib_txdone_noinfo(struct queue_entry *entry, u32 status)
446 {
447  struct txdone_entry_desc txdesc;
448 
449  txdesc.flags = 0;
450  __set_bit(status, &txdesc.flags);
451  txdesc.retry = 0;
452 
453  rt2x00lib_txdone(entry, &txdesc);
454 }
456 
457 static u8 *rt2x00lib_find_ie(u8 *data, unsigned int len, u8 ie)
458 {
459  struct ieee80211_mgmt *mgmt = (void *)data;
460  u8 *pos, *end;
461 
462  pos = (u8 *)mgmt->u.beacon.variable;
463  end = data + len;
464  while (pos < end) {
465  if (pos + 2 + pos[1] > end)
466  return NULL;
467 
468  if (pos[0] == ie)
469  return pos;
470 
471  pos += 2 + pos[1];
472  }
473 
474  return NULL;
475 }
476 
477 static void rt2x00lib_sleep(struct work_struct *work)
478 {
479  struct rt2x00_dev *rt2x00dev =
480  container_of(work, struct rt2x00_dev, sleep_work);
481 
482  if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
483  return;
484 
485  /*
486  * Check again is powersaving is enabled, to prevent races from delayed
487  * work execution.
488  */
489  if (!test_bit(CONFIG_POWERSAVING, &rt2x00dev->flags))
490  rt2x00lib_config(rt2x00dev, &rt2x00dev->hw->conf,
492 }
493 
494 static void rt2x00lib_rxdone_check_ps(struct rt2x00_dev *rt2x00dev,
495  struct sk_buff *skb,
496  struct rxdone_entry_desc *rxdesc)
497 {
498  struct ieee80211_hdr *hdr = (void *) skb->data;
499  struct ieee80211_tim_ie *tim_ie;
500  u8 *tim;
501  u8 tim_len;
502  bool cam;
503 
504  /* If this is not a beacon, or if mac80211 has no powersaving
505  * configured, or if the device is already in powersaving mode
506  * we can exit now. */
507  if (likely(!ieee80211_is_beacon(hdr->frame_control) ||
508  !(rt2x00dev->hw->conf.flags & IEEE80211_CONF_PS)))
509  return;
510 
511  /* min. beacon length + FCS_LEN */
512  if (skb->len <= 40 + FCS_LEN)
513  return;
514 
515  /* and only beacons from the associated BSSID, please */
516  if (!(rxdesc->dev_flags & RXDONE_MY_BSS) ||
517  !rt2x00dev->aid)
518  return;
519 
520  rt2x00dev->last_beacon = jiffies;
521 
522  tim = rt2x00lib_find_ie(skb->data, skb->len - FCS_LEN, WLAN_EID_TIM);
523  if (!tim)
524  return;
525 
526  if (tim[1] < sizeof(*tim_ie))
527  return;
528 
529  tim_len = tim[1];
530  tim_ie = (struct ieee80211_tim_ie *) &tim[2];
531 
532  /* Check whenever the PHY can be turned off again. */
533 
534  /* 1. What about buffered unicast traffic for our AID? */
535  cam = ieee80211_check_tim(tim_ie, tim_len, rt2x00dev->aid);
536 
537  /* 2. Maybe the AP wants to send multicast/broadcast data? */
538  cam |= (tim_ie->bitmap_ctrl & 0x01);
539 
540  if (!cam && !test_bit(CONFIG_POWERSAVING, &rt2x00dev->flags))
541  queue_work(rt2x00dev->workqueue, &rt2x00dev->sleep_work);
542 }
543 
544 static int rt2x00lib_rxdone_read_signal(struct rt2x00_dev *rt2x00dev,
545  struct rxdone_entry_desc *rxdesc)
546 {
547  struct ieee80211_supported_band *sband;
548  const struct rt2x00_rate *rate;
549  unsigned int i;
550  int signal = rxdesc->signal;
551  int type = (rxdesc->dev_flags & RXDONE_SIGNAL_MASK);
552 
553  switch (rxdesc->rate_mode) {
554  case RATE_MODE_CCK:
555  case RATE_MODE_OFDM:
556  /*
557  * For non-HT rates the MCS value needs to contain the
558  * actually used rate modulation (CCK or OFDM).
559  */
560  if (rxdesc->dev_flags & RXDONE_SIGNAL_MCS)
561  signal = RATE_MCS(rxdesc->rate_mode, signal);
562 
563  sband = &rt2x00dev->bands[rt2x00dev->curr_band];
564  for (i = 0; i < sband->n_bitrates; i++) {
565  rate = rt2x00_get_rate(sband->bitrates[i].hw_value);
566  if (((type == RXDONE_SIGNAL_PLCP) &&
567  (rate->plcp == signal)) ||
568  ((type == RXDONE_SIGNAL_BITRATE) &&
569  (rate->bitrate == signal)) ||
570  ((type == RXDONE_SIGNAL_MCS) &&
571  (rate->mcs == signal))) {
572  return i;
573  }
574  }
575  break;
576  case RATE_MODE_HT_MIX:
578  if (signal >= 0 && signal <= 76)
579  return signal;
580  break;
581  default:
582  break;
583  }
584 
585  WARNING(rt2x00dev, "Frame received with unrecognized signal, "
586  "mode=0x%.4x, signal=0x%.4x, type=%d.\n",
587  rxdesc->rate_mode, signal, type);
588  return 0;
589 }
590 
591 void rt2x00lib_rxdone(struct queue_entry *entry, gfp_t gfp)
592 {
593  struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
594  struct rxdone_entry_desc rxdesc;
595  struct sk_buff *skb;
597  unsigned int header_length;
598  int rate_idx;
599 
600  if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) ||
602  goto submit_entry;
603 
604  if (test_bit(ENTRY_DATA_IO_FAILED, &entry->flags))
605  goto submit_entry;
606 
607  /*
608  * Allocate a new sk_buffer. If no new buffer available, drop the
609  * received frame and reuse the existing buffer.
610  */
611  skb = rt2x00queue_alloc_rxskb(entry, gfp);
612  if (!skb)
613  goto submit_entry;
614 
615  /*
616  * Unmap the skb.
617  */
618  rt2x00queue_unmap_skb(entry);
619 
620  /*
621  * Extract the RXD details.
622  */
623  memset(&rxdesc, 0, sizeof(rxdesc));
624  rt2x00dev->ops->lib->fill_rxdone(entry, &rxdesc);
625 
626  /*
627  * Check for valid size in case we get corrupted descriptor from
628  * hardware.
629  */
630  if (unlikely(rxdesc.size == 0 ||
631  rxdesc.size > entry->queue->data_size)) {
632  ERROR(rt2x00dev, "Wrong frame size %d max %d.\n",
633  rxdesc.size, entry->queue->data_size);
634  dev_kfree_skb(entry->skb);
635  goto renew_skb;
636  }
637 
638  /*
639  * The data behind the ieee80211 header must be
640  * aligned on a 4 byte boundary.
641  */
642  header_length = ieee80211_get_hdrlen_from_skb(entry->skb);
643 
644  /*
645  * Hardware might have stripped the IV/EIV/ICV data,
646  * in that case it is possible that the data was
647  * provided separately (through hardware descriptor)
648  * in which case we should reinsert the data into the frame.
649  */
650  if ((rxdesc.dev_flags & RXDONE_CRYPTO_IV) &&
651  (rxdesc.flags & RX_FLAG_IV_STRIPPED))
652  rt2x00crypto_rx_insert_iv(entry->skb, header_length,
653  &rxdesc);
654  else if (header_length &&
655  (rxdesc.size > header_length) &&
656  (rxdesc.dev_flags & RXDONE_L2PAD))
657  rt2x00queue_remove_l2pad(entry->skb, header_length);
658 
659  /* Trim buffer to correct size */
660  skb_trim(entry->skb, rxdesc.size);
661 
662  /*
663  * Translate the signal to the correct bitrate index.
664  */
665  rate_idx = rt2x00lib_rxdone_read_signal(rt2x00dev, &rxdesc);
666  if (rxdesc.rate_mode == RATE_MODE_HT_MIX ||
668  rxdesc.flags |= RX_FLAG_HT;
669 
670  /*
671  * Check if this is a beacon, and more frames have been
672  * buffered while we were in powersaving mode.
673  */
674  rt2x00lib_rxdone_check_ps(rt2x00dev, entry->skb, &rxdesc);
675 
676  /*
677  * Update extra components
678  */
679  rt2x00link_update_stats(rt2x00dev, entry->skb, &rxdesc);
680  rt2x00debug_update_crypto(rt2x00dev, &rxdesc);
681  rt2x00debug_dump_frame(rt2x00dev, DUMP_FRAME_RXDONE, entry->skb);
682 
683  /*
684  * Initialize RX status information, and send frame
685  * to mac80211.
686  */
687  rx_status = IEEE80211_SKB_RXCB(entry->skb);
688  rx_status->mactime = rxdesc.timestamp;
689  rx_status->band = rt2x00dev->curr_band;
690  rx_status->freq = rt2x00dev->curr_freq;
691  rx_status->rate_idx = rate_idx;
692  rx_status->signal = rxdesc.rssi;
693  rx_status->flag = rxdesc.flags;
694  rx_status->antenna = rt2x00dev->link.ant.active.rx;
695 
696  ieee80211_rx_ni(rt2x00dev->hw, entry->skb);
697 
698 renew_skb:
699  /*
700  * Replace the skb with the freshly allocated one.
701  */
702  entry->skb = skb;
703 
704 submit_entry:
705  entry->flags = 0;
707  if (test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) &&
709  rt2x00dev->ops->lib->clear_entry(entry);
710 }
712 
713 /*
714  * Driver initialization handlers.
715  */
717  {
718  .flags = DEV_RATE_CCK,
719  .bitrate = 10,
720  .ratemask = BIT(0),
721  .plcp = 0x00,
722  .mcs = RATE_MCS(RATE_MODE_CCK, 0),
723  },
724  {
726  .bitrate = 20,
727  .ratemask = BIT(1),
728  .plcp = 0x01,
729  .mcs = RATE_MCS(RATE_MODE_CCK, 1),
730  },
731  {
733  .bitrate = 55,
734  .ratemask = BIT(2),
735  .plcp = 0x02,
736  .mcs = RATE_MCS(RATE_MODE_CCK, 2),
737  },
738  {
740  .bitrate = 110,
741  .ratemask = BIT(3),
742  .plcp = 0x03,
743  .mcs = RATE_MCS(RATE_MODE_CCK, 3),
744  },
745  {
746  .flags = DEV_RATE_OFDM,
747  .bitrate = 60,
748  .ratemask = BIT(4),
749  .plcp = 0x0b,
750  .mcs = RATE_MCS(RATE_MODE_OFDM, 0),
751  },
752  {
753  .flags = DEV_RATE_OFDM,
754  .bitrate = 90,
755  .ratemask = BIT(5),
756  .plcp = 0x0f,
757  .mcs = RATE_MCS(RATE_MODE_OFDM, 1),
758  },
759  {
760  .flags = DEV_RATE_OFDM,
761  .bitrate = 120,
762  .ratemask = BIT(6),
763  .plcp = 0x0a,
764  .mcs = RATE_MCS(RATE_MODE_OFDM, 2),
765  },
766  {
767  .flags = DEV_RATE_OFDM,
768  .bitrate = 180,
769  .ratemask = BIT(7),
770  .plcp = 0x0e,
771  .mcs = RATE_MCS(RATE_MODE_OFDM, 3),
772  },
773  {
774  .flags = DEV_RATE_OFDM,
775  .bitrate = 240,
776  .ratemask = BIT(8),
777  .plcp = 0x09,
778  .mcs = RATE_MCS(RATE_MODE_OFDM, 4),
779  },
780  {
781  .flags = DEV_RATE_OFDM,
782  .bitrate = 360,
783  .ratemask = BIT(9),
784  .plcp = 0x0d,
785  .mcs = RATE_MCS(RATE_MODE_OFDM, 5),
786  },
787  {
788  .flags = DEV_RATE_OFDM,
789  .bitrate = 480,
790  .ratemask = BIT(10),
791  .plcp = 0x08,
792  .mcs = RATE_MCS(RATE_MODE_OFDM, 6),
793  },
794  {
795  .flags = DEV_RATE_OFDM,
796  .bitrate = 540,
797  .ratemask = BIT(11),
798  .plcp = 0x0c,
799  .mcs = RATE_MCS(RATE_MODE_OFDM, 7),
800  },
801 };
802 
803 static void rt2x00lib_channel(struct ieee80211_channel *entry,
804  const int channel, const int tx_power,
805  const int value)
806 {
807  /* XXX: this assumption about the band is wrong for 802.11j */
808  entry->band = channel <= 14 ? IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
810  entry->band);
811  entry->hw_value = value;
812  entry->max_power = tx_power;
813  entry->max_antenna_gain = 0xff;
814 }
815 
816 static void rt2x00lib_rate(struct ieee80211_rate *entry,
817  const u16 index, const struct rt2x00_rate *rate)
818 {
819  entry->flags = 0;
820  entry->bitrate = rate->bitrate;
821  entry->hw_value = index;
822  entry->hw_value_short = index;
823 
824  if (rate->flags & DEV_RATE_SHORT_PREAMBLE)
826 }
827 
828 static int rt2x00lib_probe_hw_modes(struct rt2x00_dev *rt2x00dev,
829  struct hw_mode_spec *spec)
830 {
831  struct ieee80211_hw *hw = rt2x00dev->hw;
832  struct ieee80211_channel *channels;
833  struct ieee80211_rate *rates;
834  unsigned int num_rates;
835  unsigned int i;
836 
837  num_rates = 0;
838  if (spec->supported_rates & SUPPORT_RATE_CCK)
839  num_rates += 4;
841  num_rates += 8;
842 
843  channels = kcalloc(spec->num_channels, sizeof(*channels), GFP_KERNEL);
844  if (!channels)
845  return -ENOMEM;
846 
847  rates = kcalloc(num_rates, sizeof(*rates), GFP_KERNEL);
848  if (!rates)
849  goto exit_free_channels;
850 
851  /*
852  * Initialize Rate list.
853  */
854  for (i = 0; i < num_rates; i++)
855  rt2x00lib_rate(&rates[i], i, rt2x00_get_rate(i));
856 
857  /*
858  * Initialize Channel list.
859  */
860  for (i = 0; i < spec->num_channels; i++) {
861  rt2x00lib_channel(&channels[i],
862  spec->channels[i].channel,
863  spec->channels_info[i].max_power, i);
864  }
865 
866  /*
867  * Intitialize 802.11b, 802.11g
868  * Rates: CCK, OFDM.
869  * Channels: 2.4 GHz
870  */
871  if (spec->supported_bands & SUPPORT_BAND_2GHZ) {
872  rt2x00dev->bands[IEEE80211_BAND_2GHZ].n_channels = 14;
873  rt2x00dev->bands[IEEE80211_BAND_2GHZ].n_bitrates = num_rates;
874  rt2x00dev->bands[IEEE80211_BAND_2GHZ].channels = channels;
875  rt2x00dev->bands[IEEE80211_BAND_2GHZ].bitrates = rates;
876  hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
877  &rt2x00dev->bands[IEEE80211_BAND_2GHZ];
878  memcpy(&rt2x00dev->bands[IEEE80211_BAND_2GHZ].ht_cap,
879  &spec->ht, sizeof(spec->ht));
880  }
881 
882  /*
883  * Intitialize 802.11a
884  * Rates: OFDM.
885  * Channels: OFDM, UNII, HiperLAN2.
886  */
887  if (spec->supported_bands & SUPPORT_BAND_5GHZ) {
888  rt2x00dev->bands[IEEE80211_BAND_5GHZ].n_channels =
889  spec->num_channels - 14;
890  rt2x00dev->bands[IEEE80211_BAND_5GHZ].n_bitrates =
891  num_rates - 4;
892  rt2x00dev->bands[IEEE80211_BAND_5GHZ].channels = &channels[14];
893  rt2x00dev->bands[IEEE80211_BAND_5GHZ].bitrates = &rates[4];
894  hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
895  &rt2x00dev->bands[IEEE80211_BAND_5GHZ];
896  memcpy(&rt2x00dev->bands[IEEE80211_BAND_5GHZ].ht_cap,
897  &spec->ht, sizeof(spec->ht));
898  }
899 
900  return 0;
901 
902  exit_free_channels:
903  kfree(channels);
904  ERROR(rt2x00dev, "Allocation ieee80211 modes failed.\n");
905  return -ENOMEM;
906 }
907 
908 static void rt2x00lib_remove_hw(struct rt2x00_dev *rt2x00dev)
909 {
910  if (test_bit(DEVICE_STATE_REGISTERED_HW, &rt2x00dev->flags))
911  ieee80211_unregister_hw(rt2x00dev->hw);
912 
913  if (likely(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ])) {
914  kfree(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ]->channels);
915  kfree(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ]->bitrates);
916  rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = NULL;
917  rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = NULL;
918  }
919 
920  kfree(rt2x00dev->spec.channels_info);
921 }
922 
923 static int rt2x00lib_probe_hw(struct rt2x00_dev *rt2x00dev)
924 {
925  struct hw_mode_spec *spec = &rt2x00dev->spec;
926  int status;
927 
928  if (test_bit(DEVICE_STATE_REGISTERED_HW, &rt2x00dev->flags))
929  return 0;
930 
931  /*
932  * Initialize HW modes.
933  */
934  status = rt2x00lib_probe_hw_modes(rt2x00dev, spec);
935  if (status)
936  return status;
937 
938  /*
939  * Initialize HW fields.
940  */
941  rt2x00dev->hw->queues = rt2x00dev->ops->tx_queues;
942 
943  /*
944  * Initialize extra TX headroom required.
945  */
946  rt2x00dev->hw->extra_tx_headroom =
947  max_t(unsigned int, IEEE80211_TX_STATUS_HEADROOM,
948  rt2x00dev->ops->extra_tx_headroom);
949 
950  /*
951  * Take TX headroom required for alignment into account.
952  */
953  if (test_bit(REQUIRE_L2PAD, &rt2x00dev->cap_flags))
954  rt2x00dev->hw->extra_tx_headroom += RT2X00_L2PAD_SIZE;
955  else if (test_bit(REQUIRE_DMA, &rt2x00dev->cap_flags))
956  rt2x00dev->hw->extra_tx_headroom += RT2X00_ALIGN_SIZE;
957 
958  /*
959  * Tell mac80211 about the size of our private STA structure.
960  */
961  rt2x00dev->hw->sta_data_size = sizeof(struct rt2x00_sta);
962 
963  /*
964  * Allocate tx status FIFO for driver use.
965  */
966  if (test_bit(REQUIRE_TXSTATUS_FIFO, &rt2x00dev->cap_flags)) {
967  /*
968  * Allocate the txstatus fifo. In the worst case the tx
969  * status fifo has to hold the tx status of all entries
970  * in all tx queues. Hence, calculate the kfifo size as
971  * tx_queues * entry_num and round up to the nearest
972  * power of 2.
973  */
974  int kfifo_size =
975  roundup_pow_of_two(rt2x00dev->ops->tx_queues *
976  rt2x00dev->ops->tx->entry_num *
977  sizeof(u32));
978 
979  status = kfifo_alloc(&rt2x00dev->txstatus_fifo, kfifo_size,
980  GFP_KERNEL);
981  if (status)
982  return status;
983  }
984 
985  /*
986  * Initialize tasklets if used by the driver. Tasklets are
987  * disabled until the interrupts are turned on. The driver
988  * has to handle that.
989  */
990 #define RT2X00_TASKLET_INIT(taskletname) \
991  if (rt2x00dev->ops->lib->taskletname) { \
992  tasklet_init(&rt2x00dev->taskletname, \
993  rt2x00dev->ops->lib->taskletname, \
994  (unsigned long)rt2x00dev); \
995  }
996 
997  RT2X00_TASKLET_INIT(txstatus_tasklet);
998  RT2X00_TASKLET_INIT(pretbtt_tasklet);
999  RT2X00_TASKLET_INIT(tbtt_tasklet);
1000  RT2X00_TASKLET_INIT(rxdone_tasklet);
1001  RT2X00_TASKLET_INIT(autowake_tasklet);
1002 
1003 #undef RT2X00_TASKLET_INIT
1004 
1005  /*
1006  * Register HW.
1007  */
1008  status = ieee80211_register_hw(rt2x00dev->hw);
1009  if (status)
1010  return status;
1011 
1013 
1014  return 0;
1015 }
1016 
1017 /*
1018  * Initialization/uninitialization handlers.
1019  */
1020 static void rt2x00lib_uninitialize(struct rt2x00_dev *rt2x00dev)
1021 {
1023  return;
1024 
1025  /*
1026  * Unregister extra components.
1027  */
1028  rt2x00rfkill_unregister(rt2x00dev);
1029 
1030  /*
1031  * Allow the HW to uninitialize.
1032  */
1033  rt2x00dev->ops->lib->uninitialize(rt2x00dev);
1034 
1035  /*
1036  * Free allocated queue entries.
1037  */
1038  rt2x00queue_uninitialize(rt2x00dev);
1039 }
1040 
1041 static int rt2x00lib_initialize(struct rt2x00_dev *rt2x00dev)
1042 {
1043  int status;
1044 
1045  if (test_bit(DEVICE_STATE_INITIALIZED, &rt2x00dev->flags))
1046  return 0;
1047 
1048  /*
1049  * Allocate all queue entries.
1050  */
1051  status = rt2x00queue_initialize(rt2x00dev);
1052  if (status)
1053  return status;
1054 
1055  /*
1056  * Initialize the device.
1057  */
1058  status = rt2x00dev->ops->lib->initialize(rt2x00dev);
1059  if (status) {
1060  rt2x00queue_uninitialize(rt2x00dev);
1061  return status;
1062  }
1063 
1064  set_bit(DEVICE_STATE_INITIALIZED, &rt2x00dev->flags);
1065 
1066  return 0;
1067 }
1068 
1069 int rt2x00lib_start(struct rt2x00_dev *rt2x00dev)
1070 {
1071  int retval;
1072 
1073  if (test_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags))
1074  return 0;
1075 
1076  /*
1077  * If this is the first interface which is added,
1078  * we should load the firmware now.
1079  */
1080  retval = rt2x00lib_load_firmware(rt2x00dev);
1081  if (retval)
1082  return retval;
1083 
1084  /*
1085  * Initialize the device.
1086  */
1087  retval = rt2x00lib_initialize(rt2x00dev);
1088  if (retval)
1089  return retval;
1090 
1091  rt2x00dev->intf_ap_count = 0;
1092  rt2x00dev->intf_sta_count = 0;
1093  rt2x00dev->intf_associated = 0;
1094 
1095  /* Enable the radio */
1096  retval = rt2x00lib_enable_radio(rt2x00dev);
1097  if (retval)
1098  return retval;
1099 
1100  set_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags);
1101 
1102  return 0;
1103 }
1104 
1105 void rt2x00lib_stop(struct rt2x00_dev *rt2x00dev)
1106 {
1107  if (!test_and_clear_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags))
1108  return;
1109 
1110  /*
1111  * Perhaps we can add something smarter here,
1112  * but for now just disabling the radio should do.
1113  */
1114  rt2x00lib_disable_radio(rt2x00dev);
1115 
1116  rt2x00dev->intf_ap_count = 0;
1117  rt2x00dev->intf_sta_count = 0;
1118  rt2x00dev->intf_associated = 0;
1119 }
1120 
1121 static inline void rt2x00lib_set_if_combinations(struct rt2x00_dev *rt2x00dev)
1122 {
1123  struct ieee80211_iface_limit *if_limit;
1124  struct ieee80211_iface_combination *if_combination;
1125 
1126  /*
1127  * Build up AP interface limits structure.
1128  */
1129  if_limit = &rt2x00dev->if_limits_ap;
1130  if_limit->max = rt2x00dev->ops->max_ap_intf;
1131  if_limit->types = BIT(NL80211_IFTYPE_AP);
1132 
1133  /*
1134  * Build up AP interface combinations structure.
1135  */
1136  if_combination = &rt2x00dev->if_combinations[IF_COMB_AP];
1137  if_combination->limits = if_limit;
1138  if_combination->n_limits = 1;
1139  if_combination->max_interfaces = if_limit->max;
1140  if_combination->num_different_channels = 1;
1141 
1142  /*
1143  * Finally, specify the possible combinations to mac80211.
1144  */
1145  rt2x00dev->hw->wiphy->iface_combinations = rt2x00dev->if_combinations;
1146  rt2x00dev->hw->wiphy->n_iface_combinations = 1;
1147 }
1148 
1149 /*
1150  * driver allocation handlers.
1151  */
1152 int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev)
1153 {
1154  int retval = -ENOMEM;
1155 
1156  /*
1157  * Set possible interface combinations.
1158  */
1159  rt2x00lib_set_if_combinations(rt2x00dev);
1160 
1161  /*
1162  * Allocate the driver data memory, if necessary.
1163  */
1164  if (rt2x00dev->ops->drv_data_size > 0) {
1165  rt2x00dev->drv_data = kzalloc(rt2x00dev->ops->drv_data_size,
1166  GFP_KERNEL);
1167  if (!rt2x00dev->drv_data) {
1168  retval = -ENOMEM;
1169  goto exit;
1170  }
1171  }
1172 
1173  spin_lock_init(&rt2x00dev->irqmask_lock);
1174  mutex_init(&rt2x00dev->csr_mutex);
1175 
1176  set_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
1177 
1178  /*
1179  * Make room for rt2x00_intf inside the per-interface
1180  * structure ieee80211_vif.
1181  */
1182  rt2x00dev->hw->vif_data_size = sizeof(struct rt2x00_intf);
1183 
1184  /*
1185  * Determine which operating modes are supported, all modes
1186  * which require beaconing, depend on the availability of
1187  * beacon entries.
1188  */
1189  rt2x00dev->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
1190  if (rt2x00dev->ops->bcn->entry_num > 0)
1191  rt2x00dev->hw->wiphy->interface_modes |=
1196 
1197  rt2x00dev->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
1198 
1199  /*
1200  * Initialize work.
1201  */
1202  rt2x00dev->workqueue =
1203  alloc_ordered_workqueue(wiphy_name(rt2x00dev->hw->wiphy), 0);
1204  if (!rt2x00dev->workqueue) {
1205  retval = -ENOMEM;
1206  goto exit;
1207  }
1208 
1209  INIT_WORK(&rt2x00dev->intf_work, rt2x00lib_intf_scheduled);
1210  INIT_DELAYED_WORK(&rt2x00dev->autowakeup_work, rt2x00lib_autowakeup);
1211  INIT_WORK(&rt2x00dev->sleep_work, rt2x00lib_sleep);
1212 
1213  /*
1214  * Let the driver probe the device to detect the capabilities.
1215  */
1216  retval = rt2x00dev->ops->lib->probe_hw(rt2x00dev);
1217  if (retval) {
1218  ERROR(rt2x00dev, "Failed to allocate device.\n");
1219  goto exit;
1220  }
1221 
1222  /*
1223  * Allocate queue array.
1224  */
1225  retval = rt2x00queue_allocate(rt2x00dev);
1226  if (retval)
1227  goto exit;
1228 
1229  /*
1230  * Initialize ieee80211 structure.
1231  */
1232  retval = rt2x00lib_probe_hw(rt2x00dev);
1233  if (retval) {
1234  ERROR(rt2x00dev, "Failed to initialize hw.\n");
1235  goto exit;
1236  }
1237 
1238  /*
1239  * Register extra components.
1240  */
1241  rt2x00link_register(rt2x00dev);
1242  rt2x00leds_register(rt2x00dev);
1243  rt2x00debug_register(rt2x00dev);
1244  rt2x00rfkill_register(rt2x00dev);
1245 
1246  return 0;
1247 
1248 exit:
1249  rt2x00lib_remove_dev(rt2x00dev);
1250 
1251  return retval;
1252 }
1254 
1255 void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev)
1256 {
1257  clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
1258 
1259  /*
1260  * Disable radio.
1261  */
1262  rt2x00lib_disable_radio(rt2x00dev);
1263 
1264  /*
1265  * Stop all work.
1266  */
1267  cancel_work_sync(&rt2x00dev->intf_work);
1269  cancel_work_sync(&rt2x00dev->sleep_work);
1270  if (rt2x00_is_usb(rt2x00dev)) {
1271  hrtimer_cancel(&rt2x00dev->txstatus_timer);
1272  cancel_work_sync(&rt2x00dev->rxdone_work);
1273  cancel_work_sync(&rt2x00dev->txdone_work);
1274  }
1275  if (rt2x00dev->workqueue)
1276  destroy_workqueue(rt2x00dev->workqueue);
1277 
1278  /*
1279  * Free the tx status fifo.
1280  */
1281  kfifo_free(&rt2x00dev->txstatus_fifo);
1282 
1283  /*
1284  * Kill the tx status tasklet.
1285  */
1286  tasklet_kill(&rt2x00dev->txstatus_tasklet);
1287  tasklet_kill(&rt2x00dev->pretbtt_tasklet);
1288  tasklet_kill(&rt2x00dev->tbtt_tasklet);
1289  tasklet_kill(&rt2x00dev->rxdone_tasklet);
1290  tasklet_kill(&rt2x00dev->autowake_tasklet);
1291 
1292  /*
1293  * Uninitialize device.
1294  */
1295  rt2x00lib_uninitialize(rt2x00dev);
1296 
1297  /*
1298  * Free extra components
1299  */
1300  rt2x00debug_deregister(rt2x00dev);
1301  rt2x00leds_unregister(rt2x00dev);
1302 
1303  /*
1304  * Free ieee80211_hw memory.
1305  */
1306  rt2x00lib_remove_hw(rt2x00dev);
1307 
1308  /*
1309  * Free firmware image.
1310  */
1311  rt2x00lib_free_firmware(rt2x00dev);
1312 
1313  /*
1314  * Free queue structures.
1315  */
1316  rt2x00queue_free(rt2x00dev);
1317 
1318  /*
1319  * Free the driver data.
1320  */
1321  if (rt2x00dev->drv_data)
1322  kfree(rt2x00dev->drv_data);
1323 }
1325 
1326 /*
1327  * Device state handlers
1328  */
1329 #ifdef CONFIG_PM
1330 int rt2x00lib_suspend(struct rt2x00_dev *rt2x00dev, pm_message_t state)
1331 {
1332  NOTICE(rt2x00dev, "Going to sleep.\n");
1333 
1334  /*
1335  * Prevent mac80211 from accessing driver while suspended.
1336  */
1337  if (!test_and_clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
1338  return 0;
1339 
1340  /*
1341  * Cleanup as much as possible.
1342  */
1343  rt2x00lib_uninitialize(rt2x00dev);
1344 
1345  /*
1346  * Suspend/disable extra components.
1347  */
1348  rt2x00leds_suspend(rt2x00dev);
1349  rt2x00debug_deregister(rt2x00dev);
1350 
1351  /*
1352  * Set device mode to sleep for power management,
1353  * on some hardware this call seems to consistently fail.
1354  * From the specifications it is hard to tell why it fails,
1355  * and if this is a "bad thing".
1356  * Overall it is safe to just ignore the failure and
1357  * continue suspending. The only downside is that the
1358  * device will not be in optimal power save mode, but with
1359  * the radio and the other components already disabled the
1360  * device is as good as disabled.
1361  */
1362  if (rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_SLEEP))
1363  WARNING(rt2x00dev, "Device failed to enter sleep state, "
1364  "continue suspending.\n");
1365 
1366  return 0;
1367 }
1368 EXPORT_SYMBOL_GPL(rt2x00lib_suspend);
1369 
1370 int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev)
1371 {
1372  NOTICE(rt2x00dev, "Waking up.\n");
1373 
1374  /*
1375  * Restore/enable extra components.
1376  */
1377  rt2x00debug_register(rt2x00dev);
1378  rt2x00leds_resume(rt2x00dev);
1379 
1380  /*
1381  * We are ready again to receive requests from mac80211.
1382  */
1383  set_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
1384 
1385  return 0;
1386 }
1387 EXPORT_SYMBOL_GPL(rt2x00lib_resume);
1388 #endif /* CONFIG_PM */
1389 
1390 /*
1391  * rt2x00lib module information.
1392  */
1395 MODULE_DESCRIPTION("rt2x00 library");
1396 MODULE_LICENSE("GPL");