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_fetch_nvs(struct wl1271 *wl)
 574 {
 575         const struct firmware *fw;
 576         int ret;
 577
 578         ret = request_firmware(&fw, WL1271_NVS_NAME, wl1271_wl_to_dev(wl));
 579
 580         if (ret < 0) {
 581                 wl1271_error("could not get nvs file: %d", ret);
 582                 return ret;
 583         }
 584
 585         if (fw->size != sizeof(struct wl1271_nvs_file)) {
 586                 wl1271_error("nvs size is not as expected: %zu != %zu",
 587                              fw->size, sizeof(struct wl1271_nvs_file));
 588                 ret = -EILSEQ;
 589                 goto out;
 590         }
 591
 592         wl->nvs = kmalloc(sizeof(struct wl1271_nvs_file), GFP_KERNEL);
 593
 594         if (!wl->nvs) {
 595                 wl1271_error("could not allocate memory for the nvs file");
 596                 ret = -ENOMEM;
 597                 goto out;
 598         }
 599
 600         memcpy(wl->nvs, fw->data, sizeof(struct wl1271_nvs_file));
 601
 602 out:
 603         release_firmware(fw);
 604
 605         return ret;
 606 }
 607
 608 static void wl1271_fw_wakeup(struct wl1271 *wl)
 609 {
 610         u32 elp_reg;
 611
 612         elp_reg = ELPCTRL_WAKE_UP;
 613         wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
 614 }
 615
 616 static int wl1271_setup(struct wl1271 *wl)
 617 {
 618         wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
 619         if (!wl->fw_status)
 620                 return -ENOMEM;
 621
 622         wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
 623         if (!wl->tx_res_if) {
 624                 kfree(wl->fw_status);
 625                 return -ENOMEM;
 626         }
 627
 628         INIT_WORK(&wl->irq_work, wl1271_irq_work);
 629         INIT_WORK(&wl->tx_work, wl1271_tx_work);
 630         return 0;
 631 }
 632
 633 static int wl1271_chip_wakeup(struct wl1271 *wl)
 634 {
 635         struct wl1271_partition_set partition;
 636         int ret = 0;
 637
 638         msleep(WL1271_PRE_POWER_ON_SLEEP);
 639         wl1271_power_on(wl);
 640         msleep(WL1271_POWER_ON_SLEEP);
 641         wl1271_io_reset(wl);
 642         wl1271_io_init(wl);
 643
 644         /* We don't need a real memory partition here, because we only want
 645          * to use the registers at this point. */
 646         memset(&partition, 0, sizeof(partition));
 647         partition.reg.start = REGISTERS_BASE;
 648         partition.reg.size = REGISTERS_DOWN_SIZE;
 649         wl1271_set_partition(wl, &partition);
 650
 651         /* ELP module wake up */
 652         wl1271_fw_wakeup(wl);
 653
 654         /* whal_FwCtrl_BootSm() */
 655
 656         /* 0. read chip id from CHIP_ID */
 657         wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
 658
 659         /* 1. check if chip id is valid */
 660
 661         switch (wl->chip.id) {
 662         case CHIP_ID_1271_PG10:
 663                 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
 664                                wl->chip.id);
 665
 666                 ret = wl1271_setup(wl);
 667                 if (ret < 0)
 668                         goto out;
 669                 break;
 670         case CHIP_ID_1271_PG20:
 671                 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
 672                              wl->chip.id);
 673
 674                 ret = wl1271_setup(wl);
 675                 if (ret < 0)
 676                         goto out;
 677                 break;
 678         default:
 679                 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
 680                 ret = -ENODEV;
 681                 goto out;
 682         }
 683
 684         if (wl->fw == NULL) {
 685                 ret = wl1271_fetch_firmware(wl);
 686                 if (ret < 0)
 687                         goto out;
 688         }
 689
 690         /* No NVS from netlink, try to get it from the filesystem */
 691         if (wl->nvs == NULL) {
 692                 ret = wl1271_fetch_nvs(wl);
 693                 if (ret < 0)
 694                         goto out;
 695         }
 696
 697 out:
 698         return ret;
 699 }
 700
 701 int wl1271_plt_start(struct wl1271 *wl)
 702 {
 703         int retries = WL1271_BOOT_RETRIES;
 704         int ret;
 705
 706         mutex_lock(&wl->mutex);
 707
 708         wl1271_notice("power up");
 709
 710         if (wl->state != WL1271_STATE_OFF) {
 711                 wl1271_error("cannot go into PLT state because not "
 712                              "in off state: %d", wl->state);
 713                 ret = -EBUSY;
 714                 goto out;
 715         }
 716
 717         while (retries) {
 718                 retries--;
 719                 ret = wl1271_chip_wakeup(wl);
 720                 if (ret < 0)
 721                         goto power_off;
 722
 723                 ret = wl1271_boot(wl);
 724                 if (ret < 0)
 725                         goto power_off;
 726
 727                 ret = wl1271_plt_init(wl);
 728                 if (ret < 0)
 729                         goto irq_disable;
 730
 731                 wl->state = WL1271_STATE_PLT;
 732                 wl1271_notice("firmware booted in PLT mode (%s)",
 733                               wl->chip.fw_ver);
 734                 goto out;
 735
 736 irq_disable:
 737                 wl1271_disable_interrupts(wl);
 738                 mutex_unlock(&wl->mutex);
 739                 /* Unlocking the mutex in the middle of handling is
 740                    inherently unsafe. In this case we deem it safe to do,
 741                    because we need to let any possibly pending IRQ out of
 742                    the system (and while we are WL1271_STATE_OFF the IRQ
 743                    work function will not do anything.) Also, any other
 744                    possible concurrent operations will fail due to the
 745                    current state, hence the wl1271 struct should be safe. */
 746                 cancel_work_sync(&wl->irq_work);
 747                 mutex_lock(&wl->mutex);
 748 power_off:
 749                 wl1271_power_off(wl);
 750         }
 751
 752         wl1271_error("firmware boot in PLT mode failed despite %d retries",
 753                      WL1271_BOOT_RETRIES);
 754 out:
 755         mutex_unlock(&wl->mutex);
 756
 757         return ret;
 758 }
 759
 760 int wl1271_plt_stop(struct wl1271 *wl)
 761 {
 762         int ret = 0;
 763
 764         mutex_lock(&wl->mutex);
 765
 766         wl1271_notice("power down");
 767
 768         if (wl->state != WL1271_STATE_PLT) {
 769                 wl1271_error("cannot power down because not in PLT "
 770                              "state: %d", wl->state);
 771                 ret = -EBUSY;
 772                 goto out;
 773         }
 774
 775         wl1271_disable_interrupts(wl);
 776         wl1271_power_off(wl);
 777
 778         wl->state = WL1271_STATE_OFF;
 779         wl->rx_counter = 0;
 780
 781 out:
 782         mutex_unlock(&wl->mutex);
 783
 784         return ret;
 785 }
 786
 787
 788 static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
 789 {
 790         struct wl1271 *wl = hw->priv;
 791         struct ieee80211_conf *conf = &hw->conf;
 792         struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
 793         struct ieee80211_sta *sta = txinfo->control.sta;
 794         unsigned long flags;
 795
 796         /* peek into the rates configured in the STA entry */
 797         spin_lock_irqsave(&wl->wl_lock, flags);
 798         if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
 799                 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
 800                 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
 801         }
 802         spin_unlock_irqrestore(&wl->wl_lock, flags);
 803
 804         /* queue the packet */
 805         skb_queue_tail(&wl->tx_queue, skb);
 806
 807         /*
 808          * The chip specific setup must run before the first TX packet -
 809          * before that, the tx_work will not be initialized!
 810          */
 811
 812         ieee80211_queue_work(wl->hw, &wl->tx_work);
 813
 814         /*
 815          * The workqueue is slow to process the tx_queue and we need stop
 816          * the queue here, otherwise the queue will get too long.
 817          */
 818         if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
 819                 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
 820
 821                 spin_lock_irqsave(&wl->wl_lock, flags);
 822                 ieee80211_stop_queues(wl->hw);
 823                 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
 824                 spin_unlock_irqrestore(&wl->wl_lock, flags);
 825         }
 826
 827         return NETDEV_TX_OK;
 828 }
 829
 830 static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
 831                              void *arg)
 832 {
 833         struct net_device *dev;
 834         struct wireless_dev *wdev;
 835         struct wiphy *wiphy;
 836         struct ieee80211_hw *hw;
 837         struct wl1271 *wl;
 838         struct wl1271 *wl_temp;
 839         struct in_device *idev;
 840         struct in_ifaddr *ifa = arg;
 841         int ret = 0;
 842
 843         /* FIXME: this ugly function should probably be implemented in the
 844          * mac80211, and here should only be a simple callback handling actual
 845          * setting of the filters. Now we need to dig up references to
 846          * various structures to gain access to what we need.
 847          * Also, because of this, there is no "initial" setting of the filter
 848          * in "op_start", because we don't want to dig up struct net_device
 849          * there - the filter will be set upon first change of the interface
 850          * IP address. */
 851
 852         dev = ifa->ifa_dev->dev;
 853
 854         wdev = dev->ieee80211_ptr;
 855         if (wdev == NULL)
 856                 return NOTIFY_DONE;
 857
 858         wiphy = wdev->wiphy;
 859         if (wiphy == NULL)
 860                 return NOTIFY_DONE;
 861
 862         hw = wiphy_priv(wiphy);
 863         if (hw == NULL)
 864                 return NOTIFY_DONE;
 865
 866         /* Check that the interface is one supported by this driver. */
 867         wl_temp = hw->priv;
 868         list_for_each_entry(wl, &wl_list, list) {
 869                 if (wl == wl_temp)
 870                         break;
 871         }
 872         if (wl == NULL)
 873                 return NOTIFY_DONE;
 874
 875         /* Get the interface IP address for the device. "ifa" will become
 876            NULL if:
 877              - there is no IPV4 protocol address configured
 878              - there are multiple (virtual) IPV4 addresses configured
 879            When "ifa" is NULL, filtering will be disabled.
 880         */
 881         ifa = NULL;
 882         idev = dev->ip_ptr;
 883         if (idev)
 884                 ifa = idev->ifa_list;
 885
 886         if (ifa && ifa->ifa_next)
 887                 ifa = NULL;
 888
 889         mutex_lock(&wl->mutex);
 890
 891         if (wl->state == WL1271_STATE_OFF)
 892                 goto out;
 893
 894         ret = wl1271_ps_elp_wakeup(wl, false);
 895         if (ret < 0)
 896                 goto out;
 897         if (ifa)
 898                 ret = wl1271_acx_arp_ip_filter(wl, true,
 899                                                (u8 *)&ifa->ifa_address,
 900                                                ACX_IPV4_VERSION);
 901         else
 902                 ret = wl1271_acx_arp_ip_filter(wl, false, NULL,
 903                                                ACX_IPV4_VERSION);
 904         wl1271_ps_elp_sleep(wl);
 905
 906 out:
 907         mutex_unlock(&wl->mutex);
 908
 909         return NOTIFY_OK;
 910 }
 911
 912 static struct notifier_block wl1271_dev_notifier = {
 913         .notifier_call = wl1271_dev_notify,
 914 };
 915
 916
 917 static int wl1271_op_start(struct ieee80211_hw *hw)
 918 {
 919         wl1271_debug(DEBUG_MAC80211, "mac80211 start");
 920
 921         /*
 922          * We have to delay the booting of the hardware because
 923          * we need to know the local MAC address before downloading and
 924          * initializing the firmware. The MAC address cannot be changed
 925          * after boot, and without the proper MAC address, the firmware
 926          * will not function properly.
 927          *
 928          * The MAC address is first known when the corresponding interface
 929          * is added. That is where we will initialize the hardware.
 930          */
 931
 932         return 0;
 933 }
 934
 935 static void wl1271_op_stop(struct ieee80211_hw *hw)
 936 {
 937         wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
 938 }
 939
 940 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
 941                                    struct ieee80211_vif *vif)
 942 {
 943         struct wl1271 *wl = hw->priv;
 944         int retries = WL1271_BOOT_RETRIES;
 945         int ret = 0;
 946
 947         wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
 948                      vif->type, vif->addr);
 949
 950         mutex_lock(&wl->mutex);
 951         if (wl->vif) {
 952                 ret = -EBUSY;
 953                 goto out;
 954         }
 955
 956         wl->vif = vif;
 957
 958         switch (vif->type) {
 959         case NL80211_IFTYPE_STATION:
 960                 wl->bss_type = BSS_TYPE_STA_BSS;
 961                 break;
 962         case NL80211_IFTYPE_ADHOC:
 963                 wl->bss_type = BSS_TYPE_IBSS;
 964                 break;
 965         default:
 966                 ret = -EOPNOTSUPP;
 967                 goto out;
 968         }
 969
 970         memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
 971
 972         if (wl->state != WL1271_STATE_OFF) {
 973                 wl1271_error("cannot start because not in off state: %d",
 974                              wl->state);
 975                 ret = -EBUSY;
 976                 goto out;
 977         }
 978
 979         while (retries) {
 980                 retries--;
 981                 ret = wl1271_chip_wakeup(wl);
 982                 if (ret < 0)
 983                         goto power_off;
 984
 985                 ret = wl1271_boot(wl);
 986                 if (ret < 0)
 987                         goto power_off;
 988
 989                 ret = wl1271_hw_init(wl);
 990                 if (ret < 0)
 991                         goto irq_disable;
 992
 993                 wl->state = WL1271_STATE_ON;
 994                 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
 995                 goto out;
 996
 997 irq_disable:
 998                 wl1271_disable_interrupts(wl);
 999                 mutex_unlock(&wl->mutex);
1000                 /* Unlocking the mutex in the middle of handling is
1001                    inherently unsafe. In this case we deem it safe to do,
1002                    because we need to let any possibly pending IRQ out of
1003                    the system (and while we are WL1271_STATE_OFF the IRQ
1004                    work function will not do anything.) Also, any other
1005                    possible concurrent operations will fail due to the
1006                    current state, hence the wl1271 struct should be safe. */
1007                 cancel_work_sync(&wl->irq_work);
1008                 mutex_lock(&wl->mutex);
1009 power_off:
1010                 wl1271_power_off(wl);
1011         }
1012
1013         wl1271_error("firmware boot failed despite %d retries",
1014                      WL1271_BOOT_RETRIES);
1015 out:
1016         mutex_unlock(&wl->mutex);
1017
1018         if (!ret) {
1019                 list_add(&wl->list, &wl_list);
1020                 register_inetaddr_notifier(&wl1271_dev_notifier);
1021         }
1022
1023         return ret;
1024 }
1025
1026 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1027                                        struct ieee80211_vif *vif)
1028 {
1029         struct wl1271 *wl = hw->priv;
1030         int i;
1031
1032         mutex_lock(&wl->mutex);
1033         wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1034
1035         wl1271_info("down");
1036
1037         unregister_inetaddr_notifier(&wl1271_dev_notifier);
1038         list_del(&wl->list);
1039
1040         WARN_ON(wl->state != WL1271_STATE_ON);
1041
1042         if (test_and_clear_bit(WL1271_FLAG_SCANNING, &wl->flags)) {
1043                 mutex_unlock(&wl->mutex);
1044                 ieee80211_scan_completed(wl->hw, true);
1045                 mutex_lock(&wl->mutex);
1046         }
1047
1048         wl->state = WL1271_STATE_OFF;
1049
1050         wl1271_disable_interrupts(wl);
1051
1052         mutex_unlock(&wl->mutex);
1053
1054         cancel_work_sync(&wl->irq_work);
1055         cancel_work_sync(&wl->tx_work);
1056
1057         mutex_lock(&wl->mutex);
1058
1059         /* let's notify MAC80211 about the remaining pending TX frames */
1060         wl1271_tx_flush(wl);
1061         wl1271_power_off(wl);
1062
1063         memset(wl->bssid, 0, ETH_ALEN);
1064         memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1065         wl->ssid_len = 0;
1066         wl->bss_type = MAX_BSS_TYPE;
1067         wl->band = IEEE80211_BAND_2GHZ;
1068
1069         wl->rx_counter = 0;
1070         wl->psm_entry_retry = 0;
1071         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1072         wl->tx_blocks_available = 0;
1073         wl->tx_results_count = 0;
1074         wl->tx_packets_count = 0;
1075         wl->tx_security_last_seq = 0;
1076         wl->tx_security_seq = 0;
1077         wl->time_offset = 0;
1078         wl->session_counter = 0;
1079         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1080         wl->sta_rate_set = 0;
1081         wl->flags = 0;
1082         wl->vif = NULL;
1083
1084         for (i = 0; i < NUM_TX_QUEUES; i++)
1085                 wl->tx_blocks_freed[i] = 0;
1086
1087         wl1271_debugfs_reset(wl);
1088         mutex_unlock(&wl->mutex);
1089 }
1090
1091 static int wl1271_join_channel(struct wl1271 *wl, int channel)
1092 {
1093         int ret = 0;
1094         /* we need to use a dummy BSSID for now */
1095         static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1096                                                   0xad, 0xbe, 0xef };
1097
1098         /* disable mac filter, so we hear everything */
1099         wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1100
1101         wl->channel = channel;
1102         memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1103
1104         /* the dummy join is performed always with STATION BSS type to allow
1105            also ad-hoc mode to listen to the surroundings without sending any
1106            beacons yet. */
1107         ret = wl1271_cmd_join(wl, BSS_TYPE_STA_BSS);
1108         if (ret < 0)
1109                 goto out;
1110
1111         set_bit(WL1271_FLAG_JOINED, &wl->flags);
1112
1113 out:
1114         return ret;
1115 }
1116
1117 static int wl1271_unjoin_channel(struct wl1271 *wl)
1118 {
1119         int ret;
1120
1121         /* to stop listening to a channel, we disconnect */
1122         ret = wl1271_cmd_disconnect(wl);
1123         if (ret < 0)
1124                 goto out;
1125
1126         clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1127         wl->channel = 0;
1128         memset(wl->bssid, 0, ETH_ALEN);
1129         wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1130
1131 out:
1132         return ret;
1133 }
1134
1135 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1136 {
1137         struct wl1271 *wl = hw->priv;
1138         struct ieee80211_conf *conf = &hw->conf;
1139         int channel, ret = 0;
1140
1141         channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1142
1143         wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
1144                      channel,
1145                      conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1146                      conf->power_level,
1147                      conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
1148
1149         mutex_lock(&wl->mutex);
1150
1151         wl->band = conf->channel->band;
1152
1153         ret = wl1271_ps_elp_wakeup(wl, false);
1154         if (ret < 0)
1155                 goto out;
1156
1157         if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1158                 if (conf->flags & IEEE80211_CONF_IDLE &&
1159                     test_bit(WL1271_FLAG_JOINED, &wl->flags))
1160                         wl1271_unjoin_channel(wl);
1161                 else if (!(conf->flags & IEEE80211_CONF_IDLE))
1162                         wl1271_join_channel(wl, channel);
1163
1164                 if (conf->flags & IEEE80211_CONF_IDLE) {
1165                         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1166                         wl->sta_rate_set = 0;
1167                         wl1271_acx_rate_policies(wl);
1168                 }
1169         }
1170
1171         /* if the channel changes while joined, join again */
1172         if (channel != wl->channel &&
1173             test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1174                 wl->channel = channel;
1175                 /* FIXME: maybe use CMD_CHANNEL_SWITCH for this? */
1176                 ret = wl1271_cmd_join(wl, wl->bss_type);
1177                 if (ret < 0)
1178                         wl1271_warning("cmd join to update channel failed %d",
1179                                        ret);
1180         } else
1181                 wl->channel = channel;
1182
1183         if (conf->flags & IEEE80211_CONF_PS &&
1184             !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1185                 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1186
1187                 /*
1188                  * We enter PSM only if we're already associated.
1189                  * If we're not, we'll enter it when joining an SSID,
1190                  * through the bss_info_changed() hook.
1191                  */
1192                 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1193                         wl1271_debug(DEBUG_PSM, "psm enabled");
1194                         ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1195                                                  true);
1196                 }
1197         } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1198                    test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1199                 wl1271_debug(DEBUG_PSM, "psm disabled");
1200
1201                 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1202
1203                 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1204                         ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1205                                                  true);
1206         }
1207
1208         if (conf->power_level != wl->power_level) {
1209                 ret = wl1271_acx_tx_power(wl, conf->power_level);
1210                 if (ret < 0)
1211                         goto out_sleep;
1212
1213                 wl->power_level = conf->power_level;
1214         }
1215
1216 out_sleep:
1217         wl1271_ps_elp_sleep(wl);
1218
1219 out:
1220         mutex_unlock(&wl->mutex);
1221
1222         return ret;
1223 }
1224
1225 struct wl1271_filter_params {
1226         bool enabled;
1227         int mc_list_length;
1228         u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1229 };
1230
1231 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw, int mc_count,
1232                                        struct dev_addr_list *mc_list)
1233 {
1234         struct wl1271_filter_params *fp;
1235         int i;
1236
1237         fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1238         if (!fp) {
1239                 wl1271_error("Out of memory setting filters.");
1240                 return 0;
1241         }
1242
1243         /* update multicast filtering parameters */
1244         fp->enabled = true;
1245         if (mc_count > ACX_MC_ADDRESS_GROUP_MAX) {
1246                 mc_count = 0;
1247                 fp->enabled = false;
1248         }
1249
1250         fp->mc_list_length = 0;
1251         for (i = 0; i < mc_count; i++) {
1252                 if (mc_list->da_addrlen == ETH_ALEN) {
1253                         memcpy(fp->mc_list[fp->mc_list_length],
1254                                mc_list->da_addr, ETH_ALEN);
1255                         fp->mc_list_length++;
1256                 } else
1257                         wl1271_warning("Unknown mc address length.");
1258                 mc_list = mc_list->next;
1259         }
1260
1261         return (u64)(unsigned long)fp;
1262 }
1263
1264 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1265                                   FIF_ALLMULTI | \
1266                                   FIF_FCSFAIL | \
1267                                   FIF_BCN_PRBRESP_PROMISC | \
1268                                   FIF_CONTROL | \
1269                                   FIF_OTHER_BSS)
1270
1271 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1272                                        unsigned int changed,
1273                                        unsigned int *total, u64 multicast)
1274 {
1275         struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1276         struct wl1271 *wl = hw->priv;
1277         int ret;
1278
1279         wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1280
1281         mutex_lock(&wl->mutex);
1282
1283         if (wl->state == WL1271_STATE_OFF)
1284                 goto out;
1285
1286         ret = wl1271_ps_elp_wakeup(wl, false);
1287         if (ret < 0)
1288                 goto out;
1289
1290         *total &= WL1271_SUPPORTED_FILTERS;
1291         changed &= WL1271_SUPPORTED_FILTERS;
1292
1293         if (*total & FIF_ALLMULTI)
1294                 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1295         else if (fp)
1296                 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1297                                                    fp->mc_list,
1298                                                    fp->mc_list_length);
1299         if (ret < 0)
1300                 goto out_sleep;
1301
1302         kfree(fp);
1303
1304         /* FIXME: We still need to set our filters properly */
1305
1306         /* determine, whether supported filter values have changed */
1307         if (changed == 0)
1308                 goto out_sleep;
1309
1310         /* apply configured filters */
1311         ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1312         if (ret < 0)
1313                 goto out_sleep;
1314
1315 out_sleep:
1316         wl1271_ps_elp_sleep(wl);
1317
1318 out:
1319         mutex_unlock(&wl->mutex);
1320 }
1321
1322 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1323                              struct ieee80211_vif *vif,
1324                              struct ieee80211_sta *sta,
1325                              struct ieee80211_key_conf *key_conf)
1326 {
1327         struct wl1271 *wl = hw->priv;
1328         const u8 *addr;
1329         int ret;
1330         u32 tx_seq_32 = 0;
1331         u16 tx_seq_16 = 0;
1332         u8 key_type;
1333
1334         static const u8 bcast_addr[ETH_ALEN] =
1335                 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1336
1337         wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1338
1339         addr = sta ? sta->addr : bcast_addr;
1340
1341         wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1342         wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1343         wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1344                      key_conf->alg, key_conf->keyidx,
1345                      key_conf->keylen, key_conf->flags);
1346         wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1347
1348         if (is_zero_ether_addr(addr)) {
1349                 /* We dont support TX only encryption */
1350                 ret = -EOPNOTSUPP;
1351                 goto out;
1352         }
1353
1354         mutex_lock(&wl->mutex);
1355
1356         ret = wl1271_ps_elp_wakeup(wl, false);
1357         if (ret < 0)
1358                 goto out_unlock;
1359
1360         switch (key_conf->alg) {
1361         case ALG_WEP:
1362                 key_type = KEY_WEP;
1363
1364                 key_conf->hw_key_idx = key_conf->keyidx;
1365                 break;
1366         case ALG_TKIP:
1367                 key_type = KEY_TKIP;
1368
1369                 key_conf->hw_key_idx = key_conf->keyidx;
1370                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1371                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1372                 break;
1373         case ALG_CCMP:
1374                 key_type = KEY_AES;
1375
1376                 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1377                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1378                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1379                 break;
1380         default:
1381                 wl1271_error("Unknown key algo 0x%x", key_conf->alg);
1382
1383                 ret = -EOPNOTSUPP;
1384                 goto out_sleep;
1385         }
1386
1387         switch (cmd) {
1388         case SET_KEY:
1389                 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1390                                          key_conf->keyidx, key_type,
1391                                          key_conf->keylen, key_conf->key,
1392                                          addr, tx_seq_32, tx_seq_16);
1393                 if (ret < 0) {
1394                         wl1271_error("Could not add or replace key");
1395                         goto out_sleep;
1396                 }
1397
1398                 /* the default WEP key needs to be configured at least once */
1399                 if (key_type == KEY_WEP) {
1400                         ret = wl1271_cmd_set_default_wep_key(wl,
1401                                                              wl->default_key);
1402                         if (ret < 0)
1403                                 goto out_sleep;
1404                 }
1405                 break;
1406
1407         case DISABLE_KEY:
1408                 /* The wl1271 does not allow to remove unicast keys - they
1409                    will be cleared automatically on next CMD_JOIN. Ignore the
1410                    request silently, as we dont want the mac80211 to emit
1411                    an error message. */
1412                 if (!is_broadcast_ether_addr(addr))
1413                         break;
1414
1415                 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1416                                          key_conf->keyidx, key_type,
1417                                          key_conf->keylen, key_conf->key,
1418                                          addr, 0, 0);
1419                 if (ret < 0) {
1420                         wl1271_error("Could not remove key");
1421                         goto out_sleep;
1422                 }
1423                 break;
1424
1425         default:
1426                 wl1271_error("Unsupported key cmd 0x%x", cmd);
1427                 ret = -EOPNOTSUPP;
1428                 goto out_sleep;
1429
1430                 break;
1431         }
1432
1433 out_sleep:
1434         wl1271_ps_elp_sleep(wl);
1435
1436 out_unlock:
1437         mutex_unlock(&wl->mutex);
1438
1439 out:
1440         return ret;
1441 }
1442
1443 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1444                              struct cfg80211_scan_request *req)
1445 {
1446         struct wl1271 *wl = hw->priv;
1447         int ret;
1448         u8 *ssid = NULL;
1449         size_t len = 0;
1450
1451         wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1452
1453         if (req->n_ssids) {
1454                 ssid = req->ssids[0].ssid;
1455                 len = req->ssids[0].ssid_len;
1456         }
1457
1458         mutex_lock(&wl->mutex);
1459
1460         ret = wl1271_ps_elp_wakeup(wl, false);
1461         if (ret < 0)
1462                 goto out;
1463
1464         if (wl1271_11a_enabled())
1465                 ret = wl1271_cmd_scan(hw->priv, ssid, len,
1466                                       req->ie, req->ie_len, 1, 0,
1467                                       WL1271_SCAN_BAND_DUAL, 3);
1468         else
1469                 ret = wl1271_cmd_scan(hw->priv, ssid, len,
1470                                       req->ie, req->ie_len, 1, 0,
1471                                       WL1271_SCAN_BAND_2_4_GHZ, 3);
1472
1473         wl1271_ps_elp_sleep(wl);
1474
1475 out:
1476         mutex_unlock(&wl->mutex);
1477
1478         return ret;
1479 }
1480
1481 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1482 {
1483         struct wl1271 *wl = hw->priv;
1484         int ret;
1485
1486         mutex_lock(&wl->mutex);
1487
1488         ret = wl1271_ps_elp_wakeup(wl, false);
1489         if (ret < 0)
1490                 goto out;
1491
1492         ret = wl1271_acx_rts_threshold(wl, (u16) value);
1493         if (ret < 0)
1494                 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1495
1496         wl1271_ps_elp_sleep(wl);
1497
1498 out:
1499         mutex_unlock(&wl->mutex);
1500
1501         return ret;
1502 }
1503
1504 static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1505 {
1506         u8 *ptr = beacon->data +
1507                 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1508
1509         /* find the location of the ssid in the beacon */
1510         while (ptr < beacon->data + beacon->len) {
1511                 if (ptr[0] == WLAN_EID_SSID) {
1512                         wl->ssid_len = ptr[1];
1513                         memcpy(wl->ssid, ptr+2, wl->ssid_len);
1514                         return;
1515                 }
1516                 ptr += ptr[1];
1517         }
1518         wl1271_error("ad-hoc beacon template has no SSID!\n");
1519 }
1520
1521 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1522                                        struct ieee80211_vif *vif,
1523                                        struct ieee80211_bss_conf *bss_conf,
1524                                        u32 changed)
1525 {
1526         enum wl1271_cmd_ps_mode mode;
1527         struct wl1271 *wl = hw->priv;
1528         bool do_join = false;
1529         int ret;
1530
1531         wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1532
1533         mutex_lock(&wl->mutex);
1534
1535         ret = wl1271_ps_elp_wakeup(wl, false);
1536         if (ret < 0)
1537                 goto out;
1538
1539         if (wl->bss_type == BSS_TYPE_IBSS) {
1540                 /* FIXME: This implements rudimentary ad-hoc support -
1541                    proper templates are on the wish list and notification
1542                    on when they change. This patch will update the templates
1543                    on every call to this function. */
1544                 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1545
1546                 if (beacon) {
1547                         struct ieee80211_hdr *hdr;
1548
1549                         wl1271_ssid_set(wl, beacon);
1550                         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1551                                                       beacon->data,
1552                                                       beacon->len);
1553
1554                         if (ret < 0) {
1555                                 dev_kfree_skb(beacon);
1556                                 goto out_sleep;
1557                         }
1558
1559                         hdr = (struct ieee80211_hdr *) beacon->data;
1560                         hdr->frame_control = cpu_to_le16(
1561                                 IEEE80211_FTYPE_MGMT |
1562                                 IEEE80211_STYPE_PROBE_RESP);
1563
1564                         ret = wl1271_cmd_template_set(wl,
1565                                                       CMD_TEMPL_PROBE_RESPONSE,
1566                                                       beacon->data,
1567                                                       beacon->len);
1568                         dev_kfree_skb(beacon);
1569                         if (ret < 0)
1570                                 goto out_sleep;
1571
1572                         /* Need to update the SSID (for filtering etc) */
1573                         do_join = true;
1574                 }
1575         }
1576
1577         if ((changed & BSS_CHANGED_BSSID) &&
1578             /*
1579              * Now we know the correct bssid, so we send a new join command
1580              * and enable the BSSID filter
1581              */
1582             memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1583                         wl->rx_config |= CFG_BSSID_FILTER_EN;
1584                         memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1585                         ret = wl1271_cmd_build_null_data(wl);
1586                         if (ret < 0) {
1587                                 wl1271_warning("cmd buld null data failed %d",
1588                                                ret);
1589                                 goto out_sleep;
1590                         }
1591
1592                         /* Need to update the BSSID (for filtering etc) */
1593                         do_join = true;
1594         }
1595
1596         if (changed & BSS_CHANGED_ASSOC) {
1597                 if (bss_conf->assoc) {
1598                         wl->aid = bss_conf->aid;
1599                         set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1600
1601                         /*
1602                          * with wl1271, we don't need to update the
1603                          * beacon_int and dtim_period, because the firmware
1604                          * updates it by itself when the first beacon is
1605                          * received after a join.
1606                          */
1607                         ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1608                         if (ret < 0)
1609                                 goto out_sleep;
1610
1611                         ret = wl1271_acx_aid(wl, wl->aid);
1612                         if (ret < 0)
1613                                 goto out_sleep;
1614
1615                         /* If we want to go in PSM but we're not there yet */
1616                         if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1617                             !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1618                                 mode = STATION_POWER_SAVE_MODE;
1619                                 ret = wl1271_ps_set_mode(wl, mode, true);
1620                                 if (ret < 0)
1621                                         goto out_sleep;
1622                         }
1623                 } else {
1624                         /* use defaults when not associated */
1625                         clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1626                         wl->aid = 0;
1627                 }
1628
1629         }
1630
1631         if (changed & BSS_CHANGED_ERP_SLOT) {
1632                 if (bss_conf->use_short_slot)
1633                         ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1634                 else
1635                         ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1636                 if (ret < 0) {
1637                         wl1271_warning("Set slot time failed %d", ret);
1638                         goto out_sleep;
1639                 }
1640         }
1641
1642         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1643                 if (bss_conf->use_short_preamble)
1644                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1645                 else
1646                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1647         }
1648
1649         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1650                 if (bss_conf->use_cts_prot)
1651                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1652                 else
1653                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1654                 if (ret < 0) {
1655                         wl1271_warning("Set ctsprotect failed %d", ret);
1656                         goto out_sleep;
1657                 }
1658         }
1659
1660         if (do_join) {
1661                 ret = wl1271_cmd_join(wl, wl->bss_type);
1662                 if (ret < 0) {
1663                         wl1271_warning("cmd join failed %d", ret);
1664                         goto out_sleep;
1665                 }
1666                 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1667         }
1668
1669 out_sleep:
1670         wl1271_ps_elp_sleep(wl);
1671
1672 out:
1673         mutex_unlock(&wl->mutex);
1674 }
1675
1676 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1677                              const struct ieee80211_tx_queue_params *params)
1678 {
1679         struct wl1271 *wl = hw->priv;
1680         u8 ps_scheme;
1681         int ret;
1682
1683         mutex_lock(&wl->mutex);
1684
1685         wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1686
1687         ret = wl1271_ps_elp_wakeup(wl, false);
1688         if (ret < 0)
1689                 goto out;
1690
1691         /* the txop is confed in units of 32us by the mac80211, we need us */
1692         ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1693                                 params->cw_min, params->cw_max,
1694                                 params->aifs, params->txop << 5);
1695         if (ret < 0)
1696                 goto out_sleep;
1697
1698         if (params->uapsd)
1699                 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
1700         else
1701                 ps_scheme = CONF_PS_SCHEME_LEGACY;
1702
1703         ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1704                                  CONF_CHANNEL_TYPE_EDCF,
1705                                  wl1271_tx_get_queue(queue),
1706                                  ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
1707         if (ret < 0)
1708                 goto out_sleep;
1709
1710 out_sleep:
1711         wl1271_ps_elp_sleep(wl);
1712
1713 out:
1714         mutex_unlock(&wl->mutex);
1715
1716         return ret;
1717 }
1718
1719
1720 /* can't be const, mac80211 writes to this */
1721 static struct ieee80211_rate wl1271_rates[] = {
1722         { .bitrate = 10,
1723           .hw_value = CONF_HW_BIT_RATE_1MBPS,
1724           .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
1725         { .bitrate = 20,
1726           .hw_value = CONF_HW_BIT_RATE_2MBPS,
1727           .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
1728           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1729         { .bitrate = 55,
1730           .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1731           .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
1732           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1733         { .bitrate = 110,
1734           .hw_value = CONF_HW_BIT_RATE_11MBPS,
1735           .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
1736           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1737         { .bitrate = 60,
1738           .hw_value = CONF_HW_BIT_RATE_6MBPS,
1739           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1740         { .bitrate = 90,
1741           .hw_value = CONF_HW_BIT_RATE_9MBPS,
1742           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1743         { .bitrate = 120,
1744           .hw_value = CONF_HW_BIT_RATE_12MBPS,
1745           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1746         { .bitrate = 180,
1747           .hw_value = CONF_HW_BIT_RATE_18MBPS,
1748           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1749         { .bitrate = 240,
1750           .hw_value = CONF_HW_BIT_RATE_24MBPS,
1751           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1752         { .bitrate = 360,
1753          .hw_value = CONF_HW_BIT_RATE_36MBPS,
1754          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1755         { .bitrate = 480,
1756           .hw_value = CONF_HW_BIT_RATE_48MBPS,
1757           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1758         { .bitrate = 540,
1759           .hw_value = CONF_HW_BIT_RATE_54MBPS,
1760           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1761 };
1762
1763 /* can't be const, mac80211 writes to this */
1764 static struct ieee80211_channel wl1271_channels[] = {
1765         { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
1766         { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
1767         { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
1768         { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
1769         { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
1770         { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
1771         { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
1772         { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
1773         { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
1774         { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
1775         { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
1776         { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
1777         { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
1778 };
1779
1780 /* can't be const, mac80211 writes to this */
1781 static struct ieee80211_supported_band wl1271_band_2ghz = {
1782         .channels = wl1271_channels,
1783         .n_channels = ARRAY_SIZE(wl1271_channels),
1784         .bitrates = wl1271_rates,
1785         .n_bitrates = ARRAY_SIZE(wl1271_rates),
1786 };
1787
1788 /* 5 GHz data rates for WL1273 */
1789 static struct ieee80211_rate wl1271_rates_5ghz[] = {
1790         { .bitrate = 60,
1791           .hw_value = CONF_HW_BIT_RATE_6MBPS,
1792           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1793         { .bitrate = 90,
1794           .hw_value = CONF_HW_BIT_RATE_9MBPS,
1795           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1796         { .bitrate = 120,
1797           .hw_value = CONF_HW_BIT_RATE_12MBPS,
1798           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1799         { .bitrate = 180,
1800           .hw_value = CONF_HW_BIT_RATE_18MBPS,
1801           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1802         { .bitrate = 240,
1803           .hw_value = CONF_HW_BIT_RATE_24MBPS,
1804           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1805         { .bitrate = 360,
1806          .hw_value = CONF_HW_BIT_RATE_36MBPS,
1807          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1808         { .bitrate = 480,
1809           .hw_value = CONF_HW_BIT_RATE_48MBPS,
1810           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1811         { .bitrate = 540,
1812           .hw_value = CONF_HW_BIT_RATE_54MBPS,
1813           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1814 };
1815
1816 /* 5 GHz band channels for WL1273 */
1817 static struct ieee80211_channel wl1271_channels_5ghz[] = {
1818         { .hw_value = 183, .center_freq = 4915},
1819         { .hw_value = 184, .center_freq = 4920},
1820         { .hw_value = 185, .center_freq = 4925},
1821         { .hw_value = 187, .center_freq = 4935},
1822         { .hw_value = 188, .center_freq = 4940},
1823         { .hw_value = 189, .center_freq = 4945},
1824         { .hw_value = 192, .center_freq = 4960},
1825         { .hw_value = 196, .center_freq = 4980},
1826         { .hw_value = 7, .center_freq = 5035},
1827         { .hw_value = 8, .center_freq = 5040},
1828         { .hw_value = 9, .center_freq = 5045},
1829         { .hw_value = 11, .center_freq = 5055},
1830         { .hw_value = 12, .center_freq = 5060},
1831         { .hw_value = 16, .center_freq = 5080},
1832         { .hw_value = 34, .center_freq = 5170},
1833         { .hw_value = 36, .center_freq = 5180},
1834         { .hw_value = 38, .center_freq = 5190},
1835         { .hw_value = 40, .center_freq = 5200},
1836         { .hw_value = 42, .center_freq = 5210},
1837         { .hw_value = 44, .center_freq = 5220},
1838         { .hw_value = 46, .center_freq = 5230},
1839         { .hw_value = 48, .center_freq = 5240},
1840         { .hw_value = 52, .center_freq = 5260},
1841         { .hw_value = 56, .center_freq = 5280},
1842         { .hw_value = 60, .center_freq = 5300},
1843         { .hw_value = 64, .center_freq = 5320},
1844         { .hw_value = 100, .center_freq = 5500},
1845         { .hw_value = 104, .center_freq = 5520},
1846         { .hw_value = 108, .center_freq = 5540},
1847         { .hw_value = 112, .center_freq = 5560},
1848         { .hw_value = 116, .center_freq = 5580},
1849         { .hw_value = 120, .center_freq = 5600},
1850         { .hw_value = 124, .center_freq = 5620},
1851         { .hw_value = 128, .center_freq = 5640},
1852         { .hw_value = 132, .center_freq = 5660},
1853         { .hw_value = 136, .center_freq = 5680},
1854         { .hw_value = 140, .center_freq = 5700},
1855         { .hw_value = 149, .center_freq = 5745},
1856         { .hw_value = 153, .center_freq = 5765},
1857         { .hw_value = 157, .center_freq = 5785},
1858         { .hw_value = 161, .center_freq = 5805},
1859         { .hw_value = 165, .center_freq = 5825},
1860 };
1861
1862
1863 static struct ieee80211_supported_band wl1271_band_5ghz = {
1864         .channels = wl1271_channels_5ghz,
1865         .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
1866         .bitrates = wl1271_rates_5ghz,
1867         .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
1868 };
1869
1870 static const struct ieee80211_ops wl1271_ops = {
1871         .start = wl1271_op_start,
1872         .stop = wl1271_op_stop,
1873         .add_interface = wl1271_op_add_interface,
1874         .remove_interface = wl1271_op_remove_interface,
1875         .config = wl1271_op_config,
1876         .prepare_multicast = wl1271_op_prepare_multicast,
1877         .configure_filter = wl1271_op_configure_filter,
1878         .tx = wl1271_op_tx,
1879         .set_key = wl1271_op_set_key,
1880         .hw_scan = wl1271_op_hw_scan,
1881         .bss_info_changed = wl1271_op_bss_info_changed,
1882         .set_rts_threshold = wl1271_op_set_rts_threshold,
1883         .conf_tx = wl1271_op_conf_tx,
1884         CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
1885 };
1886
1887 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
1888                                                struct device_attribute *attr,
1889                                                char *buf)
1890 {
1891         struct wl1271 *wl = dev_get_drvdata(dev);
1892         ssize_t len;
1893
1894         /* FIXME: what's the maximum length of buf? page size?*/
1895         len = 500;
1896
1897         mutex_lock(&wl->mutex);
1898         len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
1899                        wl->sg_enabled);
1900         mutex_unlock(&wl->mutex);
1901
1902         return len;
1903
1904 }
1905
1906 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
1907                                                 struct device_attribute *attr,
1908                                                 const char *buf, size_t count)
1909 {
1910         struct wl1271 *wl = dev_get_drvdata(dev);
1911         unsigned long res;
1912         int ret;
1913
1914         ret = strict_strtoul(buf, 10, &res);
1915
1916         if (ret < 0) {
1917                 wl1271_warning("incorrect value written to bt_coex_mode");
1918                 return count;
1919         }
1920
1921         mutex_lock(&wl->mutex);
1922
1923         res = !!res;
1924
1925         if (res == wl->sg_enabled)
1926                 goto out;
1927
1928         wl->sg_enabled = res;
1929
1930         if (wl->state == WL1271_STATE_OFF)
1931                 goto out;
1932
1933         ret = wl1271_ps_elp_wakeup(wl, false);
1934         if (ret < 0)
1935                 goto out;
1936
1937         wl1271_acx_sg_enable(wl, wl->sg_enabled);
1938         wl1271_ps_elp_sleep(wl);
1939
1940  out:
1941         mutex_unlock(&wl->mutex);
1942         return count;
1943 }
1944
1945 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
1946                    wl1271_sysfs_show_bt_coex_state,
1947                    wl1271_sysfs_store_bt_coex_state);
1948
1949 int wl1271_register_hw(struct wl1271 *wl)
1950 {
1951         int ret;
1952
1953         if (wl->mac80211_registered)
1954                 return 0;
1955
1956         SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
1957
1958         ret = ieee80211_register_hw(wl->hw);
1959         if (ret < 0) {
1960                 wl1271_error("unable to register mac80211 hw: %d", ret);
1961                 return ret;
1962         }
1963
1964         wl->mac80211_registered = true;
1965
1966         wl1271_notice("loaded");
1967
1968         return 0;
1969 }
1970 EXPORT_SYMBOL_GPL(wl1271_register_hw);
1971
1972 int wl1271_init_ieee80211(struct wl1271 *wl)
1973 {
1974         /* The tx descriptor buffer and the TKIP space. */
1975         wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
1976                 sizeof(struct wl1271_tx_hw_descr);
1977
1978         /* unit us */
1979         /* FIXME: find a proper value */
1980         wl->hw->channel_change_time = 10000;
1981
1982         wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
1983                 IEEE80211_HW_NOISE_DBM |
1984                 IEEE80211_HW_BEACON_FILTER |
1985                 IEEE80211_HW_SUPPORTS_PS |
1986                 IEEE80211_HW_SUPPORTS_UAPSD |
1987                 IEEE80211_HW_HAS_RATE_CONTROL;
1988
1989         wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
1990                 BIT(NL80211_IFTYPE_ADHOC);
1991         wl->hw->wiphy->max_scan_ssids = 1;
1992         wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
1993
1994         if (wl1271_11a_enabled())
1995                 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
1996
1997         wl->hw->queues = 4;
1998
1999         SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
2000
2001         return 0;
2002 }
2003 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
2004
2005 #define WL1271_DEFAULT_CHANNEL 0
2006
2007 struct ieee80211_hw *wl1271_alloc_hw(void)
2008 {
2009         struct ieee80211_hw *hw;
2010         struct wl1271 *wl;
2011         int i, ret;
2012         static const u8 nokia_oui[3] = {0x00, 0x1f, 0xdf};
2013
2014         hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2015         if (!hw) {
2016                 wl1271_error("could not alloc ieee80211_hw");
2017                 ret = -ENOMEM;
2018                 goto err;
2019         }
2020
2021         wl = hw->priv;
2022         memset(wl, 0, sizeof(*wl));
2023
2024         INIT_LIST_HEAD(&wl->list);
2025
2026         wl->hw = hw;
2027
2028         skb_queue_head_init(&wl->tx_queue);
2029
2030         INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
2031         wl->channel = WL1271_DEFAULT_CHANNEL;
2032         wl->default_key = 0;
2033         wl->rx_counter = 0;
2034         wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2035         wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
2036         wl->psm_entry_retry = 0;
2037         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2038         wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2039         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2040         wl->sta_rate_set = 0;
2041         wl->band = IEEE80211_BAND_2GHZ;
2042         wl->vif = NULL;
2043         wl->flags = 0;
2044         wl->sg_enabled = true;
2045
2046         for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
2047                 wl->tx_frames[i] = NULL;
2048
2049         spin_lock_init(&wl->wl_lock);
2050
2051         wl->state = WL1271_STATE_OFF;
2052         mutex_init(&wl->mutex);
2053
2054         /*
2055          * FIXME: we should use a zero MAC address here, but for now we
2056          * generate a random Nokia address.
2057          */
2058         memcpy(wl->mac_addr, nokia_oui, 3);
2059         get_random_bytes(wl->mac_addr + 3, 3);
2060
2061         /* Apply default driver configuration. */
2062         wl1271_conf_init(wl);
2063
2064         wl1271_debugfs_init(wl);
2065
2066         /* Register platform device */
2067         ret = platform_device_register(&wl1271_device);
2068         if (ret) {
2069                 wl1271_error("couldn't register platform device");
2070                 goto err_hw;
2071         }
2072         dev_set_drvdata(&wl1271_device.dev, wl);
2073
2074         /* Create sysfs file to control bt coex state */
2075         ret = device_create_file(&wl1271_device.dev, &dev_attr_bt_coex_state);
2076         if (ret < 0) {
2077                 wl1271_error("failed to create sysfs file bt_coex_state");
2078                 goto err_platform;
2079         }
2080
2081         return hw;
2082
2083 err_platform:
2084         platform_device_unregister(&wl1271_device);
2085
2086 err_hw:
2087         ieee80211_unregister_hw(wl->hw);
2088
2089 err:
2090         return ERR_PTR(ret);
2091 }
2092 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
2093
2094 int wl1271_free_hw(struct wl1271 *wl)
2095 {
2096         platform_device_unregister(&wl1271_device);
2097         ieee80211_unregister_hw(wl->hw);
2098
2099         wl1271_debugfs_exit(wl);
2100
2101         kfree(wl->target_mem_map);
2102         vfree(wl->fw);
2103         wl->fw = NULL;
2104         kfree(wl->nvs);
2105         wl->nvs = NULL;
2106
2107         kfree(wl->fw_status);
2108         kfree(wl->tx_res_if);
2109
2110         ieee80211_free_hw(wl->hw);
2111
2112         return 0;
2113 }
2114 EXPORT_SYMBOL_GPL(wl1271_free_hw);
2115
2116 MODULE_LICENSE("GPL");
2117 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2118 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");