main.c 23.1 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/*
 * 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 <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/rtnetlink.h>
#include <linux/bitmap.h>
22
#include <linux/pm_qos_params.h>
23
#include <linux/inetdevice.h>
24
#include <net/net_namespace.h>
25
26
27
#include <net/cfg80211.h>

#include "ieee80211_i.h"
28
#include "driver-ops.h"
Johannes Berg's avatar
Johannes Berg committed
29
#include "rate.h"
30
#include "mesh.h"
31
#include "wep.h"
Johannes Berg's avatar
Johannes Berg committed
32
#include "led.h"
33
#include "cfg.h"
34
#include "debugfs.h"
35

36
37
38
39
40
41

bool ieee80211_disable_40mhz_24ghz;
module_param(ieee80211_disable_40mhz_24ghz, bool, 0644);
MODULE_PARM_DESC(ieee80211_disable_40mhz_24ghz,
		 "Disable 40MHz support in the 2.4GHz band");

42
void ieee80211_configure_filter(struct ieee80211_local *local)
43
{
44
	u64 mc;
45
46
47
	unsigned int changed_flags;
	unsigned int new_flags = 0;

48
	if (atomic_read(&local->iff_promiscs))
49
50
		new_flags |= FIF_PROMISC_IN_BSS;

51
	if (atomic_read(&local->iff_allmultis))
52
53
		new_flags |= FIF_ALLMULTI;

54
	if (local->monitors || local->scanning)
55
56
57
58
59
60
61
62
63
64
65
66
67
		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;
68

69
70
71
	if (local->fif_pspoll)
		new_flags |= FIF_PSPOLL;

72
	spin_lock_bh(&local->filter_lock);
73
74
	changed_flags = local->filter_flags ^ new_flags;

75
	mc = drv_prepare_multicast(local, &local->mc_list);
76
77
	spin_unlock_bh(&local->filter_lock);

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

81
	drv_configure_filter(local, changed_flags, &new_flags, mc);
82
83
84
85
86
87

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

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

88
89
90
91
92
93
94
95
static void ieee80211_reconfig_filter(struct work_struct *work)
{
	struct ieee80211_local *local =
		container_of(work, struct ieee80211_local, reconfig_filter);

	ieee80211_configure_filter(local);
}

96
int ieee80211_hw_config(struct ieee80211_local *local, u32 changed)
97
{
98
	struct ieee80211_channel *chan, *scan_chan;
99
	int ret = 0;
100
	int power;
Sujith's avatar
Sujith committed
101
	enum nl80211_channel_type channel_type;
102
	u32 offchannel_flag;
103

104
105
	might_sleep();

106
107
	scan_chan = local->scan_channel;

108
	offchannel_flag = local->hw.conf.flags & IEEE80211_CONF_OFFCHANNEL;
109
110
	if (scan_chan) {
		chan = scan_chan;
Sujith's avatar
Sujith committed
111
		channel_type = NL80211_CHAN_NO_HT;
112
		local->hw.conf.flags |= IEEE80211_CONF_OFFCHANNEL;
113
114
115
	} else if (local->tmp_channel) {
		chan = scan_chan = local->tmp_channel;
		channel_type = local->tmp_channel_type;
116
		local->hw.conf.flags |= IEEE80211_CONF_OFFCHANNEL;
117
	} else {
118
		chan = local->oper_channel;
119
		channel_type = local->_oper_channel_type;
120
		local->hw.conf.flags &= ~IEEE80211_CONF_OFFCHANNEL;
121
	}
122
	offchannel_flag ^= local->hw.conf.flags & IEEE80211_CONF_OFFCHANNEL;
123

124
	if (offchannel_flag || chan != local->hw.conf.channel ||
125
	    channel_type != local->hw.conf.channel_type) {
126
		local->hw.conf.channel = chan;
127
		local->hw.conf.channel_type = channel_type;
128
129
		changed |= IEEE80211_CONF_CHANGE_CHANNEL;
	}
130

131
132
133
134
135
136
137
138
139
140
141
142
	if (!conf_is_ht(&local->hw.conf)) {
		/*
		 * mac80211.h documents that this is only valid
		 * when the channel is set to an HT type, and
		 * that otherwise STATIC is used.
		 */
		local->hw.conf.smps_mode = IEEE80211_SMPS_STATIC;
	} else if (local->hw.conf.smps_mode != local->smps_mode) {
		local->hw.conf.smps_mode = local->smps_mode;
		changed |= IEEE80211_CONF_CHANGE_SMPS;
	}

143
	if (scan_chan)
144
		power = chan->max_power;
145
	else
146
147
148
149
		power = local->power_constr_level ?
			(chan->max_power - local->power_constr_level) :
			chan->max_power;

150
	if (local->user_power_level >= 0)
151
152
		power = min(power, local->user_power_level);

153
154
155
156
	if (local->hw.conf.power_level != power) {
		changed |= IEEE80211_CONF_CHANGE_POWER;
		local->hw.conf.power_level = power;
	}
157

158
	if (changed && local->open_count) {
159
		ret = drv_config(local, changed);
160
		/*
161
		 * Goal:
162
163
		 * HW reconfiguration should never fail, the driver has told
		 * us what it can support so it should live up to that promise.
164
165
166
167
168
169
170
171
172
		 *
		 * 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
		 *
173
		 */
174
		/* WARN_ON(ret); */
175
	}
176

177
178
	return ret;
}
179

180
181
void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
				      u32 changed)
182
{
183
	struct ieee80211_local *local = sdata->local;
184
	static const u8 zero[ETH_ALEN] = { 0 };
185
186
187
188

	if (!changed)
		return;

189
190
191
192
193
194
195
196
197
198
199
	if (sdata->vif.type == NL80211_IFTYPE_STATION) {
		/*
		 * While not associated, claim a BSSID of all-zeroes
		 * so that drivers don't do any weird things with the
		 * BSSID at that time.
		 */
		if (sdata->vif.bss_conf.assoc)
			sdata->vif.bss_conf.bssid = sdata->u.mgd.bssid;
		else
			sdata->vif.bss_conf.bssid = zero;
	} else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
200
201
		sdata->vif.bss_conf.bssid = sdata->u.ibss.bssid;
	else if (sdata->vif.type == NL80211_IFTYPE_AP)
202
		sdata->vif.bss_conf.bssid = sdata->vif.addr;
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
	else if (ieee80211_vif_is_mesh(&sdata->vif)) {
		sdata->vif.bss_conf.bssid = zero;
	} else {
		WARN_ON(1);
		return;
	}

	switch (sdata->vif.type) {
	case NL80211_IFTYPE_AP:
	case NL80211_IFTYPE_ADHOC:
	case NL80211_IFTYPE_MESH_POINT:
		break;
	default:
		/* do not warn to simplify caller in scan.c */
		changed &= ~BSS_CHANGED_BEACON_ENABLED;
		if (WARN_ON(changed & BSS_CHANGED_BEACON))
			return;
		break;
	}

	if (changed & BSS_CHANGED_BEACON_ENABLED) {
224
		if (local->quiescing || !ieee80211_sdata_running(sdata) ||
225
		    test_bit(SCAN_SW_SCANNING, &local->scanning)) {
226
227
228
229
230
231
232
233
234
			sdata->vif.bss_conf.enable_beacon = false;
		} else {
			/*
			 * Beacon should be enabled, but AP mode must
			 * check whether there is a beacon configured.
			 */
			switch (sdata->vif.type) {
			case NL80211_IFTYPE_AP:
				sdata->vif.bss_conf.enable_beacon =
235
					!!sdata->u.ap.beacon;
236
237
238
				break;
			case NL80211_IFTYPE_ADHOC:
				sdata->vif.bss_conf.enable_beacon =
239
					!!sdata->u.ibss.presp;
240
241
242
243
244
245
246
247
248
249
250
251
				break;
			case NL80211_IFTYPE_MESH_POINT:
				sdata->vif.bss_conf.enable_beacon = true;
				break;
			default:
				/* not reached */
				WARN_ON(1);
				break;
			}
		}
	}

Johannes Berg's avatar
Johannes Berg committed
252
	drv_bss_info_changed(local, sdata, &sdata->vif.bss_conf, changed);
253
254
}

255
u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata)
256
{
257
258
259
	sdata->vif.bss_conf.use_cts_prot = false;
	sdata->vif.bss_conf.use_short_preamble = false;
	sdata->vif.bss_conf.use_short_slot = false;
260
261
262
	return BSS_CHANGED_ERP_CTS_PROT |
	       BSS_CHANGED_ERP_PREAMBLE |
	       BSS_CHANGED_ERP_SLOT;
263
264
}

265
266
267
268
269
270
271
272
273
static void ieee80211_tasklet_handler(unsigned long data)
{
	struct ieee80211_local *local = (struct ieee80211_local *) data;
	struct sk_buff *skb;

	while ((skb = skb_dequeue(&local->skb_queue)) ||
	       (skb = skb_dequeue(&local->skb_queue_unreliable))) {
		switch (skb->pkt_type) {
		case IEEE80211_RX_MSG:
274
			/* Clear skb->pkt_type in order to not confuse kernel
275
276
			 * netstack. */
			skb->pkt_type = 0;
277
			ieee80211_rx(local_to_hw(local), skb);
278
279
280
			break;
		case IEEE80211_TX_STATUS_MSG:
			skb->pkt_type = 0;
281
			ieee80211_tx_status(local_to_hw(local), skb);
282
			break;
283
		default:
284
285
			WARN(1, "mac80211: Packet is of unknown type %d\n",
			     skb->pkt_type);
286
287
288
289
290
291
			dev_kfree_skb(skb);
			break;
		}
	}
}

292
293
294
295
296
297
298
299
300
301
302
303
304
305
static void ieee80211_restart_work(struct work_struct *work)
{
	struct ieee80211_local *local =
		container_of(work, struct ieee80211_local, restart_work);

	rtnl_lock();
	ieee80211_reconfig(local);
	rtnl_unlock();
}

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

Johannes Berg's avatar
Johannes Berg committed
306
307
	trace_api_restart_hw(local);

308
309
310
311
312
313
314
315
	/* use this reason, __ieee80211_resume will unblock it */
	ieee80211_stop_queues_by_reason(hw,
		IEEE80211_QUEUE_STOP_REASON_SUSPEND);

	schedule_work(&local->restart_work);
}
EXPORT_SYMBOL(ieee80211_restart_hw);

316
317
318
319
320
321
322
323
324
325
static void ieee80211_recalc_smps_work(struct work_struct *work)
{
	struct ieee80211_local *local =
		container_of(work, struct ieee80211_local, recalc_smps);

	mutex_lock(&local->iflist_mtx);
	ieee80211_recalc_smps(local, NULL);
	mutex_unlock(&local->iflist_mtx);
}

326
#ifdef CONFIG_INET
327
328
329
330
331
332
333
334
335
static int ieee80211_ifa_changed(struct notifier_block *nb,
				 unsigned long data, void *arg)
{
	struct in_ifaddr *ifa = arg;
	struct ieee80211_local *local =
		container_of(nb, struct ieee80211_local,
			     ifa_notifier);
	struct net_device *ndev = ifa->ifa_dev->dev;
	struct wireless_dev *wdev = ndev->ieee80211_ptr;
336
	struct in_device *idev;
337
	struct ieee80211_sub_if_data *sdata;
338
	struct ieee80211_bss_conf *bss_conf;
339
	struct ieee80211_if_managed *ifmgd;
340
	int c = 0;
341

342
343
344
	if (!netif_running(ndev))
		return NOTIFY_DONE;

345
346
347
348
349
350
351
352
	/* Make sure it's our interface that got changed */
	if (!wdev)
		return NOTIFY_DONE;

	if (wdev->wiphy != local->hw.wiphy)
		return NOTIFY_DONE;

	sdata = IEEE80211_DEV_TO_SUB_IF(ndev);
353
	bss_conf = &sdata->vif.bss_conf;
354
355
356
357
358

	/* ARP filtering is only supported in managed mode */
	if (sdata->vif.type != NL80211_IFTYPE_STATION)
		return NOTIFY_DONE;

359
360
361
362
	idev = sdata->dev->ip_ptr;
	if (!idev)
		return NOTIFY_DONE;

363
364
	ifmgd = &sdata->u.mgd;
	mutex_lock(&ifmgd->mtx);
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389

	/* Copy the addresses to the bss_conf list */
	ifa = idev->ifa_list;
	while (c < IEEE80211_BSS_ARP_ADDR_LIST_LEN && ifa) {
		bss_conf->arp_addr_list[c] = ifa->ifa_address;
		ifa = ifa->ifa_next;
		c++;
	}

	/* If not all addresses fit the list, disable filtering */
	if (ifa) {
		sdata->arp_filter_state = false;
		c = 0;
	} else {
		sdata->arp_filter_state = true;
	}
	bss_conf->arp_addr_cnt = c;

	/* Configure driver only if associated */
	if (ifmgd->associated) {
		bss_conf->arp_filter_enabled = sdata->arp_filter_state;
		ieee80211_bss_info_change_notify(sdata,
						 BSS_CHANGED_ARP_FILTER);
	}

390
391
392
393
	mutex_unlock(&ifmgd->mtx);

	return NOTIFY_DONE;
}
394
#endif
395

396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
static int ieee80211_napi_poll(struct napi_struct *napi, int budget)
{
	struct ieee80211_local *local =
		container_of(napi, struct ieee80211_local, napi);

	return local->ops->napi_poll(&local->hw, budget);
}

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

	napi_schedule(&local->napi);
}
EXPORT_SYMBOL(ieee80211_napi_schedule);

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

	napi_complete(&local->napi);
}
EXPORT_SYMBOL(ieee80211_napi_complete);

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
451
452
453
454
/* There isn't a lot of sense in it, but you can transmit anything you like */
static const struct ieee80211_txrx_stypes
ieee80211_default_mgmt_stypes[NUM_NL80211_IFTYPES] = {
	[NL80211_IFTYPE_ADHOC] = {
		.tx = 0xffff,
		.rx = BIT(IEEE80211_STYPE_ACTION >> 4),
	},
	[NL80211_IFTYPE_STATION] = {
		.tx = 0xffff,
		.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
			BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
	},
	[NL80211_IFTYPE_AP] = {
		.tx = 0xffff,
		.rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
			BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
			BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
			BIT(IEEE80211_STYPE_DISASSOC >> 4) |
			BIT(IEEE80211_STYPE_AUTH >> 4) |
			BIT(IEEE80211_STYPE_DEAUTH >> 4) |
			BIT(IEEE80211_STYPE_ACTION >> 4),
	},
	[NL80211_IFTYPE_AP_VLAN] = {
		/* copy AP */
		.tx = 0xffff,
		.rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
			BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
			BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
			BIT(IEEE80211_STYPE_DISASSOC >> 4) |
			BIT(IEEE80211_STYPE_AUTH >> 4) |
			BIT(IEEE80211_STYPE_DEAUTH >> 4) |
			BIT(IEEE80211_STYPE_ACTION >> 4),
	},
};

455
456
457
458
struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len,
					const struct ieee80211_ops *ops)
{
	struct ieee80211_local *local;
459
	int priv_size, i;
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
	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   |
	 * +-------------------------+
	 *
	 */
477
	priv_size = ALIGN(sizeof(*local), NETDEV_ALIGN) + priv_data_len;
478
479
480
481
482
483

	wiphy = wiphy_new(&mac80211_config_ops, priv_size);

	if (!wiphy)
		return NULL;

484
485
	wiphy->mgmt_stypes = ieee80211_default_mgmt_stypes;

486
487
488
	wiphy->flags |= WIPHY_FLAG_NETNS_OK |
			WIPHY_FLAG_4ADDR_AP |
			WIPHY_FLAG_4ADDR_STATION;
489
	wiphy->privid = mac80211_wiphy_privid;
490

491
	wiphy->bss_priv_size = sizeof(struct ieee80211_bss);
492
493

	local = wiphy_priv(wiphy);
494

495
496
	local->hw.wiphy = wiphy;

497
	local->hw.priv = (char *)local + ALIGN(sizeof(*local), NETDEV_ALIGN);
498

499
	BUG_ON(!ops->tx);
500
501
	BUG_ON(!ops->start);
	BUG_ON(!ops->stop);
502
503
	BUG_ON(!ops->config);
	BUG_ON(!ops->add_interface);
504
505
	BUG_ON(!ops->remove_interface);
	BUG_ON(!ops->configure_filter);
506
507
	local->ops = ops;

508
509
510
	/* set up some defaults */
	local->hw.queues = 1;
	local->hw.max_rates = 1;
511
512
	local->hw.conf.long_frame_max_tx_count = wiphy->retry_long;
	local->hw.conf.short_frame_max_tx_count = wiphy->retry_short;
513
	local->user_power_level = -1;
514
515
	local->uapsd_queues = IEEE80211_DEFAULT_UAPSD_QUEUES;
	local->uapsd_max_sp_len = IEEE80211_DEFAULT_MAX_SP_LEN;
516

517
	INIT_LIST_HEAD(&local->interfaces);
518
519
520

	__hw_addr_init(&local->mc_list);

521
	mutex_init(&local->iflist_mtx);
522
	mutex_init(&local->mtx);
523

Johannes Berg's avatar
Johannes Berg committed
524
	mutex_init(&local->key_mtx);
Johannes Berg's avatar
Johannes Berg committed
525
	spin_lock_init(&local->filter_lock);
526
527
	spin_lock_init(&local->queue_stop_reason_lock);

528
	INIT_DELAYED_WORK(&local->scan_work, ieee80211_scan_work);
529

530
531
	ieee80211_work_init(local);

532
533
	INIT_WORK(&local->restart_work, ieee80211_restart_work);

534
	INIT_WORK(&local->reconfig_filter, ieee80211_reconfig_filter);
535
536
	INIT_WORK(&local->recalc_smps, ieee80211_recalc_smps_work);
	local->smps_mode = IEEE80211_SMPS_OFF;
537

538
539
540
541
542
543
544
	INIT_WORK(&local->dynamic_ps_enable_work,
		  ieee80211_dynamic_ps_enable_work);
	INIT_WORK(&local->dynamic_ps_disable_work,
		  ieee80211_dynamic_ps_disable_work);
	setup_timer(&local->dynamic_ps_timer,
		    ieee80211_dynamic_ps_timer, (unsigned long) local);

545
546
	sta_info_init(local);

547
	for (i = 0; i < IEEE80211_MAX_QUEUES; i++) {
548
		skb_queue_head_init(&local->pending[i]);
549
550
		atomic_set(&local->agg_queue_stop[i], 0);
	}
551
552
553
554
555
556
557
558
559
560
	tasklet_init(&local->tx_pending_tasklet, ieee80211_tx_pending,
		     (unsigned long)local);

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

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

561
562
563
	/* init dummy netdev for use w/ NAPI */
	init_dummy_netdev(&local->napi_dev);

564
565
566
567
568
569
570
571
	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;
572
	enum ieee80211_band band;
573
	int channels, max_bitrates;
574
	bool supp_ht;
575
	static const u32 cipher_suites[] = {
576
		/* keep WEP first, it may be removed below */
577
578
579
580
581
582
583
584
		WLAN_CIPHER_SUITE_WEP40,
		WLAN_CIPHER_SUITE_WEP104,
		WLAN_CIPHER_SUITE_TKIP,
		WLAN_CIPHER_SUITE_CCMP,

		/* keep last -- depends on hw flags! */
		WLAN_CIPHER_SUITE_AES_CMAC
	};
585
586
587
588
589
590

	/*
	 * generic code guarantees at least one band,
	 * set this very early because much code assumes
	 * that hw.conf.channel is assigned
	 */
591
	channels = 0;
592
	max_bitrates = 0;
593
	supp_ht = false;
594
595
596
597
	for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
		struct ieee80211_supported_band *sband;

		sband = local->hw.wiphy->bands[band];
598
599
600
		if (!sband)
			continue;
		if (!local->oper_channel) {
601
602
			/* init channel we're on */
			local->hw.conf.channel =
603
604
			local->oper_channel = &sband->channels[0];
			local->hw.conf.channel_type = NL80211_CHAN_NO_HT;
605
		}
606
607
608
609
		channels += sband->n_channels;

		if (max_bitrates < sband->n_bitrates)
			max_bitrates = sband->n_bitrates;
610
		supp_ht = supp_ht || sband->ht_cap.ht_supported;
611
	}
612

613
614
615
	local->int_scan_req = kzalloc(sizeof(*local->int_scan_req) +
				      sizeof(void *) * channels, GFP_KERNEL);
	if (!local->int_scan_req)
616
617
		return -ENOMEM;

618
619
620
621
622
623
624
	/* 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);

Johannes Berg's avatar
Johannes Berg committed
625
626
627
628
629
	if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
		local->hw.wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
	else if (local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC)
		local->hw.wiphy->signal_type = CFG80211_SIGNAL_TYPE_UNSPEC;

630
631
632
633
	WARN((local->hw.flags & IEEE80211_HW_SUPPORTS_UAPSD)
	     && (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK),
	     "U-APSD not supported with HW_PS_NULLFUNC_STACK\n");

634
635
636
637
638
639
640
	/*
	 * Calculate scan IE length -- we need this to alloc
	 * memory and to subtract from the driver limit. It
	 * includes the (extended) supported rates and HT
	 * information -- SSID is the driver's responsibility.
	 */
	local->scan_ies_len = 4 + max_bitrates; /* (ext) supp rates */
641
642
	if (supp_ht)
		local->scan_ies_len += 2 + sizeof(struct ieee80211_ht_cap);
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659

	if (!local->ops->hw_scan) {
		/* For hw_scan, driver needs to set these up. */
		local->hw.wiphy->max_scan_ssids = 4;
		local->hw.wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN;
	}

	/*
	 * If the driver supports any scan IEs, then assume the
	 * limit includes the IEs mac80211 will add, otherwise
	 * leave it at zero and let the driver sort it out; we
	 * still pass our IEs to the driver but userspace will
	 * not be allowed to in that case.
	 */
	if (local->hw.wiphy->max_scan_ie_len)
		local->hw.wiphy->max_scan_ie_len -= local->scan_ies_len;

660
661
662
663
	local->hw.wiphy->cipher_suites = cipher_suites;
	local->hw.wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
	if (!(local->hw.flags & IEEE80211_HW_MFP_CAPABLE))
		local->hw.wiphy->n_cipher_suites--;
664
665
666
667
	if (IS_ERR(local->wep_tx_tfm) || IS_ERR(local->wep_rx_tfm)) {
		local->hw.wiphy->cipher_suites += 2;
		local->hw.wiphy->n_cipher_suites -= 2;
	}
668

669
670
	result = wiphy_register(local->hw.wiphy);
	if (result < 0)
671
		goto fail_wiphy_register;
672

673
674
675
676
677
678
679
	/*
	 * 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;

680
	local->workqueue =
681
		create_singlethread_workqueue(wiphy_name(local->hw.wiphy));
682
	if (!local->workqueue) {
683
684
685
686
		result = -ENOMEM;
		goto fail_workqueue;
	}

687
688
689
690
691
	/*
	 * 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.
	 */
692
693
	BUILD_BUG_ON(IEEE80211_TX_STATUS_HEADROOM !=
			sizeof(struct ieee80211_tx_status_rtap_hdr));
694
695
	local->tx_headroom = max_t(unsigned int , local->hw.extra_tx_headroom,
				   sizeof(struct ieee80211_tx_status_rtap_hdr));
696

697
698
	debugfs_hw_add(local);

699
700
701
702
	/*
	 * if the driver doesn't specify a max listen interval we
	 * use 5 which should be a safe default
	 */
703
	if (local->hw.max_listen_interval == 0)
704
		local->hw.max_listen_interval = 5;
705
706
707

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

708
	local->dynamic_ps_forced_timeout = -1;
709

710
711
712
713
	result = sta_info_start(local);
	if (result < 0)
		goto fail_sta_info;

714
	result = ieee80211_wep_init(local);
715
	if (result < 0)
Joe Perches's avatar
Joe Perches committed
716
717
		wiphy_debug(local->hw.wiphy, "Failed to initialize wep: %d\n",
			    result);
718

719
720
	rtnl_lock();

721
722
	result = ieee80211_init_rate_ctrl_alg(local,
					      hw->rate_control_algorithm);
723
	if (result < 0) {
Joe Perches's avatar
Joe Perches committed
724
725
		wiphy_debug(local->hw.wiphy,
			    "Failed to initialize rate control algorithm\n");
726
727
728
		goto fail_rate;
	}

729
730
731
732
733
	/* add one default STA interface if supported */
	if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_STATION)) {
		result = ieee80211_if_add(local, "wlan%d", NULL,
					  NL80211_IFTYPE_STATION, NULL);
		if (result)
Joe Perches's avatar
Joe Perches committed
734
735
			wiphy_warn(local->hw.wiphy,
				   "Failed to add default virtual iface\n");
736
	}
737
738
739
740
741

	rtnl_unlock();

	ieee80211_led_init(local);

742
743
744
745
746
747
748
749
750
	local->network_latency_notifier.notifier_call =
		ieee80211_max_network_latency;
	result = pm_qos_add_notifier(PM_QOS_NETWORK_LATENCY,
				     &local->network_latency_notifier);
	if (result) {
		rtnl_lock();
		goto fail_pm_qos;
	}

751
#ifdef CONFIG_INET
752
753
754
755
	local->ifa_notifier.notifier_call = ieee80211_ifa_changed;
	result = register_inetaddr_notifier(&local->ifa_notifier);
	if (result)
		goto fail_ifa;
756
#endif
757

758
759
760
	netif_napi_add(&local->napi_dev, &local->napi, ieee80211_napi_poll,
			local->hw.napi_weight);

761
762
	return 0;

763
#ifdef CONFIG_INET
764
765
766
767
 fail_ifa:
	pm_qos_remove_notifier(PM_QOS_NETWORK_LATENCY,
			       &local->network_latency_notifier);
	rtnl_lock();
768
#endif
769
770
771
772
 fail_pm_qos:
	ieee80211_led_exit(local);
	ieee80211_remove_interfaces(local);
 fail_rate:
773
	rtnl_unlock();
774
	ieee80211_wep_free(local);
775
	sta_info_stop(local);
776
 fail_sta_info:
777
	destroy_workqueue(local->workqueue);
778
 fail_workqueue:
779
	wiphy_unregister(local->hw.wiphy);
780
 fail_wiphy_register:
781
	kfree(local->int_scan_req);
782
783
784
785
786
787
788
789
790
791
792
	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);

793
794
	pm_qos_remove_notifier(PM_QOS_NETWORK_LATENCY,
			       &local->network_latency_notifier);
795
#ifdef CONFIG_INET
796
	unregister_inetaddr_notifier(&local->ifa_notifier);
797
#endif
798

799
800
	rtnl_lock();

801
802
803
804
805
	/*
	 * At this point, interface list manipulations are fine
	 * because the driver cannot be handing us frames any
	 * more and the tasklet is killed.
	 */
806
	ieee80211_remove_interfaces(local);
807

808
809
	rtnl_unlock();

810
	cancel_work_sync(&local->restart_work);
811
812
	cancel_work_sync(&local->reconfig_filter);

813
814
815
816
	ieee80211_clear_tx_pending(local);
	sta_info_stop(local);
	rate_control_deinitialize(local);

817
818
	if (skb_queue_len(&local->skb_queue) ||
	    skb_queue_len(&local->skb_queue_unreliable))
Joe Perches's avatar
Joe Perches committed
819
		wiphy_warn(local->hw.wiphy, "skb_queue not empty\n");
820
821
822
	skb_queue_purge(&local->skb_queue);
	skb_queue_purge(&local->skb_queue_unreliable);

823
	destroy_workqueue(local->workqueue);
824
825
826
	wiphy_unregister(local->hw.wiphy);
	ieee80211_wep_free(local);
	ieee80211_led_exit(local);
827
	kfree(local->int_scan_req);
828
829
830
831
832
833
834
}
EXPORT_SYMBOL(ieee80211_unregister_hw);

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

835
	mutex_destroy(&local->iflist_mtx);
836
	mutex_destroy(&local->mtx);
837

838
839
840
841
842
843
844
845
846
	wiphy_free(local->hw.wiphy);
}
EXPORT_SYMBOL(ieee80211_free_hw);

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

847
848
	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
849
		     IEEE80211_TX_INFO_DRIVER_DATA_SIZE > sizeof(skb->cb));
850

851
852
853
854
	ret = rc80211_minstrel_init();
	if (ret)
		return ret;

855
856
857
858
	ret = rc80211_minstrel_ht_init();
	if (ret)
		goto err_minstrel;

859
	ret = rc80211_pid_init();
860
	if (ret)
861
		goto err_pid;
862

863
864
865
	ret = ieee80211_iface_init();
	if (ret)
		goto err_netdev;
866

867
	return 0;
868
869
870
 err_netdev:
	rc80211_pid_exit();
 err_pid:
871
872
	rc80211_minstrel_ht_exit();
 err_minstrel:
873
874
875
	rc80211_minstrel_exit();

	return ret;
876
877
878
879
}

static void __exit ieee80211_exit(void)
{
880
	rc80211_pid_exit();
881
	rc80211_minstrel_ht_exit();
882
	rc80211_minstrel_exit();
883

884
885
886
887
888
889
	/*
	 * For key todo, it'll be empty by now but the work
	 * might still be scheduled.
	 */
	flush_scheduled_work();

890
891
	if (mesh_allocated)
		ieee80211s_stop();
Johannes Berg's avatar
Johannes Berg committed
892

893
	ieee80211_iface_exit();
894
895
896
}


897
subsys_initcall(ieee80211_init);
898
899
900
901
module_exit(ieee80211_exit);

MODULE_DESCRIPTION("IEEE 802.11 subsystem");
MODULE_LICENSE("GPL");