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 EXPORT_SYMBOL(cfg80211_chandef_dfs_required); 332 333 static bool cfg80211_secondary_chans_ok(struct wiphy *wiphy, 334 u32 center_freq, u32 bandwidth, 335 u32 prohibited_flags) 336 { 337 struct ieee80211_channel *c; 338 u32 freq, start_freq, end_freq; 339 340 if (bandwidth <= 20) { 341 start_freq = center_freq; 342 end_freq = center_freq; 343 } else { 344 start_freq = center_freq - bandwidth/2 + 10; 345 end_freq = center_freq + bandwidth/2 - 10; 346 } 347 348 for (freq = start_freq; freq <= end_freq; freq += 20) { 349 c = ieee80211_get_channel(wiphy, freq); 350 if (!c) 351 return false; 352 353 /* check for radar flags */ 354 if ((prohibited_flags & c->flags & IEEE80211_CHAN_RADAR) && 355 (c->dfs_state != NL80211_DFS_AVAILABLE)) 356 return false; 357 358 /* check for the other flags */ 359 if (c->flags & prohibited_flags & ~IEEE80211_CHAN_RADAR) 360 return false; 361 } 362 363 return true; 364 } 365 366 bool cfg80211_chandef_usable(struct wiphy *wiphy, 367 const struct cfg80211_chan_def *chandef, 368 u32 prohibited_flags) 369 { 370 struct ieee80211_sta_ht_cap *ht_cap; 371 struct ieee80211_sta_vht_cap *vht_cap; 372 u32 width, control_freq; 373 374 if (WARN_ON(!cfg80211_chandef_valid(chandef))) 375 return false; 376 377 ht_cap = &wiphy->bands[chandef->chan->band]->ht_cap; 378 vht_cap = &wiphy->bands[chandef->chan->band]->vht_cap; 379 380 control_freq = chandef->chan->center_freq; 381 382 switch (chandef->width) { 383 case NL80211_CHAN_WIDTH_5: 384 width = 5; 385 break; 386 case NL80211_CHAN_WIDTH_10: 387 width = 10; 388 break; 389 case NL80211_CHAN_WIDTH_20: 390 if (!ht_cap->ht_supported) 391 return false; 392 case NL80211_CHAN_WIDTH_20_NOHT: 393 width = 20; 394 break; 395 case NL80211_CHAN_WIDTH_40: 396 width = 40; 397 if (!ht_cap->ht_supported) 398 return false; 399 if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) || 400 ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT) 401 return false; 402 if (chandef->center_freq1 < control_freq && 403 chandef->chan->flags & IEEE80211_CHAN_NO_HT40MINUS) 404 return false; 405 if (chandef->center_freq1 > control_freq && 406 chandef->chan->flags & IEEE80211_CHAN_NO_HT40PLUS) 407 return false; 408 break; 409 case NL80211_CHAN_WIDTH_80P80: 410 if (!(vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ)) 411 return false; 412 case NL80211_CHAN_WIDTH_80: 413 if (!vht_cap->vht_supported) 414 return false; 415 prohibited_flags |= IEEE80211_CHAN_NO_80MHZ; 416 width = 80; 417 break; 418 case NL80211_CHAN_WIDTH_160: 419 if (!vht_cap->vht_supported) 420 return false; 421 if (!(vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ)) 422 return false; 423 prohibited_flags |= IEEE80211_CHAN_NO_160MHZ; 424 width = 160; 425 break; 426 default: 427 WARN_ON_ONCE(1); 428 return false; 429 } 430 431 /* 432 * TODO: What if there are only certain 80/160/80+80 MHz channels 433 * allowed by the driver, or only certain combinations? 434 * For 40 MHz the driver can set the NO_HT40 flags, but for 435 * 80/160 MHz and in particular 80+80 MHz this isn't really 436 * feasible and we only have NO_80MHZ/NO_160MHZ so far but 437 * no way to cover 80+80 MHz or more complex restrictions. 438 * Note that such restrictions also need to be advertised to 439 * userspace, for example for P2P channel selection. 440 */ 441 442 if (width > 20) 443 prohibited_flags |= IEEE80211_CHAN_NO_OFDM; 444 445 /* 5 and 10 MHz are only defined for the OFDM PHY */ 446 if (width < 20) 447 prohibited_flags |= IEEE80211_CHAN_NO_OFDM; 448 449 450 if (!cfg80211_secondary_chans_ok(wiphy, chandef->center_freq1, 451 width, prohibited_flags)) 452 return false; 453 454 if (!chandef->center_freq2) 455 return true; 456 return cfg80211_secondary_chans_ok(wiphy, chandef->center_freq2, 457 width, prohibited_flags); 458 } 459 EXPORT_SYMBOL(cfg80211_chandef_usable); 460 461 bool cfg80211_reg_can_beacon(struct wiphy *wiphy, 462 struct cfg80211_chan_def *chandef) 463 { 464 bool res; 465 466 trace_cfg80211_reg_can_beacon(wiphy, chandef); 467 468 res = cfg80211_chandef_usable(wiphy, chandef, 469 IEEE80211_CHAN_DISABLED | 470 IEEE80211_CHAN_PASSIVE_SCAN | 471 IEEE80211_CHAN_NO_IBSS | 472 IEEE80211_CHAN_RADAR); 473 474 trace_cfg80211_return_bool(res); 475 return res; 476 } 477 EXPORT_SYMBOL(cfg80211_reg_can_beacon); 478 479 int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev, 480 struct cfg80211_chan_def *chandef) 481 { 482 if (!rdev->ops->set_monitor_channel) 483 return -EOPNOTSUPP; 484 if (!cfg80211_has_monitors_only(rdev)) 485 return -EBUSY; 486 487 return rdev_set_monitor_channel(rdev, chandef); 488 } 489 490 void 491 cfg80211_get_chan_state(struct wireless_dev *wdev, 492 struct ieee80211_channel **chan, 493 enum cfg80211_chan_mode *chanmode) 494 { 495 *chan = NULL; 496 *chanmode = CHAN_MODE_UNDEFINED; 497 498 ASSERT_WDEV_LOCK(wdev); 499 500 if (wdev->netdev && !netif_running(wdev->netdev)) 501 return; 502 503 switch (wdev->iftype) { 504 case NL80211_IFTYPE_ADHOC: 505 if (wdev->current_bss) { 506 *chan = wdev->current_bss->pub.channel; 507 *chanmode = (wdev->ibss_fixed && 508 !wdev->ibss_dfs_possible) 509 ? CHAN_MODE_SHARED 510 : CHAN_MODE_EXCLUSIVE; 511 return; 512 } 513 case NL80211_IFTYPE_STATION: 514 case NL80211_IFTYPE_P2P_CLIENT: 515 if (wdev->current_bss) { 516 *chan = wdev->current_bss->pub.channel; 517 *chanmode = CHAN_MODE_SHARED; 518 return; 519 } 520 break; 521 case NL80211_IFTYPE_AP: 522 case NL80211_IFTYPE_P2P_GO: 523 if (wdev->cac_started) { 524 *chan = wdev->channel; 525 *chanmode = CHAN_MODE_SHARED; 526 } else if (wdev->beacon_interval) { 527 *chan = wdev->channel; 528 *chanmode = CHAN_MODE_SHARED; 529 } 530 return; 531 case NL80211_IFTYPE_MESH_POINT: 532 if (wdev->mesh_id_len) { 533 *chan = wdev->channel; 534 *chanmode = CHAN_MODE_SHARED; 535 } 536 return; 537 case NL80211_IFTYPE_MONITOR: 538 case NL80211_IFTYPE_AP_VLAN: 539 case NL80211_IFTYPE_WDS: 540 /* these interface types don't really have a channel */ 541 return; 542 case NL80211_IFTYPE_P2P_DEVICE: 543 if (wdev->wiphy->features & 544 NL80211_FEATURE_P2P_DEVICE_NEEDS_CHANNEL) 545 *chanmode = CHAN_MODE_EXCLUSIVE; 546 return; 547 case NL80211_IFTYPE_UNSPECIFIED: 548 case NUM_NL80211_IFTYPES: 549 WARN_ON(1); 550 } 551 552 return; 553 } 554