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