drivers/net/wireless/wl12xx/wl1271_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 "wl1271.h"
  35 #include "wl12xx_80211.h"
  36 #include "wl1271_reg.h"
  37 #include "wl1271_io.h"
  38 #include "wl1271_event.h"
  39 #include "wl1271_tx.h"
  40 #include "wl1271_rx.h"
  41 #include "wl1271_ps.h"
  42 #include "wl1271_init.h"
  43 #include "wl1271_debugfs.h"
  44 #include "wl1271_cmd.h"
  45 #include "wl1271_boot.h"
  46 #include "wl1271_testmode.h"
  47 #include "wl1271_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                 .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                         [0] = {
 128                                 .ac          = CONF_TX_AC_BE,
 129                                 .cw_min      = 15,
 130                                 .cw_max      = 63,
 131                                 .aifsn       = 3,
 132                                 .tx_op_limit = 0,
 133                         },
 134                         [1] = {
 135                                 .ac          = CONF_TX_AC_BK,
 136                                 .cw_min      = 15,
 137                                 .cw_max      = 63,
 138                                 .aifsn       = 7,
 139                                 .tx_op_limit = 0,
 140                         },
 141                         [2] = {
 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                         [3] = {
 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                 .tid_conf_count = 7,
 157                 .tid_conf = {
 158                         [0] = {
 159                                 .queue_id    = 0,
 160                                 .channel_type = CONF_CHANNEL_TYPE_DCF,
 161                                 .tsid        = CONF_TX_AC_BE,
 162                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
 163                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
 164                                 .apsd_conf   = {0, 0},
 165                         },
 166                         [1] = {
 167                                 .queue_id    = 1,
 168                                 .channel_type = CONF_CHANNEL_TYPE_DCF,
 169                                 .tsid        = CONF_TX_AC_BE,
 170                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
 171                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
 172                                 .apsd_conf   = {0, 0},
 173                         },
 174                         [2] = {
 175                                 .queue_id    = 2,
 176                                 .channel_type = CONF_CHANNEL_TYPE_DCF,
 177                                 .tsid        = CONF_TX_AC_BE,
 178                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
 179                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
 180                                 .apsd_conf   = {0, 0},
 181                         },
 182                         [3] = {
 183                                 .queue_id    = 3,
 184                                 .channel_type = CONF_CHANNEL_TYPE_DCF,
 185                                 .tsid        = CONF_TX_AC_BE,
 186                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
 187                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
 188                                 .apsd_conf   = {0, 0},
 189                         },
 190                         [4] = {
 191                                 .queue_id    = 4,
 192                                 .channel_type = CONF_CHANNEL_TYPE_DCF,
 193                                 .tsid        = CONF_TX_AC_BE,
 194                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
 195                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
 196                                 .apsd_conf   = {0, 0},
 197                         },
 198                         [5] = {
 199                                 .queue_id    = 5,
 200                                 .channel_type = CONF_CHANNEL_TYPE_DCF,
 201                                 .tsid        = CONF_TX_AC_BE,
 202                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
 203                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
 204                                 .apsd_conf   = {0, 0},
 205                         },
 206                         [6] = {
 207                                 .queue_id    = 6,
 208                                 .channel_type = CONF_CHANNEL_TYPE_DCF,
 209                                 .tsid        = CONF_TX_AC_BE,
 210                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
 211                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
 212                                 .apsd_conf   = {0, 0},
 213                         }
 214                 },
 215                 .frag_threshold              = IEEE80211_MAX_FRAG_THRESHOLD,
 216                 .tx_compl_timeout            = 700,
 217                 .tx_compl_threshold          = 4,
 218                 .basic_rate                  = CONF_HW_BIT_RATE_1MBPS,
 219                 .basic_rate_5                = CONF_HW_BIT_RATE_6MBPS,
 220         },
 221         .conn = {
 222                 .wake_up_event               = CONF_WAKE_UP_EVENT_DTIM,
 223                 .listen_interval             = 1,
 224                 .bcn_filt_mode               = CONF_BCN_FILT_MODE_ENABLED,
 225                 .bcn_filt_ie_count           = 1,
 226                 .bcn_filt_ie = {
 227                         [0] = {
 228                                 .ie          = WLAN_EID_CHANNEL_SWITCH,
 229                                 .rule        = CONF_BCN_RULE_PASS_ON_APPEARANCE,
 230                         }
 231                 },
 232                 .synch_fail_thold            = 10,
 233                 .bss_lose_timeout            = 100,
 234                 .beacon_rx_timeout           = 10000,
 235                 .broadcast_timeout           = 20000,
 236                 .rx_broadcast_in_ps          = 1,
 237                 .ps_poll_threshold           = 10,
 238                 .ps_poll_recovery_period     = 700,
 239                 .bet_enable                  = CONF_BET_MODE_ENABLE,
 240                 .bet_max_consecutive         = 10,
 241                 .psm_entry_retries           = 3,
 242                 .keep_alive_interval         = 55000,
 243                 .max_listen_interval         = 20,
 244         },
 245         .itrim = {
 246                 .enable = false,
 247                 .timeout = 50000,
 248         },
 249         .pm_config = {
 250                 .host_clk_settling_time = 5000,
 251                 .host_fast_wakeup_support = false
 252         },
 253         .roam_trigger = {
 254                 /* FIXME: due to firmware bug, must use value 1 for now */
 255                 .trigger_pacing               = 1,
 256                 .avg_weight_rssi_beacon       = 20,
 257                 .avg_weight_rssi_data         = 10,
 258                 .avg_weight_snr_beacon        = 20,
 259                 .avg_weight_snr_data          = 10
 260         }
 261 };
 262
 263 static void wl1271_device_release(struct device *dev)
 264 {
 265
 266 }
 267
 268 static struct platform_device wl1271_device = {
 269         .name           = "wl1271",
 270         .id             = -1,
 271
 272         /* device model insists to have a release function */
 273         .dev            = {
 274                 .release = wl1271_device_release,
 275         },
 276 };
 277
 278 static LIST_HEAD(wl_list);
 279
 280 static void wl1271_conf_init(struct wl1271 *wl)
 281 {
 282
 283         /*
 284          * This function applies the default configuration to the driver. This
 285          * function is invoked upon driver load (spi probe.)
 286          *
 287          * The configuration is stored in a run-time structure in order to
 288          * facilitate for run-time adjustment of any of the parameters. Making
 289          * changes to the configuration structure will apply the new values on
 290          * the next interface up (wl1271_op_start.)
 291          */
 292
 293         /* apply driver default configuration */
 294         memcpy(&wl->conf, &default_conf, sizeof(default_conf));
 295 }
 296
 297
 298 static int wl1271_plt_init(struct wl1271 *wl)
 299 {
 300         struct conf_tx_ac_category *conf_ac;
 301         struct conf_tx_tid *conf_tid;
 302         int ret, i;
 303
 304         ret = wl1271_cmd_general_parms(wl);
 305         if (ret < 0)
 306                 return ret;
 307
 308         ret = wl1271_cmd_radio_parms(wl);
 309         if (ret < 0)
 310                 return ret;
 311
 312         ret = wl1271_init_templates_config(wl);
 313         if (ret < 0)
 314                 return ret;
 315
 316         ret = wl1271_acx_init_mem_config(wl);
 317         if (ret < 0)
 318                 return ret;
 319
 320         /* PHY layer config */
 321         ret = wl1271_init_phy_config(wl);
 322         if (ret < 0)
 323                 goto out_free_memmap;
 324
 325         ret = wl1271_acx_dco_itrim_params(wl);
 326         if (ret < 0)
 327                 goto out_free_memmap;
 328
 329         /* Initialize connection monitoring thresholds */
 330         ret = wl1271_acx_conn_monit_params(wl, false);
 331         if (ret < 0)
 332                 goto out_free_memmap;
 333
 334         /* Bluetooth WLAN coexistence */
 335         ret = wl1271_init_pta(wl);
 336         if (ret < 0)
 337                 goto out_free_memmap;
 338
 339         /* Energy detection */
 340         ret = wl1271_init_energy_detection(wl);
 341         if (ret < 0)
 342                 goto out_free_memmap;
 343
 344         /* Default fragmentation threshold */
 345         ret = wl1271_acx_frag_threshold(wl);
 346         if (ret < 0)
 347                 goto out_free_memmap;
 348
 349         /* Default TID configuration */
 350         for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
 351                 conf_tid = &wl->conf.tx.tid_conf[i];
 352                 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
 353                                          conf_tid->channel_type,
 354                                          conf_tid->tsid,
 355                                          conf_tid->ps_scheme,
 356                                          conf_tid->ack_policy,
 357                                          conf_tid->apsd_conf[0],
 358                                          conf_tid->apsd_conf[1]);
 359                 if (ret < 0)
 360                         goto out_free_memmap;
 361         }
 362
 363         /* Default AC configuration */
 364         for (i = 0; i < wl->conf.tx.ac_conf_count; i++) {
 365                 conf_ac = &wl->conf.tx.ac_conf[i];
 366                 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
 367                                         conf_ac->cw_max, conf_ac->aifsn,
 368                                         conf_ac->tx_op_limit);
 369                 if (ret < 0)
 370                         goto out_free_memmap;
 371         }
 372
 373         /* Enable data path */
 374         ret = wl1271_cmd_data_path(wl, 1);
 375         if (ret < 0)
 376                 goto out_free_memmap;
 377
 378         /* Configure for CAM power saving (ie. always active) */
 379         ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
 380         if (ret < 0)
 381                 goto out_free_memmap;
 382
 383         /* configure PM */
 384         ret = wl1271_acx_pm_config(wl);
 385         if (ret < 0)
 386                 goto out_free_memmap;
 387
 388         return 0;
 389
 390  out_free_memmap:
 391         kfree(wl->target_mem_map);
 392         wl->target_mem_map = NULL;
 393
 394         return ret;
 395 }
 396
 397 static void wl1271_fw_status(struct wl1271 *wl,
 398                              struct wl1271_fw_status *status)
 399 {
 400         struct timespec ts;
 401         u32 total = 0;
 402         int i;
 403
 404         wl1271_raw_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
 405
 406         wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
 407                      "drv_rx_counter = %d, tx_results_counter = %d)",
 408                      status->intr,
 409                      status->fw_rx_counter,
 410                      status->drv_rx_counter,
 411                      status->tx_results_counter);
 412
 413         /* update number of available TX blocks */
 414         for (i = 0; i < NUM_TX_QUEUES; i++) {
 415                 u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
 416                         wl->tx_blocks_freed[i];
 417
 418                 wl->tx_blocks_freed[i] =
 419                         le32_to_cpu(status->tx_released_blks[i]);
 420                 wl->tx_blocks_available += cnt;
 421                 total += cnt;
 422         }
 423
 424         /* if more blocks are available now, schedule some tx work */
 425         if (total && !skb_queue_empty(&wl->tx_queue))
 426                 ieee80211_queue_work(wl->hw, &wl->tx_work);
 427
 428         /* update the host-chipset time offset */
 429         getnstimeofday(&ts);
 430         wl->time_offset = (timespec_to_ns(&ts) >> 10) -
 431                 (s64)le32_to_cpu(status->fw_localtime);
 432 }
 433
 434 #define WL1271_IRQ_MAX_LOOPS 10
 435
 436 static void wl1271_irq_work(struct work_struct *work)
 437 {
 438         int ret;
 439         u32 intr;
 440         int loopcount = WL1271_IRQ_MAX_LOOPS;
 441         unsigned long flags;
 442         struct wl1271 *wl =
 443                 container_of(work, struct wl1271, irq_work);
 444
 445         mutex_lock(&wl->mutex);
 446
 447         wl1271_debug(DEBUG_IRQ, "IRQ work");
 448
 449         if (unlikely(wl->state == WL1271_STATE_OFF))
 450                 goto out;
 451
 452         ret = wl1271_ps_elp_wakeup(wl, true);
 453         if (ret < 0)
 454                 goto out;
 455
 456         spin_lock_irqsave(&wl->wl_lock, flags);
 457         while (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags) && loopcount) {
 458                 clear_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
 459                 spin_unlock_irqrestore(&wl->wl_lock, flags);
 460                 loopcount--;
 461
 462                 wl1271_fw_status(wl, wl->fw_status);
 463                 intr = le32_to_cpu(wl->fw_status->intr);
 464                 if (!intr) {
 465                         wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
 466                         spin_lock_irqsave(&wl->wl_lock, flags);
 467                         continue;
 468                 }
 469
 470                 intr &= WL1271_INTR_MASK;
 471
 472                 if (intr & WL1271_ACX_INTR_DATA) {
 473                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
 474
 475                         /* check for tx results */
 476                         if (wl->fw_status->tx_results_counter !=
 477                             (wl->tx_results_count & 0xff))
 478                                 wl1271_tx_complete(wl);
 479
 480                         wl1271_rx(wl, wl->fw_status);
 481                 }
 482
 483                 if (intr & WL1271_ACX_INTR_EVENT_A) {
 484                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
 485                         wl1271_event_handle(wl, 0);
 486                 }
 487
 488                 if (intr & WL1271_ACX_INTR_EVENT_B) {
 489                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
 490                         wl1271_event_handle(wl, 1);
 491                 }
 492
 493                 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
 494                         wl1271_debug(DEBUG_IRQ,
 495                                      "WL1271_ACX_INTR_INIT_COMPLETE");
 496
 497                 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
 498                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
 499
 500                 spin_lock_irqsave(&wl->wl_lock, flags);
 501         }
 502
 503         if (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags))
 504                 ieee80211_queue_work(wl->hw, &wl->irq_work);
 505         else
 506                 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
 507         spin_unlock_irqrestore(&wl->wl_lock, flags);
 508
 509         wl1271_ps_elp_sleep(wl);
 510
 511 out:
 512         mutex_unlock(&wl->mutex);
 513 }
 514
 515 static int wl1271_fetch_firmware(struct wl1271 *wl)
 516 {
 517         const struct firmware *fw;
 518         int ret;
 519
 520         ret = request_firmware(&fw, WL1271_FW_NAME, wl1271_wl_to_dev(wl));
 521
 522         if (ret < 0) {
 523                 wl1271_error("could not get firmware: %d", ret);
 524                 return ret;
 525         }
 526
 527         if (fw->size % 4) {
 528                 wl1271_error("firmware size is not multiple of 32 bits: %zu",
 529                              fw->size);
 530                 ret = -EILSEQ;
 531                 goto out;
 532         }
 533
 534         wl->fw_len = fw->size;
 535         wl->fw = vmalloc(wl->fw_len);
 536
 537         if (!wl->fw) {
 538                 wl1271_error("could not allocate memory for the firmware");
 539                 ret = -ENOMEM;
 540                 goto out;
 541         }
 542
 543         memcpy(wl->fw, fw->data, wl->fw_len);
 544
 545         ret = 0;
 546
 547 out:
 548         release_firmware(fw);
 549
 550         return ret;
 551 }
 552
 553 static int wl1271_fetch_nvs(struct wl1271 *wl)
 554 {
 555         const struct firmware *fw;
 556         int ret;
 557
 558         ret = request_firmware(&fw, WL1271_NVS_NAME, wl1271_wl_to_dev(wl));
 559
 560         if (ret < 0) {
 561                 wl1271_error("could not get nvs file: %d", ret);
 562                 return ret;
 563         }
 564
 565         /*
 566          * FIXME: the LEGACY NVS image support (NVS's missing the 5GHz band
 567          * configurations) can be removed when those NVS files stop floating
 568          * around.
 569          */
 570         if (fw->size != sizeof(struct wl1271_nvs_file) &&
 571             (fw->size != WL1271_INI_LEGACY_NVS_FILE_SIZE ||
 572              wl1271_11a_enabled())) {
 573                 wl1271_error("nvs size is not as expected: %zu != %zu",
 574                              fw->size, sizeof(struct wl1271_nvs_file));
 575                 ret = -EILSEQ;
 576                 goto out;
 577         }
 578
 579         wl->nvs = kmemdup(fw->data, sizeof(struct wl1271_nvs_file), GFP_KERNEL);
 580
 581         if (!wl->nvs) {
 582                 wl1271_error("could not allocate memory for the nvs file");
 583                 ret = -ENOMEM;
 584                 goto out;
 585         }
 586
 587 out:
 588         release_firmware(fw);
 589
 590         return ret;
 591 }
 592
 593 static void wl1271_fw_wakeup(struct wl1271 *wl)
 594 {
 595         u32 elp_reg;
 596
 597         elp_reg = ELPCTRL_WAKE_UP;
 598         wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
 599 }
 600
 601 static int wl1271_setup(struct wl1271 *wl)
 602 {
 603         wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
 604         if (!wl->fw_status)
 605                 return -ENOMEM;
 606
 607         wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
 608         if (!wl->tx_res_if) {
 609                 kfree(wl->fw_status);
 610                 return -ENOMEM;
 611         }
 612
 613         INIT_WORK(&wl->irq_work, wl1271_irq_work);
 614         INIT_WORK(&wl->tx_work, wl1271_tx_work);
 615         return 0;
 616 }
 617
 618 static int wl1271_chip_wakeup(struct wl1271 *wl)
 619 {
 620         struct wl1271_partition_set partition;
 621         int ret = 0;
 622
 623         msleep(WL1271_PRE_POWER_ON_SLEEP);
 624         wl1271_power_on(wl);
 625         msleep(WL1271_POWER_ON_SLEEP);
 626         wl1271_io_reset(wl);
 627         wl1271_io_init(wl);
 628
 629         /* We don't need a real memory partition here, because we only want
 630          * to use the registers at this point. */
 631         memset(&partition, 0, sizeof(partition));
 632         partition.reg.start = REGISTERS_BASE;
 633         partition.reg.size = REGISTERS_DOWN_SIZE;
 634         wl1271_set_partition(wl, &partition);
 635
 636         /* ELP module wake up */
 637         wl1271_fw_wakeup(wl);
 638
 639         /* whal_FwCtrl_BootSm() */
 640
 641         /* 0. read chip id from CHIP_ID */
 642         wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
 643
 644         /* 1. check if chip id is valid */
 645
 646         switch (wl->chip.id) {
 647         case CHIP_ID_1271_PG10:
 648                 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
 649                                wl->chip.id);
 650
 651                 ret = wl1271_setup(wl);
 652                 if (ret < 0)
 653                         goto out;
 654                 break;
 655         case CHIP_ID_1271_PG20:
 656                 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
 657                              wl->chip.id);
 658
 659                 ret = wl1271_setup(wl);
 660                 if (ret < 0)
 661                         goto out;
 662                 break;
 663         default:
 664                 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
 665                 ret = -ENODEV;
 666                 goto out;
 667         }
 668
 669         if (wl->fw == NULL) {
 670                 ret = wl1271_fetch_firmware(wl);
 671                 if (ret < 0)
 672                         goto out;
 673         }
 674
 675         /* No NVS from netlink, try to get it from the filesystem */
 676         if (wl->nvs == NULL) {
 677                 ret = wl1271_fetch_nvs(wl);
 678                 if (ret < 0)
 679                         goto out;
 680         }
 681
 682 out:
 683         return ret;
 684 }
 685
 686 int wl1271_plt_start(struct wl1271 *wl)
 687 {
 688         int retries = WL1271_BOOT_RETRIES;
 689         int ret;
 690
 691         mutex_lock(&wl->mutex);
 692
 693         wl1271_notice("power up");
 694
 695         if (wl->state != WL1271_STATE_OFF) {
 696                 wl1271_error("cannot go into PLT state because not "
 697                              "in off state: %d", wl->state);
 698                 ret = -EBUSY;
 699                 goto out;
 700         }
 701
 702         while (retries) {
 703                 retries--;
 704                 ret = wl1271_chip_wakeup(wl);
 705                 if (ret < 0)
 706                         goto power_off;
 707
 708                 ret = wl1271_boot(wl);
 709                 if (ret < 0)
 710                         goto power_off;
 711
 712                 ret = wl1271_plt_init(wl);
 713                 if (ret < 0)
 714                         goto irq_disable;
 715
 716                 wl->state = WL1271_STATE_PLT;
 717                 wl1271_notice("firmware booted in PLT mode (%s)",
 718                               wl->chip.fw_ver);
 719                 goto out;
 720
 721 irq_disable:
 722                 wl1271_disable_interrupts(wl);
 723                 mutex_unlock(&wl->mutex);
 724                 /* Unlocking the mutex in the middle of handling is
 725                    inherently unsafe. In this case we deem it safe to do,
 726                    because we need to let any possibly pending IRQ out of
 727                    the system (and while we are WL1271_STATE_OFF the IRQ
 728                    work function will not do anything.) Also, any other
 729                    possible concurrent operations will fail due to the
 730                    current state, hence the wl1271 struct should be safe. */
 731                 cancel_work_sync(&wl->irq_work);
 732                 mutex_lock(&wl->mutex);
 733 power_off:
 734                 wl1271_power_off(wl);
 735         }
 736
 737         wl1271_error("firmware boot in PLT mode failed despite %d retries",
 738                      WL1271_BOOT_RETRIES);
 739 out:
 740         mutex_unlock(&wl->mutex);
 741
 742         return ret;
 743 }
 744
 745 int wl1271_plt_stop(struct wl1271 *wl)
 746 {
 747         int ret = 0;
 748
 749         mutex_lock(&wl->mutex);
 750
 751         wl1271_notice("power down");
 752
 753         if (wl->state != WL1271_STATE_PLT) {
 754                 wl1271_error("cannot power down because not in PLT "
 755                              "state: %d", wl->state);
 756                 ret = -EBUSY;
 757                 goto out;
 758         }
 759
 760         wl1271_disable_interrupts(wl);
 761         wl1271_power_off(wl);
 762
 763         wl->state = WL1271_STATE_OFF;
 764         wl->rx_counter = 0;
 765
 766 out:
 767         mutex_unlock(&wl->mutex);
 768
 769         return ret;
 770 }
 771
 772
 773 static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
 774 {
 775         struct wl1271 *wl = hw->priv;
 776         struct ieee80211_conf *conf = &hw->conf;
 777         struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
 778         struct ieee80211_sta *sta = txinfo->control.sta;
 779         unsigned long flags;
 780
 781         /* peek into the rates configured in the STA entry */
 782         spin_lock_irqsave(&wl->wl_lock, flags);
 783         if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
 784                 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
 785                 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
 786         }
 787         spin_unlock_irqrestore(&wl->wl_lock, flags);
 788
 789         /* queue the packet */
 790         skb_queue_tail(&wl->tx_queue, skb);
 791
 792         /*
 793          * The chip specific setup must run before the first TX packet -
 794          * before that, the tx_work will not be initialized!
 795          */
 796
 797         ieee80211_queue_work(wl->hw, &wl->tx_work);
 798
 799         /*
 800          * The workqueue is slow to process the tx_queue and we need stop
 801          * the queue here, otherwise the queue will get too long.
 802          */
 803         if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
 804                 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
 805
 806                 spin_lock_irqsave(&wl->wl_lock, flags);
 807                 ieee80211_stop_queues(wl->hw);
 808                 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
 809                 spin_unlock_irqrestore(&wl->wl_lock, flags);
 810         }
 811
 812         return NETDEV_TX_OK;
 813 }
 814
 815 static int wl1271_op_start(struct ieee80211_hw *hw)
 816 {
 817         wl1271_debug(DEBUG_MAC80211, "mac80211 start");
 818
 819         /*
 820          * We have to delay the booting of the hardware because
 821          * we need to know the local MAC address before downloading and
 822          * initializing the firmware. The MAC address cannot be changed
 823          * after boot, and without the proper MAC address, the firmware
 824          * will not function properly.
 825          *
 826          * The MAC address is first known when the corresponding interface
 827          * is added. That is where we will initialize the hardware.
 828          */
 829
 830         return 0;
 831 }
 832
 833 static void wl1271_op_stop(struct ieee80211_hw *hw)
 834 {
 835         wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
 836 }
 837
 838 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
 839                                    struct ieee80211_vif *vif)
 840 {
 841         struct wl1271 *wl = hw->priv;
 842         struct wiphy *wiphy = hw->wiphy;
 843         int retries = WL1271_BOOT_RETRIES;
 844         int ret = 0;
 845
 846         wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
 847                      vif->type, vif->addr);
 848
 849         mutex_lock(&wl->mutex);
 850         if (wl->vif) {
 851                 ret = -EBUSY;
 852                 goto out;
 853         }
 854
 855         wl->vif = vif;
 856
 857         switch (vif->type) {
 858         case NL80211_IFTYPE_STATION:
 859                 wl->bss_type = BSS_TYPE_STA_BSS;
 860                 wl->set_bss_type = BSS_TYPE_STA_BSS;
 861                 break;
 862         case NL80211_IFTYPE_ADHOC:
 863                 wl->bss_type = BSS_TYPE_IBSS;
 864                 wl->set_bss_type = BSS_TYPE_STA_BSS;
 865                 break;
 866         default:
 867                 ret = -EOPNOTSUPP;
 868                 goto out;
 869         }
 870
 871         memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
 872
 873         if (wl->state != WL1271_STATE_OFF) {
 874                 wl1271_error("cannot start because not in off state: %d",
 875                              wl->state);
 876                 ret = -EBUSY;
 877                 goto out;
 878         }
 879
 880         while (retries) {
 881                 retries--;
 882                 ret = wl1271_chip_wakeup(wl);
 883                 if (ret < 0)
 884                         goto power_off;
 885
 886                 ret = wl1271_boot(wl);
 887                 if (ret < 0)
 888                         goto power_off;
 889
 890                 ret = wl1271_hw_init(wl);
 891                 if (ret < 0)
 892                         goto irq_disable;
 893
 894                 wl->state = WL1271_STATE_ON;
 895                 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
 896
 897                 /* update hw/fw version info in wiphy struct */
 898                 wiphy->hw_version = wl->chip.id;
 899                 strncpy(wiphy->fw_version, wl->chip.fw_ver,
 900                         sizeof(wiphy->fw_version));
 901
 902                 goto out;
 903
 904 irq_disable:
 905                 wl1271_disable_interrupts(wl);
 906                 mutex_unlock(&wl->mutex);
 907                 /* Unlocking the mutex in the middle of handling is
 908                    inherently unsafe. In this case we deem it safe to do,
 909                    because we need to let any possibly pending IRQ out of
 910                    the system (and while we are WL1271_STATE_OFF the IRQ
 911                    work function will not do anything.) Also, any other
 912                    possible concurrent operations will fail due to the
 913                    current state, hence the wl1271 struct should be safe. */
 914                 cancel_work_sync(&wl->irq_work);
 915                 mutex_lock(&wl->mutex);
 916 power_off:
 917                 wl1271_power_off(wl);
 918         }
 919
 920         wl1271_error("firmware boot failed despite %d retries",
 921                      WL1271_BOOT_RETRIES);
 922 out:
 923         mutex_unlock(&wl->mutex);
 924
 925         if (!ret)
 926                 list_add(&wl->list, &wl_list);
 927
 928         return ret;
 929 }
 930
 931 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
 932                                        struct ieee80211_vif *vif)
 933 {
 934         struct wl1271 *wl = hw->priv;
 935         int i;
 936
 937         mutex_lock(&wl->mutex);
 938         wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
 939
 940         wl1271_info("down");
 941
 942         list_del(&wl->list);
 943
 944         WARN_ON(wl->state != WL1271_STATE_ON);
 945
 946         /* enable dyn ps just in case (if left on due to fw crash etc) */
 947         if (wl->bss_type == BSS_TYPE_STA_BSS)
 948                 ieee80211_enable_dyn_ps(wl->vif);
 949
 950         if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
 951                 ieee80211_scan_completed(wl->hw, true);
 952                 wl->scan.state = WL1271_SCAN_STATE_IDLE;
 953                 kfree(wl->scan.scanned_ch);
 954                 wl->scan.scanned_ch = NULL;
 955         }
 956
 957         wl->state = WL1271_STATE_OFF;
 958
 959         wl1271_disable_interrupts(wl);
 960
 961         mutex_unlock(&wl->mutex);
 962
 963         cancel_work_sync(&wl->irq_work);
 964         cancel_work_sync(&wl->tx_work);
 965         cancel_delayed_work_sync(&wl->pspoll_work);
 966
 967         mutex_lock(&wl->mutex);
 968
 969         /* let's notify MAC80211 about the remaining pending TX frames */
 970         wl1271_tx_reset(wl);
 971         wl1271_power_off(wl);
 972
 973         memset(wl->bssid, 0, ETH_ALEN);
 974         memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
 975         wl->ssid_len = 0;
 976         wl->bss_type = MAX_BSS_TYPE;
 977         wl->set_bss_type = MAX_BSS_TYPE;
 978         wl->band = IEEE80211_BAND_2GHZ;
 979
 980         wl->rx_counter = 0;
 981         wl->psm_entry_retry = 0;
 982         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
 983         wl->tx_blocks_available = 0;
 984         wl->tx_results_count = 0;
 985         wl->tx_packets_count = 0;
 986         wl->tx_security_last_seq = 0;
 987         wl->tx_security_seq = 0;
 988         wl->time_offset = 0;
 989         wl->session_counter = 0;
 990         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
 991         wl->sta_rate_set = 0;
 992         wl->flags = 0;
 993         wl->vif = NULL;
 994         wl->filters = 0;
 995
 996         for (i = 0; i < NUM_TX_QUEUES; i++)
 997                 wl->tx_blocks_freed[i] = 0;
 998
 999         wl1271_debugfs_reset(wl);
1000
1001         kfree(wl->fw_status);
1002         wl->fw_status = NULL;
1003         kfree(wl->tx_res_if);
1004         wl->tx_res_if = NULL;
1005         kfree(wl->target_mem_map);
1006         wl->target_mem_map = NULL;
1007
1008         mutex_unlock(&wl->mutex);
1009 }
1010
1011 static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1012 {
1013         wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1014         wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1015
1016         /* combine requested filters with current filter config */
1017         filters = wl->filters | filters;
1018
1019         wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1020
1021         if (filters & FIF_PROMISC_IN_BSS) {
1022                 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1023                 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1024                 wl->rx_config |= CFG_BSSID_FILTER_EN;
1025         }
1026         if (filters & FIF_BCN_PRBRESP_PROMISC) {
1027                 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1028                 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1029                 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1030         }
1031         if (filters & FIF_OTHER_BSS) {
1032                 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1033                 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1034         }
1035         if (filters & FIF_CONTROL) {
1036                 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1037                 wl->rx_filter |= CFG_RX_CTL_EN;
1038         }
1039         if (filters & FIF_FCSFAIL) {
1040                 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1041                 wl->rx_filter |= CFG_RX_FCS_ERROR;
1042         }
1043 }
1044
1045 static int wl1271_dummy_join(struct wl1271 *wl)
1046 {
1047         int ret = 0;
1048         /* we need to use a dummy BSSID for now */
1049         static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1050                                                   0xad, 0xbe, 0xef };
1051
1052         memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1053
1054         /* pass through frames from all BSS */
1055         wl1271_configure_filters(wl, FIF_OTHER_BSS);
1056
1057         ret = wl1271_cmd_join(wl, wl->set_bss_type);
1058         if (ret < 0)
1059                 goto out;
1060
1061         set_bit(WL1271_FLAG_JOINED, &wl->flags);
1062
1063 out:
1064         return ret;
1065 }
1066
1067 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
1068 {
1069         int ret;
1070
1071         /*
1072          * One of the side effects of the JOIN command is that is clears
1073          * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1074          * to a WPA/WPA2 access point will therefore kill the data-path.
1075          * Currently there is no supported scenario for JOIN during
1076          * association - if it becomes a supported scenario, the WPA/WPA2 keys
1077          * must be handled somehow.
1078          *
1079          */
1080         if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1081                 wl1271_info("JOIN while associated.");
1082
1083         if (set_assoc)
1084                 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1085
1086         ret = wl1271_cmd_join(wl, wl->set_bss_type);
1087         if (ret < 0)
1088                 goto out;
1089
1090         set_bit(WL1271_FLAG_JOINED, &wl->flags);
1091
1092         if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1093                 goto out;
1094
1095         /*
1096          * The join command disable the keep-alive mode, shut down its process,
1097          * and also clear the template config, so we need to reset it all after
1098          * the join. The acx_aid starts the keep-alive process, and the order
1099          * of the commands below is relevant.
1100          */
1101         ret = wl1271_acx_keep_alive_mode(wl, true);
1102         if (ret < 0)
1103                 goto out;
1104
1105         ret = wl1271_acx_aid(wl, wl->aid);
1106         if (ret < 0)
1107                 goto out;
1108
1109         ret = wl1271_cmd_build_klv_null_data(wl);
1110         if (ret < 0)
1111                 goto out;
1112
1113         ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1114                                            ACX_KEEP_ALIVE_TPL_VALID);
1115         if (ret < 0)
1116                 goto out;
1117
1118 out:
1119         return ret;
1120 }
1121
1122 static int wl1271_unjoin(struct wl1271 *wl)
1123 {
1124         int ret;
1125
1126         /* to stop listening to a channel, we disconnect */
1127         ret = wl1271_cmd_disconnect(wl);
1128         if (ret < 0)
1129                 goto out;
1130
1131         clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1132         memset(wl->bssid, 0, ETH_ALEN);
1133
1134         /* stop filterting packets based on bssid */
1135         wl1271_configure_filters(wl, FIF_OTHER_BSS);
1136
1137 out:
1138         return ret;
1139 }
1140
1141 static void wl1271_set_band_rate(struct wl1271 *wl)
1142 {
1143         if (wl->band == IEEE80211_BAND_2GHZ)
1144                 wl->basic_rate_set = wl->conf.tx.basic_rate;
1145         else
1146                 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1147 }
1148
1149 static u32 wl1271_min_rate_get(struct wl1271 *wl)
1150 {
1151         int i;
1152         u32 rate = 0;
1153
1154         if (!wl->basic_rate_set) {
1155                 WARN_ON(1);
1156                 wl->basic_rate_set = wl->conf.tx.basic_rate;
1157         }
1158
1159         for (i = 0; !rate; i++) {
1160                 if ((wl->basic_rate_set >> i) & 0x1)
1161                         rate = 1 << i;
1162         }
1163
1164         return rate;
1165 }
1166
1167 static int wl1271_handle_idle(struct wl1271 *wl, bool idle)
1168 {
1169         int ret;
1170
1171         if (idle) {
1172                 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1173                         ret = wl1271_unjoin(wl);
1174                         if (ret < 0)
1175                                 goto out;
1176                 }
1177                 wl->rate_set = wl1271_min_rate_get(wl);
1178                 wl->sta_rate_set = 0;
1179                 ret = wl1271_acx_rate_policies(wl);
1180                 if (ret < 0)
1181                         goto out;
1182                 ret = wl1271_acx_keep_alive_config(
1183                         wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1184                         ACX_KEEP_ALIVE_TPL_INVALID);
1185                 if (ret < 0)
1186                         goto out;
1187                 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1188         } else {
1189                 /* increment the session counter */
1190                 wl->session_counter++;
1191                 if (wl->session_counter >= SESSION_COUNTER_MAX)
1192                         wl->session_counter = 0;
1193                 ret = wl1271_dummy_join(wl);
1194                 if (ret < 0)
1195                         goto out;
1196                 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1197         }
1198
1199 out:
1200         return ret;
1201 }
1202
1203 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1204 {
1205         struct wl1271 *wl = hw->priv;
1206         struct ieee80211_conf *conf = &hw->conf;
1207         int channel, ret = 0;
1208
1209         channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1210
1211         wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
1212                      channel,
1213                      conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1214                      conf->power_level,
1215                      conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
1216
1217         /*
1218          * mac80211 will go to idle nearly immediately after transmitting some
1219          * frames, such as the deauth. To make sure those frames reach the air,
1220          * wait here until the TX queue is fully flushed.
1221          */
1222         if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1223             (conf->flags & IEEE80211_CONF_IDLE))
1224                 wl1271_tx_flush(wl);
1225
1226         mutex_lock(&wl->mutex);
1227
1228         if (unlikely(wl->state == WL1271_STATE_OFF))
1229                 goto out;
1230
1231         ret = wl1271_ps_elp_wakeup(wl, false);
1232         if (ret < 0)
1233                 goto out;
1234
1235         /* if the channel changes while joined, join again */
1236         if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1237             ((wl->band != conf->channel->band) ||
1238              (wl->channel != channel))) {
1239                 wl->band = conf->channel->band;
1240                 wl->channel = channel;
1241
1242                 /*
1243                  * FIXME: the mac80211 should really provide a fixed rate
1244                  * to use here. for now, just use the smallest possible rate
1245                  * for the band as a fixed rate for association frames and
1246                  * other control messages.
1247                  */
1248                 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1249                         wl1271_set_band_rate(wl);
1250
1251                 wl->basic_rate = wl1271_min_rate_get(wl);
1252                 ret = wl1271_acx_rate_policies(wl);
1253                 if (ret < 0)
1254                         wl1271_warning("rate policy for update channel "
1255                                        "failed %d", ret);
1256
1257                 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1258                         ret = wl1271_join(wl, false);
1259                         if (ret < 0)
1260                                 wl1271_warning("cmd join to update channel "
1261                                                "failed %d", ret);
1262                 }
1263         }
1264
1265         if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1266                 ret = wl1271_handle_idle(wl, conf->flags & IEEE80211_CONF_IDLE);
1267                 if (ret < 0)
1268                         wl1271_warning("idle mode change failed %d", ret);
1269         }
1270
1271         /*
1272          * if mac80211 changes the PSM mode, make sure the mode is not
1273          * incorrectly changed after the pspoll failure active window.
1274          */
1275         if (changed & IEEE80211_CONF_CHANGE_PS)
1276                 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
1277
1278         if (conf->flags & IEEE80211_CONF_PS &&
1279             !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1280                 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1281
1282                 /*
1283                  * We enter PSM only if we're already associated.
1284                  * If we're not, we'll enter it when joining an SSID,
1285                  * through the bss_info_changed() hook.
1286                  */
1287                 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1288                         wl1271_debug(DEBUG_PSM, "psm enabled");
1289                         ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1290                                                  true);
1291                 }
1292         } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1293                    test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1294                 wl1271_debug(DEBUG_PSM, "psm disabled");
1295
1296                 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1297
1298                 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1299                         ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1300                                                  true);
1301         }
1302
1303         if (conf->power_level != wl->power_level) {
1304                 ret = wl1271_acx_tx_power(wl, conf->power_level);
1305                 if (ret < 0)
1306                         goto out_sleep;
1307
1308                 wl->power_level = conf->power_level;
1309         }
1310
1311 out_sleep:
1312         wl1271_ps_elp_sleep(wl);
1313
1314 out:
1315         mutex_unlock(&wl->mutex);
1316
1317         return ret;
1318 }
1319
1320 struct wl1271_filter_params {
1321         bool enabled;
1322         int mc_list_length;
1323         u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1324 };
1325
1326 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1327                                        struct netdev_hw_addr_list *mc_list)
1328 {
1329         struct wl1271_filter_params *fp;
1330         struct netdev_hw_addr *ha;
1331         struct wl1271 *wl = hw->priv;
1332
1333         if (unlikely(wl->state == WL1271_STATE_OFF))
1334                 return 0;
1335
1336         fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1337         if (!fp) {
1338                 wl1271_error("Out of memory setting filters.");
1339                 return 0;
1340         }
1341
1342         /* update multicast filtering parameters */
1343         fp->mc_list_length = 0;
1344         if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1345                 fp->enabled = false;
1346         } else {
1347                 fp->enabled = true;
1348                 netdev_hw_addr_list_for_each(ha, mc_list) {
1349                         memcpy(fp->mc_list[fp->mc_list_length],
1350                                         ha->addr, ETH_ALEN);
1351                         fp->mc_list_length++;
1352                 }
1353         }
1354
1355         return (u64)(unsigned long)fp;
1356 }
1357
1358 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1359                                   FIF_ALLMULTI | \
1360                                   FIF_FCSFAIL | \
1361                                   FIF_BCN_PRBRESP_PROMISC | \
1362                                   FIF_CONTROL | \
1363                                   FIF_OTHER_BSS)
1364
1365 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1366                                        unsigned int changed,
1367                                        unsigned int *total, u64 multicast)
1368 {
1369         struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1370         struct wl1271 *wl = hw->priv;
1371         int ret;
1372
1373         wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1374
1375         mutex_lock(&wl->mutex);
1376
1377         *total &= WL1271_SUPPORTED_FILTERS;
1378         changed &= WL1271_SUPPORTED_FILTERS;
1379
1380         if (unlikely(wl->state == WL1271_STATE_OFF))
1381                 goto out;
1382
1383         ret = wl1271_ps_elp_wakeup(wl, false);
1384         if (ret < 0)
1385                 goto out;
1386
1387
1388         if (*total & FIF_ALLMULTI)
1389                 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1390         else if (fp)
1391                 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1392                                                    fp->mc_list,
1393                                                    fp->mc_list_length);
1394         if (ret < 0)
1395                 goto out_sleep;
1396
1397         /* determine, whether supported filter values have changed */
1398         if (changed == 0)
1399                 goto out_sleep;
1400
1401         /* configure filters */
1402         wl->filters = *total;
1403         wl1271_configure_filters(wl, 0);
1404
1405         /* apply configured filters */
1406         ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1407         if (ret < 0)
1408                 goto out_sleep;
1409
1410 out_sleep:
1411         wl1271_ps_elp_sleep(wl);
1412
1413 out:
1414         mutex_unlock(&wl->mutex);
1415         kfree(fp);
1416 }
1417
1418 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1419                              struct ieee80211_vif *vif,
1420                              struct ieee80211_sta *sta,
1421                              struct ieee80211_key_conf *key_conf)
1422 {
1423         struct wl1271 *wl = hw->priv;
1424         const u8 *addr;
1425         int ret;
1426         u32 tx_seq_32 = 0;
1427         u16 tx_seq_16 = 0;
1428         u8 key_type;
1429
1430         static const u8 bcast_addr[ETH_ALEN] =
1431                 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1432
1433         wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1434
1435         addr = sta ? sta->addr : bcast_addr;
1436
1437         wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1438         wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1439         wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1440                      key_conf->cipher, key_conf->keyidx,
1441                      key_conf->keylen, key_conf->flags);
1442         wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1443
1444         if (is_zero_ether_addr(addr)) {
1445                 /* We dont support TX only encryption */
1446                 ret = -EOPNOTSUPP;
1447                 goto out;
1448         }
1449
1450         mutex_lock(&wl->mutex);
1451
1452         ret = wl1271_ps_elp_wakeup(wl, false);
1453         if (ret < 0)
1454                 goto out_unlock;
1455
1456         switch (key_conf->cipher) {
1457         case WLAN_CIPHER_SUITE_WEP40:
1458         case WLAN_CIPHER_SUITE_WEP104:
1459                 key_type = KEY_WEP;
1460
1461                 key_conf->hw_key_idx = key_conf->keyidx;
1462                 break;
1463         case WLAN_CIPHER_SUITE_TKIP:
1464                 key_type = KEY_TKIP;
1465
1466                 key_conf->hw_key_idx = key_conf->keyidx;
1467                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1468                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1469                 break;
1470         case WLAN_CIPHER_SUITE_CCMP:
1471                 key_type = KEY_AES;
1472
1473                 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1474                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1475                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1476                 break;
1477         default:
1478                 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
1479
1480                 ret = -EOPNOTSUPP;
1481                 goto out_sleep;
1482         }
1483
1484         switch (cmd) {
1485         case SET_KEY:
1486                 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1487                                          key_conf->keyidx, key_type,
1488                                          key_conf->keylen, key_conf->key,
1489                                          addr, tx_seq_32, tx_seq_16);
1490                 if (ret < 0) {
1491                         wl1271_error("Could not add or replace key");
1492                         goto out_sleep;
1493                 }
1494
1495                 /* the default WEP key needs to be configured at least once */
1496                 if (key_type == KEY_WEP) {
1497                         ret = wl1271_cmd_set_default_wep_key(wl,
1498                                                              wl->default_key);
1499                         if (ret < 0)
1500                                 goto out_sleep;
1501                 }
1502                 break;
1503
1504         case DISABLE_KEY:
1505                 /* The wl1271 does not allow to remove unicast keys - they
1506                    will be cleared automatically on next CMD_JOIN. Ignore the
1507                    request silently, as we dont want the mac80211 to emit
1508                    an error message. */
1509                 if (!is_broadcast_ether_addr(addr))
1510                         break;
1511
1512                 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1513                                          key_conf->keyidx, key_type,
1514                                          key_conf->keylen, key_conf->key,
1515                                          addr, 0, 0);
1516                 if (ret < 0) {
1517                         wl1271_error("Could not remove key");
1518                         goto out_sleep;
1519                 }
1520                 break;
1521
1522         default:
1523                 wl1271_error("Unsupported key cmd 0x%x", cmd);
1524                 ret = -EOPNOTSUPP;
1525                 break;
1526         }
1527
1528 out_sleep:
1529         wl1271_ps_elp_sleep(wl);
1530
1531 out_unlock:
1532         mutex_unlock(&wl->mutex);
1533
1534 out:
1535         return ret;
1536 }
1537
1538 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1539                              struct ieee80211_vif *vif,
1540                              struct cfg80211_scan_request *req)
1541 {
1542         struct wl1271 *wl = hw->priv;
1543         int ret;
1544         u8 *ssid = NULL;
1545         size_t len = 0;
1546
1547         wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1548
1549         if (req->n_ssids) {
1550                 ssid = req->ssids[0].ssid;
1551                 len = req->ssids[0].ssid_len;
1552         }
1553
1554         mutex_lock(&wl->mutex);
1555
1556         ret = wl1271_ps_elp_wakeup(wl, false);
1557         if (ret < 0)
1558                 goto out;
1559
1560         if (wl1271_11a_enabled())
1561                 ret = wl1271_scan(hw->priv, ssid, len, req);
1562         else
1563                 ret = wl1271_scan(hw->priv, ssid, len, req);
1564
1565         wl1271_ps_elp_sleep(wl);
1566
1567 out:
1568         mutex_unlock(&wl->mutex);
1569
1570         return ret;
1571 }
1572
1573 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1574 {
1575         struct wl1271 *wl = hw->priv;
1576         int ret = 0;
1577
1578         mutex_lock(&wl->mutex);
1579
1580         if (unlikely(wl->state == WL1271_STATE_OFF))
1581                 goto out;
1582
1583         ret = wl1271_ps_elp_wakeup(wl, false);
1584         if (ret < 0)
1585                 goto out;
1586
1587         ret = wl1271_acx_rts_threshold(wl, (u16) value);
1588         if (ret < 0)
1589                 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1590
1591         wl1271_ps_elp_sleep(wl);
1592
1593 out:
1594         mutex_unlock(&wl->mutex);
1595
1596         return ret;
1597 }
1598
1599 static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1600 {
1601         u8 *ptr = beacon->data +
1602                 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1603
1604         /* find the location of the ssid in the beacon */
1605         while (ptr < beacon->data + beacon->len) {
1606                 if (ptr[0] == WLAN_EID_SSID) {
1607                         wl->ssid_len = ptr[1];
1608                         memcpy(wl->ssid, ptr+2, wl->ssid_len);
1609                         return;
1610                 }
1611                 ptr += ptr[1];
1612         }
1613         wl1271_error("ad-hoc beacon template has no SSID!\n");
1614 }
1615
1616 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1617                                        struct ieee80211_vif *vif,
1618                                        struct ieee80211_bss_conf *bss_conf,
1619                                        u32 changed)
1620 {
1621         enum wl1271_cmd_ps_mode mode;
1622         struct wl1271 *wl = hw->priv;
1623         bool do_join = false;
1624         bool set_assoc = false;
1625         int ret;
1626
1627         wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1628
1629         mutex_lock(&wl->mutex);
1630
1631         ret = wl1271_ps_elp_wakeup(wl, false);
1632         if (ret < 0)
1633                 goto out;
1634
1635         if ((changed && BSS_CHANGED_BEACON_INT) &&
1636             (wl->bss_type == BSS_TYPE_IBSS)) {
1637                 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
1638                         bss_conf->beacon_int);
1639
1640                 wl->beacon_int = bss_conf->beacon_int;
1641                 do_join = true;
1642         }
1643
1644         if ((changed && BSS_CHANGED_BEACON) &&
1645             (wl->bss_type == BSS_TYPE_IBSS)) {
1646                 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1647
1648                 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
1649
1650                 if (beacon) {
1651                         struct ieee80211_hdr *hdr;
1652
1653                         wl1271_ssid_set(wl, beacon);
1654                         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1655                                                       beacon->data,
1656                                                       beacon->len, 0,
1657                                                       wl1271_min_rate_get(wl));
1658
1659                         if (ret < 0) {
1660                                 dev_kfree_skb(beacon);
1661                                 goto out_sleep;
1662                         }
1663
1664                         hdr = (struct ieee80211_hdr *) beacon->data;
1665                         hdr->frame_control = cpu_to_le16(
1666                                 IEEE80211_FTYPE_MGMT |
1667                                 IEEE80211_STYPE_PROBE_RESP);
1668
1669                         ret = wl1271_cmd_template_set(wl,
1670                                                       CMD_TEMPL_PROBE_RESPONSE,
1671                                                       beacon->data,
1672                                                       beacon->len, 0,
1673                                                       wl1271_min_rate_get(wl));
1674                         dev_kfree_skb(beacon);
1675                         if (ret < 0)
1676                                 goto out_sleep;
1677
1678                         /* Need to update the SSID (for filtering etc) */
1679                         do_join = true;
1680                 }
1681         }
1682
1683         if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1684             (wl->bss_type == BSS_TYPE_IBSS)) {
1685                 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1686                              bss_conf->enable_beacon ? "enabled" : "disabled");
1687
1688                 if (bss_conf->enable_beacon)
1689                         wl->set_bss_type = BSS_TYPE_IBSS;
1690                 else
1691                         wl->set_bss_type = BSS_TYPE_STA_BSS;
1692                 do_join = true;
1693         }
1694
1695         if (changed & BSS_CHANGED_CQM) {
1696                 bool enable = false;
1697                 if (bss_conf->cqm_rssi_thold)
1698                         enable = true;
1699                 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
1700                                                   bss_conf->cqm_rssi_thold,
1701                                                   bss_conf->cqm_rssi_hyst);
1702                 if (ret < 0)
1703                         goto out;
1704                 wl->rssi_thold = bss_conf->cqm_rssi_thold;
1705         }
1706
1707         if ((changed & BSS_CHANGED_BSSID) &&
1708             /*
1709              * Now we know the correct bssid, so we send a new join command
1710              * and enable the BSSID filter
1711              */
1712             memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1713                         memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1714
1715                         ret = wl1271_cmd_build_null_data(wl);
1716                         if (ret < 0)
1717                                 goto out_sleep;
1718
1719                         ret = wl1271_build_qos_null_data(wl);
1720                         if (ret < 0)
1721                                 goto out_sleep;
1722
1723                         /* filter out all packets not from this BSSID */
1724                         wl1271_configure_filters(wl, 0);
1725
1726                         /* Need to update the BSSID (for filtering etc) */
1727                         do_join = true;
1728         }
1729
1730         if (changed & BSS_CHANGED_ASSOC) {
1731                 if (bss_conf->assoc) {
1732                         u32 rates;
1733                         wl->aid = bss_conf->aid;
1734                         set_assoc = true;
1735
1736                         wl->ps_poll_failures = 0;
1737
1738                         /*
1739                          * use basic rates from AP, and determine lowest rate
1740                          * to use with control frames.
1741                          */
1742                         rates = bss_conf->basic_rates;
1743                         wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1744                                                                          rates);
1745                         wl->basic_rate = wl1271_min_rate_get(wl);
1746                         ret = wl1271_acx_rate_policies(wl);
1747                         if (ret < 0)
1748                                 goto out_sleep;
1749
1750                         /*
1751                          * with wl1271, we don't need to update the
1752                          * beacon_int and dtim_period, because the firmware
1753                          * updates it by itself when the first beacon is
1754                          * received after a join.
1755                          */
1756                         ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1757                         if (ret < 0)
1758                                 goto out_sleep;
1759
1760                         /*
1761                          * The SSID is intentionally set to NULL here - the
1762                          * firmware will set the probe request with a
1763                          * broadcast SSID regardless of what we set in the
1764                          * template.
1765                          */
1766                         ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1767                                                          NULL, 0, wl->band);
1768
1769                         /* enable the connection monitoring feature */
1770                         ret = wl1271_acx_conn_monit_params(wl, true);
1771                         if (ret < 0)
1772                                 goto out_sleep;
1773
1774                         /* If we want to go in PSM but we're not there yet */
1775                         if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1776                             !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1777                                 mode = STATION_POWER_SAVE_MODE;
1778                                 ret = wl1271_ps_set_mode(wl, mode, true);
1779                                 if (ret < 0)
1780                                         goto out_sleep;
1781                         }
1782                 } else {
1783                         /* use defaults when not associated */
1784                         clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1785                         wl->aid = 0;
1786
1787                         /* re-enable dynamic ps - just in case */
1788                         ieee80211_enable_dyn_ps(wl->vif);
1789
1790                         /* revert back to minimum rates for the current band */
1791                         wl1271_set_band_rate(wl);
1792                         wl->basic_rate = wl1271_min_rate_get(wl);
1793                         ret = wl1271_acx_rate_policies(wl);
1794                         if (ret < 0)
1795                                 goto out_sleep;
1796
1797                         /* disable connection monitor features */
1798                         ret = wl1271_acx_conn_monit_params(wl, false);
1799
1800                         /* Disable the keep-alive feature */
1801                         ret = wl1271_acx_keep_alive_mode(wl, false);
1802
1803                         if (ret < 0)
1804                                 goto out_sleep;
1805                 }
1806
1807         }
1808
1809         if (changed & BSS_CHANGED_ERP_SLOT) {
1810                 if (bss_conf->use_short_slot)
1811                         ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1812                 else
1813                         ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1814                 if (ret < 0) {
1815                         wl1271_warning("Set slot time failed %d", ret);
1816                         goto out_sleep;
1817                 }
1818         }
1819
1820         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1821                 if (bss_conf->use_short_preamble)
1822                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1823                 else
1824                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1825         }
1826
1827         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1828                 if (bss_conf->use_cts_prot)
1829                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1830                 else
1831                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1832                 if (ret < 0) {
1833                         wl1271_warning("Set ctsprotect failed %d", ret);
1834                         goto out_sleep;
1835                 }
1836         }
1837
1838         if (changed & BSS_CHANGED_ARP_FILTER) {
1839                 __be32 addr = bss_conf->arp_addr_list[0];
1840                 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
1841
1842                 if (bss_conf->arp_addr_cnt == 1 && bss_conf->arp_filter_enabled)
1843                         ret = wl1271_acx_arp_ip_filter(wl, true, addr);
1844                 else
1845                         ret = wl1271_acx_arp_ip_filter(wl, false, addr);
1846
1847                 if (ret < 0)
1848                         goto out_sleep;
1849         }
1850
1851         if (do_join) {
1852                 ret = wl1271_join(wl, set_assoc);
1853                 if (ret < 0) {
1854                         wl1271_warning("cmd join failed %d", ret);
1855                         goto out_sleep;
1856                 }
1857         }
1858
1859 out_sleep:
1860         wl1271_ps_elp_sleep(wl);
1861
1862 out:
1863         mutex_unlock(&wl->mutex);
1864 }
1865
1866 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1867                              const struct ieee80211_tx_queue_params *params)
1868 {
1869         struct wl1271 *wl = hw->priv;
1870         u8 ps_scheme;
1871         int ret;
1872
1873         mutex_lock(&wl->mutex);
1874
1875         wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1876
1877         ret = wl1271_ps_elp_wakeup(wl, false);
1878         if (ret < 0)
1879                 goto out;
1880
1881         /* the txop is confed in units of 32us by the mac80211, we need us */
1882         ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1883                                 params->cw_min, params->cw_max,
1884                                 params->aifs, params->txop << 5);
1885         if (ret < 0)
1886                 goto out_sleep;
1887
1888         if (params->uapsd)
1889                 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
1890         else
1891                 ps_scheme = CONF_PS_SCHEME_LEGACY;
1892
1893         ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1894                                  CONF_CHANNEL_TYPE_EDCF,
1895                                  wl1271_tx_get_queue(queue),
1896                                  ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
1897         if (ret < 0)
1898                 goto out_sleep;
1899
1900 out_sleep:
1901         wl1271_ps_elp_sleep(wl);
1902
1903 out:
1904         mutex_unlock(&wl->mutex);
1905
1906         return ret;
1907 }
1908
1909 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
1910 {
1911
1912         struct wl1271 *wl = hw->priv;
1913         u64 mactime = ULLONG_MAX;
1914         int ret;
1915
1916         wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
1917
1918         mutex_lock(&wl->mutex);
1919
1920         ret = wl1271_ps_elp_wakeup(wl, false);
1921         if (ret < 0)
1922                 goto out;
1923
1924         ret = wl1271_acx_tsf_info(wl, &mactime);
1925         if (ret < 0)
1926                 goto out_sleep;
1927
1928 out_sleep:
1929         wl1271_ps_elp_sleep(wl);
1930
1931 out:
1932         mutex_unlock(&wl->mutex);
1933         return mactime;
1934 }
1935
1936 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
1937                                 struct survey_info *survey)
1938 {
1939         struct wl1271 *wl = hw->priv;
1940         struct ieee80211_conf *conf = &hw->conf;
1941
1942         if (idx != 0)
1943                 return -ENOENT;
1944
1945         survey->channel = conf->channel;
1946         survey->filled = SURVEY_INFO_NOISE_DBM;
1947         survey->noise = wl->noise;
1948
1949         return 0;
1950 }
1951
1952 /* can't be const, mac80211 writes to this */
1953 static struct ieee80211_rate wl1271_rates[] = {
1954         { .bitrate = 10,
1955           .hw_value = CONF_HW_BIT_RATE_1MBPS,
1956           .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
1957         { .bitrate = 20,
1958           .hw_value = CONF_HW_BIT_RATE_2MBPS,
1959           .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
1960           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1961         { .bitrate = 55,
1962           .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1963           .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
1964           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1965         { .bitrate = 110,
1966           .hw_value = CONF_HW_BIT_RATE_11MBPS,
1967           .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
1968           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1969         { .bitrate = 60,
1970           .hw_value = CONF_HW_BIT_RATE_6MBPS,
1971           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1972         { .bitrate = 90,
1973           .hw_value = CONF_HW_BIT_RATE_9MBPS,
1974           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1975         { .bitrate = 120,
1976           .hw_value = CONF_HW_BIT_RATE_12MBPS,
1977           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1978         { .bitrate = 180,
1979           .hw_value = CONF_HW_BIT_RATE_18MBPS,
1980           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1981         { .bitrate = 240,
1982           .hw_value = CONF_HW_BIT_RATE_24MBPS,
1983           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1984         { .bitrate = 360,
1985          .hw_value = CONF_HW_BIT_RATE_36MBPS,
1986          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1987         { .bitrate = 480,
1988           .hw_value = CONF_HW_BIT_RATE_48MBPS,
1989           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1990         { .bitrate = 540,
1991           .hw_value = CONF_HW_BIT_RATE_54MBPS,
1992           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1993 };
1994
1995 /* can't be const, mac80211 writes to this */
1996 static struct ieee80211_channel wl1271_channels[] = {
1997         { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
1998         { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
1999         { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
2000         { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
2001         { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
2002         { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
2003         { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
2004         { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
2005         { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
2006         { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
2007         { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
2008         { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
2009         { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
2010 };
2011
2012 /* mapping to indexes for wl1271_rates */
2013 static const u8 wl1271_rate_to_idx_2ghz[] = {
2014         /* MCS rates are used only with 11n */
2015         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2016         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2017         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2018         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2019         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2020         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2021         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2022         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2023
2024         11,                            /* CONF_HW_RXTX_RATE_54   */
2025         10,                            /* CONF_HW_RXTX_RATE_48   */
2026         9,                             /* CONF_HW_RXTX_RATE_36   */
2027         8,                             /* CONF_HW_RXTX_RATE_24   */
2028
2029         /* TI-specific rate */
2030         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
2031
2032         7,                             /* CONF_HW_RXTX_RATE_18   */
2033         6,                             /* CONF_HW_RXTX_RATE_12   */
2034         3,                             /* CONF_HW_RXTX_RATE_11   */
2035         5,                             /* CONF_HW_RXTX_RATE_9    */
2036         4,                             /* CONF_HW_RXTX_RATE_6    */
2037         2,                             /* CONF_HW_RXTX_RATE_5_5  */
2038         1,                             /* CONF_HW_RXTX_RATE_2    */
2039         0                              /* CONF_HW_RXTX_RATE_1    */
2040 };
2041
2042 /* can't be const, mac80211 writes to this */
2043 static struct ieee80211_supported_band wl1271_band_2ghz = {
2044         .channels = wl1271_channels,
2045         .n_channels = ARRAY_SIZE(wl1271_channels),
2046         .bitrates = wl1271_rates,
2047         .n_bitrates = ARRAY_SIZE(wl1271_rates),
2048 };
2049
2050 /* 5 GHz data rates for WL1273 */
2051 static struct ieee80211_rate wl1271_rates_5ghz[] = {
2052         { .bitrate = 60,
2053           .hw_value = CONF_HW_BIT_RATE_6MBPS,
2054           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2055         { .bitrate = 90,
2056           .hw_value = CONF_HW_BIT_RATE_9MBPS,
2057           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2058         { .bitrate = 120,
2059           .hw_value = CONF_HW_BIT_RATE_12MBPS,
2060           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2061         { .bitrate = 180,
2062           .hw_value = CONF_HW_BIT_RATE_18MBPS,
2063           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2064         { .bitrate = 240,
2065           .hw_value = CONF_HW_BIT_RATE_24MBPS,
2066           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2067         { .bitrate = 360,
2068          .hw_value = CONF_HW_BIT_RATE_36MBPS,
2069          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2070         { .bitrate = 480,
2071           .hw_value = CONF_HW_BIT_RATE_48MBPS,
2072           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2073         { .bitrate = 540,
2074           .hw_value = CONF_HW_BIT_RATE_54MBPS,
2075           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2076 };
2077
2078 /* 5 GHz band channels for WL1273 */
2079 static struct ieee80211_channel wl1271_channels_5ghz[] = {
2080         { .hw_value = 183, .center_freq = 4915},
2081         { .hw_value = 184, .center_freq = 4920},
2082         { .hw_value = 185, .center_freq = 4925},
2083         { .hw_value = 187, .center_freq = 4935},
2084         { .hw_value = 188, .center_freq = 4940},
2085         { .hw_value = 189, .center_freq = 4945},
2086         { .hw_value = 192, .center_freq = 4960},
2087         { .hw_value = 196, .center_freq = 4980},
2088         { .hw_value = 7, .center_freq = 5035},
2089         { .hw_value = 8, .center_freq = 5040},
2090         { .hw_value = 9, .center_freq = 5045},
2091         { .hw_value = 11, .center_freq = 5055},
2092         { .hw_value = 12, .center_freq = 5060},
2093         { .hw_value = 16, .center_freq = 5080},
2094         { .hw_value = 34, .center_freq = 5170},
2095         { .hw_value = 36, .center_freq = 5180},
2096         { .hw_value = 38, .center_freq = 5190},
2097         { .hw_value = 40, .center_freq = 5200},
2098         { .hw_value = 42, .center_freq = 5210},
2099         { .hw_value = 44, .center_freq = 5220},
2100         { .hw_value = 46, .center_freq = 5230},
2101         { .hw_value = 48, .center_freq = 5240},
2102         { .hw_value = 52, .center_freq = 5260},
2103         { .hw_value = 56, .center_freq = 5280},
2104         { .hw_value = 60, .center_freq = 5300},
2105         { .hw_value = 64, .center_freq = 5320},
2106         { .hw_value = 100, .center_freq = 5500},
2107         { .hw_value = 104, .center_freq = 5520},
2108         { .hw_value = 108, .center_freq = 5540},
2109         { .hw_value = 112, .center_freq = 5560},
2110         { .hw_value = 116, .center_freq = 5580},
2111         { .hw_value = 120, .center_freq = 5600},
2112         { .hw_value = 124, .center_freq = 5620},
2113         { .hw_value = 128, .center_freq = 5640},
2114         { .hw_value = 132, .center_freq = 5660},
2115         { .hw_value = 136, .center_freq = 5680},
2116         { .hw_value = 140, .center_freq = 5700},
2117         { .hw_value = 149, .center_freq = 5745},
2118         { .hw_value = 153, .center_freq = 5765},
2119         { .hw_value = 157, .center_freq = 5785},
2120         { .hw_value = 161, .center_freq = 5805},
2121         { .hw_value = 165, .center_freq = 5825},
2122 };
2123
2124 /* mapping to indexes for wl1271_rates_5ghz */
2125 static const u8 wl1271_rate_to_idx_5ghz[] = {
2126         /* MCS rates are used only with 11n */
2127         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2128         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2129         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2130         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2131         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2132         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2133         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2134         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2135
2136         7,                             /* CONF_HW_RXTX_RATE_54   */
2137         6,                             /* CONF_HW_RXTX_RATE_48   */
2138         5,                             /* CONF_HW_RXTX_RATE_36   */
2139         4,                             /* CONF_HW_RXTX_RATE_24   */
2140
2141         /* TI-specific rate */
2142         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
2143
2144         3,                             /* CONF_HW_RXTX_RATE_18   */
2145         2,                             /* CONF_HW_RXTX_RATE_12   */
2146         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11   */
2147         1,                             /* CONF_HW_RXTX_RATE_9    */
2148         0,                             /* CONF_HW_RXTX_RATE_6    */
2149         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5  */
2150         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2    */
2151         CONF_HW_RXTX_RATE_UNSUPPORTED  /* CONF_HW_RXTX_RATE_1    */
2152 };
2153
2154 static struct ieee80211_supported_band wl1271_band_5ghz = {
2155         .channels = wl1271_channels_5ghz,
2156         .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2157         .bitrates = wl1271_rates_5ghz,
2158         .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
2159 };
2160
2161 static const u8 *wl1271_band_rate_to_idx[] = {
2162         [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2163         [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2164 };
2165
2166 static const struct ieee80211_ops wl1271_ops = {
2167         .start = wl1271_op_start,
2168         .stop = wl1271_op_stop,
2169         .add_interface = wl1271_op_add_interface,
2170         .remove_interface = wl1271_op_remove_interface,
2171         .config = wl1271_op_config,
2172         .prepare_multicast = wl1271_op_prepare_multicast,
2173         .configure_filter = wl1271_op_configure_filter,
2174         .tx = wl1271_op_tx,
2175         .set_key = wl1271_op_set_key,
2176         .hw_scan = wl1271_op_hw_scan,
2177         .bss_info_changed = wl1271_op_bss_info_changed,
2178         .set_rts_threshold = wl1271_op_set_rts_threshold,
2179         .conf_tx = wl1271_op_conf_tx,
2180         .get_tsf = wl1271_op_get_tsf,
2181         .get_survey = wl1271_op_get_survey,
2182         CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
2183 };
2184
2185
2186 u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate)
2187 {
2188         u8 idx;
2189
2190         BUG_ON(wl->band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
2191
2192         if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2193                 wl1271_error("Illegal RX rate from HW: %d", rate);
2194                 return 0;
2195         }
2196
2197         idx = wl1271_band_rate_to_idx[wl->band][rate];
2198         if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2199                 wl1271_error("Unsupported RX rate from HW: %d", rate);
2200                 return 0;
2201         }
2202
2203         return idx;
2204 }
2205
2206 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2207                                                struct device_attribute *attr,
2208                                                char *buf)
2209 {
2210         struct wl1271 *wl = dev_get_drvdata(dev);
2211         ssize_t len;
2212
2213         /* FIXME: what's the maximum length of buf? page size?*/
2214         len = 500;
2215
2216         mutex_lock(&wl->mutex);
2217         len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2218                        wl->sg_enabled);
2219         mutex_unlock(&wl->mutex);
2220
2221         return len;
2222
2223 }
2224
2225 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2226                                                 struct device_attribute *attr,
2227                                                 const char *buf, size_t count)
2228 {
2229         struct wl1271 *wl = dev_get_drvdata(dev);
2230         unsigned long res;
2231         int ret;
2232
2233         ret = strict_strtoul(buf, 10, &res);
2234
2235         if (ret < 0) {
2236                 wl1271_warning("incorrect value written to bt_coex_mode");
2237                 return count;
2238         }
2239
2240         mutex_lock(&wl->mutex);
2241
2242         res = !!res;
2243
2244         if (res == wl->sg_enabled)
2245                 goto out;
2246
2247         wl->sg_enabled = res;
2248
2249         if (wl->state == WL1271_STATE_OFF)
2250                 goto out;
2251
2252         ret = wl1271_ps_elp_wakeup(wl, false);
2253         if (ret < 0)
2254                 goto out;
2255
2256         wl1271_acx_sg_enable(wl, wl->sg_enabled);
2257         wl1271_ps_elp_sleep(wl);
2258
2259  out:
2260         mutex_unlock(&wl->mutex);
2261         return count;
2262 }
2263
2264 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2265                    wl1271_sysfs_show_bt_coex_state,
2266                    wl1271_sysfs_store_bt_coex_state);
2267
2268 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
2269                                            struct device_attribute *attr,
2270                                            char *buf)
2271 {
2272         struct wl1271 *wl = dev_get_drvdata(dev);
2273         ssize_t len;
2274
2275         /* FIXME: what's the maximum length of buf? page size?*/
2276         len = 500;
2277
2278         mutex_lock(&wl->mutex);
2279         if (wl->hw_pg_ver >= 0)
2280                 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
2281         else
2282                 len = snprintf(buf, len, "n/a\n");
2283         mutex_unlock(&wl->mutex);
2284
2285         return len;
2286 }
2287
2288 static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
2289                    wl1271_sysfs_show_hw_pg_ver, NULL);
2290
2291 int wl1271_register_hw(struct wl1271 *wl)
2292 {
2293         int ret;
2294
2295         if (wl->mac80211_registered)
2296                 return 0;
2297
2298         SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2299
2300         ret = ieee80211_register_hw(wl->hw);
2301         if (ret < 0) {
2302                 wl1271_error("unable to register mac80211 hw: %d", ret);
2303                 return ret;
2304         }
2305
2306         wl->mac80211_registered = true;
2307
2308         wl1271_notice("loaded");
2309
2310         return 0;
2311 }
2312 EXPORT_SYMBOL_GPL(wl1271_register_hw);
2313
2314 void wl1271_unregister_hw(struct wl1271 *wl)
2315 {
2316         ieee80211_unregister_hw(wl->hw);
2317         wl->mac80211_registered = false;
2318
2319 }
2320 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2321
2322 int wl1271_init_ieee80211(struct wl1271 *wl)
2323 {
2324         /* The tx descriptor buffer and the TKIP space. */
2325         wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2326                 sizeof(struct wl1271_tx_hw_descr);
2327
2328         /* unit us */
2329         /* FIXME: find a proper value */
2330         wl->hw->channel_change_time = 10000;
2331         wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
2332
2333         wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
2334                 IEEE80211_HW_BEACON_FILTER |
2335                 IEEE80211_HW_SUPPORTS_PS |
2336                 IEEE80211_HW_SUPPORTS_UAPSD |
2337                 IEEE80211_HW_HAS_RATE_CONTROL |
2338                 IEEE80211_HW_CONNECTION_MONITOR |
2339                 IEEE80211_HW_SUPPORTS_CQM_RSSI;
2340
2341         wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2342                 BIT(NL80211_IFTYPE_ADHOC);
2343         wl->hw->wiphy->max_scan_ssids = 1;
2344         wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2345
2346         if (wl1271_11a_enabled())
2347                 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2348
2349         wl->hw->queues = 4;
2350         wl->hw->max_rates = 1;
2351
2352         SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
2353
2354         return 0;
2355 }
2356 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
2357
2358 #define WL1271_DEFAULT_CHANNEL 0
2359
2360 struct ieee80211_hw *wl1271_alloc_hw(void)
2361 {
2362         struct ieee80211_hw *hw;
2363         struct platform_device *plat_dev = NULL;
2364         struct wl1271 *wl;
2365         int i, ret;
2366
2367         hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2368         if (!hw) {
2369                 wl1271_error("could not alloc ieee80211_hw");
2370                 ret = -ENOMEM;
2371                 goto err_hw_alloc;
2372         }
2373
2374         plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
2375         if (!plat_dev) {
2376                 wl1271_error("could not allocate platform_device");
2377                 ret = -ENOMEM;
2378                 goto err_plat_alloc;
2379         }
2380
2381         wl = hw->priv;
2382         memset(wl, 0, sizeof(*wl));
2383
2384         INIT_LIST_HEAD(&wl->list);
2385
2386         wl->hw = hw;
2387         wl->plat_dev = plat_dev;
2388
2389         skb_queue_head_init(&wl->tx_queue);
2390
2391         INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
2392         INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
2393         wl->channel = WL1271_DEFAULT_CHANNEL;
2394         wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
2395         wl->default_key = 0;
2396         wl->rx_counter = 0;
2397         wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2398         wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
2399         wl->psm_entry_retry = 0;
2400         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2401         wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2402         wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
2403         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2404         wl->sta_rate_set = 0;
2405         wl->band = IEEE80211_BAND_2GHZ;
2406         wl->vif = NULL;
2407         wl->flags = 0;
2408         wl->sg_enabled = true;
2409         wl->hw_pg_ver = -1;
2410
2411         for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
2412                 wl->tx_frames[i] = NULL;
2413
2414         spin_lock_init(&wl->wl_lock);
2415
2416         wl->state = WL1271_STATE_OFF;
2417         mutex_init(&wl->mutex);
2418
2419         /* Apply default driver configuration. */
2420         wl1271_conf_init(wl);
2421
2422         wl1271_debugfs_init(wl);
2423
2424         /* Register platform device */
2425         ret = platform_device_register(wl->plat_dev);
2426         if (ret) {
2427                 wl1271_error("couldn't register platform device");
2428                 goto err_hw;
2429         }
2430         dev_set_drvdata(&wl->plat_dev->dev, wl);
2431
2432         /* Create sysfs file to control bt coex state */
2433         ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2434         if (ret < 0) {
2435                 wl1271_error("failed to create sysfs file bt_coex_state");
2436                 goto err_platform;
2437         }
2438
2439         /* Create sysfs file to get HW PG version */
2440         ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
2441         if (ret < 0) {
2442                 wl1271_error("failed to create sysfs file hw_pg_ver");
2443                 goto err_bt_coex_state;
2444         }
2445
2446         return hw;
2447
2448 err_bt_coex_state:
2449         device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2450
2451 err_platform:
2452         platform_device_unregister(wl->plat_dev);
2453
2454 err_hw:
2455         wl1271_debugfs_exit(wl);
2456         kfree(plat_dev);
2457
2458 err_plat_alloc:
2459         ieee80211_free_hw(hw);
2460
2461 err_hw_alloc:
2462
2463         return ERR_PTR(ret);
2464 }
2465 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
2466
2467 int wl1271_free_hw(struct wl1271 *wl)
2468 {
2469         platform_device_unregister(wl->plat_dev);
2470         kfree(wl->plat_dev);
2471
2472         wl1271_debugfs_exit(wl);
2473
2474         vfree(wl->fw);
2475         wl->fw = NULL;
2476         kfree(wl->nvs);
2477         wl->nvs = NULL;
2478
2479         kfree(wl->fw_status);
2480         kfree(wl->tx_res_if);
2481
2482         ieee80211_free_hw(wl->hw);
2483
2484         return 0;
2485 }
2486 EXPORT_SYMBOL_GPL(wl1271_free_hw);
2487
2488 MODULE_LICENSE("GPL");
2489 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2490 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");