drivers/net/wireless/wl12xx/wl1271_main.c

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