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