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         cancel_work_sync(&wl->irq_work);
 796
 797         return ret;
 798 }
 799
 800
 801 static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
 802 {
 803         struct wl1271 *wl = hw->priv;
 804         struct ieee80211_conf *conf = &hw->conf;
 805         struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
 806         struct ieee80211_sta *sta = txinfo->control.sta;
 807         unsigned long flags;
 808
 809         /* peek into the rates configured in the STA entry */
 810         spin_lock_irqsave(&wl->wl_lock, flags);
 811         if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
 812                 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
 813                 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
 814         }
 815         spin_unlock_irqrestore(&wl->wl_lock, flags);
 816
 817         /* queue the packet */
 818         skb_queue_tail(&wl->tx_queue, skb);
 819
 820         /*
 821          * The chip specific setup must run before the first TX packet -
 822          * before that, the tx_work will not be initialized!
 823          */
 824
 825         ieee80211_queue_work(wl->hw, &wl->tx_work);
 826
 827         /*
 828          * The workqueue is slow to process the tx_queue and we need stop
 829          * the queue here, otherwise the queue will get too long.
 830          */
 831         if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
 832                 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
 833
 834                 spin_lock_irqsave(&wl->wl_lock, flags);
 835                 ieee80211_stop_queues(wl->hw);
 836                 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
 837                 spin_unlock_irqrestore(&wl->wl_lock, flags);
 838         }
 839
 840         return NETDEV_TX_OK;
 841 }
 842
 843 static struct notifier_block wl1271_dev_notifier = {
 844         .notifier_call = wl1271_dev_notify,
 845 };
 846
 847 static int wl1271_op_start(struct ieee80211_hw *hw)
 848 {
 849         wl1271_debug(DEBUG_MAC80211, "mac80211 start");
 850
 851         /*
 852          * We have to delay the booting of the hardware because
 853          * we need to know the local MAC address before downloading and
 854          * initializing the firmware. The MAC address cannot be changed
 855          * after boot, and without the proper MAC address, the firmware
 856          * will not function properly.
 857          *
 858          * The MAC address is first known when the corresponding interface
 859          * is added. That is where we will initialize the hardware.
 860          */
 861
 862         return 0;
 863 }
 864
 865 static void wl1271_op_stop(struct ieee80211_hw *hw)
 866 {
 867         wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
 868 }
 869
 870 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
 871                                    struct ieee80211_vif *vif)
 872 {
 873         struct wl1271 *wl = hw->priv;
 874         struct wiphy *wiphy = hw->wiphy;
 875         int retries = WL1271_BOOT_RETRIES;
 876         int ret = 0;
 877
 878         wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
 879                      vif->type, vif->addr);
 880
 881         mutex_lock(&wl->mutex);
 882         if (wl->vif) {
 883                 ret = -EBUSY;
 884                 goto out;
 885         }
 886
 887         wl->vif = vif;
 888
 889         switch (vif->type) {
 890         case NL80211_IFTYPE_STATION:
 891                 wl->bss_type = BSS_TYPE_STA_BSS;
 892                 wl->set_bss_type = BSS_TYPE_STA_BSS;
 893                 break;
 894         case NL80211_IFTYPE_ADHOC:
 895                 wl->bss_type = BSS_TYPE_IBSS;
 896                 wl->set_bss_type = BSS_TYPE_STA_BSS;
 897                 break;
 898         default:
 899                 ret = -EOPNOTSUPP;
 900                 goto out;
 901         }
 902
 903         memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
 904
 905         if (wl->state != WL1271_STATE_OFF) {
 906                 wl1271_error("cannot start because not in off state: %d",
 907                              wl->state);
 908                 ret = -EBUSY;
 909                 goto out;
 910         }
 911
 912         while (retries) {
 913                 retries--;
 914                 ret = wl1271_chip_wakeup(wl);
 915                 if (ret < 0)
 916                         goto power_off;
 917
 918                 ret = wl1271_boot(wl);
 919                 if (ret < 0)
 920                         goto power_off;
 921
 922                 ret = wl1271_hw_init(wl);
 923                 if (ret < 0)
 924                         goto irq_disable;
 925
 926                 wl->state = WL1271_STATE_ON;
 927                 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
 928
 929                 /* update hw/fw version info in wiphy struct */
 930                 wiphy->hw_version = wl->chip.id;
 931                 strncpy(wiphy->fw_version, wl->chip.fw_ver,
 932                         sizeof(wiphy->fw_version));
 933
 934                 goto out;
 935
 936 irq_disable:
 937                 wl1271_disable_interrupts(wl);
 938                 mutex_unlock(&wl->mutex);
 939                 /* Unlocking the mutex in the middle of handling is
 940                    inherently unsafe. In this case we deem it safe to do,
 941                    because we need to let any possibly pending IRQ out of
 942                    the system (and while we are WL1271_STATE_OFF the IRQ
 943                    work function will not do anything.) Also, any other
 944                    possible concurrent operations will fail due to the
 945                    current state, hence the wl1271 struct should be safe. */
 946                 cancel_work_sync(&wl->irq_work);
 947                 mutex_lock(&wl->mutex);
 948 power_off:
 949                 wl1271_power_off(wl);
 950         }
 951
 952         wl1271_error("firmware boot failed despite %d retries",
 953                      WL1271_BOOT_RETRIES);
 954 out:
 955         mutex_unlock(&wl->mutex);
 956
 957         if (!ret)
 958                 list_add(&wl->list, &wl_list);
 959
 960         return ret;
 961 }
 962
 963 static void __wl1271_op_remove_interface(struct wl1271 *wl)
 964 {
 965         int i;
 966
 967         wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
 968
 969         wl1271_info("down");
 970
 971         list_del(&wl->list);
 972
 973         WARN_ON(wl->state != WL1271_STATE_ON);
 974
 975         /* enable dyn ps just in case (if left on due to fw crash etc) */
 976         if (wl->bss_type == BSS_TYPE_STA_BSS)
 977                 ieee80211_enable_dyn_ps(wl->vif);
 978
 979         if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
 980                 wl->scan.state = WL1271_SCAN_STATE_IDLE;
 981                 kfree(wl->scan.scanned_ch);
 982                 wl->scan.scanned_ch = NULL;
 983                 ieee80211_scan_completed(wl->hw, true);
 984         }
 985
 986         wl->state = WL1271_STATE_OFF;
 987
 988         wl1271_disable_interrupts(wl);
 989
 990         mutex_unlock(&wl->mutex);
 991
 992         cancel_work_sync(&wl->scan_complete_work);
 993         cancel_work_sync(&wl->irq_work);
 994         cancel_work_sync(&wl->tx_work);
 995         cancel_delayed_work_sync(&wl->pspoll_work);
 996         cancel_delayed_work_sync(&wl->elp_work);
 997
 998         mutex_lock(&wl->mutex);
 999
1000         /* let's notify MAC80211 about the remaining pending TX frames */
1001         wl1271_tx_reset(wl);
1002         wl1271_power_off(wl);
1003
1004         memset(wl->bssid, 0, ETH_ALEN);
1005         memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1006         wl->ssid_len = 0;
1007         wl->bss_type = MAX_BSS_TYPE;
1008         wl->set_bss_type = MAX_BSS_TYPE;
1009         wl->band = IEEE80211_BAND_2GHZ;
1010
1011         wl->rx_counter = 0;
1012         wl->psm_entry_retry = 0;
1013         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1014         wl->tx_blocks_available = 0;
1015         wl->tx_results_count = 0;
1016         wl->tx_packets_count = 0;
1017         wl->tx_security_last_seq = 0;
1018         wl->tx_security_seq = 0;
1019         wl->time_offset = 0;
1020         wl->session_counter = 0;
1021         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1022         wl->sta_rate_set = 0;
1023         wl->flags = 0;
1024         wl->vif = NULL;
1025         wl->filters = 0;
1026
1027         for (i = 0; i < NUM_TX_QUEUES; i++)
1028                 wl->tx_blocks_freed[i] = 0;
1029
1030         wl1271_debugfs_reset(wl);
1031
1032         kfree(wl->fw_status);
1033         wl->fw_status = NULL;
1034         kfree(wl->tx_res_if);
1035         wl->tx_res_if = NULL;
1036         kfree(wl->target_mem_map);
1037         wl->target_mem_map = NULL;
1038 }
1039
1040 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1041                                        struct ieee80211_vif *vif)
1042 {
1043         struct wl1271 *wl = hw->priv;
1044
1045         mutex_lock(&wl->mutex);
1046         WARN_ON(wl->vif != vif);
1047         __wl1271_op_remove_interface(wl);
1048         mutex_unlock(&wl->mutex);
1049 }
1050
1051 static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1052 {
1053         wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1054         wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1055
1056         /* combine requested filters with current filter config */
1057         filters = wl->filters | filters;
1058
1059         wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1060
1061         if (filters & FIF_PROMISC_IN_BSS) {
1062                 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1063                 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1064                 wl->rx_config |= CFG_BSSID_FILTER_EN;
1065         }
1066         if (filters & FIF_BCN_PRBRESP_PROMISC) {
1067                 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1068                 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1069                 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1070         }
1071         if (filters & FIF_OTHER_BSS) {
1072                 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1073                 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1074         }
1075         if (filters & FIF_CONTROL) {
1076                 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1077                 wl->rx_filter |= CFG_RX_CTL_EN;
1078         }
1079         if (filters & FIF_FCSFAIL) {
1080                 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1081                 wl->rx_filter |= CFG_RX_FCS_ERROR;
1082         }
1083 }
1084
1085 static int wl1271_dummy_join(struct wl1271 *wl)
1086 {
1087         int ret = 0;
1088         /* we need to use a dummy BSSID for now */
1089         static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1090                                                   0xad, 0xbe, 0xef };
1091
1092         memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1093
1094         /* pass through frames from all BSS */
1095         wl1271_configure_filters(wl, FIF_OTHER_BSS);
1096
1097         ret = wl1271_cmd_join(wl, wl->set_bss_type);
1098         if (ret < 0)
1099                 goto out;
1100
1101         set_bit(WL1271_FLAG_JOINED, &wl->flags);
1102
1103 out:
1104         return ret;
1105 }
1106
1107 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
1108 {
1109         int ret;
1110
1111         /*
1112          * One of the side effects of the JOIN command is that is clears
1113          * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1114          * to a WPA/WPA2 access point will therefore kill the data-path.
1115          * Currently there is no supported scenario for JOIN during
1116          * association - if it becomes a supported scenario, the WPA/WPA2 keys
1117          * must be handled somehow.
1118          *
1119          */
1120         if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1121                 wl1271_info("JOIN while associated.");
1122
1123         if (set_assoc)
1124                 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1125
1126         ret = wl1271_cmd_join(wl, wl->set_bss_type);
1127         if (ret < 0)
1128                 goto out;
1129
1130         set_bit(WL1271_FLAG_JOINED, &wl->flags);
1131
1132         if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1133                 goto out;
1134
1135         /*
1136          * The join command disable the keep-alive mode, shut down its process,
1137          * and also clear the template config, so we need to reset it all after
1138          * the join. The acx_aid starts the keep-alive process, and the order
1139          * of the commands below is relevant.
1140          */
1141         ret = wl1271_acx_keep_alive_mode(wl, true);
1142         if (ret < 0)
1143                 goto out;
1144
1145         ret = wl1271_acx_aid(wl, wl->aid);
1146         if (ret < 0)
1147                 goto out;
1148
1149         ret = wl1271_cmd_build_klv_null_data(wl);
1150         if (ret < 0)
1151                 goto out;
1152
1153         ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1154                                            ACX_KEEP_ALIVE_TPL_VALID);
1155         if (ret < 0)
1156                 goto out;
1157
1158 out:
1159         return ret;
1160 }
1161
1162 static int wl1271_unjoin(struct wl1271 *wl)
1163 {
1164         int ret;
1165
1166         /* to stop listening to a channel, we disconnect */
1167         ret = wl1271_cmd_disconnect(wl);
1168         if (ret < 0)
1169                 goto out;
1170
1171         clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1172         memset(wl->bssid, 0, ETH_ALEN);
1173
1174         /* stop filterting packets based on bssid */
1175         wl1271_configure_filters(wl, FIF_OTHER_BSS);
1176
1177 out:
1178         return ret;
1179 }
1180
1181 static void wl1271_set_band_rate(struct wl1271 *wl)
1182 {
1183         if (wl->band == IEEE80211_BAND_2GHZ)
1184                 wl->basic_rate_set = wl->conf.tx.basic_rate;
1185         else
1186                 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1187 }
1188
1189 static u32 wl1271_min_rate_get(struct wl1271 *wl)
1190 {
1191         int i;
1192         u32 rate = 0;
1193
1194         if (!wl->basic_rate_set) {
1195                 WARN_ON(1);
1196                 wl->basic_rate_set = wl->conf.tx.basic_rate;
1197         }
1198
1199         for (i = 0; !rate; i++) {
1200                 if ((wl->basic_rate_set >> i) & 0x1)
1201                         rate = 1 << i;
1202         }
1203
1204         return rate;
1205 }
1206
1207 static int wl1271_handle_idle(struct wl1271 *wl, bool idle)
1208 {
1209         int ret;
1210
1211         if (idle) {
1212                 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1213                         ret = wl1271_unjoin(wl);
1214                         if (ret < 0)
1215                                 goto out;
1216                 }
1217                 wl->rate_set = wl1271_min_rate_get(wl);
1218                 wl->sta_rate_set = 0;
1219                 ret = wl1271_acx_rate_policies(wl);
1220                 if (ret < 0)
1221                         goto out;
1222                 ret = wl1271_acx_keep_alive_config(
1223                         wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1224                         ACX_KEEP_ALIVE_TPL_INVALID);
1225                 if (ret < 0)
1226                         goto out;
1227                 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1228         } else {
1229                 /* increment the session counter */
1230                 wl->session_counter++;
1231                 if (wl->session_counter >= SESSION_COUNTER_MAX)
1232                         wl->session_counter = 0;
1233                 ret = wl1271_dummy_join(wl);
1234                 if (ret < 0)
1235                         goto out;
1236                 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1237         }
1238
1239 out:
1240         return ret;
1241 }
1242
1243 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1244 {
1245         struct wl1271 *wl = hw->priv;
1246         struct ieee80211_conf *conf = &hw->conf;
1247         int channel, ret = 0;
1248
1249         channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1250
1251         wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
1252                      channel,
1253                      conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1254                      conf->power_level,
1255                      conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
1256
1257         /*
1258          * mac80211 will go to idle nearly immediately after transmitting some
1259          * frames, such as the deauth. To make sure those frames reach the air,
1260          * wait here until the TX queue is fully flushed.
1261          */
1262         if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1263             (conf->flags & IEEE80211_CONF_IDLE))
1264                 wl1271_tx_flush(wl);
1265
1266         mutex_lock(&wl->mutex);
1267
1268         if (unlikely(wl->state == WL1271_STATE_OFF))
1269                 goto out;
1270
1271         ret = wl1271_ps_elp_wakeup(wl, false);
1272         if (ret < 0)
1273                 goto out;
1274
1275         /* if the channel changes while joined, join again */
1276         if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1277             ((wl->band != conf->channel->band) ||
1278              (wl->channel != channel))) {
1279                 wl->band = conf->channel->band;
1280                 wl->channel = channel;
1281
1282                 /*
1283                  * FIXME: the mac80211 should really provide a fixed rate
1284                  * to use here. for now, just use the smallest possible rate
1285                  * for the band as a fixed rate for association frames and
1286                  * other control messages.
1287                  */
1288                 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1289                         wl1271_set_band_rate(wl);
1290
1291                 wl->basic_rate = wl1271_min_rate_get(wl);
1292                 ret = wl1271_acx_rate_policies(wl);
1293                 if (ret < 0)
1294                         wl1271_warning("rate policy for update channel "
1295                                        "failed %d", ret);
1296
1297                 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1298                         ret = wl1271_join(wl, false);
1299                         if (ret < 0)
1300                                 wl1271_warning("cmd join to update channel "
1301                                                "failed %d", ret);
1302                 }
1303         }
1304
1305         if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1306                 ret = wl1271_handle_idle(wl, conf->flags & IEEE80211_CONF_IDLE);
1307                 if (ret < 0)
1308                         wl1271_warning("idle mode change failed %d", ret);
1309         }
1310
1311         /*
1312          * if mac80211 changes the PSM mode, make sure the mode is not
1313          * incorrectly changed after the pspoll failure active window.
1314          */
1315         if (changed & IEEE80211_CONF_CHANGE_PS)
1316                 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
1317
1318         if (conf->flags & IEEE80211_CONF_PS &&
1319             !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1320                 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1321
1322                 /*
1323                  * We enter PSM only if we're already associated.
1324                  * If we're not, we'll enter it when joining an SSID,
1325                  * through the bss_info_changed() hook.
1326                  */
1327                 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1328                         wl1271_debug(DEBUG_PSM, "psm enabled");
1329                         ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1330                                                  wl->basic_rate_set, true);
1331                 }
1332         } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1333                    test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1334                 wl1271_debug(DEBUG_PSM, "psm disabled");
1335
1336                 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1337
1338                 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1339                         ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1340                                                  wl->basic_rate_set, true);
1341         }
1342
1343         if (conf->power_level != wl->power_level) {
1344                 ret = wl1271_acx_tx_power(wl, conf->power_level);
1345                 if (ret < 0)
1346                         goto out_sleep;
1347
1348                 wl->power_level = conf->power_level;
1349         }
1350
1351 out_sleep:
1352         wl1271_ps_elp_sleep(wl);
1353
1354 out:
1355         mutex_unlock(&wl->mutex);
1356
1357         return ret;
1358 }
1359
1360 struct wl1271_filter_params {
1361         bool enabled;
1362         int mc_list_length;
1363         u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1364 };
1365
1366 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1367                                        struct netdev_hw_addr_list *mc_list)
1368 {
1369         struct wl1271_filter_params *fp;
1370         struct netdev_hw_addr *ha;
1371         struct wl1271 *wl = hw->priv;
1372
1373         if (unlikely(wl->state == WL1271_STATE_OFF))
1374                 return 0;
1375
1376         fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1377         if (!fp) {
1378                 wl1271_error("Out of memory setting filters.");
1379                 return 0;
1380         }
1381
1382         /* update multicast filtering parameters */
1383         fp->mc_list_length = 0;
1384         if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1385                 fp->enabled = false;
1386         } else {
1387                 fp->enabled = true;
1388                 netdev_hw_addr_list_for_each(ha, mc_list) {
1389                         memcpy(fp->mc_list[fp->mc_list_length],
1390                                         ha->addr, ETH_ALEN);
1391                         fp->mc_list_length++;
1392                 }
1393         }
1394
1395         return (u64)(unsigned long)fp;
1396 }
1397
1398 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1399                                   FIF_ALLMULTI | \
1400                                   FIF_FCSFAIL | \
1401                                   FIF_BCN_PRBRESP_PROMISC | \
1402                                   FIF_CONTROL | \
1403                                   FIF_OTHER_BSS)
1404
1405 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1406                                        unsigned int changed,
1407                                        unsigned int *total, u64 multicast)
1408 {
1409         struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1410         struct wl1271 *wl = hw->priv;
1411         int ret;
1412
1413         wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1414
1415         mutex_lock(&wl->mutex);
1416
1417         *total &= WL1271_SUPPORTED_FILTERS;
1418         changed &= WL1271_SUPPORTED_FILTERS;
1419
1420         if (unlikely(wl->state == WL1271_STATE_OFF))
1421                 goto out;
1422
1423         ret = wl1271_ps_elp_wakeup(wl, false);
1424         if (ret < 0)
1425                 goto out;
1426
1427
1428         if (*total & FIF_ALLMULTI)
1429                 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1430         else if (fp)
1431                 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1432                                                    fp->mc_list,
1433                                                    fp->mc_list_length);
1434         if (ret < 0)
1435                 goto out_sleep;
1436
1437         /* determine, whether supported filter values have changed */
1438         if (changed == 0)
1439                 goto out_sleep;
1440
1441         /* configure filters */
1442         wl->filters = *total;
1443         wl1271_configure_filters(wl, 0);
1444
1445         /* apply configured filters */
1446         ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1447         if (ret < 0)
1448                 goto out_sleep;
1449
1450 out_sleep:
1451         wl1271_ps_elp_sleep(wl);
1452
1453 out:
1454         mutex_unlock(&wl->mutex);
1455         kfree(fp);
1456 }
1457
1458 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1459                              struct ieee80211_vif *vif,
1460                              struct ieee80211_sta *sta,
1461                              struct ieee80211_key_conf *key_conf)
1462 {
1463         struct wl1271 *wl = hw->priv;
1464         const u8 *addr;
1465         int ret;
1466         u32 tx_seq_32 = 0;
1467         u16 tx_seq_16 = 0;
1468         u8 key_type;
1469
1470         static const u8 bcast_addr[ETH_ALEN] =
1471                 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1472
1473         wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1474
1475         addr = sta ? sta->addr : bcast_addr;
1476
1477         wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1478         wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1479         wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1480                      key_conf->cipher, key_conf->keyidx,
1481                      key_conf->keylen, key_conf->flags);
1482         wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1483
1484         if (is_zero_ether_addr(addr)) {
1485                 /* We dont support TX only encryption */
1486                 ret = -EOPNOTSUPP;
1487                 goto out;
1488         }
1489
1490         mutex_lock(&wl->mutex);
1491
1492         ret = wl1271_ps_elp_wakeup(wl, false);
1493         if (ret < 0)
1494                 goto out_unlock;
1495
1496         switch (key_conf->cipher) {
1497         case WLAN_CIPHER_SUITE_WEP40:
1498         case WLAN_CIPHER_SUITE_WEP104:
1499                 key_type = KEY_WEP;
1500
1501                 key_conf->hw_key_idx = key_conf->keyidx;
1502                 break;
1503         case WLAN_CIPHER_SUITE_TKIP:
1504                 key_type = KEY_TKIP;
1505
1506                 key_conf->hw_key_idx = key_conf->keyidx;
1507                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1508                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1509                 break;
1510         case WLAN_CIPHER_SUITE_CCMP:
1511                 key_type = KEY_AES;
1512
1513                 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1514                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1515                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1516                 break;
1517         default:
1518                 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
1519
1520                 ret = -EOPNOTSUPP;
1521                 goto out_sleep;
1522         }
1523
1524         switch (cmd) {
1525         case SET_KEY:
1526                 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1527                                          key_conf->keyidx, key_type,
1528                                          key_conf->keylen, key_conf->key,
1529                                          addr, tx_seq_32, tx_seq_16);
1530                 if (ret < 0) {
1531                         wl1271_error("Could not add or replace key");
1532                         goto out_sleep;
1533                 }
1534
1535                 /* the default WEP key needs to be configured at least once */
1536                 if (key_type == KEY_WEP) {
1537                         ret = wl1271_cmd_set_default_wep_key(wl,
1538                                                              wl->default_key);
1539                         if (ret < 0)
1540                                 goto out_sleep;
1541                 }
1542                 break;
1543
1544         case DISABLE_KEY:
1545                 /* The wl1271 does not allow to remove unicast keys - they
1546                    will be cleared automatically on next CMD_JOIN. Ignore the
1547                    request silently, as we dont want the mac80211 to emit
1548                    an error message. */
1549                 if (!is_broadcast_ether_addr(addr))
1550                         break;
1551
1552                 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1553                                          key_conf->keyidx, key_type,
1554                                          key_conf->keylen, key_conf->key,
1555                                          addr, 0, 0);
1556                 if (ret < 0) {
1557                         wl1271_error("Could not remove key");
1558                         goto out_sleep;
1559                 }
1560                 break;
1561
1562         default:
1563                 wl1271_error("Unsupported key cmd 0x%x", cmd);
1564                 ret = -EOPNOTSUPP;
1565                 break;
1566         }
1567
1568 out_sleep:
1569         wl1271_ps_elp_sleep(wl);
1570
1571 out_unlock:
1572         mutex_unlock(&wl->mutex);
1573
1574 out:
1575         return ret;
1576 }
1577
1578 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1579                              struct ieee80211_vif *vif,
1580                              struct cfg80211_scan_request *req)
1581 {
1582         struct wl1271 *wl = hw->priv;
1583         int ret;
1584         u8 *ssid = NULL;
1585         size_t len = 0;
1586
1587         wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1588
1589         if (req->n_ssids) {
1590                 ssid = req->ssids[0].ssid;
1591                 len = req->ssids[0].ssid_len;
1592         }
1593
1594         mutex_lock(&wl->mutex);
1595
1596         ret = wl1271_ps_elp_wakeup(wl, false);
1597         if (ret < 0)
1598                 goto out;
1599
1600         ret = wl1271_scan(hw->priv, ssid, len, req);
1601
1602         wl1271_ps_elp_sleep(wl);
1603
1604 out:
1605         mutex_unlock(&wl->mutex);
1606
1607         return ret;
1608 }
1609
1610 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1611 {
1612         struct wl1271 *wl = hw->priv;
1613         int ret = 0;
1614
1615         mutex_lock(&wl->mutex);
1616
1617         if (unlikely(wl->state == WL1271_STATE_OFF))
1618                 goto out;
1619
1620         ret = wl1271_ps_elp_wakeup(wl, false);
1621         if (ret < 0)
1622                 goto out;
1623
1624         ret = wl1271_acx_rts_threshold(wl, (u16) value);
1625         if (ret < 0)
1626                 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1627
1628         wl1271_ps_elp_sleep(wl);
1629
1630 out:
1631         mutex_unlock(&wl->mutex);
1632
1633         return ret;
1634 }
1635
1636 static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1637 {
1638         u8 *ptr = beacon->data +
1639                 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1640
1641         /* find the location of the ssid in the beacon */
1642         while (ptr < beacon->data + beacon->len) {
1643                 if (ptr[0] == WLAN_EID_SSID) {
1644                         wl->ssid_len = ptr[1];
1645                         memcpy(wl->ssid, ptr+2, wl->ssid_len);
1646                         return;
1647                 }
1648                 ptr += ptr[1];
1649         }
1650         wl1271_error("ad-hoc beacon template has no SSID!\n");
1651 }
1652
1653 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1654                                        struct ieee80211_vif *vif,
1655                                        struct ieee80211_bss_conf *bss_conf,
1656                                        u32 changed)
1657 {
1658         enum wl1271_cmd_ps_mode mode;
1659         struct wl1271 *wl = hw->priv;
1660         bool do_join = false;
1661         bool set_assoc = false;
1662         int ret;
1663
1664         wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1665
1666         mutex_lock(&wl->mutex);
1667
1668         ret = wl1271_ps_elp_wakeup(wl, false);
1669         if (ret < 0)
1670                 goto out;
1671
1672         if ((changed & BSS_CHANGED_BEACON_INT) &&
1673             (wl->bss_type == BSS_TYPE_IBSS)) {
1674                 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
1675                         bss_conf->beacon_int);
1676
1677                 wl->beacon_int = bss_conf->beacon_int;
1678                 do_join = true;
1679         }
1680
1681         if ((changed & BSS_CHANGED_BEACON) &&
1682             (wl->bss_type == BSS_TYPE_IBSS)) {
1683                 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1684
1685                 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
1686
1687                 if (beacon) {
1688                         struct ieee80211_hdr *hdr;
1689
1690                         wl1271_ssid_set(wl, beacon);
1691                         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1692                                                       beacon->data,
1693                                                       beacon->len, 0,
1694                                                       wl1271_min_rate_get(wl));
1695
1696                         if (ret < 0) {
1697                                 dev_kfree_skb(beacon);
1698                                 goto out_sleep;
1699                         }
1700
1701                         hdr = (struct ieee80211_hdr *) beacon->data;
1702                         hdr->frame_control = cpu_to_le16(
1703                                 IEEE80211_FTYPE_MGMT |
1704                                 IEEE80211_STYPE_PROBE_RESP);
1705
1706                         ret = wl1271_cmd_template_set(wl,
1707                                                       CMD_TEMPL_PROBE_RESPONSE,
1708                                                       beacon->data,
1709                                                       beacon->len, 0,
1710                                                       wl1271_min_rate_get(wl));
1711                         dev_kfree_skb(beacon);
1712                         if (ret < 0)
1713                                 goto out_sleep;
1714
1715                         /* Need to update the SSID (for filtering etc) */
1716                         do_join = true;
1717                 }
1718         }
1719
1720         if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1721             (wl->bss_type == BSS_TYPE_IBSS)) {
1722                 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1723                              bss_conf->enable_beacon ? "enabled" : "disabled");
1724
1725                 if (bss_conf->enable_beacon)
1726                         wl->set_bss_type = BSS_TYPE_IBSS;
1727                 else
1728                         wl->set_bss_type = BSS_TYPE_STA_BSS;
1729                 do_join = true;
1730         }
1731
1732         if (changed & BSS_CHANGED_CQM) {
1733                 bool enable = false;
1734                 if (bss_conf->cqm_rssi_thold)
1735                         enable = true;
1736                 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
1737                                                   bss_conf->cqm_rssi_thold,
1738                                                   bss_conf->cqm_rssi_hyst);
1739                 if (ret < 0)
1740                         goto out;
1741                 wl->rssi_thold = bss_conf->cqm_rssi_thold;
1742         }
1743
1744         if ((changed & BSS_CHANGED_BSSID) &&
1745             /*
1746              * Now we know the correct bssid, so we send a new join command
1747              * and enable the BSSID filter
1748              */
1749             memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1750                         memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1751
1752                         ret = wl1271_cmd_build_null_data(wl);
1753                         if (ret < 0)
1754                                 goto out_sleep;
1755
1756                         ret = wl1271_build_qos_null_data(wl);
1757                         if (ret < 0)
1758                                 goto out_sleep;
1759
1760                         /* filter out all packets not from this BSSID */
1761                         wl1271_configure_filters(wl, 0);
1762
1763                         /* Need to update the BSSID (for filtering etc) */
1764                         do_join = true;
1765         }
1766
1767         if (changed & BSS_CHANGED_ASSOC) {
1768                 if (bss_conf->assoc) {
1769                         u32 rates;
1770                         wl->aid = bss_conf->aid;
1771                         set_assoc = true;
1772
1773                         wl->ps_poll_failures = 0;
1774
1775                         /*
1776                          * use basic rates from AP, and determine lowest rate
1777                          * to use with control frames.
1778                          */
1779                         rates = bss_conf->basic_rates;
1780                         wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1781                                                                          rates);
1782                         wl->basic_rate = wl1271_min_rate_get(wl);
1783                         ret = wl1271_acx_rate_policies(wl);
1784                         if (ret < 0)
1785                                 goto out_sleep;
1786
1787                         /*
1788                          * with wl1271, we don't need to update the
1789                          * beacon_int and dtim_period, because the firmware
1790                          * updates it by itself when the first beacon is
1791                          * received after a join.
1792                          */
1793                         ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1794                         if (ret < 0)
1795                                 goto out_sleep;
1796
1797                         /*
1798                          * The SSID is intentionally set to NULL here - the
1799                          * firmware will set the probe request with a
1800                          * broadcast SSID regardless of what we set in the
1801                          * template.
1802                          */
1803                         ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1804                                                          NULL, 0, wl->band);
1805
1806                         /* enable the connection monitoring feature */
1807                         ret = wl1271_acx_conn_monit_params(wl, true);
1808                         if (ret < 0)
1809                                 goto out_sleep;
1810
1811                         /* If we want to go in PSM but we're not there yet */
1812                         if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1813                             !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1814                                 mode = STATION_POWER_SAVE_MODE;
1815                                 ret = wl1271_ps_set_mode(wl, mode,
1816                                                          wl->basic_rate_set,
1817                                                          true);
1818                                 if (ret < 0)
1819                                         goto out_sleep;
1820                         }
1821                 } else {
1822                         /* use defaults when not associated */
1823                         clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
1824                         clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1825                         wl->aid = 0;
1826
1827                         /* re-enable dynamic ps - just in case */
1828                         ieee80211_enable_dyn_ps(wl->vif);
1829
1830                         /* revert back to minimum rates for the current band */
1831                         wl1271_set_band_rate(wl);
1832                         wl->basic_rate = wl1271_min_rate_get(wl);
1833                         ret = wl1271_acx_rate_policies(wl);
1834                         if (ret < 0)
1835                                 goto out_sleep;
1836
1837                         /* disable connection monitor features */
1838                         ret = wl1271_acx_conn_monit_params(wl, false);
1839
1840                         /* Disable the keep-alive feature */
1841                         ret = wl1271_acx_keep_alive_mode(wl, false);
1842
1843                         if (ret < 0)
1844                                 goto out_sleep;
1845                 }
1846
1847         }
1848
1849         if (changed & BSS_CHANGED_ERP_SLOT) {
1850                 if (bss_conf->use_short_slot)
1851                         ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1852                 else
1853                         ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1854                 if (ret < 0) {
1855                         wl1271_warning("Set slot time failed %d", ret);
1856                         goto out_sleep;
1857                 }
1858         }
1859
1860         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1861                 if (bss_conf->use_short_preamble)
1862                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1863                 else
1864                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1865         }
1866
1867         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1868                 if (bss_conf->use_cts_prot)
1869                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1870                 else
1871                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1872                 if (ret < 0) {
1873                         wl1271_warning("Set ctsprotect failed %d", ret);
1874                         goto out_sleep;
1875                 }
1876         }
1877
1878         if (changed & BSS_CHANGED_ARP_FILTER) {
1879                 __be32 addr = bss_conf->arp_addr_list[0];
1880                 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
1881
1882                 if (bss_conf->arp_addr_cnt == 1 && bss_conf->arp_filter_enabled)
1883                         ret = wl1271_acx_arp_ip_filter(wl, true, addr);
1884                 else
1885                         ret = wl1271_acx_arp_ip_filter(wl, false, addr);
1886
1887                 if (ret < 0)
1888                         goto out_sleep;
1889         }
1890
1891         if (do_join) {
1892                 ret = wl1271_join(wl, set_assoc);
1893                 if (ret < 0) {
1894                         wl1271_warning("cmd join failed %d", ret);
1895                         goto out_sleep;
1896                 }
1897         }
1898
1899 out_sleep:
1900         wl1271_ps_elp_sleep(wl);
1901
1902 out:
1903         mutex_unlock(&wl->mutex);
1904 }
1905
1906 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1907                              const struct ieee80211_tx_queue_params *params)
1908 {
1909         struct wl1271 *wl = hw->priv;
1910         u8 ps_scheme;
1911         int ret;
1912
1913         mutex_lock(&wl->mutex);
1914
1915         wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1916
1917         ret = wl1271_ps_elp_wakeup(wl, false);
1918         if (ret < 0)
1919                 goto out;
1920
1921         /* the txop is confed in units of 32us by the mac80211, we need us */
1922         ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1923                                 params->cw_min, params->cw_max,
1924                                 params->aifs, params->txop << 5);
1925         if (ret < 0)
1926                 goto out_sleep;
1927
1928         if (params->uapsd)
1929                 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
1930         else
1931                 ps_scheme = CONF_PS_SCHEME_LEGACY;
1932
1933         ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1934                                  CONF_CHANNEL_TYPE_EDCF,
1935                                  wl1271_tx_get_queue(queue),
1936                                  ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
1937         if (ret < 0)
1938                 goto out_sleep;
1939
1940 out_sleep:
1941         wl1271_ps_elp_sleep(wl);
1942
1943 out:
1944         mutex_unlock(&wl->mutex);
1945
1946         return ret;
1947 }
1948
1949 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
1950 {
1951
1952         struct wl1271 *wl = hw->priv;
1953         u64 mactime = ULLONG_MAX;
1954         int ret;
1955
1956         wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
1957
1958         mutex_lock(&wl->mutex);
1959
1960         ret = wl1271_ps_elp_wakeup(wl, false);
1961         if (ret < 0)
1962                 goto out;
1963
1964         ret = wl1271_acx_tsf_info(wl, &mactime);
1965         if (ret < 0)
1966                 goto out_sleep;
1967
1968 out_sleep:
1969         wl1271_ps_elp_sleep(wl);
1970
1971 out:
1972         mutex_unlock(&wl->mutex);
1973         return mactime;
1974 }
1975
1976 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
1977                                 struct survey_info *survey)
1978 {
1979         struct wl1271 *wl = hw->priv;
1980         struct ieee80211_conf *conf = &hw->conf;
1981
1982         if (idx != 0)
1983                 return -ENOENT;
1984
1985         survey->channel = conf->channel;
1986         survey->filled = SURVEY_INFO_NOISE_DBM;
1987         survey->noise = wl->noise;
1988
1989         return 0;
1990 }
1991
1992 /* can't be const, mac80211 writes to this */
1993 static struct ieee80211_rate wl1271_rates[] = {
1994         { .bitrate = 10,
1995           .hw_value = CONF_HW_BIT_RATE_1MBPS,
1996           .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
1997         { .bitrate = 20,
1998           .hw_value = CONF_HW_BIT_RATE_2MBPS,
1999           .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
2000           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2001         { .bitrate = 55,
2002           .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
2003           .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
2004           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2005         { .bitrate = 110,
2006           .hw_value = CONF_HW_BIT_RATE_11MBPS,
2007           .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
2008           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2009         { .bitrate = 60,
2010           .hw_value = CONF_HW_BIT_RATE_6MBPS,
2011           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2012         { .bitrate = 90,
2013           .hw_value = CONF_HW_BIT_RATE_9MBPS,
2014           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2015         { .bitrate = 120,
2016           .hw_value = CONF_HW_BIT_RATE_12MBPS,
2017           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2018         { .bitrate = 180,
2019           .hw_value = CONF_HW_BIT_RATE_18MBPS,
2020           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2021         { .bitrate = 240,
2022           .hw_value = CONF_HW_BIT_RATE_24MBPS,
2023           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2024         { .bitrate = 360,
2025          .hw_value = CONF_HW_BIT_RATE_36MBPS,
2026          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2027         { .bitrate = 480,
2028           .hw_value = CONF_HW_BIT_RATE_48MBPS,
2029           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2030         { .bitrate = 540,
2031           .hw_value = CONF_HW_BIT_RATE_54MBPS,
2032           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2033 };
2034
2035 /*
2036  * Can't be const, mac80211 writes to this. The order of the channels here
2037  * is designed to improve scanning.
2038  */
2039 static struct ieee80211_channel wl1271_channels[] = {
2040         { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
2041         { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
2042         { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
2043         { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
2044         { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
2045         { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
2046         { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
2047         { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
2048         { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
2049         { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
2050         { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
2051         { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
2052         { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
2053 };
2054
2055 /* mapping to indexes for wl1271_rates */
2056 static const u8 wl1271_rate_to_idx_2ghz[] = {
2057         /* MCS rates are used only with 11n */
2058         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2059         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2060         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2061         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2062         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2063         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2064         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2065         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2066
2067         11,                            /* CONF_HW_RXTX_RATE_54   */
2068         10,                            /* CONF_HW_RXTX_RATE_48   */
2069         9,                             /* CONF_HW_RXTX_RATE_36   */
2070         8,                             /* CONF_HW_RXTX_RATE_24   */
2071
2072         /* TI-specific rate */
2073         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
2074
2075         7,                             /* CONF_HW_RXTX_RATE_18   */
2076         6,                             /* CONF_HW_RXTX_RATE_12   */
2077         3,                             /* CONF_HW_RXTX_RATE_11   */
2078         5,                             /* CONF_HW_RXTX_RATE_9    */
2079         4,                             /* CONF_HW_RXTX_RATE_6    */
2080         2,                             /* CONF_HW_RXTX_RATE_5_5  */
2081         1,                             /* CONF_HW_RXTX_RATE_2    */
2082         0                              /* CONF_HW_RXTX_RATE_1    */
2083 };
2084
2085 /* can't be const, mac80211 writes to this */
2086 static struct ieee80211_supported_band wl1271_band_2ghz = {
2087         .channels = wl1271_channels,
2088         .n_channels = ARRAY_SIZE(wl1271_channels),
2089         .bitrates = wl1271_rates,
2090         .n_bitrates = ARRAY_SIZE(wl1271_rates),
2091 };
2092
2093 /* 5 GHz data rates for WL1273 */
2094 static struct ieee80211_rate wl1271_rates_5ghz[] = {
2095         { .bitrate = 60,
2096           .hw_value = CONF_HW_BIT_RATE_6MBPS,
2097           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2098         { .bitrate = 90,
2099           .hw_value = CONF_HW_BIT_RATE_9MBPS,
2100           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2101         { .bitrate = 120,
2102           .hw_value = CONF_HW_BIT_RATE_12MBPS,
2103           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2104         { .bitrate = 180,
2105           .hw_value = CONF_HW_BIT_RATE_18MBPS,
2106           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2107         { .bitrate = 240,
2108           .hw_value = CONF_HW_BIT_RATE_24MBPS,
2109           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2110         { .bitrate = 360,
2111          .hw_value = CONF_HW_BIT_RATE_36MBPS,
2112          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2113         { .bitrate = 480,
2114           .hw_value = CONF_HW_BIT_RATE_48MBPS,
2115           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2116         { .bitrate = 540,
2117           .hw_value = CONF_HW_BIT_RATE_54MBPS,
2118           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2119 };
2120
2121 /*
2122  * 5 GHz band channels for WL1273 - can't be const, mac80211 writes to this.
2123  * The order of the channels here is designed to improve scanning.
2124  */
2125 static struct ieee80211_channel wl1271_channels_5ghz[] = {
2126         { .hw_value = 183, .center_freq = 4915},
2127         { .hw_value = 188, .center_freq = 4940},
2128         { .hw_value = 8, .center_freq = 5040},
2129         { .hw_value = 34, .center_freq = 5170},
2130         { .hw_value = 44, .center_freq = 5220},
2131         { .hw_value = 60, .center_freq = 5300},
2132         { .hw_value = 112, .center_freq = 5560},
2133         { .hw_value = 132, .center_freq = 5660},
2134         { .hw_value = 157, .center_freq = 5785},
2135         { .hw_value = 184, .center_freq = 4920},
2136         { .hw_value = 189, .center_freq = 4945},
2137         { .hw_value = 9, .center_freq = 5045},
2138         { .hw_value = 36, .center_freq = 5180},
2139         { .hw_value = 46, .center_freq = 5230},
2140         { .hw_value = 64, .center_freq = 5320},
2141         { .hw_value = 116, .center_freq = 5580},
2142         { .hw_value = 136, .center_freq = 5680},
2143         { .hw_value = 192, .center_freq = 4960},
2144         { .hw_value = 11, .center_freq = 5055},
2145         { .hw_value = 38, .center_freq = 5190},
2146         { .hw_value = 48, .center_freq = 5240},
2147         { .hw_value = 100, .center_freq = 5500},
2148         { .hw_value = 120, .center_freq = 5600},
2149         { .hw_value = 140, .center_freq = 5700},
2150         { .hw_value = 185, .center_freq = 4925},
2151         { .hw_value = 196, .center_freq = 4980},
2152         { .hw_value = 12, .center_freq = 5060},
2153         { .hw_value = 40, .center_freq = 5200},
2154         { .hw_value = 52, .center_freq = 5260},
2155         { .hw_value = 104, .center_freq = 5520},
2156         { .hw_value = 124, .center_freq = 5620},
2157         { .hw_value = 149, .center_freq = 5745},
2158         { .hw_value = 161, .center_freq = 5805},
2159         { .hw_value = 187, .center_freq = 4935},
2160         { .hw_value = 7, .center_freq = 5035},
2161         { .hw_value = 16, .center_freq = 5080},
2162         { .hw_value = 42, .center_freq = 5210},
2163         { .hw_value = 56, .center_freq = 5280},
2164         { .hw_value = 108, .center_freq = 5540},
2165         { .hw_value = 128, .center_freq = 5640},
2166         { .hw_value = 153, .center_freq = 5765},
2167         { .hw_value = 165, .center_freq = 5825},
2168 };
2169
2170 /* mapping to indexes for wl1271_rates_5ghz */
2171 static const u8 wl1271_rate_to_idx_5ghz[] = {
2172         /* MCS rates are used only with 11n */
2173         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2174         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2175         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2176         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2177         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2178         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2179         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2180         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2181
2182         7,                             /* CONF_HW_RXTX_RATE_54   */
2183         6,                             /* CONF_HW_RXTX_RATE_48   */
2184         5,                             /* CONF_HW_RXTX_RATE_36   */
2185         4,                             /* CONF_HW_RXTX_RATE_24   */
2186
2187         /* TI-specific rate */
2188         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
2189
2190         3,                             /* CONF_HW_RXTX_RATE_18   */
2191         2,                             /* CONF_HW_RXTX_RATE_12   */
2192         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11   */
2193         1,                             /* CONF_HW_RXTX_RATE_9    */
2194         0,                             /* CONF_HW_RXTX_RATE_6    */
2195         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5  */
2196         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2    */
2197         CONF_HW_RXTX_RATE_UNSUPPORTED  /* CONF_HW_RXTX_RATE_1    */
2198 };
2199
2200 static struct ieee80211_supported_band wl1271_band_5ghz = {
2201         .channels = wl1271_channels_5ghz,
2202         .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2203         .bitrates = wl1271_rates_5ghz,
2204         .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
2205 };
2206
2207 static const u8 *wl1271_band_rate_to_idx[] = {
2208         [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2209         [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2210 };
2211
2212 static const struct ieee80211_ops wl1271_ops = {
2213         .start = wl1271_op_start,
2214         .stop = wl1271_op_stop,
2215         .add_interface = wl1271_op_add_interface,
2216         .remove_interface = wl1271_op_remove_interface,
2217         .config = wl1271_op_config,
2218         .prepare_multicast = wl1271_op_prepare_multicast,
2219         .configure_filter = wl1271_op_configure_filter,
2220         .tx = wl1271_op_tx,
2221         .set_key = wl1271_op_set_key,
2222         .hw_scan = wl1271_op_hw_scan,
2223         .bss_info_changed = wl1271_op_bss_info_changed,
2224         .set_rts_threshold = wl1271_op_set_rts_threshold,
2225         .conf_tx = wl1271_op_conf_tx,
2226         .get_tsf = wl1271_op_get_tsf,
2227         .get_survey = wl1271_op_get_survey,
2228         CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
2229 };
2230
2231
2232 u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate)
2233 {
2234         u8 idx;
2235
2236         BUG_ON(wl->band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
2237
2238         if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2239                 wl1271_error("Illegal RX rate from HW: %d", rate);
2240                 return 0;
2241         }
2242
2243         idx = wl1271_band_rate_to_idx[wl->band][rate];
2244         if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2245                 wl1271_error("Unsupported RX rate from HW: %d", rate);
2246                 return 0;
2247         }
2248
2249         return idx;
2250 }
2251
2252 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2253                                                struct device_attribute *attr,
2254                                                char *buf)
2255 {
2256         struct wl1271 *wl = dev_get_drvdata(dev);
2257         ssize_t len;
2258
2259         len = PAGE_SIZE;
2260
2261         mutex_lock(&wl->mutex);
2262         len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2263                        wl->sg_enabled);
2264         mutex_unlock(&wl->mutex);
2265
2266         return len;
2267
2268 }
2269
2270 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2271                                                 struct device_attribute *attr,
2272                                                 const char *buf, size_t count)
2273 {
2274         struct wl1271 *wl = dev_get_drvdata(dev);
2275         unsigned long res;
2276         int ret;
2277
2278         ret = strict_strtoul(buf, 10, &res);
2279
2280         if (ret < 0) {
2281                 wl1271_warning("incorrect value written to bt_coex_mode");
2282                 return count;
2283         }
2284
2285         mutex_lock(&wl->mutex);
2286
2287         res = !!res;
2288
2289         if (res == wl->sg_enabled)
2290                 goto out;
2291
2292         wl->sg_enabled = res;
2293
2294         if (wl->state == WL1271_STATE_OFF)
2295                 goto out;
2296
2297         ret = wl1271_ps_elp_wakeup(wl, false);
2298         if (ret < 0)
2299                 goto out;
2300
2301         wl1271_acx_sg_enable(wl, wl->sg_enabled);
2302         wl1271_ps_elp_sleep(wl);
2303
2304  out:
2305         mutex_unlock(&wl->mutex);
2306         return count;
2307 }
2308
2309 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2310                    wl1271_sysfs_show_bt_coex_state,
2311                    wl1271_sysfs_store_bt_coex_state);
2312
2313 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
2314                                            struct device_attribute *attr,
2315                                            char *buf)
2316 {
2317         struct wl1271 *wl = dev_get_drvdata(dev);
2318         ssize_t len;
2319
2320         len = PAGE_SIZE;
2321
2322         mutex_lock(&wl->mutex);
2323         if (wl->hw_pg_ver >= 0)
2324                 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
2325         else
2326                 len = snprintf(buf, len, "n/a\n");
2327         mutex_unlock(&wl->mutex);
2328
2329         return len;
2330 }
2331
2332 static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
2333                    wl1271_sysfs_show_hw_pg_ver, NULL);
2334
2335 int wl1271_register_hw(struct wl1271 *wl)
2336 {
2337         int ret;
2338
2339         if (wl->mac80211_registered)
2340                 return 0;
2341
2342         SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2343
2344         ret = ieee80211_register_hw(wl->hw);
2345         if (ret < 0) {
2346                 wl1271_error("unable to register mac80211 hw: %d", ret);
2347                 return ret;
2348         }
2349
2350         wl->mac80211_registered = true;
2351
2352         register_netdevice_notifier(&wl1271_dev_notifier);
2353
2354         wl1271_notice("loaded");
2355
2356         return 0;
2357 }
2358 EXPORT_SYMBOL_GPL(wl1271_register_hw);
2359
2360 void wl1271_unregister_hw(struct wl1271 *wl)
2361 {
2362         unregister_netdevice_notifier(&wl1271_dev_notifier);
2363         ieee80211_unregister_hw(wl->hw);
2364         wl->mac80211_registered = false;
2365
2366 }
2367 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2368
2369 int wl1271_init_ieee80211(struct wl1271 *wl)
2370 {
2371         /* The tx descriptor buffer and the TKIP space. */
2372         wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2373                 sizeof(struct wl1271_tx_hw_descr);
2374
2375         /* unit us */
2376         /* FIXME: find a proper value */
2377         wl->hw->channel_change_time = 10000;
2378         wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
2379
2380         wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
2381                 IEEE80211_HW_BEACON_FILTER |
2382                 IEEE80211_HW_SUPPORTS_PS |
2383                 IEEE80211_HW_SUPPORTS_UAPSD |
2384                 IEEE80211_HW_HAS_RATE_CONTROL |
2385                 IEEE80211_HW_CONNECTION_MONITOR |
2386                 IEEE80211_HW_SUPPORTS_CQM_RSSI;
2387
2388         wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2389                 BIT(NL80211_IFTYPE_ADHOC);
2390         wl->hw->wiphy->max_scan_ssids = 1;
2391         wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2392         wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2393
2394         wl->hw->queues = 4;
2395         wl->hw->max_rates = 1;
2396
2397         SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
2398
2399         return 0;
2400 }
2401 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
2402
2403 #define WL1271_DEFAULT_CHANNEL 0
2404
2405 struct ieee80211_hw *wl1271_alloc_hw(void)
2406 {
2407         struct ieee80211_hw *hw;
2408         struct platform_device *plat_dev = NULL;
2409         struct wl1271 *wl;
2410         int i, ret;
2411
2412         hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2413         if (!hw) {
2414                 wl1271_error("could not alloc ieee80211_hw");
2415                 ret = -ENOMEM;
2416                 goto err_hw_alloc;
2417         }
2418
2419         plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
2420         if (!plat_dev) {
2421                 wl1271_error("could not allocate platform_device");
2422                 ret = -ENOMEM;
2423                 goto err_plat_alloc;
2424         }
2425
2426         wl = hw->priv;
2427         memset(wl, 0, sizeof(*wl));
2428
2429         INIT_LIST_HEAD(&wl->list);
2430
2431         wl->hw = hw;
2432         wl->plat_dev = plat_dev;
2433
2434         skb_queue_head_init(&wl->tx_queue);
2435
2436         INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
2437         INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
2438         wl->channel = WL1271_DEFAULT_CHANNEL;
2439         wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
2440         wl->default_key = 0;
2441         wl->rx_counter = 0;
2442         wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2443         wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
2444         wl->psm_entry_retry = 0;
2445         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2446         wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2447         wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
2448         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2449         wl->sta_rate_set = 0;
2450         wl->band = IEEE80211_BAND_2GHZ;
2451         wl->vif = NULL;
2452         wl->flags = 0;
2453         wl->sg_enabled = true;
2454         wl->hw_pg_ver = -1;
2455
2456         for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
2457                 wl->tx_frames[i] = NULL;
2458
2459         spin_lock_init(&wl->wl_lock);
2460
2461         wl->state = WL1271_STATE_OFF;
2462         mutex_init(&wl->mutex);
2463
2464         /* Apply default driver configuration. */
2465         wl1271_conf_init(wl);
2466
2467         wl1271_debugfs_init(wl);
2468
2469         /* Register platform device */
2470         ret = platform_device_register(wl->plat_dev);
2471         if (ret) {
2472                 wl1271_error("couldn't register platform device");
2473                 goto err_hw;
2474         }
2475         dev_set_drvdata(&wl->plat_dev->dev, wl);
2476
2477         /* Create sysfs file to control bt coex state */
2478         ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2479         if (ret < 0) {
2480                 wl1271_error("failed to create sysfs file bt_coex_state");
2481                 goto err_platform;
2482         }
2483
2484         /* Create sysfs file to get HW PG version */
2485         ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
2486         if (ret < 0) {
2487                 wl1271_error("failed to create sysfs file hw_pg_ver");
2488                 goto err_bt_coex_state;
2489         }
2490
2491         return hw;
2492
2493 err_bt_coex_state:
2494         device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2495
2496 err_platform:
2497         platform_device_unregister(wl->plat_dev);
2498
2499 err_hw:
2500         wl1271_debugfs_exit(wl);
2501         kfree(plat_dev);
2502
2503 err_plat_alloc:
2504         ieee80211_free_hw(hw);
2505
2506 err_hw_alloc:
2507
2508         return ERR_PTR(ret);
2509 }
2510 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
2511
2512 int wl1271_free_hw(struct wl1271 *wl)
2513 {
2514         platform_device_unregister(wl->plat_dev);
2515         kfree(wl->plat_dev);
2516
2517         wl1271_debugfs_exit(wl);
2518
2519         vfree(wl->fw);
2520         wl->fw = NULL;
2521         kfree(wl->nvs);
2522         wl->nvs = NULL;
2523
2524         kfree(wl->fw_status);
2525         kfree(wl->tx_res_if);
2526
2527         ieee80211_free_hw(wl->hw);
2528
2529         return 0;
2530 }
2531 EXPORT_SYMBOL_GPL(wl1271_free_hw);
2532
2533 MODULE_LICENSE("GPL");
2534 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2535 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");