drivers/net/wireless/wl12xx/main.c

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