drivers/net/wireless/wl12xx/wl1271_main.c

   1 /*
   2  * This file is part of wl1271
   3  *
   4  * Copyright (C) 2008-2010 Nokia Corporation
   5  *
   6  * Contact: Luciano Coelho <luciano.coelho@nokia.com>
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * version 2 as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  20  * 02110-1301 USA
  21  *
  22  */
  23
  24 #include <linux/module.h>
  25 #include <linux/firmware.h>
  26 #include <linux/delay.h>
  27 #include <linux/spi/spi.h>
  28 #include <linux/crc32.h>
  29 #include <linux/etherdevice.h>
  30 #include <linux/vmalloc.h>
  31 #include <linux/platform_device.h>
  32 #include <linux/slab.h>
  33
  34 #include "wl1271.h"
  35 #include "wl12xx_80211.h"
  36 #include "wl1271_reg.h"
  37 #include "wl1271_io.h"
  38 #include "wl1271_event.h"
  39 #include "wl1271_tx.h"
  40 #include "wl1271_rx.h"
  41 #include "wl1271_ps.h"
  42 #include "wl1271_init.h"
  43 #include "wl1271_debugfs.h"
  44 #include "wl1271_cmd.h"
  45 #include "wl1271_boot.h"
  46 #include "wl1271_testmode.h"
  47 #include "wl1271_scan.h"
  48
  49 #define WL1271_BOOT_RETRIES 3
  50
  51 static struct conf_drv_settings default_conf = {
  52         .sg = {
  53                 .params = {
  54                         [CONF_SG_BT_PER_THRESHOLD]                  = 7500,
  55                         [CONF_SG_HV3_MAX_OVERRIDE]                  = 0,
  56                         [CONF_SG_BT_NFS_SAMPLE_INTERVAL]            = 400,
  57                         [CONF_SG_BT_LOAD_RATIO]                     = 50,
  58                         [CONF_SG_AUTO_PS_MODE]                      = 1,
  59                         [CONF_SG_AUTO_SCAN_PROBE_REQ]               = 170,
  60                         [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3]   = 50,
  61                         [CONF_SG_ANTENNA_CONFIGURATION]             = 0,
  62                         [CONF_SG_BEACON_MISS_PERCENT]               = 60,
  63                         [CONF_SG_RATE_ADAPT_THRESH]                 = 12,
  64                         [CONF_SG_RATE_ADAPT_SNR]                    = 0,
  65                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR]      = 10,
  66                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR]      = 30,
  67                         [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR]      = 8,
  68                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR]       = 20,
  69                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR]       = 50,
  70                         /* Note: with UPSD, this should be 4 */
  71                         [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR]       = 8,
  72                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR]     = 7,
  73                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR]     = 25,
  74                         [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR]     = 20,
  75                         /* Note: with UPDS, this should be 15 */
  76                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR]      = 8,
  77                         /* Note: with UPDS, this should be 50 */
  78                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR]      = 40,
  79                         /* Note: with UPDS, this should be 10 */
  80                         [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR]      = 20,
  81                         [CONF_SG_RXT]                               = 1200,
  82                         [CONF_SG_TXT]                               = 1000,
  83                         [CONF_SG_ADAPTIVE_RXT_TXT]                  = 1,
  84                         [CONF_SG_PS_POLL_TIMEOUT]                   = 10,
  85                         [CONF_SG_UPSD_TIMEOUT]                      = 10,
  86                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
  87                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
  88                         [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
  89                         [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR]  = 8,
  90                         [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR]  = 20,
  91                         [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR]  = 15,
  92                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR]         = 20,
  93                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR]         = 50,
  94                         [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR]         = 10,
  95                         [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3]  = 200,
  96                         [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
  97                         [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME]         = 75,
  98                         [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME]       = 15,
  99                         [CONF_SG_HV3_MAX_SERVED]                    = 6,
 100                         [CONF_SG_DHCP_TIME]                         = 5000,
 101                         [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP]  = 100,
 102                 },
 103                 .state = CONF_SG_PROTECTIVE,
 104         },
 105         .rx = {
 106                 .rx_msdu_life_time           = 512000,
 107                 .packet_detection_threshold  = 0,
 108                 .ps_poll_timeout             = 15,
 109                 .upsd_timeout                = 15,
 110                 .rts_threshold               = 2347,
 111                 .rx_cca_threshold            = 0,
 112                 .irq_blk_threshold           = 0xFFFF,
 113                 .irq_pkt_threshold           = 0,
 114                 .irq_timeout                 = 600,
 115                 .queue_type                  = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
 116         },
 117         .tx = {
 118                 .tx_energy_detection         = 0,
 119                 .rc_conf                     = {
 120                         .enabled_rates       = 0,
 121                         .short_retry_limit   = 10,
 122                         .long_retry_limit    = 10,
 123                         .aflags              = 0
 124                 },
 125                 .ac_conf_count               = 4,
 126                 .ac_conf                     = {
 127                         [CONF_TX_AC_BE] = {
 128                                 .ac          = CONF_TX_AC_BE,
 129                                 .cw_min      = 15,
 130                                 .cw_max      = 63,
 131                                 .aifsn       = 3,
 132                                 .tx_op_limit = 0,
 133                         },
 134                         [CONF_TX_AC_BK] = {
 135                                 .ac          = CONF_TX_AC_BK,
 136                                 .cw_min      = 15,
 137                                 .cw_max      = 63,
 138                                 .aifsn       = 7,
 139                                 .tx_op_limit = 0,
 140                         },
 141                         [CONF_TX_AC_VI] = {
 142                                 .ac          = CONF_TX_AC_VI,
 143                                 .cw_min      = 15,
 144                                 .cw_max      = 63,
 145                                 .aifsn       = CONF_TX_AIFS_PIFS,
 146                                 .tx_op_limit = 3008,
 147                         },
 148                         [CONF_TX_AC_VO] = {
 149                                 .ac          = CONF_TX_AC_VO,
 150                                 .cw_min      = 15,
 151                                 .cw_max      = 63,
 152                                 .aifsn       = CONF_TX_AIFS_PIFS,
 153                                 .tx_op_limit = 1504,
 154                         },
 155                 },
 156                 .tid_conf_count = 4,
 157                 .tid_conf = {
 158                         [CONF_TX_AC_BE] = {
 159                                 .queue_id    = CONF_TX_AC_BE,
 160                                 .channel_type = CONF_CHANNEL_TYPE_EDCF,
 161                                 .tsid        = CONF_TX_AC_BE,
 162                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
 163                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
 164                                 .apsd_conf   = {0, 0},
 165                         },
 166                         [CONF_TX_AC_BK] = {
 167                                 .queue_id    = CONF_TX_AC_BK,
 168                                 .channel_type = CONF_CHANNEL_TYPE_EDCF,
 169                                 .tsid        = CONF_TX_AC_BK,
 170                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
 171                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
 172                                 .apsd_conf   = {0, 0},
 173                         },
 174                         [CONF_TX_AC_VI] = {
 175                                 .queue_id    = CONF_TX_AC_VI,
 176                                 .channel_type = CONF_CHANNEL_TYPE_EDCF,
 177                                 .tsid        = CONF_TX_AC_VI,
 178                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
 179                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
 180                                 .apsd_conf   = {0, 0},
 181                         },
 182                         [CONF_TX_AC_VO] = {
 183                                 .queue_id    = CONF_TX_AC_VO,
 184                                 .channel_type = CONF_CHANNEL_TYPE_EDCF,
 185                                 .tsid        = CONF_TX_AC_VO,
 186                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
 187                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
 188                                 .apsd_conf   = {0, 0},
 189                         },
 190                 },
 191                 .frag_threshold              = IEEE80211_MAX_FRAG_THRESHOLD,
 192                 .tx_compl_timeout            = 700,
 193                 .tx_compl_threshold          = 4,
 194                 .basic_rate                  = CONF_HW_BIT_RATE_1MBPS,
 195                 .basic_rate_5                = CONF_HW_BIT_RATE_6MBPS,
 196         },
 197         .conn = {
 198                 .wake_up_event               = CONF_WAKE_UP_EVENT_DTIM,
 199                 .listen_interval             = 1,
 200                 .bcn_filt_mode               = CONF_BCN_FILT_MODE_ENABLED,
 201                 .bcn_filt_ie_count           = 1,
 202                 .bcn_filt_ie = {
 203                         [0] = {
 204                                 .ie          = WLAN_EID_CHANNEL_SWITCH,
 205                                 .rule        = CONF_BCN_RULE_PASS_ON_APPEARANCE,
 206                         }
 207                 },
 208                 .synch_fail_thold            = 10,
 209                 .bss_lose_timeout            = 100,
 210                 .beacon_rx_timeout           = 10000,
 211                 .broadcast_timeout           = 20000,
 212                 .rx_broadcast_in_ps          = 1,
 213                 .ps_poll_threshold           = 10,
 214                 .ps_poll_recovery_period     = 700,
 215                 .bet_enable                  = CONF_BET_MODE_ENABLE,
 216                 .bet_max_consecutive         = 10,
 217                 .psm_entry_retries           = 3,
 218                 .keep_alive_interval         = 55000,
 219                 .max_listen_interval         = 20,
 220         },
 221         .itrim = {
 222                 .enable = false,
 223                 .timeout = 50000,
 224         },
 225         .pm_config = {
 226                 .host_clk_settling_time = 5000,
 227                 .host_fast_wakeup_support = false
 228         },
 229         .roam_trigger = {
 230                 .trigger_pacing               = 1,
 231                 .avg_weight_rssi_beacon       = 20,
 232                 .avg_weight_rssi_data         = 10,
 233                 .avg_weight_snr_beacon        = 20,
 234                 .avg_weight_snr_data          = 10
 235         }
 236 };
 237
 238 static void wl1271_device_release(struct device *dev)
 239 {
 240
 241 }
 242
 243 static struct platform_device wl1271_device = {
 244         .name           = "wl1271",
 245         .id             = -1,
 246
 247         /* device model insists to have a release function */
 248         .dev            = {
 249                 .release = wl1271_device_release,
 250         },
 251 };
 252
 253 static LIST_HEAD(wl_list);
 254
 255 static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
 256                              void *arg)
 257 {
 258         struct net_device *dev = arg;
 259         struct wireless_dev *wdev;
 260         struct wiphy *wiphy;
 261         struct ieee80211_hw *hw;
 262         struct wl1271 *wl;
 263         struct wl1271 *wl_temp;
 264         int ret = 0;
 265
 266         /* Check that this notification is for us. */
 267         if (what != NETDEV_CHANGE)
 268                 return NOTIFY_DONE;
 269
 270         wdev = dev->ieee80211_ptr;
 271         if (wdev == NULL)
 272                 return NOTIFY_DONE;
 273
 274         wiphy = wdev->wiphy;
 275         if (wiphy == NULL)
 276                 return NOTIFY_DONE;
 277
 278         hw = wiphy_priv(wiphy);
 279         if (hw == NULL)
 280                 return NOTIFY_DONE;
 281
 282         wl_temp = hw->priv;
 283         list_for_each_entry(wl, &wl_list, list) {
 284                 if (wl == wl_temp)
 285                         break;
 286         }
 287         if (wl != wl_temp)
 288                 return NOTIFY_DONE;
 289
 290         mutex_lock(&wl->mutex);
 291
 292         if (wl->state == WL1271_STATE_OFF)
 293                 goto out;
 294
 295         if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
 296                 goto out;
 297
 298         ret = wl1271_ps_elp_wakeup(wl, false);
 299         if (ret < 0)
 300                 goto out;
 301
 302         if ((dev->operstate == IF_OPER_UP) &&
 303             !test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags)) {
 304                 wl1271_cmd_set_sta_state(wl);
 305                 wl1271_info("Association completed.");
 306         }
 307
 308         wl1271_ps_elp_sleep(wl);
 309
 310 out:
 311         mutex_unlock(&wl->mutex);
 312
 313         return NOTIFY_OK;
 314 }
 315
 316 static void wl1271_conf_init(struct wl1271 *wl)
 317 {
 318
 319         /*
 320          * This function applies the default configuration to the driver. This
 321          * function is invoked upon driver load (spi probe.)
 322          *
 323          * The configuration is stored in a run-time structure in order to
 324          * facilitate for run-time adjustment of any of the parameters. Making
 325          * changes to the configuration structure will apply the new values on
 326          * the next interface up (wl1271_op_start.)
 327          */
 328
 329         /* apply driver default configuration */
 330         memcpy(&wl->conf, &default_conf, sizeof(default_conf));
 331 }
 332
 333
 334 static int wl1271_plt_init(struct wl1271 *wl)
 335 {
 336         struct conf_tx_ac_category *conf_ac;
 337         struct conf_tx_tid *conf_tid;
 338         int ret, i;
 339
 340         ret = wl1271_cmd_general_parms(wl);
 341         if (ret < 0)
 342                 return ret;
 343
 344         ret = wl1271_cmd_radio_parms(wl);
 345         if (ret < 0)
 346                 return ret;
 347
 348         ret = wl1271_init_templates_config(wl);
 349         if (ret < 0)
 350                 return ret;
 351
 352         ret = wl1271_acx_init_mem_config(wl);
 353         if (ret < 0)
 354                 return ret;
 355
 356         /* PHY layer config */
 357         ret = wl1271_init_phy_config(wl);
 358         if (ret < 0)
 359                 goto out_free_memmap;
 360
 361         ret = wl1271_acx_dco_itrim_params(wl);
 362         if (ret < 0)
 363                 goto out_free_memmap;
 364
 365         /* Initialize connection monitoring thresholds */
 366         ret = wl1271_acx_conn_monit_params(wl, false);
 367         if (ret < 0)
 368                 goto out_free_memmap;
 369
 370         /* Bluetooth WLAN coexistence */
 371         ret = wl1271_init_pta(wl);
 372         if (ret < 0)
 373                 goto out_free_memmap;
 374
 375         /* Energy detection */
 376         ret = wl1271_init_energy_detection(wl);
 377         if (ret < 0)
 378                 goto out_free_memmap;
 379
 380         /* Default fragmentation threshold */
 381         ret = wl1271_acx_frag_threshold(wl);
 382         if (ret < 0)
 383                 goto out_free_memmap;
 384
 385         /* Default TID/AC configuration */
 386         BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count);
 387         for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
 388                 conf_ac = &wl->conf.tx.ac_conf[i];
 389                 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
 390                                         conf_ac->cw_max, conf_ac->aifsn,
 391                                         conf_ac->tx_op_limit);
 392                 if (ret < 0)
 393                         goto out_free_memmap;
 394
 395                 conf_tid = &wl->conf.tx.tid_conf[i];
 396                 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
 397                                          conf_tid->channel_type,
 398                                          conf_tid->tsid,
 399                                          conf_tid->ps_scheme,
 400                                          conf_tid->ack_policy,
 401                                          conf_tid->apsd_conf[0],
 402                                          conf_tid->apsd_conf[1]);
 403                 if (ret < 0)
 404                         goto out_free_memmap;
 405         }
 406
 407         /* Enable data path */
 408         ret = wl1271_cmd_data_path(wl, 1);
 409         if (ret < 0)
 410                 goto out_free_memmap;
 411
 412         /* Configure for CAM power saving (ie. always active) */
 413         ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
 414         if (ret < 0)
 415                 goto out_free_memmap;
 416
 417         /* configure PM */
 418         ret = wl1271_acx_pm_config(wl);
 419         if (ret < 0)
 420                 goto out_free_memmap;
 421
 422         return 0;
 423
 424  out_free_memmap:
 425         kfree(wl->target_mem_map);
 426         wl->target_mem_map = NULL;
 427
 428         return ret;
 429 }
 430
 431 static void wl1271_fw_status(struct wl1271 *wl,
 432                              struct wl1271_fw_status *status)
 433 {
 434         struct timespec ts;
 435         u32 total = 0;
 436         int i;
 437
 438         wl1271_raw_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
 439
 440         wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
 441                      "drv_rx_counter = %d, tx_results_counter = %d)",
 442                      status->intr,
 443                      status->fw_rx_counter,
 444                      status->drv_rx_counter,
 445                      status->tx_results_counter);
 446
 447         /* update number of available TX blocks */
 448         for (i = 0; i < NUM_TX_QUEUES; i++) {
 449                 u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
 450                         wl->tx_blocks_freed[i];
 451
 452                 wl->tx_blocks_freed[i] =
 453                         le32_to_cpu(status->tx_released_blks[i]);
 454                 wl->tx_blocks_available += cnt;
 455                 total += cnt;
 456         }
 457
 458         /* if more blocks are available now, schedule some tx work */
 459         if (total && !skb_queue_empty(&wl->tx_queue))
 460                 ieee80211_queue_work(wl->hw, &wl->tx_work);
 461
 462         /* update the host-chipset time offset */
 463         getnstimeofday(&ts);
 464         wl->time_offset = (timespec_to_ns(&ts) >> 10) -
 465                 (s64)le32_to_cpu(status->fw_localtime);
 466 }
 467
 468 #define WL1271_IRQ_MAX_LOOPS 10
 469
 470 static void wl1271_irq_work(struct work_struct *work)
 471 {
 472         int ret;
 473         u32 intr;
 474         int loopcount = WL1271_IRQ_MAX_LOOPS;
 475         unsigned long flags;
 476         struct wl1271 *wl =
 477                 container_of(work, struct wl1271, irq_work);
 478
 479         mutex_lock(&wl->mutex);
 480
 481         wl1271_debug(DEBUG_IRQ, "IRQ work");
 482
 483         if (unlikely(wl->state == WL1271_STATE_OFF))
 484                 goto out;
 485
 486         ret = wl1271_ps_elp_wakeup(wl, true);
 487         if (ret < 0)
 488                 goto out;
 489
 490         spin_lock_irqsave(&wl->wl_lock, flags);
 491         while (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags) && loopcount) {
 492                 clear_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
 493                 spin_unlock_irqrestore(&wl->wl_lock, flags);
 494                 loopcount--;
 495
 496                 wl1271_fw_status(wl, wl->fw_status);
 497                 intr = le32_to_cpu(wl->fw_status->intr);
 498                 if (!intr) {
 499                         wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
 500                         spin_lock_irqsave(&wl->wl_lock, flags);
 501                         continue;
 502                 }
 503
 504                 intr &= WL1271_INTR_MASK;
 505
 506                 if (intr & WL1271_ACX_INTR_DATA) {
 507                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
 508
 509                         /* check for tx results */
 510                         if (wl->fw_status->tx_results_counter !=
 511                             (wl->tx_results_count & 0xff))
 512                                 wl1271_tx_complete(wl);
 513
 514                         wl1271_rx(wl, wl->fw_status);
 515                 }
 516
 517                 if (intr & WL1271_ACX_INTR_EVENT_A) {
 518                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
 519                         wl1271_event_handle(wl, 0);
 520                 }
 521
 522                 if (intr & WL1271_ACX_INTR_EVENT_B) {
 523                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
 524                         wl1271_event_handle(wl, 1);
 525                 }
 526
 527                 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
 528                         wl1271_debug(DEBUG_IRQ,
 529                                      "WL1271_ACX_INTR_INIT_COMPLETE");
 530
 531                 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
 532                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
 533
 534                 spin_lock_irqsave(&wl->wl_lock, flags);
 535         }
 536
 537         if (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags))
 538                 ieee80211_queue_work(wl->hw, &wl->irq_work);
 539         else
 540                 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
 541         spin_unlock_irqrestore(&wl->wl_lock, flags);
 542
 543         wl1271_ps_elp_sleep(wl);
 544
 545 out:
 546         mutex_unlock(&wl->mutex);
 547 }
 548
 549 static int wl1271_fetch_firmware(struct wl1271 *wl)
 550 {
 551         const struct firmware *fw;
 552         int ret;
 553
 554         ret = request_firmware(&fw, WL1271_FW_NAME, wl1271_wl_to_dev(wl));
 555
 556         if (ret < 0) {
 557                 wl1271_error("could not get firmware: %d", ret);
 558                 return ret;
 559         }
 560
 561         if (fw->size % 4) {
 562                 wl1271_error("firmware size is not multiple of 32 bits: %zu",
 563                              fw->size);
 564                 ret = -EILSEQ;
 565                 goto out;
 566         }
 567
 568         wl->fw_len = fw->size;
 569         wl->fw = vmalloc(wl->fw_len);
 570
 571         if (!wl->fw) {
 572                 wl1271_error("could not allocate memory for the firmware");
 573                 ret = -ENOMEM;
 574                 goto out;
 575         }
 576
 577         memcpy(wl->fw, fw->data, wl->fw_len);
 578
 579         ret = 0;
 580
 581 out:
 582         release_firmware(fw);
 583
 584         return ret;
 585 }
 586
 587 static int wl1271_fetch_nvs(struct wl1271 *wl)
 588 {
 589         const struct firmware *fw;
 590         int ret;
 591
 592         ret = request_firmware(&fw, WL1271_NVS_NAME, wl1271_wl_to_dev(wl));
 593
 594         if (ret < 0) {
 595                 wl1271_error("could not get nvs file: %d", ret);
 596                 return ret;
 597         }
 598
 599         wl->nvs = kmemdup(fw->data, sizeof(struct wl1271_nvs_file), GFP_KERNEL);
 600
 601         if (!wl->nvs) {
 602                 wl1271_error("could not allocate memory for the nvs file");
 603                 ret = -ENOMEM;
 604                 goto out;
 605         }
 606
 607         wl->nvs_len = fw->size;
 608
 609 out:
 610         release_firmware(fw);
 611
 612         return ret;
 613 }
 614
 615 static void wl1271_fw_wakeup(struct wl1271 *wl)
 616 {
 617         u32 elp_reg;
 618
 619         elp_reg = ELPCTRL_WAKE_UP;
 620         wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
 621 }
 622
 623 static int wl1271_setup(struct wl1271 *wl)
 624 {
 625         wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
 626         if (!wl->fw_status)
 627                 return -ENOMEM;
 628
 629         wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
 630         if (!wl->tx_res_if) {
 631                 kfree(wl->fw_status);
 632                 return -ENOMEM;
 633         }
 634
 635         INIT_WORK(&wl->irq_work, wl1271_irq_work);
 636         INIT_WORK(&wl->tx_work, wl1271_tx_work);
 637         INIT_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
 638
 639         return 0;
 640 }
 641
 642 static int wl1271_chip_wakeup(struct wl1271 *wl)
 643 {
 644         struct wl1271_partition_set partition;
 645         int ret = 0;
 646
 647         msleep(WL1271_PRE_POWER_ON_SLEEP);
 648         ret = wl1271_power_on(wl);
 649         if (ret < 0)
 650                 goto out;
 651         msleep(WL1271_POWER_ON_SLEEP);
 652         wl1271_io_reset(wl);
 653         wl1271_io_init(wl);
 654
 655         /* We don't need a real memory partition here, because we only want
 656          * to use the registers at this point. */
 657         memset(&partition, 0, sizeof(partition));
 658         partition.reg.start = REGISTERS_BASE;
 659         partition.reg.size = REGISTERS_DOWN_SIZE;
 660         wl1271_set_partition(wl, &partition);
 661
 662         /* ELP module wake up */
 663         wl1271_fw_wakeup(wl);
 664
 665         /* whal_FwCtrl_BootSm() */
 666
 667         /* 0. read chip id from CHIP_ID */
 668         wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
 669
 670         /* 1. check if chip id is valid */
 671
 672         switch (wl->chip.id) {
 673         case CHIP_ID_1271_PG10:
 674                 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
 675                                wl->chip.id);
 676
 677                 ret = wl1271_setup(wl);
 678                 if (ret < 0)
 679                         goto out;
 680                 break;
 681         case CHIP_ID_1271_PG20:
 682                 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
 683                              wl->chip.id);
 684
 685                 ret = wl1271_setup(wl);
 686                 if (ret < 0)
 687                         goto out;
 688                 break;
 689         default:
 690                 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
 691                 ret = -ENODEV;
 692                 goto out;
 693         }
 694
 695         if (wl->fw == NULL) {
 696                 ret = wl1271_fetch_firmware(wl);
 697                 if (ret < 0)
 698                         goto out;
 699         }
 700
 701         /* No NVS from netlink, try to get it from the filesystem */
 702         if (wl->nvs == NULL) {
 703                 ret = wl1271_fetch_nvs(wl);
 704                 if (ret < 0)
 705                         goto out;
 706         }
 707
 708 out:
 709         return ret;
 710 }
 711
 712 int wl1271_plt_start(struct wl1271 *wl)
 713 {
 714         int retries = WL1271_BOOT_RETRIES;
 715         int ret;
 716
 717         mutex_lock(&wl->mutex);
 718
 719         wl1271_notice("power up");
 720
 721         if (wl->state != WL1271_STATE_OFF) {
 722                 wl1271_error("cannot go into PLT state because not "
 723                              "in off state: %d", wl->state);
 724                 ret = -EBUSY;
 725                 goto out;
 726         }
 727
 728         while (retries) {
 729                 retries--;
 730                 ret = wl1271_chip_wakeup(wl);
 731                 if (ret < 0)
 732                         goto power_off;
 733
 734                 ret = wl1271_boot(wl);
 735                 if (ret < 0)
 736                         goto power_off;
 737
 738                 ret = wl1271_plt_init(wl);
 739                 if (ret < 0)
 740                         goto irq_disable;
 741
 742                 wl->state = WL1271_STATE_PLT;
 743                 wl1271_notice("firmware booted in PLT mode (%s)",
 744                               wl->chip.fw_ver);
 745                 goto out;
 746
 747 irq_disable:
 748                 wl1271_disable_interrupts(wl);
 749                 mutex_unlock(&wl->mutex);
 750                 /* Unlocking the mutex in the middle of handling is
 751                    inherently unsafe. In this case we deem it safe to do,
 752                    because we need to let any possibly pending IRQ out of
 753                    the system (and while we are WL1271_STATE_OFF the IRQ
 754                    work function will not do anything.) Also, any other
 755                    possible concurrent operations will fail due to the
 756                    current state, hence the wl1271 struct should be safe. */
 757                 cancel_work_sync(&wl->irq_work);
 758                 mutex_lock(&wl->mutex);
 759 power_off:
 760                 wl1271_power_off(wl);
 761         }
 762
 763         wl1271_error("firmware boot in PLT mode failed despite %d retries",
 764                      WL1271_BOOT_RETRIES);
 765 out:
 766         mutex_unlock(&wl->mutex);
 767
 768         return ret;
 769 }
 770
 771 int wl1271_plt_stop(struct wl1271 *wl)
 772 {
 773         int ret = 0;
 774
 775         mutex_lock(&wl->mutex);
 776
 777         wl1271_notice("power down");
 778
 779         if (wl->state != WL1271_STATE_PLT) {
 780                 wl1271_error("cannot power down because not in PLT "
 781                              "state: %d", wl->state);
 782                 ret = -EBUSY;
 783                 goto out;
 784         }
 785
 786         wl1271_disable_interrupts(wl);
 787         wl1271_power_off(wl);
 788
 789         wl->state = WL1271_STATE_OFF;
 790         wl->rx_counter = 0;
 791
 792 out:
 793         mutex_unlock(&wl->mutex);
 794
 795         return ret;
 796 }
 797
 798
 799 static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
 800 {
 801         struct wl1271 *wl = hw->priv;
 802         struct ieee80211_conf *conf = &hw->conf;
 803         struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
 804         struct ieee80211_sta *sta = txinfo->control.sta;
 805         unsigned long flags;
 806
 807         /* peek into the rates configured in the STA entry */
 808         spin_lock_irqsave(&wl->wl_lock, flags);
 809         if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
 810                 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
 811                 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
 812         }
 813         spin_unlock_irqrestore(&wl->wl_lock, flags);
 814
 815         /* queue the packet */
 816         skb_queue_tail(&wl->tx_queue, skb);
 817
 818         /*
 819          * The chip specific setup must run before the first TX packet -
 820          * before that, the tx_work will not be initialized!
 821          */
 822
 823         ieee80211_queue_work(wl->hw, &wl->tx_work);
 824
 825         /*
 826          * The workqueue is slow to process the tx_queue and we need stop
 827          * the queue here, otherwise the queue will get too long.
 828          */
 829         if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
 830                 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
 831
 832                 spin_lock_irqsave(&wl->wl_lock, flags);
 833                 ieee80211_stop_queues(wl->hw);
 834                 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
 835                 spin_unlock_irqrestore(&wl->wl_lock, flags);
 836         }
 837
 838         return NETDEV_TX_OK;
 839 }
 840
 841 static struct notifier_block wl1271_dev_notifier = {
 842         .notifier_call = wl1271_dev_notify,
 843 };
 844
 845 static int wl1271_op_start(struct ieee80211_hw *hw)
 846 {
 847         wl1271_debug(DEBUG_MAC80211, "mac80211 start");
 848
 849         /*
 850          * We have to delay the booting of the hardware because
 851          * we need to know the local MAC address before downloading and
 852          * initializing the firmware. The MAC address cannot be changed
 853          * after boot, and without the proper MAC address, the firmware
 854          * will not function properly.
 855          *
 856          * The MAC address is first known when the corresponding interface
 857          * is added. That is where we will initialize the hardware.
 858          */
 859
 860         return 0;
 861 }
 862
 863 static void wl1271_op_stop(struct ieee80211_hw *hw)
 864 {
 865         wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
 866 }
 867
 868 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
 869                                    struct ieee80211_vif *vif)
 870 {
 871         struct wl1271 *wl = hw->priv;
 872         struct wiphy *wiphy = hw->wiphy;
 873         int retries = WL1271_BOOT_RETRIES;
 874         int ret = 0;
 875
 876         wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
 877                      vif->type, vif->addr);
 878
 879         mutex_lock(&wl->mutex);
 880         if (wl->vif) {
 881                 ret = -EBUSY;
 882                 goto out;
 883         }
 884
 885         wl->vif = vif;
 886
 887         switch (vif->type) {
 888         case NL80211_IFTYPE_STATION:
 889                 wl->bss_type = BSS_TYPE_STA_BSS;
 890                 wl->set_bss_type = BSS_TYPE_STA_BSS;
 891                 break;
 892         case NL80211_IFTYPE_ADHOC:
 893                 wl->bss_type = BSS_TYPE_IBSS;
 894                 wl->set_bss_type = BSS_TYPE_STA_BSS;
 895                 break;
 896         default:
 897                 ret = -EOPNOTSUPP;
 898                 goto out;
 899         }
 900
 901         memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
 902
 903         if (wl->state != WL1271_STATE_OFF) {
 904                 wl1271_error("cannot start because not in off state: %d",
 905                              wl->state);
 906                 ret = -EBUSY;
 907                 goto out;
 908         }
 909
 910         while (retries) {
 911                 retries--;
 912                 ret = wl1271_chip_wakeup(wl);
 913                 if (ret < 0)
 914                         goto power_off;
 915
 916                 ret = wl1271_boot(wl);
 917                 if (ret < 0)
 918                         goto power_off;
 919
 920                 ret = wl1271_hw_init(wl);
 921                 if (ret < 0)
 922                         goto irq_disable;
 923
 924                 wl->state = WL1271_STATE_ON;
 925                 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
 926
 927                 /* update hw/fw version info in wiphy struct */
 928                 wiphy->hw_version = wl->chip.id;
 929                 strncpy(wiphy->fw_version, wl->chip.fw_ver,
 930                         sizeof(wiphy->fw_version));
 931
 932                 goto out;
 933
 934 irq_disable:
 935                 wl1271_disable_interrupts(wl);
 936                 mutex_unlock(&wl->mutex);
 937                 /* Unlocking the mutex in the middle of handling is
 938                    inherently unsafe. In this case we deem it safe to do,
 939                    because we need to let any possibly pending IRQ out of
 940                    the system (and while we are WL1271_STATE_OFF the IRQ
 941                    work function will not do anything.) Also, any other
 942                    possible concurrent operations will fail due to the
 943                    current state, hence the wl1271 struct should be safe. */
 944                 cancel_work_sync(&wl->irq_work);
 945                 mutex_lock(&wl->mutex);
 946 power_off:
 947                 wl1271_power_off(wl);
 948         }
 949
 950         wl1271_error("firmware boot failed despite %d retries",
 951                      WL1271_BOOT_RETRIES);
 952 out:
 953         mutex_unlock(&wl->mutex);
 954
 955         if (!ret)
 956                 list_add(&wl->list, &wl_list);
 957
 958         return ret;
 959 }
 960
 961 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
 962                                        struct ieee80211_vif *vif)
 963 {
 964         struct wl1271 *wl = hw->priv;
 965         int i;
 966
 967         cancel_work_sync(&wl->scan_complete_work);
 968
 969         mutex_lock(&wl->mutex);
 970         wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
 971
 972         wl1271_info("down");
 973
 974         list_del(&wl->list);
 975
 976         WARN_ON(wl->state != WL1271_STATE_ON);
 977
 978         /* enable dyn ps just in case (if left on due to fw crash etc) */
 979         if (wl->bss_type == BSS_TYPE_STA_BSS)
 980                 ieee80211_enable_dyn_ps(wl->vif);
 981
 982         if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
 983                 wl->scan.state = WL1271_SCAN_STATE_IDLE;
 984                 kfree(wl->scan.scanned_ch);
 985                 wl->scan.scanned_ch = NULL;
 986                 ieee80211_scan_completed(wl->hw, true);
 987         }
 988
 989         wl->state = WL1271_STATE_OFF;
 990
 991         wl1271_disable_interrupts(wl);
 992
 993         mutex_unlock(&wl->mutex);
 994
 995         cancel_work_sync(&wl->irq_work);
 996         cancel_work_sync(&wl->tx_work);
 997         cancel_delayed_work_sync(&wl->pspoll_work);
 998
 999         mutex_lock(&wl->mutex);
1000
1001         /* let's notify MAC80211 about the remaining pending TX frames */
1002         wl1271_tx_reset(wl);
1003         wl1271_power_off(wl);
1004
1005         memset(wl->bssid, 0, ETH_ALEN);
1006         memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1007         wl->ssid_len = 0;
1008         wl->bss_type = MAX_BSS_TYPE;
1009         wl->set_bss_type = MAX_BSS_TYPE;
1010         wl->band = IEEE80211_BAND_2GHZ;
1011
1012         wl->rx_counter = 0;
1013         wl->psm_entry_retry = 0;
1014         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1015         wl->tx_blocks_available = 0;
1016         wl->tx_results_count = 0;
1017         wl->tx_packets_count = 0;
1018         wl->tx_security_last_seq = 0;
1019         wl->tx_security_seq = 0;
1020         wl->time_offset = 0;
1021         wl->session_counter = 0;
1022         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1023         wl->sta_rate_set = 0;
1024         wl->flags = 0;
1025         wl->vif = NULL;
1026         wl->filters = 0;
1027
1028         for (i = 0; i < NUM_TX_QUEUES; i++)
1029                 wl->tx_blocks_freed[i] = 0;
1030
1031         wl1271_debugfs_reset(wl);
1032
1033         kfree(wl->fw_status);
1034         wl->fw_status = NULL;
1035         kfree(wl->tx_res_if);
1036         wl->tx_res_if = NULL;
1037         kfree(wl->target_mem_map);
1038         wl->target_mem_map = NULL;
1039
1040         mutex_unlock(&wl->mutex);
1041 }
1042
1043 static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1044 {
1045         wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1046         wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1047
1048         /* combine requested filters with current filter config */
1049         filters = wl->filters | filters;
1050
1051         wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1052
1053         if (filters & FIF_PROMISC_IN_BSS) {
1054                 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1055                 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1056                 wl->rx_config |= CFG_BSSID_FILTER_EN;
1057         }
1058         if (filters & FIF_BCN_PRBRESP_PROMISC) {
1059                 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1060                 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1061                 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1062         }
1063         if (filters & FIF_OTHER_BSS) {
1064                 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1065                 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1066         }
1067         if (filters & FIF_CONTROL) {
1068                 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1069                 wl->rx_filter |= CFG_RX_CTL_EN;
1070         }
1071         if (filters & FIF_FCSFAIL) {
1072                 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1073                 wl->rx_filter |= CFG_RX_FCS_ERROR;
1074         }
1075 }
1076
1077 static int wl1271_dummy_join(struct wl1271 *wl)
1078 {
1079         int ret = 0;
1080         /* we need to use a dummy BSSID for now */
1081         static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1082                                                   0xad, 0xbe, 0xef };
1083
1084         memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1085
1086         /* pass through frames from all BSS */
1087         wl1271_configure_filters(wl, FIF_OTHER_BSS);
1088
1089         ret = wl1271_cmd_join(wl, wl->set_bss_type);
1090         if (ret < 0)
1091                 goto out;
1092
1093         set_bit(WL1271_FLAG_JOINED, &wl->flags);
1094
1095 out:
1096         return ret;
1097 }
1098
1099 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
1100 {
1101         int ret;
1102
1103         /*
1104          * One of the side effects of the JOIN command is that is clears
1105          * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1106          * to a WPA/WPA2 access point will therefore kill the data-path.
1107          * Currently there is no supported scenario for JOIN during
1108          * association - if it becomes a supported scenario, the WPA/WPA2 keys
1109          * must be handled somehow.
1110          *
1111          */
1112         if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1113                 wl1271_info("JOIN while associated.");
1114
1115         if (set_assoc)
1116                 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1117
1118         ret = wl1271_cmd_join(wl, wl->set_bss_type);
1119         if (ret < 0)
1120                 goto out;
1121
1122         set_bit(WL1271_FLAG_JOINED, &wl->flags);
1123
1124         if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1125                 goto out;
1126
1127         /*
1128          * The join command disable the keep-alive mode, shut down its process,
1129          * and also clear the template config, so we need to reset it all after
1130          * the join. The acx_aid starts the keep-alive process, and the order
1131          * of the commands below is relevant.
1132          */
1133         ret = wl1271_acx_keep_alive_mode(wl, true);
1134         if (ret < 0)
1135                 goto out;
1136
1137         ret = wl1271_acx_aid(wl, wl->aid);
1138         if (ret < 0)
1139                 goto out;
1140
1141         ret = wl1271_cmd_build_klv_null_data(wl);
1142         if (ret < 0)
1143                 goto out;
1144
1145         ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1146                                            ACX_KEEP_ALIVE_TPL_VALID);
1147         if (ret < 0)
1148                 goto out;
1149
1150 out:
1151         return ret;
1152 }
1153
1154 static int wl1271_unjoin(struct wl1271 *wl)
1155 {
1156         int ret;
1157
1158         /* to stop listening to a channel, we disconnect */
1159         ret = wl1271_cmd_disconnect(wl);
1160         if (ret < 0)
1161                 goto out;
1162
1163         clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1164         memset(wl->bssid, 0, ETH_ALEN);
1165
1166         /* stop filterting packets based on bssid */
1167         wl1271_configure_filters(wl, FIF_OTHER_BSS);
1168
1169 out:
1170         return ret;
1171 }
1172
1173 static void wl1271_set_band_rate(struct wl1271 *wl)
1174 {
1175         if (wl->band == IEEE80211_BAND_2GHZ)
1176                 wl->basic_rate_set = wl->conf.tx.basic_rate;
1177         else
1178                 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1179 }
1180
1181 static u32 wl1271_min_rate_get(struct wl1271 *wl)
1182 {
1183         int i;
1184         u32 rate = 0;
1185
1186         if (!wl->basic_rate_set) {
1187                 WARN_ON(1);
1188                 wl->basic_rate_set = wl->conf.tx.basic_rate;
1189         }
1190
1191         for (i = 0; !rate; i++) {
1192                 if ((wl->basic_rate_set >> i) & 0x1)
1193                         rate = 1 << i;
1194         }
1195
1196         return rate;
1197 }
1198
1199 static int wl1271_handle_idle(struct wl1271 *wl, bool idle)
1200 {
1201         int ret;
1202
1203         if (idle) {
1204                 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1205                         ret = wl1271_unjoin(wl);
1206                         if (ret < 0)
1207                                 goto out;
1208                 }
1209                 wl->rate_set = wl1271_min_rate_get(wl);
1210                 wl->sta_rate_set = 0;
1211                 ret = wl1271_acx_rate_policies(wl);
1212                 if (ret < 0)
1213                         goto out;
1214                 ret = wl1271_acx_keep_alive_config(
1215                         wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1216                         ACX_KEEP_ALIVE_TPL_INVALID);
1217                 if (ret < 0)
1218                         goto out;
1219                 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1220         } else {
1221                 /* increment the session counter */
1222                 wl->session_counter++;
1223                 if (wl->session_counter >= SESSION_COUNTER_MAX)
1224                         wl->session_counter = 0;
1225                 ret = wl1271_dummy_join(wl);
1226                 if (ret < 0)
1227                         goto out;
1228                 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1229         }
1230
1231 out:
1232         return ret;
1233 }
1234
1235 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1236 {
1237         struct wl1271 *wl = hw->priv;
1238         struct ieee80211_conf *conf = &hw->conf;
1239         int channel, ret = 0;
1240
1241         channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1242
1243         wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
1244                      channel,
1245                      conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1246                      conf->power_level,
1247                      conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
1248
1249         /*
1250          * mac80211 will go to idle nearly immediately after transmitting some
1251          * frames, such as the deauth. To make sure those frames reach the air,
1252          * wait here until the TX queue is fully flushed.
1253          */
1254         if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1255             (conf->flags & IEEE80211_CONF_IDLE))
1256                 wl1271_tx_flush(wl);
1257
1258         mutex_lock(&wl->mutex);
1259
1260         if (unlikely(wl->state == WL1271_STATE_OFF))
1261                 goto out;
1262
1263         ret = wl1271_ps_elp_wakeup(wl, false);
1264         if (ret < 0)
1265                 goto out;
1266
1267         /* if the channel changes while joined, join again */
1268         if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1269             ((wl->band != conf->channel->band) ||
1270              (wl->channel != channel))) {
1271                 wl->band = conf->channel->band;
1272                 wl->channel = channel;
1273
1274                 /*
1275                  * FIXME: the mac80211 should really provide a fixed rate
1276                  * to use here. for now, just use the smallest possible rate
1277                  * for the band as a fixed rate for association frames and
1278                  * other control messages.
1279                  */
1280                 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1281                         wl1271_set_band_rate(wl);
1282
1283                 wl->basic_rate = wl1271_min_rate_get(wl);
1284                 ret = wl1271_acx_rate_policies(wl);
1285                 if (ret < 0)
1286                         wl1271_warning("rate policy for update channel "
1287                                        "failed %d", ret);
1288
1289                 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1290                         ret = wl1271_join(wl, false);
1291                         if (ret < 0)
1292                                 wl1271_warning("cmd join to update channel "
1293                                                "failed %d", ret);
1294                 }
1295         }
1296
1297         if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1298                 ret = wl1271_handle_idle(wl, conf->flags & IEEE80211_CONF_IDLE);
1299                 if (ret < 0)
1300                         wl1271_warning("idle mode change failed %d", ret);
1301         }
1302
1303         /*
1304          * if mac80211 changes the PSM mode, make sure the mode is not
1305          * incorrectly changed after the pspoll failure active window.
1306          */
1307         if (changed & IEEE80211_CONF_CHANGE_PS)
1308                 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
1309
1310         if (conf->flags & IEEE80211_CONF_PS &&
1311             !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1312                 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1313
1314                 /*
1315                  * We enter PSM only if we're already associated.
1316                  * If we're not, we'll enter it when joining an SSID,
1317                  * through the bss_info_changed() hook.
1318                  */
1319                 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1320                         wl1271_debug(DEBUG_PSM, "psm enabled");
1321                         ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1322                                                  wl->basic_rate_set, true);
1323                 }
1324         } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1325                    test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1326                 wl1271_debug(DEBUG_PSM, "psm disabled");
1327
1328                 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1329
1330                 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1331                         ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1332                                                  wl->basic_rate_set, true);
1333         }
1334
1335         if (conf->power_level != wl->power_level) {
1336                 ret = wl1271_acx_tx_power(wl, conf->power_level);
1337                 if (ret < 0)
1338                         goto out_sleep;
1339
1340                 wl->power_level = conf->power_level;
1341         }
1342
1343 out_sleep:
1344         wl1271_ps_elp_sleep(wl);
1345
1346 out:
1347         mutex_unlock(&wl->mutex);
1348
1349         return ret;
1350 }
1351
1352 struct wl1271_filter_params {
1353         bool enabled;
1354         int mc_list_length;
1355         u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1356 };
1357
1358 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1359                                        struct netdev_hw_addr_list *mc_list)
1360 {
1361         struct wl1271_filter_params *fp;
1362         struct netdev_hw_addr *ha;
1363         struct wl1271 *wl = hw->priv;
1364
1365         if (unlikely(wl->state == WL1271_STATE_OFF))
1366                 return 0;
1367
1368         fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1369         if (!fp) {
1370                 wl1271_error("Out of memory setting filters.");
1371                 return 0;
1372         }
1373
1374         /* update multicast filtering parameters */
1375         fp->mc_list_length = 0;
1376         if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1377                 fp->enabled = false;
1378         } else {
1379                 fp->enabled = true;
1380                 netdev_hw_addr_list_for_each(ha, mc_list) {
1381                         memcpy(fp->mc_list[fp->mc_list_length],
1382                                         ha->addr, ETH_ALEN);
1383                         fp->mc_list_length++;
1384                 }
1385         }
1386
1387         return (u64)(unsigned long)fp;
1388 }
1389
1390 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1391                                   FIF_ALLMULTI | \
1392                                   FIF_FCSFAIL | \
1393                                   FIF_BCN_PRBRESP_PROMISC | \
1394                                   FIF_CONTROL | \
1395                                   FIF_OTHER_BSS)
1396
1397 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1398                                        unsigned int changed,
1399                                        unsigned int *total, u64 multicast)
1400 {
1401         struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1402         struct wl1271 *wl = hw->priv;
1403         int ret;
1404
1405         wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1406
1407         mutex_lock(&wl->mutex);
1408
1409         *total &= WL1271_SUPPORTED_FILTERS;
1410         changed &= WL1271_SUPPORTED_FILTERS;
1411
1412         if (unlikely(wl->state == WL1271_STATE_OFF))
1413                 goto out;
1414
1415         ret = wl1271_ps_elp_wakeup(wl, false);
1416         if (ret < 0)
1417                 goto out;
1418
1419
1420         if (*total & FIF_ALLMULTI)
1421                 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1422         else if (fp)
1423                 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1424                                                    fp->mc_list,
1425                                                    fp->mc_list_length);
1426         if (ret < 0)
1427                 goto out_sleep;
1428
1429         /* determine, whether supported filter values have changed */
1430         if (changed == 0)
1431                 goto out_sleep;
1432
1433         /* configure filters */
1434         wl->filters = *total;
1435         wl1271_configure_filters(wl, 0);
1436
1437         /* apply configured filters */
1438         ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1439         if (ret < 0)
1440                 goto out_sleep;
1441
1442 out_sleep:
1443         wl1271_ps_elp_sleep(wl);
1444
1445 out:
1446         mutex_unlock(&wl->mutex);
1447         kfree(fp);
1448 }
1449
1450 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1451                              struct ieee80211_vif *vif,
1452                              struct ieee80211_sta *sta,
1453                              struct ieee80211_key_conf *key_conf)
1454 {
1455         struct wl1271 *wl = hw->priv;
1456         const u8 *addr;
1457         int ret;
1458         u32 tx_seq_32 = 0;
1459         u16 tx_seq_16 = 0;
1460         u8 key_type;
1461
1462         static const u8 bcast_addr[ETH_ALEN] =
1463                 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1464
1465         wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1466
1467         addr = sta ? sta->addr : bcast_addr;
1468
1469         wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1470         wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1471         wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1472                      key_conf->cipher, key_conf->keyidx,
1473                      key_conf->keylen, key_conf->flags);
1474         wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1475
1476         if (is_zero_ether_addr(addr)) {
1477                 /* We dont support TX only encryption */
1478                 ret = -EOPNOTSUPP;
1479                 goto out;
1480         }
1481
1482         mutex_lock(&wl->mutex);
1483
1484         ret = wl1271_ps_elp_wakeup(wl, false);
1485         if (ret < 0)
1486                 goto out_unlock;
1487
1488         switch (key_conf->cipher) {
1489         case WLAN_CIPHER_SUITE_WEP40:
1490         case WLAN_CIPHER_SUITE_WEP104:
1491                 key_type = KEY_WEP;
1492
1493                 key_conf->hw_key_idx = key_conf->keyidx;
1494                 break;
1495         case WLAN_CIPHER_SUITE_TKIP:
1496                 key_type = KEY_TKIP;
1497
1498                 key_conf->hw_key_idx = key_conf->keyidx;
1499                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1500                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1501                 break;
1502         case WLAN_CIPHER_SUITE_CCMP:
1503                 key_type = KEY_AES;
1504
1505                 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1506                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1507                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1508                 break;
1509         default:
1510                 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
1511
1512                 ret = -EOPNOTSUPP;
1513                 goto out_sleep;
1514         }
1515
1516         switch (cmd) {
1517         case SET_KEY:
1518                 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1519                                          key_conf->keyidx, key_type,
1520                                          key_conf->keylen, key_conf->key,
1521                                          addr, tx_seq_32, tx_seq_16);
1522                 if (ret < 0) {
1523                         wl1271_error("Could not add or replace key");
1524                         goto out_sleep;
1525                 }
1526
1527                 /* the default WEP key needs to be configured at least once */
1528                 if (key_type == KEY_WEP) {
1529                         ret = wl1271_cmd_set_default_wep_key(wl,
1530                                                              wl->default_key);
1531                         if (ret < 0)
1532                                 goto out_sleep;
1533                 }
1534                 break;
1535
1536         case DISABLE_KEY:
1537                 /* The wl1271 does not allow to remove unicast keys - they
1538                    will be cleared automatically on next CMD_JOIN. Ignore the
1539                    request silently, as we dont want the mac80211 to emit
1540                    an error message. */
1541                 if (!is_broadcast_ether_addr(addr))
1542                         break;
1543
1544                 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1545                                          key_conf->keyidx, key_type,
1546                                          key_conf->keylen, key_conf->key,
1547                                          addr, 0, 0);
1548                 if (ret < 0) {
1549                         wl1271_error("Could not remove key");
1550                         goto out_sleep;
1551                 }
1552                 break;
1553
1554         default:
1555                 wl1271_error("Unsupported key cmd 0x%x", cmd);
1556                 ret = -EOPNOTSUPP;
1557                 break;
1558         }
1559
1560 out_sleep:
1561         wl1271_ps_elp_sleep(wl);
1562
1563 out_unlock:
1564         mutex_unlock(&wl->mutex);
1565
1566 out:
1567         return ret;
1568 }
1569
1570 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1571                              struct ieee80211_vif *vif,
1572                              struct cfg80211_scan_request *req)
1573 {
1574         struct wl1271 *wl = hw->priv;
1575         int ret;
1576         u8 *ssid = NULL;
1577         size_t len = 0;
1578
1579         wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1580
1581         if (req->n_ssids) {
1582                 ssid = req->ssids[0].ssid;
1583                 len = req->ssids[0].ssid_len;
1584         }
1585
1586         mutex_lock(&wl->mutex);
1587
1588         ret = wl1271_ps_elp_wakeup(wl, false);
1589         if (ret < 0)
1590                 goto out;
1591
1592         ret = wl1271_scan(hw->priv, ssid, len, req);
1593
1594         wl1271_ps_elp_sleep(wl);
1595
1596 out:
1597         mutex_unlock(&wl->mutex);
1598
1599         return ret;
1600 }
1601
1602 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1603 {
1604         struct wl1271 *wl = hw->priv;
1605         int ret = 0;
1606
1607         mutex_lock(&wl->mutex);
1608
1609         if (unlikely(wl->state == WL1271_STATE_OFF))
1610                 goto out;
1611
1612         ret = wl1271_ps_elp_wakeup(wl, false);
1613         if (ret < 0)
1614                 goto out;
1615
1616         ret = wl1271_acx_rts_threshold(wl, (u16) value);
1617         if (ret < 0)
1618                 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1619
1620         wl1271_ps_elp_sleep(wl);
1621
1622 out:
1623         mutex_unlock(&wl->mutex);
1624
1625         return ret;
1626 }
1627
1628 static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1629 {
1630         u8 *ptr = beacon->data +
1631                 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1632
1633         /* find the location of the ssid in the beacon */
1634         while (ptr < beacon->data + beacon->len) {
1635                 if (ptr[0] == WLAN_EID_SSID) {
1636                         wl->ssid_len = ptr[1];
1637                         memcpy(wl->ssid, ptr+2, wl->ssid_len);
1638                         return;
1639                 }
1640                 ptr += ptr[1];
1641         }
1642         wl1271_error("ad-hoc beacon template has no SSID!\n");
1643 }
1644
1645 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1646                                        struct ieee80211_vif *vif,
1647                                        struct ieee80211_bss_conf *bss_conf,
1648                                        u32 changed)
1649 {
1650         enum wl1271_cmd_ps_mode mode;
1651         struct wl1271 *wl = hw->priv;
1652         bool do_join = false;
1653         bool set_assoc = false;
1654         int ret;
1655
1656         wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1657
1658         mutex_lock(&wl->mutex);
1659
1660         ret = wl1271_ps_elp_wakeup(wl, false);
1661         if (ret < 0)
1662                 goto out;
1663
1664         if ((changed & BSS_CHANGED_BEACON_INT) &&
1665             (wl->bss_type == BSS_TYPE_IBSS)) {
1666                 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
1667                         bss_conf->beacon_int);
1668
1669                 wl->beacon_int = bss_conf->beacon_int;
1670                 do_join = true;
1671         }
1672
1673         if ((changed & BSS_CHANGED_BEACON) &&
1674             (wl->bss_type == BSS_TYPE_IBSS)) {
1675                 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1676
1677                 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
1678
1679                 if (beacon) {
1680                         struct ieee80211_hdr *hdr;
1681
1682                         wl1271_ssid_set(wl, beacon);
1683                         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1684                                                       beacon->data,
1685                                                       beacon->len, 0,
1686                                                       wl1271_min_rate_get(wl));
1687
1688                         if (ret < 0) {
1689                                 dev_kfree_skb(beacon);
1690                                 goto out_sleep;
1691                         }
1692
1693                         hdr = (struct ieee80211_hdr *) beacon->data;
1694                         hdr->frame_control = cpu_to_le16(
1695                                 IEEE80211_FTYPE_MGMT |
1696                                 IEEE80211_STYPE_PROBE_RESP);
1697
1698                         ret = wl1271_cmd_template_set(wl,
1699                                                       CMD_TEMPL_PROBE_RESPONSE,
1700                                                       beacon->data,
1701                                                       beacon->len, 0,
1702                                                       wl1271_min_rate_get(wl));
1703                         dev_kfree_skb(beacon);
1704                         if (ret < 0)
1705                                 goto out_sleep;
1706
1707                         /* Need to update the SSID (for filtering etc) */
1708                         do_join = true;
1709                 }
1710         }
1711
1712         if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1713             (wl->bss_type == BSS_TYPE_IBSS)) {
1714                 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1715                              bss_conf->enable_beacon ? "enabled" : "disabled");
1716
1717                 if (bss_conf->enable_beacon)
1718                         wl->set_bss_type = BSS_TYPE_IBSS;
1719                 else
1720                         wl->set_bss_type = BSS_TYPE_STA_BSS;
1721                 do_join = true;
1722         }
1723
1724         if (changed & BSS_CHANGED_CQM) {
1725                 bool enable = false;
1726                 if (bss_conf->cqm_rssi_thold)
1727                         enable = true;
1728                 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
1729                                                   bss_conf->cqm_rssi_thold,
1730                                                   bss_conf->cqm_rssi_hyst);
1731                 if (ret < 0)
1732                         goto out;
1733                 wl->rssi_thold = bss_conf->cqm_rssi_thold;
1734         }
1735
1736         if ((changed & BSS_CHANGED_BSSID) &&
1737             /*
1738              * Now we know the correct bssid, so we send a new join command
1739              * and enable the BSSID filter
1740              */
1741             memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1742                         memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1743
1744                         ret = wl1271_cmd_build_null_data(wl);
1745                         if (ret < 0)
1746                                 goto out_sleep;
1747
1748                         ret = wl1271_build_qos_null_data(wl);
1749                         if (ret < 0)
1750                                 goto out_sleep;
1751
1752                         /* filter out all packets not from this BSSID */
1753                         wl1271_configure_filters(wl, 0);
1754
1755                         /* Need to update the BSSID (for filtering etc) */
1756                         do_join = true;
1757         }
1758
1759         if (changed & BSS_CHANGED_ASSOC) {
1760                 if (bss_conf->assoc) {
1761                         u32 rates;
1762                         wl->aid = bss_conf->aid;
1763                         set_assoc = true;
1764
1765                         wl->ps_poll_failures = 0;
1766
1767                         /*
1768                          * use basic rates from AP, and determine lowest rate
1769                          * to use with control frames.
1770                          */
1771                         rates = bss_conf->basic_rates;
1772                         wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1773                                                                          rates);
1774                         wl->basic_rate = wl1271_min_rate_get(wl);
1775                         ret = wl1271_acx_rate_policies(wl);
1776                         if (ret < 0)
1777                                 goto out_sleep;
1778
1779                         /*
1780                          * with wl1271, we don't need to update the
1781                          * beacon_int and dtim_period, because the firmware
1782                          * updates it by itself when the first beacon is
1783                          * received after a join.
1784                          */
1785                         ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1786                         if (ret < 0)
1787                                 goto out_sleep;
1788
1789                         /*
1790                          * The SSID is intentionally set to NULL here - the
1791                          * firmware will set the probe request with a
1792                          * broadcast SSID regardless of what we set in the
1793                          * template.
1794                          */
1795                         ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1796                                                          NULL, 0, wl->band);
1797
1798                         /* enable the connection monitoring feature */
1799                         ret = wl1271_acx_conn_monit_params(wl, true);
1800                         if (ret < 0)
1801                                 goto out_sleep;
1802
1803                         /* If we want to go in PSM but we're not there yet */
1804                         if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1805                             !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1806                                 mode = STATION_POWER_SAVE_MODE;
1807                                 ret = wl1271_ps_set_mode(wl, mode,
1808                                                          wl->basic_rate_set,
1809                                                          true);
1810                                 if (ret < 0)
1811                                         goto out_sleep;
1812                         }
1813                 } else {
1814                         /* use defaults when not associated */
1815                         clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
1816                         clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1817                         wl->aid = 0;
1818
1819                         /* re-enable dynamic ps - just in case */
1820                         ieee80211_enable_dyn_ps(wl->vif);
1821
1822                         /* revert back to minimum rates for the current band */
1823                         wl1271_set_band_rate(wl);
1824                         wl->basic_rate = wl1271_min_rate_get(wl);
1825                         ret = wl1271_acx_rate_policies(wl);
1826                         if (ret < 0)
1827                                 goto out_sleep;
1828
1829                         /* disable connection monitor features */
1830                         ret = wl1271_acx_conn_monit_params(wl, false);
1831
1832                         /* Disable the keep-alive feature */
1833                         ret = wl1271_acx_keep_alive_mode(wl, false);
1834
1835                         if (ret < 0)
1836                                 goto out_sleep;
1837                 }
1838
1839         }
1840
1841         if (changed & BSS_CHANGED_ERP_SLOT) {
1842                 if (bss_conf->use_short_slot)
1843                         ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1844                 else
1845                         ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1846                 if (ret < 0) {
1847                         wl1271_warning("Set slot time failed %d", ret);
1848                         goto out_sleep;
1849                 }
1850         }
1851
1852         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1853                 if (bss_conf->use_short_preamble)
1854                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1855                 else
1856                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1857         }
1858
1859         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1860                 if (bss_conf->use_cts_prot)
1861                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1862                 else
1863                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1864                 if (ret < 0) {
1865                         wl1271_warning("Set ctsprotect failed %d", ret);
1866                         goto out_sleep;
1867                 }
1868         }
1869
1870         if (changed & BSS_CHANGED_ARP_FILTER) {
1871                 __be32 addr = bss_conf->arp_addr_list[0];
1872                 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
1873
1874                 if (bss_conf->arp_addr_cnt == 1 && bss_conf->arp_filter_enabled)
1875                         ret = wl1271_acx_arp_ip_filter(wl, true, addr);
1876                 else
1877                         ret = wl1271_acx_arp_ip_filter(wl, false, addr);
1878
1879                 if (ret < 0)
1880                         goto out_sleep;
1881         }
1882
1883         if (do_join) {
1884                 ret = wl1271_join(wl, set_assoc);
1885                 if (ret < 0) {
1886                         wl1271_warning("cmd join failed %d", ret);
1887                         goto out_sleep;
1888                 }
1889         }
1890
1891 out_sleep:
1892         wl1271_ps_elp_sleep(wl);
1893
1894 out:
1895         mutex_unlock(&wl->mutex);
1896 }
1897
1898 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1899                              const struct ieee80211_tx_queue_params *params)
1900 {
1901         struct wl1271 *wl = hw->priv;
1902         u8 ps_scheme;
1903         int ret;
1904
1905         mutex_lock(&wl->mutex);
1906
1907         wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1908
1909         ret = wl1271_ps_elp_wakeup(wl, false);
1910         if (ret < 0)
1911                 goto out;
1912
1913         /* the txop is confed in units of 32us by the mac80211, we need us */
1914         ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1915                                 params->cw_min, params->cw_max,
1916                                 params->aifs, params->txop << 5);
1917         if (ret < 0)
1918                 goto out_sleep;
1919
1920         if (params->uapsd)
1921                 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
1922         else
1923                 ps_scheme = CONF_PS_SCHEME_LEGACY;
1924
1925         ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1926                                  CONF_CHANNEL_TYPE_EDCF,
1927                                  wl1271_tx_get_queue(queue),
1928                                  ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
1929         if (ret < 0)
1930                 goto out_sleep;
1931
1932 out_sleep:
1933         wl1271_ps_elp_sleep(wl);
1934
1935 out:
1936         mutex_unlock(&wl->mutex);
1937
1938         return ret;
1939 }
1940
1941 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
1942 {
1943
1944         struct wl1271 *wl = hw->priv;
1945         u64 mactime = ULLONG_MAX;
1946         int ret;
1947
1948         wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
1949
1950         mutex_lock(&wl->mutex);
1951
1952         ret = wl1271_ps_elp_wakeup(wl, false);
1953         if (ret < 0)
1954                 goto out;
1955
1956         ret = wl1271_acx_tsf_info(wl, &mactime);
1957         if (ret < 0)
1958                 goto out_sleep;
1959
1960 out_sleep:
1961         wl1271_ps_elp_sleep(wl);
1962
1963 out:
1964         mutex_unlock(&wl->mutex);
1965         return mactime;
1966 }
1967
1968 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
1969                                 struct survey_info *survey)
1970 {
1971         struct wl1271 *wl = hw->priv;
1972         struct ieee80211_conf *conf = &hw->conf;
1973
1974         if (idx != 0)
1975                 return -ENOENT;
1976
1977         survey->channel = conf->channel;
1978         survey->filled = SURVEY_INFO_NOISE_DBM;
1979         survey->noise = wl->noise;
1980
1981         return 0;
1982 }
1983
1984 /* can't be const, mac80211 writes to this */
1985 static struct ieee80211_rate wl1271_rates[] = {
1986         { .bitrate = 10,
1987           .hw_value = CONF_HW_BIT_RATE_1MBPS,
1988           .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
1989         { .bitrate = 20,
1990           .hw_value = CONF_HW_BIT_RATE_2MBPS,
1991           .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
1992           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1993         { .bitrate = 55,
1994           .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1995           .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
1996           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1997         { .bitrate = 110,
1998           .hw_value = CONF_HW_BIT_RATE_11MBPS,
1999           .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
2000           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2001         { .bitrate = 60,
2002           .hw_value = CONF_HW_BIT_RATE_6MBPS,
2003           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2004         { .bitrate = 90,
2005           .hw_value = CONF_HW_BIT_RATE_9MBPS,
2006           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2007         { .bitrate = 120,
2008           .hw_value = CONF_HW_BIT_RATE_12MBPS,
2009           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2010         { .bitrate = 180,
2011           .hw_value = CONF_HW_BIT_RATE_18MBPS,
2012           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2013         { .bitrate = 240,
2014           .hw_value = CONF_HW_BIT_RATE_24MBPS,
2015           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2016         { .bitrate = 360,
2017          .hw_value = CONF_HW_BIT_RATE_36MBPS,
2018          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2019         { .bitrate = 480,
2020           .hw_value = CONF_HW_BIT_RATE_48MBPS,
2021           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2022         { .bitrate = 540,
2023           .hw_value = CONF_HW_BIT_RATE_54MBPS,
2024           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2025 };
2026
2027 /*
2028  * Can't be const, mac80211 writes to this. The order of the channels here
2029  * is designed to improve scanning.
2030  */
2031 static struct ieee80211_channel wl1271_channels[] = {
2032         { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
2033         { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
2034         { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
2035         { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
2036         { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
2037         { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
2038         { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
2039         { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
2040         { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
2041         { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
2042         { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
2043         { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
2044         { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
2045 };
2046
2047 /* mapping to indexes for wl1271_rates */
2048 static const u8 wl1271_rate_to_idx_2ghz[] = {
2049         /* MCS rates are used only with 11n */
2050         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2051         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2052         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2053         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2054         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2055         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2056         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2057         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2058
2059         11,                            /* CONF_HW_RXTX_RATE_54   */
2060         10,                            /* CONF_HW_RXTX_RATE_48   */
2061         9,                             /* CONF_HW_RXTX_RATE_36   */
2062         8,                             /* CONF_HW_RXTX_RATE_24   */
2063
2064         /* TI-specific rate */
2065         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
2066
2067         7,                             /* CONF_HW_RXTX_RATE_18   */
2068         6,                             /* CONF_HW_RXTX_RATE_12   */
2069         3,                             /* CONF_HW_RXTX_RATE_11   */
2070         5,                             /* CONF_HW_RXTX_RATE_9    */
2071         4,                             /* CONF_HW_RXTX_RATE_6    */
2072         2,                             /* CONF_HW_RXTX_RATE_5_5  */
2073         1,                             /* CONF_HW_RXTX_RATE_2    */
2074         0                              /* CONF_HW_RXTX_RATE_1    */
2075 };
2076
2077 /* can't be const, mac80211 writes to this */
2078 static struct ieee80211_supported_band wl1271_band_2ghz = {
2079         .channels = wl1271_channels,
2080         .n_channels = ARRAY_SIZE(wl1271_channels),
2081         .bitrates = wl1271_rates,
2082         .n_bitrates = ARRAY_SIZE(wl1271_rates),
2083 };
2084
2085 /* 5 GHz data rates for WL1273 */
2086 static struct ieee80211_rate wl1271_rates_5ghz[] = {
2087         { .bitrate = 60,
2088           .hw_value = CONF_HW_BIT_RATE_6MBPS,
2089           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2090         { .bitrate = 90,
2091           .hw_value = CONF_HW_BIT_RATE_9MBPS,
2092           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2093         { .bitrate = 120,
2094           .hw_value = CONF_HW_BIT_RATE_12MBPS,
2095           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2096         { .bitrate = 180,
2097           .hw_value = CONF_HW_BIT_RATE_18MBPS,
2098           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2099         { .bitrate = 240,
2100           .hw_value = CONF_HW_BIT_RATE_24MBPS,
2101           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2102         { .bitrate = 360,
2103          .hw_value = CONF_HW_BIT_RATE_36MBPS,
2104          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2105         { .bitrate = 480,
2106           .hw_value = CONF_HW_BIT_RATE_48MBPS,
2107           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2108         { .bitrate = 540,
2109           .hw_value = CONF_HW_BIT_RATE_54MBPS,
2110           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2111 };
2112
2113 /*
2114  * 5 GHz band channels for WL1273 - can't be const, mac80211 writes to this.
2115  * The order of the channels here is designed to improve scanning.
2116  */
2117 static struct ieee80211_channel wl1271_channels_5ghz[] = {
2118         { .hw_value = 183, .center_freq = 4915},
2119         { .hw_value = 188, .center_freq = 4940},
2120         { .hw_value = 8, .center_freq = 5040},
2121         { .hw_value = 34, .center_freq = 5170},
2122         { .hw_value = 44, .center_freq = 5220},
2123         { .hw_value = 60, .center_freq = 5300},
2124         { .hw_value = 112, .center_freq = 5560},
2125         { .hw_value = 132, .center_freq = 5660},
2126         { .hw_value = 157, .center_freq = 5785},
2127         { .hw_value = 184, .center_freq = 4920},
2128         { .hw_value = 189, .center_freq = 4945},
2129         { .hw_value = 9, .center_freq = 5045},
2130         { .hw_value = 36, .center_freq = 5180},
2131         { .hw_value = 46, .center_freq = 5230},
2132         { .hw_value = 64, .center_freq = 5320},
2133         { .hw_value = 116, .center_freq = 5580},
2134         { .hw_value = 136, .center_freq = 5680},
2135         { .hw_value = 192, .center_freq = 4960},
2136         { .hw_value = 11, .center_freq = 5055},
2137         { .hw_value = 38, .center_freq = 5190},
2138         { .hw_value = 48, .center_freq = 5240},
2139         { .hw_value = 100, .center_freq = 5500},
2140         { .hw_value = 120, .center_freq = 5600},
2141         { .hw_value = 140, .center_freq = 5700},
2142         { .hw_value = 185, .center_freq = 4925},
2143         { .hw_value = 196, .center_freq = 4980},
2144         { .hw_value = 12, .center_freq = 5060},
2145         { .hw_value = 40, .center_freq = 5200},
2146         { .hw_value = 52, .center_freq = 5260},
2147         { .hw_value = 104, .center_freq = 5520},
2148         { .hw_value = 124, .center_freq = 5620},
2149         { .hw_value = 149, .center_freq = 5745},
2150         { .hw_value = 161, .center_freq = 5805},
2151         { .hw_value = 187, .center_freq = 4935},
2152         { .hw_value = 7, .center_freq = 5035},
2153         { .hw_value = 16, .center_freq = 5080},
2154         { .hw_value = 42, .center_freq = 5210},
2155         { .hw_value = 56, .center_freq = 5280},
2156         { .hw_value = 108, .center_freq = 5540},
2157         { .hw_value = 128, .center_freq = 5640},
2158         { .hw_value = 153, .center_freq = 5765},
2159         { .hw_value = 165, .center_freq = 5825},
2160 };
2161
2162 /* mapping to indexes for wl1271_rates_5ghz */
2163 static const u8 wl1271_rate_to_idx_5ghz[] = {
2164         /* MCS rates are used only with 11n */
2165         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2166         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2167         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2168         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2169         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2170         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2171         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2172         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2173
2174         7,                             /* CONF_HW_RXTX_RATE_54   */
2175         6,                             /* CONF_HW_RXTX_RATE_48   */
2176         5,                             /* CONF_HW_RXTX_RATE_36   */
2177         4,                             /* CONF_HW_RXTX_RATE_24   */
2178
2179         /* TI-specific rate */
2180         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
2181
2182         3,                             /* CONF_HW_RXTX_RATE_18   */
2183         2,                             /* CONF_HW_RXTX_RATE_12   */
2184         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11   */
2185         1,                             /* CONF_HW_RXTX_RATE_9    */
2186         0,                             /* CONF_HW_RXTX_RATE_6    */
2187         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5  */
2188         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2    */
2189         CONF_HW_RXTX_RATE_UNSUPPORTED  /* CONF_HW_RXTX_RATE_1    */
2190 };
2191
2192 static struct ieee80211_supported_band wl1271_band_5ghz = {
2193         .channels = wl1271_channels_5ghz,
2194         .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2195         .bitrates = wl1271_rates_5ghz,
2196         .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
2197 };
2198
2199 static const u8 *wl1271_band_rate_to_idx[] = {
2200         [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2201         [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2202 };
2203
2204 static const struct ieee80211_ops wl1271_ops = {
2205         .start = wl1271_op_start,
2206         .stop = wl1271_op_stop,
2207         .add_interface = wl1271_op_add_interface,
2208         .remove_interface = wl1271_op_remove_interface,
2209         .config = wl1271_op_config,
2210         .prepare_multicast = wl1271_op_prepare_multicast,
2211         .configure_filter = wl1271_op_configure_filter,
2212         .tx = wl1271_op_tx,
2213         .set_key = wl1271_op_set_key,
2214         .hw_scan = wl1271_op_hw_scan,
2215         .bss_info_changed = wl1271_op_bss_info_changed,
2216         .set_rts_threshold = wl1271_op_set_rts_threshold,
2217         .conf_tx = wl1271_op_conf_tx,
2218         .get_tsf = wl1271_op_get_tsf,
2219         .get_survey = wl1271_op_get_survey,
2220         CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
2221 };
2222
2223
2224 u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate)
2225 {
2226         u8 idx;
2227
2228         BUG_ON(wl->band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
2229
2230         if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2231                 wl1271_error("Illegal RX rate from HW: %d", rate);
2232                 return 0;
2233         }
2234
2235         idx = wl1271_band_rate_to_idx[wl->band][rate];
2236         if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2237                 wl1271_error("Unsupported RX rate from HW: %d", rate);
2238                 return 0;
2239         }
2240
2241         return idx;
2242 }
2243
2244 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2245                                                struct device_attribute *attr,
2246                                                char *buf)
2247 {
2248         struct wl1271 *wl = dev_get_drvdata(dev);
2249         ssize_t len;
2250
2251         len = PAGE_SIZE;
2252
2253         mutex_lock(&wl->mutex);
2254         len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2255                        wl->sg_enabled);
2256         mutex_unlock(&wl->mutex);
2257
2258         return len;
2259
2260 }
2261
2262 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2263                                                 struct device_attribute *attr,
2264                                                 const char *buf, size_t count)
2265 {
2266         struct wl1271 *wl = dev_get_drvdata(dev);
2267         unsigned long res;
2268         int ret;
2269
2270         ret = strict_strtoul(buf, 10, &res);
2271
2272         if (ret < 0) {
2273                 wl1271_warning("incorrect value written to bt_coex_mode");
2274                 return count;
2275         }
2276
2277         mutex_lock(&wl->mutex);
2278
2279         res = !!res;
2280
2281         if (res == wl->sg_enabled)
2282                 goto out;
2283
2284         wl->sg_enabled = res;
2285
2286         if (wl->state == WL1271_STATE_OFF)
2287                 goto out;
2288
2289         ret = wl1271_ps_elp_wakeup(wl, false);
2290         if (ret < 0)
2291                 goto out;
2292
2293         wl1271_acx_sg_enable(wl, wl->sg_enabled);
2294         wl1271_ps_elp_sleep(wl);
2295
2296  out:
2297         mutex_unlock(&wl->mutex);
2298         return count;
2299 }
2300
2301 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2302                    wl1271_sysfs_show_bt_coex_state,
2303                    wl1271_sysfs_store_bt_coex_state);
2304
2305 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
2306                                            struct device_attribute *attr,
2307                                            char *buf)
2308 {
2309         struct wl1271 *wl = dev_get_drvdata(dev);
2310         ssize_t len;
2311
2312         len = PAGE_SIZE;
2313
2314         mutex_lock(&wl->mutex);
2315         if (wl->hw_pg_ver >= 0)
2316                 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
2317         else
2318                 len = snprintf(buf, len, "n/a\n");
2319         mutex_unlock(&wl->mutex);
2320
2321         return len;
2322 }
2323
2324 static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
2325                    wl1271_sysfs_show_hw_pg_ver, NULL);
2326
2327 int wl1271_register_hw(struct wl1271 *wl)
2328 {
2329         int ret;
2330
2331         if (wl->mac80211_registered)
2332                 return 0;
2333
2334         SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2335
2336         ret = ieee80211_register_hw(wl->hw);
2337         if (ret < 0) {
2338                 wl1271_error("unable to register mac80211 hw: %d", ret);
2339                 return ret;
2340         }
2341
2342         wl->mac80211_registered = true;
2343
2344         register_netdevice_notifier(&wl1271_dev_notifier);
2345
2346         wl1271_notice("loaded");
2347
2348         return 0;
2349 }
2350 EXPORT_SYMBOL_GPL(wl1271_register_hw);
2351
2352 void wl1271_unregister_hw(struct wl1271 *wl)
2353 {
2354         unregister_netdevice_notifier(&wl1271_dev_notifier);
2355         ieee80211_unregister_hw(wl->hw);
2356         wl->mac80211_registered = false;
2357
2358 }
2359 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2360
2361 int wl1271_init_ieee80211(struct wl1271 *wl)
2362 {
2363         /* The tx descriptor buffer and the TKIP space. */
2364         wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2365                 sizeof(struct wl1271_tx_hw_descr);
2366
2367         /* unit us */
2368         /* FIXME: find a proper value */
2369         wl->hw->channel_change_time = 10000;
2370         wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
2371
2372         wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
2373                 IEEE80211_HW_BEACON_FILTER |
2374                 IEEE80211_HW_SUPPORTS_PS |
2375                 IEEE80211_HW_SUPPORTS_UAPSD |
2376                 IEEE80211_HW_HAS_RATE_CONTROL |
2377                 IEEE80211_HW_CONNECTION_MONITOR |
2378                 IEEE80211_HW_SUPPORTS_CQM_RSSI;
2379
2380         wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2381                 BIT(NL80211_IFTYPE_ADHOC);
2382         wl->hw->wiphy->max_scan_ssids = 1;
2383         wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2384         wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2385
2386         wl->hw->queues = 4;
2387         wl->hw->max_rates = 1;
2388
2389         SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
2390
2391         return 0;
2392 }
2393 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
2394
2395 #define WL1271_DEFAULT_CHANNEL 0
2396
2397 struct ieee80211_hw *wl1271_alloc_hw(void)
2398 {
2399         struct ieee80211_hw *hw;
2400         struct platform_device *plat_dev = NULL;
2401         struct wl1271 *wl;
2402         int i, ret;
2403
2404         hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2405         if (!hw) {
2406                 wl1271_error("could not alloc ieee80211_hw");
2407                 ret = -ENOMEM;
2408                 goto err_hw_alloc;
2409         }
2410
2411         plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
2412         if (!plat_dev) {
2413                 wl1271_error("could not allocate platform_device");
2414                 ret = -ENOMEM;
2415                 goto err_plat_alloc;
2416         }
2417
2418         wl = hw->priv;
2419         memset(wl, 0, sizeof(*wl));
2420
2421         INIT_LIST_HEAD(&wl->list);
2422
2423         wl->hw = hw;
2424         wl->plat_dev = plat_dev;
2425
2426         skb_queue_head_init(&wl->tx_queue);
2427
2428         INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
2429         INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
2430         wl->channel = WL1271_DEFAULT_CHANNEL;
2431         wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
2432         wl->default_key = 0;
2433         wl->rx_counter = 0;
2434         wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2435         wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
2436         wl->psm_entry_retry = 0;
2437         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2438         wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2439         wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
2440         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2441         wl->sta_rate_set = 0;
2442         wl->band = IEEE80211_BAND_2GHZ;
2443         wl->vif = NULL;
2444         wl->flags = 0;
2445         wl->sg_enabled = true;
2446         wl->hw_pg_ver = -1;
2447
2448         for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
2449                 wl->tx_frames[i] = NULL;
2450
2451         spin_lock_init(&wl->wl_lock);
2452
2453         wl->state = WL1271_STATE_OFF;
2454         mutex_init(&wl->mutex);
2455
2456         /* Apply default driver configuration. */
2457         wl1271_conf_init(wl);
2458
2459         wl1271_debugfs_init(wl);
2460
2461         /* Register platform device */
2462         ret = platform_device_register(wl->plat_dev);
2463         if (ret) {
2464                 wl1271_error("couldn't register platform device");
2465                 goto err_hw;
2466         }
2467         dev_set_drvdata(&wl->plat_dev->dev, wl);
2468
2469         /* Create sysfs file to control bt coex state */
2470         ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2471         if (ret < 0) {
2472                 wl1271_error("failed to create sysfs file bt_coex_state");
2473                 goto err_platform;
2474         }
2475
2476         /* Create sysfs file to get HW PG version */
2477         ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
2478         if (ret < 0) {
2479                 wl1271_error("failed to create sysfs file hw_pg_ver");
2480                 goto err_bt_coex_state;
2481         }
2482
2483         return hw;
2484
2485 err_bt_coex_state:
2486         device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2487
2488 err_platform:
2489         platform_device_unregister(wl->plat_dev);
2490
2491 err_hw:
2492         wl1271_debugfs_exit(wl);
2493         kfree(plat_dev);
2494
2495 err_plat_alloc:
2496         ieee80211_free_hw(hw);
2497
2498 err_hw_alloc:
2499
2500         return ERR_PTR(ret);
2501 }
2502 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
2503
2504 int wl1271_free_hw(struct wl1271 *wl)
2505 {
2506         platform_device_unregister(wl->plat_dev);
2507         kfree(wl->plat_dev);
2508
2509         wl1271_debugfs_exit(wl);
2510
2511         vfree(wl->fw);
2512         wl->fw = NULL;
2513         kfree(wl->nvs);
2514         wl->nvs = NULL;
2515
2516         kfree(wl->fw_status);
2517         kfree(wl->tx_res_if);
2518
2519         ieee80211_free_hw(wl->hw);
2520
2521         return 0;
2522 }
2523 EXPORT_SYMBOL_GPL(wl1271_free_hw);
2524
2525 MODULE_LICENSE("GPL");
2526 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2527 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");