1 /*
2 Copyright (C) 2004 - 2009 Ivo van Doorn <IvDoorn@gmail.com>
3 <http://rt2x00.serialmonkey.com>
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the
17 Free Software Foundation, Inc.,
18 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 */
20
21 /*
22 Module: rt2x00mac
23 Abstract: rt2x00 generic mac80211 routines.
24 */
25
26 #include <linux/kernel.h>
27 #include <linux/module.h>
28
29 #include "rt2x00.h"
30 #include "rt2x00lib.h"
31
rt2x00mac_tx_rts_cts(struct rt2x00_dev * rt2x00dev,struct data_queue * queue,struct sk_buff * frag_skb)32 static int rt2x00mac_tx_rts_cts(struct rt2x00_dev *rt2x00dev,
33 struct data_queue *queue,
34 struct sk_buff *frag_skb)
35 {
36 struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(frag_skb);
37 struct ieee80211_tx_info *rts_info;
38 struct sk_buff *skb;
39 unsigned int data_length;
40 int retval = 0;
41
42 if (tx_info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT)
43 data_length = sizeof(struct ieee80211_cts);
44 else
45 data_length = sizeof(struct ieee80211_rts);
46
47 skb = dev_alloc_skb(data_length + rt2x00dev->hw->extra_tx_headroom);
48 if (unlikely(!skb)) {
49 WARNING(rt2x00dev, "Failed to create RTS/CTS frame.\n");
50 return -ENOMEM;
51 }
52
53 skb_reserve(skb, rt2x00dev->hw->extra_tx_headroom);
54 skb_put(skb, data_length);
55
56 /*
57 * Copy TX information over from original frame to
58 * RTS/CTS frame. Note that we set the no encryption flag
59 * since we don't want this frame to be encrypted.
60 * RTS frames should be acked, while CTS-to-self frames
61 * should not. The ready for TX flag is cleared to prevent
62 * it being automatically send when the descriptor is
63 * written to the hardware.
64 */
65 memcpy(skb->cb, frag_skb->cb, sizeof(skb->cb));
66 rts_info = IEEE80211_SKB_CB(skb);
67 rts_info->control.rates[0].flags &= ~IEEE80211_TX_RC_USE_RTS_CTS;
68 rts_info->control.rates[0].flags &= ~IEEE80211_TX_RC_USE_CTS_PROTECT;
69
70 if (tx_info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT)
71 rts_info->flags |= IEEE80211_TX_CTL_NO_ACK;
72 else
73 rts_info->flags &= ~IEEE80211_TX_CTL_NO_ACK;
74
75 /* Disable hardware encryption */
76 rts_info->control.hw_key = NULL;
77
78 /*
79 * RTS/CTS frame should use the length of the frame plus any
80 * encryption overhead that will be added by the hardware.
81 */
82 data_length += rt2x00crypto_tx_overhead(rt2x00dev, skb);
83
84 if (tx_info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT)
85 ieee80211_ctstoself_get(rt2x00dev->hw, tx_info->control.vif,
86 frag_skb->data, data_length, tx_info,
87 (struct ieee80211_cts *)(skb->data));
88 else
89 ieee80211_rts_get(rt2x00dev->hw, tx_info->control.vif,
90 frag_skb->data, data_length, tx_info,
91 (struct ieee80211_rts *)(skb->data));
92
93 retval = rt2x00queue_write_tx_frame(queue, skb, true);
94 if (retval) {
95 dev_kfree_skb_any(skb);
96 WARNING(rt2x00dev, "Failed to send RTS/CTS frame.\n");
97 }
98
99 return retval;
100 }
101
rt2x00mac_tx(struct ieee80211_hw * hw,struct sk_buff * skb)102 void rt2x00mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
103 {
104 struct rt2x00_dev *rt2x00dev = hw->priv;
105 struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
106 enum data_queue_qid qid = skb_get_queue_mapping(skb);
107 struct data_queue *queue = NULL;
108
109 /*
110 * Mac80211 might be calling this function while we are trying
111 * to remove the device or perhaps suspending it.
112 * Note that we can only stop the TX queues inside the TX path
113 * due to possible race conditions in mac80211.
114 */
115 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
116 goto exit_free_skb;
117
118 /*
119 * Use the ATIM queue if appropriate and present.
120 */
121 if (tx_info->flags & IEEE80211_TX_CTL_SEND_AFTER_DTIM &&
122 test_bit(REQUIRE_ATIM_QUEUE, &rt2x00dev->cap_flags))
123 qid = QID_ATIM;
124
125 queue = rt2x00queue_get_tx_queue(rt2x00dev, qid);
126 if (unlikely(!queue)) {
127 ERROR(rt2x00dev,
128 "Attempt to send packet over invalid queue %d.\n"
129 "Please file bug report to %s.\n", qid, DRV_PROJECT);
130 goto exit_free_skb;
131 }
132
133 /*
134 * If CTS/RTS is required. create and queue that frame first.
135 * Make sure we have at least enough entries available to send
136 * this CTS/RTS frame as well as the data frame.
137 * Note that when the driver has set the set_rts_threshold()
138 * callback function it doesn't need software generation of
139 * either RTS or CTS-to-self frame and handles everything
140 * inside the hardware.
141 */
142 if (!rt2x00dev->ops->hw->set_rts_threshold &&
143 (tx_info->control.rates[0].flags & (IEEE80211_TX_RC_USE_RTS_CTS |
144 IEEE80211_TX_RC_USE_CTS_PROTECT))) {
145 if (rt2x00queue_available(queue) <= 1)
146 goto exit_fail;
147
148 if (rt2x00mac_tx_rts_cts(rt2x00dev, queue, skb))
149 goto exit_fail;
150 }
151
152 if (unlikely(rt2x00queue_write_tx_frame(queue, skb, false)))
153 goto exit_fail;
154
155 /*
156 * Pausing queue has to be serialized with rt2x00lib_txdone(). Note
157 * we should not use spin_lock_bh variant as bottom halve was already
158 * disabled before ieee80211_xmit() call.
159 */
160 spin_lock(&queue->tx_lock);
161 if (rt2x00queue_threshold(queue))
162 rt2x00queue_pause_queue(queue);
163 spin_unlock(&queue->tx_lock);
164
165 return;
166
167 exit_fail:
168 spin_lock(&queue->tx_lock);
169 rt2x00queue_pause_queue(queue);
170 spin_unlock(&queue->tx_lock);
171 exit_free_skb:
172 ieee80211_free_txskb(hw, skb);
173 }
174 EXPORT_SYMBOL_GPL(rt2x00mac_tx);
175
rt2x00mac_start(struct ieee80211_hw * hw)176 int rt2x00mac_start(struct ieee80211_hw *hw)
177 {
178 struct rt2x00_dev *rt2x00dev = hw->priv;
179
180 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
181 return 0;
182
183 return rt2x00lib_start(rt2x00dev);
184 }
185 EXPORT_SYMBOL_GPL(rt2x00mac_start);
186
rt2x00mac_stop(struct ieee80211_hw * hw)187 void rt2x00mac_stop(struct ieee80211_hw *hw)
188 {
189 struct rt2x00_dev *rt2x00dev = hw->priv;
190
191 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
192 return;
193
194 rt2x00lib_stop(rt2x00dev);
195 }
196 EXPORT_SYMBOL_GPL(rt2x00mac_stop);
197
rt2x00mac_add_interface(struct ieee80211_hw * hw,struct ieee80211_vif * vif)198 int rt2x00mac_add_interface(struct ieee80211_hw *hw,
199 struct ieee80211_vif *vif)
200 {
201 struct rt2x00_dev *rt2x00dev = hw->priv;
202 struct rt2x00_intf *intf = vif_to_intf(vif);
203 struct data_queue *queue = rt2x00dev->bcn;
204 struct queue_entry *entry = NULL;
205 unsigned int i;
206
207 /*
208 * Don't allow interfaces to be added
209 * the device has disappeared.
210 */
211 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) ||
212 !test_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags))
213 return -ENODEV;
214
215 switch (vif->type) {
216 case NL80211_IFTYPE_AP:
217 /*
218 * We don't support mixed combinations of
219 * sta and ap interfaces.
220 */
221 if (rt2x00dev->intf_sta_count)
222 return -ENOBUFS;
223
224 /*
225 * Check if we exceeded the maximum amount
226 * of supported interfaces.
227 */
228 if (rt2x00dev->intf_ap_count >= rt2x00dev->ops->max_ap_intf)
229 return -ENOBUFS;
230
231 break;
232 case NL80211_IFTYPE_STATION:
233 case NL80211_IFTYPE_ADHOC:
234 case NL80211_IFTYPE_MESH_POINT:
235 case NL80211_IFTYPE_WDS:
236 /*
237 * We don't support mixed combinations of
238 * sta and ap interfaces.
239 */
240 if (rt2x00dev->intf_ap_count)
241 return -ENOBUFS;
242
243 /*
244 * Check if we exceeded the maximum amount
245 * of supported interfaces.
246 */
247 if (rt2x00dev->intf_sta_count >= rt2x00dev->ops->max_sta_intf)
248 return -ENOBUFS;
249
250 break;
251 default:
252 return -EINVAL;
253 }
254
255 /*
256 * Loop through all beacon queues to find a free
257 * entry. Since there are as much beacon entries
258 * as the maximum interfaces, this search shouldn't
259 * fail.
260 */
261 for (i = 0; i < queue->limit; i++) {
262 entry = &queue->entries[i];
263 if (!test_and_set_bit(ENTRY_BCN_ASSIGNED, &entry->flags))
264 break;
265 }
266
267 if (unlikely(i == queue->limit))
268 return -ENOBUFS;
269
270 /*
271 * We are now absolutely sure the interface can be created,
272 * increase interface count and start initialization.
273 */
274
275 if (vif->type == NL80211_IFTYPE_AP)
276 rt2x00dev->intf_ap_count++;
277 else
278 rt2x00dev->intf_sta_count++;
279
280 mutex_init(&intf->beacon_skb_mutex);
281 intf->beacon = entry;
282
283 /*
284 * The MAC address must be configured after the device
285 * has been initialized. Otherwise the device can reset
286 * the MAC registers.
287 * The BSSID address must only be configured in AP mode,
288 * however we should not send an empty BSSID address for
289 * STA interfaces at this time, since this can cause
290 * invalid behavior in the device.
291 */
292 rt2x00lib_config_intf(rt2x00dev, intf, vif->type,
293 vif->addr, NULL);
294
295 /*
296 * Some filters depend on the current working mode. We can force
297 * an update during the next configure_filter() run by mac80211 by
298 * resetting the current packet_filter state.
299 */
300 rt2x00dev->packet_filter = 0;
301
302 return 0;
303 }
304 EXPORT_SYMBOL_GPL(rt2x00mac_add_interface);
305
rt2x00mac_remove_interface(struct ieee80211_hw * hw,struct ieee80211_vif * vif)306 void rt2x00mac_remove_interface(struct ieee80211_hw *hw,
307 struct ieee80211_vif *vif)
308 {
309 struct rt2x00_dev *rt2x00dev = hw->priv;
310 struct rt2x00_intf *intf = vif_to_intf(vif);
311
312 /*
313 * Don't allow interfaces to be remove while
314 * either the device has disappeared or when
315 * no interface is present.
316 */
317 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) ||
318 (vif->type == NL80211_IFTYPE_AP && !rt2x00dev->intf_ap_count) ||
319 (vif->type != NL80211_IFTYPE_AP && !rt2x00dev->intf_sta_count))
320 return;
321
322 if (vif->type == NL80211_IFTYPE_AP)
323 rt2x00dev->intf_ap_count--;
324 else
325 rt2x00dev->intf_sta_count--;
326
327 /*
328 * Release beacon entry so it is available for
329 * new interfaces again.
330 */
331 clear_bit(ENTRY_BCN_ASSIGNED, &intf->beacon->flags);
332
333 /*
334 * Make sure the bssid and mac address registers
335 * are cleared to prevent false ACKing of frames.
336 */
337 rt2x00lib_config_intf(rt2x00dev, intf,
338 NL80211_IFTYPE_UNSPECIFIED, NULL, NULL);
339 }
340 EXPORT_SYMBOL_GPL(rt2x00mac_remove_interface);
341
rt2x00mac_config(struct ieee80211_hw * hw,u32 changed)342 int rt2x00mac_config(struct ieee80211_hw *hw, u32 changed)
343 {
344 struct rt2x00_dev *rt2x00dev = hw->priv;
345 struct ieee80211_conf *conf = &hw->conf;
346
347 /*
348 * mac80211 might be calling this function while we are trying
349 * to remove the device or perhaps suspending it.
350 */
351 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
352 return 0;
353
354 /*
355 * Some configuration parameters (e.g. channel and antenna values) can
356 * only be set when the radio is enabled, but do require the RX to
357 * be off. During this period we should keep link tuning enabled,
358 * if for any reason the link tuner must be reset, this will be
359 * handled by rt2x00lib_config().
360 */
361 rt2x00queue_stop_queue(rt2x00dev->rx);
362
363 /*
364 * When we've just turned on the radio, we want to reprogram
365 * everything to ensure a consistent state
366 */
367 rt2x00lib_config(rt2x00dev, conf, changed);
368
369 /*
370 * After the radio has been enabled we need to configure
371 * the antenna to the default settings. rt2x00lib_config_antenna()
372 * should determine if any action should be taken based on
373 * checking if diversity has been enabled or no antenna changes
374 * have been made since the last configuration change.
375 */
376 rt2x00lib_config_antenna(rt2x00dev, rt2x00dev->default_ant);
377
378 /* Turn RX back on */
379 rt2x00queue_start_queue(rt2x00dev->rx);
380
381 return 0;
382 }
383 EXPORT_SYMBOL_GPL(rt2x00mac_config);
384
rt2x00mac_configure_filter(struct ieee80211_hw * hw,unsigned int changed_flags,unsigned int * total_flags,u64 multicast)385 void rt2x00mac_configure_filter(struct ieee80211_hw *hw,
386 unsigned int changed_flags,
387 unsigned int *total_flags,
388 u64 multicast)
389 {
390 struct rt2x00_dev *rt2x00dev = hw->priv;
391
392 /*
393 * Mask off any flags we are going to ignore
394 * from the total_flags field.
395 */
396 *total_flags &=
397 FIF_ALLMULTI |
398 FIF_FCSFAIL |
399 FIF_PLCPFAIL |
400 FIF_CONTROL |
401 FIF_PSPOLL |
402 FIF_OTHER_BSS |
403 FIF_PROMISC_IN_BSS;
404
405 /*
406 * Apply some rules to the filters:
407 * - Some filters imply different filters to be set.
408 * - Some things we can't filter out at all.
409 * - Multicast filter seems to kill broadcast traffic so never use it.
410 */
411 *total_flags |= FIF_ALLMULTI;
412 if (*total_flags & FIF_OTHER_BSS ||
413 *total_flags & FIF_PROMISC_IN_BSS)
414 *total_flags |= FIF_PROMISC_IN_BSS | FIF_OTHER_BSS;
415
416 /*
417 * If the device has a single filter for all control frames,
418 * FIF_CONTROL and FIF_PSPOLL flags imply each other.
419 * And if the device has more than one filter for control frames
420 * of different types, but has no a separate filter for PS Poll frames,
421 * FIF_CONTROL flag implies FIF_PSPOLL.
422 */
423 if (!test_bit(CAPABILITY_CONTROL_FILTERS, &rt2x00dev->cap_flags)) {
424 if (*total_flags & FIF_CONTROL || *total_flags & FIF_PSPOLL)
425 *total_flags |= FIF_CONTROL | FIF_PSPOLL;
426 }
427 if (!test_bit(CAPABILITY_CONTROL_FILTER_PSPOLL, &rt2x00dev->cap_flags)) {
428 if (*total_flags & FIF_CONTROL)
429 *total_flags |= FIF_PSPOLL;
430 }
431
432 /*
433 * Check if there is any work left for us.
434 */
435 if (rt2x00dev->packet_filter == *total_flags)
436 return;
437 rt2x00dev->packet_filter = *total_flags;
438
439 rt2x00dev->ops->lib->config_filter(rt2x00dev, *total_flags);
440 }
441 EXPORT_SYMBOL_GPL(rt2x00mac_configure_filter);
442
rt2x00mac_set_tim_iter(void * data,u8 * mac,struct ieee80211_vif * vif)443 static void rt2x00mac_set_tim_iter(void *data, u8 *mac,
444 struct ieee80211_vif *vif)
445 {
446 struct rt2x00_intf *intf = vif_to_intf(vif);
447
448 if (vif->type != NL80211_IFTYPE_AP &&
449 vif->type != NL80211_IFTYPE_ADHOC &&
450 vif->type != NL80211_IFTYPE_MESH_POINT &&
451 vif->type != NL80211_IFTYPE_WDS)
452 return;
453
454 set_bit(DELAYED_UPDATE_BEACON, &intf->delayed_flags);
455 }
456
rt2x00mac_set_tim(struct ieee80211_hw * hw,struct ieee80211_sta * sta,bool set)457 int rt2x00mac_set_tim(struct ieee80211_hw *hw, struct ieee80211_sta *sta,
458 bool set)
459 {
460 struct rt2x00_dev *rt2x00dev = hw->priv;
461
462 if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
463 return 0;
464
465 ieee80211_iterate_active_interfaces_atomic(rt2x00dev->hw,
466 rt2x00mac_set_tim_iter,
467 rt2x00dev);
468
469 /* queue work to upodate the beacon template */
470 ieee80211_queue_work(rt2x00dev->hw, &rt2x00dev->intf_work);
471 return 0;
472 }
473 EXPORT_SYMBOL_GPL(rt2x00mac_set_tim);
474
475 #ifdef CONFIG_RT2X00_LIB_CRYPTO
memcpy_tkip(struct rt2x00lib_crypto * crypto,u8 * key,u8 key_len)476 static void memcpy_tkip(struct rt2x00lib_crypto *crypto, u8 *key, u8 key_len)
477 {
478 if (key_len > NL80211_TKIP_DATA_OFFSET_ENCR_KEY)
479 memcpy(crypto->key,
480 &key[NL80211_TKIP_DATA_OFFSET_ENCR_KEY],
481 sizeof(crypto->key));
482
483 if (key_len > NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY)
484 memcpy(crypto->tx_mic,
485 &key[NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY],
486 sizeof(crypto->tx_mic));
487
488 if (key_len > NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY)
489 memcpy(crypto->rx_mic,
490 &key[NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY],
491 sizeof(crypto->rx_mic));
492 }
493
rt2x00mac_set_key(struct ieee80211_hw * hw,enum set_key_cmd cmd,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct ieee80211_key_conf * key)494 int rt2x00mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
495 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
496 struct ieee80211_key_conf *key)
497 {
498 struct rt2x00_dev *rt2x00dev = hw->priv;
499 int (*set_key) (struct rt2x00_dev *rt2x00dev,
500 struct rt2x00lib_crypto *crypto,
501 struct ieee80211_key_conf *key);
502 struct rt2x00lib_crypto crypto;
503 static const u8 bcast_addr[ETH_ALEN] =
504 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, };
505 struct rt2x00_sta *sta_priv = NULL;
506
507 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
508 return 0;
509 else if (!test_bit(CAPABILITY_HW_CRYPTO, &rt2x00dev->cap_flags))
510 return -EOPNOTSUPP;
511 else if (key->keylen > 32)
512 return -ENOSPC;
513
514 memset(&crypto, 0, sizeof(crypto));
515
516 crypto.bssidx = rt2x00lib_get_bssidx(rt2x00dev, vif);
517 crypto.cipher = rt2x00crypto_key_to_cipher(key);
518 if (crypto.cipher == CIPHER_NONE)
519 return -EOPNOTSUPP;
520 if (crypto.cipher == CIPHER_TKIP && rt2x00_is_usb(rt2x00dev))
521 return -EOPNOTSUPP;
522
523 crypto.cmd = cmd;
524
525 if (sta) {
526 crypto.address = sta->addr;
527 sta_priv = sta_to_rt2x00_sta(sta);
528 crypto.wcid = sta_priv->wcid;
529 } else
530 crypto.address = bcast_addr;
531
532 if (crypto.cipher == CIPHER_TKIP)
533 memcpy_tkip(&crypto, &key->key[0], key->keylen);
534 else
535 memcpy(crypto.key, &key->key[0], key->keylen);
536 /*
537 * Each BSS has a maximum of 4 shared keys.
538 * Shared key index values:
539 * 0) BSS0 key0
540 * 1) BSS0 key1
541 * ...
542 * 4) BSS1 key0
543 * ...
544 * 8) BSS2 key0
545 * ...
546 * Both pairwise as shared key indeces are determined by
547 * driver. This is required because the hardware requires
548 * keys to be assigned in correct order (When key 1 is
549 * provided but key 0 is not, then the key is not found
550 * by the hardware during RX).
551 */
552 if (cmd == SET_KEY)
553 key->hw_key_idx = 0;
554
555 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
556 set_key = rt2x00dev->ops->lib->config_pairwise_key;
557 else
558 set_key = rt2x00dev->ops->lib->config_shared_key;
559
560 if (!set_key)
561 return -EOPNOTSUPP;
562
563 return set_key(rt2x00dev, &crypto, key);
564 }
565 EXPORT_SYMBOL_GPL(rt2x00mac_set_key);
566 #endif /* CONFIG_RT2X00_LIB_CRYPTO */
567
rt2x00mac_sta_add(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta)568 int rt2x00mac_sta_add(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
569 struct ieee80211_sta *sta)
570 {
571 struct rt2x00_dev *rt2x00dev = hw->priv;
572 struct rt2x00_sta *sta_priv = sta_to_rt2x00_sta(sta);
573
574 /*
575 * If there's no space left in the device table store
576 * -1 as wcid but tell mac80211 everything went ok.
577 */
578 if (rt2x00dev->ops->lib->sta_add(rt2x00dev, vif, sta))
579 sta_priv->wcid = -1;
580
581 return 0;
582 }
583 EXPORT_SYMBOL_GPL(rt2x00mac_sta_add);
584
rt2x00mac_sta_remove(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta)585 int rt2x00mac_sta_remove(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
586 struct ieee80211_sta *sta)
587 {
588 struct rt2x00_dev *rt2x00dev = hw->priv;
589 struct rt2x00_sta *sta_priv = sta_to_rt2x00_sta(sta);
590
591 /*
592 * If we never sent the STA to the device no need to clean it up.
593 */
594 if (sta_priv->wcid < 0)
595 return 0;
596
597 return rt2x00dev->ops->lib->sta_remove(rt2x00dev, sta_priv->wcid);
598 }
599 EXPORT_SYMBOL_GPL(rt2x00mac_sta_remove);
600
rt2x00mac_sw_scan_start(struct ieee80211_hw * hw)601 void rt2x00mac_sw_scan_start(struct ieee80211_hw *hw)
602 {
603 struct rt2x00_dev *rt2x00dev = hw->priv;
604 set_bit(DEVICE_STATE_SCANNING, &rt2x00dev->flags);
605 rt2x00link_stop_tuner(rt2x00dev);
606 }
607 EXPORT_SYMBOL_GPL(rt2x00mac_sw_scan_start);
608
rt2x00mac_sw_scan_complete(struct ieee80211_hw * hw)609 void rt2x00mac_sw_scan_complete(struct ieee80211_hw *hw)
610 {
611 struct rt2x00_dev *rt2x00dev = hw->priv;
612 clear_bit(DEVICE_STATE_SCANNING, &rt2x00dev->flags);
613 rt2x00link_start_tuner(rt2x00dev);
614 }
615 EXPORT_SYMBOL_GPL(rt2x00mac_sw_scan_complete);
616
rt2x00mac_get_stats(struct ieee80211_hw * hw,struct ieee80211_low_level_stats * stats)617 int rt2x00mac_get_stats(struct ieee80211_hw *hw,
618 struct ieee80211_low_level_stats *stats)
619 {
620 struct rt2x00_dev *rt2x00dev = hw->priv;
621
622 /*
623 * The dot11ACKFailureCount, dot11RTSFailureCount and
624 * dot11RTSSuccessCount are updated in interrupt time.
625 * dot11FCSErrorCount is updated in the link tuner.
626 */
627 memcpy(stats, &rt2x00dev->low_level_stats, sizeof(*stats));
628
629 return 0;
630 }
631 EXPORT_SYMBOL_GPL(rt2x00mac_get_stats);
632
rt2x00mac_bss_info_changed(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_bss_conf * bss_conf,u32 changes)633 void rt2x00mac_bss_info_changed(struct ieee80211_hw *hw,
634 struct ieee80211_vif *vif,
635 struct ieee80211_bss_conf *bss_conf,
636 u32 changes)
637 {
638 struct rt2x00_dev *rt2x00dev = hw->priv;
639 struct rt2x00_intf *intf = vif_to_intf(vif);
640
641 /*
642 * mac80211 might be calling this function while we are trying
643 * to remove the device or perhaps suspending it.
644 */
645 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
646 return;
647
648 /*
649 * Update the BSSID.
650 */
651 if (changes & BSS_CHANGED_BSSID)
652 rt2x00lib_config_intf(rt2x00dev, intf, vif->type, NULL,
653 bss_conf->bssid);
654
655 /*
656 * Start/stop beaconing.
657 */
658 if (changes & BSS_CHANGED_BEACON_ENABLED) {
659 if (!bss_conf->enable_beacon && intf->enable_beacon) {
660 rt2x00dev->intf_beaconing--;
661 intf->enable_beacon = false;
662 /*
663 * Clear beacon in the H/W for this vif. This is needed
664 * to disable beaconing on this particular interface
665 * and keep it running on other interfaces.
666 */
667 rt2x00queue_clear_beacon(rt2x00dev, vif);
668
669 if (rt2x00dev->intf_beaconing == 0) {
670 /*
671 * Last beaconing interface disabled
672 * -> stop beacon queue.
673 */
674 mutex_lock(&intf->beacon_skb_mutex);
675 rt2x00queue_stop_queue(rt2x00dev->bcn);
676 mutex_unlock(&intf->beacon_skb_mutex);
677 }
678 } else if (bss_conf->enable_beacon && !intf->enable_beacon) {
679 rt2x00dev->intf_beaconing++;
680 intf->enable_beacon = true;
681 /*
682 * Upload beacon to the H/W. This is only required on
683 * USB devices. PCI devices fetch beacons periodically.
684 */
685 if (rt2x00_is_usb(rt2x00dev))
686 rt2x00queue_update_beacon(rt2x00dev, vif);
687
688 if (rt2x00dev->intf_beaconing == 1) {
689 /*
690 * First beaconing interface enabled
691 * -> start beacon queue.
692 */
693 mutex_lock(&intf->beacon_skb_mutex);
694 rt2x00queue_start_queue(rt2x00dev->bcn);
695 mutex_unlock(&intf->beacon_skb_mutex);
696 }
697 }
698 }
699
700 /*
701 * When the association status has changed we must reset the link
702 * tuner counter. This is because some drivers determine if they
703 * should perform link tuning based on the number of seconds
704 * while associated or not associated.
705 */
706 if (changes & BSS_CHANGED_ASSOC) {
707 rt2x00dev->link.count = 0;
708
709 if (bss_conf->assoc)
710 rt2x00dev->intf_associated++;
711 else
712 rt2x00dev->intf_associated--;
713
714 rt2x00leds_led_assoc(rt2x00dev, !!rt2x00dev->intf_associated);
715 }
716
717 /*
718 * When the erp information has changed, we should perform
719 * additional configuration steps. For all other changes we are done.
720 */
721 if (changes & (BSS_CHANGED_ERP_CTS_PROT | BSS_CHANGED_ERP_PREAMBLE |
722 BSS_CHANGED_ERP_SLOT | BSS_CHANGED_BASIC_RATES |
723 BSS_CHANGED_BEACON_INT | BSS_CHANGED_HT))
724 rt2x00lib_config_erp(rt2x00dev, intf, bss_conf, changes);
725 }
726 EXPORT_SYMBOL_GPL(rt2x00mac_bss_info_changed);
727
rt2x00mac_conf_tx(struct ieee80211_hw * hw,struct ieee80211_vif * vif,u16 queue_idx,const struct ieee80211_tx_queue_params * params)728 int rt2x00mac_conf_tx(struct ieee80211_hw *hw,
729 struct ieee80211_vif *vif, u16 queue_idx,
730 const struct ieee80211_tx_queue_params *params)
731 {
732 struct rt2x00_dev *rt2x00dev = hw->priv;
733 struct data_queue *queue;
734
735 queue = rt2x00queue_get_tx_queue(rt2x00dev, queue_idx);
736 if (unlikely(!queue))
737 return -EINVAL;
738
739 /*
740 * The passed variables are stored as real value ((2^n)-1).
741 * Ralink registers require to know the bit number 'n'.
742 */
743 if (params->cw_min > 0)
744 queue->cw_min = fls(params->cw_min);
745 else
746 queue->cw_min = 5; /* cw_min: 2^5 = 32. */
747
748 if (params->cw_max > 0)
749 queue->cw_max = fls(params->cw_max);
750 else
751 queue->cw_max = 10; /* cw_min: 2^10 = 1024. */
752
753 queue->aifs = params->aifs;
754 queue->txop = params->txop;
755
756 INFO(rt2x00dev,
757 "Configured TX queue %d - CWmin: %d, CWmax: %d, Aifs: %d, TXop: %d.\n",
758 queue_idx, queue->cw_min, queue->cw_max, queue->aifs, queue->txop);
759
760 return 0;
761 }
762 EXPORT_SYMBOL_GPL(rt2x00mac_conf_tx);
763
rt2x00mac_rfkill_poll(struct ieee80211_hw * hw)764 void rt2x00mac_rfkill_poll(struct ieee80211_hw *hw)
765 {
766 struct rt2x00_dev *rt2x00dev = hw->priv;
767 bool active = !!rt2x00dev->ops->lib->rfkill_poll(rt2x00dev);
768
769 wiphy_rfkill_set_hw_state(hw->wiphy, !active);
770 }
771 EXPORT_SYMBOL_GPL(rt2x00mac_rfkill_poll);
772
rt2x00mac_flush(struct ieee80211_hw * hw,bool drop)773 void rt2x00mac_flush(struct ieee80211_hw *hw, bool drop)
774 {
775 struct rt2x00_dev *rt2x00dev = hw->priv;
776 struct data_queue *queue;
777
778 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
779 return;
780
781 tx_queue_for_each(rt2x00dev, queue)
782 rt2x00queue_flush_queue(queue, drop);
783 }
784 EXPORT_SYMBOL_GPL(rt2x00mac_flush);
785
rt2x00mac_set_antenna(struct ieee80211_hw * hw,u32 tx_ant,u32 rx_ant)786 int rt2x00mac_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
787 {
788 struct rt2x00_dev *rt2x00dev = hw->priv;
789 struct link_ant *ant = &rt2x00dev->link.ant;
790 struct antenna_setup *def = &rt2x00dev->default_ant;
791 struct antenna_setup setup;
792
793 // The antenna value is not supposed to be 0,
794 // or exceed the maximum number of antenna's.
795 if (!tx_ant || (tx_ant & ~3) || !rx_ant || (rx_ant & ~3))
796 return -EINVAL;
797
798 // When the client tried to configure the antenna to or from
799 // diversity mode, we must reset the default antenna as well
800 // as that controls the diversity switch.
801 if (ant->flags & ANTENNA_TX_DIVERSITY && tx_ant != 3)
802 ant->flags &= ~ANTENNA_TX_DIVERSITY;
803 if (ant->flags & ANTENNA_RX_DIVERSITY && rx_ant != 3)
804 ant->flags &= ~ANTENNA_RX_DIVERSITY;
805
806 // If diversity is being enabled, check if we need hardware
807 // or software diversity. In the latter case, reset the value,
808 // and make sure we update the antenna flags to have the
809 // link tuner pick up the diversity tuning.
810 if (tx_ant == 3 && def->tx == ANTENNA_SW_DIVERSITY) {
811 tx_ant = ANTENNA_SW_DIVERSITY;
812 ant->flags |= ANTENNA_TX_DIVERSITY;
813 }
814
815 if (rx_ant == 3 && def->rx == ANTENNA_SW_DIVERSITY) {
816 rx_ant = ANTENNA_SW_DIVERSITY;
817 ant->flags |= ANTENNA_RX_DIVERSITY;
818 }
819
820 setup.tx = tx_ant;
821 setup.rx = rx_ant;
822
823 rt2x00lib_config_antenna(rt2x00dev, setup);
824
825 return 0;
826 }
827 EXPORT_SYMBOL_GPL(rt2x00mac_set_antenna);
828
rt2x00mac_get_antenna(struct ieee80211_hw * hw,u32 * tx_ant,u32 * rx_ant)829 int rt2x00mac_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
830 {
831 struct rt2x00_dev *rt2x00dev = hw->priv;
832 struct link_ant *ant = &rt2x00dev->link.ant;
833 struct antenna_setup *active = &rt2x00dev->link.ant.active;
834
835 // When software diversity is active, we must report this to the
836 // client and not the current active antenna state.
837 if (ant->flags & ANTENNA_TX_DIVERSITY)
838 *tx_ant = ANTENNA_HW_DIVERSITY;
839 else
840 *tx_ant = active->tx;
841
842 if (ant->flags & ANTENNA_RX_DIVERSITY)
843 *rx_ant = ANTENNA_HW_DIVERSITY;
844 else
845 *rx_ant = active->rx;
846
847 return 0;
848 }
849 EXPORT_SYMBOL_GPL(rt2x00mac_get_antenna);
850
rt2x00mac_get_ringparam(struct ieee80211_hw * hw,u32 * tx,u32 * tx_max,u32 * rx,u32 * rx_max)851 void rt2x00mac_get_ringparam(struct ieee80211_hw *hw,
852 u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max)
853 {
854 struct rt2x00_dev *rt2x00dev = hw->priv;
855 struct data_queue *queue;
856
857 tx_queue_for_each(rt2x00dev, queue) {
858 *tx += queue->length;
859 *tx_max += queue->limit;
860 }
861
862 *rx = rt2x00dev->rx->length;
863 *rx_max = rt2x00dev->rx->limit;
864 }
865 EXPORT_SYMBOL_GPL(rt2x00mac_get_ringparam);
866
rt2x00mac_tx_frames_pending(struct ieee80211_hw * hw)867 bool rt2x00mac_tx_frames_pending(struct ieee80211_hw *hw)
868 {
869 struct rt2x00_dev *rt2x00dev = hw->priv;
870 struct data_queue *queue;
871
872 tx_queue_for_each(rt2x00dev, queue) {
873 if (!rt2x00queue_empty(queue))
874 return true;
875 }
876
877 return false;
878 }
879 EXPORT_SYMBOL_GPL(rt2x00mac_tx_frames_pending);
880