drivers/net/wireless/wl12xx/wl1271_main.c

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