1 /* 2 * Copyright (c) 2014-2020 The Linux Foundation. All rights reserved. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for 5 * any purpose with or without fee is hereby granted, provided that the 6 * above copyright notice and this permission notice appear in all 7 * copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 10 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 11 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 12 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 13 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 14 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 15 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 16 * PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 /** 20 * DOC: reg_services_common.c 21 * This file defines regulatory component service functions 22 */ 23 24 #include <wlan_cmn.h> 25 #include <reg_services_public_struct.h> 26 #include <wlan_objmgr_psoc_obj.h> 27 #include <qdf_lock.h> 28 #include "reg_priv_objs.h" 29 #include "reg_utils.h" 30 #include "reg_callbacks.h" 31 #include "reg_services_common.h" 32 #include <wlan_objmgr_psoc_obj.h> 33 #include "reg_db.h" 34 #include "reg_db_parser.h" 35 #include "reg_build_chan_list.h" 36 #include <wlan_objmgr_pdev_obj.h> 37 #include <target_if.h> 38 39 const struct chan_map *channel_map; 40 #ifdef CONFIG_CHAN_NUM_API 41 static const struct bonded_channel bonded_chan_40mhz_list[] = { 42 {36, 40}, 43 {44, 48}, 44 {52, 56}, 45 {60, 64}, 46 {100, 104}, 47 {108, 112}, 48 {116, 120}, 49 {124, 128}, 50 {132, 136}, 51 {140, 144}, 52 {149, 153}, 53 {157, 161}, 54 {165, 169}, 55 {173, 177} 56 }; 57 58 static const struct bonded_channel bonded_chan_80mhz_list[] = { 59 {36, 48}, 60 {52, 64}, 61 {100, 112}, 62 {116, 128}, 63 {132, 144}, 64 {149, 161}, 65 {165, 177} 66 }; 67 68 static const struct bonded_channel bonded_chan_160mhz_list[] = { 69 {36, 64}, 70 {100, 128}, 71 {149, 177} 72 }; 73 #endif /* CONFIG_CHAN_NUM_API */ 74 75 #ifdef CONFIG_CHAN_FREQ_API 76 /* bonded_chan_40mhz_list_freq - List of 40MHz bonnded channel frequencies */ 77 static const struct bonded_channel_freq bonded_chan_40mhz_list_freq[] = { 78 {5180, 5200}, 79 {5220, 5240}, 80 {5260, 5280}, 81 {5300, 5320}, 82 {5500, 5520}, 83 {5540, 5560}, 84 {5580, 5600}, 85 {5620, 5640}, 86 {5660, 5680}, 87 {5700, 5720}, 88 {5745, 5765}, 89 {5785, 5805}, 90 {5825, 5845}, 91 {5865, 5885}, 92 #ifdef CONFIG_BAND_6GHZ 93 {5955, 5975}, 94 {5995, 6015}, 95 {6035, 6055}, 96 {6075, 6095}, 97 {6115, 6135}, 98 {6155, 6175}, 99 {6195, 6215}, 100 {6235, 6255}, 101 {6275, 6295}, 102 {6315, 6335}, 103 {6355, 6375}, 104 {6395, 6415}, 105 {6435, 6455}, 106 {6475, 6495}, 107 {6515, 6535}, 108 {6555, 6575}, 109 {6595, 6615}, 110 {6635, 6655}, 111 {6675, 6695}, 112 {6715, 6735}, 113 {6755, 6775}, 114 {6795, 6815}, 115 {6835, 6855}, 116 {6875, 6895}, 117 {6915, 6935}, 118 {6955, 6975}, 119 {6995, 7015}, 120 {7035, 7055}, 121 {7075, 7095} 122 #endif /*CONFIG_BAND_6GHZ*/ 123 }; 124 125 /* bonded_chan_80mhz_list_freq - List of 80MHz bonnded channel frequencies */ 126 static const struct bonded_channel_freq bonded_chan_80mhz_list_freq[] = { 127 {5180, 5240}, 128 {5260, 5320}, 129 {5500, 5560}, 130 {5580, 5640}, 131 {5660, 5720}, 132 {5745, 5805}, 133 {5825, 5885}, 134 #ifdef CONFIG_BAND_6GHZ 135 {5955, 6015}, 136 {6035, 6095}, 137 {6115, 6175}, 138 {6195, 6255}, 139 {6275, 6335}, 140 {6355, 6415}, 141 {6435, 6495}, 142 {6515, 6575}, 143 {6595, 6655}, 144 {6675, 6735}, 145 {6755, 6815}, 146 {6835, 6895}, 147 {6915, 6975}, 148 {6995, 7055} 149 #endif /*CONFIG_BAND_6GHZ*/ 150 }; 151 152 /* bonded_chan_160mhz_list_freq - List of 160MHz bonnded channel frequencies */ 153 static const struct bonded_channel_freq bonded_chan_160mhz_list_freq[] = { 154 {5180, 5320}, 155 {5500, 5640}, 156 {5745, 5885}, 157 #ifdef CONFIG_BAND_6GHZ 158 {5955, 6095}, 159 {6115, 6255}, 160 {6275, 6415}, 161 {6435, 6575}, 162 {6595, 6735}, 163 {6755, 6895}, 164 {6915, 7055} 165 #endif /*CONFIG_BAND_6GHZ*/ 166 }; 167 #endif /*CONFIG_CHAN_FREQ_API*/ 168 169 static const enum phy_ch_width get_next_lower_bw[] = { 170 [CH_WIDTH_80P80MHZ] = CH_WIDTH_160MHZ, 171 [CH_WIDTH_160MHZ] = CH_WIDTH_80MHZ, 172 [CH_WIDTH_80MHZ] = CH_WIDTH_40MHZ, 173 [CH_WIDTH_40MHZ] = CH_WIDTH_20MHZ, 174 [CH_WIDTH_20MHZ] = CH_WIDTH_10MHZ, 175 [CH_WIDTH_10MHZ] = CH_WIDTH_5MHZ, 176 [CH_WIDTH_5MHZ] = CH_WIDTH_INVALID 177 }; 178 179 const struct chan_map channel_map_us[NUM_CHANNELS] = { 180 [CHAN_ENUM_2412] = {2412, 1, 20, 40}, 181 [CHAN_ENUM_2417] = {2417, 2, 20, 40}, 182 [CHAN_ENUM_2422] = {2422, 3, 20, 40}, 183 [CHAN_ENUM_2427] = {2427, 4, 20, 40}, 184 [CHAN_ENUM_2432] = {2432, 5, 20, 40}, 185 [CHAN_ENUM_2437] = {2437, 6, 20, 40}, 186 [CHAN_ENUM_2442] = {2442, 7, 20, 40}, 187 [CHAN_ENUM_2447] = {2447, 8, 20, 40}, 188 [CHAN_ENUM_2452] = {2452, 9, 20, 40}, 189 [CHAN_ENUM_2457] = {2457, 10, 20, 40}, 190 [CHAN_ENUM_2462] = {2462, 11, 20, 40}, 191 [CHAN_ENUM_2467] = {2467, 12, 20, 40}, 192 [CHAN_ENUM_2472] = {2472, 13, 20, 40}, 193 [CHAN_ENUM_2484] = {2484, 14, 20, 20}, 194 #ifdef CONFIG_49GHZ_CHAN 195 [CHAN_ENUM_4912] = {4912, INVALID_CHANNEL_NUM, 2, 20}, 196 [CHAN_ENUM_4915] = {4915, INVALID_CHANNEL_NUM, 2, 20}, 197 [CHAN_ENUM_4917] = {4917, INVALID_CHANNEL_NUM, 2, 20}, 198 [CHAN_ENUM_4920] = {4920, INVALID_CHANNEL_NUM, 2, 20}, 199 [CHAN_ENUM_4922] = {4922, INVALID_CHANNEL_NUM, 2, 20}, 200 [CHAN_ENUM_4925] = {4925, INVALID_CHANNEL_NUM, 2, 20}, 201 [CHAN_ENUM_4927] = {4927, INVALID_CHANNEL_NUM, 2, 20}, 202 [CHAN_ENUM_4932] = {4932, INVALID_CHANNEL_NUM, 2, 20}, 203 [CHAN_ENUM_4935] = {4935, INVALID_CHANNEL_NUM, 2, 20}, 204 [CHAN_ENUM_4937] = {4937, INVALID_CHANNEL_NUM, 2, 20}, 205 [CHAN_ENUM_4940] = {4940, INVALID_CHANNEL_NUM, 2, 20}, 206 [CHAN_ENUM_4942] = {4942, 1, 5, 5}, 207 [CHAN_ENUM_4945] = {4945, 11, 10, 10}, 208 [CHAN_ENUM_4947] = {4947, 2, 5, 5}, 209 [CHAN_ENUM_4950] = {4950, 20, 10, 20}, 210 [CHAN_ENUM_4952] = {4952, 3, 5, 5}, 211 [CHAN_ENUM_4955] = {4955, 21, 10, 20}, 212 [CHAN_ENUM_4957] = {4957, 4, 5, 5}, 213 [CHAN_ENUM_4960] = {4960, 22, 10, 20}, 214 [CHAN_ENUM_4962] = {4962, 5, 5, 5}, 215 [CHAN_ENUM_4965] = {4965, 23, 10, 20}, 216 [CHAN_ENUM_4967] = {4967, 6, 5, 5}, 217 [CHAN_ENUM_4970] = {4970, 24, 10, 20}, 218 [CHAN_ENUM_4972] = {4972, 7, 5, 5}, 219 [CHAN_ENUM_4975] = {4975, 25, 10, 20}, 220 [CHAN_ENUM_4977] = {4977, 8, 5, 5}, 221 [CHAN_ENUM_4980] = {4980, 26, 10, 20}, 222 [CHAN_ENUM_4982] = {4982, 9, 5, 5}, 223 [CHAN_ENUM_4985] = {4985, 19, 10, 10}, 224 [CHAN_ENUM_4987] = {4987, 10, 5, 5}, 225 [CHAN_ENUM_5032] = {5032, INVALID_CHANNEL_NUM, 2, 20}, 226 [CHAN_ENUM_5035] = {5035, INVALID_CHANNEL_NUM, 2, 20}, 227 [CHAN_ENUM_5037] = {5037, INVALID_CHANNEL_NUM, 2, 20}, 228 [CHAN_ENUM_5040] = {5040, INVALID_CHANNEL_NUM, 2, 20}, 229 [CHAN_ENUM_5042] = {5042, INVALID_CHANNEL_NUM, 2, 20}, 230 [CHAN_ENUM_5045] = {5045, INVALID_CHANNEL_NUM, 2, 20}, 231 [CHAN_ENUM_5047] = {5047, INVALID_CHANNEL_NUM, 2, 20}, 232 [CHAN_ENUM_5052] = {5052, INVALID_CHANNEL_NUM, 2, 20}, 233 [CHAN_ENUM_5055] = {5055, INVALID_CHANNEL_NUM, 2, 20}, 234 [CHAN_ENUM_5057] = {5057, INVALID_CHANNEL_NUM, 2, 20}, 235 [CHAN_ENUM_5060] = {5060, INVALID_CHANNEL_NUM, 2, 20}, 236 [CHAN_ENUM_5080] = {5080, INVALID_CHANNEL_NUM, 2, 20}, 237 #endif /* CONFIG_49GHZ_CHAN */ 238 [CHAN_ENUM_5180] = {5180, 36, 2, 160}, 239 [CHAN_ENUM_5200] = {5200, 40, 2, 160}, 240 [CHAN_ENUM_5220] = {5220, 44, 2, 160}, 241 [CHAN_ENUM_5240] = {5240, 48, 2, 160}, 242 [CHAN_ENUM_5260] = {5260, 52, 2, 160}, 243 [CHAN_ENUM_5280] = {5280, 56, 2, 160}, 244 [CHAN_ENUM_5300] = {5300, 60, 2, 160}, 245 [CHAN_ENUM_5320] = {5320, 64, 2, 160}, 246 [CHAN_ENUM_5500] = {5500, 100, 2, 160}, 247 [CHAN_ENUM_5520] = {5520, 104, 2, 160}, 248 [CHAN_ENUM_5540] = {5540, 108, 2, 160}, 249 [CHAN_ENUM_5560] = {5560, 112, 2, 160}, 250 [CHAN_ENUM_5580] = {5580, 116, 2, 160}, 251 [CHAN_ENUM_5600] = {5600, 120, 2, 160}, 252 [CHAN_ENUM_5620] = {5620, 124, 2, 160}, 253 [CHAN_ENUM_5640] = {5640, 128, 2, 160}, 254 [CHAN_ENUM_5660] = {5660, 132, 2, 160}, 255 [CHAN_ENUM_5680] = {5680, 136, 2, 160}, 256 [CHAN_ENUM_5700] = {5700, 140, 2, 160}, 257 [CHAN_ENUM_5720] = {5720, 144, 2, 160}, 258 [CHAN_ENUM_5745] = {5745, 149, 2, 160}, 259 [CHAN_ENUM_5765] = {5765, 153, 2, 160}, 260 [CHAN_ENUM_5785] = {5785, 157, 2, 160}, 261 [CHAN_ENUM_5805] = {5805, 161, 2, 160}, 262 [CHAN_ENUM_5825] = {5825, 165, 2, 160}, 263 [CHAN_ENUM_5845] = {5845, 169, 2, 160}, 264 #ifdef WLAN_FEATURE_DSRC 265 [CHAN_ENUM_5850] = {5850, 170, 2, 160}, 266 [CHAN_ENUM_5855] = {5855, 171, 2, 160}, 267 [CHAN_ENUM_5860] = {5860, 172, 2, 160}, 268 #endif 269 [CHAN_ENUM_5865] = {5865, 173, 2, 160}, 270 #ifdef WLAN_FEATURE_DSRC 271 [CHAN_ENUM_5870] = {5870, 174, 2, 160}, 272 [CHAN_ENUM_5875] = {5875, 175, 2, 160}, 273 [CHAN_ENUM_5880] = {5880, 176, 2, 160}, 274 #endif 275 [CHAN_ENUM_5885] = {5885, 177, 2, 160}, 276 #ifdef WLAN_FEATURE_DSRC 277 [CHAN_ENUM_5890] = {5890, 178, 2, 160}, 278 [CHAN_ENUM_5895] = {5895, 179, 2, 160}, 279 [CHAN_ENUM_5900] = {5900, 180, 2, 160}, 280 [CHAN_ENUM_5905] = {5905, 181, 2, 160}, 281 [CHAN_ENUM_5910] = {5910, 182, 2, 160}, 282 [CHAN_ENUM_5915] = {5915, 183, 2, 160}, 283 [CHAN_ENUM_5920] = {5920, 184, 2, 160}, 284 #endif /* WLAN_FEATURE_DSRC */ 285 #ifdef CONFIG_BAND_6GHZ 286 [CHAN_ENUM_5935] = {5935, 2, 2, 20}, 287 [CHAN_ENUM_5955] = {5955, 1, 2, 160}, 288 [CHAN_ENUM_5975] = {5975, 5, 2, 160}, 289 [CHAN_ENUM_5995] = {5995, 9, 2, 160}, 290 [CHAN_ENUM_6015] = {6015, 13, 2, 160}, 291 [CHAN_ENUM_6035] = {6035, 17, 2, 160}, 292 [CHAN_ENUM_6055] = {6055, 21, 2, 160}, 293 [CHAN_ENUM_6075] = {6075, 25, 2, 160}, 294 [CHAN_ENUM_6095] = {6095, 29, 2, 160}, 295 [CHAN_ENUM_6115] = {6115, 33, 2, 160}, 296 [CHAN_ENUM_6135] = {6135, 37, 2, 160}, 297 [CHAN_ENUM_6155] = {6155, 41, 2, 160}, 298 [CHAN_ENUM_6175] = {6175, 45, 2, 160}, 299 [CHAN_ENUM_6195] = {6195, 49, 2, 160}, 300 [CHAN_ENUM_6215] = {6215, 53, 2, 160}, 301 [CHAN_ENUM_6235] = {6235, 57, 2, 160}, 302 [CHAN_ENUM_6255] = {6255, 61, 2, 160}, 303 [CHAN_ENUM_6275] = {6275, 65, 2, 160}, 304 [CHAN_ENUM_6295] = {6295, 69, 2, 160}, 305 [CHAN_ENUM_6315] = {6315, 73, 2, 160}, 306 [CHAN_ENUM_6335] = {6335, 77, 2, 160}, 307 [CHAN_ENUM_6355] = {6355, 81, 2, 160}, 308 [CHAN_ENUM_6375] = {6375, 85, 2, 160}, 309 [CHAN_ENUM_6395] = {6395, 89, 2, 160}, 310 [CHAN_ENUM_6415] = {6415, 93, 2, 160}, 311 [CHAN_ENUM_6435] = {6435, 97, 2, 160}, 312 [CHAN_ENUM_6455] = {6455, 101, 2, 160}, 313 [CHAN_ENUM_6475] = {6475, 105, 2, 160}, 314 [CHAN_ENUM_6495] = {6495, 109, 2, 160}, 315 [CHAN_ENUM_6515] = {6515, 113, 2, 160}, 316 [CHAN_ENUM_6535] = {6535, 117, 2, 160}, 317 [CHAN_ENUM_6555] = {6555, 121, 2, 160}, 318 [CHAN_ENUM_6575] = {6575, 125, 2, 160}, 319 [CHAN_ENUM_6595] = {6595, 129, 2, 160}, 320 [CHAN_ENUM_6615] = {6615, 133, 2, 160}, 321 [CHAN_ENUM_6635] = {6635, 137, 2, 160}, 322 [CHAN_ENUM_6655] = {6655, 141, 2, 160}, 323 [CHAN_ENUM_6675] = {6675, 145, 2, 160}, 324 [CHAN_ENUM_6695] = {6695, 149, 2, 160}, 325 [CHAN_ENUM_6715] = {6715, 153, 2, 160}, 326 [CHAN_ENUM_6735] = {6735, 157, 2, 160}, 327 [CHAN_ENUM_6755] = {6755, 161, 2, 160}, 328 [CHAN_ENUM_6775] = {6775, 165, 2, 160}, 329 [CHAN_ENUM_6795] = {6795, 169, 2, 160}, 330 [CHAN_ENUM_6815] = {6815, 173, 2, 160}, 331 [CHAN_ENUM_6835] = {6835, 177, 2, 160}, 332 [CHAN_ENUM_6855] = {6855, 181, 2, 160}, 333 [CHAN_ENUM_6875] = {6875, 185, 2, 160}, 334 [CHAN_ENUM_6895] = {6895, 189, 2, 160}, 335 [CHAN_ENUM_6915] = {6915, 193, 2, 160}, 336 [CHAN_ENUM_6935] = {6935, 197, 2, 160}, 337 [CHAN_ENUM_6955] = {6955, 201, 2, 160}, 338 [CHAN_ENUM_6975] = {6975, 205, 2, 160}, 339 [CHAN_ENUM_6995] = {6995, 209, 2, 160}, 340 [CHAN_ENUM_7015] = {7015, 213, 2, 160}, 341 [CHAN_ENUM_7035] = {7035, 217, 2, 160}, 342 [CHAN_ENUM_7055] = {7055, 221, 2, 160}, 343 [CHAN_ENUM_7075] = {7075, 225, 2, 160}, 344 [CHAN_ENUM_7095] = {7095, 229, 2, 160}, 345 [CHAN_ENUM_7115] = {7115, 233, 2, 160} 346 #endif /* CONFIG_BAND_6GHZ */ 347 }; 348 349 const struct chan_map channel_map_eu[NUM_CHANNELS] = { 350 [CHAN_ENUM_2412] = {2412, 1, 20, 40}, 351 [CHAN_ENUM_2417] = {2417, 2, 20, 40}, 352 [CHAN_ENUM_2422] = {2422, 3, 20, 40}, 353 [CHAN_ENUM_2427] = {2427, 4, 20, 40}, 354 [CHAN_ENUM_2432] = {2432, 5, 20, 40}, 355 [CHAN_ENUM_2437] = {2437, 6, 20, 40}, 356 [CHAN_ENUM_2442] = {2442, 7, 20, 40}, 357 [CHAN_ENUM_2447] = {2447, 8, 20, 40}, 358 [CHAN_ENUM_2452] = {2452, 9, 20, 40}, 359 [CHAN_ENUM_2457] = {2457, 10, 20, 40}, 360 [CHAN_ENUM_2462] = {2462, 11, 20, 40}, 361 [CHAN_ENUM_2467] = {2467, 12, 20, 40}, 362 [CHAN_ENUM_2472] = {2472, 13, 20, 40}, 363 [CHAN_ENUM_2484] = {2484, 14, 20, 20}, 364 #ifdef CONFIG_49GHZ_CHAN 365 [CHAN_ENUM_4912] = {4912, INVALID_CHANNEL_NUM, 2, 20}, 366 [CHAN_ENUM_4915] = {4915, INVALID_CHANNEL_NUM, 2, 20}, 367 [CHAN_ENUM_4917] = {4917, INVALID_CHANNEL_NUM, 2, 20}, 368 [CHAN_ENUM_4920] = {4920, INVALID_CHANNEL_NUM, 2, 20}, 369 [CHAN_ENUM_4922] = {4922, INVALID_CHANNEL_NUM, 2, 20}, 370 [CHAN_ENUM_4925] = {4925, INVALID_CHANNEL_NUM, 2, 20}, 371 [CHAN_ENUM_4927] = {4927, INVALID_CHANNEL_NUM, 2, 20}, 372 [CHAN_ENUM_4932] = {4932, INVALID_CHANNEL_NUM, 2, 20}, 373 [CHAN_ENUM_4935] = {4935, INVALID_CHANNEL_NUM, 2, 20}, 374 [CHAN_ENUM_4937] = {4937, INVALID_CHANNEL_NUM, 2, 20}, 375 [CHAN_ENUM_4940] = {4940, INVALID_CHANNEL_NUM, 2, 20}, 376 [CHAN_ENUM_4942] = {4942, INVALID_CHANNEL_NUM, 2, 20}, 377 [CHAN_ENUM_4945] = {4945, INVALID_CHANNEL_NUM, 2, 20}, 378 [CHAN_ENUM_4947] = {4947, INVALID_CHANNEL_NUM, 2, 20}, 379 [CHAN_ENUM_4950] = {4950, INVALID_CHANNEL_NUM, 2, 20}, 380 [CHAN_ENUM_4952] = {4952, INVALID_CHANNEL_NUM, 2, 20}, 381 [CHAN_ENUM_4955] = {4955, INVALID_CHANNEL_NUM, 2, 20}, 382 [CHAN_ENUM_4957] = {4957, INVALID_CHANNEL_NUM, 2, 20}, 383 [CHAN_ENUM_4960] = {4960, INVALID_CHANNEL_NUM, 2, 20}, 384 [CHAN_ENUM_4962] = {4962, INVALID_CHANNEL_NUM, 2, 20}, 385 [CHAN_ENUM_4965] = {4965, INVALID_CHANNEL_NUM, 2, 20}, 386 [CHAN_ENUM_4967] = {4967, INVALID_CHANNEL_NUM, 2, 20}, 387 [CHAN_ENUM_4970] = {4970, INVALID_CHANNEL_NUM, 2, 20}, 388 [CHAN_ENUM_4972] = {4972, INVALID_CHANNEL_NUM, 2, 20}, 389 [CHAN_ENUM_4975] = {4975, INVALID_CHANNEL_NUM, 2, 20}, 390 [CHAN_ENUM_4977] = {4977, INVALID_CHANNEL_NUM, 2, 20}, 391 [CHAN_ENUM_4980] = {4980, INVALID_CHANNEL_NUM, 2, 20}, 392 [CHAN_ENUM_4982] = {4982, INVALID_CHANNEL_NUM, 2, 20}, 393 [CHAN_ENUM_4985] = {4985, INVALID_CHANNEL_NUM, 2, 20}, 394 [CHAN_ENUM_4987] = {4987, INVALID_CHANNEL_NUM, 2, 20}, 395 [CHAN_ENUM_5032] = {5032, INVALID_CHANNEL_NUM, 2, 20}, 396 [CHAN_ENUM_5035] = {5035, INVALID_CHANNEL_NUM, 2, 20}, 397 [CHAN_ENUM_5037] = {5037, INVALID_CHANNEL_NUM, 2, 20}, 398 [CHAN_ENUM_5040] = {5040, INVALID_CHANNEL_NUM, 2, 20}, 399 [CHAN_ENUM_5042] = {5042, INVALID_CHANNEL_NUM, 2, 20}, 400 [CHAN_ENUM_5045] = {5045, INVALID_CHANNEL_NUM, 2, 20}, 401 [CHAN_ENUM_5047] = {5047, INVALID_CHANNEL_NUM, 2, 20}, 402 [CHAN_ENUM_5052] = {5052, INVALID_CHANNEL_NUM, 2, 20}, 403 [CHAN_ENUM_5055] = {5055, INVALID_CHANNEL_NUM, 2, 20}, 404 [CHAN_ENUM_5057] = {5057, INVALID_CHANNEL_NUM, 2, 20}, 405 [CHAN_ENUM_5060] = {5060, INVALID_CHANNEL_NUM, 2, 20}, 406 [CHAN_ENUM_5080] = {5080, INVALID_CHANNEL_NUM, 2, 20}, 407 #endif /* CONFIG_49GHZ_CHAN */ 408 [CHAN_ENUM_5180] = {5180, 36, 2, 160}, 409 [CHAN_ENUM_5200] = {5200, 40, 2, 160}, 410 [CHAN_ENUM_5220] = {5220, 44, 2, 160}, 411 [CHAN_ENUM_5240] = {5240, 48, 2, 160}, 412 [CHAN_ENUM_5260] = {5260, 52, 2, 160}, 413 [CHAN_ENUM_5280] = {5280, 56, 2, 160}, 414 [CHAN_ENUM_5300] = {5300, 60, 2, 160}, 415 [CHAN_ENUM_5320] = {5320, 64, 2, 160}, 416 [CHAN_ENUM_5500] = {5500, 100, 2, 160}, 417 [CHAN_ENUM_5520] = {5520, 104, 2, 160}, 418 [CHAN_ENUM_5540] = {5540, 108, 2, 160}, 419 [CHAN_ENUM_5560] = {5560, 112, 2, 160}, 420 [CHAN_ENUM_5580] = {5580, 116, 2, 160}, 421 [CHAN_ENUM_5600] = {5600, 120, 2, 160}, 422 [CHAN_ENUM_5620] = {5620, 124, 2, 160}, 423 [CHAN_ENUM_5640] = {5640, 128, 2, 160}, 424 [CHAN_ENUM_5660] = {5660, 132, 2, 160}, 425 [CHAN_ENUM_5680] = {5680, 136, 2, 160}, 426 [CHAN_ENUM_5700] = {5700, 140, 2, 160}, 427 [CHAN_ENUM_5720] = {5720, 144, 2, 160}, 428 [CHAN_ENUM_5745] = {5745, 149, 2, 160}, 429 [CHAN_ENUM_5765] = {5765, 153, 2, 160}, 430 [CHAN_ENUM_5785] = {5785, 157, 2, 160}, 431 [CHAN_ENUM_5805] = {5805, 161, 2, 160}, 432 [CHAN_ENUM_5825] = {5825, 165, 2, 160}, 433 [CHAN_ENUM_5845] = {5845, 169, 2, 160}, 434 #ifdef WLAN_FEATURE_DSRC 435 [CHAN_ENUM_5850] = {5850, INVALID_CHANNEL_NUM, 2, 160}, 436 [CHAN_ENUM_5855] = {5855, INVALID_CHANNEL_NUM, 2, 160}, 437 [CHAN_ENUM_5860] = {5860, INVALID_CHANNEL_NUM, 2, 160}, 438 #endif 439 [CHAN_ENUM_5865] = {5865, 173, 2, 160}, 440 #ifdef WLAN_FEATURE_DSRC 441 [CHAN_ENUM_5870] = {5870, INVALID_CHANNEL_NUM, 2, 160}, 442 [CHAN_ENUM_5875] = {5875, 175, 2, 160}, 443 [CHAN_ENUM_5880] = {5880, 176, 2, 160}, 444 #endif 445 [CHAN_ENUM_5885] = {5885, 177, 2, 160}, 446 #ifdef WLAN_FEATURE_DSRC 447 [CHAN_ENUM_5890] = {5890, 178, 2, 160}, 448 [CHAN_ENUM_5895] = {5895, 179, 2, 160}, 449 [CHAN_ENUM_5900] = {5900, 180, 2, 160}, 450 [CHAN_ENUM_5905] = {5905, 181, 2, 160}, 451 [CHAN_ENUM_5910] = {5910, 182, 2, 160}, 452 [CHAN_ENUM_5915] = {5915, 183, 2, 160}, 453 [CHAN_ENUM_5920] = {5920, 184, 2, 160}, 454 #endif /* WLAN_FEATURE_DSRC */ 455 #ifdef CONFIG_BAND_6GHZ 456 [CHAN_ENUM_5935] = {5935, 2, 2, 20}, 457 [CHAN_ENUM_5955] = {5955, 1, 2, 160}, 458 [CHAN_ENUM_5975] = {5975, 5, 2, 160}, 459 [CHAN_ENUM_5995] = {5995, 9, 2, 160}, 460 [CHAN_ENUM_6015] = {6015, 13, 2, 160}, 461 [CHAN_ENUM_6035] = {6035, 17, 2, 160}, 462 [CHAN_ENUM_6055] = {6055, 21, 2, 160}, 463 [CHAN_ENUM_6075] = {6075, 25, 2, 160}, 464 [CHAN_ENUM_6095] = {6095, 29, 2, 160}, 465 [CHAN_ENUM_6115] = {6115, 33, 2, 160}, 466 [CHAN_ENUM_6135] = {6135, 37, 2, 160}, 467 [CHAN_ENUM_6155] = {6155, 41, 2, 160}, 468 [CHAN_ENUM_6175] = {6175, 45, 2, 160}, 469 [CHAN_ENUM_6195] = {6195, 49, 2, 160}, 470 [CHAN_ENUM_6215] = {6215, 53, 2, 160}, 471 [CHAN_ENUM_6235] = {6235, 57, 2, 160}, 472 [CHAN_ENUM_6255] = {6255, 61, 2, 160}, 473 [CHAN_ENUM_6275] = {6275, 65, 2, 160}, 474 [CHAN_ENUM_6295] = {6295, 69, 2, 160}, 475 [CHAN_ENUM_6315] = {6315, 73, 2, 160}, 476 [CHAN_ENUM_6335] = {6335, 77, 2, 160}, 477 [CHAN_ENUM_6355] = {6355, 81, 2, 160}, 478 [CHAN_ENUM_6375] = {6375, 85, 2, 160}, 479 [CHAN_ENUM_6395] = {6395, 89, 2, 160}, 480 [CHAN_ENUM_6415] = {6415, 93, 2, 160}, 481 [CHAN_ENUM_6435] = {6435, 97, 2, 160}, 482 [CHAN_ENUM_6455] = {6455, 101, 2, 160}, 483 [CHAN_ENUM_6475] = {6475, 105, 2, 160}, 484 [CHAN_ENUM_6495] = {6495, 109, 2, 160}, 485 [CHAN_ENUM_6515] = {6515, 113, 2, 160}, 486 [CHAN_ENUM_6535] = {6535, 117, 2, 160}, 487 [CHAN_ENUM_6555] = {6555, 121, 2, 160}, 488 [CHAN_ENUM_6575] = {6575, 125, 2, 160}, 489 [CHAN_ENUM_6595] = {6595, 129, 2, 160}, 490 [CHAN_ENUM_6615] = {6615, 133, 2, 160}, 491 [CHAN_ENUM_6635] = {6635, 137, 2, 160}, 492 [CHAN_ENUM_6655] = {6655, 141, 2, 160}, 493 [CHAN_ENUM_6675] = {6675, 145, 2, 160}, 494 [CHAN_ENUM_6695] = {6695, 149, 2, 160}, 495 [CHAN_ENUM_6715] = {6715, 153, 2, 160}, 496 [CHAN_ENUM_6735] = {6735, 157, 2, 160}, 497 [CHAN_ENUM_6755] = {6755, 161, 2, 160}, 498 [CHAN_ENUM_6775] = {6775, 165, 2, 160}, 499 [CHAN_ENUM_6795] = {6795, 169, 2, 160}, 500 [CHAN_ENUM_6815] = {6815, 173, 2, 160}, 501 [CHAN_ENUM_6835] = {6835, 177, 2, 160}, 502 [CHAN_ENUM_6855] = {6855, 181, 2, 160}, 503 [CHAN_ENUM_6875] = {6875, 185, 2, 160}, 504 [CHAN_ENUM_6895] = {6895, 189, 2, 160}, 505 [CHAN_ENUM_6915] = {6915, 193, 2, 160}, 506 [CHAN_ENUM_6935] = {6935, 197, 2, 160}, 507 [CHAN_ENUM_6955] = {6955, 201, 2, 160}, 508 [CHAN_ENUM_6975] = {6975, 205, 2, 160}, 509 [CHAN_ENUM_6995] = {6995, 209, 2, 160}, 510 [CHAN_ENUM_7015] = {7015, 213, 2, 160}, 511 [CHAN_ENUM_7035] = {7035, 217, 2, 160}, 512 [CHAN_ENUM_7055] = {7055, 221, 2, 160}, 513 [CHAN_ENUM_7075] = {7075, 225, 2, 160}, 514 [CHAN_ENUM_7095] = {7095, 229, 2, 160}, 515 [CHAN_ENUM_7115] = {7115, 233, 2, 160} 516 #endif /* CONFIG_BAND_6GHZ */ 517 }; 518 519 const struct chan_map channel_map_jp[NUM_CHANNELS] = { 520 [CHAN_ENUM_2412] = {2412, 1, 20, 40}, 521 [CHAN_ENUM_2417] = {2417, 2, 20, 40}, 522 [CHAN_ENUM_2422] = {2422, 3, 20, 40}, 523 [CHAN_ENUM_2427] = {2427, 4, 20, 40}, 524 [CHAN_ENUM_2432] = {2432, 5, 20, 40}, 525 [CHAN_ENUM_2437] = {2437, 6, 20, 40}, 526 [CHAN_ENUM_2442] = {2442, 7, 20, 40}, 527 [CHAN_ENUM_2447] = {2447, 8, 20, 40}, 528 [CHAN_ENUM_2452] = {2452, 9, 20, 40}, 529 [CHAN_ENUM_2457] = {2457, 10, 20, 40}, 530 [CHAN_ENUM_2462] = {2462, 11, 20, 40}, 531 [CHAN_ENUM_2467] = {2467, 12, 20, 40}, 532 [CHAN_ENUM_2472] = {2472, 13, 20, 40}, 533 [CHAN_ENUM_2484] = {2484, 14, 20, 20}, 534 #ifdef CONFIG_49GHZ_CHAN 535 [CHAN_ENUM_4912] = {4912, 182, 5, 5}, 536 [CHAN_ENUM_4915] = {4915, 183, 10, 10}, 537 [CHAN_ENUM_4917] = {4917, 183, 5, 5}, 538 [CHAN_ENUM_4920] = {4920, 184, 10, 20}, 539 [CHAN_ENUM_4922] = {4922, 184, 5, 5}, 540 [CHAN_ENUM_4925] = {4925, 185, 10, 10}, 541 [CHAN_ENUM_4927] = {4927, 185, 5, 5}, 542 [CHAN_ENUM_4932] = {4932, 186, 5, 5}, 543 [CHAN_ENUM_4935] = {4935, 187, 10, 10}, 544 [CHAN_ENUM_4937] = {4937, 187, 5, 5}, 545 [CHAN_ENUM_4940] = {4940, 188, 10, 20}, 546 [CHAN_ENUM_4942] = {4942, 188, 5, 5}, 547 [CHAN_ENUM_4945] = {4945, 189, 10, 10}, 548 [CHAN_ENUM_4947] = {4947, 189, 5, 5}, 549 [CHAN_ENUM_4950] = {4950, INVALID_CHANNEL_NUM, 2, 20}, 550 [CHAN_ENUM_4952] = {4952, INVALID_CHANNEL_NUM, 2, 20}, 551 [CHAN_ENUM_4955] = {4955, INVALID_CHANNEL_NUM, 2, 20}, 552 [CHAN_ENUM_4957] = {4957, INVALID_CHANNEL_NUM, 2, 20}, 553 [CHAN_ENUM_4960] = {4960, 192, 20, 20}, 554 [CHAN_ENUM_4962] = {4962, INVALID_CHANNEL_NUM, 2, 20}, 555 [CHAN_ENUM_4965] = {4965, INVALID_CHANNEL_NUM, 2, 20}, 556 [CHAN_ENUM_4967] = {4967, INVALID_CHANNEL_NUM, 2, 20}, 557 [CHAN_ENUM_4970] = {4970, INVALID_CHANNEL_NUM, 2, 20}, 558 [CHAN_ENUM_4972] = {4972, INVALID_CHANNEL_NUM, 2, 20}, 559 [CHAN_ENUM_4975] = {4975, INVALID_CHANNEL_NUM, 2, 20}, 560 [CHAN_ENUM_4977] = {4977, INVALID_CHANNEL_NUM, 2, 20}, 561 [CHAN_ENUM_4980] = {4980, 196, 20, 20}, 562 [CHAN_ENUM_4982] = {4982, INVALID_CHANNEL_NUM, 2, 20}, 563 [CHAN_ENUM_4985] = {4985, INVALID_CHANNEL_NUM, 2, 20}, 564 [CHAN_ENUM_4987] = {4987, INVALID_CHANNEL_NUM, 2, 20}, 565 [CHAN_ENUM_5032] = {5032, 6, 5, 5}, 566 [CHAN_ENUM_5035] = {5035, 7, 10, 10}, 567 [CHAN_ENUM_5037] = {5037, 7, 5, 5}, 568 [CHAN_ENUM_5040] = {5040, 8, 10, 20}, 569 [CHAN_ENUM_5042] = {5042, 8, 5, 5}, 570 [CHAN_ENUM_5045] = {5045, 9, 10, 10}, 571 [CHAN_ENUM_5047] = {5047, 9, 5, 5}, 572 [CHAN_ENUM_5052] = {5052, 10, 5, 5}, 573 [CHAN_ENUM_5055] = {5055, 11, 10, 10}, 574 [CHAN_ENUM_5057] = {5057, 11, 5, 5}, 575 [CHAN_ENUM_5060] = {5060, 12, 20, 20}, 576 [CHAN_ENUM_5080] = {5080, 16, 20, 20}, 577 #endif /* CONFIG_49GHZ_CHAN */ 578 [CHAN_ENUM_5180] = {5180, 36, 2, 160}, 579 [CHAN_ENUM_5200] = {5200, 40, 2, 160}, 580 [CHAN_ENUM_5220] = {5220, 44, 2, 160}, 581 [CHAN_ENUM_5240] = {5240, 48, 2, 160}, 582 [CHAN_ENUM_5260] = {5260, 52, 2, 160}, 583 [CHAN_ENUM_5280] = {5280, 56, 2, 160}, 584 [CHAN_ENUM_5300] = {5300, 60, 2, 160}, 585 [CHAN_ENUM_5320] = {5320, 64, 2, 160}, 586 [CHAN_ENUM_5500] = {5500, 100, 2, 160}, 587 [CHAN_ENUM_5520] = {5520, 104, 2, 160}, 588 [CHAN_ENUM_5540] = {5540, 108, 2, 160}, 589 [CHAN_ENUM_5560] = {5560, 112, 2, 160}, 590 [CHAN_ENUM_5580] = {5580, 116, 2, 160}, 591 [CHAN_ENUM_5600] = {5600, 120, 2, 160}, 592 [CHAN_ENUM_5620] = {5620, 124, 2, 160}, 593 [CHAN_ENUM_5640] = {5640, 128, 2, 160}, 594 [CHAN_ENUM_5660] = {5660, 132, 2, 160}, 595 [CHAN_ENUM_5680] = {5680, 136, 2, 160}, 596 [CHAN_ENUM_5700] = {5700, 140, 2, 160}, 597 [CHAN_ENUM_5720] = {5720, 144, 2, 160}, 598 [CHAN_ENUM_5745] = {5745, 149, 2, 160}, 599 [CHAN_ENUM_5765] = {5765, 153, 2, 160}, 600 [CHAN_ENUM_5785] = {5785, 157, 2, 160}, 601 [CHAN_ENUM_5805] = {5805, 161, 2, 160}, 602 [CHAN_ENUM_5825] = {5825, 165, 2, 160}, 603 [CHAN_ENUM_5845] = {5845, 169, 2, 160}, 604 #ifdef WLAN_FEATURE_DSRC 605 [CHAN_ENUM_5850] = {5850, INVALID_CHANNEL_NUM, 2, 160}, 606 [CHAN_ENUM_5855] = {5855, INVALID_CHANNEL_NUM, 2, 160}, 607 [CHAN_ENUM_5860] = {5860, INVALID_CHANNEL_NUM, 2, 160}, 608 #endif 609 [CHAN_ENUM_5865] = {5865, INVALID_CHANNEL_NUM, 2, 160}, 610 #ifdef WLAN_FEATURE_DSRC 611 [CHAN_ENUM_5870] = {5870, INVALID_CHANNEL_NUM, 2, 160}, 612 [CHAN_ENUM_5875] = {5875, INVALID_CHANNEL_NUM, 2, 160}, 613 [CHAN_ENUM_5880] = {5880, INVALID_CHANNEL_NUM, 2, 160}, 614 #endif 615 [CHAN_ENUM_5885] = {5885, INVALID_CHANNEL_NUM, 2, 160}, 616 #ifdef WLAN_FEATURE_DSRC 617 [CHAN_ENUM_5890] = {5890, INVALID_CHANNEL_NUM, 2, 160}, 618 [CHAN_ENUM_5895] = {5895, INVALID_CHANNEL_NUM, 2, 160}, 619 [CHAN_ENUM_5900] = {5900, INVALID_CHANNEL_NUM, 2, 160}, 620 [CHAN_ENUM_5905] = {5905, INVALID_CHANNEL_NUM, 2, 160}, 621 [CHAN_ENUM_5910] = {5910, INVALID_CHANNEL_NUM, 2, 160}, 622 [CHAN_ENUM_5915] = {5915, INVALID_CHANNEL_NUM, 2, 160}, 623 [CHAN_ENUM_5920] = {5920, INVALID_CHANNEL_NUM, 2, 160}, 624 #endif /* WLAN_FEATURE_DSRC */ 625 #ifdef CONFIG_BAND_6GHZ 626 [CHAN_ENUM_5935] = {5935, 2, 2, 20}, 627 [CHAN_ENUM_5955] = {5955, 1, 2, 160}, 628 [CHAN_ENUM_5975] = {5975, 5, 2, 160}, 629 [CHAN_ENUM_5995] = {5995, 9, 2, 160}, 630 [CHAN_ENUM_6015] = {6015, 13, 2, 160}, 631 [CHAN_ENUM_6035] = {6035, 17, 2, 160}, 632 [CHAN_ENUM_6055] = {6055, 21, 2, 160}, 633 [CHAN_ENUM_6075] = {6075, 25, 2, 160}, 634 [CHAN_ENUM_6095] = {6095, 29, 2, 160}, 635 [CHAN_ENUM_6115] = {6115, 33, 2, 160}, 636 [CHAN_ENUM_6135] = {6135, 37, 2, 160}, 637 [CHAN_ENUM_6155] = {6155, 41, 2, 160}, 638 [CHAN_ENUM_6175] = {6175, 45, 2, 160}, 639 [CHAN_ENUM_6195] = {6195, 49, 2, 160}, 640 [CHAN_ENUM_6215] = {6215, 53, 2, 160}, 641 [CHAN_ENUM_6235] = {6235, 57, 2, 160}, 642 [CHAN_ENUM_6255] = {6255, 61, 2, 160}, 643 [CHAN_ENUM_6275] = {6275, 65, 2, 160}, 644 [CHAN_ENUM_6295] = {6295, 69, 2, 160}, 645 [CHAN_ENUM_6315] = {6315, 73, 2, 160}, 646 [CHAN_ENUM_6335] = {6335, 77, 2, 160}, 647 [CHAN_ENUM_6355] = {6355, 81, 2, 160}, 648 [CHAN_ENUM_6375] = {6375, 85, 2, 160}, 649 [CHAN_ENUM_6395] = {6395, 89, 2, 160}, 650 [CHAN_ENUM_6415] = {6415, 93, 2, 160}, 651 [CHAN_ENUM_6435] = {6435, 97, 2, 160}, 652 [CHAN_ENUM_6455] = {6455, 101, 2, 160}, 653 [CHAN_ENUM_6475] = {6475, 105, 2, 160}, 654 [CHAN_ENUM_6495] = {6495, 109, 2, 160}, 655 [CHAN_ENUM_6515] = {6515, 113, 2, 160}, 656 [CHAN_ENUM_6535] = {6535, 117, 2, 160}, 657 [CHAN_ENUM_6555] = {6555, 121, 2, 160}, 658 [CHAN_ENUM_6575] = {6575, 125, 2, 160}, 659 [CHAN_ENUM_6595] = {6595, 129, 2, 160}, 660 [CHAN_ENUM_6615] = {6615, 133, 2, 160}, 661 [CHAN_ENUM_6635] = {6635, 137, 2, 160}, 662 [CHAN_ENUM_6655] = {6655, 141, 2, 160}, 663 [CHAN_ENUM_6675] = {6675, 145, 2, 160}, 664 [CHAN_ENUM_6695] = {6695, 149, 2, 160}, 665 [CHAN_ENUM_6715] = {6715, 153, 2, 160}, 666 [CHAN_ENUM_6735] = {6735, 157, 2, 160}, 667 [CHAN_ENUM_6755] = {6755, 161, 2, 160}, 668 [CHAN_ENUM_6775] = {6775, 165, 2, 160}, 669 [CHAN_ENUM_6795] = {6795, 169, 2, 160}, 670 [CHAN_ENUM_6815] = {6815, 173, 2, 160}, 671 [CHAN_ENUM_6835] = {6835, 177, 2, 160}, 672 [CHAN_ENUM_6855] = {6855, 181, 2, 160}, 673 [CHAN_ENUM_6875] = {6875, 185, 2, 160}, 674 [CHAN_ENUM_6895] = {6895, 189, 2, 160}, 675 [CHAN_ENUM_6915] = {6915, 193, 2, 160}, 676 [CHAN_ENUM_6935] = {6935, 197, 2, 160}, 677 [CHAN_ENUM_6955] = {6955, 201, 2, 160}, 678 [CHAN_ENUM_6975] = {6975, 205, 2, 160}, 679 [CHAN_ENUM_6995] = {6995, 209, 2, 160}, 680 [CHAN_ENUM_7015] = {7015, 213, 2, 160}, 681 [CHAN_ENUM_7035] = {7035, 217, 2, 160}, 682 [CHAN_ENUM_7055] = {7055, 221, 2, 160}, 683 [CHAN_ENUM_7075] = {7075, 225, 2, 160}, 684 [CHAN_ENUM_7095] = {7095, 229, 2, 160}, 685 [CHAN_ENUM_7115] = {7115, 233, 2, 160} 686 #endif /* CONFIG_BAND_6GHZ */ 687 }; 688 689 const struct chan_map channel_map_global[NUM_CHANNELS] = { 690 [CHAN_ENUM_2412] = {2412, 1, 20, 40}, 691 [CHAN_ENUM_2417] = {2417, 2, 20, 40}, 692 [CHAN_ENUM_2422] = {2422, 3, 20, 40}, 693 [CHAN_ENUM_2427] = {2427, 4, 20, 40}, 694 [CHAN_ENUM_2432] = {2432, 5, 20, 40}, 695 [CHAN_ENUM_2437] = {2437, 6, 20, 40}, 696 [CHAN_ENUM_2442] = {2442, 7, 20, 40}, 697 [CHAN_ENUM_2447] = {2447, 8, 20, 40}, 698 [CHAN_ENUM_2452] = {2452, 9, 20, 40}, 699 [CHAN_ENUM_2457] = {2457, 10, 20, 40}, 700 [CHAN_ENUM_2462] = {2462, 11, 20, 40}, 701 [CHAN_ENUM_2467] = {2467, 12, 20, 40}, 702 [CHAN_ENUM_2472] = {2472, 13, 20, 40}, 703 [CHAN_ENUM_2484] = {2484, 14, 20, 20}, 704 #ifdef CONFIG_49GHZ_CHAN 705 [CHAN_ENUM_4912] = {4912, INVALID_CHANNEL_NUM, 2, 20}, 706 [CHAN_ENUM_4915] = {4915, INVALID_CHANNEL_NUM, 2, 20}, 707 [CHAN_ENUM_4917] = {4917, INVALID_CHANNEL_NUM, 2, 20}, 708 [CHAN_ENUM_4920] = {4920, INVALID_CHANNEL_NUM, 2, 20}, 709 [CHAN_ENUM_4922] = {4922, INVALID_CHANNEL_NUM, 2, 20}, 710 [CHAN_ENUM_4925] = {4925, INVALID_CHANNEL_NUM, 2, 20}, 711 [CHAN_ENUM_4927] = {4927, INVALID_CHANNEL_NUM, 2, 20}, 712 [CHAN_ENUM_4932] = {4932, INVALID_CHANNEL_NUM, 2, 20}, 713 [CHAN_ENUM_4935] = {4935, INVALID_CHANNEL_NUM, 2, 20}, 714 [CHAN_ENUM_4937] = {4937, INVALID_CHANNEL_NUM, 2, 20}, 715 [CHAN_ENUM_4940] = {4940, INVALID_CHANNEL_NUM, 2, 20}, 716 [CHAN_ENUM_4942] = {4942, INVALID_CHANNEL_NUM, 2, 20}, 717 [CHAN_ENUM_4945] = {4945, INVALID_CHANNEL_NUM, 2, 20}, 718 [CHAN_ENUM_4947] = {4947, INVALID_CHANNEL_NUM, 2, 20}, 719 [CHAN_ENUM_4950] = {4950, INVALID_CHANNEL_NUM, 2, 20}, 720 [CHAN_ENUM_4952] = {4952, INVALID_CHANNEL_NUM, 2, 20}, 721 [CHAN_ENUM_4955] = {4955, INVALID_CHANNEL_NUM, 2, 20}, 722 [CHAN_ENUM_4957] = {4957, INVALID_CHANNEL_NUM, 2, 20}, 723 [CHAN_ENUM_4960] = {4960, INVALID_CHANNEL_NUM, 2, 20}, 724 [CHAN_ENUM_4962] = {4962, INVALID_CHANNEL_NUM, 2, 20}, 725 [CHAN_ENUM_4965] = {4965, INVALID_CHANNEL_NUM, 2, 20}, 726 [CHAN_ENUM_4967] = {4967, INVALID_CHANNEL_NUM, 2, 20}, 727 [CHAN_ENUM_4970] = {4970, INVALID_CHANNEL_NUM, 2, 20}, 728 [CHAN_ENUM_4972] = {4972, INVALID_CHANNEL_NUM, 2, 20}, 729 [CHAN_ENUM_4975] = {4975, INVALID_CHANNEL_NUM, 2, 20}, 730 [CHAN_ENUM_4977] = {4977, INVALID_CHANNEL_NUM, 2, 20}, 731 [CHAN_ENUM_4980] = {4980, INVALID_CHANNEL_NUM, 2, 20}, 732 [CHAN_ENUM_4982] = {4982, INVALID_CHANNEL_NUM, 2, 20}, 733 [CHAN_ENUM_4985] = {4985, INVALID_CHANNEL_NUM, 2, 20}, 734 [CHAN_ENUM_4987] = {4987, INVALID_CHANNEL_NUM, 2, 20}, 735 [CHAN_ENUM_5032] = {5032, INVALID_CHANNEL_NUM, 2, 20}, 736 [CHAN_ENUM_5035] = {5035, INVALID_CHANNEL_NUM, 2, 20}, 737 [CHAN_ENUM_5037] = {5037, INVALID_CHANNEL_NUM, 2, 20}, 738 [CHAN_ENUM_5040] = {5040, INVALID_CHANNEL_NUM, 2, 20}, 739 [CHAN_ENUM_5042] = {5042, INVALID_CHANNEL_NUM, 2, 20}, 740 [CHAN_ENUM_5045] = {5045, INVALID_CHANNEL_NUM, 2, 20}, 741 [CHAN_ENUM_5047] = {5047, INVALID_CHANNEL_NUM, 2, 20}, 742 [CHAN_ENUM_5052] = {5052, INVALID_CHANNEL_NUM, 2, 20}, 743 [CHAN_ENUM_5055] = {5055, INVALID_CHANNEL_NUM, 2, 20}, 744 [CHAN_ENUM_5057] = {5057, INVALID_CHANNEL_NUM, 2, 20}, 745 [CHAN_ENUM_5060] = {5060, INVALID_CHANNEL_NUM, 2, 20}, 746 [CHAN_ENUM_5080] = {5080, INVALID_CHANNEL_NUM, 2, 20}, 747 #endif /* CONFIG_49GHZ_CHAN */ 748 [CHAN_ENUM_5180] = {5180, 36, 2, 160}, 749 [CHAN_ENUM_5200] = {5200, 40, 2, 160}, 750 [CHAN_ENUM_5220] = {5220, 44, 2, 160}, 751 [CHAN_ENUM_5240] = {5240, 48, 2, 160}, 752 [CHAN_ENUM_5260] = {5260, 52, 2, 160}, 753 [CHAN_ENUM_5280] = {5280, 56, 2, 160}, 754 [CHAN_ENUM_5300] = {5300, 60, 2, 160}, 755 [CHAN_ENUM_5320] = {5320, 64, 2, 160}, 756 [CHAN_ENUM_5500] = {5500, 100, 2, 160}, 757 [CHAN_ENUM_5520] = {5520, 104, 2, 160}, 758 [CHAN_ENUM_5540] = {5540, 108, 2, 160}, 759 [CHAN_ENUM_5560] = {5560, 112, 2, 160}, 760 [CHAN_ENUM_5580] = {5580, 116, 2, 160}, 761 [CHAN_ENUM_5600] = {5600, 120, 2, 160}, 762 [CHAN_ENUM_5620] = {5620, 124, 2, 160}, 763 [CHAN_ENUM_5640] = {5640, 128, 2, 160}, 764 [CHAN_ENUM_5660] = {5660, 132, 2, 160}, 765 [CHAN_ENUM_5680] = {5680, 136, 2, 160}, 766 [CHAN_ENUM_5700] = {5700, 140, 2, 160}, 767 [CHAN_ENUM_5720] = {5720, 144, 2, 160}, 768 [CHAN_ENUM_5745] = {5745, 149, 2, 160}, 769 [CHAN_ENUM_5765] = {5765, 153, 2, 160}, 770 [CHAN_ENUM_5785] = {5785, 157, 2, 160}, 771 [CHAN_ENUM_5805] = {5805, 161, 2, 160}, 772 [CHAN_ENUM_5825] = {5825, 165, 2, 160}, 773 [CHAN_ENUM_5845] = {5845, 169, 2, 160}, 774 #ifdef WLAN_FEATURE_DSRC 775 [CHAN_ENUM_5850] = {5850, INVALID_CHANNEL_NUM, 2, 160}, 776 [CHAN_ENUM_5855] = {5855, INVALID_CHANNEL_NUM, 2, 160}, 777 [CHAN_ENUM_5860] = {5860, INVALID_CHANNEL_NUM, 2, 160}, 778 #endif 779 [CHAN_ENUM_5865] = {5865, 173, 2, 160}, 780 #ifdef WLAN_FEATURE_DSRC 781 [CHAN_ENUM_5870] = {5870, INVALID_CHANNEL_NUM, 2, 160}, 782 [CHAN_ENUM_5875] = {5875, INVALID_CHANNEL_NUM, 2, 160}, 783 [CHAN_ENUM_5880] = {5880, INVALID_CHANNEL_NUM, 2, 160}, 784 #endif 785 [CHAN_ENUM_5885] = {5885, INVALID_CHANNEL_NUM, 2, 160}, 786 #ifdef WLAN_FEATURE_DSRC 787 [CHAN_ENUM_5890] = {5890, INVALID_CHANNEL_NUM, 2, 160}, 788 [CHAN_ENUM_5895] = {5895, INVALID_CHANNEL_NUM, 2, 160}, 789 [CHAN_ENUM_5900] = {5900, INVALID_CHANNEL_NUM, 2, 160}, 790 [CHAN_ENUM_5905] = {5905, INVALID_CHANNEL_NUM, 2, 160}, 791 [CHAN_ENUM_5910] = {5910, INVALID_CHANNEL_NUM, 2, 160}, 792 [CHAN_ENUM_5915] = {5915, INVALID_CHANNEL_NUM, 2, 160}, 793 [CHAN_ENUM_5920] = {5920, INVALID_CHANNEL_NUM, 2, 160}, 794 #endif /* WLAN_FEATURE_DSRC */ 795 #ifdef CONFIG_BAND_6GHZ 796 [CHAN_ENUM_5935] = {5935, 2, 2, 20}, 797 [CHAN_ENUM_5955] = {5955, 1, 2, 160}, 798 [CHAN_ENUM_5975] = {5975, 5, 2, 160}, 799 [CHAN_ENUM_5995] = {5995, 9, 2, 160}, 800 [CHAN_ENUM_6015] = {6015, 13, 2, 160}, 801 [CHAN_ENUM_6035] = {6035, 17, 2, 160}, 802 [CHAN_ENUM_6055] = {6055, 21, 2, 160}, 803 [CHAN_ENUM_6075] = {6075, 25, 2, 160}, 804 [CHAN_ENUM_6095] = {6095, 29, 2, 160}, 805 [CHAN_ENUM_6115] = {6115, 33, 2, 160}, 806 [CHAN_ENUM_6135] = {6135, 37, 2, 160}, 807 [CHAN_ENUM_6155] = {6155, 41, 2, 160}, 808 [CHAN_ENUM_6175] = {6175, 45, 2, 160}, 809 [CHAN_ENUM_6195] = {6195, 49, 2, 160}, 810 [CHAN_ENUM_6215] = {6215, 53, 2, 160}, 811 [CHAN_ENUM_6235] = {6235, 57, 2, 160}, 812 [CHAN_ENUM_6255] = {6255, 61, 2, 160}, 813 [CHAN_ENUM_6275] = {6275, 65, 2, 160}, 814 [CHAN_ENUM_6295] = {6295, 69, 2, 160}, 815 [CHAN_ENUM_6315] = {6315, 73, 2, 160}, 816 [CHAN_ENUM_6335] = {6335, 77, 2, 160}, 817 [CHAN_ENUM_6355] = {6355, 81, 2, 160}, 818 [CHAN_ENUM_6375] = {6375, 85, 2, 160}, 819 [CHAN_ENUM_6395] = {6395, 89, 2, 160}, 820 [CHAN_ENUM_6415] = {6415, 93, 2, 160}, 821 [CHAN_ENUM_6435] = {6435, 97, 2, 160}, 822 [CHAN_ENUM_6455] = {6455, 101, 2, 160}, 823 [CHAN_ENUM_6475] = {6475, 105, 2, 160}, 824 [CHAN_ENUM_6495] = {6495, 109, 2, 160}, 825 [CHAN_ENUM_6515] = {6515, 113, 2, 160}, 826 [CHAN_ENUM_6535] = {6535, 117, 2, 160}, 827 [CHAN_ENUM_6555] = {6555, 121, 2, 160}, 828 [CHAN_ENUM_6575] = {6575, 125, 2, 160}, 829 [CHAN_ENUM_6595] = {6595, 129, 2, 160}, 830 [CHAN_ENUM_6615] = {6615, 133, 2, 160}, 831 [CHAN_ENUM_6635] = {6635, 137, 2, 160}, 832 [CHAN_ENUM_6655] = {6655, 141, 2, 160}, 833 [CHAN_ENUM_6675] = {6675, 145, 2, 160}, 834 [CHAN_ENUM_6695] = {6695, 149, 2, 160}, 835 [CHAN_ENUM_6715] = {6715, 153, 2, 160}, 836 [CHAN_ENUM_6735] = {6735, 157, 2, 160}, 837 [CHAN_ENUM_6755] = {6755, 161, 2, 160}, 838 [CHAN_ENUM_6775] = {6775, 165, 2, 160}, 839 [CHAN_ENUM_6795] = {6795, 169, 2, 160}, 840 [CHAN_ENUM_6815] = {6815, 173, 2, 160}, 841 [CHAN_ENUM_6835] = {6835, 177, 2, 160}, 842 [CHAN_ENUM_6855] = {6855, 181, 2, 160}, 843 [CHAN_ENUM_6875] = {6875, 185, 2, 160}, 844 [CHAN_ENUM_6895] = {6895, 189, 2, 160}, 845 [CHAN_ENUM_6915] = {6915, 193, 2, 160}, 846 [CHAN_ENUM_6935] = {6935, 197, 2, 160}, 847 [CHAN_ENUM_6955] = {6955, 201, 2, 160}, 848 [CHAN_ENUM_6975] = {6975, 205, 2, 160}, 849 [CHAN_ENUM_6995] = {6995, 209, 2, 160}, 850 [CHAN_ENUM_7015] = {7015, 213, 2, 160}, 851 [CHAN_ENUM_7035] = {7035, 217, 2, 160}, 852 [CHAN_ENUM_7055] = {7055, 221, 2, 160}, 853 [CHAN_ENUM_7075] = {7075, 225, 2, 160}, 854 [CHAN_ENUM_7095] = {7095, 229, 2, 160}, 855 [CHAN_ENUM_7115] = {7115, 233, 2, 160} 856 #endif /* CONFIG_BAND_6GHZ */ 857 }; 858 859 const struct chan_map channel_map_china[NUM_CHANNELS] = { 860 [CHAN_ENUM_2412] = {2412, 1, 20, 40}, 861 [CHAN_ENUM_2417] = {2417, 2, 20, 40}, 862 [CHAN_ENUM_2422] = {2422, 3, 20, 40}, 863 [CHAN_ENUM_2427] = {2427, 4, 20, 40}, 864 [CHAN_ENUM_2432] = {2432, 5, 20, 40}, 865 [CHAN_ENUM_2437] = {2437, 6, 20, 40}, 866 [CHAN_ENUM_2442] = {2442, 7, 20, 40}, 867 [CHAN_ENUM_2447] = {2447, 8, 20, 40}, 868 [CHAN_ENUM_2452] = {2452, 9, 20, 40}, 869 [CHAN_ENUM_2457] = {2457, 10, 20, 40}, 870 [CHAN_ENUM_2462] = {2462, 11, 20, 40}, 871 [CHAN_ENUM_2467] = {2467, 12, 20, 40}, 872 [CHAN_ENUM_2472] = {2472, 13, 20, 40}, 873 [CHAN_ENUM_2484] = {2484, 14, 20, 20}, 874 #ifdef CONFIG_49GHZ_CHAN 875 [CHAN_ENUM_4912] = {4912, INVALID_CHANNEL_NUM, 2, 20}, 876 [CHAN_ENUM_4915] = {4915, INVALID_CHANNEL_NUM, 2, 20}, 877 [CHAN_ENUM_4917] = {4917, INVALID_CHANNEL_NUM, 2, 20}, 878 [CHAN_ENUM_4920] = {4920, INVALID_CHANNEL_NUM, 2, 20}, 879 [CHAN_ENUM_4922] = {4922, INVALID_CHANNEL_NUM, 2, 20}, 880 [CHAN_ENUM_4925] = {4925, INVALID_CHANNEL_NUM, 2, 20}, 881 [CHAN_ENUM_4927] = {4927, INVALID_CHANNEL_NUM, 2, 20}, 882 [CHAN_ENUM_4932] = {4932, INVALID_CHANNEL_NUM, 2, 20}, 883 [CHAN_ENUM_4935] = {4935, INVALID_CHANNEL_NUM, 2, 20}, 884 [CHAN_ENUM_4937] = {4937, INVALID_CHANNEL_NUM, 2, 20}, 885 [CHAN_ENUM_4940] = {4940, INVALID_CHANNEL_NUM, 2, 20}, 886 [CHAN_ENUM_4942] = {4942, INVALID_CHANNEL_NUM, 2, 20}, 887 [CHAN_ENUM_4945] = {4945, INVALID_CHANNEL_NUM, 2, 20}, 888 [CHAN_ENUM_4947] = {4947, INVALID_CHANNEL_NUM, 2, 20}, 889 [CHAN_ENUM_4950] = {4950, INVALID_CHANNEL_NUM, 2, 20}, 890 [CHAN_ENUM_4952] = {4952, INVALID_CHANNEL_NUM, 2, 20}, 891 [CHAN_ENUM_4955] = {4955, INVALID_CHANNEL_NUM, 2, 20}, 892 [CHAN_ENUM_4957] = {4957, INVALID_CHANNEL_NUM, 2, 20}, 893 [CHAN_ENUM_4960] = {4960, INVALID_CHANNEL_NUM, 2, 20}, 894 [CHAN_ENUM_4962] = {4962, INVALID_CHANNEL_NUM, 2, 20}, 895 [CHAN_ENUM_4965] = {4965, INVALID_CHANNEL_NUM, 2, 20}, 896 [CHAN_ENUM_4967] = {4967, INVALID_CHANNEL_NUM, 2, 20}, 897 [CHAN_ENUM_4970] = {4970, INVALID_CHANNEL_NUM, 2, 20}, 898 [CHAN_ENUM_4972] = {4972, INVALID_CHANNEL_NUM, 2, 20}, 899 [CHAN_ENUM_4975] = {4975, INVALID_CHANNEL_NUM, 2, 20}, 900 [CHAN_ENUM_4977] = {4977, INVALID_CHANNEL_NUM, 2, 20}, 901 [CHAN_ENUM_4980] = {4980, INVALID_CHANNEL_NUM, 2, 20}, 902 [CHAN_ENUM_4982] = {4982, INVALID_CHANNEL_NUM, 2, 20}, 903 [CHAN_ENUM_4985] = {4985, INVALID_CHANNEL_NUM, 2, 20}, 904 [CHAN_ENUM_4987] = {4987, INVALID_CHANNEL_NUM, 2, 20}, 905 [CHAN_ENUM_5032] = {5032, INVALID_CHANNEL_NUM, 2, 20}, 906 [CHAN_ENUM_5035] = {5035, INVALID_CHANNEL_NUM, 2, 20}, 907 [CHAN_ENUM_5037] = {5037, INVALID_CHANNEL_NUM, 2, 20}, 908 [CHAN_ENUM_5040] = {5040, INVALID_CHANNEL_NUM, 2, 20}, 909 [CHAN_ENUM_5042] = {5042, INVALID_CHANNEL_NUM, 2, 20}, 910 [CHAN_ENUM_5045] = {5045, INVALID_CHANNEL_NUM, 2, 20}, 911 [CHAN_ENUM_5047] = {5047, INVALID_CHANNEL_NUM, 2, 20}, 912 [CHAN_ENUM_5052] = {5052, INVALID_CHANNEL_NUM, 2, 20}, 913 [CHAN_ENUM_5055] = {5055, INVALID_CHANNEL_NUM, 2, 20}, 914 [CHAN_ENUM_5057] = {5057, INVALID_CHANNEL_NUM, 2, 20}, 915 [CHAN_ENUM_5060] = {5060, INVALID_CHANNEL_NUM, 2, 20}, 916 [CHAN_ENUM_5080] = {5080, INVALID_CHANNEL_NUM, 2, 20}, 917 #endif /* CONFIG_49GHZ_CHAN */ 918 [CHAN_ENUM_5180] = {5180, 36, 2, 160}, 919 [CHAN_ENUM_5200] = {5200, 40, 2, 160}, 920 [CHAN_ENUM_5220] = {5220, 44, 2, 160}, 921 [CHAN_ENUM_5240] = {5240, 48, 2, 160}, 922 [CHAN_ENUM_5260] = {5260, 52, 2, 160}, 923 [CHAN_ENUM_5280] = {5280, 56, 2, 160}, 924 [CHAN_ENUM_5300] = {5300, 60, 2, 160}, 925 [CHAN_ENUM_5320] = {5320, 64, 2, 160}, 926 [CHAN_ENUM_5500] = {5500, 100, 2, 160}, 927 [CHAN_ENUM_5520] = {5520, 104, 2, 160}, 928 [CHAN_ENUM_5540] = {5540, 108, 2, 160}, 929 [CHAN_ENUM_5560] = {5560, 112, 2, 160}, 930 [CHAN_ENUM_5580] = {5580, 116, 2, 160}, 931 [CHAN_ENUM_5600] = {5600, 120, 2, 160}, 932 [CHAN_ENUM_5620] = {5620, 124, 2, 160}, 933 [CHAN_ENUM_5640] = {5640, 128, 2, 160}, 934 [CHAN_ENUM_5660] = {5660, 132, 2, 160}, 935 [CHAN_ENUM_5680] = {5680, 136, 2, 160}, 936 [CHAN_ENUM_5700] = {5700, 140, 2, 160}, 937 [CHAN_ENUM_5720] = {5720, 144, 2, 160}, 938 [CHAN_ENUM_5745] = {5745, 149, 2, 160}, 939 [CHAN_ENUM_5765] = {5765, 153, 2, 160}, 940 [CHAN_ENUM_5785] = {5785, 157, 2, 160}, 941 [CHAN_ENUM_5805] = {5805, 161, 2, 160}, 942 [CHAN_ENUM_5825] = {5825, 165, 2, 160}, 943 [CHAN_ENUM_5845] = {5845, 169, 2, 160}, 944 #ifdef WLAN_FEATURE_DSRC 945 [CHAN_ENUM_5850] = {5850, INVALID_CHANNEL_NUM, 2, 160}, 946 [CHAN_ENUM_5855] = {5855, INVALID_CHANNEL_NUM, 2, 160}, 947 [CHAN_ENUM_5860] = {5860, INVALID_CHANNEL_NUM, 2, 160}, 948 #endif 949 [CHAN_ENUM_5865] = {5865, INVALID_CHANNEL_NUM, 2, 160}, 950 #ifdef WLAN_FEATURE_DSRC 951 [CHAN_ENUM_5870] = {5870, INVALID_CHANNEL_NUM, 2, 160}, 952 [CHAN_ENUM_5875] = {5875, INVALID_CHANNEL_NUM, 2, 160}, 953 [CHAN_ENUM_5880] = {5880, INVALID_CHANNEL_NUM, 2, 160}, 954 #endif 955 [CHAN_ENUM_5885] = {5885, INVALID_CHANNEL_NUM, 2, 160}, 956 #ifdef WLAN_FEATURE_DSRC 957 [CHAN_ENUM_5890] = {5890, INVALID_CHANNEL_NUM, 2, 160}, 958 [CHAN_ENUM_5895] = {5895, INVALID_CHANNEL_NUM, 2, 160}, 959 [CHAN_ENUM_5900] = {5900, INVALID_CHANNEL_NUM, 2, 160}, 960 [CHAN_ENUM_5905] = {5905, INVALID_CHANNEL_NUM, 2, 160}, 961 [CHAN_ENUM_5910] = {5910, INVALID_CHANNEL_NUM, 2, 160}, 962 [CHAN_ENUM_5915] = {5915, INVALID_CHANNEL_NUM, 2, 160}, 963 [CHAN_ENUM_5920] = {5920, INVALID_CHANNEL_NUM, 2, 160}, 964 #endif /* WLAN_FEATURE_DSRC */ 965 #ifdef CONFIG_BAND_6GHZ 966 [CHAN_ENUM_5935] = {5935, 2, 2, 20}, 967 [CHAN_ENUM_5955] = {5955, 1, 2, 160}, 968 [CHAN_ENUM_5975] = {5975, 5, 2, 160}, 969 [CHAN_ENUM_5995] = {5995, 9, 2, 160}, 970 [CHAN_ENUM_6015] = {6015, 13, 2, 160}, 971 [CHAN_ENUM_6035] = {6035, 17, 2, 160}, 972 [CHAN_ENUM_6055] = {6055, 21, 2, 160}, 973 [CHAN_ENUM_6075] = {6075, 25, 2, 160}, 974 [CHAN_ENUM_6095] = {6095, 29, 2, 160}, 975 [CHAN_ENUM_6115] = {6115, 33, 2, 160}, 976 [CHAN_ENUM_6135] = {6135, 37, 2, 160}, 977 [CHAN_ENUM_6155] = {6155, 41, 2, 160}, 978 [CHAN_ENUM_6175] = {6175, 45, 2, 160}, 979 [CHAN_ENUM_6195] = {6195, 49, 2, 160}, 980 [CHAN_ENUM_6215] = {6215, 53, 2, 160}, 981 [CHAN_ENUM_6235] = {6235, 57, 2, 160}, 982 [CHAN_ENUM_6255] = {6255, 61, 2, 160}, 983 [CHAN_ENUM_6275] = {6275, 65, 2, 160}, 984 [CHAN_ENUM_6295] = {6295, 69, 2, 160}, 985 [CHAN_ENUM_6315] = {6315, 73, 2, 160}, 986 [CHAN_ENUM_6335] = {6335, 77, 2, 160}, 987 [CHAN_ENUM_6355] = {6355, 81, 2, 160}, 988 [CHAN_ENUM_6375] = {6375, 85, 2, 160}, 989 [CHAN_ENUM_6395] = {6395, 89, 2, 160}, 990 [CHAN_ENUM_6415] = {6415, 93, 2, 160}, 991 [CHAN_ENUM_6435] = {6435, 97, 2, 160}, 992 [CHAN_ENUM_6455] = {6455, 101, 2, 160}, 993 [CHAN_ENUM_6475] = {6475, 105, 2, 160}, 994 [CHAN_ENUM_6495] = {6495, 109, 2, 160}, 995 [CHAN_ENUM_6515] = {6515, 113, 2, 160}, 996 [CHAN_ENUM_6535] = {6535, 117, 2, 160}, 997 [CHAN_ENUM_6555] = {6555, 121, 2, 160}, 998 [CHAN_ENUM_6575] = {6575, 125, 2, 160}, 999 [CHAN_ENUM_6595] = {6595, 129, 2, 160}, 1000 [CHAN_ENUM_6615] = {6615, 133, 2, 160}, 1001 [CHAN_ENUM_6635] = {6635, 137, 2, 160}, 1002 [CHAN_ENUM_6655] = {6655, 141, 2, 160}, 1003 [CHAN_ENUM_6675] = {6675, 145, 2, 160}, 1004 [CHAN_ENUM_6695] = {6695, 149, 2, 160}, 1005 [CHAN_ENUM_6715] = {6715, 153, 2, 160}, 1006 [CHAN_ENUM_6735] = {6735, 157, 2, 160}, 1007 [CHAN_ENUM_6755] = {6755, 161, 2, 160}, 1008 [CHAN_ENUM_6775] = {6775, 165, 2, 160}, 1009 [CHAN_ENUM_6795] = {6795, 169, 2, 160}, 1010 [CHAN_ENUM_6815] = {6815, 173, 2, 160}, 1011 [CHAN_ENUM_6835] = {6835, 177, 2, 160}, 1012 [CHAN_ENUM_6855] = {6855, 181, 2, 160}, 1013 [CHAN_ENUM_6875] = {6875, 185, 2, 160}, 1014 [CHAN_ENUM_6895] = {6895, 189, 2, 160}, 1015 [CHAN_ENUM_6915] = {6915, 193, 2, 160}, 1016 [CHAN_ENUM_6935] = {6935, 197, 2, 160}, 1017 [CHAN_ENUM_6955] = {6955, 201, 2, 160}, 1018 [CHAN_ENUM_6975] = {6975, 205, 2, 160}, 1019 [CHAN_ENUM_6995] = {6995, 209, 2, 160}, 1020 [CHAN_ENUM_7015] = {7015, 213, 2, 160}, 1021 [CHAN_ENUM_7035] = {7035, 217, 2, 160}, 1022 [CHAN_ENUM_7055] = {7055, 221, 2, 160}, 1023 [CHAN_ENUM_7075] = {7075, 225, 2, 160}, 1024 [CHAN_ENUM_7095] = {7095, 229, 2, 160}, 1025 [CHAN_ENUM_7115] = {7115, 233, 2, 160} 1026 #endif /* CONFIG_BAND_6GHZ */ 1027 }; 1028 1029 void reg_init_channel_map(enum dfs_reg dfs_region) 1030 { 1031 switch (dfs_region) { 1032 case DFS_UNINIT_REGION: 1033 case DFS_UNDEF_REGION: 1034 channel_map = channel_map_global; 1035 break; 1036 case DFS_FCC_REGION: 1037 channel_map = channel_map_us; 1038 break; 1039 case DFS_ETSI_REGION: 1040 channel_map = channel_map_eu; 1041 break; 1042 case DFS_MKK_REGION: 1043 case DFS_MKKN_REGION: 1044 channel_map = channel_map_jp; 1045 break; 1046 case DFS_CN_REGION: 1047 channel_map = channel_map_china; 1048 break; 1049 case DFS_KR_REGION: 1050 channel_map = channel_map_global; 1051 break; 1052 } 1053 } 1054 1055 uint16_t reg_get_bw_value(enum phy_ch_width bw) 1056 { 1057 switch (bw) { 1058 case CH_WIDTH_20MHZ: 1059 return 20; 1060 case CH_WIDTH_40MHZ: 1061 return 40; 1062 case CH_WIDTH_80MHZ: 1063 return 80; 1064 case CH_WIDTH_160MHZ: 1065 return 160; 1066 case CH_WIDTH_80P80MHZ: 1067 return 160; 1068 case CH_WIDTH_INVALID: 1069 return 0; 1070 case CH_WIDTH_5MHZ: 1071 return 5; 1072 case CH_WIDTH_10MHZ: 1073 return 10; 1074 case CH_WIDTH_MAX: 1075 return 160; 1076 default: 1077 return 0; 1078 } 1079 } 1080 1081 struct wlan_lmac_if_reg_tx_ops *reg_get_psoc_tx_ops( 1082 struct wlan_objmgr_psoc *psoc) 1083 { 1084 struct wlan_lmac_if_tx_ops *tx_ops; 1085 1086 tx_ops = wlan_psoc_get_lmac_if_txops(psoc); 1087 if (!tx_ops) { 1088 reg_err("tx_ops is NULL"); 1089 return NULL; 1090 } 1091 1092 return &tx_ops->reg_ops; 1093 } 1094 1095 #ifdef CONFIG_CHAN_NUM_API 1096 enum channel_enum reg_get_chan_enum(uint8_t chan_num) 1097 { 1098 uint32_t count; 1099 1100 for (count = 0; count < NUM_CHANNELS; count++) 1101 if (channel_map[count].chan_num == chan_num) 1102 return count; 1103 1104 reg_err("invalid channel number %d", chan_num); 1105 1106 return INVALID_CHANNEL; 1107 } 1108 1109 enum channel_state reg_get_channel_state(struct wlan_objmgr_pdev *pdev, 1110 uint8_t ch) 1111 { 1112 enum channel_enum ch_idx; 1113 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1114 1115 ch_idx = reg_get_chan_enum(ch); 1116 1117 if (ch_idx == INVALID_CHANNEL) 1118 return CHANNEL_STATE_INVALID; 1119 1120 pdev_priv_obj = reg_get_pdev_obj(pdev); 1121 1122 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 1123 reg_err("pdev reg obj is NULL"); 1124 return CHANNEL_STATE_INVALID; 1125 } 1126 1127 return pdev_priv_obj->cur_chan_list[ch_idx].state; 1128 } 1129 1130 /** 1131 * reg_get_5g_bonded_chan_array() - get ptr to bonded channel 1132 * @pdev: Pointer to pdev structure 1133 * @oper_ch: operating channel number 1134 * @bonded_chan_ar: bonded channel array 1135 * @array_size; Array size 1136 * @bonded_chan_ptr_ptr: bonded channel ptr ptr 1137 * 1138 * Return: bonded channel state 1139 */ 1140 static enum channel_state reg_get_5g_bonded_chan_array( 1141 struct wlan_objmgr_pdev *pdev, 1142 uint8_t oper_chan, 1143 const struct bonded_channel bonded_chan_ar[], 1144 uint16_t array_size, 1145 const struct bonded_channel **bonded_chan_ptr_ptr) 1146 { 1147 int i; 1148 uint8_t chan_num; 1149 const struct bonded_channel *bonded_chan_ptr = NULL; 1150 enum channel_state chan_state = CHANNEL_STATE_INVALID; 1151 enum channel_state temp_chan_state; 1152 1153 for (i = 0; i < array_size; i++) { 1154 if ((oper_chan >= bonded_chan_ar[i].start_ch) && 1155 (oper_chan <= bonded_chan_ar[i].end_ch)) { 1156 bonded_chan_ptr = &bonded_chan_ar[i]; 1157 break; 1158 } 1159 } 1160 1161 if (!bonded_chan_ptr) 1162 return chan_state; 1163 1164 *bonded_chan_ptr_ptr = bonded_chan_ptr; 1165 chan_num = bonded_chan_ptr->start_ch; 1166 while (chan_num <= bonded_chan_ptr->end_ch) { 1167 temp_chan_state = reg_get_channel_state(pdev, chan_num); 1168 if (temp_chan_state < chan_state) 1169 chan_state = temp_chan_state; 1170 chan_num = chan_num + 4; 1171 } 1172 1173 return chan_state; 1174 } 1175 1176 enum channel_state reg_get_5g_bonded_channel( 1177 struct wlan_objmgr_pdev *pdev, uint8_t chan_num, 1178 enum phy_ch_width ch_width, 1179 const struct bonded_channel **bonded_chan_ptr_ptr) 1180 { 1181 if (ch_width == CH_WIDTH_80P80MHZ) 1182 return reg_get_5g_bonded_chan_array(pdev, chan_num, 1183 bonded_chan_80mhz_list, 1184 QDF_ARRAY_SIZE(bonded_chan_80mhz_list), 1185 bonded_chan_ptr_ptr); 1186 else if (ch_width == CH_WIDTH_160MHZ) 1187 return reg_get_5g_bonded_chan_array(pdev, chan_num, 1188 bonded_chan_160mhz_list, 1189 QDF_ARRAY_SIZE(bonded_chan_160mhz_list), 1190 bonded_chan_ptr_ptr); 1191 else if (ch_width == CH_WIDTH_80MHZ) 1192 return reg_get_5g_bonded_chan_array(pdev, chan_num, 1193 bonded_chan_80mhz_list, 1194 QDF_ARRAY_SIZE(bonded_chan_80mhz_list), 1195 bonded_chan_ptr_ptr); 1196 else if (ch_width == CH_WIDTH_40MHZ) 1197 return reg_get_5g_bonded_chan_array(pdev, chan_num, 1198 bonded_chan_40mhz_list, 1199 QDF_ARRAY_SIZE(bonded_chan_40mhz_list), 1200 bonded_chan_ptr_ptr); 1201 else 1202 return reg_get_channel_state(pdev, chan_num); 1203 } 1204 1205 enum channel_state reg_get_5g_bonded_channel_state( 1206 struct wlan_objmgr_pdev *pdev, 1207 uint8_t ch, enum phy_ch_width bw) 1208 { 1209 enum channel_enum ch_indx; 1210 enum channel_state chan_state; 1211 struct regulatory_channel *reg_channels; 1212 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1213 bool bw_enabled = false; 1214 const struct bonded_channel *bonded_chan_ptr = NULL; 1215 1216 if (bw > CH_WIDTH_80P80MHZ) { 1217 reg_err("bw passed is not good"); 1218 return CHANNEL_STATE_INVALID; 1219 } 1220 1221 chan_state = reg_get_5g_bonded_channel(pdev, ch, bw, &bonded_chan_ptr); 1222 1223 if ((chan_state == CHANNEL_STATE_INVALID) || 1224 (chan_state == CHANNEL_STATE_DISABLE)) 1225 return chan_state; 1226 1227 pdev_priv_obj = reg_get_pdev_obj(pdev); 1228 1229 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 1230 reg_err("pdev reg obj is NULL"); 1231 return CHANNEL_STATE_INVALID; 1232 } 1233 reg_channels = pdev_priv_obj->cur_chan_list; 1234 1235 ch_indx = reg_get_chan_enum(ch); 1236 if (ch_indx == INVALID_CHANNEL) 1237 return CHANNEL_STATE_INVALID; 1238 if (bw == CH_WIDTH_5MHZ) 1239 bw_enabled = true; 1240 else if (bw == CH_WIDTH_10MHZ) 1241 bw_enabled = (reg_channels[ch_indx].min_bw <= 10) && 1242 (reg_channels[ch_indx].max_bw >= 10); 1243 else if (bw == CH_WIDTH_20MHZ) 1244 bw_enabled = (reg_channels[ch_indx].min_bw <= 20) && 1245 (reg_channels[ch_indx].max_bw >= 20); 1246 else if (bw == CH_WIDTH_40MHZ) 1247 bw_enabled = (reg_channels[ch_indx].min_bw <= 40) && 1248 (reg_channels[ch_indx].max_bw >= 40); 1249 else if (bw == CH_WIDTH_80MHZ) 1250 bw_enabled = (reg_channels[ch_indx].min_bw <= 80) && 1251 (reg_channels[ch_indx].max_bw >= 80); 1252 else if (bw == CH_WIDTH_160MHZ) 1253 bw_enabled = (reg_channels[ch_indx].min_bw <= 160) && 1254 (reg_channels[ch_indx].max_bw >= 160); 1255 else if (bw == CH_WIDTH_80P80MHZ) 1256 bw_enabled = (reg_channels[ch_indx].min_bw <= 80) && 1257 (reg_channels[ch_indx].max_bw >= 80); 1258 1259 if (bw_enabled) 1260 return chan_state; 1261 else 1262 return CHANNEL_STATE_DISABLE; 1263 } 1264 1265 enum channel_state reg_get_2g_bonded_channel_state( 1266 struct wlan_objmgr_pdev *pdev, 1267 uint8_t oper_ch, uint8_t sec_ch, 1268 enum phy_ch_width bw) 1269 { 1270 enum channel_enum chan_idx; 1271 enum channel_state chan_state; 1272 struct regulatory_channel *reg_channels; 1273 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1274 bool bw_enabled = false; 1275 enum channel_state chan_state2 = CHANNEL_STATE_INVALID; 1276 1277 if (bw > CH_WIDTH_40MHZ) 1278 return CHANNEL_STATE_INVALID; 1279 1280 if (bw == CH_WIDTH_40MHZ) { 1281 if ((sec_ch + 4 != oper_ch) && 1282 (oper_ch + 4 != sec_ch)) 1283 return CHANNEL_STATE_INVALID; 1284 chan_state2 = reg_get_channel_state(pdev, sec_ch); 1285 if (chan_state2 == CHANNEL_STATE_INVALID) 1286 return chan_state2; 1287 } 1288 1289 pdev_priv_obj = reg_get_pdev_obj(pdev); 1290 1291 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 1292 reg_err("reg pdev priv obj is NULL"); 1293 return CHANNEL_STATE_INVALID; 1294 } 1295 1296 reg_channels = pdev_priv_obj->cur_chan_list; 1297 1298 chan_state = reg_get_channel_state(pdev, oper_ch); 1299 if (chan_state2 < chan_state) 1300 chan_state = chan_state2; 1301 1302 if ((chan_state == CHANNEL_STATE_INVALID) || 1303 (chan_state == CHANNEL_STATE_DISABLE)) 1304 return chan_state; 1305 1306 chan_idx = reg_get_chan_enum(oper_ch); 1307 if (chan_idx == INVALID_CHANNEL) 1308 return CHANNEL_STATE_INVALID; 1309 if (bw == CH_WIDTH_5MHZ) 1310 bw_enabled = true; 1311 else if (bw == CH_WIDTH_10MHZ) 1312 bw_enabled = (reg_channels[chan_idx].min_bw <= 10) && 1313 (reg_channels[chan_idx].max_bw >= 10); 1314 else if (bw == CH_WIDTH_20MHZ) 1315 bw_enabled = (reg_channels[chan_idx].min_bw <= 20) && 1316 (reg_channels[chan_idx].max_bw >= 20); 1317 else if (bw == CH_WIDTH_40MHZ) 1318 bw_enabled = (reg_channels[chan_idx].min_bw <= 40) && 1319 (reg_channels[chan_idx].max_bw >= 40); 1320 1321 if (bw_enabled) 1322 return chan_state; 1323 else 1324 return CHANNEL_STATE_DISABLE; 1325 1326 return CHANNEL_STATE_ENABLE; 1327 } 1328 #endif /* CONFIG_CHAN_NUM_API */ 1329 1330 /** 1331 * reg_combine_channel_states() - Get minimum of channel state1 and state2 1332 * @chan_state1: Channel state1 1333 * @chan_state2: Channel state2 1334 * 1335 * Return: Channel state 1336 */ 1337 static enum channel_state reg_combine_channel_states( 1338 enum channel_state chan_state1, 1339 enum channel_state chan_state2) 1340 { 1341 if ((chan_state1 == CHANNEL_STATE_INVALID) || 1342 (chan_state2 == CHANNEL_STATE_INVALID)) 1343 return CHANNEL_STATE_INVALID; 1344 else 1345 return min(chan_state1, chan_state2); 1346 } 1347 1348 #ifdef CONFIG_CHAN_NUM_API 1349 /** 1350 * reg_set_5g_channel_params () - Sets channel parameteres for given bandwidth 1351 * @ch: channel number. 1352 * @ch_params: pointer to the channel parameters. 1353 * 1354 * Return: None 1355 */ 1356 static void reg_set_5g_channel_params(struct wlan_objmgr_pdev *pdev, 1357 uint8_t ch, 1358 struct ch_params *ch_params) 1359 { 1360 /* 1361 * Set channel parameters like center frequency for a bonded channel 1362 * state. Also return the maximum bandwidth supported by the channel. 1363 */ 1364 1365 enum channel_state chan_state = CHANNEL_STATE_ENABLE; 1366 enum channel_state chan_state2 = CHANNEL_STATE_ENABLE; 1367 const struct bonded_channel *bonded_chan_ptr = NULL; 1368 const struct bonded_channel *bonded_chan_ptr2 = NULL; 1369 1370 if (!ch_params) { 1371 reg_err("ch_params is NULL"); 1372 return; 1373 } 1374 1375 if (ch_params->ch_width >= CH_WIDTH_MAX) { 1376 if (ch_params->center_freq_seg1 != 0) 1377 ch_params->ch_width = CH_WIDTH_80P80MHZ; 1378 else 1379 ch_params->ch_width = CH_WIDTH_160MHZ; 1380 } 1381 1382 while (ch_params->ch_width != CH_WIDTH_INVALID) { 1383 bonded_chan_ptr = NULL; 1384 bonded_chan_ptr2 = NULL; 1385 chan_state = reg_get_5g_bonded_channel( 1386 pdev, ch, ch_params->ch_width, 1387 &bonded_chan_ptr); 1388 1389 chan_state = reg_get_5g_bonded_channel_state( 1390 pdev, ch, ch_params->ch_width); 1391 1392 if (ch_params->ch_width == CH_WIDTH_80P80MHZ) { 1393 chan_state2 = reg_get_5g_bonded_channel_state( 1394 pdev, ch_params->center_freq_seg1 - 2, 1395 CH_WIDTH_80MHZ); 1396 1397 chan_state = reg_combine_channel_states( 1398 chan_state, chan_state2); 1399 } 1400 1401 if ((chan_state != CHANNEL_STATE_ENABLE) && 1402 (chan_state != CHANNEL_STATE_DFS)) 1403 goto update_bw; 1404 1405 if (ch_params->ch_width <= CH_WIDTH_20MHZ) { 1406 ch_params->sec_ch_offset = NO_SEC_CH; 1407 ch_params->center_freq_seg0 = ch; 1408 break; 1409 } else if (ch_params->ch_width >= CH_WIDTH_40MHZ) { 1410 reg_get_5g_bonded_chan_array( 1411 pdev, ch, bonded_chan_40mhz_list, 1412 QDF_ARRAY_SIZE(bonded_chan_40mhz_list), 1413 &bonded_chan_ptr2); 1414 if (!bonded_chan_ptr || !bonded_chan_ptr2) 1415 goto update_bw; 1416 if (ch == bonded_chan_ptr2->start_ch) 1417 ch_params->sec_ch_offset = LOW_PRIMARY_CH; 1418 else 1419 ch_params->sec_ch_offset = HIGH_PRIMARY_CH; 1420 1421 ch_params->center_freq_seg0 = 1422 (bonded_chan_ptr->start_ch + 1423 bonded_chan_ptr->end_ch) / 2; 1424 break; 1425 } 1426 update_bw: 1427 ch_params->ch_width = get_next_lower_bw[ch_params->ch_width]; 1428 } 1429 1430 if (ch_params->ch_width == CH_WIDTH_160MHZ) { 1431 ch_params->center_freq_seg1 = ch_params->center_freq_seg0; 1432 chan_state = reg_get_5g_bonded_channel( 1433 pdev, ch, CH_WIDTH_80MHZ, &bonded_chan_ptr); 1434 if (bonded_chan_ptr) 1435 ch_params->center_freq_seg0 = 1436 (bonded_chan_ptr->start_ch + 1437 bonded_chan_ptr->end_ch) / 2; 1438 } 1439 1440 /* Overwrite center_freq_seg1 to 0 for non 160 and 80+80 width */ 1441 if (!(ch_params->ch_width == CH_WIDTH_160MHZ || 1442 ch_params->ch_width == CH_WIDTH_80P80MHZ)) 1443 ch_params->center_freq_seg1 = 0; 1444 1445 reg_nofl_debug("ch %d ch_wd %d freq0 %d freq1 %d", ch, 1446 ch_params->ch_width, ch_params->center_freq_seg0, 1447 ch_params->center_freq_seg1); 1448 } 1449 1450 /** 1451 * reg_set_2g_channel_params() - set the 2.4G bonded channel parameters 1452 * @oper_ch: operating channel 1453 * @ch_params: channel parameters 1454 * @sec_ch_2g: 2.4G secondary channel 1455 * 1456 * Return: void 1457 */ 1458 static void reg_set_2g_channel_params(struct wlan_objmgr_pdev *pdev, 1459 uint16_t oper_ch, 1460 struct ch_params *ch_params, 1461 uint16_t sec_ch_2g) 1462 { 1463 enum channel_state chan_state = CHANNEL_STATE_ENABLE; 1464 1465 if (ch_params->ch_width >= CH_WIDTH_MAX) 1466 ch_params->ch_width = CH_WIDTH_40MHZ; 1467 if ((reg_get_bw_value(ch_params->ch_width) > 20) && !sec_ch_2g) { 1468 if (oper_ch >= 1 && oper_ch <= 5) 1469 sec_ch_2g = oper_ch + 4; 1470 else if (oper_ch >= 6 && oper_ch <= 13) 1471 sec_ch_2g = oper_ch - 4; 1472 } 1473 1474 while (ch_params->ch_width != CH_WIDTH_INVALID) { 1475 chan_state = reg_get_2g_bonded_channel_state( 1476 pdev, oper_ch, sec_ch_2g, ch_params->ch_width); 1477 if (chan_state == CHANNEL_STATE_ENABLE) { 1478 if (ch_params->ch_width == CH_WIDTH_40MHZ) { 1479 if (oper_ch < sec_ch_2g) 1480 ch_params->sec_ch_offset = 1481 LOW_PRIMARY_CH; 1482 else 1483 ch_params->sec_ch_offset = 1484 HIGH_PRIMARY_CH; 1485 ch_params->center_freq_seg0 = 1486 (oper_ch + sec_ch_2g) / 2; 1487 } else { 1488 ch_params->sec_ch_offset = NO_SEC_CH; 1489 ch_params->center_freq_seg0 = oper_ch; 1490 } 1491 break; 1492 } 1493 1494 ch_params->ch_width = get_next_lower_bw[ch_params->ch_width]; 1495 } 1496 /* Overwrite center_freq_seg1 to 0 for 2.4 Ghz */ 1497 ch_params->center_freq_seg1 = 0; 1498 } 1499 1500 void reg_set_channel_params(struct wlan_objmgr_pdev *pdev, 1501 uint8_t ch, uint8_t sec_ch_2g, 1502 struct ch_params *ch_params) 1503 { 1504 if (REG_IS_5GHZ_CH(ch)) 1505 reg_set_5g_channel_params(pdev, ch, ch_params); 1506 else if (REG_IS_24GHZ_CH(ch)) 1507 reg_set_2g_channel_params(pdev, ch, ch_params, sec_ch_2g); 1508 } 1509 #endif /* CONFIG_CHAN_NUM_API */ 1510 1511 QDF_STATUS reg_read_default_country(struct wlan_objmgr_psoc *psoc, 1512 uint8_t *country_code) 1513 { 1514 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 1515 1516 if (!country_code) { 1517 reg_err("country_code is NULL"); 1518 return QDF_STATUS_E_INVAL; 1519 } 1520 1521 psoc_priv_obj = reg_get_psoc_obj(psoc); 1522 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 1523 reg_err("psoc reg component is NULL"); 1524 return QDF_STATUS_E_INVAL; 1525 } 1526 1527 qdf_mem_copy(country_code, psoc_priv_obj->def_country, 1528 REG_ALPHA2_LEN + 1); 1529 1530 return QDF_STATUS_SUCCESS; 1531 } 1532 1533 QDF_STATUS reg_get_max_5g_bw_from_country_code(uint16_t cc, 1534 uint16_t *max_bw_5g) 1535 { 1536 uint16_t i; 1537 int num_countries; 1538 1539 *max_bw_5g = 0; 1540 reg_get_num_countries(&num_countries); 1541 1542 for (i = 0; i < num_countries; i++) { 1543 if (g_all_countries[i].country_code == cc) 1544 break; 1545 } 1546 1547 if (i == num_countries) 1548 return QDF_STATUS_E_FAILURE; 1549 1550 *max_bw_5g = g_all_countries[i].max_bw_5g; 1551 1552 return QDF_STATUS_SUCCESS; 1553 } 1554 1555 QDF_STATUS reg_get_max_5g_bw_from_regdomain(uint16_t regdmn, 1556 uint16_t *max_bw_5g) 1557 { 1558 uint16_t i; 1559 int num_reg_dmn; 1560 1561 *max_bw_5g = 0; 1562 reg_get_num_reg_dmn_pairs(&num_reg_dmn); 1563 1564 for (i = 0; i < num_reg_dmn; i++) { 1565 if (g_reg_dmn_pairs[i].reg_dmn_pair_id == regdmn) 1566 break; 1567 } 1568 1569 if (i == num_reg_dmn) 1570 return QDF_STATUS_E_FAILURE; 1571 1572 *max_bw_5g = regdomains_5g[g_reg_dmn_pairs[i].dmn_id_5g].max_bw; 1573 1574 return QDF_STATUS_SUCCESS; 1575 } 1576 1577 void reg_get_current_dfs_region(struct wlan_objmgr_pdev *pdev, 1578 enum dfs_reg *dfs_reg) 1579 { 1580 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1581 1582 pdev_priv_obj = reg_get_pdev_obj(pdev); 1583 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 1584 reg_err("reg component pdev priv is NULL"); 1585 return; 1586 } 1587 1588 *dfs_reg = pdev_priv_obj->dfs_region; 1589 } 1590 1591 void reg_set_dfs_region(struct wlan_objmgr_pdev *pdev, 1592 enum dfs_reg dfs_reg) 1593 { 1594 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1595 1596 pdev_priv_obj = reg_get_pdev_obj(pdev); 1597 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 1598 reg_err("psoc reg component is NULL"); 1599 return; 1600 } 1601 1602 pdev_priv_obj->dfs_region = dfs_reg; 1603 1604 reg_init_channel_map(dfs_reg); 1605 } 1606 1607 #ifdef CONFIG_CHAN_NUM_API 1608 uint32_t reg_get_channel_reg_power(struct wlan_objmgr_pdev *pdev, 1609 uint8_t chan_num) 1610 { 1611 enum channel_enum chan_enum; 1612 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1613 struct regulatory_channel *reg_channels; 1614 1615 chan_enum = reg_get_chan_enum(chan_num); 1616 1617 if (chan_enum == INVALID_CHANNEL) { 1618 reg_err("channel is invalid"); 1619 return QDF_STATUS_E_FAILURE; 1620 } 1621 1622 pdev_priv_obj = reg_get_pdev_obj(pdev); 1623 1624 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 1625 reg_err("reg pdev priv obj is NULL"); 1626 return QDF_STATUS_E_FAILURE; 1627 } 1628 1629 reg_channels = pdev_priv_obj->cur_chan_list; 1630 1631 return reg_channels[chan_enum].tx_power; 1632 } 1633 1634 qdf_freq_t reg_get_channel_freq(struct wlan_objmgr_pdev *pdev, 1635 uint8_t chan_num) 1636 { 1637 enum channel_enum chan_enum; 1638 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1639 struct regulatory_channel *reg_channels; 1640 1641 chan_enum = reg_get_chan_enum(chan_num); 1642 1643 if (chan_enum == INVALID_CHANNEL) 1644 return CHANNEL_STATE_INVALID; 1645 1646 pdev_priv_obj = reg_get_pdev_obj(pdev); 1647 1648 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 1649 reg_err("reg pdev priv obj is NULL"); 1650 return QDF_STATUS_E_FAILURE; 1651 } 1652 1653 reg_channels = pdev_priv_obj->cur_chan_list; 1654 1655 return reg_channels[chan_enum].center_freq; 1656 } 1657 1658 bool reg_is_dfs_ch(struct wlan_objmgr_pdev *pdev, 1659 uint8_t chan) 1660 { 1661 enum channel_state ch_state; 1662 1663 ch_state = reg_get_channel_state(pdev, chan); 1664 1665 return ch_state == CHANNEL_STATE_DFS; 1666 } 1667 1668 bool reg_is_disable_ch(struct wlan_objmgr_pdev *pdev, uint8_t chan) 1669 { 1670 enum channel_state ch_state; 1671 1672 ch_state = reg_get_channel_state(pdev, chan); 1673 1674 return ch_state == CHANNEL_STATE_DISABLE; 1675 } 1676 #endif /* CONFIG_CHAN_NUM_API */ 1677 1678 uint8_t reg_freq_to_chan(struct wlan_objmgr_pdev *pdev, 1679 qdf_freq_t freq) 1680 { 1681 uint32_t count; 1682 struct regulatory_channel *chan_list; 1683 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1684 1685 if (freq == 0) { 1686 reg_err_rl("Invalid freq %d", freq); 1687 return 0; 1688 } 1689 1690 pdev_priv_obj = reg_get_pdev_obj(pdev); 1691 1692 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 1693 reg_err("reg pdev priv obj is NULL"); 1694 return 0; 1695 } 1696 1697 chan_list = pdev_priv_obj->mas_chan_list; 1698 for (count = 0; count < NUM_CHANNELS; count++) { 1699 if (chan_list[count].center_freq >= freq) 1700 break; 1701 } 1702 1703 if (count == NUM_CHANNELS) 1704 goto end; 1705 1706 if (chan_list[count].center_freq == freq) 1707 return chan_list[count].chan_num; 1708 1709 if (count == 0) 1710 goto end; 1711 1712 if ((chan_list[count - 1].chan_num == INVALID_CHANNEL_NUM) || 1713 (chan_list[count].chan_num == INVALID_CHANNEL_NUM)) { 1714 reg_err("Frequency %d invalid in current reg domain", freq); 1715 return 0; 1716 } 1717 1718 return (chan_list[count - 1].chan_num + 1719 (freq - chan_list[count - 1].center_freq) / 5); 1720 1721 end: 1722 reg_err_rl("invalid frequency %d", freq); 1723 return 0; 1724 } 1725 1726 static uint16_t reg_compute_chan_to_freq(struct wlan_objmgr_pdev *pdev, 1727 uint8_t chan_num, 1728 enum channel_enum min_chan_range, 1729 enum channel_enum max_chan_range) 1730 { 1731 uint16_t count; 1732 struct regulatory_channel *chan_list; 1733 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1734 1735 pdev_priv_obj = reg_get_pdev_obj(pdev); 1736 1737 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 1738 reg_err("reg pdev priv obj is NULL"); 1739 return 0; 1740 } 1741 1742 if (min_chan_range < MIN_CHANNEL || max_chan_range > MAX_CHANNEL) { 1743 reg_err_rl("Channel range is invalid"); 1744 return 0; 1745 } 1746 1747 chan_list = pdev_priv_obj->mas_chan_list; 1748 1749 for (count = min_chan_range; count <= max_chan_range; count++) { 1750 if ((chan_list[count].state != CHANNEL_STATE_DISABLE) && 1751 !(chan_list[count].chan_flags & REGULATORY_CHAN_DISABLED)) { 1752 if (REG_IS_49GHZ_FREQ(chan_list[count].center_freq)) { 1753 if (chan_list[count].chan_num == chan_num) 1754 break; 1755 continue; 1756 } else if ((chan_list[count].chan_num >= chan_num) && 1757 (chan_list[count].chan_num != 1758 INVALID_CHANNEL_NUM)) 1759 break; 1760 } 1761 } 1762 1763 if (count == max_chan_range + 1) 1764 goto end; 1765 1766 if (chan_list[count].chan_num == chan_num) { 1767 if (chan_list[count].chan_flags & REGULATORY_CHAN_DISABLED) 1768 reg_err("Channel %d disabled in current reg domain", 1769 chan_num); 1770 return chan_list[count].center_freq; 1771 } 1772 1773 if (count == min_chan_range) 1774 goto end; 1775 1776 if ((chan_list[count - 1].chan_num == INVALID_CHANNEL_NUM) || 1777 REG_IS_49GHZ_FREQ(chan_list[count - 1].center_freq) || 1778 (chan_list[count].chan_num == INVALID_CHANNEL_NUM)) { 1779 reg_err("Channel %d invalid in current reg domain", 1780 chan_num); 1781 return 0; 1782 } 1783 1784 return (chan_list[count - 1].center_freq + 1785 (chan_num - chan_list[count - 1].chan_num) * 5); 1786 1787 end: 1788 1789 reg_debug_rl("Invalid channel %d", chan_num); 1790 return 0; 1791 } 1792 1793 uint16_t reg_legacy_chan_to_freq(struct wlan_objmgr_pdev *pdev, 1794 uint8_t chan_num) 1795 { 1796 uint16_t min_chan_range = MIN_24GHZ_CHANNEL; 1797 uint16_t max_chan_range = MAX_5GHZ_CHANNEL; 1798 1799 if (chan_num == 0) { 1800 reg_err_rl("Invalid channel %d", chan_num); 1801 return 0; 1802 } 1803 1804 return reg_compute_chan_to_freq(pdev, chan_num, 1805 min_chan_range, 1806 max_chan_range); 1807 } 1808 1809 qdf_freq_t reg_chan_to_freq(struct wlan_objmgr_pdev *pdev, 1810 uint8_t chan_num) 1811 { 1812 uint32_t count; 1813 struct regulatory_channel *chan_list; 1814 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1815 1816 if (chan_num == 0) { 1817 reg_err_rl("Invalid channel %d", chan_num); 1818 return 0; 1819 } 1820 1821 pdev_priv_obj = reg_get_pdev_obj(pdev); 1822 1823 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 1824 reg_err("reg pdev priv obj is NULL"); 1825 return 0; 1826 } 1827 1828 chan_list = pdev_priv_obj->cur_chan_list; 1829 for (count = 0; count < NUM_CHANNELS; count++) 1830 if (chan_list[count].chan_num == chan_num) { 1831 if (reg_chan_in_range(chan_list, 1832 pdev_priv_obj->range_2g_low, 1833 pdev_priv_obj->range_2g_high, 1834 pdev_priv_obj->range_5g_low, 1835 pdev_priv_obj->range_5g_high, 1836 count)) { 1837 return chan_list[count].center_freq; 1838 } 1839 } 1840 1841 reg_debug_rl("invalid channel %d", chan_num); 1842 return 0; 1843 } 1844 1845 #ifdef CONFIG_CHAN_NUM_API 1846 bool reg_chan_is_49ghz(struct wlan_objmgr_pdev *pdev, uint8_t chan_num) 1847 { 1848 qdf_freq_t freq = 0; 1849 1850 freq = reg_chan_to_freq(pdev, chan_num); 1851 1852 return REG_IS_49GHZ_FREQ(freq) ? true : false; 1853 } 1854 1855 enum band_info reg_chan_to_band(uint8_t chan_num) 1856 { 1857 if (chan_num <= 14) 1858 return BAND_2G; 1859 1860 return BAND_5G; 1861 } 1862 1863 void reg_update_nol_ch(struct wlan_objmgr_pdev *pdev, 1864 uint8_t *chan_list, 1865 uint8_t num_chan, 1866 bool nol_chan) 1867 { 1868 enum channel_enum chan_enum; 1869 struct regulatory_channel *mas_chan_list; 1870 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1871 uint16_t i; 1872 1873 if (!num_chan || !chan_list) { 1874 reg_err("chan_list or num_ch is NULL"); 1875 return; 1876 } 1877 1878 pdev_priv_obj = reg_get_pdev_obj(pdev); 1879 if (!pdev_priv_obj) { 1880 reg_err("reg psoc private obj is NULL"); 1881 return; 1882 } 1883 1884 mas_chan_list = pdev_priv_obj->mas_chan_list; 1885 for (i = 0; i < num_chan; i++) { 1886 chan_enum = reg_get_chan_enum(chan_list[i]); 1887 if (chan_enum == INVALID_CHANNEL) { 1888 reg_err("Invalid ch in nol list, chan %d", 1889 chan_list[i]); 1890 continue; 1891 } 1892 mas_chan_list[chan_enum].nol_chan = nol_chan; 1893 } 1894 1895 reg_compute_pdev_current_chan_list(pdev_priv_obj); 1896 } 1897 #endif /* CONFIG_CHAN_NUM_API */ 1898 1899 QDF_STATUS reg_program_default_cc(struct wlan_objmgr_pdev *pdev, 1900 uint16_t regdmn) 1901 { 1902 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1903 struct cur_regulatory_info *reg_info; 1904 uint16_t cc = -1; 1905 uint16_t country_index = -1, regdmn_pair = -1; 1906 struct wlan_objmgr_psoc *psoc; 1907 QDF_STATUS err; 1908 1909 pdev_priv_obj = reg_get_pdev_obj(pdev); 1910 if (!pdev_priv_obj) { 1911 reg_err("reg soc is NULL"); 1912 return QDF_STATUS_E_FAILURE; 1913 } 1914 1915 reg_info = (struct cur_regulatory_info *)qdf_mem_malloc 1916 (sizeof(struct cur_regulatory_info)); 1917 if (!reg_info) 1918 return QDF_STATUS_E_NOMEM; 1919 1920 psoc = wlan_pdev_get_psoc(pdev); 1921 if (!psoc) { 1922 reg_err("psoc is NULL"); 1923 return QDF_STATUS_E_INVAL; 1924 } 1925 1926 reg_info->psoc = psoc; 1927 reg_info->phy_id = wlan_objmgr_pdev_get_pdev_id(pdev); 1928 reg_info->num_phy = 1; 1929 1930 if (regdmn == 0) { 1931 reg_get_default_country(®dmn); 1932 regdmn |= COUNTRY_ERD_FLAG; 1933 } 1934 1935 if (regdmn & COUNTRY_ERD_FLAG) { 1936 cc = regdmn & ~COUNTRY_ERD_FLAG; 1937 1938 reg_get_rdpair_from_country_code(cc, 1939 &country_index, 1940 ®dmn_pair); 1941 1942 err = reg_get_cur_reginfo(reg_info, country_index, regdmn_pair); 1943 if (err == QDF_STATUS_E_FAILURE) { 1944 reg_err("Unable to set country code\n"); 1945 qdf_mem_free(reg_info->reg_rules_2g_ptr); 1946 qdf_mem_free(reg_info->reg_rules_5g_ptr); 1947 qdf_mem_free(reg_info); 1948 return QDF_STATUS_E_FAILURE; 1949 } 1950 1951 pdev_priv_obj->ctry_code = cc; 1952 1953 } else { 1954 reg_get_rdpair_from_regdmn_id(regdmn, ®dmn_pair); 1955 1956 err = reg_get_cur_reginfo(reg_info, country_index, regdmn_pair); 1957 if (err == QDF_STATUS_E_FAILURE) { 1958 reg_err("Unable to set country code\n"); 1959 qdf_mem_free(reg_info->reg_rules_2g_ptr); 1960 qdf_mem_free(reg_info->reg_rules_5g_ptr); 1961 qdf_mem_free(reg_info); 1962 return QDF_STATUS_E_FAILURE; 1963 } 1964 1965 pdev_priv_obj->reg_dmn_pair = regdmn; 1966 } 1967 1968 reg_info->offload_enabled = false; 1969 reg_process_master_chan_list(reg_info); 1970 1971 qdf_mem_free(reg_info->reg_rules_2g_ptr); 1972 qdf_mem_free(reg_info->reg_rules_5g_ptr); 1973 qdf_mem_free(reg_info); 1974 1975 return QDF_STATUS_SUCCESS; 1976 } 1977 1978 QDF_STATUS reg_program_chan_list(struct wlan_objmgr_pdev *pdev, 1979 struct cc_regdmn_s *rd) 1980 { 1981 struct cur_regulatory_info *reg_info; 1982 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1983 uint16_t country_index = -1, regdmn_pair = -1; 1984 struct wlan_objmgr_psoc *psoc; 1985 struct wlan_lmac_if_reg_tx_ops *tx_ops; 1986 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 1987 uint8_t pdev_id; 1988 uint8_t phy_id; 1989 QDF_STATUS err; 1990 1991 pdev_priv_obj = reg_get_pdev_obj(pdev); 1992 if (!pdev_priv_obj) { 1993 reg_err(" pdev priv obj is NULL"); 1994 return QDF_STATUS_E_FAILURE; 1995 } 1996 1997 psoc = wlan_pdev_get_psoc(pdev); 1998 if (!psoc) { 1999 reg_err("psoc is NULL"); 2000 return QDF_STATUS_E_INVAL; 2001 } 2002 2003 psoc_priv_obj = reg_get_psoc_obj(psoc); 2004 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 2005 reg_err("psoc reg component is NULL"); 2006 return QDF_STATUS_E_FAILURE; 2007 } 2008 2009 if (psoc_priv_obj->offload_enabled) { 2010 if ((rd->flags == ALPHA_IS_SET) && (rd->cc.alpha[2] == 'O')) 2011 pdev_priv_obj->indoor_chan_enabled = false; 2012 else 2013 pdev_priv_obj->indoor_chan_enabled = true; 2014 2015 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 2016 tx_ops = reg_get_psoc_tx_ops(psoc); 2017 2018 if (tx_ops->get_phy_id_from_pdev_id) 2019 tx_ops->get_phy_id_from_pdev_id(psoc, pdev_id, &phy_id); 2020 else 2021 phy_id = pdev_id; 2022 2023 if (tx_ops->set_user_country_code) { 2024 psoc_priv_obj->new_init_ctry_pending[phy_id] = true; 2025 return tx_ops->set_user_country_code(psoc, pdev_id, rd); 2026 } 2027 2028 return QDF_STATUS_E_FAILURE; 2029 } 2030 2031 reg_info = (struct cur_regulatory_info *)qdf_mem_malloc 2032 (sizeof(struct cur_regulatory_info)); 2033 if (!reg_info) 2034 return QDF_STATUS_E_NOMEM; 2035 2036 reg_info->psoc = psoc; 2037 reg_info->phy_id = wlan_objmgr_pdev_get_pdev_id(pdev); 2038 2039 if (rd->flags == CC_IS_SET) { 2040 reg_get_rdpair_from_country_code(rd->cc.country_code, 2041 &country_index, 2042 ®dmn_pair); 2043 } else if (rd->flags == ALPHA_IS_SET) { 2044 reg_get_rdpair_from_country_iso(rd->cc.alpha, 2045 &country_index, 2046 ®dmn_pair); 2047 } else if (rd->flags == REGDMN_IS_SET) { 2048 reg_get_rdpair_from_regdmn_id(rd->cc.regdmn.reg_2g_5g_pair_id, 2049 ®dmn_pair); 2050 } 2051 2052 err = reg_get_cur_reginfo(reg_info, country_index, regdmn_pair); 2053 if (err == QDF_STATUS_E_FAILURE) { 2054 reg_err("Unable to set country code\n"); 2055 qdf_mem_free(reg_info->reg_rules_2g_ptr); 2056 qdf_mem_free(reg_info->reg_rules_5g_ptr); 2057 qdf_mem_free(reg_info); 2058 return QDF_STATUS_E_FAILURE; 2059 } 2060 2061 reg_info->offload_enabled = false; 2062 reg_process_master_chan_list(reg_info); 2063 2064 qdf_mem_free(reg_info->reg_rules_2g_ptr); 2065 qdf_mem_free(reg_info->reg_rules_5g_ptr); 2066 qdf_mem_free(reg_info); 2067 2068 return QDF_STATUS_SUCCESS; 2069 } 2070 2071 QDF_STATUS reg_get_current_cc(struct wlan_objmgr_pdev *pdev, 2072 struct cc_regdmn_s *rd) 2073 { 2074 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 2075 2076 pdev_priv_obj = reg_get_pdev_obj(pdev); 2077 if (!pdev_priv_obj) { 2078 reg_err("reg pdev priv is NULL"); 2079 return QDF_STATUS_E_FAILURE; 2080 } 2081 2082 if (rd->flags == CC_IS_SET) { 2083 rd->cc.country_code = pdev_priv_obj->ctry_code; 2084 } else if (rd->flags == ALPHA_IS_SET) { 2085 qdf_mem_copy(rd->cc.alpha, pdev_priv_obj->current_country, 2086 sizeof(rd->cc.alpha)); 2087 } else if (rd->flags == REGDMN_IS_SET) { 2088 rd->cc.regdmn.reg_2g_5g_pair_id = pdev_priv_obj->reg_dmn_pair; 2089 rd->cc.regdmn.sixg_superdmn_id = pdev_priv_obj->reg_6g_superid; 2090 } 2091 2092 return QDF_STATUS_SUCCESS; 2093 } 2094 2095 QDF_STATUS reg_set_regdb_offloaded(struct wlan_objmgr_psoc *psoc, bool val) 2096 { 2097 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 2098 2099 psoc_priv_obj = reg_get_psoc_obj(psoc); 2100 2101 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 2102 reg_err("psoc reg component is NULL"); 2103 return QDF_STATUS_E_FAILURE; 2104 } 2105 2106 psoc_priv_obj->offload_enabled = val; 2107 2108 return QDF_STATUS_SUCCESS; 2109 } 2110 2111 QDF_STATUS reg_get_curr_regdomain(struct wlan_objmgr_pdev *pdev, 2112 struct cur_regdmn_info *cur_regdmn) 2113 { 2114 struct wlan_objmgr_psoc *psoc; 2115 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 2116 uint16_t index; 2117 int num_reg_dmn; 2118 uint8_t phy_id; 2119 uint8_t pdev_id; 2120 struct wlan_lmac_if_reg_tx_ops *tx_ops; 2121 2122 psoc = wlan_pdev_get_psoc(pdev); 2123 psoc_priv_obj = reg_get_psoc_obj(psoc); 2124 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 2125 reg_err("soc reg component is NULL"); 2126 return QDF_STATUS_E_INVAL; 2127 } 2128 2129 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 2130 2131 tx_ops = reg_get_psoc_tx_ops(psoc); 2132 if (tx_ops->get_phy_id_from_pdev_id) 2133 tx_ops->get_phy_id_from_pdev_id(psoc, pdev_id, &phy_id); 2134 else 2135 phy_id = pdev_id; 2136 2137 cur_regdmn->regdmn_pair_id = 2138 psoc_priv_obj->mas_chan_params[phy_id].reg_dmn_pair; 2139 2140 reg_get_num_reg_dmn_pairs(&num_reg_dmn); 2141 for (index = 0; index < num_reg_dmn; index++) { 2142 if (g_reg_dmn_pairs[index].reg_dmn_pair_id == 2143 cur_regdmn->regdmn_pair_id) 2144 break; 2145 } 2146 2147 if (index == num_reg_dmn) { 2148 reg_debug_rl("invalid regdomain"); 2149 return QDF_STATUS_E_FAILURE; 2150 } 2151 2152 cur_regdmn->dmn_id_2g = g_reg_dmn_pairs[index].dmn_id_2g; 2153 cur_regdmn->dmn_id_5g = g_reg_dmn_pairs[index].dmn_id_5g; 2154 cur_regdmn->ctl_2g = regdomains_2g[cur_regdmn->dmn_id_2g].ctl_val; 2155 cur_regdmn->ctl_5g = regdomains_5g[cur_regdmn->dmn_id_5g].ctl_val; 2156 cur_regdmn->dfs_region = 2157 regdomains_5g[cur_regdmn->dmn_id_5g].dfs_region; 2158 2159 return QDF_STATUS_SUCCESS; 2160 } 2161 2162 QDF_STATUS reg_modify_chan_144(struct wlan_objmgr_pdev *pdev, 2163 bool enable_ch_144) 2164 { 2165 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 2166 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 2167 struct wlan_objmgr_psoc *psoc; 2168 struct wlan_lmac_if_reg_tx_ops *reg_tx_ops; 2169 QDF_STATUS status; 2170 2171 pdev_priv_obj = reg_get_pdev_obj(pdev); 2172 2173 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 2174 reg_err("pdev reg component is NULL"); 2175 return QDF_STATUS_E_INVAL; 2176 } 2177 2178 if (pdev_priv_obj->en_chan_144 == enable_ch_144) { 2179 reg_info("chan 144 is already %d", enable_ch_144); 2180 return QDF_STATUS_SUCCESS; 2181 } 2182 2183 psoc = wlan_pdev_get_psoc(pdev); 2184 if (!psoc) { 2185 reg_err("psoc is NULL"); 2186 return QDF_STATUS_E_INVAL; 2187 } 2188 2189 psoc_priv_obj = reg_get_psoc_obj(psoc); 2190 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 2191 reg_err("psoc reg component is NULL"); 2192 return QDF_STATUS_E_INVAL; 2193 } 2194 2195 reg_debug("setting chan 144: %d", enable_ch_144); 2196 pdev_priv_obj->en_chan_144 = enable_ch_144; 2197 2198 reg_compute_pdev_current_chan_list(pdev_priv_obj); 2199 2200 reg_tx_ops = reg_get_psoc_tx_ops(psoc); 2201 if (reg_tx_ops->fill_umac_legacy_chanlist) 2202 reg_tx_ops->fill_umac_legacy_chanlist(pdev, 2203 pdev_priv_obj->cur_chan_list); 2204 2205 status = reg_send_scheduler_msg_sb(psoc, pdev); 2206 2207 return status; 2208 } 2209 2210 bool reg_get_en_chan_144(struct wlan_objmgr_pdev *pdev) 2211 { 2212 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 2213 2214 pdev_priv_obj = reg_get_pdev_obj(pdev); 2215 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 2216 reg_err("pdev reg component is NULL"); 2217 return false; 2218 } 2219 2220 return pdev_priv_obj->en_chan_144; 2221 } 2222 2223 struct wlan_psoc_host_hal_reg_capabilities_ext *reg_get_hal_reg_cap( 2224 struct wlan_objmgr_psoc *psoc) 2225 { 2226 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 2227 2228 psoc_priv_obj = reg_get_psoc_obj(psoc); 2229 2230 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 2231 reg_err("psoc reg component is NULL"); 2232 return NULL; 2233 } 2234 2235 return psoc_priv_obj->reg_cap; 2236 } 2237 2238 QDF_STATUS reg_set_hal_reg_cap( 2239 struct wlan_objmgr_psoc *psoc, 2240 struct wlan_psoc_host_hal_reg_capabilities_ext *reg_cap, 2241 uint16_t phy_cnt) 2242 { 2243 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 2244 2245 psoc_priv_obj = reg_get_psoc_obj(psoc); 2246 2247 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 2248 reg_err("psoc reg component is NULL"); 2249 return QDF_STATUS_E_FAILURE; 2250 } 2251 2252 if (phy_cnt > PSOC_MAX_PHY_REG_CAP) { 2253 reg_err("phy cnt:%d is more than %d", phy_cnt, 2254 PSOC_MAX_PHY_REG_CAP); 2255 return QDF_STATUS_E_FAILURE; 2256 } 2257 2258 qdf_mem_copy(psoc_priv_obj->reg_cap, reg_cap, 2259 phy_cnt * 2260 sizeof(struct wlan_psoc_host_hal_reg_capabilities_ext)); 2261 2262 return QDF_STATUS_SUCCESS; 2263 } 2264 2265 QDF_STATUS reg_update_hal_reg_cap(struct wlan_objmgr_psoc *psoc, 2266 uint32_t wireless_modes, uint8_t phy_id) 2267 { 2268 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 2269 2270 if (!psoc) { 2271 reg_err("psoc is null"); 2272 return QDF_STATUS_E_FAILURE; 2273 } 2274 2275 psoc_priv_obj = reg_get_psoc_obj(psoc); 2276 2277 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 2278 reg_err("psoc reg component is NULL"); 2279 return QDF_STATUS_E_FAILURE; 2280 } 2281 2282 psoc_priv_obj->reg_cap[phy_id].wireless_modes |= wireless_modes; 2283 2284 return QDF_STATUS_SUCCESS; 2285 } 2286 2287 bool reg_chan_in_range(struct regulatory_channel *chan_list, 2288 qdf_freq_t low_freq_2g, qdf_freq_t high_freq_2g, 2289 qdf_freq_t low_freq_5g, qdf_freq_t high_freq_5g, 2290 enum channel_enum ch_enum) 2291 { 2292 uint32_t low_limit_2g = NUM_CHANNELS; 2293 uint32_t high_limit_2g = NUM_CHANNELS; 2294 uint32_t low_limit_5g = NUM_CHANNELS; 2295 uint32_t high_limit_5g = NUM_CHANNELS; 2296 bool chan_in_range; 2297 enum channel_enum chan_enum; 2298 uint16_t min_bw; 2299 qdf_freq_t center_freq; 2300 2301 for (chan_enum = 0; chan_enum < NUM_CHANNELS; chan_enum++) { 2302 min_bw = chan_list[chan_enum].min_bw; 2303 center_freq = chan_list[chan_enum].center_freq; 2304 2305 if ((center_freq - min_bw / 2) >= low_freq_2g) { 2306 low_limit_2g = chan_enum; 2307 break; 2308 } 2309 } 2310 2311 for (chan_enum = 0; chan_enum < NUM_CHANNELS; chan_enum++) { 2312 min_bw = chan_list[chan_enum].min_bw; 2313 center_freq = chan_list[chan_enum].center_freq; 2314 2315 if ((center_freq - min_bw / 2) >= low_freq_5g) { 2316 low_limit_5g = chan_enum; 2317 break; 2318 } 2319 } 2320 2321 for (chan_enum = NUM_CHANNELS - 1; chan_enum >= 0; chan_enum--) { 2322 min_bw = chan_list[chan_enum].min_bw; 2323 center_freq = chan_list[chan_enum].center_freq; 2324 2325 if (center_freq + min_bw / 2 <= high_freq_2g) { 2326 high_limit_2g = chan_enum; 2327 break; 2328 } 2329 if (chan_enum == 0) 2330 break; 2331 } 2332 2333 for (chan_enum = NUM_CHANNELS - 1; chan_enum >= 0; chan_enum--) { 2334 min_bw = chan_list[chan_enum].min_bw; 2335 center_freq = chan_list[chan_enum].center_freq; 2336 2337 if (center_freq + min_bw / 2 <= high_freq_5g) { 2338 high_limit_5g = chan_enum; 2339 break; 2340 } 2341 if (chan_enum == 0) 2342 break; 2343 } 2344 2345 chan_in_range = false; 2346 if ((low_limit_2g <= ch_enum) && 2347 (high_limit_2g >= ch_enum) && 2348 (low_limit_2g != NUM_CHANNELS) && 2349 (high_limit_2g != NUM_CHANNELS)) 2350 chan_in_range = true; 2351 if ((low_limit_5g <= ch_enum) && 2352 (high_limit_5g >= ch_enum) && 2353 (low_limit_5g != NUM_CHANNELS) && 2354 (high_limit_5g != NUM_CHANNELS)) 2355 chan_in_range = true; 2356 2357 if (chan_in_range) 2358 return true; 2359 else 2360 return false; 2361 } 2362 2363 #ifdef CONFIG_CHAN_NUM_API 2364 void reg_update_nol_history_ch(struct wlan_objmgr_pdev *pdev, 2365 uint8_t *chan_list, uint8_t num_chan, 2366 bool nol_history_chan) 2367 { 2368 enum channel_enum chan_enum; 2369 struct regulatory_channel *mas_chan_list; 2370 struct regulatory_channel *cur_chan_list; 2371 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 2372 uint16_t i; 2373 2374 if (!num_chan || !chan_list) { 2375 reg_err("chan_list or num_ch is NULL"); 2376 return; 2377 } 2378 2379 pdev_priv_obj = wlan_objmgr_pdev_get_comp_private_obj( 2380 pdev, WLAN_UMAC_COMP_REGULATORY); 2381 2382 if (!pdev_priv_obj) { 2383 reg_err("reg psoc private obj is NULL"); 2384 return; 2385 } 2386 2387 mas_chan_list = pdev_priv_obj->mas_chan_list; 2388 cur_chan_list = pdev_priv_obj->cur_chan_list; 2389 2390 for (i = 0; i < num_chan; i++) { 2391 chan_enum = reg_get_chan_enum(chan_list[i]); 2392 if (chan_enum == INVALID_CHANNEL) { 2393 reg_err("Invalid ch in nol list, chan %d", 2394 chan_list[i]); 2395 continue; 2396 } 2397 mas_chan_list[chan_enum].nol_history = nol_history_chan; 2398 cur_chan_list[chan_enum].nol_history = nol_history_chan; 2399 } 2400 } 2401 2402 bool reg_is_24ghz_ch(uint32_t chan) 2403 { 2404 return REG_IS_24GHZ_CH(chan); 2405 } 2406 2407 bool reg_is_5ghz_ch(uint32_t chan) 2408 { 2409 return REG_IS_5GHZ_CH(chan); 2410 } 2411 #endif /* CONFIG_CHAN_NUM_API */ 2412 2413 bool reg_is_24ghz_ch_freq(uint32_t freq) 2414 { 2415 return REG_IS_24GHZ_CH_FREQ(freq); 2416 } 2417 2418 bool reg_is_5ghz_ch_freq(uint32_t freq) 2419 { 2420 return REG_IS_5GHZ_FREQ(freq); 2421 } 2422 2423 /** 2424 * BAND_2G_PRESENT() - Check if REG_BAND_2G is set in the band_mask 2425 * @band_mask: Bitmask for bands 2426 * 2427 * Return: True if REG_BAND_2G is set in the band_mask, else false 2428 */ 2429 static inline bool BAND_2G_PRESENT(uint8_t band_mask) 2430 { 2431 return !!(band_mask & (BIT(REG_BAND_2G))); 2432 } 2433 2434 /** 2435 * BAND_5G_PRESENT() - Check if REG_BAND_5G is set in the band_mask 2436 * @band_mask: Bitmask for bands 2437 * 2438 * Return: True if REG_BAND_5G is set in the band_mask, else false 2439 */ 2440 static inline bool BAND_5G_PRESENT(uint8_t band_mask) 2441 { 2442 return !!(band_mask & (BIT(REG_BAND_5G))); 2443 } 2444 2445 /** 2446 * reg_is_freq_in_between() - Check whether freq falls within low_freq and 2447 * high_freq, inclusively. 2448 * @low_freq - Low frequency. 2449 * @high_freq - High frequency. 2450 * @freq - Frequency to be checked. 2451 * 2452 * Return: True if freq falls within low_freq and high_freq, else false. 2453 */ 2454 static bool reg_is_freq_in_between(qdf_freq_t low_freq, qdf_freq_t high_freq, 2455 qdf_freq_t freq) 2456 { 2457 return (low_freq <= freq && freq <= high_freq); 2458 } 2459 2460 static bool reg_is_ranges_overlap(qdf_freq_t low_freq, qdf_freq_t high_freq, 2461 qdf_freq_t start_edge_freq, 2462 qdf_freq_t end_edge_freq) 2463 { 2464 return (reg_is_freq_in_between(start_edge_freq, 2465 end_edge_freq, 2466 low_freq) || 2467 reg_is_freq_in_between(start_edge_freq, 2468 end_edge_freq, 2469 high_freq) || 2470 reg_is_freq_in_between(low_freq, 2471 high_freq, 2472 start_edge_freq) || 2473 reg_is_freq_in_between(low_freq, 2474 high_freq, 2475 end_edge_freq)); 2476 } 2477 2478 bool reg_is_range_overlap_2g(qdf_freq_t low_freq, qdf_freq_t high_freq) 2479 { 2480 return reg_is_ranges_overlap(low_freq, high_freq, 2481 TWO_GIG_STARTING_EDGE_FREQ, 2482 TWO_GIG_ENDING_EDGE_FREQ); 2483 } 2484 2485 bool reg_is_range_overlap_5g(qdf_freq_t low_freq, qdf_freq_t high_freq) 2486 { 2487 return reg_is_ranges_overlap(low_freq, high_freq, 2488 FIVE_GIG_STARTING_EDGE_FREQ, 2489 FIVE_GIG_ENDING_EDGE_FREQ); 2490 } 2491 2492 #ifdef CONFIG_BAND_6GHZ 2493 bool reg_is_6ghz_chan_freq(uint16_t freq) 2494 { 2495 return REG_IS_6GHZ_FREQ(freq); 2496 } 2497 2498 #ifdef CONFIG_6G_FREQ_OVERLAP 2499 bool reg_is_range_overlap_6g(qdf_freq_t low_freq, qdf_freq_t high_freq) 2500 { 2501 return reg_is_ranges_overlap(low_freq, high_freq, 2502 SIX_GIG_STARTING_EDGE_FREQ, 2503 SIX_GIG_ENDING_EDGE_FREQ); 2504 } 2505 2506 bool reg_is_range_only6g(qdf_freq_t low_freq, qdf_freq_t high_freq) 2507 { 2508 if (low_freq >= high_freq) { 2509 reg_err_rl("Low freq is greater than or equal to high freq"); 2510 return false; 2511 } 2512 2513 if (reg_is_range_overlap_6g(low_freq, high_freq) && 2514 !reg_is_range_overlap_5g(low_freq, high_freq)) { 2515 reg_debug_rl("The device is 6G only"); 2516 return true; 2517 } 2518 2519 reg_debug_rl("The device is not 6G only"); 2520 2521 return false; 2522 } 2523 #endif 2524 2525 uint16_t reg_min_6ghz_chan_freq(void) 2526 { 2527 return REG_MIN_6GHZ_CHAN_FREQ; 2528 } 2529 2530 uint16_t reg_max_6ghz_chan_freq(void) 2531 { 2532 return REG_MAX_6GHZ_CHAN_FREQ; 2533 } 2534 2535 bool reg_is_6ghz_psc_chan_freq(uint16_t freq) 2536 { 2537 if (!REG_IS_6GHZ_FREQ(freq)) { 2538 reg_debug(" Channel frequency is not a 6GHz frequency"); 2539 return false; 2540 } 2541 2542 if (!(((freq - SIX_GHZ_NON_ORPHAN_START_FREQ) + FREQ_LEFT_SHIFT) % 2543 (FREQ_TO_CHAN_SCALE * NUM_80MHZ_BAND_IN_6G))) { 2544 return true; 2545 } 2546 2547 reg_debug_rl("Channel freq %d MHz is not a 6GHz PSC frequency", freq); 2548 2549 return false; 2550 } 2551 2552 /** 2553 * reg_is_freq_indoor() - Check if the input frequency is an indoor frequency. 2554 * @pdev: Pointer to pdev. 2555 * @freq: Channel frequency. 2556 * 2557 * Return: Return true if the input frequency is indoor, else false. 2558 */ 2559 static bool reg_is_freq_indoor(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq) 2560 { 2561 struct regulatory_channel *cur_chan_list; 2562 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 2563 enum channel_enum chan_enum; 2564 2565 pdev_priv_obj = reg_get_pdev_obj(pdev); 2566 2567 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 2568 reg_err("reg pdev priv obj is NULL"); 2569 return false; 2570 } 2571 2572 chan_enum = reg_get_chan_enum_for_freq(freq); 2573 2574 if (chan_enum == INVALID_CHANNEL) { 2575 reg_err_rl("Invalid chan enum %d", chan_enum); 2576 return false; 2577 } 2578 2579 cur_chan_list = pdev_priv_obj->cur_chan_list; 2580 2581 return (cur_chan_list[chan_enum].chan_flags & 2582 REGULATORY_CHAN_INDOOR_ONLY); 2583 } 2584 2585 bool reg_is_6g_freq_indoor(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq) 2586 { 2587 return (REG_IS_6GHZ_FREQ(freq) && reg_is_freq_indoor(pdev, freq)); 2588 } 2589 2590 /** 2591 * reg_get_max_psd() - Get max PSD. 2592 * @freq: Channel frequency. 2593 * @bw: Channel bandwidth. 2594 * @reg_ap: Regulatory 6G AP type. 2595 * @reg_client: Regulatory 6G client type. 2596 * @tx_power: Pointer to tx-power. 2597 * 2598 * Return: Return QDF_STATUS_SUCCESS, if PSD is filled for 6G TPE IE 2599 * else return QDF_STATUS_E_FAILURE. 2600 */ 2601 static QDF_STATUS reg_get_max_psd(qdf_freq_t freq, 2602 uint16_t bw, 2603 enum reg_6g_ap_type reg_ap, 2604 enum reg_6g_client_type reg_client, 2605 uint8_t *tx_power) 2606 { 2607 if (reg_ap == REG_INDOOR_AP) { 2608 switch (reg_client) { 2609 case REG_DEFAULT_CLIENT: 2610 *tx_power = REG_PSD_MAX_TXPOWER_FOR_DEFAULT_CLIENT; 2611 return QDF_STATUS_SUCCESS; 2612 case REG_SUBORDINATE_CLIENT: 2613 *tx_power = REG_PSD_MAX_TXPOWER_FOR_SUBORDINATE_CLIENT; 2614 return QDF_STATUS_SUCCESS; 2615 default: 2616 reg_err_rl("Invalid client type"); 2617 return QDF_STATUS_E_FAILURE; 2618 } 2619 } 2620 2621 return QDF_STATUS_E_FAILURE; 2622 } 2623 2624 /** 2625 * reg_get_max_txpower_for_eirp() - Get max EIRP. 2626 * @pdev: Pointer to pdev. 2627 * @freq: Channel frequency. 2628 * @bw: Channel bandwidth. 2629 * @reg_ap: Regulatory 6G AP type. 2630 * @reg_client: Regulatory client type. 2631 * @tx_power: Pointer to tx-power. 2632 * 2633 * Return: Return QDF_STATUS_SUCCESS, if EIRP is filled for 6G TPE IE 2634 * else return QDF_STATUS_E_FAILURE. 2635 */ 2636 static QDF_STATUS reg_get_max_eirp(struct wlan_objmgr_pdev *pdev, 2637 qdf_freq_t freq, 2638 uint16_t bw, 2639 enum reg_6g_ap_type reg_ap, 2640 enum reg_6g_client_type reg_client, 2641 uint8_t *tx_power) 2642 { 2643 if (reg_ap == REG_INDOOR_AP) { 2644 switch (reg_client) { 2645 case REG_DEFAULT_CLIENT: 2646 *tx_power = reg_get_channel_reg_power_for_freq(pdev, 2647 freq); 2648 return QDF_STATUS_SUCCESS; 2649 case REG_SUBORDINATE_CLIENT: 2650 *tx_power = REG_EIRP_MAX_TXPOWER_FOR_SUBORDINATE_CLIENT; 2651 return QDF_STATUS_SUCCESS; 2652 default: 2653 reg_err_rl("Invalid client type"); 2654 return QDF_STATUS_E_FAILURE; 2655 } 2656 } 2657 2658 return QDF_STATUS_E_FAILURE; 2659 } 2660 2661 QDF_STATUS reg_get_max_txpower_for_6g_tpe(struct wlan_objmgr_pdev *pdev, 2662 qdf_freq_t freq, uint8_t bw, 2663 enum reg_6g_ap_type reg_ap, 2664 enum reg_6g_client_type reg_client, 2665 bool is_psd, 2666 uint8_t *tx_power) 2667 { 2668 if (!REG_IS_6GHZ_FREQ(freq)) { 2669 reg_err_rl("%d is not a 6G channel frequency", freq); 2670 return QDF_STATUS_E_FAILURE; 2671 } 2672 2673 /* 2674 * For now, there is support only for Indoor AP and we have only 2675 * LPI power values. 2676 */ 2677 if (is_psd) 2678 return reg_get_max_psd(freq, bw, reg_ap, reg_client, tx_power); 2679 2680 return reg_get_max_eirp(pdev, freq, bw, reg_ap, reg_client, tx_power); 2681 } 2682 2683 /** 2684 * BAND_6G_PRESENT() - Check if REG_BAND_6G is set in the band_mask 2685 * @band_mask: Bitmask for bands 2686 * 2687 * Return: True if REG_BAND_6G is set in the band_mask, else false 2688 */ 2689 static inline bool BAND_6G_PRESENT(uint8_t band_mask) 2690 { 2691 return !!(band_mask & (BIT(REG_BAND_6G))); 2692 } 2693 #else 2694 static inline bool BAND_6G_PRESENT(uint8_t band_mask) 2695 { 2696 return false; 2697 } 2698 #endif /* CONFIG_BAND_6GHZ */ 2699 2700 uint16_t 2701 reg_get_band_channel_list(struct wlan_objmgr_pdev *pdev, 2702 uint8_t band_mask, 2703 struct regulatory_channel *channel_list) 2704 { 2705 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 2706 struct regulatory_channel *cur_chan_list; 2707 uint16_t i, num_channels = 0; 2708 2709 pdev_priv_obj = reg_get_pdev_obj(pdev); 2710 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 2711 reg_err("reg pdev priv obj is NULL"); 2712 return 0; 2713 } 2714 2715 cur_chan_list = pdev_priv_obj->cur_chan_list; 2716 2717 if (BAND_2G_PRESENT(band_mask)) { 2718 for (i = MIN_24GHZ_CHANNEL; i <= MAX_24GHZ_CHANNEL; i++) { 2719 if ((cur_chan_list[i].state != CHANNEL_STATE_DISABLE) && 2720 !(cur_chan_list[i].chan_flags & 2721 REGULATORY_CHAN_DISABLED)) { 2722 channel_list[num_channels] = cur_chan_list[i]; 2723 num_channels++; 2724 } 2725 } 2726 } 2727 if (BAND_5G_PRESENT(band_mask)) { 2728 for (i = BAND_5GHZ_START_CHANNEL; i <= MAX_5GHZ_CHANNEL; i++) { 2729 if ((cur_chan_list[i].state != CHANNEL_STATE_DISABLE) && 2730 !(cur_chan_list[i].chan_flags & 2731 REGULATORY_CHAN_DISABLED)) { 2732 channel_list[num_channels] = cur_chan_list[i]; 2733 num_channels++; 2734 } 2735 } 2736 } 2737 if (BAND_6G_PRESENT(band_mask)) { 2738 for (i = MIN_6GHZ_CHANNEL; i <= MAX_6GHZ_CHANNEL; i++) { 2739 if ((cur_chan_list[i].state != CHANNEL_STATE_DISABLE) && 2740 !(cur_chan_list[i].chan_flags & 2741 REGULATORY_CHAN_DISABLED)) { 2742 channel_list[num_channels] = cur_chan_list[i]; 2743 num_channels++; 2744 } 2745 } 2746 } 2747 2748 if (!num_channels) { 2749 reg_err("Failed to retrieve the channel list"); 2750 return 0; 2751 } 2752 2753 return num_channels; 2754 } 2755 2756 qdf_freq_t reg_chan_band_to_freq(struct wlan_objmgr_pdev *pdev, 2757 uint8_t chan_num, 2758 uint8_t band_mask) 2759 { 2760 enum channel_enum min_chan, max_chan; 2761 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 2762 uint16_t freq; 2763 2764 if (chan_num == 0) { 2765 reg_err_rl("Invalid channel %d", chan_num); 2766 return 0; 2767 } 2768 2769 pdev_priv_obj = reg_get_pdev_obj(pdev); 2770 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 2771 reg_err("reg pdev priv obj is NULL"); 2772 return 0; 2773 } 2774 2775 if (BAND_6G_PRESENT(band_mask)) { 2776 if (BAND_2G_PRESENT(band_mask) || 2777 BAND_5G_PRESENT(band_mask)) { 2778 reg_err_rl("Incorrect band_mask %x", band_mask); 2779 return 0; 2780 } 2781 2782 min_chan = MIN_6GHZ_CHANNEL; 2783 max_chan = MAX_6GHZ_CHANNEL; 2784 return reg_compute_chan_to_freq(pdev, chan_num, 2785 min_chan, 2786 max_chan); 2787 } else { 2788 if (BAND_2G_PRESENT(band_mask)) { 2789 min_chan = MIN_24GHZ_CHANNEL; 2790 max_chan = MAX_24GHZ_CHANNEL; 2791 freq = reg_compute_chan_to_freq(pdev, chan_num, 2792 min_chan, 2793 max_chan); 2794 if (freq != 0) 2795 return freq; 2796 } 2797 2798 if (BAND_5G_PRESENT(band_mask)) { 2799 min_chan = BAND_5GHZ_START_CHANNEL; 2800 max_chan = MAX_5GHZ_CHANNEL; 2801 2802 return reg_compute_chan_to_freq(pdev, chan_num, 2803 min_chan, 2804 max_chan); 2805 } 2806 2807 reg_err_rl("Incorrect band_mask %x", band_mask); 2808 return 0; 2809 } 2810 } 2811 2812 #ifdef CONFIG_49GHZ_CHAN 2813 bool reg_is_49ghz_freq(qdf_freq_t freq) 2814 { 2815 return REG_IS_49GHZ_FREQ(freq); 2816 } 2817 #endif /* CONFIG_49GHZ_CHAN */ 2818 2819 qdf_freq_t reg_ch_num(uint32_t ch_enum) 2820 { 2821 return REG_CH_NUM(ch_enum); 2822 } 2823 2824 qdf_freq_t reg_ch_to_freq(uint32_t ch_enum) 2825 { 2826 return REG_CH_TO_FREQ(ch_enum); 2827 } 2828 2829 #ifdef CONFIG_CHAN_NUM_API 2830 bool reg_is_same_band_channels(uint8_t chan_num1, uint8_t chan_num2) 2831 { 2832 return (chan_num1 && chan_num2 && 2833 (REG_IS_5GHZ_CH(chan_num1) == REG_IS_5GHZ_CH(chan_num2))); 2834 } 2835 2836 bool reg_is_channel_valid_5g_sbs(uint8_t curchan, uint8_t newchan) 2837 { 2838 return REG_IS_CHANNEL_VALID_5G_SBS(curchan, newchan); 2839 } 2840 2841 uint8_t reg_min_24ghz_ch_num(void) 2842 { 2843 return REG_MIN_24GHZ_CH_NUM; 2844 } 2845 2846 uint8_t reg_max_24ghz_ch_num(void) 2847 { 2848 return REG_MAX_24GHZ_CH_NUM; 2849 } 2850 2851 uint8_t reg_min_5ghz_ch_num(void) 2852 { 2853 return REG_MIN_5GHZ_CH_NUM; 2854 } 2855 2856 uint8_t reg_max_5ghz_ch_num(void) 2857 { 2858 return REG_MAX_5GHZ_CH_NUM; 2859 } 2860 #endif /* CONFIG_CHAN_NUM_API */ 2861 2862 #ifdef CONFIG_CHAN_FREQ_API 2863 qdf_freq_t reg_min_24ghz_chan_freq(void) 2864 { 2865 return REG_MIN_24GHZ_CH_FREQ; 2866 } 2867 2868 qdf_freq_t reg_max_24ghz_chan_freq(void) 2869 { 2870 return REG_MAX_24GHZ_CH_FREQ; 2871 } 2872 2873 qdf_freq_t reg_min_5ghz_chan_freq(void) 2874 { 2875 return REG_MIN_5GHZ_CH_FREQ; 2876 } 2877 2878 qdf_freq_t reg_max_5ghz_chan_freq(void) 2879 { 2880 return REG_MAX_5GHZ_CH_FREQ; 2881 } 2882 #endif /* CONFIG_CHAN_FREQ_API */ 2883 2884 QDF_STATUS reg_enable_dfs_channels(struct wlan_objmgr_pdev *pdev, 2885 bool enable) 2886 { 2887 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 2888 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 2889 struct wlan_objmgr_psoc *psoc; 2890 QDF_STATUS status; 2891 struct wlan_lmac_if_reg_tx_ops *reg_tx_ops; 2892 2893 pdev_priv_obj = reg_get_pdev_obj(pdev); 2894 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 2895 reg_err("pdev reg component is NULL"); 2896 return QDF_STATUS_E_INVAL; 2897 } 2898 2899 if (pdev_priv_obj->dfs_enabled == enable) { 2900 reg_info("dfs_enabled is already set to %d", enable); 2901 return QDF_STATUS_SUCCESS; 2902 } 2903 2904 psoc = wlan_pdev_get_psoc(pdev); 2905 if (!psoc) { 2906 reg_err("psoc is NULL"); 2907 return QDF_STATUS_E_INVAL; 2908 } 2909 2910 psoc_priv_obj = reg_get_psoc_obj(psoc); 2911 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 2912 reg_err("psoc reg component is NULL"); 2913 return QDF_STATUS_E_INVAL; 2914 } 2915 2916 reg_info("set dfs_enabled: %d", enable); 2917 2918 pdev_priv_obj->dfs_enabled = enable; 2919 2920 reg_compute_pdev_current_chan_list(pdev_priv_obj); 2921 2922 reg_tx_ops = reg_get_psoc_tx_ops(psoc); 2923 2924 /* Fill the ic channel list with the updated current channel 2925 * chan list. 2926 */ 2927 if (reg_tx_ops->fill_umac_legacy_chanlist) 2928 reg_tx_ops->fill_umac_legacy_chanlist(pdev, 2929 pdev_priv_obj->cur_chan_list); 2930 2931 status = reg_send_scheduler_msg_sb(psoc, pdev); 2932 2933 return status; 2934 } 2935 2936 bool reg_is_regdmn_en302502_applicable(struct wlan_objmgr_pdev *pdev) 2937 { 2938 struct cur_regdmn_info cur_reg_dmn; 2939 QDF_STATUS status; 2940 2941 status = reg_get_curr_regdomain(pdev, &cur_reg_dmn); 2942 if (status != QDF_STATUS_SUCCESS) { 2943 reg_err("Failed to get reg domain"); 2944 return false; 2945 } 2946 2947 return reg_en302_502_regdmn(cur_reg_dmn.regdmn_pair_id); 2948 } 2949 2950 QDF_STATUS reg_get_phybitmap(struct wlan_objmgr_pdev *pdev, 2951 uint16_t *phybitmap) 2952 { 2953 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 2954 2955 pdev_priv_obj = reg_get_pdev_obj(pdev); 2956 2957 if (!pdev_priv_obj) { 2958 reg_err("reg pdev private obj is NULL"); 2959 return QDF_STATUS_E_FAULT; 2960 } 2961 2962 *phybitmap = pdev_priv_obj->phybitmap; 2963 2964 return QDF_STATUS_SUCCESS; 2965 } 2966 2967 QDF_STATUS reg_modify_pdev_chan_range(struct wlan_objmgr_pdev *pdev) 2968 { 2969 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 2970 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 2971 struct wlan_objmgr_psoc *psoc; 2972 struct wlan_lmac_if_reg_tx_ops *reg_tx_ops; 2973 struct wlan_psoc_host_hal_reg_capabilities_ext *reg_cap_ptr; 2974 uint32_t cnt; 2975 uint32_t phy_id; 2976 enum direction dir; 2977 QDF_STATUS status = QDF_STATUS_SUCCESS; 2978 struct target_pdev_info *tgt_pdev; 2979 2980 tgt_pdev = wlan_pdev_get_tgt_if_handle(pdev); 2981 phy_id = (uint32_t)target_pdev_get_phy_idx(tgt_pdev); 2982 pdev_priv_obj = reg_get_pdev_obj(pdev); 2983 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 2984 reg_err("pdev reg component is NULL"); 2985 return QDF_STATUS_E_INVAL; 2986 } 2987 2988 psoc = wlan_pdev_get_psoc(pdev); 2989 if (!psoc) { 2990 reg_err("psoc is NULL"); 2991 return QDF_STATUS_E_INVAL; 2992 } 2993 2994 psoc_priv_obj = reg_get_psoc_obj(psoc); 2995 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 2996 reg_err("psoc reg component is NULL"); 2997 return QDF_STATUS_E_INVAL; 2998 } 2999 3000 reg_cap_ptr = psoc_priv_obj->reg_cap; 3001 3002 for (cnt = 0; cnt < PSOC_MAX_PHY_REG_CAP; cnt++) { 3003 if (!reg_cap_ptr) { 3004 qdf_mem_free(pdev_priv_obj); 3005 reg_err("reg cap ptr is NULL"); 3006 return QDF_STATUS_E_FAULT; 3007 } 3008 3009 if (reg_cap_ptr->phy_id == phy_id) 3010 break; 3011 reg_cap_ptr++; 3012 } 3013 3014 if (cnt == PSOC_MAX_PHY_REG_CAP) { 3015 qdf_mem_free(pdev_priv_obj); 3016 reg_err("extended capabilities not found for pdev"); 3017 return QDF_STATUS_E_FAULT; 3018 } 3019 3020 if (psoc_priv_obj->offload_enabled) { 3021 dir = NORTHBOUND; 3022 } else { 3023 dir = SOUTHBOUND; 3024 } 3025 3026 pdev_priv_obj->range_2g_low = reg_cap_ptr->low_2ghz_chan; 3027 pdev_priv_obj->range_2g_high = reg_cap_ptr->high_2ghz_chan; 3028 pdev_priv_obj->range_5g_low = reg_cap_ptr->low_5ghz_chan; 3029 pdev_priv_obj->range_5g_high = reg_cap_ptr->high_5ghz_chan; 3030 pdev_priv_obj->wireless_modes = reg_cap_ptr->wireless_modes; 3031 3032 reg_compute_pdev_current_chan_list(pdev_priv_obj); 3033 3034 reg_tx_ops = reg_get_psoc_tx_ops(psoc); 3035 3036 /* Fill the ic channel list with the updated current channel 3037 * chan list. 3038 */ 3039 if (reg_tx_ops->fill_umac_legacy_chanlist) { 3040 reg_tx_ops->fill_umac_legacy_chanlist(pdev, 3041 pdev_priv_obj->cur_chan_list); 3042 3043 } else { 3044 if (dir == NORTHBOUND) 3045 status = reg_send_scheduler_msg_nb(psoc, pdev); 3046 else 3047 status = reg_send_scheduler_msg_sb(psoc, pdev); 3048 } 3049 3050 return status; 3051 } 3052 3053 QDF_STATUS reg_update_pdev_wireless_modes(struct wlan_objmgr_pdev *pdev, 3054 uint32_t wireless_modes) 3055 { 3056 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 3057 3058 pdev_priv_obj = wlan_objmgr_pdev_get_comp_private_obj(pdev, 3059 WLAN_UMAC_COMP_REGULATORY); 3060 3061 if (!pdev_priv_obj) { 3062 reg_err("reg pdev private obj is NULL"); 3063 return QDF_STATUS_E_INVAL; 3064 } 3065 3066 pdev_priv_obj->wireless_modes = wireless_modes; 3067 3068 return QDF_STATUS_SUCCESS; 3069 } 3070 3071 #ifdef DISABLE_UNII_SHARED_BANDS 3072 /** 3073 * reg_is_reg_unii_band_1_or_reg_unii_band_2a() - Check the input bitmap 3074 * @unii_5g_bitmap: 5G UNII band bitmap 3075 * 3076 * This function checks if either REG_UNII_BAND_1 or REG_UNII_BAND_2A, 3077 * are present in the 5G UNII band bitmap. 3078 * 3079 * Return: Return true if REG_UNII_BAND_1 or REG_UNII_BAND_2A, are present in 3080 * the UNII 5g bitmap else return false. 3081 */ 3082 static bool 3083 reg_is_reg_unii_band_1_or_reg_unii_band_2a(uint8_t unii_5g_bitmap) 3084 { 3085 if (!unii_5g_bitmap) 3086 return false; 3087 3088 return ((unii_5g_bitmap & (BIT(REG_UNII_BAND_1) | 3089 BIT(REG_UNII_BAND_2A))) == unii_5g_bitmap); 3090 } 3091 3092 QDF_STATUS reg_disable_chan_coex(struct wlan_objmgr_pdev *pdev, 3093 uint8_t unii_5g_bitmap) 3094 { 3095 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 3096 struct wlan_lmac_if_reg_tx_ops *reg_tx_ops; 3097 struct wlan_objmgr_psoc *psoc; 3098 3099 psoc = wlan_pdev_get_psoc(pdev); 3100 if (!psoc) { 3101 reg_err("psoc is NULL"); 3102 return QDF_STATUS_E_INVAL; 3103 } 3104 3105 pdev_priv_obj = reg_get_pdev_obj(pdev); 3106 3107 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 3108 reg_err_rl("reg pdev priv obj is NULL"); 3109 return QDF_STATUS_E_FAILURE; 3110 } 3111 3112 if (unii_5g_bitmap && 3113 !reg_is_reg_unii_band_1_or_reg_unii_band_2a(unii_5g_bitmap)) { 3114 reg_err_rl("Invalid unii_5g_bitmap = %d", unii_5g_bitmap); 3115 return QDF_STATUS_E_FAILURE; 3116 } 3117 3118 if (pdev_priv_obj->unii_5g_bitmap == unii_5g_bitmap) { 3119 reg_debug_rl("UNII bitmask for 5G channels is already set %d", 3120 unii_5g_bitmap); 3121 return QDF_STATUS_SUCCESS; 3122 } 3123 3124 reg_debug_rl("Setting UNII bitmask for 5G: %d", unii_5g_bitmap); 3125 pdev_priv_obj->unii_5g_bitmap = unii_5g_bitmap; 3126 3127 reg_compute_pdev_current_chan_list(pdev_priv_obj); 3128 3129 reg_tx_ops = reg_get_psoc_tx_ops(psoc); 3130 3131 if (reg_tx_ops->fill_umac_legacy_chanlist) { 3132 reg_tx_ops->fill_umac_legacy_chanlist(pdev, 3133 pdev_priv_obj->cur_chan_list); 3134 } 3135 3136 return QDF_STATUS_SUCCESS; 3137 } 3138 #endif 3139 3140 #ifdef CONFIG_CHAN_FREQ_API 3141 QDF_STATUS reg_get_channel_list_with_power_for_freq(struct wlan_objmgr_pdev 3142 *pdev, 3143 struct channel_power 3144 *ch_list, 3145 uint8_t *num_chan) 3146 { 3147 int i, count; 3148 struct regulatory_channel *reg_channels; 3149 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 3150 3151 if (!num_chan || !ch_list) { 3152 reg_err("chan_list or num_ch is NULL"); 3153 return QDF_STATUS_E_FAILURE; 3154 } 3155 3156 pdev_priv_obj = reg_get_pdev_obj(pdev); 3157 3158 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 3159 reg_err("reg pdev priv obj is NULL"); 3160 return QDF_STATUS_E_FAILURE; 3161 } 3162 3163 /* set the current channel list */ 3164 reg_channels = pdev_priv_obj->cur_chan_list; 3165 3166 for (i = 0, count = 0; i < NUM_CHANNELS; i++) { 3167 if (reg_channels[i].state && 3168 !(reg_channels[i].chan_flags & REGULATORY_CHAN_DISABLED)) { 3169 ch_list[count].center_freq = 3170 reg_channels[i].center_freq; 3171 ch_list[count].chan_num = reg_channels[i].chan_num; 3172 ch_list[count++].tx_power = 3173 reg_channels[i].tx_power; 3174 } 3175 } 3176 3177 *num_chan = count; 3178 3179 return QDF_STATUS_SUCCESS; 3180 } 3181 3182 enum channel_enum reg_get_chan_enum_for_freq(qdf_freq_t freq) 3183 { 3184 uint32_t count; 3185 3186 for (count = 0; count < NUM_CHANNELS; count++) 3187 if (channel_map[count].center_freq == freq) 3188 return count; 3189 3190 reg_err_rl("invalid channel center frequency %d", freq); 3191 3192 return INVALID_CHANNEL; 3193 } 3194 3195 bool 3196 reg_is_freq_present_in_cur_chan_list(struct wlan_objmgr_pdev *pdev, 3197 qdf_freq_t freq) 3198 { 3199 enum channel_enum chan_enum; 3200 struct regulatory_channel *cur_chan_list; 3201 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 3202 3203 pdev_priv_obj = reg_get_pdev_obj(pdev); 3204 3205 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 3206 reg_err_rl("pdev reg obj is NULL"); 3207 return false; 3208 } 3209 3210 cur_chan_list = pdev_priv_obj->cur_chan_list; 3211 3212 for (chan_enum = 0; chan_enum < NUM_CHANNELS; chan_enum++) 3213 if (cur_chan_list[chan_enum].center_freq == freq) 3214 if ((cur_chan_list[chan_enum].state != 3215 CHANNEL_STATE_DISABLE) && 3216 !(cur_chan_list[chan_enum].chan_flags & 3217 REGULATORY_CHAN_DISABLED)) 3218 return true; 3219 3220 reg_debug_rl("Channel center frequency %d not found", freq); 3221 3222 return false; 3223 } 3224 3225 enum channel_state reg_get_channel_state_for_freq(struct wlan_objmgr_pdev *pdev, 3226 qdf_freq_t freq) 3227 { 3228 enum channel_enum ch_idx; 3229 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 3230 3231 ch_idx = reg_get_chan_enum_for_freq(freq); 3232 3233 if (ch_idx == INVALID_CHANNEL) 3234 return CHANNEL_STATE_INVALID; 3235 3236 pdev_priv_obj = reg_get_pdev_obj(pdev); 3237 3238 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 3239 reg_err("pdev reg obj is NULL"); 3240 return CHANNEL_STATE_INVALID; 3241 } 3242 3243 return pdev_priv_obj->cur_chan_list[ch_idx].state; 3244 } 3245 3246 static uint32_t reg_get_channel_flags_for_freq(struct wlan_objmgr_pdev *pdev, 3247 qdf_freq_t freq) 3248 { 3249 enum channel_enum chan_enum; 3250 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 3251 3252 chan_enum = reg_get_chan_enum_for_freq(freq); 3253 3254 if (chan_enum == INVALID_CHANNEL) { 3255 reg_err("chan freq is not valid"); 3256 return REGULATORY_CHAN_INVALID; 3257 } 3258 3259 pdev_priv_obj = reg_get_pdev_obj(pdev); 3260 3261 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 3262 reg_err("pdev reg obj is NULL"); 3263 return REGULATORY_CHAN_INVALID; 3264 } 3265 3266 return pdev_priv_obj->cur_chan_list[chan_enum].chan_flags; 3267 } 3268 3269 /** 3270 * reg_get_5g_bonded_chan_array_for_freq()- Return the channel state for a 3271 * 5G or 6G channel frequency based on the bonded channel. 3272 * @pdev: Pointer to pdev. 3273 * @freq: Channel center frequency. 3274 * @bonded_chan_ar: Array of bonded channel frequencies. 3275 * @array_size: Array size. 3276 * @bonded_chan_ptr_ptr: Pointer to bonded_channel_freq. 3277 * 3278 * Return: Channel State 3279 */ 3280 static enum channel_state 3281 reg_get_5g_bonded_chan_array_for_freq(struct wlan_objmgr_pdev *pdev, 3282 uint16_t freq, 3283 const struct bonded_channel_freq 3284 bonded_chan_ar[], 3285 uint16_t array_size, 3286 const struct bonded_channel_freq 3287 **bonded_chan_ptr_ptr) 3288 { 3289 int i; 3290 uint16_t chan_cfreq; 3291 const struct bonded_channel_freq *bonded_chan_ptr = NULL; 3292 enum channel_state chan_state = CHANNEL_STATE_INVALID; 3293 enum channel_state temp_chan_state; 3294 3295 for (i = 0; i < array_size; i++) { 3296 if ((freq >= bonded_chan_ar[i].start_freq) && 3297 (freq <= bonded_chan_ar[i].end_freq)) { 3298 bonded_chan_ptr = &bonded_chan_ar[i]; 3299 break; 3300 } 3301 } 3302 3303 if (!bonded_chan_ptr) 3304 return chan_state; 3305 3306 *bonded_chan_ptr_ptr = bonded_chan_ptr; 3307 chan_cfreq = bonded_chan_ptr->start_freq; 3308 while (chan_cfreq <= bonded_chan_ptr->end_freq) { 3309 temp_chan_state = reg_get_channel_state_for_freq(pdev, 3310 chan_cfreq); 3311 if (temp_chan_state < chan_state) 3312 chan_state = temp_chan_state; 3313 chan_cfreq = chan_cfreq + 20; 3314 } 3315 3316 return chan_state; 3317 } 3318 3319 /** 3320 * reg_get_5g_bonded_channel_for_freq()- Return the channel state for a 3321 * 5G or 6G channel frequency based on the channel width and bonded channel 3322 * @pdev: Pointer to pdev. 3323 * @freq: Channel center frequency. 3324 * @ch_width: Channel Width. 3325 * @bonded_chan_ptr_ptr: Pointer to bonded_channel_freq. 3326 * 3327 * Return: Channel State 3328 */ 3329 enum channel_state 3330 reg_get_5g_bonded_channel_for_freq(struct wlan_objmgr_pdev *pdev, 3331 uint16_t freq, 3332 enum phy_ch_width ch_width, 3333 const struct bonded_channel_freq 3334 **bonded_chan_ptr_ptr) 3335 3336 { 3337 if (ch_width == CH_WIDTH_80P80MHZ) 3338 return reg_get_5g_bonded_chan_array_for_freq(pdev, freq, 3339 bonded_chan_80mhz_list_freq, 3340 QDF_ARRAY_SIZE(bonded_chan_80mhz_list_freq), 3341 bonded_chan_ptr_ptr); 3342 else if (ch_width == CH_WIDTH_160MHZ) 3343 return reg_get_5g_bonded_chan_array_for_freq(pdev, freq, 3344 bonded_chan_160mhz_list_freq, 3345 QDF_ARRAY_SIZE(bonded_chan_160mhz_list_freq), 3346 bonded_chan_ptr_ptr); 3347 else if (ch_width == CH_WIDTH_80MHZ) 3348 return reg_get_5g_bonded_chan_array_for_freq(pdev, freq, 3349 bonded_chan_80mhz_list_freq, 3350 QDF_ARRAY_SIZE(bonded_chan_80mhz_list_freq), 3351 bonded_chan_ptr_ptr); 3352 else if (ch_width == CH_WIDTH_40MHZ) 3353 return reg_get_5g_bonded_chan_array_for_freq(pdev, freq, 3354 bonded_chan_40mhz_list_freq, 3355 QDF_ARRAY_SIZE(bonded_chan_40mhz_list_freq), 3356 bonded_chan_ptr_ptr); 3357 else 3358 return reg_get_channel_state_for_freq(pdev, freq); 3359 } 3360 3361 enum channel_state 3362 reg_get_5g_bonded_channel_state_for_freq(struct wlan_objmgr_pdev *pdev, 3363 qdf_freq_t freq, 3364 enum phy_ch_width bw) 3365 { 3366 enum channel_enum ch_indx; 3367 enum channel_state chan_state; 3368 struct regulatory_channel *reg_channels; 3369 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 3370 bool bw_enabled = false; 3371 const struct bonded_channel_freq *bonded_chan_ptr = NULL; 3372 3373 if (bw > CH_WIDTH_80P80MHZ) { 3374 reg_err("bw passed is not good"); 3375 return CHANNEL_STATE_INVALID; 3376 } 3377 3378 chan_state = reg_get_5g_bonded_channel_for_freq(pdev, freq, bw, 3379 &bonded_chan_ptr); 3380 3381 if ((chan_state == CHANNEL_STATE_INVALID) || 3382 (chan_state == CHANNEL_STATE_DISABLE)) 3383 return chan_state; 3384 3385 pdev_priv_obj = reg_get_pdev_obj(pdev); 3386 3387 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 3388 reg_err("pdev reg obj is NULL"); 3389 return CHANNEL_STATE_INVALID; 3390 } 3391 reg_channels = pdev_priv_obj->cur_chan_list; 3392 3393 ch_indx = reg_get_chan_enum_for_freq(freq); 3394 if (ch_indx == INVALID_CHANNEL) 3395 return CHANNEL_STATE_INVALID; 3396 if (bw == CH_WIDTH_5MHZ) 3397 bw_enabled = true; 3398 else if (bw == CH_WIDTH_10MHZ) 3399 bw_enabled = (reg_channels[ch_indx].min_bw <= 10) && 3400 (reg_channels[ch_indx].max_bw >= 10); 3401 else if (bw == CH_WIDTH_20MHZ) 3402 bw_enabled = (reg_channels[ch_indx].min_bw <= 20) && 3403 (reg_channels[ch_indx].max_bw >= 20); 3404 else if (bw == CH_WIDTH_40MHZ) 3405 bw_enabled = (reg_channels[ch_indx].min_bw <= 40) && 3406 (reg_channels[ch_indx].max_bw >= 40); 3407 else if (bw == CH_WIDTH_80MHZ) 3408 bw_enabled = (reg_channels[ch_indx].min_bw <= 80) && 3409 (reg_channels[ch_indx].max_bw >= 80); 3410 else if (bw == CH_WIDTH_160MHZ) 3411 bw_enabled = (reg_channels[ch_indx].min_bw <= 160) && 3412 (reg_channels[ch_indx].max_bw >= 160); 3413 else if (bw == CH_WIDTH_80P80MHZ) 3414 bw_enabled = (reg_channels[ch_indx].min_bw <= 80) && 3415 (reg_channels[ch_indx].max_bw >= 80); 3416 3417 if (bw_enabled) 3418 return chan_state; 3419 else 3420 return CHANNEL_STATE_DISABLE; 3421 } 3422 3423 enum channel_state 3424 reg_get_2g_bonded_channel_state_for_freq(struct wlan_objmgr_pdev *pdev, 3425 qdf_freq_t oper_ch_freq, 3426 qdf_freq_t sec_ch_freq, 3427 enum phy_ch_width bw) 3428 { 3429 enum channel_enum chan_idx; 3430 enum channel_state chan_state; 3431 struct regulatory_channel *reg_channels; 3432 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 3433 bool bw_enabled = false; 3434 enum channel_state chan_state2 = CHANNEL_STATE_INVALID; 3435 3436 if (bw > CH_WIDTH_40MHZ) 3437 return CHANNEL_STATE_INVALID; 3438 3439 if (bw == CH_WIDTH_40MHZ) { 3440 if ((sec_ch_freq + 20 != oper_ch_freq) && 3441 (oper_ch_freq + 20 != sec_ch_freq)) 3442 return CHANNEL_STATE_INVALID; 3443 chan_state2 = reg_get_channel_state_for_freq(pdev, sec_ch_freq); 3444 if (chan_state2 == CHANNEL_STATE_INVALID) 3445 return chan_state2; 3446 } 3447 3448 pdev_priv_obj = reg_get_pdev_obj(pdev); 3449 3450 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 3451 reg_err("reg pdev priv obj is NULL"); 3452 return CHANNEL_STATE_INVALID; 3453 } 3454 3455 reg_channels = pdev_priv_obj->cur_chan_list; 3456 3457 chan_state = reg_get_channel_state_for_freq(pdev, oper_ch_freq); 3458 if (chan_state2 < chan_state) 3459 chan_state = chan_state2; 3460 3461 if ((chan_state == CHANNEL_STATE_INVALID) || 3462 (chan_state == CHANNEL_STATE_DISABLE)) 3463 return chan_state; 3464 3465 chan_idx = reg_get_chan_enum_for_freq(oper_ch_freq); 3466 if (chan_idx == INVALID_CHANNEL) 3467 return CHANNEL_STATE_INVALID; 3468 if (bw == CH_WIDTH_5MHZ) 3469 bw_enabled = true; 3470 else if (bw == CH_WIDTH_10MHZ) 3471 bw_enabled = (reg_channels[chan_idx].min_bw <= 10) && 3472 (reg_channels[chan_idx].max_bw >= 10); 3473 else if (bw == CH_WIDTH_20MHZ) 3474 bw_enabled = (reg_channels[chan_idx].min_bw <= 20) && 3475 (reg_channels[chan_idx].max_bw >= 20); 3476 else if (bw == CH_WIDTH_40MHZ) 3477 bw_enabled = (reg_channels[chan_idx].min_bw <= 40) && 3478 (reg_channels[chan_idx].max_bw >= 40); 3479 3480 if (bw_enabled) 3481 return chan_state; 3482 else 3483 return CHANNEL_STATE_DISABLE; 3484 3485 return CHANNEL_STATE_ENABLE; 3486 } 3487 3488 /** 3489 * reg_set_5g_channel_params_for_freq()- Set channel parameters like center 3490 * frequency for a bonded channel state. Also return the maximum bandwidth 3491 * supported by the channel. 3492 * @pdev: Pointer to pdev. 3493 * @freq: Channel center frequency. 3494 * ch_params: Pointer to ch_params. 3495 * 3496 * Return: void 3497 */ 3498 static void reg_set_5g_channel_params_for_freq(struct wlan_objmgr_pdev *pdev, 3499 uint16_t freq, 3500 struct ch_params *ch_params) 3501 { 3502 /* 3503 * Set channel parameters like center frequency for a bonded channel 3504 * state. Also return the maximum bandwidth supported by the channel. 3505 */ 3506 3507 enum channel_state chan_state = CHANNEL_STATE_ENABLE; 3508 enum channel_state chan_state2 = CHANNEL_STATE_ENABLE; 3509 const struct bonded_channel_freq *bonded_chan_ptr = NULL; 3510 const struct bonded_channel_freq *bonded_chan_ptr2 = NULL; 3511 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 3512 enum channel_enum chan_enum, sec_5g_chan_enum; 3513 uint16_t max_bw, bw_80, sec_5g_freq_max_bw = 0; 3514 3515 if (!ch_params) { 3516 reg_err("ch_params is NULL"); 3517 return; 3518 } 3519 3520 chan_enum = reg_get_chan_enum_for_freq(freq); 3521 if (chan_enum == INVALID_CHANNEL) { 3522 reg_err("chan freq is not valid"); 3523 return; 3524 } 3525 3526 pdev_priv_obj = reg_get_pdev_obj(pdev); 3527 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 3528 reg_err("reg pdev priv obj is NULL"); 3529 return; 3530 } 3531 3532 if (ch_params->ch_width >= CH_WIDTH_MAX) { 3533 if (ch_params->mhz_freq_seg1 != 0) 3534 ch_params->ch_width = CH_WIDTH_80P80MHZ; 3535 else 3536 ch_params->ch_width = CH_WIDTH_160MHZ; 3537 } 3538 3539 max_bw = pdev_priv_obj->cur_chan_list[chan_enum].max_bw; 3540 bw_80 = reg_get_bw_value(CH_WIDTH_80MHZ); 3541 3542 if (ch_params->ch_width == CH_WIDTH_80P80MHZ) { 3543 sec_5g_chan_enum = 3544 reg_get_chan_enum_for_freq(ch_params->mhz_freq_seg1 - 3545 NEAREST_20MHZ_CHAN_FREQ_OFFSET); 3546 if (sec_5g_chan_enum == INVALID_CHANNEL) { 3547 reg_err("secondary channel freq is not valid"); 3548 return; 3549 } 3550 3551 sec_5g_freq_max_bw = 3552 pdev_priv_obj->cur_chan_list[sec_5g_chan_enum].max_bw; 3553 } 3554 3555 while (ch_params->ch_width != CH_WIDTH_INVALID) { 3556 if (ch_params->ch_width == CH_WIDTH_80P80MHZ) { 3557 if ((max_bw < bw_80) || (sec_5g_freq_max_bw < bw_80)) 3558 goto update_bw; 3559 } else if (max_bw < reg_get_bw_value(ch_params->ch_width)) { 3560 goto update_bw; 3561 } 3562 3563 bonded_chan_ptr = NULL; 3564 bonded_chan_ptr2 = NULL; 3565 chan_state = reg_get_5g_bonded_channel_for_freq( 3566 pdev, freq, ch_params->ch_width, 3567 &bonded_chan_ptr); 3568 3569 chan_state = reg_get_5g_bonded_channel_state_for_freq( 3570 pdev, freq, ch_params->ch_width); 3571 3572 if (ch_params->ch_width == CH_WIDTH_80P80MHZ) { 3573 chan_state2 = reg_get_5g_bonded_channel_state_for_freq( 3574 pdev, ch_params->mhz_freq_seg1 - 3575 NEAREST_20MHZ_CHAN_FREQ_OFFSET, 3576 CH_WIDTH_80MHZ); 3577 3578 chan_state = reg_combine_channel_states( 3579 chan_state, chan_state2); 3580 } 3581 3582 if ((chan_state != CHANNEL_STATE_ENABLE) && 3583 (chan_state != CHANNEL_STATE_DFS)) 3584 goto update_bw; 3585 if (ch_params->ch_width <= CH_WIDTH_20MHZ) { 3586 ch_params->sec_ch_offset = NO_SEC_CH; 3587 ch_params->mhz_freq_seg0 = freq; 3588 ch_params->center_freq_seg0 = 3589 reg_freq_to_chan(pdev, 3590 ch_params->mhz_freq_seg0); 3591 break; 3592 } else if (ch_params->ch_width >= CH_WIDTH_40MHZ) { 3593 reg_get_5g_bonded_chan_array_for_freq( 3594 pdev, freq, bonded_chan_40mhz_list_freq, 3595 QDF_ARRAY_SIZE(bonded_chan_40mhz_list_freq), 3596 &bonded_chan_ptr2); 3597 if (!bonded_chan_ptr || !bonded_chan_ptr2) 3598 goto update_bw; 3599 if (freq == bonded_chan_ptr2->start_freq) 3600 ch_params->sec_ch_offset = LOW_PRIMARY_CH; 3601 else 3602 ch_params->sec_ch_offset = HIGH_PRIMARY_CH; 3603 3604 ch_params->mhz_freq_seg0 = 3605 (bonded_chan_ptr->start_freq + 3606 bonded_chan_ptr->end_freq) / 2; 3607 ch_params->center_freq_seg0 = 3608 reg_freq_to_chan(pdev, 3609 ch_params->mhz_freq_seg0); 3610 break; 3611 } 3612 update_bw: 3613 ch_params->ch_width = get_next_lower_bw[ch_params->ch_width]; 3614 } 3615 3616 if (ch_params->ch_width == CH_WIDTH_160MHZ) { 3617 ch_params->mhz_freq_seg1 = ch_params->mhz_freq_seg0; 3618 ch_params->center_freq_seg1 = 3619 reg_freq_to_chan(pdev, 3620 ch_params->mhz_freq_seg1); 3621 3622 chan_state = reg_get_5g_bonded_channel_for_freq( 3623 pdev, freq, CH_WIDTH_80MHZ, &bonded_chan_ptr); 3624 if (bonded_chan_ptr) { 3625 ch_params->mhz_freq_seg0 = 3626 (bonded_chan_ptr->start_freq + 3627 bonded_chan_ptr->end_freq) / 2; 3628 ch_params->center_freq_seg0 = 3629 reg_freq_to_chan(pdev, 3630 ch_params->mhz_freq_seg0); 3631 } 3632 } 3633 3634 /* Overwrite mhz_freq_seg1 to 0 for non 160 and 80+80 width */ 3635 if (!(ch_params->ch_width == CH_WIDTH_160MHZ || 3636 ch_params->ch_width == CH_WIDTH_80P80MHZ)) { 3637 ch_params->mhz_freq_seg1 = 0; 3638 ch_params->center_freq_seg1 = 0; 3639 } 3640 } 3641 3642 /** 3643 * reg_set_2g_channel_params_for_freq() - set the 2.4G bonded channel parameters 3644 * @oper_freq: operating channel 3645 * @ch_params: channel parameters 3646 * @sec_ch_2g_freq: 2.4G secondary channel 3647 * 3648 * Return: void 3649 */ 3650 static void reg_set_2g_channel_params_for_freq(struct wlan_objmgr_pdev *pdev, 3651 uint16_t oper_freq, 3652 struct ch_params *ch_params, 3653 uint16_t sec_ch_2g_freq) 3654 { 3655 enum channel_state chan_state = CHANNEL_STATE_ENABLE; 3656 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 3657 enum channel_enum chan_enum; 3658 uint16_t max_bw; 3659 3660 chan_enum = reg_get_chan_enum_for_freq(oper_freq); 3661 if (chan_enum == INVALID_CHANNEL) { 3662 reg_err("chan freq is not valid"); 3663 return; 3664 } 3665 3666 pdev_priv_obj = reg_get_pdev_obj(pdev); 3667 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 3668 reg_err("reg pdev priv obj is NULL"); 3669 return; 3670 } 3671 3672 if (ch_params->ch_width >= CH_WIDTH_MAX) 3673 ch_params->ch_width = CH_WIDTH_40MHZ; 3674 if ((reg_get_bw_value(ch_params->ch_width) > 20) && !sec_ch_2g_freq) { 3675 if (oper_freq >= TWOG_CHAN_1_IN_MHZ && oper_freq <= 3676 TWOG_CHAN_5_IN_MHZ) 3677 sec_ch_2g_freq = oper_freq + 20; 3678 else if (oper_freq >= TWOG_CHAN_6_IN_MHZ && oper_freq <= 3679 TWOG_CHAN_13_IN_MHZ) 3680 sec_ch_2g_freq = oper_freq - 20; 3681 } 3682 3683 max_bw = pdev_priv_obj->cur_chan_list[chan_enum].max_bw; 3684 3685 while (ch_params->ch_width != CH_WIDTH_INVALID) { 3686 if (max_bw < reg_get_bw_value(ch_params->ch_width)) 3687 goto update_bw; 3688 3689 chan_state = 3690 reg_get_2g_bonded_channel_state_for_freq(pdev, oper_freq, 3691 sec_ch_2g_freq, 3692 ch_params->ch_width); 3693 if (chan_state == CHANNEL_STATE_ENABLE) { 3694 if (ch_params->ch_width == CH_WIDTH_40MHZ) { 3695 if (oper_freq < sec_ch_2g_freq) 3696 ch_params->sec_ch_offset = 3697 LOW_PRIMARY_CH; 3698 else 3699 ch_params->sec_ch_offset = 3700 HIGH_PRIMARY_CH; 3701 ch_params->mhz_freq_seg0 = 3702 (oper_freq + sec_ch_2g_freq) / 2; 3703 if (ch_params->mhz_freq_seg0 == 3704 TWOG_CHAN_14_IN_MHZ) 3705 ch_params->center_freq_seg0 = 14; 3706 else 3707 ch_params->center_freq_seg0 = 3708 (ch_params->mhz_freq_seg0 - 3709 TWOG_STARTING_FREQ) / 3710 FREQ_TO_CHAN_SCALE; 3711 } else { 3712 ch_params->sec_ch_offset = NO_SEC_CH; 3713 ch_params->mhz_freq_seg0 = oper_freq; 3714 if (ch_params->mhz_freq_seg0 == 3715 TWOG_CHAN_14_IN_MHZ) 3716 ch_params->center_freq_seg0 = 14; 3717 else 3718 ch_params->center_freq_seg0 = 3719 (ch_params->mhz_freq_seg0 - 3720 TWOG_STARTING_FREQ) / 3721 FREQ_TO_CHAN_SCALE; 3722 } 3723 break; 3724 } 3725 update_bw: 3726 ch_params->ch_width = get_next_lower_bw[ch_params->ch_width]; 3727 } 3728 /* Overwrite mhz_freq_seg1 and center_freq_seg1 to 0 for 2.4 Ghz */ 3729 ch_params->mhz_freq_seg1 = 0; 3730 ch_params->center_freq_seg1 = 0; 3731 } 3732 3733 void reg_set_channel_params_for_freq(struct wlan_objmgr_pdev *pdev, 3734 qdf_freq_t freq, 3735 qdf_freq_t sec_ch_2g_freq, 3736 struct ch_params *ch_params) 3737 { 3738 if (reg_is_5ghz_ch_freq(freq) || reg_is_6ghz_chan_freq(freq)) 3739 reg_set_5g_channel_params_for_freq(pdev, freq, ch_params); 3740 else if (reg_is_24ghz_ch_freq(freq)) 3741 reg_set_2g_channel_params_for_freq(pdev, freq, ch_params, 3742 sec_ch_2g_freq); 3743 } 3744 3745 uint8_t reg_get_channel_reg_power_for_freq(struct wlan_objmgr_pdev *pdev, 3746 qdf_freq_t freq) 3747 { 3748 enum channel_enum chan_enum; 3749 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 3750 struct regulatory_channel *reg_channels; 3751 3752 chan_enum = reg_get_chan_enum_for_freq(freq); 3753 3754 if (chan_enum == INVALID_CHANNEL) { 3755 reg_err("channel is invalid"); 3756 return REG_INVALID_TXPOWER; 3757 } 3758 3759 pdev_priv_obj = reg_get_pdev_obj(pdev); 3760 3761 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 3762 reg_err("reg pdev priv obj is NULL"); 3763 return REG_INVALID_TXPOWER; 3764 } 3765 3766 reg_channels = pdev_priv_obj->cur_chan_list; 3767 3768 return reg_channels[chan_enum].tx_power; 3769 } 3770 3771 bool reg_is_dfs_for_freq(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq) 3772 { 3773 uint32_t chan_flags; 3774 3775 chan_flags = reg_get_channel_flags_for_freq(pdev, freq); 3776 3777 return chan_flags & REGULATORY_CHAN_RADAR; 3778 } 3779 3780 #ifdef CONFIG_REG_CLIENT 3781 /** 3782 * reg_get_psoc_mas_chan_list () - Get psoc master channel list 3783 * @pdev: pointer to pdev object 3784 * @psoc: pointer to psoc object 3785 * 3786 * Return: psoc master chanel list 3787 */ 3788 static struct regulatory_channel *reg_get_psoc_mas_chan_list( 3789 struct wlan_objmgr_pdev *pdev, 3790 struct wlan_objmgr_psoc *psoc) 3791 { 3792 struct wlan_regulatory_psoc_priv_obj *soc_reg; 3793 uint8_t pdev_id; 3794 uint8_t phy_id; 3795 struct wlan_lmac_if_reg_tx_ops *reg_tx_ops; 3796 3797 soc_reg = reg_get_psoc_obj(psoc); 3798 if (!soc_reg) { 3799 reg_err("reg psoc private obj is NULL"); 3800 return NULL; 3801 } 3802 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 3803 3804 reg_tx_ops = reg_get_psoc_tx_ops(psoc); 3805 if (reg_tx_ops->get_phy_id_from_pdev_id) 3806 reg_tx_ops->get_phy_id_from_pdev_id(psoc, pdev_id, &phy_id); 3807 else 3808 phy_id = pdev_id; 3809 3810 return soc_reg->mas_chan_params[phy_id].mas_chan_list; 3811 } 3812 #else 3813 static inline struct regulatory_channel *reg_get_psoc_mas_chan_list( 3814 struct wlan_objmgr_pdev *pdev, 3815 struct wlan_objmgr_psoc *psoc) 3816 { 3817 return NULL; 3818 } 3819 #endif 3820 3821 void reg_update_nol_ch_for_freq(struct wlan_objmgr_pdev *pdev, 3822 uint16_t *chan_freq_list, 3823 uint8_t num_chan, 3824 bool nol_chan) 3825 { 3826 enum channel_enum chan_enum; 3827 struct regulatory_channel *mas_chan_list, *psoc_mas_chan_list; 3828 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 3829 struct wlan_objmgr_psoc *psoc; 3830 uint16_t i; 3831 3832 if (!num_chan || !chan_freq_list) { 3833 reg_err("chan_freq_list or num_ch is NULL"); 3834 return; 3835 } 3836 3837 psoc = wlan_pdev_get_psoc(pdev); 3838 3839 pdev_priv_obj = reg_get_pdev_obj(pdev); 3840 if (!pdev_priv_obj) { 3841 reg_err("reg pdev private obj is NULL"); 3842 return; 3843 } 3844 3845 psoc_mas_chan_list = reg_get_psoc_mas_chan_list(pdev, psoc); 3846 3847 mas_chan_list = pdev_priv_obj->mas_chan_list; 3848 for (i = 0; i < num_chan; i++) { 3849 chan_enum = reg_get_chan_enum_for_freq(chan_freq_list[i]); 3850 if (chan_enum == INVALID_CHANNEL) { 3851 reg_err("Invalid freq in nol list, freq %d", 3852 chan_freq_list[i]); 3853 continue; 3854 } 3855 mas_chan_list[chan_enum].nol_chan = nol_chan; 3856 if (psoc_mas_chan_list) 3857 psoc_mas_chan_list[chan_enum].nol_chan = nol_chan; 3858 } 3859 3860 reg_compute_pdev_current_chan_list(pdev_priv_obj); 3861 3862 reg_send_scheduler_msg_sb(psoc, pdev); 3863 } 3864 3865 void reg_update_nol_history_ch_for_freq(struct wlan_objmgr_pdev *pdev, 3866 uint16_t *chan_list, 3867 uint8_t num_chan, 3868 bool nol_history_chan) 3869 { 3870 enum channel_enum chan_enum; 3871 struct regulatory_channel *mas_chan_list; 3872 struct regulatory_channel *cur_chan_list; 3873 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 3874 uint16_t i; 3875 3876 if (!num_chan || !chan_list) { 3877 reg_err("chan_list or num_ch is NULL"); 3878 return; 3879 } 3880 3881 pdev_priv_obj = wlan_objmgr_pdev_get_comp_private_obj( 3882 pdev, WLAN_UMAC_COMP_REGULATORY); 3883 3884 if (!pdev_priv_obj) { 3885 reg_err("reg psoc private obj is NULL"); 3886 return; 3887 } 3888 3889 mas_chan_list = pdev_priv_obj->mas_chan_list; 3890 cur_chan_list = pdev_priv_obj->cur_chan_list; 3891 3892 for (i = 0; i < num_chan; i++) { 3893 chan_enum = reg_get_chan_enum_for_freq(chan_list[i]); 3894 if (chan_enum == INVALID_CHANNEL) { 3895 reg_err("Invalid ch in nol list, chan %d", 3896 chan_list[i]); 3897 continue; 3898 } 3899 mas_chan_list[chan_enum].nol_history = nol_history_chan; 3900 cur_chan_list[chan_enum].nol_history = nol_history_chan; 3901 } 3902 } 3903 3904 static inline bool REG_IS_FREQUENCY_VALID_5G_SBS(qdf_freq_t curfreq, 3905 qdf_freq_t newfreq) 3906 { 3907 return ((curfreq) > (newfreq) ? 3908 REG_CH_TO_FREQ(reg_get_chan_enum_for_freq(curfreq)) 3909 - REG_CH_TO_FREQ(reg_get_chan_enum_for_freq(newfreq)) 3910 > REG_SBS_SEPARATION_THRESHOLD : 3911 REG_CH_TO_FREQ(reg_get_chan_enum_for_freq(newfreq)) 3912 - REG_CH_TO_FREQ(reg_get_chan_enum_for_freq(curfreq)) 3913 > REG_SBS_SEPARATION_THRESHOLD); 3914 } 3915 3916 bool reg_is_frequency_valid_5g_sbs(qdf_freq_t curfreq, qdf_freq_t newfreq) 3917 { 3918 return REG_IS_FREQUENCY_VALID_5G_SBS(curfreq, newfreq); 3919 } 3920 3921 qdf_freq_t reg_min_chan_freq(void) 3922 { 3923 return channel_map[MIN_24GHZ_CHANNEL].center_freq; 3924 } 3925 3926 qdf_freq_t reg_max_chan_freq(void) 3927 { 3928 return channel_map[NUM_CHANNELS - 1].center_freq; 3929 } 3930 3931 bool reg_is_same_band_freqs(qdf_freq_t freq1, qdf_freq_t freq2) 3932 { 3933 return (freq1 && freq2 && ((REG_IS_6GHZ_FREQ(freq1) && 3934 REG_IS_6GHZ_FREQ(freq2)) || 3935 (REG_IS_5GHZ_FREQ(freq1) && 3936 REG_IS_5GHZ_FREQ(freq2)) || 3937 (REG_IS_24GHZ_CH_FREQ(freq1) && 3938 REG_IS_24GHZ_CH_FREQ(freq2)))); 3939 } 3940 3941 enum reg_wifi_band reg_freq_to_band(qdf_freq_t freq) 3942 { 3943 if (REG_IS_24GHZ_CH_FREQ(freq)) 3944 return REG_BAND_2G; 3945 else if (REG_IS_5GHZ_FREQ(freq) || REG_IS_49GHZ_FREQ(freq)) 3946 return REG_BAND_5G; 3947 else if (REG_IS_6GHZ_FREQ(freq)) 3948 return REG_BAND_6G; 3949 return REG_BAND_UNKNOWN; 3950 } 3951 3952 bool reg_is_disable_for_freq(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq) 3953 { 3954 enum channel_state ch_state; 3955 3956 ch_state = reg_get_channel_state_for_freq(pdev, freq); 3957 3958 return ch_state == CHANNEL_STATE_DISABLE; 3959 } 3960 3961 bool reg_is_passive_for_freq(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq) 3962 { 3963 uint32_t chan_flags; 3964 3965 chan_flags = reg_get_channel_flags_for_freq(pdev, freq); 3966 3967 return chan_flags & REGULATORY_CHAN_NO_IR; 3968 } 3969 #endif /* CONFIG_CHAN_FREQ_API */ 3970 3971 uint8_t reg_get_max_tx_power(struct wlan_objmgr_pdev *pdev) 3972 { 3973 struct regulatory_channel *cur_chan_list; 3974 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 3975 uint8_t i, max_tx_power = 0; 3976 3977 pdev_priv_obj = reg_get_pdev_obj(pdev); 3978 3979 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 3980 reg_err("reg pdev private obj is NULL"); 3981 return QDF_STATUS_E_FAILURE; 3982 } 3983 3984 cur_chan_list = pdev_priv_obj->cur_chan_list; 3985 3986 for (i = 0; i < NUM_CHANNELS; i++) { 3987 if (cur_chan_list[i].state != CHANNEL_STATE_DISABLE && 3988 cur_chan_list[i].chan_flags != REGULATORY_CHAN_DISABLED) { 3989 if (cur_chan_list[i].tx_power > max_tx_power) 3990 max_tx_power = cur_chan_list[i].tx_power; 3991 } 3992 } 3993 3994 if (!max_tx_power) 3995 reg_err_rl("max_tx_power is zero"); 3996 3997 return max_tx_power; 3998 } 3999 4000 QDF_STATUS reg_set_ignore_fw_reg_offload_ind(struct wlan_objmgr_psoc *psoc) 4001 { 4002 struct wlan_regulatory_psoc_priv_obj *psoc_reg; 4003 4004 psoc_reg = reg_get_psoc_obj(psoc); 4005 if (!IS_VALID_PSOC_REG_OBJ(psoc_reg)) { 4006 reg_err("psoc reg component is NULL"); 4007 return QDF_STATUS_E_INVAL; 4008 } 4009 4010 psoc_reg->ignore_fw_reg_offload_ind = true; 4011 return QDF_STATUS_SUCCESS; 4012 } 4013 4014 bool reg_get_ignore_fw_reg_offload_ind(struct wlan_objmgr_psoc *psoc) 4015 { 4016 struct wlan_regulatory_psoc_priv_obj *psoc_reg; 4017 4018 psoc_reg = reg_get_psoc_obj(psoc); 4019 if (!IS_VALID_PSOC_REG_OBJ(psoc_reg)) 4020 return false; 4021 4022 return psoc_reg->ignore_fw_reg_offload_ind; 4023 } 4024 4025 QDF_STATUS reg_set_6ghz_supported(struct wlan_objmgr_psoc *psoc, bool val) 4026 { 4027 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 4028 4029 psoc_priv_obj = reg_get_psoc_obj(psoc); 4030 4031 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 4032 reg_err("psoc reg component is NULL"); 4033 return QDF_STATUS_E_FAILURE; 4034 } 4035 4036 psoc_priv_obj->six_ghz_supported = val; 4037 4038 return QDF_STATUS_SUCCESS; 4039 } 4040 4041 QDF_STATUS 4042 reg_set_5dot9_ghz_supported(struct wlan_objmgr_psoc *psoc, bool val) 4043 { 4044 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 4045 4046 psoc_priv_obj = reg_get_psoc_obj(psoc); 4047 4048 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 4049 reg_err("psoc reg component is NULL"); 4050 return QDF_STATUS_E_FAILURE; 4051 } 4052 4053 psoc_priv_obj->five_dot_nine_ghz_supported = val; 4054 4055 return QDF_STATUS_SUCCESS; 4056 } 4057 4058 #ifdef CONFIG_REG_CLIENT 4059 bool reg_is_6ghz_supported(struct wlan_objmgr_psoc *psoc) 4060 { 4061 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 4062 4063 psoc_priv_obj = reg_get_psoc_obj(psoc); 4064 4065 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 4066 reg_err("psoc reg component is NULL"); 4067 return false; 4068 } 4069 4070 return psoc_priv_obj->six_ghz_supported; 4071 } 4072 #endif 4073 4074 bool reg_is_5dot9_ghz_supported(struct wlan_objmgr_psoc *psoc) 4075 { 4076 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 4077 4078 psoc_priv_obj = reg_get_psoc_obj(psoc); 4079 4080 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 4081 reg_err("psoc reg component is NULL"); 4082 return false; 4083 } 4084 4085 return psoc_priv_obj->five_dot_nine_ghz_supported; 4086 } 4087 4088 bool reg_is_fcc_regdmn(struct wlan_objmgr_pdev *pdev) 4089 { 4090 struct cur_regdmn_info cur_reg_dmn; 4091 QDF_STATUS status; 4092 4093 status = reg_get_curr_regdomain(pdev, &cur_reg_dmn); 4094 if (status != QDF_STATUS_SUCCESS) { 4095 reg_err_rl("Failed to get reg domain"); 4096 return false; 4097 } 4098 4099 return reg_fcc_regdmn(cur_reg_dmn.dmn_id_5g); 4100 } 4101 4102 bool reg_is_5dot9_ghz_freq(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq) 4103 { 4104 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 4105 4106 pdev_priv_obj = reg_get_pdev_obj(pdev); 4107 4108 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 4109 reg_err("reg pdev priv obj is NULL"); 4110 return false; 4111 } 4112 4113 return (freq >= channel_map_us[MIN_5DOT9_CHANNEL].center_freq && 4114 freq <= channel_map_us[MAX_5DOT9_CHANNEL].center_freq); 4115 } 4116 4117 bool reg_is_5dot9_ghz_chan_allowed_master_mode(struct wlan_objmgr_pdev *pdev) 4118 { 4119 struct wlan_objmgr_psoc *psoc; 4120 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 4121 4122 if (!pdev) { 4123 reg_alert("pdev is NULL"); 4124 return true; 4125 } 4126 psoc = wlan_pdev_get_psoc(pdev); 4127 4128 psoc_priv_obj = reg_get_psoc_obj(psoc); 4129 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 4130 reg_alert("psoc reg component is NULL"); 4131 return true; 4132 } 4133 4134 return psoc_priv_obj->enable_5dot9_ghz_chan_in_master_mode; 4135 } 4136 4137 #ifdef DISABLE_UNII_SHARED_BANDS 4138 QDF_STATUS 4139 reg_get_unii_5g_bitmap(struct wlan_objmgr_pdev *pdev, uint8_t *bitmap) 4140 { 4141 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 4142 4143 pdev_priv_obj = reg_get_pdev_obj(pdev); 4144 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 4145 reg_err_rl("pdev reg component is NULL"); 4146 return QDF_STATUS_E_FAILURE; 4147 } 4148 *bitmap = pdev_priv_obj->unii_5g_bitmap; 4149 4150 return QDF_STATUS_SUCCESS; 4151 } 4152 #endif 4153 4154 #ifdef CHECK_REG_PHYMODE 4155 /** 4156 * reg_is_phymode_allowed() - Check if requested phymode is unallowed 4157 * @phy_in: phymode that the user requested 4158 * @phymode_bitmap: bitmap of unallowed phymodes for specific country 4159 * 4160 * Return: true if phymode is not allowed, else false 4161 */ 4162 static bool reg_is_phymode_unallowed(enum reg_phymode phy_in, 4163 uint32_t phymode_bitmap) 4164 { 4165 if (!phymode_bitmap) 4166 return false; 4167 4168 if (phy_in == REG_PHYMODE_11AX) 4169 return phymode_bitmap & REGULATORY_PHYMODE_NO11AX; 4170 else if (phy_in == REG_PHYMODE_11AC) 4171 return phymode_bitmap & REGULATORY_PHYMODE_NO11AC; 4172 else if (phy_in == REG_PHYMODE_11N) 4173 return phymode_bitmap & REGULATORY_CHAN_NO11N; 4174 else if (phy_in == REG_PHYMODE_11G) 4175 return phymode_bitmap & REGULATORY_PHYMODE_NO11G; 4176 else if (phy_in == REG_PHYMODE_11A) 4177 return phymode_bitmap & REGULATORY_PHYMODE_NO11A; 4178 else if (phy_in == REG_PHYMODE_11B) 4179 return phymode_bitmap & REGULATORY_PHYMODE_NO11B; 4180 else 4181 return true; 4182 4183 } 4184 4185 enum reg_phymode reg_get_max_phymode(struct wlan_objmgr_pdev *pdev, 4186 enum reg_phymode phy_in, 4187 qdf_freq_t freq) 4188 { 4189 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 4190 uint32_t phymode_bitmap; 4191 enum reg_phymode current_phymode = phy_in; 4192 4193 pdev_priv_obj = reg_get_pdev_obj(pdev); 4194 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 4195 reg_err("pdev reg component is NULL"); 4196 return REG_PHYMODE_INVALID; 4197 } 4198 4199 phymode_bitmap = pdev_priv_obj->phybitmap; 4200 4201 while (1) { 4202 if (reg_is_phymode_unallowed(current_phymode, phymode_bitmap)) { 4203 if (current_phymode == REG_PHYMODE_11N) { 4204 if (REG_IS_24GHZ_CH_FREQ(freq)) 4205 current_phymode = REG_PHYMODE_11G; 4206 else 4207 current_phymode = REG_PHYMODE_11A; 4208 } else if (current_phymode == REG_PHYMODE_11A || 4209 current_phymode == REG_PHYMODE_11B) { 4210 reg_err("Couldn't find a suitable phymode"); 4211 return REG_PHYMODE_INVALID; 4212 } else if (current_phymode > REG_PHYMODE_MAX) { 4213 reg_err("Unknown phymode"); 4214 return REG_PHYMODE_INVALID; 4215 } else { 4216 current_phymode--; 4217 } 4218 } else { 4219 return current_phymode; 4220 } 4221 } 4222 } 4223 #endif /* CHECK_REG_PHYMODE */ 4224 4225 #ifdef CONFIG_REG_CLIENT 4226 enum band_info reg_band_bitmap_to_band_info(uint32_t band_bitmap) 4227 { 4228 if ((band_bitmap & BIT(REG_BAND_2G)) && 4229 (band_bitmap & BIT(REG_BAND_5G)) && 4230 (band_bitmap & BIT(REG_BAND_6G))) 4231 return BAND_ALL; 4232 else if ((band_bitmap & BIT(REG_BAND_5G)) && 4233 (band_bitmap & BIT(REG_BAND_6G))) 4234 return BAND_5G; 4235 else if ((band_bitmap & BIT(REG_BAND_2G)) && 4236 (band_bitmap & BIT(REG_BAND_6G))) 4237 return BAND_2G; 4238 else if ((band_bitmap & BIT(REG_BAND_2G)) && 4239 (band_bitmap & BIT(REG_BAND_5G))) 4240 return BAND_ALL; 4241 else if (band_bitmap & BIT(REG_BAND_2G)) 4242 return BAND_2G; 4243 else if (band_bitmap & BIT(REG_BAND_5G)) 4244 return BAND_5G; 4245 else if (band_bitmap & BIT(REG_BAND_6G)) 4246 return BAND_2G; 4247 else 4248 return BAND_UNKNOWN; 4249 } 4250 #endif 4251 4252 #if defined(CONFIG_BAND_6GHZ) 4253 QDF_STATUS 4254 reg_set_cur_6g_ap_pwr_type(struct wlan_objmgr_pdev *pdev, 4255 enum reg_6g_ap_type reg_cur_6g_ap_pwr_type) 4256 { 4257 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 4258 4259 pdev_priv_obj = reg_get_pdev_obj(pdev); 4260 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 4261 reg_err("pdev reg component is NULL"); 4262 return QDF_STATUS_E_FAILURE; 4263 } 4264 4265 if (reg_cur_6g_ap_pwr_type > REG_MAX_SUPP_AP_TYPE) { 4266 reg_err("Unsupported 6G AP power type"); 4267 return QDF_STATUS_E_FAILURE; 4268 } 4269 /* should we validate the input reg_cur_6g_ap_type? */ 4270 pdev_priv_obj->reg_cur_6g_ap_pwr_type = reg_cur_6g_ap_pwr_type; 4271 return QDF_STATUS_SUCCESS; 4272 } 4273 4274 QDF_STATUS 4275 reg_get_cur_6g_ap_pwr_type(struct wlan_objmgr_pdev *pdev, 4276 enum reg_6g_ap_type *reg_cur_6g_ap_pwr_type) 4277 { 4278 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 4279 4280 pdev_priv_obj = reg_get_pdev_obj(pdev); 4281 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 4282 reg_err("pdev reg component is NULL"); 4283 return QDF_STATUS_E_FAILURE; 4284 } 4285 *reg_cur_6g_ap_pwr_type = pdev_priv_obj->reg_cur_6g_ap_pwr_type; 4286 return QDF_STATUS_SUCCESS; 4287 } 4288 4289 QDF_STATUS 4290 reg_get_cur_6g_client_type(struct wlan_objmgr_pdev *pdev, 4291 enum reg_6g_client_type 4292 *reg_cur_6g_client_mobility_type) 4293 { 4294 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 4295 4296 pdev_priv_obj = reg_get_pdev_obj(pdev); 4297 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 4298 reg_err("pdev reg component is NULL"); 4299 return QDF_STATUS_E_FAILURE; 4300 } 4301 *reg_cur_6g_client_mobility_type = 4302 pdev_priv_obj->reg_cur_6g_client_mobility_type; 4303 return QDF_STATUS_SUCCESS; 4304 } 4305 4306 QDF_STATUS reg_get_rnr_tpe_usable(struct wlan_objmgr_pdev *pdev, 4307 bool *reg_rnr_tpe_usable) 4308 { 4309 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 4310 4311 pdev_priv_obj = reg_get_pdev_obj(pdev); 4312 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 4313 reg_err("pdev reg component is NULL"); 4314 return QDF_STATUS_E_FAILURE; 4315 } 4316 *reg_rnr_tpe_usable = pdev_priv_obj->reg_rnr_tpe_usable; 4317 return QDF_STATUS_SUCCESS; 4318 } 4319 4320 QDF_STATUS reg_get_unspecified_ap_usable(struct wlan_objmgr_pdev *pdev, 4321 bool *reg_unspecified_ap_usable) 4322 { 4323 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 4324 4325 pdev_priv_obj = reg_get_pdev_obj(pdev); 4326 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 4327 reg_err("pdev reg component is NULL"); 4328 return QDF_STATUS_E_FAILURE; 4329 } 4330 *reg_unspecified_ap_usable = pdev_priv_obj->reg_unspecified_ap_usable; 4331 return QDF_STATUS_SUCCESS; 4332 } 4333 #endif 4334