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 /* remove once we remove the wext stuff */ 24 #include <net/iw_handler.h> 25 #include <linux/wireless.h> 26 27 28 /* 29 * wireless hardware capability structures 30 */ 31 32 /** 33 * enum ieee80211_band - supported frequency bands 34 * 35 * The bands are assigned this way because the supported 36 * bitrates differ in these bands. 37 * 38 * @IEEE80211_BAND_2GHZ: 2.4GHz ISM band 39 * @IEEE80211_BAND_5GHZ: around 5GHz band (4.9-5.7) 40 */ 41 enum ieee80211_band { 42 IEEE80211_BAND_2GHZ = NL80211_BAND_2GHZ, 43 IEEE80211_BAND_5GHZ = NL80211_BAND_5GHZ, 44 45 /* keep last */ 46 IEEE80211_NUM_BANDS 47 }; 48 49 /** 50 * enum ieee80211_channel_flags - channel flags 51 * 52 * Channel flags set by the regulatory control code. 53 * 54 * @IEEE80211_CHAN_DISABLED: This channel is disabled. 55 * @IEEE80211_CHAN_PASSIVE_SCAN: Only passive scanning is permitted 56 * on this channel. 57 * @IEEE80211_CHAN_NO_IBSS: IBSS is not allowed on this channel. 58 * @IEEE80211_CHAN_RADAR: Radar detection is required on this channel. 59 * @IEEE80211_CHAN_NO_HT40PLUS: extension channel above this channel 60 * is not permitted. 61 * @IEEE80211_CHAN_NO_HT40MINUS: extension channel below this channel 62 * is not permitted. 63 */ 64 enum ieee80211_channel_flags { 65 IEEE80211_CHAN_DISABLED = 1<<0, 66 IEEE80211_CHAN_PASSIVE_SCAN = 1<<1, 67 IEEE80211_CHAN_NO_IBSS = 1<<2, 68 IEEE80211_CHAN_RADAR = 1<<3, 69 IEEE80211_CHAN_NO_HT40PLUS = 1<<4, 70 IEEE80211_CHAN_NO_HT40MINUS = 1<<5, 71 }; 72 73 #define IEEE80211_CHAN_NO_HT40 \ 74 (IEEE80211_CHAN_NO_HT40PLUS | IEEE80211_CHAN_NO_HT40MINUS) 75 76 /** 77 * struct ieee80211_channel - channel definition 78 * 79 * This structure describes a single channel for use 80 * with cfg80211. 81 * 82 * @center_freq: center frequency in MHz 83 * @hw_value: hardware-specific value for the channel 84 * @flags: channel flags from &enum ieee80211_channel_flags. 85 * @orig_flags: channel flags at registration time, used by regulatory 86 * code to support devices with additional restrictions 87 * @band: band this channel belongs to. 88 * @max_antenna_gain: maximum antenna gain in dBi 89 * @max_power: maximum transmission power (in dBm) 90 * @beacon_found: helper to regulatory code to indicate when a beacon 91 * has been found on this channel. Use regulatory_hint_found_beacon() 92 * to enable this, this is is useful only on 5 GHz band. 93 * @orig_mag: internal use 94 * @orig_mpwr: internal use 95 */ 96 struct ieee80211_channel { 97 enum ieee80211_band band; 98 u16 center_freq; 99 u16 hw_value; 100 u32 flags; 101 int max_antenna_gain; 102 int max_power; 103 bool beacon_found; 104 u32 orig_flags; 105 int orig_mag, orig_mpwr; 106 }; 107 108 /** 109 * enum ieee80211_rate_flags - rate flags 110 * 111 * Hardware/specification flags for rates. These are structured 112 * in a way that allows using the same bitrate structure for 113 * different bands/PHY modes. 114 * 115 * @IEEE80211_RATE_SHORT_PREAMBLE: Hardware can send with short 116 * preamble on this bitrate; only relevant in 2.4GHz band and 117 * with CCK rates. 118 * @IEEE80211_RATE_MANDATORY_A: This bitrate is a mandatory rate 119 * when used with 802.11a (on the 5 GHz band); filled by the 120 * core code when registering the wiphy. 121 * @IEEE80211_RATE_MANDATORY_B: This bitrate is a mandatory rate 122 * when used with 802.11b (on the 2.4 GHz band); filled by the 123 * core code when registering the wiphy. 124 * @IEEE80211_RATE_MANDATORY_G: This bitrate is a mandatory rate 125 * when used with 802.11g (on the 2.4 GHz band); filled by the 126 * core code when registering the wiphy. 127 * @IEEE80211_RATE_ERP_G: This is an ERP rate in 802.11g mode. 128 */ 129 enum ieee80211_rate_flags { 130 IEEE80211_RATE_SHORT_PREAMBLE = 1<<0, 131 IEEE80211_RATE_MANDATORY_A = 1<<1, 132 IEEE80211_RATE_MANDATORY_B = 1<<2, 133 IEEE80211_RATE_MANDATORY_G = 1<<3, 134 IEEE80211_RATE_ERP_G = 1<<4, 135 }; 136 137 /** 138 * struct ieee80211_rate - bitrate definition 139 * 140 * This structure describes a bitrate that an 802.11 PHY can 141 * operate with. The two values @hw_value and @hw_value_short 142 * are only for driver use when pointers to this structure are 143 * passed around. 144 * 145 * @flags: rate-specific flags 146 * @bitrate: bitrate in units of 100 Kbps 147 * @hw_value: driver/hardware value for this rate 148 * @hw_value_short: driver/hardware value for this rate when 149 * short preamble is used 150 */ 151 struct ieee80211_rate { 152 u32 flags; 153 u16 bitrate; 154 u16 hw_value, hw_value_short; 155 }; 156 157 /** 158 * struct ieee80211_sta_ht_cap - STA's HT capabilities 159 * 160 * This structure describes most essential parameters needed 161 * to describe 802.11n HT capabilities for an STA. 162 * 163 * @ht_supported: is HT supported by the STA 164 * @cap: HT capabilities map as described in 802.11n spec 165 * @ampdu_factor: Maximum A-MPDU length factor 166 * @ampdu_density: Minimum A-MPDU spacing 167 * @mcs: Supported MCS rates 168 */ 169 struct ieee80211_sta_ht_cap { 170 u16 cap; /* use IEEE80211_HT_CAP_ */ 171 bool ht_supported; 172 u8 ampdu_factor; 173 u8 ampdu_density; 174 struct ieee80211_mcs_info mcs; 175 }; 176 177 /** 178 * struct ieee80211_supported_band - frequency band definition 179 * 180 * This structure describes a frequency band a wiphy 181 * is able to operate in. 182 * 183 * @channels: Array of channels the hardware can operate in 184 * in this band. 185 * @band: the band this structure represents 186 * @n_channels: Number of channels in @channels 187 * @bitrates: Array of bitrates the hardware can operate with 188 * in this band. Must be sorted to give a valid "supported 189 * rates" IE, i.e. CCK rates first, then OFDM. 190 * @n_bitrates: Number of bitrates in @bitrates 191 */ 192 struct ieee80211_supported_band { 193 struct ieee80211_channel *channels; 194 struct ieee80211_rate *bitrates; 195 enum ieee80211_band band; 196 int n_channels; 197 int n_bitrates; 198 struct ieee80211_sta_ht_cap ht_cap; 199 }; 200 201 /* 202 * Wireless hardware/device configuration structures and methods 203 */ 204 205 /** 206 * struct vif_params - describes virtual interface parameters 207 * @mesh_id: mesh ID to use 208 * @mesh_id_len: length of the mesh ID 209 * @use_4addr: use 4-address frames 210 */ 211 struct vif_params { 212 u8 *mesh_id; 213 int mesh_id_len; 214 int use_4addr; 215 }; 216 217 /** 218 * struct key_params - key information 219 * 220 * Information about a key 221 * 222 * @key: key material 223 * @key_len: length of key material 224 * @cipher: cipher suite selector 225 * @seq: sequence counter (IV/PN) for TKIP and CCMP keys, only used 226 * with the get_key() callback, must be in little endian, 227 * length given by @seq_len. 228 */ 229 struct key_params { 230 u8 *key; 231 u8 *seq; 232 int key_len; 233 int seq_len; 234 u32 cipher; 235 }; 236 237 /** 238 * enum survey_info_flags - survey information flags 239 * 240 * Used by the driver to indicate which info in &struct survey_info 241 * it has filled in during the get_survey(). 242 */ 243 enum survey_info_flags { 244 SURVEY_INFO_NOISE_DBM = 1<<0, 245 }; 246 247 /** 248 * struct survey_info - channel survey response 249 * 250 * Used by dump_survey() to report back per-channel survey information. 251 * 252 * @channel: the channel this survey record reports, mandatory 253 * @filled: bitflag of flags from &enum survey_info_flags 254 * @noise: channel noise in dBm. This and all following fields are 255 * optional 256 * 257 * This structure can later be expanded with things like 258 * channel duty cycle etc. 259 */ 260 struct survey_info { 261 struct ieee80211_channel *channel; 262 u32 filled; 263 s8 noise; 264 }; 265 266 /** 267 * struct beacon_parameters - beacon parameters 268 * 269 * Used to configure the beacon for an interface. 270 * 271 * @head: head portion of beacon (before TIM IE) 272 * or %NULL if not changed 273 * @tail: tail portion of beacon (after TIM IE) 274 * or %NULL if not changed 275 * @interval: beacon interval or zero if not changed 276 * @dtim_period: DTIM period or zero if not changed 277 * @head_len: length of @head 278 * @tail_len: length of @tail 279 */ 280 struct beacon_parameters { 281 u8 *head, *tail; 282 int interval, dtim_period; 283 int head_len, tail_len; 284 }; 285 286 /** 287 * enum plink_action - actions to perform in mesh peers 288 * 289 * @PLINK_ACTION_INVALID: action 0 is reserved 290 * @PLINK_ACTION_OPEN: start mesh peer link establishment 291 * @PLINK_ACTION_BLOCL: block traffic from this mesh peer 292 */ 293 enum plink_actions { 294 PLINK_ACTION_INVALID, 295 PLINK_ACTION_OPEN, 296 PLINK_ACTION_BLOCK, 297 }; 298 299 /** 300 * struct station_parameters - station parameters 301 * 302 * Used to change and create a new station. 303 * 304 * @vlan: vlan interface station should belong to 305 * @supported_rates: supported rates in IEEE 802.11 format 306 * (or NULL for no change) 307 * @supported_rates_len: number of supported rates 308 * @sta_flags_mask: station flags that changed 309 * (bitmask of BIT(NL80211_STA_FLAG_...)) 310 * @sta_flags_set: station flags values 311 * (bitmask of BIT(NL80211_STA_FLAG_...)) 312 * @listen_interval: listen interval or -1 for no change 313 * @aid: AID or zero for no change 314 */ 315 struct station_parameters { 316 u8 *supported_rates; 317 struct net_device *vlan; 318 u32 sta_flags_mask, sta_flags_set; 319 int listen_interval; 320 u16 aid; 321 u8 supported_rates_len; 322 u8 plink_action; 323 struct ieee80211_ht_cap *ht_capa; 324 }; 325 326 /** 327 * enum station_info_flags - station information flags 328 * 329 * Used by the driver to indicate which info in &struct station_info 330 * it has filled in during get_station() or dump_station(). 331 * 332 * @STATION_INFO_INACTIVE_TIME: @inactive_time filled 333 * @STATION_INFO_RX_BYTES: @rx_bytes filled 334 * @STATION_INFO_TX_BYTES: @tx_bytes filled 335 * @STATION_INFO_LLID: @llid filled 336 * @STATION_INFO_PLID: @plid filled 337 * @STATION_INFO_PLINK_STATE: @plink_state filled 338 * @STATION_INFO_SIGNAL: @signal filled 339 * @STATION_INFO_TX_BITRATE: @tx_bitrate fields are filled 340 * (tx_bitrate, tx_bitrate_flags and tx_bitrate_mcs) 341 * @STATION_INFO_RX_PACKETS: @rx_packets filled 342 * @STATION_INFO_TX_PACKETS: @tx_packets filled 343 */ 344 enum station_info_flags { 345 STATION_INFO_INACTIVE_TIME = 1<<0, 346 STATION_INFO_RX_BYTES = 1<<1, 347 STATION_INFO_TX_BYTES = 1<<2, 348 STATION_INFO_LLID = 1<<3, 349 STATION_INFO_PLID = 1<<4, 350 STATION_INFO_PLINK_STATE = 1<<5, 351 STATION_INFO_SIGNAL = 1<<6, 352 STATION_INFO_TX_BITRATE = 1<<7, 353 STATION_INFO_RX_PACKETS = 1<<8, 354 STATION_INFO_TX_PACKETS = 1<<9, 355 }; 356 357 /** 358 * enum station_info_rate_flags - bitrate info flags 359 * 360 * Used by the driver to indicate the specific rate transmission 361 * type for 802.11n transmissions. 362 * 363 * @RATE_INFO_FLAGS_MCS: @tx_bitrate_mcs filled 364 * @RATE_INFO_FLAGS_40_MHZ_WIDTH: 40 Mhz width transmission 365 * @RATE_INFO_FLAGS_SHORT_GI: 400ns guard interval 366 */ 367 enum rate_info_flags { 368 RATE_INFO_FLAGS_MCS = 1<<0, 369 RATE_INFO_FLAGS_40_MHZ_WIDTH = 1<<1, 370 RATE_INFO_FLAGS_SHORT_GI = 1<<2, 371 }; 372 373 /** 374 * struct rate_info - bitrate information 375 * 376 * Information about a receiving or transmitting bitrate 377 * 378 * @flags: bitflag of flags from &enum rate_info_flags 379 * @mcs: mcs index if struct describes a 802.11n bitrate 380 * @legacy: bitrate in 100kbit/s for 802.11abg 381 */ 382 struct rate_info { 383 u8 flags; 384 u8 mcs; 385 u16 legacy; 386 }; 387 388 /** 389 * struct station_info - station information 390 * 391 * Station information filled by driver for get_station() and dump_station. 392 * 393 * @filled: bitflag of flags from &enum station_info_flags 394 * @inactive_time: time since last station activity (tx/rx) in milliseconds 395 * @rx_bytes: bytes received from this station 396 * @tx_bytes: bytes transmitted to this station 397 * @llid: mesh local link id 398 * @plid: mesh peer link id 399 * @plink_state: mesh peer link state 400 * @signal: signal strength of last received packet in dBm 401 * @txrate: current unicast bitrate to this station 402 * @rx_packets: packets received from this station 403 * @tx_packets: packets transmitted to this station 404 * @generation: generation number for nl80211 dumps. 405 * This number should increase every time the list of stations 406 * changes, i.e. when a station is added or removed, so that 407 * userspace can tell whether it got a consistent snapshot. 408 */ 409 struct station_info { 410 u32 filled; 411 u32 inactive_time; 412 u32 rx_bytes; 413 u32 tx_bytes; 414 u16 llid; 415 u16 plid; 416 u8 plink_state; 417 s8 signal; 418 struct rate_info txrate; 419 u32 rx_packets; 420 u32 tx_packets; 421 422 int generation; 423 }; 424 425 /** 426 * enum monitor_flags - monitor flags 427 * 428 * Monitor interface configuration flags. Note that these must be the bits 429 * according to the nl80211 flags. 430 * 431 * @MONITOR_FLAG_FCSFAIL: pass frames with bad FCS 432 * @MONITOR_FLAG_PLCPFAIL: pass frames with bad PLCP 433 * @MONITOR_FLAG_CONTROL: pass control frames 434 * @MONITOR_FLAG_OTHER_BSS: disable BSSID filtering 435 * @MONITOR_FLAG_COOK_FRAMES: report frames after processing 436 */ 437 enum monitor_flags { 438 MONITOR_FLAG_FCSFAIL = 1<<NL80211_MNTR_FLAG_FCSFAIL, 439 MONITOR_FLAG_PLCPFAIL = 1<<NL80211_MNTR_FLAG_PLCPFAIL, 440 MONITOR_FLAG_CONTROL = 1<<NL80211_MNTR_FLAG_CONTROL, 441 MONITOR_FLAG_OTHER_BSS = 1<<NL80211_MNTR_FLAG_OTHER_BSS, 442 MONITOR_FLAG_COOK_FRAMES = 1<<NL80211_MNTR_FLAG_COOK_FRAMES, 443 }; 444 445 /** 446 * enum mpath_info_flags - mesh path information flags 447 * 448 * Used by the driver to indicate which info in &struct mpath_info it has filled 449 * in during get_station() or dump_station(). 450 * 451 * MPATH_INFO_FRAME_QLEN: @frame_qlen filled 452 * MPATH_INFO_SN: @sn filled 453 * MPATH_INFO_METRIC: @metric filled 454 * MPATH_INFO_EXPTIME: @exptime filled 455 * MPATH_INFO_DISCOVERY_TIMEOUT: @discovery_timeout filled 456 * MPATH_INFO_DISCOVERY_RETRIES: @discovery_retries filled 457 * MPATH_INFO_FLAGS: @flags filled 458 */ 459 enum mpath_info_flags { 460 MPATH_INFO_FRAME_QLEN = BIT(0), 461 MPATH_INFO_SN = BIT(1), 462 MPATH_INFO_METRIC = BIT(2), 463 MPATH_INFO_EXPTIME = BIT(3), 464 MPATH_INFO_DISCOVERY_TIMEOUT = BIT(4), 465 MPATH_INFO_DISCOVERY_RETRIES = BIT(5), 466 MPATH_INFO_FLAGS = BIT(6), 467 }; 468 469 /** 470 * struct mpath_info - mesh path information 471 * 472 * Mesh path information filled by driver for get_mpath() and dump_mpath(). 473 * 474 * @filled: bitfield of flags from &enum mpath_info_flags 475 * @frame_qlen: number of queued frames for this destination 476 * @sn: target sequence number 477 * @metric: metric (cost) of this mesh path 478 * @exptime: expiration time for the mesh path from now, in msecs 479 * @flags: mesh path flags 480 * @discovery_timeout: total mesh path discovery timeout, in msecs 481 * @discovery_retries: mesh path discovery retries 482 * @generation: generation number for nl80211 dumps. 483 * This number should increase every time the list of mesh paths 484 * changes, i.e. when a station is added or removed, so that 485 * userspace can tell whether it got a consistent snapshot. 486 */ 487 struct mpath_info { 488 u32 filled; 489 u32 frame_qlen; 490 u32 sn; 491 u32 metric; 492 u32 exptime; 493 u32 discovery_timeout; 494 u8 discovery_retries; 495 u8 flags; 496 497 int generation; 498 }; 499 500 /** 501 * struct bss_parameters - BSS parameters 502 * 503 * Used to change BSS parameters (mainly for AP mode). 504 * 505 * @use_cts_prot: Whether to use CTS protection 506 * (0 = no, 1 = yes, -1 = do not change) 507 * @use_short_preamble: Whether the use of short preambles is allowed 508 * (0 = no, 1 = yes, -1 = do not change) 509 * @use_short_slot_time: Whether the use of short slot time is allowed 510 * (0 = no, 1 = yes, -1 = do not change) 511 * @basic_rates: basic rates in IEEE 802.11 format 512 * (or NULL for no change) 513 * @basic_rates_len: number of basic rates 514 * @ap_isolate: do not forward packets between connected stations 515 */ 516 struct bss_parameters { 517 int use_cts_prot; 518 int use_short_preamble; 519 int use_short_slot_time; 520 u8 *basic_rates; 521 u8 basic_rates_len; 522 int ap_isolate; 523 }; 524 525 struct mesh_config { 526 /* Timeouts in ms */ 527 /* Mesh plink management parameters */ 528 u16 dot11MeshRetryTimeout; 529 u16 dot11MeshConfirmTimeout; 530 u16 dot11MeshHoldingTimeout; 531 u16 dot11MeshMaxPeerLinks; 532 u8 dot11MeshMaxRetries; 533 u8 dot11MeshTTL; 534 bool auto_open_plinks; 535 /* HWMP parameters */ 536 u8 dot11MeshHWMPmaxPREQretries; 537 u32 path_refresh_time; 538 u16 min_discovery_timeout; 539 u32 dot11MeshHWMPactivePathTimeout; 540 u16 dot11MeshHWMPpreqMinInterval; 541 u16 dot11MeshHWMPnetDiameterTraversalTime; 542 u8 dot11MeshHWMPRootMode; 543 }; 544 545 /** 546 * struct ieee80211_txq_params - TX queue parameters 547 * @queue: TX queue identifier (NL80211_TXQ_Q_*) 548 * @txop: Maximum burst time in units of 32 usecs, 0 meaning disabled 549 * @cwmin: Minimum contention window [a value of the form 2^n-1 in the range 550 * 1..32767] 551 * @cwmax: Maximum contention window [a value of the form 2^n-1 in the range 552 * 1..32767] 553 * @aifs: Arbitration interframe space [0..255] 554 */ 555 struct ieee80211_txq_params { 556 enum nl80211_txq_q queue; 557 u16 txop; 558 u16 cwmin; 559 u16 cwmax; 560 u8 aifs; 561 }; 562 563 /* from net/wireless.h */ 564 struct wiphy; 565 566 /* from net/ieee80211.h */ 567 struct ieee80211_channel; 568 569 /** 570 * struct cfg80211_ssid - SSID description 571 * @ssid: the SSID 572 * @ssid_len: length of the ssid 573 */ 574 struct cfg80211_ssid { 575 u8 ssid[IEEE80211_MAX_SSID_LEN]; 576 u8 ssid_len; 577 }; 578 579 /** 580 * struct cfg80211_scan_request - scan request description 581 * 582 * @ssids: SSIDs to scan for (active scan only) 583 * @n_ssids: number of SSIDs 584 * @channels: channels to scan on. 585 * @n_channels: total number of channels to scan 586 * @ie: optional information element(s) to add into Probe Request or %NULL 587 * @ie_len: length of ie in octets 588 * @wiphy: the wiphy this was for 589 * @dev: the interface 590 */ 591 struct cfg80211_scan_request { 592 struct cfg80211_ssid *ssids; 593 int n_ssids; 594 u32 n_channels; 595 const u8 *ie; 596 size_t ie_len; 597 598 /* internal */ 599 struct wiphy *wiphy; 600 struct net_device *dev; 601 bool aborted; 602 603 /* keep last */ 604 struct ieee80211_channel *channels[0]; 605 }; 606 607 /** 608 * enum cfg80211_signal_type - signal type 609 * 610 * @CFG80211_SIGNAL_TYPE_NONE: no signal strength information available 611 * @CFG80211_SIGNAL_TYPE_MBM: signal strength in mBm (100*dBm) 612 * @CFG80211_SIGNAL_TYPE_UNSPEC: signal strength, increasing from 0 through 100 613 */ 614 enum cfg80211_signal_type { 615 CFG80211_SIGNAL_TYPE_NONE, 616 CFG80211_SIGNAL_TYPE_MBM, 617 CFG80211_SIGNAL_TYPE_UNSPEC, 618 }; 619 620 /** 621 * struct cfg80211_bss - BSS description 622 * 623 * This structure describes a BSS (which may also be a mesh network) 624 * for use in scan results and similar. 625 * 626 * @bssid: BSSID of the BSS 627 * @tsf: timestamp of last received update 628 * @beacon_interval: the beacon interval as from the frame 629 * @capability: the capability field in host byte order 630 * @information_elements: the information elements (Note that there 631 * is no guarantee that these are well-formed!); this is a pointer to 632 * either the beacon_ies or proberesp_ies depending on whether Probe 633 * Response frame has been received 634 * @len_information_elements: total length of the information elements 635 * @beacon_ies: the information elements from the last Beacon frame 636 * @len_beacon_ies: total length of the beacon_ies 637 * @proberesp_ies: the information elements from the last Probe Response frame 638 * @len_proberesp_ies: total length of the proberesp_ies 639 * @signal: signal strength value (type depends on the wiphy's signal_type) 640 * @free_priv: function pointer to free private data 641 * @priv: private area for driver use, has at least wiphy->bss_priv_size bytes 642 */ 643 struct cfg80211_bss { 644 struct ieee80211_channel *channel; 645 646 u8 bssid[ETH_ALEN]; 647 u64 tsf; 648 u16 beacon_interval; 649 u16 capability; 650 u8 *information_elements; 651 size_t len_information_elements; 652 u8 *beacon_ies; 653 size_t len_beacon_ies; 654 u8 *proberesp_ies; 655 size_t len_proberesp_ies; 656 657 s32 signal; 658 659 void (*free_priv)(struct cfg80211_bss *bss); 660 u8 priv[0] __attribute__((__aligned__(sizeof(void *)))); 661 }; 662 663 /** 664 * ieee80211_bss_get_ie - find IE with given ID 665 * @bss: the bss to search 666 * @ie: the IE ID 667 * Returns %NULL if not found. 668 */ 669 const u8 *ieee80211_bss_get_ie(struct cfg80211_bss *bss, u8 ie); 670 671 672 /** 673 * struct cfg80211_crypto_settings - Crypto settings 674 * @wpa_versions: indicates which, if any, WPA versions are enabled 675 * (from enum nl80211_wpa_versions) 676 * @cipher_group: group key cipher suite (or 0 if unset) 677 * @n_ciphers_pairwise: number of AP supported unicast ciphers 678 * @ciphers_pairwise: unicast key cipher suites 679 * @n_akm_suites: number of AKM suites 680 * @akm_suites: AKM suites 681 * @control_port: Whether user space controls IEEE 802.1X port, i.e., 682 * sets/clears %NL80211_STA_FLAG_AUTHORIZED. If true, the driver is 683 * required to assume that the port is unauthorized until authorized by 684 * user space. Otherwise, port is marked authorized by default. 685 */ 686 struct cfg80211_crypto_settings { 687 u32 wpa_versions; 688 u32 cipher_group; 689 int n_ciphers_pairwise; 690 u32 ciphers_pairwise[NL80211_MAX_NR_CIPHER_SUITES]; 691 int n_akm_suites; 692 u32 akm_suites[NL80211_MAX_NR_AKM_SUITES]; 693 bool control_port; 694 }; 695 696 /** 697 * struct cfg80211_auth_request - Authentication request data 698 * 699 * This structure provides information needed to complete IEEE 802.11 700 * authentication. 701 * 702 * @bss: The BSS to authenticate with. 703 * @auth_type: Authentication type (algorithm) 704 * @ie: Extra IEs to add to Authentication frame or %NULL 705 * @ie_len: Length of ie buffer in octets 706 * @key_len: length of WEP key for shared key authentication 707 * @key_idx: index of WEP key for shared key authentication 708 * @key: WEP key for shared key authentication 709 * @local_state_change: This is a request for a local state only, i.e., no 710 * Authentication frame is to be transmitted and authentication state is 711 * to be changed without having to wait for a response from the peer STA 712 * (AP). 713 */ 714 struct cfg80211_auth_request { 715 struct cfg80211_bss *bss; 716 const u8 *ie; 717 size_t ie_len; 718 enum nl80211_auth_type auth_type; 719 const u8 *key; 720 u8 key_len, key_idx; 721 bool local_state_change; 722 }; 723 724 /** 725 * struct cfg80211_assoc_request - (Re)Association request data 726 * 727 * This structure provides information needed to complete IEEE 802.11 728 * (re)association. 729 * @bss: The BSS to associate with. 730 * @ie: Extra IEs to add to (Re)Association Request frame or %NULL 731 * @ie_len: Length of ie buffer in octets 732 * @use_mfp: Use management frame protection (IEEE 802.11w) in this association 733 * @crypto: crypto settings 734 * @prev_bssid: previous BSSID, if not %NULL use reassociate frame 735 */ 736 struct cfg80211_assoc_request { 737 struct cfg80211_bss *bss; 738 const u8 *ie, *prev_bssid; 739 size_t ie_len; 740 struct cfg80211_crypto_settings crypto; 741 bool use_mfp; 742 }; 743 744 /** 745 * struct cfg80211_deauth_request - Deauthentication request data 746 * 747 * This structure provides information needed to complete IEEE 802.11 748 * deauthentication. 749 * 750 * @bss: the BSS to deauthenticate from 751 * @ie: Extra IEs to add to Deauthentication frame or %NULL 752 * @ie_len: Length of ie buffer in octets 753 * @reason_code: The reason code for the deauthentication 754 * @local_state_change: This is a request for a local state only, i.e., no 755 * Deauthentication frame is to be transmitted. 756 */ 757 struct cfg80211_deauth_request { 758 struct cfg80211_bss *bss; 759 const u8 *ie; 760 size_t ie_len; 761 u16 reason_code; 762 bool local_state_change; 763 }; 764 765 /** 766 * struct cfg80211_disassoc_request - Disassociation request data 767 * 768 * This structure provides information needed to complete IEEE 802.11 769 * disassocation. 770 * 771 * @bss: the BSS to disassociate from 772 * @ie: Extra IEs to add to Disassociation frame or %NULL 773 * @ie_len: Length of ie buffer in octets 774 * @reason_code: The reason code for the disassociation 775 * @local_state_change: This is a request for a local state only, i.e., no 776 * Disassociation frame is to be transmitted. 777 */ 778 struct cfg80211_disassoc_request { 779 struct cfg80211_bss *bss; 780 const u8 *ie; 781 size_t ie_len; 782 u16 reason_code; 783 bool local_state_change; 784 }; 785 786 /** 787 * struct cfg80211_ibss_params - IBSS parameters 788 * 789 * This structure defines the IBSS parameters for the join_ibss() 790 * method. 791 * 792 * @ssid: The SSID, will always be non-null. 793 * @ssid_len: The length of the SSID, will always be non-zero. 794 * @bssid: Fixed BSSID requested, maybe be %NULL, if set do not 795 * search for IBSSs with a different BSSID. 796 * @channel: The channel to use if no IBSS can be found to join. 797 * @channel_fixed: The channel should be fixed -- do not search for 798 * IBSSs to join on other channels. 799 * @ie: information element(s) to include in the beacon 800 * @ie_len: length of that 801 * @beacon_interval: beacon interval to use 802 * @privacy: this is a protected network, keys will be configured 803 * after joining 804 */ 805 struct cfg80211_ibss_params { 806 u8 *ssid; 807 u8 *bssid; 808 struct ieee80211_channel *channel; 809 u8 *ie; 810 u8 ssid_len, ie_len; 811 u16 beacon_interval; 812 bool channel_fixed; 813 bool privacy; 814 }; 815 816 /** 817 * struct cfg80211_connect_params - Connection parameters 818 * 819 * This structure provides information needed to complete IEEE 802.11 820 * authentication and association. 821 * 822 * @channel: The channel to use or %NULL if not specified (auto-select based 823 * on scan results) 824 * @bssid: The AP BSSID or %NULL if not specified (auto-select based on scan 825 * results) 826 * @ssid: SSID 827 * @ssid_len: Length of ssid in octets 828 * @auth_type: Authentication type (algorithm) 829 * @assoc_ie: IEs for association request 830 * @assoc_ie_len: Length of assoc_ie in octets 831 * @privacy: indicates whether privacy-enabled APs should be used 832 * @crypto: crypto settings 833 * @key_len: length of WEP key for shared key authentication 834 * @key_idx: index of WEP key for shared key authentication 835 * @key: WEP key for shared key authentication 836 */ 837 struct cfg80211_connect_params { 838 struct ieee80211_channel *channel; 839 u8 *bssid; 840 u8 *ssid; 841 size_t ssid_len; 842 enum nl80211_auth_type auth_type; 843 u8 *ie; 844 size_t ie_len; 845 bool privacy; 846 struct cfg80211_crypto_settings crypto; 847 const u8 *key; 848 u8 key_len, key_idx; 849 }; 850 851 /** 852 * enum wiphy_params_flags - set_wiphy_params bitfield values 853 * WIPHY_PARAM_RETRY_SHORT: wiphy->retry_short has changed 854 * WIPHY_PARAM_RETRY_LONG: wiphy->retry_long has changed 855 * WIPHY_PARAM_FRAG_THRESHOLD: wiphy->frag_threshold has changed 856 * WIPHY_PARAM_RTS_THRESHOLD: wiphy->rts_threshold has changed 857 */ 858 enum wiphy_params_flags { 859 WIPHY_PARAM_RETRY_SHORT = 1 << 0, 860 WIPHY_PARAM_RETRY_LONG = 1 << 1, 861 WIPHY_PARAM_FRAG_THRESHOLD = 1 << 2, 862 WIPHY_PARAM_RTS_THRESHOLD = 1 << 3, 863 WIPHY_PARAM_COVERAGE_CLASS = 1 << 4, 864 }; 865 866 /** 867 * enum tx_power_setting - TX power adjustment 868 * 869 * @TX_POWER_AUTOMATIC: the dbm parameter is ignored 870 * @TX_POWER_LIMITED: limit TX power by the dbm parameter 871 * @TX_POWER_FIXED: fix TX power to the dbm parameter 872 */ 873 enum tx_power_setting { 874 TX_POWER_AUTOMATIC, 875 TX_POWER_LIMITED, 876 TX_POWER_FIXED, 877 }; 878 879 /* 880 * cfg80211_bitrate_mask - masks for bitrate control 881 */ 882 struct cfg80211_bitrate_mask { 883 struct { 884 u32 legacy; 885 /* TODO: add support for masking MCS rates; e.g.: */ 886 /* u8 mcs[IEEE80211_HT_MCS_MASK_LEN]; */ 887 } control[IEEE80211_NUM_BANDS]; 888 }; 889 /** 890 * struct cfg80211_pmksa - PMK Security Association 891 * 892 * This structure is passed to the set/del_pmksa() method for PMKSA 893 * caching. 894 * 895 * @bssid: The AP's BSSID. 896 * @pmkid: The PMK material itself. 897 */ 898 struct cfg80211_pmksa { 899 u8 *bssid; 900 u8 *pmkid; 901 }; 902 903 /** 904 * struct cfg80211_ops - backend description for wireless configuration 905 * 906 * This struct is registered by fullmac card drivers and/or wireless stacks 907 * in order to handle configuration requests on their interfaces. 908 * 909 * All callbacks except where otherwise noted should return 0 910 * on success or a negative error code. 911 * 912 * All operations are currently invoked under rtnl for consistency with the 913 * wireless extensions but this is subject to reevaluation as soon as this 914 * code is used more widely and we have a first user without wext. 915 * 916 * @suspend: wiphy device needs to be suspended 917 * @resume: wiphy device needs to be resumed 918 * 919 * @add_virtual_intf: create a new virtual interface with the given name, 920 * must set the struct wireless_dev's iftype. Beware: You must create 921 * the new netdev in the wiphy's network namespace! 922 * 923 * @del_virtual_intf: remove the virtual interface determined by ifindex. 924 * 925 * @change_virtual_intf: change type/configuration of virtual interface, 926 * keep the struct wireless_dev's iftype updated. 927 * 928 * @add_key: add a key with the given parameters. @mac_addr will be %NULL 929 * when adding a group key. 930 * 931 * @get_key: get information about the key with the given parameters. 932 * @mac_addr will be %NULL when requesting information for a group 933 * key. All pointers given to the @callback function need not be valid 934 * after it returns. This function should return an error if it is 935 * not possible to retrieve the key, -ENOENT if it doesn't exist. 936 * 937 * @del_key: remove a key given the @mac_addr (%NULL for a group key) 938 * and @key_index, return -ENOENT if the key doesn't exist. 939 * 940 * @set_default_key: set the default key on an interface 941 * 942 * @set_default_mgmt_key: set the default management frame key on an interface 943 * 944 * @add_beacon: Add a beacon with given parameters, @head, @interval 945 * and @dtim_period will be valid, @tail is optional. 946 * @set_beacon: Change the beacon parameters for an access point mode 947 * interface. This should reject the call when no beacon has been 948 * configured. 949 * @del_beacon: Remove beacon configuration and stop sending the beacon. 950 * 951 * @add_station: Add a new station. 952 * 953 * @del_station: Remove a station; @mac may be NULL to remove all stations. 954 * 955 * @change_station: Modify a given station. 956 * 957 * @get_mesh_params: Put the current mesh parameters into *params 958 * 959 * @set_mesh_params: Set mesh parameters. 960 * The mask is a bitfield which tells us which parameters to 961 * set, and which to leave alone. 962 * 963 * @set_mesh_cfg: set mesh parameters (by now, just mesh id) 964 * 965 * @change_bss: Modify parameters for a given BSS. 966 * 967 * @set_txq_params: Set TX queue parameters 968 * 969 * @set_channel: Set channel for a given wireless interface. Some devices 970 * may support multi-channel operation (by channel hopping) so cfg80211 971 * doesn't verify much. Note, however, that the passed netdev may be 972 * %NULL as well if the user requested changing the channel for the 973 * device itself, or for a monitor interface. 974 * 975 * @scan: Request to do a scan. If returning zero, the scan request is given 976 * the driver, and will be valid until passed to cfg80211_scan_done(). 977 * For scan results, call cfg80211_inform_bss(); you can call this outside 978 * the scan/scan_done bracket too. 979 * 980 * @auth: Request to authenticate with the specified peer 981 * @assoc: Request to (re)associate with the specified peer 982 * @deauth: Request to deauthenticate from the specified peer 983 * @disassoc: Request to disassociate from the specified peer 984 * 985 * @connect: Connect to the ESS with the specified parameters. When connected, 986 * call cfg80211_connect_result() with status code %WLAN_STATUS_SUCCESS. 987 * If the connection fails for some reason, call cfg80211_connect_result() 988 * with the status from the AP. 989 * @disconnect: Disconnect from the BSS/ESS. 990 * 991 * @join_ibss: Join the specified IBSS (or create if necessary). Once done, call 992 * cfg80211_ibss_joined(), also call that function when changing BSSID due 993 * to a merge. 994 * @leave_ibss: Leave the IBSS. 995 * 996 * @set_wiphy_params: Notify that wiphy parameters have changed; 997 * @changed bitfield (see &enum wiphy_params_flags) describes which values 998 * have changed. The actual parameter values are available in 999 * struct wiphy. If returning an error, no value should be changed. 1000 * 1001 * @set_tx_power: set the transmit power according to the parameters 1002 * @get_tx_power: store the current TX power into the dbm variable; 1003 * return 0 if successful 1004 * 1005 * @rfkill_poll: polls the hw rfkill line, use cfg80211 reporting 1006 * functions to adjust rfkill hw state 1007 * 1008 * @dump_survey: get site survey information. 1009 * 1010 * @remain_on_channel: Request the driver to remain awake on the specified 1011 * channel for the specified duration to complete an off-channel 1012 * operation (e.g., public action frame exchange). When the driver is 1013 * ready on the requested channel, it must indicate this with an event 1014 * notification by calling cfg80211_ready_on_channel(). 1015 * @cancel_remain_on_channel: Cancel an on-going remain-on-channel operation. 1016 * This allows the operation to be terminated prior to timeout based on 1017 * the duration value. 1018 * @action: Transmit an action frame 1019 * 1020 * @testmode_cmd: run a test mode command 1021 * 1022 * @set_pmksa: Cache a PMKID for a BSSID. This is mostly useful for fullmac 1023 * devices running firmwares capable of generating the (re) association 1024 * RSN IE. It allows for faster roaming between WPA2 BSSIDs. 1025 * @del_pmksa: Delete a cached PMKID. 1026 * @flush_pmksa: Flush all cached PMKIDs. 1027 * @set_power_mgmt: Configure WLAN power management. A timeout value of -1 1028 * allows the driver to adjust the dynamic ps timeout value. 1029 * @set_cqm_rssi_config: Configure connection quality monitor RSSI threshold. 1030 * 1031 */ 1032 struct cfg80211_ops { 1033 int (*suspend)(struct wiphy *wiphy); 1034 int (*resume)(struct wiphy *wiphy); 1035 1036 int (*add_virtual_intf)(struct wiphy *wiphy, char *name, 1037 enum nl80211_iftype type, u32 *flags, 1038 struct vif_params *params); 1039 int (*del_virtual_intf)(struct wiphy *wiphy, struct net_device *dev); 1040 int (*change_virtual_intf)(struct wiphy *wiphy, 1041 struct net_device *dev, 1042 enum nl80211_iftype type, u32 *flags, 1043 struct vif_params *params); 1044 1045 int (*add_key)(struct wiphy *wiphy, struct net_device *netdev, 1046 u8 key_index, const u8 *mac_addr, 1047 struct key_params *params); 1048 int (*get_key)(struct wiphy *wiphy, struct net_device *netdev, 1049 u8 key_index, const u8 *mac_addr, void *cookie, 1050 void (*callback)(void *cookie, struct key_params*)); 1051 int (*del_key)(struct wiphy *wiphy, struct net_device *netdev, 1052 u8 key_index, const u8 *mac_addr); 1053 int (*set_default_key)(struct wiphy *wiphy, 1054 struct net_device *netdev, 1055 u8 key_index); 1056 int (*set_default_mgmt_key)(struct wiphy *wiphy, 1057 struct net_device *netdev, 1058 u8 key_index); 1059 1060 int (*add_beacon)(struct wiphy *wiphy, struct net_device *dev, 1061 struct beacon_parameters *info); 1062 int (*set_beacon)(struct wiphy *wiphy, struct net_device *dev, 1063 struct beacon_parameters *info); 1064 int (*del_beacon)(struct wiphy *wiphy, struct net_device *dev); 1065 1066 1067 int (*add_station)(struct wiphy *wiphy, struct net_device *dev, 1068 u8 *mac, struct station_parameters *params); 1069 int (*del_station)(struct wiphy *wiphy, struct net_device *dev, 1070 u8 *mac); 1071 int (*change_station)(struct wiphy *wiphy, struct net_device *dev, 1072 u8 *mac, struct station_parameters *params); 1073 int (*get_station)(struct wiphy *wiphy, struct net_device *dev, 1074 u8 *mac, struct station_info *sinfo); 1075 int (*dump_station)(struct wiphy *wiphy, struct net_device *dev, 1076 int idx, u8 *mac, struct station_info *sinfo); 1077 1078 int (*add_mpath)(struct wiphy *wiphy, struct net_device *dev, 1079 u8 *dst, u8 *next_hop); 1080 int (*del_mpath)(struct wiphy *wiphy, struct net_device *dev, 1081 u8 *dst); 1082 int (*change_mpath)(struct wiphy *wiphy, struct net_device *dev, 1083 u8 *dst, u8 *next_hop); 1084 int (*get_mpath)(struct wiphy *wiphy, struct net_device *dev, 1085 u8 *dst, u8 *next_hop, 1086 struct mpath_info *pinfo); 1087 int (*dump_mpath)(struct wiphy *wiphy, struct net_device *dev, 1088 int idx, u8 *dst, u8 *next_hop, 1089 struct mpath_info *pinfo); 1090 int (*get_mesh_params)(struct wiphy *wiphy, 1091 struct net_device *dev, 1092 struct mesh_config *conf); 1093 int (*set_mesh_params)(struct wiphy *wiphy, 1094 struct net_device *dev, 1095 const struct mesh_config *nconf, u32 mask); 1096 int (*change_bss)(struct wiphy *wiphy, struct net_device *dev, 1097 struct bss_parameters *params); 1098 1099 int (*set_txq_params)(struct wiphy *wiphy, 1100 struct ieee80211_txq_params *params); 1101 1102 int (*set_channel)(struct wiphy *wiphy, struct net_device *dev, 1103 struct ieee80211_channel *chan, 1104 enum nl80211_channel_type channel_type); 1105 1106 int (*scan)(struct wiphy *wiphy, struct net_device *dev, 1107 struct cfg80211_scan_request *request); 1108 1109 int (*auth)(struct wiphy *wiphy, struct net_device *dev, 1110 struct cfg80211_auth_request *req); 1111 int (*assoc)(struct wiphy *wiphy, struct net_device *dev, 1112 struct cfg80211_assoc_request *req); 1113 int (*deauth)(struct wiphy *wiphy, struct net_device *dev, 1114 struct cfg80211_deauth_request *req, 1115 void *cookie); 1116 int (*disassoc)(struct wiphy *wiphy, struct net_device *dev, 1117 struct cfg80211_disassoc_request *req, 1118 void *cookie); 1119 1120 int (*connect)(struct wiphy *wiphy, struct net_device *dev, 1121 struct cfg80211_connect_params *sme); 1122 int (*disconnect)(struct wiphy *wiphy, struct net_device *dev, 1123 u16 reason_code); 1124 1125 int (*join_ibss)(struct wiphy *wiphy, struct net_device *dev, 1126 struct cfg80211_ibss_params *params); 1127 int (*leave_ibss)(struct wiphy *wiphy, struct net_device *dev); 1128 1129 int (*set_wiphy_params)(struct wiphy *wiphy, u32 changed); 1130 1131 int (*set_tx_power)(struct wiphy *wiphy, 1132 enum tx_power_setting type, int dbm); 1133 int (*get_tx_power)(struct wiphy *wiphy, int *dbm); 1134 1135 int (*set_wds_peer)(struct wiphy *wiphy, struct net_device *dev, 1136 u8 *addr); 1137 1138 void (*rfkill_poll)(struct wiphy *wiphy); 1139 1140 #ifdef CONFIG_NL80211_TESTMODE 1141 int (*testmode_cmd)(struct wiphy *wiphy, void *data, int len); 1142 #endif 1143 1144 int (*set_bitrate_mask)(struct wiphy *wiphy, 1145 struct net_device *dev, 1146 const u8 *peer, 1147 const struct cfg80211_bitrate_mask *mask); 1148 1149 int (*dump_survey)(struct wiphy *wiphy, struct net_device *netdev, 1150 int idx, struct survey_info *info); 1151 1152 int (*set_pmksa)(struct wiphy *wiphy, struct net_device *netdev, 1153 struct cfg80211_pmksa *pmksa); 1154 int (*del_pmksa)(struct wiphy *wiphy, struct net_device *netdev, 1155 struct cfg80211_pmksa *pmksa); 1156 int (*flush_pmksa)(struct wiphy *wiphy, struct net_device *netdev); 1157 1158 int (*remain_on_channel)(struct wiphy *wiphy, 1159 struct net_device *dev, 1160 struct ieee80211_channel *chan, 1161 enum nl80211_channel_type channel_type, 1162 unsigned int duration, 1163 u64 *cookie); 1164 int (*cancel_remain_on_channel)(struct wiphy *wiphy, 1165 struct net_device *dev, 1166 u64 cookie); 1167 1168 int (*action)(struct wiphy *wiphy, struct net_device *dev, 1169 struct ieee80211_channel *chan, 1170 enum nl80211_channel_type channel_type, 1171 const u8 *buf, size_t len, u64 *cookie); 1172 1173 int (*set_power_mgmt)(struct wiphy *wiphy, struct net_device *dev, 1174 bool enabled, int timeout); 1175 1176 int (*set_cqm_rssi_config)(struct wiphy *wiphy, 1177 struct net_device *dev, 1178 s32 rssi_thold, u32 rssi_hyst); 1179 }; 1180 1181 /* 1182 * wireless hardware and networking interfaces structures 1183 * and registration/helper functions 1184 */ 1185 1186 /** 1187 * enum wiphy_flags - wiphy capability flags 1188 * 1189 * @WIPHY_FLAG_CUSTOM_REGULATORY: tells us the driver for this device 1190 * has its own custom regulatory domain and cannot identify the 1191 * ISO / IEC 3166 alpha2 it belongs to. When this is enabled 1192 * we will disregard the first regulatory hint (when the 1193 * initiator is %REGDOM_SET_BY_CORE). 1194 * @WIPHY_FLAG_STRICT_REGULATORY: tells us the driver for this device will 1195 * ignore regulatory domain settings until it gets its own regulatory 1196 * domain via its regulatory_hint(). After its gets its own regulatory 1197 * domain it will only allow further regulatory domain settings to 1198 * further enhance compliance. For example if channel 13 and 14 are 1199 * disabled by this regulatory domain no user regulatory domain can 1200 * enable these channels at a later time. This can be used for devices 1201 * which do not have calibration information gauranteed for frequencies 1202 * or settings outside of its regulatory domain. 1203 * @WIPHY_FLAG_DISABLE_BEACON_HINTS: enable this if your driver needs to ensure 1204 * that passive scan flags and beaconing flags may not be lifted by 1205 * cfg80211 due to regulatory beacon hints. For more information on beacon 1206 * hints read the documenation for regulatory_hint_found_beacon() 1207 * @WIPHY_FLAG_NETNS_OK: if not set, do not allow changing the netns of this 1208 * wiphy at all 1209 * @WIPHY_FLAG_PS_ON_BY_DEFAULT: if set to true, powersave will be enabled 1210 * by default -- this flag will be set depending on the kernel's default 1211 * on wiphy_new(), but can be changed by the driver if it has a good 1212 * reason to override the default 1213 * @WIPHY_FLAG_4ADDR_AP: supports 4addr mode even on AP (with a single station 1214 * on a VLAN interface) 1215 * @WIPHY_FLAG_4ADDR_STATION: supports 4addr mode even as a station 1216 */ 1217 enum wiphy_flags { 1218 WIPHY_FLAG_CUSTOM_REGULATORY = BIT(0), 1219 WIPHY_FLAG_STRICT_REGULATORY = BIT(1), 1220 WIPHY_FLAG_DISABLE_BEACON_HINTS = BIT(2), 1221 WIPHY_FLAG_NETNS_OK = BIT(3), 1222 WIPHY_FLAG_PS_ON_BY_DEFAULT = BIT(4), 1223 WIPHY_FLAG_4ADDR_AP = BIT(5), 1224 WIPHY_FLAG_4ADDR_STATION = BIT(6), 1225 }; 1226 1227 struct mac_address { 1228 u8 addr[ETH_ALEN]; 1229 }; 1230 1231 /** 1232 * struct wiphy - wireless hardware description 1233 * @idx: the wiphy index assigned to this item 1234 * @class_dev: the class device representing /sys/class/ieee80211/<wiphy-name> 1235 * @reg_notifier: the driver's regulatory notification callback 1236 * @regd: the driver's regulatory domain, if one was requested via 1237 * the regulatory_hint() API. This can be used by the driver 1238 * on the reg_notifier() if it chooses to ignore future 1239 * regulatory domain changes caused by other drivers. 1240 * @signal_type: signal type reported in &struct cfg80211_bss. 1241 * @cipher_suites: supported cipher suites 1242 * @n_cipher_suites: number of supported cipher suites 1243 * @retry_short: Retry limit for short frames (dot11ShortRetryLimit) 1244 * @retry_long: Retry limit for long frames (dot11LongRetryLimit) 1245 * @frag_threshold: Fragmentation threshold (dot11FragmentationThreshold); 1246 * -1 = fragmentation disabled, only odd values >= 256 used 1247 * @rts_threshold: RTS threshold (dot11RTSThreshold); -1 = RTS/CTS disabled 1248 * @net: the network namespace this wiphy currently lives in 1249 * @perm_addr: permanent MAC address of this device 1250 * @addr_mask: If the device supports multiple MAC addresses by masking, 1251 * set this to a mask with variable bits set to 1, e.g. if the last 1252 * four bits are variable then set it to 00:...:00:0f. The actual 1253 * variable bits shall be determined by the interfaces added, with 1254 * interfaces not matching the mask being rejected to be brought up. 1255 * @n_addresses: number of addresses in @addresses. 1256 * @addresses: If the device has more than one address, set this pointer 1257 * to a list of addresses (6 bytes each). The first one will be used 1258 * by default for perm_addr. In this case, the mask should be set to 1259 * all-zeroes. In this case it is assumed that the device can handle 1260 * the same number of arbitrary MAC addresses. 1261 */ 1262 struct wiphy { 1263 /* assign these fields before you register the wiphy */ 1264 1265 /* permanent MAC address(es) */ 1266 u8 perm_addr[ETH_ALEN]; 1267 u8 addr_mask[ETH_ALEN]; 1268 1269 u16 n_addresses; 1270 struct mac_address *addresses; 1271 1272 /* Supported interface modes, OR together BIT(NL80211_IFTYPE_...) */ 1273 u16 interface_modes; 1274 1275 u32 flags; 1276 1277 enum cfg80211_signal_type signal_type; 1278 1279 int bss_priv_size; 1280 u8 max_scan_ssids; 1281 u16 max_scan_ie_len; 1282 1283 int n_cipher_suites; 1284 const u32 *cipher_suites; 1285 1286 u8 retry_short; 1287 u8 retry_long; 1288 u32 frag_threshold; 1289 u32 rts_threshold; 1290 u8 coverage_class; 1291 1292 char fw_version[ETHTOOL_BUSINFO_LEN]; 1293 u32 hw_version; 1294 1295 u8 max_num_pmkids; 1296 1297 /* If multiple wiphys are registered and you're handed e.g. 1298 * a regular netdev with assigned ieee80211_ptr, you won't 1299 * know whether it points to a wiphy your driver has registered 1300 * or not. Assign this to something global to your driver to 1301 * help determine whether you own this wiphy or not. */ 1302 const void *privid; 1303 1304 struct ieee80211_supported_band *bands[IEEE80211_NUM_BANDS]; 1305 1306 /* Lets us get back the wiphy on the callback */ 1307 int (*reg_notifier)(struct wiphy *wiphy, 1308 struct regulatory_request *request); 1309 1310 /* fields below are read-only, assigned by cfg80211 */ 1311 1312 const struct ieee80211_regdomain *regd; 1313 1314 /* the item in /sys/class/ieee80211/ points to this, 1315 * you need use set_wiphy_dev() (see below) */ 1316 struct device dev; 1317 1318 /* dir in debugfs: ieee80211/<wiphyname> */ 1319 struct dentry *debugfsdir; 1320 1321 #ifdef CONFIG_NET_NS 1322 /* the network namespace this phy lives in currently */ 1323 struct net *_net; 1324 #endif 1325 1326 #ifdef CONFIG_CFG80211_WEXT 1327 const struct iw_handler_def *wext; 1328 #endif 1329 1330 char priv[0] __attribute__((__aligned__(NETDEV_ALIGN))); 1331 }; 1332 1333 #ifdef CONFIG_NET_NS 1334 static inline struct net *wiphy_net(struct wiphy *wiphy) 1335 { 1336 return wiphy->_net; 1337 } 1338 1339 static inline void wiphy_net_set(struct wiphy *wiphy, struct net *net) 1340 { 1341 wiphy->_net = net; 1342 } 1343 #else 1344 static inline struct net *wiphy_net(struct wiphy *wiphy) 1345 { 1346 return &init_net; 1347 } 1348 1349 static inline void wiphy_net_set(struct wiphy *wiphy, struct net *net) 1350 { 1351 } 1352 #endif 1353 1354 /** 1355 * wiphy_priv - return priv from wiphy 1356 * 1357 * @wiphy: the wiphy whose priv pointer to return 1358 */ 1359 static inline void *wiphy_priv(struct wiphy *wiphy) 1360 { 1361 BUG_ON(!wiphy); 1362 return &wiphy->priv; 1363 } 1364 1365 /** 1366 * priv_to_wiphy - return the wiphy containing the priv 1367 * 1368 * @priv: a pointer previously returned by wiphy_priv 1369 */ 1370 static inline struct wiphy *priv_to_wiphy(void *priv) 1371 { 1372 BUG_ON(!priv); 1373 return container_of(priv, struct wiphy, priv); 1374 } 1375 1376 /** 1377 * set_wiphy_dev - set device pointer for wiphy 1378 * 1379 * @wiphy: The wiphy whose device to bind 1380 * @dev: The device to parent it to 1381 */ 1382 static inline void set_wiphy_dev(struct wiphy *wiphy, struct device *dev) 1383 { 1384 wiphy->dev.parent = dev; 1385 } 1386 1387 /** 1388 * wiphy_dev - get wiphy dev pointer 1389 * 1390 * @wiphy: The wiphy whose device struct to look up 1391 */ 1392 static inline struct device *wiphy_dev(struct wiphy *wiphy) 1393 { 1394 return wiphy->dev.parent; 1395 } 1396 1397 /** 1398 * wiphy_name - get wiphy name 1399 * 1400 * @wiphy: The wiphy whose name to return 1401 */ 1402 static inline const char *wiphy_name(struct wiphy *wiphy) 1403 { 1404 return dev_name(&wiphy->dev); 1405 } 1406 1407 /** 1408 * wiphy_new - create a new wiphy for use with cfg80211 1409 * 1410 * @ops: The configuration operations for this device 1411 * @sizeof_priv: The size of the private area to allocate 1412 * 1413 * Create a new wiphy and associate the given operations with it. 1414 * @sizeof_priv bytes are allocated for private use. 1415 * 1416 * The returned pointer must be assigned to each netdev's 1417 * ieee80211_ptr for proper operation. 1418 */ 1419 struct wiphy *wiphy_new(const struct cfg80211_ops *ops, int sizeof_priv); 1420 1421 /** 1422 * wiphy_register - register a wiphy with cfg80211 1423 * 1424 * @wiphy: The wiphy to register. 1425 * 1426 * Returns a non-negative wiphy index or a negative error code. 1427 */ 1428 extern int wiphy_register(struct wiphy *wiphy); 1429 1430 /** 1431 * wiphy_unregister - deregister a wiphy from cfg80211 1432 * 1433 * @wiphy: The wiphy to unregister. 1434 * 1435 * After this call, no more requests can be made with this priv 1436 * pointer, but the call may sleep to wait for an outstanding 1437 * request that is being handled. 1438 */ 1439 extern void wiphy_unregister(struct wiphy *wiphy); 1440 1441 /** 1442 * wiphy_free - free wiphy 1443 * 1444 * @wiphy: The wiphy to free 1445 */ 1446 extern void wiphy_free(struct wiphy *wiphy); 1447 1448 /* internal structs */ 1449 struct cfg80211_conn; 1450 struct cfg80211_internal_bss; 1451 struct cfg80211_cached_keys; 1452 1453 #define MAX_AUTH_BSSES 4 1454 1455 /** 1456 * struct wireless_dev - wireless per-netdev state 1457 * 1458 * This structure must be allocated by the driver/stack 1459 * that uses the ieee80211_ptr field in struct net_device 1460 * (this is intentional so it can be allocated along with 1461 * the netdev.) 1462 * 1463 * @wiphy: pointer to hardware description 1464 * @iftype: interface type 1465 * @list: (private) Used to collect the interfaces 1466 * @netdev: (private) Used to reference back to the netdev 1467 * @current_bss: (private) Used by the internal configuration code 1468 * @channel: (private) Used by the internal configuration code to track 1469 * user-set AP, monitor and WDS channels for wireless extensions 1470 * @bssid: (private) Used by the internal configuration code 1471 * @ssid: (private) Used by the internal configuration code 1472 * @ssid_len: (private) Used by the internal configuration code 1473 * @wext: (private) Used by the internal wireless extensions compat code 1474 * @wext_bssid: (private) Used by the internal wireless extensions compat code 1475 * @use_4addr: indicates 4addr mode is used on this interface, must be 1476 * set by driver (if supported) on add_interface BEFORE registering the 1477 * netdev and may otherwise be used by driver read-only, will be update 1478 * by cfg80211 on change_interface 1479 * @action_registrations: list of registrations for action frames 1480 * @action_registrations_lock: lock for the list 1481 */ 1482 struct wireless_dev { 1483 struct wiphy *wiphy; 1484 enum nl80211_iftype iftype; 1485 1486 /* the remainder of this struct should be private to cfg80211 */ 1487 struct list_head list; 1488 struct net_device *netdev; 1489 1490 struct list_head action_registrations; 1491 spinlock_t action_registrations_lock; 1492 1493 struct mutex mtx; 1494 1495 struct work_struct cleanup_work; 1496 1497 bool use_4addr; 1498 1499 /* currently used for IBSS and SME - might be rearranged later */ 1500 u8 ssid[IEEE80211_MAX_SSID_LEN]; 1501 u8 ssid_len; 1502 enum { 1503 CFG80211_SME_IDLE, 1504 CFG80211_SME_CONNECTING, 1505 CFG80211_SME_CONNECTED, 1506 } sme_state; 1507 struct cfg80211_conn *conn; 1508 struct cfg80211_cached_keys *connect_keys; 1509 1510 struct list_head event_list; 1511 spinlock_t event_lock; 1512 1513 struct cfg80211_internal_bss *authtry_bsses[MAX_AUTH_BSSES]; 1514 struct cfg80211_internal_bss *auth_bsses[MAX_AUTH_BSSES]; 1515 struct cfg80211_internal_bss *current_bss; /* associated / joined */ 1516 struct ieee80211_channel *channel; 1517 1518 bool ps; 1519 int ps_timeout; 1520 1521 #ifdef CONFIG_CFG80211_WEXT 1522 /* wext data */ 1523 struct { 1524 struct cfg80211_ibss_params ibss; 1525 struct cfg80211_connect_params connect; 1526 struct cfg80211_cached_keys *keys; 1527 u8 *ie; 1528 size_t ie_len; 1529 u8 bssid[ETH_ALEN], prev_bssid[ETH_ALEN]; 1530 u8 ssid[IEEE80211_MAX_SSID_LEN]; 1531 s8 default_key, default_mgmt_key; 1532 bool prev_bssid_valid; 1533 } wext; 1534 #endif 1535 }; 1536 1537 /** 1538 * wdev_priv - return wiphy priv from wireless_dev 1539 * 1540 * @wdev: The wireless device whose wiphy's priv pointer to return 1541 */ 1542 static inline void *wdev_priv(struct wireless_dev *wdev) 1543 { 1544 BUG_ON(!wdev); 1545 return wiphy_priv(wdev->wiphy); 1546 } 1547 1548 /* 1549 * Utility functions 1550 */ 1551 1552 /** 1553 * ieee80211_channel_to_frequency - convert channel number to frequency 1554 */ 1555 extern int ieee80211_channel_to_frequency(int chan); 1556 1557 /** 1558 * ieee80211_frequency_to_channel - convert frequency to channel number 1559 */ 1560 extern int ieee80211_frequency_to_channel(int freq); 1561 1562 /* 1563 * Name indirection necessary because the ieee80211 code also has 1564 * a function named "ieee80211_get_channel", so if you include 1565 * cfg80211's header file you get cfg80211's version, if you try 1566 * to include both header files you'll (rightfully!) get a symbol 1567 * clash. 1568 */ 1569 extern struct ieee80211_channel *__ieee80211_get_channel(struct wiphy *wiphy, 1570 int freq); 1571 /** 1572 * ieee80211_get_channel - get channel struct from wiphy for specified frequency 1573 */ 1574 static inline struct ieee80211_channel * 1575 ieee80211_get_channel(struct wiphy *wiphy, int freq) 1576 { 1577 return __ieee80211_get_channel(wiphy, freq); 1578 } 1579 1580 /** 1581 * ieee80211_get_response_rate - get basic rate for a given rate 1582 * 1583 * @sband: the band to look for rates in 1584 * @basic_rates: bitmap of basic rates 1585 * @bitrate: the bitrate for which to find the basic rate 1586 * 1587 * This function returns the basic rate corresponding to a given 1588 * bitrate, that is the next lower bitrate contained in the basic 1589 * rate map, which is, for this function, given as a bitmap of 1590 * indices of rates in the band's bitrate table. 1591 */ 1592 struct ieee80211_rate * 1593 ieee80211_get_response_rate(struct ieee80211_supported_band *sband, 1594 u32 basic_rates, int bitrate); 1595 1596 /* 1597 * Radiotap parsing functions -- for controlled injection support 1598 * 1599 * Implemented in net/wireless/radiotap.c 1600 * Documentation in Documentation/networking/radiotap-headers.txt 1601 */ 1602 1603 struct radiotap_align_size { 1604 uint8_t align:4, size:4; 1605 }; 1606 1607 struct ieee80211_radiotap_namespace { 1608 const struct radiotap_align_size *align_size; 1609 int n_bits; 1610 uint32_t oui; 1611 uint8_t subns; 1612 }; 1613 1614 struct ieee80211_radiotap_vendor_namespaces { 1615 const struct ieee80211_radiotap_namespace *ns; 1616 int n_ns; 1617 }; 1618 1619 /** 1620 * struct ieee80211_radiotap_iterator - tracks walk thru present radiotap args 1621 * @this_arg_index: index of current arg, valid after each successful call 1622 * to ieee80211_radiotap_iterator_next() 1623 * @this_arg: pointer to current radiotap arg; it is valid after each 1624 * call to ieee80211_radiotap_iterator_next() but also after 1625 * ieee80211_radiotap_iterator_init() where it will point to 1626 * the beginning of the actual data portion 1627 * @this_arg_size: length of the current arg, for convenience 1628 * @current_namespace: pointer to the current namespace definition 1629 * (or internally %NULL if the current namespace is unknown) 1630 * @is_radiotap_ns: indicates whether the current namespace is the default 1631 * radiotap namespace or not 1632 * 1633 * @overrides: override standard radiotap fields 1634 * @n_overrides: number of overrides 1635 * 1636 * @_rtheader: pointer to the radiotap header we are walking through 1637 * @_max_length: length of radiotap header in cpu byte ordering 1638 * @_arg_index: next argument index 1639 * @_arg: next argument pointer 1640 * @_next_bitmap: internal pointer to next present u32 1641 * @_bitmap_shifter: internal shifter for curr u32 bitmap, b0 set == arg present 1642 * @_vns: vendor namespace definitions 1643 * @_next_ns_data: beginning of the next namespace's data 1644 * @_reset_on_ext: internal; reset the arg index to 0 when going to the 1645 * next bitmap word 1646 * 1647 * Describes the radiotap parser state. Fields prefixed with an underscore 1648 * must not be used by users of the parser, only by the parser internally. 1649 */ 1650 1651 struct ieee80211_radiotap_iterator { 1652 struct ieee80211_radiotap_header *_rtheader; 1653 const struct ieee80211_radiotap_vendor_namespaces *_vns; 1654 const struct ieee80211_radiotap_namespace *current_namespace; 1655 1656 unsigned char *_arg, *_next_ns_data; 1657 __le32 *_next_bitmap; 1658 1659 unsigned char *this_arg; 1660 int this_arg_index; 1661 int this_arg_size; 1662 1663 int is_radiotap_ns; 1664 1665 int _max_length; 1666 int _arg_index; 1667 uint32_t _bitmap_shifter; 1668 int _reset_on_ext; 1669 }; 1670 1671 extern int ieee80211_radiotap_iterator_init( 1672 struct ieee80211_radiotap_iterator *iterator, 1673 struct ieee80211_radiotap_header *radiotap_header, 1674 int max_length, const struct ieee80211_radiotap_vendor_namespaces *vns); 1675 1676 extern int ieee80211_radiotap_iterator_next( 1677 struct ieee80211_radiotap_iterator *iterator); 1678 1679 1680 extern const unsigned char rfc1042_header[6]; 1681 extern const unsigned char bridge_tunnel_header[6]; 1682 1683 /** 1684 * ieee80211_get_hdrlen_from_skb - get header length from data 1685 * 1686 * Given an skb with a raw 802.11 header at the data pointer this function 1687 * returns the 802.11 header length in bytes (not including encryption 1688 * headers). If the data in the sk_buff is too short to contain a valid 802.11 1689 * header the function returns 0. 1690 * 1691 * @skb: the frame 1692 */ 1693 unsigned int ieee80211_get_hdrlen_from_skb(const struct sk_buff *skb); 1694 1695 /** 1696 * ieee80211_hdrlen - get header length in bytes from frame control 1697 * @fc: frame control field in little-endian format 1698 */ 1699 unsigned int ieee80211_hdrlen(__le16 fc); 1700 1701 /** 1702 * ieee80211_data_to_8023 - convert an 802.11 data frame to 802.3 1703 * @skb: the 802.11 data frame 1704 * @addr: the device MAC address 1705 * @iftype: the virtual interface type 1706 */ 1707 int ieee80211_data_to_8023(struct sk_buff *skb, const u8 *addr, 1708 enum nl80211_iftype iftype); 1709 1710 /** 1711 * ieee80211_data_from_8023 - convert an 802.3 frame to 802.11 1712 * @skb: the 802.3 frame 1713 * @addr: the device MAC address 1714 * @iftype: the virtual interface type 1715 * @bssid: the network bssid (used only for iftype STATION and ADHOC) 1716 * @qos: build 802.11 QoS data frame 1717 */ 1718 int ieee80211_data_from_8023(struct sk_buff *skb, const u8 *addr, 1719 enum nl80211_iftype iftype, u8 *bssid, bool qos); 1720 1721 /** 1722 * ieee80211_amsdu_to_8023s - decode an IEEE 802.11n A-MSDU frame 1723 * 1724 * Decode an IEEE 802.11n A-MSDU frame and convert it to a list of 1725 * 802.3 frames. The @list will be empty if the decode fails. The 1726 * @skb is consumed after the function returns. 1727 * 1728 * @skb: The input IEEE 802.11n A-MSDU frame. 1729 * @list: The output list of 802.3 frames. It must be allocated and 1730 * initialized by by the caller. 1731 * @addr: The device MAC address. 1732 * @iftype: The device interface type. 1733 * @extra_headroom: The hardware extra headroom for SKBs in the @list. 1734 */ 1735 void ieee80211_amsdu_to_8023s(struct sk_buff *skb, struct sk_buff_head *list, 1736 const u8 *addr, enum nl80211_iftype iftype, 1737 const unsigned int extra_headroom); 1738 1739 /** 1740 * cfg80211_classify8021d - determine the 802.1p/1d tag for a data frame 1741 * @skb: the data frame 1742 */ 1743 unsigned int cfg80211_classify8021d(struct sk_buff *skb); 1744 1745 /** 1746 * cfg80211_find_ie - find information element in data 1747 * 1748 * @eid: element ID 1749 * @ies: data consisting of IEs 1750 * @len: length of data 1751 * 1752 * This function will return %NULL if the element ID could 1753 * not be found or if the element is invalid (claims to be 1754 * longer than the given data), or a pointer to the first byte 1755 * of the requested element, that is the byte containing the 1756 * element ID. There are no checks on the element length 1757 * other than having to fit into the given data. 1758 */ 1759 const u8 *cfg80211_find_ie(u8 eid, const u8 *ies, int len); 1760 1761 /* 1762 * Regulatory helper functions for wiphys 1763 */ 1764 1765 /** 1766 * regulatory_hint - driver hint to the wireless core a regulatory domain 1767 * @wiphy: the wireless device giving the hint (used only for reporting 1768 * conflicts) 1769 * @alpha2: the ISO/IEC 3166 alpha2 the driver claims its regulatory domain 1770 * should be in. If @rd is set this should be NULL. Note that if you 1771 * set this to NULL you should still set rd->alpha2 to some accepted 1772 * alpha2. 1773 * 1774 * Wireless drivers can use this function to hint to the wireless core 1775 * what it believes should be the current regulatory domain by 1776 * giving it an ISO/IEC 3166 alpha2 country code it knows its regulatory 1777 * domain should be in or by providing a completely build regulatory domain. 1778 * If the driver provides an ISO/IEC 3166 alpha2 userspace will be queried 1779 * for a regulatory domain structure for the respective country. 1780 * 1781 * The wiphy must have been registered to cfg80211 prior to this call. 1782 * For cfg80211 drivers this means you must first use wiphy_register(), 1783 * for mac80211 drivers you must first use ieee80211_register_hw(). 1784 * 1785 * Drivers should check the return value, its possible you can get 1786 * an -ENOMEM. 1787 */ 1788 extern int regulatory_hint(struct wiphy *wiphy, const char *alpha2); 1789 1790 /** 1791 * wiphy_apply_custom_regulatory - apply a custom driver regulatory domain 1792 * @wiphy: the wireless device we want to process the regulatory domain on 1793 * @regd: the custom regulatory domain to use for this wiphy 1794 * 1795 * Drivers can sometimes have custom regulatory domains which do not apply 1796 * to a specific country. Drivers can use this to apply such custom regulatory 1797 * domains. This routine must be called prior to wiphy registration. The 1798 * custom regulatory domain will be trusted completely and as such previous 1799 * default channel settings will be disregarded. If no rule is found for a 1800 * channel on the regulatory domain the channel will be disabled. 1801 */ 1802 extern void wiphy_apply_custom_regulatory( 1803 struct wiphy *wiphy, 1804 const struct ieee80211_regdomain *regd); 1805 1806 /** 1807 * freq_reg_info - get regulatory information for the given frequency 1808 * @wiphy: the wiphy for which we want to process this rule for 1809 * @center_freq: Frequency in KHz for which we want regulatory information for 1810 * @desired_bw_khz: the desired max bandwidth you want to use per 1811 * channel. Note that this is still 20 MHz if you want to use HT40 1812 * as HT40 makes use of two channels for its 40 MHz width bandwidth. 1813 * If set to 0 we'll assume you want the standard 20 MHz. 1814 * @reg_rule: the regulatory rule which we have for this frequency 1815 * 1816 * Use this function to get the regulatory rule for a specific frequency on 1817 * a given wireless device. If the device has a specific regulatory domain 1818 * it wants to follow we respect that unless a country IE has been received 1819 * and processed already. 1820 * 1821 * Returns 0 if it was able to find a valid regulatory rule which does 1822 * apply to the given center_freq otherwise it returns non-zero. It will 1823 * also return -ERANGE if we determine the given center_freq does not even have 1824 * a regulatory rule for a frequency range in the center_freq's band. See 1825 * freq_in_rule_band() for our current definition of a band -- this is purely 1826 * subjective and right now its 802.11 specific. 1827 */ 1828 extern int freq_reg_info(struct wiphy *wiphy, 1829 u32 center_freq, 1830 u32 desired_bw_khz, 1831 const struct ieee80211_reg_rule **reg_rule); 1832 1833 /* 1834 * Temporary wext handlers & helper functions 1835 * 1836 * In the future cfg80211 will simply assign the entire wext handler 1837 * structure to netdevs it manages, but we're not there yet. 1838 */ 1839 int cfg80211_wext_giwname(struct net_device *dev, 1840 struct iw_request_info *info, 1841 char *name, char *extra); 1842 int cfg80211_wext_siwmode(struct net_device *dev, struct iw_request_info *info, 1843 u32 *mode, char *extra); 1844 int cfg80211_wext_giwmode(struct net_device *dev, struct iw_request_info *info, 1845 u32 *mode, char *extra); 1846 int cfg80211_wext_siwscan(struct net_device *dev, 1847 struct iw_request_info *info, 1848 union iwreq_data *wrqu, char *extra); 1849 int cfg80211_wext_giwscan(struct net_device *dev, 1850 struct iw_request_info *info, 1851 struct iw_point *data, char *extra); 1852 int cfg80211_wext_siwmlme(struct net_device *dev, 1853 struct iw_request_info *info, 1854 struct iw_point *data, char *extra); 1855 int cfg80211_wext_giwrange(struct net_device *dev, 1856 struct iw_request_info *info, 1857 struct iw_point *data, char *extra); 1858 int cfg80211_wext_siwgenie(struct net_device *dev, 1859 struct iw_request_info *info, 1860 struct iw_point *data, char *extra); 1861 int cfg80211_wext_siwauth(struct net_device *dev, 1862 struct iw_request_info *info, 1863 struct iw_param *data, char *extra); 1864 int cfg80211_wext_giwauth(struct net_device *dev, 1865 struct iw_request_info *info, 1866 struct iw_param *data, char *extra); 1867 1868 int cfg80211_wext_siwfreq(struct net_device *dev, 1869 struct iw_request_info *info, 1870 struct iw_freq *freq, char *extra); 1871 int cfg80211_wext_giwfreq(struct net_device *dev, 1872 struct iw_request_info *info, 1873 struct iw_freq *freq, char *extra); 1874 int cfg80211_wext_siwessid(struct net_device *dev, 1875 struct iw_request_info *info, 1876 struct iw_point *data, char *ssid); 1877 int cfg80211_wext_giwessid(struct net_device *dev, 1878 struct iw_request_info *info, 1879 struct iw_point *data, char *ssid); 1880 int cfg80211_wext_siwrate(struct net_device *dev, 1881 struct iw_request_info *info, 1882 struct iw_param *rate, char *extra); 1883 int cfg80211_wext_giwrate(struct net_device *dev, 1884 struct iw_request_info *info, 1885 struct iw_param *rate, char *extra); 1886 1887 int cfg80211_wext_siwrts(struct net_device *dev, 1888 struct iw_request_info *info, 1889 struct iw_param *rts, char *extra); 1890 int cfg80211_wext_giwrts(struct net_device *dev, 1891 struct iw_request_info *info, 1892 struct iw_param *rts, char *extra); 1893 int cfg80211_wext_siwfrag(struct net_device *dev, 1894 struct iw_request_info *info, 1895 struct iw_param *frag, char *extra); 1896 int cfg80211_wext_giwfrag(struct net_device *dev, 1897 struct iw_request_info *info, 1898 struct iw_param *frag, char *extra); 1899 int cfg80211_wext_siwretry(struct net_device *dev, 1900 struct iw_request_info *info, 1901 struct iw_param *retry, char *extra); 1902 int cfg80211_wext_giwretry(struct net_device *dev, 1903 struct iw_request_info *info, 1904 struct iw_param *retry, char *extra); 1905 int cfg80211_wext_siwencodeext(struct net_device *dev, 1906 struct iw_request_info *info, 1907 struct iw_point *erq, char *extra); 1908 int cfg80211_wext_siwencode(struct net_device *dev, 1909 struct iw_request_info *info, 1910 struct iw_point *erq, char *keybuf); 1911 int cfg80211_wext_giwencode(struct net_device *dev, 1912 struct iw_request_info *info, 1913 struct iw_point *erq, char *keybuf); 1914 int cfg80211_wext_siwtxpower(struct net_device *dev, 1915 struct iw_request_info *info, 1916 union iwreq_data *data, char *keybuf); 1917 int cfg80211_wext_giwtxpower(struct net_device *dev, 1918 struct iw_request_info *info, 1919 union iwreq_data *data, char *keybuf); 1920 struct iw_statistics *cfg80211_wireless_stats(struct net_device *dev); 1921 1922 int cfg80211_wext_siwpower(struct net_device *dev, 1923 struct iw_request_info *info, 1924 struct iw_param *wrq, char *extra); 1925 int cfg80211_wext_giwpower(struct net_device *dev, 1926 struct iw_request_info *info, 1927 struct iw_param *wrq, char *extra); 1928 1929 int cfg80211_wext_siwap(struct net_device *dev, 1930 struct iw_request_info *info, 1931 struct sockaddr *ap_addr, char *extra); 1932 int cfg80211_wext_giwap(struct net_device *dev, 1933 struct iw_request_info *info, 1934 struct sockaddr *ap_addr, char *extra); 1935 1936 /* 1937 * callbacks for asynchronous cfg80211 methods, notification 1938 * functions and BSS handling helpers 1939 */ 1940 1941 /** 1942 * cfg80211_scan_done - notify that scan finished 1943 * 1944 * @request: the corresponding scan request 1945 * @aborted: set to true if the scan was aborted for any reason, 1946 * userspace will be notified of that 1947 */ 1948 void cfg80211_scan_done(struct cfg80211_scan_request *request, bool aborted); 1949 1950 /** 1951 * cfg80211_inform_bss - inform cfg80211 of a new BSS 1952 * 1953 * @wiphy: the wiphy reporting the BSS 1954 * @bss: the found BSS 1955 * @signal: the signal strength, type depends on the wiphy's signal_type 1956 * @gfp: context flags 1957 * 1958 * This informs cfg80211 that BSS information was found and 1959 * the BSS should be updated/added. 1960 */ 1961 struct cfg80211_bss* 1962 cfg80211_inform_bss_frame(struct wiphy *wiphy, 1963 struct ieee80211_channel *channel, 1964 struct ieee80211_mgmt *mgmt, size_t len, 1965 s32 signal, gfp_t gfp); 1966 1967 struct cfg80211_bss* 1968 cfg80211_inform_bss(struct wiphy *wiphy, 1969 struct ieee80211_channel *channel, 1970 const u8 *bssid, 1971 u64 timestamp, u16 capability, u16 beacon_interval, 1972 const u8 *ie, size_t ielen, 1973 s32 signal, gfp_t gfp); 1974 1975 struct cfg80211_bss *cfg80211_get_bss(struct wiphy *wiphy, 1976 struct ieee80211_channel *channel, 1977 const u8 *bssid, 1978 const u8 *ssid, size_t ssid_len, 1979 u16 capa_mask, u16 capa_val); 1980 static inline struct cfg80211_bss * 1981 cfg80211_get_ibss(struct wiphy *wiphy, 1982 struct ieee80211_channel *channel, 1983 const u8 *ssid, size_t ssid_len) 1984 { 1985 return cfg80211_get_bss(wiphy, channel, NULL, ssid, ssid_len, 1986 WLAN_CAPABILITY_IBSS, WLAN_CAPABILITY_IBSS); 1987 } 1988 1989 struct cfg80211_bss *cfg80211_get_mesh(struct wiphy *wiphy, 1990 struct ieee80211_channel *channel, 1991 const u8 *meshid, size_t meshidlen, 1992 const u8 *meshcfg); 1993 void cfg80211_put_bss(struct cfg80211_bss *bss); 1994 1995 /** 1996 * cfg80211_unlink_bss - unlink BSS from internal data structures 1997 * @wiphy: the wiphy 1998 * @bss: the bss to remove 1999 * 2000 * This function removes the given BSS from the internal data structures 2001 * thereby making it no longer show up in scan results etc. Use this 2002 * function when you detect a BSS is gone. Normally BSSes will also time 2003 * out, so it is not necessary to use this function at all. 2004 */ 2005 void cfg80211_unlink_bss(struct wiphy *wiphy, struct cfg80211_bss *bss); 2006 2007 /** 2008 * cfg80211_send_rx_auth - notification of processed authentication 2009 * @dev: network device 2010 * @buf: authentication frame (header + body) 2011 * @len: length of the frame data 2012 * 2013 * This function is called whenever an authentication has been processed in 2014 * station mode. The driver is required to call either this function or 2015 * cfg80211_send_auth_timeout() to indicate the result of cfg80211_ops::auth() 2016 * call. This function may sleep. 2017 */ 2018 void cfg80211_send_rx_auth(struct net_device *dev, const u8 *buf, size_t len); 2019 2020 /** 2021 * cfg80211_send_auth_timeout - notification of timed out authentication 2022 * @dev: network device 2023 * @addr: The MAC address of the device with which the authentication timed out 2024 * 2025 * This function may sleep. 2026 */ 2027 void cfg80211_send_auth_timeout(struct net_device *dev, const u8 *addr); 2028 2029 /** 2030 * __cfg80211_auth_canceled - notify cfg80211 that authentication was canceled 2031 * @dev: network device 2032 * @addr: The MAC address of the device with which the authentication timed out 2033 * 2034 * When a pending authentication had no action yet, the driver may decide 2035 * to not send a deauth frame, but in that case must calls this function 2036 * to tell cfg80211 about this decision. It is only valid to call this 2037 * function within the deauth() callback. 2038 */ 2039 void __cfg80211_auth_canceled(struct net_device *dev, const u8 *addr); 2040 2041 /** 2042 * cfg80211_send_rx_assoc - notification of processed association 2043 * @dev: network device 2044 * @buf: (re)association response frame (header + body) 2045 * @len: length of the frame data 2046 * 2047 * This function is called whenever a (re)association response has been 2048 * processed in station mode. The driver is required to call either this 2049 * function or cfg80211_send_assoc_timeout() to indicate the result of 2050 * cfg80211_ops::assoc() call. This function may sleep. 2051 */ 2052 void cfg80211_send_rx_assoc(struct net_device *dev, const u8 *buf, size_t len); 2053 2054 /** 2055 * cfg80211_send_assoc_timeout - notification of timed out association 2056 * @dev: network device 2057 * @addr: The MAC address of the device with which the association timed out 2058 * 2059 * This function may sleep. 2060 */ 2061 void cfg80211_send_assoc_timeout(struct net_device *dev, const u8 *addr); 2062 2063 /** 2064 * cfg80211_send_deauth - notification of processed deauthentication 2065 * @dev: network device 2066 * @buf: deauthentication frame (header + body) 2067 * @len: length of the frame data 2068 * 2069 * This function is called whenever deauthentication has been processed in 2070 * station mode. This includes both received deauthentication frames and 2071 * locally generated ones. This function may sleep. 2072 */ 2073 void cfg80211_send_deauth(struct net_device *dev, const u8 *buf, size_t len); 2074 2075 /** 2076 * __cfg80211_send_deauth - notification of processed deauthentication 2077 * @dev: network device 2078 * @buf: deauthentication frame (header + body) 2079 * @len: length of the frame data 2080 * 2081 * Like cfg80211_send_deauth(), but doesn't take the wdev lock. 2082 */ 2083 void __cfg80211_send_deauth(struct net_device *dev, const u8 *buf, size_t len); 2084 2085 /** 2086 * cfg80211_send_disassoc - notification of processed disassociation 2087 * @dev: network device 2088 * @buf: disassociation response frame (header + body) 2089 * @len: length of the frame data 2090 * 2091 * This function is called whenever disassociation has been processed in 2092 * station mode. This includes both received disassociation frames and locally 2093 * generated ones. This function may sleep. 2094 */ 2095 void cfg80211_send_disassoc(struct net_device *dev, const u8 *buf, size_t len); 2096 2097 /** 2098 * __cfg80211_send_disassoc - notification of processed disassociation 2099 * @dev: network device 2100 * @buf: disassociation response frame (header + body) 2101 * @len: length of the frame data 2102 * 2103 * Like cfg80211_send_disassoc(), but doesn't take the wdev lock. 2104 */ 2105 void __cfg80211_send_disassoc(struct net_device *dev, const u8 *buf, 2106 size_t len); 2107 2108 /** 2109 * cfg80211_michael_mic_failure - notification of Michael MIC failure (TKIP) 2110 * @dev: network device 2111 * @addr: The source MAC address of the frame 2112 * @key_type: The key type that the received frame used 2113 * @key_id: Key identifier (0..3) 2114 * @tsc: The TSC value of the frame that generated the MIC failure (6 octets) 2115 * @gfp: allocation flags 2116 * 2117 * This function is called whenever the local MAC detects a MIC failure in a 2118 * received frame. This matches with MLME-MICHAELMICFAILURE.indication() 2119 * primitive. 2120 */ 2121 void cfg80211_michael_mic_failure(struct net_device *dev, const u8 *addr, 2122 enum nl80211_key_type key_type, int key_id, 2123 const u8 *tsc, gfp_t gfp); 2124 2125 /** 2126 * cfg80211_ibss_joined - notify cfg80211 that device joined an IBSS 2127 * 2128 * @dev: network device 2129 * @bssid: the BSSID of the IBSS joined 2130 * @gfp: allocation flags 2131 * 2132 * This function notifies cfg80211 that the device joined an IBSS or 2133 * switched to a different BSSID. Before this function can be called, 2134 * either a beacon has to have been received from the IBSS, or one of 2135 * the cfg80211_inform_bss{,_frame} functions must have been called 2136 * with the locally generated beacon -- this guarantees that there is 2137 * always a scan result for this IBSS. cfg80211 will handle the rest. 2138 */ 2139 void cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid, gfp_t gfp); 2140 2141 /** 2142 * wiphy_rfkill_set_hw_state - notify cfg80211 about hw block state 2143 * @wiphy: the wiphy 2144 * @blocked: block status 2145 */ 2146 void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked); 2147 2148 /** 2149 * wiphy_rfkill_start_polling - start polling rfkill 2150 * @wiphy: the wiphy 2151 */ 2152 void wiphy_rfkill_start_polling(struct wiphy *wiphy); 2153 2154 /** 2155 * wiphy_rfkill_stop_polling - stop polling rfkill 2156 * @wiphy: the wiphy 2157 */ 2158 void wiphy_rfkill_stop_polling(struct wiphy *wiphy); 2159 2160 #ifdef CONFIG_NL80211_TESTMODE 2161 /** 2162 * cfg80211_testmode_alloc_reply_skb - allocate testmode reply 2163 * @wiphy: the wiphy 2164 * @approxlen: an upper bound of the length of the data that will 2165 * be put into the skb 2166 * 2167 * This function allocates and pre-fills an skb for a reply to 2168 * the testmode command. Since it is intended for a reply, calling 2169 * it outside of the @testmode_cmd operation is invalid. 2170 * 2171 * The returned skb (or %NULL if any errors happen) is pre-filled 2172 * with the wiphy index and set up in a way that any data that is 2173 * put into the skb (with skb_put(), nla_put() or similar) will end 2174 * up being within the %NL80211_ATTR_TESTDATA attribute, so all that 2175 * needs to be done with the skb is adding data for the corresponding 2176 * userspace tool which can then read that data out of the testdata 2177 * attribute. You must not modify the skb in any other way. 2178 * 2179 * When done, call cfg80211_testmode_reply() with the skb and return 2180 * its error code as the result of the @testmode_cmd operation. 2181 */ 2182 struct sk_buff *cfg80211_testmode_alloc_reply_skb(struct wiphy *wiphy, 2183 int approxlen); 2184 2185 /** 2186 * cfg80211_testmode_reply - send the reply skb 2187 * @skb: The skb, must have been allocated with 2188 * cfg80211_testmode_alloc_reply_skb() 2189 * 2190 * Returns an error code or 0 on success, since calling this 2191 * function will usually be the last thing before returning 2192 * from the @testmode_cmd you should return the error code. 2193 * Note that this function consumes the skb regardless of the 2194 * return value. 2195 */ 2196 int cfg80211_testmode_reply(struct sk_buff *skb); 2197 2198 /** 2199 * cfg80211_testmode_alloc_event_skb - allocate testmode event 2200 * @wiphy: the wiphy 2201 * @approxlen: an upper bound of the length of the data that will 2202 * be put into the skb 2203 * @gfp: allocation flags 2204 * 2205 * This function allocates and pre-fills an skb for an event on the 2206 * testmode multicast group. 2207 * 2208 * The returned skb (or %NULL if any errors happen) is set up in the 2209 * same way as with cfg80211_testmode_alloc_reply_skb() but prepared 2210 * for an event. As there, you should simply add data to it that will 2211 * then end up in the %NL80211_ATTR_TESTDATA attribute. Again, you must 2212 * not modify the skb in any other way. 2213 * 2214 * When done filling the skb, call cfg80211_testmode_event() with the 2215 * skb to send the event. 2216 */ 2217 struct sk_buff *cfg80211_testmode_alloc_event_skb(struct wiphy *wiphy, 2218 int approxlen, gfp_t gfp); 2219 2220 /** 2221 * cfg80211_testmode_event - send the event 2222 * @skb: The skb, must have been allocated with 2223 * cfg80211_testmode_alloc_event_skb() 2224 * @gfp: allocation flags 2225 * 2226 * This function sends the given @skb, which must have been allocated 2227 * by cfg80211_testmode_alloc_event_skb(), as an event. It always 2228 * consumes it. 2229 */ 2230 void cfg80211_testmode_event(struct sk_buff *skb, gfp_t gfp); 2231 2232 #define CFG80211_TESTMODE_CMD(cmd) .testmode_cmd = (cmd), 2233 #else 2234 #define CFG80211_TESTMODE_CMD(cmd) 2235 #endif 2236 2237 /** 2238 * cfg80211_connect_result - notify cfg80211 of connection result 2239 * 2240 * @dev: network device 2241 * @bssid: the BSSID of the AP 2242 * @req_ie: association request IEs (maybe be %NULL) 2243 * @req_ie_len: association request IEs length 2244 * @resp_ie: association response IEs (may be %NULL) 2245 * @resp_ie_len: assoc response IEs length 2246 * @status: status code, 0 for successful connection, use 2247 * %WLAN_STATUS_UNSPECIFIED_FAILURE if your device cannot give you 2248 * the real status code for failures. 2249 * @gfp: allocation flags 2250 * 2251 * It should be called by the underlying driver whenever connect() has 2252 * succeeded. 2253 */ 2254 void cfg80211_connect_result(struct net_device *dev, const u8 *bssid, 2255 const u8 *req_ie, size_t req_ie_len, 2256 const u8 *resp_ie, size_t resp_ie_len, 2257 u16 status, gfp_t gfp); 2258 2259 /** 2260 * cfg80211_roamed - notify cfg80211 of roaming 2261 * 2262 * @dev: network device 2263 * @bssid: the BSSID of the new AP 2264 * @req_ie: association request IEs (maybe be %NULL) 2265 * @req_ie_len: association request IEs length 2266 * @resp_ie: association response IEs (may be %NULL) 2267 * @resp_ie_len: assoc response IEs length 2268 * @gfp: allocation flags 2269 * 2270 * It should be called by the underlying driver whenever it roamed 2271 * from one AP to another while connected. 2272 */ 2273 void cfg80211_roamed(struct net_device *dev, const u8 *bssid, 2274 const u8 *req_ie, size_t req_ie_len, 2275 const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp); 2276 2277 /** 2278 * cfg80211_disconnected - notify cfg80211 that connection was dropped 2279 * 2280 * @dev: network device 2281 * @ie: information elements of the deauth/disassoc frame (may be %NULL) 2282 * @ie_len: length of IEs 2283 * @reason: reason code for the disconnection, set it to 0 if unknown 2284 * @gfp: allocation flags 2285 * 2286 * After it calls this function, the driver should enter an idle state 2287 * and not try to connect to any AP any more. 2288 */ 2289 void cfg80211_disconnected(struct net_device *dev, u16 reason, 2290 u8 *ie, size_t ie_len, gfp_t gfp); 2291 2292 /** 2293 * cfg80211_ready_on_channel - notification of remain_on_channel start 2294 * @dev: network device 2295 * @cookie: the request cookie 2296 * @chan: The current channel (from remain_on_channel request) 2297 * @channel_type: Channel type 2298 * @duration: Duration in milliseconds that the driver intents to remain on the 2299 * channel 2300 * @gfp: allocation flags 2301 */ 2302 void cfg80211_ready_on_channel(struct net_device *dev, u64 cookie, 2303 struct ieee80211_channel *chan, 2304 enum nl80211_channel_type channel_type, 2305 unsigned int duration, gfp_t gfp); 2306 2307 /** 2308 * cfg80211_remain_on_channel_expired - remain_on_channel duration expired 2309 * @dev: network device 2310 * @cookie: the request cookie 2311 * @chan: The current channel (from remain_on_channel request) 2312 * @channel_type: Channel type 2313 * @gfp: allocation flags 2314 */ 2315 void cfg80211_remain_on_channel_expired(struct net_device *dev, 2316 u64 cookie, 2317 struct ieee80211_channel *chan, 2318 enum nl80211_channel_type channel_type, 2319 gfp_t gfp); 2320 2321 2322 /** 2323 * cfg80211_new_sta - notify userspace about station 2324 * 2325 * @dev: the netdev 2326 * @mac_addr: the station's address 2327 * @sinfo: the station information 2328 * @gfp: allocation flags 2329 */ 2330 void cfg80211_new_sta(struct net_device *dev, const u8 *mac_addr, 2331 struct station_info *sinfo, gfp_t gfp); 2332 2333 /** 2334 * cfg80211_rx_action - notification of received, unprocessed Action frame 2335 * @dev: network device 2336 * @freq: Frequency on which the frame was received in MHz 2337 * @buf: Action frame (header + body) 2338 * @len: length of the frame data 2339 * @gfp: context flags 2340 * Returns %true if a user space application is responsible for rejecting the 2341 * unrecognized Action frame; %false if no such application is registered 2342 * (i.e., the driver is responsible for rejecting the unrecognized Action 2343 * frame) 2344 * 2345 * This function is called whenever an Action frame is received for a station 2346 * mode interface, but is not processed in kernel. 2347 */ 2348 bool cfg80211_rx_action(struct net_device *dev, int freq, const u8 *buf, 2349 size_t len, gfp_t gfp); 2350 2351 /** 2352 * cfg80211_action_tx_status - notification of TX status for Action frame 2353 * @dev: network device 2354 * @cookie: Cookie returned by cfg80211_ops::action() 2355 * @buf: Action frame (header + body) 2356 * @len: length of the frame data 2357 * @ack: Whether frame was acknowledged 2358 * @gfp: context flags 2359 * 2360 * This function is called whenever an Action frame was requested to be 2361 * transmitted with cfg80211_ops::action() to report the TX status of the 2362 * transmission attempt. 2363 */ 2364 void cfg80211_action_tx_status(struct net_device *dev, u64 cookie, 2365 const u8 *buf, size_t len, bool ack, gfp_t gfp); 2366 2367 2368 /** 2369 * cfg80211_cqm_rssi_notify - connection quality monitoring rssi event 2370 * @dev: network device 2371 * @rssi_event: the triggered RSSI event 2372 * @gfp: context flags 2373 * 2374 * This function is called when a configured connection quality monitoring 2375 * rssi threshold reached event occurs. 2376 */ 2377 void cfg80211_cqm_rssi_notify(struct net_device *dev, 2378 enum nl80211_cqm_rssi_threshold_event rssi_event, 2379 gfp_t gfp); 2380 2381 #endif /* __NET_CFG80211_H */ 2382