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 u8 wl12xx_get_role_type(struct wl1271 *wl)
1783 {
1784         switch (wl->bss_type) {
1785         case BSS_TYPE_AP_BSS:
1786                 return WL1271_ROLE_AP;
1787
1788         case BSS_TYPE_STA_BSS:
1789                 return WL1271_ROLE_STA;
1790
1791         default:
1792                 wl1271_error("invalid bss_type: %d", wl->bss_type);
1793         }
1794         return WL12XX_INVALID_ROLE_TYPE;
1795 }
1796
1797 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
1798                                    struct ieee80211_vif *vif)
1799 {
1800         struct wl1271 *wl = hw->priv;
1801         struct wiphy *wiphy = hw->wiphy;
1802         int retries = WL1271_BOOT_RETRIES;
1803         int ret = 0;
1804         u8 role_type;
1805         bool booted = false;
1806
1807         wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
1808                      vif->type, vif->addr);
1809
1810         mutex_lock(&wl->mutex);
1811         if (wl->vif) {
1812                 wl1271_debug(DEBUG_MAC80211,
1813                              "multiple vifs are not supported yet");
1814                 ret = -EBUSY;
1815                 goto out;
1816         }
1817
1818         /*
1819          * in some very corner case HW recovery scenarios its possible to
1820          * get here before __wl1271_op_remove_interface is complete, so
1821          * opt out if that is the case.
1822          */
1823         if (test_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags)) {
1824                 ret = -EBUSY;
1825                 goto out;
1826         }
1827
1828         switch (vif->type) {
1829         case NL80211_IFTYPE_STATION:
1830                 wl->bss_type = BSS_TYPE_STA_BSS;
1831                 wl->set_bss_type = BSS_TYPE_STA_BSS;
1832                 break;
1833         case NL80211_IFTYPE_ADHOC:
1834                 wl->bss_type = BSS_TYPE_IBSS;
1835                 wl->set_bss_type = BSS_TYPE_STA_BSS;
1836                 break;
1837         case NL80211_IFTYPE_AP:
1838                 wl->bss_type = BSS_TYPE_AP_BSS;
1839                 break;
1840         default:
1841                 ret = -EOPNOTSUPP;
1842                 goto out;
1843         }
1844
1845         role_type = wl12xx_get_role_type(wl);
1846         if (role_type == WL12XX_INVALID_ROLE_TYPE) {
1847                 ret = -EINVAL;
1848                 goto out;
1849         }
1850         memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
1851
1852         if (wl->state != WL1271_STATE_OFF) {
1853                 wl1271_error("cannot start because not in off state: %d",
1854                              wl->state);
1855                 ret = -EBUSY;
1856                 goto out;
1857         }
1858
1859         while (retries) {
1860                 retries--;
1861                 ret = wl1271_chip_wakeup(wl);
1862                 if (ret < 0)
1863                         goto power_off;
1864
1865                 ret = wl1271_boot(wl);
1866                 if (ret < 0)
1867                         goto power_off;
1868
1869                 if (wl->bss_type == BSS_TYPE_STA_BSS) {
1870                         /*
1871                          * The device role is a special role used for
1872                          * rx and tx frames prior to association (as
1873                          * the STA role can get packets only from
1874                          * its associated bssid)
1875                          */
1876                         ret = wl12xx_cmd_role_enable(wl,
1877                                                          WL1271_ROLE_DEVICE,
1878                                                          &wl->dev_role_id);
1879                         if (ret < 0)
1880                                 goto irq_disable;
1881                 }
1882
1883                 ret = wl12xx_cmd_role_enable(wl, role_type, &wl->role_id);
1884                 if (ret < 0)
1885                         goto irq_disable;
1886
1887                 ret = wl1271_hw_init(wl);
1888                 if (ret < 0)
1889                         goto irq_disable;
1890
1891                 booted = true;
1892                 break;
1893
1894 irq_disable:
1895                 mutex_unlock(&wl->mutex);
1896                 /* Unlocking the mutex in the middle of handling is
1897                    inherently unsafe. In this case we deem it safe to do,
1898                    because we need to let any possibly pending IRQ out of
1899                    the system (and while we are WL1271_STATE_OFF the IRQ
1900                    work function will not do anything.) Also, any other
1901                    possible concurrent operations will fail due to the
1902                    current state, hence the wl1271 struct should be safe. */
1903                 wl1271_disable_interrupts(wl);
1904                 wl1271_flush_deferred_work(wl);
1905                 cancel_work_sync(&wl->netstack_work);
1906                 mutex_lock(&wl->mutex);
1907 power_off:
1908                 wl1271_power_off(wl);
1909         }
1910
1911         if (!booted) {
1912                 wl1271_error("firmware boot failed despite %d retries",
1913                              WL1271_BOOT_RETRIES);
1914                 goto out;
1915         }
1916
1917         wl->vif = vif;
1918         wl->state = WL1271_STATE_ON;
1919         set_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags);
1920         wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
1921
1922         /* update hw/fw version info in wiphy struct */
1923         wiphy->hw_version = wl->chip.id;
1924         strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
1925                 sizeof(wiphy->fw_version));
1926
1927         /*
1928          * Now we know if 11a is supported (info from the NVS), so disable
1929          * 11a channels if not supported
1930          */
1931         if (!wl->enable_11a)
1932                 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
1933
1934         wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
1935                      wl->enable_11a ? "" : "not ");
1936
1937 out:
1938         mutex_unlock(&wl->mutex);
1939
1940         mutex_lock(&wl_list_mutex);
1941         if (!ret)
1942                 list_add(&wl->list, &wl_list);
1943         mutex_unlock(&wl_list_mutex);
1944
1945         return ret;
1946 }
1947
1948 static void __wl1271_op_remove_interface(struct wl1271 *wl,
1949                                          bool reset_tx_queues)
1950 {
1951         int ret;
1952
1953         wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1954
1955         /* because of hardware recovery, we may get here twice */
1956         if (wl->state != WL1271_STATE_ON)
1957                 return;
1958
1959         wl1271_info("down");
1960
1961         mutex_lock(&wl_list_mutex);
1962         list_del(&wl->list);
1963         mutex_unlock(&wl_list_mutex);
1964
1965         /* enable dyn ps just in case (if left on due to fw crash etc) */
1966         if (wl->bss_type == BSS_TYPE_STA_BSS)
1967                 ieee80211_enable_dyn_ps(wl->vif);
1968
1969         if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
1970                 wl->scan.state = WL1271_SCAN_STATE_IDLE;
1971                 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
1972                 wl->scan.req = NULL;
1973                 ieee80211_scan_completed(wl->hw, true);
1974         }
1975
1976         if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags)) {
1977                 /* disable active roles */
1978                 ret = wl1271_ps_elp_wakeup(wl);
1979                 if (ret < 0)
1980                         goto deinit;
1981
1982                 if (wl->bss_type == BSS_TYPE_STA_BSS) {
1983                         ret = wl12xx_cmd_role_disable(wl, &wl->dev_role_id);
1984                         if (ret < 0)
1985                                 goto deinit;
1986                 }
1987
1988                 ret = wl12xx_cmd_role_disable(wl, &wl->role_id);
1989                 if (ret < 0)
1990                         goto deinit;
1991
1992                 wl1271_ps_elp_sleep(wl);
1993         }
1994 deinit:
1995         wl->sta_hlid = WL12XX_INVALID_LINK_ID;
1996         wl->dev_hlid = WL12XX_INVALID_LINK_ID;
1997
1998         /*
1999          * this must be before the cancel_work calls below, so that the work
2000          * functions don't perform further work.
2001          */
2002         wl->state = WL1271_STATE_OFF;
2003
2004         mutex_unlock(&wl->mutex);
2005
2006         wl1271_disable_interrupts(wl);
2007         wl1271_flush_deferred_work(wl);
2008         cancel_delayed_work_sync(&wl->scan_complete_work);
2009         cancel_work_sync(&wl->netstack_work);
2010         cancel_work_sync(&wl->tx_work);
2011         del_timer_sync(&wl->rx_streaming_timer);
2012         cancel_work_sync(&wl->rx_streaming_enable_work);
2013         cancel_work_sync(&wl->rx_streaming_disable_work);
2014         cancel_delayed_work_sync(&wl->pspoll_work);
2015         cancel_delayed_work_sync(&wl->elp_work);
2016
2017         mutex_lock(&wl->mutex);
2018
2019         /* let's notify MAC80211 about the remaining pending TX frames */
2020         wl1271_tx_reset(wl, reset_tx_queues);
2021         wl1271_power_off(wl);
2022
2023         memset(wl->bssid, 0, ETH_ALEN);
2024         memset(wl->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
2025         wl->ssid_len = 0;
2026         wl->bss_type = MAX_BSS_TYPE;
2027         wl->set_bss_type = MAX_BSS_TYPE;
2028         wl->band = IEEE80211_BAND_2GHZ;
2029
2030         wl->rx_counter = 0;
2031         wl->psm_entry_retry = 0;
2032         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2033         wl->tx_blocks_available = 0;
2034         wl->tx_allocated_blocks = 0;
2035         wl->tx_results_count = 0;
2036         wl->tx_packets_count = 0;
2037         wl->time_offset = 0;
2038         wl->session_counter = 0;
2039         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2040         wl->vif = NULL;
2041         wl1271_free_ap_keys(wl);
2042         memset(wl->ap_hlid_map, 0, sizeof(wl->ap_hlid_map));
2043         wl->ap_fw_ps_map = 0;
2044         wl->ap_ps_map = 0;
2045         wl->sched_scanning = false;
2046         wl->role_id = WL12XX_INVALID_ROLE_ID;
2047         wl->dev_role_id = WL12XX_INVALID_ROLE_ID;
2048         memset(wl->roles_map, 0, sizeof(wl->roles_map));
2049         memset(wl->links_map, 0, sizeof(wl->links_map));
2050
2051         /*
2052          * this is performed after the cancel_work calls and the associated
2053          * mutex_lock, so that wl1271_op_add_interface does not accidentally
2054          * get executed before all these vars have been reset.
2055          */
2056         wl->flags = 0;
2057
2058         wl->tx_blocks_freed = 0;
2059
2060         wl1271_debugfs_reset(wl);
2061
2062         kfree(wl->fw_status);
2063         wl->fw_status = NULL;
2064         kfree(wl->tx_res_if);
2065         wl->tx_res_if = NULL;
2066         kfree(wl->target_mem_map);
2067         wl->target_mem_map = NULL;
2068 }
2069
2070 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
2071                                        struct ieee80211_vif *vif)
2072 {
2073         struct wl1271 *wl = hw->priv;
2074
2075         mutex_lock(&wl->mutex);
2076         /*
2077          * wl->vif can be null here if someone shuts down the interface
2078          * just when hardware recovery has been started.
2079          */
2080         if (wl->vif) {
2081                 WARN_ON(wl->vif != vif);
2082                 __wl1271_op_remove_interface(wl, true);
2083         }
2084
2085         mutex_unlock(&wl->mutex);
2086         cancel_work_sync(&wl->recovery_work);
2087 }
2088
2089 static int wl1271_dummy_join(struct wl1271 *wl)
2090 {
2091         int ret = 0;
2092         /* we need to use a dummy BSSID for now */
2093         static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
2094                                                   0xad, 0xbe, 0xef };
2095
2096         memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
2097
2098         ret = wl12xx_cmd_role_start_sta(wl);
2099         if (ret < 0)
2100                 goto out;
2101
2102         set_bit(WL1271_FLAG_JOINED, &wl->flags);
2103
2104 out:
2105         return ret;
2106 }
2107
2108 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
2109 {
2110         int ret;
2111
2112         /*
2113          * One of the side effects of the JOIN command is that is clears
2114          * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
2115          * to a WPA/WPA2 access point will therefore kill the data-path.
2116          * Currently the only valid scenario for JOIN during association
2117          * is on roaming, in which case we will also be given new keys.
2118          * Keep the below message for now, unless it starts bothering
2119          * users who really like to roam a lot :)
2120          */
2121         if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2122                 wl1271_info("JOIN while associated.");
2123
2124         if (set_assoc)
2125                 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
2126
2127         ret = wl12xx_cmd_role_start_sta(wl);
2128         if (ret < 0)
2129                 goto out;
2130
2131         set_bit(WL1271_FLAG_JOINED, &wl->flags);
2132
2133         if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2134                 goto out;
2135
2136         /*
2137          * The join command disable the keep-alive mode, shut down its process,
2138          * and also clear the template config, so we need to reset it all after
2139          * the join. The acx_aid starts the keep-alive process, and the order
2140          * of the commands below is relevant.
2141          */
2142         ret = wl1271_acx_keep_alive_mode(wl, true);
2143         if (ret < 0)
2144                 goto out;
2145
2146         ret = wl1271_acx_aid(wl, wl->aid);
2147         if (ret < 0)
2148                 goto out;
2149
2150         ret = wl1271_cmd_build_klv_null_data(wl);
2151         if (ret < 0)
2152                 goto out;
2153
2154         ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
2155                                            ACX_KEEP_ALIVE_TPL_VALID);
2156         if (ret < 0)
2157                 goto out;
2158
2159 out:
2160         return ret;
2161 }
2162
2163 static int wl1271_unjoin(struct wl1271 *wl)
2164 {
2165         int ret;
2166
2167         /* to stop listening to a channel, we disconnect */
2168         ret = wl12xx_cmd_role_stop_sta(wl);
2169         if (ret < 0)
2170                 goto out;
2171
2172         clear_bit(WL1271_FLAG_JOINED, &wl->flags);
2173         memset(wl->bssid, 0, ETH_ALEN);
2174
2175         /* reset TX security counters on a clean disconnect */
2176         wl->tx_security_last_seq_lsb = 0;
2177         wl->tx_security_seq = 0;
2178
2179 out:
2180         return ret;
2181 }
2182
2183 static void wl1271_set_band_rate(struct wl1271 *wl)
2184 {
2185         if (wl->band == IEEE80211_BAND_2GHZ)
2186                 wl->basic_rate_set = wl->conf.tx.basic_rate;
2187         else
2188                 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
2189 }
2190
2191 static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle)
2192 {
2193         int ret;
2194
2195         if (idle) {
2196                 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
2197                         ret = wl1271_unjoin(wl);
2198                         if (ret < 0)
2199                                 goto out;
2200                 }
2201                 wl->rate_set = wl1271_tx_min_rate_get(wl);
2202                 ret = wl1271_acx_sta_rate_policies(wl);
2203                 if (ret < 0)
2204                         goto out;
2205                 ret = wl1271_acx_keep_alive_config(
2206                         wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
2207                         ACX_KEEP_ALIVE_TPL_INVALID);
2208                 if (ret < 0)
2209                         goto out;
2210                 set_bit(WL1271_FLAG_IDLE, &wl->flags);
2211         } else {
2212                 /* increment the session counter */
2213                 wl->session_counter++;
2214                 if (wl->session_counter >= SESSION_COUNTER_MAX)
2215                         wl->session_counter = 0;
2216
2217                 /* The current firmware only supports sched_scan in idle */
2218                 if (wl->sched_scanning) {
2219                         wl1271_scan_sched_scan_stop(wl);
2220                         ieee80211_sched_scan_stopped(wl->hw);
2221                 }
2222
2223                 ret = wl1271_dummy_join(wl);
2224                 if (ret < 0)
2225                         goto out;
2226                 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
2227         }
2228
2229 out:
2230         return ret;
2231 }
2232
2233 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
2234 {
2235         struct wl1271 *wl = hw->priv;
2236         struct ieee80211_conf *conf = &hw->conf;
2237         int channel, ret = 0;
2238         bool is_ap;
2239
2240         channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
2241
2242         wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
2243                      " changed 0x%x",
2244                      channel,
2245                      conf->flags & IEEE80211_CONF_PS ? "on" : "off",
2246                      conf->power_level,
2247                      conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
2248                          changed);
2249
2250         /*
2251          * mac80211 will go to idle nearly immediately after transmitting some
2252          * frames, such as the deauth. To make sure those frames reach the air,
2253          * wait here until the TX queue is fully flushed.
2254          */
2255         if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
2256             (conf->flags & IEEE80211_CONF_IDLE))
2257                 wl1271_tx_flush(wl);
2258
2259         mutex_lock(&wl->mutex);
2260
2261         if (unlikely(wl->state == WL1271_STATE_OFF)) {
2262                 /* we support configuring the channel and band while off */
2263                 if ((changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
2264                         wl->band = conf->channel->band;
2265                         wl->channel = channel;
2266                 }
2267
2268                 if ((changed & IEEE80211_CONF_CHANGE_POWER))
2269                         wl->power_level = conf->power_level;
2270
2271                 goto out;
2272         }
2273
2274         is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2275
2276         ret = wl1271_ps_elp_wakeup(wl);
2277         if (ret < 0)
2278                 goto out;
2279
2280         /* if the channel changes while joined, join again */
2281         if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
2282             ((wl->band != conf->channel->band) ||
2283              (wl->channel != channel))) {
2284                 wl->band = conf->channel->band;
2285                 wl->channel = channel;
2286
2287                 if (!is_ap) {
2288                         /*
2289                          * FIXME: the mac80211 should really provide a fixed
2290                          * rate to use here. for now, just use the smallest
2291                          * possible rate for the band as a fixed rate for
2292                          * association frames and other control messages.
2293                          */
2294                         if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2295                                 wl1271_set_band_rate(wl);
2296
2297                         wl->basic_rate = wl1271_tx_min_rate_get(wl);
2298                         ret = wl1271_acx_sta_rate_policies(wl);
2299                         if (ret < 0)
2300                                 wl1271_warning("rate policy for channel "
2301                                                "failed %d", ret);
2302
2303                         if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
2304                                 ret = wl1271_join(wl, false);
2305                                 if (ret < 0)
2306                                         wl1271_warning("cmd join on channel "
2307                                                        "failed %d", ret);
2308                         }
2309                 }
2310         }
2311
2312         if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
2313                 ret = wl1271_sta_handle_idle(wl,
2314                                         conf->flags & IEEE80211_CONF_IDLE);
2315                 if (ret < 0)
2316                         wl1271_warning("idle mode change failed %d", ret);
2317         }
2318
2319         /*
2320          * if mac80211 changes the PSM mode, make sure the mode is not
2321          * incorrectly changed after the pspoll failure active window.
2322          */
2323         if (changed & IEEE80211_CONF_CHANGE_PS)
2324                 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
2325
2326         if (conf->flags & IEEE80211_CONF_PS &&
2327             !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
2328                 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
2329
2330                 /*
2331                  * We enter PSM only if we're already associated.
2332                  * If we're not, we'll enter it when joining an SSID,
2333                  * through the bss_info_changed() hook.
2334                  */
2335                 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
2336                         wl1271_debug(DEBUG_PSM, "psm enabled");
2337                         ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
2338                                                  wl->basic_rate, true);
2339                 }
2340         } else if (!(conf->flags & IEEE80211_CONF_PS) &&
2341                    test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
2342                 wl1271_debug(DEBUG_PSM, "psm disabled");
2343
2344                 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
2345
2346                 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
2347                         ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
2348                                                  wl->basic_rate, true);
2349         }
2350
2351         if (conf->power_level != wl->power_level) {
2352                 ret = wl1271_acx_tx_power(wl, conf->power_level);
2353                 if (ret < 0)
2354                         goto out_sleep;
2355
2356                 wl->power_level = conf->power_level;
2357         }
2358
2359 out_sleep:
2360         wl1271_ps_elp_sleep(wl);
2361
2362 out:
2363         mutex_unlock(&wl->mutex);
2364
2365         return ret;
2366 }
2367
2368 struct wl1271_filter_params {
2369         bool enabled;
2370         int mc_list_length;
2371         u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
2372 };
2373
2374 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
2375                                        struct netdev_hw_addr_list *mc_list)
2376 {
2377         struct wl1271_filter_params *fp;
2378         struct netdev_hw_addr *ha;
2379         struct wl1271 *wl = hw->priv;
2380
2381         if (unlikely(wl->state == WL1271_STATE_OFF))
2382                 return 0;
2383
2384         fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
2385         if (!fp) {
2386                 wl1271_error("Out of memory setting filters.");
2387                 return 0;
2388         }
2389
2390         /* update multicast filtering parameters */
2391         fp->mc_list_length = 0;
2392         if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
2393                 fp->enabled = false;
2394         } else {
2395                 fp->enabled = true;
2396                 netdev_hw_addr_list_for_each(ha, mc_list) {
2397                         memcpy(fp->mc_list[fp->mc_list_length],
2398                                         ha->addr, ETH_ALEN);
2399                         fp->mc_list_length++;
2400                 }
2401         }
2402
2403         return (u64)(unsigned long)fp;
2404 }
2405
2406 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
2407                                   FIF_ALLMULTI | \
2408                                   FIF_FCSFAIL | \
2409                                   FIF_BCN_PRBRESP_PROMISC | \
2410                                   FIF_CONTROL | \
2411                                   FIF_OTHER_BSS)
2412
2413 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
2414                                        unsigned int changed,
2415                                        unsigned int *total, u64 multicast)
2416 {
2417         struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
2418         struct wl1271 *wl = hw->priv;
2419         int ret;
2420
2421         wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
2422                      " total %x", changed, *total);
2423
2424         mutex_lock(&wl->mutex);
2425
2426         *total &= WL1271_SUPPORTED_FILTERS;
2427         changed &= WL1271_SUPPORTED_FILTERS;
2428
2429         if (unlikely(wl->state == WL1271_STATE_OFF))
2430                 goto out;
2431
2432         ret = wl1271_ps_elp_wakeup(wl);
2433         if (ret < 0)
2434                 goto out;
2435
2436         if (wl->bss_type != BSS_TYPE_AP_BSS) {
2437                 if (*total & FIF_ALLMULTI)
2438                         ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
2439                 else if (fp)
2440                         ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
2441                                                            fp->mc_list,
2442                                                            fp->mc_list_length);
2443                 if (ret < 0)
2444                         goto out_sleep;
2445         }
2446
2447         /*
2448          * the fw doesn't provide an api to configure the filters. instead,
2449          * the filters configuration is based on the active roles / ROC
2450          * state.
2451          */
2452
2453 out_sleep:
2454         wl1271_ps_elp_sleep(wl);
2455
2456 out:
2457         mutex_unlock(&wl->mutex);
2458         kfree(fp);
2459 }
2460
2461 static int wl1271_record_ap_key(struct wl1271 *wl, u8 id, u8 key_type,
2462                         u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
2463                         u16 tx_seq_16)
2464 {
2465         struct wl1271_ap_key *ap_key;
2466         int i;
2467
2468         wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
2469
2470         if (key_size > MAX_KEY_SIZE)
2471                 return -EINVAL;
2472
2473         /*
2474          * Find next free entry in ap_keys. Also check we are not replacing
2475          * an existing key.
2476          */
2477         for (i = 0; i < MAX_NUM_KEYS; i++) {
2478                 if (wl->recorded_ap_keys[i] == NULL)
2479                         break;
2480
2481                 if (wl->recorded_ap_keys[i]->id == id) {
2482                         wl1271_warning("trying to record key replacement");
2483                         return -EINVAL;
2484                 }
2485         }
2486
2487         if (i == MAX_NUM_KEYS)
2488                 return -EBUSY;
2489
2490         ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
2491         if (!ap_key)
2492                 return -ENOMEM;
2493
2494         ap_key->id = id;
2495         ap_key->key_type = key_type;
2496         ap_key->key_size = key_size;
2497         memcpy(ap_key->key, key, key_size);
2498         ap_key->hlid = hlid;
2499         ap_key->tx_seq_32 = tx_seq_32;
2500         ap_key->tx_seq_16 = tx_seq_16;
2501
2502         wl->recorded_ap_keys[i] = ap_key;
2503         return 0;
2504 }
2505
2506 static void wl1271_free_ap_keys(struct wl1271 *wl)
2507 {
2508         int i;
2509
2510         for (i = 0; i < MAX_NUM_KEYS; i++) {
2511                 kfree(wl->recorded_ap_keys[i]);
2512                 wl->recorded_ap_keys[i] = NULL;
2513         }
2514 }
2515
2516 static int wl1271_ap_init_hwenc(struct wl1271 *wl)
2517 {
2518         int i, ret = 0;
2519         struct wl1271_ap_key *key;
2520         bool wep_key_added = false;
2521
2522         for (i = 0; i < MAX_NUM_KEYS; i++) {
2523                 if (wl->recorded_ap_keys[i] == NULL)
2524                         break;
2525
2526                 key = wl->recorded_ap_keys[i];
2527                 ret = wl1271_cmd_set_ap_key(wl, KEY_ADD_OR_REPLACE,
2528                                             key->id, key->key_type,
2529                                             key->key_size, key->key,
2530                                             key->hlid, key->tx_seq_32,
2531                                             key->tx_seq_16);
2532                 if (ret < 0)
2533                         goto out;
2534
2535                 if (key->key_type == KEY_WEP)
2536                         wep_key_added = true;
2537         }
2538
2539         if (wep_key_added) {
2540                 ret = wl12xx_cmd_set_default_wep_key(wl, wl->default_key,
2541                                                      WL1271_AP_BROADCAST_HLID);
2542                 if (ret < 0)
2543                         goto out;
2544         }
2545
2546 out:
2547         wl1271_free_ap_keys(wl);
2548         return ret;
2549 }
2550
2551 static int wl1271_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
2552                        u8 key_size, const u8 *key, u32 tx_seq_32,
2553                        u16 tx_seq_16, struct ieee80211_sta *sta)
2554 {
2555         int ret;
2556         bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2557
2558         if (is_ap) {
2559                 struct wl1271_station *wl_sta;
2560                 u8 hlid;
2561
2562                 if (sta) {
2563                         wl_sta = (struct wl1271_station *)sta->drv_priv;
2564                         hlid = wl_sta->hlid;
2565                 } else {
2566                         hlid = WL1271_AP_BROADCAST_HLID;
2567                 }
2568
2569                 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2570                         /*
2571                          * We do not support removing keys after AP shutdown.
2572                          * Pretend we do to make mac80211 happy.
2573                          */
2574                         if (action != KEY_ADD_OR_REPLACE)
2575                                 return 0;
2576
2577                         ret = wl1271_record_ap_key(wl, id,
2578                                              key_type, key_size,
2579                                              key, hlid, tx_seq_32,
2580                                              tx_seq_16);
2581                 } else {
2582                         ret = wl1271_cmd_set_ap_key(wl, action,
2583                                              id, key_type, key_size,
2584                                              key, hlid, tx_seq_32,
2585                                              tx_seq_16);
2586                 }
2587
2588                 if (ret < 0)
2589                         return ret;
2590         } else {
2591                 const u8 *addr;
2592                 static const u8 bcast_addr[ETH_ALEN] = {
2593                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2594                 };
2595
2596                 addr = sta ? sta->addr : bcast_addr;
2597
2598                 if (is_zero_ether_addr(addr)) {
2599                         /* We dont support TX only encryption */
2600                         return -EOPNOTSUPP;
2601                 }
2602
2603                 /* The wl1271 does not allow to remove unicast keys - they
2604                    will be cleared automatically on next CMD_JOIN. Ignore the
2605                    request silently, as we dont want the mac80211 to emit
2606                    an error message. */
2607                 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
2608                         return 0;
2609
2610                 ret = wl1271_cmd_set_sta_key(wl, action,
2611                                              id, key_type, key_size,
2612                                              key, addr, tx_seq_32,
2613                                              tx_seq_16);
2614                 if (ret < 0)
2615                         return ret;
2616
2617                 /* the default WEP key needs to be configured at least once */
2618                 if (key_type == KEY_WEP) {
2619                         ret = wl12xx_cmd_set_default_wep_key(wl,
2620                                                              wl->default_key,
2621                                                              wl->sta_hlid);
2622                         if (ret < 0)
2623                                 return ret;
2624                 }
2625         }
2626
2627         return 0;
2628 }
2629
2630 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2631                              struct ieee80211_vif *vif,
2632                              struct ieee80211_sta *sta,
2633                              struct ieee80211_key_conf *key_conf)
2634 {
2635         struct wl1271 *wl = hw->priv;
2636         int ret;
2637         u32 tx_seq_32 = 0;
2638         u16 tx_seq_16 = 0;
2639         u8 key_type;
2640
2641         wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
2642
2643         wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
2644         wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
2645                      key_conf->cipher, key_conf->keyidx,
2646                      key_conf->keylen, key_conf->flags);
2647         wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
2648
2649         mutex_lock(&wl->mutex);
2650
2651         if (unlikely(wl->state == WL1271_STATE_OFF)) {
2652                 ret = -EAGAIN;
2653                 goto out_unlock;
2654         }
2655
2656         ret = wl1271_ps_elp_wakeup(wl);
2657         if (ret < 0)
2658                 goto out_unlock;
2659
2660         switch (key_conf->cipher) {
2661         case WLAN_CIPHER_SUITE_WEP40:
2662         case WLAN_CIPHER_SUITE_WEP104:
2663                 key_type = KEY_WEP;
2664
2665                 key_conf->hw_key_idx = key_conf->keyidx;
2666                 break;
2667         case WLAN_CIPHER_SUITE_TKIP:
2668                 key_type = KEY_TKIP;
2669
2670                 key_conf->hw_key_idx = key_conf->keyidx;
2671                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2672                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2673                 break;
2674         case WLAN_CIPHER_SUITE_CCMP:
2675                 key_type = KEY_AES;
2676
2677                 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
2678                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2679                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2680                 break;
2681         case WL1271_CIPHER_SUITE_GEM:
2682                 key_type = KEY_GEM;
2683                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2684                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2685                 break;
2686         default:
2687                 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
2688
2689                 ret = -EOPNOTSUPP;
2690                 goto out_sleep;
2691         }
2692
2693         switch (cmd) {
2694         case SET_KEY:
2695                 ret = wl1271_set_key(wl, KEY_ADD_OR_REPLACE,
2696                                  key_conf->keyidx, key_type,
2697                                  key_conf->keylen, key_conf->key,
2698                                  tx_seq_32, tx_seq_16, sta);
2699                 if (ret < 0) {
2700                         wl1271_error("Could not add or replace key");
2701                         goto out_sleep;
2702                 }
2703                 break;
2704
2705         case DISABLE_KEY:
2706                 ret = wl1271_set_key(wl, KEY_REMOVE,
2707                                      key_conf->keyidx, key_type,
2708                                      key_conf->keylen, key_conf->key,
2709                                      0, 0, sta);
2710                 if (ret < 0) {
2711                         wl1271_error("Could not remove key");
2712                         goto out_sleep;
2713                 }
2714                 break;
2715
2716         default:
2717                 wl1271_error("Unsupported key cmd 0x%x", cmd);
2718                 ret = -EOPNOTSUPP;
2719                 break;
2720         }
2721
2722 out_sleep:
2723         wl1271_ps_elp_sleep(wl);
2724
2725 out_unlock:
2726         mutex_unlock(&wl->mutex);
2727
2728         return ret;
2729 }
2730
2731 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
2732                              struct ieee80211_vif *vif,
2733                              struct cfg80211_scan_request *req)
2734 {
2735         struct wl1271 *wl = hw->priv;
2736         int ret;
2737         u8 *ssid = NULL;
2738         size_t len = 0;
2739
2740         wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
2741
2742         if (req->n_ssids) {
2743                 ssid = req->ssids[0].ssid;
2744                 len = req->ssids[0].ssid_len;
2745         }
2746
2747         mutex_lock(&wl->mutex);
2748
2749         if (wl->state == WL1271_STATE_OFF) {
2750                 /*
2751                  * We cannot return -EBUSY here because cfg80211 will expect
2752                  * a call to ieee80211_scan_completed if we do - in this case
2753                  * there won't be any call.
2754                  */
2755                 ret = -EAGAIN;
2756                 goto out;
2757         }
2758
2759         ret = wl1271_ps_elp_wakeup(wl);
2760         if (ret < 0)
2761                 goto out;
2762
2763         ret = wl1271_scan(hw->priv, ssid, len, req);
2764
2765         wl1271_ps_elp_sleep(wl);
2766
2767 out:
2768         mutex_unlock(&wl->mutex);
2769
2770         return ret;
2771 }
2772
2773 static void wl1271_op_cancel_hw_scan(struct ieee80211_hw *hw,
2774                                      struct ieee80211_vif *vif)
2775 {
2776         struct wl1271 *wl = hw->priv;
2777         int ret;
2778
2779         wl1271_debug(DEBUG_MAC80211, "mac80211 cancel hw scan");
2780
2781         mutex_lock(&wl->mutex);
2782
2783         if (wl->state == WL1271_STATE_OFF)
2784                 goto out;
2785
2786         if (wl->scan.state == WL1271_SCAN_STATE_IDLE)
2787                 goto out;
2788
2789         ret = wl1271_ps_elp_wakeup(wl);
2790         if (ret < 0)
2791                 goto out;
2792
2793         if (wl->scan.state != WL1271_SCAN_STATE_DONE) {
2794                 ret = wl1271_scan_stop(wl);
2795                 if (ret < 0)
2796                         goto out_sleep;
2797         }
2798         wl->scan.state = WL1271_SCAN_STATE_IDLE;
2799         memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
2800         wl->scan.req = NULL;
2801         ieee80211_scan_completed(wl->hw, true);
2802
2803 out_sleep:
2804         wl1271_ps_elp_sleep(wl);
2805 out:
2806         mutex_unlock(&wl->mutex);
2807
2808         cancel_delayed_work_sync(&wl->scan_complete_work);
2809 }
2810
2811 static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
2812                                       struct ieee80211_vif *vif,
2813                                       struct cfg80211_sched_scan_request *req,
2814                                       struct ieee80211_sched_scan_ies *ies)
2815 {
2816         struct wl1271 *wl = hw->priv;
2817         int ret;
2818
2819         wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");
2820
2821         mutex_lock(&wl->mutex);
2822
2823         ret = wl1271_ps_elp_wakeup(wl);
2824         if (ret < 0)
2825                 goto out;
2826
2827         ret = wl1271_scan_sched_scan_config(wl, req, ies);
2828         if (ret < 0)
2829                 goto out_sleep;
2830
2831         ret = wl1271_scan_sched_scan_start(wl);
2832         if (ret < 0)
2833                 goto out_sleep;
2834
2835         wl->sched_scanning = true;
2836
2837 out_sleep:
2838         wl1271_ps_elp_sleep(wl);
2839 out:
2840         mutex_unlock(&wl->mutex);
2841         return ret;
2842 }
2843
2844 static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
2845                                       struct ieee80211_vif *vif)
2846 {
2847         struct wl1271 *wl = hw->priv;
2848         int ret;
2849
2850         wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");
2851
2852         mutex_lock(&wl->mutex);
2853
2854         ret = wl1271_ps_elp_wakeup(wl);
2855         if (ret < 0)
2856                 goto out;
2857
2858         wl1271_scan_sched_scan_stop(wl);
2859
2860         wl1271_ps_elp_sleep(wl);
2861 out:
2862         mutex_unlock(&wl->mutex);
2863 }
2864
2865 static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
2866 {
2867         struct wl1271 *wl = hw->priv;
2868         int ret = 0;
2869
2870         mutex_lock(&wl->mutex);
2871
2872         if (unlikely(wl->state == WL1271_STATE_OFF)) {
2873                 ret = -EAGAIN;
2874                 goto out;
2875         }
2876
2877         ret = wl1271_ps_elp_wakeup(wl);
2878         if (ret < 0)
2879                 goto out;
2880
2881         ret = wl1271_acx_frag_threshold(wl, value);
2882         if (ret < 0)
2883                 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
2884
2885         wl1271_ps_elp_sleep(wl);
2886
2887 out:
2888         mutex_unlock(&wl->mutex);
2889
2890         return ret;
2891 }
2892
2893 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
2894 {
2895         struct wl1271 *wl = hw->priv;
2896         int ret = 0;
2897
2898         mutex_lock(&wl->mutex);
2899
2900         if (unlikely(wl->state == WL1271_STATE_OFF)) {
2901                 ret = -EAGAIN;
2902                 goto out;
2903         }
2904
2905         ret = wl1271_ps_elp_wakeup(wl);
2906         if (ret < 0)
2907                 goto out;
2908
2909         ret = wl1271_acx_rts_threshold(wl, value);
2910         if (ret < 0)
2911                 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
2912
2913         wl1271_ps_elp_sleep(wl);
2914
2915 out:
2916         mutex_unlock(&wl->mutex);
2917
2918         return ret;
2919 }
2920
2921 static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
2922                             int offset)
2923 {
2924         u8 ssid_len;
2925         const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
2926                                          skb->len - offset);
2927
2928         if (!ptr) {
2929                 wl1271_error("No SSID in IEs!");
2930                 return -ENOENT;
2931         }
2932
2933         ssid_len = ptr[1];
2934         if (ssid_len > IEEE80211_MAX_SSID_LEN) {
2935                 wl1271_error("SSID is too long!");
2936                 return -EINVAL;
2937         }
2938
2939         wl->ssid_len = ssid_len;
2940         memcpy(wl->ssid, ptr+2, ssid_len);
2941         return 0;
2942 }
2943
2944 static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
2945                                        struct ieee80211_bss_conf *bss_conf,
2946                                        u32 changed)
2947 {
2948         int ret = 0;
2949
2950         if (changed & BSS_CHANGED_ERP_SLOT) {
2951                 if (bss_conf->use_short_slot)
2952                         ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
2953                 else
2954                         ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
2955                 if (ret < 0) {
2956                         wl1271_warning("Set slot time failed %d", ret);
2957                         goto out;
2958                 }
2959         }
2960
2961         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2962                 if (bss_conf->use_short_preamble)
2963                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
2964                 else
2965                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
2966         }
2967
2968         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2969                 if (bss_conf->use_cts_prot)
2970                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
2971                 else
2972                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
2973                 if (ret < 0) {
2974                         wl1271_warning("Set ctsprotect failed %d", ret);
2975                         goto out;
2976                 }
2977         }
2978
2979 out:
2980         return ret;
2981 }
2982
2983 static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
2984                                           struct ieee80211_vif *vif,
2985                                           struct ieee80211_bss_conf *bss_conf,
2986                                           u32 changed)
2987 {
2988         bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2989         int ret = 0;
2990
2991         if ((changed & BSS_CHANGED_BEACON_INT)) {
2992                 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
2993                         bss_conf->beacon_int);
2994
2995                 wl->beacon_int = bss_conf->beacon_int;
2996         }
2997
2998         if ((changed & BSS_CHANGED_BEACON)) {
2999                 struct ieee80211_hdr *hdr;
3000                 int ieoffset = offsetof(struct ieee80211_mgmt,
3001                                         u.beacon.variable);
3002                 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
3003                 u16 tmpl_id;
3004
3005                 if (!beacon)
3006                         goto out;
3007
3008                 wl1271_debug(DEBUG_MASTER, "beacon updated");
3009
3010                 ret = wl1271_ssid_set(wl, beacon, ieoffset);
3011                 if (ret < 0) {
3012                         dev_kfree_skb(beacon);
3013                         goto out;
3014                 }
3015                 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
3016                                   CMD_TEMPL_BEACON;
3017                 ret = wl1271_cmd_template_set(wl, tmpl_id,
3018                                               beacon->data,
3019                                               beacon->len, 0,
3020                                               wl1271_tx_min_rate_get(wl));
3021                 if (ret < 0) {
3022                         dev_kfree_skb(beacon);
3023                         goto out;
3024                 }
3025
3026                 hdr = (struct ieee80211_hdr *) beacon->data;
3027                 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
3028                                                  IEEE80211_STYPE_PROBE_RESP);
3029
3030                 tmpl_id = is_ap ? CMD_TEMPL_AP_PROBE_RESPONSE :
3031                                   CMD_TEMPL_PROBE_RESPONSE;
3032                 ret = wl1271_cmd_template_set(wl,
3033                                               tmpl_id,
3034                                               beacon->data,
3035                                               beacon->len, 0,
3036                                               wl1271_tx_min_rate_get(wl));
3037                 dev_kfree_skb(beacon);
3038                 if (ret < 0)
3039                         goto out;
3040         }
3041
3042 out:
3043         return ret;
3044 }
3045
3046 /* AP mode changes */
3047 static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
3048                                        struct ieee80211_vif *vif,
3049                                        struct ieee80211_bss_conf *bss_conf,
3050                                        u32 changed)
3051 {
3052         int ret = 0;
3053
3054         if ((changed & BSS_CHANGED_BASIC_RATES)) {
3055                 u32 rates = bss_conf->basic_rates;
3056
3057                 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates);
3058                 wl->basic_rate = wl1271_tx_min_rate_get(wl);
3059
3060                 ret = wl1271_init_ap_rates(wl);
3061                 if (ret < 0) {
3062                         wl1271_error("AP rate policy change failed %d", ret);
3063                         goto out;
3064                 }
3065
3066                 ret = wl1271_ap_init_templates(wl);
3067                 if (ret < 0)
3068                         goto out;
3069         }
3070
3071         ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
3072         if (ret < 0)
3073                 goto out;
3074
3075         if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
3076                 if (bss_conf->enable_beacon) {
3077                         if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
3078                                 ret = wl12xx_cmd_role_start_ap(wl);
3079                                 if (ret < 0)
3080                                         goto out;
3081
3082                                 set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
3083                                 wl1271_debug(DEBUG_AP, "started AP");
3084
3085                                 ret = wl1271_ap_init_hwenc(wl);
3086                                 if (ret < 0)
3087                                         goto out;
3088                         }
3089                 } else {
3090                         if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
3091                                 ret = wl12xx_cmd_role_stop_ap(wl);
3092                                 if (ret < 0)
3093                                         goto out;
3094
3095                                 clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
3096                                 wl1271_debug(DEBUG_AP, "stopped AP");
3097                         }
3098                 }
3099         }
3100
3101         ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
3102         if (ret < 0)
3103                 goto out;
3104 out:
3105         return;
3106 }
3107
3108 /* STA/IBSS mode changes */
3109 static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
3110                                         struct ieee80211_vif *vif,
3111                                         struct ieee80211_bss_conf *bss_conf,
3112                                         u32 changed)
3113 {
3114         bool do_join = false, set_assoc = false;
3115         bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
3116         u32 sta_rate_set = 0;
3117         int ret;
3118         struct ieee80211_sta *sta;
3119         bool sta_exists = false;
3120         struct ieee80211_sta_ht_cap sta_ht_cap;
3121
3122         if (is_ibss) {
3123                 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
3124                                                      changed);
3125                 if (ret < 0)
3126                         goto out;
3127         }
3128
3129         if ((changed & BSS_CHANGED_BEACON_INT)  && is_ibss)
3130                 do_join = true;
3131
3132         /* Need to update the SSID (for filtering etc) */
3133         if ((changed & BSS_CHANGED_BEACON) && is_ibss)
3134                 do_join = true;
3135
3136         if ((changed & BSS_CHANGED_BEACON_ENABLED) && is_ibss) {
3137                 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
3138                              bss_conf->enable_beacon ? "enabled" : "disabled");
3139
3140                 if (bss_conf->enable_beacon)
3141                         wl->set_bss_type = BSS_TYPE_IBSS;
3142                 else
3143                         wl->set_bss_type = BSS_TYPE_STA_BSS;
3144                 do_join = true;
3145         }
3146
3147         if ((changed & BSS_CHANGED_CQM)) {
3148                 bool enable = false;
3149                 if (bss_conf->cqm_rssi_thold)
3150                         enable = true;
3151                 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
3152                                                   bss_conf->cqm_rssi_thold,
3153                                                   bss_conf->cqm_rssi_hyst);
3154                 if (ret < 0)
3155                         goto out;
3156                 wl->rssi_thold = bss_conf->cqm_rssi_thold;
3157         }
3158
3159         if ((changed & BSS_CHANGED_BSSID) &&
3160             /*
3161              * Now we know the correct bssid, so we send a new join command
3162              * and enable the BSSID filter
3163              */
3164             memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
3165                 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
3166
3167                 if (!is_zero_ether_addr(wl->bssid)) {
3168                         ret = wl1271_cmd_build_null_data(wl);
3169                         if (ret < 0)
3170                                 goto out;
3171
3172                         ret = wl1271_build_qos_null_data(wl);
3173                         if (ret < 0)
3174                                 goto out;
3175
3176                         /* Need to update the BSSID (for filtering etc) */
3177                         do_join = true;
3178                 }
3179         }
3180
3181         rcu_read_lock();
3182         sta = ieee80211_find_sta(vif, bss_conf->bssid);
3183         if (sta)  {
3184                 /* save the supp_rates of the ap */
3185                 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
3186                 if (sta->ht_cap.ht_supported)
3187                         sta_rate_set |=
3188                             (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
3189                 sta_ht_cap = sta->ht_cap;
3190                 sta_exists = true;
3191         }
3192         rcu_read_unlock();
3193
3194         if (sta_exists) {
3195                 /* handle new association with HT and HT information change */
3196                 if ((changed & BSS_CHANGED_HT) &&
3197                     (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3198                         ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
3199                                                              true);
3200                         if (ret < 0) {
3201                                 wl1271_warning("Set ht cap true failed %d",
3202                                                ret);
3203                                 goto out;
3204                         }
3205                         ret = wl1271_acx_set_ht_information(wl,
3206                                                 bss_conf->ht_operation_mode);
3207                         if (ret < 0) {
3208                                 wl1271_warning("Set ht information failed %d",
3209                                                ret);
3210                                 goto out;
3211                         }
3212                 }
3213                 /* handle new association without HT and disassociation */
3214                 else if (changed & BSS_CHANGED_ASSOC) {
3215                         ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
3216                                                              false);
3217                         if (ret < 0) {
3218                                 wl1271_warning("Set ht cap false failed %d",
3219                                                ret);
3220                                 goto out;
3221                         }
3222                 }
3223         }
3224
3225         if ((changed & BSS_CHANGED_ASSOC)) {
3226                 if (bss_conf->assoc) {
3227                         u32 rates;
3228                         int ieoffset;
3229                         wl->aid = bss_conf->aid;
3230                         set_assoc = true;
3231
3232                         wl->ps_poll_failures = 0;
3233
3234                         /*
3235                          * use basic rates from AP, and determine lowest rate
3236                          * to use with control frames.
3237                          */
3238                         rates = bss_conf->basic_rates;
3239                         wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
3240                                                                          rates);
3241                         wl->basic_rate = wl1271_tx_min_rate_get(wl);
3242                         if (sta_rate_set)
3243                                 wl->rate_set = wl1271_tx_enabled_rates_get(wl,
3244                                                                 sta_rate_set);
3245                         ret = wl1271_acx_sta_rate_policies(wl);
3246                         if (ret < 0)
3247                                 goto out;
3248
3249                         /*
3250                          * with wl1271, we don't need to update the
3251                          * beacon_int and dtim_period, because the firmware
3252                          * updates it by itself when the first beacon is
3253                          * received after a join.
3254                          */
3255                         ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
3256                         if (ret < 0)
3257                                 goto out;
3258
3259                         /*
3260                          * Get a template for hardware connection maintenance
3261                          */
3262                         dev_kfree_skb(wl->probereq);
3263                         wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL);
3264                         ieoffset = offsetof(struct ieee80211_mgmt,
3265                                             u.probe_req.variable);
3266                         wl1271_ssid_set(wl, wl->probereq, ieoffset);
3267
3268                         /* enable the connection monitoring feature */
3269                         ret = wl1271_acx_conn_monit_params(wl, true);
3270                         if (ret < 0)
3271                                 goto out;
3272
3273                         /* If we want to go in PSM but we're not there yet */
3274                         if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
3275                             !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
3276                                 enum wl1271_cmd_ps_mode mode;
3277
3278                                 mode = STATION_POWER_SAVE_MODE;
3279                                 ret = wl1271_ps_set_mode(wl, mode,
3280                                                          wl->basic_rate,
3281                                                          true);
3282                                 if (ret < 0)
3283                                         goto out;
3284                         }
3285                 } else {
3286                         /* use defaults when not associated */
3287                         bool was_assoc =
3288                             !!test_and_clear_bit(WL1271_FLAG_STA_ASSOCIATED,
3289                                                  &wl->flags);
3290                         clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
3291                         wl->aid = 0;
3292
3293                         /* free probe-request template */
3294                         dev_kfree_skb(wl->probereq);
3295                         wl->probereq = NULL;
3296
3297                         /* re-enable dynamic ps - just in case */
3298                         ieee80211_enable_dyn_ps(wl->vif);
3299
3300                         /* revert back to minimum rates for the current band */
3301                         wl1271_set_band_rate(wl);
3302                         wl->basic_rate = wl1271_tx_min_rate_get(wl);
3303                         ret = wl1271_acx_sta_rate_policies(wl);
3304                         if (ret < 0)
3305                                 goto out;
3306
3307                         /* disable connection monitor features */
3308                         ret = wl1271_acx_conn_monit_params(wl, false);
3309
3310                         /* Disable the keep-alive feature */
3311                         ret = wl1271_acx_keep_alive_mode(wl, false);
3312                         if (ret < 0)
3313                                 goto out;
3314
3315                         /* restore the bssid filter and go to dummy bssid */
3316                         if (was_assoc) {
3317                                 wl1271_unjoin(wl);
3318                                 wl1271_dummy_join(wl);
3319                         }
3320                 }
3321         }
3322
3323         if (changed & BSS_CHANGED_IBSS) {
3324                 wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
3325                              bss_conf->ibss_joined);
3326
3327                 if (bss_conf->ibss_joined) {
3328                         u32 rates = bss_conf->basic_rates;
3329                         wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
3330                                                                          rates);
3331                         wl->basic_rate = wl1271_tx_min_rate_get(wl);
3332
3333                         /* by default, use 11b rates */
3334                         wl->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
3335                         ret = wl1271_acx_sta_rate_policies(wl);
3336                         if (ret < 0)
3337                                 goto out;
3338                 }
3339         }
3340
3341         ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
3342         if (ret < 0)
3343                 goto out;
3344
3345         if (changed & BSS_CHANGED_ARP_FILTER) {
3346                 __be32 addr = bss_conf->arp_addr_list[0];
3347                 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3348
3349                 if (bss_conf->arp_addr_cnt == 1 &&
3350                     bss_conf->arp_filter_enabled) {
3351                         /*
3352                          * The template should have been configured only upon
3353                          * association. however, it seems that the correct ip
3354                          * isn't being set (when sending), so we have to
3355                          * reconfigure the template upon every ip change.
3356                          */
3357                         ret = wl1271_cmd_build_arp_rsp(wl, addr);
3358                         if (ret < 0) {
3359                                 wl1271_warning("build arp rsp failed: %d", ret);
3360                                 goto out;
3361                         }
3362
3363                         ret = wl1271_acx_arp_ip_filter(wl,
3364                                 ACX_ARP_FILTER_ARP_FILTERING,
3365                                 addr);
3366                 } else
3367                         ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
3368
3369                 if (ret < 0)
3370                         goto out;
3371         }
3372
3373         if (do_join) {
3374                 ret = wl1271_join(wl, set_assoc);
3375                 if (ret < 0) {
3376                         wl1271_warning("cmd join failed %d", ret);
3377                         goto out;
3378                 }
3379                 wl1271_check_operstate(wl, ieee80211_get_operstate(vif));
3380         }
3381
3382 out:
3383         return;
3384 }
3385
3386 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
3387                                        struct ieee80211_vif *vif,
3388                                        struct ieee80211_bss_conf *bss_conf,
3389                                        u32 changed)
3390 {
3391         struct wl1271 *wl = hw->priv;
3392         bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
3393         int ret;
3394
3395         wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
3396                      (int)changed);
3397
3398         mutex_lock(&wl->mutex);
3399
3400         if (unlikely(wl->state == WL1271_STATE_OFF))
3401                 goto out;
3402
3403         ret = wl1271_ps_elp_wakeup(wl);
3404         if (ret < 0)
3405                 goto out;
3406
3407         if (is_ap)
3408                 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
3409         else
3410                 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
3411
3412         wl1271_ps_elp_sleep(wl);
3413
3414 out:
3415         mutex_unlock(&wl->mutex);
3416 }
3417
3418 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
3419                              const struct ieee80211_tx_queue_params *params)
3420 {
3421         struct wl1271 *wl = hw->priv;
3422         u8 ps_scheme;
3423         int ret = 0;
3424
3425         mutex_lock(&wl->mutex);
3426
3427         wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
3428
3429         if (params->uapsd)
3430                 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
3431         else
3432                 ps_scheme = CONF_PS_SCHEME_LEGACY;
3433
3434         if (wl->state == WL1271_STATE_OFF) {
3435                 /*
3436                  * If the state is off, the parameters will be recorded and
3437                  * configured on init. This happens in AP-mode.
3438                  */
3439                 struct conf_tx_ac_category *conf_ac =
3440                         &wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)];
3441                 struct conf_tx_tid *conf_tid =
3442                         &wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)];
3443
3444                 conf_ac->ac = wl1271_tx_get_queue(queue);
3445                 conf_ac->cw_min = (u8)params->cw_min;
3446                 conf_ac->cw_max = params->cw_max;
3447                 conf_ac->aifsn = params->aifs;
3448                 conf_ac->tx_op_limit = params->txop << 5;
3449
3450                 conf_tid->queue_id = wl1271_tx_get_queue(queue);
3451                 conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF;
3452                 conf_tid->tsid = wl1271_tx_get_queue(queue);
3453                 conf_tid->ps_scheme = ps_scheme;
3454                 conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY;
3455                 conf_tid->apsd_conf[0] = 0;
3456                 conf_tid->apsd_conf[1] = 0;
3457                 goto out;
3458         }
3459
3460         ret = wl1271_ps_elp_wakeup(wl);
3461         if (ret < 0)
3462                 goto out;
3463
3464         /*
3465          * the txop is confed in units of 32us by the mac80211,
3466          * we need us
3467          */
3468         ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
3469                                 params->cw_min, params->cw_max,
3470                                 params->aifs, params->txop << 5);
3471         if (ret < 0)
3472                 goto out_sleep;
3473
3474         ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
3475                                  CONF_CHANNEL_TYPE_EDCF,
3476                                  wl1271_tx_get_queue(queue),
3477                                  ps_scheme, CONF_ACK_POLICY_LEGACY,
3478                                  0, 0);
3479
3480 out_sleep:
3481         wl1271_ps_elp_sleep(wl);
3482
3483 out:
3484         mutex_unlock(&wl->mutex);
3485
3486         return ret;
3487 }
3488
3489 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
3490 {
3491
3492         struct wl1271 *wl = hw->priv;
3493         u64 mactime = ULLONG_MAX;
3494         int ret;
3495
3496         wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
3497
3498         mutex_lock(&wl->mutex);
3499
3500         if (unlikely(wl->state == WL1271_STATE_OFF))
3501                 goto out;
3502
3503         ret = wl1271_ps_elp_wakeup(wl);
3504         if (ret < 0)
3505                 goto out;
3506
3507         ret = wl1271_acx_tsf_info(wl, &mactime);
3508         if (ret < 0)
3509                 goto out_sleep;
3510
3511 out_sleep:
3512         wl1271_ps_elp_sleep(wl);
3513
3514 out:
3515         mutex_unlock(&wl->mutex);
3516         return mactime;
3517 }
3518
3519 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
3520                                 struct survey_info *survey)
3521 {
3522         struct wl1271 *wl = hw->priv;
3523         struct ieee80211_conf *conf = &hw->conf;
3524
3525         if (idx != 0)
3526                 return -ENOENT;
3527
3528         survey->channel = conf->channel;
3529         survey->filled = SURVEY_INFO_NOISE_DBM;
3530         survey->noise = wl->noise;
3531
3532         return 0;
3533 }
3534
3535 static int wl1271_allocate_sta(struct wl1271 *wl,
3536                              struct ieee80211_sta *sta,
3537                              u8 *hlid)
3538 {
3539         struct wl1271_station *wl_sta;
3540         int id;
3541
3542         id = find_first_zero_bit(wl->ap_hlid_map, AP_MAX_STATIONS);
3543         if (id >= AP_MAX_STATIONS) {
3544                 wl1271_warning("could not allocate HLID - too much stations");
3545                 return -EBUSY;
3546         }
3547
3548         wl_sta = (struct wl1271_station *)sta->drv_priv;
3549         __set_bit(id, wl->ap_hlid_map);
3550         wl_sta->hlid = WL1271_AP_STA_HLID_START + id;
3551         *hlid = wl_sta->hlid;
3552         memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
3553         return 0;
3554 }
3555
3556 static void wl1271_free_sta(struct wl1271 *wl, u8 hlid)
3557 {
3558         int id = hlid - WL1271_AP_STA_HLID_START;
3559
3560         if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3561                 return;
3562
3563         __clear_bit(id, wl->ap_hlid_map);
3564         memset(wl->links[hlid].addr, 0, ETH_ALEN);
3565         wl1271_tx_reset_link_queues(wl, hlid);
3566         __clear_bit(hlid, &wl->ap_ps_map);
3567         __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
3568 }
3569
3570 bool wl1271_is_active_sta(struct wl1271 *wl, u8 hlid)
3571 {
3572         int id = hlid - WL1271_AP_STA_HLID_START;
3573         return test_bit(id, wl->ap_hlid_map);
3574 }
3575
3576 static int wl1271_op_sta_add(struct ieee80211_hw *hw,
3577                              struct ieee80211_vif *vif,
3578                              struct ieee80211_sta *sta)
3579 {
3580         struct wl1271 *wl = hw->priv;
3581         int ret = 0;
3582         u8 hlid;
3583
3584         mutex_lock(&wl->mutex);
3585
3586         if (unlikely(wl->state == WL1271_STATE_OFF))
3587                 goto out;
3588
3589         if (wl->bss_type != BSS_TYPE_AP_BSS)
3590                 goto out;
3591
3592         wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
3593
3594         ret = wl1271_allocate_sta(wl, sta, &hlid);
3595         if (ret < 0)
3596                 goto out;
3597
3598         ret = wl1271_ps_elp_wakeup(wl);
3599         if (ret < 0)
3600                 goto out_free_sta;
3601
3602         ret = wl12xx_cmd_add_peer(wl, sta, hlid);
3603         if (ret < 0)
3604                 goto out_sleep;
3605
3606 out_sleep:
3607         wl1271_ps_elp_sleep(wl);
3608
3609 out_free_sta:
3610         if (ret < 0)
3611                 wl1271_free_sta(wl, hlid);
3612
3613 out:
3614         mutex_unlock(&wl->mutex);
3615         return ret;
3616 }
3617
3618 static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
3619                                 struct ieee80211_vif *vif,
3620                                 struct ieee80211_sta *sta)
3621 {
3622         struct wl1271 *wl = hw->priv;
3623         struct wl1271_station *wl_sta;
3624         int ret = 0, id;
3625
3626         mutex_lock(&wl->mutex);
3627
3628         if (unlikely(wl->state == WL1271_STATE_OFF))
3629                 goto out;
3630
3631         if (wl->bss_type != BSS_TYPE_AP_BSS)
3632                 goto out;
3633
3634         wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
3635
3636         wl_sta = (struct wl1271_station *)sta->drv_priv;
3637         id = wl_sta->hlid - WL1271_AP_STA_HLID_START;
3638         if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3639                 goto out;
3640
3641         ret = wl1271_ps_elp_wakeup(wl);
3642         if (ret < 0)
3643                 goto out;
3644
3645         ret = wl12xx_cmd_remove_peer(wl, wl_sta->hlid);
3646         if (ret < 0)
3647                 goto out_sleep;
3648
3649         wl1271_free_sta(wl, wl_sta->hlid);
3650
3651 out_sleep:
3652         wl1271_ps_elp_sleep(wl);
3653
3654 out:
3655         mutex_unlock(&wl->mutex);
3656         return ret;
3657 }
3658
3659 static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
3660                                   struct ieee80211_vif *vif,
3661                                   enum ieee80211_ampdu_mlme_action action,
3662                                   struct ieee80211_sta *sta, u16 tid, u16 *ssn,
3663                                   u8 buf_size)
3664 {
3665         struct wl1271 *wl = hw->priv;
3666         int ret;
3667
3668         mutex_lock(&wl->mutex);
3669
3670         if (unlikely(wl->state == WL1271_STATE_OFF)) {
3671                 ret = -EAGAIN;
3672                 goto out;
3673         }
3674
3675         ret = wl1271_ps_elp_wakeup(wl);
3676         if (ret < 0)
3677                 goto out;
3678
3679         wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu: Rx tid %d action %d",
3680                      tid, action);
3681
3682         switch (action) {
3683         case IEEE80211_AMPDU_RX_START:
3684                 if ((wl->ba_support) && (wl->ba_allowed)) {
3685                         ret = wl1271_acx_set_ba_receiver_session(wl, tid, *ssn,
3686                                                                  true);
3687                         if (!ret)
3688                                 wl->ba_rx_bitmap |= BIT(tid);
3689                 } else {
3690                         ret = -ENOTSUPP;
3691                 }
3692                 break;
3693
3694         case IEEE80211_AMPDU_RX_STOP:
3695                 ret = wl1271_acx_set_ba_receiver_session(wl, tid, 0, false);
3696                 if (!ret)
3697                         wl->ba_rx_bitmap &= ~BIT(tid);
3698                 break;
3699
3700         /*
3701          * The BA initiator session management in FW independently.
3702          * Falling break here on purpose for all TX APDU commands.
3703          */
3704         case IEEE80211_AMPDU_TX_START:
3705         case IEEE80211_AMPDU_TX_STOP:
3706         case IEEE80211_AMPDU_TX_OPERATIONAL:
3707                 ret = -EINVAL;
3708                 break;
3709
3710         default:
3711                 wl1271_error("Incorrect ampdu action id=%x\n", action);
3712                 ret = -EINVAL;
3713         }
3714
3715         wl1271_ps_elp_sleep(wl);
3716
3717 out:
3718         mutex_unlock(&wl->mutex);
3719
3720         return ret;
3721 }
3722
3723 static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
3724 {
3725         struct wl1271 *wl = hw->priv;
3726         bool ret = false;
3727
3728         mutex_lock(&wl->mutex);
3729
3730         if (unlikely(wl->state == WL1271_STATE_OFF))
3731                 goto out;
3732
3733         /* packets are considered pending if in the TX queue or the FW */
3734         ret = (wl1271_tx_total_queue_count(wl) > 0) || (wl->tx_frames_cnt > 0);
3735
3736         /* the above is appropriate for STA mode for PS purposes */
3737         WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3738
3739 out:
3740         mutex_unlock(&wl->mutex);
3741
3742         return ret;
3743 }
3744
3745 /* can't be const, mac80211 writes to this */
3746 static struct ieee80211_rate wl1271_rates[] = {
3747         { .bitrate = 10,
3748           .hw_value = CONF_HW_BIT_RATE_1MBPS,
3749           .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
3750         { .bitrate = 20,
3751           .hw_value = CONF_HW_BIT_RATE_2MBPS,
3752           .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
3753           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3754         { .bitrate = 55,
3755           .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
3756           .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
3757           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3758         { .bitrate = 110,
3759           .hw_value = CONF_HW_BIT_RATE_11MBPS,
3760           .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
3761           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3762         { .bitrate = 60,
3763           .hw_value = CONF_HW_BIT_RATE_6MBPS,
3764           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
3765         { .bitrate = 90,
3766           .hw_value = CONF_HW_BIT_RATE_9MBPS,
3767           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
3768         { .bitrate = 120,
3769           .hw_value = CONF_HW_BIT_RATE_12MBPS,
3770           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
3771         { .bitrate = 180,
3772           .hw_value = CONF_HW_BIT_RATE_18MBPS,
3773           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
3774         { .bitrate = 240,
3775           .hw_value = CONF_HW_BIT_RATE_24MBPS,
3776           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
3777         { .bitrate = 360,
3778          .hw_value = CONF_HW_BIT_RATE_36MBPS,
3779          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
3780         { .bitrate = 480,
3781           .hw_value = CONF_HW_BIT_RATE_48MBPS,
3782           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
3783         { .bitrate = 540,
3784           .hw_value = CONF_HW_BIT_RATE_54MBPS,
3785           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
3786 };
3787
3788 /* can't be const, mac80211 writes to this */
3789 static struct ieee80211_channel wl1271_channels[] = {
3790         { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
3791         { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
3792         { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
3793         { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
3794         { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
3795         { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
3796         { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
3797         { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
3798         { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
3799         { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
3800         { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
3801         { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
3802         { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
3803         { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
3804 };
3805
3806 /* mapping to indexes for wl1271_rates */
3807 static const u8 wl1271_rate_to_idx_2ghz[] = {
3808         /* MCS rates are used only with 11n */
3809         7,                            /* CONF_HW_RXTX_RATE_MCS7 */
3810         6,                            /* CONF_HW_RXTX_RATE_MCS6 */
3811         5,                            /* CONF_HW_RXTX_RATE_MCS5 */
3812         4,                            /* CONF_HW_RXTX_RATE_MCS4 */
3813         3,                            /* CONF_HW_RXTX_RATE_MCS3 */
3814         2,                            /* CONF_HW_RXTX_RATE_MCS2 */
3815         1,                            /* CONF_HW_RXTX_RATE_MCS1 */
3816         0,                            /* CONF_HW_RXTX_RATE_MCS0 */
3817
3818         11,                            /* CONF_HW_RXTX_RATE_54   */
3819         10,                            /* CONF_HW_RXTX_RATE_48   */
3820         9,                             /* CONF_HW_RXTX_RATE_36   */
3821         8,                             /* CONF_HW_RXTX_RATE_24   */
3822
3823         /* TI-specific rate */
3824         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
3825
3826         7,                             /* CONF_HW_RXTX_RATE_18   */
3827         6,                             /* CONF_HW_RXTX_RATE_12   */
3828         3,                             /* CONF_HW_RXTX_RATE_11   */
3829         5,                             /* CONF_HW_RXTX_RATE_9    */
3830         4,                             /* CONF_HW_RXTX_RATE_6    */
3831         2,                             /* CONF_HW_RXTX_RATE_5_5  */
3832         1,                             /* CONF_HW_RXTX_RATE_2    */
3833         0                              /* CONF_HW_RXTX_RATE_1    */
3834 };
3835
3836 /* 11n STA capabilities */
3837 #define HW_RX_HIGHEST_RATE      72
3838
3839 #ifdef CONFIG_WL12XX_HT
3840 #define WL12XX_HT_CAP { \
3841         .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
3842                (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
3843         .ht_supported = true, \
3844         .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
3845         .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
3846         .mcs = { \
3847                 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
3848                 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
3849                 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
3850                 }, \
3851 }
3852 #else
3853 #define WL12XX_HT_CAP { \
3854         .ht_supported = false, \
3855 }
3856 #endif
3857
3858 /* can't be const, mac80211 writes to this */
3859 static struct ieee80211_supported_band wl1271_band_2ghz = {
3860         .channels = wl1271_channels,
3861         .n_channels = ARRAY_SIZE(wl1271_channels),
3862         .bitrates = wl1271_rates,
3863         .n_bitrates = ARRAY_SIZE(wl1271_rates),
3864         .ht_cap = WL12XX_HT_CAP,
3865 };
3866
3867 /* 5 GHz data rates for WL1273 */
3868 static struct ieee80211_rate wl1271_rates_5ghz[] = {
3869         { .bitrate = 60,
3870           .hw_value = CONF_HW_BIT_RATE_6MBPS,
3871           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
3872         { .bitrate = 90,
3873           .hw_value = CONF_HW_BIT_RATE_9MBPS,
3874           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
3875         { .bitrate = 120,
3876           .hw_value = CONF_HW_BIT_RATE_12MBPS,
3877           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
3878         { .bitrate = 180,
3879           .hw_value = CONF_HW_BIT_RATE_18MBPS,
3880           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
3881         { .bitrate = 240,
3882           .hw_value = CONF_HW_BIT_RATE_24MBPS,
3883           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
3884         { .bitrate = 360,
3885          .hw_value = CONF_HW_BIT_RATE_36MBPS,
3886          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
3887         { .bitrate = 480,
3888           .hw_value = CONF_HW_BIT_RATE_48MBPS,
3889           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
3890         { .bitrate = 540,
3891           .hw_value = CONF_HW_BIT_RATE_54MBPS,
3892           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
3893 };
3894
3895 /* 5 GHz band channels for WL1273 */
3896 static struct ieee80211_channel wl1271_channels_5ghz[] = {
3897         { .hw_value = 7, .center_freq = 5035, .max_power = 25 },
3898         { .hw_value = 8, .center_freq = 5040, .max_power = 25 },
3899         { .hw_value = 9, .center_freq = 5045, .max_power = 25 },
3900         { .hw_value = 11, .center_freq = 5055, .max_power = 25 },
3901         { .hw_value = 12, .center_freq = 5060, .max_power = 25 },
3902         { .hw_value = 16, .center_freq = 5080, .max_power = 25 },
3903         { .hw_value = 34, .center_freq = 5170, .max_power = 25 },
3904         { .hw_value = 36, .center_freq = 5180, .max_power = 25 },
3905         { .hw_value = 38, .center_freq = 5190, .max_power = 25 },
3906         { .hw_value = 40, .center_freq = 5200, .max_power = 25 },
3907         { .hw_value = 42, .center_freq = 5210, .max_power = 25 },
3908         { .hw_value = 44, .center_freq = 5220, .max_power = 25 },
3909         { .hw_value = 46, .center_freq = 5230, .max_power = 25 },
3910         { .hw_value = 48, .center_freq = 5240, .max_power = 25 },
3911         { .hw_value = 52, .center_freq = 5260, .max_power = 25 },
3912         { .hw_value = 56, .center_freq = 5280, .max_power = 25 },
3913         { .hw_value = 60, .center_freq = 5300, .max_power = 25 },
3914         { .hw_value = 64, .center_freq = 5320, .max_power = 25 },
3915         { .hw_value = 100, .center_freq = 5500, .max_power = 25 },
3916         { .hw_value = 104, .center_freq = 5520, .max_power = 25 },
3917         { .hw_value = 108, .center_freq = 5540, .max_power = 25 },
3918         { .hw_value = 112, .center_freq = 5560, .max_power = 25 },
3919         { .hw_value = 116, .center_freq = 5580, .max_power = 25 },
3920         { .hw_value = 120, .center_freq = 5600, .max_power = 25 },
3921         { .hw_value = 124, .center_freq = 5620, .max_power = 25 },
3922         { .hw_value = 128, .center_freq = 5640, .max_power = 25 },
3923         { .hw_value = 132, .center_freq = 5660, .max_power = 25 },
3924         { .hw_value = 136, .center_freq = 5680, .max_power = 25 },
3925         { .hw_value = 140, .center_freq = 5700, .max_power = 25 },
3926         { .hw_value = 149, .center_freq = 5745, .max_power = 25 },
3927         { .hw_value = 153, .center_freq = 5765, .max_power = 25 },
3928         { .hw_value = 157, .center_freq = 5785, .max_power = 25 },
3929         { .hw_value = 161, .center_freq = 5805, .max_power = 25 },
3930         { .hw_value = 165, .center_freq = 5825, .max_power = 25 },
3931 };
3932
3933 /* mapping to indexes for wl1271_rates_5ghz */
3934 static const u8 wl1271_rate_to_idx_5ghz[] = {
3935         /* MCS rates are used only with 11n */
3936         7,                            /* CONF_HW_RXTX_RATE_MCS7 */
3937         6,                            /* CONF_HW_RXTX_RATE_MCS6 */
3938         5,                            /* CONF_HW_RXTX_RATE_MCS5 */
3939         4,                            /* CONF_HW_RXTX_RATE_MCS4 */
3940         3,                            /* CONF_HW_RXTX_RATE_MCS3 */
3941         2,                            /* CONF_HW_RXTX_RATE_MCS2 */
3942         1,                            /* CONF_HW_RXTX_RATE_MCS1 */
3943         0,                            /* CONF_HW_RXTX_RATE_MCS0 */
3944
3945         7,                             /* CONF_HW_RXTX_RATE_54   */
3946         6,                             /* CONF_HW_RXTX_RATE_48   */
3947         5,                             /* CONF_HW_RXTX_RATE_36   */
3948         4,                             /* CONF_HW_RXTX_RATE_24   */
3949
3950         /* TI-specific rate */
3951         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
3952
3953         3,                             /* CONF_HW_RXTX_RATE_18   */
3954         2,                             /* CONF_HW_RXTX_RATE_12   */
3955         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11   */
3956         1,                             /* CONF_HW_RXTX_RATE_9    */
3957         0,                             /* CONF_HW_RXTX_RATE_6    */
3958         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5  */
3959         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2    */
3960         CONF_HW_RXTX_RATE_UNSUPPORTED  /* CONF_HW_RXTX_RATE_1    */
3961 };
3962
3963 static struct ieee80211_supported_band wl1271_band_5ghz = {
3964         .channels = wl1271_channels_5ghz,
3965         .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
3966         .bitrates = wl1271_rates_5ghz,
3967         .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
3968         .ht_cap = WL12XX_HT_CAP,
3969 };
3970
3971 static const u8 *wl1271_band_rate_to_idx[] = {
3972         [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
3973         [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
3974 };
3975
3976 static const struct ieee80211_ops wl1271_ops = {
3977         .start = wl1271_op_start,
3978         .stop = wl1271_op_stop,
3979         .add_interface = wl1271_op_add_interface,
3980         .remove_interface = wl1271_op_remove_interface,
3981 #ifdef CONFIG_PM
3982         .suspend = wl1271_op_suspend,
3983         .resume = wl1271_op_resume,
3984 #endif
3985         .config = wl1271_op_config,
3986         .prepare_multicast = wl1271_op_prepare_multicast,
3987         .configure_filter = wl1271_op_configure_filter,
3988         .tx = wl1271_op_tx,
3989         .set_key = wl1271_op_set_key,
3990         .hw_scan = wl1271_op_hw_scan,
3991         .cancel_hw_scan = wl1271_op_cancel_hw_scan,
3992         .sched_scan_start = wl1271_op_sched_scan_start,
3993         .sched_scan_stop = wl1271_op_sched_scan_stop,
3994         .bss_info_changed = wl1271_op_bss_info_changed,
3995         .set_frag_threshold = wl1271_op_set_frag_threshold,
3996         .set_rts_threshold = wl1271_op_set_rts_threshold,
3997         .conf_tx = wl1271_op_conf_tx,
3998         .get_tsf = wl1271_op_get_tsf,
3999         .get_survey = wl1271_op_get_survey,
4000         .sta_add = wl1271_op_sta_add,
4001         .sta_remove = wl1271_op_sta_remove,
4002         .ampdu_action = wl1271_op_ampdu_action,
4003         .tx_frames_pending = wl1271_tx_frames_pending,
4004         CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
4005 };
4006
4007
4008 u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
4009 {
4010         u8 idx;
4011
4012         BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
4013
4014         if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
4015                 wl1271_error("Illegal RX rate from HW: %d", rate);
4016                 return 0;
4017         }
4018
4019         idx = wl1271_band_rate_to_idx[band][rate];
4020         if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
4021                 wl1271_error("Unsupported RX rate from HW: %d", rate);
4022                 return 0;
4023         }
4024
4025         return idx;
4026 }
4027
4028 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
4029                                                struct device_attribute *attr,
4030                                                char *buf)
4031 {
4032         struct wl1271 *wl = dev_get_drvdata(dev);
4033         ssize_t len;
4034
4035         len = PAGE_SIZE;
4036
4037         mutex_lock(&wl->mutex);
4038         len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
4039                        wl->sg_enabled);
4040         mutex_unlock(&wl->mutex);
4041
4042         return len;
4043
4044 }
4045
4046 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
4047                                                 struct device_attribute *attr,
4048                                                 const char *buf, size_t count)
4049 {
4050         struct wl1271 *wl = dev_get_drvdata(dev);
4051         unsigned long res;
4052         int ret;
4053
4054         ret = kstrtoul(buf, 10, &res);
4055         if (ret < 0) {
4056                 wl1271_warning("incorrect value written to bt_coex_mode");
4057                 return count;
4058         }
4059
4060         mutex_lock(&wl->mutex);
4061
4062         res = !!res;
4063
4064         if (res == wl->sg_enabled)
4065                 goto out;
4066
4067         wl->sg_enabled = res;
4068
4069         if (wl->state == WL1271_STATE_OFF)
4070                 goto out;
4071
4072         ret = wl1271_ps_elp_wakeup(wl);
4073         if (ret < 0)
4074                 goto out;
4075
4076         wl1271_acx_sg_enable(wl, wl->sg_enabled);
4077         wl1271_ps_elp_sleep(wl);
4078
4079  out:
4080         mutex_unlock(&wl->mutex);
4081         return count;
4082 }
4083
4084 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
4085                    wl1271_sysfs_show_bt_coex_state,
4086                    wl1271_sysfs_store_bt_coex_state);
4087
4088 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
4089                                            struct device_attribute *attr,
4090                                            char *buf)
4091 {
4092         struct wl1271 *wl = dev_get_drvdata(dev);
4093         ssize_t len;
4094
4095         len = PAGE_SIZE;
4096
4097         mutex_lock(&wl->mutex);
4098         if (wl->hw_pg_ver >= 0)
4099                 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
4100         else
4101                 len = snprintf(buf, len, "n/a\n");
4102         mutex_unlock(&wl->mutex);
4103
4104         return len;
4105 }
4106
4107 static DEVICE_ATTR(hw_pg_ver, S_IRUGO,
4108                    wl1271_sysfs_show_hw_pg_ver, NULL);
4109
4110 static ssize_t wl1271_sysfs_read_fwlog(struct file *filp, struct kobject *kobj,
4111                                        struct bin_attribute *bin_attr,
4112                                        char *buffer, loff_t pos, size_t count)
4113 {
4114         struct device *dev = container_of(kobj, struct device, kobj);
4115         struct wl1271 *wl = dev_get_drvdata(dev);
4116         ssize_t len;
4117         int ret;
4118
4119         ret = mutex_lock_interruptible(&wl->mutex);
4120         if (ret < 0)
4121                 return -ERESTARTSYS;
4122
4123         /* Let only one thread read the log at a time, blocking others */
4124         while (wl->fwlog_size == 0) {
4125                 DEFINE_WAIT(wait);
4126
4127                 prepare_to_wait_exclusive(&wl->fwlog_waitq,
4128                                           &wait,
4129                                           TASK_INTERRUPTIBLE);
4130
4131                 if (wl->fwlog_size != 0) {
4132                         finish_wait(&wl->fwlog_waitq, &wait);
4133                         break;
4134                 }
4135
4136                 mutex_unlock(&wl->mutex);
4137
4138                 schedule();
4139                 finish_wait(&wl->fwlog_waitq, &wait);
4140
4141                 if (signal_pending(current))
4142                         return -ERESTARTSYS;
4143
4144                 ret = mutex_lock_interruptible(&wl->mutex);
4145                 if (ret < 0)
4146                         return -ERESTARTSYS;
4147         }
4148
4149         /* Check if the fwlog is still valid */
4150         if (wl->fwlog_size < 0) {
4151                 mutex_unlock(&wl->mutex);
4152                 return 0;
4153         }
4154
4155         /* Seeking is not supported - old logs are not kept. Disregard pos. */
4156         len = min(count, (size_t)wl->fwlog_size);
4157         wl->fwlog_size -= len;
4158         memcpy(buffer, wl->fwlog, len);
4159
4160         /* Make room for new messages */
4161         memmove(wl->fwlog, wl->fwlog + len, wl->fwlog_size);
4162
4163         mutex_unlock(&wl->mutex);
4164
4165         return len;
4166 }
4167
4168 static struct bin_attribute fwlog_attr = {
4169         .attr = {.name = "fwlog", .mode = S_IRUSR},
4170         .read = wl1271_sysfs_read_fwlog,
4171 };
4172
4173 int wl1271_register_hw(struct wl1271 *wl)
4174 {
4175         int ret;
4176
4177         if (wl->mac80211_registered)
4178                 return 0;
4179
4180         ret = wl1271_fetch_nvs(wl);
4181         if (ret == 0) {
4182                 /* NOTE: The wl->nvs->nvs element must be first, in
4183                  * order to simplify the casting, we assume it is at
4184                  * the beginning of the wl->nvs structure.
4185                  */
4186                 u8 *nvs_ptr = (u8 *)wl->nvs;
4187
4188                 wl->mac_addr[0] = nvs_ptr[11];
4189                 wl->mac_addr[1] = nvs_ptr[10];
4190                 wl->mac_addr[2] = nvs_ptr[6];
4191                 wl->mac_addr[3] = nvs_ptr[5];
4192                 wl->mac_addr[4] = nvs_ptr[4];
4193                 wl->mac_addr[5] = nvs_ptr[3];
4194         }
4195
4196         SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
4197
4198         ret = ieee80211_register_hw(wl->hw);
4199         if (ret < 0) {
4200                 wl1271_error("unable to register mac80211 hw: %d", ret);
4201                 return ret;
4202         }
4203
4204         wl->mac80211_registered = true;
4205
4206         wl1271_debugfs_init(wl);
4207
4208         register_netdevice_notifier(&wl1271_dev_notifier);
4209
4210         wl1271_notice("loaded");
4211
4212         return 0;
4213 }
4214 EXPORT_SYMBOL_GPL(wl1271_register_hw);
4215
4216 void wl1271_unregister_hw(struct wl1271 *wl)
4217 {
4218         if (wl->state == WL1271_STATE_PLT)
4219                 __wl1271_plt_stop(wl);
4220
4221         unregister_netdevice_notifier(&wl1271_dev_notifier);
4222         ieee80211_unregister_hw(wl->hw);
4223         wl->mac80211_registered = false;
4224
4225 }
4226 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
4227
4228 int wl1271_init_ieee80211(struct wl1271 *wl)
4229 {
4230         static const u32 cipher_suites[] = {
4231                 WLAN_CIPHER_SUITE_WEP40,
4232                 WLAN_CIPHER_SUITE_WEP104,
4233                 WLAN_CIPHER_SUITE_TKIP,
4234                 WLAN_CIPHER_SUITE_CCMP,
4235                 WL1271_CIPHER_SUITE_GEM,
4236         };
4237
4238         /* The tx descriptor buffer and the TKIP space. */
4239         wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
4240                 sizeof(struct wl1271_tx_hw_descr);
4241
4242         /* unit us */
4243         /* FIXME: find a proper value */
4244         wl->hw->channel_change_time = 10000;
4245         wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
4246
4247         wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
4248                 IEEE80211_HW_BEACON_FILTER |
4249                 IEEE80211_HW_SUPPORTS_PS |
4250                 IEEE80211_HW_SUPPORTS_UAPSD |
4251                 IEEE80211_HW_HAS_RATE_CONTROL |
4252                 IEEE80211_HW_CONNECTION_MONITOR |
4253                 IEEE80211_HW_SUPPORTS_CQM_RSSI |
4254                 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
4255                 IEEE80211_HW_SPECTRUM_MGMT |
4256                 IEEE80211_HW_AP_LINK_PS;
4257
4258         wl->hw->wiphy->cipher_suites = cipher_suites;
4259         wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
4260
4261         wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
4262                 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
4263         wl->hw->wiphy->max_scan_ssids = 1;
4264         /*
4265          * Maximum length of elements in scanning probe request templates
4266          * should be the maximum length possible for a template, without
4267          * the IEEE80211 header of the template
4268          */
4269         wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
4270                         sizeof(struct ieee80211_header);
4271
4272         /* make sure all our channels fit in the scanned_ch bitmask */
4273         BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
4274                      ARRAY_SIZE(wl1271_channels_5ghz) >
4275                      WL1271_MAX_CHANNELS);
4276         /*
4277          * We keep local copies of the band structs because we need to
4278          * modify them on a per-device basis.
4279          */
4280         memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
4281                sizeof(wl1271_band_2ghz));
4282         memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
4283                sizeof(wl1271_band_5ghz));
4284
4285         wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
4286                 &wl->bands[IEEE80211_BAND_2GHZ];
4287         wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
4288                 &wl->bands[IEEE80211_BAND_5GHZ];
4289
4290         wl->hw->queues = 4;
4291         wl->hw->max_rates = 1;
4292
4293         wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
4294
4295         SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
4296
4297         wl->hw->sta_data_size = sizeof(struct wl1271_station);
4298
4299         wl->hw->max_rx_aggregation_subframes = 8;
4300
4301         return 0;
4302 }
4303 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
4304
4305 #define WL1271_DEFAULT_CHANNEL 0
4306
4307 struct ieee80211_hw *wl1271_alloc_hw(void)
4308 {
4309         struct ieee80211_hw *hw;
4310         struct platform_device *plat_dev = NULL;
4311         struct wl1271 *wl;
4312         int i, j, ret;
4313         unsigned int order;
4314
4315         hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
4316         if (!hw) {
4317                 wl1271_error("could not alloc ieee80211_hw");
4318                 ret = -ENOMEM;
4319                 goto err_hw_alloc;
4320         }
4321
4322         plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
4323         if (!plat_dev) {
4324                 wl1271_error("could not allocate platform_device");
4325                 ret = -ENOMEM;
4326                 goto err_plat_alloc;
4327         }
4328
4329         wl = hw->priv;
4330         memset(wl, 0, sizeof(*wl));
4331
4332         INIT_LIST_HEAD(&wl->list);
4333
4334         wl->hw = hw;
4335         wl->plat_dev = plat_dev;
4336
4337         for (i = 0; i < NUM_TX_QUEUES; i++)
4338                 skb_queue_head_init(&wl->tx_queue[i]);
4339
4340         for (i = 0; i < NUM_TX_QUEUES; i++)
4341                 for (j = 0; j < AP_MAX_LINKS; j++)
4342                         skb_queue_head_init(&wl->links[j].tx_queue[i]);
4343
4344         skb_queue_head_init(&wl->deferred_rx_queue);
4345         skb_queue_head_init(&wl->deferred_tx_queue);
4346
4347         INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
4348         INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
4349         INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
4350         INIT_WORK(&wl->tx_work, wl1271_tx_work);
4351         INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
4352         INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
4353         INIT_WORK(&wl->rx_streaming_enable_work,
4354                   wl1271_rx_streaming_enable_work);
4355         INIT_WORK(&wl->rx_streaming_disable_work,
4356                   wl1271_rx_streaming_disable_work);
4357
4358         wl->freezable_wq = create_freezable_workqueue("wl12xx_wq");
4359         if (!wl->freezable_wq) {
4360                 ret = -ENOMEM;
4361                 goto err_hw;
4362         }
4363
4364         wl->channel = WL1271_DEFAULT_CHANNEL;
4365         wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
4366         wl->default_key = 0;
4367         wl->rx_counter = 0;
4368         wl->psm_entry_retry = 0;
4369         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
4370         wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
4371         wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
4372         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
4373         wl->band = IEEE80211_BAND_2GHZ;
4374         wl->vif = NULL;
4375         wl->flags = 0;
4376         wl->sg_enabled = true;
4377         wl->hw_pg_ver = -1;
4378         wl->bss_type = MAX_BSS_TYPE;
4379         wl->set_bss_type = MAX_BSS_TYPE;
4380         wl->last_tx_hlid = 0;
4381         wl->ap_ps_map = 0;
4382         wl->ap_fw_ps_map = 0;
4383         wl->quirks = 0;
4384         wl->platform_quirks = 0;
4385         wl->sched_scanning = false;
4386         wl->tx_security_seq = 0;
4387         wl->tx_security_last_seq_lsb = 0;
4388         wl->role_id = WL12XX_INVALID_ROLE_ID;
4389         wl->sta_hlid = WL12XX_INVALID_LINK_ID;
4390         wl->dev_role_id = WL12XX_INVALID_ROLE_ID;
4391         wl->dev_hlid = WL12XX_INVALID_LINK_ID;
4392         setup_timer(&wl->rx_streaming_timer, wl1271_rx_streaming_timer,
4393                     (unsigned long) wl);
4394         wl->fwlog_size = 0;
4395         init_waitqueue_head(&wl->fwlog_waitq);
4396
4397         memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
4398         for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
4399                 wl->tx_frames[i] = NULL;
4400
4401         spin_lock_init(&wl->wl_lock);
4402
4403         wl->state = WL1271_STATE_OFF;
4404         mutex_init(&wl->mutex);
4405
4406         /* Apply default driver configuration. */
4407         wl1271_conf_init(wl);
4408
4409         order = get_order(WL1271_AGGR_BUFFER_SIZE);
4410         wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
4411         if (!wl->aggr_buf) {
4412                 ret = -ENOMEM;
4413                 goto err_wq;
4414         }
4415
4416         wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
4417         if (!wl->dummy_packet) {
4418                 ret = -ENOMEM;
4419                 goto err_aggr;
4420         }
4421
4422         /* Allocate one page for the FW log */
4423         wl->fwlog = (u8 *)get_zeroed_page(GFP_KERNEL);
4424         if (!wl->fwlog) {
4425                 ret = -ENOMEM;
4426                 goto err_dummy_packet;
4427         }
4428
4429         /* Register platform device */
4430         ret = platform_device_register(wl->plat_dev);
4431         if (ret) {
4432                 wl1271_error("couldn't register platform device");
4433                 goto err_fwlog;
4434         }
4435         dev_set_drvdata(&wl->plat_dev->dev, wl);
4436
4437         /* Create sysfs file to control bt coex state */
4438         ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4439         if (ret < 0) {
4440                 wl1271_error("failed to create sysfs file bt_coex_state");
4441                 goto err_platform;
4442         }
4443
4444         /* Create sysfs file to get HW PG version */
4445         ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4446         if (ret < 0) {
4447                 wl1271_error("failed to create sysfs file hw_pg_ver");
4448                 goto err_bt_coex_state;
4449         }
4450
4451         /* Create sysfs file for the FW log */
4452         ret = device_create_bin_file(&wl->plat_dev->dev, &fwlog_attr);
4453         if (ret < 0) {
4454                 wl1271_error("failed to create sysfs file fwlog");
4455                 goto err_hw_pg_ver;
4456         }
4457
4458         return hw;
4459
4460 err_hw_pg_ver:
4461         device_remove_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4462
4463 err_bt_coex_state:
4464         device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4465
4466 err_platform:
4467         platform_device_unregister(wl->plat_dev);
4468
4469 err_fwlog:
4470         free_page((unsigned long)wl->fwlog);
4471
4472 err_dummy_packet:
4473         dev_kfree_skb(wl->dummy_packet);
4474
4475 err_aggr:
4476         free_pages((unsigned long)wl->aggr_buf, order);
4477
4478 err_wq:
4479         destroy_workqueue(wl->freezable_wq);
4480
4481 err_hw:
4482         wl1271_debugfs_exit(wl);
4483         kfree(plat_dev);
4484
4485 err_plat_alloc:
4486         ieee80211_free_hw(hw);
4487
4488 err_hw_alloc:
4489
4490         return ERR_PTR(ret);
4491 }
4492 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
4493
4494 int wl1271_free_hw(struct wl1271 *wl)
4495 {
4496         /* Unblock any fwlog readers */
4497         mutex_lock(&wl->mutex);
4498         wl->fwlog_size = -1;
4499         wake_up_interruptible_all(&wl->fwlog_waitq);
4500         mutex_unlock(&wl->mutex);
4501
4502         device_remove_bin_file(&wl->plat_dev->dev, &fwlog_attr);
4503
4504         device_remove_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4505
4506         device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4507         platform_device_unregister(wl->plat_dev);
4508         free_page((unsigned long)wl->fwlog);
4509         dev_kfree_skb(wl->dummy_packet);
4510         free_pages((unsigned long)wl->aggr_buf,
4511                         get_order(WL1271_AGGR_BUFFER_SIZE));
4512         kfree(wl->plat_dev);
4513
4514         wl1271_debugfs_exit(wl);
4515
4516         vfree(wl->fw);
4517         wl->fw = NULL;
4518         kfree(wl->nvs);
4519         wl->nvs = NULL;
4520
4521         kfree(wl->fw_status);
4522         kfree(wl->tx_res_if);
4523         destroy_workqueue(wl->freezable_wq);
4524
4525         ieee80211_free_hw(wl->hw);
4526
4527         return 0;
4528 }
4529 EXPORT_SYMBOL_GPL(wl1271_free_hw);
4530
4531 u32 wl12xx_debug_level = DEBUG_NONE;
4532 EXPORT_SYMBOL_GPL(wl12xx_debug_level);
4533 module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
4534 MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
4535
4536 module_param_named(fwlog, fwlog_param, charp, 0);
4537 MODULE_PARM_DESC(keymap,
4538                  "FW logger options: continuous, ondemand, dbgpins or disable");
4539
4540 MODULE_LICENSE("GPL");
4541 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
4542 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");