main.c 26.8 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/*
 * Copyright 2002-2005, Instant802 Networks, Inc.
 * Copyright 2005-2006, Devicescape Software, Inc.
 * Copyright 2006-2007	Jiri Benc <jbenc@suse.cz>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <net/mac80211.h>
#include <net/ieee80211_radiotap.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/netdevice.h>
#include <linux/types.h>
#include <linux/slab.h>
#include <linux/skbuff.h>
#include <linux/etherdevice.h>
#include <linux/if_arp.h>
#include <linux/wireless.h>
#include <linux/rtnetlink.h>
#include <linux/bitmap.h>
24
#include <net/net_namespace.h>
25
26
27
#include <net/cfg80211.h>

#include "ieee80211_i.h"
Johannes Berg's avatar
Johannes Berg committed
28
#include "rate.h"
29
#include "mesh.h"
30
31
32
#include "wep.h"
#include "wme.h"
#include "aes_ccm.h"
Johannes Berg's avatar
Johannes Berg committed
33
#include "led.h"
34
#include "cfg.h"
35
36
#include "debugfs.h"
#include "debugfs_netdev.h"
37

38
39
40
41
42
43
/*
 * For seeing transmitted packets on monitor interfaces
 * we have a radiotap header too.
 */
struct ieee80211_tx_status_rtap_hdr {
	struct ieee80211_radiotap_header hdr;
44
45
	u8 rate;
	u8 padding_for_rate;
46
47
48
49
	__le16 tx_flags;
	u8 data_retries;
} __attribute__ ((packed));

50

51
/* must be called under mdev tx lock */
52
void ieee80211_configure_filter(struct ieee80211_local *local)
53
54
55
56
{
	unsigned int changed_flags;
	unsigned int new_flags = 0;

57
	if (atomic_read(&local->iff_promiscs))
58
59
		new_flags |= FIF_PROMISC_IN_BSS;

60
	if (atomic_read(&local->iff_allmultis))
61
62
63
		new_flags |= FIF_ALLMULTI;

	if (local->monitors)
64
65
66
67
68
69
70
71
72
73
74
75
76
		new_flags |= FIF_BCN_PRBRESP_PROMISC;

	if (local->fif_fcsfail)
		new_flags |= FIF_FCSFAIL;

	if (local->fif_plcpfail)
		new_flags |= FIF_PLCPFAIL;

	if (local->fif_control)
		new_flags |= FIF_CONTROL;

	if (local->fif_other_bss)
		new_flags |= FIF_OTHER_BSS;
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

	changed_flags = local->filter_flags ^ new_flags;

	/* be a bit nasty */
	new_flags |= (1<<31);

	local->ops->configure_filter(local_to_hw(local),
				     changed_flags, &new_flags,
				     local->mdev->mc_count,
				     local->mdev->mc_list);

	WARN_ON(new_flags & (1<<31));

	local->filter_flags = new_flags & ~(1<<31);
}

93
/* master interface */
94

95
96
97
98
99
100
101
102
103
104
105
106
107
108
static int header_parse_80211(const struct sk_buff *skb, unsigned char *haddr)
{
	memcpy(haddr, skb_mac_header(skb) + 10, ETH_ALEN); /* addr2 */
	return ETH_ALEN;
}

static const struct header_ops ieee80211_header_ops = {
	.create		= eth_header,
	.parse		= header_parse_80211,
	.rebuild	= eth_rebuild_header,
	.cache		= eth_header_cache,
	.cache_update	= eth_header_cache_update,
};

109
110
static int ieee80211_master_open(struct net_device *dev)
{
111
112
	struct ieee80211_master_priv *mpriv = netdev_priv(dev);
	struct ieee80211_local *local = mpriv->local;
113
114
	struct ieee80211_sub_if_data *sdata;
	int res = -EOPNOTSUPP;
115

116
117
	/* we hold the RTNL here so can safely walk the list */
	list_for_each_entry(sdata, &local->interfaces, list) {
118
		if (netif_running(sdata->dev)) {
119
120
121
122
			res = 0;
			break;
		}
	}
123
124
125
126

	if (res)
		return res;

127
	netif_tx_start_all_queues(local->mdev);
128
129

	return 0;
130
}
131

132
static int ieee80211_master_stop(struct net_device *dev)
133
{
134
135
	struct ieee80211_master_priv *mpriv = netdev_priv(dev);
	struct ieee80211_local *local = mpriv->local;
136
	struct ieee80211_sub_if_data *sdata;
137

138
139
	/* we hold the RTNL here so can safely walk the list */
	list_for_each_entry(sdata, &local->interfaces, list)
140
		if (netif_running(sdata->dev))
141
			dev_close(sdata->dev);
142

143
144
	return 0;
}
145

146
147
static void ieee80211_master_set_multicast_list(struct net_device *dev)
{
148
149
	struct ieee80211_master_priv *mpriv = netdev_priv(dev);
	struct ieee80211_local *local = mpriv->local;
150
151
152
153

	ieee80211_configure_filter(local);
}

154
155
/* everything else */

156
int ieee80211_if_config(struct ieee80211_sub_if_data *sdata, u32 changed)
157
{
158
	struct ieee80211_local *local = sdata->local;
159
160
	struct ieee80211_if_conf conf;

161
162
163
	if (WARN_ON(!netif_running(sdata->dev)))
		return 0;

164
165
166
	if (WARN_ON(sdata->vif.type == NL80211_IFTYPE_AP_VLAN))
		return -EINVAL;

167
	if (!local->ops->config_interface)
168
169
		return 0;

170
	memset(&conf, 0, sizeof(conf));
171
172
	conf.changed = changed;

173
	if (sdata->vif.type == NL80211_IFTYPE_STATION ||
174
	    sdata->vif.type == NL80211_IFTYPE_ADHOC)
175
		conf.bssid = sdata->u.sta.bssid;
176
	else if (sdata->vif.type == NL80211_IFTYPE_AP)
177
		conf.bssid = sdata->dev->dev_addr;
178
	else if (ieee80211_vif_is_mesh(&sdata->vif)) {
179
180
181
182
183
		u8 zero[ETH_ALEN] = { 0 };
		conf.bssid = zero;
	} else {
		WARN_ON(1);
		return -EINVAL;
184
185
	}

186
187
	if (WARN_ON(!conf.bssid && (changed & IEEE80211_IFCC_BSSID)))
		return -EINVAL;
188

189
190
	return local->ops->config_interface(local_to_hw(local),
					    &sdata->vif, &conf);
191
}
192

193
int ieee80211_hw_config(struct ieee80211_local *local, u32 changed)
194
195
196
{
	struct ieee80211_channel *chan;
	int ret = 0;
197
	int power;
198
	enum nl80211_sec_chan_offset sec_chan_offset;
199

200
201
	might_sleep();

202
	if (local->sw_scanning) {
203
		chan = local->scan_channel;
204
205
		sec_chan_offset = NL80211_SEC_CHAN_NO_HT;
	} else {
206
		chan = local->oper_channel;
207
208
		sec_chan_offset = local->oper_sec_chan_offset;
	}
209

210
211
	if (chan != local->hw.conf.channel ||
	    sec_chan_offset != local->hw.conf.ht.sec_chan_offset) {
212
		local->hw.conf.channel = chan;
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
		switch (sec_chan_offset) {
		case NL80211_SEC_CHAN_NO_HT:
			local->hw.conf.ht.enabled = false;
			local->hw.conf.ht.sec_chan_offset = 0;
			break;
		case NL80211_SEC_CHAN_DISABLED:
			local->hw.conf.ht.enabled = true;
			local->hw.conf.ht.sec_chan_offset = 0;
			break;
		case NL80211_SEC_CHAN_BELOW:
			local->hw.conf.ht.enabled = true;
			local->hw.conf.ht.sec_chan_offset = -1;
			break;
		case NL80211_SEC_CHAN_ABOVE:
			local->hw.conf.ht.enabled = true;
			local->hw.conf.ht.sec_chan_offset = 1;
			break;
		}
231
232
		changed |= IEEE80211_CONF_CHANGE_CHANNEL;
	}
233
234

	if (!local->hw.conf.power_level)
235
		power = chan->max_power;
236
	else
237
238
239
240
241
		power = min(chan->max_power, local->hw.conf.power_level);
	if (local->hw.conf.power_level != power) {
		changed |= IEEE80211_CONF_CHANGE_POWER;
		local->hw.conf.power_level = power;
	}
242

243
244
	if (changed && local->open_count) {
		ret = local->ops->config(local_to_hw(local), changed);
245
		/*
246
		 * Goal:
247
248
		 * HW reconfiguration should never fail, the driver has told
		 * us what it can support so it should live up to that promise.
249
250
251
252
253
254
255
256
257
		 *
		 * Current status:
		 * rfkill is not integrated with mac80211 and a
		 * configuration command can thus fail if hardware rfkill
		 * is enabled
		 *
		 * FIXME: integrate rfkill with mac80211 and then add this
		 * WARN_ON() back
		 *
258
		 */
259
		/* WARN_ON(ret); */
260
	}
261

262
263
	return ret;
}
264

265
266
void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
				      u32 changed)
267
{
268
269
	struct ieee80211_local *local = sdata->local;

270
271
272
	if (WARN_ON(sdata->vif.type == NL80211_IFTYPE_AP_VLAN))
		return;

273
274
275
276
277
278
	if (!changed)
		return;

	if (local->ops->bss_info_changed)
		local->ops->bss_info_changed(local_to_hw(local),
					     &sdata->vif,
279
					     &sdata->vif.bss_conf,
280
					     changed);
281
282
}

283
u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata)
284
{
285
286
287
	sdata->vif.bss_conf.use_cts_prot = false;
	sdata->vif.bss_conf.use_short_preamble = false;
	sdata->vif.bss_conf.use_short_slot = false;
288
289
290
	return BSS_CHANGED_ERP_CTS_PROT |
	       BSS_CHANGED_ERP_PREAMBLE |
	       BSS_CHANGED_ERP_SLOT;
291
292
}

293
void ieee80211_tx_status_irqsafe(struct ieee80211_hw *hw,
294
				 struct sk_buff *skb)
295
296
{
	struct ieee80211_local *local = hw_to_local(hw);
297
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
298
299
300
301
	int tmp;

	skb->dev = local->mdev;
	skb->pkt_type = IEEE80211_TX_STATUS_MSG;
302
	skb_queue_tail(info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS ?
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
		       &local->skb_queue : &local->skb_queue_unreliable, skb);
	tmp = skb_queue_len(&local->skb_queue) +
		skb_queue_len(&local->skb_queue_unreliable);
	while (tmp > IEEE80211_IRQSAFE_QUEUE_LIMIT &&
	       (skb = skb_dequeue(&local->skb_queue_unreliable))) {
		dev_kfree_skb_irq(skb);
		tmp--;
		I802_DEBUG_INC(local->tx_status_drop);
	}
	tasklet_schedule(&local->tasklet);
}
EXPORT_SYMBOL(ieee80211_tx_status_irqsafe);

static void ieee80211_tasklet_handler(unsigned long data)
{
	struct ieee80211_local *local = (struct ieee80211_local *) data;
	struct sk_buff *skb;
	struct ieee80211_rx_status rx_status;
321
	struct ieee80211_ra_tid *ra_tid;
322
323
324
325
326
327
328

	while ((skb = skb_dequeue(&local->skb_queue)) ||
	       (skb = skb_dequeue(&local->skb_queue_unreliable))) {
		switch (skb->pkt_type) {
		case IEEE80211_RX_MSG:
			/* status is in skb->cb */
			memcpy(&rx_status, skb->cb, sizeof(rx_status));
329
			/* Clear skb->pkt_type in order to not confuse kernel
330
331
332
333
334
335
			 * netstack. */
			skb->pkt_type = 0;
			__ieee80211_rx(local_to_hw(local), skb, &rx_status);
			break;
		case IEEE80211_TX_STATUS_MSG:
			skb->pkt_type = 0;
336
			ieee80211_tx_status(local_to_hw(local), skb);
337
			break;
338
339
340
341
342
343
344
345
346
347
348
349
		case IEEE80211_DELBA_MSG:
			ra_tid = (struct ieee80211_ra_tid *) &skb->cb;
			ieee80211_stop_tx_ba_cb(local_to_hw(local),
						ra_tid->ra, ra_tid->tid);
			dev_kfree_skb(skb);
			break;
		case IEEE80211_ADDBA_MSG:
			ra_tid = (struct ieee80211_ra_tid *) &skb->cb;
			ieee80211_start_tx_ba_cb(local_to_hw(local),
						 ra_tid->ra, ra_tid->tid);
			dev_kfree_skb(skb);
			break ;
350
351
		default:
			WARN_ON(1);
352
353
354
355
356
357
358
359
360
			dev_kfree_skb(skb);
			break;
		}
	}
}

/* Remove added headers (e.g., QoS control), encryption header/MIC, etc. to
 * make a prepared TX frame (one that has been given to hw) to look like brand
 * new IEEE 802.11 frame that is ready to go through TX processing again.
361
 */
362
363
static void ieee80211_remove_tx_extra(struct ieee80211_local *local,
				      struct ieee80211_key *key,
364
				      struct sk_buff *skb)
365
{
366
367
	unsigned int hdrlen, iv_len, mic_len;
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
368

369
	hdrlen = ieee80211_hdrlen(hdr->frame_control);
370
371
372
373

	if (!key)
		goto no_key;

374
	switch (key->conf.alg) {
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
	case ALG_WEP:
		iv_len = WEP_IV_LEN;
		mic_len = WEP_ICV_LEN;
		break;
	case ALG_TKIP:
		iv_len = TKIP_IV_LEN;
		mic_len = TKIP_ICV_LEN;
		break;
	case ALG_CCMP:
		iv_len = CCMP_HDR_LEN;
		mic_len = CCMP_MIC_LEN;
		break;
	default:
		goto no_key;
	}

391
	if (skb->len >= hdrlen + mic_len &&
392
	    !(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE))
393
		skb_trim(skb, skb->len - mic_len);
394
	if (skb->len >= hdrlen + iv_len) {
395
		memmove(skb->data + iv_len, skb->data, hdrlen);
396
		hdr = (struct ieee80211_hdr *)skb_pull(skb, iv_len);
397
398
399
	}

no_key:
400
401
402
403
404
	if (ieee80211_is_data_qos(hdr->frame_control)) {
		hdr->frame_control &= ~cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
		memmove(skb->data + IEEE80211_QOS_CTL_LEN, skb->data,
			hdrlen - IEEE80211_QOS_CTL_LEN);
		skb_pull(skb, IEEE80211_QOS_CTL_LEN);
405
406
407
	}
}

408
409
static void ieee80211_handle_filtered_frame(struct ieee80211_local *local,
					    struct sta_info *sta,
410
					    struct sk_buff *skb)
411
412
413
414
415
416
{
	sta->tx_filtered_count++;

	/*
	 * Clear the TX filter mask for this STA when sending the next
	 * packet. If the STA went to power save mode, this will happen
417
	 * when it wakes up for the next time.
418
	 */
419
	set_sta_flags(sta, WLAN_STA_CLEAR_PS_FILT);
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450

	/*
	 * This code races in the following way:
	 *
	 *  (1) STA sends frame indicating it will go to sleep and does so
	 *  (2) hardware/firmware adds STA to filter list, passes frame up
	 *  (3) hardware/firmware processes TX fifo and suppresses a frame
	 *  (4) we get TX status before having processed the frame and
	 *	knowing that the STA has gone to sleep.
	 *
	 * This is actually quite unlikely even when both those events are
	 * processed from interrupts coming in quickly after one another or
	 * even at the same time because we queue both TX status events and
	 * RX frames to be processed by a tasklet and process them in the
	 * same order that they were received or TX status last. Hence, there
	 * is no race as long as the frame RX is processed before the next TX
	 * status, which drivers can ensure, see below.
	 *
	 * Note that this can only happen if the hardware or firmware can
	 * actually add STAs to the filter list, if this is done by the
	 * driver in response to set_tim() (which will only reduce the race
	 * this whole filtering tries to solve, not completely solve it)
	 * this situation cannot happen.
	 *
	 * To completely solve this race drivers need to make sure that they
	 *  (a) don't mix the irq-safe/not irq-safe TX status/RX processing
	 *	functions and
	 *  (b) always process RX events before TX status events if ordering
	 *      can be unknown, for example with different interrupt status
	 *	bits.
	 */
451
	if (test_sta_flags(sta, WLAN_STA_PS) &&
452
	    skb_queue_len(&sta->tx_filtered) < STA_MAX_TX_BUFFER) {
453
		ieee80211_remove_tx_extra(local, sta->key, skb);
454
455
456
457
		skb_queue_tail(&sta->tx_filtered, skb);
		return;
	}

Sujith's avatar
Sujith committed
458
	if (!test_sta_flags(sta, WLAN_STA_PS) && !skb->requeue) {
459
		/* Software retry the packet once */
Sujith's avatar
Sujith committed
460
		skb->requeue = 1;
461
		ieee80211_remove_tx_extra(local, sta->key, skb);
462
463
464
465
		dev_queue_xmit(skb);
		return;
	}

466
#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
467
468
469
470
471
	if (net_ratelimit())
		printk(KERN_DEBUG "%s: dropped TX filtered frame, "
		       "queue_len=%d PS=%d @%lu\n",
		       wiphy_name(local->hw.wiphy),
		       skb_queue_len(&sta->tx_filtered),
472
		       !!test_sta_flags(sta, WLAN_STA_PS), jiffies);
473
#endif
474
475
476
	dev_kfree_skb(skb);
}

477
void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb)
478
479
480
481
{
	struct sk_buff *skb2;
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
	struct ieee80211_local *local = hw_to_local(hw);
482
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
483
	u16 frag, type;
484
	__le16 fc;
485
	struct ieee80211_supported_band *sband;
486
487
	struct ieee80211_tx_status_rtap_hdr *rthdr;
	struct ieee80211_sub_if_data *sdata;
488
	struct net_device *prev_dev = NULL;
489
	struct sta_info *sta;
490
491
492
493
494
495
496
497
498
499
500
501
502
	int retry_count = -1, i;

	for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
		/* the HW cannot have attempted that rate */
		if (i >= hw->max_rates) {
			info->status.rates[i].idx = -1;
			info->status.rates[i].count = 0;
		}

		retry_count += info->status.rates[i].count;
	}
	if (retry_count < 0)
		retry_count = 0;
503

504
505
	rcu_read_lock();

506
507
	sband = local->hw.wiphy->bands[info->band];

508
509
510
	sta = sta_info_get(local, hdr->addr1);

	if (sta) {
511
		if (!(info->flags & IEEE80211_TX_STAT_ACK) &&
512
513
514
515
516
517
518
519
		    test_sta_flags(sta, WLAN_STA_PS)) {
			/*
			 * The STA is in power save mode, so assume
			 * that this TX packet failed because of that.
			 */
			ieee80211_handle_filtered_frame(local, sta, skb);
			rcu_read_unlock();
			return;
520
521
		}

522
523
524
525
526
527
		fc = hdr->frame_control;

		if ((info->flags & IEEE80211_TX_STAT_AMPDU_NO_BACK) &&
		    (ieee80211_is_data_qos(fc))) {
			u16 tid, ssn;
			u8 *qc;
528
529
530
531
532

			qc = ieee80211_get_qos_ctl(hdr);
			tid = qc[0] & 0xf;
			ssn = ((le16_to_cpu(hdr->seq_ctrl) + 0x10)
						& IEEE80211_SCTL_SEQ);
533
			ieee80211_send_bar(sta->sdata, hdr->addr1,
534
535
536
					   tid, ssn);
		}

537
		if (info->flags & IEEE80211_TX_STAT_TX_FILTERED) {
538
			ieee80211_handle_filtered_frame(local, sta, skb);
539
			rcu_read_unlock();
540
			return;
541
		} else {
542
			if (!(info->flags & IEEE80211_TX_STAT_ACK))
543
				sta->tx_retry_failed++;
544
			sta->tx_retry_count += retry_count;
545
		}
546

547
		rate_control_tx_status(local, sband, sta, skb);
548
	}
549

550
551
	rcu_read_unlock();

552
553
554
555
556
557
558
559
560
561
	ieee80211_led_tx(local, 0);

	/* SNMP counters
	 * Fragments are passed to low-level drivers as separate skbs, so these
	 * are actually fragments, not frames. Update frame counters only for
	 * the first fragment of the frame. */

	frag = le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_FRAG;
	type = le16_to_cpu(hdr->frame_control) & IEEE80211_FCTL_FTYPE;

562
	if (info->flags & IEEE80211_TX_STAT_ACK) {
563
564
565
566
		if (frag == 0) {
			local->dot11TransmittedFrameCount++;
			if (is_multicast_ether_addr(hdr->addr1))
				local->dot11MulticastTransmittedFrameCount++;
567
			if (retry_count > 0)
568
				local->dot11RetryCount++;
569
			if (retry_count > 1)
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
				local->dot11MultipleRetryCount++;
		}

		/* This counter shall be incremented for an acknowledged MPDU
		 * with an individual address in the address 1 field or an MPDU
		 * with a multicast address in the address 1 field of type Data
		 * or Management. */
		if (!is_multicast_ether_addr(hdr->addr1) ||
		    type == IEEE80211_FTYPE_DATA ||
		    type == IEEE80211_FTYPE_MGMT)
			local->dot11TransmittedFragmentCount++;
	} else {
		if (frag == 0)
			local->dot11FailedCount++;
	}

586
587
588
	/* this was a transmitted frame, but now we want to reuse it */
	skb_orphan(skb);

589
590
591
592
593
	/*
	 * This is a bit racy but we can avoid a lot of work
	 * with this test...
	 */
	if (!local->monitors && !local->cooked_mntrs) {
594
595
596
597
		dev_kfree_skb(skb);
		return;
	}

598
	/* send frame to monitor interfaces now */
599

600
601
	if (skb_headroom(skb) < sizeof(*rthdr)) {
		printk(KERN_ERR "ieee80211_tx_status: headroom too small\n");
602
603
604
605
		dev_kfree_skb(skb);
		return;
	}

Johannes Berg's avatar
Johannes Berg committed
606
	rthdr = (struct ieee80211_tx_status_rtap_hdr *)
607
608
609
610
611
612
				skb_push(skb, sizeof(*rthdr));

	memset(rthdr, 0, sizeof(*rthdr));
	rthdr->hdr.it_len = cpu_to_le16(sizeof(*rthdr));
	rthdr->hdr.it_present =
		cpu_to_le32((1 << IEEE80211_RADIOTAP_TX_FLAGS) |
613
614
			    (1 << IEEE80211_RADIOTAP_DATA_RETRIES) |
			    (1 << IEEE80211_RADIOTAP_RATE));
615

616
	if (!(info->flags & IEEE80211_TX_STAT_ACK) &&
617
618
619
	    !is_multicast_ether_addr(hdr->addr1))
		rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_FAIL);

620
621
622
623
624
625
626
	/*
	 * XXX: Once radiotap gets the bitmap reset thing the vendor
	 *	extensions proposal contains, we can actually report
	 *	the whole set of tries we did.
	 */
	if ((info->status.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) ||
	    (info->status.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT))
627
		rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_CTS);
628
	else if (info->status.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS)
629
		rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_RTS);
630
631
632
633
	if (info->status.rates[0].idx >= 0 &&
	    !(info->status.rates[0].flags & IEEE80211_TX_RC_MCS))
		rthdr->rate = sband->bitrates[
				info->status.rates[0].idx].bitrate / 5;
634

635
636
	/* for now report the total retry_count */
	rthdr->data_retries = retry_count;
637

638
639
640
641
642
643
644
	/* XXX: is this sufficient for BPF? */
	skb_set_mac_header(skb, 0);
	skb->ip_summed = CHECKSUM_UNNECESSARY;
	skb->pkt_type = PACKET_OTHERHOST;
	skb->protocol = htons(ETH_P_802_2);
	memset(skb->cb, 0, sizeof(skb->cb));

645
646
	rcu_read_lock();
	list_for_each_entry_rcu(sdata, &local->interfaces, list) {
647
		if (sdata->vif.type == NL80211_IFTYPE_MONITOR) {
648
649
			if (!netif_running(sdata->dev))
				continue;
650
651

			if (prev_dev) {
652
				skb2 = skb_clone(skb, GFP_ATOMIC);
653
654
655
656
657
658
659
				if (skb2) {
					skb2->dev = prev_dev;
					netif_rx(skb2);
				}
			}

			prev_dev = sdata->dev;
660
661
		}
	}
662
663
664
665
666
	if (prev_dev) {
		skb->dev = prev_dev;
		netif_rx(skb);
		skb = NULL;
	}
667
	rcu_read_unlock();
668
	dev_kfree_skb(skb);
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
}
EXPORT_SYMBOL(ieee80211_tx_status);

struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len,
					const struct ieee80211_ops *ops)
{
	struct ieee80211_local *local;
	int priv_size;
	struct wiphy *wiphy;

	/* Ensure 32-byte alignment of our private data and hw private data.
	 * We use the wiphy priv data for both our ieee80211_local and for
	 * the driver's private data
	 *
	 * In memory it'll be like this:
	 *
	 * +-------------------------+
	 * | struct wiphy	    |
	 * +-------------------------+
	 * | struct ieee80211_local  |
	 * +-------------------------+
	 * | driver's private data   |
	 * +-------------------------+
	 *
	 */
	priv_size = ((sizeof(struct ieee80211_local) +
		      NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST) +
		    priv_data_len;

	wiphy = wiphy_new(&mac80211_config_ops, priv_size);

	if (!wiphy)
		return NULL;

	wiphy->privid = mac80211_wiphy_privid;

	local = wiphy_priv(wiphy);
	local->hw.wiphy = wiphy;

	local->hw.priv = (char *)local +
			 ((sizeof(struct ieee80211_local) +
			   NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST);

712
	BUG_ON(!ops->tx);
713
714
	BUG_ON(!ops->start);
	BUG_ON(!ops->stop);
715
716
	BUG_ON(!ops->config);
	BUG_ON(!ops->add_interface);
717
718
	BUG_ON(!ops->remove_interface);
	BUG_ON(!ops->configure_filter);
719
720
	local->ops = ops;

721
722
723
	/* set up some defaults */
	local->hw.queues = 1;
	local->hw.max_rates = 1;
724
725
	local->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;
	local->fragmentation_threshold = IEEE80211_MAX_FRAG_THRESHOLD;
726
727
	local->hw.conf.long_frame_max_tx_count = 4;
	local->hw.conf.short_frame_max_tx_count = 7;
728
	local->hw.conf.radio_enabled = true;
729

730
	INIT_LIST_HEAD(&local->interfaces);
731

732
733
	spin_lock_init(&local->key_lock);

734
	INIT_DELAYED_WORK(&local->scan_work, ieee80211_scan_work);
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757

	sta_info_init(local);

	tasklet_init(&local->tx_pending_tasklet, ieee80211_tx_pending,
		     (unsigned long)local);
	tasklet_disable(&local->tx_pending_tasklet);

	tasklet_init(&local->tasklet,
		     ieee80211_tasklet_handler,
		     (unsigned long) local);
	tasklet_disable(&local->tasklet);

	skb_queue_head_init(&local->skb_queue);
	skb_queue_head_init(&local->skb_queue_unreliable);

	return local_to_hw(local);
}
EXPORT_SYMBOL(ieee80211_alloc_hw);

int ieee80211_register_hw(struct ieee80211_hw *hw)
{
	struct ieee80211_local *local = hw_to_local(hw);
	int result;
758
	enum ieee80211_band band;
759
	struct net_device *mdev;
760
	struct ieee80211_master_priv *mpriv;
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778

	/*
	 * generic code guarantees at least one band,
	 * set this very early because much code assumes
	 * that hw.conf.channel is assigned
	 */
	for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
		struct ieee80211_supported_band *sband;

		sband = local->hw.wiphy->bands[band];
		if (sband) {
			/* init channel we're on */
			local->hw.conf.channel =
			local->oper_channel =
			local->scan_channel = &sband->channels[0];
			break;
		}
	}
779

780
781
782
783
784
785
786
	/* if low-level driver supports AP, we also support VLAN */
	if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_AP))
		local->hw.wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP_VLAN);

	/* mac80211 always supports monitor */
	local->hw.wiphy->interface_modes |= BIT(NL80211_IFTYPE_MONITOR);

787
788
789
790
	result = wiphy_register(local->hw.wiphy);
	if (result < 0)
		return result;

791
792
793
794
795
796
797
798
799
800
801
	/*
	 * We use the number of queues for feature tests (QoS, HT) internally
	 * so restrict them appropriately.
	 */
	if (hw->queues > IEEE80211_MAX_QUEUES)
		hw->queues = IEEE80211_MAX_QUEUES;
	if (hw->ampdu_queues > IEEE80211_MAX_AMPDU_QUEUES)
		hw->ampdu_queues = IEEE80211_MAX_AMPDU_QUEUES;
	if (hw->queues < 4)
		hw->ampdu_queues = 0;

802
	mdev = alloc_netdev_mq(sizeof(struct ieee80211_master_priv),
803
804
			       "wmaster%d", ether_setup,
			       ieee80211_num_queues(hw));
805
806
807
	if (!mdev)
		goto fail_mdev_alloc;

808
809
	mpriv = netdev_priv(mdev);
	mpriv->local = local;
810
811
	local->mdev = mdev;

812
	ieee80211_rx_bss_list_init(local);
813
814
815
816
817
818
819
820

	mdev->hard_start_xmit = ieee80211_master_start_xmit;
	mdev->open = ieee80211_master_open;
	mdev->stop = ieee80211_master_stop;
	mdev->type = ARPHRD_IEEE80211;
	mdev->header_ops = &ieee80211_header_ops;
	mdev->set_multicast_list = ieee80211_master_set_multicast_list;

821
822
	local->hw.workqueue =
		create_freezeable_workqueue(wiphy_name(local->hw.wiphy));
823
824
825
826
827
	if (!local->hw.workqueue) {
		result = -ENOMEM;
		goto fail_workqueue;
	}

828
829
830
831
832
	/*
	 * The hardware needs headroom for sending the frame,
	 * and we need some headroom for passing the frame to monitor
	 * interfaces, but never both at the same time.
	 */
833
834
	local->tx_headroom = max_t(unsigned int , local->hw.extra_tx_headroom,
				   sizeof(struct ieee80211_tx_status_rtap_hdr));
835

836
837
	debugfs_hw_add(local);

838
839
	if (local->hw.conf.beacon_int < 10)
		local->hw.conf.beacon_int = 100;
840

841
842
843
844
845
	if (local->hw.max_listen_interval == 0)
		local->hw.max_listen_interval = 1;

	local->hw.conf.listen_interval = local->hw.max_listen_interval;

846
847
848
	local->wstats_flags |= local->hw.flags & (IEEE80211_HW_SIGNAL_UNSPEC |
						  IEEE80211_HW_SIGNAL_DB |
						  IEEE80211_HW_SIGNAL_DBM) ?
849
			       IW_QUAL_QUAL_UPDATED : IW_QUAL_QUAL_INVALID;
850
	local->wstats_flags |= local->hw.flags & IEEE80211_HW_NOISE_DBM ?
851
			       IW_QUAL_NOISE_UPDATED : IW_QUAL_NOISE_INVALID;
852
	if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
		local->wstats_flags |= IW_QUAL_DBM;

	result = sta_info_start(local);
	if (result < 0)
		goto fail_sta_info;

	rtnl_lock();
	result = dev_alloc_name(local->mdev, local->mdev->name);
	if (result < 0)
		goto fail_dev;

	memcpy(local->mdev->dev_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
	SET_NETDEV_DEV(local->mdev, wiphy_dev(local->hw.wiphy));

	result = register_netdevice(local->mdev);
	if (result < 0)
		goto fail_dev;

871
872
	result = ieee80211_init_rate_ctrl_alg(local,
					      hw->rate_control_algorithm);
873
874
	if (result < 0) {
		printk(KERN_DEBUG "%s: Failed to initialize rate control "
875
		       "algorithm\n", wiphy_name(local->hw.wiphy));
876
877
878
879
880
881
		goto fail_rate;
	}

	result = ieee80211_wep_init(local);

	if (result < 0) {
882
883
		printk(KERN_DEBUG "%s: Failed to initialize wep: %d\n",
		       wiphy_name(local->hw.wiphy), result);
884
885
886
		goto fail_wep;
	}

887
	local->mdev->select_queue = ieee80211_select_queue;
888
889

	/* add one default STA interface */
890
	result = ieee80211_if_add(local, "wlan%d", NULL,
891
				  NL80211_IFTYPE_STATION, NULL);
892
893
	if (result)
		printk(KERN_WARNING "%s: Failed to add default virtual iface\n",
894
		       wiphy_name(local->hw.wiphy));
895
896
897
898
899
900
901
902
903
904
905

	rtnl_unlock();

	ieee80211_led_init(local);

	return 0;

fail_wep:
	rate_control_deinitialize(local);
fail_rate:
	unregister_netdevice(local->mdev);
906
	local->mdev = NULL;
907
908
909
910
fail_dev:
	rtnl_unlock();
	sta_info_stop(local);
fail_sta_info:
911
	debugfs_hw_del(local);
912
913
	destroy_workqueue(local->hw.workqueue);
fail_workqueue:
914
915
	if (local->mdev)
		free_netdev(local->mdev);
916
fail_mdev_alloc:
917
918
919
920
921
922
923
924
925
926
927
928
929
930
	wiphy_unregister(local->hw.wiphy);
	return result;
}
EXPORT_SYMBOL(ieee80211_register_hw);

void ieee80211_unregister_hw(struct ieee80211_hw *hw)
{
	struct ieee80211_local *local = hw_to_local(hw);

	tasklet_kill(&local->tx_pending_tasklet);
	tasklet_kill(&local->tasklet);

	rtnl_lock();

931
932
933
934
935
	/*
	 * At this point, interface list manipulations are fine
	 * because the driver cannot be handing us frames any
	 * more and the tasklet is killed.
	 */
936

937
938
	/* First, we remove all virtual interfaces. */
	ieee80211_remove_interfaces(local);
939
940

	/* then, finally, remove the master interface */
941
	unregister_netdevice(local->mdev);
942
943
944

	rtnl_unlock();

945
	ieee80211_rx_bss_list_deinit(local);
946
947
948
	ieee80211_clear_tx_pending(local);
	sta_info_stop(local);
	rate_control_deinitialize(local);
949
	debugfs_hw_del(local);
950
951
952
953

	if (skb_queue_len(&local->skb_queue)
			|| skb_queue_len(&local->skb_queue_unreliable))
		printk(KERN_WARNING "%s: skb_queue not empty\n",
954
		       wiphy_name(local->hw.wiphy));
955
956
957
958
959
960
961
	skb_queue_purge(&local->skb_queue);
	skb_queue_purge(&local->skb_queue_unreliable);

	destroy_workqueue(local->hw.workqueue);
	wiphy_unregister(local->hw.wiphy);
	ieee80211_wep_free(local);
	ieee80211_led_exit(local);
962
	free_netdev(local->mdev);
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
}
EXPORT_SYMBOL(ieee80211_unregister_hw);

void ieee80211_free_hw(struct ieee80211_hw *hw)
{
	struct ieee80211_local *local = hw_to_local(hw);

	wiphy_free(local->hw.wiphy);
}
EXPORT_SYMBOL(ieee80211_free_hw);

static int __init ieee80211_init(void)
{
	struct sk_buff *skb;
	int ret;

979
980
	BUILD_BUG_ON(sizeof(struct ieee80211_tx_info) > sizeof(skb->cb));
	BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, driver_data) +
Johannes Berg's avatar
Johannes Berg committed
981
		     IEEE80211_TX_INFO_DRIVER_DATA_SIZE > sizeof(skb->cb));
982

983
984
985
986
	ret = rc80211_minstrel_init();
	if (ret)
		return ret;

987
	ret = rc80211_pid_init();
988
	if (ret)
989
		return ret;
990

991
992
	ieee80211_debugfs_netdev_init();

993
994
995
996
997
	return 0;
}

static void __exit ieee80211_exit(void)
{
998
	rc80211_pid_exit();
999
	rc80211_minstrel_exit();
1000

For faster browsing, not all history is shown. View entire blame