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