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