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