1 #ifndef __NET_CFG80211_H 2 #define __NET_CFG80211_H 3 /* 4 * 802.11 device and configuration interface 5 * 6 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net> 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 <linux/netdevice.h> 14 #include <linux/debugfs.h> 15 #include <linux/list.h> 16 #include <linux/bug.h> 17 #include <linux/netlink.h> 18 #include <linux/skbuff.h> 19 #include <linux/nl80211.h> 20 #include <linux/if_ether.h> 21 #include <linux/ieee80211.h> 22 #include <net/regulatory.h> 23 24 /** 25 * DOC: Introduction 26 * 27 * cfg80211 is the configuration API for 802.11 devices in Linux. It bridges 28 * userspace and drivers, and offers some utility functionality associated 29 * with 802.11. cfg80211 must, directly or indirectly via mac80211, be used 30 * by all modern wireless drivers in Linux, so that they offer a consistent 31 * API through nl80211. For backward compatibility, cfg80211 also offers 32 * wireless extensions to userspace, but hides them from drivers completely. 33 * 34 * Additionally, cfg80211 contains code to help enforce regulatory spectrum 35 * use restrictions. 36 */ 37 38 39 /** 40 * DOC: Device registration 41 * 42 * In order for a driver to use cfg80211, it must register the hardware device 43 * with cfg80211. This happens through a number of hardware capability structs 44 * described below. 45 * 46 * The fundamental structure for each device is the 'wiphy', of which each 47 * instance describes a physical wireless device connected to the system. Each 48 * such wiphy can have zero, one, or many virtual interfaces associated with 49 * it, which need to be identified as such by pointing the network interface's 50 * @ieee80211_ptr pointer to a &struct wireless_dev which further describes 51 * the wireless part of the interface, normally this struct is embedded in the 52 * network interface's private data area. Drivers can optionally allow creating 53 * or destroying virtual interfaces on the fly, but without at least one or the 54 * ability to create some the wireless device isn't useful. 55 * 56 * Each wiphy structure contains device capability information, and also has 57 * a pointer to the various operations the driver offers. The definitions and 58 * structures here describe these capabilities in detail. 59 */ 60 61 struct wiphy; 62 63 /* 64 * wireless hardware capability structures 65 */ 66 67 /** 68 * enum ieee80211_band - supported frequency bands 69 * 70 * The bands are assigned this way because the supported 71 * bitrates differ in these bands. 72 * 73 * @IEEE80211_BAND_2GHZ: 2.4GHz ISM band 74 * @IEEE80211_BAND_5GHZ: around 5GHz band (4.9-5.7) 75 * @IEEE80211_BAND_60GHZ: around 60 GHz band (58.32 - 64.80 GHz) 76 * @IEEE80211_NUM_BANDS: number of defined bands 77 */ 78 enum ieee80211_band { 79 IEEE80211_BAND_2GHZ = NL80211_BAND_2GHZ, 80 IEEE80211_BAND_5GHZ = NL80211_BAND_5GHZ, 81 IEEE80211_BAND_60GHZ = NL80211_BAND_60GHZ, 82 83 /* keep last */ 84 IEEE80211_NUM_BANDS 85 }; 86 87 /** 88 * enum ieee80211_channel_flags - channel flags 89 * 90 * Channel flags set by the regulatory control code. 91 * 92 * @IEEE80211_CHAN_DISABLED: This channel is disabled. 93 * @IEEE80211_CHAN_PASSIVE_SCAN: Only passive scanning is permitted 94 * on this channel. 95 * @IEEE80211_CHAN_NO_IBSS: IBSS is not allowed on this channel. 96 * @IEEE80211_CHAN_RADAR: Radar detection is required on this channel. 97 * @IEEE80211_CHAN_NO_HT40PLUS: extension channel above this channel 98 * is not permitted. 99 * @IEEE80211_CHAN_NO_HT40MINUS: extension channel below this channel 100 * is not permitted. 101 * @IEEE80211_CHAN_NO_OFDM: OFDM is not allowed on this channel. 102 */ 103 enum ieee80211_channel_flags { 104 IEEE80211_CHAN_DISABLED = 1<<0, 105 IEEE80211_CHAN_PASSIVE_SCAN = 1<<1, 106 IEEE80211_CHAN_NO_IBSS = 1<<2, 107 IEEE80211_CHAN_RADAR = 1<<3, 108 IEEE80211_CHAN_NO_HT40PLUS = 1<<4, 109 IEEE80211_CHAN_NO_HT40MINUS = 1<<5, 110 IEEE80211_CHAN_NO_OFDM = 1<<6, 111 }; 112 113 #define IEEE80211_CHAN_NO_HT40 \ 114 (IEEE80211_CHAN_NO_HT40PLUS | IEEE80211_CHAN_NO_HT40MINUS) 115 116 /** 117 * struct ieee80211_channel - channel definition 118 * 119 * This structure describes a single channel for use 120 * with cfg80211. 121 * 122 * @center_freq: center frequency in MHz 123 * @hw_value: hardware-specific value for the channel 124 * @flags: channel flags from &enum ieee80211_channel_flags. 125 * @orig_flags: channel flags at registration time, used by regulatory 126 * code to support devices with additional restrictions 127 * @band: band this channel belongs to. 128 * @max_antenna_gain: maximum antenna gain in dBi 129 * @max_power: maximum transmission power (in dBm) 130 * @max_reg_power: maximum regulatory transmission power (in dBm) 131 * @beacon_found: helper to regulatory code to indicate when a beacon 132 * has been found on this channel. Use regulatory_hint_found_beacon() 133 * to enable this, this is useful only on 5 GHz band. 134 * @orig_mag: internal use 135 * @orig_mpwr: internal use 136 */ 137 struct ieee80211_channel { 138 enum ieee80211_band band; 139 u16 center_freq; 140 u16 hw_value; 141 u32 flags; 142 int max_antenna_gain; 143 int max_power; 144 int max_reg_power; 145 bool beacon_found; 146 u32 orig_flags; 147 int orig_mag, orig_mpwr; 148 }; 149 150 /** 151 * enum ieee80211_rate_flags - rate flags 152 * 153 * Hardware/specification flags for rates. These are structured 154 * in a way that allows using the same bitrate structure for 155 * different bands/PHY modes. 156 * 157 * @IEEE80211_RATE_SHORT_PREAMBLE: Hardware can send with short 158 * preamble on this bitrate; only relevant in 2.4GHz band and 159 * with CCK rates. 160 * @IEEE80211_RATE_MANDATORY_A: This bitrate is a mandatory rate 161 * when used with 802.11a (on the 5 GHz band); filled by the 162 * core code when registering the wiphy. 163 * @IEEE80211_RATE_MANDATORY_B: This bitrate is a mandatory rate 164 * when used with 802.11b (on the 2.4 GHz band); filled by the 165 * core code when registering the wiphy. 166 * @IEEE80211_RATE_MANDATORY_G: This bitrate is a mandatory rate 167 * when used with 802.11g (on the 2.4 GHz band); filled by the 168 * core code when registering the wiphy. 169 * @IEEE80211_RATE_ERP_G: This is an ERP rate in 802.11g mode. 170 */ 171 enum ieee80211_rate_flags { 172 IEEE80211_RATE_SHORT_PREAMBLE = 1<<0, 173 IEEE80211_RATE_MANDATORY_A = 1<<1, 174 IEEE80211_RATE_MANDATORY_B = 1<<2, 175 IEEE80211_RATE_MANDATORY_G = 1<<3, 176 IEEE80211_RATE_ERP_G = 1<<4, 177 }; 178 179 /** 180 * struct ieee80211_rate - bitrate definition 181 * 182 * This structure describes a bitrate that an 802.11 PHY can 183 * operate with. The two values @hw_value and @hw_value_short 184 * are only for driver use when pointers to this structure are 185 * passed around. 186 * 187 * @flags: rate-specific flags 188 * @bitrate: bitrate in units of 100 Kbps 189 * @hw_value: driver/hardware value for this rate 190 * @hw_value_short: driver/hardware value for this rate when 191 * short preamble is used 192 */ 193 struct ieee80211_rate { 194 u32 flags; 195 u16 bitrate; 196 u16 hw_value, hw_value_short; 197 }; 198 199 /** 200 * struct ieee80211_sta_ht_cap - STA's HT capabilities 201 * 202 * This structure describes most essential parameters needed 203 * to describe 802.11n HT capabilities for an STA. 204 * 205 * @ht_supported: is HT supported by the STA 206 * @cap: HT capabilities map as described in 802.11n spec 207 * @ampdu_factor: Maximum A-MPDU length factor 208 * @ampdu_density: Minimum A-MPDU spacing 209 * @mcs: Supported MCS rates 210 */ 211 struct ieee80211_sta_ht_cap { 212 u16 cap; /* use IEEE80211_HT_CAP_ */ 213 bool ht_supported; 214 u8 ampdu_factor; 215 u8 ampdu_density; 216 struct ieee80211_mcs_info mcs; 217 }; 218 219 /** 220 * struct ieee80211_sta_vht_cap - STA's VHT capabilities 221 * 222 * This structure describes most essential parameters needed 223 * to describe 802.11ac VHT capabilities for an STA. 224 * 225 * @vht_supported: is VHT supported by the STA 226 * @cap: VHT capabilities map as described in 802.11ac spec 227 * @vht_mcs: Supported VHT MCS rates 228 */ 229 struct ieee80211_sta_vht_cap { 230 bool vht_supported; 231 u32 cap; /* use IEEE80211_VHT_CAP_ */ 232 struct ieee80211_vht_mcs_info vht_mcs; 233 }; 234 235 /** 236 * struct ieee80211_supported_band - frequency band definition 237 * 238 * This structure describes a frequency band a wiphy 239 * is able to operate in. 240 * 241 * @channels: Array of channels the hardware can operate in 242 * in this band. 243 * @band: the band this structure represents 244 * @n_channels: Number of channels in @channels 245 * @bitrates: Array of bitrates the hardware can operate with 246 * in this band. Must be sorted to give a valid "supported 247 * rates" IE, i.e. CCK rates first, then OFDM. 248 * @n_bitrates: Number of bitrates in @bitrates 249 * @ht_cap: HT capabilities in this band 250 * @vht_cap: VHT capabilities in this band 251 */ 252 struct ieee80211_supported_band { 253 struct ieee80211_channel *channels; 254 struct ieee80211_rate *bitrates; 255 enum ieee80211_band band; 256 int n_channels; 257 int n_bitrates; 258 struct ieee80211_sta_ht_cap ht_cap; 259 struct ieee80211_sta_vht_cap vht_cap; 260 }; 261 262 /* 263 * Wireless hardware/device configuration structures and methods 264 */ 265 266 /** 267 * DOC: Actions and configuration 268 * 269 * Each wireless device and each virtual interface offer a set of configuration 270 * operations and other actions that are invoked by userspace. Each of these 271 * actions is described in the operations structure, and the parameters these 272 * operations use are described separately. 273 * 274 * Additionally, some operations are asynchronous and expect to get status 275 * information via some functions that drivers need to call. 276 * 277 * Scanning and BSS list handling with its associated functionality is described 278 * in a separate chapter. 279 */ 280 281 /** 282 * struct vif_params - describes virtual interface parameters 283 * @use_4addr: use 4-address frames 284 */ 285 struct vif_params { 286 int use_4addr; 287 }; 288 289 /** 290 * struct key_params - key information 291 * 292 * Information about a key 293 * 294 * @key: key material 295 * @key_len: length of key material 296 * @cipher: cipher suite selector 297 * @seq: sequence counter (IV/PN) for TKIP and CCMP keys, only used 298 * with the get_key() callback, must be in little endian, 299 * length given by @seq_len. 300 * @seq_len: length of @seq. 301 */ 302 struct key_params { 303 u8 *key; 304 u8 *seq; 305 int key_len; 306 int seq_len; 307 u32 cipher; 308 }; 309 310 /** 311 * struct cfg80211_chan_def - channel definition 312 * @chan: the (control) channel 313 * @width: channel width 314 * @center_freq1: center frequency of first segment 315 * @center_freq2: center frequency of second segment 316 * (only with 80+80 MHz) 317 */ 318 struct cfg80211_chan_def { 319 struct ieee80211_channel *chan; 320 enum nl80211_chan_width width; 321 u32 center_freq1; 322 u32 center_freq2; 323 }; 324 325 /** 326 * cfg80211_get_chandef_type - return old channel type from chandef 327 * @chandef: the channel definition 328 * 329 * Returns the old channel type (NOHT, HT20, HT40+/-) from a given 330 * chandef, which must have a bandwidth allowing this conversion. 331 */ 332 static inline enum nl80211_channel_type 333 cfg80211_get_chandef_type(const struct cfg80211_chan_def *chandef) 334 { 335 switch (chandef->width) { 336 case NL80211_CHAN_WIDTH_20_NOHT: 337 return NL80211_CHAN_NO_HT; 338 case NL80211_CHAN_WIDTH_20: 339 return NL80211_CHAN_HT20; 340 case NL80211_CHAN_WIDTH_40: 341 if (chandef->center_freq1 > chandef->chan->center_freq) 342 return NL80211_CHAN_HT40PLUS; 343 return NL80211_CHAN_HT40MINUS; 344 default: 345 WARN_ON(1); 346 return NL80211_CHAN_NO_HT; 347 } 348 } 349 350 /** 351 * cfg80211_chandef_create - create channel definition using channel type 352 * @chandef: the channel definition struct to fill 353 * @channel: the control channel 354 * @chantype: the channel type 355 * 356 * Given a channel type, create a channel definition. 357 */ 358 void cfg80211_chandef_create(struct cfg80211_chan_def *chandef, 359 struct ieee80211_channel *channel, 360 enum nl80211_channel_type chantype); 361 362 /** 363 * cfg80211_chandef_identical - check if two channel definitions are identical 364 * @chandef1: first channel definition 365 * @chandef2: second channel definition 366 * 367 * Returns %true if the channels defined by the channel definitions are 368 * identical, %false otherwise. 369 */ 370 static inline bool 371 cfg80211_chandef_identical(const struct cfg80211_chan_def *chandef1, 372 const struct cfg80211_chan_def *chandef2) 373 { 374 return (chandef1->chan == chandef2->chan && 375 chandef1->width == chandef2->width && 376 chandef1->center_freq1 == chandef2->center_freq1 && 377 chandef1->center_freq2 == chandef2->center_freq2); 378 } 379 380 /** 381 * cfg80211_chandef_compatible - check if two channel definitions are compatible 382 * @chandef1: first channel definition 383 * @chandef2: second channel definition 384 * 385 * Returns %NULL if the given channel definitions are incompatible, 386 * chandef1 or chandef2 otherwise. 387 */ 388 const struct cfg80211_chan_def * 389 cfg80211_chandef_compatible(const struct cfg80211_chan_def *chandef1, 390 const struct cfg80211_chan_def *chandef2); 391 392 /** 393 * cfg80211_chandef_valid - check if a channel definition is valid 394 * @chandef: the channel definition to check 395 */ 396 bool cfg80211_chandef_valid(const struct cfg80211_chan_def *chandef); 397 398 /** 399 * cfg80211_chandef_usable - check if secondary channels can be used 400 * @wiphy: the wiphy to validate against 401 * @chandef: the channel definition to check 402 * @prohibited_flags: the regulatory chanenl flags that must not be set 403 */ 404 bool cfg80211_chandef_usable(struct wiphy *wiphy, 405 const struct cfg80211_chan_def *chandef, 406 u32 prohibited_flags); 407 408 /** 409 * enum survey_info_flags - survey information flags 410 * 411 * @SURVEY_INFO_NOISE_DBM: noise (in dBm) was filled in 412 * @SURVEY_INFO_IN_USE: channel is currently being used 413 * @SURVEY_INFO_CHANNEL_TIME: channel active time (in ms) was filled in 414 * @SURVEY_INFO_CHANNEL_TIME_BUSY: channel busy time was filled in 415 * @SURVEY_INFO_CHANNEL_TIME_EXT_BUSY: extension channel busy time was filled in 416 * @SURVEY_INFO_CHANNEL_TIME_RX: channel receive time was filled in 417 * @SURVEY_INFO_CHANNEL_TIME_TX: channel transmit time was filled in 418 * 419 * Used by the driver to indicate which info in &struct survey_info 420 * it has filled in during the get_survey(). 421 */ 422 enum survey_info_flags { 423 SURVEY_INFO_NOISE_DBM = 1<<0, 424 SURVEY_INFO_IN_USE = 1<<1, 425 SURVEY_INFO_CHANNEL_TIME = 1<<2, 426 SURVEY_INFO_CHANNEL_TIME_BUSY = 1<<3, 427 SURVEY_INFO_CHANNEL_TIME_EXT_BUSY = 1<<4, 428 SURVEY_INFO_CHANNEL_TIME_RX = 1<<5, 429 SURVEY_INFO_CHANNEL_TIME_TX = 1<<6, 430 }; 431 432 /** 433 * struct survey_info - channel survey response 434 * 435 * @channel: the channel this survey record reports, mandatory 436 * @filled: bitflag of flags from &enum survey_info_flags 437 * @noise: channel noise in dBm. This and all following fields are 438 * optional 439 * @channel_time: amount of time in ms the radio spent on the channel 440 * @channel_time_busy: amount of time the primary channel was sensed busy 441 * @channel_time_ext_busy: amount of time the extension channel was sensed busy 442 * @channel_time_rx: amount of time the radio spent receiving data 443 * @channel_time_tx: amount of time the radio spent transmitting data 444 * 445 * Used by dump_survey() to report back per-channel survey information. 446 * 447 * This structure can later be expanded with things like 448 * channel duty cycle etc. 449 */ 450 struct survey_info { 451 struct ieee80211_channel *channel; 452 u64 channel_time; 453 u64 channel_time_busy; 454 u64 channel_time_ext_busy; 455 u64 channel_time_rx; 456 u64 channel_time_tx; 457 u32 filled; 458 s8 noise; 459 }; 460 461 /** 462 * struct cfg80211_crypto_settings - Crypto settings 463 * @wpa_versions: indicates which, if any, WPA versions are enabled 464 * (from enum nl80211_wpa_versions) 465 * @cipher_group: group key cipher suite (or 0 if unset) 466 * @n_ciphers_pairwise: number of AP supported unicast ciphers 467 * @ciphers_pairwise: unicast key cipher suites 468 * @n_akm_suites: number of AKM suites 469 * @akm_suites: AKM suites 470 * @control_port: Whether user space controls IEEE 802.1X port, i.e., 471 * sets/clears %NL80211_STA_FLAG_AUTHORIZED. If true, the driver is 472 * required to assume that the port is unauthorized until authorized by 473 * user space. Otherwise, port is marked authorized by default. 474 * @control_port_ethertype: the control port protocol that should be 475 * allowed through even on unauthorized ports 476 * @control_port_no_encrypt: TRUE to prevent encryption of control port 477 * protocol frames. 478 */ 479 struct cfg80211_crypto_settings { 480 u32 wpa_versions; 481 u32 cipher_group; 482 int n_ciphers_pairwise; 483 u32 ciphers_pairwise[NL80211_MAX_NR_CIPHER_SUITES]; 484 int n_akm_suites; 485 u32 akm_suites[NL80211_MAX_NR_AKM_SUITES]; 486 bool control_port; 487 __be16 control_port_ethertype; 488 bool control_port_no_encrypt; 489 }; 490 491 /** 492 * struct cfg80211_beacon_data - beacon data 493 * @head: head portion of beacon (before TIM IE) 494 * or %NULL if not changed 495 * @tail: tail portion of beacon (after TIM IE) 496 * or %NULL if not changed 497 * @head_len: length of @head 498 * @tail_len: length of @tail 499 * @beacon_ies: extra information element(s) to add into Beacon frames or %NULL 500 * @beacon_ies_len: length of beacon_ies in octets 501 * @proberesp_ies: extra information element(s) to add into Probe Response 502 * frames or %NULL 503 * @proberesp_ies_len: length of proberesp_ies in octets 504 * @assocresp_ies: extra information element(s) to add into (Re)Association 505 * Response frames or %NULL 506 * @assocresp_ies_len: length of assocresp_ies in octets 507 * @probe_resp_len: length of probe response template (@probe_resp) 508 * @probe_resp: probe response template (AP mode only) 509 */ 510 struct cfg80211_beacon_data { 511 const u8 *head, *tail; 512 const u8 *beacon_ies; 513 const u8 *proberesp_ies; 514 const u8 *assocresp_ies; 515 const u8 *probe_resp; 516 517 size_t head_len, tail_len; 518 size_t beacon_ies_len; 519 size_t proberesp_ies_len; 520 size_t assocresp_ies_len; 521 size_t probe_resp_len; 522 }; 523 524 /** 525 * struct cfg80211_ap_settings - AP configuration 526 * 527 * Used to configure an AP interface. 528 * 529 * @chandef: defines the channel to use 530 * @beacon: beacon data 531 * @beacon_interval: beacon interval 532 * @dtim_period: DTIM period 533 * @ssid: SSID to be used in the BSS (note: may be %NULL if not provided from 534 * user space) 535 * @ssid_len: length of @ssid 536 * @hidden_ssid: whether to hide the SSID in Beacon/Probe Response frames 537 * @crypto: crypto settings 538 * @privacy: the BSS uses privacy 539 * @auth_type: Authentication type (algorithm) 540 * @inactivity_timeout: time in seconds to determine station's inactivity. 541 * @p2p_ctwindow: P2P CT Window 542 * @p2p_opp_ps: P2P opportunistic PS 543 */ 544 struct cfg80211_ap_settings { 545 struct cfg80211_chan_def chandef; 546 547 struct cfg80211_beacon_data beacon; 548 549 int beacon_interval, dtim_period; 550 const u8 *ssid; 551 size_t ssid_len; 552 enum nl80211_hidden_ssid hidden_ssid; 553 struct cfg80211_crypto_settings crypto; 554 bool privacy; 555 enum nl80211_auth_type auth_type; 556 int inactivity_timeout; 557 u8 p2p_ctwindow; 558 bool p2p_opp_ps; 559 }; 560 561 /** 562 * enum plink_action - actions to perform in mesh peers 563 * 564 * @PLINK_ACTION_INVALID: action 0 is reserved 565 * @PLINK_ACTION_OPEN: start mesh peer link establishment 566 * @PLINK_ACTION_BLOCK: block traffic from this mesh peer 567 */ 568 enum plink_actions { 569 PLINK_ACTION_INVALID, 570 PLINK_ACTION_OPEN, 571 PLINK_ACTION_BLOCK, 572 }; 573 574 /** 575 * enum station_parameters_apply_mask - station parameter values to apply 576 * @STATION_PARAM_APPLY_UAPSD: apply new uAPSD parameters (uapsd_queues, max_sp) 577 * 578 * Not all station parameters have in-band "no change" signalling, 579 * for those that don't these flags will are used. 580 */ 581 enum station_parameters_apply_mask { 582 STATION_PARAM_APPLY_UAPSD = BIT(0), 583 }; 584 585 /** 586 * struct station_parameters - station parameters 587 * 588 * Used to change and create a new station. 589 * 590 * @vlan: vlan interface station should belong to 591 * @supported_rates: supported rates in IEEE 802.11 format 592 * (or NULL for no change) 593 * @supported_rates_len: number of supported rates 594 * @sta_flags_mask: station flags that changed 595 * (bitmask of BIT(NL80211_STA_FLAG_...)) 596 * @sta_flags_set: station flags values 597 * (bitmask of BIT(NL80211_STA_FLAG_...)) 598 * @listen_interval: listen interval or -1 for no change 599 * @aid: AID or zero for no change 600 * @plink_action: plink action to take 601 * @plink_state: set the peer link state for a station 602 * @ht_capa: HT capabilities of station 603 * @vht_capa: VHT capabilities of station 604 * @uapsd_queues: bitmap of queues configured for uapsd. same format 605 * as the AC bitmap in the QoS info field 606 * @max_sp: max Service Period. same format as the MAX_SP in the 607 * QoS info field (but already shifted down) 608 * @sta_modify_mask: bitmap indicating which parameters changed 609 * (for those that don't have a natural "no change" value), 610 * see &enum station_parameters_apply_mask 611 */ 612 struct station_parameters { 613 u8 *supported_rates; 614 struct net_device *vlan; 615 u32 sta_flags_mask, sta_flags_set; 616 u32 sta_modify_mask; 617 int listen_interval; 618 u16 aid; 619 u8 supported_rates_len; 620 u8 plink_action; 621 u8 plink_state; 622 struct ieee80211_ht_cap *ht_capa; 623 struct ieee80211_vht_cap *vht_capa; 624 u8 uapsd_queues; 625 u8 max_sp; 626 }; 627 628 /** 629 * enum station_info_flags - station information flags 630 * 631 * Used by the driver to indicate which info in &struct station_info 632 * it has filled in during get_station() or dump_station(). 633 * 634 * @STATION_INFO_INACTIVE_TIME: @inactive_time filled 635 * @STATION_INFO_RX_BYTES: @rx_bytes filled 636 * @STATION_INFO_TX_BYTES: @tx_bytes filled 637 * @STATION_INFO_LLID: @llid filled 638 * @STATION_INFO_PLID: @plid filled 639 * @STATION_INFO_PLINK_STATE: @plink_state filled 640 * @STATION_INFO_SIGNAL: @signal filled 641 * @STATION_INFO_TX_BITRATE: @txrate fields are filled 642 * (tx_bitrate, tx_bitrate_flags and tx_bitrate_mcs) 643 * @STATION_INFO_RX_PACKETS: @rx_packets filled 644 * @STATION_INFO_TX_PACKETS: @tx_packets filled 645 * @STATION_INFO_TX_RETRIES: @tx_retries filled 646 * @STATION_INFO_TX_FAILED: @tx_failed filled 647 * @STATION_INFO_RX_DROP_MISC: @rx_dropped_misc filled 648 * @STATION_INFO_SIGNAL_AVG: @signal_avg filled 649 * @STATION_INFO_RX_BITRATE: @rxrate fields are filled 650 * @STATION_INFO_BSS_PARAM: @bss_param filled 651 * @STATION_INFO_CONNECTED_TIME: @connected_time filled 652 * @STATION_INFO_ASSOC_REQ_IES: @assoc_req_ies filled 653 * @STATION_INFO_STA_FLAGS: @sta_flags filled 654 * @STATION_INFO_BEACON_LOSS_COUNT: @beacon_loss_count filled 655 * @STATION_INFO_T_OFFSET: @t_offset filled 656 */ 657 enum station_info_flags { 658 STATION_INFO_INACTIVE_TIME = 1<<0, 659 STATION_INFO_RX_BYTES = 1<<1, 660 STATION_INFO_TX_BYTES = 1<<2, 661 STATION_INFO_LLID = 1<<3, 662 STATION_INFO_PLID = 1<<4, 663 STATION_INFO_PLINK_STATE = 1<<5, 664 STATION_INFO_SIGNAL = 1<<6, 665 STATION_INFO_TX_BITRATE = 1<<7, 666 STATION_INFO_RX_PACKETS = 1<<8, 667 STATION_INFO_TX_PACKETS = 1<<9, 668 STATION_INFO_TX_RETRIES = 1<<10, 669 STATION_INFO_TX_FAILED = 1<<11, 670 STATION_INFO_RX_DROP_MISC = 1<<12, 671 STATION_INFO_SIGNAL_AVG = 1<<13, 672 STATION_INFO_RX_BITRATE = 1<<14, 673 STATION_INFO_BSS_PARAM = 1<<15, 674 STATION_INFO_CONNECTED_TIME = 1<<16, 675 STATION_INFO_ASSOC_REQ_IES = 1<<17, 676 STATION_INFO_STA_FLAGS = 1<<18, 677 STATION_INFO_BEACON_LOSS_COUNT = 1<<19, 678 STATION_INFO_T_OFFSET = 1<<20, 679 }; 680 681 /** 682 * enum station_info_rate_flags - bitrate info flags 683 * 684 * Used by the driver to indicate the specific rate transmission 685 * type for 802.11n transmissions. 686 * 687 * @RATE_INFO_FLAGS_MCS: mcs field filled with HT MCS 688 * @RATE_INFO_FLAGS_VHT_MCS: mcs field filled with VHT MCS 689 * @RATE_INFO_FLAGS_40_MHZ_WIDTH: 40 MHz width transmission 690 * @RATE_INFO_FLAGS_80_MHZ_WIDTH: 80 MHz width transmission 691 * @RATE_INFO_FLAGS_80P80_MHZ_WIDTH: 80+80 MHz width transmission 692 * @RATE_INFO_FLAGS_160_MHZ_WIDTH: 160 MHz width transmission 693 * @RATE_INFO_FLAGS_SHORT_GI: 400ns guard interval 694 * @RATE_INFO_FLAGS_60G: 60GHz MCS 695 */ 696 enum rate_info_flags { 697 RATE_INFO_FLAGS_MCS = BIT(0), 698 RATE_INFO_FLAGS_VHT_MCS = BIT(1), 699 RATE_INFO_FLAGS_40_MHZ_WIDTH = BIT(2), 700 RATE_INFO_FLAGS_80_MHZ_WIDTH = BIT(3), 701 RATE_INFO_FLAGS_80P80_MHZ_WIDTH = BIT(4), 702 RATE_INFO_FLAGS_160_MHZ_WIDTH = BIT(5), 703 RATE_INFO_FLAGS_SHORT_GI = BIT(6), 704 RATE_INFO_FLAGS_60G = BIT(7), 705 }; 706 707 /** 708 * struct rate_info - bitrate information 709 * 710 * Information about a receiving or transmitting bitrate 711 * 712 * @flags: bitflag of flags from &enum rate_info_flags 713 * @mcs: mcs index if struct describes a 802.11n bitrate 714 * @legacy: bitrate in 100kbit/s for 802.11abg 715 * @nss: number of streams (VHT only) 716 */ 717 struct rate_info { 718 u8 flags; 719 u8 mcs; 720 u16 legacy; 721 u8 nss; 722 }; 723 724 /** 725 * enum station_info_rate_flags - bitrate info flags 726 * 727 * Used by the driver to indicate the specific rate transmission 728 * type for 802.11n transmissions. 729 * 730 * @BSS_PARAM_FLAGS_CTS_PROT: whether CTS protection is enabled 731 * @BSS_PARAM_FLAGS_SHORT_PREAMBLE: whether short preamble is enabled 732 * @BSS_PARAM_FLAGS_SHORT_SLOT_TIME: whether short slot time is enabled 733 */ 734 enum bss_param_flags { 735 BSS_PARAM_FLAGS_CTS_PROT = 1<<0, 736 BSS_PARAM_FLAGS_SHORT_PREAMBLE = 1<<1, 737 BSS_PARAM_FLAGS_SHORT_SLOT_TIME = 1<<2, 738 }; 739 740 /** 741 * struct sta_bss_parameters - BSS parameters for the attached station 742 * 743 * Information about the currently associated BSS 744 * 745 * @flags: bitflag of flags from &enum bss_param_flags 746 * @dtim_period: DTIM period for the BSS 747 * @beacon_interval: beacon interval 748 */ 749 struct sta_bss_parameters { 750 u8 flags; 751 u8 dtim_period; 752 u16 beacon_interval; 753 }; 754 755 /** 756 * struct station_info - station information 757 * 758 * Station information filled by driver for get_station() and dump_station. 759 * 760 * @filled: bitflag of flags from &enum station_info_flags 761 * @connected_time: time(in secs) since a station is last connected 762 * @inactive_time: time since last station activity (tx/rx) in milliseconds 763 * @rx_bytes: bytes received from this station 764 * @tx_bytes: bytes transmitted to this station 765 * @llid: mesh local link id 766 * @plid: mesh peer link id 767 * @plink_state: mesh peer link state 768 * @signal: The signal strength, type depends on the wiphy's signal_type. 769 * For CFG80211_SIGNAL_TYPE_MBM, value is expressed in _dBm_. 770 * @signal_avg: Average signal strength, type depends on the wiphy's signal_type. 771 * For CFG80211_SIGNAL_TYPE_MBM, value is expressed in _dBm_. 772 * @txrate: current unicast bitrate from this station 773 * @rxrate: current unicast bitrate to this station 774 * @rx_packets: packets received from this station 775 * @tx_packets: packets transmitted to this station 776 * @tx_retries: cumulative retry counts 777 * @tx_failed: number of failed transmissions (retries exceeded, no ACK) 778 * @rx_dropped_misc: Dropped for un-specified reason. 779 * @bss_param: current BSS parameters 780 * @generation: generation number for nl80211 dumps. 781 * This number should increase every time the list of stations 782 * changes, i.e. when a station is added or removed, so that 783 * userspace can tell whether it got a consistent snapshot. 784 * @assoc_req_ies: IEs from (Re)Association Request. 785 * This is used only when in AP mode with drivers that do not use 786 * user space MLME/SME implementation. The information is provided for 787 * the cfg80211_new_sta() calls to notify user space of the IEs. 788 * @assoc_req_ies_len: Length of assoc_req_ies buffer in octets. 789 * @sta_flags: station flags mask & values 790 * @beacon_loss_count: Number of times beacon loss event has triggered. 791 * @t_offset: Time offset of the station relative to this host. 792 */ 793 struct station_info { 794 u32 filled; 795 u32 connected_time; 796 u32 inactive_time; 797 u32 rx_bytes; 798 u32 tx_bytes; 799 u16 llid; 800 u16 plid; 801 u8 plink_state; 802 s8 signal; 803 s8 signal_avg; 804 struct rate_info txrate; 805 struct rate_info rxrate; 806 u32 rx_packets; 807 u32 tx_packets; 808 u32 tx_retries; 809 u32 tx_failed; 810 u32 rx_dropped_misc; 811 struct sta_bss_parameters bss_param; 812 struct nl80211_sta_flag_update sta_flags; 813 814 int generation; 815 816 const u8 *assoc_req_ies; 817 size_t assoc_req_ies_len; 818 819 u32 beacon_loss_count; 820 s64 t_offset; 821 822 /* 823 * Note: Add a new enum station_info_flags value for each new field and 824 * use it to check which fields are initialized. 825 */ 826 }; 827 828 /** 829 * enum monitor_flags - monitor flags 830 * 831 * Monitor interface configuration flags. Note that these must be the bits 832 * according to the nl80211 flags. 833 * 834 * @MONITOR_FLAG_FCSFAIL: pass frames with bad FCS 835 * @MONITOR_FLAG_PLCPFAIL: pass frames with bad PLCP 836 * @MONITOR_FLAG_CONTROL: pass control frames 837 * @MONITOR_FLAG_OTHER_BSS: disable BSSID filtering 838 * @MONITOR_FLAG_COOK_FRAMES: report frames after processing 839 */ 840 enum monitor_flags { 841 MONITOR_FLAG_FCSFAIL = 1<<NL80211_MNTR_FLAG_FCSFAIL, 842 MONITOR_FLAG_PLCPFAIL = 1<<NL80211_MNTR_FLAG_PLCPFAIL, 843 MONITOR_FLAG_CONTROL = 1<<NL80211_MNTR_FLAG_CONTROL, 844 MONITOR_FLAG_OTHER_BSS = 1<<NL80211_MNTR_FLAG_OTHER_BSS, 845 MONITOR_FLAG_COOK_FRAMES = 1<<NL80211_MNTR_FLAG_COOK_FRAMES, 846 }; 847 848 /** 849 * enum mpath_info_flags - mesh path information flags 850 * 851 * Used by the driver to indicate which info in &struct mpath_info it has filled 852 * in during get_station() or dump_station(). 853 * 854 * @MPATH_INFO_FRAME_QLEN: @frame_qlen filled 855 * @MPATH_INFO_SN: @sn filled 856 * @MPATH_INFO_METRIC: @metric filled 857 * @MPATH_INFO_EXPTIME: @exptime filled 858 * @MPATH_INFO_DISCOVERY_TIMEOUT: @discovery_timeout filled 859 * @MPATH_INFO_DISCOVERY_RETRIES: @discovery_retries filled 860 * @MPATH_INFO_FLAGS: @flags filled 861 */ 862 enum mpath_info_flags { 863 MPATH_INFO_FRAME_QLEN = BIT(0), 864 MPATH_INFO_SN = BIT(1), 865 MPATH_INFO_METRIC = BIT(2), 866 MPATH_INFO_EXPTIME = BIT(3), 867 MPATH_INFO_DISCOVERY_TIMEOUT = BIT(4), 868 MPATH_INFO_DISCOVERY_RETRIES = BIT(5), 869 MPATH_INFO_FLAGS = BIT(6), 870 }; 871 872 /** 873 * struct mpath_info - mesh path information 874 * 875 * Mesh path information filled by driver for get_mpath() and dump_mpath(). 876 * 877 * @filled: bitfield of flags from &enum mpath_info_flags 878 * @frame_qlen: number of queued frames for this destination 879 * @sn: target sequence number 880 * @metric: metric (cost) of this mesh path 881 * @exptime: expiration time for the mesh path from now, in msecs 882 * @flags: mesh path flags 883 * @discovery_timeout: total mesh path discovery timeout, in msecs 884 * @discovery_retries: mesh path discovery retries 885 * @generation: generation number for nl80211 dumps. 886 * This number should increase every time the list of mesh paths 887 * changes, i.e. when a station is added or removed, so that 888 * userspace can tell whether it got a consistent snapshot. 889 */ 890 struct mpath_info { 891 u32 filled; 892 u32 frame_qlen; 893 u32 sn; 894 u32 metric; 895 u32 exptime; 896 u32 discovery_timeout; 897 u8 discovery_retries; 898 u8 flags; 899 900 int generation; 901 }; 902 903 /** 904 * struct bss_parameters - BSS parameters 905 * 906 * Used to change BSS parameters (mainly for AP mode). 907 * 908 * @use_cts_prot: Whether to use CTS protection 909 * (0 = no, 1 = yes, -1 = do not change) 910 * @use_short_preamble: Whether the use of short preambles is allowed 911 * (0 = no, 1 = yes, -1 = do not change) 912 * @use_short_slot_time: Whether the use of short slot time is allowed 913 * (0 = no, 1 = yes, -1 = do not change) 914 * @basic_rates: basic rates in IEEE 802.11 format 915 * (or NULL for no change) 916 * @basic_rates_len: number of basic rates 917 * @ap_isolate: do not forward packets between connected stations 918 * @ht_opmode: HT Operation mode 919 * (u16 = opmode, -1 = do not change) 920 * @p2p_ctwindow: P2P CT Window (-1 = no change) 921 * @p2p_opp_ps: P2P opportunistic PS (-1 = no change) 922 */ 923 struct bss_parameters { 924 int use_cts_prot; 925 int use_short_preamble; 926 int use_short_slot_time; 927 u8 *basic_rates; 928 u8 basic_rates_len; 929 int ap_isolate; 930 int ht_opmode; 931 s8 p2p_ctwindow, p2p_opp_ps; 932 }; 933 934 /** 935 * struct mesh_config - 802.11s mesh configuration 936 * 937 * These parameters can be changed while the mesh is active. 938 * 939 * @dot11MeshRetryTimeout: the initial retry timeout in millisecond units used 940 * by the Mesh Peering Open message 941 * @dot11MeshConfirmTimeout: the initial retry timeout in millisecond units 942 * used by the Mesh Peering Open message 943 * @dot11MeshHoldingTimeout: the confirm timeout in millisecond units used by 944 * the mesh peering management to close a mesh peering 945 * @dot11MeshMaxPeerLinks: the maximum number of peer links allowed on this 946 * mesh interface 947 * @dot11MeshMaxRetries: the maximum number of peer link open retries that can 948 * be sent to establish a new peer link instance in a mesh 949 * @dot11MeshTTL: the value of TTL field set at a source mesh STA 950 * @element_ttl: the value of TTL field set at a mesh STA for path selection 951 * elements 952 * @auto_open_plinks: whether we should automatically open peer links when we 953 * detect compatible mesh peers 954 * @dot11MeshNbrOffsetMaxNeighbor: the maximum number of neighbors to 955 * synchronize to for 11s default synchronization method 956 * @dot11MeshHWMPmaxPREQretries: the number of action frames containing a PREQ 957 * that an originator mesh STA can send to a particular path target 958 * @path_refresh_time: how frequently to refresh mesh paths in milliseconds 959 * @min_discovery_timeout: the minimum length of time to wait until giving up on 960 * a path discovery in milliseconds 961 * @dot11MeshHWMPactivePathTimeout: the time (in TUs) for which mesh STAs 962 * receiving a PREQ shall consider the forwarding information from the 963 * root to be valid. (TU = time unit) 964 * @dot11MeshHWMPpreqMinInterval: the minimum interval of time (in TUs) during 965 * which a mesh STA can send only one action frame containing a PREQ 966 * element 967 * @dot11MeshHWMPperrMinInterval: the minimum interval of time (in TUs) during 968 * which a mesh STA can send only one Action frame containing a PERR 969 * element 970 * @dot11MeshHWMPnetDiameterTraversalTime: the interval of time (in TUs) that 971 * it takes for an HWMP information element to propagate across the mesh 972 * @dot11MeshHWMPRootMode: the configuration of a mesh STA as root mesh STA 973 * @dot11MeshHWMPRannInterval: the interval of time (in TUs) between root 974 * announcements are transmitted 975 * @dot11MeshGateAnnouncementProtocol: whether to advertise that this mesh 976 * station has access to a broader network beyond the MBSS. (This is 977 * missnamed in draft 12.0: dot11MeshGateAnnouncementProtocol set to true 978 * only means that the station will announce others it's a mesh gate, but 979 * not necessarily using the gate announcement protocol. Still keeping the 980 * same nomenclature to be in sync with the spec) 981 * @dot11MeshForwarding: whether the Mesh STA is forwarding or non-forwarding 982 * entity (default is TRUE - forwarding entity) 983 * @rssi_threshold: the threshold for average signal strength of candidate 984 * station to establish a peer link 985 * @ht_opmode: mesh HT protection mode 986 * 987 * @dot11MeshHWMPactivePathToRootTimeout: The time (in TUs) for which mesh STAs 988 * receiving a proactive PREQ shall consider the forwarding information to 989 * the root mesh STA to be valid. 990 * 991 * @dot11MeshHWMProotInterval: The interval of time (in TUs) between proactive 992 * PREQs are transmitted. 993 * @dot11MeshHWMPconfirmationInterval: The minimum interval of time (in TUs) 994 * during which a mesh STA can send only one Action frame containing 995 * a PREQ element for root path confirmation. 996 */ 997 struct mesh_config { 998 u16 dot11MeshRetryTimeout; 999 u16 dot11MeshConfirmTimeout; 1000 u16 dot11MeshHoldingTimeout; 1001 u16 dot11MeshMaxPeerLinks; 1002 u8 dot11MeshMaxRetries; 1003 u8 dot11MeshTTL; 1004 u8 element_ttl; 1005 bool auto_open_plinks; 1006 u32 dot11MeshNbrOffsetMaxNeighbor; 1007 u8 dot11MeshHWMPmaxPREQretries; 1008 u32 path_refresh_time; 1009 u16 min_discovery_timeout; 1010 u32 dot11MeshHWMPactivePathTimeout; 1011 u16 dot11MeshHWMPpreqMinInterval; 1012 u16 dot11MeshHWMPperrMinInterval; 1013 u16 dot11MeshHWMPnetDiameterTraversalTime; 1014 u8 dot11MeshHWMPRootMode; 1015 u16 dot11MeshHWMPRannInterval; 1016 bool dot11MeshGateAnnouncementProtocol; 1017 bool dot11MeshForwarding; 1018 s32 rssi_threshold; 1019 u16 ht_opmode; 1020 u32 dot11MeshHWMPactivePathToRootTimeout; 1021 u16 dot11MeshHWMProotInterval; 1022 u16 dot11MeshHWMPconfirmationInterval; 1023 }; 1024 1025 /** 1026 * struct mesh_setup - 802.11s mesh setup configuration 1027 * @chandef: defines the channel to use 1028 * @mesh_id: the mesh ID 1029 * @mesh_id_len: length of the mesh ID, at least 1 and at most 32 bytes 1030 * @sync_method: which synchronization method to use 1031 * @path_sel_proto: which path selection protocol to use 1032 * @path_metric: which metric to use 1033 * @ie: vendor information elements (optional) 1034 * @ie_len: length of vendor information elements 1035 * @is_authenticated: this mesh requires authentication 1036 * @is_secure: this mesh uses security 1037 * @mcast_rate: multicat rate for Mesh Node [6Mbps is the default for 802.11a] 1038 * 1039 * These parameters are fixed when the mesh is created. 1040 */ 1041 struct mesh_setup { 1042 struct cfg80211_chan_def chandef; 1043 const u8 *mesh_id; 1044 u8 mesh_id_len; 1045 u8 sync_method; 1046 u8 path_sel_proto; 1047 u8 path_metric; 1048 const u8 *ie; 1049 u8 ie_len; 1050 bool is_authenticated; 1051 bool is_secure; 1052 int mcast_rate[IEEE80211_NUM_BANDS]; 1053 }; 1054 1055 /** 1056 * struct ieee80211_txq_params - TX queue parameters 1057 * @ac: AC identifier 1058 * @txop: Maximum burst time in units of 32 usecs, 0 meaning disabled 1059 * @cwmin: Minimum contention window [a value of the form 2^n-1 in the range 1060 * 1..32767] 1061 * @cwmax: Maximum contention window [a value of the form 2^n-1 in the range 1062 * 1..32767] 1063 * @aifs: Arbitration interframe space [0..255] 1064 */ 1065 struct ieee80211_txq_params { 1066 enum nl80211_ac ac; 1067 u16 txop; 1068 u16 cwmin; 1069 u16 cwmax; 1070 u8 aifs; 1071 }; 1072 1073 /** 1074 * DOC: Scanning and BSS list handling 1075 * 1076 * The scanning process itself is fairly simple, but cfg80211 offers quite 1077 * a bit of helper functionality. To start a scan, the scan operation will 1078 * be invoked with a scan definition. This scan definition contains the 1079 * channels to scan, and the SSIDs to send probe requests for (including the 1080 * wildcard, if desired). A passive scan is indicated by having no SSIDs to 1081 * probe. Additionally, a scan request may contain extra information elements 1082 * that should be added to the probe request. The IEs are guaranteed to be 1083 * well-formed, and will not exceed the maximum length the driver advertised 1084 * in the wiphy structure. 1085 * 1086 * When scanning finds a BSS, cfg80211 needs to be notified of that, because 1087 * it is responsible for maintaining the BSS list; the driver should not 1088 * maintain a list itself. For this notification, various functions exist. 1089 * 1090 * Since drivers do not maintain a BSS list, there are also a number of 1091 * functions to search for a BSS and obtain information about it from the 1092 * BSS structure cfg80211 maintains. The BSS list is also made available 1093 * to userspace. 1094 */ 1095 1096 /** 1097 * struct cfg80211_ssid - SSID description 1098 * @ssid: the SSID 1099 * @ssid_len: length of the ssid 1100 */ 1101 struct cfg80211_ssid { 1102 u8 ssid[IEEE80211_MAX_SSID_LEN]; 1103 u8 ssid_len; 1104 }; 1105 1106 /** 1107 * struct cfg80211_scan_request - scan request description 1108 * 1109 * @ssids: SSIDs to scan for (active scan only) 1110 * @n_ssids: number of SSIDs 1111 * @channels: channels to scan on. 1112 * @n_channels: total number of channels to scan 1113 * @ie: optional information element(s) to add into Probe Request or %NULL 1114 * @ie_len: length of ie in octets 1115 * @flags: bit field of flags controlling operation 1116 * @rates: bitmap of rates to advertise for each band 1117 * @wiphy: the wiphy this was for 1118 * @scan_start: time (in jiffies) when the scan started 1119 * @wdev: the wireless device to scan for 1120 * @aborted: (internal) scan request was notified as aborted 1121 * @no_cck: used to send probe requests at non CCK rate in 2GHz band 1122 */ 1123 struct cfg80211_scan_request { 1124 struct cfg80211_ssid *ssids; 1125 int n_ssids; 1126 u32 n_channels; 1127 const u8 *ie; 1128 size_t ie_len; 1129 u32 flags; 1130 1131 u32 rates[IEEE80211_NUM_BANDS]; 1132 1133 struct wireless_dev *wdev; 1134 1135 /* internal */ 1136 struct wiphy *wiphy; 1137 unsigned long scan_start; 1138 bool aborted; 1139 bool no_cck; 1140 1141 /* keep last */ 1142 struct ieee80211_channel *channels[0]; 1143 }; 1144 1145 /** 1146 * struct cfg80211_match_set - sets of attributes to match 1147 * 1148 * @ssid: SSID to be matched 1149 */ 1150 struct cfg80211_match_set { 1151 struct cfg80211_ssid ssid; 1152 }; 1153 1154 /** 1155 * struct cfg80211_sched_scan_request - scheduled scan request description 1156 * 1157 * @ssids: SSIDs to scan for (passed in the probe_reqs in active scans) 1158 * @n_ssids: number of SSIDs 1159 * @n_channels: total number of channels to scan 1160 * @interval: interval between each scheduled scan cycle 1161 * @ie: optional information element(s) to add into Probe Request or %NULL 1162 * @ie_len: length of ie in octets 1163 * @flags: bit field of flags controlling operation 1164 * @match_sets: sets of parameters to be matched for a scan result 1165 * entry to be considered valid and to be passed to the host 1166 * (others are filtered out). 1167 * If ommited, all results are passed. 1168 * @n_match_sets: number of match sets 1169 * @wiphy: the wiphy this was for 1170 * @dev: the interface 1171 * @channels: channels to scan 1172 * @rssi_thold: don't report scan results below this threshold (in s32 dBm) 1173 */ 1174 struct cfg80211_sched_scan_request { 1175 struct cfg80211_ssid *ssids; 1176 int n_ssids; 1177 u32 n_channels; 1178 u32 interval; 1179 const u8 *ie; 1180 size_t ie_len; 1181 u32 flags; 1182 struct cfg80211_match_set *match_sets; 1183 int n_match_sets; 1184 s32 rssi_thold; 1185 1186 /* internal */ 1187 struct wiphy *wiphy; 1188 struct net_device *dev; 1189 unsigned long scan_start; 1190 1191 /* keep last */ 1192 struct ieee80211_channel *channels[0]; 1193 }; 1194 1195 /** 1196 * enum cfg80211_signal_type - signal type 1197 * 1198 * @CFG80211_SIGNAL_TYPE_NONE: no signal strength information available 1199 * @CFG80211_SIGNAL_TYPE_MBM: signal strength in mBm (100*dBm) 1200 * @CFG80211_SIGNAL_TYPE_UNSPEC: signal strength, increasing from 0 through 100 1201 */ 1202 enum cfg80211_signal_type { 1203 CFG80211_SIGNAL_TYPE_NONE, 1204 CFG80211_SIGNAL_TYPE_MBM, 1205 CFG80211_SIGNAL_TYPE_UNSPEC, 1206 }; 1207 1208 /** 1209 * struct cfg80211_bss_ie_data - BSS entry IE data 1210 * @rcu_head: internal use, for freeing 1211 * @len: length of the IEs 1212 * @data: IE data 1213 */ 1214 struct cfg80211_bss_ies { 1215 struct rcu_head rcu_head; 1216 int len; 1217 u8 data[]; 1218 }; 1219 1220 /** 1221 * struct cfg80211_bss - BSS description 1222 * 1223 * This structure describes a BSS (which may also be a mesh network) 1224 * for use in scan results and similar. 1225 * 1226 * @channel: channel this BSS is on 1227 * @bssid: BSSID of the BSS 1228 * @tsf: timestamp of last received update 1229 * @beacon_interval: the beacon interval as from the frame 1230 * @capability: the capability field in host byte order 1231 * @ies: the information elements (Note that there 1232 * is no guarantee that these are well-formed!); this is a pointer to 1233 * either the beacon_ies or proberesp_ies depending on whether Probe 1234 * Response frame has been received 1235 * @beacon_ies: the information elements from the last Beacon frame 1236 * @proberesp_ies: the information elements from the last Probe Response frame 1237 * @signal: signal strength value (type depends on the wiphy's signal_type) 1238 * @free_priv: function pointer to free private data 1239 * @priv: private area for driver use, has at least wiphy->bss_priv_size bytes 1240 */ 1241 struct cfg80211_bss { 1242 u64 tsf; 1243 1244 struct ieee80211_channel *channel; 1245 1246 const struct cfg80211_bss_ies __rcu *ies; 1247 const struct cfg80211_bss_ies __rcu *beacon_ies; 1248 const struct cfg80211_bss_ies __rcu *proberesp_ies; 1249 1250 void (*free_priv)(struct cfg80211_bss *bss); 1251 1252 s32 signal; 1253 1254 u16 beacon_interval; 1255 u16 capability; 1256 1257 u8 bssid[ETH_ALEN]; 1258 1259 u8 priv[0] __attribute__((__aligned__(sizeof(void *)))); 1260 }; 1261 1262 /** 1263 * ieee80211_bss_get_ie - find IE with given ID 1264 * @bss: the bss to search 1265 * @ie: the IE ID 1266 * 1267 * Note that the return value is an RCU-protected pointer, so 1268 * rcu_read_lock() must be held when calling this function. 1269 * Returns %NULL if not found. 1270 */ 1271 const u8 *ieee80211_bss_get_ie(struct cfg80211_bss *bss, u8 ie); 1272 1273 1274 /** 1275 * struct cfg80211_auth_request - Authentication request data 1276 * 1277 * This structure provides information needed to complete IEEE 802.11 1278 * authentication. 1279 * 1280 * @bss: The BSS to authenticate with. 1281 * @auth_type: Authentication type (algorithm) 1282 * @ie: Extra IEs to add to Authentication frame or %NULL 1283 * @ie_len: Length of ie buffer in octets 1284 * @key_len: length of WEP key for shared key authentication 1285 * @key_idx: index of WEP key for shared key authentication 1286 * @key: WEP key for shared key authentication 1287 * @sae_data: Non-IE data to use with SAE or %NULL. This starts with 1288 * Authentication transaction sequence number field. 1289 * @sae_data_len: Length of sae_data buffer in octets 1290 */ 1291 struct cfg80211_auth_request { 1292 struct cfg80211_bss *bss; 1293 const u8 *ie; 1294 size_t ie_len; 1295 enum nl80211_auth_type auth_type; 1296 const u8 *key; 1297 u8 key_len, key_idx; 1298 const u8 *sae_data; 1299 size_t sae_data_len; 1300 }; 1301 1302 /** 1303 * enum cfg80211_assoc_req_flags - Over-ride default behaviour in association. 1304 * 1305 * @ASSOC_REQ_DISABLE_HT: Disable HT (802.11n) 1306 */ 1307 enum cfg80211_assoc_req_flags { 1308 ASSOC_REQ_DISABLE_HT = BIT(0), 1309 }; 1310 1311 /** 1312 * struct cfg80211_assoc_request - (Re)Association request data 1313 * 1314 * This structure provides information needed to complete IEEE 802.11 1315 * (re)association. 1316 * @bss: The BSS to associate with. If the call is successful the driver 1317 * is given a reference that it must release, normally via a call to 1318 * cfg80211_send_rx_assoc(), or, if association timed out, with a 1319 * call to cfg80211_put_bss() (in addition to calling 1320 * cfg80211_send_assoc_timeout()) 1321 * @ie: Extra IEs to add to (Re)Association Request frame or %NULL 1322 * @ie_len: Length of ie buffer in octets 1323 * @use_mfp: Use management frame protection (IEEE 802.11w) in this association 1324 * @crypto: crypto settings 1325 * @prev_bssid: previous BSSID, if not %NULL use reassociate frame 1326 * @flags: See &enum cfg80211_assoc_req_flags 1327 * @ht_capa: HT Capabilities over-rides. Values set in ht_capa_mask 1328 * will be used in ht_capa. Un-supported values will be ignored. 1329 * @ht_capa_mask: The bits of ht_capa which are to be used. 1330 */ 1331 struct cfg80211_assoc_request { 1332 struct cfg80211_bss *bss; 1333 const u8 *ie, *prev_bssid; 1334 size_t ie_len; 1335 struct cfg80211_crypto_settings crypto; 1336 bool use_mfp; 1337 u32 flags; 1338 struct ieee80211_ht_cap ht_capa; 1339 struct ieee80211_ht_cap ht_capa_mask; 1340 }; 1341 1342 /** 1343 * struct cfg80211_deauth_request - Deauthentication request data 1344 * 1345 * This structure provides information needed to complete IEEE 802.11 1346 * deauthentication. 1347 * 1348 * @bssid: the BSSID of the BSS to deauthenticate from 1349 * @ie: Extra IEs to add to Deauthentication frame or %NULL 1350 * @ie_len: Length of ie buffer in octets 1351 * @reason_code: The reason code for the deauthentication 1352 */ 1353 struct cfg80211_deauth_request { 1354 const u8 *bssid; 1355 const u8 *ie; 1356 size_t ie_len; 1357 u16 reason_code; 1358 bool local_state_change; 1359 }; 1360 1361 /** 1362 * struct cfg80211_disassoc_request - Disassociation request data 1363 * 1364 * This structure provides information needed to complete IEEE 802.11 1365 * disassocation. 1366 * 1367 * @bss: the BSS to disassociate from 1368 * @ie: Extra IEs to add to Disassociation frame or %NULL 1369 * @ie_len: Length of ie buffer in octets 1370 * @reason_code: The reason code for the disassociation 1371 * @local_state_change: This is a request for a local state only, i.e., no 1372 * Disassociation frame is to be transmitted. 1373 */ 1374 struct cfg80211_disassoc_request { 1375 struct cfg80211_bss *bss; 1376 const u8 *ie; 1377 size_t ie_len; 1378 u16 reason_code; 1379 bool local_state_change; 1380 }; 1381 1382 /** 1383 * struct cfg80211_ibss_params - IBSS parameters 1384 * 1385 * This structure defines the IBSS parameters for the join_ibss() 1386 * method. 1387 * 1388 * @ssid: The SSID, will always be non-null. 1389 * @ssid_len: The length of the SSID, will always be non-zero. 1390 * @bssid: Fixed BSSID requested, maybe be %NULL, if set do not 1391 * search for IBSSs with a different BSSID. 1392 * @chandef: defines the channel to use if no other IBSS to join can be found 1393 * @channel_fixed: The channel should be fixed -- do not search for 1394 * IBSSs to join on other channels. 1395 * @ie: information element(s) to include in the beacon 1396 * @ie_len: length of that 1397 * @beacon_interval: beacon interval to use 1398 * @privacy: this is a protected network, keys will be configured 1399 * after joining 1400 * @control_port: whether user space controls IEEE 802.1X port, i.e., 1401 * sets/clears %NL80211_STA_FLAG_AUTHORIZED. If true, the driver is 1402 * required to assume that the port is unauthorized until authorized by 1403 * user space. Otherwise, port is marked authorized by default. 1404 * @basic_rates: bitmap of basic rates to use when creating the IBSS 1405 * @mcast_rate: per-band multicast rate index + 1 (0: disabled) 1406 */ 1407 struct cfg80211_ibss_params { 1408 u8 *ssid; 1409 u8 *bssid; 1410 struct cfg80211_chan_def chandef; 1411 u8 *ie; 1412 u8 ssid_len, ie_len; 1413 u16 beacon_interval; 1414 u32 basic_rates; 1415 bool channel_fixed; 1416 bool privacy; 1417 bool control_port; 1418 int mcast_rate[IEEE80211_NUM_BANDS]; 1419 }; 1420 1421 /** 1422 * struct cfg80211_connect_params - Connection parameters 1423 * 1424 * This structure provides information needed to complete IEEE 802.11 1425 * authentication and association. 1426 * 1427 * @channel: The channel to use or %NULL if not specified (auto-select based 1428 * on scan results) 1429 * @bssid: The AP BSSID or %NULL if not specified (auto-select based on scan 1430 * results) 1431 * @ssid: SSID 1432 * @ssid_len: Length of ssid in octets 1433 * @auth_type: Authentication type (algorithm) 1434 * @ie: IEs for association request 1435 * @ie_len: Length of assoc_ie in octets 1436 * @privacy: indicates whether privacy-enabled APs should be used 1437 * @crypto: crypto settings 1438 * @key_len: length of WEP key for shared key authentication 1439 * @key_idx: index of WEP key for shared key authentication 1440 * @key: WEP key for shared key authentication 1441 * @flags: See &enum cfg80211_assoc_req_flags 1442 * @bg_scan_period: Background scan period in seconds 1443 * or -1 to indicate that default value is to be used. 1444 * @ht_capa: HT Capabilities over-rides. Values set in ht_capa_mask 1445 * will be used in ht_capa. Un-supported values will be ignored. 1446 * @ht_capa_mask: The bits of ht_capa which are to be used. 1447 */ 1448 struct cfg80211_connect_params { 1449 struct ieee80211_channel *channel; 1450 u8 *bssid; 1451 u8 *ssid; 1452 size_t ssid_len; 1453 enum nl80211_auth_type auth_type; 1454 u8 *ie; 1455 size_t ie_len; 1456 bool privacy; 1457 struct cfg80211_crypto_settings crypto; 1458 const u8 *key; 1459 u8 key_len, key_idx; 1460 u32 flags; 1461 int bg_scan_period; 1462 struct ieee80211_ht_cap ht_capa; 1463 struct ieee80211_ht_cap ht_capa_mask; 1464 }; 1465 1466 /** 1467 * enum wiphy_params_flags - set_wiphy_params bitfield values 1468 * @WIPHY_PARAM_RETRY_SHORT: wiphy->retry_short has changed 1469 * @WIPHY_PARAM_RETRY_LONG: wiphy->retry_long has changed 1470 * @WIPHY_PARAM_FRAG_THRESHOLD: wiphy->frag_threshold has changed 1471 * @WIPHY_PARAM_RTS_THRESHOLD: wiphy->rts_threshold has changed 1472 * @WIPHY_PARAM_COVERAGE_CLASS: coverage class changed 1473 */ 1474 enum wiphy_params_flags { 1475 WIPHY_PARAM_RETRY_SHORT = 1 << 0, 1476 WIPHY_PARAM_RETRY_LONG = 1 << 1, 1477 WIPHY_PARAM_FRAG_THRESHOLD = 1 << 2, 1478 WIPHY_PARAM_RTS_THRESHOLD = 1 << 3, 1479 WIPHY_PARAM_COVERAGE_CLASS = 1 << 4, 1480 }; 1481 1482 /* 1483 * cfg80211_bitrate_mask - masks for bitrate control 1484 */ 1485 struct cfg80211_bitrate_mask { 1486 struct { 1487 u32 legacy; 1488 u8 mcs[IEEE80211_HT_MCS_MASK_LEN]; 1489 } control[IEEE80211_NUM_BANDS]; 1490 }; 1491 /** 1492 * struct cfg80211_pmksa - PMK Security Association 1493 * 1494 * This structure is passed to the set/del_pmksa() method for PMKSA 1495 * caching. 1496 * 1497 * @bssid: The AP's BSSID. 1498 * @pmkid: The PMK material itself. 1499 */ 1500 struct cfg80211_pmksa { 1501 u8 *bssid; 1502 u8 *pmkid; 1503 }; 1504 1505 /** 1506 * struct cfg80211_wowlan_trig_pkt_pattern - packet pattern 1507 * @mask: bitmask where to match pattern and where to ignore bytes, 1508 * one bit per byte, in same format as nl80211 1509 * @pattern: bytes to match where bitmask is 1 1510 * @pattern_len: length of pattern (in bytes) 1511 * 1512 * Internal note: @mask and @pattern are allocated in one chunk of 1513 * memory, free @mask only! 1514 */ 1515 struct cfg80211_wowlan_trig_pkt_pattern { 1516 u8 *mask, *pattern; 1517 int pattern_len; 1518 }; 1519 1520 /** 1521 * struct cfg80211_wowlan - Wake on Wireless-LAN support info 1522 * 1523 * This structure defines the enabled WoWLAN triggers for the device. 1524 * @any: wake up on any activity -- special trigger if device continues 1525 * operating as normal during suspend 1526 * @disconnect: wake up if getting disconnected 1527 * @magic_pkt: wake up on receiving magic packet 1528 * @patterns: wake up on receiving packet matching a pattern 1529 * @n_patterns: number of patterns 1530 * @gtk_rekey_failure: wake up on GTK rekey failure 1531 * @eap_identity_req: wake up on EAP identity request packet 1532 * @four_way_handshake: wake up on 4-way handshake 1533 * @rfkill_release: wake up when rfkill is released 1534 */ 1535 struct cfg80211_wowlan { 1536 bool any, disconnect, magic_pkt, gtk_rekey_failure, 1537 eap_identity_req, four_way_handshake, 1538 rfkill_release; 1539 struct cfg80211_wowlan_trig_pkt_pattern *patterns; 1540 int n_patterns; 1541 }; 1542 1543 /** 1544 * struct cfg80211_gtk_rekey_data - rekey data 1545 * @kek: key encryption key 1546 * @kck: key confirmation key 1547 * @replay_ctr: replay counter 1548 */ 1549 struct cfg80211_gtk_rekey_data { 1550 u8 kek[NL80211_KEK_LEN]; 1551 u8 kck[NL80211_KCK_LEN]; 1552 u8 replay_ctr[NL80211_REPLAY_CTR_LEN]; 1553 }; 1554 1555 /** 1556 * struct cfg80211_ops - backend description for wireless configuration 1557 * 1558 * This struct is registered by fullmac card drivers and/or wireless stacks 1559 * in order to handle configuration requests on their interfaces. 1560 * 1561 * All callbacks except where otherwise noted should return 0 1562 * on success or a negative error code. 1563 * 1564 * All operations are currently invoked under rtnl for consistency with the 1565 * wireless extensions but this is subject to reevaluation as soon as this 1566 * code is used more widely and we have a first user without wext. 1567 * 1568 * @suspend: wiphy device needs to be suspended. The variable @wow will 1569 * be %NULL or contain the enabled Wake-on-Wireless triggers that are 1570 * configured for the device. 1571 * @resume: wiphy device needs to be resumed 1572 * @set_wakeup: Called when WoWLAN is enabled/disabled, use this callback 1573 * to call device_set_wakeup_enable() to enable/disable wakeup from 1574 * the device. 1575 * 1576 * @add_virtual_intf: create a new virtual interface with the given name, 1577 * must set the struct wireless_dev's iftype. Beware: You must create 1578 * the new netdev in the wiphy's network namespace! Returns the struct 1579 * wireless_dev, or an ERR_PTR. For P2P device wdevs, the driver must 1580 * also set the address member in the wdev. 1581 * 1582 * @del_virtual_intf: remove the virtual interface 1583 * 1584 * @change_virtual_intf: change type/configuration of virtual interface, 1585 * keep the struct wireless_dev's iftype updated. 1586 * 1587 * @add_key: add a key with the given parameters. @mac_addr will be %NULL 1588 * when adding a group key. 1589 * 1590 * @get_key: get information about the key with the given parameters. 1591 * @mac_addr will be %NULL when requesting information for a group 1592 * key. All pointers given to the @callback function need not be valid 1593 * after it returns. This function should return an error if it is 1594 * not possible to retrieve the key, -ENOENT if it doesn't exist. 1595 * 1596 * @del_key: remove a key given the @mac_addr (%NULL for a group key) 1597 * and @key_index, return -ENOENT if the key doesn't exist. 1598 * 1599 * @set_default_key: set the default key on an interface 1600 * 1601 * @set_default_mgmt_key: set the default management frame key on an interface 1602 * 1603 * @set_rekey_data: give the data necessary for GTK rekeying to the driver 1604 * 1605 * @start_ap: Start acting in AP mode defined by the parameters. 1606 * @change_beacon: Change the beacon parameters for an access point mode 1607 * interface. This should reject the call when AP mode wasn't started. 1608 * @stop_ap: Stop being an AP, including stopping beaconing. 1609 * 1610 * @add_station: Add a new station. 1611 * @del_station: Remove a station; @mac may be NULL to remove all stations. 1612 * @change_station: Modify a given station. Note that flags changes are not much 1613 * validated in cfg80211, in particular the auth/assoc/authorized flags 1614 * might come to the driver in invalid combinations -- make sure to check 1615 * them, also against the existing state! Also, supported_rates changes are 1616 * not checked in station mode -- drivers need to reject (or ignore) them 1617 * for anything but TDLS peers. 1618 * @get_station: get station information for the station identified by @mac 1619 * @dump_station: dump station callback -- resume dump at index @idx 1620 * 1621 * @add_mpath: add a fixed mesh path 1622 * @del_mpath: delete a given mesh path 1623 * @change_mpath: change a given mesh path 1624 * @get_mpath: get a mesh path for the given parameters 1625 * @dump_mpath: dump mesh path callback -- resume dump at index @idx 1626 * @join_mesh: join the mesh network with the specified parameters 1627 * @leave_mesh: leave the current mesh network 1628 * 1629 * @get_mesh_config: Get the current mesh configuration 1630 * 1631 * @update_mesh_config: Update mesh parameters on a running mesh. 1632 * The mask is a bitfield which tells us which parameters to 1633 * set, and which to leave alone. 1634 * 1635 * @change_bss: Modify parameters for a given BSS. 1636 * 1637 * @set_txq_params: Set TX queue parameters 1638 * 1639 * @libertas_set_mesh_channel: Only for backward compatibility for libertas, 1640 * as it doesn't implement join_mesh and needs to set the channel to 1641 * join the mesh instead. 1642 * 1643 * @set_monitor_channel: Set the monitor mode channel for the device. If other 1644 * interfaces are active this callback should reject the configuration. 1645 * If no interfaces are active or the device is down, the channel should 1646 * be stored for when a monitor interface becomes active. 1647 * 1648 * @scan: Request to do a scan. If returning zero, the scan request is given 1649 * the driver, and will be valid until passed to cfg80211_scan_done(). 1650 * For scan results, call cfg80211_inform_bss(); you can call this outside 1651 * the scan/scan_done bracket too. 1652 * 1653 * @auth: Request to authenticate with the specified peer 1654 * @assoc: Request to (re)associate with the specified peer 1655 * @deauth: Request to deauthenticate from the specified peer 1656 * @disassoc: Request to disassociate from the specified peer 1657 * 1658 * @connect: Connect to the ESS with the specified parameters. When connected, 1659 * call cfg80211_connect_result() with status code %WLAN_STATUS_SUCCESS. 1660 * If the connection fails for some reason, call cfg80211_connect_result() 1661 * with the status from the AP. 1662 * @disconnect: Disconnect from the BSS/ESS. 1663 * 1664 * @join_ibss: Join the specified IBSS (or create if necessary). Once done, call 1665 * cfg80211_ibss_joined(), also call that function when changing BSSID due 1666 * to a merge. 1667 * @leave_ibss: Leave the IBSS. 1668 * 1669 * @set_mcast_rate: Set the specified multicast rate (only if vif is in ADHOC or 1670 * MESH mode) 1671 * 1672 * @set_wiphy_params: Notify that wiphy parameters have changed; 1673 * @changed bitfield (see &enum wiphy_params_flags) describes which values 1674 * have changed. The actual parameter values are available in 1675 * struct wiphy. If returning an error, no value should be changed. 1676 * 1677 * @set_tx_power: set the transmit power according to the parameters, 1678 * the power passed is in mBm, to get dBm use MBM_TO_DBM(). The 1679 * wdev may be %NULL if power was set for the wiphy, and will 1680 * always be %NULL unless the driver supports per-vif TX power 1681 * (as advertised by the nl80211 feature flag.) 1682 * @get_tx_power: store the current TX power into the dbm variable; 1683 * return 0 if successful 1684 * 1685 * @set_wds_peer: set the WDS peer for a WDS interface 1686 * 1687 * @rfkill_poll: polls the hw rfkill line, use cfg80211 reporting 1688 * functions to adjust rfkill hw state 1689 * 1690 * @dump_survey: get site survey information. 1691 * 1692 * @remain_on_channel: Request the driver to remain awake on the specified 1693 * channel for the specified duration to complete an off-channel 1694 * operation (e.g., public action frame exchange). When the driver is 1695 * ready on the requested channel, it must indicate this with an event 1696 * notification by calling cfg80211_ready_on_channel(). 1697 * @cancel_remain_on_channel: Cancel an on-going remain-on-channel operation. 1698 * This allows the operation to be terminated prior to timeout based on 1699 * the duration value. 1700 * @mgmt_tx: Transmit a management frame. 1701 * @mgmt_tx_cancel_wait: Cancel the wait time from transmitting a management 1702 * frame on another channel 1703 * 1704 * @testmode_cmd: run a test mode command 1705 * @testmode_dump: Implement a test mode dump. The cb->args[2] and up may be 1706 * used by the function, but 0 and 1 must not be touched. Additionally, 1707 * return error codes other than -ENOBUFS and -ENOENT will terminate the 1708 * dump and return to userspace with an error, so be careful. If any data 1709 * was passed in from userspace then the data/len arguments will be present 1710 * and point to the data contained in %NL80211_ATTR_TESTDATA. 1711 * 1712 * @set_bitrate_mask: set the bitrate mask configuration 1713 * 1714 * @set_pmksa: Cache a PMKID for a BSSID. This is mostly useful for fullmac 1715 * devices running firmwares capable of generating the (re) association 1716 * RSN IE. It allows for faster roaming between WPA2 BSSIDs. 1717 * @del_pmksa: Delete a cached PMKID. 1718 * @flush_pmksa: Flush all cached PMKIDs. 1719 * @set_power_mgmt: Configure WLAN power management. A timeout value of -1 1720 * allows the driver to adjust the dynamic ps timeout value. 1721 * @set_cqm_rssi_config: Configure connection quality monitor RSSI threshold. 1722 * @set_cqm_txe_config: Configure connection quality monitor TX error 1723 * thresholds. 1724 * @sched_scan_start: Tell the driver to start a scheduled scan. 1725 * @sched_scan_stop: Tell the driver to stop an ongoing scheduled scan. 1726 * 1727 * @mgmt_frame_register: Notify driver that a management frame type was 1728 * registered. Note that this callback may not sleep, and cannot run 1729 * concurrently with itself. 1730 * 1731 * @set_antenna: Set antenna configuration (tx_ant, rx_ant) on the device. 1732 * Parameters are bitmaps of allowed antennas to use for TX/RX. Drivers may 1733 * reject TX/RX mask combinations they cannot support by returning -EINVAL 1734 * (also see nl80211.h @NL80211_ATTR_WIPHY_ANTENNA_TX). 1735 * 1736 * @get_antenna: Get current antenna configuration from device (tx_ant, rx_ant). 1737 * 1738 * @set_ringparam: Set tx and rx ring sizes. 1739 * 1740 * @get_ringparam: Get tx and rx ring current and maximum sizes. 1741 * 1742 * @tdls_mgmt: Transmit a TDLS management frame. 1743 * @tdls_oper: Perform a high-level TDLS operation (e.g. TDLS link setup). 1744 * 1745 * @probe_client: probe an associated client, must return a cookie that it 1746 * later passes to cfg80211_probe_status(). 1747 * 1748 * @set_noack_map: Set the NoAck Map for the TIDs. 1749 * 1750 * @get_et_sset_count: Ethtool API to get string-set count. 1751 * See @ethtool_ops.get_sset_count 1752 * 1753 * @get_et_stats: Ethtool API to get a set of u64 stats. 1754 * See @ethtool_ops.get_ethtool_stats 1755 * 1756 * @get_et_strings: Ethtool API to get a set of strings to describe stats 1757 * and perhaps other supported types of ethtool data-sets. 1758 * See @ethtool_ops.get_strings 1759 * 1760 * @get_channel: Get the current operating channel for the virtual interface. 1761 * For monitor interfaces, it should return %NULL unless there's a single 1762 * current monitoring channel. 1763 * 1764 * @start_p2p_device: Start the given P2P device. 1765 * @stop_p2p_device: Stop the given P2P device. 1766 */ 1767 struct cfg80211_ops { 1768 int (*suspend)(struct wiphy *wiphy, struct cfg80211_wowlan *wow); 1769 int (*resume)(struct wiphy *wiphy); 1770 void (*set_wakeup)(struct wiphy *wiphy, bool enabled); 1771 1772 struct wireless_dev * (*add_virtual_intf)(struct wiphy *wiphy, 1773 const char *name, 1774 enum nl80211_iftype type, 1775 u32 *flags, 1776 struct vif_params *params); 1777 int (*del_virtual_intf)(struct wiphy *wiphy, 1778 struct wireless_dev *wdev); 1779 int (*change_virtual_intf)(struct wiphy *wiphy, 1780 struct net_device *dev, 1781 enum nl80211_iftype type, u32 *flags, 1782 struct vif_params *params); 1783 1784 int (*add_key)(struct wiphy *wiphy, struct net_device *netdev, 1785 u8 key_index, bool pairwise, const u8 *mac_addr, 1786 struct key_params *params); 1787 int (*get_key)(struct wiphy *wiphy, struct net_device *netdev, 1788 u8 key_index, bool pairwise, const u8 *mac_addr, 1789 void *cookie, 1790 void (*callback)(void *cookie, struct key_params*)); 1791 int (*del_key)(struct wiphy *wiphy, struct net_device *netdev, 1792 u8 key_index, bool pairwise, const u8 *mac_addr); 1793 int (*set_default_key)(struct wiphy *wiphy, 1794 struct net_device *netdev, 1795 u8 key_index, bool unicast, bool multicast); 1796 int (*set_default_mgmt_key)(struct wiphy *wiphy, 1797 struct net_device *netdev, 1798 u8 key_index); 1799 1800 int (*start_ap)(struct wiphy *wiphy, struct net_device *dev, 1801 struct cfg80211_ap_settings *settings); 1802 int (*change_beacon)(struct wiphy *wiphy, struct net_device *dev, 1803 struct cfg80211_beacon_data *info); 1804 int (*stop_ap)(struct wiphy *wiphy, struct net_device *dev); 1805 1806 1807 int (*add_station)(struct wiphy *wiphy, struct net_device *dev, 1808 u8 *mac, struct station_parameters *params); 1809 int (*del_station)(struct wiphy *wiphy, struct net_device *dev, 1810 u8 *mac); 1811 int (*change_station)(struct wiphy *wiphy, struct net_device *dev, 1812 u8 *mac, struct station_parameters *params); 1813 int (*get_station)(struct wiphy *wiphy, struct net_device *dev, 1814 u8 *mac, struct station_info *sinfo); 1815 int (*dump_station)(struct wiphy *wiphy, struct net_device *dev, 1816 int idx, u8 *mac, struct station_info *sinfo); 1817 1818 int (*add_mpath)(struct wiphy *wiphy, struct net_device *dev, 1819 u8 *dst, u8 *next_hop); 1820 int (*del_mpath)(struct wiphy *wiphy, struct net_device *dev, 1821 u8 *dst); 1822 int (*change_mpath)(struct wiphy *wiphy, struct net_device *dev, 1823 u8 *dst, u8 *next_hop); 1824 int (*get_mpath)(struct wiphy *wiphy, struct net_device *dev, 1825 u8 *dst, u8 *next_hop, 1826 struct mpath_info *pinfo); 1827 int (*dump_mpath)(struct wiphy *wiphy, struct net_device *dev, 1828 int idx, u8 *dst, u8 *next_hop, 1829 struct mpath_info *pinfo); 1830 int (*get_mesh_config)(struct wiphy *wiphy, 1831 struct net_device *dev, 1832 struct mesh_config *conf); 1833 int (*update_mesh_config)(struct wiphy *wiphy, 1834 struct net_device *dev, u32 mask, 1835 const struct mesh_config *nconf); 1836 int (*join_mesh)(struct wiphy *wiphy, struct net_device *dev, 1837 const struct mesh_config *conf, 1838 const struct mesh_setup *setup); 1839 int (*leave_mesh)(struct wiphy *wiphy, struct net_device *dev); 1840 1841 int (*change_bss)(struct wiphy *wiphy, struct net_device *dev, 1842 struct bss_parameters *params); 1843 1844 int (*set_txq_params)(struct wiphy *wiphy, struct net_device *dev, 1845 struct ieee80211_txq_params *params); 1846 1847 int (*libertas_set_mesh_channel)(struct wiphy *wiphy, 1848 struct net_device *dev, 1849 struct ieee80211_channel *chan); 1850 1851 int (*set_monitor_channel)(struct wiphy *wiphy, 1852 struct cfg80211_chan_def *chandef); 1853 1854 int (*scan)(struct wiphy *wiphy, 1855 struct cfg80211_scan_request *request); 1856 1857 int (*auth)(struct wiphy *wiphy, struct net_device *dev, 1858 struct cfg80211_auth_request *req); 1859 int (*assoc)(struct wiphy *wiphy, struct net_device *dev, 1860 struct cfg80211_assoc_request *req); 1861 int (*deauth)(struct wiphy *wiphy, struct net_device *dev, 1862 struct cfg80211_deauth_request *req); 1863 int (*disassoc)(struct wiphy *wiphy, struct net_device *dev, 1864 struct cfg80211_disassoc_request *req); 1865 1866 int (*connect)(struct wiphy *wiphy, struct net_device *dev, 1867 struct cfg80211_connect_params *sme); 1868 int (*disconnect)(struct wiphy *wiphy, struct net_device *dev, 1869 u16 reason_code); 1870 1871 int (*join_ibss)(struct wiphy *wiphy, struct net_device *dev, 1872 struct cfg80211_ibss_params *params); 1873 int (*leave_ibss)(struct wiphy *wiphy, struct net_device *dev); 1874 1875 int (*set_mcast_rate)(struct wiphy *wiphy, struct net_device *dev, 1876 int rate[IEEE80211_NUM_BANDS]); 1877 1878 int (*set_wiphy_params)(struct wiphy *wiphy, u32 changed); 1879 1880 int (*set_tx_power)(struct wiphy *wiphy, struct wireless_dev *wdev, 1881 enum nl80211_tx_power_setting type, int mbm); 1882 int (*get_tx_power)(struct wiphy *wiphy, struct wireless_dev *wdev, 1883 int *dbm); 1884 1885 int (*set_wds_peer)(struct wiphy *wiphy, struct net_device *dev, 1886 const u8 *addr); 1887 1888 void (*rfkill_poll)(struct wiphy *wiphy); 1889 1890 #ifdef CONFIG_NL80211_TESTMODE 1891 int (*testmode_cmd)(struct wiphy *wiphy, void *data, int len); 1892 int (*testmode_dump)(struct wiphy *wiphy, struct sk_buff *skb, 1893 struct netlink_callback *cb, 1894 void *data, int len); 1895 #endif 1896 1897 int (*set_bitrate_mask)(struct wiphy *wiphy, 1898 struct net_device *dev, 1899 const u8 *peer, 1900 const struct cfg80211_bitrate_mask *mask); 1901 1902 int (*dump_survey)(struct wiphy *wiphy, struct net_device *netdev, 1903 int idx, struct survey_info *info); 1904 1905 int (*set_pmksa)(struct wiphy *wiphy, struct net_device *netdev, 1906 struct cfg80211_pmksa *pmksa); 1907 int (*del_pmksa)(struct wiphy *wiphy, struct net_device *netdev, 1908 struct cfg80211_pmksa *pmksa); 1909 int (*flush_pmksa)(struct wiphy *wiphy, struct net_device *netdev); 1910 1911 int (*remain_on_channel)(struct wiphy *wiphy, 1912 struct wireless_dev *wdev, 1913 struct ieee80211_channel *chan, 1914 unsigned int duration, 1915 u64 *cookie); 1916 int (*cancel_remain_on_channel)(struct wiphy *wiphy, 1917 struct wireless_dev *wdev, 1918 u64 cookie); 1919 1920 int (*mgmt_tx)(struct wiphy *wiphy, struct wireless_dev *wdev, 1921 struct ieee80211_channel *chan, bool offchan, 1922 unsigned int wait, const u8 *buf, size_t len, 1923 bool no_cck, bool dont_wait_for_ack, u64 *cookie); 1924 int (*mgmt_tx_cancel_wait)(struct wiphy *wiphy, 1925 struct wireless_dev *wdev, 1926 u64 cookie); 1927 1928 int (*set_power_mgmt)(struct wiphy *wiphy, struct net_device *dev, 1929 bool enabled, int timeout); 1930 1931 int (*set_cqm_rssi_config)(struct wiphy *wiphy, 1932 struct net_device *dev, 1933 s32 rssi_thold, u32 rssi_hyst); 1934 1935 int (*set_cqm_txe_config)(struct wiphy *wiphy, 1936 struct net_device *dev, 1937 u32 rate, u32 pkts, u32 intvl); 1938 1939 void (*mgmt_frame_register)(struct wiphy *wiphy, 1940 struct wireless_dev *wdev, 1941 u16 frame_type, bool reg); 1942 1943 int (*set_antenna)(struct wiphy *wiphy, u32 tx_ant, u32 rx_ant); 1944 int (*get_antenna)(struct wiphy *wiphy, u32 *tx_ant, u32 *rx_ant); 1945 1946 int (*set_ringparam)(struct wiphy *wiphy, u32 tx, u32 rx); 1947 void (*get_ringparam)(struct wiphy *wiphy, 1948 u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max); 1949 1950 int (*sched_scan_start)(struct wiphy *wiphy, 1951 struct net_device *dev, 1952 struct cfg80211_sched_scan_request *request); 1953 int (*sched_scan_stop)(struct wiphy *wiphy, struct net_device *dev); 1954 1955 int (*set_rekey_data)(struct wiphy *wiphy, struct net_device *dev, 1956 struct cfg80211_gtk_rekey_data *data); 1957 1958 int (*tdls_mgmt)(struct wiphy *wiphy, struct net_device *dev, 1959 u8 *peer, u8 action_code, u8 dialog_token, 1960 u16 status_code, const u8 *buf, size_t len); 1961 int (*tdls_oper)(struct wiphy *wiphy, struct net_device *dev, 1962 u8 *peer, enum nl80211_tdls_operation oper); 1963 1964 int (*probe_client)(struct wiphy *wiphy, struct net_device *dev, 1965 const u8 *peer, u64 *cookie); 1966 1967 int (*set_noack_map)(struct wiphy *wiphy, 1968 struct net_device *dev, 1969 u16 noack_map); 1970 1971 int (*get_et_sset_count)(struct wiphy *wiphy, 1972 struct net_device *dev, int sset); 1973 void (*get_et_stats)(struct wiphy *wiphy, struct net_device *dev, 1974 struct ethtool_stats *stats, u64 *data); 1975 void (*get_et_strings)(struct wiphy *wiphy, struct net_device *dev, 1976 u32 sset, u8 *data); 1977 1978 int (*get_channel)(struct wiphy *wiphy, 1979 struct wireless_dev *wdev, 1980 struct cfg80211_chan_def *chandef); 1981 1982 int (*start_p2p_device)(struct wiphy *wiphy, 1983 struct wireless_dev *wdev); 1984 void (*stop_p2p_device)(struct wiphy *wiphy, 1985 struct wireless_dev *wdev); 1986 }; 1987 1988 /* 1989 * wireless hardware and networking interfaces structures 1990 * and registration/helper functions 1991 */ 1992 1993 /** 1994 * enum wiphy_flags - wiphy capability flags 1995 * 1996 * @WIPHY_FLAG_CUSTOM_REGULATORY: tells us the driver for this device 1997 * has its own custom regulatory domain and cannot identify the 1998 * ISO / IEC 3166 alpha2 it belongs to. When this is enabled 1999 * we will disregard the first regulatory hint (when the 2000 * initiator is %REGDOM_SET_BY_CORE). 2001 * @WIPHY_FLAG_STRICT_REGULATORY: tells us the driver for this device will 2002 * ignore regulatory domain settings until it gets its own regulatory 2003 * domain via its regulatory_hint() unless the regulatory hint is 2004 * from a country IE. After its gets its own regulatory domain it will 2005 * only allow further regulatory domain settings to further enhance 2006 * compliance. For example if channel 13 and 14 are disabled by this 2007 * regulatory domain no user regulatory domain can enable these channels 2008 * at a later time. This can be used for devices which do not have 2009 * calibration information guaranteed for frequencies or settings 2010 * outside of its regulatory domain. If used in combination with 2011 * WIPHY_FLAG_CUSTOM_REGULATORY the inspected country IE power settings 2012 * will be followed. 2013 * @WIPHY_FLAG_DISABLE_BEACON_HINTS: enable this if your driver needs to ensure 2014 * that passive scan flags and beaconing flags may not be lifted by 2015 * cfg80211 due to regulatory beacon hints. For more information on beacon 2016 * hints read the documenation for regulatory_hint_found_beacon() 2017 * @WIPHY_FLAG_NETNS_OK: if not set, do not allow changing the netns of this 2018 * wiphy at all 2019 * @WIPHY_FLAG_PS_ON_BY_DEFAULT: if set to true, powersave will be enabled 2020 * by default -- this flag will be set depending on the kernel's default 2021 * on wiphy_new(), but can be changed by the driver if it has a good 2022 * reason to override the default 2023 * @WIPHY_FLAG_4ADDR_AP: supports 4addr mode even on AP (with a single station 2024 * on a VLAN interface) 2025 * @WIPHY_FLAG_4ADDR_STATION: supports 4addr mode even as a station 2026 * @WIPHY_FLAG_CONTROL_PORT_PROTOCOL: This device supports setting the 2027 * control port protocol ethertype. The device also honours the 2028 * control_port_no_encrypt flag. 2029 * @WIPHY_FLAG_IBSS_RSN: The device supports IBSS RSN. 2030 * @WIPHY_FLAG_MESH_AUTH: The device supports mesh authentication by routing 2031 * auth frames to userspace. See @NL80211_MESH_SETUP_USERSPACE_AUTH. 2032 * @WIPHY_FLAG_SUPPORTS_SCHED_SCAN: The device supports scheduled scans. 2033 * @WIPHY_FLAG_SUPPORTS_FW_ROAM: The device supports roaming feature in the 2034 * firmware. 2035 * @WIPHY_FLAG_AP_UAPSD: The device supports uapsd on AP. 2036 * @WIPHY_FLAG_SUPPORTS_TDLS: The device supports TDLS (802.11z) operation. 2037 * @WIPHY_FLAG_TDLS_EXTERNAL_SETUP: The device does not handle TDLS (802.11z) 2038 * link setup/discovery operations internally. Setup, discovery and 2039 * teardown packets should be sent through the @NL80211_CMD_TDLS_MGMT 2040 * command. When this flag is not set, @NL80211_CMD_TDLS_OPER should be 2041 * used for asking the driver/firmware to perform a TDLS operation. 2042 * @WIPHY_FLAG_HAVE_AP_SME: device integrates AP SME 2043 * @WIPHY_FLAG_REPORTS_OBSS: the device will report beacons from other BSSes 2044 * when there are virtual interfaces in AP mode by calling 2045 * cfg80211_report_obss_beacon(). 2046 * @WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD: When operating as an AP, the device 2047 * responds to probe-requests in hardware. 2048 * @WIPHY_FLAG_OFFCHAN_TX: Device supports direct off-channel TX. 2049 * @WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL: Device supports remain-on-channel call. 2050 */ 2051 enum wiphy_flags { 2052 WIPHY_FLAG_CUSTOM_REGULATORY = BIT(0), 2053 WIPHY_FLAG_STRICT_REGULATORY = BIT(1), 2054 WIPHY_FLAG_DISABLE_BEACON_HINTS = BIT(2), 2055 WIPHY_FLAG_NETNS_OK = BIT(3), 2056 WIPHY_FLAG_PS_ON_BY_DEFAULT = BIT(4), 2057 WIPHY_FLAG_4ADDR_AP = BIT(5), 2058 WIPHY_FLAG_4ADDR_STATION = BIT(6), 2059 WIPHY_FLAG_CONTROL_PORT_PROTOCOL = BIT(7), 2060 WIPHY_FLAG_IBSS_RSN = BIT(8), 2061 WIPHY_FLAG_MESH_AUTH = BIT(10), 2062 WIPHY_FLAG_SUPPORTS_SCHED_SCAN = BIT(11), 2063 /* use hole at 12 */ 2064 WIPHY_FLAG_SUPPORTS_FW_ROAM = BIT(13), 2065 WIPHY_FLAG_AP_UAPSD = BIT(14), 2066 WIPHY_FLAG_SUPPORTS_TDLS = BIT(15), 2067 WIPHY_FLAG_TDLS_EXTERNAL_SETUP = BIT(16), 2068 WIPHY_FLAG_HAVE_AP_SME = BIT(17), 2069 WIPHY_FLAG_REPORTS_OBSS = BIT(18), 2070 WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD = BIT(19), 2071 WIPHY_FLAG_OFFCHAN_TX = BIT(20), 2072 WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL = BIT(21), 2073 }; 2074 2075 /** 2076 * struct ieee80211_iface_limit - limit on certain interface types 2077 * @max: maximum number of interfaces of these types 2078 * @types: interface types (bits) 2079 */ 2080 struct ieee80211_iface_limit { 2081 u16 max; 2082 u16 types; 2083 }; 2084 2085 /** 2086 * struct ieee80211_iface_combination - possible interface combination 2087 * @limits: limits for the given interface types 2088 * @n_limits: number of limitations 2089 * @num_different_channels: can use up to this many different channels 2090 * @max_interfaces: maximum number of interfaces in total allowed in this 2091 * group 2092 * @beacon_int_infra_match: In this combination, the beacon intervals 2093 * between infrastructure and AP types must match. This is required 2094 * only in special cases. 2095 * 2096 * These examples can be expressed as follows: 2097 * 2098 * Allow #STA <= 1, #AP <= 1, matching BI, channels = 1, 2 total: 2099 * 2100 * struct ieee80211_iface_limit limits1[] = { 2101 * { .max = 1, .types = BIT(NL80211_IFTYPE_STATION), }, 2102 * { .max = 1, .types = BIT(NL80211_IFTYPE_AP}, }, 2103 * }; 2104 * struct ieee80211_iface_combination combination1 = { 2105 * .limits = limits1, 2106 * .n_limits = ARRAY_SIZE(limits1), 2107 * .max_interfaces = 2, 2108 * .beacon_int_infra_match = true, 2109 * }; 2110 * 2111 * 2112 * Allow #{AP, P2P-GO} <= 8, channels = 1, 8 total: 2113 * 2114 * struct ieee80211_iface_limit limits2[] = { 2115 * { .max = 8, .types = BIT(NL80211_IFTYPE_AP) | 2116 * BIT(NL80211_IFTYPE_P2P_GO), }, 2117 * }; 2118 * struct ieee80211_iface_combination combination2 = { 2119 * .limits = limits2, 2120 * .n_limits = ARRAY_SIZE(limits2), 2121 * .max_interfaces = 8, 2122 * .num_different_channels = 1, 2123 * }; 2124 * 2125 * 2126 * Allow #STA <= 1, #{P2P-client,P2P-GO} <= 3 on two channels, 4 total. 2127 * This allows for an infrastructure connection and three P2P connections. 2128 * 2129 * struct ieee80211_iface_limit limits3[] = { 2130 * { .max = 1, .types = BIT(NL80211_IFTYPE_STATION), }, 2131 * { .max = 3, .types = BIT(NL80211_IFTYPE_P2P_GO) | 2132 * BIT(NL80211_IFTYPE_P2P_CLIENT), }, 2133 * }; 2134 * struct ieee80211_iface_combination combination3 = { 2135 * .limits = limits3, 2136 * .n_limits = ARRAY_SIZE(limits3), 2137 * .max_interfaces = 4, 2138 * .num_different_channels = 2, 2139 * }; 2140 */ 2141 struct ieee80211_iface_combination { 2142 const struct ieee80211_iface_limit *limits; 2143 u32 num_different_channels; 2144 u16 max_interfaces; 2145 u8 n_limits; 2146 bool beacon_int_infra_match; 2147 }; 2148 2149 struct mac_address { 2150 u8 addr[ETH_ALEN]; 2151 }; 2152 2153 struct ieee80211_txrx_stypes { 2154 u16 tx, rx; 2155 }; 2156 2157 /** 2158 * enum wiphy_wowlan_support_flags - WoWLAN support flags 2159 * @WIPHY_WOWLAN_ANY: supports wakeup for the special "any" 2160 * trigger that keeps the device operating as-is and 2161 * wakes up the host on any activity, for example a 2162 * received packet that passed filtering; note that the 2163 * packet should be preserved in that case 2164 * @WIPHY_WOWLAN_MAGIC_PKT: supports wakeup on magic packet 2165 * (see nl80211.h) 2166 * @WIPHY_WOWLAN_DISCONNECT: supports wakeup on disconnect 2167 * @WIPHY_WOWLAN_SUPPORTS_GTK_REKEY: supports GTK rekeying while asleep 2168 * @WIPHY_WOWLAN_GTK_REKEY_FAILURE: supports wakeup on GTK rekey failure 2169 * @WIPHY_WOWLAN_EAP_IDENTITY_REQ: supports wakeup on EAP identity request 2170 * @WIPHY_WOWLAN_4WAY_HANDSHAKE: supports wakeup on 4-way handshake failure 2171 * @WIPHY_WOWLAN_RFKILL_RELEASE: supports wakeup on RF-kill release 2172 */ 2173 enum wiphy_wowlan_support_flags { 2174 WIPHY_WOWLAN_ANY = BIT(0), 2175 WIPHY_WOWLAN_MAGIC_PKT = BIT(1), 2176 WIPHY_WOWLAN_DISCONNECT = BIT(2), 2177 WIPHY_WOWLAN_SUPPORTS_GTK_REKEY = BIT(3), 2178 WIPHY_WOWLAN_GTK_REKEY_FAILURE = BIT(4), 2179 WIPHY_WOWLAN_EAP_IDENTITY_REQ = BIT(5), 2180 WIPHY_WOWLAN_4WAY_HANDSHAKE = BIT(6), 2181 WIPHY_WOWLAN_RFKILL_RELEASE = BIT(7), 2182 }; 2183 2184 /** 2185 * struct wiphy_wowlan_support - WoWLAN support data 2186 * @flags: see &enum wiphy_wowlan_support_flags 2187 * @n_patterns: number of supported wakeup patterns 2188 * (see nl80211.h for the pattern definition) 2189 * @pattern_max_len: maximum length of each pattern 2190 * @pattern_min_len: minimum length of each pattern 2191 */ 2192 struct wiphy_wowlan_support { 2193 u32 flags; 2194 int n_patterns; 2195 int pattern_max_len; 2196 int pattern_min_len; 2197 }; 2198 2199 /** 2200 * struct wiphy - wireless hardware description 2201 * @reg_notifier: the driver's regulatory notification callback, 2202 * note that if your driver uses wiphy_apply_custom_regulatory() 2203 * the reg_notifier's request can be passed as NULL 2204 * @regd: the driver's regulatory domain, if one was requested via 2205 * the regulatory_hint() API. This can be used by the driver 2206 * on the reg_notifier() if it chooses to ignore future 2207 * regulatory domain changes caused by other drivers. 2208 * @signal_type: signal type reported in &struct cfg80211_bss. 2209 * @cipher_suites: supported cipher suites 2210 * @n_cipher_suites: number of supported cipher suites 2211 * @retry_short: Retry limit for short frames (dot11ShortRetryLimit) 2212 * @retry_long: Retry limit for long frames (dot11LongRetryLimit) 2213 * @frag_threshold: Fragmentation threshold (dot11FragmentationThreshold); 2214 * -1 = fragmentation disabled, only odd values >= 256 used 2215 * @rts_threshold: RTS threshold (dot11RTSThreshold); -1 = RTS/CTS disabled 2216 * @_net: the network namespace this wiphy currently lives in 2217 * @perm_addr: permanent MAC address of this device 2218 * @addr_mask: If the device supports multiple MAC addresses by masking, 2219 * set this to a mask with variable bits set to 1, e.g. if the last 2220 * four bits are variable then set it to 00:...:00:0f. The actual 2221 * variable bits shall be determined by the interfaces added, with 2222 * interfaces not matching the mask being rejected to be brought up. 2223 * @n_addresses: number of addresses in @addresses. 2224 * @addresses: If the device has more than one address, set this pointer 2225 * to a list of addresses (6 bytes each). The first one will be used 2226 * by default for perm_addr. In this case, the mask should be set to 2227 * all-zeroes. In this case it is assumed that the device can handle 2228 * the same number of arbitrary MAC addresses. 2229 * @registered: protects ->resume and ->suspend sysfs callbacks against 2230 * unregister hardware 2231 * @debugfsdir: debugfs directory used for this wiphy, will be renamed 2232 * automatically on wiphy renames 2233 * @dev: (virtual) struct device for this wiphy 2234 * @registered: helps synchronize suspend/resume with wiphy unregister 2235 * @wext: wireless extension handlers 2236 * @priv: driver private data (sized according to wiphy_new() parameter) 2237 * @interface_modes: bitmask of interfaces types valid for this wiphy, 2238 * must be set by driver 2239 * @iface_combinations: Valid interface combinations array, should not 2240 * list single interface types. 2241 * @n_iface_combinations: number of entries in @iface_combinations array. 2242 * @software_iftypes: bitmask of software interface types, these are not 2243 * subject to any restrictions since they are purely managed in SW. 2244 * @flags: wiphy flags, see &enum wiphy_flags 2245 * @features: features advertised to nl80211, see &enum nl80211_feature_flags. 2246 * @bss_priv_size: each BSS struct has private data allocated with it, 2247 * this variable determines its size 2248 * @max_scan_ssids: maximum number of SSIDs the device can scan for in 2249 * any given scan 2250 * @max_sched_scan_ssids: maximum number of SSIDs the device can scan 2251 * for in any given scheduled scan 2252 * @max_match_sets: maximum number of match sets the device can handle 2253 * when performing a scheduled scan, 0 if filtering is not 2254 * supported. 2255 * @max_scan_ie_len: maximum length of user-controlled IEs device can 2256 * add to probe request frames transmitted during a scan, must not 2257 * include fixed IEs like supported rates 2258 * @max_sched_scan_ie_len: same as max_scan_ie_len, but for scheduled 2259 * scans 2260 * @coverage_class: current coverage class 2261 * @fw_version: firmware version for ethtool reporting 2262 * @hw_version: hardware version for ethtool reporting 2263 * @max_num_pmkids: maximum number of PMKIDs supported by device 2264 * @privid: a pointer that drivers can use to identify if an arbitrary 2265 * wiphy is theirs, e.g. in global notifiers 2266 * @bands: information about bands/channels supported by this device 2267 * 2268 * @mgmt_stypes: bitmasks of frame subtypes that can be subscribed to or 2269 * transmitted through nl80211, points to an array indexed by interface 2270 * type 2271 * 2272 * @available_antennas_tx: bitmap of antennas which are available to be 2273 * configured as TX antennas. Antenna configuration commands will be 2274 * rejected unless this or @available_antennas_rx is set. 2275 * 2276 * @available_antennas_rx: bitmap of antennas which are available to be 2277 * configured as RX antennas. Antenna configuration commands will be 2278 * rejected unless this or @available_antennas_tx is set. 2279 * 2280 * @probe_resp_offload: 2281 * Bitmap of supported protocols for probe response offloading. 2282 * See &enum nl80211_probe_resp_offload_support_attr. Only valid 2283 * when the wiphy flag @WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD is set. 2284 * 2285 * @max_remain_on_channel_duration: Maximum time a remain-on-channel operation 2286 * may request, if implemented. 2287 * 2288 * @wowlan: WoWLAN support information 2289 * 2290 * @ap_sme_capa: AP SME capabilities, flags from &enum nl80211_ap_sme_features. 2291 * @ht_capa_mod_mask: Specify what ht_cap values can be over-ridden. 2292 * If null, then none can be over-ridden. 2293 */ 2294 struct wiphy { 2295 /* assign these fields before you register the wiphy */ 2296 2297 /* permanent MAC address(es) */ 2298 u8 perm_addr[ETH_ALEN]; 2299 u8 addr_mask[ETH_ALEN]; 2300 2301 struct mac_address *addresses; 2302 2303 const struct ieee80211_txrx_stypes *mgmt_stypes; 2304 2305 const struct ieee80211_iface_combination *iface_combinations; 2306 int n_iface_combinations; 2307 u16 software_iftypes; 2308 2309 u16 n_addresses; 2310 2311 /* Supported interface modes, OR together BIT(NL80211_IFTYPE_...) */ 2312 u16 interface_modes; 2313 2314 u32 flags, features; 2315 2316 u32 ap_sme_capa; 2317 2318 enum cfg80211_signal_type signal_type; 2319 2320 int bss_priv_size; 2321 u8 max_scan_ssids; 2322 u8 max_sched_scan_ssids; 2323 u8 max_match_sets; 2324 u16 max_scan_ie_len; 2325 u16 max_sched_scan_ie_len; 2326 2327 int n_cipher_suites; 2328 const u32 *cipher_suites; 2329 2330 u8 retry_short; 2331 u8 retry_long; 2332 u32 frag_threshold; 2333 u32 rts_threshold; 2334 u8 coverage_class; 2335 2336 char fw_version[ETHTOOL_BUSINFO_LEN]; 2337 u32 hw_version; 2338 2339 #ifdef CONFIG_PM 2340 struct wiphy_wowlan_support wowlan; 2341 #endif 2342 2343 u16 max_remain_on_channel_duration; 2344 2345 u8 max_num_pmkids; 2346 2347 u32 available_antennas_tx; 2348 u32 available_antennas_rx; 2349 2350 /* 2351 * Bitmap of supported protocols for probe response offloading 2352 * see &enum nl80211_probe_resp_offload_support_attr. Only valid 2353 * when the wiphy flag @WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD is set. 2354 */ 2355 u32 probe_resp_offload; 2356 2357 /* If multiple wiphys are registered and you're handed e.g. 2358 * a regular netdev with assigned ieee80211_ptr, you won't 2359 * know whether it points to a wiphy your driver has registered 2360 * or not. Assign this to something global to your driver to 2361 * help determine whether you own this wiphy or not. */ 2362 const void *privid; 2363 2364 struct ieee80211_supported_band *bands[IEEE80211_NUM_BANDS]; 2365 2366 /* Lets us get back the wiphy on the callback */ 2367 int (*reg_notifier)(struct wiphy *wiphy, 2368 struct regulatory_request *request); 2369 2370 /* fields below are read-only, assigned by cfg80211 */ 2371 2372 const struct ieee80211_regdomain *regd; 2373 2374 /* the item in /sys/class/ieee80211/ points to this, 2375 * you need use set_wiphy_dev() (see below) */ 2376 struct device dev; 2377 2378 /* protects ->resume, ->suspend sysfs callbacks against unregister hw */ 2379 bool registered; 2380 2381 /* dir in debugfs: ieee80211/<wiphyname> */ 2382 struct dentry *debugfsdir; 2383 2384 const struct ieee80211_ht_cap *ht_capa_mod_mask; 2385 2386 #ifdef CONFIG_NET_NS 2387 /* the network namespace this phy lives in currently */ 2388 struct net *_net; 2389 #endif 2390 2391 #ifdef CONFIG_CFG80211_WEXT 2392 const struct iw_handler_def *wext; 2393 #endif 2394 2395 char priv[0] __attribute__((__aligned__(NETDEV_ALIGN))); 2396 }; 2397 2398 static inline struct net *wiphy_net(struct wiphy *wiphy) 2399 { 2400 return read_pnet(&wiphy->_net); 2401 } 2402 2403 static inline void wiphy_net_set(struct wiphy *wiphy, struct net *net) 2404 { 2405 write_pnet(&wiphy->_net, net); 2406 } 2407 2408 /** 2409 * wiphy_priv - return priv from wiphy 2410 * 2411 * @wiphy: the wiphy whose priv pointer to return 2412 */ 2413 static inline void *wiphy_priv(struct wiphy *wiphy) 2414 { 2415 BUG_ON(!wiphy); 2416 return &wiphy->priv; 2417 } 2418 2419 /** 2420 * priv_to_wiphy - return the wiphy containing the priv 2421 * 2422 * @priv: a pointer previously returned by wiphy_priv 2423 */ 2424 static inline struct wiphy *priv_to_wiphy(void *priv) 2425 { 2426 BUG_ON(!priv); 2427 return container_of(priv, struct wiphy, priv); 2428 } 2429 2430 /** 2431 * set_wiphy_dev - set device pointer for wiphy 2432 * 2433 * @wiphy: The wiphy whose device to bind 2434 * @dev: The device to parent it to 2435 */ 2436 static inline void set_wiphy_dev(struct wiphy *wiphy, struct device *dev) 2437 { 2438 wiphy->dev.parent = dev; 2439 } 2440 2441 /** 2442 * wiphy_dev - get wiphy dev pointer 2443 * 2444 * @wiphy: The wiphy whose device struct to look up 2445 */ 2446 static inline struct device *wiphy_dev(struct wiphy *wiphy) 2447 { 2448 return wiphy->dev.parent; 2449 } 2450 2451 /** 2452 * wiphy_name - get wiphy name 2453 * 2454 * @wiphy: The wiphy whose name to return 2455 */ 2456 static inline const char *wiphy_name(const struct wiphy *wiphy) 2457 { 2458 return dev_name(&wiphy->dev); 2459 } 2460 2461 /** 2462 * wiphy_new - create a new wiphy for use with cfg80211 2463 * 2464 * @ops: The configuration operations for this device 2465 * @sizeof_priv: The size of the private area to allocate 2466 * 2467 * Create a new wiphy and associate the given operations with it. 2468 * @sizeof_priv bytes are allocated for private use. 2469 * 2470 * The returned pointer must be assigned to each netdev's 2471 * ieee80211_ptr for proper operation. 2472 */ 2473 struct wiphy *wiphy_new(const struct cfg80211_ops *ops, int sizeof_priv); 2474 2475 /** 2476 * wiphy_register - register a wiphy with cfg80211 2477 * 2478 * @wiphy: The wiphy to register. 2479 * 2480 * Returns a non-negative wiphy index or a negative error code. 2481 */ 2482 extern int wiphy_register(struct wiphy *wiphy); 2483 2484 /** 2485 * wiphy_unregister - deregister a wiphy from cfg80211 2486 * 2487 * @wiphy: The wiphy to unregister. 2488 * 2489 * After this call, no more requests can be made with this priv 2490 * pointer, but the call may sleep to wait for an outstanding 2491 * request that is being handled. 2492 */ 2493 extern void wiphy_unregister(struct wiphy *wiphy); 2494 2495 /** 2496 * wiphy_free - free wiphy 2497 * 2498 * @wiphy: The wiphy to free 2499 */ 2500 extern void wiphy_free(struct wiphy *wiphy); 2501 2502 /* internal structs */ 2503 struct cfg80211_conn; 2504 struct cfg80211_internal_bss; 2505 struct cfg80211_cached_keys; 2506 2507 /** 2508 * struct wireless_dev - wireless device state 2509 * 2510 * For netdevs, this structure must be allocated by the driver 2511 * that uses the ieee80211_ptr field in struct net_device (this 2512 * is intentional so it can be allocated along with the netdev.) 2513 * It need not be registered then as netdev registration will 2514 * be intercepted by cfg80211 to see the new wireless device. 2515 * 2516 * For non-netdev uses, it must also be allocated by the driver 2517 * in response to the cfg80211 callbacks that require it, as 2518 * there's no netdev registration in that case it may not be 2519 * allocated outside of callback operations that return it. 2520 * 2521 * @wiphy: pointer to hardware description 2522 * @iftype: interface type 2523 * @list: (private) Used to collect the interfaces 2524 * @netdev: (private) Used to reference back to the netdev, may be %NULL 2525 * @identifier: (private) Identifier used in nl80211 to identify this 2526 * wireless device if it has no netdev 2527 * @current_bss: (private) Used by the internal configuration code 2528 * @channel: (private) Used by the internal configuration code to track 2529 * the user-set AP, monitor and WDS channel 2530 * @preset_chan: (private) Used by the internal configuration code to 2531 * track the channel to be used for AP later 2532 * @preset_chantype: (private) the corresponding channel type 2533 * @bssid: (private) Used by the internal configuration code 2534 * @ssid: (private) Used by the internal configuration code 2535 * @ssid_len: (private) Used by the internal configuration code 2536 * @mesh_id_len: (private) Used by the internal configuration code 2537 * @mesh_id_up_len: (private) Used by the internal configuration code 2538 * @wext: (private) Used by the internal wireless extensions compat code 2539 * @use_4addr: indicates 4addr mode is used on this interface, must be 2540 * set by driver (if supported) on add_interface BEFORE registering the 2541 * netdev and may otherwise be used by driver read-only, will be update 2542 * by cfg80211 on change_interface 2543 * @mgmt_registrations: list of registrations for management frames 2544 * @mgmt_registrations_lock: lock for the list 2545 * @mtx: mutex used to lock data in this struct 2546 * @cleanup_work: work struct used for cleanup that can't be done directly 2547 * @beacon_interval: beacon interval used on this device for transmitting 2548 * beacons, 0 when not valid 2549 * @address: The address for this device, valid only if @netdev is %NULL 2550 * @p2p_started: true if this is a P2P Device that has been started 2551 */ 2552 struct wireless_dev { 2553 struct wiphy *wiphy; 2554 enum nl80211_iftype iftype; 2555 2556 /* the remainder of this struct should be private to cfg80211 */ 2557 struct list_head list; 2558 struct net_device *netdev; 2559 2560 u32 identifier; 2561 2562 struct list_head mgmt_registrations; 2563 spinlock_t mgmt_registrations_lock; 2564 2565 struct mutex mtx; 2566 2567 struct work_struct cleanup_work; 2568 2569 bool use_4addr, p2p_started; 2570 2571 u8 address[ETH_ALEN] __aligned(sizeof(u16)); 2572 2573 /* currently used for IBSS and SME - might be rearranged later */ 2574 u8 ssid[IEEE80211_MAX_SSID_LEN]; 2575 u8 ssid_len, mesh_id_len, mesh_id_up_len; 2576 enum { 2577 CFG80211_SME_IDLE, 2578 CFG80211_SME_CONNECTING, 2579 CFG80211_SME_CONNECTED, 2580 } sme_state; 2581 struct cfg80211_conn *conn; 2582 struct cfg80211_cached_keys *connect_keys; 2583 2584 struct list_head event_list; 2585 spinlock_t event_lock; 2586 2587 struct cfg80211_internal_bss *current_bss; /* associated / joined */ 2588 struct cfg80211_chan_def preset_chandef; 2589 2590 /* for AP and mesh channel tracking */ 2591 struct ieee80211_channel *channel; 2592 2593 bool ibss_fixed; 2594 2595 bool ps; 2596 int ps_timeout; 2597 2598 int beacon_interval; 2599 2600 u32 ap_unexpected_nlportid; 2601 2602 #ifdef CONFIG_CFG80211_WEXT 2603 /* wext data */ 2604 struct { 2605 struct cfg80211_ibss_params ibss; 2606 struct cfg80211_connect_params connect; 2607 struct cfg80211_cached_keys *keys; 2608 u8 *ie; 2609 size_t ie_len; 2610 u8 bssid[ETH_ALEN], prev_bssid[ETH_ALEN]; 2611 u8 ssid[IEEE80211_MAX_SSID_LEN]; 2612 s8 default_key, default_mgmt_key; 2613 bool prev_bssid_valid; 2614 } wext; 2615 #endif 2616 }; 2617 2618 static inline u8 *wdev_address(struct wireless_dev *wdev) 2619 { 2620 if (wdev->netdev) 2621 return wdev->netdev->dev_addr; 2622 return wdev->address; 2623 } 2624 2625 /** 2626 * wdev_priv - return wiphy priv from wireless_dev 2627 * 2628 * @wdev: The wireless device whose wiphy's priv pointer to return 2629 */ 2630 static inline void *wdev_priv(struct wireless_dev *wdev) 2631 { 2632 BUG_ON(!wdev); 2633 return wiphy_priv(wdev->wiphy); 2634 } 2635 2636 /** 2637 * DOC: Utility functions 2638 * 2639 * cfg80211 offers a number of utility functions that can be useful. 2640 */ 2641 2642 /** 2643 * ieee80211_channel_to_frequency - convert channel number to frequency 2644 * @chan: channel number 2645 * @band: band, necessary due to channel number overlap 2646 */ 2647 extern int ieee80211_channel_to_frequency(int chan, enum ieee80211_band band); 2648 2649 /** 2650 * ieee80211_frequency_to_channel - convert frequency to channel number 2651 * @freq: center frequency 2652 */ 2653 extern int ieee80211_frequency_to_channel(int freq); 2654 2655 /* 2656 * Name indirection necessary because the ieee80211 code also has 2657 * a function named "ieee80211_get_channel", so if you include 2658 * cfg80211's header file you get cfg80211's version, if you try 2659 * to include both header files you'll (rightfully!) get a symbol 2660 * clash. 2661 */ 2662 extern struct ieee80211_channel *__ieee80211_get_channel(struct wiphy *wiphy, 2663 int freq); 2664 /** 2665 * ieee80211_get_channel - get channel struct from wiphy for specified frequency 2666 * @wiphy: the struct wiphy to get the channel for 2667 * @freq: the center frequency of the channel 2668 */ 2669 static inline struct ieee80211_channel * 2670 ieee80211_get_channel(struct wiphy *wiphy, int freq) 2671 { 2672 return __ieee80211_get_channel(wiphy, freq); 2673 } 2674 2675 /** 2676 * ieee80211_get_response_rate - get basic rate for a given rate 2677 * 2678 * @sband: the band to look for rates in 2679 * @basic_rates: bitmap of basic rates 2680 * @bitrate: the bitrate for which to find the basic rate 2681 * 2682 * This function returns the basic rate corresponding to a given 2683 * bitrate, that is the next lower bitrate contained in the basic 2684 * rate map, which is, for this function, given as a bitmap of 2685 * indices of rates in the band's bitrate table. 2686 */ 2687 struct ieee80211_rate * 2688 ieee80211_get_response_rate(struct ieee80211_supported_band *sband, 2689 u32 basic_rates, int bitrate); 2690 2691 /* 2692 * Radiotap parsing functions -- for controlled injection support 2693 * 2694 * Implemented in net/wireless/radiotap.c 2695 * Documentation in Documentation/networking/radiotap-headers.txt 2696 */ 2697 2698 struct radiotap_align_size { 2699 uint8_t align:4, size:4; 2700 }; 2701 2702 struct ieee80211_radiotap_namespace { 2703 const struct radiotap_align_size *align_size; 2704 int n_bits; 2705 uint32_t oui; 2706 uint8_t subns; 2707 }; 2708 2709 struct ieee80211_radiotap_vendor_namespaces { 2710 const struct ieee80211_radiotap_namespace *ns; 2711 int n_ns; 2712 }; 2713 2714 /** 2715 * struct ieee80211_radiotap_iterator - tracks walk thru present radiotap args 2716 * @this_arg_index: index of current arg, valid after each successful call 2717 * to ieee80211_radiotap_iterator_next() 2718 * @this_arg: pointer to current radiotap arg; it is valid after each 2719 * call to ieee80211_radiotap_iterator_next() but also after 2720 * ieee80211_radiotap_iterator_init() where it will point to 2721 * the beginning of the actual data portion 2722 * @this_arg_size: length of the current arg, for convenience 2723 * @current_namespace: pointer to the current namespace definition 2724 * (or internally %NULL if the current namespace is unknown) 2725 * @is_radiotap_ns: indicates whether the current namespace is the default 2726 * radiotap namespace or not 2727 * 2728 * @_rtheader: pointer to the radiotap header we are walking through 2729 * @_max_length: length of radiotap header in cpu byte ordering 2730 * @_arg_index: next argument index 2731 * @_arg: next argument pointer 2732 * @_next_bitmap: internal pointer to next present u32 2733 * @_bitmap_shifter: internal shifter for curr u32 bitmap, b0 set == arg present 2734 * @_vns: vendor namespace definitions 2735 * @_next_ns_data: beginning of the next namespace's data 2736 * @_reset_on_ext: internal; reset the arg index to 0 when going to the 2737 * next bitmap word 2738 * 2739 * Describes the radiotap parser state. Fields prefixed with an underscore 2740 * must not be used by users of the parser, only by the parser internally. 2741 */ 2742 2743 struct ieee80211_radiotap_iterator { 2744 struct ieee80211_radiotap_header *_rtheader; 2745 const struct ieee80211_radiotap_vendor_namespaces *_vns; 2746 const struct ieee80211_radiotap_namespace *current_namespace; 2747 2748 unsigned char *_arg, *_next_ns_data; 2749 __le32 *_next_bitmap; 2750 2751 unsigned char *this_arg; 2752 int this_arg_index; 2753 int this_arg_size; 2754 2755 int is_radiotap_ns; 2756 2757 int _max_length; 2758 int _arg_index; 2759 uint32_t _bitmap_shifter; 2760 int _reset_on_ext; 2761 }; 2762 2763 extern int ieee80211_radiotap_iterator_init( 2764 struct ieee80211_radiotap_iterator *iterator, 2765 struct ieee80211_radiotap_header *radiotap_header, 2766 int max_length, const struct ieee80211_radiotap_vendor_namespaces *vns); 2767 2768 extern int ieee80211_radiotap_iterator_next( 2769 struct ieee80211_radiotap_iterator *iterator); 2770 2771 2772 extern const unsigned char rfc1042_header[6]; 2773 extern const unsigned char bridge_tunnel_header[6]; 2774 2775 /** 2776 * ieee80211_get_hdrlen_from_skb - get header length from data 2777 * 2778 * Given an skb with a raw 802.11 header at the data pointer this function 2779 * returns the 802.11 header length in bytes (not including encryption 2780 * headers). If the data in the sk_buff is too short to contain a valid 802.11 2781 * header the function returns 0. 2782 * 2783 * @skb: the frame 2784 */ 2785 unsigned int ieee80211_get_hdrlen_from_skb(const struct sk_buff *skb); 2786 2787 /** 2788 * ieee80211_hdrlen - get header length in bytes from frame control 2789 * @fc: frame control field in little-endian format 2790 */ 2791 unsigned int __attribute_const__ ieee80211_hdrlen(__le16 fc); 2792 2793 /** 2794 * ieee80211_get_mesh_hdrlen - get mesh extension header length 2795 * @meshhdr: the mesh extension header, only the flags field 2796 * (first byte) will be accessed 2797 * Returns the length of the extension header, which is always at 2798 * least 6 bytes and at most 18 if address 5 and 6 are present. 2799 */ 2800 unsigned int ieee80211_get_mesh_hdrlen(struct ieee80211s_hdr *meshhdr); 2801 2802 /** 2803 * DOC: Data path helpers 2804 * 2805 * In addition to generic utilities, cfg80211 also offers 2806 * functions that help implement the data path for devices 2807 * that do not do the 802.11/802.3 conversion on the device. 2808 */ 2809 2810 /** 2811 * ieee80211_data_to_8023 - convert an 802.11 data frame to 802.3 2812 * @skb: the 802.11 data frame 2813 * @addr: the device MAC address 2814 * @iftype: the virtual interface type 2815 */ 2816 int ieee80211_data_to_8023(struct sk_buff *skb, const u8 *addr, 2817 enum nl80211_iftype iftype); 2818 2819 /** 2820 * ieee80211_data_from_8023 - convert an 802.3 frame to 802.11 2821 * @skb: the 802.3 frame 2822 * @addr: the device MAC address 2823 * @iftype: the virtual interface type 2824 * @bssid: the network bssid (used only for iftype STATION and ADHOC) 2825 * @qos: build 802.11 QoS data frame 2826 */ 2827 int ieee80211_data_from_8023(struct sk_buff *skb, const u8 *addr, 2828 enum nl80211_iftype iftype, u8 *bssid, bool qos); 2829 2830 /** 2831 * ieee80211_amsdu_to_8023s - decode an IEEE 802.11n A-MSDU frame 2832 * 2833 * Decode an IEEE 802.11n A-MSDU frame and convert it to a list of 2834 * 802.3 frames. The @list will be empty if the decode fails. The 2835 * @skb is consumed after the function returns. 2836 * 2837 * @skb: The input IEEE 802.11n A-MSDU frame. 2838 * @list: The output list of 802.3 frames. It must be allocated and 2839 * initialized by by the caller. 2840 * @addr: The device MAC address. 2841 * @iftype: The device interface type. 2842 * @extra_headroom: The hardware extra headroom for SKBs in the @list. 2843 * @has_80211_header: Set it true if SKB is with IEEE 802.11 header. 2844 */ 2845 void ieee80211_amsdu_to_8023s(struct sk_buff *skb, struct sk_buff_head *list, 2846 const u8 *addr, enum nl80211_iftype iftype, 2847 const unsigned int extra_headroom, 2848 bool has_80211_header); 2849 2850 /** 2851 * cfg80211_classify8021d - determine the 802.1p/1d tag for a data frame 2852 * @skb: the data frame 2853 */ 2854 unsigned int cfg80211_classify8021d(struct sk_buff *skb); 2855 2856 /** 2857 * cfg80211_find_ie - find information element in data 2858 * 2859 * @eid: element ID 2860 * @ies: data consisting of IEs 2861 * @len: length of data 2862 * 2863 * This function will return %NULL if the element ID could 2864 * not be found or if the element is invalid (claims to be 2865 * longer than the given data), or a pointer to the first byte 2866 * of the requested element, that is the byte containing the 2867 * element ID. There are no checks on the element length 2868 * other than having to fit into the given data. 2869 */ 2870 const u8 *cfg80211_find_ie(u8 eid, const u8 *ies, int len); 2871 2872 /** 2873 * cfg80211_find_vendor_ie - find vendor specific information element in data 2874 * 2875 * @oui: vendor OUI 2876 * @oui_type: vendor-specific OUI type 2877 * @ies: data consisting of IEs 2878 * @len: length of data 2879 * 2880 * This function will return %NULL if the vendor specific element ID 2881 * could not be found or if the element is invalid (claims to be 2882 * longer than the given data), or a pointer to the first byte 2883 * of the requested element, that is the byte containing the 2884 * element ID. There are no checks on the element length 2885 * other than having to fit into the given data. 2886 */ 2887 const u8 *cfg80211_find_vendor_ie(unsigned int oui, u8 oui_type, 2888 const u8 *ies, int len); 2889 2890 /** 2891 * DOC: Regulatory enforcement infrastructure 2892 * 2893 * TODO 2894 */ 2895 2896 /** 2897 * regulatory_hint - driver hint to the wireless core a regulatory domain 2898 * @wiphy: the wireless device giving the hint (used only for reporting 2899 * conflicts) 2900 * @alpha2: the ISO/IEC 3166 alpha2 the driver claims its regulatory domain 2901 * should be in. If @rd is set this should be NULL. Note that if you 2902 * set this to NULL you should still set rd->alpha2 to some accepted 2903 * alpha2. 2904 * 2905 * Wireless drivers can use this function to hint to the wireless core 2906 * what it believes should be the current regulatory domain by 2907 * giving it an ISO/IEC 3166 alpha2 country code it knows its regulatory 2908 * domain should be in or by providing a completely build regulatory domain. 2909 * If the driver provides an ISO/IEC 3166 alpha2 userspace will be queried 2910 * for a regulatory domain structure for the respective country. 2911 * 2912 * The wiphy must have been registered to cfg80211 prior to this call. 2913 * For cfg80211 drivers this means you must first use wiphy_register(), 2914 * for mac80211 drivers you must first use ieee80211_register_hw(). 2915 * 2916 * Drivers should check the return value, its possible you can get 2917 * an -ENOMEM. 2918 */ 2919 extern int regulatory_hint(struct wiphy *wiphy, const char *alpha2); 2920 2921 /** 2922 * wiphy_apply_custom_regulatory - apply a custom driver regulatory domain 2923 * @wiphy: the wireless device we want to process the regulatory domain on 2924 * @regd: the custom regulatory domain to use for this wiphy 2925 * 2926 * Drivers can sometimes have custom regulatory domains which do not apply 2927 * to a specific country. Drivers can use this to apply such custom regulatory 2928 * domains. This routine must be called prior to wiphy registration. The 2929 * custom regulatory domain will be trusted completely and as such previous 2930 * default channel settings will be disregarded. If no rule is found for a 2931 * channel on the regulatory domain the channel will be disabled. 2932 */ 2933 extern void wiphy_apply_custom_regulatory( 2934 struct wiphy *wiphy, 2935 const struct ieee80211_regdomain *regd); 2936 2937 /** 2938 * freq_reg_info - get regulatory information for the given frequency 2939 * @wiphy: the wiphy for which we want to process this rule for 2940 * @center_freq: Frequency in KHz for which we want regulatory information for 2941 * @desired_bw_khz: the desired max bandwidth you want to use per 2942 * channel. Note that this is still 20 MHz if you want to use HT40 2943 * as HT40 makes use of two channels for its 40 MHz width bandwidth. 2944 * If set to 0 we'll assume you want the standard 20 MHz. 2945 * @reg_rule: the regulatory rule which we have for this frequency 2946 * 2947 * Use this function to get the regulatory rule for a specific frequency on 2948 * a given wireless device. If the device has a specific regulatory domain 2949 * it wants to follow we respect that unless a country IE has been received 2950 * and processed already. 2951 * 2952 * Returns 0 if it was able to find a valid regulatory rule which does 2953 * apply to the given center_freq otherwise it returns non-zero. It will 2954 * also return -ERANGE if we determine the given center_freq does not even have 2955 * a regulatory rule for a frequency range in the center_freq's band. See 2956 * freq_in_rule_band() for our current definition of a band -- this is purely 2957 * subjective and right now its 802.11 specific. 2958 */ 2959 extern int freq_reg_info(struct wiphy *wiphy, 2960 u32 center_freq, 2961 u32 desired_bw_khz, 2962 const struct ieee80211_reg_rule **reg_rule); 2963 2964 /* 2965 * callbacks for asynchronous cfg80211 methods, notification 2966 * functions and BSS handling helpers 2967 */ 2968 2969 /** 2970 * cfg80211_scan_done - notify that scan finished 2971 * 2972 * @request: the corresponding scan request 2973 * @aborted: set to true if the scan was aborted for any reason, 2974 * userspace will be notified of that 2975 */ 2976 void cfg80211_scan_done(struct cfg80211_scan_request *request, bool aborted); 2977 2978 /** 2979 * cfg80211_sched_scan_results - notify that new scan results are available 2980 * 2981 * @wiphy: the wiphy which got scheduled scan results 2982 */ 2983 void cfg80211_sched_scan_results(struct wiphy *wiphy); 2984 2985 /** 2986 * cfg80211_sched_scan_stopped - notify that the scheduled scan has stopped 2987 * 2988 * @wiphy: the wiphy on which the scheduled scan stopped 2989 * 2990 * The driver can call this function to inform cfg80211 that the 2991 * scheduled scan had to be stopped, for whatever reason. The driver 2992 * is then called back via the sched_scan_stop operation when done. 2993 */ 2994 void cfg80211_sched_scan_stopped(struct wiphy *wiphy); 2995 2996 /** 2997 * cfg80211_inform_bss_frame - inform cfg80211 of a received BSS frame 2998 * 2999 * @wiphy: the wiphy reporting the BSS 3000 * @channel: The channel the frame was received on 3001 * @mgmt: the management frame (probe response or beacon) 3002 * @len: length of the management frame 3003 * @signal: the signal strength, type depends on the wiphy's signal_type 3004 * @gfp: context flags 3005 * 3006 * This informs cfg80211 that BSS information was found and 3007 * the BSS should be updated/added. 3008 * 3009 * NOTE: Returns a referenced struct, must be released with cfg80211_put_bss()! 3010 */ 3011 struct cfg80211_bss * __must_check 3012 cfg80211_inform_bss_frame(struct wiphy *wiphy, 3013 struct ieee80211_channel *channel, 3014 struct ieee80211_mgmt *mgmt, size_t len, 3015 s32 signal, gfp_t gfp); 3016 3017 /** 3018 * cfg80211_inform_bss - inform cfg80211 of a new BSS 3019 * 3020 * @wiphy: the wiphy reporting the BSS 3021 * @channel: The channel the frame was received on 3022 * @bssid: the BSSID of the BSS 3023 * @tsf: the TSF sent by the peer in the beacon/probe response (or 0) 3024 * @capability: the capability field sent by the peer 3025 * @beacon_interval: the beacon interval announced by the peer 3026 * @ie: additional IEs sent by the peer 3027 * @ielen: length of the additional IEs 3028 * @signal: the signal strength, type depends on the wiphy's signal_type 3029 * @gfp: context flags 3030 * 3031 * This informs cfg80211 that BSS information was found and 3032 * the BSS should be updated/added. 3033 * 3034 * NOTE: Returns a referenced struct, must be released with cfg80211_put_bss()! 3035 */ 3036 struct cfg80211_bss * __must_check 3037 cfg80211_inform_bss(struct wiphy *wiphy, 3038 struct ieee80211_channel *channel, 3039 const u8 *bssid, u64 tsf, u16 capability, 3040 u16 beacon_interval, const u8 *ie, size_t ielen, 3041 s32 signal, gfp_t gfp); 3042 3043 struct cfg80211_bss *cfg80211_get_bss(struct wiphy *wiphy, 3044 struct ieee80211_channel *channel, 3045 const u8 *bssid, 3046 const u8 *ssid, size_t ssid_len, 3047 u16 capa_mask, u16 capa_val); 3048 static inline struct cfg80211_bss * 3049 cfg80211_get_ibss(struct wiphy *wiphy, 3050 struct ieee80211_channel *channel, 3051 const u8 *ssid, size_t ssid_len) 3052 { 3053 return cfg80211_get_bss(wiphy, channel, NULL, ssid, ssid_len, 3054 WLAN_CAPABILITY_IBSS, WLAN_CAPABILITY_IBSS); 3055 } 3056 3057 struct cfg80211_bss *cfg80211_get_mesh(struct wiphy *wiphy, 3058 struct ieee80211_channel *channel, 3059 const u8 *meshid, size_t meshidlen, 3060 const u8 *meshcfg); 3061 /** 3062 * cfg80211_ref_bss - reference BSS struct 3063 * @bss: the BSS struct to reference 3064 * 3065 * Increments the refcount of the given BSS struct. 3066 */ 3067 void cfg80211_ref_bss(struct cfg80211_bss *bss); 3068 3069 /** 3070 * cfg80211_put_bss - unref BSS struct 3071 * @bss: the BSS struct 3072 * 3073 * Decrements the refcount of the given BSS struct. 3074 */ 3075 void cfg80211_put_bss(struct cfg80211_bss *bss); 3076 3077 /** 3078 * cfg80211_unlink_bss - unlink BSS from internal data structures 3079 * @wiphy: the wiphy 3080 * @bss: the bss to remove 3081 * 3082 * This function removes the given BSS from the internal data structures 3083 * thereby making it no longer show up in scan results etc. Use this 3084 * function when you detect a BSS is gone. Normally BSSes will also time 3085 * out, so it is not necessary to use this function at all. 3086 */ 3087 void cfg80211_unlink_bss(struct wiphy *wiphy, struct cfg80211_bss *bss); 3088 3089 /** 3090 * cfg80211_send_rx_auth - notification of processed authentication 3091 * @dev: network device 3092 * @buf: authentication frame (header + body) 3093 * @len: length of the frame data 3094 * 3095 * This function is called whenever an authentication has been processed in 3096 * station mode. The driver is required to call either this function or 3097 * cfg80211_send_auth_timeout() to indicate the result of cfg80211_ops::auth() 3098 * call. This function may sleep. 3099 */ 3100 void cfg80211_send_rx_auth(struct net_device *dev, const u8 *buf, size_t len); 3101 3102 /** 3103 * cfg80211_send_auth_timeout - notification of timed out authentication 3104 * @dev: network device 3105 * @addr: The MAC address of the device with which the authentication timed out 3106 * 3107 * This function may sleep. 3108 */ 3109 void cfg80211_send_auth_timeout(struct net_device *dev, const u8 *addr); 3110 3111 /** 3112 * cfg80211_send_rx_assoc - notification of processed association 3113 * @dev: network device 3114 * @bss: the BSS struct association was requested for, the struct reference 3115 * is owned by cfg80211 after this call 3116 * @buf: (re)association response frame (header + body) 3117 * @len: length of the frame data 3118 * 3119 * This function is called whenever a (re)association response has been 3120 * processed in station mode. The driver is required to call either this 3121 * function or cfg80211_send_assoc_timeout() to indicate the result of 3122 * cfg80211_ops::assoc() call. This function may sleep. 3123 */ 3124 void cfg80211_send_rx_assoc(struct net_device *dev, struct cfg80211_bss *bss, 3125 const u8 *buf, size_t len); 3126 3127 /** 3128 * cfg80211_send_assoc_timeout - notification of timed out association 3129 * @dev: network device 3130 * @addr: The MAC address of the device with which the association timed out 3131 * 3132 * This function may sleep. 3133 */ 3134 void cfg80211_send_assoc_timeout(struct net_device *dev, const u8 *addr); 3135 3136 /** 3137 * cfg80211_send_deauth - notification of processed deauthentication 3138 * @dev: network device 3139 * @buf: deauthentication frame (header + body) 3140 * @len: length of the frame data 3141 * 3142 * This function is called whenever deauthentication has been processed in 3143 * station mode. This includes both received deauthentication frames and 3144 * locally generated ones. This function may sleep. 3145 */ 3146 void cfg80211_send_deauth(struct net_device *dev, const u8 *buf, size_t len); 3147 3148 /** 3149 * __cfg80211_send_deauth - notification of processed deauthentication 3150 * @dev: network device 3151 * @buf: deauthentication frame (header + body) 3152 * @len: length of the frame data 3153 * 3154 * Like cfg80211_send_deauth(), but doesn't take the wdev lock. 3155 */ 3156 void __cfg80211_send_deauth(struct net_device *dev, const u8 *buf, size_t len); 3157 3158 /** 3159 * cfg80211_send_disassoc - notification of processed disassociation 3160 * @dev: network device 3161 * @buf: disassociation response frame (header + body) 3162 * @len: length of the frame data 3163 * 3164 * This function is called whenever disassociation has been processed in 3165 * station mode. This includes both received disassociation frames and locally 3166 * generated ones. This function may sleep. 3167 */ 3168 void cfg80211_send_disassoc(struct net_device *dev, const u8 *buf, size_t len); 3169 3170 /** 3171 * __cfg80211_send_disassoc - notification of processed disassociation 3172 * @dev: network device 3173 * @buf: disassociation response frame (header + body) 3174 * @len: length of the frame data 3175 * 3176 * Like cfg80211_send_disassoc(), but doesn't take the wdev lock. 3177 */ 3178 void __cfg80211_send_disassoc(struct net_device *dev, const u8 *buf, 3179 size_t len); 3180 3181 /** 3182 * cfg80211_send_unprot_deauth - notification of unprotected deauthentication 3183 * @dev: network device 3184 * @buf: deauthentication frame (header + body) 3185 * @len: length of the frame data 3186 * 3187 * This function is called whenever a received Deauthentication frame has been 3188 * dropped in station mode because of MFP being used but the Deauthentication 3189 * frame was not protected. This function may sleep. 3190 */ 3191 void cfg80211_send_unprot_deauth(struct net_device *dev, const u8 *buf, 3192 size_t len); 3193 3194 /** 3195 * cfg80211_send_unprot_disassoc - notification of unprotected disassociation 3196 * @dev: network device 3197 * @buf: disassociation frame (header + body) 3198 * @len: length of the frame data 3199 * 3200 * This function is called whenever a received Disassociation frame has been 3201 * dropped in station mode because of MFP being used but the Disassociation 3202 * frame was not protected. This function may sleep. 3203 */ 3204 void cfg80211_send_unprot_disassoc(struct net_device *dev, const u8 *buf, 3205 size_t len); 3206 3207 /** 3208 * cfg80211_michael_mic_failure - notification of Michael MIC failure (TKIP) 3209 * @dev: network device 3210 * @addr: The source MAC address of the frame 3211 * @key_type: The key type that the received frame used 3212 * @key_id: Key identifier (0..3). Can be -1 if missing. 3213 * @tsc: The TSC value of the frame that generated the MIC failure (6 octets) 3214 * @gfp: allocation flags 3215 * 3216 * This function is called whenever the local MAC detects a MIC failure in a 3217 * received frame. This matches with MLME-MICHAELMICFAILURE.indication() 3218 * primitive. 3219 */ 3220 void cfg80211_michael_mic_failure(struct net_device *dev, const u8 *addr, 3221 enum nl80211_key_type key_type, int key_id, 3222 const u8 *tsc, gfp_t gfp); 3223 3224 /** 3225 * cfg80211_ibss_joined - notify cfg80211 that device joined an IBSS 3226 * 3227 * @dev: network device 3228 * @bssid: the BSSID of the IBSS joined 3229 * @gfp: allocation flags 3230 * 3231 * This function notifies cfg80211 that the device joined an IBSS or 3232 * switched to a different BSSID. Before this function can be called, 3233 * either a beacon has to have been received from the IBSS, or one of 3234 * the cfg80211_inform_bss{,_frame} functions must have been called 3235 * with the locally generated beacon -- this guarantees that there is 3236 * always a scan result for this IBSS. cfg80211 will handle the rest. 3237 */ 3238 void cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid, gfp_t gfp); 3239 3240 /** 3241 * cfg80211_notify_new_candidate - notify cfg80211 of a new mesh peer candidate 3242 * 3243 * @dev: network device 3244 * @macaddr: the MAC address of the new candidate 3245 * @ie: information elements advertised by the peer candidate 3246 * @ie_len: lenght of the information elements buffer 3247 * @gfp: allocation flags 3248 * 3249 * This function notifies cfg80211 that the mesh peer candidate has been 3250 * detected, most likely via a beacon or, less likely, via a probe response. 3251 * cfg80211 then sends a notification to userspace. 3252 */ 3253 void cfg80211_notify_new_peer_candidate(struct net_device *dev, 3254 const u8 *macaddr, const u8 *ie, u8 ie_len, gfp_t gfp); 3255 3256 /** 3257 * DOC: RFkill integration 3258 * 3259 * RFkill integration in cfg80211 is almost invisible to drivers, 3260 * as cfg80211 automatically registers an rfkill instance for each 3261 * wireless device it knows about. Soft kill is also translated 3262 * into disconnecting and turning all interfaces off, drivers are 3263 * expected to turn off the device when all interfaces are down. 3264 * 3265 * However, devices may have a hard RFkill line, in which case they 3266 * also need to interact with the rfkill subsystem, via cfg80211. 3267 * They can do this with a few helper functions documented here. 3268 */ 3269 3270 /** 3271 * wiphy_rfkill_set_hw_state - notify cfg80211 about hw block state 3272 * @wiphy: the wiphy 3273 * @blocked: block status 3274 */ 3275 void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked); 3276 3277 /** 3278 * wiphy_rfkill_start_polling - start polling rfkill 3279 * @wiphy: the wiphy 3280 */ 3281 void wiphy_rfkill_start_polling(struct wiphy *wiphy); 3282 3283 /** 3284 * wiphy_rfkill_stop_polling - stop polling rfkill 3285 * @wiphy: the wiphy 3286 */ 3287 void wiphy_rfkill_stop_polling(struct wiphy *wiphy); 3288 3289 #ifdef CONFIG_NL80211_TESTMODE 3290 /** 3291 * DOC: Test mode 3292 * 3293 * Test mode is a set of utility functions to allow drivers to 3294 * interact with driver-specific tools to aid, for instance, 3295 * factory programming. 3296 * 3297 * This chapter describes how drivers interact with it, for more 3298 * information see the nl80211 book's chapter on it. 3299 */ 3300 3301 /** 3302 * cfg80211_testmode_alloc_reply_skb - allocate testmode reply 3303 * @wiphy: the wiphy 3304 * @approxlen: an upper bound of the length of the data that will 3305 * be put into the skb 3306 * 3307 * This function allocates and pre-fills an skb for a reply to 3308 * the testmode command. Since it is intended for a reply, calling 3309 * it outside of the @testmode_cmd operation is invalid. 3310 * 3311 * The returned skb (or %NULL if any errors happen) is pre-filled 3312 * with the wiphy index and set up in a way that any data that is 3313 * put into the skb (with skb_put(), nla_put() or similar) will end 3314 * up being within the %NL80211_ATTR_TESTDATA attribute, so all that 3315 * needs to be done with the skb is adding data for the corresponding 3316 * userspace tool which can then read that data out of the testdata 3317 * attribute. You must not modify the skb in any other way. 3318 * 3319 * When done, call cfg80211_testmode_reply() with the skb and return 3320 * its error code as the result of the @testmode_cmd operation. 3321 */ 3322 struct sk_buff *cfg80211_testmode_alloc_reply_skb(struct wiphy *wiphy, 3323 int approxlen); 3324 3325 /** 3326 * cfg80211_testmode_reply - send the reply skb 3327 * @skb: The skb, must have been allocated with 3328 * cfg80211_testmode_alloc_reply_skb() 3329 * 3330 * Returns an error code or 0 on success, since calling this 3331 * function will usually be the last thing before returning 3332 * from the @testmode_cmd you should return the error code. 3333 * Note that this function consumes the skb regardless of the 3334 * return value. 3335 */ 3336 int cfg80211_testmode_reply(struct sk_buff *skb); 3337 3338 /** 3339 * cfg80211_testmode_alloc_event_skb - allocate testmode event 3340 * @wiphy: the wiphy 3341 * @approxlen: an upper bound of the length of the data that will 3342 * be put into the skb 3343 * @gfp: allocation flags 3344 * 3345 * This function allocates and pre-fills an skb for an event on the 3346 * testmode multicast group. 3347 * 3348 * The returned skb (or %NULL if any errors happen) is set up in the 3349 * same way as with cfg80211_testmode_alloc_reply_skb() but prepared 3350 * for an event. As there, you should simply add data to it that will 3351 * then end up in the %NL80211_ATTR_TESTDATA attribute. Again, you must 3352 * not modify the skb in any other way. 3353 * 3354 * When done filling the skb, call cfg80211_testmode_event() with the 3355 * skb to send the event. 3356 */ 3357 struct sk_buff *cfg80211_testmode_alloc_event_skb(struct wiphy *wiphy, 3358 int approxlen, gfp_t gfp); 3359 3360 /** 3361 * cfg80211_testmode_event - send the event 3362 * @skb: The skb, must have been allocated with 3363 * cfg80211_testmode_alloc_event_skb() 3364 * @gfp: allocation flags 3365 * 3366 * This function sends the given @skb, which must have been allocated 3367 * by cfg80211_testmode_alloc_event_skb(), as an event. It always 3368 * consumes it. 3369 */ 3370 void cfg80211_testmode_event(struct sk_buff *skb, gfp_t gfp); 3371 3372 #define CFG80211_TESTMODE_CMD(cmd) .testmode_cmd = (cmd), 3373 #define CFG80211_TESTMODE_DUMP(cmd) .testmode_dump = (cmd), 3374 #else 3375 #define CFG80211_TESTMODE_CMD(cmd) 3376 #define CFG80211_TESTMODE_DUMP(cmd) 3377 #endif 3378 3379 /** 3380 * cfg80211_connect_result - notify cfg80211 of connection result 3381 * 3382 * @dev: network device 3383 * @bssid: the BSSID of the AP 3384 * @req_ie: association request IEs (maybe be %NULL) 3385 * @req_ie_len: association request IEs length 3386 * @resp_ie: association response IEs (may be %NULL) 3387 * @resp_ie_len: assoc response IEs length 3388 * @status: status code, 0 for successful connection, use 3389 * %WLAN_STATUS_UNSPECIFIED_FAILURE if your device cannot give you 3390 * the real status code for failures. 3391 * @gfp: allocation flags 3392 * 3393 * It should be called by the underlying driver whenever connect() has 3394 * succeeded. 3395 */ 3396 void cfg80211_connect_result(struct net_device *dev, const u8 *bssid, 3397 const u8 *req_ie, size_t req_ie_len, 3398 const u8 *resp_ie, size_t resp_ie_len, 3399 u16 status, gfp_t gfp); 3400 3401 /** 3402 * cfg80211_roamed - notify cfg80211 of roaming 3403 * 3404 * @dev: network device 3405 * @channel: the channel of the new AP 3406 * @bssid: the BSSID of the new AP 3407 * @req_ie: association request IEs (maybe be %NULL) 3408 * @req_ie_len: association request IEs length 3409 * @resp_ie: association response IEs (may be %NULL) 3410 * @resp_ie_len: assoc response IEs length 3411 * @gfp: allocation flags 3412 * 3413 * It should be called by the underlying driver whenever it roamed 3414 * from one AP to another while connected. 3415 */ 3416 void cfg80211_roamed(struct net_device *dev, 3417 struct ieee80211_channel *channel, 3418 const u8 *bssid, 3419 const u8 *req_ie, size_t req_ie_len, 3420 const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp); 3421 3422 /** 3423 * cfg80211_roamed_bss - notify cfg80211 of roaming 3424 * 3425 * @dev: network device 3426 * @bss: entry of bss to which STA got roamed 3427 * @req_ie: association request IEs (maybe be %NULL) 3428 * @req_ie_len: association request IEs length 3429 * @resp_ie: association response IEs (may be %NULL) 3430 * @resp_ie_len: assoc response IEs length 3431 * @gfp: allocation flags 3432 * 3433 * This is just a wrapper to notify cfg80211 of roaming event with driver 3434 * passing bss to avoid a race in timeout of the bss entry. It should be 3435 * called by the underlying driver whenever it roamed from one AP to another 3436 * while connected. Drivers which have roaming implemented in firmware 3437 * may use this function to avoid a race in bss entry timeout where the bss 3438 * entry of the new AP is seen in the driver, but gets timed out by the time 3439 * it is accessed in __cfg80211_roamed() due to delay in scheduling 3440 * rdev->event_work. In case of any failures, the reference is released 3441 * either in cfg80211_roamed_bss() or in __cfg80211_romed(), Otherwise, 3442 * it will be released while diconneting from the current bss. 3443 */ 3444 void cfg80211_roamed_bss(struct net_device *dev, struct cfg80211_bss *bss, 3445 const u8 *req_ie, size_t req_ie_len, 3446 const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp); 3447 3448 /** 3449 * cfg80211_disconnected - notify cfg80211 that connection was dropped 3450 * 3451 * @dev: network device 3452 * @ie: information elements of the deauth/disassoc frame (may be %NULL) 3453 * @ie_len: length of IEs 3454 * @reason: reason code for the disconnection, set it to 0 if unknown 3455 * @gfp: allocation flags 3456 * 3457 * After it calls this function, the driver should enter an idle state 3458 * and not try to connect to any AP any more. 3459 */ 3460 void cfg80211_disconnected(struct net_device *dev, u16 reason, 3461 u8 *ie, size_t ie_len, gfp_t gfp); 3462 3463 /** 3464 * cfg80211_ready_on_channel - notification of remain_on_channel start 3465 * @wdev: wireless device 3466 * @cookie: the request cookie 3467 * @chan: The current channel (from remain_on_channel request) 3468 * @duration: Duration in milliseconds that the driver intents to remain on the 3469 * channel 3470 * @gfp: allocation flags 3471 */ 3472 void cfg80211_ready_on_channel(struct wireless_dev *wdev, u64 cookie, 3473 struct ieee80211_channel *chan, 3474 unsigned int duration, gfp_t gfp); 3475 3476 /** 3477 * cfg80211_remain_on_channel_expired - remain_on_channel duration expired 3478 * @wdev: wireless device 3479 * @cookie: the request cookie 3480 * @chan: The current channel (from remain_on_channel request) 3481 * @gfp: allocation flags 3482 */ 3483 void cfg80211_remain_on_channel_expired(struct wireless_dev *wdev, u64 cookie, 3484 struct ieee80211_channel *chan, 3485 gfp_t gfp); 3486 3487 3488 /** 3489 * cfg80211_new_sta - notify userspace about station 3490 * 3491 * @dev: the netdev 3492 * @mac_addr: the station's address 3493 * @sinfo: the station information 3494 * @gfp: allocation flags 3495 */ 3496 void cfg80211_new_sta(struct net_device *dev, const u8 *mac_addr, 3497 struct station_info *sinfo, gfp_t gfp); 3498 3499 /** 3500 * cfg80211_del_sta - notify userspace about deletion of a station 3501 * 3502 * @dev: the netdev 3503 * @mac_addr: the station's address 3504 * @gfp: allocation flags 3505 */ 3506 void cfg80211_del_sta(struct net_device *dev, const u8 *mac_addr, gfp_t gfp); 3507 3508 /** 3509 * cfg80211_conn_failed - connection request failed notification 3510 * 3511 * @dev: the netdev 3512 * @mac_addr: the station's address 3513 * @reason: the reason for connection failure 3514 * @gfp: allocation flags 3515 * 3516 * Whenever a station tries to connect to an AP and if the station 3517 * could not connect to the AP as the AP has rejected the connection 3518 * for some reasons, this function is called. 3519 * 3520 * The reason for connection failure can be any of the value from 3521 * nl80211_connect_failed_reason enum 3522 */ 3523 void cfg80211_conn_failed(struct net_device *dev, const u8 *mac_addr, 3524 enum nl80211_connect_failed_reason reason, 3525 gfp_t gfp); 3526 3527 /** 3528 * cfg80211_rx_mgmt - notification of received, unprocessed management frame 3529 * @wdev: wireless device receiving the frame 3530 * @freq: Frequency on which the frame was received in MHz 3531 * @sig_dbm: signal strength in mBm, or 0 if unknown 3532 * @buf: Management frame (header + body) 3533 * @len: length of the frame data 3534 * @gfp: context flags 3535 * 3536 * Returns %true if a user space application has registered for this frame. 3537 * For action frames, that makes it responsible for rejecting unrecognized 3538 * action frames; %false otherwise, in which case for action frames the 3539 * driver is responsible for rejecting the frame. 3540 * 3541 * This function is called whenever an Action frame is received for a station 3542 * mode interface, but is not processed in kernel. 3543 */ 3544 bool cfg80211_rx_mgmt(struct wireless_dev *wdev, int freq, int sig_dbm, 3545 const u8 *buf, size_t len, gfp_t gfp); 3546 3547 /** 3548 * cfg80211_mgmt_tx_status - notification of TX status for management frame 3549 * @wdev: wireless device receiving the frame 3550 * @cookie: Cookie returned by cfg80211_ops::mgmt_tx() 3551 * @buf: Management frame (header + body) 3552 * @len: length of the frame data 3553 * @ack: Whether frame was acknowledged 3554 * @gfp: context flags 3555 * 3556 * This function is called whenever a management frame was requested to be 3557 * transmitted with cfg80211_ops::mgmt_tx() to report the TX status of the 3558 * transmission attempt. 3559 */ 3560 void cfg80211_mgmt_tx_status(struct wireless_dev *wdev, u64 cookie, 3561 const u8 *buf, size_t len, bool ack, gfp_t gfp); 3562 3563 3564 /** 3565 * cfg80211_cqm_rssi_notify - connection quality monitoring rssi event 3566 * @dev: network device 3567 * @rssi_event: the triggered RSSI event 3568 * @gfp: context flags 3569 * 3570 * This function is called when a configured connection quality monitoring 3571 * rssi threshold reached event occurs. 3572 */ 3573 void cfg80211_cqm_rssi_notify(struct net_device *dev, 3574 enum nl80211_cqm_rssi_threshold_event rssi_event, 3575 gfp_t gfp); 3576 3577 /** 3578 * cfg80211_cqm_pktloss_notify - notify userspace about packetloss to peer 3579 * @dev: network device 3580 * @peer: peer's MAC address 3581 * @num_packets: how many packets were lost -- should be a fixed threshold 3582 * but probably no less than maybe 50, or maybe a throughput dependent 3583 * threshold (to account for temporary interference) 3584 * @gfp: context flags 3585 */ 3586 void cfg80211_cqm_pktloss_notify(struct net_device *dev, 3587 const u8 *peer, u32 num_packets, gfp_t gfp); 3588 3589 /** 3590 * cfg80211_cqm_txe_notify - TX error rate event 3591 * @dev: network device 3592 * @peer: peer's MAC address 3593 * @num_packets: how many packets were lost 3594 * @rate: % of packets which failed transmission 3595 * @intvl: interval (in s) over which the TX failure threshold was breached. 3596 * @gfp: context flags 3597 * 3598 * Notify userspace when configured % TX failures over number of packets in a 3599 * given interval is exceeded. 3600 */ 3601 void cfg80211_cqm_txe_notify(struct net_device *dev, const u8 *peer, 3602 u32 num_packets, u32 rate, u32 intvl, gfp_t gfp); 3603 3604 /** 3605 * cfg80211_gtk_rekey_notify - notify userspace about driver rekeying 3606 * @dev: network device 3607 * @bssid: BSSID of AP (to avoid races) 3608 * @replay_ctr: new replay counter 3609 * @gfp: allocation flags 3610 */ 3611 void cfg80211_gtk_rekey_notify(struct net_device *dev, const u8 *bssid, 3612 const u8 *replay_ctr, gfp_t gfp); 3613 3614 /** 3615 * cfg80211_pmksa_candidate_notify - notify about PMKSA caching candidate 3616 * @dev: network device 3617 * @index: candidate index (the smaller the index, the higher the priority) 3618 * @bssid: BSSID of AP 3619 * @preauth: Whether AP advertises support for RSN pre-authentication 3620 * @gfp: allocation flags 3621 */ 3622 void cfg80211_pmksa_candidate_notify(struct net_device *dev, int index, 3623 const u8 *bssid, bool preauth, gfp_t gfp); 3624 3625 /** 3626 * cfg80211_rx_spurious_frame - inform userspace about a spurious frame 3627 * @dev: The device the frame matched to 3628 * @addr: the transmitter address 3629 * @gfp: context flags 3630 * 3631 * This function is used in AP mode (only!) to inform userspace that 3632 * a spurious class 3 frame was received, to be able to deauth the 3633 * sender. 3634 * Returns %true if the frame was passed to userspace (or this failed 3635 * for a reason other than not having a subscription.) 3636 */ 3637 bool cfg80211_rx_spurious_frame(struct net_device *dev, 3638 const u8 *addr, gfp_t gfp); 3639 3640 /** 3641 * cfg80211_rx_unexpected_4addr_frame - inform about unexpected WDS frame 3642 * @dev: The device the frame matched to 3643 * @addr: the transmitter address 3644 * @gfp: context flags 3645 * 3646 * This function is used in AP mode (only!) to inform userspace that 3647 * an associated station sent a 4addr frame but that wasn't expected. 3648 * It is allowed and desirable to send this event only once for each 3649 * station to avoid event flooding. 3650 * Returns %true if the frame was passed to userspace (or this failed 3651 * for a reason other than not having a subscription.) 3652 */ 3653 bool cfg80211_rx_unexpected_4addr_frame(struct net_device *dev, 3654 const u8 *addr, gfp_t gfp); 3655 3656 /** 3657 * cfg80211_probe_status - notify userspace about probe status 3658 * @dev: the device the probe was sent on 3659 * @addr: the address of the peer 3660 * @cookie: the cookie filled in @probe_client previously 3661 * @acked: indicates whether probe was acked or not 3662 * @gfp: allocation flags 3663 */ 3664 void cfg80211_probe_status(struct net_device *dev, const u8 *addr, 3665 u64 cookie, bool acked, gfp_t gfp); 3666 3667 /** 3668 * cfg80211_report_obss_beacon - report beacon from other APs 3669 * @wiphy: The wiphy that received the beacon 3670 * @frame: the frame 3671 * @len: length of the frame 3672 * @freq: frequency the frame was received on 3673 * @sig_dbm: signal strength in mBm, or 0 if unknown 3674 * 3675 * Use this function to report to userspace when a beacon was 3676 * received. It is not useful to call this when there is no 3677 * netdev that is in AP/GO mode. 3678 */ 3679 void cfg80211_report_obss_beacon(struct wiphy *wiphy, 3680 const u8 *frame, size_t len, 3681 int freq, int sig_dbm); 3682 3683 /** 3684 * cfg80211_reg_can_beacon - check if beaconing is allowed 3685 * @wiphy: the wiphy 3686 * @chandef: the channel definition 3687 * 3688 * This function returns true if there is no secondary channel or the secondary 3689 * channel(s) can be used for beaconing (i.e. is not a radar channel etc.) 3690 */ 3691 bool cfg80211_reg_can_beacon(struct wiphy *wiphy, 3692 struct cfg80211_chan_def *chandef); 3693 3694 /* 3695 * cfg80211_ch_switch_notify - update wdev channel and notify userspace 3696 * @dev: the device which switched channels 3697 * @chandef: the new channel definition 3698 * 3699 * Acquires wdev_lock, so must only be called from sleepable driver context! 3700 */ 3701 void cfg80211_ch_switch_notify(struct net_device *dev, 3702 struct cfg80211_chan_def *chandef); 3703 3704 /* 3705 * cfg80211_tdls_oper_request - request userspace to perform TDLS operation 3706 * @dev: the device on which the operation is requested 3707 * @peer: the MAC address of the peer device 3708 * @oper: the requested TDLS operation (NL80211_TDLS_SETUP or 3709 * NL80211_TDLS_TEARDOWN) 3710 * @reason_code: the reason code for teardown request 3711 * @gfp: allocation flags 3712 * 3713 * This function is used to request userspace to perform TDLS operation that 3714 * requires knowledge of keys, i.e., link setup or teardown when the AP 3715 * connection uses encryption. This is optional mechanism for the driver to use 3716 * if it can automatically determine when a TDLS link could be useful (e.g., 3717 * based on traffic and signal strength for a peer). 3718 */ 3719 void cfg80211_tdls_oper_request(struct net_device *dev, const u8 *peer, 3720 enum nl80211_tdls_operation oper, 3721 u16 reason_code, gfp_t gfp); 3722 3723 /* 3724 * cfg80211_calculate_bitrate - calculate actual bitrate (in 100Kbps units) 3725 * @rate: given rate_info to calculate bitrate from 3726 * 3727 * return 0 if MCS index >= 32 3728 */ 3729 u32 cfg80211_calculate_bitrate(struct rate_info *rate); 3730 3731 /** 3732 * cfg80211_unregister_wdev - remove the given wdev 3733 * @wdev: struct wireless_dev to remove 3734 * 3735 * Call this function only for wdevs that have no netdev assigned, 3736 * e.g. P2P Devices. It removes the device from the list so that 3737 * it can no longer be used. It is necessary to call this function 3738 * even when cfg80211 requests the removal of the interface by 3739 * calling the del_virtual_intf() callback. The function must also 3740 * be called when the driver wishes to unregister the wdev, e.g. 3741 * when the device is unbound from the driver. 3742 * 3743 * Requires the RTNL to be held. 3744 */ 3745 void cfg80211_unregister_wdev(struct wireless_dev *wdev); 3746 3747 /** 3748 * cfg80211_get_p2p_attr - find and copy a P2P attribute from IE buffer 3749 * @ies: the input IE buffer 3750 * @len: the input length 3751 * @attr: the attribute ID to find 3752 * @buf: output buffer, can be %NULL if the data isn't needed, e.g. 3753 * if the function is only called to get the needed buffer size 3754 * @bufsize: size of the output buffer 3755 * 3756 * The function finds a given P2P attribute in the (vendor) IEs and 3757 * copies its contents to the given buffer. 3758 * 3759 * The return value is a negative error code (-%EILSEQ or -%ENOENT) if 3760 * the data is malformed or the attribute can't be found (respectively), 3761 * or the length of the found attribute (which can be zero). 3762 */ 3763 int cfg80211_get_p2p_attr(const u8 *ies, unsigned int len, 3764 enum ieee80211_p2p_attr_id attr, 3765 u8 *buf, unsigned int bufsize); 3766 3767 /* Logging, debugging and troubleshooting/diagnostic helpers. */ 3768 3769 /* wiphy_printk helpers, similar to dev_printk */ 3770 3771 #define wiphy_printk(level, wiphy, format, args...) \ 3772 dev_printk(level, &(wiphy)->dev, format, ##args) 3773 #define wiphy_emerg(wiphy, format, args...) \ 3774 dev_emerg(&(wiphy)->dev, format, ##args) 3775 #define wiphy_alert(wiphy, format, args...) \ 3776 dev_alert(&(wiphy)->dev, format, ##args) 3777 #define wiphy_crit(wiphy, format, args...) \ 3778 dev_crit(&(wiphy)->dev, format, ##args) 3779 #define wiphy_err(wiphy, format, args...) \ 3780 dev_err(&(wiphy)->dev, format, ##args) 3781 #define wiphy_warn(wiphy, format, args...) \ 3782 dev_warn(&(wiphy)->dev, format, ##args) 3783 #define wiphy_notice(wiphy, format, args...) \ 3784 dev_notice(&(wiphy)->dev, format, ##args) 3785 #define wiphy_info(wiphy, format, args...) \ 3786 dev_info(&(wiphy)->dev, format, ##args) 3787 3788 #define wiphy_debug(wiphy, format, args...) \ 3789 wiphy_printk(KERN_DEBUG, wiphy, format, ##args) 3790 3791 #define wiphy_dbg(wiphy, format, args...) \ 3792 dev_dbg(&(wiphy)->dev, format, ##args) 3793 3794 #if defined(VERBOSE_DEBUG) 3795 #define wiphy_vdbg wiphy_dbg 3796 #else 3797 #define wiphy_vdbg(wiphy, format, args...) \ 3798 ({ \ 3799 if (0) \ 3800 wiphy_printk(KERN_DEBUG, wiphy, format, ##args); \ 3801 0; \ 3802 }) 3803 #endif 3804 3805 /* 3806 * wiphy_WARN() acts like wiphy_printk(), but with the key difference 3807 * of using a WARN/WARN_ON to get the message out, including the 3808 * file/line information and a backtrace. 3809 */ 3810 #define wiphy_WARN(wiphy, format, args...) \ 3811 WARN(1, "wiphy: %s\n" format, wiphy_name(wiphy), ##args); 3812 3813 #endif /* __NET_CFG80211_H */ 3814