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