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 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 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 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 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 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 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 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 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 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 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 QDF_STATUS reg_get_channel_list_with_power(struct wlan_objmgr_pdev *pdev, 1096 struct channel_power *ch_list, 1097 uint8_t *num_chan) 1098 { 1099 int i, count; 1100 struct regulatory_channel *reg_channels; 1101 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1102 1103 if (!num_chan || !ch_list) { 1104 reg_err("chan_list or num_ch is NULL"); 1105 return QDF_STATUS_E_FAILURE; 1106 } 1107 1108 pdev_priv_obj = reg_get_pdev_obj(pdev); 1109 1110 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 1111 reg_err("reg pdev priv obj is NULL"); 1112 return QDF_STATUS_E_FAILURE; 1113 } 1114 1115 /* set the current channel list */ 1116 reg_channels = pdev_priv_obj->cur_chan_list; 1117 1118 for (i = 0, count = 0; i < NUM_CHANNELS; i++) { 1119 if (reg_channels[i].state && 1120 reg_channels[i].chan_flags != REGULATORY_CHAN_DISABLED) { 1121 ch_list[count].chan_num = 1122 reg_channels[i].chan_num; 1123 ch_list[count].center_freq = 1124 reg_channels[i].center_freq; 1125 ch_list[count++].tx_power = 1126 reg_channels[i].tx_power; 1127 } 1128 } 1129 1130 *num_chan = count; 1131 1132 return QDF_STATUS_SUCCESS; 1133 } 1134 1135 #ifdef CONFIG_CHAN_NUM_API 1136 enum channel_enum reg_get_chan_enum(uint8_t chan_num) 1137 { 1138 uint32_t count; 1139 1140 for (count = 0; count < NUM_CHANNELS; count++) 1141 if (channel_map[count].chan_num == chan_num) 1142 return count; 1143 1144 reg_err("invalid channel number %d", chan_num); 1145 1146 return INVALID_CHANNEL; 1147 } 1148 1149 enum channel_state reg_get_channel_state(struct wlan_objmgr_pdev *pdev, 1150 uint8_t ch) 1151 { 1152 enum channel_enum ch_idx; 1153 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1154 1155 ch_idx = reg_get_chan_enum(ch); 1156 1157 if (ch_idx == INVALID_CHANNEL) 1158 return CHANNEL_STATE_INVALID; 1159 1160 pdev_priv_obj = reg_get_pdev_obj(pdev); 1161 1162 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 1163 reg_err("pdev reg obj is NULL"); 1164 return CHANNEL_STATE_INVALID; 1165 } 1166 1167 return pdev_priv_obj->cur_chan_list[ch_idx].state; 1168 } 1169 1170 /** 1171 * reg_get_5g_bonded_chan_array() - get ptr to bonded channel 1172 * @pdev: Pointer to pdev structure 1173 * @oper_ch: operating channel number 1174 * @bonded_chan_ar: bonded channel array 1175 * @array_size; Array size 1176 * @bonded_chan_ptr_ptr: bonded channel ptr ptr 1177 * 1178 * Return: bonded channel state 1179 */ 1180 static enum channel_state reg_get_5g_bonded_chan_array( 1181 struct wlan_objmgr_pdev *pdev, 1182 uint8_t oper_chan, 1183 const struct bonded_channel bonded_chan_ar[], 1184 uint16_t array_size, 1185 const struct bonded_channel **bonded_chan_ptr_ptr) 1186 { 1187 int i; 1188 uint8_t chan_num; 1189 const struct bonded_channel *bonded_chan_ptr = NULL; 1190 enum channel_state chan_state = CHANNEL_STATE_INVALID; 1191 enum channel_state temp_chan_state; 1192 1193 for (i = 0; i < array_size; i++) { 1194 if ((oper_chan >= bonded_chan_ar[i].start_ch) && 1195 (oper_chan <= bonded_chan_ar[i].end_ch)) { 1196 bonded_chan_ptr = &bonded_chan_ar[i]; 1197 break; 1198 } 1199 } 1200 1201 if (!bonded_chan_ptr) 1202 return chan_state; 1203 1204 *bonded_chan_ptr_ptr = bonded_chan_ptr; 1205 chan_num = bonded_chan_ptr->start_ch; 1206 while (chan_num <= bonded_chan_ptr->end_ch) { 1207 temp_chan_state = reg_get_channel_state(pdev, chan_num); 1208 if (temp_chan_state < chan_state) 1209 chan_state = temp_chan_state; 1210 chan_num = chan_num + 4; 1211 } 1212 1213 return chan_state; 1214 } 1215 1216 enum channel_state reg_get_5g_bonded_channel( 1217 struct wlan_objmgr_pdev *pdev, uint8_t chan_num, 1218 enum phy_ch_width ch_width, 1219 const struct bonded_channel **bonded_chan_ptr_ptr) 1220 { 1221 if (ch_width == CH_WIDTH_80P80MHZ) 1222 return reg_get_5g_bonded_chan_array(pdev, chan_num, 1223 bonded_chan_80mhz_list, 1224 QDF_ARRAY_SIZE(bonded_chan_80mhz_list), 1225 bonded_chan_ptr_ptr); 1226 else if (ch_width == CH_WIDTH_160MHZ) 1227 return reg_get_5g_bonded_chan_array(pdev, chan_num, 1228 bonded_chan_160mhz_list, 1229 QDF_ARRAY_SIZE(bonded_chan_160mhz_list), 1230 bonded_chan_ptr_ptr); 1231 else if (ch_width == CH_WIDTH_80MHZ) 1232 return reg_get_5g_bonded_chan_array(pdev, chan_num, 1233 bonded_chan_80mhz_list, 1234 QDF_ARRAY_SIZE(bonded_chan_80mhz_list), 1235 bonded_chan_ptr_ptr); 1236 else if (ch_width == CH_WIDTH_40MHZ) 1237 return reg_get_5g_bonded_chan_array(pdev, chan_num, 1238 bonded_chan_40mhz_list, 1239 QDF_ARRAY_SIZE(bonded_chan_40mhz_list), 1240 bonded_chan_ptr_ptr); 1241 else 1242 return reg_get_channel_state(pdev, chan_num); 1243 } 1244 1245 enum channel_state reg_get_5g_bonded_channel_state( 1246 struct wlan_objmgr_pdev *pdev, 1247 uint8_t ch, enum phy_ch_width bw) 1248 { 1249 enum channel_enum ch_indx; 1250 enum channel_state chan_state; 1251 struct regulatory_channel *reg_channels; 1252 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1253 bool bw_enabled = false; 1254 const struct bonded_channel *bonded_chan_ptr = NULL; 1255 1256 if (bw > CH_WIDTH_80P80MHZ) { 1257 reg_err("bw passed is not good"); 1258 return CHANNEL_STATE_INVALID; 1259 } 1260 1261 chan_state = reg_get_5g_bonded_channel(pdev, ch, bw, &bonded_chan_ptr); 1262 1263 if ((chan_state == CHANNEL_STATE_INVALID) || 1264 (chan_state == CHANNEL_STATE_DISABLE)) 1265 return chan_state; 1266 1267 pdev_priv_obj = reg_get_pdev_obj(pdev); 1268 1269 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 1270 reg_err("pdev reg obj is NULL"); 1271 return CHANNEL_STATE_INVALID; 1272 } 1273 reg_channels = pdev_priv_obj->cur_chan_list; 1274 1275 ch_indx = reg_get_chan_enum(ch); 1276 if (ch_indx == INVALID_CHANNEL) 1277 return CHANNEL_STATE_INVALID; 1278 if (bw == CH_WIDTH_5MHZ) 1279 bw_enabled = true; 1280 else if (bw == CH_WIDTH_10MHZ) 1281 bw_enabled = (reg_channels[ch_indx].min_bw <= 10) && 1282 (reg_channels[ch_indx].max_bw >= 10); 1283 else if (bw == CH_WIDTH_20MHZ) 1284 bw_enabled = (reg_channels[ch_indx].min_bw <= 20) && 1285 (reg_channels[ch_indx].max_bw >= 20); 1286 else if (bw == CH_WIDTH_40MHZ) 1287 bw_enabled = (reg_channels[ch_indx].min_bw <= 40) && 1288 (reg_channels[ch_indx].max_bw >= 40); 1289 else if (bw == CH_WIDTH_80MHZ) 1290 bw_enabled = (reg_channels[ch_indx].min_bw <= 80) && 1291 (reg_channels[ch_indx].max_bw >= 80); 1292 else if (bw == CH_WIDTH_160MHZ) 1293 bw_enabled = (reg_channels[ch_indx].min_bw <= 160) && 1294 (reg_channels[ch_indx].max_bw >= 160); 1295 else if (bw == CH_WIDTH_80P80MHZ) 1296 bw_enabled = (reg_channels[ch_indx].min_bw <= 80) && 1297 (reg_channels[ch_indx].max_bw >= 80); 1298 1299 if (bw_enabled) 1300 return chan_state; 1301 else 1302 return CHANNEL_STATE_DISABLE; 1303 } 1304 1305 enum channel_state reg_get_2g_bonded_channel_state( 1306 struct wlan_objmgr_pdev *pdev, 1307 uint8_t oper_ch, uint8_t sec_ch, 1308 enum phy_ch_width bw) 1309 { 1310 enum channel_enum chan_idx; 1311 enum channel_state chan_state; 1312 struct regulatory_channel *reg_channels; 1313 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1314 bool bw_enabled = false; 1315 enum channel_state chan_state2 = CHANNEL_STATE_INVALID; 1316 1317 if (bw > CH_WIDTH_40MHZ) 1318 return CHANNEL_STATE_INVALID; 1319 1320 if (bw == CH_WIDTH_40MHZ) { 1321 if ((sec_ch + 4 != oper_ch) && 1322 (oper_ch + 4 != sec_ch)) 1323 return CHANNEL_STATE_INVALID; 1324 chan_state2 = reg_get_channel_state(pdev, sec_ch); 1325 if (chan_state2 == CHANNEL_STATE_INVALID) 1326 return chan_state2; 1327 } 1328 1329 pdev_priv_obj = reg_get_pdev_obj(pdev); 1330 1331 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 1332 reg_err("reg pdev priv obj is NULL"); 1333 return CHANNEL_STATE_INVALID; 1334 } 1335 1336 reg_channels = pdev_priv_obj->cur_chan_list; 1337 1338 chan_state = reg_get_channel_state(pdev, oper_ch); 1339 if (chan_state2 < chan_state) 1340 chan_state = chan_state2; 1341 1342 if ((chan_state == CHANNEL_STATE_INVALID) || 1343 (chan_state == CHANNEL_STATE_DISABLE)) 1344 return chan_state; 1345 1346 chan_idx = reg_get_chan_enum(oper_ch); 1347 if (chan_idx == INVALID_CHANNEL) 1348 return CHANNEL_STATE_INVALID; 1349 if (bw == CH_WIDTH_5MHZ) 1350 bw_enabled = true; 1351 else if (bw == CH_WIDTH_10MHZ) 1352 bw_enabled = (reg_channels[chan_idx].min_bw <= 10) && 1353 (reg_channels[chan_idx].max_bw >= 10); 1354 else if (bw == CH_WIDTH_20MHZ) 1355 bw_enabled = (reg_channels[chan_idx].min_bw <= 20) && 1356 (reg_channels[chan_idx].max_bw >= 20); 1357 else if (bw == CH_WIDTH_40MHZ) 1358 bw_enabled = (reg_channels[chan_idx].min_bw <= 40) && 1359 (reg_channels[chan_idx].max_bw >= 40); 1360 1361 if (bw_enabled) 1362 return chan_state; 1363 else 1364 return CHANNEL_STATE_DISABLE; 1365 1366 return CHANNEL_STATE_ENABLE; 1367 } 1368 #endif /* CONFIG_CHAN_NUM_API */ 1369 1370 /** 1371 * reg_combine_channel_states() - Get minimum of channel state1 and state2 1372 * @chan_state1: Channel state1 1373 * @chan_state2: Channel state2 1374 * 1375 * Return: Channel state 1376 */ 1377 static enum channel_state reg_combine_channel_states( 1378 enum channel_state chan_state1, 1379 enum channel_state chan_state2) 1380 { 1381 if ((chan_state1 == CHANNEL_STATE_INVALID) || 1382 (chan_state2 == CHANNEL_STATE_INVALID)) 1383 return CHANNEL_STATE_INVALID; 1384 else 1385 return min(chan_state1, chan_state2); 1386 } 1387 1388 #ifdef CONFIG_CHAN_NUM_API 1389 /** 1390 * reg_set_5g_channel_params () - Sets channel parameteres for given bandwidth 1391 * @ch: channel number. 1392 * @ch_params: pointer to the channel parameters. 1393 * 1394 * Return: None 1395 */ 1396 static void reg_set_5g_channel_params(struct wlan_objmgr_pdev *pdev, 1397 uint8_t ch, 1398 struct ch_params *ch_params) 1399 { 1400 /* 1401 * Set channel parameters like center frequency for a bonded channel 1402 * state. Also return the maximum bandwidth supported by the channel. 1403 */ 1404 1405 enum channel_state chan_state = CHANNEL_STATE_ENABLE; 1406 enum channel_state chan_state2 = CHANNEL_STATE_ENABLE; 1407 const struct bonded_channel *bonded_chan_ptr = NULL; 1408 const struct bonded_channel *bonded_chan_ptr2 = NULL; 1409 1410 if (!ch_params) { 1411 reg_err("ch_params is NULL"); 1412 return; 1413 } 1414 1415 if (ch_params->ch_width >= CH_WIDTH_MAX) { 1416 if (ch_params->center_freq_seg1 != 0) 1417 ch_params->ch_width = CH_WIDTH_80P80MHZ; 1418 else 1419 ch_params->ch_width = CH_WIDTH_160MHZ; 1420 } 1421 1422 while (ch_params->ch_width != CH_WIDTH_INVALID) { 1423 bonded_chan_ptr = NULL; 1424 bonded_chan_ptr2 = NULL; 1425 chan_state = reg_get_5g_bonded_channel( 1426 pdev, ch, ch_params->ch_width, 1427 &bonded_chan_ptr); 1428 1429 chan_state = reg_get_5g_bonded_channel_state( 1430 pdev, ch, ch_params->ch_width); 1431 1432 if (ch_params->ch_width == CH_WIDTH_80P80MHZ) { 1433 chan_state2 = reg_get_5g_bonded_channel_state( 1434 pdev, ch_params->center_freq_seg1 - 2, 1435 CH_WIDTH_80MHZ); 1436 1437 chan_state = reg_combine_channel_states( 1438 chan_state, chan_state2); 1439 } 1440 1441 if ((chan_state != CHANNEL_STATE_ENABLE) && 1442 (chan_state != CHANNEL_STATE_DFS)) 1443 goto update_bw; 1444 1445 if (ch_params->ch_width <= CH_WIDTH_20MHZ) { 1446 ch_params->sec_ch_offset = NO_SEC_CH; 1447 ch_params->center_freq_seg0 = ch; 1448 break; 1449 } else if (ch_params->ch_width >= CH_WIDTH_40MHZ) { 1450 reg_get_5g_bonded_chan_array( 1451 pdev, ch, bonded_chan_40mhz_list, 1452 QDF_ARRAY_SIZE(bonded_chan_40mhz_list), 1453 &bonded_chan_ptr2); 1454 if (!bonded_chan_ptr || !bonded_chan_ptr2) 1455 goto update_bw; 1456 if (ch == bonded_chan_ptr2->start_ch) 1457 ch_params->sec_ch_offset = LOW_PRIMARY_CH; 1458 else 1459 ch_params->sec_ch_offset = HIGH_PRIMARY_CH; 1460 1461 ch_params->center_freq_seg0 = 1462 (bonded_chan_ptr->start_ch + 1463 bonded_chan_ptr->end_ch) / 2; 1464 break; 1465 } 1466 update_bw: 1467 ch_params->ch_width = get_next_lower_bw[ch_params->ch_width]; 1468 } 1469 1470 if (ch_params->ch_width == CH_WIDTH_160MHZ) { 1471 ch_params->center_freq_seg1 = ch_params->center_freq_seg0; 1472 chan_state = reg_get_5g_bonded_channel( 1473 pdev, ch, CH_WIDTH_80MHZ, &bonded_chan_ptr); 1474 if (bonded_chan_ptr) 1475 ch_params->center_freq_seg0 = 1476 (bonded_chan_ptr->start_ch + 1477 bonded_chan_ptr->end_ch) / 2; 1478 } 1479 1480 /* Overwrite center_freq_seg1 to 0 for non 160 and 80+80 width */ 1481 if (!(ch_params->ch_width == CH_WIDTH_160MHZ || 1482 ch_params->ch_width == CH_WIDTH_80P80MHZ)) 1483 ch_params->center_freq_seg1 = 0; 1484 1485 reg_nofl_debug("ch %d ch_wd %d freq0 %d freq1 %d", ch, 1486 ch_params->ch_width, ch_params->center_freq_seg0, 1487 ch_params->center_freq_seg1); 1488 } 1489 1490 /** 1491 * reg_set_2g_channel_params() - set the 2.4G bonded channel parameters 1492 * @oper_ch: operating channel 1493 * @ch_params: channel parameters 1494 * @sec_ch_2g: 2.4G secondary channel 1495 * 1496 * Return: void 1497 */ 1498 static void reg_set_2g_channel_params(struct wlan_objmgr_pdev *pdev, 1499 uint16_t oper_ch, 1500 struct ch_params *ch_params, 1501 uint16_t sec_ch_2g) 1502 { 1503 enum channel_state chan_state = CHANNEL_STATE_ENABLE; 1504 1505 if (ch_params->ch_width >= CH_WIDTH_MAX) 1506 ch_params->ch_width = CH_WIDTH_40MHZ; 1507 if ((reg_get_bw_value(ch_params->ch_width) > 20) && !sec_ch_2g) { 1508 if (oper_ch >= 1 && oper_ch <= 5) 1509 sec_ch_2g = oper_ch + 4; 1510 else if (oper_ch >= 6 && oper_ch <= 13) 1511 sec_ch_2g = oper_ch - 4; 1512 } 1513 1514 while (ch_params->ch_width != CH_WIDTH_INVALID) { 1515 chan_state = reg_get_2g_bonded_channel_state( 1516 pdev, oper_ch, sec_ch_2g, ch_params->ch_width); 1517 if (chan_state == CHANNEL_STATE_ENABLE) { 1518 if (ch_params->ch_width == CH_WIDTH_40MHZ) { 1519 if (oper_ch < sec_ch_2g) 1520 ch_params->sec_ch_offset = 1521 LOW_PRIMARY_CH; 1522 else 1523 ch_params->sec_ch_offset = 1524 HIGH_PRIMARY_CH; 1525 ch_params->center_freq_seg0 = 1526 (oper_ch + sec_ch_2g) / 2; 1527 } else { 1528 ch_params->sec_ch_offset = NO_SEC_CH; 1529 ch_params->center_freq_seg0 = oper_ch; 1530 } 1531 break; 1532 } 1533 1534 ch_params->ch_width = get_next_lower_bw[ch_params->ch_width]; 1535 } 1536 /* Overwrite center_freq_seg1 to 0 for 2.4 Ghz */ 1537 ch_params->center_freq_seg1 = 0; 1538 } 1539 1540 void reg_set_channel_params(struct wlan_objmgr_pdev *pdev, 1541 uint8_t ch, uint8_t sec_ch_2g, 1542 struct ch_params *ch_params) 1543 { 1544 if (REG_IS_5GHZ_CH(ch)) 1545 reg_set_5g_channel_params(pdev, ch, ch_params); 1546 else if (REG_IS_24GHZ_CH(ch)) 1547 reg_set_2g_channel_params(pdev, ch, ch_params, sec_ch_2g); 1548 } 1549 #endif /* CONFIG_CHAN_NUM_API */ 1550 1551 QDF_STATUS reg_read_default_country(struct wlan_objmgr_psoc *psoc, 1552 uint8_t *country_code) 1553 { 1554 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 1555 1556 if (!country_code) { 1557 reg_err("country_code is NULL"); 1558 return QDF_STATUS_E_INVAL; 1559 } 1560 1561 psoc_priv_obj = reg_get_psoc_obj(psoc); 1562 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 1563 reg_err("psoc reg component is NULL"); 1564 return QDF_STATUS_E_INVAL; 1565 } 1566 1567 qdf_mem_copy(country_code, psoc_priv_obj->def_country, 1568 REG_ALPHA2_LEN + 1); 1569 1570 return QDF_STATUS_SUCCESS; 1571 } 1572 1573 QDF_STATUS reg_get_max_5g_bw_from_country_code(uint16_t cc, 1574 uint16_t *max_bw_5g) 1575 { 1576 uint16_t i; 1577 int num_countries; 1578 1579 *max_bw_5g = 0; 1580 reg_get_num_countries(&num_countries); 1581 1582 for (i = 0; i < num_countries; i++) { 1583 if (g_all_countries[i].country_code == cc) 1584 break; 1585 } 1586 1587 if (i == num_countries) 1588 return QDF_STATUS_E_FAILURE; 1589 1590 *max_bw_5g = g_all_countries[i].max_bw_5g; 1591 1592 return QDF_STATUS_SUCCESS; 1593 } 1594 1595 QDF_STATUS reg_get_max_5g_bw_from_regdomain(uint16_t regdmn, 1596 uint16_t *max_bw_5g) 1597 { 1598 uint16_t i; 1599 int num_reg_dmn; 1600 1601 *max_bw_5g = 0; 1602 reg_get_num_reg_dmn_pairs(&num_reg_dmn); 1603 1604 for (i = 0; i < num_reg_dmn; i++) { 1605 if (g_reg_dmn_pairs[i].reg_dmn_pair_id == regdmn) 1606 break; 1607 } 1608 1609 if (i == num_reg_dmn) 1610 return QDF_STATUS_E_FAILURE; 1611 1612 *max_bw_5g = regdomains_5g[g_reg_dmn_pairs[i].dmn_id_5g].max_bw; 1613 1614 return QDF_STATUS_SUCCESS; 1615 } 1616 1617 void reg_get_current_dfs_region(struct wlan_objmgr_pdev *pdev, 1618 enum dfs_reg *dfs_reg) 1619 { 1620 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1621 1622 pdev_priv_obj = reg_get_pdev_obj(pdev); 1623 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 1624 reg_err("reg component pdev priv is NULL"); 1625 return; 1626 } 1627 1628 *dfs_reg = pdev_priv_obj->dfs_region; 1629 } 1630 1631 void reg_set_dfs_region(struct wlan_objmgr_pdev *pdev, 1632 enum dfs_reg dfs_reg) 1633 { 1634 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1635 1636 pdev_priv_obj = reg_get_pdev_obj(pdev); 1637 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 1638 reg_err("psoc reg component is NULL"); 1639 return; 1640 } 1641 1642 pdev_priv_obj->dfs_region = dfs_reg; 1643 1644 reg_init_channel_map(dfs_reg); 1645 } 1646 1647 #ifdef CONFIG_CHAN_NUM_API 1648 uint32_t reg_get_channel_reg_power(struct wlan_objmgr_pdev *pdev, 1649 uint8_t chan_num) 1650 { 1651 enum channel_enum chan_enum; 1652 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1653 struct regulatory_channel *reg_channels; 1654 1655 chan_enum = reg_get_chan_enum(chan_num); 1656 1657 if (chan_enum == INVALID_CHANNEL) { 1658 reg_err("channel is invalid"); 1659 return QDF_STATUS_E_FAILURE; 1660 } 1661 1662 pdev_priv_obj = reg_get_pdev_obj(pdev); 1663 1664 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 1665 reg_err("reg pdev priv obj is NULL"); 1666 return QDF_STATUS_E_FAILURE; 1667 } 1668 1669 reg_channels = pdev_priv_obj->cur_chan_list; 1670 1671 return reg_channels[chan_enum].tx_power; 1672 } 1673 1674 qdf_freq_t reg_get_channel_freq(struct wlan_objmgr_pdev *pdev, 1675 uint8_t chan_num) 1676 { 1677 enum channel_enum chan_enum; 1678 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1679 struct regulatory_channel *reg_channels; 1680 1681 chan_enum = reg_get_chan_enum(chan_num); 1682 1683 if (chan_enum == INVALID_CHANNEL) 1684 return CHANNEL_STATE_INVALID; 1685 1686 pdev_priv_obj = reg_get_pdev_obj(pdev); 1687 1688 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 1689 reg_err("reg pdev priv obj is NULL"); 1690 return QDF_STATUS_E_FAILURE; 1691 } 1692 1693 reg_channels = pdev_priv_obj->cur_chan_list; 1694 1695 return reg_channels[chan_enum].center_freq; 1696 } 1697 1698 bool reg_is_dfs_ch(struct wlan_objmgr_pdev *pdev, 1699 uint8_t chan) 1700 { 1701 enum channel_state ch_state; 1702 1703 ch_state = reg_get_channel_state(pdev, chan); 1704 1705 return ch_state == CHANNEL_STATE_DFS; 1706 } 1707 1708 bool reg_is_disable_ch(struct wlan_objmgr_pdev *pdev, uint8_t chan) 1709 { 1710 enum channel_state ch_state; 1711 1712 ch_state = reg_get_channel_state(pdev, chan); 1713 1714 return ch_state == CHANNEL_STATE_DISABLE; 1715 } 1716 #endif /* CONFIG_CHAN_NUM_API */ 1717 1718 uint8_t reg_freq_to_chan(struct wlan_objmgr_pdev *pdev, 1719 qdf_freq_t freq) 1720 { 1721 uint32_t count; 1722 struct regulatory_channel *chan_list; 1723 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1724 1725 if (freq == 0) { 1726 reg_err_rl("Invalid freq %d", freq); 1727 return 0; 1728 } 1729 1730 pdev_priv_obj = reg_get_pdev_obj(pdev); 1731 1732 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 1733 reg_err("reg pdev priv obj is NULL"); 1734 return 0; 1735 } 1736 1737 chan_list = pdev_priv_obj->mas_chan_list; 1738 for (count = 0; count < NUM_CHANNELS; count++) { 1739 if (chan_list[count].center_freq >= freq) 1740 break; 1741 } 1742 1743 if (count == NUM_CHANNELS) 1744 goto end; 1745 1746 if (chan_list[count].center_freq == freq) 1747 return chan_list[count].chan_num; 1748 1749 if (count == 0) 1750 goto end; 1751 1752 if ((chan_list[count - 1].chan_num == INVALID_CHANNEL_NUM) || 1753 (chan_list[count].chan_num == INVALID_CHANNEL_NUM)) { 1754 reg_err("Frequency %d invalid in current reg domain", freq); 1755 return 0; 1756 } 1757 1758 return (chan_list[count - 1].chan_num + 1759 (freq - chan_list[count - 1].center_freq) / 5); 1760 1761 end: 1762 reg_err_rl("invalid frequency %d", freq); 1763 return 0; 1764 } 1765 1766 static uint16_t reg_compute_chan_to_freq(struct wlan_objmgr_pdev *pdev, 1767 uint8_t chan_num, 1768 enum channel_enum min_chan_range, 1769 enum channel_enum max_chan_range) 1770 { 1771 uint16_t count; 1772 struct regulatory_channel *chan_list; 1773 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1774 1775 pdev_priv_obj = reg_get_pdev_obj(pdev); 1776 1777 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 1778 reg_err("reg pdev priv obj is NULL"); 1779 return 0; 1780 } 1781 1782 if (min_chan_range < MIN_CHANNEL || max_chan_range > MAX_CHANNEL) { 1783 reg_err_rl("Channel range is invalid"); 1784 return 0; 1785 } 1786 1787 chan_list = pdev_priv_obj->mas_chan_list; 1788 1789 for (count = min_chan_range; count <= max_chan_range; count++) { 1790 if ((chan_list[count].state != CHANNEL_STATE_DISABLE) && 1791 !(chan_list[count].chan_flags & REGULATORY_CHAN_DISABLED)) { 1792 if (REG_IS_49GHZ_FREQ(chan_list[count].center_freq)) { 1793 if (chan_list[count].chan_num == chan_num) 1794 break; 1795 continue; 1796 } else if ((chan_list[count].chan_num >= chan_num) && 1797 (chan_list[count].chan_num != 1798 INVALID_CHANNEL_NUM)) 1799 break; 1800 } 1801 } 1802 1803 if (count == max_chan_range + 1) 1804 goto end; 1805 1806 if (chan_list[count].chan_num == chan_num) { 1807 if (chan_list[count].chan_flags & REGULATORY_CHAN_DISABLED) 1808 reg_err("Channel %d disabled in current reg domain", 1809 chan_num); 1810 return chan_list[count].center_freq; 1811 } 1812 1813 if (count == min_chan_range) 1814 goto end; 1815 1816 if ((chan_list[count - 1].chan_num == INVALID_CHANNEL_NUM) || 1817 REG_IS_49GHZ_FREQ(chan_list[count - 1].center_freq) || 1818 (chan_list[count].chan_num == INVALID_CHANNEL_NUM)) { 1819 reg_err("Channel %d invalid in current reg domain", 1820 chan_num); 1821 return 0; 1822 } 1823 1824 return (chan_list[count - 1].center_freq + 1825 (chan_num - chan_list[count - 1].chan_num) * 5); 1826 1827 end: 1828 1829 reg_debug_rl("Invalid channel %d", chan_num); 1830 return 0; 1831 } 1832 1833 uint16_t reg_legacy_chan_to_freq(struct wlan_objmgr_pdev *pdev, 1834 uint8_t chan_num) 1835 { 1836 uint16_t min_chan_range = MIN_24GHZ_CHANNEL; 1837 uint16_t max_chan_range = MAX_5GHZ_CHANNEL; 1838 1839 if (chan_num == 0) { 1840 reg_err_rl("Invalid channel %d", chan_num); 1841 return 0; 1842 } 1843 1844 return reg_compute_chan_to_freq(pdev, chan_num, 1845 min_chan_range, 1846 max_chan_range); 1847 } 1848 1849 qdf_freq_t reg_chan_to_freq(struct wlan_objmgr_pdev *pdev, 1850 uint8_t chan_num) 1851 { 1852 uint32_t count; 1853 struct regulatory_channel *chan_list; 1854 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1855 1856 if (chan_num == 0) { 1857 reg_err_rl("Invalid channel %d", chan_num); 1858 return 0; 1859 } 1860 1861 pdev_priv_obj = reg_get_pdev_obj(pdev); 1862 1863 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 1864 reg_err("reg pdev priv obj is NULL"); 1865 return 0; 1866 } 1867 1868 chan_list = pdev_priv_obj->cur_chan_list; 1869 for (count = 0; count < NUM_CHANNELS; count++) 1870 if (chan_list[count].chan_num == chan_num) { 1871 if (reg_chan_in_range(chan_list, 1872 pdev_priv_obj->range_2g_low, 1873 pdev_priv_obj->range_2g_high, 1874 pdev_priv_obj->range_5g_low, 1875 pdev_priv_obj->range_5g_high, 1876 count)) { 1877 return chan_list[count].center_freq; 1878 } 1879 } 1880 1881 reg_debug_rl("invalid channel %d", chan_num); 1882 return 0; 1883 } 1884 1885 #ifdef CONFIG_CHAN_NUM_API 1886 bool reg_chan_is_49ghz(struct wlan_objmgr_pdev *pdev, uint8_t chan_num) 1887 { 1888 qdf_freq_t freq = 0; 1889 1890 freq = reg_chan_to_freq(pdev, chan_num); 1891 1892 return REG_IS_49GHZ_FREQ(freq) ? true : false; 1893 } 1894 1895 enum band_info reg_chan_to_band(uint8_t chan_num) 1896 { 1897 if (chan_num <= 14) 1898 return BAND_2G; 1899 1900 return BAND_5G; 1901 } 1902 1903 void reg_update_nol_ch(struct wlan_objmgr_pdev *pdev, 1904 uint8_t *chan_list, 1905 uint8_t num_chan, 1906 bool nol_chan) 1907 { 1908 enum channel_enum chan_enum; 1909 struct regulatory_channel *mas_chan_list; 1910 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1911 uint16_t i; 1912 1913 if (!num_chan || !chan_list) { 1914 reg_err("chan_list or num_ch is NULL"); 1915 return; 1916 } 1917 1918 pdev_priv_obj = reg_get_pdev_obj(pdev); 1919 if (!pdev_priv_obj) { 1920 reg_err("reg psoc private obj is NULL"); 1921 return; 1922 } 1923 1924 mas_chan_list = pdev_priv_obj->mas_chan_list; 1925 for (i = 0; i < num_chan; i++) { 1926 chan_enum = reg_get_chan_enum(chan_list[i]); 1927 if (chan_enum == INVALID_CHANNEL) { 1928 reg_err("Invalid ch in nol list, chan %d", 1929 chan_list[i]); 1930 continue; 1931 } 1932 mas_chan_list[chan_enum].nol_chan = nol_chan; 1933 } 1934 1935 reg_compute_pdev_current_chan_list(pdev_priv_obj); 1936 } 1937 #endif /* CONFIG_CHAN_NUM_API */ 1938 1939 QDF_STATUS reg_program_default_cc(struct wlan_objmgr_pdev *pdev, 1940 uint16_t regdmn) 1941 { 1942 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 1943 struct cur_regulatory_info *reg_info; 1944 uint16_t cc = -1; 1945 uint16_t country_index = -1, regdmn_pair = -1; 1946 struct wlan_objmgr_psoc *psoc; 1947 QDF_STATUS err; 1948 1949 pdev_priv_obj = reg_get_pdev_obj(pdev); 1950 if (!pdev_priv_obj) { 1951 reg_err("reg soc is NULL"); 1952 return QDF_STATUS_E_FAILURE; 1953 } 1954 1955 reg_info = (struct cur_regulatory_info *)qdf_mem_malloc 1956 (sizeof(struct cur_regulatory_info)); 1957 if (!reg_info) 1958 return QDF_STATUS_E_NOMEM; 1959 1960 psoc = wlan_pdev_get_psoc(pdev); 1961 if (!psoc) { 1962 reg_err("psoc is NULL"); 1963 return QDF_STATUS_E_INVAL; 1964 } 1965 1966 reg_info->psoc = psoc; 1967 reg_info->phy_id = wlan_objmgr_pdev_get_pdev_id(pdev); 1968 reg_info->num_phy = 1; 1969 1970 if (regdmn == 0) { 1971 reg_get_default_country(®dmn); 1972 regdmn |= COUNTRY_ERD_FLAG; 1973 } 1974 1975 if (regdmn & COUNTRY_ERD_FLAG) { 1976 cc = regdmn & ~COUNTRY_ERD_FLAG; 1977 1978 reg_get_rdpair_from_country_code(cc, 1979 &country_index, 1980 ®dmn_pair); 1981 1982 err = reg_get_cur_reginfo(reg_info, country_index, regdmn_pair); 1983 if (err == QDF_STATUS_E_FAILURE) { 1984 reg_err("Unable to set country code\n"); 1985 qdf_mem_free(reg_info->reg_rules_2g_ptr); 1986 qdf_mem_free(reg_info->reg_rules_5g_ptr); 1987 qdf_mem_free(reg_info); 1988 return QDF_STATUS_E_FAILURE; 1989 } 1990 1991 pdev_priv_obj->ctry_code = cc; 1992 1993 } else { 1994 reg_get_rdpair_from_regdmn_id(regdmn, ®dmn_pair); 1995 1996 err = reg_get_cur_reginfo(reg_info, country_index, regdmn_pair); 1997 if (err == QDF_STATUS_E_FAILURE) { 1998 reg_err("Unable to set country code\n"); 1999 qdf_mem_free(reg_info->reg_rules_2g_ptr); 2000 qdf_mem_free(reg_info->reg_rules_5g_ptr); 2001 qdf_mem_free(reg_info); 2002 return QDF_STATUS_E_FAILURE; 2003 } 2004 2005 pdev_priv_obj->reg_dmn_pair = regdmn; 2006 } 2007 2008 reg_info->offload_enabled = false; 2009 reg_process_master_chan_list(reg_info); 2010 2011 qdf_mem_free(reg_info->reg_rules_2g_ptr); 2012 qdf_mem_free(reg_info->reg_rules_5g_ptr); 2013 qdf_mem_free(reg_info); 2014 2015 return QDF_STATUS_SUCCESS; 2016 } 2017 2018 QDF_STATUS reg_program_chan_list(struct wlan_objmgr_pdev *pdev, 2019 struct cc_regdmn_s *rd) 2020 { 2021 struct cur_regulatory_info *reg_info; 2022 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 2023 uint16_t country_index = -1, regdmn_pair = -1; 2024 struct wlan_objmgr_psoc *psoc; 2025 struct wlan_lmac_if_reg_tx_ops *tx_ops; 2026 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 2027 uint8_t pdev_id; 2028 uint8_t phy_id; 2029 QDF_STATUS err; 2030 2031 pdev_priv_obj = reg_get_pdev_obj(pdev); 2032 if (!pdev_priv_obj) { 2033 reg_err(" pdev priv obj is NULL"); 2034 return QDF_STATUS_E_FAILURE; 2035 } 2036 2037 psoc = wlan_pdev_get_psoc(pdev); 2038 if (!psoc) { 2039 reg_err("psoc is NULL"); 2040 return QDF_STATUS_E_INVAL; 2041 } 2042 2043 psoc_priv_obj = reg_get_psoc_obj(psoc); 2044 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 2045 reg_err("psoc reg component is NULL"); 2046 return QDF_STATUS_E_FAILURE; 2047 } 2048 2049 if (psoc_priv_obj->offload_enabled) { 2050 if ((rd->flags == ALPHA_IS_SET) && (rd->cc.alpha[2] == 'O')) 2051 pdev_priv_obj->indoor_chan_enabled = false; 2052 else 2053 pdev_priv_obj->indoor_chan_enabled = true; 2054 2055 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 2056 tx_ops = reg_get_psoc_tx_ops(psoc); 2057 2058 if (tx_ops->get_phy_id_from_pdev_id) 2059 tx_ops->get_phy_id_from_pdev_id(psoc, pdev_id, &phy_id); 2060 else 2061 phy_id = pdev_id; 2062 2063 if (tx_ops->set_user_country_code) { 2064 psoc_priv_obj->new_init_ctry_pending[phy_id] = true; 2065 return tx_ops->set_user_country_code(psoc, pdev_id, rd); 2066 } 2067 2068 return QDF_STATUS_E_FAILURE; 2069 } 2070 2071 reg_info = (struct cur_regulatory_info *)qdf_mem_malloc 2072 (sizeof(struct cur_regulatory_info)); 2073 if (!reg_info) 2074 return QDF_STATUS_E_NOMEM; 2075 2076 reg_info->psoc = psoc; 2077 reg_info->phy_id = wlan_objmgr_pdev_get_pdev_id(pdev); 2078 2079 if (rd->flags == CC_IS_SET) { 2080 reg_get_rdpair_from_country_code(rd->cc.country_code, 2081 &country_index, 2082 ®dmn_pair); 2083 } else if (rd->flags == ALPHA_IS_SET) { 2084 reg_get_rdpair_from_country_iso(rd->cc.alpha, 2085 &country_index, 2086 ®dmn_pair); 2087 } else if (rd->flags == REGDMN_IS_SET) { 2088 reg_get_rdpair_from_regdmn_id(rd->cc.regdmn_id, 2089 ®dmn_pair); 2090 } 2091 2092 err = reg_get_cur_reginfo(reg_info, country_index, regdmn_pair); 2093 if (err == QDF_STATUS_E_FAILURE) { 2094 reg_err("Unable to set country code\n"); 2095 qdf_mem_free(reg_info->reg_rules_2g_ptr); 2096 qdf_mem_free(reg_info->reg_rules_5g_ptr); 2097 qdf_mem_free(reg_info); 2098 return QDF_STATUS_E_FAILURE; 2099 } 2100 2101 reg_info->offload_enabled = false; 2102 reg_process_master_chan_list(reg_info); 2103 2104 qdf_mem_free(reg_info->reg_rules_2g_ptr); 2105 qdf_mem_free(reg_info->reg_rules_5g_ptr); 2106 qdf_mem_free(reg_info); 2107 2108 return QDF_STATUS_SUCCESS; 2109 } 2110 2111 QDF_STATUS reg_get_current_cc(struct wlan_objmgr_pdev *pdev, 2112 struct cc_regdmn_s *rd) 2113 { 2114 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 2115 2116 pdev_priv_obj = reg_get_pdev_obj(pdev); 2117 if (!pdev_priv_obj) { 2118 reg_err("reg pdev priv is NULL"); 2119 return QDF_STATUS_E_FAILURE; 2120 } 2121 2122 if (rd->flags == CC_IS_SET) { 2123 rd->cc.country_code = pdev_priv_obj->ctry_code; 2124 } else if (rd->flags == ALPHA_IS_SET) { 2125 qdf_mem_copy(rd->cc.alpha, pdev_priv_obj->current_country, 2126 sizeof(rd->cc.alpha)); 2127 } else if (rd->flags == REGDMN_IS_SET) { 2128 rd->cc.regdmn_id = pdev_priv_obj->reg_dmn_pair; 2129 } 2130 2131 return QDF_STATUS_SUCCESS; 2132 } 2133 2134 QDF_STATUS reg_set_regdb_offloaded(struct wlan_objmgr_psoc *psoc, bool val) 2135 { 2136 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 2137 2138 psoc_priv_obj = reg_get_psoc_obj(psoc); 2139 2140 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 2141 reg_err("psoc reg component is NULL"); 2142 return QDF_STATUS_E_FAILURE; 2143 } 2144 2145 psoc_priv_obj->offload_enabled = val; 2146 2147 return QDF_STATUS_SUCCESS; 2148 } 2149 2150 QDF_STATUS reg_get_curr_regdomain(struct wlan_objmgr_pdev *pdev, 2151 struct cur_regdmn_info *cur_regdmn) 2152 { 2153 struct wlan_objmgr_psoc *psoc; 2154 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 2155 uint16_t index; 2156 int num_reg_dmn; 2157 uint8_t phy_id; 2158 uint8_t pdev_id; 2159 struct wlan_lmac_if_reg_tx_ops *tx_ops; 2160 2161 psoc = wlan_pdev_get_psoc(pdev); 2162 psoc_priv_obj = reg_get_psoc_obj(psoc); 2163 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 2164 reg_err("soc reg component is NULL"); 2165 return QDF_STATUS_E_INVAL; 2166 } 2167 2168 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 2169 2170 tx_ops = reg_get_psoc_tx_ops(psoc); 2171 if (tx_ops->get_phy_id_from_pdev_id) 2172 tx_ops->get_phy_id_from_pdev_id(psoc, pdev_id, &phy_id); 2173 else 2174 phy_id = pdev_id; 2175 2176 cur_regdmn->regdmn_pair_id = 2177 psoc_priv_obj->mas_chan_params[phy_id].reg_dmn_pair; 2178 2179 reg_get_num_reg_dmn_pairs(&num_reg_dmn); 2180 for (index = 0; index < num_reg_dmn; index++) { 2181 if (g_reg_dmn_pairs[index].reg_dmn_pair_id == 2182 cur_regdmn->regdmn_pair_id) 2183 break; 2184 } 2185 2186 if (index == num_reg_dmn) { 2187 reg_debug_rl("invalid regdomain"); 2188 return QDF_STATUS_E_FAILURE; 2189 } 2190 2191 cur_regdmn->dmn_id_2g = g_reg_dmn_pairs[index].dmn_id_2g; 2192 cur_regdmn->dmn_id_5g = g_reg_dmn_pairs[index].dmn_id_5g; 2193 cur_regdmn->ctl_2g = regdomains_2g[cur_regdmn->dmn_id_2g].ctl_val; 2194 cur_regdmn->ctl_5g = regdomains_5g[cur_regdmn->dmn_id_5g].ctl_val; 2195 cur_regdmn->dfs_region = 2196 regdomains_5g[cur_regdmn->dmn_id_5g].dfs_region; 2197 2198 return QDF_STATUS_SUCCESS; 2199 } 2200 2201 QDF_STATUS reg_modify_chan_144(struct wlan_objmgr_pdev *pdev, 2202 bool enable_ch_144) 2203 { 2204 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 2205 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 2206 struct wlan_objmgr_psoc *psoc; 2207 struct wlan_lmac_if_reg_tx_ops *reg_tx_ops; 2208 QDF_STATUS status; 2209 2210 pdev_priv_obj = reg_get_pdev_obj(pdev); 2211 2212 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 2213 reg_err("pdev reg component is NULL"); 2214 return QDF_STATUS_E_INVAL; 2215 } 2216 2217 if (pdev_priv_obj->en_chan_144 == enable_ch_144) { 2218 reg_info("chan 144 is already %d", enable_ch_144); 2219 return QDF_STATUS_SUCCESS; 2220 } 2221 2222 psoc = wlan_pdev_get_psoc(pdev); 2223 if (!psoc) { 2224 reg_err("psoc is NULL"); 2225 return QDF_STATUS_E_INVAL; 2226 } 2227 2228 psoc_priv_obj = reg_get_psoc_obj(psoc); 2229 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 2230 reg_err("psoc reg component is NULL"); 2231 return QDF_STATUS_E_INVAL; 2232 } 2233 2234 reg_debug("setting chan 144: %d", enable_ch_144); 2235 pdev_priv_obj->en_chan_144 = enable_ch_144; 2236 2237 reg_compute_pdev_current_chan_list(pdev_priv_obj); 2238 2239 reg_tx_ops = reg_get_psoc_tx_ops(psoc); 2240 if (reg_tx_ops->fill_umac_legacy_chanlist) 2241 reg_tx_ops->fill_umac_legacy_chanlist(pdev, 2242 pdev_priv_obj->cur_chan_list); 2243 2244 status = reg_send_scheduler_msg_sb(psoc, pdev); 2245 2246 return status; 2247 } 2248 2249 bool reg_get_en_chan_144(struct wlan_objmgr_pdev *pdev) 2250 { 2251 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 2252 2253 pdev_priv_obj = reg_get_pdev_obj(pdev); 2254 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 2255 reg_err("pdev reg component is NULL"); 2256 return false; 2257 } 2258 2259 return pdev_priv_obj->en_chan_144; 2260 } 2261 2262 struct wlan_psoc_host_hal_reg_capabilities_ext *reg_get_hal_reg_cap( 2263 struct wlan_objmgr_psoc *psoc) 2264 { 2265 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 2266 2267 psoc_priv_obj = reg_get_psoc_obj(psoc); 2268 2269 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 2270 reg_err("psoc reg component is NULL"); 2271 return NULL; 2272 } 2273 2274 return psoc_priv_obj->reg_cap; 2275 } 2276 2277 QDF_STATUS reg_set_hal_reg_cap( 2278 struct wlan_objmgr_psoc *psoc, 2279 struct wlan_psoc_host_hal_reg_capabilities_ext *reg_cap, 2280 uint16_t phy_cnt) 2281 { 2282 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 2283 2284 psoc_priv_obj = reg_get_psoc_obj(psoc); 2285 2286 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 2287 reg_err("psoc reg component is NULL"); 2288 return QDF_STATUS_E_FAILURE; 2289 } 2290 2291 if (phy_cnt > PSOC_MAX_PHY_REG_CAP) { 2292 reg_err("phy cnt:%d is more than %d", phy_cnt, 2293 PSOC_MAX_PHY_REG_CAP); 2294 return QDF_STATUS_E_FAILURE; 2295 } 2296 2297 qdf_mem_copy(psoc_priv_obj->reg_cap, reg_cap, 2298 phy_cnt * 2299 sizeof(struct wlan_psoc_host_hal_reg_capabilities_ext)); 2300 2301 return QDF_STATUS_SUCCESS; 2302 } 2303 2304 QDF_STATUS reg_update_hal_reg_cap(struct wlan_objmgr_psoc *psoc, 2305 uint32_t wireless_modes, uint8_t phy_id) 2306 { 2307 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 2308 2309 if (!psoc) { 2310 reg_err("psoc is null"); 2311 return QDF_STATUS_E_FAILURE; 2312 } 2313 2314 psoc_priv_obj = reg_get_psoc_obj(psoc); 2315 2316 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 2317 reg_err("psoc reg component is NULL"); 2318 return QDF_STATUS_E_FAILURE; 2319 } 2320 2321 psoc_priv_obj->reg_cap[phy_id].wireless_modes |= wireless_modes; 2322 2323 return QDF_STATUS_SUCCESS; 2324 } 2325 2326 bool reg_chan_in_range(struct regulatory_channel *chan_list, 2327 qdf_freq_t low_freq_2g, qdf_freq_t high_freq_2g, 2328 qdf_freq_t low_freq_5g, qdf_freq_t high_freq_5g, 2329 enum channel_enum ch_enum) 2330 { 2331 uint32_t low_limit_2g = NUM_CHANNELS; 2332 uint32_t high_limit_2g = NUM_CHANNELS; 2333 uint32_t low_limit_5g = NUM_CHANNELS; 2334 uint32_t high_limit_5g = NUM_CHANNELS; 2335 bool chan_in_range; 2336 enum channel_enum chan_enum; 2337 uint16_t min_bw; 2338 qdf_freq_t center_freq; 2339 2340 for (chan_enum = 0; chan_enum < NUM_CHANNELS; chan_enum++) { 2341 min_bw = chan_list[chan_enum].min_bw; 2342 center_freq = chan_list[chan_enum].center_freq; 2343 2344 if ((center_freq - min_bw / 2) >= low_freq_2g) { 2345 low_limit_2g = chan_enum; 2346 break; 2347 } 2348 } 2349 2350 for (chan_enum = 0; chan_enum < NUM_CHANNELS; chan_enum++) { 2351 min_bw = chan_list[chan_enum].min_bw; 2352 center_freq = chan_list[chan_enum].center_freq; 2353 2354 if ((center_freq - min_bw / 2) >= low_freq_5g) { 2355 low_limit_5g = chan_enum; 2356 break; 2357 } 2358 } 2359 2360 for (chan_enum = NUM_CHANNELS - 1; chan_enum >= 0; chan_enum--) { 2361 min_bw = chan_list[chan_enum].min_bw; 2362 center_freq = chan_list[chan_enum].center_freq; 2363 2364 if (center_freq + min_bw / 2 <= high_freq_2g) { 2365 high_limit_2g = chan_enum; 2366 break; 2367 } 2368 if (chan_enum == 0) 2369 break; 2370 } 2371 2372 for (chan_enum = NUM_CHANNELS - 1; chan_enum >= 0; chan_enum--) { 2373 min_bw = chan_list[chan_enum].min_bw; 2374 center_freq = chan_list[chan_enum].center_freq; 2375 2376 if (center_freq + min_bw / 2 <= high_freq_5g) { 2377 high_limit_5g = chan_enum; 2378 break; 2379 } 2380 if (chan_enum == 0) 2381 break; 2382 } 2383 2384 chan_in_range = false; 2385 if ((low_limit_2g <= ch_enum) && 2386 (high_limit_2g >= ch_enum) && 2387 (low_limit_2g != NUM_CHANNELS) && 2388 (high_limit_2g != NUM_CHANNELS)) 2389 chan_in_range = true; 2390 if ((low_limit_5g <= ch_enum) && 2391 (high_limit_5g >= ch_enum) && 2392 (low_limit_5g != NUM_CHANNELS) && 2393 (high_limit_5g != NUM_CHANNELS)) 2394 chan_in_range = true; 2395 2396 if (chan_in_range) 2397 return true; 2398 else 2399 return false; 2400 } 2401 2402 #ifdef CONFIG_CHAN_NUM_API 2403 void reg_update_nol_history_ch(struct wlan_objmgr_pdev *pdev, 2404 uint8_t *chan_list, uint8_t num_chan, 2405 bool nol_history_chan) 2406 { 2407 enum channel_enum chan_enum; 2408 struct regulatory_channel *mas_chan_list; 2409 struct regulatory_channel *cur_chan_list; 2410 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 2411 uint16_t i; 2412 2413 if (!num_chan || !chan_list) { 2414 reg_err("chan_list or num_ch is NULL"); 2415 return; 2416 } 2417 2418 pdev_priv_obj = wlan_objmgr_pdev_get_comp_private_obj( 2419 pdev, WLAN_UMAC_COMP_REGULATORY); 2420 2421 if (!pdev_priv_obj) { 2422 reg_err("reg psoc private obj is NULL"); 2423 return; 2424 } 2425 2426 mas_chan_list = pdev_priv_obj->mas_chan_list; 2427 cur_chan_list = pdev_priv_obj->cur_chan_list; 2428 2429 for (i = 0; i < num_chan; i++) { 2430 chan_enum = reg_get_chan_enum(chan_list[i]); 2431 if (chan_enum == INVALID_CHANNEL) { 2432 reg_err("Invalid ch in nol list, chan %d", 2433 chan_list[i]); 2434 continue; 2435 } 2436 mas_chan_list[chan_enum].nol_history = nol_history_chan; 2437 cur_chan_list[chan_enum].nol_history = nol_history_chan; 2438 } 2439 } 2440 2441 bool reg_is_24ghz_ch(uint32_t chan) 2442 { 2443 return REG_IS_24GHZ_CH(chan); 2444 } 2445 2446 bool reg_is_5ghz_ch(uint32_t chan) 2447 { 2448 return REG_IS_5GHZ_CH(chan); 2449 } 2450 #endif /* CONFIG_CHAN_NUM_API */ 2451 2452 bool reg_is_24ghz_ch_freq(uint32_t freq) 2453 { 2454 return REG_IS_24GHZ_CH_FREQ(freq); 2455 } 2456 2457 bool reg_is_5ghz_ch_freq(uint32_t freq) 2458 { 2459 return REG_IS_5GHZ_FREQ(freq); 2460 } 2461 2462 /** 2463 * BAND_2G_PRESENT() - Check if REG_BAND_2G is set in the band_mask 2464 * @band_mask: Bitmask for bands 2465 * 2466 * Return: True if REG_BAND_2G is set in the band_mask, else false 2467 */ 2468 static inline bool BAND_2G_PRESENT(uint8_t band_mask) 2469 { 2470 return !!(band_mask & (BIT(REG_BAND_2G))); 2471 } 2472 2473 /** 2474 * BAND_5G_PRESENT() - Check if REG_BAND_5G is set in the band_mask 2475 * @band_mask: Bitmask for bands 2476 * 2477 * Return: True if REG_BAND_5G is set in the band_mask, else false 2478 */ 2479 static inline bool BAND_5G_PRESENT(uint8_t band_mask) 2480 { 2481 return !!(band_mask & (BIT(REG_BAND_5G))); 2482 } 2483 2484 #ifdef CONFIG_BAND_6GHZ 2485 bool reg_is_6ghz_chan_freq(uint16_t freq) 2486 { 2487 return REG_IS_6GHZ_FREQ(freq); 2488 } 2489 2490 #ifdef CONFIG_6G_FREQ_OVERLAP 2491 /** 2492 * reg_is_freq_in_between() - Check whether freq falls within low_freq and 2493 * high_freq, inclusively. 2494 * @low_freq - Low frequency. 2495 * @high_freq - High frequency. 2496 * @freq - Frequency to be checked. 2497 * 2498 * Return: True if freq falls within low_freq and high_freq, else false. 2499 */ 2500 static bool reg_is_freq_in_between(qdf_freq_t low_freq, qdf_freq_t high_freq, 2501 qdf_freq_t freq) 2502 { 2503 return (low_freq <= freq && freq <= high_freq); 2504 } 2505 2506 static bool reg_is_ranges_overlap(qdf_freq_t low_freq, qdf_freq_t high_freq, 2507 qdf_freq_t start_edge_freq, 2508 qdf_freq_t end_edge_freq) 2509 { 2510 return (reg_is_freq_in_between(start_edge_freq, 2511 end_edge_freq, 2512 low_freq) || 2513 reg_is_freq_in_between(start_edge_freq, 2514 end_edge_freq, 2515 high_freq) || 2516 reg_is_freq_in_between(low_freq, 2517 high_freq, 2518 start_edge_freq) || 2519 reg_is_freq_in_between(low_freq, 2520 high_freq, 2521 end_edge_freq)); 2522 } 2523 2524 static bool reg_is_range_overlap_6g(qdf_freq_t low_freq, 2525 qdf_freq_t high_freq) 2526 { 2527 return reg_is_ranges_overlap(low_freq, high_freq, 2528 SIXG_STARTING_EDGE_FREQ, 2529 SIXG_ENDING_EDGE_FREQ); 2530 } 2531 2532 static bool reg_is_range_overlap_5g(qdf_freq_t low_freq, 2533 qdf_freq_t high_freq) 2534 { 2535 return reg_is_ranges_overlap(low_freq, high_freq, 2536 FIVEG_STARTING_EDGE_FREQ, 2537 FIVEG_ENDING_EDGE_FREQ); 2538 } 2539 2540 bool reg_is_range_only6g(qdf_freq_t low_freq, qdf_freq_t high_freq) 2541 { 2542 if (low_freq >= high_freq) { 2543 reg_err_rl("Low freq is greater than or equal to high freq"); 2544 return false; 2545 } 2546 2547 if (reg_is_range_overlap_6g(low_freq, high_freq) && 2548 !reg_is_range_overlap_5g(low_freq, high_freq)) { 2549 reg_debug_rl("The device is 6G only"); 2550 return true; 2551 } 2552 2553 reg_debug_rl("The device is not 6G only"); 2554 2555 return false; 2556 } 2557 #endif 2558 2559 uint16_t reg_min_6ghz_chan_freq(void) 2560 { 2561 return REG_MIN_6GHZ_CHAN_FREQ; 2562 } 2563 2564 uint16_t reg_max_6ghz_chan_freq(void) 2565 { 2566 return REG_MAX_6GHZ_CHAN_FREQ; 2567 } 2568 2569 bool reg_is_6ghz_psc_chan_freq(uint16_t freq) 2570 { 2571 if (!REG_IS_6GHZ_FREQ(freq)) { 2572 reg_debug(" Channel frequency is not a 6GHz frequency"); 2573 return false; 2574 } 2575 2576 if (!(((freq - SIX_GHZ_NON_ORPHAN_START_FREQ) + FREQ_LEFT_SHIFT) % 2577 (FREQ_TO_CHAN_SCALE * NUM_80MHZ_BAND_IN_6G))) { 2578 return true; 2579 } 2580 2581 reg_debug_rl("Channel freq %d MHz is not a 6GHz PSC frequency", freq); 2582 2583 return false; 2584 } 2585 2586 /** 2587 * reg_is_freq_indoor() - Check if the input frequency is an indoor frequency. 2588 * @pdev: Pointer to pdev. 2589 * @freq: Channel frequency. 2590 * 2591 * Return: Return true if the input frequency is indoor, else false. 2592 */ 2593 static bool reg_is_freq_indoor(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq) 2594 { 2595 struct regulatory_channel *cur_chan_list; 2596 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 2597 enum channel_enum chan_enum; 2598 2599 pdev_priv_obj = reg_get_pdev_obj(pdev); 2600 2601 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 2602 reg_err("reg pdev priv obj is NULL"); 2603 return false; 2604 } 2605 2606 chan_enum = reg_get_chan_enum_for_freq(freq); 2607 2608 if (chan_enum == INVALID_CHANNEL) { 2609 reg_err_rl("Invalid chan enum %d", chan_enum); 2610 return false; 2611 } 2612 2613 cur_chan_list = pdev_priv_obj->cur_chan_list; 2614 2615 return (cur_chan_list[chan_enum].chan_flags & 2616 REGULATORY_CHAN_INDOOR_ONLY); 2617 } 2618 2619 bool reg_is_6g_freq_indoor(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq) 2620 { 2621 return (REG_IS_6GHZ_FREQ(freq) && reg_is_freq_indoor(pdev, freq)); 2622 } 2623 2624 /** 2625 * BAND_6G_PRESENT() - Check if REG_BAND_6G is set in the band_mask 2626 * @band_mask: Bitmask for bands 2627 * 2628 * Return: True if REG_BAND_6G is set in the band_mask, else false 2629 */ 2630 static inline bool BAND_6G_PRESENT(uint8_t band_mask) 2631 { 2632 return !!(band_mask & (BIT(REG_BAND_6G))); 2633 } 2634 #else 2635 static inline bool BAND_6G_PRESENT(uint8_t band_mask) 2636 { 2637 return false; 2638 } 2639 #endif /* CONFIG_BAND_6GHZ */ 2640 2641 uint16_t 2642 reg_get_band_channel_list(struct wlan_objmgr_pdev *pdev, 2643 uint8_t band_mask, 2644 struct regulatory_channel *channel_list) 2645 { 2646 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 2647 struct regulatory_channel *cur_chan_list; 2648 uint16_t i, num_channels = 0; 2649 2650 pdev_priv_obj = reg_get_pdev_obj(pdev); 2651 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 2652 reg_err("reg pdev priv obj is NULL"); 2653 return 0; 2654 } 2655 2656 cur_chan_list = pdev_priv_obj->cur_chan_list; 2657 2658 if (BAND_2G_PRESENT(band_mask)) { 2659 for (i = MIN_24GHZ_CHANNEL; i <= MAX_24GHZ_CHANNEL; i++) { 2660 if ((cur_chan_list[i].state != CHANNEL_STATE_DISABLE) && 2661 !(cur_chan_list[i].chan_flags & 2662 REGULATORY_CHAN_DISABLED)) { 2663 channel_list[num_channels] = cur_chan_list[i]; 2664 num_channels++; 2665 } 2666 } 2667 } 2668 if (BAND_5G_PRESENT(band_mask)) { 2669 for (i = MIN_49GHZ_CHANNEL; i <= MAX_5GHZ_CHANNEL; i++) { 2670 if ((cur_chan_list[i].state != CHANNEL_STATE_DISABLE) && 2671 !(cur_chan_list[i].chan_flags & 2672 REGULATORY_CHAN_DISABLED)) { 2673 channel_list[num_channels] = cur_chan_list[i]; 2674 num_channels++; 2675 } 2676 } 2677 } 2678 if (BAND_6G_PRESENT(band_mask)) { 2679 for (i = MIN_6GHZ_CHANNEL; i <= MAX_6GHZ_CHANNEL; i++) { 2680 if ((cur_chan_list[i].state != CHANNEL_STATE_DISABLE) && 2681 !(cur_chan_list[i].chan_flags & 2682 REGULATORY_CHAN_DISABLED)) { 2683 channel_list[num_channels] = cur_chan_list[i]; 2684 num_channels++; 2685 } 2686 } 2687 } 2688 2689 if (!num_channels) { 2690 reg_err("Failed to retrieve the channel list"); 2691 return 0; 2692 } 2693 2694 return num_channels; 2695 } 2696 2697 qdf_freq_t reg_chan_band_to_freq(struct wlan_objmgr_pdev *pdev, 2698 uint8_t chan_num, 2699 uint8_t band_mask) 2700 { 2701 enum channel_enum min_chan, max_chan; 2702 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 2703 uint16_t freq; 2704 2705 if (chan_num == 0) { 2706 reg_err_rl("Invalid channel %d", chan_num); 2707 return 0; 2708 } 2709 2710 pdev_priv_obj = reg_get_pdev_obj(pdev); 2711 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 2712 reg_err("reg pdev priv obj is NULL"); 2713 return 0; 2714 } 2715 2716 if (BAND_6G_PRESENT(band_mask)) { 2717 if (BAND_2G_PRESENT(band_mask) || 2718 BAND_5G_PRESENT(band_mask)) { 2719 reg_err_rl("Incorrect band_mask %x", band_mask); 2720 return 0; 2721 } 2722 2723 min_chan = MIN_6GHZ_CHANNEL; 2724 max_chan = MAX_6GHZ_CHANNEL; 2725 return reg_compute_chan_to_freq(pdev, chan_num, 2726 min_chan, 2727 max_chan); 2728 } else { 2729 if (BAND_2G_PRESENT(band_mask)) { 2730 min_chan = MIN_24GHZ_CHANNEL; 2731 max_chan = MAX_24GHZ_CHANNEL; 2732 freq = reg_compute_chan_to_freq(pdev, chan_num, 2733 min_chan, 2734 max_chan); 2735 if (freq != 0) 2736 return freq; 2737 } 2738 2739 if (BAND_5G_PRESENT(band_mask)) { 2740 min_chan = MIN_49GHZ_CHANNEL; 2741 max_chan = MAX_5GHZ_CHANNEL; 2742 2743 return reg_compute_chan_to_freq(pdev, chan_num, 2744 min_chan, 2745 max_chan); 2746 } 2747 2748 reg_err_rl("Incorrect band_mask %x", band_mask); 2749 return 0; 2750 } 2751 } 2752 2753 bool reg_is_49ghz_freq(qdf_freq_t freq) 2754 { 2755 return REG_IS_49GHZ_FREQ(freq); 2756 } 2757 2758 qdf_freq_t reg_ch_num(uint32_t ch_enum) 2759 { 2760 return REG_CH_NUM(ch_enum); 2761 } 2762 2763 qdf_freq_t reg_ch_to_freq(uint32_t ch_enum) 2764 { 2765 return REG_CH_TO_FREQ(ch_enum); 2766 } 2767 2768 #ifdef CONFIG_CHAN_NUM_API 2769 bool reg_is_same_band_channels(uint8_t chan_num1, uint8_t chan_num2) 2770 { 2771 return (chan_num1 && chan_num2 && 2772 (REG_IS_5GHZ_CH(chan_num1) == REG_IS_5GHZ_CH(chan_num2))); 2773 } 2774 2775 bool reg_is_channel_valid_5g_sbs(uint8_t curchan, uint8_t newchan) 2776 { 2777 return REG_IS_CHANNEL_VALID_5G_SBS(curchan, newchan); 2778 } 2779 2780 uint8_t reg_min_24ghz_ch_num(void) 2781 { 2782 return REG_MIN_24GHZ_CH_NUM; 2783 } 2784 2785 uint8_t reg_max_24ghz_ch_num(void) 2786 { 2787 return REG_MAX_24GHZ_CH_NUM; 2788 } 2789 2790 uint8_t reg_min_5ghz_ch_num(void) 2791 { 2792 return REG_MIN_5GHZ_CH_NUM; 2793 } 2794 2795 uint8_t reg_max_5ghz_ch_num(void) 2796 { 2797 return REG_MAX_5GHZ_CH_NUM; 2798 } 2799 #endif /* CONFIG_CHAN_NUM_API */ 2800 2801 #ifdef CONFIG_CHAN_FREQ_API 2802 qdf_freq_t reg_min_24ghz_chan_freq(void) 2803 { 2804 return REG_MIN_24GHZ_CH_FREQ; 2805 } 2806 2807 qdf_freq_t reg_max_24ghz_chan_freq(void) 2808 { 2809 return REG_MAX_24GHZ_CH_FREQ; 2810 } 2811 2812 qdf_freq_t reg_min_5ghz_chan_freq(void) 2813 { 2814 return REG_MIN_5GHZ_CH_FREQ; 2815 } 2816 2817 qdf_freq_t reg_max_5ghz_chan_freq(void) 2818 { 2819 return REG_MAX_5GHZ_CH_FREQ; 2820 } 2821 #endif /* CONFIG_CHAN_FREQ_API */ 2822 2823 QDF_STATUS reg_enable_dfs_channels(struct wlan_objmgr_pdev *pdev, 2824 bool enable) 2825 { 2826 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 2827 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 2828 struct wlan_objmgr_psoc *psoc; 2829 QDF_STATUS status; 2830 struct wlan_lmac_if_reg_tx_ops *reg_tx_ops; 2831 2832 pdev_priv_obj = reg_get_pdev_obj(pdev); 2833 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 2834 reg_err("pdev reg component is NULL"); 2835 return QDF_STATUS_E_INVAL; 2836 } 2837 2838 if (pdev_priv_obj->dfs_enabled == enable) { 2839 reg_info("dfs_enabled is already set to %d", enable); 2840 return QDF_STATUS_SUCCESS; 2841 } 2842 2843 psoc = wlan_pdev_get_psoc(pdev); 2844 if (!psoc) { 2845 reg_err("psoc is NULL"); 2846 return QDF_STATUS_E_INVAL; 2847 } 2848 2849 psoc_priv_obj = reg_get_psoc_obj(psoc); 2850 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 2851 reg_err("psoc reg component is NULL"); 2852 return QDF_STATUS_E_INVAL; 2853 } 2854 2855 reg_info("set dfs_enabled: %d", enable); 2856 2857 pdev_priv_obj->dfs_enabled = enable; 2858 2859 reg_compute_pdev_current_chan_list(pdev_priv_obj); 2860 2861 reg_tx_ops = reg_get_psoc_tx_ops(psoc); 2862 2863 /* Fill the ic channel list with the updated current channel 2864 * chan list. 2865 */ 2866 if (reg_tx_ops->fill_umac_legacy_chanlist) 2867 reg_tx_ops->fill_umac_legacy_chanlist(pdev, 2868 pdev_priv_obj->cur_chan_list); 2869 2870 status = reg_send_scheduler_msg_sb(psoc, pdev); 2871 2872 return status; 2873 } 2874 2875 bool reg_is_regdmn_en302502_applicable(struct wlan_objmgr_pdev *pdev) 2876 { 2877 struct cur_regdmn_info cur_reg_dmn; 2878 QDF_STATUS status; 2879 2880 status = reg_get_curr_regdomain(pdev, &cur_reg_dmn); 2881 if (status != QDF_STATUS_SUCCESS) { 2882 reg_err("Failed to get reg domain"); 2883 return false; 2884 } 2885 2886 return reg_en302_502_regdmn(cur_reg_dmn.regdmn_pair_id); 2887 } 2888 2889 QDF_STATUS reg_get_phybitmap(struct wlan_objmgr_pdev *pdev, 2890 uint16_t *phybitmap) 2891 { 2892 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 2893 2894 pdev_priv_obj = reg_get_pdev_obj(pdev); 2895 2896 if (!pdev_priv_obj) { 2897 reg_err("reg pdev private obj is NULL"); 2898 return QDF_STATUS_E_FAULT; 2899 } 2900 2901 *phybitmap = pdev_priv_obj->phybitmap; 2902 2903 return QDF_STATUS_SUCCESS; 2904 } 2905 2906 QDF_STATUS reg_modify_pdev_chan_range(struct wlan_objmgr_pdev *pdev) 2907 { 2908 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 2909 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 2910 struct wlan_objmgr_psoc *psoc; 2911 struct wlan_lmac_if_reg_tx_ops *reg_tx_ops; 2912 struct wlan_psoc_host_hal_reg_capabilities_ext *reg_cap_ptr; 2913 uint32_t cnt; 2914 uint32_t phy_id; 2915 enum direction dir; 2916 QDF_STATUS status = QDF_STATUS_SUCCESS; 2917 struct target_pdev_info *tgt_pdev; 2918 2919 tgt_pdev = wlan_pdev_get_tgt_if_handle(pdev); 2920 phy_id = (uint32_t)target_pdev_get_phy_idx(tgt_pdev); 2921 pdev_priv_obj = reg_get_pdev_obj(pdev); 2922 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 2923 reg_err("pdev reg component is NULL"); 2924 return QDF_STATUS_E_INVAL; 2925 } 2926 2927 psoc = wlan_pdev_get_psoc(pdev); 2928 if (!psoc) { 2929 reg_err("psoc is NULL"); 2930 return QDF_STATUS_E_INVAL; 2931 } 2932 2933 psoc_priv_obj = reg_get_psoc_obj(psoc); 2934 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 2935 reg_err("psoc reg component is NULL"); 2936 return QDF_STATUS_E_INVAL; 2937 } 2938 2939 reg_cap_ptr = psoc_priv_obj->reg_cap; 2940 2941 for (cnt = 0; cnt < PSOC_MAX_PHY_REG_CAP; cnt++) { 2942 if (!reg_cap_ptr) { 2943 qdf_mem_free(pdev_priv_obj); 2944 reg_err("reg cap ptr is NULL"); 2945 return QDF_STATUS_E_FAULT; 2946 } 2947 2948 if (reg_cap_ptr->phy_id == phy_id) 2949 break; 2950 reg_cap_ptr++; 2951 } 2952 2953 if (cnt == PSOC_MAX_PHY_REG_CAP) { 2954 qdf_mem_free(pdev_priv_obj); 2955 reg_err("extended capabilities not found for pdev"); 2956 return QDF_STATUS_E_FAULT; 2957 } 2958 2959 if (psoc_priv_obj->offload_enabled) { 2960 dir = NORTHBOUND; 2961 } else { 2962 dir = SOUTHBOUND; 2963 } 2964 2965 pdev_priv_obj->range_2g_low = reg_cap_ptr->low_2ghz_chan; 2966 pdev_priv_obj->range_2g_high = reg_cap_ptr->high_2ghz_chan; 2967 pdev_priv_obj->range_5g_low = reg_cap_ptr->low_5ghz_chan; 2968 pdev_priv_obj->range_5g_high = reg_cap_ptr->high_5ghz_chan; 2969 pdev_priv_obj->wireless_modes = reg_cap_ptr->wireless_modes; 2970 2971 reg_compute_pdev_current_chan_list(pdev_priv_obj); 2972 2973 reg_tx_ops = reg_get_psoc_tx_ops(psoc); 2974 2975 /* Fill the ic channel list with the updated current channel 2976 * chan list. 2977 */ 2978 if (reg_tx_ops->fill_umac_legacy_chanlist) { 2979 reg_tx_ops->fill_umac_legacy_chanlist(pdev, 2980 pdev_priv_obj->cur_chan_list); 2981 2982 } else { 2983 if (dir == NORTHBOUND) 2984 status = reg_send_scheduler_msg_nb(psoc, pdev); 2985 else 2986 status = reg_send_scheduler_msg_sb(psoc, pdev); 2987 } 2988 2989 return status; 2990 } 2991 2992 QDF_STATUS reg_update_pdev_wireless_modes(struct wlan_objmgr_pdev *pdev, 2993 uint32_t wireless_modes) 2994 { 2995 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 2996 2997 pdev_priv_obj = wlan_objmgr_pdev_get_comp_private_obj(pdev, 2998 WLAN_UMAC_COMP_REGULATORY); 2999 3000 if (!pdev_priv_obj) { 3001 reg_err("reg pdev private obj is NULL"); 3002 return QDF_STATUS_E_INVAL; 3003 } 3004 3005 pdev_priv_obj->wireless_modes = wireless_modes; 3006 3007 return QDF_STATUS_SUCCESS; 3008 } 3009 3010 #ifdef DISABLE_UNII_SHARED_BANDS 3011 /** 3012 * reg_is_reg_unii_band_1_or_reg_unii_band_2a() - Check the input bitmap 3013 * @unii_5g_bitmap: 5G UNII band bitmap 3014 * 3015 * This function checks if either REG_UNII_BAND_1 or REG_UNII_BAND_2A, 3016 * are present in the 5G UNII band bitmap. 3017 * 3018 * Return: Return true if REG_UNII_BAND_1 or REG_UNII_BAND_2A, are present in 3019 * the UNII 5g bitmap else return false. 3020 */ 3021 static bool 3022 reg_is_reg_unii_band_1_or_reg_unii_band_2a(uint8_t unii_5g_bitmap) 3023 { 3024 if (!unii_5g_bitmap) 3025 return false; 3026 3027 return ((unii_5g_bitmap & (BIT(REG_UNII_BAND_1) | 3028 BIT(REG_UNII_BAND_2A))) == unii_5g_bitmap); 3029 } 3030 3031 QDF_STATUS reg_disable_chan_coex(struct wlan_objmgr_pdev *pdev, 3032 uint8_t unii_5g_bitmap) 3033 { 3034 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 3035 struct wlan_lmac_if_reg_tx_ops *reg_tx_ops; 3036 struct wlan_objmgr_psoc *psoc; 3037 3038 psoc = wlan_pdev_get_psoc(pdev); 3039 if (!psoc) { 3040 reg_err("psoc is NULL"); 3041 return QDF_STATUS_E_INVAL; 3042 } 3043 3044 pdev_priv_obj = reg_get_pdev_obj(pdev); 3045 3046 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 3047 reg_err_rl("reg pdev priv obj is NULL"); 3048 return QDF_STATUS_E_FAILURE; 3049 } 3050 3051 if (unii_5g_bitmap && 3052 !reg_is_reg_unii_band_1_or_reg_unii_band_2a(unii_5g_bitmap)) { 3053 reg_err_rl("Invalid unii_5g_bitmap = %d", unii_5g_bitmap); 3054 return QDF_STATUS_E_FAILURE; 3055 } 3056 3057 if (pdev_priv_obj->unii_5g_bitmap == unii_5g_bitmap) { 3058 reg_debug_rl("UNII bitmask for 5G channels is already set %d", 3059 unii_5g_bitmap); 3060 return QDF_STATUS_SUCCESS; 3061 } 3062 3063 reg_debug_rl("Setting UNII bitmask for 5G: %d", unii_5g_bitmap); 3064 pdev_priv_obj->unii_5g_bitmap = unii_5g_bitmap; 3065 3066 reg_compute_pdev_current_chan_list(pdev_priv_obj); 3067 3068 reg_tx_ops = reg_get_psoc_tx_ops(psoc); 3069 3070 if (reg_tx_ops->fill_umac_legacy_chanlist) { 3071 reg_tx_ops->fill_umac_legacy_chanlist(pdev, 3072 pdev_priv_obj->cur_chan_list); 3073 } 3074 3075 return QDF_STATUS_SUCCESS; 3076 } 3077 #endif 3078 3079 #ifdef CONFIG_CHAN_FREQ_API 3080 QDF_STATUS reg_get_channel_list_with_power_for_freq(struct wlan_objmgr_pdev 3081 *pdev, 3082 struct channel_power 3083 *ch_list, 3084 uint8_t *num_chan) 3085 { 3086 int i, count; 3087 struct regulatory_channel *reg_channels; 3088 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 3089 3090 if (!num_chan || !ch_list) { 3091 reg_err("chan_list or num_ch is NULL"); 3092 return QDF_STATUS_E_FAILURE; 3093 } 3094 3095 pdev_priv_obj = reg_get_pdev_obj(pdev); 3096 3097 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 3098 reg_err("reg pdev priv obj is NULL"); 3099 return QDF_STATUS_E_FAILURE; 3100 } 3101 3102 /* set the current channel list */ 3103 reg_channels = pdev_priv_obj->cur_chan_list; 3104 3105 for (i = 0, count = 0; i < NUM_CHANNELS; i++) { 3106 if (reg_channels[i].state && 3107 !(reg_channels[i].chan_flags & REGULATORY_CHAN_DISABLED)) { 3108 ch_list[count].center_freq = 3109 reg_channels[i].center_freq; 3110 ch_list[count++].tx_power = 3111 reg_channels[i].tx_power; 3112 } 3113 } 3114 3115 *num_chan = count; 3116 3117 return QDF_STATUS_SUCCESS; 3118 } 3119 3120 enum channel_enum reg_get_chan_enum_for_freq(qdf_freq_t freq) 3121 { 3122 uint32_t count; 3123 3124 for (count = 0; count < NUM_CHANNELS; count++) 3125 if (channel_map[count].center_freq == freq) 3126 return count; 3127 3128 reg_err("invalid channel center frequency %d", freq); 3129 3130 return INVALID_CHANNEL; 3131 } 3132 3133 bool 3134 reg_is_freq_present_in_cur_chan_list(struct wlan_objmgr_pdev *pdev, 3135 qdf_freq_t freq) 3136 { 3137 enum channel_enum chan_enum; 3138 struct regulatory_channel *cur_chan_list; 3139 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 3140 3141 pdev_priv_obj = reg_get_pdev_obj(pdev); 3142 3143 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 3144 reg_err_rl("pdev reg obj is NULL"); 3145 return false; 3146 } 3147 3148 cur_chan_list = pdev_priv_obj->cur_chan_list; 3149 3150 for (chan_enum = 0; chan_enum < NUM_CHANNELS; chan_enum++) 3151 if (cur_chan_list[chan_enum].center_freq == freq) 3152 if ((cur_chan_list[chan_enum].state != 3153 CHANNEL_STATE_DISABLE) && 3154 !(cur_chan_list[chan_enum].chan_flags & 3155 REGULATORY_CHAN_DISABLED)) 3156 return true; 3157 3158 reg_debug_rl("Channel center frequency %d not found", freq); 3159 3160 return false; 3161 } 3162 3163 enum channel_state reg_get_channel_state_for_freq(struct wlan_objmgr_pdev *pdev, 3164 qdf_freq_t freq) 3165 { 3166 enum channel_enum ch_idx; 3167 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 3168 3169 ch_idx = reg_get_chan_enum_for_freq(freq); 3170 3171 if (ch_idx == INVALID_CHANNEL) 3172 return CHANNEL_STATE_INVALID; 3173 3174 pdev_priv_obj = reg_get_pdev_obj(pdev); 3175 3176 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 3177 reg_err("pdev reg obj is NULL"); 3178 return CHANNEL_STATE_INVALID; 3179 } 3180 3181 return pdev_priv_obj->cur_chan_list[ch_idx].state; 3182 } 3183 3184 static uint32_t reg_get_channel_flags_for_freq(struct wlan_objmgr_pdev *pdev, 3185 qdf_freq_t freq) 3186 { 3187 enum channel_enum chan_enum; 3188 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 3189 3190 chan_enum = reg_get_chan_enum_for_freq(freq); 3191 3192 if (chan_enum == INVALID_CHANNEL) { 3193 reg_err("chan freq is not valid"); 3194 return REGULATORY_CHAN_INVALID; 3195 } 3196 3197 pdev_priv_obj = reg_get_pdev_obj(pdev); 3198 3199 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 3200 reg_err("pdev reg obj is NULL"); 3201 return REGULATORY_CHAN_INVALID; 3202 } 3203 3204 return pdev_priv_obj->cur_chan_list[chan_enum].chan_flags; 3205 } 3206 3207 /** 3208 * reg_get_5g_bonded_chan_array_for_freq()- Return the channel state for a 3209 * 5G or 6G channel frequency based on the bonded channel. 3210 * @pdev: Pointer to pdev. 3211 * @freq: Channel center frequency. 3212 * @bonded_chan_ar: Array of bonded channel frequencies. 3213 * @array_size: Array size. 3214 * @bonded_chan_ptr_ptr: Pointer to bonded_channel_freq. 3215 * 3216 * Return: Channel State 3217 */ 3218 static enum channel_state 3219 reg_get_5g_bonded_chan_array_for_freq(struct wlan_objmgr_pdev *pdev, 3220 uint16_t freq, 3221 const struct bonded_channel_freq 3222 bonded_chan_ar[], 3223 uint16_t array_size, 3224 const struct bonded_channel_freq 3225 **bonded_chan_ptr_ptr) 3226 { 3227 int i; 3228 uint16_t chan_cfreq; 3229 const struct bonded_channel_freq *bonded_chan_ptr = NULL; 3230 enum channel_state chan_state = CHANNEL_STATE_INVALID; 3231 enum channel_state temp_chan_state; 3232 3233 for (i = 0; i < array_size; i++) { 3234 if ((freq >= bonded_chan_ar[i].start_freq) && 3235 (freq <= bonded_chan_ar[i].end_freq)) { 3236 bonded_chan_ptr = &bonded_chan_ar[i]; 3237 break; 3238 } 3239 } 3240 3241 if (!bonded_chan_ptr) 3242 return chan_state; 3243 3244 *bonded_chan_ptr_ptr = bonded_chan_ptr; 3245 chan_cfreq = bonded_chan_ptr->start_freq; 3246 while (chan_cfreq <= bonded_chan_ptr->end_freq) { 3247 temp_chan_state = reg_get_channel_state_for_freq(pdev, 3248 chan_cfreq); 3249 if (temp_chan_state < chan_state) 3250 chan_state = temp_chan_state; 3251 chan_cfreq = chan_cfreq + 20; 3252 } 3253 3254 return chan_state; 3255 } 3256 3257 /** 3258 * reg_get_5g_bonded_channel_for_freq()- Return the channel state for a 3259 * 5G or 6G channel frequency based on the channel width and bonded channel 3260 * @pdev: Pointer to pdev. 3261 * @freq: Channel center frequency. 3262 * @ch_width: Channel Width. 3263 * @bonded_chan_ptr_ptr: Pointer to bonded_channel_freq. 3264 * 3265 * Return: Channel State 3266 */ 3267 enum channel_state 3268 reg_get_5g_bonded_channel_for_freq(struct wlan_objmgr_pdev *pdev, 3269 uint16_t freq, 3270 enum phy_ch_width ch_width, 3271 const struct bonded_channel_freq 3272 **bonded_chan_ptr_ptr) 3273 3274 { 3275 if (ch_width == CH_WIDTH_80P80MHZ) 3276 return reg_get_5g_bonded_chan_array_for_freq(pdev, freq, 3277 bonded_chan_80mhz_list_freq, 3278 QDF_ARRAY_SIZE(bonded_chan_80mhz_list_freq), 3279 bonded_chan_ptr_ptr); 3280 else if (ch_width == CH_WIDTH_160MHZ) 3281 return reg_get_5g_bonded_chan_array_for_freq(pdev, freq, 3282 bonded_chan_160mhz_list_freq, 3283 QDF_ARRAY_SIZE(bonded_chan_160mhz_list_freq), 3284 bonded_chan_ptr_ptr); 3285 else if (ch_width == CH_WIDTH_80MHZ) 3286 return reg_get_5g_bonded_chan_array_for_freq(pdev, freq, 3287 bonded_chan_80mhz_list_freq, 3288 QDF_ARRAY_SIZE(bonded_chan_80mhz_list_freq), 3289 bonded_chan_ptr_ptr); 3290 else if (ch_width == CH_WIDTH_40MHZ) 3291 return reg_get_5g_bonded_chan_array_for_freq(pdev, freq, 3292 bonded_chan_40mhz_list_freq, 3293 QDF_ARRAY_SIZE(bonded_chan_40mhz_list_freq), 3294 bonded_chan_ptr_ptr); 3295 else 3296 return reg_get_channel_state_for_freq(pdev, freq); 3297 } 3298 3299 enum channel_state 3300 reg_get_5g_bonded_channel_state_for_freq(struct wlan_objmgr_pdev *pdev, 3301 qdf_freq_t freq, 3302 enum phy_ch_width bw) 3303 { 3304 enum channel_enum ch_indx; 3305 enum channel_state chan_state; 3306 struct regulatory_channel *reg_channels; 3307 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 3308 bool bw_enabled = false; 3309 const struct bonded_channel_freq *bonded_chan_ptr = NULL; 3310 3311 if (bw > CH_WIDTH_80P80MHZ) { 3312 reg_err("bw passed is not good"); 3313 return CHANNEL_STATE_INVALID; 3314 } 3315 3316 chan_state = reg_get_5g_bonded_channel_for_freq(pdev, freq, bw, 3317 &bonded_chan_ptr); 3318 3319 if ((chan_state == CHANNEL_STATE_INVALID) || 3320 (chan_state == CHANNEL_STATE_DISABLE)) 3321 return chan_state; 3322 3323 pdev_priv_obj = reg_get_pdev_obj(pdev); 3324 3325 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 3326 reg_err("pdev reg obj is NULL"); 3327 return CHANNEL_STATE_INVALID; 3328 } 3329 reg_channels = pdev_priv_obj->cur_chan_list; 3330 3331 ch_indx = reg_get_chan_enum_for_freq(freq); 3332 if (ch_indx == INVALID_CHANNEL) 3333 return CHANNEL_STATE_INVALID; 3334 if (bw == CH_WIDTH_5MHZ) 3335 bw_enabled = true; 3336 else if (bw == CH_WIDTH_10MHZ) 3337 bw_enabled = (reg_channels[ch_indx].min_bw <= 10) && 3338 (reg_channels[ch_indx].max_bw >= 10); 3339 else if (bw == CH_WIDTH_20MHZ) 3340 bw_enabled = (reg_channels[ch_indx].min_bw <= 20) && 3341 (reg_channels[ch_indx].max_bw >= 20); 3342 else if (bw == CH_WIDTH_40MHZ) 3343 bw_enabled = (reg_channels[ch_indx].min_bw <= 40) && 3344 (reg_channels[ch_indx].max_bw >= 40); 3345 else if (bw == CH_WIDTH_80MHZ) 3346 bw_enabled = (reg_channels[ch_indx].min_bw <= 80) && 3347 (reg_channels[ch_indx].max_bw >= 80); 3348 else if (bw == CH_WIDTH_160MHZ) 3349 bw_enabled = (reg_channels[ch_indx].min_bw <= 160) && 3350 (reg_channels[ch_indx].max_bw >= 160); 3351 else if (bw == CH_WIDTH_80P80MHZ) 3352 bw_enabled = (reg_channels[ch_indx].min_bw <= 80) && 3353 (reg_channels[ch_indx].max_bw >= 80); 3354 3355 if (bw_enabled) 3356 return chan_state; 3357 else 3358 return CHANNEL_STATE_DISABLE; 3359 } 3360 3361 enum channel_state 3362 reg_get_2g_bonded_channel_state_for_freq(struct wlan_objmgr_pdev *pdev, 3363 qdf_freq_t oper_ch_freq, 3364 qdf_freq_t sec_ch_freq, 3365 enum phy_ch_width bw) 3366 { 3367 enum channel_enum chan_idx; 3368 enum channel_state chan_state; 3369 struct regulatory_channel *reg_channels; 3370 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 3371 bool bw_enabled = false; 3372 enum channel_state chan_state2 = CHANNEL_STATE_INVALID; 3373 3374 if (bw > CH_WIDTH_40MHZ) 3375 return CHANNEL_STATE_INVALID; 3376 3377 if (bw == CH_WIDTH_40MHZ) { 3378 if ((sec_ch_freq + 20 != oper_ch_freq) && 3379 (oper_ch_freq + 20 != sec_ch_freq)) 3380 return CHANNEL_STATE_INVALID; 3381 chan_state2 = reg_get_channel_state_for_freq(pdev, sec_ch_freq); 3382 if (chan_state2 == CHANNEL_STATE_INVALID) 3383 return chan_state2; 3384 } 3385 3386 pdev_priv_obj = reg_get_pdev_obj(pdev); 3387 3388 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 3389 reg_err("reg pdev priv obj is NULL"); 3390 return CHANNEL_STATE_INVALID; 3391 } 3392 3393 reg_channels = pdev_priv_obj->cur_chan_list; 3394 3395 chan_state = reg_get_channel_state_for_freq(pdev, oper_ch_freq); 3396 if (chan_state2 < chan_state) 3397 chan_state = chan_state2; 3398 3399 if ((chan_state == CHANNEL_STATE_INVALID) || 3400 (chan_state == CHANNEL_STATE_DISABLE)) 3401 return chan_state; 3402 3403 chan_idx = reg_get_chan_enum_for_freq(oper_ch_freq); 3404 if (chan_idx == INVALID_CHANNEL) 3405 return CHANNEL_STATE_INVALID; 3406 if (bw == CH_WIDTH_5MHZ) 3407 bw_enabled = true; 3408 else if (bw == CH_WIDTH_10MHZ) 3409 bw_enabled = (reg_channels[chan_idx].min_bw <= 10) && 3410 (reg_channels[chan_idx].max_bw >= 10); 3411 else if (bw == CH_WIDTH_20MHZ) 3412 bw_enabled = (reg_channels[chan_idx].min_bw <= 20) && 3413 (reg_channels[chan_idx].max_bw >= 20); 3414 else if (bw == CH_WIDTH_40MHZ) 3415 bw_enabled = (reg_channels[chan_idx].min_bw <= 40) && 3416 (reg_channels[chan_idx].max_bw >= 40); 3417 3418 if (bw_enabled) 3419 return chan_state; 3420 else 3421 return CHANNEL_STATE_DISABLE; 3422 3423 return CHANNEL_STATE_ENABLE; 3424 } 3425 3426 /** 3427 * reg_set_5g_channel_params_for_freq()- Set channel parameters like center 3428 * frequency for a bonded channel state. Also return the maximum bandwidth 3429 * supported by the channel. 3430 * @pdev: Pointer to pdev. 3431 * @freq: Channel center frequency. 3432 * ch_params: Pointer to ch_params. 3433 * 3434 * Return: void 3435 */ 3436 static void reg_set_5g_channel_params_for_freq(struct wlan_objmgr_pdev *pdev, 3437 uint16_t freq, 3438 struct ch_params *ch_params) 3439 { 3440 /* 3441 * Set channel parameters like center frequency for a bonded channel 3442 * state. Also return the maximum bandwidth supported by the channel. 3443 */ 3444 3445 enum channel_state chan_state = CHANNEL_STATE_ENABLE; 3446 enum channel_state chan_state2 = CHANNEL_STATE_ENABLE; 3447 const struct bonded_channel_freq *bonded_chan_ptr = NULL; 3448 const struct bonded_channel_freq *bonded_chan_ptr2 = NULL; 3449 3450 if (!ch_params) { 3451 reg_err("ch_params is NULL"); 3452 return; 3453 } 3454 3455 if (ch_params->ch_width >= CH_WIDTH_MAX) { 3456 if (ch_params->mhz_freq_seg1 != 0) 3457 ch_params->ch_width = CH_WIDTH_80P80MHZ; 3458 else 3459 ch_params->ch_width = CH_WIDTH_160MHZ; 3460 } 3461 3462 while (ch_params->ch_width != CH_WIDTH_INVALID) { 3463 bonded_chan_ptr = NULL; 3464 bonded_chan_ptr2 = NULL; 3465 chan_state = reg_get_5g_bonded_channel_for_freq( 3466 pdev, freq, ch_params->ch_width, 3467 &bonded_chan_ptr); 3468 3469 chan_state = reg_get_5g_bonded_channel_state_for_freq( 3470 pdev, freq, ch_params->ch_width); 3471 3472 if (ch_params->ch_width == CH_WIDTH_80P80MHZ) { 3473 chan_state2 = reg_get_5g_bonded_channel_state_for_freq( 3474 pdev, ch_params->mhz_freq_seg1 - 3475 NEAREST_20MHZ_CHAN_FREQ_OFFSET, 3476 CH_WIDTH_80MHZ); 3477 3478 chan_state = reg_combine_channel_states( 3479 chan_state, chan_state2); 3480 } 3481 3482 if ((chan_state != CHANNEL_STATE_ENABLE) && 3483 (chan_state != CHANNEL_STATE_DFS)) 3484 goto update_bw; 3485 if (ch_params->ch_width <= CH_WIDTH_20MHZ) { 3486 ch_params->sec_ch_offset = NO_SEC_CH; 3487 ch_params->mhz_freq_seg0 = freq; 3488 ch_params->center_freq_seg0 = 3489 reg_freq_to_chan(pdev, 3490 ch_params->mhz_freq_seg0); 3491 break; 3492 } else if (ch_params->ch_width >= CH_WIDTH_40MHZ) { 3493 reg_get_5g_bonded_chan_array_for_freq( 3494 pdev, freq, bonded_chan_40mhz_list_freq, 3495 QDF_ARRAY_SIZE(bonded_chan_40mhz_list_freq), 3496 &bonded_chan_ptr2); 3497 if (!bonded_chan_ptr || !bonded_chan_ptr2) 3498 goto update_bw; 3499 if (freq == bonded_chan_ptr2->start_freq) 3500 ch_params->sec_ch_offset = LOW_PRIMARY_CH; 3501 else 3502 ch_params->sec_ch_offset = HIGH_PRIMARY_CH; 3503 3504 ch_params->mhz_freq_seg0 = 3505 (bonded_chan_ptr->start_freq + 3506 bonded_chan_ptr->end_freq) / 2; 3507 ch_params->center_freq_seg0 = 3508 reg_freq_to_chan(pdev, 3509 ch_params->mhz_freq_seg0); 3510 break; 3511 } 3512 update_bw: 3513 ch_params->ch_width = get_next_lower_bw[ch_params->ch_width]; 3514 } 3515 3516 if (ch_params->ch_width == CH_WIDTH_160MHZ) { 3517 ch_params->mhz_freq_seg1 = ch_params->mhz_freq_seg0; 3518 ch_params->center_freq_seg1 = 3519 reg_freq_to_chan(pdev, 3520 ch_params->mhz_freq_seg1); 3521 3522 chan_state = reg_get_5g_bonded_channel_for_freq( 3523 pdev, freq, CH_WIDTH_80MHZ, &bonded_chan_ptr); 3524 if (bonded_chan_ptr) { 3525 ch_params->mhz_freq_seg0 = 3526 (bonded_chan_ptr->start_freq + 3527 bonded_chan_ptr->end_freq) / 2; 3528 ch_params->center_freq_seg0 = 3529 reg_freq_to_chan(pdev, 3530 ch_params->mhz_freq_seg0); 3531 } 3532 } 3533 3534 /* Overwrite mhz_freq_seg1 to 0 for non 160 and 80+80 width */ 3535 if (!(ch_params->ch_width == CH_WIDTH_160MHZ || 3536 ch_params->ch_width == CH_WIDTH_80P80MHZ)) { 3537 ch_params->mhz_freq_seg1 = 0; 3538 ch_params->center_freq_seg1 = 0; 3539 } 3540 } 3541 3542 /** 3543 * reg_set_2g_channel_params_for_freq() - set the 2.4G bonded channel parameters 3544 * @oper_freq: operating channel 3545 * @ch_params: channel parameters 3546 * @sec_ch_2g_freq: 2.4G secondary channel 3547 * 3548 * Return: void 3549 */ 3550 static void reg_set_2g_channel_params_for_freq(struct wlan_objmgr_pdev *pdev, 3551 uint16_t oper_freq, 3552 struct ch_params *ch_params, 3553 uint16_t sec_ch_2g_freq) 3554 { 3555 enum channel_state chan_state = CHANNEL_STATE_ENABLE; 3556 3557 if (ch_params->ch_width >= CH_WIDTH_MAX) 3558 ch_params->ch_width = CH_WIDTH_40MHZ; 3559 if ((reg_get_bw_value(ch_params->ch_width) > 20) && !sec_ch_2g_freq) { 3560 if (oper_freq >= TWOG_CHAN_1_IN_MHZ && oper_freq <= 3561 TWOG_CHAN_5_IN_MHZ) 3562 sec_ch_2g_freq = oper_freq + 20; 3563 else if (oper_freq >= TWOG_CHAN_6_IN_MHZ && oper_freq <= 3564 TWOG_CHAN_13_IN_MHZ) 3565 sec_ch_2g_freq = oper_freq - 20; 3566 } 3567 3568 while (ch_params->ch_width != CH_WIDTH_INVALID) { 3569 chan_state = 3570 reg_get_2g_bonded_channel_state_for_freq(pdev, oper_freq, 3571 sec_ch_2g_freq, 3572 ch_params->ch_width); 3573 if (chan_state == CHANNEL_STATE_ENABLE) { 3574 if (ch_params->ch_width == CH_WIDTH_40MHZ) { 3575 if (oper_freq < sec_ch_2g_freq) 3576 ch_params->sec_ch_offset = 3577 LOW_PRIMARY_CH; 3578 else 3579 ch_params->sec_ch_offset = 3580 HIGH_PRIMARY_CH; 3581 ch_params->mhz_freq_seg0 = 3582 (oper_freq + sec_ch_2g_freq) / 2; 3583 if (ch_params->mhz_freq_seg0 == 3584 TWOG_CHAN_14_IN_MHZ) 3585 ch_params->center_freq_seg0 = 14; 3586 else 3587 ch_params->center_freq_seg0 = 3588 (ch_params->mhz_freq_seg0 - 3589 TWOG_STARTING_FREQ) / 3590 FREQ_TO_CHAN_SCALE; 3591 } else { 3592 ch_params->sec_ch_offset = NO_SEC_CH; 3593 ch_params->mhz_freq_seg0 = oper_freq; 3594 if (ch_params->mhz_freq_seg0 == 3595 TWOG_CHAN_14_IN_MHZ) 3596 ch_params->center_freq_seg0 = 14; 3597 else 3598 ch_params->center_freq_seg0 = 3599 (ch_params->mhz_freq_seg0 - 3600 TWOG_STARTING_FREQ) / 3601 FREQ_TO_CHAN_SCALE; 3602 } 3603 break; 3604 } 3605 3606 ch_params->ch_width = get_next_lower_bw[ch_params->ch_width]; 3607 } 3608 /* Overwrite mhz_freq_seg1 and center_freq_seg1 to 0 for 2.4 Ghz */ 3609 ch_params->mhz_freq_seg1 = 0; 3610 ch_params->center_freq_seg1 = 0; 3611 } 3612 3613 void reg_set_channel_params_for_freq(struct wlan_objmgr_pdev *pdev, 3614 qdf_freq_t freq, 3615 qdf_freq_t sec_ch_2g_freq, 3616 struct ch_params *ch_params) 3617 { 3618 if (reg_is_5ghz_ch_freq(freq) || reg_is_6ghz_chan_freq(freq)) 3619 reg_set_5g_channel_params_for_freq(pdev, freq, ch_params); 3620 else if (reg_is_24ghz_ch_freq(freq)) 3621 reg_set_2g_channel_params_for_freq(pdev, freq, ch_params, 3622 sec_ch_2g_freq); 3623 } 3624 3625 uint8_t reg_get_channel_reg_power_for_freq(struct wlan_objmgr_pdev *pdev, 3626 qdf_freq_t freq) 3627 { 3628 enum channel_enum chan_enum; 3629 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 3630 struct regulatory_channel *reg_channels; 3631 3632 chan_enum = reg_get_chan_enum_for_freq(freq); 3633 3634 if (chan_enum == INVALID_CHANNEL) { 3635 reg_err("channel is invalid"); 3636 return REG_INVALID_TXPOWER; 3637 } 3638 3639 pdev_priv_obj = reg_get_pdev_obj(pdev); 3640 3641 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 3642 reg_err("reg pdev priv obj is NULL"); 3643 return REG_INVALID_TXPOWER; 3644 } 3645 3646 reg_channels = pdev_priv_obj->cur_chan_list; 3647 3648 return reg_channels[chan_enum].tx_power; 3649 } 3650 3651 bool reg_is_dfs_for_freq(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq) 3652 { 3653 uint32_t chan_flags; 3654 3655 chan_flags = reg_get_channel_flags_for_freq(pdev, freq); 3656 3657 return chan_flags & REGULATORY_CHAN_RADAR; 3658 } 3659 3660 #ifdef CONFIG_REG_CLIENT 3661 /** 3662 * reg_get_psoc_mas_chan_list () - Get psoc master channel list 3663 * @pdev: pointer to pdev object 3664 * @psoc: pointer to psoc object 3665 * 3666 * Return: psoc master chanel list 3667 */ 3668 static struct regulatory_channel *reg_get_psoc_mas_chan_list( 3669 struct wlan_objmgr_pdev *pdev, 3670 struct wlan_objmgr_psoc *psoc) 3671 { 3672 struct wlan_regulatory_psoc_priv_obj *soc_reg; 3673 uint8_t pdev_id; 3674 uint8_t phy_id; 3675 struct wlan_lmac_if_reg_tx_ops *reg_tx_ops; 3676 3677 soc_reg = reg_get_psoc_obj(psoc); 3678 if (!soc_reg) { 3679 reg_err("reg psoc private obj is NULL"); 3680 return NULL; 3681 } 3682 pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev); 3683 3684 reg_tx_ops = reg_get_psoc_tx_ops(psoc); 3685 if (reg_tx_ops->get_phy_id_from_pdev_id) 3686 reg_tx_ops->get_phy_id_from_pdev_id(psoc, pdev_id, &phy_id); 3687 else 3688 phy_id = pdev_id; 3689 3690 return soc_reg->mas_chan_params[phy_id].mas_chan_list; 3691 } 3692 #else 3693 static inline struct regulatory_channel *reg_get_psoc_mas_chan_list( 3694 struct wlan_objmgr_pdev *pdev, 3695 struct wlan_objmgr_psoc *psoc) 3696 { 3697 return NULL; 3698 } 3699 #endif 3700 3701 void reg_update_nol_ch_for_freq(struct wlan_objmgr_pdev *pdev, 3702 uint16_t *chan_freq_list, 3703 uint8_t num_chan, 3704 bool nol_chan) 3705 { 3706 enum channel_enum chan_enum; 3707 struct regulatory_channel *mas_chan_list, *psoc_mas_chan_list; 3708 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 3709 struct wlan_objmgr_psoc *psoc; 3710 uint16_t i; 3711 3712 if (!num_chan || !chan_freq_list) { 3713 reg_err("chan_freq_list or num_ch is NULL"); 3714 return; 3715 } 3716 3717 psoc = wlan_pdev_get_psoc(pdev); 3718 3719 pdev_priv_obj = reg_get_pdev_obj(pdev); 3720 if (!pdev_priv_obj) { 3721 reg_err("reg pdev private obj is NULL"); 3722 return; 3723 } 3724 3725 psoc_mas_chan_list = reg_get_psoc_mas_chan_list(pdev, psoc); 3726 3727 mas_chan_list = pdev_priv_obj->mas_chan_list; 3728 for (i = 0; i < num_chan; i++) { 3729 chan_enum = reg_get_chan_enum_for_freq(chan_freq_list[i]); 3730 if (chan_enum == INVALID_CHANNEL) { 3731 reg_err("Invalid freq in nol list, freq %d", 3732 chan_freq_list[i]); 3733 continue; 3734 } 3735 mas_chan_list[chan_enum].nol_chan = nol_chan; 3736 if (psoc_mas_chan_list) 3737 psoc_mas_chan_list[chan_enum].nol_chan = nol_chan; 3738 } 3739 3740 reg_compute_pdev_current_chan_list(pdev_priv_obj); 3741 3742 reg_send_scheduler_msg_sb(psoc, pdev); 3743 } 3744 3745 void reg_update_nol_history_ch_for_freq(struct wlan_objmgr_pdev *pdev, 3746 uint16_t *chan_list, 3747 uint8_t num_chan, 3748 bool nol_history_chan) 3749 { 3750 enum channel_enum chan_enum; 3751 struct regulatory_channel *mas_chan_list; 3752 struct regulatory_channel *cur_chan_list; 3753 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 3754 uint16_t i; 3755 3756 if (!num_chan || !chan_list) { 3757 reg_err("chan_list or num_ch is NULL"); 3758 return; 3759 } 3760 3761 pdev_priv_obj = wlan_objmgr_pdev_get_comp_private_obj( 3762 pdev, WLAN_UMAC_COMP_REGULATORY); 3763 3764 if (!pdev_priv_obj) { 3765 reg_err("reg psoc private obj is NULL"); 3766 return; 3767 } 3768 3769 mas_chan_list = pdev_priv_obj->mas_chan_list; 3770 cur_chan_list = pdev_priv_obj->cur_chan_list; 3771 3772 for (i = 0; i < num_chan; i++) { 3773 chan_enum = reg_get_chan_enum_for_freq(chan_list[i]); 3774 if (chan_enum == INVALID_CHANNEL) { 3775 reg_err("Invalid ch in nol list, chan %d", 3776 chan_list[i]); 3777 continue; 3778 } 3779 mas_chan_list[chan_enum].nol_history = nol_history_chan; 3780 cur_chan_list[chan_enum].nol_history = nol_history_chan; 3781 } 3782 } 3783 3784 static inline bool REG_IS_FREQUENCY_VALID_5G_SBS(qdf_freq_t curfreq, 3785 qdf_freq_t newfreq) 3786 { 3787 return ((curfreq) > (newfreq) ? 3788 REG_CH_TO_FREQ(reg_get_chan_enum_for_freq(curfreq)) 3789 - REG_CH_TO_FREQ(reg_get_chan_enum_for_freq(newfreq)) 3790 > REG_SBS_SEPARATION_THRESHOLD : 3791 REG_CH_TO_FREQ(reg_get_chan_enum_for_freq(newfreq)) 3792 - REG_CH_TO_FREQ(reg_get_chan_enum_for_freq(curfreq)) 3793 > REG_SBS_SEPARATION_THRESHOLD); 3794 } 3795 3796 bool reg_is_frequency_valid_5g_sbs(qdf_freq_t curfreq, qdf_freq_t newfreq) 3797 { 3798 return REG_IS_FREQUENCY_VALID_5G_SBS(curfreq, newfreq); 3799 } 3800 3801 qdf_freq_t reg_min_chan_freq(void) 3802 { 3803 return channel_map[MIN_24GHZ_CHANNEL].center_freq; 3804 } 3805 3806 qdf_freq_t reg_max_chan_freq(void) 3807 { 3808 return channel_map[NUM_CHANNELS - 1].center_freq; 3809 } 3810 3811 bool reg_is_same_band_freqs(qdf_freq_t freq1, qdf_freq_t freq2) 3812 { 3813 return (freq1 && freq2 && ((REG_IS_6GHZ_FREQ(freq1) && 3814 REG_IS_6GHZ_FREQ(freq2)) || 3815 (REG_IS_5GHZ_FREQ(freq1) && 3816 REG_IS_5GHZ_FREQ(freq2)) || 3817 (REG_IS_24GHZ_CH_FREQ(freq1) && 3818 REG_IS_24GHZ_CH_FREQ(freq2)))); 3819 } 3820 3821 enum reg_wifi_band reg_freq_to_band(qdf_freq_t freq) 3822 { 3823 if (REG_IS_24GHZ_CH_FREQ(freq)) 3824 return REG_BAND_2G; 3825 else if (REG_IS_5GHZ_FREQ(freq) || REG_IS_49GHZ_FREQ(freq)) 3826 return REG_BAND_5G; 3827 else if (REG_IS_6GHZ_FREQ(freq)) 3828 return REG_BAND_6G; 3829 return REG_BAND_UNKNOWN; 3830 } 3831 3832 bool reg_is_disable_for_freq(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq) 3833 { 3834 enum channel_state ch_state; 3835 3836 ch_state = reg_get_channel_state_for_freq(pdev, freq); 3837 3838 return ch_state == CHANNEL_STATE_DISABLE; 3839 } 3840 #endif /* CONFIG_CHAN_FREQ_API */ 3841 3842 uint8_t reg_get_max_tx_power(struct wlan_objmgr_pdev *pdev) 3843 { 3844 struct regulatory_channel *cur_chan_list; 3845 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 3846 uint8_t i, max_tx_power = 0; 3847 3848 pdev_priv_obj = reg_get_pdev_obj(pdev); 3849 3850 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 3851 reg_err("reg pdev private obj is NULL"); 3852 return QDF_STATUS_E_FAILURE; 3853 } 3854 3855 cur_chan_list = pdev_priv_obj->cur_chan_list; 3856 3857 for (i = 0; i < NUM_CHANNELS; i++) { 3858 if (cur_chan_list[i].state != CHANNEL_STATE_DISABLE && 3859 cur_chan_list[i].chan_flags != REGULATORY_CHAN_DISABLED) { 3860 if (cur_chan_list[i].tx_power > max_tx_power) 3861 max_tx_power = cur_chan_list[i].tx_power; 3862 } 3863 } 3864 3865 if (!max_tx_power) 3866 reg_err_rl("max_tx_power is zero"); 3867 3868 return max_tx_power; 3869 } 3870 3871 QDF_STATUS reg_set_ignore_fw_reg_offload_ind(struct wlan_objmgr_psoc *psoc) 3872 { 3873 struct wlan_regulatory_psoc_priv_obj *psoc_reg; 3874 3875 psoc_reg = reg_get_psoc_obj(psoc); 3876 if (!IS_VALID_PSOC_REG_OBJ(psoc_reg)) { 3877 reg_err("psoc reg component is NULL"); 3878 return QDF_STATUS_E_INVAL; 3879 } 3880 3881 psoc_reg->ignore_fw_reg_offload_ind = true; 3882 return QDF_STATUS_SUCCESS; 3883 } 3884 3885 bool reg_get_ignore_fw_reg_offload_ind(struct wlan_objmgr_psoc *psoc) 3886 { 3887 struct wlan_regulatory_psoc_priv_obj *psoc_reg; 3888 3889 psoc_reg = reg_get_psoc_obj(psoc); 3890 if (!IS_VALID_PSOC_REG_OBJ(psoc_reg)) 3891 return false; 3892 3893 return psoc_reg->ignore_fw_reg_offload_ind; 3894 } 3895 3896 QDF_STATUS reg_set_6ghz_supported(struct wlan_objmgr_psoc *psoc, bool val) 3897 { 3898 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 3899 3900 psoc_priv_obj = reg_get_psoc_obj(psoc); 3901 3902 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 3903 reg_err("psoc reg component is NULL"); 3904 return QDF_STATUS_E_FAILURE; 3905 } 3906 3907 psoc_priv_obj->six_ghz_supported = val; 3908 3909 return QDF_STATUS_SUCCESS; 3910 } 3911 3912 QDF_STATUS 3913 reg_set_5dot9_ghz_supported(struct wlan_objmgr_psoc *psoc, bool val) 3914 { 3915 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 3916 3917 psoc_priv_obj = reg_get_psoc_obj(psoc); 3918 3919 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 3920 reg_err("psoc reg component is NULL"); 3921 return QDF_STATUS_E_FAILURE; 3922 } 3923 3924 psoc_priv_obj->five_dot_nine_ghz_supported = val; 3925 3926 return QDF_STATUS_SUCCESS; 3927 } 3928 3929 #ifdef CONFIG_REG_CLIENT 3930 bool reg_is_6ghz_supported(struct wlan_objmgr_psoc *psoc) 3931 { 3932 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 3933 3934 psoc_priv_obj = reg_get_psoc_obj(psoc); 3935 3936 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 3937 reg_err("psoc reg component is NULL"); 3938 return false; 3939 } 3940 3941 return psoc_priv_obj->six_ghz_supported; 3942 } 3943 #endif 3944 3945 bool reg_is_5dot9_ghz_supported(struct wlan_objmgr_psoc *psoc) 3946 { 3947 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 3948 3949 psoc_priv_obj = reg_get_psoc_obj(psoc); 3950 3951 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 3952 reg_err("psoc reg component is NULL"); 3953 return false; 3954 } 3955 3956 return psoc_priv_obj->five_dot_nine_ghz_supported; 3957 } 3958 3959 bool reg_is_fcc_regdmn(struct wlan_objmgr_pdev *pdev) 3960 { 3961 struct cur_regdmn_info cur_reg_dmn; 3962 QDF_STATUS status; 3963 3964 status = reg_get_curr_regdomain(pdev, &cur_reg_dmn); 3965 if (status != QDF_STATUS_SUCCESS) { 3966 reg_err_rl("Failed to get reg domain"); 3967 return false; 3968 } 3969 3970 return reg_fcc_regdmn(cur_reg_dmn.dmn_id_5g); 3971 } 3972 3973 bool reg_is_5dot9_ghz_freq(struct wlan_objmgr_pdev *pdev, qdf_freq_t freq) 3974 { 3975 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 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 priv obj is NULL"); 3981 return false; 3982 } 3983 3984 return (freq >= channel_map_us[MIN_5DOT9_CHANNEL].center_freq && 3985 freq <= channel_map_us[MAX_5DOT9_CHANNEL].center_freq); 3986 } 3987 3988 bool reg_is_5dot9_ghz_chan_allowed_master_mode(struct wlan_objmgr_pdev *pdev) 3989 { 3990 struct wlan_objmgr_psoc *psoc; 3991 struct wlan_regulatory_psoc_priv_obj *psoc_priv_obj; 3992 3993 if (!pdev) { 3994 reg_alert("pdev is NULL"); 3995 return true; 3996 } 3997 psoc = wlan_pdev_get_psoc(pdev); 3998 3999 psoc_priv_obj = reg_get_psoc_obj(psoc); 4000 if (!IS_VALID_PSOC_REG_OBJ(psoc_priv_obj)) { 4001 reg_alert("psoc reg component is NULL"); 4002 return true; 4003 } 4004 4005 return psoc_priv_obj->enable_5dot9_ghz_chan_in_master_mode; 4006 } 4007 4008 #ifdef DISABLE_UNII_SHARED_BANDS 4009 QDF_STATUS 4010 reg_get_unii_5g_bitmap(struct wlan_objmgr_pdev *pdev, uint8_t *bitmap) 4011 { 4012 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 4013 4014 pdev_priv_obj = reg_get_pdev_obj(pdev); 4015 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 4016 reg_err_rl("pdev reg component is NULL"); 4017 return QDF_STATUS_E_FAILURE; 4018 } 4019 *bitmap = pdev_priv_obj->unii_5g_bitmap; 4020 4021 return QDF_STATUS_SUCCESS; 4022 } 4023 #endif 4024 4025 #ifdef CHECK_REG_PHYMODE 4026 /** 4027 * reg_is_phymode_allowed() - Check if requested phymode is unallowed 4028 * @phy_in: phymode that the user requested 4029 * @phymode_bitmap: bitmap of unallowed phymodes for specific country 4030 * 4031 * Return: true if phymode is not allowed, else false 4032 */ 4033 static bool reg_is_phymode_unallowed(enum reg_phymode phy_in, 4034 uint32_t phymode_bitmap) 4035 { 4036 if (!phymode_bitmap) 4037 return false; 4038 4039 if (phy_in == REG_PHYMODE_11AX) 4040 return phymode_bitmap & REGULATORY_PHYMODE_NO11AX; 4041 else if (phy_in == REG_PHYMODE_11AC) 4042 return phymode_bitmap & REGULATORY_PHYMODE_NO11AC; 4043 else if (phy_in == REG_PHYMODE_11N) 4044 return phymode_bitmap & REGULATORY_CHAN_NO11N; 4045 else if (phy_in == REG_PHYMODE_11G) 4046 return phymode_bitmap & REGULATORY_PHYMODE_NO11G; 4047 else if (phy_in == REG_PHYMODE_11A) 4048 return phymode_bitmap & REGULATORY_PHYMODE_NO11A; 4049 else if (phy_in == REG_PHYMODE_11B) 4050 return phymode_bitmap & REGULATORY_PHYMODE_NO11B; 4051 else 4052 return true; 4053 4054 } 4055 4056 enum reg_phymode reg_get_max_phymode(struct wlan_objmgr_pdev *pdev, 4057 enum reg_phymode phy_in, 4058 qdf_freq_t freq) 4059 { 4060 struct wlan_regulatory_pdev_priv_obj *pdev_priv_obj; 4061 uint32_t phymode_bitmap; 4062 enum reg_phymode current_phymode = phy_in; 4063 4064 pdev_priv_obj = reg_get_pdev_obj(pdev); 4065 if (!IS_VALID_PDEV_REG_OBJ(pdev_priv_obj)) { 4066 reg_err("pdev reg component is NULL"); 4067 return REG_PHYMODE_INVALID; 4068 } 4069 4070 phymode_bitmap = pdev_priv_obj->phybitmap; 4071 4072 while (1) { 4073 if (reg_is_phymode_unallowed(current_phymode, phymode_bitmap)) { 4074 if (current_phymode == REG_PHYMODE_11N) { 4075 if (REG_IS_24GHZ_CH_FREQ(freq)) 4076 current_phymode = REG_PHYMODE_11G; 4077 else 4078 current_phymode = REG_PHYMODE_11A; 4079 } else if (current_phymode == REG_PHYMODE_11A || 4080 current_phymode == REG_PHYMODE_11B) { 4081 reg_err("Couldn't find a suitable phymode"); 4082 return REG_PHYMODE_INVALID; 4083 } else if (current_phymode > REG_PHYMODE_MAX) { 4084 reg_err("Unknown phymode"); 4085 return REG_PHYMODE_INVALID; 4086 } else { 4087 current_phymode--; 4088 } 4089 } else { 4090 return current_phymode; 4091 } 4092 } 4093 } 4094 #endif /* CHECK_REG_PHYMODE */ 4095 4096 #ifdef CONFIG_REG_CLIENT 4097 enum band_info reg_band_bitmap_to_band_info(uint32_t band_bitmap) 4098 { 4099 if ((band_bitmap & BIT(REG_BAND_2G)) && 4100 (band_bitmap & BIT(REG_BAND_5G)) && 4101 (band_bitmap & BIT(REG_BAND_6G))) 4102 return BAND_ALL; 4103 else if ((band_bitmap & BIT(REG_BAND_5G)) && 4104 (band_bitmap & BIT(REG_BAND_6G))) 4105 return BAND_5G; 4106 else if ((band_bitmap & BIT(REG_BAND_2G)) && 4107 (band_bitmap & BIT(REG_BAND_6G))) 4108 return BAND_2G; 4109 else if ((band_bitmap & BIT(REG_BAND_2G)) && 4110 (band_bitmap & BIT(REG_BAND_5G))) 4111 return BAND_ALL; 4112 else if (band_bitmap & BIT(REG_BAND_2G)) 4113 return BAND_2G; 4114 else if (band_bitmap & BIT(REG_BAND_5G)) 4115 return BAND_5G; 4116 else if (band_bitmap & BIT(REG_BAND_6G)) 4117 return BAND_2G; 4118 else 4119 return BAND_UNKNOWN; 4120 } 4121 #endif 4122