SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/net/wireless/libertas/assoc.c

   1 /* Copyright (C) 2006, Red Hat, Inc. */
   2
   3 #include <linux/bitops.h>
   4 #include <net/ieee80211.h>
   5 #include <linux/etherdevice.h>
   6
   7 #include "assoc.h"
   8 #include "join.h"
   9 #include "decl.h"
  10 #include "hostcmd.h"
  11 #include "host.h"
  12
  13
  14 static const u8 bssid_any[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
  15 static const u8 bssid_off[ETH_ALEN] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
  16
  17
  18 static int assoc_helper_essid(struct lbs_private *priv,
  19                               struct assoc_request * assoc_req)
  20 {
  21         struct lbs_adapter *adapter = priv->adapter;
  22         int ret = 0;
  23         struct bss_descriptor * bss;
  24         int channel = -1;
  25
  26         lbs_deb_enter(LBS_DEB_ASSOC);
  27
  28         /* FIXME: take channel into account when picking SSIDs if a channel
  29          * is set.
  30          */
  31
  32         if (test_bit(ASSOC_FLAG_CHANNEL, &assoc_req->flags))
  33                 channel = assoc_req->channel;
  34
  35         lbs_deb_assoc("SSID '%s' requested\n",
  36                       escape_essid(assoc_req->ssid, assoc_req->ssid_len));
  37         if (assoc_req->mode == IW_MODE_INFRA) {
  38                 lbs_send_specific_ssid_scan(priv, assoc_req->ssid,
  39                         assoc_req->ssid_len, 0);
  40
  41                 bss = lbs_find_ssid_in_list(adapter, assoc_req->ssid,
  42                                 assoc_req->ssid_len, NULL, IW_MODE_INFRA, channel);
  43                 if (bss != NULL) {
  44                         memcpy(&assoc_req->bss, bss, sizeof(struct bss_descriptor));
  45                         ret = lbs_associate(priv, assoc_req);
  46                 } else {
  47                         lbs_deb_assoc("SSID not found; cannot associate\n");
  48                 }
  49         } else if (assoc_req->mode == IW_MODE_ADHOC) {
  50                 /* Scan for the network, do not save previous results.  Stale
  51                  *   scan data will cause us to join a non-existant adhoc network
  52                  */
  53                 lbs_send_specific_ssid_scan(priv, assoc_req->ssid,
  54                         assoc_req->ssid_len, 1);
  55
  56                 /* Search for the requested SSID in the scan table */
  57                 bss = lbs_find_ssid_in_list(adapter, assoc_req->ssid,
  58                                 assoc_req->ssid_len, NULL, IW_MODE_ADHOC, channel);
  59                 if (bss != NULL) {
  60                         lbs_deb_assoc("SSID found, will join\n");
  61                         memcpy(&assoc_req->bss, bss, sizeof(struct bss_descriptor));
  62                         lbs_join_adhoc_network(priv, assoc_req);
  63                 } else {
  64                         /* else send START command */
  65                         lbs_deb_assoc("SSID not found, creating adhoc network\n");
  66                         memcpy(&assoc_req->bss.ssid, &assoc_req->ssid,
  67                                 IW_ESSID_MAX_SIZE);
  68                         assoc_req->bss.ssid_len = assoc_req->ssid_len;
  69                         lbs_start_adhoc_network(priv, assoc_req);
  70                 }
  71         }
  72
  73         lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
  74         return ret;
  75 }
  76
  77
  78 static int assoc_helper_bssid(struct lbs_private *priv,
  79                               struct assoc_request * assoc_req)
  80 {
  81         struct lbs_adapter *adapter = priv->adapter;
  82         int ret = 0;
  83         struct bss_descriptor * bss;
  84         DECLARE_MAC_BUF(mac);
  85
  86         lbs_deb_enter_args(LBS_DEB_ASSOC, "BSSID %s",
  87                 print_mac(mac, assoc_req->bssid));
  88
  89         /* Search for index position in list for requested MAC */
  90         bss = lbs_find_bssid_in_list(adapter, assoc_req->bssid,
  91                             assoc_req->mode);
  92         if (bss == NULL) {
  93                 lbs_deb_assoc("ASSOC: WAP: BSSID %s not found, "
  94                         "cannot associate.\n", print_mac(mac, assoc_req->bssid));
  95                 goto out;
  96         }
  97
  98         memcpy(&assoc_req->bss, bss, sizeof(struct bss_descriptor));
  99         if (assoc_req->mode == IW_MODE_INFRA) {
 100                 ret = lbs_associate(priv, assoc_req);
 101                 lbs_deb_assoc("ASSOC: lbs_associate(bssid) returned %d\n", ret);
 102         } else if (assoc_req->mode == IW_MODE_ADHOC) {
 103                 lbs_join_adhoc_network(priv, assoc_req);
 104         }
 105
 106 out:
 107         lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
 108         return ret;
 109 }
 110
 111
 112 static int assoc_helper_associate(struct lbs_private *priv,
 113                                   struct assoc_request * assoc_req)
 114 {
 115         int ret = 0, done = 0;
 116
 117         lbs_deb_enter(LBS_DEB_ASSOC);
 118
 119         /* If we're given and 'any' BSSID, try associating based on SSID */
 120
 121         if (test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)) {
 122                 if (compare_ether_addr(bssid_any, assoc_req->bssid)
 123                     && compare_ether_addr(bssid_off, assoc_req->bssid)) {
 124                         ret = assoc_helper_bssid(priv, assoc_req);
 125                         done = 1;
 126                 }
 127         }
 128
 129         if (!done && test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
 130                 ret = assoc_helper_essid(priv, assoc_req);
 131         }
 132
 133         lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
 134         return ret;
 135 }
 136
 137
 138 static int assoc_helper_mode(struct lbs_private *priv,
 139                              struct assoc_request * assoc_req)
 140 {
 141         struct lbs_adapter *adapter = priv->adapter;
 142         int ret = 0;
 143
 144         lbs_deb_enter(LBS_DEB_ASSOC);
 145
 146         if (assoc_req->mode == adapter->mode)
 147                 goto done;
 148
 149         if (assoc_req->mode == IW_MODE_INFRA) {
 150                 if (adapter->psstate != PS_STATE_FULL_POWER)
 151                         lbs_ps_wakeup(priv, CMD_OPTION_WAITFORRSP);
 152                 adapter->psmode = LBS802_11POWERMODECAM;
 153         }
 154
 155         adapter->mode = assoc_req->mode;
 156         ret = lbs_prepare_and_send_command(priv,
 157                                     CMD_802_11_SNMP_MIB,
 158                                     0, CMD_OPTION_WAITFORRSP,
 159                                     OID_802_11_INFRASTRUCTURE_MODE,
 160                 /* Shoot me now */  (void *) (size_t) assoc_req->mode);
 161
 162 done:
 163         lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
 164         return ret;
 165 }
 166
 167
 168 static int update_channel(struct lbs_private *priv)
 169 {
 170         int ret;
 171         /* the channel in f/w could be out of sync, get the current channel */
 172         lbs_deb_enter(LBS_DEB_ASSOC);
 173         ret = lbs_prepare_and_send_command(priv, CMD_802_11_RF_CHANNEL,
 174                                     CMD_OPT_802_11_RF_CHANNEL_GET,
 175                                     CMD_OPTION_WAITFORRSP, 0, NULL);
 176         lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
 177         return ret;
 178 }
 179
 180 void lbs_sync_channel(struct work_struct *work)
 181 {
 182         struct lbs_private *priv = container_of(work, struct lbs_private,
 183                 sync_channel);
 184
 185         lbs_deb_enter(LBS_DEB_ASSOC);
 186         if (update_channel(priv) != 0)
 187                 lbs_pr_info("Channel synchronization failed.");
 188         lbs_deb_leave(LBS_DEB_ASSOC);
 189 }
 190
 191 static int assoc_helper_channel(struct lbs_private *priv,
 192                                 struct assoc_request * assoc_req)
 193 {
 194         struct lbs_adapter *adapter = priv->adapter;
 195         int ret = 0;
 196
 197         lbs_deb_enter(LBS_DEB_ASSOC);
 198
 199         ret = update_channel(priv);
 200         if (ret < 0) {
 201                 lbs_deb_assoc("ASSOC: channel: error getting channel.");
 202         }
 203
 204         if (assoc_req->channel == adapter->curbssparams.channel)
 205                 goto done;
 206
 207         lbs_deb_assoc("ASSOC: channel: %d -> %d\n",
 208                adapter->curbssparams.channel, assoc_req->channel);
 209
 210         ret = lbs_prepare_and_send_command(priv, CMD_802_11_RF_CHANNEL,
 211                                 CMD_OPT_802_11_RF_CHANNEL_SET,
 212                                 CMD_OPTION_WAITFORRSP, 0, &assoc_req->channel);
 213         if (ret < 0) {
 214                 lbs_deb_assoc("ASSOC: channel: error setting channel.");
 215         }
 216
 217         ret = update_channel(priv);
 218         if (ret < 0) {
 219                 lbs_deb_assoc("ASSOC: channel: error getting channel.");
 220         }
 221
 222         if (assoc_req->channel != adapter->curbssparams.channel) {
 223                 lbs_deb_assoc("ASSOC: channel: failed to update channel to %d",
 224                               assoc_req->channel);
 225                 goto done;
 226         }
 227
 228         if (   assoc_req->secinfo.wep_enabled
 229             &&   (assoc_req->wep_keys[0].len
 230                || assoc_req->wep_keys[1].len
 231                || assoc_req->wep_keys[2].len
 232                || assoc_req->wep_keys[3].len)) {
 233                 /* Make sure WEP keys are re-sent to firmware */
 234                 set_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags);
 235         }
 236
 237         /* Must restart/rejoin adhoc networks after channel change */
 238         set_bit(ASSOC_FLAG_SSID, &assoc_req->flags);
 239
 240 done:
 241         lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
 242         return ret;
 243 }
 244
 245
 246 static int assoc_helper_wep_keys(struct lbs_private *priv,
 247                                  struct assoc_request * assoc_req)
 248 {
 249         struct lbs_adapter *adapter = priv->adapter;
 250         int i;
 251         int ret = 0;
 252
 253         lbs_deb_enter(LBS_DEB_ASSOC);
 254
 255         /* Set or remove WEP keys */
 256         if (   assoc_req->wep_keys[0].len
 257             || assoc_req->wep_keys[1].len
 258             || assoc_req->wep_keys[2].len
 259             || assoc_req->wep_keys[3].len) {
 260                 ret = lbs_prepare_and_send_command(priv,
 261                                             CMD_802_11_SET_WEP,
 262                                             CMD_ACT_ADD,
 263                                             CMD_OPTION_WAITFORRSP,
 264                                             0, assoc_req);
 265         } else {
 266                 ret = lbs_prepare_and_send_command(priv,
 267                                             CMD_802_11_SET_WEP,
 268                                             CMD_ACT_REMOVE,
 269                                             CMD_OPTION_WAITFORRSP,
 270                                             0, NULL);
 271         }
 272
 273         if (ret)
 274                 goto out;
 275
 276         /* enable/disable the MAC's WEP packet filter */
 277         if (assoc_req->secinfo.wep_enabled)
 278                 adapter->currentpacketfilter |= CMD_ACT_MAC_WEP_ENABLE;
 279         else
 280                 adapter->currentpacketfilter &= ~CMD_ACT_MAC_WEP_ENABLE;
 281         ret = lbs_set_mac_packet_filter(priv);
 282         if (ret)
 283                 goto out;
 284
 285         mutex_lock(&adapter->lock);
 286
 287         /* Copy WEP keys into adapter wep key fields */
 288         for (i = 0; i < 4; i++) {
 289                 memcpy(&adapter->wep_keys[i], &assoc_req->wep_keys[i],
 290                         sizeof(struct enc_key));
 291         }
 292         adapter->wep_tx_keyidx = assoc_req->wep_tx_keyidx;
 293
 294         mutex_unlock(&adapter->lock);
 295
 296 out:
 297         lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
 298         return ret;
 299 }
 300
 301 static int assoc_helper_secinfo(struct lbs_private *priv,
 302                                 struct assoc_request * assoc_req)
 303 {
 304         struct lbs_adapter *adapter = priv->adapter;
 305         int ret = 0;
 306         u32 do_wpa;
 307         u32 rsn = 0;
 308
 309         lbs_deb_enter(LBS_DEB_ASSOC);
 310
 311         memcpy(&adapter->secinfo, &assoc_req->secinfo,
 312                 sizeof(struct lbs_802_11_security));
 313
 314         ret = lbs_set_mac_packet_filter(priv);
 315         if (ret)
 316                 goto out;
 317
 318         /* If RSN is already enabled, don't try to enable it again, since
 319          * ENABLE_RSN resets internal state machines and will clobber the
 320          * 4-way WPA handshake.
 321          */
 322
 323         /* Get RSN enabled/disabled */
 324         ret = lbs_prepare_and_send_command(priv,
 325                                     CMD_802_11_ENABLE_RSN,
 326                                     CMD_ACT_GET,
 327                                     CMD_OPTION_WAITFORRSP,
 328                                     0, &rsn);
 329         if (ret) {
 330                 lbs_deb_assoc("Failed to get RSN status: %d", ret);
 331                 goto out;
 332         }
 333
 334         /* Don't re-enable RSN if it's already enabled */
 335         do_wpa = (assoc_req->secinfo.WPAenabled || assoc_req->secinfo.WPA2enabled);
 336         if (do_wpa == rsn)
 337                 goto out;
 338
 339         /* Set RSN enabled/disabled */
 340         rsn = do_wpa;
 341         ret = lbs_prepare_and_send_command(priv,
 342                                     CMD_802_11_ENABLE_RSN,
 343                                     CMD_ACT_SET,
 344                                     CMD_OPTION_WAITFORRSP,
 345                                     0, &rsn);
 346
 347 out:
 348         lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
 349         return ret;
 350 }
 351
 352
 353 static int assoc_helper_wpa_keys(struct lbs_private *priv,
 354                                  struct assoc_request * assoc_req)
 355 {
 356         int ret = 0;
 357         unsigned int flags = assoc_req->flags;
 358
 359         lbs_deb_enter(LBS_DEB_ASSOC);
 360
 361         /* Work around older firmware bug where WPA unicast and multicast
 362          * keys must be set independently.  Seen in SDIO parts with firmware
 363          * version 5.0.11p0.
 364          */
 365
 366         if (test_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags)) {
 367                 clear_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags);
 368                 ret = lbs_prepare_and_send_command(priv,
 369                                         CMD_802_11_KEY_MATERIAL,
 370                                         CMD_ACT_SET,
 371                                         CMD_OPTION_WAITFORRSP,
 372                                         0, assoc_req);
 373                 assoc_req->flags = flags;
 374         }
 375
 376         if (ret)
 377                 goto out;
 378
 379         if (test_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags)) {
 380                 clear_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags);
 381
 382                 ret = lbs_prepare_and_send_command(priv,
 383                                         CMD_802_11_KEY_MATERIAL,
 384                                         CMD_ACT_SET,
 385                                         CMD_OPTION_WAITFORRSP,
 386                                         0, assoc_req);
 387                 assoc_req->flags = flags;
 388         }
 389
 390 out:
 391         lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
 392         return ret;
 393 }
 394
 395
 396 static int assoc_helper_wpa_ie(struct lbs_private *priv,
 397                                struct assoc_request * assoc_req)
 398 {
 399         struct lbs_adapter *adapter = priv->adapter;
 400         int ret = 0;
 401
 402         lbs_deb_enter(LBS_DEB_ASSOC);
 403
 404         if (assoc_req->secinfo.WPAenabled || assoc_req->secinfo.WPA2enabled) {
 405                 memcpy(&adapter->wpa_ie, &assoc_req->wpa_ie, assoc_req->wpa_ie_len);
 406                 adapter->wpa_ie_len = assoc_req->wpa_ie_len;
 407         } else {
 408                 memset(&adapter->wpa_ie, 0, MAX_WPA_IE_LEN);
 409                 adapter->wpa_ie_len = 0;
 410         }
 411
 412         lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
 413         return ret;
 414 }
 415
 416
 417 static int should_deauth_infrastructure(struct lbs_adapter *adapter,
 418                                         struct assoc_request * assoc_req)
 419 {
 420         int ret = 0;
 421
 422         lbs_deb_enter(LBS_DEB_ASSOC);
 423
 424         if (adapter->connect_status != LBS_CONNECTED)
 425                 return 0;
 426
 427         if (test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
 428                 lbs_deb_assoc("Deauthenticating due to new SSID\n");
 429                 ret = 1;
 430                 goto out;
 431         }
 432
 433         if (test_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags)) {
 434                 if (adapter->secinfo.auth_mode != assoc_req->secinfo.auth_mode) {
 435                         lbs_deb_assoc("Deauthenticating due to new security\n");
 436                         ret = 1;
 437                         goto out;
 438                 }
 439         }
 440
 441         if (test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)) {
 442                 lbs_deb_assoc("Deauthenticating due to new BSSID\n");
 443                 ret = 1;
 444                 goto out;
 445         }
 446
 447         if (test_bit(ASSOC_FLAG_CHANNEL, &assoc_req->flags)) {
 448                 lbs_deb_assoc("Deauthenticating due to channel switch\n");
 449                 ret = 1;
 450                 goto out;
 451         }
 452
 453         /* FIXME: deal with 'auto' mode somehow */
 454         if (test_bit(ASSOC_FLAG_MODE, &assoc_req->flags)) {
 455                 if (assoc_req->mode != IW_MODE_INFRA) {
 456                         lbs_deb_assoc("Deauthenticating due to leaving "
 457                                 "infra mode\n");
 458                         ret = 1;
 459                         goto out;
 460                 }
 461         }
 462
 463 out:
 464         lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
 465         return 0;
 466 }
 467
 468
 469 static int should_stop_adhoc(struct lbs_adapter *adapter,
 470                              struct assoc_request * assoc_req)
 471 {
 472         lbs_deb_enter(LBS_DEB_ASSOC);
 473
 474         if (adapter->connect_status != LBS_CONNECTED)
 475                 return 0;
 476
 477         if (lbs_ssid_cmp(adapter->curbssparams.ssid,
 478                               adapter->curbssparams.ssid_len,
 479                               assoc_req->ssid, assoc_req->ssid_len) != 0)
 480                 return 1;
 481
 482         /* FIXME: deal with 'auto' mode somehow */
 483         if (test_bit(ASSOC_FLAG_MODE, &assoc_req->flags)) {
 484                 if (assoc_req->mode != IW_MODE_ADHOC)
 485                         return 1;
 486         }
 487
 488         if (test_bit(ASSOC_FLAG_CHANNEL, &assoc_req->flags)) {
 489                 if (assoc_req->channel != adapter->curbssparams.channel)
 490                         return 1;
 491         }
 492
 493         lbs_deb_leave(LBS_DEB_ASSOC);
 494         return 0;
 495 }
 496
 497
 498 void lbs_association_worker(struct work_struct *work)
 499 {
 500         struct lbs_private *priv = container_of(work, struct lbs_private,
 501                 assoc_work.work);
 502         struct lbs_adapter *adapter = priv->adapter;
 503         struct assoc_request * assoc_req = NULL;
 504         int ret = 0;
 505         int find_any_ssid = 0;
 506         DECLARE_MAC_BUF(mac);
 507
 508         lbs_deb_enter(LBS_DEB_ASSOC);
 509
 510         mutex_lock(&adapter->lock);
 511         assoc_req = adapter->pending_assoc_req;
 512         adapter->pending_assoc_req = NULL;
 513         adapter->in_progress_assoc_req = assoc_req;
 514         mutex_unlock(&adapter->lock);
 515
 516         if (!assoc_req)
 517                 goto done;
 518
 519         lbs_deb_assoc(
 520                 "Association Request:\n"
 521                 "    flags:     0x%08lx\n"
 522                 "    SSID:      '%s'\n"
 523                 "    chann:     %d\n"
 524                 "    band:      %d\n"
 525                 "    mode:      %d\n"
 526                 "    BSSID:     %s\n"
 527                 "    secinfo:  %s%s%s\n"
 528                 "    auth_mode: %d\n",
 529                 assoc_req->flags,
 530                 escape_essid(assoc_req->ssid, assoc_req->ssid_len),
 531                 assoc_req->channel, assoc_req->band, assoc_req->mode,
 532                 print_mac(mac, assoc_req->bssid),
 533                 assoc_req->secinfo.WPAenabled ? " WPA" : "",
 534                 assoc_req->secinfo.WPA2enabled ? " WPA2" : "",
 535                 assoc_req->secinfo.wep_enabled ? " WEP" : "",
 536                 assoc_req->secinfo.auth_mode);
 537
 538         /* If 'any' SSID was specified, find an SSID to associate with */
 539         if (test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)
 540             && !assoc_req->ssid_len)
 541                 find_any_ssid = 1;
 542
 543         /* But don't use 'any' SSID if there's a valid locked BSSID to use */
 544         if (test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)) {
 545                 if (compare_ether_addr(assoc_req->bssid, bssid_any)
 546                     && compare_ether_addr(assoc_req->bssid, bssid_off))
 547                         find_any_ssid = 0;
 548         }
 549
 550         if (find_any_ssid) {
 551                 u8 new_mode;
 552
 553                 ret = lbs_find_best_network_ssid(priv, assoc_req->ssid,
 554                                 &assoc_req->ssid_len, assoc_req->mode, &new_mode);
 555                 if (ret) {
 556                         lbs_deb_assoc("Could not find best network\n");
 557                         ret = -ENETUNREACH;
 558                         goto out;
 559                 }
 560
 561                 /* Ensure we switch to the mode of the AP */
 562                 if (assoc_req->mode == IW_MODE_AUTO) {
 563                         set_bit(ASSOC_FLAG_MODE, &assoc_req->flags);
 564                         assoc_req->mode = new_mode;
 565                 }
 566         }
 567
 568         /*
 569          * Check if the attributes being changing require deauthentication
 570          * from the currently associated infrastructure access point.
 571          */
 572         if (adapter->mode == IW_MODE_INFRA) {
 573                 if (should_deauth_infrastructure(adapter, assoc_req)) {
 574                         ret = lbs_send_deauthentication(priv);
 575                         if (ret) {
 576                                 lbs_deb_assoc("Deauthentication due to new "
 577                                         "configuration request failed: %d\n",
 578                                         ret);
 579                         }
 580                 }
 581         } else if (adapter->mode == IW_MODE_ADHOC) {
 582                 if (should_stop_adhoc(adapter, assoc_req)) {
 583                         ret = lbs_stop_adhoc_network(priv);
 584                         if (ret) {
 585                                 lbs_deb_assoc("Teardown of AdHoc network due to "
 586                                         "new configuration request failed: %d\n",
 587                                         ret);
 588                         }
 589
 590                 }
 591         }
 592
 593         /* Send the various configuration bits to the firmware */
 594         if (test_bit(ASSOC_FLAG_MODE, &assoc_req->flags)) {
 595                 ret = assoc_helper_mode(priv, assoc_req);
 596                 if (ret)
 597                         goto out;
 598         }
 599
 600         if (test_bit(ASSOC_FLAG_CHANNEL, &assoc_req->flags)) {
 601                 ret = assoc_helper_channel(priv, assoc_req);
 602                 if (ret)
 603                         goto out;
 604         }
 605
 606         if (   test_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags)
 607             || test_bit(ASSOC_FLAG_WEP_TX_KEYIDX, &assoc_req->flags)) {
 608                 ret = assoc_helper_wep_keys(priv, assoc_req);
 609                 if (ret)
 610                         goto out;
 611         }
 612
 613         if (test_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags)) {
 614                 ret = assoc_helper_secinfo(priv, assoc_req);
 615                 if (ret)
 616                         goto out;
 617         }
 618
 619         if (test_bit(ASSOC_FLAG_WPA_IE, &assoc_req->flags)) {
 620                 ret = assoc_helper_wpa_ie(priv, assoc_req);
 621                 if (ret)
 622                         goto out;
 623         }
 624
 625         if (test_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags)
 626             || test_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags)) {
 627                 ret = assoc_helper_wpa_keys(priv, assoc_req);
 628                 if (ret)
 629                         goto out;
 630         }
 631
 632         /* SSID/BSSID should be the _last_ config option set, because they
 633          * trigger the association attempt.
 634          */
 635         if (test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)
 636             || test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
 637                 int success = 1;
 638
 639                 ret = assoc_helper_associate(priv, assoc_req);
 640                 if (ret) {
 641                         lbs_deb_assoc("ASSOC: association unsuccessful: %d\n",
 642                                 ret);
 643                         success = 0;
 644                 }
 645
 646                 if (adapter->connect_status != LBS_CONNECTED) {
 647                         lbs_deb_assoc("ASSOC: association unsuccessful, "
 648                                 "not connected\n");
 649                         success = 0;
 650                 }
 651
 652                 if (success) {
 653                         lbs_deb_assoc("ASSOC: associated to '%s', %s\n",
 654                                 escape_essid(adapter->curbssparams.ssid,
 655                                              adapter->curbssparams.ssid_len),
 656                                 print_mac(mac, adapter->curbssparams.bssid));
 657                         lbs_prepare_and_send_command(priv,
 658                                 CMD_802_11_RSSI,
 659                                 0, CMD_OPTION_WAITFORRSP, 0, NULL);
 660
 661                         lbs_prepare_and_send_command(priv,
 662                                 CMD_802_11_GET_LOG,
 663                                 0, CMD_OPTION_WAITFORRSP, 0, NULL);
 664                 } else {
 665                         ret = -1;
 666                 }
 667         }
 668
 669 out:
 670         if (ret) {
 671                 lbs_deb_assoc("ASSOC: reconfiguration attempt unsuccessful: %d\n",
 672                         ret);
 673         }
 674
 675         mutex_lock(&adapter->lock);
 676         adapter->in_progress_assoc_req = NULL;
 677         mutex_unlock(&adapter->lock);
 678         kfree(assoc_req);
 679
 680 done:
 681         lbs_deb_leave(LBS_DEB_ASSOC);
 682 }
 683
 684
 685 /*
 686  * Caller MUST hold any necessary locks
 687  */
 688 struct assoc_request *lbs_get_association_request(struct lbs_adapter *adapter)
 689 {
 690         struct assoc_request * assoc_req;
 691
 692         lbs_deb_enter(LBS_DEB_ASSOC);
 693         if (!adapter->pending_assoc_req) {
 694                 adapter->pending_assoc_req = kzalloc(sizeof(struct assoc_request),
 695                                                      GFP_KERNEL);
 696                 if (!adapter->pending_assoc_req) {
 697                         lbs_pr_info("Not enough memory to allocate association"
 698                                 " request!\n");
 699                         return NULL;
 700                 }
 701         }
 702
 703         /* Copy current configuration attributes to the association request,
 704          * but don't overwrite any that are already set.
 705          */
 706         assoc_req = adapter->pending_assoc_req;
 707         if (!test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
 708                 memcpy(&assoc_req->ssid, &adapter->curbssparams.ssid,
 709                        IW_ESSID_MAX_SIZE);
 710                 assoc_req->ssid_len = adapter->curbssparams.ssid_len;
 711         }
 712
 713         if (!test_bit(ASSOC_FLAG_CHANNEL, &assoc_req->flags))
 714                 assoc_req->channel = adapter->curbssparams.channel;
 715
 716         if (!test_bit(ASSOC_FLAG_BAND, &assoc_req->flags))
 717                 assoc_req->band = adapter->curbssparams.band;
 718
 719         if (!test_bit(ASSOC_FLAG_MODE, &assoc_req->flags))
 720                 assoc_req->mode = adapter->mode;
 721
 722         if (!test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)) {
 723                 memcpy(&assoc_req->bssid, adapter->curbssparams.bssid,
 724                         ETH_ALEN);
 725         }
 726
 727         if (!test_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags)) {
 728                 int i;
 729                 for (i = 0; i < 4; i++) {
 730                         memcpy(&assoc_req->wep_keys[i], &adapter->wep_keys[i],
 731                                 sizeof(struct enc_key));
 732                 }
 733         }
 734
 735         if (!test_bit(ASSOC_FLAG_WEP_TX_KEYIDX, &assoc_req->flags))
 736                 assoc_req->wep_tx_keyidx = adapter->wep_tx_keyidx;
 737
 738         if (!test_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags)) {
 739                 memcpy(&assoc_req->wpa_mcast_key, &adapter->wpa_mcast_key,
 740                         sizeof(struct enc_key));
 741         }
 742
 743         if (!test_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags)) {
 744                 memcpy(&assoc_req->wpa_unicast_key, &adapter->wpa_unicast_key,
 745                         sizeof(struct enc_key));
 746         }
 747
 748         if (!test_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags)) {
 749                 memcpy(&assoc_req->secinfo, &adapter->secinfo,
 750                         sizeof(struct lbs_802_11_security));
 751         }
 752
 753         if (!test_bit(ASSOC_FLAG_WPA_IE, &assoc_req->flags)) {
 754                 memcpy(&assoc_req->wpa_ie, &adapter->wpa_ie,
 755                         MAX_WPA_IE_LEN);
 756                 assoc_req->wpa_ie_len = adapter->wpa_ie_len;
 757         }
 758
 759         lbs_deb_leave(LBS_DEB_ASSOC);
 760         return assoc_req;
 761 }