drivers/net/wireless/wl12xx/main.c

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