Pileus Git - ~andy/linux/blob - 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         memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
1900
1901         if (wl->state != WL1271_STATE_OFF) {
1902                 wl1271_error("cannot start because not in off state: %d",
1903                              wl->state);
1904                 ret = -EBUSY;
1905                 goto out;
1906         }
1907
1908         while (retries) {
1909                 retries--;
1910                 ret = wl1271_chip_wakeup(wl);
1911                 if (ret < 0)
1912                         goto power_off;
1913
1914                 ret = wl1271_boot(wl);
1915                 if (ret < 0)
1916                         goto power_off;
1917
1918                 if (wl->bss_type == BSS_TYPE_STA_BSS ||
1919                     wl->bss_type == BSS_TYPE_IBSS) {
1920                         /*
1921                          * The device role is a special role used for
1922                          * rx and tx frames prior to association (as
1923                          * the STA role can get packets only from
1924                          * its associated bssid)
1925                          */
1926                         ret = wl12xx_cmd_role_enable(wl,
1927                                                          WL1271_ROLE_DEVICE,
1928                                                          &wl->dev_role_id);
1929                         if (ret < 0)
1930                                 goto irq_disable;
1931                 }
1932
1933                 ret = wl12xx_cmd_role_enable(wl, role_type, &wl->role_id);
1934                 if (ret < 0)
1935                         goto irq_disable;
1936
1937                 ret = wl1271_hw_init(wl);
1938                 if (ret < 0)
1939                         goto irq_disable;
1940
1941                 booted = true;
1942                 break;
1943
1944 irq_disable:
1945                 mutex_unlock(&wl->mutex);
1946                 /* Unlocking the mutex in the middle of handling is
1947                    inherently unsafe. In this case we deem it safe to do,
1948                    because we need to let any possibly pending IRQ out of
1949                    the system (and while we are WL1271_STATE_OFF the IRQ
1950                    work function will not do anything.) Also, any other
1951                    possible concurrent operations will fail due to the
1952                    current state, hence the wl1271 struct should be safe. */
1953                 wl1271_disable_interrupts(wl);
1954                 wl1271_flush_deferred_work(wl);
1955                 cancel_work_sync(&wl->netstack_work);
1956                 mutex_lock(&wl->mutex);
1957 power_off:
1958                 wl1271_power_off(wl);
1959         }
1960
1961         if (!booted) {
1962                 wl1271_error("firmware boot failed despite %d retries",
1963                              WL1271_BOOT_RETRIES);
1964                 goto out;
1965         }
1966
1967         wl->vif = vif;
1968         wl->state = WL1271_STATE_ON;
1969         set_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags);
1970         wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
1971
1972         /* update hw/fw version info in wiphy struct */
1973         wiphy->hw_version = wl->chip.id;
1974         strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
1975                 sizeof(wiphy->fw_version));
1976
1977         /*
1978          * Now we know if 11a is supported (info from the NVS), so disable
1979          * 11a channels if not supported
1980          */
1981         if (!wl->enable_11a)
1982                 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
1983
1984         wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
1985                      wl->enable_11a ? "" : "not ");
1986
1987 out:
1988         mutex_unlock(&wl->mutex);
1989
1990         mutex_lock(&wl_list_mutex);
1991         if (!ret)
1992                 list_add(&wl->list, &wl_list);
1993         mutex_unlock(&wl_list_mutex);
1994
1995         return ret;
1996 }
1997
1998 static void __wl1271_op_remove_interface(struct wl1271 *wl,
1999                                          bool reset_tx_queues)
2000 {
2001         int ret, i;
2002
2003         wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
2004
2005         /* because of hardware recovery, we may get here twice */
2006         if (wl->state != WL1271_STATE_ON)
2007                 return;
2008
2009         wl1271_info("down");
2010
2011         mutex_lock(&wl_list_mutex);
2012         list_del(&wl->list);
2013         mutex_unlock(&wl_list_mutex);
2014
2015         /* enable dyn ps just in case (if left on due to fw crash etc) */
2016         if (wl->bss_type == BSS_TYPE_STA_BSS)
2017                 ieee80211_enable_dyn_ps(wl->vif);
2018
2019         if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
2020                 wl->scan.state = WL1271_SCAN_STATE_IDLE;
2021                 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
2022                 wl->scan.req = NULL;
2023                 ieee80211_scan_completed(wl->hw, true);
2024         }
2025
2026         if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags)) {
2027                 /* disable active roles */
2028                 ret = wl1271_ps_elp_wakeup(wl);
2029                 if (ret < 0)
2030                         goto deinit;
2031
2032                 if (wl->bss_type == BSS_TYPE_STA_BSS) {
2033                         ret = wl12xx_cmd_role_disable(wl, &wl->dev_role_id);
2034                         if (ret < 0)
2035                                 goto deinit;
2036                 }
2037
2038                 ret = wl12xx_cmd_role_disable(wl, &wl->role_id);
2039                 if (ret < 0)
2040                         goto deinit;
2041
2042                 wl1271_ps_elp_sleep(wl);
2043         }
2044 deinit:
2045         /* clear all hlids (except system_hlid) */
2046         wl->sta_hlid = WL12XX_INVALID_LINK_ID;
2047         wl->dev_hlid = WL12XX_INVALID_LINK_ID;
2048         wl->ap_bcast_hlid = WL12XX_INVALID_LINK_ID;
2049         wl->ap_global_hlid = WL12XX_INVALID_LINK_ID;
2050
2051         /*
2052          * this must be before the cancel_work calls below, so that the work
2053          * functions don't perform further work.
2054          */
2055         wl->state = WL1271_STATE_OFF;
2056
2057         mutex_unlock(&wl->mutex);
2058
2059         wl1271_disable_interrupts(wl);
2060         wl1271_flush_deferred_work(wl);
2061         cancel_delayed_work_sync(&wl->scan_complete_work);
2062         cancel_work_sync(&wl->netstack_work);
2063         cancel_work_sync(&wl->tx_work);
2064         del_timer_sync(&wl->rx_streaming_timer);
2065         cancel_work_sync(&wl->rx_streaming_enable_work);
2066         cancel_work_sync(&wl->rx_streaming_disable_work);
2067         cancel_delayed_work_sync(&wl->pspoll_work);
2068         cancel_delayed_work_sync(&wl->elp_work);
2069
2070         mutex_lock(&wl->mutex);
2071
2072         /* let's notify MAC80211 about the remaining pending TX frames */
2073         wl1271_tx_reset(wl, reset_tx_queues);
2074         wl1271_power_off(wl);
2075
2076         memset(wl->bssid, 0, ETH_ALEN);
2077         memset(wl->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
2078         wl->ssid_len = 0;
2079         wl->bss_type = MAX_BSS_TYPE;
2080         wl->set_bss_type = MAX_BSS_TYPE;
2081         wl->p2p = 0;
2082         wl->band = IEEE80211_BAND_2GHZ;
2083
2084         wl->rx_counter = 0;
2085         wl->psm_entry_retry = 0;
2086         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2087         wl->tx_blocks_available = 0;
2088         wl->tx_allocated_blocks = 0;
2089         wl->tx_results_count = 0;
2090         wl->tx_packets_count = 0;
2091         wl->time_offset = 0;
2092         wl->session_counter = 0;
2093         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2094         wl->bitrate_masks[IEEE80211_BAND_2GHZ] = wl->conf.tx.basic_rate;
2095         wl->bitrate_masks[IEEE80211_BAND_5GHZ] = wl->conf.tx.basic_rate_5;
2096         wl->vif = NULL;
2097         wl->tx_spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
2098         wl1271_free_ap_keys(wl);
2099         memset(wl->ap_hlid_map, 0, sizeof(wl->ap_hlid_map));
2100         wl->ap_fw_ps_map = 0;
2101         wl->ap_ps_map = 0;
2102         wl->sched_scanning = false;
2103         wl->role_id = WL12XX_INVALID_ROLE_ID;
2104         wl->dev_role_id = WL12XX_INVALID_ROLE_ID;
2105         memset(wl->roles_map, 0, sizeof(wl->roles_map));
2106         memset(wl->links_map, 0, sizeof(wl->links_map));
2107         memset(wl->roc_map, 0, sizeof(wl->roc_map));
2108         wl->active_sta_count = 0;
2109
2110         /* The system link is always allocated */
2111         __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
2112
2113         /*
2114          * this is performed after the cancel_work calls and the associated
2115          * mutex_lock, so that wl1271_op_add_interface does not accidentally
2116          * get executed before all these vars have been reset.
2117          */
2118         wl->flags = 0;
2119
2120         wl->tx_blocks_freed = 0;
2121
2122         for (i = 0; i < NUM_TX_QUEUES; i++) {
2123                 wl->tx_pkts_freed[i] = 0;
2124                 wl->tx_allocated_pkts[i] = 0;
2125         }
2126
2127         wl1271_debugfs_reset(wl);
2128
2129         kfree(wl->fw_status);
2130         wl->fw_status = NULL;
2131         kfree(wl->tx_res_if);
2132         wl->tx_res_if = NULL;
2133         kfree(wl->target_mem_map);
2134         wl->target_mem_map = NULL;
2135 }
2136
2137 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
2138                                        struct ieee80211_vif *vif)
2139 {
2140         struct wl1271 *wl = hw->priv;
2141
2142         mutex_lock(&wl->mutex);
2143         /*
2144          * wl->vif can be null here if someone shuts down the interface
2145          * just when hardware recovery has been started.
2146          */
2147         if (wl->vif) {
2148                 WARN_ON(wl->vif != vif);
2149                 __wl1271_op_remove_interface(wl, true);
2150         }
2151
2152         mutex_unlock(&wl->mutex);
2153         cancel_work_sync(&wl->recovery_work);
2154 }
2155
2156 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
2157 {
2158         int ret;
2159         bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
2160
2161         /*
2162          * One of the side effects of the JOIN command is that is clears
2163          * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
2164          * to a WPA/WPA2 access point will therefore kill the data-path.
2165          * Currently the only valid scenario for JOIN during association
2166          * is on roaming, in which case we will also be given new keys.
2167          * Keep the below message for now, unless it starts bothering
2168          * users who really like to roam a lot :)
2169          */
2170         if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2171                 wl1271_info("JOIN while associated.");
2172
2173         if (set_assoc)
2174                 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
2175
2176         if (is_ibss)
2177                 ret = wl12xx_cmd_role_start_ibss(wl);
2178         else
2179                 ret = wl12xx_cmd_role_start_sta(wl);
2180         if (ret < 0)
2181                 goto out;
2182
2183         if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2184                 goto out;
2185
2186         /*
2187          * The join command disable the keep-alive mode, shut down its process,
2188          * and also clear the template config, so we need to reset it all after
2189          * the join. The acx_aid starts the keep-alive process, and the order
2190          * of the commands below is relevant.
2191          */
2192         ret = wl1271_acx_keep_alive_mode(wl, true);
2193         if (ret < 0)
2194                 goto out;
2195
2196         ret = wl1271_acx_aid(wl, wl->aid);
2197         if (ret < 0)
2198                 goto out;
2199
2200         ret = wl1271_cmd_build_klv_null_data(wl);
2201         if (ret < 0)
2202                 goto out;
2203
2204         ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
2205                                            ACX_KEEP_ALIVE_TPL_VALID);
2206         if (ret < 0)
2207                 goto out;
2208
2209 out:
2210         return ret;
2211 }
2212
2213 static int wl1271_unjoin(struct wl1271 *wl)
2214 {
2215         int ret;
2216
2217         if (test_and_clear_bit(WL1271_FLAG_CS_PROGRESS, &wl->flags)) {
2218                 wl12xx_cmd_stop_channel_switch(wl);
2219                 ieee80211_chswitch_done(wl->vif, false);
2220         }
2221
2222         /* to stop listening to a channel, we disconnect */
2223         ret = wl12xx_cmd_role_stop_sta(wl);
2224         if (ret < 0)
2225                 goto out;
2226
2227         memset(wl->bssid, 0, ETH_ALEN);
2228
2229         /* reset TX security counters on a clean disconnect */
2230         wl->tx_security_last_seq_lsb = 0;
2231         wl->tx_security_seq = 0;
2232
2233 out:
2234         return ret;
2235 }
2236
2237 static void wl1271_set_band_rate(struct wl1271 *wl)
2238 {
2239         wl->basic_rate_set = wl->bitrate_masks[wl->band];
2240         wl->rate_set = wl->basic_rate_set;
2241 }
2242
2243 static bool wl12xx_is_roc(struct wl1271 *wl)
2244 {
2245         u8 role_id;
2246
2247         role_id = find_first_bit(wl->roc_map, WL12XX_MAX_ROLES);
2248         if (role_id >= WL12XX_MAX_ROLES)
2249                 return false;
2250
2251         return true;
2252 }
2253
2254 static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle)
2255 {
2256         int ret;
2257
2258         if (idle) {
2259                 /* no need to croc if we weren't busy (e.g. during boot) */
2260                 if (wl12xx_is_roc(wl)) {
2261                         ret = wl12xx_croc(wl, wl->dev_role_id);
2262                         if (ret < 0)
2263                                 goto out;
2264
2265                         ret = wl12xx_cmd_role_stop_dev(wl);
2266                         if (ret < 0)
2267                                 goto out;
2268                 }
2269                 wl->rate_set = wl1271_tx_min_rate_get(wl, wl->basic_rate_set);
2270                 ret = wl1271_acx_sta_rate_policies(wl);
2271                 if (ret < 0)
2272                         goto out;
2273                 ret = wl1271_acx_keep_alive_config(
2274                         wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
2275                         ACX_KEEP_ALIVE_TPL_INVALID);
2276                 if (ret < 0)
2277                         goto out;
2278                 set_bit(WL1271_FLAG_IDLE, &wl->flags);
2279         } else {
2280                 /* The current firmware only supports sched_scan in idle */
2281                 if (wl->sched_scanning) {
2282                         wl1271_scan_sched_scan_stop(wl);
2283                         ieee80211_sched_scan_stopped(wl->hw);
2284                 }
2285
2286                 ret = wl12xx_cmd_role_start_dev(wl);
2287                 if (ret < 0)
2288                         goto out;
2289
2290                 ret = wl12xx_roc(wl, wl->dev_role_id);
2291                 if (ret < 0)
2292                         goto out;
2293                 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
2294         }
2295
2296 out:
2297         return ret;
2298 }
2299
2300 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
2301 {
2302         struct wl1271 *wl = hw->priv;
2303         struct ieee80211_conf *conf = &hw->conf;
2304         int channel, ret = 0;
2305         bool is_ap;
2306
2307         channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
2308
2309         wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
2310                      " changed 0x%x",
2311                      channel,
2312                      conf->flags & IEEE80211_CONF_PS ? "on" : "off",
2313                      conf->power_level,
2314                      conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
2315                          changed);
2316
2317         /*
2318          * mac80211 will go to idle nearly immediately after transmitting some
2319          * frames, such as the deauth. To make sure those frames reach the air,
2320          * wait here until the TX queue is fully flushed.
2321          */
2322         if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
2323             (conf->flags & IEEE80211_CONF_IDLE))
2324                 wl1271_tx_flush(wl);
2325
2326         mutex_lock(&wl->mutex);
2327
2328         if (unlikely(wl->state == WL1271_STATE_OFF)) {
2329                 /* we support configuring the channel and band while off */
2330                 if ((changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
2331                         wl->band = conf->channel->band;
2332                         wl->channel = channel;
2333                 }
2334
2335                 if ((changed & IEEE80211_CONF_CHANGE_POWER))
2336                         wl->power_level = conf->power_level;
2337
2338                 goto out;
2339         }
2340
2341         is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2342
2343         ret = wl1271_ps_elp_wakeup(wl);
2344         if (ret < 0)
2345                 goto out;
2346
2347         /* if the channel changes while joined, join again */
2348         if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
2349             ((wl->band != conf->channel->band) ||
2350              (wl->channel != channel))) {
2351                 /* send all pending packets */
2352                 wl1271_tx_work_locked(wl);
2353                 wl->band = conf->channel->band;
2354                 wl->channel = channel;
2355
2356                 if (!is_ap) {
2357                         /*
2358                          * FIXME: the mac80211 should really provide a fixed
2359                          * rate to use here. for now, just use the smallest
2360                          * possible rate for the band as a fixed rate for
2361                          * association frames and other control messages.
2362                          */
2363                         if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2364                                 wl1271_set_band_rate(wl);
2365
2366                         wl->basic_rate =
2367                                 wl1271_tx_min_rate_get(wl, wl->basic_rate_set);
2368                         ret = wl1271_acx_sta_rate_policies(wl);
2369                         if (ret < 0)
2370                                 wl1271_warning("rate policy for channel "
2371                                                "failed %d", ret);
2372
2373                         if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
2374                                 if (wl12xx_is_roc(wl)) {
2375                                         /* roaming */
2376                                         ret = wl12xx_croc(wl, wl->dev_role_id);
2377                                         if (ret < 0)
2378                                                 goto out_sleep;
2379                                 }
2380                                 ret = wl1271_join(wl, false);
2381                                 if (ret < 0)
2382                                         wl1271_warning("cmd join on channel "
2383                                                        "failed %d", ret);
2384                         } else {
2385                                 /*
2386                                  * change the ROC channel. do it only if we are
2387                                  * not idle. otherwise, CROC will be called
2388                                  * anyway.
2389                                  */
2390                                 if (wl12xx_is_roc(wl) &&
2391                                     !(conf->flags & IEEE80211_CONF_IDLE)) {
2392                                         ret = wl12xx_croc(wl, wl->dev_role_id);
2393                                         if (ret < 0)
2394                                                 goto out_sleep;
2395
2396                                         ret = wl12xx_roc(wl, wl->dev_role_id);
2397                                         if (ret < 0)
2398                                                 wl1271_warning("roc failed %d",
2399                                                                ret);
2400                                 }
2401                         }
2402                 }
2403         }
2404
2405         if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
2406                 ret = wl1271_sta_handle_idle(wl,
2407                                         conf->flags & IEEE80211_CONF_IDLE);
2408                 if (ret < 0)
2409                         wl1271_warning("idle mode change failed %d", ret);
2410         }
2411
2412         /*
2413          * if mac80211 changes the PSM mode, make sure the mode is not
2414          * incorrectly changed after the pspoll failure active window.
2415          */
2416         if (changed & IEEE80211_CONF_CHANGE_PS)
2417                 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
2418
2419         if (conf->flags & IEEE80211_CONF_PS &&
2420             !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
2421                 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
2422
2423                 /*
2424                  * We enter PSM only if we're already associated.
2425                  * If we're not, we'll enter it when joining an SSID,
2426                  * through the bss_info_changed() hook.
2427                  */
2428                 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
2429                         wl1271_debug(DEBUG_PSM, "psm enabled");
2430                         ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
2431                                                  wl->basic_rate, true);
2432                 }
2433         } else if (!(conf->flags & IEEE80211_CONF_PS) &&
2434                    test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
2435                 wl1271_debug(DEBUG_PSM, "psm disabled");
2436
2437                 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
2438
2439                 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
2440                         ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
2441                                                  wl->basic_rate, true);
2442         }
2443
2444         if (conf->power_level != wl->power_level) {
2445                 ret = wl1271_acx_tx_power(wl, conf->power_level);
2446                 if (ret < 0)
2447                         goto out_sleep;
2448
2449                 wl->power_level = conf->power_level;
2450         }
2451
2452 out_sleep:
2453         wl1271_ps_elp_sleep(wl);
2454
2455 out:
2456         mutex_unlock(&wl->mutex);
2457
2458         return ret;
2459 }
2460
2461 struct wl1271_filter_params {
2462         bool enabled;
2463         int mc_list_length;
2464         u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
2465 };
2466
2467 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
2468                                        struct netdev_hw_addr_list *mc_list)
2469 {
2470         struct wl1271_filter_params *fp;
2471         struct netdev_hw_addr *ha;
2472         struct wl1271 *wl = hw->priv;
2473
2474         if (unlikely(wl->state == WL1271_STATE_OFF))
2475                 return 0;
2476
2477         fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
2478         if (!fp) {
2479                 wl1271_error("Out of memory setting filters.");
2480                 return 0;
2481         }
2482
2483         /* update multicast filtering parameters */
2484         fp->mc_list_length = 0;
2485         if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
2486                 fp->enabled = false;
2487         } else {
2488                 fp->enabled = true;
2489                 netdev_hw_addr_list_for_each(ha, mc_list) {
2490                         memcpy(fp->mc_list[fp->mc_list_length],
2491                                         ha->addr, ETH_ALEN);
2492                         fp->mc_list_length++;
2493                 }
2494         }
2495
2496         return (u64)(unsigned long)fp;
2497 }
2498
2499 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
2500                                   FIF_ALLMULTI | \
2501                                   FIF_FCSFAIL | \
2502                                   FIF_BCN_PRBRESP_PROMISC | \
2503                                   FIF_CONTROL | \
2504                                   FIF_OTHER_BSS)
2505
2506 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
2507                                        unsigned int changed,
2508                                        unsigned int *total, u64 multicast)
2509 {
2510         struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
2511         struct wl1271 *wl = hw->priv;
2512         int ret;
2513
2514         wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
2515                      " total %x", changed, *total);
2516
2517         mutex_lock(&wl->mutex);
2518
2519         *total &= WL1271_SUPPORTED_FILTERS;
2520         changed &= WL1271_SUPPORTED_FILTERS;
2521
2522         if (unlikely(wl->state == WL1271_STATE_OFF))
2523                 goto out;
2524
2525         ret = wl1271_ps_elp_wakeup(wl);
2526         if (ret < 0)
2527                 goto out;
2528
2529         if (wl->bss_type != BSS_TYPE_AP_BSS) {
2530                 if (*total & FIF_ALLMULTI)
2531                         ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
2532                 else if (fp)
2533                         ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
2534                                                            fp->mc_list,
2535                                                            fp->mc_list_length);
2536                 if (ret < 0)
2537                         goto out_sleep;
2538         }
2539
2540         /*
2541          * the fw doesn't provide an api to configure the filters. instead,
2542          * the filters configuration is based on the active roles / ROC
2543          * state.
2544          */
2545
2546 out_sleep:
2547         wl1271_ps_elp_sleep(wl);
2548
2549 out:
2550         mutex_unlock(&wl->mutex);
2551         kfree(fp);
2552 }
2553
2554 static int wl1271_record_ap_key(struct wl1271 *wl, u8 id, u8 key_type,
2555                         u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
2556                         u16 tx_seq_16)
2557 {
2558         struct wl1271_ap_key *ap_key;
2559         int i;
2560
2561         wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
2562
2563         if (key_size > MAX_KEY_SIZE)
2564                 return -EINVAL;
2565
2566         /*
2567          * Find next free entry in ap_keys. Also check we are not replacing
2568          * an existing key.
2569          */
2570         for (i = 0; i < MAX_NUM_KEYS; i++) {
2571                 if (wl->recorded_ap_keys[i] == NULL)
2572                         break;
2573
2574                 if (wl->recorded_ap_keys[i]->id == id) {
2575                         wl1271_warning("trying to record key replacement");
2576                         return -EINVAL;
2577                 }
2578         }
2579
2580         if (i == MAX_NUM_KEYS)
2581                 return -EBUSY;
2582
2583         ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
2584         if (!ap_key)
2585                 return -ENOMEM;
2586
2587         ap_key->id = id;
2588         ap_key->key_type = key_type;
2589         ap_key->key_size = key_size;
2590         memcpy(ap_key->key, key, key_size);
2591         ap_key->hlid = hlid;
2592         ap_key->tx_seq_32 = tx_seq_32;
2593         ap_key->tx_seq_16 = tx_seq_16;
2594
2595         wl->recorded_ap_keys[i] = ap_key;
2596         return 0;
2597 }
2598
2599 static void wl1271_free_ap_keys(struct wl1271 *wl)
2600 {
2601         int i;
2602
2603         for (i = 0; i < MAX_NUM_KEYS; i++) {
2604                 kfree(wl->recorded_ap_keys[i]);
2605                 wl->recorded_ap_keys[i] = NULL;
2606         }
2607 }
2608
2609 static int wl1271_ap_init_hwenc(struct wl1271 *wl)
2610 {
2611         int i, ret = 0;
2612         struct wl1271_ap_key *key;
2613         bool wep_key_added = false;
2614
2615         for (i = 0; i < MAX_NUM_KEYS; i++) {
2616                 u8 hlid;
2617                 if (wl->recorded_ap_keys[i] == NULL)
2618                         break;
2619
2620                 key = wl->recorded_ap_keys[i];
2621                 hlid = key->hlid;
2622                 if (hlid == WL12XX_INVALID_LINK_ID)
2623                         hlid = wl->ap_bcast_hlid;
2624
2625                 ret = wl1271_cmd_set_ap_key(wl, KEY_ADD_OR_REPLACE,
2626                                             key->id, key->key_type,
2627                                             key->key_size, key->key,
2628                                             hlid, key->tx_seq_32,
2629                                             key->tx_seq_16);
2630                 if (ret < 0)
2631                         goto out;
2632
2633                 if (key->key_type == KEY_WEP)
2634                         wep_key_added = true;
2635         }
2636
2637         if (wep_key_added) {
2638                 ret = wl12xx_cmd_set_default_wep_key(wl, wl->default_key,
2639                                                      wl->ap_bcast_hlid);
2640                 if (ret < 0)
2641                         goto out;
2642         }
2643
2644 out:
2645         wl1271_free_ap_keys(wl);
2646         return ret;
2647 }
2648
2649 static int wl1271_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
2650                        u8 key_size, const u8 *key, u32 tx_seq_32,
2651                        u16 tx_seq_16, struct ieee80211_sta *sta)
2652 {
2653         int ret;
2654         bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2655
2656         if (is_ap) {
2657                 struct wl1271_station *wl_sta;
2658                 u8 hlid;
2659
2660                 if (sta) {
2661                         wl_sta = (struct wl1271_station *)sta->drv_priv;
2662                         hlid = wl_sta->hlid;
2663                 } else {
2664                         hlid = wl->ap_bcast_hlid;
2665                 }
2666
2667                 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2668                         /*
2669                          * We do not support removing keys after AP shutdown.
2670                          * Pretend we do to make mac80211 happy.
2671                          */
2672                         if (action != KEY_ADD_OR_REPLACE)
2673                                 return 0;
2674
2675                         ret = wl1271_record_ap_key(wl, id,
2676                                              key_type, key_size,
2677                                              key, hlid, tx_seq_32,
2678                                              tx_seq_16);
2679                 } else {
2680                         ret = wl1271_cmd_set_ap_key(wl, action,
2681                                              id, key_type, key_size,
2682                                              key, hlid, tx_seq_32,
2683                                              tx_seq_16);
2684                 }
2685
2686                 if (ret < 0)
2687                         return ret;
2688         } else {
2689                 const u8 *addr;
2690                 static const u8 bcast_addr[ETH_ALEN] = {
2691                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2692                 };
2693
2694                 /*
2695                  * A STA set to GEM cipher requires 2 tx spare blocks.
2696                  * Return to default value when GEM cipher key is removed
2697                  */
2698                 if (key_type == KEY_GEM) {
2699                         if (action == KEY_ADD_OR_REPLACE)
2700                                 wl->tx_spare_blocks = 2;
2701                         else if (action == KEY_REMOVE)
2702                                 wl->tx_spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
2703                 }
2704
2705                 addr = sta ? sta->addr : bcast_addr;
2706
2707                 if (is_zero_ether_addr(addr)) {
2708                         /* We dont support TX only encryption */
2709                         return -EOPNOTSUPP;
2710                 }
2711
2712                 /* The wl1271 does not allow to remove unicast keys - they
2713                    will be cleared automatically on next CMD_JOIN. Ignore the
2714                    request silently, as we dont want the mac80211 to emit
2715                    an error message. */
2716                 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
2717                         return 0;
2718
2719                 /* don't remove key if hlid was already deleted */
2720                 if (action == KEY_REMOVE &&
2721                     wl->sta_hlid == WL12XX_INVALID_LINK_ID)
2722                         return 0;
2723
2724                 ret = wl1271_cmd_set_sta_key(wl, action,
2725                                              id, key_type, key_size,
2726                                              key, addr, tx_seq_32,
2727                                              tx_seq_16);
2728                 if (ret < 0)
2729                         return ret;
2730
2731                 /* the default WEP key needs to be configured at least once */
2732                 if (key_type == KEY_WEP) {
2733                         ret = wl12xx_cmd_set_default_wep_key(wl,
2734                                                              wl->default_key,
2735                                                              wl->sta_hlid);
2736                         if (ret < 0)
2737                                 return ret;
2738                 }
2739         }
2740
2741         return 0;
2742 }
2743
2744 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2745                              struct ieee80211_vif *vif,
2746                              struct ieee80211_sta *sta,
2747                              struct ieee80211_key_conf *key_conf)
2748 {
2749         struct wl1271 *wl = hw->priv;
2750         int ret;
2751         u32 tx_seq_32 = 0;
2752         u16 tx_seq_16 = 0;
2753         u8 key_type;
2754
2755         wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
2756
2757         wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
2758         wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
2759                      key_conf->cipher, key_conf->keyidx,
2760                      key_conf->keylen, key_conf->flags);
2761         wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
2762
2763         mutex_lock(&wl->mutex);
2764
2765         if (unlikely(wl->state == WL1271_STATE_OFF)) {
2766                 ret = -EAGAIN;
2767                 goto out_unlock;
2768         }
2769
2770         ret = wl1271_ps_elp_wakeup(wl);
2771         if (ret < 0)
2772                 goto out_unlock;
2773
2774         switch (key_conf->cipher) {
2775         case WLAN_CIPHER_SUITE_WEP40:
2776         case WLAN_CIPHER_SUITE_WEP104:
2777                 key_type = KEY_WEP;
2778
2779                 key_conf->hw_key_idx = key_conf->keyidx;
2780                 break;
2781         case WLAN_CIPHER_SUITE_TKIP:
2782                 key_type = KEY_TKIP;
2783
2784                 key_conf->hw_key_idx = key_conf->keyidx;
2785                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2786                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2787                 break;
2788         case WLAN_CIPHER_SUITE_CCMP:
2789                 key_type = KEY_AES;
2790
2791                 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
2792                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2793                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2794                 break;
2795         case WL1271_CIPHER_SUITE_GEM:
2796                 key_type = KEY_GEM;
2797                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2798                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2799                 break;
2800         default:
2801                 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
2802
2803                 ret = -EOPNOTSUPP;
2804                 goto out_sleep;
2805         }
2806
2807         switch (cmd) {
2808         case SET_KEY:
2809                 ret = wl1271_set_key(wl, KEY_ADD_OR_REPLACE,
2810                                  key_conf->keyidx, key_type,
2811                                  key_conf->keylen, key_conf->key,
2812                                  tx_seq_32, tx_seq_16, sta);
2813                 if (ret < 0) {
2814                         wl1271_error("Could not add or replace key");
2815                         goto out_sleep;
2816                 }
2817                 break;
2818
2819         case DISABLE_KEY:
2820                 ret = wl1271_set_key(wl, KEY_REMOVE,
2821                                      key_conf->keyidx, key_type,
2822                                      key_conf->keylen, key_conf->key,
2823                                      0, 0, sta);
2824                 if (ret < 0) {
2825                         wl1271_error("Could not remove key");
2826                         goto out_sleep;
2827                 }
2828                 break;
2829
2830         default:
2831                 wl1271_error("Unsupported key cmd 0x%x", cmd);
2832                 ret = -EOPNOTSUPP;
2833                 break;
2834         }
2835
2836 out_sleep:
2837         wl1271_ps_elp_sleep(wl);
2838
2839 out_unlock:
2840         mutex_unlock(&wl->mutex);
2841
2842         return ret;
2843 }
2844
2845 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
2846                              struct ieee80211_vif *vif,
2847                              struct cfg80211_scan_request *req)
2848 {
2849         struct wl1271 *wl = hw->priv;
2850         int ret;
2851         u8 *ssid = NULL;
2852         size_t len = 0;
2853
2854         wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
2855
2856         if (req->n_ssids) {
2857                 ssid = req->ssids[0].ssid;
2858                 len = req->ssids[0].ssid_len;
2859         }
2860
2861         mutex_lock(&wl->mutex);
2862
2863         if (wl->state == WL1271_STATE_OFF) {
2864                 /*
2865                  * We cannot return -EBUSY here because cfg80211 will expect
2866                  * a call to ieee80211_scan_completed if we do - in this case
2867                  * there won't be any call.
2868                  */
2869                 ret = -EAGAIN;
2870                 goto out;
2871         }
2872
2873         ret = wl1271_ps_elp_wakeup(wl);
2874         if (ret < 0)
2875                 goto out;
2876
2877         /* cancel ROC before scanning */
2878         if (wl12xx_is_roc(wl)) {
2879                 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
2880                         /* don't allow scanning right now */
2881                         ret = -EBUSY;
2882                         goto out_sleep;
2883                 }
2884                 wl12xx_croc(wl, wl->dev_role_id);
2885                 wl12xx_cmd_role_stop_dev(wl);
2886         }
2887
2888         ret = wl1271_scan(hw->priv, ssid, len, req);
2889 out_sleep:
2890         wl1271_ps_elp_sleep(wl);
2891 out:
2892         mutex_unlock(&wl->mutex);
2893
2894         return ret;
2895 }
2896
2897 static void wl1271_op_cancel_hw_scan(struct ieee80211_hw *hw,
2898                                      struct ieee80211_vif *vif)
2899 {
2900         struct wl1271 *wl = hw->priv;
2901         int ret;
2902
2903         wl1271_debug(DEBUG_MAC80211, "mac80211 cancel hw scan");
2904
2905         mutex_lock(&wl->mutex);
2906
2907         if (wl->state == WL1271_STATE_OFF)
2908                 goto out;
2909
2910         if (wl->scan.state == WL1271_SCAN_STATE_IDLE)
2911                 goto out;
2912
2913         ret = wl1271_ps_elp_wakeup(wl);
2914         if (ret < 0)
2915                 goto out;
2916
2917         if (wl->scan.state != WL1271_SCAN_STATE_DONE) {
2918                 ret = wl1271_scan_stop(wl);
2919                 if (ret < 0)
2920                         goto out_sleep;
2921         }
2922         wl->scan.state = WL1271_SCAN_STATE_IDLE;
2923         memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
2924         wl->scan.req = NULL;
2925         ieee80211_scan_completed(wl->hw, true);
2926
2927 out_sleep:
2928         wl1271_ps_elp_sleep(wl);
2929 out:
2930         mutex_unlock(&wl->mutex);
2931
2932         cancel_delayed_work_sync(&wl->scan_complete_work);
2933 }
2934
2935 static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
2936                                       struct ieee80211_vif *vif,
2937                                       struct cfg80211_sched_scan_request *req,
2938                                       struct ieee80211_sched_scan_ies *ies)
2939 {
2940         struct wl1271 *wl = hw->priv;
2941         int ret;
2942
2943         wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");
2944
2945         mutex_lock(&wl->mutex);
2946
2947         ret = wl1271_ps_elp_wakeup(wl);
2948         if (ret < 0)
2949                 goto out;
2950
2951         ret = wl1271_scan_sched_scan_config(wl, req, ies);
2952         if (ret < 0)
2953                 goto out_sleep;
2954
2955         ret = wl1271_scan_sched_scan_start(wl);
2956         if (ret < 0)
2957                 goto out_sleep;
2958
2959         wl->sched_scanning = true;
2960
2961 out_sleep:
2962         wl1271_ps_elp_sleep(wl);
2963 out:
2964         mutex_unlock(&wl->mutex);
2965         return ret;
2966 }
2967
2968 static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
2969                                       struct ieee80211_vif *vif)
2970 {
2971         struct wl1271 *wl = hw->priv;
2972         int ret;
2973
2974         wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");
2975
2976         mutex_lock(&wl->mutex);
2977
2978         ret = wl1271_ps_elp_wakeup(wl);
2979         if (ret < 0)
2980                 goto out;
2981
2982         wl1271_scan_sched_scan_stop(wl);
2983
2984         wl1271_ps_elp_sleep(wl);
2985 out:
2986         mutex_unlock(&wl->mutex);
2987 }
2988
2989 static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
2990 {
2991         struct wl1271 *wl = hw->priv;
2992         int ret = 0;
2993
2994         mutex_lock(&wl->mutex);
2995
2996         if (unlikely(wl->state == WL1271_STATE_OFF)) {
2997                 ret = -EAGAIN;
2998                 goto out;
2999         }
3000
3001         ret = wl1271_ps_elp_wakeup(wl);
3002         if (ret < 0)
3003                 goto out;
3004
3005         ret = wl1271_acx_frag_threshold(wl, value);
3006         if (ret < 0)
3007                 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
3008
3009         wl1271_ps_elp_sleep(wl);
3010
3011 out:
3012         mutex_unlock(&wl->mutex);
3013
3014         return ret;
3015 }
3016
3017 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
3018 {
3019         struct wl1271 *wl = hw->priv;
3020         int ret = 0;
3021
3022         mutex_lock(&wl->mutex);
3023
3024         if (unlikely(wl->state == WL1271_STATE_OFF)) {
3025                 ret = -EAGAIN;
3026                 goto out;
3027         }
3028
3029         ret = wl1271_ps_elp_wakeup(wl);
3030         if (ret < 0)
3031                 goto out;
3032
3033         ret = wl1271_acx_rts_threshold(wl, value);
3034         if (ret < 0)
3035                 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
3036
3037         wl1271_ps_elp_sleep(wl);
3038
3039 out:
3040         mutex_unlock(&wl->mutex);
3041
3042         return ret;
3043 }
3044
3045 static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
3046                             int offset)
3047 {
3048         u8 ssid_len;
3049         const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
3050                                          skb->len - offset);
3051
3052         if (!ptr) {
3053                 wl1271_error("No SSID in IEs!");
3054                 return -ENOENT;
3055         }
3056
3057         ssid_len = ptr[1];
3058         if (ssid_len > IEEE80211_MAX_SSID_LEN) {
3059                 wl1271_error("SSID is too long!");
3060                 return -EINVAL;
3061         }
3062
3063         wl->ssid_len = ssid_len;
3064         memcpy(wl->ssid, ptr+2, ssid_len);
3065         return 0;
3066 }
3067
3068 static void wl12xx_remove_ie(struct sk_buff *skb, u8 eid, int ieoffset)
3069 {
3070         int len;
3071         const u8 *next, *end = skb->data + skb->len;
3072         u8 *ie = (u8 *)cfg80211_find_ie(eid, skb->data + ieoffset,
3073                                         skb->len - ieoffset);
3074         if (!ie)
3075                 return;
3076         len = ie[1] + 2;
3077         next = ie + len;
3078         memmove(ie, next, end - next);
3079         skb_trim(skb, skb->len - len);
3080 }
3081
3082 static void wl12xx_remove_vendor_ie(struct sk_buff *skb,
3083                                             unsigned int oui, u8 oui_type,
3084                                             int ieoffset)
3085 {
3086         int len;
3087         const u8 *next, *end = skb->data + skb->len;
3088         u8 *ie = (u8 *)cfg80211_find_vendor_ie(oui, oui_type,
3089                                                skb->data + ieoffset,
3090                                                skb->len - ieoffset);
3091         if (!ie)
3092                 return;
3093         len = ie[1] + 2;
3094         next = ie + len;
3095         memmove(ie, next, end - next);
3096         skb_trim(skb, skb->len - len);
3097 }
3098
3099 static int wl1271_ap_set_probe_resp_tmpl(struct wl1271 *wl,
3100                                          u8 *probe_rsp_data,
3101                                          size_t probe_rsp_len,
3102                                          u32 rates)
3103 {
3104         struct ieee80211_bss_conf *bss_conf = &wl->vif->bss_conf;
3105         u8 probe_rsp_templ[WL1271_CMD_TEMPL_MAX_SIZE];
3106         int ssid_ie_offset, ie_offset, templ_len;
3107         const u8 *ptr;
3108
3109         /* no need to change probe response if the SSID is set correctly */
3110         if (wl->ssid_len > 0)
3111                 return wl1271_cmd_template_set(wl,
3112                                                CMD_TEMPL_AP_PROBE_RESPONSE,
3113                                                probe_rsp_data,
3114                                                probe_rsp_len, 0,
3115                                                rates);
3116
3117         if (probe_rsp_len + bss_conf->ssid_len > WL1271_CMD_TEMPL_MAX_SIZE) {
3118                 wl1271_error("probe_rsp template too big");
3119                 return -EINVAL;
3120         }
3121
3122         /* start searching from IE offset */
3123         ie_offset = offsetof(struct ieee80211_mgmt, u.probe_resp.variable);
3124
3125         ptr = cfg80211_find_ie(WLAN_EID_SSID, probe_rsp_data + ie_offset,
3126                                probe_rsp_len - ie_offset);
3127         if (!ptr) {
3128                 wl1271_error("No SSID in beacon!");
3129                 return -EINVAL;
3130         }
3131
3132         ssid_ie_offset = ptr - probe_rsp_data;
3133         ptr += (ptr[1] + 2);
3134
3135         memcpy(probe_rsp_templ, probe_rsp_data, ssid_ie_offset);
3136
3137         /* insert SSID from bss_conf */
3138         probe_rsp_templ[ssid_ie_offset] = WLAN_EID_SSID;
3139         probe_rsp_templ[ssid_ie_offset + 1] = bss_conf->ssid_len;
3140         memcpy(probe_rsp_templ + ssid_ie_offset + 2,
3141                bss_conf->ssid, bss_conf->ssid_len);
3142         templ_len = ssid_ie_offset + 2 + bss_conf->ssid_len;
3143
3144         memcpy(probe_rsp_templ + ssid_ie_offset + 2 + bss_conf->ssid_len,
3145                ptr, probe_rsp_len - (ptr - probe_rsp_data));
3146         templ_len += probe_rsp_len - (ptr - probe_rsp_data);
3147
3148         return wl1271_cmd_template_set(wl,
3149                                        CMD_TEMPL_AP_PROBE_RESPONSE,
3150                                        probe_rsp_templ,
3151                                        templ_len, 0,
3152                                        rates);
3153 }
3154
3155 static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
3156                                        struct ieee80211_bss_conf *bss_conf,
3157                                        u32 changed)
3158 {
3159         int ret = 0;
3160
3161         if (changed & BSS_CHANGED_ERP_SLOT) {
3162                 if (bss_conf->use_short_slot)
3163                         ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
3164                 else
3165                         ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
3166                 if (ret < 0) {
3167                         wl1271_warning("Set slot time failed %d", ret);
3168                         goto out;
3169                 }
3170         }
3171
3172         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3173                 if (bss_conf->use_short_preamble)
3174                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
3175                 else
3176                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
3177         }
3178
3179         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
3180                 if (bss_conf->use_cts_prot)
3181                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
3182                 else
3183                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
3184                 if (ret < 0) {
3185                         wl1271_warning("Set ctsprotect failed %d", ret);
3186                         goto out;
3187                 }
3188         }
3189
3190 out:
3191         return ret;
3192 }
3193
3194 static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
3195                                           struct ieee80211_vif *vif,
3196                                           struct ieee80211_bss_conf *bss_conf,
3197                                           u32 changed)
3198 {
3199         bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
3200         int ret = 0;
3201
3202         if ((changed & BSS_CHANGED_BEACON_INT)) {
3203                 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
3204                         bss_conf->beacon_int);
3205
3206                 wl->beacon_int = bss_conf->beacon_int;
3207         }
3208
3209         if ((changed & BSS_CHANGED_BEACON)) {
3210                 struct ieee80211_hdr *hdr;
3211                 u32 min_rate;
3212                 int ieoffset = offsetof(struct ieee80211_mgmt,
3213                                         u.beacon.variable);
3214                 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
3215                 u16 tmpl_id;
3216
3217                 if (!beacon)
3218                         goto out;
3219
3220                 wl1271_debug(DEBUG_MASTER, "beacon updated");
3221
3222                 ret = wl1271_ssid_set(wl, beacon, ieoffset);
3223                 if (ret < 0) {
3224                         dev_kfree_skb(beacon);
3225                         goto out;
3226                 }
3227                 min_rate = wl1271_tx_min_rate_get(wl, wl->basic_rate_set);
3228                 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
3229                                   CMD_TEMPL_BEACON;
3230                 ret = wl1271_cmd_template_set(wl, tmpl_id,
3231                                               beacon->data,
3232                                               beacon->len, 0,
3233                                               min_rate);
3234                 if (ret < 0) {
3235                         dev_kfree_skb(beacon);
3236                         goto out;
3237                 }
3238
3239                 /* remove TIM ie from probe response */
3240                 wl12xx_remove_ie(beacon, WLAN_EID_TIM, ieoffset);
3241
3242                 /*
3243                  * remove p2p ie from probe response.
3244                  * the fw reponds to probe requests that don't include
3245                  * the p2p ie. probe requests with p2p ie will be passed,
3246                  * and will be responded by the supplicant (the spec
3247                  * forbids including the p2p ie when responding to probe
3248                  * requests that didn't include it).
3249                  */
3250                 wl12xx_remove_vendor_ie(beacon, WLAN_OUI_WFA,
3251                                         WLAN_OUI_TYPE_WFA_P2P, ieoffset);
3252
3253                 hdr = (struct ieee80211_hdr *) beacon->data;
3254                 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
3255                                                  IEEE80211_STYPE_PROBE_RESP);
3256                 if (is_ap)
3257                         ret = wl1271_ap_set_probe_resp_tmpl(wl,
3258                                                 beacon->data,
3259                                                 beacon->len,
3260                                                 min_rate);
3261                 else
3262                         ret = wl1271_cmd_template_set(wl,
3263                                                 CMD_TEMPL_PROBE_RESPONSE,
3264                                                 beacon->data,
3265                                                 beacon->len, 0,
3266                                                 min_rate);
3267                 dev_kfree_skb(beacon);
3268                 if (ret < 0)
3269                         goto out;
3270         }
3271
3272 out:
3273         return ret;
3274 }
3275
3276 /* AP mode changes */
3277 static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
3278                                        struct ieee80211_vif *vif,
3279                                        struct ieee80211_bss_conf *bss_conf,
3280                                        u32 changed)
3281 {
3282         int ret = 0;
3283
3284         if ((changed & BSS_CHANGED_BASIC_RATES)) {
3285                 u32 rates = bss_conf->basic_rates;
3286
3287                 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates,
3288                                                                  wl->band);
3289                 wl->basic_rate = wl1271_tx_min_rate_get(wl,
3290                                                         wl->basic_rate_set);
3291
3292                 ret = wl1271_init_ap_rates(wl);
3293                 if (ret < 0) {
3294                         wl1271_error("AP rate policy change failed %d", ret);
3295                         goto out;
3296                 }
3297
3298                 ret = wl1271_ap_init_templates(wl);
3299                 if (ret < 0)
3300                         goto out;
3301         }
3302
3303         ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
3304         if (ret < 0)
3305                 goto out;
3306
3307         if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
3308                 if (bss_conf->enable_beacon) {
3309                         if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
3310                                 ret = wl12xx_cmd_role_start_ap(wl);
3311                                 if (ret < 0)
3312                                         goto out;
3313
3314                                 ret = wl1271_ap_init_hwenc(wl);
3315                                 if (ret < 0)
3316                                         goto out;
3317
3318                                 set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
3319                                 wl1271_debug(DEBUG_AP, "started AP");
3320                         }
3321                 } else {
3322                         if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
3323                                 ret = wl12xx_cmd_role_stop_ap(wl);
3324                                 if (ret < 0)
3325                                         goto out;
3326
3327                                 clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
3328                                 wl1271_debug(DEBUG_AP, "stopped AP");
3329                         }
3330                 }
3331         }
3332
3333         ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
3334         if (ret < 0)
3335                 goto out;
3336
3337         /* Handle HT information change */
3338         if ((changed & BSS_CHANGED_HT) &&
3339             (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3340                 ret = wl1271_acx_set_ht_information(wl,
3341                                         bss_conf->ht_operation_mode);
3342                 if (ret < 0) {
3343                         wl1271_warning("Set ht information failed %d", ret);
3344                         goto out;
3345                 }
3346         }
3347
3348 out:
3349         return;
3350 }
3351
3352 /* STA/IBSS mode changes */
3353 static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
3354                                         struct ieee80211_vif *vif,
3355                                         struct ieee80211_bss_conf *bss_conf,
3356                                         u32 changed)
3357 {
3358         bool do_join = false, set_assoc = false;
3359         bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
3360         bool ibss_joined = false;
3361         u32 sta_rate_set = 0;
3362         int ret;
3363         struct ieee80211_sta *sta;
3364         bool sta_exists = false;
3365         struct ieee80211_sta_ht_cap sta_ht_cap;
3366
3367         if (is_ibss) {
3368                 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
3369                                                      changed);
3370                 if (ret < 0)
3371                         goto out;
3372         }
3373
3374         if (changed & BSS_CHANGED_IBSS) {
3375                 if (bss_conf->ibss_joined) {
3376                         set_bit(WL1271_FLAG_IBSS_JOINED, &wl->flags);
3377                         ibss_joined = true;
3378                 } else {
3379                         if (test_and_clear_bit(WL1271_FLAG_IBSS_JOINED,
3380                                                &wl->flags)) {
3381                                 wl1271_unjoin(wl);
3382                                 wl12xx_cmd_role_start_dev(wl);
3383                                 wl12xx_roc(wl, wl->dev_role_id);
3384                         }
3385                 }
3386         }
3387
3388         if ((changed & BSS_CHANGED_BEACON_INT) && ibss_joined)
3389                 do_join = true;
3390
3391         /* Need to update the SSID (for filtering etc) */
3392         if ((changed & BSS_CHANGED_BEACON) && ibss_joined)
3393                 do_join = true;
3394
3395         if ((changed & BSS_CHANGED_BEACON_ENABLED) && ibss_joined) {
3396                 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
3397                              bss_conf->enable_beacon ? "enabled" : "disabled");
3398
3399                 if (bss_conf->enable_beacon)
3400                         wl->set_bss_type = BSS_TYPE_IBSS;
3401                 else
3402                         wl->set_bss_type = BSS_TYPE_STA_BSS;
3403                 do_join = true;
3404         }
3405
3406         if ((changed & BSS_CHANGED_CQM)) {
3407                 bool enable = false;
3408                 if (bss_conf->cqm_rssi_thold)
3409                         enable = true;
3410                 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
3411                                                   bss_conf->cqm_rssi_thold,
3412                                                   bss_conf->cqm_rssi_hyst);
3413                 if (ret < 0)
3414                         goto out;
3415                 wl->rssi_thold = bss_conf->cqm_rssi_thold;
3416         }
3417
3418         if ((changed & BSS_CHANGED_BSSID) &&
3419             /*
3420              * Now we know the correct bssid, so we send a new join command
3421              * and enable the BSSID filter
3422              */
3423             memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
3424                 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
3425
3426                 if (!is_zero_ether_addr(wl->bssid)) {
3427                         ret = wl1271_cmd_build_null_data(wl);
3428                         if (ret < 0)
3429                                 goto out;
3430
3431                         ret = wl1271_build_qos_null_data(wl);
3432                         if (ret < 0)
3433                                 goto out;
3434
3435                         /* Need to update the BSSID (for filtering etc) */
3436                         do_join = true;
3437                 }
3438         }
3439
3440         if (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_HT)) {
3441                 rcu_read_lock();
3442                 sta = ieee80211_find_sta(vif, bss_conf->bssid);
3443                 if (!sta)
3444                         goto sta_not_found;
3445
3446                 /* save the supp_rates of the ap */
3447                 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
3448                 if (sta->ht_cap.ht_supported)
3449                         sta_rate_set |=
3450                             (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
3451                 sta_ht_cap = sta->ht_cap;
3452                 sta_exists = true;
3453
3454 sta_not_found:
3455                 rcu_read_unlock();
3456         }
3457
3458         if ((changed & BSS_CHANGED_ASSOC)) {
3459                 if (bss_conf->assoc) {
3460                         u32 rates;
3461                         int ieoffset;
3462                         wl->aid = bss_conf->aid;
3463                         set_assoc = true;
3464
3465                         wl->ps_poll_failures = 0;
3466
3467                         /*
3468                          * use basic rates from AP, and determine lowest rate
3469                          * to use with control frames.
3470                          */
3471                         rates = bss_conf->basic_rates;
3472                         wl->basic_rate_set =
3473                                 wl1271_tx_enabled_rates_get(wl, rates,
3474                                                             wl->band);
3475                         wl->basic_rate =
3476                                 wl1271_tx_min_rate_get(wl, wl->basic_rate_set);
3477                         if (sta_rate_set)
3478                                 wl->rate_set = wl1271_tx_enabled_rates_get(wl,
3479                                                                 sta_rate_set,
3480                                                                 wl->band);
3481                         ret = wl1271_acx_sta_rate_policies(wl);
3482                         if (ret < 0)
3483                                 goto out;
3484
3485                         /*
3486                          * with wl1271, we don't need to update the
3487                          * beacon_int and dtim_period, because the firmware
3488                          * updates it by itself when the first beacon is
3489                          * received after a join.
3490                          */
3491                         ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
3492                         if (ret < 0)
3493                                 goto out;
3494
3495                         /*
3496                          * Get a template for hardware connection maintenance
3497                          */
3498                         dev_kfree_skb(wl->probereq);
3499                         wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL);
3500                         ieoffset = offsetof(struct ieee80211_mgmt,
3501                                             u.probe_req.variable);
3502                         wl1271_ssid_set(wl, wl->probereq, ieoffset);
3503
3504                         /* enable the connection monitoring feature */
3505                         ret = wl1271_acx_conn_monit_params(wl, true);
3506                         if (ret < 0)
3507                                 goto out;
3508                 } else {
3509                         /* use defaults when not associated */
3510                         bool was_assoc =
3511                             !!test_and_clear_bit(WL1271_FLAG_STA_ASSOCIATED,
3512                                                  &wl->flags);
3513                         bool was_ifup =
3514                             !!test_and_clear_bit(WL1271_FLAG_STA_STATE_SENT,
3515                                                  &wl->flags);
3516                         wl->aid = 0;
3517
3518                         /* free probe-request template */
3519                         dev_kfree_skb(wl->probereq);
3520                         wl->probereq = NULL;
3521
3522                         /* re-enable dynamic ps - just in case */
3523                         ieee80211_enable_dyn_ps(wl->vif);
3524
3525                         /* revert back to minimum rates for the current band */
3526                         wl1271_set_band_rate(wl);
3527                         wl->basic_rate =
3528                                 wl1271_tx_min_rate_get(wl, wl->basic_rate_set);
3529                         ret = wl1271_acx_sta_rate_policies(wl);
3530                         if (ret < 0)
3531                                 goto out;
3532
3533                         /* disable connection monitor features */
3534                         ret = wl1271_acx_conn_monit_params(wl, false);
3535
3536                         /* Disable the keep-alive feature */
3537                         ret = wl1271_acx_keep_alive_mode(wl, false);
3538                         if (ret < 0)
3539                                 goto out;
3540
3541                         /* restore the bssid filter and go to dummy bssid */
3542                         if (was_assoc) {
3543                                 u32 conf_flags = wl->hw->conf.flags;
3544                                 /*
3545                                  * we might have to disable roc, if there was
3546                                  * no IF_OPER_UP notification.
3547                                  */
3548                                 if (!was_ifup) {
3549                                         ret = wl12xx_croc(wl, wl->role_id);
3550                                         if (ret < 0)
3551                                                 goto out;
3552                                 }
3553                                 /*
3554                                  * (we also need to disable roc in case of
3555                                  * roaming on the same channel. until we will
3556                                  * have a better flow...)
3557                                  */
3558                                 if (test_bit(wl->dev_role_id, wl->roc_map)) {
3559                                         ret = wl12xx_croc(wl, wl->dev_role_id);
3560                                         if (ret < 0)
3561                                                 goto out;
3562                                 }
3563
3564                                 wl1271_unjoin(wl);
3565                                 if (!(conf_flags & IEEE80211_CONF_IDLE)) {
3566                                         wl12xx_cmd_role_start_dev(wl);
3567                                         wl12xx_roc(wl, wl->dev_role_id);
3568                                 }
3569                         }
3570                 }
3571         }
3572
3573         if (changed & BSS_CHANGED_IBSS) {
3574                 wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
3575                              bss_conf->ibss_joined);
3576
3577                 if (bss_conf->ibss_joined) {
3578                         u32 rates = bss_conf->basic_rates;
3579                         wl->basic_rate_set =
3580                                 wl1271_tx_enabled_rates_get(wl, rates,
3581                                                             wl->band);
3582                         wl->basic_rate =
3583                                 wl1271_tx_min_rate_get(wl, wl->basic_rate_set);
3584
3585                         /* by default, use 11b + OFDM rates */
3586                         wl->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
3587                         ret = wl1271_acx_sta_rate_policies(wl);
3588                         if (ret < 0)
3589                                 goto out;
3590                 }
3591         }
3592
3593         ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
3594         if (ret < 0)
3595                 goto out;
3596
3597         if (changed & BSS_CHANGED_ARP_FILTER) {
3598                 __be32 addr = bss_conf->arp_addr_list[0];
3599                 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3600
3601                 if (bss_conf->arp_addr_cnt == 1 &&
3602                     bss_conf->arp_filter_enabled) {
3603                         /*
3604                          * The template should have been configured only upon
3605                          * association. however, it seems that the correct ip
3606                          * isn't being set (when sending), so we have to
3607                          * reconfigure the template upon every ip change.
3608                          */
3609                         ret = wl1271_cmd_build_arp_rsp(wl, addr);
3610                         if (ret < 0) {
3611                                 wl1271_warning("build arp rsp failed: %d", ret);
3612                                 goto out;
3613                         }
3614
3615                         ret = wl1271_acx_arp_ip_filter(wl,
3616                                 ACX_ARP_FILTER_ARP_FILTERING,
3617                                 addr);
3618                 } else
3619                         ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
3620
3621                 if (ret < 0)
3622                         goto out;
3623         }
3624
3625         if (do_join) {
3626                 ret = wl1271_join(wl, set_assoc);
3627                 if (ret < 0) {
3628                         wl1271_warning("cmd join failed %d", ret);
3629                         goto out;
3630                 }
3631
3632                 /* ROC until connected (after EAPOL exchange) */
3633                 if (!is_ibss) {
3634                         ret = wl12xx_roc(wl, wl->role_id);
3635                         if (ret < 0)
3636                                 goto out;
3637
3638                         wl1271_check_operstate(wl,
3639                                                ieee80211_get_operstate(vif));
3640                 }
3641                 /*
3642                  * stop device role if started (we might already be in
3643                  * STA role). TODO: make it better.
3644                  */
3645                 if (wl->dev_role_id != WL12XX_INVALID_ROLE_ID) {
3646                         ret = wl12xx_croc(wl, wl->dev_role_id);
3647                         if (ret < 0)
3648                                 goto out;
3649
3650                         ret = wl12xx_cmd_role_stop_dev(wl);
3651                         if (ret < 0)
3652                                 goto out;
3653                 }
3654
3655                 /* If we want to go in PSM but we're not there yet */
3656                 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
3657                     !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
3658                         enum wl1271_cmd_ps_mode mode;
3659
3660                         mode = STATION_POWER_SAVE_MODE;
3661                         ret = wl1271_ps_set_mode(wl, mode,
3662                                                  wl->basic_rate,
3663                                                  true);
3664                         if (ret < 0)
3665                                 goto out;
3666                 }
3667         }
3668
3669         /* Handle new association with HT. Do this after join. */
3670         if (sta_exists) {
3671                 if ((changed & BSS_CHANGED_HT) &&
3672                     (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3673                         ret = wl1271_acx_set_ht_capabilities(wl,
3674                                                              &sta_ht_cap,
3675                                                              true,
3676                                                              wl->sta_hlid);
3677                         if (ret < 0) {
3678                                 wl1271_warning("Set ht cap true failed %d",
3679                                                ret);
3680                                 goto out;
3681                         }
3682                 }
3683                 /* handle new association without HT and disassociation */
3684                 else if (changed & BSS_CHANGED_ASSOC) {
3685                         ret = wl1271_acx_set_ht_capabilities(wl,
3686                                                              &sta_ht_cap,
3687                                                              false,
3688                                                              wl->sta_hlid);
3689                         if (ret < 0) {
3690                                 wl1271_warning("Set ht cap false failed %d",
3691                                                ret);
3692                                 goto out;
3693                         }
3694                 }
3695         }
3696
3697         /* Handle HT information change. Done after join. */
3698         if ((changed & BSS_CHANGED_HT) &&
3699             (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3700                 ret = wl1271_acx_set_ht_information(wl,
3701                                         bss_conf->ht_operation_mode);
3702                 if (ret < 0) {
3703                         wl1271_warning("Set ht information failed %d", ret);
3704                         goto out;
3705                 }
3706         }
3707
3708 out:
3709         return;
3710 }
3711
3712 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
3713                                        struct ieee80211_vif *vif,
3714                                        struct ieee80211_bss_conf *bss_conf,
3715                                        u32 changed)
3716 {
3717         struct wl1271 *wl = hw->priv;
3718         bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
3719         int ret;
3720
3721         wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
3722                      (int)changed);
3723
3724         mutex_lock(&wl->mutex);
3725
3726         if (unlikely(wl->state == WL1271_STATE_OFF))
3727                 goto out;
3728
3729         ret = wl1271_ps_elp_wakeup(wl);
3730         if (ret < 0)
3731                 goto out;
3732
3733         if (is_ap)
3734                 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
3735         else
3736                 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
3737
3738         wl1271_ps_elp_sleep(wl);
3739
3740 out:
3741         mutex_unlock(&wl->mutex);
3742 }
3743
3744 static int wl1271_op_conf_tx(struct ieee80211_hw *hw,
3745                              struct ieee80211_vif *vif, u16 queue,
3746                              const struct ieee80211_tx_queue_params *params)
3747 {
3748         struct wl1271 *wl = hw->priv;
3749         u8 ps_scheme;
3750         int ret = 0;
3751
3752         mutex_lock(&wl->mutex);
3753
3754         wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
3755
3756         if (params->uapsd)
3757                 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
3758         else
3759                 ps_scheme = CONF_PS_SCHEME_LEGACY;
3760
3761         if (wl->state == WL1271_STATE_OFF) {
3762                 /*
3763                  * If the state is off, the parameters will be recorded and
3764                  * configured on init. This happens in AP-mode.
3765                  */
3766                 struct conf_tx_ac_category *conf_ac =
3767                         &wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)];
3768                 struct conf_tx_tid *conf_tid =
3769                         &wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)];
3770
3771                 conf_ac->ac = wl1271_tx_get_queue(queue);
3772                 conf_ac->cw_min = (u8)params->cw_min;
3773                 conf_ac->cw_max = params->cw_max;
3774                 conf_ac->aifsn = params->aifs;
3775                 conf_ac->tx_op_limit = params->txop << 5;
3776
3777                 conf_tid->queue_id = wl1271_tx_get_queue(queue);
3778                 conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF;
3779                 conf_tid->tsid = wl1271_tx_get_queue(queue);
3780                 conf_tid->ps_scheme = ps_scheme;
3781                 conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY;
3782                 conf_tid->apsd_conf[0] = 0;
3783                 conf_tid->apsd_conf[1] = 0;
3784                 goto out;
3785         }
3786
3787         ret = wl1271_ps_elp_wakeup(wl);
3788         if (ret < 0)
3789                 goto out;
3790
3791         /*
3792          * the txop is confed in units of 32us by the mac80211,
3793          * we need us
3794          */
3795         ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
3796                                 params->cw_min, params->cw_max,
3797                                 params->aifs, params->txop << 5);
3798         if (ret < 0)
3799                 goto out_sleep;
3800
3801         ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
3802                                  CONF_CHANNEL_TYPE_EDCF,
3803                                  wl1271_tx_get_queue(queue),
3804                                  ps_scheme, CONF_ACK_POLICY_LEGACY,
3805                                  0, 0);
3806
3807 out_sleep:
3808         wl1271_ps_elp_sleep(wl);
3809
3810 out:
3811         mutex_unlock(&wl->mutex);
3812
3813         return ret;
3814 }
3815
3816 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw,
3817                              struct ieee80211_vif *vif)
3818 {
3819
3820         struct wl1271 *wl = hw->priv;
3821         u64 mactime = ULLONG_MAX;
3822         int ret;
3823
3824         wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
3825
3826         mutex_lock(&wl->mutex);
3827
3828         if (unlikely(wl->state == WL1271_STATE_OFF))
3829                 goto out;
3830
3831         ret = wl1271_ps_elp_wakeup(wl);
3832         if (ret < 0)
3833                 goto out;
3834
3835         ret = wl1271_acx_tsf_info(wl, &mactime);
3836         if (ret < 0)
3837                 goto out_sleep;
3838
3839 out_sleep:
3840         wl1271_ps_elp_sleep(wl);
3841
3842 out:
3843         mutex_unlock(&wl->mutex);
3844         return mactime;
3845 }
3846
3847 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
3848                                 struct survey_info *survey)
3849 {
3850         struct wl1271 *wl = hw->priv;
3851         struct ieee80211_conf *conf = &hw->conf;
3852
3853         if (idx != 0)
3854                 return -ENOENT;
3855
3856         survey->channel = conf->channel;
3857         survey->filled = SURVEY_INFO_NOISE_DBM;
3858         survey->noise = wl->noise;
3859
3860         return 0;
3861 }
3862
3863 static int wl1271_allocate_sta(struct wl1271 *wl,
3864                              struct ieee80211_sta *sta,
3865                              u8 *hlid)
3866 {
3867         struct wl1271_station *wl_sta;
3868         int id;
3869
3870         id = find_first_zero_bit(wl->ap_hlid_map, AP_MAX_STATIONS);
3871         if (id >= AP_MAX_STATIONS) {
3872                 wl1271_warning("could not allocate HLID - too much stations");
3873                 return -EBUSY;
3874         }
3875
3876         wl_sta = (struct wl1271_station *)sta->drv_priv;
3877         set_bit(id, wl->ap_hlid_map);
3878         wl_sta->hlid = WL1271_AP_STA_HLID_START + id;
3879         *hlid = wl_sta->hlid;
3880         memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
3881         wl->active_sta_count++;
3882         return 0;
3883 }
3884
3885 void wl1271_free_sta(struct wl1271 *wl, u8 hlid)
3886 {
3887         int id = hlid - WL1271_AP_STA_HLID_START;
3888
3889         if (hlid < WL1271_AP_STA_HLID_START)
3890                 return;
3891
3892         if (!test_bit(id, wl->ap_hlid_map))
3893                 return;
3894
3895         clear_bit(id, wl->ap_hlid_map);
3896         memset(wl->links[hlid].addr, 0, ETH_ALEN);
3897         wl->links[hlid].ba_bitmap = 0;
3898         wl1271_tx_reset_link_queues(wl, hlid);
3899         __clear_bit(hlid, &wl->ap_ps_map);
3900         __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
3901         wl->active_sta_count--;
3902 }
3903
3904 static int wl1271_op_sta_add(struct ieee80211_hw *hw,
3905                              struct ieee80211_vif *vif,
3906                              struct ieee80211_sta *sta)
3907 {
3908         struct wl1271 *wl = hw->priv;
3909         int ret = 0;
3910         u8 hlid;
3911
3912         mutex_lock(&wl->mutex);
3913
3914         if (unlikely(wl->state == WL1271_STATE_OFF))
3915                 goto out;
3916
3917         if (wl->bss_type != BSS_TYPE_AP_BSS)
3918                 goto out;
3919
3920         wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
3921
3922         ret = wl1271_allocate_sta(wl, sta, &hlid);
3923         if (ret < 0)
3924                 goto out;
3925
3926         ret = wl1271_ps_elp_wakeup(wl);
3927         if (ret < 0)
3928                 goto out_free_sta;
3929
3930         ret = wl12xx_cmd_add_peer(wl, sta, hlid);
3931         if (ret < 0)
3932                 goto out_sleep;
3933
3934         ret = wl12xx_cmd_set_peer_state(wl, hlid);
3935         if (ret < 0)
3936                 goto out_sleep;
3937
3938         ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, true, hlid);
3939         if (ret < 0)
3940                 goto out_sleep;
3941
3942 out_sleep:
3943         wl1271_ps_elp_sleep(wl);
3944
3945 out_free_sta:
3946         if (ret < 0)
3947                 wl1271_free_sta(wl, hlid);
3948
3949 out:
3950         mutex_unlock(&wl->mutex);
3951         return ret;
3952 }
3953
3954 static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
3955                                 struct ieee80211_vif *vif,
3956                                 struct ieee80211_sta *sta)
3957 {
3958         struct wl1271 *wl = hw->priv;
3959         struct wl1271_station *wl_sta;
3960         int ret = 0, id;
3961
3962         mutex_lock(&wl->mutex);
3963
3964         if (unlikely(wl->state == WL1271_STATE_OFF))
3965                 goto out;
3966
3967         if (wl->bss_type != BSS_TYPE_AP_BSS)
3968                 goto out;
3969
3970         wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
3971
3972         wl_sta = (struct wl1271_station *)sta->drv_priv;
3973         id = wl_sta->hlid - WL1271_AP_STA_HLID_START;
3974         if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3975                 goto out;
3976
3977         ret = wl1271_ps_elp_wakeup(wl);
3978         if (ret < 0)
3979                 goto out;
3980
3981         ret = wl12xx_cmd_remove_peer(wl, wl_sta->hlid);
3982         if (ret < 0)
3983                 goto out_sleep;
3984
3985         wl1271_free_sta(wl, wl_sta->hlid);
3986
3987 out_sleep:
3988         wl1271_ps_elp_sleep(wl);
3989
3990 out:
3991         mutex_unlock(&wl->mutex);
3992         return ret;
3993 }
3994
3995 static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
3996                                   struct ieee80211_vif *vif,
3997                                   enum ieee80211_ampdu_mlme_action action,
3998                                   struct ieee80211_sta *sta, u16 tid, u16 *ssn,
3999                                   u8 buf_size)
4000 {
4001         struct wl1271 *wl = hw->priv;
4002         int ret;
4003         u8 hlid, *ba_bitmap;
4004
4005         wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu action %d tid %d", action,
4006                      tid);
4007
4008         /* sanity check - the fields in FW are only 8bits wide */
4009         if (WARN_ON(tid > 0xFF))
4010                 return -ENOTSUPP;
4011
4012         mutex_lock(&wl->mutex);
4013
4014         if (unlikely(wl->state == WL1271_STATE_OFF)) {
4015                 ret = -EAGAIN;
4016                 goto out;
4017         }
4018
4019         if (wl->bss_type == BSS_TYPE_STA_BSS) {
4020                 hlid = wl->sta_hlid;
4021                 ba_bitmap = &wl->ba_rx_bitmap;
4022         } else if (wl->bss_type == BSS_TYPE_AP_BSS) {
4023                 struct wl1271_station *wl_sta;
4024
4025                 wl_sta = (struct wl1271_station *)sta->drv_priv;
4026                 hlid = wl_sta->hlid;
4027                 ba_bitmap = &wl->links[hlid].ba_bitmap;
4028         } else {
4029                 ret = -EINVAL;
4030                 goto out;
4031         }
4032
4033         ret = wl1271_ps_elp_wakeup(wl);
4034         if (ret < 0)
4035                 goto out;
4036
4037         wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu: Rx tid %d action %d",
4038                      tid, action);
4039
4040         switch (action) {
4041         case IEEE80211_AMPDU_RX_START:
4042                 if (!wl->ba_support || !wl->ba_allowed) {
4043                         ret = -ENOTSUPP;
4044                         break;
4045                 }
4046
4047                 if (wl->ba_rx_session_count >= RX_BA_MAX_SESSIONS) {
4048                         ret = -EBUSY;
4049                         wl1271_error("exceeded max RX BA sessions");
4050                         break;
4051                 }
4052
4053                 if (*ba_bitmap & BIT(tid)) {
4054                         ret = -EINVAL;
4055                         wl1271_error("cannot enable RX BA session on active "
4056                                      "tid: %d", tid);
4057                         break;
4058                 }
4059
4060                 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, *ssn, true,
4061                                                          hlid);
4062                 if (!ret) {
4063                         *ba_bitmap |= BIT(tid);
4064                         wl->ba_rx_session_count++;
4065                 }
4066                 break;
4067
4068         case IEEE80211_AMPDU_RX_STOP:
4069                 if (!(*ba_bitmap & BIT(tid))) {
4070                         ret = -EINVAL;
4071                         wl1271_error("no active RX BA session on tid: %d",
4072                                      tid);
4073                         break;
4074                 }
4075
4076                 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, 0, false,
4077                                                          hlid);
4078                 if (!ret) {
4079                         *ba_bitmap &= ~BIT(tid);
4080                         wl->ba_rx_session_count--;
4081                 }
4082                 break;
4083
4084         /*
4085          * The BA initiator session management in FW independently.
4086          * Falling break here on purpose for all TX APDU commands.
4087          */
4088         case IEEE80211_AMPDU_TX_START:
4089         case IEEE80211_AMPDU_TX_STOP:
4090         case IEEE80211_AMPDU_TX_OPERATIONAL:
4091                 ret = -EINVAL;
4092                 break;
4093
4094         default:
4095                 wl1271_error("Incorrect ampdu action id=%x\n", action);
4096                 ret = -EINVAL;
4097         }
4098
4099         wl1271_ps_elp_sleep(wl);
4100
4101 out:
4102         mutex_unlock(&wl->mutex);
4103
4104         return ret;
4105 }
4106
4107 static int wl12xx_set_bitrate_mask(struct ieee80211_hw *hw,
4108                                    struct ieee80211_vif *vif,
4109                                    const struct cfg80211_bitrate_mask *mask)
4110 {
4111         struct wl1271 *wl = hw->priv;
4112         int i;
4113
4114         wl1271_debug(DEBUG_MAC80211, "mac80211 set_bitrate_mask 0x%x 0x%x",
4115                 mask->control[NL80211_BAND_2GHZ].legacy,
4116                 mask->control[NL80211_BAND_5GHZ].legacy);
4117
4118         mutex_lock(&wl->mutex);
4119
4120         for (i = 0; i < IEEE80211_NUM_BANDS; i++)
4121                 wl->bitrate_masks[i] =
4122                         wl1271_tx_enabled_rates_get(wl,
4123                                                     mask->control[i].legacy,
4124                                                     i);
4125         mutex_unlock(&wl->mutex);
4126
4127         return 0;
4128 }
4129
4130 static void wl12xx_op_channel_switch(struct ieee80211_hw *hw,
4131                                      struct ieee80211_channel_switch *ch_switch)
4132 {
4133         struct wl1271 *wl = hw->priv;
4134         int ret;
4135
4136         wl1271_debug(DEBUG_MAC80211, "mac80211 channel switch");
4137
4138         mutex_lock(&wl->mutex);
4139
4140         if (unlikely(wl->state == WL1271_STATE_OFF)) {
4141                 mutex_unlock(&wl->mutex);
4142                 ieee80211_chswitch_done(wl->vif, false);
4143                 return;
4144         }
4145
4146         ret = wl1271_ps_elp_wakeup(wl);
4147         if (ret < 0)
4148                 goto out;
4149
4150         ret = wl12xx_cmd_channel_switch(wl, ch_switch);
4151
4152         if (!ret)
4153                 set_bit(WL1271_FLAG_CS_PROGRESS, &wl->flags);
4154
4155         wl1271_ps_elp_sleep(wl);
4156
4157 out:
4158         mutex_unlock(&wl->mutex);
4159 }
4160
4161 static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
4162 {
4163         struct wl1271 *wl = hw->priv;
4164         bool ret = false;
4165
4166         mutex_lock(&wl->mutex);
4167
4168         if (unlikely(wl->state == WL1271_STATE_OFF))
4169                 goto out;
4170
4171         /* packets are considered pending if in the TX queue or the FW */
4172         ret = (wl1271_tx_total_queue_count(wl) > 0) || (wl->tx_frames_cnt > 0);
4173
4174         /* the above is appropriate for STA mode for PS purposes */
4175         WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
4176
4177 out:
4178         mutex_unlock(&wl->mutex);
4179
4180         return ret;
4181 }
4182
4183 /* can't be const, mac80211 writes to this */
4184 static struct ieee80211_rate wl1271_rates[] = {
4185         { .bitrate = 10,
4186           .hw_value = CONF_HW_BIT_RATE_1MBPS,
4187           .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
4188         { .bitrate = 20,
4189           .hw_value = CONF_HW_BIT_RATE_2MBPS,
4190           .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
4191           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
4192         { .bitrate = 55,
4193           .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
4194           .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
4195           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
4196         { .bitrate = 110,
4197           .hw_value = CONF_HW_BIT_RATE_11MBPS,
4198           .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
4199           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
4200         { .bitrate = 60,
4201           .hw_value = CONF_HW_BIT_RATE_6MBPS,
4202           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
4203         { .bitrate = 90,
4204           .hw_value = CONF_HW_BIT_RATE_9MBPS,
4205           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
4206         { .bitrate = 120,
4207           .hw_value = CONF_HW_BIT_RATE_12MBPS,
4208           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
4209         { .bitrate = 180,
4210           .hw_value = CONF_HW_BIT_RATE_18MBPS,
4211           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
4212         { .bitrate = 240,
4213           .hw_value = CONF_HW_BIT_RATE_24MBPS,
4214           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
4215         { .bitrate = 360,
4216          .hw_value = CONF_HW_BIT_RATE_36MBPS,
4217          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
4218         { .bitrate = 480,
4219           .hw_value = CONF_HW_BIT_RATE_48MBPS,
4220           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
4221         { .bitrate = 540,
4222           .hw_value = CONF_HW_BIT_RATE_54MBPS,
4223           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
4224 };
4225
4226 /* can't be const, mac80211 writes to this */
4227 static struct ieee80211_channel wl1271_channels[] = {
4228         { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
4229         { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
4230         { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
4231         { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
4232         { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
4233         { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
4234         { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
4235         { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
4236         { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
4237         { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
4238         { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
4239         { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
4240         { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
4241         { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
4242 };
4243
4244 /* mapping to indexes for wl1271_rates */
4245 static const u8 wl1271_rate_to_idx_2ghz[] = {
4246         /* MCS rates are used only with 11n */
4247         7,                            /* CONF_HW_RXTX_RATE_MCS7 */
4248         6,                            /* CONF_HW_RXTX_RATE_MCS6 */
4249         5,                            /* CONF_HW_RXTX_RATE_MCS5 */
4250         4,                            /* CONF_HW_RXTX_RATE_MCS4 */
4251         3,                            /* CONF_HW_RXTX_RATE_MCS3 */
4252         2,                            /* CONF_HW_RXTX_RATE_MCS2 */
4253         1,                            /* CONF_HW_RXTX_RATE_MCS1 */
4254         0,                            /* CONF_HW_RXTX_RATE_MCS0 */
4255
4256         11,                            /* CONF_HW_RXTX_RATE_54   */
4257         10,                            /* CONF_HW_RXTX_RATE_48   */
4258         9,                             /* CONF_HW_RXTX_RATE_36   */
4259         8,                             /* CONF_HW_RXTX_RATE_24   */
4260
4261         /* TI-specific rate */
4262         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
4263
4264         7,                             /* CONF_HW_RXTX_RATE_18   */
4265         6,                             /* CONF_HW_RXTX_RATE_12   */
4266         3,                             /* CONF_HW_RXTX_RATE_11   */
4267         5,                             /* CONF_HW_RXTX_RATE_9    */
4268         4,                             /* CONF_HW_RXTX_RATE_6    */
4269         2,                             /* CONF_HW_RXTX_RATE_5_5  */
4270         1,                             /* CONF_HW_RXTX_RATE_2    */
4271         0                              /* CONF_HW_RXTX_RATE_1    */
4272 };
4273
4274 /* 11n STA capabilities */
4275 #define HW_RX_HIGHEST_RATE      72
4276
4277 #define WL12XX_HT_CAP { \
4278         .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
4279                (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
4280         .ht_supported = true, \
4281         .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
4282         .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
4283         .mcs = { \
4284                 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
4285                 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
4286                 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
4287                 }, \
4288 }
4289
4290 /* can't be const, mac80211 writes to this */
4291 static struct ieee80211_supported_band wl1271_band_2ghz = {
4292         .channels = wl1271_channels,
4293         .n_channels = ARRAY_SIZE(wl1271_channels),
4294         .bitrates = wl1271_rates,
4295         .n_bitrates = ARRAY_SIZE(wl1271_rates),
4296         .ht_cap = WL12XX_HT_CAP,
4297 };
4298
4299 /* 5 GHz data rates for WL1273 */
4300 static struct ieee80211_rate wl1271_rates_5ghz[] = {
4301         { .bitrate = 60,
4302           .hw_value = CONF_HW_BIT_RATE_6MBPS,
4303           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
4304         { .bitrate = 90,
4305           .hw_value = CONF_HW_BIT_RATE_9MBPS,
4306           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
4307         { .bitrate = 120,
4308           .hw_value = CONF_HW_BIT_RATE_12MBPS,
4309           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
4310         { .bitrate = 180,
4311           .hw_value = CONF_HW_BIT_RATE_18MBPS,
4312           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
4313         { .bitrate = 240,
4314           .hw_value = CONF_HW_BIT_RATE_24MBPS,
4315           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
4316         { .bitrate = 360,
4317          .hw_value = CONF_HW_BIT_RATE_36MBPS,
4318          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
4319         { .bitrate = 480,
4320           .hw_value = CONF_HW_BIT_RATE_48MBPS,
4321           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
4322         { .bitrate = 540,
4323           .hw_value = CONF_HW_BIT_RATE_54MBPS,
4324           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
4325 };
4326
4327 /* 5 GHz band channels for WL1273 */
4328 static struct ieee80211_channel wl1271_channels_5ghz[] = {
4329         { .hw_value = 7, .center_freq = 5035, .max_power = 25 },
4330         { .hw_value = 8, .center_freq = 5040, .max_power = 25 },
4331         { .hw_value = 9, .center_freq = 5045, .max_power = 25 },
4332         { .hw_value = 11, .center_freq = 5055, .max_power = 25 },
4333         { .hw_value = 12, .center_freq = 5060, .max_power = 25 },
4334         { .hw_value = 16, .center_freq = 5080, .max_power = 25 },
4335         { .hw_value = 34, .center_freq = 5170, .max_power = 25 },
4336         { .hw_value = 36, .center_freq = 5180, .max_power = 25 },
4337         { .hw_value = 38, .center_freq = 5190, .max_power = 25 },
4338         { .hw_value = 40, .center_freq = 5200, .max_power = 25 },
4339         { .hw_value = 42, .center_freq = 5210, .max_power = 25 },
4340         { .hw_value = 44, .center_freq = 5220, .max_power = 25 },
4341         { .hw_value = 46, .center_freq = 5230, .max_power = 25 },
4342         { .hw_value = 48, .center_freq = 5240, .max_power = 25 },
4343         { .hw_value = 52, .center_freq = 5260, .max_power = 25 },
4344         { .hw_value = 56, .center_freq = 5280, .max_power = 25 },
4345         { .hw_value = 60, .center_freq = 5300, .max_power = 25 },
4346         { .hw_value = 64, .center_freq = 5320, .max_power = 25 },
4347         { .hw_value = 100, .center_freq = 5500, .max_power = 25 },
4348         { .hw_value = 104, .center_freq = 5520, .max_power = 25 },
4349         { .hw_value = 108, .center_freq = 5540, .max_power = 25 },
4350         { .hw_value = 112, .center_freq = 5560, .max_power = 25 },
4351         { .hw_value = 116, .center_freq = 5580, .max_power = 25 },
4352         { .hw_value = 120, .center_freq = 5600, .max_power = 25 },
4353         { .hw_value = 124, .center_freq = 5620, .max_power = 25 },
4354         { .hw_value = 128, .center_freq = 5640, .max_power = 25 },
4355         { .hw_value = 132, .center_freq = 5660, .max_power = 25 },
4356         { .hw_value = 136, .center_freq = 5680, .max_power = 25 },
4357         { .hw_value = 140, .center_freq = 5700, .max_power = 25 },
4358         { .hw_value = 149, .center_freq = 5745, .max_power = 25 },
4359         { .hw_value = 153, .center_freq = 5765, .max_power = 25 },
4360         { .hw_value = 157, .center_freq = 5785, .max_power = 25 },
4361         { .hw_value = 161, .center_freq = 5805, .max_power = 25 },
4362         { .hw_value = 165, .center_freq = 5825, .max_power = 25 },
4363 };
4364
4365 /* mapping to indexes for wl1271_rates_5ghz */
4366 static const u8 wl1271_rate_to_idx_5ghz[] = {
4367         /* MCS rates are used only with 11n */
4368         7,                            /* CONF_HW_RXTX_RATE_MCS7 */
4369         6,                            /* CONF_HW_RXTX_RATE_MCS6 */
4370         5,                            /* CONF_HW_RXTX_RATE_MCS5 */
4371         4,                            /* CONF_HW_RXTX_RATE_MCS4 */
4372         3,                            /* CONF_HW_RXTX_RATE_MCS3 */
4373         2,                            /* CONF_HW_RXTX_RATE_MCS2 */
4374         1,                            /* CONF_HW_RXTX_RATE_MCS1 */
4375         0,                            /* CONF_HW_RXTX_RATE_MCS0 */
4376
4377         7,                             /* CONF_HW_RXTX_RATE_54   */
4378         6,                             /* CONF_HW_RXTX_RATE_48   */
4379         5,                             /* CONF_HW_RXTX_RATE_36   */
4380         4,                             /* CONF_HW_RXTX_RATE_24   */
4381
4382         /* TI-specific rate */
4383         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
4384
4385         3,                             /* CONF_HW_RXTX_RATE_18   */
4386         2,                             /* CONF_HW_RXTX_RATE_12   */
4387         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11   */
4388         1,                             /* CONF_HW_RXTX_RATE_9    */
4389         0,                             /* CONF_HW_RXTX_RATE_6    */
4390         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5  */
4391         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2    */
4392         CONF_HW_RXTX_RATE_UNSUPPORTED  /* CONF_HW_RXTX_RATE_1    */
4393 };
4394
4395 static struct ieee80211_supported_band wl1271_band_5ghz = {
4396         .channels = wl1271_channels_5ghz,
4397         .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
4398         .bitrates = wl1271_rates_5ghz,
4399         .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
4400         .ht_cap = WL12XX_HT_CAP,
4401 };
4402
4403 static const u8 *wl1271_band_rate_to_idx[] = {
4404         [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
4405         [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
4406 };
4407
4408 static const struct ieee80211_ops wl1271_ops = {
4409         .start = wl1271_op_start,
4410         .stop = wl1271_op_stop,
4411         .add_interface = wl1271_op_add_interface,
4412         .remove_interface = wl1271_op_remove_interface,
4413 #ifdef CONFIG_PM
4414         .suspend = wl1271_op_suspend,
4415         .resume = wl1271_op_resume,
4416 #endif
4417         .config = wl1271_op_config,
4418         .prepare_multicast = wl1271_op_prepare_multicast,
4419         .configure_filter = wl1271_op_configure_filter,
4420         .tx = wl1271_op_tx,
4421         .set_key = wl1271_op_set_key,
4422         .hw_scan = wl1271_op_hw_scan,
4423         .cancel_hw_scan = wl1271_op_cancel_hw_scan,
4424         .sched_scan_start = wl1271_op_sched_scan_start,
4425         .sched_scan_stop = wl1271_op_sched_scan_stop,
4426         .bss_info_changed = wl1271_op_bss_info_changed,
4427         .set_frag_threshold = wl1271_op_set_frag_threshold,
4428         .set_rts_threshold = wl1271_op_set_rts_threshold,
4429         .conf_tx = wl1271_op_conf_tx,
4430         .get_tsf = wl1271_op_get_tsf,
4431         .get_survey = wl1271_op_get_survey,
4432         .sta_add = wl1271_op_sta_add,
4433         .sta_remove = wl1271_op_sta_remove,
4434         .ampdu_action = wl1271_op_ampdu_action,
4435         .tx_frames_pending = wl1271_tx_frames_pending,
4436         .set_bitrate_mask = wl12xx_set_bitrate_mask,
4437         .channel_switch = wl12xx_op_channel_switch,
4438         CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
4439 };
4440
4441
4442 u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
4443 {
4444         u8 idx;
4445
4446         BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
4447
4448         if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
4449                 wl1271_error("Illegal RX rate from HW: %d", rate);
4450                 return 0;
4451         }
4452
4453         idx = wl1271_band_rate_to_idx[band][rate];
4454         if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
4455                 wl1271_error("Unsupported RX rate from HW: %d", rate);
4456                 return 0;
4457         }
4458
4459         return idx;
4460 }
4461
4462 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
4463                                                struct device_attribute *attr,
4464                                                char *buf)
4465 {
4466         struct wl1271 *wl = dev_get_drvdata(dev);
4467         ssize_t len;
4468
4469         len = PAGE_SIZE;
4470
4471         mutex_lock(&wl->mutex);
4472         len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
4473                        wl->sg_enabled);
4474         mutex_unlock(&wl->mutex);
4475
4476         return len;
4477
4478 }
4479
4480 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
4481                                                 struct device_attribute *attr,
4482                                                 const char *buf, size_t count)
4483 {
4484         struct wl1271 *wl = dev_get_drvdata(dev);
4485         unsigned long res;
4486         int ret;
4487
4488         ret = kstrtoul(buf, 10, &res);
4489         if (ret < 0) {
4490                 wl1271_warning("incorrect value written to bt_coex_mode");
4491                 return count;
4492         }
4493
4494         mutex_lock(&wl->mutex);
4495
4496         res = !!res;
4497
4498         if (res == wl->sg_enabled)
4499                 goto out;
4500
4501         wl->sg_enabled = res;
4502
4503         if (wl->state == WL1271_STATE_OFF)
4504                 goto out;
4505
4506         ret = wl1271_ps_elp_wakeup(wl);
4507         if (ret < 0)
4508                 goto out;
4509
4510         wl1271_acx_sg_enable(wl, wl->sg_enabled);
4511         wl1271_ps_elp_sleep(wl);
4512
4513  out:
4514         mutex_unlock(&wl->mutex);
4515         return count;
4516 }
4517
4518 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
4519                    wl1271_sysfs_show_bt_coex_state,
4520                    wl1271_sysfs_store_bt_coex_state);
4521
4522 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
4523                                            struct device_attribute *attr,
4524                                            char *buf)
4525 {
4526         struct wl1271 *wl = dev_get_drvdata(dev);
4527         ssize_t len;
4528
4529         len = PAGE_SIZE;
4530
4531         mutex_lock(&wl->mutex);
4532         if (wl->hw_pg_ver >= 0)
4533                 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
4534         else
4535                 len = snprintf(buf, len, "n/a\n");
4536         mutex_unlock(&wl->mutex);
4537
4538         return len;
4539 }
4540
4541 static DEVICE_ATTR(hw_pg_ver, S_IRUGO,
4542                    wl1271_sysfs_show_hw_pg_ver, NULL);
4543
4544 static ssize_t wl1271_sysfs_read_fwlog(struct file *filp, struct kobject *kobj,
4545                                        struct bin_attribute *bin_attr,
4546                                        char *buffer, loff_t pos, size_t count)
4547 {
4548         struct device *dev = container_of(kobj, struct device, kobj);
4549         struct wl1271 *wl = dev_get_drvdata(dev);
4550         ssize_t len;
4551         int ret;
4552
4553         ret = mutex_lock_interruptible(&wl->mutex);
4554         if (ret < 0)
4555                 return -ERESTARTSYS;
4556
4557         /* Let only one thread read the log at a time, blocking others */
4558         while (wl->fwlog_size == 0) {
4559                 DEFINE_WAIT(wait);
4560
4561                 prepare_to_wait_exclusive(&wl->fwlog_waitq,
4562                                           &wait,
4563                                           TASK_INTERRUPTIBLE);
4564
4565                 if (wl->fwlog_size != 0) {
4566                         finish_wait(&wl->fwlog_waitq, &wait);
4567                         break;
4568                 }
4569
4570                 mutex_unlock(&wl->mutex);
4571
4572                 schedule();
4573                 finish_wait(&wl->fwlog_waitq, &wait);
4574
4575                 if (signal_pending(current))
4576                         return -ERESTARTSYS;
4577
4578                 ret = mutex_lock_interruptible(&wl->mutex);
4579                 if (ret < 0)
4580                         return -ERESTARTSYS;
4581         }
4582
4583         /* Check if the fwlog is still valid */
4584         if (wl->fwlog_size < 0) {
4585                 mutex_unlock(&wl->mutex);
4586                 return 0;
4587         }
4588
4589         /* Seeking is not supported - old logs are not kept. Disregard pos. */
4590         len = min(count, (size_t)wl->fwlog_size);
4591         wl->fwlog_size -= len;
4592         memcpy(buffer, wl->fwlog, len);
4593
4594         /* Make room for new messages */
4595         memmove(wl->fwlog, wl->fwlog + len, wl->fwlog_size);
4596
4597         mutex_unlock(&wl->mutex);
4598
4599         return len;
4600 }
4601
4602 static struct bin_attribute fwlog_attr = {
4603         .attr = {.name = "fwlog", .mode = S_IRUSR},
4604         .read = wl1271_sysfs_read_fwlog,
4605 };
4606
4607 int wl1271_register_hw(struct wl1271 *wl)
4608 {
4609         int ret;
4610
4611         if (wl->mac80211_registered)
4612                 return 0;
4613
4614         ret = wl1271_fetch_nvs(wl);
4615         if (ret == 0) {
4616                 /* NOTE: The wl->nvs->nvs element must be first, in
4617                  * order to simplify the casting, we assume it is at
4618                  * the beginning of the wl->nvs structure.
4619                  */
4620                 u8 *nvs_ptr = (u8 *)wl->nvs;
4621
4622                 wl->mac_addr[0] = nvs_ptr[11];
4623                 wl->mac_addr[1] = nvs_ptr[10];
4624                 wl->mac_addr[2] = nvs_ptr[6];
4625                 wl->mac_addr[3] = nvs_ptr[5];
4626                 wl->mac_addr[4] = nvs_ptr[4];
4627                 wl->mac_addr[5] = nvs_ptr[3];
4628         }
4629
4630         SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
4631
4632         ret = ieee80211_register_hw(wl->hw);
4633         if (ret < 0) {
4634                 wl1271_error("unable to register mac80211 hw: %d", ret);
4635                 return ret;
4636         }
4637
4638         wl->mac80211_registered = true;
4639
4640         wl1271_debugfs_init(wl);
4641
4642         register_netdevice_notifier(&wl1271_dev_notifier);
4643
4644         wl1271_notice("loaded");
4645
4646         return 0;
4647 }
4648 EXPORT_SYMBOL_GPL(wl1271_register_hw);
4649
4650 void wl1271_unregister_hw(struct wl1271 *wl)
4651 {
4652         if (wl->state == WL1271_STATE_PLT)
4653                 __wl1271_plt_stop(wl);
4654
4655         unregister_netdevice_notifier(&wl1271_dev_notifier);
4656         ieee80211_unregister_hw(wl->hw);
4657         wl->mac80211_registered = false;
4658
4659 }
4660 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
4661
4662 int wl1271_init_ieee80211(struct wl1271 *wl)
4663 {
4664         static const u32 cipher_suites[] = {
4665                 WLAN_CIPHER_SUITE_WEP40,
4666                 WLAN_CIPHER_SUITE_WEP104,
4667                 WLAN_CIPHER_SUITE_TKIP,
4668                 WLAN_CIPHER_SUITE_CCMP,
4669                 WL1271_CIPHER_SUITE_GEM,
4670         };
4671
4672         /* The tx descriptor buffer and the TKIP space. */
4673         wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
4674                 sizeof(struct wl1271_tx_hw_descr);
4675
4676         /* unit us */
4677         /* FIXME: find a proper value */
4678         wl->hw->channel_change_time = 10000;
4679         wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
4680
4681         wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
4682                 IEEE80211_HW_BEACON_FILTER |
4683                 IEEE80211_HW_SUPPORTS_PS |
4684                 IEEE80211_HW_SUPPORTS_UAPSD |
4685                 IEEE80211_HW_HAS_RATE_CONTROL |
4686                 IEEE80211_HW_CONNECTION_MONITOR |
4687                 IEEE80211_HW_SUPPORTS_CQM_RSSI |
4688                 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
4689                 IEEE80211_HW_SPECTRUM_MGMT |
4690                 IEEE80211_HW_AP_LINK_PS |
4691                 IEEE80211_HW_AMPDU_AGGREGATION |
4692                 IEEE80211_HW_TX_AMPDU_SETUP_IN_HW;
4693
4694         wl->hw->wiphy->cipher_suites = cipher_suites;
4695         wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
4696
4697         wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
4698                 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP) |
4699                 BIT(NL80211_IFTYPE_P2P_CLIENT) | BIT(NL80211_IFTYPE_P2P_GO);
4700         wl->hw->wiphy->max_scan_ssids = 1;
4701         wl->hw->wiphy->max_sched_scan_ssids = 16;
4702         wl->hw->wiphy->max_match_sets = 16;
4703         /*
4704          * Maximum length of elements in scanning probe request templates
4705          * should be the maximum length possible for a template, without
4706          * the IEEE80211 header of the template
4707          */
4708         wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_DFLT_SIZE -
4709                         sizeof(struct ieee80211_header);
4710
4711         wl->hw->wiphy->max_sched_scan_ie_len = WL1271_CMD_TEMPL_DFLT_SIZE -
4712                 sizeof(struct ieee80211_header);
4713
4714         wl->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
4715
4716         /* make sure all our channels fit in the scanned_ch bitmask */
4717         BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
4718                      ARRAY_SIZE(wl1271_channels_5ghz) >
4719                      WL1271_MAX_CHANNELS);
4720         /*
4721          * We keep local copies of the band structs because we need to
4722          * modify them on a per-device basis.
4723          */
4724         memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
4725                sizeof(wl1271_band_2ghz));
4726         memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
4727                sizeof(wl1271_band_5ghz));
4728
4729         wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
4730                 &wl->bands[IEEE80211_BAND_2GHZ];
4731         wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
4732                 &wl->bands[IEEE80211_BAND_5GHZ];
4733
4734         wl->hw->queues = 4;
4735         wl->hw->max_rates = 1;
4736
4737         wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
4738
4739         SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
4740
4741         wl->hw->sta_data_size = sizeof(struct wl1271_station);
4742
4743         wl->hw->max_rx_aggregation_subframes = 8;
4744
4745         return 0;
4746 }
4747 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
4748
4749 #define WL1271_DEFAULT_CHANNEL 0
4750
4751 struct ieee80211_hw *wl1271_alloc_hw(void)
4752 {
4753         struct ieee80211_hw *hw;
4754         struct platform_device *plat_dev = NULL;
4755         struct wl1271 *wl;
4756         int i, j, ret;
4757         unsigned int order;
4758
4759         BUILD_BUG_ON(AP_MAX_LINKS > WL12XX_MAX_LINKS);
4760
4761         hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
4762         if (!hw) {
4763                 wl1271_error("could not alloc ieee80211_hw");
4764                 ret = -ENOMEM;
4765                 goto err_hw_alloc;
4766         }
4767
4768         plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
4769         if (!plat_dev) {
4770                 wl1271_error("could not allocate platform_device");
4771                 ret = -ENOMEM;
4772                 goto err_plat_alloc;
4773         }
4774
4775         wl = hw->priv;
4776         memset(wl, 0, sizeof(*wl));
4777
4778         INIT_LIST_HEAD(&wl->list);
4779
4780         wl->hw = hw;
4781         wl->plat_dev = plat_dev;
4782
4783         for (i = 0; i < NUM_TX_QUEUES; i++)
4784                 skb_queue_head_init(&wl->tx_queue[i]);
4785
4786         for (i = 0; i < NUM_TX_QUEUES; i++)
4787                 for (j = 0; j < AP_MAX_LINKS; j++)
4788                         skb_queue_head_init(&wl->links[j].tx_queue[i]);
4789
4790         skb_queue_head_init(&wl->deferred_rx_queue);
4791         skb_queue_head_init(&wl->deferred_tx_queue);
4792
4793         INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
4794         INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
4795         INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
4796         INIT_WORK(&wl->tx_work, wl1271_tx_work);
4797         INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
4798         INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
4799         INIT_WORK(&wl->rx_streaming_enable_work,
4800                   wl1271_rx_streaming_enable_work);
4801         INIT_WORK(&wl->rx_streaming_disable_work,
4802                   wl1271_rx_streaming_disable_work);
4803
4804         wl->freezable_wq = create_freezable_workqueue("wl12xx_wq");
4805         if (!wl->freezable_wq) {
4806                 ret = -ENOMEM;
4807                 goto err_hw;
4808         }
4809
4810         wl->channel = WL1271_DEFAULT_CHANNEL;
4811         wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
4812         wl->default_key = 0;
4813         wl->rx_counter = 0;
4814         wl->psm_entry_retry = 0;
4815         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
4816         wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
4817         wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
4818         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
4819         wl->band = IEEE80211_BAND_2GHZ;
4820         wl->vif = NULL;
4821         wl->flags = 0;
4822         wl->sg_enabled = true;
4823         wl->hw_pg_ver = -1;
4824         wl->bss_type = MAX_BSS_TYPE;
4825         wl->set_bss_type = MAX_BSS_TYPE;
4826         wl->last_tx_hlid = 0;
4827         wl->ap_ps_map = 0;
4828         wl->ap_fw_ps_map = 0;
4829         wl->quirks = 0;
4830         wl->platform_quirks = 0;
4831         wl->sched_scanning = false;
4832         wl->tx_security_seq = 0;
4833         wl->tx_security_last_seq_lsb = 0;
4834         wl->tx_spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
4835         wl->role_id = WL12XX_INVALID_ROLE_ID;
4836         wl->system_hlid = WL12XX_SYSTEM_HLID;
4837         wl->sta_hlid = WL12XX_INVALID_LINK_ID;
4838         wl->dev_role_id = WL12XX_INVALID_ROLE_ID;
4839         wl->dev_hlid = WL12XX_INVALID_LINK_ID;
4840         wl->session_counter = 0;
4841         wl->ap_bcast_hlid = WL12XX_INVALID_LINK_ID;
4842         wl->ap_global_hlid = WL12XX_INVALID_LINK_ID;
4843         wl->active_sta_count = 0;
4844         setup_timer(&wl->rx_streaming_timer, wl1271_rx_streaming_timer,
4845                     (unsigned long) wl);
4846         wl->fwlog_size = 0;
4847         init_waitqueue_head(&wl->fwlog_waitq);
4848
4849         /* The system link is always allocated */
4850         __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
4851
4852         memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
4853         for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
4854                 wl->tx_frames[i] = NULL;
4855
4856         spin_lock_init(&wl->wl_lock);
4857
4858         wl->state = WL1271_STATE_OFF;
4859         mutex_init(&wl->mutex);
4860
4861         /* Apply default driver configuration. */
4862         wl1271_conf_init(wl);
4863         wl->bitrate_masks[IEEE80211_BAND_2GHZ] = wl->conf.tx.basic_rate;
4864         wl->bitrate_masks[IEEE80211_BAND_5GHZ] = wl->conf.tx.basic_rate_5;
4865
4866         order = get_order(WL1271_AGGR_BUFFER_SIZE);
4867         wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
4868         if (!wl->aggr_buf) {
4869                 ret = -ENOMEM;
4870                 goto err_wq;
4871         }
4872
4873         wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
4874         if (!wl->dummy_packet) {
4875                 ret = -ENOMEM;
4876                 goto err_aggr;
4877         }
4878
4879         /* Allocate one page for the FW log */
4880         wl->fwlog = (u8 *)get_zeroed_page(GFP_KERNEL);
4881         if (!wl->fwlog) {
4882                 ret = -ENOMEM;
4883                 goto err_dummy_packet;
4884         }
4885
4886         /* Register platform device */
4887         ret = platform_device_register(wl->plat_dev);
4888         if (ret) {
4889                 wl1271_error("couldn't register platform device");
4890                 goto err_fwlog;
4891         }
4892         dev_set_drvdata(&wl->plat_dev->dev, wl);
4893
4894         /* Create sysfs file to control bt coex state */
4895         ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4896         if (ret < 0) {
4897                 wl1271_error("failed to create sysfs file bt_coex_state");
4898                 goto err_platform;
4899         }
4900
4901         /* Create sysfs file to get HW PG version */
4902         ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4903         if (ret < 0) {
4904                 wl1271_error("failed to create sysfs file hw_pg_ver");
4905                 goto err_bt_coex_state;
4906         }
4907
4908         /* Create sysfs file for the FW log */
4909         ret = device_create_bin_file(&wl->plat_dev->dev, &fwlog_attr);
4910         if (ret < 0) {
4911                 wl1271_error("failed to create sysfs file fwlog");
4912                 goto err_hw_pg_ver;
4913         }
4914
4915         return hw;
4916
4917 err_hw_pg_ver:
4918         device_remove_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4919
4920 err_bt_coex_state:
4921         device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4922
4923 err_platform:
4924         platform_device_unregister(wl->plat_dev);
4925
4926 err_fwlog:
4927         free_page((unsigned long)wl->fwlog);
4928
4929 err_dummy_packet:
4930         dev_kfree_skb(wl->dummy_packet);
4931
4932 err_aggr:
4933         free_pages((unsigned long)wl->aggr_buf, order);
4934
4935 err_wq:
4936         destroy_workqueue(wl->freezable_wq);
4937
4938 err_hw:
4939         wl1271_debugfs_exit(wl);
4940         kfree(plat_dev);
4941
4942 err_plat_alloc:
4943         ieee80211_free_hw(hw);
4944
4945 err_hw_alloc:
4946
4947         return ERR_PTR(ret);
4948 }
4949 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
4950
4951 int wl1271_free_hw(struct wl1271 *wl)
4952 {
4953         /* Unblock any fwlog readers */
4954         mutex_lock(&wl->mutex);
4955         wl->fwlog_size = -1;
4956         wake_up_interruptible_all(&wl->fwlog_waitq);
4957         mutex_unlock(&wl->mutex);
4958
4959         device_remove_bin_file(&wl->plat_dev->dev, &fwlog_attr);
4960
4961         device_remove_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4962
4963         device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4964         platform_device_unregister(wl->plat_dev);
4965         free_page((unsigned long)wl->fwlog);
4966         dev_kfree_skb(wl->dummy_packet);
4967         free_pages((unsigned long)wl->aggr_buf,
4968                         get_order(WL1271_AGGR_BUFFER_SIZE));
4969         kfree(wl->plat_dev);
4970
4971         wl1271_debugfs_exit(wl);
4972
4973         vfree(wl->fw);
4974         wl->fw = NULL;
4975         kfree(wl->nvs);
4976         wl->nvs = NULL;
4977
4978         kfree(wl->fw_status);
4979         kfree(wl->tx_res_if);
4980         destroy_workqueue(wl->freezable_wq);
4981
4982         ieee80211_free_hw(wl->hw);
4983
4984         return 0;
4985 }
4986 EXPORT_SYMBOL_GPL(wl1271_free_hw);
4987
4988 u32 wl12xx_debug_level = DEBUG_NONE;
4989 EXPORT_SYMBOL_GPL(wl12xx_debug_level);
4990 module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
4991 MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
4992
4993 module_param_named(fwlog, fwlog_param, charp, 0);
4994 MODULE_PARM_DESC(keymap,
4995                  "FW logger options: continuous, ondemand, dbgpins or disable");
4996
4997 module_param(bug_on_recovery, bool, S_IRUSR | S_IWUSR);
4998 MODULE_PARM_DESC(bug_on_recovery, "BUG() on fw recovery");
4999
5000 MODULE_LICENSE("GPL");
5001 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
5002 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");