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
reg_is_chan_bit_punctured(uint16_t input_punc_bitmap,uint8_t chan_idx)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
reg_is_chan_bit_punctured(uint16_t in_punc_bitmap,uint8_t chan_idx)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
reg_get_band_cen_from_bandstart(uint16_t bw,qdf_freq_t bandstart)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
reg_fetch_punc_bitmap(struct ch_params * ch_params)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
reg_get_band_cen_from_bandstart(uint16_t bw,qdf_freq_t bandstart)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
reg_is_freq_within_bonded_chan(qdf_freq_t freq,const struct bonded_channel_freq * bonded_chan_arr,enum phy_ch_width chwidth,qdf_freq_t cen320_freq)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 *
reg_get_bonded_chan_entry(qdf_freq_t freq,enum phy_ch_width chwidth,qdf_freq_t cen320_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
reg_get_next_higher_bandwidth(enum phy_ch_width ch_width)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
get_next_lower_bandwidth(enum phy_ch_width ch_width)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
reg_calculate_max_5gh_enum(void)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
reg_init_channel_map(enum dfs_reg dfs_region)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
reg_get_bw_value(enum phy_ch_width bw)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
reg_get_bw_value(enum phy_ch_width bw)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
reg_get_psoc_tx_ops(struct wlan_objmgr_psoc * psoc)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 */
reg_combine_channel_states(enum channel_state chan_state1,enum channel_state chan_state2)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
reg_read_default_country(struct wlan_objmgr_psoc * psoc,uint8_t * country_code)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
reg_get_max_5g_bw_from_country_code(struct wlan_objmgr_pdev * pdev,uint16_t cc,uint16_t * max_bw_5g)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
reg_get_max_5g_bw_from_regdomain(struct wlan_objmgr_pdev * pdev,uint16_t regdmn,uint16_t * max_bw_5g)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
reg_get_max_5g_bw_from_country_code(struct wlan_objmgr_pdev * pdev,uint16_t cc,uint16_t * max_bw_5g)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
reg_get_max_5g_bw_from_regdomain(struct wlan_objmgr_pdev * pdev,uint16_t regdmn,uint16_t * max_bw_5g)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
reg_get_max_bw_5G_for_fo(struct wlan_objmgr_pdev * pdev)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
reg_get_current_dfs_region(struct wlan_objmgr_pdev * pdev,enum dfs_reg * dfs_reg)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
reg_set_dfs_region(struct wlan_objmgr_pdev * pdev,enum dfs_reg dfs_reg)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
reg_freq_to_chan_direct(qdf_freq_t freq)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
reg_freq_to_chan_for_chlist(struct regulatory_channel * chan_list,qdf_freq_t freq,enum channel_enum num_chans)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
reg_freq_to_chan(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq)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
reg_compute_chan_to_freq_for_chlist(struct regulatory_channel * chan_list,uint8_t chan_num,enum channel_enum min_chan_range,enum channel_enum max_chan_range)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
reg_compute_chan_to_freq(struct wlan_objmgr_pdev * pdev,uint8_t chan_num,enum channel_enum min_chan_range,enum channel_enum max_chan_range)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
reg_legacy_chan_to_freq(struct wlan_objmgr_pdev * pdev,uint8_t chan_num)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
reg_program_default_cc(struct wlan_objmgr_pdev * pdev,uint16_t regdmn)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(®dmn);
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 ®dmn_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, ®dmn_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 */
reg_program_chan_list_po(struct wlan_objmgr_psoc * psoc,struct wlan_objmgr_pdev * pdev,struct cc_regdmn_s * rd)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 ®dmn_pair);
1972 } else if (rd->flags == ALPHA_IS_SET) {
1973 reg_get_rdpair_from_country_iso(rd->cc.alpha,
1974 &country_index,
1975 ®dmn_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 ®dmn_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
reg_program_chan_list_po(struct wlan_objmgr_psoc * psoc,struct wlan_objmgr_pdev * pdev,struct cc_regdmn_s * rd)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
reg_program_chan_list(struct wlan_objmgr_pdev * pdev,struct cc_regdmn_s * rd)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
reg_get_current_cc(struct wlan_objmgr_pdev * pdev,struct cc_regdmn_s * rd)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
reg_set_regdb_offloaded(struct wlan_objmgr_psoc * psoc,bool val)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
reg_get_curr_regdomain(struct wlan_objmgr_pdev * pdev,struct cur_regdmn_info * cur_regdmn)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
reg_modify_chan_144(struct wlan_objmgr_pdev * pdev,bool enable_ch_144)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
reg_get_en_chan_144(struct wlan_objmgr_pdev * pdev)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
reg_get_hal_reg_cap(struct wlan_objmgr_psoc * psoc)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
reg_set_hal_reg_cap(struct wlan_objmgr_psoc * psoc,struct wlan_psoc_host_hal_reg_capabilities_ext * reg_cap,uint16_t phy_cnt)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
reg_update_hal_cap_wireless_modes(struct wlan_objmgr_psoc * psoc,uint64_t wireless_modes,uint8_t phy_id)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
reg_update_hal_reg_range_caps(struct wlan_objmgr_psoc * psoc,uint32_t low_2g_chan,uint32_t high_2g_chan,uint32_t low_5g_chan,uint32_t high_5g_chan,uint8_t phy_id)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)
reg_get_enable_6ghz_sp_mode_support(struct wlan_objmgr_psoc * psoc)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
reg_set_enable_6ghz_sp_mode_support(struct wlan_objmgr_psoc * psoc,bool value)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
reg_get_afc_disable_timer_check(struct wlan_objmgr_psoc * psoc)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
reg_set_afc_disable_timer_check(struct wlan_objmgr_psoc * psoc,bool value)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
reg_get_afc_disable_request_id_check(struct wlan_objmgr_psoc * psoc)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
reg_set_afc_disable_request_id_check(struct wlan_objmgr_psoc * psoc,bool value)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
reg_get_afc_noaction(struct wlan_objmgr_psoc * psoc)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
reg_set_afc_noaction(struct wlan_objmgr_psoc * psoc,bool value)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
reg_chan_in_range(struct regulatory_channel * chan_list,qdf_freq_t low_freq_2g,qdf_freq_t high_freq_2g,qdf_freq_t low_freq_5g,qdf_freq_t high_freq_5g,enum channel_enum ch_enum)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
reg_is_24ghz_ch_freq(uint32_t freq)2510 bool reg_is_24ghz_ch_freq(uint32_t freq)
2511 {
2512 return REG_IS_24GHZ_CH_FREQ(freq);
2513 }
2514
reg_is_5ghz_ch_freq(uint32_t freq)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 */
BAND_2G_PRESENT(uint8_t band_mask)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 */
BAND_5G_PRESENT(uint8_t band_mask)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 */
reg_is_freq_in_between(qdf_freq_t low_freq,qdf_freq_t high_freq,qdf_freq_t freq)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
reg_is_ranges_overlap(qdf_freq_t low_freq,qdf_freq_t high_freq,qdf_freq_t start_edge_freq,qdf_freq_t end_edge_freq)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
reg_is_range_overlap_2g(qdf_freq_t low_freq,qdf_freq_t high_freq)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
reg_is_range_overlap_5g(qdf_freq_t low_freq,qdf_freq_t high_freq)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 *
reg_get_reg_chan(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq)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
reg_is_freq_indoor(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq)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
reg_get_min_chwidth(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq)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
reg_get_max_chwidth(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq)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
reg_is_freq_indoor_in_secondary_list(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq)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
reg_is_6ghz_chan_freq(uint16_t freq)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
reg_is_range_overlap_6g(qdf_freq_t low_freq,qdf_freq_t high_freq)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
reg_is_range_only6g(qdf_freq_t low_freq,qdf_freq_t high_freq)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
reg_min_6ghz_chan_freq(void)2722 uint16_t reg_min_6ghz_chan_freq(void)
2723 {
2724 return REG_MIN_6GHZ_CHAN_FREQ;
2725 }
2726
reg_max_6ghz_chan_freq(void)2727 uint16_t reg_max_6ghz_chan_freq(void)
2728 {
2729 return REG_MAX_6GHZ_CHAN_FREQ;
2730 }
2731
reg_is_6ghz_psc_chan_freq(uint16_t freq)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
reg_is_6g_freq_indoor(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq)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 */
reg_get_max_psd(qdf_freq_t freq,uint16_t bw,enum reg_6g_ap_type reg_ap,enum reg_6g_client_type reg_client,uint8_t * tx_power)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 */
reg_get_max_eirp(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq,uint16_t bw,enum reg_6g_ap_type reg_ap,enum reg_6g_client_type reg_client,uint8_t * tx_power)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
reg_get_max_txpower_for_6g_tpe(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq,uint8_t bw,enum reg_6g_ap_type reg_ap,enum reg_6g_client_type reg_client,bool is_psd,uint8_t * tx_power)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
reg_is_6ghz_unii5_chan_freq(qdf_freq_t freq)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 */
BAND_6G_PRESENT(uint8_t band_mask)2868 static inline bool BAND_6G_PRESENT(uint8_t band_mask)
2869 {
2870 return !!(band_mask & (BIT(REG_BAND_6G)));
2871 }
2872 #else
BAND_6G_PRESENT(uint8_t band_mask)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
reg_get_band_from_cur_chan_list(struct wlan_objmgr_pdev * pdev,uint8_t band_mask,struct regulatory_channel * channel_list,struct regulatory_channel * cur_chan_list)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
reg_get_band_channel_list(struct wlan_objmgr_pdev * pdev,uint8_t band_mask,struct regulatory_channel * channel_list)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
reg_get_band_channel_list_for_pwrmode(struct wlan_objmgr_pdev * pdev,uint8_t band_mask,struct regulatory_channel * channel_list,enum supported_6g_pwr_types in_6g_pwr_mode)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
reg_get_secondary_band_channel_list(struct wlan_objmgr_pdev * pdev,uint8_t band_mask,struct regulatory_channel * channel_list)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
reg_chan_band_to_freq(struct wlan_objmgr_pdev * pdev,uint8_t chan_num,uint8_t band_mask)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
reg_is_49ghz_freq(qdf_freq_t freq)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
reg_ch_num(uint32_t ch_enum)3097 qdf_freq_t reg_ch_num(uint32_t ch_enum)
3098 {
3099 return REG_CH_NUM(ch_enum);
3100 }
3101
reg_ch_to_freq(uint32_t ch_enum)3102 qdf_freq_t reg_ch_to_freq(uint32_t ch_enum)
3103 {
3104 return REG_CH_TO_FREQ(ch_enum);
3105 }
3106
reg_max_5ghz_ch_num(void)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
reg_min_24ghz_chan_freq(void)3113 qdf_freq_t reg_min_24ghz_chan_freq(void)
3114 {
3115 return REG_MIN_24GHZ_CH_FREQ;
3116 }
3117
reg_max_24ghz_chan_freq(void)3118 qdf_freq_t reg_max_24ghz_chan_freq(void)
3119 {
3120 return REG_MAX_24GHZ_CH_FREQ;
3121 }
3122
reg_min_5ghz_chan_freq(void)3123 qdf_freq_t reg_min_5ghz_chan_freq(void)
3124 {
3125 return REG_MIN_5GHZ_CH_FREQ;
3126 }
3127
reg_max_5ghz_chan_freq(void)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
reg_enable_dfs_channels(struct wlan_objmgr_pdev * pdev,bool enable)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
reg_is_regdmn_en302502_applicable(struct wlan_objmgr_pdev * pdev)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
reg_get_phybitmap(struct wlan_objmgr_pdev * pdev,uint16_t * phybitmap)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
reg_update_channel_ranges(struct wlan_objmgr_pdev * pdev)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
reg_modify_pdev_chan_range(struct wlan_objmgr_pdev * pdev)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
reg_update_pdev_wireless_modes(struct wlan_objmgr_pdev * pdev,uint64_t wireless_modes)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
reg_is_reg_unii_band_1_or_reg_unii_band_2a(uint8_t unii_5g_bitmap)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
reg_disable_chan_coex(struct wlan_objmgr_pdev * pdev,uint8_t unii_5g_bitmap)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
reg_is_chan_disabled(uint32_t chan_flags,enum channel_state chan_state)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
reg_append_6g_channel_list_with_power(struct wlan_regulatory_pdev_priv_obj * pdev_priv_obj,struct channel_power * ch_list,uint8_t * count,enum supported_6g_pwr_types in_6g_pwr_type)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
reg_append_6g_channel_list_with_power(struct wlan_regulatory_pdev_priv_obj * pdev_priv_obj,struct channel_power * ch_list,uint8_t * count,enum supported_6g_pwr_types in_6g_pwr_type)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
reg_get_channel_list_with_power(struct wlan_objmgr_pdev * pdev,struct channel_power * ch_list,uint8_t * num_chan,enum supported_6g_pwr_types in_6g_pwr_type)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
reg_get_channel_list_with_power_for_freq(struct wlan_objmgr_pdev * pdev,struct channel_power * ch_list,uint8_t * num_chan)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
reg_get_chan_enum_for_freq(qdf_freq_t freq)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
reg_is_freq_present_in_cur_chan_list(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq)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
is_freq_present_in_resp_list(uint32_t pcl_ch,struct get_usable_chan_res_params * res_msg,int count)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
reg_update_usable_chan_resp(struct wlan_objmgr_pdev * pdev,struct get_usable_chan_res_params * res_msg,uint32_t * pcl_ch,uint32_t len,uint32_t iface_mode_mask,uint32_t band_mask,int * count,enum supported_6g_pwr_types in_6g_pwr_mode)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
reg_update_conn_chan_list(struct wlan_objmgr_pdev * pdev,struct get_usable_chan_res_params * res_msg,enum policy_mgr_con_mode mode,uint32_t iftype,uint32_t band_mask,uint32_t * count,enum supported_6g_pwr_types in_6g_pwr_mode)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
reg_get_usable_channel_con_filter(struct wlan_objmgr_pdev * pdev,struct get_usable_chan_req_params req_msg,struct get_usable_chan_res_params * res_msg,int * count,enum supported_6g_pwr_types in_6g_pwr_mode)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
reg_remove_freq(struct get_usable_chan_res_params * res_msg,int index)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
reg_skip_invalid_chan_freq(struct wlan_objmgr_pdev * pdev,struct get_usable_chan_res_params * res_msg,uint32_t * no_usable_channels,uint32_t iface_mode_mask)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
reg_get_usable_channel_no_filter(struct wlan_objmgr_pdev * pdev,struct get_usable_chan_req_params req_msg,struct get_usable_chan_res_params * res_msg,struct regulatory_channel * chan_list,int * count)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
reg_get_usable_channel_coex_filter(struct wlan_objmgr_pdev * pdev,struct get_usable_chan_req_params req_msg,struct get_usable_chan_res_params * res_msg,struct regulatory_channel * chan_list,int * count)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
reg_calculate_mode_mask(uint32_t iface_mode_mask)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
reg_add_usable_channel_to_resp(struct wlan_objmgr_pdev * pdev,struct get_usable_chan_res_params * res_msg,uint32_t iface_mode_mask,struct regulatory_channel * chan_list,int * count,enum supported_6g_pwr_types in_6g_pwr_mode)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
wlan_reg_get_usable_channel(struct wlan_objmgr_pdev * pdev,struct get_usable_chan_req_params req_msg,struct get_usable_chan_res_params * res_msg,uint32_t * usable_channels,enum supported_6g_pwr_types in_6g_pwr_mode)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
reg_get_nol_channel_state(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq,enum supported_6g_pwr_types in_6g_pwr_mode)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
reg_get_5g_bonded_chan_state(struct wlan_objmgr_pdev * pdev,uint16_t freq,const struct bonded_channel_freq * bonded_chan_ptr,enum supported_6g_pwr_types in_6g_pwr_mode,uint16_t input_punc_bitmap)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
reg_get_5g_chan_state(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq,enum phy_ch_width bw,enum supported_6g_pwr_types in_6g_pwr_mode,uint16_t input_punc_bitmap)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
reg_get_ch_state_based_on_nol_flag(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq,struct ch_params * ch_params,enum supported_6g_pwr_types in_6g_pwr_mode,bool treat_nol_chan_as_disabled)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
reg_is_ch_width_320(enum phy_ch_width ch_width)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
reg_is_ch_width_320(enum phy_ch_width ch_width)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
reg_get_channel_state_for_pwrmode(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq,enum supported_6g_pwr_types in_6g_pwr_type)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
reg_get_channel_flags_for_freq(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq)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
reg_get_channel_state_from_secondary_list_for_freq(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq)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
reg_get_channel_flags_from_secondary_list_for_freq(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq)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 */
reg_get_psd_power(struct regulatory_channel * chan,bool * is_psd)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
reg_get_psd_power(struct regulatory_channel * chan,bool * is_psd)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
reg_get_channel_power_attr_from_secondary_list_for_freq(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq,bool * is_psd,uint16_t * tx_power,uint16_t * psd_eirp,uint32_t * flags)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
reg_decide_6ghz_power_within_bw_for_freq(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq,enum phy_ch_width bw,bool * is_psd,uint16_t * min_tx_power,int16_t * min_psd_eirp,enum reg_6g_ap_type * power_type,enum supported_6g_pwr_types pwr_mode,uint16_t input_punc_bitmap)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
reg_get_5g_bonded_chan_array_for_pwrmode(struct wlan_objmgr_pdev * pdev,uint16_t freq,const struct bonded_channel_freq * bonded_chan_ptr,enum supported_6g_pwr_types in_6g_pwr_type,uint16_t input_punc_bitmap)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
reg_extract_puncture_by_bw(enum phy_ch_width ori_bw,uint16_t ori_puncture_bitmap,qdf_freq_t freq,qdf_freq_t cen320_freq,enum phy_ch_width new_bw,uint16_t * new_puncture_bitmap)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
reg_set_create_punc_bitmap(struct ch_params * ch_params,bool is_create_punc_bitmap)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
reg_is_punc_bitmap_valid(enum phy_ch_width bw,uint16_t puncture_bitmap)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
reg_find_nearest_puncture_pattern(enum phy_ch_width bw,uint16_t proposed_bitmap)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 */
reg_update_5g_bonded_channel_state_punc_for_pwrmode(struct wlan_objmgr_pdev * pdev,const struct bonded_channel_freq * bonded_chan_ptr,struct ch_params * ch_params,enum channel_state * chan_state,enum supported_6g_pwr_types in_6g_pwr_mode)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
reg_apply_puncture(struct wlan_objmgr_pdev * pdev,uint16_t puncture_bitmap,qdf_freq_t freq,enum phy_ch_width bw,qdf_freq_t cen320_freq)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
reg_remove_puncture(struct wlan_objmgr_pdev * pdev)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
reg_update_5g_bonded_channel_state_punc_for_pwrmode(struct wlan_objmgr_pdev * pdev,const struct bonded_channel_freq * bonded_chan_ptr,struct ch_params * ch_params,enum channel_state * chan_state,enum supported_6g_pwr_types in_6g_pwr_mode)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
reg_get_5g_bonded_channel_state_for_pwrmode(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq,struct ch_params * ch_params,enum supported_6g_pwr_types in_6g_pwr_mode)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
reg_get_2g_bonded_channel_state_for_freq(struct wlan_objmgr_pdev * pdev,qdf_freq_t oper_ch_freq,qdf_freq_t sec_ch_freq,enum phy_ch_width bw)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
reg_get_20mhz_channel_state_based_on_nol(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq,bool treat_nol_chan_as_disabled,enum supported_6g_pwr_types in_6g_pwr_type)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
reg_get_320_bonded_chan_array(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq,qdf_freq_t band_center_320,const struct bonded_channel_freq bonded_chan_ar[],uint16_t array_size,const struct bonded_channel_freq * bonded_chan_ptr[])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
reg_get_endchan_cen_from_bandstart(qdf_freq_t band_start,uint16_t bw)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
reg_get_chan_state_for_320(struct wlan_objmgr_pdev * pdev,uint16_t freq,qdf_freq_t band_center_320,enum phy_ch_width ch_width,const struct bonded_channel_freq ** bonded_chan_ptr_ptr,enum supported_6g_pwr_types in_6g_pwr_type,bool treat_nol_chan_as_disabled,uint16_t input_punc_bitmap)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
reg_verify_punc_for_320_and_set_channel_state(uint16_t punc_bitmap,enum channel_state * chan_state,enum channel_state update_state)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
reg_verify_punc_for_320_and_set_channel_state(uint16_t punc_bitmap,enum channel_state * chan_state,enum channel_state update_state)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
reg_get_320_bonded_channel_state_for_pwrmode(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq,const struct bonded_channel_freq * bonded_chan_ptr,enum phy_ch_width bw,uint16_t * out_punc_bitmap,enum supported_6g_pwr_types in_6g_pwr_type,bool treat_nol_chan_as_disabled,uint16_t input_punc_bitmap)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
reg_is_pri_within_240mhz_chan(qdf_freq_t freq)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
reg_fill_chan320mhz_seg0_center(struct wlan_objmgr_pdev * pdev,struct ch_params * ch_param,qdf_freq_t freq)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
reg_fill_channel_list_for_320_for_pwrmode(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq,enum phy_ch_width * in_ch_width,qdf_freq_t band_center_320,struct reg_channel_list * chan_list,bool * update_bw,enum supported_6g_pwr_types in_6g_pwr_mode,bool treat_nol_chan_as_disabled)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
reg_fill_pre320mhz_channel_for_pwrmode(struct wlan_objmgr_pdev * pdev,struct reg_channel_list * chan_list,enum phy_ch_width ch_width,qdf_freq_t freq,qdf_freq_t sec_ch_2g_freq,enum supported_6g_pwr_types in_6g_pwr_mode,bool treat_nol_chan_as_disabled)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
reg_fill_channel_list_for_pwrmode(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq,qdf_freq_t sec_ch_2g_freq,enum phy_ch_width in_ch_width,qdf_freq_t band_center_320,struct reg_channel_list * chan_list,enum supported_6g_pwr_types in_6g_pwr_mode,bool treat_nol_chan_as_disabled)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
reg_get_5g_bonded_channel_for_pwrmode(struct wlan_objmgr_pdev * pdev,uint16_t freq,enum phy_ch_width ch_width,const struct bonded_channel_freq ** bonded_chan_ptr_ptr,enum supported_6g_pwr_types in_6g_pwr_mode,uint16_t input_punc_bitmap)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 */
reg_set_5g_channel_params_for_pwrmode(struct wlan_objmgr_pdev * pdev,uint16_t freq,struct ch_params * ch_params,enum supported_6g_pwr_types in_6g_pwr_type,bool treat_nol_chan_as_disabled)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
reg_get_sec_ch_2g_freq(struct wlan_objmgr_pdev * pdev,qdf_freq_t primary_freq)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
reg_get_sec_ch_2g_freq(struct wlan_objmgr_pdev * pdev,qdf_freq_t primary_freq)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
reg_set_2g_channel_params_for_freq(struct wlan_objmgr_pdev * pdev,uint16_t oper_freq,struct ch_params * ch_params,uint16_t sec_ch_2g_freq)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
reg_copy_ch_params(struct ch_params * ch_params,struct reg_channel_list chan_list)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
reg_set_channel_params_for_pwrmode(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq,qdf_freq_t sec_ch_2g_freq,struct ch_params * ch_params,enum supported_6g_pwr_types in_6g_pwr_mode,bool is_treat_nol_dis)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
reg_set_channel_params_for_pwrmode(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq,qdf_freq_t sec_ch_2g_freq,struct ch_params * ch_params,enum supported_6g_pwr_types in_6g_pwr_mode,bool is_treat_nol_dis)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
reg_get_channel_reg_power_for_freq(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq)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
reg_is_dfs_for_freq(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq)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
reg_is_dfs_in_secondary_list_for_freq(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq)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 */
reg_get_psoc_mas_chan_list(struct wlan_objmgr_pdev * pdev,struct wlan_objmgr_psoc * psoc)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
reg_get_psoc_mas_chan_list(struct wlan_objmgr_pdev * pdev,struct wlan_objmgr_psoc * psoc)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
reg_update_nol_ch_for_freq(struct wlan_objmgr_pdev * pdev,uint16_t * chan_freq_list,uint8_t num_chan,bool nol_chan)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
reg_update_nol_history_ch_for_freq(struct wlan_objmgr_pdev * pdev,uint16_t * chan_list,uint8_t num_chan,bool nol_history_chan)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
reg_min_chan_freq(void)6205 qdf_freq_t reg_min_chan_freq(void)
6206 {
6207 return channel_map[MIN_24GHZ_CHANNEL].center_freq;
6208 }
6209
reg_max_chan_freq(void)6210 qdf_freq_t reg_max_chan_freq(void)
6211 {
6212 return channel_map[NUM_CHANNELS - 1].center_freq;
6213 }
6214
reg_is_same_band_freqs(qdf_freq_t freq1,qdf_freq_t freq2)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
reg_freq_to_band(qdf_freq_t freq)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
reg_is_disable_for_pwrmode(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq,enum supported_6g_pwr_types in_6g_pwr_mode)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
reg_is_disable_in_secondary_list_for_freq(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq)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
reg_is_enable_in_secondary_list_for_freq(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq)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
reg_get_max_tx_power_from_super_chan_list(struct wlan_regulatory_pdev_priv_obj * pdev_priv_obj,enum supported_6g_pwr_types in_6g_pwr_type)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
reg_get_max_tx_power_from_super_chan_list(struct wlan_regulatory_pdev_priv_obj * pdev_priv_obj,enum supported_6g_pwr_types in_6g_pwr_type)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
reg_get_max_tx_power_for_pwr_mode(struct wlan_objmgr_pdev * pdev,enum supported_6g_pwr_types in_6g_pwr_type)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
reg_is_passive_for_freq(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq)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
reg_get_max_tx_power(struct wlan_objmgr_pdev * pdev)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
reg_set_ignore_fw_reg_offload_ind(struct wlan_objmgr_psoc * psoc)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
reg_get_ignore_fw_reg_offload_ind(struct wlan_objmgr_psoc * psoc)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
reg_set_6ghz_supported(struct wlan_objmgr_psoc * psoc,bool val)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
reg_set_5dot9_ghz_supported(struct wlan_objmgr_psoc * psoc,bool val)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
reg_is_6ghz_supported(struct wlan_objmgr_psoc * psoc)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
reg_is_5dot9_ghz_supported(struct wlan_objmgr_psoc * psoc)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
reg_is_fcc_regdmn(struct wlan_objmgr_pdev * pdev)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
reg_is_5dot9_ghz_freq(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq)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
reg_is_5dot9_ghz_chan_allowed_master_mode(struct wlan_objmgr_pdev * pdev)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
reg_get_unii_5g_bitmap(struct wlan_objmgr_pdev * pdev,uint8_t * bitmap)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
reg_is_phymode_unallowed(enum reg_phymode phy_in,uint32_t phymode_bitmap)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
reg_is_phymode_unallowed(enum reg_phymode phy_in,uint32_t phymode_bitmap)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
reg_get_max_phymode(struct wlan_objmgr_pdev * pdev,enum reg_phymode phy_in,qdf_freq_t freq)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
reg_band_bitmap_to_band_info(uint32_t band_bitmap)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
reg_update_tx_power_on_ctry_change(struct wlan_objmgr_pdev * pdev,uint8_t vdev_id)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
reg_add_indoor_concurrency(struct wlan_objmgr_pdev * pdev,uint8_t vdev_id,uint32_t freq,enum phy_ch_width width)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
reg_remove_indoor_concurrency(struct wlan_objmgr_pdev * pdev,uint8_t vdev_id,uint32_t freq)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
reg_init_indoor_channel_list(struct wlan_objmgr_pdev * pdev)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
reg_compute_indoor_list_on_cc_change(struct wlan_objmgr_psoc * psoc,struct wlan_objmgr_pdev * pdev)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
reg_set_cur_6g_ap_pwr_type(struct wlan_objmgr_pdev * pdev,enum reg_6g_ap_type reg_cur_6g_ap_pwr_type)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
reg_get_cur_6g_ap_pwr_type(struct wlan_objmgr_pdev * pdev,enum reg_6g_ap_type * reg_cur_6g_ap_pwr_type)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 *
reg_get_reg_rules_for_pdev(struct wlan_objmgr_pdev * pdev)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
reg_get_num_rules_of_ap_pwr_type(struct wlan_objmgr_pdev * pdev,enum reg_6g_ap_type ap_pwr_type)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 */
reg_is_empty_range(struct freq_range * in_range)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
reg_init_freq_range(qdf_freq_t left,qdf_freq_t right)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
reg_assign_vars_with_range_vals(struct freq_range * in_range,qdf_freq_t * left,qdf_freq_t * right)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
reg_intersect_ranges(struct freq_range * first_range,struct freq_range * second_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 */
reg_iterate_sp_rules(struct wlan_objmgr_pdev * pdev,struct wlan_regulatory_pdev_priv_obj * pdev_priv_obj,reg_act_sp_rule_cb sp_rule_action,void * arg)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 */
reg_afc_incr_num_ranges(struct freq_range * p_range,void * num_freq_ranges)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 */
reg_get_num_sp_freq_ranges(struct wlan_objmgr_pdev * pdev,struct wlan_regulatory_pdev_priv_obj * pdev_priv_obj)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 */
reg_afc_get_intersected_ranges(struct freq_range * rule_fr,void * arg)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 */
reg_cp_freq_ranges(struct wlan_objmgr_pdev * pdev,struct wlan_regulatory_pdev_priv_obj * pdev_priv_obj,uint8_t num_freq_ranges,struct wlan_afc_freq_range_obj * p_range_obj)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
reg_fill_afc_freq_ranges(struct wlan_objmgr_pdev * pdev,struct wlan_regulatory_pdev_priv_obj * pdev_priv_obj,struct wlan_afc_frange_list * p_frange_lst,uint8_t num_freq_ranges)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
reg_fill_afc_opclass_obj(struct wlan_afc_opclass_obj * p_obj_opclass_obj,uint8_t opclass,uint8_t num_chans,uint8_t * p_chan_lst)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
reg_free_afc_opclass_objs(struct wlan_afc_opclass_obj * opclass_objs,uint8_t num_opclass_objs)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
reg_fill_afc_opclasses_arr(struct wlan_objmgr_pdev * pdev,uint8_t num_opclasses,uint8_t * opclass_lst,uint8_t * chansize_lst,uint8_t * channel_lists[],struct wlan_afc_opclass_obj * p_opclass_obj_arr)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
reg_print_afc_req_info_header_params(struct wlan_afc_host_request * afc_req)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
reg_print_afc_req_info_frange_list(struct wlan_afc_host_request * afc_req)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
reg_print_afc_req_info_opclass_list(struct wlan_afc_host_request * afc_req)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
reg_print_afc_req_info_location(struct wlan_afc_host_request * afc_req)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
reg_print_afc_req_info(struct wlan_objmgr_pdev * pdev,struct wlan_afc_host_request * afc_req)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 */
reg_free_afc_freq_list(struct wlan_afc_frange_list * freq_lst)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
reg_free_afc_opclass_list(struct wlan_afc_opclass_obj_list * opclass_obj_lst)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 *
reg_fill_freq_lst(struct wlan_objmgr_pdev * pdev,struct wlan_regulatory_pdev_priv_obj * pdev_priv_obj)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
reg_free_afc_req(struct wlan_objmgr_pdev * pdev,struct wlan_afc_host_request * afc_req)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 *
reg_fill_afc_opclass_obj_lst(struct wlan_objmgr_pdev * pdev,struct wlan_afc_host_request * p_afc_req)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 *
reg_fill_afc_location_obj(struct wlan_regulatory_pdev_priv_obj * pdev_priv_obj,struct wlan_afc_host_request * afc_req)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
reg_get_afc_req_info(struct wlan_objmgr_pdev * pdev,struct wlan_afc_host_request ** afc_req)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
reg_dmn_set_afc_req_id(struct wlan_afc_host_request * afc_req,uint64_t req_id)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
reg_send_afc_request(struct wlan_objmgr_pdev * pdev,struct wlan_afc_host_request * afc_req)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
reg_afc_start(struct wlan_objmgr_pdev * pdev,uint64_t req_id)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
reg_send_afc_power_event(struct wlan_objmgr_pdev * pdev,struct reg_fw_afc_power_event * power_info)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
reg_send_afc_payload_reset_event(struct wlan_objmgr_pdev * pdev)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
reg_register_afc_req_rx_callback(struct wlan_objmgr_pdev * pdev,afc_req_rx_evt_handler cbf,void * arg)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
reg_unregister_afc_req_rx_callback(struct wlan_objmgr_pdev * pdev,afc_req_rx_evt_handler cbf)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
reg_register_afc_power_event_callback(struct wlan_objmgr_pdev * pdev,afc_power_tx_evt_handler cbf,void * arg)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
reg_unregister_afc_power_event_callback(struct wlan_objmgr_pdev * pdev,afc_power_tx_evt_handler cbf)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
reg_register_afc_payload_reset_event_callback(struct wlan_objmgr_pdev * pdev,afc_payload_reset_tx_evt_handler cbf,void * arg)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
reg_unregister_afc_payload_reset_event_callback(struct wlan_objmgr_pdev * pdev,afc_payload_reset_tx_evt_handler cbf)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
reg_get_afc_dev_deploy_type(struct wlan_objmgr_pdev * pdev,enum reg_afc_dev_deploy_type * reg_afc_dev_type)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
reg_is_sta_connect_allowed(struct wlan_objmgr_pdev * pdev,enum reg_6g_ap_type root_ap_pwr_mode)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
reg_set_afc_soc_dev_type(struct wlan_objmgr_psoc * psoc,enum reg_afc_dev_deploy_type reg_afc_dev_type)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
reg_get_afc_soc_dev_type(struct wlan_objmgr_psoc * psoc,enum reg_afc_dev_deploy_type * reg_afc_dev_type)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
reg_set_eirp_preferred_support(struct wlan_objmgr_psoc * psoc,bool reg_is_eirp_support_preferred)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
reg_get_eirp_preferred_support(struct wlan_objmgr_psoc * psoc,bool * reg_is_eirp_support_preferred)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
reg_get_cur_6g_client_type(struct wlan_objmgr_pdev * pdev,enum reg_6g_client_type * reg_cur_6g_client_mobility_type)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
reg_set_cur_6ghz_client_type(struct wlan_objmgr_pdev * pdev,enum reg_6g_client_type in_6ghz_client_type)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
reg_set_6ghz_client_type_from_target(struct wlan_objmgr_pdev * pdev)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
reg_get_rnr_tpe_usable(struct wlan_objmgr_pdev * pdev,bool * reg_rnr_tpe_usable)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
reg_get_unspecified_ap_usable(struct wlan_objmgr_pdev * pdev,bool * reg_unspecified_ap_usable)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
reg_find_txpower_from_6g_list(qdf_freq_t freq,struct regulatory_channel * chan_list,int16_t * txpower)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
reg_is_6g_psd_power(struct wlan_objmgr_pdev * pdev)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
reg_get_6g_chan_psd_eirp_power(qdf_freq_t freq,struct regulatory_channel * mas_chan_list,int16_t * eirp_psd_power)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
reg_get_6g_chan_ap_power(struct wlan_objmgr_pdev * pdev,qdf_freq_t chan_freq,bool * is_psd,int16_t * tx_power,int16_t * eirp_psd_power)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
reg_get_client_power_for_connecting_ap(struct wlan_objmgr_pdev * pdev,enum reg_6g_ap_type ap_type,qdf_freq_t chan_freq,bool is_psd,uint16_t * tx_power,uint16_t * eirp_psd_power)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
reg_get_client_power_for_6ghz_ap(struct wlan_objmgr_pdev * pdev,enum reg_6g_client_type client_type,qdf_freq_t chan_freq,bool * is_psd,uint16_t * tx_power,uint16_t * eirp_psd_power)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
reg_set_ap_pwr_and_update_chan_list(struct wlan_objmgr_pdev * pdev,enum reg_6g_ap_type ap_pwr_type)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
reg_is_regdb_offloaded(struct wlan_objmgr_psoc * psoc)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
reg_set_ext_tpc_supported(struct wlan_objmgr_psoc * psoc,bool val)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
reg_is_ext_tpc_supported(struct wlan_objmgr_psoc * psoc)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
reg_set_lower_6g_edge_ch_supp(struct wlan_objmgr_psoc * psoc,bool val)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
reg_set_disable_upper_6g_edge_ch_supp(struct wlan_objmgr_psoc * psoc,bool val)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
reg_is_lower_6g_edge_ch_supp(struct wlan_objmgr_psoc * psoc)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
reg_is_upper_6g_edge_ch_disabled(struct wlan_objmgr_psoc * psoc)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
reg_is_within_range_inclusive(enum channel_enum left,enum channel_enum right,enum channel_enum idx)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
reg_convert_enum_to_6g_idx(enum channel_enum ch_idx)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
reg_get_superchan_entry(struct wlan_objmgr_pdev * pdev,enum channel_enum chan_enum,const struct super_chan_info ** p_sup_chan_entry)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
reg_process_ch_avoid_freq_ext(struct wlan_objmgr_psoc * psoc,struct wlan_objmgr_pdev * pdev)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
reg_update_avoid_ch_ext(struct wlan_objmgr_psoc * psoc,void * object,void * arg)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
reg_process_ch_avoid_ext_event(struct wlan_objmgr_psoc * psoc,struct ch_avoid_ind_type * ch_avoid_event)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
reg_check_coex_unsafe_nb_user_prefer(struct wlan_objmgr_psoc * psoc)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
reg_check_coex_unsafe_chan_reg_disable(struct wlan_objmgr_psoc * psoc)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)
reg_send_afc_cmd(struct wlan_objmgr_pdev * pdev,struct reg_afc_resp_rx_ind_info * afc_ind_obj)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
reg_is_afc_power_event_received(struct wlan_objmgr_pdev * pdev)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
reg_is_afc_done(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq)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
reg_get_afc_req_id(struct wlan_objmgr_pdev * pdev,uint64_t * req_id)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
reg_is_afc_expiry_event_received(struct wlan_objmgr_pdev * pdev)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
reg_is_noaction_on_afc_pwr_evt(struct wlan_objmgr_pdev * pdev)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
reg_is_chwidth_supported(struct wlan_objmgr_pdev * pdev,enum phy_ch_width ch_width,bool * is_supported)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
reg_is_state_allowed(enum channel_state chan_state)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
reg_is_freq_idx_enabled_on_cur_chan_list(struct wlan_regulatory_pdev_priv_obj * pdev_priv_obj,enum channel_enum freq_idx)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
reg_get_min_max_bw_on_cur_chan_list(struct wlan_objmgr_pdev * pdev,enum channel_enum freq_idx,uint16_t * min_bw,uint16_t * max_bw)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
reg_get_chan_state_on_cur_chan_list(struct wlan_regulatory_pdev_priv_obj * pdev_priv_obj,enum channel_enum freq_idx)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
reg_get_chan_state_based_on_nol_flag_cur_chan_list(struct wlan_regulatory_pdev_priv_obj * pdev_priv_obj,enum channel_enum freq_idx)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
reg_is_supr_entry_mode_disabled(const struct super_chan_info * super_chan_ent,enum supported_6g_pwr_types in_6g_pwr_mode)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
reg_is_freq_idx_enabled_on_given_pwr_mode(struct wlan_regulatory_pdev_priv_obj * pdev_priv_obj,enum channel_enum freq_idx,enum supported_6g_pwr_types in_6g_pwr_mode)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
reg_get_min_max_bw_on_given_pwr_mode(struct wlan_regulatory_pdev_priv_obj * pdev_priv_obj,enum channel_enum freq_idx,enum supported_6g_pwr_types in_6g_pwr_mode,uint16_t * min_bw,uint16_t * max_bw)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
reg_get_chan_state_on_given_pwr_mode(struct wlan_regulatory_pdev_priv_obj * pdev_priv_obj,enum channel_enum freq_idx,enum supported_6g_pwr_types in_6g_pwr_mode)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
reg_get_best_6g_pwr_type(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq)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
reg_is_6g_ap_type_invalid(enum reg_6g_ap_type ap_pwr_type)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
reg_conv_6g_ap_type_to_supported_6g_pwr_types(enum reg_6g_ap_type ap_pwr_type)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
reg_is_freq_idx_enabled_on_given_pwr_mode(struct wlan_regulatory_pdev_priv_obj * pdev_priv_obj,enum channel_enum freq_idx,enum supported_6g_pwr_types in_6g_pwr_mode)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
reg_get_min_max_bw_on_given_pwr_mode(struct wlan_regulatory_pdev_priv_obj * pdev_priv_obj,enum channel_enum freq_idx,enum supported_6g_pwr_types in_6g_pwr_mode,uint16_t * min_bw,uint16_t * max_bw)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
reg_get_chan_state_on_given_pwr_mode(struct wlan_regulatory_pdev_priv_obj * pdev_priv_obj,enum channel_enum freq_idx,enum supported_6g_pwr_types in_6g_pwr_mode)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
reg_is_freq_enabled(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq,enum supported_6g_pwr_types in_6g_pwr_mode)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
reg_is_freq_idx_enabled(struct wlan_objmgr_pdev * pdev,enum channel_enum freq_idx,enum supported_6g_pwr_types in_6g_pwr_mode)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
reg_get_min_max_bw_reg_chan_list(struct wlan_objmgr_pdev * pdev,enum channel_enum freq_idx,enum supported_6g_pwr_types in_6g_pwr_mode,uint16_t * min_bw,uint16_t * max_bw)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
reg_get_chan_state(struct wlan_objmgr_pdev * pdev,enum channel_enum freq_idx,enum supported_6g_pwr_types in_6g_pwr_mode,bool treat_nol_chan_as_disabled)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
reg_find_chwidth_from_bw(uint16_t bw)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
reg_find_chwidth_from_bw(uint16_t bw)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
reg_get_thresh_priority_freq(struct wlan_objmgr_pdev * pdev)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
reg_get_eirp_from_psd_and_reg_max_eirp(struct wlan_objmgr_pdev * pdev,struct regulatory_channel * mas_chan_list,qdf_freq_t freq,uint16_t bw,int16_t * reg_eirp_pwr)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
reg_get_mas_chan_list_for_lookup(struct wlan_objmgr_pdev * pdev,struct regulatory_channel ** master_chan_list,enum reg_6g_ap_type ap_pwr_type,bool is_client_list_lookup_needed,enum reg_6g_client_type client_type)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
reg_get_eirp_from_mas_chan_list(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq,uint16_t bw,enum reg_6g_ap_type ap_pwr_type,bool is_client_list_lookup_needed,enum reg_6g_client_type client_type)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
reg_compute_6g_center_freq_from_cfi(uint8_t ieee_6g_cfi)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 */
reg_is_320_opclass(qdf_freq_t freq,uint8_t in_opclass)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
reg_is_320_opclass(qdf_freq_t freq,uint8_t op_class)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 */
reg_find_eirp_in_afc_eirp_obj(struct wlan_objmgr_pdev * pdev,struct chan_eirp_obj * eirp_obj,qdf_freq_t freq,qdf_freq_t cen320,uint8_t op_class)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 */
reg_find_eirp_in_afc_chan_obj(struct wlan_objmgr_pdev * pdev,struct afc_chan_obj * chan_obj,qdf_freq_t freq,qdf_freq_t cen320,uint8_t op_class)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
reg_is_chan_punc(uint16_t in_punc_pattern,uint16_t bw)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
reg_is_chan_punc(uint16_t in_punc_pattern,uint16_t bw)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
reg_find_non_punctured_bw(uint16_t bw,uint16_t in_punc_pattern)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
reg_get_sp_eirp_for_punc_chans(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq,qdf_freq_t cen320,uint16_t bw,uint16_t in_punc_pattern,int16_t reg_sp_eirp_pwr)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
reg_get_sp_eirp_before_afc_resp_rx(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq,uint16_t bw,bool is_client_list_lookup_needed,enum reg_6g_client_type client_type)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, ®_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 */
reg_get_sp_eirp(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq,qdf_freq_t cen320,uint16_t bw,uint16_t in_punc_pattern,bool is_client_list_lookup_needed,enum reg_6g_client_type client_type)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 ®_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 ®_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 ®_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
reg_get_sp_eirp(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq,qdf_freq_t cen320,uint16_t bw,uint16_t in_punc_pattern,bool is_client_list_lookup_needed,enum reg_6g_client_type client_type)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
reg_get_best_pwr_mode_from_eirp_list(int8_t * eirp_list,uint8_t size)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
reg_get_eirp_pwr(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq,qdf_freq_t cen320,uint16_t bw,enum reg_6g_ap_type ap_pwr_type,uint16_t in_punc_pattern,bool is_client_list_lookup_needed,enum reg_6g_client_type client_type)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
reg_get_best_pwr_mode(struct wlan_objmgr_pdev * pdev,qdf_freq_t freq,qdf_freq_t cen320,uint16_t bw,uint16_t in_punc_pattern)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
reg_get_regd_rules(struct wlan_objmgr_pdev * pdev,struct reg_rule_info * reg_rules)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
reg_is_sup_chan_entry_afc_done(struct wlan_objmgr_pdev * pdev,enum channel_enum chan_idx,enum supported_6g_pwr_types in_6g_pwr_mode)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
reg_display_super_chan_list(struct wlan_objmgr_pdev * pdev)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
reg_get_afc_freq_range_and_psd_limits(struct wlan_objmgr_pdev * pdev,uint8_t num_freq_obj,struct afc_freq_obj * afc_freq_info)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
reg_get_num_afc_freq_obj(struct wlan_objmgr_pdev * pdev,uint8_t * num_freq_obj)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
reg_set_afc_power_event_received(struct wlan_objmgr_pdev * pdev,bool val)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
reg_process_r2p_table_update_response(struct wlan_objmgr_psoc * psoc,uint32_t pdev_id)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
reg_is_dev_supports_80p80(struct wlan_objmgr_pdev * pdev)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