SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/net/wireless/wl12xx/wl1271_main.c

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