1 /* 2 * Copyright 2002-2005, Instant802 Networks, Inc. 3 * Copyright 2005-2006, Devicescape Software, Inc. 4 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz> 5 * Copyright 2007 Johannes Berg <johannes@sipsolutions.net> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 * 11 * utilities for mac80211 12 */ 13 14 #include <net/mac80211.h> 15 #include <linux/netdevice.h> 16 #include <linux/types.h> 17 #include <linux/slab.h> 18 #include <linux/skbuff.h> 19 #include <linux/etherdevice.h> 20 #include <linux/if_arp.h> 21 #include <linux/wireless.h> 22 #include <linux/bitmap.h> 23 #include <net/net_namespace.h> 24 #include <net/cfg80211.h> 25 #include <net/rtnetlink.h> 26 27 #include "ieee80211_i.h" 28 #include "rate.h" 29 #include "mesh.h" 30 #include "wme.h" 31 32 /* privid for wiphys to determine whether they belong to us or not */ 33 void *mac80211_wiphy_privid = &mac80211_wiphy_privid; 34 35 /* See IEEE 802.1H for LLC/SNAP encapsulation/decapsulation */ 36 /* Ethernet-II snap header (RFC1042 for most EtherTypes) */ 37 const unsigned char rfc1042_header[] __aligned(2) = 38 { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 }; 39 40 /* Bridge-Tunnel header (for EtherTypes ETH_P_AARP and ETH_P_IPX) */ 41 const unsigned char bridge_tunnel_header[] __aligned(2) = 42 { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8 }; 43 44 45 u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len, 46 enum nl80211_iftype type) 47 { 48 __le16 fc = hdr->frame_control; 49 50 /* drop ACK/CTS frames and incorrect hdr len (ctrl) */ 51 if (len < 16) 52 return NULL; 53 54 if (ieee80211_is_data(fc)) { 55 if (len < 24) /* drop incorrect hdr len (data) */ 56 return NULL; 57 58 if (ieee80211_has_a4(fc)) 59 return NULL; 60 if (ieee80211_has_tods(fc)) 61 return hdr->addr1; 62 if (ieee80211_has_fromds(fc)) 63 return hdr->addr2; 64 65 return hdr->addr3; 66 } 67 68 if (ieee80211_is_mgmt(fc)) { 69 if (len < 24) /* drop incorrect hdr len (mgmt) */ 70 return NULL; 71 return hdr->addr3; 72 } 73 74 if (ieee80211_is_ctl(fc)) { 75 if(ieee80211_is_pspoll(fc)) 76 return hdr->addr1; 77 78 if (ieee80211_is_back_req(fc)) { 79 switch (type) { 80 case NL80211_IFTYPE_STATION: 81 return hdr->addr2; 82 case NL80211_IFTYPE_AP: 83 case NL80211_IFTYPE_AP_VLAN: 84 return hdr->addr1; 85 default: 86 break; /* fall through to the return */ 87 } 88 } 89 } 90 91 return NULL; 92 } 93 94 unsigned int ieee80211_hdrlen(__le16 fc) 95 { 96 unsigned int hdrlen = 24; 97 98 if (ieee80211_is_data(fc)) { 99 if (ieee80211_has_a4(fc)) 100 hdrlen = 30; 101 if (ieee80211_is_data_qos(fc)) 102 hdrlen += IEEE80211_QOS_CTL_LEN; 103 goto out; 104 } 105 106 if (ieee80211_is_ctl(fc)) { 107 /* 108 * ACK and CTS are 10 bytes, all others 16. To see how 109 * to get this condition consider 110 * subtype mask: 0b0000000011110000 (0x00F0) 111 * ACK subtype: 0b0000000011010000 (0x00D0) 112 * CTS subtype: 0b0000000011000000 (0x00C0) 113 * bits that matter: ^^^ (0x00E0) 114 * value of those: 0b0000000011000000 (0x00C0) 115 */ 116 if ((fc & cpu_to_le16(0x00E0)) == cpu_to_le16(0x00C0)) 117 hdrlen = 10; 118 else 119 hdrlen = 16; 120 } 121 out: 122 return hdrlen; 123 } 124 EXPORT_SYMBOL(ieee80211_hdrlen); 125 126 unsigned int ieee80211_get_hdrlen_from_skb(const struct sk_buff *skb) 127 { 128 const struct ieee80211_hdr *hdr = (const struct ieee80211_hdr *)skb->data; 129 unsigned int hdrlen; 130 131 if (unlikely(skb->len < 10)) 132 return 0; 133 hdrlen = ieee80211_hdrlen(hdr->frame_control); 134 if (unlikely(hdrlen > skb->len)) 135 return 0; 136 return hdrlen; 137 } 138 EXPORT_SYMBOL(ieee80211_get_hdrlen_from_skb); 139 140 int ieee80211_get_mesh_hdrlen(struct ieee80211s_hdr *meshhdr) 141 { 142 int ae = meshhdr->flags & IEEE80211S_FLAGS_AE; 143 /* 7.1.3.5a.2 */ 144 switch (ae) { 145 case 0: 146 return 6; 147 case 1: 148 return 12; 149 case 2: 150 return 18; 151 case 3: 152 return 24; 153 default: 154 return 6; 155 } 156 } 157 158 void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx) 159 { 160 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) tx->skb->data; 161 162 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED); 163 if (tx->extra_frag) { 164 struct ieee80211_hdr *fhdr; 165 int i; 166 for (i = 0; i < tx->num_extra_frag; i++) { 167 fhdr = (struct ieee80211_hdr *) 168 tx->extra_frag[i]->data; 169 fhdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED); 170 } 171 } 172 } 173 174 int ieee80211_frame_duration(struct ieee80211_local *local, size_t len, 175 int rate, int erp, int short_preamble) 176 { 177 int dur; 178 179 /* calculate duration (in microseconds, rounded up to next higher 180 * integer if it includes a fractional microsecond) to send frame of 181 * len bytes (does not include FCS) at the given rate. Duration will 182 * also include SIFS. 183 * 184 * rate is in 100 kbps, so divident is multiplied by 10 in the 185 * DIV_ROUND_UP() operations. 186 */ 187 188 if (local->hw.conf.channel->band == IEEE80211_BAND_5GHZ || erp) { 189 /* 190 * OFDM: 191 * 192 * N_DBPS = DATARATE x 4 193 * N_SYM = Ceiling((16+8xLENGTH+6) / N_DBPS) 194 * (16 = SIGNAL time, 6 = tail bits) 195 * TXTIME = T_PREAMBLE + T_SIGNAL + T_SYM x N_SYM + Signal Ext 196 * 197 * T_SYM = 4 usec 198 * 802.11a - 17.5.2: aSIFSTime = 16 usec 199 * 802.11g - 19.8.4: aSIFSTime = 10 usec + 200 * signal ext = 6 usec 201 */ 202 dur = 16; /* SIFS + signal ext */ 203 dur += 16; /* 17.3.2.3: T_PREAMBLE = 16 usec */ 204 dur += 4; /* 17.3.2.3: T_SIGNAL = 4 usec */ 205 dur += 4 * DIV_ROUND_UP((16 + 8 * (len + 4) + 6) * 10, 206 4 * rate); /* T_SYM x N_SYM */ 207 } else { 208 /* 209 * 802.11b or 802.11g with 802.11b compatibility: 210 * 18.3.4: TXTIME = PreambleLength + PLCPHeaderTime + 211 * Ceiling(((LENGTH+PBCC)x8)/DATARATE). PBCC=0. 212 * 213 * 802.11 (DS): 15.3.3, 802.11b: 18.3.4 214 * aSIFSTime = 10 usec 215 * aPreambleLength = 144 usec or 72 usec with short preamble 216 * aPLCPHeaderLength = 48 usec or 24 usec with short preamble 217 */ 218 dur = 10; /* aSIFSTime = 10 usec */ 219 dur += short_preamble ? (72 + 24) : (144 + 48); 220 221 dur += DIV_ROUND_UP(8 * (len + 4) * 10, rate); 222 } 223 224 return dur; 225 } 226 227 /* Exported duration function for driver use */ 228 __le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw, 229 struct ieee80211_vif *vif, 230 size_t frame_len, 231 struct ieee80211_rate *rate) 232 { 233 struct ieee80211_local *local = hw_to_local(hw); 234 struct ieee80211_sub_if_data *sdata; 235 u16 dur; 236 int erp; 237 bool short_preamble = false; 238 239 erp = 0; 240 if (vif) { 241 sdata = vif_to_sdata(vif); 242 short_preamble = sdata->bss_conf.use_short_preamble; 243 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) 244 erp = rate->flags & IEEE80211_RATE_ERP_G; 245 } 246 247 dur = ieee80211_frame_duration(local, frame_len, rate->bitrate, erp, 248 short_preamble); 249 250 return cpu_to_le16(dur); 251 } 252 EXPORT_SYMBOL(ieee80211_generic_frame_duration); 253 254 __le16 ieee80211_rts_duration(struct ieee80211_hw *hw, 255 struct ieee80211_vif *vif, size_t frame_len, 256 const struct ieee80211_tx_info *frame_txctl) 257 { 258 struct ieee80211_local *local = hw_to_local(hw); 259 struct ieee80211_rate *rate; 260 struct ieee80211_sub_if_data *sdata; 261 bool short_preamble; 262 int erp; 263 u16 dur; 264 struct ieee80211_supported_band *sband; 265 266 sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; 267 268 short_preamble = false; 269 270 rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx]; 271 272 erp = 0; 273 if (vif) { 274 sdata = vif_to_sdata(vif); 275 short_preamble = sdata->bss_conf.use_short_preamble; 276 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) 277 erp = rate->flags & IEEE80211_RATE_ERP_G; 278 } 279 280 /* CTS duration */ 281 dur = ieee80211_frame_duration(local, 10, rate->bitrate, 282 erp, short_preamble); 283 /* Data frame duration */ 284 dur += ieee80211_frame_duration(local, frame_len, rate->bitrate, 285 erp, short_preamble); 286 /* ACK duration */ 287 dur += ieee80211_frame_duration(local, 10, rate->bitrate, 288 erp, short_preamble); 289 290 return cpu_to_le16(dur); 291 } 292 EXPORT_SYMBOL(ieee80211_rts_duration); 293 294 __le16 ieee80211_ctstoself_duration(struct ieee80211_hw *hw, 295 struct ieee80211_vif *vif, 296 size_t frame_len, 297 const struct ieee80211_tx_info *frame_txctl) 298 { 299 struct ieee80211_local *local = hw_to_local(hw); 300 struct ieee80211_rate *rate; 301 struct ieee80211_sub_if_data *sdata; 302 bool short_preamble; 303 int erp; 304 u16 dur; 305 struct ieee80211_supported_band *sband; 306 307 sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; 308 309 short_preamble = false; 310 311 rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx]; 312 erp = 0; 313 if (vif) { 314 sdata = vif_to_sdata(vif); 315 short_preamble = sdata->bss_conf.use_short_preamble; 316 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) 317 erp = rate->flags & IEEE80211_RATE_ERP_G; 318 } 319 320 /* Data frame duration */ 321 dur = ieee80211_frame_duration(local, frame_len, rate->bitrate, 322 erp, short_preamble); 323 if (!(frame_txctl->flags & IEEE80211_TX_CTL_NO_ACK)) { 324 /* ACK duration */ 325 dur += ieee80211_frame_duration(local, 10, rate->bitrate, 326 erp, short_preamble); 327 } 328 329 return cpu_to_le16(dur); 330 } 331 EXPORT_SYMBOL(ieee80211_ctstoself_duration); 332 333 void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue) 334 { 335 struct ieee80211_local *local = hw_to_local(hw); 336 337 if (test_bit(queue, local->queues_pending)) { 338 set_bit(queue, local->queues_pending_run); 339 tasklet_schedule(&local->tx_pending_tasklet); 340 } else { 341 netif_wake_subqueue(local->mdev, queue); 342 } 343 } 344 EXPORT_SYMBOL(ieee80211_wake_queue); 345 346 void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue) 347 { 348 struct ieee80211_local *local = hw_to_local(hw); 349 350 netif_stop_subqueue(local->mdev, queue); 351 } 352 EXPORT_SYMBOL(ieee80211_stop_queue); 353 354 void ieee80211_stop_queues(struct ieee80211_hw *hw) 355 { 356 int i; 357 358 for (i = 0; i < ieee80211_num_queues(hw); i++) 359 ieee80211_stop_queue(hw, i); 360 } 361 EXPORT_SYMBOL(ieee80211_stop_queues); 362 363 int ieee80211_queue_stopped(struct ieee80211_hw *hw, int queue) 364 { 365 struct ieee80211_local *local = hw_to_local(hw); 366 return __netif_subqueue_stopped(local->mdev, queue); 367 } 368 EXPORT_SYMBOL(ieee80211_queue_stopped); 369 370 void ieee80211_wake_queues(struct ieee80211_hw *hw) 371 { 372 int i; 373 374 for (i = 0; i < hw->queues + hw->ampdu_queues; i++) 375 ieee80211_wake_queue(hw, i); 376 } 377 EXPORT_SYMBOL(ieee80211_wake_queues); 378 379 void ieee80211_iterate_active_interfaces( 380 struct ieee80211_hw *hw, 381 void (*iterator)(void *data, u8 *mac, 382 struct ieee80211_vif *vif), 383 void *data) 384 { 385 struct ieee80211_local *local = hw_to_local(hw); 386 struct ieee80211_sub_if_data *sdata; 387 388 rtnl_lock(); 389 390 list_for_each_entry(sdata, &local->interfaces, list) { 391 switch (sdata->vif.type) { 392 case __NL80211_IFTYPE_AFTER_LAST: 393 case NL80211_IFTYPE_UNSPECIFIED: 394 case NL80211_IFTYPE_MONITOR: 395 case NL80211_IFTYPE_AP_VLAN: 396 continue; 397 case NL80211_IFTYPE_AP: 398 case NL80211_IFTYPE_STATION: 399 case NL80211_IFTYPE_ADHOC: 400 case NL80211_IFTYPE_WDS: 401 case NL80211_IFTYPE_MESH_POINT: 402 break; 403 } 404 if (netif_running(sdata->dev)) 405 iterator(data, sdata->dev->dev_addr, 406 &sdata->vif); 407 } 408 409 rtnl_unlock(); 410 } 411 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces); 412 413 void ieee80211_iterate_active_interfaces_atomic( 414 struct ieee80211_hw *hw, 415 void (*iterator)(void *data, u8 *mac, 416 struct ieee80211_vif *vif), 417 void *data) 418 { 419 struct ieee80211_local *local = hw_to_local(hw); 420 struct ieee80211_sub_if_data *sdata; 421 422 rcu_read_lock(); 423 424 list_for_each_entry_rcu(sdata, &local->interfaces, list) { 425 switch (sdata->vif.type) { 426 case __NL80211_IFTYPE_AFTER_LAST: 427 case NL80211_IFTYPE_UNSPECIFIED: 428 case NL80211_IFTYPE_MONITOR: 429 case NL80211_IFTYPE_AP_VLAN: 430 continue; 431 case NL80211_IFTYPE_AP: 432 case NL80211_IFTYPE_STATION: 433 case NL80211_IFTYPE_ADHOC: 434 case NL80211_IFTYPE_WDS: 435 case NL80211_IFTYPE_MESH_POINT: 436 break; 437 } 438 if (netif_running(sdata->dev)) 439 iterator(data, sdata->dev->dev_addr, 440 &sdata->vif); 441 } 442 443 rcu_read_unlock(); 444 } 445 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic); 446 447 void ieee802_11_parse_elems(u8 *start, size_t len, 448 struct ieee802_11_elems *elems) 449 { 450 size_t left = len; 451 u8 *pos = start; 452 453 memset(elems, 0, sizeof(*elems)); 454 elems->ie_start = start; 455 elems->total_len = len; 456 457 while (left >= 2) { 458 u8 id, elen; 459 460 id = *pos++; 461 elen = *pos++; 462 left -= 2; 463 464 if (elen > left) 465 return; 466 467 switch (id) { 468 case WLAN_EID_SSID: 469 elems->ssid = pos; 470 elems->ssid_len = elen; 471 break; 472 case WLAN_EID_SUPP_RATES: 473 elems->supp_rates = pos; 474 elems->supp_rates_len = elen; 475 break; 476 case WLAN_EID_FH_PARAMS: 477 elems->fh_params = pos; 478 elems->fh_params_len = elen; 479 break; 480 case WLAN_EID_DS_PARAMS: 481 elems->ds_params = pos; 482 elems->ds_params_len = elen; 483 break; 484 case WLAN_EID_CF_PARAMS: 485 elems->cf_params = pos; 486 elems->cf_params_len = elen; 487 break; 488 case WLAN_EID_TIM: 489 elems->tim = pos; 490 elems->tim_len = elen; 491 break; 492 case WLAN_EID_IBSS_PARAMS: 493 elems->ibss_params = pos; 494 elems->ibss_params_len = elen; 495 break; 496 case WLAN_EID_CHALLENGE: 497 elems->challenge = pos; 498 elems->challenge_len = elen; 499 break; 500 case WLAN_EID_WPA: 501 if (elen >= 4 && pos[0] == 0x00 && pos[1] == 0x50 && 502 pos[2] == 0xf2) { 503 /* Microsoft OUI (00:50:F2) */ 504 if (pos[3] == 1) { 505 /* OUI Type 1 - WPA IE */ 506 elems->wpa = pos; 507 elems->wpa_len = elen; 508 } else if (elen >= 5 && pos[3] == 2) { 509 if (pos[4] == 0) { 510 elems->wmm_info = pos; 511 elems->wmm_info_len = elen; 512 } else if (pos[4] == 1) { 513 elems->wmm_param = pos; 514 elems->wmm_param_len = elen; 515 } 516 } 517 } 518 break; 519 case WLAN_EID_RSN: 520 elems->rsn = pos; 521 elems->rsn_len = elen; 522 break; 523 case WLAN_EID_ERP_INFO: 524 elems->erp_info = pos; 525 elems->erp_info_len = elen; 526 break; 527 case WLAN_EID_EXT_SUPP_RATES: 528 elems->ext_supp_rates = pos; 529 elems->ext_supp_rates_len = elen; 530 break; 531 case WLAN_EID_HT_CAPABILITY: 532 if (elen >= sizeof(struct ieee80211_ht_cap)) 533 elems->ht_cap_elem = (void *)pos; 534 break; 535 case WLAN_EID_HT_EXTRA_INFO: 536 if (elen >= sizeof(struct ieee80211_ht_addt_info)) 537 elems->ht_info_elem = (void *)pos; 538 break; 539 case WLAN_EID_MESH_ID: 540 elems->mesh_id = pos; 541 elems->mesh_id_len = elen; 542 break; 543 case WLAN_EID_MESH_CONFIG: 544 elems->mesh_config = pos; 545 elems->mesh_config_len = elen; 546 break; 547 case WLAN_EID_PEER_LINK: 548 elems->peer_link = pos; 549 elems->peer_link_len = elen; 550 break; 551 case WLAN_EID_PREQ: 552 elems->preq = pos; 553 elems->preq_len = elen; 554 break; 555 case WLAN_EID_PREP: 556 elems->prep = pos; 557 elems->prep_len = elen; 558 break; 559 case WLAN_EID_PERR: 560 elems->perr = pos; 561 elems->perr_len = elen; 562 break; 563 case WLAN_EID_CHANNEL_SWITCH: 564 elems->ch_switch_elem = pos; 565 elems->ch_switch_elem_len = elen; 566 break; 567 case WLAN_EID_QUIET: 568 if (!elems->quiet_elem) { 569 elems->quiet_elem = pos; 570 elems->quiet_elem_len = elen; 571 } 572 elems->num_of_quiet_elem++; 573 break; 574 case WLAN_EID_COUNTRY: 575 elems->country_elem = pos; 576 elems->country_elem_len = elen; 577 break; 578 case WLAN_EID_PWR_CONSTRAINT: 579 elems->pwr_constr_elem = pos; 580 elems->pwr_constr_elem_len = elen; 581 break; 582 default: 583 break; 584 } 585 586 left -= elen; 587 pos += elen; 588 } 589 } 590 591 void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata) 592 { 593 struct ieee80211_local *local = sdata->local; 594 struct ieee80211_tx_queue_params qparam; 595 int i; 596 597 if (!local->ops->conf_tx) 598 return; 599 600 memset(&qparam, 0, sizeof(qparam)); 601 602 qparam.aifs = 2; 603 604 if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ && 605 !(sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)) 606 qparam.cw_min = 31; 607 else 608 qparam.cw_min = 15; 609 610 qparam.cw_max = 1023; 611 qparam.txop = 0; 612 613 for (i = 0; i < local_to_hw(local)->queues; i++) 614 local->ops->conf_tx(local_to_hw(local), i, &qparam); 615 } 616 617 void ieee80211_tx_skb(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb, 618 int encrypt) 619 { 620 skb->dev = sdata->local->mdev; 621 skb_set_mac_header(skb, 0); 622 skb_set_network_header(skb, 0); 623 skb_set_transport_header(skb, 0); 624 625 skb->iif = sdata->dev->ifindex; 626 skb->do_not_encrypt = !encrypt; 627 628 dev_queue_xmit(skb); 629 } 630 631 int ieee80211_set_freq(struct ieee80211_sub_if_data *sdata, int freqMHz) 632 { 633 int ret = -EINVAL; 634 struct ieee80211_channel *chan; 635 struct ieee80211_local *local = sdata->local; 636 637 chan = ieee80211_get_channel(local->hw.wiphy, freqMHz); 638 639 if (chan && !(chan->flags & IEEE80211_CHAN_DISABLED)) { 640 if (sdata->vif.type == NL80211_IFTYPE_ADHOC && 641 chan->flags & IEEE80211_CHAN_NO_IBSS) { 642 printk(KERN_DEBUG "%s: IBSS not allowed on frequency " 643 "%d MHz\n", sdata->dev->name, chan->center_freq); 644 return ret; 645 } 646 local->oper_channel = chan; 647 648 if (local->sw_scanning || local->hw_scanning) 649 ret = 0; 650 else 651 ret = ieee80211_hw_config(local); 652 653 rate_control_clear(local); 654 } 655 656 return ret; 657 } 658 659 u64 ieee80211_mandatory_rates(struct ieee80211_local *local, 660 enum ieee80211_band band) 661 { 662 struct ieee80211_supported_band *sband; 663 struct ieee80211_rate *bitrates; 664 u64 mandatory_rates; 665 enum ieee80211_rate_flags mandatory_flag; 666 int i; 667 668 sband = local->hw.wiphy->bands[band]; 669 if (!sband) { 670 WARN_ON(1); 671 sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; 672 } 673 674 if (band == IEEE80211_BAND_2GHZ) 675 mandatory_flag = IEEE80211_RATE_MANDATORY_B; 676 else 677 mandatory_flag = IEEE80211_RATE_MANDATORY_A; 678 679 bitrates = sband->bitrates; 680 mandatory_rates = 0; 681 for (i = 0; i < sband->n_bitrates; i++) 682 if (bitrates[i].flags & mandatory_flag) 683 mandatory_rates |= BIT(i); 684 return mandatory_rates; 685 } 686