net/mac80211/work.c

   1 /*
   2  * mac80211 work implementation
   3  *
   4  * Copyright 2003-2008, Jouni Malinen <j@w1.fi>
   5  * Copyright 2004, Instant802 Networks, Inc.
   6  * Copyright 2005, Devicescape Software, Inc.
   7  * Copyright 2006-2007  Jiri Benc <jbenc@suse.cz>
   8  * Copyright 2007, Michael Wu <flamingice@sourmilk.net>
   9  * Copyright 2009, Johannes Berg <johannes@sipsolutions.net>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License version 2 as
  13  * published by the Free Software Foundation.
  14  */
  15
  16 #include <linux/delay.h>
  17 #include <linux/if_ether.h>
  18 #include <linux/skbuff.h>
  19 #include <linux/if_arp.h>
  20 #include <linux/etherdevice.h>
  21 #include <linux/crc32.h>
  22 #include <linux/slab.h>
  23 #include <net/mac80211.h>
  24 #include <asm/unaligned.h>
  25
  26 #include "ieee80211_i.h"
  27 #include "rate.h"
  28 #include "driver-ops.h"
  29
  30 #define IEEE80211_AUTH_TIMEOUT (HZ / 5)
  31 #define IEEE80211_AUTH_MAX_TRIES 3
  32 #define IEEE80211_ASSOC_TIMEOUT (HZ / 5)
  33 #define IEEE80211_ASSOC_MAX_TRIES 3
  34
  35 enum work_action {
  36         WORK_ACT_MISMATCH,
  37         WORK_ACT_NONE,
  38         WORK_ACT_TIMEOUT,
  39         WORK_ACT_DONE,
  40 };
  41
  42
  43 /* utils */
  44 static inline void ASSERT_WORK_MTX(struct ieee80211_local *local)
  45 {
  46         lockdep_assert_held(&local->mtx);
  47 }
  48
  49 /*
  50  * We can have multiple work items (and connection probing)
  51  * scheduling this timer, but we need to take care to only
  52  * reschedule it when it should fire _earlier_ than it was
  53  * asked for before, or if it's not pending right now. This
  54  * function ensures that. Note that it then is required to
  55  * run this function for all timeouts after the first one
  56  * has happened -- the work that runs from this timer will
  57  * do that.
  58  */
  59 static void run_again(struct ieee80211_local *local,
  60                       unsigned long timeout)
  61 {
  62         ASSERT_WORK_MTX(local);
  63
  64         if (!timer_pending(&local->work_timer) ||
  65             time_before(timeout, local->work_timer.expires))
  66                 mod_timer(&local->work_timer, timeout);
  67 }
  68
  69 void free_work(struct ieee80211_work *wk)
  70 {
  71         kfree_rcu(wk, rcu_head);
  72 }
  73
  74 static int ieee80211_compatible_rates(const u8 *supp_rates, int supp_rates_len,
  75                                       struct ieee80211_supported_band *sband,
  76                                       u32 *rates)
  77 {
  78         int i, j, count;
  79         *rates = 0;
  80         count = 0;
  81         for (i = 0; i < supp_rates_len; i++) {
  82                 int rate = (supp_rates[i] & 0x7F) * 5;
  83
  84                 for (j = 0; j < sband->n_bitrates; j++)
  85                         if (sband->bitrates[j].bitrate == rate) {
  86                                 *rates |= BIT(j);
  87                                 count++;
  88                                 break;
  89                         }
  90         }
  91
  92         return count;
  93 }
  94
  95 /* frame sending functions */
  96
  97 static void ieee80211_add_ht_ie(struct ieee80211_sub_if_data *sdata,
  98                                 struct sk_buff *skb, const u8 *ht_info_ie,
  99                                 struct ieee80211_supported_band *sband,
 100                                 struct ieee80211_channel *channel,
 101                                 enum ieee80211_smps_mode smps)
 102 {
 103         struct ieee80211_ht_info *ht_info;
 104         u8 *pos;
 105         u32 flags = channel->flags;
 106         u16 cap;
 107         struct ieee80211_sta_ht_cap ht_cap;
 108
 109         BUILD_BUG_ON(sizeof(ht_cap) != sizeof(sband->ht_cap));
 110
 111         if (!sband->ht_cap.ht_supported)
 112                 return;
 113
 114         if (!ht_info_ie)
 115                 return;
 116
 117         if (ht_info_ie[1] < sizeof(struct ieee80211_ht_info))
 118                 return;
 119
 120         memcpy(&ht_cap, &sband->ht_cap, sizeof(ht_cap));
 121         ieee80211_apply_htcap_overrides(sdata, &ht_cap);
 122
 123         ht_info = (struct ieee80211_ht_info *)(ht_info_ie + 2);
 124
 125         /* determine capability flags */
 126         cap = ht_cap.cap;
 127
 128         switch (ht_info->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
 129         case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
 130                 if (flags & IEEE80211_CHAN_NO_HT40PLUS) {
 131                         cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
 132                         cap &= ~IEEE80211_HT_CAP_SGI_40;
 133                 }
 134                 break;
 135         case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
 136                 if (flags & IEEE80211_CHAN_NO_HT40MINUS) {
 137                         cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
 138                         cap &= ~IEEE80211_HT_CAP_SGI_40;
 139                 }
 140                 break;
 141         }
 142
 143         /* set SM PS mode properly */
 144         cap &= ~IEEE80211_HT_CAP_SM_PS;
 145         switch (smps) {
 146         case IEEE80211_SMPS_AUTOMATIC:
 147         case IEEE80211_SMPS_NUM_MODES:
 148                 WARN_ON(1);
 149         case IEEE80211_SMPS_OFF:
 150                 cap |= WLAN_HT_CAP_SM_PS_DISABLED <<
 151                         IEEE80211_HT_CAP_SM_PS_SHIFT;
 152                 break;
 153         case IEEE80211_SMPS_STATIC:
 154                 cap |= WLAN_HT_CAP_SM_PS_STATIC <<
 155                         IEEE80211_HT_CAP_SM_PS_SHIFT;
 156                 break;
 157         case IEEE80211_SMPS_DYNAMIC:
 158                 cap |= WLAN_HT_CAP_SM_PS_DYNAMIC <<
 159                         IEEE80211_HT_CAP_SM_PS_SHIFT;
 160                 break;
 161         }
 162
 163         /* reserve and fill IE */
 164         pos = skb_put(skb, sizeof(struct ieee80211_ht_cap) + 2);
 165         ieee80211_ie_build_ht_cap(pos, &ht_cap, cap);
 166 }
 167
 168 static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,
 169                                  struct ieee80211_work *wk)
 170 {
 171         struct ieee80211_local *local = sdata->local;
 172         struct sk_buff *skb;
 173         struct ieee80211_mgmt *mgmt;
 174         u8 *pos, qos_info;
 175         size_t offset = 0, noffset;
 176         int i, count, rates_len, supp_rates_len;
 177         u16 capab;
 178         struct ieee80211_supported_band *sband;
 179         u32 rates = 0;
 180
 181         sband = local->hw.wiphy->bands[wk->chan->band];
 182
 183         if (wk->assoc.supp_rates_len) {
 184                 /*
 185                  * Get all rates supported by the device and the AP as
 186                  * some APs don't like getting a superset of their rates
 187                  * in the association request (e.g. D-Link DAP 1353 in
 188                  * b-only mode)...
 189                  */
 190                 rates_len = ieee80211_compatible_rates(wk->assoc.supp_rates,
 191                                                        wk->assoc.supp_rates_len,
 192                                                        sband, &rates);
 193         } else {
 194                 /*
 195                  * In case AP not provide any supported rates information
 196                  * before association, we send information element(s) with
 197                  * all rates that we support.
 198                  */
 199                 rates = ~0;
 200                 rates_len = sband->n_bitrates;
 201         }
 202
 203         skb = alloc_skb(local->hw.extra_tx_headroom +
 204                         sizeof(*mgmt) + /* bit too much but doesn't matter */
 205                         2 + wk->assoc.ssid_len + /* SSID */
 206                         4 + rates_len + /* (extended) rates */
 207                         4 + /* power capability */
 208                         2 + 2 * sband->n_channels + /* supported channels */
 209                         2 + sizeof(struct ieee80211_ht_cap) + /* HT */
 210                         wk->ie_len + /* extra IEs */
 211                         9, /* WMM */
 212                         GFP_KERNEL);
 213         if (!skb)
 214                 return;
 215
 216         skb_reserve(skb, local->hw.extra_tx_headroom);
 217
 218         capab = WLAN_CAPABILITY_ESS;
 219
 220         if (sband->band == IEEE80211_BAND_2GHZ) {
 221                 if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE))
 222                         capab |= WLAN_CAPABILITY_SHORT_SLOT_TIME;
 223                 if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE))
 224                         capab |= WLAN_CAPABILITY_SHORT_PREAMBLE;
 225         }
 226
 227         if (wk->assoc.capability & WLAN_CAPABILITY_PRIVACY)
 228                 capab |= WLAN_CAPABILITY_PRIVACY;
 229
 230         if ((wk->assoc.capability & WLAN_CAPABILITY_SPECTRUM_MGMT) &&
 231             (local->hw.flags & IEEE80211_HW_SPECTRUM_MGMT))
 232                 capab |= WLAN_CAPABILITY_SPECTRUM_MGMT;
 233
 234         mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
 235         memset(mgmt, 0, 24);
 236         memcpy(mgmt->da, wk->filter_ta, ETH_ALEN);
 237         memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
 238         memcpy(mgmt->bssid, wk->filter_ta, ETH_ALEN);
 239
 240         if (!is_zero_ether_addr(wk->assoc.prev_bssid)) {
 241                 skb_put(skb, 10);
 242                 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
 243                                                   IEEE80211_STYPE_REASSOC_REQ);
 244                 mgmt->u.reassoc_req.capab_info = cpu_to_le16(capab);
 245                 mgmt->u.reassoc_req.listen_interval =
 246                                 cpu_to_le16(local->hw.conf.listen_interval);
 247                 memcpy(mgmt->u.reassoc_req.current_ap, wk->assoc.prev_bssid,
 248                        ETH_ALEN);
 249         } else {
 250                 skb_put(skb, 4);
 251                 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
 252                                                   IEEE80211_STYPE_ASSOC_REQ);
 253                 mgmt->u.assoc_req.capab_info = cpu_to_le16(capab);
 254                 mgmt->u.assoc_req.listen_interval =
 255                                 cpu_to_le16(local->hw.conf.listen_interval);
 256         }
 257
 258         /* SSID */
 259         pos = skb_put(skb, 2 + wk->assoc.ssid_len);
 260         *pos++ = WLAN_EID_SSID;
 261         *pos++ = wk->assoc.ssid_len;
 262         memcpy(pos, wk->assoc.ssid, wk->assoc.ssid_len);
 263
 264         /* add all rates which were marked to be used above */
 265         supp_rates_len = rates_len;
 266         if (supp_rates_len > 8)
 267                 supp_rates_len = 8;
 268
 269         pos = skb_put(skb, supp_rates_len + 2);
 270         *pos++ = WLAN_EID_SUPP_RATES;
 271         *pos++ = supp_rates_len;
 272
 273         count = 0;
 274         for (i = 0; i < sband->n_bitrates; i++) {
 275                 if (BIT(i) & rates) {
 276                         int rate = sband->bitrates[i].bitrate;
 277                         *pos++ = (u8) (rate / 5);
 278                         if (++count == 8)
 279                                 break;
 280                 }
 281         }
 282
 283         if (rates_len > count) {
 284                 pos = skb_put(skb, rates_len - count + 2);
 285                 *pos++ = WLAN_EID_EXT_SUPP_RATES;
 286                 *pos++ = rates_len - count;
 287
 288                 for (i++; i < sband->n_bitrates; i++) {
 289                         if (BIT(i) & rates) {
 290                                 int rate = sband->bitrates[i].bitrate;
 291                                 *pos++ = (u8) (rate / 5);
 292                         }
 293                 }
 294         }
 295
 296         if (capab & WLAN_CAPABILITY_SPECTRUM_MGMT) {
 297                 /* 1. power capabilities */
 298                 pos = skb_put(skb, 4);
 299                 *pos++ = WLAN_EID_PWR_CAPABILITY;
 300                 *pos++ = 2;
 301                 *pos++ = 0; /* min tx power */
 302                 *pos++ = wk->chan->max_power; /* max tx power */
 303
 304                 /* 2. supported channels */
 305                 /* TODO: get this in reg domain format */
 306                 pos = skb_put(skb, 2 * sband->n_channels + 2);
 307                 *pos++ = WLAN_EID_SUPPORTED_CHANNELS;
 308                 *pos++ = 2 * sband->n_channels;
 309                 for (i = 0; i < sband->n_channels; i++) {
 310                         *pos++ = ieee80211_frequency_to_channel(
 311                                         sband->channels[i].center_freq);
 312                         *pos++ = 1; /* one channel in the subband*/
 313                 }
 314         }
 315
 316         /* if present, add any custom IEs that go before HT */
 317         if (wk->ie_len && wk->ie) {
 318                 static const u8 before_ht[] = {
 319                         WLAN_EID_SSID,
 320                         WLAN_EID_SUPP_RATES,
 321                         WLAN_EID_EXT_SUPP_RATES,
 322                         WLAN_EID_PWR_CAPABILITY,
 323                         WLAN_EID_SUPPORTED_CHANNELS,
 324                         WLAN_EID_RSN,
 325                         WLAN_EID_QOS_CAPA,
 326                         WLAN_EID_RRM_ENABLED_CAPABILITIES,
 327                         WLAN_EID_MOBILITY_DOMAIN,
 328                         WLAN_EID_SUPPORTED_REGULATORY_CLASSES,
 329                 };
 330                 noffset = ieee80211_ie_split(wk->ie, wk->ie_len,
 331                                              before_ht, ARRAY_SIZE(before_ht),
 332                                              offset);
 333                 pos = skb_put(skb, noffset - offset);
 334                 memcpy(pos, wk->ie + offset, noffset - offset);
 335                 offset = noffset;
 336         }
 337
 338         if (wk->assoc.use_11n && wk->assoc.wmm_used &&
 339             local->hw.queues >= 4)
 340                 ieee80211_add_ht_ie(sdata, skb, wk->assoc.ht_information_ie,
 341                                     sband, wk->chan, wk->assoc.smps);
 342
 343         /* if present, add any custom non-vendor IEs that go after HT */
 344         if (wk->ie_len && wk->ie) {
 345                 noffset = ieee80211_ie_split_vendor(wk->ie, wk->ie_len,
 346                                                     offset);
 347                 pos = skb_put(skb, noffset - offset);
 348                 memcpy(pos, wk->ie + offset, noffset - offset);
 349                 offset = noffset;
 350         }
 351
 352         if (wk->assoc.wmm_used && local->hw.queues >= 4) {
 353                 if (wk->assoc.uapsd_used) {
 354                         qos_info = local->uapsd_queues;
 355                         qos_info |= (local->uapsd_max_sp_len <<
 356                                      IEEE80211_WMM_IE_STA_QOSINFO_SP_SHIFT);
 357                 } else {
 358                         qos_info = 0;
 359                 }
 360
 361                 pos = skb_put(skb, 9);
 362                 *pos++ = WLAN_EID_VENDOR_SPECIFIC;
 363                 *pos++ = 7; /* len */
 364                 *pos++ = 0x00; /* Microsoft OUI 00:50:F2 */
 365                 *pos++ = 0x50;
 366                 *pos++ = 0xf2;
 367                 *pos++ = 2; /* WME */
 368                 *pos++ = 0; /* WME info */
 369                 *pos++ = 1; /* WME ver */
 370                 *pos++ = qos_info;
 371         }
 372
 373         /* add any remaining custom (i.e. vendor specific here) IEs */
 374         if (wk->ie_len && wk->ie) {
 375                 noffset = wk->ie_len;
 376                 pos = skb_put(skb, noffset - offset);
 377                 memcpy(pos, wk->ie + offset, noffset - offset);
 378         }
 379
 380         IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
 381         ieee80211_tx_skb(sdata, skb);
 382 }
 383
 384 static void ieee80211_remove_auth_bss(struct ieee80211_local *local,
 385                                       struct ieee80211_work *wk)
 386 {
 387         struct cfg80211_bss *cbss;
 388         u16 capa_val = WLAN_CAPABILITY_ESS;
 389
 390         if (wk->probe_auth.privacy)
 391                 capa_val |= WLAN_CAPABILITY_PRIVACY;
 392
 393         cbss = cfg80211_get_bss(local->hw.wiphy, wk->chan, wk->filter_ta,
 394                                 wk->probe_auth.ssid, wk->probe_auth.ssid_len,
 395                                 WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_PRIVACY,
 396                                 capa_val);
 397         if (!cbss)
 398                 return;
 399
 400         cfg80211_unlink_bss(local->hw.wiphy, cbss);
 401         cfg80211_put_bss(cbss);
 402 }
 403
 404 static enum work_action __must_check
 405 ieee80211_direct_probe(struct ieee80211_work *wk)
 406 {
 407         struct ieee80211_sub_if_data *sdata = wk->sdata;
 408         struct ieee80211_local *local = sdata->local;
 409
 410         if (!wk->probe_auth.synced) {
 411                 int ret = drv_tx_sync(local, sdata, wk->filter_ta,
 412                                       IEEE80211_TX_SYNC_AUTH);
 413                 if (ret)
 414                         return WORK_ACT_TIMEOUT;
 415         }
 416         wk->probe_auth.synced = true;
 417
 418         wk->probe_auth.tries++;
 419         if (wk->probe_auth.tries > IEEE80211_AUTH_MAX_TRIES) {
 420                 printk(KERN_DEBUG "%s: direct probe to %pM timed out\n",
 421                        sdata->name, wk->filter_ta);
 422
 423                 /*
 424                  * Most likely AP is not in the range so remove the
 425                  * bss struct for that AP.
 426                  */
 427                 ieee80211_remove_auth_bss(local, wk);
 428
 429                 return WORK_ACT_TIMEOUT;
 430         }
 431
 432         printk(KERN_DEBUG "%s: direct probe to %pM (try %d/%i)\n",
 433                sdata->name, wk->filter_ta, wk->probe_auth.tries,
 434                IEEE80211_AUTH_MAX_TRIES);
 435
 436         /*
 437          * Direct probe is sent to broadcast address as some APs
 438          * will not answer to direct packet in unassociated state.
 439          */
 440         ieee80211_send_probe_req(sdata, NULL, wk->probe_auth.ssid,
 441                                  wk->probe_auth.ssid_len, NULL, 0,
 442                                  (u32) -1, true, false);
 443
 444         wk->timeout = jiffies + IEEE80211_AUTH_TIMEOUT;
 445         run_again(local, wk->timeout);
 446
 447         return WORK_ACT_NONE;
 448 }
 449
 450
 451 static enum work_action __must_check
 452 ieee80211_authenticate(struct ieee80211_work *wk)
 453 {
 454         struct ieee80211_sub_if_data *sdata = wk->sdata;
 455         struct ieee80211_local *local = sdata->local;
 456
 457         if (!wk->probe_auth.synced) {
 458                 int ret = drv_tx_sync(local, sdata, wk->filter_ta,
 459                                       IEEE80211_TX_SYNC_AUTH);
 460                 if (ret)
 461                         return WORK_ACT_TIMEOUT;
 462         }
 463         wk->probe_auth.synced = true;
 464
 465         wk->probe_auth.tries++;
 466         if (wk->probe_auth.tries > IEEE80211_AUTH_MAX_TRIES) {
 467                 printk(KERN_DEBUG "%s: authentication with %pM"
 468                        " timed out\n", sdata->name, wk->filter_ta);
 469
 470                 /*
 471                  * Most likely AP is not in the range so remove the
 472                  * bss struct for that AP.
 473                  */
 474                 ieee80211_remove_auth_bss(local, wk);
 475
 476                 return WORK_ACT_TIMEOUT;
 477         }
 478
 479         printk(KERN_DEBUG "%s: authenticate with %pM (try %d)\n",
 480                sdata->name, wk->filter_ta, wk->probe_auth.tries);
 481
 482         ieee80211_send_auth(sdata, 1, wk->probe_auth.algorithm, wk->ie,
 483                             wk->ie_len, wk->filter_ta, NULL, 0, 0);
 484         wk->probe_auth.transaction = 2;
 485
 486         wk->timeout = jiffies + IEEE80211_AUTH_TIMEOUT;
 487         run_again(local, wk->timeout);
 488
 489         return WORK_ACT_NONE;
 490 }
 491
 492 static enum work_action __must_check
 493 ieee80211_associate(struct ieee80211_work *wk)
 494 {
 495         struct ieee80211_sub_if_data *sdata = wk->sdata;
 496         struct ieee80211_local *local = sdata->local;
 497
 498         if (!wk->assoc.synced) {
 499                 int ret = drv_tx_sync(local, sdata, wk->filter_ta,
 500                                       IEEE80211_TX_SYNC_ASSOC);
 501                 if (ret)
 502                         return WORK_ACT_TIMEOUT;
 503         }
 504         wk->assoc.synced = true;
 505
 506         wk->assoc.tries++;
 507         if (wk->assoc.tries > IEEE80211_ASSOC_MAX_TRIES) {
 508                 printk(KERN_DEBUG "%s: association with %pM"
 509                        " timed out\n",
 510                        sdata->name, wk->filter_ta);
 511
 512                 /*
 513                  * Most likely AP is not in the range so remove the
 514                  * bss struct for that AP.
 515                  */
 516                 if (wk->assoc.bss)
 517                         cfg80211_unlink_bss(local->hw.wiphy, wk->assoc.bss);
 518
 519                 return WORK_ACT_TIMEOUT;
 520         }
 521
 522         printk(KERN_DEBUG "%s: associate with %pM (try %d)\n",
 523                sdata->name, wk->filter_ta, wk->assoc.tries);
 524         ieee80211_send_assoc(sdata, wk);
 525
 526         wk->timeout = jiffies + IEEE80211_ASSOC_TIMEOUT;
 527         run_again(local, wk->timeout);
 528
 529         return WORK_ACT_NONE;
 530 }
 531
 532 static enum work_action __must_check
 533 ieee80211_remain_on_channel_timeout(struct ieee80211_work *wk)
 534 {
 535         /*
 536          * First time we run, do nothing -- the generic code will
 537          * have switched to the right channel etc.
 538          */
 539         if (!wk->started) {
 540                 wk->timeout = jiffies + msecs_to_jiffies(wk->remain.duration);
 541
 542                 cfg80211_ready_on_channel(wk->sdata->dev, (unsigned long) wk,
 543                                           wk->chan, wk->chan_type,
 544                                           wk->remain.duration, GFP_KERNEL);
 545
 546                 return WORK_ACT_NONE;
 547         }
 548
 549         return WORK_ACT_TIMEOUT;
 550 }
 551
 552 static enum work_action __must_check
 553 ieee80211_offchannel_tx(struct ieee80211_work *wk)
 554 {
 555         if (!wk->started) {
 556                 wk->timeout = jiffies + msecs_to_jiffies(wk->offchan_tx.wait);
 557
 558                 /*
 559                  * After this, offchan_tx.frame remains but now is no
 560                  * longer a valid pointer -- we still need it as the
 561                  * cookie for canceling this work/status matching.
 562                  */
 563                 ieee80211_tx_skb(wk->sdata, wk->offchan_tx.frame);
 564
 565                 return WORK_ACT_NONE;
 566         }
 567
 568         return WORK_ACT_TIMEOUT;
 569 }
 570
 571 static enum work_action __must_check
 572 ieee80211_assoc_beacon_wait(struct ieee80211_work *wk)
 573 {
 574         if (wk->started)
 575                 return WORK_ACT_TIMEOUT;
 576
 577         /*
 578          * Wait up to one beacon interval ...
 579          * should this be more if we miss one?
 580          */
 581         printk(KERN_DEBUG "%s: waiting for beacon from %pM\n",
 582                wk->sdata->name, wk->filter_ta);
 583         wk->timeout = TU_TO_EXP_TIME(wk->assoc.bss->beacon_interval);
 584         return WORK_ACT_NONE;
 585 }
 586
 587 static void ieee80211_auth_challenge(struct ieee80211_work *wk,
 588                                      struct ieee80211_mgmt *mgmt,
 589                                      size_t len)
 590 {
 591         struct ieee80211_sub_if_data *sdata = wk->sdata;
 592         u8 *pos;
 593         struct ieee802_11_elems elems;
 594
 595         pos = mgmt->u.auth.variable;
 596         ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
 597         if (!elems.challenge)
 598                 return;
 599         ieee80211_send_auth(sdata, 3, wk->probe_auth.algorithm,
 600                             elems.challenge - 2, elems.challenge_len + 2,
 601                             wk->filter_ta, wk->probe_auth.key,
 602                             wk->probe_auth.key_len, wk->probe_auth.key_idx);
 603         wk->probe_auth.transaction = 4;
 604 }
 605
 606 static enum work_action __must_check
 607 ieee80211_rx_mgmt_auth(struct ieee80211_work *wk,
 608                        struct ieee80211_mgmt *mgmt, size_t len)
 609 {
 610         u16 auth_alg, auth_transaction, status_code;
 611
 612         if (wk->type != IEEE80211_WORK_AUTH)
 613                 return WORK_ACT_MISMATCH;
 614
 615         if (len < 24 + 6)
 616                 return WORK_ACT_NONE;
 617
 618         auth_alg = le16_to_cpu(mgmt->u.auth.auth_alg);
 619         auth_transaction = le16_to_cpu(mgmt->u.auth.auth_transaction);
 620         status_code = le16_to_cpu(mgmt->u.auth.status_code);
 621
 622         if (auth_alg != wk->probe_auth.algorithm ||
 623             auth_transaction != wk->probe_auth.transaction)
 624                 return WORK_ACT_NONE;
 625
 626         if (status_code != WLAN_STATUS_SUCCESS) {
 627                 printk(KERN_DEBUG "%s: %pM denied authentication (status %d)\n",
 628                        wk->sdata->name, mgmt->sa, status_code);
 629                 return WORK_ACT_DONE;
 630         }
 631
 632         switch (wk->probe_auth.algorithm) {
 633         case WLAN_AUTH_OPEN:
 634         case WLAN_AUTH_LEAP:
 635         case WLAN_AUTH_FT:
 636                 break;
 637         case WLAN_AUTH_SHARED_KEY:
 638                 if (wk->probe_auth.transaction != 4) {
 639                         ieee80211_auth_challenge(wk, mgmt, len);
 640                         /* need another frame */
 641                         return WORK_ACT_NONE;
 642                 }
 643                 break;
 644         default:
 645                 WARN_ON(1);
 646                 return WORK_ACT_NONE;
 647         }
 648
 649         printk(KERN_DEBUG "%s: authenticated\n", wk->sdata->name);
 650         return WORK_ACT_DONE;
 651 }
 652
 653 static enum work_action __must_check
 654 ieee80211_rx_mgmt_assoc_resp(struct ieee80211_work *wk,
 655                              struct ieee80211_mgmt *mgmt, size_t len,
 656                              bool reassoc)
 657 {
 658         struct ieee80211_sub_if_data *sdata = wk->sdata;
 659         struct ieee80211_local *local = sdata->local;
 660         u16 capab_info, status_code, aid;
 661         struct ieee802_11_elems elems;
 662         u8 *pos;
 663
 664         if (wk->type != IEEE80211_WORK_ASSOC)
 665                 return WORK_ACT_MISMATCH;
 666
 667         /*
 668          * AssocResp and ReassocResp have identical structure, so process both
 669          * of them in this function.
 670          */
 671
 672         if (len < 24 + 6)
 673                 return WORK_ACT_NONE;
 674
 675         capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info);
 676         status_code = le16_to_cpu(mgmt->u.assoc_resp.status_code);
 677         aid = le16_to_cpu(mgmt->u.assoc_resp.aid);
 678
 679         printk(KERN_DEBUG "%s: RX %sssocResp from %pM (capab=0x%x "
 680                "status=%d aid=%d)\n",
 681                sdata->name, reassoc ? "Rea" : "A", mgmt->sa,
 682                capab_info, status_code, (u16)(aid & ~(BIT(15) | BIT(14))));
 683
 684         pos = mgmt->u.assoc_resp.variable;
 685         ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
 686
 687         if (status_code == WLAN_STATUS_ASSOC_REJECTED_TEMPORARILY &&
 688             elems.timeout_int && elems.timeout_int_len == 5 &&
 689             elems.timeout_int[0] == WLAN_TIMEOUT_ASSOC_COMEBACK) {
 690                 u32 tu, ms;
 691                 tu = get_unaligned_le32(elems.timeout_int + 1);
 692                 ms = tu * 1024 / 1000;
 693                 printk(KERN_DEBUG "%s: %pM rejected association temporarily; "
 694                        "comeback duration %u TU (%u ms)\n",
 695                        sdata->name, mgmt->sa, tu, ms);
 696                 wk->timeout = jiffies + msecs_to_jiffies(ms);
 697                 if (ms > IEEE80211_ASSOC_TIMEOUT)
 698                         run_again(local, wk->timeout);
 699                 return WORK_ACT_NONE;
 700         }
 701
 702         if (status_code != WLAN_STATUS_SUCCESS)
 703                 printk(KERN_DEBUG "%s: %pM denied association (code=%d)\n",
 704                        sdata->name, mgmt->sa, status_code);
 705         else
 706                 printk(KERN_DEBUG "%s: associated\n", sdata->name);
 707
 708         return WORK_ACT_DONE;
 709 }
 710
 711 static enum work_action __must_check
 712 ieee80211_rx_mgmt_probe_resp(struct ieee80211_work *wk,
 713                              struct ieee80211_mgmt *mgmt, size_t len,
 714                              struct ieee80211_rx_status *rx_status)
 715 {
 716         struct ieee80211_sub_if_data *sdata = wk->sdata;
 717         struct ieee80211_local *local = sdata->local;
 718         size_t baselen;
 719
 720         ASSERT_WORK_MTX(local);
 721
 722         if (wk->type != IEEE80211_WORK_DIRECT_PROBE)
 723                 return WORK_ACT_MISMATCH;
 724
 725         if (len < 24 + 12)
 726                 return WORK_ACT_NONE;
 727
 728         baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;
 729         if (baselen > len)
 730                 return WORK_ACT_NONE;
 731
 732         printk(KERN_DEBUG "%s: direct probe responded\n", sdata->name);
 733         return WORK_ACT_DONE;
 734 }
 735
 736 static enum work_action __must_check
 737 ieee80211_rx_mgmt_beacon(struct ieee80211_work *wk,
 738                          struct ieee80211_mgmt *mgmt, size_t len)
 739 {
 740         struct ieee80211_sub_if_data *sdata = wk->sdata;
 741         struct ieee80211_local *local = sdata->local;
 742
 743         ASSERT_WORK_MTX(local);
 744
 745         if (wk->type != IEEE80211_WORK_ASSOC_BEACON_WAIT)
 746                 return WORK_ACT_MISMATCH;
 747
 748         if (len < 24 + 12)
 749                 return WORK_ACT_NONE;
 750
 751         printk(KERN_DEBUG "%s: beacon received\n", sdata->name);
 752         return WORK_ACT_DONE;
 753 }
 754
 755 static void ieee80211_work_rx_queued_mgmt(struct ieee80211_local *local,
 756                                           struct sk_buff *skb)
 757 {
 758         struct ieee80211_rx_status *rx_status;
 759         struct ieee80211_mgmt *mgmt;
 760         struct ieee80211_work *wk;
 761         enum work_action rma = WORK_ACT_NONE;
 762         u16 fc;
 763
 764         rx_status = (struct ieee80211_rx_status *) skb->cb;
 765         mgmt = (struct ieee80211_mgmt *) skb->data;
 766         fc = le16_to_cpu(mgmt->frame_control);
 767
 768         mutex_lock(&local->mtx);
 769
 770         list_for_each_entry(wk, &local->work_list, list) {
 771                 const u8 *bssid = NULL;
 772
 773                 switch (wk->type) {
 774                 case IEEE80211_WORK_DIRECT_PROBE:
 775                 case IEEE80211_WORK_AUTH:
 776                 case IEEE80211_WORK_ASSOC:
 777                 case IEEE80211_WORK_ASSOC_BEACON_WAIT:
 778                         bssid = wk->filter_ta;
 779                         break;
 780                 default:
 781                         continue;
 782                 }
 783
 784                 /*
 785                  * Before queuing, we already verified mgmt->sa,
 786                  * so this is needed just for matching.
 787                  */
 788                 if (compare_ether_addr(bssid, mgmt->bssid))
 789                         continue;
 790
 791                 switch (fc & IEEE80211_FCTL_STYPE) {
 792                 case IEEE80211_STYPE_BEACON:
 793                         rma = ieee80211_rx_mgmt_beacon(wk, mgmt, skb->len);
 794                         break;
 795                 case IEEE80211_STYPE_PROBE_RESP:
 796                         rma = ieee80211_rx_mgmt_probe_resp(wk, mgmt, skb->len,
 797                                                            rx_status);
 798                         break;
 799                 case IEEE80211_STYPE_AUTH:
 800                         rma = ieee80211_rx_mgmt_auth(wk, mgmt, skb->len);
 801                         break;
 802                 case IEEE80211_STYPE_ASSOC_RESP:
 803                         rma = ieee80211_rx_mgmt_assoc_resp(wk, mgmt,
 804                                                            skb->len, false);
 805                         break;
 806                 case IEEE80211_STYPE_REASSOC_RESP:
 807                         rma = ieee80211_rx_mgmt_assoc_resp(wk, mgmt,
 808                                                            skb->len, true);
 809                         break;
 810                 default:
 811                         WARN_ON(1);
 812                         rma = WORK_ACT_NONE;
 813                 }
 814
 815                 /*
 816                  * We've either received an unexpected frame, or we have
 817                  * multiple work items and need to match the frame to the
 818                  * right one.
 819                  */
 820                 if (rma == WORK_ACT_MISMATCH)
 821                         continue;
 822
 823                 /*
 824                  * We've processed this frame for that work, so it can't
 825                  * belong to another work struct.
 826                  * NB: this is also required for correctness for 'rma'!
 827                  */
 828                 break;
 829         }
 830
 831         switch (rma) {
 832         case WORK_ACT_MISMATCH:
 833                 /* ignore this unmatched frame */
 834                 break;
 835         case WORK_ACT_NONE:
 836                 break;
 837         case WORK_ACT_DONE:
 838                 list_del_rcu(&wk->list);
 839                 break;
 840         default:
 841                 WARN(1, "unexpected: %d", rma);
 842         }
 843
 844         mutex_unlock(&local->mtx);
 845
 846         if (rma != WORK_ACT_DONE)
 847                 goto out;
 848
 849         switch (wk->done(wk, skb)) {
 850         case WORK_DONE_DESTROY:
 851                 free_work(wk);
 852                 break;
 853         case WORK_DONE_REQUEUE:
 854                 synchronize_rcu();
 855                 wk->started = false; /* restart */
 856                 mutex_lock(&local->mtx);
 857                 list_add_tail(&wk->list, &local->work_list);
 858                 mutex_unlock(&local->mtx);
 859         }
 860
 861  out:
 862         kfree_skb(skb);
 863 }
 864
 865 static bool ieee80211_work_ct_coexists(enum nl80211_channel_type wk_ct,
 866                                        enum nl80211_channel_type oper_ct)
 867 {
 868         switch (wk_ct) {
 869         case NL80211_CHAN_NO_HT:
 870                 return true;
 871         case NL80211_CHAN_HT20:
 872                 if (oper_ct != NL80211_CHAN_NO_HT)
 873                         return true;
 874                 return false;
 875         case NL80211_CHAN_HT40MINUS:
 876         case NL80211_CHAN_HT40PLUS:
 877                 return (wk_ct == oper_ct);
 878         }
 879         WARN_ON(1); /* shouldn't get here */
 880         return false;
 881 }
 882
 883 static enum nl80211_channel_type
 884 ieee80211_calc_ct(enum nl80211_channel_type wk_ct,
 885                   enum nl80211_channel_type oper_ct)
 886 {
 887         switch (wk_ct) {
 888         case NL80211_CHAN_NO_HT:
 889                 return oper_ct;
 890         case NL80211_CHAN_HT20:
 891                 if (oper_ct != NL80211_CHAN_NO_HT)
 892                         return oper_ct;
 893                 return wk_ct;
 894         case NL80211_CHAN_HT40MINUS:
 895         case NL80211_CHAN_HT40PLUS:
 896                 return wk_ct;
 897         }
 898         WARN_ON(1); /* shouldn't get here */
 899         return wk_ct;
 900 }
 901
 902
 903 static void ieee80211_work_timer(unsigned long data)
 904 {
 905         struct ieee80211_local *local = (void *) data;
 906
 907         if (local->quiescing)
 908                 return;
 909
 910         ieee80211_queue_work(&local->hw, &local->work_work);
 911 }
 912
 913 static void ieee80211_work_work(struct work_struct *work)
 914 {
 915         struct ieee80211_local *local =
 916                 container_of(work, struct ieee80211_local, work_work);
 917         struct sk_buff *skb;
 918         struct ieee80211_work *wk, *tmp;
 919         LIST_HEAD(free_work);
 920         enum work_action rma;
 921         bool remain_off_channel = false;
 922
 923         if (local->scanning)
 924                 return;
 925
 926         /*
 927          * ieee80211_queue_work() should have picked up most cases,
 928          * here we'll pick the rest.
 929          */
 930         if (WARN(local->suspended, "work scheduled while going to suspend\n"))
 931                 return;
 932
 933         /* first process frames to avoid timing out while a frame is pending */
 934         while ((skb = skb_dequeue(&local->work_skb_queue)))
 935                 ieee80211_work_rx_queued_mgmt(local, skb);
 936
 937         mutex_lock(&local->mtx);
 938
 939         ieee80211_recalc_idle(local);
 940
 941         list_for_each_entry_safe(wk, tmp, &local->work_list, list) {
 942                 bool started = wk->started;
 943
 944                 /* mark work as started if it's on the current off-channel */
 945                 if (!started && local->tmp_channel &&
 946                     wk->chan == local->tmp_channel &&
 947                     wk->chan_type == local->tmp_channel_type) {
 948                         started = true;
 949                         wk->timeout = jiffies;
 950                 }
 951
 952                 if (!started && !local->tmp_channel) {
 953                         bool on_oper_chan, on_oper_chan2;
 954                         enum nl80211_channel_type wk_ct;
 955
 956                         on_oper_chan = ieee80211_cfg_on_oper_channel(local);
 957
 958                         /* Work with existing channel type if possible. */
 959                         wk_ct = wk->chan_type;
 960                         if (wk->chan == local->hw.conf.channel)
 961                                 wk_ct = ieee80211_calc_ct(wk->chan_type,
 962                                                 local->hw.conf.channel_type);
 963
 964                         local->tmp_channel = wk->chan;
 965                         local->tmp_channel_type = wk_ct;
 966                         /*
 967                          * Leave the station vifs in awake mode if they
 968                          * happen to be on the same channel as
 969                          * the requested channel.
 970                          */
 971                         on_oper_chan2 = ieee80211_cfg_on_oper_channel(local);
 972                         if (on_oper_chan != on_oper_chan2) {
 973                                 if (on_oper_chan2) {
 974                                         /* going off oper channel, PS too */
 975                                         ieee80211_offchannel_stop_vifs(local,
 976                                                                        true);
 977                                         ieee80211_hw_config(local, 0);
 978                                 } else {
 979                                         /* going on channel, but leave PS
 980                                          * off-channel. */
 981                                         ieee80211_hw_config(local, 0);
 982                                         ieee80211_offchannel_return(local,
 983                                                                     true,
 984                                                                     false);
 985                                 }
 986                         }
 987
 988                         started = true;
 989                         wk->timeout = jiffies;
 990                 }
 991
 992                 /* don't try to work with items that aren't started */
 993                 if (!started)
 994                         continue;
 995
 996                 if (time_is_after_jiffies(wk->timeout)) {
 997                         /*
 998                          * This work item isn't supposed to be worked on
 999                          * right now, but take care to adjust the timer
1000                          * properly.
1001                          */
1002                         run_again(local, wk->timeout);
1003                         continue;
1004                 }
1005
1006                 switch (wk->type) {
1007                 default:
1008                         WARN_ON(1);
1009                         /* nothing */
1010                         rma = WORK_ACT_NONE;
1011                         break;
1012                 case IEEE80211_WORK_ABORT:
1013                         rma = WORK_ACT_TIMEOUT;
1014                         break;
1015                 case IEEE80211_WORK_DIRECT_PROBE:
1016                         rma = ieee80211_direct_probe(wk);
1017                         break;
1018                 case IEEE80211_WORK_AUTH:
1019                         rma = ieee80211_authenticate(wk);
1020                         break;
1021                 case IEEE80211_WORK_ASSOC:
1022                         rma = ieee80211_associate(wk);
1023                         break;
1024                 case IEEE80211_WORK_REMAIN_ON_CHANNEL:
1025                         rma = ieee80211_remain_on_channel_timeout(wk);
1026                         break;
1027                 case IEEE80211_WORK_OFFCHANNEL_TX:
1028                         rma = ieee80211_offchannel_tx(wk);
1029                         break;
1030                 case IEEE80211_WORK_ASSOC_BEACON_WAIT:
1031                         rma = ieee80211_assoc_beacon_wait(wk);
1032                         break;
1033                 }
1034
1035                 wk->started = started;
1036
1037                 switch (rma) {
1038                 case WORK_ACT_NONE:
1039                         /* might have changed the timeout */
1040                         run_again(local, wk->timeout);
1041                         break;
1042                 case WORK_ACT_TIMEOUT:
1043                         list_del_rcu(&wk->list);
1044                         synchronize_rcu();
1045                         list_add(&wk->list, &free_work);
1046                         break;
1047                 default:
1048                         WARN(1, "unexpected: %d", rma);
1049                 }
1050         }
1051
1052         list_for_each_entry(wk, &local->work_list, list) {
1053                 if (!wk->started)
1054                         continue;
1055                 if (wk->chan != local->tmp_channel)
1056                         continue;
1057                 if (!ieee80211_work_ct_coexists(wk->chan_type,
1058                                                 local->tmp_channel_type))
1059                         continue;
1060                 remain_off_channel = true;
1061         }
1062
1063         if (!remain_off_channel && local->tmp_channel) {
1064                 local->tmp_channel = NULL;
1065                 /* If tmp_channel wasn't operating channel, then
1066                  * we need to go back on-channel.
1067                  * NOTE:  If we can ever be here while scannning,
1068                  * or if the hw_config() channel config logic changes,
1069                  * then we may need to do a more thorough check to see if
1070                  * we still need to do a hardware config.  Currently,
1071                  * we cannot be here while scanning, however.
1072                  */
1073                 if (!ieee80211_cfg_on_oper_channel(local))
1074                         ieee80211_hw_config(local, 0);
1075
1076                 /* At the least, we need to disable offchannel_ps,
1077                  * so just go ahead and run the entire offchannel
1078                  * return logic here.  We *could* skip enabling
1079                  * beaconing if we were already on-oper-channel
1080                  * as a future optimization.
1081                  */
1082                 ieee80211_offchannel_return(local, true, true);
1083
1084                 /* give connection some time to breathe */
1085                 run_again(local, jiffies + HZ/2);
1086         }
1087
1088         if (list_empty(&local->work_list) && local->scan_req &&
1089             !local->scanning)
1090                 ieee80211_queue_delayed_work(&local->hw,
1091                                              &local->scan_work,
1092                                              round_jiffies_relative(0));
1093
1094         ieee80211_recalc_idle(local);
1095
1096         mutex_unlock(&local->mtx);
1097
1098         list_for_each_entry_safe(wk, tmp, &free_work, list) {
1099                 wk->done(wk, NULL);
1100                 list_del(&wk->list);
1101                 kfree(wk);
1102         }
1103 }
1104
1105 void ieee80211_add_work(struct ieee80211_work *wk)
1106 {
1107         struct ieee80211_local *local;
1108
1109         if (WARN_ON(!wk->chan))
1110                 return;
1111
1112         if (WARN_ON(!wk->sdata))
1113                 return;
1114
1115         if (WARN_ON(!wk->done))
1116                 return;
1117
1118         if (WARN_ON(!ieee80211_sdata_running(wk->sdata)))
1119                 return;
1120
1121         wk->started = false;
1122
1123         local = wk->sdata->local;
1124         mutex_lock(&local->mtx);
1125         list_add_tail(&wk->list, &local->work_list);
1126         mutex_unlock(&local->mtx);
1127
1128         ieee80211_queue_work(&local->hw, &local->work_work);
1129 }
1130
1131 void ieee80211_work_init(struct ieee80211_local *local)
1132 {
1133         INIT_LIST_HEAD(&local->work_list);
1134         setup_timer(&local->work_timer, ieee80211_work_timer,
1135                     (unsigned long)local);
1136         INIT_WORK(&local->work_work, ieee80211_work_work);
1137         skb_queue_head_init(&local->work_skb_queue);
1138 }
1139
1140 void ieee80211_work_purge(struct ieee80211_sub_if_data *sdata)
1141 {
1142         struct ieee80211_local *local = sdata->local;
1143         struct ieee80211_work *wk;
1144         bool cleanup = false;
1145
1146         mutex_lock(&local->mtx);
1147         list_for_each_entry(wk, &local->work_list, list) {
1148                 if (wk->sdata != sdata)
1149                         continue;
1150                 cleanup = true;
1151                 wk->type = IEEE80211_WORK_ABORT;
1152                 wk->started = true;
1153                 wk->timeout = jiffies;
1154         }
1155         mutex_unlock(&local->mtx);
1156
1157         /* run cleanups etc. */
1158         if (cleanup)
1159                 ieee80211_work_work(&local->work_work);
1160
1161         mutex_lock(&local->mtx);
1162         list_for_each_entry(wk, &local->work_list, list) {
1163                 if (wk->sdata != sdata)
1164                         continue;
1165                 WARN_ON(1);
1166                 break;
1167         }
1168         mutex_unlock(&local->mtx);
1169 }
1170
1171 ieee80211_rx_result ieee80211_work_rx_mgmt(struct ieee80211_sub_if_data *sdata,
1172                                            struct sk_buff *skb)
1173 {
1174         struct ieee80211_local *local = sdata->local;
1175         struct ieee80211_mgmt *mgmt;
1176         struct ieee80211_work *wk;
1177         u16 fc;
1178
1179         if (skb->len < 24)
1180                 return RX_DROP_MONITOR;
1181
1182         mgmt = (struct ieee80211_mgmt *) skb->data;
1183         fc = le16_to_cpu(mgmt->frame_control);
1184
1185         list_for_each_entry_rcu(wk, &local->work_list, list) {
1186                 if (sdata != wk->sdata)
1187                         continue;
1188                 if (compare_ether_addr(wk->filter_ta, mgmt->sa))
1189                         continue;
1190                 if (compare_ether_addr(wk->filter_ta, mgmt->bssid))
1191                         continue;
1192
1193                 switch (fc & IEEE80211_FCTL_STYPE) {
1194                 case IEEE80211_STYPE_AUTH:
1195                 case IEEE80211_STYPE_PROBE_RESP:
1196                 case IEEE80211_STYPE_ASSOC_RESP:
1197                 case IEEE80211_STYPE_REASSOC_RESP:
1198                 case IEEE80211_STYPE_BEACON:
1199                         skb_queue_tail(&local->work_skb_queue, skb);
1200                         ieee80211_queue_work(&local->hw, &local->work_work);
1201                         return RX_QUEUED;
1202                 }
1203         }
1204
1205         return RX_CONTINUE;
1206 }
1207
1208 static enum work_done_result ieee80211_remain_done(struct ieee80211_work *wk,
1209                                                    struct sk_buff *skb)
1210 {
1211         /*
1212          * We are done serving the remain-on-channel command.
1213          */
1214         cfg80211_remain_on_channel_expired(wk->sdata->dev, (unsigned long) wk,
1215                                            wk->chan, wk->chan_type,
1216                                            GFP_KERNEL);
1217
1218         return WORK_DONE_DESTROY;
1219 }
1220
1221 int ieee80211_wk_remain_on_channel(struct ieee80211_sub_if_data *sdata,
1222                                    struct ieee80211_channel *chan,
1223                                    enum nl80211_channel_type channel_type,
1224                                    unsigned int duration, u64 *cookie)
1225 {
1226         struct ieee80211_work *wk;
1227
1228         wk = kzalloc(sizeof(*wk), GFP_KERNEL);
1229         if (!wk)
1230                 return -ENOMEM;
1231
1232         wk->type = IEEE80211_WORK_REMAIN_ON_CHANNEL;
1233         wk->chan = chan;
1234         wk->chan_type = channel_type;
1235         wk->sdata = sdata;
1236         wk->done = ieee80211_remain_done;
1237
1238         wk->remain.duration = duration;
1239
1240         *cookie = (unsigned long) wk;
1241
1242         ieee80211_add_work(wk);
1243
1244         return 0;
1245 }
1246
1247 int ieee80211_wk_cancel_remain_on_channel(struct ieee80211_sub_if_data *sdata,
1248                                           u64 cookie)
1249 {
1250         struct ieee80211_local *local = sdata->local;
1251         struct ieee80211_work *wk, *tmp;
1252         bool found = false;
1253
1254         mutex_lock(&local->mtx);
1255         list_for_each_entry_safe(wk, tmp, &local->work_list, list) {
1256                 if ((unsigned long) wk == cookie) {
1257                         wk->timeout = jiffies;
1258                         found = true;
1259                         break;
1260                 }
1261         }
1262         mutex_unlock(&local->mtx);
1263
1264         if (!found)
1265                 return -ENOENT;
1266
1267         ieee80211_queue_work(&local->hw, &local->work_work);
1268
1269         return 0;
1270 }