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