1 /* 2 * Copyright (c) 2017-2021 The Linux Foundation. All rights reserved. 3 * Copyright (c) 2021-2023 Qualcomm Innovation Center, Inc. All rights reserved. 4 * 5 * 6 * Permission to use, copy, modify, and/or distribute this software for 7 * any purpose with or without fee is hereby granted, provided that the 8 * above copyright notice and this permission notice appear in all 9 * copies. 10 * 11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 12 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 13 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 14 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 15 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 16 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 17 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 18 * PERFORMANCE OF THIS SOFTWARE. 19 */ 20 21 /** 22 * DOC: reg_services.h 23 * This file provides prototypes of the regulatory component 24 * service functions 25 */ 26 27 #ifndef __REG_SERVICES_COMMON_H_ 28 #define __REG_SERVICES_COMMON_H_ 29 30 #ifdef CONFIG_AFC_SUPPORT 31 #include <wlan_reg_afc.h> 32 #endif 33 34 #define IS_VALID_PSOC_REG_OBJ(psoc_priv_obj) (psoc_priv_obj) 35 #define IS_VALID_PDEV_REG_OBJ(pdev_priv_obj) (pdev_priv_obj) 36 #define FREQ_TO_CHAN_SCALE 5 37 /* The distance between the 80Mhz center and the nearest 20Mhz channel */ 38 #define NEAREST_20MHZ_CHAN_FREQ_OFFSET 10 39 #define NUM_20_MHZ_CHAN_IN_40_MHZ_CHAN 2 40 #define NUM_20_MHZ_CHAN_IN_80_MHZ_CHAN 4 41 #define NUM_20_MHZ_CHAN_IN_160_MHZ_CHAN 8 42 #define NUM_20_MHZ_CHAN_IN_320_MHZ_CHAN 16 43 44 #define REG_MAX_5GHZ_CH_NUM channel_map[MAX_5GHZ_CHANNEL].chan_num 45 46 #define REG_MIN_24GHZ_CH_FREQ channel_map[MIN_24GHZ_CHANNEL].center_freq 47 #define REG_MAX_24GHZ_CH_FREQ channel_map[MAX_24GHZ_CHANNEL].center_freq 48 49 #define REG_IS_24GHZ_CH_FREQ(freq) \ 50 (((freq) >= REG_MIN_24GHZ_CH_FREQ) && \ 51 ((freq) <= REG_MAX_24GHZ_CH_FREQ)) 52 53 #ifdef CONFIG_CHAN_FREQ_API 54 #define REG_MIN_5GHZ_CH_FREQ channel_map[MIN_5GHZ_CHANNEL].center_freq 55 #define REG_MAX_5GHZ_CH_FREQ channel_map[MAX_5GHZ_CHANNEL].center_freq 56 #endif /* CONFIG_CHAN_FREQ_API */ 57 58 #ifdef CONFIG_49GHZ_CHAN 59 #define REG_MIN_49GHZ_CH_FREQ channel_map[MIN_49GHZ_CHANNEL].center_freq 60 #define REG_MAX_49GHZ_CH_FREQ channel_map[MAX_49GHZ_CHANNEL].center_freq 61 #else 62 #define REG_MIN_49GHZ_CH_FREQ 0 63 #define REG_MAX_49GHZ_CH_FREQ 0 64 #endif /* CONFIG_49GHZ_CHAN */ 65 66 #define REG_IS_49GHZ_FREQ(freq) \ 67 (((freq) >= REG_MIN_49GHZ_CH_FREQ) && \ 68 ((freq) <= REG_MAX_49GHZ_CH_FREQ)) 69 70 71 #define REG_IS_5GHZ_FREQ(freq) \ 72 (((freq) >= channel_map[MIN_5GHZ_CHANNEL].center_freq) && \ 73 ((freq) <= channel_map[MAX_5GHZ_CHANNEL].center_freq)) 74 75 /* 76 * It should be 2.5 MHz actually but since we are using integer use 2 77 * instead, which does not create any problem in the start edge calculation. 78 */ 79 #define HALF_5MHZ_BW 2 80 #define HALF_20MHZ_BW 10 81 #define HALF_40MHZ_BW 20 82 #define HALF_80MHZ_BW 40 83 #define HALF_160MHZ_BW 80 84 85 #define TWO_GIG_STARTING_EDGE_FREQ (channel_map_global[MIN_24GHZ_CHANNEL]. \ 86 center_freq - HALF_20MHZ_BW) 87 #define TWO_GIG_ENDING_EDGE_FREQ (channel_map_global[MAX_24GHZ_CHANNEL]. \ 88 center_freq + HALF_20MHZ_BW) 89 #ifdef CONFIG_49GHZ_CHAN 90 #define FIVE_GIG_STARTING_EDGE_FREQ (channel_map_global[MIN_49GHZ_CHANNEL]. \ 91 center_freq - HALF_5MHZ_BW) 92 #else 93 #define FIVE_GIG_STARTING_EDGE_FREQ (channel_map_global[MIN_5GHZ_CHANNEL]. \ 94 center_freq - HALF_20MHZ_BW) 95 #endif /* CONFIG_49GHZ_CHAN */ 96 #define FIVE_GIG_ENDING_EDGE_FREQ (channel_map_global[MAX_5GHZ_CHANNEL]. \ 97 center_freq + HALF_20MHZ_BW) 98 99 #ifdef CONFIG_BAND_6GHZ 100 #define SIX_GIG_STARTING_EDGE_FREQ (channel_map_global[MIN_6GHZ_CHANNEL]. \ 101 center_freq - HALF_20MHZ_BW) 102 #define SIX_GIG_ENDING_EDGE_FREQ (channel_map_global[MAX_6GHZ_CHANNEL]. \ 103 center_freq + HALF_20MHZ_BW) 104 #define SIXG_START_FREQ 5950 105 #define FREQ_LEFT_SHIFT 55 106 #define SIX_GHZ_NON_ORPHAN_START_FREQ \ 107 (channel_map_global[MIN_6GHZ_NON_ORPHAN_CHANNEL].center_freq - 5) 108 #define CHAN_FREQ_5935 5935 109 #define NUM_80MHZ_BAND_IN_6G 16 110 #define NUM_PSC_FREQ 15 111 #define PSC_BAND_MHZ (FREQ_TO_CHAN_SCALE * NUM_80MHZ_BAND_IN_6G) 112 #define REG_MIN_6GHZ_CHAN_FREQ channel_map[MIN_6GHZ_CHANNEL].center_freq 113 #define REG_MAX_6GHZ_CHAN_FREQ channel_map[MAX_6GHZ_CHANNEL].center_freq 114 #else 115 #define FREQ_LEFT_SHIFT 0 116 #define SIX_GHZ_NON_ORPHAN_START_FREQ 0 117 #define CHAN_FREQ_5935 0 118 #define NUM_80MHZ_BAND_IN_6G 0 119 #define NUM_PSC_FREQ 0 120 #define PSC_BAND_MHZ (FREQ_TO_CHAN_SCALE * NUM_80MHZ_BAND_IN_6G) 121 #define REG_MIN_6GHZ_CHAN_FREQ 0 122 #define REG_MAX_6GHZ_CHAN_FREQ 0 123 #endif /*CONFIG_BAND_6GHZ*/ 124 125 #define REG_CH_NUM(ch_enum) channel_map[ch_enum].chan_num 126 #define REG_CH_TO_FREQ(ch_enum) channel_map[ch_enum].center_freq 127 128 /* EEPROM setting is a country code */ 129 #define COUNTRY_ERD_FLAG 0x8000 130 #define MIN_6GHZ_OPER_CLASS 131 131 #define MAX_6GHZ_OPER_CLASS 137 132 133 #ifdef CONFIG_AFC_SUPPORT 134 #define DEFAULT_REQ_ID 11235813 135 /* default minimum power in dBm units */ 136 #define DEFAULT_MIN_POWER (-10) 137 #define DEFAULT_NUM_FREQS 1 138 139 /* Have the entire 6Ghz band as single range */ 140 #define DEFAULT_LOW_6GFREQ 5925 141 #define DEFAULT_HIGH_6GFREQ 7125 142 #endif 143 144 #define SIXG_CHAN_2 2 145 #ifdef CONFIG_BAND_6GHZ 146 #define CHAN_ENUM_SIXG_2 CHAN_ENUM_5935 147 #else 148 #define CHAN_ENUM_SIXG_2 INVALID_CHANNEL 149 #endif 150 151 /* The eirp power values are in 0.01dBm units */ 152 #define EIRP_PWR_SCALE 100 153 154 extern const struct chan_map *channel_map; 155 extern const struct chan_map channel_map_us[]; 156 extern const struct chan_map channel_map_eu[]; 157 extern const struct chan_map channel_map_jp[]; 158 extern const struct chan_map channel_map_china[]; 159 extern const struct chan_map channel_map_global[]; 160 161 #ifdef WLAN_FEATURE_11BE 162 /* binary 1:- Punctured 0:- Not-Punctured */ 163 #define ALL_SCHANS_PUNC 0xFFFF /* all subchannels punctured */ 164 #endif 165 166 #define CHAN_FREQ_5660 5660 167 #define CHAN_FREQ_5720 5720 168 169 #define PRIM_SEG_IEEE_CENTER_240MHZ_5G_CHAN 146 170 #define PRIM_SEG_FREQ_CENTER_240MHZ_5G_CHAN 5730 171 172 #ifdef CONFIG_AFC_SUPPORT 173 /** 174 * struct afc_cb_handler - defines structure for afc request received event 175 * handler call back function and argument 176 * @func: handler function pointer 177 * @arg: argument to handler function 178 */ 179 struct afc_cb_handler { 180 afc_req_rx_evt_handler func; 181 void *arg; 182 }; 183 184 /** 185 * struct afc_pow_evt_cb_handler - defines structure for afc power received 186 * event handler call back function and argument 187 * @func: handler function pointer 188 * @arg: argument to handler function 189 */ 190 struct afc_pow_evt_cb_handler { 191 afc_power_tx_evt_handler func; 192 void *arg; 193 }; 194 195 /** 196 * reg_init_freq_range() - Initialize a freq_range object 197 * @left: The left frequency range 198 * @right: The right frequency range 199 * 200 * Return: The initialized freq_range object 201 */ 202 struct freq_range 203 reg_init_freq_range(qdf_freq_t left, qdf_freq_t right); 204 #endif 205 /** 206 * get_next_lower_bandwidth() - Get next lower bandwidth 207 * @ch_width: Channel width 208 * 209 * Return: Channel width 210 */ 211 enum phy_ch_width get_next_lower_bandwidth(enum phy_ch_width ch_width); 212 213 /** 214 * reg_read_default_country() - Get the default regulatory country 215 * @psoc: The physical SoC to get default country from 216 * @country_code: the buffer to populate the country code into 217 * 218 * Return: QDF_STATUS 219 */ 220 QDF_STATUS reg_read_default_country(struct wlan_objmgr_psoc *psoc, 221 uint8_t *country_code); 222 223 /** 224 * reg_get_ctry_idx_max_bw_from_country_code() - Get the max 5G bandwidth 225 * from country code 226 * @pdev: Pointer to pdev 227 * @cc: Country Code 228 * @max_bw_5g: Max 5G bandwidth supported by the country 229 * 230 * Return: QDF_STATUS 231 */ 232 233 QDF_STATUS reg_get_max_5g_bw_from_country_code(struct wlan_objmgr_pdev *pdev, 234 uint16_t cc, 235 uint16_t *max_bw_5g); 236 237 /** 238 * reg_get_max_5g_bw_from_regdomain() - Get the max 5G bandwidth 239 * supported by the regdomain 240 * @pdev: Pointer to pdev 241 * @orig_regdmn: Regdomain pair value 242 * @max_bw_5g: Max 5G bandwidth supported by the country 243 * 244 * Return: QDF_STATUS 245 */ 246 247 QDF_STATUS reg_get_max_5g_bw_from_regdomain(struct wlan_objmgr_pdev *pdev, 248 uint16_t regdmn, 249 uint16_t *max_bw_5g); 250 251 /** 252 * reg_get_current_dfs_region () - Get the current dfs region 253 * @pdev: Pointer to pdev 254 * @dfs_reg: pointer to dfs region 255 * 256 * Return: None 257 */ 258 void reg_get_current_dfs_region(struct wlan_objmgr_pdev *pdev, 259 enum dfs_reg *dfs_reg); 260 261 /** 262 * reg_get_bw_value() - give bandwidth value 263 * bw: bandwidth enum 264 * 265 * Return: uint16_t 266 */ 267 uint16_t reg_get_bw_value(enum phy_ch_width bw); 268 269 /** 270 * reg_set_dfs_region () - Set the current dfs region 271 * @pdev: Pointer to pdev 272 * @dfs_reg: pointer to dfs region 273 * 274 * Return: None 275 */ 276 void reg_set_dfs_region(struct wlan_objmgr_pdev *pdev, 277 enum dfs_reg dfs_reg); 278 279 /** 280 * reg_program_chan_list() - Set user country code and populate the channel list 281 * @pdev: Pointer to pdev 282 * @rd: Pointer to cc_regdmn_s structure 283 * 284 * Return: QDF_STATUS 285 */ 286 QDF_STATUS reg_program_chan_list(struct wlan_objmgr_pdev *pdev, 287 struct cc_regdmn_s *rd); 288 289 /** 290 * reg_freq_to_chan() - Get channel number from frequency. 291 * @pdev: Pointer to pdev 292 * @freq: Channel frequency 293 * 294 * Return: Channel number if success, otherwise 0 295 */ 296 uint8_t reg_freq_to_chan(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq); 297 298 /** 299 * reg_legacy_chan_to_freq() - Get freq from chan noumber, for 2G and 5G 300 * @pdev: Pointer to pdev 301 * @chan_num: Channel number 302 * 303 * Return: Channel frequency if success, otherwise 0 304 */ 305 uint16_t reg_legacy_chan_to_freq(struct wlan_objmgr_pdev *pdev, 306 uint8_t chan_num); 307 308 /** 309 * reg_get_current_cc() - Get current country code 310 * @pdev: Pdev pointer 311 * @regdmn: Pointer to get current country values 312 * 313 * Return: QDF_STATUS 314 */ 315 QDF_STATUS reg_get_current_cc(struct wlan_objmgr_pdev *pdev, 316 struct cc_regdmn_s *rd); 317 318 /** 319 * reg_set_regdb_offloaded() - set/clear regulatory offloaded flag 320 * 321 * @psoc: psoc pointer 322 * Return: Success or Failure 323 */ 324 QDF_STATUS reg_set_regdb_offloaded(struct wlan_objmgr_psoc *psoc, bool val); 325 326 /** 327 * reg_get_curr_regdomain() - Get current regdomain in use 328 * @pdev: pdev pointer 329 * @cur_regdmn: Current regdomain info 330 * 331 * Return: QDF status 332 */ 333 QDF_STATUS reg_get_curr_regdomain(struct wlan_objmgr_pdev *pdev, 334 struct cur_regdmn_info *cur_regdmn); 335 336 /** 337 * reg_modify_chan_144() - Enable/Disable channel 144 338 * @pdev: pdev pointer 339 * @en_chan_144: flag to disable/enable channel 144 340 * 341 * Return: Success or Failure 342 */ 343 QDF_STATUS reg_modify_chan_144(struct wlan_objmgr_pdev *pdev, bool en_chan_144); 344 345 /** 346 * reg_get_en_chan_144() - get en_chan_144 flag value 347 * @pdev: pdev pointer 348 * 349 * Return: en_chan_144 flag value 350 */ 351 bool reg_get_en_chan_144(struct wlan_objmgr_pdev *pdev); 352 353 #if defined(CONFIG_BAND_6GHZ) && defined(CONFIG_AFC_SUPPORT) 354 /** 355 * reg_get_enable_6ghz_sp_mode_support() - Get enable 6 GHz SP mode support 356 * @psoc: pointer to psoc object 357 * 358 * Return: enable 6 GHz SP mode support flag 359 */ 360 bool reg_get_enable_6ghz_sp_mode_support(struct wlan_objmgr_psoc *psoc); 361 362 /** 363 * reg_set_enable_6ghz_sp_mode_support() - Set enable 6 GHz SP mode support 364 * @psoc: pointer to psoc object 365 * @value: value to be set 366 * 367 * Return: None 368 */ 369 void reg_set_enable_6ghz_sp_mode_support(struct wlan_objmgr_psoc *psoc, 370 bool value); 371 372 /** 373 * reg_get_afc_disable_timer_check() - Get AFC timer check flag 374 * @psoc: pointer to psoc object 375 * 376 * Return: AFC timer check flag 377 */ 378 bool reg_get_afc_disable_timer_check(struct wlan_objmgr_psoc *psoc); 379 380 /** 381 * reg_set_afc_disable_timer_check() - Set AFC disable timer check 382 * @psoc: pointer to psoc object 383 * @value: value to be set 384 * 385 * Return: None 386 */ 387 void reg_set_afc_disable_timer_check(struct wlan_objmgr_psoc *psoc, 388 bool value); 389 390 /** 391 * reg_get_afc_disable_request_id_check() - Get AFC request id check flag 392 * @psoc: pointer to psoc object 393 * 394 * Return: AFC request id check flag 395 */ 396 bool reg_get_afc_disable_request_id_check(struct wlan_objmgr_psoc *psoc); 397 398 /** 399 * reg_set_afc_disable_request_id_check() - Set AFC disable request id flag 400 * @psoc: pointer to psoc object 401 * @value: value to be set 402 * 403 * Return: None 404 */ 405 void reg_set_afc_disable_request_id_check(struct wlan_objmgr_psoc *psoc, 406 bool value); 407 408 /** 409 * reg_get_afc_noaction() - Get AFC no action flag 410 * @psoc: pointer to psoc object 411 * 412 * Return: AFC no action flag 413 */ 414 bool reg_get_afc_noaction(struct wlan_objmgr_psoc *psoc); 415 416 /** 417 * reg_set_afc_noaction() - Set AFC no action flag 418 * @psoc: pointer to psoc object 419 * @value: value to be set 420 * 421 * Return: None 422 */ 423 void reg_set_afc_noaction(struct wlan_objmgr_psoc *psoc, bool value); 424 #endif 425 426 /** 427 * reg_get_hal_reg_cap() - Get HAL REG capabilities 428 * @psoc: psoc for country information 429 * 430 * Return: hal reg cap pointer 431 */ 432 struct wlan_psoc_host_hal_reg_capabilities_ext *reg_get_hal_reg_cap( 433 struct wlan_objmgr_psoc *psoc); 434 435 /** 436 * reg_set_hal_reg_cap() - Set HAL REG capabilities 437 * @psoc: psoc for country information 438 * @reg_cap: Regulatory caps pointer 439 * @phy_cnt: number of phy 440 * 441 * Return: hal reg cap pointer 442 */ 443 QDF_STATUS reg_set_hal_reg_cap( 444 struct wlan_objmgr_psoc *psoc, 445 struct wlan_psoc_host_hal_reg_capabilities_ext *reg_cap, 446 uint16_t phy_cnt); 447 448 /** 449 * reg_update_hal_reg_cap() - Update HAL REG capabilities 450 * @psoc: psoc pointer 451 * @wireless_modes: 11AX wireless modes 452 * @phy_id: phy id 453 * 454 * Return: QDF_STATUS 455 */ 456 QDF_STATUS reg_update_hal_reg_cap(struct wlan_objmgr_psoc *psoc, 457 uint64_t wireless_modes, uint8_t phy_id); 458 459 /** 460 * reg_chan_in_range() - Check if the given channel is in pdev's channel range 461 * @chan_list: Pointer to regulatory channel list. 462 * @low_freq_2g: Low frequency 2G. 463 * @high_freq_2g: High frequency 2G. 464 * @low_freq_5g: Low frequency 5G. 465 * @high_freq_5g: High frequency 5G. 466 * @ch_enum: Channel enum. 467 * 468 * Return: true if ch_enum is with in pdev's channel range, else false. 469 */ 470 bool reg_chan_in_range(struct regulatory_channel *chan_list, 471 qdf_freq_t low_freq_2g, qdf_freq_t high_freq_2g, 472 qdf_freq_t low_freq_5g, qdf_freq_t high_freq_5g, 473 enum channel_enum ch_enum); 474 475 /** 476 * reg_init_channel_map() - Initialize the channel list based on the dfs region. 477 * @dfs_region: Dfs region 478 */ 479 void reg_init_channel_map(enum dfs_reg dfs_region); 480 481 /** 482 * reg_get_psoc_tx_ops() - Get regdb tx ops 483 * @psoc: Pointer to psoc structure 484 */ 485 struct wlan_lmac_if_reg_tx_ops *reg_get_psoc_tx_ops( 486 struct wlan_objmgr_psoc *psoc); 487 488 /** 489 * reg_is_24ghz_ch_freq() - Check if the given channel frequency is 2.4GHz 490 * @freq: Channel frequency 491 * 492 * Return: true if channel frequency is 2.4GHz, else false 493 */ 494 bool reg_is_24ghz_ch_freq(uint32_t freq); 495 496 /** 497 * reg_is_5ghz_ch_freq() - Check if the given channel frequency is 5GHz 498 * @freq: Channel frequency 499 * 500 * Return: true if channel frequency is 5GHz, else false 501 */ 502 bool reg_is_5ghz_ch_freq(uint32_t freq); 503 504 /** 505 * reg_is_range_overlap_2g() - Check if the given low_freq and high_freq 506 * is in the 2G range. 507 * 508 * @low_freq - Low frequency. 509 * @high_freq - High frequency. 510 * 511 * Return: Return true if given low_freq and high_freq overlaps 2G range, 512 * else false. 513 */ 514 bool reg_is_range_overlap_2g(qdf_freq_t low_freq, qdf_freq_t high_freq); 515 516 /** 517 * reg_is_range_overlap_5g() - Check if the given low_freq and high_freq 518 * is in the 5G range. 519 * 520 * @low_freq - Low frequency. 521 * @high_freq - High frequency. 522 * 523 * Return: Return true if given low_freq and high_freq overlaps 5G range, 524 * else false. 525 */ 526 bool reg_is_range_overlap_5g(qdf_freq_t low_freq, qdf_freq_t high_freq); 527 528 /** 529 * reg_is_freq_indoor() - Check if the input frequency is an indoor frequency. 530 * @pdev: Pointer to pdev. 531 * @freq: Channel frequency. 532 * 533 * Return: Return true if the input frequency is indoor, else false. 534 */ 535 bool reg_is_freq_indoor(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq); 536 537 /** 538 * reg_get_min_chwidth() - Return min chanwidth supported by freq. 539 * @pdev: Pointer to pdev. 540 * @freq: Channel frequency. 541 * 542 * Return: Min chwidth supported by freq as per regulatory DB. 543 */ 544 uint16_t reg_get_min_chwidth(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq); 545 546 /** 547 * reg_get_max_chwidth() - Return max chanwidth supported by freq. 548 * @pdev: Pointer to pdev. 549 * @freq: Channel frequency. 550 * 551 * Return: Max chwidth supported by freq as per regulatory DB. 552 */ 553 uint16_t reg_get_max_chwidth(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq); 554 555 #ifdef CONFIG_REG_CLIENT 556 /** 557 * reg_is_freq_indoor_in_secondary_list() - Check if the input frequency is 558 * an indoor frequency in the secondary channel list 559 * @pdev: Pointer to pdev. 560 * @freq: Channel frequency. 561 * 562 * Return: Return true if the input frequency is indoor, else false. 563 */ 564 bool reg_is_freq_indoor_in_secondary_list(struct wlan_objmgr_pdev *pdev, 565 qdf_freq_t freq); 566 #endif 567 568 #ifdef CONFIG_BAND_6GHZ 569 /** 570 * reg_is_6ghz_chan_freq() - Check if the given channel frequency is 6GHz 571 * @freq: Channel frequency 572 * 573 * Return: true if channel frequency is 6GHz, else false 574 */ 575 bool reg_is_6ghz_chan_freq(uint16_t freq); 576 577 #ifdef CONFIG_6G_FREQ_OVERLAP 578 /** 579 * reg_is_range_only6g() - Check if the given low_freq and high_freq is only in 580 * the 6G range. 581 * 582 * @low_freq - Low frequency. 583 * @high_freq - High frequency. 584 * 585 * Return: Return true if given low_freq and high_freq overlaps only the 6G 586 * range, else false. 587 */ 588 bool reg_is_range_only6g(qdf_freq_t low_freq, qdf_freq_t high_freq); 589 590 /** 591 * reg_is_range_overlap_6g() - Check if the given low_freq and high_freq 592 * is in the 6G range. 593 * 594 * @low_freq - Low frequency. 595 * @high_freq - High frequency. 596 * 597 * Return: Return true if given low_freq and high_freq overlaps 6G range, 598 * else false. 599 */ 600 bool reg_is_range_overlap_6g(qdf_freq_t low_freq, qdf_freq_t high_freq); 601 #endif 602 603 /** 604 * REG_IS_6GHZ_FREQ() - Check if the given channel frequency is 6GHz 605 * @freq: Channel frequency 606 * 607 * Return: true if channel frequency is 6GHz, else false 608 */ 609 static inline bool REG_IS_6GHZ_FREQ(uint16_t freq) 610 { 611 return ((freq >= REG_MIN_6GHZ_CHAN_FREQ) && 612 (freq <= REG_MAX_6GHZ_CHAN_FREQ)); 613 } 614 615 /** 616 * reg_is_6ghz_psc_chan_freq() - Check if the given 6GHz channel frequency is 617 * preferred scanning channel frequency. 618 * @freq: Channel frequency 619 * 620 * Return: true if given 6GHz channel frequency is preferred scanning channel 621 * frequency, else false 622 */ 623 bool reg_is_6ghz_psc_chan_freq(uint16_t freq); 624 625 /** 626 * reg_is_6g_freq_indoor() - Check if a 6GHz frequency is indoor. 627 * @pdev: Pointer to pdev. 628 * @freq: Channel frequency. 629 * 630 * Return: Return true if a 6GHz frequency is indoor, else false. 631 */ 632 bool reg_is_6g_freq_indoor(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq); 633 634 /** 635 * reg_get_max_txpower_for_6g_tpe() - Get max txpower for 6G TPE IE. 636 * @pdev: Pointer to pdev. 637 * @freq: Channel frequency. 638 * @bw: Channel bandwidth. 639 * @reg_ap: Regulatory 6G AP type. 640 * @reg_client: Regulatory 6G client type. 641 * @is_psd: True if txpower is needed in PSD format, and false if needed in EIRP 642 * format. 643 * @tx_power: Pointer to tx-power. 644 * 645 * Return: Return QDF_STATUS_SUCCESS, if tx_power is filled for 6G TPE IE 646 * else return QDF_STATUS_E_FAILURE. 647 */ 648 QDF_STATUS reg_get_max_txpower_for_6g_tpe(struct wlan_objmgr_pdev *pdev, 649 qdf_freq_t freq, uint8_t bw, 650 enum reg_6g_ap_type reg_ap, 651 enum reg_6g_client_type reg_client, 652 bool is_psd, 653 uint8_t *tx_power); 654 655 /** 656 * reg_min_6ghz_chan_freq() - Get minimum 6GHz channel center frequency 657 * 658 * Return: Minimum 6GHz channel center frequency 659 */ 660 uint16_t reg_min_6ghz_chan_freq(void); 661 662 /** 663 * reg_max_6ghz_chan_freq() - Get maximum 6GHz channel center frequency 664 * 665 * Return: Maximum 6GHz channel center frequency 666 */ 667 uint16_t reg_max_6ghz_chan_freq(void); 668 #else 669 static inline bool reg_is_6ghz_chan_freq(uint16_t freq) 670 { 671 return false; 672 } 673 674 static inline bool 675 reg_is_6g_freq_indoor(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq) 676 { 677 return false; 678 } 679 680 static inline QDF_STATUS 681 reg_get_max_txpower_for_6g_tpe(struct wlan_objmgr_pdev *pdev, 682 qdf_freq_t freq, uint8_t bw, 683 enum reg_6g_ap_type reg_ap, 684 enum reg_6g_client_type reg_client, 685 bool is_psd, 686 uint8_t *tx_power) 687 { 688 return QDF_STATUS_E_FAILURE; 689 } 690 691 #ifdef CONFIG_6G_FREQ_OVERLAP 692 static inline bool reg_is_range_overlap_6g(qdf_freq_t low_freq, 693 qdf_freq_t high_freq) 694 { 695 return false; 696 } 697 698 static inline bool reg_is_range_only6g(qdf_freq_t low_freq, 699 qdf_freq_t high_freq) 700 { 701 return false; 702 } 703 #endif 704 705 static inline bool REG_IS_6GHZ_FREQ(uint16_t freq) 706 { 707 return false; 708 } 709 710 static inline bool reg_is_6ghz_psc_chan_freq(uint16_t freq) 711 { 712 return false; 713 } 714 715 static inline uint16_t reg_min_6ghz_chan_freq(void) 716 { 717 return 0; 718 } 719 720 static inline uint16_t reg_max_6ghz_chan_freq(void) 721 { 722 return 0; 723 } 724 #endif /* CONFIG_BAND_6GHZ */ 725 726 /** 727 * reg_get_band_channel_list() - Caller function to 728 * reg_get_band_from_cur_chan_list with primary current channel list 729 * @pdev: pdev ptr 730 * @band_mask: Input bitmap with band set 731 * @channel_list: Pointer to Channel List 732 * 733 * Caller function to reg_get_band_from_cur_chan_listto get the primary channel 734 * list and number of channels (for non-beaconing entities). 735 * 736 * Return: Number of channels, else 0 to indicate error 737 */ 738 uint16_t reg_get_band_channel_list(struct wlan_objmgr_pdev *pdev, 739 uint8_t band_mask, 740 struct regulatory_channel *channel_list); 741 742 #ifdef CONFIG_REG_6G_PWRMODE 743 /** 744 * reg_get_band_channel_list() - Caller function to 745 * reg_get_band_from_cur_chan_list with primary current channel list 746 * @pdev: pdev ptr 747 * @band_mask: Input bitmap with band set 748 * @channel_list: Pointer to Channel List 749 * @in_6g_pwr_type: 6g power type which decides 6G channel list lookup. 750 * 751 * Caller function to reg_get_band_from_cur_chan_listto get the primary channel 752 * list and number of channels (for non-beaconing entities). 753 * 754 * Return: Number of channels, else 0 to indicate error 755 */ 756 uint16_t reg_get_band_channel_list_for_pwrmode(struct wlan_objmgr_pdev *pdev, 757 uint8_t band_mask, 758 struct regulatory_channel 759 *channel_list, 760 enum supported_6g_pwr_types 761 in_6g_pwr_type); 762 #endif 763 764 #ifdef CONFIG_REG_CLIENT 765 /** 766 * reg_get_secondary_band_channel_list() - Caller function to 767 * reg_get_band_from_cur_chan_list with secondary current channel list 768 * @pdev: pdev ptr 769 * @band_mask: Input bitmap with band set 770 * @channel_list: Pointer to Channel List 771 * 772 * Caller function to reg_get_band_from_cur_chan_list to get the secondary 773 * channel list and number of channels (for beaconing entities). 774 * 775 * Return: Number of channels, else 0 to indicate error 776 */ 777 uint16_t reg_get_secondary_band_channel_list(struct wlan_objmgr_pdev *pdev, 778 uint8_t band_mask, 779 struct regulatory_channel 780 *channel_list); 781 #endif 782 783 /** 784 * reg_chan_band_to_freq - Return channel frequency based on the channel number 785 * and band. 786 * @pdev: pdev ptr 787 * @chan: Channel Number 788 * @band_mask: Bitmap for bands 789 * 790 * Return: Return channel frequency or return 0, if the channel is disabled or 791 * if the input channel number or band_mask is invalid. Composite bands are 792 * supported only for 2.4Ghz and 5Ghz bands. For other bands the following 793 * priority is given: 1) 6Ghz 2) 5Ghz 3) 2.4Ghz. 794 */ 795 qdf_freq_t reg_chan_band_to_freq(struct wlan_objmgr_pdev *pdev, 796 uint8_t chan, 797 uint8_t band_mask); 798 799 /** 800 * reg_is_49ghz_freq() - Check if the given channel frequency is 4.9GHz 801 * @freq: Channel frequency 802 * 803 * Return: true if channel frequency is 4.9GHz, else false 804 */ 805 bool reg_is_49ghz_freq(qdf_freq_t freq); 806 807 /** 808 * reg_ch_num() - Get channel number from channel enum 809 * @ch_enum: Channel enum 810 * 811 * Return: channel number 812 */ 813 qdf_freq_t reg_ch_num(uint32_t ch_enum); 814 815 /** 816 * reg_ch_to_freq() - Get channel frequency from channel enum 817 * @ch_enum: Channel enum 818 * 819 * Return: channel frequency 820 */ 821 qdf_freq_t reg_ch_to_freq(uint32_t ch_enum); 822 823 /** 824 * reg_max_5ghz_ch_num() - Get maximum 5GHz channel number 825 * 826 * Return: Maximum 5GHz channel number 827 */ 828 uint8_t reg_max_5ghz_ch_num(void); 829 830 #ifdef CONFIG_CHAN_FREQ_API 831 /** 832 * reg_min_24ghz_chan_freq() - Get minimum 2.4GHz channel frequency 833 * 834 * Return: Minimum 2.4GHz channel frequency 835 */ 836 qdf_freq_t reg_min_24ghz_chan_freq(void); 837 838 /** 839 * reg_max_24ghz_chan_freq() - Get maximum 2.4GHz channel frequency 840 * 841 * Return: Maximum 2.4GHz channel frequency 842 */ 843 qdf_freq_t reg_max_24ghz_chan_freq(void); 844 845 /** 846 * reg_min_5ghz_chan_freq() - Get minimum 5GHz channel frequency 847 * 848 * Return: Minimum 5GHz channel frequency 849 */ 850 qdf_freq_t reg_min_5ghz_chan_freq(void); 851 852 /** 853 * reg_max_5ghz_chan_freq() - Get maximum 5GHz channel frequency 854 * 855 * Return: Maximum 5GHz channel frequency 856 */ 857 qdf_freq_t reg_max_5ghz_chan_freq(void); 858 #endif /* CONFIG_CHAN_FREQ_API */ 859 860 /** 861 * reg_enable_dfs_channels() - Enable the use of DFS channels 862 * @pdev: The physical dev to enable/disable DFS channels for 863 * 864 * Return: QDF_STATUS 865 */ 866 QDF_STATUS reg_enable_dfs_channels(struct wlan_objmgr_pdev *pdev, bool enable); 867 868 #ifdef WLAN_REG_PARTIAL_OFFLOAD 869 /** 870 * reg_program_default_cc() - Program default country code 871 * @pdev: Pdev pointer 872 * @regdmn: Regdomain value 873 * 874 * Return: QDF_STATUS 875 */ 876 QDF_STATUS reg_program_default_cc(struct wlan_objmgr_pdev *pdev, 877 uint16_t regdmn); 878 879 /** 880 * reg_is_regdmn_en302502_applicable() - Find if ETSI EN302_502 radar pattern 881 * is applicable in current regulatory domain. 882 * @pdev: Pdev object pointer. 883 * 884 * Return: True if en302_502 is applicable, else false. 885 */ 886 bool reg_is_regdmn_en302502_applicable(struct wlan_objmgr_pdev *pdev); 887 #endif 888 889 /** 890 * reg_update_channel_ranges() - Update the channel ranges with the new 891 * phy capabilities. 892 * @pdev: The physical dev for which channel ranges are to be updated. 893 * 894 * Return: QDF_STATUS. 895 */ 896 QDF_STATUS reg_update_channel_ranges(struct wlan_objmgr_pdev *pdev); 897 898 /** 899 * reg_modify_pdev_chan_range() - Compute current channel list 900 * in accordance with the modified reg caps. 901 * @pdev: The physical dev for which channel list must be built. 902 * 903 * Return: QDF_STATUS 904 */ 905 QDF_STATUS reg_modify_pdev_chan_range(struct wlan_objmgr_pdev *pdev); 906 907 /** 908 * reg_update_pdev_wireless_modes() - Update the wireless_modes in the 909 * pdev_priv_obj with the input wireless_modes 910 * @pdev: pointer to wlan_objmgr_pdev. 911 * @wireless_modes: Wireless modes. 912 * 913 * Return : QDF_STATUS 914 */ 915 QDF_STATUS reg_update_pdev_wireless_modes(struct wlan_objmgr_pdev *pdev, 916 uint64_t wireless_modes); 917 918 /** 919 * reg_get_phybitmap() - Get phybitmap from regulatory pdev_priv_obj 920 * @pdev: pdev pointer 921 * @phybitmap: pointer to phybitmap 922 * 923 * Return: QDF STATUS 924 */ 925 QDF_STATUS reg_get_phybitmap(struct wlan_objmgr_pdev *pdev, 926 uint16_t *phybitmap); 927 #ifdef DISABLE_UNII_SHARED_BANDS 928 /** 929 * reg_disable_chan_coex() - Disable Coexisting channels based on the input 930 * bitmask. 931 * @pdev: pointer to wlan_objmgr_pdev. 932 * unii_5g_bitmap: UNII 5G bitmap. 933 * 934 * Return : QDF_STATUS 935 */ 936 QDF_STATUS reg_disable_chan_coex(struct wlan_objmgr_pdev *pdev, 937 uint8_t unii_5g_bitmap); 938 #endif 939 940 #ifdef CONFIG_CHAN_FREQ_API 941 /** 942 * reg_is_freq_present_in_cur_chan_list() - Check the input frequency 943 * @pdev: Pointer to pdev 944 * @freq: Channel center frequency in MHz 945 * 946 * Check if the input channel center frequency is present in the current 947 * channel list 948 * 949 * Return: Return true if channel center frequency is present in the current 950 * channel list, else return false. 951 */ 952 bool 953 reg_is_freq_present_in_cur_chan_list(struct wlan_objmgr_pdev *pdev, 954 qdf_freq_t freq); 955 956 /** 957 * reg_get_chan_enum_for_freq() - Get channel enum for given channel frequency 958 * @freq: Channel Frequency 959 * 960 * Return: Channel enum 961 */ 962 enum channel_enum reg_get_chan_enum_for_freq(qdf_freq_t freq); 963 964 /** 965 * reg_get_channel_list_with_power_for_freq() - Provides the channel list with 966 * power 967 * @pdev: Pointer to pdev 968 * @ch_list: Pointer to the channel list. 969 * @num_chan: Pointer to save number of channels 970 * 971 * Return: QDF_STATUS 972 */ 973 QDF_STATUS 974 reg_get_channel_list_with_power_for_freq(struct wlan_objmgr_pdev *pdev, 975 struct channel_power *ch_list, 976 uint8_t *num_chan); 977 978 #ifdef CONFIG_REG_6G_PWRMODE 979 /** 980 * reg_get_channel_state_for_pwrmode() - Get channel state from regulatory 981 * @pdev: Pointer to pdev 982 * @freq: channel center frequency. 983 * @in_6g_pwr_type: 6g power type which decides 6G channel list lookup. 984 * 985 * Return: channel state 986 */ 987 enum channel_state 988 reg_get_channel_state_for_pwrmode(struct wlan_objmgr_pdev *pdev, 989 qdf_freq_t freq, 990 enum supported_6g_pwr_types in_6g_pwr_type); 991 #endif 992 993 #ifdef CONFIG_REG_CLIENT 994 /** 995 * reg_get_channel_state_from_secondary_list_for_freq() - Get channel state 996 * from secondary regulatory current channel list 997 * @pdev: Pointer to pdev 998 * @freq: channel center frequency. 999 * 1000 * Return: channel state 1001 */ 1002 enum channel_state reg_get_channel_state_from_secondary_list_for_freq( 1003 struct wlan_objmgr_pdev *pdev, 1004 qdf_freq_t freq); 1005 1006 /** 1007 * reg_get_channel_list_with_power() - Provides the channel list with power 1008 * @pdev: Pointer to pdev 1009 * @ch_list: Pointer to the channel list. 1010 * @num_chan: Pointer to save number of channels 1011 * @in_6g_pwr_type: 6G power type corresponding to which 6G channel list is 1012 * required 1013 * 1014 * Return: QDF_STATUS 1015 */ 1016 QDF_STATUS reg_get_channel_list_with_power( 1017 struct wlan_objmgr_pdev *pdev, 1018 struct channel_power *ch_list, 1019 uint8_t *num_chan, 1020 enum supported_6g_pwr_types in_6g_pwr_type); 1021 #endif 1022 1023 /** 1024 * reg_get_5g_bonded_channel_state_for_freq() - Get channel state for 1025 * 5G bonded channel using the channel frequency 1026 * @pdev: Pointer to pdev 1027 * @freq: channel center frequency. 1028 * @ch_params: channel parameters 1029 * @in_6g_pwr_type: 6g power type which decides 6G channel list lookup. 1030 * 1031 * Return: channel state 1032 */ 1033 enum channel_state 1034 reg_get_5g_bonded_channel_state_for_freq(struct wlan_objmgr_pdev *pdev, 1035 qdf_freq_t freq, 1036 struct ch_params *ch_params); 1037 1038 #ifdef CONFIG_REG_6G_PWRMODE 1039 enum channel_state 1040 reg_get_5g_bonded_channel_state_for_pwrmode(struct wlan_objmgr_pdev *pdev, 1041 qdf_freq_t freq, 1042 struct ch_params *ch_params, 1043 enum supported_6g_pwr_types 1044 in_6g_pwr_mode); 1045 #endif 1046 1047 /** 1048 * reg_get_2g_bonded_channel_state_for_freq() - Get channel state for 2G 1049 * bonded channel 1050 * @freq: channel center frequency. 1051 * @pdev: Pointer to pdev 1052 * @oper_ch_freq: Primary channel center frequency 1053 * @sec_ch_freq: Secondary channel center frequency 1054 * @bw: channel band width 1055 * 1056 * Return: channel state 1057 */ 1058 enum channel_state 1059 reg_get_2g_bonded_channel_state_for_freq(struct wlan_objmgr_pdev *pdev, 1060 qdf_freq_t oper_ch_freq, 1061 qdf_freq_t sec_ch_freq, 1062 enum phy_ch_width bw); 1063 1064 /** 1065 * reg_set_channel_params_for_freq () - Sets channel parameteres for given 1066 * bandwidth 1067 * @pdev: Pointer to pdev 1068 * @freq: Channel center frequency. 1069 * @sec_ch_2g_freq: Secondary 2G channel frequency 1070 * @ch_params: pointer to the channel parameters. 1071 * @treat_nol_chan_as_disabled: bool to treat nol channel as enabled or 1072 * disabled. If set to true, nol chan is considered as disabled in chan search. 1073 * 1074 * Return: None 1075 */ 1076 void reg_set_channel_params_for_freq(struct wlan_objmgr_pdev *pdev, 1077 qdf_freq_t freq, 1078 qdf_freq_t sec_ch_2g_freq, 1079 struct ch_params *ch_params, 1080 bool treat_nol_chan_as_disabled); 1081 1082 #ifdef CONFIG_REG_6G_PWRMODE 1083 /** 1084 * reg_set_channel_params_for_pwrmode () - Sets channel parameteres for given 1085 * bandwidth 1086 * @pdev: Pointer to pdev 1087 * @freq: Channel center frequency. 1088 * @sec_ch_2g_freq: Secondary 2G channel frequency 1089 * @ch_params: pointer to the channel parameters. 1090 * @in_6g_pwr_type: 6g power type which decides 6G channel list lookup. 1091 * @treat_nol_chan_as_disabled: bool to treat nol channel as enabled or 1092 * disabled. If set to true, nol chan is considered as disabled in chan search. 1093 * 1094 * Return: None 1095 */ 1096 void reg_set_channel_params_for_pwrmode(struct wlan_objmgr_pdev *pdev, 1097 qdf_freq_t freq, 1098 qdf_freq_t sec_ch_2g_freq, 1099 struct ch_params *ch_params, 1100 enum supported_6g_pwr_types 1101 in_6g_pwr_mode, 1102 bool treat_nol_chan_as_disabled); 1103 #endif 1104 1105 #ifdef WLAN_FEATURE_11BE 1106 /** 1107 * reg_fill_channel_list() - Fills an array of ch_params (list of 1108 * channels) for the given channel width and primary freq. 1109 * If 320 band_center is given, ch_params corresponding to the 1110 * given band_center is filled. 1111 * 1112 * @pdev: Pointer to pdev 1113 * @freq: Center frequency of the primary channel in MHz 1114 * @sec_ch_2g_freq: Secondary 2G channel frequency in MHZ 1115 * @ch_width: Input channel width. 1116 * @band_center: Center frequency of the 320MHZ channel. 1117 * @chan_list: Pointer to struct reg_channel_list to be filled (Output). 1118 * The caller is supposed to provide enough storage for the elements 1119 * in the list. 1120 * @in_6g_pwr_type: 6g power type which decides 6G channel list lookup. 1121 * @treat_nol_chan_as_disabled: bool to treat nol channel as enabled or 1122 * disabled. If set to true, nol chan is considered as disabled in chan search. 1123 * 1124 * Return: None 1125 */ 1126 void 1127 reg_fill_channel_list(struct wlan_objmgr_pdev *pdev, 1128 qdf_freq_t freq, 1129 qdf_freq_t sec_ch_2g_freq, 1130 enum phy_ch_width ch_width, 1131 qdf_freq_t band_center_320, 1132 struct reg_channel_list *chan_list, 1133 bool treat_nol_chan_as_disabled); 1134 1135 #ifdef CONFIG_REG_6G_PWRMODE 1136 /** 1137 * reg_fill_channel_list_for_pwrmode() - Fills an array of ch_params (list of 1138 * channels) for the given channel width and primary freq. 1139 * If 320 band_center is given, ch_params corresponding to the 1140 * given band_center is filled. 1141 * 1142 * @pdev: Pointer to pdev 1143 * @freq: Center frequency of the primary channel in MHz 1144 * @sec_ch_2g_freq: Secondary 2G channel frequency in MHZ 1145 * @ch_width: Input channel width. 1146 * @band_center: Center frequency of the 320MHZ channel. 1147 * @chan_list: Pointer to struct reg_channel_list to be filled (Output). 1148 * The caller is supposed to provide enough storage for the elements 1149 * in the list. 1150 * @in_6g_pwr_type: 6g power type which decides 6G channel list lookup. 1151 * @treat_nol_chan_as_disabled: bool to treat nol channel as enabled or 1152 * disabled. If set to true, nol chan is considered as disabled in chan search. 1153 * 1154 * Return: None 1155 */ 1156 void 1157 reg_fill_channel_list_for_pwrmode(struct wlan_objmgr_pdev *pdev, 1158 qdf_freq_t freq, 1159 qdf_freq_t sec_ch_2g_freq, 1160 enum phy_ch_width ch_width, 1161 qdf_freq_t band_center_320, 1162 struct reg_channel_list *chan_list, 1163 enum supported_6g_pwr_types in_6g_pwr_mode, 1164 bool treat_nol_chan_as_disabled); 1165 #endif 1166 1167 /** 1168 * reg_is_punc_bitmap_valid() - is puncture bitmap valid or not 1169 * @bw: Input channel width. 1170 * @puncture_bitmap Input puncture bitmap. 1171 * 1172 * Return: true if given puncture bitmap is valid 1173 */ 1174 bool reg_is_punc_bitmap_valid(enum phy_ch_width bw, uint16_t puncture_bitmap); 1175 1176 #ifdef QCA_DFS_BW_PUNCTURE 1177 /** 1178 * reg_find_nearest_puncture_pattern() - is generated bitmap is valid or not 1179 * @bw: Input channel width. 1180 * @proposed_bitmap: Input puncture bitmap. 1181 * 1182 * Return: Radar bitmap if it is valid. 1183 */ 1184 uint16_t reg_find_nearest_puncture_pattern(enum phy_ch_width bw, 1185 uint16_t proposed_bitmap); 1186 #else 1187 static inline 1188 uint16_t reg_find_nearest_puncture_pattern(enum phy_ch_width bw, 1189 uint16_t proposed_bitmap) 1190 { 1191 return 0; 1192 } 1193 #endif /* QCA_DFS_BW_PUNCTURE */ 1194 1195 /** 1196 * reg_extract_puncture_by_bw() - generate new puncture bitmap from original 1197 * puncture bitmap and bandwidth based on new 1198 * bandwidth 1199 * @ori_bw: original bandwidth 1200 * @ori_puncture_bitmap: original puncture bitmap 1201 * @freq: frequency of primary channel 1202 * @cen320_freq: center frequency of 320 MHZ if channel width is 320 1203 * @new_bw new bandwidth. It should be smaller than original bandwidth 1204 * @new_puncture_bitmap: output of puncture bitmap 1205 * 1206 * Example 1: ori_bw = CH_WIDTH_320MHZ (center 320 = 6105{IEEE31}) 1207 * freq = 6075 ( Primary chan location: 0000_000P_0000_0000) 1208 * ori_puncture_bitmap = B1111 0000 0011 0000(binary) 1209 * If new_bw = CH_WIDTH_160MHZ, then new_puncture_bitmap = B0011 0000(binary) 1210 * If new_bw = CH_WIDTH_80MHZ, then new_puncture_bitmap = B0011(binary) 1211 * 1212 * Example 2: ori_bw = CH_WIDTH_320MHZ (center 320 = 6105{IEEE31}) 1213 * freq = 6135 ( Primary chan location: 0000_0000_0P00_0000) 1214 * ori_puncture_bitmap = B1111 0000 0011 0000(binary) 1215 * If new_bw = CH_WIDTH_160MHZ, then new_puncture_bitmap = B1111 0000(binary) 1216 * If new_bw = CH_WIDTH_80MHZ, then new_puncture_bitmap = B0000(binary) 1217 * 1218 * Return: QDF_STATUS 1219 */ 1220 QDF_STATUS reg_extract_puncture_by_bw(enum phy_ch_width ori_bw, 1221 uint16_t ori_puncture_bitmap, 1222 qdf_freq_t freq, 1223 qdf_freq_t cen320_freq, 1224 enum phy_ch_width new_bw, 1225 uint16_t *new_puncture_bitmap); 1226 1227 /** 1228 * reg_set_create_punc_bitmap() - set is_create_punc_bitmap of ch_params 1229 * @ch_params: ch_params to set 1230 * @is_create_punc_bitmap: is create punc bitmap 1231 * 1232 * Return: NULL 1233 */ 1234 void reg_set_create_punc_bitmap(struct ch_params *ch_params, 1235 bool is_create_punc_bitmap); 1236 1237 #ifdef CONFIG_REG_CLIENT 1238 /** 1239 * reg_apply_puncture() - apply puncture to regulatory 1240 * @pdev: pdev 1241 * @puncture_bitmap: puncture bitmap 1242 * @freq: sap operation freq 1243 * @bw: band width 1244 * @cen320_freq: 320 MHz center freq 1245 * 1246 * When start ap, apply puncture to regulatory, set static puncture flag 1247 * for all 20 MHz sub channels of current bonded channel in master channel list 1248 * of pdev, and disable 20 MHz sub channel in current channel list if static 1249 * puncture flag is set. 1250 * 1251 * Return: QDF_STATUS 1252 */ 1253 QDF_STATUS reg_apply_puncture(struct wlan_objmgr_pdev *pdev, 1254 uint16_t puncture_bitmap, 1255 qdf_freq_t freq, 1256 enum phy_ch_width bw, 1257 qdf_freq_t cen320_freq); 1258 1259 /** 1260 * wlan_reg_remove_puncture() - Remove puncture from regulatory 1261 * @pdev: pdev 1262 * 1263 * When stop ap, remove puncture from regulatory, clear static puncture flag 1264 * for all 20 MHz sub channels in master channel list of pdev, and don't disable 1265 * 20 MHz sub channel in current channel list if static puncture flag is not 1266 * set. 1267 * 1268 * Return: QDF_STATUS 1269 */ 1270 QDF_STATUS reg_remove_puncture(struct wlan_objmgr_pdev *pdev); 1271 #endif 1272 #else 1273 static inline 1274 QDF_STATUS reg_extract_puncture_by_bw(enum phy_ch_width ori_bw, 1275 uint16_t ori_puncture_bitmap, 1276 qdf_freq_t freq, 1277 qdf_freq_t cen320_freq, 1278 enum phy_ch_width new_bw, 1279 uint16_t *new_puncture_bitmap) 1280 { 1281 return QDF_STATUS_SUCCESS; 1282 } 1283 1284 static inline void reg_set_create_punc_bitmap(struct ch_params *ch_params, 1285 bool is_create_punc_bitmap) 1286 { 1287 } 1288 #endif 1289 /** 1290 * reg_get_channel_reg_power_for_freq() - Get the txpower for the given channel 1291 * @pdev: Pointer to pdev 1292 * @freq: Channel frequency 1293 * 1294 * Return: txpower 1295 */ 1296 uint8_t reg_get_channel_reg_power_for_freq(struct wlan_objmgr_pdev *pdev, 1297 qdf_freq_t freq); 1298 1299 /** 1300 * reg_update_nol_ch_for_freq () - Updates NOL channels in current channel list 1301 * @pdev: pointer to pdev object 1302 * @chan_freq_list: pointer to NOL channel list 1303 * @num_ch: No.of channels in list 1304 * @update_nol: set/reset the NOL status 1305 * 1306 * Return: None 1307 */ 1308 void reg_update_nol_ch_for_freq(struct wlan_objmgr_pdev *pdev, 1309 uint16_t *chan_freq_list, 1310 uint8_t num_chan, 1311 bool nol_chan); 1312 /** 1313 * reg_is_dfs_for_freq () - Checks the channel state for DFS 1314 * @pdev: pdev ptr 1315 * @freq: Channel center frequency 1316 * 1317 * Return: true or false 1318 */ 1319 bool reg_is_dfs_for_freq(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq); 1320 1321 #ifdef CONFIG_REG_CLIENT 1322 /** 1323 * reg_is_dfs_in_secondary_list_for_freq() - Checks the channel state for DFS 1324 * from the secondary channel list 1325 * @pdev: pdev ptr 1326 * @freq: Channel center frequency 1327 * 1328 * Return: true or false 1329 */ 1330 bool reg_is_dfs_in_secondary_list_for_freq(struct wlan_objmgr_pdev *pdev, 1331 qdf_freq_t freq); 1332 1333 /** 1334 * reg_get_channel_power_attr_from_secondary_list_for_freq() - get channel 1335 * power attributions from secondary channel list. 1336 * @pdev: pdev pointer 1337 * @freq: channel frequency 1338 * @is_psd: pointer to retrieve value whether channel power is psd 1339 * @tx_power: pointer to retrieve value of channel eirp tx power 1340 * @psd_eirp: pointer to retrieve value of channel psd eirp power 1341 * @flags: pointer to retrieve value of channel flags 1342 * 1343 * Return: QDF STATUS 1344 */ 1345 QDF_STATUS 1346 reg_get_channel_power_attr_from_secondary_list_for_freq( 1347 struct wlan_objmgr_pdev *pdev, 1348 qdf_freq_t freq, bool *is_psd, 1349 uint16_t *tx_power, uint16_t *psd_eirp, 1350 uint32_t *flags); 1351 1352 #ifdef CONFIG_BAND_6GHZ 1353 /** 1354 * reg_decide_6ghz_power_within_bw_for_freq() - decide tx power and 6 GHz power 1355 * type given channel frequency and bandwidth. 1356 * @pdev: pdev pointer 1357 * @freq: channel frequency 1358 * @bw: channel bandwidth 1359 * @is_psd: pointer to retrieve value whether channel power is psd 1360 * @min_tx_power: pointer to retrieve value of minimum eirp tx power in bw 1361 * @min_psd_eirp: pointer to retrieve value of minimum psd eirp power in bw 1362 * @power_type: pointer to retrieve value of 6 GHz power type 1363 * 1364 * Return: QDF STATUS 1365 */ 1366 QDF_STATUS 1367 reg_decide_6ghz_power_within_bw_for_freq(struct wlan_objmgr_pdev *pdev, 1368 qdf_freq_t freq, enum phy_ch_width bw, 1369 bool *is_psd, uint16_t *min_tx_power, 1370 int16_t *min_psd_eirp, 1371 enum reg_6g_ap_type *power_type); 1372 #else 1373 static inline QDF_STATUS 1374 reg_decide_6ghz_power_within_bw_for_freq(struct wlan_objmgr_pdev *pdev, 1375 qdf_freq_t freq, enum phy_ch_width bw, 1376 bool *is_psd, uint16_t *min_tx_power, 1377 int16_t *min_psd_eirp, 1378 enum reg_6g_ap_type *power_type) 1379 { 1380 return QDF_STATUS_E_NOSUPPORT; 1381 } 1382 #endif 1383 #endif 1384 1385 /** 1386 * reg_chan_freq_is_49ghz() - Check if the input channel center frequency is 1387 * 4.9GHz 1388 * @pdev: Pdev pointer 1389 * @chan_num: Input channel center frequency 1390 * 1391 * Return: true if the frequency is 4.9GHz else false. 1392 */ 1393 bool reg_chan_freq_is_49ghz(qdf_freq_t freq); 1394 1395 /** 1396 * reg_update_nol_history_ch_for_freq() - Set nol-history flag for the channels 1397 * in the list. 1398 * @pdev: Pdev ptr. 1399 * @chan_list: Input channel frequency list. 1400 * @num_ch: Number of channels. 1401 * @nol_history_ch: NOL-History flag. 1402 * 1403 * Return: void 1404 */ 1405 void reg_update_nol_history_ch_for_freq(struct wlan_objmgr_pdev *pdev, 1406 uint16_t *chan_list, 1407 uint8_t num_chan, 1408 bool nol_history_chan); 1409 1410 /** 1411 * reg_is_same_5g_band_freqs() - Check if given channel center 1412 * frequencies have same band 1413 * @freq1: Channel Center Frequency 1 1414 * @freq2: Channel Center Frequency 2 1415 * 1416 * Return: true if both the frequencies has the same band. 1417 */ 1418 bool reg_is_same_band_freqs(qdf_freq_t freq1, qdf_freq_t freq2); 1419 1420 /** 1421 * reg_freq_to_band() - Get band from channel frequency 1422 * @chan_num: channel frequency 1423 * 1424 * Return: wifi band 1425 */ 1426 enum reg_wifi_band reg_freq_to_band(qdf_freq_t freq); 1427 1428 /** 1429 * reg_min_chan_freq() - minimum channel frequency supported 1430 * 1431 * Return: channel frequency 1432 */ 1433 qdf_freq_t reg_min_chan_freq(void); 1434 1435 /** 1436 * reg_max_chan_freq() - maximum channel frequency supported 1437 * 1438 * Return: channel frequency 1439 */ 1440 qdf_freq_t reg_max_chan_freq(void); 1441 1442 /** 1443 * reg_get_5g_bonded_channel_for_freq()- Return the channel state for a 1444 * 5G or 6G channel frequency based on the channel width and bonded channel 1445 * @pdev: Pointer to pdev. 1446 * @freq: Channel center frequency. 1447 * @ch_width: Channel Width. 1448 * @bonded_chan_ptr_ptr: Pointer to bonded_channel_freq. 1449 * @in_6g_pwr_type: 6g power type which decides 6G channel list lookup. 1450 * 1451 * Return: Channel State 1452 */ 1453 enum channel_state 1454 reg_get_5g_bonded_channel_for_freq(struct wlan_objmgr_pdev *pdev, 1455 uint16_t freq, 1456 enum phy_ch_width ch_width, 1457 const struct bonded_channel_freq 1458 **bonded_chan_ptr_ptr); 1459 1460 #ifdef CONFIG_REG_6G_PWRMODE 1461 /** 1462 * reg_get_5g_bonded_channel_for_pwrmode()- Return the channel state for a 1463 * 5G or 6G channel frequency based on the channel width and bonded channel 1464 * @pdev: Pointer to pdev. 1465 * @freq: Channel center frequency. 1466 * @ch_width: Channel Width. 1467 * @bonded_chan_ptr_ptr: Pointer to bonded_channel_freq. 1468 * @in_6g_pwr_type: 6g power type which decides 6G channel list lookup. 1469 * @input_puncture_bitmap: Input puncture bitmap 1470 * 1471 * Return: Channel State 1472 */ 1473 enum channel_state 1474 reg_get_5g_bonded_channel_for_pwrmode(struct wlan_objmgr_pdev *pdev, 1475 uint16_t freq, 1476 enum phy_ch_width ch_width, 1477 const struct bonded_channel_freq 1478 **bonded_chan_ptr_ptr, 1479 enum supported_6g_pwr_types 1480 in_6g_pwr_mode, 1481 uint16_t input_puncture_bitmap); 1482 #endif 1483 1484 #ifdef CONFIG_REG_6G_PWRMODE 1485 /** 1486 * reg_is_disable_for_pwrmode() - Check if the given channel frequency in 1487 * disable state 1488 * @pdev: Pointer to pdev 1489 * @freq: Channel frequency 1490 * @in_6g_pwr_type: 6g power type which decides 6G channel list lookup. 1491 * 1492 * Return: True if channel state is disabled, else false 1493 */ 1494 bool reg_is_disable_for_pwrmode(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq, 1495 enum supported_6g_pwr_types in_6g_pwr_mode); 1496 #endif 1497 1498 #ifdef CONFIG_REG_CLIENT 1499 /** 1500 * reg_is_disable_in_secondary_list_for_freq() - Check if the given channel 1501 * frequency is in disable state 1502 * @pdev: Pointer to pdev 1503 * @freq: Channel frequency 1504 * 1505 * Return: True if channel state is disabled, else false 1506 */ 1507 bool reg_is_disable_in_secondary_list_for_freq(struct wlan_objmgr_pdev *pdev, 1508 qdf_freq_t freq); 1509 1510 /** 1511 * reg_is_enable_in_secondary_list_for_freq() - Check if the given channel 1512 * frequency is in enable state 1513 * @pdev: Pointer to pdev 1514 * @freq: Channel frequency 1515 * 1516 * Return: True if channel state is enabled, else false 1517 */ 1518 bool reg_is_enable_in_secondary_list_for_freq(struct wlan_objmgr_pdev *pdev, 1519 qdf_freq_t freq); 1520 1521 /** 1522 * reg_get_max_tx_power_for_pwr_mode() - Get maximum tx power 1523 * @pdev: Pointer to pdev 1524 * @in_6g_pwr_type: 6 GHz power type for which 6GHz frequencies needs to be 1525 * considered while getting the max power 1526 * 1527 * Return: return the value of the maximum tx power for 2GHz/5GHz channels 1528 * from current channel list and for 6GHz channels from the super channel list 1529 * for the specified power mode 1530 * 1531 */ 1532 uint8_t reg_get_max_tx_power_for_pwr_mode( 1533 struct wlan_objmgr_pdev *pdev, 1534 enum supported_6g_pwr_types in_6g_pwr_type); 1535 #endif 1536 1537 /** 1538 * reg_is_passive_for_freq() - Check if the given channel frequency is in 1539 * passive state 1540 * @pdev: Pointer to pdev 1541 * @freq: Channel frequency 1542 * 1543 * Return: True if channel state is passive, else false 1544 */ 1545 bool reg_is_passive_for_freq(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq); 1546 #endif /* CONFIG_CHAN_FREQ_API */ 1547 1548 /** 1549 * reg_get_max_tx_power() - Get maximum tx power from the current channel list 1550 * @pdev: Pointer to pdev 1551 * 1552 * Return: return the value of the maximum tx power in the current channel list 1553 * 1554 */ 1555 uint8_t reg_get_max_tx_power(struct wlan_objmgr_pdev *pdev); 1556 1557 /** 1558 * reg_set_ignore_fw_reg_offload_ind() - Set if regdb offload indication 1559 * needs to be ignored 1560 * @psoc: Pointer to psoc 1561 * 1562 * Return: QDF_STATUS 1563 */ 1564 QDF_STATUS reg_set_ignore_fw_reg_offload_ind(struct wlan_objmgr_psoc *psoc); 1565 1566 /** 1567 * reg_get_ignore_fw_reg_offload_ind() - Check whether regdb offload indication 1568 * needs to be ignored 1569 * 1570 * @psoc: Pointer to psoc 1571 */ 1572 bool reg_get_ignore_fw_reg_offload_ind(struct wlan_objmgr_psoc *psoc); 1573 1574 /** 1575 * reg_set_6ghz_supported() - Set if 6ghz is supported 1576 * 1577 * @psoc: Pointer to psoc 1578 * @val: value 1579 */ 1580 QDF_STATUS reg_set_6ghz_supported(struct wlan_objmgr_psoc *psoc, 1581 bool val); 1582 1583 /** 1584 * reg_set_5dot9_ghz_supported() - Set if 5.9ghz is supported 1585 * 1586 * @psoc: Pointer to psoc 1587 * @val: value 1588 */ 1589 QDF_STATUS reg_set_5dot9_ghz_supported(struct wlan_objmgr_psoc *psoc, 1590 bool val); 1591 1592 /** 1593 * reg_is_6ghz_op_class() - Check whether 6ghz oper class 1594 * 1595 * @pdev: Pointer to pdev 1596 * @op_class: oper class 1597 */ 1598 bool reg_is_6ghz_op_class(struct wlan_objmgr_pdev *pdev, 1599 uint8_t op_class); 1600 1601 #ifdef CONFIG_REG_CLIENT 1602 /** 1603 * reg_is_6ghz_supported() - Whether 6ghz is supported 1604 * 1605 * @psoc: pointer to psoc 1606 */ 1607 bool reg_is_6ghz_supported(struct wlan_objmgr_psoc *psoc); 1608 #endif 1609 1610 /** 1611 * reg_is_5dot9_ghz_supported() - Whether 5.9ghz is supported 1612 * 1613 * @psoc: pointer to psoc 1614 */ 1615 bool reg_is_5dot9_ghz_supported(struct wlan_objmgr_psoc *psoc); 1616 1617 /** 1618 * reg_is_fcc_regdmn () - Checks if the current reg domain is FCC3/FCC8/FCC15/ 1619 * FCC16 or not 1620 * @pdev: pdev ptr 1621 * 1622 * Return: true or false 1623 */ 1624 bool reg_is_fcc_regdmn(struct wlan_objmgr_pdev *pdev); 1625 1626 /** 1627 * reg_is_5dot9_ghz_freq () - Checks if the frequency is 5.9 GHz freq or not 1628 * @freq: frequency 1629 * @pdev: pdev ptr 1630 * 1631 * Return: true or false 1632 */ 1633 bool reg_is_5dot9_ghz_freq(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq); 1634 1635 /** 1636 * reg_is_5dot9_ghz_chan_allowed_master_mode () - Checks if 5.9 GHz channels 1637 * are allowed in master mode or not. 1638 * 1639 * @pdev: pdev ptr 1640 * 1641 * Return: true or false 1642 */ 1643 bool reg_is_5dot9_ghz_chan_allowed_master_mode(struct wlan_objmgr_pdev *pdev); 1644 1645 /** 1646 * reg_get_unii_5g_bitmap() - get unii_5g_bitmap value 1647 * @pdev: pdev pointer 1648 * @bitmap: Pointer to retrieve the unii_5g_bitmap of enum reg_unii_band 1649 * 1650 * Return: QDF_STATUS 1651 */ 1652 #ifdef DISABLE_UNII_SHARED_BANDS 1653 QDF_STATUS 1654 reg_get_unii_5g_bitmap(struct wlan_objmgr_pdev *pdev, uint8_t *bitmap); 1655 #endif 1656 1657 #ifdef CHECK_REG_PHYMODE 1658 /** 1659 * reg_get_max_phymode() - Recursively find the best possible phymode given a 1660 * phymode, a frequency, and per-country regulations 1661 * @pdev: pdev pointer 1662 * @phy_in: phymode that the user requested 1663 * @freq: current operating center frequency 1664 * 1665 * Return: maximum phymode allowed in current country that is <= phy_in 1666 */ 1667 enum reg_phymode reg_get_max_phymode(struct wlan_objmgr_pdev *pdev, 1668 enum reg_phymode phy_in, 1669 qdf_freq_t freq); 1670 #else 1671 static inline enum reg_phymode 1672 reg_get_max_phymode(struct wlan_objmgr_pdev *pdev, 1673 enum reg_phymode phy_in, 1674 qdf_freq_t freq) 1675 { 1676 return REG_PHYMODE_INVALID; 1677 } 1678 #endif /* CHECK_REG_PHYMODE */ 1679 1680 #ifdef CONFIG_REG_CLIENT 1681 /** 1682 * reg_band_bitmap_to_band_info() - Convert the band_bitmap to a band_info enum. 1683 * Since band_info enum only has combinations for 2G and 5G, 6G is not 1684 * considered in this function. 1685 * @band_bitmap: bitmap on top of reg_wifi_band of bands enabled 1686 * 1687 * Return: BAND_ALL if both 2G and 5G band is enabled 1688 * BAND_2G if 2G is enabled but 5G isn't 1689 * BAND_5G if 5G is enabled but 2G isn't 1690 */ 1691 enum band_info reg_band_bitmap_to_band_info(uint32_t band_bitmap); 1692 1693 QDF_STATUS 1694 reg_update_tx_power_on_ctry_change(struct wlan_objmgr_pdev *pdev, 1695 uint8_t vdev_id); 1696 1697 /** 1698 * reg_add_indoor_concurrency() - Add the frequency to the indoor concurrency 1699 * list 1700 * 1701 * @pdev: pointer to pdev 1702 * @vdev_id: vdev id 1703 * @freq: frequency 1704 * @width: channel width 1705 * 1706 * Return: QDF_STATUS 1707 */ 1708 QDF_STATUS 1709 reg_add_indoor_concurrency(struct wlan_objmgr_pdev *pdev, uint8_t vdev_id, 1710 uint32_t freq, enum phy_ch_width width); 1711 1712 /** 1713 * reg_remove_indoor_concurrency() - Remove the vdev entry from the indoor 1714 * concurrency list 1715 * 1716 * @pdev: pointer to pdev 1717 * @vdev_id: vdev id 1718 * @freq: frequency 1719 * 1720 * Return: QDF_STATUS 1721 */ 1722 QDF_STATUS 1723 reg_remove_indoor_concurrency(struct wlan_objmgr_pdev *pdev, uint8_t vdev_id, 1724 uint32_t freq); 1725 1726 /** 1727 * reg_init_indoor_channel_list() - Initialize the indoor concurrency list 1728 * 1729 * @pdev: pointer to pdev 1730 * 1731 * Return: None 1732 */ 1733 void 1734 reg_init_indoor_channel_list(struct wlan_objmgr_pdev *pdev); 1735 /** 1736 * reg_compute_indoor_list_on_cc_change() - Recompute the indoor concurrency 1737 * list on a country change 1738 * 1739 * @psoc: pointer to psoc 1740 * @pdev: pointer to pdev 1741 * 1742 * Return: QDF_STATUS 1743 */ 1744 QDF_STATUS 1745 reg_compute_indoor_list_on_cc_change(struct wlan_objmgr_psoc *psoc, 1746 struct wlan_objmgr_pdev *pdev); 1747 #else 1748 static inline void 1749 reg_init_indoor_channel_list(struct wlan_objmgr_pdev *pdev) 1750 { 1751 } 1752 1753 static inline QDF_STATUS 1754 reg_compute_indoor_list_on_cc_change(struct wlan_objmgr_psoc *psoc, 1755 struct wlan_objmgr_pdev *pdev) 1756 { 1757 return QDF_STATUS_SUCCESS; 1758 } 1759 #endif 1760 1761 #if defined(CONFIG_BAND_6GHZ) 1762 /** 1763 * reg_set_cur_6g_ap_pwr_type() - Set the current 6G regulatory AP power type. 1764 * @pdev: Pointer to PDEV object. 1765 * @reg_6g_ap_type: Regulatory 6G AP type ie VLPI/LPI/SP. 1766 * 1767 * Return: QDF_STATUS_E_INVAL if unable to set and QDF_STATUS_SUCCESS is set. 1768 */ 1769 QDF_STATUS 1770 reg_set_cur_6g_ap_pwr_type(struct wlan_objmgr_pdev *pdev, 1771 enum reg_6g_ap_type reg_cur_6g_ap_pwr_type); 1772 1773 /** 1774 * reg_get_cur_6g_ap_pwr_type() - Get the current 6G regulatory AP power type. 1775 * @reg_6g_ap_pwr_type: The current regulatory 6G AP type ie VLPI/LPI/SP. 1776 * subordinate. 1777 * 1778 * Return: QDF_STATUS. 1779 */ 1780 QDF_STATUS 1781 reg_get_cur_6g_ap_pwr_type(struct wlan_objmgr_pdev *pdev, 1782 enum reg_6g_ap_type *reg_cur_6g_ap_pwr_type); 1783 1784 #ifdef CONFIG_AFC_SUPPORT 1785 /** 1786 * reg_afc_start() - Start the AFC request from regulatory. This finally 1787 * sends the request to registered callbacks 1788 * @pdev: Pointer to pdev 1789 * @req_id: The AFC request ID 1790 * 1791 * Return: QDF_STATUS 1792 */ 1793 QDF_STATUS reg_afc_start(struct wlan_objmgr_pdev *pdev, uint64_t req_id); 1794 1795 /** 1796 * reg_get_partial_afc_req_info() - Get the AFC partial request information 1797 * @pdev: Pointer to pdev 1798 * @afc_req: Address of AFC request pointer 1799 * 1800 * NOTE:- The memory for AFC request is allocated by the function must be 1801 * freed by the caller. 1802 * Return: QDF_STATUS 1803 */ 1804 QDF_STATUS 1805 reg_get_partial_afc_req_info(struct wlan_objmgr_pdev *pdev, 1806 struct wlan_afc_host_partial_request **afc_req); 1807 1808 /** 1809 * reg_print_partial_afc_req_info() - Print the AFC partial request 1810 * information 1811 * @pdev: Pointer to pdev 1812 * @afc_req: Pointer to AFC request 1813 * 1814 * Return: Void 1815 */ 1816 void 1817 reg_print_partial_afc_req_info(struct wlan_objmgr_pdev *pdev, 1818 struct wlan_afc_host_partial_request *afc_req); 1819 1820 /** 1821 * reg_register_afc_req_rx_callback () - add AFC request received callback 1822 * @pdev: Pointer to pdev 1823 * @cbf: Pointer to callback handler 1824 * @arg: Pointer to opaque argument 1825 * 1826 * Return: QDF_STATUS 1827 */ 1828 QDF_STATUS reg_register_afc_req_rx_callback(struct wlan_objmgr_pdev *pdev, 1829 afc_req_rx_evt_handler cbf, 1830 void *arg); 1831 1832 /** 1833 * reg_unregister_afc_req_rx_callback () - remove AFC request received 1834 * callback 1835 * @pdev: Pointer to pdev 1836 * @cbf: Pointer to callback handler 1837 * 1838 * Return: QDF_STATUS 1839 */ 1840 QDF_STATUS reg_unregister_afc_req_rx_callback(struct wlan_objmgr_pdev *pdev, 1841 afc_req_rx_evt_handler cbf); 1842 1843 /** 1844 * reg_register_afc_power_event_callback() - add AFC power event received 1845 * @pdev: Pointer to pdev 1846 * @cbf: Pointer to callback function 1847 * @arg: Pointer to opaque argument 1848 * 1849 * Return: QDF_STATUS 1850 */ 1851 QDF_STATUS 1852 reg_register_afc_power_event_callback(struct wlan_objmgr_pdev *pdev, 1853 afc_power_tx_evt_handler cbf, 1854 void *arg); 1855 /** 1856 * reg_unregister_afc_power_event_callback() - remove AFC power event received 1857 * callback 1858 * @pdev: Pointer to pdev 1859 * @cbf: Pointer to callback function 1860 * 1861 * Return: QDF_STATUS 1862 */ 1863 QDF_STATUS 1864 reg_unregister_afc_power_event_callback(struct wlan_objmgr_pdev *pdev, 1865 afc_power_tx_evt_handler cbf); 1866 1867 /** 1868 * reg_send_afc_power_event() - Send AFC power event to registered 1869 * recipient 1870 * @pdev: Pointer to pdev 1871 * @power_info: Pointer to afc power info 1872 * 1873 * Return: QDF_STATUS 1874 */ 1875 QDF_STATUS reg_send_afc_power_event(struct wlan_objmgr_pdev *pdev, 1876 struct reg_fw_afc_power_event *power_info); 1877 1878 /** 1879 * reg_get_afc_dev_deploy_type() - Get AFC device deployment type 1880 * @pdev: Pointer to pdev 1881 * @reg_afc_dev_type: Pointer to afc device deployment type 1882 * 1883 * Return: QDF_STATUS 1884 */ 1885 QDF_STATUS 1886 reg_get_afc_dev_deploy_type(struct wlan_objmgr_pdev *pdev, 1887 enum reg_afc_dev_deploy_type *reg_afc_dev_type); 1888 1889 /** 1890 * reg_set_afc_soc_dev_deploy_type() - Set AFC soc device deployment type 1891 * @pdev: Pointer to psoc 1892 * @reg_afc_dev_type: afc device deployment type 1893 * 1894 * Return: QDF_STATUS 1895 */ 1896 QDF_STATUS 1897 reg_set_afc_soc_dev_type(struct wlan_objmgr_psoc *psoc, 1898 enum reg_afc_dev_deploy_type reg_afc_dev_type); 1899 1900 /** 1901 * reg_is_sta_connect_allowed() - Check if STA connection is allowed. 1902 * @pdev: Pointer to pdev 1903 * @root_ap_pwr_mode: power mode of the Root AP. 1904 * 1905 * Return: True if STA Vap is allowed to connect. 1906 */ 1907 bool 1908 reg_is_sta_connect_allowed(struct wlan_objmgr_pdev *pdev, 1909 enum reg_6g_ap_type root_ap_pwr_mode); 1910 1911 /** 1912 * reg_get_afc_soc_dev_deploy_type() - Get AFC soc device deployment type 1913 * @pdev: Pointer to psoc 1914 * @reg_afc_dev_type: Pointer to afc device deployment type 1915 * 1916 * Return: QDF_STATUS 1917 */ 1918 QDF_STATUS 1919 reg_get_afc_soc_dev_type(struct wlan_objmgr_psoc *psoc, 1920 enum reg_afc_dev_deploy_type *reg_afc_dev_type); 1921 1922 /** 1923 * reg_set_eirp_preferred_support() - Set EIRP as the preferred 1924 * support for TPC power command 1925 * @psoc: psoc pointer 1926 * @reg_is_eirp_support_preferred: Boolean to indicate if target prefers EIRP 1927 * support for TPC power command 1928 * 1929 * Return: Success or Failure 1930 */ 1931 QDF_STATUS 1932 reg_set_eirp_preferred_support(struct wlan_objmgr_psoc *psoc, 1933 bool reg_is_eirp_support_preferred); 1934 1935 /** 1936 * reg_get_eirp_preferred_support() - Check if is EIRP support is 1937 * preferred by the target for TPC power command 1938 * @psoc: psoc pointer 1939 * @reg_is_eirp_support_preferred: Pointer to reg_is_eirp_support_preferred 1940 * 1941 * Return: Success or Failure 1942 */ 1943 QDF_STATUS 1944 reg_get_eirp_preferred_support(struct wlan_objmgr_psoc *psoc, 1945 bool *reg_is_eirp_support_preferred); 1946 #endif /* CONFIG_AFC_SUPPORT */ 1947 1948 /** 1949 * reg_get_cur_6g_client_type() - Get the current 6G regulatory client Type. 1950 * @pdev: Pointer to PDEV object. 1951 * @reg_cur_6g_client_mobility_type: The current regulatory 6G client type ie. 1952 * default/subordinate. 1953 * 1954 * Return: QDF_STATUS. 1955 */ 1956 QDF_STATUS 1957 reg_get_cur_6g_client_type(struct wlan_objmgr_pdev *pdev, 1958 enum reg_6g_client_type 1959 *reg_cur_6g_client_mobility_type); 1960 1961 /** 1962 * reg_set_cur_6ghz_client_type() - Set the cur 6 GHz regulatory client type to 1963 * the given value. 1964 * @pdev: Pointer to PDEV object. 1965 * @in_6ghz_client_type: Input 6 GHz client type ie. default/subordinate. 1966 * 1967 * Return: QDF_STATUS. 1968 */ 1969 QDF_STATUS 1970 reg_set_cur_6ghz_client_type(struct wlan_objmgr_pdev *pdev, 1971 enum reg_6g_client_type in_6ghz_client_type); 1972 1973 /** 1974 * reg_set_6ghz_client_type_from_target() - Set the current 6 GHz regulatory 1975 * client type to the value received from target. 1976 * @pdev: Pointer to PDEV object. 1977 * 1978 * Return: QDF_STATUS. 1979 */ 1980 QDF_STATUS 1981 reg_set_6ghz_client_type_from_target(struct wlan_objmgr_pdev *pdev); 1982 1983 /** 1984 * reg_get_rnr_tpe_usable() - Tells if RNR IE is applicable for current domain. 1985 * @pdev: Pointer to PDEV object. 1986 * @reg_rnr_tpe_usable: Pointer to hold the bool value, true if RNR IE is 1987 * applicable, else false. 1988 * 1989 * Return: QDF_STATUS. 1990 */ 1991 QDF_STATUS reg_get_rnr_tpe_usable(struct wlan_objmgr_pdev *pdev, 1992 bool *reg_rnr_tpe_usable); 1993 1994 /** 1995 * reg_get_unspecified_ap_usable() - Tells if AP type unspecified by 802.11 can 1996 * be used or not. 1997 * @pdev: Pointer to PDEV object. 1998 * @reg_unspecified_ap_usable: Pointer to hold the bool value, true if 1999 * unspecified AP types can be used in the IE, else false. 2000 * 2001 * Return: QDF_STATUS. 2002 */ 2003 QDF_STATUS reg_get_unspecified_ap_usable(struct wlan_objmgr_pdev *pdev, 2004 bool *reg_unspecified_ap_usable); 2005 2006 /** 2007 * reg_is_6g_psd_power() - Checks if pdev has PSD power 2008 * 2009 * @pdev: pdev ptr 2010 * 2011 * Return: true if PSD power or false otherwise 2012 */ 2013 bool reg_is_6g_psd_power(struct wlan_objmgr_pdev *pdev); 2014 2015 /** 2016 * reg_get_6g_chan_ap_power() - Finds the TX power for the given channel 2017 * frequency, taking the AP's current power level into account 2018 * 2019 * @pdev: pdev ptr 2020 * @chan_freq: channel frequency 2021 * @is_psd: is channel PSD or not 2022 * @tx_power: transmit power to fill for chan_freq 2023 * @eirp_psd_power: EIRP PSD power, will only be filled if is_psd is true 2024 * 2025 * Return: QDF_STATUS 2026 */ 2027 QDF_STATUS reg_get_6g_chan_ap_power(struct wlan_objmgr_pdev *pdev, 2028 qdf_freq_t chan_freq, bool *is_psd, 2029 uint16_t *tx_power, 2030 uint16_t *eirp_psd_power); 2031 2032 /** 2033 * reg_get_client_power_for_connecting_ap() - Find the channel information when 2034 * device is operating as a client 2035 * 2036 * @pdev: pdev ptr 2037 * @ap_type: type of AP that device is connected to 2038 * @chan_freq: channel frequency 2039 * @is_psd: is channel PSD or not 2040 * @tx_power: transmit power to fill for chan_freq 2041 * @eirp_psd_power: EIRP power, will only be filled if is_psd is true 2042 * 2043 * This function is meant to be called to find the channel frequency power 2044 * information for a client when the device is operating as a client. It will 2045 * fill in the parameters tx_power and eirp_psd_power. eirp_psd_power 2046 * will only be filled if the channel is PSD. 2047 * 2048 * Return: QDF_STATUS 2049 */ 2050 QDF_STATUS reg_get_client_power_for_connecting_ap(struct wlan_objmgr_pdev *pdev, 2051 enum reg_6g_ap_type ap_type, 2052 qdf_freq_t chan_freq, 2053 bool is_psd, 2054 uint16_t *tx_power, 2055 uint16_t *eirp_psd_power); 2056 2057 /** 2058 * reg_get_client_power_for_6ghz_ap() - Find the channel information when 2059 * device is operating as a 6GHz AP 2060 * 2061 * @pdev: pdev ptr 2062 * @client_type: type of client that is connected to our AP 2063 * @chan_freq: channel frequency 2064 * @is_psd: is channel PSD or not 2065 * @tx_power: transmit power to fill for chan_freq 2066 * @eirp_psd_power: EIRP power, will only be filled if is_psd is true 2067 * 2068 * This function is meant to be called to find the channel frequency power 2069 * information for a client when the device is operating as an AP. It will fill 2070 * in the parameter is_psd, tx_power, and eirp_psd_power. eirp_psd_power will 2071 * only be filled if the channel is PSD. 2072 * 2073 * Return: QDF_STATUS 2074 */ 2075 QDF_STATUS reg_get_client_power_for_6ghz_ap(struct wlan_objmgr_pdev *pdev, 2076 enum reg_6g_client_type client_type, 2077 qdf_freq_t chan_freq, 2078 bool *is_psd, uint16_t *tx_power, 2079 uint16_t *eirp_psd_power); 2080 2081 /** 2082 * reg_set_ap_pwr_and_update_chan_list() - Set the AP power mode and recompute 2083 * the current channel list 2084 * 2085 * @pdev: pdev ptr 2086 * @ap_pwr_type: the AP power type to update to 2087 * 2088 * Return: QDF_STATUS 2089 */ 2090 QDF_STATUS reg_set_ap_pwr_and_update_chan_list(struct wlan_objmgr_pdev *pdev, 2091 enum reg_6g_ap_type ap_pwr_type); 2092 2093 /** 2094 * reg_get_6g_chan_psd_eirp_power() - For a given frequency, get the max PSD 2095 * from the mas_chan_list 2096 * @freq: Channel frequency 2097 * @mas_chan_list: Pointer to mas_chan_list 2098 * @reg_psd: Pointer to reg_psd 2099 * 2100 * Return: QDF_STATUS 2101 */ 2102 QDF_STATUS 2103 reg_get_6g_chan_psd_eirp_power(qdf_freq_t freq, 2104 struct regulatory_channel *mas_chan_list, 2105 uint16_t *reg_psd); 2106 2107 /** 2108 * reg_find_txpower_from_6g_list() - For a given frequency, get the max EIRP 2109 * from the mas_chan_list 2110 * @freq: Channel frequency 2111 * @mas_chan_list: Pointer to mas_chan_list 2112 * @reg_eirp: Pointer to reg_eirp 2113 * 2114 * Return: QDF_STATUS 2115 */ 2116 QDF_STATUS 2117 reg_find_txpower_from_6g_list(qdf_freq_t freq, 2118 struct regulatory_channel *chan_list, 2119 uint16_t *reg_eirp); 2120 #else 2121 static inline QDF_STATUS 2122 reg_set_cur_6g_ap_pwr_type(struct wlan_objmgr_pdev *pdev, 2123 enum reg_6g_ap_type reg_cur_6g_ap_pwr_type) 2124 { 2125 return QDF_STATUS_E_NOSUPPORT; 2126 } 2127 2128 static inline QDF_STATUS 2129 reg_get_cur_6g_ap_pwr_type(struct wlan_objmgr_pdev *pdev, 2130 enum reg_6g_ap_type *reg_cur_6g_ap_pwr_type) 2131 { 2132 *reg_cur_6g_ap_pwr_type = REG_MAX_AP_TYPE; 2133 return QDF_STATUS_E_NOSUPPORT; 2134 } 2135 2136 static inline QDF_STATUS 2137 reg_get_cur_6g_client_type(struct wlan_objmgr_pdev *pdev, 2138 enum reg_6g_client_type 2139 *reg_cur_6g_client_mobility_type) 2140 { 2141 *reg_cur_6g_client_mobility_type = REG_SUBORDINATE_CLIENT; 2142 return QDF_STATUS_E_NOSUPPORT; 2143 } 2144 2145 static inline QDF_STATUS 2146 reg_set_cur_6ghz_client_type(struct wlan_objmgr_pdev *pdev, 2147 enum reg_6g_client_type in_6ghz_client_type) 2148 { 2149 return QDF_STATUS_E_NOSUPPORT; 2150 } 2151 2152 static inline QDF_STATUS 2153 reg_set_6ghz_client_type_from_target(struct wlan_objmgr_pdev *pdev) 2154 { 2155 return QDF_STATUS_E_NOSUPPORT; 2156 } 2157 2158 static inline 2159 QDF_STATUS reg_get_rnr_tpe_usable(struct wlan_objmgr_pdev *pdev, 2160 bool *reg_rnr_tpe_usable) 2161 { 2162 *reg_rnr_tpe_usable = false; 2163 return QDF_STATUS_E_NOSUPPORT; 2164 } 2165 2166 static inline 2167 QDF_STATUS reg_get_unspecified_ap_usable(struct wlan_objmgr_pdev *pdev, 2168 bool *reg_unspecified_ap_usable) 2169 { 2170 *reg_unspecified_ap_usable = false; 2171 return QDF_STATUS_E_NOSUPPORT; 2172 } 2173 2174 static inline 2175 bool reg_is_6g_psd_power(struct wlan_objmgr_pdev *pdev) 2176 { 2177 return false; 2178 } 2179 2180 static inline 2181 QDF_STATUS reg_get_6g_chan_ap_power(struct wlan_objmgr_pdev *pdev, 2182 qdf_freq_t chan_freq, bool *is_psd, 2183 uint16_t *tx_power, 2184 uint16_t *eirp_psd_power) 2185 { 2186 *is_psd = false; 2187 *eirp_psd_power = 0; 2188 *tx_power = 0; 2189 return QDF_STATUS_E_NOSUPPORT; 2190 } 2191 2192 static inline 2193 QDF_STATUS reg_get_client_power_for_connecting_ap(struct wlan_objmgr_pdev *pdev, 2194 enum reg_6g_ap_type ap_type, 2195 qdf_freq_t chan_freq, 2196 bool is_psd, 2197 uint16_t *tx_power, 2198 uint16_t *eirp_psd_power) 2199 { 2200 *tx_power = 0; 2201 *eirp_psd_power = 0; 2202 return QDF_STATUS_E_NOSUPPORT; 2203 } 2204 2205 static inline 2206 QDF_STATUS reg_get_client_power_for_6ghz_ap(struct wlan_objmgr_pdev *pdev, 2207 enum reg_6g_client_type client_type, 2208 qdf_freq_t chan_freq, 2209 bool *is_psd, uint16_t *tx_power, 2210 uint16_t *eirp_psd_power) 2211 { 2212 *is_psd = false; 2213 *tx_power = 0; 2214 *eirp_psd_power = 0; 2215 return QDF_STATUS_E_NOSUPPORT; 2216 } 2217 2218 static inline 2219 QDF_STATUS reg_set_ap_pwr_and_update_chan_list(struct wlan_objmgr_pdev *pdev, 2220 enum reg_6g_ap_type ap_pwr_type) 2221 { 2222 return QDF_STATUS_E_NOSUPPORT; 2223 } 2224 2225 static inline QDF_STATUS 2226 reg_get_6g_chan_psd_eirp_power(qdf_freq_t freq, 2227 struct regulatory_channel *mas_chan_list, 2228 uint16_t *eirp_psd_power) 2229 { 2230 *eirp_psd_power = 0; 2231 return QDF_STATUS_E_NOSUPPORT; 2232 } 2233 2234 static inline QDF_STATUS 2235 reg_find_txpower_from_6g_list(qdf_freq_t freq, 2236 struct regulatory_channel *chan_list, 2237 uint16_t *reg_eirp) 2238 { 2239 *reg_eirp = 0; 2240 return QDF_STATUS_E_NOSUPPORT; 2241 } 2242 #endif 2243 2244 #ifdef CONFIG_HOST_FIND_CHAN 2245 /** 2246 * reg_update_max_phymode_chwidth_for_pdev() - Update the maximum phymode 2247 * and the corresponding chwidth for the pdev. 2248 * @pdev: Pointer to PDEV object. 2249 * 2250 */ 2251 void reg_update_max_phymode_chwidth_for_pdev(struct wlan_objmgr_pdev *pdev); 2252 2253 /** 2254 * reg_modify_chan_list_for_max_chwidth_for_pwrmode() - Update the maximum 2255 * bandwidth for 2256 * each channel in the current channel list. 2257 * @pdev: Pointer to PDEV object. 2258 * @cur_chan_list: Pointer to the pdev current channel list. 2259 * @in_6g_pwr_type: 6g power type which decides 6G channel list lookup. 2260 * 2261 * In countries like DK, the channel 144 is not supported by the regulatory. 2262 * When we get the regulatory rules, the entire UNII-2E's max bandwidth is set 2263 * to 160MHz but this is only true for channel 100 to 128. Channels 132 and 2264 * and 136 will have maximum bandwidth of 40MHz and channel 140 will have a 2265 * max bandwidth value of 20MHz (since 144 is not available). 2266 * These values in the current channel list are not updated based on the 2267 * bonded channels and hence will have an incorrect value for particular 2268 * channels. 2269 * Use this API to update the maximum bandwidth based on the device 2270 * capabilities and the availability of adjacent channels. 2271 */ 2272 void 2273 reg_modify_chan_list_for_max_chwidth_for_pwrmode(struct wlan_objmgr_pdev *pdev, 2274 struct regulatory_channel 2275 *cur_chan_list, 2276 enum supported_6g_pwr_types 2277 in_6g_pwr_mode); 2278 2279 #else 2280 static inline void 2281 reg_update_max_phymode_chwidth_for_pdev(struct wlan_objmgr_pdev *pdev) 2282 { 2283 } 2284 2285 static inline void 2286 reg_modify_chan_list_for_max_chwidth_for_pwrmode(struct wlan_objmgr_pdev *pdev, 2287 struct regulatory_channel 2288 *cur_chan_list, 2289 enum supported_6g_pwr_types 2290 in_6g_pwr_mode) 2291 { 2292 } 2293 #endif /* CONFIG_HOST_FIND_CHAN */ 2294 2295 /** 2296 * reg_is_phymode_unallowed() - Check if requested phymode is unallowed 2297 * @phy_in: phymode that the user requested 2298 * @phymode_bitmap: bitmap of unallowed phymodes for specific country 2299 * 2300 * Return: true if phymode is not allowed, else false 2301 */ 2302 bool reg_is_phymode_unallowed(enum reg_phymode phy_in, uint32_t phymode_bitmap); 2303 2304 /* 2305 * reg_is_regdb_offloaded() - is regdb offloaded 2306 * @psoc: Pointer to psoc object 2307 * 2308 * Return: true if regdb is offloaded, else false 2309 */ 2310 bool reg_is_regdb_offloaded(struct wlan_objmgr_psoc *psoc); 2311 2312 /** 2313 * reg_set_ext_tpc_supported() - Set if FW supports new WMI command for TPC 2314 * @psoc: Pointer to psoc 2315 * @val: value 2316 * 2317 * Return: QDF_STATUS 2318 */ 2319 QDF_STATUS reg_set_ext_tpc_supported(struct wlan_objmgr_psoc *psoc, 2320 bool val); 2321 2322 /** 2323 * reg_is_ext_tpc_supported() - Whether FW supports new WMI command for TPC 2324 * 2325 * @psoc: pointer to psoc 2326 * 2327 * Return: true if FW supports the new TPC command, else false 2328 */ 2329 bool reg_is_ext_tpc_supported(struct wlan_objmgr_psoc *psoc); 2330 2331 /** 2332 * reg_get_bonded_chan_entry() - Fetch the bonded channel pointer given a 2333 * frequency and channel width. 2334 * @freq: Input frequency. 2335 * @chwidth: Input channel width. 2336 * @cen320_freq: center frequency of 320. In 6G band 320Mhz channel are 2337 * overlapping. The exact band should be therefore identified 2338 * by the center frequency of the 320Mhz channel. 2339 * For example: Primary channel 6135 (IEEE37) can be part of either channel 2340 * (A) the 320Mhz channel with center 6105(IEEE31) or 2341 * (B) the 320Mhz channel with center 6265(IEEE63) 2342 * For (A) the start frequency is 5955(IEEE1) whereas for (B) the start 2343 * frequency is 6115(IEEE33) 2344 * 2345 * Return: A valid bonded channel pointer if found, else NULL. 2346 */ 2347 const struct bonded_channel_freq * 2348 reg_get_bonded_chan_entry(qdf_freq_t freq, enum phy_ch_width chwidth, 2349 qdf_freq_t cen320_freq); 2350 2351 /** 2352 * reg_set_2g_channel_params_for_freq() - set the 2.4G bonded channel parameters 2353 * @oper_freq: operating channel 2354 * @ch_params: channel parameters 2355 * @sec_ch_2g_freq: 2.4G secondary channel 2356 * 2357 * Return: void 2358 */ 2359 void reg_set_2g_channel_params_for_freq(struct wlan_objmgr_pdev *pdev, 2360 uint16_t oper_freq, 2361 struct ch_params *ch_params, 2362 uint16_t sec_ch_2g_freq); 2363 2364 /** 2365 * reg_combine_channel_states() - Get minimum of channel state1 and state2 2366 * @chan_state1: Channel state1 2367 * @chan_state2: Channel state2 2368 * 2369 * Return: Channel state 2370 */ 2371 enum channel_state reg_combine_channel_states(enum channel_state chan_state1, 2372 enum channel_state chan_state2); 2373 2374 #if defined(CONFIG_BAND_6GHZ) 2375 /** 2376 * reg_set_lower_6g_edge_ch_supp() - Set if lower 6ghz edge channel is 2377 * supported by FW 2378 * 2379 * @psoc: Pointer to psoc 2380 * @val: value 2381 */ 2382 QDF_STATUS reg_set_lower_6g_edge_ch_supp(struct wlan_objmgr_psoc *psoc, 2383 bool val); 2384 2385 /** 2386 * reg_set_disable_upper_6g_edge_ch_supp() - Set if upper 6ghz edge channel is 2387 * disabled by FW 2388 * 2389 * @psoc: Pointer to psoc 2390 * @val: value 2391 */ 2392 QDF_STATUS 2393 reg_set_disable_upper_6g_edge_ch_supp(struct wlan_objmgr_psoc *psoc, 2394 bool val); 2395 2396 /** 2397 * reg_is_lower_6g_edge_ch_supp() - Check whether 6GHz lower edge channel 2398 * (5935 MHz) is supported. 2399 * @psoc: pointer to psoc 2400 * 2401 * Return: true if edge channels are supported, else false 2402 */ 2403 bool reg_is_lower_6g_edge_ch_supp(struct wlan_objmgr_psoc *psoc); 2404 2405 /** 2406 * reg_is_upper_6g_edge_ch_disabled() - Check whether 6GHz upper edge 2407 * channel (7115 MHz) is disabled. 2408 * @psoc: pointer to psoc 2409 * 2410 * Return: true if edge channels are supported, else false 2411 */ 2412 bool reg_is_upper_6g_edge_ch_disabled(struct wlan_objmgr_psoc *psoc); 2413 2414 /** 2415 * reg_convert_enum_to_6g_idx() - Convert a channel enum between 2416 * MIN_6GHZ_CHANNEL and MAX_6GHZ_CHANNEL, to an index between 0 and 2417 * NUM_6GHZ_CHANNELS 2418 * @ch_idx: Channel index 2419 * 2420 * Return: enum channel_enum 2421 */ 2422 uint16_t reg_convert_enum_to_6g_idx(enum channel_enum ch_idx); 2423 2424 /** 2425 * reg_get_superchan_entry() - Get the address of the super channel list 2426 * entry for a given input channel index. 2427 * 2428 * @pdev: pdev ptr 2429 * @chan_enum: Channel enum 2430 * @p_sup_chan_entry: Pointer to address of *p_sup_chan_entry 2431 * 2432 * Return: QDF_STATUS_SUCCESS if super channel entry is available for the input 2433 * chan_enum else QDF_STATUS_E_FAILURE 2434 */ 2435 QDF_STATUS 2436 reg_get_superchan_entry(struct wlan_objmgr_pdev *pdev, 2437 enum channel_enum chan_enum, 2438 const struct super_chan_info **p_sup_chan_entry); 2439 #else 2440 static inline QDF_STATUS 2441 reg_set_lower_6g_edge_ch_supp(struct wlan_objmgr_psoc *psoc, bool val) 2442 { 2443 return QDF_STATUS_E_NOSUPPORT; 2444 } 2445 2446 static inline QDF_STATUS 2447 reg_set_disable_upper_6g_edge_ch_supp(struct wlan_objmgr_psoc *psoc, 2448 bool val) 2449 { 2450 return QDF_STATUS_E_NOSUPPORT; 2451 } 2452 2453 static inline bool reg_is_lower_6g_edge_ch_supp(struct wlan_objmgr_psoc *psoc) 2454 { 2455 return false; 2456 } 2457 2458 static inline bool 2459 reg_is_upper_6g_edge_ch_disabled(struct wlan_objmgr_psoc *psoc) 2460 { 2461 return false; 2462 } 2463 2464 static inline QDF_STATUS 2465 reg_get_superchan_entry(struct wlan_objmgr_pdev *pdev, 2466 enum channel_enum chan_enum, 2467 const struct super_chan_info **p_sup_chan_entry) 2468 { 2469 return QDF_STATUS_E_NOSUPPORT; 2470 } 2471 2472 static inline uint16_t reg_convert_enum_to_6g_idx(enum channel_enum ch_idx) 2473 { 2474 return INVALID_CHANNEL; 2475 } 2476 #endif 2477 2478 #ifdef FEATURE_WLAN_CH_AVOID_EXT 2479 /** 2480 * reg_process_ch_avoid_ext_event() - Process channel avoid extended event 2481 * @psoc: psoc for country information 2482 * @ch_avoid_event: channel avoid extended event buffer 2483 * 2484 * Return: QDF_STATUS 2485 */ 2486 2487 QDF_STATUS 2488 reg_process_ch_avoid_ext_event(struct wlan_objmgr_psoc *psoc, 2489 struct ch_avoid_ind_type *ch_avoid_event); 2490 /** 2491 * reg_check_coex_unsafe_nb_user_prefer() - get coex unsafe nb 2492 * user prefer ini 2493 * @psoc: pointer to psoc 2494 * 2495 * Return: bool 2496 */ 2497 2498 bool reg_check_coex_unsafe_nb_user_prefer(struct wlan_objmgr_psoc *psoc); 2499 2500 /** 2501 * reg_disable_coex_unsafe_channel() - get reg channel disable for 2502 * for coex unsafe channels 2503 * @psoc: pointer to psoc 2504 * 2505 * Return: bool 2506 */ 2507 2508 bool reg_check_coex_unsafe_chan_reg_disable(struct wlan_objmgr_psoc *psoc); 2509 #else 2510 static inline QDF_STATUS 2511 reg_process_ch_avoid_ext_event(struct wlan_objmgr_psoc *psoc, 2512 struct ch_avoid_ind_type *ch_avoid_event) 2513 { 2514 return QDF_STATUS_SUCCESS; 2515 } 2516 2517 static inline 2518 bool reg_check_coex_unsafe_nb_user_prefer(struct wlan_objmgr_psoc *psoc) 2519 { 2520 return false; 2521 } 2522 2523 static inline 2524 bool reg_check_coex_unsafe_chan_reg_disable(struct wlan_objmgr_psoc *psoc) 2525 { 2526 return false; 2527 } 2528 #endif 2529 2530 #if defined(CONFIG_AFC_SUPPORT) && defined(CONFIG_BAND_6GHZ) 2531 /** 2532 * reg_send_afc_cmd() - Send AFC cmd to the FW 2533 * @pdev: pdev ptr 2534 * @afc_ind_obj: Pointer to hold AFC indication 2535 * 2536 * Return: QDF_STATUS_SUCCESS if the WMI command is sent or QDF_STATUS_E_FAILURE 2537 * otherwise 2538 */ 2539 QDF_STATUS reg_send_afc_cmd(struct wlan_objmgr_pdev *pdev, 2540 struct reg_afc_resp_rx_ind_info *afc_ind_obj); 2541 2542 /** 2543 * reg_is_afc_power_event_received() - Checks if AFC power event is 2544 * received from the FW. 2545 * 2546 * @pdev: pdev ptr 2547 * 2548 * Return: true if AFC power event is received from the FW or false otherwise 2549 */ 2550 bool reg_is_afc_power_event_received(struct wlan_objmgr_pdev *pdev); 2551 2552 /** 2553 * reg_is_afc_done() - Check is AFC response has been received enabling 2554 * the given frequency. 2555 * @pdev: pdev ptr 2556 * @freq: given frequency 2557 * 2558 * Return: True if frequency is enabled, false otherwise 2559 */ 2560 bool reg_is_afc_done(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq); 2561 2562 /** 2563 * reg_get_afc_req_id() - Get the AFC request ID 2564 * @pdev: pdev pointer 2565 * @req_id: Pointer to request id 2566 * 2567 * Return: QDF_STATUS 2568 */ 2569 QDF_STATUS reg_get_afc_req_id(struct wlan_objmgr_pdev *pdev, uint64_t *req_id); 2570 2571 /** 2572 * reg_is_afc_expiry_event_received() - Checks if AFC power event is 2573 * received from the FW. 2574 * 2575 * @pdev: pdev ptr 2576 * 2577 * Return: true if AFC expiry event is received from the FW or false otherwise 2578 */ 2579 bool reg_is_afc_expiry_event_received(struct wlan_objmgr_pdev *pdev); 2580 2581 /** 2582 * reg_is_noaction_on_afc_pwr_evt() - Checks if the regulatory module 2583 * needs to take action when AFC power event is received. 2584 * 2585 * @pdev: pdev ptr 2586 * 2587 * Return: true if regulatory should not take any action or false otherwise 2588 */ 2589 bool reg_is_noaction_on_afc_pwr_evt(struct wlan_objmgr_pdev *pdev); 2590 2591 /** 2592 * reg_dmn_set_afc_req_id() - Set the request ID in the AFC partial request 2593 * object 2594 * @afc_req: pointer to AFC partial request 2595 * @req_id: AFC request ID 2596 * 2597 * Return: Void 2598 */ 2599 void reg_dmn_set_afc_req_id(struct wlan_afc_host_partial_request *afc_req, 2600 uint64_t req_id); 2601 #endif 2602 2603 /** 2604 * reg_is_chwidth_supported() - Check if given channel width is supported 2605 * on a given pdev 2606 * @pdev: pdev pointer 2607 * @ch_width: channel width. 2608 * @is_supported: whether the channel width is supported 2609 * 2610 * Return QDF_STATUS_SUCCESS of operation 2611 */ 2612 QDF_STATUS reg_is_chwidth_supported(struct wlan_objmgr_pdev *pdev, 2613 enum phy_ch_width ch_width, 2614 bool *is_supported); 2615 2616 /** 2617 * reg_is_state_allowed() - Check the state of the regulatory channel if it 2618 * is invalid or disabled. 2619 * @chan_state: Channel state. 2620 * 2621 * Return bool: true if the channel is not an invalid channel or disabled 2622 * channel. 2623 */ 2624 bool reg_is_state_allowed(enum channel_state chan_state); 2625 2626 /** 2627 * reg_is_freq_enabled() - Checks if the given frequency is enabled on the given 2628 * power mode or not. If the frequency is not a 6G frequency then the input 2629 * power mode is ignored and only current channel list is searched. 2630 * 2631 * @pdev: pdev pointer. 2632 * @freq: input frequency. 2633 * @in_6g_pwr_mode: Power mode on which the freq is enabled or not is to be 2634 * checked. 2635 * 2636 * Return: True if the frequency is present in the given power mode channel 2637 * list. 2638 */ 2639 bool reg_is_freq_enabled(struct wlan_objmgr_pdev *pdev, 2640 qdf_freq_t freq, 2641 enum supported_6g_pwr_types in_6g_pwr_mode); 2642 2643 /** 2644 * reg_is_freq_idx_enabled() - Checks if the given frequency index is enabled on 2645 * the given power mode or not. If the frequency index is not a 6G frequency 2646 * then the input power mode is ignored and only current channel list is 2647 * searched. 2648 * 2649 * @pdev: pdev pointer. 2650 * @freq_idx: input frequency index. 2651 * @in_6g_pwr_mode: Power mode on which the frequency index is enabled or not 2652 * is to be checked. 2653 * 2654 * Return: True if the frequency index is present in the given power mode 2655 * channel list. 2656 */ 2657 bool reg_is_freq_idx_enabled(struct wlan_objmgr_pdev *pdev, 2658 enum channel_enum freq_idx, 2659 enum supported_6g_pwr_types in_6g_pwr_mode); 2660 2661 /** 2662 * reg_get_best_6g_pwr_type() - Returns the best 6g power type supported for 2663 * a given frequency. 2664 * @pdev: pdev pointer 2665 * @freq: input frequency. 2666 * 2667 * Return: supported_6g_pwr_types enum. 2668 */ 2669 enum supported_6g_pwr_types 2670 reg_get_best_6g_pwr_type(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq); 2671 2672 /** 2673 * reg_conv_6g_ap_type_to_supported_6g_pwr_types() - Converts the 6G AP power 2674 * type to 6g supported power type enum. 2675 * @ap_pwr_type: input 6G AP power type. 2676 * 2677 * Return: supported_6g_pwr_types enum. 2678 */ 2679 enum supported_6g_pwr_types 2680 reg_conv_6g_ap_type_to_supported_6g_pwr_types(enum reg_6g_ap_type ap_pwr_type); 2681 2682 /** 2683 * reg_find_chwidth_from_bw () - Gets channel width for given 2684 * bandwidth 2685 * @bw: Bandwidth 2686 * 2687 * Return: phy_ch_width 2688 */ 2689 enum phy_ch_width reg_find_chwidth_from_bw(uint16_t bw); 2690 2691 #ifdef CONFIG_BAND_6GHZ 2692 /** 2693 * reg_get_thresh_priority_freq() - Get the prioritized frequency value 2694 * @pdev: pdev pointer 2695 */ 2696 qdf_freq_t reg_get_thresh_priority_freq(struct wlan_objmgr_pdev *pdev); 2697 2698 /** 2699 * reg_get_best_pwr_mode() - Get the AP's primary channel center frequency and 2700 * AP's operating bandwidth to return the best power mode, which is calculated 2701 * based on the maximum EIRP power among the 3 AP types, i.e, LPI, SP and VLP 2702 * @pdev: Pointer to pdev 2703 * @freq: Primary channel center frequency in MHz 2704 * @cen320: Band center of 320 MHz. (For other BW, this param is ignored during 2705 * processing) 2706 * @bw: AP's operating bandwidth in mhz 2707 * @in_punc_pattern: input puncture bitmap 2708 * 2709 * Return: Best power mode 2710 */ 2711 enum reg_6g_ap_type reg_get_best_pwr_mode(struct wlan_objmgr_pdev *pdev, 2712 qdf_freq_t freq, 2713 qdf_freq_t cen320, 2714 uint16_t bw, 2715 uint16_t in_punc_pattern); 2716 2717 /** 2718 * reg_get_eirp_pwr() - Get eirp power based on the AP power mode 2719 * @pdev: Pointer to pdev 2720 * @freq: Frequency in MHz 2721 * @cen320: 320 MHz Band center frequency 2722 * @bw: Bandwidth in MHz 2723 * @ap_pwr_type: AP power type 2724 * @in_punc_pattern: Input puncture pattern 2725 * @is_client_list_lookup_needed: Boolean to indicate if client list lookup is 2726 * needed 2727 * @client_type: Client power type 2728 * 2729 * Return: EIRP power 2730 */ 2731 uint8_t reg_get_eirp_pwr(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq, 2732 qdf_freq_t cen320, 2733 uint16_t bw, enum reg_6g_ap_type ap_pwr_type, 2734 uint16_t in_punc_pattern, 2735 bool is_client_list_lookup_needed, 2736 enum reg_6g_client_type client_type); 2737 #endif /* CONFIG_BAND_6GHZ */ 2738 2739 /** 2740 * reg_get_5g_chan_state() - Get channel state for 2741 * 5G bonded channel using the channel frequency 2742 * @pdev: Pointer to pdev 2743 * @freq: channel center frequency. 2744 * @bw: channel band width 2745 * @in_6g_pwr_mode: Input power mode which decides the 6G channel list to be 2746 * used. 2747 * @input_puncture_bitmap: Input puncture bitmap 2748 * 2749 * Return: channel state 2750 */ 2751 enum channel_state 2752 reg_get_5g_chan_state(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq, 2753 enum phy_ch_width bw, 2754 enum supported_6g_pwr_types in_6g_pwr_mode, 2755 uint16_t input_puncture_bitmap); 2756 2757 /** 2758 * reg_get_320_bonded_channel_state_for_pwrmode() - Given a bonded channel 2759 * pointer and freq, determine if the subchannels of the bonded pair 2760 * are valid and supported by the current regulatory. 2761 * 2762 * @pdev: Pointer to struct wlan_objmgr_pdev. 2763 * @freq: Frequency in MHZ. 2764 * @bonded_chan_ptr: Pointer to const struct bonded_channel_freq. 2765 * @bw: channel bandwidth 2766 * @out_punc_bitmap: Output puncturing bitmap 2767 * @in_6g_pwr_type: Input 6g power type 2768 * @treat_nol_chan_as_disabled: Bool to treat nol as enabled/disabled 2769 * @input_punc_bitmap: Input puncture bitmap 2770 * 2771 * Return - The channel state of the bonded pair. 2772 */ 2773 #ifdef WLAN_FEATURE_11BE 2774 enum channel_state 2775 reg_get_320_bonded_channel_state_for_pwrmode(struct wlan_objmgr_pdev *pdev, 2776 qdf_freq_t freq, 2777 const struct bonded_channel_freq 2778 *bonded_chan_ptr, 2779 enum phy_ch_width bw, 2780 uint16_t *out_punc_bitmap, 2781 enum supported_6g_pwr_types 2782 in_6g_pwr_type, 2783 bool treat_nol_chan_as_disabled, 2784 uint16_t input_punc_bitmap); 2785 #endif 2786 2787 /** 2788 * reg_is_ch_width_320() - Given a channel width, find out if it is 320MHZ. 2789 * @ch_width: Channel width 2790 * Return - True if ch_width is 320, false otherwise. 2791 */ 2792 bool reg_is_ch_width_320(enum phy_ch_width ch_width); 2793 2794 /** 2795 * reg_fetch_punc_bitmap() - Return the puncture bitmap from the ch_params 2796 * @ch_params: Pointer to struct ch_params 2797 * 2798 * Return: puncture bitmap 2799 */ 2800 #ifdef WLAN_FEATURE_11BE 2801 uint16_t 2802 reg_fetch_punc_bitmap(struct ch_params *ch_params); 2803 #else 2804 static inline uint16_t 2805 reg_fetch_punc_bitmap(struct ch_params *ch_params) 2806 { 2807 return 0; 2808 } 2809 #endif 2810 2811 /** 2812 * reg_get_ch_state_based_on_nol_flag() - Given a channel, find out the 2813 * state of the channel. If "treat_nol_chan_as_disabled" flag is set, nol channels 2814 * are considered disabled, else nol channels are considered enabled. 2815 * @pdev: Pointer to struct wlan_objmgr_pdev 2816 * @freq: Primary frequency 2817 * @treat_nol_chan_as_disabled: Flag to consider nol chan as enabled/disabled. 2818 * @ch_param: pointer to struct ch_params 2819 * @in_6g_pwr_mode: Input 6g power type 2820 * 2821 * Return - Channel state 2822 */ 2823 enum channel_state 2824 reg_get_ch_state_based_on_nol_flag(struct wlan_objmgr_pdev *pdev, 2825 qdf_freq_t freq, 2826 struct ch_params *ch_param, 2827 enum supported_6g_pwr_types 2828 in_6g_pwr_mode, 2829 bool treat_nol_chan_as_disabled); 2830 2831 /** 2832 * reg_get_min_max_bw_reg_chan_list() - Given a frequency index, find out the 2833 * min/max bw of the channel. 2834 * 2835 * @pdev: pdev pointer. 2836 * @freq_idx: input frequency index. 2837 * @in_6g_pwr_mode: Input 6g power type. 2838 * @min_bw: Min bandwidth. 2839 * @max_bw: Max bandwidth 2840 * 2841 * Return: true/false. 2842 */ 2843 QDF_STATUS reg_get_min_max_bw_reg_chan_list(struct wlan_objmgr_pdev *pdev, 2844 enum channel_enum freq_idx, 2845 enum supported_6g_pwr_types 2846 in_6g_pwr_mode, 2847 uint16_t *min_bw, 2848 uint16_t *max_bw); 2849 2850 /** 2851 * reg_get_chan_state() - Given a frequency index, find out the 2852 * state of the channel. 2853 * 2854 * @pdev: pdev pointer. 2855 * @freq_idx: input frequency index. 2856 * @in_6g_pwr_mode: Input 6g power type 2857 * @treat_nol_chan_as_disabled: Bool to treat NOL channels as 2858 * disabled/enabled. 2859 * 2860 * Return: Channel state. 2861 */ 2862 enum channel_state reg_get_chan_state(struct wlan_objmgr_pdev *pdev, 2863 enum channel_enum freq_idx, 2864 enum supported_6g_pwr_types 2865 in_6g_pwr_mode, 2866 bool treat_nol_chan_as_disabled); 2867 2868 /** 2869 * reg_is_chan_disabled() - Check if a channel is disabled or not 2870 * 2871 * @chan_flags: Channel flags 2872 * @chan_state: Channel state 2873 * 2874 * Return: True if channel is disabled else false. 2875 */ 2876 bool reg_is_chan_disabled(uint32_t chan_flags, enum channel_state chan_state); 2877 2878 /** 2879 * reg_get_chan_state_for_320() - Get the channel state of a 320 MHz 2880 * bonded channel. 2881 * @pdev: Pointer to wlan_objmgr_pdev 2882 * @freq: Primary frequency 2883 * @center_320: Band center of 320 MHz 2884 * @ch_width: Channel width 2885 * @bonded_chan_ptr_ptr: Pointer to bonded channel pointer 2886 * @treat_nol_chan_as_disabled: Bool to treat nol chan as enabled/disabled 2887 * @in_pwr_type: Input 6g power type 2888 * @input_punc_bitmap: Input puncture bitmap 2889 * 2890 * Return: Channel state 2891 */ 2892 #ifdef WLAN_FEATURE_11BE 2893 enum channel_state 2894 reg_get_chan_state_for_320(struct wlan_objmgr_pdev *pdev, 2895 uint16_t freq, 2896 qdf_freq_t center_320, 2897 enum phy_ch_width ch_width, 2898 const struct bonded_channel_freq 2899 **bonded_chan_ptr_ptr, 2900 enum supported_6g_pwr_types in_pwr_type, 2901 bool treat_nol_chan_as_disabled, 2902 uint16_t input_punc_bitmap); 2903 #else 2904 static inline enum channel_state 2905 reg_get_chan_state_for_320(struct wlan_objmgr_pdev *pdev, 2906 uint16_t freq, 2907 qdf_freq_t center_320, 2908 enum phy_ch_width ch_width, 2909 const struct bonded_channel_freq 2910 **bonded_chan_ptr_ptr, 2911 enum supported_6g_pwr_types in_pwr_type, 2912 bool treat_nol_chan_as_disabled, 2913 uint16_t input_punc_bitmap) 2914 { 2915 return CHANNEL_STATE_INVALID; 2916 } 2917 #endif 2918 2919 /** 2920 * reg_get_regd_rules() - provides the reg domain rules info 2921 * @pdev: pdev pointer 2922 * @reg_rules: regulatory rules 2923 * 2924 * Return: QDF_STATUS 2925 */ 2926 QDF_STATUS reg_get_regd_rules(struct wlan_objmgr_pdev *pdev, 2927 struct reg_rule_info *reg_rules); 2928 2929 #if defined(CONFIG_AFC_SUPPORT) && defined(CONFIG_BAND_6GHZ) 2930 /** 2931 * reg_is_sup_chan_entry_afc_done() - Checks if the super chan entry of given 2932 * channel idx and power mode has REGULATORY_CHAN_AFC_NOT_DONE flag cleared. 2933 * 2934 * @pdev: pdev pointer. 2935 * @freq: input channel idx. 2936 * @in_6g_pwr_mode: input power mode 2937 * 2938 * Return: True if REGULATORY_CHAN_AFC_NOT_DONE flag is clear for the super 2939 * chan entry. 2940 */ 2941 bool reg_is_sup_chan_entry_afc_done(struct wlan_objmgr_pdev *pdev, 2942 enum channel_enum chan_idx, 2943 enum supported_6g_pwr_types in_6g_pwr_mode); 2944 2945 /** 2946 * reg_is_6ghz_freq_txable() - Check if the given 6 GHz frequency is tx-able. 2947 * @pdev: Pointer to pdev 2948 * @freq: Frequency in MHz 2949 * @in_6ghz_pwr_type: Input AP power type 2950 * 2951 * An SP channel is tx-able if the channel is present in the AFC response. 2952 * In case of non-OUTDOOR mode, a channel is always tx-able (Assuming it is 2953 * enabled by regulatory). 2954 * 2955 * Return: True if the frequency is tx-able, else false. 2956 */ 2957 bool 2958 reg_is_6ghz_freq_txable(struct wlan_objmgr_pdev *pdev, 2959 qdf_freq_t freq, 2960 enum supported_6g_pwr_types in_6ghz_pwr_mode); 2961 2962 /** 2963 * reg_set_afc_power_event_received() - Set power event received flag with 2964 * given val. 2965 * @pdev: pdev pointer. 2966 * @val: value to be set 2967 * 2968 * Return: QDF_STATUS 2969 */ 2970 QDF_STATUS reg_set_afc_power_event_received(struct wlan_objmgr_pdev *pdev, 2971 bool val); 2972 #else 2973 static inline bool 2974 reg_is_sup_chan_entry_afc_done(struct wlan_objmgr_pdev *pdev, 2975 enum channel_enum chan_idx, 2976 enum supported_6g_pwr_types in_6g_pwr_mode) 2977 { 2978 return false; 2979 } 2980 2981 static inline bool 2982 reg_is_6ghz_freq_txable(struct wlan_objmgr_pdev *pdev, 2983 qdf_freq_t freq, 2984 enum supported_6g_pwr_types in_6ghz_pwr_mode) 2985 { 2986 return false; 2987 } 2988 2989 static inline QDF_STATUS 2990 reg_set_afc_power_event_received(struct wlan_objmgr_pdev *pdev, bool val) 2991 { 2992 return QDF_STATUS_E_FAILURE; 2993 } 2994 #endif 2995 2996 #ifdef CONFIG_BAND_6GHZ 2997 /** 2998 * reg_display_super_chan_list() - Display super channel list for all modes 2999 * @pdev: pdev pointer 3000 * 3001 * Return: QDF_STATUS 3002 */ 3003 QDF_STATUS 3004 reg_display_super_chan_list(struct wlan_objmgr_pdev *pdev); 3005 3006 #if defined(CONFIG_AFC_SUPPORT) && defined(CONFIG_BAND_6GHZ) 3007 /** 3008 * reg_get_afc_freq_range_and_psd_limits() - Get freq range and psd 3009 * limits from afc server response. 3010 * 3011 * @pdev: Pointer to pdev 3012 * @num_freq_obj: Number of frequency objects 3013 * @afc_obj: Pointer to struct afc_freq_obj 3014 * 3015 * Return: QDF_STATUS 3016 */ 3017 3018 QDF_STATUS 3019 reg_get_afc_freq_range_and_psd_limits(struct wlan_objmgr_pdev *pdev, 3020 uint8_t num_freq_obj, 3021 struct afc_freq_obj *afc_obj); 3022 3023 /** 3024 * reg_get_num_afc_freq_obj() - Get number of afc frequency objects 3025 * 3026 * @pdev: Pointer to pdev 3027 * @num_freq_obj: Number of frequency objects 3028 * 3029 * Return: QDF_STATUS 3030 */ 3031 QDF_STATUS 3032 reg_get_num_afc_freq_obj(struct wlan_objmgr_pdev *pdev, uint8_t *num_freq_obj); 3033 #endif 3034 #endif 3035 3036 /** 3037 * reg_get_max_bw_5G_for_fo() - get max bw 3038 * @pdev: PDEV object 3039 * 3040 * API to get max bw from pdev. 3041 * 3042 * Return: max bw 3043 */ 3044 uint16_t reg_get_max_bw_5G_for_fo(struct wlan_objmgr_pdev *pdev); 3045 3046 /** 3047 * reg_get_num_rules_of_ap_pwr_type() - Get the number of reg rules present 3048 * for a given ap power type 3049 * @pdev: Pointer to pdev 3050 * @ap_pwr_type: AP power type 3051 * 3052 * Return: Return the number of reg rules for a given ap power type 3053 */ 3054 uint8_t 3055 reg_get_num_rules_of_ap_pwr_type(struct wlan_objmgr_pdev *pdev, 3056 enum reg_6g_ap_type ap_pwr_type); 3057 #endif 3058