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