1 /* 2 * Copyright 2002-2005, Instant802 Networks, Inc. 3 * Copyright 2005-2006, Devicescape Software, Inc. 4 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz> 5 * Copyright 2013-2014 Intel Mobile Communications GmbH 6 * Copyright (C) 2017 Intel Deutschland GmbH 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation. 11 */ 12 13 #include <net/mac80211.h> 14 #include <linux/module.h> 15 #include <linux/init.h> 16 #include <linux/netdevice.h> 17 #include <linux/types.h> 18 #include <linux/slab.h> 19 #include <linux/skbuff.h> 20 #include <linux/etherdevice.h> 21 #include <linux/if_arp.h> 22 #include <linux/rtnetlink.h> 23 #include <linux/bitmap.h> 24 #include <linux/inetdevice.h> 25 #include <net/net_namespace.h> 26 #include <net/cfg80211.h> 27 #include <net/addrconf.h> 28 29 #include "ieee80211_i.h" 30 #include "driver-ops.h" 31 #include "rate.h" 32 #include "mesh.h" 33 #include "wep.h" 34 #include "led.h" 35 #include "debugfs.h" 36 37 void ieee80211_configure_filter(struct ieee80211_local *local) 38 { 39 u64 mc; 40 unsigned int changed_flags; 41 unsigned int new_flags = 0; 42 43 if (atomic_read(&local->iff_allmultis)) 44 new_flags |= FIF_ALLMULTI; 45 46 if (local->monitors || test_bit(SCAN_SW_SCANNING, &local->scanning) || 47 test_bit(SCAN_ONCHANNEL_SCANNING, &local->scanning)) 48 new_flags |= FIF_BCN_PRBRESP_PROMISC; 49 50 if (local->fif_probe_req || local->probe_req_reg) 51 new_flags |= FIF_PROBE_REQ; 52 53 if (local->fif_fcsfail) 54 new_flags |= FIF_FCSFAIL; 55 56 if (local->fif_plcpfail) 57 new_flags |= FIF_PLCPFAIL; 58 59 if (local->fif_control) 60 new_flags |= FIF_CONTROL; 61 62 if (local->fif_other_bss) 63 new_flags |= FIF_OTHER_BSS; 64 65 if (local->fif_pspoll) 66 new_flags |= FIF_PSPOLL; 67 68 spin_lock_bh(&local->filter_lock); 69 changed_flags = local->filter_flags ^ new_flags; 70 71 mc = drv_prepare_multicast(local, &local->mc_list); 72 spin_unlock_bh(&local->filter_lock); 73 74 /* be a bit nasty */ 75 new_flags |= (1<<31); 76 77 drv_configure_filter(local, changed_flags, &new_flags, mc); 78 79 WARN_ON(new_flags & (1<<31)); 80 81 local->filter_flags = new_flags & ~(1<<31); 82 } 83 84 static void ieee80211_reconfig_filter(struct work_struct *work) 85 { 86 struct ieee80211_local *local = 87 container_of(work, struct ieee80211_local, reconfig_filter); 88 89 ieee80211_configure_filter(local); 90 } 91 92 static u32 ieee80211_hw_conf_chan(struct ieee80211_local *local) 93 { 94 struct ieee80211_sub_if_data *sdata; 95 struct cfg80211_chan_def chandef = {}; 96 u32 changed = 0; 97 int power; 98 u32 offchannel_flag; 99 100 offchannel_flag = local->hw.conf.flags & IEEE80211_CONF_OFFCHANNEL; 101 102 if (local->scan_chandef.chan) { 103 chandef = local->scan_chandef; 104 } else if (local->tmp_channel) { 105 chandef.chan = local->tmp_channel; 106 chandef.width = NL80211_CHAN_WIDTH_20_NOHT; 107 chandef.center_freq1 = chandef.chan->center_freq; 108 } else 109 chandef = local->_oper_chandef; 110 111 WARN(!cfg80211_chandef_valid(&chandef), 112 "control:%d MHz width:%d center: %d/%d MHz", 113 chandef.chan->center_freq, chandef.width, 114 chandef.center_freq1, chandef.center_freq2); 115 116 if (!cfg80211_chandef_identical(&chandef, &local->_oper_chandef)) 117 local->hw.conf.flags |= IEEE80211_CONF_OFFCHANNEL; 118 else 119 local->hw.conf.flags &= ~IEEE80211_CONF_OFFCHANNEL; 120 121 offchannel_flag ^= local->hw.conf.flags & IEEE80211_CONF_OFFCHANNEL; 122 123 if (offchannel_flag || 124 !cfg80211_chandef_identical(&local->hw.conf.chandef, 125 &local->_oper_chandef)) { 126 local->hw.conf.chandef = chandef; 127 changed |= IEEE80211_CONF_CHANGE_CHANNEL; 128 } 129 130 if (!conf_is_ht(&local->hw.conf)) { 131 /* 132 * mac80211.h documents that this is only valid 133 * when the channel is set to an HT type, and 134 * that otherwise STATIC is used. 135 */ 136 local->hw.conf.smps_mode = IEEE80211_SMPS_STATIC; 137 } else if (local->hw.conf.smps_mode != local->smps_mode) { 138 local->hw.conf.smps_mode = local->smps_mode; 139 changed |= IEEE80211_CONF_CHANGE_SMPS; 140 } 141 142 power = ieee80211_chandef_max_power(&chandef); 143 144 rcu_read_lock(); 145 list_for_each_entry_rcu(sdata, &local->interfaces, list) { 146 if (!rcu_access_pointer(sdata->vif.chanctx_conf)) 147 continue; 148 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) 149 continue; 150 power = min(power, sdata->vif.bss_conf.txpower); 151 } 152 rcu_read_unlock(); 153 154 if (local->hw.conf.power_level != power) { 155 changed |= IEEE80211_CONF_CHANGE_POWER; 156 local->hw.conf.power_level = power; 157 } 158 159 return changed; 160 } 161 162 int ieee80211_hw_config(struct ieee80211_local *local, u32 changed) 163 { 164 int ret = 0; 165 166 might_sleep(); 167 168 if (!local->use_chanctx) 169 changed |= ieee80211_hw_conf_chan(local); 170 else 171 changed &= ~(IEEE80211_CONF_CHANGE_CHANNEL | 172 IEEE80211_CONF_CHANGE_POWER); 173 174 if (changed && local->open_count) { 175 ret = drv_config(local, changed); 176 /* 177 * Goal: 178 * HW reconfiguration should never fail, the driver has told 179 * us what it can support so it should live up to that promise. 180 * 181 * Current status: 182 * rfkill is not integrated with mac80211 and a 183 * configuration command can thus fail if hardware rfkill 184 * is enabled 185 * 186 * FIXME: integrate rfkill with mac80211 and then add this 187 * WARN_ON() back 188 * 189 */ 190 /* WARN_ON(ret); */ 191 } 192 193 return ret; 194 } 195 196 void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata, 197 u32 changed) 198 { 199 struct ieee80211_local *local = sdata->local; 200 201 if (!changed || sdata->vif.type == NL80211_IFTYPE_AP_VLAN) 202 return; 203 204 drv_bss_info_changed(local, sdata, &sdata->vif.bss_conf, changed); 205 } 206 207 u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata) 208 { 209 sdata->vif.bss_conf.use_cts_prot = false; 210 sdata->vif.bss_conf.use_short_preamble = false; 211 sdata->vif.bss_conf.use_short_slot = false; 212 return BSS_CHANGED_ERP_CTS_PROT | 213 BSS_CHANGED_ERP_PREAMBLE | 214 BSS_CHANGED_ERP_SLOT; 215 } 216 217 static void ieee80211_tasklet_handler(unsigned long data) 218 { 219 struct ieee80211_local *local = (struct ieee80211_local *) data; 220 struct sk_buff *skb; 221 222 while ((skb = skb_dequeue(&local->skb_queue)) || 223 (skb = skb_dequeue(&local->skb_queue_unreliable))) { 224 switch (skb->pkt_type) { 225 case IEEE80211_RX_MSG: 226 /* Clear skb->pkt_type in order to not confuse kernel 227 * netstack. */ 228 skb->pkt_type = 0; 229 ieee80211_rx(&local->hw, skb); 230 break; 231 case IEEE80211_TX_STATUS_MSG: 232 skb->pkt_type = 0; 233 ieee80211_tx_status(&local->hw, skb); 234 break; 235 default: 236 WARN(1, "mac80211: Packet is of unknown type %d\n", 237 skb->pkt_type); 238 dev_kfree_skb(skb); 239 break; 240 } 241 } 242 } 243 244 static void ieee80211_restart_work(struct work_struct *work) 245 { 246 struct ieee80211_local *local = 247 container_of(work, struct ieee80211_local, restart_work); 248 struct ieee80211_sub_if_data *sdata; 249 250 /* wait for scan work complete */ 251 flush_workqueue(local->workqueue); 252 flush_work(&local->sched_scan_stopped_work); 253 254 WARN(test_bit(SCAN_HW_SCANNING, &local->scanning), 255 "%s called with hardware scan in progress\n", __func__); 256 257 flush_work(&local->radar_detected_work); 258 rtnl_lock(); 259 list_for_each_entry(sdata, &local->interfaces, list) 260 flush_delayed_work(&sdata->dec_tailroom_needed_wk); 261 ieee80211_scan_cancel(local); 262 263 /* make sure any new ROC will consider local->in_reconfig */ 264 flush_delayed_work(&local->roc_work); 265 flush_work(&local->hw_roc_done); 266 267 /* wait for all packet processing to be done */ 268 synchronize_net(); 269 270 ieee80211_reconfig(local); 271 rtnl_unlock(); 272 } 273 274 void ieee80211_restart_hw(struct ieee80211_hw *hw) 275 { 276 struct ieee80211_local *local = hw_to_local(hw); 277 278 trace_api_restart_hw(local); 279 280 wiphy_info(hw->wiphy, 281 "Hardware restart was requested\n"); 282 283 /* use this reason, ieee80211_reconfig will unblock it */ 284 ieee80211_stop_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP, 285 IEEE80211_QUEUE_STOP_REASON_SUSPEND, 286 false); 287 288 /* 289 * Stop all Rx during the reconfig. We don't want state changes 290 * or driver callbacks while this is in progress. 291 */ 292 local->in_reconfig = true; 293 barrier(); 294 295 queue_work(system_freezable_wq, &local->restart_work); 296 } 297 EXPORT_SYMBOL(ieee80211_restart_hw); 298 299 #ifdef CONFIG_INET 300 static int ieee80211_ifa_changed(struct notifier_block *nb, 301 unsigned long data, void *arg) 302 { 303 struct in_ifaddr *ifa = arg; 304 struct ieee80211_local *local = 305 container_of(nb, struct ieee80211_local, 306 ifa_notifier); 307 struct net_device *ndev = ifa->ifa_dev->dev; 308 struct wireless_dev *wdev = ndev->ieee80211_ptr; 309 struct in_device *idev; 310 struct ieee80211_sub_if_data *sdata; 311 struct ieee80211_bss_conf *bss_conf; 312 struct ieee80211_if_managed *ifmgd; 313 int c = 0; 314 315 /* Make sure it's our interface that got changed */ 316 if (!wdev) 317 return NOTIFY_DONE; 318 319 if (wdev->wiphy != local->hw.wiphy) 320 return NOTIFY_DONE; 321 322 sdata = IEEE80211_DEV_TO_SUB_IF(ndev); 323 bss_conf = &sdata->vif.bss_conf; 324 325 /* ARP filtering is only supported in managed mode */ 326 if (sdata->vif.type != NL80211_IFTYPE_STATION) 327 return NOTIFY_DONE; 328 329 idev = __in_dev_get_rtnl(sdata->dev); 330 if (!idev) 331 return NOTIFY_DONE; 332 333 ifmgd = &sdata->u.mgd; 334 sdata_lock(sdata); 335 336 /* Copy the addresses to the bss_conf list */ 337 ifa = idev->ifa_list; 338 while (ifa) { 339 if (c < IEEE80211_BSS_ARP_ADDR_LIST_LEN) 340 bss_conf->arp_addr_list[c] = ifa->ifa_address; 341 ifa = ifa->ifa_next; 342 c++; 343 } 344 345 bss_conf->arp_addr_cnt = c; 346 347 /* Configure driver only if associated (which also implies it is up) */ 348 if (ifmgd->associated) 349 ieee80211_bss_info_change_notify(sdata, 350 BSS_CHANGED_ARP_FILTER); 351 352 sdata_unlock(sdata); 353 354 return NOTIFY_OK; 355 } 356 #endif 357 358 #if IS_ENABLED(CONFIG_IPV6) 359 static int ieee80211_ifa6_changed(struct notifier_block *nb, 360 unsigned long data, void *arg) 361 { 362 struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)arg; 363 struct inet6_dev *idev = ifa->idev; 364 struct net_device *ndev = ifa->idev->dev; 365 struct ieee80211_local *local = 366 container_of(nb, struct ieee80211_local, ifa6_notifier); 367 struct wireless_dev *wdev = ndev->ieee80211_ptr; 368 struct ieee80211_sub_if_data *sdata; 369 370 /* Make sure it's our interface that got changed */ 371 if (!wdev || wdev->wiphy != local->hw.wiphy) 372 return NOTIFY_DONE; 373 374 sdata = IEEE80211_DEV_TO_SUB_IF(ndev); 375 376 /* 377 * For now only support station mode. This is mostly because 378 * doing AP would have to handle AP_VLAN in some way ... 379 */ 380 if (sdata->vif.type != NL80211_IFTYPE_STATION) 381 return NOTIFY_DONE; 382 383 drv_ipv6_addr_change(local, sdata, idev); 384 385 return NOTIFY_OK; 386 } 387 #endif 388 389 /* There isn't a lot of sense in it, but you can transmit anything you like */ 390 static const struct ieee80211_txrx_stypes 391 ieee80211_default_mgmt_stypes[NUM_NL80211_IFTYPES] = { 392 [NL80211_IFTYPE_ADHOC] = { 393 .tx = 0xffff, 394 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 395 BIT(IEEE80211_STYPE_AUTH >> 4) | 396 BIT(IEEE80211_STYPE_DEAUTH >> 4) | 397 BIT(IEEE80211_STYPE_PROBE_REQ >> 4), 398 }, 399 [NL80211_IFTYPE_STATION] = { 400 .tx = 0xffff, 401 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 402 BIT(IEEE80211_STYPE_PROBE_REQ >> 4), 403 }, 404 [NL80211_IFTYPE_AP] = { 405 .tx = 0xffff, 406 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) | 407 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) | 408 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) | 409 BIT(IEEE80211_STYPE_DISASSOC >> 4) | 410 BIT(IEEE80211_STYPE_AUTH >> 4) | 411 BIT(IEEE80211_STYPE_DEAUTH >> 4) | 412 BIT(IEEE80211_STYPE_ACTION >> 4), 413 }, 414 [NL80211_IFTYPE_AP_VLAN] = { 415 /* copy AP */ 416 .tx = 0xffff, 417 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) | 418 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) | 419 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) | 420 BIT(IEEE80211_STYPE_DISASSOC >> 4) | 421 BIT(IEEE80211_STYPE_AUTH >> 4) | 422 BIT(IEEE80211_STYPE_DEAUTH >> 4) | 423 BIT(IEEE80211_STYPE_ACTION >> 4), 424 }, 425 [NL80211_IFTYPE_P2P_CLIENT] = { 426 .tx = 0xffff, 427 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 428 BIT(IEEE80211_STYPE_PROBE_REQ >> 4), 429 }, 430 [NL80211_IFTYPE_P2P_GO] = { 431 .tx = 0xffff, 432 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) | 433 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) | 434 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) | 435 BIT(IEEE80211_STYPE_DISASSOC >> 4) | 436 BIT(IEEE80211_STYPE_AUTH >> 4) | 437 BIT(IEEE80211_STYPE_DEAUTH >> 4) | 438 BIT(IEEE80211_STYPE_ACTION >> 4), 439 }, 440 [NL80211_IFTYPE_MESH_POINT] = { 441 .tx = 0xffff, 442 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 443 BIT(IEEE80211_STYPE_AUTH >> 4) | 444 BIT(IEEE80211_STYPE_DEAUTH >> 4), 445 }, 446 [NL80211_IFTYPE_P2P_DEVICE] = { 447 .tx = 0xffff, 448 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 449 BIT(IEEE80211_STYPE_PROBE_REQ >> 4), 450 }, 451 }; 452 453 static const struct ieee80211_ht_cap mac80211_ht_capa_mod_mask = { 454 .ampdu_params_info = IEEE80211_HT_AMPDU_PARM_FACTOR | 455 IEEE80211_HT_AMPDU_PARM_DENSITY, 456 457 .cap_info = cpu_to_le16(IEEE80211_HT_CAP_SUP_WIDTH_20_40 | 458 IEEE80211_HT_CAP_MAX_AMSDU | 459 IEEE80211_HT_CAP_SGI_20 | 460 IEEE80211_HT_CAP_SGI_40 | 461 IEEE80211_HT_CAP_LDPC_CODING | 462 IEEE80211_HT_CAP_40MHZ_INTOLERANT), 463 .mcs = { 464 .rx_mask = { 0xff, 0xff, 0xff, 0xff, 0xff, 465 0xff, 0xff, 0xff, 0xff, 0xff, }, 466 }, 467 }; 468 469 static const struct ieee80211_vht_cap mac80211_vht_capa_mod_mask = { 470 .vht_cap_info = 471 cpu_to_le32(IEEE80211_VHT_CAP_RXLDPC | 472 IEEE80211_VHT_CAP_SHORT_GI_80 | 473 IEEE80211_VHT_CAP_SHORT_GI_160 | 474 IEEE80211_VHT_CAP_RXSTBC_1 | 475 IEEE80211_VHT_CAP_RXSTBC_2 | 476 IEEE80211_VHT_CAP_RXSTBC_3 | 477 IEEE80211_VHT_CAP_RXSTBC_4 | 478 IEEE80211_VHT_CAP_TXSTBC | 479 IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE | 480 IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE | 481 IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN | 482 IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN | 483 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK), 484 .supp_mcs = { 485 .rx_mcs_map = cpu_to_le16(~0), 486 .tx_mcs_map = cpu_to_le16(~0), 487 }, 488 }; 489 490 struct ieee80211_hw *ieee80211_alloc_hw_nm(size_t priv_data_len, 491 const struct ieee80211_ops *ops, 492 const char *requested_name) 493 { 494 struct ieee80211_local *local; 495 int priv_size, i; 496 struct wiphy *wiphy; 497 bool use_chanctx; 498 499 if (WARN_ON(!ops->tx || !ops->start || !ops->stop || !ops->config || 500 !ops->add_interface || !ops->remove_interface || 501 !ops->configure_filter)) 502 return NULL; 503 504 if (WARN_ON(ops->sta_state && (ops->sta_add || ops->sta_remove))) 505 return NULL; 506 507 /* check all or no channel context operations exist */ 508 i = !!ops->add_chanctx + !!ops->remove_chanctx + 509 !!ops->change_chanctx + !!ops->assign_vif_chanctx + 510 !!ops->unassign_vif_chanctx; 511 if (WARN_ON(i != 0 && i != 5)) 512 return NULL; 513 use_chanctx = i == 5; 514 515 /* Ensure 32-byte alignment of our private data and hw private data. 516 * We use the wiphy priv data for both our ieee80211_local and for 517 * the driver's private data 518 * 519 * In memory it'll be like this: 520 * 521 * +-------------------------+ 522 * | struct wiphy | 523 * +-------------------------+ 524 * | struct ieee80211_local | 525 * +-------------------------+ 526 * | driver's private data | 527 * +-------------------------+ 528 * 529 */ 530 priv_size = ALIGN(sizeof(*local), NETDEV_ALIGN) + priv_data_len; 531 532 wiphy = wiphy_new_nm(&mac80211_config_ops, priv_size, requested_name); 533 534 if (!wiphy) 535 return NULL; 536 537 wiphy->mgmt_stypes = ieee80211_default_mgmt_stypes; 538 539 wiphy->privid = mac80211_wiphy_privid; 540 541 wiphy->flags |= WIPHY_FLAG_NETNS_OK | 542 WIPHY_FLAG_4ADDR_AP | 543 WIPHY_FLAG_4ADDR_STATION | 544 WIPHY_FLAG_REPORTS_OBSS | 545 WIPHY_FLAG_OFFCHAN_TX; 546 547 if (ops->remain_on_channel) 548 wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL; 549 550 wiphy->features |= NL80211_FEATURE_SK_TX_STATUS | 551 NL80211_FEATURE_SAE | 552 NL80211_FEATURE_HT_IBSS | 553 NL80211_FEATURE_VIF_TXPOWER | 554 NL80211_FEATURE_MAC_ON_CREATE | 555 NL80211_FEATURE_USERSPACE_MPM | 556 NL80211_FEATURE_FULL_AP_CLIENT_STATE; 557 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_FILS_STA); 558 wiphy_ext_feature_set(wiphy, 559 NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211); 560 561 if (!ops->hw_scan) { 562 wiphy->features |= NL80211_FEATURE_LOW_PRIORITY_SCAN | 563 NL80211_FEATURE_AP_SCAN; 564 /* 565 * if the driver behaves correctly using the probe request 566 * (template) from mac80211, then both of these should be 567 * supported even with hw scan - but let drivers opt in. 568 */ 569 wiphy_ext_feature_set(wiphy, 570 NL80211_EXT_FEATURE_SCAN_RANDOM_SN); 571 wiphy_ext_feature_set(wiphy, 572 NL80211_EXT_FEATURE_SCAN_MIN_PREQ_CONTENT); 573 } 574 575 if (!ops->set_key) 576 wiphy->flags |= WIPHY_FLAG_IBSS_RSN; 577 578 if (ops->wake_tx_queue) 579 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_TXQS); 580 581 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_RRM); 582 583 wiphy->bss_priv_size = sizeof(struct ieee80211_bss); 584 585 local = wiphy_priv(wiphy); 586 587 if (sta_info_init(local)) 588 goto err_free; 589 590 local->hw.wiphy = wiphy; 591 592 local->hw.priv = (char *)local + ALIGN(sizeof(*local), NETDEV_ALIGN); 593 594 local->ops = ops; 595 local->use_chanctx = use_chanctx; 596 597 /* set up some defaults */ 598 local->hw.queues = 1; 599 local->hw.max_rates = 1; 600 local->hw.max_report_rates = 0; 601 local->hw.max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_HT; 602 local->hw.max_tx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_HT; 603 local->hw.offchannel_tx_hw_queue = IEEE80211_INVAL_HW_QUEUE; 604 local->hw.conf.long_frame_max_tx_count = wiphy->retry_long; 605 local->hw.conf.short_frame_max_tx_count = wiphy->retry_short; 606 local->hw.radiotap_mcs_details = IEEE80211_RADIOTAP_MCS_HAVE_MCS | 607 IEEE80211_RADIOTAP_MCS_HAVE_GI | 608 IEEE80211_RADIOTAP_MCS_HAVE_BW; 609 local->hw.radiotap_vht_details = IEEE80211_RADIOTAP_VHT_KNOWN_GI | 610 IEEE80211_RADIOTAP_VHT_KNOWN_BANDWIDTH; 611 local->hw.uapsd_queues = IEEE80211_DEFAULT_UAPSD_QUEUES; 612 local->hw.uapsd_max_sp_len = IEEE80211_DEFAULT_MAX_SP_LEN; 613 local->user_power_level = IEEE80211_UNSET_POWER_LEVEL; 614 wiphy->ht_capa_mod_mask = &mac80211_ht_capa_mod_mask; 615 wiphy->vht_capa_mod_mask = &mac80211_vht_capa_mod_mask; 616 617 local->ext_capa[7] = WLAN_EXT_CAPA8_OPMODE_NOTIF; 618 619 wiphy->extended_capabilities = local->ext_capa; 620 wiphy->extended_capabilities_mask = local->ext_capa; 621 wiphy->extended_capabilities_len = 622 ARRAY_SIZE(local->ext_capa); 623 624 INIT_LIST_HEAD(&local->interfaces); 625 INIT_LIST_HEAD(&local->mon_list); 626 627 __hw_addr_init(&local->mc_list); 628 629 mutex_init(&local->iflist_mtx); 630 mutex_init(&local->mtx); 631 632 mutex_init(&local->key_mtx); 633 spin_lock_init(&local->filter_lock); 634 spin_lock_init(&local->rx_path_lock); 635 spin_lock_init(&local->queue_stop_reason_lock); 636 637 INIT_LIST_HEAD(&local->chanctx_list); 638 mutex_init(&local->chanctx_mtx); 639 640 INIT_DELAYED_WORK(&local->scan_work, ieee80211_scan_work); 641 642 INIT_WORK(&local->restart_work, ieee80211_restart_work); 643 644 INIT_WORK(&local->radar_detected_work, 645 ieee80211_dfs_radar_detected_work); 646 647 INIT_WORK(&local->reconfig_filter, ieee80211_reconfig_filter); 648 local->smps_mode = IEEE80211_SMPS_OFF; 649 650 INIT_WORK(&local->dynamic_ps_enable_work, 651 ieee80211_dynamic_ps_enable_work); 652 INIT_WORK(&local->dynamic_ps_disable_work, 653 ieee80211_dynamic_ps_disable_work); 654 timer_setup(&local->dynamic_ps_timer, ieee80211_dynamic_ps_timer, 0); 655 656 INIT_WORK(&local->sched_scan_stopped_work, 657 ieee80211_sched_scan_stopped_work); 658 659 INIT_WORK(&local->tdls_chsw_work, ieee80211_tdls_chsw_work); 660 661 spin_lock_init(&local->ack_status_lock); 662 idr_init(&local->ack_status_frames); 663 664 for (i = 0; i < IEEE80211_MAX_QUEUES; i++) { 665 skb_queue_head_init(&local->pending[i]); 666 atomic_set(&local->agg_queue_stop[i], 0); 667 } 668 tasklet_init(&local->tx_pending_tasklet, ieee80211_tx_pending, 669 (unsigned long)local); 670 671 tasklet_init(&local->tasklet, 672 ieee80211_tasklet_handler, 673 (unsigned long) local); 674 675 skb_queue_head_init(&local->skb_queue); 676 skb_queue_head_init(&local->skb_queue_unreliable); 677 skb_queue_head_init(&local->skb_queue_tdls_chsw); 678 679 ieee80211_alloc_led_names(local); 680 681 ieee80211_roc_setup(local); 682 683 local->hw.radiotap_timestamp.units_pos = -1; 684 local->hw.radiotap_timestamp.accuracy = -1; 685 686 return &local->hw; 687 err_free: 688 wiphy_free(wiphy); 689 return NULL; 690 } 691 EXPORT_SYMBOL(ieee80211_alloc_hw_nm); 692 693 static int ieee80211_init_cipher_suites(struct ieee80211_local *local) 694 { 695 bool have_wep = !(IS_ERR(local->wep_tx_tfm) || 696 IS_ERR(local->wep_rx_tfm)); 697 bool have_mfp = ieee80211_hw_check(&local->hw, MFP_CAPABLE); 698 int n_suites = 0, r = 0, w = 0; 699 u32 *suites; 700 static const u32 cipher_suites[] = { 701 /* keep WEP first, it may be removed below */ 702 WLAN_CIPHER_SUITE_WEP40, 703 WLAN_CIPHER_SUITE_WEP104, 704 WLAN_CIPHER_SUITE_TKIP, 705 WLAN_CIPHER_SUITE_CCMP, 706 WLAN_CIPHER_SUITE_CCMP_256, 707 WLAN_CIPHER_SUITE_GCMP, 708 WLAN_CIPHER_SUITE_GCMP_256, 709 710 /* keep last -- depends on hw flags! */ 711 WLAN_CIPHER_SUITE_AES_CMAC, 712 WLAN_CIPHER_SUITE_BIP_CMAC_256, 713 WLAN_CIPHER_SUITE_BIP_GMAC_128, 714 WLAN_CIPHER_SUITE_BIP_GMAC_256, 715 }; 716 717 if (ieee80211_hw_check(&local->hw, SW_CRYPTO_CONTROL) || 718 local->hw.wiphy->cipher_suites) { 719 /* If the driver advertises, or doesn't support SW crypto, 720 * we only need to remove WEP if necessary. 721 */ 722 if (have_wep) 723 return 0; 724 725 /* well if it has _no_ ciphers ... fine */ 726 if (!local->hw.wiphy->n_cipher_suites) 727 return 0; 728 729 /* Driver provides cipher suites, but we need to exclude WEP */ 730 suites = kmemdup(local->hw.wiphy->cipher_suites, 731 sizeof(u32) * local->hw.wiphy->n_cipher_suites, 732 GFP_KERNEL); 733 if (!suites) 734 return -ENOMEM; 735 736 for (r = 0; r < local->hw.wiphy->n_cipher_suites; r++) { 737 u32 suite = local->hw.wiphy->cipher_suites[r]; 738 739 if (suite == WLAN_CIPHER_SUITE_WEP40 || 740 suite == WLAN_CIPHER_SUITE_WEP104) 741 continue; 742 suites[w++] = suite; 743 } 744 } else if (!local->hw.cipher_schemes) { 745 /* If the driver doesn't have cipher schemes, there's nothing 746 * else to do other than assign the (software supported and 747 * perhaps offloaded) cipher suites. 748 */ 749 local->hw.wiphy->cipher_suites = cipher_suites; 750 local->hw.wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites); 751 752 if (!have_mfp) 753 local->hw.wiphy->n_cipher_suites -= 4; 754 755 if (!have_wep) { 756 local->hw.wiphy->cipher_suites += 2; 757 local->hw.wiphy->n_cipher_suites -= 2; 758 } 759 760 /* not dynamically allocated, so just return */ 761 return 0; 762 } else { 763 const struct ieee80211_cipher_scheme *cs; 764 765 cs = local->hw.cipher_schemes; 766 767 /* Driver specifies cipher schemes only (but not cipher suites 768 * including the schemes) 769 * 770 * We start counting ciphers defined by schemes, TKIP, CCMP, 771 * CCMP-256, GCMP, and GCMP-256 772 */ 773 n_suites = local->hw.n_cipher_schemes + 5; 774 775 /* check if we have WEP40 and WEP104 */ 776 if (have_wep) 777 n_suites += 2; 778 779 /* check if we have AES_CMAC, BIP-CMAC-256, BIP-GMAC-128, 780 * BIP-GMAC-256 781 */ 782 if (have_mfp) 783 n_suites += 4; 784 785 suites = kmalloc_array(n_suites, sizeof(u32), GFP_KERNEL); 786 if (!suites) 787 return -ENOMEM; 788 789 suites[w++] = WLAN_CIPHER_SUITE_CCMP; 790 suites[w++] = WLAN_CIPHER_SUITE_CCMP_256; 791 suites[w++] = WLAN_CIPHER_SUITE_TKIP; 792 suites[w++] = WLAN_CIPHER_SUITE_GCMP; 793 suites[w++] = WLAN_CIPHER_SUITE_GCMP_256; 794 795 if (have_wep) { 796 suites[w++] = WLAN_CIPHER_SUITE_WEP40; 797 suites[w++] = WLAN_CIPHER_SUITE_WEP104; 798 } 799 800 if (have_mfp) { 801 suites[w++] = WLAN_CIPHER_SUITE_AES_CMAC; 802 suites[w++] = WLAN_CIPHER_SUITE_BIP_CMAC_256; 803 suites[w++] = WLAN_CIPHER_SUITE_BIP_GMAC_128; 804 suites[w++] = WLAN_CIPHER_SUITE_BIP_GMAC_256; 805 } 806 807 for (r = 0; r < local->hw.n_cipher_schemes; r++) { 808 suites[w++] = cs[r].cipher; 809 if (WARN_ON(cs[r].pn_len > IEEE80211_MAX_PN_LEN)) { 810 kfree(suites); 811 return -EINVAL; 812 } 813 } 814 } 815 816 local->hw.wiphy->cipher_suites = suites; 817 local->hw.wiphy->n_cipher_suites = w; 818 local->wiphy_ciphers_allocated = true; 819 820 return 0; 821 } 822 823 int ieee80211_register_hw(struct ieee80211_hw *hw) 824 { 825 struct ieee80211_local *local = hw_to_local(hw); 826 int result, i; 827 enum nl80211_band band; 828 int channels, max_bitrates; 829 bool supp_ht, supp_vht, supp_he; 830 netdev_features_t feature_whitelist; 831 struct cfg80211_chan_def dflt_chandef = {}; 832 833 if (ieee80211_hw_check(hw, QUEUE_CONTROL) && 834 (local->hw.offchannel_tx_hw_queue == IEEE80211_INVAL_HW_QUEUE || 835 local->hw.offchannel_tx_hw_queue >= local->hw.queues)) 836 return -EINVAL; 837 838 if ((hw->wiphy->features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH) && 839 (!local->ops->tdls_channel_switch || 840 !local->ops->tdls_cancel_channel_switch || 841 !local->ops->tdls_recv_channel_switch)) 842 return -EOPNOTSUPP; 843 844 if (WARN_ON(ieee80211_hw_check(hw, SUPPORTS_TX_FRAG) && 845 !local->ops->set_frag_threshold)) 846 return -EINVAL; 847 848 if (WARN_ON(local->hw.wiphy->interface_modes & 849 BIT(NL80211_IFTYPE_NAN) && 850 (!local->ops->start_nan || !local->ops->stop_nan))) 851 return -EINVAL; 852 853 #ifdef CONFIG_PM 854 if (hw->wiphy->wowlan && (!local->ops->suspend || !local->ops->resume)) 855 return -EINVAL; 856 #endif 857 858 if (!local->use_chanctx) { 859 for (i = 0; i < local->hw.wiphy->n_iface_combinations; i++) { 860 const struct ieee80211_iface_combination *comb; 861 862 comb = &local->hw.wiphy->iface_combinations[i]; 863 864 if (comb->num_different_channels > 1) 865 return -EINVAL; 866 } 867 } else { 868 /* 869 * WDS is currently prohibited when channel contexts are used 870 * because there's no clear definition of which channel WDS 871 * type interfaces use 872 */ 873 if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_WDS)) 874 return -EINVAL; 875 876 /* DFS is not supported with multi-channel combinations yet */ 877 for (i = 0; i < local->hw.wiphy->n_iface_combinations; i++) { 878 const struct ieee80211_iface_combination *comb; 879 880 comb = &local->hw.wiphy->iface_combinations[i]; 881 882 if (comb->radar_detect_widths && 883 comb->num_different_channels > 1) 884 return -EINVAL; 885 } 886 } 887 888 /* Only HW csum features are currently compatible with mac80211 */ 889 feature_whitelist = NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | 890 NETIF_F_HW_CSUM | NETIF_F_SG | NETIF_F_HIGHDMA | 891 NETIF_F_GSO_SOFTWARE | NETIF_F_RXCSUM; 892 if (WARN_ON(hw->netdev_features & ~feature_whitelist)) 893 return -EINVAL; 894 895 if (hw->max_report_rates == 0) 896 hw->max_report_rates = hw->max_rates; 897 898 local->rx_chains = 1; 899 900 /* 901 * generic code guarantees at least one band, 902 * set this very early because much code assumes 903 * that hw.conf.channel is assigned 904 */ 905 channels = 0; 906 max_bitrates = 0; 907 supp_ht = false; 908 supp_vht = false; 909 supp_he = false; 910 for (band = 0; band < NUM_NL80211_BANDS; band++) { 911 struct ieee80211_supported_band *sband; 912 913 sband = local->hw.wiphy->bands[band]; 914 if (!sband) 915 continue; 916 917 if (!dflt_chandef.chan) { 918 cfg80211_chandef_create(&dflt_chandef, 919 &sband->channels[0], 920 NL80211_CHAN_NO_HT); 921 /* init channel we're on */ 922 if (!local->use_chanctx && !local->_oper_chandef.chan) { 923 local->hw.conf.chandef = dflt_chandef; 924 local->_oper_chandef = dflt_chandef; 925 } 926 local->monitor_chandef = dflt_chandef; 927 } 928 929 channels += sband->n_channels; 930 931 if (max_bitrates < sband->n_bitrates) 932 max_bitrates = sband->n_bitrates; 933 supp_ht = supp_ht || sband->ht_cap.ht_supported; 934 supp_vht = supp_vht || sband->vht_cap.vht_supported; 935 936 if (!supp_he) 937 supp_he = !!ieee80211_get_he_sta_cap(sband); 938 939 if (!sband->ht_cap.ht_supported) 940 continue; 941 942 /* TODO: consider VHT for RX chains, hopefully it's the same */ 943 local->rx_chains = 944 max(ieee80211_mcs_to_chains(&sband->ht_cap.mcs), 945 local->rx_chains); 946 947 /* no need to mask, SM_PS_DISABLED has all bits set */ 948 sband->ht_cap.cap |= WLAN_HT_CAP_SM_PS_DISABLED << 949 IEEE80211_HT_CAP_SM_PS_SHIFT; 950 } 951 952 /* if low-level driver supports AP, we also support VLAN. 953 * drivers advertising SW_CRYPTO_CONTROL should enable AP_VLAN 954 * based on their support to transmit SW encrypted packets. 955 */ 956 if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_AP) && 957 !ieee80211_hw_check(&local->hw, SW_CRYPTO_CONTROL)) { 958 hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP_VLAN); 959 hw->wiphy->software_iftypes |= BIT(NL80211_IFTYPE_AP_VLAN); 960 } 961 962 /* mac80211 always supports monitor */ 963 hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_MONITOR); 964 hw->wiphy->software_iftypes |= BIT(NL80211_IFTYPE_MONITOR); 965 966 /* mac80211 doesn't support more than one IBSS interface right now */ 967 for (i = 0; i < hw->wiphy->n_iface_combinations; i++) { 968 const struct ieee80211_iface_combination *c; 969 int j; 970 971 c = &hw->wiphy->iface_combinations[i]; 972 973 for (j = 0; j < c->n_limits; j++) 974 if ((c->limits[j].types & BIT(NL80211_IFTYPE_ADHOC)) && 975 c->limits[j].max > 1) 976 return -EINVAL; 977 } 978 979 local->int_scan_req = kzalloc(sizeof(*local->int_scan_req) + 980 sizeof(void *) * channels, GFP_KERNEL); 981 if (!local->int_scan_req) 982 return -ENOMEM; 983 984 for (band = 0; band < NUM_NL80211_BANDS; band++) { 985 if (!local->hw.wiphy->bands[band]) 986 continue; 987 local->int_scan_req->rates[band] = (u32) -1; 988 } 989 990 #ifndef CONFIG_MAC80211_MESH 991 /* mesh depends on Kconfig, but drivers should set it if they want */ 992 local->hw.wiphy->interface_modes &= ~BIT(NL80211_IFTYPE_MESH_POINT); 993 #endif 994 995 /* if the underlying driver supports mesh, mac80211 will (at least) 996 * provide routing of mesh authentication frames to userspace */ 997 if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_MESH_POINT)) 998 local->hw.wiphy->flags |= WIPHY_FLAG_MESH_AUTH; 999 1000 /* mac80211 supports control port protocol changing */ 1001 local->hw.wiphy->flags |= WIPHY_FLAG_CONTROL_PORT_PROTOCOL; 1002 1003 if (ieee80211_hw_check(&local->hw, SIGNAL_DBM)) { 1004 local->hw.wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM; 1005 } else if (ieee80211_hw_check(&local->hw, SIGNAL_UNSPEC)) { 1006 local->hw.wiphy->signal_type = CFG80211_SIGNAL_TYPE_UNSPEC; 1007 if (hw->max_signal <= 0) { 1008 result = -EINVAL; 1009 goto fail_wiphy_register; 1010 } 1011 } 1012 1013 /* 1014 * Calculate scan IE length -- we need this to alloc 1015 * memory and to subtract from the driver limit. It 1016 * includes the DS Params, (extended) supported rates, and HT 1017 * information -- SSID is the driver's responsibility. 1018 */ 1019 local->scan_ies_len = 4 + max_bitrates /* (ext) supp rates */ + 1020 3 /* DS Params */; 1021 if (supp_ht) 1022 local->scan_ies_len += 2 + sizeof(struct ieee80211_ht_cap); 1023 1024 if (supp_vht) 1025 local->scan_ies_len += 1026 2 + sizeof(struct ieee80211_vht_cap); 1027 1028 /* HE cap element is variable in size - set len to allow max size */ 1029 /* 1030 * TODO: 1 is added at the end of the calculation to accommodate for 1031 * the temporary placing of the HE capabilities IE under EXT. 1032 * Remove it once it is placed in the final place. 1033 */ 1034 if (supp_he) 1035 local->scan_ies_len += 1036 2 + sizeof(struct ieee80211_he_cap_elem) + 1037 sizeof(struct ieee80211_he_mcs_nss_supp) + 1038 IEEE80211_HE_PPE_THRES_MAX_LEN + 1; 1039 1040 if (!local->ops->hw_scan) { 1041 /* For hw_scan, driver needs to set these up. */ 1042 local->hw.wiphy->max_scan_ssids = 4; 1043 local->hw.wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN; 1044 } 1045 1046 /* 1047 * If the driver supports any scan IEs, then assume the 1048 * limit includes the IEs mac80211 will add, otherwise 1049 * leave it at zero and let the driver sort it out; we 1050 * still pass our IEs to the driver but userspace will 1051 * not be allowed to in that case. 1052 */ 1053 if (local->hw.wiphy->max_scan_ie_len) 1054 local->hw.wiphy->max_scan_ie_len -= local->scan_ies_len; 1055 1056 WARN_ON(!ieee80211_cs_list_valid(local->hw.cipher_schemes, 1057 local->hw.n_cipher_schemes)); 1058 1059 result = ieee80211_init_cipher_suites(local); 1060 if (result < 0) 1061 goto fail_wiphy_register; 1062 1063 if (!local->ops->remain_on_channel) 1064 local->hw.wiphy->max_remain_on_channel_duration = 5000; 1065 1066 /* mac80211 based drivers don't support internal TDLS setup */ 1067 if (local->hw.wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS) 1068 local->hw.wiphy->flags |= WIPHY_FLAG_TDLS_EXTERNAL_SETUP; 1069 1070 /* mac80211 supports eCSA, if the driver supports STA CSA at all */ 1071 if (ieee80211_hw_check(&local->hw, CHANCTX_STA_CSA)) 1072 local->ext_capa[0] |= WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING; 1073 1074 local->hw.wiphy->max_num_csa_counters = IEEE80211_MAX_CSA_COUNTERS_NUM; 1075 1076 result = wiphy_register(local->hw.wiphy); 1077 if (result < 0) 1078 goto fail_wiphy_register; 1079 1080 /* 1081 * We use the number of queues for feature tests (QoS, HT) internally 1082 * so restrict them appropriately. 1083 */ 1084 if (hw->queues > IEEE80211_MAX_QUEUES) 1085 hw->queues = IEEE80211_MAX_QUEUES; 1086 1087 local->workqueue = 1088 alloc_ordered_workqueue("%s", 0, wiphy_name(local->hw.wiphy)); 1089 if (!local->workqueue) { 1090 result = -ENOMEM; 1091 goto fail_workqueue; 1092 } 1093 1094 /* 1095 * The hardware needs headroom for sending the frame, 1096 * and we need some headroom for passing the frame to monitor 1097 * interfaces, but never both at the same time. 1098 */ 1099 local->tx_headroom = max_t(unsigned int , local->hw.extra_tx_headroom, 1100 IEEE80211_TX_STATUS_HEADROOM); 1101 1102 debugfs_hw_add(local); 1103 1104 /* 1105 * if the driver doesn't specify a max listen interval we 1106 * use 5 which should be a safe default 1107 */ 1108 if (local->hw.max_listen_interval == 0) 1109 local->hw.max_listen_interval = 5; 1110 1111 local->hw.conf.listen_interval = local->hw.max_listen_interval; 1112 1113 local->dynamic_ps_forced_timeout = -1; 1114 1115 if (!local->hw.max_nan_de_entries) 1116 local->hw.max_nan_de_entries = IEEE80211_MAX_NAN_INSTANCE_ID; 1117 1118 result = ieee80211_wep_init(local); 1119 if (result < 0) 1120 wiphy_debug(local->hw.wiphy, "Failed to initialize wep: %d\n", 1121 result); 1122 1123 local->hw.conf.flags = IEEE80211_CONF_IDLE; 1124 1125 ieee80211_led_init(local); 1126 1127 result = ieee80211_txq_setup_flows(local); 1128 if (result) 1129 goto fail_flows; 1130 1131 rtnl_lock(); 1132 1133 result = ieee80211_init_rate_ctrl_alg(local, 1134 hw->rate_control_algorithm); 1135 if (result < 0) { 1136 wiphy_debug(local->hw.wiphy, 1137 "Failed to initialize rate control algorithm\n"); 1138 goto fail_rate; 1139 } 1140 1141 /* add one default STA interface if supported */ 1142 if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_STATION) && 1143 !ieee80211_hw_check(hw, NO_AUTO_VIF)) { 1144 result = ieee80211_if_add(local, "wlan%d", NET_NAME_ENUM, NULL, 1145 NL80211_IFTYPE_STATION, NULL); 1146 if (result) 1147 wiphy_warn(local->hw.wiphy, 1148 "Failed to add default virtual iface\n"); 1149 } 1150 1151 rtnl_unlock(); 1152 1153 #ifdef CONFIG_INET 1154 local->ifa_notifier.notifier_call = ieee80211_ifa_changed; 1155 result = register_inetaddr_notifier(&local->ifa_notifier); 1156 if (result) 1157 goto fail_ifa; 1158 #endif 1159 1160 #if IS_ENABLED(CONFIG_IPV6) 1161 local->ifa6_notifier.notifier_call = ieee80211_ifa6_changed; 1162 result = register_inet6addr_notifier(&local->ifa6_notifier); 1163 if (result) 1164 goto fail_ifa6; 1165 #endif 1166 1167 return 0; 1168 1169 #if IS_ENABLED(CONFIG_IPV6) 1170 fail_ifa6: 1171 #ifdef CONFIG_INET 1172 unregister_inetaddr_notifier(&local->ifa_notifier); 1173 #endif 1174 #endif 1175 #if defined(CONFIG_INET) || defined(CONFIG_IPV6) 1176 fail_ifa: 1177 #endif 1178 rtnl_lock(); 1179 rate_control_deinitialize(local); 1180 ieee80211_remove_interfaces(local); 1181 fail_rate: 1182 rtnl_unlock(); 1183 ieee80211_led_exit(local); 1184 ieee80211_wep_free(local); 1185 ieee80211_txq_teardown_flows(local); 1186 fail_flows: 1187 destroy_workqueue(local->workqueue); 1188 fail_workqueue: 1189 wiphy_unregister(local->hw.wiphy); 1190 fail_wiphy_register: 1191 if (local->wiphy_ciphers_allocated) 1192 kfree(local->hw.wiphy->cipher_suites); 1193 kfree(local->int_scan_req); 1194 return result; 1195 } 1196 EXPORT_SYMBOL(ieee80211_register_hw); 1197 1198 void ieee80211_unregister_hw(struct ieee80211_hw *hw) 1199 { 1200 struct ieee80211_local *local = hw_to_local(hw); 1201 1202 tasklet_kill(&local->tx_pending_tasklet); 1203 tasklet_kill(&local->tasklet); 1204 1205 #ifdef CONFIG_INET 1206 unregister_inetaddr_notifier(&local->ifa_notifier); 1207 #endif 1208 #if IS_ENABLED(CONFIG_IPV6) 1209 unregister_inet6addr_notifier(&local->ifa6_notifier); 1210 #endif 1211 1212 rtnl_lock(); 1213 1214 /* 1215 * At this point, interface list manipulations are fine 1216 * because the driver cannot be handing us frames any 1217 * more and the tasklet is killed. 1218 */ 1219 ieee80211_remove_interfaces(local); 1220 1221 rtnl_unlock(); 1222 1223 cancel_delayed_work_sync(&local->roc_work); 1224 cancel_work_sync(&local->restart_work); 1225 cancel_work_sync(&local->reconfig_filter); 1226 cancel_work_sync(&local->tdls_chsw_work); 1227 flush_work(&local->sched_scan_stopped_work); 1228 flush_work(&local->radar_detected_work); 1229 1230 ieee80211_clear_tx_pending(local); 1231 rate_control_deinitialize(local); 1232 1233 if (skb_queue_len(&local->skb_queue) || 1234 skb_queue_len(&local->skb_queue_unreliable)) 1235 wiphy_warn(local->hw.wiphy, "skb_queue not empty\n"); 1236 skb_queue_purge(&local->skb_queue); 1237 skb_queue_purge(&local->skb_queue_unreliable); 1238 skb_queue_purge(&local->skb_queue_tdls_chsw); 1239 ieee80211_txq_teardown_flows(local); 1240 1241 destroy_workqueue(local->workqueue); 1242 wiphy_unregister(local->hw.wiphy); 1243 ieee80211_wep_free(local); 1244 ieee80211_led_exit(local); 1245 kfree(local->int_scan_req); 1246 } 1247 EXPORT_SYMBOL(ieee80211_unregister_hw); 1248 1249 static int ieee80211_free_ack_frame(int id, void *p, void *data) 1250 { 1251 WARN_ONCE(1, "Have pending ack frames!\n"); 1252 kfree_skb(p); 1253 return 0; 1254 } 1255 1256 void ieee80211_free_hw(struct ieee80211_hw *hw) 1257 { 1258 struct ieee80211_local *local = hw_to_local(hw); 1259 1260 mutex_destroy(&local->iflist_mtx); 1261 mutex_destroy(&local->mtx); 1262 1263 if (local->wiphy_ciphers_allocated) 1264 kfree(local->hw.wiphy->cipher_suites); 1265 1266 idr_for_each(&local->ack_status_frames, 1267 ieee80211_free_ack_frame, NULL); 1268 idr_destroy(&local->ack_status_frames); 1269 1270 sta_info_stop(local); 1271 1272 ieee80211_free_led_names(local); 1273 1274 wiphy_free(local->hw.wiphy); 1275 } 1276 EXPORT_SYMBOL(ieee80211_free_hw); 1277 1278 static int __init ieee80211_init(void) 1279 { 1280 struct sk_buff *skb; 1281 int ret; 1282 1283 BUILD_BUG_ON(sizeof(struct ieee80211_tx_info) > sizeof(skb->cb)); 1284 BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, driver_data) + 1285 IEEE80211_TX_INFO_DRIVER_DATA_SIZE > sizeof(skb->cb)); 1286 1287 ret = rc80211_minstrel_init(); 1288 if (ret) 1289 return ret; 1290 1291 ret = rc80211_minstrel_ht_init(); 1292 if (ret) 1293 goto err_minstrel; 1294 1295 ret = ieee80211_iface_init(); 1296 if (ret) 1297 goto err_netdev; 1298 1299 return 0; 1300 err_netdev: 1301 rc80211_minstrel_ht_exit(); 1302 err_minstrel: 1303 rc80211_minstrel_exit(); 1304 1305 return ret; 1306 } 1307 1308 static void __exit ieee80211_exit(void) 1309 { 1310 rc80211_minstrel_ht_exit(); 1311 rc80211_minstrel_exit(); 1312 1313 ieee80211s_stop(); 1314 1315 ieee80211_iface_exit(); 1316 1317 rcu_barrier(); 1318 } 1319 1320 1321 subsys_initcall(ieee80211_init); 1322 module_exit(ieee80211_exit); 1323 1324 MODULE_DESCRIPTION("IEEE 802.11 subsystem"); 1325 MODULE_LICENSE("GPL"); 1326