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