drivers/net/wireless/wl12xx/wl1271_main.c

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