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