drivers/net/wireless/wl12xx/main.c

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