1 /* 2 * This file contains helper code to handle channel 3 * settings and keeping track of what is possible at 4 * any point in time. 5 * 6 * Copyright 2009 Johannes Berg <johannes@sipsolutions.net> 7 */ 8 9 #include <linux/export.h> 10 #include <net/cfg80211.h> 11 #include "core.h" 12 #include "rdev-ops.h" 13 14 void cfg80211_chandef_create(struct cfg80211_chan_def *chandef, 15 struct ieee80211_channel *chan, 16 enum nl80211_channel_type chan_type) 17 { 18 if (WARN_ON(!chan)) 19 return; 20 21 chandef->chan = chan; 22 chandef->center_freq2 = 0; 23 24 switch (chan_type) { 25 case NL80211_CHAN_NO_HT: 26 chandef->width = NL80211_CHAN_WIDTH_20_NOHT; 27 chandef->center_freq1 = chan->center_freq; 28 break; 29 case NL80211_CHAN_HT20: 30 chandef->width = NL80211_CHAN_WIDTH_20; 31 chandef->center_freq1 = chan->center_freq; 32 break; 33 case NL80211_CHAN_HT40PLUS: 34 chandef->width = NL80211_CHAN_WIDTH_40; 35 chandef->center_freq1 = chan->center_freq + 10; 36 break; 37 case NL80211_CHAN_HT40MINUS: 38 chandef->width = NL80211_CHAN_WIDTH_40; 39 chandef->center_freq1 = chan->center_freq - 10; 40 break; 41 default: 42 WARN_ON(1); 43 } 44 } 45 EXPORT_SYMBOL(cfg80211_chandef_create); 46 47 bool cfg80211_chandef_valid(const struct cfg80211_chan_def *chandef) 48 { 49 u32 control_freq; 50 51 if (!chandef->chan) 52 return false; 53 54 control_freq = chandef->chan->center_freq; 55 56 switch (chandef->width) { 57 case NL80211_CHAN_WIDTH_5: 58 case NL80211_CHAN_WIDTH_10: 59 case NL80211_CHAN_WIDTH_20: 60 case NL80211_CHAN_WIDTH_20_NOHT: 61 if (chandef->center_freq1 != control_freq) 62 return false; 63 if (chandef->center_freq2) 64 return false; 65 break; 66 case NL80211_CHAN_WIDTH_40: 67 if (chandef->center_freq1 != control_freq + 10 && 68 chandef->center_freq1 != control_freq - 10) 69 return false; 70 if (chandef->center_freq2) 71 return false; 72 break; 73 case NL80211_CHAN_WIDTH_80P80: 74 if (chandef->center_freq1 != control_freq + 30 && 75 chandef->center_freq1 != control_freq + 10 && 76 chandef->center_freq1 != control_freq - 10 && 77 chandef->center_freq1 != control_freq - 30) 78 return false; 79 if (!chandef->center_freq2) 80 return false; 81 /* adjacent is not allowed -- that's a 160 MHz channel */ 82 if (chandef->center_freq1 - chandef->center_freq2 == 80 || 83 chandef->center_freq2 - chandef->center_freq1 == 80) 84 return false; 85 break; 86 case NL80211_CHAN_WIDTH_80: 87 if (chandef->center_freq1 != control_freq + 30 && 88 chandef->center_freq1 != control_freq + 10 && 89 chandef->center_freq1 != control_freq - 10 && 90 chandef->center_freq1 != control_freq - 30) 91 return false; 92 if (chandef->center_freq2) 93 return false; 94 break; 95 case NL80211_CHAN_WIDTH_160: 96 if (chandef->center_freq1 != control_freq + 70 && 97 chandef->center_freq1 != control_freq + 50 && 98 chandef->center_freq1 != control_freq + 30 && 99 chandef->center_freq1 != control_freq + 10 && 100 chandef->center_freq1 != control_freq - 10 && 101 chandef->center_freq1 != control_freq - 30 && 102 chandef->center_freq1 != control_freq - 50 && 103 chandef->center_freq1 != control_freq - 70) 104 return false; 105 if (chandef->center_freq2) 106 return false; 107 break; 108 default: 109 return false; 110 } 111 112 return true; 113 } 114 EXPORT_SYMBOL(cfg80211_chandef_valid); 115 116 static void chandef_primary_freqs(const struct cfg80211_chan_def *c, 117 int *pri40, int *pri80) 118 { 119 int tmp; 120 121 switch (c->width) { 122 case NL80211_CHAN_WIDTH_40: 123 *pri40 = c->center_freq1; 124 *pri80 = 0; 125 break; 126 case NL80211_CHAN_WIDTH_80: 127 case NL80211_CHAN_WIDTH_80P80: 128 *pri80 = c->center_freq1; 129 /* n_P20 */ 130 tmp = (30 + c->chan->center_freq - c->center_freq1)/20; 131 /* n_P40 */ 132 tmp /= 2; 133 /* freq_P40 */ 134 *pri40 = c->center_freq1 - 20 + 40 * tmp; 135 break; 136 case NL80211_CHAN_WIDTH_160: 137 /* n_P20 */ 138 tmp = (70 + c->chan->center_freq - c->center_freq1)/20; 139 /* n_P40 */ 140 tmp /= 2; 141 /* freq_P40 */ 142 *pri40 = c->center_freq1 - 60 + 40 * tmp; 143 /* n_P80 */ 144 tmp /= 2; 145 *pri80 = c->center_freq1 - 40 + 80 * tmp; 146 break; 147 default: 148 WARN_ON_ONCE(1); 149 } 150 } 151 152 static int cfg80211_chandef_get_width(const struct cfg80211_chan_def *c) 153 { 154 int width; 155 156 switch (c->width) { 157 case NL80211_CHAN_WIDTH_5: 158 width = 5; 159 break; 160 case NL80211_CHAN_WIDTH_10: 161 width = 10; 162 break; 163 case NL80211_CHAN_WIDTH_20: 164 case NL80211_CHAN_WIDTH_20_NOHT: 165 width = 20; 166 break; 167 case NL80211_CHAN_WIDTH_40: 168 width = 40; 169 break; 170 case NL80211_CHAN_WIDTH_80P80: 171 case NL80211_CHAN_WIDTH_80: 172 width = 80; 173 break; 174 case NL80211_CHAN_WIDTH_160: 175 width = 160; 176 break; 177 default: 178 WARN_ON_ONCE(1); 179 return -1; 180 } 181 return width; 182 } 183 184 const struct cfg80211_chan_def * 185 cfg80211_chandef_compatible(const struct cfg80211_chan_def *c1, 186 const struct cfg80211_chan_def *c2) 187 { 188 u32 c1_pri40, c1_pri80, c2_pri40, c2_pri80; 189 190 /* If they are identical, return */ 191 if (cfg80211_chandef_identical(c1, c2)) 192 return c1; 193 194 /* otherwise, must have same control channel */ 195 if (c1->chan != c2->chan) 196 return NULL; 197 198 /* 199 * If they have the same width, but aren't identical, 200 * then they can't be compatible. 201 */ 202 if (c1->width == c2->width) 203 return NULL; 204 205 /* 206 * can't be compatible if one of them is 5 or 10 MHz, 207 * but they don't have the same width. 208 */ 209 if (c1->width == NL80211_CHAN_WIDTH_5 || 210 c1->width == NL80211_CHAN_WIDTH_10 || 211 c2->width == NL80211_CHAN_WIDTH_5 || 212 c2->width == NL80211_CHAN_WIDTH_10) 213 return NULL; 214 215 if (c1->width == NL80211_CHAN_WIDTH_20_NOHT || 216 c1->width == NL80211_CHAN_WIDTH_20) 217 return c2; 218 219 if (c2->width == NL80211_CHAN_WIDTH_20_NOHT || 220 c2->width == NL80211_CHAN_WIDTH_20) 221 return c1; 222 223 chandef_primary_freqs(c1, &c1_pri40, &c1_pri80); 224 chandef_primary_freqs(c2, &c2_pri40, &c2_pri80); 225 226 if (c1_pri40 != c2_pri40) 227 return NULL; 228 229 WARN_ON(!c1_pri80 && !c2_pri80); 230 if (c1_pri80 && c2_pri80 && c1_pri80 != c2_pri80) 231 return NULL; 232 233 if (c1->width > c2->width) 234 return c1; 235 return c2; 236 } 237 EXPORT_SYMBOL(cfg80211_chandef_compatible); 238 239 static void cfg80211_set_chans_dfs_state(struct wiphy *wiphy, u32 center_freq, 240 u32 bandwidth, 241 enum nl80211_dfs_state dfs_state) 242 { 243 struct ieee80211_channel *c; 244 u32 freq; 245 246 for (freq = center_freq - bandwidth/2 + 10; 247 freq <= center_freq + bandwidth/2 - 10; 248 freq += 20) { 249 c = ieee80211_get_channel(wiphy, freq); 250 if (!c || !(c->flags & IEEE80211_CHAN_RADAR)) 251 continue; 252 253 c->dfs_state = dfs_state; 254 c->dfs_state_entered = jiffies; 255 } 256 } 257 258 void cfg80211_set_dfs_state(struct wiphy *wiphy, 259 const struct cfg80211_chan_def *chandef, 260 enum nl80211_dfs_state dfs_state) 261 { 262 int width; 263 264 if (WARN_ON(!cfg80211_chandef_valid(chandef))) 265 return; 266 267 width = cfg80211_chandef_get_width(chandef); 268 if (width < 0) 269 return; 270 271 cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq1, 272 width, dfs_state); 273 274 if (!chandef->center_freq2) 275 return; 276 cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq2, 277 width, dfs_state); 278 } 279 280 static int cfg80211_get_chans_dfs_required(struct wiphy *wiphy, 281 u32 center_freq, 282 u32 bandwidth) 283 { 284 struct ieee80211_channel *c; 285 u32 freq, start_freq, end_freq; 286 287 if (bandwidth <= 20) { 288 start_freq = center_freq; 289 end_freq = center_freq; 290 } else { 291 start_freq = center_freq - bandwidth/2 + 10; 292 end_freq = center_freq + bandwidth/2 - 10; 293 } 294 295 for (freq = start_freq; freq <= end_freq; freq += 20) { 296 c = ieee80211_get_channel(wiphy, freq); 297 if (!c) 298 return -EINVAL; 299 300 if (c->flags & IEEE80211_CHAN_RADAR) 301 return 1; 302 } 303 return 0; 304 } 305 306 307 int cfg80211_chandef_dfs_required(struct wiphy *wiphy, 308 const struct cfg80211_chan_def *chandef) 309 { 310 int width; 311 int r; 312 313 if (WARN_ON(!cfg80211_chandef_valid(chandef))) 314 return -EINVAL; 315 316 width = cfg80211_chandef_get_width(chandef); 317 if (width < 0) 318 return -EINVAL; 319 320 r = cfg80211_get_chans_dfs_required(wiphy, chandef->center_freq1, 321 width); 322 if (r) 323 return r; 324 325 if (!chandef->center_freq2) 326 return 0; 327 328 return cfg80211_get_chans_dfs_required(wiphy, chandef->center_freq2, 329 width); 330 } 331 332 static bool cfg80211_secondary_chans_ok(struct wiphy *wiphy, 333 u32 center_freq, u32 bandwidth, 334 u32 prohibited_flags) 335 { 336 struct ieee80211_channel *c; 337 u32 freq, start_freq, end_freq; 338 339 if (bandwidth <= 20) { 340 start_freq = center_freq; 341 end_freq = center_freq; 342 } else { 343 start_freq = center_freq - bandwidth/2 + 10; 344 end_freq = center_freq + bandwidth/2 - 10; 345 } 346 347 for (freq = start_freq; freq <= end_freq; freq += 20) { 348 c = ieee80211_get_channel(wiphy, freq); 349 if (!c) 350 return false; 351 352 /* check for radar flags */ 353 if ((prohibited_flags & c->flags & IEEE80211_CHAN_RADAR) && 354 (c->dfs_state != NL80211_DFS_AVAILABLE)) 355 return false; 356 357 /* check for the other flags */ 358 if (c->flags & prohibited_flags & ~IEEE80211_CHAN_RADAR) 359 return false; 360 } 361 362 return true; 363 } 364 365 bool cfg80211_chandef_usable(struct wiphy *wiphy, 366 const struct cfg80211_chan_def *chandef, 367 u32 prohibited_flags) 368 { 369 struct ieee80211_sta_ht_cap *ht_cap; 370 struct ieee80211_sta_vht_cap *vht_cap; 371 u32 width, control_freq; 372 373 if (WARN_ON(!cfg80211_chandef_valid(chandef))) 374 return false; 375 376 ht_cap = &wiphy->bands[chandef->chan->band]->ht_cap; 377 vht_cap = &wiphy->bands[chandef->chan->band]->vht_cap; 378 379 control_freq = chandef->chan->center_freq; 380 381 switch (chandef->width) { 382 case NL80211_CHAN_WIDTH_5: 383 width = 5; 384 break; 385 case NL80211_CHAN_WIDTH_10: 386 width = 10; 387 break; 388 case NL80211_CHAN_WIDTH_20: 389 if (!ht_cap->ht_supported) 390 return false; 391 case NL80211_CHAN_WIDTH_20_NOHT: 392 width = 20; 393 break; 394 case NL80211_CHAN_WIDTH_40: 395 width = 40; 396 if (!ht_cap->ht_supported) 397 return false; 398 if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) || 399 ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT) 400 return false; 401 if (chandef->center_freq1 < control_freq && 402 chandef->chan->flags & IEEE80211_CHAN_NO_HT40MINUS) 403 return false; 404 if (chandef->center_freq1 > control_freq && 405 chandef->chan->flags & IEEE80211_CHAN_NO_HT40PLUS) 406 return false; 407 break; 408 case NL80211_CHAN_WIDTH_80P80: 409 if (!(vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ)) 410 return false; 411 case NL80211_CHAN_WIDTH_80: 412 if (!vht_cap->vht_supported) 413 return false; 414 prohibited_flags |= IEEE80211_CHAN_NO_80MHZ; 415 width = 80; 416 break; 417 case NL80211_CHAN_WIDTH_160: 418 if (!vht_cap->vht_supported) 419 return false; 420 if (!(vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ)) 421 return false; 422 prohibited_flags |= IEEE80211_CHAN_NO_160MHZ; 423 width = 160; 424 break; 425 default: 426 WARN_ON_ONCE(1); 427 return false; 428 } 429 430 /* 431 * TODO: What if there are only certain 80/160/80+80 MHz channels 432 * allowed by the driver, or only certain combinations? 433 * For 40 MHz the driver can set the NO_HT40 flags, but for 434 * 80/160 MHz and in particular 80+80 MHz this isn't really 435 * feasible and we only have NO_80MHZ/NO_160MHZ so far but 436 * no way to cover 80+80 MHz or more complex restrictions. 437 * Note that such restrictions also need to be advertised to 438 * userspace, for example for P2P channel selection. 439 */ 440 441 if (width > 20) 442 prohibited_flags |= IEEE80211_CHAN_NO_OFDM; 443 444 /* 5 and 10 MHz are only defined for the OFDM PHY */ 445 if (width < 20) 446 prohibited_flags |= IEEE80211_CHAN_NO_OFDM; 447 448 449 if (!cfg80211_secondary_chans_ok(wiphy, chandef->center_freq1, 450 width, prohibited_flags)) 451 return false; 452 453 if (!chandef->center_freq2) 454 return true; 455 return cfg80211_secondary_chans_ok(wiphy, chandef->center_freq2, 456 width, prohibited_flags); 457 } 458 EXPORT_SYMBOL(cfg80211_chandef_usable); 459 460 bool cfg80211_reg_can_beacon(struct wiphy *wiphy, 461 struct cfg80211_chan_def *chandef) 462 { 463 bool res; 464 465 trace_cfg80211_reg_can_beacon(wiphy, chandef); 466 467 res = cfg80211_chandef_usable(wiphy, chandef, 468 IEEE80211_CHAN_DISABLED | 469 IEEE80211_CHAN_PASSIVE_SCAN | 470 IEEE80211_CHAN_NO_IBSS | 471 IEEE80211_CHAN_RADAR); 472 473 trace_cfg80211_return_bool(res); 474 return res; 475 } 476 EXPORT_SYMBOL(cfg80211_reg_can_beacon); 477 478 int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev, 479 struct cfg80211_chan_def *chandef) 480 { 481 if (!rdev->ops->set_monitor_channel) 482 return -EOPNOTSUPP; 483 if (!cfg80211_has_monitors_only(rdev)) 484 return -EBUSY; 485 486 return rdev_set_monitor_channel(rdev, chandef); 487 } 488 489 void 490 cfg80211_get_chan_state(struct wireless_dev *wdev, 491 struct ieee80211_channel **chan, 492 enum cfg80211_chan_mode *chanmode) 493 { 494 *chan = NULL; 495 *chanmode = CHAN_MODE_UNDEFINED; 496 497 ASSERT_WDEV_LOCK(wdev); 498 499 if (wdev->netdev && !netif_running(wdev->netdev)) 500 return; 501 502 switch (wdev->iftype) { 503 case NL80211_IFTYPE_ADHOC: 504 if (wdev->current_bss) { 505 *chan = wdev->current_bss->pub.channel; 506 *chanmode = wdev->ibss_fixed 507 ? CHAN_MODE_SHARED 508 : CHAN_MODE_EXCLUSIVE; 509 return; 510 } 511 case NL80211_IFTYPE_STATION: 512 case NL80211_IFTYPE_P2P_CLIENT: 513 if (wdev->current_bss) { 514 *chan = wdev->current_bss->pub.channel; 515 *chanmode = CHAN_MODE_SHARED; 516 return; 517 } 518 break; 519 case NL80211_IFTYPE_AP: 520 case NL80211_IFTYPE_P2P_GO: 521 if (wdev->cac_started) { 522 *chan = wdev->channel; 523 *chanmode = CHAN_MODE_SHARED; 524 } else if (wdev->beacon_interval) { 525 *chan = wdev->channel; 526 *chanmode = CHAN_MODE_SHARED; 527 } 528 return; 529 case NL80211_IFTYPE_MESH_POINT: 530 if (wdev->mesh_id_len) { 531 *chan = wdev->channel; 532 *chanmode = CHAN_MODE_SHARED; 533 } 534 return; 535 case NL80211_IFTYPE_MONITOR: 536 case NL80211_IFTYPE_AP_VLAN: 537 case NL80211_IFTYPE_WDS: 538 /* these interface types don't really have a channel */ 539 return; 540 case NL80211_IFTYPE_P2P_DEVICE: 541 if (wdev->wiphy->features & 542 NL80211_FEATURE_P2P_DEVICE_NEEDS_CHANNEL) 543 *chanmode = CHAN_MODE_EXCLUSIVE; 544 return; 545 case NL80211_IFTYPE_UNSPECIFIED: 546 case NUM_NL80211_IFTYPES: 547 WARN_ON(1); 548 } 549 550 return; 551 } 552