1 /* 2 * Operating classes 3 * Copyright(c) 2015 Intel Deutschland GmbH 4 * Contact Information: 5 * Intel Linux Wireless <ilw (at) linux.intel.com> 6 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 7 * 8 * This software may be distributed under the terms of the BSD license. 9 * See README for more details. 10 */ 11 12 #include "utils/includes.h" 13 14 #include "utils/common.h" 15 #include "common/ieee802_11_common.h" 16 #include "wpa_supplicant_i.h" 17 18 19 static enum chan_allowed allow_channel(struct hostapd_hw_modes *mode, u8 chan, 20 unsigned int *flags) 21 { 22 int i; 23 24 for (i = 0; i < mode->num_channels; i++) { 25 if (mode->channels[i].chan == chan) 26 break; 27 } 28 29 if (i == mode->num_channels || 30 (mode->channels[i].flag & HOSTAPD_CHAN_DISABLED)) 31 return NOT_ALLOWED; 32 33 if (flags) 34 *flags = mode->channels[i].flag; 35 36 if (mode->channels[i].flag & HOSTAPD_CHAN_NO_IR) 37 return NO_IR; 38 39 return ALLOWED; 40 } 41 42 43 static int get_center_80mhz(struct hostapd_hw_modes *mode, u8 channel) 44 { 45 u8 center_channels[] = { 42, 58, 106, 122, 138, 155 }; 46 size_t i; 47 48 if (mode->mode != HOSTAPD_MODE_IEEE80211A) 49 return 0; 50 51 for (i = 0; i < ARRAY_SIZE(center_channels); i++) { 52 /* 53 * In 80 MHz, the bandwidth "spans" 12 channels (e.g., 36-48), 54 * so the center channel is 6 channels away from the start/end. 55 */ 56 if (channel >= center_channels[i] - 6 && 57 channel <= center_channels[i] + 6) 58 return center_channels[i]; 59 } 60 61 return 0; 62 } 63 64 65 static enum chan_allowed verify_80mhz(struct hostapd_hw_modes *mode, u8 channel) 66 { 67 u8 center_chan; 68 unsigned int i; 69 unsigned int no_ir = 0; 70 71 center_chan = get_center_80mhz(mode, channel); 72 if (!center_chan) 73 return NOT_ALLOWED; 74 75 /* check all the channels are available */ 76 for (i = 0; i < 4; i++) { 77 unsigned int flags; 78 u8 adj_chan = center_chan - 6 + i * 4; 79 80 if (allow_channel(mode, adj_chan, &flags) == NOT_ALLOWED) 81 return NOT_ALLOWED; 82 83 if ((i == 0 && !(flags & HOSTAPD_CHAN_VHT_10_70)) || 84 (i == 1 && !(flags & HOSTAPD_CHAN_VHT_30_50)) || 85 (i == 2 && !(flags & HOSTAPD_CHAN_VHT_50_30)) || 86 (i == 3 && !(flags & HOSTAPD_CHAN_VHT_70_10))) 87 return NOT_ALLOWED; 88 89 if (flags & HOSTAPD_CHAN_NO_IR) 90 no_ir = 1; 91 } 92 93 if (no_ir) 94 return NO_IR; 95 96 return ALLOWED; 97 } 98 99 100 static int get_center_160mhz(struct hostapd_hw_modes *mode, u8 channel) 101 { 102 u8 center_channels[] = { 50, 114 }; 103 unsigned int i; 104 105 if (mode->mode != HOSTAPD_MODE_IEEE80211A) 106 return 0; 107 108 for (i = 0; i < ARRAY_SIZE(center_channels); i++) { 109 /* 110 * In 160 MHz, the bandwidth "spans" 28 channels (e.g., 36-64), 111 * so the center channel is 14 channels away from the start/end. 112 */ 113 if (channel >= center_channels[i] - 14 && 114 channel <= center_channels[i] + 14) 115 return center_channels[i]; 116 } 117 118 return 0; 119 } 120 121 122 static enum chan_allowed verify_160mhz(struct hostapd_hw_modes *mode, 123 u8 channel) 124 { 125 u8 center_chan; 126 unsigned int i; 127 unsigned int no_ir = 0; 128 129 center_chan = get_center_160mhz(mode, channel); 130 if (!center_chan) 131 return NOT_ALLOWED; 132 133 /* Check all the channels are available */ 134 for (i = 0; i < 8; i++) { 135 unsigned int flags; 136 u8 adj_chan = center_chan - 14 + i * 4; 137 138 if (allow_channel(mode, adj_chan, &flags) == NOT_ALLOWED) 139 return NOT_ALLOWED; 140 141 if ((i == 0 && !(flags & HOSTAPD_CHAN_VHT_10_150)) || 142 (i == 1 && !(flags & HOSTAPD_CHAN_VHT_30_130)) || 143 (i == 2 && !(flags & HOSTAPD_CHAN_VHT_50_110)) || 144 (i == 3 && !(flags & HOSTAPD_CHAN_VHT_70_90)) || 145 (i == 4 && !(flags & HOSTAPD_CHAN_VHT_90_70)) || 146 (i == 5 && !(flags & HOSTAPD_CHAN_VHT_110_50)) || 147 (i == 6 && !(flags & HOSTAPD_CHAN_VHT_130_30)) || 148 (i == 7 && !(flags & HOSTAPD_CHAN_VHT_150_10))) 149 return NOT_ALLOWED; 150 151 if (flags & HOSTAPD_CHAN_NO_IR) 152 no_ir = 1; 153 } 154 155 if (no_ir) 156 return NO_IR; 157 158 return ALLOWED; 159 } 160 161 162 enum chan_allowed verify_channel(struct hostapd_hw_modes *mode, u8 channel, 163 u8 bw) 164 { 165 unsigned int flag = 0; 166 enum chan_allowed res, res2; 167 168 res2 = res = allow_channel(mode, channel, &flag); 169 if (bw == BW40MINUS) { 170 if (!(flag & HOSTAPD_CHAN_HT40MINUS)) 171 return NOT_ALLOWED; 172 res2 = allow_channel(mode, channel - 4, NULL); 173 } else if (bw == BW40PLUS) { 174 if (!(flag & HOSTAPD_CHAN_HT40PLUS)) 175 return NOT_ALLOWED; 176 res2 = allow_channel(mode, channel + 4, NULL); 177 } else if (bw == BW80) { 178 /* 179 * channel is a center channel and as such, not necessarily a 180 * valid 20 MHz channels. Override earlier allow_channel() 181 * result and use only the 80 MHz specific version. 182 */ 183 res2 = res = verify_80mhz(mode, channel); 184 } else if (bw == BW160) { 185 /* 186 * channel is a center channel and as such, not necessarily a 187 * valid 20 MHz channels. Override earlier allow_channel() 188 * result and use only the 160 MHz specific version. 189 */ 190 res2 = res = verify_160mhz(mode, channel); 191 } else if (bw == BW80P80) { 192 /* 193 * channel is a center channel and as such, not necessarily a 194 * valid 20 MHz channels. Override earlier allow_channel() 195 * result and use only the 80 MHz specific version. 196 */ 197 res2 = res = verify_80mhz(mode, channel); 198 } 199 200 if (res == NOT_ALLOWED || res2 == NOT_ALLOWED) 201 return NOT_ALLOWED; 202 203 if (res == NO_IR || res2 == NO_IR) 204 return NO_IR; 205 206 return ALLOWED; 207 } 208 209 210 static int wpas_op_class_supported(struct wpa_supplicant *wpa_s, 211 struct wpa_ssid *ssid, 212 const struct oper_class_map *op_class) 213 { 214 int chan; 215 size_t i; 216 struct hostapd_hw_modes *mode; 217 int found; 218 int z; 219 int freq2 = 0; 220 int freq5 = 0; 221 222 mode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes, op_class->mode); 223 if (!mode) 224 return 0; 225 226 /* If we are configured to disable certain things, take that into 227 * account here. */ 228 if (ssid->freq_list && ssid->freq_list[0]) { 229 for (z = 0; ; z++) { 230 int f = ssid->freq_list[z]; 231 232 if (f == 0) 233 break; /* end of list */ 234 if (f > 4000 && f < 6000) 235 freq5 = 1; 236 else if (f > 2400 && f < 2500) 237 freq2 = 1; 238 } 239 } else { 240 /* No frequencies specified, can use anything hardware supports. 241 */ 242 freq2 = freq5 = 1; 243 } 244 245 if (op_class->op_class >= 115 && op_class->op_class <= 130 && !freq5) 246 return 0; 247 if (op_class->op_class >= 81 && op_class->op_class <= 84 && !freq2) 248 return 0; 249 250 #ifdef CONFIG_HT_OVERRIDES 251 if (ssid->disable_ht) { 252 switch (op_class->op_class) { 253 case 83: 254 case 84: 255 case 104: 256 case 105: 257 case 116: 258 case 117: 259 case 119: 260 case 120: 261 case 122: 262 case 123: 263 case 126: 264 case 127: 265 case 128: 266 case 129: 267 case 130: 268 /* Disable >= 40 MHz channels if HT is disabled */ 269 return 0; 270 } 271 } 272 #endif /* CONFIG_HT_OVERRIDES */ 273 274 #ifdef CONFIG_VHT_OVERRIDES 275 if (ssid->disable_vht) { 276 if (op_class->op_class >= 128 && op_class->op_class <= 130) { 277 /* Disable >= 80 MHz channels if VHT is disabled */ 278 return 0; 279 } 280 } 281 #endif /* CONFIG_VHT_OVERRIDES */ 282 283 if (op_class->op_class == 128) { 284 u8 channels[] = { 42, 58, 106, 122, 138, 155 }; 285 286 for (i = 0; i < ARRAY_SIZE(channels); i++) { 287 if (verify_channel(mode, channels[i], op_class->bw) != 288 NOT_ALLOWED) 289 return 1; 290 } 291 292 return 0; 293 } 294 295 if (op_class->op_class == 129) { 296 /* Check if either 160 MHz channels is allowed */ 297 return verify_channel(mode, 50, op_class->bw) != NOT_ALLOWED || 298 verify_channel(mode, 114, op_class->bw) != NOT_ALLOWED; 299 } 300 301 if (op_class->op_class == 130) { 302 /* Need at least two non-contiguous 80 MHz segments */ 303 found = 0; 304 305 if (verify_channel(mode, 42, op_class->bw) != NOT_ALLOWED || 306 verify_channel(mode, 58, op_class->bw) != NOT_ALLOWED) 307 found++; 308 if (verify_channel(mode, 106, op_class->bw) != NOT_ALLOWED || 309 verify_channel(mode, 122, op_class->bw) != NOT_ALLOWED || 310 verify_channel(mode, 138, op_class->bw) != NOT_ALLOWED) 311 found++; 312 if (verify_channel(mode, 106, op_class->bw) != NOT_ALLOWED && 313 verify_channel(mode, 138, op_class->bw) != NOT_ALLOWED) 314 found++; 315 if (verify_channel(mode, 155, op_class->bw) != NOT_ALLOWED) 316 found++; 317 318 if (found >= 2) 319 return 1; 320 321 return 0; 322 } 323 324 found = 0; 325 for (chan = op_class->min_chan; chan <= op_class->max_chan; 326 chan += op_class->inc) { 327 if (verify_channel(mode, chan, op_class->bw) != NOT_ALLOWED) { 328 found = 1; 329 break; 330 } 331 } 332 333 return found; 334 } 335 336 337 size_t wpas_supp_op_class_ie(struct wpa_supplicant *wpa_s, 338 struct wpa_ssid *ssid, 339 int freq, u8 *pos, size_t len) 340 { 341 struct wpabuf *buf; 342 u8 op, current, chan; 343 u8 *ie_len; 344 size_t res; 345 346 /* 347 * Assume 20 MHz channel for now. 348 * TODO: Use the secondary channel and VHT channel width that will be 349 * used after association. 350 */ 351 if (ieee80211_freq_to_channel_ext(freq, 0, VHT_CHANWIDTH_USE_HT, 352 ¤t, &chan) == NUM_HOSTAPD_MODES) 353 return 0; 354 355 /* 356 * Need 3 bytes for EID, length, and current operating class, plus 357 * 1 byte for every other supported operating class. 358 */ 359 buf = wpabuf_alloc(global_op_class_size + 3); 360 if (!buf) 361 return 0; 362 363 wpabuf_put_u8(buf, WLAN_EID_SUPPORTED_OPERATING_CLASSES); 364 /* Will set the length later, putting a placeholder */ 365 ie_len = wpabuf_put(buf, 1); 366 wpabuf_put_u8(buf, current); 367 368 for (op = 0; global_op_class[op].op_class; op++) { 369 if (wpas_op_class_supported(wpa_s, ssid, &global_op_class[op])) 370 wpabuf_put_u8(buf, global_op_class[op].op_class); 371 } 372 373 *ie_len = wpabuf_len(buf) - 2; 374 if (*ie_len < 2 || wpabuf_len(buf) > len) { 375 wpa_printf(MSG_ERROR, 376 "Failed to add supported operating classes IE"); 377 res = 0; 378 } else { 379 os_memcpy(pos, wpabuf_head(buf), wpabuf_len(buf)); 380 res = wpabuf_len(buf); 381 wpa_hexdump_buf(MSG_DEBUG, 382 "Added supported operating classes IE", buf); 383 } 384 385 wpabuf_free(buf); 386 return res; 387 } 388
