drivers/net/wireless/wl12xx/wl1271_main.c

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