drivers/net/wireless/wl12xx/main.c

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