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