drivers/net/wireless/wl12xx/main.c

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