linux/drivers/net/wireless/ath/ath6kl/main.c
<<
>>
Prefs
   1/*
   2 * Copyright (c) 2004-2011 Atheros Communications Inc.
   3 * Copyright (c) 2011-2012 Qualcomm Atheros, Inc.
   4 *
   5 * Permission to use, copy, modify, and/or distribute this software for any
   6 * purpose with or without fee is hereby granted, provided that the above
   7 * copyright notice and this permission notice appear in all copies.
   8 *
   9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16 */
  17
  18#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  19
  20#include "core.h"
  21#include "hif-ops.h"
  22#include "cfg80211.h"
  23#include "target.h"
  24#include "debug.h"
  25
  26struct ath6kl_sta *ath6kl_find_sta(struct ath6kl_vif *vif, u8 *node_addr)
  27{
  28        struct ath6kl *ar = vif->ar;
  29        struct ath6kl_sta *conn = NULL;
  30        u8 i, max_conn;
  31
  32        if (is_zero_ether_addr(node_addr))
  33                return NULL;
  34
  35        max_conn = (vif->nw_type == AP_NETWORK) ? AP_MAX_NUM_STA : 0;
  36
  37        for (i = 0; i < max_conn; i++) {
  38                if (memcmp(node_addr, ar->sta_list[i].mac, ETH_ALEN) == 0) {
  39                        conn = &ar->sta_list[i];
  40                        break;
  41                }
  42        }
  43
  44        return conn;
  45}
  46
  47struct ath6kl_sta *ath6kl_find_sta_by_aid(struct ath6kl *ar, u8 aid)
  48{
  49        struct ath6kl_sta *conn = NULL;
  50        u8 ctr;
  51
  52        for (ctr = 0; ctr < AP_MAX_NUM_STA; ctr++) {
  53                if (ar->sta_list[ctr].aid == aid) {
  54                        conn = &ar->sta_list[ctr];
  55                        break;
  56                }
  57        }
  58        return conn;
  59}
  60
  61static void ath6kl_add_new_sta(struct ath6kl_vif *vif, u8 *mac, u16 aid,
  62                               u8 *wpaie, size_t ielen, u8 keymgmt,
  63                               u8 ucipher, u8 auth, u8 apsd_info)
  64{
  65        struct ath6kl *ar = vif->ar;
  66        struct ath6kl_sta *sta;
  67        u8 free_slot;
  68
  69        free_slot = aid - 1;
  70
  71        sta = &ar->sta_list[free_slot];
  72        memcpy(sta->mac, mac, ETH_ALEN);
  73        if (ielen <= ATH6KL_MAX_IE)
  74                memcpy(sta->wpa_ie, wpaie, ielen);
  75        sta->aid = aid;
  76        sta->keymgmt = keymgmt;
  77        sta->ucipher = ucipher;
  78        sta->auth = auth;
  79        sta->apsd_info = apsd_info;
  80
  81        ar->sta_list_index = ar->sta_list_index | (1 << free_slot);
  82        ar->ap_stats.sta[free_slot].aid = cpu_to_le32(aid);
  83        aggr_conn_init(vif, vif->aggr_cntxt, sta->aggr_conn);
  84}
  85
  86static void ath6kl_sta_cleanup(struct ath6kl *ar, u8 i)
  87{
  88        struct ath6kl_sta *sta = &ar->sta_list[i];
  89        struct ath6kl_mgmt_buff *entry, *tmp;
  90
  91        /* empty the queued pkts in the PS queue if any */
  92        spin_lock_bh(&sta->psq_lock);
  93        skb_queue_purge(&sta->psq);
  94        skb_queue_purge(&sta->apsdq);
  95
  96        if (sta->mgmt_psq_len != 0) {
  97                list_for_each_entry_safe(entry, tmp, &sta->mgmt_psq, list) {
  98                        kfree(entry);
  99                }
 100                INIT_LIST_HEAD(&sta->mgmt_psq);
 101                sta->mgmt_psq_len = 0;
 102        }
 103
 104        spin_unlock_bh(&sta->psq_lock);
 105
 106        memset(&ar->ap_stats.sta[sta->aid - 1], 0,
 107               sizeof(struct wmi_per_sta_stat));
 108        eth_zero_addr(sta->mac);
 109        memset(sta->wpa_ie, 0, ATH6KL_MAX_IE);
 110        sta->aid = 0;
 111        sta->sta_flags = 0;
 112
 113        ar->sta_list_index = ar->sta_list_index & ~(1 << i);
 114        aggr_reset_state(sta->aggr_conn);
 115}
 116
 117static u8 ath6kl_remove_sta(struct ath6kl *ar, u8 *mac, u16 reason)
 118{
 119        u8 i, removed = 0;
 120
 121        if (is_zero_ether_addr(mac))
 122                return removed;
 123
 124        if (is_broadcast_ether_addr(mac)) {
 125                ath6kl_dbg(ATH6KL_DBG_TRC, "deleting all station\n");
 126
 127                for (i = 0; i < AP_MAX_NUM_STA; i++) {
 128                        if (!is_zero_ether_addr(ar->sta_list[i].mac)) {
 129                                ath6kl_sta_cleanup(ar, i);
 130                                removed = 1;
 131                        }
 132                }
 133        } else {
 134                for (i = 0; i < AP_MAX_NUM_STA; i++) {
 135                        if (memcmp(ar->sta_list[i].mac, mac, ETH_ALEN) == 0) {
 136                                ath6kl_dbg(ATH6KL_DBG_TRC,
 137                                           "deleting station %pM aid=%d reason=%d\n",
 138                                           mac, ar->sta_list[i].aid, reason);
 139                                ath6kl_sta_cleanup(ar, i);
 140                                removed = 1;
 141                                break;
 142                        }
 143                }
 144        }
 145
 146        return removed;
 147}
 148
 149enum htc_endpoint_id ath6kl_ac2_endpoint_id(void *devt, u8 ac)
 150{
 151        struct ath6kl *ar = devt;
 152        return ar->ac2ep_map[ac];
 153}
 154
 155struct ath6kl_cookie *ath6kl_alloc_cookie(struct ath6kl *ar)
 156{
 157        struct ath6kl_cookie *cookie;
 158
 159        cookie = ar->cookie_list;
 160        if (cookie != NULL) {
 161                ar->cookie_list = cookie->arc_list_next;
 162                ar->cookie_count--;
 163        }
 164
 165        return cookie;
 166}
 167
 168void ath6kl_cookie_init(struct ath6kl *ar)
 169{
 170        u32 i;
 171
 172        ar->cookie_list = NULL;
 173        ar->cookie_count = 0;
 174
 175        memset(ar->cookie_mem, 0, sizeof(ar->cookie_mem));
 176
 177        for (i = 0; i < MAX_COOKIE_NUM; i++)
 178                ath6kl_free_cookie(ar, &ar->cookie_mem[i]);
 179}
 180
 181void ath6kl_cookie_cleanup(struct ath6kl *ar)
 182{
 183        ar->cookie_list = NULL;
 184        ar->cookie_count = 0;
 185}
 186
 187void ath6kl_free_cookie(struct ath6kl *ar, struct ath6kl_cookie *cookie)
 188{
 189        /* Insert first */
 190
 191        if (!ar || !cookie)
 192                return;
 193
 194        cookie->arc_list_next = ar->cookie_list;
 195        ar->cookie_list = cookie;
 196        ar->cookie_count++;
 197}
 198
 199/*
 200 * Read from the hardware through its diagnostic window. No cooperation
 201 * from the firmware is required for this.
 202 */
 203int ath6kl_diag_read32(struct ath6kl *ar, u32 address, u32 *value)
 204{
 205        int ret;
 206
 207        ret = ath6kl_hif_diag_read32(ar, address, value);
 208        if (ret) {
 209                ath6kl_warn("failed to read32 through diagnose window: %d\n",
 210                            ret);
 211                return ret;
 212        }
 213
 214        return 0;
 215}
 216
 217/*
 218 * Write to the ATH6KL through its diagnostic window. No cooperation from
 219 * the Target is required for this.
 220 */
 221int ath6kl_diag_write32(struct ath6kl *ar, u32 address, __le32 value)
 222{
 223        int ret;
 224
 225        ret = ath6kl_hif_diag_write32(ar, address, value);
 226
 227        if (ret) {
 228                ath6kl_err("failed to write 0x%x during diagnose window to 0x%x\n",
 229                           address, value);
 230                return ret;
 231        }
 232
 233        return 0;
 234}
 235
 236int ath6kl_diag_read(struct ath6kl *ar, u32 address, void *data, u32 length)
 237{
 238        u32 count, *buf = data;
 239        int ret;
 240
 241        if (WARN_ON(length % 4))
 242                return -EINVAL;
 243
 244        for (count = 0; count < length / 4; count++, address += 4) {
 245                ret = ath6kl_diag_read32(ar, address, &buf[count]);
 246                if (ret)
 247                        return ret;
 248        }
 249
 250        return 0;
 251}
 252
 253int ath6kl_diag_write(struct ath6kl *ar, u32 address, void *data, u32 length)
 254{
 255        u32 count;
 256        __le32 *buf = data;
 257        int ret;
 258
 259        if (WARN_ON(length % 4))
 260                return -EINVAL;
 261
 262        for (count = 0; count < length / 4; count++, address += 4) {
 263                ret = ath6kl_diag_write32(ar, address, buf[count]);
 264                if (ret)
 265                        return ret;
 266        }
 267
 268        return 0;
 269}
 270
 271int ath6kl_read_fwlogs(struct ath6kl *ar)
 272{
 273        struct ath6kl_dbglog_hdr debug_hdr;
 274        struct ath6kl_dbglog_buf debug_buf;
 275        u32 address, length, firstbuf, debug_hdr_addr;
 276        int ret, loop;
 277        u8 *buf;
 278
 279        buf = kmalloc(ATH6KL_FWLOG_PAYLOAD_SIZE, GFP_KERNEL);
 280        if (!buf)
 281                return -ENOMEM;
 282
 283        address = TARG_VTOP(ar->target_type,
 284                            ath6kl_get_hi_item_addr(ar,
 285                                                    HI_ITEM(hi_dbglog_hdr)));
 286
 287        ret = ath6kl_diag_read32(ar, address, &debug_hdr_addr);
 288        if (ret)
 289                goto out;
 290
 291        /* Get the contents of the ring buffer */
 292        if (debug_hdr_addr == 0) {
 293                ath6kl_warn("Invalid address for debug_hdr_addr\n");
 294                ret = -EINVAL;
 295                goto out;
 296        }
 297
 298        address = TARG_VTOP(ar->target_type, debug_hdr_addr);
 299        ret = ath6kl_diag_read(ar, address, &debug_hdr, sizeof(debug_hdr));
 300        if (ret)
 301                goto out;
 302
 303        address = TARG_VTOP(ar->target_type,
 304                            le32_to_cpu(debug_hdr.dbuf_addr));
 305        firstbuf = address;
 306        ret = ath6kl_diag_read(ar, address, &debug_buf, sizeof(debug_buf));
 307        if (ret)
 308                goto out;
 309
 310        loop = 100;
 311
 312        do {
 313                address = TARG_VTOP(ar->target_type,
 314                                    le32_to_cpu(debug_buf.buffer_addr));
 315                length = le32_to_cpu(debug_buf.length);
 316
 317                if (length != 0 && (le32_to_cpu(debug_buf.length) <=
 318                                    le32_to_cpu(debug_buf.bufsize))) {
 319                        length = ALIGN(length, 4);
 320
 321                        ret = ath6kl_diag_read(ar, address,
 322                                               buf, length);
 323                        if (ret)
 324                                goto out;
 325
 326                        ath6kl_debug_fwlog_event(ar, buf, length);
 327                }
 328
 329                address = TARG_VTOP(ar->target_type,
 330                                    le32_to_cpu(debug_buf.next));
 331                ret = ath6kl_diag_read(ar, address, &debug_buf,
 332                                       sizeof(debug_buf));
 333                if (ret)
 334                        goto out;
 335
 336                loop--;
 337
 338                if (WARN_ON(loop == 0)) {
 339                        ret = -ETIMEDOUT;
 340                        goto out;
 341                }
 342        } while (address != firstbuf);
 343
 344out:
 345        kfree(buf);
 346
 347        return ret;
 348}
 349
 350static void ath6kl_install_static_wep_keys(struct ath6kl_vif *vif)
 351{
 352        u8 index;
 353        u8 keyusage;
 354
 355        for (index = 0; index <= WMI_MAX_KEY_INDEX; index++) {
 356                if (vif->wep_key_list[index].key_len) {
 357                        keyusage = GROUP_USAGE;
 358                        if (index == vif->def_txkey_index)
 359                                keyusage |= TX_USAGE;
 360
 361                        ath6kl_wmi_addkey_cmd(vif->ar->wmi, vif->fw_vif_idx,
 362                                              index,
 363                                              WEP_CRYPT,
 364                                              keyusage,
 365                                              vif->wep_key_list[index].key_len,
 366                                              NULL, 0,
 367                                              vif->wep_key_list[index].key,
 368                                              KEY_OP_INIT_VAL, NULL,
 369                                              NO_SYNC_WMIFLAG);
 370                }
 371        }
 372}
 373
 374void ath6kl_connect_ap_mode_bss(struct ath6kl_vif *vif, u16 channel)
 375{
 376        struct ath6kl *ar = vif->ar;
 377        struct ath6kl_req_key *ik;
 378        int res;
 379        u8 key_rsc[ATH6KL_KEY_SEQ_LEN];
 380
 381        ik = &ar->ap_mode_bkey;
 382
 383        ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "AP mode started on %u MHz\n", channel);
 384
 385        switch (vif->auth_mode) {
 386        case NONE_AUTH:
 387                if (vif->prwise_crypto == WEP_CRYPT)
 388                        ath6kl_install_static_wep_keys(vif);
 389                if (!ik->valid || ik->key_type != WAPI_CRYPT)
 390                        break;
 391                /* for WAPI, we need to set the delayed group key, continue: */
 392                /* fall through */
 393        case WPA_PSK_AUTH:
 394        case WPA2_PSK_AUTH:
 395        case (WPA_PSK_AUTH | WPA2_PSK_AUTH):
 396                if (!ik->valid)
 397                        break;
 398
 399                ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
 400                           "Delayed addkey for the initial group key for AP mode\n");
 401                memset(key_rsc, 0, sizeof(key_rsc));
 402                res = ath6kl_wmi_addkey_cmd(
 403                        ar->wmi, vif->fw_vif_idx, ik->key_index, ik->key_type,
 404                        GROUP_USAGE, ik->key_len, key_rsc, ATH6KL_KEY_SEQ_LEN,
 405                        ik->key,
 406                        KEY_OP_INIT_VAL, NULL, SYNC_BOTH_WMIFLAG);
 407                if (res) {
 408                        ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
 409                                   "Delayed addkey failed: %d\n", res);
 410                }
 411                break;
 412        }
 413
 414        if (ar->last_ch != channel)
 415                /* we actually don't know the phymode, default to HT20 */
 416                ath6kl_cfg80211_ch_switch_notify(vif, channel, WMI_11G_HT20);
 417
 418        ath6kl_wmi_bssfilter_cmd(ar->wmi, vif->fw_vif_idx, NONE_BSS_FILTER, 0);
 419        set_bit(CONNECTED, &vif->flags);
 420        netif_carrier_on(vif->ndev);
 421}
 422
 423void ath6kl_connect_ap_mode_sta(struct ath6kl_vif *vif, u16 aid, u8 *mac_addr,
 424                                u8 keymgmt, u8 ucipher, u8 auth,
 425                                u8 assoc_req_len, u8 *assoc_info, u8 apsd_info)
 426{
 427        u8 *ies = NULL, *wpa_ie = NULL, *pos;
 428        size_t ies_len = 0;
 429        struct station_info *sinfo;
 430
 431        ath6kl_dbg(ATH6KL_DBG_TRC, "new station %pM aid=%d\n", mac_addr, aid);
 432
 433        if (assoc_req_len > sizeof(struct ieee80211_hdr_3addr)) {
 434                struct ieee80211_mgmt *mgmt =
 435                        (struct ieee80211_mgmt *) assoc_info;
 436                if (ieee80211_is_assoc_req(mgmt->frame_control) &&
 437                    assoc_req_len >= sizeof(struct ieee80211_hdr_3addr) +
 438                    sizeof(mgmt->u.assoc_req)) {
 439                        ies = mgmt->u.assoc_req.variable;
 440                        ies_len = assoc_info + assoc_req_len - ies;
 441                } else if (ieee80211_is_reassoc_req(mgmt->frame_control) &&
 442                           assoc_req_len >= sizeof(struct ieee80211_hdr_3addr)
 443                           + sizeof(mgmt->u.reassoc_req)) {
 444                        ies = mgmt->u.reassoc_req.variable;
 445                        ies_len = assoc_info + assoc_req_len - ies;
 446                }
 447        }
 448
 449        pos = ies;
 450        while (pos && pos + 1 < ies + ies_len) {
 451                if (pos + 2 + pos[1] > ies + ies_len)
 452                        break;
 453                if (pos[0] == WLAN_EID_RSN)
 454                        wpa_ie = pos; /* RSN IE */
 455                else if (pos[0] == WLAN_EID_VENDOR_SPECIFIC &&
 456                         pos[1] >= 4 &&
 457                         pos[2] == 0x00 && pos[3] == 0x50 && pos[4] == 0xf2) {
 458                        if (pos[5] == 0x01)
 459                                wpa_ie = pos; /* WPA IE */
 460                        else if (pos[5] == 0x04) {
 461                                wpa_ie = pos; /* WPS IE */
 462                                break; /* overrides WPA/RSN IE */
 463                        }
 464                } else if (pos[0] == 0x44 && wpa_ie == NULL) {
 465                        /*
 466                         * Note: WAPI Parameter Set IE re-uses Element ID that
 467                         * was officially allocated for BSS AC Access Delay. As
 468                         * such, we need to be a bit more careful on when
 469                         * parsing the frame. However, BSS AC Access Delay
 470                         * element is not supposed to be included in
 471                         * (Re)Association Request frames, so this should not
 472                         * cause problems.
 473                         */
 474                        wpa_ie = pos; /* WAPI IE */
 475                        break;
 476                }
 477                pos += 2 + pos[1];
 478        }
 479
 480        ath6kl_add_new_sta(vif, mac_addr, aid, wpa_ie,
 481                           wpa_ie ? 2 + wpa_ie[1] : 0,
 482                           keymgmt, ucipher, auth, apsd_info);
 483
 484        /* send event to application */
 485        sinfo = kzalloc(sizeof(*sinfo), GFP_KERNEL);
 486        if (!sinfo)
 487                return;
 488
 489        /* TODO: sinfo.generation */
 490
 491        sinfo->assoc_req_ies = ies;
 492        sinfo->assoc_req_ies_len = ies_len;
 493
 494        cfg80211_new_sta(vif->ndev, mac_addr, sinfo, GFP_KERNEL);
 495
 496        netif_wake_queue(vif->ndev);
 497
 498        kfree(sinfo);
 499}
 500
 501void disconnect_timer_handler(struct timer_list *t)
 502{
 503        struct ath6kl_vif *vif = from_timer(vif, t, disconnect_timer);
 504
 505        ath6kl_init_profile_info(vif);
 506        ath6kl_disconnect(vif);
 507}
 508
 509void ath6kl_disconnect(struct ath6kl_vif *vif)
 510{
 511        if (test_bit(CONNECTED, &vif->flags) ||
 512            test_bit(CONNECT_PEND, &vif->flags)) {
 513                ath6kl_wmi_disconnect_cmd(vif->ar->wmi, vif->fw_vif_idx);
 514                /*
 515                 * Disconnect command is issued, clear the connect pending
 516                 * flag. The connected flag will be cleared in
 517                 * disconnect event notification.
 518                 */
 519                clear_bit(CONNECT_PEND, &vif->flags);
 520        }
 521}
 522
 523/* WMI Event handlers */
 524
 525void ath6kl_ready_event(void *devt, u8 *datap, u32 sw_ver, u32 abi_ver,
 526                        enum wmi_phy_cap cap)
 527{
 528        struct ath6kl *ar = devt;
 529
 530        memcpy(ar->mac_addr, datap, ETH_ALEN);
 531
 532        ath6kl_dbg(ATH6KL_DBG_BOOT,
 533                   "ready event mac addr %pM sw_ver 0x%x abi_ver 0x%x cap 0x%x\n",
 534                   ar->mac_addr, sw_ver, abi_ver, cap);
 535
 536        ar->version.wlan_ver = sw_ver;
 537        ar->version.abi_ver = abi_ver;
 538        ar->hw.cap = cap;
 539
 540        if (strlen(ar->wiphy->fw_version) == 0) {
 541                snprintf(ar->wiphy->fw_version,
 542                         sizeof(ar->wiphy->fw_version),
 543                         "%u.%u.%u.%u",
 544                         (ar->version.wlan_ver & 0xf0000000) >> 28,
 545                         (ar->version.wlan_ver & 0x0f000000) >> 24,
 546                         (ar->version.wlan_ver & 0x00ff0000) >> 16,
 547                         (ar->version.wlan_ver & 0x0000ffff));
 548        }
 549
 550        /* indicate to the waiting thread that the ready event was received */
 551        set_bit(WMI_READY, &ar->flag);
 552        wake_up(&ar->event_wq);
 553}
 554
 555void ath6kl_scan_complete_evt(struct ath6kl_vif *vif, int status)
 556{
 557        struct ath6kl *ar = vif->ar;
 558        bool aborted = false;
 559
 560        if (status != WMI_SCAN_STATUS_SUCCESS)
 561                aborted = true;
 562
 563        ath6kl_cfg80211_scan_complete_event(vif, aborted);
 564
 565        if (!ar->usr_bss_filter) {
 566                clear_bit(CLEAR_BSSFILTER_ON_BEACON, &vif->flags);
 567                ath6kl_wmi_bssfilter_cmd(ar->wmi, vif->fw_vif_idx,
 568                                         NONE_BSS_FILTER, 0);
 569        }
 570
 571        ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "scan complete: %d\n", status);
 572}
 573
 574static int ath6kl_commit_ch_switch(struct ath6kl_vif *vif, u16 channel)
 575{
 576        struct ath6kl *ar = vif->ar;
 577
 578        vif->profile.ch = cpu_to_le16(channel);
 579
 580        switch (vif->nw_type) {
 581        case AP_NETWORK:
 582                /*
 583                 * reconfigure any saved RSN IE capabilites in the beacon /
 584                 * probe response to stay in sync with the supplicant.
 585                 */
 586                if (vif->rsn_capab &&
 587                    test_bit(ATH6KL_FW_CAPABILITY_RSN_CAP_OVERRIDE,
 588                             ar->fw_capabilities))
 589                        ath6kl_wmi_set_ie_cmd(ar->wmi, vif->fw_vif_idx,
 590                                              WLAN_EID_RSN, WMI_RSN_IE_CAPB,
 591                                              (const u8 *) &vif->rsn_capab,
 592                                              sizeof(vif->rsn_capab));
 593
 594                return ath6kl_wmi_ap_profile_commit(ar->wmi, vif->fw_vif_idx,
 595                                                    &vif->profile);
 596        default:
 597                ath6kl_err("won't switch channels nw_type=%d\n", vif->nw_type);
 598                return -ENOTSUPP;
 599        }
 600}
 601
 602static void ath6kl_check_ch_switch(struct ath6kl *ar, u16 channel)
 603{
 604        struct ath6kl_vif *vif;
 605        int res = 0;
 606
 607        if (!ar->want_ch_switch)
 608                return;
 609
 610        spin_lock_bh(&ar->list_lock);
 611        list_for_each_entry(vif, &ar->vif_list, list) {
 612                if (ar->want_ch_switch & (1 << vif->fw_vif_idx))
 613                        res = ath6kl_commit_ch_switch(vif, channel);
 614
 615                /* if channel switch failed, oh well we tried */
 616                ar->want_ch_switch &= ~(1 << vif->fw_vif_idx);
 617
 618                if (res)
 619                        ath6kl_err("channel switch failed nw_type %d res %d\n",
 620                                   vif->nw_type, res);
 621        }
 622        spin_unlock_bh(&ar->list_lock);
 623}
 624
 625void ath6kl_connect_event(struct ath6kl_vif *vif, u16 channel, u8 *bssid,
 626                          u16 listen_int, u16 beacon_int,
 627                          enum network_type net_type, u8 beacon_ie_len,
 628                          u8 assoc_req_len, u8 assoc_resp_len,
 629                          u8 *assoc_info)
 630{
 631        struct ath6kl *ar = vif->ar;
 632
 633        ath6kl_cfg80211_connect_event(vif, channel, bssid,
 634                                      listen_int, beacon_int,
 635                                      net_type, beacon_ie_len,
 636                                      assoc_req_len, assoc_resp_len,
 637                                      assoc_info);
 638
 639        memcpy(vif->bssid, bssid, sizeof(vif->bssid));
 640        vif->bss_ch = channel;
 641
 642        if (vif->nw_type == INFRA_NETWORK) {
 643                ath6kl_wmi_listeninterval_cmd(ar->wmi, vif->fw_vif_idx,
 644                                              vif->listen_intvl_t, 0);
 645                ath6kl_check_ch_switch(ar, channel);
 646        }
 647
 648        netif_wake_queue(vif->ndev);
 649
 650        /* Update connect & link status atomically */
 651        spin_lock_bh(&vif->if_lock);
 652        set_bit(CONNECTED, &vif->flags);
 653        clear_bit(CONNECT_PEND, &vif->flags);
 654        netif_carrier_on(vif->ndev);
 655        spin_unlock_bh(&vif->if_lock);
 656
 657        aggr_reset_state(vif->aggr_cntxt->aggr_conn);
 658        vif->reconnect_flag = 0;
 659
 660        if ((vif->nw_type == ADHOC_NETWORK) && ar->ibss_ps_enable) {
 661                memset(ar->node_map, 0, sizeof(ar->node_map));
 662                ar->node_num = 0;
 663                ar->next_ep_id = ENDPOINT_2;
 664        }
 665
 666        if (!ar->usr_bss_filter) {
 667                set_bit(CLEAR_BSSFILTER_ON_BEACON, &vif->flags);
 668                ath6kl_wmi_bssfilter_cmd(ar->wmi, vif->fw_vif_idx,
 669                                         CURRENT_BSS_FILTER, 0);
 670        }
 671}
 672
 673void ath6kl_tkip_micerr_event(struct ath6kl_vif *vif, u8 keyid, bool ismcast)
 674{
 675        struct ath6kl_sta *sta;
 676        struct ath6kl *ar = vif->ar;
 677        u8 tsc[6];
 678
 679        /*
 680         * For AP case, keyid will have aid of STA which sent pkt with
 681         * MIC error. Use this aid to get MAC & send it to hostapd.
 682         */
 683        if (vif->nw_type == AP_NETWORK) {
 684                sta = ath6kl_find_sta_by_aid(ar, (keyid >> 2));
 685                if (!sta)
 686                        return;
 687
 688                ath6kl_dbg(ATH6KL_DBG_TRC,
 689                           "ap tkip mic error received from aid=%d\n", keyid);
 690
 691                memset(tsc, 0, sizeof(tsc)); /* FIX: get correct TSC */
 692                cfg80211_michael_mic_failure(vif->ndev, sta->mac,
 693                                             NL80211_KEYTYPE_PAIRWISE, keyid,
 694                                             tsc, GFP_KERNEL);
 695        } else {
 696                ath6kl_cfg80211_tkip_micerr_event(vif, keyid, ismcast);
 697        }
 698}
 699
 700static void ath6kl_update_target_stats(struct ath6kl_vif *vif, u8 *ptr, u32 len)
 701{
 702        struct wmi_target_stats *tgt_stats =
 703                (struct wmi_target_stats *) ptr;
 704        struct ath6kl *ar = vif->ar;
 705        struct target_stats *stats = &vif->target_stats;
 706        struct tkip_ccmp_stats *ccmp_stats;
 707        s32 rate;
 708        u8 ac;
 709
 710        if (len < sizeof(*tgt_stats))
 711                return;
 712
 713        ath6kl_dbg(ATH6KL_DBG_TRC, "updating target stats\n");
 714
 715        stats->tx_pkt += le32_to_cpu(tgt_stats->stats.tx.pkt);
 716        stats->tx_byte += le32_to_cpu(tgt_stats->stats.tx.byte);
 717        stats->tx_ucast_pkt += le32_to_cpu(tgt_stats->stats.tx.ucast_pkt);
 718        stats->tx_ucast_byte += le32_to_cpu(tgt_stats->stats.tx.ucast_byte);
 719        stats->tx_mcast_pkt += le32_to_cpu(tgt_stats->stats.tx.mcast_pkt);
 720        stats->tx_mcast_byte += le32_to_cpu(tgt_stats->stats.tx.mcast_byte);
 721        stats->tx_bcast_pkt  += le32_to_cpu(tgt_stats->stats.tx.bcast_pkt);
 722        stats->tx_bcast_byte += le32_to_cpu(tgt_stats->stats.tx.bcast_byte);
 723        stats->tx_rts_success_cnt +=
 724                le32_to_cpu(tgt_stats->stats.tx.rts_success_cnt);
 725
 726        for (ac = 0; ac < WMM_NUM_AC; ac++)
 727                stats->tx_pkt_per_ac[ac] +=
 728                        le32_to_cpu(tgt_stats->stats.tx.pkt_per_ac[ac]);
 729
 730        stats->tx_err += le32_to_cpu(tgt_stats->stats.tx.err);
 731        stats->tx_fail_cnt += le32_to_cpu(tgt_stats->stats.tx.fail_cnt);
 732        stats->tx_retry_cnt += le32_to_cpu(tgt_stats->stats.tx.retry_cnt);
 733        stats->tx_mult_retry_cnt +=
 734                le32_to_cpu(tgt_stats->stats.tx.mult_retry_cnt);
 735        stats->tx_rts_fail_cnt +=
 736                le32_to_cpu(tgt_stats->stats.tx.rts_fail_cnt);
 737
 738        rate = a_sle32_to_cpu(tgt_stats->stats.tx.ucast_rate);
 739        stats->tx_ucast_rate = ath6kl_wmi_get_rate(ar->wmi, rate);
 740
 741        stats->rx_pkt += le32_to_cpu(tgt_stats->stats.rx.pkt);
 742        stats->rx_byte += le32_to_cpu(tgt_stats->stats.rx.byte);
 743        stats->rx_ucast_pkt += le32_to_cpu(tgt_stats->stats.rx.ucast_pkt);
 744        stats->rx_ucast_byte += le32_to_cpu(tgt_stats->stats.rx.ucast_byte);
 745        stats->rx_mcast_pkt += le32_to_cpu(tgt_stats->stats.rx.mcast_pkt);
 746        stats->rx_mcast_byte += le32_to_cpu(tgt_stats->stats.rx.mcast_byte);
 747        stats->rx_bcast_pkt += le32_to_cpu(tgt_stats->stats.rx.bcast_pkt);
 748        stats->rx_bcast_byte += le32_to_cpu(tgt_stats->stats.rx.bcast_byte);
 749        stats->rx_frgment_pkt += le32_to_cpu(tgt_stats->stats.rx.frgment_pkt);
 750        stats->rx_err += le32_to_cpu(tgt_stats->stats.rx.err);
 751        stats->rx_crc_err += le32_to_cpu(tgt_stats->stats.rx.crc_err);
 752        stats->rx_key_cache_miss +=
 753                le32_to_cpu(tgt_stats->stats.rx.key_cache_miss);
 754        stats->rx_decrypt_err += le32_to_cpu(tgt_stats->stats.rx.decrypt_err);
 755        stats->rx_dupl_frame += le32_to_cpu(tgt_stats->stats.rx.dupl_frame);
 756
 757        rate = a_sle32_to_cpu(tgt_stats->stats.rx.ucast_rate);
 758        stats->rx_ucast_rate = ath6kl_wmi_get_rate(ar->wmi, rate);
 759
 760        ccmp_stats = &tgt_stats->stats.tkip_ccmp_stats;
 761
 762        stats->tkip_local_mic_fail +=
 763                le32_to_cpu(ccmp_stats->tkip_local_mic_fail);
 764        stats->tkip_cnter_measures_invoked +=
 765                le32_to_cpu(ccmp_stats->tkip_cnter_measures_invoked);
 766        stats->tkip_fmt_err += le32_to_cpu(ccmp_stats->tkip_fmt_err);
 767
 768        stats->ccmp_fmt_err += le32_to_cpu(ccmp_stats->ccmp_fmt_err);
 769        stats->ccmp_replays += le32_to_cpu(ccmp_stats->ccmp_replays);
 770
 771        stats->pwr_save_fail_cnt +=
 772                le32_to_cpu(tgt_stats->pm_stats.pwr_save_failure_cnt);
 773        stats->noise_floor_calib =
 774                a_sle32_to_cpu(tgt_stats->noise_floor_calib);
 775
 776        stats->cs_bmiss_cnt +=
 777                le32_to_cpu(tgt_stats->cserv_stats.cs_bmiss_cnt);
 778        stats->cs_low_rssi_cnt +=
 779                le32_to_cpu(tgt_stats->cserv_stats.cs_low_rssi_cnt);
 780        stats->cs_connect_cnt +=
 781                le16_to_cpu(tgt_stats->cserv_stats.cs_connect_cnt);
 782        stats->cs_discon_cnt +=
 783                le16_to_cpu(tgt_stats->cserv_stats.cs_discon_cnt);
 784
 785        stats->cs_ave_beacon_rssi =
 786                a_sle16_to_cpu(tgt_stats->cserv_stats.cs_ave_beacon_rssi);
 787
 788        stats->cs_last_roam_msec =
 789                tgt_stats->cserv_stats.cs_last_roam_msec;
 790        stats->cs_snr = tgt_stats->cserv_stats.cs_snr;
 791        stats->cs_rssi = a_sle16_to_cpu(tgt_stats->cserv_stats.cs_rssi);
 792
 793        stats->lq_val = le32_to_cpu(tgt_stats->lq_val);
 794
 795        stats->wow_pkt_dropped +=
 796                le32_to_cpu(tgt_stats->wow_stats.wow_pkt_dropped);
 797        stats->wow_host_pkt_wakeups +=
 798                tgt_stats->wow_stats.wow_host_pkt_wakeups;
 799        stats->wow_host_evt_wakeups +=
 800                tgt_stats->wow_stats.wow_host_evt_wakeups;
 801        stats->wow_evt_discarded +=
 802                le16_to_cpu(tgt_stats->wow_stats.wow_evt_discarded);
 803
 804        stats->arp_received = le32_to_cpu(tgt_stats->arp_stats.arp_received);
 805        stats->arp_replied = le32_to_cpu(tgt_stats->arp_stats.arp_replied);
 806        stats->arp_matched = le32_to_cpu(tgt_stats->arp_stats.arp_matched);
 807
 808        if (test_bit(STATS_UPDATE_PEND, &vif->flags)) {
 809                clear_bit(STATS_UPDATE_PEND, &vif->flags);
 810                wake_up(&ar->event_wq);
 811        }
 812}
 813
 814static void ath6kl_add_le32(__le32 *var, __le32 val)
 815{
 816        *var = cpu_to_le32(le32_to_cpu(*var) + le32_to_cpu(val));
 817}
 818
 819void ath6kl_tgt_stats_event(struct ath6kl_vif *vif, u8 *ptr, u32 len)
 820{
 821        struct wmi_ap_mode_stat *p = (struct wmi_ap_mode_stat *) ptr;
 822        struct ath6kl *ar = vif->ar;
 823        struct wmi_ap_mode_stat *ap = &ar->ap_stats;
 824        struct wmi_per_sta_stat *st_ap, *st_p;
 825        u8 ac;
 826
 827        if (vif->nw_type == AP_NETWORK) {
 828                if (len < sizeof(*p))
 829                        return;
 830
 831                for (ac = 0; ac < AP_MAX_NUM_STA; ac++) {
 832                        st_ap = &ap->sta[ac];
 833                        st_p = &p->sta[ac];
 834
 835                        ath6kl_add_le32(&st_ap->tx_bytes, st_p->tx_bytes);
 836                        ath6kl_add_le32(&st_ap->tx_pkts, st_p->tx_pkts);
 837                        ath6kl_add_le32(&st_ap->tx_error, st_p->tx_error);
 838                        ath6kl_add_le32(&st_ap->tx_discard, st_p->tx_discard);
 839                        ath6kl_add_le32(&st_ap->rx_bytes, st_p->rx_bytes);
 840                        ath6kl_add_le32(&st_ap->rx_pkts, st_p->rx_pkts);
 841                        ath6kl_add_le32(&st_ap->rx_error, st_p->rx_error);
 842                        ath6kl_add_le32(&st_ap->rx_discard, st_p->rx_discard);
 843                }
 844
 845        } else {
 846                ath6kl_update_target_stats(vif, ptr, len);
 847        }
 848}
 849
 850void ath6kl_wakeup_event(void *dev)
 851{
 852        struct ath6kl *ar = (struct ath6kl *) dev;
 853
 854        wake_up(&ar->event_wq);
 855}
 856
 857void ath6kl_txpwr_rx_evt(void *devt, u8 tx_pwr)
 858{
 859        struct ath6kl *ar = (struct ath6kl *) devt;
 860
 861        ar->tx_pwr = tx_pwr;
 862        wake_up(&ar->event_wq);
 863}
 864
 865void ath6kl_pspoll_event(struct ath6kl_vif *vif, u8 aid)
 866{
 867        struct ath6kl_sta *conn;
 868        struct sk_buff *skb;
 869        bool psq_empty = false;
 870        struct ath6kl *ar = vif->ar;
 871        struct ath6kl_mgmt_buff *mgmt_buf;
 872
 873        conn = ath6kl_find_sta_by_aid(ar, aid);
 874
 875        if (!conn)
 876                return;
 877        /*
 878         * Send out a packet queued on ps queue. When the ps queue
 879         * becomes empty update the PVB for this station.
 880         */
 881        spin_lock_bh(&conn->psq_lock);
 882        psq_empty  = skb_queue_empty(&conn->psq) && (conn->mgmt_psq_len == 0);
 883        spin_unlock_bh(&conn->psq_lock);
 884
 885        if (psq_empty)
 886                /* TODO: Send out a NULL data frame */
 887                return;
 888
 889        spin_lock_bh(&conn->psq_lock);
 890        if (conn->mgmt_psq_len > 0) {
 891                mgmt_buf = list_first_entry(&conn->mgmt_psq,
 892                                        struct ath6kl_mgmt_buff, list);
 893                list_del(&mgmt_buf->list);
 894                conn->mgmt_psq_len--;
 895                spin_unlock_bh(&conn->psq_lock);
 896
 897                conn->sta_flags |= STA_PS_POLLED;
 898                ath6kl_wmi_send_mgmt_cmd(ar->wmi, vif->fw_vif_idx,
 899                                         mgmt_buf->id, mgmt_buf->freq,
 900                                         mgmt_buf->wait, mgmt_buf->buf,
 901                                         mgmt_buf->len, mgmt_buf->no_cck);
 902                conn->sta_flags &= ~STA_PS_POLLED;
 903                kfree(mgmt_buf);
 904        } else {
 905                skb = skb_dequeue(&conn->psq);
 906                spin_unlock_bh(&conn->psq_lock);
 907
 908                conn->sta_flags |= STA_PS_POLLED;
 909                ath6kl_data_tx(skb, vif->ndev);
 910                conn->sta_flags &= ~STA_PS_POLLED;
 911        }
 912
 913        spin_lock_bh(&conn->psq_lock);
 914        psq_empty  = skb_queue_empty(&conn->psq) && (conn->mgmt_psq_len == 0);
 915        spin_unlock_bh(&conn->psq_lock);
 916
 917        if (psq_empty)
 918                ath6kl_wmi_set_pvb_cmd(ar->wmi, vif->fw_vif_idx, conn->aid, 0);
 919}
 920
 921void ath6kl_dtimexpiry_event(struct ath6kl_vif *vif)
 922{
 923        bool mcastq_empty = false;
 924        struct sk_buff *skb;
 925        struct ath6kl *ar = vif->ar;
 926
 927        /*
 928         * If there are no associated STAs, ignore the DTIM expiry event.
 929         * There can be potential race conditions where the last associated
 930         * STA may disconnect & before the host could clear the 'Indicate
 931         * DTIM' request to the firmware, the firmware would have just
 932         * indicated a DTIM expiry event. The race is between 'clear DTIM
 933         * expiry cmd' going from the host to the firmware & the DTIM
 934         * expiry event happening from the firmware to the host.
 935         */
 936        if (!ar->sta_list_index)
 937                return;
 938
 939        spin_lock_bh(&ar->mcastpsq_lock);
 940        mcastq_empty = skb_queue_empty(&ar->mcastpsq);
 941        spin_unlock_bh(&ar->mcastpsq_lock);
 942
 943        if (mcastq_empty)
 944                return;
 945
 946        /* set the STA flag to dtim_expired for the frame to go out */
 947        set_bit(DTIM_EXPIRED, &vif->flags);
 948
 949        spin_lock_bh(&ar->mcastpsq_lock);
 950        while ((skb = skb_dequeue(&ar->mcastpsq)) != NULL) {
 951                spin_unlock_bh(&ar->mcastpsq_lock);
 952
 953                ath6kl_data_tx(skb, vif->ndev);
 954
 955                spin_lock_bh(&ar->mcastpsq_lock);
 956        }
 957        spin_unlock_bh(&ar->mcastpsq_lock);
 958
 959        clear_bit(DTIM_EXPIRED, &vif->flags);
 960
 961        /* clear the LSB of the BitMapCtl field of the TIM IE */
 962        ath6kl_wmi_set_pvb_cmd(ar->wmi, vif->fw_vif_idx, MCAST_AID, 0);
 963}
 964
 965void ath6kl_disconnect_event(struct ath6kl_vif *vif, u8 reason, u8 *bssid,
 966                             u8 assoc_resp_len, u8 *assoc_info,
 967                             u16 prot_reason_status)
 968{
 969        struct ath6kl *ar = vif->ar;
 970
 971        if (vif->nw_type == AP_NETWORK) {
 972                /* disconnect due to other STA vif switching channels */
 973                if (reason == BSS_DISCONNECTED &&
 974                    prot_reason_status == WMI_AP_REASON_STA_ROAM) {
 975                        ar->want_ch_switch |= 1 << vif->fw_vif_idx;
 976                        /* bail back to this channel if STA vif fails connect */
 977                        ar->last_ch = le16_to_cpu(vif->profile.ch);
 978                }
 979
 980                if (prot_reason_status == WMI_AP_REASON_MAX_STA) {
 981                        /* send max client reached notification to user space */
 982                        cfg80211_conn_failed(vif->ndev, bssid,
 983                                             NL80211_CONN_FAIL_MAX_CLIENTS,
 984                                             GFP_KERNEL);
 985                }
 986
 987                if (prot_reason_status == WMI_AP_REASON_ACL) {
 988                        /* send blocked client notification to user space */
 989                        cfg80211_conn_failed(vif->ndev, bssid,
 990                                             NL80211_CONN_FAIL_BLOCKED_CLIENT,
 991                                             GFP_KERNEL);
 992                }
 993
 994                if (!ath6kl_remove_sta(ar, bssid, prot_reason_status))
 995                        return;
 996
 997                /* if no more associated STAs, empty the mcast PS q */
 998                if (ar->sta_list_index == 0) {
 999                        spin_lock_bh(&ar->mcastpsq_lock);
1000                        skb_queue_purge(&ar->mcastpsq);
1001                        spin_unlock_bh(&ar->mcastpsq_lock);
1002
1003                        /* clear the LSB of the TIM IE's BitMapCtl field */
1004                        if (test_bit(WMI_READY, &ar->flag))
1005                                ath6kl_wmi_set_pvb_cmd(ar->wmi, vif->fw_vif_idx,
1006                                                       MCAST_AID, 0);
1007                }
1008
1009                if (!is_broadcast_ether_addr(bssid)) {
1010                        /* send event to application */
1011                        cfg80211_del_sta(vif->ndev, bssid, GFP_KERNEL);
1012                }
1013
1014                if (memcmp(vif->ndev->dev_addr, bssid, ETH_ALEN) == 0) {
1015                        memset(vif->wep_key_list, 0, sizeof(vif->wep_key_list));
1016                        clear_bit(CONNECTED, &vif->flags);
1017                }
1018                return;
1019        }
1020
1021        ath6kl_cfg80211_disconnect_event(vif, reason, bssid,
1022                                         assoc_resp_len, assoc_info,
1023                                         prot_reason_status);
1024
1025        aggr_reset_state(vif->aggr_cntxt->aggr_conn);
1026
1027        del_timer(&vif->disconnect_timer);
1028
1029        ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "disconnect reason is %d\n", reason);
1030
1031        /*
1032         * If the event is due to disconnect cmd from the host, only they
1033         * the target would stop trying to connect. Under any other
1034         * condition, target would keep trying to connect.
1035         */
1036        if (reason == DISCONNECT_CMD) {
1037                if (!ar->usr_bss_filter && test_bit(WMI_READY, &ar->flag))
1038                        ath6kl_wmi_bssfilter_cmd(ar->wmi, vif->fw_vif_idx,
1039                                                 NONE_BSS_FILTER, 0);
1040        } else {
1041                set_bit(CONNECT_PEND, &vif->flags);
1042                if (((reason == ASSOC_FAILED) &&
1043                     (prot_reason_status == 0x11)) ||
1044                    ((reason == ASSOC_FAILED) && (prot_reason_status == 0x0) &&
1045                     (vif->reconnect_flag == 1))) {
1046                        set_bit(CONNECTED, &vif->flags);
1047                        return;
1048                }
1049        }
1050
1051        /* restart disconnected concurrent vifs waiting for new channel */
1052        ath6kl_check_ch_switch(ar, ar->last_ch);
1053
1054        /* update connect & link status atomically */
1055        spin_lock_bh(&vif->if_lock);
1056        clear_bit(CONNECTED, &vif->flags);
1057        netif_carrier_off(vif->ndev);
1058        spin_unlock_bh(&vif->if_lock);
1059
1060        if ((reason != CSERV_DISCONNECT) || (vif->reconnect_flag != 1))
1061                vif->reconnect_flag = 0;
1062
1063        if (reason != CSERV_DISCONNECT)
1064                ar->user_key_ctrl = 0;
1065
1066        netif_stop_queue(vif->ndev);
1067        memset(vif->bssid, 0, sizeof(vif->bssid));
1068        vif->bss_ch = 0;
1069
1070        ath6kl_tx_data_cleanup(ar);
1071}
1072
1073struct ath6kl_vif *ath6kl_vif_first(struct ath6kl *ar)
1074{
1075        struct ath6kl_vif *vif;
1076
1077        spin_lock_bh(&ar->list_lock);
1078        if (list_empty(&ar->vif_list)) {
1079                spin_unlock_bh(&ar->list_lock);
1080                return NULL;
1081        }
1082
1083        vif = list_first_entry(&ar->vif_list, struct ath6kl_vif, list);
1084
1085        spin_unlock_bh(&ar->list_lock);
1086
1087        return vif;
1088}
1089
1090static int ath6kl_open(struct net_device *dev)
1091{
1092        struct ath6kl_vif *vif = netdev_priv(dev);
1093
1094        set_bit(WLAN_ENABLED, &vif->flags);
1095
1096        if (test_bit(CONNECTED, &vif->flags)) {
1097                netif_carrier_on(dev);
1098                netif_wake_queue(dev);
1099        } else {
1100                netif_carrier_off(dev);
1101        }
1102
1103        return 0;
1104}
1105
1106static int ath6kl_close(struct net_device *dev)
1107{
1108        struct ath6kl_vif *vif = netdev_priv(dev);
1109
1110        netif_stop_queue(dev);
1111
1112        ath6kl_cfg80211_stop(vif);
1113
1114        clear_bit(WLAN_ENABLED, &vif->flags);
1115
1116        return 0;
1117}
1118
1119static int ath6kl_set_features(struct net_device *dev,
1120                               netdev_features_t features)
1121{
1122        struct ath6kl_vif *vif = netdev_priv(dev);
1123        struct ath6kl *ar = vif->ar;
1124        int err = 0;
1125
1126        if ((features & NETIF_F_RXCSUM) &&
1127            (ar->rx_meta_ver != WMI_META_VERSION_2)) {
1128                ar->rx_meta_ver = WMI_META_VERSION_2;
1129                err = ath6kl_wmi_set_rx_frame_format_cmd(ar->wmi,
1130                                                         vif->fw_vif_idx,
1131                                                         ar->rx_meta_ver, 0, 0);
1132                if (err) {
1133                        dev->features = features & ~NETIF_F_RXCSUM;
1134                        return err;
1135                }
1136        } else if (!(features & NETIF_F_RXCSUM) &&
1137                   (ar->rx_meta_ver == WMI_META_VERSION_2)) {
1138                ar->rx_meta_ver = 0;
1139                err = ath6kl_wmi_set_rx_frame_format_cmd(ar->wmi,
1140                                                         vif->fw_vif_idx,
1141                                                         ar->rx_meta_ver, 0, 0);
1142                if (err) {
1143                        dev->features = features | NETIF_F_RXCSUM;
1144                        return err;
1145                }
1146        }
1147
1148        return err;
1149}
1150
1151static void ath6kl_set_multicast_list(struct net_device *ndev)
1152{
1153        struct ath6kl_vif *vif = netdev_priv(ndev);
1154        bool mc_all_on = false;
1155        int mc_count = netdev_mc_count(ndev);
1156        struct netdev_hw_addr *ha;
1157        bool found;
1158        struct ath6kl_mc_filter *mc_filter, *tmp;
1159        struct list_head mc_filter_new;
1160        int ret;
1161
1162        if (!test_bit(WMI_READY, &vif->ar->flag) ||
1163            !test_bit(WLAN_ENABLED, &vif->flags))
1164                return;
1165
1166        /* Enable multicast-all filter. */
1167        mc_all_on = !!(ndev->flags & IFF_PROMISC) ||
1168                    !!(ndev->flags & IFF_ALLMULTI) ||
1169                    !!(mc_count > ATH6K_MAX_MC_FILTERS_PER_LIST);
1170
1171        if (mc_all_on)
1172                set_bit(NETDEV_MCAST_ALL_ON, &vif->flags);
1173        else
1174                clear_bit(NETDEV_MCAST_ALL_ON, &vif->flags);
1175
1176        if (test_bit(ATH6KL_FW_CAPABILITY_WOW_MULTICAST_FILTER,
1177                     vif->ar->fw_capabilities)) {
1178                mc_all_on = mc_all_on || (vif->ar->state == ATH6KL_STATE_ON);
1179        }
1180
1181        if (!(ndev->flags & IFF_MULTICAST)) {
1182                mc_all_on = false;
1183                set_bit(NETDEV_MCAST_ALL_OFF, &vif->flags);
1184        } else {
1185                clear_bit(NETDEV_MCAST_ALL_OFF, &vif->flags);
1186        }
1187
1188        /* Enable/disable "multicast-all" filter*/
1189        ath6kl_dbg(ATH6KL_DBG_TRC, "%s multicast-all filter\n",
1190                   mc_all_on ? "enabling" : "disabling");
1191
1192        ret = ath6kl_wmi_mcast_filter_cmd(vif->ar->wmi, vif->fw_vif_idx,
1193                                                  mc_all_on);
1194        if (ret) {
1195                ath6kl_warn("Failed to %s multicast-all receive\n",
1196                            mc_all_on ? "enable" : "disable");
1197                return;
1198        }
1199
1200        if (test_bit(NETDEV_MCAST_ALL_ON, &vif->flags))
1201                return;
1202
1203        /* Keep the driver and firmware mcast list in sync. */
1204        list_for_each_entry_safe(mc_filter, tmp, &vif->mc_filter, list) {
1205                found = false;
1206                netdev_for_each_mc_addr(ha, ndev) {
1207                        if (memcmp(ha->addr, mc_filter->hw_addr,
1208                                   ATH6KL_MCAST_FILTER_MAC_ADDR_SIZE) == 0) {
1209                                found = true;
1210                                break;
1211                        }
1212                }
1213
1214                if (!found) {
1215                        /*
1216                         * Delete the filter which was previously set
1217                         * but not in the new request.
1218                         */
1219                        ath6kl_dbg(ATH6KL_DBG_TRC,
1220                                   "Removing %pM from multicast filter\n",
1221                                   mc_filter->hw_addr);
1222                        ret = ath6kl_wmi_add_del_mcast_filter_cmd(vif->ar->wmi,
1223                                        vif->fw_vif_idx, mc_filter->hw_addr,
1224                                        false);
1225                        if (ret) {
1226                                ath6kl_warn("Failed to remove multicast filter:%pM\n",
1227                                            mc_filter->hw_addr);
1228                                return;
1229                        }
1230
1231                        list_del(&mc_filter->list);
1232                        kfree(mc_filter);
1233                }
1234        }
1235
1236        INIT_LIST_HEAD(&mc_filter_new);
1237
1238        netdev_for_each_mc_addr(ha, ndev) {
1239                found = false;
1240                list_for_each_entry(mc_filter, &vif->mc_filter, list) {
1241                        if (memcmp(ha->addr, mc_filter->hw_addr,
1242                                   ATH6KL_MCAST_FILTER_MAC_ADDR_SIZE) == 0) {
1243                                found = true;
1244                                break;
1245                        }
1246                }
1247
1248                if (!found) {
1249                        mc_filter = kzalloc(sizeof(struct ath6kl_mc_filter),
1250                                            GFP_ATOMIC);
1251                        if (!mc_filter) {
1252                                WARN_ON(1);
1253                                goto out;
1254                        }
1255
1256                        memcpy(mc_filter->hw_addr, ha->addr,
1257                               ATH6KL_MCAST_FILTER_MAC_ADDR_SIZE);
1258                        /* Set the multicast filter */
1259                        ath6kl_dbg(ATH6KL_DBG_TRC,
1260                                   "Adding %pM to multicast filter list\n",
1261                                   mc_filter->hw_addr);
1262                        ret = ath6kl_wmi_add_del_mcast_filter_cmd(vif->ar->wmi,
1263                                        vif->fw_vif_idx, mc_filter->hw_addr,
1264                                        true);
1265                        if (ret) {
1266                                ath6kl_warn("Failed to add multicast filter :%pM\n",
1267                                            mc_filter->hw_addr);
1268                                kfree(mc_filter);
1269                                goto out;
1270                        }
1271
1272                        list_add_tail(&mc_filter->list, &mc_filter_new);
1273                }
1274        }
1275
1276out:
1277        list_splice_tail(&mc_filter_new, &vif->mc_filter);
1278}
1279
1280static const struct net_device_ops ath6kl_netdev_ops = {
1281        .ndo_open               = ath6kl_open,
1282        .ndo_stop               = ath6kl_close,
1283        .ndo_start_xmit         = ath6kl_data_tx,
1284        .ndo_set_features       = ath6kl_set_features,
1285        .ndo_set_rx_mode        = ath6kl_set_multicast_list,
1286};
1287
1288void init_netdev(struct net_device *dev)
1289{
1290        struct ath6kl *ar = ath6kl_priv(dev);
1291
1292        dev->netdev_ops = &ath6kl_netdev_ops;
1293        dev->needs_free_netdev = true;
1294        dev->watchdog_timeo = ATH6KL_TX_TIMEOUT;
1295
1296        dev->needed_headroom = ETH_HLEN;
1297        dev->needed_headroom += roundup(sizeof(struct ath6kl_llc_snap_hdr) +
1298                                        sizeof(struct wmi_data_hdr) +
1299                                        HTC_HDR_LENGTH +
1300                                        WMI_MAX_TX_META_SZ +
1301                                        ATH6KL_HTC_ALIGN_BYTES, 4);
1302
1303        if (!test_bit(ATH6KL_FW_CAPABILITY_NO_IP_CHECKSUM,
1304                      ar->fw_capabilities))
1305                dev->hw_features |= NETIF_F_IP_CSUM | NETIF_F_RXCSUM;
1306
1307        return;
1308}
1309