drivers/net/wireless/wl12xx/wl1271_main.c

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