drivers/net/wireless/wl12xx/main.c

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