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