drivers/net/wireless/wl12xx/wl1271_main.c

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