xref: /wlan-dirver/qca-wifi-host-cmn/umac/regulatory/core/src/reg_services_common.c (revision ece2e29fdfbf5fc2972fd7a1823ed8232bbc0ccc)
1 /*
2  * Copyright (c) 2014-2021 The Linux Foundation. All rights reserved.
3  * Copyright (c) 2021-2024 Qualcomm Innovation Center, Inc. All rights reserved.
4  *
5  * Permission to use, copy, modify, and/or distribute this software for
6  * any purpose with or without fee is hereby granted, provided that the
7  * above copyright notice and this permission notice appear in all
8  * copies.
9  *
10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
11  * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
12  * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
13  * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
14  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
15  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
16  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
17  * PERFORMANCE OF THIS SOFTWARE.
18  */
19 
20 /**
21  * DOC: reg_services_common.c
22  * This file defines regulatory component service functions
23  */
24 
25 #include <wlan_cmn.h>
26 #include <reg_services_public_struct.h>
27 #include <wlan_reg_services_api.h>
28 #ifdef CONFIG_AFC_SUPPORT
29 #include "reg_opclass.h"
30 #endif
31 #include <wlan_objmgr_psoc_obj.h>
32 #include <qdf_lock.h>
33 #include "reg_priv_objs.h"
34 #include "reg_utils.h"
35 #include "reg_callbacks.h"
36 #include "reg_services_common.h"
37 #include <wlan_objmgr_psoc_obj.h>
38 #include "reg_db.h"
39 #include "reg_db_parser.h"
40 #include "reg_build_chan_list.h"
41 #include <wlan_objmgr_pdev_obj.h>
42 #include <target_if.h>
43 #ifdef WLAN_FEATURE_GET_USABLE_CHAN_LIST
44 #include "wlan_mlme_ucfg_api.h"
45 #include "wlan_nan_api.h"
46 #endif
47 #ifndef CONFIG_REG_CLIENT
48 #include <wlan_reg_channel_api.h>
49 #endif
50 
51 const struct chan_map *channel_map;
52 uint8_t g_reg_max_5g_chan_num;
53 
54 #ifdef WLAN_FEATURE_11BE
55 static bool reg_is_chan_bit_punctured(uint16_t input_punc_bitmap,
56 				      uint8_t chan_idx)
57 {
58 	return input_punc_bitmap & BIT(chan_idx);
59 }
60 #else
61 static bool reg_is_chan_bit_punctured(uint16_t in_punc_bitmap,
62 				      uint8_t chan_idx)
63 {
64 	return false;
65 }
66 #endif
67 
68 #ifdef CONFIG_CHAN_FREQ_API
69 /* bonded_chan_40mhz_list_freq - List of 40MHz bonnded channel frequencies */
70 static const struct bonded_channel_freq bonded_chan_40mhz_list_freq[] = {
71 	{5180, 5200},
72 	{5220, 5240},
73 	{5260, 5280},
74 	{5300, 5320},
75 	{5500, 5520},
76 	{5540, 5560},
77 	{5580, 5600},
78 	{5620, 5640},
79 	{5660, 5680},
80 	{5700, 5720},
81 	{5745, 5765},
82 	{5785, 5805},
83 	{5825, 5845},
84 	{5865, 5885},
85 #ifdef CONFIG_BAND_6GHZ
86 	{5955, 5975},
87 	{5995, 6015},
88 	{6035, 6055},
89 	{6075, 6095},
90 	{6115, 6135},
91 	{6155, 6175},
92 	{6195, 6215},
93 	{6235, 6255},
94 	{6275, 6295},
95 	{6315, 6335},
96 	{6355, 6375},
97 	{6395, 6415},
98 	{6435, 6455},
99 	{6475, 6495},
100 	{6515, 6535},
101 	{6555, 6575},
102 	{6595, 6615},
103 	{6635, 6655},
104 	{6675, 6695},
105 	{6715, 6735},
106 	{6755, 6775},
107 	{6795, 6815},
108 	{6835, 6855},
109 	{6875, 6895},
110 	{6915, 6935},
111 	{6955, 6975},
112 	{6995, 7015},
113 	{7035, 7055},
114 	{7075, 7095}
115 #endif /*CONFIG_BAND_6GHZ*/
116 };
117 
118 /* bonded_chan_80mhz_list_freq - List of 80MHz bonnded channel frequencies */
119 static const struct bonded_channel_freq bonded_chan_80mhz_list_freq[] = {
120 	{5180, 5240},
121 	{5260, 5320},
122 	{5500, 5560},
123 	{5580, 5640},
124 	{5660, 5720},
125 	{5745, 5805},
126 	{5825, 5885},
127 #ifdef CONFIG_BAND_6GHZ
128 	{5955, 6015},
129 	{6035, 6095},
130 	{6115, 6175},
131 	{6195, 6255},
132 	{6275, 6335},
133 	{6355, 6415},
134 	{6435, 6495},
135 	{6515, 6575},
136 	{6595, 6655},
137 	{6675, 6735},
138 	{6755, 6815},
139 	{6835, 6895},
140 	{6915, 6975},
141 	{6995, 7055}
142 #endif /*CONFIG_BAND_6GHZ*/
143 };
144 
145 /* bonded_chan_160mhz_list_freq - List of 160MHz bonnded channel frequencies */
146 static const struct bonded_channel_freq bonded_chan_160mhz_list_freq[] = {
147 	{5180, 5320},
148 	{5500, 5640},
149 	{5745, 5885},
150 #ifdef CONFIG_BAND_6GHZ
151 	{5955, 6095},
152 	{6115, 6255},
153 	{6275, 6415},
154 	{6435, 6575},
155 	{6595, 6735},
156 	{6755, 6895},
157 	{6915, 7055}
158 #endif /*CONFIG_BAND_6GHZ*/
159 };
160 
161 #ifdef WLAN_FEATURE_11BE
162 /* bonded_chan_320mhz_list_freq - List of 320MHz bonnded channel frequencies */
163 static const struct bonded_channel_freq bonded_chan_320mhz_list_freq[] = {
164 	{5500, 5720}, /* center freq: 5650: The 5Ghz 240MHz chan */
165 #ifdef CONFIG_BAND_6GHZ
166 	{5955, 6255}, /* center freq: 6105 */
167 	{6115, 6415}, /* center freq: 6265 */
168 	{6275, 6575}, /* center freq: 6425 */
169 	{6435, 6735}, /* center freq: 6585 */
170 	{6595, 6895}, /* center freq: 6745 */
171 	{6755, 7055}  /* center freq: 6905 */
172 #endif /*CONFIG_BAND_6GHZ*/
173 };
174 #endif
175 
176 /**
177  * struct bw_bonded_array_pair - Structure containing bandwidth, bonded_array
178  * corresponding to bandwidth and the size of the bonded array.
179  * @chwidth: channel width
180  * @bonded_chan_arr: bonded array corresponding to chwidth.
181  * @array_size: size of the bonded_chan_arr.
182  */
183 struct bw_bonded_array_pair {
184 	enum phy_ch_width chwidth;
185 	const struct bonded_channel_freq *bonded_chan_arr;
186 	uint16_t array_size;
187 };
188 
189 /* Mapping of chwidth to bonded array and size of bonded array */
190 static const
191 struct bw_bonded_array_pair bw_bonded_array_pair_map[] = {
192 #ifdef WLAN_FEATURE_11BE
193 	{CH_WIDTH_320MHZ, bonded_chan_320mhz_list_freq,
194 		QDF_ARRAY_SIZE(bonded_chan_320mhz_list_freq)},
195 #endif
196 	{CH_WIDTH_160MHZ, bonded_chan_160mhz_list_freq,
197 		QDF_ARRAY_SIZE(bonded_chan_160mhz_list_freq)},
198 	{CH_WIDTH_80P80MHZ, bonded_chan_80mhz_list_freq,
199 		QDF_ARRAY_SIZE(bonded_chan_80mhz_list_freq)},
200 	{CH_WIDTH_80MHZ, bonded_chan_80mhz_list_freq,
201 		QDF_ARRAY_SIZE(bonded_chan_80mhz_list_freq)},
202 	{CH_WIDTH_40MHZ, bonded_chan_40mhz_list_freq,
203 		QDF_ARRAY_SIZE(bonded_chan_40mhz_list_freq)},
204 };
205 
206 #ifdef WLAN_FEATURE_11BE
207 /** Binary bitmap pattern
208  * 1: Punctured 20Mhz chan 0:non-Punctured 20Mhz Chan
209  *
210  * Band: 80MHz  Puncturing Unit: 20Mhz
211  *  B0001 = 0x1  : BIT(0)
212  *  B0010 = 0x2  : BIT(1)
213  *  B0100 = 0x4  : BIT(2)
214  *  B1000 = 0x8  : BIT(3)
215  *
216  * Band: 160MHz  Puncturing Unit: 20Mhz
217  *  B0000_0001 = 0x01  : BIT(0)
218  *  B0000_0010 = 0x02  : BIT(1)
219  *  B0000_0100 = 0x04  : BIT(2)
220  *  B0000_1000 = 0x08  : BIT(3)
221  *  B0001_0000 = 0x10  : BIT(4)
222  *  B0010_0000 = 0x20  : BIT(5)
223  *  B0100_0000 = 0x40  : BIT(6)
224  *  B1000_0000 = 0x80  : BIT(7)
225  *
226  * Band: 160MHz  Puncturing Unit: 40Mhz
227  *  B0000_0011 = 0x03  : BIT(0) | BIT(1)
228  *  B0000_1100 = 0x0C  : BIT(2) | BIT(3)
229  *  B0011_0000 = 0x30  : BIT(4) | BIT(5)
230  *  B1100_0000 = 0xC0  : BIT(6) | BIT(7)
231  *
232  * Band: 320MHz  Puncturing Unit: 40Mhz
233  *  B0000_0000_0000_0011 = 0x0003  : BIT(0)  | BIT(1)
234  *  B0000_0000_0000_1100 = 0x000C  : BIT(2)  | BIT(3)
235  *  B0000_0000_0011_0000 = 0x0030  : BIT(4)  | BIT(5)
236  *  B0000_0000_1100_0000 = 0x00C0  : BIT(6)  | BIT(7)
237  *  B0000_0011_0000_0000 = 0x0300  : BIT(8)  | BIT(9)
238  *  B0000_1100_0000_0000 = 0x0C00  : BIT(10) | BIT(11)
239  *  B0011_0000_0000_0000 = 0x3000  : BIT(12) | BIT(13)
240  *  B1100_0000_0000_0000 = 0xC000  : BIT(13) | BIT(15)
241  *
242  * Band: 320MHz  Puncturing Unit: 80Mhz
243  *  B0000_0000_0000_1111 = 0x000F  : BIT(0)  | BIT(1) | BIT(2) | BIT(3)
244  *  B0000_0000_1111_0000 = 0x00F0  : BIT(4)  | BIT(5) | BIT(6) | BIT(7)
245  *  B0000_1111_0000_0000 = 0x0F00  : BIT(8)  | BIT(9) | BIT(10) | BIT(11)
246  *  B1111_0000_0000_0000 = 0xF000  : BIT(12) | BIT(13) | BIT(14) | BIT(15)
247  *
248  * Band: 320MHz  Puncturing Unit: 80Mhz+40Mhz (Right 80Mhz punctured)
249  *  B0000_0000_0011_1111 = 0x003F  : BIT(4)  | BIT(5)   [right 80MHz: BIT(0) | BIT(1) | BIT(2) | BIT(3)]
250  *  B0000_0000_1100_1111 = 0x00CF  : BIT(6)  | BIT(7)   [right 80MHz: BIT(0) | BIT(1) | BIT(2) | BIT(3)]
251  *  B0000_0011_0000_1111 = 0x030F  : BIT(8)  | BIT(9)   [right 80MHz: BIT(0) | BIT(1) | BIT(2) | BIT(3)]
252  *  B0000_1100_0000_1111 = 0x0C0F  : BIT(10) | BIT(11)  [right 80MHz: BIT(0) | BIT(1) | BIT(2) | BIT(3)]
253  *  B0011_0000_0000_1111 = 0x300F  : BIT(12) | BIT(13)  [right 80MHz: BIT(0) | BIT(1) | BIT(2) | BIT(3)]
254  *  B1100_0000_0000_1111 = 0xC00F  : BIT(14) | BIT(15)  [right 80MHz: BIT(0) | BIT(1) | BIT(2) | BIT(3)]
255  *
256  * Band: 320MHz  Puncturing Unit: 80Mhz+40Mhz (Left 80Mhz punctured)
257  *  B1111_0000_0000_0011 = 0xF003  : BIT(4)  | BIT(5)   [left 80MHz: BIT(12) | BIT(13) | BIT(14) | BIT(15)]
258  *  B1111_0000_0000_1100 = 0xF00C  : BIT(6)  | BIT(7)   [left 80MHz: BIT(12) | BIT(13) | BIT(14) | BIT(15)]
259  *  B1111_0000_0011_0000 = 0xF030  : BIT(8)  | BIT(9)   [left 80MHz: BIT(12) | BIT(13) | BIT(14) | BIT(15)]
260  *  B1111_0000_1100_0000 = 0xF0C0  : BIT(10) | BIT(11)  [left 80MHz: BIT(12) | BIT(13) | BIT(14) | BIT(15)]
261  *  B1111_0011_0000_0000 = 0xF300  : BIT(12) | BIT(13)  [left 80MHz: BIT(12) | BIT(13) | BIT(14) | BIT(15)]
262  *  B1111_1100_0000_0000 = 0xFC00  : BIT(14) | BIT(15)  [left 80MHz: BIT(12) | BIT(13) | BIT(14) | BIT(15)]
263  */
264 static const uint16_t chan_80mhz_puncture_bitmap[] = {
265 	/* 20Mhz puncturing pattern */
266 	0x1,
267 	0x2,
268 	0x4,
269 	0x8
270 };
271 
272 static const uint16_t chan_160mhz_puncture_bitmap[] = {
273 	/* 20Mhz puncturing pattern */
274 	0x1,
275 	0x2,
276 	0x4,
277 	0x8,
278 	0x10,
279 	0x20,
280 	0x40,
281 	0x80,
282 	/* 40Mhz puncturing pattern */
283 	0x3,
284 	0xc,
285 	0x30,
286 	0xc0
287 };
288 
289 static const uint16_t chan_320mhz_puncture_bitmap[] = {
290 	/* 40Mhz puncturing pattern */
291 	0x3,
292 	0xc,
293 	0x30,
294 	0xc0,
295 	0x300,
296 	0xc00,
297 	0x3000,
298 	0xc000,
299 	/* 80Mhz puncturing pattern */
300 	0xf,
301 	0xf0,
302 	0xf00,
303 	0xf000,
304 	/* 80+40Mhz puncturing pattern: Left 80MHz punctured */
305 	0x3f,
306 	0xcf,
307 	0x30f,
308 	0xc0f,
309 	0x300f,
310 	0xc00f,
311 	/* 80+40Mhz puncturing pattern: Right 80MHz punctured */
312 	0xf003,
313 	0xf00c,
314 	0xf030,
315 	0xf0c0,
316 	0xf300,
317 	0xfc00
318 };
319 
320 struct bw_puncture_bitmap_pair {
321 	enum phy_ch_width chwidth;
322 	const uint16_t *puncture_bitmap_arr;
323 	uint16_t array_size;
324 };
325 
326 static const
327 struct bw_puncture_bitmap_pair bw_puncture_bitmap_pair_map[] = {
328 	{CH_WIDTH_320MHZ, chan_320mhz_puncture_bitmap,
329 		QDF_ARRAY_SIZE(chan_320mhz_puncture_bitmap)},
330 	{CH_WIDTH_160MHZ, chan_160mhz_puncture_bitmap,
331 		QDF_ARRAY_SIZE(chan_160mhz_puncture_bitmap)},
332 	{CH_WIDTH_80MHZ, chan_80mhz_puncture_bitmap,
333 		QDF_ARRAY_SIZE(chan_80mhz_puncture_bitmap)},
334 };
335 
336 static inline qdf_freq_t
337 reg_get_band_cen_from_bandstart(uint16_t bw, qdf_freq_t bandstart)
338 {
339 	return bandstart - BW_10_MHZ + bw / 2;
340 }
341 
342 #ifdef WLAN_FEATURE_11BE
343 uint16_t
344 reg_fetch_punc_bitmap(struct ch_params *ch_params)
345 {
346 	if (!ch_params)
347 		return NO_SCHANS_PUNC;
348 
349 	return ch_params->input_punc_bitmap;
350 }
351 #endif
352 
353 #else /* WLAN_FEATURE_11BE */
354 static inline qdf_freq_t
355 reg_get_band_cen_from_bandstart(uint16_t bw, qdf_freq_t bandstart)
356 {
357 	return 0;
358 }
359 
360 #endif /* WLAN_FEATURE_11BE */
361 
362 static bool reg_is_freq_within_bonded_chan(
363 		qdf_freq_t freq,
364 		const struct bonded_channel_freq *bonded_chan_arr,
365 		enum phy_ch_width chwidth, qdf_freq_t cen320_freq)
366 {
367 	qdf_freq_t band_center;
368 
369 	if (reg_is_ch_width_320(chwidth) && cen320_freq) {
370 		/*
371 		 * For the 5GHz 320/240 MHz channel, bonded pair ends are not
372 		 * symmetric around the center of the channel. Use the start
373 		 * frequency of the bonded channel to calculate the center
374 		 */
375 		if (REG_IS_5GHZ_FREQ(freq)) {
376 			qdf_freq_t start_freq = bonded_chan_arr->start_freq;
377 			uint16_t bw = reg_get_bw_value(chwidth);
378 
379 			band_center =
380 				reg_get_band_cen_from_bandstart(bw,
381 								start_freq);
382 		} else
383 			band_center = (bonded_chan_arr->start_freq +
384 					bonded_chan_arr->end_freq) >> 1;
385 		if (band_center != cen320_freq)
386 			return false;
387 	}
388 
389 	if (freq >= bonded_chan_arr->start_freq &&
390 	    freq <= bonded_chan_arr->end_freq)
391 		return true;
392 
393 	return false;
394 }
395 
396 const struct bonded_channel_freq *
397 reg_get_bonded_chan_entry(qdf_freq_t freq,
398 			  enum phy_ch_width chwidth,
399 			  qdf_freq_t cen320_freq)
400 {
401 	const struct bonded_channel_freq *bonded_chan_arr;
402 	uint16_t array_size, i, num_bws;
403 
404 	num_bws = QDF_ARRAY_SIZE(bw_bonded_array_pair_map);
405 	for (i = 0; i < num_bws; i++) {
406 		if (chwidth == bw_bonded_array_pair_map[i].chwidth) {
407 			bonded_chan_arr =
408 				bw_bonded_array_pair_map[i].bonded_chan_arr;
409 			array_size = bw_bonded_array_pair_map[i].array_size;
410 			break;
411 		}
412 	}
413 	if (i == num_bws) {
414 		reg_debug("Could not find bonded_chan_array for chwidth %d",
415 			  chwidth);
416 		return NULL;
417 	}
418 
419 	for (i = 0; i < array_size; i++) {
420 		if (reg_is_freq_within_bonded_chan(freq, &bonded_chan_arr[i],
421 						   chwidth, cen320_freq))
422 			return &bonded_chan_arr[i];
423 	}
424 
425 	reg_debug("Could not find a bonded pair for freq %d and width %d cen320_freq %u",
426 		  freq, chwidth, cen320_freq);
427 	return NULL;
428 }
429 
430 #endif /*CONFIG_CHAN_FREQ_API*/
431 
432 /* For a given chan_width, provide the next higher chan_width */
433 static const enum phy_ch_width next_higher_bw[] = {
434 	[CH_WIDTH_20MHZ] = CH_WIDTH_40MHZ,
435 	[CH_WIDTH_40MHZ] = CH_WIDTH_80MHZ,
436 	[CH_WIDTH_80MHZ] = CH_WIDTH_160MHZ,
437 	[CH_WIDTH_5MHZ]  = CH_WIDTH_10MHZ,
438 	[CH_WIDTH_10MHZ] = CH_WIDTH_20MHZ,
439 #ifdef WLAN_FEATURE_11BE
440 	[CH_WIDTH_160MHZ] = CH_WIDTH_320MHZ,
441 	[CH_WIDTH_320MHZ]   = CH_WIDTH_INVALID
442 #else
443 	[CH_WIDTH_80P80MHZ] = CH_WIDTH_160MHZ,
444 	[CH_WIDTH_160MHZ] = CH_WIDTH_INVALID
445 #endif
446 };
447 
448 enum phy_ch_width reg_get_next_higher_bandwidth(enum phy_ch_width ch_width)
449 {
450 	if (ch_width >= CH_WIDTH_20MHZ && ch_width <= CH_WIDTH_320MHZ)
451 	    return next_higher_bw[ch_width];
452 	else
453 	    return CH_WIDTH_INVALID;
454 }
455 
456 enum phy_ch_width get_next_lower_bandwidth(enum phy_ch_width ch_width)
457 {
458 	static const enum phy_ch_width get_next_lower_bw[] = {
459     /* 80+80 mode not supported in chips that support 320 mode */
460 #ifdef WLAN_FEATURE_11BE
461 		[CH_WIDTH_320MHZ] = CH_WIDTH_160MHZ,
462 #endif
463 		[CH_WIDTH_80P80MHZ] = CH_WIDTH_160MHZ,
464 		[CH_WIDTH_160MHZ] = CH_WIDTH_80MHZ,
465 		[CH_WIDTH_80MHZ] = CH_WIDTH_40MHZ,
466 		[CH_WIDTH_40MHZ] = CH_WIDTH_20MHZ,
467 		[CH_WIDTH_20MHZ] = CH_WIDTH_10MHZ,
468 		[CH_WIDTH_10MHZ] = CH_WIDTH_5MHZ,
469 		[CH_WIDTH_5MHZ] = CH_WIDTH_INVALID
470 	};
471 
472 	if (ch_width >= CH_WIDTH_20MHZ && ch_width <= CH_WIDTH_320MHZ)
473 	    return get_next_lower_bw[ch_width];
474 	else
475 	    return CH_WIDTH_INVALID;
476 }
477 
478 const struct chan_map channel_map_us[NUM_CHANNELS] = {
479 	[CHAN_ENUM_2412] = {2412, 1, 20, 40},
480 	[CHAN_ENUM_2417] = {2417, 2, 20, 40},
481 	[CHAN_ENUM_2422] = {2422, 3, 20, 40},
482 	[CHAN_ENUM_2427] = {2427, 4, 20, 40},
483 	[CHAN_ENUM_2432] = {2432, 5, 20, 40},
484 	[CHAN_ENUM_2437] = {2437, 6, 20, 40},
485 	[CHAN_ENUM_2442] = {2442, 7, 20, 40},
486 	[CHAN_ENUM_2447] = {2447, 8, 20, 40},
487 	[CHAN_ENUM_2452] = {2452, 9, 20, 40},
488 	[CHAN_ENUM_2457] = {2457, 10, 20, 40},
489 	[CHAN_ENUM_2462] = {2462, 11, 20, 40},
490 	[CHAN_ENUM_2467] = {2467, 12, 20, 40},
491 	[CHAN_ENUM_2472] = {2472, 13, 20, 40},
492 	[CHAN_ENUM_2484] = {2484, 14, 20, 20},
493 #ifdef CONFIG_49GHZ_CHAN
494 	[CHAN_ENUM_4912] = {4912, INVALID_CHANNEL_NUM, 2, 20},
495 	[CHAN_ENUM_4915] = {4915, INVALID_CHANNEL_NUM, 2, 20},
496 	[CHAN_ENUM_4917] = {4917, INVALID_CHANNEL_NUM, 2, 20},
497 	[CHAN_ENUM_4920] = {4920, INVALID_CHANNEL_NUM, 2, 20},
498 	[CHAN_ENUM_4922] = {4922, INVALID_CHANNEL_NUM, 2, 20},
499 	[CHAN_ENUM_4925] = {4925, INVALID_CHANNEL_NUM, 2, 20},
500 	[CHAN_ENUM_4927] = {4927, INVALID_CHANNEL_NUM, 2, 20},
501 	[CHAN_ENUM_4932] = {4932, INVALID_CHANNEL_NUM, 2, 20},
502 	[CHAN_ENUM_4935] = {4935, INVALID_CHANNEL_NUM, 2, 20},
503 	[CHAN_ENUM_4937] = {4937, INVALID_CHANNEL_NUM, 2, 20},
504 	[CHAN_ENUM_4940] = {4940, INVALID_CHANNEL_NUM, 2, 20},
505 	[CHAN_ENUM_4942] = {4942, 1, 5, 5},
506 	[CHAN_ENUM_4945] = {4945, 11, 10, 10},
507 	[CHAN_ENUM_4947] = {4947, 2, 5, 5},
508 	[CHAN_ENUM_4950] = {4950, 20, 10, 20},
509 	[CHAN_ENUM_4952] = {4952, 3, 5, 5},
510 	[CHAN_ENUM_4955] = {4955, 21, 10, 20},
511 	[CHAN_ENUM_4957] = {4957, 4, 5, 5},
512 	[CHAN_ENUM_4960] = {4960, 22, 10, 20},
513 	[CHAN_ENUM_4962] = {4962, 5, 5, 5},
514 	[CHAN_ENUM_4965] = {4965, 23, 10, 20},
515 	[CHAN_ENUM_4967] = {4967, 6, 5, 5},
516 	[CHAN_ENUM_4970] = {4970, 24, 10, 20},
517 	[CHAN_ENUM_4972] = {4972, 7, 5, 5},
518 	[CHAN_ENUM_4975] = {4975, 25, 10, 20},
519 	[CHAN_ENUM_4977] = {4977, 8, 5, 5},
520 	[CHAN_ENUM_4980] = {4980, 26, 10, 20},
521 	[CHAN_ENUM_4982] = {4982, 9, 5, 5},
522 	[CHAN_ENUM_4985] = {4985, 19, 10, 10},
523 	[CHAN_ENUM_4987] = {4987, 10, 5, 5},
524 	[CHAN_ENUM_5032] = {5032, INVALID_CHANNEL_NUM, 2, 20},
525 	[CHAN_ENUM_5035] = {5035, INVALID_CHANNEL_NUM, 2, 20},
526 	[CHAN_ENUM_5037] = {5037, INVALID_CHANNEL_NUM, 2, 20},
527 	[CHAN_ENUM_5040] = {5040, INVALID_CHANNEL_NUM, 2, 20},
528 	[CHAN_ENUM_5042] = {5042, INVALID_CHANNEL_NUM, 2, 20},
529 	[CHAN_ENUM_5045] = {5045, INVALID_CHANNEL_NUM, 2, 20},
530 	[CHAN_ENUM_5047] = {5047, INVALID_CHANNEL_NUM, 2, 20},
531 	[CHAN_ENUM_5052] = {5052, INVALID_CHANNEL_NUM, 2, 20},
532 	[CHAN_ENUM_5055] = {5055, INVALID_CHANNEL_NUM, 2, 20},
533 	[CHAN_ENUM_5057] = {5057, INVALID_CHANNEL_NUM, 2, 20},
534 	[CHAN_ENUM_5060] = {5060, INVALID_CHANNEL_NUM, 2, 20},
535 	[CHAN_ENUM_5080] = {5080, INVALID_CHANNEL_NUM, 2, 20},
536 #endif /* CONFIG_49GHZ_CHAN */
537 	[CHAN_ENUM_5180] = {5180, 36, 2, 160},
538 	[CHAN_ENUM_5200] = {5200, 40, 2, 160},
539 	[CHAN_ENUM_5220] = {5220, 44, 2, 160},
540 	[CHAN_ENUM_5240] = {5240, 48, 2, 160},
541 	[CHAN_ENUM_5260] = {5260, 52, 2, 160},
542 	[CHAN_ENUM_5280] = {5280, 56, 2, 160},
543 	[CHAN_ENUM_5300] = {5300, 60, 2, 160},
544 	[CHAN_ENUM_5320] = {5320, 64, 2, 160},
545 	[CHAN_ENUM_5500] = {5500, 100, 2, 240},
546 	[CHAN_ENUM_5520] = {5520, 104, 2, 240},
547 	[CHAN_ENUM_5540] = {5540, 108, 2, 240},
548 	[CHAN_ENUM_5560] = {5560, 112, 2, 240},
549 	[CHAN_ENUM_5580] = {5580, 116, 2, 240},
550 	[CHAN_ENUM_5600] = {5600, 120, 2, 240},
551 	[CHAN_ENUM_5620] = {5620, 124, 2, 240},
552 	[CHAN_ENUM_5640] = {5640, 128, 2, 240},
553 	[CHAN_ENUM_5660] = {5660, 132, 2, 240},
554 	[CHAN_ENUM_5680] = {5680, 136, 2, 240},
555 	[CHAN_ENUM_5700] = {5700, 140, 2, 240},
556 	[CHAN_ENUM_5720] = {5720, 144, 2, 240},
557 	[CHAN_ENUM_5745] = {5745, 149, 2, 160},
558 	[CHAN_ENUM_5765] = {5765, 153, 2, 160},
559 	[CHAN_ENUM_5785] = {5785, 157, 2, 160},
560 	[CHAN_ENUM_5805] = {5805, 161, 2, 160},
561 	[CHAN_ENUM_5825] = {5825, 165, 2, 160},
562 	[CHAN_ENUM_5845] = {5845, 169, 2, 160},
563 #ifdef WLAN_FEATURE_DSRC
564 	[CHAN_ENUM_5850] = {5850, 170, 2, 160},
565 	[CHAN_ENUM_5855] = {5855, 171, 2, 160},
566 	[CHAN_ENUM_5860] = {5860, 172, 2, 160},
567 #endif
568 	[CHAN_ENUM_5865] = {5865, 173, 2, 160},
569 #ifdef WLAN_FEATURE_DSRC
570 	[CHAN_ENUM_5870] = {5870, 174, 2, 160},
571 	[CHAN_ENUM_5875] = {5875, 175, 2, 160},
572 	[CHAN_ENUM_5880] = {5880, 176, 2, 160},
573 #endif
574 	[CHAN_ENUM_5885] = {5885, 177, 2, 160},
575 #ifdef WLAN_FEATURE_DSRC
576 	[CHAN_ENUM_5890] = {5890, 178, 2, 160},
577 	[CHAN_ENUM_5895] = {5895, 179, 2, 160},
578 	[CHAN_ENUM_5900] = {5900, 180, 2, 160},
579 	[CHAN_ENUM_5905] = {5905, 181, 2, 160},
580 	[CHAN_ENUM_5910] = {5910, 182, 2, 160},
581 	[CHAN_ENUM_5915] = {5915, 183, 2, 160},
582 	[CHAN_ENUM_5920] = {5920, 184, 2, 160},
583 #endif /* WLAN_FEATURE_DSRC */
584 #ifdef CONFIG_BAND_6GHZ
585 	[CHAN_ENUM_5935] = {5935, 2, 2, 20},
586 	[CHAN_ENUM_5955] = {5955, 1, 2, 320},
587 	[CHAN_ENUM_5975] = {5975, 5, 2, 320},
588 	[CHAN_ENUM_5995] = {5995, 9, 2, 320},
589 	[CHAN_ENUM_6015] = {6015, 13, 2, 320},
590 	[CHAN_ENUM_6035] = {6035, 17, 2, 320},
591 	[CHAN_ENUM_6055] = {6055, 21, 2, 320},
592 	[CHAN_ENUM_6075] = {6075, 25, 2, 320},
593 	[CHAN_ENUM_6095] = {6095, 29, 2, 320},
594 	[CHAN_ENUM_6115] = {6115, 33, 2, 320},
595 	[CHAN_ENUM_6135] = {6135, 37, 2, 320},
596 	[CHAN_ENUM_6155] = {6155, 41, 2, 320},
597 	[CHAN_ENUM_6175] = {6175, 45, 2, 320},
598 	[CHAN_ENUM_6195] = {6195, 49, 2, 320},
599 	[CHAN_ENUM_6215] = {6215, 53, 2, 320},
600 	[CHAN_ENUM_6235] = {6235, 57, 2, 320},
601 	[CHAN_ENUM_6255] = {6255, 61, 2, 320},
602 	[CHAN_ENUM_6275] = {6275, 65, 2, 320},
603 	[CHAN_ENUM_6295] = {6295, 69, 2, 320},
604 	[CHAN_ENUM_6315] = {6315, 73, 2, 320},
605 	[CHAN_ENUM_6335] = {6335, 77, 2, 320},
606 	[CHAN_ENUM_6355] = {6355, 81, 2, 320},
607 	[CHAN_ENUM_6375] = {6375, 85, 2, 320},
608 	[CHAN_ENUM_6395] = {6395, 89, 2, 320},
609 	[CHAN_ENUM_6415] = {6415, 93, 2, 320},
610 	[CHAN_ENUM_6435] = {6435, 97, 2, 320},
611 	[CHAN_ENUM_6455] = {6455, 101, 2, 320},
612 	[CHAN_ENUM_6475] = {6475, 105, 2, 320},
613 	[CHAN_ENUM_6495] = {6495, 109, 2, 320},
614 	[CHAN_ENUM_6515] = {6515, 113, 2, 320},
615 	[CHAN_ENUM_6535] = {6535, 117, 2, 320},
616 	[CHAN_ENUM_6555] = {6555, 121, 2, 320},
617 	[CHAN_ENUM_6575] = {6575, 125, 2, 320},
618 	[CHAN_ENUM_6595] = {6595, 129, 2, 320},
619 	[CHAN_ENUM_6615] = {6615, 133, 2, 320},
620 	[CHAN_ENUM_6635] = {6635, 137, 2, 320},
621 	[CHAN_ENUM_6655] = {6655, 141, 2, 320},
622 	[CHAN_ENUM_6675] = {6675, 145, 2, 320},
623 	[CHAN_ENUM_6695] = {6695, 149, 2, 320},
624 	[CHAN_ENUM_6715] = {6715, 153, 2, 320},
625 	[CHAN_ENUM_6735] = {6735, 157, 2, 320},
626 	[CHAN_ENUM_6755] = {6755, 161, 2, 320},
627 	[CHAN_ENUM_6775] = {6775, 165, 2, 320},
628 	[CHAN_ENUM_6795] = {6795, 169, 2, 320},
629 	[CHAN_ENUM_6815] = {6815, 173, 2, 320},
630 	[CHAN_ENUM_6835] = {6835, 177, 2, 320},
631 	[CHAN_ENUM_6855] = {6855, 181, 2, 320},
632 	[CHAN_ENUM_6875] = {6875, 185, 2, 320},
633 	[CHAN_ENUM_6895] = {6895, 189, 2, 320},
634 	[CHAN_ENUM_6915] = {6915, 193, 2, 320},
635 	[CHAN_ENUM_6935] = {6935, 197, 2, 320},
636 	[CHAN_ENUM_6955] = {6955, 201, 2, 320},
637 	[CHAN_ENUM_6975] = {6975, 205, 2, 320},
638 	[CHAN_ENUM_6995] = {6995, 209, 2, 320},
639 	[CHAN_ENUM_7015] = {7015, 213, 2, 320},
640 	[CHAN_ENUM_7035] = {7035, 217, 2, 320},
641 	[CHAN_ENUM_7055] = {7055, 221, 2, 320},
642 	[CHAN_ENUM_7075] = {7075, 225, 2, 160},
643 	[CHAN_ENUM_7095] = {7095, 229, 2, 160},
644 	[CHAN_ENUM_7115] = {7115, 233, 2, 160}
645 #endif /* CONFIG_BAND_6GHZ */
646 };
647 
648 const struct chan_map channel_map_eu[NUM_CHANNELS] = {
649 	[CHAN_ENUM_2412] = {2412, 1, 20, 40},
650 	[CHAN_ENUM_2417] = {2417, 2, 20, 40},
651 	[CHAN_ENUM_2422] = {2422, 3, 20, 40},
652 	[CHAN_ENUM_2427] = {2427, 4, 20, 40},
653 	[CHAN_ENUM_2432] = {2432, 5, 20, 40},
654 	[CHAN_ENUM_2437] = {2437, 6, 20, 40},
655 	[CHAN_ENUM_2442] = {2442, 7, 20, 40},
656 	[CHAN_ENUM_2447] = {2447, 8, 20, 40},
657 	[CHAN_ENUM_2452] = {2452, 9, 20, 40},
658 	[CHAN_ENUM_2457] = {2457, 10, 20, 40},
659 	[CHAN_ENUM_2462] = {2462, 11, 20, 40},
660 	[CHAN_ENUM_2467] = {2467, 12, 20, 40},
661 	[CHAN_ENUM_2472] = {2472, 13, 20, 40},
662 	[CHAN_ENUM_2484] = {2484, 14, 20, 20},
663 #ifdef CONFIG_49GHZ_CHAN
664 	[CHAN_ENUM_4912] = {4912, INVALID_CHANNEL_NUM, 2, 20},
665 	[CHAN_ENUM_4915] = {4915, INVALID_CHANNEL_NUM, 2, 20},
666 	[CHAN_ENUM_4917] = {4917, INVALID_CHANNEL_NUM, 2, 20},
667 	[CHAN_ENUM_4920] = {4920, INVALID_CHANNEL_NUM, 2, 20},
668 	[CHAN_ENUM_4922] = {4922, INVALID_CHANNEL_NUM, 2, 20},
669 	[CHAN_ENUM_4925] = {4925, INVALID_CHANNEL_NUM, 2, 20},
670 	[CHAN_ENUM_4927] = {4927, INVALID_CHANNEL_NUM, 2, 20},
671 	[CHAN_ENUM_4932] = {4932, INVALID_CHANNEL_NUM, 2, 20},
672 	[CHAN_ENUM_4935] = {4935, INVALID_CHANNEL_NUM, 2, 20},
673 	[CHAN_ENUM_4937] = {4937, INVALID_CHANNEL_NUM, 2, 20},
674 	[CHAN_ENUM_4940] = {4940, INVALID_CHANNEL_NUM, 2, 20},
675 	[CHAN_ENUM_4942] = {4942, INVALID_CHANNEL_NUM, 2, 20},
676 	[CHAN_ENUM_4945] = {4945, INVALID_CHANNEL_NUM, 2, 20},
677 	[CHAN_ENUM_4947] = {4947, INVALID_CHANNEL_NUM, 2, 20},
678 	[CHAN_ENUM_4950] = {4950, INVALID_CHANNEL_NUM, 2, 20},
679 	[CHAN_ENUM_4952] = {4952, INVALID_CHANNEL_NUM, 2, 20},
680 	[CHAN_ENUM_4955] = {4955, INVALID_CHANNEL_NUM, 2, 20},
681 	[CHAN_ENUM_4957] = {4957, INVALID_CHANNEL_NUM, 2, 20},
682 	[CHAN_ENUM_4960] = {4960, INVALID_CHANNEL_NUM, 2, 20},
683 	[CHAN_ENUM_4962] = {4962, INVALID_CHANNEL_NUM, 2, 20},
684 	[CHAN_ENUM_4965] = {4965, INVALID_CHANNEL_NUM, 2, 20},
685 	[CHAN_ENUM_4967] = {4967, INVALID_CHANNEL_NUM, 2, 20},
686 	[CHAN_ENUM_4970] = {4970, INVALID_CHANNEL_NUM, 2, 20},
687 	[CHAN_ENUM_4972] = {4972, INVALID_CHANNEL_NUM, 2, 20},
688 	[CHAN_ENUM_4975] = {4975, INVALID_CHANNEL_NUM, 2, 20},
689 	[CHAN_ENUM_4977] = {4977, INVALID_CHANNEL_NUM, 2, 20},
690 	[CHAN_ENUM_4980] = {4980, INVALID_CHANNEL_NUM, 2, 20},
691 	[CHAN_ENUM_4982] = {4982, INVALID_CHANNEL_NUM, 2, 20},
692 	[CHAN_ENUM_4985] = {4985, INVALID_CHANNEL_NUM, 2, 20},
693 	[CHAN_ENUM_4987] = {4987, INVALID_CHANNEL_NUM, 2, 20},
694 	[CHAN_ENUM_5032] = {5032, INVALID_CHANNEL_NUM, 2, 20},
695 	[CHAN_ENUM_5035] = {5035, INVALID_CHANNEL_NUM, 2, 20},
696 	[CHAN_ENUM_5037] = {5037, INVALID_CHANNEL_NUM, 2, 20},
697 	[CHAN_ENUM_5040] = {5040, INVALID_CHANNEL_NUM, 2, 20},
698 	[CHAN_ENUM_5042] = {5042, INVALID_CHANNEL_NUM, 2, 20},
699 	[CHAN_ENUM_5045] = {5045, INVALID_CHANNEL_NUM, 2, 20},
700 	[CHAN_ENUM_5047] = {5047, INVALID_CHANNEL_NUM, 2, 20},
701 	[CHAN_ENUM_5052] = {5052, INVALID_CHANNEL_NUM, 2, 20},
702 	[CHAN_ENUM_5055] = {5055, INVALID_CHANNEL_NUM, 2, 20},
703 	[CHAN_ENUM_5057] = {5057, INVALID_CHANNEL_NUM, 2, 20},
704 	[CHAN_ENUM_5060] = {5060, INVALID_CHANNEL_NUM, 2, 20},
705 	[CHAN_ENUM_5080] = {5080, INVALID_CHANNEL_NUM, 2, 20},
706 #endif /* CONFIG_49GHZ_CHAN */
707 	[CHAN_ENUM_5180] = {5180, 36, 2, 160},
708 	[CHAN_ENUM_5200] = {5200, 40, 2, 160},
709 	[CHAN_ENUM_5220] = {5220, 44, 2, 160},
710 	[CHAN_ENUM_5240] = {5240, 48, 2, 160},
711 	[CHAN_ENUM_5260] = {5260, 52, 2, 160},
712 	[CHAN_ENUM_5280] = {5280, 56, 2, 160},
713 	[CHAN_ENUM_5300] = {5300, 60, 2, 160},
714 	[CHAN_ENUM_5320] = {5320, 64, 2, 160},
715 	[CHAN_ENUM_5500] = {5500, 100, 2, 240},
716 	[CHAN_ENUM_5520] = {5520, 104, 2, 240},
717 	[CHAN_ENUM_5540] = {5540, 108, 2, 240},
718 	[CHAN_ENUM_5560] = {5560, 112, 2, 240},
719 	[CHAN_ENUM_5580] = {5580, 116, 2, 240},
720 	[CHAN_ENUM_5600] = {5600, 120, 2, 240},
721 	[CHAN_ENUM_5620] = {5620, 124, 2, 240},
722 	[CHAN_ENUM_5640] = {5640, 128, 2, 240},
723 	[CHAN_ENUM_5660] = {5660, 132, 2, 240},
724 	[CHAN_ENUM_5680] = {5680, 136, 2, 240},
725 	[CHAN_ENUM_5700] = {5700, 140, 2, 240},
726 	[CHAN_ENUM_5720] = {5720, 144, 2, 240},
727 	[CHAN_ENUM_5745] = {5745, 149, 2, 160},
728 	[CHAN_ENUM_5765] = {5765, 153, 2, 160},
729 	[CHAN_ENUM_5785] = {5785, 157, 2, 160},
730 	[CHAN_ENUM_5805] = {5805, 161, 2, 160},
731 	[CHAN_ENUM_5825] = {5825, 165, 2, 160},
732 	[CHAN_ENUM_5845] = {5845, 169, 2, 160},
733 #ifdef WLAN_FEATURE_DSRC
734 	[CHAN_ENUM_5850] = {5850, INVALID_CHANNEL_NUM, 2, 160},
735 	[CHAN_ENUM_5855] = {5855, INVALID_CHANNEL_NUM, 2, 160},
736 	[CHAN_ENUM_5860] = {5860, INVALID_CHANNEL_NUM, 2, 160},
737 #endif
738 	[CHAN_ENUM_5865] = {5865, 173, 2, 160},
739 #ifdef WLAN_FEATURE_DSRC
740 	[CHAN_ENUM_5870] = {5870, INVALID_CHANNEL_NUM, 2, 160},
741 	[CHAN_ENUM_5875] = {5875, 175, 2, 160},
742 	[CHAN_ENUM_5880] = {5880, 176, 2, 160},
743 #endif
744 	[CHAN_ENUM_5885] = {5885, 177, 2, 160},
745 #ifdef WLAN_FEATURE_DSRC
746 	[CHAN_ENUM_5890] = {5890, 178, 2, 160},
747 	[CHAN_ENUM_5895] = {5895, 179, 2, 160},
748 	[CHAN_ENUM_5900] = {5900, 180, 2, 160},
749 	[CHAN_ENUM_5905] = {5905, 181, 2, 160},
750 	[CHAN_ENUM_5910] = {5910, 182, 2, 160},
751 	[CHAN_ENUM_5915] = {5915, 183, 2, 160},
752 	[CHAN_ENUM_5920] = {5920, 184, 2, 160},
753 #endif /* WLAN_FEATURE_DSRC */
754 #ifdef CONFIG_BAND_6GHZ
755 	[CHAN_ENUM_5935] = {5935, 2, 2, 20},
756 	[CHAN_ENUM_5955] = {5955, 1, 2, 320},
757 	[CHAN_ENUM_5975] = {5975, 5, 2, 320},
758 	[CHAN_ENUM_5995] = {5995, 9, 2, 320},
759 	[CHAN_ENUM_6015] = {6015, 13, 2, 320},
760 	[CHAN_ENUM_6035] = {6035, 17, 2, 320},
761 	[CHAN_ENUM_6055] = {6055, 21, 2, 320},
762 	[CHAN_ENUM_6075] = {6075, 25, 2, 320},
763 	[CHAN_ENUM_6095] = {6095, 29, 2, 320},
764 	[CHAN_ENUM_6115] = {6115, 33, 2, 320},
765 	[CHAN_ENUM_6135] = {6135, 37, 2, 320},
766 	[CHAN_ENUM_6155] = {6155, 41, 2, 320},
767 	[CHAN_ENUM_6175] = {6175, 45, 2, 320},
768 	[CHAN_ENUM_6195] = {6195, 49, 2, 320},
769 	[CHAN_ENUM_6215] = {6215, 53, 2, 320},
770 	[CHAN_ENUM_6235] = {6235, 57, 2, 320},
771 	[CHAN_ENUM_6255] = {6255, 61, 2, 320},
772 	[CHAN_ENUM_6275] = {6275, 65, 2, 320},
773 	[CHAN_ENUM_6295] = {6295, 69, 2, 320},
774 	[CHAN_ENUM_6315] = {6315, 73, 2, 320},
775 	[CHAN_ENUM_6335] = {6335, 77, 2, 320},
776 	[CHAN_ENUM_6355] = {6355, 81, 2, 320},
777 	[CHAN_ENUM_6375] = {6375, 85, 2, 320},
778 	[CHAN_ENUM_6395] = {6395, 89, 2, 320},
779 	[CHAN_ENUM_6415] = {6415, 93, 2, 320},
780 	[CHAN_ENUM_6435] = {6435, 97, 2, 320},
781 	[CHAN_ENUM_6455] = {6455, 101, 2, 320},
782 	[CHAN_ENUM_6475] = {6475, 105, 2, 320},
783 	[CHAN_ENUM_6495] = {6495, 109, 2, 320},
784 	[CHAN_ENUM_6515] = {6515, 113, 2, 320},
785 	[CHAN_ENUM_6535] = {6535, 117, 2, 320},
786 	[CHAN_ENUM_6555] = {6555, 121, 2, 320},
787 	[CHAN_ENUM_6575] = {6575, 125, 2, 320},
788 	[CHAN_ENUM_6595] = {6595, 129, 2, 320},
789 	[CHAN_ENUM_6615] = {6615, 133, 2, 320},
790 	[CHAN_ENUM_6635] = {6635, 137, 2, 320},
791 	[CHAN_ENUM_6655] = {6655, 141, 2, 320},
792 	[CHAN_ENUM_6675] = {6675, 145, 2, 320},
793 	[CHAN_ENUM_6695] = {6695, 149, 2, 320},
794 	[CHAN_ENUM_6715] = {6715, 153, 2, 320},
795 	[CHAN_ENUM_6735] = {6735, 157, 2, 320},
796 	[CHAN_ENUM_6755] = {6755, 161, 2, 320},
797 	[CHAN_ENUM_6775] = {6775, 165, 2, 320},
798 	[CHAN_ENUM_6795] = {6795, 169, 2, 320},
799 	[CHAN_ENUM_6815] = {6815, 173, 2, 320},
800 	[CHAN_ENUM_6835] = {6835, 177, 2, 320},
801 	[CHAN_ENUM_6855] = {6855, 181, 2, 320},
802 	[CHAN_ENUM_6875] = {6875, 185, 2, 320},
803 	[CHAN_ENUM_6895] = {6895, 189, 2, 320},
804 	[CHAN_ENUM_6915] = {6915, 193, 2, 320},
805 	[CHAN_ENUM_6935] = {6935, 197, 2, 320},
806 	[CHAN_ENUM_6955] = {6955, 201, 2, 320},
807 	[CHAN_ENUM_6975] = {6975, 205, 2, 320},
808 	[CHAN_ENUM_6995] = {6995, 209, 2, 320},
809 	[CHAN_ENUM_7015] = {7015, 213, 2, 320},
810 	[CHAN_ENUM_7035] = {7035, 217, 2, 320},
811 	[CHAN_ENUM_7055] = {7055, 221, 2, 320},
812 	[CHAN_ENUM_7075] = {7075, 225, 2, 160},
813 	[CHAN_ENUM_7095] = {7095, 229, 2, 160},
814 	[CHAN_ENUM_7115] = {7115, 233, 2, 160}
815 #endif /* CONFIG_BAND_6GHZ */
816 };
817 
818 const struct chan_map channel_map_jp[NUM_CHANNELS] = {
819 	[CHAN_ENUM_2412] = {2412, 1, 20, 40},
820 	[CHAN_ENUM_2417] = {2417, 2, 20, 40},
821 	[CHAN_ENUM_2422] = {2422, 3, 20, 40},
822 	[CHAN_ENUM_2427] = {2427, 4, 20, 40},
823 	[CHAN_ENUM_2432] = {2432, 5, 20, 40},
824 	[CHAN_ENUM_2437] = {2437, 6, 20, 40},
825 	[CHAN_ENUM_2442] = {2442, 7, 20, 40},
826 	[CHAN_ENUM_2447] = {2447, 8, 20, 40},
827 	[CHAN_ENUM_2452] = {2452, 9, 20, 40},
828 	[CHAN_ENUM_2457] = {2457, 10, 20, 40},
829 	[CHAN_ENUM_2462] = {2462, 11, 20, 40},
830 	[CHAN_ENUM_2467] = {2467, 12, 20, 40},
831 	[CHAN_ENUM_2472] = {2472, 13, 20, 40},
832 	[CHAN_ENUM_2484] = {2484, 14, 20, 20},
833 #ifdef CONFIG_49GHZ_CHAN
834 	[CHAN_ENUM_4912] = {4912, 182, 5, 5},
835 	[CHAN_ENUM_4915] = {4915, 183, 10, 10},
836 	[CHAN_ENUM_4917] = {4917, 183, 5, 5},
837 	[CHAN_ENUM_4920] = {4920, 184, 10, 20},
838 	[CHAN_ENUM_4922] = {4922, 184, 5, 5},
839 	[CHAN_ENUM_4925] = {4925, 185, 10, 10},
840 	[CHAN_ENUM_4927] = {4927, 185, 5, 5},
841 	[CHAN_ENUM_4932] = {4932, 186, 5, 5},
842 	[CHAN_ENUM_4935] = {4935, 187, 10, 10},
843 	[CHAN_ENUM_4937] = {4937, 187, 5, 5},
844 	[CHAN_ENUM_4940] = {4940, 188, 10, 20},
845 	[CHAN_ENUM_4942] = {4942, 188, 5, 5},
846 	[CHAN_ENUM_4945] = {4945, 189, 10, 10},
847 	[CHAN_ENUM_4947] = {4947, 189, 5, 5},
848 	[CHAN_ENUM_4950] = {4950, INVALID_CHANNEL_NUM, 2, 20},
849 	[CHAN_ENUM_4952] = {4952, INVALID_CHANNEL_NUM, 2, 20},
850 	[CHAN_ENUM_4955] = {4955, INVALID_CHANNEL_NUM, 2, 20},
851 	[CHAN_ENUM_4957] = {4957, INVALID_CHANNEL_NUM, 2, 20},
852 	[CHAN_ENUM_4960] = {4960, 192, 20, 20},
853 	[CHAN_ENUM_4962] = {4962, INVALID_CHANNEL_NUM, 2, 20},
854 	[CHAN_ENUM_4965] = {4965, INVALID_CHANNEL_NUM, 2, 20},
855 	[CHAN_ENUM_4967] = {4967, INVALID_CHANNEL_NUM, 2, 20},
856 	[CHAN_ENUM_4970] = {4970, INVALID_CHANNEL_NUM, 2, 20},
857 	[CHAN_ENUM_4972] = {4972, INVALID_CHANNEL_NUM, 2, 20},
858 	[CHAN_ENUM_4975] = {4975, INVALID_CHANNEL_NUM, 2, 20},
859 	[CHAN_ENUM_4977] = {4977, INVALID_CHANNEL_NUM, 2, 20},
860 	[CHAN_ENUM_4980] = {4980, 196, 20, 20},
861 	[CHAN_ENUM_4982] = {4982, INVALID_CHANNEL_NUM, 2, 20},
862 	[CHAN_ENUM_4985] = {4985, INVALID_CHANNEL_NUM, 2, 20},
863 	[CHAN_ENUM_4987] = {4987, INVALID_CHANNEL_NUM, 2, 20},
864 	[CHAN_ENUM_5032] = {5032, 6, 5, 5},
865 	[CHAN_ENUM_5035] = {5035, 7, 10, 10},
866 	[CHAN_ENUM_5037] = {5037, 7, 5, 5},
867 	[CHAN_ENUM_5040] = {5040, 8, 10, 20},
868 	[CHAN_ENUM_5042] = {5042, 8, 5, 5},
869 	[CHAN_ENUM_5045] = {5045, 9, 10, 10},
870 	[CHAN_ENUM_5047] = {5047, 9, 5, 5},
871 	[CHAN_ENUM_5052] = {5052, 10, 5, 5},
872 	[CHAN_ENUM_5055] = {5055, 11, 10, 10},
873 	[CHAN_ENUM_5057] = {5057, 11, 5, 5},
874 	[CHAN_ENUM_5060] = {5060, 12, 20, 20},
875 	[CHAN_ENUM_5080] = {5080, 16, 20, 20},
876 #endif /* CONFIG_49GHZ_CHAN */
877 	[CHAN_ENUM_5180] = {5180, 36, 2, 160},
878 	[CHAN_ENUM_5200] = {5200, 40, 2, 160},
879 	[CHAN_ENUM_5220] = {5220, 44, 2, 160},
880 	[CHAN_ENUM_5240] = {5240, 48, 2, 160},
881 	[CHAN_ENUM_5260] = {5260, 52, 2, 160},
882 	[CHAN_ENUM_5280] = {5280, 56, 2, 160},
883 	[CHAN_ENUM_5300] = {5300, 60, 2, 160},
884 	[CHAN_ENUM_5320] = {5320, 64, 2, 160},
885 	[CHAN_ENUM_5500] = {5500, 100, 2, 240},
886 	[CHAN_ENUM_5520] = {5520, 104, 2, 240},
887 	[CHAN_ENUM_5540] = {5540, 108, 2, 240},
888 	[CHAN_ENUM_5560] = {5560, 112, 2, 240},
889 	[CHAN_ENUM_5580] = {5580, 116, 2, 240},
890 	[CHAN_ENUM_5600] = {5600, 120, 2, 240},
891 	[CHAN_ENUM_5620] = {5620, 124, 2, 240},
892 	[CHAN_ENUM_5640] = {5640, 128, 2, 240},
893 	[CHAN_ENUM_5660] = {5660, 132, 2, 240},
894 	[CHAN_ENUM_5680] = {5680, 136, 2, 240},
895 	[CHAN_ENUM_5700] = {5700, 140, 2, 240},
896 	[CHAN_ENUM_5720] = {5720, 144, 2, 240},
897 	[CHAN_ENUM_5745] = {5745, 149, 2, 160},
898 	[CHAN_ENUM_5765] = {5765, 153, 2, 160},
899 	[CHAN_ENUM_5785] = {5785, 157, 2, 160},
900 	[CHAN_ENUM_5805] = {5805, 161, 2, 160},
901 	[CHAN_ENUM_5825] = {5825, 165, 2, 160},
902 	[CHAN_ENUM_5845] = {5845, 169, 2, 160},
903 #ifdef WLAN_FEATURE_DSRC
904 	[CHAN_ENUM_5850] = {5850, INVALID_CHANNEL_NUM, 2, 160},
905 	[CHAN_ENUM_5855] = {5855, INVALID_CHANNEL_NUM, 2, 160},
906 	[CHAN_ENUM_5860] = {5860, INVALID_CHANNEL_NUM, 2, 160},
907 #endif
908 	[CHAN_ENUM_5865] = {5865, INVALID_CHANNEL_NUM, 2, 160},
909 #ifdef WLAN_FEATURE_DSRC
910 	[CHAN_ENUM_5870] = {5870, INVALID_CHANNEL_NUM, 2, 160},
911 	[CHAN_ENUM_5875] = {5875, INVALID_CHANNEL_NUM, 2, 160},
912 	[CHAN_ENUM_5880] = {5880, INVALID_CHANNEL_NUM, 2, 160},
913 #endif
914 	[CHAN_ENUM_5885] = {5885, INVALID_CHANNEL_NUM, 2, 160},
915 #ifdef WLAN_FEATURE_DSRC
916 	[CHAN_ENUM_5890] = {5890, INVALID_CHANNEL_NUM, 2, 160},
917 	[CHAN_ENUM_5895] = {5895, INVALID_CHANNEL_NUM, 2, 160},
918 	[CHAN_ENUM_5900] = {5900, INVALID_CHANNEL_NUM, 2, 160},
919 	[CHAN_ENUM_5905] = {5905, INVALID_CHANNEL_NUM, 2, 160},
920 	[CHAN_ENUM_5910] = {5910, INVALID_CHANNEL_NUM, 2, 160},
921 	[CHAN_ENUM_5915] = {5915, INVALID_CHANNEL_NUM, 2, 160},
922 	[CHAN_ENUM_5920] = {5920, INVALID_CHANNEL_NUM, 2, 160},
923 #endif /* WLAN_FEATURE_DSRC */
924 #ifdef CONFIG_BAND_6GHZ
925 	[CHAN_ENUM_5935] = {5935, 2, 2, 20},
926 	[CHAN_ENUM_5955] = {5955, 1, 2, 320},
927 	[CHAN_ENUM_5975] = {5975, 5, 2, 320},
928 	[CHAN_ENUM_5995] = {5995, 9, 2, 320},
929 	[CHAN_ENUM_6015] = {6015, 13, 2, 320},
930 	[CHAN_ENUM_6035] = {6035, 17, 2, 320},
931 	[CHAN_ENUM_6055] = {6055, 21, 2, 320},
932 	[CHAN_ENUM_6075] = {6075, 25, 2, 320},
933 	[CHAN_ENUM_6095] = {6095, 29, 2, 320},
934 	[CHAN_ENUM_6115] = {6115, 33, 2, 320},
935 	[CHAN_ENUM_6135] = {6135, 37, 2, 320},
936 	[CHAN_ENUM_6155] = {6155, 41, 2, 320},
937 	[CHAN_ENUM_6175] = {6175, 45, 2, 320},
938 	[CHAN_ENUM_6195] = {6195, 49, 2, 320},
939 	[CHAN_ENUM_6215] = {6215, 53, 2, 320},
940 	[CHAN_ENUM_6235] = {6235, 57, 2, 320},
941 	[CHAN_ENUM_6255] = {6255, 61, 2, 320},
942 	[CHAN_ENUM_6275] = {6275, 65, 2, 320},
943 	[CHAN_ENUM_6295] = {6295, 69, 2, 320},
944 	[CHAN_ENUM_6315] = {6315, 73, 2, 320},
945 	[CHAN_ENUM_6335] = {6335, 77, 2, 320},
946 	[CHAN_ENUM_6355] = {6355, 81, 2, 320},
947 	[CHAN_ENUM_6375] = {6375, 85, 2, 320},
948 	[CHAN_ENUM_6395] = {6395, 89, 2, 320},
949 	[CHAN_ENUM_6415] = {6415, 93, 2, 320},
950 	[CHAN_ENUM_6435] = {6435, 97, 2, 320},
951 	[CHAN_ENUM_6455] = {6455, 101, 2, 320},
952 	[CHAN_ENUM_6475] = {6475, 105, 2, 320},
953 	[CHAN_ENUM_6495] = {6495, 109, 2, 320},
954 	[CHAN_ENUM_6515] = {6515, 113, 2, 320},
955 	[CHAN_ENUM_6535] = {6535, 117, 2, 320},
956 	[CHAN_ENUM_6555] = {6555, 121, 2, 320},
957 	[CHAN_ENUM_6575] = {6575, 125, 2, 320},
958 	[CHAN_ENUM_6595] = {6595, 129, 2, 320},
959 	[CHAN_ENUM_6615] = {6615, 133, 2, 320},
960 	[CHAN_ENUM_6635] = {6635, 137, 2, 320},
961 	[CHAN_ENUM_6655] = {6655, 141, 2, 320},
962 	[CHAN_ENUM_6675] = {6675, 145, 2, 320},
963 	[CHAN_ENUM_6695] = {6695, 149, 2, 320},
964 	[CHAN_ENUM_6715] = {6715, 153, 2, 320},
965 	[CHAN_ENUM_6735] = {6735, 157, 2, 320},
966 	[CHAN_ENUM_6755] = {6755, 161, 2, 320},
967 	[CHAN_ENUM_6775] = {6775, 165, 2, 320},
968 	[CHAN_ENUM_6795] = {6795, 169, 2, 320},
969 	[CHAN_ENUM_6815] = {6815, 173, 2, 320},
970 	[CHAN_ENUM_6835] = {6835, 177, 2, 320},
971 	[CHAN_ENUM_6855] = {6855, 181, 2, 320},
972 	[CHAN_ENUM_6875] = {6875, 185, 2, 320},
973 	[CHAN_ENUM_6895] = {6895, 189, 2, 320},
974 	[CHAN_ENUM_6915] = {6915, 193, 2, 320},
975 	[CHAN_ENUM_6935] = {6935, 197, 2, 320},
976 	[CHAN_ENUM_6955] = {6955, 201, 2, 320},
977 	[CHAN_ENUM_6975] = {6975, 205, 2, 320},
978 	[CHAN_ENUM_6995] = {6995, 209, 2, 320},
979 	[CHAN_ENUM_7015] = {7015, 213, 2, 320},
980 	[CHAN_ENUM_7035] = {7035, 217, 2, 320},
981 	[CHAN_ENUM_7055] = {7055, 221, 2, 320},
982 	[CHAN_ENUM_7075] = {7075, 225, 2, 160},
983 	[CHAN_ENUM_7095] = {7095, 229, 2, 160},
984 	[CHAN_ENUM_7115] = {7115, 233, 2, 160}
985 #endif /* CONFIG_BAND_6GHZ */
986 };
987 
988 const struct chan_map channel_map_global[NUM_CHANNELS] = {
989 	[CHAN_ENUM_2412] = {2412, 1, 20, 40},
990 	[CHAN_ENUM_2417] = {2417, 2, 20, 40},
991 	[CHAN_ENUM_2422] = {2422, 3, 20, 40},
992 	[CHAN_ENUM_2427] = {2427, 4, 20, 40},
993 	[CHAN_ENUM_2432] = {2432, 5, 20, 40},
994 	[CHAN_ENUM_2437] = {2437, 6, 20, 40},
995 	[CHAN_ENUM_2442] = {2442, 7, 20, 40},
996 	[CHAN_ENUM_2447] = {2447, 8, 20, 40},
997 	[CHAN_ENUM_2452] = {2452, 9, 20, 40},
998 	[CHAN_ENUM_2457] = {2457, 10, 20, 40},
999 	[CHAN_ENUM_2462] = {2462, 11, 20, 40},
1000 	[CHAN_ENUM_2467] = {2467, 12, 20, 40},
1001 	[CHAN_ENUM_2472] = {2472, 13, 20, 40},
1002 	[CHAN_ENUM_2484] = {2484, 14, 20, 20},
1003 #ifdef CONFIG_49GHZ_CHAN
1004 	[CHAN_ENUM_4912] = {4912, INVALID_CHANNEL_NUM, 2, 20},
1005 	[CHAN_ENUM_4915] = {4915, INVALID_CHANNEL_NUM, 2, 20},
1006 	[CHAN_ENUM_4917] = {4917, INVALID_CHANNEL_NUM, 2, 20},
1007 	[CHAN_ENUM_4920] = {4920, INVALID_CHANNEL_NUM, 2, 20},
1008 	[CHAN_ENUM_4922] = {4922, INVALID_CHANNEL_NUM, 2, 20},
1009 	[CHAN_ENUM_4925] = {4925, INVALID_CHANNEL_NUM, 2, 20},
1010 	[CHAN_ENUM_4927] = {4927, INVALID_CHANNEL_NUM, 2, 20},
1011 	[CHAN_ENUM_4932] = {4932, INVALID_CHANNEL_NUM, 2, 20},
1012 	[CHAN_ENUM_4935] = {4935, INVALID_CHANNEL_NUM, 2, 20},
1013 	[CHAN_ENUM_4937] = {4937, INVALID_CHANNEL_NUM, 2, 20},
1014 	[CHAN_ENUM_4940] = {4940, INVALID_CHANNEL_NUM, 2, 20},
1015 	[CHAN_ENUM_4942] = {4942, INVALID_CHANNEL_NUM, 2, 20},
1016 	[CHAN_ENUM_4945] = {4945, INVALID_CHANNEL_NUM, 2, 20},
1017 	[CHAN_ENUM_4947] = {4947, INVALID_CHANNEL_NUM, 2, 20},
1018 	[CHAN_ENUM_4950] = {4950, INVALID_CHANNEL_NUM, 2, 20},
1019 	[CHAN_ENUM_4952] = {4952, INVALID_CHANNEL_NUM, 2, 20},
1020 	[CHAN_ENUM_4955] = {4955, INVALID_CHANNEL_NUM, 2, 20},
1021 	[CHAN_ENUM_4957] = {4957, INVALID_CHANNEL_NUM, 2, 20},
1022 	[CHAN_ENUM_4960] = {4960, INVALID_CHANNEL_NUM, 2, 20},
1023 	[CHAN_ENUM_4962] = {4962, INVALID_CHANNEL_NUM, 2, 20},
1024 	[CHAN_ENUM_4965] = {4965, INVALID_CHANNEL_NUM, 2, 20},
1025 	[CHAN_ENUM_4967] = {4967, INVALID_CHANNEL_NUM, 2, 20},
1026 	[CHAN_ENUM_4970] = {4970, INVALID_CHANNEL_NUM, 2, 20},
1027 	[CHAN_ENUM_4972] = {4972, INVALID_CHANNEL_NUM, 2, 20},
1028 	[CHAN_ENUM_4975] = {4975, INVALID_CHANNEL_NUM, 2, 20},
1029 	[CHAN_ENUM_4977] = {4977, INVALID_CHANNEL_NUM, 2, 20},
1030 	[CHAN_ENUM_4980] = {4980, INVALID_CHANNEL_NUM, 2, 20},
1031 	[CHAN_ENUM_4982] = {4982, INVALID_CHANNEL_NUM, 2, 20},
1032 	[CHAN_ENUM_4985] = {4985, INVALID_CHANNEL_NUM, 2, 20},
1033 	[CHAN_ENUM_4987] = {4987, INVALID_CHANNEL_NUM, 2, 20},
1034 	[CHAN_ENUM_5032] = {5032, INVALID_CHANNEL_NUM, 2, 20},
1035 	[CHAN_ENUM_5035] = {5035, INVALID_CHANNEL_NUM, 2, 20},
1036 	[CHAN_ENUM_5037] = {5037, INVALID_CHANNEL_NUM, 2, 20},
1037 	[CHAN_ENUM_5040] = {5040, INVALID_CHANNEL_NUM, 2, 20},
1038 	[CHAN_ENUM_5042] = {5042, INVALID_CHANNEL_NUM, 2, 20},
1039 	[CHAN_ENUM_5045] = {5045, INVALID_CHANNEL_NUM, 2, 20},
1040 	[CHAN_ENUM_5047] = {5047, INVALID_CHANNEL_NUM, 2, 20},
1041 	[CHAN_ENUM_5052] = {5052, INVALID_CHANNEL_NUM, 2, 20},
1042 	[CHAN_ENUM_5055] = {5055, INVALID_CHANNEL_NUM, 2, 20},
1043 	[CHAN_ENUM_5057] = {5057, INVALID_CHANNEL_NUM, 2, 20},
1044 	[CHAN_ENUM_5060] = {5060, INVALID_CHANNEL_NUM, 2, 20},
1045 	[CHAN_ENUM_5080] = {5080, INVALID_CHANNEL_NUM, 2, 20},
1046 #endif /* CONFIG_49GHZ_CHAN */
1047 	[CHAN_ENUM_5180] = {5180, 36, 2, 160},
1048 	[CHAN_ENUM_5200] = {5200, 40, 2, 160},
1049 	[CHAN_ENUM_5220] = {5220, 44, 2, 160},
1050 	[CHAN_ENUM_5240] = {5240, 48, 2, 160},
1051 	[CHAN_ENUM_5260] = {5260, 52, 2, 160},
1052 	[CHAN_ENUM_5280] = {5280, 56, 2, 160},
1053 	[CHAN_ENUM_5300] = {5300, 60, 2, 160},
1054 	[CHAN_ENUM_5320] = {5320, 64, 2, 160},
1055 	[CHAN_ENUM_5500] = {5500, 100, 2, 240},
1056 	[CHAN_ENUM_5520] = {5520, 104, 2, 240},
1057 	[CHAN_ENUM_5540] = {5540, 108, 2, 240},
1058 	[CHAN_ENUM_5560] = {5560, 112, 2, 240},
1059 	[CHAN_ENUM_5580] = {5580, 116, 2, 240},
1060 	[CHAN_ENUM_5600] = {5600, 120, 2, 240},
1061 	[CHAN_ENUM_5620] = {5620, 124, 2, 240},
1062 	[CHAN_ENUM_5640] = {5640, 128, 2, 240},
1063 	[CHAN_ENUM_5660] = {5660, 132, 2, 240},
1064 	[CHAN_ENUM_5680] = {5680, 136, 2, 240},
1065 	[CHAN_ENUM_5700] = {5700, 140, 2, 240},
1066 	[CHAN_ENUM_5720] = {5720, 144, 2, 240},
1067 	[CHAN_ENUM_5745] = {5745, 149, 2, 160},
1068 	[CHAN_ENUM_5765] = {5765, 153, 2, 160},
1069 	[CHAN_ENUM_5785] = {5785, 157, 2, 160},
1070 	[CHAN_ENUM_5805] = {5805, 161, 2, 160},
1071 	[CHAN_ENUM_5825] = {5825, 165, 2, 160},
1072 	[CHAN_ENUM_5845] = {5845, 169, 2, 160},
1073 #ifdef WLAN_FEATURE_DSRC
1074 	[CHAN_ENUM_5850] = {5850, INVALID_CHANNEL_NUM, 2, 160},
1075 	[CHAN_ENUM_5855] = {5855, INVALID_CHANNEL_NUM, 2, 160},
1076 	[CHAN_ENUM_5860] = {5860, INVALID_CHANNEL_NUM, 2, 160},
1077 #endif
1078 	[CHAN_ENUM_5865] = {5865, 173, 2, 160},
1079 #ifdef WLAN_FEATURE_DSRC
1080 	[CHAN_ENUM_5870] = {5870, INVALID_CHANNEL_NUM, 2, 160},
1081 	[CHAN_ENUM_5875] = {5875, INVALID_CHANNEL_NUM, 2, 160},
1082 	[CHAN_ENUM_5880] = {5880, INVALID_CHANNEL_NUM, 2, 160},
1083 #endif
1084 	[CHAN_ENUM_5885] = {5885, INVALID_CHANNEL_NUM, 2, 160},
1085 #ifdef WLAN_FEATURE_DSRC
1086 	[CHAN_ENUM_5890] = {5890, INVALID_CHANNEL_NUM, 2, 160},
1087 	[CHAN_ENUM_5895] = {5895, INVALID_CHANNEL_NUM, 2, 160},
1088 	[CHAN_ENUM_5900] = {5900, INVALID_CHANNEL_NUM, 2, 160},
1089 	[CHAN_ENUM_5905] = {5905, INVALID_CHANNEL_NUM, 2, 160},
1090 	[CHAN_ENUM_5910] = {5910, INVALID_CHANNEL_NUM, 2, 160},
1091 	[CHAN_ENUM_5915] = {5915, INVALID_CHANNEL_NUM, 2, 160},
1092 	[CHAN_ENUM_5920] = {5920, INVALID_CHANNEL_NUM, 2, 160},
1093 #endif /* WLAN_FEATURE_DSRC */
1094 #ifdef CONFIG_BAND_6GHZ
1095 	[CHAN_ENUM_5935] = {5935, 2, 2, 20},
1096 	[CHAN_ENUM_5955] = {5955, 1, 2, 320},
1097 	[CHAN_ENUM_5975] = {5975, 5, 2, 320},
1098 	[CHAN_ENUM_5995] = {5995, 9, 2, 320},
1099 	[CHAN_ENUM_6015] = {6015, 13, 2, 320},
1100 	[CHAN_ENUM_6035] = {6035, 17, 2, 320},
1101 	[CHAN_ENUM_6055] = {6055, 21, 2, 320},
1102 	[CHAN_ENUM_6075] = {6075, 25, 2, 320},
1103 	[CHAN_ENUM_6095] = {6095, 29, 2, 320},
1104 	[CHAN_ENUM_6115] = {6115, 33, 2, 320},
1105 	[CHAN_ENUM_6135] = {6135, 37, 2, 320},
1106 	[CHAN_ENUM_6155] = {6155, 41, 2, 320},
1107 	[CHAN_ENUM_6175] = {6175, 45, 2, 320},
1108 	[CHAN_ENUM_6195] = {6195, 49, 2, 320},
1109 	[CHAN_ENUM_6215] = {6215, 53, 2, 320},
1110 	[CHAN_ENUM_6235] = {6235, 57, 2, 320},
1111 	[CHAN_ENUM_6255] = {6255, 61, 2, 320},
1112 	[CHAN_ENUM_6275] = {6275, 65, 2, 320},
1113 	[CHAN_ENUM_6295] = {6295, 69, 2, 320},
1114 	[CHAN_ENUM_6315] = {6315, 73, 2, 320},
1115 	[CHAN_ENUM_6335] = {6335, 77, 2, 320},
1116 	[CHAN_ENUM_6355] = {6355, 81, 2, 320},
1117 	[CHAN_ENUM_6375] = {6375, 85, 2, 320},
1118 	[CHAN_ENUM_6395] = {6395, 89, 2, 320},
1119 	[CHAN_ENUM_6415] = {6415, 93, 2, 320},
1120 	[CHAN_ENUM_6435] = {6435, 97, 2, 320},
1121 	[CHAN_ENUM_6455] = {6455, 101, 2, 320},
1122 	[CHAN_ENUM_6475] = {6475, 105, 2, 320},
1123 	[CHAN_ENUM_6495] = {6495, 109, 2, 320},
1124 	[CHAN_ENUM_6515] = {6515, 113, 2, 320},
1125 	[CHAN_ENUM_6535] = {6535, 117, 2, 320},
1126 	[CHAN_ENUM_6555] = {6555, 121, 2, 320},
1127 	[CHAN_ENUM_6575] = {6575, 125, 2, 320},
1128 	[CHAN_ENUM_6595] = {6595, 129, 2, 320},
1129 	[CHAN_ENUM_6615] = {6615, 133, 2, 320},
1130 	[CHAN_ENUM_6635] = {6635, 137, 2, 320},
1131 	[CHAN_ENUM_6655] = {6655, 141, 2, 320},
1132 	[CHAN_ENUM_6675] = {6675, 145, 2, 320},
1133 	[CHAN_ENUM_6695] = {6695, 149, 2, 320},
1134 	[CHAN_ENUM_6715] = {6715, 153, 2, 320},
1135 	[CHAN_ENUM_6735] = {6735, 157, 2, 320},
1136 	[CHAN_ENUM_6755] = {6755, 161, 2, 320},
1137 	[CHAN_ENUM_6775] = {6775, 165, 2, 320},
1138 	[CHAN_ENUM_6795] = {6795, 169, 2, 320},
1139 	[CHAN_ENUM_6815] = {6815, 173, 2, 320},
1140 	[CHAN_ENUM_6835] = {6835, 177, 2, 320},
1141 	[CHAN_ENUM_6855] = {6855, 181, 2, 320},
1142 	[CHAN_ENUM_6875] = {6875, 185, 2, 320},
1143 	[CHAN_ENUM_6895] = {6895, 189, 2, 320},
1144 	[CHAN_ENUM_6915] = {6915, 193, 2, 320},
1145 	[CHAN_ENUM_6935] = {6935, 197, 2, 320},
1146 	[CHAN_ENUM_6955] = {6955, 201, 2, 320},
1147 	[CHAN_ENUM_6975] = {6975, 205, 2, 320},
1148 	[CHAN_ENUM_6995] = {6995, 209, 2, 320},
1149 	[CHAN_ENUM_7015] = {7015, 213, 2, 320},
1150 	[CHAN_ENUM_7035] = {7035, 217, 2, 320},
1151 	[CHAN_ENUM_7055] = {7055, 221, 2, 320},
1152 	[CHAN_ENUM_7075] = {7075, 225, 2, 160},
1153 	[CHAN_ENUM_7095] = {7095, 229, 2, 160},
1154 	[CHAN_ENUM_7115] = {7115, 233, 2, 160}
1155 #endif /* CONFIG_BAND_6GHZ */
1156 };
1157 
1158 const struct chan_map channel_map_china[NUM_CHANNELS] = {
1159 	[CHAN_ENUM_2412] = {2412, 1, 20, 40},
1160 	[CHAN_ENUM_2417] = {2417, 2, 20, 40},
1161 	[CHAN_ENUM_2422] = {2422, 3, 20, 40},
1162 	[CHAN_ENUM_2427] = {2427, 4, 20, 40},
1163 	[CHAN_ENUM_2432] = {2432, 5, 20, 40},
1164 	[CHAN_ENUM_2437] = {2437, 6, 20, 40},
1165 	[CHAN_ENUM_2442] = {2442, 7, 20, 40},
1166 	[CHAN_ENUM_2447] = {2447, 8, 20, 40},
1167 	[CHAN_ENUM_2452] = {2452, 9, 20, 40},
1168 	[CHAN_ENUM_2457] = {2457, 10, 20, 40},
1169 	[CHAN_ENUM_2462] = {2462, 11, 20, 40},
1170 	[CHAN_ENUM_2467] = {2467, 12, 20, 40},
1171 	[CHAN_ENUM_2472] = {2472, 13, 20, 40},
1172 	[CHAN_ENUM_2484] = {2484, 14, 20, 20},
1173 #ifdef CONFIG_49GHZ_CHAN
1174 	[CHAN_ENUM_4912] = {4912, INVALID_CHANNEL_NUM, 2, 20},
1175 	[CHAN_ENUM_4915] = {4915, INVALID_CHANNEL_NUM, 2, 20},
1176 	[CHAN_ENUM_4917] = {4917, INVALID_CHANNEL_NUM, 2, 20},
1177 	[CHAN_ENUM_4920] = {4920, INVALID_CHANNEL_NUM, 2, 20},
1178 	[CHAN_ENUM_4922] = {4922, INVALID_CHANNEL_NUM, 2, 20},
1179 	[CHAN_ENUM_4925] = {4925, INVALID_CHANNEL_NUM, 2, 20},
1180 	[CHAN_ENUM_4927] = {4927, INVALID_CHANNEL_NUM, 2, 20},
1181 	[CHAN_ENUM_4932] = {4932, INVALID_CHANNEL_NUM, 2, 20},
1182 	[CHAN_ENUM_4935] = {4935, INVALID_CHANNEL_NUM, 2, 20},
1183 	[CHAN_ENUM_4937] = {4937, INVALID_CHANNEL_NUM, 2, 20},
1184 	[CHAN_ENUM_4940] = {4940, INVALID_CHANNEL_NUM, 2, 20},
1185 	[CHAN_ENUM_4942] = {4942, INVALID_CHANNEL_NUM, 2, 20},
1186 	[CHAN_ENUM_4945] = {4945, INVALID_CHANNEL_NUM, 2, 20},
1187 	[CHAN_ENUM_4947] = {4947, INVALID_CHANNEL_NUM, 2, 20},
1188 	[CHAN_ENUM_4950] = {4950, INVALID_CHANNEL_NUM, 2, 20},
1189 	[CHAN_ENUM_4952] = {4952, INVALID_CHANNEL_NUM, 2, 20},
1190 	[CHAN_ENUM_4955] = {4955, INVALID_CHANNEL_NUM, 2, 20},
1191 	[CHAN_ENUM_4957] = {4957, INVALID_CHANNEL_NUM, 2, 20},
1192 	[CHAN_ENUM_4960] = {4960, INVALID_CHANNEL_NUM, 2, 20},
1193 	[CHAN_ENUM_4962] = {4962, INVALID_CHANNEL_NUM, 2, 20},
1194 	[CHAN_ENUM_4965] = {4965, INVALID_CHANNEL_NUM, 2, 20},
1195 	[CHAN_ENUM_4967] = {4967, INVALID_CHANNEL_NUM, 2, 20},
1196 	[CHAN_ENUM_4970] = {4970, INVALID_CHANNEL_NUM, 2, 20},
1197 	[CHAN_ENUM_4972] = {4972, INVALID_CHANNEL_NUM, 2, 20},
1198 	[CHAN_ENUM_4975] = {4975, INVALID_CHANNEL_NUM, 2, 20},
1199 	[CHAN_ENUM_4977] = {4977, INVALID_CHANNEL_NUM, 2, 20},
1200 	[CHAN_ENUM_4980] = {4980, INVALID_CHANNEL_NUM, 2, 20},
1201 	[CHAN_ENUM_4982] = {4982, INVALID_CHANNEL_NUM, 2, 20},
1202 	[CHAN_ENUM_4985] = {4985, INVALID_CHANNEL_NUM, 2, 20},
1203 	[CHAN_ENUM_4987] = {4987, INVALID_CHANNEL_NUM, 2, 20},
1204 	[CHAN_ENUM_5032] = {5032, INVALID_CHANNEL_NUM, 2, 20},
1205 	[CHAN_ENUM_5035] = {5035, INVALID_CHANNEL_NUM, 2, 20},
1206 	[CHAN_ENUM_5037] = {5037, INVALID_CHANNEL_NUM, 2, 20},
1207 	[CHAN_ENUM_5040] = {5040, INVALID_CHANNEL_NUM, 2, 20},
1208 	[CHAN_ENUM_5042] = {5042, INVALID_CHANNEL_NUM, 2, 20},
1209 	[CHAN_ENUM_5045] = {5045, INVALID_CHANNEL_NUM, 2, 20},
1210 	[CHAN_ENUM_5047] = {5047, INVALID_CHANNEL_NUM, 2, 20},
1211 	[CHAN_ENUM_5052] = {5052, INVALID_CHANNEL_NUM, 2, 20},
1212 	[CHAN_ENUM_5055] = {5055, INVALID_CHANNEL_NUM, 2, 20},
1213 	[CHAN_ENUM_5057] = {5057, INVALID_CHANNEL_NUM, 2, 20},
1214 	[CHAN_ENUM_5060] = {5060, INVALID_CHANNEL_NUM, 2, 20},
1215 	[CHAN_ENUM_5080] = {5080, INVALID_CHANNEL_NUM, 2, 20},
1216 #endif /* CONFIG_49GHZ_CHAN */
1217 	[CHAN_ENUM_5180] = {5180, 36, 2, 160},
1218 	[CHAN_ENUM_5200] = {5200, 40, 2, 160},
1219 	[CHAN_ENUM_5220] = {5220, 44, 2, 160},
1220 	[CHAN_ENUM_5240] = {5240, 48, 2, 160},
1221 	[CHAN_ENUM_5260] = {5260, 52, 2, 160},
1222 	[CHAN_ENUM_5280] = {5280, 56, 2, 160},
1223 	[CHAN_ENUM_5300] = {5300, 60, 2, 160},
1224 	[CHAN_ENUM_5320] = {5320, 64, 2, 160},
1225 	[CHAN_ENUM_5500] = {5500, 100, 2, 240},
1226 	[CHAN_ENUM_5520] = {5520, 104, 2, 240},
1227 	[CHAN_ENUM_5540] = {5540, 108, 2, 240},
1228 	[CHAN_ENUM_5560] = {5560, 112, 2, 240},
1229 	[CHAN_ENUM_5580] = {5580, 116, 2, 240},
1230 	[CHAN_ENUM_5600] = {5600, 120, 2, 240},
1231 	[CHAN_ENUM_5620] = {5620, 124, 2, 240},
1232 	[CHAN_ENUM_5640] = {5640, 128, 2, 240},
1233 	[CHAN_ENUM_5660] = {5660, 132, 2, 240},
1234 	[CHAN_ENUM_5680] = {5680, 136, 2, 240},
1235 	[CHAN_ENUM_5700] = {5700, 140, 2, 240},
1236 	[CHAN_ENUM_5720] = {5720, 144, 2, 240},
1237 	[CHAN_ENUM_5745] = {5745, 149, 2, 160},
1238 	[CHAN_ENUM_5765] = {5765, 153, 2, 160},
1239 	[CHAN_ENUM_5785] = {5785, 157, 2, 160},
1240 	[CHAN_ENUM_5805] = {5805, 161, 2, 160},
1241 	[CHAN_ENUM_5825] = {5825, 165, 2, 160},
1242 	[CHAN_ENUM_5845] = {5845, 169, 2, 160},
1243 #ifdef WLAN_FEATURE_DSRC
1244 	[CHAN_ENUM_5850] = {5850, INVALID_CHANNEL_NUM, 2, 160},
1245 	[CHAN_ENUM_5855] = {5855, INVALID_CHANNEL_NUM, 2, 160},
1246 	[CHAN_ENUM_5860] = {5860, INVALID_CHANNEL_NUM, 2, 160},
1247 #endif
1248 	[CHAN_ENUM_5865] = {5865, INVALID_CHANNEL_NUM, 2, 160},
1249 #ifdef WLAN_FEATURE_DSRC
1250 	[CHAN_ENUM_5870] = {5870, INVALID_CHANNEL_NUM, 2, 160},
1251 	[CHAN_ENUM_5875] = {5875, INVALID_CHANNEL_NUM, 2, 160},
1252 	[CHAN_ENUM_5880] = {5880, INVALID_CHANNEL_NUM, 2, 160},
1253 #endif
1254 	[CHAN_ENUM_5885] = {5885, INVALID_CHANNEL_NUM, 2, 160},
1255 #ifdef WLAN_FEATURE_DSRC
1256 	[CHAN_ENUM_5890] = {5890, INVALID_CHANNEL_NUM, 2, 160},
1257 	[CHAN_ENUM_5895] = {5895, INVALID_CHANNEL_NUM, 2, 160},
1258 	[CHAN_ENUM_5900] = {5900, INVALID_CHANNEL_NUM, 2, 160},
1259 	[CHAN_ENUM_5905] = {5905, INVALID_CHANNEL_NUM, 2, 160},
1260 	[CHAN_ENUM_5910] = {5910, INVALID_CHANNEL_NUM, 2, 160},
1261 	[CHAN_ENUM_5915] = {5915, INVALID_CHANNEL_NUM, 2, 160},
1262 	[CHAN_ENUM_5920] = {5920, INVALID_CHANNEL_NUM, 2, 160},
1263 #endif /* WLAN_FEATURE_DSRC */
1264 #ifdef CONFIG_BAND_6GHZ
1265 	[CHAN_ENUM_5935] = {5935, 2, 2, 20},
1266 	[CHAN_ENUM_5955] = {5955, 1, 2, 320},
1267 	[CHAN_ENUM_5975] = {5975, 5, 2, 320},
1268 	[CHAN_ENUM_5995] = {5995, 9, 2, 320},
1269 	[CHAN_ENUM_6015] = {6015, 13, 2, 320},
1270 	[CHAN_ENUM_6035] = {6035, 17, 2, 320},
1271 	[CHAN_ENUM_6055] = {6055, 21, 2, 320},
1272 	[CHAN_ENUM_6075] = {6075, 25, 2, 320},
1273 	[CHAN_ENUM_6095] = {6095, 29, 2, 320},
1274 	[CHAN_ENUM_6115] = {6115, 33, 2, 320},
1275 	[CHAN_ENUM_6135] = {6135, 37, 2, 320},
1276 	[CHAN_ENUM_6155] = {6155, 41, 2, 320},
1277 	[CHAN_ENUM_6175] = {6175, 45, 2, 320},
1278 	[CHAN_ENUM_6195] = {6195, 49, 2, 320},
1279 	[CHAN_ENUM_6215] = {6215, 53, 2, 320},
1280 	[CHAN_ENUM_6235] = {6235, 57, 2, 320},
1281 	[CHAN_ENUM_6255] = {6255, 61, 2, 320},
1282 	[CHAN_ENUM_6275] = {6275, 65, 2, 320},
1283 	[CHAN_ENUM_6295] = {6295, 69, 2, 320},
1284 	[CHAN_ENUM_6315] = {6315, 73, 2, 320},
1285 	[CHAN_ENUM_6335] = {6335, 77, 2, 320},
1286 	[CHAN_ENUM_6355] = {6355, 81, 2, 320},
1287 	[CHAN_ENUM_6375] = {6375, 85, 2, 320},
1288 	[CHAN_ENUM_6395] = {6395, 89, 2, 320},
1289 	[CHAN_ENUM_6415] = {6415, 93, 2, 320},
1290 	[CHAN_ENUM_6435] = {6435, 97, 2, 320},
1291 	[CHAN_ENUM_6455] = {6455, 101, 2, 320},
1292 	[CHAN_ENUM_6475] = {6475, 105, 2, 320},
1293 	[CHAN_ENUM_6495] = {6495, 109, 2, 320},
1294 	[CHAN_ENUM_6515] = {6515, 113, 2, 320},
1295 	[CHAN_ENUM_6535] = {6535, 117, 2, 320},
1296 	[CHAN_ENUM_6555] = {6555, 121, 2, 320},
1297 	[CHAN_ENUM_6575] = {6575, 125, 2, 320},
1298 	[CHAN_ENUM_6595] = {6595, 129, 2, 320},
1299 	[CHAN_ENUM_6615] = {6615, 133, 2, 320},
1300 	[CHAN_ENUM_6635] = {6635, 137, 2, 320},
1301 	[CHAN_ENUM_6655] = {6655, 141, 2, 320},
1302 	[CHAN_ENUM_6675] = {6675, 145, 2, 320},
1303 	[CHAN_ENUM_6695] = {6695, 149, 2, 320},
1304 	[CHAN_ENUM_6715] = {6715, 153, 2, 320},
1305 	[CHAN_ENUM_6735] = {6735, 157, 2, 320},
1306 	[CHAN_ENUM_6755] = {6755, 161, 2, 320},
1307 	[CHAN_ENUM_6775] = {6775, 165, 2, 320},
1308 	[CHAN_ENUM_6795] = {6795, 169, 2, 320},
1309 	[CHAN_ENUM_6815] = {6815, 173, 2, 320},
1310 	[CHAN_ENUM_6835] = {6835, 177, 2, 320},
1311 	[CHAN_ENUM_6855] = {6855, 181, 2, 320},
1312 	[CHAN_ENUM_6875] = {6875, 185, 2, 320},
1313 	[CHAN_ENUM_6895] = {6895, 189, 2, 320},
1314 	[CHAN_ENUM_6915] = {6915, 193, 2, 320},
1315 	[CHAN_ENUM_6935] = {6935, 197, 2, 320},
1316 	[CHAN_ENUM_6955] = {6955, 201, 2, 320},
1317 	[CHAN_ENUM_6975] = {6975, 205, 2, 320},
1318 	[CHAN_ENUM_6995] = {6995, 209, 2, 320},
1319 	[CHAN_ENUM_7015] = {7015, 213, 2, 320},
1320 	[CHAN_ENUM_7035] = {7035, 217, 2, 320},
1321 	[CHAN_ENUM_7055] = {7055, 221, 2, 320},
1322 	[CHAN_ENUM_7075] = {7075, 225, 2, 160},
1323 	[CHAN_ENUM_7095] = {7095, 229, 2, 160},
1324 	[CHAN_ENUM_7115] = {7115, 233, 2, 160}
1325 #endif /* CONFIG_BAND_6GHZ */
1326 };
1327 
1328 static uint8_t reg_calculate_max_5gh_enum(void)
1329 {
1330 	int16_t idx;
1331 	uint8_t max_valid_ieee_chan = INVALID_CHANNEL_NUM;
1332 
1333 	for (idx = MAX_5GHZ_CHANNEL; idx >= 0; idx--) {
1334 		if (channel_map[idx].chan_num != INVALID_CHANNEL_NUM) {
1335 			max_valid_ieee_chan = channel_map[idx].chan_num;
1336 			break;
1337 		}
1338 	}
1339 
1340 	return max_valid_ieee_chan;
1341 }
1342 
1343 void reg_init_channel_map(enum dfs_reg dfs_region)
1344 {
1345 	switch (dfs_region) {
1346 	case DFS_UNINIT_REGION:
1347 	case DFS_UNDEF_REGION:
1348 		channel_map = channel_map_global;
1349 		break;
1350 	case DFS_FCC_REGION:
1351 		channel_map = channel_map_us;
1352 		break;
1353 	case DFS_ETSI_REGION:
1354 		channel_map = channel_map_eu;
1355 		break;
1356 	case DFS_MKK_REGION:
1357 	case DFS_MKKN_REGION:
1358 		channel_map = channel_map_jp;
1359 		break;
1360 	case DFS_CN_REGION:
1361 		channel_map = channel_map_china;
1362 		break;
1363 	case DFS_KR_REGION:
1364 		channel_map = channel_map_global;
1365 		break;
1366 	}
1367 
1368 	g_reg_max_5g_chan_num = reg_calculate_max_5gh_enum();
1369 }
1370 
1371 #ifdef WLAN_FEATURE_11BE
1372 uint16_t reg_get_bw_value(enum phy_ch_width bw)
1373 {
1374 	switch (bw) {
1375 	case CH_WIDTH_20MHZ:
1376 		return 20;
1377 	case CH_WIDTH_40MHZ:
1378 		return 40;
1379 	case CH_WIDTH_80MHZ:
1380 		return 80;
1381 	case CH_WIDTH_160MHZ:
1382 		return 160;
1383 	case CH_WIDTH_80P80MHZ:
1384 		return 160;
1385 	case CH_WIDTH_INVALID:
1386 		return 0;
1387 	case CH_WIDTH_5MHZ:
1388 		return 5;
1389 	case CH_WIDTH_10MHZ:
1390 		return 10;
1391 	case CH_WIDTH_320MHZ:
1392 	case CH_WIDTH_MAX:
1393 		return 320;
1394 	default:
1395 		return 0;
1396 	}
1397 }
1398 #else
1399 uint16_t reg_get_bw_value(enum phy_ch_width bw)
1400 {
1401 	switch (bw) {
1402 	case CH_WIDTH_20MHZ:
1403 		return 20;
1404 	case CH_WIDTH_40MHZ:
1405 		return 40;
1406 	case CH_WIDTH_80MHZ:
1407 		return 80;
1408 	case CH_WIDTH_160MHZ:
1409 		return 160;
1410 	case CH_WIDTH_80P80MHZ:
1411 		return 160;
1412 	case CH_WIDTH_INVALID:
1413 		return 0;
1414 	case CH_WIDTH_5MHZ:
1415 		return 5;
1416 	case CH_WIDTH_10MHZ:
1417 		return 10;
1418 	case CH_WIDTH_MAX:
1419 		return 160;
1420 	default:
1421 		return 0;
1422 	}
1423 }
1424 #endif
1425 
1426 struct wlan_lmac_if_reg_tx_ops *reg_get_psoc_tx_ops(
1427 		struct wlan_objmgr_psoc *psoc)
1428 {
1429 	struct wlan_lmac_if_tx_ops *tx_ops;
1430 
1431 	tx_ops = wlan_psoc_get_lmac_if_txops(psoc);
1432 	if (!tx_ops) {
1433 		reg_err("tx_ops is NULL");
1434 		return NULL;
1435 	}
1436 
1437 	return &tx_ops->reg_ops;
1438 }
1439 
1440 /**
1441  * reg_combine_channel_states() - Get minimum of channel state1 and state2
1442  * @chan_state1: Channel state1
1443  * @chan_state2: Channel state2
1444  *
1445  * Return: Channel state
1446  */
1447 enum channel_state reg_combine_channel_states(enum channel_state chan_state1,
1448 					      enum channel_state chan_state2)
1449 {
1450 	if ((chan_state1 == CHANNEL_STATE_INVALID) ||
1451 	    (chan_state2 == CHANNEL_STATE_INVALID))
1452 		return CHANNEL_STATE_INVALID;
1453 	else
1454 		return min(chan_state1, chan_state2);
1455 }
1456 
1457 QDF_STATUS reg_read_default_country(struct wlan_objmgr_psoc *psoc,
1458 				    uint8_t *country_code)
1459 {
1460 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
1461 
1462 	if (!country_code) {
1463 		reg_err("country_code is NULL");
1464 		return QDF_STATUS_E_INVAL;
1465 	}
1466 
1467 	psoc_priv_obj = reg_get_psoc_obj(psoc);
1468 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
1469 		reg_err("psoc reg component is NULL");
1470 		return QDF_STATUS_E_INVAL;
1471 	}
1472 
1473 	qdf_mem_copy(country_code, psoc_priv_obj->def_country,
1474 		     REG_ALPHA2_LEN + 1);
1475 
1476 	return QDF_STATUS_SUCCESS;
1477 }
1478 
1479 #ifdef WLAN_REG_PARTIAL_OFFLOAD
1480 QDF_STATUS reg_get_max_5g_bw_from_country_code(struct wlan_objmgr_pdev *pdev,
1481 					       uint16_t cc,
1482 					       uint16_t *max_bw_5g)
1483 {
1484 	uint16_t i;
1485 	int num_countries;
1486 
1487 	*max_bw_5g = 0;
1488 	reg_get_num_countries(&num_countries);
1489 
1490 	for (i = 0; i < num_countries; i++) {
1491 		if (g_all_countries[i].country_code == cc)
1492 			break;
1493 	}
1494 
1495 	if (i == num_countries)
1496 		return QDF_STATUS_E_FAILURE;
1497 
1498 	*max_bw_5g = g_all_countries[i].max_bw_5g;
1499 
1500 	return QDF_STATUS_SUCCESS;
1501 }
1502 
1503 QDF_STATUS reg_get_max_5g_bw_from_regdomain(struct wlan_objmgr_pdev *pdev,
1504 					    uint16_t regdmn,
1505 					    uint16_t *max_bw_5g)
1506 {
1507 	uint16_t i;
1508 	int num_reg_dmn;
1509 
1510 	*max_bw_5g = 0;
1511 	reg_get_num_reg_dmn_pairs(&num_reg_dmn);
1512 
1513 	for (i = 0; i < num_reg_dmn; i++) {
1514 		if (g_reg_dmn_pairs[i].reg_dmn_pair_id == regdmn)
1515 			break;
1516 	}
1517 
1518 	if (i == num_reg_dmn)
1519 		return QDF_STATUS_E_FAILURE;
1520 
1521 	*max_bw_5g = regdomains_5g[g_reg_dmn_pairs[i].dmn_id_5g].max_bw;
1522 
1523 	return QDF_STATUS_SUCCESS;
1524 }
1525 #else
1526 
1527 QDF_STATUS reg_get_max_5g_bw_from_country_code(struct wlan_objmgr_pdev *pdev,
1528 					       uint16_t cc,
1529 					       uint16_t *max_bw_5g)
1530 {
1531 	*max_bw_5g = reg_get_max_bw_5G_for_fo(pdev);
1532 
1533 	return QDF_STATUS_SUCCESS;
1534 }
1535 
1536 QDF_STATUS reg_get_max_5g_bw_from_regdomain(struct wlan_objmgr_pdev *pdev,
1537 					    uint16_t regdmn,
1538 					    uint16_t *max_bw_5g)
1539 {
1540 	*max_bw_5g = reg_get_max_bw_5G_for_fo(pdev);
1541 
1542 	return QDF_STATUS_SUCCESS;
1543 }
1544 #endif
1545 
1546 uint16_t reg_get_max_bw_5G_for_fo(struct wlan_objmgr_pdev *pdev)
1547 {
1548 	struct wlan_objmgr_psoc *psoc = wlan_pdev_get_psoc(pdev);
1549 	struct wlan_regulatory_psoc_priv_obj *soc_reg;
1550 	uint8_t pdev_id;
1551 	uint8_t phy_id;
1552 	struct wlan_lmac_if_reg_tx_ops *reg_tx_ops;
1553 
1554 	soc_reg = reg_get_psoc_obj(psoc);
1555 	if (!soc_reg) {
1556 		reg_err("soc_reg is NULL");
1557 		return 0;
1558 	}
1559 
1560 	pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev);
1561 	reg_tx_ops = reg_get_psoc_tx_ops(psoc);
1562 	if (reg_tx_ops->get_phy_id_from_pdev_id)
1563 		reg_tx_ops->get_phy_id_from_pdev_id(psoc, pdev_id, &phy_id);
1564 	else
1565 		phy_id = pdev_id;
1566 
1567 	return soc_reg->mas_chan_params[phy_id].max_bw_5g;
1568 }
1569 
1570 void reg_get_current_dfs_region(struct wlan_objmgr_pdev *pdev,
1571 				enum dfs_reg *dfs_reg)
1572 {
1573 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
1574 
1575 	pdev_priv_obj = reg_get_pdev_obj(pdev);
1576 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
1577 		reg_err("reg component pdev priv is NULL");
1578 		return;
1579 	}
1580 
1581 	*dfs_reg = pdev_priv_obj->dfs_region;
1582 }
1583 
1584 void reg_set_dfs_region(struct wlan_objmgr_pdev *pdev,
1585 			enum dfs_reg dfs_reg)
1586 {
1587 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
1588 
1589 	pdev_priv_obj = reg_get_pdev_obj(pdev);
1590 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
1591 		reg_err("psoc reg component is NULL");
1592 		return;
1593 	}
1594 
1595 	pdev_priv_obj->dfs_region = dfs_reg;
1596 
1597 	reg_init_channel_map(dfs_reg);
1598 }
1599 
1600 static uint8_t reg_freq_to_chan_direct(qdf_freq_t freq)
1601 {
1602 	if (freq >= TWOG_CHAN_1_IN_MHZ && freq <= TWOG_CHAN_13_IN_MHZ)
1603 		return IEEE_2GHZ_CH1 +
1604 			(freq - TWOG_CHAN_1_IN_MHZ) / IEEE_CH_SEP;
1605 
1606 	if (freq == TWOG_CHAN_14_IN_MHZ)
1607 		return IEEE_2GHZ_CH14;
1608 
1609 	if (freq >= FIVEG_CHAN_36_IN_MHZ && freq <= FIVEG_CHAN_177_IN_MHZ)
1610 		return IEEE_5GHZ_CH36 +
1611 			(freq - FIVEG_CHAN_36_IN_MHZ) / IEEE_CH_SEP;
1612 
1613 	if (freq == SIXG_CHAN_2_IN_MHZ)
1614 		return IEEE_6GHZ_CH2;
1615 
1616 	if (freq >= SIXG_CHAN_1_IN_MHZ && freq <= SIXG_CHAN_233_IN_MHZ)
1617 		return IEEE_6GHZ_CH1 +
1618 			(freq - SIXG_CHAN_1_IN_MHZ) / IEEE_CH_SEP;
1619 
1620 	return 0;
1621 }
1622 
1623 static uint8_t
1624 reg_freq_to_chan_for_chlist(struct regulatory_channel *chan_list,
1625 			    qdf_freq_t freq,
1626 			    enum channel_enum num_chans)
1627 {
1628 	uint32_t count;
1629 	uint8_t chan_ieee;
1630 
1631 	if (num_chans > NUM_CHANNELS) {
1632 		reg_err_rl("invalid num_chans");
1633 		return 0;
1634 	}
1635 
1636 	chan_ieee = reg_freq_to_chan_direct(freq);
1637 	if (chan_ieee)
1638 		return chan_ieee;
1639 
1640 	for (count = 0; count < num_chans; count++) {
1641 		if (chan_list[count].center_freq >= freq)
1642 			break;
1643 	}
1644 
1645 	if (count == num_chans)
1646 		goto end;
1647 
1648 	if (chan_list[count].center_freq == freq)
1649 		return chan_list[count].chan_num;
1650 
1651 	if (count == 0)
1652 		goto end;
1653 
1654 	if ((chan_list[count - 1].chan_num == INVALID_CHANNEL_NUM) ||
1655 	    (chan_list[count].chan_num == INVALID_CHANNEL_NUM)) {
1656 		reg_err("Frequency %d invalid in current reg domain", freq);
1657 		return 0;
1658 	}
1659 
1660 	return (chan_list[count - 1].chan_num +
1661 		(freq - chan_list[count - 1].center_freq) / 5);
1662 
1663 end:
1664 	reg_err_rl("invalid frequency %d", freq);
1665 	return 0;
1666 }
1667 
1668 uint8_t reg_freq_to_chan(struct wlan_objmgr_pdev *pdev,
1669 			 qdf_freq_t freq)
1670 {
1671 	struct regulatory_channel *chan_list;
1672 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
1673 	uint8_t chan;
1674 	enum supported_6g_pwr_types input_6g_pwr_mode = REG_AP_LPI;
1675 
1676 	if (freq == 0) {
1677 		reg_debug_rl("Invalid freq %d", freq);
1678 		return 0;
1679 	}
1680 
1681 	pdev_priv_obj = reg_get_pdev_obj(pdev);
1682 
1683 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
1684 		reg_err("reg pdev priv obj is NULL");
1685 		return 0;
1686 	}
1687 
1688 	chan_list = pdev_priv_obj->mas_chan_list;
1689 	chan = reg_freq_to_chan_for_chlist(chan_list, freq, NUM_CHANNELS);
1690 
1691 	if (chan)
1692 		return chan;
1693 
1694 	if (!REG_IS_6GHZ_FREQ(freq))
1695 		return chan;
1696 
1697 	input_6g_pwr_mode = REG_AP_LPI;
1698 
1699 	while (input_6g_pwr_mode < REG_INVALID_PWR_MODE) {
1700 		chan_list = reg_get_reg_maschan_lst_frm_6g_pwr_mode(
1701 							input_6g_pwr_mode,
1702 							pdev_priv_obj, 0);
1703 		if (!chan_list)
1704 			return 0;
1705 
1706 		chan = reg_freq_to_chan_for_chlist(chan_list, freq,
1707 						   NUM_6GHZ_CHANNELS);
1708 		if (chan)
1709 			break;
1710 		input_6g_pwr_mode++;
1711 	}
1712 
1713 	return chan;
1714 }
1715 
1716 static uint16_t
1717 reg_compute_chan_to_freq_for_chlist(struct regulatory_channel *chan_list,
1718 				    uint8_t chan_num,
1719 				    enum channel_enum min_chan_range,
1720 				    enum channel_enum max_chan_range)
1721 {
1722 	uint16_t count;
1723 
1724 	if (reg_is_chan_enum_invalid(min_chan_range) ||
1725 	    reg_is_chan_enum_invalid(max_chan_range)) {
1726 		reg_debug_rl("Invalid channel range: min_chan_range: 0x%X max_chan_range: 0x%X",
1727 			     min_chan_range,
1728 			     max_chan_range);
1729 		return 0;
1730 	}
1731 
1732 	for (count = min_chan_range; count <= max_chan_range; count++) {
1733 		if ((chan_list[count].state != CHANNEL_STATE_DISABLE) &&
1734 		    !(chan_list[count].chan_flags & REGULATORY_CHAN_DISABLED)) {
1735 			if (REG_IS_49GHZ_FREQ(chan_list[count].center_freq)) {
1736 				if (chan_list[count].chan_num == chan_num)
1737 					break;
1738 				continue;
1739 			} else if ((chan_list[count].chan_num >= chan_num) &&
1740 				   (chan_list[count].chan_num !=
1741 							INVALID_CHANNEL_NUM))
1742 				break;
1743 		}
1744 	}
1745 
1746 	if (count == max_chan_range + 1)
1747 		goto end;
1748 
1749 	if (chan_list[count].chan_num == chan_num) {
1750 		if (chan_list[count].chan_flags & REGULATORY_CHAN_DISABLED)
1751 			reg_err("Channel %d disabled in current reg domain",
1752 				chan_num);
1753 		return chan_list[count].center_freq;
1754 	}
1755 
1756 	if (count == min_chan_range)
1757 		goto end;
1758 
1759 	if ((chan_list[count - 1].chan_num == INVALID_CHANNEL_NUM) ||
1760 	    REG_IS_49GHZ_FREQ(chan_list[count - 1].center_freq) ||
1761 	    (chan_list[count].chan_num == INVALID_CHANNEL_NUM)) {
1762 		reg_err("Channel %d invalid in current reg domain",
1763 			chan_num);
1764 		return 0;
1765 	}
1766 
1767 	return (chan_list[count - 1].center_freq +
1768 		(chan_num - chan_list[count - 1].chan_num) * 5);
1769 
1770 end:
1771 
1772 	reg_debug_rl("Invalid channel %d", chan_num);
1773 	return 0;
1774 }
1775 
1776 static uint16_t reg_compute_chan_to_freq(struct wlan_objmgr_pdev *pdev,
1777 					 uint8_t chan_num,
1778 					 enum channel_enum min_chan_range,
1779 					 enum channel_enum max_chan_range)
1780 {
1781 	struct regulatory_channel *chan_list;
1782 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
1783 	uint16_t freq;
1784 	enum supported_6g_pwr_types input_6g_pwr_mode;
1785 
1786 	pdev_priv_obj = reg_get_pdev_obj(pdev);
1787 
1788 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
1789 		reg_err("reg pdev priv obj is NULL");
1790 		return 0;
1791 	}
1792 
1793 	if (min_chan_range < MIN_CHANNEL || max_chan_range > MAX_CHANNEL) {
1794 		reg_err_rl("Channel range is invalid");
1795 		return 0;
1796 	}
1797 
1798 	chan_list = pdev_priv_obj->mas_chan_list;
1799 
1800 	freq = reg_compute_chan_to_freq_for_chlist(chan_list, chan_num,
1801 						   min_chan_range,
1802 						   max_chan_range);
1803 
1804 	/* If the frequency is a 2G or 5G frequency, then it should be found
1805 	 * in the regulatory mas_chan_list.
1806 	 * If a valid 6G frequency has been returned with the current power mode
1807 	 * itself, then return the freq computed.
1808 	 */
1809 	if (freq)
1810 		return freq;
1811 
1812 	min_chan_range = reg_convert_enum_to_6g_idx(min_chan_range);
1813 	max_chan_range = reg_convert_enum_to_6g_idx(max_chan_range);
1814 	if (reg_is_chan_enum_invalid(min_chan_range) ||
1815 	    reg_is_chan_enum_invalid(max_chan_range))
1816 		return freq;
1817 
1818 	/* If a valid 6G frequency has not been found, then search in a
1819 	 * power mode's master channel list.
1820 	 */
1821 	input_6g_pwr_mode = REG_AP_LPI;
1822 	while (input_6g_pwr_mode <= REG_CLI_SUB_VLP) {
1823 		chan_list = reg_get_reg_maschan_lst_frm_6g_pwr_mode(
1824 							input_6g_pwr_mode,
1825 							pdev_priv_obj, 0);
1826 		if (!chan_list)
1827 			return 0;
1828 
1829 		freq = reg_compute_chan_to_freq_for_chlist(chan_list, chan_num,
1830 							   min_chan_range,
1831 							   max_chan_range);
1832 		if (freq)
1833 			break;
1834 		input_6g_pwr_mode++;
1835 	}
1836 
1837 	return freq;
1838 }
1839 
1840 uint16_t reg_legacy_chan_to_freq(struct wlan_objmgr_pdev *pdev,
1841 				 uint8_t chan_num)
1842 {
1843 	uint16_t min_chan_range = MIN_24GHZ_CHANNEL;
1844 	uint16_t max_chan_range = MAX_5GHZ_CHANNEL;
1845 
1846 	if (chan_num == 0) {
1847 		reg_debug_rl("Invalid channel %d", chan_num);
1848 		return 0;
1849 	}
1850 
1851 	return reg_compute_chan_to_freq(pdev, chan_num,
1852 					min_chan_range,
1853 					max_chan_range);
1854 }
1855 
1856 #ifdef WLAN_REG_PARTIAL_OFFLOAD
1857 QDF_STATUS reg_program_default_cc(struct wlan_objmgr_pdev *pdev,
1858 				  uint16_t regdmn)
1859 {
1860 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
1861 	struct cur_regulatory_info *reg_info;
1862 	uint16_t cc = -1;
1863 	uint16_t country_index = -1, regdmn_pair = -1;
1864 	struct wlan_objmgr_psoc *psoc;
1865 	QDF_STATUS err;
1866 
1867 	pdev_priv_obj = reg_get_pdev_obj(pdev);
1868 	if (!pdev_priv_obj) {
1869 		reg_err("reg soc is NULL");
1870 		return QDF_STATUS_E_FAILURE;
1871 	}
1872 
1873 	reg_info = (struct cur_regulatory_info *)qdf_mem_malloc
1874 		(sizeof(struct cur_regulatory_info));
1875 	if (!reg_info)
1876 		return QDF_STATUS_E_NOMEM;
1877 
1878 	psoc = wlan_pdev_get_psoc(pdev);
1879 	if (!psoc) {
1880 		reg_err("psoc is NULL");
1881 		return QDF_STATUS_E_INVAL;
1882 	}
1883 
1884 	reg_info->psoc = psoc;
1885 	reg_info->phy_id = wlan_objmgr_pdev_get_pdev_id(pdev);
1886 	reg_info->num_phy = 1;
1887 
1888 	if (regdmn == 0) {
1889 		reg_get_default_country(&regdmn);
1890 		regdmn |= COUNTRY_ERD_FLAG;
1891 	}
1892 
1893 	if (regdmn & COUNTRY_ERD_FLAG) {
1894 		cc = regdmn & ~COUNTRY_ERD_FLAG;
1895 
1896 		reg_get_rdpair_from_country_code(cc,
1897 						 &country_index,
1898 						 &regdmn_pair);
1899 
1900 		err = reg_get_cur_reginfo(reg_info, country_index, regdmn_pair);
1901 		if (err == QDF_STATUS_E_FAILURE) {
1902 			reg_err("Unable to set country code\n");
1903 			qdf_mem_free(reg_info->reg_rules_2g_ptr);
1904 			qdf_mem_free(reg_info->reg_rules_5g_ptr);
1905 			qdf_mem_free(reg_info);
1906 			return QDF_STATUS_E_FAILURE;
1907 		}
1908 
1909 		pdev_priv_obj->ctry_code = cc;
1910 
1911 	} else {
1912 		err = reg_get_rdpair_from_regdmn_id(regdmn, &regdmn_pair);
1913 		if (err == QDF_STATUS_E_FAILURE) {
1914 			reg_err("Failed to get regdmn idx for regdmn pair: %x",
1915 				regdmn);
1916 			qdf_mem_free(reg_info->reg_rules_2g_ptr);
1917 			qdf_mem_free(reg_info->reg_rules_5g_ptr);
1918 			qdf_mem_free(reg_info);
1919 			return QDF_STATUS_E_FAILURE;
1920 		}
1921 
1922 		err = reg_get_cur_reginfo(reg_info, country_index, regdmn_pair);
1923 		if (err == QDF_STATUS_E_FAILURE) {
1924 			reg_err("Unable to set country code\n");
1925 			qdf_mem_free(reg_info->reg_rules_2g_ptr);
1926 			qdf_mem_free(reg_info->reg_rules_5g_ptr);
1927 			qdf_mem_free(reg_info);
1928 			return QDF_STATUS_E_FAILURE;
1929 		}
1930 
1931 		pdev_priv_obj->reg_dmn_pair = regdmn;
1932 	}
1933 
1934 	reg_info->offload_enabled = false;
1935 	reg_process_master_chan_list(reg_info);
1936 
1937 	qdf_mem_free(reg_info->reg_rules_2g_ptr);
1938 	qdf_mem_free(reg_info->reg_rules_5g_ptr);
1939 	qdf_mem_free(reg_info);
1940 
1941 	return QDF_STATUS_SUCCESS;
1942 }
1943 
1944 /**
1945  * reg_program_chan_list_po() - API to program channel list in Partial Offload
1946  * @psoc: Pointer to psoc object manager
1947  * @pdev: Pointer to pdev object
1948  * @rd: Pointer to cc_regdmn_s structure
1949  *
1950  * Return: QDF_STATUS
1951  */
1952 static QDF_STATUS reg_program_chan_list_po(struct wlan_objmgr_psoc *psoc,
1953 					   struct wlan_objmgr_pdev *pdev,
1954 					   struct cc_regdmn_s *rd)
1955 {
1956 	struct cur_regulatory_info *reg_info;
1957 	uint16_t country_index = -1, regdmn_pair = -1;
1958 	QDF_STATUS err;
1959 
1960 	reg_info = (struct cur_regulatory_info *)qdf_mem_malloc
1961 		(sizeof(struct cur_regulatory_info));
1962 	if (!reg_info)
1963 		return QDF_STATUS_E_NOMEM;
1964 
1965 	reg_info->psoc = psoc;
1966 	reg_info->phy_id = wlan_objmgr_pdev_get_pdev_id(pdev);
1967 
1968 	if (rd->flags == CC_IS_SET) {
1969 		reg_get_rdpair_from_country_code(rd->cc.country_code,
1970 						 &country_index,
1971 						 &regdmn_pair);
1972 	} else if (rd->flags == ALPHA_IS_SET) {
1973 		reg_get_rdpair_from_country_iso(rd->cc.alpha,
1974 						&country_index,
1975 						&regdmn_pair);
1976 	} else if (rd->flags == REGDMN_IS_SET) {
1977 		err = reg_get_rdpair_from_regdmn_id(
1978 				rd->cc.regdmn.reg_2g_5g_pair_id,
1979 				&regdmn_pair);
1980 		if (err == QDF_STATUS_E_FAILURE) {
1981 			reg_err("Failed to get regdmn idx for regdmn pair: %x",
1982 				rd->cc.regdmn.reg_2g_5g_pair_id);
1983 			qdf_mem_free(reg_info->reg_rules_2g_ptr);
1984 			qdf_mem_free(reg_info->reg_rules_5g_ptr);
1985 			qdf_mem_free(reg_info);
1986 			return QDF_STATUS_E_FAILURE;
1987 		}
1988 	}
1989 
1990 	err = reg_get_cur_reginfo(reg_info, country_index, regdmn_pair);
1991 	if (err == QDF_STATUS_E_FAILURE) {
1992 		reg_err("Unable to set country code\n");
1993 		qdf_mem_free(reg_info->reg_rules_2g_ptr);
1994 		qdf_mem_free(reg_info->reg_rules_5g_ptr);
1995 		qdf_mem_free(reg_info);
1996 		return QDF_STATUS_E_FAILURE;
1997 	}
1998 
1999 	reg_info->offload_enabled = false;
2000 	reg_process_master_chan_list(reg_info);
2001 
2002 	qdf_mem_free(reg_info->reg_rules_2g_ptr);
2003 	qdf_mem_free(reg_info->reg_rules_5g_ptr);
2004 	qdf_mem_free(reg_info);
2005 
2006 	return QDF_STATUS_SUCCESS;
2007 }
2008 #else
2009 static QDF_STATUS reg_program_chan_list_po(struct wlan_objmgr_psoc *psoc,
2010 					   struct wlan_objmgr_pdev *pdev,
2011 					   struct cc_regdmn_s *rd)
2012 {
2013 	return QDF_STATUS_SUCCESS;
2014 }
2015 #endif /* WLAN_REG_PARTIAL_OFFLOAD */
2016 
2017 QDF_STATUS reg_program_chan_list(struct wlan_objmgr_pdev *pdev,
2018 				 struct cc_regdmn_s *rd)
2019 {
2020 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
2021 	struct wlan_objmgr_psoc *psoc;
2022 	struct wlan_lmac_if_reg_tx_ops *tx_ops;
2023 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
2024 	uint8_t pdev_id;
2025 	uint8_t phy_id;
2026 
2027 	pdev_priv_obj = reg_get_pdev_obj(pdev);
2028 	if (!pdev_priv_obj) {
2029 		reg_err(" pdev priv obj is NULL");
2030 		return QDF_STATUS_E_FAILURE;
2031 	}
2032 
2033 	psoc = wlan_pdev_get_psoc(pdev);
2034 	if (!psoc) {
2035 		reg_err("psoc is NULL");
2036 		return QDF_STATUS_E_INVAL;
2037 	}
2038 
2039 	psoc_priv_obj = reg_get_psoc_obj(psoc);
2040 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
2041 		reg_err("psoc reg component is NULL");
2042 		return QDF_STATUS_E_FAILURE;
2043 	}
2044 
2045 	if (psoc_priv_obj->offload_enabled) {
2046 		if ((rd->flags == ALPHA_IS_SET) && (rd->cc.alpha[2] == 'O'))
2047 			pdev_priv_obj->indoor_chan_enabled = false;
2048 		else
2049 			pdev_priv_obj->indoor_chan_enabled = true;
2050 
2051 		pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev);
2052 		tx_ops = reg_get_psoc_tx_ops(psoc);
2053 
2054 		if (tx_ops->get_phy_id_from_pdev_id)
2055 			tx_ops->get_phy_id_from_pdev_id(psoc, pdev_id, &phy_id);
2056 		else
2057 			phy_id = pdev_id;
2058 
2059 		if (tx_ops->set_user_country_code) {
2060 			psoc_priv_obj->new_init_ctry_pending[phy_id] = true;
2061 			return tx_ops->set_user_country_code(psoc, pdev_id, rd);
2062 		}
2063 
2064 		return QDF_STATUS_E_FAILURE;
2065 	}
2066 
2067 	return reg_program_chan_list_po(psoc, pdev, rd);
2068 }
2069 
2070 QDF_STATUS reg_get_current_cc(struct wlan_objmgr_pdev *pdev,
2071 			      struct cc_regdmn_s *rd)
2072 {
2073 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
2074 
2075 	pdev_priv_obj = reg_get_pdev_obj(pdev);
2076 	if (!pdev_priv_obj) {
2077 		reg_err("reg pdev priv is NULL");
2078 		return QDF_STATUS_E_FAILURE;
2079 	}
2080 
2081 	if (rd->flags == CC_IS_SET) {
2082 		rd->cc.country_code = pdev_priv_obj->ctry_code;
2083 	} else if (rd->flags == ALPHA_IS_SET) {
2084 		qdf_mem_copy(rd->cc.alpha, pdev_priv_obj->current_country,
2085 			     sizeof(rd->cc.alpha));
2086 	} else if (rd->flags == REGDMN_IS_SET) {
2087 		rd->cc.regdmn.reg_2g_5g_pair_id = pdev_priv_obj->reg_dmn_pair;
2088 		rd->cc.regdmn.sixg_superdmn_id = pdev_priv_obj->reg_6g_superid;
2089 	}
2090 
2091 	return QDF_STATUS_SUCCESS;
2092 }
2093 
2094 QDF_STATUS reg_set_regdb_offloaded(struct wlan_objmgr_psoc *psoc, bool val)
2095 {
2096 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
2097 
2098 	psoc_priv_obj = reg_get_psoc_obj(psoc);
2099 
2100 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
2101 		reg_err("psoc reg component is NULL");
2102 		return QDF_STATUS_E_FAILURE;
2103 	}
2104 
2105 	psoc_priv_obj->offload_enabled = val;
2106 
2107 	return QDF_STATUS_SUCCESS;
2108 }
2109 
2110 QDF_STATUS reg_get_curr_regdomain(struct wlan_objmgr_pdev *pdev,
2111 				  struct cur_regdmn_info *cur_regdmn)
2112 {
2113 	struct wlan_objmgr_psoc *psoc;
2114 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
2115 	uint16_t index;
2116 	int num_reg_dmn;
2117 	uint8_t phy_id;
2118 	uint8_t pdev_id;
2119 	struct wlan_lmac_if_reg_tx_ops *tx_ops;
2120 
2121 	psoc = wlan_pdev_get_psoc(pdev);
2122 	psoc_priv_obj = reg_get_psoc_obj(psoc);
2123 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
2124 		reg_err("soc reg component is NULL");
2125 		return QDF_STATUS_E_INVAL;
2126 	}
2127 
2128 	pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev);
2129 
2130 	tx_ops = reg_get_psoc_tx_ops(psoc);
2131 	if (tx_ops->get_phy_id_from_pdev_id)
2132 		tx_ops->get_phy_id_from_pdev_id(psoc, pdev_id, &phy_id);
2133 	else
2134 		phy_id = pdev_id;
2135 
2136 	cur_regdmn->regdmn_pair_id =
2137 		psoc_priv_obj->mas_chan_params[phy_id].reg_dmn_pair;
2138 
2139 	reg_get_num_reg_dmn_pairs(&num_reg_dmn);
2140 	for (index = 0; index < num_reg_dmn; index++) {
2141 		if (g_reg_dmn_pairs[index].reg_dmn_pair_id ==
2142 				cur_regdmn->regdmn_pair_id)
2143 			break;
2144 	}
2145 
2146 	if (index == num_reg_dmn) {
2147 		reg_debug_rl("invalid regdomain");
2148 		return QDF_STATUS_E_FAILURE;
2149 	}
2150 
2151 	cur_regdmn->dmn_id_2g = g_reg_dmn_pairs[index].dmn_id_2g;
2152 	cur_regdmn->dmn_id_5g = g_reg_dmn_pairs[index].dmn_id_5g;
2153 	cur_regdmn->ctl_2g = regdomains_2g[cur_regdmn->dmn_id_2g].ctl_val;
2154 	cur_regdmn->ctl_5g = regdomains_5g[cur_regdmn->dmn_id_5g].ctl_val;
2155 	cur_regdmn->dfs_region =
2156 		regdomains_5g[cur_regdmn->dmn_id_5g].dfs_region;
2157 
2158 	return QDF_STATUS_SUCCESS;
2159 }
2160 
2161 QDF_STATUS reg_modify_chan_144(struct wlan_objmgr_pdev *pdev,
2162 			       bool enable_ch_144)
2163 {
2164 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
2165 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
2166 	struct wlan_objmgr_psoc *psoc;
2167 	struct wlan_lmac_if_reg_tx_ops *reg_tx_ops;
2168 	QDF_STATUS status;
2169 
2170 	pdev_priv_obj = reg_get_pdev_obj(pdev);
2171 
2172 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
2173 		reg_err("pdev reg component is NULL");
2174 		return QDF_STATUS_E_INVAL;
2175 	}
2176 
2177 	if (pdev_priv_obj->en_chan_144 == enable_ch_144) {
2178 		reg_info("chan 144 is already  %d", enable_ch_144);
2179 		return QDF_STATUS_SUCCESS;
2180 	}
2181 
2182 	psoc = wlan_pdev_get_psoc(pdev);
2183 	if (!psoc) {
2184 		reg_err("psoc is NULL");
2185 		return QDF_STATUS_E_INVAL;
2186 	}
2187 
2188 	psoc_priv_obj = reg_get_psoc_obj(psoc);
2189 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
2190 		reg_err("psoc reg component is NULL");
2191 		return QDF_STATUS_E_INVAL;
2192 	}
2193 
2194 	reg_debug("setting chan 144: %d", enable_ch_144);
2195 	pdev_priv_obj->en_chan_144 = enable_ch_144;
2196 
2197 	reg_compute_pdev_current_chan_list(pdev_priv_obj);
2198 
2199 	reg_tx_ops = reg_get_psoc_tx_ops(psoc);
2200 	if (reg_tx_ops->fill_umac_legacy_chanlist)
2201 		reg_tx_ops->fill_umac_legacy_chanlist(pdev,
2202 				pdev_priv_obj->cur_chan_list);
2203 
2204 	status = reg_send_scheduler_msg_sb(psoc, pdev);
2205 
2206 	return status;
2207 }
2208 
2209 bool reg_get_en_chan_144(struct wlan_objmgr_pdev *pdev)
2210 {
2211 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
2212 
2213 	pdev_priv_obj = reg_get_pdev_obj(pdev);
2214 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
2215 		reg_err("pdev reg component is NULL");
2216 		return false;
2217 	}
2218 
2219 	return pdev_priv_obj->en_chan_144;
2220 }
2221 
2222 struct wlan_psoc_host_hal_reg_capabilities_ext *reg_get_hal_reg_cap(
2223 						struct wlan_objmgr_psoc *psoc)
2224 {
2225 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
2226 
2227 	psoc_priv_obj = reg_get_psoc_obj(psoc);
2228 
2229 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
2230 		reg_err("psoc reg component is NULL");
2231 		return NULL;
2232 	}
2233 
2234 	return psoc_priv_obj->reg_cap;
2235 }
2236 
2237 QDF_STATUS reg_set_hal_reg_cap(
2238 		struct wlan_objmgr_psoc *psoc,
2239 		struct wlan_psoc_host_hal_reg_capabilities_ext *reg_cap,
2240 		uint16_t phy_cnt)
2241 {
2242 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
2243 
2244 	psoc_priv_obj = reg_get_psoc_obj(psoc);
2245 
2246 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
2247 		reg_err("psoc reg component is NULL");
2248 		return QDF_STATUS_E_FAILURE;
2249 	}
2250 
2251 	if (phy_cnt > PSOC_MAX_PHY_REG_CAP) {
2252 		reg_err("phy cnt:%d is more than %d", phy_cnt,
2253 			PSOC_MAX_PHY_REG_CAP);
2254 		return QDF_STATUS_E_FAILURE;
2255 	}
2256 
2257 	qdf_mem_copy(psoc_priv_obj->reg_cap, reg_cap,
2258 		     phy_cnt *
2259 		     sizeof(struct wlan_psoc_host_hal_reg_capabilities_ext));
2260 
2261 	return QDF_STATUS_SUCCESS;
2262 }
2263 
2264 QDF_STATUS reg_update_hal_cap_wireless_modes(struct wlan_objmgr_psoc *psoc,
2265 					uint64_t wireless_modes, uint8_t phy_id)
2266 {
2267 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
2268 
2269 	if (!psoc) {
2270 		reg_err("psoc is null");
2271 		return QDF_STATUS_E_FAILURE;
2272 	}
2273 
2274 	psoc_priv_obj = reg_get_psoc_obj(psoc);
2275 
2276 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
2277 		reg_err("psoc reg component is NULL");
2278 		return QDF_STATUS_E_FAILURE;
2279 	}
2280 
2281 	psoc_priv_obj->reg_cap[phy_id].wireless_modes |= wireless_modes;
2282 
2283 	return QDF_STATUS_SUCCESS;
2284 }
2285 
2286 QDF_STATUS reg_update_hal_reg_range_caps(struct wlan_objmgr_psoc *psoc,
2287 					 uint32_t low_2g_chan,
2288 					 uint32_t high_2g_chan,
2289 					 uint32_t low_5g_chan,
2290 					 uint32_t high_5g_chan,
2291 					 uint8_t phy_id)
2292 {
2293 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
2294 	struct wlan_psoc_host_hal_reg_capabilities_ext *reg_cap;
2295 
2296 	if (!psoc) {
2297 		reg_err("psoc is null");
2298 		return QDF_STATUS_E_FAILURE;
2299 	}
2300 
2301 	psoc_priv_obj = reg_get_psoc_obj(psoc);
2302 
2303 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
2304 		reg_err("psoc reg component is NULL");
2305 		return QDF_STATUS_E_FAILURE;
2306 	}
2307 
2308 	reg_cap = &psoc_priv_obj->reg_cap[phy_id];
2309 	reg_cap->low_2ghz_chan = low_2g_chan;
2310 	reg_cap->high_2ghz_chan = high_2g_chan;
2311 	reg_cap->low_5ghz_chan = low_5g_chan;
2312 	reg_cap->high_5ghz_chan = high_5g_chan;
2313 
2314 	return QDF_STATUS_SUCCESS;
2315 }
2316 
2317 #if defined(CONFIG_BAND_6GHZ) && defined(CONFIG_AFC_SUPPORT)
2318 bool reg_get_enable_6ghz_sp_mode_support(struct wlan_objmgr_psoc *psoc)
2319 {
2320 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
2321 
2322 	psoc_priv_obj = reg_get_psoc_obj(psoc);
2323 
2324 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
2325 		reg_err("psoc reg component is NULL");
2326 		return false;
2327 	}
2328 
2329 	return psoc_priv_obj->enable_6ghz_sp_pwrmode_supp;
2330 }
2331 
2332 void reg_set_enable_6ghz_sp_mode_support(struct wlan_objmgr_psoc *psoc,
2333 					 bool value)
2334 {
2335 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
2336 
2337 	psoc_priv_obj = reg_get_psoc_obj(psoc);
2338 
2339 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
2340 		reg_err("psoc reg component is NULL");
2341 		return;
2342 	}
2343 
2344 	psoc_priv_obj->enable_6ghz_sp_pwrmode_supp = value;
2345 }
2346 
2347 bool reg_get_afc_disable_timer_check(struct wlan_objmgr_psoc *psoc)
2348 {
2349 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
2350 
2351 	psoc_priv_obj = reg_get_psoc_obj(psoc);
2352 
2353 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
2354 		reg_err("psoc reg component is NULL");
2355 		return false;
2356 	}
2357 
2358 	return psoc_priv_obj->afc_disable_timer_check;
2359 }
2360 
2361 void reg_set_afc_disable_timer_check(struct wlan_objmgr_psoc *psoc,
2362 				     bool value)
2363 {
2364 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
2365 
2366 	psoc_priv_obj = reg_get_psoc_obj(psoc);
2367 
2368 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
2369 		reg_err("psoc reg component is NULL");
2370 		return;
2371 	}
2372 
2373 	psoc_priv_obj->afc_disable_timer_check = value;
2374 }
2375 
2376 bool reg_get_afc_disable_request_id_check(struct wlan_objmgr_psoc *psoc)
2377 {
2378 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
2379 
2380 	psoc_priv_obj = reg_get_psoc_obj(psoc);
2381 
2382 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
2383 		reg_err("psoc reg component is NULL");
2384 		return false;
2385 	}
2386 
2387 	return psoc_priv_obj->afc_disable_request_id_check;
2388 }
2389 
2390 void reg_set_afc_disable_request_id_check(struct wlan_objmgr_psoc *psoc,
2391 					  bool value)
2392 {
2393 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
2394 
2395 	psoc_priv_obj = reg_get_psoc_obj(psoc);
2396 
2397 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
2398 		reg_err("psoc reg component is NULL");
2399 		return;
2400 	}
2401 
2402 	psoc_priv_obj->afc_disable_request_id_check = value;
2403 }
2404 
2405 bool reg_get_afc_noaction(struct wlan_objmgr_psoc *psoc)
2406 {
2407 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
2408 
2409 	psoc_priv_obj = reg_get_psoc_obj(psoc);
2410 
2411 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
2412 		reg_err("psoc reg component is NULL");
2413 		return false;
2414 	}
2415 
2416 	return psoc_priv_obj->is_afc_reg_noaction;
2417 }
2418 
2419 void reg_set_afc_noaction(struct wlan_objmgr_psoc *psoc, bool value)
2420 {
2421 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
2422 
2423 	psoc_priv_obj = reg_get_psoc_obj(psoc);
2424 
2425 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
2426 		reg_err("psoc reg component is NULL");
2427 		return;
2428 	}
2429 
2430 	psoc_priv_obj->is_afc_reg_noaction = value;
2431 }
2432 #endif
2433 
2434 bool reg_chan_in_range(struct regulatory_channel *chan_list,
2435 		       qdf_freq_t low_freq_2g, qdf_freq_t high_freq_2g,
2436 		       qdf_freq_t low_freq_5g, qdf_freq_t high_freq_5g,
2437 		       enum channel_enum ch_enum)
2438 {
2439 	uint32_t low_limit_2g = NUM_CHANNELS;
2440 	uint32_t high_limit_2g = NUM_CHANNELS;
2441 	uint32_t low_limit_5g = NUM_CHANNELS;
2442 	uint32_t high_limit_5g = NUM_CHANNELS;
2443 	bool chan_in_range;
2444 	enum channel_enum chan_enum;
2445 	uint16_t min_bw;
2446 	qdf_freq_t center_freq;
2447 
2448 	for (chan_enum = 0; chan_enum < NUM_CHANNELS; chan_enum++) {
2449 		min_bw = chan_list[chan_enum].min_bw;
2450 		center_freq = chan_list[chan_enum].center_freq;
2451 
2452 		if ((center_freq - min_bw / 2) >= low_freq_2g) {
2453 			low_limit_2g = chan_enum;
2454 			break;
2455 		}
2456 	}
2457 
2458 	for (chan_enum = 0; chan_enum < NUM_CHANNELS; chan_enum++) {
2459 		min_bw = chan_list[chan_enum].min_bw;
2460 		center_freq = chan_list[chan_enum].center_freq;
2461 
2462 		if ((center_freq - min_bw / 2) >= low_freq_5g) {
2463 			low_limit_5g = chan_enum;
2464 			break;
2465 		}
2466 	}
2467 
2468 	for (chan_enum = NUM_CHANNELS - 1; chan_enum >= 0; chan_enum--) {
2469 		min_bw = chan_list[chan_enum].min_bw;
2470 		center_freq = chan_list[chan_enum].center_freq;
2471 
2472 		if (center_freq + min_bw / 2 <= high_freq_2g) {
2473 			high_limit_2g = chan_enum;
2474 			break;
2475 		}
2476 		if (chan_enum == 0)
2477 			break;
2478 	}
2479 
2480 	for (chan_enum = NUM_CHANNELS - 1; chan_enum >= 0; chan_enum--) {
2481 		min_bw = chan_list[chan_enum].min_bw;
2482 		center_freq = chan_list[chan_enum].center_freq;
2483 
2484 		if (center_freq + min_bw / 2 <= high_freq_5g) {
2485 			high_limit_5g = chan_enum;
2486 			break;
2487 		}
2488 		if (chan_enum == 0)
2489 			break;
2490 	}
2491 
2492 	chan_in_range = false;
2493 	if  ((low_limit_2g <= ch_enum) &&
2494 	     (high_limit_2g >= ch_enum) &&
2495 	     (low_limit_2g != NUM_CHANNELS) &&
2496 	     (high_limit_2g != NUM_CHANNELS))
2497 		chan_in_range = true;
2498 	if  ((low_limit_5g <= ch_enum) &&
2499 	     (high_limit_5g >= ch_enum) &&
2500 	     (low_limit_5g != NUM_CHANNELS) &&
2501 	     (high_limit_5g != NUM_CHANNELS))
2502 		chan_in_range = true;
2503 
2504 	if (chan_in_range)
2505 		return true;
2506 	else
2507 		return false;
2508 }
2509 
2510 bool reg_is_24ghz_ch_freq(uint32_t freq)
2511 {
2512 	return REG_IS_24GHZ_CH_FREQ(freq);
2513 }
2514 
2515 bool reg_is_5ghz_ch_freq(uint32_t freq)
2516 {
2517 	return REG_IS_5GHZ_FREQ(freq);
2518 }
2519 
2520 /**
2521  * BAND_2G_PRESENT() - Check if REG_BAND_2G is set in the band_mask
2522  * @band_mask: Bitmask for bands
2523  *
2524  * Return: True if REG_BAND_2G is set in the band_mask, else false
2525  */
2526 static inline bool BAND_2G_PRESENT(uint8_t band_mask)
2527 {
2528 	return !!(band_mask & (BIT(REG_BAND_2G)));
2529 }
2530 
2531 /**
2532  * BAND_5G_PRESENT() - Check if REG_BAND_5G is set in the band_mask
2533  * @band_mask: Bitmask for bands
2534  *
2535  * Return: True if REG_BAND_5G is set in the band_mask, else false
2536  */
2537 static inline bool BAND_5G_PRESENT(uint8_t band_mask)
2538 {
2539 	return !!(band_mask & (BIT(REG_BAND_5G)));
2540 }
2541 
2542 /**
2543  * reg_is_freq_in_between() - Check whether freq falls within low_freq and
2544  * high_freq, inclusively.
2545  * @low_freq: Low frequency.
2546  * @high_freq: High frequency.
2547  * @freq: Frequency to be checked.
2548  *
2549  * Return: True if freq falls within low_freq and high_freq, else false.
2550  */
2551 static bool reg_is_freq_in_between(qdf_freq_t low_freq, qdf_freq_t high_freq,
2552 				   qdf_freq_t freq)
2553 {
2554 	return (low_freq <= freq && freq <= high_freq);
2555 }
2556 
2557 static bool reg_is_ranges_overlap(qdf_freq_t low_freq, qdf_freq_t high_freq,
2558 				  qdf_freq_t start_edge_freq,
2559 				  qdf_freq_t end_edge_freq)
2560 {
2561 	return (reg_is_freq_in_between(start_edge_freq,
2562 				       end_edge_freq,
2563 				       low_freq) ||
2564 		reg_is_freq_in_between(start_edge_freq,
2565 				       end_edge_freq,
2566 				       high_freq) ||
2567 		reg_is_freq_in_between(low_freq,
2568 				       high_freq,
2569 				       start_edge_freq) ||
2570 		reg_is_freq_in_between(low_freq,
2571 				       high_freq,
2572 				       end_edge_freq));
2573 }
2574 
2575 bool reg_is_range_overlap_2g(qdf_freq_t low_freq, qdf_freq_t high_freq)
2576 {
2577 	return reg_is_ranges_overlap(low_freq, high_freq,
2578 				     TWO_GIG_STARTING_EDGE_FREQ,
2579 				     TWO_GIG_ENDING_EDGE_FREQ);
2580 }
2581 
2582 bool reg_is_range_overlap_5g(qdf_freq_t low_freq, qdf_freq_t high_freq)
2583 {
2584 	return reg_is_ranges_overlap(low_freq, high_freq,
2585 				     FIVE_GIG_STARTING_EDGE_FREQ,
2586 				     FIVE_GIG_ENDING_EDGE_FREQ);
2587 }
2588 
2589 static struct regulatory_channel *
2590 reg_get_reg_chan(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq)
2591 {
2592 	struct regulatory_channel *cur_chan_list;
2593 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
2594 	enum channel_enum chan_enum;
2595 
2596 	pdev_priv_obj = reg_get_pdev_obj(pdev);
2597 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
2598 		reg_err("reg pdev priv obj is NULL");
2599 		return NULL;
2600 	}
2601 
2602 	chan_enum = reg_get_chan_enum_for_freq(freq);
2603 	if (reg_is_chan_enum_invalid(chan_enum)) {
2604 		reg_err_rl("Invalid chan enum %d", chan_enum);
2605 		return NULL;
2606 	}
2607 
2608 	cur_chan_list = pdev_priv_obj->cur_chan_list;
2609 	if (cur_chan_list[chan_enum].state == CHANNEL_STATE_DISABLE) {
2610 		reg_err("Channel %u is not enabled for this pdev", freq);
2611 		return NULL;
2612 	}
2613 
2614 	return &cur_chan_list[chan_enum];
2615 }
2616 
2617 bool reg_is_freq_indoor(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq)
2618 {
2619 	struct regulatory_channel *reg_chan;
2620 
2621 	reg_chan = reg_get_reg_chan(pdev, freq);
2622 
2623 	if (!reg_chan) {
2624 		reg_err("reg channel is NULL");
2625 		return false;
2626 	}
2627 
2628 	return (reg_chan->chan_flags &
2629 		REGULATORY_CHAN_INDOOR_ONLY);
2630 }
2631 
2632 uint16_t reg_get_min_chwidth(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq)
2633 {
2634 	struct regulatory_channel *reg_chan;
2635 
2636 	reg_chan = reg_get_reg_chan(pdev, freq);
2637 
2638 	if (!reg_chan) {
2639 		reg_err("reg channel is NULL");
2640 		return 0;
2641 	}
2642 
2643 	return reg_chan->min_bw;
2644 }
2645 
2646 uint16_t reg_get_max_chwidth(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq)
2647 {
2648 	struct regulatory_channel *reg_chan;
2649 
2650 	reg_chan = reg_get_reg_chan(pdev, freq);
2651 
2652 	if (!reg_chan) {
2653 		reg_err("reg channel is NULL");
2654 		return 0;
2655 	}
2656 
2657 	return reg_chan->max_bw;
2658 }
2659 
2660 #ifdef CONFIG_REG_CLIENT
2661 bool reg_is_freq_indoor_in_secondary_list(struct wlan_objmgr_pdev *pdev,
2662 					  qdf_freq_t freq)
2663 {
2664 	struct regulatory_channel *secondary_cur_chan_list;
2665 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
2666 	enum channel_enum chan_enum;
2667 
2668 	pdev_priv_obj = reg_get_pdev_obj(pdev);
2669 
2670 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
2671 		reg_err("reg pdev priv obj is NULL");
2672 		return false;
2673 	}
2674 
2675 	chan_enum = reg_get_chan_enum_for_freq(freq);
2676 
2677 	if (reg_is_chan_enum_invalid(chan_enum)) {
2678 		reg_err_rl("Invalid chan enum %d", chan_enum);
2679 		return false;
2680 	}
2681 
2682 	secondary_cur_chan_list = pdev_priv_obj->secondary_cur_chan_list;
2683 
2684 	return (secondary_cur_chan_list[chan_enum].chan_flags &
2685 		REGULATORY_CHAN_INDOOR_ONLY);
2686 }
2687 #endif
2688 
2689 #ifdef CONFIG_BAND_6GHZ
2690 bool reg_is_6ghz_chan_freq(uint16_t freq)
2691 {
2692 	return REG_IS_6GHZ_FREQ(freq);
2693 }
2694 
2695 #ifdef CONFIG_6G_FREQ_OVERLAP
2696 bool reg_is_range_overlap_6g(qdf_freq_t low_freq, qdf_freq_t high_freq)
2697 {
2698 	return reg_is_ranges_overlap(low_freq, high_freq,
2699 				     SIX_GIG_STARTING_EDGE_FREQ,
2700 				     SIX_GIG_ENDING_EDGE_FREQ);
2701 }
2702 
2703 bool reg_is_range_only6g(qdf_freq_t low_freq, qdf_freq_t high_freq)
2704 {
2705 	if (low_freq >= high_freq) {
2706 		reg_err_rl("Low freq is greater than or equal to high freq");
2707 		return false;
2708 	}
2709 
2710 	if (reg_is_range_overlap_6g(low_freq, high_freq) &&
2711 	    !reg_is_range_overlap_5g(low_freq, high_freq)) {
2712 		reg_debug_rl("The device is 6G only");
2713 		return true;
2714 	}
2715 
2716 	reg_debug_rl("The device is not 6G only");
2717 
2718 	return false;
2719 }
2720 #endif
2721 
2722 uint16_t reg_min_6ghz_chan_freq(void)
2723 {
2724 	return REG_MIN_6GHZ_CHAN_FREQ;
2725 }
2726 
2727 uint16_t reg_max_6ghz_chan_freq(void)
2728 {
2729 	return REG_MAX_6GHZ_CHAN_FREQ;
2730 }
2731 
2732 bool reg_is_6ghz_psc_chan_freq(uint16_t freq)
2733 {
2734 	if (!REG_IS_6GHZ_FREQ(freq)) {
2735 		reg_debug(" Channel frequency is not a 6GHz frequency");
2736 		return false;
2737 	}
2738 
2739 	if (!(((freq - SIX_GHZ_NON_ORPHAN_START_FREQ) + FREQ_LEFT_SHIFT) %
2740 	      (FREQ_TO_CHAN_SCALE * NUM_80MHZ_BAND_IN_6G))) {
2741 		return true;
2742 	}
2743 
2744 	reg_debug_rl("Channel freq %d MHz is not a 6GHz PSC frequency", freq);
2745 
2746 	return false;
2747 }
2748 
2749 bool reg_is_6g_freq_indoor(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq)
2750 {
2751 	return (REG_IS_6GHZ_FREQ(freq) && reg_is_freq_indoor(pdev, freq));
2752 }
2753 
2754 /**
2755  * reg_get_max_psd() - Get max PSD.
2756  * @freq: Channel frequency.
2757  * @bw: Channel bandwidth.
2758  * @reg_ap: Regulatory 6G AP type.
2759  * @reg_client: Regulatory 6G client type.
2760  * @tx_power: Pointer to tx-power.
2761  *
2762  * Return: Return QDF_STATUS_SUCCESS, if PSD is filled for 6G TPE IE
2763  * else return QDF_STATUS_E_FAILURE.
2764  */
2765 static QDF_STATUS reg_get_max_psd(qdf_freq_t freq,
2766 				  uint16_t bw,
2767 				  enum reg_6g_ap_type reg_ap,
2768 				  enum reg_6g_client_type reg_client,
2769 				  uint8_t *tx_power)
2770 {
2771 	if (reg_ap == REG_INDOOR_AP ||
2772 	    reg_ap == REG_VERY_LOW_POWER_AP) {
2773 		switch (reg_client) {
2774 		case REG_DEFAULT_CLIENT:
2775 			*tx_power = REG_PSD_MAX_TXPOWER_FOR_DEFAULT_CLIENT;
2776 			return QDF_STATUS_SUCCESS;
2777 		case REG_SUBORDINATE_CLIENT:
2778 			*tx_power = REG_PSD_MAX_TXPOWER_FOR_SUBORDINATE_CLIENT;
2779 			return QDF_STATUS_SUCCESS;
2780 		default:
2781 			reg_err_rl("Invalid client type");
2782 			return QDF_STATUS_E_FAILURE;
2783 		}
2784 	}
2785 
2786 	return QDF_STATUS_E_FAILURE;
2787 }
2788 
2789 /**
2790  * reg_get_max_eirp() - Get max EIRP.
2791  * @pdev: Pointer to pdev.
2792  * @freq: Channel frequency.
2793  * @bw: Channel bandwidth.
2794  * @reg_ap: Regulatory 6G AP type.
2795  * @reg_client: Regulatory client type.
2796  * @tx_power: Pointer to tx-power.
2797  *
2798  * Return: Return QDF_STATUS_SUCCESS, if EIRP is filled for 6G TPE IE
2799  * else return QDF_STATUS_E_FAILURE.
2800  */
2801 static QDF_STATUS reg_get_max_eirp(struct wlan_objmgr_pdev *pdev,
2802 				   qdf_freq_t freq,
2803 				   uint16_t bw,
2804 				   enum reg_6g_ap_type reg_ap,
2805 				   enum reg_6g_client_type reg_client,
2806 				   uint8_t *tx_power)
2807 {
2808 	if (reg_ap == REG_INDOOR_AP ||
2809 	    reg_ap == REG_VERY_LOW_POWER_AP) {
2810 		switch (reg_client) {
2811 		case REG_DEFAULT_CLIENT:
2812 			*tx_power = reg_get_channel_reg_power_for_freq(pdev,
2813 								       freq);
2814 			return QDF_STATUS_SUCCESS;
2815 		case REG_SUBORDINATE_CLIENT:
2816 			*tx_power = REG_EIRP_MAX_TXPOWER_FOR_SUBORDINATE_CLIENT;
2817 			return QDF_STATUS_SUCCESS;
2818 		default:
2819 			reg_err_rl("Invalid client type");
2820 			return QDF_STATUS_E_FAILURE;
2821 		}
2822 	}
2823 
2824 	return QDF_STATUS_E_FAILURE;
2825 }
2826 
2827 QDF_STATUS reg_get_max_txpower_for_6g_tpe(struct wlan_objmgr_pdev *pdev,
2828 					  qdf_freq_t freq, uint8_t bw,
2829 					  enum reg_6g_ap_type reg_ap,
2830 					  enum reg_6g_client_type reg_client,
2831 					  bool is_psd,
2832 					  uint8_t *tx_power)
2833 {
2834 	if (!REG_IS_6GHZ_FREQ(freq)) {
2835 		reg_err_rl("%d is not a 6G channel frequency", freq);
2836 		return QDF_STATUS_E_FAILURE;
2837 	}
2838 
2839 	/*
2840 	 * For now, there is support only for Indoor AP and we have only
2841 	 * LPI power values.
2842 	 */
2843 	if (is_psd)
2844 		return reg_get_max_psd(freq, bw, reg_ap, reg_client, tx_power);
2845 
2846 	return reg_get_max_eirp(pdev, freq, bw, reg_ap, reg_client, tx_power);
2847 }
2848 
2849 #define MIN_UNII_5_BAND_CHANNEL 5935
2850 #define MAX_UNII_5_BAND_CHANNEL 6415
2851 bool reg_is_6ghz_unii5_chan_freq(qdf_freq_t freq)
2852 {
2853 	if (!REG_IS_6GHZ_FREQ(freq))
2854 		return false;
2855 
2856 	if (freq >= MIN_UNII_5_BAND_CHANNEL && freq <= MAX_UNII_5_BAND_CHANNEL)
2857 		return true;
2858 
2859 	return false;
2860 }
2861 
2862 /**
2863  * BAND_6G_PRESENT() - Check if REG_BAND_6G is set in the band_mask
2864  * @band_mask: Bitmask for bands
2865  *
2866  * Return: True if REG_BAND_6G is set in the band_mask, else false
2867  */
2868 static inline bool BAND_6G_PRESENT(uint8_t band_mask)
2869 {
2870 	return !!(band_mask & (BIT(REG_BAND_6G)));
2871 }
2872 #else
2873 static inline bool BAND_6G_PRESENT(uint8_t band_mask)
2874 {
2875 	return false;
2876 }
2877 #endif /* CONFIG_BAND_6GHZ */
2878 
2879 /**
2880  * reg_get_band_from_cur_chan_list() - Get channel list and number of channels
2881  * @pdev: pdev ptr
2882  * @band_mask: Input bitmap with band set
2883  * @channel_list: Pointer to Channel List
2884  * @cur_chan_list: Pointer to primary current channel list for non-beaconing
2885  * entities (STA, p2p client) and secondary channel list for beaconing entities
2886  * (SAP, p2p GO)
2887  *
2888  * Get the given channel list and number of channels from the current channel
2889  * list based on input band bitmap.
2890  *
2891  * Return: Number of channels, else 0 to indicate error
2892  */
2893 static uint16_t
2894 reg_get_band_from_cur_chan_list(struct wlan_objmgr_pdev *pdev,
2895 				uint8_t band_mask,
2896 				struct regulatory_channel *channel_list,
2897 				struct regulatory_channel *cur_chan_list)
2898 {
2899 	uint16_t i, num_channels = 0;
2900 
2901 	if (BAND_2G_PRESENT(band_mask)) {
2902 		for (i = MIN_24GHZ_CHANNEL; i <= MAX_24GHZ_CHANNEL; i++) {
2903 			if ((cur_chan_list[i].state != CHANNEL_STATE_DISABLE) &&
2904 			    !(cur_chan_list[i].chan_flags &
2905 			      REGULATORY_CHAN_DISABLED)) {
2906 				channel_list[num_channels] = cur_chan_list[i];
2907 				num_channels++;
2908 			}
2909 		}
2910 	}
2911 	if (BAND_5G_PRESENT(band_mask)) {
2912 		for (i = BAND_5GHZ_START_CHANNEL; i <= MAX_5GHZ_CHANNEL; i++) {
2913 			if ((cur_chan_list[i].state != CHANNEL_STATE_DISABLE) &&
2914 			    !(cur_chan_list[i].chan_flags &
2915 			      REGULATORY_CHAN_DISABLED)) {
2916 				channel_list[num_channels] = cur_chan_list[i];
2917 				num_channels++;
2918 			}
2919 		}
2920 	}
2921 	if (BAND_6G_PRESENT(band_mask)) {
2922 		for (i = MIN_6GHZ_CHANNEL; i <= MAX_6GHZ_CHANNEL; i++) {
2923 			if ((cur_chan_list[i].state != CHANNEL_STATE_DISABLE) &&
2924 			    !(cur_chan_list[i].chan_flags &
2925 			      REGULATORY_CHAN_DISABLED)) {
2926 				channel_list[num_channels] = cur_chan_list[i];
2927 				num_channels++;
2928 			}
2929 		}
2930 	}
2931 
2932 	if (!num_channels) {
2933 		reg_err("Failed to retrieve the channel list");
2934 		return 0;
2935 	}
2936 
2937 	return num_channels;
2938 }
2939 
2940 uint16_t
2941 reg_get_band_channel_list(struct wlan_objmgr_pdev *pdev,
2942 			  uint8_t band_mask,
2943 			  struct regulatory_channel *channel_list)
2944 {
2945 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
2946 
2947 	pdev_priv_obj = reg_get_pdev_obj(pdev);
2948 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
2949 		reg_err("reg pdev priv obj is NULL");
2950 		return 0;
2951 	}
2952 
2953 	return reg_get_band_from_cur_chan_list(pdev, band_mask, channel_list,
2954 					       pdev_priv_obj->cur_chan_list);
2955 }
2956 
2957 #ifdef CONFIG_REG_6G_PWRMODE
2958 uint16_t
2959 reg_get_band_channel_list_for_pwrmode(struct wlan_objmgr_pdev *pdev,
2960 				      uint8_t band_mask,
2961 				      struct regulatory_channel *channel_list,
2962 				      enum supported_6g_pwr_types
2963 				      in_6g_pwr_mode)
2964 {
2965 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
2966 	struct regulatory_channel *reg_chan_list;
2967 	uint16_t nchan = 0;
2968 
2969 	reg_chan_list = qdf_mem_malloc(NUM_CHANNELS * sizeof(*reg_chan_list));
2970 
2971 	if (!reg_chan_list)
2972 		return 0;
2973 
2974 	pdev_priv_obj = reg_get_pdev_obj(pdev);
2975 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
2976 		reg_err("reg pdev priv obj is NULL");
2977 		goto err;
2978 	}
2979 
2980 	if (reg_get_pwrmode_chan_list(pdev, reg_chan_list, in_6g_pwr_mode)) {
2981 		reg_debug_rl("Unable to get powermode channel list");
2982 		goto err;
2983 	}
2984 
2985 	nchan = reg_get_band_from_cur_chan_list(pdev, band_mask, channel_list,
2986 						reg_chan_list);
2987 err:
2988 	qdf_mem_free(reg_chan_list);
2989 	return nchan;
2990 }
2991 #endif
2992 
2993 #ifdef CONFIG_REG_CLIENT
2994 uint16_t
2995 reg_get_secondary_band_channel_list(struct wlan_objmgr_pdev *pdev,
2996 				    uint8_t band_mask,
2997 				    struct regulatory_channel *channel_list)
2998 {
2999 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
3000 
3001 	pdev_priv_obj = reg_get_pdev_obj(pdev);
3002 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
3003 		reg_err("reg pdev priv obj is NULL");
3004 		return 0;
3005 	}
3006 
3007 	return reg_get_band_from_cur_chan_list(
3008 				pdev, band_mask, channel_list,
3009 				pdev_priv_obj->secondary_cur_chan_list);
3010 }
3011 #endif
3012 
3013 qdf_freq_t reg_chan_band_to_freq(struct wlan_objmgr_pdev *pdev,
3014 				 uint8_t chan_num,
3015 				 uint8_t band_mask)
3016 {
3017 	enum channel_enum min_chan, max_chan;
3018 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
3019 	uint16_t freq;
3020 
3021 	if (chan_num == 0) {
3022 		reg_debug_rl("Invalid channel %d", chan_num);
3023 		return 0;
3024 	}
3025 
3026 	pdev_priv_obj = reg_get_pdev_obj(pdev);
3027 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
3028 		reg_err("reg pdev priv obj is NULL");
3029 		return 0;
3030 	}
3031 
3032 	if (BAND_6G_PRESENT(band_mask)) {
3033 		if (BAND_2G_PRESENT(band_mask) ||
3034 		    BAND_5G_PRESENT(band_mask)) {
3035 			reg_err_rl("Incorrect band_mask %x", band_mask);
3036 				return 0;
3037 		}
3038 
3039 		/* Handle 6G channel 2 as a special case as it does not follow
3040 		 * the regular increasing order of channel numbers
3041 		 */
3042 		if (chan_num == SIXG_CHAN_2) {
3043 			struct regulatory_channel *mas_chan_list;
3044 
3045 			mas_chan_list = pdev_priv_obj->mas_chan_list;
3046 			/* Check if chan 2 is in the master list */
3047 			if ((mas_chan_list[CHAN_ENUM_SIXG_2].state !=
3048 			     CHANNEL_STATE_DISABLE) &&
3049 			    !(mas_chan_list[CHAN_ENUM_SIXG_2].chan_flags &
3050 			     REGULATORY_CHAN_DISABLED))
3051 				return mas_chan_list[CHAN_ENUM_SIXG_2].
3052 								center_freq;
3053 			else
3054 				return 0;
3055 		}
3056 
3057 		/* MIN_6GHZ_CHANNEL corresponds to CHAN_ENUM_5935
3058 		 * ( a.k.a SIXG_CHAN_2). Skip it from the search space
3059 		 */
3060 		min_chan = MIN_6GHZ_CHANNEL + 1;
3061 		max_chan = MAX_6GHZ_CHANNEL;
3062 		return reg_compute_chan_to_freq(pdev, chan_num,
3063 						min_chan,
3064 						max_chan);
3065 	} else {
3066 		if (BAND_2G_PRESENT(band_mask)) {
3067 			min_chan = MIN_24GHZ_CHANNEL;
3068 			max_chan = MAX_24GHZ_CHANNEL;
3069 			freq = reg_compute_chan_to_freq(pdev, chan_num,
3070 							min_chan,
3071 							max_chan);
3072 			if (freq != 0)
3073 				return freq;
3074 		}
3075 
3076 		if (BAND_5G_PRESENT(band_mask)) {
3077 			min_chan = BAND_5GHZ_START_CHANNEL;
3078 			max_chan = MAX_5GHZ_CHANNEL;
3079 
3080 			return reg_compute_chan_to_freq(pdev, chan_num,
3081 							min_chan,
3082 							max_chan);
3083 		}
3084 
3085 		reg_err_rl("Incorrect band_mask %x", band_mask);
3086 		return 0;
3087 	}
3088 }
3089 
3090 #ifdef CONFIG_49GHZ_CHAN
3091 bool reg_is_49ghz_freq(qdf_freq_t freq)
3092 {
3093 	return REG_IS_49GHZ_FREQ(freq);
3094 }
3095 #endif /* CONFIG_49GHZ_CHAN */
3096 
3097 qdf_freq_t reg_ch_num(uint32_t ch_enum)
3098 {
3099 	return REG_CH_NUM(ch_enum);
3100 }
3101 
3102 qdf_freq_t reg_ch_to_freq(uint32_t ch_enum)
3103 {
3104 	return REG_CH_TO_FREQ(ch_enum);
3105 }
3106 
3107 uint8_t reg_max_5ghz_ch_num(void)
3108 {
3109 	return g_reg_max_5g_chan_num;
3110 }
3111 
3112 #ifdef CONFIG_CHAN_FREQ_API
3113 qdf_freq_t reg_min_24ghz_chan_freq(void)
3114 {
3115 	return REG_MIN_24GHZ_CH_FREQ;
3116 }
3117 
3118 qdf_freq_t reg_max_24ghz_chan_freq(void)
3119 {
3120 	return REG_MAX_24GHZ_CH_FREQ;
3121 }
3122 
3123 qdf_freq_t reg_min_5ghz_chan_freq(void)
3124 {
3125 	return REG_MIN_5GHZ_CH_FREQ;
3126 }
3127 
3128 qdf_freq_t reg_max_5ghz_chan_freq(void)
3129 {
3130 	return REG_MAX_5GHZ_CH_FREQ;
3131 }
3132 #endif /* CONFIG_CHAN_FREQ_API */
3133 
3134 QDF_STATUS reg_enable_dfs_channels(struct wlan_objmgr_pdev *pdev,
3135 				   bool enable)
3136 {
3137 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
3138 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
3139 	struct wlan_objmgr_psoc *psoc;
3140 	QDF_STATUS status;
3141 	struct wlan_lmac_if_reg_tx_ops *reg_tx_ops;
3142 
3143 	pdev_priv_obj = reg_get_pdev_obj(pdev);
3144 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
3145 		reg_err("pdev reg component is NULL");
3146 		return QDF_STATUS_E_INVAL;
3147 	}
3148 
3149 	if (pdev_priv_obj->dfs_enabled == enable) {
3150 		reg_info("dfs_enabled is already set to %d", enable);
3151 		return QDF_STATUS_SUCCESS;
3152 	}
3153 
3154 	psoc = wlan_pdev_get_psoc(pdev);
3155 	if (!psoc) {
3156 		reg_err("psoc is NULL");
3157 		return QDF_STATUS_E_INVAL;
3158 	}
3159 
3160 	psoc_priv_obj = reg_get_psoc_obj(psoc);
3161 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
3162 		reg_err("psoc reg component is NULL");
3163 		return QDF_STATUS_E_INVAL;
3164 	}
3165 
3166 	reg_info("set dfs_enabled: %d", enable);
3167 
3168 	pdev_priv_obj->dfs_enabled = enable;
3169 
3170 	reg_compute_pdev_current_chan_list(pdev_priv_obj);
3171 
3172 	reg_tx_ops = reg_get_psoc_tx_ops(psoc);
3173 
3174 	/* Fill the ic channel list with the updated current channel
3175 	 * chan list.
3176 	 */
3177 	if (reg_tx_ops->fill_umac_legacy_chanlist)
3178 		reg_tx_ops->fill_umac_legacy_chanlist(pdev,
3179 				pdev_priv_obj->cur_chan_list);
3180 
3181 	status = reg_send_scheduler_msg_sb(psoc, pdev);
3182 
3183 	return status;
3184 }
3185 
3186 #ifdef WLAN_REG_PARTIAL_OFFLOAD
3187 bool reg_is_regdmn_en302502_applicable(struct wlan_objmgr_pdev *pdev)
3188 {
3189 	struct cur_regdmn_info cur_reg_dmn;
3190 	QDF_STATUS status;
3191 
3192 	status = reg_get_curr_regdomain(pdev, &cur_reg_dmn);
3193 	if (status != QDF_STATUS_SUCCESS) {
3194 		reg_err("Failed to get reg domain");
3195 		return false;
3196 	}
3197 
3198 	return reg_en302_502_regdmn(cur_reg_dmn.regdmn_pair_id);
3199 }
3200 #endif
3201 
3202 QDF_STATUS reg_get_phybitmap(struct wlan_objmgr_pdev *pdev,
3203 			     uint16_t *phybitmap)
3204 {
3205 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
3206 
3207 	pdev_priv_obj = reg_get_pdev_obj(pdev);
3208 
3209 	if (!pdev_priv_obj) {
3210 		reg_err("reg pdev private obj is NULL");
3211 		return QDF_STATUS_E_FAULT;
3212 	}
3213 
3214 	*phybitmap = pdev_priv_obj->phybitmap;
3215 
3216 	return QDF_STATUS_SUCCESS;
3217 }
3218 
3219 QDF_STATUS reg_update_channel_ranges(struct wlan_objmgr_pdev *pdev)
3220 {
3221 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
3222 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
3223 	struct wlan_objmgr_psoc *psoc;
3224 	struct wlan_lmac_if_reg_tx_ops *reg_tx_ops;
3225 	struct wlan_psoc_host_hal_reg_capabilities_ext *reg_cap_ptr;
3226 	uint32_t cnt;
3227 	uint8_t phy_id;
3228 	uint8_t pdev_id;
3229 	QDF_STATUS status = QDF_STATUS_SUCCESS;
3230 
3231 	pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev);
3232 
3233 	pdev_priv_obj = reg_get_pdev_obj(pdev);
3234 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
3235 		reg_err("pdev reg component is NULL");
3236 		return QDF_STATUS_E_INVAL;
3237 	}
3238 
3239 	psoc = wlan_pdev_get_psoc(pdev);
3240 	if (!psoc) {
3241 		reg_err("psoc is NULL");
3242 		return QDF_STATUS_E_INVAL;
3243 	}
3244 
3245 	reg_tx_ops = reg_get_psoc_tx_ops(psoc);
3246 	if (reg_tx_ops->get_phy_id_from_pdev_id)
3247 		reg_tx_ops->get_phy_id_from_pdev_id(psoc, pdev_id, &phy_id);
3248 	else
3249 		phy_id = pdev_id;
3250 
3251 	psoc_priv_obj = reg_get_psoc_obj(psoc);
3252 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
3253 		reg_err("psoc reg component is NULL");
3254 		return QDF_STATUS_E_INVAL;
3255 	}
3256 
3257 	reg_cap_ptr = psoc_priv_obj->reg_cap;
3258 
3259 	for (cnt = 0; cnt < PSOC_MAX_PHY_REG_CAP; cnt++) {
3260 		if (!reg_cap_ptr) {
3261 			qdf_mem_free(pdev_priv_obj);
3262 			reg_err("reg cap ptr is NULL");
3263 			return QDF_STATUS_E_FAULT;
3264 		}
3265 
3266 		if (reg_cap_ptr->phy_id == phy_id)
3267 			break;
3268 		reg_cap_ptr++;
3269 	}
3270 
3271 	if (cnt == PSOC_MAX_PHY_REG_CAP) {
3272 		qdf_mem_free(pdev_priv_obj);
3273 		reg_err("extended capabilities not found for pdev");
3274 		return QDF_STATUS_E_FAULT;
3275 	}
3276 	pdev_priv_obj->range_2g_low = reg_cap_ptr->low_2ghz_chan;
3277 	pdev_priv_obj->range_2g_high = reg_cap_ptr->high_2ghz_chan;
3278 	pdev_priv_obj->range_5g_low = reg_cap_ptr->low_5ghz_chan;
3279 	pdev_priv_obj->range_5g_high = reg_cap_ptr->high_5ghz_chan;
3280 	pdev_priv_obj->wireless_modes = reg_cap_ptr->wireless_modes;
3281 
3282 	return status;
3283 }
3284 
3285 QDF_STATUS reg_modify_pdev_chan_range(struct wlan_objmgr_pdev *pdev)
3286 {
3287 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
3288 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
3289 	struct wlan_objmgr_psoc *psoc;
3290 	struct wlan_lmac_if_reg_tx_ops *reg_tx_ops;
3291 	enum direction dir;
3292 	QDF_STATUS status;
3293 
3294 	status = reg_update_channel_ranges(pdev);
3295 	if (status != QDF_STATUS_SUCCESS)
3296 		return status;
3297 
3298 	pdev_priv_obj = reg_get_pdev_obj(pdev);
3299 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
3300 		reg_err("pdev reg component is NULL");
3301 		return QDF_STATUS_E_INVAL;
3302 	}
3303 
3304 	psoc = wlan_pdev_get_psoc(pdev);
3305 	if (!psoc) {
3306 		reg_err("psoc is NULL");
3307 		return QDF_STATUS_E_INVAL;
3308 	}
3309 
3310 	psoc_priv_obj = reg_get_psoc_obj(psoc);
3311 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
3312 		reg_err("psoc reg component is NULL");
3313 		return QDF_STATUS_E_INVAL;
3314 	}
3315 
3316 	if (psoc_priv_obj->offload_enabled) {
3317 		dir = NORTHBOUND;
3318 	} else {
3319 		dir = SOUTHBOUND;
3320 	}
3321 
3322 	reg_compute_pdev_current_chan_list(pdev_priv_obj);
3323 
3324 	reg_tx_ops = reg_get_psoc_tx_ops(psoc);
3325 
3326 	/* Fill the ic channel list with the updated current channel
3327 	 * chan list.
3328 	 */
3329 	if (reg_tx_ops->fill_umac_legacy_chanlist) {
3330 	    reg_tx_ops->fill_umac_legacy_chanlist(pdev,
3331 						  pdev_priv_obj->cur_chan_list);
3332 
3333 	} else {
3334 		if (dir == NORTHBOUND)
3335 			status = reg_send_scheduler_msg_nb(psoc, pdev);
3336 		else
3337 			status = reg_send_scheduler_msg_sb(psoc, pdev);
3338 	}
3339 
3340 	return status;
3341 }
3342 
3343 QDF_STATUS reg_update_pdev_wireless_modes(struct wlan_objmgr_pdev *pdev,
3344 					  uint64_t wireless_modes)
3345 {
3346 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
3347 
3348 	pdev_priv_obj = wlan_objmgr_pdev_get_comp_private_obj(pdev,
3349 							      WLAN_UMAC_COMP_REGULATORY);
3350 
3351 	if (!pdev_priv_obj) {
3352 		reg_err("reg pdev private obj is NULL");
3353 		return QDF_STATUS_E_INVAL;
3354 	}
3355 
3356 	pdev_priv_obj->wireless_modes = wireless_modes;
3357 
3358 	return QDF_STATUS_SUCCESS;
3359 }
3360 
3361 #ifdef DISABLE_UNII_SHARED_BANDS
3362 /**
3363  * reg_is_reg_unii_band_1_or_reg_unii_band_2a() - Check the input bitmap
3364  * @unii_5g_bitmap: 5G UNII band bitmap
3365  *
3366  * This function checks if either REG_UNII_BAND_1 or REG_UNII_BAND_2A,
3367  * are present in the 5G UNII band bitmap.
3368  *
3369  * Return: Return true if REG_UNII_BAND_1 or REG_UNII_BAND_2A, are present in
3370  * the UNII 5g bitmap else return false.
3371  */
3372 static bool
3373 reg_is_reg_unii_band_1_or_reg_unii_band_2a(uint8_t unii_5g_bitmap)
3374 {
3375 	if (!unii_5g_bitmap)
3376 		return false;
3377 
3378 	return ((unii_5g_bitmap & (BIT(REG_UNII_BAND_1) |
3379 		 BIT(REG_UNII_BAND_2A))) ==  unii_5g_bitmap);
3380 }
3381 
3382 QDF_STATUS reg_disable_chan_coex(struct wlan_objmgr_pdev *pdev,
3383 				 uint8_t unii_5g_bitmap)
3384 {
3385 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
3386 	struct wlan_lmac_if_reg_tx_ops *reg_tx_ops;
3387 	struct wlan_objmgr_psoc *psoc;
3388 
3389 	psoc = wlan_pdev_get_psoc(pdev);
3390 	if (!psoc) {
3391 		reg_err("psoc is NULL");
3392 		return QDF_STATUS_E_INVAL;
3393 	}
3394 
3395 	pdev_priv_obj = reg_get_pdev_obj(pdev);
3396 
3397 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
3398 		reg_err_rl("reg pdev priv obj is NULL");
3399 		return QDF_STATUS_E_FAILURE;
3400 	}
3401 
3402 	if (unii_5g_bitmap &&
3403 	    !reg_is_reg_unii_band_1_or_reg_unii_band_2a(unii_5g_bitmap)) {
3404 		reg_err_rl("Invalid unii_5g_bitmap =  %d", unii_5g_bitmap);
3405 		return QDF_STATUS_E_FAILURE;
3406 	}
3407 
3408 	if (pdev_priv_obj->unii_5g_bitmap == unii_5g_bitmap) {
3409 		reg_debug_rl("UNII bitmask for 5G channels is already set  %d",
3410 			    unii_5g_bitmap);
3411 		return QDF_STATUS_SUCCESS;
3412 	}
3413 
3414 	reg_debug_rl("Setting UNII bitmask for 5G: %d", unii_5g_bitmap);
3415 	pdev_priv_obj->unii_5g_bitmap = unii_5g_bitmap;
3416 
3417 	reg_compute_pdev_current_chan_list(pdev_priv_obj);
3418 
3419 	reg_tx_ops = reg_get_psoc_tx_ops(psoc);
3420 
3421 	if (reg_tx_ops->fill_umac_legacy_chanlist) {
3422 		reg_tx_ops->fill_umac_legacy_chanlist(pdev,
3423 				pdev_priv_obj->cur_chan_list);
3424 	}
3425 
3426 	return QDF_STATUS_SUCCESS;
3427 }
3428 #endif
3429 
3430 bool reg_is_chan_disabled(uint32_t chan_flags, enum channel_state chan_state)
3431 {
3432 	return (REGULATORY_CHAN_DISABLED & chan_flags ||
3433 		chan_state == CHANNEL_STATE_DISABLE);
3434 }
3435 
3436 #ifdef CONFIG_REG_CLIENT
3437 #ifdef CONFIG_BAND_6GHZ
3438 static void reg_append_6g_channel_list_with_power(
3439 			struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj,
3440 			struct channel_power *ch_list,
3441 			uint8_t *count,
3442 			enum supported_6g_pwr_types in_6g_pwr_type)
3443 {
3444 	struct super_chan_info *sc_entry;
3445 	enum supported_6g_pwr_types pwr_type;
3446 	uint8_t i, count_6g = *count;
3447 
3448 	pwr_type = in_6g_pwr_type;
3449 	for (i = 0; i < NUM_6GHZ_CHANNELS; i++) {
3450 		sc_entry = &pdev_priv_obj->super_chan_list[i];
3451 
3452 		if (in_6g_pwr_type == REG_BEST_PWR_MODE)
3453 			pwr_type = sc_entry->best_power_mode;
3454 
3455 		if (reg_is_supp_pwr_mode_invalid(pwr_type))
3456 			continue;
3457 
3458 		if (!reg_is_chan_disabled(sc_entry->chan_flags_arr[pwr_type],
3459 					  sc_entry->state_arr[pwr_type])) {
3460 			ch_list[count_6g].center_freq =
3461 					reg_ch_to_freq(i + MIN_6GHZ_CHANNEL);
3462 			ch_list[count_6g].chan_num =
3463 					reg_ch_num(i + MIN_6GHZ_CHANNEL);
3464 			ch_list[count_6g++].tx_power =
3465 				sc_entry->reg_chan_pwr[pwr_type].tx_power;
3466 		}
3467 	}
3468 	*count = count_6g;
3469 }
3470 #else
3471 static inline void reg_append_6g_channel_list_with_power(
3472 			struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj,
3473 			struct channel_power *ch_list,
3474 			uint8_t *count,
3475 			enum supported_6g_pwr_types in_6g_pwr_type)
3476 {
3477 }
3478 #endif
3479 
3480 QDF_STATUS reg_get_channel_list_with_power(
3481 				struct wlan_objmgr_pdev *pdev,
3482 				struct channel_power *ch_list,
3483 				uint8_t *num_chan,
3484 				enum supported_6g_pwr_types in_6g_pwr_type)
3485 {
3486 	uint8_t i, count;
3487 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
3488 	uint8_t max_curr_num_chan;
3489 
3490 	if (!pdev) {
3491 		reg_err_rl("invalid pdev");
3492 		return QDF_STATUS_E_INVAL;
3493 	}
3494 
3495 	pdev_priv_obj = reg_get_pdev_obj(pdev);
3496 
3497 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
3498 		reg_err_rl("reg pdev priv obj is NULL");
3499 		return QDF_STATUS_E_INVAL;
3500 	}
3501 
3502 	if (!num_chan || !ch_list) {
3503 		reg_err("chan_list or num_ch is NULL");
3504 		return QDF_STATUS_E_FAILURE;
3505 	}
3506 
3507 	*num_chan = 0;
3508 
3509 	if (in_6g_pwr_type == REG_CURRENT_PWR_MODE)
3510 		max_curr_num_chan = NUM_CHANNELS;
3511 	else
3512 		max_curr_num_chan = MAX_5GHZ_CHANNEL;
3513 
3514 	for (i = 0, count = 0; i < max_curr_num_chan; i++) {
3515 		if (!reg_is_chan_disabled(
3516 				pdev_priv_obj->cur_chan_list[i].chan_flags,
3517 				pdev_priv_obj->cur_chan_list[i].state)) {
3518 			ch_list[count].center_freq =
3519 				pdev_priv_obj->cur_chan_list[i].center_freq;
3520 			ch_list[count].chan_num =
3521 				pdev_priv_obj->cur_chan_list[i].chan_num;
3522 			ch_list[count++].tx_power =
3523 				pdev_priv_obj->cur_chan_list[i].tx_power;
3524 		}
3525 	}
3526 
3527 	if (in_6g_pwr_type == REG_CURRENT_PWR_MODE) {
3528 		*num_chan = count;
3529 		return QDF_STATUS_SUCCESS;
3530 	}
3531 
3532 	reg_append_6g_channel_list_with_power(pdev_priv_obj, ch_list, &count,
3533 					      in_6g_pwr_type);
3534 	*num_chan = count;
3535 
3536 	return QDF_STATUS_SUCCESS;
3537 }
3538 #endif
3539 
3540 #ifdef CONFIG_CHAN_FREQ_API
3541 QDF_STATUS reg_get_channel_list_with_power_for_freq(struct wlan_objmgr_pdev
3542 						    *pdev,
3543 						    struct channel_power
3544 						    *ch_list,
3545 						    uint8_t *num_chan)
3546 {
3547 	int i, count;
3548 	struct regulatory_channel *reg_channels;
3549 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
3550 
3551 	if (!num_chan || !ch_list) {
3552 		reg_err("chan_list or num_ch is NULL");
3553 		return QDF_STATUS_E_FAILURE;
3554 	}
3555 
3556 	pdev_priv_obj = reg_get_pdev_obj(pdev);
3557 
3558 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
3559 		reg_err("reg pdev priv obj is NULL");
3560 		return QDF_STATUS_E_FAILURE;
3561 	}
3562 
3563 	/* set the current channel list */
3564 	reg_channels = pdev_priv_obj->cur_chan_list;
3565 
3566 	for (i = 0, count = 0; i < NUM_CHANNELS; i++) {
3567 		if (reg_channels[i].state &&
3568 		    !(reg_channels[i].chan_flags & REGULATORY_CHAN_DISABLED)) {
3569 			ch_list[count].center_freq =
3570 				reg_channels[i].center_freq;
3571 			ch_list[count].chan_num = reg_channels[i].chan_num;
3572 			ch_list[count++].tx_power =
3573 				reg_channels[i].tx_power;
3574 		}
3575 	}
3576 
3577 	*num_chan = count;
3578 
3579 	return QDF_STATUS_SUCCESS;
3580 }
3581 
3582 enum channel_enum reg_get_chan_enum_for_freq(qdf_freq_t freq)
3583 {
3584 	int16_t start = 0;
3585 	int16_t end = NUM_CHANNELS - 1;
3586 
3587 	while (start <= end) {
3588 		int16_t middle = (start + end) / 2;
3589 		qdf_freq_t mid_freq_elem = channel_map[middle].center_freq;
3590 
3591 		if (freq == mid_freq_elem)
3592 			return middle;
3593 		if (freq > mid_freq_elem)
3594 			start = middle + 1;
3595 		else
3596 			end = middle - 1;
3597 	}
3598 
3599 	reg_debug_rl("invalid channel center frequency %d", freq);
3600 
3601 	return INVALID_CHANNEL;
3602 }
3603 
3604 bool
3605 reg_is_freq_present_in_cur_chan_list(struct wlan_objmgr_pdev *pdev,
3606 				     qdf_freq_t freq)
3607 {
3608 	enum channel_enum chan_enum;
3609 	struct regulatory_channel *cur_chan_list;
3610 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
3611 
3612 	pdev_priv_obj = reg_get_pdev_obj(pdev);
3613 
3614 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
3615 		reg_err_rl("pdev reg obj is NULL");
3616 		return false;
3617 	}
3618 
3619 	cur_chan_list = pdev_priv_obj->cur_chan_list;
3620 
3621 	for (chan_enum = 0; chan_enum < NUM_CHANNELS; chan_enum++)
3622 		if (cur_chan_list[chan_enum].center_freq == freq)
3623 			if ((cur_chan_list[chan_enum].state !=
3624 			     CHANNEL_STATE_DISABLE) &&
3625 			    !(cur_chan_list[chan_enum].chan_flags &
3626 			      REGULATORY_CHAN_DISABLED))
3627 				return true;
3628 
3629 	reg_debug_rl("Channel center frequency %d not found", freq);
3630 
3631 	return false;
3632 }
3633 
3634 #ifdef WLAN_FEATURE_GET_USABLE_CHAN_LIST
3635 /**
3636  * is_freq_present_in_resp_list() - is freq present in resp list
3637  *
3638  * @pcl_ch: pcl ch
3639  * @res_msg: Response msg
3640  * @count: no of usable channels
3641  *
3642  * Return: void
3643  */
3644 static bool
3645 is_freq_present_in_resp_list(uint32_t pcl_ch,
3646 			     struct get_usable_chan_res_params *res_msg,
3647 			     int count)
3648 {
3649 	int i;
3650 
3651 	for (i = 0; i < count; i++) {
3652 		if (res_msg[i].freq == pcl_ch)
3653 			return true;
3654 	}
3655 	return false;
3656 }
3657 
3658 /**
3659  * reg_update_usable_chan_resp() - Update response msg
3660  * @pdev: Pointer to pdev
3661  * @res_msg: Response msg
3662  * @pcl_ch: pcl channel
3663  * @len: calculated pcl len
3664  * @iface_mode_mask: interface type
3665  * @band_mask: requested band mask
3666  * @count: no of usable channels
3667  * @in_6g_pwr_mode: Input 6GHz power mode
3668  *
3669  * Return: void
3670  */
3671 static void
3672 reg_update_usable_chan_resp(struct wlan_objmgr_pdev *pdev,
3673 			    struct get_usable_chan_res_params *res_msg,
3674 			    uint32_t *pcl_ch, uint32_t len,
3675 			    uint32_t iface_mode_mask,
3676 			    uint32_t band_mask, int *count,
3677 			    enum supported_6g_pwr_types in_6g_pwr_mode)
3678 {
3679 	int i;
3680 	struct ch_params ch_params = {0};
3681 	int index = *count;
3682 
3683 	for (i = 0; i < len && index < NUM_CHANNELS; i++) {
3684 		/* In case usable channels are required for multiple filter
3685 		 * mask, Some frequencies may present in res_msg . To avoid
3686 		 * frequency duplication, only mode mask is updated for
3687 		 * existing frequency.
3688 		 */
3689 		if (is_freq_present_in_resp_list(pcl_ch[i], res_msg, *count))
3690 			continue;
3691 
3692 		if (!(band_mask & 1 << wlan_reg_freq_to_band(pcl_ch[i])))
3693 			continue;
3694 
3695 		ch_params.ch_width = CH_WIDTH_MAX;
3696 		reg_set_channel_params_for_pwrmode(
3697 				pdev,
3698 				pcl_ch[i],
3699 				0, &ch_params, in_6g_pwr_mode, true);
3700 		res_msg[index].freq = (qdf_freq_t)pcl_ch[i];
3701 		res_msg[index].iface_mode_mask |= 1 << iface_mode_mask;
3702 		res_msg[index].bw = ch_params.ch_width;
3703 		if (ch_params.center_freq_seg0)
3704 			res_msg[index].seg0_freq =
3705 					ch_params.center_freq_seg0;
3706 		if (ch_params.center_freq_seg1)
3707 			res_msg[index].seg1_freq =
3708 					ch_params.center_freq_seg1;
3709 		index++;
3710 	}
3711 
3712 	*count = index;
3713 }
3714 
3715 /**
3716  * reg_update_conn_chan_list() - Get usable channels with conn filter
3717  *				 and policy mgr mask
3718  * @pdev: Pointer to pdev
3719  * @res_msg: Response msg
3720  * @mode: policy mgr mode
3721  * @iftype: interface type
3722  * @band_mask: requested band mask
3723  * @count: no of usable channels
3724  * @in_6g_pwr_mode: Input 6GHz power mode
3725  *
3726  * Return: qdf status
3727  */
3728 static QDF_STATUS
3729 reg_update_conn_chan_list(struct wlan_objmgr_pdev *pdev,
3730 			  struct get_usable_chan_res_params *res_msg,
3731 			  enum policy_mgr_con_mode mode,
3732 			  uint32_t iftype,
3733 			  uint32_t band_mask,
3734 			  uint32_t *count,
3735 			  enum supported_6g_pwr_types in_6g_pwr_mode)
3736 {
3737 	uint32_t *pcl_ch;
3738 	uint8_t *weight_list;
3739 	uint32_t len;
3740 	uint32_t weight_len;
3741 	struct wlan_objmgr_psoc *psoc;
3742 	QDF_STATUS status = QDF_STATUS_SUCCESS;
3743 
3744 	pcl_ch = qdf_mem_malloc(NUM_CHANNELS *
3745 			sizeof(uint32_t));
3746 
3747 	if (!pcl_ch) {
3748 		reg_err("pcl_ch invalid");
3749 		return QDF_STATUS_E_FAILURE;
3750 	}
3751 
3752 	weight_list = qdf_mem_malloc(NUM_CHANNELS *
3753 			sizeof(uint8_t));
3754 
3755 	if (!weight_list) {
3756 		reg_err("weight_list invalid");
3757 		qdf_mem_free(pcl_ch);
3758 		return QDF_STATUS_E_FAILURE;
3759 	}
3760 
3761 	psoc = wlan_pdev_get_psoc(pdev);
3762 	if (!psoc) {
3763 		reg_err("invalid psoc");
3764 		status = QDF_STATUS_E_FAILURE;
3765 		goto err;
3766 	}
3767 
3768 	len = NUM_CHANNELS;
3769 	weight_len = NUM_CHANNELS;
3770 
3771 	status = policy_mgr_get_pcl(psoc, mode, pcl_ch, &len,
3772 				    weight_list, weight_len,
3773 				    WLAN_INVALID_VDEV_ID);
3774 	if (QDF_IS_STATUS_ERROR(status)) {
3775 		reg_err("get pcl failed for mode: %d", mode);
3776 		goto err;
3777 	}
3778 	reg_update_usable_chan_resp(pdev, res_msg, pcl_ch, len,
3779 				    iftype, band_mask, count,
3780 				    in_6g_pwr_mode);
3781 err:
3782 	qdf_mem_free(pcl_ch);
3783 	qdf_mem_free(weight_list);
3784 	return status;
3785 }
3786 
3787 /**
3788  * reg_get_usable_channel_con_filter() - Get usable channel with con filter mask
3789  * @pdev: Pointer to pdev
3790  * @req_msg: Request msg
3791  * @res_msg: Response msg
3792  * @count: no of usable channels
3793  * @in_6g_pwr_mode: Input 6GHz power mode
3794  *
3795  * Return: qdf status
3796  */
3797 static QDF_STATUS
3798 reg_get_usable_channel_con_filter(struct wlan_objmgr_pdev *pdev,
3799 				  struct get_usable_chan_req_params req_msg,
3800 				  struct get_usable_chan_res_params *res_msg,
3801 				  int *count,
3802 				  enum supported_6g_pwr_types in_6g_pwr_mode)
3803 {
3804 	QDF_STATUS status = QDF_STATUS_SUCCESS;
3805 	uint32_t iface_mode_mask = req_msg.iface_mode_mask;
3806 
3807 	while (iface_mode_mask) {
3808 		if (iface_mode_mask & 1 << IFTYPE_AP) {
3809 			status =
3810 			reg_update_conn_chan_list(pdev, res_msg, PM_SAP_MODE,
3811 						  IFTYPE_AP, req_msg.band_mask,
3812 						  count, in_6g_pwr_mode);
3813 			iface_mode_mask &= ~(1 << IFTYPE_AP);
3814 		} else if (iface_mode_mask & 1 << IFTYPE_STATION) {
3815 			status =
3816 			reg_update_conn_chan_list(pdev, res_msg, PM_STA_MODE,
3817 						  IFTYPE_STATION,
3818 						  req_msg.band_mask, count,
3819 						  in_6g_pwr_mode);
3820 			iface_mode_mask &= ~(1 << IFTYPE_STATION);
3821 		} else if (iface_mode_mask & 1 << IFTYPE_P2P_GO) {
3822 			status =
3823 			reg_update_conn_chan_list(pdev, res_msg, PM_P2P_GO_MODE,
3824 						  IFTYPE_P2P_GO,
3825 						  req_msg.band_mask, count,
3826 						  in_6g_pwr_mode);
3827 			iface_mode_mask &= ~(1 << IFTYPE_P2P_GO);
3828 		} else if (iface_mode_mask & 1 << IFTYPE_P2P_CLIENT) {
3829 			status =
3830 			reg_update_conn_chan_list(pdev, res_msg,
3831 						  PM_P2P_CLIENT_MODE,
3832 						  IFTYPE_P2P_CLIENT,
3833 						  req_msg.band_mask, count,
3834 						  in_6g_pwr_mode);
3835 			iface_mode_mask &= ~(1 << IFTYPE_P2P_CLIENT);
3836 		} else if (iface_mode_mask & 1 << IFTYPE_NAN) {
3837 			status =
3838 			reg_update_conn_chan_list(pdev, res_msg,
3839 						  PM_NAN_DISC_MODE, IFTYPE_NAN,
3840 						  req_msg.band_mask, count,
3841 						  in_6g_pwr_mode);
3842 			iface_mode_mask &= ~(1 << IFTYPE_NAN);
3843 		} else {
3844 			reg_err("invalid mode");
3845 			break;
3846 		}
3847 	}
3848 	return status;
3849 }
3850 
3851 /**
3852  * reg_remove_freq() - Remove invalid freq
3853  * @res_msg: Response msg
3854  * @index: index of freq that needs to be removed
3855  *
3856  * Return: void
3857  */
3858 static void
3859 reg_remove_freq(struct get_usable_chan_res_params *res_msg,
3860 		int index)
3861 {
3862 	reg_debug("removing freq %d", res_msg[index].freq);
3863 	qdf_mem_zero(&res_msg[index],
3864 		     sizeof(struct get_usable_chan_res_params));
3865 }
3866 
3867 /**
3868  * reg_skip_invalid_chan_freq() - Remove invalid freq for SAP, P2P GO
3869  *				  and NAN
3870  * @pdev: Pointer to pdev
3871  * @res_msg: Response msg
3872  * @no_usable_channels: no of usable channels
3873  * @iface_mode_mask: interface mode mask
3874  *
3875  * Return: qdf status
3876  */
3877 static QDF_STATUS
3878 reg_skip_invalid_chan_freq(struct wlan_objmgr_pdev *pdev,
3879 			   struct get_usable_chan_res_params *res_msg,
3880 			   uint32_t *no_usable_channels,
3881 			   uint32_t iface_mode_mask)
3882 {
3883 	uint32_t chan_enum, iface_mode = 0;
3884 	QDF_STATUS status = QDF_STATUS_SUCCESS;
3885 	bool include_indoor_channel, dfs_master_capable;
3886 	uint8_t enable_srd_chan, srd_mask = 0;
3887 	struct wlan_objmgr_psoc *psoc;
3888 	psoc = wlan_pdev_get_psoc(pdev);
3889 	if (!psoc) {
3890 		reg_err("invalid psoc");
3891 		return QDF_STATUS_E_FAILURE;
3892 	}
3893 
3894 	status = ucfg_mlme_get_indoor_channel_support(psoc,
3895 						      &include_indoor_channel);
3896 	if (QDF_IS_STATUS_ERROR(status)) {
3897 		reg_err("failed to get indoor channel skip info");
3898 		return QDF_STATUS_E_FAILURE;
3899 	}
3900 
3901 	ucfg_mlme_get_etsi_srd_chan_in_master_mode(psoc,
3902 						   &enable_srd_chan);
3903 	if (QDF_IS_STATUS_ERROR(status)) {
3904 		reg_err("failed to get srd chan info");
3905 		return QDF_STATUS_E_FAILURE;
3906 	}
3907 
3908 	status = ucfg_mlme_get_dfs_master_capability(psoc, &dfs_master_capable);
3909 	if (QDF_IS_STATUS_ERROR(status)) {
3910 		reg_err("failed to get dfs master capable");
3911 		return status;
3912 	}
3913 
3914 	while (iface_mode_mask) {
3915 		if (iface_mode_mask & (1 << IFTYPE_AP)) {
3916 			srd_mask = 1;
3917 			iface_mode = 1 << IFTYPE_AP;
3918 		} else if (iface_mode_mask & (1 << IFTYPE_P2P_GO)) {
3919 			srd_mask = 2;
3920 			iface_mode = 1 << IFTYPE_P2P_GO;
3921 		} else if (iface_mode_mask & (1 << IFTYPE_NAN)) {
3922 			iface_mode = 1 << IFTYPE_NAN;
3923 		} else {
3924 			break;
3925 		}
3926 		for (chan_enum = 0; chan_enum < *no_usable_channels;
3927 		     chan_enum++) {
3928 			if (iface_mode_mask & (1 << IFTYPE_NAN)) {
3929 				if (!wlan_is_nan_allowed_on_freq(pdev,
3930 				     res_msg[chan_enum].freq))
3931 					res_msg[chan_enum].iface_mode_mask &=
3932 						~(iface_mode);
3933 				if (!res_msg[chan_enum].iface_mode_mask)
3934 					reg_remove_freq(res_msg, chan_enum);
3935 			} else {
3936 				if (wlan_reg_is_freq_indoor(
3937 					pdev, res_msg[chan_enum].freq) &&
3938 					!include_indoor_channel) {
3939 					res_msg[chan_enum].iface_mode_mask &=
3940 							~(iface_mode);
3941 					if (!res_msg[chan_enum].iface_mode_mask)
3942 						reg_remove_freq(res_msg,
3943 								chan_enum);
3944 				}
3945 
3946 				if (!(enable_srd_chan & srd_mask) &&
3947 				    reg_is_etsi_srd_chan_for_freq(
3948 					pdev, res_msg[chan_enum].freq)) {
3949 					res_msg[chan_enum].iface_mode_mask &=
3950 						~(iface_mode);
3951 					if (!res_msg[chan_enum].iface_mode_mask)
3952 						reg_remove_freq(res_msg,
3953 								chan_enum);
3954 				}
3955 
3956 				if (!dfs_master_capable &&
3957 				    wlan_reg_is_dfs_for_freq(pdev,
3958 				    res_msg[chan_enum].freq)) {
3959 					res_msg[chan_enum].iface_mode_mask &=
3960 						~(iface_mode);
3961 					if (!res_msg[chan_enum].iface_mode_mask)
3962 						reg_remove_freq(res_msg,
3963 								chan_enum);
3964 				}
3965 			}
3966 		}
3967 
3968 		iface_mode_mask &= ~iface_mode;
3969 	}
3970 
3971 	return status;
3972 }
3973 
3974 /**
3975  * reg_get_usable_channel_no_filter() - Get usable channel with no filter mask
3976  * @pdev: Pointer to pdev
3977  * @req_msg: Request msg
3978  * @res_msg: Response msg
3979  * @chan_list: reg channel list
3980  * @count: no of usable channels
3981  *
3982  * Return: qdf status
3983  */
3984 static QDF_STATUS
3985 reg_get_usable_channel_no_filter(struct wlan_objmgr_pdev *pdev,
3986 				 struct get_usable_chan_req_params req_msg,
3987 				 struct get_usable_chan_res_params *res_msg,
3988 				 struct regulatory_channel *chan_list,
3989 				 int *count)
3990 {
3991 	QDF_STATUS status = QDF_STATUS_SUCCESS;
3992 
3993 	status =
3994 	reg_skip_invalid_chan_freq(pdev, res_msg,
3995 				   count, req_msg.iface_mode_mask);
3996 	return status;
3997 }
3998 
3999 /**
4000  * reg_get_usable_channel_coex_filter() - Get usable channel with coex filter
4001  * @pdev: Pointer to pdev
4002  * @req_msg: Request msg
4003  * @res_msg: Response msg
4004  * @chan_list: reg channel list
4005  * @count: no of usable channels
4006  *
4007  * Return: qdf status
4008  */
4009 static QDF_STATUS
4010 reg_get_usable_channel_coex_filter(struct wlan_objmgr_pdev *pdev,
4011 				   struct get_usable_chan_req_params req_msg,
4012 				   struct get_usable_chan_res_params *res_msg,
4013 				   struct regulatory_channel *chan_list,
4014 				   int *count)
4015 {
4016 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
4017 	enum channel_enum chan_enum;
4018 	uint32_t i = 0;
4019 	struct ch_avoid_freq_type freq_range;
4020 	struct wlan_objmgr_psoc *psoc;
4021 	QDF_STATUS status = QDF_STATUS_SUCCESS;
4022 
4023 	psoc = wlan_pdev_get_psoc(pdev);
4024 	if (!psoc) {
4025 		reg_err("invalid psoc");
4026 		return QDF_STATUS_E_FAILURE;
4027 	}
4028 
4029 	psoc_priv_obj = reg_get_psoc_obj(psoc);
4030 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
4031 		reg_alert("psoc reg component is NULL");
4032 		return QDF_STATUS_E_FAILURE;
4033 	}
4034 	for (chan_enum = 0; chan_enum < *count; chan_enum++) {
4035 		for (i = 0; i <
4036 		    psoc_priv_obj->avoid_freq_list.ch_avoid_range_cnt; i++) {
4037 			freq_range =
4038 			psoc_priv_obj->avoid_freq_list.avoid_freq_range[i];
4039 
4040 			if (freq_range.start_freq <=
4041 			    chan_list[chan_enum].center_freq &&
4042 			    freq_range.end_freq >=
4043 			    chan_list[chan_enum].center_freq) {
4044 				reg_debug("avoid freq %d",
4045 					  chan_list[chan_enum].center_freq);
4046 				reg_remove_freq(res_msg, chan_enum);
4047 			}
4048 		}
4049 	}
4050 	if (req_msg.iface_mode_mask & 1 << IFTYPE_AP ||
4051 	    req_msg.iface_mode_mask & 1 << IFTYPE_P2P_GO ||
4052 	    req_msg.iface_mode_mask & 1 << IFTYPE_NAN)
4053 		status =
4054 		reg_skip_invalid_chan_freq(pdev, res_msg, count,
4055 					   req_msg.iface_mode_mask);
4056 	return status;
4057 }
4058 
4059 /**
4060  * reg_calculate_mode_mask() - calculate valid mode mask
4061  * @iface_mode_mask: interface mode mask
4062  *
4063  * Return: Valid mode mask
4064  */
4065 static uint32_t
4066 reg_calculate_mode_mask(uint32_t iface_mode_mask)
4067 {
4068 	int mode_mask = 0;
4069 
4070 	mode_mask = (iface_mode_mask & 1 << IFTYPE_STATION) |
4071 		    (iface_mode_mask & 1 << IFTYPE_AP) |
4072 		    (iface_mode_mask & 1 << IFTYPE_P2P_GO) |
4073 		    (iface_mode_mask & 1 << IFTYPE_P2P_CLIENT) |
4074 		    (iface_mode_mask & 1 << IFTYPE_P2P_DEVICE) |
4075 		    (iface_mode_mask & 1 << IFTYPE_NAN);
4076 
4077 	return mode_mask;
4078 }
4079 
4080 /**
4081  * reg_add_usable_channel_to_resp() - Add usable channels to resp structure
4082  * @pdev: Pointer to pdev
4083  * @res_msg: Response msg
4084  * @iface_mode_mask: interface mode mask
4085  * @chan_list: reg channel list
4086  * @count: no of usable channels
4087  * @in_6g_pwr_mode: Input 6GHz power mode
4088  *
4089  * Return: qdf status
4090  */
4091 static QDF_STATUS
4092 reg_add_usable_channel_to_resp(struct wlan_objmgr_pdev *pdev,
4093 			       struct get_usable_chan_res_params *res_msg,
4094 			       uint32_t iface_mode_mask,
4095 			       struct regulatory_channel *chan_list,
4096 			       int *count,
4097 			       enum supported_6g_pwr_types in_6g_pwr_mode)
4098 {
4099 	enum channel_enum chan_enum;
4100 	struct ch_params ch_params = {0};
4101 	QDF_STATUS status = QDF_STATUS_SUCCESS;
4102 	uint32_t mode_mask = 0;
4103 
4104 	mode_mask = reg_calculate_mode_mask(iface_mode_mask);
4105 
4106 	for (chan_enum = 0; chan_enum < *count &&
4107 	     chan_enum < NUM_CHANNELS; chan_enum++) {
4108 		ch_params.ch_width = CH_WIDTH_MAX;
4109 		reg_set_channel_params_for_pwrmode(
4110 				pdev,
4111 				chan_list[chan_enum].center_freq,
4112 				chan_list[chan_enum].max_bw, &ch_params,
4113 				in_6g_pwr_mode, true);
4114 
4115 		res_msg[chan_enum].freq = chan_list[chan_enum].center_freq;
4116 		res_msg[chan_enum].iface_mode_mask = mode_mask;
4117 		if (!res_msg[chan_enum].iface_mode_mask) {
4118 			reg_err("invalid iface mask");
4119 			return QDF_STATUS_E_FAILURE;
4120 		}
4121 		res_msg[chan_enum].bw = ch_params.ch_width;
4122 		res_msg[chan_enum].state = chan_list[chan_enum].state;
4123 		if (ch_params.center_freq_seg0)
4124 			res_msg[chan_enum].seg0_freq =
4125 					ch_params.center_freq_seg0;
4126 		if (ch_params.center_freq_seg1)
4127 			res_msg[chan_enum].seg1_freq =
4128 					ch_params.center_freq_seg1;
4129 	}
4130 
4131 	return status;
4132 }
4133 
4134 QDF_STATUS
4135 wlan_reg_get_usable_channel(struct wlan_objmgr_pdev *pdev,
4136 			    struct get_usable_chan_req_params req_msg,
4137 			    struct get_usable_chan_res_params *res_msg,
4138 			    uint32_t *usable_channels,
4139 			    enum supported_6g_pwr_types in_6g_pwr_mode)
4140 {
4141 	struct regulatory_channel *chan_list;
4142 	QDF_STATUS status = QDF_STATUS_SUCCESS;
4143 
4144 	chan_list = qdf_mem_malloc(NUM_CHANNELS *
4145 			sizeof(*chan_list));
4146 
4147 	if (!chan_list) {
4148 		reg_err("chan_list invalid");
4149 		return QDF_STATUS_E_FAILURE;
4150 	}
4151 
4152 	if ((req_msg.filter_mask & 1 << FILTER_CELLULAR_COEX) ||
4153 	    (!(req_msg.filter_mask & 1 << FILTER_CELLULAR_COEX) &&
4154 	     !(req_msg.filter_mask & 1 << FILTER_WLAN_CONCURRENCY))) {
4155 		*usable_channels = reg_get_band_channel_list(pdev,
4156 							     req_msg.band_mask,
4157 							     chan_list);
4158 		status =
4159 		reg_add_usable_channel_to_resp(pdev, res_msg,
4160 					       req_msg.iface_mode_mask,
4161 					       chan_list, usable_channels,
4162 					       in_6g_pwr_mode);
4163 		if (QDF_IS_STATUS_ERROR(status)) {
4164 			qdf_mem_free(chan_list);
4165 			return status;
4166 		}
4167 	}
4168 
4169 	if (req_msg.filter_mask & 1 << FILTER_WLAN_CONCURRENCY)
4170 		status =
4171 		reg_get_usable_channel_con_filter(pdev, req_msg, res_msg,
4172 						  usable_channels,
4173 						  in_6g_pwr_mode);
4174 
4175 	if (req_msg.filter_mask & 1 << FILTER_CELLULAR_COEX)
4176 		status =
4177 		reg_get_usable_channel_coex_filter(pdev, req_msg, res_msg,
4178 						   chan_list, usable_channels);
4179 	if (!(req_msg.filter_mask & 1 << FILTER_CELLULAR_COEX) &&
4180 	    !(req_msg.filter_mask & 1 << FILTER_WLAN_CONCURRENCY))
4181 		status =
4182 		reg_get_usable_channel_no_filter(pdev, req_msg, res_msg,
4183 						 chan_list, usable_channels);
4184 	reg_debug("usable chan count is %d", *usable_channels);
4185 
4186 	qdf_mem_free(chan_list);
4187 	return status;
4188 }
4189 #endif
4190 
4191 /**
4192  * reg_get_nol_channel_state() - Get channel state from regulatory
4193  * and treat NOL channels as enabled channels
4194  * @pdev: Pointer to pdev
4195  * @freq: channel center frequency.
4196  * @in_6g_pwr_mode: Input 6 GHz power mode
4197  *
4198  * Return: channel state
4199  */
4200 static enum channel_state
4201 reg_get_nol_channel_state(struct wlan_objmgr_pdev *pdev,
4202 			  qdf_freq_t freq,
4203 			  enum supported_6g_pwr_types in_6g_pwr_mode)
4204 {
4205 	enum channel_enum ch_idx;
4206 	enum channel_state chan_state;
4207 
4208 	ch_idx = reg_get_chan_enum_for_freq(freq);
4209 
4210 	if (reg_is_chan_enum_invalid(ch_idx))
4211 		return CHANNEL_STATE_INVALID;
4212 
4213 	chan_state = reg_get_chan_state(pdev, ch_idx, in_6g_pwr_mode, false);
4214 
4215 	return chan_state;
4216 }
4217 
4218 /**
4219  * reg_get_5g_bonded_chan_state()- Return the channel state for a
4220  * 5G or 6G channel frequency based on the bonded channel.
4221  * @pdev: Pointer to pdev.
4222  * @freq: Channel center frequency.
4223  * @bonded_chan_ptr: Pointer to bonded_channel_freq.
4224  * @in_6g_pwr_mode: Input 6 GHz power mode
4225  * @input_punc_bitmap: input puncture bitmap
4226  *
4227  * Return: Channel State
4228  */
4229 static enum channel_state
4230 reg_get_5g_bonded_chan_state(struct wlan_objmgr_pdev *pdev,
4231 			     uint16_t freq,
4232 			     const struct bonded_channel_freq *bonded_chan_ptr,
4233 			     enum supported_6g_pwr_types in_6g_pwr_mode,
4234 			     uint16_t input_punc_bitmap)
4235 {
4236 	uint16_t chan_cfreq;
4237 	enum channel_state chan_state = CHANNEL_STATE_INVALID;
4238 	enum channel_state temp_chan_state;
4239 	uint8_t i = 0;
4240 
4241 	chan_cfreq =  bonded_chan_ptr->start_freq;
4242 	while (chan_cfreq <= bonded_chan_ptr->end_freq) {
4243 		if (!reg_is_chan_bit_punctured(input_punc_bitmap, i)) {
4244 			temp_chan_state =
4245 				reg_get_nol_channel_state(pdev, chan_cfreq,
4246 							  in_6g_pwr_mode);
4247 			if (temp_chan_state < chan_state)
4248 				chan_state = temp_chan_state;
4249 		}
4250 		chan_cfreq = chan_cfreq + 20;
4251 		i++;
4252 	}
4253 
4254 	return chan_state;
4255 }
4256 
4257 enum channel_state
4258 reg_get_5g_chan_state(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq,
4259 		      enum phy_ch_width bw,
4260 		      enum supported_6g_pwr_types in_6g_pwr_mode,
4261 		      uint16_t input_punc_bitmap)
4262 {
4263 	enum channel_enum ch_indx;
4264 	enum channel_state chan_state;
4265 	bool bw_enabled = false;
4266 	const struct bonded_channel_freq *bonded_chan_ptr = NULL;
4267 	uint16_t min_bw, max_bw;
4268 
4269 	if (bw > CH_WIDTH_80P80MHZ) {
4270 		reg_err_rl("bw passed is not good");
4271 		return CHANNEL_STATE_INVALID;
4272 	}
4273 
4274 	if (bw == CH_WIDTH_20MHZ)
4275 		return reg_get_nol_channel_state(pdev, freq, in_6g_pwr_mode);
4276 
4277 	/* Fetch the bonded_chan_ptr for width greater than 20MHZ. */
4278 	bonded_chan_ptr = reg_get_bonded_chan_entry(freq, bw, 0);
4279 
4280 	if (!bonded_chan_ptr)
4281 		return CHANNEL_STATE_INVALID;
4282 
4283 	chan_state = reg_get_5g_bonded_chan_state(pdev, freq, bonded_chan_ptr,
4284 						  in_6g_pwr_mode,
4285 						  input_punc_bitmap);
4286 
4287 	if ((chan_state == CHANNEL_STATE_INVALID) ||
4288 	    (chan_state == CHANNEL_STATE_DISABLE))
4289 		return chan_state;
4290 
4291 	ch_indx = reg_get_chan_enum_for_freq(freq);
4292 	if (reg_is_chan_enum_invalid(ch_indx))
4293 		return CHANNEL_STATE_INVALID;
4294 
4295 	if (reg_get_min_max_bw_reg_chan_list(pdev, ch_indx, in_6g_pwr_mode,
4296 					     &min_bw, &max_bw)) {
4297 		return CHANNEL_STATE_INVALID;
4298 	}
4299 
4300 	if (bw == CH_WIDTH_5MHZ)
4301 		bw_enabled = true;
4302 	else if (bw == CH_WIDTH_10MHZ)
4303 		bw_enabled = (min_bw <= 10) &&
4304 			(max_bw >= 10);
4305 	else if (bw == CH_WIDTH_20MHZ)
4306 		bw_enabled = (min_bw <= 20) &&
4307 			(max_bw >= 20);
4308 	else if (bw == CH_WIDTH_40MHZ)
4309 		bw_enabled = (min_bw <= 40) &&
4310 			(max_bw >= 40);
4311 	else if (bw == CH_WIDTH_80MHZ)
4312 		bw_enabled = (min_bw <= 80) &&
4313 			(max_bw >= 80);
4314 	else if (bw == CH_WIDTH_160MHZ)
4315 		bw_enabled = (min_bw <= 160) &&
4316 			(max_bw >= 160);
4317 	else if (bw == CH_WIDTH_80P80MHZ)
4318 		bw_enabled = (min_bw <= 80) &&
4319 			(max_bw >= 80);
4320 
4321 	if (bw_enabled)
4322 		return chan_state;
4323 	else
4324 		return CHANNEL_STATE_DISABLE;
4325 }
4326 
4327 enum channel_state
4328 reg_get_ch_state_based_on_nol_flag(struct wlan_objmgr_pdev *pdev,
4329 				   qdf_freq_t freq,
4330 				   struct ch_params *ch_params,
4331 				   enum supported_6g_pwr_types
4332 				   in_6g_pwr_mode,
4333 				   bool treat_nol_chan_as_disabled)
4334 {
4335 	uint16_t input_punc_bitmap = reg_fetch_punc_bitmap(ch_params);
4336 
4337 	if (treat_nol_chan_as_disabled)
4338 		return wlan_reg_get_5g_bonded_channel_state_for_pwrmode(pdev,
4339 									freq,
4340 									ch_params,
4341 									in_6g_pwr_mode);
4342 
4343 	return reg_get_5g_chan_state(pdev, freq, ch_params->ch_width,
4344 				     in_6g_pwr_mode,
4345 				     input_punc_bitmap);
4346 }
4347 
4348 #ifdef WLAN_FEATURE_11BE
4349 bool reg_is_ch_width_320(enum phy_ch_width ch_width)
4350 {
4351 	if (ch_width == CH_WIDTH_320MHZ)
4352 		return true;
4353 	return false;
4354 }
4355 #else
4356 bool reg_is_ch_width_320(enum phy_ch_width ch_width)
4357 {
4358 	return false;
4359 }
4360 #endif
4361 
4362 #ifdef CONFIG_REG_6G_PWRMODE
4363 enum channel_state
4364 reg_get_channel_state_for_pwrmode(struct wlan_objmgr_pdev *pdev,
4365 				  qdf_freq_t freq,
4366 				  enum supported_6g_pwr_types in_6g_pwr_type)
4367 {
4368 	enum channel_enum ch_idx;
4369 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
4370 	enum channel_state state;
4371 
4372 	ch_idx = reg_get_chan_enum_for_freq(freq);
4373 
4374 	if (reg_is_chan_enum_invalid(ch_idx))
4375 		return CHANNEL_STATE_INVALID;
4376 
4377 	pdev_priv_obj = reg_get_pdev_obj(pdev);
4378 
4379 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
4380 		reg_err("pdev reg obj is NULL");
4381 		return CHANNEL_STATE_INVALID;
4382 	}
4383 
4384 	state = reg_get_chan_state(pdev, ch_idx, in_6g_pwr_type, true);
4385 	return state;
4386 }
4387 #endif
4388 
4389 static uint32_t reg_get_channel_flags_for_freq(struct wlan_objmgr_pdev *pdev,
4390 					       qdf_freq_t freq)
4391 {
4392 	enum channel_enum chan_enum;
4393 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
4394 
4395 	chan_enum = reg_get_chan_enum_for_freq(freq);
4396 
4397 	if (reg_is_chan_enum_invalid(chan_enum)) {
4398 		reg_debug("chan freq is not valid");
4399 		return REGULATORY_CHAN_INVALID;
4400 	}
4401 
4402 	pdev_priv_obj = reg_get_pdev_obj(pdev);
4403 
4404 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
4405 		reg_debug("pdev reg obj is NULL");
4406 		return REGULATORY_CHAN_INVALID;
4407 	}
4408 
4409 	return pdev_priv_obj->cur_chan_list[chan_enum].chan_flags;
4410 }
4411 
4412 #ifdef CONFIG_REG_CLIENT
4413 enum channel_state reg_get_channel_state_from_secondary_list_for_freq(
4414 						struct wlan_objmgr_pdev *pdev,
4415 						qdf_freq_t freq)
4416 {
4417 	enum channel_enum ch_idx;
4418 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
4419 
4420 	ch_idx = reg_get_chan_enum_for_freq(freq);
4421 
4422 	if (reg_is_chan_enum_invalid(ch_idx))
4423 		return CHANNEL_STATE_INVALID;
4424 
4425 	pdev_priv_obj = reg_get_pdev_obj(pdev);
4426 
4427 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
4428 		reg_err("pdev reg obj is NULL");
4429 		return CHANNEL_STATE_INVALID;
4430 	}
4431 
4432 	return pdev_priv_obj->secondary_cur_chan_list[ch_idx].state;
4433 }
4434 
4435 static uint32_t reg_get_channel_flags_from_secondary_list_for_freq(
4436 						struct wlan_objmgr_pdev *pdev,
4437 						qdf_freq_t freq)
4438 {
4439 	enum channel_enum chan_enum;
4440 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
4441 
4442 	chan_enum = reg_get_chan_enum_for_freq(freq);
4443 
4444 	if (reg_is_chan_enum_invalid(chan_enum)) {
4445 		reg_err_rl("chan freq %u is not valid", freq);
4446 		return REGULATORY_CHAN_INVALID;
4447 	}
4448 
4449 	pdev_priv_obj = reg_get_pdev_obj(pdev);
4450 
4451 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
4452 		reg_err("pdev reg obj is NULL");
4453 		return REGULATORY_CHAN_INVALID;
4454 	}
4455 
4456 	return pdev_priv_obj->secondary_cur_chan_list[chan_enum].chan_flags;
4457 }
4458 
4459 #ifdef CONFIG_BAND_6GHZ
4460 /**
4461  * reg_get_psd_power() - Function to get PSD power for 6 GHz channel
4462  * @chan: Pointer to channel object
4463  * @is_psd: Pointer to whether it is PSD power
4464  *
4465  * Return: Channel PSD power value if it is PSD type.
4466  */
4467 static uint16_t reg_get_psd_power(struct regulatory_channel *chan, bool *is_psd)
4468 {
4469 	if (is_psd)
4470 		*is_psd = chan->psd_flag;
4471 	return chan->psd_eirp;
4472 }
4473 #else
4474 static uint16_t reg_get_psd_power(struct regulatory_channel *chan, bool *is_psd)
4475 {
4476 	if (is_psd)
4477 		*is_psd = false;
4478 	return 0;
4479 }
4480 #endif
4481 
4482 QDF_STATUS
4483 reg_get_channel_power_attr_from_secondary_list_for_freq(
4484 		struct wlan_objmgr_pdev *pdev,
4485 		qdf_freq_t freq, bool *is_psd,
4486 		uint16_t *tx_power, uint16_t *psd_eirp, uint32_t *flags)
4487 {
4488 	enum channel_enum chan_enum;
4489 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
4490 	struct regulatory_channel *chan;
4491 
4492 	if (!is_psd && !tx_power && !psd_eirp && !flags) {
4493 		reg_err("all pointers null");
4494 		return QDF_STATUS_E_FAILURE;
4495 	}
4496 
4497 	pdev_priv_obj = reg_get_pdev_obj(pdev);
4498 	if (!pdev_priv_obj) {
4499 		reg_err("pdev priv obj is NULL");
4500 		return QDF_STATUS_E_FAILURE;
4501 	}
4502 
4503 	chan_enum = reg_get_chan_enum_for_freq(freq);
4504 	if (chan_enum == INVALID_CHANNEL) {
4505 		reg_err_rl("chan freq %u is not valid", freq);
4506 		return QDF_STATUS_E_FAILURE;
4507 	}
4508 
4509 	chan = &pdev_priv_obj->secondary_cur_chan_list[chan_enum];
4510 
4511 	if (chan->state == CHANNEL_STATE_DISABLE ||
4512 	    chan->state == CHANNEL_STATE_INVALID) {
4513 		reg_err_rl("invalid channel state %d", chan->state);
4514 		return QDF_STATUS_E_FAILURE;
4515 	}
4516 
4517 	if (tx_power)
4518 		*tx_power = chan->tx_power;
4519 	if (psd_eirp)
4520 		*psd_eirp = reg_get_psd_power(chan, is_psd);
4521 	if (flags)
4522 		*flags = chan->chan_flags;
4523 
4524 	return QDF_STATUS_SUCCESS;
4525 }
4526 
4527 #ifdef CONFIG_BAND_6GHZ
4528 QDF_STATUS
4529 reg_decide_6ghz_power_within_bw_for_freq(struct wlan_objmgr_pdev *pdev,
4530 					 qdf_freq_t freq, enum phy_ch_width bw,
4531 					 bool *is_psd, uint16_t *min_tx_power,
4532 					 int16_t *min_psd_eirp,
4533 					 enum reg_6g_ap_type *power_type,
4534 					 enum supported_6g_pwr_types pwr_mode,
4535 					 uint16_t input_punc_bitmap)
4536 {
4537 	const struct bonded_channel_freq *bonded_chan_ptr = NULL;
4538 	enum channel_state state;
4539 	qdf_freq_t start_freq;
4540 	uint16_t tx_power, psd_eirp;
4541 	uint32_t chan_flags, min_chan_flags = 0;
4542 	bool first_time = true;
4543 
4544 	if (!reg_is_6ghz_chan_freq(freq))
4545 		return QDF_STATUS_E_INVAL;
4546 
4547 	if (!is_psd) {
4548 		reg_err("is_psd pointer null");
4549 		return QDF_STATUS_E_INVAL;
4550 	}
4551 	if (!min_tx_power) {
4552 		reg_err("min_tx_power pointer null");
4553 		return QDF_STATUS_E_INVAL;
4554 	}
4555 	if (!min_psd_eirp) {
4556 		reg_err("min_psd_eirp pointer null");
4557 		return QDF_STATUS_E_INVAL;
4558 	}
4559 	if (!power_type) {
4560 		reg_err("power_type pointer null");
4561 		return QDF_STATUS_E_INVAL;
4562 	}
4563 
4564 	state = reg_get_5g_bonded_channel_for_pwrmode(pdev,
4565 						      freq,
4566 						      bw,
4567 						      &bonded_chan_ptr,
4568 						      pwr_mode,
4569 						      input_punc_bitmap);
4570 	if (state != CHANNEL_STATE_ENABLE &&
4571 	    state != CHANNEL_STATE_DFS) {
4572 		reg_err("invalid channel state %d", state);
4573 		return QDF_STATUS_E_INVAL;
4574 	}
4575 
4576 	if (bw <= CH_WIDTH_20MHZ) {
4577 		if (reg_get_channel_power_attr_from_secondary_list_for_freq(
4578 			pdev, freq, is_psd, &tx_power,
4579 			&psd_eirp, &chan_flags) != QDF_STATUS_SUCCESS)
4580 			return QDF_STATUS_E_INVAL;
4581 		*min_psd_eirp = (int16_t)psd_eirp;
4582 		*min_tx_power = tx_power;
4583 		min_chan_flags = chan_flags;
4584 		goto decide_power_type;
4585 	}
4586 
4587 	start_freq = bonded_chan_ptr->start_freq;
4588 	while (start_freq <= bonded_chan_ptr->end_freq) {
4589 		if (reg_get_channel_power_attr_from_secondary_list_for_freq(
4590 			pdev, start_freq, is_psd, &tx_power,
4591 			&psd_eirp, &chan_flags) != QDF_STATUS_SUCCESS)
4592 			return QDF_STATUS_E_INVAL;
4593 
4594 		if (first_time) {
4595 			*min_psd_eirp = (int16_t)psd_eirp;
4596 			*min_tx_power = tx_power;
4597 			min_chan_flags = chan_flags;
4598 			first_time = false;
4599 		}
4600 		if ((int16_t)psd_eirp < *min_psd_eirp)
4601 			*min_psd_eirp = (int16_t)psd_eirp;
4602 		if (tx_power < *min_tx_power)
4603 			*min_tx_power = tx_power;
4604 		min_chan_flags |= (chan_flags & REGULATORY_CHAN_AFC);
4605 		min_chan_flags |= (chan_flags & REGULATORY_CHAN_INDOOR_ONLY);
4606 		start_freq += 20;
4607 	}
4608 
4609 decide_power_type:
4610 	if ((min_chan_flags & REGULATORY_CHAN_AFC) &&
4611 	    (min_chan_flags & REGULATORY_CHAN_INDOOR_ONLY))
4612 		*power_type = REG_INDOOR_AP;
4613 	else if (min_chan_flags & REGULATORY_CHAN_AFC)
4614 		*power_type = REG_STANDARD_POWER_AP;
4615 	else if (min_chan_flags & REGULATORY_CHAN_INDOOR_ONLY)
4616 		*power_type = REG_INDOOR_AP;
4617 	else
4618 		*power_type = REG_VERY_LOW_POWER_AP;
4619 
4620 	return QDF_STATUS_SUCCESS;
4621 }
4622 #endif
4623 #endif
4624 
4625 /**
4626  * reg_get_5g_bonded_chan_array_for_pwrmode()- Return the channel state for a
4627  * 5G or 6G channel frequency based on the bonded channel.
4628  * @pdev: Pointer to pdev.
4629  * @freq: Channel center frequency.
4630  * @bonded_chan_ptr: Pointer to bonded_channel_freq.
4631  * @in_6g_pwr_type: Input 6g power mode which decides the which power mode based
4632  * channel list will be chosen.
4633  * @input_punc_bitmap: Input puncture bitmap
4634  *
4635  * Return: Channel State
4636  */
4637 static enum channel_state
4638 reg_get_5g_bonded_chan_array_for_pwrmode(struct wlan_objmgr_pdev *pdev,
4639 					 uint16_t freq,
4640 					 const struct bonded_channel_freq *
4641 					 bonded_chan_ptr,
4642 					 enum supported_6g_pwr_types
4643 					 in_6g_pwr_type,
4644 					 uint16_t input_punc_bitmap)
4645 {
4646 	uint16_t chan_cfreq;
4647 	enum channel_state chan_state = CHANNEL_STATE_INVALID;
4648 	enum channel_state temp_chan_state;
4649 	uint8_t i = 0;
4650 
4651 	if (!bonded_chan_ptr) {
4652 		reg_debug("bonded chan ptr is NULL");
4653 		return chan_state;
4654 	}
4655 
4656 	chan_cfreq =  bonded_chan_ptr->start_freq;
4657 	while (chan_cfreq <= bonded_chan_ptr->end_freq) {
4658 		if (!reg_is_chan_bit_punctured(input_punc_bitmap, i)) {
4659 			temp_chan_state =
4660 				reg_get_channel_state_for_pwrmode(pdev,
4661 								  chan_cfreq,
4662 								  in_6g_pwr_type);
4663 			if (temp_chan_state < chan_state)
4664 				chan_state = temp_chan_state;
4665 		}
4666 		chan_cfreq = chan_cfreq + 20;
4667 		i++;
4668 	}
4669 
4670 	return chan_state;
4671 }
4672 
4673 #ifdef WLAN_FEATURE_11BE
4674 
4675 QDF_STATUS reg_extract_puncture_by_bw(enum phy_ch_width ori_bw,
4676 				      uint16_t ori_puncture_bitmap,
4677 				      qdf_freq_t freq,
4678 				      qdf_freq_t cen320_freq,
4679 				      enum phy_ch_width new_bw,
4680 				      uint16_t *new_puncture_bitmap)
4681 {
4682 	const struct bonded_channel_freq *ori_bonded_chan;
4683 	const struct bonded_channel_freq *new_bonded_chan;
4684 	uint16_t chan_cfreq;
4685 	uint16_t new_bit;
4686 
4687 	if (ori_bw < new_bw) {
4688 		reg_err_rl("freq %d, ori bw %d can't be smaller than new bw %d",
4689 			   freq, ori_bw, new_bw);
4690 		return QDF_STATUS_E_FAILURE;
4691 	}
4692 
4693 	if (ori_bw == new_bw) {
4694 		*new_puncture_bitmap = ori_puncture_bitmap;
4695 		return QDF_STATUS_SUCCESS;
4696 	}
4697 
4698 	ori_bonded_chan = reg_get_bonded_chan_entry(freq, ori_bw, cen320_freq);
4699 	new_bonded_chan = reg_get_bonded_chan_entry(freq, new_bw, 0);
4700 	if (!ori_bonded_chan) {
4701 		reg_err_rl("bonded chan fails, freq %d, ori bw %d, new bw %d",
4702 			   freq, ori_bw, new_bw);
4703 		return QDF_STATUS_E_FAILURE;
4704 	}
4705 
4706 	new_bit = 0;
4707 	*new_puncture_bitmap = 0;
4708 	chan_cfreq =  ori_bonded_chan->start_freq;
4709 	while (chan_cfreq <= ori_bonded_chan->end_freq) {
4710 		/*
4711 		 * If the "new_bw" is 20, then new_bonded_chan = NULL and the
4712 		 * output puncturing bitmap (*new_puncture_bitmap) as per spec
4713 		 * should be 0. However, if the "ori_puncture_bitmap" has
4714 		 * punctured the primary channel (the only channel in 20Mhz
4715 		 * case), then the output "(*ori_puncture_bitmap) should contain
4716 		 * the same so that the caller can recognize the error in the
4717 		 * input pattern.
4718 		 */
4719 		if (freq == chan_cfreq ||
4720 		    (new_bonded_chan &&
4721 		     chan_cfreq >= new_bonded_chan->start_freq &&
4722 		     chan_cfreq <= new_bonded_chan->end_freq)) {
4723 			/* this frequency is in new bw */
4724 			*new_puncture_bitmap |=
4725 					(ori_puncture_bitmap & 1) << new_bit;
4726 			new_bit++;
4727 		}
4728 
4729 		ori_puncture_bitmap >>= 1;
4730 		chan_cfreq = chan_cfreq + BW_20_MHZ;
4731 	}
4732 
4733 	return QDF_STATUS_SUCCESS;
4734 }
4735 
4736 void reg_set_create_punc_bitmap(struct ch_params *ch_params,
4737 				bool is_create_punc_bitmap)
4738 {
4739 	ch_params->is_create_punc_bitmap = is_create_punc_bitmap;
4740 }
4741 
4742 bool reg_is_punc_bitmap_valid(enum phy_ch_width bw, uint16_t puncture_bitmap)
4743 {
4744 	int i, num_bws;
4745 	const uint16_t *bonded_puncture_bitmap = NULL;
4746 	uint16_t array_size = 0;
4747 	bool is_punc_bitmap_valid = false;
4748 
4749 	num_bws = QDF_ARRAY_SIZE(bw_puncture_bitmap_pair_map);
4750 	for (i = 0; i < num_bws; i++) {
4751 		if (bw == bw_puncture_bitmap_pair_map[i].chwidth) {
4752 			bonded_puncture_bitmap =
4753 			    bw_puncture_bitmap_pair_map[i].puncture_bitmap_arr;
4754 			array_size = bw_puncture_bitmap_pair_map[i].array_size;
4755 			break;
4756 		}
4757 	}
4758 
4759 	if (array_size && bonded_puncture_bitmap) {
4760 		for (i = 0; i < array_size; i++) {
4761 			if (puncture_bitmap == bonded_puncture_bitmap[i]) {
4762 				is_punc_bitmap_valid = true;
4763 				break;
4764 			}
4765 		}
4766 	}
4767 
4768 	return is_punc_bitmap_valid;
4769 }
4770 
4771 uint16_t reg_find_nearest_puncture_pattern(enum phy_ch_width bw,
4772 					   uint16_t proposed_bitmap)
4773 {
4774 	int i, num_bws;
4775 	const uint16_t *bonded_puncture_bitmap = NULL;
4776 	uint16_t array_size;
4777 	uint16_t final_bitmap;
4778 
4779 	/* An input pattern = 0 will match any pattern
4780 	 * Therefore, ignore '0' pattern and return '0', as '0' matches '0'.
4781 	 */
4782 	if (!proposed_bitmap)
4783 		return 0;
4784 
4785 	array_size = 0;
4786 	final_bitmap = 0;
4787 
4788 	num_bws = QDF_ARRAY_SIZE(bw_puncture_bitmap_pair_map);
4789 	for (i = 0; i < num_bws; i++) {
4790 		if (bw == bw_puncture_bitmap_pair_map[i].chwidth) {
4791 			bonded_puncture_bitmap =
4792 			    bw_puncture_bitmap_pair_map[i].puncture_bitmap_arr;
4793 			array_size = bw_puncture_bitmap_pair_map[i].array_size;
4794 			break;
4795 		}
4796 	}
4797 
4798 	if (array_size && bonded_puncture_bitmap) {
4799 		for (i = 0; i < array_size; i++) {
4800 			uint16_t valid_bitmap = bonded_puncture_bitmap[i];
4801 
4802 			if ((proposed_bitmap | valid_bitmap) == valid_bitmap) {
4803 				final_bitmap = valid_bitmap;
4804 				break;
4805 			}
4806 		}
4807 	}
4808 
4809 	return final_bitmap;
4810 }
4811 
4812 /**
4813  * reg_update_5g_bonded_channel_state_punc_for_pwrmode() - update channel state
4814  * with static puncturing feature
4815  * @pdev: pointer to pdev
4816  * @bonded_chan_ptr: Pointer to bonded_channel_freq.
4817  * @ch_params: pointer to ch_params
4818  * @chan_state: chan_state to be updated
4819  * @in_6g_pwr_mode: Input 6 GHz power mode
4820  *
4821  * Return: void
4822  */
4823 static void reg_update_5g_bonded_channel_state_punc_for_pwrmode(
4824 			struct wlan_objmgr_pdev *pdev,
4825 			const struct bonded_channel_freq *bonded_chan_ptr,
4826 			struct ch_params *ch_params,
4827 			enum channel_state *chan_state,
4828 			enum supported_6g_pwr_types in_6g_pwr_mode)
4829 {
4830 	qdf_freq_t chan_cfreq;
4831 	enum channel_state temp_chan_state;
4832 	uint16_t puncture_bitmap = 0;
4833 	uint16_t final_bitmap;
4834 	int i = 0;
4835 	enum channel_state update_state = CHANNEL_STATE_ENABLE;
4836 
4837 	if (!pdev || !bonded_chan_ptr || !ch_params || !chan_state ||
4838 	    !ch_params->is_create_punc_bitmap)
4839 		return;
4840 
4841 	chan_cfreq =  bonded_chan_ptr->start_freq;
4842 	while (chan_cfreq <= bonded_chan_ptr->end_freq) {
4843 		temp_chan_state =
4844 			reg_get_channel_state_for_pwrmode(pdev, chan_cfreq,
4845 							  in_6g_pwr_mode);
4846 		if (!reg_is_state_allowed(temp_chan_state))
4847 			puncture_bitmap |= BIT(i);
4848 		/* Remember of any of the sub20 channel is a DFS channel */
4849 		if (temp_chan_state == CHANNEL_STATE_DFS)
4850 			update_state = CHANNEL_STATE_DFS;
4851 		chan_cfreq = chan_cfreq + BW_20_MHZ;
4852 		i++;
4853 	}
4854 	/* Validate puncture bitmap. Update channel state. */
4855 	final_bitmap = reg_find_nearest_puncture_pattern(ch_params->ch_width,
4856 							 puncture_bitmap);
4857 	if (final_bitmap) {
4858 		*chan_state = update_state;
4859 		ch_params->reg_punc_bitmap = final_bitmap;
4860 	}
4861 }
4862 
4863 #ifdef CONFIG_REG_CLIENT
4864 QDF_STATUS reg_apply_puncture(struct wlan_objmgr_pdev *pdev,
4865 			      uint16_t puncture_bitmap,
4866 			      qdf_freq_t freq,
4867 			      enum phy_ch_width bw,
4868 			      qdf_freq_t cen320_freq)
4869 {
4870 	const struct bonded_channel_freq *bonded_chan;
4871 	qdf_freq_t chan_cfreq;
4872 	enum channel_enum chan_enum;
4873 	struct regulatory_channel *mas_chan_list;
4874 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
4875 	bool is_puncture;
4876 	uint16_t i = 0;
4877 
4878 	pdev_priv_obj = reg_get_pdev_obj(pdev);
4879 
4880 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
4881 		reg_err_rl("pdev reg obj is NULL");
4882 		return QDF_STATUS_E_FAILURE;
4883 	}
4884 
4885 	mas_chan_list = pdev_priv_obj->mas_chan_list;
4886 	if (!mas_chan_list) {
4887 		reg_err_rl("mas chan_list is NULL");
4888 		return QDF_STATUS_E_FAILURE;
4889 	}
4890 	bonded_chan = reg_get_bonded_chan_entry(freq, bw, cen320_freq);
4891 	if (!bonded_chan) {
4892 		reg_err_rl("bonded chan fails, freq %d, bw %d, cen320_freq %d",
4893 			   freq, bw, cen320_freq);
4894 		return QDF_STATUS_E_FAILURE;
4895 	}
4896 
4897 	chan_cfreq = bonded_chan->start_freq;
4898 	while (chan_cfreq <= bonded_chan->end_freq) {
4899 		is_puncture = BIT(i) & puncture_bitmap;
4900 		if (is_puncture) {
4901 			chan_enum = reg_get_chan_enum_for_freq(chan_cfreq);
4902 			if (reg_is_chan_enum_invalid(chan_enum)) {
4903 				reg_debug_rl("Invalid chan enum %d", chan_enum);
4904 				return QDF_STATUS_E_FAILURE;
4905 			}
4906 			mas_chan_list[chan_enum].is_static_punctured = true;
4907 		}
4908 		i++;
4909 		chan_cfreq = chan_cfreq + BW_20_MHZ;
4910 	}
4911 
4912 	reg_compute_pdev_current_chan_list(pdev_priv_obj);
4913 
4914 	return QDF_STATUS_SUCCESS;
4915 }
4916 
4917 QDF_STATUS reg_remove_puncture(struct wlan_objmgr_pdev *pdev)
4918 {
4919 	enum channel_enum chan_enum;
4920 	struct regulatory_channel *mas_chan_list;
4921 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
4922 
4923 	pdev_priv_obj = reg_get_pdev_obj(pdev);
4924 
4925 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
4926 		reg_err_rl("pdev reg obj is NULL");
4927 		return QDF_STATUS_E_FAILURE;
4928 	}
4929 
4930 	mas_chan_list = pdev_priv_obj->mas_chan_list;
4931 	if (!mas_chan_list) {
4932 		reg_err_rl("mas chan_list is NULL");
4933 		return QDF_STATUS_E_FAILURE;
4934 	}
4935 
4936 	for (chan_enum = 0; chan_enum < NUM_CHANNELS; chan_enum++)
4937 		if (mas_chan_list[chan_enum].is_static_punctured)
4938 			mas_chan_list[chan_enum].is_static_punctured = false;
4939 
4940 	reg_compute_pdev_current_chan_list(pdev_priv_obj);
4941 
4942 	return QDF_STATUS_SUCCESS;
4943 }
4944 #endif
4945 
4946 #else
4947 static void reg_update_5g_bonded_channel_state_punc_for_pwrmode(
4948 			struct wlan_objmgr_pdev *pdev,
4949 			const struct bonded_channel_freq *bonded_chan_ptr,
4950 			struct ch_params *ch_params,
4951 			enum channel_state *chan_state,
4952 			enum supported_6g_pwr_types in_6g_pwr_mode)
4953 {
4954 }
4955 #endif
4956 
4957 #ifdef CONFIG_REG_6G_PWRMODE
4958 enum channel_state
4959 reg_get_5g_bonded_channel_state_for_pwrmode(struct wlan_objmgr_pdev *pdev,
4960 					    qdf_freq_t freq,
4961 					    struct ch_params *ch_params,
4962 					    enum supported_6g_pwr_types
4963 					    in_6g_pwr_mode)
4964 {
4965 	enum phy_ch_width bw;
4966 	enum channel_enum ch_indx;
4967 	enum channel_state chan_state;
4968 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
4969 	bool bw_enabled = false;
4970 	const struct bonded_channel_freq *bonded_chan_ptr = NULL;
4971 	uint16_t min_bw, max_bw;
4972 	uint16_t in_punc_bitmap = reg_fetch_punc_bitmap(ch_params);
4973 
4974 	if (!ch_params) {
4975 		reg_err_rl("Invalid ch_params");
4976 		return CHANNEL_STATE_INVALID;
4977 	}
4978 	bw = ch_params->ch_width;
4979 	if (bw > CH_WIDTH_80P80MHZ) {
4980 		reg_err_rl("bw (%d) passed is not good", bw);
4981 		return CHANNEL_STATE_INVALID;
4982 	}
4983 
4984 	chan_state = reg_get_5g_bonded_channel_for_pwrmode(pdev, freq, bw,
4985 							   &bonded_chan_ptr,
4986 							   in_6g_pwr_mode,
4987 							   in_punc_bitmap);
4988 
4989 	reg_update_5g_bonded_channel_state_punc_for_pwrmode(
4990 						pdev, bonded_chan_ptr,
4991 						ch_params, &chan_state,
4992 						in_6g_pwr_mode);
4993 
4994 	if ((chan_state == CHANNEL_STATE_INVALID) ||
4995 	    (chan_state == CHANNEL_STATE_DISABLE))
4996 		return chan_state;
4997 
4998 	pdev_priv_obj = reg_get_pdev_obj(pdev);
4999 
5000 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
5001 		reg_err("pdev reg obj is NULL");
5002 		return CHANNEL_STATE_INVALID;
5003 	}
5004 
5005 	ch_indx = reg_get_chan_enum_for_freq(freq);
5006 	if (reg_is_chan_enum_invalid(ch_indx))
5007 		return CHANNEL_STATE_INVALID;
5008 
5009 	if (reg_get_min_max_bw_reg_chan_list(pdev, ch_indx, in_6g_pwr_mode,
5010 					     &min_bw, &max_bw))
5011 		return CHANNEL_STATE_INVALID;
5012 
5013 	if (bw == CH_WIDTH_5MHZ)
5014 		bw_enabled = true;
5015 	else if (bw == CH_WIDTH_10MHZ)
5016 		bw_enabled = (min_bw <= 10) &&
5017 			(max_bw >= 10);
5018 	else if (bw == CH_WIDTH_20MHZ)
5019 		bw_enabled = (min_bw <= 20) &&
5020 			(max_bw >= 20);
5021 	else if (bw == CH_WIDTH_40MHZ)
5022 		bw_enabled = (min_bw <= 40) &&
5023 			(max_bw >= 40);
5024 	else if (bw == CH_WIDTH_80MHZ)
5025 		bw_enabled = (min_bw <= 80) &&
5026 			(max_bw >= 80);
5027 	else if (bw == CH_WIDTH_160MHZ)
5028 		bw_enabled = (min_bw <= 160) &&
5029 			(max_bw >= 160);
5030 	else if (bw == CH_WIDTH_80P80MHZ)
5031 		bw_enabled = (min_bw <= 80) &&
5032 			(max_bw >= 80);
5033 
5034 	if (bw_enabled)
5035 		return chan_state;
5036 	return CHANNEL_STATE_DISABLE;
5037 }
5038 #endif
5039 
5040 enum channel_state
5041 reg_get_2g_bonded_channel_state_for_freq(struct wlan_objmgr_pdev *pdev,
5042 					 qdf_freq_t oper_ch_freq,
5043 					 qdf_freq_t sec_ch_freq,
5044 					 enum phy_ch_width bw)
5045 {
5046 	enum channel_enum chan_idx;
5047 	enum channel_state chan_state;
5048 	struct regulatory_channel *reg_channels;
5049 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
5050 	bool bw_enabled = false;
5051 	enum channel_state chan_state2 = CHANNEL_STATE_INVALID;
5052 
5053 	if (bw > CH_WIDTH_40MHZ)
5054 		return CHANNEL_STATE_INVALID;
5055 
5056 	if (bw == CH_WIDTH_40MHZ) {
5057 		if ((sec_ch_freq + 20 != oper_ch_freq) &&
5058 		    (oper_ch_freq + 20 != sec_ch_freq))
5059 			return CHANNEL_STATE_INVALID;
5060 		chan_state2 =
5061 		    reg_get_channel_state_for_pwrmode(pdev,
5062 						      sec_ch_freq,
5063 						      REG_CURRENT_PWR_MODE);
5064 		if (chan_state2 == CHANNEL_STATE_INVALID)
5065 			return chan_state2;
5066 	}
5067 	pdev_priv_obj = reg_get_pdev_obj(pdev);
5068 
5069 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
5070 		reg_err("reg pdev priv obj is NULL");
5071 		return CHANNEL_STATE_INVALID;
5072 	}
5073 
5074 	reg_channels = pdev_priv_obj->cur_chan_list;
5075 
5076 	chan_state = reg_get_channel_state_for_pwrmode(pdev,
5077 						       oper_ch_freq,
5078 						       REG_CURRENT_PWR_MODE);
5079 	if (chan_state2 < chan_state)
5080 		chan_state = chan_state2;
5081 
5082 	if ((chan_state == CHANNEL_STATE_INVALID) ||
5083 	    (chan_state == CHANNEL_STATE_DISABLE))
5084 		return chan_state;
5085 
5086 	chan_idx = reg_get_chan_enum_for_freq(oper_ch_freq);
5087 	if (reg_is_chan_enum_invalid(chan_idx))
5088 		return CHANNEL_STATE_INVALID;
5089 	if (bw == CH_WIDTH_5MHZ)
5090 		bw_enabled = true;
5091 	else if (bw == CH_WIDTH_10MHZ)
5092 		bw_enabled = (reg_channels[chan_idx].min_bw <= 10) &&
5093 			(reg_channels[chan_idx].max_bw >= 10);
5094 	else if (bw == CH_WIDTH_20MHZ)
5095 		bw_enabled = (reg_channels[chan_idx].min_bw <= 20) &&
5096 			(reg_channels[chan_idx].max_bw >= 20);
5097 	else if (bw == CH_WIDTH_40MHZ)
5098 		bw_enabled = (reg_channels[chan_idx].min_bw <= 40) &&
5099 			(reg_channels[chan_idx].max_bw >= 40);
5100 
5101 	if (bw_enabled)
5102 		return chan_state;
5103 	else
5104 		return CHANNEL_STATE_DISABLE;
5105 
5106 	return CHANNEL_STATE_ENABLE;
5107 }
5108 
5109 #ifdef WLAN_FEATURE_11BE
5110 
5111 /**
5112  * reg_get_20mhz_channel_state_based_on_nol() - Get channel state of the
5113  * given 20MHZ channel. If the freq is in NOL/NOL history, it is considered
5114  * as enabled if "treat_nol_chan_as_disabled" is false, else the state is
5115  * considered as "disabled".
5116  * @pdev: Pointer to struct wlan_objmgr_pdev
5117  * @freq: Primary frequency
5118  * @treat_nol_chan_as_disabled: Flag to treat nol chan as enabled/disabled
5119  * @in_6g_pwr_type: Input 6g power type
5120  *
5121  * Return - Channel state
5122  */
5123 static enum channel_state
5124 reg_get_20mhz_channel_state_based_on_nol(struct wlan_objmgr_pdev *pdev,
5125 					 qdf_freq_t freq,
5126 					 bool treat_nol_chan_as_disabled,
5127 					 enum supported_6g_pwr_types in_6g_pwr_type)
5128 {
5129 	if (treat_nol_chan_as_disabled)
5130 		return  reg_get_channel_state_for_pwrmode(pdev, freq,
5131 							  in_6g_pwr_type);
5132 	return reg_get_nol_channel_state(pdev, freq,
5133 					 in_6g_pwr_type);
5134 }
5135 
5136 #define MAX_NUM_BONDED_PAIR 2
5137 
5138 /**
5139  * reg_get_320_bonded_chan_array() - Fetches a list of bonded channel pointers
5140  * for the given bonded channel array. If 320 band center is specified,
5141  * return the bonded channel pointer comprising of given band center else
5142  * return list of all available bonded channel pair.
5143  *
5144  * @pdev: Pointer to struct wlan_objmgr_pdev.
5145  * @freq: Input frequency in MHZ whose bonded channel pointer must be fetched.
5146  * @band_center_320: Channel center frequency of 320MHZ channel.
5147  * @bonded_chan_ar: Array of bonded channel list.
5148  * @array_size: Size of bonded channel array.
5149  * @bonded_chan_ptr: Pointer to hold the address of bonded_channel_freq index.
5150  *
5151  * Return: number of bonded channel arrays fetched.
5152  */
5153 static uint8_t
5154 reg_get_320_bonded_chan_array(struct wlan_objmgr_pdev *pdev,
5155 			      qdf_freq_t freq,
5156 			      qdf_freq_t band_center_320,
5157 			      const struct bonded_channel_freq bonded_chan_ar[],
5158 			      uint16_t array_size,
5159 			      const struct bonded_channel_freq
5160 			      *bonded_chan_ptr[])
5161 {
5162 	int i;
5163 	uint8_t num_bonded_pairs = 0;
5164 
5165 	/* Fetch all possible bonded channel pointers for the given freq */
5166 	if (!band_center_320) {
5167 		for (i = 0 ; i < array_size &&
5168 		     num_bonded_pairs < MAX_NUM_BONDED_PAIR; i++) {
5169 			if ((freq >= bonded_chan_ar[i].start_freq) &&
5170 			    (freq <= bonded_chan_ar[i].end_freq)) {
5171 				bonded_chan_ptr[num_bonded_pairs] =
5172 					&bonded_chan_ar[i];
5173 				num_bonded_pairs++;
5174 			}
5175 		}
5176 	} else {
5177 		/* Fetch the bonded channel pointer for the given band_center */
5178 		for (i = 0; i < array_size; i++) {
5179 			qdf_freq_t bandstart = bonded_chan_ar[i].start_freq;
5180 
5181 			if (band_center_320 ==
5182 			    reg_get_band_cen_from_bandstart(BW_320_MHZ,
5183 							    bandstart)) {
5184 				bonded_chan_ptr[num_bonded_pairs] =
5185 					&bonded_chan_ar[i];
5186 				num_bonded_pairs++;
5187 				break;
5188 			}
5189 		}
5190 	}
5191 	return num_bonded_pairs;
5192 }
5193 
5194 #define SUB_CHAN_BW 20 /* 20 MHZ */
5195 #define BW_160MHZ 160
5196 #define  REG_IS_TOT_CHAN_BW_BELOW_160(_x, _y) \
5197 	(reg_is_state_allowed((_x)) && (_y) < BW_160MHZ)
5198 #endif
5199 
5200 qdf_freq_t
5201 reg_get_endchan_cen_from_bandstart(qdf_freq_t band_start,
5202 				   uint16_t bw)
5203 {
5204 	uint16_t left_edge_freq = band_start - BW_10_MHZ;
5205 
5206 	return left_edge_freq + bw - BW_10_MHZ;
5207 }
5208 
5209 #ifdef WLAN_FEATURE_11BE
5210 enum channel_state
5211 reg_get_chan_state_for_320(struct wlan_objmgr_pdev *pdev,
5212 			   uint16_t freq,
5213 			   qdf_freq_t band_center_320,
5214 			   enum phy_ch_width ch_width,
5215 			   const struct bonded_channel_freq
5216 			   **bonded_chan_ptr_ptr,
5217 			   enum supported_6g_pwr_types in_6g_pwr_type,
5218 			   bool treat_nol_chan_as_disabled,
5219 			   uint16_t input_punc_bitmap)
5220 {
5221 	uint8_t num_bonded_pairs;
5222 	uint16_t array_size =
5223 		QDF_ARRAY_SIZE(bonded_chan_320mhz_list_freq);
5224 	const struct bonded_channel_freq *bonded_ch_ptr[2] = {
5225 		NULL, NULL};
5226 	uint16_t punct_pattern;
5227 
5228 	/* For now sending band center freq as 0 */
5229 	num_bonded_pairs =
5230 		reg_get_320_bonded_chan_array(pdev, freq, band_center_320,
5231 					      bonded_chan_320mhz_list_freq,
5232 					      array_size, bonded_ch_ptr);
5233 	if (!num_bonded_pairs) {
5234 		reg_info("No 320MHz bonded pair for freq %d", freq);
5235 		return CHANNEL_STATE_INVALID;
5236 	}
5237 	/* Taking only first bonded pair */
5238 	*bonded_chan_ptr_ptr = bonded_ch_ptr[0];
5239 
5240 	return reg_get_320_bonded_channel_state_for_pwrmode(pdev, freq,
5241 							    bonded_ch_ptr[0],
5242 							    ch_width,
5243 							    &punct_pattern,
5244 							    in_6g_pwr_type,
5245 							    treat_nol_chan_as_disabled,
5246 							    input_punc_bitmap);
5247 }
5248 #endif
5249 
5250 #ifdef WLAN_FEATURE_11BE
5251 #ifdef CONFIG_REG_CLIENT
5252 static void
5253 reg_verify_punc_for_320_and_set_channel_state(uint16_t punc_bitmap,
5254 					      enum channel_state *chan_state,
5255 					      enum channel_state update_state)
5256 {
5257 	if (reg_is_punc_bitmap_valid(CH_WIDTH_320MHZ, punc_bitmap)) {
5258 		*chan_state = update_state;
5259 	}
5260 }
5261 #else /* CONFIG_REG_CLIENT */
5262 static inline void
5263 reg_verify_punc_for_320_and_set_channel_state(uint16_t punc_bitmap,
5264 					      enum channel_state *chan_state,
5265 					      enum channel_state update_state)
5266 {
5267 }
5268 #endif /* CONFIG_REG_CLIENT */
5269 
5270 enum channel_state
5271 reg_get_320_bonded_channel_state_for_pwrmode(struct wlan_objmgr_pdev *pdev,
5272 					     qdf_freq_t freq,
5273 					     const struct bonded_channel_freq
5274 					     *bonded_chan_ptr,
5275 					     enum phy_ch_width bw,
5276 					     uint16_t *out_punc_bitmap,
5277 					     enum supported_6g_pwr_types
5278 					     in_6g_pwr_type,
5279 					     bool treat_nol_chan_as_disabled,
5280 					     uint16_t input_punc_bitmap)
5281 {
5282 	enum channel_state chan_state = CHANNEL_STATE_INVALID;
5283 	enum channel_state temp_chan_state, prim_chan_state;
5284 	uint16_t startchan_cfreq, endchan_cfreq;
5285 	uint16_t max_cont_bw, i;
5286 	enum channel_state update_state = CHANNEL_STATE_ENABLE;
5287 
5288 	*out_punc_bitmap = ALL_SCHANS_PUNC;
5289 
5290 	if (!bonded_chan_ptr)
5291 		return chan_state;
5292 
5293 	startchan_cfreq =  bonded_chan_ptr->start_freq;
5294 	endchan_cfreq =
5295 		reg_get_endchan_cen_from_bandstart(startchan_cfreq,
5296 						   BW_320_MHZ);
5297 	max_cont_bw = 0;
5298 	i = 0;
5299 
5300 	while (startchan_cfreq <= endchan_cfreq) {
5301 		if (!reg_is_chan_bit_punctured(input_punc_bitmap, i)) {
5302 			temp_chan_state =
5303 				reg_get_20mhz_channel_state_based_on_nol(pdev,
5304 									 startchan_cfreq,
5305 									 treat_nol_chan_as_disabled,
5306 									 in_6g_pwr_type);
5307 
5308 			if (reg_is_state_allowed(temp_chan_state)) {
5309 				max_cont_bw += SUB_CHAN_BW;
5310 				*out_punc_bitmap &= ~BIT(i);
5311 				/* Remember if sub20 channel is DFS channel */
5312 				if (temp_chan_state == CHANNEL_STATE_DFS)
5313 					update_state = CHANNEL_STATE_DFS;
5314 			}
5315 
5316 			if (temp_chan_state < chan_state)
5317 				chan_state = temp_chan_state;
5318 		}
5319 		startchan_cfreq = startchan_cfreq + SUB_CHAN_BW;
5320 		i++;
5321 	}
5322 
5323 	/* Validate puncture bitmap. Update channel state. */
5324 	reg_verify_punc_for_320_and_set_channel_state(*out_punc_bitmap,
5325 						      &chan_state,
5326 						      update_state);
5327 
5328 	prim_chan_state =
5329 		reg_get_20mhz_channel_state_based_on_nol(pdev, freq,
5330 							 treat_nol_chan_as_disabled,
5331 							 in_6g_pwr_type);
5332 
5333 	/* After iterating through all the subchannels, if the final channel
5334 	 * state is invalid/disable, it means all our subchannels are not
5335 	 * valid and we could not find a 320 MHZ channel.
5336 	 * If we have found a channel where the max width is:
5337 	 * 1. Less than 160: there is no puncturing needed. Hence return
5338 	 * the chan state as invalid. Or if the primary freq given is not
5339 	 * supported by regulatory, the channel cannot be enabled as a
5340 	 * punctured channel. So return channel state as invalid.
5341 	 * 2. If greater than 160: Mark the invalid channels as punctured.
5342 	 * and return channel state as ENABLE.
5343 	 */
5344 	if (REG_IS_TOT_CHAN_BW_BELOW_160(chan_state, max_cont_bw) ||
5345 		!reg_is_state_allowed(prim_chan_state))
5346 		return CHANNEL_STATE_INVALID;
5347 
5348 	return chan_state;
5349 }
5350 
5351 static inline bool reg_is_pri_within_240mhz_chan(qdf_freq_t freq)
5352 {
5353 	return (freq >= CHAN_FREQ_5660 && freq <= CHAN_FREQ_5720);
5354 }
5355 
5356 /**
5357  * reg_fill_chan320mhz_seg0_center() - Fill the primary segment center
5358  * for a 320MHz channel in the given channel param. Primary segment center
5359  * of a 320MHZ is the 160MHZ segment center of the given freq.
5360  * @pdev: Pointer to struct wlan_objmgr_pdev.
5361  * @ch_param: channel params to be filled.
5362  * @freq: Input primary frequency in MHZ.
5363  *
5364  * Return: void.
5365  */
5366 static void
5367 reg_fill_chan320mhz_seg0_center(struct wlan_objmgr_pdev *pdev,
5368 				struct ch_params *ch_param, qdf_freq_t freq)
5369 {
5370 	const struct bonded_channel_freq *t_bonded_ch_ptr;
5371 
5372 	t_bonded_ch_ptr = reg_get_bonded_chan_entry(freq, CH_WIDTH_160MHZ, 0);
5373 	if (t_bonded_ch_ptr) {
5374 		ch_param->mhz_freq_seg0 =
5375 			(t_bonded_ch_ptr->start_freq +
5376 			 t_bonded_ch_ptr->end_freq) / 2;
5377 		ch_param->center_freq_seg0 =
5378 			reg_freq_to_chan(pdev,
5379 					 ch_param->mhz_freq_seg0);
5380 	} else {
5381 		/**
5382 		 * If we do not find a 160Mhz  bonded  pair, since it is
5383 		 * for a 320Mhz channel we need to also see if we can find a
5384 		 * pseudo 160Mhz channel for the special case of
5385 		 * 5Ghz 240Mhz channel.
5386 		 */
5387 		if (reg_is_pri_within_240mhz_chan(freq)) {
5388 			ch_param->mhz_freq_seg0 =
5389 				PRIM_SEG_FREQ_CENTER_240MHZ_5G_CHAN;
5390 			ch_param->center_freq_seg0 =
5391 				PRIM_SEG_IEEE_CENTER_240MHZ_5G_CHAN;
5392 		} else {
5393 			ch_param->ch_width = CH_WIDTH_INVALID;
5394 			reg_debug("Cannot find 160 MHz centers for freq %d",
5395 				  freq);
5396 		}
5397 	}
5398 }
5399 
5400 /**
5401  * reg_fill_channel_list_for_320_for_pwrmode() - Fill 320MHZ channel list.
5402  * @pdev: Pointer to struct wlan_objmgr_pdev.
5403  * @freq: Input frequency in MHz.
5404  * @in_ch_width: Input channel width, if a channel of the given width is not
5405  * found, reduce the channel width to the next lower mode and pass it to the
5406  * caller.
5407  * @band_center_320: Center of 320 MHz channel.
5408  * @chan_list: Pointer to reg_channel_list to be filled.
5409  * @update_bw: Flag to hold if bw is updated.
5410  * @in_6g_pwr_mode: Input 6g power mode which decides the which power mode based
5411  * channel list will be chosen.
5412  * @treat_nol_chan_as_disabled: Bool to treat NOL channels as disabled/enabled
5413  *
5414  * If we are unable to find a channel whose width is greater than
5415  * 160 MHz and less than 320 with the help of puncturing, using the
5416  * given freq, set "update_bw" variable to be true, lower the channel
5417  * width and return to the caller.  The caller fetches a channel of
5418  * reduced mode based on "update_bw" flag.
5419  *
5420  * If 320 band center is 0, return all the 320 channels
5421  * that match the primary frequency else return only channel
5422  * that matches 320 band center.
5423  *
5424  *
5425  * Return - None.
5426  */
5427 static void
5428 reg_fill_channel_list_for_320_for_pwrmode(
5429 			      struct wlan_objmgr_pdev *pdev,
5430 			      qdf_freq_t freq,
5431 			      enum phy_ch_width *in_ch_width,
5432 			      qdf_freq_t band_center_320,
5433 			      struct reg_channel_list *chan_list,
5434 			      bool *update_bw,
5435 			      enum supported_6g_pwr_types in_6g_pwr_mode,
5436 			      bool treat_nol_chan_as_disabled)
5437 {
5438 	uint8_t num_bonded_pairs, i, num_ch_params;
5439 	enum channel_state chan_state;
5440 	uint16_t array_size = QDF_ARRAY_SIZE(bonded_chan_320mhz_list_freq);
5441 	uint16_t out_punc_bitmap;
5442 	uint16_t max_reg_bw;
5443 	enum channel_enum chan_enum;
5444 	const struct bonded_channel_freq *bonded_ch_ptr[2] = {NULL, NULL};
5445 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
5446 
5447 	*update_bw = false;
5448 
5449 	chan_enum = reg_get_chan_enum_for_freq(freq);
5450 	if (reg_is_chan_enum_invalid(chan_enum)) {
5451 		reg_err("chan freq is not valid");
5452 		return;
5453 	}
5454 
5455 	pdev_priv_obj = reg_get_pdev_obj(pdev);
5456 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
5457 		reg_err("reg pdev priv obj is NULL");
5458 		return;
5459 	}
5460 
5461 	/* Maximum bandwidth of the channel supported by regulatory for
5462 	 * the given freq.
5463 	 */
5464 	if (reg_get_min_max_bw_reg_chan_list(pdev, chan_enum, in_6g_pwr_mode,
5465 					     NULL, &max_reg_bw))
5466 		return;
5467 
5468 	/* Regulatory does not support BW greater than 160.
5469 	 * Try finding a channel in a lower mode.
5470 	 */
5471 	if (max_reg_bw <= BW_160MHZ) {
5472 		*in_ch_width =  get_next_lower_bandwidth(*in_ch_width);
5473 		*update_bw = true;
5474 		return;
5475 	}
5476 
5477 	num_bonded_pairs =
5478 		reg_get_320_bonded_chan_array(pdev, freq, band_center_320,
5479 					      bonded_chan_320mhz_list_freq,
5480 					      array_size,
5481 					      bonded_ch_ptr);
5482 
5483 	if (!num_bonded_pairs) {
5484 		if (band_center_320) {
5485 			reg_debug("No bonded pair for the given band_center\n");
5486 			chan_list->num_ch_params = 0;
5487 		} else {
5488 			/* Could not find a 320 MHZ bonded channel pair,
5489 			 * find a channel of lower BW.
5490 			 */
5491 			*in_ch_width =  get_next_lower_bandwidth(*in_ch_width);
5492 			*update_bw = true;
5493 		}
5494 		return;
5495 	}
5496 
5497 	for (i = 0, num_ch_params = 0 ; i < num_bonded_pairs; i++) {
5498 		uint16_t in_punc_bitmap =
5499 			chan_list->chan_param[i].input_punc_bitmap;
5500 
5501 		/* Chan_state to hold the channel state of bonding
5502 		 * pair of channels.
5503 		 */
5504 		chan_state =
5505 			reg_get_320_bonded_channel_state_for_pwrmode(pdev, freq,
5506 								     bonded_ch_ptr[i],
5507 								     *in_ch_width,
5508 								     &out_punc_bitmap,
5509 								     in_6g_pwr_mode,
5510 								     treat_nol_chan_as_disabled,
5511 								     in_punc_bitmap);
5512 
5513 		if (reg_is_state_allowed(chan_state)) {
5514 			struct ch_params *t_chan_param =
5515 			    &chan_list->chan_param[num_ch_params];
5516 			qdf_freq_t start_freq = bonded_ch_ptr[i]->start_freq;
5517 
5518 			t_chan_param->mhz_freq_seg1 =
5519 				reg_get_band_cen_from_bandstart(BW_320_MHZ,
5520 								start_freq);
5521 			t_chan_param->center_freq_seg1 =
5522 				reg_freq_to_chan(pdev,
5523 						 t_chan_param->mhz_freq_seg1);
5524 			t_chan_param->ch_width = *in_ch_width;
5525 			t_chan_param->reg_punc_bitmap = out_punc_bitmap;
5526 
5527 			reg_fill_chan320mhz_seg0_center(pdev,
5528 							t_chan_param,
5529 							freq);
5530 			num_ch_params++;
5531 			chan_list->num_ch_params = num_ch_params;
5532 		}
5533 	}
5534 
5535 	/* The bonded pairs could not create any channels,
5536 	 * lower the bandwidth to find a channel.
5537 	 */
5538 	if (!chan_list->num_ch_params) {
5539 		*in_ch_width =  get_next_lower_bandwidth(*in_ch_width);
5540 		*update_bw = true;
5541 	}
5542 }
5543 
5544 /**
5545  * reg_fill_pre320mhz_channel_for_pwrmode() - Fill channel params for channel
5546  * width less than 320.
5547  * @pdev: Pointer to struct wlan_objmgr_pdev
5548  * @chan_list: Pointer to struct reg_channel_list
5549  * @ch_width: Channel width
5550  * @freq: Center frequency of the primary channel in MHz
5551  * @sec_ch_2g_freq:  Secondary 2G channel frequency in MHZ
5552  * @in_6g_pwr_mode: Input 6g power mode which decides the which power mode based
5553  * channel list will be chosen.
5554  * @treat_nol_chan_as_disabled: Bool to consider nol chan as enabled/disabled
5555  */
5556 static void
5557 reg_fill_pre320mhz_channel_for_pwrmode(
5558 			   struct wlan_objmgr_pdev *pdev,
5559 			   struct reg_channel_list *chan_list,
5560 			   enum phy_ch_width ch_width,
5561 			   qdf_freq_t freq,
5562 			   qdf_freq_t sec_ch_2g_freq,
5563 			   enum supported_6g_pwr_types in_6g_pwr_mode,
5564 			   bool treat_nol_chan_as_disabled)
5565 {
5566 	chan_list->num_ch_params = 1;
5567 	chan_list->chan_param[0].ch_width = ch_width;
5568 	chan_list->chan_param[0].reg_punc_bitmap = NO_SCHANS_PUNC;
5569 	reg_set_channel_params_for_pwrmode(pdev, freq, sec_ch_2g_freq,
5570 					   &chan_list->chan_param[0],
5571 					   in_6g_pwr_mode,
5572 					   treat_nol_chan_as_disabled);
5573 }
5574 
5575 void
5576 reg_fill_channel_list_for_pwrmode(struct wlan_objmgr_pdev *pdev,
5577 				  qdf_freq_t freq,
5578 				  qdf_freq_t sec_ch_2g_freq,
5579 				  enum phy_ch_width in_ch_width,
5580 				  qdf_freq_t band_center_320,
5581 				  struct reg_channel_list *chan_list,
5582 				  enum supported_6g_pwr_types in_6g_pwr_mode,
5583 				  bool treat_nol_chan_as_disabled)
5584 {
5585 	bool update_bw;
5586 
5587 	if (!chan_list) {
5588 		reg_err("channel params is NULL");
5589 		return;
5590 	}
5591 
5592 	if (in_ch_width >= CH_WIDTH_MAX)
5593 		in_ch_width = CH_WIDTH_320MHZ;
5594 
5595 	if (in_ch_width == CH_WIDTH_320MHZ) {
5596 		update_bw = 0;
5597 		reg_fill_channel_list_for_320_for_pwrmode(
5598 					      pdev, freq, &in_ch_width,
5599 					      band_center_320, chan_list,
5600 					      &update_bw, in_6g_pwr_mode,
5601 					      treat_nol_chan_as_disabled);
5602 		if (!update_bw)
5603 			return;
5604 	}
5605 
5606 	/* A 320 channel is not available (or) user has not requested
5607 	 * for a 320MHZ channel, look for channels in lower modes,
5608 	 * reg_set_5g_channel_params_for_freq() finds for the
5609 	 * next available mode and fills ch_params.
5610 	 */
5611 	reg_fill_pre320mhz_channel_for_pwrmode(
5612 				   pdev, chan_list, in_ch_width, freq,
5613 				   sec_ch_2g_freq, in_6g_pwr_mode,
5614 				   treat_nol_chan_as_disabled);
5615 }
5616 #endif
5617 
5618 enum channel_state
5619 reg_get_5g_bonded_channel_for_pwrmode(struct wlan_objmgr_pdev *pdev,
5620 				      uint16_t freq,
5621 				      enum phy_ch_width ch_width,
5622 				      const struct bonded_channel_freq
5623 				      **bonded_chan_ptr_ptr,
5624 				      enum supported_6g_pwr_types
5625 				      in_6g_pwr_mode,
5626 				      uint16_t input_punc_bitmap)
5627 {
5628 	if (ch_width == CH_WIDTH_20MHZ)
5629 		return reg_get_channel_state_for_pwrmode(pdev, freq,
5630 						      in_6g_pwr_mode);
5631 
5632 	if (reg_is_ch_width_320(ch_width))
5633 		return reg_get_chan_state_for_320(pdev, freq, 0,
5634 						  ch_width,
5635 						  bonded_chan_ptr_ptr,
5636 						  in_6g_pwr_mode, true,
5637 						  input_punc_bitmap);
5638 	/* Fetch the bonded_chan_ptr for width greater than 20MHZ. */
5639 	*bonded_chan_ptr_ptr = reg_get_bonded_chan_entry(freq, ch_width, 0);
5640 
5641 	if (!(*bonded_chan_ptr_ptr)) {
5642 		reg_debug_rl("bonded_chan_ptr_ptr is NULL");
5643 		return CHANNEL_STATE_INVALID;
5644 	}
5645 
5646 	return reg_get_5g_bonded_chan_array_for_pwrmode(pdev, freq,
5647 						     *bonded_chan_ptr_ptr,
5648 						     in_6g_pwr_mode,
5649 						     input_punc_bitmap);
5650 }
5651 
5652 #ifdef CONFIG_REG_6G_PWRMODE
5653 /**
5654  * reg_set_5g_channel_params_for_pwrmode()- Set channel parameters like center
5655  * frequency for a bonded channel state. Also return the maximum bandwidth
5656  * supported by the channel.
5657  * @pdev: Pointer to pdev.
5658  * @freq: Channel center frequency.
5659  * @ch_params: Pointer to ch_params.
5660  * @in_6g_pwr_type: Input 6g power mode which decides the which power mode based
5661  * channel list will be chosen.
5662  * @treat_nol_chan_as_disabled: Bool to treat NOL channels as disabled/enabled
5663  *
5664  * Return: void
5665  */
5666 static void reg_set_5g_channel_params_for_pwrmode(
5667 					       struct wlan_objmgr_pdev *pdev,
5668 					       uint16_t freq,
5669 					       struct ch_params *ch_params,
5670 					       enum supported_6g_pwr_types
5671 					       in_6g_pwr_type,
5672 					       bool treat_nol_chan_as_disabled)
5673 {
5674 	/*
5675 	 * Set channel parameters like center frequency for a bonded channel
5676 	 * state. Also return the maximum bandwidth supported by the channel.
5677 	 */
5678 
5679 	enum channel_state chan_state = CHANNEL_STATE_ENABLE;
5680 	enum channel_state chan_state2 = CHANNEL_STATE_ENABLE;
5681 	const struct bonded_channel_freq *bonded_chan_ptr = NULL;
5682 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
5683 	enum channel_enum chan_enum, sec_5g_chan_enum;
5684 	uint16_t bw_80 = 0;
5685 	uint16_t max_bw, sec_5g_freq_max_bw = 0;
5686 	uint16_t in_punc_bitmap = reg_fetch_punc_bitmap(ch_params);
5687 
5688 	if (!ch_params) {
5689 		reg_err("ch_params is NULL");
5690 		return;
5691 	}
5692 
5693 	chan_enum = reg_get_chan_enum_for_freq(freq);
5694 	if (reg_is_chan_enum_invalid(chan_enum)) {
5695 		reg_err("chan freq is not valid");
5696 		return;
5697 	}
5698 
5699 	pdev_priv_obj = reg_get_pdev_obj(pdev);
5700 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
5701 		reg_err("reg pdev priv obj is NULL");
5702 		return;
5703 	}
5704 
5705 	if (ch_params->ch_width >= CH_WIDTH_MAX) {
5706 		if (ch_params->mhz_freq_seg1 != 0)
5707 			ch_params->ch_width = CH_WIDTH_80P80MHZ;
5708 		else
5709 			ch_params->ch_width = CH_WIDTH_160MHZ;
5710 	}
5711 
5712 	if (reg_get_min_max_bw_reg_chan_list(pdev, chan_enum, in_6g_pwr_type,
5713 					     NULL, &max_bw))
5714 		return;
5715 
5716 	bw_80 = reg_get_bw_value(CH_WIDTH_80MHZ);
5717 
5718 	if (ch_params->ch_width == CH_WIDTH_80P80MHZ) {
5719 		sec_5g_chan_enum =
5720 			reg_get_chan_enum_for_freq(ch_params->mhz_freq_seg1 -
5721 					NEAREST_20MHZ_CHAN_FREQ_OFFSET);
5722 		if (reg_is_chan_enum_invalid(sec_5g_chan_enum)) {
5723 			reg_err("secondary channel freq is not valid");
5724 			return;
5725 		}
5726 
5727 		if (reg_get_min_max_bw_reg_chan_list(pdev, sec_5g_chan_enum,
5728 						     in_6g_pwr_type,
5729 						     NULL, &sec_5g_freq_max_bw))
5730 			return;
5731 	}
5732 
5733 	while (ch_params->ch_width != CH_WIDTH_INVALID) {
5734 		if (ch_params->ch_width == CH_WIDTH_80P80MHZ) {
5735 			if ((max_bw < bw_80) || (sec_5g_freq_max_bw < bw_80))
5736 				goto update_bw;
5737 		} else if (max_bw < reg_get_bw_value(ch_params->ch_width)) {
5738 			goto update_bw;
5739 		}
5740 
5741 		bonded_chan_ptr = NULL;
5742 		chan_state = reg_get_5g_bonded_channel_for_pwrmode(
5743 				pdev, freq, ch_params->ch_width,
5744 				&bonded_chan_ptr, in_6g_pwr_type,
5745 				in_punc_bitmap);
5746 		chan_state =
5747 			reg_get_ch_state_based_on_nol_flag(pdev, freq,
5748 							   ch_params,
5749 							   in_6g_pwr_type,
5750 							   treat_nol_chan_as_disabled);
5751 
5752 		if (ch_params->ch_width == CH_WIDTH_80P80MHZ) {
5753 			struct ch_params temp_ch_params = {0};
5754 
5755 			temp_ch_params.ch_width = CH_WIDTH_80MHZ;
5756 			/* Puncturing pattern is not needed for 80+80 */
5757 			reg_set_create_punc_bitmap(&temp_ch_params, false);
5758 			chan_state2 =
5759 				reg_get_ch_state_based_on_nol_flag(pdev,
5760 								   ch_params->mhz_freq_seg1 -
5761 								   NEAREST_20MHZ_CHAN_FREQ_OFFSET,
5762 								   &temp_ch_params, in_6g_pwr_type,
5763 								   treat_nol_chan_as_disabled);
5764 			chan_state = reg_combine_channel_states(
5765 					chan_state, chan_state2);
5766 		}
5767 
5768 		if ((chan_state != CHANNEL_STATE_ENABLE) &&
5769 		    (chan_state != CHANNEL_STATE_DFS))
5770 			goto update_bw;
5771 		if (ch_params->ch_width <= CH_WIDTH_20MHZ) {
5772 			ch_params->sec_ch_offset = NO_SEC_CH;
5773 			ch_params->mhz_freq_seg0 = freq;
5774 				ch_params->center_freq_seg0 =
5775 				reg_freq_to_chan(pdev,
5776 						 ch_params->mhz_freq_seg0);
5777 			break;
5778 		} else if (ch_params->ch_width >= CH_WIDTH_40MHZ) {
5779 			const struct bonded_channel_freq *bonded_chan_ptr2;
5780 
5781 			bonded_chan_ptr2 =
5782 					reg_get_bonded_chan_entry(
5783 								freq,
5784 								CH_WIDTH_40MHZ,
5785 								0);
5786 
5787 			if (!bonded_chan_ptr || !bonded_chan_ptr2)
5788 				goto update_bw;
5789 			if (freq == bonded_chan_ptr2->start_freq)
5790 				ch_params->sec_ch_offset = LOW_PRIMARY_CH;
5791 			else
5792 				ch_params->sec_ch_offset = HIGH_PRIMARY_CH;
5793 
5794 			ch_params->mhz_freq_seg0 =
5795 				(bonded_chan_ptr->start_freq +
5796 				 bonded_chan_ptr->end_freq) / 2;
5797 				ch_params->center_freq_seg0 =
5798 				reg_freq_to_chan(pdev,
5799 						 ch_params->mhz_freq_seg0);
5800 			break;
5801 		}
5802 update_bw:
5803 		ch_params->ch_width =
5804 		    get_next_lower_bandwidth(ch_params->ch_width);
5805 	}
5806 
5807 	if (ch_params->ch_width == CH_WIDTH_160MHZ) {
5808 		ch_params->mhz_freq_seg1 = ch_params->mhz_freq_seg0;
5809 			ch_params->center_freq_seg1 =
5810 				reg_freq_to_chan(pdev,
5811 						 ch_params->mhz_freq_seg1);
5812 
5813 		chan_state = reg_get_5g_bonded_channel_for_pwrmode(
5814 				pdev, freq, CH_WIDTH_80MHZ, &bonded_chan_ptr,
5815 				in_6g_pwr_type,
5816 				in_punc_bitmap);
5817 		if (bonded_chan_ptr) {
5818 			ch_params->mhz_freq_seg0 =
5819 				(bonded_chan_ptr->start_freq +
5820 				 bonded_chan_ptr->end_freq) / 2;
5821 				ch_params->center_freq_seg0 =
5822 				reg_freq_to_chan(pdev,
5823 						 ch_params->mhz_freq_seg0);
5824 		}
5825 	}
5826 
5827 	/* Overwrite mhz_freq_seg1 to 0 for non 160 and 80+80 width */
5828 	if (!(ch_params->ch_width == CH_WIDTH_160MHZ ||
5829 	      ch_params->ch_width == CH_WIDTH_80P80MHZ)) {
5830 		ch_params->mhz_freq_seg1 = 0;
5831 		ch_params->center_freq_seg1 = 0;
5832 	}
5833 }
5834 #endif
5835 
5836 #ifdef CONFIG_REG_CLIENT
5837 static qdf_freq_t reg_get_sec_ch_2g_freq(struct wlan_objmgr_pdev *pdev,
5838 					 qdf_freq_t primary_freq)
5839 {
5840 	qdf_freq_t sec_ch_2g_freq = 0;
5841 
5842 	if (primary_freq >= TWOG_CHAN_1_IN_MHZ &&
5843 	    primary_freq <= TWOG_CHAN_5_IN_MHZ)
5844 		sec_ch_2g_freq = primary_freq + HT40_SEC_OFFSET;
5845 	else if (primary_freq >= TWOG_CHAN_6_IN_MHZ &&
5846 		 primary_freq <= TWOG_CHAN_13_IN_MHZ)
5847 		sec_ch_2g_freq = primary_freq - HT40_SEC_OFFSET;
5848 
5849 	return sec_ch_2g_freq;
5850 }
5851 #else
5852 static qdf_freq_t reg_get_sec_ch_2g_freq(struct wlan_objmgr_pdev *pdev,
5853 					 qdf_freq_t primary_freq)
5854 {
5855 	qdf_freq_t sec_ch_2g_freq;
5856 
5857 	if (primary_freq < TWOG_CHAN_1_IN_MHZ ||
5858 	    primary_freq > TWOG_CHAN_13_IN_MHZ)
5859 		return 0;
5860 
5861 	sec_ch_2g_freq = primary_freq + HT40_SEC_OFFSET;
5862 
5863 	/* For 2G primary frequencies > 2452 (IEEE9), return HT40-. */
5864 	if (primary_freq > TWOG_CHAN_9_IN_MHZ)
5865 		sec_ch_2g_freq = primary_freq - HT40_SEC_OFFSET;
5866 
5867 	/*
5868 	 * For 2G primary frequencies <= 2452 (IEEE9), return HT40+ if
5869 	 * the secondary is available, else return HT40-.
5870 	 */
5871 	else if (!reg_is_freq_present_in_cur_chan_list(pdev, sec_ch_2g_freq))
5872 		sec_ch_2g_freq = primary_freq - HT40_SEC_OFFSET;
5873 
5874 	return sec_ch_2g_freq;
5875 }
5876 #endif
5877 
5878 void reg_set_2g_channel_params_for_freq(struct wlan_objmgr_pdev *pdev,
5879 					uint16_t oper_freq,
5880 					struct ch_params *ch_params,
5881 					uint16_t sec_ch_2g_freq)
5882 {
5883 	enum channel_state chan_state = CHANNEL_STATE_ENABLE;
5884 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
5885 	enum channel_enum chan_enum;
5886 	uint16_t max_bw;
5887 
5888 	chan_enum = reg_get_chan_enum_for_freq(oper_freq);
5889 	if (reg_is_chan_enum_invalid(chan_enum)) {
5890 		reg_err("chan freq is not valid");
5891 		return;
5892 	}
5893 
5894 	pdev_priv_obj = reg_get_pdev_obj(pdev);
5895 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
5896 		reg_err("reg pdev priv obj is NULL");
5897 		return;
5898 	}
5899 
5900 	if (ch_params->ch_width >= CH_WIDTH_MAX)
5901 		ch_params->ch_width = CH_WIDTH_40MHZ;
5902 	if ((reg_get_bw_value(ch_params->ch_width) > 20) && !sec_ch_2g_freq)
5903 		sec_ch_2g_freq = reg_get_sec_ch_2g_freq(pdev, oper_freq);
5904 
5905 	max_bw = pdev_priv_obj->cur_chan_list[chan_enum].max_bw;
5906 
5907 	while (ch_params->ch_width != CH_WIDTH_INVALID) {
5908 		if (max_bw < reg_get_bw_value(ch_params->ch_width))
5909 			goto update_bw;
5910 
5911 		chan_state =
5912 		reg_get_2g_bonded_channel_state_for_freq(pdev, oper_freq,
5913 							 sec_ch_2g_freq,
5914 							 ch_params->ch_width);
5915 		if ((chan_state == CHANNEL_STATE_ENABLE) ||
5916 		    (chan_state == CHANNEL_STATE_DFS)) {
5917 			if (ch_params->ch_width == CH_WIDTH_40MHZ) {
5918 				if (oper_freq < sec_ch_2g_freq)
5919 					ch_params->sec_ch_offset =
5920 						LOW_PRIMARY_CH;
5921 				else
5922 					ch_params->sec_ch_offset =
5923 						HIGH_PRIMARY_CH;
5924 				ch_params->mhz_freq_seg0 =
5925 					(oper_freq + sec_ch_2g_freq) / 2;
5926 				if (ch_params->mhz_freq_seg0 ==
5927 						TWOG_CHAN_14_IN_MHZ)
5928 					ch_params->center_freq_seg0 = 14;
5929 				else
5930 					ch_params->center_freq_seg0 =
5931 						(ch_params->mhz_freq_seg0 -
5932 						 TWOG_STARTING_FREQ) /
5933 						FREQ_TO_CHAN_SCALE;
5934 			} else {
5935 				ch_params->sec_ch_offset = NO_SEC_CH;
5936 				ch_params->mhz_freq_seg0 = oper_freq;
5937 				if (ch_params->mhz_freq_seg0 ==
5938 						TWOG_CHAN_14_IN_MHZ)
5939 					ch_params->center_freq_seg0 = 14;
5940 				else
5941 					ch_params->center_freq_seg0 =
5942 						(ch_params->mhz_freq_seg0 -
5943 						 TWOG_STARTING_FREQ) /
5944 						FREQ_TO_CHAN_SCALE;
5945 			}
5946 			break;
5947 		}
5948 update_bw:
5949 		ch_params->ch_width =
5950 		    get_next_lower_bandwidth(ch_params->ch_width);
5951 	}
5952 	/* Overwrite mhz_freq_seg1 and center_freq_seg1 to 0 for 2.4 Ghz */
5953 	ch_params->mhz_freq_seg1 = 0;
5954 	ch_params->center_freq_seg1 = 0;
5955 }
5956 
5957 #ifdef WLAN_FEATURE_11BE
5958 static void reg_copy_ch_params(struct ch_params *ch_params,
5959 			       struct reg_channel_list chan_list)
5960 {
5961 	ch_params->center_freq_seg0 = chan_list.chan_param[0].center_freq_seg0;
5962 	ch_params->center_freq_seg1 = chan_list.chan_param[0].center_freq_seg1;
5963 	ch_params->mhz_freq_seg0 = chan_list.chan_param[0].mhz_freq_seg0;
5964 	ch_params->mhz_freq_seg1 = chan_list.chan_param[0].mhz_freq_seg1;
5965 	ch_params->ch_width = chan_list.chan_param[0].ch_width;
5966 	ch_params->sec_ch_offset = chan_list.chan_param[0].sec_ch_offset;
5967 	ch_params->reg_punc_bitmap = chan_list.chan_param[0].reg_punc_bitmap;
5968 }
5969 #endif /* WLAN_FEATURE_11BE */
5970 
5971 #ifdef CONFIG_REG_6G_PWRMODE
5972 #ifdef WLAN_FEATURE_11BE
5973 void
5974 reg_set_channel_params_for_pwrmode(struct wlan_objmgr_pdev *pdev,
5975 				   qdf_freq_t freq,
5976 				   qdf_freq_t sec_ch_2g_freq,
5977 				   struct ch_params *ch_params,
5978 				   enum supported_6g_pwr_types in_6g_pwr_mode,
5979 				   bool is_treat_nol_dis)
5980 {
5981 	if (reg_is_5ghz_ch_freq(freq) || reg_is_6ghz_chan_freq(freq)) {
5982 		if (reg_is_ch_width_320(ch_params->ch_width)) {
5983 			struct reg_channel_list chan_list;
5984 			uint8_t i;
5985 
5986 			qdf_mem_zero(&chan_list, sizeof(chan_list));
5987 
5988 			for (i = 0; i < MAX_NUM_CHAN_PARAM; i++) {
5989 				chan_list.chan_param[i].input_punc_bitmap =
5990 					ch_params->input_punc_bitmap;
5991 			}
5992 			reg_fill_channel_list_for_pwrmode(pdev, freq,
5993 							  sec_ch_2g_freq,
5994 							  ch_params->ch_width,
5995 							  ch_params->mhz_freq_seg1,
5996 							  &chan_list,
5997 							  in_6g_pwr_mode,
5998 							  is_treat_nol_dis);
5999 			reg_copy_ch_params(ch_params, chan_list);
6000 		} else {
6001 			reg_set_5g_channel_params_for_pwrmode(pdev, freq,
6002 							      ch_params,
6003 							      in_6g_pwr_mode,
6004 							      is_treat_nol_dis);
6005 		}
6006 	} else if  (reg_is_24ghz_ch_freq(freq)) {
6007 		reg_set_2g_channel_params_for_freq(pdev, freq, ch_params,
6008 						   sec_ch_2g_freq);
6009 	}
6010 }
6011 #else
6012 void
6013 reg_set_channel_params_for_pwrmode(struct wlan_objmgr_pdev *pdev,
6014 				   qdf_freq_t freq,
6015 				   qdf_freq_t sec_ch_2g_freq,
6016 				   struct ch_params *ch_params,
6017 				   enum supported_6g_pwr_types in_6g_pwr_mode,
6018 				   bool is_treat_nol_dis)
6019 {
6020 	if (reg_is_5ghz_ch_freq(freq) || reg_is_6ghz_chan_freq(freq))
6021 		reg_set_5g_channel_params_for_pwrmode(pdev, freq, ch_params,
6022 						      in_6g_pwr_mode,
6023 						      is_treat_nol_dis);
6024 	else if  (reg_is_24ghz_ch_freq(freq))
6025 		reg_set_2g_channel_params_for_freq(pdev, freq, ch_params,
6026 						   sec_ch_2g_freq);
6027 }
6028 #endif
6029 #endif
6030 
6031 uint8_t reg_get_channel_reg_power_for_freq(struct wlan_objmgr_pdev *pdev,
6032 					   qdf_freq_t freq)
6033 {
6034 	enum channel_enum chan_enum;
6035 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
6036 	struct regulatory_channel *reg_channels;
6037 
6038 	chan_enum = reg_get_chan_enum_for_freq(freq);
6039 
6040 	if (reg_is_chan_enum_invalid(chan_enum)) {
6041 		reg_err("channel is invalid");
6042 		return REG_INVALID_TXPOWER;
6043 	}
6044 
6045 	pdev_priv_obj = reg_get_pdev_obj(pdev);
6046 
6047 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
6048 		reg_err("reg pdev priv obj is NULL");
6049 		return REG_INVALID_TXPOWER;
6050 	}
6051 
6052 	reg_channels = pdev_priv_obj->cur_chan_list;
6053 
6054 	return reg_channels[chan_enum].tx_power;
6055 }
6056 
6057 bool reg_is_dfs_for_freq(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq)
6058 {
6059 	uint32_t chan_flags;
6060 
6061 	chan_flags = reg_get_channel_flags_for_freq(pdev, freq);
6062 
6063 	return chan_flags & REGULATORY_CHAN_RADAR;
6064 }
6065 
6066 #ifdef CONFIG_REG_CLIENT
6067 bool reg_is_dfs_in_secondary_list_for_freq(struct wlan_objmgr_pdev *pdev,
6068 					   qdf_freq_t freq)
6069 {
6070 	uint32_t chan_flags;
6071 
6072 	chan_flags = reg_get_channel_flags_from_secondary_list_for_freq(pdev,
6073 									freq);
6074 
6075 	return chan_flags & REGULATORY_CHAN_RADAR;
6076 }
6077 
6078 /**
6079  * reg_get_psoc_mas_chan_list() - Get psoc master channel list
6080  * @pdev: pointer to pdev object
6081  * @psoc: pointer to psoc object
6082  *
6083  * Return: psoc master channel list
6084  */
6085 static struct regulatory_channel *reg_get_psoc_mas_chan_list(
6086 						struct wlan_objmgr_pdev *pdev,
6087 						struct wlan_objmgr_psoc *psoc)
6088 {
6089 	struct wlan_regulatory_psoc_priv_obj *soc_reg;
6090 	uint8_t pdev_id;
6091 	uint8_t phy_id;
6092 	struct wlan_lmac_if_reg_tx_ops *reg_tx_ops;
6093 
6094 	soc_reg = reg_get_psoc_obj(psoc);
6095 	if (!soc_reg) {
6096 		reg_err("reg psoc private obj is NULL");
6097 		return NULL;
6098 	}
6099 	pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev);
6100 
6101 	reg_tx_ops = reg_get_psoc_tx_ops(psoc);
6102 	if (reg_tx_ops->get_phy_id_from_pdev_id)
6103 		reg_tx_ops->get_phy_id_from_pdev_id(psoc, pdev_id, &phy_id);
6104 	else
6105 		phy_id = pdev_id;
6106 
6107 	return soc_reg->mas_chan_params[phy_id].mas_chan_list;
6108 }
6109 #else
6110 static inline struct regulatory_channel *reg_get_psoc_mas_chan_list(
6111 						struct wlan_objmgr_pdev *pdev,
6112 						struct wlan_objmgr_psoc *psoc)
6113 {
6114 	return NULL;
6115 }
6116 #endif
6117 
6118 void reg_update_nol_ch_for_freq(struct wlan_objmgr_pdev *pdev,
6119 				uint16_t *chan_freq_list,
6120 				uint8_t num_chan,
6121 				bool nol_chan)
6122 {
6123 	enum channel_enum chan_enum;
6124 	struct regulatory_channel *mas_chan_list = NULL, *psoc_mas_chan_list;
6125 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
6126 	struct wlan_objmgr_psoc *psoc;
6127 	uint16_t i;
6128 
6129 	if (!num_chan || !chan_freq_list) {
6130 		reg_err("chan_freq_list or num_ch is NULL");
6131 		return;
6132 	}
6133 
6134 	psoc = wlan_pdev_get_psoc(pdev);
6135 
6136 
6137 	psoc_mas_chan_list = reg_get_psoc_mas_chan_list(pdev, psoc);
6138 	pdev_priv_obj = reg_get_pdev_obj(pdev);
6139 
6140 	if (pdev_priv_obj)
6141 		mas_chan_list = pdev_priv_obj->mas_chan_list;
6142 
6143 	for (i = 0; i < num_chan; i++) {
6144 		chan_enum = reg_get_chan_enum_for_freq(chan_freq_list[i]);
6145 		if (reg_is_chan_enum_invalid(chan_enum)) {
6146 			reg_err("Invalid freq in nol list, freq %d",
6147 				chan_freq_list[i]);
6148 			continue;
6149 		}
6150 		if (mas_chan_list)
6151 			mas_chan_list[chan_enum].nol_chan = nol_chan;
6152 		if (psoc_mas_chan_list)
6153 			psoc_mas_chan_list[chan_enum].nol_chan = nol_chan;
6154 	}
6155 
6156 	if (!pdev_priv_obj) {
6157 		reg_err("reg pdev private obj is NULL");
6158 		return;
6159 	}
6160 
6161 	reg_compute_pdev_current_chan_list(pdev_priv_obj);
6162 
6163 	reg_send_scheduler_msg_sb(psoc, pdev);
6164 }
6165 
6166 void reg_update_nol_history_ch_for_freq(struct wlan_objmgr_pdev *pdev,
6167 					uint16_t *chan_list,
6168 					uint8_t num_chan,
6169 					bool nol_history_chan)
6170 {
6171 	enum channel_enum chan_enum;
6172 	struct regulatory_channel *mas_chan_list;
6173 	struct regulatory_channel *cur_chan_list;
6174 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
6175 	uint16_t i;
6176 
6177 	if (!num_chan || !chan_list) {
6178 		reg_err("chan_list or num_ch is NULL");
6179 		return;
6180 	}
6181 
6182 	pdev_priv_obj = wlan_objmgr_pdev_get_comp_private_obj(
6183 			pdev, WLAN_UMAC_COMP_REGULATORY);
6184 
6185 	if (!pdev_priv_obj) {
6186 		reg_err("reg psoc private obj is NULL");
6187 		return;
6188 	}
6189 
6190 	mas_chan_list = pdev_priv_obj->mas_chan_list;
6191 	cur_chan_list = pdev_priv_obj->cur_chan_list;
6192 
6193 	for (i = 0; i < num_chan; i++) {
6194 		chan_enum = reg_get_chan_enum_for_freq(chan_list[i]);
6195 		if (reg_is_chan_enum_invalid(chan_enum)) {
6196 			reg_err("Invalid ch in nol list, chan %d",
6197 				chan_list[i]);
6198 			continue;
6199 		}
6200 		mas_chan_list[chan_enum].nol_history = nol_history_chan;
6201 		cur_chan_list[chan_enum].nol_history = nol_history_chan;
6202 	}
6203 }
6204 
6205 qdf_freq_t reg_min_chan_freq(void)
6206 {
6207 	return channel_map[MIN_24GHZ_CHANNEL].center_freq;
6208 }
6209 
6210 qdf_freq_t reg_max_chan_freq(void)
6211 {
6212 	return channel_map[NUM_CHANNELS - 1].center_freq;
6213 }
6214 
6215 bool reg_is_same_band_freqs(qdf_freq_t freq1, qdf_freq_t freq2)
6216 {
6217 	return (freq1 && freq2 && ((REG_IS_6GHZ_FREQ(freq1) &&
6218 				    REG_IS_6GHZ_FREQ(freq2)) ||
6219 				   (REG_IS_5GHZ_FREQ(freq1) &&
6220 				    REG_IS_5GHZ_FREQ(freq2)) ||
6221 				   (REG_IS_24GHZ_CH_FREQ(freq1) &&
6222 				    REG_IS_24GHZ_CH_FREQ(freq2))));
6223 }
6224 
6225 enum reg_wifi_band reg_freq_to_band(qdf_freq_t freq)
6226 {
6227 	if (!freq)
6228 		return REG_BAND_UNKNOWN;
6229 
6230 	if (REG_IS_24GHZ_CH_FREQ(freq))
6231 		return REG_BAND_2G;
6232 	else if (REG_IS_5GHZ_FREQ(freq) || REG_IS_49GHZ_FREQ(freq))
6233 		return REG_BAND_5G;
6234 	else if (REG_IS_6GHZ_FREQ(freq))
6235 		return REG_BAND_6G;
6236 	return REG_BAND_UNKNOWN;
6237 }
6238 
6239 #ifdef CONFIG_REG_6G_PWRMODE
6240 bool reg_is_disable_for_pwrmode(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq,
6241 				enum supported_6g_pwr_types in_6g_pwr_mode)
6242 {
6243 	enum channel_state ch_state;
6244 
6245 	ch_state = reg_get_channel_state_for_pwrmode(pdev,
6246 						     freq,
6247 						     in_6g_pwr_mode);
6248 
6249 	return (ch_state == CHANNEL_STATE_DISABLE) ||
6250 		(ch_state == CHANNEL_STATE_INVALID);
6251 }
6252 #endif
6253 
6254 #ifdef CONFIG_REG_CLIENT
6255 bool reg_is_disable_in_secondary_list_for_freq(struct wlan_objmgr_pdev *pdev,
6256 					       qdf_freq_t freq)
6257 {
6258 	enum channel_state ch_state;
6259 
6260 	ch_state = reg_get_channel_state_from_secondary_list_for_freq(pdev,
6261 								      freq);
6262 
6263 	return ch_state == CHANNEL_STATE_DISABLE;
6264 }
6265 
6266 bool reg_is_enable_in_secondary_list_for_freq(struct wlan_objmgr_pdev *pdev,
6267 					      qdf_freq_t freq)
6268 {
6269 	enum channel_state ch_state;
6270 
6271 	ch_state = reg_get_channel_state_from_secondary_list_for_freq(pdev,
6272 								      freq);
6273 
6274 	return ch_state == CHANNEL_STATE_ENABLE;
6275 }
6276 
6277 #ifdef CONFIG_BAND_6GHZ
6278 static uint8_t reg_get_max_tx_power_from_super_chan_list(
6279 			struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj,
6280 			enum supported_6g_pwr_types in_6g_pwr_type)
6281 {
6282 	struct super_chan_info *sc_entry;
6283 	enum supported_6g_pwr_types pwr_type;
6284 	uint8_t i, max_tx_power = 0;
6285 
6286 	pwr_type = in_6g_pwr_type;
6287 	for (i = 0; i < NUM_6GHZ_CHANNELS; i++) {
6288 		sc_entry = &pdev_priv_obj->super_chan_list[i];
6289 
6290 		if (in_6g_pwr_type == REG_BEST_PWR_MODE)
6291 			pwr_type = sc_entry->best_power_mode;
6292 
6293 		if (reg_is_supp_pwr_mode_invalid(pwr_type))
6294 			continue;
6295 
6296 		if (!reg_is_chan_disabled(sc_entry->chan_flags_arr[pwr_type],
6297 					  sc_entry->state_arr[pwr_type]) &&
6298 		    (sc_entry->reg_chan_pwr[pwr_type].tx_power > max_tx_power))
6299 			max_tx_power =
6300 				sc_entry->reg_chan_pwr[pwr_type].tx_power;
6301 	}
6302 	return max_tx_power;
6303 }
6304 #else
6305 static inline uint8_t reg_get_max_tx_power_from_super_chan_list(
6306 			struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj,
6307 			enum supported_6g_pwr_types in_6g_pwr_type)
6308 {
6309 	return 0;
6310 }
6311 #endif
6312 
6313 uint8_t reg_get_max_tx_power_for_pwr_mode(
6314 				struct wlan_objmgr_pdev *pdev,
6315 				enum supported_6g_pwr_types in_6g_pwr_type)
6316 {
6317 	uint8_t i, max_tx_power = 0, max_super_chan_power = 0;
6318 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
6319 	uint16_t max_curr_num_chan;
6320 
6321 	if (!pdev) {
6322 		reg_err_rl("invalid pdev");
6323 		return QDF_STATUS_E_INVAL;
6324 	}
6325 
6326 	pdev_priv_obj = reg_get_pdev_obj(pdev);
6327 
6328 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
6329 		reg_err_rl("reg pdev priv obj is NULL");
6330 		return QDF_STATUS_E_INVAL;
6331 	}
6332 
6333 	if (in_6g_pwr_type == REG_CURRENT_PWR_MODE)
6334 		max_curr_num_chan = NUM_CHANNELS;
6335 	else
6336 		max_curr_num_chan = MAX_5GHZ_CHANNEL;
6337 
6338 	for (i = 0; i < max_curr_num_chan; i++) {
6339 		if (!reg_is_chan_disabled(
6340 			pdev_priv_obj->cur_chan_list[i].chan_flags,
6341 			pdev_priv_obj->cur_chan_list[i].state) &&
6342 		    (pdev_priv_obj->cur_chan_list[i].tx_power > max_tx_power))
6343 			max_tx_power =
6344 			pdev_priv_obj->cur_chan_list[i].tx_power;
6345 	}
6346 
6347 	if (in_6g_pwr_type == REG_CURRENT_PWR_MODE)
6348 		goto return_max_tx_power;
6349 
6350 	max_super_chan_power = reg_get_max_tx_power_from_super_chan_list(
6351 								pdev_priv_obj,
6352 								in_6g_pwr_type);
6353 
6354 	if (max_super_chan_power > max_tx_power)
6355 		max_tx_power = max_super_chan_power;
6356 
6357 return_max_tx_power:
6358 
6359 	if (!max_tx_power)
6360 		reg_err_rl("max_tx_power is zero");
6361 
6362 	return max_tx_power;
6363 }
6364 #endif
6365 
6366 bool reg_is_passive_for_freq(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq)
6367 {
6368 	uint32_t chan_flags;
6369 
6370 	chan_flags = reg_get_channel_flags_for_freq(pdev, freq);
6371 
6372 	return chan_flags & REGULATORY_CHAN_NO_IR;
6373 }
6374 #endif /* CONFIG_CHAN_FREQ_API */
6375 
6376 uint8_t  reg_get_max_tx_power(struct wlan_objmgr_pdev *pdev)
6377 {
6378 	struct regulatory_channel *cur_chan_list;
6379 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
6380 	uint8_t i, max_tx_power = 0;
6381 
6382 	pdev_priv_obj = reg_get_pdev_obj(pdev);
6383 
6384 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
6385 		reg_err("reg pdev private obj is NULL");
6386 		return QDF_STATUS_E_FAILURE;
6387 	}
6388 
6389 	cur_chan_list = pdev_priv_obj->cur_chan_list;
6390 
6391 	for (i = 0; i < NUM_CHANNELS; i++) {
6392 		if (cur_chan_list[i].state != CHANNEL_STATE_DISABLE &&
6393 		    cur_chan_list[i].chan_flags != REGULATORY_CHAN_DISABLED) {
6394 			if (cur_chan_list[i].tx_power > max_tx_power)
6395 				max_tx_power = cur_chan_list[i].tx_power;
6396 		}
6397 	}
6398 
6399 	if (!max_tx_power)
6400 		reg_err_rl("max_tx_power is zero");
6401 
6402 	return max_tx_power;
6403 }
6404 
6405 QDF_STATUS reg_set_ignore_fw_reg_offload_ind(struct wlan_objmgr_psoc *psoc)
6406 {
6407 	struct wlan_regulatory_psoc_priv_obj *psoc_reg;
6408 
6409 	psoc_reg = reg_get_psoc_obj(psoc);
6410 	if (!IS_VALID_PSOC_REG_OBJ(psoc_reg)) {
6411 		reg_err("psoc reg component is NULL");
6412 		return QDF_STATUS_E_INVAL;
6413 	}
6414 
6415 	psoc_reg->ignore_fw_reg_offload_ind = true;
6416 	return QDF_STATUS_SUCCESS;
6417 }
6418 
6419 bool reg_get_ignore_fw_reg_offload_ind(struct wlan_objmgr_psoc *psoc)
6420 {
6421 	struct wlan_regulatory_psoc_priv_obj *psoc_reg;
6422 
6423 	psoc_reg = reg_get_psoc_obj(psoc);
6424 	if (!IS_VALID_PSOC_REG_OBJ(psoc_reg))
6425 		return false;
6426 
6427 	return psoc_reg->ignore_fw_reg_offload_ind;
6428 }
6429 
6430 QDF_STATUS reg_set_6ghz_supported(struct wlan_objmgr_psoc *psoc, bool val)
6431 {
6432 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
6433 
6434 	psoc_priv_obj = reg_get_psoc_obj(psoc);
6435 
6436 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
6437 		reg_err("psoc reg component is NULL");
6438 		return QDF_STATUS_E_FAILURE;
6439 	}
6440 
6441 	psoc_priv_obj->six_ghz_supported = val;
6442 
6443 	return QDF_STATUS_SUCCESS;
6444 }
6445 
6446 QDF_STATUS
6447 reg_set_5dot9_ghz_supported(struct wlan_objmgr_psoc *psoc, bool val)
6448 {
6449 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
6450 
6451 	psoc_priv_obj = reg_get_psoc_obj(psoc);
6452 
6453 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
6454 		reg_err("psoc reg component is NULL");
6455 		return QDF_STATUS_E_FAILURE;
6456 	}
6457 
6458 	psoc_priv_obj->five_dot_nine_ghz_supported = val;
6459 
6460 	return QDF_STATUS_SUCCESS;
6461 }
6462 
6463 #ifdef CONFIG_REG_CLIENT
6464 bool reg_is_6ghz_supported(struct wlan_objmgr_psoc *psoc)
6465 {
6466 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
6467 
6468 	psoc_priv_obj = reg_get_psoc_obj(psoc);
6469 
6470 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
6471 		reg_err("psoc reg component is NULL");
6472 		return  false;
6473 	}
6474 
6475 	return psoc_priv_obj->six_ghz_supported;
6476 }
6477 #endif
6478 
6479 bool reg_is_5dot9_ghz_supported(struct wlan_objmgr_psoc *psoc)
6480 {
6481 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
6482 
6483 	psoc_priv_obj = reg_get_psoc_obj(psoc);
6484 
6485 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
6486 		reg_err("psoc reg component is NULL");
6487 		return  false;
6488 	}
6489 
6490 	return psoc_priv_obj->five_dot_nine_ghz_supported;
6491 }
6492 
6493 bool reg_is_fcc_regdmn(struct wlan_objmgr_pdev *pdev)
6494 {
6495 	struct cur_regdmn_info cur_reg_dmn;
6496 	QDF_STATUS status;
6497 
6498 	status = reg_get_curr_regdomain(pdev, &cur_reg_dmn);
6499 	if (status != QDF_STATUS_SUCCESS) {
6500 		reg_debug_rl("Failed to get reg domain");
6501 		return false;
6502 	}
6503 
6504 	return reg_fcc_regdmn(cur_reg_dmn.dmn_id_5g);
6505 }
6506 
6507 bool reg_is_5dot9_ghz_freq(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq)
6508 {
6509 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
6510 
6511 	pdev_priv_obj = reg_get_pdev_obj(pdev);
6512 
6513 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
6514 		reg_err("reg pdev priv obj is NULL");
6515 		return false;
6516 	}
6517 
6518 	return (freq >= channel_map_us[MIN_5DOT9_CHANNEL].center_freq &&
6519 		freq <= channel_map_us[MAX_5DOT9_CHANNEL].center_freq);
6520 }
6521 
6522 bool reg_is_5dot9_ghz_chan_allowed_master_mode(struct wlan_objmgr_pdev *pdev)
6523 {
6524 	struct wlan_objmgr_psoc *psoc;
6525 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
6526 
6527 	if (!pdev) {
6528 		reg_alert("pdev is NULL");
6529 		return true;
6530 	}
6531 	psoc = wlan_pdev_get_psoc(pdev);
6532 
6533 	psoc_priv_obj = reg_get_psoc_obj(psoc);
6534 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
6535 		reg_alert("psoc reg component is NULL");
6536 		return true;
6537 	}
6538 
6539 	return psoc_priv_obj->enable_5dot9_ghz_chan_in_master_mode;
6540 }
6541 
6542 #ifdef DISABLE_UNII_SHARED_BANDS
6543 QDF_STATUS
6544 reg_get_unii_5g_bitmap(struct wlan_objmgr_pdev *pdev, uint8_t *bitmap)
6545 {
6546 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
6547 
6548 	pdev_priv_obj = reg_get_pdev_obj(pdev);
6549 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
6550 		reg_err_rl("pdev reg component is NULL");
6551 		return QDF_STATUS_E_FAILURE;
6552 	}
6553 	*bitmap =  pdev_priv_obj->unii_5g_bitmap;
6554 
6555 	return QDF_STATUS_SUCCESS;
6556 }
6557 #endif
6558 
6559 #ifdef WLAN_FEATURE_11BE
6560 bool reg_is_phymode_unallowed(enum reg_phymode phy_in, uint32_t phymode_bitmap)
6561 {
6562 	if (!phymode_bitmap)
6563 		return false;
6564 
6565 	if (phy_in == REG_PHYMODE_11BE)
6566 		return phymode_bitmap & REGULATORY_PHYMODE_NO11BE;
6567 	else if (phy_in == REG_PHYMODE_11AX)
6568 		return phymode_bitmap & REGULATORY_PHYMODE_NO11AX;
6569 	else if (phy_in == REG_PHYMODE_11AC)
6570 		return phymode_bitmap & REGULATORY_PHYMODE_NO11AC;
6571 	else if (phy_in == REG_PHYMODE_11N)
6572 		return phymode_bitmap & REGULATORY_CHAN_NO11N;
6573 	else if (phy_in == REG_PHYMODE_11G)
6574 		return phymode_bitmap & REGULATORY_PHYMODE_NO11G;
6575 	else if (phy_in == REG_PHYMODE_11A)
6576 		return phymode_bitmap & REGULATORY_PHYMODE_NO11A;
6577 	else if (phy_in == REG_PHYMODE_11B)
6578 		return phymode_bitmap & REGULATORY_PHYMODE_NO11B;
6579 	else
6580 		return true;
6581 }
6582 #else
6583 bool reg_is_phymode_unallowed(enum reg_phymode phy_in, uint32_t phymode_bitmap)
6584 {
6585 	if (!phymode_bitmap)
6586 		return false;
6587 
6588 	if (phy_in == REG_PHYMODE_11AX)
6589 		return phymode_bitmap & REGULATORY_PHYMODE_NO11AX;
6590 	else if (phy_in == REG_PHYMODE_11AC)
6591 		return phymode_bitmap & REGULATORY_PHYMODE_NO11AC;
6592 	else if (phy_in == REG_PHYMODE_11N)
6593 		return phymode_bitmap & REGULATORY_CHAN_NO11N;
6594 	else if (phy_in == REG_PHYMODE_11G)
6595 		return phymode_bitmap & REGULATORY_PHYMODE_NO11G;
6596 	else if (phy_in == REG_PHYMODE_11A)
6597 		return phymode_bitmap & REGULATORY_PHYMODE_NO11A;
6598 	else if (phy_in == REG_PHYMODE_11B)
6599 		return phymode_bitmap & REGULATORY_PHYMODE_NO11B;
6600 	else
6601 		return true;
6602 }
6603 #endif
6604 
6605 #ifdef CHECK_REG_PHYMODE
6606 enum reg_phymode reg_get_max_phymode(struct wlan_objmgr_pdev *pdev,
6607 				     enum reg_phymode phy_in,
6608 				     qdf_freq_t freq)
6609 {
6610 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
6611 	uint32_t phymode_bitmap;
6612 	enum reg_phymode current_phymode = phy_in;
6613 
6614 	pdev_priv_obj = reg_get_pdev_obj(pdev);
6615 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
6616 		reg_err("pdev reg component is NULL");
6617 		return REG_PHYMODE_INVALID;
6618 	}
6619 
6620 	phymode_bitmap = pdev_priv_obj->phybitmap;
6621 
6622 	while (1) {
6623 		if (reg_is_phymode_unallowed(current_phymode, phymode_bitmap)) {
6624 			if (current_phymode == REG_PHYMODE_11N) {
6625 				if (REG_IS_24GHZ_CH_FREQ(freq))
6626 					current_phymode = REG_PHYMODE_11G;
6627 				else
6628 					current_phymode = REG_PHYMODE_11A;
6629 			} else if (current_phymode == REG_PHYMODE_11A ||
6630 				   current_phymode == REG_PHYMODE_11B) {
6631 				reg_err("Couldn't find a suitable phymode");
6632 				return REG_PHYMODE_INVALID;
6633 			} else if (current_phymode > REG_PHYMODE_MAX) {
6634 				reg_err("Unknown phymode");
6635 				return REG_PHYMODE_INVALID;
6636 			} else {
6637 				current_phymode--;
6638 			}
6639 		} else {
6640 			return current_phymode;
6641 		}
6642 	}
6643 }
6644 #endif /* CHECK_REG_PHYMODE */
6645 
6646 #ifdef CONFIG_REG_CLIENT
6647 enum band_info reg_band_bitmap_to_band_info(uint32_t band_bitmap)
6648 {
6649 	if ((band_bitmap & BIT(REG_BAND_2G)) &&
6650 	    (band_bitmap & BIT(REG_BAND_5G)) &&
6651 	    (band_bitmap & BIT(REG_BAND_6G)))
6652 		return BAND_ALL;
6653 	else if ((band_bitmap & BIT(REG_BAND_5G)) &&
6654 		 (band_bitmap & BIT(REG_BAND_6G)))
6655 		return BAND_5G;
6656 	else if ((band_bitmap & BIT(REG_BAND_2G)) &&
6657 		 (band_bitmap & BIT(REG_BAND_6G)))
6658 		return BAND_2G;
6659 	else if ((band_bitmap & BIT(REG_BAND_2G)) &&
6660 		 (band_bitmap & BIT(REG_BAND_5G)))
6661 		return BAND_ALL;
6662 	else if (band_bitmap & BIT(REG_BAND_2G))
6663 		return BAND_2G;
6664 	else if (band_bitmap & BIT(REG_BAND_5G))
6665 		return BAND_5G;
6666 	else if (band_bitmap & BIT(REG_BAND_6G))
6667 		return BAND_2G;
6668 	else
6669 		return BAND_UNKNOWN;
6670 }
6671 
6672 QDF_STATUS
6673 reg_update_tx_power_on_ctry_change(struct wlan_objmgr_pdev *pdev,
6674 				   uint8_t vdev_id)
6675 {
6676 	struct wlan_objmgr_psoc *psoc;
6677 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
6678 	reg_ctry_change_callback callback = NULL;
6679 
6680 	psoc = wlan_pdev_get_psoc(pdev);
6681 	psoc_priv_obj = reg_get_psoc_obj(psoc);
6682 	if (!psoc_priv_obj) {
6683 		reg_err("reg psoc private obj is NULL");
6684 		return QDF_STATUS_E_FAILURE;
6685 	}
6686 
6687 	qdf_spin_lock_bh(&psoc_priv_obj->cbk_list_lock);
6688 	if (psoc_priv_obj->cc_cbk.cbk)
6689 		callback = psoc_priv_obj->cc_cbk.cbk;
6690 	qdf_spin_unlock_bh(&psoc_priv_obj->cbk_list_lock);
6691 	if (callback)
6692 		callback(vdev_id);
6693 
6694 	return QDF_STATUS_SUCCESS;
6695 }
6696 
6697 QDF_STATUS
6698 reg_add_indoor_concurrency(struct wlan_objmgr_pdev *pdev, uint8_t vdev_id,
6699 			   uint32_t freq, enum phy_ch_width width)
6700 {
6701 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
6702 	struct indoor_concurrency_list *list;
6703 	const struct bonded_channel_freq *range = NULL;
6704 	uint8_t i = 0;
6705 
6706 	pdev_priv_obj = reg_get_pdev_obj(pdev);
6707 
6708 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
6709 		reg_err("pdev reg component is NULL");
6710 		return QDF_STATUS_E_FAILURE;
6711 	}
6712 
6713 	if (width > CH_WIDTH_20MHZ)
6714 		range = wlan_reg_get_bonded_chan_entry(freq, width, 0);
6715 
6716 	list = &pdev_priv_obj->indoor_list[0];
6717 	for (i = 0; i < MAX_INDOOR_LIST_SIZE; i++, list++) {
6718 		if (list->freq == 0 && list->vdev_id == INVALID_VDEV_ID) {
6719 			list->freq = freq;
6720 			list->vdev_id = vdev_id;
6721 			list->chan_range = range;
6722 			reg_debug("Added freq %d vdev %d width %d at idx %d",
6723 				  freq, vdev_id, width, i);
6724 			return QDF_STATUS_SUCCESS;
6725 		}
6726 	}
6727 	reg_err("Unable to add indoor concurrency for vdev %d freq %d width %d",
6728 		vdev_id, freq, width);
6729 	return QDF_STATUS_E_FAILURE;
6730 }
6731 
6732 QDF_STATUS
6733 reg_remove_indoor_concurrency(struct wlan_objmgr_pdev *pdev, uint8_t vdev_id,
6734 			      uint32_t freq)
6735 {
6736 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
6737 	struct indoor_concurrency_list *list;
6738 	uint8_t i = 0;
6739 
6740 	pdev_priv_obj = reg_get_pdev_obj(pdev);
6741 
6742 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
6743 		reg_err("pdev reg component is NULL");
6744 		return QDF_STATUS_E_FAILURE;
6745 	}
6746 
6747 	list = &pdev_priv_obj->indoor_list[0];
6748 	for (i = 0; i < MAX_INDOOR_LIST_SIZE; i++, list++) {
6749 		if (list->freq == freq ||
6750 		    (vdev_id != INVALID_VDEV_ID && list->vdev_id == vdev_id)) {
6751 			reg_debug("Removed freq %d from idx %d", list->freq, i);
6752 			list->freq = 0;
6753 			list->vdev_id = INVALID_VDEV_ID;
6754 			list->chan_range = NULL;
6755 			return QDF_STATUS_SUCCESS;
6756 		}
6757 		continue;
6758 	}
6759 
6760 	return QDF_STATUS_E_FAILURE;
6761 }
6762 
6763 void
6764 reg_init_indoor_channel_list(struct wlan_objmgr_pdev *pdev)
6765 {
6766 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
6767 	struct indoor_concurrency_list *list;
6768 	uint8_t i;
6769 
6770 	pdev_priv_obj = reg_get_pdev_obj(pdev);
6771 
6772 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
6773 		reg_debug("reg pdev priv obj is NULL");
6774 		return;
6775 	}
6776 
6777 	list = pdev_priv_obj->indoor_list;
6778 	for (i = 0; i < MAX_INDOOR_LIST_SIZE; i++, list++) {
6779 		list->freq = 0;
6780 		list->vdev_id = INVALID_VDEV_ID;
6781 		list->chan_range = NULL;
6782 	}
6783 }
6784 
6785 QDF_STATUS
6786 reg_compute_indoor_list_on_cc_change(struct wlan_objmgr_psoc *psoc,
6787 				     struct wlan_objmgr_pdev *pdev)
6788 {
6789 	struct wlan_objmgr_vdev *vdev;
6790 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
6791 	struct wlan_channel *des_chan;
6792 	enum channel_enum chan_enum;
6793 	uint8_t vdev_id;
6794 
6795 	pdev_priv_obj = reg_get_pdev_obj(pdev);
6796 
6797 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
6798 		reg_err("reg pdev priv obj is NULL");
6799 		return QDF_STATUS_E_FAILURE;
6800 	}
6801 
6802 	if (pdev_priv_obj->indoor_chan_enabled ||
6803 	    !pdev_priv_obj->sta_sap_scc_on_indoor_channel)
6804 		return QDF_STATUS_SUCCESS;
6805 
6806 	/* Iterate through VDEV list */
6807 	for (vdev_id = 0; vdev_id < WLAN_UMAC_PSOC_MAX_VDEVS; vdev_id++) {
6808 		vdev =
6809 		wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id,
6810 						     WLAN_REGULATORY_SB_ID);
6811 		if (!vdev)
6812 			continue;
6813 
6814 		if (vdev->vdev_mlme.vdev_opmode != QDF_STA_MODE &&
6815 		    vdev->vdev_mlme.vdev_opmode != QDF_P2P_CLIENT_MODE)
6816 			goto next;
6817 
6818 		des_chan = vdev->vdev_mlme.des_chan;
6819 		if (!des_chan)
6820 			goto next;
6821 
6822 		if (!reg_is_5ghz_ch_freq(des_chan->ch_freq))
6823 			goto next;
6824 
6825 		chan_enum = reg_get_chan_enum_for_freq(des_chan->ch_freq);
6826 		if (reg_is_chan_enum_invalid(chan_enum)) {
6827 			reg_err_rl("Invalid chan enum %d", chan_enum);
6828 			goto next;
6829 		}
6830 
6831 		if (pdev_priv_obj->mas_chan_list[chan_enum].state !=
6832 		    CHANNEL_STATE_DISABLE &&
6833 		    pdev_priv_obj->mas_chan_list[chan_enum].chan_flags &
6834 		    REGULATORY_CHAN_INDOOR_ONLY)
6835 			reg_add_indoor_concurrency(pdev, vdev_id,
6836 						   des_chan->ch_freq,
6837 						   des_chan->ch_width);
6838 
6839 next:
6840 		wlan_objmgr_vdev_release_ref(vdev, WLAN_REGULATORY_SB_ID);
6841 	}
6842 
6843 	return QDF_STATUS_SUCCESS;
6844 }
6845 #endif
6846 
6847 #if defined(CONFIG_BAND_6GHZ)
6848 QDF_STATUS
6849 reg_set_cur_6g_ap_pwr_type(struct wlan_objmgr_pdev *pdev,
6850 			   enum reg_6g_ap_type reg_cur_6g_ap_pwr_type)
6851 {
6852 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
6853 
6854 	pdev_priv_obj = reg_get_pdev_obj(pdev);
6855 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
6856 		reg_err("pdev reg component is NULL");
6857 		return QDF_STATUS_E_FAILURE;
6858 	}
6859 
6860 	if (reg_cur_6g_ap_pwr_type > REG_MAX_SUPP_AP_TYPE) {
6861 		reg_err("Unsupported 6G AP power type");
6862 		return QDF_STATUS_E_FAILURE;
6863 	}
6864 	/* should we validate the input reg_cur_6g_ap_type? */
6865 	pdev_priv_obj->reg_cur_6g_ap_pwr_type = reg_cur_6g_ap_pwr_type;
6866 	return QDF_STATUS_SUCCESS;
6867 }
6868 
6869 QDF_STATUS
6870 reg_get_cur_6g_ap_pwr_type(struct wlan_objmgr_pdev *pdev,
6871 			   enum reg_6g_ap_type *reg_cur_6g_ap_pwr_type)
6872 {
6873 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
6874 
6875 	pdev_priv_obj = reg_get_pdev_obj(pdev);
6876 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
6877 		reg_err("pdev reg component is NULL");
6878 		return QDF_STATUS_E_FAILURE;
6879 	}
6880 
6881 	if (pdev_priv_obj->reg_cur_6g_ap_pwr_type >= REG_CURRENT_MAX_AP_TYPE)
6882 		return QDF_STATUS_E_FAILURE;
6883 
6884 	*reg_cur_6g_ap_pwr_type = pdev_priv_obj->reg_cur_6g_ap_pwr_type;
6885 
6886 	return QDF_STATUS_SUCCESS;
6887 }
6888 
6889 /**
6890  * reg_get_reg_rules_for_pdev() - Get the pointer to the reg rules for the pdev
6891  * @pdev: Pointer to pdev
6892  *
6893  * Return: Pointer to Standard Power regulatory rules
6894  */
6895 static struct reg_rule_info *
6896 reg_get_reg_rules_for_pdev(struct wlan_objmgr_pdev *pdev)
6897 {
6898 	struct wlan_objmgr_psoc *psoc;
6899 	struct wlan_regulatory_psoc_priv_obj *psoc_reg_priv;
6900 	uint8_t phy_id;
6901 	struct reg_rule_info *psoc_reg_rules;
6902 
6903 	psoc = wlan_pdev_get_psoc(pdev);
6904 	psoc_reg_priv = reg_get_psoc_obj(psoc);
6905 
6906 	if (!psoc_reg_priv) {
6907 		reg_debug("Regulatory psoc private object is NULL");
6908 		return NULL;
6909 	}
6910 
6911 	phy_id = wlan_objmgr_pdev_get_pdev_id(pdev);
6912 	psoc_reg_rules = &psoc_reg_priv->mas_chan_params[phy_id].reg_rules;
6913 
6914 	return psoc_reg_rules;
6915 }
6916 
6917 uint8_t
6918 reg_get_num_rules_of_ap_pwr_type(struct wlan_objmgr_pdev *pdev,
6919 				 enum reg_6g_ap_type ap_pwr_type)
6920 {
6921 	struct reg_rule_info *psoc_reg_rules = reg_get_reg_rules_for_pdev(pdev);
6922 
6923 	if (!psoc_reg_rules) {
6924 		reg_debug("No psoc_reg_rules");
6925 		return 0;
6926 	}
6927 
6928 	if (ap_pwr_type > REG_MAX_SUPP_AP_TYPE) {
6929 		reg_err("Unsupported 6G AP power type");
6930 		return 0;
6931 	}
6932 
6933 	return psoc_reg_rules->num_of_6g_ap_reg_rules[ap_pwr_type];
6934 }
6935 
6936 #ifdef CONFIG_AFC_SUPPORT
6937 /**
6938  * reg_is_empty_range() - If both left, right frquency edges in the input range
6939  * are zero then the range is empty, else not.
6940  * @in_range: Pointer to input range
6941  *
6942  * Return: True if the range is empty, else false
6943  */
6944 static bool reg_is_empty_range(struct freq_range *in_range)
6945 {
6946 	return !in_range->left && !in_range->right;
6947 }
6948 
6949 struct freq_range
6950 reg_init_freq_range(qdf_freq_t left, qdf_freq_t right)
6951 {
6952 	struct freq_range out_range;
6953 
6954 	out_range.left = left;
6955 	out_range.right = right;
6956 
6957 	return out_range;
6958 }
6959 
6960 /**
6961  * reg_assign_vars_with_range_vals() - Assign input variables with the values of
6962  * the range variable values
6963  * @in_range: Pointer to input range object
6964  * @left: Pointer to the first variable to get the value of left frequency edge
6965  * @right: Pointer to the second variable to get the value of right frequency
6966  *         edge
6967  *
6968  * Return: void
6969  */
6970 static void
6971 reg_assign_vars_with_range_vals(struct freq_range *in_range,
6972 				qdf_freq_t *left,
6973 				qdf_freq_t *right)
6974 {
6975 	*left = in_range->left;
6976 	*right = in_range->right;
6977 }
6978 
6979 /**
6980  * reg_intersect_ranges() - Intersect two ranges and return the intesected range
6981  * @first_range: Pointer to first input range
6982  * @second_range: Pointer to second input range
6983  *
6984  * Return: Intersected output range
6985  */
6986 static struct freq_range
6987 reg_intersect_ranges(struct freq_range *first_range,
6988 		     struct freq_range *second_range)
6989 {
6990 	struct freq_range out_range;
6991 	qdf_freq_t l_freq;
6992 	qdf_freq_t r_freq;
6993 
6994 	/* validate if the ranges are proper */
6995 
6996 	l_freq = QDF_MAX(first_range->left, second_range->left);
6997 	r_freq = QDF_MIN(first_range->right, second_range->right);
6998 
6999 	if (l_freq > r_freq) {
7000 		l_freq = 0;
7001 		r_freq = 0;
7002 
7003 		reg_debug("Ranges do not overlap first= [%u, %u], second = [%u, %u]",
7004 			  first_range->left,
7005 			  first_range->right,
7006 			  second_range->left,
7007 			  second_range->right);
7008 	}
7009 
7010 	out_range.left = l_freq;
7011 	out_range.right = r_freq;
7012 
7013 	return out_range;
7014 }
7015 
7016 /**
7017  * typedef reg_act_sp_rule_cb() - A function pointer type that calculates
7018  *                                something from the input frequency range
7019  * @rule_fr: Pointer to frequency range
7020  * @arg: Pointer to generic argument (a.k.a. context)
7021  *
7022  * Return: Void
7023  */
7024 typedef void (*reg_act_sp_rule_cb)(struct freq_range *rule_fr,
7025 				   void *arg);
7026 
7027 /**
7028  * reg_iterate_sp_rules() - Iterate through the Standard Power reg rules, for
7029  * every reg rule call the call back function to take some action or calculate
7030  * something
7031  * @pdev: Pointer to pdev
7032  * @pdev_priv_obj: Pointer to pdev private object
7033  * @sp_rule_action: A function pointer to take some action or calculate
7034  * something for every sp rule
7035  * @arg: Pointer to opque object (argument/context)
7036  *
7037  * Return: Void
7038  */
7039 static void reg_iterate_sp_rules(struct wlan_objmgr_pdev *pdev,
7040 				 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj,
7041 				 reg_act_sp_rule_cb sp_rule_action,
7042 				 void *arg)
7043 {
7044 	struct cur_reg_rule *p_sp_reg_rule;
7045 	struct reg_rule_info *psoc_reg_rules;
7046 	uint8_t n_6g_sp_ap_reg_rules;
7047 	qdf_freq_t low_5g;
7048 	qdf_freq_t high_5g;
7049 	uint8_t i;
7050 	struct freq_range chip_range;
7051 
7052 	psoc_reg_rules = reg_get_reg_rules_for_pdev(pdev);
7053 
7054 	if (!psoc_reg_rules) {
7055 		reg_debug("psoc reg rule pointer is NULL");
7056 		return;
7057 	}
7058 
7059 	n_6g_sp_ap_reg_rules = psoc_reg_rules->num_of_6g_ap_reg_rules[REG_STANDARD_POWER_AP];
7060 	p_sp_reg_rule = psoc_reg_rules->reg_rules_6g_ap[REG_STANDARD_POWER_AP];
7061 
7062 	low_5g = pdev_priv_obj->range_5g_low;
7063 	high_5g = pdev_priv_obj->range_5g_high;
7064 
7065 	chip_range = reg_init_freq_range(low_5g, high_5g);
7066 
7067 	reg_debug("chip_range = [%u, %u]", low_5g, high_5g);
7068 	reg_debug("Num_6g_rules = %u", n_6g_sp_ap_reg_rules);
7069 
7070 	for (i = 0; i < n_6g_sp_ap_reg_rules; i++) {
7071 		struct freq_range sp_range;
7072 		struct freq_range out_range;
7073 
7074 		sp_range = reg_init_freq_range(p_sp_reg_rule->start_freq,
7075 					       p_sp_reg_rule->end_freq);
7076 		reg_debug("Rule:[%u, %u]",
7077 			  p_sp_reg_rule->start_freq,
7078 			  p_sp_reg_rule->end_freq);
7079 		out_range = reg_intersect_ranges(&chip_range, &sp_range);
7080 
7081 		if (sp_rule_action)
7082 			sp_rule_action(&out_range, arg);
7083 
7084 		p_sp_reg_rule++;
7085 	}
7086 }
7087 
7088 /**
7089  * reg_afc_incr_num_ranges() - Increment the number of frequency ranges
7090  * @p_range: Pointer to frequency range
7091  * @num_freq_ranges: Pointer to number of frequency ranges. This needs to be
7092  * (Actual type: uint8_t *num_freq_ranges)
7093  * incremented by the function
7094  *
7095  * Return: Void
7096  */
7097 static void reg_afc_incr_num_ranges(struct freq_range *p_range,
7098 				    void *num_freq_ranges)
7099 {
7100 	if (!reg_is_empty_range(p_range))
7101 		(*(uint8_t *)num_freq_ranges)++;
7102 }
7103 
7104 /**
7105  * reg_get_num_sp_freq_ranges() - Find the number of reg rules from the Standard
7106  *                                power regulatory rules
7107  * @pdev: Pointer to pdev
7108  * @pdev_priv_obj: Pointer to pdev private object
7109  *
7110  * Return: number of frequency ranges
7111  */
7112 static uint8_t reg_get_num_sp_freq_ranges(struct wlan_objmgr_pdev *pdev,
7113 					  struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj)
7114 {
7115 	uint8_t num_freq_ranges;
7116 
7117 	num_freq_ranges = 0;
7118 	reg_iterate_sp_rules(pdev,
7119 			     pdev_priv_obj,
7120 			     reg_afc_incr_num_ranges,
7121 			     &num_freq_ranges);
7122 
7123 	reg_debug("Num_freq_ranges=%u", num_freq_ranges);
7124 	return num_freq_ranges;
7125 }
7126 
7127 /**
7128  * reg_afc_get_intersected_ranges() - Get the intersected range into range obj
7129  * @rule_fr: Pointer to the rule for frequency range
7130  * @arg: Pointer to opaque object (argument/context)
7131  * (Actual type: struct wlan_afc_freq_range_obj **p_range_obj)
7132  * incremented by the function
7133  *
7134  * Return: Void
7135  */
7136 static void reg_afc_get_intersected_ranges(struct freq_range *rule_fr,
7137 					   void *arg)
7138 {
7139 	struct wlan_afc_freq_range_obj *p_range;
7140 	struct wlan_afc_freq_range_obj **pp_range;
7141 	qdf_freq_t low, high;
7142 
7143 	pp_range = (struct wlan_afc_freq_range_obj **)arg;
7144 	p_range = *pp_range;
7145 
7146 	if (!reg_is_empty_range(rule_fr)) {
7147 		reg_assign_vars_with_range_vals(rule_fr, &low, &high);
7148 		p_range->lowfreq = (uint16_t)low;
7149 		p_range->highfreq = (uint16_t)high;
7150 		reg_debug("Range = [%u, %u]", p_range->lowfreq, p_range->highfreq);
7151 		(*pp_range)++;
7152 	}
7153 }
7154 
7155 /**
7156  * reg_cp_freq_ranges() - Copy frequency ranges  from the Standard power
7157  * regulatory rules
7158  * @pdev: Pointer to pdev
7159  * @pdev_priv_obj: Pointer to pdev private object
7160  * @num_freq_ranges: Number of frequency ranges
7161  * @p_range_obj: Pointer to range object
7162  *
7163  * Return: void
7164  */
7165 static void reg_cp_freq_ranges(struct wlan_objmgr_pdev *pdev,
7166 			       struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj,
7167 			       uint8_t num_freq_ranges,
7168 			       struct wlan_afc_freq_range_obj *p_range_obj)
7169 {
7170 	struct wlan_afc_freq_range_obj *p_range;
7171 
7172 	reg_debug("Num freq ranges = %u", num_freq_ranges);
7173 
7174 	p_range = p_range_obj;
7175 	reg_iterate_sp_rules(pdev,
7176 			     pdev_priv_obj,
7177 			     reg_afc_get_intersected_ranges,
7178 			     &p_range);
7179 }
7180 
7181 /**
7182  * reg_fill_afc_freq_ranges() - Allocate memory for and fill the AFC frequency
7183  * range lists.
7184  * @pdev: Pointer to pdev
7185  * @pdev_priv_obj: Pointer to pdev private object
7186  * @p_frange_lst: Pointer to frequency range list
7187  * @num_freq_ranges: Number of frequency ranges
7188  *
7189  * Return: QDF_STATUS
7190  */
7191 static inline QDF_STATUS
7192 reg_fill_afc_freq_ranges(struct wlan_objmgr_pdev *pdev,
7193 			 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj,
7194 			 struct wlan_afc_frange_list *p_frange_lst,
7195 			 uint8_t num_freq_ranges)
7196 {
7197 	struct wlan_afc_freq_range_obj *p_range_obj;
7198 
7199 	p_frange_lst->num_ranges = num_freq_ranges;
7200 	if (!num_freq_ranges)
7201 		return QDF_STATUS_E_INVAL;
7202 
7203 	p_range_obj = qdf_mem_malloc(num_freq_ranges * sizeof(*p_range_obj));
7204 	if (!p_range_obj)
7205 		return QDF_STATUS_E_NOMEM;
7206 
7207 	reg_cp_freq_ranges(pdev, pdev_priv_obj, num_freq_ranges, p_range_obj);
7208 
7209 	p_frange_lst->range_objs = p_range_obj;
7210 
7211 	return QDF_STATUS_SUCCESS;
7212 }
7213 
7214 /**
7215  * reg_fill_afc_opclass_obj() - Fill the opclass object and return pointer to
7216  *                              next AFC opclass object
7217  * @p_obj_opclass_obj: Pointer to opclass object
7218  * @opclass: Operating class
7219  * @num_chans: Number of channels in the opclass
7220  * @p_chan_lst: Pointer to channel list
7221  *
7222  * Return: QDF_STATUS
7223  */
7224 static QDF_STATUS
7225 reg_fill_afc_opclass_obj(struct wlan_afc_opclass_obj *p_obj_opclass_obj,
7226 			 uint8_t opclass,
7227 			 uint8_t num_chans,
7228 			 uint8_t *p_chan_lst)
7229 {
7230 	uint8_t *src, *dst;
7231 	uint8_t copy_len;
7232 
7233 	p_obj_opclass_obj->opclass_num_cfis = num_chans;
7234 	p_obj_opclass_obj->opclass = opclass;
7235 	/* Zero CFIs(opclass_num_cfis / num_chans) is a valid case */
7236 	if (!num_chans)
7237 		return QDF_STATUS_SUCCESS;
7238 
7239 	src = p_chan_lst;
7240 	copy_len = num_chans * sizeof(uint8_t);
7241 	dst = qdf_mem_malloc(copy_len);
7242 	if (!dst)
7243 		return QDF_STATUS_E_NOMEM;
7244 
7245 	qdf_mem_copy(dst, src, copy_len);
7246 	p_obj_opclass_obj->cfis = dst;
7247 
7248 	return QDF_STATUS_SUCCESS;
7249 }
7250 
7251 /**
7252  * reg_free_afc_opclass_objs() - Free the  memory allocated for AFC opclass
7253  * object. Each opclass object also contains a cfi array. Free the memory
7254  * allocated for the cfi array.
7255  * @opclass_objs: Pointer to opclass objects array.
7256  * @num_opclass_objs: Number of opclass objects.
7257  *
7258  * Return: void
7259  */
7260 static void
7261 reg_free_afc_opclass_objs(struct wlan_afc_opclass_obj *opclass_objs,
7262 			  uint8_t num_opclass_objs)
7263 {
7264 	uint8_t i;
7265 
7266 	for (i = 0; i < num_opclass_objs; i++) {
7267 		struct wlan_afc_opclass_obj *opclass_obj;
7268 
7269 		opclass_obj = &opclass_objs[i];
7270 		qdf_mem_free(opclass_obj->cfis);
7271 	}
7272 	qdf_mem_free(opclass_objs);
7273 }
7274 
7275 /**
7276  * reg_fill_afc_opclasses_arr() - Fill the array of opclass objects
7277  * @pdev: Pointer to pdev
7278  * @num_opclasses: The number of opclasses
7279  * @opclass_lst: The array of Operating classes
7280  * @chansize_lst: The array of sizes of channel lists
7281  * @channel_lists: The array of channel lists
7282  * @p_opclass_obj_arr: Pointer to the first opclass object
7283  *
7284  * Return: QDF_STATUS
7285  */
7286 static QDF_STATUS
7287 reg_fill_afc_opclasses_arr(struct wlan_objmgr_pdev *pdev,
7288 			   uint8_t num_opclasses,
7289 			   uint8_t *opclass_lst,
7290 			   uint8_t *chansize_lst,
7291 			   uint8_t *channel_lists[],
7292 			   struct wlan_afc_opclass_obj *p_opclass_obj_arr)
7293 {
7294 	uint16_t i;
7295 	QDF_STATUS status;
7296 
7297 	for (i = 0; i < num_opclasses; i++) {
7298 		struct wlan_afc_opclass_obj *p_opclass_obj;
7299 
7300 		p_opclass_obj = &p_opclass_obj_arr[i];
7301 		status = reg_fill_afc_opclass_obj(p_opclass_obj,
7302 						  opclass_lst[i],
7303 						  chansize_lst[i],
7304 						  channel_lists[i]);
7305 		if (QDF_IS_STATUS_ERROR(status)) {
7306 			reg_free_afc_opclass_objs(p_opclass_obj_arr,
7307 						  num_opclasses);
7308 			return status;
7309 		}
7310 	}
7311 	return QDF_STATUS_SUCCESS;
7312 }
7313 
7314 /**
7315  * reg_print_afc_req_info_header_params() - Print the fixed param portion of the
7316  * AFC request information.
7317  * @afc_req: Pointer to AFC request
7318  *
7319  * Return: Void
7320  */
7321 static void
7322 reg_print_afc_req_info_header_params(struct wlan_afc_host_request *afc_req)
7323 {
7324 	reg_debug("req_id=%llu", afc_req->req_id);
7325 	reg_debug("version_minor=%u", afc_req->version_minor);
7326 	reg_debug("version_major=%u", afc_req->version_major);
7327 	reg_debug("min_des_power=%hd", afc_req->min_des_power);
7328 }
7329 
7330 /**
7331  * reg_print_afc_req_info_frange_list() - Print the list of frequency ranges
7332  * portion of the AFC request information.
7333  * @afc_req: Pointer to AFC request
7334  *
7335  * Return: Void
7336  */
7337 static void
7338 reg_print_afc_req_info_frange_list(struct wlan_afc_host_request *afc_req)
7339 {
7340 	struct wlan_afc_frange_list *p_frange_lst;
7341 	uint8_t i;
7342 
7343 	p_frange_lst = afc_req->freq_lst;
7344 	if (!p_frange_lst) {
7345 		reg_debug("p_frange_lst is NULL");
7346 		return;
7347 	}
7348 
7349 	reg_debug("num_ranges=%hhu", p_frange_lst->num_ranges);
7350 	for (i = 0; i < p_frange_lst->num_ranges; i++) {
7351 		struct wlan_afc_freq_range_obj *p_range_obj;
7352 
7353 		p_range_obj = &p_frange_lst->range_objs[i];
7354 		reg_debug("lowfreq=%hu", p_range_obj->lowfreq);
7355 		reg_debug("highfreq=%hu", p_range_obj->highfreq);
7356 	}
7357 }
7358 
7359 /**
7360  * reg_print_afc_req_info_opclass_list() - Print the list of opclasses
7361  * and the corresponding CFIs supported in those opclasses.
7362  * @afc_req: Pointer to AFC request
7363  *
7364  * Return: Void
7365  */
7366 static void
7367 reg_print_afc_req_info_opclass_list(struct wlan_afc_host_request *afc_req)
7368 {
7369 	uint8_t i;
7370 	uint8_t num_opclasses;
7371 	struct wlan_afc_opclass_obj_list *p_opclass_obj_lst;
7372 	struct wlan_afc_opclass_obj *p_opclass_obj;
7373 
7374 	p_opclass_obj_lst = afc_req->opclass_obj_lst;
7375 	if (!p_opclass_obj_lst) {
7376 		reg_debug("p_opclass_obj_lst is NULL");
7377 		return;
7378 	}
7379 
7380 	num_opclasses = p_opclass_obj_lst->num_opclass_objs;
7381 	reg_debug("num_opclasses=%hhu", num_opclasses);
7382 	p_opclass_obj = p_opclass_obj_lst->opclass_objs;
7383 	for (i = 0; i < num_opclasses; i++) {
7384 		uint8_t opclass = p_opclass_obj[i].opclass;
7385 		uint8_t num_cfis = p_opclass_obj[i].opclass_num_cfis;
7386 		uint8_t *cfis = p_opclass_obj[i].cfis;
7387 		uint8_t j;
7388 
7389 		reg_debug("opclass[%hhu]=%hhu", i, opclass);
7390 		reg_debug("num_cfis[%hhu]=%hhu", i, num_cfis);
7391 		reg_debug("[");
7392 		for (j = 0; j < num_cfis; j++)
7393 			reg_debug("%hhu,", cfis[j]);
7394 		reg_debug("]");
7395 	}
7396 }
7397 
7398 /**
7399  * reg_print_afc_req_info_location() - Print the location information in the afc
7400  * request.
7401  * @afc_req: Pointer to AFC request
7402  *
7403  * Return: Void
7404  */
7405 static void
7406 reg_print_afc_req_info_location(struct wlan_afc_host_request *afc_req)
7407 {
7408 	struct wlan_afc_location *p_afc_location;
7409 	uint8_t *deployment_type_str;
7410 
7411 	p_afc_location = afc_req->afc_location;
7412 	if (!p_afc_location) {
7413 		reg_debug("p_afc_location is NULL");
7414 		return;
7415 	}
7416 
7417 	switch (p_afc_location->deployment_type) {
7418 	case AFC_DEPLOYMENT_INDOOR:
7419 		deployment_type_str = "Indoor";
7420 		break;
7421 	case AFC_DEPLOYMENT_OUTDOOR:
7422 		deployment_type_str = "Outdoor";
7423 		break;
7424 	default:
7425 		deployment_type_str = "Unknown";
7426 	}
7427 	reg_debug("AFC location=%s", deployment_type_str);
7428 }
7429 
7430 void reg_print_afc_req_info(struct wlan_objmgr_pdev *pdev,
7431 			    struct wlan_afc_host_request *afc_req)
7432 {
7433 	if (!afc_req) {
7434 		reg_debug("afc_req is NULL");
7435 		return;
7436 	}
7437 
7438 	reg_print_afc_req_info_header_params(afc_req);
7439 	reg_print_afc_req_info_frange_list(afc_req);
7440 	reg_print_afc_req_info_opclass_list(afc_req);
7441 	reg_print_afc_req_info_location(afc_req);
7442 }
7443 
7444 /**
7445  * reg_free_afc_freq_list() - Free the  memory allocated for AFC frequency list
7446  * pointer and range object.
7447  * @freq_lst: Pointer to AFC frequency list structure.
7448  *
7449  * Return: void
7450  */
7451 static void reg_free_afc_freq_list(struct wlan_afc_frange_list *freq_lst)
7452 {
7453 	if (freq_lst) {
7454 		qdf_mem_free(freq_lst->range_objs);
7455 		qdf_mem_free(freq_lst);
7456 	}
7457 }
7458 
7459 /**
7460  * reg_free_afc_opclass_list() - Free the  memory allocated for AFC opclass list
7461  * pointer and opclass objects.
7462  * @opclass_obj_lst: Pointer to AFC opclass object list structure.
7463  *
7464  * Return: void
7465  */
7466 static void
7467 reg_free_afc_opclass_list(struct wlan_afc_opclass_obj_list *opclass_obj_lst)
7468 {
7469 	uint8_t num_opclass_objs;
7470 
7471 	if (!opclass_obj_lst)
7472 		return;
7473 
7474 	num_opclass_objs = opclass_obj_lst->num_opclass_objs;
7475 	if (opclass_obj_lst->opclass_objs)
7476 		reg_free_afc_opclass_objs(opclass_obj_lst->opclass_objs,
7477 					  num_opclass_objs);
7478 	qdf_mem_free(opclass_obj_lst);
7479 }
7480 
7481 /**
7482  * reg_fill_freq_lst() - Allocate and fill the frange buffer and return
7483  * the buffer. Also return the number of frequence ranges
7484  * @pdev: Pointer to pdev
7485  * @pdev_priv_obj: Pointer to pdev private object
7486  *
7487  * Return: Pointer to the frange buffer
7488  */
7489 static struct wlan_afc_frange_list *
7490 reg_fill_freq_lst(struct wlan_objmgr_pdev *pdev,
7491 		  struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj)
7492 {
7493 	uint8_t num_freq_ranges;
7494 	struct wlan_afc_frange_list *p_frange_lst_local;
7495 	QDF_STATUS status;
7496 
7497 	num_freq_ranges =  reg_get_num_sp_freq_ranges(pdev, pdev_priv_obj);
7498 	p_frange_lst_local = qdf_mem_malloc(sizeof(*p_frange_lst_local));
7499 	if (!p_frange_lst_local)
7500 		return NULL;
7501 
7502 	status = reg_fill_afc_freq_ranges(pdev,
7503 					  pdev_priv_obj,
7504 					  p_frange_lst_local,
7505 					  num_freq_ranges);
7506 	if (QDF_IS_STATUS_ERROR(status)) {
7507 		reg_free_afc_freq_list(p_frange_lst_local);
7508 		return NULL;
7509 	}
7510 
7511 	return p_frange_lst_local;
7512 }
7513 
7514 void reg_free_afc_req(struct wlan_objmgr_pdev *pdev,
7515 		      struct wlan_afc_host_request *afc_req)
7516 {
7517 	if (!afc_req)
7518 		return;
7519 
7520 	reg_free_afc_freq_list(afc_req->freq_lst);
7521 	reg_free_afc_opclass_list(afc_req->opclass_obj_lst);
7522 	qdf_mem_free(afc_req->afc_location);
7523 	qdf_mem_free(afc_req);
7524 }
7525 
7526 /**
7527  * reg_fill_afc_opclass_obj_lst() - Allocate and fill the opclass object list
7528  * pointer and return the pointer.
7529  * @pdev: Pointer to pdev
7530  * @p_afc_req: Pointer to AFC request.
7531  *
7532  * Return: Pointer to the opclass object list.
7533  */
7534 static struct wlan_afc_opclass_obj_list *
7535 reg_fill_afc_opclass_obj_lst(struct wlan_objmgr_pdev *pdev,
7536 			     struct wlan_afc_host_request *p_afc_req)
7537 {
7538 	uint8_t num_opclasses;
7539 	uint8_t *opclass_lst;
7540 	uint8_t *chansize_lst;
7541 	uint8_t **channel_lists;
7542 	struct wlan_afc_opclass_obj_list *opclass_obj_lst;
7543 	struct wlan_afc_opclass_obj *l_opclass_objs;
7544 	QDF_STATUS status;
7545 
7546 	status = reg_dmn_get_6g_opclasses_and_channels(pdev,
7547 						       p_afc_req->freq_lst,
7548 						       &num_opclasses,
7549 						       &opclass_lst,
7550 						       &chansize_lst,
7551 						       &channel_lists);
7552 	if (status != QDF_STATUS_SUCCESS) {
7553 		reg_err("Opclasses and chans not allocated");
7554 		return NULL;
7555 	}
7556 
7557 	opclass_obj_lst =  qdf_mem_malloc(sizeof(*opclass_obj_lst));
7558 	if (!opclass_obj_lst) {
7559 		reg_dmn_free_6g_opclasses_and_channels(pdev, num_opclasses,
7560 						       opclass_lst,
7561 						       chansize_lst,
7562 						       channel_lists);
7563 		return NULL;
7564 	}
7565 
7566 	if (!num_opclasses)
7567 		return NULL;
7568 
7569 	opclass_obj_lst->num_opclass_objs = num_opclasses;
7570 	l_opclass_objs = qdf_mem_malloc(num_opclasses *
7571 					sizeof(struct wlan_afc_opclass_obj));
7572 	if (!l_opclass_objs) {
7573 		reg_dmn_free_6g_opclasses_and_channels(pdev, num_opclasses,
7574 						       opclass_lst,
7575 						       chansize_lst,
7576 						       channel_lists);
7577 		reg_free_afc_opclass_list(opclass_obj_lst);
7578 		return NULL;
7579 	}
7580 
7581 	status = reg_fill_afc_opclasses_arr(pdev, num_opclasses, opclass_lst,
7582 					    chansize_lst, channel_lists,
7583 					    l_opclass_objs);
7584 	if (QDF_IS_STATUS_ERROR(status)) {
7585 		reg_dmn_free_6g_opclasses_and_channels(pdev, num_opclasses,
7586 						       opclass_lst,
7587 						       chansize_lst,
7588 						       channel_lists);
7589 		reg_free_afc_opclass_list(opclass_obj_lst);
7590 		return NULL;
7591 	}
7592 
7593 	opclass_obj_lst->opclass_objs = l_opclass_objs;
7594 	reg_dmn_free_6g_opclasses_and_channels(pdev, num_opclasses,
7595 					       opclass_lst,
7596 					       chansize_lst,
7597 					       channel_lists);
7598 	return opclass_obj_lst;
7599 }
7600 
7601 /**
7602  * reg_fill_afc_location_obj() - Allocate and fill the AFC location object
7603  * pointer and return the pointer.
7604  * @pdev_priv_obj: Pointer to pdev private object
7605  * @afc_req: Pointer to AFC request.
7606  *
7607  * Return: Pointer to the AFC location object.
7608  */
7609 static struct wlan_afc_location *
7610 reg_fill_afc_location_obj(struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj,
7611 			  struct wlan_afc_host_request *afc_req)
7612 {
7613 	struct wlan_afc_location *p_afc_location;
7614 
7615 	p_afc_location = qdf_mem_malloc(sizeof(*p_afc_location));
7616 	if (!p_afc_location)
7617 		return NULL;
7618 
7619 	p_afc_location->deployment_type =
7620 				pdev_priv_obj->reg_afc_dev_deployment_type;
7621 	return p_afc_location;
7622 }
7623 
7624 QDF_STATUS
7625 reg_get_afc_req_info(struct wlan_objmgr_pdev *pdev,
7626 		     struct wlan_afc_host_request **afc_req)
7627 {
7628 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
7629 	struct wlan_afc_host_request *p_afc_req;
7630 
7631 	pdev_priv_obj = reg_get_pdev_obj(pdev);
7632 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
7633 		reg_err("pdev reg component is NULL");
7634 		return QDF_STATUS_E_INVAL;
7635 	}
7636 
7637 	if (!afc_req) {
7638 		reg_err("afc_req is NULL");
7639 		return QDF_STATUS_E_INVAL;
7640 	}
7641 
7642 	*afc_req = qdf_mem_malloc(sizeof(struct wlan_afc_host_request));
7643 	if (!*afc_req)
7644 		return QDF_STATUS_E_NOMEM;
7645 
7646 	p_afc_req = *afc_req;
7647 	p_afc_req->req_id = DEFAULT_REQ_ID;
7648 	p_afc_req->min_des_power = DEFAULT_MIN_POWER;
7649 
7650 	p_afc_req->freq_lst = reg_fill_freq_lst(pdev, pdev_priv_obj);
7651 	if (!p_afc_req->freq_lst) {
7652 		reg_err("Frange lst not allocated");
7653 		reg_free_afc_req(pdev, p_afc_req);
7654 		return QDF_STATUS_E_NOMEM;
7655 	}
7656 
7657 	p_afc_req->opclass_obj_lst = reg_fill_afc_opclass_obj_lst(pdev,
7658 								  p_afc_req);
7659 	if (!p_afc_req->opclass_obj_lst) {
7660 		reg_err("opclass object lst not allocated");
7661 		reg_free_afc_req(pdev, p_afc_req);
7662 		return QDF_STATUS_E_NOMEM;
7663 	}
7664 
7665 	p_afc_req->afc_location = reg_fill_afc_location_obj(pdev_priv_obj,
7666 							    p_afc_req);
7667 	if (!p_afc_req->afc_location) {
7668 		reg_err("AFC location not allocated");
7669 		reg_free_afc_req(pdev, p_afc_req);
7670 		return QDF_STATUS_E_NOMEM;
7671 	}
7672 
7673 	return QDF_STATUS_SUCCESS;
7674 }
7675 
7676 void reg_dmn_set_afc_req_id(struct wlan_afc_host_request *afc_req,
7677 			    uint64_t req_id)
7678 {
7679 
7680 	afc_req->req_id = req_id;
7681 }
7682 
7683 /**
7684  * reg_send_afc_request() - Send AFC request to registered recipient
7685  * @pdev: Pointer to pdev
7686  * @afc_req: Pointer to afc request
7687  *
7688  * Return: void
7689  */
7690 static
7691 void reg_send_afc_request(struct wlan_objmgr_pdev *pdev,
7692 			  struct wlan_afc_host_request *afc_req)
7693 {
7694 	afc_req_rx_evt_handler cbf;
7695 	void *arg;
7696 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
7697 
7698 	pdev_priv_obj = reg_get_pdev_obj(pdev);
7699 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
7700 		reg_err("pdev reg component is NULL");
7701 		return;
7702 	}
7703 
7704 	qdf_spin_lock_bh(&pdev_priv_obj->afc_cb_lock);
7705 	cbf = pdev_priv_obj->afc_cb_obj.func;
7706 	if (cbf) {
7707 		arg = pdev_priv_obj->afc_cb_obj.arg;
7708 		cbf(pdev, afc_req, arg);
7709 	}
7710 	qdf_spin_unlock_bh(&pdev_priv_obj->afc_cb_lock);
7711 }
7712 
7713 QDF_STATUS reg_afc_start(struct wlan_objmgr_pdev *pdev, uint64_t req_id)
7714 {
7715 	struct wlan_afc_host_request *afc_req;
7716 	QDF_STATUS status;
7717 
7718 	status = reg_get_afc_req_info(pdev, &afc_req);
7719 	if (status != QDF_STATUS_SUCCESS) {
7720 		reg_err("Creating AFC Request failed");
7721 		return QDF_STATUS_E_FAILURE;
7722 	}
7723 
7724 	QDF_TRACE(QDF_MODULE_ID_AFC, QDF_TRACE_LEVEL_DEBUG,
7725 		  "Processing AFC Start/Renew Expiry event");
7726 
7727 	reg_dmn_set_afc_req_id(afc_req, req_id);
7728 
7729 	reg_print_afc_req_info(pdev, afc_req);
7730 
7731 	reg_send_afc_request(pdev, afc_req);
7732 
7733 	reg_free_afc_req(pdev, afc_req);
7734 
7735 	return QDF_STATUS_SUCCESS;
7736 }
7737 
7738 QDF_STATUS reg_send_afc_power_event(struct wlan_objmgr_pdev *pdev,
7739 				    struct reg_fw_afc_power_event *power_info)
7740 {
7741 	afc_power_tx_evt_handler cbf;
7742 	void *arg;
7743 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
7744 
7745 	pdev_priv_obj = reg_get_pdev_obj(pdev);
7746 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
7747 		reg_err("pdev reg component is NULL");
7748 		return QDF_STATUS_E_FAILURE;
7749 	}
7750 
7751 	qdf_spin_lock_bh(&pdev_priv_obj->afc_cb_lock);
7752 	cbf = pdev_priv_obj->afc_pow_evt_cb_obj.func;
7753 	if (cbf) {
7754 		arg = pdev_priv_obj->afc_pow_evt_cb_obj.arg;
7755 		cbf(pdev, power_info, arg);
7756 	}
7757 
7758 	qdf_spin_unlock_bh(&pdev_priv_obj->afc_cb_lock);
7759 
7760 	return QDF_STATUS_SUCCESS;
7761 }
7762 
7763 QDF_STATUS reg_send_afc_payload_reset_event(struct wlan_objmgr_pdev *pdev)
7764 {
7765 	afc_payload_reset_tx_evt_handler cbf;
7766 	void *arg;
7767 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
7768 
7769 	pdev_priv_obj = reg_get_pdev_obj(pdev);
7770 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
7771 		reg_err("pdev reg component is NULL");
7772 		return QDF_STATUS_E_FAILURE;
7773 	}
7774 
7775 	qdf_spin_lock_bh(&pdev_priv_obj->afc_cb_lock);
7776 	cbf = pdev_priv_obj->afc_payload_reset_evt_cb_obj.func;
7777 	if (cbf) {
7778 		arg = pdev_priv_obj->afc_payload_reset_evt_cb_obj.arg;
7779 		cbf(pdev, arg);
7780 	}
7781 	qdf_spin_unlock_bh(&pdev_priv_obj->afc_cb_lock);
7782 
7783 	return QDF_STATUS_SUCCESS;
7784 }
7785 
7786 QDF_STATUS reg_register_afc_req_rx_callback(struct wlan_objmgr_pdev *pdev,
7787 					    afc_req_rx_evt_handler cbf,
7788 					    void *arg)
7789 {
7790 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
7791 
7792 	pdev_priv_obj = reg_get_pdev_obj(pdev);
7793 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
7794 		reg_err("pdev reg component is NULL");
7795 		return QDF_STATUS_E_FAILURE;
7796 	}
7797 
7798 	qdf_spin_lock_bh(&pdev_priv_obj->afc_cb_lock);
7799 	pdev_priv_obj->afc_cb_obj.func = cbf;
7800 	pdev_priv_obj->afc_cb_obj.arg = arg;
7801 	qdf_spin_unlock_bh(&pdev_priv_obj->afc_cb_lock);
7802 	reg_debug("afc_event_cb: 0x%pK, arg: 0x%pK", cbf, arg);
7803 
7804 	return QDF_STATUS_SUCCESS;
7805 }
7806 
7807 QDF_STATUS reg_unregister_afc_req_rx_callback(struct wlan_objmgr_pdev *pdev,
7808 					      afc_req_rx_evt_handler cbf)
7809 {
7810 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
7811 
7812 	pdev_priv_obj = reg_get_pdev_obj(pdev);
7813 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
7814 		reg_err("pdev reg component is NULL");
7815 		return QDF_STATUS_E_FAILURE;
7816 	}
7817 
7818 	qdf_spin_lock_bh(&pdev_priv_obj->afc_cb_lock);
7819 	if (pdev_priv_obj->afc_cb_obj.func == cbf) {
7820 		pdev_priv_obj->afc_cb_obj.func = NULL;
7821 		pdev_priv_obj->afc_cb_obj.arg = NULL;
7822 	} else {
7823 		reg_err("cb function=0x%pK not found", cbf);
7824 	}
7825 	qdf_spin_unlock_bh(&pdev_priv_obj->afc_cb_lock);
7826 
7827 	return QDF_STATUS_SUCCESS;
7828 }
7829 
7830 QDF_STATUS
7831 reg_register_afc_power_event_callback(struct wlan_objmgr_pdev *pdev,
7832 				      afc_power_tx_evt_handler cbf,
7833 				      void *arg)
7834 {
7835 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
7836 
7837 	pdev_priv_obj = reg_get_pdev_obj(pdev);
7838 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
7839 		reg_err("pdev reg component is NULL");
7840 		return QDF_STATUS_E_FAILURE;
7841 	}
7842 
7843 	qdf_spin_lock_bh(&pdev_priv_obj->afc_cb_lock);
7844 	pdev_priv_obj->afc_pow_evt_cb_obj.func = cbf;
7845 	pdev_priv_obj->afc_pow_evt_cb_obj.arg = arg;
7846 	qdf_spin_unlock_bh(&pdev_priv_obj->afc_cb_lock);
7847 	reg_debug("afc_power_event_cb: 0x%pK, arg: 0x%pK", cbf, arg);
7848 
7849 	return QDF_STATUS_SUCCESS;
7850 }
7851 
7852 QDF_STATUS
7853 reg_unregister_afc_power_event_callback(struct wlan_objmgr_pdev *pdev,
7854 					afc_power_tx_evt_handler cbf)
7855 {
7856 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
7857 
7858 	pdev_priv_obj = reg_get_pdev_obj(pdev);
7859 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
7860 		reg_err("pdev reg component is NULL");
7861 		return QDF_STATUS_E_FAILURE;
7862 	}
7863 
7864 	qdf_spin_lock_bh(&pdev_priv_obj->afc_cb_lock);
7865 	if (pdev_priv_obj->afc_pow_evt_cb_obj.func == cbf) {
7866 		pdev_priv_obj->afc_pow_evt_cb_obj.func = NULL;
7867 		pdev_priv_obj->afc_pow_evt_cb_obj.arg = NULL;
7868 	} else {
7869 		reg_err("cb function=0x%pK not found", cbf);
7870 	}
7871 	qdf_spin_unlock_bh(&pdev_priv_obj->afc_cb_lock);
7872 
7873 	return QDF_STATUS_SUCCESS;
7874 }
7875 
7876 QDF_STATUS
7877 reg_register_afc_payload_reset_event_callback(struct wlan_objmgr_pdev *pdev,
7878 					      afc_payload_reset_tx_evt_handler cbf,
7879 					      void *arg)
7880 {
7881 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
7882 
7883 	pdev_priv_obj = reg_get_pdev_obj(pdev);
7884 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
7885 		reg_err("pdev reg component is NULL");
7886 		return QDF_STATUS_E_FAILURE;
7887 	}
7888 
7889 	qdf_spin_lock_bh(&pdev_priv_obj->afc_cb_lock);
7890 	pdev_priv_obj->afc_payload_reset_evt_cb_obj.func = cbf;
7891 	pdev_priv_obj->afc_payload_reset_evt_cb_obj.arg = arg;
7892 	qdf_spin_unlock_bh(&pdev_priv_obj->afc_cb_lock);
7893 	reg_debug("afc_payload_reset_event_cb: 0x%pK, arg: 0x%pK", cbf, arg);
7894 
7895 	return QDF_STATUS_SUCCESS;
7896 }
7897 
7898 QDF_STATUS
7899 reg_unregister_afc_payload_reset_event_callback(struct wlan_objmgr_pdev *pdev,
7900 						afc_payload_reset_tx_evt_handler cbf)
7901 {
7902 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
7903 
7904 	pdev_priv_obj = reg_get_pdev_obj(pdev);
7905 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
7906 		reg_err("pdev reg component is NULL");
7907 		return QDF_STATUS_E_FAILURE;
7908 	}
7909 
7910 	qdf_spin_lock_bh(&pdev_priv_obj->afc_cb_lock);
7911 	if (pdev_priv_obj->afc_payload_reset_evt_cb_obj.func == cbf) {
7912 		pdev_priv_obj->afc_payload_reset_evt_cb_obj.func = NULL;
7913 		pdev_priv_obj->afc_payload_reset_evt_cb_obj.arg = NULL;
7914 	} else {
7915 		reg_err("cb function=0x%pK not found", cbf);
7916 	}
7917 	qdf_spin_unlock_bh(&pdev_priv_obj->afc_cb_lock);
7918 
7919 	return QDF_STATUS_SUCCESS;
7920 }
7921 
7922 QDF_STATUS
7923 reg_get_afc_dev_deploy_type(struct wlan_objmgr_pdev *pdev,
7924 			    enum reg_afc_dev_deploy_type *reg_afc_dev_type)
7925 {
7926 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
7927 
7928 	pdev_priv_obj = reg_get_pdev_obj(pdev);
7929 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
7930 		reg_err("pdev reg component is NULL");
7931 		return QDF_STATUS_E_FAILURE;
7932 	}
7933 
7934 	*reg_afc_dev_type = pdev_priv_obj->reg_afc_dev_deployment_type;
7935 
7936 	return QDF_STATUS_SUCCESS;
7937 }
7938 
7939 bool
7940 reg_is_sta_connect_allowed(struct wlan_objmgr_pdev *pdev,
7941 			   enum reg_6g_ap_type root_ap_pwr_mode)
7942 {
7943 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
7944 
7945 	pdev_priv_obj = reg_get_pdev_obj(pdev);
7946 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
7947 		reg_err("pdev reg component is NULL");
7948 		return false;
7949 	}
7950 
7951 	if (reg_get_num_rules_of_ap_pwr_type(pdev, REG_STANDARD_POWER_AP) &&
7952 	    (pdev_priv_obj->reg_afc_dev_deployment_type == AFC_DEPLOYMENT_OUTDOOR)) {
7953 		if (root_ap_pwr_mode == REG_STANDARD_POWER_AP)
7954 			return true;
7955 		else
7956 			return false;
7957 	}
7958 
7959 	return true;
7960 }
7961 
7962 QDF_STATUS reg_set_afc_soc_dev_type(struct wlan_objmgr_psoc *psoc,
7963 				    enum reg_afc_dev_deploy_type
7964 				    reg_afc_dev_type)
7965 {
7966 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
7967 
7968 	psoc_priv_obj = reg_get_psoc_obj(psoc);
7969 
7970 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
7971 		reg_err("psoc reg component is NULL");
7972 		return QDF_STATUS_E_FAILURE;
7973 	}
7974 
7975 	psoc_priv_obj->reg_afc_dev_type = reg_afc_dev_type;
7976 
7977 	return QDF_STATUS_SUCCESS;
7978 }
7979 
7980 QDF_STATUS
7981 reg_get_afc_soc_dev_type(struct wlan_objmgr_psoc *psoc,
7982 			 enum reg_afc_dev_deploy_type *reg_afc_dev_type)
7983 {
7984 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
7985 
7986 	psoc_priv_obj = reg_get_psoc_obj(psoc);
7987 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
7988 		reg_err("psoc reg component is NULL");
7989 		return QDF_STATUS_E_FAILURE;
7990 	}
7991 
7992 	*reg_afc_dev_type = psoc_priv_obj->reg_afc_dev_type;
7993 
7994 	return QDF_STATUS_SUCCESS;
7995 }
7996 
7997 QDF_STATUS
7998 reg_set_eirp_preferred_support(struct wlan_objmgr_psoc *psoc,
7999 			       bool reg_is_eirp_support_preferred)
8000 {
8001 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
8002 
8003 	psoc_priv_obj = reg_get_psoc_obj(psoc);
8004 
8005 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
8006 		reg_err("psoc reg component is NULL");
8007 		return QDF_STATUS_E_FAILURE;
8008 	}
8009 
8010 	psoc_priv_obj->reg_is_eirp_support_preferred =
8011 					reg_is_eirp_support_preferred;
8012 
8013 	return QDF_STATUS_SUCCESS;
8014 }
8015 
8016 QDF_STATUS
8017 reg_get_eirp_preferred_support(struct wlan_objmgr_psoc *psoc,
8018 			       bool *reg_is_eirp_support_preferred)
8019 {
8020 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
8021 
8022 	psoc_priv_obj = reg_get_psoc_obj(psoc);
8023 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
8024 		reg_err("psoc reg component is NULL");
8025 		return QDF_STATUS_E_FAILURE;
8026 	}
8027 
8028 	*reg_is_eirp_support_preferred =
8029 			psoc_priv_obj->reg_is_eirp_support_preferred;
8030 
8031 	return QDF_STATUS_SUCCESS;
8032 }
8033 
8034 #endif /* CONFIG_AFC_SUPPORT */
8035 
8036 QDF_STATUS
8037 reg_get_cur_6g_client_type(struct wlan_objmgr_pdev *pdev,
8038 			   enum reg_6g_client_type
8039 			   *reg_cur_6g_client_mobility_type)
8040 {
8041 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
8042 
8043 	pdev_priv_obj = reg_get_pdev_obj(pdev);
8044 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
8045 		reg_err("pdev reg component is NULL");
8046 		return QDF_STATUS_E_FAILURE;
8047 	}
8048 
8049 	if (pdev_priv_obj->reg_cur_6g_client_mobility_type >=
8050 	    REG_MAX_CLIENT_TYPE)
8051 		return QDF_STATUS_E_FAILURE;
8052 
8053 	*reg_cur_6g_client_mobility_type =
8054 	    pdev_priv_obj->reg_cur_6g_client_mobility_type;
8055 
8056 	return QDF_STATUS_SUCCESS;
8057 }
8058 
8059 QDF_STATUS
8060 reg_set_cur_6ghz_client_type(struct wlan_objmgr_pdev *pdev,
8061 			     enum reg_6g_client_type in_6ghz_client_type)
8062 {
8063 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
8064 
8065 	pdev_priv_obj = reg_get_pdev_obj(pdev);
8066 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
8067 		reg_err("pdev reg component is NULL");
8068 		return QDF_STATUS_E_FAILURE;
8069 	}
8070 
8071 	if (in_6ghz_client_type >= REG_MAX_CLIENT_TYPE)
8072 		return QDF_STATUS_E_FAILURE;
8073 
8074 	pdev_priv_obj->reg_cur_6g_client_mobility_type = in_6ghz_client_type;
8075 
8076 	return QDF_STATUS_SUCCESS;
8077 }
8078 
8079 QDF_STATUS
8080 reg_set_6ghz_client_type_from_target(struct wlan_objmgr_pdev *pdev)
8081 {
8082 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
8083 
8084 	pdev_priv_obj = reg_get_pdev_obj(pdev);
8085 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
8086 		reg_err("pdev reg component is NULL");
8087 		return QDF_STATUS_E_FAILURE;
8088 	}
8089 
8090 	pdev_priv_obj->reg_cur_6g_client_mobility_type =
8091 					pdev_priv_obj->reg_target_client_type;
8092 
8093 	return QDF_STATUS_SUCCESS;
8094 }
8095 
8096 QDF_STATUS reg_get_rnr_tpe_usable(struct wlan_objmgr_pdev *pdev,
8097 				  bool *reg_rnr_tpe_usable)
8098 {
8099 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
8100 
8101 	pdev_priv_obj = reg_get_pdev_obj(pdev);
8102 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
8103 		reg_err("pdev reg component is NULL");
8104 		return QDF_STATUS_E_FAILURE;
8105 	}
8106 	*reg_rnr_tpe_usable = pdev_priv_obj->reg_rnr_tpe_usable;
8107 	return QDF_STATUS_SUCCESS;
8108 }
8109 
8110 QDF_STATUS reg_get_unspecified_ap_usable(struct wlan_objmgr_pdev *pdev,
8111 					 bool *reg_unspecified_ap_usable)
8112 {
8113 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
8114 
8115 	pdev_priv_obj = reg_get_pdev_obj(pdev);
8116 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
8117 		reg_err("pdev reg component is NULL");
8118 		return QDF_STATUS_E_FAILURE;
8119 	}
8120 	*reg_unspecified_ap_usable = pdev_priv_obj->reg_unspecified_ap_usable;
8121 	return QDF_STATUS_SUCCESS;
8122 }
8123 
8124 QDF_STATUS
8125 reg_find_txpower_from_6g_list(qdf_freq_t freq,
8126 			      struct regulatory_channel *chan_list,
8127 			      int16_t *txpower)
8128 {
8129 	enum channel_enum chan_enum;
8130 
8131 	*txpower = 0;
8132 
8133 	for (chan_enum = 0; chan_enum < NUM_6GHZ_CHANNELS; chan_enum++) {
8134 		if (chan_list[chan_enum].center_freq == freq) {
8135 			*txpower = chan_list[chan_enum].tx_power;
8136 			return QDF_STATUS_SUCCESS;
8137 		}
8138 	}
8139 
8140 	return QDF_STATUS_E_FAILURE;
8141 }
8142 
8143 bool reg_is_6g_psd_power(struct wlan_objmgr_pdev *pdev)
8144 {
8145 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
8146 	struct regulatory_channel *cur_chan_list;
8147 	enum channel_enum i;
8148 
8149 	if (!pdev) {
8150 		reg_err("pdev is NULL");
8151 		return false;
8152 	}
8153 
8154 	pdev_priv_obj = reg_get_pdev_obj(pdev);
8155 	if (!pdev_priv_obj) {
8156 		reg_err("pdev priv obj is NULL");
8157 		return false;
8158 	}
8159 
8160 	cur_chan_list = pdev_priv_obj->cur_chan_list;
8161 
8162 	for (i = MIN_6GHZ_CHANNEL; i <= MAX_6GHZ_CHANNEL; i++) {
8163 		if (!(cur_chan_list[i].chan_flags & REGULATORY_CHAN_DISABLED))
8164 			return cur_chan_list[i].psd_flag;
8165 	}
8166 
8167 	return false;
8168 }
8169 
8170 QDF_STATUS
8171 reg_get_6g_chan_psd_eirp_power(qdf_freq_t freq,
8172 			       struct regulatory_channel *mas_chan_list,
8173 			       int16_t *eirp_psd_power)
8174 {
8175 	uint16_t i;
8176 
8177 	if (!mas_chan_list) {
8178 		reg_err_rl("mas_chan_list is NULL");
8179 		return QDF_STATUS_E_FAILURE;
8180 	}
8181 
8182 	for (i = 0; i < NUM_6GHZ_CHANNELS; i++) {
8183 		if (freq == mas_chan_list[i].center_freq) {
8184 			*eirp_psd_power = mas_chan_list[i].psd_eirp;
8185 			return QDF_STATUS_SUCCESS;
8186 		}
8187 	}
8188 
8189 	return QDF_STATUS_E_FAILURE;
8190 }
8191 
8192 QDF_STATUS reg_get_6g_chan_ap_power(struct wlan_objmgr_pdev *pdev,
8193 				    qdf_freq_t chan_freq, bool *is_psd,
8194 				    int16_t *tx_power,
8195 				    int16_t *eirp_psd_power)
8196 {
8197 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
8198 	struct regulatory_channel *master_chan_list;
8199 	enum reg_6g_ap_type ap_pwr_type;
8200 	QDF_STATUS status = QDF_STATUS_SUCCESS;
8201 
8202 	pdev_priv_obj = reg_get_pdev_obj(pdev);
8203 	if (!pdev_priv_obj) {
8204 		reg_err("pdev priv obj is NULL");
8205 		return QDF_STATUS_E_FAILURE;
8206 	}
8207 
8208 	status = reg_get_cur_6g_ap_pwr_type(pdev, &ap_pwr_type);
8209 	if (!QDF_IS_STATUS_SUCCESS(status))
8210 		return status;
8211 
8212 	master_chan_list = pdev_priv_obj->mas_chan_list_6g_ap[ap_pwr_type];
8213 
8214 	reg_find_txpower_from_6g_list(chan_freq, master_chan_list,
8215 				      tx_power);
8216 
8217 	*is_psd = reg_is_6g_psd_power(pdev);
8218 	if (*is_psd)
8219 		status = reg_get_6g_chan_psd_eirp_power(chan_freq,
8220 							master_chan_list,
8221 							eirp_psd_power);
8222 
8223 	return status;
8224 }
8225 
8226 QDF_STATUS reg_get_client_power_for_connecting_ap(struct wlan_objmgr_pdev *pdev,
8227 						  enum reg_6g_ap_type ap_type,
8228 						  qdf_freq_t chan_freq,
8229 						  bool is_psd,
8230 						  uint16_t *tx_power,
8231 						  uint16_t *eirp_psd_power)
8232 {
8233 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
8234 	enum reg_6g_client_type client_type = REG_DEFAULT_CLIENT;
8235 	struct regulatory_channel *master_chan_list;
8236 	QDF_STATUS status = QDF_STATUS_SUCCESS;
8237 
8238 	pdev_priv_obj = reg_get_pdev_obj(pdev);
8239 	if (!pdev_priv_obj) {
8240 		reg_err("pdev priv obj is NULL");
8241 		return QDF_STATUS_E_FAILURE;
8242 	}
8243 
8244 	reg_get_cur_6g_client_type(pdev, &client_type);
8245 
8246 	master_chan_list =
8247 		pdev_priv_obj->mas_chan_list_6g_client[ap_type][client_type];
8248 
8249 	reg_find_txpower_from_6g_list(chan_freq, master_chan_list,
8250 				      tx_power);
8251 
8252 	if (is_psd)
8253 		status = reg_get_6g_chan_psd_eirp_power(chan_freq,
8254 							master_chan_list,
8255 							eirp_psd_power);
8256 
8257 	return status;
8258 }
8259 
8260 QDF_STATUS reg_get_client_power_for_6ghz_ap(struct wlan_objmgr_pdev *pdev,
8261 					    enum reg_6g_client_type client_type,
8262 					    qdf_freq_t chan_freq,
8263 					    bool *is_psd, uint16_t *tx_power,
8264 					    uint16_t *eirp_psd_power)
8265 {
8266 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
8267 	enum reg_6g_ap_type ap_pwr_type;
8268 	struct regulatory_channel *master_chan_list;
8269 	QDF_STATUS status = QDF_STATUS_SUCCESS;
8270 
8271 	status = reg_get_cur_6g_ap_pwr_type(pdev, &ap_pwr_type);
8272 	if (!QDF_IS_STATUS_SUCCESS(status))
8273 		return status;
8274 
8275 	pdev_priv_obj = reg_get_pdev_obj(pdev);
8276 	if (!pdev_priv_obj) {
8277 		reg_err("pdev priv obj is NULL");
8278 		return QDF_STATUS_E_FAILURE;
8279 	}
8280 
8281 	master_chan_list = pdev_priv_obj->
8282 			mas_chan_list_6g_client[ap_pwr_type][client_type];
8283 
8284 	reg_find_txpower_from_6g_list(chan_freq, master_chan_list,
8285 				      tx_power);
8286 
8287 	*is_psd = reg_is_6g_psd_power(pdev);
8288 	if (*is_psd)
8289 		status = reg_get_6g_chan_psd_eirp_power(chan_freq,
8290 							master_chan_list,
8291 							eirp_psd_power);
8292 
8293 	return status;
8294 }
8295 
8296 QDF_STATUS reg_set_ap_pwr_and_update_chan_list(struct wlan_objmgr_pdev *pdev,
8297 		enum reg_6g_ap_type ap_pwr_type)
8298 {
8299 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
8300 	QDF_STATUS status;
8301 
8302 	pdev_priv_obj = reg_get_pdev_obj(pdev);
8303 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
8304 		reg_err("pdev reg component is NULL");
8305 		return QDF_STATUS_E_INVAL;
8306 	}
8307 
8308 	if (!reg_get_num_rules_of_ap_pwr_type(pdev, ap_pwr_type))
8309 		return QDF_STATUS_E_FAILURE;
8310 
8311 	status = reg_set_cur_6g_ap_pwr_type(pdev, ap_pwr_type);
8312 	if (QDF_IS_STATUS_ERROR(status)) {
8313 		reg_debug("failed to set AP power type to %d",
8314 				ap_pwr_type);
8315 		return status;
8316 	}
8317 	reg_compute_pdev_current_chan_list(pdev_priv_obj);
8318 
8319 	return QDF_STATUS_SUCCESS;
8320 }
8321 #endif
8322 
8323 bool reg_is_regdb_offloaded(struct wlan_objmgr_psoc *psoc)
8324 {
8325 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
8326 
8327 	psoc_priv_obj = reg_get_psoc_obj(psoc);
8328 	if (!psoc_priv_obj) {
8329 		reg_err("reg psoc private obj is NULL");
8330 		return false;
8331 	}
8332 
8333 	return psoc_priv_obj->offload_enabled;
8334 }
8335 
8336 QDF_STATUS
8337 reg_set_ext_tpc_supported(struct wlan_objmgr_psoc *psoc, bool val)
8338 {
8339 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
8340 
8341 	psoc_priv_obj = reg_get_psoc_obj(psoc);
8342 
8343 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
8344 		reg_err("psoc reg component is NULL");
8345 		return QDF_STATUS_E_FAILURE;
8346 	}
8347 
8348 	psoc_priv_obj->is_ext_tpc_supported = val;
8349 
8350 	return QDF_STATUS_SUCCESS;
8351 }
8352 
8353 bool reg_is_ext_tpc_supported(struct wlan_objmgr_psoc *psoc)
8354 {
8355 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
8356 
8357 	psoc_priv_obj = reg_get_psoc_obj(psoc);
8358 
8359 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
8360 		reg_err("psoc reg component is NULL");
8361 		return  false;
8362 	}
8363 
8364 	return psoc_priv_obj->is_ext_tpc_supported;
8365 }
8366 
8367 #if defined(CONFIG_BAND_6GHZ)
8368 QDF_STATUS
8369 reg_set_lower_6g_edge_ch_supp(struct wlan_objmgr_psoc *psoc, bool val)
8370 {
8371 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
8372 
8373 	psoc_priv_obj = reg_get_psoc_obj(psoc);
8374 
8375 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
8376 		reg_err("psoc reg component is NULL");
8377 		return QDF_STATUS_E_FAILURE;
8378 	}
8379 
8380 	psoc_priv_obj->is_lower_6g_edge_ch_supported = val;
8381 
8382 	return QDF_STATUS_SUCCESS;
8383 }
8384 
8385 QDF_STATUS
8386 reg_set_disable_upper_6g_edge_ch_supp(struct wlan_objmgr_psoc *psoc, bool val)
8387 {
8388 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
8389 
8390 	psoc_priv_obj = reg_get_psoc_obj(psoc);
8391 
8392 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
8393 		reg_err("psoc reg component is NULL");
8394 		return QDF_STATUS_E_FAILURE;
8395 	}
8396 
8397 	psoc_priv_obj->is_upper_6g_edge_ch_disabled = val;
8398 
8399 	return QDF_STATUS_SUCCESS;
8400 }
8401 
8402 bool reg_is_lower_6g_edge_ch_supp(struct wlan_objmgr_psoc *psoc)
8403 {
8404 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
8405 
8406 	psoc_priv_obj = reg_get_psoc_obj(psoc);
8407 
8408 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
8409 		reg_err("psoc reg component is NULL");
8410 		return  false;
8411 	}
8412 
8413 	return psoc_priv_obj->is_lower_6g_edge_ch_supported;
8414 }
8415 
8416 bool reg_is_upper_6g_edge_ch_disabled(struct wlan_objmgr_psoc *psoc)
8417 {
8418 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
8419 
8420 	psoc_priv_obj = reg_get_psoc_obj(psoc);
8421 
8422 	if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) {
8423 		reg_err("psoc reg component is NULL");
8424 		return  false;
8425 	}
8426 
8427 	return psoc_priv_obj->is_upper_6g_edge_ch_disabled;
8428 }
8429 
8430 static inline bool reg_is_within_range_inclusive(enum channel_enum left,
8431 						 enum channel_enum right,
8432 						 enum channel_enum idx)
8433 {
8434 	return (idx >= left) && (idx <= right);
8435 }
8436 
8437 uint16_t reg_convert_enum_to_6g_idx(enum channel_enum ch_idx)
8438 {
8439 	if (!reg_is_within_range_inclusive(MIN_6GHZ_CHANNEL,
8440 					   MAX_6GHZ_CHANNEL,
8441 					   ch_idx))
8442 		return INVALID_CHANNEL;
8443 
8444 	return (ch_idx - MIN_6GHZ_CHANNEL);
8445 }
8446 
8447 QDF_STATUS
8448 reg_get_superchan_entry(struct wlan_objmgr_pdev *pdev,
8449 			enum channel_enum chan_enum,
8450 			const struct super_chan_info **p_sup_chan_entry)
8451 {
8452 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
8453 	uint16_t sup_idx;
8454 
8455 	sup_idx = reg_convert_enum_to_6g_idx(chan_enum);
8456 
8457 	if (reg_is_chan_enum_invalid(sup_idx)) {
8458 		reg_debug("super channel idx is invalid for the chan_enum %d",
8459 			  chan_enum);
8460 		return QDF_STATUS_E_INVAL;
8461 	}
8462 
8463 	pdev_priv_obj = reg_get_pdev_obj(pdev);
8464 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
8465 		reg_err_rl("pdev reg component is NULL");
8466 		return QDF_STATUS_E_INVAL;
8467 	}
8468 
8469 	if (!p_sup_chan_entry) {
8470 		reg_err_rl("p_sup_chan_entry is NULL");
8471 		return QDF_STATUS_E_INVAL;
8472 	}
8473 
8474 	if (sup_idx >= NUM_6GHZ_CHANNELS) {
8475 		reg_debug("sup_idx is out of bounds");
8476 		return QDF_STATUS_E_INVAL;
8477 	}
8478 
8479 	*p_sup_chan_entry = &pdev_priv_obj->super_chan_list[sup_idx];
8480 
8481 	return QDF_STATUS_SUCCESS;
8482 }
8483 #endif
8484 
8485 #ifdef FEATURE_WLAN_CH_AVOID_EXT
8486 /**
8487  * reg_process_ch_avoid_freq_ext() - Update extended avoid frequencies in
8488  * psoc_priv_obj
8489  * @psoc: Pointer to psoc structure
8490  * @pdev: pointer to pdev object
8491  *
8492  * Return: None
8493  */
8494 static QDF_STATUS
8495 reg_process_ch_avoid_freq_ext(struct wlan_objmgr_psoc *psoc,
8496 			      struct wlan_objmgr_pdev *pdev)
8497 {
8498 	uint32_t i;
8499 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
8500 	uint8_t start_channel;
8501 	uint8_t end_channel;
8502 	int32_t txpower;
8503 	bool is_valid_txpower;
8504 	struct ch_avoid_freq_type *range;
8505 	enum channel_enum ch_loop;
8506 	enum channel_enum start_ch_idx;
8507 	enum channel_enum end_ch_idx;
8508 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
8509 	uint32_t len;
8510 	struct unsafe_ch_list *unsafe_ch_list;
8511 	bool coex_unsafe_nb_user_prefer;
8512 
8513 	pdev_priv_obj = reg_get_pdev_obj(pdev);
8514 
8515 	if (!pdev_priv_obj) {
8516 		reg_err("reg pdev private obj is NULL");
8517 		return QDF_STATUS_E_FAILURE;
8518 	}
8519 	psoc_priv_obj = reg_get_psoc_obj(psoc);
8520 	if (!psoc_priv_obj) {
8521 		reg_err("reg psoc private obj is NULL");
8522 		return QDF_STATUS_E_FAILURE;
8523 	}
8524 
8525 	unsafe_ch_list = &psoc_priv_obj->unsafe_chan_list;
8526 	coex_unsafe_nb_user_prefer =
8527 		psoc_priv_obj->coex_unsafe_chan_nb_user_prefer;
8528 
8529 	if (pdev_priv_obj->avoid_chan_ext_list.chan_cnt > 0) {
8530 		len = sizeof(pdev_priv_obj->avoid_chan_ext_list.chan_freq_list);
8531 		pdev_priv_obj->avoid_chan_ext_list.chan_cnt = 0;
8532 		qdf_mem_zero(&pdev_priv_obj->avoid_chan_ext_list.chan_freq_list,
8533 			     len);
8534 	}
8535 
8536 	if (unsafe_ch_list->chan_cnt > 0) {
8537 		len = sizeof(unsafe_ch_list->chan_freq_list);
8538 		unsafe_ch_list->chan_cnt = 0;
8539 		qdf_mem_zero(unsafe_ch_list->chan_freq_list, len);
8540 	}
8541 
8542 	for (i = 0; i < psoc_priv_obj->avoid_freq_ext_list.ch_avoid_range_cnt;
8543 		i++) {
8544 		if (pdev_priv_obj->avoid_chan_ext_list.chan_cnt >=
8545 		    NUM_CHANNELS) {
8546 			reg_debug("ext avoid channel list full");
8547 			break;
8548 		}
8549 
8550 		if (unsafe_ch_list->chan_cnt >= NUM_CHANNELS) {
8551 			reg_warn("LTE Coex unsafe channel list full");
8552 			break;
8553 		}
8554 
8555 		start_ch_idx = INVALID_CHANNEL;
8556 		end_ch_idx = INVALID_CHANNEL;
8557 		range = &psoc_priv_obj->avoid_freq_ext_list.avoid_freq_range[i];
8558 
8559 		start_channel = reg_freq_to_chan(pdev, range->start_freq);
8560 		end_channel = reg_freq_to_chan(pdev, range->end_freq);
8561 		txpower = range->txpower;
8562 		is_valid_txpower = range->is_valid_txpower;
8563 
8564 		reg_debug("start: freq %d, ch %d, end: freq %d, ch %d txpower %d",
8565 			  range->start_freq, start_channel, range->end_freq,
8566 			  end_channel, txpower);
8567 
8568 		/* do not process frequency bands that are not mapped to
8569 		 * predefined channels
8570 		 */
8571 		if (start_channel == 0 || end_channel == 0)
8572 			continue;
8573 
8574 		for (ch_loop = 0; ch_loop < NUM_CHANNELS;
8575 			ch_loop++) {
8576 			if (REG_CH_TO_FREQ(ch_loop) >= range->start_freq) {
8577 				start_ch_idx = ch_loop;
8578 				break;
8579 			}
8580 		}
8581 		for (ch_loop = 0; ch_loop < NUM_CHANNELS;
8582 			ch_loop++) {
8583 			if (REG_CH_TO_FREQ(ch_loop) >= range->end_freq) {
8584 				end_ch_idx = ch_loop;
8585 				if (REG_CH_TO_FREQ(ch_loop) > range->end_freq)
8586 					end_ch_idx--;
8587 				break;
8588 			}
8589 		}
8590 
8591 		if (reg_is_chan_enum_invalid(start_ch_idx) ||
8592 		    reg_is_chan_enum_invalid(end_ch_idx))
8593 			continue;
8594 
8595 		for (ch_loop = start_ch_idx; ch_loop <= end_ch_idx;
8596 			ch_loop++) {
8597 			pdev_priv_obj->avoid_chan_ext_list.chan_freq_list
8598 			[pdev_priv_obj->avoid_chan_ext_list.chan_cnt++] =
8599 			REG_CH_TO_FREQ(ch_loop);
8600 
8601 			if (coex_unsafe_nb_user_prefer) {
8602 				if (unsafe_ch_list->chan_cnt >=
8603 					NUM_CHANNELS) {
8604 					reg_warn("LTECoex unsafe ch list full");
8605 					break;
8606 				}
8607 				unsafe_ch_list->txpower[
8608 				unsafe_ch_list->chan_cnt] =
8609 					txpower;
8610 				unsafe_ch_list->is_valid_txpower[
8611 				unsafe_ch_list->chan_cnt] =
8612 					is_valid_txpower;
8613 				unsafe_ch_list->chan_freq_list[
8614 				unsafe_ch_list->chan_cnt++] =
8615 					REG_CH_TO_FREQ(ch_loop);
8616 			}
8617 
8618 			if (pdev_priv_obj->avoid_chan_ext_list.chan_cnt >=
8619 				NUM_CHANNELS) {
8620 				reg_debug("avoid freq ext list full");
8621 				break;
8622 			}
8623 		}
8624 		/* if start == end for 5G, meanwhile it only have one valid
8625 		 * channel updated, then disable 20M by default around
8626 		 * this center freq. For example input [5805-5805], it
8627 		 * will disable 20Mhz around 5805, then the range change
8628 		 * to [5705-5815], otherwise, not sure about how many width
8629 		 * need to disabled for such case.
8630 		 */
8631 		if ((ch_loop - start_ch_idx) == 1 &&
8632 		    (range->end_freq - range->start_freq == 0) &&
8633 			reg_is_5ghz_ch_freq(range->start_freq)) {
8634 			range->start_freq = range->start_freq - HALF_20MHZ_BW;
8635 			range->end_freq = range->end_freq + HALF_20MHZ_BW;
8636 		}
8637 
8638 		for (ch_loop = 0; ch_loop <
8639 			unsafe_ch_list->chan_cnt; ch_loop++) {
8640 			if (ch_loop >= NUM_CHANNELS)
8641 				break;
8642 			reg_debug("Unsafe freq %d",
8643 				  unsafe_ch_list->chan_freq_list[ch_loop]);
8644 		}
8645 	}
8646 
8647 	return QDF_STATUS_SUCCESS;
8648 }
8649 
8650 /**
8651  * reg_update_avoid_ch_ext() - Updates the current channel list that block out
8652  * by extended avoid frequency list
8653  * @psoc: Pointer to psoc structure
8654  * @object: Pointer to pdev structure
8655  * @arg: List of arguments
8656  *
8657  * Return: None
8658  */
8659 static void
8660 reg_update_avoid_ch_ext(struct wlan_objmgr_psoc *psoc,
8661 			void *object, void *arg)
8662 {
8663 	struct wlan_objmgr_pdev *pdev = (struct wlan_objmgr_pdev *)object;
8664 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
8665 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
8666 	QDF_STATUS status;
8667 
8668 	psoc_priv_obj = reg_get_psoc_obj(psoc);
8669 	if (!psoc_priv_obj) {
8670 		reg_err("reg psoc private obj is NULL");
8671 		return;
8672 	}
8673 
8674 	pdev_priv_obj = reg_get_pdev_obj(pdev);
8675 
8676 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
8677 		reg_err("reg pdev priv obj is NULL");
8678 		return;
8679 	}
8680 
8681 	if (psoc_priv_obj->ch_avoid_ext_ind) {
8682 		status = reg_process_ch_avoid_freq_ext(psoc, pdev);
8683 		if (QDF_IS_STATUS_ERROR(status))
8684 			psoc_priv_obj->ch_avoid_ext_ind = false;
8685 	}
8686 
8687 	reg_compute_pdev_current_chan_list(pdev_priv_obj);
8688 	status = reg_send_scheduler_msg_sb(psoc, pdev);
8689 
8690 	if (QDF_IS_STATUS_ERROR(status))
8691 		reg_err("channel change msg schedule failed");
8692 }
8693 
8694 QDF_STATUS
8695 reg_process_ch_avoid_ext_event(struct wlan_objmgr_psoc *psoc,
8696 			       struct ch_avoid_ind_type *ch_avoid_event)
8697 {
8698 	uint32_t i;
8699 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
8700 	QDF_STATUS status;
8701 	struct ch_avoid_freq_type *range;
8702 
8703 	psoc_priv_obj = reg_get_psoc_obj(psoc);
8704 	if (!psoc_priv_obj) {
8705 		reg_err("reg psoc private obj is NULL");
8706 		return QDF_STATUS_E_FAILURE;
8707 	}
8708 
8709 	reg_debug("freq range count %d", ch_avoid_event->ch_avoid_range_cnt);
8710 
8711 	qdf_mem_zero(&psoc_priv_obj->avoid_freq_ext_list,
8712 		     sizeof(struct ch_avoid_ind_type));
8713 
8714 	for (i = 0; i < ch_avoid_event->ch_avoid_range_cnt; i++) {
8715 		range = &psoc_priv_obj->avoid_freq_ext_list.avoid_freq_range[i];
8716 		range->start_freq =
8717 			ch_avoid_event->avoid_freq_range[i].start_freq;
8718 		range->end_freq =
8719 			ch_avoid_event->avoid_freq_range[i].end_freq;
8720 		range->txpower =
8721 			ch_avoid_event->avoid_freq_range[i].txpower;
8722 		range->is_valid_txpower =
8723 			ch_avoid_event->avoid_freq_range[i].is_valid_txpower;
8724 	}
8725 
8726 	psoc_priv_obj->avoid_freq_ext_list.restriction_mask =
8727 		ch_avoid_event->restriction_mask;
8728 	psoc_priv_obj->avoid_freq_ext_list.ch_avoid_range_cnt =
8729 		ch_avoid_event->ch_avoid_range_cnt;
8730 
8731 	psoc_priv_obj->ch_avoid_ext_ind = true;
8732 
8733 	status = wlan_objmgr_psoc_try_get_ref(psoc, WLAN_REGULATORY_SB_ID);
8734 
8735 	if (QDF_IS_STATUS_ERROR(status)) {
8736 		reg_err("error taking psoc ref cnt");
8737 		return status;
8738 	}
8739 
8740 	status = wlan_objmgr_iterate_obj_list(psoc, WLAN_PDEV_OP,
8741 					      reg_update_avoid_ch_ext,
8742 					      NULL, 1,
8743 					      WLAN_REGULATORY_SB_ID);
8744 
8745 	wlan_objmgr_psoc_release_ref(psoc, WLAN_REGULATORY_SB_ID);
8746 
8747 	return status;
8748 }
8749 
8750 bool reg_check_coex_unsafe_nb_user_prefer(struct wlan_objmgr_psoc *psoc)
8751 {
8752 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
8753 
8754 	psoc_priv_obj = reg_get_psoc_obj(psoc);
8755 	if (!psoc_priv_obj) {
8756 		reg_err("reg psoc private obj is NULL");
8757 		return false;
8758 	}
8759 
8760 	return psoc_priv_obj->coex_unsafe_chan_nb_user_prefer;
8761 }
8762 
8763 bool reg_check_coex_unsafe_chan_reg_disable(struct wlan_objmgr_psoc *psoc)
8764 {
8765 	struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj;
8766 
8767 	psoc_priv_obj = reg_get_psoc_obj(psoc);
8768 	if (!psoc_priv_obj) {
8769 		reg_err("reg psoc private obj is NULL");
8770 		return false;
8771 	}
8772 
8773 	return psoc_priv_obj->coex_unsafe_chan_reg_disable;
8774 }
8775 #endif
8776 
8777 #if defined(CONFIG_AFC_SUPPORT) && defined(CONFIG_BAND_6GHZ)
8778 QDF_STATUS reg_send_afc_cmd(struct wlan_objmgr_pdev *pdev,
8779 			    struct reg_afc_resp_rx_ind_info *afc_ind_obj)
8780 {
8781 	uint8_t pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev);
8782 	struct wlan_objmgr_psoc *psoc;
8783 	struct wlan_lmac_if_reg_tx_ops *tx_ops;
8784 
8785 	psoc = wlan_pdev_get_psoc(pdev);
8786 	if (!psoc) {
8787 		reg_err("psoc is NULL");
8788 		return QDF_STATUS_E_INVAL;
8789 	}
8790 
8791 	tx_ops = reg_get_psoc_tx_ops(psoc);
8792 	if (tx_ops->send_afc_ind)
8793 		return tx_ops->send_afc_ind(psoc, pdev_id, afc_ind_obj);
8794 
8795 	return QDF_STATUS_E_FAILURE;
8796 }
8797 
8798 bool reg_is_afc_power_event_received(struct wlan_objmgr_pdev *pdev)
8799 {
8800 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
8801 
8802 	pdev_priv_obj = reg_get_pdev_obj(pdev);
8803 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
8804 		reg_err("pdev reg component is NULL");
8805 		return false;
8806 	}
8807 
8808 	return pdev_priv_obj->is_6g_afc_power_event_received;
8809 }
8810 
8811 bool reg_is_afc_done(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq)
8812 {
8813 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
8814 	uint32_t chan_flags;
8815 
8816 	pdev_priv_obj = reg_get_pdev_obj(pdev);
8817 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
8818 		reg_err("pdev reg component is NULL");
8819 		return false;
8820 	}
8821 
8822 	chan_flags = reg_get_channel_flags_for_freq(pdev, freq);
8823 
8824 	return !(chan_flags & REGULATORY_CHAN_AFC_NOT_DONE);
8825 }
8826 
8827 QDF_STATUS reg_get_afc_req_id(struct wlan_objmgr_pdev *pdev, uint64_t *req_id)
8828 {
8829 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
8830 
8831 	pdev_priv_obj = reg_get_pdev_obj(pdev);
8832 
8833 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
8834 		reg_err("reg pdev priv obj is NULL");
8835 		return QDF_STATUS_E_FAILURE;
8836 	}
8837 
8838 	*req_id = pdev_priv_obj->afc_request_id;
8839 
8840 	return QDF_STATUS_SUCCESS;
8841 }
8842 
8843 bool reg_is_afc_expiry_event_received(struct wlan_objmgr_pdev *pdev)
8844 {
8845 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
8846 
8847 	pdev_priv_obj = reg_get_pdev_obj(pdev);
8848 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
8849 		reg_err("pdev reg component is NULL");
8850 		return false;
8851 	}
8852 
8853 	return pdev_priv_obj->is_6g_afc_expiry_event_received;
8854 }
8855 
8856 bool reg_is_noaction_on_afc_pwr_evt(struct wlan_objmgr_pdev *pdev)
8857 {
8858 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
8859 
8860 	pdev_priv_obj = reg_get_pdev_obj(pdev);
8861 
8862 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
8863 		reg_err("reg pdev priv obj is NULL");
8864 		return QDF_STATUS_E_FAILURE;
8865 	}
8866 
8867 	return pdev_priv_obj->is_reg_noaction_on_afc_pwr_evt;
8868 }
8869 #endif
8870 
8871 /**
8872  * struct bw_wireless_modes_pair - structure containing bandwidth and wireless
8873  * modes corresponding to the bandwidth
8874  * @ch_width: channel width
8875  * @wireless_modes: wireless modes bitmap corresponding to @ch_width. This
8876  * bitmap is a combination of enum values HOST_REGDMN_MODE
8877  */
8878 struct bw_wireless_modes_pair {
8879 	enum phy_ch_width ch_width;
8880 	uint64_t wireless_modes;
8881 };
8882 
8883 /* Mapping of bandwidth to wireless modes */
8884 static const struct bw_wireless_modes_pair bw_wireless_modes_pair_map[] = {
8885 #ifdef WLAN_FEATURE_11BE
8886 	{CH_WIDTH_320MHZ, WIRELESS_320_MODES},
8887 #endif
8888 	{CH_WIDTH_80P80MHZ, WIRELESS_80P80_MODES},
8889 	{CH_WIDTH_160MHZ, WIRELESS_160_MODES},
8890 	{CH_WIDTH_80MHZ, WIRELESS_80_MODES},
8891 	{CH_WIDTH_40MHZ, WIRELESS_40_MODES},
8892 	{CH_WIDTH_20MHZ, WIRELESS_20_MODES},
8893 	{CH_WIDTH_10MHZ, WIRELESS_10_MODES},
8894 	{CH_WIDTH_5MHZ, WIRELESS_5_MODES},
8895 };
8896 
8897 QDF_STATUS reg_is_chwidth_supported(struct wlan_objmgr_pdev *pdev,
8898 				    enum phy_ch_width ch_width,
8899 				    bool *is_supported)
8900 {
8901 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
8902 	uint64_t wireless_modes;
8903 	uint8_t num_bws, idx;
8904 
8905 	pdev_priv_obj = reg_get_pdev_obj(pdev);
8906 
8907 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
8908 		reg_err("reg pdev priv obj is NULL");
8909 		return QDF_STATUS_E_FAILURE;
8910 	}
8911 
8912 	*is_supported = false;
8913 
8914 	wireless_modes = pdev_priv_obj->wireless_modes;
8915 	num_bws = QDF_ARRAY_SIZE(bw_wireless_modes_pair_map);
8916 
8917 	for (idx = 0; idx < num_bws; ++idx) {
8918 		if (bw_wireless_modes_pair_map[idx].ch_width == ch_width) {
8919 			*is_supported = !!(wireless_modes &
8920 					   bw_wireless_modes_pair_map[idx].wireless_modes);
8921 			break;
8922 		}
8923 	}
8924 
8925 	return QDF_STATUS_SUCCESS;
8926 }
8927 
8928 bool reg_is_state_allowed(enum channel_state chan_state)
8929 {
8930 	return !((chan_state == CHANNEL_STATE_INVALID) ||
8931 		 (chan_state == CHANNEL_STATE_DISABLE));
8932 }
8933 
8934 static bool
8935 reg_is_freq_idx_enabled_on_cur_chan_list(struct wlan_regulatory_pdev_priv_obj
8936 					 *pdev_priv_obj,
8937 					 enum channel_enum freq_idx)
8938 {
8939 	struct regulatory_channel *cur_chan_list;
8940 
8941 	if (freq_idx >= NUM_CHANNELS)
8942 		return false;
8943 
8944 	cur_chan_list = pdev_priv_obj->cur_chan_list;
8945 
8946 	return !reg_is_chan_disabled_and_not_nol(&cur_chan_list[freq_idx]);
8947 }
8948 
8949 QDF_STATUS
8950 reg_get_min_max_bw_on_cur_chan_list(struct wlan_objmgr_pdev *pdev,
8951 				    enum channel_enum freq_idx,
8952 				    uint16_t *min_bw,
8953 				    uint16_t *max_bw)
8954 {
8955 	struct regulatory_channel *cur_chan_list;
8956 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
8957 
8958 	pdev_priv_obj = reg_get_pdev_obj(pdev);
8959 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
8960 		reg_err("reg pdev private obj is NULL");
8961 		return QDF_STATUS_E_FAILURE;
8962 	}
8963 	if (freq_idx >= NUM_CHANNELS)
8964 		return QDF_STATUS_E_FAILURE;
8965 
8966 	cur_chan_list = pdev_priv_obj->cur_chan_list;
8967 	if (min_bw)
8968 		*min_bw = cur_chan_list[freq_idx].min_bw;
8969 	if (max_bw)
8970 		*max_bw = cur_chan_list[freq_idx].max_bw;
8971 
8972 	return QDF_STATUS_SUCCESS;
8973 }
8974 
8975 static enum channel_state
8976 reg_get_chan_state_on_cur_chan_list(struct wlan_regulatory_pdev_priv_obj
8977 				    *pdev_priv_obj,
8978 				    enum channel_enum freq_idx)
8979 {
8980 	struct regulatory_channel *cur_chan_list;
8981 	enum channel_state chan_state;
8982 
8983 	if (freq_idx >= NUM_CHANNELS)
8984 		return CHANNEL_STATE_INVALID;
8985 
8986 	cur_chan_list = pdev_priv_obj->cur_chan_list;
8987 	chan_state = cur_chan_list[freq_idx].state;
8988 
8989 	return chan_state;
8990 }
8991 
8992 static enum channel_state
8993 reg_get_chan_state_based_on_nol_flag_cur_chan_list(struct wlan_regulatory_pdev_priv_obj
8994 						   *pdev_priv_obj,
8995 						   enum channel_enum freq_idx)
8996 {
8997 	struct regulatory_channel *cur_chan_list;
8998 	enum channel_state chan_state;
8999 
9000 	if (freq_idx >= NUM_CHANNELS)
9001 		return CHANNEL_STATE_INVALID;
9002 
9003 	cur_chan_list = pdev_priv_obj->cur_chan_list;
9004 	chan_state = cur_chan_list[freq_idx].state;
9005 
9006 	if ((cur_chan_list[freq_idx].nol_chan ||
9007 	     cur_chan_list[freq_idx].nol_history) &&
9008 	     chan_state == CHANNEL_STATE_DISABLE)
9009 		chan_state = CHANNEL_STATE_DFS;
9010 
9011 	return chan_state;
9012 }
9013 
9014 #ifdef CONFIG_BAND_6GHZ
9015 static inline bool
9016 reg_is_supr_entry_mode_disabled(const struct super_chan_info *super_chan_ent,
9017 				enum supported_6g_pwr_types in_6g_pwr_mode)
9018 {
9019 	return ((super_chan_ent->chan_flags_arr[in_6g_pwr_mode] &
9020 		 REGULATORY_CHAN_DISABLED) &&
9021 		super_chan_ent->state_arr[in_6g_pwr_mode] ==
9022 		CHANNEL_STATE_DISABLE);
9023 }
9024 
9025 static bool
9026 reg_is_freq_idx_enabled_on_given_pwr_mode(struct wlan_regulatory_pdev_priv_obj
9027 					  *pdev_priv_obj,
9028 					  enum channel_enum freq_idx,
9029 					  enum supported_6g_pwr_types
9030 					  in_6g_pwr_mode)
9031 {
9032 	const struct super_chan_info *super_chan_ent;
9033 	QDF_STATUS status;
9034 
9035 	if (freq_idx >= NUM_CHANNELS)
9036 		return false;
9037 
9038 	if (freq_idx < MIN_6GHZ_CHANNEL)
9039 		return reg_is_freq_idx_enabled_on_cur_chan_list(pdev_priv_obj,
9040 								freq_idx);
9041 
9042 	status = reg_get_superchan_entry(pdev_priv_obj->pdev_ptr, freq_idx,
9043 					 &super_chan_ent);
9044 	if (QDF_IS_STATUS_ERROR(status)) {
9045 		reg_debug("Failed to get super channel entry for freq_idx %d",
9046 			  freq_idx);
9047 		return false;
9048 	}
9049 
9050 	/* If the input 6G power mode is best power mode, get the best power
9051 	 * mode type from the super channel entry.
9052 	 */
9053 	if (in_6g_pwr_mode == REG_BEST_PWR_MODE)
9054 		in_6g_pwr_mode = super_chan_ent->best_power_mode;
9055 
9056 	return !reg_is_supr_entry_mode_disabled(super_chan_ent, in_6g_pwr_mode);
9057 }
9058 
9059 static QDF_STATUS
9060 reg_get_min_max_bw_on_given_pwr_mode(struct wlan_regulatory_pdev_priv_obj
9061 				     *pdev_priv_obj,
9062 				     enum channel_enum freq_idx,
9063 				     enum supported_6g_pwr_types
9064 				     in_6g_pwr_mode,
9065 				     uint16_t *min_bw,
9066 				     uint16_t *max_bw)
9067 {
9068 	const struct super_chan_info *super_chan_ent;
9069 	QDF_STATUS status;
9070 
9071 	if (freq_idx >= NUM_CHANNELS)
9072 		return QDF_STATUS_E_FAILURE;
9073 
9074 	if (freq_idx < MIN_6GHZ_CHANNEL)
9075 		return reg_get_min_max_bw_on_cur_chan_list(
9076 						       pdev_priv_obj->pdev_ptr,
9077 						       freq_idx,
9078 						       min_bw, max_bw);
9079 
9080 	status = reg_get_superchan_entry(pdev_priv_obj->pdev_ptr, freq_idx,
9081 					 &super_chan_ent);
9082 	if (QDF_IS_STATUS_ERROR(status)) {
9083 		reg_debug("Failed to get super channel entry for freq_idx %d",
9084 			  freq_idx);
9085 		return QDF_STATUS_E_FAILURE;
9086 	}
9087 
9088 	/* If the input 6G power mode is best power mode, get the best power
9089 	 * mode type from the super channel entry.
9090 	 */
9091 	if (in_6g_pwr_mode == REG_BEST_PWR_MODE)
9092 		in_6g_pwr_mode = super_chan_ent->best_power_mode;
9093 
9094 	if (reg_is_supp_pwr_mode_invalid(in_6g_pwr_mode)) {
9095 		reg_debug("pwr_type invalid");
9096 		return QDF_STATUS_E_FAILURE;
9097 	}
9098 
9099 	if (min_bw)
9100 		*min_bw = super_chan_ent->min_bw[in_6g_pwr_mode];
9101 	if (max_bw)
9102 		*max_bw = super_chan_ent->max_bw[in_6g_pwr_mode];
9103 
9104 	return QDF_STATUS_SUCCESS;
9105 }
9106 
9107 static enum channel_state
9108 reg_get_chan_state_on_given_pwr_mode(struct wlan_regulatory_pdev_priv_obj
9109 				     *pdev_priv_obj,
9110 				     enum channel_enum freq_idx,
9111 				     enum supported_6g_pwr_types
9112 				     in_6g_pwr_mode)
9113 {
9114 	const struct super_chan_info *super_chan_ent;
9115 	enum channel_state chan_state;
9116 	QDF_STATUS status;
9117 
9118 	if (freq_idx >= NUM_CHANNELS)
9119 		return CHANNEL_STATE_INVALID;
9120 
9121 	if (freq_idx < MIN_6GHZ_CHANNEL)
9122 		return reg_get_chan_state_on_cur_chan_list(pdev_priv_obj,
9123 				freq_idx);
9124 
9125 	status = reg_get_superchan_entry(pdev_priv_obj->pdev_ptr, freq_idx,
9126 					 &super_chan_ent);
9127 	if (QDF_IS_STATUS_ERROR(status)) {
9128 		reg_debug("Failed to get super channel entry for freq_idx %d",
9129 			  freq_idx);
9130 		return CHANNEL_STATE_INVALID;
9131 	}
9132 
9133 	/* If the input 6G power mode is best power mode, get the best power
9134 	 * mode type from the super channel entry.
9135 	 */
9136 	if (in_6g_pwr_mode == REG_BEST_PWR_MODE)
9137 		in_6g_pwr_mode = super_chan_ent->best_power_mode;
9138 
9139 	if (reg_is_supp_pwr_mode_invalid(in_6g_pwr_mode)) {
9140 		reg_debug("pwr_type invalid");
9141 		return CHANNEL_STATE_INVALID;
9142 	}
9143 
9144 	chan_state = super_chan_ent->state_arr[in_6g_pwr_mode];
9145 
9146 	return chan_state;
9147 }
9148 
9149 enum supported_6g_pwr_types
9150 reg_get_best_6g_pwr_type(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq)
9151 {
9152 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
9153 	enum channel_enum freq_idx;
9154 	enum channel_enum sixg_freq_idx;
9155 
9156 	pdev_priv_obj = reg_get_pdev_obj(pdev);
9157 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
9158 		reg_err_rl("pdev reg component is NULL");
9159 		return REG_INVALID_PWR_MODE;
9160 	}
9161 
9162 	freq_idx = reg_get_chan_enum_for_freq(freq);
9163 
9164 	if (reg_is_chan_enum_invalid(freq_idx))
9165 		return REG_INVALID_PWR_MODE;
9166 
9167 	sixg_freq_idx = reg_convert_enum_to_6g_idx(freq_idx);
9168 	if (reg_is_chan_enum_invalid(sixg_freq_idx) ||
9169 	    sixg_freq_idx >= NUM_6GHZ_CHANNELS)
9170 		return REG_INVALID_PWR_MODE;
9171 
9172 	return pdev_priv_obj->super_chan_list[sixg_freq_idx].best_power_mode;
9173 }
9174 
9175 static inline bool reg_is_6g_ap_type_invalid(enum reg_6g_ap_type ap_pwr_type)
9176 {
9177 	return ((ap_pwr_type < REG_INDOOR_AP) ||
9178 		(ap_pwr_type > REG_MAX_SUPP_AP_TYPE));
9179 }
9180 
9181 enum supported_6g_pwr_types
9182 reg_conv_6g_ap_type_to_supported_6g_pwr_types(enum reg_6g_ap_type ap_pwr_type)
9183 {
9184 	static const enum supported_6g_pwr_types reg_enum_conv[] = {
9185 		[REG_INDOOR_AP] = REG_AP_LPI,
9186 		[REG_STANDARD_POWER_AP] = REG_AP_SP,
9187 		[REG_VERY_LOW_POWER_AP] = REG_AP_VLP,
9188 	};
9189 
9190 	if (reg_is_6g_ap_type_invalid(ap_pwr_type))
9191 		return REG_INVALID_PWR_MODE;
9192 
9193 	return reg_enum_conv[ap_pwr_type];
9194 }
9195 #else
9196 static inline bool
9197 reg_is_freq_idx_enabled_on_given_pwr_mode(struct wlan_regulatory_pdev_priv_obj
9198 					  *pdev_priv_obj,
9199 					  enum channel_enum freq_idx,
9200 					  enum supported_6g_pwr_types
9201 					  in_6g_pwr_mode)
9202 {
9203 	return reg_is_freq_idx_enabled_on_cur_chan_list(pdev_priv_obj,
9204 							freq_idx);
9205 }
9206 
9207 static inline QDF_STATUS
9208 reg_get_min_max_bw_on_given_pwr_mode(struct wlan_regulatory_pdev_priv_obj
9209 				     *pdev_priv_obj,
9210 				     enum channel_enum freq_idx,
9211 				     enum supported_6g_pwr_types
9212 				     in_6g_pwr_mode,
9213 				     uint16_t *min_bw,
9214 				     uint16_t *max_bw)
9215 {
9216 	return reg_get_min_max_bw_on_cur_chan_list(pdev_priv_obj->pdev_ptr,
9217 						   freq_idx,
9218 						   min_bw, max_bw);
9219 }
9220 
9221 static inline enum channel_state
9222 reg_get_chan_state_on_given_pwr_mode(struct wlan_regulatory_pdev_priv_obj
9223 				     *pdev_priv_obj,
9224 				     enum channel_enum freq_idx,
9225 				     enum supported_6g_pwr_types
9226 				     in_6g_pwr_mode)
9227 {
9228 	return reg_get_chan_state_on_cur_chan_list(pdev_priv_obj,
9229 						   freq_idx);
9230 }
9231 #endif /* CONFIG_BAND_6GHZ */
9232 
9233 bool
9234 reg_is_freq_enabled(struct wlan_objmgr_pdev *pdev,
9235 		    qdf_freq_t freq,
9236 		    enum supported_6g_pwr_types in_6g_pwr_mode)
9237 {
9238 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
9239 	enum channel_enum freq_idx;
9240 
9241 	pdev_priv_obj = reg_get_pdev_obj(pdev);
9242 
9243 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
9244 		reg_err("reg pdev private obj is NULL");
9245 		return false;
9246 	}
9247 
9248 	freq_idx = reg_get_chan_enum_for_freq(freq);
9249 
9250 	if (reg_is_chan_enum_invalid(freq_idx))
9251 		return false;
9252 
9253 	return reg_is_freq_idx_enabled(pdev, freq_idx, in_6g_pwr_mode);
9254 }
9255 
9256 bool reg_is_freq_idx_enabled(struct wlan_objmgr_pdev *pdev,
9257 			     enum channel_enum freq_idx,
9258 			     enum supported_6g_pwr_types in_6g_pwr_mode)
9259 {
9260 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
9261 
9262 	pdev_priv_obj = reg_get_pdev_obj(pdev);
9263 
9264 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
9265 		reg_err("reg pdev private obj is NULL");
9266 		return false;
9267 	}
9268 
9269 	if (freq_idx < MIN_6GHZ_CHANNEL)
9270 		return reg_is_freq_idx_enabled_on_cur_chan_list(pdev_priv_obj,
9271 								freq_idx);
9272 
9273 	switch (in_6g_pwr_mode) {
9274 	case REG_CURRENT_PWR_MODE:
9275 		return reg_is_freq_idx_enabled_on_cur_chan_list(pdev_priv_obj,
9276 								freq_idx);
9277 
9278 	case REG_BEST_PWR_MODE:
9279 	default:
9280 		return reg_is_freq_idx_enabled_on_given_pwr_mode(pdev_priv_obj,
9281 								 freq_idx,
9282 								 in_6g_pwr_mode
9283 								 );
9284 	}
9285 }
9286 
9287 QDF_STATUS reg_get_min_max_bw_reg_chan_list(struct wlan_objmgr_pdev *pdev,
9288 					    enum channel_enum freq_idx,
9289 					    enum supported_6g_pwr_types
9290 					    in_6g_pwr_mode,
9291 					    uint16_t *min_bw,
9292 					    uint16_t *max_bw)
9293 {
9294 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
9295 
9296 	pdev_priv_obj = reg_get_pdev_obj(pdev);
9297 
9298 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
9299 		reg_err("reg pdev private obj is NULL");
9300 		return QDF_STATUS_E_FAILURE;
9301 	}
9302 
9303 	if (freq_idx < MIN_6GHZ_CHANNEL)
9304 		return reg_get_min_max_bw_on_cur_chan_list(
9305 							pdev,
9306 							freq_idx,
9307 							min_bw, max_bw);
9308 
9309 	switch (in_6g_pwr_mode) {
9310 	case REG_CURRENT_PWR_MODE:
9311 		return reg_get_min_max_bw_on_cur_chan_list(
9312 							pdev,
9313 							freq_idx,
9314 							min_bw, max_bw);
9315 
9316 	case REG_BEST_PWR_MODE:
9317 	default:
9318 		return reg_get_min_max_bw_on_given_pwr_mode(pdev_priv_obj,
9319 							    freq_idx,
9320 							    in_6g_pwr_mode,
9321 							    min_bw, max_bw);
9322 	}
9323 }
9324 
9325 enum channel_state reg_get_chan_state(struct wlan_objmgr_pdev *pdev,
9326 				      enum channel_enum freq_idx,
9327 				      enum supported_6g_pwr_types
9328 				      in_6g_pwr_mode,
9329 				      bool treat_nol_chan_as_disabled)
9330 {
9331 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
9332 
9333 	pdev_priv_obj = reg_get_pdev_obj(pdev);
9334 
9335 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
9336 		reg_err("reg pdev private obj is NULL");
9337 		return CHANNEL_STATE_INVALID;
9338 	}
9339 
9340 	if (freq_idx < MIN_6GHZ_CHANNEL) {
9341 		if (treat_nol_chan_as_disabled)
9342 			return reg_get_chan_state_on_cur_chan_list(pdev_priv_obj,
9343 								   freq_idx);
9344 		else
9345 			return reg_get_chan_state_based_on_nol_flag_cur_chan_list(
9346 								pdev_priv_obj,
9347 								freq_idx);
9348 	}
9349 
9350 	switch (in_6g_pwr_mode) {
9351 	case REG_CURRENT_PWR_MODE:
9352 		return reg_get_chan_state_on_cur_chan_list(pdev_priv_obj,
9353 							   freq_idx);
9354 
9355 	case REG_BEST_PWR_MODE:
9356 	default:
9357 		return reg_get_chan_state_on_given_pwr_mode(pdev_priv_obj,
9358 							    freq_idx,
9359 							    in_6g_pwr_mode
9360 							   );
9361 	}
9362 }
9363 
9364 #ifdef WLAN_FEATURE_11BE
9365 enum phy_ch_width reg_find_chwidth_from_bw(uint16_t bw)
9366 {
9367 	switch (bw) {
9368 	case BW_5_MHZ:
9369 		return CH_WIDTH_5MHZ;
9370 	case BW_10_MHZ:
9371 		return CH_WIDTH_10MHZ;
9372 	case BW_20_MHZ:
9373 		return CH_WIDTH_20MHZ;
9374 	case BW_40_MHZ:
9375 		return CH_WIDTH_40MHZ;
9376 	case BW_80_MHZ:
9377 		return CH_WIDTH_80MHZ;
9378 	case BW_160_MHZ:
9379 		return CH_WIDTH_160MHZ;
9380 	case BW_320_MHZ:
9381 		return CH_WIDTH_320MHZ;
9382 	default:
9383 		return CH_WIDTH_INVALID;
9384 	}
9385 }
9386 #else
9387 enum phy_ch_width reg_find_chwidth_from_bw(uint16_t bw)
9388 {
9389 	switch (bw) {
9390 	case BW_5_MHZ:
9391 		return CH_WIDTH_5MHZ;
9392 	case BW_10_MHZ:
9393 		return CH_WIDTH_10MHZ;
9394 	case BW_20_MHZ:
9395 		return CH_WIDTH_20MHZ;
9396 	case BW_40_MHZ:
9397 		return CH_WIDTH_40MHZ;
9398 	case BW_80_MHZ:
9399 		return CH_WIDTH_80MHZ;
9400 	case BW_160_MHZ:
9401 		return CH_WIDTH_160MHZ;
9402 	default:
9403 		return CH_WIDTH_INVALID;
9404 	}
9405 }
9406 #endif
9407 
9408 #ifdef CONFIG_BAND_6GHZ
9409 qdf_freq_t reg_get_thresh_priority_freq(struct wlan_objmgr_pdev *pdev)
9410 {
9411 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
9412 
9413 	pdev_priv_obj = reg_get_pdev_obj(pdev);
9414 
9415 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
9416 		reg_err("reg pdev private obj is NULL");
9417 		return 0;
9418 	}
9419 
9420 	return pdev_priv_obj->reg_6g_thresh_priority_freq;
9421 }
9422 
9423 /**
9424  * reg_get_eirp_from_psd_and_reg_max_eirp() - Get the EIRP by the computing the
9425  * minimum(max regulatory EIRP, EIRP computed from regulatory PSD)
9426  * @pdev: Pointer to pdev
9427  * @mas_chan_list: Pointer to master_chan_list
9428  * @freq: Frequency in mhz
9429  * @bw: Bandwidth in mhz
9430  * @reg_eirp_pwr: Pointer to reg_eirp_pwr
9431  *
9432  * Return: Void
9433  */
9434 static void
9435 reg_get_eirp_from_psd_and_reg_max_eirp(struct wlan_objmgr_pdev *pdev,
9436 				       struct regulatory_channel *mas_chan_list,
9437 				       qdf_freq_t freq,
9438 				       uint16_t bw,
9439 				       int16_t *reg_eirp_pwr)
9440 {
9441 	int16_t eirp_from_psd = 0, psd = 0;
9442 
9443 	reg_get_6g_chan_psd_eirp_power(freq, mas_chan_list, &psd);
9444 	reg_psd_2_eirp(pdev, psd, bw, &eirp_from_psd);
9445 	*reg_eirp_pwr = QDF_MIN(*reg_eirp_pwr, eirp_from_psd);
9446 }
9447 
9448 /**
9449  * reg_get_mas_chan_list_for_lookup() - Get the AP or client master_chan_list
9450  * based on the is_client_list_lookup_needed flag
9451  * @pdev: Pointer to pdev
9452  * @master_chan_list: Pointer to master_chan_list
9453  * @ap_pwr_type: AP Power type
9454  * @is_client_list_lookup_needed: Boolean to indicate if client list lookup is
9455  * needed
9456  * @client_type: Client power type
9457  *
9458  * Return: Void
9459  */
9460 static void
9461 reg_get_mas_chan_list_for_lookup(struct wlan_objmgr_pdev *pdev,
9462 				 struct regulatory_channel **master_chan_list,
9463 				 enum reg_6g_ap_type ap_pwr_type,
9464 				 bool is_client_list_lookup_needed,
9465 				 enum reg_6g_client_type client_type)
9466 {
9467 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
9468 
9469 	pdev_priv_obj = reg_get_pdev_obj(pdev);
9470 	if (!pdev_priv_obj) {
9471 		reg_err("pdev priv obj is NULL");
9472 		return;
9473 	}
9474 
9475 	if (client_type > REG_MAX_CLIENT_TYPE) {
9476 		reg_err("Invalid client type");
9477 		return;
9478 	}
9479 
9480 	if (is_client_list_lookup_needed)
9481 		*master_chan_list =
9482 			pdev_priv_obj->mas_chan_list_6g_client[ap_pwr_type]
9483 								[client_type];
9484 	else
9485 		*master_chan_list =
9486 			pdev_priv_obj->mas_chan_list_6g_ap[ap_pwr_type];
9487 }
9488 
9489 /**
9490  * reg_get_eirp_from_mas_chan_list() -  For the given power mode, using the bandwidth
9491  * and psd(from master channel entry), calculate an EIRP value. The minimum
9492  * of calculated EIRP and regulatory max EIRP is returned.
9493  * @pdev: Pointer to pdev
9494  * @freq: Frequency in mhz
9495  * @bw: Bandwidth in mhz
9496  * @ap_pwr_type: AP Power type
9497  * @is_client_list_lookup_needed: Boolean to indicate if client list lookup is
9498  * needed
9499  * @client_type: Client power type
9500  *
9501  * Return: EIRP
9502  */
9503 static int8_t
9504 reg_get_eirp_from_mas_chan_list(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq,
9505 				uint16_t bw, enum reg_6g_ap_type ap_pwr_type,
9506 				bool is_client_list_lookup_needed,
9507 				enum reg_6g_client_type client_type)
9508 {
9509 	bool is_psd;
9510 	struct regulatory_channel *master_chan_list = NULL;
9511 	int16_t txpower = 0;
9512 
9513 	reg_get_mas_chan_list_for_lookup(pdev, &master_chan_list, ap_pwr_type,
9514 					 is_client_list_lookup_needed,
9515 					 client_type);
9516 	if (!master_chan_list) {
9517 		reg_err("master_chan_list is NULL");
9518 		return 0;
9519 	}
9520 
9521 	is_psd = reg_is_6g_psd_power(pdev);
9522 	reg_find_txpower_from_6g_list(freq, master_chan_list, &txpower);
9523 
9524 	if (is_psd)
9525 		reg_get_eirp_from_psd_and_reg_max_eirp(pdev,
9526 						       master_chan_list,
9527 						       freq, bw,
9528 						       &txpower);
9529 
9530 	return txpower;
9531 }
9532 
9533 qdf_freq_t reg_compute_6g_center_freq_from_cfi(uint8_t ieee_6g_cfi)
9534 {
9535 	return (SIXG_START_FREQ + ieee_6g_cfi * FREQ_TO_CHAN_SCALE);
9536 }
9537 
9538 #ifdef CONFIG_AFC_SUPPORT
9539 #ifdef WLAN_FEATURE_11BE
9540 /**
9541  * reg_is_320_opclass: Find out if the opclass computed from freq and
9542  * width of 320 is same as the input op_class.
9543  * @freq: Frequency in MHz
9544  * @in_opclass: Input Opclass number
9545  * Return: true if opclass is 320 supported, false otherwise.
9546  */
9547 static bool reg_is_320_opclass(qdf_freq_t freq, uint8_t in_opclass)
9548 {
9549 	uint8_t local_op_class =
9550 		reg_dmn_get_opclass_from_freq_width(NULL, freq, BW_320_MHZ,
9551 						    BIT(BEHAV_NONE));
9552 	return (in_opclass == local_op_class);
9553 }
9554 #else
9555 static inline bool reg_is_320_opclass(qdf_freq_t freq, uint8_t op_class)
9556 {
9557 	return false;
9558 }
9559 #endif
9560 
9561 /**
9562  * reg_find_eirp_in_afc_eirp_obj() - Get eirp power from the AFC eirp object
9563  * based on the channel center frequency and operating class
9564  * @pdev: Pointer to pdev
9565  * @eirp_obj: Pointer to eirp_obj
9566  * @freq: Frequency in MHz
9567  * @cen320: 320 MHz band center frequency
9568  * @op_class: Operating class
9569  *
9570  * Return: EIRP power
9571  */
9572 static int8_t reg_find_eirp_in_afc_eirp_obj(struct wlan_objmgr_pdev *pdev,
9573 					    struct chan_eirp_obj *eirp_obj,
9574 					    qdf_freq_t freq,
9575 					    qdf_freq_t cen320,
9576 					    uint8_t op_class)
9577 {
9578 	uint8_t k;
9579 	uint8_t subchannels[NUM_20_MHZ_CHAN_IN_320_MHZ_CHAN];
9580 	uint8_t nchans;
9581 
9582 	if (reg_is_320_opclass(freq, op_class)) {
9583 		qdf_freq_t cfi_freq =
9584 			reg_compute_6g_center_freq_from_cfi(eirp_obj->cfi);
9585 
9586 		if (cfi_freq == cen320)
9587 			return eirp_obj->eirp_power / EIRP_PWR_SCALE;
9588 
9589 		return 0;
9590 	}
9591 
9592 	nchans = reg_get_subchannels_for_opclass(eirp_obj->cfi,
9593 						 op_class,
9594 						 subchannels);
9595 
9596 	for (k = 0; k < nchans; k++)
9597 		if (reg_chan_band_to_freq(pdev, subchannels[k],
9598 					  BIT(REG_BAND_6G)) == freq)
9599 			return eirp_obj->eirp_power / EIRP_PWR_SCALE;
9600 
9601 	return 0;
9602 }
9603 
9604 /**
9605  * reg_find_eirp_in_afc_chan_obj() - Get eirp power from the AFC channel
9606  * object based on the channel center frequency and operating class
9607  * @pdev: Pointer to pdev
9608  * @chan_obj: Pointer to chan_obj
9609  * @freq: Frequency in MHz
9610  * @cen320: 320 MHz band center frequency
9611  * @op_class: Operating class
9612  *
9613  * Return: EIRP power
9614  */
9615 static int8_t reg_find_eirp_in_afc_chan_obj(struct wlan_objmgr_pdev *pdev,
9616 					    struct afc_chan_obj *chan_obj,
9617 					    qdf_freq_t freq,
9618 					    qdf_freq_t cen320,
9619 					    uint8_t op_class)
9620 {
9621 	uint8_t j;
9622 
9623 	if (chan_obj->global_opclass != op_class)
9624 		return 0;
9625 
9626 	for (j = 0; j < chan_obj->num_chans; j++) {
9627 		int8_t afc_eirp;
9628 		struct chan_eirp_obj *eirp_obj = &chan_obj->chan_eirp_info[j];
9629 
9630 		afc_eirp = reg_find_eirp_in_afc_eirp_obj(pdev, eirp_obj,
9631 							 freq, cen320,
9632 							 op_class);
9633 
9634 		if (afc_eirp)
9635 			return afc_eirp;
9636 	}
9637 
9638 	return 0;
9639 }
9640 
9641 /**
9642  * reg_is_chan_punc() - Validates the input puncture pattern.
9643  * @in_punc_pattern: Input puncture pattern
9644  * @bw: Channel bandwidth in MHz
9645  *
9646  * If the in_punc_pattern has none of the subchans punctured, channel
9647  * is not considered as punctured. Also, if the input puncture bitmap
9648  * is invalid, do not consider the channel as punctured.
9649  *
9650  * Return: true if channel is punctured, false otherwise.
9651  */
9652 #ifdef WLAN_FEATURE_11BE
9653 static bool
9654 reg_is_chan_punc(uint16_t in_punc_pattern, uint16_t bw)
9655 {
9656 	enum phy_ch_width ch_width = reg_find_chwidth_from_bw(bw);
9657 
9658 	if (in_punc_pattern == NO_SCHANS_PUNC ||
9659 	    !reg_is_punc_bitmap_valid(ch_width, in_punc_pattern))
9660 		return false;
9661 
9662 	return true;
9663 }
9664 #else
9665 static inline bool
9666 reg_is_chan_punc(uint16_t in_punc_pattern, uint16_t bw)
9667 {
9668 	return false;
9669 }
9670 #endif
9671 
9672 /**
9673  * reg_find_non_punctured_bw() - Given the input puncture pattern and the
9674  * total BW of the channel, find the non-punctured bandwidth.
9675  * @bw: Total bandwidth of the channel
9676  * @in_punc_pattern: Input puncture pattern
9677  *
9678  * Return: non-punctured bw in MHz
9679  */
9680 static uint16_t
9681 reg_find_non_punctured_bw(uint16_t bw,  uint16_t in_punc_pattern)
9682 {
9683 	uint8_t num_punc_bw = 0;
9684 
9685 	while (in_punc_pattern) {
9686 		if (in_punc_pattern & 1)
9687 			++num_punc_bw;
9688 		in_punc_pattern >>= 1;
9689 	}
9690 
9691 	if (bw <= num_punc_bw * 20)
9692 		return 0;
9693 
9694 	return (bw - num_punc_bw * 20);
9695 }
9696 
9697 /**
9698  * reg_get_sp_eirp_for_punc_chans() - Find the standard EIRP power for
9699  * punctured channels.
9700  * @pdev: Pointer to struct wlan_objmgr_pdev
9701  * @freq: Frequency in MHz
9702  * @cen320: Center of 320 MHz channel in Mhz
9703  * @bw: Bandwidth in MHz
9704  * @in_punc_pattern: Input puncture pattern
9705  * @reg_sp_eirp_pwr: Regulatory defined SP power for the input frequency
9706  *
9707  * Return: Regulatory and AFC intersected SP power of punctured channel
9708  */
9709 static int8_t
9710 reg_get_sp_eirp_for_punc_chans(struct wlan_objmgr_pdev *pdev,
9711 			       qdf_freq_t freq,
9712 			       qdf_freq_t cen320,
9713 			       uint16_t bw,
9714 			       uint16_t in_punc_pattern,
9715 			       int16_t reg_sp_eirp_pwr)
9716 {
9717 	int16_t min_psd = REG_MIN_POWER;
9718 	int16_t afc_eirp_pwr = REG_MIN_POWER;
9719 	int16_t non_punc_bw;
9720 	struct wlan_lmac_if_reg_tx_ops *reg_tx_ops;
9721 	struct wlan_objmgr_psoc *psoc;
9722 	QDF_STATUS status;
9723 
9724 	psoc = wlan_pdev_get_psoc(pdev);
9725 
9726 	if (!psoc)
9727 		return 0;
9728 
9729 	reg_tx_ops = reg_get_psoc_tx_ops(psoc);
9730 
9731 	if (!reg_tx_ops->reg_get_min_psd)
9732 		return 0;
9733 
9734 	/* min_psd will be calculated here */
9735 	status = reg_tx_ops->reg_get_min_psd(pdev, freq, cen320,
9736 					     in_punc_pattern, bw,
9737 					     &min_psd);
9738 	if (status != QDF_STATUS_SUCCESS) {
9739 		reg_debug("Could not derive min_psd power for width %u, freq; %d, cen320: %d, in_punc: 0x%x\n",
9740 			  bw, freq, cen320, in_punc_pattern);
9741 		return 0;
9742 	}
9743 
9744 	non_punc_bw = reg_find_non_punctured_bw(bw, in_punc_pattern);
9745 
9746 	if (reg_psd_2_eirp(pdev, min_psd, non_punc_bw, &afc_eirp_pwr) !=
9747 	    QDF_STATUS_SUCCESS) {
9748 		reg_debug("Could not derive EIRP power for width %u, min_psd: %d\n", non_punc_bw, min_psd);
9749 		return 0;
9750 	}
9751 
9752 	reg_debug("freq = %u, bw: %u, cen320: %u, punc_pattern: 0x%x "
9753 		  "reg_sp_eirp: %d, min_psd: %d, non_punc_bw: %u, afc_eirp_pwr: %d\n",
9754 		  freq, bw, cen320, in_punc_pattern, reg_sp_eirp_pwr, min_psd,
9755 		  non_punc_bw, afc_eirp_pwr);
9756 
9757 	if (afc_eirp_pwr)
9758 		return QDF_MIN(afc_eirp_pwr, reg_sp_eirp_pwr);
9759 
9760 	return 0;
9761 }
9762 
9763 /**
9764  * reg_get_sp_eirp_before_afc_resp_rx() - Before the AFC response is received
9765  * from the target, for a given input frequency and bw, find the EIRP values
9766  * based on the deployment type and, the presence of SP AP and VLP AP reg rules.
9767  * @pdev: Pointer to pdev
9768  * @freq: Frequency in MHz
9769  * @bw: Bandwidth in MHz
9770  * @is_client_list_lookup_needed: Boolean to indicate if client list lookup is
9771  * needed
9772  * @client_type: Client power type
9773  *
9774  * Return: EIRP
9775  */
9776 static int8_t
9777 reg_get_sp_eirp_before_afc_resp_rx(struct wlan_objmgr_pdev *pdev,
9778 				   qdf_freq_t freq,
9779 				   uint16_t bw,
9780 				   bool is_client_list_lookup_needed,
9781 				   enum reg_6g_client_type client_type)
9782 {
9783 	enum reg_afc_dev_deploy_type reg_afc_dev_type;
9784 	struct wlan_objmgr_psoc *psoc;
9785 	uint8_t num_ap_sp_rules, num_ap_vlp_rules;
9786 
9787 	psoc = wlan_pdev_get_psoc(pdev);
9788 
9789 	if (!psoc) {
9790 		reg_err("psoc is NULL");
9791 		return 0;
9792 	}
9793 
9794 	reg_get_afc_soc_dev_type(psoc, &reg_afc_dev_type);
9795 	num_ap_sp_rules =
9796 		reg_get_num_rules_of_ap_pwr_type(pdev, REG_STANDARD_POWER_AP);
9797 	num_ap_vlp_rules =
9798 		reg_get_num_rules_of_ap_pwr_type(pdev, REG_VERY_LOW_POWER_AP);
9799 
9800 	if (reg_afc_dev_type == AFC_DEPLOYMENT_OUTDOOR && num_ap_sp_rules &&
9801 	    !num_ap_vlp_rules)
9802 		return reg_get_eirp_from_mas_chan_list(pdev, freq, bw,
9803 						       REG_STANDARD_POWER_AP,
9804 						       is_client_list_lookup_needed,
9805 						       client_type);
9806 	else
9807 		return 0;
9808 }
9809 
9810 /**
9811  * reg_get_sp_eirp() - For the given power mode, using the bandwidth, find the
9812  * corresponding EIRP values from the afc power info array. The minimum of found
9813  * EIRP and regulatory max EIRP is returned
9814  * @pdev: Pointer to pdev
9815  * @freq: Frequency in MHz
9816  * @cen320: 320 MHz band center frequency
9817  * @bw: Bandwidth in MHz
9818  * @in_punc_pattern: Input puncture pattern
9819  * @is_client_list_lookup_needed: Boolean to indicate if client list lookup is
9820  * needed
9821  * @client_type: Client power type
9822  *
9823  * Return: EIRP
9824  */
9825 static int8_t reg_get_sp_eirp(struct wlan_objmgr_pdev *pdev,
9826 			      qdf_freq_t freq,
9827 			      qdf_freq_t cen320,
9828 			      uint16_t bw,
9829 			      uint16_t in_punc_pattern,
9830 			      bool is_client_list_lookup_needed,
9831 			      enum reg_6g_client_type client_type)
9832 {
9833 	uint8_t i, op_class = 0, chan_num = 0;
9834 	int8_t afc_eirp_pwr = 0;
9835 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
9836 	struct regulatory_channel *sp_master_chan_list = NULL;
9837 	struct reg_fw_afc_power_event *power_info;
9838 	int16_t reg_sp_eirp_pwr = 0;
9839 	bool is_psd;
9840 
9841 	pdev_priv_obj = reg_get_pdev_obj(pdev);
9842 
9843 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
9844 		reg_err("reg pdev priv obj is NULL");
9845 		return 0;
9846 	}
9847 
9848 	if (!reg_is_afc_power_event_received(pdev))
9849 		return reg_get_sp_eirp_before_afc_resp_rx(pdev, freq, bw,
9850 							  is_client_list_lookup_needed,
9851 							  client_type);
9852 
9853 	sp_master_chan_list =
9854 		pdev_priv_obj->mas_chan_list_6g_ap[REG_STANDARD_POWER_AP];
9855 	reg_find_txpower_from_6g_list(freq, sp_master_chan_list,
9856 				      &reg_sp_eirp_pwr);
9857 
9858 	if (!reg_sp_eirp_pwr)
9859 		return 0;
9860 
9861 	if (reg_is_chan_punc(in_punc_pattern, bw)) {
9862 		reg_info("Computing SP EIRP with puncturing info");
9863 		return reg_get_sp_eirp_for_punc_chans(pdev, freq, cen320, bw,
9864 						      in_punc_pattern,
9865 						      reg_sp_eirp_pwr);
9866 	}
9867 
9868 	power_info = pdev_priv_obj->power_info;
9869 	if (!power_info) {
9870 		reg_err("power_info is NULL");
9871 		return 0;
9872 	}
9873 
9874 	reg_freq_width_to_chan_op_class(pdev,
9875 					freq,
9876 					bw,
9877 					true,
9878 					BIT(BEHAV_NONE),
9879 					&op_class,
9880 					&chan_num);
9881 	reg_get_mas_chan_list_for_lookup(pdev, &sp_master_chan_list,
9882 					 REG_STANDARD_POWER_AP,
9883 					 is_client_list_lookup_needed,
9884 					 client_type);
9885 	if (!sp_master_chan_list) {
9886 		reg_err("sp_master_chan_list is NULL");
9887 		return 0;
9888 	}
9889 
9890 	reg_find_txpower_from_6g_list(freq, sp_master_chan_list,
9891 				      &reg_sp_eirp_pwr);
9892 
9893 	if (!reg_sp_eirp_pwr)
9894 		return 0;
9895 
9896 	for (i = 0; i < power_info->num_chan_objs; i++) {
9897 		struct afc_chan_obj *chan_obj = &power_info->afc_chan_info[i];
9898 
9899 		afc_eirp_pwr = reg_find_eirp_in_afc_chan_obj(pdev,
9900 							     chan_obj,
9901 							     freq,
9902 							     cen320,
9903 							     op_class);
9904 		if (afc_eirp_pwr)
9905 			break;
9906 	}
9907 
9908 	is_psd = reg_is_6g_psd_power(pdev);
9909 	if (is_psd)
9910 		reg_get_eirp_from_psd_and_reg_max_eirp(pdev,
9911 						       sp_master_chan_list,
9912 						       freq, bw,
9913 						       &reg_sp_eirp_pwr);
9914 
9915 	if (afc_eirp_pwr)
9916 		return QDF_MIN(afc_eirp_pwr, (int8_t)reg_sp_eirp_pwr);
9917 
9918 	return 0;
9919 }
9920 #else
9921 static int8_t reg_get_sp_eirp(struct wlan_objmgr_pdev *pdev,
9922 			      qdf_freq_t freq,
9923 			      qdf_freq_t cen320,
9924 			      uint16_t bw,
9925 			      uint16_t in_punc_pattern,
9926 			      bool is_client_list_lookup_needed,
9927 			      enum reg_6g_client_type client_type)
9928 {
9929 	return reg_get_eirp_from_mas_chan_list(pdev, freq, bw, REG_STANDARD_POWER_AP,
9930 					       is_client_list_lookup_needed,
9931 					       client_type);
9932 }
9933 #endif
9934 
9935 /**
9936  * reg_get_best_pwr_mode_from_eirp_list() - Get best power mode from the input
9937  * EIRP list
9938  * @eirp_list: EIRP list
9939  * @size: Size of eirp list
9940  *
9941  * Return: Best power mode
9942  */
9943 static enum reg_6g_ap_type
9944 reg_get_best_pwr_mode_from_eirp_list(int8_t *eirp_list, uint8_t size)
9945 {
9946 	int8_t max = 0;
9947 	uint8_t i;
9948 	enum reg_6g_ap_type best_pwr_mode = REG_CURRENT_MAX_AP_TYPE;
9949 
9950 	for (i = 0; i < size; i++) {
9951 		/* Assuming the eirp = 0 means the mode is not available,
9952 		 * skip the mode.
9953 		 * EIRP = 0 may be a valid value. We need to fix this in
9954 		 * future by setting the min negative value (-128) to
9955 		 * the channels for which power mode is not available.
9956 		 */
9957 		if (!eirp_list[i])
9958 			continue;
9959 		if (eirp_list[i] > max) {
9960 			max = eirp_list[i];
9961 			best_pwr_mode = i;
9962 		}
9963 	}
9964 
9965 	return best_pwr_mode;
9966 }
9967 
9968 int8_t reg_get_eirp_pwr(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq,
9969 			qdf_freq_t cen320,
9970 			uint16_t bw, enum reg_6g_ap_type ap_pwr_type,
9971 			uint16_t in_punc_pattern,
9972 			bool is_client_list_lookup_needed,
9973 			enum reg_6g_client_type client_type)
9974 {
9975 	if (ap_pwr_type == REG_STANDARD_POWER_AP)
9976 		return reg_get_sp_eirp(pdev, freq, cen320, bw, in_punc_pattern,
9977 				       is_client_list_lookup_needed,
9978 				       client_type);
9979 
9980 	return reg_get_eirp_from_mas_chan_list(pdev, freq, bw, ap_pwr_type,
9981 					       is_client_list_lookup_needed,
9982 					       client_type);
9983 }
9984 
9985 enum reg_6g_ap_type reg_get_best_pwr_mode(struct wlan_objmgr_pdev *pdev,
9986 					  qdf_freq_t freq,
9987 					  qdf_freq_t cen320,
9988 					  uint16_t bw,
9989 					  uint16_t in_punc_pattern)
9990 {
9991 	int8_t eirp_list[REG_MAX_SUPP_AP_TYPE + 1];
9992 	enum reg_6g_ap_type ap_pwr_type;
9993 
9994 	for (ap_pwr_type = REG_INDOOR_AP; ap_pwr_type <= REG_VERY_LOW_POWER_AP;
9995 	     ap_pwr_type++)
9996 		eirp_list[ap_pwr_type] =
9997 				reg_get_eirp_pwr(pdev, freq, cen320, bw,
9998 						 ap_pwr_type, in_punc_pattern,
9999 						 false,
10000 						 REG_MAX_CLIENT_TYPE);
10001 
10002 	return reg_get_best_pwr_mode_from_eirp_list(eirp_list,
10003 						    REG_MAX_SUPP_AP_TYPE + 1);
10004 }
10005 #endif
10006 
10007 QDF_STATUS reg_get_regd_rules(struct wlan_objmgr_pdev *pdev,
10008 			      struct reg_rule_info *reg_rules)
10009 {
10010 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
10011 
10012 	if (!pdev) {
10013 		reg_err("pdev is NULL");
10014 		return QDF_STATUS_E_FAILURE;
10015 	}
10016 
10017 	pdev_priv_obj = reg_get_pdev_obj(pdev);
10018 	if (!pdev_priv_obj) {
10019 		reg_err("pdev priv obj is NULL");
10020 		return QDF_STATUS_E_FAILURE;
10021 	}
10022 
10023 	qdf_spin_lock_bh(&pdev_priv_obj->reg_rules_lock);
10024 	qdf_mem_copy(reg_rules, &pdev_priv_obj->reg_rules,
10025 		     sizeof(struct reg_rule_info));
10026 	qdf_spin_unlock_bh(&pdev_priv_obj->reg_rules_lock);
10027 
10028 	return QDF_STATUS_SUCCESS;
10029 }
10030 
10031 #if defined(CONFIG_AFC_SUPPORT) && defined(CONFIG_BAND_6GHZ)
10032 bool
10033 reg_is_sup_chan_entry_afc_done(struct wlan_objmgr_pdev *pdev,
10034 			       enum channel_enum chan_idx,
10035 			       enum supported_6g_pwr_types in_6g_pwr_mode)
10036 {
10037 	const struct super_chan_info *super_chan_ent;
10038 	QDF_STATUS status;
10039 
10040 	status = reg_get_superchan_entry(pdev, chan_idx,
10041 					 &super_chan_ent);
10042 	if (QDF_IS_STATUS_ERROR(status)) {
10043 		reg_debug("Failed to get super channel entry for chan_idx %d",
10044 			  chan_idx);
10045 		return false;
10046 	}
10047 
10048 	if (in_6g_pwr_mode == REG_BEST_PWR_MODE)
10049 		in_6g_pwr_mode = super_chan_ent->best_power_mode;
10050 
10051 	if (in_6g_pwr_mode != REG_AP_SP)
10052 		return false;
10053 
10054 	return !(super_chan_ent->chan_flags_arr[in_6g_pwr_mode] &
10055 		 REGULATORY_CHAN_AFC_NOT_DONE);
10056 }
10057 #endif
10058 
10059 #ifdef CONFIG_BAND_6GHZ
10060 QDF_STATUS
10061 reg_display_super_chan_list(struct wlan_objmgr_pdev *pdev)
10062 {
10063 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
10064 	struct super_chan_info *super_chan_list;
10065 	uint8_t i;
10066 
10067 	pdev_priv_obj = reg_get_pdev_obj(pdev);
10068 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
10069 		reg_err_rl("pdev reg component is NULL");
10070 		return QDF_STATUS_E_FAILURE;
10071 	}
10072 
10073 	super_chan_list = pdev_priv_obj->super_chan_list;
10074 	for (i = 0; i < NUM_6GHZ_CHANNELS; i++) {
10075 		struct super_chan_info *chan_info = &super_chan_list[i];
10076 		struct regulatory_channel  cur_chan_list =
10077 			pdev_priv_obj->cur_chan_list[MIN_6GHZ_CHANNEL + i];
10078 		uint8_t j;
10079 
10080 		qdf_print("Freq = %d\tPower types = 0x%x\t"
10081 			  "Best power mode = 0x%x\n",
10082 			  cur_chan_list.center_freq, chan_info->power_types,
10083 			  chan_info->best_power_mode);
10084 		for (j = REG_AP_LPI; j <= REG_CLI_SUB_VLP; j++) {
10085 			bool afc_not_done_bit;
10086 
10087 			afc_not_done_bit = chan_info->chan_flags_arr[j] &
10088 						REGULATORY_CHAN_AFC_NOT_DONE;
10089 			qdf_print("Power mode = %d\tPSD flag = %d\t"
10090 				  "PSD power = %d\tEIRP power = %d\t"
10091 				  "Chan flags = 0x%x\tChannel state = %d\t"
10092 				  "Min bw = %d\tMax bw = %d\t"
10093 				  "AFC_NOT_DONE = %d\n",
10094 				  j, chan_info->reg_chan_pwr[j].psd_flag,
10095 				  chan_info->reg_chan_pwr[j].psd_eirp,
10096 				  chan_info->reg_chan_pwr[j].tx_power,
10097 				  chan_info->chan_flags_arr[j],
10098 				  chan_info->state_arr[j],
10099 				  chan_info->min_bw[j], chan_info->max_bw[j],
10100 				  afc_not_done_bit);
10101 		}
10102 	}
10103 
10104 	return QDF_STATUS_SUCCESS;
10105 }
10106 
10107 #if defined(CONFIG_AFC_SUPPORT) && defined(CONFIG_BAND_6GHZ)
10108 QDF_STATUS
10109 reg_get_afc_freq_range_and_psd_limits(struct wlan_objmgr_pdev *pdev,
10110 				      uint8_t num_freq_obj,
10111 				      struct afc_freq_obj *afc_freq_info)
10112 {
10113 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
10114 	struct reg_fw_afc_power_event *power_info;
10115 	uint8_t i;
10116 
10117 	pdev_priv_obj = reg_get_pdev_obj(pdev);
10118 
10119 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
10120 		reg_err("reg pdev priv obj is NULL");
10121 		return QDF_STATUS_E_FAILURE;
10122 	}
10123 
10124 	if (!reg_is_afc_power_event_received(pdev)) {
10125 		reg_err("afc power event is not received\n");
10126 		return QDF_STATUS_E_FAILURE;
10127 	}
10128 
10129 	power_info = pdev_priv_obj->power_info;
10130 	if (!power_info) {
10131 		reg_err("power_info is NULL");
10132 		return QDF_STATUS_E_FAILURE;
10133 	}
10134 
10135 	if (!num_freq_obj) {
10136 		reg_err("num freq objs cannot be zero");
10137 		return QDF_STATUS_E_FAILURE;
10138 	}
10139 
10140 	if (!afc_freq_info)
10141 		return QDF_STATUS_E_FAILURE;
10142 
10143 	for (i = 0; i < num_freq_obj; i++) {
10144 		struct afc_freq_obj *reg_afc_info =
10145 			&power_info->afc_freq_info[i];
10146 
10147 		afc_freq_info[i].low_freq = reg_afc_info->low_freq;
10148 		afc_freq_info[i].high_freq = reg_afc_info->high_freq;
10149 		afc_freq_info[i].max_psd  = reg_afc_info->max_psd;
10150 	}
10151 	return QDF_STATUS_SUCCESS;
10152 }
10153 
10154 QDF_STATUS
10155 reg_get_num_afc_freq_obj(struct wlan_objmgr_pdev *pdev, uint8_t *num_freq_obj)
10156 {
10157 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
10158 	struct reg_fw_afc_power_event *power_info;
10159 
10160 	pdev_priv_obj = reg_get_pdev_obj(pdev);
10161 
10162 	if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) {
10163 		reg_err("reg pdev priv obj is NULL");
10164 		return QDF_STATUS_E_FAILURE;
10165 	}
10166 
10167 	if (!reg_is_afc_power_event_received(pdev)) {
10168 		reg_err("afc power event is not received\n");
10169 		return QDF_STATUS_E_FAILURE;
10170 	}
10171 
10172 	power_info = pdev_priv_obj->power_info;
10173 	if (!power_info) {
10174 		reg_err("power_info is NULL");
10175 		return QDF_STATUS_E_FAILURE;
10176 	}
10177 
10178 	if (!power_info->num_freq_objs) {
10179 		reg_err("num freq objs cannot be zero");
10180 		return QDF_STATUS_E_FAILURE;
10181 	}
10182 
10183 	*num_freq_obj = power_info->num_freq_objs;
10184 
10185 	return QDF_STATUS_SUCCESS;
10186 }
10187 #endif
10188 
10189 #endif
10190 
10191 #ifdef CONFIG_AFC_SUPPORT
10192 QDF_STATUS reg_set_afc_power_event_received(struct wlan_objmgr_pdev *pdev,
10193 					    bool val)
10194 {
10195 	struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj;
10196 
10197 	pdev_priv_obj = reg_get_pdev_obj(pdev);
10198 	if (!pdev_priv_obj) {
10199 		reg_err("pdev priv obj is NULL");
10200 		return QDF_STATUS_E_FAILURE;
10201 	}
10202 	pdev_priv_obj->is_6g_afc_power_event_received = val;
10203 
10204 	return QDF_STATUS_SUCCESS;
10205 }
10206 #endif
10207 
10208 QDF_STATUS reg_process_r2p_table_update_response(struct wlan_objmgr_psoc *psoc,
10209 						 uint32_t pdev_id)
10210 {
10211 	struct wlan_lmac_if_reg_tx_ops *reg_tx_ops;
10212 	QDF_STATUS status = QDF_STATUS_E_FAILURE;
10213 
10214 	reg_tx_ops = reg_get_psoc_tx_ops(psoc);
10215 	if (reg_tx_ops->end_r2p_table_update_wait)
10216 		status = reg_tx_ops->end_r2p_table_update_wait(psoc, pdev_id);
10217 
10218 	return status;
10219 }
10220 
10221 #ifndef CONFIG_REG_CLIENT
10222 bool reg_is_dev_supports_80p80(struct wlan_objmgr_pdev *pdev)
10223 {
10224 	struct wlan_lmac_if_reg_tx_ops *reg_tx_ops;
10225 	struct wlan_objmgr_psoc *psoc;
10226 
10227 	psoc = wlan_pdev_get_psoc(pdev);
10228 	if (!psoc) {
10229 		reg_err("psoc is NULL");
10230 		return false;
10231 	}
10232 
10233 	reg_tx_ops = reg_get_psoc_tx_ops(psoc);
10234 	if (!reg_tx_ops) {
10235 		reg_err("reg_tx_ops is NULL");
10236 		return false;
10237 	}
10238 
10239 	if (reg_tx_ops->is_80p80_supported)
10240 		return reg_tx_ops->is_80p80_supported(pdev);
10241 
10242 	return false;
10243 }
10244 #endif
10245