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