drivers/net/wireless/iwmc3200wifi/main.c

   1 /*
   2  * Intel Wireless Multicomm 3200 WiFi driver
   3  *
   4  * Copyright (C) 2009 Intel Corporation. All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  *   * Redistributions of source code must retain the above copyright
  11  *     notice, this list of conditions and the following disclaimer.
  12  *   * Redistributions in binary form must reproduce the above copyright
  13  *     notice, this list of conditions and the following disclaimer in
  14  *     the documentation and/or other materials provided with the
  15  *     distribution.
  16  *   * Neither the name of Intel Corporation nor the names of its
  17  *     contributors may be used to endorse or promote products derived
  18  *     from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  *
  33  * Intel Corporation <ilw@linux.intel.com>
  34  * Samuel Ortiz <samuel.ortiz@intel.com>
  35  * Zhu Yi <yi.zhu@intel.com>
  36  *
  37  */
  38
  39 #include <linux/kernel.h>
  40 #include <linux/netdevice.h>
  41 #include <linux/sched.h>
  42 #include <linux/ieee80211.h>
  43 #include <linux/wireless.h>
  44 #include <linux/slab.h>
  45
  46 #include "iwm.h"
  47 #include "debug.h"
  48 #include "bus.h"
  49 #include "umac.h"
  50 #include "commands.h"
  51 #include "hal.h"
  52 #include "fw.h"
  53 #include "rx.h"
  54
  55 static struct iwm_conf def_iwm_conf = {
  56
  57         .sdio_ior_timeout       = 5000,
  58         .calib_map              = BIT(CALIB_CFG_DC_IDX) |
  59                                   BIT(CALIB_CFG_LO_IDX) |
  60                                   BIT(CALIB_CFG_TX_IQ_IDX)      |
  61                                   BIT(CALIB_CFG_RX_IQ_IDX)      |
  62                                   BIT(SHILOH_PHY_CALIBRATE_BASE_BAND_CMD),
  63         .expected_calib_map     = BIT(PHY_CALIBRATE_DC_CMD)     |
  64                                   BIT(PHY_CALIBRATE_LO_CMD)     |
  65                                   BIT(PHY_CALIBRATE_TX_IQ_CMD)  |
  66                                   BIT(PHY_CALIBRATE_RX_IQ_CMD)  |
  67                                   BIT(SHILOH_PHY_CALIBRATE_BASE_BAND_CMD),
  68         .ct_kill_entry          = 110,
  69         .ct_kill_exit           = 110,
  70         .reset_on_fatal_err     = 1,
  71         .auto_connect           = 1,
  72         .enable_qos             = 1,
  73         .mode                   = UMAC_MODE_BSS,
  74
  75         /* UMAC configuration */
  76         .power_index            = 0,
  77         .frag_threshold         = IEEE80211_MAX_FRAG_THRESHOLD,
  78         .rts_threshold          = IEEE80211_MAX_RTS_THRESHOLD,
  79         .cts_to_self            = 0,
  80
  81         .assoc_timeout          = 2,
  82         .roam_timeout           = 10,
  83         .wireless_mode          = WIRELESS_MODE_11A | WIRELESS_MODE_11G |
  84                                   WIRELESS_MODE_11N,
  85
  86         /* IBSS */
  87         .ibss_band              = UMAC_BAND_2GHZ,
  88         .ibss_channel           = 1,
  89
  90         .mac_addr               = {0x00, 0x02, 0xb3, 0x01, 0x02, 0x03},
  91 };
  92
  93 static int modparam_reset;
  94 module_param_named(reset, modparam_reset, bool, 0644);
  95 MODULE_PARM_DESC(reset, "reset on firmware errors (default 0 [not reset])");
  96
  97 static int modparam_wimax_enable = 1;
  98 module_param_named(wimax_enable, modparam_wimax_enable, bool, 0644);
  99 MODULE_PARM_DESC(wimax_enable, "Enable wimax core (default 1 [wimax enabled])");
 100
 101 int iwm_mode_to_nl80211_iftype(int mode)
 102 {
 103         switch (mode) {
 104         case UMAC_MODE_BSS:
 105                 return NL80211_IFTYPE_STATION;
 106         case UMAC_MODE_IBSS:
 107                 return NL80211_IFTYPE_ADHOC;
 108         default:
 109                 return NL80211_IFTYPE_UNSPECIFIED;
 110         }
 111
 112         return 0;
 113 }
 114
 115 static void iwm_statistics_request(struct work_struct *work)
 116 {
 117         struct iwm_priv *iwm =
 118                 container_of(work, struct iwm_priv, stats_request.work);
 119
 120         iwm_send_umac_stats_req(iwm, 0);
 121 }
 122
 123 static void iwm_disconnect_work(struct work_struct *work)
 124 {
 125         struct iwm_priv *iwm =
 126                 container_of(work, struct iwm_priv, disconnect.work);
 127
 128         if (iwm->umac_profile_active)
 129                 iwm_invalidate_mlme_profile(iwm);
 130
 131         clear_bit(IWM_STATUS_ASSOCIATED, &iwm->status);
 132         iwm->umac_profile_active = 0;
 133         memset(iwm->bssid, 0, ETH_ALEN);
 134         iwm->channel = 0;
 135
 136         iwm_link_off(iwm);
 137
 138         wake_up_interruptible(&iwm->mlme_queue);
 139
 140         cfg80211_disconnected(iwm_to_ndev(iwm), 0, NULL, 0, GFP_KERNEL);
 141 }
 142
 143 static void iwm_ct_kill_work(struct work_struct *work)
 144 {
 145         struct iwm_priv *iwm =
 146                 container_of(work, struct iwm_priv, ct_kill_delay.work);
 147         struct wiphy *wiphy = iwm_to_wiphy(iwm);
 148
 149         IWM_INFO(iwm, "CT kill delay timeout\n");
 150
 151         wiphy_rfkill_set_hw_state(wiphy, false);
 152 }
 153
 154 static int __iwm_up(struct iwm_priv *iwm);
 155 static int __iwm_down(struct iwm_priv *iwm);
 156
 157 static void iwm_reset_worker(struct work_struct *work)
 158 {
 159         struct iwm_priv *iwm;
 160         struct iwm_umac_profile *profile = NULL;
 161         int uninitialized_var(ret), retry = 0;
 162
 163         iwm = container_of(work, struct iwm_priv, reset_worker);
 164
 165         /*
 166          * XXX: The iwm->mutex is introduced purely for this reset work,
 167          * because the other users for iwm_up and iwm_down are only netdev
 168          * ndo_open and ndo_stop which are already protected by rtnl.
 169          * Please remove iwm->mutex together if iwm_reset_worker() is not
 170          * required in the future.
 171          */
 172         if (!mutex_trylock(&iwm->mutex)) {
 173                 IWM_WARN(iwm, "We are in the middle of interface bringing "
 174                          "UP/DOWN. Skip driver resetting.\n");
 175                 return;
 176         }
 177
 178         if (iwm->umac_profile_active) {
 179                 profile = kmalloc(sizeof(struct iwm_umac_profile), GFP_KERNEL);
 180                 if (profile)
 181                         memcpy(profile, iwm->umac_profile, sizeof(*profile));
 182                 else
 183                         IWM_ERR(iwm, "Couldn't alloc memory for profile\n");
 184         }
 185
 186         __iwm_down(iwm);
 187
 188         while (retry++ < 3) {
 189                 ret = __iwm_up(iwm);
 190                 if (!ret)
 191                         break;
 192
 193                 schedule_timeout_uninterruptible(10 * HZ);
 194         }
 195
 196         if (ret) {
 197                 IWM_WARN(iwm, "iwm_up() failed: %d\n", ret);
 198
 199                 kfree(profile);
 200                 goto out;
 201         }
 202
 203         if (profile) {
 204                 IWM_DBG_MLME(iwm, DBG, "Resend UMAC profile\n");
 205                 memcpy(iwm->umac_profile, profile, sizeof(*profile));
 206                 iwm_send_mlme_profile(iwm);
 207                 kfree(profile);
 208         } else
 209                 clear_bit(IWM_STATUS_RESETTING, &iwm->status);
 210
 211  out:
 212         mutex_unlock(&iwm->mutex);
 213 }
 214
 215 static void iwm_auth_retry_worker(struct work_struct *work)
 216 {
 217         struct iwm_priv *iwm;
 218         int i, ret;
 219
 220         iwm = container_of(work, struct iwm_priv, auth_retry_worker);
 221         if (iwm->umac_profile_active) {
 222                 ret = iwm_invalidate_mlme_profile(iwm);
 223                 if (ret < 0)
 224                         return;
 225         }
 226
 227         iwm->umac_profile->sec.auth_type = UMAC_AUTH_TYPE_LEGACY_PSK;
 228
 229         ret = iwm_send_mlme_profile(iwm);
 230         if (ret < 0)
 231                 return;
 232
 233         for (i = 0; i < IWM_NUM_KEYS; i++)
 234                 if (iwm->keys[i].key_len)
 235                         iwm_set_key(iwm, 0, &iwm->keys[i]);
 236
 237         iwm_set_tx_key(iwm, iwm->default_key);
 238 }
 239
 240
 241
 242 static void iwm_watchdog(unsigned long data)
 243 {
 244         struct iwm_priv *iwm = (struct iwm_priv *)data;
 245
 246         IWM_WARN(iwm, "Watchdog expired: UMAC stalls!\n");
 247
 248         if (modparam_reset)
 249                 iwm_resetting(iwm);
 250 }
 251
 252 int iwm_priv_init(struct iwm_priv *iwm)
 253 {
 254         int i, j;
 255         char name[32];
 256
 257         iwm->status = 0;
 258         INIT_LIST_HEAD(&iwm->pending_notif);
 259         init_waitqueue_head(&iwm->notif_queue);
 260         init_waitqueue_head(&iwm->nonwifi_queue);
 261         init_waitqueue_head(&iwm->wifi_ntfy_queue);
 262         init_waitqueue_head(&iwm->mlme_queue);
 263         memcpy(&iwm->conf, &def_iwm_conf, sizeof(struct iwm_conf));
 264         spin_lock_init(&iwm->tx_credit.lock);
 265         INIT_LIST_HEAD(&iwm->wifi_pending_cmd);
 266         INIT_LIST_HEAD(&iwm->nonwifi_pending_cmd);
 267         iwm->wifi_seq_num = UMAC_WIFI_SEQ_NUM_BASE;
 268         iwm->nonwifi_seq_num = UMAC_NONWIFI_SEQ_NUM_BASE;
 269         spin_lock_init(&iwm->cmd_lock);
 270         iwm->scan_id = 1;
 271         INIT_DELAYED_WORK(&iwm->stats_request, iwm_statistics_request);
 272         INIT_DELAYED_WORK(&iwm->disconnect, iwm_disconnect_work);
 273         INIT_DELAYED_WORK(&iwm->ct_kill_delay, iwm_ct_kill_work);
 274         INIT_WORK(&iwm->reset_worker, iwm_reset_worker);
 275         INIT_WORK(&iwm->auth_retry_worker, iwm_auth_retry_worker);
 276         INIT_LIST_HEAD(&iwm->bss_list);
 277
 278         skb_queue_head_init(&iwm->rx_list);
 279         INIT_LIST_HEAD(&iwm->rx_tickets);
 280         for (i = 0; i < IWM_RX_ID_HASH; i++)
 281                 INIT_LIST_HEAD(&iwm->rx_packets[i]);
 282
 283         INIT_WORK(&iwm->rx_worker, iwm_rx_worker);
 284
 285         iwm->rx_wq = create_singlethread_workqueue(KBUILD_MODNAME "_rx");
 286         if (!iwm->rx_wq)
 287                 return -EAGAIN;
 288
 289         for (i = 0; i < IWM_TX_QUEUES; i++) {
 290                 INIT_WORK(&iwm->txq[i].worker, iwm_tx_worker);
 291                 snprintf(name, 32, KBUILD_MODNAME "_tx_%d", i);
 292                 iwm->txq[i].id = i;
 293                 iwm->txq[i].wq = create_singlethread_workqueue(name);
 294                 if (!iwm->txq[i].wq)
 295                         return -EAGAIN;
 296
 297                 skb_queue_head_init(&iwm->txq[i].queue);
 298                 skb_queue_head_init(&iwm->txq[i].stopped_queue);
 299                 spin_lock_init(&iwm->txq[i].lock);
 300         }
 301
 302         for (i = 0; i < IWM_NUM_KEYS; i++)
 303                 memset(&iwm->keys[i], 0, sizeof(struct iwm_key));
 304
 305         iwm->default_key = -1;
 306
 307         for (i = 0; i < IWM_STA_TABLE_NUM; i++)
 308                 for (j = 0; j < IWM_UMAC_TID_NR; j++) {
 309                         mutex_init(&iwm->sta_table[i].tid_info[j].mutex);
 310                         iwm->sta_table[i].tid_info[j].stopped = false;
 311                 }
 312
 313         init_timer(&iwm->watchdog);
 314         iwm->watchdog.function = iwm_watchdog;
 315         iwm->watchdog.data = (unsigned long)iwm;
 316         mutex_init(&iwm->mutex);
 317
 318         iwm->last_fw_err = kzalloc(sizeof(struct iwm_fw_error_hdr),
 319                                    GFP_KERNEL);
 320         if (iwm->last_fw_err == NULL)
 321                 return -ENOMEM;
 322
 323         return 0;
 324 }
 325
 326 void iwm_priv_deinit(struct iwm_priv *iwm)
 327 {
 328         int i;
 329
 330         for (i = 0; i < IWM_TX_QUEUES; i++)
 331                 destroy_workqueue(iwm->txq[i].wq);
 332
 333         destroy_workqueue(iwm->rx_wq);
 334         kfree(iwm->last_fw_err);
 335 }
 336
 337 /*
 338  * We reset all the structures, and we reset the UMAC.
 339  * After calling this routine, you're expected to reload
 340  * the firmware.
 341  */
 342 void iwm_reset(struct iwm_priv *iwm)
 343 {
 344         struct iwm_notif *notif, *next;
 345
 346         if (test_bit(IWM_STATUS_READY, &iwm->status))
 347                 iwm_target_reset(iwm);
 348
 349         if (test_bit(IWM_STATUS_RESETTING, &iwm->status)) {
 350                 iwm->status = 0;
 351                 set_bit(IWM_STATUS_RESETTING, &iwm->status);
 352         } else
 353                 iwm->status = 0;
 354         iwm->scan_id = 1;
 355
 356         list_for_each_entry_safe(notif, next, &iwm->pending_notif, pending) {
 357                 list_del(&notif->pending);
 358                 kfree(notif->buf);
 359                 kfree(notif);
 360         }
 361
 362         iwm_cmd_flush(iwm);
 363
 364         flush_workqueue(iwm->rx_wq);
 365
 366         iwm_link_off(iwm);
 367 }
 368
 369 void iwm_resetting(struct iwm_priv *iwm)
 370 {
 371         set_bit(IWM_STATUS_RESETTING, &iwm->status);
 372
 373         schedule_work(&iwm->reset_worker);
 374 }
 375
 376 /*
 377  * Notification code:
 378  *
 379  * We're faced with the following issue: Any host command can
 380  * have an answer or not, and if there's an answer to expect,
 381  * it can be treated synchronously or asynchronously.
 382  * To work around the synchronous answer case, we implemented
 383  * our notification mechanism.
 384  * When a code path needs to wait for a command response
 385  * synchronously, it calls notif_handle(), which waits for the
 386  * right notification to show up, and then process it. Before
 387  * starting to wait, it registered as a waiter for this specific
 388  * answer (by toggling a bit in on of the handler_map), so that
 389  * the rx code knows that it needs to send a notification to the
 390  * waiting processes. It does so by calling iwm_notif_send(),
 391  * which adds the notification to the pending notifications list,
 392  * and then wakes the waiting processes up.
 393  */
 394 int iwm_notif_send(struct iwm_priv *iwm, struct iwm_wifi_cmd *cmd,
 395                    u8 cmd_id, u8 source, u8 *buf, unsigned long buf_size)
 396 {
 397         struct iwm_notif *notif;
 398
 399         notif = kzalloc(sizeof(struct iwm_notif), GFP_KERNEL);
 400         if (!notif) {
 401                 IWM_ERR(iwm, "Couldn't alloc memory for notification\n");
 402                 return -ENOMEM;
 403         }
 404
 405         INIT_LIST_HEAD(&notif->pending);
 406         notif->cmd = cmd;
 407         notif->cmd_id = cmd_id;
 408         notif->src = source;
 409         notif->buf = kzalloc(buf_size, GFP_KERNEL);
 410         if (!notif->buf) {
 411                 IWM_ERR(iwm, "Couldn't alloc notification buffer\n");
 412                 kfree(notif);
 413                 return -ENOMEM;
 414         }
 415         notif->buf_size = buf_size;
 416         memcpy(notif->buf, buf, buf_size);
 417         list_add_tail(&notif->pending, &iwm->pending_notif);
 418
 419         wake_up_interruptible(&iwm->notif_queue);
 420
 421         return 0;
 422 }
 423
 424 static struct iwm_notif *iwm_notif_find(struct iwm_priv *iwm, u32 cmd,
 425                                         u8 source)
 426 {
 427         struct iwm_notif *notif, *next;
 428
 429         list_for_each_entry_safe(notif, next, &iwm->pending_notif, pending) {
 430                 if ((notif->cmd_id == cmd) && (notif->src == source)) {
 431                         list_del(&notif->pending);
 432                         return notif;
 433                 }
 434         }
 435
 436         return NULL;
 437 }
 438
 439 static struct iwm_notif *iwm_notif_wait(struct iwm_priv *iwm, u32 cmd,
 440                                         u8 source, long timeout)
 441 {
 442         int ret;
 443         struct iwm_notif *notif;
 444         unsigned long *map = NULL;
 445
 446         switch (source) {
 447         case IWM_SRC_LMAC:
 448                 map = &iwm->lmac_handler_map[0];
 449                 break;
 450         case IWM_SRC_UMAC:
 451                 map = &iwm->umac_handler_map[0];
 452                 break;
 453         case IWM_SRC_UDMA:
 454                 map = &iwm->udma_handler_map[0];
 455                 break;
 456         }
 457
 458         set_bit(cmd, map);
 459
 460         ret = wait_event_interruptible_timeout(iwm->notif_queue,
 461                          ((notif = iwm_notif_find(iwm, cmd, source)) != NULL),
 462                                                timeout);
 463         clear_bit(cmd, map);
 464
 465         if (!ret)
 466                 return NULL;
 467
 468         return notif;
 469 }
 470
 471 int iwm_notif_handle(struct iwm_priv *iwm, u32 cmd, u8 source, long timeout)
 472 {
 473         int ret;
 474         struct iwm_notif *notif;
 475
 476         notif = iwm_notif_wait(iwm, cmd, source, timeout);
 477         if (!notif)
 478                 return -ETIME;
 479
 480         ret = iwm_rx_handle_resp(iwm, notif->buf, notif->buf_size, notif->cmd);
 481         kfree(notif->buf);
 482         kfree(notif);
 483
 484         return ret;
 485 }
 486
 487 static int iwm_config_boot_params(struct iwm_priv *iwm)
 488 {
 489         struct iwm_udma_nonwifi_cmd target_cmd;
 490         int ret;
 491
 492         /* check Wimax is off and config debug monitor */
 493         if (!modparam_wimax_enable) {
 494                 u32 data1 = 0x1f;
 495                 u32 addr1 = 0x606BE258;
 496
 497                 u32 data2_set = 0x0;
 498                 u32 data2_clr = 0x1;
 499                 u32 addr2 = 0x606BE100;
 500
 501                 u32 data3 = 0x1;
 502                 u32 addr3 = 0x606BEC00;
 503
 504                 target_cmd.resp = 0;
 505                 target_cmd.handle_by_hw = 0;
 506                 target_cmd.eop = 1;
 507
 508                 target_cmd.opcode = UMAC_HDI_OUT_OPCODE_WRITE;
 509                 target_cmd.addr = cpu_to_le32(addr1);
 510                 target_cmd.op1_sz = cpu_to_le32(sizeof(u32));
 511                 target_cmd.op2 = 0;
 512
 513                 ret = iwm_hal_send_target_cmd(iwm, &target_cmd, &data1);
 514                 if (ret < 0) {
 515                         IWM_ERR(iwm, "iwm_hal_send_target_cmd failed\n");
 516                         return ret;
 517                 }
 518
 519                 target_cmd.opcode = UMAC_HDI_OUT_OPCODE_READ_MODIFY_WRITE;
 520                 target_cmd.addr = cpu_to_le32(addr2);
 521                 target_cmd.op1_sz = cpu_to_le32(data2_set);
 522                 target_cmd.op2 = cpu_to_le32(data2_clr);
 523
 524                 ret = iwm_hal_send_target_cmd(iwm, &target_cmd, &data1);
 525                 if (ret < 0) {
 526                         IWM_ERR(iwm, "iwm_hal_send_target_cmd failed\n");
 527                         return ret;
 528                 }
 529
 530                 target_cmd.opcode = UMAC_HDI_OUT_OPCODE_WRITE;
 531                 target_cmd.addr = cpu_to_le32(addr3);
 532                 target_cmd.op1_sz = cpu_to_le32(sizeof(u32));
 533                 target_cmd.op2 = 0;
 534
 535                 ret = iwm_hal_send_target_cmd(iwm, &target_cmd, &data3);
 536                 if (ret < 0) {
 537                         IWM_ERR(iwm, "iwm_hal_send_target_cmd failed\n");
 538                         return ret;
 539                 }
 540         }
 541
 542         return 0;
 543 }
 544
 545 void iwm_init_default_profile(struct iwm_priv *iwm,
 546                               struct iwm_umac_profile *profile)
 547 {
 548         memset(profile, 0, sizeof(struct iwm_umac_profile));
 549
 550         profile->sec.auth_type = UMAC_AUTH_TYPE_OPEN;
 551         profile->sec.flags = UMAC_SEC_FLG_LEGACY_PROFILE;
 552         profile->sec.ucast_cipher = UMAC_CIPHER_TYPE_NONE;
 553         profile->sec.mcast_cipher = UMAC_CIPHER_TYPE_NONE;
 554
 555         if (iwm->conf.enable_qos)
 556                 profile->flags |= cpu_to_le16(UMAC_PROFILE_QOS_ALLOWED);
 557
 558         profile->wireless_mode = iwm->conf.wireless_mode;
 559         profile->mode = cpu_to_le32(iwm->conf.mode);
 560
 561         profile->ibss.atim = 0;
 562         profile->ibss.beacon_interval = 100;
 563         profile->ibss.join_only = 0;
 564         profile->ibss.band = iwm->conf.ibss_band;
 565         profile->ibss.channel = iwm->conf.ibss_channel;
 566 }
 567
 568 void iwm_link_on(struct iwm_priv *iwm)
 569 {
 570         netif_carrier_on(iwm_to_ndev(iwm));
 571         netif_tx_wake_all_queues(iwm_to_ndev(iwm));
 572
 573         iwm_send_umac_stats_req(iwm, 0);
 574 }
 575
 576 void iwm_link_off(struct iwm_priv *iwm)
 577 {
 578         struct iw_statistics *wstats = &iwm->wstats;
 579         int i;
 580
 581         netif_tx_stop_all_queues(iwm_to_ndev(iwm));
 582         netif_carrier_off(iwm_to_ndev(iwm));
 583
 584         for (i = 0; i < IWM_TX_QUEUES; i++) {
 585                 skb_queue_purge(&iwm->txq[i].queue);
 586                 skb_queue_purge(&iwm->txq[i].stopped_queue);
 587
 588                 iwm->txq[i].concat_count = 0;
 589                 iwm->txq[i].concat_ptr = iwm->txq[i].concat_buf;
 590
 591                 flush_workqueue(iwm->txq[i].wq);
 592         }
 593
 594         iwm_rx_free(iwm);
 595
 596         cancel_delayed_work_sync(&iwm->stats_request);
 597         memset(wstats, 0, sizeof(struct iw_statistics));
 598         wstats->qual.updated = IW_QUAL_ALL_INVALID;
 599
 600         kfree(iwm->req_ie);
 601         iwm->req_ie = NULL;
 602         iwm->req_ie_len = 0;
 603         kfree(iwm->resp_ie);
 604         iwm->resp_ie = NULL;
 605         iwm->resp_ie_len = 0;
 606
 607         del_timer_sync(&iwm->watchdog);
 608 }
 609
 610 static void iwm_bss_list_clean(struct iwm_priv *iwm)
 611 {
 612         struct iwm_bss_info *bss, *next;
 613
 614         list_for_each_entry_safe(bss, next, &iwm->bss_list, node) {
 615                 list_del(&bss->node);
 616                 kfree(bss->bss);
 617                 kfree(bss);
 618         }
 619 }
 620
 621 static int iwm_channels_init(struct iwm_priv *iwm)
 622 {
 623         int ret;
 624
 625         ret = iwm_send_umac_channel_list(iwm);
 626         if (ret) {
 627                 IWM_ERR(iwm, "Send channel list failed\n");
 628                 return ret;
 629         }
 630
 631         ret = iwm_notif_handle(iwm, UMAC_CMD_OPCODE_GET_CHAN_INFO_LIST,
 632                                IWM_SRC_UMAC, WAIT_NOTIF_TIMEOUT);
 633         if (ret) {
 634                 IWM_ERR(iwm, "Didn't get a channel list notification\n");
 635                 return ret;
 636         }
 637
 638         return 0;
 639 }
 640
 641 static int __iwm_up(struct iwm_priv *iwm)
 642 {
 643         int ret;
 644         struct iwm_notif *notif_reboot, *notif_ack = NULL;
 645         struct wiphy *wiphy = iwm_to_wiphy(iwm);
 646         u32 wireless_mode;
 647
 648         ret = iwm_bus_enable(iwm);
 649         if (ret) {
 650                 IWM_ERR(iwm, "Couldn't enable function\n");
 651                 return ret;
 652         }
 653
 654         iwm_rx_setup_handlers(iwm);
 655
 656         /* Wait for initial BARKER_REBOOT from hardware */
 657         notif_reboot = iwm_notif_wait(iwm, IWM_BARKER_REBOOT_NOTIFICATION,
 658                                       IWM_SRC_UDMA, 2 * HZ);
 659         if (!notif_reboot) {
 660                 IWM_ERR(iwm, "Wait for REBOOT_BARKER timeout\n");
 661                 goto err_disable;
 662         }
 663
 664         /* We send the barker back */
 665         ret = iwm_bus_send_chunk(iwm, notif_reboot->buf, 16);
 666         if (ret) {
 667                 IWM_ERR(iwm, "REBOOT barker response failed\n");
 668                 kfree(notif_reboot);
 669                 goto err_disable;
 670         }
 671
 672         kfree(notif_reboot->buf);
 673         kfree(notif_reboot);
 674
 675         /* Wait for ACK_BARKER from hardware */
 676         notif_ack = iwm_notif_wait(iwm, IWM_ACK_BARKER_NOTIFICATION,
 677                                    IWM_SRC_UDMA, 2 * HZ);
 678         if (!notif_ack) {
 679                 IWM_ERR(iwm, "Wait for ACK_BARKER timeout\n");
 680                 goto err_disable;
 681         }
 682
 683         kfree(notif_ack->buf);
 684         kfree(notif_ack);
 685
 686         /* We start to config static boot parameters */
 687         ret = iwm_config_boot_params(iwm);
 688         if (ret) {
 689                 IWM_ERR(iwm, "Config boot parameters failed\n");
 690                 goto err_disable;
 691         }
 692
 693         ret = iwm_read_mac(iwm, iwm_to_ndev(iwm)->dev_addr);
 694         if (ret) {
 695                 IWM_ERR(iwm, "MAC reading failed\n");
 696                 goto err_disable;
 697         }
 698         memcpy(iwm_to_ndev(iwm)->perm_addr, iwm_to_ndev(iwm)->dev_addr,
 699                 ETH_ALEN);
 700
 701         /* We can load the FWs */
 702         ret = iwm_load_fw(iwm);
 703         if (ret) {
 704                 IWM_ERR(iwm, "FW loading failed\n");
 705                 goto err_disable;
 706         }
 707
 708         ret = iwm_eeprom_fat_channels(iwm);
 709         if (ret) {
 710                 IWM_ERR(iwm, "Couldnt read HT channels EEPROM entries\n");
 711                 goto err_fw;
 712         }
 713
 714         /*
 715          * Read our SKU capabilities.
 716          * If it's valid, we AND the configured wireless mode with the
 717          * device EEPROM value as the current profile wireless mode.
 718          */
 719         wireless_mode = iwm_eeprom_wireless_mode(iwm);
 720         if (wireless_mode) {
 721                 iwm->conf.wireless_mode &= wireless_mode;
 722                 if (iwm->umac_profile)
 723                         iwm->umac_profile->wireless_mode =
 724                                         iwm->conf.wireless_mode;
 725         } else
 726                 IWM_ERR(iwm, "Wrong SKU capabilities: 0x%x\n",
 727                         *((u16 *)iwm_eeprom_access(iwm, IWM_EEPROM_SKU_CAP)));
 728
 729         snprintf(wiphy->fw_version, sizeof(wiphy->fw_version), "L%s_U%s",
 730                  iwm->lmac_version, iwm->umac_version);
 731
 732         /* We configure the UMAC and enable the wifi module */
 733         ret = iwm_send_umac_config(iwm,
 734                         cpu_to_le32(UMAC_RST_CTRL_FLG_WIFI_CORE_EN) |
 735                         cpu_to_le32(UMAC_RST_CTRL_FLG_WIFI_LINK_EN) |
 736                         cpu_to_le32(UMAC_RST_CTRL_FLG_WIFI_MLME_EN));
 737         if (ret) {
 738                 IWM_ERR(iwm, "UMAC config failed\n");
 739                 goto err_fw;
 740         }
 741
 742         ret = iwm_notif_handle(iwm, UMAC_NOTIFY_OPCODE_WIFI_CORE_STATUS,
 743                                IWM_SRC_UMAC, WAIT_NOTIF_TIMEOUT);
 744         if (ret) {
 745                 IWM_ERR(iwm, "Didn't get a wifi core status notification\n");
 746                 goto err_fw;
 747         }
 748
 749         if (iwm->core_enabled != (UMAC_NTFY_WIFI_CORE_STATUS_LINK_EN |
 750                                   UMAC_NTFY_WIFI_CORE_STATUS_MLME_EN)) {
 751                 IWM_DBG_BOOT(iwm, DBG, "Not all cores enabled:0x%x\n",
 752                              iwm->core_enabled);
 753                 ret = iwm_notif_handle(iwm, UMAC_NOTIFY_OPCODE_WIFI_CORE_STATUS,
 754                                IWM_SRC_UMAC, WAIT_NOTIF_TIMEOUT);
 755                 if (ret) {
 756                         IWM_ERR(iwm, "Didn't get a core status notification\n");
 757                         goto err_fw;
 758                 }
 759
 760                 if (iwm->core_enabled != (UMAC_NTFY_WIFI_CORE_STATUS_LINK_EN |
 761                                           UMAC_NTFY_WIFI_CORE_STATUS_MLME_EN)) {
 762                         IWM_ERR(iwm, "Not all cores enabled: 0x%x\n",
 763                                 iwm->core_enabled);
 764                         goto err_fw;
 765                 } else {
 766                         IWM_INFO(iwm, "All cores enabled\n");
 767                 }
 768         }
 769
 770         ret = iwm_channels_init(iwm);
 771         if (ret < 0) {
 772                 IWM_ERR(iwm, "Couldn't init channels\n");
 773                 goto err_fw;
 774         }
 775
 776         /* Set the READY bit to indicate interface is brought up successfully */
 777         set_bit(IWM_STATUS_READY, &iwm->status);
 778
 779         return 0;
 780
 781  err_fw:
 782         iwm_eeprom_exit(iwm);
 783
 784  err_disable:
 785         ret = iwm_bus_disable(iwm);
 786         if (ret < 0)
 787                 IWM_ERR(iwm, "Couldn't disable function\n");
 788
 789         return -EIO;
 790 }
 791
 792 int iwm_up(struct iwm_priv *iwm)
 793 {
 794         int ret;
 795
 796         mutex_lock(&iwm->mutex);
 797         ret = __iwm_up(iwm);
 798         mutex_unlock(&iwm->mutex);
 799
 800         return ret;
 801 }
 802
 803 static int __iwm_down(struct iwm_priv *iwm)
 804 {
 805         int ret;
 806
 807         /* The interface is already down */
 808         if (!test_bit(IWM_STATUS_READY, &iwm->status))
 809                 return 0;
 810
 811         if (iwm->scan_request) {
 812                 cfg80211_scan_done(iwm->scan_request, true);
 813                 iwm->scan_request = NULL;
 814         }
 815
 816         clear_bit(IWM_STATUS_READY, &iwm->status);
 817
 818         iwm_eeprom_exit(iwm);
 819         iwm_bss_list_clean(iwm);
 820         iwm_init_default_profile(iwm, iwm->umac_profile);
 821         iwm->umac_profile_active = false;
 822         iwm->default_key = -1;
 823         iwm->core_enabled = 0;
 824
 825         ret = iwm_bus_disable(iwm);
 826         if (ret < 0) {
 827                 IWM_ERR(iwm, "Couldn't disable function\n");
 828                 return ret;
 829         }
 830
 831         return 0;
 832 }
 833
 834 int iwm_down(struct iwm_priv *iwm)
 835 {
 836         int ret;
 837
 838         mutex_lock(&iwm->mutex);
 839         ret = __iwm_down(iwm);
 840         mutex_unlock(&iwm->mutex);
 841
 842         return ret;
 843 }