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 #include <linux/wl12xx.h>
  34
  35 #include "wl12xx.h"
  36 #include "wl12xx_80211.h"
  37 #include "reg.h"
  38 #include "io.h"
  39 #include "event.h"
  40 #include "tx.h"
  41 #include "rx.h"
  42 #include "ps.h"
  43 #include "init.h"
  44 #include "debugfs.h"
  45 #include "cmd.h"
  46 #include "boot.h"
  47 #include "testmode.h"
  48 #include "scan.h"
  49
  50 #define WL1271_BOOT_RETRIES 3
  51
  52 static struct conf_drv_settings default_conf = {
  53         .sg = {
  54                 .sta_params = {
  55                         [CONF_SG_BT_PER_THRESHOLD]                  = 7500,
  56                         [CONF_SG_HV3_MAX_OVERRIDE]                  = 0,
  57                         [CONF_SG_BT_NFS_SAMPLE_INTERVAL]            = 400,
  58                         [CONF_SG_BT_LOAD_RATIO]                     = 200,
  59                         [CONF_SG_AUTO_PS_MODE]                      = 1,
  60                         [CONF_SG_AUTO_SCAN_PROBE_REQ]               = 170,
  61                         [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3]   = 50,
  62                         [CONF_SG_ANTENNA_CONFIGURATION]             = 0,
  63                         [CONF_SG_BEACON_MISS_PERCENT]               = 60,
  64                         [CONF_SG_RATE_ADAPT_THRESH]                 = 12,
  65                         [CONF_SG_RATE_ADAPT_SNR]                    = 0,
  66                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR]      = 10,
  67                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR]      = 30,
  68                         [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR]      = 8,
  69                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR]       = 20,
  70                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR]       = 50,
  71                         /* Note: with UPSD, this should be 4 */
  72                         [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR]       = 8,
  73                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR]     = 7,
  74                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR]     = 25,
  75                         [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR]     = 20,
  76                         /* Note: with UPDS, this should be 15 */
  77                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR]      = 8,
  78                         /* Note: with UPDS, this should be 50 */
  79                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR]      = 40,
  80                         /* Note: with UPDS, this should be 10 */
  81                         [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR]      = 20,
  82                         [CONF_SG_RXT]                               = 1200,
  83                         [CONF_SG_TXT]                               = 1000,
  84                         [CONF_SG_ADAPTIVE_RXT_TXT]                  = 1,
  85                         [CONF_SG_PS_POLL_TIMEOUT]                   = 10,
  86                         [CONF_SG_UPSD_TIMEOUT]                      = 10,
  87                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
  88                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
  89                         [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
  90                         [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR]  = 8,
  91                         [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR]  = 20,
  92                         [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR]  = 15,
  93                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR]         = 20,
  94                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR]         = 50,
  95                         [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR]         = 10,
  96                         [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3]  = 200,
  97                         [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
  98                         [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME]         = 75,
  99                         [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME]       = 15,
 100                         [CONF_SG_HV3_MAX_SERVED]                    = 6,
 101                         [CONF_SG_DHCP_TIME]                         = 5000,
 102                         [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP]  = 100,
 103                 },
 104                 .ap_params = {
 105                         [CONF_SG_BT_PER_THRESHOLD]                  = 7500,
 106                         [CONF_SG_HV3_MAX_OVERRIDE]                  = 0,
 107                         [CONF_SG_BT_NFS_SAMPLE_INTERVAL]            = 400,
 108                         [CONF_SG_BT_LOAD_RATIO]                     = 50,
 109                         [CONF_SG_AUTO_PS_MODE]                      = 1,
 110                         [CONF_SG_AUTO_SCAN_PROBE_REQ]               = 170,
 111                         [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3]   = 50,
 112                         [CONF_SG_ANTENNA_CONFIGURATION]             = 0,
 113                         [CONF_SG_BEACON_MISS_PERCENT]               = 60,
 114                         [CONF_SG_RATE_ADAPT_THRESH]                 = 64,
 115                         [CONF_SG_RATE_ADAPT_SNR]                    = 1,
 116                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR]      = 10,
 117                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR]      = 25,
 118                         [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR]      = 25,
 119                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR]       = 20,
 120                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR]       = 25,
 121                         [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR]       = 25,
 122                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR]     = 7,
 123                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR]     = 25,
 124                         [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR]     = 25,
 125                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR]      = 8,
 126                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR]      = 25,
 127                         [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR]      = 25,
 128                         [CONF_SG_RXT]                               = 1200,
 129                         [CONF_SG_TXT]                               = 1000,
 130                         [CONF_SG_ADAPTIVE_RXT_TXT]                  = 1,
 131                         [CONF_SG_PS_POLL_TIMEOUT]                   = 10,
 132                         [CONF_SG_UPSD_TIMEOUT]                      = 10,
 133                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
 134                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
 135                         [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
 136                         [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR]  = 8,
 137                         [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR]  = 20,
 138                         [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR]  = 15,
 139                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR]         = 20,
 140                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR]         = 50,
 141                         [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR]         = 10,
 142                         [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3]  = 200,
 143                         [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
 144                         [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME]         = 75,
 145                         [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME]       = 15,
 146                         [CONF_SG_HV3_MAX_SERVED]                    = 6,
 147                         [CONF_SG_DHCP_TIME]                         = 5000,
 148                         [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP]  = 100,
 149                         [CONF_SG_TEMP_PARAM_1]                      = 0,
 150                         [CONF_SG_TEMP_PARAM_2]                      = 0,
 151                         [CONF_SG_TEMP_PARAM_3]                      = 0,
 152                         [CONF_SG_TEMP_PARAM_4]                      = 0,
 153                         [CONF_SG_TEMP_PARAM_5]                      = 0,
 154                         [CONF_SG_AP_BEACON_MISS_TX]                 = 3,
 155                         [CONF_SG_RX_WINDOW_LENGTH]                  = 6,
 156                         [CONF_SG_AP_CONNECTION_PROTECTION_TIME]     = 50,
 157                         [CONF_SG_TEMP_PARAM_6]                      = 1,
 158                 },
 159                 .state = CONF_SG_PROTECTIVE,
 160         },
 161         .rx = {
 162                 .rx_msdu_life_time           = 512000,
 163                 .packet_detection_threshold  = 0,
 164                 .ps_poll_timeout             = 15,
 165                 .upsd_timeout                = 15,
 166                 .rts_threshold               = IEEE80211_MAX_RTS_THRESHOLD,
 167                 .rx_cca_threshold            = 0,
 168                 .irq_blk_threshold           = 0xFFFF,
 169                 .irq_pkt_threshold           = 0,
 170                 .irq_timeout                 = 600,
 171                 .queue_type                  = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
 172         },
 173         .tx = {
 174                 .tx_energy_detection         = 0,
 175                 .sta_rc_conf                 = {
 176                         .enabled_rates       = 0,
 177                         .short_retry_limit   = 10,
 178                         .long_retry_limit    = 10,
 179                         .aflags              = 0,
 180                 },
 181                 .ac_conf_count               = 4,
 182                 .ac_conf                     = {
 183                         [CONF_TX_AC_BE] = {
 184                                 .ac          = CONF_TX_AC_BE,
 185                                 .cw_min      = 15,
 186                                 .cw_max      = 63,
 187                                 .aifsn       = 3,
 188                                 .tx_op_limit = 0,
 189                         },
 190                         [CONF_TX_AC_BK] = {
 191                                 .ac          = CONF_TX_AC_BK,
 192                                 .cw_min      = 15,
 193                                 .cw_max      = 63,
 194                                 .aifsn       = 7,
 195                                 .tx_op_limit = 0,
 196                         },
 197                         [CONF_TX_AC_VI] = {
 198                                 .ac          = CONF_TX_AC_VI,
 199                                 .cw_min      = 15,
 200                                 .cw_max      = 63,
 201                                 .aifsn       = CONF_TX_AIFS_PIFS,
 202                                 .tx_op_limit = 3008,
 203                         },
 204                         [CONF_TX_AC_VO] = {
 205                                 .ac          = CONF_TX_AC_VO,
 206                                 .cw_min      = 15,
 207                                 .cw_max      = 63,
 208                                 .aifsn       = CONF_TX_AIFS_PIFS,
 209                                 .tx_op_limit = 1504,
 210                         },
 211                 },
 212                 .ap_max_tx_retries = 100,
 213                 .tid_conf_count = 4,
 214                 .tid_conf = {
 215                         [CONF_TX_AC_BE] = {
 216                                 .queue_id    = CONF_TX_AC_BE,
 217                                 .channel_type = CONF_CHANNEL_TYPE_EDCF,
 218                                 .tsid        = CONF_TX_AC_BE,
 219                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
 220                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
 221                                 .apsd_conf   = {0, 0},
 222                         },
 223                         [CONF_TX_AC_BK] = {
 224                                 .queue_id    = CONF_TX_AC_BK,
 225                                 .channel_type = CONF_CHANNEL_TYPE_EDCF,
 226                                 .tsid        = CONF_TX_AC_BK,
 227                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
 228                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
 229                                 .apsd_conf   = {0, 0},
 230                         },
 231                         [CONF_TX_AC_VI] = {
 232                                 .queue_id    = CONF_TX_AC_VI,
 233                                 .channel_type = CONF_CHANNEL_TYPE_EDCF,
 234                                 .tsid        = CONF_TX_AC_VI,
 235                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
 236                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
 237                                 .apsd_conf   = {0, 0},
 238                         },
 239                         [CONF_TX_AC_VO] = {
 240                                 .queue_id    = CONF_TX_AC_VO,
 241                                 .channel_type = CONF_CHANNEL_TYPE_EDCF,
 242                                 .tsid        = CONF_TX_AC_VO,
 243                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
 244                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
 245                                 .apsd_conf   = {0, 0},
 246                         },
 247                 },
 248                 .frag_threshold              = IEEE80211_MAX_FRAG_THRESHOLD,
 249                 .tx_compl_timeout            = 700,
 250                 .tx_compl_threshold          = 4,
 251                 .basic_rate                  = CONF_HW_BIT_RATE_1MBPS,
 252                 .basic_rate_5                = CONF_HW_BIT_RATE_6MBPS,
 253                 .tmpl_short_retry_limit      = 10,
 254                 .tmpl_long_retry_limit       = 10,
 255         },
 256         .conn = {
 257                 .wake_up_event               = CONF_WAKE_UP_EVENT_DTIM,
 258                 .listen_interval             = 1,
 259                 .bcn_filt_mode               = CONF_BCN_FILT_MODE_ENABLED,
 260                 .bcn_filt_ie_count           = 2,
 261                 .bcn_filt_ie = {
 262                         [0] = {
 263                                 .ie          = WLAN_EID_CHANNEL_SWITCH,
 264                                 .rule        = CONF_BCN_RULE_PASS_ON_APPEARANCE,
 265                         },
 266                         [1] = {
 267                                 .ie          = WLAN_EID_HT_INFORMATION,
 268                                 .rule        = CONF_BCN_RULE_PASS_ON_CHANGE,
 269                         },
 270                 },
 271                 .synch_fail_thold            = 10,
 272                 .bss_lose_timeout            = 100,
 273                 .beacon_rx_timeout           = 10000,
 274                 .broadcast_timeout           = 20000,
 275                 .rx_broadcast_in_ps          = 1,
 276                 .ps_poll_threshold           = 10,
 277                 .ps_poll_recovery_period     = 700,
 278                 .bet_enable                  = CONF_BET_MODE_ENABLE,
 279                 .bet_max_consecutive         = 50,
 280                 .psm_entry_retries           = 5,
 281                 .psm_exit_retries            = 16,
 282                 .psm_entry_nullfunc_retries  = 3,
 283                 .psm_entry_hangover_period   = 1,
 284                 .keep_alive_interval         = 55000,
 285                 .max_listen_interval         = 20,
 286         },
 287         .itrim = {
 288                 .enable = false,
 289                 .timeout = 50000,
 290         },
 291         .pm_config = {
 292                 .host_clk_settling_time = 5000,
 293                 .host_fast_wakeup_support = false
 294         },
 295         .roam_trigger = {
 296                 .trigger_pacing               = 1,
 297                 .avg_weight_rssi_beacon       = 20,
 298                 .avg_weight_rssi_data         = 10,
 299                 .avg_weight_snr_beacon        = 20,
 300                 .avg_weight_snr_data          = 10,
 301         },
 302         .scan = {
 303                 .min_dwell_time_active        = 7500,
 304                 .max_dwell_time_active        = 30000,
 305                 .min_dwell_time_passive       = 100000,
 306                 .max_dwell_time_passive       = 100000,
 307                 .num_probe_reqs               = 2,
 308         },
 309         .sched_scan = {
 310                 /* sched_scan requires dwell times in TU instead of TU/1000 */
 311                 .min_dwell_time_active = 8,
 312                 .max_dwell_time_active = 30,
 313                 .dwell_time_passive    = 100,
 314                 .dwell_time_dfs        = 150,
 315                 .num_probe_reqs        = 2,
 316                 .rssi_threshold        = -90,
 317                 .snr_threshold         = 0,
 318         },
 319         .rf = {
 320                 .tx_per_channel_power_compensation_2 = {
 321                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 322                 },
 323                 .tx_per_channel_power_compensation_5 = {
 324                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 325                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 326                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 327                 },
 328         },
 329         .ht = {
 330                 .tx_ba_win_size = 64,
 331                 .inactivity_timeout = 10000,
 332         },
 333         .mem_wl127x = {
 334                 .num_stations                 = 1,
 335                 .ssid_profiles                = 1,
 336                 .rx_block_num                 = 70,
 337                 .tx_min_block_num             = 40,
 338                 .dynamic_memory               = 1,
 339                 .min_req_tx_blocks            = 100,
 340                 .min_req_rx_blocks            = 22,
 341                 .tx_min                       = 27,
 342         },
 343         .mem_wl128x = {
 344                 .num_stations                 = 1,
 345                 .ssid_profiles                = 1,
 346                 .rx_block_num                 = 40,
 347                 .tx_min_block_num             = 40,
 348                 .dynamic_memory               = 1,
 349                 .min_req_tx_blocks            = 45,
 350                 .min_req_rx_blocks            = 22,
 351                 .tx_min                       = 27,
 352         },
 353         .fm_coex = {
 354                 .enable                       = true,
 355                 .swallow_period               = 5,
 356                 .n_divider_fref_set_1         = 0xff,       /* default */
 357                 .n_divider_fref_set_2         = 12,
 358                 .m_divider_fref_set_1         = 148,
 359                 .m_divider_fref_set_2         = 0xffff,     /* default */
 360                 .coex_pll_stabilization_time  = 0xffffffff, /* default */
 361                 .ldo_stabilization_time       = 0xffff,     /* default */
 362                 .fm_disturbed_band_margin     = 0xff,       /* default */
 363                 .swallow_clk_diff             = 0xff,       /* default */
 364         },
 365         .rx_streaming = {
 366                 .duration                      = 150,
 367                 .queues                        = 0x1,
 368                 .interval                      = 20,
 369         },
 370         .hci_io_ds = HCI_IO_DS_6MA,
 371 };
 372
 373 static void __wl1271_op_remove_interface(struct wl1271 *wl,
 374                                          bool reset_tx_queues);
 375 static void wl1271_free_ap_keys(struct wl1271 *wl);
 376
 377
 378 static void wl1271_device_release(struct device *dev)
 379 {
 380
 381 }
 382
 383 static struct platform_device wl1271_device = {
 384         .name           = "wl1271",
 385         .id             = -1,
 386
 387         /* device model insists to have a release function */
 388         .dev            = {
 389                 .release = wl1271_device_release,
 390         },
 391 };
 392
 393 static DEFINE_MUTEX(wl_list_mutex);
 394 static LIST_HEAD(wl_list);
 395
 396 static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
 397                              void *arg)
 398 {
 399         struct net_device *dev = arg;
 400         struct wireless_dev *wdev;
 401         struct wiphy *wiphy;
 402         struct ieee80211_hw *hw;
 403         struct wl1271 *wl;
 404         struct wl1271 *wl_temp;
 405         int ret = 0;
 406
 407         /* Check that this notification is for us. */
 408         if (what != NETDEV_CHANGE)
 409                 return NOTIFY_DONE;
 410
 411         wdev = dev->ieee80211_ptr;
 412         if (wdev == NULL)
 413                 return NOTIFY_DONE;
 414
 415         wiphy = wdev->wiphy;
 416         if (wiphy == NULL)
 417                 return NOTIFY_DONE;
 418
 419         hw = wiphy_priv(wiphy);
 420         if (hw == NULL)
 421                 return NOTIFY_DONE;
 422
 423         wl_temp = hw->priv;
 424         mutex_lock(&wl_list_mutex);
 425         list_for_each_entry(wl, &wl_list, list) {
 426                 if (wl == wl_temp)
 427                         break;
 428         }
 429         mutex_unlock(&wl_list_mutex);
 430         if (wl != wl_temp)
 431                 return NOTIFY_DONE;
 432
 433         mutex_lock(&wl->mutex);
 434
 435         if (wl->state == WL1271_STATE_OFF)
 436                 goto out;
 437
 438         if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
 439                 goto out;
 440
 441         ret = wl1271_ps_elp_wakeup(wl);
 442         if (ret < 0)
 443                 goto out;
 444
 445         if ((dev->operstate == IF_OPER_UP) &&
 446             !test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags)) {
 447                 wl1271_cmd_set_sta_state(wl);
 448                 wl1271_info("Association completed.");
 449         }
 450
 451         wl1271_ps_elp_sleep(wl);
 452
 453 out:
 454         mutex_unlock(&wl->mutex);
 455
 456         return NOTIFY_OK;
 457 }
 458
 459 static int wl1271_reg_notify(struct wiphy *wiphy,
 460                              struct regulatory_request *request)
 461 {
 462         struct ieee80211_supported_band *band;
 463         struct ieee80211_channel *ch;
 464         int i;
 465
 466         band = wiphy->bands[IEEE80211_BAND_5GHZ];
 467         for (i = 0; i < band->n_channels; i++) {
 468                 ch = &band->channels[i];
 469                 if (ch->flags & IEEE80211_CHAN_DISABLED)
 470                         continue;
 471
 472                 if (ch->flags & IEEE80211_CHAN_RADAR)
 473                         ch->flags |= IEEE80211_CHAN_NO_IBSS |
 474                                      IEEE80211_CHAN_PASSIVE_SCAN;
 475
 476         }
 477
 478         return 0;
 479 }
 480
 481 static void wl1271_conf_init(struct wl1271 *wl)
 482 {
 483
 484         /*
 485          * This function applies the default configuration to the driver. This
 486          * function is invoked upon driver load (spi probe.)
 487          *
 488          * The configuration is stored in a run-time structure in order to
 489          * facilitate for run-time adjustment of any of the parameters. Making
 490          * changes to the configuration structure will apply the new values on
 491          * the next interface up (wl1271_op_start.)
 492          */
 493
 494         /* apply driver default configuration */
 495         memcpy(&wl->conf, &default_conf, sizeof(default_conf));
 496 }
 497
 498
 499 static int wl1271_plt_init(struct wl1271 *wl)
 500 {
 501         struct conf_tx_ac_category *conf_ac;
 502         struct conf_tx_tid *conf_tid;
 503         int ret, i;
 504
 505         if (wl->chip.id == CHIP_ID_1283_PG20)
 506                 ret = wl128x_cmd_general_parms(wl);
 507         else
 508                 ret = wl1271_cmd_general_parms(wl);
 509         if (ret < 0)
 510                 return ret;
 511
 512         if (wl->chip.id == CHIP_ID_1283_PG20)
 513                 ret = wl128x_cmd_radio_parms(wl);
 514         else
 515                 ret = wl1271_cmd_radio_parms(wl);
 516         if (ret < 0)
 517                 return ret;
 518
 519         if (wl->chip.id != CHIP_ID_1283_PG20) {
 520                 ret = wl1271_cmd_ext_radio_parms(wl);
 521                 if (ret < 0)
 522                         return ret;
 523         }
 524         if (ret < 0)
 525                 return ret;
 526
 527         /* Chip-specific initializations */
 528         ret = wl1271_chip_specific_init(wl);
 529         if (ret < 0)
 530                 return ret;
 531
 532         ret = wl1271_sta_init_templates_config(wl);
 533         if (ret < 0)
 534                 return ret;
 535
 536         ret = wl1271_acx_init_mem_config(wl);
 537         if (ret < 0)
 538                 return ret;
 539
 540         /* PHY layer config */
 541         ret = wl1271_init_phy_config(wl);
 542         if (ret < 0)
 543                 goto out_free_memmap;
 544
 545         ret = wl1271_acx_dco_itrim_params(wl);
 546         if (ret < 0)
 547                 goto out_free_memmap;
 548
 549         /* Initialize connection monitoring thresholds */
 550         ret = wl1271_acx_conn_monit_params(wl, false);
 551         if (ret < 0)
 552                 goto out_free_memmap;
 553
 554         /* Bluetooth WLAN coexistence */
 555         ret = wl1271_init_pta(wl);
 556         if (ret < 0)
 557                 goto out_free_memmap;
 558
 559         /* FM WLAN coexistence */
 560         ret = wl1271_acx_fm_coex(wl);
 561         if (ret < 0)
 562                 goto out_free_memmap;
 563
 564         /* Energy detection */
 565         ret = wl1271_init_energy_detection(wl);
 566         if (ret < 0)
 567                 goto out_free_memmap;
 568
 569         ret = wl1271_acx_sta_mem_cfg(wl);
 570         if (ret < 0)
 571                 goto out_free_memmap;
 572
 573         /* Default fragmentation threshold */
 574         ret = wl1271_acx_frag_threshold(wl, wl->conf.tx.frag_threshold);
 575         if (ret < 0)
 576                 goto out_free_memmap;
 577
 578         /* Default TID/AC configuration */
 579         BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count);
 580         for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
 581                 conf_ac = &wl->conf.tx.ac_conf[i];
 582                 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
 583                                         conf_ac->cw_max, conf_ac->aifsn,
 584                                         conf_ac->tx_op_limit);
 585                 if (ret < 0)
 586                         goto out_free_memmap;
 587
 588                 conf_tid = &wl->conf.tx.tid_conf[i];
 589                 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
 590                                          conf_tid->channel_type,
 591                                          conf_tid->tsid,
 592                                          conf_tid->ps_scheme,
 593                                          conf_tid->ack_policy,
 594                                          conf_tid->apsd_conf[0],
 595                                          conf_tid->apsd_conf[1]);
 596                 if (ret < 0)
 597                         goto out_free_memmap;
 598         }
 599
 600         /* Enable data path */
 601         ret = wl1271_cmd_data_path(wl, 1);
 602         if (ret < 0)
 603                 goto out_free_memmap;
 604
 605         /* Configure for CAM power saving (ie. always active) */
 606         ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
 607         if (ret < 0)
 608                 goto out_free_memmap;
 609
 610         /* configure PM */
 611         ret = wl1271_acx_pm_config(wl);
 612         if (ret < 0)
 613                 goto out_free_memmap;
 614
 615         return 0;
 616
 617  out_free_memmap:
 618         kfree(wl->target_mem_map);
 619         wl->target_mem_map = NULL;
 620
 621         return ret;
 622 }
 623
 624 static void wl1271_irq_ps_regulate_link(struct wl1271 *wl, u8 hlid, u8 tx_blks)
 625 {
 626         bool fw_ps;
 627
 628         /* only regulate station links */
 629         if (hlid < WL1271_AP_STA_HLID_START)
 630                 return;
 631
 632         fw_ps = test_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
 633
 634         /*
 635          * Wake up from high level PS if the STA is asleep with too little
 636          * blocks in FW or if the STA is awake.
 637          */
 638         if (!fw_ps || tx_blks < WL1271_PS_STA_MAX_BLOCKS)
 639                 wl1271_ps_link_end(wl, hlid);
 640
 641         /* Start high-level PS if the STA is asleep with enough blocks in FW */
 642         else if (fw_ps && tx_blks >= WL1271_PS_STA_MAX_BLOCKS)
 643                 wl1271_ps_link_start(wl, hlid, true);
 644 }
 645
 646 static void wl1271_irq_update_links_status(struct wl1271 *wl,
 647                                        struct wl1271_fw_ap_status *status)
 648 {
 649         u32 cur_fw_ps_map;
 650         u8 hlid;
 651
 652         cur_fw_ps_map = le32_to_cpu(status->link_ps_bitmap);
 653         if (wl->ap_fw_ps_map != cur_fw_ps_map) {
 654                 wl1271_debug(DEBUG_PSM,
 655                              "link ps prev 0x%x cur 0x%x changed 0x%x",
 656                              wl->ap_fw_ps_map, cur_fw_ps_map,
 657                              wl->ap_fw_ps_map ^ cur_fw_ps_map);
 658
 659                 wl->ap_fw_ps_map = cur_fw_ps_map;
 660         }
 661
 662         for (hlid = WL1271_AP_STA_HLID_START; hlid < AP_MAX_LINKS; hlid++) {
 663                 u8 cnt = status->tx_lnk_free_blks[hlid] -
 664                         wl->links[hlid].prev_freed_blks;
 665
 666                 wl->links[hlid].prev_freed_blks =
 667                         status->tx_lnk_free_blks[hlid];
 668                 wl->links[hlid].allocated_blks -= cnt;
 669
 670                 wl1271_irq_ps_regulate_link(wl, hlid,
 671                                             wl->links[hlid].allocated_blks);
 672         }
 673 }
 674
 675 static void wl1271_fw_status(struct wl1271 *wl,
 676                              struct wl1271_fw_full_status *full_status)
 677 {
 678         struct wl1271_fw_common_status *status = &full_status->common;
 679         struct timespec ts;
 680         u32 old_tx_blk_count = wl->tx_blocks_available;
 681         u32 freed_blocks = 0;
 682         int i;
 683
 684         if (wl->bss_type == BSS_TYPE_AP_BSS) {
 685                 wl1271_raw_read(wl, FW_STATUS_ADDR, status,
 686                                 sizeof(struct wl1271_fw_ap_status), false);
 687         } else {
 688                 wl1271_raw_read(wl, FW_STATUS_ADDR, status,
 689                                 sizeof(struct wl1271_fw_sta_status), false);
 690         }
 691
 692         wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
 693                      "drv_rx_counter = %d, tx_results_counter = %d)",
 694                      status->intr,
 695                      status->fw_rx_counter,
 696                      status->drv_rx_counter,
 697                      status->tx_results_counter);
 698
 699         /* update number of available TX blocks */
 700         for (i = 0; i < NUM_TX_QUEUES; i++) {
 701                 freed_blocks += le32_to_cpu(status->tx_released_blks[i]) -
 702                                 wl->tx_blocks_freed[i];
 703
 704                 wl->tx_blocks_freed[i] =
 705                         le32_to_cpu(status->tx_released_blks[i]);
 706         }
 707
 708         wl->tx_allocated_blocks -= freed_blocks;
 709
 710         if (wl->bss_type == BSS_TYPE_AP_BSS) {
 711                 /* Update num of allocated TX blocks per link and ps status */
 712                 wl1271_irq_update_links_status(wl, &full_status->ap);
 713                 wl->tx_blocks_available += freed_blocks;
 714         } else {
 715                 int avail = full_status->sta.tx_total - wl->tx_allocated_blocks;
 716
 717                 /*
 718                  * The FW might change the total number of TX memblocks before
 719                  * we get a notification about blocks being released. Thus, the
 720                  * available blocks calculation might yield a temporary result
 721                  * which is lower than the actual available blocks. Keeping in
 722                  * mind that only blocks that were allocated can be moved from
 723                  * TX to RX, tx_blocks_available should never decrease here.
 724                  */
 725                 wl->tx_blocks_available = max((int)wl->tx_blocks_available,
 726                                               avail);
 727         }
 728
 729         /* if more blocks are available now, tx work can be scheduled */
 730         if (wl->tx_blocks_available > old_tx_blk_count)
 731                 clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
 732
 733         /* update the host-chipset time offset */
 734         getnstimeofday(&ts);
 735         wl->time_offset = (timespec_to_ns(&ts) >> 10) -
 736                 (s64)le32_to_cpu(status->fw_localtime);
 737 }
 738
 739 static void wl1271_flush_deferred_work(struct wl1271 *wl)
 740 {
 741         struct sk_buff *skb;
 742
 743         /* Pass all received frames to the network stack */
 744         while ((skb = skb_dequeue(&wl->deferred_rx_queue)))
 745                 ieee80211_rx_ni(wl->hw, skb);
 746
 747         /* Return sent skbs to the network stack */
 748         while ((skb = skb_dequeue(&wl->deferred_tx_queue)))
 749                 ieee80211_tx_status(wl->hw, skb);
 750 }
 751
 752 static void wl1271_netstack_work(struct work_struct *work)
 753 {
 754         struct wl1271 *wl =
 755                 container_of(work, struct wl1271, netstack_work);
 756
 757         do {
 758                 wl1271_flush_deferred_work(wl);
 759         } while (skb_queue_len(&wl->deferred_rx_queue));
 760 }
 761
 762 #define WL1271_IRQ_MAX_LOOPS 256
 763
 764 irqreturn_t wl1271_irq(int irq, void *cookie)
 765 {
 766         int ret;
 767         u32 intr;
 768         int loopcount = WL1271_IRQ_MAX_LOOPS;
 769         struct wl1271 *wl = (struct wl1271 *)cookie;
 770         bool done = false;
 771         unsigned int defer_count;
 772         unsigned long flags;
 773
 774         /* TX might be handled here, avoid redundant work */
 775         set_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
 776         cancel_work_sync(&wl->tx_work);
 777
 778         /*
 779          * In case edge triggered interrupt must be used, we cannot iterate
 780          * more than once without introducing race conditions with the hardirq.
 781          */
 782         if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)
 783                 loopcount = 1;
 784
 785         mutex_lock(&wl->mutex);
 786
 787         wl1271_debug(DEBUG_IRQ, "IRQ work");
 788
 789         if (unlikely(wl->state == WL1271_STATE_OFF))
 790                 goto out;
 791
 792         ret = wl1271_ps_elp_wakeup(wl);
 793         if (ret < 0)
 794                 goto out;
 795
 796         while (!done && loopcount--) {
 797                 /*
 798                  * In order to avoid a race with the hardirq, clear the flag
 799                  * before acknowledging the chip. Since the mutex is held,
 800                  * wl1271_ps_elp_wakeup cannot be called concurrently.
 801                  */
 802                 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
 803                 smp_mb__after_clear_bit();
 804
 805                 wl1271_fw_status(wl, wl->fw_status);
 806                 intr = le32_to_cpu(wl->fw_status->common.intr);
 807                 intr &= WL1271_INTR_MASK;
 808                 if (!intr) {
 809                         done = true;
 810                         continue;
 811                 }
 812
 813                 if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
 814                         wl1271_error("watchdog interrupt received! "
 815                                      "starting recovery.");
 816                         ieee80211_queue_work(wl->hw, &wl->recovery_work);
 817
 818                         /* restarting the chip. ignore any other interrupt. */
 819                         goto out;
 820                 }
 821
 822                 if (likely(intr & WL1271_ACX_INTR_DATA)) {
 823                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
 824
 825                         wl1271_rx(wl, &wl->fw_status->common);
 826
 827                         /* Check if any tx blocks were freed */
 828                         spin_lock_irqsave(&wl->wl_lock, flags);
 829                         if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
 830                             wl->tx_queue_count) {
 831                                 spin_unlock_irqrestore(&wl->wl_lock, flags);
 832                                 /*
 833                                  * In order to avoid starvation of the TX path,
 834                                  * call the work function directly.
 835                                  */
 836                                 wl1271_tx_work_locked(wl);
 837                         } else {
 838                                 spin_unlock_irqrestore(&wl->wl_lock, flags);
 839                         }
 840
 841                         /* check for tx results */
 842                         if (wl->fw_status->common.tx_results_counter !=
 843                             (wl->tx_results_count & 0xff))
 844                                 wl1271_tx_complete(wl);
 845
 846                         /* Make sure the deferred queues don't get too long */
 847                         defer_count = skb_queue_len(&wl->deferred_tx_queue) +
 848                                       skb_queue_len(&wl->deferred_rx_queue);
 849                         if (defer_count > WL1271_DEFERRED_QUEUE_LIMIT)
 850                                 wl1271_flush_deferred_work(wl);
 851                 }
 852
 853                 if (intr & WL1271_ACX_INTR_EVENT_A) {
 854                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
 855                         wl1271_event_handle(wl, 0);
 856                 }
 857
 858                 if (intr & WL1271_ACX_INTR_EVENT_B) {
 859                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
 860                         wl1271_event_handle(wl, 1);
 861                 }
 862
 863                 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
 864                         wl1271_debug(DEBUG_IRQ,
 865                                      "WL1271_ACX_INTR_INIT_COMPLETE");
 866
 867                 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
 868                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
 869         }
 870
 871         wl1271_ps_elp_sleep(wl);
 872
 873 out:
 874         spin_lock_irqsave(&wl->wl_lock, flags);
 875         /* In case TX was not handled here, queue TX work */
 876         clear_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
 877         if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
 878             wl->tx_queue_count)
 879                 ieee80211_queue_work(wl->hw, &wl->tx_work);
 880         spin_unlock_irqrestore(&wl->wl_lock, flags);
 881
 882         mutex_unlock(&wl->mutex);
 883
 884         return IRQ_HANDLED;
 885 }
 886 EXPORT_SYMBOL_GPL(wl1271_irq);
 887
 888 static int wl1271_fetch_firmware(struct wl1271 *wl)
 889 {
 890         const struct firmware *fw;
 891         const char *fw_name;
 892         int ret;
 893
 894         switch (wl->bss_type) {
 895         case BSS_TYPE_AP_BSS:
 896                 if (wl->chip.id == CHIP_ID_1283_PG20)
 897                         fw_name = WL128X_AP_FW_NAME;
 898                 else
 899                         fw_name = WL127X_AP_FW_NAME;
 900                 break;
 901         case BSS_TYPE_IBSS:
 902         case BSS_TYPE_STA_BSS:
 903                 if (wl->chip.id == CHIP_ID_1283_PG20)
 904                         fw_name = WL128X_FW_NAME;
 905                 else
 906                         fw_name = WL1271_FW_NAME;
 907                 break;
 908         default:
 909                 wl1271_error("no compatible firmware for bss_type %d",
 910                              wl->bss_type);
 911                 return -EINVAL;
 912         }
 913
 914         wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name);
 915
 916         ret = request_firmware(&fw, fw_name, wl1271_wl_to_dev(wl));
 917
 918         if (ret < 0) {
 919                 wl1271_error("could not get firmware: %d", ret);
 920                 return ret;
 921         }
 922
 923         if (fw->size % 4) {
 924                 wl1271_error("firmware size is not multiple of 32 bits: %zu",
 925                              fw->size);
 926                 ret = -EILSEQ;
 927                 goto out;
 928         }
 929
 930         vfree(wl->fw);
 931         wl->fw_len = fw->size;
 932         wl->fw = vmalloc(wl->fw_len);
 933
 934         if (!wl->fw) {
 935                 wl1271_error("could not allocate memory for the firmware");
 936                 ret = -ENOMEM;
 937                 goto out;
 938         }
 939
 940         memcpy(wl->fw, fw->data, wl->fw_len);
 941         wl->fw_bss_type = wl->bss_type;
 942         ret = 0;
 943
 944 out:
 945         release_firmware(fw);
 946
 947         return ret;
 948 }
 949
 950 static int wl1271_fetch_nvs(struct wl1271 *wl)
 951 {
 952         const struct firmware *fw;
 953         int ret;
 954
 955         ret = request_firmware(&fw, WL12XX_NVS_NAME, wl1271_wl_to_dev(wl));
 956
 957         if (ret < 0) {
 958                 wl1271_error("could not get nvs file: %d", ret);
 959                 return ret;
 960         }
 961
 962         wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL);
 963
 964         if (!wl->nvs) {
 965                 wl1271_error("could not allocate memory for the nvs file");
 966                 ret = -ENOMEM;
 967                 goto out;
 968         }
 969
 970         wl->nvs_len = fw->size;
 971
 972 out:
 973         release_firmware(fw);
 974
 975         return ret;
 976 }
 977
 978 static void wl1271_recovery_work(struct work_struct *work)
 979 {
 980         struct wl1271 *wl =
 981                 container_of(work, struct wl1271, recovery_work);
 982
 983         mutex_lock(&wl->mutex);
 984
 985         if (wl->state != WL1271_STATE_ON)
 986                 goto out;
 987
 988         wl1271_info("Hardware recovery in progress. FW ver: %s pc: 0x%x",
 989                     wl->chip.fw_ver_str, wl1271_read32(wl, SCR_PAD4));
 990
 991         if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
 992                 ieee80211_connection_loss(wl->vif);
 993
 994         /* Prevent spurious TX during FW restart */
 995         ieee80211_stop_queues(wl->hw);
 996
 997         if (wl->sched_scanning) {
 998                 ieee80211_sched_scan_stopped(wl->hw);
 999                 wl->sched_scanning = false;
1000         }
1001
1002         /* reboot the chipset */
1003         __wl1271_op_remove_interface(wl, false);
1004         ieee80211_restart_hw(wl->hw);
1005
1006         /*
1007          * Its safe to enable TX now - the queues are stopped after a request
1008          * to restart the HW.
1009          */
1010         ieee80211_wake_queues(wl->hw);
1011
1012 out:
1013         mutex_unlock(&wl->mutex);
1014 }
1015
1016 static void wl1271_fw_wakeup(struct wl1271 *wl)
1017 {
1018         u32 elp_reg;
1019
1020         elp_reg = ELPCTRL_WAKE_UP;
1021         wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
1022 }
1023
1024 static int wl1271_setup(struct wl1271 *wl)
1025 {
1026         wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
1027         if (!wl->fw_status)
1028                 return -ENOMEM;
1029
1030         wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
1031         if (!wl->tx_res_if) {
1032                 kfree(wl->fw_status);
1033                 return -ENOMEM;
1034         }
1035
1036         return 0;
1037 }
1038
1039 static int wl1271_chip_wakeup(struct wl1271 *wl)
1040 {
1041         struct wl1271_partition_set partition;
1042         int ret = 0;
1043
1044         msleep(WL1271_PRE_POWER_ON_SLEEP);
1045         ret = wl1271_power_on(wl);
1046         if (ret < 0)
1047                 goto out;
1048         msleep(WL1271_POWER_ON_SLEEP);
1049         wl1271_io_reset(wl);
1050         wl1271_io_init(wl);
1051
1052         /* We don't need a real memory partition here, because we only want
1053          * to use the registers at this point. */
1054         memset(&partition, 0, sizeof(partition));
1055         partition.reg.start = REGISTERS_BASE;
1056         partition.reg.size = REGISTERS_DOWN_SIZE;
1057         wl1271_set_partition(wl, &partition);
1058
1059         /* ELP module wake up */
1060         wl1271_fw_wakeup(wl);
1061
1062         /* whal_FwCtrl_BootSm() */
1063
1064         /* 0. read chip id from CHIP_ID */
1065         wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
1066
1067         /* 1. check if chip id is valid */
1068
1069         switch (wl->chip.id) {
1070         case CHIP_ID_1271_PG10:
1071                 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
1072                                wl->chip.id);
1073
1074                 ret = wl1271_setup(wl);
1075                 if (ret < 0)
1076                         goto out;
1077                 break;
1078         case CHIP_ID_1271_PG20:
1079                 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
1080                              wl->chip.id);
1081
1082                 /* end-of-transaction flag should be set in wl127x AP mode */
1083                 if (wl->bss_type == BSS_TYPE_AP_BSS)
1084                         wl->quirks |= WL12XX_QUIRK_END_OF_TRANSACTION;
1085
1086                 ret = wl1271_setup(wl);
1087                 if (ret < 0)
1088                         goto out;
1089                 break;
1090         case CHIP_ID_1283_PG20:
1091                 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1283 PG20)",
1092                              wl->chip.id);
1093
1094                 ret = wl1271_setup(wl);
1095                 if (ret < 0)
1096                         goto out;
1097                 if (wl1271_set_block_size(wl))
1098                         wl->quirks |= WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT;
1099                 break;
1100         case CHIP_ID_1283_PG10:
1101         default:
1102                 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
1103                 ret = -ENODEV;
1104                 goto out;
1105         }
1106
1107         /* Make sure the firmware type matches the BSS type */
1108         if (wl->fw == NULL || wl->fw_bss_type != wl->bss_type) {
1109                 ret = wl1271_fetch_firmware(wl);
1110                 if (ret < 0)
1111                         goto out;
1112         }
1113
1114         /* No NVS from netlink, try to get it from the filesystem */
1115         if (wl->nvs == NULL) {
1116                 ret = wl1271_fetch_nvs(wl);
1117                 if (ret < 0)
1118                         goto out;
1119         }
1120
1121 out:
1122         return ret;
1123 }
1124
1125 static unsigned int wl1271_get_fw_ver_quirks(struct wl1271 *wl)
1126 {
1127         unsigned int quirks = 0;
1128         unsigned int *fw_ver = wl->chip.fw_ver;
1129
1130         /* Only for wl127x */
1131         if ((fw_ver[FW_VER_CHIP] == FW_VER_CHIP_WL127X) &&
1132             /* Check STA version */
1133             (((fw_ver[FW_VER_IF_TYPE] == FW_VER_IF_TYPE_STA) &&
1134               (fw_ver[FW_VER_MINOR] < FW_VER_MINOR_1_SPARE_STA_MIN)) ||
1135              /* Check AP version */
1136              ((fw_ver[FW_VER_IF_TYPE] == FW_VER_IF_TYPE_AP) &&
1137               (fw_ver[FW_VER_MINOR] < FW_VER_MINOR_1_SPARE_AP_MIN))))
1138                 quirks |= WL12XX_QUIRK_USE_2_SPARE_BLOCKS;
1139
1140         return quirks;
1141 }
1142
1143 int wl1271_plt_start(struct wl1271 *wl)
1144 {
1145         int retries = WL1271_BOOT_RETRIES;
1146         int ret;
1147
1148         mutex_lock(&wl->mutex);
1149
1150         wl1271_notice("power up");
1151
1152         if (wl->state != WL1271_STATE_OFF) {
1153                 wl1271_error("cannot go into PLT state because not "
1154                              "in off state: %d", wl->state);
1155                 ret = -EBUSY;
1156                 goto out;
1157         }
1158
1159         wl->bss_type = BSS_TYPE_STA_BSS;
1160
1161         while (retries) {
1162                 retries--;
1163                 ret = wl1271_chip_wakeup(wl);
1164                 if (ret < 0)
1165                         goto power_off;
1166
1167                 ret = wl1271_boot(wl);
1168                 if (ret < 0)
1169                         goto power_off;
1170
1171                 ret = wl1271_plt_init(wl);
1172                 if (ret < 0)
1173                         goto irq_disable;
1174
1175                 wl->state = WL1271_STATE_PLT;
1176                 wl1271_notice("firmware booted in PLT mode (%s)",
1177                               wl->chip.fw_ver_str);
1178
1179                 /* Check if any quirks are needed with older fw versions */
1180                 wl->quirks |= wl1271_get_fw_ver_quirks(wl);
1181                 goto out;
1182
1183 irq_disable:
1184                 mutex_unlock(&wl->mutex);
1185                 /* Unlocking the mutex in the middle of handling is
1186                    inherently unsafe. In this case we deem it safe to do,
1187                    because we need to let any possibly pending IRQ out of
1188                    the system (and while we are WL1271_STATE_OFF the IRQ
1189                    work function will not do anything.) Also, any other
1190                    possible concurrent operations will fail due to the
1191                    current state, hence the wl1271 struct should be safe. */
1192                 wl1271_disable_interrupts(wl);
1193                 wl1271_flush_deferred_work(wl);
1194                 cancel_work_sync(&wl->netstack_work);
1195                 mutex_lock(&wl->mutex);
1196 power_off:
1197                 wl1271_power_off(wl);
1198         }
1199
1200         wl1271_error("firmware boot in PLT mode failed despite %d retries",
1201                      WL1271_BOOT_RETRIES);
1202 out:
1203         mutex_unlock(&wl->mutex);
1204
1205         return ret;
1206 }
1207
1208 static int __wl1271_plt_stop(struct wl1271 *wl)
1209 {
1210         int ret = 0;
1211
1212         wl1271_notice("power down");
1213
1214         if (wl->state != WL1271_STATE_PLT) {
1215                 wl1271_error("cannot power down because not in PLT "
1216                              "state: %d", wl->state);
1217                 ret = -EBUSY;
1218                 goto out;
1219         }
1220
1221         wl1271_power_off(wl);
1222
1223         wl->state = WL1271_STATE_OFF;
1224         wl->rx_counter = 0;
1225
1226         mutex_unlock(&wl->mutex);
1227         wl1271_disable_interrupts(wl);
1228         wl1271_flush_deferred_work(wl);
1229         cancel_work_sync(&wl->netstack_work);
1230         cancel_work_sync(&wl->recovery_work);
1231         mutex_lock(&wl->mutex);
1232 out:
1233         return ret;
1234 }
1235
1236 int wl1271_plt_stop(struct wl1271 *wl)
1237 {
1238         int ret;
1239
1240         mutex_lock(&wl->mutex);
1241         ret = __wl1271_plt_stop(wl);
1242         mutex_unlock(&wl->mutex);
1243         return ret;
1244 }
1245
1246 static void wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
1247 {
1248         struct wl1271 *wl = hw->priv;
1249         unsigned long flags;
1250         int q;
1251         u8 hlid = 0;
1252
1253         q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
1254
1255         if (wl->bss_type == BSS_TYPE_AP_BSS)
1256                 hlid = wl1271_tx_get_hlid(skb);
1257
1258         spin_lock_irqsave(&wl->wl_lock, flags);
1259
1260         wl->tx_queue_count++;
1261
1262         /*
1263          * The workqueue is slow to process the tx_queue and we need stop
1264          * the queue here, otherwise the queue will get too long.
1265          */
1266         if (wl->tx_queue_count >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
1267                 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
1268                 ieee80211_stop_queues(wl->hw);
1269                 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
1270         }
1271
1272         /* queue the packet */
1273         if (wl->bss_type == BSS_TYPE_AP_BSS) {
1274                 wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d", hlid, q);
1275                 skb_queue_tail(&wl->links[hlid].tx_queue[q], skb);
1276         } else {
1277                 skb_queue_tail(&wl->tx_queue[q], skb);
1278         }
1279
1280         /*
1281          * The chip specific setup must run before the first TX packet -
1282          * before that, the tx_work will not be initialized!
1283          */
1284
1285         if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
1286             !test_bit(WL1271_FLAG_TX_PENDING, &wl->flags))
1287                 ieee80211_queue_work(wl->hw, &wl->tx_work);
1288
1289         spin_unlock_irqrestore(&wl->wl_lock, flags);
1290 }
1291
1292 int wl1271_tx_dummy_packet(struct wl1271 *wl)
1293 {
1294         unsigned long flags;
1295
1296         spin_lock_irqsave(&wl->wl_lock, flags);
1297         set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
1298         wl->tx_queue_count++;
1299         spin_unlock_irqrestore(&wl->wl_lock, flags);
1300
1301         /* The FW is low on RX memory blocks, so send the dummy packet asap */
1302         if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags))
1303                 wl1271_tx_work_locked(wl);
1304
1305         /*
1306          * If the FW TX is busy, TX work will be scheduled by the threaded
1307          * interrupt handler function
1308          */
1309         return 0;
1310 }
1311
1312 /*
1313  * The size of the dummy packet should be at least 1400 bytes. However, in
1314  * order to minimize the number of bus transactions, aligning it to 512 bytes
1315  * boundaries could be beneficial, performance wise
1316  */
1317 #define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512))
1318
1319 static struct sk_buff *wl12xx_alloc_dummy_packet(struct wl1271 *wl)
1320 {
1321         struct sk_buff *skb;
1322         struct ieee80211_hdr_3addr *hdr;
1323         unsigned int dummy_packet_size;
1324
1325         dummy_packet_size = TOTAL_TX_DUMMY_PACKET_SIZE -
1326                             sizeof(struct wl1271_tx_hw_descr) - sizeof(*hdr);
1327
1328         skb = dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE);
1329         if (!skb) {
1330                 wl1271_warning("Failed to allocate a dummy packet skb");
1331                 return NULL;
1332         }
1333
1334         skb_reserve(skb, sizeof(struct wl1271_tx_hw_descr));
1335
1336         hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr));
1337         memset(hdr, 0, sizeof(*hdr));
1338         hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
1339                                          IEEE80211_STYPE_NULLFUNC |
1340                                          IEEE80211_FCTL_TODS);
1341
1342         memset(skb_put(skb, dummy_packet_size), 0, dummy_packet_size);
1343
1344         /* Dummy packets require the TID to be management */
1345         skb->priority = WL1271_TID_MGMT;
1346
1347         /* Initialize all fields that might be used */
1348         skb_set_queue_mapping(skb, 0);
1349         memset(IEEE80211_SKB_CB(skb), 0, sizeof(struct ieee80211_tx_info));
1350
1351         return skb;
1352 }
1353
1354
1355 static struct notifier_block wl1271_dev_notifier = {
1356         .notifier_call = wl1271_dev_notify,
1357 };
1358
1359 #ifdef CONFIG_PM
1360 static int wl1271_configure_suspend(struct wl1271 *wl)
1361 {
1362         int ret;
1363
1364         if (wl->bss_type != BSS_TYPE_STA_BSS)
1365                 return 0;
1366
1367         mutex_lock(&wl->mutex);
1368
1369         ret = wl1271_ps_elp_wakeup(wl);
1370         if (ret < 0)
1371                 goto out_unlock;
1372
1373         /* enter psm if needed*/
1374         if (!test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1375                 DECLARE_COMPLETION_ONSTACK(compl);
1376
1377                 wl->ps_compl = &compl;
1378                 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1379                                    wl->basic_rate, true);
1380                 if (ret < 0)
1381                         goto out_sleep;
1382
1383                 /* we must unlock here so we will be able to get events */
1384                 wl1271_ps_elp_sleep(wl);
1385                 mutex_unlock(&wl->mutex);
1386
1387                 ret = wait_for_completion_timeout(
1388                         &compl, msecs_to_jiffies(WL1271_PS_COMPLETE_TIMEOUT));
1389                 if (ret <= 0) {
1390                         wl1271_warning("couldn't enter ps mode!");
1391                         ret = -EBUSY;
1392                         goto out;
1393                 }
1394
1395                 /* take mutex again, and wakeup */
1396                 mutex_lock(&wl->mutex);
1397
1398                 ret = wl1271_ps_elp_wakeup(wl);
1399                 if (ret < 0)
1400                         goto out_unlock;
1401         }
1402 out_sleep:
1403         wl1271_ps_elp_sleep(wl);
1404 out_unlock:
1405         mutex_unlock(&wl->mutex);
1406 out:
1407         return ret;
1408
1409 }
1410
1411 static void wl1271_configure_resume(struct wl1271 *wl)
1412 {
1413         int ret;
1414
1415         if (wl->bss_type != BSS_TYPE_STA_BSS)
1416                 return;
1417
1418         mutex_lock(&wl->mutex);
1419         ret = wl1271_ps_elp_wakeup(wl);
1420         if (ret < 0)
1421                 goto out;
1422
1423         /* exit psm if it wasn't configured */
1424         if (!test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags))
1425                 wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1426                                    wl->basic_rate, true);
1427
1428         wl1271_ps_elp_sleep(wl);
1429 out:
1430         mutex_unlock(&wl->mutex);
1431 }
1432
1433 static int wl1271_op_suspend(struct ieee80211_hw *hw,
1434                             struct cfg80211_wowlan *wow)
1435 {
1436         struct wl1271 *wl = hw->priv;
1437         wl1271_debug(DEBUG_MAC80211, "mac80211 suspend wow=%d", !!wow);
1438         wl->wow_enabled = !!wow;
1439         if (wl->wow_enabled) {
1440                 int ret;
1441                 ret = wl1271_configure_suspend(wl);
1442                 if (ret < 0) {
1443                         wl1271_warning("couldn't prepare device to suspend");
1444                         return ret;
1445                 }
1446                 /* flush any remaining work */
1447                 wl1271_debug(DEBUG_MAC80211, "flushing remaining works");
1448                 flush_delayed_work(&wl->scan_complete_work);
1449
1450                 /*
1451                  * disable and re-enable interrupts in order to flush
1452                  * the threaded_irq
1453                  */
1454                 wl1271_disable_interrupts(wl);
1455
1456                 /*
1457                  * set suspended flag to avoid triggering a new threaded_irq
1458                  * work. no need for spinlock as interrupts are disabled.
1459                  */
1460                 set_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1461
1462                 wl1271_enable_interrupts(wl);
1463                 flush_work(&wl->tx_work);
1464                 flush_delayed_work(&wl->pspoll_work);
1465                 flush_delayed_work(&wl->elp_work);
1466         }
1467         return 0;
1468 }
1469
1470 static int wl1271_op_resume(struct ieee80211_hw *hw)
1471 {
1472         struct wl1271 *wl = hw->priv;
1473         wl1271_debug(DEBUG_MAC80211, "mac80211 resume wow=%d",
1474                      wl->wow_enabled);
1475
1476         /*
1477          * re-enable irq_work enqueuing, and call irq_work directly if
1478          * there is a pending work.
1479          */
1480         if (wl->wow_enabled) {
1481                 struct wl1271 *wl = hw->priv;
1482                 unsigned long flags;
1483                 bool run_irq_work = false;
1484
1485                 spin_lock_irqsave(&wl->wl_lock, flags);
1486                 clear_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1487                 if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK, &wl->flags))
1488                         run_irq_work = true;
1489                 spin_unlock_irqrestore(&wl->wl_lock, flags);
1490
1491                 if (run_irq_work) {
1492                         wl1271_debug(DEBUG_MAC80211,
1493                                      "run postponed irq_work directly");
1494                         wl1271_irq(0, wl);
1495                         wl1271_enable_interrupts(wl);
1496                 }
1497
1498                 wl1271_configure_resume(wl);
1499         }
1500
1501         return 0;
1502 }
1503 #endif
1504
1505 static int wl1271_op_start(struct ieee80211_hw *hw)
1506 {
1507         wl1271_debug(DEBUG_MAC80211, "mac80211 start");
1508
1509         /*
1510          * We have to delay the booting of the hardware because
1511          * we need to know the local MAC address before downloading and
1512          * initializing the firmware. The MAC address cannot be changed
1513          * after boot, and without the proper MAC address, the firmware
1514          * will not function properly.
1515          *
1516          * The MAC address is first known when the corresponding interface
1517          * is added. That is where we will initialize the hardware.
1518          *
1519          * In addition, we currently have different firmwares for AP and managed
1520          * operation. We will know which to boot according to interface type.
1521          */
1522
1523         return 0;
1524 }
1525
1526 static void wl1271_op_stop(struct ieee80211_hw *hw)
1527 {
1528         wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
1529 }
1530
1531 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
1532                                    struct ieee80211_vif *vif)
1533 {
1534         struct wl1271 *wl = hw->priv;
1535         struct wiphy *wiphy = hw->wiphy;
1536         int retries = WL1271_BOOT_RETRIES;
1537         int ret = 0;
1538         bool booted = false;
1539
1540         wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
1541                      vif->type, vif->addr);
1542
1543         mutex_lock(&wl->mutex);
1544         if (wl->vif) {
1545                 wl1271_debug(DEBUG_MAC80211,
1546                              "multiple vifs are not supported yet");
1547                 ret = -EBUSY;
1548                 goto out;
1549         }
1550
1551         /*
1552          * in some very corner case HW recovery scenarios its possible to
1553          * get here before __wl1271_op_remove_interface is complete, so
1554          * opt out if that is the case.
1555          */
1556         if (test_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags)) {
1557                 ret = -EBUSY;
1558                 goto out;
1559         }
1560
1561         switch (vif->type) {
1562         case NL80211_IFTYPE_STATION:
1563                 wl->bss_type = BSS_TYPE_STA_BSS;
1564                 wl->set_bss_type = BSS_TYPE_STA_BSS;
1565                 break;
1566         case NL80211_IFTYPE_ADHOC:
1567                 wl->bss_type = BSS_TYPE_IBSS;
1568                 wl->set_bss_type = BSS_TYPE_STA_BSS;
1569                 break;
1570         case NL80211_IFTYPE_AP:
1571                 wl->bss_type = BSS_TYPE_AP_BSS;
1572                 break;
1573         default:
1574                 ret = -EOPNOTSUPP;
1575                 goto out;
1576         }
1577
1578         memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
1579
1580         if (wl->state != WL1271_STATE_OFF) {
1581                 wl1271_error("cannot start because not in off state: %d",
1582                              wl->state);
1583                 ret = -EBUSY;
1584                 goto out;
1585         }
1586
1587         while (retries) {
1588                 retries--;
1589                 ret = wl1271_chip_wakeup(wl);
1590                 if (ret < 0)
1591                         goto power_off;
1592
1593                 ret = wl1271_boot(wl);
1594                 if (ret < 0)
1595                         goto power_off;
1596
1597                 ret = wl1271_hw_init(wl);
1598                 if (ret < 0)
1599                         goto irq_disable;
1600
1601                 booted = true;
1602                 break;
1603
1604 irq_disable:
1605                 mutex_unlock(&wl->mutex);
1606                 /* Unlocking the mutex in the middle of handling is
1607                    inherently unsafe. In this case we deem it safe to do,
1608                    because we need to let any possibly pending IRQ out of
1609                    the system (and while we are WL1271_STATE_OFF the IRQ
1610                    work function will not do anything.) Also, any other
1611                    possible concurrent operations will fail due to the
1612                    current state, hence the wl1271 struct should be safe. */
1613                 wl1271_disable_interrupts(wl);
1614                 wl1271_flush_deferred_work(wl);
1615                 cancel_work_sync(&wl->netstack_work);
1616                 mutex_lock(&wl->mutex);
1617 power_off:
1618                 wl1271_power_off(wl);
1619         }
1620
1621         if (!booted) {
1622                 wl1271_error("firmware boot failed despite %d retries",
1623                              WL1271_BOOT_RETRIES);
1624                 goto out;
1625         }
1626
1627         wl->vif = vif;
1628         wl->state = WL1271_STATE_ON;
1629         set_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags);
1630         wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
1631
1632         /* update hw/fw version info in wiphy struct */
1633         wiphy->hw_version = wl->chip.id;
1634         strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
1635                 sizeof(wiphy->fw_version));
1636
1637         /* Check if any quirks are needed with older fw versions */
1638         wl->quirks |= wl1271_get_fw_ver_quirks(wl);
1639
1640         /*
1641          * Now we know if 11a is supported (info from the NVS), so disable
1642          * 11a channels if not supported
1643          */
1644         if (!wl->enable_11a)
1645                 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
1646
1647         wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
1648                      wl->enable_11a ? "" : "not ");
1649
1650 out:
1651         mutex_unlock(&wl->mutex);
1652
1653         mutex_lock(&wl_list_mutex);
1654         if (!ret)
1655                 list_add(&wl->list, &wl_list);
1656         mutex_unlock(&wl_list_mutex);
1657
1658         return ret;
1659 }
1660
1661 static void __wl1271_op_remove_interface(struct wl1271 *wl,
1662                                          bool reset_tx_queues)
1663 {
1664         int i;
1665
1666         wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1667
1668         /* because of hardware recovery, we may get here twice */
1669         if (wl->state != WL1271_STATE_ON)
1670                 return;
1671
1672         wl1271_info("down");
1673
1674         mutex_lock(&wl_list_mutex);
1675         list_del(&wl->list);
1676         mutex_unlock(&wl_list_mutex);
1677
1678         /* enable dyn ps just in case (if left on due to fw crash etc) */
1679         if (wl->bss_type == BSS_TYPE_STA_BSS)
1680                 ieee80211_enable_dyn_ps(wl->vif);
1681
1682         if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
1683                 wl->scan.state = WL1271_SCAN_STATE_IDLE;
1684                 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
1685                 wl->scan.req = NULL;
1686                 ieee80211_scan_completed(wl->hw, true);
1687         }
1688
1689         /*
1690          * this must be before the cancel_work calls below, so that the work
1691          * functions don't perform further work.
1692          */
1693         wl->state = WL1271_STATE_OFF;
1694
1695         mutex_unlock(&wl->mutex);
1696
1697         wl1271_disable_interrupts(wl);
1698         wl1271_flush_deferred_work(wl);
1699         cancel_delayed_work_sync(&wl->scan_complete_work);
1700         cancel_work_sync(&wl->netstack_work);
1701         cancel_work_sync(&wl->tx_work);
1702         cancel_delayed_work_sync(&wl->pspoll_work);
1703         cancel_delayed_work_sync(&wl->elp_work);
1704
1705         mutex_lock(&wl->mutex);
1706
1707         /* let's notify MAC80211 about the remaining pending TX frames */
1708         wl1271_tx_reset(wl, reset_tx_queues);
1709         wl1271_power_off(wl);
1710
1711         memset(wl->bssid, 0, ETH_ALEN);
1712         memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1713         wl->ssid_len = 0;
1714         wl->bss_type = MAX_BSS_TYPE;
1715         wl->set_bss_type = MAX_BSS_TYPE;
1716         wl->band = IEEE80211_BAND_2GHZ;
1717
1718         wl->rx_counter = 0;
1719         wl->psm_entry_retry = 0;
1720         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1721         wl->tx_blocks_available = 0;
1722         wl->tx_allocated_blocks = 0;
1723         wl->tx_results_count = 0;
1724         wl->tx_packets_count = 0;
1725         wl->tx_security_last_seq = 0;
1726         wl->tx_security_seq = 0;
1727         wl->time_offset = 0;
1728         wl->session_counter = 0;
1729         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1730         wl->vif = NULL;
1731         wl->filters = 0;
1732         wl1271_free_ap_keys(wl);
1733         memset(wl->ap_hlid_map, 0, sizeof(wl->ap_hlid_map));
1734         wl->ap_fw_ps_map = 0;
1735         wl->ap_ps_map = 0;
1736         wl->sched_scanning = false;
1737
1738         /*
1739          * this is performed after the cancel_work calls and the associated
1740          * mutex_lock, so that wl1271_op_add_interface does not accidentally
1741          * get executed before all these vars have been reset.
1742          */
1743         wl->flags = 0;
1744
1745         for (i = 0; i < NUM_TX_QUEUES; i++)
1746                 wl->tx_blocks_freed[i] = 0;
1747
1748         wl1271_debugfs_reset(wl);
1749
1750         kfree(wl->fw_status);
1751         wl->fw_status = NULL;
1752         kfree(wl->tx_res_if);
1753         wl->tx_res_if = NULL;
1754         kfree(wl->target_mem_map);
1755         wl->target_mem_map = NULL;
1756 }
1757
1758 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1759                                        struct ieee80211_vif *vif)
1760 {
1761         struct wl1271 *wl = hw->priv;
1762
1763         mutex_lock(&wl->mutex);
1764         /*
1765          * wl->vif can be null here if someone shuts down the interface
1766          * just when hardware recovery has been started.
1767          */
1768         if (wl->vif) {
1769                 WARN_ON(wl->vif != vif);
1770                 __wl1271_op_remove_interface(wl, true);
1771         }
1772
1773         mutex_unlock(&wl->mutex);
1774         cancel_work_sync(&wl->recovery_work);
1775 }
1776
1777 void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1778 {
1779         wl1271_set_default_filters(wl);
1780
1781         /* combine requested filters with current filter config */
1782         filters = wl->filters | filters;
1783
1784         wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1785
1786         if (filters & FIF_PROMISC_IN_BSS) {
1787                 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1788                 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1789                 wl->rx_config |= CFG_BSSID_FILTER_EN;
1790         }
1791         if (filters & FIF_BCN_PRBRESP_PROMISC) {
1792                 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1793                 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1794                 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1795         }
1796         if (filters & FIF_OTHER_BSS) {
1797                 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1798                 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1799         }
1800         if (filters & FIF_CONTROL) {
1801                 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1802                 wl->rx_filter |= CFG_RX_CTL_EN;
1803         }
1804         if (filters & FIF_FCSFAIL) {
1805                 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1806                 wl->rx_filter |= CFG_RX_FCS_ERROR;
1807         }
1808 }
1809
1810 static int wl1271_dummy_join(struct wl1271 *wl)
1811 {
1812         int ret = 0;
1813         /* we need to use a dummy BSSID for now */
1814         static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1815                                                   0xad, 0xbe, 0xef };
1816
1817         memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1818
1819         /* pass through frames from all BSS */
1820         wl1271_configure_filters(wl, FIF_OTHER_BSS);
1821
1822         ret = wl1271_cmd_join(wl, wl->set_bss_type);
1823         if (ret < 0)
1824                 goto out;
1825
1826         set_bit(WL1271_FLAG_JOINED, &wl->flags);
1827
1828 out:
1829         return ret;
1830 }
1831
1832 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
1833 {
1834         int ret;
1835
1836         /*
1837          * One of the side effects of the JOIN command is that is clears
1838          * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1839          * to a WPA/WPA2 access point will therefore kill the data-path.
1840          * Currently the only valid scenario for JOIN during association
1841          * is on roaming, in which case we will also be given new keys.
1842          * Keep the below message for now, unless it starts bothering
1843          * users who really like to roam a lot :)
1844          */
1845         if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1846                 wl1271_info("JOIN while associated.");
1847
1848         if (set_assoc)
1849                 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1850
1851         ret = wl1271_cmd_join(wl, wl->set_bss_type);
1852         if (ret < 0)
1853                 goto out;
1854
1855         set_bit(WL1271_FLAG_JOINED, &wl->flags);
1856
1857         if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1858                 goto out;
1859
1860         /*
1861          * The join command disable the keep-alive mode, shut down its process,
1862          * and also clear the template config, so we need to reset it all after
1863          * the join. The acx_aid starts the keep-alive process, and the order
1864          * of the commands below is relevant.
1865          */
1866         ret = wl1271_acx_keep_alive_mode(wl, true);
1867         if (ret < 0)
1868                 goto out;
1869
1870         ret = wl1271_acx_aid(wl, wl->aid);
1871         if (ret < 0)
1872                 goto out;
1873
1874         ret = wl1271_cmd_build_klv_null_data(wl);
1875         if (ret < 0)
1876                 goto out;
1877
1878         ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1879                                            ACX_KEEP_ALIVE_TPL_VALID);
1880         if (ret < 0)
1881                 goto out;
1882
1883 out:
1884         return ret;
1885 }
1886
1887 static int wl1271_unjoin(struct wl1271 *wl)
1888 {
1889         int ret;
1890
1891         /* to stop listening to a channel, we disconnect */
1892         ret = wl1271_cmd_disconnect(wl);
1893         if (ret < 0)
1894                 goto out;
1895
1896         clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1897         memset(wl->bssid, 0, ETH_ALEN);
1898
1899         /* stop filtering packets based on bssid */
1900         wl1271_configure_filters(wl, FIF_OTHER_BSS);
1901
1902 out:
1903         return ret;
1904 }
1905
1906 static void wl1271_set_band_rate(struct wl1271 *wl)
1907 {
1908         if (wl->band == IEEE80211_BAND_2GHZ)
1909                 wl->basic_rate_set = wl->conf.tx.basic_rate;
1910         else
1911                 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1912 }
1913
1914 static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle)
1915 {
1916         int ret;
1917
1918         if (idle) {
1919                 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1920                         ret = wl1271_unjoin(wl);
1921                         if (ret < 0)
1922                                 goto out;
1923                 }
1924                 wl->rate_set = wl1271_tx_min_rate_get(wl);
1925                 ret = wl1271_acx_sta_rate_policies(wl);
1926                 if (ret < 0)
1927                         goto out;
1928                 ret = wl1271_acx_keep_alive_config(
1929                         wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1930                         ACX_KEEP_ALIVE_TPL_INVALID);
1931                 if (ret < 0)
1932                         goto out;
1933                 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1934         } else {
1935                 /* increment the session counter */
1936                 wl->session_counter++;
1937                 if (wl->session_counter >= SESSION_COUNTER_MAX)
1938                         wl->session_counter = 0;
1939
1940                 /* The current firmware only supports sched_scan in idle */
1941                 if (wl->sched_scanning) {
1942                         wl1271_scan_sched_scan_stop(wl);
1943                         ieee80211_sched_scan_stopped(wl->hw);
1944                 }
1945
1946                 ret = wl1271_dummy_join(wl);
1947                 if (ret < 0)
1948                         goto out;
1949                 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1950         }
1951
1952 out:
1953         return ret;
1954 }
1955
1956 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1957 {
1958         struct wl1271 *wl = hw->priv;
1959         struct ieee80211_conf *conf = &hw->conf;
1960         int channel, ret = 0;
1961         bool is_ap;
1962
1963         channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1964
1965         wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
1966                      " changed 0x%x",
1967                      channel,
1968                      conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1969                      conf->power_level,
1970                      conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
1971                          changed);
1972
1973         /*
1974          * mac80211 will go to idle nearly immediately after transmitting some
1975          * frames, such as the deauth. To make sure those frames reach the air,
1976          * wait here until the TX queue is fully flushed.
1977          */
1978         if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1979             (conf->flags & IEEE80211_CONF_IDLE))
1980                 wl1271_tx_flush(wl);
1981
1982         mutex_lock(&wl->mutex);
1983
1984         if (unlikely(wl->state == WL1271_STATE_OFF)) {
1985                 /* we support configuring the channel and band while off */
1986                 if ((changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
1987                         wl->band = conf->channel->band;
1988                         wl->channel = channel;
1989                 }
1990
1991                 goto out;
1992         }
1993
1994         is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
1995
1996         ret = wl1271_ps_elp_wakeup(wl);
1997         if (ret < 0)
1998                 goto out;
1999
2000         /* if the channel changes while joined, join again */
2001         if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
2002             ((wl->band != conf->channel->band) ||
2003              (wl->channel != channel))) {
2004                 wl->band = conf->channel->band;
2005                 wl->channel = channel;
2006
2007                 if (!is_ap) {
2008                         /*
2009                          * FIXME: the mac80211 should really provide a fixed
2010                          * rate to use here. for now, just use the smallest
2011                          * possible rate for the band as a fixed rate for
2012                          * association frames and other control messages.
2013                          */
2014                         if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2015                                 wl1271_set_band_rate(wl);
2016
2017                         wl->basic_rate = wl1271_tx_min_rate_get(wl);
2018                         ret = wl1271_acx_sta_rate_policies(wl);
2019                         if (ret < 0)
2020                                 wl1271_warning("rate policy for channel "
2021                                                "failed %d", ret);
2022
2023                         if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
2024                                 ret = wl1271_join(wl, false);
2025                                 if (ret < 0)
2026                                         wl1271_warning("cmd join on channel "
2027                                                        "failed %d", ret);
2028                         }
2029                 }
2030         }
2031
2032         if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
2033                 ret = wl1271_sta_handle_idle(wl,
2034                                         conf->flags & IEEE80211_CONF_IDLE);
2035                 if (ret < 0)
2036                         wl1271_warning("idle mode change failed %d", ret);
2037         }
2038
2039         /*
2040          * if mac80211 changes the PSM mode, make sure the mode is not
2041          * incorrectly changed after the pspoll failure active window.
2042          */
2043         if (changed & IEEE80211_CONF_CHANGE_PS)
2044                 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
2045
2046         if (conf->flags & IEEE80211_CONF_PS &&
2047             !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
2048                 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
2049
2050                 /*
2051                  * We enter PSM only if we're already associated.
2052                  * If we're not, we'll enter it when joining an SSID,
2053                  * through the bss_info_changed() hook.
2054                  */
2055                 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
2056                         wl1271_debug(DEBUG_PSM, "psm enabled");
2057                         ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
2058                                                  wl->basic_rate, true);
2059                 }
2060         } else if (!(conf->flags & IEEE80211_CONF_PS) &&
2061                    test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
2062                 wl1271_debug(DEBUG_PSM, "psm disabled");
2063
2064                 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
2065
2066                 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
2067                         ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
2068                                                  wl->basic_rate, true);
2069         }
2070
2071         if (conf->power_level != wl->power_level) {
2072                 ret = wl1271_acx_tx_power(wl, conf->power_level);
2073                 if (ret < 0)
2074                         goto out_sleep;
2075
2076                 wl->power_level = conf->power_level;
2077         }
2078
2079 out_sleep:
2080         wl1271_ps_elp_sleep(wl);
2081
2082 out:
2083         mutex_unlock(&wl->mutex);
2084
2085         return ret;
2086 }
2087
2088 struct wl1271_filter_params {
2089         bool enabled;
2090         int mc_list_length;
2091         u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
2092 };
2093
2094 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
2095                                        struct netdev_hw_addr_list *mc_list)
2096 {
2097         struct wl1271_filter_params *fp;
2098         struct netdev_hw_addr *ha;
2099         struct wl1271 *wl = hw->priv;
2100
2101         if (unlikely(wl->state == WL1271_STATE_OFF))
2102                 return 0;
2103
2104         fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
2105         if (!fp) {
2106                 wl1271_error("Out of memory setting filters.");
2107                 return 0;
2108         }
2109
2110         /* update multicast filtering parameters */
2111         fp->mc_list_length = 0;
2112         if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
2113                 fp->enabled = false;
2114         } else {
2115                 fp->enabled = true;
2116                 netdev_hw_addr_list_for_each(ha, mc_list) {
2117                         memcpy(fp->mc_list[fp->mc_list_length],
2118                                         ha->addr, ETH_ALEN);
2119                         fp->mc_list_length++;
2120                 }
2121         }
2122
2123         return (u64)(unsigned long)fp;
2124 }
2125
2126 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
2127                                   FIF_ALLMULTI | \
2128                                   FIF_FCSFAIL | \
2129                                   FIF_BCN_PRBRESP_PROMISC | \
2130                                   FIF_CONTROL | \
2131                                   FIF_OTHER_BSS)
2132
2133 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
2134                                        unsigned int changed,
2135                                        unsigned int *total, u64 multicast)
2136 {
2137         struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
2138         struct wl1271 *wl = hw->priv;
2139         int ret;
2140
2141         wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
2142                      " total %x", changed, *total);
2143
2144         mutex_lock(&wl->mutex);
2145
2146         *total &= WL1271_SUPPORTED_FILTERS;
2147         changed &= WL1271_SUPPORTED_FILTERS;
2148
2149         if (unlikely(wl->state == WL1271_STATE_OFF))
2150                 goto out;
2151
2152         ret = wl1271_ps_elp_wakeup(wl);
2153         if (ret < 0)
2154                 goto out;
2155
2156         if (wl->bss_type != BSS_TYPE_AP_BSS) {
2157                 if (*total & FIF_ALLMULTI)
2158                         ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
2159                 else if (fp)
2160                         ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
2161                                                            fp->mc_list,
2162                                                            fp->mc_list_length);
2163                 if (ret < 0)
2164                         goto out_sleep;
2165         }
2166
2167         /* determine, whether supported filter values have changed */
2168         if (changed == 0)
2169                 goto out_sleep;
2170
2171         /* configure filters */
2172         wl->filters = *total;
2173         wl1271_configure_filters(wl, 0);
2174
2175         /* apply configured filters */
2176         ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
2177         if (ret < 0)
2178                 goto out_sleep;
2179
2180 out_sleep:
2181         wl1271_ps_elp_sleep(wl);
2182
2183 out:
2184         mutex_unlock(&wl->mutex);
2185         kfree(fp);
2186 }
2187
2188 static int wl1271_record_ap_key(struct wl1271 *wl, u8 id, u8 key_type,
2189                         u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
2190                         u16 tx_seq_16)
2191 {
2192         struct wl1271_ap_key *ap_key;
2193         int i;
2194
2195         wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
2196
2197         if (key_size > MAX_KEY_SIZE)
2198                 return -EINVAL;
2199
2200         /*
2201          * Find next free entry in ap_keys. Also check we are not replacing
2202          * an existing key.
2203          */
2204         for (i = 0; i < MAX_NUM_KEYS; i++) {
2205                 if (wl->recorded_ap_keys[i] == NULL)
2206                         break;
2207
2208                 if (wl->recorded_ap_keys[i]->id == id) {
2209                         wl1271_warning("trying to record key replacement");
2210                         return -EINVAL;
2211                 }
2212         }
2213
2214         if (i == MAX_NUM_KEYS)
2215                 return -EBUSY;
2216
2217         ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
2218         if (!ap_key)
2219                 return -ENOMEM;
2220
2221         ap_key->id = id;
2222         ap_key->key_type = key_type;
2223         ap_key->key_size = key_size;
2224         memcpy(ap_key->key, key, key_size);
2225         ap_key->hlid = hlid;
2226         ap_key->tx_seq_32 = tx_seq_32;
2227         ap_key->tx_seq_16 = tx_seq_16;
2228
2229         wl->recorded_ap_keys[i] = ap_key;
2230         return 0;
2231 }
2232
2233 static void wl1271_free_ap_keys(struct wl1271 *wl)
2234 {
2235         int i;
2236
2237         for (i = 0; i < MAX_NUM_KEYS; i++) {
2238                 kfree(wl->recorded_ap_keys[i]);
2239                 wl->recorded_ap_keys[i] = NULL;
2240         }
2241 }
2242
2243 static int wl1271_ap_init_hwenc(struct wl1271 *wl)
2244 {
2245         int i, ret = 0;
2246         struct wl1271_ap_key *key;
2247         bool wep_key_added = false;
2248
2249         for (i = 0; i < MAX_NUM_KEYS; i++) {
2250                 if (wl->recorded_ap_keys[i] == NULL)
2251                         break;
2252
2253                 key = wl->recorded_ap_keys[i];
2254                 ret = wl1271_cmd_set_ap_key(wl, KEY_ADD_OR_REPLACE,
2255                                             key->id, key->key_type,
2256                                             key->key_size, key->key,
2257                                             key->hlid, key->tx_seq_32,
2258                                             key->tx_seq_16);
2259                 if (ret < 0)
2260                         goto out;
2261
2262                 if (key->key_type == KEY_WEP)
2263                         wep_key_added = true;
2264         }
2265
2266         if (wep_key_added) {
2267                 ret = wl1271_cmd_set_ap_default_wep_key(wl, wl->default_key);
2268                 if (ret < 0)
2269                         goto out;
2270         }
2271
2272 out:
2273         wl1271_free_ap_keys(wl);
2274         return ret;
2275 }
2276
2277 static int wl1271_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
2278                        u8 key_size, const u8 *key, u32 tx_seq_32,
2279                        u16 tx_seq_16, struct ieee80211_sta *sta)
2280 {
2281         int ret;
2282         bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2283
2284         if (is_ap) {
2285                 struct wl1271_station *wl_sta;
2286                 u8 hlid;
2287
2288                 if (sta) {
2289                         wl_sta = (struct wl1271_station *)sta->drv_priv;
2290                         hlid = wl_sta->hlid;
2291                 } else {
2292                         hlid = WL1271_AP_BROADCAST_HLID;
2293                 }
2294
2295                 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2296                         /*
2297                          * We do not support removing keys after AP shutdown.
2298                          * Pretend we do to make mac80211 happy.
2299                          */
2300                         if (action != KEY_ADD_OR_REPLACE)
2301                                 return 0;
2302
2303                         ret = wl1271_record_ap_key(wl, id,
2304                                              key_type, key_size,
2305                                              key, hlid, tx_seq_32,
2306                                              tx_seq_16);
2307                 } else {
2308                         ret = wl1271_cmd_set_ap_key(wl, action,
2309                                              id, key_type, key_size,
2310                                              key, hlid, tx_seq_32,
2311                                              tx_seq_16);
2312                 }
2313
2314                 if (ret < 0)
2315                         return ret;
2316         } else {
2317                 const u8 *addr;
2318                 static const u8 bcast_addr[ETH_ALEN] = {
2319                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2320                 };
2321
2322                 addr = sta ? sta->addr : bcast_addr;
2323
2324                 if (is_zero_ether_addr(addr)) {
2325                         /* We dont support TX only encryption */
2326                         return -EOPNOTSUPP;
2327                 }
2328
2329                 /* The wl1271 does not allow to remove unicast keys - they
2330                    will be cleared automatically on next CMD_JOIN. Ignore the
2331                    request silently, as we dont want the mac80211 to emit
2332                    an error message. */
2333                 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
2334                         return 0;
2335
2336                 ret = wl1271_cmd_set_sta_key(wl, action,
2337                                              id, key_type, key_size,
2338                                              key, addr, tx_seq_32,
2339                                              tx_seq_16);
2340                 if (ret < 0)
2341                         return ret;
2342
2343                 /* the default WEP key needs to be configured at least once */
2344                 if (key_type == KEY_WEP) {
2345                         ret = wl1271_cmd_set_sta_default_wep_key(wl,
2346                                                         wl->default_key);
2347                         if (ret < 0)
2348                                 return ret;
2349                 }
2350         }
2351
2352         return 0;
2353 }
2354
2355 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2356                              struct ieee80211_vif *vif,
2357                              struct ieee80211_sta *sta,
2358                              struct ieee80211_key_conf *key_conf)
2359 {
2360         struct wl1271 *wl = hw->priv;
2361         int ret;
2362         u32 tx_seq_32 = 0;
2363         u16 tx_seq_16 = 0;
2364         u8 key_type;
2365
2366         wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
2367
2368         wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
2369         wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
2370                      key_conf->cipher, key_conf->keyidx,
2371                      key_conf->keylen, key_conf->flags);
2372         wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
2373
2374         mutex_lock(&wl->mutex);
2375
2376         if (unlikely(wl->state == WL1271_STATE_OFF)) {
2377                 ret = -EAGAIN;
2378                 goto out_unlock;
2379         }
2380
2381         ret = wl1271_ps_elp_wakeup(wl);
2382         if (ret < 0)
2383                 goto out_unlock;
2384
2385         switch (key_conf->cipher) {
2386         case WLAN_CIPHER_SUITE_WEP40:
2387         case WLAN_CIPHER_SUITE_WEP104:
2388                 key_type = KEY_WEP;
2389
2390                 key_conf->hw_key_idx = key_conf->keyidx;
2391                 break;
2392         case WLAN_CIPHER_SUITE_TKIP:
2393                 key_type = KEY_TKIP;
2394
2395                 key_conf->hw_key_idx = key_conf->keyidx;
2396                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2397                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2398                 break;
2399         case WLAN_CIPHER_SUITE_CCMP:
2400                 key_type = KEY_AES;
2401
2402                 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
2403                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2404                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2405                 break;
2406         case WL1271_CIPHER_SUITE_GEM:
2407                 key_type = KEY_GEM;
2408                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2409                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2410                 break;
2411         default:
2412                 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
2413
2414                 ret = -EOPNOTSUPP;
2415                 goto out_sleep;
2416         }
2417
2418         switch (cmd) {
2419         case SET_KEY:
2420                 ret = wl1271_set_key(wl, KEY_ADD_OR_REPLACE,
2421                                  key_conf->keyidx, key_type,
2422                                  key_conf->keylen, key_conf->key,
2423                                  tx_seq_32, tx_seq_16, sta);
2424                 if (ret < 0) {
2425                         wl1271_error("Could not add or replace key");
2426                         goto out_sleep;
2427                 }
2428                 break;
2429
2430         case DISABLE_KEY:
2431                 ret = wl1271_set_key(wl, KEY_REMOVE,
2432                                      key_conf->keyidx, key_type,
2433                                      key_conf->keylen, key_conf->key,
2434                                      0, 0, sta);
2435                 if (ret < 0) {
2436                         wl1271_error("Could not remove key");
2437                         goto out_sleep;
2438                 }
2439                 break;
2440
2441         default:
2442                 wl1271_error("Unsupported key cmd 0x%x", cmd);
2443                 ret = -EOPNOTSUPP;
2444                 break;
2445         }
2446
2447 out_sleep:
2448         wl1271_ps_elp_sleep(wl);
2449
2450 out_unlock:
2451         mutex_unlock(&wl->mutex);
2452
2453         return ret;
2454 }
2455
2456 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
2457                              struct ieee80211_vif *vif,
2458                              struct cfg80211_scan_request *req)
2459 {
2460         struct wl1271 *wl = hw->priv;
2461         int ret;
2462         u8 *ssid = NULL;
2463         size_t len = 0;
2464
2465         wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
2466
2467         if (req->n_ssids) {
2468                 ssid = req->ssids[0].ssid;
2469                 len = req->ssids[0].ssid_len;
2470         }
2471
2472         mutex_lock(&wl->mutex);
2473
2474         if (wl->state == WL1271_STATE_OFF) {
2475                 /*
2476                  * We cannot return -EBUSY here because cfg80211 will expect
2477                  * a call to ieee80211_scan_completed if we do - in this case
2478                  * there won't be any call.
2479                  */
2480                 ret = -EAGAIN;
2481                 goto out;
2482         }
2483
2484         ret = wl1271_ps_elp_wakeup(wl);
2485         if (ret < 0)
2486                 goto out;
2487
2488         ret = wl1271_scan(hw->priv, ssid, len, req);
2489
2490         wl1271_ps_elp_sleep(wl);
2491
2492 out:
2493         mutex_unlock(&wl->mutex);
2494
2495         return ret;
2496 }
2497
2498 static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
2499                                       struct ieee80211_vif *vif,
2500                                       struct cfg80211_sched_scan_request *req,
2501                                       struct ieee80211_sched_scan_ies *ies)
2502 {
2503         struct wl1271 *wl = hw->priv;
2504         int ret;
2505
2506         wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");
2507
2508         mutex_lock(&wl->mutex);
2509
2510         ret = wl1271_ps_elp_wakeup(wl);
2511         if (ret < 0)
2512                 goto out;
2513
2514         ret = wl1271_scan_sched_scan_config(wl, req, ies);
2515         if (ret < 0)
2516                 goto out_sleep;
2517
2518         ret = wl1271_scan_sched_scan_start(wl);
2519         if (ret < 0)
2520                 goto out_sleep;
2521
2522         wl->sched_scanning = true;
2523
2524 out_sleep:
2525         wl1271_ps_elp_sleep(wl);
2526 out:
2527         mutex_unlock(&wl->mutex);
2528         return ret;
2529 }
2530
2531 static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
2532                                       struct ieee80211_vif *vif)
2533 {
2534         struct wl1271 *wl = hw->priv;
2535         int ret;
2536
2537         wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");
2538
2539         mutex_lock(&wl->mutex);
2540
2541         ret = wl1271_ps_elp_wakeup(wl);
2542         if (ret < 0)
2543                 goto out;
2544
2545         wl1271_scan_sched_scan_stop(wl);
2546
2547         wl1271_ps_elp_sleep(wl);
2548 out:
2549         mutex_unlock(&wl->mutex);
2550 }
2551
2552 static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
2553 {
2554         struct wl1271 *wl = hw->priv;
2555         int ret = 0;
2556
2557         mutex_lock(&wl->mutex);
2558
2559         if (unlikely(wl->state == WL1271_STATE_OFF)) {
2560                 ret = -EAGAIN;
2561                 goto out;
2562         }
2563
2564         ret = wl1271_ps_elp_wakeup(wl);
2565         if (ret < 0)
2566                 goto out;
2567
2568         ret = wl1271_acx_frag_threshold(wl, value);
2569         if (ret < 0)
2570                 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
2571
2572         wl1271_ps_elp_sleep(wl);
2573
2574 out:
2575         mutex_unlock(&wl->mutex);
2576
2577         return ret;
2578 }
2579
2580 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
2581 {
2582         struct wl1271 *wl = hw->priv;
2583         int ret = 0;
2584
2585         mutex_lock(&wl->mutex);
2586
2587         if (unlikely(wl->state == WL1271_STATE_OFF)) {
2588                 ret = -EAGAIN;
2589                 goto out;
2590         }
2591
2592         ret = wl1271_ps_elp_wakeup(wl);
2593         if (ret < 0)
2594                 goto out;
2595
2596         ret = wl1271_acx_rts_threshold(wl, value);
2597         if (ret < 0)
2598                 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
2599
2600         wl1271_ps_elp_sleep(wl);
2601
2602 out:
2603         mutex_unlock(&wl->mutex);
2604
2605         return ret;
2606 }
2607
2608 static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
2609                             int offset)
2610 {
2611         u8 ssid_len;
2612         const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
2613                                          skb->len - offset);
2614
2615         if (!ptr) {
2616                 wl1271_error("No SSID in IEs!");
2617                 return -ENOENT;
2618         }
2619
2620         ssid_len = ptr[1];
2621         if (ssid_len > IEEE80211_MAX_SSID_LEN) {
2622                 wl1271_error("SSID is too long!");
2623                 return -EINVAL;
2624         }
2625
2626         wl->ssid_len = ssid_len;
2627         memcpy(wl->ssid, ptr+2, ssid_len);
2628         return 0;
2629 }
2630
2631 static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
2632                                        struct ieee80211_bss_conf *bss_conf,
2633                                        u32 changed)
2634 {
2635         int ret = 0;
2636
2637         if (changed & BSS_CHANGED_ERP_SLOT) {
2638                 if (bss_conf->use_short_slot)
2639                         ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
2640                 else
2641                         ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
2642                 if (ret < 0) {
2643                         wl1271_warning("Set slot time failed %d", ret);
2644                         goto out;
2645                 }
2646         }
2647
2648         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2649                 if (bss_conf->use_short_preamble)
2650                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
2651                 else
2652                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
2653         }
2654
2655         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2656                 if (bss_conf->use_cts_prot)
2657                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
2658                 else
2659                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
2660                 if (ret < 0) {
2661                         wl1271_warning("Set ctsprotect failed %d", ret);
2662                         goto out;
2663                 }
2664         }
2665
2666 out:
2667         return ret;
2668 }
2669
2670 static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
2671                                           struct ieee80211_vif *vif,
2672                                           struct ieee80211_bss_conf *bss_conf,
2673                                           u32 changed)
2674 {
2675         bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2676         int ret = 0;
2677
2678         if ((changed & BSS_CHANGED_BEACON_INT)) {
2679                 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
2680                         bss_conf->beacon_int);
2681
2682                 wl->beacon_int = bss_conf->beacon_int;
2683         }
2684
2685         if ((changed & BSS_CHANGED_BEACON)) {
2686                 struct ieee80211_hdr *hdr;
2687                 int ieoffset = offsetof(struct ieee80211_mgmt,
2688                                         u.beacon.variable);
2689                 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
2690                 u16 tmpl_id;
2691
2692                 if (!beacon)
2693                         goto out;
2694
2695                 wl1271_debug(DEBUG_MASTER, "beacon updated");
2696
2697                 ret = wl1271_ssid_set(wl, beacon, ieoffset);
2698                 if (ret < 0) {
2699                         dev_kfree_skb(beacon);
2700                         goto out;
2701                 }
2702                 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
2703                                   CMD_TEMPL_BEACON;
2704                 ret = wl1271_cmd_template_set(wl, tmpl_id,
2705                                               beacon->data,
2706                                               beacon->len, 0,
2707                                               wl1271_tx_min_rate_get(wl));
2708                 if (ret < 0) {
2709                         dev_kfree_skb(beacon);
2710                         goto out;
2711                 }
2712
2713                 hdr = (struct ieee80211_hdr *) beacon->data;
2714                 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2715                                                  IEEE80211_STYPE_PROBE_RESP);
2716
2717                 tmpl_id = is_ap ? CMD_TEMPL_AP_PROBE_RESPONSE :
2718                                   CMD_TEMPL_PROBE_RESPONSE;
2719                 ret = wl1271_cmd_template_set(wl,
2720                                               tmpl_id,
2721                                               beacon->data,
2722                                               beacon->len, 0,
2723                                               wl1271_tx_min_rate_get(wl));
2724                 dev_kfree_skb(beacon);
2725                 if (ret < 0)
2726                         goto out;
2727         }
2728
2729 out:
2730         return ret;
2731 }
2732
2733 /* AP mode changes */
2734 static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
2735                                        struct ieee80211_vif *vif,
2736                                        struct ieee80211_bss_conf *bss_conf,
2737                                        u32 changed)
2738 {
2739         int ret = 0;
2740
2741         if ((changed & BSS_CHANGED_BASIC_RATES)) {
2742                 u32 rates = bss_conf->basic_rates;
2743
2744                 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates);
2745                 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2746
2747                 ret = wl1271_init_ap_rates(wl);
2748                 if (ret < 0) {
2749                         wl1271_error("AP rate policy change failed %d", ret);
2750                         goto out;
2751                 }
2752
2753                 ret = wl1271_ap_init_templates(wl);
2754                 if (ret < 0)
2755                         goto out;
2756         }
2757
2758         ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
2759         if (ret < 0)
2760                 goto out;
2761
2762         if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
2763                 if (bss_conf->enable_beacon) {
2764                         if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2765                                 ret = wl1271_cmd_start_bss(wl);
2766                                 if (ret < 0)
2767                                         goto out;
2768
2769                                 set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2770                                 wl1271_debug(DEBUG_AP, "started AP");
2771
2772                                 ret = wl1271_ap_init_hwenc(wl);
2773                                 if (ret < 0)
2774                                         goto out;
2775                         }
2776                 } else {
2777                         if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2778                                 ret = wl1271_cmd_stop_bss(wl);
2779                                 if (ret < 0)
2780                                         goto out;
2781
2782                                 clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2783                                 wl1271_debug(DEBUG_AP, "stopped AP");
2784                         }
2785                 }
2786         }
2787
2788         if (changed & BSS_CHANGED_IBSS) {
2789                 wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
2790                              bss_conf->ibss_joined);
2791
2792                 if (bss_conf->ibss_joined) {
2793                         u32 rates = bss_conf->basic_rates;
2794                         wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
2795                                                                          rates);
2796                         wl->basic_rate = wl1271_tx_min_rate_get(wl);
2797
2798                         /* by default, use 11b rates */
2799                         wl->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
2800                         ret = wl1271_acx_sta_rate_policies(wl);
2801                         if (ret < 0)
2802                                 goto out;
2803                 }
2804         }
2805
2806         ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
2807         if (ret < 0)
2808                 goto out;
2809 out:
2810         return;
2811 }
2812
2813 /* STA/IBSS mode changes */
2814 static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
2815                                         struct ieee80211_vif *vif,
2816                                         struct ieee80211_bss_conf *bss_conf,
2817                                         u32 changed)
2818 {
2819         bool do_join = false, set_assoc = false;
2820         bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
2821         u32 sta_rate_set = 0;
2822         int ret;
2823         struct ieee80211_sta *sta;
2824         bool sta_exists = false;
2825         struct ieee80211_sta_ht_cap sta_ht_cap;
2826
2827         if (is_ibss) {
2828                 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
2829                                                      changed);
2830                 if (ret < 0)
2831                         goto out;
2832         }
2833
2834         if ((changed & BSS_CHANGED_BEACON_INT)  && is_ibss)
2835                 do_join = true;
2836
2837         /* Need to update the SSID (for filtering etc) */
2838         if ((changed & BSS_CHANGED_BEACON) && is_ibss)
2839                 do_join = true;
2840
2841         if ((changed & BSS_CHANGED_BEACON_ENABLED) && is_ibss) {
2842                 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
2843                              bss_conf->enable_beacon ? "enabled" : "disabled");
2844
2845                 if (bss_conf->enable_beacon)
2846                         wl->set_bss_type = BSS_TYPE_IBSS;
2847                 else
2848                         wl->set_bss_type = BSS_TYPE_STA_BSS;
2849                 do_join = true;
2850         }
2851
2852         if ((changed & BSS_CHANGED_CQM)) {
2853                 bool enable = false;
2854                 if (bss_conf->cqm_rssi_thold)
2855                         enable = true;
2856                 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
2857                                                   bss_conf->cqm_rssi_thold,
2858                                                   bss_conf->cqm_rssi_hyst);
2859                 if (ret < 0)
2860                         goto out;
2861                 wl->rssi_thold = bss_conf->cqm_rssi_thold;
2862         }
2863
2864         if ((changed & BSS_CHANGED_BSSID) &&
2865             /*
2866              * Now we know the correct bssid, so we send a new join command
2867              * and enable the BSSID filter
2868              */
2869             memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
2870                 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
2871
2872                 if (!is_zero_ether_addr(wl->bssid)) {
2873                         ret = wl1271_cmd_build_null_data(wl);
2874                         if (ret < 0)
2875                                 goto out;
2876
2877                         ret = wl1271_build_qos_null_data(wl);
2878                         if (ret < 0)
2879                                 goto out;
2880
2881                         /* filter out all packets not from this BSSID */
2882                         wl1271_configure_filters(wl, 0);
2883
2884                         /* Need to update the BSSID (for filtering etc) */
2885                         do_join = true;
2886                 }
2887         }
2888
2889         rcu_read_lock();
2890         sta = ieee80211_find_sta(vif, bss_conf->bssid);
2891         if (sta)  {
2892                 /* save the supp_rates of the ap */
2893                 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
2894                 if (sta->ht_cap.ht_supported)
2895                         sta_rate_set |=
2896                             (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
2897                 sta_ht_cap = sta->ht_cap;
2898                 sta_exists = true;
2899         }
2900         rcu_read_unlock();
2901
2902         if (sta_exists) {
2903                 /* handle new association with HT and HT information change */
2904                 if ((changed & BSS_CHANGED_HT) &&
2905                     (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
2906                         ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
2907                                                              true);
2908                         if (ret < 0) {
2909                                 wl1271_warning("Set ht cap true failed %d",
2910                                                ret);
2911                                 goto out;
2912                         }
2913                         ret = wl1271_acx_set_ht_information(wl,
2914                                                 bss_conf->ht_operation_mode);
2915                         if (ret < 0) {
2916                                 wl1271_warning("Set ht information failed %d",
2917                                                ret);
2918                                 goto out;
2919                         }
2920                 }
2921                 /* handle new association without HT and disassociation */
2922                 else if (changed & BSS_CHANGED_ASSOC) {
2923                         ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
2924                                                              false);
2925                         if (ret < 0) {
2926                                 wl1271_warning("Set ht cap false failed %d",
2927                                                ret);
2928                                 goto out;
2929                         }
2930                 }
2931         }
2932
2933         if ((changed & BSS_CHANGED_ASSOC)) {
2934                 if (bss_conf->assoc) {
2935                         u32 rates;
2936                         int ieoffset;
2937                         wl->aid = bss_conf->aid;
2938                         set_assoc = true;
2939
2940                         wl->ps_poll_failures = 0;
2941
2942                         /*
2943                          * use basic rates from AP, and determine lowest rate
2944                          * to use with control frames.
2945                          */
2946                         rates = bss_conf->basic_rates;
2947                         wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
2948                                                                          rates);
2949                         wl->basic_rate = wl1271_tx_min_rate_get(wl);
2950                         if (sta_rate_set)
2951                                 wl->rate_set = wl1271_tx_enabled_rates_get(wl,
2952                                                                 sta_rate_set);
2953                         ret = wl1271_acx_sta_rate_policies(wl);
2954                         if (ret < 0)
2955                                 goto out;
2956
2957                         /*
2958                          * with wl1271, we don't need to update the
2959                          * beacon_int and dtim_period, because the firmware
2960                          * updates it by itself when the first beacon is
2961                          * received after a join.
2962                          */
2963                         ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
2964                         if (ret < 0)
2965                                 goto out;
2966
2967                         /*
2968                          * Get a template for hardware connection maintenance
2969                          */
2970                         dev_kfree_skb(wl->probereq);
2971                         wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL);
2972                         ieoffset = offsetof(struct ieee80211_mgmt,
2973                                             u.probe_req.variable);
2974                         wl1271_ssid_set(wl, wl->probereq, ieoffset);
2975
2976                         /* enable the connection monitoring feature */
2977                         ret = wl1271_acx_conn_monit_params(wl, true);
2978                         if (ret < 0)
2979                                 goto out;
2980
2981                         /* If we want to go in PSM but we're not there yet */
2982                         if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
2983                             !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
2984                                 enum wl1271_cmd_ps_mode mode;
2985
2986                                 mode = STATION_POWER_SAVE_MODE;
2987                                 ret = wl1271_ps_set_mode(wl, mode,
2988                                                          wl->basic_rate,
2989                                                          true);
2990                                 if (ret < 0)
2991                                         goto out;
2992                         }
2993                 } else {
2994                         /* use defaults when not associated */
2995                         bool was_assoc =
2996                             !!test_and_clear_bit(WL1271_FLAG_STA_ASSOCIATED,
2997                                                  &wl->flags);
2998                         clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
2999                         wl->aid = 0;
3000
3001                         /* free probe-request template */
3002                         dev_kfree_skb(wl->probereq);
3003                         wl->probereq = NULL;
3004
3005                         /* re-enable dynamic ps - just in case */
3006                         ieee80211_enable_dyn_ps(wl->vif);
3007
3008                         /* revert back to minimum rates for the current band */
3009                         wl1271_set_band_rate(wl);
3010                         wl->basic_rate = wl1271_tx_min_rate_get(wl);
3011                         ret = wl1271_acx_sta_rate_policies(wl);
3012                         if (ret < 0)
3013                                 goto out;
3014
3015                         /* disable connection monitor features */
3016                         ret = wl1271_acx_conn_monit_params(wl, false);
3017
3018                         /* Disable the keep-alive feature */
3019                         ret = wl1271_acx_keep_alive_mode(wl, false);
3020                         if (ret < 0)
3021                                 goto out;
3022
3023                         /* restore the bssid filter and go to dummy bssid */
3024                         if (was_assoc) {
3025                                 wl1271_unjoin(wl);
3026                                 wl1271_dummy_join(wl);
3027                         }
3028                 }
3029         }
3030
3031         ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
3032         if (ret < 0)
3033                 goto out;
3034
3035         if (changed & BSS_CHANGED_ARP_FILTER) {
3036                 __be32 addr = bss_conf->arp_addr_list[0];
3037                 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3038
3039                 if (bss_conf->arp_addr_cnt == 1 &&
3040                     bss_conf->arp_filter_enabled) {
3041                         /*
3042                          * The template should have been configured only upon
3043                          * association. however, it seems that the correct ip
3044                          * isn't being set (when sending), so we have to
3045                          * reconfigure the template upon every ip change.
3046                          */
3047                         ret = wl1271_cmd_build_arp_rsp(wl, addr);
3048                         if (ret < 0) {
3049                                 wl1271_warning("build arp rsp failed: %d", ret);
3050                                 goto out;
3051                         }
3052
3053                         ret = wl1271_acx_arp_ip_filter(wl,
3054                                 ACX_ARP_FILTER_ARP_FILTERING,
3055                                 addr);
3056                 } else
3057                         ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
3058
3059                 if (ret < 0)
3060                         goto out;
3061         }
3062
3063         if (do_join) {
3064                 ret = wl1271_join(wl, set_assoc);
3065                 if (ret < 0) {
3066                         wl1271_warning("cmd join failed %d", ret);
3067                         goto out;
3068                 }
3069         }
3070
3071 out:
3072         return;
3073 }
3074
3075 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
3076                                        struct ieee80211_vif *vif,
3077                                        struct ieee80211_bss_conf *bss_conf,
3078                                        u32 changed)
3079 {
3080         struct wl1271 *wl = hw->priv;
3081         bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
3082         int ret;
3083
3084         wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
3085                      (int)changed);
3086
3087         mutex_lock(&wl->mutex);
3088
3089         if (unlikely(wl->state == WL1271_STATE_OFF))
3090                 goto out;
3091
3092         ret = wl1271_ps_elp_wakeup(wl);
3093         if (ret < 0)
3094                 goto out;
3095
3096         if (is_ap)
3097                 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
3098         else
3099                 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
3100
3101         wl1271_ps_elp_sleep(wl);
3102
3103 out:
3104         mutex_unlock(&wl->mutex);
3105 }
3106
3107 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
3108                              const struct ieee80211_tx_queue_params *params)
3109 {
3110         struct wl1271 *wl = hw->priv;
3111         u8 ps_scheme;
3112         int ret = 0;
3113
3114         mutex_lock(&wl->mutex);
3115
3116         wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
3117
3118         if (params->uapsd)
3119                 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
3120         else
3121                 ps_scheme = CONF_PS_SCHEME_LEGACY;
3122
3123         if (wl->state == WL1271_STATE_OFF) {
3124                 /*
3125                  * If the state is off, the parameters will be recorded and
3126                  * configured on init. This happens in AP-mode.
3127                  */
3128                 struct conf_tx_ac_category *conf_ac =
3129                         &wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)];
3130                 struct conf_tx_tid *conf_tid =
3131                         &wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)];
3132
3133                 conf_ac->ac = wl1271_tx_get_queue(queue);
3134                 conf_ac->cw_min = (u8)params->cw_min;
3135                 conf_ac->cw_max = params->cw_max;
3136                 conf_ac->aifsn = params->aifs;
3137                 conf_ac->tx_op_limit = params->txop << 5;
3138
3139                 conf_tid->queue_id = wl1271_tx_get_queue(queue);
3140                 conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF;
3141                 conf_tid->tsid = wl1271_tx_get_queue(queue);
3142                 conf_tid->ps_scheme = ps_scheme;
3143                 conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY;
3144                 conf_tid->apsd_conf[0] = 0;
3145                 conf_tid->apsd_conf[1] = 0;
3146                 goto out;
3147         }
3148
3149         ret = wl1271_ps_elp_wakeup(wl);
3150         if (ret < 0)
3151                 goto out;
3152
3153         /*
3154          * the txop is confed in units of 32us by the mac80211,
3155          * we need us
3156          */
3157         ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
3158                                 params->cw_min, params->cw_max,
3159                                 params->aifs, params->txop << 5);
3160         if (ret < 0)
3161                 goto out_sleep;
3162
3163         ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
3164                                  CONF_CHANNEL_TYPE_EDCF,
3165                                  wl1271_tx_get_queue(queue),
3166                                  ps_scheme, CONF_ACK_POLICY_LEGACY,
3167                                  0, 0);
3168
3169 out_sleep:
3170         wl1271_ps_elp_sleep(wl);
3171
3172 out:
3173         mutex_unlock(&wl->mutex);
3174
3175         return ret;
3176 }
3177
3178 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
3179 {
3180
3181         struct wl1271 *wl = hw->priv;
3182         u64 mactime = ULLONG_MAX;
3183         int ret;
3184
3185         wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
3186
3187         mutex_lock(&wl->mutex);
3188
3189         if (unlikely(wl->state == WL1271_STATE_OFF))
3190                 goto out;
3191
3192         ret = wl1271_ps_elp_wakeup(wl);
3193         if (ret < 0)
3194                 goto out;
3195
3196         ret = wl1271_acx_tsf_info(wl, &mactime);
3197         if (ret < 0)
3198                 goto out_sleep;
3199
3200 out_sleep:
3201         wl1271_ps_elp_sleep(wl);
3202
3203 out:
3204         mutex_unlock(&wl->mutex);
3205         return mactime;
3206 }
3207
3208 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
3209                                 struct survey_info *survey)
3210 {
3211         struct wl1271 *wl = hw->priv;
3212         struct ieee80211_conf *conf = &hw->conf;
3213
3214         if (idx != 0)
3215                 return -ENOENT;
3216
3217         survey->channel = conf->channel;
3218         survey->filled = SURVEY_INFO_NOISE_DBM;
3219         survey->noise = wl->noise;
3220
3221         return 0;
3222 }
3223
3224 static int wl1271_allocate_sta(struct wl1271 *wl,
3225                              struct ieee80211_sta *sta,
3226                              u8 *hlid)
3227 {
3228         struct wl1271_station *wl_sta;
3229         int id;
3230
3231         id = find_first_zero_bit(wl->ap_hlid_map, AP_MAX_STATIONS);
3232         if (id >= AP_MAX_STATIONS) {
3233                 wl1271_warning("could not allocate HLID - too much stations");
3234                 return -EBUSY;
3235         }
3236
3237         wl_sta = (struct wl1271_station *)sta->drv_priv;
3238         __set_bit(id, wl->ap_hlid_map);
3239         wl_sta->hlid = WL1271_AP_STA_HLID_START + id;
3240         *hlid = wl_sta->hlid;
3241         memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
3242         return 0;
3243 }
3244
3245 static void wl1271_free_sta(struct wl1271 *wl, u8 hlid)
3246 {
3247         int id = hlid - WL1271_AP_STA_HLID_START;
3248
3249         if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3250                 return;
3251
3252         __clear_bit(id, wl->ap_hlid_map);
3253         memset(wl->links[hlid].addr, 0, ETH_ALEN);
3254         wl1271_tx_reset_link_queues(wl, hlid);
3255         __clear_bit(hlid, &wl->ap_ps_map);
3256         __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
3257 }
3258
3259 static int wl1271_op_sta_add(struct ieee80211_hw *hw,
3260                              struct ieee80211_vif *vif,
3261                              struct ieee80211_sta *sta)
3262 {
3263         struct wl1271 *wl = hw->priv;
3264         int ret = 0;
3265         u8 hlid;
3266
3267         mutex_lock(&wl->mutex);
3268
3269         if (unlikely(wl->state == WL1271_STATE_OFF))
3270                 goto out;
3271
3272         if (wl->bss_type != BSS_TYPE_AP_BSS)
3273                 goto out;
3274
3275         wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
3276
3277         ret = wl1271_allocate_sta(wl, sta, &hlid);
3278         if (ret < 0)
3279                 goto out;
3280
3281         ret = wl1271_ps_elp_wakeup(wl);
3282         if (ret < 0)
3283                 goto out_free_sta;
3284
3285         ret = wl1271_cmd_add_sta(wl, sta, hlid);
3286         if (ret < 0)
3287                 goto out_sleep;
3288
3289 out_sleep:
3290         wl1271_ps_elp_sleep(wl);
3291
3292 out_free_sta:
3293         if (ret < 0)
3294                 wl1271_free_sta(wl, hlid);
3295
3296 out:
3297         mutex_unlock(&wl->mutex);
3298         return ret;
3299 }
3300
3301 static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
3302                                 struct ieee80211_vif *vif,
3303                                 struct ieee80211_sta *sta)
3304 {
3305         struct wl1271 *wl = hw->priv;
3306         struct wl1271_station *wl_sta;
3307         int ret = 0, id;
3308
3309         mutex_lock(&wl->mutex);
3310
3311         if (unlikely(wl->state == WL1271_STATE_OFF))
3312                 goto out;
3313
3314         if (wl->bss_type != BSS_TYPE_AP_BSS)
3315                 goto out;
3316
3317         wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
3318
3319         wl_sta = (struct wl1271_station *)sta->drv_priv;
3320         id = wl_sta->hlid - WL1271_AP_STA_HLID_START;
3321         if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3322                 goto out;
3323
3324         ret = wl1271_ps_elp_wakeup(wl);
3325         if (ret < 0)
3326                 goto out;
3327
3328         ret = wl1271_cmd_remove_sta(wl, wl_sta->hlid);
3329         if (ret < 0)
3330                 goto out_sleep;
3331
3332         wl1271_free_sta(wl, wl_sta->hlid);
3333
3334 out_sleep:
3335         wl1271_ps_elp_sleep(wl);
3336
3337 out:
3338         mutex_unlock(&wl->mutex);
3339         return ret;
3340 }
3341
3342 static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
3343                                   struct ieee80211_vif *vif,
3344                                   enum ieee80211_ampdu_mlme_action action,
3345                                   struct ieee80211_sta *sta, u16 tid, u16 *ssn,
3346                                   u8 buf_size)
3347 {
3348         struct wl1271 *wl = hw->priv;
3349         int ret;
3350
3351         mutex_lock(&wl->mutex);
3352
3353         if (unlikely(wl->state == WL1271_STATE_OFF)) {
3354                 ret = -EAGAIN;
3355                 goto out;
3356         }
3357
3358         ret = wl1271_ps_elp_wakeup(wl);
3359         if (ret < 0)
3360                 goto out;
3361
3362         wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu: Rx tid %d action %d",
3363                      tid, action);
3364
3365         switch (action) {
3366         case IEEE80211_AMPDU_RX_START:
3367                 if ((wl->ba_support) && (wl->ba_allowed)) {
3368                         ret = wl1271_acx_set_ba_receiver_session(wl, tid, *ssn,
3369                                                                  true);
3370                         if (!ret)
3371                                 wl->ba_rx_bitmap |= BIT(tid);
3372                 } else {
3373                         ret = -ENOTSUPP;
3374                 }
3375                 break;
3376
3377         case IEEE80211_AMPDU_RX_STOP:
3378                 ret = wl1271_acx_set_ba_receiver_session(wl, tid, 0, false);
3379                 if (!ret)
3380                         wl->ba_rx_bitmap &= ~BIT(tid);
3381                 break;
3382
3383         /*
3384          * The BA initiator session management in FW independently.
3385          * Falling break here on purpose for all TX APDU commands.
3386          */
3387         case IEEE80211_AMPDU_TX_START:
3388         case IEEE80211_AMPDU_TX_STOP:
3389         case IEEE80211_AMPDU_TX_OPERATIONAL:
3390                 ret = -EINVAL;
3391                 break;
3392
3393         default:
3394                 wl1271_error("Incorrect ampdu action id=%x\n", action);
3395                 ret = -EINVAL;
3396         }
3397
3398         wl1271_ps_elp_sleep(wl);
3399
3400 out:
3401         mutex_unlock(&wl->mutex);
3402
3403         return ret;
3404 }
3405
3406 static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
3407 {
3408         struct wl1271 *wl = hw->priv;
3409         bool ret = false;
3410
3411         mutex_lock(&wl->mutex);
3412
3413         if (unlikely(wl->state == WL1271_STATE_OFF))
3414                 goto out;
3415
3416         /* packets are considered pending if in the TX queue or the FW */
3417         ret = (wl->tx_queue_count > 0) || (wl->tx_frames_cnt > 0);
3418
3419         /* the above is appropriate for STA mode for PS purposes */
3420         WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3421
3422 out:
3423         mutex_unlock(&wl->mutex);
3424
3425         return ret;
3426 }
3427
3428 /* can't be const, mac80211 writes to this */
3429 static struct ieee80211_rate wl1271_rates[] = {
3430         { .bitrate = 10,
3431           .hw_value = CONF_HW_BIT_RATE_1MBPS,
3432           .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
3433         { .bitrate = 20,
3434           .hw_value = CONF_HW_BIT_RATE_2MBPS,
3435           .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
3436           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3437         { .bitrate = 55,
3438           .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
3439           .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
3440           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3441         { .bitrate = 110,
3442           .hw_value = CONF_HW_BIT_RATE_11MBPS,
3443           .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
3444           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3445         { .bitrate = 60,
3446           .hw_value = CONF_HW_BIT_RATE_6MBPS,
3447           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
3448         { .bitrate = 90,
3449           .hw_value = CONF_HW_BIT_RATE_9MBPS,
3450           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
3451         { .bitrate = 120,
3452           .hw_value = CONF_HW_BIT_RATE_12MBPS,
3453           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
3454         { .bitrate = 180,
3455           .hw_value = CONF_HW_BIT_RATE_18MBPS,
3456           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
3457         { .bitrate = 240,
3458           .hw_value = CONF_HW_BIT_RATE_24MBPS,
3459           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
3460         { .bitrate = 360,
3461          .hw_value = CONF_HW_BIT_RATE_36MBPS,
3462          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
3463         { .bitrate = 480,
3464           .hw_value = CONF_HW_BIT_RATE_48MBPS,
3465           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
3466         { .bitrate = 540,
3467           .hw_value = CONF_HW_BIT_RATE_54MBPS,
3468           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
3469 };
3470
3471 /* can't be const, mac80211 writes to this */
3472 static struct ieee80211_channel wl1271_channels[] = {
3473         { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
3474         { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
3475         { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
3476         { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
3477         { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
3478         { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
3479         { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
3480         { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
3481         { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
3482         { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
3483         { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
3484         { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
3485         { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
3486         { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
3487 };
3488
3489 /* mapping to indexes for wl1271_rates */
3490 static const u8 wl1271_rate_to_idx_2ghz[] = {
3491         /* MCS rates are used only with 11n */
3492         7,                            /* CONF_HW_RXTX_RATE_MCS7 */
3493         6,                            /* CONF_HW_RXTX_RATE_MCS6 */
3494         5,                            /* CONF_HW_RXTX_RATE_MCS5 */
3495         4,                            /* CONF_HW_RXTX_RATE_MCS4 */
3496         3,                            /* CONF_HW_RXTX_RATE_MCS3 */
3497         2,                            /* CONF_HW_RXTX_RATE_MCS2 */
3498         1,                            /* CONF_HW_RXTX_RATE_MCS1 */
3499         0,                            /* CONF_HW_RXTX_RATE_MCS0 */
3500
3501         11,                            /* CONF_HW_RXTX_RATE_54   */
3502         10,                            /* CONF_HW_RXTX_RATE_48   */
3503         9,                             /* CONF_HW_RXTX_RATE_36   */
3504         8,                             /* CONF_HW_RXTX_RATE_24   */
3505
3506         /* TI-specific rate */
3507         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
3508
3509         7,                             /* CONF_HW_RXTX_RATE_18   */
3510         6,                             /* CONF_HW_RXTX_RATE_12   */
3511         3,                             /* CONF_HW_RXTX_RATE_11   */
3512         5,                             /* CONF_HW_RXTX_RATE_9    */
3513         4,                             /* CONF_HW_RXTX_RATE_6    */
3514         2,                             /* CONF_HW_RXTX_RATE_5_5  */
3515         1,                             /* CONF_HW_RXTX_RATE_2    */
3516         0                              /* CONF_HW_RXTX_RATE_1    */
3517 };
3518
3519 /* 11n STA capabilities */
3520 #define HW_RX_HIGHEST_RATE      72
3521
3522 #ifdef CONFIG_WL12XX_HT
3523 #define WL12XX_HT_CAP { \
3524         .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
3525                (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
3526         .ht_supported = true, \
3527         .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
3528         .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
3529         .mcs = { \
3530                 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
3531                 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
3532                 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
3533                 }, \
3534 }
3535 #else
3536 #define WL12XX_HT_CAP { \
3537         .ht_supported = false, \
3538 }
3539 #endif
3540
3541 /* can't be const, mac80211 writes to this */
3542 static struct ieee80211_supported_band wl1271_band_2ghz = {
3543         .channels = wl1271_channels,
3544         .n_channels = ARRAY_SIZE(wl1271_channels),
3545         .bitrates = wl1271_rates,
3546         .n_bitrates = ARRAY_SIZE(wl1271_rates),
3547         .ht_cap = WL12XX_HT_CAP,
3548 };
3549
3550 /* 5 GHz data rates for WL1273 */
3551 static struct ieee80211_rate wl1271_rates_5ghz[] = {
3552         { .bitrate = 60,
3553           .hw_value = CONF_HW_BIT_RATE_6MBPS,
3554           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
3555         { .bitrate = 90,
3556           .hw_value = CONF_HW_BIT_RATE_9MBPS,
3557           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
3558         { .bitrate = 120,
3559           .hw_value = CONF_HW_BIT_RATE_12MBPS,
3560           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
3561         { .bitrate = 180,
3562           .hw_value = CONF_HW_BIT_RATE_18MBPS,
3563           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
3564         { .bitrate = 240,
3565           .hw_value = CONF_HW_BIT_RATE_24MBPS,
3566           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
3567         { .bitrate = 360,
3568          .hw_value = CONF_HW_BIT_RATE_36MBPS,
3569          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
3570         { .bitrate = 480,
3571           .hw_value = CONF_HW_BIT_RATE_48MBPS,
3572           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
3573         { .bitrate = 540,
3574           .hw_value = CONF_HW_BIT_RATE_54MBPS,
3575           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
3576 };
3577
3578 /* 5 GHz band channels for WL1273 */
3579 static struct ieee80211_channel wl1271_channels_5ghz[] = {
3580         { .hw_value = 7, .center_freq = 5035},
3581         { .hw_value = 8, .center_freq = 5040},
3582         { .hw_value = 9, .center_freq = 5045},
3583         { .hw_value = 11, .center_freq = 5055},
3584         { .hw_value = 12, .center_freq = 5060},
3585         { .hw_value = 16, .center_freq = 5080},
3586         { .hw_value = 34, .center_freq = 5170},
3587         { .hw_value = 36, .center_freq = 5180},
3588         { .hw_value = 38, .center_freq = 5190},
3589         { .hw_value = 40, .center_freq = 5200},
3590         { .hw_value = 42, .center_freq = 5210},
3591         { .hw_value = 44, .center_freq = 5220},
3592         { .hw_value = 46, .center_freq = 5230},
3593         { .hw_value = 48, .center_freq = 5240},
3594         { .hw_value = 52, .center_freq = 5260},
3595         { .hw_value = 56, .center_freq = 5280},
3596         { .hw_value = 60, .center_freq = 5300},
3597         { .hw_value = 64, .center_freq = 5320},
3598         { .hw_value = 100, .center_freq = 5500},
3599         { .hw_value = 104, .center_freq = 5520},
3600         { .hw_value = 108, .center_freq = 5540},
3601         { .hw_value = 112, .center_freq = 5560},
3602         { .hw_value = 116, .center_freq = 5580},
3603         { .hw_value = 120, .center_freq = 5600},
3604         { .hw_value = 124, .center_freq = 5620},
3605         { .hw_value = 128, .center_freq = 5640},
3606         { .hw_value = 132, .center_freq = 5660},
3607         { .hw_value = 136, .center_freq = 5680},
3608         { .hw_value = 140, .center_freq = 5700},
3609         { .hw_value = 149, .center_freq = 5745},
3610         { .hw_value = 153, .center_freq = 5765},
3611         { .hw_value = 157, .center_freq = 5785},
3612         { .hw_value = 161, .center_freq = 5805},
3613         { .hw_value = 165, .center_freq = 5825},
3614 };
3615
3616 /* mapping to indexes for wl1271_rates_5ghz */
3617 static const u8 wl1271_rate_to_idx_5ghz[] = {
3618         /* MCS rates are used only with 11n */
3619         7,                            /* CONF_HW_RXTX_RATE_MCS7 */
3620         6,                            /* CONF_HW_RXTX_RATE_MCS6 */
3621         5,                            /* CONF_HW_RXTX_RATE_MCS5 */
3622         4,                            /* CONF_HW_RXTX_RATE_MCS4 */
3623         3,                            /* CONF_HW_RXTX_RATE_MCS3 */
3624         2,                            /* CONF_HW_RXTX_RATE_MCS2 */
3625         1,                            /* CONF_HW_RXTX_RATE_MCS1 */
3626         0,                            /* CONF_HW_RXTX_RATE_MCS0 */
3627
3628         7,                             /* CONF_HW_RXTX_RATE_54   */
3629         6,                             /* CONF_HW_RXTX_RATE_48   */
3630         5,                             /* CONF_HW_RXTX_RATE_36   */
3631         4,                             /* CONF_HW_RXTX_RATE_24   */
3632
3633         /* TI-specific rate */
3634         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
3635
3636         3,                             /* CONF_HW_RXTX_RATE_18   */
3637         2,                             /* CONF_HW_RXTX_RATE_12   */
3638         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11   */
3639         1,                             /* CONF_HW_RXTX_RATE_9    */
3640         0,                             /* CONF_HW_RXTX_RATE_6    */
3641         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5  */
3642         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2    */
3643         CONF_HW_RXTX_RATE_UNSUPPORTED  /* CONF_HW_RXTX_RATE_1    */
3644 };
3645
3646 static struct ieee80211_supported_band wl1271_band_5ghz = {
3647         .channels = wl1271_channels_5ghz,
3648         .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
3649         .bitrates = wl1271_rates_5ghz,
3650         .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
3651         .ht_cap = WL12XX_HT_CAP,
3652 };
3653
3654 static const u8 *wl1271_band_rate_to_idx[] = {
3655         [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
3656         [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
3657 };
3658
3659 static const struct ieee80211_ops wl1271_ops = {
3660         .start = wl1271_op_start,
3661         .stop = wl1271_op_stop,
3662         .add_interface = wl1271_op_add_interface,
3663         .remove_interface = wl1271_op_remove_interface,
3664 #ifdef CONFIG_PM
3665         .suspend = wl1271_op_suspend,
3666         .resume = wl1271_op_resume,
3667 #endif
3668         .config = wl1271_op_config,
3669         .prepare_multicast = wl1271_op_prepare_multicast,
3670         .configure_filter = wl1271_op_configure_filter,
3671         .tx = wl1271_op_tx,
3672         .set_key = wl1271_op_set_key,
3673         .hw_scan = wl1271_op_hw_scan,
3674         .sched_scan_start = wl1271_op_sched_scan_start,
3675         .sched_scan_stop = wl1271_op_sched_scan_stop,
3676         .bss_info_changed = wl1271_op_bss_info_changed,
3677         .set_frag_threshold = wl1271_op_set_frag_threshold,
3678         .set_rts_threshold = wl1271_op_set_rts_threshold,
3679         .conf_tx = wl1271_op_conf_tx,
3680         .get_tsf = wl1271_op_get_tsf,
3681         .get_survey = wl1271_op_get_survey,
3682         .sta_add = wl1271_op_sta_add,
3683         .sta_remove = wl1271_op_sta_remove,
3684         .ampdu_action = wl1271_op_ampdu_action,
3685         .tx_frames_pending = wl1271_tx_frames_pending,
3686         CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
3687 };
3688
3689
3690 u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
3691 {
3692         u8 idx;
3693
3694         BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
3695
3696         if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
3697                 wl1271_error("Illegal RX rate from HW: %d", rate);
3698                 return 0;
3699         }
3700
3701         idx = wl1271_band_rate_to_idx[band][rate];
3702         if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
3703                 wl1271_error("Unsupported RX rate from HW: %d", rate);
3704                 return 0;
3705         }
3706
3707         return idx;
3708 }
3709
3710 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
3711                                                struct device_attribute *attr,
3712                                                char *buf)
3713 {
3714         struct wl1271 *wl = dev_get_drvdata(dev);
3715         ssize_t len;
3716
3717         len = PAGE_SIZE;
3718
3719         mutex_lock(&wl->mutex);
3720         len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
3721                        wl->sg_enabled);
3722         mutex_unlock(&wl->mutex);
3723
3724         return len;
3725
3726 }
3727
3728 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
3729                                                 struct device_attribute *attr,
3730                                                 const char *buf, size_t count)
3731 {
3732         struct wl1271 *wl = dev_get_drvdata(dev);
3733         unsigned long res;
3734         int ret;
3735
3736         ret = kstrtoul(buf, 10, &res);
3737         if (ret < 0) {
3738                 wl1271_warning("incorrect value written to bt_coex_mode");
3739                 return count;
3740         }
3741
3742         mutex_lock(&wl->mutex);
3743
3744         res = !!res;
3745
3746         if (res == wl->sg_enabled)
3747                 goto out;
3748
3749         wl->sg_enabled = res;
3750
3751         if (wl->state == WL1271_STATE_OFF)
3752                 goto out;
3753
3754         ret = wl1271_ps_elp_wakeup(wl);
3755         if (ret < 0)
3756                 goto out;
3757
3758         wl1271_acx_sg_enable(wl, wl->sg_enabled);
3759         wl1271_ps_elp_sleep(wl);
3760
3761  out:
3762         mutex_unlock(&wl->mutex);
3763         return count;
3764 }
3765
3766 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
3767                    wl1271_sysfs_show_bt_coex_state,
3768                    wl1271_sysfs_store_bt_coex_state);
3769
3770 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
3771                                            struct device_attribute *attr,
3772                                            char *buf)
3773 {
3774         struct wl1271 *wl = dev_get_drvdata(dev);
3775         ssize_t len;
3776
3777         len = PAGE_SIZE;
3778
3779         mutex_lock(&wl->mutex);
3780         if (wl->hw_pg_ver >= 0)
3781                 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
3782         else
3783                 len = snprintf(buf, len, "n/a\n");
3784         mutex_unlock(&wl->mutex);
3785
3786         return len;
3787 }
3788
3789 static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
3790                    wl1271_sysfs_show_hw_pg_ver, NULL);
3791
3792 int wl1271_register_hw(struct wl1271 *wl)
3793 {
3794         int ret;
3795
3796         if (wl->mac80211_registered)
3797                 return 0;
3798
3799         ret = wl1271_fetch_nvs(wl);
3800         if (ret == 0) {
3801                 /* NOTE: The wl->nvs->nvs element must be first, in
3802                  * order to simplify the casting, we assume it is at
3803                  * the beginning of the wl->nvs structure.
3804                  */
3805                 u8 *nvs_ptr = (u8 *)wl->nvs;
3806
3807                 wl->mac_addr[0] = nvs_ptr[11];
3808                 wl->mac_addr[1] = nvs_ptr[10];
3809                 wl->mac_addr[2] = nvs_ptr[6];
3810                 wl->mac_addr[3] = nvs_ptr[5];
3811                 wl->mac_addr[4] = nvs_ptr[4];
3812                 wl->mac_addr[5] = nvs_ptr[3];
3813         }
3814
3815         SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
3816
3817         ret = ieee80211_register_hw(wl->hw);
3818         if (ret < 0) {
3819                 wl1271_error("unable to register mac80211 hw: %d", ret);
3820                 return ret;
3821         }
3822
3823         wl->mac80211_registered = true;
3824
3825         wl1271_debugfs_init(wl);
3826
3827         register_netdevice_notifier(&wl1271_dev_notifier);
3828
3829         wl1271_notice("loaded");
3830
3831         return 0;
3832 }
3833 EXPORT_SYMBOL_GPL(wl1271_register_hw);
3834
3835 void wl1271_unregister_hw(struct wl1271 *wl)
3836 {
3837         if (wl->state == WL1271_STATE_PLT)
3838                 __wl1271_plt_stop(wl);
3839
3840         unregister_netdevice_notifier(&wl1271_dev_notifier);
3841         ieee80211_unregister_hw(wl->hw);
3842         wl->mac80211_registered = false;
3843
3844 }
3845 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
3846
3847 int wl1271_init_ieee80211(struct wl1271 *wl)
3848 {
3849         static const u32 cipher_suites[] = {
3850                 WLAN_CIPHER_SUITE_WEP40,
3851                 WLAN_CIPHER_SUITE_WEP104,
3852                 WLAN_CIPHER_SUITE_TKIP,
3853                 WLAN_CIPHER_SUITE_CCMP,
3854                 WL1271_CIPHER_SUITE_GEM,
3855         };
3856
3857         /* The tx descriptor buffer and the TKIP space. */
3858         wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
3859                 sizeof(struct wl1271_tx_hw_descr);
3860
3861         /* unit us */
3862         /* FIXME: find a proper value */
3863         wl->hw->channel_change_time = 10000;
3864         wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
3865
3866         wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
3867                 IEEE80211_HW_BEACON_FILTER |
3868                 IEEE80211_HW_SUPPORTS_PS |
3869                 IEEE80211_HW_SUPPORTS_UAPSD |
3870                 IEEE80211_HW_HAS_RATE_CONTROL |
3871                 IEEE80211_HW_CONNECTION_MONITOR |
3872                 IEEE80211_HW_SUPPORTS_CQM_RSSI |
3873                 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
3874                 IEEE80211_HW_SPECTRUM_MGMT |
3875                 IEEE80211_HW_AP_LINK_PS;
3876
3877         wl->hw->wiphy->cipher_suites = cipher_suites;
3878         wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
3879
3880         wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
3881                 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
3882         wl->hw->wiphy->max_scan_ssids = 1;
3883         /*
3884          * Maximum length of elements in scanning probe request templates
3885          * should be the maximum length possible for a template, without
3886          * the IEEE80211 header of the template
3887          */
3888         wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
3889                         sizeof(struct ieee80211_header);
3890
3891         /* make sure all our channels fit in the scanned_ch bitmask */
3892         BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
3893                      ARRAY_SIZE(wl1271_channels_5ghz) >
3894                      WL1271_MAX_CHANNELS);
3895         /*
3896          * We keep local copies of the band structs because we need to
3897          * modify them on a per-device basis.
3898          */
3899         memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
3900                sizeof(wl1271_band_2ghz));
3901         memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
3902                sizeof(wl1271_band_5ghz));
3903
3904         wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
3905                 &wl->bands[IEEE80211_BAND_2GHZ];
3906         wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
3907                 &wl->bands[IEEE80211_BAND_5GHZ];
3908
3909         wl->hw->queues = 4;
3910         wl->hw->max_rates = 1;
3911
3912         wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
3913
3914         SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
3915
3916         wl->hw->sta_data_size = sizeof(struct wl1271_station);
3917
3918         wl->hw->max_rx_aggregation_subframes = 8;
3919
3920         return 0;
3921 }
3922 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
3923
3924 #define WL1271_DEFAULT_CHANNEL 0
3925
3926 struct ieee80211_hw *wl1271_alloc_hw(void)
3927 {
3928         struct ieee80211_hw *hw;
3929         struct platform_device *plat_dev = NULL;
3930         struct wl1271 *wl;
3931         int i, j, ret;
3932         unsigned int order;
3933
3934         hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
3935         if (!hw) {
3936                 wl1271_error("could not alloc ieee80211_hw");
3937                 ret = -ENOMEM;
3938                 goto err_hw_alloc;
3939         }
3940
3941         plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
3942         if (!plat_dev) {
3943                 wl1271_error("could not allocate platform_device");
3944                 ret = -ENOMEM;
3945                 goto err_plat_alloc;
3946         }
3947
3948         wl = hw->priv;
3949         memset(wl, 0, sizeof(*wl));
3950
3951         INIT_LIST_HEAD(&wl->list);
3952
3953         wl->hw = hw;
3954         wl->plat_dev = plat_dev;
3955
3956         for (i = 0; i < NUM_TX_QUEUES; i++)
3957                 skb_queue_head_init(&wl->tx_queue[i]);
3958
3959         for (i = 0; i < NUM_TX_QUEUES; i++)
3960                 for (j = 0; j < AP_MAX_LINKS; j++)
3961                         skb_queue_head_init(&wl->links[j].tx_queue[i]);
3962
3963         skb_queue_head_init(&wl->deferred_rx_queue);
3964         skb_queue_head_init(&wl->deferred_tx_queue);
3965
3966         INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
3967         INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
3968         INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
3969         INIT_WORK(&wl->tx_work, wl1271_tx_work);
3970         INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
3971         INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
3972         wl->channel = WL1271_DEFAULT_CHANNEL;
3973         wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
3974         wl->default_key = 0;
3975         wl->rx_counter = 0;
3976         wl->rx_config = WL1271_DEFAULT_STA_RX_CONFIG;
3977         wl->rx_filter = WL1271_DEFAULT_STA_RX_FILTER;
3978         wl->psm_entry_retry = 0;
3979         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
3980         wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
3981         wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
3982         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
3983         wl->band = IEEE80211_BAND_2GHZ;
3984         wl->vif = NULL;
3985         wl->flags = 0;
3986         wl->sg_enabled = true;
3987         wl->hw_pg_ver = -1;
3988         wl->bss_type = MAX_BSS_TYPE;
3989         wl->set_bss_type = MAX_BSS_TYPE;
3990         wl->fw_bss_type = MAX_BSS_TYPE;
3991         wl->last_tx_hlid = 0;
3992         wl->ap_ps_map = 0;
3993         wl->ap_fw_ps_map = 0;
3994         wl->quirks = 0;
3995         wl->platform_quirks = 0;
3996         wl->sched_scanning = false;
3997
3998         memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
3999         for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
4000                 wl->tx_frames[i] = NULL;
4001
4002         spin_lock_init(&wl->wl_lock);
4003
4004         wl->state = WL1271_STATE_OFF;
4005         mutex_init(&wl->mutex);
4006
4007         /* Apply default driver configuration. */
4008         wl1271_conf_init(wl);
4009
4010         order = get_order(WL1271_AGGR_BUFFER_SIZE);
4011         wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
4012         if (!wl->aggr_buf) {
4013                 ret = -ENOMEM;
4014                 goto err_hw;
4015         }
4016
4017         wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
4018         if (!wl->dummy_packet) {
4019                 ret = -ENOMEM;
4020                 goto err_aggr;
4021         }
4022
4023         /* Register platform device */
4024         ret = platform_device_register(wl->plat_dev);
4025         if (ret) {
4026                 wl1271_error("couldn't register platform device");
4027                 goto err_dummy_packet;
4028         }
4029         dev_set_drvdata(&wl->plat_dev->dev, wl);
4030
4031         /* Create sysfs file to control bt coex state */
4032         ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4033         if (ret < 0) {
4034                 wl1271_error("failed to create sysfs file bt_coex_state");
4035                 goto err_platform;
4036         }
4037
4038         /* Create sysfs file to get HW PG version */
4039         ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4040         if (ret < 0) {
4041                 wl1271_error("failed to create sysfs file hw_pg_ver");
4042                 goto err_bt_coex_state;
4043         }
4044
4045         return hw;
4046
4047 err_bt_coex_state:
4048         device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4049
4050 err_platform:
4051         platform_device_unregister(wl->plat_dev);
4052
4053 err_dummy_packet:
4054         dev_kfree_skb(wl->dummy_packet);
4055
4056 err_aggr:
4057         free_pages((unsigned long)wl->aggr_buf, order);
4058
4059 err_hw:
4060         wl1271_debugfs_exit(wl);
4061         kfree(plat_dev);
4062
4063 err_plat_alloc:
4064         ieee80211_free_hw(hw);
4065
4066 err_hw_alloc:
4067
4068         return ERR_PTR(ret);
4069 }
4070 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
4071
4072 int wl1271_free_hw(struct wl1271 *wl)
4073 {
4074         platform_device_unregister(wl->plat_dev);
4075         dev_kfree_skb(wl->dummy_packet);
4076         free_pages((unsigned long)wl->aggr_buf,
4077                         get_order(WL1271_AGGR_BUFFER_SIZE));
4078         kfree(wl->plat_dev);
4079
4080         wl1271_debugfs_exit(wl);
4081
4082         vfree(wl->fw);
4083         wl->fw = NULL;
4084         kfree(wl->nvs);
4085         wl->nvs = NULL;
4086
4087         kfree(wl->fw_status);
4088         kfree(wl->tx_res_if);
4089
4090         ieee80211_free_hw(wl->hw);
4091
4092         return 0;
4093 }
4094 EXPORT_SYMBOL_GPL(wl1271_free_hw);
4095
4096 u32 wl12xx_debug_level = DEBUG_NONE;
4097 EXPORT_SYMBOL_GPL(wl12xx_debug_level);
4098 module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
4099 MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
4100
4101 MODULE_LICENSE("GPL");
4102 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
4103 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");