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