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