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, 0,
 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, ATH6KL_KEY_SEQ_LEN,
 481                         ik->key,
 482                         KEY_OP_INIT_VAL, NULL, SYNC_BOTH_WMIFLAG);
 483                 if (res) {
 484                         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "Delayed "
 485                                    "addkey failed: %d\n", res);
 486                 }
 487                 break;
 488         }
 489
 490         ath6kl_wmi_bssfilter_cmd(ar->wmi, vif->fw_vif_idx, NONE_BSS_FILTER, 0);
 491         set_bit(CONNECTED, &vif->flags);
 492         netif_carrier_on(vif->ndev);
 493 }
 494
 495 void ath6kl_connect_ap_mode_sta(struct ath6kl_vif *vif, u16 aid, u8 *mac_addr,
 496                                 u8 keymgmt, u8 ucipher, u8 auth,
 497                                 u8 assoc_req_len, u8 *assoc_info)
 498 {
 499         struct ath6kl *ar = vif->ar;
 500         u8 *ies = NULL, *wpa_ie = NULL, *pos;
 501         size_t ies_len = 0;
 502         struct station_info sinfo;
 503
 504         ath6kl_dbg(ATH6KL_DBG_TRC, "new station %pM aid=%d\n", mac_addr, aid);
 505
 506         if (assoc_req_len > sizeof(struct ieee80211_hdr_3addr)) {
 507                 struct ieee80211_mgmt *mgmt =
 508                         (struct ieee80211_mgmt *) assoc_info;
 509                 if (ieee80211_is_assoc_req(mgmt->frame_control) &&
 510                     assoc_req_len >= sizeof(struct ieee80211_hdr_3addr) +
 511                     sizeof(mgmt->u.assoc_req)) {
 512                         ies = mgmt->u.assoc_req.variable;
 513                         ies_len = assoc_info + assoc_req_len - ies;
 514                 } else if (ieee80211_is_reassoc_req(mgmt->frame_control) &&
 515                            assoc_req_len >= sizeof(struct ieee80211_hdr_3addr)
 516                            + sizeof(mgmt->u.reassoc_req)) {
 517                         ies = mgmt->u.reassoc_req.variable;
 518                         ies_len = assoc_info + assoc_req_len - ies;
 519                 }
 520         }
 521
 522         pos = ies;
 523         while (pos && pos + 1 < ies + ies_len) {
 524                 if (pos + 2 + pos[1] > ies + ies_len)
 525                         break;
 526                 if (pos[0] == WLAN_EID_RSN)
 527                         wpa_ie = pos; /* RSN IE */
 528                 else if (pos[0] == WLAN_EID_VENDOR_SPECIFIC &&
 529                          pos[1] >= 4 &&
 530                          pos[2] == 0x00 && pos[3] == 0x50 && pos[4] == 0xf2) {
 531                         if (pos[5] == 0x01)
 532                                 wpa_ie = pos; /* WPA IE */
 533                         else if (pos[5] == 0x04) {
 534                                 wpa_ie = pos; /* WPS IE */
 535                                 break; /* overrides WPA/RSN IE */
 536                         }
 537                 }
 538                 pos += 2 + pos[1];
 539         }
 540
 541         ath6kl_add_new_sta(ar, mac_addr, aid, wpa_ie,
 542                            wpa_ie ? 2 + wpa_ie[1] : 0,
 543                            keymgmt, ucipher, auth);
 544
 545         /* send event to application */
 546         memset(&sinfo, 0, sizeof(sinfo));
 547
 548         /* TODO: sinfo.generation */
 549
 550         sinfo.assoc_req_ies = ies;
 551         sinfo.assoc_req_ies_len = ies_len;
 552         sinfo.filled |= STATION_INFO_ASSOC_REQ_IES;
 553
 554         cfg80211_new_sta(vif->ndev, mac_addr, &sinfo, GFP_KERNEL);
 555
 556         netif_wake_queue(vif->ndev);
 557 }
 558
 559 void disconnect_timer_handler(unsigned long ptr)
 560 {
 561         struct net_device *dev = (struct net_device *)ptr;
 562         struct ath6kl_vif *vif = netdev_priv(dev);
 563
 564         ath6kl_init_profile_info(vif);
 565         ath6kl_disconnect(vif);
 566 }
 567
 568 void ath6kl_disconnect(struct ath6kl_vif *vif)
 569 {
 570         if (test_bit(CONNECTED, &vif->flags) ||
 571             test_bit(CONNECT_PEND, &vif->flags)) {
 572                 ath6kl_wmi_disconnect_cmd(vif->ar->wmi, vif->fw_vif_idx);
 573                 /*
 574                  * Disconnect command is issued, clear the connect pending
 575                  * flag. The connected flag will be cleared in
 576                  * disconnect event notification.
 577                  */
 578                 clear_bit(CONNECT_PEND, &vif->flags);
 579         }
 580 }
 581
 582 /* WMI Event handlers */
 583
 584 static const char *get_hw_id_string(u32 id)
 585 {
 586         switch (id) {
 587         case AR6003_REV1_VERSION:
 588                 return "1.0";
 589         case AR6003_REV2_VERSION:
 590                 return "2.0";
 591         case AR6003_REV3_VERSION:
 592                 return "2.1.1";
 593         default:
 594                 return "unknown";
 595         }
 596 }
 597
 598 void ath6kl_ready_event(void *devt, u8 *datap, u32 sw_ver, u32 abi_ver)
 599 {
 600         struct ath6kl *ar = devt;
 601
 602         memcpy(ar->mac_addr, datap, ETH_ALEN);
 603         ath6kl_dbg(ATH6KL_DBG_TRC, "%s: mac addr = %pM\n",
 604                    __func__, ar->mac_addr);
 605
 606         ar->version.wlan_ver = sw_ver;
 607         ar->version.abi_ver = abi_ver;
 608
 609         snprintf(ar->wiphy->fw_version,
 610                  sizeof(ar->wiphy->fw_version),
 611                  "%u.%u.%u.%u",
 612                  (ar->version.wlan_ver & 0xf0000000) >> 28,
 613                  (ar->version.wlan_ver & 0x0f000000) >> 24,
 614                  (ar->version.wlan_ver & 0x00ff0000) >> 16,
 615                  (ar->version.wlan_ver & 0x0000ffff));
 616
 617         /* indicate to the waiting thread that the ready event was received */
 618         set_bit(WMI_READY, &ar->flag);
 619         wake_up(&ar->event_wq);
 620
 621         if (test_and_clear_bit(FIRST_BOOT, &ar->flag)) {
 622                 ath6kl_info("hw %s fw %s%s\n",
 623                             get_hw_id_string(ar->wiphy->hw_version),
 624                             ar->wiphy->fw_version,
 625                             test_bit(TESTMODE, &ar->flag) ? " testmode" : "");
 626         }
 627 }
 628
 629 void ath6kl_scan_complete_evt(struct ath6kl_vif *vif, int status)
 630 {
 631         struct ath6kl *ar = vif->ar;
 632         bool aborted = false;
 633
 634         if (status != WMI_SCAN_STATUS_SUCCESS)
 635                 aborted = true;
 636
 637         ath6kl_cfg80211_scan_complete_event(vif, aborted);
 638
 639         if (!ar->usr_bss_filter) {
 640                 clear_bit(CLEAR_BSSFILTER_ON_BEACON, &vif->flags);
 641                 ath6kl_wmi_bssfilter_cmd(ar->wmi, vif->fw_vif_idx,
 642                                          NONE_BSS_FILTER, 0);
 643         }
 644
 645         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "scan complete: %d\n", status);
 646 }
 647
 648 void ath6kl_connect_event(struct ath6kl_vif *vif, u16 channel, u8 *bssid,
 649                           u16 listen_int, u16 beacon_int,
 650                           enum network_type net_type, u8 beacon_ie_len,
 651                           u8 assoc_req_len, u8 assoc_resp_len,
 652                           u8 *assoc_info)
 653 {
 654         struct ath6kl *ar = vif->ar;
 655
 656         ath6kl_cfg80211_connect_event(vif, channel, bssid,
 657                                       listen_int, beacon_int,
 658                                       net_type, beacon_ie_len,
 659                                       assoc_req_len, assoc_resp_len,
 660                                       assoc_info);
 661
 662         memcpy(vif->bssid, bssid, sizeof(vif->bssid));
 663         vif->bss_ch = channel;
 664
 665         if ((vif->nw_type == INFRA_NETWORK))
 666                 ath6kl_wmi_listeninterval_cmd(ar->wmi, vif->fw_vif_idx,
 667                                               ar->listen_intvl_t,
 668                                               ar->listen_intvl_b);
 669
 670         netif_wake_queue(vif->ndev);
 671
 672         /* Update connect & link status atomically */
 673         spin_lock_bh(&vif->if_lock);
 674         set_bit(CONNECTED, &vif->flags);
 675         clear_bit(CONNECT_PEND, &vif->flags);
 676         netif_carrier_on(vif->ndev);
 677         spin_unlock_bh(&vif->if_lock);
 678
 679         aggr_reset_state(vif->aggr_cntxt);
 680         vif->reconnect_flag = 0;
 681
 682         if ((vif->nw_type == ADHOC_NETWORK) && ar->ibss_ps_enable) {
 683                 memset(ar->node_map, 0, sizeof(ar->node_map));
 684                 ar->node_num = 0;
 685                 ar->next_ep_id = ENDPOINT_2;
 686         }
 687
 688         if (!ar->usr_bss_filter) {
 689                 set_bit(CLEAR_BSSFILTER_ON_BEACON, &vif->flags);
 690                 ath6kl_wmi_bssfilter_cmd(ar->wmi, vif->fw_vif_idx,
 691                                          CURRENT_BSS_FILTER, 0);
 692         }
 693 }
 694
 695 void ath6kl_tkip_micerr_event(struct ath6kl_vif *vif, u8 keyid, bool ismcast)
 696 {
 697         struct ath6kl_sta *sta;
 698         struct ath6kl *ar = vif->ar;
 699         u8 tsc[6];
 700
 701         /*
 702          * For AP case, keyid will have aid of STA which sent pkt with
 703          * MIC error. Use this aid to get MAC & send it to hostapd.
 704          */
 705         if (vif->nw_type == AP_NETWORK) {
 706                 sta = ath6kl_find_sta_by_aid(ar, (keyid >> 2));
 707                 if (!sta)
 708                         return;
 709
 710                 ath6kl_dbg(ATH6KL_DBG_TRC,
 711                            "ap tkip mic error received from aid=%d\n", keyid);
 712
 713                 memset(tsc, 0, sizeof(tsc)); /* FIX: get correct TSC */
 714                 cfg80211_michael_mic_failure(vif->ndev, sta->mac,
 715                                              NL80211_KEYTYPE_PAIRWISE, keyid,
 716                                              tsc, GFP_KERNEL);
 717         } else
 718                 ath6kl_cfg80211_tkip_micerr_event(vif, keyid, ismcast);
 719
 720 }
 721
 722 static void ath6kl_update_target_stats(struct ath6kl_vif *vif, u8 *ptr, u32 len)
 723 {
 724         struct wmi_target_stats *tgt_stats =
 725                 (struct wmi_target_stats *) ptr;
 726         struct ath6kl *ar = vif->ar;
 727         struct target_stats *stats = &vif->target_stats;
 728         struct tkip_ccmp_stats *ccmp_stats;
 729         u8 ac;
 730
 731         if (len < sizeof(*tgt_stats))
 732                 return;
 733
 734         ath6kl_dbg(ATH6KL_DBG_TRC, "updating target stats\n");
 735
 736         stats->tx_pkt += le32_to_cpu(tgt_stats->stats.tx.pkt);
 737         stats->tx_byte += le32_to_cpu(tgt_stats->stats.tx.byte);
 738         stats->tx_ucast_pkt += le32_to_cpu(tgt_stats->stats.tx.ucast_pkt);
 739         stats->tx_ucast_byte += le32_to_cpu(tgt_stats->stats.tx.ucast_byte);
 740         stats->tx_mcast_pkt += le32_to_cpu(tgt_stats->stats.tx.mcast_pkt);
 741         stats->tx_mcast_byte += le32_to_cpu(tgt_stats->stats.tx.mcast_byte);
 742         stats->tx_bcast_pkt  += le32_to_cpu(tgt_stats->stats.tx.bcast_pkt);
 743         stats->tx_bcast_byte += le32_to_cpu(tgt_stats->stats.tx.bcast_byte);
 744         stats->tx_rts_success_cnt +=
 745                 le32_to_cpu(tgt_stats->stats.tx.rts_success_cnt);
 746
 747         for (ac = 0; ac < WMM_NUM_AC; ac++)
 748                 stats->tx_pkt_per_ac[ac] +=
 749                         le32_to_cpu(tgt_stats->stats.tx.pkt_per_ac[ac]);
 750
 751         stats->tx_err += le32_to_cpu(tgt_stats->stats.tx.err);
 752         stats->tx_fail_cnt += le32_to_cpu(tgt_stats->stats.tx.fail_cnt);
 753         stats->tx_retry_cnt += le32_to_cpu(tgt_stats->stats.tx.retry_cnt);
 754         stats->tx_mult_retry_cnt +=
 755                 le32_to_cpu(tgt_stats->stats.tx.mult_retry_cnt);
 756         stats->tx_rts_fail_cnt +=
 757                 le32_to_cpu(tgt_stats->stats.tx.rts_fail_cnt);
 758         stats->tx_ucast_rate =
 759             ath6kl_wmi_get_rate(a_sle32_to_cpu(tgt_stats->stats.tx.ucast_rate));
 760
 761         stats->rx_pkt += le32_to_cpu(tgt_stats->stats.rx.pkt);
 762         stats->rx_byte += le32_to_cpu(tgt_stats->stats.rx.byte);
 763         stats->rx_ucast_pkt += le32_to_cpu(tgt_stats->stats.rx.ucast_pkt);
 764         stats->rx_ucast_byte += le32_to_cpu(tgt_stats->stats.rx.ucast_byte);
 765         stats->rx_mcast_pkt += le32_to_cpu(tgt_stats->stats.rx.mcast_pkt);
 766         stats->rx_mcast_byte += le32_to_cpu(tgt_stats->stats.rx.mcast_byte);
 767         stats->rx_bcast_pkt += le32_to_cpu(tgt_stats->stats.rx.bcast_pkt);
 768         stats->rx_bcast_byte += le32_to_cpu(tgt_stats->stats.rx.bcast_byte);
 769         stats->rx_frgment_pkt += le32_to_cpu(tgt_stats->stats.rx.frgment_pkt);
 770         stats->rx_err += le32_to_cpu(tgt_stats->stats.rx.err);
 771         stats->rx_crc_err += le32_to_cpu(tgt_stats->stats.rx.crc_err);
 772         stats->rx_key_cache_miss +=
 773                 le32_to_cpu(tgt_stats->stats.rx.key_cache_miss);
 774         stats->rx_decrypt_err += le32_to_cpu(tgt_stats->stats.rx.decrypt_err);
 775         stats->rx_dupl_frame += le32_to_cpu(tgt_stats->stats.rx.dupl_frame);
 776         stats->rx_ucast_rate =
 777             ath6kl_wmi_get_rate(a_sle32_to_cpu(tgt_stats->stats.rx.ucast_rate));
 778
 779         ccmp_stats = &tgt_stats->stats.tkip_ccmp_stats;
 780
 781         stats->tkip_local_mic_fail +=
 782                 le32_to_cpu(ccmp_stats->tkip_local_mic_fail);
 783         stats->tkip_cnter_measures_invoked +=
 784                 le32_to_cpu(ccmp_stats->tkip_cnter_measures_invoked);
 785         stats->tkip_fmt_err += le32_to_cpu(ccmp_stats->tkip_fmt_err);
 786
 787         stats->ccmp_fmt_err += le32_to_cpu(ccmp_stats->ccmp_fmt_err);
 788         stats->ccmp_replays += le32_to_cpu(ccmp_stats->ccmp_replays);
 789
 790         stats->pwr_save_fail_cnt +=
 791                 le32_to_cpu(tgt_stats->pm_stats.pwr_save_failure_cnt);
 792         stats->noise_floor_calib =
 793                 a_sle32_to_cpu(tgt_stats->noise_floor_calib);
 794
 795         stats->cs_bmiss_cnt +=
 796                 le32_to_cpu(tgt_stats->cserv_stats.cs_bmiss_cnt);
 797         stats->cs_low_rssi_cnt +=
 798                 le32_to_cpu(tgt_stats->cserv_stats.cs_low_rssi_cnt);
 799         stats->cs_connect_cnt +=
 800                 le16_to_cpu(tgt_stats->cserv_stats.cs_connect_cnt);
 801         stats->cs_discon_cnt +=
 802                 le16_to_cpu(tgt_stats->cserv_stats.cs_discon_cnt);
 803
 804         stats->cs_ave_beacon_rssi =
 805                 a_sle16_to_cpu(tgt_stats->cserv_stats.cs_ave_beacon_rssi);
 806
 807         stats->cs_last_roam_msec =
 808                 tgt_stats->cserv_stats.cs_last_roam_msec;
 809         stats->cs_snr = tgt_stats->cserv_stats.cs_snr;
 810         stats->cs_rssi = a_sle16_to_cpu(tgt_stats->cserv_stats.cs_rssi);
 811
 812         stats->lq_val = le32_to_cpu(tgt_stats->lq_val);
 813
 814         stats->wow_pkt_dropped +=
 815                 le32_to_cpu(tgt_stats->wow_stats.wow_pkt_dropped);
 816         stats->wow_host_pkt_wakeups +=
 817                 tgt_stats->wow_stats.wow_host_pkt_wakeups;
 818         stats->wow_host_evt_wakeups +=
 819                 tgt_stats->wow_stats.wow_host_evt_wakeups;
 820         stats->wow_evt_discarded +=
 821                 le16_to_cpu(tgt_stats->wow_stats.wow_evt_discarded);
 822
 823         if (test_bit(STATS_UPDATE_PEND, &vif->flags)) {
 824                 clear_bit(STATS_UPDATE_PEND, &vif->flags);
 825                 wake_up(&ar->event_wq);
 826         }
 827 }
 828
 829 static void ath6kl_add_le32(__le32 *var, __le32 val)
 830 {
 831         *var = cpu_to_le32(le32_to_cpu(*var) + le32_to_cpu(val));
 832 }
 833
 834 void ath6kl_tgt_stats_event(struct ath6kl_vif *vif, u8 *ptr, u32 len)
 835 {
 836         struct wmi_ap_mode_stat *p = (struct wmi_ap_mode_stat *) ptr;
 837         struct ath6kl *ar = vif->ar;
 838         struct wmi_ap_mode_stat *ap = &ar->ap_stats;
 839         struct wmi_per_sta_stat *st_ap, *st_p;
 840         u8 ac;
 841
 842         if (vif->nw_type == AP_NETWORK) {
 843                 if (len < sizeof(*p))
 844                         return;
 845
 846                 for (ac = 0; ac < AP_MAX_NUM_STA; ac++) {
 847                         st_ap = &ap->sta[ac];
 848                         st_p = &p->sta[ac];
 849
 850                         ath6kl_add_le32(&st_ap->tx_bytes, st_p->tx_bytes);
 851                         ath6kl_add_le32(&st_ap->tx_pkts, st_p->tx_pkts);
 852                         ath6kl_add_le32(&st_ap->tx_error, st_p->tx_error);
 853                         ath6kl_add_le32(&st_ap->tx_discard, st_p->tx_discard);
 854                         ath6kl_add_le32(&st_ap->rx_bytes, st_p->rx_bytes);
 855                         ath6kl_add_le32(&st_ap->rx_pkts, st_p->rx_pkts);
 856                         ath6kl_add_le32(&st_ap->rx_error, st_p->rx_error);
 857                         ath6kl_add_le32(&st_ap->rx_discard, st_p->rx_discard);
 858                 }
 859
 860         } else {
 861                 ath6kl_update_target_stats(vif, ptr, len);
 862         }
 863 }
 864
 865 void ath6kl_wakeup_event(void *dev)
 866 {
 867         struct ath6kl *ar = (struct ath6kl *) dev;
 868
 869         wake_up(&ar->event_wq);
 870 }
 871
 872 void ath6kl_txpwr_rx_evt(void *devt, u8 tx_pwr)
 873 {
 874         struct ath6kl *ar = (struct ath6kl *) devt;
 875
 876         ar->tx_pwr = tx_pwr;
 877         wake_up(&ar->event_wq);
 878 }
 879
 880 void ath6kl_pspoll_event(struct ath6kl_vif *vif, u8 aid)
 881 {
 882         struct ath6kl_sta *conn;
 883         struct sk_buff *skb;
 884         bool psq_empty = false;
 885         struct ath6kl *ar = vif->ar;
 886
 887         conn = ath6kl_find_sta_by_aid(ar, aid);
 888
 889         if (!conn)
 890                 return;
 891         /*
 892          * Send out a packet queued on ps queue. When the ps queue
 893          * becomes empty update the PVB for this station.
 894          */
 895         spin_lock_bh(&conn->psq_lock);
 896         psq_empty  = skb_queue_empty(&conn->psq);
 897         spin_unlock_bh(&conn->psq_lock);
 898
 899         if (psq_empty)
 900                 /* TODO: Send out a NULL data frame */
 901                 return;
 902
 903         spin_lock_bh(&conn->psq_lock);
 904         skb = skb_dequeue(&conn->psq);
 905         spin_unlock_bh(&conn->psq_lock);
 906
 907         conn->sta_flags |= STA_PS_POLLED;
 908         ath6kl_data_tx(skb, vif->ndev);
 909         conn->sta_flags &= ~STA_PS_POLLED;
 910
 911         spin_lock_bh(&conn->psq_lock);
 912         psq_empty  = skb_queue_empty(&conn->psq);
 913         spin_unlock_bh(&conn->psq_lock);
 914
 915         if (psq_empty)
 916                 ath6kl_wmi_set_pvb_cmd(ar->wmi, vif->fw_vif_idx, conn->aid, 0);
 917 }
 918
 919 void ath6kl_dtimexpiry_event(struct ath6kl_vif *vif)
 920 {
 921         bool mcastq_empty = false;
 922         struct sk_buff *skb;
 923         struct ath6kl *ar = vif->ar;
 924
 925         /*
 926          * If there are no associated STAs, ignore the DTIM expiry event.
 927          * There can be potential race conditions where the last associated
 928          * STA may disconnect & before the host could clear the 'Indicate
 929          * DTIM' request to the firmware, the firmware would have just
 930          * indicated a DTIM expiry event. The race is between 'clear DTIM
 931          * expiry cmd' going from the host to the firmware & the DTIM
 932          * expiry event happening from the firmware to the host.
 933          */
 934         if (!ar->sta_list_index)
 935                 return;
 936
 937         spin_lock_bh(&ar->mcastpsq_lock);
 938         mcastq_empty = skb_queue_empty(&ar->mcastpsq);
 939         spin_unlock_bh(&ar->mcastpsq_lock);
 940
 941         if (mcastq_empty)
 942                 return;
 943
 944         /* set the STA flag to dtim_expired for the frame to go out */
 945         set_bit(DTIM_EXPIRED, &vif->flags);
 946
 947         spin_lock_bh(&ar->mcastpsq_lock);
 948         while ((skb = skb_dequeue(&ar->mcastpsq)) != NULL) {
 949                 spin_unlock_bh(&ar->mcastpsq_lock);
 950
 951                 ath6kl_data_tx(skb, vif->ndev);
 952
 953                 spin_lock_bh(&ar->mcastpsq_lock);
 954         }
 955         spin_unlock_bh(&ar->mcastpsq_lock);
 956
 957         clear_bit(DTIM_EXPIRED, &vif->flags);
 958
 959         /* clear the LSB of the BitMapCtl field of the TIM IE */
 960         ath6kl_wmi_set_pvb_cmd(ar->wmi, vif->fw_vif_idx, MCAST_AID, 0);
 961 }
 962
 963 void ath6kl_disconnect_event(struct ath6kl_vif *vif, u8 reason, u8 *bssid,
 964                              u8 assoc_resp_len, u8 *assoc_info,
 965                              u16 prot_reason_status)
 966 {
 967         struct ath6kl *ar = vif->ar;
 968
 969         if (vif->nw_type == AP_NETWORK) {
 970                 if (!ath6kl_remove_sta(ar, bssid, prot_reason_status))
 971                         return;
 972
 973                 /* if no more associated STAs, empty the mcast PS q */
 974                 if (ar->sta_list_index == 0) {
 975                         spin_lock_bh(&ar->mcastpsq_lock);
 976                         skb_queue_purge(&ar->mcastpsq);
 977                         spin_unlock_bh(&ar->mcastpsq_lock);
 978
 979                         /* clear the LSB of the TIM IE's BitMapCtl field */
 980                         if (test_bit(WMI_READY, &ar->flag))
 981                                 ath6kl_wmi_set_pvb_cmd(ar->wmi, vif->fw_vif_idx,
 982                                                        MCAST_AID, 0);
 983                 }
 984
 985                 if (!is_broadcast_ether_addr(bssid)) {
 986                         /* send event to application */
 987                         cfg80211_del_sta(vif->ndev, bssid, GFP_KERNEL);
 988                 }
 989
 990                 if (memcmp(vif->ndev->dev_addr, bssid, ETH_ALEN) == 0) {
 991                         memset(vif->wep_key_list, 0, sizeof(vif->wep_key_list));
 992                         clear_bit(CONNECTED, &vif->flags);
 993                 }
 994                 return;
 995         }
 996
 997         ath6kl_cfg80211_disconnect_event(vif, reason, bssid,
 998                                        assoc_resp_len, assoc_info,
 999                                        prot_reason_status);
1000
1001         aggr_reset_state(vif->aggr_cntxt);
1002
1003         del_timer(&vif->disconnect_timer);
1004
1005         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "disconnect reason is %d\n", reason);
1006
1007         /*
1008          * If the event is due to disconnect cmd from the host, only they
1009          * the target would stop trying to connect. Under any other
1010          * condition, target would keep trying to connect.
1011          */
1012         if (reason == DISCONNECT_CMD) {
1013                 if (!ar->usr_bss_filter && test_bit(WMI_READY, &ar->flag))
1014                         ath6kl_wmi_bssfilter_cmd(ar->wmi, vif->fw_vif_idx,
1015                                                  NONE_BSS_FILTER, 0);
1016         } else {
1017                 set_bit(CONNECT_PEND, &vif->flags);
1018                 if (((reason == ASSOC_FAILED) &&
1019                     (prot_reason_status == 0x11)) ||
1020                     ((reason == ASSOC_FAILED) && (prot_reason_status == 0x0)
1021                      && (vif->reconnect_flag == 1))) {
1022                         set_bit(CONNECTED, &vif->flags);
1023                         return;
1024                 }
1025         }
1026
1027         /* update connect & link status atomically */
1028         spin_lock_bh(&vif->if_lock);
1029         clear_bit(CONNECTED, &vif->flags);
1030         netif_carrier_off(vif->ndev);
1031         spin_unlock_bh(&vif->if_lock);
1032
1033         if ((reason != CSERV_DISCONNECT) || (vif->reconnect_flag != 1))
1034                 vif->reconnect_flag = 0;
1035
1036         if (reason != CSERV_DISCONNECT)
1037                 ar->user_key_ctrl = 0;
1038
1039         netif_stop_queue(vif->ndev);
1040         memset(vif->bssid, 0, sizeof(vif->bssid));
1041         vif->bss_ch = 0;
1042
1043         ath6kl_tx_data_cleanup(ar);
1044 }
1045
1046 struct ath6kl_vif *ath6kl_vif_first(struct ath6kl *ar)
1047 {
1048         struct ath6kl_vif *vif;
1049
1050         spin_lock_bh(&ar->list_lock);
1051         if (list_empty(&ar->vif_list)) {
1052                 spin_unlock_bh(&ar->list_lock);
1053                 return NULL;
1054         }
1055
1056         vif = list_first_entry(&ar->vif_list, struct ath6kl_vif, list);
1057
1058         spin_unlock_bh(&ar->list_lock);
1059
1060         return vif;
1061 }
1062
1063 static int ath6kl_open(struct net_device *dev)
1064 {
1065         struct ath6kl_vif *vif = netdev_priv(dev);
1066
1067         set_bit(WLAN_ENABLED, &vif->flags);
1068
1069         if (test_bit(CONNECTED, &vif->flags)) {
1070                 netif_carrier_on(dev);
1071                 netif_wake_queue(dev);
1072         } else
1073                 netif_carrier_off(dev);
1074
1075         return 0;
1076 }
1077
1078 static int ath6kl_close(struct net_device *dev)
1079 {
1080         struct ath6kl *ar = ath6kl_priv(dev);
1081         struct ath6kl_vif *vif = netdev_priv(dev);
1082
1083         netif_stop_queue(dev);
1084
1085         ath6kl_disconnect(vif);
1086
1087         if (test_bit(WMI_READY, &ar->flag)) {
1088                 if (ath6kl_wmi_scanparams_cmd(ar->wmi, vif->fw_vif_idx, 0xFFFF,
1089                                               0, 0, 0, 0, 0, 0, 0, 0, 0))
1090                         return -EIO;
1091
1092         }
1093
1094         ath6kl_cfg80211_scan_complete_event(vif, true);
1095
1096         clear_bit(WLAN_ENABLED, &vif->flags);
1097
1098         return 0;
1099 }
1100
1101 static struct net_device_stats *ath6kl_get_stats(struct net_device *dev)
1102 {
1103         struct ath6kl_vif *vif = netdev_priv(dev);
1104
1105         return &vif->net_stats;
1106 }
1107
1108 static struct net_device_ops ath6kl_netdev_ops = {
1109         .ndo_open               = ath6kl_open,
1110         .ndo_stop               = ath6kl_close,
1111         .ndo_start_xmit         = ath6kl_data_tx,
1112         .ndo_get_stats          = ath6kl_get_stats,
1113 };
1114
1115 void init_netdev(struct net_device *dev)
1116 {
1117         dev->netdev_ops = &ath6kl_netdev_ops;
1118         dev->destructor = free_netdev;
1119         dev->watchdog_timeo = ATH6KL_TX_TIMEOUT;
1120
1121         dev->needed_headroom = ETH_HLEN;
1122         dev->needed_headroom += sizeof(struct ath6kl_llc_snap_hdr) +
1123                                 sizeof(struct wmi_data_hdr) + HTC_HDR_LENGTH
1124                                 + WMI_MAX_TX_META_SZ + ATH6KL_HTC_ALIGN_BYTES;
1125
1126         return;
1127 }