1 #ifndef __NET_CFG80211_H 2 #define __NET_CFG80211_H 3 /* 4 * 802.11 device and configuration interface 5 * 6 * Copyright 2006-2009 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, 43 IEEE80211_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 */ 515 struct bss_parameters { 516 int use_cts_prot; 517 int use_short_preamble; 518 int use_short_slot_time; 519 u8 *basic_rates; 520 u8 basic_rates_len; 521 }; 522 523 struct mesh_config { 524 /* Timeouts in ms */ 525 /* Mesh plink management parameters */ 526 u16 dot11MeshRetryTimeout; 527 u16 dot11MeshConfirmTimeout; 528 u16 dot11MeshHoldingTimeout; 529 u16 dot11MeshMaxPeerLinks; 530 u8 dot11MeshMaxRetries; 531 u8 dot11MeshTTL; 532 bool auto_open_plinks; 533 /* HWMP parameters */ 534 u8 dot11MeshHWMPmaxPREQretries; 535 u32 path_refresh_time; 536 u16 min_discovery_timeout; 537 u32 dot11MeshHWMPactivePathTimeout; 538 u16 dot11MeshHWMPpreqMinInterval; 539 u16 dot11MeshHWMPnetDiameterTraversalTime; 540 u8 dot11MeshHWMPRootMode; 541 }; 542 543 /** 544 * struct ieee80211_txq_params - TX queue parameters 545 * @queue: TX queue identifier (NL80211_TXQ_Q_*) 546 * @txop: Maximum burst time in units of 32 usecs, 0 meaning disabled 547 * @cwmin: Minimum contention window [a value of the form 2^n-1 in the range 548 * 1..32767] 549 * @cwmax: Maximum contention window [a value of the form 2^n-1 in the range 550 * 1..32767] 551 * @aifs: Arbitration interframe space [0..255] 552 */ 553 struct ieee80211_txq_params { 554 enum nl80211_txq_q queue; 555 u16 txop; 556 u16 cwmin; 557 u16 cwmax; 558 u8 aifs; 559 }; 560 561 /* from net/wireless.h */ 562 struct wiphy; 563 564 /* from net/ieee80211.h */ 565 struct ieee80211_channel; 566 567 /** 568 * struct cfg80211_ssid - SSID description 569 * @ssid: the SSID 570 * @ssid_len: length of the ssid 571 */ 572 struct cfg80211_ssid { 573 u8 ssid[IEEE80211_MAX_SSID_LEN]; 574 u8 ssid_len; 575 }; 576 577 /** 578 * struct cfg80211_scan_request - scan request description 579 * 580 * @ssids: SSIDs to scan for (active scan only) 581 * @n_ssids: number of SSIDs 582 * @channels: channels to scan on. 583 * @n_channels: total number of channels to scan 584 * @ie: optional information element(s) to add into Probe Request or %NULL 585 * @ie_len: length of ie in octets 586 * @wiphy: the wiphy this was for 587 * @dev: the interface 588 */ 589 struct cfg80211_scan_request { 590 struct cfg80211_ssid *ssids; 591 int n_ssids; 592 u32 n_channels; 593 const u8 *ie; 594 size_t ie_len; 595 596 /* internal */ 597 struct wiphy *wiphy; 598 struct net_device *dev; 599 bool aborted; 600 601 /* keep last */ 602 struct ieee80211_channel *channels[0]; 603 }; 604 605 /** 606 * enum cfg80211_signal_type - signal type 607 * 608 * @CFG80211_SIGNAL_TYPE_NONE: no signal strength information available 609 * @CFG80211_SIGNAL_TYPE_MBM: signal strength in mBm (100*dBm) 610 * @CFG80211_SIGNAL_TYPE_UNSPEC: signal strength, increasing from 0 through 100 611 */ 612 enum cfg80211_signal_type { 613 CFG80211_SIGNAL_TYPE_NONE, 614 CFG80211_SIGNAL_TYPE_MBM, 615 CFG80211_SIGNAL_TYPE_UNSPEC, 616 }; 617 618 /** 619 * struct cfg80211_bss - BSS description 620 * 621 * This structure describes a BSS (which may also be a mesh network) 622 * for use in scan results and similar. 623 * 624 * @bssid: BSSID of the BSS 625 * @tsf: timestamp of last received update 626 * @beacon_interval: the beacon interval as from the frame 627 * @capability: the capability field in host byte order 628 * @information_elements: the information elements (Note that there 629 * is no guarantee that these are well-formed!) 630 * @len_information_elements: total length of the information elements 631 * @signal: signal strength value (type depends on the wiphy's signal_type) 632 * @free_priv: function pointer to free private data 633 * @priv: private area for driver use, has at least wiphy->bss_priv_size bytes 634 */ 635 struct cfg80211_bss { 636 struct ieee80211_channel *channel; 637 638 u8 bssid[ETH_ALEN]; 639 u64 tsf; 640 u16 beacon_interval; 641 u16 capability; 642 u8 *information_elements; 643 size_t len_information_elements; 644 645 s32 signal; 646 647 void (*free_priv)(struct cfg80211_bss *bss); 648 u8 priv[0] __attribute__((__aligned__(sizeof(void *)))); 649 }; 650 651 /** 652 * ieee80211_bss_get_ie - find IE with given ID 653 * @bss: the bss to search 654 * @ie: the IE ID 655 * Returns %NULL if not found. 656 */ 657 const u8 *ieee80211_bss_get_ie(struct cfg80211_bss *bss, u8 ie); 658 659 660 /** 661 * struct cfg80211_crypto_settings - Crypto settings 662 * @wpa_versions: indicates which, if any, WPA versions are enabled 663 * (from enum nl80211_wpa_versions) 664 * @cipher_group: group key cipher suite (or 0 if unset) 665 * @n_ciphers_pairwise: number of AP supported unicast ciphers 666 * @ciphers_pairwise: unicast key cipher suites 667 * @n_akm_suites: number of AKM suites 668 * @akm_suites: AKM suites 669 * @control_port: Whether user space controls IEEE 802.1X port, i.e., 670 * sets/clears %NL80211_STA_FLAG_AUTHORIZED. If true, the driver is 671 * required to assume that the port is unauthorized until authorized by 672 * user space. Otherwise, port is marked authorized by default. 673 */ 674 struct cfg80211_crypto_settings { 675 u32 wpa_versions; 676 u32 cipher_group; 677 int n_ciphers_pairwise; 678 u32 ciphers_pairwise[NL80211_MAX_NR_CIPHER_SUITES]; 679 int n_akm_suites; 680 u32 akm_suites[NL80211_MAX_NR_AKM_SUITES]; 681 bool control_port; 682 }; 683 684 /** 685 * struct cfg80211_auth_request - Authentication request data 686 * 687 * This structure provides information needed to complete IEEE 802.11 688 * authentication. 689 * 690 * @bss: The BSS to authenticate with. 691 * @auth_type: Authentication type (algorithm) 692 * @ie: Extra IEs to add to Authentication frame or %NULL 693 * @ie_len: Length of ie buffer in octets 694 * @key_len: length of WEP key for shared key authentication 695 * @key_idx: index of WEP key for shared key authentication 696 * @key: WEP key for shared key authentication 697 */ 698 struct cfg80211_auth_request { 699 struct cfg80211_bss *bss; 700 const u8 *ie; 701 size_t ie_len; 702 enum nl80211_auth_type auth_type; 703 const u8 *key; 704 u8 key_len, key_idx; 705 }; 706 707 /** 708 * struct cfg80211_assoc_request - (Re)Association request data 709 * 710 * This structure provides information needed to complete IEEE 802.11 711 * (re)association. 712 * @bss: The BSS to associate with. 713 * @ie: Extra IEs to add to (Re)Association Request frame or %NULL 714 * @ie_len: Length of ie buffer in octets 715 * @use_mfp: Use management frame protection (IEEE 802.11w) in this association 716 * @crypto: crypto settings 717 * @prev_bssid: previous BSSID, if not %NULL use reassociate frame 718 */ 719 struct cfg80211_assoc_request { 720 struct cfg80211_bss *bss; 721 const u8 *ie, *prev_bssid; 722 size_t ie_len; 723 struct cfg80211_crypto_settings crypto; 724 bool use_mfp; 725 }; 726 727 /** 728 * struct cfg80211_deauth_request - Deauthentication request data 729 * 730 * This structure provides information needed to complete IEEE 802.11 731 * deauthentication. 732 * 733 * @bss: the BSS to deauthenticate from 734 * @ie: Extra IEs to add to Deauthentication frame or %NULL 735 * @ie_len: Length of ie buffer in octets 736 * @reason_code: The reason code for the deauthentication 737 */ 738 struct cfg80211_deauth_request { 739 struct cfg80211_bss *bss; 740 const u8 *ie; 741 size_t ie_len; 742 u16 reason_code; 743 }; 744 745 /** 746 * struct cfg80211_disassoc_request - Disassociation request data 747 * 748 * This structure provides information needed to complete IEEE 802.11 749 * disassocation. 750 * 751 * @bss: the BSS to disassociate from 752 * @ie: Extra IEs to add to Disassociation frame or %NULL 753 * @ie_len: Length of ie buffer in octets 754 * @reason_code: The reason code for the disassociation 755 */ 756 struct cfg80211_disassoc_request { 757 struct cfg80211_bss *bss; 758 const u8 *ie; 759 size_t ie_len; 760 u16 reason_code; 761 }; 762 763 /** 764 * struct cfg80211_ibss_params - IBSS parameters 765 * 766 * This structure defines the IBSS parameters for the join_ibss() 767 * method. 768 * 769 * @ssid: The SSID, will always be non-null. 770 * @ssid_len: The length of the SSID, will always be non-zero. 771 * @bssid: Fixed BSSID requested, maybe be %NULL, if set do not 772 * search for IBSSs with a different BSSID. 773 * @channel: The channel to use if no IBSS can be found to join. 774 * @channel_fixed: The channel should be fixed -- do not search for 775 * IBSSs to join on other channels. 776 * @ie: information element(s) to include in the beacon 777 * @ie_len: length of that 778 * @beacon_interval: beacon interval to use 779 * @privacy: this is a protected network, keys will be configured 780 * after joining 781 */ 782 struct cfg80211_ibss_params { 783 u8 *ssid; 784 u8 *bssid; 785 struct ieee80211_channel *channel; 786 u8 *ie; 787 u8 ssid_len, ie_len; 788 u16 beacon_interval; 789 bool channel_fixed; 790 bool privacy; 791 }; 792 793 /** 794 * struct cfg80211_connect_params - Connection parameters 795 * 796 * This structure provides information needed to complete IEEE 802.11 797 * authentication and association. 798 * 799 * @channel: The channel to use or %NULL if not specified (auto-select based 800 * on scan results) 801 * @bssid: The AP BSSID or %NULL if not specified (auto-select based on scan 802 * results) 803 * @ssid: SSID 804 * @ssid_len: Length of ssid in octets 805 * @auth_type: Authentication type (algorithm) 806 * @assoc_ie: IEs for association request 807 * @assoc_ie_len: Length of assoc_ie in octets 808 * @privacy: indicates whether privacy-enabled APs should be used 809 * @crypto: crypto settings 810 * @key_len: length of WEP key for shared key authentication 811 * @key_idx: index of WEP key for shared key authentication 812 * @key: WEP key for shared key authentication 813 */ 814 struct cfg80211_connect_params { 815 struct ieee80211_channel *channel; 816 u8 *bssid; 817 u8 *ssid; 818 size_t ssid_len; 819 enum nl80211_auth_type auth_type; 820 u8 *ie; 821 size_t ie_len; 822 bool privacy; 823 struct cfg80211_crypto_settings crypto; 824 const u8 *key; 825 u8 key_len, key_idx; 826 }; 827 828 /** 829 * enum wiphy_params_flags - set_wiphy_params bitfield values 830 * WIPHY_PARAM_RETRY_SHORT: wiphy->retry_short has changed 831 * WIPHY_PARAM_RETRY_LONG: wiphy->retry_long has changed 832 * WIPHY_PARAM_FRAG_THRESHOLD: wiphy->frag_threshold has changed 833 * WIPHY_PARAM_RTS_THRESHOLD: wiphy->rts_threshold has changed 834 */ 835 enum wiphy_params_flags { 836 WIPHY_PARAM_RETRY_SHORT = 1 << 0, 837 WIPHY_PARAM_RETRY_LONG = 1 << 1, 838 WIPHY_PARAM_FRAG_THRESHOLD = 1 << 2, 839 WIPHY_PARAM_RTS_THRESHOLD = 1 << 3, 840 }; 841 842 /** 843 * enum tx_power_setting - TX power adjustment 844 * 845 * @TX_POWER_AUTOMATIC: the dbm parameter is ignored 846 * @TX_POWER_LIMITED: limit TX power by the dbm parameter 847 * @TX_POWER_FIXED: fix TX power to the dbm parameter 848 */ 849 enum tx_power_setting { 850 TX_POWER_AUTOMATIC, 851 TX_POWER_LIMITED, 852 TX_POWER_FIXED, 853 }; 854 855 /* 856 * cfg80211_bitrate_mask - masks for bitrate control 857 */ 858 struct cfg80211_bitrate_mask { 859 /* 860 * As discussed in Berlin, this struct really 861 * should look like this: 862 863 struct { 864 u32 legacy; 865 u8 mcs[IEEE80211_HT_MCS_MASK_LEN]; 866 } control[IEEE80211_NUM_BANDS]; 867 868 * Since we can always fix in-kernel users, let's keep 869 * it simpler for now: 870 */ 871 u32 fixed; /* fixed bitrate, 0 == not fixed */ 872 u32 maxrate; /* in kbps, 0 == no limit */ 873 }; 874 /** 875 * struct cfg80211_pmksa - PMK Security Association 876 * 877 * This structure is passed to the set/del_pmksa() method for PMKSA 878 * caching. 879 * 880 * @bssid: The AP's BSSID. 881 * @pmkid: The PMK material itself. 882 */ 883 struct cfg80211_pmksa { 884 u8 *bssid; 885 u8 *pmkid; 886 }; 887 888 /** 889 * struct cfg80211_ops - backend description for wireless configuration 890 * 891 * This struct is registered by fullmac card drivers and/or wireless stacks 892 * in order to handle configuration requests on their interfaces. 893 * 894 * All callbacks except where otherwise noted should return 0 895 * on success or a negative error code. 896 * 897 * All operations are currently invoked under rtnl for consistency with the 898 * wireless extensions but this is subject to reevaluation as soon as this 899 * code is used more widely and we have a first user without wext. 900 * 901 * @suspend: wiphy device needs to be suspended 902 * @resume: wiphy device needs to be resumed 903 * 904 * @add_virtual_intf: create a new virtual interface with the given name, 905 * must set the struct wireless_dev's iftype. Beware: You must create 906 * the new netdev in the wiphy's network namespace! 907 * 908 * @del_virtual_intf: remove the virtual interface determined by ifindex. 909 * 910 * @change_virtual_intf: change type/configuration of virtual interface, 911 * keep the struct wireless_dev's iftype updated. 912 * 913 * @add_key: add a key with the given parameters. @mac_addr will be %NULL 914 * when adding a group key. 915 * 916 * @get_key: get information about the key with the given parameters. 917 * @mac_addr will be %NULL when requesting information for a group 918 * key. All pointers given to the @callback function need not be valid 919 * after it returns. This function should return an error if it is 920 * not possible to retrieve the key, -ENOENT if it doesn't exist. 921 * 922 * @del_key: remove a key given the @mac_addr (%NULL for a group key) 923 * and @key_index, return -ENOENT if the key doesn't exist. 924 * 925 * @set_default_key: set the default key on an interface 926 * 927 * @set_default_mgmt_key: set the default management frame key on an interface 928 * 929 * @add_beacon: Add a beacon with given parameters, @head, @interval 930 * and @dtim_period will be valid, @tail is optional. 931 * @set_beacon: Change the beacon parameters for an access point mode 932 * interface. This should reject the call when no beacon has been 933 * configured. 934 * @del_beacon: Remove beacon configuration and stop sending the beacon. 935 * 936 * @add_station: Add a new station. 937 * 938 * @del_station: Remove a station; @mac may be NULL to remove all stations. 939 * 940 * @change_station: Modify a given station. 941 * 942 * @get_mesh_params: Put the current mesh parameters into *params 943 * 944 * @set_mesh_params: Set mesh parameters. 945 * The mask is a bitfield which tells us which parameters to 946 * set, and which to leave alone. 947 * 948 * @set_mesh_cfg: set mesh parameters (by now, just mesh id) 949 * 950 * @change_bss: Modify parameters for a given BSS. 951 * 952 * @set_txq_params: Set TX queue parameters 953 * 954 * @set_channel: Set channel 955 * 956 * @scan: Request to do a scan. If returning zero, the scan request is given 957 * the driver, and will be valid until passed to cfg80211_scan_done(). 958 * For scan results, call cfg80211_inform_bss(); you can call this outside 959 * the scan/scan_done bracket too. 960 * 961 * @auth: Request to authenticate with the specified peer 962 * @assoc: Request to (re)associate with the specified peer 963 * @deauth: Request to deauthenticate from the specified peer 964 * @disassoc: Request to disassociate from the specified peer 965 * 966 * @connect: Connect to the ESS with the specified parameters. When connected, 967 * call cfg80211_connect_result() with status code %WLAN_STATUS_SUCCESS. 968 * If the connection fails for some reason, call cfg80211_connect_result() 969 * with the status from the AP. 970 * @disconnect: Disconnect from the BSS/ESS. 971 * 972 * @join_ibss: Join the specified IBSS (or create if necessary). Once done, call 973 * cfg80211_ibss_joined(), also call that function when changing BSSID due 974 * to a merge. 975 * @leave_ibss: Leave the IBSS. 976 * 977 * @set_wiphy_params: Notify that wiphy parameters have changed; 978 * @changed bitfield (see &enum wiphy_params_flags) describes which values 979 * have changed. The actual parameter values are available in 980 * struct wiphy. If returning an error, no value should be changed. 981 * 982 * @set_tx_power: set the transmit power according to the parameters 983 * @get_tx_power: store the current TX power into the dbm variable; 984 * return 0 if successful 985 * 986 * @rfkill_poll: polls the hw rfkill line, use cfg80211 reporting 987 * functions to adjust rfkill hw state 988 * 989 * @dump_survey: get site survey information. 990 * 991 * @testmode_cmd: run a test mode command 992 * 993 * @set_pmksa: Cache a PMKID for a BSSID. This is mostly useful for fullmac 994 * devices running firmwares capable of generating the (re) association 995 * RSN IE. It allows for faster roaming between WPA2 BSSIDs. 996 * @del_pmksa: Delete a cached PMKID. 997 * @flush_pmksa: Flush all cached PMKIDs. 998 * 999 */ 1000 struct cfg80211_ops { 1001 int (*suspend)(struct wiphy *wiphy); 1002 int (*resume)(struct wiphy *wiphy); 1003 1004 int (*add_virtual_intf)(struct wiphy *wiphy, char *name, 1005 enum nl80211_iftype type, u32 *flags, 1006 struct vif_params *params); 1007 int (*del_virtual_intf)(struct wiphy *wiphy, struct net_device *dev); 1008 int (*change_virtual_intf)(struct wiphy *wiphy, 1009 struct net_device *dev, 1010 enum nl80211_iftype type, u32 *flags, 1011 struct vif_params *params); 1012 1013 int (*add_key)(struct wiphy *wiphy, struct net_device *netdev, 1014 u8 key_index, const u8 *mac_addr, 1015 struct key_params *params); 1016 int (*get_key)(struct wiphy *wiphy, struct net_device *netdev, 1017 u8 key_index, const u8 *mac_addr, void *cookie, 1018 void (*callback)(void *cookie, struct key_params*)); 1019 int (*del_key)(struct wiphy *wiphy, struct net_device *netdev, 1020 u8 key_index, const u8 *mac_addr); 1021 int (*set_default_key)(struct wiphy *wiphy, 1022 struct net_device *netdev, 1023 u8 key_index); 1024 int (*set_default_mgmt_key)(struct wiphy *wiphy, 1025 struct net_device *netdev, 1026 u8 key_index); 1027 1028 int (*add_beacon)(struct wiphy *wiphy, struct net_device *dev, 1029 struct beacon_parameters *info); 1030 int (*set_beacon)(struct wiphy *wiphy, struct net_device *dev, 1031 struct beacon_parameters *info); 1032 int (*del_beacon)(struct wiphy *wiphy, struct net_device *dev); 1033 1034 1035 int (*add_station)(struct wiphy *wiphy, struct net_device *dev, 1036 u8 *mac, struct station_parameters *params); 1037 int (*del_station)(struct wiphy *wiphy, struct net_device *dev, 1038 u8 *mac); 1039 int (*change_station)(struct wiphy *wiphy, struct net_device *dev, 1040 u8 *mac, struct station_parameters *params); 1041 int (*get_station)(struct wiphy *wiphy, struct net_device *dev, 1042 u8 *mac, struct station_info *sinfo); 1043 int (*dump_station)(struct wiphy *wiphy, struct net_device *dev, 1044 int idx, u8 *mac, struct station_info *sinfo); 1045 1046 int (*add_mpath)(struct wiphy *wiphy, struct net_device *dev, 1047 u8 *dst, u8 *next_hop); 1048 int (*del_mpath)(struct wiphy *wiphy, struct net_device *dev, 1049 u8 *dst); 1050 int (*change_mpath)(struct wiphy *wiphy, struct net_device *dev, 1051 u8 *dst, u8 *next_hop); 1052 int (*get_mpath)(struct wiphy *wiphy, struct net_device *dev, 1053 u8 *dst, u8 *next_hop, 1054 struct mpath_info *pinfo); 1055 int (*dump_mpath)(struct wiphy *wiphy, struct net_device *dev, 1056 int idx, u8 *dst, u8 *next_hop, 1057 struct mpath_info *pinfo); 1058 int (*get_mesh_params)(struct wiphy *wiphy, 1059 struct net_device *dev, 1060 struct mesh_config *conf); 1061 int (*set_mesh_params)(struct wiphy *wiphy, 1062 struct net_device *dev, 1063 const struct mesh_config *nconf, u32 mask); 1064 int (*change_bss)(struct wiphy *wiphy, struct net_device *dev, 1065 struct bss_parameters *params); 1066 1067 int (*set_txq_params)(struct wiphy *wiphy, 1068 struct ieee80211_txq_params *params); 1069 1070 int (*set_channel)(struct wiphy *wiphy, 1071 struct ieee80211_channel *chan, 1072 enum nl80211_channel_type channel_type); 1073 1074 int (*scan)(struct wiphy *wiphy, struct net_device *dev, 1075 struct cfg80211_scan_request *request); 1076 1077 int (*auth)(struct wiphy *wiphy, struct net_device *dev, 1078 struct cfg80211_auth_request *req); 1079 int (*assoc)(struct wiphy *wiphy, struct net_device *dev, 1080 struct cfg80211_assoc_request *req); 1081 int (*deauth)(struct wiphy *wiphy, struct net_device *dev, 1082 struct cfg80211_deauth_request *req, 1083 void *cookie); 1084 int (*disassoc)(struct wiphy *wiphy, struct net_device *dev, 1085 struct cfg80211_disassoc_request *req, 1086 void *cookie); 1087 1088 int (*connect)(struct wiphy *wiphy, struct net_device *dev, 1089 struct cfg80211_connect_params *sme); 1090 int (*disconnect)(struct wiphy *wiphy, struct net_device *dev, 1091 u16 reason_code); 1092 1093 int (*join_ibss)(struct wiphy *wiphy, struct net_device *dev, 1094 struct cfg80211_ibss_params *params); 1095 int (*leave_ibss)(struct wiphy *wiphy, struct net_device *dev); 1096 1097 int (*set_wiphy_params)(struct wiphy *wiphy, u32 changed); 1098 1099 int (*set_tx_power)(struct wiphy *wiphy, 1100 enum tx_power_setting type, int dbm); 1101 int (*get_tx_power)(struct wiphy *wiphy, int *dbm); 1102 1103 int (*set_wds_peer)(struct wiphy *wiphy, struct net_device *dev, 1104 u8 *addr); 1105 1106 void (*rfkill_poll)(struct wiphy *wiphy); 1107 1108 #ifdef CONFIG_NL80211_TESTMODE 1109 int (*testmode_cmd)(struct wiphy *wiphy, void *data, int len); 1110 #endif 1111 1112 int (*set_bitrate_mask)(struct wiphy *wiphy, 1113 struct net_device *dev, 1114 const u8 *peer, 1115 const struct cfg80211_bitrate_mask *mask); 1116 1117 int (*dump_survey)(struct wiphy *wiphy, struct net_device *netdev, 1118 int idx, struct survey_info *info); 1119 1120 int (*set_pmksa)(struct wiphy *wiphy, struct net_device *netdev, 1121 struct cfg80211_pmksa *pmksa); 1122 int (*del_pmksa)(struct wiphy *wiphy, struct net_device *netdev, 1123 struct cfg80211_pmksa *pmksa); 1124 int (*flush_pmksa)(struct wiphy *wiphy, struct net_device *netdev); 1125 1126 /* some temporary stuff to finish wext */ 1127 int (*set_power_mgmt)(struct wiphy *wiphy, struct net_device *dev, 1128 bool enabled, int timeout); 1129 }; 1130 1131 /* 1132 * wireless hardware and networking interfaces structures 1133 * and registration/helper functions 1134 */ 1135 1136 /** 1137 * enum wiphy_flags - wiphy capability flags 1138 * 1139 * @WIPHY_FLAG_CUSTOM_REGULATORY: tells us the driver for this device 1140 * has its own custom regulatory domain and cannot identify the 1141 * ISO / IEC 3166 alpha2 it belongs to. When this is enabled 1142 * we will disregard the first regulatory hint (when the 1143 * initiator is %REGDOM_SET_BY_CORE). 1144 * @WIPHY_FLAG_STRICT_REGULATORY: tells us the driver for this device will 1145 * ignore regulatory domain settings until it gets its own regulatory 1146 * domain via its regulatory_hint(). After its gets its own regulatory 1147 * domain it will only allow further regulatory domain settings to 1148 * further enhance compliance. For example if channel 13 and 14 are 1149 * disabled by this regulatory domain no user regulatory domain can 1150 * enable these channels at a later time. This can be used for devices 1151 * which do not have calibration information gauranteed for frequencies 1152 * or settings outside of its regulatory domain. 1153 * @WIPHY_FLAG_DISABLE_BEACON_HINTS: enable this if your driver needs to ensure 1154 * that passive scan flags and beaconing flags may not be lifted by 1155 * cfg80211 due to regulatory beacon hints. For more information on beacon 1156 * hints read the documenation for regulatory_hint_found_beacon() 1157 * @WIPHY_FLAG_NETNS_OK: if not set, do not allow changing the netns of this 1158 * wiphy at all 1159 * @WIPHY_FLAG_PS_ON_BY_DEFAULT: if set to true, powersave will be enabled 1160 * by default -- this flag will be set depending on the kernel's default 1161 * on wiphy_new(), but can be changed by the driver if it has a good 1162 * reason to override the default 1163 * @WIPHY_FLAG_4ADDR_AP: supports 4addr mode even on AP (with a single station 1164 * on a VLAN interface) 1165 * @WIPHY_FLAG_4ADDR_STATION: supports 4addr mode even as a station 1166 */ 1167 enum wiphy_flags { 1168 WIPHY_FLAG_CUSTOM_REGULATORY = BIT(0), 1169 WIPHY_FLAG_STRICT_REGULATORY = BIT(1), 1170 WIPHY_FLAG_DISABLE_BEACON_HINTS = BIT(2), 1171 WIPHY_FLAG_NETNS_OK = BIT(3), 1172 WIPHY_FLAG_PS_ON_BY_DEFAULT = BIT(4), 1173 WIPHY_FLAG_4ADDR_AP = BIT(5), 1174 WIPHY_FLAG_4ADDR_STATION = BIT(6), 1175 }; 1176 1177 /** 1178 * struct wiphy - wireless hardware description 1179 * @idx: the wiphy index assigned to this item 1180 * @class_dev: the class device representing /sys/class/ieee80211/<wiphy-name> 1181 * @reg_notifier: the driver's regulatory notification callback 1182 * @regd: the driver's regulatory domain, if one was requested via 1183 * the regulatory_hint() API. This can be used by the driver 1184 * on the reg_notifier() if it chooses to ignore future 1185 * regulatory domain changes caused by other drivers. 1186 * @signal_type: signal type reported in &struct cfg80211_bss. 1187 * @cipher_suites: supported cipher suites 1188 * @n_cipher_suites: number of supported cipher suites 1189 * @retry_short: Retry limit for short frames (dot11ShortRetryLimit) 1190 * @retry_long: Retry limit for long frames (dot11LongRetryLimit) 1191 * @frag_threshold: Fragmentation threshold (dot11FragmentationThreshold); 1192 * -1 = fragmentation disabled, only odd values >= 256 used 1193 * @rts_threshold: RTS threshold (dot11RTSThreshold); -1 = RTS/CTS disabled 1194 * @net: the network namespace this wiphy currently lives in 1195 */ 1196 struct wiphy { 1197 /* assign these fields before you register the wiphy */ 1198 1199 /* permanent MAC address */ 1200 u8 perm_addr[ETH_ALEN]; 1201 1202 /* Supported interface modes, OR together BIT(NL80211_IFTYPE_...) */ 1203 u16 interface_modes; 1204 1205 u32 flags; 1206 1207 enum cfg80211_signal_type signal_type; 1208 1209 int bss_priv_size; 1210 u8 max_scan_ssids; 1211 u16 max_scan_ie_len; 1212 1213 int n_cipher_suites; 1214 const u32 *cipher_suites; 1215 1216 u8 retry_short; 1217 u8 retry_long; 1218 u32 frag_threshold; 1219 u32 rts_threshold; 1220 1221 char fw_version[ETHTOOL_BUSINFO_LEN]; 1222 u32 hw_version; 1223 1224 u8 max_num_pmkids; 1225 1226 /* If multiple wiphys are registered and you're handed e.g. 1227 * a regular netdev with assigned ieee80211_ptr, you won't 1228 * know whether it points to a wiphy your driver has registered 1229 * or not. Assign this to something global to your driver to 1230 * help determine whether you own this wiphy or not. */ 1231 const void *privid; 1232 1233 struct ieee80211_supported_band *bands[IEEE80211_NUM_BANDS]; 1234 1235 /* Lets us get back the wiphy on the callback */ 1236 int (*reg_notifier)(struct wiphy *wiphy, 1237 struct regulatory_request *request); 1238 1239 /* fields below are read-only, assigned by cfg80211 */ 1240 1241 const struct ieee80211_regdomain *regd; 1242 1243 /* the item in /sys/class/ieee80211/ points to this, 1244 * you need use set_wiphy_dev() (see below) */ 1245 struct device dev; 1246 1247 /* dir in debugfs: ieee80211/<wiphyname> */ 1248 struct dentry *debugfsdir; 1249 1250 #ifdef CONFIG_NET_NS 1251 /* the network namespace this phy lives in currently */ 1252 struct net *_net; 1253 #endif 1254 1255 #ifdef CONFIG_CFG80211_WEXT 1256 const struct iw_handler_def *wext; 1257 #endif 1258 1259 char priv[0] __attribute__((__aligned__(NETDEV_ALIGN))); 1260 }; 1261 1262 #ifdef CONFIG_NET_NS 1263 static inline struct net *wiphy_net(struct wiphy *wiphy) 1264 { 1265 return wiphy->_net; 1266 } 1267 1268 static inline void wiphy_net_set(struct wiphy *wiphy, struct net *net) 1269 { 1270 wiphy->_net = net; 1271 } 1272 #else 1273 static inline struct net *wiphy_net(struct wiphy *wiphy) 1274 { 1275 return &init_net; 1276 } 1277 1278 static inline void wiphy_net_set(struct wiphy *wiphy, struct net *net) 1279 { 1280 } 1281 #endif 1282 1283 /** 1284 * wiphy_priv - return priv from wiphy 1285 * 1286 * @wiphy: the wiphy whose priv pointer to return 1287 */ 1288 static inline void *wiphy_priv(struct wiphy *wiphy) 1289 { 1290 BUG_ON(!wiphy); 1291 return &wiphy->priv; 1292 } 1293 1294 /** 1295 * priv_to_wiphy - return the wiphy containing the priv 1296 * 1297 * @priv: a pointer previously returned by wiphy_priv 1298 */ 1299 static inline struct wiphy *priv_to_wiphy(void *priv) 1300 { 1301 BUG_ON(!priv); 1302 return container_of(priv, struct wiphy, priv); 1303 } 1304 1305 /** 1306 * set_wiphy_dev - set device pointer for wiphy 1307 * 1308 * @wiphy: The wiphy whose device to bind 1309 * @dev: The device to parent it to 1310 */ 1311 static inline void set_wiphy_dev(struct wiphy *wiphy, struct device *dev) 1312 { 1313 wiphy->dev.parent = dev; 1314 } 1315 1316 /** 1317 * wiphy_dev - get wiphy dev pointer 1318 * 1319 * @wiphy: The wiphy whose device struct to look up 1320 */ 1321 static inline struct device *wiphy_dev(struct wiphy *wiphy) 1322 { 1323 return wiphy->dev.parent; 1324 } 1325 1326 /** 1327 * wiphy_name - get wiphy name 1328 * 1329 * @wiphy: The wiphy whose name to return 1330 */ 1331 static inline const char *wiphy_name(struct wiphy *wiphy) 1332 { 1333 return dev_name(&wiphy->dev); 1334 } 1335 1336 /** 1337 * wiphy_new - create a new wiphy for use with cfg80211 1338 * 1339 * @ops: The configuration operations for this device 1340 * @sizeof_priv: The size of the private area to allocate 1341 * 1342 * Create a new wiphy and associate the given operations with it. 1343 * @sizeof_priv bytes are allocated for private use. 1344 * 1345 * The returned pointer must be assigned to each netdev's 1346 * ieee80211_ptr for proper operation. 1347 */ 1348 struct wiphy *wiphy_new(const struct cfg80211_ops *ops, int sizeof_priv); 1349 1350 /** 1351 * wiphy_register - register a wiphy with cfg80211 1352 * 1353 * @wiphy: The wiphy to register. 1354 * 1355 * Returns a non-negative wiphy index or a negative error code. 1356 */ 1357 extern int wiphy_register(struct wiphy *wiphy); 1358 1359 /** 1360 * wiphy_unregister - deregister a wiphy from cfg80211 1361 * 1362 * @wiphy: The wiphy to unregister. 1363 * 1364 * After this call, no more requests can be made with this priv 1365 * pointer, but the call may sleep to wait for an outstanding 1366 * request that is being handled. 1367 */ 1368 extern void wiphy_unregister(struct wiphy *wiphy); 1369 1370 /** 1371 * wiphy_free - free wiphy 1372 * 1373 * @wiphy: The wiphy to free 1374 */ 1375 extern void wiphy_free(struct wiphy *wiphy); 1376 1377 /* internal structs */ 1378 struct cfg80211_conn; 1379 struct cfg80211_internal_bss; 1380 struct cfg80211_cached_keys; 1381 1382 #define MAX_AUTH_BSSES 4 1383 1384 /** 1385 * struct wireless_dev - wireless per-netdev state 1386 * 1387 * This structure must be allocated by the driver/stack 1388 * that uses the ieee80211_ptr field in struct net_device 1389 * (this is intentional so it can be allocated along with 1390 * the netdev.) 1391 * 1392 * @wiphy: pointer to hardware description 1393 * @iftype: interface type 1394 * @list: (private) Used to collect the interfaces 1395 * @netdev: (private) Used to reference back to the netdev 1396 * @current_bss: (private) Used by the internal configuration code 1397 * @bssid: (private) Used by the internal configuration code 1398 * @ssid: (private) Used by the internal configuration code 1399 * @ssid_len: (private) Used by the internal configuration code 1400 * @wext: (private) Used by the internal wireless extensions compat code 1401 * @wext_bssid: (private) Used by the internal wireless extensions compat code 1402 * @use_4addr: indicates 4addr mode is used on this interface, must be 1403 * set by driver (if supported) on add_interface BEFORE registering the 1404 * netdev and may otherwise be used by driver read-only, will be update 1405 * by cfg80211 on change_interface 1406 */ 1407 struct wireless_dev { 1408 struct wiphy *wiphy; 1409 enum nl80211_iftype iftype; 1410 1411 /* the remainder of this struct should be private to cfg80211 */ 1412 struct list_head list; 1413 struct net_device *netdev; 1414 1415 struct mutex mtx; 1416 1417 struct work_struct cleanup_work; 1418 1419 bool use_4addr; 1420 1421 /* currently used for IBSS and SME - might be rearranged later */ 1422 u8 ssid[IEEE80211_MAX_SSID_LEN]; 1423 u8 ssid_len; 1424 enum { 1425 CFG80211_SME_IDLE, 1426 CFG80211_SME_CONNECTING, 1427 CFG80211_SME_CONNECTED, 1428 } sme_state; 1429 struct cfg80211_conn *conn; 1430 struct cfg80211_cached_keys *connect_keys; 1431 1432 struct list_head event_list; 1433 spinlock_t event_lock; 1434 1435 struct cfg80211_internal_bss *authtry_bsses[MAX_AUTH_BSSES]; 1436 struct cfg80211_internal_bss *auth_bsses[MAX_AUTH_BSSES]; 1437 struct cfg80211_internal_bss *current_bss; /* associated / joined */ 1438 1439 #ifdef CONFIG_CFG80211_WEXT 1440 /* wext data */ 1441 struct { 1442 struct cfg80211_ibss_params ibss; 1443 struct cfg80211_connect_params connect; 1444 struct cfg80211_cached_keys *keys; 1445 u8 *ie; 1446 size_t ie_len; 1447 u8 bssid[ETH_ALEN], prev_bssid[ETH_ALEN]; 1448 u8 ssid[IEEE80211_MAX_SSID_LEN]; 1449 s8 default_key, default_mgmt_key; 1450 bool ps, prev_bssid_valid; 1451 int ps_timeout; 1452 } wext; 1453 #endif 1454 }; 1455 1456 /** 1457 * wdev_priv - return wiphy priv from wireless_dev 1458 * 1459 * @wdev: The wireless device whose wiphy's priv pointer to return 1460 */ 1461 static inline void *wdev_priv(struct wireless_dev *wdev) 1462 { 1463 BUG_ON(!wdev); 1464 return wiphy_priv(wdev->wiphy); 1465 } 1466 1467 /* 1468 * Utility functions 1469 */ 1470 1471 /** 1472 * ieee80211_channel_to_frequency - convert channel number to frequency 1473 */ 1474 extern int ieee80211_channel_to_frequency(int chan); 1475 1476 /** 1477 * ieee80211_frequency_to_channel - convert frequency to channel number 1478 */ 1479 extern int ieee80211_frequency_to_channel(int freq); 1480 1481 /* 1482 * Name indirection necessary because the ieee80211 code also has 1483 * a function named "ieee80211_get_channel", so if you include 1484 * cfg80211's header file you get cfg80211's version, if you try 1485 * to include both header files you'll (rightfully!) get a symbol 1486 * clash. 1487 */ 1488 extern struct ieee80211_channel *__ieee80211_get_channel(struct wiphy *wiphy, 1489 int freq); 1490 /** 1491 * ieee80211_get_channel - get channel struct from wiphy for specified frequency 1492 */ 1493 static inline struct ieee80211_channel * 1494 ieee80211_get_channel(struct wiphy *wiphy, int freq) 1495 { 1496 return __ieee80211_get_channel(wiphy, freq); 1497 } 1498 1499 /** 1500 * ieee80211_get_response_rate - get basic rate for a given rate 1501 * 1502 * @sband: the band to look for rates in 1503 * @basic_rates: bitmap of basic rates 1504 * @bitrate: the bitrate for which to find the basic rate 1505 * 1506 * This function returns the basic rate corresponding to a given 1507 * bitrate, that is the next lower bitrate contained in the basic 1508 * rate map, which is, for this function, given as a bitmap of 1509 * indices of rates in the band's bitrate table. 1510 */ 1511 struct ieee80211_rate * 1512 ieee80211_get_response_rate(struct ieee80211_supported_band *sband, 1513 u32 basic_rates, int bitrate); 1514 1515 /* 1516 * Radiotap parsing functions -- for controlled injection support 1517 * 1518 * Implemented in net/wireless/radiotap.c 1519 * Documentation in Documentation/networking/radiotap-headers.txt 1520 */ 1521 1522 /** 1523 * struct ieee80211_radiotap_iterator - tracks walk thru present radiotap args 1524 * @rtheader: pointer to the radiotap header we are walking through 1525 * @max_length: length of radiotap header in cpu byte ordering 1526 * @this_arg_index: IEEE80211_RADIOTAP_... index of current arg 1527 * @this_arg: pointer to current radiotap arg 1528 * @arg_index: internal next argument index 1529 * @arg: internal next argument pointer 1530 * @next_bitmap: internal pointer to next present u32 1531 * @bitmap_shifter: internal shifter for curr u32 bitmap, b0 set == arg present 1532 */ 1533 1534 struct ieee80211_radiotap_iterator { 1535 struct ieee80211_radiotap_header *rtheader; 1536 int max_length; 1537 int this_arg_index; 1538 u8 *this_arg; 1539 1540 int arg_index; 1541 u8 *arg; 1542 __le32 *next_bitmap; 1543 u32 bitmap_shifter; 1544 }; 1545 1546 extern int ieee80211_radiotap_iterator_init( 1547 struct ieee80211_radiotap_iterator *iterator, 1548 struct ieee80211_radiotap_header *radiotap_header, 1549 int max_length); 1550 1551 extern int ieee80211_radiotap_iterator_next( 1552 struct ieee80211_radiotap_iterator *iterator); 1553 1554 extern const unsigned char rfc1042_header[6]; 1555 extern const unsigned char bridge_tunnel_header[6]; 1556 1557 /** 1558 * ieee80211_get_hdrlen_from_skb - get header length from data 1559 * 1560 * Given an skb with a raw 802.11 header at the data pointer this function 1561 * returns the 802.11 header length in bytes (not including encryption 1562 * headers). If the data in the sk_buff is too short to contain a valid 802.11 1563 * header the function returns 0. 1564 * 1565 * @skb: the frame 1566 */ 1567 unsigned int ieee80211_get_hdrlen_from_skb(const struct sk_buff *skb); 1568 1569 /** 1570 * ieee80211_hdrlen - get header length in bytes from frame control 1571 * @fc: frame control field in little-endian format 1572 */ 1573 unsigned int ieee80211_hdrlen(__le16 fc); 1574 1575 /** 1576 * ieee80211_data_to_8023 - convert an 802.11 data frame to 802.3 1577 * @skb: the 802.11 data frame 1578 * @addr: the device MAC address 1579 * @iftype: the virtual interface type 1580 */ 1581 int ieee80211_data_to_8023(struct sk_buff *skb, u8 *addr, 1582 enum nl80211_iftype iftype); 1583 1584 /** 1585 * ieee80211_data_from_8023 - convert an 802.3 frame to 802.11 1586 * @skb: the 802.3 frame 1587 * @addr: the device MAC address 1588 * @iftype: the virtual interface type 1589 * @bssid: the network bssid (used only for iftype STATION and ADHOC) 1590 * @qos: build 802.11 QoS data frame 1591 */ 1592 int ieee80211_data_from_8023(struct sk_buff *skb, u8 *addr, 1593 enum nl80211_iftype iftype, u8 *bssid, bool qos); 1594 1595 /** 1596 * cfg80211_classify8021d - determine the 802.1p/1d tag for a data frame 1597 * @skb: the data frame 1598 */ 1599 unsigned int cfg80211_classify8021d(struct sk_buff *skb); 1600 1601 /* 1602 * Regulatory helper functions for wiphys 1603 */ 1604 1605 /** 1606 * regulatory_hint - driver hint to the wireless core a regulatory domain 1607 * @wiphy: the wireless device giving the hint (used only for reporting 1608 * conflicts) 1609 * @alpha2: the ISO/IEC 3166 alpha2 the driver claims its regulatory domain 1610 * should be in. If @rd is set this should be NULL. Note that if you 1611 * set this to NULL you should still set rd->alpha2 to some accepted 1612 * alpha2. 1613 * 1614 * Wireless drivers can use this function to hint to the wireless core 1615 * what it believes should be the current regulatory domain by 1616 * giving it an ISO/IEC 3166 alpha2 country code it knows its regulatory 1617 * domain should be in or by providing a completely build regulatory domain. 1618 * If the driver provides an ISO/IEC 3166 alpha2 userspace will be queried 1619 * for a regulatory domain structure for the respective country. 1620 * 1621 * The wiphy must have been registered to cfg80211 prior to this call. 1622 * For cfg80211 drivers this means you must first use wiphy_register(), 1623 * for mac80211 drivers you must first use ieee80211_register_hw(). 1624 * 1625 * Drivers should check the return value, its possible you can get 1626 * an -ENOMEM. 1627 */ 1628 extern int regulatory_hint(struct wiphy *wiphy, const char *alpha2); 1629 1630 /** 1631 * wiphy_apply_custom_regulatory - apply a custom driver regulatory domain 1632 * @wiphy: the wireless device we want to process the regulatory domain on 1633 * @regd: the custom regulatory domain to use for this wiphy 1634 * 1635 * Drivers can sometimes have custom regulatory domains which do not apply 1636 * to a specific country. Drivers can use this to apply such custom regulatory 1637 * domains. This routine must be called prior to wiphy registration. The 1638 * custom regulatory domain will be trusted completely and as such previous 1639 * default channel settings will be disregarded. If no rule is found for a 1640 * channel on the regulatory domain the channel will be disabled. 1641 */ 1642 extern void wiphy_apply_custom_regulatory( 1643 struct wiphy *wiphy, 1644 const struct ieee80211_regdomain *regd); 1645 1646 /** 1647 * freq_reg_info - get regulatory information for the given frequency 1648 * @wiphy: the wiphy for which we want to process this rule for 1649 * @center_freq: Frequency in KHz for which we want regulatory information for 1650 * @desired_bw_khz: the desired max bandwidth you want to use per 1651 * channel. Note that this is still 20 MHz if you want to use HT40 1652 * as HT40 makes use of two channels for its 40 MHz width bandwidth. 1653 * If set to 0 we'll assume you want the standard 20 MHz. 1654 * @reg_rule: the regulatory rule which we have for this frequency 1655 * 1656 * Use this function to get the regulatory rule for a specific frequency on 1657 * a given wireless device. If the device has a specific regulatory domain 1658 * it wants to follow we respect that unless a country IE has been received 1659 * and processed already. 1660 * 1661 * Returns 0 if it was able to find a valid regulatory rule which does 1662 * apply to the given center_freq otherwise it returns non-zero. It will 1663 * also return -ERANGE if we determine the given center_freq does not even have 1664 * a regulatory rule for a frequency range in the center_freq's band. See 1665 * freq_in_rule_band() for our current definition of a band -- this is purely 1666 * subjective and right now its 802.11 specific. 1667 */ 1668 extern int freq_reg_info(struct wiphy *wiphy, 1669 u32 center_freq, 1670 u32 desired_bw_khz, 1671 const struct ieee80211_reg_rule **reg_rule); 1672 1673 /* 1674 * Temporary wext handlers & helper functions 1675 * 1676 * In the future cfg80211 will simply assign the entire wext handler 1677 * structure to netdevs it manages, but we're not there yet. 1678 */ 1679 int cfg80211_wext_giwname(struct net_device *dev, 1680 struct iw_request_info *info, 1681 char *name, char *extra); 1682 int cfg80211_wext_siwmode(struct net_device *dev, struct iw_request_info *info, 1683 u32 *mode, char *extra); 1684 int cfg80211_wext_giwmode(struct net_device *dev, struct iw_request_info *info, 1685 u32 *mode, char *extra); 1686 int cfg80211_wext_siwscan(struct net_device *dev, 1687 struct iw_request_info *info, 1688 union iwreq_data *wrqu, char *extra); 1689 int cfg80211_wext_giwscan(struct net_device *dev, 1690 struct iw_request_info *info, 1691 struct iw_point *data, char *extra); 1692 int cfg80211_wext_siwmlme(struct net_device *dev, 1693 struct iw_request_info *info, 1694 struct iw_point *data, char *extra); 1695 int cfg80211_wext_giwrange(struct net_device *dev, 1696 struct iw_request_info *info, 1697 struct iw_point *data, char *extra); 1698 int cfg80211_wext_siwgenie(struct net_device *dev, 1699 struct iw_request_info *info, 1700 struct iw_point *data, char *extra); 1701 int cfg80211_wext_siwauth(struct net_device *dev, 1702 struct iw_request_info *info, 1703 struct iw_param *data, char *extra); 1704 int cfg80211_wext_giwauth(struct net_device *dev, 1705 struct iw_request_info *info, 1706 struct iw_param *data, char *extra); 1707 1708 int cfg80211_wext_siwfreq(struct net_device *dev, 1709 struct iw_request_info *info, 1710 struct iw_freq *freq, char *extra); 1711 int cfg80211_wext_giwfreq(struct net_device *dev, 1712 struct iw_request_info *info, 1713 struct iw_freq *freq, char *extra); 1714 int cfg80211_wext_siwessid(struct net_device *dev, 1715 struct iw_request_info *info, 1716 struct iw_point *data, char *ssid); 1717 int cfg80211_wext_giwessid(struct net_device *dev, 1718 struct iw_request_info *info, 1719 struct iw_point *data, char *ssid); 1720 int cfg80211_wext_siwrate(struct net_device *dev, 1721 struct iw_request_info *info, 1722 struct iw_param *rate, char *extra); 1723 int cfg80211_wext_giwrate(struct net_device *dev, 1724 struct iw_request_info *info, 1725 struct iw_param *rate, char *extra); 1726 1727 int cfg80211_wext_siwrts(struct net_device *dev, 1728 struct iw_request_info *info, 1729 struct iw_param *rts, char *extra); 1730 int cfg80211_wext_giwrts(struct net_device *dev, 1731 struct iw_request_info *info, 1732 struct iw_param *rts, char *extra); 1733 int cfg80211_wext_siwfrag(struct net_device *dev, 1734 struct iw_request_info *info, 1735 struct iw_param *frag, char *extra); 1736 int cfg80211_wext_giwfrag(struct net_device *dev, 1737 struct iw_request_info *info, 1738 struct iw_param *frag, char *extra); 1739 int cfg80211_wext_siwretry(struct net_device *dev, 1740 struct iw_request_info *info, 1741 struct iw_param *retry, char *extra); 1742 int cfg80211_wext_giwretry(struct net_device *dev, 1743 struct iw_request_info *info, 1744 struct iw_param *retry, char *extra); 1745 int cfg80211_wext_siwencodeext(struct net_device *dev, 1746 struct iw_request_info *info, 1747 struct iw_point *erq, char *extra); 1748 int cfg80211_wext_siwencode(struct net_device *dev, 1749 struct iw_request_info *info, 1750 struct iw_point *erq, char *keybuf); 1751 int cfg80211_wext_giwencode(struct net_device *dev, 1752 struct iw_request_info *info, 1753 struct iw_point *erq, char *keybuf); 1754 int cfg80211_wext_siwtxpower(struct net_device *dev, 1755 struct iw_request_info *info, 1756 union iwreq_data *data, char *keybuf); 1757 int cfg80211_wext_giwtxpower(struct net_device *dev, 1758 struct iw_request_info *info, 1759 union iwreq_data *data, char *keybuf); 1760 struct iw_statistics *cfg80211_wireless_stats(struct net_device *dev); 1761 1762 int cfg80211_wext_siwpower(struct net_device *dev, 1763 struct iw_request_info *info, 1764 struct iw_param *wrq, char *extra); 1765 int cfg80211_wext_giwpower(struct net_device *dev, 1766 struct iw_request_info *info, 1767 struct iw_param *wrq, char *extra); 1768 1769 int cfg80211_wext_siwap(struct net_device *dev, 1770 struct iw_request_info *info, 1771 struct sockaddr *ap_addr, char *extra); 1772 int cfg80211_wext_giwap(struct net_device *dev, 1773 struct iw_request_info *info, 1774 struct sockaddr *ap_addr, char *extra); 1775 1776 /* 1777 * callbacks for asynchronous cfg80211 methods, notification 1778 * functions and BSS handling helpers 1779 */ 1780 1781 /** 1782 * cfg80211_scan_done - notify that scan finished 1783 * 1784 * @request: the corresponding scan request 1785 * @aborted: set to true if the scan was aborted for any reason, 1786 * userspace will be notified of that 1787 */ 1788 void cfg80211_scan_done(struct cfg80211_scan_request *request, bool aborted); 1789 1790 /** 1791 * cfg80211_inform_bss - inform cfg80211 of a new BSS 1792 * 1793 * @wiphy: the wiphy reporting the BSS 1794 * @bss: the found BSS 1795 * @signal: the signal strength, type depends on the wiphy's signal_type 1796 * @gfp: context flags 1797 * 1798 * This informs cfg80211 that BSS information was found and 1799 * the BSS should be updated/added. 1800 */ 1801 struct cfg80211_bss* 1802 cfg80211_inform_bss_frame(struct wiphy *wiphy, 1803 struct ieee80211_channel *channel, 1804 struct ieee80211_mgmt *mgmt, size_t len, 1805 s32 signal, gfp_t gfp); 1806 1807 struct cfg80211_bss* 1808 cfg80211_inform_bss(struct wiphy *wiphy, 1809 struct ieee80211_channel *channel, 1810 const u8 *bssid, 1811 u64 timestamp, u16 capability, u16 beacon_interval, 1812 const u8 *ie, size_t ielen, 1813 s32 signal, gfp_t gfp); 1814 1815 struct cfg80211_bss *cfg80211_get_bss(struct wiphy *wiphy, 1816 struct ieee80211_channel *channel, 1817 const u8 *bssid, 1818 const u8 *ssid, size_t ssid_len, 1819 u16 capa_mask, u16 capa_val); 1820 static inline struct cfg80211_bss * 1821 cfg80211_get_ibss(struct wiphy *wiphy, 1822 struct ieee80211_channel *channel, 1823 const u8 *ssid, size_t ssid_len) 1824 { 1825 return cfg80211_get_bss(wiphy, channel, NULL, ssid, ssid_len, 1826 WLAN_CAPABILITY_IBSS, WLAN_CAPABILITY_IBSS); 1827 } 1828 1829 struct cfg80211_bss *cfg80211_get_mesh(struct wiphy *wiphy, 1830 struct ieee80211_channel *channel, 1831 const u8 *meshid, size_t meshidlen, 1832 const u8 *meshcfg); 1833 void cfg80211_put_bss(struct cfg80211_bss *bss); 1834 1835 /** 1836 * cfg80211_unlink_bss - unlink BSS from internal data structures 1837 * @wiphy: the wiphy 1838 * @bss: the bss to remove 1839 * 1840 * This function removes the given BSS from the internal data structures 1841 * thereby making it no longer show up in scan results etc. Use this 1842 * function when you detect a BSS is gone. Normally BSSes will also time 1843 * out, so it is not necessary to use this function at all. 1844 */ 1845 void cfg80211_unlink_bss(struct wiphy *wiphy, struct cfg80211_bss *bss); 1846 1847 /** 1848 * cfg80211_send_rx_auth - notification of processed authentication 1849 * @dev: network device 1850 * @buf: authentication frame (header + body) 1851 * @len: length of the frame data 1852 * 1853 * This function is called whenever an authentication has been processed in 1854 * station mode. The driver is required to call either this function or 1855 * cfg80211_send_auth_timeout() to indicate the result of cfg80211_ops::auth() 1856 * call. This function may sleep. 1857 */ 1858 void cfg80211_send_rx_auth(struct net_device *dev, const u8 *buf, size_t len); 1859 1860 /** 1861 * cfg80211_send_auth_timeout - notification of timed out authentication 1862 * @dev: network device 1863 * @addr: The MAC address of the device with which the authentication timed out 1864 * 1865 * This function may sleep. 1866 */ 1867 void cfg80211_send_auth_timeout(struct net_device *dev, const u8 *addr); 1868 1869 /** 1870 * __cfg80211_auth_canceled - notify cfg80211 that authentication was canceled 1871 * @dev: network device 1872 * @addr: The MAC address of the device with which the authentication timed out 1873 * 1874 * When a pending authentication had no action yet, the driver may decide 1875 * to not send a deauth frame, but in that case must calls this function 1876 * to tell cfg80211 about this decision. It is only valid to call this 1877 * function within the deauth() callback. 1878 */ 1879 void __cfg80211_auth_canceled(struct net_device *dev, const u8 *addr); 1880 1881 /** 1882 * cfg80211_send_rx_assoc - notification of processed association 1883 * @dev: network device 1884 * @buf: (re)association response frame (header + body) 1885 * @len: length of the frame data 1886 * 1887 * This function is called whenever a (re)association response has been 1888 * processed in station mode. The driver is required to call either this 1889 * function or cfg80211_send_assoc_timeout() to indicate the result of 1890 * cfg80211_ops::assoc() call. This function may sleep. 1891 */ 1892 void cfg80211_send_rx_assoc(struct net_device *dev, const u8 *buf, size_t len); 1893 1894 /** 1895 * cfg80211_send_assoc_timeout - notification of timed out association 1896 * @dev: network device 1897 * @addr: The MAC address of the device with which the association timed out 1898 * 1899 * This function may sleep. 1900 */ 1901 void cfg80211_send_assoc_timeout(struct net_device *dev, const u8 *addr); 1902 1903 /** 1904 * cfg80211_send_deauth - notification of processed deauthentication 1905 * @dev: network device 1906 * @buf: deauthentication frame (header + body) 1907 * @len: length of the frame data 1908 * 1909 * This function is called whenever deauthentication has been processed in 1910 * station mode. This includes both received deauthentication frames and 1911 * locally generated ones. This function may sleep. 1912 */ 1913 void cfg80211_send_deauth(struct net_device *dev, const u8 *buf, size_t len); 1914 1915 /** 1916 * __cfg80211_send_deauth - notification of processed deauthentication 1917 * @dev: network device 1918 * @buf: deauthentication frame (header + body) 1919 * @len: length of the frame data 1920 * 1921 * Like cfg80211_send_deauth(), but doesn't take the wdev lock. 1922 */ 1923 void __cfg80211_send_deauth(struct net_device *dev, const u8 *buf, size_t len); 1924 1925 /** 1926 * cfg80211_send_disassoc - notification of processed disassociation 1927 * @dev: network device 1928 * @buf: disassociation response frame (header + body) 1929 * @len: length of the frame data 1930 * 1931 * This function is called whenever disassociation has been processed in 1932 * station mode. This includes both received disassociation frames and locally 1933 * generated ones. This function may sleep. 1934 */ 1935 void cfg80211_send_disassoc(struct net_device *dev, const u8 *buf, size_t len); 1936 1937 /** 1938 * __cfg80211_send_disassoc - notification of processed disassociation 1939 * @dev: network device 1940 * @buf: disassociation response frame (header + body) 1941 * @len: length of the frame data 1942 * 1943 * Like cfg80211_send_disassoc(), but doesn't take the wdev lock. 1944 */ 1945 void __cfg80211_send_disassoc(struct net_device *dev, const u8 *buf, 1946 size_t len); 1947 1948 /** 1949 * cfg80211_michael_mic_failure - notification of Michael MIC failure (TKIP) 1950 * @dev: network device 1951 * @addr: The source MAC address of the frame 1952 * @key_type: The key type that the received frame used 1953 * @key_id: Key identifier (0..3) 1954 * @tsc: The TSC value of the frame that generated the MIC failure (6 octets) 1955 * @gfp: allocation flags 1956 * 1957 * This function is called whenever the local MAC detects a MIC failure in a 1958 * received frame. This matches with MLME-MICHAELMICFAILURE.indication() 1959 * primitive. 1960 */ 1961 void cfg80211_michael_mic_failure(struct net_device *dev, const u8 *addr, 1962 enum nl80211_key_type key_type, int key_id, 1963 const u8 *tsc, gfp_t gfp); 1964 1965 /** 1966 * cfg80211_ibss_joined - notify cfg80211 that device joined an IBSS 1967 * 1968 * @dev: network device 1969 * @bssid: the BSSID of the IBSS joined 1970 * @gfp: allocation flags 1971 * 1972 * This function notifies cfg80211 that the device joined an IBSS or 1973 * switched to a different BSSID. Before this function can be called, 1974 * either a beacon has to have been received from the IBSS, or one of 1975 * the cfg80211_inform_bss{,_frame} functions must have been called 1976 * with the locally generated beacon -- this guarantees that there is 1977 * always a scan result for this IBSS. cfg80211 will handle the rest. 1978 */ 1979 void cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid, gfp_t gfp); 1980 1981 /** 1982 * wiphy_rfkill_set_hw_state - notify cfg80211 about hw block state 1983 * @wiphy: the wiphy 1984 * @blocked: block status 1985 */ 1986 void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked); 1987 1988 /** 1989 * wiphy_rfkill_start_polling - start polling rfkill 1990 * @wiphy: the wiphy 1991 */ 1992 void wiphy_rfkill_start_polling(struct wiphy *wiphy); 1993 1994 /** 1995 * wiphy_rfkill_stop_polling - stop polling rfkill 1996 * @wiphy: the wiphy 1997 */ 1998 void wiphy_rfkill_stop_polling(struct wiphy *wiphy); 1999 2000 #ifdef CONFIG_NL80211_TESTMODE 2001 /** 2002 * cfg80211_testmode_alloc_reply_skb - allocate testmode reply 2003 * @wiphy: the wiphy 2004 * @approxlen: an upper bound of the length of the data that will 2005 * be put into the skb 2006 * 2007 * This function allocates and pre-fills an skb for a reply to 2008 * the testmode command. Since it is intended for a reply, calling 2009 * it outside of the @testmode_cmd operation is invalid. 2010 * 2011 * The returned skb (or %NULL if any errors happen) is pre-filled 2012 * with the wiphy index and set up in a way that any data that is 2013 * put into the skb (with skb_put(), nla_put() or similar) will end 2014 * up being within the %NL80211_ATTR_TESTDATA attribute, so all that 2015 * needs to be done with the skb is adding data for the corresponding 2016 * userspace tool which can then read that data out of the testdata 2017 * attribute. You must not modify the skb in any other way. 2018 * 2019 * When done, call cfg80211_testmode_reply() with the skb and return 2020 * its error code as the result of the @testmode_cmd operation. 2021 */ 2022 struct sk_buff *cfg80211_testmode_alloc_reply_skb(struct wiphy *wiphy, 2023 int approxlen); 2024 2025 /** 2026 * cfg80211_testmode_reply - send the reply skb 2027 * @skb: The skb, must have been allocated with 2028 * cfg80211_testmode_alloc_reply_skb() 2029 * 2030 * Returns an error code or 0 on success, since calling this 2031 * function will usually be the last thing before returning 2032 * from the @testmode_cmd you should return the error code. 2033 * Note that this function consumes the skb regardless of the 2034 * return value. 2035 */ 2036 int cfg80211_testmode_reply(struct sk_buff *skb); 2037 2038 /** 2039 * cfg80211_testmode_alloc_event_skb - allocate testmode event 2040 * @wiphy: the wiphy 2041 * @approxlen: an upper bound of the length of the data that will 2042 * be put into the skb 2043 * @gfp: allocation flags 2044 * 2045 * This function allocates and pre-fills an skb for an event on the 2046 * testmode multicast group. 2047 * 2048 * The returned skb (or %NULL if any errors happen) is set up in the 2049 * same way as with cfg80211_testmode_alloc_reply_skb() but prepared 2050 * for an event. As there, you should simply add data to it that will 2051 * then end up in the %NL80211_ATTR_TESTDATA attribute. Again, you must 2052 * not modify the skb in any other way. 2053 * 2054 * When done filling the skb, call cfg80211_testmode_event() with the 2055 * skb to send the event. 2056 */ 2057 struct sk_buff *cfg80211_testmode_alloc_event_skb(struct wiphy *wiphy, 2058 int approxlen, gfp_t gfp); 2059 2060 /** 2061 * cfg80211_testmode_event - send the event 2062 * @skb: The skb, must have been allocated with 2063 * cfg80211_testmode_alloc_event_skb() 2064 * @gfp: allocation flags 2065 * 2066 * This function sends the given @skb, which must have been allocated 2067 * by cfg80211_testmode_alloc_event_skb(), as an event. It always 2068 * consumes it. 2069 */ 2070 void cfg80211_testmode_event(struct sk_buff *skb, gfp_t gfp); 2071 2072 #define CFG80211_TESTMODE_CMD(cmd) .testmode_cmd = (cmd), 2073 #else 2074 #define CFG80211_TESTMODE_CMD(cmd) 2075 #endif 2076 2077 /** 2078 * cfg80211_connect_result - notify cfg80211 of connection result 2079 * 2080 * @dev: network device 2081 * @bssid: the BSSID of the AP 2082 * @req_ie: association request IEs (maybe be %NULL) 2083 * @req_ie_len: association request IEs length 2084 * @resp_ie: association response IEs (may be %NULL) 2085 * @resp_ie_len: assoc response IEs length 2086 * @status: status code, 0 for successful connection, use 2087 * %WLAN_STATUS_UNSPECIFIED_FAILURE if your device cannot give you 2088 * the real status code for failures. 2089 * @gfp: allocation flags 2090 * 2091 * It should be called by the underlying driver whenever connect() has 2092 * succeeded. 2093 */ 2094 void cfg80211_connect_result(struct net_device *dev, const u8 *bssid, 2095 const u8 *req_ie, size_t req_ie_len, 2096 const u8 *resp_ie, size_t resp_ie_len, 2097 u16 status, gfp_t gfp); 2098 2099 /** 2100 * cfg80211_roamed - notify cfg80211 of roaming 2101 * 2102 * @dev: network device 2103 * @bssid: the BSSID of the new AP 2104 * @req_ie: association request IEs (maybe be %NULL) 2105 * @req_ie_len: association request IEs length 2106 * @resp_ie: association response IEs (may be %NULL) 2107 * @resp_ie_len: assoc response IEs length 2108 * @gfp: allocation flags 2109 * 2110 * It should be called by the underlying driver whenever it roamed 2111 * from one AP to another while connected. 2112 */ 2113 void cfg80211_roamed(struct net_device *dev, const u8 *bssid, 2114 const u8 *req_ie, size_t req_ie_len, 2115 const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp); 2116 2117 /** 2118 * cfg80211_disconnected - notify cfg80211 that connection was dropped 2119 * 2120 * @dev: network device 2121 * @ie: information elements of the deauth/disassoc frame (may be %NULL) 2122 * @ie_len: length of IEs 2123 * @reason: reason code for the disconnection, set it to 0 if unknown 2124 * @gfp: allocation flags 2125 * 2126 * After it calls this function, the driver should enter an idle state 2127 * and not try to connect to any AP any more. 2128 */ 2129 void cfg80211_disconnected(struct net_device *dev, u16 reason, 2130 u8 *ie, size_t ie_len, gfp_t gfp); 2131 2132 2133 #endif /* __NET_CFG80211_H */ 2134