Pileus Git - ~andy/linux/blob - net/mac80211/util.c

   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/export.h>
  17 #include <linux/types.h>
  18 #include <linux/slab.h>
  19 #include <linux/skbuff.h>
  20 #include <linux/etherdevice.h>
  21 #include <linux/if_arp.h>
  22 #include <linux/bitmap.h>
  23 #include <linux/crc32.h>
  24 #include <net/net_namespace.h>
  25 #include <net/cfg80211.h>
  26 #include <net/rtnetlink.h>
  27
  28 #include "ieee80211_i.h"
  29 #include "driver-ops.h"
  30 #include "rate.h"
  31 #include "mesh.h"
  32 #include "wme.h"
  33 #include "led.h"
  34 #include "wep.h"
  35
  36 /* privid for wiphys to determine whether they belong to us or not */
  37 void *mac80211_wiphy_privid = &mac80211_wiphy_privid;
  38
  39 struct ieee80211_hw *wiphy_to_ieee80211_hw(struct wiphy *wiphy)
  40 {
  41         struct ieee80211_local *local;
  42         BUG_ON(!wiphy);
  43
  44         local = wiphy_priv(wiphy);
  45         return &local->hw;
  46 }
  47 EXPORT_SYMBOL(wiphy_to_ieee80211_hw);
  48
  49 u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len,
  50                         enum nl80211_iftype type)
  51 {
  52         __le16 fc = hdr->frame_control;
  53
  54          /* drop ACK/CTS frames and incorrect hdr len (ctrl) */
  55         if (len < 16)
  56                 return NULL;
  57
  58         if (ieee80211_is_data(fc)) {
  59                 if (len < 24) /* drop incorrect hdr len (data) */
  60                         return NULL;
  61
  62                 if (ieee80211_has_a4(fc))
  63                         return NULL;
  64                 if (ieee80211_has_tods(fc))
  65                         return hdr->addr1;
  66                 if (ieee80211_has_fromds(fc))
  67                         return hdr->addr2;
  68
  69                 return hdr->addr3;
  70         }
  71
  72         if (ieee80211_is_mgmt(fc)) {
  73                 if (len < 24) /* drop incorrect hdr len (mgmt) */
  74                         return NULL;
  75                 return hdr->addr3;
  76         }
  77
  78         if (ieee80211_is_ctl(fc)) {
  79                 if(ieee80211_is_pspoll(fc))
  80                         return hdr->addr1;
  81
  82                 if (ieee80211_is_back_req(fc)) {
  83                         switch (type) {
  84                         case NL80211_IFTYPE_STATION:
  85                                 return hdr->addr2;
  86                         case NL80211_IFTYPE_AP:
  87                         case NL80211_IFTYPE_AP_VLAN:
  88                                 return hdr->addr1;
  89                         default:
  90                                 break; /* fall through to the return */
  91                         }
  92                 }
  93         }
  94
  95         return NULL;
  96 }
  97
  98 void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx)
  99 {
 100         struct sk_buff *skb;
 101         struct ieee80211_hdr *hdr;
 102
 103         skb_queue_walk(&tx->skbs, skb) {
 104                 hdr = (struct ieee80211_hdr *) skb->data;
 105                 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
 106         }
 107 }
 108
 109 int ieee80211_frame_duration(enum ieee80211_band band, size_t len,
 110                              int rate, int erp, int short_preamble,
 111                              int shift)
 112 {
 113         int dur;
 114
 115         /* calculate duration (in microseconds, rounded up to next higher
 116          * integer if it includes a fractional microsecond) to send frame of
 117          * len bytes (does not include FCS) at the given rate. Duration will
 118          * also include SIFS.
 119          *
 120          * rate is in 100 kbps, so divident is multiplied by 10 in the
 121          * DIV_ROUND_UP() operations.
 122          *
 123          * shift may be 2 for 5 MHz channels or 1 for 10 MHz channels, and
 124          * is assumed to be 0 otherwise.
 125          */
 126
 127         if (band == IEEE80211_BAND_5GHZ || erp) {
 128                 /*
 129                  * OFDM:
 130                  *
 131                  * N_DBPS = DATARATE x 4
 132                  * N_SYM = Ceiling((16+8xLENGTH+6) / N_DBPS)
 133                  *      (16 = SIGNAL time, 6 = tail bits)
 134                  * TXTIME = T_PREAMBLE + T_SIGNAL + T_SYM x N_SYM + Signal Ext
 135                  *
 136                  * T_SYM = 4 usec
 137                  * 802.11a - 18.5.2: aSIFSTime = 16 usec
 138                  * 802.11g - 19.8.4: aSIFSTime = 10 usec +
 139                  *      signal ext = 6 usec
 140                  */
 141                 dur = 16; /* SIFS + signal ext */
 142                 dur += 16; /* IEEE 802.11-2012 18.3.2.4: T_PREAMBLE = 16 usec */
 143                 dur += 4; /* IEEE 802.11-2012 18.3.2.4: T_SIGNAL = 4 usec */
 144                 dur += 4 * DIV_ROUND_UP((16 + 8 * (len + 4) + 6) * 10,
 145                                         4 * rate); /* T_SYM x N_SYM */
 146
 147                 /* IEEE 802.11-2012 18.3.2.4: all values above are:
 148                  *  * times 4 for 5 MHz
 149                  *  * times 2 for 10 MHz
 150                  */
 151                 dur *= 1 << shift;
 152         } else {
 153                 /*
 154                  * 802.11b or 802.11g with 802.11b compatibility:
 155                  * 18.3.4: TXTIME = PreambleLength + PLCPHeaderTime +
 156                  * Ceiling(((LENGTH+PBCC)x8)/DATARATE). PBCC=0.
 157                  *
 158                  * 802.11 (DS): 15.3.3, 802.11b: 18.3.4
 159                  * aSIFSTime = 10 usec
 160                  * aPreambleLength = 144 usec or 72 usec with short preamble
 161                  * aPLCPHeaderLength = 48 usec or 24 usec with short preamble
 162                  */
 163                 dur = 10; /* aSIFSTime = 10 usec */
 164                 dur += short_preamble ? (72 + 24) : (144 + 48);
 165
 166                 dur += DIV_ROUND_UP(8 * (len + 4) * 10, rate);
 167         }
 168
 169         return dur;
 170 }
 171
 172 /* Exported duration function for driver use */
 173 __le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw,
 174                                         struct ieee80211_vif *vif,
 175                                         enum ieee80211_band band,
 176                                         size_t frame_len,
 177                                         struct ieee80211_rate *rate)
 178 {
 179         struct ieee80211_sub_if_data *sdata;
 180         u16 dur;
 181         int erp, shift = 0;
 182         bool short_preamble = false;
 183
 184         erp = 0;
 185         if (vif) {
 186                 sdata = vif_to_sdata(vif);
 187                 short_preamble = sdata->vif.bss_conf.use_short_preamble;
 188                 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
 189                         erp = rate->flags & IEEE80211_RATE_ERP_G;
 190                 shift = ieee80211_vif_get_shift(vif);
 191         }
 192
 193         dur = ieee80211_frame_duration(band, frame_len, rate->bitrate, erp,
 194                                        short_preamble, shift);
 195
 196         return cpu_to_le16(dur);
 197 }
 198 EXPORT_SYMBOL(ieee80211_generic_frame_duration);
 199
 200 __le16 ieee80211_rts_duration(struct ieee80211_hw *hw,
 201                               struct ieee80211_vif *vif, size_t frame_len,
 202                               const struct ieee80211_tx_info *frame_txctl)
 203 {
 204         struct ieee80211_local *local = hw_to_local(hw);
 205         struct ieee80211_rate *rate;
 206         struct ieee80211_sub_if_data *sdata;
 207         bool short_preamble;
 208         int erp, shift = 0;
 209         u16 dur;
 210         struct ieee80211_supported_band *sband;
 211
 212         sband = local->hw.wiphy->bands[frame_txctl->band];
 213
 214         short_preamble = false;
 215
 216         rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
 217
 218         erp = 0;
 219         if (vif) {
 220                 sdata = vif_to_sdata(vif);
 221                 short_preamble = sdata->vif.bss_conf.use_short_preamble;
 222                 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
 223                         erp = rate->flags & IEEE80211_RATE_ERP_G;
 224                 shift = ieee80211_vif_get_shift(vif);
 225         }
 226
 227         /* CTS duration */
 228         dur = ieee80211_frame_duration(sband->band, 10, rate->bitrate,
 229                                        erp, short_preamble, shift);
 230         /* Data frame duration */
 231         dur += ieee80211_frame_duration(sband->band, frame_len, rate->bitrate,
 232                                         erp, short_preamble, shift);
 233         /* ACK duration */
 234         dur += ieee80211_frame_duration(sband->band, 10, rate->bitrate,
 235                                         erp, short_preamble, shift);
 236
 237         return cpu_to_le16(dur);
 238 }
 239 EXPORT_SYMBOL(ieee80211_rts_duration);
 240
 241 __le16 ieee80211_ctstoself_duration(struct ieee80211_hw *hw,
 242                                     struct ieee80211_vif *vif,
 243                                     size_t frame_len,
 244                                     const struct ieee80211_tx_info *frame_txctl)
 245 {
 246         struct ieee80211_local *local = hw_to_local(hw);
 247         struct ieee80211_rate *rate;
 248         struct ieee80211_sub_if_data *sdata;
 249         bool short_preamble;
 250         int erp, shift = 0;
 251         u16 dur;
 252         struct ieee80211_supported_band *sband;
 253
 254         sband = local->hw.wiphy->bands[frame_txctl->band];
 255
 256         short_preamble = false;
 257
 258         rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
 259         erp = 0;
 260         if (vif) {
 261                 sdata = vif_to_sdata(vif);
 262                 short_preamble = sdata->vif.bss_conf.use_short_preamble;
 263                 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
 264                         erp = rate->flags & IEEE80211_RATE_ERP_G;
 265                 shift = ieee80211_vif_get_shift(vif);
 266         }
 267
 268         /* Data frame duration */
 269         dur = ieee80211_frame_duration(sband->band, frame_len, rate->bitrate,
 270                                        erp, short_preamble, shift);
 271         if (!(frame_txctl->flags & IEEE80211_TX_CTL_NO_ACK)) {
 272                 /* ACK duration */
 273                 dur += ieee80211_frame_duration(sband->band, 10, rate->bitrate,
 274                                                 erp, short_preamble, shift);
 275         }
 276
 277         return cpu_to_le16(dur);
 278 }
 279 EXPORT_SYMBOL(ieee80211_ctstoself_duration);
 280
 281 void ieee80211_propagate_queue_wake(struct ieee80211_local *local, int queue)
 282 {
 283         struct ieee80211_sub_if_data *sdata;
 284         int n_acs = IEEE80211_NUM_ACS;
 285
 286         if (local->hw.queues < IEEE80211_NUM_ACS)
 287                 n_acs = 1;
 288
 289         list_for_each_entry_rcu(sdata, &local->interfaces, list) {
 290                 int ac;
 291
 292                 if (!sdata->dev)
 293                         continue;
 294
 295                 if (test_bit(SDATA_STATE_OFFCHANNEL, &sdata->state))
 296                         continue;
 297
 298                 if (sdata->vif.cab_queue != IEEE80211_INVAL_HW_QUEUE &&
 299                     local->queue_stop_reasons[sdata->vif.cab_queue] != 0)
 300                         continue;
 301
 302                 for (ac = 0; ac < n_acs; ac++) {
 303                         int ac_queue = sdata->vif.hw_queue[ac];
 304
 305                         if (ac_queue == queue ||
 306                             (sdata->vif.cab_queue == queue &&
 307                              local->queue_stop_reasons[ac_queue] == 0 &&
 308                              skb_queue_empty(&local->pending[ac_queue])))
 309                                 netif_wake_subqueue(sdata->dev, ac);
 310                 }
 311         }
 312 }
 313
 314 static void __ieee80211_wake_queue(struct ieee80211_hw *hw, int queue,
 315                                    enum queue_stop_reason reason)
 316 {
 317         struct ieee80211_local *local = hw_to_local(hw);
 318
 319         trace_wake_queue(local, queue, reason);
 320
 321         if (WARN_ON(queue >= hw->queues))
 322                 return;
 323
 324         if (!test_bit(reason, &local->queue_stop_reasons[queue]))
 325                 return;
 326
 327         __clear_bit(reason, &local->queue_stop_reasons[queue]);
 328
 329         if (local->queue_stop_reasons[queue] != 0)
 330                 /* someone still has this queue stopped */
 331                 return;
 332
 333         if (skb_queue_empty(&local->pending[queue])) {
 334                 rcu_read_lock();
 335                 ieee80211_propagate_queue_wake(local, queue);
 336                 rcu_read_unlock();
 337         } else
 338                 tasklet_schedule(&local->tx_pending_tasklet);
 339 }
 340
 341 void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue,
 342                                     enum queue_stop_reason reason)
 343 {
 344         struct ieee80211_local *local = hw_to_local(hw);
 345         unsigned long flags;
 346
 347         spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 348         __ieee80211_wake_queue(hw, queue, reason);
 349         spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 350 }
 351
 352 void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue)
 353 {
 354         ieee80211_wake_queue_by_reason(hw, queue,
 355                                        IEEE80211_QUEUE_STOP_REASON_DRIVER);
 356 }
 357 EXPORT_SYMBOL(ieee80211_wake_queue);
 358
 359 static void __ieee80211_stop_queue(struct ieee80211_hw *hw, int queue,
 360                                    enum queue_stop_reason reason)
 361 {
 362         struct ieee80211_local *local = hw_to_local(hw);
 363         struct ieee80211_sub_if_data *sdata;
 364         int n_acs = IEEE80211_NUM_ACS;
 365
 366         trace_stop_queue(local, queue, reason);
 367
 368         if (WARN_ON(queue >= hw->queues))
 369                 return;
 370
 371         if (test_bit(reason, &local->queue_stop_reasons[queue]))
 372                 return;
 373
 374         __set_bit(reason, &local->queue_stop_reasons[queue]);
 375
 376         if (local->hw.queues < IEEE80211_NUM_ACS)
 377                 n_acs = 1;
 378
 379         rcu_read_lock();
 380         list_for_each_entry_rcu(sdata, &local->interfaces, list) {
 381                 int ac;
 382
 383                 if (!sdata->dev)
 384                         continue;
 385
 386                 for (ac = 0; ac < n_acs; ac++) {
 387                         if (sdata->vif.hw_queue[ac] == queue ||
 388                             sdata->vif.cab_queue == queue)
 389                                 netif_stop_subqueue(sdata->dev, ac);
 390                 }
 391         }
 392         rcu_read_unlock();
 393 }
 394
 395 void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue,
 396                                     enum queue_stop_reason reason)
 397 {
 398         struct ieee80211_local *local = hw_to_local(hw);
 399         unsigned long flags;
 400
 401         spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 402         __ieee80211_stop_queue(hw, queue, reason);
 403         spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 404 }
 405
 406 void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue)
 407 {
 408         ieee80211_stop_queue_by_reason(hw, queue,
 409                                        IEEE80211_QUEUE_STOP_REASON_DRIVER);
 410 }
 411 EXPORT_SYMBOL(ieee80211_stop_queue);
 412
 413 void ieee80211_add_pending_skb(struct ieee80211_local *local,
 414                                struct sk_buff *skb)
 415 {
 416         struct ieee80211_hw *hw = &local->hw;
 417         unsigned long flags;
 418         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 419         int queue = info->hw_queue;
 420
 421         if (WARN_ON(!info->control.vif)) {
 422                 ieee80211_free_txskb(&local->hw, skb);
 423                 return;
 424         }
 425
 426         spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 427         __ieee80211_stop_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD);
 428         __skb_queue_tail(&local->pending[queue], skb);
 429         __ieee80211_wake_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD);
 430         spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 431 }
 432
 433 void ieee80211_add_pending_skbs_fn(struct ieee80211_local *local,
 434                                    struct sk_buff_head *skbs,
 435                                    void (*fn)(void *data), void *data)
 436 {
 437         struct ieee80211_hw *hw = &local->hw;
 438         struct sk_buff *skb;
 439         unsigned long flags;
 440         int queue, i;
 441
 442         spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 443         while ((skb = skb_dequeue(skbs))) {
 444                 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 445
 446                 if (WARN_ON(!info->control.vif)) {
 447                         ieee80211_free_txskb(&local->hw, skb);
 448                         continue;
 449                 }
 450
 451                 queue = info->hw_queue;
 452
 453                 __ieee80211_stop_queue(hw, queue,
 454                                 IEEE80211_QUEUE_STOP_REASON_SKB_ADD);
 455
 456                 __skb_queue_tail(&local->pending[queue], skb);
 457         }
 458
 459         if (fn)
 460                 fn(data);
 461
 462         for (i = 0; i < hw->queues; i++)
 463                 __ieee80211_wake_queue(hw, i,
 464                         IEEE80211_QUEUE_STOP_REASON_SKB_ADD);
 465         spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 466 }
 467
 468 void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw,
 469                                      unsigned long queues,
 470                                      enum queue_stop_reason reason)
 471 {
 472         struct ieee80211_local *local = hw_to_local(hw);
 473         unsigned long flags;
 474         int i;
 475
 476         spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 477
 478         for_each_set_bit(i, &queues, hw->queues)
 479                 __ieee80211_stop_queue(hw, i, reason);
 480
 481         spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 482 }
 483
 484 void ieee80211_stop_queues(struct ieee80211_hw *hw)
 485 {
 486         ieee80211_stop_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
 487                                         IEEE80211_QUEUE_STOP_REASON_DRIVER);
 488 }
 489 EXPORT_SYMBOL(ieee80211_stop_queues);
 490
 491 int ieee80211_queue_stopped(struct ieee80211_hw *hw, int queue)
 492 {
 493         struct ieee80211_local *local = hw_to_local(hw);
 494         unsigned long flags;
 495         int ret;
 496
 497         if (WARN_ON(queue >= hw->queues))
 498                 return true;
 499
 500         spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 501         ret = test_bit(IEEE80211_QUEUE_STOP_REASON_DRIVER,
 502                        &local->queue_stop_reasons[queue]);
 503         spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 504         return ret;
 505 }
 506 EXPORT_SYMBOL(ieee80211_queue_stopped);
 507
 508 void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw,
 509                                      unsigned long queues,
 510                                      enum queue_stop_reason reason)
 511 {
 512         struct ieee80211_local *local = hw_to_local(hw);
 513         unsigned long flags;
 514         int i;
 515
 516         spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 517
 518         for_each_set_bit(i, &queues, hw->queues)
 519                 __ieee80211_wake_queue(hw, i, reason);
 520
 521         spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 522 }
 523
 524 void ieee80211_wake_queues(struct ieee80211_hw *hw)
 525 {
 526         ieee80211_wake_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
 527                                         IEEE80211_QUEUE_STOP_REASON_DRIVER);
 528 }
 529 EXPORT_SYMBOL(ieee80211_wake_queues);
 530
 531 void ieee80211_flush_queues(struct ieee80211_local *local,
 532                             struct ieee80211_sub_if_data *sdata)
 533 {
 534         u32 queues;
 535
 536         if (!local->ops->flush)
 537                 return;
 538
 539         if (sdata && local->hw.flags & IEEE80211_HW_QUEUE_CONTROL) {
 540                 int ac;
 541
 542                 queues = 0;
 543
 544                 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
 545                         queues |= BIT(sdata->vif.hw_queue[ac]);
 546                 if (sdata->vif.cab_queue != IEEE80211_INVAL_HW_QUEUE)
 547                         queues |= BIT(sdata->vif.cab_queue);
 548         } else {
 549                 /* all queues */
 550                 queues = BIT(local->hw.queues) - 1;
 551         }
 552
 553         ieee80211_stop_queues_by_reason(&local->hw, IEEE80211_MAX_QUEUE_MAP,
 554                                         IEEE80211_QUEUE_STOP_REASON_FLUSH);
 555
 556         drv_flush(local, queues, false);
 557
 558         ieee80211_wake_queues_by_reason(&local->hw, IEEE80211_MAX_QUEUE_MAP,
 559                                         IEEE80211_QUEUE_STOP_REASON_FLUSH);
 560 }
 561
 562 void ieee80211_iterate_active_interfaces(
 563         struct ieee80211_hw *hw, u32 iter_flags,
 564         void (*iterator)(void *data, u8 *mac,
 565                          struct ieee80211_vif *vif),
 566         void *data)
 567 {
 568         struct ieee80211_local *local = hw_to_local(hw);
 569         struct ieee80211_sub_if_data *sdata;
 570
 571         mutex_lock(&local->iflist_mtx);
 572
 573         list_for_each_entry(sdata, &local->interfaces, list) {
 574                 switch (sdata->vif.type) {
 575                 case NL80211_IFTYPE_MONITOR:
 576                         if (!(sdata->u.mntr_flags & MONITOR_FLAG_ACTIVE))
 577                                 continue;
 578                         break;
 579                 case NL80211_IFTYPE_AP_VLAN:
 580                         continue;
 581                 default:
 582                         break;
 583                 }
 584                 if (!(iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL) &&
 585                     !(sdata->flags & IEEE80211_SDATA_IN_DRIVER))
 586                         continue;
 587                 if (ieee80211_sdata_running(sdata))
 588                         iterator(data, sdata->vif.addr,
 589                                  &sdata->vif);
 590         }
 591
 592         sdata = rcu_dereference_protected(local->monitor_sdata,
 593                                           lockdep_is_held(&local->iflist_mtx));
 594         if (sdata &&
 595             (iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL ||
 596              sdata->flags & IEEE80211_SDATA_IN_DRIVER))
 597                 iterator(data, sdata->vif.addr, &sdata->vif);
 598
 599         mutex_unlock(&local->iflist_mtx);
 600 }
 601 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces);
 602
 603 void ieee80211_iterate_active_interfaces_atomic(
 604         struct ieee80211_hw *hw, u32 iter_flags,
 605         void (*iterator)(void *data, u8 *mac,
 606                          struct ieee80211_vif *vif),
 607         void *data)
 608 {
 609         struct ieee80211_local *local = hw_to_local(hw);
 610         struct ieee80211_sub_if_data *sdata;
 611
 612         rcu_read_lock();
 613
 614         list_for_each_entry_rcu(sdata, &local->interfaces, list) {
 615                 switch (sdata->vif.type) {
 616                 case NL80211_IFTYPE_MONITOR:
 617                         if (!(sdata->u.mntr_flags & MONITOR_FLAG_ACTIVE))
 618                                 continue;
 619                         break;
 620                 case NL80211_IFTYPE_AP_VLAN:
 621                         continue;
 622                 default:
 623                         break;
 624                 }
 625                 if (!(iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL) &&
 626                     !(sdata->flags & IEEE80211_SDATA_IN_DRIVER))
 627                         continue;
 628                 if (ieee80211_sdata_running(sdata))
 629                         iterator(data, sdata->vif.addr,
 630                                  &sdata->vif);
 631         }
 632
 633         sdata = rcu_dereference(local->monitor_sdata);
 634         if (sdata &&
 635             (iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL ||
 636              sdata->flags & IEEE80211_SDATA_IN_DRIVER))
 637                 iterator(data, sdata->vif.addr, &sdata->vif);
 638
 639         rcu_read_unlock();
 640 }
 641 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic);
 642
 643 /*
 644  * Nothing should have been stuffed into the workqueue during
 645  * the suspend->resume cycle. If this WARN is seen then there
 646  * is a bug with either the driver suspend or something in
 647  * mac80211 stuffing into the workqueue which we haven't yet
 648  * cleared during mac80211's suspend cycle.
 649  */
 650 static bool ieee80211_can_queue_work(struct ieee80211_local *local)
 651 {
 652         if (WARN(local->suspended && !local->resuming,
 653                  "queueing ieee80211 work while going to suspend\n"))
 654                 return false;
 655
 656         return true;
 657 }
 658
 659 void ieee80211_queue_work(struct ieee80211_hw *hw, struct work_struct *work)
 660 {
 661         struct ieee80211_local *local = hw_to_local(hw);
 662
 663         if (!ieee80211_can_queue_work(local))
 664                 return;
 665
 666         queue_work(local->workqueue, work);
 667 }
 668 EXPORT_SYMBOL(ieee80211_queue_work);
 669
 670 void ieee80211_queue_delayed_work(struct ieee80211_hw *hw,
 671                                   struct delayed_work *dwork,
 672                                   unsigned long delay)
 673 {
 674         struct ieee80211_local *local = hw_to_local(hw);
 675
 676         if (!ieee80211_can_queue_work(local))
 677                 return;
 678
 679         queue_delayed_work(local->workqueue, dwork, delay);
 680 }
 681 EXPORT_SYMBOL(ieee80211_queue_delayed_work);
 682
 683 u32 ieee802_11_parse_elems_crc(const u8 *start, size_t len, bool action,
 684                                struct ieee802_11_elems *elems,
 685                                u64 filter, u32 crc)
 686 {
 687         size_t left = len;
 688         const u8 *pos = start;
 689         bool calc_crc = filter != 0;
 690         DECLARE_BITMAP(seen_elems, 256);
 691         const u8 *ie;
 692
 693         bitmap_zero(seen_elems, 256);
 694         memset(elems, 0, sizeof(*elems));
 695         elems->ie_start = start;
 696         elems->total_len = len;
 697
 698         while (left >= 2) {
 699                 u8 id, elen;
 700                 bool elem_parse_failed;
 701
 702                 id = *pos++;
 703                 elen = *pos++;
 704                 left -= 2;
 705
 706                 if (elen > left) {
 707                         elems->parse_error = true;
 708                         break;
 709                 }
 710
 711                 switch (id) {
 712                 case WLAN_EID_SSID:
 713                 case WLAN_EID_SUPP_RATES:
 714                 case WLAN_EID_FH_PARAMS:
 715                 case WLAN_EID_DS_PARAMS:
 716                 case WLAN_EID_CF_PARAMS:
 717                 case WLAN_EID_TIM:
 718                 case WLAN_EID_IBSS_PARAMS:
 719                 case WLAN_EID_CHALLENGE:
 720                 case WLAN_EID_RSN:
 721                 case WLAN_EID_ERP_INFO:
 722                 case WLAN_EID_EXT_SUPP_RATES:
 723                 case WLAN_EID_HT_CAPABILITY:
 724                 case WLAN_EID_HT_OPERATION:
 725                 case WLAN_EID_VHT_CAPABILITY:
 726                 case WLAN_EID_VHT_OPERATION:
 727                 case WLAN_EID_MESH_ID:
 728                 case WLAN_EID_MESH_CONFIG:
 729                 case WLAN_EID_PEER_MGMT:
 730                 case WLAN_EID_PREQ:
 731                 case WLAN_EID_PREP:
 732                 case WLAN_EID_PERR:
 733                 case WLAN_EID_RANN:
 734                 case WLAN_EID_CHANNEL_SWITCH:
 735                 case WLAN_EID_EXT_CHANSWITCH_ANN:
 736                 case WLAN_EID_COUNTRY:
 737                 case WLAN_EID_PWR_CONSTRAINT:
 738                 case WLAN_EID_TIMEOUT_INTERVAL:
 739                 case WLAN_EID_SECONDARY_CHANNEL_OFFSET:
 740                 case WLAN_EID_WIDE_BW_CHANNEL_SWITCH:
 741                 /*
 742                  * not listing WLAN_EID_CHANNEL_SWITCH_WRAPPER -- it seems possible
 743                  * that if the content gets bigger it might be needed more than once
 744                  */
 745                         if (test_bit(id, seen_elems)) {
 746                                 elems->parse_error = true;
 747                                 left -= elen;
 748                                 pos += elen;
 749                                 continue;
 750                         }
 751                         break;
 752                 }
 753
 754                 if (calc_crc && id < 64 && (filter & (1ULL << id)))
 755                         crc = crc32_be(crc, pos - 2, elen + 2);
 756
 757                 elem_parse_failed = false;
 758
 759                 switch (id) {
 760                 case WLAN_EID_SSID:
 761                         elems->ssid = pos;
 762                         elems->ssid_len = elen;
 763                         break;
 764                 case WLAN_EID_SUPP_RATES:
 765                         elems->supp_rates = pos;
 766                         elems->supp_rates_len = elen;
 767                         break;
 768                 case WLAN_EID_DS_PARAMS:
 769                         if (elen >= 1)
 770                                 elems->ds_params = pos;
 771                         else
 772                                 elem_parse_failed = true;
 773                         break;
 774                 case WLAN_EID_TIM:
 775                         if (elen >= sizeof(struct ieee80211_tim_ie)) {
 776                                 elems->tim = (void *)pos;
 777                                 elems->tim_len = elen;
 778                         } else
 779                                 elem_parse_failed = true;
 780                         break;
 781                 case WLAN_EID_CHALLENGE:
 782                         elems->challenge = pos;
 783                         elems->challenge_len = elen;
 784                         break;
 785                 case WLAN_EID_VENDOR_SPECIFIC:
 786                         if (elen >= 4 && pos[0] == 0x00 && pos[1] == 0x50 &&
 787                             pos[2] == 0xf2) {
 788                                 /* Microsoft OUI (00:50:F2) */
 789
 790                                 if (calc_crc)
 791                                         crc = crc32_be(crc, pos - 2, elen + 2);
 792
 793                                 if (elen >= 5 && pos[3] == 2) {
 794                                         /* OUI Type 2 - WMM IE */
 795                                         if (pos[4] == 0) {
 796                                                 elems->wmm_info = pos;
 797                                                 elems->wmm_info_len = elen;
 798                                         } else if (pos[4] == 1) {
 799                                                 elems->wmm_param = pos;
 800                                                 elems->wmm_param_len = elen;
 801                                         }
 802                                 }
 803                         }
 804                         break;
 805                 case WLAN_EID_RSN:
 806                         elems->rsn = pos;
 807                         elems->rsn_len = elen;
 808                         break;
 809                 case WLAN_EID_ERP_INFO:
 810                         if (elen >= 1)
 811                                 elems->erp_info = pos;
 812                         else
 813                                 elem_parse_failed = true;
 814                         break;
 815                 case WLAN_EID_EXT_SUPP_RATES:
 816                         elems->ext_supp_rates = pos;
 817                         elems->ext_supp_rates_len = elen;
 818                         break;
 819                 case WLAN_EID_HT_CAPABILITY:
 820                         if (elen >= sizeof(struct ieee80211_ht_cap))
 821                                 elems->ht_cap_elem = (void *)pos;
 822                         else
 823                                 elem_parse_failed = true;
 824                         break;
 825                 case WLAN_EID_HT_OPERATION:
 826                         if (elen >= sizeof(struct ieee80211_ht_operation))
 827                                 elems->ht_operation = (void *)pos;
 828                         else
 829                                 elem_parse_failed = true;
 830                         break;
 831                 case WLAN_EID_VHT_CAPABILITY:
 832                         if (elen >= sizeof(struct ieee80211_vht_cap))
 833                                 elems->vht_cap_elem = (void *)pos;
 834                         else
 835                                 elem_parse_failed = true;
 836                         break;
 837                 case WLAN_EID_VHT_OPERATION:
 838                         if (elen >= sizeof(struct ieee80211_vht_operation))
 839                                 elems->vht_operation = (void *)pos;
 840                         else
 841                                 elem_parse_failed = true;
 842                         break;
 843                 case WLAN_EID_OPMODE_NOTIF:
 844                         if (elen > 0)
 845                                 elems->opmode_notif = pos;
 846                         else
 847                                 elem_parse_failed = true;
 848                         break;
 849                 case WLAN_EID_MESH_ID:
 850                         elems->mesh_id = pos;
 851                         elems->mesh_id_len = elen;
 852                         break;
 853                 case WLAN_EID_MESH_CONFIG:
 854                         if (elen >= sizeof(struct ieee80211_meshconf_ie))
 855                                 elems->mesh_config = (void *)pos;
 856                         else
 857                                 elem_parse_failed = true;
 858                         break;
 859                 case WLAN_EID_PEER_MGMT:
 860                         elems->peering = pos;
 861                         elems->peering_len = elen;
 862                         break;
 863                 case WLAN_EID_MESH_AWAKE_WINDOW:
 864                         if (elen >= 2)
 865                                 elems->awake_window = (void *)pos;
 866                         break;
 867                 case WLAN_EID_PREQ:
 868                         elems->preq = pos;
 869                         elems->preq_len = elen;
 870                         break;
 871                 case WLAN_EID_PREP:
 872                         elems->prep = pos;
 873                         elems->prep_len = elen;
 874                         break;
 875                 case WLAN_EID_PERR:
 876                         elems->perr = pos;
 877                         elems->perr_len = elen;
 878                         break;
 879                 case WLAN_EID_RANN:
 880                         if (elen >= sizeof(struct ieee80211_rann_ie))
 881                                 elems->rann = (void *)pos;
 882                         else
 883                                 elem_parse_failed = true;
 884                         break;
 885                 case WLAN_EID_CHANNEL_SWITCH:
 886                         if (elen != sizeof(struct ieee80211_channel_sw_ie)) {
 887                                 elem_parse_failed = true;
 888                                 break;
 889                         }
 890                         elems->ch_switch_ie = (void *)pos;
 891                         break;
 892                 case WLAN_EID_EXT_CHANSWITCH_ANN:
 893                         if (elen != sizeof(struct ieee80211_ext_chansw_ie)) {
 894                                 elem_parse_failed = true;
 895                                 break;
 896                         }
 897                         elems->ext_chansw_ie = (void *)pos;
 898                         break;
 899                 case WLAN_EID_SECONDARY_CHANNEL_OFFSET:
 900                         if (elen != sizeof(struct ieee80211_sec_chan_offs_ie)) {
 901                                 elem_parse_failed = true;
 902                                 break;
 903                         }
 904                         elems->sec_chan_offs = (void *)pos;
 905                         break;
 906                 case WLAN_EID_WIDE_BW_CHANNEL_SWITCH:
 907                         if (!action ||
 908                             elen != sizeof(*elems->wide_bw_chansw_ie)) {
 909                                 elem_parse_failed = true;
 910                                 break;
 911                         }
 912                         elems->wide_bw_chansw_ie = (void *)pos;
 913                         break;
 914                 case WLAN_EID_CHANNEL_SWITCH_WRAPPER:
 915                         if (action) {
 916                                 elem_parse_failed = true;
 917                                 break;
 918                         }
 919                         /*
 920                          * This is a bit tricky, but as we only care about
 921                          * the wide bandwidth channel switch element, so
 922                          * just parse it out manually.
 923                          */
 924                         ie = cfg80211_find_ie(WLAN_EID_WIDE_BW_CHANNEL_SWITCH,
 925                                               pos, elen);
 926                         if (ie) {
 927                                 if (ie[1] == sizeof(*elems->wide_bw_chansw_ie))
 928                                         elems->wide_bw_chansw_ie =
 929                                                 (void *)(ie + 2);
 930                                 else
 931                                         elem_parse_failed = true;
 932                         }
 933                         break;
 934                 case WLAN_EID_COUNTRY:
 935                         elems->country_elem = pos;
 936                         elems->country_elem_len = elen;
 937                         break;
 938                 case WLAN_EID_PWR_CONSTRAINT:
 939                         if (elen != 1) {
 940                                 elem_parse_failed = true;
 941                                 break;
 942                         }
 943                         elems->pwr_constr_elem = pos;
 944                         break;
 945                 case WLAN_EID_TIMEOUT_INTERVAL:
 946                         if (elen >= sizeof(struct ieee80211_timeout_interval_ie))
 947                                 elems->timeout_int = (void *)pos;
 948                         else
 949                                 elem_parse_failed = true;
 950                         break;
 951                 default:
 952                         break;
 953                 }
 954
 955                 if (elem_parse_failed)
 956                         elems->parse_error = true;
 957                 else
 958                         __set_bit(id, seen_elems);
 959
 960                 left -= elen;
 961                 pos += elen;
 962         }
 963
 964         if (left != 0)
 965                 elems->parse_error = true;
 966
 967         return crc;
 968 }
 969
 970 void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata,
 971                                bool bss_notify)
 972 {
 973         struct ieee80211_local *local = sdata->local;
 974         struct ieee80211_tx_queue_params qparam;
 975         struct ieee80211_chanctx_conf *chanctx_conf;
 976         int ac;
 977         bool use_11b, enable_qos;
 978         int aCWmin, aCWmax;
 979
 980         if (!local->ops->conf_tx)
 981                 return;
 982
 983         if (local->hw.queues < IEEE80211_NUM_ACS)
 984                 return;
 985
 986         memset(&qparam, 0, sizeof(qparam));
 987
 988         rcu_read_lock();
 989         chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
 990         use_11b = (chanctx_conf &&
 991                    chanctx_conf->def.chan->band == IEEE80211_BAND_2GHZ) &&
 992                  !(sdata->flags & IEEE80211_SDATA_OPERATING_GMODE);
 993         rcu_read_unlock();
 994
 995         /*
 996          * By default disable QoS in STA mode for old access points, which do
 997          * not support 802.11e. New APs will provide proper queue parameters,
 998          * that we will configure later.
 999          */
1000         enable_qos = (sdata->vif.type != NL80211_IFTYPE_STATION);
1001
1002         for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
1003                 /* Set defaults according to 802.11-2007 Table 7-37 */
1004                 aCWmax = 1023;
1005                 if (use_11b)
1006                         aCWmin = 31;
1007                 else
1008                         aCWmin = 15;
1009
1010                 if (enable_qos) {
1011                         switch (ac) {
1012                         case IEEE80211_AC_BK:
1013                                 qparam.cw_max = aCWmax;
1014                                 qparam.cw_min = aCWmin;
1015                                 qparam.txop = 0;
1016                                 qparam.aifs = 7;
1017                                 break;
1018                         /* never happens but let's not leave undefined */
1019                         default:
1020                         case IEEE80211_AC_BE:
1021                                 qparam.cw_max = aCWmax;
1022                                 qparam.cw_min = aCWmin;
1023                                 qparam.txop = 0;
1024                                 qparam.aifs = 3;
1025                                 break;
1026                         case IEEE80211_AC_VI:
1027                                 qparam.cw_max = aCWmin;
1028                                 qparam.cw_min = (aCWmin + 1) / 2 - 1;
1029                                 if (use_11b)
1030                                         qparam.txop = 6016/32;
1031                                 else
1032                                         qparam.txop = 3008/32;
1033                                 qparam.aifs = 2;
1034                                 break;
1035                         case IEEE80211_AC_VO:
1036                                 qparam.cw_max = (aCWmin + 1) / 2 - 1;
1037                                 qparam.cw_min = (aCWmin + 1) / 4 - 1;
1038                                 if (use_11b)
1039                                         qparam.txop = 3264/32;
1040                                 else
1041                                         qparam.txop = 1504/32;
1042                                 qparam.aifs = 2;
1043                                 break;
1044                         }
1045                 } else {
1046                         /* Confiure old 802.11b/g medium access rules. */
1047                         qparam.cw_max = aCWmax;
1048                         qparam.cw_min = aCWmin;
1049                         qparam.txop = 0;
1050                         qparam.aifs = 2;
1051                 }
1052
1053                 qparam.uapsd = false;
1054
1055                 sdata->tx_conf[ac] = qparam;
1056                 drv_conf_tx(local, sdata, ac, &qparam);
1057         }
1058
1059         if (sdata->vif.type != NL80211_IFTYPE_MONITOR &&
1060             sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE) {
1061                 sdata->vif.bss_conf.qos = enable_qos;
1062                 if (bss_notify)
1063                         ieee80211_bss_info_change_notify(sdata,
1064                                                          BSS_CHANGED_QOS);
1065         }
1066 }
1067
1068 void ieee80211_sta_def_wmm_params(struct ieee80211_sub_if_data *sdata,
1069                                   const size_t supp_rates_len,
1070                                   const u8 *supp_rates)
1071 {
1072         struct ieee80211_chanctx_conf *chanctx_conf;
1073         int i, have_higher_than_11mbit = 0;
1074
1075         /* cf. IEEE 802.11 9.2.12 */
1076         for (i = 0; i < supp_rates_len; i++)
1077                 if ((supp_rates[i] & 0x7f) * 5 > 110)
1078                         have_higher_than_11mbit = 1;
1079
1080         rcu_read_lock();
1081         chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
1082
1083         if (chanctx_conf &&
1084             chanctx_conf->def.chan->band == IEEE80211_BAND_2GHZ &&
1085             have_higher_than_11mbit)
1086                 sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE;
1087         else
1088                 sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE;
1089         rcu_read_unlock();
1090
1091         ieee80211_set_wmm_default(sdata, true);
1092 }
1093
1094 void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata,
1095                          u16 transaction, u16 auth_alg, u16 status,
1096                          const u8 *extra, size_t extra_len, const u8 *da,
1097                          const u8 *bssid, const u8 *key, u8 key_len, u8 key_idx,
1098                          u32 tx_flags)
1099 {
1100         struct ieee80211_local *local = sdata->local;
1101         struct sk_buff *skb;
1102         struct ieee80211_mgmt *mgmt;
1103         int err;
1104
1105         skb = dev_alloc_skb(local->hw.extra_tx_headroom +
1106                             sizeof(*mgmt) + 6 + extra_len);
1107         if (!skb)
1108                 return;
1109
1110         skb_reserve(skb, local->hw.extra_tx_headroom);
1111
1112         mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24 + 6);
1113         memset(mgmt, 0, 24 + 6);
1114         mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
1115                                           IEEE80211_STYPE_AUTH);
1116         memcpy(mgmt->da, da, ETH_ALEN);
1117         memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
1118         memcpy(mgmt->bssid, bssid, ETH_ALEN);
1119         mgmt->u.auth.auth_alg = cpu_to_le16(auth_alg);
1120         mgmt->u.auth.auth_transaction = cpu_to_le16(transaction);
1121         mgmt->u.auth.status_code = cpu_to_le16(status);
1122         if (extra)
1123                 memcpy(skb_put(skb, extra_len), extra, extra_len);
1124
1125         if (auth_alg == WLAN_AUTH_SHARED_KEY && transaction == 3) {
1126                 mgmt->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
1127                 err = ieee80211_wep_encrypt(local, skb, key, key_len, key_idx);
1128                 WARN_ON(err);
1129         }
1130
1131         IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT |
1132                                         tx_flags;
1133         ieee80211_tx_skb(sdata, skb);
1134 }
1135
1136 void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
1137                                     const u8 *bssid, u16 stype, u16 reason,
1138                                     bool send_frame, u8 *frame_buf)
1139 {
1140         struct ieee80211_local *local = sdata->local;
1141         struct sk_buff *skb;
1142         struct ieee80211_mgmt *mgmt = (void *)frame_buf;
1143
1144         /* build frame */
1145         mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype);
1146         mgmt->duration = 0; /* initialize only */
1147         mgmt->seq_ctrl = 0; /* initialize only */
1148         memcpy(mgmt->da, bssid, ETH_ALEN);
1149         memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
1150         memcpy(mgmt->bssid, bssid, ETH_ALEN);
1151         /* u.deauth.reason_code == u.disassoc.reason_code */
1152         mgmt->u.deauth.reason_code = cpu_to_le16(reason);
1153
1154         if (send_frame) {
1155                 skb = dev_alloc_skb(local->hw.extra_tx_headroom +
1156                                     IEEE80211_DEAUTH_FRAME_LEN);
1157                 if (!skb)
1158                         return;
1159
1160                 skb_reserve(skb, local->hw.extra_tx_headroom);
1161
1162                 /* copy in frame */
1163                 memcpy(skb_put(skb, IEEE80211_DEAUTH_FRAME_LEN),
1164                        mgmt, IEEE80211_DEAUTH_FRAME_LEN);
1165
1166                 if (sdata->vif.type != NL80211_IFTYPE_STATION ||
1167                     !(sdata->u.mgd.flags & IEEE80211_STA_MFP_ENABLED))
1168                         IEEE80211_SKB_CB(skb)->flags |=
1169                                 IEEE80211_TX_INTFL_DONT_ENCRYPT;
1170
1171                 ieee80211_tx_skb(sdata, skb);
1172         }
1173 }
1174
1175 int ieee80211_build_preq_ies(struct ieee80211_local *local, u8 *buffer,
1176                              size_t buffer_len, const u8 *ie, size_t ie_len,
1177                              enum ieee80211_band band, u32 rate_mask,
1178                              u8 channel)
1179 {
1180         struct ieee80211_supported_band *sband;
1181         u8 *pos = buffer, *end = buffer + buffer_len;
1182         size_t offset = 0, noffset;
1183         int supp_rates_len, i;
1184         u8 rates[32];
1185         int num_rates;
1186         int ext_rates_len;
1187
1188         sband = local->hw.wiphy->bands[band];
1189         if (WARN_ON_ONCE(!sband))
1190                 return 0;
1191
1192         num_rates = 0;
1193         for (i = 0; i < sband->n_bitrates; i++) {
1194                 if ((BIT(i) & rate_mask) == 0)
1195                         continue; /* skip rate */
1196                 rates[num_rates++] = (u8) (sband->bitrates[i].bitrate / 5);
1197         }
1198
1199         supp_rates_len = min_t(int, num_rates, 8);
1200
1201         if (end - pos < 2 + supp_rates_len)
1202                 goto out_err;
1203         *pos++ = WLAN_EID_SUPP_RATES;
1204         *pos++ = supp_rates_len;
1205         memcpy(pos, rates, supp_rates_len);
1206         pos += supp_rates_len;
1207
1208         /* insert "request information" if in custom IEs */
1209         if (ie && ie_len) {
1210                 static const u8 before_extrates[] = {
1211                         WLAN_EID_SSID,
1212                         WLAN_EID_SUPP_RATES,
1213                         WLAN_EID_REQUEST,
1214                 };
1215                 noffset = ieee80211_ie_split(ie, ie_len,
1216                                              before_extrates,
1217                                              ARRAY_SIZE(before_extrates),
1218                                              offset);
1219                 if (end - pos < noffset - offset)
1220                         goto out_err;
1221                 memcpy(pos, ie + offset, noffset - offset);
1222                 pos += noffset - offset;
1223                 offset = noffset;
1224         }
1225
1226         ext_rates_len = num_rates - supp_rates_len;
1227         if (ext_rates_len > 0) {
1228                 if (end - pos < 2 + ext_rates_len)
1229                         goto out_err;
1230                 *pos++ = WLAN_EID_EXT_SUPP_RATES;
1231                 *pos++ = ext_rates_len;
1232                 memcpy(pos, rates + supp_rates_len, ext_rates_len);
1233                 pos += ext_rates_len;
1234         }
1235
1236         if (channel && sband->band == IEEE80211_BAND_2GHZ) {
1237                 if (end - pos < 3)
1238                         goto out_err;
1239                 *pos++ = WLAN_EID_DS_PARAMS;
1240                 *pos++ = 1;
1241                 *pos++ = channel;
1242         }
1243
1244         /* insert custom IEs that go before HT */
1245         if (ie && ie_len) {
1246                 static const u8 before_ht[] = {
1247                         WLAN_EID_SSID,
1248                         WLAN_EID_SUPP_RATES,
1249                         WLAN_EID_REQUEST,
1250                         WLAN_EID_EXT_SUPP_RATES,
1251                         WLAN_EID_DS_PARAMS,
1252                         WLAN_EID_SUPPORTED_REGULATORY_CLASSES,
1253                 };
1254                 noffset = ieee80211_ie_split(ie, ie_len,
1255                                              before_ht, ARRAY_SIZE(before_ht),
1256                                              offset);
1257                 if (end - pos < noffset - offset)
1258                         goto out_err;
1259                 memcpy(pos, ie + offset, noffset - offset);
1260                 pos += noffset - offset;
1261                 offset = noffset;
1262         }
1263
1264         if (sband->ht_cap.ht_supported) {
1265                 if (end - pos < 2 + sizeof(struct ieee80211_ht_cap))
1266                         goto out_err;
1267                 pos = ieee80211_ie_build_ht_cap(pos, &sband->ht_cap,
1268                                                 sband->ht_cap.cap);
1269         }
1270
1271         /*
1272          * If adding more here, adjust code in main.c
1273          * that calculates local->scan_ies_len.
1274          */
1275
1276         /* add any remaining custom IEs */
1277         if (ie && ie_len) {
1278                 noffset = ie_len;
1279                 if (end - pos < noffset - offset)
1280                         goto out_err;
1281                 memcpy(pos, ie + offset, noffset - offset);
1282                 pos += noffset - offset;
1283         }
1284
1285         if (sband->vht_cap.vht_supported) {
1286                 if (end - pos < 2 + sizeof(struct ieee80211_vht_cap))
1287                         goto out_err;
1288                 pos = ieee80211_ie_build_vht_cap(pos, &sband->vht_cap,
1289                                                  sband->vht_cap.cap);
1290         }
1291
1292         return pos - buffer;
1293  out_err:
1294         WARN_ONCE(1, "not enough space for preq IEs\n");
1295         return pos - buffer;
1296 }
1297
1298 struct sk_buff *ieee80211_build_probe_req(struct ieee80211_sub_if_data *sdata,
1299                                           u8 *dst, u32 ratemask,
1300                                           struct ieee80211_channel *chan,
1301                                           const u8 *ssid, size_t ssid_len,
1302                                           const u8 *ie, size_t ie_len,
1303                                           bool directed)
1304 {
1305         struct ieee80211_local *local = sdata->local;
1306         struct sk_buff *skb;
1307         struct ieee80211_mgmt *mgmt;
1308         u8 chan_no;
1309         int ies_len;
1310
1311         /*
1312          * Do not send DS Channel parameter for directed probe requests
1313          * in order to maximize the chance that we get a response.  Some
1314          * badly-behaved APs don't respond when this parameter is included.
1315          */
1316         if (directed)
1317                 chan_no = 0;
1318         else
1319                 chan_no = ieee80211_frequency_to_channel(chan->center_freq);
1320
1321         skb = ieee80211_probereq_get(&local->hw, &sdata->vif,
1322                                      ssid, ssid_len, 100 + ie_len);
1323         if (!skb)
1324                 return NULL;
1325
1326         ies_len = ieee80211_build_preq_ies(local, skb_tail_pointer(skb),
1327                                            skb_tailroom(skb),
1328                                            ie, ie_len, chan->band,
1329                                            ratemask, chan_no);
1330         skb_put(skb, ies_len);
1331
1332         if (dst) {
1333                 mgmt = (struct ieee80211_mgmt *) skb->data;
1334                 memcpy(mgmt->da, dst, ETH_ALEN);
1335                 memcpy(mgmt->bssid, dst, ETH_ALEN);
1336         }
1337
1338         IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
1339
1340         return skb;
1341 }
1342
1343 void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata, u8 *dst,
1344                               const u8 *ssid, size_t ssid_len,
1345                               const u8 *ie, size_t ie_len,
1346                               u32 ratemask, bool directed, u32 tx_flags,
1347                               struct ieee80211_channel *channel, bool scan)
1348 {
1349         struct sk_buff *skb;
1350
1351         skb = ieee80211_build_probe_req(sdata, dst, ratemask, channel,
1352                                         ssid, ssid_len,
1353                                         ie, ie_len, directed);
1354         if (skb) {
1355                 IEEE80211_SKB_CB(skb)->flags |= tx_flags;
1356                 if (scan)
1357                         ieee80211_tx_skb_tid_band(sdata, skb, 7, channel->band);
1358                 else
1359                         ieee80211_tx_skb(sdata, skb);
1360         }
1361 }
1362
1363 u32 ieee80211_sta_get_rates(struct ieee80211_local *local,
1364                             struct ieee802_11_elems *elems,
1365                             enum ieee80211_band band, u32 *basic_rates)
1366 {
1367         struct ieee80211_supported_band *sband;
1368         struct ieee80211_rate *bitrates;
1369         size_t num_rates;
1370         u32 supp_rates;
1371         int i, j;
1372         sband = local->hw.wiphy->bands[band];
1373
1374         if (WARN_ON(!sband))
1375                 return 1;
1376
1377         bitrates = sband->bitrates;
1378         num_rates = sband->n_bitrates;
1379         supp_rates = 0;
1380         for (i = 0; i < elems->supp_rates_len +
1381                      elems->ext_supp_rates_len; i++) {
1382                 u8 rate = 0;
1383                 int own_rate;
1384                 bool is_basic;
1385                 if (i < elems->supp_rates_len)
1386                         rate = elems->supp_rates[i];
1387                 else if (elems->ext_supp_rates)
1388                         rate = elems->ext_supp_rates
1389                                 [i - elems->supp_rates_len];
1390                 own_rate = 5 * (rate & 0x7f);
1391                 is_basic = !!(rate & 0x80);
1392
1393                 if (is_basic && (rate & 0x7f) == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
1394                         continue;
1395
1396                 for (j = 0; j < num_rates; j++) {
1397                         if (bitrates[j].bitrate == own_rate) {
1398                                 supp_rates |= BIT(j);
1399                                 if (basic_rates && is_basic)
1400                                         *basic_rates |= BIT(j);
1401                         }
1402                 }
1403         }
1404         return supp_rates;
1405 }
1406
1407 void ieee80211_stop_device(struct ieee80211_local *local)
1408 {
1409         ieee80211_led_radio(local, false);
1410         ieee80211_mod_tpt_led_trig(local, 0, IEEE80211_TPT_LEDTRIG_FL_RADIO);
1411
1412         cancel_work_sync(&local->reconfig_filter);
1413
1414         flush_workqueue(local->workqueue);
1415         drv_stop(local);
1416 }
1417
1418 static void ieee80211_assign_chanctx(struct ieee80211_local *local,
1419                                      struct ieee80211_sub_if_data *sdata)
1420 {
1421         struct ieee80211_chanctx_conf *conf;
1422         struct ieee80211_chanctx *ctx;
1423
1424         if (!local->use_chanctx)
1425                 return;
1426
1427         mutex_lock(&local->chanctx_mtx);
1428         conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
1429                                          lockdep_is_held(&local->chanctx_mtx));
1430         if (conf) {
1431                 ctx = container_of(conf, struct ieee80211_chanctx, conf);
1432                 drv_assign_vif_chanctx(local, sdata, ctx);
1433         }
1434         mutex_unlock(&local->chanctx_mtx);
1435 }
1436
1437 int ieee80211_reconfig(struct ieee80211_local *local)
1438 {
1439         struct ieee80211_hw *hw = &local->hw;
1440         struct ieee80211_sub_if_data *sdata;
1441         struct ieee80211_chanctx *ctx;
1442         struct sta_info *sta;
1443         int res, i;
1444         bool reconfig_due_to_wowlan = false;
1445
1446 #ifdef CONFIG_PM
1447         if (local->suspended)
1448                 local->resuming = true;
1449
1450         if (local->wowlan) {
1451                 local->wowlan = false;
1452                 res = drv_resume(local);
1453                 if (res < 0) {
1454                         local->resuming = false;
1455                         return res;
1456                 }
1457                 if (res == 0)
1458                         goto wake_up;
1459                 WARN_ON(res > 1);
1460                 /*
1461                  * res is 1, which means the driver requested
1462                  * to go through a regular reset on wakeup.
1463                  */
1464                 reconfig_due_to_wowlan = true;
1465         }
1466 #endif
1467         /* everything else happens only if HW was up & running */
1468         if (!local->open_count)
1469                 goto wake_up;
1470
1471         /*
1472          * Upon resume hardware can sometimes be goofy due to
1473          * various platform / driver / bus issues, so restarting
1474          * the device may at times not work immediately. Propagate
1475          * the error.
1476          */
1477         res = drv_start(local);
1478         if (res) {
1479                 WARN(local->suspended, "Hardware became unavailable "
1480                      "upon resume. This could be a software issue "
1481                      "prior to suspend or a hardware issue.\n");
1482                 return res;
1483         }
1484
1485         /* setup fragmentation threshold */
1486         drv_set_frag_threshold(local, hw->wiphy->frag_threshold);
1487
1488         /* setup RTS threshold */
1489         drv_set_rts_threshold(local, hw->wiphy->rts_threshold);
1490
1491         /* reset coverage class */
1492         drv_set_coverage_class(local, hw->wiphy->coverage_class);
1493
1494         ieee80211_led_radio(local, true);
1495         ieee80211_mod_tpt_led_trig(local,
1496                                    IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);
1497
1498         /* add interfaces */
1499         sdata = rtnl_dereference(local->monitor_sdata);
1500         if (sdata) {
1501                 /* in HW restart it exists already */
1502                 WARN_ON(local->resuming);
1503                 res = drv_add_interface(local, sdata);
1504                 if (WARN_ON(res)) {
1505                         rcu_assign_pointer(local->monitor_sdata, NULL);
1506                         synchronize_net();
1507                         kfree(sdata);
1508                 }
1509         }
1510
1511         list_for_each_entry(sdata, &local->interfaces, list) {
1512                 if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
1513                     sdata->vif.type != NL80211_IFTYPE_MONITOR &&
1514                     ieee80211_sdata_running(sdata))
1515                         res = drv_add_interface(local, sdata);
1516         }
1517
1518         /* add channel contexts */
1519         if (local->use_chanctx) {
1520                 mutex_lock(&local->chanctx_mtx);
1521                 list_for_each_entry(ctx, &local->chanctx_list, list)
1522                         WARN_ON(drv_add_chanctx(local, ctx));
1523                 mutex_unlock(&local->chanctx_mtx);
1524         }
1525
1526         list_for_each_entry(sdata, &local->interfaces, list) {
1527                 if (!ieee80211_sdata_running(sdata))
1528                         continue;
1529                 ieee80211_assign_chanctx(local, sdata);
1530         }
1531
1532         sdata = rtnl_dereference(local->monitor_sdata);
1533         if (sdata && ieee80211_sdata_running(sdata))
1534                 ieee80211_assign_chanctx(local, sdata);
1535
1536         /* add STAs back */
1537         mutex_lock(&local->sta_mtx);
1538         list_for_each_entry(sta, &local->sta_list, list) {
1539                 enum ieee80211_sta_state state;
1540
1541                 if (!sta->uploaded)
1542                         continue;
1543
1544                 /* AP-mode stations will be added later */
1545                 if (sta->sdata->vif.type == NL80211_IFTYPE_AP)
1546                         continue;
1547
1548                 for (state = IEEE80211_STA_NOTEXIST;
1549                      state < sta->sta_state; state++)
1550                         WARN_ON(drv_sta_state(local, sta->sdata, sta, state,
1551                                               state + 1));
1552         }
1553         mutex_unlock(&local->sta_mtx);
1554
1555         /* reconfigure tx conf */
1556         if (hw->queues >= IEEE80211_NUM_ACS) {
1557                 list_for_each_entry(sdata, &local->interfaces, list) {
1558                         if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
1559                             sdata->vif.type == NL80211_IFTYPE_MONITOR ||
1560                             !ieee80211_sdata_running(sdata))
1561                                 continue;
1562
1563                         for (i = 0; i < IEEE80211_NUM_ACS; i++)
1564                                 drv_conf_tx(local, sdata, i,
1565                                             &sdata->tx_conf[i]);
1566                 }
1567         }
1568
1569         /* reconfigure hardware */
1570         ieee80211_hw_config(local, ~0);
1571
1572         ieee80211_configure_filter(local);
1573
1574         /* Finally also reconfigure all the BSS information */
1575         list_for_each_entry(sdata, &local->interfaces, list) {
1576                 u32 changed;
1577
1578                 if (!ieee80211_sdata_running(sdata))
1579                         continue;
1580
1581                 /* common change flags for all interface types */
1582                 changed = BSS_CHANGED_ERP_CTS_PROT |
1583                           BSS_CHANGED_ERP_PREAMBLE |
1584                           BSS_CHANGED_ERP_SLOT |
1585                           BSS_CHANGED_HT |
1586                           BSS_CHANGED_BASIC_RATES |
1587                           BSS_CHANGED_BEACON_INT |
1588                           BSS_CHANGED_BSSID |
1589                           BSS_CHANGED_CQM |
1590                           BSS_CHANGED_QOS |
1591                           BSS_CHANGED_IDLE |
1592                           BSS_CHANGED_TXPOWER;
1593
1594                 switch (sdata->vif.type) {
1595                 case NL80211_IFTYPE_STATION:
1596                         changed |= BSS_CHANGED_ASSOC |
1597                                    BSS_CHANGED_ARP_FILTER |
1598                                    BSS_CHANGED_PS;
1599
1600                         /* Re-send beacon info report to the driver */
1601                         if (sdata->u.mgd.have_beacon)
1602                                 changed |= BSS_CHANGED_BEACON_INFO;
1603
1604                         sdata_lock(sdata);
1605                         ieee80211_bss_info_change_notify(sdata, changed);
1606                         sdata_unlock(sdata);
1607                         break;
1608                 case NL80211_IFTYPE_ADHOC:
1609                         changed |= BSS_CHANGED_IBSS;
1610                         /* fall through */
1611                 case NL80211_IFTYPE_AP:
1612                         changed |= BSS_CHANGED_SSID | BSS_CHANGED_P2P_PS;
1613
1614                         if (sdata->vif.type == NL80211_IFTYPE_AP) {
1615                                 changed |= BSS_CHANGED_AP_PROBE_RESP;
1616
1617                                 if (rcu_access_pointer(sdata->u.ap.beacon))
1618                                         drv_start_ap(local, sdata);
1619                         }
1620
1621                         /* fall through */
1622                 case NL80211_IFTYPE_MESH_POINT:
1623                         if (sdata->vif.bss_conf.enable_beacon) {
1624                                 changed |= BSS_CHANGED_BEACON |
1625                                            BSS_CHANGED_BEACON_ENABLED;
1626                                 ieee80211_bss_info_change_notify(sdata, changed);
1627                         }
1628                         break;
1629                 case NL80211_IFTYPE_WDS:
1630                         break;
1631                 case NL80211_IFTYPE_AP_VLAN:
1632                 case NL80211_IFTYPE_MONITOR:
1633                         /* ignore virtual */
1634                         break;
1635                 case NL80211_IFTYPE_P2P_DEVICE:
1636                         changed = BSS_CHANGED_IDLE;
1637                         break;
1638                 case NL80211_IFTYPE_UNSPECIFIED:
1639                 case NUM_NL80211_IFTYPES:
1640                 case NL80211_IFTYPE_P2P_CLIENT:
1641                 case NL80211_IFTYPE_P2P_GO:
1642                         WARN_ON(1);
1643                         break;
1644                 }
1645         }
1646
1647         ieee80211_recalc_ps(local, -1);
1648
1649         /*
1650          * The sta might be in psm against the ap (e.g. because
1651          * this was the state before a hw restart), so we
1652          * explicitly send a null packet in order to make sure
1653          * it'll sync against the ap (and get out of psm).
1654          */
1655         if (!(local->hw.conf.flags & IEEE80211_CONF_PS)) {
1656                 list_for_each_entry(sdata, &local->interfaces, list) {
1657                         if (sdata->vif.type != NL80211_IFTYPE_STATION)
1658                                 continue;
1659                         if (!sdata->u.mgd.associated)
1660                                 continue;
1661
1662                         ieee80211_send_nullfunc(local, sdata, 0);
1663                 }
1664         }
1665
1666         /* APs are now beaconing, add back stations */
1667         mutex_lock(&local->sta_mtx);
1668         list_for_each_entry(sta, &local->sta_list, list) {
1669                 enum ieee80211_sta_state state;
1670
1671                 if (!sta->uploaded)
1672                         continue;
1673
1674                 if (sta->sdata->vif.type != NL80211_IFTYPE_AP)
1675                         continue;
1676
1677                 for (state = IEEE80211_STA_NOTEXIST;
1678                      state < sta->sta_state; state++)
1679                         WARN_ON(drv_sta_state(local, sta->sdata, sta, state,
1680                                               state + 1));
1681         }
1682         mutex_unlock(&local->sta_mtx);
1683
1684         /* add back keys */
1685         list_for_each_entry(sdata, &local->interfaces, list)
1686                 if (ieee80211_sdata_running(sdata))
1687                         ieee80211_enable_keys(sdata);
1688
1689  wake_up:
1690         local->in_reconfig = false;
1691         barrier();
1692
1693         if (local->monitors == local->open_count && local->monitors > 0)
1694                 ieee80211_add_virtual_monitor(local);
1695
1696         /*
1697          * Clear the WLAN_STA_BLOCK_BA flag so new aggregation
1698          * sessions can be established after a resume.
1699          *
1700          * Also tear down aggregation sessions since reconfiguring
1701          * them in a hardware restart scenario is not easily done
1702          * right now, and the hardware will have lost information
1703          * about the sessions, but we and the AP still think they
1704          * are active. This is really a workaround though.
1705          */
1706         if (hw->flags & IEEE80211_HW_AMPDU_AGGREGATION) {
1707                 mutex_lock(&local->sta_mtx);
1708
1709                 list_for_each_entry(sta, &local->sta_list, list) {
1710                         ieee80211_sta_tear_down_BA_sessions(
1711                                         sta, AGG_STOP_LOCAL_REQUEST);
1712                         clear_sta_flag(sta, WLAN_STA_BLOCK_BA);
1713                 }
1714
1715                 mutex_unlock(&local->sta_mtx);
1716         }
1717
1718         ieee80211_wake_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
1719                                         IEEE80211_QUEUE_STOP_REASON_SUSPEND);
1720
1721         /*
1722          * If this is for hw restart things are still running.
1723          * We may want to change that later, however.
1724          */
1725         if (!local->suspended || reconfig_due_to_wowlan)
1726                 drv_restart_complete(local);
1727
1728         if (!local->suspended)
1729                 return 0;
1730
1731 #ifdef CONFIG_PM
1732         /* first set suspended false, then resuming */
1733         local->suspended = false;
1734         mb();
1735         local->resuming = false;
1736
1737         list_for_each_entry(sdata, &local->interfaces, list) {
1738                 if (!ieee80211_sdata_running(sdata))
1739                         continue;
1740                 if (sdata->vif.type == NL80211_IFTYPE_STATION)
1741                         ieee80211_sta_restart(sdata);
1742         }
1743
1744         mod_timer(&local->sta_cleanup, jiffies + 1);
1745 #else
1746         WARN_ON(1);
1747 #endif
1748         return 0;
1749 }
1750
1751 void ieee80211_resume_disconnect(struct ieee80211_vif *vif)
1752 {
1753         struct ieee80211_sub_if_data *sdata;
1754         struct ieee80211_local *local;
1755         struct ieee80211_key *key;
1756
1757         if (WARN_ON(!vif))
1758                 return;
1759
1760         sdata = vif_to_sdata(vif);
1761         local = sdata->local;
1762
1763         if (WARN_ON(!local->resuming))
1764                 return;
1765
1766         if (WARN_ON(vif->type != NL80211_IFTYPE_STATION))
1767                 return;
1768
1769         sdata->flags |= IEEE80211_SDATA_DISCONNECT_RESUME;
1770
1771         mutex_lock(&local->key_mtx);
1772         list_for_each_entry(key, &sdata->key_list, list)
1773                 key->flags |= KEY_FLAG_TAINTED;
1774         mutex_unlock(&local->key_mtx);
1775 }
1776 EXPORT_SYMBOL_GPL(ieee80211_resume_disconnect);
1777
1778 void ieee80211_recalc_smps(struct ieee80211_sub_if_data *sdata)
1779 {
1780         struct ieee80211_local *local = sdata->local;
1781         struct ieee80211_chanctx_conf *chanctx_conf;
1782         struct ieee80211_chanctx *chanctx;
1783
1784         mutex_lock(&local->chanctx_mtx);
1785
1786         chanctx_conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
1787                                         lockdep_is_held(&local->chanctx_mtx));
1788
1789         if (WARN_ON_ONCE(!chanctx_conf))
1790                 goto unlock;
1791
1792         chanctx = container_of(chanctx_conf, struct ieee80211_chanctx, conf);
1793         ieee80211_recalc_smps_chanctx(local, chanctx);
1794  unlock:
1795         mutex_unlock(&local->chanctx_mtx);
1796 }
1797
1798 static bool ieee80211_id_in_list(const u8 *ids, int n_ids, u8 id)
1799 {
1800         int i;
1801
1802         for (i = 0; i < n_ids; i++)
1803                 if (ids[i] == id)
1804                         return true;
1805         return false;
1806 }
1807
1808 /**
1809  * ieee80211_ie_split - split an IE buffer according to ordering
1810  *
1811  * @ies: the IE buffer
1812  * @ielen: the length of the IE buffer
1813  * @ids: an array with element IDs that are allowed before
1814  *      the split
1815  * @n_ids: the size of the element ID array
1816  * @offset: offset where to start splitting in the buffer
1817  *
1818  * This function splits an IE buffer by updating the @offset
1819  * variable to point to the location where the buffer should be
1820  * split.
1821  *
1822  * It assumes that the given IE buffer is well-formed, this
1823  * has to be guaranteed by the caller!
1824  *
1825  * It also assumes that the IEs in the buffer are ordered
1826  * correctly, if not the result of using this function will not
1827  * be ordered correctly either, i.e. it does no reordering.
1828  *
1829  * The function returns the offset where the next part of the
1830  * buffer starts, which may be @ielen if the entire (remainder)
1831  * of the buffer should be used.
1832  */
1833 size_t ieee80211_ie_split(const u8 *ies, size_t ielen,
1834                           const u8 *ids, int n_ids, size_t offset)
1835 {
1836         size_t pos = offset;
1837
1838         while (pos < ielen && ieee80211_id_in_list(ids, n_ids, ies[pos]))
1839                 pos += 2 + ies[pos + 1];
1840
1841         return pos;
1842 }
1843
1844 size_t ieee80211_ie_split_vendor(const u8 *ies, size_t ielen, size_t offset)
1845 {
1846         size_t pos = offset;
1847
1848         while (pos < ielen && ies[pos] != WLAN_EID_VENDOR_SPECIFIC)
1849                 pos += 2 + ies[pos + 1];
1850
1851         return pos;
1852 }
1853
1854 static void _ieee80211_enable_rssi_reports(struct ieee80211_sub_if_data *sdata,
1855                                             int rssi_min_thold,
1856                                             int rssi_max_thold)
1857 {
1858         trace_api_enable_rssi_reports(sdata, rssi_min_thold, rssi_max_thold);
1859
1860         if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
1861                 return;
1862
1863         /*
1864          * Scale up threshold values before storing it, as the RSSI averaging
1865          * algorithm uses a scaled up value as well. Change this scaling
1866          * factor if the RSSI averaging algorithm changes.
1867          */
1868         sdata->u.mgd.rssi_min_thold = rssi_min_thold*16;
1869         sdata->u.mgd.rssi_max_thold = rssi_max_thold*16;
1870 }
1871
1872 void ieee80211_enable_rssi_reports(struct ieee80211_vif *vif,
1873                                     int rssi_min_thold,
1874                                     int rssi_max_thold)
1875 {
1876         struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
1877
1878         WARN_ON(rssi_min_thold == rssi_max_thold ||
1879                 rssi_min_thold > rssi_max_thold);
1880
1881         _ieee80211_enable_rssi_reports(sdata, rssi_min_thold,
1882                                        rssi_max_thold);
1883 }
1884 EXPORT_SYMBOL(ieee80211_enable_rssi_reports);
1885
1886 void ieee80211_disable_rssi_reports(struct ieee80211_vif *vif)
1887 {
1888         struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
1889
1890         _ieee80211_enable_rssi_reports(sdata, 0, 0);
1891 }
1892 EXPORT_SYMBOL(ieee80211_disable_rssi_reports);
1893
1894 u8 *ieee80211_ie_build_ht_cap(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
1895                               u16 cap)
1896 {
1897         __le16 tmp;
1898
1899         *pos++ = WLAN_EID_HT_CAPABILITY;
1900         *pos++ = sizeof(struct ieee80211_ht_cap);
1901         memset(pos, 0, sizeof(struct ieee80211_ht_cap));
1902
1903         /* capability flags */
1904         tmp = cpu_to_le16(cap);
1905         memcpy(pos, &tmp, sizeof(u16));
1906         pos += sizeof(u16);
1907
1908         /* AMPDU parameters */
1909         *pos++ = ht_cap->ampdu_factor |
1910                  (ht_cap->ampdu_density <<
1911                         IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT);
1912
1913         /* MCS set */
1914         memcpy(pos, &ht_cap->mcs, sizeof(ht_cap->mcs));
1915         pos += sizeof(ht_cap->mcs);
1916
1917         /* extended capabilities */
1918         pos += sizeof(__le16);
1919
1920         /* BF capabilities */
1921         pos += sizeof(__le32);
1922
1923         /* antenna selection */
1924         pos += sizeof(u8);
1925
1926         return pos;
1927 }
1928
1929 u8 *ieee80211_ie_build_vht_cap(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
1930                                u32 cap)
1931 {
1932         __le32 tmp;
1933
1934         *pos++ = WLAN_EID_VHT_CAPABILITY;
1935         *pos++ = sizeof(struct ieee80211_vht_cap);
1936         memset(pos, 0, sizeof(struct ieee80211_vht_cap));
1937
1938         /* capability flags */
1939         tmp = cpu_to_le32(cap);
1940         memcpy(pos, &tmp, sizeof(u32));
1941         pos += sizeof(u32);
1942
1943         /* VHT MCS set */
1944         memcpy(pos, &vht_cap->vht_mcs, sizeof(vht_cap->vht_mcs));
1945         pos += sizeof(vht_cap->vht_mcs);
1946
1947         return pos;
1948 }
1949
1950 u8 *ieee80211_ie_build_ht_oper(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
1951                                const struct cfg80211_chan_def *chandef,
1952                                u16 prot_mode)
1953 {
1954         struct ieee80211_ht_operation *ht_oper;
1955         /* Build HT Information */
1956         *pos++ = WLAN_EID_HT_OPERATION;
1957         *pos++ = sizeof(struct ieee80211_ht_operation);
1958         ht_oper = (struct ieee80211_ht_operation *)pos;
1959         ht_oper->primary_chan = ieee80211_frequency_to_channel(
1960                                         chandef->chan->center_freq);
1961         switch (chandef->width) {
1962         case NL80211_CHAN_WIDTH_160:
1963         case NL80211_CHAN_WIDTH_80P80:
1964         case NL80211_CHAN_WIDTH_80:
1965         case NL80211_CHAN_WIDTH_40:
1966                 if (chandef->center_freq1 > chandef->chan->center_freq)
1967                         ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
1968                 else
1969                         ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
1970                 break;
1971         default:
1972                 ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_NONE;
1973                 break;
1974         }
1975         if (ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 &&
1976             chandef->width != NL80211_CHAN_WIDTH_20_NOHT &&
1977             chandef->width != NL80211_CHAN_WIDTH_20)
1978                 ht_oper->ht_param |= IEEE80211_HT_PARAM_CHAN_WIDTH_ANY;
1979
1980         ht_oper->operation_mode = cpu_to_le16(prot_mode);
1981         ht_oper->stbc_param = 0x0000;
1982
1983         /* It seems that Basic MCS set and Supported MCS set
1984            are identical for the first 10 bytes */
1985         memset(&ht_oper->basic_set, 0, 16);
1986         memcpy(&ht_oper->basic_set, &ht_cap->mcs, 10);
1987
1988         return pos + sizeof(struct ieee80211_ht_operation);
1989 }
1990
1991 void ieee80211_ht_oper_to_chandef(struct ieee80211_channel *control_chan,
1992                                   const struct ieee80211_ht_operation *ht_oper,
1993                                   struct cfg80211_chan_def *chandef)
1994 {
1995         enum nl80211_channel_type channel_type;
1996
1997         if (!ht_oper) {
1998                 cfg80211_chandef_create(chandef, control_chan,
1999                                         NL80211_CHAN_NO_HT);
2000                 return;
2001         }
2002
2003         switch (ht_oper->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
2004         case IEEE80211_HT_PARAM_CHA_SEC_NONE:
2005                 channel_type = NL80211_CHAN_HT20;
2006                 break;
2007         case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
2008                 channel_type = NL80211_CHAN_HT40PLUS;
2009                 break;
2010         case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
2011                 channel_type = NL80211_CHAN_HT40MINUS;
2012                 break;
2013         default:
2014                 channel_type = NL80211_CHAN_NO_HT;
2015         }
2016
2017         cfg80211_chandef_create(chandef, control_chan, channel_type);
2018 }
2019
2020 int ieee80211_add_srates_ie(struct ieee80211_sub_if_data *sdata,
2021                             struct sk_buff *skb, bool need_basic,
2022                             enum ieee80211_band band)
2023 {
2024         struct ieee80211_local *local = sdata->local;
2025         struct ieee80211_supported_band *sband;
2026         int rate;
2027         u8 i, rates, *pos;
2028         u32 basic_rates = sdata->vif.bss_conf.basic_rates;
2029
2030         sband = local->hw.wiphy->bands[band];
2031         rates = sband->n_bitrates;
2032         if (rates > 8)
2033                 rates = 8;
2034
2035         if (skb_tailroom(skb) < rates + 2)
2036                 return -ENOMEM;
2037
2038         pos = skb_put(skb, rates + 2);
2039         *pos++ = WLAN_EID_SUPP_RATES;
2040         *pos++ = rates;
2041         for (i = 0; i < rates; i++) {
2042                 u8 basic = 0;
2043                 if (need_basic && basic_rates & BIT(i))
2044                         basic = 0x80;
2045                 rate = sband->bitrates[i].bitrate;
2046                 *pos++ = basic | (u8) (rate / 5);
2047         }
2048
2049         return 0;
2050 }
2051
2052 int ieee80211_add_ext_srates_ie(struct ieee80211_sub_if_data *sdata,
2053                                 struct sk_buff *skb, bool need_basic,
2054                                 enum ieee80211_band band)
2055 {
2056         struct ieee80211_local *local = sdata->local;
2057         struct ieee80211_supported_band *sband;
2058         int rate;
2059         u8 i, exrates, *pos;
2060         u32 basic_rates = sdata->vif.bss_conf.basic_rates;
2061
2062         sband = local->hw.wiphy->bands[band];
2063         exrates = sband->n_bitrates;
2064         if (exrates > 8)
2065                 exrates -= 8;
2066         else
2067                 exrates = 0;
2068
2069         if (skb_tailroom(skb) < exrates + 2)
2070                 return -ENOMEM;
2071
2072         if (exrates) {
2073                 pos = skb_put(skb, exrates + 2);
2074                 *pos++ = WLAN_EID_EXT_SUPP_RATES;
2075                 *pos++ = exrates;
2076                 for (i = 8; i < sband->n_bitrates; i++) {
2077                         u8 basic = 0;
2078                         if (need_basic && basic_rates & BIT(i))
2079                                 basic = 0x80;
2080                         rate = sband->bitrates[i].bitrate;
2081                         *pos++ = basic | (u8) (rate / 5);
2082                 }
2083         }
2084         return 0;
2085 }
2086
2087 int ieee80211_ave_rssi(struct ieee80211_vif *vif)
2088 {
2089         struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
2090         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2091
2092         if (WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION)) {
2093                 /* non-managed type inferfaces */
2094                 return 0;
2095         }
2096         return ifmgd->ave_beacon_signal / 16;
2097 }
2098 EXPORT_SYMBOL_GPL(ieee80211_ave_rssi);
2099
2100 u8 ieee80211_mcs_to_chains(const struct ieee80211_mcs_info *mcs)
2101 {
2102         if (!mcs)
2103                 return 1;
2104
2105         /* TODO: consider rx_highest */
2106
2107         if (mcs->rx_mask[3])
2108                 return 4;
2109         if (mcs->rx_mask[2])
2110                 return 3;
2111         if (mcs->rx_mask[1])
2112                 return 2;
2113         return 1;
2114 }
2115
2116 /**
2117  * ieee80211_calculate_rx_timestamp - calculate timestamp in frame
2118  * @local: mac80211 hw info struct
2119  * @status: RX status
2120  * @mpdu_len: total MPDU length (including FCS)
2121  * @mpdu_offset: offset into MPDU to calculate timestamp at
2122  *
2123  * This function calculates the RX timestamp at the given MPDU offset, taking
2124  * into account what the RX timestamp was. An offset of 0 will just normalize
2125  * the timestamp to TSF at beginning of MPDU reception.
2126  */
2127 u64 ieee80211_calculate_rx_timestamp(struct ieee80211_local *local,
2128                                      struct ieee80211_rx_status *status,
2129                                      unsigned int mpdu_len,
2130                                      unsigned int mpdu_offset)
2131 {
2132         u64 ts = status->mactime;
2133         struct rate_info ri;
2134         u16 rate;
2135
2136         if (WARN_ON(!ieee80211_have_rx_timestamp(status)))
2137                 return 0;
2138
2139         memset(&ri, 0, sizeof(ri));
2140
2141         /* Fill cfg80211 rate info */
2142         if (status->flag & RX_FLAG_HT) {
2143                 ri.mcs = status->rate_idx;
2144                 ri.flags |= RATE_INFO_FLAGS_MCS;
2145                 if (status->flag & RX_FLAG_40MHZ)
2146                         ri.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
2147                 if (status->flag & RX_FLAG_SHORT_GI)
2148                         ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
2149         } else if (status->flag & RX_FLAG_VHT) {
2150                 ri.flags |= RATE_INFO_FLAGS_VHT_MCS;
2151                 ri.mcs = status->rate_idx;
2152                 ri.nss = status->vht_nss;
2153                 if (status->flag & RX_FLAG_40MHZ)
2154                         ri.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
2155                 if (status->flag & RX_FLAG_80MHZ)
2156                         ri.flags |= RATE_INFO_FLAGS_80_MHZ_WIDTH;
2157                 if (status->flag & RX_FLAG_80P80MHZ)
2158                         ri.flags |= RATE_INFO_FLAGS_80P80_MHZ_WIDTH;
2159                 if (status->flag & RX_FLAG_160MHZ)
2160                         ri.flags |= RATE_INFO_FLAGS_160_MHZ_WIDTH;
2161                 if (status->flag & RX_FLAG_SHORT_GI)
2162                         ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
2163         } else {
2164                 struct ieee80211_supported_band *sband;
2165
2166                 sband = local->hw.wiphy->bands[status->band];
2167                 ri.legacy = sband->bitrates[status->rate_idx].bitrate;
2168         }
2169
2170         rate = cfg80211_calculate_bitrate(&ri);
2171
2172         /* rewind from end of MPDU */
2173         if (status->flag & RX_FLAG_MACTIME_END)
2174                 ts -= mpdu_len * 8 * 10 / rate;
2175
2176         ts += mpdu_offset * 8 * 10 / rate;
2177
2178         return ts;
2179 }
2180
2181 void ieee80211_dfs_cac_cancel(struct ieee80211_local *local)
2182 {
2183         struct ieee80211_sub_if_data *sdata;
2184
2185         mutex_lock(&local->iflist_mtx);
2186         list_for_each_entry(sdata, &local->interfaces, list) {
2187                 cancel_delayed_work_sync(&sdata->dfs_cac_timer_work);
2188
2189                 if (sdata->wdev.cac_started) {
2190                         ieee80211_vif_release_channel(sdata);
2191                         cfg80211_cac_event(sdata->dev,
2192                                            NL80211_RADAR_CAC_ABORTED,
2193                                            GFP_KERNEL);
2194                 }
2195         }
2196         mutex_unlock(&local->iflist_mtx);
2197 }
2198
2199 void ieee80211_dfs_radar_detected_work(struct work_struct *work)
2200 {
2201         struct ieee80211_local *local =
2202                 container_of(work, struct ieee80211_local, radar_detected_work);
2203         struct cfg80211_chan_def chandef;
2204
2205         ieee80211_dfs_cac_cancel(local);
2206
2207         if (local->use_chanctx)
2208                 /* currently not handled */
2209                 WARN_ON(1);
2210         else {
2211                 chandef = local->hw.conf.chandef;
2212                 cfg80211_radar_event(local->hw.wiphy, &chandef, GFP_KERNEL);
2213         }
2214 }
2215
2216 void ieee80211_radar_detected(struct ieee80211_hw *hw)
2217 {
2218         struct ieee80211_local *local = hw_to_local(hw);
2219
2220         trace_api_radar_detected(local);
2221
2222         ieee80211_queue_work(hw, &local->radar_detected_work);
2223 }
2224 EXPORT_SYMBOL(ieee80211_radar_detected);