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