drivers/net/wireless/wl12xx/wl1271_main.c

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