main.c 29.4 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.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"
J
Johannes Berg 已提交
29
#include "rate.h"
30
#include "mesh.h"
31
#include "wep.h"
J
Johannes Berg 已提交
32
#include "led.h"
33
#include "cfg.h"
J
Jiri Benc 已提交
34
#include "debugfs.h"
35

J
Johannes Berg 已提交
36 37
static struct lock_class_key ieee80211_rx_skb_queue_class;

38
void ieee80211_configure_filter(struct ieee80211_local *local)
39
{
40
	u64 mc;
41 42 43
	unsigned int changed_flags;
	unsigned int new_flags = 0;

44
	if (atomic_read(&local->iff_promiscs))
45 46
		new_flags |= FIF_PROMISC_IN_BSS;

47
	if (atomic_read(&local->iff_allmultis))
48 49
		new_flags |= FIF_ALLMULTI;

50
	if (local->monitors || test_bit(SCAN_SW_SCANNING, &local->scanning))
51 52
		new_flags |= FIF_BCN_PRBRESP_PROMISC;

53 54 55
	if (local->fif_probe_req || local->probe_req_reg)
		new_flags |= FIF_PROBE_REQ;

56 57 58 59 60 61 62 63 64 65 66
	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;
67

I
Igor Perminov 已提交
68 69 70
	if (local->fif_pspoll)
		new_flags |= FIF_PSPOLL;

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

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

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

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

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

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

87 88 89 90 91 92 93 94
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);
}

95
int ieee80211_hw_config(struct ieee80211_local *local, u32 changed)
96
{
97
	struct ieee80211_channel *chan;
98
	int ret = 0;
99
	int power;
S
Sujith 已提交
100
	enum nl80211_channel_type channel_type;
101
	u32 offchannel_flag;
102

103 104
	might_sleep();

105 106 107
	/* If this off-channel logic ever changes,  ieee80211_on_oper_channel
	 * may need to change as well.
	 */
108
	offchannel_flag = local->hw.conf.flags & IEEE80211_CONF_OFFCHANNEL;
109 110
	if (local->scan_channel) {
		chan = local->scan_channel;
111 112 113 114 115 116 117
		/* If scanning on oper channel, use whatever channel-type
		 * is currently in use.
		 */
		if (chan == local->oper_channel)
			channel_type = local->_oper_channel_type;
		else
			channel_type = NL80211_CHAN_NO_HT;
118
	} else if (local->tmp_channel) {
119
		chan = local->tmp_channel;
120
		channel_type = local->tmp_channel_type;
121
	} else {
122
		chan = local->oper_channel;
123
		channel_type = local->_oper_channel_type;
124
	}
125 126 127 128 129 130 131

	if (chan != local->oper_channel ||
	    channel_type != local->_oper_channel_type)
		local->hw.conf.flags |= IEEE80211_CONF_OFFCHANNEL;
	else
		local->hw.conf.flags &= ~IEEE80211_CONF_OFFCHANNEL;

132
	offchannel_flag ^= local->hw.conf.flags & IEEE80211_CONF_OFFCHANNEL;
133

134
	if (offchannel_flag || chan != local->hw.conf.channel ||
135
	    channel_type != local->hw.conf.channel_type) {
136
		local->hw.conf.channel = chan;
137
		local->hw.conf.channel_type = channel_type;
138 139
		changed |= IEEE80211_CONF_CHANGE_CHANNEL;
	}
140

141 142 143 144 145 146 147 148 149 150 151 152
	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;
	}

153 154
	if (test_bit(SCAN_SW_SCANNING, &local->scanning) ||
	    test_bit(SCAN_HW_SCANNING, &local->scanning))
155
		power = chan->max_power;
156
	else
157 158 159 160
		power = local->power_constr_level ?
			(chan->max_power - local->power_constr_level) :
			chan->max_power;

161
	if (local->user_power_level >= 0)
162 163
		power = min(power, local->user_power_level);

164 165 166 167
	if (local->hw.conf.power_level != power) {
		changed |= IEEE80211_CONF_CHANGE_POWER;
		local->hw.conf.power_level = power;
	}
168

169
	if (changed && local->open_count) {
170
		ret = drv_config(local, changed);
171
		/*
172
		 * Goal:
173 174
		 * HW reconfiguration should never fail, the driver has told
		 * us what it can support so it should live up to that promise.
175 176 177 178 179 180 181 182 183
		 *
		 * 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
		 *
184
		 */
185
		/* WARN_ON(ret); */
186
	}
187

188 189
	return ret;
}
190

191 192
void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
				      u32 changed)
193
{
194
	struct ieee80211_local *local = sdata->local;
195
	static const u8 zero[ETH_ALEN] = { 0 };
196 197 198 199

	if (!changed)
		return;

200 201 202 203 204 205 206 207 208 209 210
	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)
211 212
		sdata->vif.bss_conf.bssid = sdata->u.ibss.bssid;
	else if (sdata->vif.type == NL80211_IFTYPE_AP)
213
		sdata->vif.bss_conf.bssid = sdata->vif.addr;
B
Bill Jordan 已提交
214 215
	else if (sdata->vif.type == NL80211_IFTYPE_WDS)
		sdata->vif.bss_conf.bssid = NULL;
216 217 218 219 220 221 222 223 224 225
	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:
B
Bill Jordan 已提交
226
	case NL80211_IFTYPE_WDS:
227 228 229 230 231 232 233 234 235 236 237
	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) {
238
		if (local->quiescing || !ieee80211_sdata_running(sdata) ||
239
		    test_bit(SDATA_STATE_OFFCHANNEL, &sdata->state)) {
240 241 242 243 244 245 246 247 248
			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 =
249
					!!sdata->u.ap.beacon;
250 251 252
				break;
			case NL80211_IFTYPE_ADHOC:
				sdata->vif.bss_conf.enable_beacon =
253
					!!sdata->u.ibss.presp;
254
				break;
255
#ifdef CONFIG_MAC80211_MESH
256
			case NL80211_IFTYPE_MESH_POINT:
257 258
				sdata->vif.bss_conf.enable_beacon =
					!!sdata->u.mesh.mesh_id_len;
259
				break;
260
#endif
261 262 263 264 265 266 267 268
			default:
				/* not reached */
				WARN_ON(1);
				break;
			}
		}
	}

J
Johannes Berg 已提交
269
	drv_bss_info_changed(local, sdata, &sdata->vif.bss_conf, changed);
270 271
}

272
u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata)
273
{
J
Johannes Berg 已提交
274 275 276
	sdata->vif.bss_conf.use_cts_prot = false;
	sdata->vif.bss_conf.use_short_preamble = false;
	sdata->vif.bss_conf.use_short_slot = false;
J
Johannes Berg 已提交
277 278 279
	return BSS_CHANGED_ERP_CTS_PROT |
	       BSS_CHANGED_ERP_PREAMBLE |
	       BSS_CHANGED_ERP_SLOT;
280 281
}

282 283 284
static void ieee80211_tasklet_handler(unsigned long data)
{
	struct ieee80211_local *local = (struct ieee80211_local *) data;
285 286
	struct sta_info *sta, *tmp;
	struct skb_eosp_msg_data *eosp_data;
287 288 289 290 291 292
	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:
293
			/* Clear skb->pkt_type in order to not confuse kernel
294 295
			 * netstack. */
			skb->pkt_type = 0;
296
			ieee80211_rx(local_to_hw(local), skb);
297 298 299
			break;
		case IEEE80211_TX_STATUS_MSG:
			skb->pkt_type = 0;
300
			ieee80211_tx_status(local_to_hw(local), skb);
301
			break;
302 303 304 305 306 307 308 309 310 311 312 313
		case IEEE80211_EOSP_MSG:
			eosp_data = (void *)skb->cb;
			for_each_sta_info(local, eosp_data->sta, sta, tmp) {
				/* skip wrong virtual interface */
				if (memcmp(eosp_data->iface,
					   sta->sdata->vif.addr, ETH_ALEN))
					continue;
				clear_sta_flag(sta, WLAN_STA_SP);
				break;
			}
			dev_kfree_skb(skb);
			break;
314
		default:
315 316
			WARN(1, "mac80211: Packet is of unknown type %d\n",
			     skb->pkt_type);
317 318 319 320 321 322
			dev_kfree_skb(skb);
			break;
		}
	}
}

323 324 325 326 327
static void ieee80211_restart_work(struct work_struct *work)
{
	struct ieee80211_local *local =
		container_of(work, struct ieee80211_local, restart_work);

328 329 330 331
	/* wait for scan work complete */
	flush_workqueue(local->workqueue);

	mutex_lock(&local->mtx);
332 333
	WARN(test_bit(SCAN_HW_SCANNING, &local->scanning) ||
	     local->sched_scanning,
334 335 336
		"%s called with hardware scan in progress\n", __func__);
	mutex_unlock(&local->mtx);

337
	rtnl_lock();
338
	ieee80211_scan_cancel(local);
339 340 341 342 343 344 345 346
	ieee80211_reconfig(local);
	rtnl_unlock();
}

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

J
Johannes Berg 已提交
347 348
	trace_api_restart_hw(local);

349 350 351
	wiphy_info(hw->wiphy,
		   "Hardware restart was requested\n");

352
	/* use this reason, ieee80211_reconfig will unblock it */
353 354 355 356 357 358 359
	ieee80211_stop_queues_by_reason(hw,
		IEEE80211_QUEUE_STOP_REASON_SUSPEND);

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

360 361 362 363 364 365
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);
366
	ieee80211_recalc_smps(local);
367 368 369
	mutex_unlock(&local->iflist_mtx);
}

370
#ifdef CONFIG_INET
371 372 373 374 375 376 377 378 379
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;
380
	struct in_device *idev;
381
	struct ieee80211_sub_if_data *sdata;
382
	struct ieee80211_bss_conf *bss_conf;
383
	struct ieee80211_if_managed *ifmgd;
384
	int c = 0;
385 386 387 388 389 390 391 392 393

	/* 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);
394
	bss_conf = &sdata->vif.bss_conf;
395 396 397 398 399

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

E
Eric Dumazet 已提交
400
	idev = __in_dev_get_rtnl(sdata->dev);
401 402 403
	if (!idev)
		return NOTIFY_DONE;

404 405
	ifmgd = &sdata->u.mgd;
	mutex_lock(&ifmgd->mtx);
406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423

	/* 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;

424
	/* Configure driver only if associated (which also implies it is up) */
425 426 427 428 429 430
	if (ifmgd->associated) {
		bss_conf->arp_filter_enabled = sdata->arp_filter_state;
		ieee80211_bss_info_change_notify(sdata,
						 BSS_CHANGED_ARP_FILTER);
	}

431 432 433 434
	mutex_unlock(&ifmgd->mtx);

	return NOTIFY_DONE;
}
435
#endif
436

437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460
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);

461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491
/* 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) |
492 493 494 495 496 497 498 499 500 501 502 503
			BIT(IEEE80211_STYPE_ACTION >> 4),
	},
	[NL80211_IFTYPE_P2P_CLIENT] = {
		.tx = 0xffff,
		.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
			BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
	},
	[NL80211_IFTYPE_P2P_GO] = {
		.tx = 0xffff,
		.rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
			BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
			BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
504 505 506 507 508
			BIT(IEEE80211_STYPE_DISASSOC >> 4) |
			BIT(IEEE80211_STYPE_AUTH >> 4) |
			BIT(IEEE80211_STYPE_DEAUTH >> 4) |
			BIT(IEEE80211_STYPE_ACTION >> 4),
	},
509 510
	[NL80211_IFTYPE_MESH_POINT] = {
		.tx = 0xffff,
511 512 513
		.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
			BIT(IEEE80211_STYPE_AUTH >> 4) |
			BIT(IEEE80211_STYPE_DEAUTH >> 4),
514
	},
515 516
};

B
Ben Greear 已提交
517 518 519 520 521 522 523 524 525 526 527 528 529
static const struct ieee80211_ht_cap mac80211_ht_capa_mod_mask = {
	.ampdu_params_info = IEEE80211_HT_AMPDU_PARM_FACTOR |
			     IEEE80211_HT_AMPDU_PARM_DENSITY,

	.cap_info = cpu_to_le16(IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
				IEEE80211_HT_CAP_MAX_AMSDU |
				IEEE80211_HT_CAP_SGI_40),
	.mcs = {
		.rx_mask = { 0xff, 0xff, 0xff, 0xff, 0xff,
			     0xff, 0xff, 0xff, 0xff, 0xff, },
	},
};

530 531 532 533
struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len,
					const struct ieee80211_ops *ops)
{
	struct ieee80211_local *local;
534
	int priv_size, i;
535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551
	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   |
	 * +-------------------------+
	 *
	 */
552
	priv_size = ALIGN(sizeof(*local), NETDEV_ALIGN) + priv_data_len;
553 554 555 556 557 558

	wiphy = wiphy_new(&mac80211_config_ops, priv_size);

	if (!wiphy)
		return NULL;

559 560
	wiphy->mgmt_stypes = ieee80211_default_mgmt_stypes;

561 562
	wiphy->privid = mac80211_wiphy_privid;

563 564
	wiphy->flags |= WIPHY_FLAG_NETNS_OK |
			WIPHY_FLAG_4ADDR_AP |
J
Johannes Berg 已提交
565
			WIPHY_FLAG_4ADDR_STATION |
566 567 568
			WIPHY_FLAG_REPORTS_OBSS |
			WIPHY_FLAG_OFFCHAN_TX |
			WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
569

570 571
	wiphy->features = NL80211_FEATURE_SK_TX_STATUS |
			  NL80211_FEATURE_HT_IBSS;
J
Johannes Berg 已提交
572

573 574
	if (!ops->set_key)
		wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
575

576
	wiphy->bss_priv_size = sizeof(struct ieee80211_bss);
577 578

	local = wiphy_priv(wiphy);
579

580 581
	local->hw.wiphy = wiphy;

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

584
	BUG_ON(!ops->tx && !ops->tx_frags);
585 586
	BUG_ON(!ops->start);
	BUG_ON(!ops->stop);
587 588
	BUG_ON(!ops->config);
	BUG_ON(!ops->add_interface);
589 590
	BUG_ON(!ops->remove_interface);
	BUG_ON(!ops->configure_filter);
591 592
	local->ops = ops;

593 594 595
	/* set up some defaults */
	local->hw.queues = 1;
	local->hw.max_rates = 1;
596
	local->hw.max_report_rates = 0;
597
	local->hw.max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF;
598
	local->hw.max_tx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF;
599 600
	local->hw.conf.long_frame_max_tx_count = wiphy->retry_long;
	local->hw.conf.short_frame_max_tx_count = wiphy->retry_short;
601
	local->user_power_level = -1;
602 603
	local->uapsd_queues = IEEE80211_DEFAULT_UAPSD_QUEUES;
	local->uapsd_max_sp_len = IEEE80211_DEFAULT_MAX_SP_LEN;
B
Ben Greear 已提交
604
	wiphy->ht_capa_mod_mask = &mac80211_ht_capa_mod_mask;
605

606
	INIT_LIST_HEAD(&local->interfaces);
607 608 609

	__hw_addr_init(&local->mc_list);

610
	mutex_init(&local->iflist_mtx);
611
	mutex_init(&local->mtx);
612

J
Johannes Berg 已提交
613
	mutex_init(&local->key_mtx);
J
Johannes Berg 已提交
614
	spin_lock_init(&local->filter_lock);
K
Kalle Valo 已提交
615 616
	spin_lock_init(&local->queue_stop_reason_lock);

J
Johannes Berg 已提交
617 618 619 620 621 622 623 624 625
	/*
	 * The rx_skb_queue is only accessed from tasklets,
	 * but other SKB queues are used from within IRQ
	 * context. Therefore, this one needs a different
	 * locking class so our direct, non-irq-safe use of
	 * the queue's lock doesn't throw lockdep warnings.
	 */
	skb_queue_head_init_class(&local->rx_skb_queue,
				  &ieee80211_rx_skb_queue_class);
626

627
	INIT_DELAYED_WORK(&local->scan_work, ieee80211_scan_work);
628

J
Johannes Berg 已提交
629 630
	ieee80211_work_init(local);

631 632
	INIT_WORK(&local->restart_work, ieee80211_restart_work);

633
	INIT_WORK(&local->reconfig_filter, ieee80211_reconfig_filter);
634 635
	INIT_WORK(&local->recalc_smps, ieee80211_recalc_smps_work);
	local->smps_mode = IEEE80211_SMPS_OFF;
636

637 638 639 640 641 642 643
	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);

644 645 646
	INIT_WORK(&local->sched_scan_stopped_work,
		  ieee80211_sched_scan_stopped_work);

J
Johannes Berg 已提交
647 648 649 650 651
	spin_lock_init(&local->ack_status_lock);
	idr_init(&local->ack_status_frames);
	/* preallocate at least one entry */
	idr_pre_get(&local->ack_status_frames, GFP_KERNEL);

652 653
	sta_info_init(local);

654
	for (i = 0; i < IEEE80211_MAX_QUEUES; i++) {
655
		skb_queue_head_init(&local->pending[i]);
656 657
		atomic_set(&local->agg_queue_stop[i], 0);
	}
658 659 660 661 662 663 664 665 666 667
	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);

668 669 670
	/* init dummy netdev for use w/ NAPI */
	init_dummy_netdev(&local->napi_dev);

671 672
	ieee80211_led_names(local);

673 674
	ieee80211_hw_roc_setup(local);

675 676 677 678 679 680 681
	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);
682
	int result, i;
683
	enum ieee80211_band band;
J
Johannes Berg 已提交
684
	int channels, max_bitrates;
685
	bool supp_ht;
686
	static const u32 cipher_suites[] = {
687
		/* keep WEP first, it may be removed below */
688 689 690 691 692 693 694 695
		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
	};
696

697 698 699 700 701
	if ((hw->wiphy->wowlan.flags || hw->wiphy->wowlan.n_patterns)
#ifdef CONFIG_PM
	    && (!local->ops->suspend || !local->ops->resume)
#endif
	    )
702 703
		return -EINVAL;

704 705 706
	if (hw->max_report_rates == 0)
		hw->max_report_rates = hw->max_rates;

707 708 709 710 711
	/*
	 * generic code guarantees at least one band,
	 * set this very early because much code assumes
	 * that hw.conf.channel is assigned
	 */
712
	channels = 0;
713
	max_bitrates = 0;
714
	supp_ht = false;
715 716 717 718
	for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
		struct ieee80211_supported_band *sband;

		sband = local->hw.wiphy->bands[band];
719 720 721
		if (!sband)
			continue;
		if (!local->oper_channel) {
722 723
			/* init channel we're on */
			local->hw.conf.channel =
J
Johannes Berg 已提交
724 725
			local->oper_channel = &sband->channels[0];
			local->hw.conf.channel_type = NL80211_CHAN_NO_HT;
726
		}
727 728 729 730
		channels += sband->n_channels;

		if (max_bitrates < sband->n_bitrates)
			max_bitrates = sband->n_bitrates;
731
		supp_ht = supp_ht || sband->ht_cap.ht_supported;
732
	}
733

734 735 736
	local->int_scan_req = kzalloc(sizeof(*local->int_scan_req) +
				      sizeof(void *) * channels, GFP_KERNEL);
	if (!local->int_scan_req)
737 738
		return -ENOMEM;

739 740 741 742 743 744
	for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
		if (!local->hw.wiphy->bands[band])
			continue;
		local->int_scan_req->rates[band] = (u32) -1;
	}

745
	/* if low-level driver supports AP, we also support VLAN */
746 747 748 749
	if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_AP)) {
		hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP_VLAN);
		hw->wiphy->software_iftypes |= BIT(NL80211_IFTYPE_AP_VLAN);
	}
750 751

	/* mac80211 always supports monitor */
752 753 754
	hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_MONITOR);
	hw->wiphy->software_iftypes |= BIT(NL80211_IFTYPE_MONITOR);

755 756 757 758 759 760 761 762 763 764 765
	/*
	 * mac80211 doesn't support more than 1 channel, and also not more
	 * than one IBSS interface
	 */
	for (i = 0; i < hw->wiphy->n_iface_combinations; i++) {
		const struct ieee80211_iface_combination *c;
		int j;

		c = &hw->wiphy->iface_combinations[i];

		if (c->num_different_channels > 1)
766
			return -EINVAL;
767

768 769 770 771 772 773
		for (j = 0; j < c->n_limits; j++)
			if ((c->limits[j].types & BIT(NL80211_IFTYPE_ADHOC)) &&
			    c->limits[j].max > 1)
				return -EINVAL;
	}

J
Johannes Berg 已提交
774 775 776 777 778
#ifndef CONFIG_MAC80211_MESH
	/* mesh depends on Kconfig, but drivers should set it if they want */
	local->hw.wiphy->interface_modes &= ~BIT(NL80211_IFTYPE_MESH_POINT);
#endif

779 780 781 782 783
	/* if the underlying driver supports mesh, mac80211 will (at least)
	 * provide routing of mesh authentication frames to userspace */
	if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_MESH_POINT))
		local->hw.wiphy->flags |= WIPHY_FLAG_MESH_AUTH;

784 785 786
	/* mac80211 supports control port protocol changing */
	local->hw.wiphy->flags |= WIPHY_FLAG_CONTROL_PORT_PROTOCOL;

J
Johannes Berg 已提交
787 788 789 790 791
	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;

K
Kalle Valo 已提交
792 793 794 795
	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");

796 797 798
	/*
	 * Calculate scan IE length -- we need this to alloc
	 * memory and to subtract from the driver limit. It
799
	 * includes the DS Params, (extended) supported rates, and HT
800 801
	 * information -- SSID is the driver's responsibility.
	 */
802 803
	local->scan_ies_len = 4 + max_bitrates /* (ext) supp rates */ +
		3 /* DS Params */;
804 805
	if (supp_ht)
		local->scan_ies_len += 2 + sizeof(struct ieee80211_ht_cap);
806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822

	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;

823 824 825 826 827 828 829
	/* Set up cipher suites unless driver already did */
	if (!local->hw.wiphy->cipher_suites) {
		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--;
	}
830
	if (IS_ERR(local->wep_tx_tfm) || IS_ERR(local->wep_rx_tfm)) {
831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856
		if (local->hw.wiphy->cipher_suites == cipher_suites) {
			local->hw.wiphy->cipher_suites += 2;
			local->hw.wiphy->n_cipher_suites -= 2;
		} else {
			u32 *suites;
			int r, w = 0;

			/* Filter out WEP */

			suites = kmemdup(
				local->hw.wiphy->cipher_suites,
				sizeof(u32) * local->hw.wiphy->n_cipher_suites,
				GFP_KERNEL);
			if (!suites)
				return -ENOMEM;
			for (r = 0; r < local->hw.wiphy->n_cipher_suites; r++) {
				u32 suite = local->hw.wiphy->cipher_suites[r];
				if (suite == WLAN_CIPHER_SUITE_WEP40 ||
				    suite == WLAN_CIPHER_SUITE_WEP104)
					continue;
				suites[w++] = suite;
			}
			local->hw.wiphy->cipher_suites = suites;
			local->hw.wiphy->n_cipher_suites = w;
			local->wiphy_ciphers_allocated = true;
		}
857
	}
858

859 860
	if (!local->ops->remain_on_channel)
		local->hw.wiphy->max_remain_on_channel_duration = 5000;
861

862 863 864
	if (local->ops->sched_scan_start)
		local->hw.wiphy->flags |= WIPHY_FLAG_SUPPORTS_SCHED_SCAN;

865 866 867 868
	/* mac80211 based drivers don't support internal TDLS setup */
	if (local->hw.wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS)
		local->hw.wiphy->flags |= WIPHY_FLAG_TDLS_EXTERNAL_SETUP;

869 870
	result = wiphy_register(local->hw.wiphy);
	if (result < 0)
871
		goto fail_wiphy_register;
872

873 874 875 876 877 878 879
	/*
	 * 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;

880
	local->workqueue =
881
		alloc_ordered_workqueue(wiphy_name(local->hw.wiphy), 0);
882
	if (!local->workqueue) {
883 884 885 886
		result = -ENOMEM;
		goto fail_workqueue;
	}

887 888 889 890 891
	/*
	 * 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.
	 */
892
	local->tx_headroom = max_t(unsigned int , local->hw.extra_tx_headroom,
893
				   IEEE80211_TX_STATUS_HEADROOM);
894

J
Jiri Benc 已提交
895 896
	debugfs_hw_add(local);

897 898 899 900
	/*
	 * if the driver doesn't specify a max listen interval we
	 * use 5 which should be a safe default
	 */
901
	if (local->hw.max_listen_interval == 0)
902
		local->hw.max_listen_interval = 5;
903 904 905

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

906
	local->dynamic_ps_forced_timeout = -1;
907

908
	result = ieee80211_wep_init(local);
909
	if (result < 0)
J
Joe Perches 已提交
910 911
		wiphy_debug(local->hw.wiphy, "Failed to initialize wep: %d\n",
			    result);
912

913 914
	rtnl_lock();

915 916
	result = ieee80211_init_rate_ctrl_alg(local,
					      hw->rate_control_algorithm);
917
	if (result < 0) {
J
Joe Perches 已提交
918 919
		wiphy_debug(local->hw.wiphy,
			    "Failed to initialize rate control algorithm\n");
920 921 922
		goto fail_rate;
	}

923 924 925 926 927
	/* 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)
J
Joe Perches 已提交
928 929
			wiphy_warn(local->hw.wiphy,
				   "Failed to add default virtual iface\n");
930
	}
931 932 933 934 935

	rtnl_unlock();

	ieee80211_led_init(local);

936 937 938 939 940 941 942 943 944
	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;
	}

945
#ifdef CONFIG_INET
946 947 948 949
	local->ifa_notifier.notifier_call = ieee80211_ifa_changed;
	result = register_inetaddr_notifier(&local->ifa_notifier);
	if (result)
		goto fail_ifa;
950
#endif
951

952 953 954
	netif_napi_add(&local->napi_dev, &local->napi, ieee80211_napi_poll,
			local->hw.napi_weight);

955 956
	return 0;

957
#ifdef CONFIG_INET
958 959 960 961
 fail_ifa:
	pm_qos_remove_notifier(PM_QOS_NETWORK_LATENCY,
			       &local->network_latency_notifier);
	rtnl_lock();
962
#endif
963 964 965 966
 fail_pm_qos:
	ieee80211_led_exit(local);
	ieee80211_remove_interfaces(local);
 fail_rate:
967
	rtnl_unlock();
968
	ieee80211_wep_free(local);
969
	sta_info_stop(local);
970
	destroy_workqueue(local->workqueue);
971
 fail_workqueue:
972
	wiphy_unregister(local->hw.wiphy);
973
 fail_wiphy_register:
974 975
	if (local->wiphy_ciphers_allocated)
		kfree(local->hw.wiphy->cipher_suites);
976
	kfree(local->int_scan_req);
977 978 979 980 981 982 983 984 985 986 987
	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);

988 989
	pm_qos_remove_notifier(PM_QOS_NETWORK_LATENCY,
			       &local->network_latency_notifier);
990
#ifdef CONFIG_INET
991
	unregister_inetaddr_notifier(&local->ifa_notifier);
992
#endif
993

994 995
	rtnl_lock();

996 997 998 999 1000
	/*
	 * At this point, interface list manipulations are fine
	 * because the driver cannot be handing us frames any
	 * more and the tasklet is killed.
	 */
1001
	ieee80211_remove_interfaces(local);
1002

1003 1004
	rtnl_unlock();

J
Johannes Berg 已提交
1005 1006 1007 1008 1009 1010
	/*
	 * Now all work items will be gone, but the
	 * timer might still be armed, so delete it
	 */
	del_timer_sync(&local->work_timer);

1011
	cancel_work_sync(&local->restart_work);
1012 1013
	cancel_work_sync(&local->reconfig_filter);

1014 1015 1016
	ieee80211_clear_tx_pending(local);
	rate_control_deinitialize(local);

1017 1018
	if (skb_queue_len(&local->skb_queue) ||
	    skb_queue_len(&local->skb_queue_unreliable))
J
Joe Perches 已提交
1019
		wiphy_warn(local->hw.wiphy, "skb_queue not empty\n");
1020 1021
	skb_queue_purge(&local->skb_queue);
	skb_queue_purge(&local->skb_queue_unreliable);
1022
	skb_queue_purge(&local->rx_skb_queue);
1023

1024
	destroy_workqueue(local->workqueue);
1025
	wiphy_unregister(local->hw.wiphy);
1026
	sta_info_stop(local);
1027 1028
	ieee80211_wep_free(local);
	ieee80211_led_exit(local);
1029
	kfree(local->int_scan_req);
1030 1031 1032
}
EXPORT_SYMBOL(ieee80211_unregister_hw);

J
Johannes Berg 已提交
1033 1034 1035 1036 1037 1038 1039
static int ieee80211_free_ack_frame(int id, void *p, void *data)
{
	WARN_ONCE(1, "Have pending ack frames!\n");
	kfree_skb(p);
	return 0;
}

1040 1041 1042 1043
void ieee80211_free_hw(struct ieee80211_hw *hw)
{
	struct ieee80211_local *local = hw_to_local(hw);

1044
	mutex_destroy(&local->iflist_mtx);
1045
	mutex_destroy(&local->mtx);
1046

1047 1048 1049
	if (local->wiphy_ciphers_allocated)
		kfree(local->hw.wiphy->cipher_suites);

J
Johannes Berg 已提交
1050 1051 1052 1053
	idr_for_each(&local->ack_status_frames,
		     ieee80211_free_ack_frame, NULL);
	idr_destroy(&local->ack_status_frames);

1054 1055 1056 1057 1058 1059 1060 1061 1062
	wiphy_free(local->hw.wiphy);
}
EXPORT_SYMBOL(ieee80211_free_hw);

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

1063 1064
	BUILD_BUG_ON(sizeof(struct ieee80211_tx_info) > sizeof(skb->cb));
	BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, driver_data) +
J
Johannes Berg 已提交
1065
		     IEEE80211_TX_INFO_DRIVER_DATA_SIZE > sizeof(skb->cb));
1066

1067 1068 1069 1070
	ret = rc80211_minstrel_init();
	if (ret)
		return ret;

1071 1072 1073 1074
	ret = rc80211_minstrel_ht_init();
	if (ret)
		goto err_minstrel;

1075
	ret = rc80211_pid_init();
1076
	if (ret)
1077
		goto err_pid;
1078

1079 1080 1081
	ret = ieee80211_iface_init();
	if (ret)
		goto err_netdev;
J
Jiri Benc 已提交
1082

1083
	return 0;
1084 1085 1086
 err_netdev:
	rc80211_pid_exit();
 err_pid:
1087 1088
	rc80211_minstrel_ht_exit();
 err_minstrel:
1089 1090 1091
	rc80211_minstrel_exit();

	return ret;
1092 1093 1094 1095
}

static void __exit ieee80211_exit(void)
{
1096
	rc80211_pid_exit();
1097
	rc80211_minstrel_ht_exit();
1098
	rc80211_minstrel_exit();
1099

1100 1101
	if (mesh_allocated)
		ieee80211s_stop();
J
Johannes Berg 已提交
1102

1103
	ieee80211_iface_exit();
1104 1105

	rcu_barrier();
1106 1107 1108
}


1109
subsys_initcall(ieee80211_init);
1110 1111 1112 1113
module_exit(ieee80211_exit);

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