drivers/net/wireless/wl12xx/wl1271_main.c

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