drivers/net/wireless/wl12xx/main.c

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