blob: 8fcbc8dc94c174f5cdd56dc321cbb1f1ea01de3c [file] [log] [blame]
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001/*
Ivo van Doorn7e613e12010-08-06 20:45:38 +02002 Copyright (C) 2010 Willow Garage <http://www.willowgarage.com>
3 Copyright (C) 2004 - 2010 Ivo van Doorn <IvDoorn@gmail.com>
Ivo van Doorn95ea3622007-09-25 17:57:13 -07004 <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
Jeff Kirshera05b8c52013-12-06 03:32:11 -080017 along with this program; if not, see <http://www.gnu.org/licenses/>.
Ivo van Doorn95ea3622007-09-25 17:57:13 -070018 */
19
20/*
21 Module: rt2x00lib
22 Abstract: rt2x00 generic device routines.
23 */
24
Ivo van Doorn95ea3622007-09-25 17:57:13 -070025#include <linux/kernel.h>
26#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090027#include <linux/slab.h>
Helmut Schaaf78987c2011-03-28 13:30:36 +020028#include <linux/log2.h>
Mathias Kresin9766cb72016-08-26 09:16:53 +020029#include <linux/of.h>
30#include <linux/of_net.h>
Ivo van Doorn95ea3622007-09-25 17:57:13 -070031
32#include "rt2x00.h"
33#include "rt2x00lib.h"
34
35/*
Helmut Schaa18325522011-09-08 14:34:22 +020036 * Utility functions.
37 */
38u32 rt2x00lib_get_bssidx(struct rt2x00_dev *rt2x00dev,
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}
49EXPORT_SYMBOL_GPL(rt2x00lib_get_bssidx);
50
51/*
Ivo van Doorn95ea3622007-09-25 17:57:13 -070052 * Radio control handlers.
53 */
54int 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 */
Ivo van Doorn4b9631a2009-07-11 18:00:19 +020062 if (test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
Ivo van Doorn95ea3622007-09-25 17:57:13 -070063 return 0;
64
65 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -050066 * Initialize all data queues.
Ivo van Doorn837e7f22008-01-06 23:41:45 +010067 */
Ivo van Doorn798b7ad2008-11-08 15:25:33 +010068 rt2x00queue_init_queues(rt2x00dev);
Ivo van Doorn837e7f22008-01-06 23:41:45 +010069
70 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -070071 * Enable radio.
72 */
Ivo van Doorna2e1d522008-03-31 15:53:44 +020073 status =
74 rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_ON);
Ivo van Doorn95ea3622007-09-25 17:57:13 -070075 if (status)
76 return status;
77
Ivo van Doorn2b08da32008-06-03 18:58:56 +020078 rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_IRQ_ON);
79
Ivo van Doorna2e1d522008-03-31 15:53:44 +020080 rt2x00leds_led_radio(rt2x00dev, true);
Ivo van Doorn61c2b682008-04-21 19:01:09 +020081 rt2x00led_led_activity(rt2x00dev, true);
Ivo van Doorna2e1d522008-03-31 15:53:44 +020082
Ivo van Doorn0262ab02008-08-29 21:04:26 +020083 set_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags);
Ivo van Doorn95ea3622007-09-25 17:57:13 -070084
85 /*
Ivo van Doorn0b7fde52010-12-13 12:35:17 +010086 * Enable queues.
Ivo van Doorn95ea3622007-09-25 17:57:13 -070087 */
Ivo van Doorn0b7fde52010-12-13 12:35:17 +010088 rt2x00queue_start_queues(rt2x00dev);
Ivo van Doornea175ee2010-11-06 15:48:43 +010089 rt2x00link_start_tuner(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -070090
91 /*
Ivo van Doornc965c742010-07-11 12:25:46 +020092 * Start watchdog monitoring.
93 */
94 rt2x00link_start_watchdog(rt2x00dev);
95
Ivo van Doorn95ea3622007-09-25 17:57:13 -070096 return 0;
97}
98
99void rt2x00lib_disable_radio(struct rt2x00_dev *rt2x00dev)
100{
Ivo van Doorn0262ab02008-08-29 21:04:26 +0200101 if (!test_and_clear_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700102 return;
103
104 /*
Ivo van Doornc965c742010-07-11 12:25:46 +0200105 * Stop watchdog monitoring.
106 */
107 rt2x00link_stop_watchdog(rt2x00dev);
108
109 /*
Ivo van Doorn0b7fde52010-12-13 12:35:17 +0100110 * Stop all queues
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700111 */
Ivo van Doornea175ee2010-11-06 15:48:43 +0100112 rt2x00link_stop_tuner(rt2x00dev);
Ivo van Doorn0b7fde52010-12-13 12:35:17 +0100113 rt2x00queue_stop_queues(rt2x00dev);
Ivo van Doorn5be65602010-12-13 12:35:40 +0100114 rt2x00queue_flush_queues(rt2x00dev, true);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700115
116 /*
117 * Disable radio.
118 */
119 rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_OFF);
Ivo van Doorn2b08da32008-06-03 18:58:56 +0200120 rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_IRQ_OFF);
Ivo van Doorn61c2b682008-04-21 19:01:09 +0200121 rt2x00led_led_activity(rt2x00dev, false);
Ivo van Doorna2e1d522008-03-31 15:53:44 +0200122 rt2x00leds_led_radio(rt2x00dev, false);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700123}
124
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100125static void rt2x00lib_intf_scheduled_iter(void *data, u8 *mac,
126 struct ieee80211_vif *vif)
Ivo van Doorn5c58ee52007-10-06 13:34:52 +0200127{
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100128 struct rt2x00_dev *rt2x00dev = data;
129 struct rt2x00_intf *intf = vif_to_intf(vif);
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100130
Ivo van Doorn980dfcb2008-06-25 21:27:00 +0200131 /*
132 * It is possible the radio was disabled while the work had been
133 * scheduled. If that happens we should return here immediately,
134 * note that in the spinlock protected area above the delayed_flags
135 * have been cleared correctly.
136 */
Ivo van Doorn0262ab02008-08-29 21:04:26 +0200137 if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
Ivo van Doorn980dfcb2008-06-25 21:27:00 +0200138 return;
139
Stanislaw Gruszka283dafa2014-06-05 13:52:23 +0200140 if (test_and_clear_bit(DELAYED_UPDATE_BEACON, &intf->delayed_flags)) {
141 mutex_lock(&intf->beacon_skb_mutex);
Helmut Schaa69cf36a2011-01-30 13:16:03 +0100142 rt2x00queue_update_beacon(rt2x00dev, vif);
Stanislaw Gruszka283dafa2014-06-05 13:52:23 +0200143 mutex_unlock(&intf->beacon_skb_mutex);
144 }
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100145}
146
147static void rt2x00lib_intf_scheduled(struct work_struct *work)
148{
149 struct rt2x00_dev *rt2x00dev =
150 container_of(work, struct rt2x00_dev, intf_work);
151
152 /*
153 * Iterate over each interface and perform the
154 * requested configurations.
155 */
156 ieee80211_iterate_active_interfaces(rt2x00dev->hw,
Johannes Berg8b2c9822012-11-06 20:23:30 +0100157 IEEE80211_IFACE_ITER_RESUME_ALL,
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100158 rt2x00lib_intf_scheduled_iter,
159 rt2x00dev);
Ivo van Doorn5c58ee52007-10-06 13:34:52 +0200160}
161
Ivo van Doorn1c0bcf82011-04-30 17:18:18 +0200162static void rt2x00lib_autowakeup(struct work_struct *work)
163{
164 struct rt2x00_dev *rt2x00dev =
165 container_of(work, struct rt2x00_dev, autowakeup_work.work);
166
Stanislaw Gruszka3bb42a62011-06-04 16:48:54 +0200167 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
168 return;
169
Ivo van Doorn1c0bcf82011-04-30 17:18:18 +0200170 if (rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_AWAKE))
Joe Perchesec9c4982013-04-19 08:33:40 -0700171 rt2x00_err(rt2x00dev, "Device failed to wakeup\n");
Ivo van Doorn1c0bcf82011-04-30 17:18:18 +0200172 clear_bit(CONFIG_POWERSAVING, &rt2x00dev->flags);
173}
174
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700175/*
176 * Interrupt context handlers.
177 */
Helmut Schaa07896fe2010-07-11 12:27:58 +0200178static void rt2x00lib_bc_buffer_iter(void *data, u8 *mac,
179 struct ieee80211_vif *vif)
180{
Felix Fietkaub4089d62013-11-14 21:33:15 +0100181 struct ieee80211_tx_control control = {};
Helmut Schaa07896fe2010-07-11 12:27:58 +0200182 struct rt2x00_dev *rt2x00dev = data;
183 struct sk_buff *skb;
184
185 /*
186 * Only AP mode interfaces do broad- and multicast buffering
187 */
188 if (vif->type != NL80211_IFTYPE_AP)
189 return;
190
191 /*
192 * Send out buffered broad- and multicast frames
193 */
194 skb = ieee80211_get_buffered_bc(rt2x00dev->hw, vif);
195 while (skb) {
Felix Fietkaub4089d62013-11-14 21:33:15 +0100196 rt2x00mac_tx(rt2x00dev->hw, &control, skb);
Helmut Schaa07896fe2010-07-11 12:27:58 +0200197 skb = ieee80211_get_buffered_bc(rt2x00dev->hw, vif);
198 }
199}
200
Helmut Schaa9f926fb2010-07-11 12:28:23 +0200201static void rt2x00lib_beaconupdate_iter(void *data, u8 *mac,
202 struct ieee80211_vif *vif)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700203{
Helmut Schaa4dee32f2010-07-11 12:27:26 +0200204 struct rt2x00_dev *rt2x00dev = data;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700205
Johannes Berg05c914f2008-09-11 00:01:58 +0200206 if (vif->type != NL80211_IFTYPE_AP &&
Andrey Yurovskya07dbea2008-12-20 10:55:34 +0100207 vif->type != NL80211_IFTYPE_ADHOC &&
Ivo van Doornce292a62008-12-20 10:57:02 +0100208 vif->type != NL80211_IFTYPE_MESH_POINT &&
209 vif->type != NL80211_IFTYPE_WDS)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700210 return;
211
Helmut Schaa8d59c4e2011-01-30 13:17:29 +0100212 /*
213 * Update the beacon without locking. This is safe on PCI devices
214 * as they only update the beacon periodically here. This should
215 * never be called for USB devices.
216 */
217 WARN_ON(rt2x00_is_usb(rt2x00dev));
Stanislaw Gruszka283dafa2014-06-05 13:52:23 +0200218 rt2x00queue_update_beacon(rt2x00dev, vif);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700219}
220
221void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev)
222{
Ivo van Doorn0262ab02008-08-29 21:04:26 +0200223 if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700224 return;
225
Helmut Schaa07896fe2010-07-11 12:27:58 +0200226 /* send buffered bc/mc frames out for every bssid */
Johannes Berg8b2c9822012-11-06 20:23:30 +0100227 ieee80211_iterate_active_interfaces_atomic(
228 rt2x00dev->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
229 rt2x00lib_bc_buffer_iter, rt2x00dev);
Helmut Schaa9f926fb2010-07-11 12:28:23 +0200230 /*
231 * Devices with pre tbtt interrupt don't need to update the beacon
232 * here as they will fetch the next beacon directly prior to
233 * transmission.
234 */
Gabor Juhos7b8a00d2013-10-11 13:18:41 +0200235 if (rt2x00_has_cap_pre_tbtt_interrupt(rt2x00dev))
Helmut Schaa9f926fb2010-07-11 12:28:23 +0200236 return;
Helmut Schaa07896fe2010-07-11 12:27:58 +0200237
238 /* fetch next beacon */
Johannes Berg8b2c9822012-11-06 20:23:30 +0100239 ieee80211_iterate_active_interfaces_atomic(
240 rt2x00dev->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
241 rt2x00lib_beaconupdate_iter, rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700242}
243EXPORT_SYMBOL_GPL(rt2x00lib_beacondone);
244
Helmut Schaa9f926fb2010-07-11 12:28:23 +0200245void rt2x00lib_pretbtt(struct rt2x00_dev *rt2x00dev)
246{
247 if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
248 return;
249
250 /* fetch next beacon */
Johannes Berg8b2c9822012-11-06 20:23:30 +0100251 ieee80211_iterate_active_interfaces_atomic(
252 rt2x00dev->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
253 rt2x00lib_beaconupdate_iter, rt2x00dev);
Helmut Schaa9f926fb2010-07-11 12:28:23 +0200254}
255EXPORT_SYMBOL_GPL(rt2x00lib_pretbtt);
256
Ivo van Doorn64e7d722010-12-13 12:36:00 +0100257void rt2x00lib_dmastart(struct queue_entry *entry)
258{
259 set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
Johannes Stezenbach75256f02011-04-18 15:29:38 +0200260 rt2x00queue_index_inc(entry, Q_INDEX);
Ivo van Doorn64e7d722010-12-13 12:36:00 +0100261}
262EXPORT_SYMBOL_GPL(rt2x00lib_dmastart);
263
Ivo van Doorn652a9dd2010-08-30 21:15:19 +0200264void rt2x00lib_dmadone(struct queue_entry *entry)
265{
Ivo van Doorndba5dc12010-12-13 12:36:18 +0100266 set_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags);
Ivo van Doorna13c8f32010-10-11 15:39:48 +0200267 clear_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
Johannes Stezenbach75256f02011-04-18 15:29:38 +0200268 rt2x00queue_index_inc(entry, Q_INDEX_DMA_DONE);
Ivo van Doorn652a9dd2010-08-30 21:15:19 +0200269}
270EXPORT_SYMBOL_GPL(rt2x00lib_dmadone);
271
Helmut Schaa84e9e8ebd2013-01-17 17:34:32 +0100272static inline int rt2x00lib_txdone_bar_status(struct queue_entry *entry)
273{
274 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
275 struct ieee80211_bar *bar = (void *) entry->skb->data;
276 struct rt2x00_bar_list_entry *bar_entry;
277 int ret;
278
279 if (likely(!ieee80211_is_back_req(bar->frame_control)))
280 return 0;
281
282 /*
283 * Unlike all other frames, the status report for BARs does
284 * not directly come from the hardware as it is incapable of
285 * matching a BA to a previously send BAR. The hardware will
286 * report all BARs as if they weren't acked at all.
287 *
288 * Instead the RX-path will scan for incoming BAs and set the
289 * block_acked flag if it sees one that was likely caused by
290 * a BAR from us.
291 *
292 * Remove remaining BARs here and return their status for
293 * TX done processing.
294 */
295 ret = 0;
296 rcu_read_lock();
297 list_for_each_entry_rcu(bar_entry, &rt2x00dev->bar_list, list) {
298 if (bar_entry->entry != entry)
299 continue;
300
301 spin_lock_bh(&rt2x00dev->bar_list_lock);
302 /* Return whether this BAR was blockacked or not */
303 ret = bar_entry->block_acked;
304 /* Remove the BAR from our checklist */
305 list_del_rcu(&bar_entry->list);
306 spin_unlock_bh(&rt2x00dev->bar_list_lock);
307 kfree_rcu(bar_entry, head);
308
309 break;
310 }
311 rcu_read_unlock();
312
313 return ret;
314}
315
Ivo van Doorn181d6902008-02-05 16:42:23 -0500316void rt2x00lib_txdone(struct queue_entry *entry,
317 struct txdone_entry_desc *txdesc)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700318{
Ivo van Doorn181d6902008-02-05 16:42:23 -0500319 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
Johannes Berge039fa42008-05-15 12:55:29 +0200320 struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(entry->skb);
Johannes Berge6a98542008-10-21 12:40:02 +0200321 struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb);
RA-Jay Hungf8eaec62010-11-13 19:12:54 +0100322 unsigned int header_length, i;
Benoit PAPILLAULT92ed48e2009-08-17 18:56:10 +0200323 u8 rate_idx, rate_flags, retry_rates;
Johannes Berg7351c6b2009-11-19 01:08:30 +0100324 u8 skbdesc_flags = skbdesc->flags;
Ivo van Doorn2e27cff2009-08-29 19:10:14 +0200325 bool success;
Ivo van Doornd74f5ba2008-06-16 19:56:54 +0200326
327 /*
Gertjan van Wingerdee513a0b2010-06-29 21:41:40 +0200328 * Unmap the skb.
329 */
Ivo van Doornfa695602010-10-11 15:37:25 +0200330 rt2x00queue_unmap_skb(entry);
Gertjan van Wingerdee513a0b2010-06-29 21:41:40 +0200331
332 /*
333 * Remove the extra tx headroom from the skb.
334 */
Gabor Juhos5616a6e2013-06-06 09:36:19 +0200335 skb_pull(entry->skb, rt2x00dev->extra_tx_headroom);
Gertjan van Wingerdee513a0b2010-06-29 21:41:40 +0200336
337 /*
338 * Signal that the TX descriptor is no longer in the skb.
339 */
340 skbdesc->flags &= ~SKBDESC_DESC_IN_SKB;
341
342 /*
RA-Jay Hungf8eaec62010-11-13 19:12:54 +0100343 * Determine the length of 802.11 header.
344 */
345 header_length = ieee80211_get_hdrlen_from_skb(entry->skb);
346
347 /*
Ivo van Doorn9f166172009-04-26 16:08:50 +0200348 * Remove L2 padding which was added during
349 */
Fred Choub9d305c2014-12-26 16:19:18 +0800350 if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_L2PAD))
Ivo van Doorndaee6c02009-08-29 20:30:45 +0200351 rt2x00queue_remove_l2pad(entry->skb, header_length);
Ivo van Doorn9f166172009-04-26 16:08:50 +0200352
353 /*
Ivo van Doorn2bb057d2008-08-04 16:37:44 +0200354 * If the IV/EIV data was stripped from the frame before it was
355 * passed to the hardware, we should now reinsert it again because
Walter Goldens77c20612010-05-18 04:44:54 -0700356 * mac80211 will expect the same data to be present it the
Ivo van Doorn2bb057d2008-08-04 16:37:44 +0200357 * frame as it was passed to us.
358 */
Gabor Juhos7b8a00d2013-10-11 13:18:41 +0200359 if (rt2x00_has_cap_hw_crypto(rt2x00dev))
Ivo van Doorn9f166172009-04-26 16:08:50 +0200360 rt2x00crypto_tx_insert_iv(entry->skb, header_length);
Ivo van Doorn2bb057d2008-08-04 16:37:44 +0200361
362 /*
Johannes Berge039fa42008-05-15 12:55:29 +0200363 * Send frame to debugfs immediately, after this call is completed
364 * we are going to overwrite the skb->cb array.
365 */
366 rt2x00debug_dump_frame(rt2x00dev, DUMP_FRAME_TXDONE, entry->skb);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700367
368 /*
Helmut Schaa84e9e8ebd2013-01-17 17:34:32 +0100369 * Determine if the frame has been successfully transmitted and
370 * remove BARs from our check list while checking for their
371 * TX status.
Ivo van Doorn2e27cff2009-08-29 19:10:14 +0200372 */
373 success =
Helmut Schaa84e9e8ebd2013-01-17 17:34:32 +0100374 rt2x00lib_txdone_bar_status(entry) ||
Ivo van Doorn2e27cff2009-08-29 19:10:14 +0200375 test_bit(TXDONE_SUCCESS, &txdesc->flags) ||
Helmut Schaafd6dcb82010-06-14 22:09:09 +0200376 test_bit(TXDONE_UNKNOWN, &txdesc->flags);
Ivo van Doorn2e27cff2009-08-29 19:10:14 +0200377
378 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700379 * Update TX statistics.
380 */
Ivo van Doorn2e27cff2009-08-29 19:10:14 +0200381 rt2x00dev->link.qual.tx_success += success;
382 rt2x00dev->link.qual.tx_failed += !success;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700383
Johannes Berge6a98542008-10-21 12:40:02 +0200384 rate_idx = skbdesc->tx_rate_idx;
385 rate_flags = skbdesc->tx_rate_flags;
Benoit PAPILLAULT92ed48e2009-08-17 18:56:10 +0200386 retry_rates = test_bit(TXDONE_FALLBACK, &txdesc->flags) ?
387 (txdesc->retry + 1) : 1;
Johannes Berge6a98542008-10-21 12:40:02 +0200388
Ivo van Doorn181d6902008-02-05 16:42:23 -0500389 /*
390 * Initialize TX status
391 */
Johannes Berge039fa42008-05-15 12:55:29 +0200392 memset(&tx_info->status, 0, sizeof(tx_info->status));
393 tx_info->status.ack_signal = 0;
Benoit PAPILLAULT92ed48e2009-08-17 18:56:10 +0200394
395 /*
396 * Frame was send with retries, hardware tried
397 * different rates to send out the frame, at each
Helmut Schaa3d2bc102010-06-14 22:12:26 +0200398 * retry it lowered the rate 1 step except when the
399 * lowest rate was used.
Benoit PAPILLAULT92ed48e2009-08-17 18:56:10 +0200400 */
401 for (i = 0; i < retry_rates && i < IEEE80211_TX_MAX_RATES; i++) {
402 tx_info->status.rates[i].idx = rate_idx - i;
403 tx_info->status.rates[i].flags = rate_flags;
Helmut Schaa3d2bc102010-06-14 22:12:26 +0200404
405 if (rate_idx - i == 0) {
406 /*
407 * The lowest rate (index 0) was used until the
408 * number of max retries was reached.
409 */
410 tx_info->status.rates[i].count = retry_rates - i;
411 i++;
412 break;
413 }
Benoit PAPILLAULT92ed48e2009-08-17 18:56:10 +0200414 tx_info->status.rates[i].count = 1;
415 }
Ivo van Doorn2e27cff2009-08-29 19:10:14 +0200416 if (i < (IEEE80211_TX_MAX_RATES - 1))
Benoit PAPILLAULT92ed48e2009-08-17 18:56:10 +0200417 tx_info->status.rates[i].idx = -1; /* terminate */
Ivo van Doorn181d6902008-02-05 16:42:23 -0500418
Johannes Berge039fa42008-05-15 12:55:29 +0200419 if (!(tx_info->flags & IEEE80211_TX_CTL_NO_ACK)) {
Ivo van Doorn2e27cff2009-08-29 19:10:14 +0200420 if (success)
Johannes Berge039fa42008-05-15 12:55:29 +0200421 tx_info->flags |= IEEE80211_TX_STAT_ACK;
Ivo van Doorn2e27cff2009-08-29 19:10:14 +0200422 else
Ivo van Doorn181d6902008-02-05 16:42:23 -0500423 rt2x00dev->low_level_stats.dot11ACKFailureCount++;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700424 }
425
Helmut Schaa1df90802010-06-29 21:38:12 +0200426 /*
427 * Every single frame has it's own tx status, hence report
428 * every frame as ampdu of size 1.
429 *
430 * TODO: if we can find out how many frames were aggregated
431 * by the hw we could provide the real ampdu_len to mac80211
432 * which would allow the rc algorithm to better decide on
433 * which rates are suitable.
434 */
Helmut Schaaf16d2db2011-03-28 13:35:21 +0200435 if (test_bit(TXDONE_AMPDU, &txdesc->flags) ||
436 tx_info->flags & IEEE80211_TX_CTL_AMPDU) {
Helmut Schaa1df90802010-06-29 21:38:12 +0200437 tx_info->flags |= IEEE80211_TX_STAT_AMPDU;
438 tx_info->status.ampdu_len = 1;
439 tx_info->status.ampdu_ack_len = success ? 1 : 0;
Stanislaw Gruszkaab9d6e42012-12-03 12:59:04 +0100440
441 if (!success)
442 tx_info->flags |= IEEE80211_TX_STAT_AMPDU_NO_BACK;
Helmut Schaa1df90802010-06-29 21:38:12 +0200443 }
444
Johannes Berge6a98542008-10-21 12:40:02 +0200445 if (rate_flags & IEEE80211_TX_RC_USE_RTS_CTS) {
Ivo van Doorn2e27cff2009-08-29 19:10:14 +0200446 if (success)
Ivo van Doorn181d6902008-02-05 16:42:23 -0500447 rt2x00dev->low_level_stats.dot11RTSSuccessCount++;
Ivo van Doorn2e27cff2009-08-29 19:10:14 +0200448 else
Ivo van Doorn181d6902008-02-05 16:42:23 -0500449 rt2x00dev->low_level_stats.dot11RTSFailureCount++;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700450 }
451
452 /*
Johannes Berg7351c6b2009-11-19 01:08:30 +0100453 * Only send the status report to mac80211 when it's a frame
454 * that originated in mac80211. If this was a extra frame coming
455 * through a mac80211 library call (RTS/CTS) then we should not
456 * send the status report back.
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700457 */
Johannes Stezenbach20ed3162010-11-30 16:49:23 +0100458 if (!(skbdesc_flags & SKBDESC_NOT_MAC80211)) {
Fred Choub9d305c2014-12-26 16:19:18 +0800459 if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_TASKLET_CONTEXT))
Johannes Stezenbach20ed3162010-11-30 16:49:23 +0100460 ieee80211_tx_status(rt2x00dev->hw, entry->skb);
461 else
462 ieee80211_tx_status_ni(rt2x00dev->hw, entry->skb);
463 } else
Helmut Schaa78e256c2010-07-11 12:26:48 +0200464 dev_kfree_skb_any(entry->skb);
Ivo van Doornd74f5ba2008-06-16 19:56:54 +0200465
466 /*
467 * Make this entry available for reuse.
468 */
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700469 entry->skb = NULL;
Ivo van Doornd74f5ba2008-06-16 19:56:54 +0200470 entry->flags = 0;
471
Ivo van Doorn798b7ad2008-11-08 15:25:33 +0100472 rt2x00dev->ops->lib->clear_entry(entry);
Ivo van Doornd74f5ba2008-06-16 19:56:54 +0200473
Johannes Stezenbach75256f02011-04-18 15:29:38 +0200474 rt2x00queue_index_inc(entry, Q_INDEX_DONE);
Ivo van Doornd74f5ba2008-06-16 19:56:54 +0200475
476 /*
477 * If the data queue was below the threshold before the txdone
478 * handler we must make sure the packet queue in the mac80211 stack
Stanislaw Gruszka3780d032012-03-09 12:39:54 +0100479 * is reenabled when the txdone handler has finished. This has to be
480 * serialized with rt2x00mac_tx(), otherwise we can wake up queue
481 * before it was stopped.
Ivo van Doornd74f5ba2008-06-16 19:56:54 +0200482 */
Stanislaw Gruszka3780d032012-03-09 12:39:54 +0100483 spin_lock_bh(&entry->queue->tx_lock);
Ivo van Doornd74f5ba2008-06-16 19:56:54 +0200484 if (!rt2x00queue_threshold(entry->queue))
Ivo van Doorn0b7fde52010-12-13 12:35:17 +0100485 rt2x00queue_unpause_queue(entry->queue);
Stanislaw Gruszka3780d032012-03-09 12:39:54 +0100486 spin_unlock_bh(&entry->queue->tx_lock);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700487}
488EXPORT_SYMBOL_GPL(rt2x00lib_txdone);
489
Ivo van Doorn3392bec2010-08-06 20:46:53 +0200490void rt2x00lib_txdone_noinfo(struct queue_entry *entry, u32 status)
491{
492 struct txdone_entry_desc txdesc;
493
494 txdesc.flags = 0;
495 __set_bit(status, &txdesc.flags);
496 txdesc.retry = 0;
497
498 rt2x00lib_txdone(entry, &txdesc);
499}
500EXPORT_SYMBOL_GPL(rt2x00lib_txdone_noinfo);
501
Ivo van Doorn1c0bcf82011-04-30 17:18:18 +0200502static u8 *rt2x00lib_find_ie(u8 *data, unsigned int len, u8 ie)
503{
504 struct ieee80211_mgmt *mgmt = (void *)data;
505 u8 *pos, *end;
506
507 pos = (u8 *)mgmt->u.beacon.variable;
508 end = data + len;
509 while (pos < end) {
510 if (pos + 2 + pos[1] > end)
511 return NULL;
512
513 if (pos[0] == ie)
514 return pos;
515
516 pos += 2 + pos[1];
517 }
518
519 return NULL;
520}
521
Gertjan van Wingerdeed66ba42011-11-12 19:10:44 +0100522static void rt2x00lib_sleep(struct work_struct *work)
523{
524 struct rt2x00_dev *rt2x00dev =
525 container_of(work, struct rt2x00_dev, sleep_work);
526
527 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
528 return;
529
530 /*
531 * Check again is powersaving is enabled, to prevent races from delayed
532 * work execution.
533 */
534 if (!test_bit(CONFIG_POWERSAVING, &rt2x00dev->flags))
535 rt2x00lib_config(rt2x00dev, &rt2x00dev->hw->conf,
536 IEEE80211_CONF_CHANGE_PS);
537}
538
Helmut Schaa84e9e8ebd2013-01-17 17:34:32 +0100539static void rt2x00lib_rxdone_check_ba(struct rt2x00_dev *rt2x00dev,
540 struct sk_buff *skb,
541 struct rxdone_entry_desc *rxdesc)
542{
543 struct rt2x00_bar_list_entry *entry;
544 struct ieee80211_bar *ba = (void *)skb->data;
545
546 if (likely(!ieee80211_is_back(ba->frame_control)))
547 return;
548
549 if (rxdesc->size < sizeof(*ba) + FCS_LEN)
550 return;
551
552 rcu_read_lock();
553 list_for_each_entry_rcu(entry, &rt2x00dev->bar_list, list) {
554
555 if (ba->start_seq_num != entry->start_seq_num)
556 continue;
557
558#define TID_CHECK(a, b) ( \
559 ((a) & cpu_to_le16(IEEE80211_BAR_CTRL_TID_INFO_MASK)) == \
560 ((b) & cpu_to_le16(IEEE80211_BAR_CTRL_TID_INFO_MASK))) \
561
562 if (!TID_CHECK(ba->control, entry->control))
563 continue;
564
565#undef TID_CHECK
566
Julia Lawallf012f752013-12-30 19:14:57 +0100567 if (!ether_addr_equal_64bits(ba->ra, entry->ta))
Helmut Schaa84e9e8ebd2013-01-17 17:34:32 +0100568 continue;
569
Julia Lawallf012f752013-12-30 19:14:57 +0100570 if (!ether_addr_equal_64bits(ba->ta, entry->ra))
Helmut Schaa84e9e8ebd2013-01-17 17:34:32 +0100571 continue;
572
573 /* Mark BAR since we received the according BA */
574 spin_lock_bh(&rt2x00dev->bar_list_lock);
575 entry->block_acked = 1;
576 spin_unlock_bh(&rt2x00dev->bar_list_lock);
577 break;
578 }
579 rcu_read_unlock();
580
581}
582
Ivo van Doorn1c0bcf82011-04-30 17:18:18 +0200583static void rt2x00lib_rxdone_check_ps(struct rt2x00_dev *rt2x00dev,
584 struct sk_buff *skb,
585 struct rxdone_entry_desc *rxdesc)
586{
587 struct ieee80211_hdr *hdr = (void *) skb->data;
588 struct ieee80211_tim_ie *tim_ie;
589 u8 *tim;
590 u8 tim_len;
591 bool cam;
592
593 /* If this is not a beacon, or if mac80211 has no powersaving
594 * configured, or if the device is already in powersaving mode
595 * we can exit now. */
596 if (likely(!ieee80211_is_beacon(hdr->frame_control) ||
597 !(rt2x00dev->hw->conf.flags & IEEE80211_CONF_PS)))
598 return;
599
600 /* min. beacon length + FCS_LEN */
601 if (skb->len <= 40 + FCS_LEN)
602 return;
603
604 /* and only beacons from the associated BSSID, please */
605 if (!(rxdesc->dev_flags & RXDONE_MY_BSS) ||
606 !rt2x00dev->aid)
607 return;
608
609 rt2x00dev->last_beacon = jiffies;
610
611 tim = rt2x00lib_find_ie(skb->data, skb->len - FCS_LEN, WLAN_EID_TIM);
612 if (!tim)
613 return;
614
615 if (tim[1] < sizeof(*tim_ie))
616 return;
617
618 tim_len = tim[1];
619 tim_ie = (struct ieee80211_tim_ie *) &tim[2];
620
621 /* Check whenever the PHY can be turned off again. */
622
623 /* 1. What about buffered unicast traffic for our AID? */
624 cam = ieee80211_check_tim(tim_ie, tim_len, rt2x00dev->aid);
625
626 /* 2. Maybe the AP wants to send multicast/broadcast data? */
627 cam |= (tim_ie->bitmap_ctrl & 0x01);
628
629 if (!cam && !test_bit(CONFIG_POWERSAVING, &rt2x00dev->flags))
Gertjan van Wingerdeed66ba42011-11-12 19:10:44 +0100630 queue_work(rt2x00dev->workqueue, &rt2x00dev->sleep_work);
Ivo van Doorn1c0bcf82011-04-30 17:18:18 +0200631}
632
Ivo van Doorn35f00cf2009-04-26 16:09:32 +0200633static int rt2x00lib_rxdone_read_signal(struct rt2x00_dev *rt2x00dev,
634 struct rxdone_entry_desc *rxdesc)
635{
636 struct ieee80211_supported_band *sband;
637 const struct rt2x00_rate *rate;
638 unsigned int i;
Ivo van Doorn3590eea2010-10-11 15:38:07 +0200639 int signal = rxdesc->signal;
640 int type = (rxdesc->dev_flags & RXDONE_SIGNAL_MASK);
Ivo van Doorn35f00cf2009-04-26 16:09:32 +0200641
Ivo van Doorn3590eea2010-10-11 15:38:07 +0200642 switch (rxdesc->rate_mode) {
643 case RATE_MODE_CCK:
644 case RATE_MODE_OFDM:
645 /*
646 * For non-HT rates the MCS value needs to contain the
647 * actually used rate modulation (CCK or OFDM).
648 */
649 if (rxdesc->dev_flags & RXDONE_SIGNAL_MCS)
650 signal = RATE_MCS(rxdesc->rate_mode, signal);
Ivo van Doorn35f00cf2009-04-26 16:09:32 +0200651
Ivo van Doorn3590eea2010-10-11 15:38:07 +0200652 sband = &rt2x00dev->bands[rt2x00dev->curr_band];
653 for (i = 0; i < sband->n_bitrates; i++) {
654 rate = rt2x00_get_rate(sband->bitrates[i].hw_value);
655 if (((type == RXDONE_SIGNAL_PLCP) &&
656 (rate->plcp == signal)) ||
657 ((type == RXDONE_SIGNAL_BITRATE) &&
658 (rate->bitrate == signal)) ||
659 ((type == RXDONE_SIGNAL_MCS) &&
660 (rate->mcs == signal))) {
661 return i;
662 }
Ivo van Doorn35f00cf2009-04-26 16:09:32 +0200663 }
Ivo van Doorn3590eea2010-10-11 15:38:07 +0200664 break;
665 case RATE_MODE_HT_MIX:
666 case RATE_MODE_HT_GREENFIELD:
667 if (signal >= 0 && signal <= 76)
668 return signal;
669 break;
670 default:
671 break;
Ivo van Doorn35f00cf2009-04-26 16:09:32 +0200672 }
673
Joe Perchesec9c4982013-04-19 08:33:40 -0700674 rt2x00_warn(rt2x00dev, "Frame received with unrecognized signal, mode=0x%.4x, signal=0x%.4x, type=%d\n",
675 rxdesc->rate_mode, signal, type);
Ivo van Doorn35f00cf2009-04-26 16:09:32 +0200676 return 0;
677}
678
Helmut Schaa88211022012-04-19 13:24:10 +0200679void rt2x00lib_rxdone(struct queue_entry *entry, gfp_t gfp)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700680{
Ivo van Doornfa695602010-10-11 15:37:25 +0200681 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
Gertjan van Wingerdec4da0042008-06-16 19:56:31 +0200682 struct rxdone_entry_desc rxdesc;
683 struct sk_buff *skb;
Ivo van Doorne5ef5ba2010-08-06 20:49:27 +0200684 struct ieee80211_rx_status *rx_status;
Ivo van Doorn2bb057d2008-08-04 16:37:44 +0200685 unsigned int header_length;
Ivo van Doorn35f00cf2009-04-26 16:09:32 +0200686 int rate_idx;
Ivo van Doorn7e613e12010-08-06 20:45:38 +0200687
Ivo van Doorn070192d2010-11-04 20:41:05 +0100688 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) ||
689 !test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
690 goto submit_entry;
691
Ivo van Doorn7e613e12010-08-06 20:45:38 +0200692 if (test_bit(ENTRY_DATA_IO_FAILED, &entry->flags))
693 goto submit_entry;
694
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700695 /*
Gertjan van Wingerdec4da0042008-06-16 19:56:31 +0200696 * Allocate a new sk_buffer. If no new buffer available, drop the
697 * received frame and reuse the existing buffer.
698 */
Helmut Schaa88211022012-04-19 13:24:10 +0200699 skb = rt2x00queue_alloc_rxskb(entry, gfp);
Gertjan van Wingerdec4da0042008-06-16 19:56:31 +0200700 if (!skb)
Ivo van Doorn1550c8e2010-10-11 15:38:26 +0200701 goto submit_entry;
Gertjan van Wingerdec4da0042008-06-16 19:56:31 +0200702
703 /*
704 * Unmap the skb.
705 */
Ivo van Doornfa695602010-10-11 15:37:25 +0200706 rt2x00queue_unmap_skb(entry);
Gertjan van Wingerdec4da0042008-06-16 19:56:31 +0200707
708 /*
709 * Extract the RXD details.
710 */
711 memset(&rxdesc, 0, sizeof(rxdesc));
712 rt2x00dev->ops->lib->fill_rxdone(entry, &rxdesc);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700713
714 /*
Stanislaw Gruszka7f503fc2011-06-19 19:46:02 +0200715 * Check for valid size in case we get corrupted descriptor from
716 * hardware.
717 */
718 if (unlikely(rxdesc.size == 0 ||
719 rxdesc.size > entry->queue->data_size)) {
Joe Perchesec9c4982013-04-19 08:33:40 -0700720 rt2x00_err(rt2x00dev, "Wrong frame size %d max %d\n",
721 rxdesc.size, entry->queue->data_size);
Stanislaw Gruszka7f503fc2011-06-19 19:46:02 +0200722 dev_kfree_skb(entry->skb);
723 goto renew_skb;
724 }
725
726 /*
Gertjan van Wingerde239c2492008-06-06 22:54:12 +0200727 * The data behind the ieee80211 header must be
Gertjan van Wingerdea9f853d2008-06-07 16:57:09 +0200728 * aligned on a 4 byte boundary.
Gertjan van Wingerde239c2492008-06-06 22:54:12 +0200729 */
Ivo van Doorn2bb057d2008-08-04 16:37:44 +0200730 header_length = ieee80211_get_hdrlen_from_skb(entry->skb);
Gertjan van Wingerde239c2492008-06-06 22:54:12 +0200731
Ivo van Doorn2bb057d2008-08-04 16:37:44 +0200732 /*
733 * Hardware might have stripped the IV/EIV/ICV data,
734 * in that case it is possible that the data was
Daniel Mack3ad2f3f2010-02-03 08:01:28 +0800735 * provided separately (through hardware descriptor)
Ivo van Doorn2bb057d2008-08-04 16:37:44 +0200736 * in which case we should reinsert the data into the frame.
737 */
Ivo van Doorn74415ed2008-12-02 22:50:33 +0100738 if ((rxdesc.dev_flags & RXDONE_CRYPTO_IV) &&
Ivo van Doorn9f166172009-04-26 16:08:50 +0200739 (rxdesc.flags & RX_FLAG_IV_STRIPPED))
Ivo van Doorndaee6c02009-08-29 20:30:45 +0200740 rt2x00crypto_rx_insert_iv(entry->skb, header_length,
Ivo van Doorn9f166172009-04-26 16:08:50 +0200741 &rxdesc);
Gertjan van Wingerdeb7340832009-12-04 23:47:04 +0100742 else if (header_length &&
743 (rxdesc.size > header_length) &&
744 (rxdesc.dev_flags & RXDONE_L2PAD))
Ivo van Doorndaee6c02009-08-29 20:30:45 +0200745 rt2x00queue_remove_l2pad(entry->skb, header_length);
Gertjan van Wingerde239c2492008-06-06 22:54:12 +0200746
Alban Browaeys1398d452009-12-04 23:47:00 +0100747 /* Trim buffer to correct size */
748 skb_trim(entry->skb, rxdesc.size);
749
Gertjan van Wingerde239c2492008-06-06 22:54:12 +0200750 /*
Ivo van Doorn3590eea2010-10-11 15:38:07 +0200751 * Translate the signal to the correct bitrate index.
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700752 */
Ivo van Doorn3590eea2010-10-11 15:38:07 +0200753 rate_idx = rt2x00lib_rxdone_read_signal(rt2x00dev, &rxdesc);
754 if (rxdesc.rate_mode == RATE_MODE_HT_MIX ||
755 rxdesc.rate_mode == RATE_MODE_HT_GREENFIELD)
Ivo van Doorn35f00cf2009-04-26 16:09:32 +0200756 rxdesc.flags |= RX_FLAG_HT;
Ivo van Doorn866a0502008-03-25 14:12:45 +0100757
Mattias Nissler61af43c2007-11-27 21:50:26 +0100758 /*
Ivo van Doorn1c0bcf82011-04-30 17:18:18 +0200759 * Check if this is a beacon, and more frames have been
760 * buffered while we were in powersaving mode.
761 */
762 rt2x00lib_rxdone_check_ps(rt2x00dev, entry->skb, &rxdesc);
763
764 /*
Helmut Schaa84e9e8ebd2013-01-17 17:34:32 +0100765 * Check for incoming BlockAcks to match to the BlockAckReqs
766 * we've send out.
767 */
768 rt2x00lib_rxdone_check_ba(rt2x00dev, entry->skb, &rxdesc);
769
770 /*
Ivo van Doorn84e31962008-12-20 10:53:29 +0100771 * Update extra components
Mattias Nissler61af43c2007-11-27 21:50:26 +0100772 */
Ivo van Doorn84e31962008-12-20 10:53:29 +0100773 rt2x00link_update_stats(rt2x00dev, entry->skb, &rxdesc);
774 rt2x00debug_update_crypto(rt2x00dev, &rxdesc);
Ivo van Doorne5ef5ba2010-08-06 20:49:27 +0200775 rt2x00debug_dump_frame(rt2x00dev, DUMP_FRAME_RXDONE, entry->skb);
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200776
Ivo van Doorne5ef5ba2010-08-06 20:49:27 +0200777 /*
778 * Initialize RX status information, and send frame
779 * to mac80211.
780 */
781 rx_status = IEEE80211_SKB_RXCB(entry->skb);
Gabor Juhos028014c2012-12-11 18:27:34 +0100782
783 /* Ensure that all fields of rx_status are initialized
784 * properly. The skb->cb array was used for driver
785 * specific informations, so rx_status might contain
786 * garbage.
787 */
788 memset(rx_status, 0, sizeof(*rx_status));
789
Ivo van Doornae73e582008-07-04 16:14:59 +0200790 rx_status->mactime = rxdesc.timestamp;
Ivo van Doorne5ef5ba2010-08-06 20:49:27 +0200791 rx_status->band = rt2x00dev->curr_band;
792 rx_status->freq = rt2x00dev->curr_freq;
Ivo van Doorn35f00cf2009-04-26 16:09:32 +0200793 rx_status->rate_idx = rate_idx;
Gertjan van Wingerdec4da0042008-06-16 19:56:31 +0200794 rx_status->signal = rxdesc.rssi;
795 rx_status->flag = rxdesc.flags;
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200796 rx_status->antenna = rt2x00dev->link.ant.active.rx;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700797
Ivo van Doorn7e613e12010-08-06 20:45:38 +0200798 ieee80211_rx_ni(rt2x00dev->hw, entry->skb);
Gertjan van Wingerdec4da0042008-06-16 19:56:31 +0200799
Stanislaw Gruszka7f503fc2011-06-19 19:46:02 +0200800renew_skb:
Gertjan van Wingerdec4da0042008-06-16 19:56:31 +0200801 /*
802 * Replace the skb with the freshly allocated one.
803 */
804 entry->skb = skb;
Ivo van Doornd74f5ba2008-06-16 19:56:54 +0200805
Ivo van Doorn7e613e12010-08-06 20:45:38 +0200806submit_entry:
Ivo van Doorn070192d2010-11-04 20:41:05 +0100807 entry->flags = 0;
Johannes Stezenbach75256f02011-04-18 15:29:38 +0200808 rt2x00queue_index_inc(entry, Q_INDEX_DONE);
Ivo van Doorn070192d2010-11-04 20:41:05 +0100809 if (test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) &&
Ivo van Doorn64e7d722010-12-13 12:36:00 +0100810 test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
Ivo van Doorn070192d2010-11-04 20:41:05 +0100811 rt2x00dev->ops->lib->clear_entry(entry);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700812}
813EXPORT_SYMBOL_GPL(rt2x00lib_rxdone);
814
815/*
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700816 * Driver initialization handlers.
817 */
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100818const struct rt2x00_rate rt2x00_supported_rates[12] = {
819 {
Ivo van Doorn3d8606a2008-11-02 00:36:40 +0100820 .flags = DEV_RATE_CCK,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100821 .bitrate = 10,
Ivo van Doornaa776722008-03-09 22:48:08 +0100822 .ratemask = BIT(0),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100823 .plcp = 0x00,
Ivo van Doorn35f00cf2009-04-26 16:09:32 +0200824 .mcs = RATE_MCS(RATE_MODE_CCK, 0),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100825 },
826 {
Ivo van Doorn3d8606a2008-11-02 00:36:40 +0100827 .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100828 .bitrate = 20,
Ivo van Doornaa776722008-03-09 22:48:08 +0100829 .ratemask = BIT(1),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100830 .plcp = 0x01,
Ivo van Doorn35f00cf2009-04-26 16:09:32 +0200831 .mcs = RATE_MCS(RATE_MODE_CCK, 1),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100832 },
833 {
Ivo van Doorn3d8606a2008-11-02 00:36:40 +0100834 .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100835 .bitrate = 55,
Ivo van Doornaa776722008-03-09 22:48:08 +0100836 .ratemask = BIT(2),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100837 .plcp = 0x02,
Ivo van Doorn35f00cf2009-04-26 16:09:32 +0200838 .mcs = RATE_MCS(RATE_MODE_CCK, 2),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100839 },
840 {
Ivo van Doorn3d8606a2008-11-02 00:36:40 +0100841 .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100842 .bitrate = 110,
Ivo van Doornaa776722008-03-09 22:48:08 +0100843 .ratemask = BIT(3),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100844 .plcp = 0x03,
Ivo van Doorn35f00cf2009-04-26 16:09:32 +0200845 .mcs = RATE_MCS(RATE_MODE_CCK, 3),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100846 },
847 {
Ivo van Doorn3d8606a2008-11-02 00:36:40 +0100848 .flags = DEV_RATE_OFDM,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100849 .bitrate = 60,
Ivo van Doornaa776722008-03-09 22:48:08 +0100850 .ratemask = BIT(4),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100851 .plcp = 0x0b,
Ivo van Doorn35f00cf2009-04-26 16:09:32 +0200852 .mcs = RATE_MCS(RATE_MODE_OFDM, 0),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100853 },
854 {
855 .flags = DEV_RATE_OFDM,
856 .bitrate = 90,
Ivo van Doornaa776722008-03-09 22:48:08 +0100857 .ratemask = BIT(5),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100858 .plcp = 0x0f,
Ivo van Doorn35f00cf2009-04-26 16:09:32 +0200859 .mcs = RATE_MCS(RATE_MODE_OFDM, 1),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100860 },
861 {
Ivo van Doorn3d8606a2008-11-02 00:36:40 +0100862 .flags = DEV_RATE_OFDM,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100863 .bitrate = 120,
Ivo van Doornaa776722008-03-09 22:48:08 +0100864 .ratemask = BIT(6),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100865 .plcp = 0x0a,
Ivo van Doorn35f00cf2009-04-26 16:09:32 +0200866 .mcs = RATE_MCS(RATE_MODE_OFDM, 2),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100867 },
868 {
869 .flags = DEV_RATE_OFDM,
870 .bitrate = 180,
Ivo van Doornaa776722008-03-09 22:48:08 +0100871 .ratemask = BIT(7),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100872 .plcp = 0x0e,
Ivo van Doorn35f00cf2009-04-26 16:09:32 +0200873 .mcs = RATE_MCS(RATE_MODE_OFDM, 3),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100874 },
875 {
Ivo van Doorn3d8606a2008-11-02 00:36:40 +0100876 .flags = DEV_RATE_OFDM,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100877 .bitrate = 240,
Ivo van Doornaa776722008-03-09 22:48:08 +0100878 .ratemask = BIT(8),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100879 .plcp = 0x09,
Ivo van Doorn35f00cf2009-04-26 16:09:32 +0200880 .mcs = RATE_MCS(RATE_MODE_OFDM, 4),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100881 },
882 {
883 .flags = DEV_RATE_OFDM,
884 .bitrate = 360,
Ivo van Doornaa776722008-03-09 22:48:08 +0100885 .ratemask = BIT(9),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100886 .plcp = 0x0d,
Ivo van Doorn35f00cf2009-04-26 16:09:32 +0200887 .mcs = RATE_MCS(RATE_MODE_OFDM, 5),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100888 },
889 {
890 .flags = DEV_RATE_OFDM,
891 .bitrate = 480,
Ivo van Doornaa776722008-03-09 22:48:08 +0100892 .ratemask = BIT(10),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100893 .plcp = 0x08,
Ivo van Doorn35f00cf2009-04-26 16:09:32 +0200894 .mcs = RATE_MCS(RATE_MODE_OFDM, 6),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100895 },
896 {
897 .flags = DEV_RATE_OFDM,
898 .bitrate = 540,
Ivo van Doornaa776722008-03-09 22:48:08 +0100899 .ratemask = BIT(11),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100900 .plcp = 0x0c,
Ivo van Doorn35f00cf2009-04-26 16:09:32 +0200901 .mcs = RATE_MCS(RATE_MODE_OFDM, 7),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100902 },
903};
904
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700905static void rt2x00lib_channel(struct ieee80211_channel *entry,
906 const int channel, const int tx_power,
907 const int value)
908{
Bruno Randolf59eb21a2011-01-17 13:37:28 +0900909 /* XXX: this assumption about the band is wrong for 802.11j */
Johannes Berg57fbcce2016-04-12 15:56:15 +0200910 entry->band = channel <= 14 ? NL80211_BAND_2GHZ : NL80211_BAND_5GHZ;
Bruno Randolf59eb21a2011-01-17 13:37:28 +0900911 entry->center_freq = ieee80211_channel_to_frequency(channel,
912 entry->band);
Johannes Berg8318d782008-01-24 19:38:38 +0100913 entry->hw_value = value;
914 entry->max_power = tx_power;
915 entry->max_antenna_gain = 0xff;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700916}
917
918static void rt2x00lib_rate(struct ieee80211_rate *entry,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100919 const u16 index, const struct rt2x00_rate *rate)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700920{
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100921 entry->flags = 0;
922 entry->bitrate = rate->bitrate;
Mark Einonc2361ba2010-11-06 15:46:36 +0100923 entry->hw_value = index;
Ivo van Doorn3ea96462009-01-04 17:33:25 +0100924 entry->hw_value_short = index;
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100925
Ivo van Doorn3ea96462009-01-04 17:33:25 +0100926 if (rate->flags & DEV_RATE_SHORT_PREAMBLE)
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100927 entry->flags |= IEEE80211_RATE_SHORT_PREAMBLE;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700928}
929
Mathias Kresin9766cb72016-08-26 09:16:53 +0200930void rt2x00lib_set_mac_address(struct rt2x00_dev *rt2x00dev, u8 *eeprom_mac_addr)
931{
932 const char *mac_addr;
933
934 mac_addr = of_get_mac_address(rt2x00dev->dev->of_node);
935 if (mac_addr)
936 ether_addr_copy(eeprom_mac_addr, mac_addr);
937
938 if (!is_valid_ether_addr(eeprom_mac_addr)) {
939 eth_random_addr(eeprom_mac_addr);
940 rt2x00_eeprom_dbg(rt2x00dev, "MAC: %pM\n", eeprom_mac_addr);
941 }
942}
943EXPORT_SYMBOL_GPL(rt2x00lib_set_mac_address);
944
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700945static int rt2x00lib_probe_hw_modes(struct rt2x00_dev *rt2x00dev,
946 struct hw_mode_spec *spec)
947{
948 struct ieee80211_hw *hw = rt2x00dev->hw;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700949 struct ieee80211_channel *channels;
950 struct ieee80211_rate *rates;
Ivo van Doorn31562e82008-02-17 17:35:05 +0100951 unsigned int num_rates;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700952 unsigned int i;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700953
Ivo van Doorn31562e82008-02-17 17:35:05 +0100954 num_rates = 0;
955 if (spec->supported_rates & SUPPORT_RATE_CCK)
956 num_rates += 4;
957 if (spec->supported_rates & SUPPORT_RATE_OFDM)
958 num_rates += 8;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700959
Thomas Meyer839fafb2011-11-29 22:08:00 +0100960 channels = kcalloc(spec->num_channels, sizeof(*channels), GFP_KERNEL);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700961 if (!channels)
Johannes Berg8318d782008-01-24 19:38:38 +0100962 return -ENOMEM;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700963
Thomas Meyer839fafb2011-11-29 22:08:00 +0100964 rates = kcalloc(num_rates, sizeof(*rates), GFP_KERNEL);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700965 if (!rates)
966 goto exit_free_channels;
967
968 /*
969 * Initialize Rate list.
970 */
Ivo van Doorn31562e82008-02-17 17:35:05 +0100971 for (i = 0; i < num_rates; i++)
Ivo van Doorn8f5fa7f2008-02-03 15:54:34 +0100972 rt2x00lib_rate(&rates[i], i, rt2x00_get_rate(i));
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700973
974 /*
975 * Initialize Channel list.
976 */
977 for (i = 0; i < spec->num_channels; i++) {
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700978 rt2x00lib_channel(&channels[i],
Ivo van Doorn8c5e7a52008-08-04 16:38:47 +0200979 spec->channels[i].channel,
Ivo van Doorn8d1331b2010-08-23 19:56:07 +0200980 spec->channels_info[i].max_power, i);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700981 }
982
983 /*
Ivo van Doorn31562e82008-02-17 17:35:05 +0100984 * Intitialize 802.11b, 802.11g
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700985 * Rates: CCK, OFDM.
Johannes Berg8318d782008-01-24 19:38:38 +0100986 * Channels: 2.4 GHz
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700987 */
Gertjan van Wingerde47ac2682008-02-17 17:35:55 +0100988 if (spec->supported_bands & SUPPORT_BAND_2GHZ) {
Johannes Berg57fbcce2016-04-12 15:56:15 +0200989 rt2x00dev->bands[NL80211_BAND_2GHZ].n_channels = 14;
990 rt2x00dev->bands[NL80211_BAND_2GHZ].n_bitrates = num_rates;
991 rt2x00dev->bands[NL80211_BAND_2GHZ].channels = channels;
992 rt2x00dev->bands[NL80211_BAND_2GHZ].bitrates = rates;
993 hw->wiphy->bands[NL80211_BAND_2GHZ] =
994 &rt2x00dev->bands[NL80211_BAND_2GHZ];
995 memcpy(&rt2x00dev->bands[NL80211_BAND_2GHZ].ht_cap,
Ivo van Doorn35f00cf2009-04-26 16:09:32 +0200996 &spec->ht, sizeof(spec->ht));
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700997 }
998
999 /*
1000 * Intitialize 802.11a
1001 * Rates: OFDM.
1002 * Channels: OFDM, UNII, HiperLAN2.
1003 */
Gertjan van Wingerde47ac2682008-02-17 17:35:55 +01001004 if (spec->supported_bands & SUPPORT_BAND_5GHZ) {
Johannes Berg57fbcce2016-04-12 15:56:15 +02001005 rt2x00dev->bands[NL80211_BAND_5GHZ].n_channels =
Ivo van Doorn31562e82008-02-17 17:35:05 +01001006 spec->num_channels - 14;
Johannes Berg57fbcce2016-04-12 15:56:15 +02001007 rt2x00dev->bands[NL80211_BAND_5GHZ].n_bitrates =
Ivo van Doorn31562e82008-02-17 17:35:05 +01001008 num_rates - 4;
Johannes Berg57fbcce2016-04-12 15:56:15 +02001009 rt2x00dev->bands[NL80211_BAND_5GHZ].channels = &channels[14];
1010 rt2x00dev->bands[NL80211_BAND_5GHZ].bitrates = &rates[4];
1011 hw->wiphy->bands[NL80211_BAND_5GHZ] =
1012 &rt2x00dev->bands[NL80211_BAND_5GHZ];
1013 memcpy(&rt2x00dev->bands[NL80211_BAND_5GHZ].ht_cap,
Ivo van Doorn35f00cf2009-04-26 16:09:32 +02001014 &spec->ht, sizeof(spec->ht));
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001015 }
1016
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001017 return 0;
1018
Johannes Berg8318d782008-01-24 19:38:38 +01001019 exit_free_channels:
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001020 kfree(channels);
Joe Perchesec9c4982013-04-19 08:33:40 -07001021 rt2x00_err(rt2x00dev, "Allocation ieee80211 modes failed\n");
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001022 return -ENOMEM;
1023}
1024
1025static void rt2x00lib_remove_hw(struct rt2x00_dev *rt2x00dev)
1026{
Ivo van Doorn0262ab02008-08-29 21:04:26 +02001027 if (test_bit(DEVICE_STATE_REGISTERED_HW, &rt2x00dev->flags))
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001028 ieee80211_unregister_hw(rt2x00dev->hw);
1029
Johannes Berg57fbcce2016-04-12 15:56:15 +02001030 if (likely(rt2x00dev->hw->wiphy->bands[NL80211_BAND_2GHZ])) {
1031 kfree(rt2x00dev->hw->wiphy->bands[NL80211_BAND_2GHZ]->channels);
1032 kfree(rt2x00dev->hw->wiphy->bands[NL80211_BAND_2GHZ]->bitrates);
1033 rt2x00dev->hw->wiphy->bands[NL80211_BAND_2GHZ] = NULL;
1034 rt2x00dev->hw->wiphy->bands[NL80211_BAND_5GHZ] = NULL;
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001035 }
Ivo van Doorn8c5e7a52008-08-04 16:38:47 +02001036
1037 kfree(rt2x00dev->spec.channels_info);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001038}
1039
1040static int rt2x00lib_probe_hw(struct rt2x00_dev *rt2x00dev)
1041{
1042 struct hw_mode_spec *spec = &rt2x00dev->spec;
1043 int status;
1044
Ivo van Doorn0262ab02008-08-29 21:04:26 +02001045 if (test_bit(DEVICE_STATE_REGISTERED_HW, &rt2x00dev->flags))
1046 return 0;
1047
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001048 /*
1049 * Initialize HW modes.
1050 */
1051 status = rt2x00lib_probe_hw_modes(rt2x00dev, spec);
1052 if (status)
1053 return status;
1054
1055 /*
Gertjan van Wingerde61448f82008-05-10 13:43:33 +02001056 * Initialize HW fields.
1057 */
1058 rt2x00dev->hw->queues = rt2x00dev->ops->tx_queues;
1059
1060 /*
Gertjan van Wingerdee6218cc2009-11-23 22:44:52 +01001061 * Initialize extra TX headroom required.
1062 */
Gertjan van Wingerde7a4a77b2009-12-30 11:36:30 +01001063 rt2x00dev->hw->extra_tx_headroom =
1064 max_t(unsigned int, IEEE80211_TX_STATUS_HEADROOM,
Gabor Juhos5616a6e2013-06-06 09:36:19 +02001065 rt2x00dev->extra_tx_headroom);
Gertjan van Wingerde7a4a77b2009-12-30 11:36:30 +01001066
1067 /*
1068 * Take TX headroom required for alignment into account.
1069 */
Fred Choub9d305c2014-12-26 16:19:18 +08001070 if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_L2PAD))
Gertjan van Wingerde7a4a77b2009-12-30 11:36:30 +01001071 rt2x00dev->hw->extra_tx_headroom += RT2X00_L2PAD_SIZE;
Fred Choub9d305c2014-12-26 16:19:18 +08001072 else if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DMA))
Gertjan van Wingerde7a4a77b2009-12-30 11:36:30 +01001073 rt2x00dev->hw->extra_tx_headroom += RT2X00_ALIGN_SIZE;
Gertjan van Wingerdee6218cc2009-11-23 22:44:52 +01001074
1075 /*
Helmut Schaab4943d82011-09-08 14:36:04 +02001076 * Tell mac80211 about the size of our private STA structure.
1077 */
1078 rt2x00dev->hw->sta_data_size = sizeof(struct rt2x00_sta);
1079
1080 /*
Helmut Schaa96c3da72010-10-02 11:27:35 +02001081 * Allocate tx status FIFO for driver use.
1082 */
Fred Choub9d305c2014-12-26 16:19:18 +08001083 if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_TXSTATUS_FIFO)) {
Helmut Schaa96c3da72010-10-02 11:27:35 +02001084 /*
Helmut Schaaf78987c2011-03-28 13:30:36 +02001085 * Allocate the txstatus fifo. In the worst case the tx
1086 * status fifo has to hold the tx status of all entries
1087 * in all tx queues. Hence, calculate the kfifo size as
1088 * tx_queues * entry_num and round up to the nearest
1089 * power of 2.
Helmut Schaa96c3da72010-10-02 11:27:35 +02001090 */
Helmut Schaaf78987c2011-03-28 13:30:36 +02001091 int kfifo_size =
1092 roundup_pow_of_two(rt2x00dev->ops->tx_queues *
Gabor Juhos54ca1932013-05-01 17:17:29 +02001093 rt2x00dev->tx->limit *
Helmut Schaaf78987c2011-03-28 13:30:36 +02001094 sizeof(u32));
1095
1096 status = kfifo_alloc(&rt2x00dev->txstatus_fifo, kfifo_size,
Helmut Schaa96c3da72010-10-02 11:27:35 +02001097 GFP_KERNEL);
1098 if (status)
1099 return status;
Helmut Schaa96c3da72010-10-02 11:27:35 +02001100 }
1101
1102 /*
Helmut Schaac5c65762011-01-30 13:17:52 +01001103 * Initialize tasklets if used by the driver. Tasklets are
1104 * disabled until the interrupts are turned on. The driver
1105 * has to handle that.
1106 */
1107#define RT2X00_TASKLET_INIT(taskletname) \
1108 if (rt2x00dev->ops->lib->taskletname) { \
1109 tasklet_init(&rt2x00dev->taskletname, \
1110 rt2x00dev->ops->lib->taskletname, \
1111 (unsigned long)rt2x00dev); \
Helmut Schaac5c65762011-01-30 13:17:52 +01001112 }
1113
Helmut Schaac8e15a12011-01-30 13:18:13 +01001114 RT2X00_TASKLET_INIT(txstatus_tasklet);
Helmut Schaac5c65762011-01-30 13:17:52 +01001115 RT2X00_TASKLET_INIT(pretbtt_tasklet);
1116 RT2X00_TASKLET_INIT(tbtt_tasklet);
1117 RT2X00_TASKLET_INIT(rxdone_tasklet);
1118 RT2X00_TASKLET_INIT(autowake_tasklet);
1119
1120#undef RT2X00_TASKLET_INIT
1121
1122 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001123 * Register HW.
1124 */
1125 status = ieee80211_register_hw(rt2x00dev->hw);
Herton Ronaldo Krzesinskif05faa32009-04-10 18:05:14 -03001126 if (status)
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001127 return status;
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001128
Ivo van Doorn0262ab02008-08-29 21:04:26 +02001129 set_bit(DEVICE_STATE_REGISTERED_HW, &rt2x00dev->flags);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001130
1131 return 0;
1132}
1133
1134/*
1135 * Initialization/uninitialization handlers.
1136 */
Ivo van Doorne37ea212008-01-06 23:40:07 +01001137static void rt2x00lib_uninitialize(struct rt2x00_dev *rt2x00dev)
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001138{
Ivo van Doorn0262ab02008-08-29 21:04:26 +02001139 if (!test_and_clear_bit(DEVICE_STATE_INITIALIZED, &rt2x00dev->flags))
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001140 return;
1141
1142 /*
Stanislaw Gruszka616a8392014-06-16 18:45:15 +02001143 * Stop rfkill polling.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001144 */
Fred Choub9d305c2014-12-26 16:19:18 +08001145 if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DELAYED_RFKILL))
Stanislaw Gruszka616a8392014-06-16 18:45:15 +02001146 rt2x00rfkill_unregister(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001147
1148 /*
1149 * Allow the HW to uninitialize.
1150 */
1151 rt2x00dev->ops->lib->uninitialize(rt2x00dev);
1152
1153 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -05001154 * Free allocated queue entries.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001155 */
Ivo van Doorn181d6902008-02-05 16:42:23 -05001156 rt2x00queue_uninitialize(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001157}
1158
Ivo van Doorne37ea212008-01-06 23:40:07 +01001159static int rt2x00lib_initialize(struct rt2x00_dev *rt2x00dev)
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001160{
1161 int status;
1162
Ivo van Doorn0262ab02008-08-29 21:04:26 +02001163 if (test_bit(DEVICE_STATE_INITIALIZED, &rt2x00dev->flags))
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001164 return 0;
1165
1166 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -05001167 * Allocate all queue entries.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001168 */
Ivo van Doorn181d6902008-02-05 16:42:23 -05001169 status = rt2x00queue_initialize(rt2x00dev);
1170 if (status)
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001171 return status;
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001172
1173 /*
1174 * Initialize the device.
1175 */
1176 status = rt2x00dev->ops->lib->initialize(rt2x00dev);
Ivo van Doorned499982008-05-05 17:23:47 +02001177 if (status) {
1178 rt2x00queue_uninitialize(rt2x00dev);
1179 return status;
1180 }
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001181
Ivo van Doorn0262ab02008-08-29 21:04:26 +02001182 set_bit(DEVICE_STATE_INITIALIZED, &rt2x00dev->flags);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001183
Stanislaw Gruszka616a8392014-06-16 18:45:15 +02001184 /*
1185 * Start rfkill polling.
1186 */
Fred Choub9d305c2014-12-26 16:19:18 +08001187 if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DELAYED_RFKILL))
Stanislaw Gruszka616a8392014-06-16 18:45:15 +02001188 rt2x00rfkill_register(rt2x00dev);
1189
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001190 return 0;
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001191}
1192
Ivo van Doorne37ea212008-01-06 23:40:07 +01001193int rt2x00lib_start(struct rt2x00_dev *rt2x00dev)
1194{
1195 int retval;
1196
Ivo van Doorn0262ab02008-08-29 21:04:26 +02001197 if (test_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags))
Ivo van Doorne37ea212008-01-06 23:40:07 +01001198 return 0;
1199
1200 /*
1201 * If this is the first interface which is added,
1202 * we should load the firmware now.
1203 */
Ivo van Doorn9404ef32008-02-03 15:48:38 +01001204 retval = rt2x00lib_load_firmware(rt2x00dev);
1205 if (retval)
1206 return retval;
Ivo van Doorne37ea212008-01-06 23:40:07 +01001207
1208 /*
1209 * Initialize the device.
1210 */
1211 retval = rt2x00lib_initialize(rt2x00dev);
1212 if (retval)
1213 return retval;
1214
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +01001215 rt2x00dev->intf_ap_count = 0;
1216 rt2x00dev->intf_sta_count = 0;
1217 rt2x00dev->intf_associated = 0;
1218
Ivo van Doornbdfa5002009-08-08 23:53:04 +02001219 /* Enable the radio */
1220 retval = rt2x00lib_enable_radio(rt2x00dev);
Helmut Schaa1f0280c2010-10-02 11:34:05 +02001221 if (retval)
Ivo van Doornbdfa5002009-08-08 23:53:04 +02001222 return retval;
Ivo van Doornbdfa5002009-08-08 23:53:04 +02001223
Ivo van Doorn0262ab02008-08-29 21:04:26 +02001224 set_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags);
Ivo van Doorne37ea212008-01-06 23:40:07 +01001225
1226 return 0;
1227}
1228
1229void rt2x00lib_stop(struct rt2x00_dev *rt2x00dev)
1230{
Ivo van Doorn0262ab02008-08-29 21:04:26 +02001231 if (!test_and_clear_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags))
Ivo van Doorne37ea212008-01-06 23:40:07 +01001232 return;
1233
1234 /*
1235 * Perhaps we can add something smarter here,
1236 * but for now just disabling the radio should do.
1237 */
1238 rt2x00lib_disable_radio(rt2x00dev);
1239
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +01001240 rt2x00dev->intf_ap_count = 0;
1241 rt2x00dev->intf_sta_count = 0;
1242 rt2x00dev->intf_associated = 0;
Ivo van Doorne37ea212008-01-06 23:40:07 +01001243}
1244
Gertjan van Wingerde55d2e9d2012-09-23 20:22:54 +02001245static inline void rt2x00lib_set_if_combinations(struct rt2x00_dev *rt2x00dev)
1246{
1247 struct ieee80211_iface_limit *if_limit;
1248 struct ieee80211_iface_combination *if_combination;
1249
Helmut Schaaf5685ba2012-12-03 22:35:39 +01001250 if (rt2x00dev->ops->max_ap_intf < 2)
1251 return;
1252
Gertjan van Wingerde55d2e9d2012-09-23 20:22:54 +02001253 /*
1254 * Build up AP interface limits structure.
1255 */
1256 if_limit = &rt2x00dev->if_limits_ap;
1257 if_limit->max = rt2x00dev->ops->max_ap_intf;
Felix Fietkau6ef9e2f2013-02-26 16:09:55 +01001258 if_limit->types = BIT(NL80211_IFTYPE_AP);
1259#ifdef CONFIG_MAC80211_MESH
1260 if_limit->types |= BIT(NL80211_IFTYPE_MESH_POINT);
1261#endif
Gertjan van Wingerde55d2e9d2012-09-23 20:22:54 +02001262
1263 /*
1264 * Build up AP interface combinations structure.
1265 */
1266 if_combination = &rt2x00dev->if_combinations[IF_COMB_AP];
1267 if_combination->limits = if_limit;
1268 if_combination->n_limits = 1;
1269 if_combination->max_interfaces = if_limit->max;
1270 if_combination->num_different_channels = 1;
1271
1272 /*
1273 * Finally, specify the possible combinations to mac80211.
1274 */
1275 rt2x00dev->hw->wiphy->iface_combinations = rt2x00dev->if_combinations;
1276 rt2x00dev->hw->wiphy->n_iface_combinations = 1;
1277}
1278
Gabor Juhos5616a6e2013-06-06 09:36:19 +02001279static unsigned int rt2x00dev_extra_tx_headroom(struct rt2x00_dev *rt2x00dev)
1280{
1281 if (WARN_ON(!rt2x00dev->tx))
1282 return 0;
1283
1284 if (rt2x00_is_usb(rt2x00dev))
1285 return rt2x00dev->tx[0].winfo_size + rt2x00dev->tx[0].desc_size;
1286
1287 return rt2x00dev->tx[0].winfo_size;
1288}
1289
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001290/*
1291 * driver allocation handlers.
1292 */
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001293int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev)
1294{
1295 int retval = -ENOMEM;
1296
Gertjan van Wingerde1ebbc482012-02-06 23:45:06 +01001297 /*
Gertjan van Wingerde55d2e9d2012-09-23 20:22:54 +02001298 * Set possible interface combinations.
1299 */
1300 rt2x00lib_set_if_combinations(rt2x00dev);
1301
1302 /*
Gertjan van Wingerde1ebbc482012-02-06 23:45:06 +01001303 * Allocate the driver data memory, if necessary.
1304 */
1305 if (rt2x00dev->ops->drv_data_size > 0) {
1306 rt2x00dev->drv_data = kzalloc(rt2x00dev->ops->drv_data_size,
1307 GFP_KERNEL);
1308 if (!rt2x00dev->drv_data) {
1309 retval = -ENOMEM;
1310 goto exit;
1311 }
1312 }
1313
Helmut Schaac5c65762011-01-30 13:17:52 +01001314 spin_lock_init(&rt2x00dev->irqmask_lock);
Ivo van Doorn8ff48a82008-11-09 23:40:46 +01001315 mutex_init(&rt2x00dev->csr_mutex);
Stanislaw Gruszkac7d1c772016-12-19 11:52:57 +01001316 mutex_init(&rt2x00dev->conf_mutex);
Helmut Schaa84e9e8ebd2013-01-17 17:34:32 +01001317 INIT_LIST_HEAD(&rt2x00dev->bar_list);
1318 spin_lock_init(&rt2x00dev->bar_list_lock);
Ivo van Doorn8ff48a82008-11-09 23:40:46 +01001319
Sean Cross66f84d62009-11-05 20:22:03 +01001320 set_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
1321
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001322 /*
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +01001323 * Make room for rt2x00_intf inside the per-interface
1324 * structure ieee80211_vif.
1325 */
1326 rt2x00dev->hw->vif_data_size = sizeof(struct rt2x00_intf);
1327
Ivo van Doorn3514a442008-10-29 17:18:46 +01001328 /*
Helmut Schaa6c50f942012-11-28 10:28:52 +01001329 * rt2x00 devices can only use the last n bits of the MAC address
1330 * for virtual interfaces.
1331 */
1332 rt2x00dev->hw->wiphy->addr_mask[ETH_ALEN - 1] =
1333 (rt2x00dev->ops->max_ap_intf - 1);
1334
1335 /*
Ivo van Doorn0439f532011-01-30 13:24:05 +01001336 * Initialize work.
Stephen Boyd9acd56d2010-07-16 09:50:10 -07001337 */
Ivo van Doorn0439f532011-01-30 13:24:05 +01001338 rt2x00dev->workqueue =
Kees Cookd8537542013-07-03 15:04:57 -07001339 alloc_ordered_workqueue("%s", 0, wiphy_name(rt2x00dev->hw->wiphy));
Ivo van Doorn0439f532011-01-30 13:24:05 +01001340 if (!rt2x00dev->workqueue) {
1341 retval = -ENOMEM;
1342 goto exit;
1343 }
1344
Stephen Boyd9acd56d2010-07-16 09:50:10 -07001345 INIT_WORK(&rt2x00dev->intf_work, rt2x00lib_intf_scheduled);
Ivo van Doorn1c0bcf82011-04-30 17:18:18 +02001346 INIT_DELAYED_WORK(&rt2x00dev->autowakeup_work, rt2x00lib_autowakeup);
Gertjan van Wingerdeed66ba42011-11-12 19:10:44 +01001347 INIT_WORK(&rt2x00dev->sleep_work, rt2x00lib_sleep);
Stephen Boyd9acd56d2010-07-16 09:50:10 -07001348
1349 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001350 * Let the driver probe the device to detect the capabilities.
1351 */
1352 retval = rt2x00dev->ops->lib->probe_hw(rt2x00dev);
1353 if (retval) {
Joe Perchesec9c4982013-04-19 08:33:40 -07001354 rt2x00_err(rt2x00dev, "Failed to allocate device\n");
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001355 goto exit;
1356 }
1357
1358 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -05001359 * Allocate queue array.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001360 */
Ivo van Doorn181d6902008-02-05 16:42:23 -05001361 retval = rt2x00queue_allocate(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001362 if (retval)
1363 goto exit;
1364
Gabor Juhos5616a6e2013-06-06 09:36:19 +02001365 /* Cache TX headroom value */
1366 rt2x00dev->extra_tx_headroom = rt2x00dev_extra_tx_headroom(rt2x00dev);
1367
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001368 /*
Gabor Juhose9e43302013-05-01 17:17:34 +02001369 * Determine which operating modes are supported, all modes
1370 * which require beaconing, depend on the availability of
1371 * beacon entries.
1372 */
1373 rt2x00dev->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
Gabor Juhos56e82562013-06-04 13:40:40 +02001374 if (rt2x00dev->bcn->limit > 0)
Gabor Juhose9e43302013-05-01 17:17:34 +02001375 rt2x00dev->hw->wiphy->interface_modes |=
1376 BIT(NL80211_IFTYPE_ADHOC) |
Gabor Juhose9e43302013-05-01 17:17:34 +02001377#ifdef CONFIG_MAC80211_MESH
1378 BIT(NL80211_IFTYPE_MESH_POINT) |
1379#endif
Johannes Berg8f205422016-10-18 10:28:57 +02001380#ifdef CONFIG_WIRELESS_WDS
1381 BIT(NL80211_IFTYPE_WDS) |
1382#endif
1383 BIT(NL80211_IFTYPE_AP);
Gabor Juhose9e43302013-05-01 17:17:34 +02001384
1385 rt2x00dev->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
1386
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001387 /*
1388 * Initialize ieee80211 structure.
1389 */
1390 retval = rt2x00lib_probe_hw(rt2x00dev);
1391 if (retval) {
Joe Perchesec9c4982013-04-19 08:33:40 -07001392 rt2x00_err(rt2x00dev, "Failed to initialize hw\n");
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001393 goto exit;
1394 }
1395
1396 /*
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001397 * Register extra components.
Ivo van Doorna9450b72008-02-03 15:53:40 +01001398 */
Ivo van Doorn84e31962008-12-20 10:53:29 +01001399 rt2x00link_register(rt2x00dev);
Ivo van Doorna9450b72008-02-03 15:53:40 +01001400 rt2x00leds_register(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001401 rt2x00debug_register(rt2x00dev);
Stanislaw Gruszka616a8392014-06-16 18:45:15 +02001402
1403 /*
1404 * Start rfkill polling.
1405 */
Fred Choub9d305c2014-12-26 16:19:18 +08001406 if (!rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DELAYED_RFKILL))
Stanislaw Gruszka616a8392014-06-16 18:45:15 +02001407 rt2x00rfkill_register(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001408
1409 return 0;
1410
1411exit:
1412 rt2x00lib_remove_dev(rt2x00dev);
1413
1414 return retval;
1415}
1416EXPORT_SYMBOL_GPL(rt2x00lib_probe_dev);
1417
1418void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev)
1419{
Ivo van Doorn0262ab02008-08-29 21:04:26 +02001420 clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
Ivo van Doorn066cb632007-09-25 20:55:39 +02001421
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001422 /*
Stanislaw Gruszka616a8392014-06-16 18:45:15 +02001423 * Stop rfkill polling.
1424 */
Fred Choub9d305c2014-12-26 16:19:18 +08001425 if (!rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DELAYED_RFKILL))
Stanislaw Gruszka616a8392014-06-16 18:45:15 +02001426 rt2x00rfkill_unregister(rt2x00dev);
1427
1428 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001429 * Disable radio.
1430 */
1431 rt2x00lib_disable_radio(rt2x00dev);
1432
1433 /*
Pavel Roskind8cc8922009-08-02 14:30:15 -04001434 * Stop all work.
1435 */
Pavel Roskind8cc8922009-08-02 14:30:15 -04001436 cancel_work_sync(&rt2x00dev->intf_work);
Stanislaw Gruszka3bb42a62011-06-04 16:48:54 +02001437 cancel_delayed_work_sync(&rt2x00dev->autowakeup_work);
Gertjan van Wingerdeed66ba42011-11-12 19:10:44 +01001438 cancel_work_sync(&rt2x00dev->sleep_work);
Vishal Thankia083c8f2016-11-16 17:01:54 +01001439#if IS_ENABLED(CONFIG_RT2X00_LIB_USB)
Stanislaw Gruszka37f4ee02011-04-04 13:50:32 +02001440 if (rt2x00_is_usb(rt2x00dev)) {
Vishal Thanki8b4c0002016-03-19 11:41:01 +01001441 usb_kill_anchored_urbs(rt2x00dev->anchor);
Stanislaw Gruszkaf4211112012-03-14 11:16:19 +01001442 hrtimer_cancel(&rt2x00dev->txstatus_timer);
Stanislaw Gruszka37f4ee02011-04-04 13:50:32 +02001443 cancel_work_sync(&rt2x00dev->rxdone_work);
1444 cancel_work_sync(&rt2x00dev->txdone_work);
1445 }
Vishal Thanki8b4c0002016-03-19 11:41:01 +01001446#endif
Gabor Juhos7be08152012-02-16 20:44:59 +01001447 if (rt2x00dev->workqueue)
1448 destroy_workqueue(rt2x00dev->workqueue);
Pavel Roskind8cc8922009-08-02 14:30:15 -04001449
1450 /*
Helmut Schaa96c3da72010-10-02 11:27:35 +02001451 * Free the tx status fifo.
1452 */
1453 kfifo_free(&rt2x00dev->txstatus_fifo);
1454
1455 /*
1456 * Kill the tx status tasklet.
1457 */
1458 tasklet_kill(&rt2x00dev->txstatus_tasklet);
Ivo van Doorne1f4e802011-01-30 13:23:42 +01001459 tasklet_kill(&rt2x00dev->pretbtt_tasklet);
1460 tasklet_kill(&rt2x00dev->tbtt_tasklet);
1461 tasklet_kill(&rt2x00dev->rxdone_tasklet);
1462 tasklet_kill(&rt2x00dev->autowake_tasklet);
Helmut Schaa96c3da72010-10-02 11:27:35 +02001463
1464 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001465 * Uninitialize device.
1466 */
1467 rt2x00lib_uninitialize(rt2x00dev);
1468
1469 /*
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001470 * Free extra components
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001471 */
1472 rt2x00debug_deregister(rt2x00dev);
Ivo van Doorna9450b72008-02-03 15:53:40 +01001473 rt2x00leds_unregister(rt2x00dev);
1474
1475 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001476 * Free ieee80211_hw memory.
1477 */
1478 rt2x00lib_remove_hw(rt2x00dev);
1479
1480 /*
1481 * Free firmware image.
1482 */
1483 rt2x00lib_free_firmware(rt2x00dev);
1484
1485 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -05001486 * Free queue structures.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001487 */
Ivo van Doorn181d6902008-02-05 16:42:23 -05001488 rt2x00queue_free(rt2x00dev);
Gertjan van Wingerde1ebbc482012-02-06 23:45:06 +01001489
1490 /*
1491 * Free the driver data.
1492 */
Fabian Frederickd41502462014-06-18 16:51:29 +02001493 kfree(rt2x00dev->drv_data);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001494}
1495EXPORT_SYMBOL_GPL(rt2x00lib_remove_dev);
1496
1497/*
1498 * Device state handlers
1499 */
1500#ifdef CONFIG_PM
1501int rt2x00lib_suspend(struct rt2x00_dev *rt2x00dev, pm_message_t state)
1502{
Joe Perchesec9c4982013-04-19 08:33:40 -07001503 rt2x00_dbg(rt2x00dev, "Going to sleep\n");
Ivo van Doorn066cb632007-09-25 20:55:39 +02001504
1505 /*
Ivo van Doorn07126122009-01-23 17:04:05 +01001506 * Prevent mac80211 from accessing driver while suspended.
Ivo van Doorn066cb632007-09-25 20:55:39 +02001507 */
Ivo van Doorn07126122009-01-23 17:04:05 +01001508 if (!test_and_clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
1509 return 0;
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001510
1511 /*
Ivo van Doorn07126122009-01-23 17:04:05 +01001512 * Cleanup as much as possible.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001513 */
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001514 rt2x00lib_uninitialize(rt2x00dev);
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001515
1516 /*
1517 * Suspend/disable extra components.
1518 */
Ivo van Doorna9450b72008-02-03 15:53:40 +01001519 rt2x00leds_suspend(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001520 rt2x00debug_deregister(rt2x00dev);
1521
1522 /*
Ivo van Doorn98963222008-03-27 17:15:24 +01001523 * Set device mode to sleep for power management,
1524 * on some hardware this call seems to consistently fail.
1525 * From the specifications it is hard to tell why it fails,
1526 * and if this is a "bad thing".
1527 * Overall it is safe to just ignore the failure and
1528 * continue suspending. The only downside is that the
1529 * device will not be in optimal power save mode, but with
1530 * the radio and the other components already disabled the
1531 * device is as good as disabled.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001532 */
Ivo van Doorn07126122009-01-23 17:04:05 +01001533 if (rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_SLEEP))
Joe Perchesec9c4982013-04-19 08:33:40 -07001534 rt2x00_warn(rt2x00dev, "Device failed to enter sleep state, continue suspending\n");
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001535
1536 return 0;
1537}
1538EXPORT_SYMBOL_GPL(rt2x00lib_suspend);
1539
1540int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev)
1541{
Joe Perchesec9c4982013-04-19 08:33:40 -07001542 rt2x00_dbg(rt2x00dev, "Waking up\n");
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001543
1544 /*
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001545 * Restore/enable extra components.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001546 */
1547 rt2x00debug_register(rt2x00dev);
Ivo van Doorna9450b72008-02-03 15:53:40 +01001548 rt2x00leds_resume(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001549
1550 /*
Ivo van Doorne37ea212008-01-06 23:40:07 +01001551 * We are ready again to receive requests from mac80211.
1552 */
Ivo van Doorn0262ab02008-08-29 21:04:26 +02001553 set_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
Ivo van Doorne37ea212008-01-06 23:40:07 +01001554
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001555 return 0;
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001556}
1557EXPORT_SYMBOL_GPL(rt2x00lib_resume);
1558#endif /* CONFIG_PM */
1559
1560/*
1561 * rt2x00lib module information.
1562 */
1563MODULE_AUTHOR(DRV_PROJECT);
1564MODULE_VERSION(DRV_VERSION);
1565MODULE_DESCRIPTION("rt2x00 library");
1566MODULE_LICENSE("GPL");