drivers/net/wireless/wl12xx/wl1271_main.c

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