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