/*
* Copyright (c) 2017-2021 The Linux Foundation. All rights reserved.
* Copyright (c) 2021-2024 Qualcomm Innovation Center, Inc. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: reg_services_public_struct.h
* This file contains regulatory data structures
*/
#ifndef __REG_SERVICES_PUBLIC_STRUCT_H_
#define __REG_SERVICES_PUBLIC_STRUCT_H_
#ifdef CONFIG_AFC_SUPPORT
#include <wlan_reg_afc.h>
#endif
#ifdef CONFIG_BAND_6GHZ
#define REG_MAX_CHANNELS_PER_OPERATING_CLASS 70
/*
* These tx-power macros are present till the 6G regdomains are defined to
* support tx-power values for various client types.
*/
#define REG_PSD_MAX_TXPOWER_FOR_DEFAULT_CLIENT (-1) /* dBm */
#define REG_PSD_MAX_TXPOWER_FOR_SUBORDINATE_CLIENT 5 /* dBm */
#define REG_EIRP_MAX_TXPOWER_FOR_SUBORDINATE_CLIENT 24 /* dBm */
#else
#define REG_MAX_CHANNELS_PER_OPERATING_CLASS 28
#endif
#define REG_MAX_SUPP_OPER_CLASSES 32
#define REG_MAX_CHAN_CHANGE_CBKS 30
#define REG_INVALID_TXPOWER 255
#define MAX_STA_VDEV_CNT 4
#define INVALID_VDEV_ID 0xFF
#define INVALID_CHANNEL_NUM 0x0
#define CH_AVOID_MAX_RANGE (NUM_5GHZ_CHANNELS + NUM_24GHZ_CHANNELS)
#define REG_ALPHA2_LEN 2
#define MAX_REG_RULES 10
#define MAX_6G_REG_RULES 5
#define REGULATORY_CHAN_DISABLED BIT(0)
#define REGULATORY_CHAN_NO_IR BIT(1)
#define REGULATORY_CHAN_RADAR BIT(3)
#define REGULATORY_CHAN_NO_OFDM BIT(6)
#define REGULATORY_CHAN_INDOOR_ONLY BIT(9)
#define REGULATORY_CHAN_AFC BIT(13)
#define REGULATORY_CHAN_AFC_NOT_DONE BIT(16)
#define REGULATORY_CHAN_NO_HT40 BIT(4)
#define REGULATORY_CHAN_NO_80MHZ BIT(7)
#define REGULATORY_CHAN_NO_160MHZ BIT(8)
#define REGULATORY_CHAN_NO_20MHZ BIT(11)
#define REGULATORY_CHAN_NO_10MHZ BIT(12)
#define REGULATORY_CHAN_INVALID BIT(14)
#define REGULATORY_PHYMODE_NO11A BIT(0)
#define REGULATORY_PHYMODE_NO11B BIT(1)
#define REGULATORY_PHYMODE_NO11G BIT(2)
#define REGULATORY_CHAN_NO11N BIT(3)
#define REGULATORY_PHYMODE_NO11AC BIT(4)
#define REGULATORY_PHYMODE_NO11AX BIT(5)
#ifdef WLAN_FEATURE_11BE
#define REGULATORY_PHYMODE_NO11BE BIT(6)
#endif
#define BW_5_MHZ 5
#define BW_10_MHZ 10
#define BW_20_MHZ 20
#define BW_25_MHZ 25
#define BW_40_MHZ 40
#define BW_80_MHZ 80
#define BW_160_MHZ 160
#ifdef WLAN_FEATURE_11BE
#define BW_320_MHZ 320
#endif
#define BW_40_MHZ 40
#define MAX_NUM_PWR_LEVEL 16
#ifdef CONFIG_REG_CLIENT
#define MAX_NUM_FCC_RULES 2
/*
* As per spec valid range is range –64 dBm to 63 dBm.
* Powers in range of 64 - 191 will be invalid.
*/
#define INVALID_TPE_POWER 100
/* 802.11ax-2021 Table 9-276 Meaning of Local Maximum Transmit Power Count
* subfield if the Maximum Transmit Power Interpretation subfield is 0 or 2
*/
#define MAX_TX_PWR_COUNT_FOR_160MHZ 3
/* 802.11ax-2021 Table 9-277 Meaning of Maximum Transmit Power Count subfield
* if Maximum Transmit Power Interpretation subfield is 1 or 3
*/
#define MAX_TX_PWR_COUNT_FOR_160MHZ_PSD 4
#define MAX_NUM_TX_POWER_FOR_320MHZ 5
#define PUNCTURED_CHAN_POWER 128
#endif
/* no subchannels punctured */
#define NO_SCHANS_PUNC 0x0000
#define REG_MIN_POWER -128
/**
* enum dfs_reg - DFS region
* @DFS_UNINIT_REGION: un-initialized region
* @DFS_FCC_REGION: FCC region
* @DFS_ETSI_REGION: ETSI region
* @DFS_MKK_REGION: MKK region
* @DFS_CN_REGION: China region
* @DFS_KR_REGION: Korea region
* @DFS_MKKN_REGION: MKKN region
* that supports updated W53 RADAR pattern
* detection.
* @DFS_UNDEF_REGION: Undefined region
*/
enum dfs_reg {
DFS_UNINIT_REGION = 0,
DFS_FCC_REGION = 1,
DFS_ETSI_REGION = 2,
DFS_MKK_REGION = 3,
DFS_CN_REGION = 4,
DFS_KR_REGION = 5,
DFS_MKKN_REGION = 6,
DFS_UNDEF_REGION = 0xFFFF,
};
/**
* enum op_class_table_num
* @OP_CLASS_US: Class corresponds to US
* @OP_CLASS_EU: Class corresponds to EU
* @OP_CLASS_JAPAN: Class corresponds to JAPAN
* @OP_CLASS_GLOBAL: Class corresponds to GLOBAL
* @OP_CLASS_CHINA: Class corresponds to CHINA
*/
enum op_class_table_num {
OP_CLASS_US = 1,
OP_CLASS_EU,
OP_CLASS_JAPAN,
OP_CLASS_GLOBAL,
OP_CLASS_CHINA
};
/*
* NB: not using kernel-doc comment marker since kernel-doc doesn't
* properly handle the conditional compilation
* enum channel_enum - channel enumeration
* @CHAN_ENUM_2412: channel with freq 2412
* @CHAN_ENUM_2417: channel with freq 2417
* @CHAN_ENUM_2422: channel with freq 2422
* @CHAN_ENUM_2427: channel with freq 2427
* @CHAN_ENUM_2432: channel with freq 2432
* @CHAN_ENUM_2437: channel with freq 2437
* @CHAN_ENUM_2442: channel with freq 2442
* @CHAN_ENUM_2447: channel with freq 2447
* @CHAN_ENUM_2452: channel with freq 2452
* @CHAN_ENUM_2457: channel with freq 2457
* @CHAN_ENUM_2462: channel with freq 2462
* @CHAN_ENUM_2467: channel with freq 2467
* @CHAN_ENUM_2472: channel with freq 2472
* @CHAN_ENUM_2484: channel with freq 2484
* @CHAN_ENUM_4912: channel with freq 4912
* @CHAN_ENUM_4915: channel with freq 4915
* @CHAN_ENUM_4917: channel with freq 4917
* @CHAN_ENUM_4920: channel with freq 4920
* @CHAN_ENUM_4922: channel with freq 4922
* @CHAN_ENUM_4925: channel with freq 4925
* @CHAN_ENUM_4927: channel with freq 4927
* @CHAN_ENUM_4932: channel with freq 4932
* @CHAN_ENUM_4935: channel with freq 4935
* @CHAN_ENUM_4937: channel with freq 4937
* @CHAN_ENUM_4940: channel with freq 4940
* @CHAN_ENUM_4942: channel with freq 4942
* @CHAN_ENUM_4945: channel with freq 4945
* @CHAN_ENUM_4947: channel with freq 4947
* @CHAN_ENUM_4950: channel with freq 4950
* @CHAN_ENUM_4952: channel with freq 4952
* @CHAN_ENUM_4955: channel with freq 4955
* @CHAN_ENUM_4957: channel with freq 4957
* @CHAN_ENUM_4960: channel with freq 4960
* @CHAN_ENUM_4962: channel with freq 4962
* @CHAN_ENUM_4965: channel with freq 4965
* @CHAN_ENUM_4967: channel with freq 4967
* @CHAN_ENUM_4970: channel with freq 4970
* @CHAN_ENUM_4972: channel with freq 4972
* @CHAN_ENUM_4975: channel with freq 4975
* @CHAN_ENUM_4977: channel with freq 4977
* @CHAN_ENUM_4980: channel with freq 4980
* @CHAN_ENUM_4982: channel with freq 4982
* @CHAN_ENUM_4985: channel with freq 4985
* @CHAN_ENUM_4987: channel with freq 4987
* @CHAN_ENUM_5032: channel with freq 5032
* @CHAN_ENUM_5035: channel with freq 5035
* @CHAN_ENUM_5037: channel with freq 5037
* @CHAN_ENUM_5040: channel with freq 5040
* @CHAN_ENUM_5042: channel with freq 5042
* @CHAN_ENUM_5045: channel with freq 5045
* @CHAN_ENUM_5047: channel with freq 5047
* @CHAN_ENUM_5052: channel with freq 5052
* @CHAN_ENUM_5055: channel with freq 5055
* @CHAN_ENUM_5057: channel with freq 5057
* @CHAN_ENUM_5060: channel with freq 5060
* @CHAN_ENUM_5080: channel with freq 5080
* @CHAN_ENUM_5180: channel with freq 5180
* @CHAN_ENUM_5200: channel with freq 5200
* @CHAN_ENUM_5220: channel with freq 5220
* @CHAN_ENUM_5240: channel with freq 5240
* @CHAN_ENUM_5260: channel with freq 5260
* @CHAN_ENUM_5280: channel with freq 5280
* @CHAN_ENUM_5300: channel with freq 5300
* @CHAN_ENUM_5320: channel with freq 5320
* @CHAN_ENUM_5500: channel with freq 5500
* @CHAN_ENUM_5520: channel with freq 5520
* @CHAN_ENUM_5540: channel with freq 5540
* @CHAN_ENUM_5560: channel with freq 5560
* @CHAN_ENUM_5580: channel with freq 5580
* @CHAN_ENUM_5600: channel with freq 5600
* @CHAN_ENUM_5620: channel with freq 5620
* @CHAN_ENUM_5640: channel with freq 5640
* @CHAN_ENUM_5660: channel with freq 5660
* @CHAN_ENUM_5680: channel with freq 5680
* @CHAN_ENUM_5700: channel with freq 5700
* @CHAN_ENUM_5720: channel with freq 5720
* @CHAN_ENUM_5745: channel with freq 5745
* @CHAN_ENUM_5765: channel with freq 5765
* @CHAN_ENUM_5785: channel with freq 5785
* @CHAN_ENUM_5805: channel with freq 5805
* @CHAN_ENUM_5825: channel with freq 5825
* @CHAN_ENUM_5845: channel with freq 5845
* @CHAN_ENUM_5850: channel with freq 5850
* @CHAN_ENUM_5855: channel with freq 5855
* @CHAN_ENUM_5860: channel with freq 5860
* @CHAN_ENUM_5865: channel with freq 5865
* @CHAN_ENUM_5870: channel with freq 5870
* @CHAN_ENUM_5875: channel with freq 5875
* @CHAN_ENUM_5880: channel with freq 5880
* @CHAN_ENUM_5885: channel with freq 5885
* @CHAN_ENUM_5890: channel with freq 5890
* @CHAN_ENUM_5895: channel with freq 5895
* @CHAN_ENUM_5900: channel with freq 5900
* @CHAN_ENUM_5905: channel with freq 5905
* @CHAN_ENUM_5910: channel with freq 5910
* @CHAN_ENUM_5915: channel with freq 5915
* @CHAN_ENUM_5920: channel with freq 5920
* @CHAN_ENUM_5935: channel with freq 5935
* @CHAN_ENUM_5955: channel with freq 5955
* @CHAN_ENUM_5975: channel with freq 5975
* @CHAN_ENUM_5995: channel with freq 5995
* @CHAN_ENUM_6015: channel with freq 6015
* @CHAN_ENUM_6035: channel with freq 6035
* @CHAN_ENUM_6055: channel with freq 6055
* @CHAN_ENUM_6075: channel with freq 6075
* @CHAN_ENUM_6095: channel with freq 6095
* @CHAN_ENUM_6115: channel with freq 6115
* @CHAN_ENUM_6135: channel with freq 6135
* @CHAN_ENUM_6155: channel with freq 6155
* @CHAN_ENUM_6175: channel with freq 6175
* @CHAN_ENUM_6195: channel with freq 6195
* @CHAN_ENUM_6215: channel with freq 6215
* @CHAN_ENUM_6235: channel with freq 6235
* @CHAN_ENUM_6255: channel with freq 6255
* @CHAN_ENUM_6275: channel with freq 6275
* @CHAN_ENUM_6295: channel with freq 6295
* @CHAN_ENUM_6315: channel with freq 6315
* @CHAN_ENUM_6335: channel with freq 6335
* @CHAN_ENUM_6355: channel with freq 6355
* @CHAN_ENUM_6375: channel with freq 6375
* @CHAN_ENUM_6395: channel with freq 6395
* @CHAN_ENUM_6415: channel with freq 6415
* @CHAN_ENUM_6435: channel with freq 6435
* @CHAN_ENUM_6455: channel with freq 6455
* @CHAN_ENUM_6475: channel with freq 6475
* @CHAN_ENUM_6495: channel with freq 6495
* @CHAN_ENUM_6515: channel with freq 6515
* @CHAN_ENUM_6535: channel with freq 6535
* @CHAN_ENUM_6555: channel with freq 6555
* @CHAN_ENUM_6575: channel with freq 6575
* @CHAN_ENUM_6595: channel with freq 6595
* @CHAN_ENUM_6615: channel with freq 6615
* @CHAN_ENUM_6635: channel with freq 6635
* @CHAN_ENUM_6655: channel with freq 6655
* @CHAN_ENUM_6675: channel with freq 6675
* @CHAN_ENUM_6695: channel with freq 6695
* @CHAN_ENUM_6715: channel with freq 6715
* @CHAN_ENUM_6735: channel with freq 6735
* @CHAN_ENUM_6755: channel with freq 6755
* @CHAN_ENUM_6775: channel with freq 6775
* @CHAN_ENUM_6795: channel with freq 6795
* @CHAN_ENUM_6815: channel with freq 6815
* @CHAN_ENUM_6835: channel with freq 6835
* @CHAN_ENUM_6855: channel with freq 6855
* @CHAN_ENUM_6875: channel with freq 6875
* @CHAN_ENUM_6895: channel with freq 6895
* @CHAN_ENUM_6915: channel with freq 6915
* @CHAN_ENUM_6935: channel with freq 6935
* @CHAN_ENUM_6955: channel with freq 6955
* @CHAN_ENUM_6975: channel with freq 6975
* @CHAN_ENUM_6995: channel with freq 6995
* @CHAN_ENUM_7015: channel with freq 7015
* @CHAN_ENUM_7035: channel with freq 7035
* @CHAN_ENUM_7055: channel with freq 7055
* @CHAN_ENUM_7075: channel with freq 7075
* @CHAN_ENUM_7095: channel with freq 7095
* @CHAN_ENUM_7115: channel with freq 7115
*/
enum channel_enum {
CHAN_ENUM_2412,
CHAN_ENUM_2417,
CHAN_ENUM_2422,
CHAN_ENUM_2427,
CHAN_ENUM_2432,
CHAN_ENUM_2437,
CHAN_ENUM_2442,
CHAN_ENUM_2447,
CHAN_ENUM_2452,
CHAN_ENUM_2457,
CHAN_ENUM_2462,
CHAN_ENUM_2467,
CHAN_ENUM_2472,
CHAN_ENUM_2484,
#ifdef CONFIG_49GHZ_CHAN
CHAN_ENUM_4912,
CHAN_ENUM_4915,
CHAN_ENUM_4917,
CHAN_ENUM_4920,
CHAN_ENUM_4922,
CHAN_ENUM_4925,
CHAN_ENUM_4927,
CHAN_ENUM_4932,
CHAN_ENUM_4935,
CHAN_ENUM_4937,
CHAN_ENUM_4940,
CHAN_ENUM_4942,
CHAN_ENUM_4945,
CHAN_ENUM_4947,
CHAN_ENUM_4950,
CHAN_ENUM_4952,
CHAN_ENUM_4955,
CHAN_ENUM_4957,
CHAN_ENUM_4960,
CHAN_ENUM_4962,
CHAN_ENUM_4965,
CHAN_ENUM_4967,
CHAN_ENUM_4970,
CHAN_ENUM_4972,
CHAN_ENUM_4975,
CHAN_ENUM_4977,
CHAN_ENUM_4980,
CHAN_ENUM_4982,
CHAN_ENUM_4985,
CHAN_ENUM_4987,
CHAN_ENUM_5032,
CHAN_ENUM_5035,
CHAN_ENUM_5037,
CHAN_ENUM_5040,
CHAN_ENUM_5042,
CHAN_ENUM_5045,
CHAN_ENUM_5047,
CHAN_ENUM_5052,
CHAN_ENUM_5055,
CHAN_ENUM_5057,
CHAN_ENUM_5060,
CHAN_ENUM_5080,
#endif /* CONFIG_49GHZ_CHAN */
CHAN_ENUM_5180,
CHAN_ENUM_5200,
CHAN_ENUM_5220,
CHAN_ENUM_5240,
CHAN_ENUM_5260,
CHAN_ENUM_5280,
CHAN_ENUM_5300,
CHAN_ENUM_5320,
CHAN_ENUM_5500,
CHAN_ENUM_5520,
CHAN_ENUM_5540,
CHAN_ENUM_5560,
CHAN_ENUM_5580,
CHAN_ENUM_5600,
CHAN_ENUM_5620,
CHAN_ENUM_5640,
CHAN_ENUM_5660,
CHAN_ENUM_5680,
CHAN_ENUM_5700,
CHAN_ENUM_5720,
CHAN_ENUM_5745,
CHAN_ENUM_5765,
CHAN_ENUM_5785,
CHAN_ENUM_5805,
CHAN_ENUM_5825,
CHAN_ENUM_5845,
#ifdef WLAN_FEATURE_DSRC
CHAN_ENUM_5850,
CHAN_ENUM_5855,
CHAN_ENUM_5860,
#endif
CHAN_ENUM_5865,
#ifdef WLAN_FEATURE_DSRC
CHAN_ENUM_5870,
CHAN_ENUM_5875,
CHAN_ENUM_5880,
#endif
CHAN_ENUM_5885,
#ifdef WLAN_FEATURE_DSRC
CHAN_ENUM_5890,
CHAN_ENUM_5895,
CHAN_ENUM_5900,
CHAN_ENUM_5905,
CHAN_ENUM_5910,
CHAN_ENUM_5915,
CHAN_ENUM_5920,
#endif /* WLAN_FEATURE_DSRC */
#ifdef CONFIG_BAND_6GHZ
CHAN_ENUM_5935,
CHAN_ENUM_5955,
CHAN_ENUM_5975,
CHAN_ENUM_5995,
CHAN_ENUM_6015,
CHAN_ENUM_6035,
CHAN_ENUM_6055,
CHAN_ENUM_6075,
CHAN_ENUM_6095,
CHAN_ENUM_6115,
CHAN_ENUM_6135,
CHAN_ENUM_6155,
CHAN_ENUM_6175,
CHAN_ENUM_6195,
CHAN_ENUM_6215,
CHAN_ENUM_6235,
CHAN_ENUM_6255,
CHAN_ENUM_6275,
CHAN_ENUM_6295,
CHAN_ENUM_6315,
CHAN_ENUM_6335,
CHAN_ENUM_6355,
CHAN_ENUM_6375,
CHAN_ENUM_6395,
CHAN_ENUM_6415,
CHAN_ENUM_6435,
CHAN_ENUM_6455,
CHAN_ENUM_6475,
CHAN_ENUM_6495,
CHAN_ENUM_6515,
CHAN_ENUM_6535,
CHAN_ENUM_6555,
CHAN_ENUM_6575,
CHAN_ENUM_6595,
CHAN_ENUM_6615,
CHAN_ENUM_6635,
CHAN_ENUM_6655,
CHAN_ENUM_6675,
CHAN_ENUM_6695,
CHAN_ENUM_6715,
CHAN_ENUM_6735,
CHAN_ENUM_6755,
CHAN_ENUM_6775,
CHAN_ENUM_6795,
CHAN_ENUM_6815,
CHAN_ENUM_6835,
CHAN_ENUM_6855,
CHAN_ENUM_6875,
CHAN_ENUM_6895,
CHAN_ENUM_6915,
CHAN_ENUM_6935,
CHAN_ENUM_6955,
CHAN_ENUM_6975,
CHAN_ENUM_6995,
CHAN_ENUM_7015,
CHAN_ENUM_7035,
CHAN_ENUM_7055,
CHAN_ENUM_7075,
CHAN_ENUM_7095,
CHAN_ENUM_7115,
#endif /* CONFIG_BAND_6GHZ */
NUM_CHANNELS,
MIN_CHANNEL = CHAN_ENUM_2412,
MAX_CHANNEL = (NUM_CHANNELS - 1),
MIN_24GHZ_CHANNEL = CHAN_ENUM_2412,
MAX_24GHZ_CHANNEL = CHAN_ENUM_2484,
NUM_24GHZ_CHANNELS = (MAX_24GHZ_CHANNEL - MIN_24GHZ_CHANNEL + 1),
INVALID_CHANNEL = NUM_CHANNELS,
#ifdef CONFIG_49GHZ_CHAN
MIN_49GHZ_CHANNEL = CHAN_ENUM_4912,
MAX_49GHZ_CHANNEL = CHAN_ENUM_5080,
NUM_49GHZ_CHANNELS = (MAX_49GHZ_CHANNEL - MIN_49GHZ_CHANNEL + 1),
#else
MIN_49GHZ_CHANNEL = INVALID_CHANNEL,
MAX_49GHZ_CHANNEL = INVALID_CHANNEL,
NUM_49GHZ_CHANNELS = 0,
#endif /* CONFIG_49GHZ_CHAN */
MIN_5GHZ_CHANNEL = CHAN_ENUM_5180,
#ifdef WLAN_FEATURE_DSRC
MAX_5GHZ_CHANNEL = CHAN_ENUM_5920,
#else
MAX_5GHZ_CHANNEL = CHAN_ENUM_5885,
#endif
NUM_5GHZ_CHANNELS = (MAX_5GHZ_CHANNEL - MIN_5GHZ_CHANNEL + 1),
#ifdef WLAN_FEATURE_DSRC
MIN_DSRC_CHANNEL = CHAN_ENUM_5850,
MAX_DSRC_CHANNEL = CHAN_ENUM_5920,
NUM_DSRC_CHANNELS = (MAX_DSRC_CHANNEL - MIN_DSRC_CHANNEL + 1),
#endif
MIN_5DOT9_CHANNEL = CHAN_ENUM_5845,
MAX_5DOT9_CHANNEL = CHAN_ENUM_5885,
NUM_5DOT9_CHANNELS = (MAX_5DOT9_CHANNEL - MIN_5DOT9_CHANNEL + 1),
#ifdef CONFIG_49GHZ_CHAN
#define BAND_5GHZ_START_CHANNEL MIN_49GHZ_CHANNEL
#else
#define BAND_5GHZ_START_CHANNEL MIN_5GHZ_CHANNEL
#endif /* CONFIG_49GHZ_CHAN */
#ifdef DISABLE_UNII_SHARED_BANDS
MIN_UNII_1_BAND_CHANNEL = CHAN_ENUM_5180,
MAX_UNII_1_BAND_CHANNEL = CHAN_ENUM_5240,
NUM_UNII_1_BAND_CHANNELS = (MAX_UNII_1_BAND_CHANNEL -
MIN_UNII_1_BAND_CHANNEL + 1),
MIN_UNII_2A_BAND_CHANNEL = CHAN_ENUM_5260,
MAX_UNII_2A_BAND_CHANNEL = CHAN_ENUM_5320,
NUM_UNII_2A_BAND_CHANNELS = (MAX_UNII_2A_BAND_CHANNEL -
MIN_UNII_2A_BAND_CHANNEL + 1),
#endif
#ifdef CONFIG_BAND_6GHZ
MIN_6GHZ_CHANNEL = CHAN_ENUM_5935,
MAX_6GHZ_CHANNEL = CHAN_ENUM_7115,
NUM_6GHZ_CHANNELS = (MAX_6GHZ_CHANNEL - MIN_6GHZ_CHANNEL + 1),
MIN_6GHZ_NON_ORPHAN_CHANNEL = CHAN_ENUM_5955,
#else
MIN_6GHZ_CHANNEL = INVALID_CHANNEL,
MAX_6GHZ_CHANNEL = INVALID_CHANNEL,
NUM_6GHZ_CHANNELS = 0,
MIN_6GHZ_NON_ORPHAN_CHANNEL = INVALID_CHANNEL,
#endif /* CONFIG_BAND_6GHZ */
};
/**
* enum channel_state - channel state
* @CHANNEL_STATE_DISABLE: disabled state
* @CHANNEL_STATE_PASSIVE: passive state
* @CHANNEL_STATE_DFS: dfs state
* @CHANNEL_STATE_ENABLE: enabled state
* @CHANNEL_STATE_INVALID: invalid state
*/
enum channel_state {
CHANNEL_STATE_DISABLE,
CHANNEL_STATE_PASSIVE,
CHANNEL_STATE_DFS,
CHANNEL_STATE_ENABLE,
CHANNEL_STATE_INVALID,
};
/**
* enum reg_6g_ap_type - Regulatory AP type for regulatory info subfield.
* @REG_INDOOR_AP: Indoor AP
* @REG_STANDARD_POWER_AP: Standard Power AP
* @REG_VERY_LOW_POWER_AP: Very low power AP
* @REG_CURRENT_MAX_AP_TYPE: current maximum, used to determine array size
* @REG_MAX_SUPP_AP_TYPE: Current maximum AP power typer supported in the IEEE
* standard.
* @REG_MAX_AP_TYPE: Maximum value possible for (3 bits) regulatory info
* sub-field in the 6G HE Operation IE
*/
enum reg_6g_ap_type {
REG_INDOOR_AP = 0,
REG_STANDARD_POWER_AP = 1,
REG_VERY_LOW_POWER_AP = 2,
REG_CURRENT_MAX_AP_TYPE,
REG_MAX_SUPP_AP_TYPE = REG_VERY_LOW_POWER_AP,
REG_MAX_AP_TYPE = 7,
};
/**
* enum reg_6g_client_type - Regulatory client type for max tx-power category
* @REG_DEFAULT_CLIENT: Default client
* @REG_SUBORDINATE_CLIENT: Subordinate client
* @REG_MAX_CLIENT_TYPE: Maximum value possible for max tx-power category
* (2 bits) sub-field in the TPE (Transmit Power Envelope) IE
* @REG_INVALID_CLIENT_TYPE: Invalid client type
*/
enum reg_6g_client_type {
REG_DEFAULT_CLIENT = 0,
REG_SUBORDINATE_CLIENT = 1,
REG_MAX_CLIENT_TYPE = 2,
REG_INVALID_CLIENT_TYPE = REG_MAX_CLIENT_TYPE,
};
/**
* enum v_REGDOMAIN_t: reg domain
* @REGDOMAIN_FCC: FCC domain
* @REGDOMAIN_ETSI: ETSI domain
* @REGDOMAIN_JAPAN: JAPAN domain
* @REGDOMAIN_WORLD: WORLD domain
* @REGDOMAIN_COUNT: Max domain
*/
typedef enum {
REGDOMAIN_FCC,
REGDOMAIN_ETSI,
REGDOMAIN_JAPAN,
REGDOMAIN_WORLD,
REGDOMAIN_COUNT
} v_REGDOMAIN_t;
/**
* enum ctl_value - CTL value
* @CTL_FCC: CTL FCC
* @CTL_MKK: CTL MKK
* @CTL_ETSI: CTL ETSI
* @CTL_KOR: CTL KOR
* @CTL_CHN: CTL CHINA
* @CTL_USER_DEF: CTL USER_DEF
* @CTL_NONE: CTL NONE
*/
enum ctl_value {
CTL_FCC = 0x10,
CTL_ETSI = 0x30,
CTL_MKK = 0x40,
CTL_KOR = 0x50,
CTL_CHN = 0x60,
CTL_USER_DEF = 0x70,
CTL_NONE = 0xff
};
/**
* struct freq_range: The range/band of frequencies, indicated by left and right
* edge frequencies.
* @left: Left edge frequency(inclusive)
* @right: Right edge frequency(inclusive)
*/
struct freq_range {
qdf_freq_t left;
qdf_freq_t right;
};
/**
* struct ch_params
* @ch_width: channel width
* @sec_ch_offset: secondary channel offset
* @center_freq_seg0: channel number for segment 0
* @center_freq_seg1: channel number segment 1
* @mhz_freq_seg0: Center frequency for segment 0
* @mhz_freq_seg1: Center frequency for segment 1
* @reg_punc_bitmap: Output puncturing bitmap
* @is_create_punc_bitmap: Whether puncturing bitmap is to be created or not
* Parameter 'reg_punc_bitmap' is valid only if
* is_create_punc_bitmap is true
* @input_punc_bitmap: Input puncture bitmap. The channels which are indicated
* as punctured by this bitmap are not validated by the
* regulatory.
*/
struct ch_params {
enum phy_ch_width ch_width;
uint8_t sec_ch_offset;
uint8_t center_freq_seg0;
uint8_t center_freq_seg1;
qdf_freq_t mhz_freq_seg0;
qdf_freq_t mhz_freq_seg1;
#ifdef WLAN_FEATURE_11BE
uint16_t reg_punc_bitmap;
bool is_create_punc_bitmap;
uint16_t input_punc_bitmap;
#endif
};
#ifdef WLAN_FEATURE_11BE
#define MAX_NUM_CHAN_PARAM 2
/**
* struct reg_channel_list
* @num_ch_params: Number of chan_param elements
* @chan_param: Object of type struct ch_params to hold channel params
* Currently chan_param is an array of 2 because maximum possible 320
* channels for a given primary channel is 2. This may be dynamically
* allocated in the future by the caller if num_ch_params is greater than 2.
*
*/
struct reg_channel_list {
uint8_t num_ch_params;
struct ch_params chan_param[MAX_NUM_CHAN_PARAM];
};
#endif
/**
* struct channel_power
* @center_freq: Channel Center Frequency
* @chan_num: channel number
* @tx_power: TX power
*/
struct channel_power {
qdf_freq_t center_freq;
uint8_t chan_num;
uint32_t tx_power;
};
/**
* enum offset_t: channel offset
* @BW20: 20 mhz channel
* @BW40_LOW_PRIMARY: lower channel in 40 mhz
* @BW40_HIGH_PRIMARY: higher channel in 40 mhz
* @BW80: 80 mhz channel
* @BWALL: unknown bandwidth
* @BW_INVALID: invalid bandwidth
*/
enum offset_t {
BW20 = 0,
BW40_LOW_PRIMARY = 1,
BW40_HIGH_PRIMARY = 3,
BW80,
BWALL,
BW_INVALID = 0xFF
};
/**
* enum behav_limit - behavior limit
* @BEHAV_NONE: none
* @BEHAV_BW40_LOW_PRIMARY: BW40 low primary
* @BEHAV_BW40_HIGH_PRIMARY: BW40 high primary
* @BEHAV_BW80_PLUS: BW 80 plus
* @BEHAV_INVALID: invalid behavior
*/
enum behav_limit {
BEHAV_NONE,
BEHAV_BW40_LOW_PRIMARY,
BEHAV_BW40_HIGH_PRIMARY,
BEHAV_BW80_PLUS,
BEHAV_INVALID = 0xFF
};
/**
* struct c_freq_lst: The list data structure for the center frequencies
* @num_cfis: Number of center frequencies
* @p_cfis_arr: Start address of the array of center frequency indices. Center
* for 40/80/160/320MHz band channel opclasses. For 20MHz the list
* is empty as it is already available in @channels variable.
*/
struct c_freq_lst {
uint8_t num_cfis;
const uint8_t *p_cfis_arr;
};
/**
* struct reg_dmn_op_class_map_t: operating class
* @op_class: operating class number
* @chan_spacing: channel spacing
* @offset: offset
* @behav_limit: OR of bitmaps of enum behav_limit
* @start_freq: starting frequency
* @channels: channel set
* @p_cfi_lst_obj: Pointer to center frequency indices list
*/
struct reg_dmn_op_class_map_t {
uint8_t op_class;
uint16_t chan_spacing;
enum offset_t offset;
uint16_t behav_limit;
qdf_freq_t start_freq;
uint8_t channels[REG_MAX_CHANNELS_PER_OPERATING_CLASS];
const struct c_freq_lst *p_cfi_lst_obj;
};
/**
* enum opclass_config: Opclass configuration
* @OPCLASSES_SUPPORTED_BY_CUR_HWMODE: Retrieve opclasses that is supported
* by the current hw mode.
* @OPCLASSES_NOT_SUPPORTED_BY_CUR_HWMODE: Retrieve opclasses that are not
* supported by the current hw mode.
* @OPCLASSES_SUPPORTED_BY_DOMAIN: Populate the opclass supported by the radio
* without considering the capability of current hwmode.
*/
enum opclass_config {
OPCLASSES_SUPPORTED_BY_CUR_HWMODE = 1,
OPCLASSES_NOT_SUPPORTED_BY_CUR_HWMODE = 2,
OPCLASSES_SUPPORTED_BY_DOMAIN = 3
};
/**
* struct regdmn_ap_cap_opclass_t: AP Cap operation class table
* @op_class: operating class number
* @ch_width: channel width in MHz
* @start_freq: Starting Frequency in MHz
* @behav_limit: OR of bitmaps of enum behav_limit
* @max_tx_pwr_dbm: Maximum tx power in dbm
* @num_supported_chan: Number of supported channels
* @num_non_supported_chan: Number of non-supported channels
* @sup_chan_list: Array of supported channel numbers
* @non_sup_chan_list: Array of non supported channel numbers
*/
struct regdmn_ap_cap_opclass_t {
uint8_t op_class;
uint16_t ch_width;
qdf_freq_t start_freq;
uint16_t behav_limit;
uint8_t max_tx_pwr_dbm;
uint8_t num_supported_chan;
uint8_t num_non_supported_chan;
uint8_t sup_chan_list[REG_MAX_CHANNELS_PER_OPERATING_CLASS];
uint8_t non_sup_chan_list[REG_MAX_CHANNELS_PER_OPERATING_CLASS];
};
/**
* struct reg_dmn_supp_op_classes: operating classes
* @num_classes: number of classes
* @classes: classes
*/
struct reg_dmn_supp_op_classes {
uint8_t num_classes;
uint8_t classes[REG_MAX_SUPP_OPER_CLASSES];
};
/**
* struct reg_start_11d_scan_req: start 11d scan request
* @vdev_id: vdev id
* @scan_period_msec: scan duration in milli-seconds
* @start_interval_msec: offset duration to start the scan in milli-seconds
*/
struct reg_start_11d_scan_req {
uint8_t vdev_id;
uint32_t scan_period_msec;
uint32_t start_interval_msec;
};
/**
* struct reg_11d_scan_msg: 11d scan message structure
* @psoc: pointer to psoc object
* @enable_11d_supp: enable 11d scan or disable 11d scan
*/
struct reg_11d_scan_msg {
struct wlan_objmgr_psoc *psoc;
bool enable_11d_supp;
};
/**
* struct reg_stop_11d_scan_req: stop 11d scan request
* @vdev_id: vdev id
*/
struct reg_stop_11d_scan_req {
uint8_t vdev_id;
};
/**
* struct reg_11d_new_country: regulatory 11d new coutry code
* @alpha2: new 11d alpha2
*/
struct reg_11d_new_country {
uint8_t alpha2[REG_ALPHA2_LEN + 1];
};
/**
* enum country_src: country source
* @SOURCE_UNKNOWN: source unknown
* @SOURCE_QUERY: source query
* @SOURCE_CORE: source regulatory core
* @SOURCE_DRIVER: source driver
* @SOURCE_USERSPACE: source userspace
* @SOURCE_11D: source 11D
*/
enum country_src {
SOURCE_UNKNOWN,
SOURCE_QUERY,
SOURCE_CORE,
SOURCE_DRIVER,
SOURCE_USERSPACE,
SOURCE_11D
};
#ifdef WLAN_FEATURE_GET_USABLE_CHAN_LIST
/**
* enum iftype - (virtual) interface types
*
* @IFTYPE_UNSPECIFIED: unspecified type, driver decides
* @IFTYPE_ADHOC: independent BSS member
* @IFTYPE_STATION: managed BSS member
* @IFTYPE_AP: access point
* @IFTYPE_AP_VLAN: VLAN interface for access points; VLAN interfaces
* are a bit special in that they must always be tied to a pre-existing
* AP type interface.
* @IFTYPE_WDS: wireless distribution interface
* @IFTYPE_MONITOR: monitor interface receiving all frames
* @IFTYPE_MESH_POINT: mesh point
* @IFTYPE_P2P_CLIENT: P2P client
* @IFTYPE_P2P_GO: P2P group owner
* @IFTYPE_P2P_DEVICE: P2P device interface type, this is not a netdev
* and therefore can't be created in the normal ways, use the
* %NL80211_CMD_START_P2P_DEVICE and %NL80211_CMD_STOP_P2P_DEVICE
* commands to create and destroy one
* @IFTYPE_OCB: Outside Context of a BSS
* This mode corresponds to the MIB variable dot11OCBActivated=true
* @IFTYPE_NAN: NAN mode
* @IFTYPE_MAX: highest interface type number currently defined
* @NUM_IFTYPES: number of defined interface types
*
* These values are used with the %NL80211_ATTR_IFTYPE
* to set the type of an interface.
*
*/
enum iftype {
IFTYPE_UNSPECIFIED,
IFTYPE_ADHOC,
IFTYPE_STATION,
IFTYPE_AP,
IFTYPE_AP_VLAN,
IFTYPE_WDS,
IFTYPE_MONITOR,
IFTYPE_MESH_POINT,
IFTYPE_P2P_CLIENT,
IFTYPE_P2P_GO,
IFTYPE_P2P_DEVICE,
IFTYPE_OCB,
IFTYPE_NAN,
/* keep last */
NUM_IFTYPES,
IFTYPE_MAX = NUM_IFTYPES - 1
};
/**
* enum usable_channels_filter - Filters to get usable channels
* @FILTER_CELLULAR_COEX: Avoid lte coex channels
* @FILTER_WLAN_CONCURRENCY: Avoid con channels
**/
enum usable_channels_filter {
FILTER_CELLULAR_COEX = 0,
FILTER_WLAN_CONCURRENCY = 1,
};
/**
* struct get_usable_chan_res_params - Usable channels resp params
* @freq : center freq
* @seg0_freq : seg0 freq
* @seg1_freq: seg1 freq
* @bw : bandwidth
* @state: channel state
* @iface_mode_mask: interface mode mask
**/
struct get_usable_chan_res_params {
qdf_freq_t freq;
uint32_t seg0_freq;
uint32_t seg1_freq;
enum phy_ch_width bw;
uint32_t iface_mode_mask;
enum channel_state state;
};
/**
* struct get_usable_chan_req_params - Usable channels req params
* @band_mask: band mask
* @iface_mode_mask: interface mode mask
* @filter_mask: filter mask
**/
struct get_usable_chan_req_params {
uint32_t band_mask;
uint32_t iface_mode_mask;
uint32_t filter_mask;
};
#endif
/**
* struct regulatory_channel
* @center_freq: center frequency
* @chan_num: channel number
* @state: channel state
* @chan_flags: channel flags
* @tx_power: TX powers
* @min_bw: min bandwidth
* @max_bw: max bandwidth
* @ant_gain: antenna gain
* @nol_chan: whether channel is nol
* @nol_history: Set NOL-History when STA vap detects RADAR.
* @is_chan_hop_blocked: Whether channel is blocked for ACS hopping.
* @ht40intol_flags: Contains Flags to indicate whether the 40PLUS/40MINUS
* version of the channel is blocked by ACS due to
* intolerance.
* @psd_flag: is PSD channel or not
* @psd_eirp: PSD power level
* @is_static_punctured: is static punctured
* @opclass_chan_disable: Whether the channel is disabled/enabled by a user
* command. The command provides an opclass and a
* subset of the channels belonging to that opclass
* as inputs and expects the driver to disable/enable
* the channels in the subset.
* @power_type: channel power type
*/
struct regulatory_channel {
qdf_freq_t center_freq;
uint8_t chan_num;
enum channel_state state;
uint32_t chan_flags;
int32_t tx_power;
uint16_t min_bw;
uint16_t max_bw;
uint8_t ant_gain;
bool nol_chan;
bool nol_history;
#ifdef CONFIG_HOST_FIND_CHAN
bool is_chan_hop_blocked;
uint8_t ht40intol_flags;
#endif
#ifdef CONFIG_BAND_6GHZ
bool psd_flag;
uint16_t psd_eirp;
#endif
#ifdef CONFIG_REG_CLIENT
uint8_t is_static_punctured;
enum reg_6g_ap_type power_type;
#endif
#ifndef CONFIG_REG_CLIENT
bool opclass_chan_disable;
#endif
};
/**
* struct ap_cli_pwr_mode_info: AP and client power mode information
* @is_mode_ap: Is it AP or CLIENT
* @cli_type: Is the client a default or subordinate
* @ap_pwr_mode: LPI, SP or VLP
*/
struct ap_cli_pwr_mode_info {
bool is_mode_ap;
enum reg_6g_client_type cli_type;
enum reg_6g_ap_type ap_pwr_mode;
};
/**
* enum supported_6g_pwr_types: 6G supported AP and Client power types
* @REG_BEST_PWR_MODE: Best power mode
* @REG_CURRENT_PWR_MODE: Current power mode
* @REG_AP_LPI: LPI AP power mode
* @REG_AP_SP: SP AP power mode
* @REG_AP_VLP: VLP AP power mode
* @REG_CLI_DEF_LPI: LPI default client mode
* @REG_CLI_DEF_SP: SP default client mode
* @REG_CLI_DEF_VLP: VLP default client mode
* @REG_CLI_SUB_LPI: LPI subordinate client mode
* @REG_CLI_SUB_SP: SP subordinate client mode
* @REG_CLI_SUB_VLP: VLP subordinate client mode
* @REG_INVALID_PWR_MODE: Invalid power mode
*/
enum supported_6g_pwr_types {
REG_BEST_PWR_MODE = -1,
REG_CURRENT_PWR_MODE = 0,
REG_AP_LPI = 1,
REG_AP_SP = 2,
REG_AP_VLP = 3,
REG_CLI_DEF_LPI = 4,
REG_CLI_DEF_SP = 5,
REG_CLI_DEF_VLP = 6,
REG_CLI_SUB_LPI = 7,
REG_CLI_SUB_SP = 8,
REG_CLI_SUB_VLP = 9,
REG_INVALID_PWR_MODE = 10,
};
#define MAX_PWR_TYPES 10
/**
* struct psd_val: Regulatory power information
* @psd_flag: Boolean to indicate if PSD is supported or not
* @psd_eirp: PSD power
* @tx_power: Maximum EIRP
*/
struct psd_val {
bool psd_flag;
uint16_t psd_eirp;
uint32_t tx_power;
};
/**
* struct super_chan_info: Information of a 6G channel for every power
* mode
* @power_types: Bitmap whose bit positions indicate the power modes supported
* by a channel
* @best_power_mode: Best power mode of a channel
* @min_bw: Array of minimum bandwidths per power mode
* @max_bw: Array of maximum bandwidths per power mode
* @chan_flags_arr: Array of channel flags
* @reg_chan_pwr: Array of powers
* @state_arr: Array of states
*/
struct super_chan_info {
uint16_t power_types;
enum supported_6g_pwr_types best_power_mode;
uint16_t min_bw[MAX_PWR_TYPES];
uint16_t max_bw[MAX_PWR_TYPES];
uint32_t chan_flags_arr[MAX_PWR_TYPES];
struct psd_val reg_chan_pwr[MAX_PWR_TYPES];
enum channel_state state_arr[MAX_PWR_TYPES];
};
/**
* struct regulatory: regulatory information
* @reg_domain: regulatory domain pair
* @eeprom_rd_ext: eeprom value
* @country_code: current country in integer
* @alpha2: current alpha2
* @def_country: default country alpha2
* @def_region: DFS region
* @ctl_2g: 2G CTL value
* @ctl_5g: 5G CTL value
* @regpair: pointer to regulatory pair
* @cc_src: country code src
* @reg_flags: kernel regulatory flags
*/
struct regulatory {
uint32_t reg_domain;
uint32_t eeprom_rd_ext;
uint16_t country_code;
uint8_t alpha2[REG_ALPHA2_LEN + 1];
uint8_t ctl_2g;
uint8_t ctl_5g;
const void *regpair;
enum country_src cc_src;
uint32_t reg_flags;
};
/**
* struct chan_map
* @center_freq: center freq in mhz
* @chan_num: channel number
* @min_bw: min bw
* @max_bw: max bw
*/
struct chan_map {
qdf_freq_t center_freq;
uint8_t chan_num;
uint16_t min_bw;
uint16_t max_bw;
};
/**
* struct bonded_channel
* @start_ch: start channel
* @end_ch: end channel
*/
struct bonded_channel {
uint8_t start_ch;
uint8_t end_ch;
};
/**
* struct bonded_channel_freq
* @start_freq: start channel frequency
* @end_freq: end channel frequency
*/
struct bonded_channel_freq {
uint16_t start_freq;
uint16_t end_freq;
};
struct set_country {
uint8_t country[REG_ALPHA2_LEN + 1];
uint8_t pdev_id;
};
/**
* enum ht_sec_ch_offset
* @NO_SEC_CH: no secondary
* @LOW_PRIMARY_CH: low primary
* @HIGH_PRIMARY_CH: high primary
*/
enum ht_sec_ch_offset {
NO_SEC_CH = 0,
LOW_PRIMARY_CH = 1,
HIGH_PRIMARY_CH = 3,
};
enum cc_setting_code {
REG_SET_CC_STATUS_PASS = 0,
REG_CURRENT_ALPHA2_NOT_FOUND = 1,
REG_INIT_ALPHA2_NOT_FOUND = 2,
REG_SET_CC_CHANGE_NOT_ALLOWED = 3,
REG_SET_CC_STATUS_NO_MEMORY = 4,
REG_SET_CC_STATUS_FAIL = 5,
};
/**
* struct cur_reg_rule
* @start_freq: start frequency
* @end_freq: end frequency
* @max_bw: maximum bandwidth
* @reg_power: regulatory power
* @ant_gain: antenna gain
* @flags: regulatory flags
* @psd_flag: is PSD power used
* @psd_eirp: maximum PSD EIRP value
*/
struct cur_reg_rule {
uint16_t start_freq;
uint16_t end_freq;
uint16_t max_bw;
uint8_t reg_power;
uint8_t ant_gain;
uint16_t flags;
bool psd_flag;
uint16_t psd_eirp;
};
#ifdef CONFIG_REG_CLIENT
/**
* struct cur_fcc_rule
* @center_freq: center frequency
* @tx_power: transmission power
*/
struct cur_fcc_rule {
uint16_t center_freq;
uint8_t tx_power;
};
#endif
/**
* struct cur_regulatory_info
* @psoc: psoc ptr
* @status_code: status value
* @num_phy: number of phy
* @phy_id: phy id
* @reg_dmn_pair: reg domain pair
* @ctry_code: country code
* @alpha2: country alpha2
* @offload_enabled: offload enabled
* @dfs_region: dfs region
* @phybitmap: phy bit map
* @min_bw_2g: minimum 2G bw
* @max_bw_2g: maximum 2G bw
* @min_bw_5g: minimum 5G bw
* @max_bw_5g: maximum 5G bw
* @num_2g_reg_rules: number 2G reg rules
* @num_5g_reg_rules: number 5G and 6G reg rules
* @reg_6g_thresh_priority_freq: All frequencies greater or equal will be given
* priority during channel selection by upper layer
* @reg_rules_2g_ptr: ptr to 2G reg rules
* @reg_rules_5g_ptr: ptr to 5G reg rules
* @client_type: type of client
* @rnr_tpe_usable: if RNR TPE octet is usable for country
* @unspecified_ap_usable: if not set, AP usable for country
* @domain_code_6g_ap: domain code for 6G AP
* @domain_code_6g_client: domain code for 6G client in SP mode
* @domain_code_6g_super_id: 6G super domain ID
* @min_bw_6g_ap: minimum 6G bw for AP
* @max_bw_6g_ap: maximum 6G bw for AP
* @min_bw_6g_client: list of minimum 6G bw for clients
* @max_bw_6g_client: list of maximum 6G bw for clients
* @num_6g_reg_rules_ap: number of 6G reg rules for AP
* @num_6g_reg_rules_client: list of number of 6G reg rules for client
* @reg_rules_6g_ap_ptr: ptr to 6G AP reg rules
* @reg_rules_6g_client_ptr: list of ptr to 6G client reg rules
* @fcc_rules_ptr: ptr to fcc rules
* @num_fcc_rules: Number of fcc rules sent by firmware
*/
struct cur_regulatory_info {
struct wlan_objmgr_psoc *psoc;
enum cc_setting_code status_code;
uint8_t num_phy;
uint8_t phy_id;
uint16_t reg_dmn_pair;
uint16_t ctry_code;
uint8_t alpha2[REG_ALPHA2_LEN + 1];
bool offload_enabled;
enum dfs_reg dfs_region;
uint32_t phybitmap;
uint32_t min_bw_2g;
uint32_t max_bw_2g;
uint32_t min_bw_5g;
uint32_t max_bw_5g;
uint32_t num_2g_reg_rules;
uint32_t num_5g_reg_rules;
qdf_freq_t reg_6g_thresh_priority_freq;
struct cur_reg_rule *reg_rules_2g_ptr;
struct cur_reg_rule *reg_rules_5g_ptr;
enum reg_6g_client_type client_type;
bool rnr_tpe_usable;
bool unspecified_ap_usable;
uint8_t domain_code_6g_ap[REG_CURRENT_MAX_AP_TYPE];
uint8_t domain_code_6g_client[REG_CURRENT_MAX_AP_TYPE][REG_MAX_CLIENT_TYPE];
uint32_t domain_code_6g_super_id;
uint32_t min_bw_6g_ap[REG_CURRENT_MAX_AP_TYPE];
uint32_t max_bw_6g_ap[REG_CURRENT_MAX_AP_TYPE];
uint32_t min_bw_6g_client[REG_CURRENT_MAX_AP_TYPE][REG_MAX_CLIENT_TYPE];
uint32_t max_bw_6g_client[REG_CURRENT_MAX_AP_TYPE][REG_MAX_CLIENT_TYPE];
uint32_t num_6g_reg_rules_ap[REG_CURRENT_MAX_AP_TYPE];
uint32_t num_6g_reg_rules_client[REG_CURRENT_MAX_AP_TYPE][REG_MAX_CLIENT_TYPE];
struct cur_reg_rule *reg_rules_6g_ap_ptr[REG_CURRENT_MAX_AP_TYPE];
struct cur_reg_rule *reg_rules_6g_client_ptr[REG_CURRENT_MAX_AP_TYPE][REG_MAX_CLIENT_TYPE];
#ifdef CONFIG_REG_CLIENT
struct cur_fcc_rule *fcc_rules_ptr;
uint32_t num_fcc_rules;
#endif
};
#if defined(CONFIG_AFC_SUPPORT) && defined(CONFIG_BAND_6GHZ)
/**
* enum reg_afc_event_type - indicates the type of AFC event from FW to host.
* @REG_AFC_EVENT_POWER_INFO:
* 1. For sending Power Info REG_AFC_EVENT_POWER_INFO event is used.
* @REG_AFC_EVENT_TIMER_EXPIRY:
* 2. For sending AFC expiry use REG_AFC_EVENT_TIMER_EXPIRY
*
* This type can be expanded in future as per requirements.
*/
enum reg_afc_event_type {
REG_AFC_EVENT_POWER_INFO = 1,
REG_AFC_EVENT_TIMER_EXPIRY = 2,
};
/**
* enum reg_afc_expiry_event_subtype - indicates the AFC expiry subtype.
* @REG_AFC_EXPIRY_EVENT_START:
* 1. At boot up AFC expiry will contain AFC start.
* @REG_AFC_EXPIRY_EVENT_RENEW:
* 2. If AFC timer expires AFC_RENEW status code will be sent to host
* with expiry event.
* @REG_AFC_EXPIRY_EVENT_SWITCH_TO_LPI:
* 3. If AFC server is not responding to FW in specified time, FW will
* indicate host to switch to LPI.
* @REG_AFC_EXPIRY_EVENT_STOP_TX:
*/
enum reg_afc_expiry_event_subtype {
REG_AFC_EXPIRY_EVENT_START = 1,
REG_AFC_EXPIRY_EVENT_RENEW = 2,
REG_AFC_EXPIRY_EVENT_SWITCH_TO_LPI = 3,
REG_AFC_EXPIRY_EVENT_STOP_TX = 4,
};
/**
* enum reg_fw_afc_power_event_status_code
* @REG_FW_AFC_POWER_EVENT_SUCCESS:
* 0. AFC power event is success.
* @REG_FW_AFC_POWER_EVENT_RESP_NOT_RECEIVED:
* 1. If Host does not indicate AFC indication cmd within certain time
* of AFC expiry, REG_FW_AFC_POWER_EVENT_RESP_NOT_RECEIVED will be used.
* @REG_FW_AFC_POWER_EVENT_RESP_PARSING_FAILURE:
* 2. If FW is not able to parse afc_info, parsing_failure will be
* indicated using REG_FW_AFC_POWER_EVENT_RESP_NOT_RECEIVED.
* @REG_FW_AFC_POWER_EVENT_FAILURE:
* 3. If due to some local reason AFC event is failed, AFC event failure
* is indicated using REG_FW_AFC_POWER_EVENT_FAILURE.
*
* Firmware AFC power event status codes
*/
enum reg_fw_afc_power_event_status_code {
REG_FW_AFC_POWER_EVENT_SUCCESS = 0,
REG_FW_AFC_POWER_EVENT_RESP_NOT_RECEIVED = 1,
REG_FW_AFC_POWER_EVENT_RESP_PARSING_FAILURE = 2,
REG_FW_AFC_POWER_EVENT_FAILURE = 3,
};
/**
* enum reg_afc_serv_resp_code - AFC server response codes
* @REG_AFC_SERV_RESP_GENERAL_FAILURE:
* @REG_AFC_SERV_RESP_SUCCESS:
* @REG_AFC_SERV_RESP_VERSION_NOT_SUPPORTED:
* @REG_AFC_SERV_RESP_DEVICE_UNALLOWED:
* @REG_AFC_SERV_RESP_MISSING_PARAM:
* @REG_AFC_SERV_RESP_INVALID_VALUE:
* @REG_AFC_SERV_RESP_UNEXPECTED_PARAM:
* @REG_AFC_SERV_RESP_UNSUPPORTED_SPECTRUM:
*
* The following reg_afc_server_resp_code is mutually exclusive.
* This response code will be indicated to AFC server.
* These codes are defined in WIFI spec doc for AFC as follows
* -1: General Failure
* 0: Success
* 100 - 199: General errors related to the protocol
* 300 - 399: Error events specific to message exchange for the
* Available Spectrum Inquiry
*/
enum reg_afc_serv_resp_code {
REG_AFC_SERV_RESP_GENERAL_FAILURE = -1,
REG_AFC_SERV_RESP_SUCCESS = 0,
REG_AFC_SERV_RESP_VERSION_NOT_SUPPORTED = 100,
REG_AFC_SERV_RESP_DEVICE_UNALLOWED = 101,
REG_AFC_SERV_RESP_MISSING_PARAM = 102,
REG_AFC_SERV_RESP_INVALID_VALUE = 103,
REG_AFC_SERV_RESP_UNEXPECTED_PARAM = 106,
REG_AFC_SERV_RESP_UNSUPPORTED_SPECTRUM = 300,
};
/**
* struct afc_freq_obj
* @low_freq: Lower edge frequency
* @high_freq: Upper edge frequency
* @max_psd: Max PSD in 0.01 dBm/MHz units
*/
struct afc_freq_obj {
qdf_freq_t low_freq;
qdf_freq_t high_freq;
int16_t max_psd;
};
/**
* struct chan_eirp_obj
* @cfi: Channel frequency index
* @eirp_power: Max EIRP power in 0.01 dBm units
*/
struct chan_eirp_obj {
uint8_t cfi;
int16_t eirp_power;
};
/**
* struct afc_chan_obj
* @global_opclass: Global Operating class
* @num_chans: Number of channels
* @chan_eirp_info: Pointer to afc channel EIRP object
*/
struct afc_chan_obj {
uint8_t global_opclass;
uint8_t num_chans;
struct chan_eirp_obj *chan_eirp_info;
};
/**
* struct reg_afc_expiry_event
* @request_id: AFC request id generated by the firmware
* @event_subtype: AFC expiry event subtype
*/
struct reg_afc_expiry_event {
uint32_t request_id;
enum reg_afc_expiry_event_subtype event_subtype;
};
/**
* struct reg_fw_afc_power_event
* @resp_id: AFC server response id
* @fw_status_code: firmware status code
* @serv_resp_code: AFC server response code
* @afc_wfa_version: AFC version
* @avail_exp_time_d: Expiry date of the AFC power info
* @avail_exp_time_t: Time left for expiry of the AFC power info
* @num_freq_objs: Number of freq objects
* @num_chan_objs: Number of channel objects
* @afc_freq_info: Pointer to AFC freq object
* @afc_chan_info: Pointer to AFC channel object
*/
struct reg_fw_afc_power_event {
uint32_t resp_id;
enum reg_fw_afc_power_event_status_code fw_status_code;
enum reg_afc_serv_resp_code serv_resp_code;
uint32_t afc_wfa_version;
uint32_t avail_exp_time_d;
uint32_t avail_exp_time_t;
uint8_t num_freq_objs;
uint8_t num_chan_objs;
struct afc_freq_obj *afc_freq_info;
struct afc_chan_obj *afc_chan_info;
};
/**
* struct afc_regulatory_info
* @psoc: psoc ptr
* @phy_id: phy id
* @event_type: AFC event type
* @expiry_info: pointer to information present in the AFC expiry event
* @power_info: pointer to information present in the AFC power event
*/
struct afc_regulatory_info {
struct wlan_objmgr_psoc *psoc;
uint8_t phy_id;
enum reg_afc_event_type event_type;
union {
struct reg_afc_expiry_event *expiry_info;
struct reg_fw_afc_power_event *power_info;
};
};
#endif
/**
* struct reg_rule_info
* @alpha2: alpha2 of reg rules
* @dfs_region: dfs region
* @num_of_reg_rules: number of reg rules
* @reg_rules: regulatory rules array
* @num_of_6g_ap_reg_rules: number of 6g AP reg rules
* @reg_rules_6g_ap: reg rules for all 6g AP
* @num_of_6g_client_reg_rules: number of 6g client reg rules
* @reg_rules_6g_client: reg rules for all 6g clients
*/
struct reg_rule_info {
uint8_t alpha2[REG_ALPHA2_LEN + 1];
enum dfs_reg dfs_region;
uint8_t num_of_reg_rules;
struct cur_reg_rule reg_rules[MAX_REG_RULES];
#ifdef CONFIG_BAND_6GHZ
uint8_t num_of_6g_ap_reg_rules[REG_CURRENT_MAX_AP_TYPE];
struct cur_reg_rule reg_rules_6g_ap[REG_CURRENT_MAX_AP_TYPE][MAX_6G_REG_RULES];
uint8_t num_of_6g_client_reg_rules[REG_CURRENT_MAX_AP_TYPE];
struct cur_reg_rule reg_rules_6g_client[REG_CURRENT_MAX_AP_TYPE][MAX_6G_REG_RULES];
#endif
};
/**
* enum reg_wifi_band
* @REG_BAND_2G: 2G band
* @REG_BAND_5G: 5G band
* @REG_BAND_6G: 6G band
* @REG_BAND_UNKNOWN: Unsupported band
*/
enum reg_wifi_band {
REG_BAND_2G,
REG_BAND_5G,
REG_BAND_6G,
REG_BAND_UNKNOWN
};
#ifdef DISABLE_UNII_SHARED_BANDS
/**
* enum reg_unii_band
* @REG_UNII_BAND_1: Disable UNII-1 band channels
* @REG_UNII_BAND_2A: Disable UNII-2A band channels
*/
enum reg_unii_band {
REG_UNII_BAND_1 = 0x0,
REG_UNII_BAND_2A = 0x1,
};
#endif
#define REG_BAND_MASK_ALL (BIT(REG_BAND_2G) | BIT(REG_BAND_5G) \
| BIT(REG_BAND_6G))
/* Avoid the use of band_info as it does not support 6GHz band. Use
* reg_wifi_band, as it supports the 6GHz band
*/
/**
* enum band_info
* @BAND_ALL:all bands
* @BAND_2G: 2G band
* @BAND_5G: 5G band
* @BAND_UNKNOWN: Unsupported band
*/
enum band_info {
BAND_ALL,
BAND_2G,
BAND_5G,
BAND_UNKNOWN
};
/**
* enum restart_beaconing_on_ch_avoid_rule: control the beaconing entity to
* move away from active LTE channels
* @CH_AVOID_RULE_DO_NOT_RESTART: Do not move from active LTE
* channels
* @CH_AVOID_RULE_RESTART: Move from active LTE channels
* @CH_AVOID_RULE_RESTART_24G_ONLY: move from 2.4G active LTE
* channels only
*/
enum restart_beaconing_on_ch_avoid_rule {
CH_AVOID_RULE_DO_NOT_RESTART,
CH_AVOID_RULE_RESTART,
CH_AVOID_RULE_RESTART_24G_ONLY,
};
/**
* struct reg_config_vars
* @enable_11d_support: enable 11d support
* @scan_11d_interval: 11d scan interval in ms
* @userspace_ctry_priority: user priority
* @band_capability: band capability
* @dfs_enabled: dfs enabled
* @indoor_chan_enabled: indoor channel support
* @force_ssc_disable_indoor_channel: Disable indoor channel on sap start
* @restart_beaconing: control the beaconing entity to move
* away from active LTE channels
* @enable_srd_chan_in_master_mode: SRD channel support in master mode
* @enable_11d_in_world_mode: enable 11d in world mode
* @enable_5dot9_ghz_chan_in_master_mode: 5.9 GHz channel support in
* master mode
* @retain_nol_across_regdmn_update: Retain the NOL list across the regdomain.
* @coex_unsafe_chan_nb_user_prefer: Honor coex unsafe chan cmd from firmware or
* userspace
* @coex_unsafe_chan_reg_disable: To disable reg channels for received coex
* unsafe channels list
* @enable_6ghz_sp_pwrmode_supp: Enable target 6 GHz Standard Power mode support
* @afc_disable_timer_check: Disable target AFC timer check
* @afc_disable_request_id_check: Disable target AFC request id check
* @is_afc_reg_noaction: Whether no action to AFC power event
* @sta_sap_scc_on_indoor_channel: Value of sap+sta scc on indoor support
* @p2p_indoor_ch_support: Allow P2P GO in indoor channels
*/
struct reg_config_vars {
uint32_t enable_11d_support;
uint32_t scan_11d_interval;
uint32_t userspace_ctry_priority;
uint32_t band_capability;
uint32_t dfs_enabled;
uint32_t indoor_chan_enabled;
uint32_t force_ssc_disable_indoor_channel;
enum restart_beaconing_on_ch_avoid_rule restart_beaconing;
uint8_t enable_srd_chan_in_master_mode;
bool enable_11d_in_world_mode;
bool enable_5dot9_ghz_chan_in_master_mode;
bool retain_nol_across_regdmn_update;
#ifdef FEATURE_WLAN_CH_AVOID_EXT
bool coex_unsafe_chan_nb_user_prefer;
bool coex_unsafe_chan_reg_disable;
#endif
#if defined(CONFIG_AFC_SUPPORT) && defined(CONFIG_BAND_6GHZ)
bool enable_6ghz_sp_pwrmode_supp;
bool afc_disable_timer_check;
bool afc_disable_request_id_check;
bool is_afc_reg_noaction;
#endif
bool sta_sap_scc_on_indoor_channel;
bool p2p_indoor_ch_support;
};
/**
* struct reg_freq_range
* @low_freq: low frequency
* @high_freq: high frequency
*/
struct reg_freq_range {
uint32_t low_freq;
uint32_t high_freq;
};
/**
* enum direction
* @NORTHBOUND: northbound
* @SOUTHBOUND: southbound
*/
enum direction {
NORTHBOUND,
SOUTHBOUND,
};
/**
* struct mas_chan_params
* @dfs_region: dfs region
* @phybitmap: phybitmap
* @mas_chan_list: master chan list for 2GHz and 5GHz channels
* @is_6g_channel_list_populated: indicates the channel lists are populated
* @mas_chan_list_6g_ap: master chan list for 6GHz AP channels
* @mas_chan_list_6g_client: master chan list for 6GHz client
* @is_6g_afc_power_event_received: indicates if the AFC event is received.
* @mas_chan_list_6g_afc: master chan list for 6GHz AFC
* @default_country: default country
* @current_country: current country
* @def_region_domain: default reg domain
* @def_country_code: default country code
* @reg_dmn_pair: reg domain pair
* @reg_6g_superid: 6G super domain ID
* @ctry_code: country code
* @reg_rules: regulatory rules
* @ap_pwr_type: type of AP
* @client_type: type of client
* @rnr_tpe_usable: if RNR TPE octet is usable for country
* @unspecified_ap_usable: if not set, AP usable for country
* @reg_6g_thresh_priority_freq: All frequencies greater or equal will be given
* priority during channel selection by upper layer
* @max_bw_5g: Maximum 5g Bandwidth
*/
struct mas_chan_params {
enum dfs_reg dfs_region;
uint32_t phybitmap;
struct regulatory_channel mas_chan_list[NUM_CHANNELS];
#ifdef CONFIG_BAND_6GHZ
bool is_6g_channel_list_populated;
struct regulatory_channel mas_chan_list_6g_ap[REG_CURRENT_MAX_AP_TYPE][NUM_6GHZ_CHANNELS];
struct regulatory_channel mas_chan_list_6g_client[REG_CURRENT_MAX_AP_TYPE][REG_MAX_CLIENT_TYPE][NUM_6GHZ_CHANNELS];
#ifdef CONFIG_AFC_SUPPORT
bool is_6g_afc_power_event_received;
struct regulatory_channel mas_chan_list_6g_afc[NUM_6GHZ_CHANNELS];
#endif
#endif
char default_country[REG_ALPHA2_LEN + 1];
char current_country[REG_ALPHA2_LEN + 1];
uint16_t def_region_domain;
uint16_t def_country_code;
uint32_t reg_dmn_pair;
uint16_t reg_6g_superid;
uint16_t ctry_code;
struct reg_rule_info reg_rules;
#ifdef CONFIG_BAND_6GHZ
enum reg_6g_ap_type ap_pwr_type;
enum reg_6g_client_type client_type;
bool rnr_tpe_usable;
bool unspecified_ap_usable;
qdf_freq_t reg_6g_thresh_priority_freq;
#endif
uint16_t max_bw_5g;
};
/**
* enum cc_regdmn_flag: Regdomain flags
* @INVALID_CC: Invalid flag
* @CC_IS_SET: Country code is set
* @REGDMN_IS_SET: Regdomain ID is set
* @ALPHA_IS_SET: Country ISO is set
*/
enum cc_regdmn_flag {
INVALID_CC,
CC_IS_SET,
REGDMN_IS_SET,
ALPHA_IS_SET,
};
/**
* struct cc_regdmn_s: User country code or regdomain
* @cc: Union of country code/regulatory domain
* @cc.country_code: Country code
* @cc.regdmn: Regulatory domain
* @cc.regdmn.reg_2g_5g_pair_id: Regdomain pair ID (2Ghz + 5Ghz domain pair)
* @cc.regdmn.sixg_superdmn_id: 6Ghz super domain id
* @cc.alpha: Country ISO
* @flags: Regdomain flags (see enum cc_regdmn_flag)
*/
struct cc_regdmn_s {
union {
uint16_t country_code;
struct {
uint16_t reg_2g_5g_pair_id;
uint16_t sixg_superdmn_id;
} regdmn;
uint8_t alpha[REG_ALPHA2_LEN + 1];
} cc;
uint8_t flags;
};
/**
* struct cur_regdmn_info: Current regulatory info
* @regdmn_pair_id: Current regdomain pair ID
* @dmn_id_2g: 2GHz regdomain ID
* @dmn_id_5g: 5GHz regdomain ID
* @ctl_2g: 2GHz CTL value
* @ctl_5g: 5GHzCTL value
* @dfs_region: dfs region
*/
struct cur_regdmn_info {
uint16_t regdmn_pair_id;
uint16_t dmn_id_2g;
uint16_t dmn_id_5g;
uint8_t ctl_2g;
uint8_t ctl_5g;
uint8_t dfs_region;
};
/**
* struct ch_avoid_freq_type
* @start_freq: start freq
* @end_freq: end freq
* @txpower: txpower
* @is_valid_txpower: Is @txpower valid
*/
struct ch_avoid_freq_type {
qdf_freq_t start_freq;
qdf_freq_t end_freq;
int32_t txpower;
bool is_valid_txpower;
};
/**
* struct ch_avoid_ind_type
* @ch_avoid_range_cnt: count
* @avoid_freq_range: avoid freq range array
* @restriction_mask: restriction mask to apply txpower
*/
struct ch_avoid_ind_type {
uint32_t ch_avoid_range_cnt;
struct ch_avoid_freq_type avoid_freq_range[CH_AVOID_MAX_RANGE];
uint32_t restriction_mask;
};
/**
* struct unsafe_ch_list
* @chan_cnt: no.of channels
* @chan_freq_list: channel frequency list
* @txpower: Tx power per channel
* @is_valid_txpower: Is @txpower valid per channel
*/
struct unsafe_ch_list {
uint16_t chan_cnt;
uint16_t chan_freq_list[NUM_CHANNELS];
int32_t txpower[NUM_CHANNELS];
bool is_valid_txpower[NUM_CHANNELS];
};
/**
* struct avoid_freq_ind_data
* @freq_list: frequency list
* @chan_list: channel list
*/
struct avoid_freq_ind_data {
struct ch_avoid_ind_type freq_list;
struct unsafe_ch_list chan_list;
};
/**
* struct reg_sched_payload
* @psoc: psoc ptr
* @pdev: pdev ptr
* @ch_avoid_ind: if avoidance event indicated
* @avoid_info: chan avoid info if @ch_avoid_ind is true
*/
struct reg_sched_payload {
struct wlan_objmgr_psoc *psoc;
struct wlan_objmgr_pdev *pdev;
bool ch_avoid_ind;
struct avoid_freq_ind_data avoid_info;
};
#define FIVEG_STARTING_FREQ 5000
#define TWOG_STARTING_FREQ 2407
#define TWOG_CHAN_14_IN_MHZ 2484
#define TWOG_CHAN_1_IN_MHZ 2412
#define TWOG_CHAN_5_IN_MHZ 2432
#define TWOG_CHAN_6_IN_MHZ 2437
#define TWOG_CHAN_9_IN_MHZ 2452
#define TWOG_CHAN_13_IN_MHZ 2472
#define FIVEG_CHAN_36_IN_MHZ 5180
#define FIVEG_CHAN_177_IN_MHZ 5885
#define SIXG_CHAN_2_IN_MHZ 5935
#define SIXG_CHAN_1_IN_MHZ 5955
#define SIXG_CHAN_233_IN_MHZ 7115
#define HT40_SEC_OFFSET 20
#define IEEE_2GHZ_CH1 1
#define IEEE_2GHZ_CH14 14
#define IEEE_5GHZ_CH36 36
#define IEEE_6GHZ_CH1 1
#define IEEE_6GHZ_CH2 2
#define IEEE_CH_SEP 5
/**
* struct reg_ctl_params - reg ctl and regd info
* @regd: regdomain pair
* @regd_2g: 2g sub domain code
* @regd_5g: 5g sub domain code
* @ctl_2g: 2g ctl info
* @ctl_5g: 5g ctl info
*/
struct reg_ctl_params {
uint32_t regd;
uint16_t regd_2g;
uint16_t regd_5g;
uint8_t ctl_2g;
uint8_t ctl_5g;
};
/**
* enum reg_phymode - Regulatory phymode
* @REG_PHYMODE_INVALID: Invalid phymode
* @REG_PHYMODE_11B: 802.11b phymode
* @REG_PHYMODE_11G: 802.11g phymode
* @REG_PHYMODE_11A: 802.11a phymode
* @REG_PHYMODE_11N: 802.11n phymode
* @REG_PHYMODE_11AC: 802.11ac phymode
* @REG_PHYMODE_11AX: 802.11ax phymode
* @REG_PHYMODE_11BE: 802.11be phymode
* @REG_PHYMODE_MAX: placeholder for future phymodes
*/
enum reg_phymode {
REG_PHYMODE_INVALID,
REG_PHYMODE_11B,
REG_PHYMODE_11G,
REG_PHYMODE_11A,
REG_PHYMODE_11N,
REG_PHYMODE_11AC,
REG_PHYMODE_11AX,
#ifdef WLAN_FEATURE_11BE
REG_PHYMODE_11BE,
#endif
REG_PHYMODE_MAX,
};
/**
* struct chan_power_info - TPE containing power info per channel chunk
* @chan_cfreq: channel center freq (MHz)
* @tx_power: transmit power (dBm)
*/
struct chan_power_info {
qdf_freq_t chan_cfreq;
int8_t tx_power;
};
/**
* struct reg_tpc_power_info - regulatory TPC power info
* @is_psd_power: is PSD power or not
* @eirp_power: Maximum EIRP power (dBm), valid only if power is PSD
* @power_type_6g: type of power (SP/LPI/VLP)
* @num_pwr_levels: number of power levels
* @reg_max: Array of maximum TX power (dBm) per PSD value
* @ap_constraint_power: AP constraint power (dBm)
* @frequency: Array of operating frequency
* @tpe: TPE values processed from TPE IE
* @chan_power_info: power info to send to FW
* @is_power_constraint_abs: is power constraint absolute or not
*/
struct reg_tpc_power_info {
bool is_psd_power;
int8_t eirp_power;
uint8_t power_type_6g;
uint8_t num_pwr_levels;
uint8_t reg_max[MAX_NUM_PWR_LEVEL];
uint8_t ap_constraint_power;
qdf_freq_t frequency[MAX_NUM_PWR_LEVEL];
uint8_t tpe[MAX_NUM_PWR_LEVEL];
struct chan_power_info chan_power_info[MAX_NUM_PWR_LEVEL];
bool is_power_constraint_abs;
};
#ifdef FEATURE_WLAN_CH_AVOID_EXT
typedef struct unsafe_ch_list avoid_ch_ext_list;
/**
* struct chan_5g_center_freq
* @center_freq_20: center frequency of max 200Mhz
* @center_freq_40: center frequency of max 40Mhz
* @center_freq_80: center frequency of max 80Mhz
* @center_freq_160: center frequency of max 160Mhz
*/
struct chan_5g_center_freq {
qdf_freq_t center_freq_20;
qdf_freq_t center_freq_40;
qdf_freq_t center_freq_80;
qdf_freq_t center_freq_160;
};
#define INVALID_CENTER_FREQ 0
/*MAX 5g channel numbers, not include dsrc*/
#define MAX_5G_CHAN_NUM 28
#endif
/**
* enum HOST_REGDMN_MODE:
* @HOST_REGDMN_MODE_11A: 11a channels
* @HOST_REGDMN_MODE_TURBO: 11a turbo-only channels
* @HOST_REGDMN_MODE_11B: 11b channels
* @HOST_REGDMN_MODE_PUREG: 11g channels (OFDM only)
* @HOST_REGDMN_MODE_11G: historical
* @HOST_REGDMN_MODE_108G: 11g+Turbo channels
* @HOST_REGDMN_MODE_108A: 11a+Turbo channels
* @HOST_REGDMN_MODE_11AC_VHT20_2G: 2GHz, VHT20
* @HOST_REGDMN_MODE_XR: XR channels
* @HOST_REGDMN_MODE_11A_HALF_RATE: 11a half rate channels
* @HOST_REGDMN_MODE_11A_QUARTER_RATE: 11a quarter rate channels
* @HOST_REGDMN_MODE_11NG_HT20: 11ng HT20 channels
* @HOST_REGDMN_MODE_11NA_HT20: 11na HT20 channels
* @HOST_REGDMN_MODE_11NG_HT40PLUS: 11ng HT40+ channels
* @HOST_REGDMN_MODE_11NG_HT40MINUS: 11ng HT40- channels
* @HOST_REGDMN_MODE_11NA_HT40PLUS: 11na HT40+ channels
* @HOST_REGDMN_MODE_11NA_HT40MINUS: 11na HT40- channels
* @HOST_REGDMN_MODE_11AC_VHT20: 5GHz, VHT20
* @HOST_REGDMN_MODE_11AC_VHT40PLUS: 5GHz, VHT40+ channels
* @HOST_REGDMN_MODE_11AC_VHT40MINUS: 5GHz, VHT40- channels
* @HOST_REGDMN_MODE_11AC_VHT80: 5GHz, VHT80 channels
* @HOST_REGDMN_MODE_11AC_VHT160: 5GHz, VHT160 channels
* @HOST_REGDMN_MODE_11AC_VHT80_80: 5GHz, VHT80+80 channels
* @HOST_REGDMN_MODE_11AXG_HE20: 11ax 2.4GHz, HE20 channels
* @HOST_REGDMN_MODE_11AXA_HE20: 11ax 5GHz, HE20 channels
* @HOST_REGDMN_MODE_11AXG_HE40PLUS: 11ax 2.4GHz, HE40+ channels
* @HOST_REGDMN_MODE_11AXG_HE40MINUS: 11ax 2.4GHz, HE40- channels
* @HOST_REGDMN_MODE_11AXA_HE40PLUS: 11ax 5GHz, HE40+ channels
* @HOST_REGDMN_MODE_11AXA_HE40MINUS: 11ax 5GHz, HE40- channels
* @HOST_REGDMN_MODE_11AXA_HE80: 11ax 5GHz, HE80 channels
* @HOST_REGDMN_MODE_11AXA_HE160: 11ax 5GHz, HE160 channels
* @HOST_REGDMN_MODE_11AXA_HE80_80: 11ax 5GHz, HE80+80 channels
* @HOST_REGDMN_MODE_11BEG_EHT20: 11be 2.4GHz, EHT20 channels
* @HOST_REGDMN_MODE_11BEA_EHT20: 11be 5GHz, EHT20 channels
* @HOST_REGDMN_MODE_11BEG_EHT40PLUS: 11be 2.4GHz, EHT40+ channels
* @HOST_REGDMN_MODE_11BEG_EHT40MINUS: 11be 2.4GHz, EHT40- channels
* @HOST_REGDMN_MODE_11BEA_EHT40PLUS: 11be 5GHz, EHT40+ channels
* @HOST_REGDMN_MODE_11BEA_EHT40MINUS: 11be 5GHz, EHT40- channels
* @HOST_REGDMN_MODE_11BEA_EHT80: 11be 5GHz, EHT80 channels
* @HOST_REGDMN_MODE_11BEA_EHT160: 11be 5GHz, EHT160 channels
* @HOST_REGDMN_MODE_11BEA_EHT320: 11be 5GHz, EHT320 channels
* @HOST_REGDMN_MODE_ALL: All modes selected
*/
enum HOST_REGDMN_MODE {
HOST_REGDMN_MODE_11A = 0x00000001,
HOST_REGDMN_MODE_TURBO = 0x00000002,
HOST_REGDMN_MODE_11B = 0x00000004,
HOST_REGDMN_MODE_PUREG = 0x00000008,
HOST_REGDMN_MODE_11G = 0x00000008,
HOST_REGDMN_MODE_108G = 0x00000020,
HOST_REGDMN_MODE_108A = 0x00000040,
HOST_REGDMN_MODE_11AC_VHT20_2G = 0x00000080,
HOST_REGDMN_MODE_XR = 0x00000100,
HOST_REGDMN_MODE_11A_HALF_RATE = 0x00000200,
HOST_REGDMN_MODE_11A_QUARTER_RATE = 0x00000400,
HOST_REGDMN_MODE_11NG_HT20 = 0x00000800,
HOST_REGDMN_MODE_11NA_HT20 = 0x00001000,
HOST_REGDMN_MODE_11NG_HT40PLUS = 0x00002000,
HOST_REGDMN_MODE_11NG_HT40MINUS = 0x00004000,
HOST_REGDMN_MODE_11NA_HT40PLUS = 0x00008000,
HOST_REGDMN_MODE_11NA_HT40MINUS = 0x00010000,
HOST_REGDMN_MODE_11AC_VHT20 = 0x00020000,
HOST_REGDMN_MODE_11AC_VHT40PLUS = 0x00040000,
HOST_REGDMN_MODE_11AC_VHT40MINUS = 0x00080000,
HOST_REGDMN_MODE_11AC_VHT80 = 0x00100000,
HOST_REGDMN_MODE_11AC_VHT160 = 0x00200000,
HOST_REGDMN_MODE_11AC_VHT80_80 = 0x00400000,
HOST_REGDMN_MODE_11AXG_HE20 = 0x00800000,
HOST_REGDMN_MODE_11AXA_HE20 = 0x01000000,
HOST_REGDMN_MODE_11AXG_HE40PLUS = 0x02000000,
HOST_REGDMN_MODE_11AXG_HE40MINUS = 0x04000000,
HOST_REGDMN_MODE_11AXA_HE40PLUS = 0x08000000,
HOST_REGDMN_MODE_11AXA_HE40MINUS = 0x10000000,
HOST_REGDMN_MODE_11AXA_HE80 = 0x20000000,
HOST_REGDMN_MODE_11AXA_HE160 = 0x40000000,
HOST_REGDMN_MODE_11AXA_HE80_80 = 0x80000000,
#ifdef WLAN_FEATURE_11BE
HOST_REGDMN_MODE_11BEG_EHT20 = 0x0000000100000000,
HOST_REGDMN_MODE_11BEA_EHT20 = 0x0000000200000000,
HOST_REGDMN_MODE_11BEG_EHT40PLUS = 0x0000000400000000,
HOST_REGDMN_MODE_11BEG_EHT40MINUS = 0x0000000800000000,
HOST_REGDMN_MODE_11BEA_EHT40PLUS = 0x0000001000000000,
HOST_REGDMN_MODE_11BEA_EHT40MINUS = 0x0000002000000000,
HOST_REGDMN_MODE_11BEA_EHT80 = 0x0000004000000000,
HOST_REGDMN_MODE_11BEA_EHT160 = 0x0000008000000000,
HOST_REGDMN_MODE_11BEA_EHT320 = 0x0000010000000000,
#endif
HOST_REGDMN_MODE_ALL = 0xffffffffffffffff
};
#define WIRELESS_11AX_MODES (HOST_REGDMN_MODE_11AXG_HE20 \
| HOST_REGDMN_MODE_11AXG_HE40PLUS \
| HOST_REGDMN_MODE_11AXG_HE40MINUS \
| HOST_REGDMN_MODE_11AXA_HE20 \
| HOST_REGDMN_MODE_11AXA_HE40PLUS \
| HOST_REGDMN_MODE_11AXA_HE40MINUS \
| HOST_REGDMN_MODE_11AXA_HE80 \
| HOST_REGDMN_MODE_11AXA_HE160 \
| HOST_REGDMN_MODE_11AXA_HE80_80)
#ifdef WLAN_FEATURE_11BE
#define WIRELESS_11BE_MODES (HOST_REGDMN_MODE_11BEG_EHT20 \
| HOST_REGDMN_MODE_11BEA_EHT20 \
| HOST_REGDMN_MODE_11BEG_EHT40PLUS \
| HOST_REGDMN_MODE_11BEG_EHT40MINUS \
| HOST_REGDMN_MODE_11BEA_EHT40PLUS \
| HOST_REGDMN_MODE_11BEA_EHT40MINUS \
| HOST_REGDMN_MODE_11BEA_EHT80 \
| HOST_REGDMN_MODE_11BEA_EHT160 \
| HOST_REGDMN_MODE_11BEA_EHT320)
#endif
#define WIRELESS_11AC_MODES (HOST_REGDMN_MODE_11AC_VHT20 \
| HOST_REGDMN_MODE_11AC_VHT40PLUS \
| HOST_REGDMN_MODE_11AC_VHT40MINUS \
| HOST_REGDMN_MODE_11AC_VHT80 \
| HOST_REGDMN_MODE_11AC_VHT160 \
| HOST_REGDMN_MODE_11AC_VHT80_80)
#define WIRELESS_11N_MODES (HOST_REGDMN_MODE_11NG_HT20 \
| HOST_REGDMN_MODE_11NA_HT20 \
| HOST_REGDMN_MODE_11NG_HT40PLUS \
| HOST_REGDMN_MODE_11NG_HT40MINUS \
| HOST_REGDMN_MODE_11NA_HT40PLUS \
| HOST_REGDMN_MODE_11NA_HT40MINUS)
#define WIRELESS_11G_MODES (HOST_REGDMN_MODE_PUREG \
| HOST_REGDMN_MODE_11G \
| HOST_REGDMN_MODE_108G)
#define WIRELESS_11B_MODES (HOST_REGDMN_MODE_11B)
#define WIRELESS_11A_MODES (HOST_REGDMN_MODE_11A \
| HOST_REGDMN_MODE_TURBO \
| HOST_REGDMN_MODE_108A \
| HOST_REGDMN_MODE_11A_HALF_RATE \
| HOST_REGDMN_MODE_11A_QUARTER_RATE)
#ifdef WLAN_FEATURE_11BE
#define WIRELESS_20_MODES (HOST_REGDMN_MODE_11A \
| HOST_REGDMN_MODE_TURBO \
| HOST_REGDMN_MODE_11B \
| HOST_REGDMN_MODE_PUREG \
| HOST_REGDMN_MODE_11G \
| HOST_REGDMN_MODE_11AC_VHT20_2G \
| HOST_REGDMN_MODE_11NG_HT20 \
| HOST_REGDMN_MODE_11NA_HT20 \
| HOST_REGDMN_MODE_11AC_VHT20 \
| HOST_REGDMN_MODE_11AXG_HE20 \
| HOST_REGDMN_MODE_11AXA_HE20 \
| HOST_REGDMN_MODE_11BEA_EHT20 \
| HOST_REGDMN_MODE_11BEG_EHT20)
#else
#define WIRELESS_20_MODES (HOST_REGDMN_MODE_11A \
| HOST_REGDMN_MODE_TURBO \
| HOST_REGDMN_MODE_11B \
| HOST_REGDMN_MODE_PUREG \
| HOST_REGDMN_MODE_11G \
| HOST_REGDMN_MODE_11AC_VHT20_2G \
| HOST_REGDMN_MODE_11NG_HT20 \
| HOST_REGDMN_MODE_11NA_HT20 \
| HOST_REGDMN_MODE_11AC_VHT20 \
| HOST_REGDMN_MODE_11AXG_HE20 \
| HOST_REGDMN_MODE_11AXA_HE20)
#endif
#define WIRELESS_10_MODES (HOST_REGDMN_MODE_11A_HALF_RATE)
#define WIRELESS_5_MODES (HOST_REGDMN_MODE_11A_QUARTER_RATE)
#ifdef WLAN_FEATURE_11BE
#define WIRELESS_40_MODES (HOST_REGDMN_MODE_11NG_HT40PLUS \
| HOST_REGDMN_MODE_11NG_HT40MINUS \
| HOST_REGDMN_MODE_11NA_HT40PLUS \
| HOST_REGDMN_MODE_11NA_HT40MINUS \
| HOST_REGDMN_MODE_11AC_VHT40PLUS \
| HOST_REGDMN_MODE_11AC_VHT40MINUS \
| HOST_REGDMN_MODE_11AXG_HE40PLUS \
| HOST_REGDMN_MODE_11AXG_HE40MINUS \
| HOST_REGDMN_MODE_11AXA_HE40PLUS \
| HOST_REGDMN_MODE_11AXA_HE40MINUS \
| HOST_REGDMN_MODE_11BEA_EHT40PLUS \
| HOST_REGDMN_MODE_11BEA_EHT40MINUS \
| HOST_REGDMN_MODE_11BEG_EHT40PLUS \
| HOST_REGDMN_MODE_11BEG_EHT40MINUS)
#else
#define WIRELESS_40_MODES (HOST_REGDMN_MODE_11NG_HT40PLUS \
| HOST_REGDMN_MODE_11NG_HT40MINUS \
| HOST_REGDMN_MODE_11NA_HT40PLUS \
| HOST_REGDMN_MODE_11NA_HT40MINUS \
| HOST_REGDMN_MODE_11AC_VHT40PLUS \
| HOST_REGDMN_MODE_11AC_VHT40MINUS \
| HOST_REGDMN_MODE_11AXG_HE40PLUS \
| HOST_REGDMN_MODE_11AXG_HE40MINUS \
| HOST_REGDMN_MODE_11AXA_HE40PLUS \
| HOST_REGDMN_MODE_11AXA_HE40MINUS)
#endif
#ifdef WLAN_FEATURE_11BE
#define WIRELESS_80_MODES (HOST_REGDMN_MODE_11AC_VHT80 \
| HOST_REGDMN_MODE_11AXA_HE80 \
| HOST_REGDMN_MODE_11BEA_EHT80)
#else
#define WIRELESS_80_MODES (HOST_REGDMN_MODE_11AC_VHT80 \
| HOST_REGDMN_MODE_11AXA_HE80)
#endif
#ifdef WLAN_FEATURE_11BE
#define WIRELESS_160_MODES (HOST_REGDMN_MODE_11AC_VHT160 \
| HOST_REGDMN_MODE_11AXA_HE160 \
| HOST_REGDMN_MODE_11BEA_EHT160)
#else
#define WIRELESS_160_MODES (HOST_REGDMN_MODE_11AC_VHT160 \
| HOST_REGDMN_MODE_11AXA_HE160)
#endif
#define WIRELESS_80P80_MODES (HOST_REGDMN_MODE_11AC_VHT80_80 \
| HOST_REGDMN_MODE_11AXA_HE80_80)
#ifdef WLAN_FEATURE_11BE
#define WIRELESS_320_MODES (HOST_REGDMN_MODE_11BEA_EHT320)
#endif
#ifdef WLAN_FEATURE_11BE
#define WIRELESS_6G_MODES_11BE (HOST_REGDMN_MODE_11BEA_EHT20 \
| HOST_REGDMN_MODE_11BEA_EHT40PLUS \
| HOST_REGDMN_MODE_11BEA_EHT40MINUS \
| HOST_REGDMN_MODE_11BEA_EHT80 \
| HOST_REGDMN_MODE_11BEA_EHT160 \
| HOST_REGDMN_MODE_11BEA_EHT320)
#else
#define WIRELESS_6G_MODES_11BE 0
#endif /* WLAN_FEATURE_11BE*/
#ifdef WLAN_FEATURE_11BE
#define WIRELESS_6G_MODES (HOST_REGDMN_MODE_11AXA_HE20 \
| HOST_REGDMN_MODE_11AXA_HE40PLUS \
| HOST_REGDMN_MODE_11AXA_HE40MINUS \
| HOST_REGDMN_MODE_11AXA_HE80 \
| HOST_REGDMN_MODE_11AXA_HE160 \
| HOST_REGDMN_MODE_11AXA_HE80_80 \
| HOST_REGDMN_MODE_11BEA_EHT20 \
| HOST_REGDMN_MODE_11BEA_EHT40PLUS \
| HOST_REGDMN_MODE_11BEA_EHT40MINUS \
| HOST_REGDMN_MODE_11BEA_EHT80 \
| HOST_REGDMN_MODE_11BEA_EHT160 \
| HOST_REGDMN_MODE_11BEA_EHT320)
#else
#define WIRELESS_6G_MODES (HOST_REGDMN_MODE_11AXA_HE20 \
| HOST_REGDMN_MODE_11AXA_HE40PLUS \
| HOST_REGDMN_MODE_11AXA_HE40MINUS \
| HOST_REGDMN_MODE_11AXA_HE80 \
| HOST_REGDMN_MODE_11AXA_HE160 \
| HOST_REGDMN_MODE_11AXA_HE80_80)
#endif
#ifdef WLAN_FEATURE_11BE
#define WIRELESS_5G_MODES_11BE (HOST_REGDMN_MODE_11BEA_EHT20 \
| HOST_REGDMN_MODE_11BEA_EHT40PLUS \
| HOST_REGDMN_MODE_11BEA_EHT40MINUS \
| HOST_REGDMN_MODE_11BEA_EHT80 \
| HOST_REGDMN_MODE_11BEA_EHT160 \
| HOST_REGDMN_MODE_11BEA_EHT320)
#else
#define WIRELESS_5G_MODES_11BE 0
#endif /* WLAN_FEATURE_11BE*/
#ifdef WLAN_FEATURE_11BE
#define WIRELESS_5G_MODES (HOST_REGDMN_MODE_11BEA_EHT20 \
| HOST_REGDMN_MODE_11BEA_EHT40PLUS \
| HOST_REGDMN_MODE_11BEA_EHT40MINUS \
| HOST_REGDMN_MODE_11BEA_EHT80 \
| HOST_REGDMN_MODE_11BEA_EHT160 \
| HOST_REGDMN_MODE_11BEA_EHT320 \
| HOST_REGDMN_MODE_11AXA_HE20 \
| HOST_REGDMN_MODE_11AXA_HE40PLUS \
| HOST_REGDMN_MODE_11AXA_HE40MINUS \
| HOST_REGDMN_MODE_11AXA_HE80 \
| HOST_REGDMN_MODE_11AXA_HE160 \
| HOST_REGDMN_MODE_11AXA_HE80_80 \
| HOST_REGDMN_MODE_11AC_VHT20 \
| HOST_REGDMN_MODE_11AC_VHT40PLUS \
| HOST_REGDMN_MODE_11AC_VHT40MINUS \
| HOST_REGDMN_MODE_11AC_VHT80 \
| HOST_REGDMN_MODE_11AC_VHT160 \
| HOST_REGDMN_MODE_11AC_VHT80_80 \
| HOST_REGDMN_MODE_11NA_HT20 \
| HOST_REGDMN_MODE_11NA_HT40PLUS \
| HOST_REGDMN_MODE_11NA_HT40MINUS \
| HOST_REGDMN_MODE_11A \
| HOST_REGDMN_MODE_TURBO \
| HOST_REGDMN_MODE_108A \
| HOST_REGDMN_MODE_11A_HALF_RATE \
| HOST_REGDMN_MODE_11A_QUARTER_RATE)
#else
#define WIRELESS_5G_MODES (HOST_REGDMN_MODE_11AXA_HE20 \
| HOST_REGDMN_MODE_11AXA_HE40PLUS \
| HOST_REGDMN_MODE_11AXA_HE40MINUS \
| HOST_REGDMN_MODE_11AXA_HE80 \
| HOST_REGDMN_MODE_11AXA_HE160 \
| HOST_REGDMN_MODE_11AXA_HE80_80 \
| HOST_REGDMN_MODE_11AC_VHT20 \
| HOST_REGDMN_MODE_11AC_VHT40PLUS \
| HOST_REGDMN_MODE_11AC_VHT40MINUS \
| HOST_REGDMN_MODE_11AC_VHT80 \
| HOST_REGDMN_MODE_11AC_VHT160 \
| HOST_REGDMN_MODE_11AC_VHT80_80 \
| HOST_REGDMN_MODE_11NA_HT20 \
| HOST_REGDMN_MODE_11NA_HT40PLUS \
| HOST_REGDMN_MODE_11NA_HT40MINUS \
| HOST_REGDMN_MODE_11A \
| HOST_REGDMN_MODE_TURBO \
| HOST_REGDMN_MODE_108A \
| HOST_REGDMN_MODE_11A_HALF_RATE \
| HOST_REGDMN_MODE_11A_QUARTER_RATE)
#endif
#define WIRELESS_49G_MODES (HOST_REGDMN_MODE_11A \
| HOST_REGDMN_MODE_11A_HALF_RATE \
| HOST_REGDMN_MODE_11A_QUARTER_RATE)
#ifdef WLAN_FEATURE_11BE
#define WIRELESS_2G_MODES_11BE (HOST_REGDMN_MODE_11BEG_EHT20 \
| HOST_REGDMN_MODE_11BEG_EHT40PLUS \
| HOST_REGDMN_MODE_11BEG_EHT40MINUS)
#else
#define WIRELESS_2G_MODES_11BE 0
#endif /* WLAN_FEATURE_11BE*/
#ifdef WLAN_FEATURE_11BE
#define WIRELESS_2G_MODES (HOST_REGDMN_MODE_11BEG_EHT20 \
| HOST_REGDMN_MODE_11BEG_EHT40PLUS \
| HOST_REGDMN_MODE_11BEG_EHT40MINUS \
| HOST_REGDMN_MODE_11AXG_HE20 \
| HOST_REGDMN_MODE_11AXG_HE40PLUS \
| HOST_REGDMN_MODE_11AXG_HE40MINUS \
| HOST_REGDMN_MODE_11NG_HT20 \
| HOST_REGDMN_MODE_11NG_HT40PLUS \
| HOST_REGDMN_MODE_11NG_HT40MINUS \
| HOST_REGDMN_MODE_PUREG \
| HOST_REGDMN_MODE_11G \
| HOST_REGDMN_MODE_108G \
| HOST_REGDMN_MODE_11B)
#else
#define WIRELESS_2G_MODES (HOST_REGDMN_MODE_11AXG_HE20 \
| HOST_REGDMN_MODE_11AXG_HE40PLUS \
| HOST_REGDMN_MODE_11AXG_HE40MINUS \
| HOST_REGDMN_MODE_11NG_HT20 \
| HOST_REGDMN_MODE_11NG_HT40PLUS \
| HOST_REGDMN_MODE_11NG_HT40MINUS \
| HOST_REGDMN_MODE_PUREG \
| HOST_REGDMN_MODE_11G \
| HOST_REGDMN_MODE_108G \
| HOST_REGDMN_MODE_11B)
#endif
#ifdef CONFIG_AFC_SUPPORT
/**
* enum reg_afc_cmd_type - Type of AFC command sent to FW
* @REG_AFC_CMD_SERV_RESP_READY: Server response is ready
* @REG_AFC_CMD_RESET_AFC: Ask the target to send an AFC expiry event
* @REG_AFC_CMD_CLEAR_AFC_PAYLOAD: Ask the target to clear AFC Payload.
* The target in response sends REG_AFC_EXPIRY_EVENT_STOP_TX to host.
*/
enum reg_afc_cmd_type {
REG_AFC_CMD_SERV_RESP_READY = 1,
REG_AFC_CMD_RESET_AFC = 2,
REG_AFC_CMD_CLEAR_AFC_PAYLOAD = 3,
};
/**
* enum reg_afc_serv_resp_format - Indicate the format in which afc_serv_format
* is written in FW memory
* @REG_AFC_SERV_RESP_FORMAT_JSON: Server response in JSON format
* @REG_AFC_SERV_RESP_FORMAT_BINARY: Server response in BINARY format
*/
enum reg_afc_serv_resp_format {
REG_AFC_SERV_RESP_FORMAT_JSON = 0,
REG_AFC_SERV_RESP_FORMAT_BINARY = 1,
};
/**
* struct reg_afc_resp_rx_ind_info - regulatory AFC indication info
* @cmd_type: Type of AFC command send to FW
* @serv_resp_format: AFC server response format
*/
struct reg_afc_resp_rx_ind_info {
enum reg_afc_cmd_type cmd_type;
enum reg_afc_serv_resp_format serv_resp_format;
};
/**
* typedef afc_req_rx_evt_handler() - Function prototype of AFC request
* received event handler
* @pdev: Pointer to pdev
* @afc_req: Pointer to AFC request
* @arg: Pointer to void (opaque) argument object
*
* Return: void
*/
typedef void (*afc_req_rx_evt_handler)(struct wlan_objmgr_pdev *pdev,
struct wlan_afc_host_request *afc_req,
void *arg);
/**
* typedef afc_power_tx_evt_handler() - Function prototype of AFC power event
* sent handler
* @pdev: Pointer to pdev
* @power_info: Pointer to AFC power event data
* @arg: Pointer to void (opaque) argument object
*
* Return: void
*/
typedef void
(*afc_power_tx_evt_handler)(struct wlan_objmgr_pdev *pdev,
struct reg_fw_afc_power_event *power_info,
void *arg);
/**
* typedef afc_payload_reset_tx_evt_handler() - Function prototype of AFC
* payload reset event sent handler
* @pdev: Pointer to pdev
* @arg: Pointer to void (opaque) argument object
*
* Return: void
*/
typedef void
(*afc_payload_reset_tx_evt_handler)(struct wlan_objmgr_pdev *pdev,
void *arg);
#endif
/**
* reg_is_chan_enum_invalid() - Checks if the channel enum is invalid or not.
* @chan_enum: Input channel enum.
*
* Return: true if channel enum is invalid else false.
*/
static inline bool reg_is_chan_enum_invalid(enum channel_enum chan_enum)
{
return chan_enum >= INVALID_CHANNEL;
}
/**
* struct r2p_table_update_status_obj
* @pdev_id: pdev id from target
* @status: rate2power update status
*/
struct r2p_table_update_status_obj {
uint32_t pdev_id;
uint32_t status;
};
#endif