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