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