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
  34 #include "wl12xx.h"
  35 #include "wl12xx_80211.h"
  36 #include "reg.h"
  37 #include "io.h"
  38 #include "event.h"
  39 #include "tx.h"
  40 #include "rx.h"
  41 #include "ps.h"
  42 #include "init.h"
  43 #include "debugfs.h"
  44 #include "cmd.h"
  45 #include "boot.h"
  46 #include "testmode.h"
  47 #include "scan.h"
  48
  49 #define WL1271_BOOT_RETRIES 3
  50
  51 static struct conf_drv_settings default_conf = {
  52         .sg = {
  53                 .params = {
  54                         [CONF_SG_BT_PER_THRESHOLD]                  = 7500,
  55                         [CONF_SG_HV3_MAX_OVERRIDE]                  = 0,
  56                         [CONF_SG_BT_NFS_SAMPLE_INTERVAL]            = 400,
  57                         [CONF_SG_BT_LOAD_RATIO]                     = 200,
  58                         [CONF_SG_AUTO_PS_MODE]                      = 1,
  59                         [CONF_SG_AUTO_SCAN_PROBE_REQ]               = 170,
  60                         [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3]   = 50,
  61                         [CONF_SG_ANTENNA_CONFIGURATION]             = 0,
  62                         [CONF_SG_BEACON_MISS_PERCENT]               = 60,
  63                         [CONF_SG_RATE_ADAPT_THRESH]                 = 12,
  64                         [CONF_SG_RATE_ADAPT_SNR]                    = 0,
  65                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR]      = 10,
  66                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR]      = 30,
  67                         [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR]      = 8,
  68                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR]       = 20,
  69                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR]       = 50,
  70                         /* Note: with UPSD, this should be 4 */
  71                         [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR]       = 8,
  72                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR]     = 7,
  73                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR]     = 25,
  74                         [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR]     = 20,
  75                         /* Note: with UPDS, this should be 15 */
  76                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR]      = 8,
  77                         /* Note: with UPDS, this should be 50 */
  78                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR]      = 40,
  79                         /* Note: with UPDS, this should be 10 */
  80                         [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR]      = 20,
  81                         [CONF_SG_RXT]                               = 1200,
  82                         [CONF_SG_TXT]                               = 1000,
  83                         [CONF_SG_ADAPTIVE_RXT_TXT]                  = 1,
  84                         [CONF_SG_PS_POLL_TIMEOUT]                   = 10,
  85                         [CONF_SG_UPSD_TIMEOUT]                      = 10,
  86                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
  87                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
  88                         [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
  89                         [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR]  = 8,
  90                         [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR]  = 20,
  91                         [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR]  = 15,
  92                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR]         = 20,
  93                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR]         = 50,
  94                         [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR]         = 10,
  95                         [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3]  = 200,
  96                         [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
  97                         [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME]         = 75,
  98                         [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME]       = 15,
  99                         [CONF_SG_HV3_MAX_SERVED]                    = 6,
 100                         [CONF_SG_DHCP_TIME]                         = 5000,
 101                         [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP]  = 100,
 102                 },
 103                 .state = CONF_SG_PROTECTIVE,
 104         },
 105         .rx = {
 106                 .rx_msdu_life_time           = 512000,
 107                 .packet_detection_threshold  = 0,
 108                 .ps_poll_timeout             = 15,
 109                 .upsd_timeout                = 15,
 110                 .rts_threshold               = 2347,
 111                 .rx_cca_threshold            = 0,
 112                 .irq_blk_threshold           = 0xFFFF,
 113                 .irq_pkt_threshold           = 0,
 114                 .irq_timeout                 = 600,
 115                 .queue_type                  = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
 116         },
 117         .tx = {
 118                 .tx_energy_detection         = 0,
 119                 .sta_rc_conf                 = {
 120                         .enabled_rates       = 0,
 121                         .short_retry_limit   = 10,
 122                         .long_retry_limit    = 10,
 123                         .aflags              = 0,
 124                 },
 125                 .ac_conf_count               = 4,
 126                 .ac_conf                     = {
 127                         [CONF_TX_AC_BE] = {
 128                                 .ac          = CONF_TX_AC_BE,
 129                                 .cw_min      = 15,
 130                                 .cw_max      = 63,
 131                                 .aifsn       = 3,
 132                                 .tx_op_limit = 0,
 133                         },
 134                         [CONF_TX_AC_BK] = {
 135                                 .ac          = CONF_TX_AC_BK,
 136                                 .cw_min      = 15,
 137                                 .cw_max      = 63,
 138                                 .aifsn       = 7,
 139                                 .tx_op_limit = 0,
 140                         },
 141                         [CONF_TX_AC_VI] = {
 142                                 .ac          = CONF_TX_AC_VI,
 143                                 .cw_min      = 15,
 144                                 .cw_max      = 63,
 145                                 .aifsn       = CONF_TX_AIFS_PIFS,
 146                                 .tx_op_limit = 3008,
 147                         },
 148                         [CONF_TX_AC_VO] = {
 149                                 .ac          = CONF_TX_AC_VO,
 150                                 .cw_min      = 15,
 151                                 .cw_max      = 63,
 152                                 .aifsn       = CONF_TX_AIFS_PIFS,
 153                                 .tx_op_limit = 1504,
 154                         },
 155                 },
 156                 .ap_rc_conf                  = {
 157                         [0] = {
 158                                 .enabled_rates = CONF_TX_AP_ENABLED_RATES,
 159                                 .short_retry_limit = 10,
 160                                 .long_retry_limit = 10,
 161                                 .aflags      = 0,
 162                         },
 163                         [1] = {
 164                                 .enabled_rates = CONF_TX_AP_ENABLED_RATES,
 165                                 .short_retry_limit = 10,
 166                                 .long_retry_limit = 10,
 167                                 .aflags      = 0,
 168                         },
 169                         [2] = {
 170                                 .enabled_rates = CONF_TX_AP_ENABLED_RATES,
 171                                 .short_retry_limit = 10,
 172                                 .long_retry_limit = 10,
 173                                 .aflags      = 0,
 174                         },
 175                         [3] = {
 176                                 .enabled_rates = CONF_TX_AP_ENABLED_RATES,
 177                                 .short_retry_limit = 10,
 178                                 .long_retry_limit = 10,
 179                                 .aflags      = 0,
 180                         },
 181                 },
 182                 .ap_mgmt_conf = {
 183                         .enabled_rates       = CONF_TX_AP_DEFAULT_MGMT_RATES,
 184                         .short_retry_limit   = 10,
 185                         .long_retry_limit    = 10,
 186                         .aflags              = 0,
 187                 },
 188                 .ap_bcst_conf = {
 189                         .enabled_rates       = CONF_HW_BIT_RATE_1MBPS,
 190                         .short_retry_limit   = 10,
 191                         .long_retry_limit    = 10,
 192                         .aflags              = 0,
 193                 },
 194                 .ap_max_tx_retries = 100,
 195                 .tid_conf_count = 4,
 196                 .tid_conf = {
 197                         [CONF_TX_AC_BE] = {
 198                                 .queue_id    = CONF_TX_AC_BE,
 199                                 .channel_type = CONF_CHANNEL_TYPE_EDCF,
 200                                 .tsid        = CONF_TX_AC_BE,
 201                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
 202                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
 203                                 .apsd_conf   = {0, 0},
 204                         },
 205                         [CONF_TX_AC_BK] = {
 206                                 .queue_id    = CONF_TX_AC_BK,
 207                                 .channel_type = CONF_CHANNEL_TYPE_EDCF,
 208                                 .tsid        = CONF_TX_AC_BK,
 209                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
 210                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
 211                                 .apsd_conf   = {0, 0},
 212                         },
 213                         [CONF_TX_AC_VI] = {
 214                                 .queue_id    = CONF_TX_AC_VI,
 215                                 .channel_type = CONF_CHANNEL_TYPE_EDCF,
 216                                 .tsid        = CONF_TX_AC_VI,
 217                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
 218                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
 219                                 .apsd_conf   = {0, 0},
 220                         },
 221                         [CONF_TX_AC_VO] = {
 222                                 .queue_id    = CONF_TX_AC_VO,
 223                                 .channel_type = CONF_CHANNEL_TYPE_EDCF,
 224                                 .tsid        = CONF_TX_AC_VO,
 225                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
 226                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
 227                                 .apsd_conf   = {0, 0},
 228                         },
 229                 },
 230                 .frag_threshold              = IEEE80211_MAX_FRAG_THRESHOLD,
 231                 .tx_compl_timeout            = 700,
 232                 .tx_compl_threshold          = 4,
 233                 .basic_rate                  = CONF_HW_BIT_RATE_1MBPS,
 234                 .basic_rate_5                = CONF_HW_BIT_RATE_6MBPS,
 235                 .tmpl_short_retry_limit      = 10,
 236                 .tmpl_long_retry_limit       = 10,
 237         },
 238         .conn = {
 239                 .wake_up_event               = CONF_WAKE_UP_EVENT_DTIM,
 240                 .listen_interval             = 1,
 241                 .bcn_filt_mode               = CONF_BCN_FILT_MODE_ENABLED,
 242                 .bcn_filt_ie_count           = 1,
 243                 .bcn_filt_ie = {
 244                         [0] = {
 245                                 .ie          = WLAN_EID_CHANNEL_SWITCH,
 246                                 .rule        = CONF_BCN_RULE_PASS_ON_APPEARANCE,
 247                         }
 248                 },
 249                 .synch_fail_thold            = 10,
 250                 .bss_lose_timeout            = 100,
 251                 .beacon_rx_timeout           = 10000,
 252                 .broadcast_timeout           = 20000,
 253                 .rx_broadcast_in_ps          = 1,
 254                 .ps_poll_threshold           = 10,
 255                 .ps_poll_recovery_period     = 700,
 256                 .bet_enable                  = CONF_BET_MODE_ENABLE,
 257                 .bet_max_consecutive         = 50,
 258                 .psm_entry_retries           = 5,
 259                 .psm_exit_retries            = 255,
 260                 .psm_entry_nullfunc_retries  = 3,
 261                 .psm_entry_hangover_period   = 1,
 262                 .keep_alive_interval         = 55000,
 263                 .max_listen_interval         = 20,
 264         },
 265         .itrim = {
 266                 .enable = false,
 267                 .timeout = 50000,
 268         },
 269         .pm_config = {
 270                 .host_clk_settling_time = 5000,
 271                 .host_fast_wakeup_support = false
 272         },
 273         .roam_trigger = {
 274                 .trigger_pacing               = 1,
 275                 .avg_weight_rssi_beacon       = 20,
 276                 .avg_weight_rssi_data         = 10,
 277                 .avg_weight_snr_beacon        = 20,
 278                 .avg_weight_snr_data          = 10,
 279         },
 280         .scan = {
 281                 .min_dwell_time_active        = 7500,
 282                 .max_dwell_time_active        = 30000,
 283                 .min_dwell_time_passive       = 100000,
 284                 .max_dwell_time_passive       = 100000,
 285                 .num_probe_reqs               = 2,
 286         },
 287         .rf = {
 288                 .tx_per_channel_power_compensation_2 = {
 289                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 290                 },
 291                 .tx_per_channel_power_compensation_5 = {
 292                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 293                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 294                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 295                 },
 296         },
 297         .ht = {
 298                 .tx_ba_win_size = 64,
 299                 .inactivity_timeout = 10000,
 300         },
 301         .mem_wl127x = {
 302                 .num_stations                 = 1,
 303                 .ssid_profiles                = 1,
 304                 .rx_block_num                 = 70,
 305                 .tx_min_block_num             = 40,
 306                 .dynamic_memory               = 0,
 307                 .min_req_tx_blocks            = 100,
 308                 .min_req_rx_blocks            = 22,
 309                 .tx_min                       = 27,
 310         },
 311         .mem_wl128x = {
 312                 .num_stations                 = 1,
 313                 .ssid_profiles                = 1,
 314                 .rx_block_num                 = 40,
 315                 .tx_min_block_num             = 40,
 316                 .dynamic_memory               = 1,
 317                 .min_req_tx_blocks            = 45,
 318                 .min_req_rx_blocks            = 22,
 319                 .tx_min                       = 27,
 320         },
 321 };
 322
 323 static void __wl1271_op_remove_interface(struct wl1271 *wl);
 324 static void wl1271_free_ap_keys(struct wl1271 *wl);
 325
 326
 327 static void wl1271_device_release(struct device *dev)
 328 {
 329
 330 }
 331
 332 static struct platform_device wl1271_device = {
 333         .name           = "wl1271",
 334         .id             = -1,
 335
 336         /* device model insists to have a release function */
 337         .dev            = {
 338                 .release = wl1271_device_release,
 339         },
 340 };
 341
 342 static DEFINE_MUTEX(wl_list_mutex);
 343 static LIST_HEAD(wl_list);
 344
 345 static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
 346                              void *arg)
 347 {
 348         struct net_device *dev = arg;
 349         struct wireless_dev *wdev;
 350         struct wiphy *wiphy;
 351         struct ieee80211_hw *hw;
 352         struct wl1271 *wl;
 353         struct wl1271 *wl_temp;
 354         int ret = 0;
 355
 356         /* Check that this notification is for us. */
 357         if (what != NETDEV_CHANGE)
 358                 return NOTIFY_DONE;
 359
 360         wdev = dev->ieee80211_ptr;
 361         if (wdev == NULL)
 362                 return NOTIFY_DONE;
 363
 364         wiphy = wdev->wiphy;
 365         if (wiphy == NULL)
 366                 return NOTIFY_DONE;
 367
 368         hw = wiphy_priv(wiphy);
 369         if (hw == NULL)
 370                 return NOTIFY_DONE;
 371
 372         wl_temp = hw->priv;
 373         mutex_lock(&wl_list_mutex);
 374         list_for_each_entry(wl, &wl_list, list) {
 375                 if (wl == wl_temp)
 376                         break;
 377         }
 378         mutex_unlock(&wl_list_mutex);
 379         if (wl != wl_temp)
 380                 return NOTIFY_DONE;
 381
 382         mutex_lock(&wl->mutex);
 383
 384         if (wl->state == WL1271_STATE_OFF)
 385                 goto out;
 386
 387         if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
 388                 goto out;
 389
 390         ret = wl1271_ps_elp_wakeup(wl);
 391         if (ret < 0)
 392                 goto out;
 393
 394         if ((dev->operstate == IF_OPER_UP) &&
 395             !test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags)) {
 396                 wl1271_cmd_set_sta_state(wl);
 397                 wl1271_info("Association completed.");
 398         }
 399
 400         wl1271_ps_elp_sleep(wl);
 401
 402 out:
 403         mutex_unlock(&wl->mutex);
 404
 405         return NOTIFY_OK;
 406 }
 407
 408 static int wl1271_reg_notify(struct wiphy *wiphy,
 409                              struct regulatory_request *request)
 410 {
 411         struct ieee80211_supported_band *band;
 412         struct ieee80211_channel *ch;
 413         int i;
 414
 415         band = wiphy->bands[IEEE80211_BAND_5GHZ];
 416         for (i = 0; i < band->n_channels; i++) {
 417                 ch = &band->channels[i];
 418                 if (ch->flags & IEEE80211_CHAN_DISABLED)
 419                         continue;
 420
 421                 if (ch->flags & IEEE80211_CHAN_RADAR)
 422                         ch->flags |= IEEE80211_CHAN_NO_IBSS |
 423                                      IEEE80211_CHAN_PASSIVE_SCAN;
 424
 425         }
 426
 427         return 0;
 428 }
 429
 430 static void wl1271_conf_init(struct wl1271 *wl)
 431 {
 432
 433         /*
 434          * This function applies the default configuration to the driver. This
 435          * function is invoked upon driver load (spi probe.)
 436          *
 437          * The configuration is stored in a run-time structure in order to
 438          * facilitate for run-time adjustment of any of the parameters. Making
 439          * changes to the configuration structure will apply the new values on
 440          * the next interface up (wl1271_op_start.)
 441          */
 442
 443         /* apply driver default configuration */
 444         memcpy(&wl->conf, &default_conf, sizeof(default_conf));
 445 }
 446
 447
 448 static int wl1271_plt_init(struct wl1271 *wl)
 449 {
 450         struct conf_tx_ac_category *conf_ac;
 451         struct conf_tx_tid *conf_tid;
 452         int ret, i;
 453
 454         if (wl->chip.id == CHIP_ID_1283_PG20)
 455                 ret = wl128x_cmd_general_parms(wl);
 456         else
 457                 ret = wl1271_cmd_general_parms(wl);
 458         if (ret < 0)
 459                 return ret;
 460
 461         if (wl->chip.id == CHIP_ID_1283_PG20)
 462                 ret = wl128x_cmd_radio_parms(wl);
 463         else
 464                 ret = wl1271_cmd_radio_parms(wl);
 465         if (ret < 0)
 466                 return ret;
 467
 468         if (wl->chip.id != CHIP_ID_1283_PG20) {
 469                 ret = wl1271_cmd_ext_radio_parms(wl);
 470                 if (ret < 0)
 471                         return ret;
 472         }
 473         if (ret < 0)
 474                 return ret;
 475
 476         /* Chip-specific initializations */
 477         ret = wl1271_chip_specific_init(wl);
 478         if (ret < 0)
 479                 return ret;
 480
 481         ret = wl1271_sta_init_templates_config(wl);
 482         if (ret < 0)
 483                 return ret;
 484
 485         ret = wl1271_acx_init_mem_config(wl);
 486         if (ret < 0)
 487                 return ret;
 488
 489         /* PHY layer config */
 490         ret = wl1271_init_phy_config(wl);
 491         if (ret < 0)
 492                 goto out_free_memmap;
 493
 494         ret = wl1271_acx_dco_itrim_params(wl);
 495         if (ret < 0)
 496                 goto out_free_memmap;
 497
 498         /* Initialize connection monitoring thresholds */
 499         ret = wl1271_acx_conn_monit_params(wl, false);
 500         if (ret < 0)
 501                 goto out_free_memmap;
 502
 503         /* Bluetooth WLAN coexistence */
 504         ret = wl1271_init_pta(wl);
 505         if (ret < 0)
 506                 goto out_free_memmap;
 507
 508         /* Energy detection */
 509         ret = wl1271_init_energy_detection(wl);
 510         if (ret < 0)
 511                 goto out_free_memmap;
 512
 513         ret = wl1271_acx_sta_mem_cfg(wl);
 514         if (ret < 0)
 515                 goto out_free_memmap;
 516
 517         /* Default fragmentation threshold */
 518         ret = wl1271_acx_frag_threshold(wl, wl->conf.tx.frag_threshold);
 519         if (ret < 0)
 520                 goto out_free_memmap;
 521
 522         /* Default TID/AC configuration */
 523         BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count);
 524         for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
 525                 conf_ac = &wl->conf.tx.ac_conf[i];
 526                 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
 527                                         conf_ac->cw_max, conf_ac->aifsn,
 528                                         conf_ac->tx_op_limit);
 529                 if (ret < 0)
 530                         goto out_free_memmap;
 531
 532                 conf_tid = &wl->conf.tx.tid_conf[i];
 533                 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
 534                                          conf_tid->channel_type,
 535                                          conf_tid->tsid,
 536                                          conf_tid->ps_scheme,
 537                                          conf_tid->ack_policy,
 538                                          conf_tid->apsd_conf[0],
 539                                          conf_tid->apsd_conf[1]);
 540                 if (ret < 0)
 541                         goto out_free_memmap;
 542         }
 543
 544         /* Enable data path */
 545         ret = wl1271_cmd_data_path(wl, 1);
 546         if (ret < 0)
 547                 goto out_free_memmap;
 548
 549         /* Configure for CAM power saving (ie. always active) */
 550         ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
 551         if (ret < 0)
 552                 goto out_free_memmap;
 553
 554         /* configure PM */
 555         ret = wl1271_acx_pm_config(wl);
 556         if (ret < 0)
 557                 goto out_free_memmap;
 558
 559         return 0;
 560
 561  out_free_memmap:
 562         kfree(wl->target_mem_map);
 563         wl->target_mem_map = NULL;
 564
 565         return ret;
 566 }
 567
 568 static void wl1271_irq_ps_regulate_link(struct wl1271 *wl, u8 hlid, u8 tx_blks)
 569 {
 570         bool fw_ps;
 571
 572         /* only regulate station links */
 573         if (hlid < WL1271_AP_STA_HLID_START)
 574                 return;
 575
 576         fw_ps = test_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
 577
 578         /*
 579          * Wake up from high level PS if the STA is asleep with too little
 580          * blocks in FW or if the STA is awake.
 581          */
 582         if (!fw_ps || tx_blks < WL1271_PS_STA_MAX_BLOCKS)
 583                 wl1271_ps_link_end(wl, hlid);
 584
 585         /* Start high-level PS if the STA is asleep with enough blocks in FW */
 586         else if (fw_ps && tx_blks >= WL1271_PS_STA_MAX_BLOCKS)
 587                 wl1271_ps_link_start(wl, hlid, true);
 588 }
 589
 590 static void wl1271_irq_update_links_status(struct wl1271 *wl,
 591                                        struct wl1271_fw_ap_status *status)
 592 {
 593         u32 cur_fw_ps_map;
 594         u8 hlid;
 595
 596         cur_fw_ps_map = le32_to_cpu(status->link_ps_bitmap);
 597         if (wl->ap_fw_ps_map != cur_fw_ps_map) {
 598                 wl1271_debug(DEBUG_PSM,
 599                              "link ps prev 0x%x cur 0x%x changed 0x%x",
 600                              wl->ap_fw_ps_map, cur_fw_ps_map,
 601                              wl->ap_fw_ps_map ^ cur_fw_ps_map);
 602
 603                 wl->ap_fw_ps_map = cur_fw_ps_map;
 604         }
 605
 606         for (hlid = WL1271_AP_STA_HLID_START; hlid < AP_MAX_LINKS; hlid++) {
 607                 u8 cnt = status->tx_lnk_free_blks[hlid] -
 608                         wl->links[hlid].prev_freed_blks;
 609
 610                 wl->links[hlid].prev_freed_blks =
 611                         status->tx_lnk_free_blks[hlid];
 612                 wl->links[hlid].allocated_blks -= cnt;
 613
 614                 wl1271_irq_ps_regulate_link(wl, hlid,
 615                                             wl->links[hlid].allocated_blks);
 616         }
 617 }
 618
 619 static void wl1271_fw_status(struct wl1271 *wl,
 620                              struct wl1271_fw_full_status *full_status)
 621 {
 622         struct wl1271_fw_common_status *status = &full_status->common;
 623         struct timespec ts;
 624         u32 old_tx_blk_count = wl->tx_blocks_available;
 625         u32 total = 0;
 626         int i;
 627
 628         if (wl->bss_type == BSS_TYPE_AP_BSS) {
 629                 wl1271_raw_read(wl, FW_STATUS_ADDR, status,
 630                                 sizeof(struct wl1271_fw_ap_status), false);
 631         } else {
 632                 wl1271_raw_read(wl, FW_STATUS_ADDR, status,
 633                                 sizeof(struct wl1271_fw_sta_status), false);
 634
 635                 /* Update tx total blocks change */
 636                 wl->tx_total_diff +=
 637                         ((struct wl1271_fw_sta_status *)status)->tx_total -
 638                         wl->tx_new_total;
 639
 640                 /* Update total tx blocks */
 641                 wl->tx_new_total =
 642                         ((struct wl1271_fw_sta_status *)status)->tx_total;
 643         }
 644
 645         wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
 646                      "drv_rx_counter = %d, tx_results_counter = %d)",
 647                      status->intr,
 648                      status->fw_rx_counter,
 649                      status->drv_rx_counter,
 650                      status->tx_results_counter);
 651
 652         /* update number of available TX blocks */
 653         for (i = 0; i < NUM_TX_QUEUES; i++) {
 654                 total += le32_to_cpu(status->tx_released_blks[i]) -
 655                         wl->tx_blocks_freed[i];
 656
 657                 wl->tx_blocks_freed[i] =
 658                         le32_to_cpu(status->tx_released_blks[i]);
 659
 660         }
 661
 662         /*
 663          * By adding the freed blocks to tx_total_diff we are actually
 664          * moving them to the RX pool.
 665          */
 666         wl->tx_total_diff += total;
 667
 668         /* if we have positive difference, add the blocks to the TX pool */
 669         if (wl->tx_total_diff >= 0) {
 670                 wl->tx_blocks_available += wl->tx_total_diff;
 671                 wl->tx_total_diff = 0;
 672         }
 673
 674         /* if more blocks are available now, tx work can be scheduled */
 675         if (wl->tx_blocks_available > old_tx_blk_count)
 676                 clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
 677
 678         /* for AP update num of allocated TX blocks per link and ps status */
 679         if (wl->bss_type == BSS_TYPE_AP_BSS)
 680                 wl1271_irq_update_links_status(wl, &full_status->ap);
 681
 682         /* update the host-chipset time offset */
 683         getnstimeofday(&ts);
 684         wl->time_offset = (timespec_to_ns(&ts) >> 10) -
 685                 (s64)le32_to_cpu(status->fw_localtime);
 686 }
 687
 688 static void wl1271_flush_deferred_work(struct wl1271 *wl)
 689 {
 690         struct sk_buff *skb;
 691
 692         /* Pass all received frames to the network stack */
 693         while ((skb = skb_dequeue(&wl->deferred_rx_queue)))
 694                 ieee80211_rx_ni(wl->hw, skb);
 695
 696         /* Return sent skbs to the network stack */
 697         while ((skb = skb_dequeue(&wl->deferred_tx_queue)))
 698                 ieee80211_tx_status(wl->hw, skb);
 699 }
 700
 701 static void wl1271_netstack_work(struct work_struct *work)
 702 {
 703         struct wl1271 *wl =
 704                 container_of(work, struct wl1271, netstack_work);
 705
 706         do {
 707                 wl1271_flush_deferred_work(wl);
 708         } while (skb_queue_len(&wl->deferred_rx_queue));
 709 }
 710
 711 #define WL1271_IRQ_MAX_LOOPS 256
 712
 713 irqreturn_t wl1271_irq(int irq, void *cookie)
 714 {
 715         int ret;
 716         u32 intr;
 717         int loopcount = WL1271_IRQ_MAX_LOOPS;
 718         struct wl1271 *wl = (struct wl1271 *)cookie;
 719         bool done = false;
 720         unsigned int defer_count;
 721         unsigned long flags;
 722
 723         /* TX might be handled here, avoid redundant work */
 724         set_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
 725         cancel_work_sync(&wl->tx_work);
 726
 727         mutex_lock(&wl->mutex);
 728
 729         wl1271_debug(DEBUG_IRQ, "IRQ work");
 730
 731         if (unlikely(wl->state == WL1271_STATE_OFF))
 732                 goto out;
 733
 734         ret = wl1271_ps_elp_wakeup(wl);
 735         if (ret < 0)
 736                 goto out;
 737
 738         while (!done && loopcount--) {
 739                 /*
 740                  * In order to avoid a race with the hardirq, clear the flag
 741                  * before acknowledging the chip. Since the mutex is held,
 742                  * wl1271_ps_elp_wakeup cannot be called concurrently.
 743                  */
 744                 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
 745                 smp_mb__after_clear_bit();
 746
 747                 wl1271_fw_status(wl, wl->fw_status);
 748                 intr = le32_to_cpu(wl->fw_status->common.intr);
 749                 intr &= WL1271_INTR_MASK;
 750                 if (!intr) {
 751                         done = true;
 752                         continue;
 753                 }
 754
 755                 if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
 756                         wl1271_error("watchdog interrupt received! "
 757                                      "starting recovery.");
 758                         ieee80211_queue_work(wl->hw, &wl->recovery_work);
 759
 760                         /* restarting the chip. ignore any other interrupt. */
 761                         goto out;
 762                 }
 763
 764                 if (likely(intr & WL1271_ACX_INTR_DATA)) {
 765                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
 766
 767                         wl1271_rx(wl, &wl->fw_status->common);
 768
 769                         /* Check if any tx blocks were freed */
 770                         spin_lock_irqsave(&wl->wl_lock, flags);
 771                         if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
 772                             wl->tx_queue_count) {
 773                                 spin_unlock_irqrestore(&wl->wl_lock, flags);
 774                                 /*
 775                                  * In order to avoid starvation of the TX path,
 776                                  * call the work function directly.
 777                                  */
 778                                 wl1271_tx_work_locked(wl);
 779                         } else {
 780                                 spin_unlock_irqrestore(&wl->wl_lock, flags);
 781                         }
 782
 783                         /* check for tx results */
 784                         if (wl->fw_status->common.tx_results_counter !=
 785                             (wl->tx_results_count & 0xff))
 786                                 wl1271_tx_complete(wl);
 787
 788                         /* Make sure the deferred queues don't get too long */
 789                         defer_count = skb_queue_len(&wl->deferred_tx_queue) +
 790                                       skb_queue_len(&wl->deferred_rx_queue);
 791                         if (defer_count > WL1271_DEFERRED_QUEUE_LIMIT)
 792                                 wl1271_flush_deferred_work(wl);
 793                 }
 794
 795                 if (intr & WL1271_ACX_INTR_EVENT_A) {
 796                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
 797                         wl1271_event_handle(wl, 0);
 798                 }
 799
 800                 if (intr & WL1271_ACX_INTR_EVENT_B) {
 801                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
 802                         wl1271_event_handle(wl, 1);
 803                 }
 804
 805                 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
 806                         wl1271_debug(DEBUG_IRQ,
 807                                      "WL1271_ACX_INTR_INIT_COMPLETE");
 808
 809                 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
 810                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
 811         }
 812
 813         wl1271_ps_elp_sleep(wl);
 814
 815 out:
 816         spin_lock_irqsave(&wl->wl_lock, flags);
 817         /* In case TX was not handled here, queue TX work */
 818         clear_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
 819         if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
 820             wl->tx_queue_count)
 821                 ieee80211_queue_work(wl->hw, &wl->tx_work);
 822         spin_unlock_irqrestore(&wl->wl_lock, flags);
 823
 824         mutex_unlock(&wl->mutex);
 825
 826         return IRQ_HANDLED;
 827 }
 828 EXPORT_SYMBOL_GPL(wl1271_irq);
 829
 830 static int wl1271_fetch_firmware(struct wl1271 *wl)
 831 {
 832         const struct firmware *fw;
 833         const char *fw_name;
 834         int ret;
 835
 836         switch (wl->bss_type) {
 837         case BSS_TYPE_AP_BSS:
 838                 if (wl->chip.id == CHIP_ID_1283_PG20)
 839                         fw_name = WL128X_AP_FW_NAME;
 840                 else
 841                         fw_name = WL127X_AP_FW_NAME;
 842                 break;
 843         case BSS_TYPE_IBSS:
 844         case BSS_TYPE_STA_BSS:
 845                 if (wl->chip.id == CHIP_ID_1283_PG20)
 846                         fw_name = WL128X_FW_NAME;
 847                 else
 848                         fw_name = WL1271_FW_NAME;
 849                 break;
 850         default:
 851                 wl1271_error("no compatible firmware for bss_type %d",
 852                              wl->bss_type);
 853                 return -EINVAL;
 854         }
 855
 856         wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name);
 857
 858         ret = request_firmware(&fw, fw_name, wl1271_wl_to_dev(wl));
 859
 860         if (ret < 0) {
 861                 wl1271_error("could not get firmware: %d", ret);
 862                 return ret;
 863         }
 864
 865         if (fw->size % 4) {
 866                 wl1271_error("firmware size is not multiple of 32 bits: %zu",
 867                              fw->size);
 868                 ret = -EILSEQ;
 869                 goto out;
 870         }
 871
 872         vfree(wl->fw);
 873         wl->fw_len = fw->size;
 874         wl->fw = vmalloc(wl->fw_len);
 875
 876         if (!wl->fw) {
 877                 wl1271_error("could not allocate memory for the firmware");
 878                 ret = -ENOMEM;
 879                 goto out;
 880         }
 881
 882         memcpy(wl->fw, fw->data, wl->fw_len);
 883         wl->fw_bss_type = wl->bss_type;
 884         ret = 0;
 885
 886 out:
 887         release_firmware(fw);
 888
 889         return ret;
 890 }
 891
 892 static int wl1271_fetch_nvs(struct wl1271 *wl)
 893 {
 894         const struct firmware *fw;
 895         int ret;
 896
 897         ret = request_firmware(&fw, WL12XX_NVS_NAME, wl1271_wl_to_dev(wl));
 898
 899         if (ret < 0) {
 900                 wl1271_error("could not get nvs file: %d", ret);
 901                 return ret;
 902         }
 903
 904         wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL);
 905
 906         if (!wl->nvs) {
 907                 wl1271_error("could not allocate memory for the nvs file");
 908                 ret = -ENOMEM;
 909                 goto out;
 910         }
 911
 912         wl->nvs_len = fw->size;
 913
 914 out:
 915         release_firmware(fw);
 916
 917         return ret;
 918 }
 919
 920 static void wl1271_recovery_work(struct work_struct *work)
 921 {
 922         struct wl1271 *wl =
 923                 container_of(work, struct wl1271, recovery_work);
 924
 925         mutex_lock(&wl->mutex);
 926
 927         if (wl->state != WL1271_STATE_ON)
 928                 goto out;
 929
 930         wl1271_info("Hardware recovery in progress.");
 931
 932         if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
 933                 ieee80211_connection_loss(wl->vif);
 934
 935         /* reboot the chipset */
 936         __wl1271_op_remove_interface(wl);
 937         ieee80211_restart_hw(wl->hw);
 938
 939 out:
 940         mutex_unlock(&wl->mutex);
 941 }
 942
 943 static void wl1271_fw_wakeup(struct wl1271 *wl)
 944 {
 945         u32 elp_reg;
 946
 947         elp_reg = ELPCTRL_WAKE_UP;
 948         wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
 949 }
 950
 951 static int wl1271_setup(struct wl1271 *wl)
 952 {
 953         wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
 954         if (!wl->fw_status)
 955                 return -ENOMEM;
 956
 957         wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
 958         if (!wl->tx_res_if) {
 959                 kfree(wl->fw_status);
 960                 return -ENOMEM;
 961         }
 962
 963         return 0;
 964 }
 965
 966 static int wl1271_chip_wakeup(struct wl1271 *wl)
 967 {
 968         struct wl1271_partition_set partition;
 969         int ret = 0;
 970
 971         msleep(WL1271_PRE_POWER_ON_SLEEP);
 972         ret = wl1271_power_on(wl);
 973         if (ret < 0)
 974                 goto out;
 975         msleep(WL1271_POWER_ON_SLEEP);
 976         wl1271_io_reset(wl);
 977         wl1271_io_init(wl);
 978
 979         /* We don't need a real memory partition here, because we only want
 980          * to use the registers at this point. */
 981         memset(&partition, 0, sizeof(partition));
 982         partition.reg.start = REGISTERS_BASE;
 983         partition.reg.size = REGISTERS_DOWN_SIZE;
 984         wl1271_set_partition(wl, &partition);
 985
 986         /* ELP module wake up */
 987         wl1271_fw_wakeup(wl);
 988
 989         /* whal_FwCtrl_BootSm() */
 990
 991         /* 0. read chip id from CHIP_ID */
 992         wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
 993
 994         /* 1. check if chip id is valid */
 995
 996         switch (wl->chip.id) {
 997         case CHIP_ID_1271_PG10:
 998                 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
 999                                wl->chip.id);
1000
1001                 ret = wl1271_setup(wl);
1002                 if (ret < 0)
1003                         goto out;
1004                 break;
1005         case CHIP_ID_1271_PG20:
1006                 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
1007                              wl->chip.id);
1008
1009                 ret = wl1271_setup(wl);
1010                 if (ret < 0)
1011                         goto out;
1012                 break;
1013         case CHIP_ID_1283_PG20:
1014                 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1283 PG20)",
1015                              wl->chip.id);
1016
1017                 ret = wl1271_setup(wl);
1018                 if (ret < 0)
1019                         goto out;
1020                 break;
1021         case CHIP_ID_1283_PG10:
1022         default:
1023                 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
1024                 ret = -ENODEV;
1025                 goto out;
1026         }
1027
1028         /* Make sure the firmware type matches the BSS type */
1029         if (wl->fw == NULL || wl->fw_bss_type != wl->bss_type) {
1030                 ret = wl1271_fetch_firmware(wl);
1031                 if (ret < 0)
1032                         goto out;
1033         }
1034
1035         /* No NVS from netlink, try to get it from the filesystem */
1036         if (wl->nvs == NULL) {
1037                 ret = wl1271_fetch_nvs(wl);
1038                 if (ret < 0)
1039                         goto out;
1040         }
1041
1042 out:
1043         return ret;
1044 }
1045
1046 static unsigned int wl1271_get_fw_ver_quirks(struct wl1271 *wl)
1047 {
1048         unsigned int quirks = 0;
1049         unsigned int *fw_ver = wl->chip.fw_ver;
1050
1051         /* Only for wl127x */
1052         if ((fw_ver[FW_VER_CHIP] == FW_VER_CHIP_WL127X) &&
1053             /* Check STA version */
1054             (((fw_ver[FW_VER_IF_TYPE] == FW_VER_IF_TYPE_STA) &&
1055               (fw_ver[FW_VER_MINOR] < FW_VER_MINOR_1_SPARE_STA_MIN)) ||
1056              /* Check AP version */
1057              ((fw_ver[FW_VER_IF_TYPE] == FW_VER_IF_TYPE_AP) &&
1058               (fw_ver[FW_VER_MINOR] < FW_VER_MINOR_1_SPARE_AP_MIN))))
1059                 quirks |= WL12XX_QUIRK_USE_2_SPARE_BLOCKS;
1060
1061         return quirks;
1062 }
1063
1064 int wl1271_plt_start(struct wl1271 *wl)
1065 {
1066         int retries = WL1271_BOOT_RETRIES;
1067         int ret;
1068
1069         mutex_lock(&wl->mutex);
1070
1071         wl1271_notice("power up");
1072
1073         if (wl->state != WL1271_STATE_OFF) {
1074                 wl1271_error("cannot go into PLT state because not "
1075                              "in off state: %d", wl->state);
1076                 ret = -EBUSY;
1077                 goto out;
1078         }
1079
1080         wl->bss_type = BSS_TYPE_STA_BSS;
1081
1082         while (retries) {
1083                 retries--;
1084                 ret = wl1271_chip_wakeup(wl);
1085                 if (ret < 0)
1086                         goto power_off;
1087
1088                 ret = wl1271_boot(wl);
1089                 if (ret < 0)
1090                         goto power_off;
1091
1092                 ret = wl1271_plt_init(wl);
1093                 if (ret < 0)
1094                         goto irq_disable;
1095
1096                 wl->state = WL1271_STATE_PLT;
1097                 wl1271_notice("firmware booted in PLT mode (%s)",
1098                               wl->chip.fw_ver_str);
1099
1100                 /* Check if any quirks are needed with older fw versions */
1101                 wl->quirks |= wl1271_get_fw_ver_quirks(wl);
1102                 goto out;
1103
1104 irq_disable:
1105                 mutex_unlock(&wl->mutex);
1106                 /* Unlocking the mutex in the middle of handling is
1107                    inherently unsafe. In this case we deem it safe to do,
1108                    because we need to let any possibly pending IRQ out of
1109                    the system (and while we are WL1271_STATE_OFF the IRQ
1110                    work function will not do anything.) Also, any other
1111                    possible concurrent operations will fail due to the
1112                    current state, hence the wl1271 struct should be safe. */
1113                 wl1271_disable_interrupts(wl);
1114                 wl1271_flush_deferred_work(wl);
1115                 cancel_work_sync(&wl->netstack_work);
1116                 mutex_lock(&wl->mutex);
1117 power_off:
1118                 wl1271_power_off(wl);
1119         }
1120
1121         wl1271_error("firmware boot in PLT mode failed despite %d retries",
1122                      WL1271_BOOT_RETRIES);
1123 out:
1124         mutex_unlock(&wl->mutex);
1125
1126         return ret;
1127 }
1128
1129 static int __wl1271_plt_stop(struct wl1271 *wl)
1130 {
1131         int ret = 0;
1132
1133         wl1271_notice("power down");
1134
1135         if (wl->state != WL1271_STATE_PLT) {
1136                 wl1271_error("cannot power down because not in PLT "
1137                              "state: %d", wl->state);
1138                 ret = -EBUSY;
1139                 goto out;
1140         }
1141
1142         wl1271_power_off(wl);
1143
1144         wl->state = WL1271_STATE_OFF;
1145         wl->rx_counter = 0;
1146
1147         mutex_unlock(&wl->mutex);
1148         wl1271_disable_interrupts(wl);
1149         wl1271_flush_deferred_work(wl);
1150         cancel_work_sync(&wl->netstack_work);
1151         cancel_work_sync(&wl->recovery_work);
1152         mutex_lock(&wl->mutex);
1153 out:
1154         return ret;
1155 }
1156
1157 int wl1271_plt_stop(struct wl1271 *wl)
1158 {
1159         int ret;
1160
1161         mutex_lock(&wl->mutex);
1162         ret = __wl1271_plt_stop(wl);
1163         mutex_unlock(&wl->mutex);
1164         return ret;
1165 }
1166
1167 static void wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
1168 {
1169         struct wl1271 *wl = hw->priv;
1170         unsigned long flags;
1171         int q;
1172         u8 hlid = 0;
1173
1174         q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
1175
1176         if (wl->bss_type == BSS_TYPE_AP_BSS)
1177                 hlid = wl1271_tx_get_hlid(skb);
1178
1179         spin_lock_irqsave(&wl->wl_lock, flags);
1180
1181         wl->tx_queue_count++;
1182
1183         /*
1184          * The workqueue is slow to process the tx_queue and we need stop
1185          * the queue here, otherwise the queue will get too long.
1186          */
1187         if (wl->tx_queue_count >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
1188                 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
1189                 ieee80211_stop_queues(wl->hw);
1190                 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
1191         }
1192
1193         /* queue the packet */
1194         if (wl->bss_type == BSS_TYPE_AP_BSS) {
1195                 wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d", hlid, q);
1196                 skb_queue_tail(&wl->links[hlid].tx_queue[q], skb);
1197         } else {
1198                 skb_queue_tail(&wl->tx_queue[q], skb);
1199         }
1200
1201         /*
1202          * The chip specific setup must run before the first TX packet -
1203          * before that, the tx_work will not be initialized!
1204          */
1205
1206         if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
1207             !test_bit(WL1271_FLAG_TX_PENDING, &wl->flags))
1208                 ieee80211_queue_work(wl->hw, &wl->tx_work);
1209
1210         spin_unlock_irqrestore(&wl->wl_lock, flags);
1211 }
1212
1213 #define TX_DUMMY_PACKET_SIZE 1400
1214 int wl1271_tx_dummy_packet(struct wl1271 *wl)
1215 {
1216         struct sk_buff *skb = NULL;
1217         struct ieee80211_hdr_3addr *hdr;
1218         int ret = 0;
1219
1220         skb = dev_alloc_skb(
1221                 sizeof(struct wl1271_tx_hw_descr) + sizeof(*hdr) +
1222                 TX_DUMMY_PACKET_SIZE);
1223         if (!skb) {
1224                 wl1271_warning("failed to allocate buffer for dummy packet");
1225                 ret = -ENOMEM;
1226                 goto out;
1227         }
1228
1229         skb_reserve(skb, sizeof(struct wl1271_tx_hw_descr));
1230
1231         hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr));
1232         memset(hdr, 0, sizeof(*hdr));
1233         hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
1234                                          IEEE80211_FCTL_TODS  |
1235                                          IEEE80211_STYPE_NULLFUNC);
1236
1237         memcpy(hdr->addr1, wl->bssid, ETH_ALEN);
1238         memcpy(hdr->addr2, wl->mac_addr, ETH_ALEN);
1239         memcpy(hdr->addr3, wl->bssid, ETH_ALEN);
1240
1241         skb_put(skb, TX_DUMMY_PACKET_SIZE);
1242
1243         memset(skb->data, 0, TX_DUMMY_PACKET_SIZE);
1244
1245         skb->pkt_type = TX_PKT_TYPE_DUMMY_REQ;
1246         /* Dummy packets require the TID to be management */
1247         skb->priority = WL1271_TID_MGMT;
1248         /* CONF_TX_AC_VO */
1249         skb->queue_mapping = 0;
1250
1251         wl1271_op_tx(wl->hw, skb);
1252
1253 out:
1254         return ret;
1255 }
1256
1257 static struct notifier_block wl1271_dev_notifier = {
1258         .notifier_call = wl1271_dev_notify,
1259 };
1260
1261 static int wl1271_op_start(struct ieee80211_hw *hw)
1262 {
1263         wl1271_debug(DEBUG_MAC80211, "mac80211 start");
1264
1265         /*
1266          * We have to delay the booting of the hardware because
1267          * we need to know the local MAC address before downloading and
1268          * initializing the firmware. The MAC address cannot be changed
1269          * after boot, and without the proper MAC address, the firmware
1270          * will not function properly.
1271          *
1272          * The MAC address is first known when the corresponding interface
1273          * is added. That is where we will initialize the hardware.
1274          *
1275          * In addition, we currently have different firmwares for AP and managed
1276          * operation. We will know which to boot according to interface type.
1277          */
1278
1279         return 0;
1280 }
1281
1282 static void wl1271_op_stop(struct ieee80211_hw *hw)
1283 {
1284         wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
1285 }
1286
1287 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
1288                                    struct ieee80211_vif *vif)
1289 {
1290         struct wl1271 *wl = hw->priv;
1291         struct wiphy *wiphy = hw->wiphy;
1292         int retries = WL1271_BOOT_RETRIES;
1293         int ret = 0;
1294         bool booted = false;
1295
1296         wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
1297                      vif->type, vif->addr);
1298
1299         mutex_lock(&wl->mutex);
1300         if (wl->vif) {
1301                 wl1271_debug(DEBUG_MAC80211,
1302                              "multiple vifs are not supported yet");
1303                 ret = -EBUSY;
1304                 goto out;
1305         }
1306
1307         /*
1308          * in some very corner case HW recovery scenarios its possible to
1309          * get here before __wl1271_op_remove_interface is complete, so
1310          * opt out if that is the case.
1311          */
1312         if (test_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags)) {
1313                 ret = -EBUSY;
1314                 goto out;
1315         }
1316
1317         switch (vif->type) {
1318         case NL80211_IFTYPE_STATION:
1319                 wl->bss_type = BSS_TYPE_STA_BSS;
1320                 wl->set_bss_type = BSS_TYPE_STA_BSS;
1321                 break;
1322         case NL80211_IFTYPE_ADHOC:
1323                 wl->bss_type = BSS_TYPE_IBSS;
1324                 wl->set_bss_type = BSS_TYPE_STA_BSS;
1325                 break;
1326         case NL80211_IFTYPE_AP:
1327                 wl->bss_type = BSS_TYPE_AP_BSS;
1328                 break;
1329         default:
1330                 ret = -EOPNOTSUPP;
1331                 goto out;
1332         }
1333
1334         memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
1335
1336         if (wl->state != WL1271_STATE_OFF) {
1337                 wl1271_error("cannot start because not in off state: %d",
1338                              wl->state);
1339                 ret = -EBUSY;
1340                 goto out;
1341         }
1342
1343         while (retries) {
1344                 retries--;
1345                 ret = wl1271_chip_wakeup(wl);
1346                 if (ret < 0)
1347                         goto power_off;
1348
1349                 ret = wl1271_boot(wl);
1350                 if (ret < 0)
1351                         goto power_off;
1352
1353                 ret = wl1271_hw_init(wl);
1354                 if (ret < 0)
1355                         goto irq_disable;
1356
1357                 booted = true;
1358                 break;
1359
1360 irq_disable:
1361                 mutex_unlock(&wl->mutex);
1362                 /* Unlocking the mutex in the middle of handling is
1363                    inherently unsafe. In this case we deem it safe to do,
1364                    because we need to let any possibly pending IRQ out of
1365                    the system (and while we are WL1271_STATE_OFF the IRQ
1366                    work function will not do anything.) Also, any other
1367                    possible concurrent operations will fail due to the
1368                    current state, hence the wl1271 struct should be safe. */
1369                 wl1271_disable_interrupts(wl);
1370                 wl1271_flush_deferred_work(wl);
1371                 cancel_work_sync(&wl->netstack_work);
1372                 mutex_lock(&wl->mutex);
1373 power_off:
1374                 wl1271_power_off(wl);
1375         }
1376
1377         if (!booted) {
1378                 wl1271_error("firmware boot failed despite %d retries",
1379                              WL1271_BOOT_RETRIES);
1380                 goto out;
1381         }
1382
1383         wl->vif = vif;
1384         wl->state = WL1271_STATE_ON;
1385         set_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags);
1386         wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
1387
1388         /* update hw/fw version info in wiphy struct */
1389         wiphy->hw_version = wl->chip.id;
1390         strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
1391                 sizeof(wiphy->fw_version));
1392
1393         /* Check if any quirks are needed with older fw versions */
1394         wl->quirks |= wl1271_get_fw_ver_quirks(wl);
1395
1396         /*
1397          * Now we know if 11a is supported (info from the NVS), so disable
1398          * 11a channels if not supported
1399          */
1400         if (!wl->enable_11a)
1401                 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
1402
1403         wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
1404                      wl->enable_11a ? "" : "not ");
1405
1406 out:
1407         mutex_unlock(&wl->mutex);
1408
1409         mutex_lock(&wl_list_mutex);
1410         if (!ret)
1411                 list_add(&wl->list, &wl_list);
1412         mutex_unlock(&wl_list_mutex);
1413
1414         return ret;
1415 }
1416
1417 static void __wl1271_op_remove_interface(struct wl1271 *wl)
1418 {
1419         int i;
1420
1421         wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1422
1423         /* because of hardware recovery, we may get here twice */
1424         if (wl->state != WL1271_STATE_ON)
1425                 return;
1426
1427         wl1271_info("down");
1428
1429         mutex_lock(&wl_list_mutex);
1430         list_del(&wl->list);
1431         mutex_unlock(&wl_list_mutex);
1432
1433         /* enable dyn ps just in case (if left on due to fw crash etc) */
1434         if (wl->bss_type == BSS_TYPE_STA_BSS)
1435                 ieee80211_enable_dyn_ps(wl->vif);
1436
1437         if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
1438                 wl->scan.state = WL1271_SCAN_STATE_IDLE;
1439                 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
1440                 wl->scan.req = NULL;
1441                 ieee80211_scan_completed(wl->hw, true);
1442         }
1443
1444         /*
1445          * this must be before the cancel_work calls below, so that the work
1446          * functions don't perform further work.
1447          */
1448         wl->state = WL1271_STATE_OFF;
1449
1450         mutex_unlock(&wl->mutex);
1451
1452         wl1271_disable_interrupts(wl);
1453         wl1271_flush_deferred_work(wl);
1454         cancel_delayed_work_sync(&wl->scan_complete_work);
1455         cancel_work_sync(&wl->netstack_work);
1456         cancel_work_sync(&wl->tx_work);
1457         cancel_delayed_work_sync(&wl->pspoll_work);
1458         cancel_delayed_work_sync(&wl->elp_work);
1459
1460         mutex_lock(&wl->mutex);
1461
1462         /* let's notify MAC80211 about the remaining pending TX frames */
1463         wl1271_tx_reset(wl);
1464         wl1271_power_off(wl);
1465
1466         memset(wl->bssid, 0, ETH_ALEN);
1467         memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1468         wl->ssid_len = 0;
1469         wl->bss_type = MAX_BSS_TYPE;
1470         wl->set_bss_type = MAX_BSS_TYPE;
1471         wl->band = IEEE80211_BAND_2GHZ;
1472
1473         wl->rx_counter = 0;
1474         wl->psm_entry_retry = 0;
1475         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1476         wl->tx_blocks_available = 0;
1477         wl->tx_results_count = 0;
1478         wl->tx_packets_count = 0;
1479         wl->tx_security_last_seq = 0;
1480         wl->tx_security_seq = 0;
1481         wl->time_offset = 0;
1482         wl->session_counter = 0;
1483         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1484         wl->vif = NULL;
1485         wl->filters = 0;
1486         wl1271_free_ap_keys(wl);
1487         memset(wl->ap_hlid_map, 0, sizeof(wl->ap_hlid_map));
1488         wl->ap_fw_ps_map = 0;
1489         wl->ap_ps_map = 0;
1490         wl->block_size = 0;
1491
1492         /*
1493          * this is performed after the cancel_work calls and the associated
1494          * mutex_lock, so that wl1271_op_add_interface does not accidentally
1495          * get executed before all these vars have been reset.
1496          */
1497         wl->flags = 0;
1498
1499         for (i = 0; i < NUM_TX_QUEUES; i++)
1500                 wl->tx_blocks_freed[i] = 0;
1501
1502         wl1271_debugfs_reset(wl);
1503
1504         kfree(wl->fw_status);
1505         wl->fw_status = NULL;
1506         kfree(wl->tx_res_if);
1507         wl->tx_res_if = NULL;
1508         kfree(wl->target_mem_map);
1509         wl->target_mem_map = NULL;
1510 }
1511
1512 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1513                                        struct ieee80211_vif *vif)
1514 {
1515         struct wl1271 *wl = hw->priv;
1516
1517         mutex_lock(&wl->mutex);
1518         /*
1519          * wl->vif can be null here if someone shuts down the interface
1520          * just when hardware recovery has been started.
1521          */
1522         if (wl->vif) {
1523                 WARN_ON(wl->vif != vif);
1524                 __wl1271_op_remove_interface(wl);
1525         }
1526
1527         mutex_unlock(&wl->mutex);
1528         cancel_work_sync(&wl->recovery_work);
1529 }
1530
1531 void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1532 {
1533         wl1271_set_default_filters(wl);
1534
1535         /* combine requested filters with current filter config */
1536         filters = wl->filters | filters;
1537
1538         wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1539
1540         if (filters & FIF_PROMISC_IN_BSS) {
1541                 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1542                 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1543                 wl->rx_config |= CFG_BSSID_FILTER_EN;
1544         }
1545         if (filters & FIF_BCN_PRBRESP_PROMISC) {
1546                 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1547                 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1548                 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1549         }
1550         if (filters & FIF_OTHER_BSS) {
1551                 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1552                 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1553         }
1554         if (filters & FIF_CONTROL) {
1555                 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1556                 wl->rx_filter |= CFG_RX_CTL_EN;
1557         }
1558         if (filters & FIF_FCSFAIL) {
1559                 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1560                 wl->rx_filter |= CFG_RX_FCS_ERROR;
1561         }
1562 }
1563
1564 static int wl1271_dummy_join(struct wl1271 *wl)
1565 {
1566         int ret = 0;
1567         /* we need to use a dummy BSSID for now */
1568         static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1569                                                   0xad, 0xbe, 0xef };
1570
1571         memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1572
1573         /* pass through frames from all BSS */
1574         wl1271_configure_filters(wl, FIF_OTHER_BSS);
1575
1576         ret = wl1271_cmd_join(wl, wl->set_bss_type);
1577         if (ret < 0)
1578                 goto out;
1579
1580         set_bit(WL1271_FLAG_JOINED, &wl->flags);
1581
1582 out:
1583         return ret;
1584 }
1585
1586 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
1587 {
1588         int ret;
1589
1590         /*
1591          * One of the side effects of the JOIN command is that is clears
1592          * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1593          * to a WPA/WPA2 access point will therefore kill the data-path.
1594          * Currently there is no supported scenario for JOIN during
1595          * association - if it becomes a supported scenario, the WPA/WPA2 keys
1596          * must be handled somehow.
1597          *
1598          */
1599         if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1600                 wl1271_info("JOIN while associated.");
1601
1602         if (set_assoc)
1603                 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1604
1605         ret = wl1271_cmd_join(wl, wl->set_bss_type);
1606         if (ret < 0)
1607                 goto out;
1608
1609         set_bit(WL1271_FLAG_JOINED, &wl->flags);
1610
1611         if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1612                 goto out;
1613
1614         /*
1615          * The join command disable the keep-alive mode, shut down its process,
1616          * and also clear the template config, so we need to reset it all after
1617          * the join. The acx_aid starts the keep-alive process, and the order
1618          * of the commands below is relevant.
1619          */
1620         ret = wl1271_acx_keep_alive_mode(wl, true);
1621         if (ret < 0)
1622                 goto out;
1623
1624         ret = wl1271_acx_aid(wl, wl->aid);
1625         if (ret < 0)
1626                 goto out;
1627
1628         ret = wl1271_cmd_build_klv_null_data(wl);
1629         if (ret < 0)
1630                 goto out;
1631
1632         ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1633                                            ACX_KEEP_ALIVE_TPL_VALID);
1634         if (ret < 0)
1635                 goto out;
1636
1637 out:
1638         return ret;
1639 }
1640
1641 static int wl1271_unjoin(struct wl1271 *wl)
1642 {
1643         int ret;
1644
1645         /* to stop listening to a channel, we disconnect */
1646         ret = wl1271_cmd_disconnect(wl);
1647         if (ret < 0)
1648                 goto out;
1649
1650         clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1651         memset(wl->bssid, 0, ETH_ALEN);
1652
1653         /* stop filtering packets based on bssid */
1654         wl1271_configure_filters(wl, FIF_OTHER_BSS);
1655
1656 out:
1657         return ret;
1658 }
1659
1660 static void wl1271_set_band_rate(struct wl1271 *wl)
1661 {
1662         if (wl->band == IEEE80211_BAND_2GHZ)
1663                 wl->basic_rate_set = wl->conf.tx.basic_rate;
1664         else
1665                 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1666 }
1667
1668 static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle)
1669 {
1670         int ret;
1671
1672         if (idle) {
1673                 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1674                         ret = wl1271_unjoin(wl);
1675                         if (ret < 0)
1676                                 goto out;
1677                 }
1678                 wl->rate_set = wl1271_tx_min_rate_get(wl);
1679                 ret = wl1271_acx_sta_rate_policies(wl);
1680                 if (ret < 0)
1681                         goto out;
1682                 ret = wl1271_acx_keep_alive_config(
1683                         wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1684                         ACX_KEEP_ALIVE_TPL_INVALID);
1685                 if (ret < 0)
1686                         goto out;
1687                 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1688         } else {
1689                 /* increment the session counter */
1690                 wl->session_counter++;
1691                 if (wl->session_counter >= SESSION_COUNTER_MAX)
1692                         wl->session_counter = 0;
1693                 ret = wl1271_dummy_join(wl);
1694                 if (ret < 0)
1695                         goto out;
1696                 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1697         }
1698
1699 out:
1700         return ret;
1701 }
1702
1703 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1704 {
1705         struct wl1271 *wl = hw->priv;
1706         struct ieee80211_conf *conf = &hw->conf;
1707         int channel, ret = 0;
1708         bool is_ap;
1709
1710         channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1711
1712         wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
1713                      " changed 0x%x",
1714                      channel,
1715                      conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1716                      conf->power_level,
1717                      conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
1718                          changed);
1719
1720         /*
1721          * mac80211 will go to idle nearly immediately after transmitting some
1722          * frames, such as the deauth. To make sure those frames reach the air,
1723          * wait here until the TX queue is fully flushed.
1724          */
1725         if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1726             (conf->flags & IEEE80211_CONF_IDLE))
1727                 wl1271_tx_flush(wl);
1728
1729         mutex_lock(&wl->mutex);
1730
1731         if (unlikely(wl->state == WL1271_STATE_OFF)) {
1732                 /* we support configuring the channel and band while off */
1733                 if ((changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
1734                         wl->band = conf->channel->band;
1735                         wl->channel = channel;
1736                 }
1737
1738                 goto out;
1739         }
1740
1741         is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
1742
1743         ret = wl1271_ps_elp_wakeup(wl);
1744         if (ret < 0)
1745                 goto out;
1746
1747         /* if the channel changes while joined, join again */
1748         if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1749             ((wl->band != conf->channel->band) ||
1750              (wl->channel != channel))) {
1751                 wl->band = conf->channel->band;
1752                 wl->channel = channel;
1753
1754                 if (!is_ap) {
1755                         /*
1756                          * FIXME: the mac80211 should really provide a fixed
1757                          * rate to use here. for now, just use the smallest
1758                          * possible rate for the band as a fixed rate for
1759                          * association frames and other control messages.
1760                          */
1761                         if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1762                                 wl1271_set_band_rate(wl);
1763
1764                         wl->basic_rate = wl1271_tx_min_rate_get(wl);
1765                         ret = wl1271_acx_sta_rate_policies(wl);
1766                         if (ret < 0)
1767                                 wl1271_warning("rate policy for channel "
1768                                                "failed %d", ret);
1769
1770                         if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1771                                 ret = wl1271_join(wl, false);
1772                                 if (ret < 0)
1773                                         wl1271_warning("cmd join on channel "
1774                                                        "failed %d", ret);
1775                         }
1776                 }
1777         }
1778
1779         if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
1780                 ret = wl1271_sta_handle_idle(wl,
1781                                         conf->flags & IEEE80211_CONF_IDLE);
1782                 if (ret < 0)
1783                         wl1271_warning("idle mode change failed %d", ret);
1784         }
1785
1786         /*
1787          * if mac80211 changes the PSM mode, make sure the mode is not
1788          * incorrectly changed after the pspoll failure active window.
1789          */
1790         if (changed & IEEE80211_CONF_CHANGE_PS)
1791                 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
1792
1793         if (conf->flags & IEEE80211_CONF_PS &&
1794             !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1795                 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1796
1797                 /*
1798                  * We enter PSM only if we're already associated.
1799                  * If we're not, we'll enter it when joining an SSID,
1800                  * through the bss_info_changed() hook.
1801                  */
1802                 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1803                         wl1271_debug(DEBUG_PSM, "psm enabled");
1804                         ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1805                                                  wl->basic_rate, true);
1806                 }
1807         } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1808                    test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1809                 wl1271_debug(DEBUG_PSM, "psm disabled");
1810
1811                 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1812
1813                 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1814                         ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1815                                                  wl->basic_rate, true);
1816         }
1817
1818         if (conf->power_level != wl->power_level) {
1819                 ret = wl1271_acx_tx_power(wl, conf->power_level);
1820                 if (ret < 0)
1821                         goto out_sleep;
1822
1823                 wl->power_level = conf->power_level;
1824         }
1825
1826 out_sleep:
1827         wl1271_ps_elp_sleep(wl);
1828
1829 out:
1830         mutex_unlock(&wl->mutex);
1831
1832         return ret;
1833 }
1834
1835 struct wl1271_filter_params {
1836         bool enabled;
1837         int mc_list_length;
1838         u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1839 };
1840
1841 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1842                                        struct netdev_hw_addr_list *mc_list)
1843 {
1844         struct wl1271_filter_params *fp;
1845         struct netdev_hw_addr *ha;
1846         struct wl1271 *wl = hw->priv;
1847
1848         if (unlikely(wl->state == WL1271_STATE_OFF))
1849                 return 0;
1850
1851         fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1852         if (!fp) {
1853                 wl1271_error("Out of memory setting filters.");
1854                 return 0;
1855         }
1856
1857         /* update multicast filtering parameters */
1858         fp->mc_list_length = 0;
1859         if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1860                 fp->enabled = false;
1861         } else {
1862                 fp->enabled = true;
1863                 netdev_hw_addr_list_for_each(ha, mc_list) {
1864                         memcpy(fp->mc_list[fp->mc_list_length],
1865                                         ha->addr, ETH_ALEN);
1866                         fp->mc_list_length++;
1867                 }
1868         }
1869
1870         return (u64)(unsigned long)fp;
1871 }
1872
1873 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1874                                   FIF_ALLMULTI | \
1875                                   FIF_FCSFAIL | \
1876                                   FIF_BCN_PRBRESP_PROMISC | \
1877                                   FIF_CONTROL | \
1878                                   FIF_OTHER_BSS)
1879
1880 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1881                                        unsigned int changed,
1882                                        unsigned int *total, u64 multicast)
1883 {
1884         struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1885         struct wl1271 *wl = hw->priv;
1886         int ret;
1887
1888         wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
1889                      " total %x", changed, *total);
1890
1891         mutex_lock(&wl->mutex);
1892
1893         *total &= WL1271_SUPPORTED_FILTERS;
1894         changed &= WL1271_SUPPORTED_FILTERS;
1895
1896         if (unlikely(wl->state == WL1271_STATE_OFF))
1897                 goto out;
1898
1899         ret = wl1271_ps_elp_wakeup(wl);
1900         if (ret < 0)
1901                 goto out;
1902
1903         if (wl->bss_type != BSS_TYPE_AP_BSS) {
1904                 if (*total & FIF_ALLMULTI)
1905                         ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1906                 else if (fp)
1907                         ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1908                                                            fp->mc_list,
1909                                                            fp->mc_list_length);
1910                 if (ret < 0)
1911                         goto out_sleep;
1912         }
1913
1914         /* determine, whether supported filter values have changed */
1915         if (changed == 0)
1916                 goto out_sleep;
1917
1918         /* configure filters */
1919         wl->filters = *total;
1920         wl1271_configure_filters(wl, 0);
1921
1922         /* apply configured filters */
1923         ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1924         if (ret < 0)
1925                 goto out_sleep;
1926
1927 out_sleep:
1928         wl1271_ps_elp_sleep(wl);
1929
1930 out:
1931         mutex_unlock(&wl->mutex);
1932         kfree(fp);
1933 }
1934
1935 static int wl1271_record_ap_key(struct wl1271 *wl, u8 id, u8 key_type,
1936                         u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
1937                         u16 tx_seq_16)
1938 {
1939         struct wl1271_ap_key *ap_key;
1940         int i;
1941
1942         wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
1943
1944         if (key_size > MAX_KEY_SIZE)
1945                 return -EINVAL;
1946
1947         /*
1948          * Find next free entry in ap_keys. Also check we are not replacing
1949          * an existing key.
1950          */
1951         for (i = 0; i < MAX_NUM_KEYS; i++) {
1952                 if (wl->recorded_ap_keys[i] == NULL)
1953                         break;
1954
1955                 if (wl->recorded_ap_keys[i]->id == id) {
1956                         wl1271_warning("trying to record key replacement");
1957                         return -EINVAL;
1958                 }
1959         }
1960
1961         if (i == MAX_NUM_KEYS)
1962                 return -EBUSY;
1963
1964         ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
1965         if (!ap_key)
1966                 return -ENOMEM;
1967
1968         ap_key->id = id;
1969         ap_key->key_type = key_type;
1970         ap_key->key_size = key_size;
1971         memcpy(ap_key->key, key, key_size);
1972         ap_key->hlid = hlid;
1973         ap_key->tx_seq_32 = tx_seq_32;
1974         ap_key->tx_seq_16 = tx_seq_16;
1975
1976         wl->recorded_ap_keys[i] = ap_key;
1977         return 0;
1978 }
1979
1980 static void wl1271_free_ap_keys(struct wl1271 *wl)
1981 {
1982         int i;
1983
1984         for (i = 0; i < MAX_NUM_KEYS; i++) {
1985                 kfree(wl->recorded_ap_keys[i]);
1986                 wl->recorded_ap_keys[i] = NULL;
1987         }
1988 }
1989
1990 static int wl1271_ap_init_hwenc(struct wl1271 *wl)
1991 {
1992         int i, ret = 0;
1993         struct wl1271_ap_key *key;
1994         bool wep_key_added = false;
1995
1996         for (i = 0; i < MAX_NUM_KEYS; i++) {
1997                 if (wl->recorded_ap_keys[i] == NULL)
1998                         break;
1999
2000                 key = wl->recorded_ap_keys[i];
2001                 ret = wl1271_cmd_set_ap_key(wl, KEY_ADD_OR_REPLACE,
2002                                             key->id, key->key_type,
2003                                             key->key_size, key->key,
2004                                             key->hlid, key->tx_seq_32,
2005                                             key->tx_seq_16);
2006                 if (ret < 0)
2007                         goto out;
2008
2009                 if (key->key_type == KEY_WEP)
2010                         wep_key_added = true;
2011         }
2012
2013         if (wep_key_added) {
2014                 ret = wl1271_cmd_set_ap_default_wep_key(wl, wl->default_key);
2015                 if (ret < 0)
2016                         goto out;
2017         }
2018
2019 out:
2020         wl1271_free_ap_keys(wl);
2021         return ret;
2022 }
2023
2024 static int wl1271_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
2025                        u8 key_size, const u8 *key, u32 tx_seq_32,
2026                        u16 tx_seq_16, struct ieee80211_sta *sta)
2027 {
2028         int ret;
2029         bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2030
2031         if (is_ap) {
2032                 struct wl1271_station *wl_sta;
2033                 u8 hlid;
2034
2035                 if (sta) {
2036                         wl_sta = (struct wl1271_station *)sta->drv_priv;
2037                         hlid = wl_sta->hlid;
2038                 } else {
2039                         hlid = WL1271_AP_BROADCAST_HLID;
2040                 }
2041
2042                 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2043                         /*
2044                          * We do not support removing keys after AP shutdown.
2045                          * Pretend we do to make mac80211 happy.
2046                          */
2047                         if (action != KEY_ADD_OR_REPLACE)
2048                                 return 0;
2049
2050                         ret = wl1271_record_ap_key(wl, id,
2051                                              key_type, key_size,
2052                                              key, hlid, tx_seq_32,
2053                                              tx_seq_16);
2054                 } else {
2055                         ret = wl1271_cmd_set_ap_key(wl, action,
2056                                              id, key_type, key_size,
2057                                              key, hlid, tx_seq_32,
2058                                              tx_seq_16);
2059                 }
2060
2061                 if (ret < 0)
2062                         return ret;
2063         } else {
2064                 const u8 *addr;
2065                 static const u8 bcast_addr[ETH_ALEN] = {
2066                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2067                 };
2068
2069                 addr = sta ? sta->addr : bcast_addr;
2070
2071                 if (is_zero_ether_addr(addr)) {
2072                         /* We dont support TX only encryption */
2073                         return -EOPNOTSUPP;
2074                 }
2075
2076                 /* The wl1271 does not allow to remove unicast keys - they
2077                    will be cleared automatically on next CMD_JOIN. Ignore the
2078                    request silently, as we dont want the mac80211 to emit
2079                    an error message. */
2080                 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
2081                         return 0;
2082
2083                 ret = wl1271_cmd_set_sta_key(wl, action,
2084                                              id, key_type, key_size,
2085                                              key, addr, tx_seq_32,
2086                                              tx_seq_16);
2087                 if (ret < 0)
2088                         return ret;
2089
2090                 /* the default WEP key needs to be configured at least once */
2091                 if (key_type == KEY_WEP) {
2092                         ret = wl1271_cmd_set_sta_default_wep_key(wl,
2093                                                         wl->default_key);
2094                         if (ret < 0)
2095                                 return ret;
2096                 }
2097         }
2098
2099         return 0;
2100 }
2101
2102 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2103                              struct ieee80211_vif *vif,
2104                              struct ieee80211_sta *sta,
2105                              struct ieee80211_key_conf *key_conf)
2106 {
2107         struct wl1271 *wl = hw->priv;
2108         int ret;
2109         u32 tx_seq_32 = 0;
2110         u16 tx_seq_16 = 0;
2111         u8 key_type;
2112
2113         wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
2114
2115         wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
2116         wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
2117                      key_conf->cipher, key_conf->keyidx,
2118                      key_conf->keylen, key_conf->flags);
2119         wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
2120
2121         mutex_lock(&wl->mutex);
2122
2123         if (unlikely(wl->state == WL1271_STATE_OFF)) {
2124                 ret = -EAGAIN;
2125                 goto out_unlock;
2126         }
2127
2128         ret = wl1271_ps_elp_wakeup(wl);
2129         if (ret < 0)
2130                 goto out_unlock;
2131
2132         switch (key_conf->cipher) {
2133         case WLAN_CIPHER_SUITE_WEP40:
2134         case WLAN_CIPHER_SUITE_WEP104:
2135                 key_type = KEY_WEP;
2136
2137                 key_conf->hw_key_idx = key_conf->keyidx;
2138                 break;
2139         case WLAN_CIPHER_SUITE_TKIP:
2140                 key_type = KEY_TKIP;
2141
2142                 key_conf->hw_key_idx = key_conf->keyidx;
2143                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2144                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2145                 break;
2146         case WLAN_CIPHER_SUITE_CCMP:
2147                 key_type = KEY_AES;
2148
2149                 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
2150                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2151                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2152                 break;
2153         case WL1271_CIPHER_SUITE_GEM:
2154                 key_type = KEY_GEM;
2155                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2156                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2157                 break;
2158         default:
2159                 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
2160
2161                 ret = -EOPNOTSUPP;
2162                 goto out_sleep;
2163         }
2164
2165         switch (cmd) {
2166         case SET_KEY:
2167                 ret = wl1271_set_key(wl, KEY_ADD_OR_REPLACE,
2168                                  key_conf->keyidx, key_type,
2169                                  key_conf->keylen, key_conf->key,
2170                                  tx_seq_32, tx_seq_16, sta);
2171                 if (ret < 0) {
2172                         wl1271_error("Could not add or replace key");
2173                         goto out_sleep;
2174                 }
2175                 break;
2176
2177         case DISABLE_KEY:
2178                 ret = wl1271_set_key(wl, KEY_REMOVE,
2179                                      key_conf->keyidx, key_type,
2180                                      key_conf->keylen, key_conf->key,
2181                                      0, 0, sta);
2182                 if (ret < 0) {
2183                         wl1271_error("Could not remove key");
2184                         goto out_sleep;
2185                 }
2186                 break;
2187
2188         default:
2189                 wl1271_error("Unsupported key cmd 0x%x", cmd);
2190                 ret = -EOPNOTSUPP;
2191                 break;
2192         }
2193
2194 out_sleep:
2195         wl1271_ps_elp_sleep(wl);
2196
2197 out_unlock:
2198         mutex_unlock(&wl->mutex);
2199
2200         return ret;
2201 }
2202
2203 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
2204                              struct ieee80211_vif *vif,
2205                              struct cfg80211_scan_request *req)
2206 {
2207         struct wl1271 *wl = hw->priv;
2208         int ret;
2209         u8 *ssid = NULL;
2210         size_t len = 0;
2211
2212         wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
2213
2214         if (req->n_ssids) {
2215                 ssid = req->ssids[0].ssid;
2216                 len = req->ssids[0].ssid_len;
2217         }
2218
2219         mutex_lock(&wl->mutex);
2220
2221         if (wl->state == WL1271_STATE_OFF) {
2222                 /*
2223                  * We cannot return -EBUSY here because cfg80211 will expect
2224                  * a call to ieee80211_scan_completed if we do - in this case
2225                  * there won't be any call.
2226                  */
2227                 ret = -EAGAIN;
2228                 goto out;
2229         }
2230
2231         ret = wl1271_ps_elp_wakeup(wl);
2232         if (ret < 0)
2233                 goto out;
2234
2235         ret = wl1271_scan(hw->priv, ssid, len, req);
2236
2237         wl1271_ps_elp_sleep(wl);
2238
2239 out:
2240         mutex_unlock(&wl->mutex);
2241
2242         return ret;
2243 }
2244
2245 static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
2246 {
2247         struct wl1271 *wl = hw->priv;
2248         int ret = 0;
2249
2250         mutex_lock(&wl->mutex);
2251
2252         if (unlikely(wl->state == WL1271_STATE_OFF)) {
2253                 ret = -EAGAIN;
2254                 goto out;
2255         }
2256
2257         ret = wl1271_ps_elp_wakeup(wl);
2258         if (ret < 0)
2259                 goto out;
2260
2261         ret = wl1271_acx_frag_threshold(wl, (u16)value);
2262         if (ret < 0)
2263                 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
2264
2265         wl1271_ps_elp_sleep(wl);
2266
2267 out:
2268         mutex_unlock(&wl->mutex);
2269
2270         return ret;
2271 }
2272
2273 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
2274 {
2275         struct wl1271 *wl = hw->priv;
2276         int ret = 0;
2277
2278         mutex_lock(&wl->mutex);
2279
2280         if (unlikely(wl->state == WL1271_STATE_OFF)) {
2281                 ret = -EAGAIN;
2282                 goto out;
2283         }
2284
2285         ret = wl1271_ps_elp_wakeup(wl);
2286         if (ret < 0)
2287                 goto out;
2288
2289         ret = wl1271_acx_rts_threshold(wl, (u16) value);
2290         if (ret < 0)
2291                 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
2292
2293         wl1271_ps_elp_sleep(wl);
2294
2295 out:
2296         mutex_unlock(&wl->mutex);
2297
2298         return ret;
2299 }
2300
2301 static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
2302                             int offset)
2303 {
2304         u8 *ptr = skb->data + offset;
2305
2306         /* find the location of the ssid in the beacon */
2307         while (ptr < skb->data + skb->len) {
2308                 if (ptr[0] == WLAN_EID_SSID) {
2309                         wl->ssid_len = ptr[1];
2310                         memcpy(wl->ssid, ptr+2, wl->ssid_len);
2311                         return 0;
2312                 }
2313                 ptr += (ptr[1] + 2);
2314         }
2315
2316         wl1271_error("No SSID in IEs!\n");
2317         return -ENOENT;
2318 }
2319
2320 static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
2321                                        struct ieee80211_bss_conf *bss_conf,
2322                                        u32 changed)
2323 {
2324         int ret = 0;
2325
2326         if (changed & BSS_CHANGED_ERP_SLOT) {
2327                 if (bss_conf->use_short_slot)
2328                         ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
2329                 else
2330                         ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
2331                 if (ret < 0) {
2332                         wl1271_warning("Set slot time failed %d", ret);
2333                         goto out;
2334                 }
2335         }
2336
2337         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2338                 if (bss_conf->use_short_preamble)
2339                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
2340                 else
2341                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
2342         }
2343
2344         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2345                 if (bss_conf->use_cts_prot)
2346                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
2347                 else
2348                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
2349                 if (ret < 0) {
2350                         wl1271_warning("Set ctsprotect failed %d", ret);
2351                         goto out;
2352                 }
2353         }
2354
2355 out:
2356         return ret;
2357 }
2358
2359 static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
2360                                           struct ieee80211_vif *vif,
2361                                           struct ieee80211_bss_conf *bss_conf,
2362                                           u32 changed)
2363 {
2364         bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2365         int ret = 0;
2366
2367         if ((changed & BSS_CHANGED_BEACON_INT)) {
2368                 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
2369                         bss_conf->beacon_int);
2370
2371                 wl->beacon_int = bss_conf->beacon_int;
2372         }
2373
2374         if ((changed & BSS_CHANGED_BEACON)) {
2375                 struct ieee80211_hdr *hdr;
2376                 int ieoffset = offsetof(struct ieee80211_mgmt,
2377                                         u.beacon.variable);
2378                 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
2379                 u16 tmpl_id;
2380
2381                 if (!beacon)
2382                         goto out;
2383
2384                 wl1271_debug(DEBUG_MASTER, "beacon updated");
2385
2386                 ret = wl1271_ssid_set(wl, beacon, ieoffset);
2387                 if (ret < 0) {
2388                         dev_kfree_skb(beacon);
2389                         goto out;
2390                 }
2391                 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
2392                                   CMD_TEMPL_BEACON;
2393                 ret = wl1271_cmd_template_set(wl, tmpl_id,
2394                                               beacon->data,
2395                                               beacon->len, 0,
2396                                               wl1271_tx_min_rate_get(wl));
2397                 if (ret < 0) {
2398                         dev_kfree_skb(beacon);
2399                         goto out;
2400                 }
2401
2402                 hdr = (struct ieee80211_hdr *) beacon->data;
2403                 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2404                                                  IEEE80211_STYPE_PROBE_RESP);
2405
2406                 tmpl_id = is_ap ? CMD_TEMPL_AP_PROBE_RESPONSE :
2407                                   CMD_TEMPL_PROBE_RESPONSE;
2408                 ret = wl1271_cmd_template_set(wl,
2409                                               tmpl_id,
2410                                               beacon->data,
2411                                               beacon->len, 0,
2412                                               wl1271_tx_min_rate_get(wl));
2413                 dev_kfree_skb(beacon);
2414                 if (ret < 0)
2415                         goto out;
2416         }
2417
2418 out:
2419         return ret;
2420 }
2421
2422 /* AP mode changes */
2423 static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
2424                                        struct ieee80211_vif *vif,
2425                                        struct ieee80211_bss_conf *bss_conf,
2426                                        u32 changed)
2427 {
2428         int ret = 0;
2429
2430         if ((changed & BSS_CHANGED_BASIC_RATES)) {
2431                 u32 rates = bss_conf->basic_rates;
2432                 struct conf_tx_rate_class mgmt_rc;
2433
2434                 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates);
2435                 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2436                 wl1271_debug(DEBUG_AP, "basic rates: 0x%x",
2437                              wl->basic_rate_set);
2438
2439                 /* update the AP management rate policy with the new rates */
2440                 mgmt_rc.enabled_rates = wl->basic_rate_set;
2441                 mgmt_rc.long_retry_limit = 10;
2442                 mgmt_rc.short_retry_limit = 10;
2443                 mgmt_rc.aflags = 0;
2444                 ret = wl1271_acx_ap_rate_policy(wl, &mgmt_rc,
2445                                                 ACX_TX_AP_MODE_MGMT_RATE);
2446                 if (ret < 0) {
2447                         wl1271_error("AP mgmt policy change failed %d", ret);
2448                         goto out;
2449                 }
2450         }
2451
2452         ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
2453         if (ret < 0)
2454                 goto out;
2455
2456         if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
2457                 if (bss_conf->enable_beacon) {
2458                         if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2459                                 ret = wl1271_cmd_start_bss(wl);
2460                                 if (ret < 0)
2461                                         goto out;
2462
2463                                 set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2464                                 wl1271_debug(DEBUG_AP, "started AP");
2465
2466                                 ret = wl1271_ap_init_hwenc(wl);
2467                                 if (ret < 0)
2468                                         goto out;
2469                         }
2470                 } else {
2471                         if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2472                                 ret = wl1271_cmd_stop_bss(wl);
2473                                 if (ret < 0)
2474                                         goto out;
2475
2476                                 clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2477                                 wl1271_debug(DEBUG_AP, "stopped AP");
2478                         }
2479                 }
2480         }
2481
2482         ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
2483         if (ret < 0)
2484                 goto out;
2485 out:
2486         return;
2487 }
2488
2489 /* STA/IBSS mode changes */
2490 static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
2491                                         struct ieee80211_vif *vif,
2492                                         struct ieee80211_bss_conf *bss_conf,
2493                                         u32 changed)
2494 {
2495         bool do_join = false, set_assoc = false;
2496         bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
2497         u32 sta_rate_set = 0;
2498         int ret;
2499         struct ieee80211_sta *sta;
2500         bool sta_exists = false;
2501         struct ieee80211_sta_ht_cap sta_ht_cap;
2502
2503         if (is_ibss) {
2504                 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
2505                                                      changed);
2506                 if (ret < 0)
2507                         goto out;
2508         }
2509
2510         if ((changed & BSS_CHANGED_BEACON_INT)  && is_ibss)
2511                 do_join = true;
2512
2513         /* Need to update the SSID (for filtering etc) */
2514         if ((changed & BSS_CHANGED_BEACON) && is_ibss)
2515                 do_join = true;
2516
2517         if ((changed & BSS_CHANGED_BEACON_ENABLED) && is_ibss) {
2518                 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
2519                              bss_conf->enable_beacon ? "enabled" : "disabled");
2520
2521                 if (bss_conf->enable_beacon)
2522                         wl->set_bss_type = BSS_TYPE_IBSS;
2523                 else
2524                         wl->set_bss_type = BSS_TYPE_STA_BSS;
2525                 do_join = true;
2526         }
2527
2528         if ((changed & BSS_CHANGED_CQM)) {
2529                 bool enable = false;
2530                 if (bss_conf->cqm_rssi_thold)
2531                         enable = true;
2532                 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
2533                                                   bss_conf->cqm_rssi_thold,
2534                                                   bss_conf->cqm_rssi_hyst);
2535                 if (ret < 0)
2536                         goto out;
2537                 wl->rssi_thold = bss_conf->cqm_rssi_thold;
2538         }
2539
2540         if ((changed & BSS_CHANGED_BSSID) &&
2541             /*
2542              * Now we know the correct bssid, so we send a new join command
2543              * and enable the BSSID filter
2544              */
2545             memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
2546                 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
2547
2548                 if (!is_zero_ether_addr(wl->bssid)) {
2549                         ret = wl1271_cmd_build_null_data(wl);
2550                         if (ret < 0)
2551                                 goto out;
2552
2553                         ret = wl1271_build_qos_null_data(wl);
2554                         if (ret < 0)
2555                                 goto out;
2556
2557                         /* filter out all packets not from this BSSID */
2558                         wl1271_configure_filters(wl, 0);
2559
2560                         /* Need to update the BSSID (for filtering etc) */
2561                         do_join = true;
2562                 }
2563         }
2564
2565         rcu_read_lock();
2566         sta = ieee80211_find_sta(vif, bss_conf->bssid);
2567         if (sta)  {
2568                 /* save the supp_rates of the ap */
2569                 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
2570                 if (sta->ht_cap.ht_supported)
2571                         sta_rate_set |=
2572                             (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
2573                 sta_ht_cap = sta->ht_cap;
2574                 sta_exists = true;
2575         }
2576         rcu_read_unlock();
2577
2578         if (sta_exists) {
2579                 /* handle new association with HT and HT information change */
2580                 if ((changed & BSS_CHANGED_HT) &&
2581                     (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
2582                         ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
2583                                                              true);
2584                         if (ret < 0) {
2585                                 wl1271_warning("Set ht cap true failed %d",
2586                                                ret);
2587                                 goto out;
2588                         }
2589                         ret = wl1271_acx_set_ht_information(wl,
2590                                                 bss_conf->ht_operation_mode);
2591                         if (ret < 0) {
2592                                 wl1271_warning("Set ht information failed %d",
2593                                                ret);
2594                                 goto out;
2595                         }
2596                 }
2597                 /* handle new association without HT and disassociation */
2598                 else if (changed & BSS_CHANGED_ASSOC) {
2599                         ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
2600                                                              false);
2601                         if (ret < 0) {
2602                                 wl1271_warning("Set ht cap false failed %d",
2603                                                ret);
2604                                 goto out;
2605                         }
2606                 }
2607         }
2608
2609         if ((changed & BSS_CHANGED_ASSOC)) {
2610                 if (bss_conf->assoc) {
2611                         u32 rates;
2612                         int ieoffset;
2613                         wl->aid = bss_conf->aid;
2614                         set_assoc = true;
2615
2616                         wl->ps_poll_failures = 0;
2617
2618                         /*
2619                          * use basic rates from AP, and determine lowest rate
2620                          * to use with control frames.
2621                          */
2622                         rates = bss_conf->basic_rates;
2623                         wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
2624                                                                          rates);
2625                         wl->basic_rate = wl1271_tx_min_rate_get(wl);
2626                         if (sta_rate_set)
2627                                 wl->rate_set = wl1271_tx_enabled_rates_get(wl,
2628                                                                 sta_rate_set);
2629                         ret = wl1271_acx_sta_rate_policies(wl);
2630                         if (ret < 0)
2631                                 goto out;
2632
2633                         /*
2634                          * with wl1271, we don't need to update the
2635                          * beacon_int and dtim_period, because the firmware
2636                          * updates it by itself when the first beacon is
2637                          * received after a join.
2638                          */
2639                         ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
2640                         if (ret < 0)
2641                                 goto out;
2642
2643                         /*
2644                          * Get a template for hardware connection maintenance
2645                          */
2646                         dev_kfree_skb(wl->probereq);
2647                         wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL);
2648                         ieoffset = offsetof(struct ieee80211_mgmt,
2649                                             u.probe_req.variable);
2650                         wl1271_ssid_set(wl, wl->probereq, ieoffset);
2651
2652                         /* enable the connection monitoring feature */
2653                         ret = wl1271_acx_conn_monit_params(wl, true);
2654                         if (ret < 0)
2655                                 goto out;
2656
2657                         /* If we want to go in PSM but we're not there yet */
2658                         if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
2659                             !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
2660                                 enum wl1271_cmd_ps_mode mode;
2661
2662                                 mode = STATION_POWER_SAVE_MODE;
2663                                 ret = wl1271_ps_set_mode(wl, mode,
2664                                                          wl->basic_rate,
2665                                                          true);
2666                                 if (ret < 0)
2667                                         goto out;
2668                         }
2669                 } else {
2670                         /* use defaults when not associated */
2671                         clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
2672                         clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
2673                         wl->aid = 0;
2674
2675                         /* free probe-request template */
2676                         dev_kfree_skb(wl->probereq);
2677                         wl->probereq = NULL;
2678
2679                         /* re-enable dynamic ps - just in case */
2680                         ieee80211_enable_dyn_ps(wl->vif);
2681
2682                         /* revert back to minimum rates for the current band */
2683                         wl1271_set_band_rate(wl);
2684                         wl->basic_rate = wl1271_tx_min_rate_get(wl);
2685                         ret = wl1271_acx_sta_rate_policies(wl);
2686                         if (ret < 0)
2687                                 goto out;
2688
2689                         /* disable connection monitor features */
2690                         ret = wl1271_acx_conn_monit_params(wl, false);
2691
2692                         /* Disable the keep-alive feature */
2693                         ret = wl1271_acx_keep_alive_mode(wl, false);
2694                         if (ret < 0)
2695                                 goto out;
2696
2697                         /* restore the bssid filter and go to dummy bssid */
2698                         wl1271_unjoin(wl);
2699                         wl1271_dummy_join(wl);
2700                 }
2701         }
2702
2703         ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
2704         if (ret < 0)
2705                 goto out;
2706
2707         if (changed & BSS_CHANGED_ARP_FILTER) {
2708                 __be32 addr = bss_conf->arp_addr_list[0];
2709                 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
2710
2711                 if (bss_conf->arp_addr_cnt == 1 &&
2712                     bss_conf->arp_filter_enabled) {
2713                         /*
2714                          * The template should have been configured only upon
2715                          * association. however, it seems that the correct ip
2716                          * isn't being set (when sending), so we have to
2717                          * reconfigure the template upon every ip change.
2718                          */
2719                         ret = wl1271_cmd_build_arp_rsp(wl, addr);
2720                         if (ret < 0) {
2721                                 wl1271_warning("build arp rsp failed: %d", ret);
2722                                 goto out;
2723                         }
2724
2725                         ret = wl1271_acx_arp_ip_filter(wl,
2726                                 ACX_ARP_FILTER_ARP_FILTERING,
2727                                 addr);
2728                 } else
2729                         ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
2730
2731                 if (ret < 0)
2732                         goto out;
2733         }
2734
2735         if (do_join) {
2736                 ret = wl1271_join(wl, set_assoc);
2737                 if (ret < 0) {
2738                         wl1271_warning("cmd join failed %d", ret);
2739                         goto out;
2740                 }
2741         }
2742
2743 out:
2744         return;
2745 }
2746
2747 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
2748                                        struct ieee80211_vif *vif,
2749                                        struct ieee80211_bss_conf *bss_conf,
2750                                        u32 changed)
2751 {
2752         struct wl1271 *wl = hw->priv;
2753         bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2754         int ret;
2755
2756         wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
2757                      (int)changed);
2758
2759         mutex_lock(&wl->mutex);
2760
2761         if (unlikely(wl->state == WL1271_STATE_OFF))
2762                 goto out;
2763
2764         ret = wl1271_ps_elp_wakeup(wl);
2765         if (ret < 0)
2766                 goto out;
2767
2768         if (is_ap)
2769                 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
2770         else
2771                 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
2772
2773         wl1271_ps_elp_sleep(wl);
2774
2775 out:
2776         mutex_unlock(&wl->mutex);
2777 }
2778
2779 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
2780                              const struct ieee80211_tx_queue_params *params)
2781 {
2782         struct wl1271 *wl = hw->priv;
2783         u8 ps_scheme;
2784         int ret = 0;
2785
2786         mutex_lock(&wl->mutex);
2787
2788         wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
2789
2790         if (params->uapsd)
2791                 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
2792         else
2793                 ps_scheme = CONF_PS_SCHEME_LEGACY;
2794
2795         if (wl->state == WL1271_STATE_OFF) {
2796                 /*
2797                  * If the state is off, the parameters will be recorded and
2798                  * configured on init. This happens in AP-mode.
2799                  */
2800                 struct conf_tx_ac_category *conf_ac =
2801                         &wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)];
2802                 struct conf_tx_tid *conf_tid =
2803                         &wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)];
2804
2805                 conf_ac->ac = wl1271_tx_get_queue(queue);
2806                 conf_ac->cw_min = (u8)params->cw_min;
2807                 conf_ac->cw_max = params->cw_max;
2808                 conf_ac->aifsn = params->aifs;
2809                 conf_ac->tx_op_limit = params->txop << 5;
2810
2811                 conf_tid->queue_id = wl1271_tx_get_queue(queue);
2812                 conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF;
2813                 conf_tid->tsid = wl1271_tx_get_queue(queue);
2814                 conf_tid->ps_scheme = ps_scheme;
2815                 conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY;
2816                 conf_tid->apsd_conf[0] = 0;
2817                 conf_tid->apsd_conf[1] = 0;
2818                 goto out;
2819         }
2820
2821         ret = wl1271_ps_elp_wakeup(wl);
2822         if (ret < 0)
2823                 goto out;
2824
2825         /*
2826          * the txop is confed in units of 32us by the mac80211,
2827          * we need us
2828          */
2829         ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
2830                                 params->cw_min, params->cw_max,
2831                                 params->aifs, params->txop << 5);
2832         if (ret < 0)
2833                 goto out_sleep;
2834
2835         ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
2836                                  CONF_CHANNEL_TYPE_EDCF,
2837                                  wl1271_tx_get_queue(queue),
2838                                  ps_scheme, CONF_ACK_POLICY_LEGACY,
2839                                  0, 0);
2840
2841 out_sleep:
2842         wl1271_ps_elp_sleep(wl);
2843
2844 out:
2845         mutex_unlock(&wl->mutex);
2846
2847         return ret;
2848 }
2849
2850 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
2851 {
2852
2853         struct wl1271 *wl = hw->priv;
2854         u64 mactime = ULLONG_MAX;
2855         int ret;
2856
2857         wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
2858
2859         mutex_lock(&wl->mutex);
2860
2861         if (unlikely(wl->state == WL1271_STATE_OFF))
2862                 goto out;
2863
2864         ret = wl1271_ps_elp_wakeup(wl);
2865         if (ret < 0)
2866                 goto out;
2867
2868         ret = wl1271_acx_tsf_info(wl, &mactime);
2869         if (ret < 0)
2870                 goto out_sleep;
2871
2872 out_sleep:
2873         wl1271_ps_elp_sleep(wl);
2874
2875 out:
2876         mutex_unlock(&wl->mutex);
2877         return mactime;
2878 }
2879
2880 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
2881                                 struct survey_info *survey)
2882 {
2883         struct wl1271 *wl = hw->priv;
2884         struct ieee80211_conf *conf = &hw->conf;
2885
2886         if (idx != 0)
2887                 return -ENOENT;
2888
2889         survey->channel = conf->channel;
2890         survey->filled = SURVEY_INFO_NOISE_DBM;
2891         survey->noise = wl->noise;
2892
2893         return 0;
2894 }
2895
2896 static int wl1271_allocate_sta(struct wl1271 *wl,
2897                              struct ieee80211_sta *sta,
2898                              u8 *hlid)
2899 {
2900         struct wl1271_station *wl_sta;
2901         int id;
2902
2903         id = find_first_zero_bit(wl->ap_hlid_map, AP_MAX_STATIONS);
2904         if (id >= AP_MAX_STATIONS) {
2905                 wl1271_warning("could not allocate HLID - too much stations");
2906                 return -EBUSY;
2907         }
2908
2909         wl_sta = (struct wl1271_station *)sta->drv_priv;
2910         __set_bit(id, wl->ap_hlid_map);
2911         wl_sta->hlid = WL1271_AP_STA_HLID_START + id;
2912         *hlid = wl_sta->hlid;
2913         memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
2914         return 0;
2915 }
2916
2917 static void wl1271_free_sta(struct wl1271 *wl, u8 hlid)
2918 {
2919         int id = hlid - WL1271_AP_STA_HLID_START;
2920
2921         if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
2922                 return;
2923
2924         __clear_bit(id, wl->ap_hlid_map);
2925         memset(wl->links[hlid].addr, 0, ETH_ALEN);
2926         wl1271_tx_reset_link_queues(wl, hlid);
2927         __clear_bit(hlid, &wl->ap_ps_map);
2928         __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
2929 }
2930
2931 static int wl1271_op_sta_add(struct ieee80211_hw *hw,
2932                              struct ieee80211_vif *vif,
2933                              struct ieee80211_sta *sta)
2934 {
2935         struct wl1271 *wl = hw->priv;
2936         int ret = 0;
2937         u8 hlid;
2938
2939         mutex_lock(&wl->mutex);
2940
2941         if (unlikely(wl->state == WL1271_STATE_OFF))
2942                 goto out;
2943
2944         if (wl->bss_type != BSS_TYPE_AP_BSS)
2945                 goto out;
2946
2947         wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
2948
2949         ret = wl1271_allocate_sta(wl, sta, &hlid);
2950         if (ret < 0)
2951                 goto out;
2952
2953         ret = wl1271_ps_elp_wakeup(wl);
2954         if (ret < 0)
2955                 goto out_free_sta;
2956
2957         ret = wl1271_cmd_add_sta(wl, sta, hlid);
2958         if (ret < 0)
2959                 goto out_sleep;
2960
2961 out_sleep:
2962         wl1271_ps_elp_sleep(wl);
2963
2964 out_free_sta:
2965         if (ret < 0)
2966                 wl1271_free_sta(wl, hlid);
2967
2968 out:
2969         mutex_unlock(&wl->mutex);
2970         return ret;
2971 }
2972
2973 static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
2974                                 struct ieee80211_vif *vif,
2975                                 struct ieee80211_sta *sta)
2976 {
2977         struct wl1271 *wl = hw->priv;
2978         struct wl1271_station *wl_sta;
2979         int ret = 0, id;
2980
2981         mutex_lock(&wl->mutex);
2982
2983         if (unlikely(wl->state == WL1271_STATE_OFF))
2984                 goto out;
2985
2986         if (wl->bss_type != BSS_TYPE_AP_BSS)
2987                 goto out;
2988
2989         wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
2990
2991         wl_sta = (struct wl1271_station *)sta->drv_priv;
2992         id = wl_sta->hlid - WL1271_AP_STA_HLID_START;
2993         if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
2994                 goto out;
2995
2996         ret = wl1271_ps_elp_wakeup(wl);
2997         if (ret < 0)
2998                 goto out;
2999
3000         ret = wl1271_cmd_remove_sta(wl, wl_sta->hlid);
3001         if (ret < 0)
3002                 goto out_sleep;
3003
3004         wl1271_free_sta(wl, wl_sta->hlid);
3005
3006 out_sleep:
3007         wl1271_ps_elp_sleep(wl);
3008
3009 out:
3010         mutex_unlock(&wl->mutex);
3011         return ret;
3012 }
3013
3014 static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
3015                                   struct ieee80211_vif *vif,
3016                                   enum ieee80211_ampdu_mlme_action action,
3017                                   struct ieee80211_sta *sta, u16 tid, u16 *ssn,
3018                                   u8 buf_size)
3019 {
3020         struct wl1271 *wl = hw->priv;
3021         int ret;
3022
3023         mutex_lock(&wl->mutex);
3024
3025         if (unlikely(wl->state == WL1271_STATE_OFF)) {
3026                 ret = -EAGAIN;
3027                 goto out;
3028         }
3029
3030         ret = wl1271_ps_elp_wakeup(wl);
3031         if (ret < 0)
3032                 goto out;
3033
3034         switch (action) {
3035         case IEEE80211_AMPDU_RX_START:
3036                 if (wl->ba_support) {
3037                         ret = wl1271_acx_set_ba_receiver_session(wl, tid, *ssn,
3038                                                                  true);
3039                         if (!ret)
3040                                 wl->ba_rx_bitmap |= BIT(tid);
3041                 } else {
3042                         ret = -ENOTSUPP;
3043                 }
3044                 break;
3045
3046         case IEEE80211_AMPDU_RX_STOP:
3047                 ret = wl1271_acx_set_ba_receiver_session(wl, tid, 0, false);
3048                 if (!ret)
3049                         wl->ba_rx_bitmap &= ~BIT(tid);
3050                 break;
3051
3052         /*
3053          * The BA initiator session management in FW independently.
3054          * Falling break here on purpose for all TX APDU commands.
3055          */
3056         case IEEE80211_AMPDU_TX_START:
3057         case IEEE80211_AMPDU_TX_STOP:
3058         case IEEE80211_AMPDU_TX_OPERATIONAL:
3059                 ret = -EINVAL;
3060                 break;
3061
3062         default:
3063                 wl1271_error("Incorrect ampdu action id=%x\n", action);
3064                 ret = -EINVAL;
3065         }
3066
3067         wl1271_ps_elp_sleep(wl);
3068
3069 out:
3070         mutex_unlock(&wl->mutex);
3071
3072         return ret;
3073 }
3074
3075 /* can't be const, mac80211 writes to this */
3076 static struct ieee80211_rate wl1271_rates[] = {
3077         { .bitrate = 10,
3078           .hw_value = CONF_HW_BIT_RATE_1MBPS,
3079           .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
3080         { .bitrate = 20,
3081           .hw_value = CONF_HW_BIT_RATE_2MBPS,
3082           .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
3083           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3084         { .bitrate = 55,
3085           .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
3086           .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
3087           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3088         { .bitrate = 110,
3089           .hw_value = CONF_HW_BIT_RATE_11MBPS,
3090           .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
3091           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3092         { .bitrate = 60,
3093           .hw_value = CONF_HW_BIT_RATE_6MBPS,
3094           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
3095         { .bitrate = 90,
3096           .hw_value = CONF_HW_BIT_RATE_9MBPS,
3097           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
3098         { .bitrate = 120,
3099           .hw_value = CONF_HW_BIT_RATE_12MBPS,
3100           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
3101         { .bitrate = 180,
3102           .hw_value = CONF_HW_BIT_RATE_18MBPS,
3103           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
3104         { .bitrate = 240,
3105           .hw_value = CONF_HW_BIT_RATE_24MBPS,
3106           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
3107         { .bitrate = 360,
3108          .hw_value = CONF_HW_BIT_RATE_36MBPS,
3109          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
3110         { .bitrate = 480,
3111           .hw_value = CONF_HW_BIT_RATE_48MBPS,
3112           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
3113         { .bitrate = 540,
3114           .hw_value = CONF_HW_BIT_RATE_54MBPS,
3115           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
3116 };
3117
3118 /* can't be const, mac80211 writes to this */
3119 static struct ieee80211_channel wl1271_channels[] = {
3120         { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
3121         { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
3122         { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
3123         { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
3124         { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
3125         { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
3126         { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
3127         { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
3128         { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
3129         { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
3130         { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
3131         { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
3132         { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
3133         { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
3134 };
3135
3136 /* mapping to indexes for wl1271_rates */
3137 static const u8 wl1271_rate_to_idx_2ghz[] = {
3138         /* MCS rates are used only with 11n */
3139         7,                            /* CONF_HW_RXTX_RATE_MCS7 */
3140         6,                            /* CONF_HW_RXTX_RATE_MCS6 */
3141         5,                            /* CONF_HW_RXTX_RATE_MCS5 */
3142         4,                            /* CONF_HW_RXTX_RATE_MCS4 */
3143         3,                            /* CONF_HW_RXTX_RATE_MCS3 */
3144         2,                            /* CONF_HW_RXTX_RATE_MCS2 */
3145         1,                            /* CONF_HW_RXTX_RATE_MCS1 */
3146         0,                            /* CONF_HW_RXTX_RATE_MCS0 */
3147
3148         11,                            /* CONF_HW_RXTX_RATE_54   */
3149         10,                            /* CONF_HW_RXTX_RATE_48   */
3150         9,                             /* CONF_HW_RXTX_RATE_36   */
3151         8,                             /* CONF_HW_RXTX_RATE_24   */
3152
3153         /* TI-specific rate */
3154         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
3155
3156         7,                             /* CONF_HW_RXTX_RATE_18   */
3157         6,                             /* CONF_HW_RXTX_RATE_12   */
3158         3,                             /* CONF_HW_RXTX_RATE_11   */
3159         5,                             /* CONF_HW_RXTX_RATE_9    */
3160         4,                             /* CONF_HW_RXTX_RATE_6    */
3161         2,                             /* CONF_HW_RXTX_RATE_5_5  */
3162         1,                             /* CONF_HW_RXTX_RATE_2    */
3163         0                              /* CONF_HW_RXTX_RATE_1    */
3164 };
3165
3166 /* 11n STA capabilities */
3167 #define HW_RX_HIGHEST_RATE      72
3168
3169 #ifdef CONFIG_WL12XX_HT
3170 #define WL12XX_HT_CAP { \
3171         .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
3172                (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
3173         .ht_supported = true, \
3174         .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
3175         .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
3176         .mcs = { \
3177                 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
3178                 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
3179                 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
3180                 }, \
3181 }
3182 #else
3183 #define WL12XX_HT_CAP { \
3184         .ht_supported = false, \
3185 }
3186 #endif
3187
3188 /* can't be const, mac80211 writes to this */
3189 static struct ieee80211_supported_band wl1271_band_2ghz = {
3190         .channels = wl1271_channels,
3191         .n_channels = ARRAY_SIZE(wl1271_channels),
3192         .bitrates = wl1271_rates,
3193         .n_bitrates = ARRAY_SIZE(wl1271_rates),
3194         .ht_cap = WL12XX_HT_CAP,
3195 };
3196
3197 /* 5 GHz data rates for WL1273 */
3198 static struct ieee80211_rate wl1271_rates_5ghz[] = {
3199         { .bitrate = 60,
3200           .hw_value = CONF_HW_BIT_RATE_6MBPS,
3201           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
3202         { .bitrate = 90,
3203           .hw_value = CONF_HW_BIT_RATE_9MBPS,
3204           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
3205         { .bitrate = 120,
3206           .hw_value = CONF_HW_BIT_RATE_12MBPS,
3207           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
3208         { .bitrate = 180,
3209           .hw_value = CONF_HW_BIT_RATE_18MBPS,
3210           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
3211         { .bitrate = 240,
3212           .hw_value = CONF_HW_BIT_RATE_24MBPS,
3213           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
3214         { .bitrate = 360,
3215          .hw_value = CONF_HW_BIT_RATE_36MBPS,
3216          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
3217         { .bitrate = 480,
3218           .hw_value = CONF_HW_BIT_RATE_48MBPS,
3219           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
3220         { .bitrate = 540,
3221           .hw_value = CONF_HW_BIT_RATE_54MBPS,
3222           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
3223 };
3224
3225 /* 5 GHz band channels for WL1273 */
3226 static struct ieee80211_channel wl1271_channels_5ghz[] = {
3227         { .hw_value = 7, .center_freq = 5035},
3228         { .hw_value = 8, .center_freq = 5040},
3229         { .hw_value = 9, .center_freq = 5045},
3230         { .hw_value = 11, .center_freq = 5055},
3231         { .hw_value = 12, .center_freq = 5060},
3232         { .hw_value = 16, .center_freq = 5080},
3233         { .hw_value = 34, .center_freq = 5170},
3234         { .hw_value = 36, .center_freq = 5180},
3235         { .hw_value = 38, .center_freq = 5190},
3236         { .hw_value = 40, .center_freq = 5200},
3237         { .hw_value = 42, .center_freq = 5210},
3238         { .hw_value = 44, .center_freq = 5220},
3239         { .hw_value = 46, .center_freq = 5230},
3240         { .hw_value = 48, .center_freq = 5240},
3241         { .hw_value = 52, .center_freq = 5260},
3242         { .hw_value = 56, .center_freq = 5280},
3243         { .hw_value = 60, .center_freq = 5300},
3244         { .hw_value = 64, .center_freq = 5320},
3245         { .hw_value = 100, .center_freq = 5500},
3246         { .hw_value = 104, .center_freq = 5520},
3247         { .hw_value = 108, .center_freq = 5540},
3248         { .hw_value = 112, .center_freq = 5560},
3249         { .hw_value = 116, .center_freq = 5580},
3250         { .hw_value = 120, .center_freq = 5600},
3251         { .hw_value = 124, .center_freq = 5620},
3252         { .hw_value = 128, .center_freq = 5640},
3253         { .hw_value = 132, .center_freq = 5660},
3254         { .hw_value = 136, .center_freq = 5680},
3255         { .hw_value = 140, .center_freq = 5700},
3256         { .hw_value = 149, .center_freq = 5745},
3257         { .hw_value = 153, .center_freq = 5765},
3258         { .hw_value = 157, .center_freq = 5785},
3259         { .hw_value = 161, .center_freq = 5805},
3260         { .hw_value = 165, .center_freq = 5825},
3261 };
3262
3263 /* mapping to indexes for wl1271_rates_5ghz */
3264 static const u8 wl1271_rate_to_idx_5ghz[] = {
3265         /* MCS rates are used only with 11n */
3266         7,                            /* CONF_HW_RXTX_RATE_MCS7 */
3267         6,                            /* CONF_HW_RXTX_RATE_MCS6 */
3268         5,                            /* CONF_HW_RXTX_RATE_MCS5 */
3269         4,                            /* CONF_HW_RXTX_RATE_MCS4 */
3270         3,                            /* CONF_HW_RXTX_RATE_MCS3 */
3271         2,                            /* CONF_HW_RXTX_RATE_MCS2 */
3272         1,                            /* CONF_HW_RXTX_RATE_MCS1 */
3273         0,                            /* CONF_HW_RXTX_RATE_MCS0 */
3274
3275         7,                             /* CONF_HW_RXTX_RATE_54   */
3276         6,                             /* CONF_HW_RXTX_RATE_48   */
3277         5,                             /* CONF_HW_RXTX_RATE_36   */
3278         4,                             /* CONF_HW_RXTX_RATE_24   */
3279
3280         /* TI-specific rate */
3281         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
3282
3283         3,                             /* CONF_HW_RXTX_RATE_18   */
3284         2,                             /* CONF_HW_RXTX_RATE_12   */
3285         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11   */
3286         1,                             /* CONF_HW_RXTX_RATE_9    */
3287         0,                             /* CONF_HW_RXTX_RATE_6    */
3288         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5  */
3289         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2    */
3290         CONF_HW_RXTX_RATE_UNSUPPORTED  /* CONF_HW_RXTX_RATE_1    */
3291 };
3292
3293 static struct ieee80211_supported_band wl1271_band_5ghz = {
3294         .channels = wl1271_channels_5ghz,
3295         .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
3296         .bitrates = wl1271_rates_5ghz,
3297         .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
3298         .ht_cap = WL12XX_HT_CAP,
3299 };
3300
3301 static const u8 *wl1271_band_rate_to_idx[] = {
3302         [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
3303         [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
3304 };
3305
3306 static const struct ieee80211_ops wl1271_ops = {
3307         .start = wl1271_op_start,
3308         .stop = wl1271_op_stop,
3309         .add_interface = wl1271_op_add_interface,
3310         .remove_interface = wl1271_op_remove_interface,
3311         .config = wl1271_op_config,
3312         .prepare_multicast = wl1271_op_prepare_multicast,
3313         .configure_filter = wl1271_op_configure_filter,
3314         .tx = wl1271_op_tx,
3315         .set_key = wl1271_op_set_key,
3316         .hw_scan = wl1271_op_hw_scan,
3317         .bss_info_changed = wl1271_op_bss_info_changed,
3318         .set_frag_threshold = wl1271_op_set_frag_threshold,
3319         .set_rts_threshold = wl1271_op_set_rts_threshold,
3320         .conf_tx = wl1271_op_conf_tx,
3321         .get_tsf = wl1271_op_get_tsf,
3322         .get_survey = wl1271_op_get_survey,
3323         .sta_add = wl1271_op_sta_add,
3324         .sta_remove = wl1271_op_sta_remove,
3325         .ampdu_action = wl1271_op_ampdu_action,
3326         CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
3327 };
3328
3329
3330 u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
3331 {
3332         u8 idx;
3333
3334         BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
3335
3336         if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
3337                 wl1271_error("Illegal RX rate from HW: %d", rate);
3338                 return 0;
3339         }
3340
3341         idx = wl1271_band_rate_to_idx[band][rate];
3342         if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
3343                 wl1271_error("Unsupported RX rate from HW: %d", rate);
3344                 return 0;
3345         }
3346
3347         return idx;
3348 }
3349
3350 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
3351                                                struct device_attribute *attr,
3352                                                char *buf)
3353 {
3354         struct wl1271 *wl = dev_get_drvdata(dev);
3355         ssize_t len;
3356
3357         len = PAGE_SIZE;
3358
3359         mutex_lock(&wl->mutex);
3360         len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
3361                        wl->sg_enabled);
3362         mutex_unlock(&wl->mutex);
3363
3364         return len;
3365
3366 }
3367
3368 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
3369                                                 struct device_attribute *attr,
3370                                                 const char *buf, size_t count)
3371 {
3372         struct wl1271 *wl = dev_get_drvdata(dev);
3373         unsigned long res;
3374         int ret;
3375
3376         ret = strict_strtoul(buf, 10, &res);
3377
3378         if (ret < 0) {
3379                 wl1271_warning("incorrect value written to bt_coex_mode");
3380                 return count;
3381         }
3382
3383         mutex_lock(&wl->mutex);
3384
3385         res = !!res;
3386
3387         if (res == wl->sg_enabled)
3388                 goto out;
3389
3390         wl->sg_enabled = res;
3391
3392         if (wl->state == WL1271_STATE_OFF)
3393                 goto out;
3394
3395         ret = wl1271_ps_elp_wakeup(wl);
3396         if (ret < 0)
3397                 goto out;
3398
3399         wl1271_acx_sg_enable(wl, wl->sg_enabled);
3400         wl1271_ps_elp_sleep(wl);
3401
3402  out:
3403         mutex_unlock(&wl->mutex);
3404         return count;
3405 }
3406
3407 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
3408                    wl1271_sysfs_show_bt_coex_state,
3409                    wl1271_sysfs_store_bt_coex_state);
3410
3411 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
3412                                            struct device_attribute *attr,
3413                                            char *buf)
3414 {
3415         struct wl1271 *wl = dev_get_drvdata(dev);
3416         ssize_t len;
3417
3418         len = PAGE_SIZE;
3419
3420         mutex_lock(&wl->mutex);
3421         if (wl->hw_pg_ver >= 0)
3422                 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
3423         else
3424                 len = snprintf(buf, len, "n/a\n");
3425         mutex_unlock(&wl->mutex);
3426
3427         return len;
3428 }
3429
3430 static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
3431                    wl1271_sysfs_show_hw_pg_ver, NULL);
3432
3433 int wl1271_register_hw(struct wl1271 *wl)
3434 {
3435         int ret;
3436
3437         if (wl->mac80211_registered)
3438                 return 0;
3439
3440         ret = wl1271_fetch_nvs(wl);
3441         if (ret == 0) {
3442                 /* NOTE: The wl->nvs->nvs element must be first, in
3443                  * order to simplify the casting, we assume it is at
3444                  * the beginning of the wl->nvs structure.
3445                  */
3446                 u8 *nvs_ptr = (u8 *)wl->nvs;
3447
3448                 wl->mac_addr[0] = nvs_ptr[11];
3449                 wl->mac_addr[1] = nvs_ptr[10];
3450                 wl->mac_addr[2] = nvs_ptr[6];
3451                 wl->mac_addr[3] = nvs_ptr[5];
3452                 wl->mac_addr[4] = nvs_ptr[4];
3453                 wl->mac_addr[5] = nvs_ptr[3];
3454         }
3455
3456         SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
3457
3458         ret = ieee80211_register_hw(wl->hw);
3459         if (ret < 0) {
3460                 wl1271_error("unable to register mac80211 hw: %d", ret);
3461                 return ret;
3462         }
3463
3464         wl->mac80211_registered = true;
3465
3466         wl1271_debugfs_init(wl);
3467
3468         register_netdevice_notifier(&wl1271_dev_notifier);
3469
3470         wl1271_notice("loaded");
3471
3472         return 0;
3473 }
3474 EXPORT_SYMBOL_GPL(wl1271_register_hw);
3475
3476 void wl1271_unregister_hw(struct wl1271 *wl)
3477 {
3478         if (wl->state == WL1271_STATE_PLT)
3479                 __wl1271_plt_stop(wl);
3480
3481         unregister_netdevice_notifier(&wl1271_dev_notifier);
3482         ieee80211_unregister_hw(wl->hw);
3483         wl->mac80211_registered = false;
3484
3485 }
3486 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
3487
3488 int wl1271_init_ieee80211(struct wl1271 *wl)
3489 {
3490         static const u32 cipher_suites[] = {
3491                 WLAN_CIPHER_SUITE_WEP40,
3492                 WLAN_CIPHER_SUITE_WEP104,
3493                 WLAN_CIPHER_SUITE_TKIP,
3494                 WLAN_CIPHER_SUITE_CCMP,
3495                 WL1271_CIPHER_SUITE_GEM,
3496         };
3497
3498         /* The tx descriptor buffer and the TKIP space. */
3499         wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
3500                 sizeof(struct wl1271_tx_hw_descr);
3501
3502         /* unit us */
3503         /* FIXME: find a proper value */
3504         wl->hw->channel_change_time = 10000;
3505         wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
3506
3507         wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
3508                 IEEE80211_HW_BEACON_FILTER |
3509                 IEEE80211_HW_SUPPORTS_PS |
3510                 IEEE80211_HW_SUPPORTS_UAPSD |
3511                 IEEE80211_HW_HAS_RATE_CONTROL |
3512                 IEEE80211_HW_CONNECTION_MONITOR |
3513                 IEEE80211_HW_SUPPORTS_CQM_RSSI |
3514                 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
3515                 IEEE80211_HW_AP_LINK_PS;
3516
3517         wl->hw->wiphy->cipher_suites = cipher_suites;
3518         wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
3519
3520         wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
3521                 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
3522         wl->hw->wiphy->max_scan_ssids = 1;
3523         /*
3524          * Maximum length of elements in scanning probe request templates
3525          * should be the maximum length possible for a template, without
3526          * the IEEE80211 header of the template
3527          */
3528         wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
3529                         sizeof(struct ieee80211_header);
3530
3531         /* make sure all our channels fit in the scanned_ch bitmask */
3532         BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
3533                      ARRAY_SIZE(wl1271_channels_5ghz) >
3534                      WL1271_MAX_CHANNELS);
3535         /*
3536          * We keep local copies of the band structs because we need to
3537          * modify them on a per-device basis.
3538          */
3539         memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
3540                sizeof(wl1271_band_2ghz));
3541         memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
3542                sizeof(wl1271_band_5ghz));
3543
3544         wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
3545                 &wl->bands[IEEE80211_BAND_2GHZ];
3546         wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
3547                 &wl->bands[IEEE80211_BAND_5GHZ];
3548
3549         wl->hw->queues = 4;
3550         wl->hw->max_rates = 1;
3551
3552         wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
3553
3554         SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
3555
3556         wl->hw->sta_data_size = sizeof(struct wl1271_station);
3557
3558         wl->hw->max_rx_aggregation_subframes = 8;
3559
3560         return 0;
3561 }
3562 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
3563
3564 #define WL1271_DEFAULT_CHANNEL 0
3565
3566 struct ieee80211_hw *wl1271_alloc_hw(void)
3567 {
3568         struct ieee80211_hw *hw;
3569         struct platform_device *plat_dev = NULL;
3570         struct wl1271 *wl;
3571         int i, j, ret;
3572         unsigned int order;
3573
3574         hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
3575         if (!hw) {
3576                 wl1271_error("could not alloc ieee80211_hw");
3577                 ret = -ENOMEM;
3578                 goto err_hw_alloc;
3579         }
3580
3581         plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
3582         if (!plat_dev) {
3583                 wl1271_error("could not allocate platform_device");
3584                 ret = -ENOMEM;
3585                 goto err_plat_alloc;
3586         }
3587
3588         wl = hw->priv;
3589         memset(wl, 0, sizeof(*wl));
3590
3591         INIT_LIST_HEAD(&wl->list);
3592
3593         wl->hw = hw;
3594         wl->plat_dev = plat_dev;
3595
3596         for (i = 0; i < NUM_TX_QUEUES; i++)
3597                 skb_queue_head_init(&wl->tx_queue[i]);
3598
3599         for (i = 0; i < NUM_TX_QUEUES; i++)
3600                 for (j = 0; j < AP_MAX_LINKS; j++)
3601                         skb_queue_head_init(&wl->links[j].tx_queue[i]);
3602
3603         skb_queue_head_init(&wl->deferred_rx_queue);
3604         skb_queue_head_init(&wl->deferred_tx_queue);
3605
3606         INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
3607         INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
3608         INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
3609         INIT_WORK(&wl->tx_work, wl1271_tx_work);
3610         INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
3611         INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
3612         wl->channel = WL1271_DEFAULT_CHANNEL;
3613         wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
3614         wl->default_key = 0;
3615         wl->rx_counter = 0;
3616         wl->rx_config = WL1271_DEFAULT_STA_RX_CONFIG;
3617         wl->rx_filter = WL1271_DEFAULT_STA_RX_FILTER;
3618         wl->psm_entry_retry = 0;
3619         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
3620         wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
3621         wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
3622         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
3623         wl->band = IEEE80211_BAND_2GHZ;
3624         wl->vif = NULL;
3625         wl->flags = 0;
3626         wl->sg_enabled = true;
3627         wl->hw_pg_ver = -1;
3628         wl->bss_type = MAX_BSS_TYPE;
3629         wl->set_bss_type = MAX_BSS_TYPE;
3630         wl->fw_bss_type = MAX_BSS_TYPE;
3631         wl->last_tx_hlid = 0;
3632         wl->ap_ps_map = 0;
3633         wl->ap_fw_ps_map = 0;
3634         wl->quirks = 0;
3635         wl->block_size = 0;
3636
3637         memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
3638         for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
3639                 wl->tx_frames[i] = NULL;
3640
3641         spin_lock_init(&wl->wl_lock);
3642
3643         wl->state = WL1271_STATE_OFF;
3644         mutex_init(&wl->mutex);
3645
3646         /* Apply default driver configuration. */
3647         wl1271_conf_init(wl);
3648
3649         order = get_order(WL1271_AGGR_BUFFER_SIZE);
3650         wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
3651         if (!wl->aggr_buf) {
3652                 ret = -ENOMEM;
3653                 goto err_hw;
3654         }
3655
3656         /* Register platform device */
3657         ret = platform_device_register(wl->plat_dev);
3658         if (ret) {
3659                 wl1271_error("couldn't register platform device");
3660                 goto err_aggr;
3661         }
3662         dev_set_drvdata(&wl->plat_dev->dev, wl);
3663
3664         /* Create sysfs file to control bt coex state */
3665         ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
3666         if (ret < 0) {
3667                 wl1271_error("failed to create sysfs file bt_coex_state");
3668                 goto err_platform;
3669         }
3670
3671         /* Create sysfs file to get HW PG version */
3672         ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
3673         if (ret < 0) {
3674                 wl1271_error("failed to create sysfs file hw_pg_ver");
3675                 goto err_bt_coex_state;
3676         }
3677
3678         return hw;
3679
3680 err_bt_coex_state:
3681         device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
3682
3683 err_platform:
3684         platform_device_unregister(wl->plat_dev);
3685
3686 err_aggr:
3687         free_pages((unsigned long)wl->aggr_buf, order);
3688
3689 err_hw:
3690         wl1271_debugfs_exit(wl);
3691         kfree(plat_dev);
3692
3693 err_plat_alloc:
3694         ieee80211_free_hw(hw);
3695
3696 err_hw_alloc:
3697
3698         return ERR_PTR(ret);
3699 }
3700 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
3701
3702 int wl1271_free_hw(struct wl1271 *wl)
3703 {
3704         platform_device_unregister(wl->plat_dev);
3705         free_pages((unsigned long)wl->aggr_buf,
3706                         get_order(WL1271_AGGR_BUFFER_SIZE));
3707         kfree(wl->plat_dev);
3708
3709         wl1271_debugfs_exit(wl);
3710
3711         vfree(wl->fw);
3712         wl->fw = NULL;
3713         kfree(wl->nvs);
3714         wl->nvs = NULL;
3715
3716         kfree(wl->fw_status);
3717         kfree(wl->tx_res_if);
3718
3719         ieee80211_free_hw(wl->hw);
3720
3721         return 0;
3722 }
3723 EXPORT_SYMBOL_GPL(wl1271_free_hw);
3724
3725 u32 wl12xx_debug_level = DEBUG_NONE;
3726 EXPORT_SYMBOL_GPL(wl12xx_debug_level);
3727 module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
3728 MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
3729
3730 MODULE_LICENSE("GPL");
3731 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
3732 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");