Pileus Git - ~andy/linux/blob - drivers/net/wireless/iwlwifi/iwl-agn-sta.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
   4  *
   5  * Portions of this file are derived from the ipw3945 project, as well
   6  * as portions of the ieee80211 subsystem header files.
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of version 2 of the GNU General Public License as
  10  * published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15  * more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along with
  18  * this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  20  *
  21  * The full GNU General Public License is included in this distribution in the
  22  * file called LICENSE.
  23  *
  24  * Contact Information:
  25  *  Intel Linux Wireless <ilw@linux.intel.com>
  26  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  27  *
  28  *****************************************************************************/
  29
  30 #include <net/mac80211.h>
  31
  32 #include "iwl-dev.h"
  33 #include "iwl-core.h"
  34 #include "iwl-sta.h"
  35 #include "iwl-agn.h"
  36
  37 static struct iwl_link_quality_cmd *
  38 iwl_sta_alloc_lq(struct iwl_priv *priv, struct iwl_rxon_context *ctx, u8 sta_id)
  39 {
  40         int i, r;
  41         struct iwl_link_quality_cmd *link_cmd;
  42         u32 rate_flags = 0;
  43         __le32 rate_n_flags;
  44
  45         link_cmd = kzalloc(sizeof(struct iwl_link_quality_cmd), GFP_KERNEL);
  46         if (!link_cmd) {
  47                 IWL_ERR(priv, "Unable to allocate memory for LQ cmd.\n");
  48                 return NULL;
  49         }
  50
  51         lockdep_assert_held(&priv->mutex);
  52
  53         /* Set up the rate scaling to start at selected rate, fall back
  54          * all the way down to 1M in IEEE order, and then spin on 1M */
  55         if (priv->band == IEEE80211_BAND_5GHZ)
  56                 r = IWL_RATE_6M_INDEX;
  57         else if (ctx && ctx->vif && ctx->vif->p2p)
  58                 r = IWL_RATE_6M_INDEX;
  59         else
  60                 r = IWL_RATE_1M_INDEX;
  61
  62         if (r >= IWL_FIRST_CCK_RATE && r <= IWL_LAST_CCK_RATE)
  63                 rate_flags |= RATE_MCS_CCK_MSK;
  64
  65         rate_flags |= first_antenna(priv->hw_params.valid_tx_ant) <<
  66                                 RATE_MCS_ANT_POS;
  67         rate_n_flags = iwl_hw_set_rate_n_flags(iwl_rates[r].plcp, rate_flags);
  68         for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++)
  69                 link_cmd->rs_table[i].rate_n_flags = rate_n_flags;
  70
  71         link_cmd->general_params.single_stream_ant_msk =
  72                                 first_antenna(priv->hw_params.valid_tx_ant);
  73
  74         link_cmd->general_params.dual_stream_ant_msk =
  75                 priv->hw_params.valid_tx_ant &
  76                 ~first_antenna(priv->hw_params.valid_tx_ant);
  77         if (!link_cmd->general_params.dual_stream_ant_msk) {
  78                 link_cmd->general_params.dual_stream_ant_msk = ANT_AB;
  79         } else if (num_of_ant(priv->hw_params.valid_tx_ant) == 2) {
  80                 link_cmd->general_params.dual_stream_ant_msk =
  81                         priv->hw_params.valid_tx_ant;
  82         }
  83
  84         link_cmd->agg_params.agg_dis_start_th = LINK_QUAL_AGG_DISABLE_START_DEF;
  85         link_cmd->agg_params.agg_time_limit =
  86                 cpu_to_le16(LINK_QUAL_AGG_TIME_LIMIT_DEF);
  87
  88         link_cmd->sta_id = sta_id;
  89
  90         return link_cmd;
  91 }
  92
  93 /*
  94  * iwlagn_add_bssid_station - Add the special IBSS BSSID station
  95  *
  96  * Function sleeps.
  97  */
  98 int iwlagn_add_bssid_station(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
  99                              const u8 *addr, u8 *sta_id_r)
 100 {
 101         int ret;
 102         u8 sta_id;
 103         struct iwl_link_quality_cmd *link_cmd;
 104         unsigned long flags;
 105
 106         if (sta_id_r)
 107                 *sta_id_r = IWL_INVALID_STATION;
 108
 109         ret = iwl_add_station_common(priv, ctx, addr, 0, NULL, &sta_id);
 110         if (ret) {
 111                 IWL_ERR(priv, "Unable to add station %pM\n", addr);
 112                 return ret;
 113         }
 114
 115         if (sta_id_r)
 116                 *sta_id_r = sta_id;
 117
 118         spin_lock_irqsave(&priv->sta_lock, flags);
 119         priv->stations[sta_id].used |= IWL_STA_LOCAL;
 120         spin_unlock_irqrestore(&priv->sta_lock, flags);
 121
 122         /* Set up default rate scaling table in device's station table */
 123         link_cmd = iwl_sta_alloc_lq(priv, ctx, sta_id);
 124         if (!link_cmd) {
 125                 IWL_ERR(priv, "Unable to initialize rate scaling for station %pM.\n",
 126                         addr);
 127                 return -ENOMEM;
 128         }
 129
 130         ret = iwl_send_lq_cmd(priv, ctx, link_cmd, CMD_SYNC, true);
 131         if (ret)
 132                 IWL_ERR(priv, "Link quality command failed (%d)\n", ret);
 133
 134         spin_lock_irqsave(&priv->sta_lock, flags);
 135         priv->stations[sta_id].lq = link_cmd;
 136         spin_unlock_irqrestore(&priv->sta_lock, flags);
 137
 138         return 0;
 139 }
 140
 141 static int iwl_send_static_wepkey_cmd(struct iwl_priv *priv,
 142                                       struct iwl_rxon_context *ctx,
 143                                       bool send_if_empty)
 144 {
 145         int i, not_empty = 0;
 146         u8 buff[sizeof(struct iwl_wep_cmd) +
 147                 sizeof(struct iwl_wep_key) * WEP_KEYS_MAX];
 148         struct iwl_wep_cmd *wep_cmd = (struct iwl_wep_cmd *)buff;
 149         size_t cmd_size  = sizeof(struct iwl_wep_cmd);
 150         struct iwl_host_cmd cmd = {
 151                 .id = ctx->wep_key_cmd,
 152                 .data = { wep_cmd, },
 153                 .flags = CMD_SYNC,
 154         };
 155
 156         might_sleep();
 157
 158         memset(wep_cmd, 0, cmd_size +
 159                         (sizeof(struct iwl_wep_key) * WEP_KEYS_MAX));
 160
 161         for (i = 0; i < WEP_KEYS_MAX ; i++) {
 162                 wep_cmd->key[i].key_index = i;
 163                 if (ctx->wep_keys[i].key_size) {
 164                         wep_cmd->key[i].key_offset = i;
 165                         not_empty = 1;
 166                 } else {
 167                         wep_cmd->key[i].key_offset = WEP_INVALID_OFFSET;
 168                 }
 169
 170                 wep_cmd->key[i].key_size = ctx->wep_keys[i].key_size;
 171                 memcpy(&wep_cmd->key[i].key[3], ctx->wep_keys[i].key,
 172                                 ctx->wep_keys[i].key_size);
 173         }
 174
 175         wep_cmd->global_key_type = WEP_KEY_WEP_TYPE;
 176         wep_cmd->num_keys = WEP_KEYS_MAX;
 177
 178         cmd_size += sizeof(struct iwl_wep_key) * WEP_KEYS_MAX;
 179
 180         cmd.len[0] = cmd_size;
 181
 182         if (not_empty || send_if_empty)
 183                 return iwl_send_cmd(priv, &cmd);
 184         else
 185                 return 0;
 186 }
 187
 188 int iwl_restore_default_wep_keys(struct iwl_priv *priv,
 189                                  struct iwl_rxon_context *ctx)
 190 {
 191         lockdep_assert_held(&priv->mutex);
 192
 193         return iwl_send_static_wepkey_cmd(priv, ctx, false);
 194 }
 195
 196 int iwl_remove_default_wep_key(struct iwl_priv *priv,
 197                                struct iwl_rxon_context *ctx,
 198                                struct ieee80211_key_conf *keyconf)
 199 {
 200         int ret;
 201
 202         lockdep_assert_held(&priv->mutex);
 203
 204         IWL_DEBUG_WEP(priv, "Removing default WEP key: idx=%d\n",
 205                       keyconf->keyidx);
 206
 207         memset(&ctx->wep_keys[keyconf->keyidx], 0, sizeof(ctx->wep_keys[0]));
 208         if (iwl_is_rfkill(priv)) {
 209                 IWL_DEBUG_WEP(priv, "Not sending REPLY_WEPKEY command due to RFKILL.\n");
 210                 /* but keys in device are clear anyway so return success */
 211                 return 0;
 212         }
 213         ret = iwl_send_static_wepkey_cmd(priv, ctx, 1);
 214         IWL_DEBUG_WEP(priv, "Remove default WEP key: idx=%d ret=%d\n",
 215                       keyconf->keyidx, ret);
 216
 217         return ret;
 218 }
 219
 220 int iwl_set_default_wep_key(struct iwl_priv *priv,
 221                             struct iwl_rxon_context *ctx,
 222                             struct ieee80211_key_conf *keyconf)
 223 {
 224         int ret;
 225
 226         lockdep_assert_held(&priv->mutex);
 227
 228         if (keyconf->keylen != WEP_KEY_LEN_128 &&
 229             keyconf->keylen != WEP_KEY_LEN_64) {
 230                 IWL_DEBUG_WEP(priv, "Bad WEP key length %d\n", keyconf->keylen);
 231                 return -EINVAL;
 232         }
 233
 234         keyconf->flags &= ~IEEE80211_KEY_FLAG_GENERATE_IV;
 235         keyconf->hw_key_idx = HW_KEY_DEFAULT;
 236         priv->stations[ctx->ap_sta_id].keyinfo.cipher = keyconf->cipher;
 237
 238         ctx->wep_keys[keyconf->keyidx].key_size = keyconf->keylen;
 239         memcpy(&ctx->wep_keys[keyconf->keyidx].key, &keyconf->key,
 240                                                         keyconf->keylen);
 241
 242         ret = iwl_send_static_wepkey_cmd(priv, ctx, false);
 243         IWL_DEBUG_WEP(priv, "Set default WEP key: len=%d idx=%d ret=%d\n",
 244                 keyconf->keylen, keyconf->keyidx, ret);
 245
 246         return ret;
 247 }
 248
 249 static int iwl_set_wep_dynamic_key_info(struct iwl_priv *priv,
 250                                         struct iwl_rxon_context *ctx,
 251                                         struct ieee80211_key_conf *keyconf,
 252                                         u8 sta_id)
 253 {
 254         unsigned long flags;
 255         __le16 key_flags = 0;
 256         struct iwl_addsta_cmd sta_cmd;
 257
 258         lockdep_assert_held(&priv->mutex);
 259
 260         keyconf->flags &= ~IEEE80211_KEY_FLAG_GENERATE_IV;
 261
 262         key_flags |= (STA_KEY_FLG_WEP | STA_KEY_FLG_MAP_KEY_MSK);
 263         key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
 264         key_flags &= ~STA_KEY_FLG_INVALID;
 265
 266         if (keyconf->keylen == WEP_KEY_LEN_128)
 267                 key_flags |= STA_KEY_FLG_KEY_SIZE_MSK;
 268
 269         if (sta_id == ctx->bcast_sta_id)
 270                 key_flags |= STA_KEY_MULTICAST_MSK;
 271
 272         spin_lock_irqsave(&priv->sta_lock, flags);
 273
 274         priv->stations[sta_id].keyinfo.cipher = keyconf->cipher;
 275         priv->stations[sta_id].keyinfo.keylen = keyconf->keylen;
 276         priv->stations[sta_id].keyinfo.keyidx = keyconf->keyidx;
 277
 278         memcpy(priv->stations[sta_id].keyinfo.key,
 279                                 keyconf->key, keyconf->keylen);
 280
 281         memcpy(&priv->stations[sta_id].sta.key.key[3],
 282                                 keyconf->key, keyconf->keylen);
 283
 284         if ((priv->stations[sta_id].sta.key.key_flags & STA_KEY_FLG_ENCRYPT_MSK)
 285                         == STA_KEY_FLG_NO_ENC)
 286                 priv->stations[sta_id].sta.key.key_offset =
 287                                  iwl_get_free_ucode_key_index(priv);
 288         /* else, we are overriding an existing key => no need to allocated room
 289          * in uCode. */
 290
 291         WARN(priv->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
 292                 "no space for a new key");
 293
 294         priv->stations[sta_id].sta.key.key_flags = key_flags;
 295         priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
 296         priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
 297
 298         memcpy(&sta_cmd, &priv->stations[sta_id].sta, sizeof(struct iwl_addsta_cmd));
 299         spin_unlock_irqrestore(&priv->sta_lock, flags);
 300
 301         return iwl_send_add_sta(priv, &sta_cmd, CMD_SYNC);
 302 }
 303
 304 static int iwl_set_ccmp_dynamic_key_info(struct iwl_priv *priv,
 305                                          struct iwl_rxon_context *ctx,
 306                                          struct ieee80211_key_conf *keyconf,
 307                                          u8 sta_id)
 308 {
 309         unsigned long flags;
 310         __le16 key_flags = 0;
 311         struct iwl_addsta_cmd sta_cmd;
 312
 313         lockdep_assert_held(&priv->mutex);
 314
 315         key_flags |= (STA_KEY_FLG_CCMP | STA_KEY_FLG_MAP_KEY_MSK);
 316         key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
 317         key_flags &= ~STA_KEY_FLG_INVALID;
 318
 319         if (sta_id == ctx->bcast_sta_id)
 320                 key_flags |= STA_KEY_MULTICAST_MSK;
 321
 322         keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
 323
 324         spin_lock_irqsave(&priv->sta_lock, flags);
 325         priv->stations[sta_id].keyinfo.cipher = keyconf->cipher;
 326         priv->stations[sta_id].keyinfo.keylen = keyconf->keylen;
 327
 328         memcpy(priv->stations[sta_id].keyinfo.key, keyconf->key,
 329                keyconf->keylen);
 330
 331         memcpy(priv->stations[sta_id].sta.key.key, keyconf->key,
 332                keyconf->keylen);
 333
 334         if ((priv->stations[sta_id].sta.key.key_flags & STA_KEY_FLG_ENCRYPT_MSK)
 335                         == STA_KEY_FLG_NO_ENC)
 336                 priv->stations[sta_id].sta.key.key_offset =
 337                                  iwl_get_free_ucode_key_index(priv);
 338         /* else, we are overriding an existing key => no need to allocated room
 339          * in uCode. */
 340
 341         WARN(priv->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
 342                 "no space for a new key");
 343
 344         priv->stations[sta_id].sta.key.key_flags = key_flags;
 345         priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
 346         priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
 347
 348         memcpy(&sta_cmd, &priv->stations[sta_id].sta, sizeof(struct iwl_addsta_cmd));
 349         spin_unlock_irqrestore(&priv->sta_lock, flags);
 350
 351         return iwl_send_add_sta(priv, &sta_cmd, CMD_SYNC);
 352 }
 353
 354 static int iwl_set_tkip_dynamic_key_info(struct iwl_priv *priv,
 355                                          struct iwl_rxon_context *ctx,
 356                                          struct ieee80211_key_conf *keyconf,
 357                                          u8 sta_id)
 358 {
 359         unsigned long flags;
 360         int ret = 0;
 361         __le16 key_flags = 0;
 362
 363         key_flags |= (STA_KEY_FLG_TKIP | STA_KEY_FLG_MAP_KEY_MSK);
 364         key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
 365         key_flags &= ~STA_KEY_FLG_INVALID;
 366
 367         if (sta_id == ctx->bcast_sta_id)
 368                 key_flags |= STA_KEY_MULTICAST_MSK;
 369
 370         keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
 371         keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
 372
 373         spin_lock_irqsave(&priv->sta_lock, flags);
 374
 375         priv->stations[sta_id].keyinfo.cipher = keyconf->cipher;
 376         priv->stations[sta_id].keyinfo.keylen = 16;
 377
 378         if ((priv->stations[sta_id].sta.key.key_flags & STA_KEY_FLG_ENCRYPT_MSK)
 379                         == STA_KEY_FLG_NO_ENC)
 380                 priv->stations[sta_id].sta.key.key_offset =
 381                                  iwl_get_free_ucode_key_index(priv);
 382         /* else, we are overriding an existing key => no need to allocated room
 383          * in uCode. */
 384
 385         WARN(priv->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
 386                 "no space for a new key");
 387
 388         priv->stations[sta_id].sta.key.key_flags = key_flags;
 389
 390
 391         /* This copy is acutally not needed: we get the key with each TX */
 392         memcpy(priv->stations[sta_id].keyinfo.key, keyconf->key, 16);
 393
 394         memcpy(priv->stations[sta_id].sta.key.key, keyconf->key, 16);
 395
 396         spin_unlock_irqrestore(&priv->sta_lock, flags);
 397
 398         return ret;
 399 }
 400
 401 void iwl_update_tkip_key(struct iwl_priv *priv,
 402                          struct iwl_rxon_context *ctx,
 403                          struct ieee80211_key_conf *keyconf,
 404                          struct ieee80211_sta *sta, u32 iv32, u16 *phase1key)
 405 {
 406         u8 sta_id;
 407         unsigned long flags;
 408         int i;
 409
 410         if (iwl_scan_cancel(priv)) {
 411                 /* cancel scan failed, just live w/ bad key and rely
 412                    briefly on SW decryption */
 413                 return;
 414         }
 415
 416         sta_id = iwl_sta_id_or_broadcast(priv, ctx, sta);
 417         if (sta_id == IWL_INVALID_STATION)
 418                 return;
 419
 420         spin_lock_irqsave(&priv->sta_lock, flags);
 421
 422         priv->stations[sta_id].sta.key.tkip_rx_tsc_byte2 = (u8) iv32;
 423
 424         for (i = 0; i < 5; i++)
 425                 priv->stations[sta_id].sta.key.tkip_rx_ttak[i] =
 426                         cpu_to_le16(phase1key[i]);
 427
 428         priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
 429         priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
 430
 431         iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);
 432
 433         spin_unlock_irqrestore(&priv->sta_lock, flags);
 434
 435 }
 436
 437 int iwl_remove_dynamic_key(struct iwl_priv *priv,
 438                            struct iwl_rxon_context *ctx,
 439                            struct ieee80211_key_conf *keyconf,
 440                            u8 sta_id)
 441 {
 442         unsigned long flags;
 443         u16 key_flags;
 444         u8 keyidx;
 445         struct iwl_addsta_cmd sta_cmd;
 446
 447         lockdep_assert_held(&priv->mutex);
 448
 449         ctx->key_mapping_keys--;
 450
 451         spin_lock_irqsave(&priv->sta_lock, flags);
 452         key_flags = le16_to_cpu(priv->stations[sta_id].sta.key.key_flags);
 453         keyidx = (key_flags >> STA_KEY_FLG_KEYID_POS) & 0x3;
 454
 455         IWL_DEBUG_WEP(priv, "Remove dynamic key: idx=%d sta=%d\n",
 456                       keyconf->keyidx, sta_id);
 457
 458         if (keyconf->keyidx != keyidx) {
 459                 /* We need to remove a key with index different that the one
 460                  * in the uCode. This means that the key we need to remove has
 461                  * been replaced by another one with different index.
 462                  * Don't do anything and return ok
 463                  */
 464                 spin_unlock_irqrestore(&priv->sta_lock, flags);
 465                 return 0;
 466         }
 467
 468         if (priv->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET) {
 469                 IWL_WARN(priv, "Removing wrong key %d 0x%x\n",
 470                             keyconf->keyidx, key_flags);
 471                 spin_unlock_irqrestore(&priv->sta_lock, flags);
 472                 return 0;
 473         }
 474
 475         if (!test_and_clear_bit(priv->stations[sta_id].sta.key.key_offset,
 476                 &priv->ucode_key_table))
 477                 IWL_ERR(priv, "index %d not used in uCode key table.\n",
 478                         priv->stations[sta_id].sta.key.key_offset);
 479         memset(&priv->stations[sta_id].keyinfo, 0,
 480                                         sizeof(struct iwl_hw_key));
 481         memset(&priv->stations[sta_id].sta.key, 0,
 482                                         sizeof(struct iwl_keyinfo));
 483         priv->stations[sta_id].sta.key.key_flags =
 484                         STA_KEY_FLG_NO_ENC | STA_KEY_FLG_INVALID;
 485         priv->stations[sta_id].sta.key.key_offset = WEP_INVALID_OFFSET;
 486         priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
 487         priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
 488
 489         if (iwl_is_rfkill(priv)) {
 490                 IWL_DEBUG_WEP(priv, "Not sending REPLY_ADD_STA command because RFKILL enabled.\n");
 491                 spin_unlock_irqrestore(&priv->sta_lock, flags);
 492                 return 0;
 493         }
 494         memcpy(&sta_cmd, &priv->stations[sta_id].sta, sizeof(struct iwl_addsta_cmd));
 495         spin_unlock_irqrestore(&priv->sta_lock, flags);
 496
 497         return iwl_send_add_sta(priv, &sta_cmd, CMD_SYNC);
 498 }
 499
 500 int iwl_set_dynamic_key(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
 501                         struct ieee80211_key_conf *keyconf, u8 sta_id)
 502 {
 503         int ret;
 504
 505         lockdep_assert_held(&priv->mutex);
 506
 507         ctx->key_mapping_keys++;
 508         keyconf->hw_key_idx = HW_KEY_DYNAMIC;
 509
 510         switch (keyconf->cipher) {
 511         case WLAN_CIPHER_SUITE_CCMP:
 512                 ret = iwl_set_ccmp_dynamic_key_info(priv, ctx, keyconf, sta_id);
 513                 break;
 514         case WLAN_CIPHER_SUITE_TKIP:
 515                 ret = iwl_set_tkip_dynamic_key_info(priv, ctx, keyconf, sta_id);
 516                 break;
 517         case WLAN_CIPHER_SUITE_WEP40:
 518         case WLAN_CIPHER_SUITE_WEP104:
 519                 ret = iwl_set_wep_dynamic_key_info(priv, ctx, keyconf, sta_id);
 520                 break;
 521         default:
 522                 IWL_ERR(priv,
 523                         "Unknown alg: %s cipher = %x\n", __func__,
 524                         keyconf->cipher);
 525                 ret = -EINVAL;
 526         }
 527
 528         IWL_DEBUG_WEP(priv, "Set dynamic key: cipher=%x len=%d idx=%d sta=%d ret=%d\n",
 529                       keyconf->cipher, keyconf->keylen, keyconf->keyidx,
 530                       sta_id, ret);
 531
 532         return ret;
 533 }
 534
 535 /**
 536  * iwlagn_alloc_bcast_station - add broadcast station into driver's station table.
 537  *
 538  * This adds the broadcast station into the driver's station table
 539  * and marks it driver active, so that it will be restored to the
 540  * device at the next best time.
 541  */
 542 int iwlagn_alloc_bcast_station(struct iwl_priv *priv,
 543                                struct iwl_rxon_context *ctx)
 544 {
 545         struct iwl_link_quality_cmd *link_cmd;
 546         unsigned long flags;
 547         u8 sta_id;
 548
 549         spin_lock_irqsave(&priv->sta_lock, flags);
 550         sta_id = iwl_prep_station(priv, ctx, iwl_bcast_addr, false, NULL);
 551         if (sta_id == IWL_INVALID_STATION) {
 552                 IWL_ERR(priv, "Unable to prepare broadcast station\n");
 553                 spin_unlock_irqrestore(&priv->sta_lock, flags);
 554
 555                 return -EINVAL;
 556         }
 557
 558         priv->stations[sta_id].used |= IWL_STA_DRIVER_ACTIVE;
 559         priv->stations[sta_id].used |= IWL_STA_BCAST;
 560         spin_unlock_irqrestore(&priv->sta_lock, flags);
 561
 562         link_cmd = iwl_sta_alloc_lq(priv, ctx, sta_id);
 563         if (!link_cmd) {
 564                 IWL_ERR(priv,
 565                         "Unable to initialize rate scaling for bcast station.\n");
 566                 return -ENOMEM;
 567         }
 568
 569         spin_lock_irqsave(&priv->sta_lock, flags);
 570         priv->stations[sta_id].lq = link_cmd;
 571         spin_unlock_irqrestore(&priv->sta_lock, flags);
 572
 573         return 0;
 574 }
 575
 576 /**
 577  * iwl_update_bcast_station - update broadcast station's LQ command
 578  *
 579  * Only used by iwlagn. Placed here to have all bcast station management
 580  * code together.
 581  */
 582 int iwl_update_bcast_station(struct iwl_priv *priv,
 583                              struct iwl_rxon_context *ctx)
 584 {
 585         unsigned long flags;
 586         struct iwl_link_quality_cmd *link_cmd;
 587         u8 sta_id = ctx->bcast_sta_id;
 588
 589         link_cmd = iwl_sta_alloc_lq(priv, ctx, sta_id);
 590         if (!link_cmd) {
 591                 IWL_ERR(priv, "Unable to initialize rate scaling for bcast station.\n");
 592                 return -ENOMEM;
 593         }
 594
 595         spin_lock_irqsave(&priv->sta_lock, flags);
 596         if (priv->stations[sta_id].lq)
 597                 kfree(priv->stations[sta_id].lq);
 598         else
 599                 IWL_DEBUG_INFO(priv, "Bcast station rate scaling has not been initialized yet.\n");
 600         priv->stations[sta_id].lq = link_cmd;
 601         spin_unlock_irqrestore(&priv->sta_lock, flags);
 602
 603         return 0;
 604 }
 605
 606 int iwl_update_bcast_stations(struct iwl_priv *priv)
 607 {
 608         struct iwl_rxon_context *ctx;
 609         int ret = 0;
 610
 611         for_each_context(priv, ctx) {
 612                 ret = iwl_update_bcast_station(priv, ctx);
 613                 if (ret)
 614                         break;
 615         }
 616
 617         return ret;
 618 }
 619
 620 /**
 621  * iwl_sta_tx_modify_enable_tid - Enable Tx for this TID in station table
 622  */
 623 int iwl_sta_tx_modify_enable_tid(struct iwl_priv *priv, int sta_id, int tid)
 624 {
 625         unsigned long flags;
 626         struct iwl_addsta_cmd sta_cmd;
 627
 628         lockdep_assert_held(&priv->mutex);
 629
 630         /* Remove "disable" flag, to enable Tx for this TID */
 631         spin_lock_irqsave(&priv->sta_lock, flags);
 632         priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_TID_DISABLE_TX;
 633         priv->stations[sta_id].sta.tid_disable_tx &= cpu_to_le16(~(1 << tid));
 634         priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
 635         memcpy(&sta_cmd, &priv->stations[sta_id].sta, sizeof(struct iwl_addsta_cmd));
 636         spin_unlock_irqrestore(&priv->sta_lock, flags);
 637
 638         return iwl_send_add_sta(priv, &sta_cmd, CMD_SYNC);
 639 }
 640
 641 int iwl_sta_rx_agg_start(struct iwl_priv *priv, struct ieee80211_sta *sta,
 642                          int tid, u16 ssn)
 643 {
 644         unsigned long flags;
 645         int sta_id;
 646         struct iwl_addsta_cmd sta_cmd;
 647
 648         lockdep_assert_held(&priv->mutex);
 649
 650         sta_id = iwl_sta_id(sta);
 651         if (sta_id == IWL_INVALID_STATION)
 652                 return -ENXIO;
 653
 654         spin_lock_irqsave(&priv->sta_lock, flags);
 655         priv->stations[sta_id].sta.station_flags_msk = 0;
 656         priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_ADDBA_TID_MSK;
 657         priv->stations[sta_id].sta.add_immediate_ba_tid = (u8)tid;
 658         priv->stations[sta_id].sta.add_immediate_ba_ssn = cpu_to_le16(ssn);
 659         priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
 660         memcpy(&sta_cmd, &priv->stations[sta_id].sta, sizeof(struct iwl_addsta_cmd));
 661         spin_unlock_irqrestore(&priv->sta_lock, flags);
 662
 663         return iwl_send_add_sta(priv, &sta_cmd, CMD_SYNC);
 664 }
 665
 666 int iwl_sta_rx_agg_stop(struct iwl_priv *priv, struct ieee80211_sta *sta,
 667                         int tid)
 668 {
 669         unsigned long flags;
 670         int sta_id;
 671         struct iwl_addsta_cmd sta_cmd;
 672
 673         lockdep_assert_held(&priv->mutex);
 674
 675         sta_id = iwl_sta_id(sta);
 676         if (sta_id == IWL_INVALID_STATION) {
 677                 IWL_ERR(priv, "Invalid station for AGG tid %d\n", tid);
 678                 return -ENXIO;
 679         }
 680
 681         spin_lock_irqsave(&priv->sta_lock, flags);
 682         priv->stations[sta_id].sta.station_flags_msk = 0;
 683         priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_DELBA_TID_MSK;
 684         priv->stations[sta_id].sta.remove_immediate_ba_tid = (u8)tid;
 685         priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
 686         memcpy(&sta_cmd, &priv->stations[sta_id].sta, sizeof(struct iwl_addsta_cmd));
 687         spin_unlock_irqrestore(&priv->sta_lock, flags);
 688
 689         return iwl_send_add_sta(priv, &sta_cmd, CMD_SYNC);
 690 }
 691
 692 static void iwl_sta_modify_ps_wake(struct iwl_priv *priv, int sta_id)
 693 {
 694         unsigned long flags;
 695
 696         spin_lock_irqsave(&priv->sta_lock, flags);
 697         priv->stations[sta_id].sta.station_flags &= ~STA_FLG_PWR_SAVE_MSK;
 698         priv->stations[sta_id].sta.station_flags_msk = STA_FLG_PWR_SAVE_MSK;
 699         priv->stations[sta_id].sta.sta.modify_mask = 0;
 700         priv->stations[sta_id].sta.sleep_tx_count = 0;
 701         priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
 702         iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);
 703         spin_unlock_irqrestore(&priv->sta_lock, flags);
 704
 705 }
 706
 707 void iwl_sta_modify_sleep_tx_count(struct iwl_priv *priv, int sta_id, int cnt)
 708 {
 709         unsigned long flags;
 710
 711         spin_lock_irqsave(&priv->sta_lock, flags);
 712         priv->stations[sta_id].sta.station_flags |= STA_FLG_PWR_SAVE_MSK;
 713         priv->stations[sta_id].sta.station_flags_msk = STA_FLG_PWR_SAVE_MSK;
 714         priv->stations[sta_id].sta.sta.modify_mask =
 715                                         STA_MODIFY_SLEEP_TX_COUNT_MSK;
 716         priv->stations[sta_id].sta.sleep_tx_count = cpu_to_le16(cnt);
 717         priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
 718         iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);
 719         spin_unlock_irqrestore(&priv->sta_lock, flags);
 720
 721 }
 722
 723 void iwlagn_mac_sta_notify(struct ieee80211_hw *hw,
 724                            struct ieee80211_vif *vif,
 725                            enum sta_notify_cmd cmd,
 726                            struct ieee80211_sta *sta)
 727 {
 728         struct iwl_priv *priv = hw->priv;
 729         struct iwl_station_priv *sta_priv = (void *)sta->drv_priv;
 730         int sta_id;
 731
 732         switch (cmd) {
 733         case STA_NOTIFY_SLEEP:
 734                 WARN_ON(!sta_priv->client);
 735                 sta_priv->asleep = true;
 736                 if (atomic_read(&sta_priv->pending_frames) > 0)
 737                         ieee80211_sta_block_awake(hw, sta, true);
 738                 break;
 739         case STA_NOTIFY_AWAKE:
 740                 WARN_ON(!sta_priv->client);
 741                 if (!sta_priv->asleep)
 742                         break;
 743                 sta_priv->asleep = false;
 744                 sta_id = iwl_sta_id(sta);
 745                 if (sta_id != IWL_INVALID_STATION)
 746                         iwl_sta_modify_ps_wake(priv, sta_id);
 747                 break;
 748         default:
 749                 break;
 750         }
 751 }