drivers/net/wireless/wl12xx/main.c

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