drivers/net/wireless/wl12xx/main.c

   1 /*
   2  * This file is part of wl1271
   3  *
   4  * Copyright (C) 2008-2010 Nokia Corporation
   5  *
   6  * Contact: Luciano Coelho <luciano.coelho@nokia.com>
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * version 2 as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  20  * 02110-1301 USA
  21  *
  22  */
  23
  24 #include <linux/module.h>
  25 #include <linux/firmware.h>
  26 #include <linux/delay.h>
  27 #include <linux/spi/spi.h>
  28 #include <linux/crc32.h>
  29 #include <linux/etherdevice.h>
  30 #include <linux/vmalloc.h>
  31 #include <linux/platform_device.h>
  32 #include <linux/slab.h>
  33 #include <linux/wl12xx.h>
  34 #include <linux/sched.h>
  35
  36 #include "wl12xx.h"
  37 #include "wl12xx_80211.h"
  38 #include "reg.h"
  39 #include "io.h"
  40 #include "event.h"
  41 #include "tx.h"
  42 #include "rx.h"
  43 #include "ps.h"
  44 #include "init.h"
  45 #include "debugfs.h"
  46 #include "cmd.h"
  47 #include "boot.h"
  48 #include "testmode.h"
  49 #include "scan.h"
  50
  51 #define WL1271_BOOT_RETRIES 3
  52
  53 static struct conf_drv_settings default_conf = {
  54         .sg = {
  55                 .params = {
  56                         [CONF_SG_ACL_BT_MASTER_MIN_BR] = 10,
  57                         [CONF_SG_ACL_BT_MASTER_MAX_BR] = 180,
  58                         [CONF_SG_ACL_BT_SLAVE_MIN_BR] = 10,
  59                         [CONF_SG_ACL_BT_SLAVE_MAX_BR] = 180,
  60                         [CONF_SG_ACL_BT_MASTER_MIN_EDR] = 10,
  61                         [CONF_SG_ACL_BT_MASTER_MAX_EDR] = 80,
  62                         [CONF_SG_ACL_BT_SLAVE_MIN_EDR] = 10,
  63                         [CONF_SG_ACL_BT_SLAVE_MAX_EDR] = 80,
  64                         [CONF_SG_ACL_WLAN_PS_MASTER_BR] = 8,
  65                         [CONF_SG_ACL_WLAN_PS_SLAVE_BR] = 8,
  66                         [CONF_SG_ACL_WLAN_PS_MASTER_EDR] = 20,
  67                         [CONF_SG_ACL_WLAN_PS_SLAVE_EDR] = 20,
  68                         [CONF_SG_ACL_WLAN_ACTIVE_MASTER_MIN_BR] = 20,
  69                         [CONF_SG_ACL_WLAN_ACTIVE_MASTER_MAX_BR] = 35,
  70                         [CONF_SG_ACL_WLAN_ACTIVE_SLAVE_MIN_BR] = 16,
  71                         [CONF_SG_ACL_WLAN_ACTIVE_SLAVE_MAX_BR] = 35,
  72                         [CONF_SG_ACL_WLAN_ACTIVE_MASTER_MIN_EDR] = 32,
  73                         [CONF_SG_ACL_WLAN_ACTIVE_MASTER_MAX_EDR] = 50,
  74                         [CONF_SG_ACL_WLAN_ACTIVE_SLAVE_MIN_EDR] = 28,
  75                         [CONF_SG_ACL_WLAN_ACTIVE_SLAVE_MAX_EDR] = 50,
  76                         [CONF_SG_ACL_ACTIVE_SCAN_WLAN_BR] = 10,
  77                         [CONF_SG_ACL_ACTIVE_SCAN_WLAN_EDR] = 20,
  78                         [CONF_SG_ACL_PASSIVE_SCAN_BT_BR] = 75,
  79                         [CONF_SG_ACL_PASSIVE_SCAN_WLAN_BR] = 15,
  80                         [CONF_SG_ACL_PASSIVE_SCAN_BT_EDR] = 27,
  81                         [CONF_SG_ACL_PASSIVE_SCAN_WLAN_EDR] = 17,
  82                         /* active scan params */
  83                         [CONF_SG_AUTO_SCAN_PROBE_REQ] = 170,
  84                         [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3] = 50,
  85                         [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP] = 100,
  86                         /* passive scan params */
  87                         [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP_BR] = 800,
  88                         [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP_EDR] = 200,
  89                         [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3] = 200,
  90                         /* passive scan in dual antenna params */
  91                         [CONF_SG_CONSECUTIVE_HV3_IN_PASSIVE_SCAN] = 0,
  92                         [CONF_SG_BCN_HV3_COLLISION_THRESH_IN_PASSIVE_SCAN] = 0,
  93                         [CONF_SG_TX_RX_PROTECTION_BWIDTH_IN_PASSIVE_SCAN] = 0,
  94                         /* general params */
  95                         [CONF_SG_STA_FORCE_PS_IN_BT_SCO] = 1,
  96                         [CONF_SG_ANTENNA_CONFIGURATION] = 0,
  97                         [CONF_SG_BEACON_MISS_PERCENT] = 60,
  98                         [CONF_SG_DHCP_TIME] = 5000,
  99                         [CONF_SG_RXT] = 1200,
 100                         [CONF_SG_TXT] = 1000,
 101                         [CONF_SG_ADAPTIVE_RXT_TXT] = 1,
 102                         [CONF_SG_GENERAL_USAGE_BIT_MAP] = 3,
 103                         [CONF_SG_HV3_MAX_SERVED] = 6,
 104                         [CONF_SG_PS_POLL_TIMEOUT] = 10,
 105                         [CONF_SG_UPSD_TIMEOUT] = 10,
 106                         [CONF_SG_CONSECUTIVE_CTS_THRESHOLD] = 2,
 107                         [CONF_SG_STA_RX_WINDOW_AFTER_DTIM] = 5,
 108                         [CONF_SG_STA_CONNECTION_PROTECTION_TIME] = 30,
 109                         /* AP params */
 110                         [CONF_AP_BEACON_MISS_TX] = 3,
 111                         [CONF_AP_RX_WINDOW_AFTER_BEACON] = 10,
 112                         [CONF_AP_BEACON_WINDOW_INTERVAL] = 2,
 113                         [CONF_AP_CONNECTION_PROTECTION_TIME] = 0,
 114                         [CONF_AP_BT_ACL_VAL_BT_SERVE_TIME] = 25,
 115                         [CONF_AP_BT_ACL_VAL_WL_SERVE_TIME] = 25,
 116                 },
 117                 .state = CONF_SG_PROTECTIVE,
 118         },
 119         .rx = {
 120                 .rx_msdu_life_time           = 512000,
 121                 .packet_detection_threshold  = 0,
 122                 .ps_poll_timeout             = 15,
 123                 .upsd_timeout                = 15,
 124                 .rts_threshold               = IEEE80211_MAX_RTS_THRESHOLD,
 125                 .rx_cca_threshold            = 0,
 126                 .irq_blk_threshold           = 0xFFFF,
 127                 .irq_pkt_threshold           = 0,
 128                 .irq_timeout                 = 600,
 129                 .queue_type                  = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
 130         },
 131         .tx = {
 132                 .tx_energy_detection         = 0,
 133                 .sta_rc_conf                 = {
 134                         .enabled_rates       = 0,
 135                         .short_retry_limit   = 10,
 136                         .long_retry_limit    = 10,
 137                         .aflags              = 0,
 138                 },
 139                 .ac_conf_count               = 4,
 140                 .ac_conf                     = {
 141                         [CONF_TX_AC_BE] = {
 142                                 .ac          = CONF_TX_AC_BE,
 143                                 .cw_min      = 15,
 144                                 .cw_max      = 63,
 145                                 .aifsn       = 3,
 146                                 .tx_op_limit = 0,
 147                         },
 148                         [CONF_TX_AC_BK] = {
 149                                 .ac          = CONF_TX_AC_BK,
 150                                 .cw_min      = 15,
 151                                 .cw_max      = 63,
 152                                 .aifsn       = 7,
 153                                 .tx_op_limit = 0,
 154                         },
 155                         [CONF_TX_AC_VI] = {
 156                                 .ac          = CONF_TX_AC_VI,
 157                                 .cw_min      = 15,
 158                                 .cw_max      = 63,
 159                                 .aifsn       = CONF_TX_AIFS_PIFS,
 160                                 .tx_op_limit = 3008,
 161                         },
 162                         [CONF_TX_AC_VO] = {
 163                                 .ac          = CONF_TX_AC_VO,
 164                                 .cw_min      = 15,
 165                                 .cw_max      = 63,
 166                                 .aifsn       = CONF_TX_AIFS_PIFS,
 167                                 .tx_op_limit = 1504,
 168                         },
 169                 },
 170                 .max_tx_retries = 100,
 171                 .ap_aging_period = 300,
 172                 .tid_conf_count = 4,
 173                 .tid_conf = {
 174                         [CONF_TX_AC_BE] = {
 175                                 .queue_id    = CONF_TX_AC_BE,
 176                                 .channel_type = CONF_CHANNEL_TYPE_EDCF,
 177                                 .tsid        = CONF_TX_AC_BE,
 178                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
 179                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
 180                                 .apsd_conf   = {0, 0},
 181                         },
 182                         [CONF_TX_AC_BK] = {
 183                                 .queue_id    = CONF_TX_AC_BK,
 184                                 .channel_type = CONF_CHANNEL_TYPE_EDCF,
 185                                 .tsid        = CONF_TX_AC_BK,
 186                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
 187                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
 188                                 .apsd_conf   = {0, 0},
 189                         },
 190                         [CONF_TX_AC_VI] = {
 191                                 .queue_id    = CONF_TX_AC_VI,
 192                                 .channel_type = CONF_CHANNEL_TYPE_EDCF,
 193                                 .tsid        = CONF_TX_AC_VI,
 194                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
 195                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
 196                                 .apsd_conf   = {0, 0},
 197                         },
 198                         [CONF_TX_AC_VO] = {
 199                                 .queue_id    = CONF_TX_AC_VO,
 200                                 .channel_type = CONF_CHANNEL_TYPE_EDCF,
 201                                 .tsid        = CONF_TX_AC_VO,
 202                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
 203                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
 204                                 .apsd_conf   = {0, 0},
 205                         },
 206                 },
 207                 .frag_threshold              = IEEE80211_MAX_FRAG_THRESHOLD,
 208                 .tx_compl_timeout            = 700,
 209                 .tx_compl_threshold          = 4,
 210                 .basic_rate                  = CONF_HW_BIT_RATE_1MBPS,
 211                 .basic_rate_5                = CONF_HW_BIT_RATE_6MBPS,
 212                 .tmpl_short_retry_limit      = 10,
 213                 .tmpl_long_retry_limit       = 10,
 214         },
 215         .conn = {
 216                 .wake_up_event               = CONF_WAKE_UP_EVENT_DTIM,
 217                 .listen_interval             = 1,
 218                 .bcn_filt_mode               = CONF_BCN_FILT_MODE_ENABLED,
 219                 .bcn_filt_ie_count           = 2,
 220                 .bcn_filt_ie = {
 221                         [0] = {
 222                                 .ie          = WLAN_EID_CHANNEL_SWITCH,
 223                                 .rule        = CONF_BCN_RULE_PASS_ON_APPEARANCE,
 224                         },
 225                         [1] = {
 226                                 .ie          = WLAN_EID_HT_INFORMATION,
 227                                 .rule        = CONF_BCN_RULE_PASS_ON_CHANGE,
 228                         },
 229                 },
 230                 .synch_fail_thold            = 10,
 231                 .bss_lose_timeout            = 100,
 232                 .beacon_rx_timeout           = 10000,
 233                 .broadcast_timeout           = 20000,
 234                 .rx_broadcast_in_ps          = 1,
 235                 .ps_poll_threshold           = 10,
 236                 .ps_poll_recovery_period     = 700,
 237                 .bet_enable                  = CONF_BET_MODE_ENABLE,
 238                 .bet_max_consecutive         = 50,
 239                 .psm_entry_retries           = 5,
 240                 .psm_exit_retries            = 16,
 241                 .psm_entry_nullfunc_retries  = 3,
 242                 .psm_entry_hangover_period   = 1,
 243                 .keep_alive_interval         = 55000,
 244                 .max_listen_interval         = 20,
 245         },
 246         .itrim = {
 247                 .enable = false,
 248                 .timeout = 50000,
 249         },
 250         .pm_config = {
 251                 .host_clk_settling_time = 5000,
 252                 .host_fast_wakeup_support = false
 253         },
 254         .roam_trigger = {
 255                 .trigger_pacing               = 1,
 256                 .avg_weight_rssi_beacon       = 20,
 257                 .avg_weight_rssi_data         = 10,
 258                 .avg_weight_snr_beacon        = 20,
 259                 .avg_weight_snr_data          = 10,
 260         },
 261         .scan = {
 262                 .min_dwell_time_active        = 7500,
 263                 .max_dwell_time_active        = 30000,
 264                 .min_dwell_time_passive       = 100000,
 265                 .max_dwell_time_passive       = 100000,
 266                 .num_probe_reqs               = 2,
 267         },
 268         .sched_scan = {
 269                 /* sched_scan requires dwell times in TU instead of TU/1000 */
 270                 .min_dwell_time_active = 8,
 271                 .max_dwell_time_active = 30,
 272                 .dwell_time_passive    = 100,
 273                 .dwell_time_dfs        = 150,
 274                 .num_probe_reqs        = 2,
 275                 .rssi_threshold        = -90,
 276                 .snr_threshold         = 0,
 277         },
 278         .rf = {
 279                 .tx_per_channel_power_compensation_2 = {
 280                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 281                 },
 282                 .tx_per_channel_power_compensation_5 = {
 283                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 284                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 285                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 286                 },
 287         },
 288         .ht = {
 289                 .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         else
2206                 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
2207 }
2208
2209 static bool wl12xx_is_roc(struct wl1271 *wl)
2210 {
2211         u8 role_id;
2212
2213         role_id = find_first_bit(wl->roc_map, WL12XX_MAX_ROLES);
2214         if (role_id >= WL12XX_MAX_ROLES)
2215                 return false;
2216
2217         return true;
2218 }
2219
2220 static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle)
2221 {
2222         int ret;
2223
2224         if (idle) {
2225                 /* no need to croc if we weren't busy (e.g. during boot) */
2226                 if (wl12xx_is_roc(wl)) {
2227                         ret = wl12xx_croc(wl, wl->dev_role_id);
2228                         if (ret < 0)
2229                                 goto out;
2230
2231                         ret = wl12xx_cmd_role_stop_dev(wl);
2232                         if (ret < 0)
2233                                 goto out;
2234                 }
2235                 wl->rate_set = wl1271_tx_min_rate_get(wl);
2236                 ret = wl1271_acx_sta_rate_policies(wl);
2237                 if (ret < 0)
2238                         goto out;
2239                 ret = wl1271_acx_keep_alive_config(
2240                         wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
2241                         ACX_KEEP_ALIVE_TPL_INVALID);
2242                 if (ret < 0)
2243                         goto out;
2244                 set_bit(WL1271_FLAG_IDLE, &wl->flags);
2245         } else {
2246                 /* The current firmware only supports sched_scan in idle */
2247                 if (wl->sched_scanning) {
2248                         wl1271_scan_sched_scan_stop(wl);
2249                         ieee80211_sched_scan_stopped(wl->hw);
2250                 }
2251
2252                 ret = wl12xx_cmd_role_start_dev(wl);
2253                 if (ret < 0)
2254                         goto out;
2255
2256                 ret = wl12xx_roc(wl, wl->dev_role_id);
2257                 if (ret < 0)
2258                         goto out;
2259                 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
2260         }
2261
2262 out:
2263         return ret;
2264 }
2265
2266 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
2267 {
2268         struct wl1271 *wl = hw->priv;
2269         struct ieee80211_conf *conf = &hw->conf;
2270         int channel, ret = 0;
2271         bool is_ap;
2272
2273         channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
2274
2275         wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
2276                      " changed 0x%x",
2277                      channel,
2278                      conf->flags & IEEE80211_CONF_PS ? "on" : "off",
2279                      conf->power_level,
2280                      conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
2281                          changed);
2282
2283         /*
2284          * mac80211 will go to idle nearly immediately after transmitting some
2285          * frames, such as the deauth. To make sure those frames reach the air,
2286          * wait here until the TX queue is fully flushed.
2287          */
2288         if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
2289             (conf->flags & IEEE80211_CONF_IDLE))
2290                 wl1271_tx_flush(wl);
2291
2292         mutex_lock(&wl->mutex);
2293
2294         if (unlikely(wl->state == WL1271_STATE_OFF)) {
2295                 /* we support configuring the channel and band while off */
2296                 if ((changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
2297                         wl->band = conf->channel->band;
2298                         wl->channel = channel;
2299                 }
2300
2301                 if ((changed & IEEE80211_CONF_CHANGE_POWER))
2302                         wl->power_level = conf->power_level;
2303
2304                 goto out;
2305         }
2306
2307         is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2308
2309         ret = wl1271_ps_elp_wakeup(wl);
2310         if (ret < 0)
2311                 goto out;
2312
2313         /* if the channel changes while joined, join again */
2314         if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
2315             ((wl->band != conf->channel->band) ||
2316              (wl->channel != channel))) {
2317                 wl->band = conf->channel->band;
2318                 wl->channel = channel;
2319
2320                 if (!is_ap) {
2321                         /*
2322                          * FIXME: the mac80211 should really provide a fixed
2323                          * rate to use here. for now, just use the smallest
2324                          * possible rate for the band as a fixed rate for
2325                          * association frames and other control messages.
2326                          */
2327                         if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2328                                 wl1271_set_band_rate(wl);
2329
2330                         wl->basic_rate = wl1271_tx_min_rate_get(wl);
2331                         ret = wl1271_acx_sta_rate_policies(wl);
2332                         if (ret < 0)
2333                                 wl1271_warning("rate policy for channel "
2334                                                "failed %d", ret);
2335
2336                         if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
2337                                 if (wl12xx_is_roc(wl)) {
2338                                         /* roaming */
2339                                         ret = wl12xx_croc(wl, wl->dev_role_id);
2340                                         if (ret < 0)
2341                                                 goto out_sleep;
2342                                 }
2343                                 ret = wl1271_join(wl, false);
2344                                 if (ret < 0)
2345                                         wl1271_warning("cmd join on channel "
2346                                                        "failed %d", ret);
2347                         } else {
2348                                 /*
2349                                  * change the ROC channel. do it only if we are
2350                                  * not idle. otherwise, CROC will be called
2351                                  * anyway.
2352                                  */
2353                                 if (wl12xx_is_roc(wl) &&
2354                                     !(conf->flags & IEEE80211_CONF_IDLE)) {
2355                                         ret = wl12xx_croc(wl, wl->dev_role_id);
2356                                         if (ret < 0)
2357                                                 goto out_sleep;
2358
2359                                         ret = wl12xx_roc(wl, wl->dev_role_id);
2360                                         if (ret < 0)
2361                                                 wl1271_warning("roc failed %d",
2362                                                                ret);
2363                                 }
2364                         }
2365                 }
2366         }
2367
2368         if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
2369                 ret = wl1271_sta_handle_idle(wl,
2370                                         conf->flags & IEEE80211_CONF_IDLE);
2371                 if (ret < 0)
2372                         wl1271_warning("idle mode change failed %d", ret);
2373         }
2374
2375         /*
2376          * if mac80211 changes the PSM mode, make sure the mode is not
2377          * incorrectly changed after the pspoll failure active window.
2378          */
2379         if (changed & IEEE80211_CONF_CHANGE_PS)
2380                 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
2381
2382         if (conf->flags & IEEE80211_CONF_PS &&
2383             !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
2384                 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
2385
2386                 /*
2387                  * We enter PSM only if we're already associated.
2388                  * If we're not, we'll enter it when joining an SSID,
2389                  * through the bss_info_changed() hook.
2390                  */
2391                 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
2392                         wl1271_debug(DEBUG_PSM, "psm enabled");
2393                         ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
2394                                                  wl->basic_rate, true);
2395                 }
2396         } else if (!(conf->flags & IEEE80211_CONF_PS) &&
2397                    test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
2398                 wl1271_debug(DEBUG_PSM, "psm disabled");
2399
2400                 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
2401
2402                 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
2403                         ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
2404                                                  wl->basic_rate, true);
2405         }
2406
2407         if (conf->power_level != wl->power_level) {
2408                 ret = wl1271_acx_tx_power(wl, conf->power_level);
2409                 if (ret < 0)
2410                         goto out_sleep;
2411
2412                 wl->power_level = conf->power_level;
2413         }
2414
2415 out_sleep:
2416         wl1271_ps_elp_sleep(wl);
2417
2418 out:
2419         mutex_unlock(&wl->mutex);
2420
2421         return ret;
2422 }
2423
2424 struct wl1271_filter_params {
2425         bool enabled;
2426         int mc_list_length;
2427         u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
2428 };
2429
2430 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
2431                                        struct netdev_hw_addr_list *mc_list)
2432 {
2433         struct wl1271_filter_params *fp;
2434         struct netdev_hw_addr *ha;
2435         struct wl1271 *wl = hw->priv;
2436
2437         if (unlikely(wl->state == WL1271_STATE_OFF))
2438                 return 0;
2439
2440         fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
2441         if (!fp) {
2442                 wl1271_error("Out of memory setting filters.");
2443                 return 0;
2444         }
2445
2446         /* update multicast filtering parameters */
2447         fp->mc_list_length = 0;
2448         if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
2449                 fp->enabled = false;
2450         } else {
2451                 fp->enabled = true;
2452                 netdev_hw_addr_list_for_each(ha, mc_list) {
2453                         memcpy(fp->mc_list[fp->mc_list_length],
2454                                         ha->addr, ETH_ALEN);
2455                         fp->mc_list_length++;
2456                 }
2457         }
2458
2459         return (u64)(unsigned long)fp;
2460 }
2461
2462 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
2463                                   FIF_ALLMULTI | \
2464                                   FIF_FCSFAIL | \
2465                                   FIF_BCN_PRBRESP_PROMISC | \
2466                                   FIF_CONTROL | \
2467                                   FIF_OTHER_BSS)
2468
2469 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
2470                                        unsigned int changed,
2471                                        unsigned int *total, u64 multicast)
2472 {
2473         struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
2474         struct wl1271 *wl = hw->priv;
2475         int ret;
2476
2477         wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
2478                      " total %x", changed, *total);
2479
2480         mutex_lock(&wl->mutex);
2481
2482         *total &= WL1271_SUPPORTED_FILTERS;
2483         changed &= WL1271_SUPPORTED_FILTERS;
2484
2485         if (unlikely(wl->state == WL1271_STATE_OFF))
2486                 goto out;
2487
2488         ret = wl1271_ps_elp_wakeup(wl);
2489         if (ret < 0)
2490                 goto out;
2491
2492         if (wl->bss_type != BSS_TYPE_AP_BSS) {
2493                 if (*total & FIF_ALLMULTI)
2494                         ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
2495                 else if (fp)
2496                         ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
2497                                                            fp->mc_list,
2498                                                            fp->mc_list_length);
2499                 if (ret < 0)
2500                         goto out_sleep;
2501         }
2502
2503         /*
2504          * the fw doesn't provide an api to configure the filters. instead,
2505          * the filters configuration is based on the active roles / ROC
2506          * state.
2507          */
2508
2509 out_sleep:
2510         wl1271_ps_elp_sleep(wl);
2511
2512 out:
2513         mutex_unlock(&wl->mutex);
2514         kfree(fp);
2515 }
2516
2517 static int wl1271_record_ap_key(struct wl1271 *wl, u8 id, u8 key_type,
2518                         u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
2519                         u16 tx_seq_16)
2520 {
2521         struct wl1271_ap_key *ap_key;
2522         int i;
2523
2524         wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
2525
2526         if (key_size > MAX_KEY_SIZE)
2527                 return -EINVAL;
2528
2529         /*
2530          * Find next free entry in ap_keys. Also check we are not replacing
2531          * an existing key.
2532          */
2533         for (i = 0; i < MAX_NUM_KEYS; i++) {
2534                 if (wl->recorded_ap_keys[i] == NULL)
2535                         break;
2536
2537                 if (wl->recorded_ap_keys[i]->id == id) {
2538                         wl1271_warning("trying to record key replacement");
2539                         return -EINVAL;
2540                 }
2541         }
2542
2543         if (i == MAX_NUM_KEYS)
2544                 return -EBUSY;
2545
2546         ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
2547         if (!ap_key)
2548                 return -ENOMEM;
2549
2550         ap_key->id = id;
2551         ap_key->key_type = key_type;
2552         ap_key->key_size = key_size;
2553         memcpy(ap_key->key, key, key_size);
2554         ap_key->hlid = hlid;
2555         ap_key->tx_seq_32 = tx_seq_32;
2556         ap_key->tx_seq_16 = tx_seq_16;
2557
2558         wl->recorded_ap_keys[i] = ap_key;
2559         return 0;
2560 }
2561
2562 static void wl1271_free_ap_keys(struct wl1271 *wl)
2563 {
2564         int i;
2565
2566         for (i = 0; i < MAX_NUM_KEYS; i++) {
2567                 kfree(wl->recorded_ap_keys[i]);
2568                 wl->recorded_ap_keys[i] = NULL;
2569         }
2570 }
2571
2572 static int wl1271_ap_init_hwenc(struct wl1271 *wl)
2573 {
2574         int i, ret = 0;
2575         struct wl1271_ap_key *key;
2576         bool wep_key_added = false;
2577
2578         for (i = 0; i < MAX_NUM_KEYS; i++) {
2579                 u8 hlid;
2580                 if (wl->recorded_ap_keys[i] == NULL)
2581                         break;
2582
2583                 key = wl->recorded_ap_keys[i];
2584                 hlid = key->hlid;
2585                 if (hlid == WL12XX_INVALID_LINK_ID)
2586                         hlid = wl->ap_bcast_hlid;
2587
2588                 ret = wl1271_cmd_set_ap_key(wl, KEY_ADD_OR_REPLACE,
2589                                             key->id, key->key_type,
2590                                             key->key_size, key->key,
2591                                             hlid, key->tx_seq_32,
2592                                             key->tx_seq_16);
2593                 if (ret < 0)
2594                         goto out;
2595
2596                 if (key->key_type == KEY_WEP)
2597                         wep_key_added = true;
2598         }
2599
2600         if (wep_key_added) {
2601                 ret = wl12xx_cmd_set_default_wep_key(wl, wl->default_key,
2602                                                      wl->ap_bcast_hlid);
2603                 if (ret < 0)
2604                         goto out;
2605         }
2606
2607 out:
2608         wl1271_free_ap_keys(wl);
2609         return ret;
2610 }
2611
2612 static int wl1271_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
2613                        u8 key_size, const u8 *key, u32 tx_seq_32,
2614                        u16 tx_seq_16, struct ieee80211_sta *sta)
2615 {
2616         int ret;
2617         bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2618
2619         if (is_ap) {
2620                 struct wl1271_station *wl_sta;
2621                 u8 hlid;
2622
2623                 if (sta) {
2624                         wl_sta = (struct wl1271_station *)sta->drv_priv;
2625                         hlid = wl_sta->hlid;
2626                 } else {
2627                         hlid = wl->ap_bcast_hlid;
2628                 }
2629
2630                 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2631                         /*
2632                          * We do not support removing keys after AP shutdown.
2633                          * Pretend we do to make mac80211 happy.
2634                          */
2635                         if (action != KEY_ADD_OR_REPLACE)
2636                                 return 0;
2637
2638                         ret = wl1271_record_ap_key(wl, id,
2639                                              key_type, key_size,
2640                                              key, hlid, tx_seq_32,
2641                                              tx_seq_16);
2642                 } else {
2643                         ret = wl1271_cmd_set_ap_key(wl, action,
2644                                              id, key_type, key_size,
2645                                              key, hlid, tx_seq_32,
2646                                              tx_seq_16);
2647                 }
2648
2649                 if (ret < 0)
2650                         return ret;
2651         } else {
2652                 const u8 *addr;
2653                 static const u8 bcast_addr[ETH_ALEN] = {
2654                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2655                 };
2656
2657                 /*
2658                  * A STA set to GEM cipher requires 2 tx spare blocks.
2659                  * Return to default value when GEM cipher key is removed
2660                  */
2661                 if (key_type == KEY_GEM) {
2662                         if (action == KEY_ADD_OR_REPLACE)
2663                                 wl->tx_spare_blocks = 2;
2664                         else if (action == KEY_REMOVE)
2665                                 wl->tx_spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
2666                 }
2667
2668                 addr = sta ? sta->addr : bcast_addr;
2669
2670                 if (is_zero_ether_addr(addr)) {
2671                         /* We dont support TX only encryption */
2672                         return -EOPNOTSUPP;
2673                 }
2674
2675                 /* The wl1271 does not allow to remove unicast keys - they
2676                    will be cleared automatically on next CMD_JOIN. Ignore the
2677                    request silently, as we dont want the mac80211 to emit
2678                    an error message. */
2679                 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
2680                         return 0;
2681
2682                 /* don't remove key if hlid was already deleted */
2683                 if (action == KEY_REMOVE &&
2684                     wl->sta_hlid == WL12XX_INVALID_LINK_ID)
2685                         return 0;
2686
2687                 ret = wl1271_cmd_set_sta_key(wl, action,
2688                                              id, key_type, key_size,
2689                                              key, addr, tx_seq_32,
2690                                              tx_seq_16);
2691                 if (ret < 0)
2692                         return ret;
2693
2694                 /* the default WEP key needs to be configured at least once */
2695                 if (key_type == KEY_WEP) {
2696                         ret = wl12xx_cmd_set_default_wep_key(wl,
2697                                                              wl->default_key,
2698                                                              wl->sta_hlid);
2699                         if (ret < 0)
2700                                 return ret;
2701                 }
2702         }
2703
2704         return 0;
2705 }
2706
2707 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2708                              struct ieee80211_vif *vif,
2709                              struct ieee80211_sta *sta,
2710                              struct ieee80211_key_conf *key_conf)
2711 {
2712         struct wl1271 *wl = hw->priv;
2713         int ret;
2714         u32 tx_seq_32 = 0;
2715         u16 tx_seq_16 = 0;
2716         u8 key_type;
2717
2718         wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
2719
2720         wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
2721         wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
2722                      key_conf->cipher, key_conf->keyidx,
2723                      key_conf->keylen, key_conf->flags);
2724         wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
2725
2726         mutex_lock(&wl->mutex);
2727
2728         if (unlikely(wl->state == WL1271_STATE_OFF)) {
2729                 ret = -EAGAIN;
2730                 goto out_unlock;
2731         }
2732
2733         ret = wl1271_ps_elp_wakeup(wl);
2734         if (ret < 0)
2735                 goto out_unlock;
2736
2737         switch (key_conf->cipher) {
2738         case WLAN_CIPHER_SUITE_WEP40:
2739         case WLAN_CIPHER_SUITE_WEP104:
2740                 key_type = KEY_WEP;
2741
2742                 key_conf->hw_key_idx = key_conf->keyidx;
2743                 break;
2744         case WLAN_CIPHER_SUITE_TKIP:
2745                 key_type = KEY_TKIP;
2746
2747                 key_conf->hw_key_idx = key_conf->keyidx;
2748                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2749                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2750                 break;
2751         case WLAN_CIPHER_SUITE_CCMP:
2752                 key_type = KEY_AES;
2753
2754                 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
2755                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2756                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2757                 break;
2758         case WL1271_CIPHER_SUITE_GEM:
2759                 key_type = KEY_GEM;
2760                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2761                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2762                 break;
2763         default:
2764                 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
2765
2766                 ret = -EOPNOTSUPP;
2767                 goto out_sleep;
2768         }
2769
2770         switch (cmd) {
2771         case SET_KEY:
2772                 ret = wl1271_set_key(wl, KEY_ADD_OR_REPLACE,
2773                                  key_conf->keyidx, key_type,
2774                                  key_conf->keylen, key_conf->key,
2775                                  tx_seq_32, tx_seq_16, sta);
2776                 if (ret < 0) {
2777                         wl1271_error("Could not add or replace key");
2778                         goto out_sleep;
2779                 }
2780                 break;
2781
2782         case DISABLE_KEY:
2783                 ret = wl1271_set_key(wl, KEY_REMOVE,
2784                                      key_conf->keyidx, key_type,
2785                                      key_conf->keylen, key_conf->key,
2786                                      0, 0, sta);
2787                 if (ret < 0) {
2788                         wl1271_error("Could not remove key");
2789                         goto out_sleep;
2790                 }
2791                 break;
2792
2793         default:
2794                 wl1271_error("Unsupported key cmd 0x%x", cmd);
2795                 ret = -EOPNOTSUPP;
2796                 break;
2797         }
2798
2799 out_sleep:
2800         wl1271_ps_elp_sleep(wl);
2801
2802 out_unlock:
2803         mutex_unlock(&wl->mutex);
2804
2805         return ret;
2806 }
2807
2808 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
2809                              struct ieee80211_vif *vif,
2810                              struct cfg80211_scan_request *req)
2811 {
2812         struct wl1271 *wl = hw->priv;
2813         int ret;
2814         u8 *ssid = NULL;
2815         size_t len = 0;
2816
2817         wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
2818
2819         if (req->n_ssids) {
2820                 ssid = req->ssids[0].ssid;
2821                 len = req->ssids[0].ssid_len;
2822         }
2823
2824         mutex_lock(&wl->mutex);
2825
2826         if (wl->state == WL1271_STATE_OFF) {
2827                 /*
2828                  * We cannot return -EBUSY here because cfg80211 will expect
2829                  * a call to ieee80211_scan_completed if we do - in this case
2830                  * there won't be any call.
2831                  */
2832                 ret = -EAGAIN;
2833                 goto out;
2834         }
2835
2836         ret = wl1271_ps_elp_wakeup(wl);
2837         if (ret < 0)
2838                 goto out;
2839
2840         /* cancel ROC before scanning */
2841         if (wl12xx_is_roc(wl)) {
2842                 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
2843                         /* don't allow scanning right now */
2844                         ret = -EBUSY;
2845                         goto out_sleep;
2846                 }
2847                 wl12xx_croc(wl, wl->dev_role_id);
2848                 wl12xx_cmd_role_stop_dev(wl);
2849         }
2850
2851         ret = wl1271_scan(hw->priv, ssid, len, req);
2852 out_sleep:
2853         wl1271_ps_elp_sleep(wl);
2854 out:
2855         mutex_unlock(&wl->mutex);
2856
2857         return ret;
2858 }
2859
2860 static void wl1271_op_cancel_hw_scan(struct ieee80211_hw *hw,
2861                                      struct ieee80211_vif *vif)
2862 {
2863         struct wl1271 *wl = hw->priv;
2864         int ret;
2865
2866         wl1271_debug(DEBUG_MAC80211, "mac80211 cancel hw scan");
2867
2868         mutex_lock(&wl->mutex);
2869
2870         if (wl->state == WL1271_STATE_OFF)
2871                 goto out;
2872
2873         if (wl->scan.state == WL1271_SCAN_STATE_IDLE)
2874                 goto out;
2875
2876         ret = wl1271_ps_elp_wakeup(wl);
2877         if (ret < 0)
2878                 goto out;
2879
2880         if (wl->scan.state != WL1271_SCAN_STATE_DONE) {
2881                 ret = wl1271_scan_stop(wl);
2882                 if (ret < 0)
2883                         goto out_sleep;
2884         }
2885         wl->scan.state = WL1271_SCAN_STATE_IDLE;
2886         memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
2887         wl->scan.req = NULL;
2888         ieee80211_scan_completed(wl->hw, true);
2889
2890 out_sleep:
2891         wl1271_ps_elp_sleep(wl);
2892 out:
2893         mutex_unlock(&wl->mutex);
2894
2895         cancel_delayed_work_sync(&wl->scan_complete_work);
2896 }
2897
2898 static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
2899                                       struct ieee80211_vif *vif,
2900                                       struct cfg80211_sched_scan_request *req,
2901                                       struct ieee80211_sched_scan_ies *ies)
2902 {
2903         struct wl1271 *wl = hw->priv;
2904         int ret;
2905
2906         wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");
2907
2908         mutex_lock(&wl->mutex);
2909
2910         ret = wl1271_ps_elp_wakeup(wl);
2911         if (ret < 0)
2912                 goto out;
2913
2914         ret = wl1271_scan_sched_scan_config(wl, req, ies);
2915         if (ret < 0)
2916                 goto out_sleep;
2917
2918         ret = wl1271_scan_sched_scan_start(wl);
2919         if (ret < 0)
2920                 goto out_sleep;
2921
2922         wl->sched_scanning = true;
2923
2924 out_sleep:
2925         wl1271_ps_elp_sleep(wl);
2926 out:
2927         mutex_unlock(&wl->mutex);
2928         return ret;
2929 }
2930
2931 static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
2932                                       struct ieee80211_vif *vif)
2933 {
2934         struct wl1271 *wl = hw->priv;
2935         int ret;
2936
2937         wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");
2938
2939         mutex_lock(&wl->mutex);
2940
2941         ret = wl1271_ps_elp_wakeup(wl);
2942         if (ret < 0)
2943                 goto out;
2944
2945         wl1271_scan_sched_scan_stop(wl);
2946
2947         wl1271_ps_elp_sleep(wl);
2948 out:
2949         mutex_unlock(&wl->mutex);
2950 }
2951
2952 static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
2953 {
2954         struct wl1271 *wl = hw->priv;
2955         int ret = 0;
2956
2957         mutex_lock(&wl->mutex);
2958
2959         if (unlikely(wl->state == WL1271_STATE_OFF)) {
2960                 ret = -EAGAIN;
2961                 goto out;
2962         }
2963
2964         ret = wl1271_ps_elp_wakeup(wl);
2965         if (ret < 0)
2966                 goto out;
2967
2968         ret = wl1271_acx_frag_threshold(wl, value);
2969         if (ret < 0)
2970                 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
2971
2972         wl1271_ps_elp_sleep(wl);
2973
2974 out:
2975         mutex_unlock(&wl->mutex);
2976
2977         return ret;
2978 }
2979
2980 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
2981 {
2982         struct wl1271 *wl = hw->priv;
2983         int ret = 0;
2984
2985         mutex_lock(&wl->mutex);
2986
2987         if (unlikely(wl->state == WL1271_STATE_OFF)) {
2988                 ret = -EAGAIN;
2989                 goto out;
2990         }
2991
2992         ret = wl1271_ps_elp_wakeup(wl);
2993         if (ret < 0)
2994                 goto out;
2995
2996         ret = wl1271_acx_rts_threshold(wl, value);
2997         if (ret < 0)
2998                 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
2999
3000         wl1271_ps_elp_sleep(wl);
3001
3002 out:
3003         mutex_unlock(&wl->mutex);
3004
3005         return ret;
3006 }
3007
3008 static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
3009                             int offset)
3010 {
3011         u8 ssid_len;
3012         const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
3013                                          skb->len - offset);
3014
3015         if (!ptr) {
3016                 wl1271_error("No SSID in IEs!");
3017                 return -ENOENT;
3018         }
3019
3020         ssid_len = ptr[1];
3021         if (ssid_len > IEEE80211_MAX_SSID_LEN) {
3022                 wl1271_error("SSID is too long!");
3023                 return -EINVAL;
3024         }
3025
3026         wl->ssid_len = ssid_len;
3027         memcpy(wl->ssid, ptr+2, ssid_len);
3028         return 0;
3029 }
3030
3031 static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
3032                                        struct ieee80211_bss_conf *bss_conf,
3033                                        u32 changed)
3034 {
3035         int ret = 0;
3036
3037         if (changed & BSS_CHANGED_ERP_SLOT) {
3038                 if (bss_conf->use_short_slot)
3039                         ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
3040                 else
3041                         ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
3042                 if (ret < 0) {
3043                         wl1271_warning("Set slot time failed %d", ret);
3044                         goto out;
3045                 }
3046         }
3047
3048         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3049                 if (bss_conf->use_short_preamble)
3050                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
3051                 else
3052                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
3053         }
3054
3055         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
3056                 if (bss_conf->use_cts_prot)
3057                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
3058                 else
3059                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
3060                 if (ret < 0) {
3061                         wl1271_warning("Set ctsprotect failed %d", ret);
3062                         goto out;
3063                 }
3064         }
3065
3066 out:
3067         return ret;
3068 }
3069
3070 static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
3071                                           struct ieee80211_vif *vif,
3072                                           struct ieee80211_bss_conf *bss_conf,
3073                                           u32 changed)
3074 {
3075         bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
3076         int ret = 0;
3077
3078         if ((changed & BSS_CHANGED_BEACON_INT)) {
3079                 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
3080                         bss_conf->beacon_int);
3081
3082                 wl->beacon_int = bss_conf->beacon_int;
3083         }
3084
3085         if ((changed & BSS_CHANGED_BEACON)) {
3086                 struct ieee80211_hdr *hdr;
3087                 int ieoffset = offsetof(struct ieee80211_mgmt,
3088                                         u.beacon.variable);
3089                 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
3090                 u16 tmpl_id;
3091
3092                 if (!beacon)
3093                         goto out;
3094
3095                 wl1271_debug(DEBUG_MASTER, "beacon updated");
3096
3097                 ret = wl1271_ssid_set(wl, beacon, ieoffset);
3098                 if (ret < 0) {
3099                         dev_kfree_skb(beacon);
3100                         goto out;
3101                 }
3102                 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
3103                                   CMD_TEMPL_BEACON;
3104                 ret = wl1271_cmd_template_set(wl, tmpl_id,
3105                                               beacon->data,
3106                                               beacon->len, 0,
3107                                               wl1271_tx_min_rate_get(wl));
3108                 if (ret < 0) {
3109                         dev_kfree_skb(beacon);
3110                         goto out;
3111                 }
3112
3113                 hdr = (struct ieee80211_hdr *) beacon->data;
3114                 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
3115                                                  IEEE80211_STYPE_PROBE_RESP);
3116
3117                 tmpl_id = is_ap ? CMD_TEMPL_AP_PROBE_RESPONSE :
3118                                   CMD_TEMPL_PROBE_RESPONSE;
3119                 ret = wl1271_cmd_template_set(wl,
3120                                               tmpl_id,
3121                                               beacon->data,
3122                                               beacon->len, 0,
3123                                               wl1271_tx_min_rate_get(wl));
3124                 dev_kfree_skb(beacon);
3125                 if (ret < 0)
3126                         goto out;
3127         }
3128
3129 out:
3130         return ret;
3131 }
3132
3133 /* AP mode changes */
3134 static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
3135                                        struct ieee80211_vif *vif,
3136                                        struct ieee80211_bss_conf *bss_conf,
3137                                        u32 changed)
3138 {
3139         int ret = 0;
3140
3141         if ((changed & BSS_CHANGED_BASIC_RATES)) {
3142                 u32 rates = bss_conf->basic_rates;
3143
3144                 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates);
3145                 wl->basic_rate = wl1271_tx_min_rate_get(wl);
3146
3147                 ret = wl1271_init_ap_rates(wl);
3148                 if (ret < 0) {
3149                         wl1271_error("AP rate policy change failed %d", ret);
3150                         goto out;
3151                 }
3152
3153                 ret = wl1271_ap_init_templates(wl);
3154                 if (ret < 0)
3155                         goto out;
3156         }
3157
3158         ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
3159         if (ret < 0)
3160                 goto out;
3161
3162         if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
3163                 if (bss_conf->enable_beacon) {
3164                         if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
3165                                 ret = wl12xx_cmd_role_start_ap(wl);
3166                                 if (ret < 0)
3167                                         goto out;
3168
3169                                 ret = wl1271_ap_init_hwenc(wl);
3170                                 if (ret < 0)
3171                                         goto out;
3172
3173                                 set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
3174                                 wl1271_debug(DEBUG_AP, "started AP");
3175                         }
3176                 } else {
3177                         if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
3178                                 ret = wl12xx_cmd_role_stop_ap(wl);
3179                                 if (ret < 0)
3180                                         goto out;
3181
3182                                 clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
3183                                 wl1271_debug(DEBUG_AP, "stopped AP");
3184                         }
3185                 }
3186         }
3187
3188         ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
3189         if (ret < 0)
3190                 goto out;
3191
3192         /* Handle HT information change */
3193         if ((changed & BSS_CHANGED_HT) &&
3194             (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3195                 ret = wl1271_acx_set_ht_information(wl,
3196                                         bss_conf->ht_operation_mode);
3197                 if (ret < 0) {
3198                         wl1271_warning("Set ht information failed %d", ret);
3199                         goto out;
3200                 }
3201         }
3202
3203 out:
3204         return;
3205 }
3206
3207 /* STA/IBSS mode changes */
3208 static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
3209                                         struct ieee80211_vif *vif,
3210                                         struct ieee80211_bss_conf *bss_conf,
3211                                         u32 changed)
3212 {
3213         bool do_join = false, set_assoc = false;
3214         bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
3215         bool ibss_joined = false;
3216         u32 sta_rate_set = 0;
3217         int ret;
3218         struct ieee80211_sta *sta;
3219         bool sta_exists = false;
3220         struct ieee80211_sta_ht_cap sta_ht_cap;
3221
3222         if (is_ibss) {
3223                 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
3224                                                      changed);
3225                 if (ret < 0)
3226                         goto out;
3227         }
3228
3229         if (changed & BSS_CHANGED_IBSS) {
3230                 if (bss_conf->ibss_joined) {
3231                         set_bit(WL1271_FLAG_IBSS_JOINED, &wl->flags);
3232                         ibss_joined = true;
3233                 } else {
3234                         if (test_and_clear_bit(WL1271_FLAG_IBSS_JOINED,
3235                                                &wl->flags)) {
3236                                 wl1271_unjoin(wl);
3237                                 wl12xx_cmd_role_start_dev(wl);
3238                                 wl12xx_roc(wl, wl->dev_role_id);
3239                         }
3240                 }
3241         }
3242
3243         if ((changed & BSS_CHANGED_BEACON_INT) && ibss_joined)
3244                 do_join = true;
3245
3246         /* Need to update the SSID (for filtering etc) */
3247         if ((changed & BSS_CHANGED_BEACON) && ibss_joined)
3248                 do_join = true;
3249
3250         if ((changed & BSS_CHANGED_BEACON_ENABLED) && ibss_joined) {
3251                 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
3252                              bss_conf->enable_beacon ? "enabled" : "disabled");
3253
3254                 if (bss_conf->enable_beacon)
3255                         wl->set_bss_type = BSS_TYPE_IBSS;
3256                 else
3257                         wl->set_bss_type = BSS_TYPE_STA_BSS;
3258                 do_join = true;
3259         }
3260
3261         if ((changed & BSS_CHANGED_CQM)) {
3262                 bool enable = false;
3263                 if (bss_conf->cqm_rssi_thold)
3264                         enable = true;
3265                 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
3266                                                   bss_conf->cqm_rssi_thold,
3267                                                   bss_conf->cqm_rssi_hyst);
3268                 if (ret < 0)
3269                         goto out;
3270                 wl->rssi_thold = bss_conf->cqm_rssi_thold;
3271         }
3272
3273         if ((changed & BSS_CHANGED_BSSID) &&
3274             /*
3275              * Now we know the correct bssid, so we send a new join command
3276              * and enable the BSSID filter
3277              */
3278             memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
3279                 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
3280
3281                 if (!is_zero_ether_addr(wl->bssid)) {
3282                         ret = wl1271_cmd_build_null_data(wl);
3283                         if (ret < 0)
3284                                 goto out;
3285
3286                         ret = wl1271_build_qos_null_data(wl);
3287                         if (ret < 0)
3288                                 goto out;
3289
3290                         /* Need to update the BSSID (for filtering etc) */
3291                         do_join = true;
3292                 }
3293         }
3294
3295         if (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_HT)) {
3296                 rcu_read_lock();
3297                 sta = ieee80211_find_sta(vif, bss_conf->bssid);
3298                 if (!sta)
3299                         goto sta_not_found;
3300
3301                 /* save the supp_rates of the ap */
3302                 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
3303                 if (sta->ht_cap.ht_supported)
3304                         sta_rate_set |=
3305                             (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
3306                 sta_ht_cap = sta->ht_cap;
3307                 sta_exists = true;
3308
3309 sta_not_found:
3310                 rcu_read_unlock();
3311         }
3312
3313         if ((changed & BSS_CHANGED_ASSOC)) {
3314                 if (bss_conf->assoc) {
3315                         u32 rates;
3316                         int ieoffset;
3317                         wl->aid = bss_conf->aid;
3318                         set_assoc = true;
3319
3320                         wl->ps_poll_failures = 0;
3321
3322                         /*
3323                          * use basic rates from AP, and determine lowest rate
3324                          * to use with control frames.
3325                          */
3326                         rates = bss_conf->basic_rates;
3327                         wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
3328                                                                          rates);
3329                         wl->basic_rate = wl1271_tx_min_rate_get(wl);
3330                         if (sta_rate_set)
3331                                 wl->rate_set = wl1271_tx_enabled_rates_get(wl,
3332                                                                 sta_rate_set);
3333                         ret = wl1271_acx_sta_rate_policies(wl);
3334                         if (ret < 0)
3335                                 goto out;
3336
3337                         /*
3338                          * with wl1271, we don't need to update the
3339                          * beacon_int and dtim_period, because the firmware
3340                          * updates it by itself when the first beacon is
3341                          * received after a join.
3342                          */
3343                         ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
3344                         if (ret < 0)
3345                                 goto out;
3346
3347                         /*
3348                          * Get a template for hardware connection maintenance
3349                          */
3350                         dev_kfree_skb(wl->probereq);
3351                         wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL);
3352                         ieoffset = offsetof(struct ieee80211_mgmt,
3353                                             u.probe_req.variable);
3354                         wl1271_ssid_set(wl, wl->probereq, ieoffset);
3355
3356                         /* enable the connection monitoring feature */
3357                         ret = wl1271_acx_conn_monit_params(wl, true);
3358                         if (ret < 0)
3359                                 goto out;
3360
3361                         /* If we want to go in PSM but we're not there yet */
3362                         if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
3363                             !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
3364                                 enum wl1271_cmd_ps_mode mode;
3365
3366                                 mode = STATION_POWER_SAVE_MODE;
3367                                 ret = wl1271_ps_set_mode(wl, mode,
3368                                                          wl->basic_rate,
3369                                                          true);
3370                                 if (ret < 0)
3371                                         goto out;
3372                         }
3373                 } else {
3374                         /* use defaults when not associated */
3375                         bool was_assoc =
3376                             !!test_and_clear_bit(WL1271_FLAG_STA_ASSOCIATED,
3377                                                  &wl->flags);
3378                         bool was_ifup =
3379                             !!test_and_clear_bit(WL1271_FLAG_STA_STATE_SENT,
3380                                                  &wl->flags);
3381                         wl->aid = 0;
3382
3383                         /* free probe-request template */
3384                         dev_kfree_skb(wl->probereq);
3385                         wl->probereq = NULL;
3386
3387                         /* re-enable dynamic ps - just in case */
3388                         ieee80211_enable_dyn_ps(wl->vif);
3389
3390                         /* revert back to minimum rates for the current band */
3391                         wl1271_set_band_rate(wl);
3392                         wl->basic_rate = wl1271_tx_min_rate_get(wl);
3393                         ret = wl1271_acx_sta_rate_policies(wl);
3394                         if (ret < 0)
3395                                 goto out;
3396
3397                         /* disable connection monitor features */
3398                         ret = wl1271_acx_conn_monit_params(wl, false);
3399
3400                         /* Disable the keep-alive feature */
3401                         ret = wl1271_acx_keep_alive_mode(wl, false);
3402                         if (ret < 0)
3403                                 goto out;
3404
3405                         /* restore the bssid filter and go to dummy bssid */
3406                         if (was_assoc) {
3407                                 u32 conf_flags = wl->hw->conf.flags;
3408                                 /*
3409                                  * we might have to disable roc, if there was
3410                                  * no IF_OPER_UP notification.
3411                                  */
3412                                 if (!was_ifup) {
3413                                         ret = wl12xx_croc(wl, wl->role_id);
3414                                         if (ret < 0)
3415                                                 goto out;
3416                                 }
3417                                 /*
3418                                  * (we also need to disable roc in case of
3419                                  * roaming on the same channel. until we will
3420                                  * have a better flow...)
3421                                  */
3422                                 if (test_bit(wl->dev_role_id, wl->roc_map)) {
3423                                         ret = wl12xx_croc(wl, wl->dev_role_id);
3424                                         if (ret < 0)
3425                                                 goto out;
3426                                 }
3427
3428                                 wl1271_unjoin(wl);
3429                                 if (!(conf_flags & IEEE80211_CONF_IDLE)) {
3430                                         wl12xx_cmd_role_start_dev(wl);
3431                                         wl12xx_roc(wl, wl->dev_role_id);
3432                                 }
3433                         }
3434                 }
3435         }
3436
3437         if (changed & BSS_CHANGED_IBSS) {
3438                 wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
3439                              bss_conf->ibss_joined);
3440
3441                 if (bss_conf->ibss_joined) {
3442                         u32 rates = bss_conf->basic_rates;
3443                         wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
3444                                                                          rates);
3445                         wl->basic_rate = wl1271_tx_min_rate_get(wl);
3446
3447                         /* by default, use 11b rates */
3448                         wl->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
3449                         ret = wl1271_acx_sta_rate_policies(wl);
3450                         if (ret < 0)
3451                                 goto out;
3452                 }
3453         }
3454
3455         ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
3456         if (ret < 0)
3457                 goto out;
3458
3459         if (changed & BSS_CHANGED_ARP_FILTER) {
3460                 __be32 addr = bss_conf->arp_addr_list[0];
3461                 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3462
3463                 if (bss_conf->arp_addr_cnt == 1 &&
3464                     bss_conf->arp_filter_enabled) {
3465                         /*
3466                          * The template should have been configured only upon
3467                          * association. however, it seems that the correct ip
3468                          * isn't being set (when sending), so we have to
3469                          * reconfigure the template upon every ip change.
3470                          */
3471                         ret = wl1271_cmd_build_arp_rsp(wl, addr);
3472                         if (ret < 0) {
3473                                 wl1271_warning("build arp rsp failed: %d", ret);
3474                                 goto out;
3475                         }
3476
3477                         ret = wl1271_acx_arp_ip_filter(wl,
3478                                 ACX_ARP_FILTER_ARP_FILTERING,
3479                                 addr);
3480                 } else
3481                         ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
3482
3483                 if (ret < 0)
3484                         goto out;
3485         }
3486
3487         if (do_join) {
3488                 ret = wl1271_join(wl, set_assoc);
3489                 if (ret < 0) {
3490                         wl1271_warning("cmd join failed %d", ret);
3491                         goto out;
3492                 }
3493
3494                 /* ROC until connected (after EAPOL exchange) */
3495                 if (!is_ibss) {
3496                         ret = wl12xx_roc(wl, wl->role_id);
3497                         if (ret < 0)
3498                                 goto out;
3499
3500                         wl1271_check_operstate(wl,
3501                                                ieee80211_get_operstate(vif));
3502                 }
3503                 /*
3504                  * stop device role if started (we might already be in
3505                  * STA role). TODO: make it better.
3506                  */
3507                 if (wl->dev_role_id != WL12XX_INVALID_ROLE_ID) {
3508                         ret = wl12xx_croc(wl, wl->dev_role_id);
3509                         if (ret < 0)
3510                                 goto out;
3511
3512                         ret = wl12xx_cmd_role_stop_dev(wl);
3513                         if (ret < 0)
3514                                 goto out;
3515                 }
3516         }
3517
3518         /* Handle new association with HT. Do this after join. */
3519         if (sta_exists) {
3520                 if ((changed & BSS_CHANGED_HT) &&
3521                     (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3522                         ret = wl1271_acx_set_ht_capabilities(wl,
3523                                                              &sta_ht_cap,
3524                                                              true,
3525                                                              wl->sta_hlid);
3526                         if (ret < 0) {
3527                                 wl1271_warning("Set ht cap true failed %d",
3528                                                ret);
3529                                 goto out;
3530                         }
3531                 }
3532                 /* handle new association without HT and disassociation */
3533                 else if (changed & BSS_CHANGED_ASSOC) {
3534                         ret = wl1271_acx_set_ht_capabilities(wl,
3535                                                              &sta_ht_cap,
3536                                                              false,
3537                                                              wl->sta_hlid);
3538                         if (ret < 0) {
3539                                 wl1271_warning("Set ht cap false failed %d",
3540                                                ret);
3541                                 goto out;
3542                         }
3543                 }
3544         }
3545
3546         /* Handle HT information change. Done after join. */
3547         if ((changed & BSS_CHANGED_HT) &&
3548             (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3549                 ret = wl1271_acx_set_ht_information(wl,
3550                                         bss_conf->ht_operation_mode);
3551                 if (ret < 0) {
3552                         wl1271_warning("Set ht information failed %d", ret);
3553                         goto out;
3554                 }
3555         }
3556
3557 out:
3558         return;
3559 }
3560
3561 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
3562                                        struct ieee80211_vif *vif,
3563                                        struct ieee80211_bss_conf *bss_conf,
3564                                        u32 changed)
3565 {
3566         struct wl1271 *wl = hw->priv;
3567         bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
3568         int ret;
3569
3570         wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
3571                      (int)changed);
3572
3573         mutex_lock(&wl->mutex);
3574
3575         if (unlikely(wl->state == WL1271_STATE_OFF))
3576                 goto out;
3577
3578         ret = wl1271_ps_elp_wakeup(wl);
3579         if (ret < 0)
3580                 goto out;
3581
3582         if (is_ap)
3583                 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
3584         else
3585                 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
3586
3587         wl1271_ps_elp_sleep(wl);
3588
3589 out:
3590         mutex_unlock(&wl->mutex);
3591 }
3592
3593 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
3594                              const struct ieee80211_tx_queue_params *params)
3595 {
3596         struct wl1271 *wl = hw->priv;
3597         u8 ps_scheme;
3598         int ret = 0;
3599
3600         mutex_lock(&wl->mutex);
3601
3602         wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
3603
3604         if (params->uapsd)
3605                 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
3606         else
3607                 ps_scheme = CONF_PS_SCHEME_LEGACY;
3608
3609         if (wl->state == WL1271_STATE_OFF) {
3610                 /*
3611                  * If the state is off, the parameters will be recorded and
3612                  * configured on init. This happens in AP-mode.
3613                  */
3614                 struct conf_tx_ac_category *conf_ac =
3615                         &wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)];
3616                 struct conf_tx_tid *conf_tid =
3617                         &wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)];
3618
3619                 conf_ac->ac = wl1271_tx_get_queue(queue);
3620                 conf_ac->cw_min = (u8)params->cw_min;
3621                 conf_ac->cw_max = params->cw_max;
3622                 conf_ac->aifsn = params->aifs;
3623                 conf_ac->tx_op_limit = params->txop << 5;
3624
3625                 conf_tid->queue_id = wl1271_tx_get_queue(queue);
3626                 conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF;
3627                 conf_tid->tsid = wl1271_tx_get_queue(queue);
3628                 conf_tid->ps_scheme = ps_scheme;
3629                 conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY;
3630                 conf_tid->apsd_conf[0] = 0;
3631                 conf_tid->apsd_conf[1] = 0;
3632                 goto out;
3633         }
3634
3635         ret = wl1271_ps_elp_wakeup(wl);
3636         if (ret < 0)
3637                 goto out;
3638
3639         /*
3640          * the txop is confed in units of 32us by the mac80211,
3641          * we need us
3642          */
3643         ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
3644                                 params->cw_min, params->cw_max,
3645                                 params->aifs, params->txop << 5);
3646         if (ret < 0)
3647                 goto out_sleep;
3648
3649         ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
3650                                  CONF_CHANNEL_TYPE_EDCF,
3651                                  wl1271_tx_get_queue(queue),
3652                                  ps_scheme, CONF_ACK_POLICY_LEGACY,
3653                                  0, 0);
3654
3655 out_sleep:
3656         wl1271_ps_elp_sleep(wl);
3657
3658 out:
3659         mutex_unlock(&wl->mutex);
3660
3661         return ret;
3662 }
3663
3664 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
3665 {
3666
3667         struct wl1271 *wl = hw->priv;
3668         u64 mactime = ULLONG_MAX;
3669         int ret;
3670
3671         wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
3672
3673         mutex_lock(&wl->mutex);
3674
3675         if (unlikely(wl->state == WL1271_STATE_OFF))
3676                 goto out;
3677
3678         ret = wl1271_ps_elp_wakeup(wl);
3679         if (ret < 0)
3680                 goto out;
3681
3682         ret = wl1271_acx_tsf_info(wl, &mactime);
3683         if (ret < 0)
3684                 goto out_sleep;
3685
3686 out_sleep:
3687         wl1271_ps_elp_sleep(wl);
3688
3689 out:
3690         mutex_unlock(&wl->mutex);
3691         return mactime;
3692 }
3693
3694 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
3695                                 struct survey_info *survey)
3696 {
3697         struct wl1271 *wl = hw->priv;
3698         struct ieee80211_conf *conf = &hw->conf;
3699
3700         if (idx != 0)
3701                 return -ENOENT;
3702
3703         survey->channel = conf->channel;
3704         survey->filled = SURVEY_INFO_NOISE_DBM;
3705         survey->noise = wl->noise;
3706
3707         return 0;
3708 }
3709
3710 static int wl1271_allocate_sta(struct wl1271 *wl,
3711                              struct ieee80211_sta *sta,
3712                              u8 *hlid)
3713 {
3714         struct wl1271_station *wl_sta;
3715         int id;
3716
3717         id = find_first_zero_bit(wl->ap_hlid_map, AP_MAX_STATIONS);
3718         if (id >= AP_MAX_STATIONS) {
3719                 wl1271_warning("could not allocate HLID - too much stations");
3720                 return -EBUSY;
3721         }
3722
3723         wl_sta = (struct wl1271_station *)sta->drv_priv;
3724         set_bit(id, wl->ap_hlid_map);
3725         wl_sta->hlid = WL1271_AP_STA_HLID_START + id;
3726         *hlid = wl_sta->hlid;
3727         memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
3728         return 0;
3729 }
3730
3731 static void wl1271_free_sta(struct wl1271 *wl, u8 hlid)
3732 {
3733         int id = hlid - WL1271_AP_STA_HLID_START;
3734
3735         if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3736                 return;
3737
3738         clear_bit(id, wl->ap_hlid_map);
3739         memset(wl->links[hlid].addr, 0, ETH_ALEN);
3740         wl->links[hlid].ba_bitmap = 0;
3741         wl1271_tx_reset_link_queues(wl, hlid);
3742         __clear_bit(hlid, &wl->ap_ps_map);
3743         __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
3744 }
3745
3746 static int wl1271_op_sta_add(struct ieee80211_hw *hw,
3747                              struct ieee80211_vif *vif,
3748                              struct ieee80211_sta *sta)
3749 {
3750         struct wl1271 *wl = hw->priv;
3751         int ret = 0;
3752         u8 hlid;
3753
3754         mutex_lock(&wl->mutex);
3755
3756         if (unlikely(wl->state == WL1271_STATE_OFF))
3757                 goto out;
3758
3759         if (wl->bss_type != BSS_TYPE_AP_BSS)
3760                 goto out;
3761
3762         wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
3763
3764         ret = wl1271_allocate_sta(wl, sta, &hlid);
3765         if (ret < 0)
3766                 goto out;
3767
3768         ret = wl1271_ps_elp_wakeup(wl);
3769         if (ret < 0)
3770                 goto out_free_sta;
3771
3772         ret = wl12xx_cmd_add_peer(wl, sta, hlid);
3773         if (ret < 0)
3774                 goto out_sleep;
3775
3776         ret = wl12xx_cmd_set_peer_state(wl, hlid);
3777         if (ret < 0)
3778                 goto out_sleep;
3779
3780         ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, true, hlid);
3781         if (ret < 0)
3782                 goto out_sleep;
3783
3784 out_sleep:
3785         wl1271_ps_elp_sleep(wl);
3786
3787 out_free_sta:
3788         if (ret < 0)
3789                 wl1271_free_sta(wl, hlid);
3790
3791 out:
3792         mutex_unlock(&wl->mutex);
3793         return ret;
3794 }
3795
3796 static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
3797                                 struct ieee80211_vif *vif,
3798                                 struct ieee80211_sta *sta)
3799 {
3800         struct wl1271 *wl = hw->priv;
3801         struct wl1271_station *wl_sta;
3802         int ret = 0, id;
3803
3804         mutex_lock(&wl->mutex);
3805
3806         if (unlikely(wl->state == WL1271_STATE_OFF))
3807                 goto out;
3808
3809         if (wl->bss_type != BSS_TYPE_AP_BSS)
3810                 goto out;
3811
3812         wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
3813
3814         wl_sta = (struct wl1271_station *)sta->drv_priv;
3815         id = wl_sta->hlid - WL1271_AP_STA_HLID_START;
3816         if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3817                 goto out;
3818
3819         ret = wl1271_ps_elp_wakeup(wl);
3820         if (ret < 0)
3821                 goto out;
3822
3823         ret = wl12xx_cmd_remove_peer(wl, wl_sta->hlid);
3824         if (ret < 0)
3825                 goto out_sleep;
3826
3827         wl1271_free_sta(wl, wl_sta->hlid);
3828
3829 out_sleep:
3830         wl1271_ps_elp_sleep(wl);
3831
3832 out:
3833         mutex_unlock(&wl->mutex);
3834         return ret;
3835 }
3836
3837 static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
3838                                   struct ieee80211_vif *vif,
3839                                   enum ieee80211_ampdu_mlme_action action,
3840                                   struct ieee80211_sta *sta, u16 tid, u16 *ssn,
3841                                   u8 buf_size)
3842 {
3843         struct wl1271 *wl = hw->priv;
3844         int ret;
3845         u8 hlid, *ba_bitmap;
3846
3847         wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu action %d tid %d", action,
3848                      tid);
3849
3850         /* sanity check - the fields in FW are only 8bits wide */
3851         if (WARN_ON(tid > 0xFF))
3852                 return -ENOTSUPP;
3853
3854         mutex_lock(&wl->mutex);
3855
3856         if (unlikely(wl->state == WL1271_STATE_OFF)) {
3857                 ret = -EAGAIN;
3858                 goto out;
3859         }
3860
3861         if (wl->bss_type == BSS_TYPE_STA_BSS) {
3862                 hlid = wl->sta_hlid;
3863                 ba_bitmap = &wl->ba_rx_bitmap;
3864         } else if (wl->bss_type == BSS_TYPE_AP_BSS) {
3865                 struct wl1271_station *wl_sta;
3866
3867                 wl_sta = (struct wl1271_station *)sta->drv_priv;
3868                 hlid = wl_sta->hlid;
3869                 ba_bitmap = &wl->links[hlid].ba_bitmap;
3870         } else {
3871                 ret = -EINVAL;
3872                 goto out;
3873         }
3874
3875         ret = wl1271_ps_elp_wakeup(wl);
3876         if (ret < 0)
3877                 goto out;
3878
3879         wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu: Rx tid %d action %d",
3880                      tid, action);
3881
3882         switch (action) {
3883         case IEEE80211_AMPDU_RX_START:
3884                 if (!wl->ba_support || !wl->ba_allowed) {
3885                         ret = -ENOTSUPP;
3886                         break;
3887                 }
3888
3889                 if (wl->ba_rx_session_count >= RX_BA_MAX_SESSIONS) {
3890                         ret = -EBUSY;
3891                         wl1271_error("exceeded max RX BA sessions");
3892                         break;
3893                 }
3894
3895                 if (*ba_bitmap & BIT(tid)) {
3896                         ret = -EINVAL;
3897                         wl1271_error("cannot enable RX BA session on active "
3898                                      "tid: %d", tid);
3899                         break;
3900                 }
3901
3902                 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, *ssn, true,
3903                                                          hlid);
3904                 if (!ret) {
3905                         *ba_bitmap |= BIT(tid);
3906                         wl->ba_rx_session_count++;
3907                 }
3908                 break;
3909
3910         case IEEE80211_AMPDU_RX_STOP:
3911                 if (!(*ba_bitmap & BIT(tid))) {
3912                         ret = -EINVAL;
3913                         wl1271_error("no active RX BA session on tid: %d",
3914                                      tid);
3915                         break;
3916                 }
3917
3918                 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, 0, false,
3919                                                          hlid);
3920                 if (!ret) {
3921                         *ba_bitmap &= ~BIT(tid);
3922                         wl->ba_rx_session_count--;
3923                 }
3924                 break;
3925
3926         /*
3927          * The BA initiator session management in FW independently.
3928          * Falling break here on purpose for all TX APDU commands.
3929          */
3930         case IEEE80211_AMPDU_TX_START:
3931         case IEEE80211_AMPDU_TX_STOP:
3932         case IEEE80211_AMPDU_TX_OPERATIONAL:
3933                 ret = -EINVAL;
3934                 break;
3935
3936         default:
3937                 wl1271_error("Incorrect ampdu action id=%x\n", action);
3938                 ret = -EINVAL;
3939         }
3940
3941         wl1271_ps_elp_sleep(wl);
3942
3943 out:
3944         mutex_unlock(&wl->mutex);
3945
3946         return ret;
3947 }
3948
3949 static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
3950 {
3951         struct wl1271 *wl = hw->priv;
3952         bool ret = false;
3953
3954         mutex_lock(&wl->mutex);
3955
3956         if (unlikely(wl->state == WL1271_STATE_OFF))
3957                 goto out;
3958
3959         /* packets are considered pending if in the TX queue or the FW */
3960         ret = (wl1271_tx_total_queue_count(wl) > 0) || (wl->tx_frames_cnt > 0);
3961
3962         /* the above is appropriate for STA mode for PS purposes */
3963         WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3964
3965 out:
3966         mutex_unlock(&wl->mutex);
3967
3968         return ret;
3969 }
3970
3971 /* can't be const, mac80211 writes to this */
3972 static struct ieee80211_rate wl1271_rates[] = {
3973         { .bitrate = 10,
3974           .hw_value = CONF_HW_BIT_RATE_1MBPS,
3975           .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
3976         { .bitrate = 20,
3977           .hw_value = CONF_HW_BIT_RATE_2MBPS,
3978           .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
3979           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3980         { .bitrate = 55,
3981           .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
3982           .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
3983           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3984         { .bitrate = 110,
3985           .hw_value = CONF_HW_BIT_RATE_11MBPS,
3986           .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
3987           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3988         { .bitrate = 60,
3989           .hw_value = CONF_HW_BIT_RATE_6MBPS,
3990           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
3991         { .bitrate = 90,
3992           .hw_value = CONF_HW_BIT_RATE_9MBPS,
3993           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
3994         { .bitrate = 120,
3995           .hw_value = CONF_HW_BIT_RATE_12MBPS,
3996           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
3997         { .bitrate = 180,
3998           .hw_value = CONF_HW_BIT_RATE_18MBPS,
3999           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
4000         { .bitrate = 240,
4001           .hw_value = CONF_HW_BIT_RATE_24MBPS,
4002           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
4003         { .bitrate = 360,
4004          .hw_value = CONF_HW_BIT_RATE_36MBPS,
4005          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
4006         { .bitrate = 480,
4007           .hw_value = CONF_HW_BIT_RATE_48MBPS,
4008           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
4009         { .bitrate = 540,
4010           .hw_value = CONF_HW_BIT_RATE_54MBPS,
4011           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
4012 };
4013
4014 /* can't be const, mac80211 writes to this */
4015 static struct ieee80211_channel wl1271_channels[] = {
4016         { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
4017         { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
4018         { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
4019         { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
4020         { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
4021         { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
4022         { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
4023         { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
4024         { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
4025         { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
4026         { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
4027         { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
4028         { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
4029         { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
4030 };
4031
4032 /* mapping to indexes for wl1271_rates */
4033 static const u8 wl1271_rate_to_idx_2ghz[] = {
4034         /* MCS rates are used only with 11n */
4035         7,                            /* CONF_HW_RXTX_RATE_MCS7 */
4036         6,                            /* CONF_HW_RXTX_RATE_MCS6 */
4037         5,                            /* CONF_HW_RXTX_RATE_MCS5 */
4038         4,                            /* CONF_HW_RXTX_RATE_MCS4 */
4039         3,                            /* CONF_HW_RXTX_RATE_MCS3 */
4040         2,                            /* CONF_HW_RXTX_RATE_MCS2 */
4041         1,                            /* CONF_HW_RXTX_RATE_MCS1 */
4042         0,                            /* CONF_HW_RXTX_RATE_MCS0 */
4043
4044         11,                            /* CONF_HW_RXTX_RATE_54   */
4045         10,                            /* CONF_HW_RXTX_RATE_48   */
4046         9,                             /* CONF_HW_RXTX_RATE_36   */
4047         8,                             /* CONF_HW_RXTX_RATE_24   */
4048
4049         /* TI-specific rate */
4050         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
4051
4052         7,                             /* CONF_HW_RXTX_RATE_18   */
4053         6,                             /* CONF_HW_RXTX_RATE_12   */
4054         3,                             /* CONF_HW_RXTX_RATE_11   */
4055         5,                             /* CONF_HW_RXTX_RATE_9    */
4056         4,                             /* CONF_HW_RXTX_RATE_6    */
4057         2,                             /* CONF_HW_RXTX_RATE_5_5  */
4058         1,                             /* CONF_HW_RXTX_RATE_2    */
4059         0                              /* CONF_HW_RXTX_RATE_1    */
4060 };
4061
4062 /* 11n STA capabilities */
4063 #define HW_RX_HIGHEST_RATE      72
4064
4065 #ifdef CONFIG_WL12XX_HT
4066 #define WL12XX_HT_CAP { \
4067         .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
4068                (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
4069         .ht_supported = true, \
4070         .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
4071         .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
4072         .mcs = { \
4073                 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
4074                 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
4075                 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
4076                 }, \
4077 }
4078 #else
4079 #define WL12XX_HT_CAP { \
4080         .ht_supported = false, \
4081 }
4082 #endif
4083
4084 /* can't be const, mac80211 writes to this */
4085 static struct ieee80211_supported_band wl1271_band_2ghz = {
4086         .channels = wl1271_channels,
4087         .n_channels = ARRAY_SIZE(wl1271_channels),
4088         .bitrates = wl1271_rates,
4089         .n_bitrates = ARRAY_SIZE(wl1271_rates),
4090         .ht_cap = WL12XX_HT_CAP,
4091 };
4092
4093 /* 5 GHz data rates for WL1273 */
4094 static struct ieee80211_rate wl1271_rates_5ghz[] = {
4095         { .bitrate = 60,
4096           .hw_value = CONF_HW_BIT_RATE_6MBPS,
4097           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
4098         { .bitrate = 90,
4099           .hw_value = CONF_HW_BIT_RATE_9MBPS,
4100           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
4101         { .bitrate = 120,
4102           .hw_value = CONF_HW_BIT_RATE_12MBPS,
4103           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
4104         { .bitrate = 180,
4105           .hw_value = CONF_HW_BIT_RATE_18MBPS,
4106           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
4107         { .bitrate = 240,
4108           .hw_value = CONF_HW_BIT_RATE_24MBPS,
4109           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
4110         { .bitrate = 360,
4111          .hw_value = CONF_HW_BIT_RATE_36MBPS,
4112          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
4113         { .bitrate = 480,
4114           .hw_value = CONF_HW_BIT_RATE_48MBPS,
4115           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
4116         { .bitrate = 540,
4117           .hw_value = CONF_HW_BIT_RATE_54MBPS,
4118           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
4119 };
4120
4121 /* 5 GHz band channels for WL1273 */
4122 static struct ieee80211_channel wl1271_channels_5ghz[] = {
4123         { .hw_value = 7, .center_freq = 5035, .max_power = 25 },
4124         { .hw_value = 8, .center_freq = 5040, .max_power = 25 },
4125         { .hw_value = 9, .center_freq = 5045, .max_power = 25 },
4126         { .hw_value = 11, .center_freq = 5055, .max_power = 25 },
4127         { .hw_value = 12, .center_freq = 5060, .max_power = 25 },
4128         { .hw_value = 16, .center_freq = 5080, .max_power = 25 },
4129         { .hw_value = 34, .center_freq = 5170, .max_power = 25 },
4130         { .hw_value = 36, .center_freq = 5180, .max_power = 25 },
4131         { .hw_value = 38, .center_freq = 5190, .max_power = 25 },
4132         { .hw_value = 40, .center_freq = 5200, .max_power = 25 },
4133         { .hw_value = 42, .center_freq = 5210, .max_power = 25 },
4134         { .hw_value = 44, .center_freq = 5220, .max_power = 25 },
4135         { .hw_value = 46, .center_freq = 5230, .max_power = 25 },
4136         { .hw_value = 48, .center_freq = 5240, .max_power = 25 },
4137         { .hw_value = 52, .center_freq = 5260, .max_power = 25 },
4138         { .hw_value = 56, .center_freq = 5280, .max_power = 25 },
4139         { .hw_value = 60, .center_freq = 5300, .max_power = 25 },
4140         { .hw_value = 64, .center_freq = 5320, .max_power = 25 },
4141         { .hw_value = 100, .center_freq = 5500, .max_power = 25 },
4142         { .hw_value = 104, .center_freq = 5520, .max_power = 25 },
4143         { .hw_value = 108, .center_freq = 5540, .max_power = 25 },
4144         { .hw_value = 112, .center_freq = 5560, .max_power = 25 },
4145         { .hw_value = 116, .center_freq = 5580, .max_power = 25 },
4146         { .hw_value = 120, .center_freq = 5600, .max_power = 25 },
4147         { .hw_value = 124, .center_freq = 5620, .max_power = 25 },
4148         { .hw_value = 128, .center_freq = 5640, .max_power = 25 },
4149         { .hw_value = 132, .center_freq = 5660, .max_power = 25 },
4150         { .hw_value = 136, .center_freq = 5680, .max_power = 25 },
4151         { .hw_value = 140, .center_freq = 5700, .max_power = 25 },
4152         { .hw_value = 149, .center_freq = 5745, .max_power = 25 },
4153         { .hw_value = 153, .center_freq = 5765, .max_power = 25 },
4154         { .hw_value = 157, .center_freq = 5785, .max_power = 25 },
4155         { .hw_value = 161, .center_freq = 5805, .max_power = 25 },
4156         { .hw_value = 165, .center_freq = 5825, .max_power = 25 },
4157 };
4158
4159 /* mapping to indexes for wl1271_rates_5ghz */
4160 static const u8 wl1271_rate_to_idx_5ghz[] = {
4161         /* MCS rates are used only with 11n */
4162         7,                            /* CONF_HW_RXTX_RATE_MCS7 */
4163         6,                            /* CONF_HW_RXTX_RATE_MCS6 */
4164         5,                            /* CONF_HW_RXTX_RATE_MCS5 */
4165         4,                            /* CONF_HW_RXTX_RATE_MCS4 */
4166         3,                            /* CONF_HW_RXTX_RATE_MCS3 */
4167         2,                            /* CONF_HW_RXTX_RATE_MCS2 */
4168         1,                            /* CONF_HW_RXTX_RATE_MCS1 */
4169         0,                            /* CONF_HW_RXTX_RATE_MCS0 */
4170
4171         7,                             /* CONF_HW_RXTX_RATE_54   */
4172         6,                             /* CONF_HW_RXTX_RATE_48   */
4173         5,                             /* CONF_HW_RXTX_RATE_36   */
4174         4,                             /* CONF_HW_RXTX_RATE_24   */
4175
4176         /* TI-specific rate */
4177         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
4178
4179         3,                             /* CONF_HW_RXTX_RATE_18   */
4180         2,                             /* CONF_HW_RXTX_RATE_12   */
4181         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11   */
4182         1,                             /* CONF_HW_RXTX_RATE_9    */
4183         0,                             /* CONF_HW_RXTX_RATE_6    */
4184         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5  */
4185         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2    */
4186         CONF_HW_RXTX_RATE_UNSUPPORTED  /* CONF_HW_RXTX_RATE_1    */
4187 };
4188
4189 static struct ieee80211_supported_band wl1271_band_5ghz = {
4190         .channels = wl1271_channels_5ghz,
4191         .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
4192         .bitrates = wl1271_rates_5ghz,
4193         .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
4194         .ht_cap = WL12XX_HT_CAP,
4195 };
4196
4197 static const u8 *wl1271_band_rate_to_idx[] = {
4198         [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
4199         [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
4200 };
4201
4202 static const struct ieee80211_ops wl1271_ops = {
4203         .start = wl1271_op_start,
4204         .stop = wl1271_op_stop,
4205         .add_interface = wl1271_op_add_interface,
4206         .remove_interface = wl1271_op_remove_interface,
4207 #ifdef CONFIG_PM
4208         .suspend = wl1271_op_suspend,
4209         .resume = wl1271_op_resume,
4210 #endif
4211         .config = wl1271_op_config,
4212         .prepare_multicast = wl1271_op_prepare_multicast,
4213         .configure_filter = wl1271_op_configure_filter,
4214         .tx = wl1271_op_tx,
4215         .set_key = wl1271_op_set_key,
4216         .hw_scan = wl1271_op_hw_scan,
4217         .cancel_hw_scan = wl1271_op_cancel_hw_scan,
4218         .sched_scan_start = wl1271_op_sched_scan_start,
4219         .sched_scan_stop = wl1271_op_sched_scan_stop,
4220         .bss_info_changed = wl1271_op_bss_info_changed,
4221         .set_frag_threshold = wl1271_op_set_frag_threshold,
4222         .set_rts_threshold = wl1271_op_set_rts_threshold,
4223         .conf_tx = wl1271_op_conf_tx,
4224         .get_tsf = wl1271_op_get_tsf,
4225         .get_survey = wl1271_op_get_survey,
4226         .sta_add = wl1271_op_sta_add,
4227         .sta_remove = wl1271_op_sta_remove,
4228         .ampdu_action = wl1271_op_ampdu_action,
4229         .tx_frames_pending = wl1271_tx_frames_pending,
4230         CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
4231 };
4232
4233
4234 u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
4235 {
4236         u8 idx;
4237
4238         BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
4239
4240         if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
4241                 wl1271_error("Illegal RX rate from HW: %d", rate);
4242                 return 0;
4243         }
4244
4245         idx = wl1271_band_rate_to_idx[band][rate];
4246         if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
4247                 wl1271_error("Unsupported RX rate from HW: %d", rate);
4248                 return 0;
4249         }
4250
4251         return idx;
4252 }
4253
4254 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
4255                                                struct device_attribute *attr,
4256                                                char *buf)
4257 {
4258         struct wl1271 *wl = dev_get_drvdata(dev);
4259         ssize_t len;
4260
4261         len = PAGE_SIZE;
4262
4263         mutex_lock(&wl->mutex);
4264         len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
4265                        wl->sg_enabled);
4266         mutex_unlock(&wl->mutex);
4267
4268         return len;
4269
4270 }
4271
4272 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
4273                                                 struct device_attribute *attr,
4274                                                 const char *buf, size_t count)
4275 {
4276         struct wl1271 *wl = dev_get_drvdata(dev);
4277         unsigned long res;
4278         int ret;
4279
4280         ret = kstrtoul(buf, 10, &res);
4281         if (ret < 0) {
4282                 wl1271_warning("incorrect value written to bt_coex_mode");
4283                 return count;
4284         }
4285
4286         mutex_lock(&wl->mutex);
4287
4288         res = !!res;
4289
4290         if (res == wl->sg_enabled)
4291                 goto out;
4292
4293         wl->sg_enabled = res;
4294
4295         if (wl->state == WL1271_STATE_OFF)
4296                 goto out;
4297
4298         ret = wl1271_ps_elp_wakeup(wl);
4299         if (ret < 0)
4300                 goto out;
4301
4302         wl1271_acx_sg_enable(wl, wl->sg_enabled);
4303         wl1271_ps_elp_sleep(wl);
4304
4305  out:
4306         mutex_unlock(&wl->mutex);
4307         return count;
4308 }
4309
4310 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
4311                    wl1271_sysfs_show_bt_coex_state,
4312                    wl1271_sysfs_store_bt_coex_state);
4313
4314 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
4315                                            struct device_attribute *attr,
4316                                            char *buf)
4317 {
4318         struct wl1271 *wl = dev_get_drvdata(dev);
4319         ssize_t len;
4320
4321         len = PAGE_SIZE;
4322
4323         mutex_lock(&wl->mutex);
4324         if (wl->hw_pg_ver >= 0)
4325                 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
4326         else
4327                 len = snprintf(buf, len, "n/a\n");
4328         mutex_unlock(&wl->mutex);
4329
4330         return len;
4331 }
4332
4333 static DEVICE_ATTR(hw_pg_ver, S_IRUGO,
4334                    wl1271_sysfs_show_hw_pg_ver, NULL);
4335
4336 static ssize_t wl1271_sysfs_read_fwlog(struct file *filp, struct kobject *kobj,
4337                                        struct bin_attribute *bin_attr,
4338                                        char *buffer, loff_t pos, size_t count)
4339 {
4340         struct device *dev = container_of(kobj, struct device, kobj);
4341         struct wl1271 *wl = dev_get_drvdata(dev);
4342         ssize_t len;
4343         int ret;
4344
4345         ret = mutex_lock_interruptible(&wl->mutex);
4346         if (ret < 0)
4347                 return -ERESTARTSYS;
4348
4349         /* Let only one thread read the log at a time, blocking others */
4350         while (wl->fwlog_size == 0) {
4351                 DEFINE_WAIT(wait);
4352
4353                 prepare_to_wait_exclusive(&wl->fwlog_waitq,
4354                                           &wait,
4355                                           TASK_INTERRUPTIBLE);
4356
4357                 if (wl->fwlog_size != 0) {
4358                         finish_wait(&wl->fwlog_waitq, &wait);
4359                         break;
4360                 }
4361
4362                 mutex_unlock(&wl->mutex);
4363
4364                 schedule();
4365                 finish_wait(&wl->fwlog_waitq, &wait);
4366
4367                 if (signal_pending(current))
4368                         return -ERESTARTSYS;
4369
4370                 ret = mutex_lock_interruptible(&wl->mutex);
4371                 if (ret < 0)
4372                         return -ERESTARTSYS;
4373         }
4374
4375         /* Check if the fwlog is still valid */
4376         if (wl->fwlog_size < 0) {
4377                 mutex_unlock(&wl->mutex);
4378                 return 0;
4379         }
4380
4381         /* Seeking is not supported - old logs are not kept. Disregard pos. */
4382         len = min(count, (size_t)wl->fwlog_size);
4383         wl->fwlog_size -= len;
4384         memcpy(buffer, wl->fwlog, len);
4385
4386         /* Make room for new messages */
4387         memmove(wl->fwlog, wl->fwlog + len, wl->fwlog_size);
4388
4389         mutex_unlock(&wl->mutex);
4390
4391         return len;
4392 }
4393
4394 static struct bin_attribute fwlog_attr = {
4395         .attr = {.name = "fwlog", .mode = S_IRUSR},
4396         .read = wl1271_sysfs_read_fwlog,
4397 };
4398
4399 int wl1271_register_hw(struct wl1271 *wl)
4400 {
4401         int ret;
4402
4403         if (wl->mac80211_registered)
4404                 return 0;
4405
4406         ret = wl1271_fetch_nvs(wl);
4407         if (ret == 0) {
4408                 /* NOTE: The wl->nvs->nvs element must be first, in
4409                  * order to simplify the casting, we assume it is at
4410                  * the beginning of the wl->nvs structure.
4411                  */
4412                 u8 *nvs_ptr = (u8 *)wl->nvs;
4413
4414                 wl->mac_addr[0] = nvs_ptr[11];
4415                 wl->mac_addr[1] = nvs_ptr[10];
4416                 wl->mac_addr[2] = nvs_ptr[6];
4417                 wl->mac_addr[3] = nvs_ptr[5];
4418                 wl->mac_addr[4] = nvs_ptr[4];
4419                 wl->mac_addr[5] = nvs_ptr[3];
4420         }
4421
4422         SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
4423
4424         ret = ieee80211_register_hw(wl->hw);
4425         if (ret < 0) {
4426                 wl1271_error("unable to register mac80211 hw: %d", ret);
4427                 return ret;
4428         }
4429
4430         wl->mac80211_registered = true;
4431
4432         wl1271_debugfs_init(wl);
4433
4434         register_netdevice_notifier(&wl1271_dev_notifier);
4435
4436         wl1271_notice("loaded");
4437
4438         return 0;
4439 }
4440 EXPORT_SYMBOL_GPL(wl1271_register_hw);
4441
4442 void wl1271_unregister_hw(struct wl1271 *wl)
4443 {
4444         if (wl->state == WL1271_STATE_PLT)
4445                 __wl1271_plt_stop(wl);
4446
4447         unregister_netdevice_notifier(&wl1271_dev_notifier);
4448         ieee80211_unregister_hw(wl->hw);
4449         wl->mac80211_registered = false;
4450
4451 }
4452 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
4453
4454 int wl1271_init_ieee80211(struct wl1271 *wl)
4455 {
4456         static const u32 cipher_suites[] = {
4457                 WLAN_CIPHER_SUITE_WEP40,
4458                 WLAN_CIPHER_SUITE_WEP104,
4459                 WLAN_CIPHER_SUITE_TKIP,
4460                 WLAN_CIPHER_SUITE_CCMP,
4461                 WL1271_CIPHER_SUITE_GEM,
4462         };
4463
4464         /* The tx descriptor buffer and the TKIP space. */
4465         wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
4466                 sizeof(struct wl1271_tx_hw_descr);
4467
4468         /* unit us */
4469         /* FIXME: find a proper value */
4470         wl->hw->channel_change_time = 10000;
4471         wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
4472
4473         wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
4474                 IEEE80211_HW_BEACON_FILTER |
4475                 IEEE80211_HW_SUPPORTS_PS |
4476                 IEEE80211_HW_SUPPORTS_UAPSD |
4477                 IEEE80211_HW_HAS_RATE_CONTROL |
4478                 IEEE80211_HW_CONNECTION_MONITOR |
4479                 IEEE80211_HW_SUPPORTS_CQM_RSSI |
4480                 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
4481                 IEEE80211_HW_SPECTRUM_MGMT |
4482                 IEEE80211_HW_AP_LINK_PS;
4483
4484         wl->hw->wiphy->cipher_suites = cipher_suites;
4485         wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
4486
4487         wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
4488                 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
4489         wl->hw->wiphy->max_scan_ssids = 1;
4490         /*
4491          * Maximum length of elements in scanning probe request templates
4492          * should be the maximum length possible for a template, without
4493          * the IEEE80211 header of the template
4494          */
4495         wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_DFLT_SIZE -
4496                         sizeof(struct ieee80211_header);
4497
4498         /* make sure all our channels fit in the scanned_ch bitmask */
4499         BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
4500                      ARRAY_SIZE(wl1271_channels_5ghz) >
4501                      WL1271_MAX_CHANNELS);
4502         /*
4503          * We keep local copies of the band structs because we need to
4504          * modify them on a per-device basis.
4505          */
4506         memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
4507                sizeof(wl1271_band_2ghz));
4508         memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
4509                sizeof(wl1271_band_5ghz));
4510
4511         wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
4512                 &wl->bands[IEEE80211_BAND_2GHZ];
4513         wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
4514                 &wl->bands[IEEE80211_BAND_5GHZ];
4515
4516         wl->hw->queues = 4;
4517         wl->hw->max_rates = 1;
4518
4519         wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
4520
4521         SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
4522
4523         wl->hw->sta_data_size = sizeof(struct wl1271_station);
4524
4525         wl->hw->max_rx_aggregation_subframes = 8;
4526
4527         return 0;
4528 }
4529 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
4530
4531 #define WL1271_DEFAULT_CHANNEL 0
4532
4533 struct ieee80211_hw *wl1271_alloc_hw(void)
4534 {
4535         struct ieee80211_hw *hw;
4536         struct platform_device *plat_dev = NULL;
4537         struct wl1271 *wl;
4538         int i, j, ret;
4539         unsigned int order;
4540
4541         hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
4542         if (!hw) {
4543                 wl1271_error("could not alloc ieee80211_hw");
4544                 ret = -ENOMEM;
4545                 goto err_hw_alloc;
4546         }
4547
4548         plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
4549         if (!plat_dev) {
4550                 wl1271_error("could not allocate platform_device");
4551                 ret = -ENOMEM;
4552                 goto err_plat_alloc;
4553         }
4554
4555         wl = hw->priv;
4556         memset(wl, 0, sizeof(*wl));
4557
4558         INIT_LIST_HEAD(&wl->list);
4559
4560         wl->hw = hw;
4561         wl->plat_dev = plat_dev;
4562
4563         for (i = 0; i < NUM_TX_QUEUES; i++)
4564                 skb_queue_head_init(&wl->tx_queue[i]);
4565
4566         for (i = 0; i < NUM_TX_QUEUES; i++)
4567                 for (j = 0; j < AP_MAX_LINKS; j++)
4568                         skb_queue_head_init(&wl->links[j].tx_queue[i]);
4569
4570         skb_queue_head_init(&wl->deferred_rx_queue);
4571         skb_queue_head_init(&wl->deferred_tx_queue);
4572
4573         INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
4574         INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
4575         INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
4576         INIT_WORK(&wl->tx_work, wl1271_tx_work);
4577         INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
4578         INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
4579         INIT_WORK(&wl->rx_streaming_enable_work,
4580                   wl1271_rx_streaming_enable_work);
4581         INIT_WORK(&wl->rx_streaming_disable_work,
4582                   wl1271_rx_streaming_disable_work);
4583
4584         wl->freezable_wq = create_freezable_workqueue("wl12xx_wq");
4585         if (!wl->freezable_wq) {
4586                 ret = -ENOMEM;
4587                 goto err_hw;
4588         }
4589
4590         wl->channel = WL1271_DEFAULT_CHANNEL;
4591         wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
4592         wl->default_key = 0;
4593         wl->rx_counter = 0;
4594         wl->psm_entry_retry = 0;
4595         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
4596         wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
4597         wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
4598         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
4599         wl->band = IEEE80211_BAND_2GHZ;
4600         wl->vif = NULL;
4601         wl->flags = 0;
4602         wl->sg_enabled = true;
4603         wl->hw_pg_ver = -1;
4604         wl->bss_type = MAX_BSS_TYPE;
4605         wl->set_bss_type = MAX_BSS_TYPE;
4606         wl->last_tx_hlid = 0;
4607         wl->ap_ps_map = 0;
4608         wl->ap_fw_ps_map = 0;
4609         wl->quirks = 0;
4610         wl->platform_quirks = 0;
4611         wl->sched_scanning = false;
4612         wl->tx_security_seq = 0;
4613         wl->tx_security_last_seq_lsb = 0;
4614         wl->tx_spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
4615         wl->role_id = WL12XX_INVALID_ROLE_ID;
4616         wl->system_hlid = WL12XX_SYSTEM_HLID;
4617         wl->sta_hlid = WL12XX_INVALID_LINK_ID;
4618         wl->dev_role_id = WL12XX_INVALID_ROLE_ID;
4619         wl->dev_hlid = WL12XX_INVALID_LINK_ID;
4620         wl->session_counter = 0;
4621         wl->ap_bcast_hlid = WL12XX_INVALID_LINK_ID;
4622         wl->ap_global_hlid = WL12XX_INVALID_LINK_ID;
4623         setup_timer(&wl->rx_streaming_timer, wl1271_rx_streaming_timer,
4624                     (unsigned long) wl);
4625         wl->fwlog_size = 0;
4626         init_waitqueue_head(&wl->fwlog_waitq);
4627
4628         /* The system link is always allocated */
4629         __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
4630
4631         memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
4632         for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
4633                 wl->tx_frames[i] = NULL;
4634
4635         spin_lock_init(&wl->wl_lock);
4636
4637         wl->state = WL1271_STATE_OFF;
4638         mutex_init(&wl->mutex);
4639
4640         /* Apply default driver configuration. */
4641         wl1271_conf_init(wl);
4642
4643         order = get_order(WL1271_AGGR_BUFFER_SIZE);
4644         wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
4645         if (!wl->aggr_buf) {
4646                 ret = -ENOMEM;
4647                 goto err_wq;
4648         }
4649
4650         wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
4651         if (!wl->dummy_packet) {
4652                 ret = -ENOMEM;
4653                 goto err_aggr;
4654         }
4655
4656         /* Allocate one page for the FW log */
4657         wl->fwlog = (u8 *)get_zeroed_page(GFP_KERNEL);
4658         if (!wl->fwlog) {
4659                 ret = -ENOMEM;
4660                 goto err_dummy_packet;
4661         }
4662
4663         /* Register platform device */
4664         ret = platform_device_register(wl->plat_dev);
4665         if (ret) {
4666                 wl1271_error("couldn't register platform device");
4667                 goto err_fwlog;
4668         }
4669         dev_set_drvdata(&wl->plat_dev->dev, wl);
4670
4671         /* Create sysfs file to control bt coex state */
4672         ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4673         if (ret < 0) {
4674                 wl1271_error("failed to create sysfs file bt_coex_state");
4675                 goto err_platform;
4676         }
4677
4678         /* Create sysfs file to get HW PG version */
4679         ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4680         if (ret < 0) {
4681                 wl1271_error("failed to create sysfs file hw_pg_ver");
4682                 goto err_bt_coex_state;
4683         }
4684
4685         /* Create sysfs file for the FW log */
4686         ret = device_create_bin_file(&wl->plat_dev->dev, &fwlog_attr);
4687         if (ret < 0) {
4688                 wl1271_error("failed to create sysfs file fwlog");
4689                 goto err_hw_pg_ver;
4690         }
4691
4692         return hw;
4693
4694 err_hw_pg_ver:
4695         device_remove_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4696
4697 err_bt_coex_state:
4698         device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4699
4700 err_platform:
4701         platform_device_unregister(wl->plat_dev);
4702
4703 err_fwlog:
4704         free_page((unsigned long)wl->fwlog);
4705
4706 err_dummy_packet:
4707         dev_kfree_skb(wl->dummy_packet);
4708
4709 err_aggr:
4710         free_pages((unsigned long)wl->aggr_buf, order);
4711
4712 err_wq:
4713         destroy_workqueue(wl->freezable_wq);
4714
4715 err_hw:
4716         wl1271_debugfs_exit(wl);
4717         kfree(plat_dev);
4718
4719 err_plat_alloc:
4720         ieee80211_free_hw(hw);
4721
4722 err_hw_alloc:
4723
4724         return ERR_PTR(ret);
4725 }
4726 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
4727
4728 int wl1271_free_hw(struct wl1271 *wl)
4729 {
4730         /* Unblock any fwlog readers */
4731         mutex_lock(&wl->mutex);
4732         wl->fwlog_size = -1;
4733         wake_up_interruptible_all(&wl->fwlog_waitq);
4734         mutex_unlock(&wl->mutex);
4735
4736         device_remove_bin_file(&wl->plat_dev->dev, &fwlog_attr);
4737
4738         device_remove_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4739
4740         device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4741         platform_device_unregister(wl->plat_dev);
4742         free_page((unsigned long)wl->fwlog);
4743         dev_kfree_skb(wl->dummy_packet);
4744         free_pages((unsigned long)wl->aggr_buf,
4745                         get_order(WL1271_AGGR_BUFFER_SIZE));
4746         kfree(wl->plat_dev);
4747
4748         wl1271_debugfs_exit(wl);
4749
4750         vfree(wl->fw);
4751         wl->fw = NULL;
4752         kfree(wl->nvs);
4753         wl->nvs = NULL;
4754
4755         kfree(wl->fw_status);
4756         kfree(wl->tx_res_if);
4757         destroy_workqueue(wl->freezable_wq);
4758
4759         ieee80211_free_hw(wl->hw);
4760
4761         return 0;
4762 }
4763 EXPORT_SYMBOL_GPL(wl1271_free_hw);
4764
4765 u32 wl12xx_debug_level = DEBUG_NONE;
4766 EXPORT_SYMBOL_GPL(wl12xx_debug_level);
4767 module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
4768 MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
4769
4770 module_param_named(fwlog, fwlog_param, charp, 0);
4771 MODULE_PARM_DESC(keymap,
4772                  "FW logger options: continuous, ondemand, dbgpins or disable");
4773
4774 MODULE_LICENSE("GPL");
4775 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
4776 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");