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                 mutex_unlock(&wl->mutex);
 952                 ieee80211_scan_completed(wl->hw, true);
 953                 mutex_lock(&wl->mutex);
 954                 wl->scan.state = WL1271_SCAN_STATE_IDLE;
 955                 kfree(wl->scan.scanned_ch);
 956                 wl->scan.scanned_ch = NULL;
 957         }
 958
 959         wl->state = WL1271_STATE_OFF;
 960
 961         wl1271_disable_interrupts(wl);
 962
 963         mutex_unlock(&wl->mutex);
 964
 965         cancel_work_sync(&wl->irq_work);
 966         cancel_work_sync(&wl->tx_work);
 967         cancel_delayed_work_sync(&wl->pspoll_work);
 968
 969         mutex_lock(&wl->mutex);
 970
 971         /* let's notify MAC80211 about the remaining pending TX frames */
 972         wl1271_tx_reset(wl);
 973         wl1271_power_off(wl);
 974
 975         memset(wl->bssid, 0, ETH_ALEN);
 976         memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
 977         wl->ssid_len = 0;
 978         wl->bss_type = MAX_BSS_TYPE;
 979         wl->set_bss_type = MAX_BSS_TYPE;
 980         wl->band = IEEE80211_BAND_2GHZ;
 981
 982         wl->rx_counter = 0;
 983         wl->psm_entry_retry = 0;
 984         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
 985         wl->tx_blocks_available = 0;
 986         wl->tx_results_count = 0;
 987         wl->tx_packets_count = 0;
 988         wl->tx_security_last_seq = 0;
 989         wl->tx_security_seq = 0;
 990         wl->time_offset = 0;
 991         wl->session_counter = 0;
 992         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
 993         wl->sta_rate_set = 0;
 994         wl->flags = 0;
 995         wl->vif = NULL;
 996         wl->filters = 0;
 997
 998         for (i = 0; i < NUM_TX_QUEUES; i++)
 999                 wl->tx_blocks_freed[i] = 0;
1000
1001         wl1271_debugfs_reset(wl);
1002
1003         kfree(wl->fw_status);
1004         wl->fw_status = NULL;
1005         kfree(wl->tx_res_if);
1006         wl->tx_res_if = NULL;
1007         kfree(wl->target_mem_map);
1008         wl->target_mem_map = NULL;
1009
1010         mutex_unlock(&wl->mutex);
1011 }
1012
1013 static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1014 {
1015         wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1016         wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1017
1018         /* combine requested filters with current filter config */
1019         filters = wl->filters | filters;
1020
1021         wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1022
1023         if (filters & FIF_PROMISC_IN_BSS) {
1024                 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1025                 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1026                 wl->rx_config |= CFG_BSSID_FILTER_EN;
1027         }
1028         if (filters & FIF_BCN_PRBRESP_PROMISC) {
1029                 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1030                 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1031                 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1032         }
1033         if (filters & FIF_OTHER_BSS) {
1034                 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1035                 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1036         }
1037         if (filters & FIF_CONTROL) {
1038                 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1039                 wl->rx_filter |= CFG_RX_CTL_EN;
1040         }
1041         if (filters & FIF_FCSFAIL) {
1042                 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1043                 wl->rx_filter |= CFG_RX_FCS_ERROR;
1044         }
1045 }
1046
1047 static int wl1271_dummy_join(struct wl1271 *wl)
1048 {
1049         int ret = 0;
1050         /* we need to use a dummy BSSID for now */
1051         static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1052                                                   0xad, 0xbe, 0xef };
1053
1054         memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1055
1056         /* pass through frames from all BSS */
1057         wl1271_configure_filters(wl, FIF_OTHER_BSS);
1058
1059         ret = wl1271_cmd_join(wl, wl->set_bss_type);
1060         if (ret < 0)
1061                 goto out;
1062
1063         set_bit(WL1271_FLAG_JOINED, &wl->flags);
1064
1065 out:
1066         return ret;
1067 }
1068
1069 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
1070 {
1071         int ret;
1072
1073         /*
1074          * One of the side effects of the JOIN command is that is clears
1075          * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1076          * to a WPA/WPA2 access point will therefore kill the data-path.
1077          * Currently there is no supported scenario for JOIN during
1078          * association - if it becomes a supported scenario, the WPA/WPA2 keys
1079          * must be handled somehow.
1080          *
1081          */
1082         if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1083                 wl1271_info("JOIN while associated.");
1084
1085         if (set_assoc)
1086                 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1087
1088         ret = wl1271_cmd_join(wl, wl->set_bss_type);
1089         if (ret < 0)
1090                 goto out;
1091
1092         set_bit(WL1271_FLAG_JOINED, &wl->flags);
1093
1094         if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1095                 goto out;
1096
1097         /*
1098          * The join command disable the keep-alive mode, shut down its process,
1099          * and also clear the template config, so we need to reset it all after
1100          * the join. The acx_aid starts the keep-alive process, and the order
1101          * of the commands below is relevant.
1102          */
1103         ret = wl1271_acx_keep_alive_mode(wl, true);
1104         if (ret < 0)
1105                 goto out;
1106
1107         ret = wl1271_acx_aid(wl, wl->aid);
1108         if (ret < 0)
1109                 goto out;
1110
1111         ret = wl1271_cmd_build_klv_null_data(wl);
1112         if (ret < 0)
1113                 goto out;
1114
1115         ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1116                                            ACX_KEEP_ALIVE_TPL_VALID);
1117         if (ret < 0)
1118                 goto out;
1119
1120 out:
1121         return ret;
1122 }
1123
1124 static int wl1271_unjoin(struct wl1271 *wl)
1125 {
1126         int ret;
1127
1128         /* to stop listening to a channel, we disconnect */
1129         ret = wl1271_cmd_disconnect(wl);
1130         if (ret < 0)
1131                 goto out;
1132
1133         clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1134         memset(wl->bssid, 0, ETH_ALEN);
1135
1136         /* stop filterting packets based on bssid */
1137         wl1271_configure_filters(wl, FIF_OTHER_BSS);
1138
1139 out:
1140         return ret;
1141 }
1142
1143 static void wl1271_set_band_rate(struct wl1271 *wl)
1144 {
1145         if (wl->band == IEEE80211_BAND_2GHZ)
1146                 wl->basic_rate_set = wl->conf.tx.basic_rate;
1147         else
1148                 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1149 }
1150
1151 static u32 wl1271_min_rate_get(struct wl1271 *wl)
1152 {
1153         int i;
1154         u32 rate = 0;
1155
1156         if (!wl->basic_rate_set) {
1157                 WARN_ON(1);
1158                 wl->basic_rate_set = wl->conf.tx.basic_rate;
1159         }
1160
1161         for (i = 0; !rate; i++) {
1162                 if ((wl->basic_rate_set >> i) & 0x1)
1163                         rate = 1 << i;
1164         }
1165
1166         return rate;
1167 }
1168
1169 static int wl1271_handle_idle(struct wl1271 *wl, bool idle)
1170 {
1171         int ret;
1172
1173         if (idle) {
1174                 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1175                         ret = wl1271_unjoin(wl);
1176                         if (ret < 0)
1177                                 goto out;
1178                 }
1179                 wl->rate_set = wl1271_min_rate_get(wl);
1180                 wl->sta_rate_set = 0;
1181                 ret = wl1271_acx_rate_policies(wl);
1182                 if (ret < 0)
1183                         goto out;
1184                 ret = wl1271_acx_keep_alive_config(
1185                         wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1186                         ACX_KEEP_ALIVE_TPL_INVALID);
1187                 if (ret < 0)
1188                         goto out;
1189                 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1190         } else {
1191                 /* increment the session counter */
1192                 wl->session_counter++;
1193                 if (wl->session_counter >= SESSION_COUNTER_MAX)
1194                         wl->session_counter = 0;
1195                 ret = wl1271_dummy_join(wl);
1196                 if (ret < 0)
1197                         goto out;
1198                 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1199         }
1200
1201 out:
1202         return ret;
1203 }
1204
1205 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1206 {
1207         struct wl1271 *wl = hw->priv;
1208         struct ieee80211_conf *conf = &hw->conf;
1209         int channel, ret = 0;
1210
1211         channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1212
1213         wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
1214                      channel,
1215                      conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1216                      conf->power_level,
1217                      conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
1218
1219         /*
1220          * mac80211 will go to idle nearly immediately after transmitting some
1221          * frames, such as the deauth. To make sure those frames reach the air,
1222          * wait here until the TX queue is fully flushed.
1223          */
1224         if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1225             (conf->flags & IEEE80211_CONF_IDLE))
1226                 wl1271_tx_flush(wl);
1227
1228         mutex_lock(&wl->mutex);
1229
1230         if (unlikely(wl->state == WL1271_STATE_OFF))
1231                 goto out;
1232
1233         ret = wl1271_ps_elp_wakeup(wl, false);
1234         if (ret < 0)
1235                 goto out;
1236
1237         /* if the channel changes while joined, join again */
1238         if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1239             ((wl->band != conf->channel->band) ||
1240              (wl->channel != channel))) {
1241                 wl->band = conf->channel->band;
1242                 wl->channel = channel;
1243
1244                 /*
1245                  * FIXME: the mac80211 should really provide a fixed rate
1246                  * to use here. for now, just use the smallest possible rate
1247                  * for the band as a fixed rate for association frames and
1248                  * other control messages.
1249                  */
1250                 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1251                         wl1271_set_band_rate(wl);
1252
1253                 wl->basic_rate = wl1271_min_rate_get(wl);
1254                 ret = wl1271_acx_rate_policies(wl);
1255                 if (ret < 0)
1256                         wl1271_warning("rate policy for update channel "
1257                                        "failed %d", ret);
1258
1259                 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1260                         ret = wl1271_join(wl, false);
1261                         if (ret < 0)
1262                                 wl1271_warning("cmd join to update channel "
1263                                                "failed %d", ret);
1264                 }
1265         }
1266
1267         if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1268                 ret = wl1271_handle_idle(wl, conf->flags & IEEE80211_CONF_IDLE);
1269                 if (ret < 0)
1270                         wl1271_warning("idle mode change failed %d", ret);
1271         }
1272
1273         /*
1274          * if mac80211 changes the PSM mode, make sure the mode is not
1275          * incorrectly changed after the pspoll failure active window.
1276          */
1277         if (changed & IEEE80211_CONF_CHANGE_PS)
1278                 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
1279
1280         if (conf->flags & IEEE80211_CONF_PS &&
1281             !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1282                 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1283
1284                 /*
1285                  * We enter PSM only if we're already associated.
1286                  * If we're not, we'll enter it when joining an SSID,
1287                  * through the bss_info_changed() hook.
1288                  */
1289                 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1290                         wl1271_debug(DEBUG_PSM, "psm enabled");
1291                         ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1292                                                  true);
1293                 }
1294         } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1295                    test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1296                 wl1271_debug(DEBUG_PSM, "psm disabled");
1297
1298                 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1299
1300                 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1301                         ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1302                                                  true);
1303         }
1304
1305         if (conf->power_level != wl->power_level) {
1306                 ret = wl1271_acx_tx_power(wl, conf->power_level);
1307                 if (ret < 0)
1308                         goto out_sleep;
1309
1310                 wl->power_level = conf->power_level;
1311         }
1312
1313 out_sleep:
1314         wl1271_ps_elp_sleep(wl);
1315
1316 out:
1317         mutex_unlock(&wl->mutex);
1318
1319         return ret;
1320 }
1321
1322 struct wl1271_filter_params {
1323         bool enabled;
1324         int mc_list_length;
1325         u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1326 };
1327
1328 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1329                                        struct netdev_hw_addr_list *mc_list)
1330 {
1331         struct wl1271_filter_params *fp;
1332         struct netdev_hw_addr *ha;
1333         struct wl1271 *wl = hw->priv;
1334
1335         if (unlikely(wl->state == WL1271_STATE_OFF))
1336                 return 0;
1337
1338         fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1339         if (!fp) {
1340                 wl1271_error("Out of memory setting filters.");
1341                 return 0;
1342         }
1343
1344         /* update multicast filtering parameters */
1345         fp->mc_list_length = 0;
1346         if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1347                 fp->enabled = false;
1348         } else {
1349                 fp->enabled = true;
1350                 netdev_hw_addr_list_for_each(ha, mc_list) {
1351                         memcpy(fp->mc_list[fp->mc_list_length],
1352                                         ha->addr, ETH_ALEN);
1353                         fp->mc_list_length++;
1354                 }
1355         }
1356
1357         return (u64)(unsigned long)fp;
1358 }
1359
1360 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1361                                   FIF_ALLMULTI | \
1362                                   FIF_FCSFAIL | \
1363                                   FIF_BCN_PRBRESP_PROMISC | \
1364                                   FIF_CONTROL | \
1365                                   FIF_OTHER_BSS)
1366
1367 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1368                                        unsigned int changed,
1369                                        unsigned int *total, u64 multicast)
1370 {
1371         struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1372         struct wl1271 *wl = hw->priv;
1373         int ret;
1374
1375         wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1376
1377         mutex_lock(&wl->mutex);
1378
1379         *total &= WL1271_SUPPORTED_FILTERS;
1380         changed &= WL1271_SUPPORTED_FILTERS;
1381
1382         if (unlikely(wl->state == WL1271_STATE_OFF))
1383                 goto out;
1384
1385         ret = wl1271_ps_elp_wakeup(wl, false);
1386         if (ret < 0)
1387                 goto out;
1388
1389
1390         if (*total & FIF_ALLMULTI)
1391                 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1392         else if (fp)
1393                 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1394                                                    fp->mc_list,
1395                                                    fp->mc_list_length);
1396         if (ret < 0)
1397                 goto out_sleep;
1398
1399         /* determine, whether supported filter values have changed */
1400         if (changed == 0)
1401                 goto out_sleep;
1402
1403         /* configure filters */
1404         wl->filters = *total;
1405         wl1271_configure_filters(wl, 0);
1406
1407         /* apply configured filters */
1408         ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1409         if (ret < 0)
1410                 goto out_sleep;
1411
1412 out_sleep:
1413         wl1271_ps_elp_sleep(wl);
1414
1415 out:
1416         mutex_unlock(&wl->mutex);
1417         kfree(fp);
1418 }
1419
1420 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1421                              struct ieee80211_vif *vif,
1422                              struct ieee80211_sta *sta,
1423                              struct ieee80211_key_conf *key_conf)
1424 {
1425         struct wl1271 *wl = hw->priv;
1426         const u8 *addr;
1427         int ret;
1428         u32 tx_seq_32 = 0;
1429         u16 tx_seq_16 = 0;
1430         u8 key_type;
1431
1432         static const u8 bcast_addr[ETH_ALEN] =
1433                 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1434
1435         wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1436
1437         addr = sta ? sta->addr : bcast_addr;
1438
1439         wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1440         wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1441         wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1442                      key_conf->alg, key_conf->keyidx,
1443                      key_conf->keylen, key_conf->flags);
1444         wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1445
1446         if (is_zero_ether_addr(addr)) {
1447                 /* We dont support TX only encryption */
1448                 ret = -EOPNOTSUPP;
1449                 goto out;
1450         }
1451
1452         mutex_lock(&wl->mutex);
1453
1454         ret = wl1271_ps_elp_wakeup(wl, false);
1455         if (ret < 0)
1456                 goto out_unlock;
1457
1458         switch (key_conf->alg) {
1459         case ALG_WEP:
1460                 key_type = KEY_WEP;
1461
1462                 key_conf->hw_key_idx = key_conf->keyidx;
1463                 break;
1464         case ALG_TKIP:
1465                 key_type = KEY_TKIP;
1466
1467                 key_conf->hw_key_idx = key_conf->keyidx;
1468                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1469                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1470                 break;
1471         case ALG_CCMP:
1472                 key_type = KEY_AES;
1473
1474                 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1475                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1476                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1477                 break;
1478         default:
1479                 wl1271_error("Unknown key algo 0x%x", key_conf->alg);
1480
1481                 ret = -EOPNOTSUPP;
1482                 goto out_sleep;
1483         }
1484
1485         switch (cmd) {
1486         case SET_KEY:
1487                 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1488                                          key_conf->keyidx, key_type,
1489                                          key_conf->keylen, key_conf->key,
1490                                          addr, tx_seq_32, tx_seq_16);
1491                 if (ret < 0) {
1492                         wl1271_error("Could not add or replace key");
1493                         goto out_sleep;
1494                 }
1495
1496                 /* the default WEP key needs to be configured at least once */
1497                 if (key_type == KEY_WEP) {
1498                         ret = wl1271_cmd_set_default_wep_key(wl,
1499                                                              wl->default_key);
1500                         if (ret < 0)
1501                                 goto out_sleep;
1502                 }
1503                 break;
1504
1505         case DISABLE_KEY:
1506                 /* The wl1271 does not allow to remove unicast keys - they
1507                    will be cleared automatically on next CMD_JOIN. Ignore the
1508                    request silently, as we dont want the mac80211 to emit
1509                    an error message. */
1510                 if (!is_broadcast_ether_addr(addr))
1511                         break;
1512
1513                 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1514                                          key_conf->keyidx, key_type,
1515                                          key_conf->keylen, key_conf->key,
1516                                          addr, 0, 0);
1517                 if (ret < 0) {
1518                         wl1271_error("Could not remove key");
1519                         goto out_sleep;
1520                 }
1521                 break;
1522
1523         default:
1524                 wl1271_error("Unsupported key cmd 0x%x", cmd);
1525                 ret = -EOPNOTSUPP;
1526                 break;
1527         }
1528
1529 out_sleep:
1530         wl1271_ps_elp_sleep(wl);
1531
1532 out_unlock:
1533         mutex_unlock(&wl->mutex);
1534
1535 out:
1536         return ret;
1537 }
1538
1539 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1540                              struct ieee80211_vif *vif,
1541                              struct cfg80211_scan_request *req)
1542 {
1543         struct wl1271 *wl = hw->priv;
1544         int ret;
1545         u8 *ssid = NULL;
1546         size_t len = 0;
1547
1548         wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1549
1550         if (req->n_ssids) {
1551                 ssid = req->ssids[0].ssid;
1552                 len = req->ssids[0].ssid_len;
1553         }
1554
1555         mutex_lock(&wl->mutex);
1556
1557         ret = wl1271_ps_elp_wakeup(wl, false);
1558         if (ret < 0)
1559                 goto out;
1560
1561         if (wl1271_11a_enabled())
1562                 ret = wl1271_scan(hw->priv, ssid, len, req);
1563         else
1564                 ret = wl1271_scan(hw->priv, ssid, len, req);
1565
1566         wl1271_ps_elp_sleep(wl);
1567
1568 out:
1569         mutex_unlock(&wl->mutex);
1570
1571         return ret;
1572 }
1573
1574 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1575 {
1576         struct wl1271 *wl = hw->priv;
1577         int ret = 0;
1578
1579         mutex_lock(&wl->mutex);
1580
1581         if (unlikely(wl->state == WL1271_STATE_OFF))
1582                 goto out;
1583
1584         ret = wl1271_ps_elp_wakeup(wl, false);
1585         if (ret < 0)
1586                 goto out;
1587
1588         ret = wl1271_acx_rts_threshold(wl, (u16) value);
1589         if (ret < 0)
1590                 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1591
1592         wl1271_ps_elp_sleep(wl);
1593
1594 out:
1595         mutex_unlock(&wl->mutex);
1596
1597         return ret;
1598 }
1599
1600 static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1601 {
1602         u8 *ptr = beacon->data +
1603                 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1604
1605         /* find the location of the ssid in the beacon */
1606         while (ptr < beacon->data + beacon->len) {
1607                 if (ptr[0] == WLAN_EID_SSID) {
1608                         wl->ssid_len = ptr[1];
1609                         memcpy(wl->ssid, ptr+2, wl->ssid_len);
1610                         return;
1611                 }
1612                 ptr += ptr[1];
1613         }
1614         wl1271_error("ad-hoc beacon template has no SSID!\n");
1615 }
1616
1617 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1618                                        struct ieee80211_vif *vif,
1619                                        struct ieee80211_bss_conf *bss_conf,
1620                                        u32 changed)
1621 {
1622         enum wl1271_cmd_ps_mode mode;
1623         struct wl1271 *wl = hw->priv;
1624         bool do_join = false;
1625         bool set_assoc = false;
1626         int ret;
1627
1628         wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1629
1630         mutex_lock(&wl->mutex);
1631
1632         ret = wl1271_ps_elp_wakeup(wl, false);
1633         if (ret < 0)
1634                 goto out;
1635
1636         if ((changed && BSS_CHANGED_BEACON_INT) &&
1637             (wl->bss_type == BSS_TYPE_IBSS)) {
1638                 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
1639                         bss_conf->beacon_int);
1640
1641                 wl->beacon_int = bss_conf->beacon_int;
1642                 do_join = true;
1643         }
1644
1645         if ((changed && BSS_CHANGED_BEACON) &&
1646             (wl->bss_type == BSS_TYPE_IBSS)) {
1647                 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1648
1649                 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
1650
1651                 if (beacon) {
1652                         struct ieee80211_hdr *hdr;
1653
1654                         wl1271_ssid_set(wl, beacon);
1655                         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1656                                                       beacon->data,
1657                                                       beacon->len, 0,
1658                                                       wl1271_min_rate_get(wl));
1659
1660                         if (ret < 0) {
1661                                 dev_kfree_skb(beacon);
1662                                 goto out_sleep;
1663                         }
1664
1665                         hdr = (struct ieee80211_hdr *) beacon->data;
1666                         hdr->frame_control = cpu_to_le16(
1667                                 IEEE80211_FTYPE_MGMT |
1668                                 IEEE80211_STYPE_PROBE_RESP);
1669
1670                         ret = wl1271_cmd_template_set(wl,
1671                                                       CMD_TEMPL_PROBE_RESPONSE,
1672                                                       beacon->data,
1673                                                       beacon->len, 0,
1674                                                       wl1271_min_rate_get(wl));
1675                         dev_kfree_skb(beacon);
1676                         if (ret < 0)
1677                                 goto out_sleep;
1678
1679                         /* Need to update the SSID (for filtering etc) */
1680                         do_join = true;
1681                 }
1682         }
1683
1684         if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1685             (wl->bss_type == BSS_TYPE_IBSS)) {
1686                 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1687                              bss_conf->enable_beacon ? "enabled" : "disabled");
1688
1689                 if (bss_conf->enable_beacon)
1690                         wl->set_bss_type = BSS_TYPE_IBSS;
1691                 else
1692                         wl->set_bss_type = BSS_TYPE_STA_BSS;
1693                 do_join = true;
1694         }
1695
1696         if (changed & BSS_CHANGED_CQM) {
1697                 bool enable = false;
1698                 if (bss_conf->cqm_rssi_thold)
1699                         enable = true;
1700                 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
1701                                                   bss_conf->cqm_rssi_thold,
1702                                                   bss_conf->cqm_rssi_hyst);
1703                 if (ret < 0)
1704                         goto out;
1705                 wl->rssi_thold = bss_conf->cqm_rssi_thold;
1706         }
1707
1708         if ((changed & BSS_CHANGED_BSSID) &&
1709             /*
1710              * Now we know the correct bssid, so we send a new join command
1711              * and enable the BSSID filter
1712              */
1713             memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1714                         memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1715
1716                         ret = wl1271_cmd_build_null_data(wl);
1717                         if (ret < 0)
1718                                 goto out_sleep;
1719
1720                         ret = wl1271_build_qos_null_data(wl);
1721                         if (ret < 0)
1722                                 goto out_sleep;
1723
1724                         /* filter out all packets not from this BSSID */
1725                         wl1271_configure_filters(wl, 0);
1726
1727                         /* Need to update the BSSID (for filtering etc) */
1728                         do_join = true;
1729         }
1730
1731         if (changed & BSS_CHANGED_ASSOC) {
1732                 if (bss_conf->assoc) {
1733                         u32 rates;
1734                         wl->aid = bss_conf->aid;
1735                         set_assoc = true;
1736
1737                         wl->ps_poll_failures = 0;
1738
1739                         /*
1740                          * use basic rates from AP, and determine lowest rate
1741                          * to use with control frames.
1742                          */
1743                         rates = bss_conf->basic_rates;
1744                         wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1745                                                                          rates);
1746                         wl->basic_rate = wl1271_min_rate_get(wl);
1747                         ret = wl1271_acx_rate_policies(wl);
1748                         if (ret < 0)
1749                                 goto out_sleep;
1750
1751                         /*
1752                          * with wl1271, we don't need to update the
1753                          * beacon_int and dtim_period, because the firmware
1754                          * updates it by itself when the first beacon is
1755                          * received after a join.
1756                          */
1757                         ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1758                         if (ret < 0)
1759                                 goto out_sleep;
1760
1761                         /*
1762                          * The SSID is intentionally set to NULL here - the
1763                          * firmware will set the probe request with a
1764                          * broadcast SSID regardless of what we set in the
1765                          * template.
1766                          */
1767                         ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1768                                                          NULL, 0, wl->band);
1769
1770                         /* enable the connection monitoring feature */
1771                         ret = wl1271_acx_conn_monit_params(wl, true);
1772                         if (ret < 0)
1773                                 goto out_sleep;
1774
1775                         /* If we want to go in PSM but we're not there yet */
1776                         if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1777                             !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1778                                 mode = STATION_POWER_SAVE_MODE;
1779                                 ret = wl1271_ps_set_mode(wl, mode, true);
1780                                 if (ret < 0)
1781                                         goto out_sleep;
1782                         }
1783                 } else {
1784                         /* use defaults when not associated */
1785                         clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1786                         wl->aid = 0;
1787
1788                         /* re-enable dynamic ps - just in case */
1789                         ieee80211_enable_dyn_ps(wl->vif);
1790
1791                         /* revert back to minimum rates for the current band */
1792                         wl1271_set_band_rate(wl);
1793                         wl->basic_rate = wl1271_min_rate_get(wl);
1794                         ret = wl1271_acx_rate_policies(wl);
1795                         if (ret < 0)
1796                                 goto out_sleep;
1797
1798                         /* disable connection monitor features */
1799                         ret = wl1271_acx_conn_monit_params(wl, false);
1800
1801                         /* Disable the keep-alive feature */
1802                         ret = wl1271_acx_keep_alive_mode(wl, false);
1803
1804                         if (ret < 0)
1805                                 goto out_sleep;
1806                 }
1807
1808         }
1809
1810         if (changed & BSS_CHANGED_ERP_SLOT) {
1811                 if (bss_conf->use_short_slot)
1812                         ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1813                 else
1814                         ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1815                 if (ret < 0) {
1816                         wl1271_warning("Set slot time failed %d", ret);
1817                         goto out_sleep;
1818                 }
1819         }
1820
1821         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1822                 if (bss_conf->use_short_preamble)
1823                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1824                 else
1825                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1826         }
1827
1828         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1829                 if (bss_conf->use_cts_prot)
1830                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1831                 else
1832                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1833                 if (ret < 0) {
1834                         wl1271_warning("Set ctsprotect failed %d", ret);
1835                         goto out_sleep;
1836                 }
1837         }
1838
1839         if (changed & BSS_CHANGED_ARP_FILTER) {
1840                 __be32 addr = bss_conf->arp_addr_list[0];
1841                 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
1842
1843                 if (bss_conf->arp_addr_cnt == 1 && bss_conf->arp_filter_enabled)
1844                         ret = wl1271_acx_arp_ip_filter(wl, true, addr);
1845                 else
1846                         ret = wl1271_acx_arp_ip_filter(wl, false, addr);
1847
1848                 if (ret < 0)
1849                         goto out_sleep;
1850         }
1851
1852         if (do_join) {
1853                 ret = wl1271_join(wl, set_assoc);
1854                 if (ret < 0) {
1855                         wl1271_warning("cmd join failed %d", ret);
1856                         goto out_sleep;
1857                 }
1858         }
1859
1860 out_sleep:
1861         wl1271_ps_elp_sleep(wl);
1862
1863 out:
1864         mutex_unlock(&wl->mutex);
1865 }
1866
1867 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1868                              const struct ieee80211_tx_queue_params *params)
1869 {
1870         struct wl1271 *wl = hw->priv;
1871         u8 ps_scheme;
1872         int ret;
1873
1874         mutex_lock(&wl->mutex);
1875
1876         wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1877
1878         ret = wl1271_ps_elp_wakeup(wl, false);
1879         if (ret < 0)
1880                 goto out;
1881
1882         /* the txop is confed in units of 32us by the mac80211, we need us */
1883         ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1884                                 params->cw_min, params->cw_max,
1885                                 params->aifs, params->txop << 5);
1886         if (ret < 0)
1887                 goto out_sleep;
1888
1889         if (params->uapsd)
1890                 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
1891         else
1892                 ps_scheme = CONF_PS_SCHEME_LEGACY;
1893
1894         ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1895                                  CONF_CHANNEL_TYPE_EDCF,
1896                                  wl1271_tx_get_queue(queue),
1897                                  ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
1898         if (ret < 0)
1899                 goto out_sleep;
1900
1901 out_sleep:
1902         wl1271_ps_elp_sleep(wl);
1903
1904 out:
1905         mutex_unlock(&wl->mutex);
1906
1907         return ret;
1908 }
1909
1910 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
1911 {
1912
1913         struct wl1271 *wl = hw->priv;
1914         u64 mactime = ULLONG_MAX;
1915         int ret;
1916
1917         wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
1918
1919         mutex_lock(&wl->mutex);
1920
1921         ret = wl1271_ps_elp_wakeup(wl, false);
1922         if (ret < 0)
1923                 goto out;
1924
1925         ret = wl1271_acx_tsf_info(wl, &mactime);
1926         if (ret < 0)
1927                 goto out_sleep;
1928
1929 out_sleep:
1930         wl1271_ps_elp_sleep(wl);
1931
1932 out:
1933         mutex_unlock(&wl->mutex);
1934         return mactime;
1935 }
1936
1937 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
1938                                 struct survey_info *survey)
1939 {
1940         struct wl1271 *wl = hw->priv;
1941         struct ieee80211_conf *conf = &hw->conf;
1942
1943         if (idx != 0)
1944                 return -ENOENT;
1945
1946         survey->channel = conf->channel;
1947         survey->filled = SURVEY_INFO_NOISE_DBM;
1948         survey->noise = wl->noise;
1949
1950         return 0;
1951 }
1952
1953 /* can't be const, mac80211 writes to this */
1954 static struct ieee80211_rate wl1271_rates[] = {
1955         { .bitrate = 10,
1956           .hw_value = CONF_HW_BIT_RATE_1MBPS,
1957           .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
1958         { .bitrate = 20,
1959           .hw_value = CONF_HW_BIT_RATE_2MBPS,
1960           .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
1961           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1962         { .bitrate = 55,
1963           .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1964           .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
1965           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1966         { .bitrate = 110,
1967           .hw_value = CONF_HW_BIT_RATE_11MBPS,
1968           .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
1969           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1970         { .bitrate = 60,
1971           .hw_value = CONF_HW_BIT_RATE_6MBPS,
1972           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1973         { .bitrate = 90,
1974           .hw_value = CONF_HW_BIT_RATE_9MBPS,
1975           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1976         { .bitrate = 120,
1977           .hw_value = CONF_HW_BIT_RATE_12MBPS,
1978           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1979         { .bitrate = 180,
1980           .hw_value = CONF_HW_BIT_RATE_18MBPS,
1981           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1982         { .bitrate = 240,
1983           .hw_value = CONF_HW_BIT_RATE_24MBPS,
1984           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1985         { .bitrate = 360,
1986          .hw_value = CONF_HW_BIT_RATE_36MBPS,
1987          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1988         { .bitrate = 480,
1989           .hw_value = CONF_HW_BIT_RATE_48MBPS,
1990           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1991         { .bitrate = 540,
1992           .hw_value = CONF_HW_BIT_RATE_54MBPS,
1993           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1994 };
1995
1996 /* can't be const, mac80211 writes to this */
1997 static struct ieee80211_channel wl1271_channels[] = {
1998         { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
1999         { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
2000         { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
2001         { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
2002         { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
2003         { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
2004         { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
2005         { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
2006         { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
2007         { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
2008         { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
2009         { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
2010         { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
2011 };
2012
2013 /* mapping to indexes for wl1271_rates */
2014 static const u8 wl1271_rate_to_idx_2ghz[] = {
2015         /* MCS rates are used only with 11n */
2016         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2017         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2018         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2019         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2020         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2021         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2022         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2023         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2024
2025         11,                            /* CONF_HW_RXTX_RATE_54   */
2026         10,                            /* CONF_HW_RXTX_RATE_48   */
2027         9,                             /* CONF_HW_RXTX_RATE_36   */
2028         8,                             /* CONF_HW_RXTX_RATE_24   */
2029
2030         /* TI-specific rate */
2031         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
2032
2033         7,                             /* CONF_HW_RXTX_RATE_18   */
2034         6,                             /* CONF_HW_RXTX_RATE_12   */
2035         3,                             /* CONF_HW_RXTX_RATE_11   */
2036         5,                             /* CONF_HW_RXTX_RATE_9    */
2037         4,                             /* CONF_HW_RXTX_RATE_6    */
2038         2,                             /* CONF_HW_RXTX_RATE_5_5  */
2039         1,                             /* CONF_HW_RXTX_RATE_2    */
2040         0                              /* CONF_HW_RXTX_RATE_1    */
2041 };
2042
2043 /* can't be const, mac80211 writes to this */
2044 static struct ieee80211_supported_band wl1271_band_2ghz = {
2045         .channels = wl1271_channels,
2046         .n_channels = ARRAY_SIZE(wl1271_channels),
2047         .bitrates = wl1271_rates,
2048         .n_bitrates = ARRAY_SIZE(wl1271_rates),
2049 };
2050
2051 /* 5 GHz data rates for WL1273 */
2052 static struct ieee80211_rate wl1271_rates_5ghz[] = {
2053         { .bitrate = 60,
2054           .hw_value = CONF_HW_BIT_RATE_6MBPS,
2055           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2056         { .bitrate = 90,
2057           .hw_value = CONF_HW_BIT_RATE_9MBPS,
2058           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2059         { .bitrate = 120,
2060           .hw_value = CONF_HW_BIT_RATE_12MBPS,
2061           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2062         { .bitrate = 180,
2063           .hw_value = CONF_HW_BIT_RATE_18MBPS,
2064           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2065         { .bitrate = 240,
2066           .hw_value = CONF_HW_BIT_RATE_24MBPS,
2067           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2068         { .bitrate = 360,
2069          .hw_value = CONF_HW_BIT_RATE_36MBPS,
2070          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2071         { .bitrate = 480,
2072           .hw_value = CONF_HW_BIT_RATE_48MBPS,
2073           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2074         { .bitrate = 540,
2075           .hw_value = CONF_HW_BIT_RATE_54MBPS,
2076           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2077 };
2078
2079 /* 5 GHz band channels for WL1273 */
2080 static struct ieee80211_channel wl1271_channels_5ghz[] = {
2081         { .hw_value = 183, .center_freq = 4915},
2082         { .hw_value = 184, .center_freq = 4920},
2083         { .hw_value = 185, .center_freq = 4925},
2084         { .hw_value = 187, .center_freq = 4935},
2085         { .hw_value = 188, .center_freq = 4940},
2086         { .hw_value = 189, .center_freq = 4945},
2087         { .hw_value = 192, .center_freq = 4960},
2088         { .hw_value = 196, .center_freq = 4980},
2089         { .hw_value = 7, .center_freq = 5035},
2090         { .hw_value = 8, .center_freq = 5040},
2091         { .hw_value = 9, .center_freq = 5045},
2092         { .hw_value = 11, .center_freq = 5055},
2093         { .hw_value = 12, .center_freq = 5060},
2094         { .hw_value = 16, .center_freq = 5080},
2095         { .hw_value = 34, .center_freq = 5170},
2096         { .hw_value = 36, .center_freq = 5180},
2097         { .hw_value = 38, .center_freq = 5190},
2098         { .hw_value = 40, .center_freq = 5200},
2099         { .hw_value = 42, .center_freq = 5210},
2100         { .hw_value = 44, .center_freq = 5220},
2101         { .hw_value = 46, .center_freq = 5230},
2102         { .hw_value = 48, .center_freq = 5240},
2103         { .hw_value = 52, .center_freq = 5260},
2104         { .hw_value = 56, .center_freq = 5280},
2105         { .hw_value = 60, .center_freq = 5300},
2106         { .hw_value = 64, .center_freq = 5320},
2107         { .hw_value = 100, .center_freq = 5500},
2108         { .hw_value = 104, .center_freq = 5520},
2109         { .hw_value = 108, .center_freq = 5540},
2110         { .hw_value = 112, .center_freq = 5560},
2111         { .hw_value = 116, .center_freq = 5580},
2112         { .hw_value = 120, .center_freq = 5600},
2113         { .hw_value = 124, .center_freq = 5620},
2114         { .hw_value = 128, .center_freq = 5640},
2115         { .hw_value = 132, .center_freq = 5660},
2116         { .hw_value = 136, .center_freq = 5680},
2117         { .hw_value = 140, .center_freq = 5700},
2118         { .hw_value = 149, .center_freq = 5745},
2119         { .hw_value = 153, .center_freq = 5765},
2120         { .hw_value = 157, .center_freq = 5785},
2121         { .hw_value = 161, .center_freq = 5805},
2122         { .hw_value = 165, .center_freq = 5825},
2123 };
2124
2125 /* mapping to indexes for wl1271_rates_5ghz */
2126 static const u8 wl1271_rate_to_idx_5ghz[] = {
2127         /* MCS rates are used only with 11n */
2128         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2129         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2130         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2131         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2132         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2133         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2134         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2135         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2136
2137         7,                             /* CONF_HW_RXTX_RATE_54   */
2138         6,                             /* CONF_HW_RXTX_RATE_48   */
2139         5,                             /* CONF_HW_RXTX_RATE_36   */
2140         4,                             /* CONF_HW_RXTX_RATE_24   */
2141
2142         /* TI-specific rate */
2143         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
2144
2145         3,                             /* CONF_HW_RXTX_RATE_18   */
2146         2,                             /* CONF_HW_RXTX_RATE_12   */
2147         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11   */
2148         1,                             /* CONF_HW_RXTX_RATE_9    */
2149         0,                             /* CONF_HW_RXTX_RATE_6    */
2150         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5  */
2151         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2    */
2152         CONF_HW_RXTX_RATE_UNSUPPORTED  /* CONF_HW_RXTX_RATE_1    */
2153 };
2154
2155 static struct ieee80211_supported_band wl1271_band_5ghz = {
2156         .channels = wl1271_channels_5ghz,
2157         .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2158         .bitrates = wl1271_rates_5ghz,
2159         .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
2160 };
2161
2162 static const u8 *wl1271_band_rate_to_idx[] = {
2163         [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2164         [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2165 };
2166
2167 static const struct ieee80211_ops wl1271_ops = {
2168         .start = wl1271_op_start,
2169         .stop = wl1271_op_stop,
2170         .add_interface = wl1271_op_add_interface,
2171         .remove_interface = wl1271_op_remove_interface,
2172         .config = wl1271_op_config,
2173         .prepare_multicast = wl1271_op_prepare_multicast,
2174         .configure_filter = wl1271_op_configure_filter,
2175         .tx = wl1271_op_tx,
2176         .set_key = wl1271_op_set_key,
2177         .hw_scan = wl1271_op_hw_scan,
2178         .bss_info_changed = wl1271_op_bss_info_changed,
2179         .set_rts_threshold = wl1271_op_set_rts_threshold,
2180         .conf_tx = wl1271_op_conf_tx,
2181         .get_tsf = wl1271_op_get_tsf,
2182         .get_survey = wl1271_op_get_survey,
2183         CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
2184 };
2185
2186
2187 u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate)
2188 {
2189         u8 idx;
2190
2191         BUG_ON(wl->band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
2192
2193         if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2194                 wl1271_error("Illegal RX rate from HW: %d", rate);
2195                 return 0;
2196         }
2197
2198         idx = wl1271_band_rate_to_idx[wl->band][rate];
2199         if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2200                 wl1271_error("Unsupported RX rate from HW: %d", rate);
2201                 return 0;
2202         }
2203
2204         return idx;
2205 }
2206
2207 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2208                                                struct device_attribute *attr,
2209                                                char *buf)
2210 {
2211         struct wl1271 *wl = dev_get_drvdata(dev);
2212         ssize_t len;
2213
2214         /* FIXME: what's the maximum length of buf? page size?*/
2215         len = 500;
2216
2217         mutex_lock(&wl->mutex);
2218         len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2219                        wl->sg_enabled);
2220         mutex_unlock(&wl->mutex);
2221
2222         return len;
2223
2224 }
2225
2226 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2227                                                 struct device_attribute *attr,
2228                                                 const char *buf, size_t count)
2229 {
2230         struct wl1271 *wl = dev_get_drvdata(dev);
2231         unsigned long res;
2232         int ret;
2233
2234         ret = strict_strtoul(buf, 10, &res);
2235
2236         if (ret < 0) {
2237                 wl1271_warning("incorrect value written to bt_coex_mode");
2238                 return count;
2239         }
2240
2241         mutex_lock(&wl->mutex);
2242
2243         res = !!res;
2244
2245         if (res == wl->sg_enabled)
2246                 goto out;
2247
2248         wl->sg_enabled = res;
2249
2250         if (wl->state == WL1271_STATE_OFF)
2251                 goto out;
2252
2253         ret = wl1271_ps_elp_wakeup(wl, false);
2254         if (ret < 0)
2255                 goto out;
2256
2257         wl1271_acx_sg_enable(wl, wl->sg_enabled);
2258         wl1271_ps_elp_sleep(wl);
2259
2260  out:
2261         mutex_unlock(&wl->mutex);
2262         return count;
2263 }
2264
2265 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2266                    wl1271_sysfs_show_bt_coex_state,
2267                    wl1271_sysfs_store_bt_coex_state);
2268
2269 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
2270                                            struct device_attribute *attr,
2271                                            char *buf)
2272 {
2273         struct wl1271 *wl = dev_get_drvdata(dev);
2274         ssize_t len;
2275
2276         /* FIXME: what's the maximum length of buf? page size?*/
2277         len = 500;
2278
2279         mutex_lock(&wl->mutex);
2280         if (wl->hw_pg_ver >= 0)
2281                 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
2282         else
2283                 len = snprintf(buf, len, "n/a\n");
2284         mutex_unlock(&wl->mutex);
2285
2286         return len;
2287 }
2288
2289 static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
2290                    wl1271_sysfs_show_hw_pg_ver, NULL);
2291
2292 int wl1271_register_hw(struct wl1271 *wl)
2293 {
2294         int ret;
2295
2296         if (wl->mac80211_registered)
2297                 return 0;
2298
2299         SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2300
2301         ret = ieee80211_register_hw(wl->hw);
2302         if (ret < 0) {
2303                 wl1271_error("unable to register mac80211 hw: %d", ret);
2304                 return ret;
2305         }
2306
2307         wl->mac80211_registered = true;
2308
2309         wl1271_notice("loaded");
2310
2311         return 0;
2312 }
2313 EXPORT_SYMBOL_GPL(wl1271_register_hw);
2314
2315 void wl1271_unregister_hw(struct wl1271 *wl)
2316 {
2317         ieee80211_unregister_hw(wl->hw);
2318         wl->mac80211_registered = false;
2319
2320 }
2321 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2322
2323 int wl1271_init_ieee80211(struct wl1271 *wl)
2324 {
2325         /* The tx descriptor buffer and the TKIP space. */
2326         wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2327                 sizeof(struct wl1271_tx_hw_descr);
2328
2329         /* unit us */
2330         /* FIXME: find a proper value */
2331         wl->hw->channel_change_time = 10000;
2332         wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
2333
2334         wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
2335                 IEEE80211_HW_BEACON_FILTER |
2336                 IEEE80211_HW_SUPPORTS_PS |
2337                 IEEE80211_HW_SUPPORTS_UAPSD |
2338                 IEEE80211_HW_HAS_RATE_CONTROL |
2339                 IEEE80211_HW_CONNECTION_MONITOR |
2340                 IEEE80211_HW_SUPPORTS_CQM_RSSI;
2341
2342         wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2343                 BIT(NL80211_IFTYPE_ADHOC);
2344         wl->hw->wiphy->max_scan_ssids = 1;
2345         wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2346
2347         if (wl1271_11a_enabled())
2348                 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2349
2350         wl->hw->queues = 4;
2351         wl->hw->max_rates = 1;
2352
2353         SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
2354
2355         return 0;
2356 }
2357 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
2358
2359 #define WL1271_DEFAULT_CHANNEL 0
2360
2361 struct ieee80211_hw *wl1271_alloc_hw(void)
2362 {
2363         struct ieee80211_hw *hw;
2364         struct platform_device *plat_dev = NULL;
2365         struct wl1271 *wl;
2366         int i, ret;
2367
2368         hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2369         if (!hw) {
2370                 wl1271_error("could not alloc ieee80211_hw");
2371                 ret = -ENOMEM;
2372                 goto err_hw_alloc;
2373         }
2374
2375         plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
2376         if (!plat_dev) {
2377                 wl1271_error("could not allocate platform_device");
2378                 ret = -ENOMEM;
2379                 goto err_plat_alloc;
2380         }
2381
2382         wl = hw->priv;
2383         memset(wl, 0, sizeof(*wl));
2384
2385         INIT_LIST_HEAD(&wl->list);
2386
2387         wl->hw = hw;
2388         wl->plat_dev = plat_dev;
2389
2390         skb_queue_head_init(&wl->tx_queue);
2391
2392         INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
2393         INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
2394         wl->channel = WL1271_DEFAULT_CHANNEL;
2395         wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
2396         wl->default_key = 0;
2397         wl->rx_counter = 0;
2398         wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2399         wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
2400         wl->psm_entry_retry = 0;
2401         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2402         wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2403         wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
2404         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2405         wl->sta_rate_set = 0;
2406         wl->band = IEEE80211_BAND_2GHZ;
2407         wl->vif = NULL;
2408         wl->flags = 0;
2409         wl->sg_enabled = true;
2410         wl->hw_pg_ver = -1;
2411
2412         for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
2413                 wl->tx_frames[i] = NULL;
2414
2415         spin_lock_init(&wl->wl_lock);
2416
2417         wl->state = WL1271_STATE_OFF;
2418         mutex_init(&wl->mutex);
2419
2420         /* Apply default driver configuration. */
2421         wl1271_conf_init(wl);
2422
2423         wl1271_debugfs_init(wl);
2424
2425         /* Register platform device */
2426         ret = platform_device_register(wl->plat_dev);
2427         if (ret) {
2428                 wl1271_error("couldn't register platform device");
2429                 goto err_hw;
2430         }
2431         dev_set_drvdata(&wl->plat_dev->dev, wl);
2432
2433         /* Create sysfs file to control bt coex state */
2434         ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2435         if (ret < 0) {
2436                 wl1271_error("failed to create sysfs file bt_coex_state");
2437                 goto err_platform;
2438         }
2439
2440         /* Create sysfs file to get HW PG version */
2441         ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
2442         if (ret < 0) {
2443                 wl1271_error("failed to create sysfs file hw_pg_ver");
2444                 goto err_bt_coex_state;
2445         }
2446
2447         return hw;
2448
2449 err_bt_coex_state:
2450         device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2451
2452 err_platform:
2453         platform_device_unregister(wl->plat_dev);
2454
2455 err_hw:
2456         wl1271_debugfs_exit(wl);
2457         kfree(plat_dev);
2458
2459 err_plat_alloc:
2460         ieee80211_free_hw(hw);
2461
2462 err_hw_alloc:
2463
2464         return ERR_PTR(ret);
2465 }
2466 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
2467
2468 int wl1271_free_hw(struct wl1271 *wl)
2469 {
2470         platform_device_unregister(wl->plat_dev);
2471         kfree(wl->plat_dev);
2472
2473         wl1271_debugfs_exit(wl);
2474
2475         vfree(wl->fw);
2476         wl->fw = NULL;
2477         kfree(wl->nvs);
2478         wl->nvs = NULL;
2479
2480         kfree(wl->fw_status);
2481         kfree(wl->tx_res_if);
2482
2483         ieee80211_free_hw(wl->hw);
2484
2485         return 0;
2486 }
2487 EXPORT_SYMBOL_GPL(wl1271_free_hw);
2488
2489 MODULE_LICENSE("GPL");
2490 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2491 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");