drivers/net/wireless/ath/ath6kl/main.c

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