drivers/net/wireless/wl12xx/wl1271_main.c

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