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