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