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