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