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