drivers/net/wireless/wl12xx/wl1271_main.c

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