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