drivers/net/wireless/ath/ath6kl/wmi.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 <linux/ip.h>
  18 #include "core.h"
  19 #include "debug.h"
  20
  21 static int ath6kl_wmi_sync_point(struct wmi *wmi);
  22
  23 static const s32 wmi_rate_tbl[][2] = {
  24         /* {W/O SGI, with SGI} */
  25         {1000, 1000},
  26         {2000, 2000},
  27         {5500, 5500},
  28         {11000, 11000},
  29         {6000, 6000},
  30         {9000, 9000},
  31         {12000, 12000},
  32         {18000, 18000},
  33         {24000, 24000},
  34         {36000, 36000},
  35         {48000, 48000},
  36         {54000, 54000},
  37         {6500, 7200},
  38         {13000, 14400},
  39         {19500, 21700},
  40         {26000, 28900},
  41         {39000, 43300},
  42         {52000, 57800},
  43         {58500, 65000},
  44         {65000, 72200},
  45         {13500, 15000},
  46         {27000, 30000},
  47         {40500, 45000},
  48         {54000, 60000},
  49         {81000, 90000},
  50         {108000, 120000},
  51         {121500, 135000},
  52         {135000, 150000},
  53         {0, 0}
  54 };
  55
  56 /* 802.1d to AC mapping. Refer pg 57 of WMM-test-plan-v1.2 */
  57 static const u8 up_to_ac[] = {
  58         WMM_AC_BE,
  59         WMM_AC_BK,
  60         WMM_AC_BK,
  61         WMM_AC_BE,
  62         WMM_AC_VI,
  63         WMM_AC_VI,
  64         WMM_AC_VO,
  65         WMM_AC_VO,
  66 };
  67
  68 void ath6kl_wmi_set_control_ep(struct wmi *wmi, enum htc_endpoint_id ep_id)
  69 {
  70         if (WARN_ON(ep_id == ENDPOINT_UNUSED || ep_id >= ENDPOINT_MAX))
  71                 return;
  72
  73         wmi->ep_id = ep_id;
  74 }
  75
  76 enum htc_endpoint_id ath6kl_wmi_get_control_ep(struct wmi *wmi)
  77 {
  78         return wmi->ep_id;
  79 }
  80
  81 /*  Performs DIX to 802.3 encapsulation for transmit packets.
  82  *  Assumes the entire DIX header is contigous and that there is
  83  *  enough room in the buffer for a 802.3 mac header and LLC+SNAP headers.
  84  */
  85 int ath6kl_wmi_dix_2_dot3(struct wmi *wmi, struct sk_buff *skb)
  86 {
  87         struct ath6kl_llc_snap_hdr *llc_hdr;
  88         struct ethhdr *eth_hdr;
  89         size_t new_len;
  90         __be16 type;
  91         u8 *datap;
  92         u16 size;
  93
  94         if (WARN_ON(skb == NULL))
  95                 return -EINVAL;
  96
  97         size = sizeof(struct ath6kl_llc_snap_hdr) + sizeof(struct wmi_data_hdr);
  98         if (skb_headroom(skb) < size)
  99                 return -ENOMEM;
 100
 101         eth_hdr = (struct ethhdr *) skb->data;
 102         type = eth_hdr->h_proto;
 103
 104         if (!is_ethertype(be16_to_cpu(type))) {
 105                 ath6kl_dbg(ATH6KL_DBG_WMI,
 106                         "%s: pkt is already in 802.3 format\n", __func__);
 107                 return 0;
 108         }
 109
 110         new_len = skb->len - sizeof(*eth_hdr) + sizeof(*llc_hdr);
 111
 112         skb_push(skb, sizeof(struct ath6kl_llc_snap_hdr));
 113         datap = skb->data;
 114
 115         eth_hdr->h_proto = cpu_to_be16(new_len);
 116
 117         memcpy(datap, eth_hdr, sizeof(*eth_hdr));
 118
 119         llc_hdr = (struct ath6kl_llc_snap_hdr *)(datap + sizeof(*eth_hdr));
 120         llc_hdr->dsap = 0xAA;
 121         llc_hdr->ssap = 0xAA;
 122         llc_hdr->cntl = 0x03;
 123         llc_hdr->org_code[0] = 0x0;
 124         llc_hdr->org_code[1] = 0x0;
 125         llc_hdr->org_code[2] = 0x0;
 126         llc_hdr->eth_type = type;
 127
 128         return 0;
 129 }
 130
 131 static int ath6kl_wmi_meta_add(struct wmi *wmi, struct sk_buff *skb,
 132                                u8 *version, void *tx_meta_info)
 133 {
 134         struct wmi_tx_meta_v1 *v1;
 135         struct wmi_tx_meta_v2 *v2;
 136
 137         if (WARN_ON(skb == NULL || version == NULL))
 138                 return -EINVAL;
 139
 140         switch (*version) {
 141         case WMI_META_VERSION_1:
 142                 skb_push(skb, WMI_MAX_TX_META_SZ);
 143                 v1 = (struct wmi_tx_meta_v1 *) skb->data;
 144                 v1->pkt_id = 0;
 145                 v1->rate_plcy_id = 0;
 146                 *version = WMI_META_VERSION_1;
 147                 break;
 148         case WMI_META_VERSION_2:
 149                 skb_push(skb, WMI_MAX_TX_META_SZ);
 150                 v2 = (struct wmi_tx_meta_v2 *) skb->data;
 151                 memcpy(v2, (struct wmi_tx_meta_v2 *) tx_meta_info,
 152                        sizeof(struct wmi_tx_meta_v2));
 153                 break;
 154         }
 155
 156         return 0;
 157 }
 158
 159 int ath6kl_wmi_data_hdr_add(struct wmi *wmi, struct sk_buff *skb,
 160                             u8 msg_type, bool more_data,
 161                             enum wmi_data_hdr_data_type data_type,
 162                             u8 meta_ver, void *tx_meta_info)
 163 {
 164         struct wmi_data_hdr *data_hdr;
 165         int ret;
 166
 167         if (WARN_ON(skb == NULL))
 168                 return -EINVAL;
 169
 170         if (tx_meta_info) {
 171                 ret = ath6kl_wmi_meta_add(wmi, skb, &meta_ver, tx_meta_info);
 172                 if (ret)
 173                         return ret;
 174         }
 175
 176         skb_push(skb, sizeof(struct wmi_data_hdr));
 177
 178         data_hdr = (struct wmi_data_hdr *)skb->data;
 179         memset(data_hdr, 0, sizeof(struct wmi_data_hdr));
 180
 181         data_hdr->info = msg_type << WMI_DATA_HDR_MSG_TYPE_SHIFT;
 182         data_hdr->info |= data_type << WMI_DATA_HDR_DATA_TYPE_SHIFT;
 183
 184         if (more_data)
 185                 data_hdr->info |=
 186                     WMI_DATA_HDR_MORE_MASK << WMI_DATA_HDR_MORE_SHIFT;
 187
 188         data_hdr->info2 = cpu_to_le16(meta_ver << WMI_DATA_HDR_META_SHIFT);
 189         data_hdr->info3 = 0;
 190
 191         return 0;
 192 }
 193
 194 static u8 ath6kl_wmi_determine_user_priority(u8 *pkt, u32 layer2_pri)
 195 {
 196         struct iphdr *ip_hdr = (struct iphdr *) pkt;
 197         u8 ip_pri;
 198
 199         /*
 200          * Determine IPTOS priority
 201          *
 202          * IP-TOS - 8bits
 203          *          : DSCP(6-bits) ECN(2-bits)
 204          *          : DSCP - P2 P1 P0 X X X
 205          * where (P2 P1 P0) form 802.1D
 206          */
 207         ip_pri = ip_hdr->tos >> 5;
 208         ip_pri &= 0x7;
 209
 210         if ((layer2_pri & 0x7) > ip_pri)
 211                 return (u8) layer2_pri & 0x7;
 212         else
 213                 return ip_pri;
 214 }
 215
 216 int ath6kl_wmi_implicit_create_pstream(struct wmi *wmi, struct sk_buff *skb,
 217                                        u32 layer2_priority, bool wmm_enabled,
 218                                        u8 *ac)
 219 {
 220         struct wmi_data_hdr *data_hdr;
 221         struct ath6kl_llc_snap_hdr *llc_hdr;
 222         struct wmi_create_pstream_cmd cmd;
 223         u32 meta_size, hdr_size;
 224         u16 ip_type = IP_ETHERTYPE;
 225         u8 stream_exist, usr_pri;
 226         u8 traffic_class = WMM_AC_BE;
 227         u8 *datap;
 228
 229         if (WARN_ON(skb == NULL))
 230                 return -EINVAL;
 231
 232         datap = skb->data;
 233         data_hdr = (struct wmi_data_hdr *) datap;
 234
 235         meta_size = ((le16_to_cpu(data_hdr->info2) >> WMI_DATA_HDR_META_SHIFT) &
 236                      WMI_DATA_HDR_META_MASK) ? WMI_MAX_TX_META_SZ : 0;
 237
 238         if (!wmm_enabled) {
 239                 /* If WMM is disabled all traffic goes as BE traffic */
 240                 usr_pri = 0;
 241         } else {
 242                 hdr_size = sizeof(struct ethhdr);
 243
 244                 llc_hdr = (struct ath6kl_llc_snap_hdr *)(datap +
 245                                                          sizeof(struct
 246                                                                 wmi_data_hdr) +
 247                                                          meta_size + hdr_size);
 248
 249                 if (llc_hdr->eth_type == htons(ip_type)) {
 250                         /*
 251                          * Extract the endpoint info from the TOS field
 252                          * in the IP header.
 253                          */
 254                         usr_pri =
 255                            ath6kl_wmi_determine_user_priority(((u8 *) llc_hdr) +
 256                                         sizeof(struct ath6kl_llc_snap_hdr),
 257                                         layer2_priority);
 258                 } else
 259                         usr_pri = layer2_priority & 0x7;
 260         }
 261
 262         /* workaround for WMM S5 */
 263         if ((wmi->traffic_class == WMM_AC_VI) &&
 264             ((usr_pri == 5) || (usr_pri == 4)))
 265                 usr_pri = 1;
 266
 267         /* Convert user priority to traffic class */
 268         traffic_class = up_to_ac[usr_pri & 0x7];
 269
 270         wmi_data_hdr_set_up(data_hdr, usr_pri);
 271
 272         spin_lock_bh(&wmi->lock);
 273         stream_exist = wmi->fat_pipe_exist;
 274         spin_unlock_bh(&wmi->lock);
 275
 276         if (!(stream_exist & (1 << traffic_class))) {
 277                 memset(&cmd, 0, sizeof(cmd));
 278                 cmd.traffic_class = traffic_class;
 279                 cmd.user_pri = usr_pri;
 280                 cmd.inactivity_int =
 281                         cpu_to_le32(WMI_IMPLICIT_PSTREAM_INACTIVITY_INT);
 282                 /* Implicit streams are created with TSID 0xFF */
 283                 cmd.tsid = WMI_IMPLICIT_PSTREAM;
 284                 ath6kl_wmi_create_pstream_cmd(wmi, &cmd);
 285         }
 286
 287         *ac = traffic_class;
 288
 289         return 0;
 290 }
 291
 292 int ath6kl_wmi_dot11_hdr_remove(struct wmi *wmi, struct sk_buff *skb)
 293 {
 294         struct ieee80211_hdr_3addr *pwh, wh;
 295         struct ath6kl_llc_snap_hdr *llc_hdr;
 296         struct ethhdr eth_hdr;
 297         u32 hdr_size;
 298         u8 *datap;
 299         __le16 sub_type;
 300
 301         if (WARN_ON(skb == NULL))
 302                 return -EINVAL;
 303
 304         datap = skb->data;
 305         pwh = (struct ieee80211_hdr_3addr *) datap;
 306
 307         sub_type = pwh->frame_control & cpu_to_le16(IEEE80211_FCTL_STYPE);
 308
 309         memcpy((u8 *) &wh, datap, sizeof(struct ieee80211_hdr_3addr));
 310
 311         /* Strip off the 802.11 header */
 312         if (sub_type == cpu_to_le16(IEEE80211_STYPE_QOS_DATA)) {
 313                 hdr_size = roundup(sizeof(struct ieee80211_qos_hdr),
 314                                    sizeof(u32));
 315                 skb_pull(skb, hdr_size);
 316         } else if (sub_type == cpu_to_le16(IEEE80211_STYPE_DATA))
 317                 skb_pull(skb, sizeof(struct ieee80211_hdr_3addr));
 318
 319         datap = skb->data;
 320         llc_hdr = (struct ath6kl_llc_snap_hdr *)(datap);
 321
 322         memset(&eth_hdr, 0, sizeof(eth_hdr));
 323         eth_hdr.h_proto = llc_hdr->eth_type;
 324
 325         switch ((le16_to_cpu(wh.frame_control)) &
 326                 (IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS)) {
 327         case 0:
 328                 memcpy(eth_hdr.h_dest, wh.addr1, ETH_ALEN);
 329                 memcpy(eth_hdr.h_source, wh.addr2, ETH_ALEN);
 330                 break;
 331         case IEEE80211_FCTL_TODS:
 332                 memcpy(eth_hdr.h_dest, wh.addr3, ETH_ALEN);
 333                 memcpy(eth_hdr.h_source, wh.addr2, ETH_ALEN);
 334                 break;
 335         case IEEE80211_FCTL_FROMDS:
 336                 memcpy(eth_hdr.h_dest, wh.addr1, ETH_ALEN);
 337                 memcpy(eth_hdr.h_source, wh.addr3, ETH_ALEN);
 338                 break;
 339         case IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS:
 340                 break;
 341         }
 342
 343         skb_pull(skb, sizeof(struct ath6kl_llc_snap_hdr));
 344         skb_push(skb, sizeof(eth_hdr));
 345
 346         datap = skb->data;
 347
 348         memcpy(datap, &eth_hdr, sizeof(eth_hdr));
 349
 350         return 0;
 351 }
 352
 353 /*
 354  * Performs 802.3 to DIX encapsulation for received packets.
 355  * Assumes the entire 802.3 header is contigous.
 356  */
 357 int ath6kl_wmi_dot3_2_dix(struct sk_buff *skb)
 358 {
 359         struct ath6kl_llc_snap_hdr *llc_hdr;
 360         struct ethhdr eth_hdr;
 361         u8 *datap;
 362
 363         if (WARN_ON(skb == NULL))
 364                 return -EINVAL;
 365
 366         datap = skb->data;
 367
 368         memcpy(&eth_hdr, datap, sizeof(eth_hdr));
 369
 370         llc_hdr = (struct ath6kl_llc_snap_hdr *) (datap + sizeof(eth_hdr));
 371         eth_hdr.h_proto = llc_hdr->eth_type;
 372
 373         skb_pull(skb, sizeof(struct ath6kl_llc_snap_hdr));
 374         datap = skb->data;
 375
 376         memcpy(datap, &eth_hdr, sizeof(eth_hdr));
 377
 378         return 0;
 379 }
 380
 381 static void ath6kl_wmi_convert_bssinfo_hdr2_to_hdr(struct sk_buff *skb,
 382                                                    u8 *datap)
 383 {
 384         struct wmi_bss_info_hdr2 bih2;
 385         struct wmi_bss_info_hdr *bih;
 386
 387         memcpy(&bih2, datap, sizeof(struct wmi_bss_info_hdr2));
 388
 389         skb_push(skb, 4);
 390         bih = (struct wmi_bss_info_hdr *) skb->data;
 391
 392         bih->ch = bih2.ch;
 393         bih->frame_type = bih2.frame_type;
 394         bih->snr = bih2.snr;
 395         bih->rssi = a_cpu_to_sle16(bih2.snr - 95);
 396         bih->ie_mask = cpu_to_le32(le16_to_cpu(bih2.ie_mask));
 397         memcpy(bih->bssid, bih2.bssid, ETH_ALEN);
 398 }
 399
 400 static int ath6kl_wmi_tx_complete_event_rx(u8 *datap, int len)
 401 {
 402         struct tx_complete_msg_v1 *msg_v1;
 403         struct wmi_tx_complete_event *evt;
 404         int index;
 405         u16 size;
 406
 407         evt = (struct wmi_tx_complete_event *) datap;
 408
 409         ath6kl_dbg(ATH6KL_DBG_WMI, "comp: %d %d %d\n",
 410                    evt->num_msg, evt->msg_len, evt->msg_type);
 411
 412         if (!AR_DBG_LVL_CHECK(ATH6KL_DBG_WMI))
 413                 return 0;
 414
 415         for (index = 0; index < evt->num_msg; index++) {
 416                 size = sizeof(struct wmi_tx_complete_event) +
 417                     (index * sizeof(struct tx_complete_msg_v1));
 418                 msg_v1 = (struct tx_complete_msg_v1 *)(datap + size);
 419
 420                 ath6kl_dbg(ATH6KL_DBG_WMI, "msg: %d %d %d %d\n",
 421                            msg_v1->status, msg_v1->pkt_id,
 422                            msg_v1->rate_idx, msg_v1->ack_failures);
 423         }
 424
 425         return 0;
 426 }
 427
 428 static int ath6kl_wmi_remain_on_chnl_event_rx(struct wmi *wmi, u8 *datap,
 429                                               int len)
 430 {
 431         struct wmi_remain_on_chnl_event *ev;
 432         u32 freq;
 433         u32 dur;
 434         struct ieee80211_channel *chan;
 435         struct ath6kl *ar = wmi->parent_dev;
 436
 437         if (len < sizeof(*ev))
 438                 return -EINVAL;
 439
 440         ev = (struct wmi_remain_on_chnl_event *) datap;
 441         freq = le32_to_cpu(ev->freq);
 442         dur = le32_to_cpu(ev->duration);
 443         ath6kl_dbg(ATH6KL_DBG_WMI, "remain_on_chnl: freq=%u dur=%u\n",
 444                    freq, dur);
 445         chan = ieee80211_get_channel(ar->wdev->wiphy, freq);
 446         if (!chan) {
 447                 ath6kl_dbg(ATH6KL_DBG_WMI, "remain_on_chnl: Unknown channel "
 448                            "(freq=%u)\n", freq);
 449                 return -EINVAL;
 450         }
 451         cfg80211_ready_on_channel(ar->net_dev, 1, chan, NL80211_CHAN_NO_HT,
 452                                   dur, GFP_ATOMIC);
 453
 454         return 0;
 455 }
 456
 457 static int ath6kl_wmi_cancel_remain_on_chnl_event_rx(struct wmi *wmi,
 458                                                      u8 *datap, int len)
 459 {
 460         struct wmi_cancel_remain_on_chnl_event *ev;
 461         u32 freq;
 462         u32 dur;
 463         struct ieee80211_channel *chan;
 464         struct ath6kl *ar = wmi->parent_dev;
 465
 466         if (len < sizeof(*ev))
 467                 return -EINVAL;
 468
 469         ev = (struct wmi_cancel_remain_on_chnl_event *) datap;
 470         freq = le32_to_cpu(ev->freq);
 471         dur = le32_to_cpu(ev->duration);
 472         ath6kl_dbg(ATH6KL_DBG_WMI, "cancel_remain_on_chnl: freq=%u dur=%u "
 473                    "status=%u\n", freq, dur, ev->status);
 474         chan = ieee80211_get_channel(ar->wdev->wiphy, freq);
 475         if (!chan) {
 476                 ath6kl_dbg(ATH6KL_DBG_WMI, "cancel_remain_on_chnl: Unknown "
 477                            "channel (freq=%u)\n", freq);
 478                 return -EINVAL;
 479         }
 480         cfg80211_remain_on_channel_expired(ar->net_dev, 1, chan,
 481                                            NL80211_CHAN_NO_HT, GFP_ATOMIC);
 482
 483         return 0;
 484 }
 485
 486 static int ath6kl_wmi_tx_status_event_rx(u8 *datap, int len)
 487 {
 488         struct wmi_tx_status_event *ev;
 489         u32 id;
 490
 491         if (len < sizeof(*ev))
 492                 return -EINVAL;
 493
 494         ev = (struct wmi_tx_status_event *) datap;
 495         id = le32_to_cpu(ev->id);
 496         ath6kl_dbg(ATH6KL_DBG_WMI, "tx_status: id=%x ack_status=%u\n",
 497                    id, ev->ack_status);
 498
 499         return 0;
 500 }
 501
 502 static int ath6kl_wmi_rx_probe_req_event_rx(u8 *datap, int len)
 503 {
 504         struct wmi_p2p_rx_probe_req_event *ev;
 505         u16 dlen;
 506
 507         if (len < sizeof(*ev))
 508                 return -EINVAL;
 509
 510         ev = (struct wmi_p2p_rx_probe_req_event *) datap;
 511         dlen = le16_to_cpu(ev->len);
 512         ath6kl_dbg(ATH6KL_DBG_WMI, "rx_probe_req: len=%u\n",
 513                    dlen);
 514
 515         return 0;
 516 }
 517
 518 static int ath6kl_wmi_p2p_capabilities_event_rx(u8 *datap, int len)
 519 {
 520         struct wmi_p2p_capabilities_event *ev;
 521         u16 dlen;
 522
 523         if (len < sizeof(*ev))
 524                 return -EINVAL;
 525
 526         ev = (struct wmi_p2p_capabilities_event *) datap;
 527         dlen = le16_to_cpu(ev->len);
 528         ath6kl_dbg(ATH6KL_DBG_WMI, "p2p_capab: len=%u\n", dlen);
 529
 530         return 0;
 531 }
 532
 533 static int ath6kl_wmi_rx_action_event_rx(u8 *datap, int len)
 534 {
 535         struct wmi_rx_action_event *ev;
 536         u16 dlen;
 537
 538         if (len < sizeof(*ev))
 539                 return -EINVAL;
 540
 541         ev = (struct wmi_rx_action_event *) datap;
 542         dlen = le16_to_cpu(ev->len);
 543         ath6kl_dbg(ATH6KL_DBG_WMI, "rx_action: len=%u\n", dlen);
 544
 545         return 0;
 546 }
 547
 548 static int ath6kl_wmi_p2p_info_event_rx(u8 *datap, int len)
 549 {
 550         struct wmi_p2p_info_event *ev;
 551         u32 flags;
 552         u16 dlen;
 553
 554         if (len < sizeof(*ev))
 555                 return -EINVAL;
 556
 557         ev = (struct wmi_p2p_info_event *) datap;
 558         flags = le32_to_cpu(ev->info_req_flags);
 559         dlen = le16_to_cpu(ev->len);
 560         ath6kl_dbg(ATH6KL_DBG_WMI, "p2p_info: flags=%x len=%d\n", flags, dlen);
 561
 562         if (flags & P2P_FLAG_CAPABILITIES_REQ) {
 563                 struct wmi_p2p_capabilities *cap;
 564                 if (dlen < sizeof(*cap))
 565                         return -EINVAL;
 566                 cap = (struct wmi_p2p_capabilities *) ev->data;
 567                 ath6kl_dbg(ATH6KL_DBG_WMI, "p2p_info: GO Power Save = %d\n",
 568                            cap->go_power_save);
 569         }
 570
 571         if (flags & P2P_FLAG_MACADDR_REQ) {
 572                 struct wmi_p2p_macaddr *mac;
 573                 if (dlen < sizeof(*mac))
 574                         return -EINVAL;
 575                 mac = (struct wmi_p2p_macaddr *) ev->data;
 576                 ath6kl_dbg(ATH6KL_DBG_WMI, "p2p_info: MAC Address = %pM\n",
 577                            mac->mac_addr);
 578         }
 579
 580         if (flags & P2P_FLAG_HMODEL_REQ) {
 581                 struct wmi_p2p_hmodel *mod;
 582                 if (dlen < sizeof(*mod))
 583                         return -EINVAL;
 584                 mod = (struct wmi_p2p_hmodel *) ev->data;
 585                 ath6kl_dbg(ATH6KL_DBG_WMI, "p2p_info: P2P Model = %d (%s)\n",
 586                            mod->p2p_model,
 587                            mod->p2p_model ? "host" : "firmware");
 588         }
 589         return 0;
 590 }
 591
 592 static inline struct sk_buff *ath6kl_wmi_get_new_buf(u32 size)
 593 {
 594         struct sk_buff *skb;
 595
 596         skb = ath6kl_buf_alloc(size);
 597         if (!skb)
 598                 return NULL;
 599
 600         skb_put(skb, size);
 601         if (size)
 602                 memset(skb->data, 0, size);
 603
 604         return skb;
 605 }
 606
 607 /* Send a "simple" wmi command -- one with no arguments */
 608 static int ath6kl_wmi_simple_cmd(struct wmi *wmi, enum wmi_cmd_id cmd_id)
 609 {
 610         struct sk_buff *skb;
 611         int ret;
 612
 613         skb = ath6kl_wmi_get_new_buf(0);
 614         if (!skb)
 615                 return -ENOMEM;
 616
 617         ret = ath6kl_wmi_cmd_send(wmi, skb, cmd_id, NO_SYNC_WMIFLAG);
 618
 619         return ret;
 620 }
 621
 622 static int ath6kl_wmi_ready_event_rx(struct wmi *wmi, u8 *datap, int len)
 623 {
 624         struct wmi_ready_event_2 *ev = (struct wmi_ready_event_2 *) datap;
 625
 626         if (len < sizeof(struct wmi_ready_event_2))
 627                 return -EINVAL;
 628
 629         wmi->ready = true;
 630         ath6kl_ready_event(wmi->parent_dev, ev->mac_addr,
 631                            le32_to_cpu(ev->sw_version),
 632                            le32_to_cpu(ev->abi_version));
 633
 634         return 0;
 635 }
 636
 637 static int ath6kl_wmi_connect_event_rx(struct wmi *wmi, u8 *datap, int len)
 638 {
 639         struct wmi_connect_event *ev;
 640         u8 *pie, *peie;
 641
 642         if (len < sizeof(struct wmi_connect_event))
 643                 return -EINVAL;
 644
 645         ev = (struct wmi_connect_event *) datap;
 646
 647         ath6kl_dbg(ATH6KL_DBG_WMI, "%s: freq %d bssid %pM\n",
 648                    __func__, ev->ch, ev->bssid);
 649
 650         /* Start of assoc rsp IEs */
 651         pie = ev->assoc_info + ev->beacon_ie_len +
 652               ev->assoc_req_len + (sizeof(u16) * 3); /* capinfo, status, aid */
 653
 654         /* End of assoc rsp IEs */
 655         peie = ev->assoc_info + ev->beacon_ie_len + ev->assoc_req_len +
 656             ev->assoc_resp_len;
 657
 658         while (pie < peie) {
 659                 switch (*pie) {
 660                 case WLAN_EID_VENDOR_SPECIFIC:
 661                         if (pie[1] > 3 && pie[2] == 0x00 && pie[3] == 0x50 &&
 662                             pie[4] == 0xf2 && pie[5] == WMM_OUI_TYPE) {
 663                                 /* WMM OUT (00:50:F2) */
 664                                 if (pie[1] > 5
 665                                     && pie[6] == WMM_PARAM_OUI_SUBTYPE)
 666                                         wmi->is_wmm_enabled = true;
 667                         }
 668                         break;
 669                 }
 670
 671                 if (wmi->is_wmm_enabled)
 672                         break;
 673
 674                 pie += pie[1] + 2;
 675         }
 676
 677         ath6kl_connect_event(wmi->parent_dev, le16_to_cpu(ev->ch), ev->bssid,
 678                              le16_to_cpu(ev->listen_intvl),
 679                              le16_to_cpu(ev->beacon_intvl),
 680                              le32_to_cpu(ev->nw_type),
 681                              ev->beacon_ie_len, ev->assoc_req_len,
 682                              ev->assoc_resp_len, ev->assoc_info);
 683
 684         return 0;
 685 }
 686
 687 static int ath6kl_wmi_disconnect_event_rx(struct wmi *wmi, u8 *datap, int len)
 688 {
 689         struct wmi_disconnect_event *ev;
 690         wmi->traffic_class = 100;
 691
 692         if (len < sizeof(struct wmi_disconnect_event))
 693                 return -EINVAL;
 694
 695         ev = (struct wmi_disconnect_event *) datap;
 696
 697         wmi->is_wmm_enabled = false;
 698         wmi->pair_crypto_type = NONE_CRYPT;
 699         wmi->grp_crypto_type = NONE_CRYPT;
 700
 701         ath6kl_disconnect_event(wmi->parent_dev, ev->disconn_reason,
 702                                 ev->bssid, ev->assoc_resp_len, ev->assoc_info,
 703                                 le16_to_cpu(ev->proto_reason_status));
 704
 705         return 0;
 706 }
 707
 708 static int ath6kl_wmi_peer_node_event_rx(struct wmi *wmi, u8 *datap, int len)
 709 {
 710         struct wmi_peer_node_event *ev;
 711
 712         if (len < sizeof(struct wmi_peer_node_event))
 713                 return -EINVAL;
 714
 715         ev = (struct wmi_peer_node_event *) datap;
 716
 717         if (ev->event_code == PEER_NODE_JOIN_EVENT)
 718                 ath6kl_dbg(ATH6KL_DBG_WMI, "joined node with mac addr: %pM\n",
 719                            ev->peer_mac_addr);
 720         else if (ev->event_code == PEER_NODE_LEAVE_EVENT)
 721                 ath6kl_dbg(ATH6KL_DBG_WMI, "left node with mac addr: %pM\n",
 722                            ev->peer_mac_addr);
 723
 724         return 0;
 725 }
 726
 727 static int ath6kl_wmi_tkip_micerr_event_rx(struct wmi *wmi, u8 *datap, int len)
 728 {
 729         struct wmi_tkip_micerr_event *ev;
 730
 731         if (len < sizeof(struct wmi_tkip_micerr_event))
 732                 return -EINVAL;
 733
 734         ev = (struct wmi_tkip_micerr_event *) datap;
 735
 736         ath6kl_tkip_micerr_event(wmi->parent_dev, ev->key_id, ev->is_mcast);
 737
 738         return 0;
 739 }
 740
 741 static int ath6kl_wlan_parse_beacon(u8 *buf, int frame_len,
 742                                     struct ath6kl_common_ie *cie)
 743 {
 744         u8 *frm, *efrm;
 745         u8 elemid_ssid = false;
 746
 747         frm = buf;
 748         efrm = (u8 *) (frm + frame_len);
 749
 750         /*
 751          * beacon/probe response frame format
 752          *  [8] time stamp
 753          *  [2] beacon interval
 754          *  [2] capability information
 755          *  [tlv] ssid
 756          *  [tlv] supported rates
 757          *  [tlv] country information
 758          *  [tlv] parameter set (FH/DS)
 759          *  [tlv] erp information
 760          *  [tlv] extended supported rates
 761          *  [tlv] WMM
 762          *  [tlv] WPA or RSN
 763          *  [tlv] Atheros Advanced Capabilities
 764          */
 765         if ((efrm - frm) < 12)
 766                 return -EINVAL;
 767
 768         memset(cie, 0, sizeof(*cie));
 769
 770         cie->ie_tstamp = frm;
 771         frm += 8;
 772         cie->ie_beaconInt = *(u16 *) frm;
 773         frm += 2;
 774         cie->ie_capInfo = *(u16 *) frm;
 775         frm += 2;
 776         cie->ie_chan = 0;
 777
 778         while (frm < efrm) {
 779                 switch (*frm) {
 780                 case WLAN_EID_SSID:
 781                         if (!elemid_ssid) {
 782                                 cie->ie_ssid = frm;
 783                                 elemid_ssid = true;
 784                         }
 785                         break;
 786                 case WLAN_EID_SUPP_RATES:
 787                         cie->ie_rates = frm;
 788                         break;
 789                 case WLAN_EID_COUNTRY:
 790                         cie->ie_country = frm;
 791                         break;
 792                 case WLAN_EID_FH_PARAMS:
 793                         break;
 794                 case WLAN_EID_DS_PARAMS:
 795                         cie->ie_chan = frm[2];
 796                         break;
 797                 case WLAN_EID_TIM:
 798                         cie->ie_tim = frm;
 799                         break;
 800                 case WLAN_EID_IBSS_PARAMS:
 801                         break;
 802                 case WLAN_EID_EXT_SUPP_RATES:
 803                         cie->ie_xrates = frm;
 804                         break;
 805                 case WLAN_EID_ERP_INFO:
 806                         if (frm[1] != 1)
 807                                 return -EINVAL;
 808
 809                         cie->ie_erp = frm[2];
 810                         break;
 811                 case WLAN_EID_RSN:
 812                         cie->ie_rsn = frm;
 813                         break;
 814                 case WLAN_EID_HT_CAPABILITY:
 815                         cie->ie_htcap = frm;
 816                         break;
 817                 case WLAN_EID_HT_INFORMATION:
 818                         cie->ie_htop = frm;
 819                         break;
 820                 case WLAN_EID_VENDOR_SPECIFIC:
 821                         if (frm[1] > 3 && frm[2] == 0x00 && frm[3] == 0x50 &&
 822                             frm[4] == 0xf2) {
 823                                 /* OUT Type (00:50:F2) */
 824
 825                                 if (frm[5] == WPA_OUI_TYPE) {
 826                                         /* WPA OUT */
 827                                         cie->ie_wpa = frm;
 828                                 } else if (frm[5] == WMM_OUI_TYPE) {
 829                                         /* WMM OUT */
 830                                         cie->ie_wmm = frm;
 831                                 } else if (frm[5] == WSC_OUT_TYPE) {
 832                                         /* WSC OUT */
 833                                         cie->ie_wsc = frm;
 834                                 }
 835
 836                         } else if (frm[1] > 3 && frm[2] == 0x00
 837                                    && frm[3] == 0x03 && frm[4] == 0x7f
 838                                    && frm[5] == ATH_OUI_TYPE) {
 839                                 /* Atheros OUI (00:03:7f) */
 840                                 cie->ie_ath = frm;
 841                         }
 842                         break;
 843                 default:
 844                         break;
 845                 }
 846                 frm += frm[1] + 2;
 847         }
 848
 849         if ((cie->ie_rates == NULL)
 850             || (cie->ie_rates[1] > ATH6KL_RATE_MAXSIZE))
 851                 return -EINVAL;
 852
 853         if ((cie->ie_ssid == NULL)
 854             || (cie->ie_ssid[1] > IEEE80211_MAX_SSID_LEN))
 855                 return -EINVAL;
 856
 857         return 0;
 858 }
 859
 860 static int ath6kl_wmi_bssinfo_event_rx(struct wmi *wmi, u8 *datap, int len)
 861 {
 862         struct bss *bss = NULL;
 863         struct wmi_bss_info_hdr *bih;
 864         u8 cached_ssid_len = 0;
 865         u8 cached_ssid[IEEE80211_MAX_SSID_LEN] = { 0 };
 866         u8 beacon_ssid_len = 0;
 867         u8 *buf, *ie_ssid;
 868         u8 *ni_buf;
 869         int buf_len;
 870
 871         int ret;
 872
 873         if (len <= sizeof(struct wmi_bss_info_hdr))
 874                 return -EINVAL;
 875
 876         bih = (struct wmi_bss_info_hdr *) datap;
 877         bss = wlan_find_node(&wmi->parent_dev->scan_table, bih->bssid);
 878
 879         if (a_sle16_to_cpu(bih->rssi) > 0) {
 880                 if (bss == NULL)
 881                         return 0;
 882                 else
 883                         bih->rssi = a_cpu_to_sle16(bss->ni_rssi);
 884         }
 885
 886         buf = datap + sizeof(struct wmi_bss_info_hdr);
 887         len -= sizeof(struct wmi_bss_info_hdr);
 888
 889         ath6kl_dbg(ATH6KL_DBG_WMI,
 890                    "bss info evt - ch %u, rssi %02x, bssid \"%pM\"\n",
 891                    bih->ch, a_sle16_to_cpu(bih->rssi), bih->bssid);
 892
 893         if (bss != NULL) {
 894                 /*
 895                  * Free up the node. We are about to allocate a new node.
 896                  * In case of hidden AP, beacon will not have ssid,
 897                  * but a directed probe response will have it,
 898                  * so cache the probe-resp-ssid if already present.
 899                  */
 900                 if (wmi->is_probe_ssid && (bih->frame_type == BEACON_FTYPE)) {
 901                         ie_ssid = bss->ni_cie.ie_ssid;
 902                         if (ie_ssid && (ie_ssid[1] <= IEEE80211_MAX_SSID_LEN) &&
 903                             (ie_ssid[2] != 0)) {
 904                                 cached_ssid_len = ie_ssid[1];
 905                                 memcpy(cached_ssid, ie_ssid + 2,
 906                                        cached_ssid_len);
 907                         }
 908                 }
 909
 910                 /*
 911                  * Use the current average rssi of associated AP base on
 912                  * assumption
 913                  *   1. Most os with GUI will update RSSI by
 914                  *      ath6kl_wmi_get_stats_cmd() periodically.
 915                  *   2. ath6kl_wmi_get_stats_cmd(..) will be called when calling
 916                  *      ath6kl_wmi_startscan_cmd(...)
 917                  * The average value of RSSI give end-user better feeling for
 918                  * instance value of scan result. It also sync up RSSI info
 919                  * in GUI between scan result and RSSI signal icon.
 920                  */
 921                 if (memcmp(wmi->parent_dev->bssid, bih->bssid, ETH_ALEN) == 0) {
 922                         bih->rssi = a_cpu_to_sle16(bss->ni_rssi);
 923                         bih->snr = bss->ni_snr;
 924                 }
 925
 926                 wlan_node_reclaim(&wmi->parent_dev->scan_table, bss);
 927         }
 928
 929         /*
 930          * beacon/probe response frame format
 931          *  [8] time stamp
 932          *  [2] beacon interval
 933          *  [2] capability information
 934          *  [tlv] ssid
 935          */
 936         beacon_ssid_len = buf[SSID_IE_LEN_INDEX];
 937
 938         /*
 939          * If ssid is cached for this hidden AP, then change
 940          * buffer len accordingly.
 941          */
 942         if (wmi->is_probe_ssid && (bih->frame_type == BEACON_FTYPE) &&
 943             (cached_ssid_len != 0) &&
 944             (beacon_ssid_len == 0 || (cached_ssid_len > beacon_ssid_len &&
 945                                       buf[SSID_IE_LEN_INDEX + 1] == 0))) {
 946
 947                 len += (cached_ssid_len - beacon_ssid_len);
 948         }
 949
 950         bss = wlan_node_alloc(len);
 951         if (!bss)
 952                 return -ENOMEM;
 953
 954         bss->ni_snr = bih->snr;
 955         bss->ni_rssi = a_sle16_to_cpu(bih->rssi);
 956
 957         if (WARN_ON(!bss->ni_buf))
 958                 return -EINVAL;
 959
 960         /*
 961          * In case of hidden AP, beacon will not have ssid,
 962          * but a directed probe response will have it,
 963          * so place the cached-ssid(probe-resp) in the bss info.
 964          */
 965         if (wmi->is_probe_ssid && (bih->frame_type == BEACON_FTYPE) &&
 966             (cached_ssid_len != 0) &&
 967             (beacon_ssid_len == 0 || (beacon_ssid_len &&
 968                                       buf[SSID_IE_LEN_INDEX + 1] == 0))) {
 969                 ni_buf = bss->ni_buf;
 970                 buf_len = len;
 971
 972                 /*
 973                  * Copy the first 14 bytes:
 974                  * time-stamp(8), beacon-interval(2),
 975                  * cap-info(2), ssid-id(1), ssid-len(1).
 976                  */
 977                 memcpy(ni_buf, buf, SSID_IE_LEN_INDEX + 1);
 978
 979                 ni_buf[SSID_IE_LEN_INDEX] = cached_ssid_len;
 980                 ni_buf += (SSID_IE_LEN_INDEX + 1);
 981
 982                 buf += (SSID_IE_LEN_INDEX + 1);
 983                 buf_len -= (SSID_IE_LEN_INDEX + 1);
 984
 985                 memcpy(ni_buf, cached_ssid, cached_ssid_len);
 986                 ni_buf += cached_ssid_len;
 987
 988                 buf += beacon_ssid_len;
 989                 buf_len -= beacon_ssid_len;
 990
 991                 if (cached_ssid_len > beacon_ssid_len)
 992                         buf_len -= (cached_ssid_len - beacon_ssid_len);
 993
 994                 memcpy(ni_buf, buf, buf_len);
 995         } else
 996                 memcpy(bss->ni_buf, buf, len);
 997
 998         bss->ni_framelen = len;
 999
1000         ret = ath6kl_wlan_parse_beacon(bss->ni_buf, len, &bss->ni_cie);
1001         if (ret) {
1002                 wlan_node_free(bss);
1003                 return -EINVAL;
1004         }
1005
1006         /*
1007          * Update the frequency in ie_chan, overwriting of channel number
1008          * which is done in ath6kl_wlan_parse_beacon
1009          */
1010         bss->ni_cie.ie_chan = le16_to_cpu(bih->ch);
1011         wlan_setup_node(&wmi->parent_dev->scan_table, bss, bih->bssid);
1012
1013         return 0;
1014 }
1015
1016 static int ath6kl_wmi_opt_frame_event_rx(struct wmi *wmi, u8 *datap, int len)
1017 {
1018         struct bss *bss;
1019         struct wmi_opt_rx_info_hdr *bih;
1020         u8 *buf;
1021
1022         if (len <= sizeof(struct wmi_opt_rx_info_hdr))
1023                 return -EINVAL;
1024
1025         bih = (struct wmi_opt_rx_info_hdr *) datap;
1026         buf = datap + sizeof(struct wmi_opt_rx_info_hdr);
1027         len -= sizeof(struct wmi_opt_rx_info_hdr);
1028
1029         ath6kl_dbg(ATH6KL_DBG_WMI, "opt frame event %2.2x:%2.2x\n",
1030                    bih->bssid[4], bih->bssid[5]);
1031
1032         bss = wlan_find_node(&wmi->parent_dev->scan_table, bih->bssid);
1033         if (bss != NULL) {
1034                 /* Free up the node. We are about to allocate a new node. */
1035                 wlan_node_reclaim(&wmi->parent_dev->scan_table, bss);
1036         }
1037
1038         bss = wlan_node_alloc(len);
1039         if (!bss)
1040                 return -ENOMEM;
1041
1042         bss->ni_snr = bih->snr;
1043         bss->ni_cie.ie_chan = le16_to_cpu(bih->ch);
1044
1045         if (WARN_ON(!bss->ni_buf))
1046                 return -EINVAL;
1047
1048         memcpy(bss->ni_buf, buf, len);
1049         wlan_setup_node(&wmi->parent_dev->scan_table, bss, bih->bssid);
1050
1051         return 0;
1052 }
1053
1054 /* Inactivity timeout of a fatpipe(pstream) at the target */
1055 static int ath6kl_wmi_pstream_timeout_event_rx(struct wmi *wmi, u8 *datap,
1056                                                int len)
1057 {
1058         struct wmi_pstream_timeout_event *ev;
1059
1060         if (len < sizeof(struct wmi_pstream_timeout_event))
1061                 return -EINVAL;
1062
1063         ev = (struct wmi_pstream_timeout_event *) datap;
1064
1065         /*
1066          * When the pstream (fat pipe == AC) timesout, it means there were
1067          * no thinStreams within this pstream & it got implicitly created
1068          * due to data flow on this AC. We start the inactivity timer only
1069          * for implicitly created pstream. Just reset the host state.
1070          */
1071         spin_lock_bh(&wmi->lock);
1072         wmi->stream_exist_for_ac[ev->traffic_class] = 0;
1073         wmi->fat_pipe_exist &= ~(1 << ev->traffic_class);
1074         spin_unlock_bh(&wmi->lock);
1075
1076         /* Indicate inactivity to driver layer for this fatpipe (pstream) */
1077         ath6kl_indicate_tx_activity(wmi->parent_dev, ev->traffic_class, false);
1078
1079         return 0;
1080 }
1081
1082 static int ath6kl_wmi_bitrate_reply_rx(struct wmi *wmi, u8 *datap, int len)
1083 {
1084         struct wmi_bit_rate_reply *reply;
1085         s32 rate;
1086         u32 sgi, index;
1087
1088         if (len < sizeof(struct wmi_bit_rate_reply))
1089                 return -EINVAL;
1090
1091         reply = (struct wmi_bit_rate_reply *) datap;
1092
1093         ath6kl_dbg(ATH6KL_DBG_WMI, "rateindex %d\n", reply->rate_index);
1094
1095         if (reply->rate_index == (s8) RATE_AUTO) {
1096                 rate = RATE_AUTO;
1097         } else {
1098                 index = reply->rate_index & 0x7f;
1099                 sgi = (reply->rate_index & 0x80) ? 1 : 0;
1100                 rate = wmi_rate_tbl[index][sgi];
1101         }
1102
1103         ath6kl_wakeup_event(wmi->parent_dev);
1104
1105         return 0;
1106 }
1107
1108 static int ath6kl_wmi_ratemask_reply_rx(struct wmi *wmi, u8 *datap, int len)
1109 {
1110         if (len < sizeof(struct wmi_fix_rates_reply))
1111                 return -EINVAL;
1112
1113         ath6kl_wakeup_event(wmi->parent_dev);
1114
1115         return 0;
1116 }
1117
1118 static int ath6kl_wmi_ch_list_reply_rx(struct wmi *wmi, u8 *datap, int len)
1119 {
1120         if (len < sizeof(struct wmi_channel_list_reply))
1121                 return -EINVAL;
1122
1123         ath6kl_wakeup_event(wmi->parent_dev);
1124
1125         return 0;
1126 }
1127
1128 static int ath6kl_wmi_tx_pwr_reply_rx(struct wmi *wmi, u8 *datap, int len)
1129 {
1130         struct wmi_tx_pwr_reply *reply;
1131
1132         if (len < sizeof(struct wmi_tx_pwr_reply))
1133                 return -EINVAL;
1134
1135         reply = (struct wmi_tx_pwr_reply *) datap;
1136         ath6kl_txpwr_rx_evt(wmi->parent_dev, reply->dbM);
1137
1138         return 0;
1139 }
1140
1141 static int ath6kl_wmi_keepalive_reply_rx(struct wmi *wmi, u8 *datap, int len)
1142 {
1143         if (len < sizeof(struct wmi_get_keepalive_cmd))
1144                 return -EINVAL;
1145
1146         ath6kl_wakeup_event(wmi->parent_dev);
1147
1148         return 0;
1149 }
1150
1151 static int ath6kl_wmi_scan_complete_rx(struct wmi *wmi, u8 *datap, int len)
1152 {
1153         struct wmi_scan_complete_event *ev;
1154
1155         ev = (struct wmi_scan_complete_event *) datap;
1156
1157         if (a_sle32_to_cpu(ev->status) == 0)
1158                 wlan_refresh_inactive_nodes(wmi->parent_dev);
1159
1160         ath6kl_scan_complete_evt(wmi->parent_dev, a_sle32_to_cpu(ev->status));
1161         wmi->is_probe_ssid = false;
1162
1163         return 0;
1164 }
1165
1166 /*
1167  * Target is reporting a programming error.  This is for
1168  * developer aid only.  Target only checks a few common violations
1169  * and it is responsibility of host to do all error checking.
1170  * Behavior of target after wmi error event is undefined.
1171  * A reset is recommended.
1172  */
1173 static int ath6kl_wmi_error_event_rx(struct wmi *wmi, u8 *datap, int len)
1174 {
1175         const char *type = "unknown error";
1176         struct wmi_cmd_error_event *ev;
1177         ev = (struct wmi_cmd_error_event *) datap;
1178
1179         switch (ev->err_code) {
1180         case INVALID_PARAM:
1181                 type = "invalid parameter";
1182                 break;
1183         case ILLEGAL_STATE:
1184                 type = "invalid state";
1185                 break;
1186         case INTERNAL_ERROR:
1187                 type = "internal error";
1188                 break;
1189         }
1190
1191         ath6kl_dbg(ATH6KL_DBG_WMI, "programming error, cmd=%d %s\n",
1192                    ev->cmd_id, type);
1193
1194         return 0;
1195 }
1196
1197 static int ath6kl_wmi_stats_event_rx(struct wmi *wmi, u8 *datap, int len)
1198 {
1199         ath6kl_tgt_stats_event(wmi->parent_dev, datap, len);
1200
1201         return 0;
1202 }
1203
1204 static u8 ath6kl_wmi_get_upper_threshold(s16 rssi,
1205                                          struct sq_threshold_params *sq_thresh,
1206                                          u32 size)
1207 {
1208         u32 index;
1209         u8 threshold = (u8) sq_thresh->upper_threshold[size - 1];
1210
1211         /* The list is already in sorted order. Get the next lower value */
1212         for (index = 0; index < size; index++) {
1213                 if (rssi < sq_thresh->upper_threshold[index]) {
1214                         threshold = (u8) sq_thresh->upper_threshold[index];
1215                         break;
1216                 }
1217         }
1218
1219         return threshold;
1220 }
1221
1222 static u8 ath6kl_wmi_get_lower_threshold(s16 rssi,
1223                                          struct sq_threshold_params *sq_thresh,
1224                                          u32 size)
1225 {
1226         u32 index;
1227         u8 threshold = (u8) sq_thresh->lower_threshold[size - 1];
1228
1229         /* The list is already in sorted order. Get the next lower value */
1230         for (index = 0; index < size; index++) {
1231                 if (rssi > sq_thresh->lower_threshold[index]) {
1232                         threshold = (u8) sq_thresh->lower_threshold[index];
1233                         break;
1234                 }
1235         }
1236
1237         return threshold;
1238 }
1239
1240 static int ath6kl_wmi_send_rssi_threshold_params(struct wmi *wmi,
1241                         struct wmi_rssi_threshold_params_cmd *rssi_cmd)
1242 {
1243         struct sk_buff *skb;
1244         struct wmi_rssi_threshold_params_cmd *cmd;
1245
1246         skb = ath6kl_wmi_get_new_buf(sizeof(*cmd));
1247         if (!skb)
1248                 return -ENOMEM;
1249
1250         cmd = (struct wmi_rssi_threshold_params_cmd *) skb->data;
1251         memcpy(cmd, rssi_cmd, sizeof(struct wmi_rssi_threshold_params_cmd));
1252
1253         return ath6kl_wmi_cmd_send(wmi, skb, WMI_RSSI_THRESHOLD_PARAMS_CMDID,
1254                                    NO_SYNC_WMIFLAG);
1255 }
1256
1257 static int ath6kl_wmi_rssi_threshold_event_rx(struct wmi *wmi, u8 *datap,
1258                                               int len)
1259 {
1260         struct wmi_rssi_threshold_event *reply;
1261         struct wmi_rssi_threshold_params_cmd cmd;
1262         struct sq_threshold_params *sq_thresh;
1263         enum wmi_rssi_threshold_val new_threshold;
1264         u8 upper_rssi_threshold, lower_rssi_threshold;
1265         s16 rssi;
1266         int ret;
1267
1268         if (len < sizeof(struct wmi_rssi_threshold_event))
1269                 return -EINVAL;
1270
1271         reply = (struct wmi_rssi_threshold_event *) datap;
1272         new_threshold = (enum wmi_rssi_threshold_val) reply->range;
1273         rssi = a_sle16_to_cpu(reply->rssi);
1274
1275         sq_thresh = &wmi->sq_threshld[SIGNAL_QUALITY_METRICS_RSSI];
1276
1277         /*
1278          * Identify the threshold breached and communicate that to the app.
1279          * After that install a new set of thresholds based on the signal
1280          * quality reported by the target
1281          */
1282         if (new_threshold) {
1283                 /* Upper threshold breached */
1284                 if (rssi < sq_thresh->upper_threshold[0]) {
1285                         ath6kl_dbg(ATH6KL_DBG_WMI,
1286                                 "spurious upper rssi threshold event: %d\n",
1287                                 rssi);
1288                 } else if ((rssi < sq_thresh->upper_threshold[1]) &&
1289                            (rssi >= sq_thresh->upper_threshold[0])) {
1290                         new_threshold = WMI_RSSI_THRESHOLD1_ABOVE;
1291                 } else if ((rssi < sq_thresh->upper_threshold[2]) &&
1292                            (rssi >= sq_thresh->upper_threshold[1])) {
1293                         new_threshold = WMI_RSSI_THRESHOLD2_ABOVE;
1294                 } else if ((rssi < sq_thresh->upper_threshold[3]) &&
1295                            (rssi >= sq_thresh->upper_threshold[2])) {
1296                         new_threshold = WMI_RSSI_THRESHOLD3_ABOVE;
1297                 } else if ((rssi < sq_thresh->upper_threshold[4]) &&
1298                            (rssi >= sq_thresh->upper_threshold[3])) {
1299                         new_threshold = WMI_RSSI_THRESHOLD4_ABOVE;
1300                 } else if ((rssi < sq_thresh->upper_threshold[5]) &&
1301                            (rssi >= sq_thresh->upper_threshold[4])) {
1302                         new_threshold = WMI_RSSI_THRESHOLD5_ABOVE;
1303                 } else if (rssi >= sq_thresh->upper_threshold[5]) {
1304                         new_threshold = WMI_RSSI_THRESHOLD6_ABOVE;
1305                 }
1306         } else {
1307                 /* Lower threshold breached */
1308                 if (rssi > sq_thresh->lower_threshold[0]) {
1309                         ath6kl_dbg(ATH6KL_DBG_WMI,
1310                                 "spurious lower rssi threshold event: %d %d\n",
1311                                 rssi, sq_thresh->lower_threshold[0]);
1312                 } else if ((rssi > sq_thresh->lower_threshold[1]) &&
1313                            (rssi <= sq_thresh->lower_threshold[0])) {
1314                         new_threshold = WMI_RSSI_THRESHOLD6_BELOW;
1315                 } else if ((rssi > sq_thresh->lower_threshold[2]) &&
1316                            (rssi <= sq_thresh->lower_threshold[1])) {
1317                         new_threshold = WMI_RSSI_THRESHOLD5_BELOW;
1318                 } else if ((rssi > sq_thresh->lower_threshold[3]) &&
1319                            (rssi <= sq_thresh->lower_threshold[2])) {
1320                         new_threshold = WMI_RSSI_THRESHOLD4_BELOW;
1321                 } else if ((rssi > sq_thresh->lower_threshold[4]) &&
1322                            (rssi <= sq_thresh->lower_threshold[3])) {
1323                         new_threshold = WMI_RSSI_THRESHOLD3_BELOW;
1324                 } else if ((rssi > sq_thresh->lower_threshold[5]) &&
1325                            (rssi <= sq_thresh->lower_threshold[4])) {
1326                         new_threshold = WMI_RSSI_THRESHOLD2_BELOW;
1327                 } else if (rssi <= sq_thresh->lower_threshold[5]) {
1328                         new_threshold = WMI_RSSI_THRESHOLD1_BELOW;
1329                 }
1330         }
1331
1332         /* Calculate and install the next set of thresholds */
1333         lower_rssi_threshold = ath6kl_wmi_get_lower_threshold(rssi, sq_thresh,
1334                                        sq_thresh->lower_threshold_valid_count);
1335         upper_rssi_threshold = ath6kl_wmi_get_upper_threshold(rssi, sq_thresh,
1336                                        sq_thresh->upper_threshold_valid_count);
1337
1338         /* Issue a wmi command to install the thresholds */
1339         cmd.thresh_above1_val = a_cpu_to_sle16(upper_rssi_threshold);
1340         cmd.thresh_below1_val = a_cpu_to_sle16(lower_rssi_threshold);
1341         cmd.weight = sq_thresh->weight;
1342         cmd.poll_time = cpu_to_le32(sq_thresh->polling_interval);
1343
1344         ret = ath6kl_wmi_send_rssi_threshold_params(wmi, &cmd);
1345         if (ret) {
1346                 ath6kl_err("unable to configure rssi thresholds\n");
1347                 return -EIO;
1348         }
1349
1350         return 0;
1351 }
1352
1353 static int ath6kl_wmi_cac_event_rx(struct wmi *wmi, u8 *datap, int len)
1354 {
1355         struct wmi_cac_event *reply;
1356         struct ieee80211_tspec_ie *ts;
1357         u16 active_tsids, tsinfo;
1358         u8 tsid, index;
1359         u8 ts_id;
1360
1361         if (len < sizeof(struct wmi_cac_event))
1362                 return -EINVAL;
1363
1364         reply = (struct wmi_cac_event *) datap;
1365
1366         if ((reply->cac_indication == CAC_INDICATION_ADMISSION_RESP) &&
1367             (reply->status_code != IEEE80211_TSPEC_STATUS_ADMISS_ACCEPTED)) {
1368
1369                 ts = (struct ieee80211_tspec_ie *) &(reply->tspec_suggestion);
1370                 tsinfo = le16_to_cpu(ts->tsinfo);
1371                 tsid = (tsinfo >> IEEE80211_WMM_IE_TSPEC_TID_SHIFT) &
1372                         IEEE80211_WMM_IE_TSPEC_TID_MASK;
1373
1374                 ath6kl_wmi_delete_pstream_cmd(wmi, reply->ac, tsid);
1375         } else if (reply->cac_indication == CAC_INDICATION_NO_RESP) {
1376                 /*
1377                  * Following assumes that there is only one outstanding
1378                  * ADDTS request when this event is received
1379                  */
1380                 spin_lock_bh(&wmi->lock);
1381                 active_tsids = wmi->stream_exist_for_ac[reply->ac];
1382                 spin_unlock_bh(&wmi->lock);
1383
1384                 for (index = 0; index < sizeof(active_tsids) * 8; index++) {
1385                         if ((active_tsids >> index) & 1)
1386                                 break;
1387                 }
1388                 if (index < (sizeof(active_tsids) * 8))
1389                         ath6kl_wmi_delete_pstream_cmd(wmi, reply->ac, index);
1390         }
1391
1392         /*
1393          * Clear active tsids and Add missing handling
1394          * for delete qos stream from AP
1395          */
1396         else if (reply->cac_indication == CAC_INDICATION_DELETE) {
1397
1398                 ts = (struct ieee80211_tspec_ie *) &(reply->tspec_suggestion);
1399                 tsinfo = le16_to_cpu(ts->tsinfo);
1400                 ts_id = ((tsinfo >> IEEE80211_WMM_IE_TSPEC_TID_SHIFT) &
1401                          IEEE80211_WMM_IE_TSPEC_TID_MASK);
1402
1403                 spin_lock_bh(&wmi->lock);
1404                 wmi->stream_exist_for_ac[reply->ac] &= ~(1 << ts_id);
1405                 active_tsids = wmi->stream_exist_for_ac[reply->ac];
1406                 spin_unlock_bh(&wmi->lock);
1407
1408                 /* Indicate stream inactivity to driver layer only if all tsids
1409                  * within this AC are deleted.
1410                  */
1411                 if (!active_tsids) {
1412                         ath6kl_indicate_tx_activity(wmi->parent_dev, reply->ac,
1413                                                     false);
1414                         wmi->fat_pipe_exist &= ~(1 << reply->ac);
1415                 }
1416         }
1417
1418         return 0;
1419 }
1420
1421 static int ath6kl_wmi_send_snr_threshold_params(struct wmi *wmi,
1422                         struct wmi_snr_threshold_params_cmd *snr_cmd)
1423 {
1424         struct sk_buff *skb;
1425         struct wmi_snr_threshold_params_cmd *cmd;
1426
1427         skb = ath6kl_wmi_get_new_buf(sizeof(*cmd));
1428         if (!skb)
1429                 return -ENOMEM;
1430
1431         cmd = (struct wmi_snr_threshold_params_cmd *) skb->data;
1432         memcpy(cmd, snr_cmd, sizeof(struct wmi_snr_threshold_params_cmd));
1433
1434         return ath6kl_wmi_cmd_send(wmi, skb, WMI_SNR_THRESHOLD_PARAMS_CMDID,
1435                                    NO_SYNC_WMIFLAG);
1436 }
1437
1438 static int ath6kl_wmi_snr_threshold_event_rx(struct wmi *wmi, u8 *datap,
1439                                              int len)
1440 {
1441         struct wmi_snr_threshold_event *reply;
1442         struct sq_threshold_params *sq_thresh;
1443         struct wmi_snr_threshold_params_cmd cmd;
1444         enum wmi_snr_threshold_val new_threshold;
1445         u8 upper_snr_threshold, lower_snr_threshold;
1446         s16 snr;
1447         int ret;
1448
1449         if (len < sizeof(struct wmi_snr_threshold_event))
1450                 return -EINVAL;
1451
1452         reply = (struct wmi_snr_threshold_event *) datap;
1453
1454         new_threshold = (enum wmi_snr_threshold_val) reply->range;
1455         snr = reply->snr;
1456
1457         sq_thresh = &wmi->sq_threshld[SIGNAL_QUALITY_METRICS_SNR];
1458
1459         /*
1460          * Identify the threshold breached and communicate that to the app.
1461          * After that install a new set of thresholds based on the signal
1462          * quality reported by the target.
1463          */
1464         if (new_threshold) {
1465                 /* Upper threshold breached */
1466                 if (snr < sq_thresh->upper_threshold[0]) {
1467                         ath6kl_dbg(ATH6KL_DBG_WMI,
1468                                 "spurious upper snr threshold event: %d\n",
1469                                 snr);
1470                 } else if ((snr < sq_thresh->upper_threshold[1]) &&
1471                            (snr >= sq_thresh->upper_threshold[0])) {
1472                         new_threshold = WMI_SNR_THRESHOLD1_ABOVE;
1473                 } else if ((snr < sq_thresh->upper_threshold[2]) &&
1474                            (snr >= sq_thresh->upper_threshold[1])) {
1475                         new_threshold = WMI_SNR_THRESHOLD2_ABOVE;
1476                 } else if ((snr < sq_thresh->upper_threshold[3]) &&
1477                            (snr >= sq_thresh->upper_threshold[2])) {
1478                         new_threshold = WMI_SNR_THRESHOLD3_ABOVE;
1479                 } else if (snr >= sq_thresh->upper_threshold[3]) {
1480                         new_threshold = WMI_SNR_THRESHOLD4_ABOVE;
1481                 }
1482         } else {
1483                 /* Lower threshold breached */
1484                 if (snr > sq_thresh->lower_threshold[0]) {
1485                         ath6kl_dbg(ATH6KL_DBG_WMI,
1486                                 "spurious lower snr threshold event: %d\n",
1487                                 sq_thresh->lower_threshold[0]);
1488                 } else if ((snr > sq_thresh->lower_threshold[1]) &&
1489                            (snr <= sq_thresh->lower_threshold[0])) {
1490                         new_threshold = WMI_SNR_THRESHOLD4_BELOW;
1491                 } else if ((snr > sq_thresh->lower_threshold[2]) &&
1492                            (snr <= sq_thresh->lower_threshold[1])) {
1493                         new_threshold = WMI_SNR_THRESHOLD3_BELOW;
1494                 } else if ((snr > sq_thresh->lower_threshold[3]) &&
1495                            (snr <= sq_thresh->lower_threshold[2])) {
1496                         new_threshold = WMI_SNR_THRESHOLD2_BELOW;
1497                 } else if (snr <= sq_thresh->lower_threshold[3]) {
1498                         new_threshold = WMI_SNR_THRESHOLD1_BELOW;
1499                 }
1500         }
1501
1502         /* Calculate and install the next set of thresholds */
1503         lower_snr_threshold = ath6kl_wmi_get_lower_threshold(snr, sq_thresh,
1504                                        sq_thresh->lower_threshold_valid_count);
1505         upper_snr_threshold = ath6kl_wmi_get_upper_threshold(snr, sq_thresh,
1506                                        sq_thresh->upper_threshold_valid_count);
1507
1508         /* Issue a wmi command to install the thresholds */
1509         cmd.thresh_above1_val = upper_snr_threshold;
1510         cmd.thresh_below1_val = lower_snr_threshold;
1511         cmd.weight = sq_thresh->weight;
1512         cmd.poll_time = cpu_to_le32(sq_thresh->polling_interval);
1513
1514         ath6kl_dbg(ATH6KL_DBG_WMI,
1515                    "snr: %d, threshold: %d, lower: %d, upper: %d\n",
1516                    snr, new_threshold,
1517                    lower_snr_threshold, upper_snr_threshold);
1518
1519         ret = ath6kl_wmi_send_snr_threshold_params(wmi, &cmd);
1520         if (ret) {
1521                 ath6kl_err("unable to configure snr threshold\n");
1522                 return -EIO;
1523         }
1524
1525         return 0;
1526 }
1527
1528 static int ath6kl_wmi_aplist_event_rx(struct wmi *wmi, u8 *datap, int len)
1529 {
1530         u16 ap_info_entry_size;
1531         struct wmi_aplist_event *ev = (struct wmi_aplist_event *) datap;
1532         struct wmi_ap_info_v1 *ap_info_v1;
1533         u8 index;
1534
1535         if (len < sizeof(struct wmi_aplist_event) ||
1536             ev->ap_list_ver != APLIST_VER1)
1537                 return -EINVAL;
1538
1539         ap_info_entry_size = sizeof(struct wmi_ap_info_v1);
1540         ap_info_v1 = (struct wmi_ap_info_v1 *) ev->ap_list;
1541
1542         ath6kl_dbg(ATH6KL_DBG_WMI,
1543                    "number of APs in aplist event: %d\n", ev->num_ap);
1544
1545         if (len < (int) (sizeof(struct wmi_aplist_event) +
1546                          (ev->num_ap - 1) * ap_info_entry_size))
1547                 return -EINVAL;
1548
1549         /* AP list version 1 contents */
1550         for (index = 0; index < ev->num_ap; index++) {
1551                 ath6kl_dbg(ATH6KL_DBG_WMI, "AP#%d BSSID %pM Channel %d\n",
1552                            index, ap_info_v1->bssid, ap_info_v1->channel);
1553                 ap_info_v1++;
1554         }
1555
1556         return 0;
1557 }
1558
1559 int ath6kl_wmi_cmd_send(struct wmi *wmi, struct sk_buff *skb,
1560                         enum wmi_cmd_id cmd_id, enum wmi_sync_flag sync_flag)
1561 {
1562         struct wmi_cmd_hdr *cmd_hdr;
1563         enum htc_endpoint_id ep_id = wmi->ep_id;
1564         int ret;
1565
1566         ath6kl_dbg(ATH6KL_DBG_WMI, "%s: cmd_id=%d\n", __func__, cmd_id);
1567
1568         if (WARN_ON(skb == NULL))
1569                 return -EINVAL;
1570
1571         if (sync_flag >= END_WMIFLAG) {
1572                 dev_kfree_skb(skb);
1573                 return -EINVAL;
1574         }
1575
1576         if ((sync_flag == SYNC_BEFORE_WMIFLAG) ||
1577             (sync_flag == SYNC_BOTH_WMIFLAG)) {
1578                 /*
1579                  * Make sure all data currently queued is transmitted before
1580                  * the cmd execution.  Establish a new sync point.
1581                  */
1582                 ath6kl_wmi_sync_point(wmi);
1583         }
1584
1585         skb_push(skb, sizeof(struct wmi_cmd_hdr));
1586
1587         cmd_hdr = (struct wmi_cmd_hdr *) skb->data;
1588         cmd_hdr->cmd_id = cpu_to_le16(cmd_id);
1589         cmd_hdr->info1 = 0;     /* added for virtual interface */
1590
1591         /* Only for OPT_TX_CMD, use BE endpoint. */
1592         if (cmd_id == WMI_OPT_TX_FRAME_CMDID) {
1593                 ret = ath6kl_wmi_data_hdr_add(wmi, skb, OPT_MSGTYPE,
1594                                               false, false, 0, NULL);
1595                 if (ret) {
1596                         dev_kfree_skb(skb);
1597                         return ret;
1598                 }
1599                 ep_id = ath6kl_ac2_endpoint_id(wmi->parent_dev, WMM_AC_BE);
1600         }
1601
1602         ath6kl_control_tx(wmi->parent_dev, skb, ep_id);
1603
1604         if ((sync_flag == SYNC_AFTER_WMIFLAG) ||
1605             (sync_flag == SYNC_BOTH_WMIFLAG)) {
1606                 /*
1607                  * Make sure all new data queued waits for the command to
1608                  * execute. Establish a new sync point.
1609                  */
1610                 ath6kl_wmi_sync_point(wmi);
1611         }
1612
1613         return 0;
1614 }
1615
1616 int ath6kl_wmi_connect_cmd(struct wmi *wmi, enum network_type nw_type,
1617                            enum dot11_auth_mode dot11_auth_mode,
1618                            enum auth_mode auth_mode,
1619                            enum crypto_type pairwise_crypto,
1620                            u8 pairwise_crypto_len,
1621                            enum crypto_type group_crypto,
1622                            u8 group_crypto_len, int ssid_len, u8 *ssid,
1623                            u8 *bssid, u16 channel, u32 ctrl_flags)
1624 {
1625         struct sk_buff *skb;
1626         struct wmi_connect_cmd *cc;
1627         int ret;
1628
1629         wmi->traffic_class = 100;
1630
1631         if ((pairwise_crypto == NONE_CRYPT) && (group_crypto != NONE_CRYPT))
1632                 return -EINVAL;
1633
1634         if ((pairwise_crypto != NONE_CRYPT) && (group_crypto == NONE_CRYPT))
1635                 return -EINVAL;
1636
1637         skb = ath6kl_wmi_get_new_buf(sizeof(struct wmi_connect_cmd));
1638         if (!skb)
1639                 return -ENOMEM;
1640
1641         cc = (struct wmi_connect_cmd *) skb->data;
1642
1643         if (ssid_len)
1644                 memcpy(cc->ssid, ssid, ssid_len);
1645
1646         cc->ssid_len = ssid_len;
1647         cc->nw_type = nw_type;
1648         cc->dot11_auth_mode = dot11_auth_mode;
1649         cc->auth_mode = auth_mode;
1650         cc->prwise_crypto_type = pairwise_crypto;
1651         cc->prwise_crypto_len = pairwise_crypto_len;
1652         cc->grp_crypto_type = group_crypto;
1653         cc->grp_crypto_len = group_crypto_len;
1654         cc->ch = cpu_to_le16(channel);
1655         cc->ctrl_flags = cpu_to_le32(ctrl_flags);
1656
1657         if (bssid != NULL)
1658                 memcpy(cc->bssid, bssid, ETH_ALEN);
1659
1660         wmi->pair_crypto_type = pairwise_crypto;
1661         wmi->grp_crypto_type = group_crypto;
1662
1663         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_CONNECT_CMDID, NO_SYNC_WMIFLAG);
1664
1665         return ret;
1666 }
1667
1668 int ath6kl_wmi_reconnect_cmd(struct wmi *wmi, u8 *bssid, u16 channel)
1669 {
1670         struct sk_buff *skb;
1671         struct wmi_reconnect_cmd *cc;
1672         int ret;
1673
1674         wmi->traffic_class = 100;
1675
1676         skb = ath6kl_wmi_get_new_buf(sizeof(struct wmi_reconnect_cmd));
1677         if (!skb)
1678                 return -ENOMEM;
1679
1680         cc = (struct wmi_reconnect_cmd *) skb->data;
1681         cc->channel = cpu_to_le16(channel);
1682
1683         if (bssid != NULL)
1684                 memcpy(cc->bssid, bssid, ETH_ALEN);
1685
1686         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_RECONNECT_CMDID,
1687                                   NO_SYNC_WMIFLAG);
1688
1689         return ret;
1690 }
1691
1692 int ath6kl_wmi_disconnect_cmd(struct wmi *wmi)
1693 {
1694         int ret;
1695
1696         wmi->traffic_class = 100;
1697
1698         /* Disconnect command does not need to do a SYNC before. */
1699         ret = ath6kl_wmi_simple_cmd(wmi, WMI_DISCONNECT_CMDID);
1700
1701         return ret;
1702 }
1703
1704 int ath6kl_wmi_startscan_cmd(struct wmi *wmi, enum wmi_scan_type scan_type,
1705                              u32 force_fgscan, u32 is_legacy,
1706                              u32 home_dwell_time, u32 force_scan_interval,
1707                              s8 num_chan, u16 *ch_list)
1708 {
1709         struct sk_buff *skb;
1710         struct wmi_start_scan_cmd *sc;
1711         s8 size;
1712         int ret;
1713
1714         size = sizeof(struct wmi_start_scan_cmd);
1715
1716         if ((scan_type != WMI_LONG_SCAN) && (scan_type != WMI_SHORT_SCAN))
1717                 return -EINVAL;
1718
1719         if (num_chan > WMI_MAX_CHANNELS)
1720                 return -EINVAL;
1721
1722         if (num_chan)
1723                 size += sizeof(u16) * (num_chan - 1);
1724
1725         skb = ath6kl_wmi_get_new_buf(size);
1726         if (!skb)
1727                 return -ENOMEM;
1728
1729         sc = (struct wmi_start_scan_cmd *) skb->data;
1730         sc->scan_type = scan_type;
1731         sc->force_fg_scan = cpu_to_le32(force_fgscan);
1732         sc->is_legacy = cpu_to_le32(is_legacy);
1733         sc->home_dwell_time = cpu_to_le32(home_dwell_time);
1734         sc->force_scan_intvl = cpu_to_le32(force_scan_interval);
1735         sc->num_ch = num_chan;
1736
1737         if (num_chan)
1738                 memcpy(sc->ch_list, ch_list, num_chan * sizeof(u16));
1739
1740         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_START_SCAN_CMDID,
1741                                   NO_SYNC_WMIFLAG);
1742
1743         return ret;
1744 }
1745
1746 int ath6kl_wmi_scanparams_cmd(struct wmi *wmi, u16 fg_start_sec,
1747                               u16 fg_end_sec, u16 bg_sec,
1748                               u16 minact_chdw_msec, u16 maxact_chdw_msec,
1749                               u16 pas_chdw_msec, u8 short_scan_ratio,
1750                               u8 scan_ctrl_flag, u32 max_dfsch_act_time,
1751                               u16 maxact_scan_per_ssid)
1752 {
1753         struct sk_buff *skb;
1754         struct wmi_scan_params_cmd *sc;
1755         int ret;
1756
1757         skb = ath6kl_wmi_get_new_buf(sizeof(*sc));
1758         if (!skb)
1759                 return -ENOMEM;
1760
1761         sc = (struct wmi_scan_params_cmd *) skb->data;
1762         sc->fg_start_period = cpu_to_le16(fg_start_sec);
1763         sc->fg_end_period = cpu_to_le16(fg_end_sec);
1764         sc->bg_period = cpu_to_le16(bg_sec);
1765         sc->minact_chdwell_time = cpu_to_le16(minact_chdw_msec);
1766         sc->maxact_chdwell_time = cpu_to_le16(maxact_chdw_msec);
1767         sc->pas_chdwell_time = cpu_to_le16(pas_chdw_msec);
1768         sc->short_scan_ratio = short_scan_ratio;
1769         sc->scan_ctrl_flags = scan_ctrl_flag;
1770         sc->max_dfsch_act_time = cpu_to_le32(max_dfsch_act_time);
1771         sc->maxact_scan_per_ssid = cpu_to_le16(maxact_scan_per_ssid);
1772
1773         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_SET_SCAN_PARAMS_CMDID,
1774                                   NO_SYNC_WMIFLAG);
1775         return ret;
1776 }
1777
1778 int ath6kl_wmi_bssfilter_cmd(struct wmi *wmi, u8 filter, u32 ie_mask)
1779 {
1780         struct sk_buff *skb;
1781         struct wmi_bss_filter_cmd *cmd;
1782         int ret;
1783
1784         if (filter >= LAST_BSS_FILTER)
1785                 return -EINVAL;
1786
1787         skb = ath6kl_wmi_get_new_buf(sizeof(*cmd));
1788         if (!skb)
1789                 return -ENOMEM;
1790
1791         cmd = (struct wmi_bss_filter_cmd *) skb->data;
1792         cmd->bss_filter = filter;
1793         cmd->ie_mask = cpu_to_le32(ie_mask);
1794
1795         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_SET_BSS_FILTER_CMDID,
1796                                   NO_SYNC_WMIFLAG);
1797         return ret;
1798 }
1799
1800 int ath6kl_wmi_probedssid_cmd(struct wmi *wmi, u8 index, u8 flag,
1801                               u8 ssid_len, u8 *ssid)
1802 {
1803         struct sk_buff *skb;
1804         struct wmi_probed_ssid_cmd *cmd;
1805         int ret;
1806
1807         if (index > MAX_PROBED_SSID_INDEX)
1808                 return -EINVAL;
1809
1810         if (ssid_len > sizeof(cmd->ssid))
1811                 return -EINVAL;
1812
1813         if ((flag & (DISABLE_SSID_FLAG | ANY_SSID_FLAG)) && (ssid_len > 0))
1814                 return -EINVAL;
1815
1816         if ((flag & SPECIFIC_SSID_FLAG) && !ssid_len)
1817                 return -EINVAL;
1818
1819         if (flag & SPECIFIC_SSID_FLAG)
1820                 wmi->is_probe_ssid = true;
1821
1822         skb = ath6kl_wmi_get_new_buf(sizeof(*cmd));
1823         if (!skb)
1824                 return -ENOMEM;
1825
1826         cmd = (struct wmi_probed_ssid_cmd *) skb->data;
1827         cmd->entry_index = index;
1828         cmd->flag = flag;
1829         cmd->ssid_len = ssid_len;
1830         memcpy(cmd->ssid, ssid, ssid_len);
1831
1832         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_SET_PROBED_SSID_CMDID,
1833                                   NO_SYNC_WMIFLAG);
1834         return ret;
1835 }
1836
1837 int ath6kl_wmi_listeninterval_cmd(struct wmi *wmi, u16 listen_interval,
1838                                   u16 listen_beacons)
1839 {
1840         struct sk_buff *skb;
1841         struct wmi_listen_int_cmd *cmd;
1842         int ret;
1843
1844         skb = ath6kl_wmi_get_new_buf(sizeof(*cmd));
1845         if (!skb)
1846                 return -ENOMEM;
1847
1848         cmd = (struct wmi_listen_int_cmd *) skb->data;
1849         cmd->listen_intvl = cpu_to_le16(listen_interval);
1850         cmd->num_beacons = cpu_to_le16(listen_beacons);
1851
1852         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_SET_LISTEN_INT_CMDID,
1853                                   NO_SYNC_WMIFLAG);
1854         return ret;
1855 }
1856
1857 int ath6kl_wmi_powermode_cmd(struct wmi *wmi, u8 pwr_mode)
1858 {
1859         struct sk_buff *skb;
1860         struct wmi_power_mode_cmd *cmd;
1861         int ret;
1862
1863         skb = ath6kl_wmi_get_new_buf(sizeof(*cmd));
1864         if (!skb)
1865                 return -ENOMEM;
1866
1867         cmd = (struct wmi_power_mode_cmd *) skb->data;
1868         cmd->pwr_mode = pwr_mode;
1869         wmi->pwr_mode = pwr_mode;
1870
1871         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_SET_POWER_MODE_CMDID,
1872                                   NO_SYNC_WMIFLAG);
1873         return ret;
1874 }
1875
1876 int ath6kl_wmi_pmparams_cmd(struct wmi *wmi, u16 idle_period,
1877                             u16 ps_poll_num, u16 dtim_policy,
1878                             u16 tx_wakeup_policy, u16 num_tx_to_wakeup,
1879                             u16 ps_fail_event_policy)
1880 {
1881         struct sk_buff *skb;
1882         struct wmi_power_params_cmd *pm;
1883         int ret;
1884
1885         skb = ath6kl_wmi_get_new_buf(sizeof(*pm));
1886         if (!skb)
1887                 return -ENOMEM;
1888
1889         pm = (struct wmi_power_params_cmd *)skb->data;
1890         pm->idle_period = cpu_to_le16(idle_period);
1891         pm->pspoll_number = cpu_to_le16(ps_poll_num);
1892         pm->dtim_policy = cpu_to_le16(dtim_policy);
1893         pm->tx_wakeup_policy = cpu_to_le16(tx_wakeup_policy);
1894         pm->num_tx_to_wakeup = cpu_to_le16(num_tx_to_wakeup);
1895         pm->ps_fail_event_policy = cpu_to_le16(ps_fail_event_policy);
1896
1897         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_SET_POWER_PARAMS_CMDID,
1898                                   NO_SYNC_WMIFLAG);
1899         return ret;
1900 }
1901
1902 int ath6kl_wmi_disctimeout_cmd(struct wmi *wmi, u8 timeout)
1903 {
1904         struct sk_buff *skb;
1905         struct wmi_disc_timeout_cmd *cmd;
1906         int ret;
1907
1908         skb = ath6kl_wmi_get_new_buf(sizeof(*cmd));
1909         if (!skb)
1910                 return -ENOMEM;
1911
1912         cmd = (struct wmi_disc_timeout_cmd *) skb->data;
1913         cmd->discon_timeout = timeout;
1914
1915         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_SET_DISC_TIMEOUT_CMDID,
1916                                   NO_SYNC_WMIFLAG);
1917         return ret;
1918 }
1919
1920 int ath6kl_wmi_addkey_cmd(struct wmi *wmi, u8 key_index,
1921                           enum crypto_type key_type,
1922                           u8 key_usage, u8 key_len,
1923                           u8 *key_rsc, u8 *key_material,
1924                           u8 key_op_ctrl, u8 *mac_addr,
1925                           enum wmi_sync_flag sync_flag)
1926 {
1927         struct sk_buff *skb;
1928         struct wmi_add_cipher_key_cmd *cmd;
1929         int ret;
1930
1931         ath6kl_dbg(ATH6KL_DBG_WMI, "addkey cmd: key_index=%u key_type=%d "
1932                    "key_usage=%d key_len=%d key_op_ctrl=%d\n",
1933                    key_index, key_type, key_usage, key_len, key_op_ctrl);
1934
1935         if ((key_index > WMI_MAX_KEY_INDEX) || (key_len > WMI_MAX_KEY_LEN) ||
1936             (key_material == NULL))
1937                 return -EINVAL;
1938
1939         if ((WEP_CRYPT != key_type) && (NULL == key_rsc))
1940                 return -EINVAL;
1941
1942         skb = ath6kl_wmi_get_new_buf(sizeof(*cmd));
1943         if (!skb)
1944                 return -ENOMEM;
1945
1946         cmd = (struct wmi_add_cipher_key_cmd *) skb->data;
1947         cmd->key_index = key_index;
1948         cmd->key_type = key_type;
1949         cmd->key_usage = key_usage;
1950         cmd->key_len = key_len;
1951         memcpy(cmd->key, key_material, key_len);
1952
1953         if (key_rsc != NULL)
1954                 memcpy(cmd->key_rsc, key_rsc, sizeof(cmd->key_rsc));
1955
1956         cmd->key_op_ctrl = key_op_ctrl;
1957
1958         if (mac_addr)
1959                 memcpy(cmd->key_mac_addr, mac_addr, ETH_ALEN);
1960
1961         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_ADD_CIPHER_KEY_CMDID,
1962                                   sync_flag);
1963
1964         return ret;
1965 }
1966
1967 int ath6kl_wmi_add_krk_cmd(struct wmi *wmi, u8 *krk)
1968 {
1969         struct sk_buff *skb;
1970         struct wmi_add_krk_cmd *cmd;
1971         int ret;
1972
1973         skb = ath6kl_wmi_get_new_buf(sizeof(*cmd));
1974         if (!skb)
1975                 return -ENOMEM;
1976
1977         cmd = (struct wmi_add_krk_cmd *) skb->data;
1978         memcpy(cmd->krk, krk, WMI_KRK_LEN);
1979
1980         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_ADD_KRK_CMDID, NO_SYNC_WMIFLAG);
1981
1982         return ret;
1983 }
1984
1985 int ath6kl_wmi_deletekey_cmd(struct wmi *wmi, u8 key_index)
1986 {
1987         struct sk_buff *skb;
1988         struct wmi_delete_cipher_key_cmd *cmd;
1989         int ret;
1990
1991         if (key_index > WMI_MAX_KEY_INDEX)
1992                 return -EINVAL;
1993
1994         skb = ath6kl_wmi_get_new_buf(sizeof(*cmd));
1995         if (!skb)
1996                 return -ENOMEM;
1997
1998         cmd = (struct wmi_delete_cipher_key_cmd *) skb->data;
1999         cmd->key_index = key_index;
2000
2001         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_DELETE_CIPHER_KEY_CMDID,
2002                                   NO_SYNC_WMIFLAG);
2003
2004         return ret;
2005 }
2006
2007 int ath6kl_wmi_setpmkid_cmd(struct wmi *wmi, const u8 *bssid,
2008                             const u8 *pmkid, bool set)
2009 {
2010         struct sk_buff *skb;
2011         struct wmi_setpmkid_cmd *cmd;
2012         int ret;
2013
2014         if (bssid == NULL)
2015                 return -EINVAL;
2016
2017         if (set && pmkid == NULL)
2018                 return -EINVAL;
2019
2020         skb = ath6kl_wmi_get_new_buf(sizeof(*cmd));
2021         if (!skb)
2022                 return -ENOMEM;
2023
2024         cmd = (struct wmi_setpmkid_cmd *) skb->data;
2025         memcpy(cmd->bssid, bssid, ETH_ALEN);
2026         if (set) {
2027                 memcpy(cmd->pmkid, pmkid, sizeof(cmd->pmkid));
2028                 cmd->enable = PMKID_ENABLE;
2029         } else {
2030                 memset(cmd->pmkid, 0, sizeof(cmd->pmkid));
2031                 cmd->enable = PMKID_DISABLE;
2032         }
2033
2034         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_SET_PMKID_CMDID,
2035                                   NO_SYNC_WMIFLAG);
2036
2037         return ret;
2038 }
2039
2040 static int ath6kl_wmi_data_sync_send(struct wmi *wmi, struct sk_buff *skb,
2041                               enum htc_endpoint_id ep_id)
2042 {
2043         struct wmi_data_hdr *data_hdr;
2044         int ret;
2045
2046         if (WARN_ON(skb == NULL || ep_id == wmi->ep_id))
2047                 return -EINVAL;
2048
2049         skb_push(skb, sizeof(struct wmi_data_hdr));
2050
2051         data_hdr = (struct wmi_data_hdr *) skb->data;
2052         data_hdr->info = SYNC_MSGTYPE << WMI_DATA_HDR_MSG_TYPE_SHIFT;
2053         data_hdr->info3 = 0;
2054
2055         ret = ath6kl_control_tx(wmi->parent_dev, skb, ep_id);
2056
2057         return ret;
2058 }
2059
2060 static int ath6kl_wmi_sync_point(struct wmi *wmi)
2061 {
2062         struct sk_buff *skb;
2063         struct wmi_sync_cmd *cmd;
2064         struct wmi_data_sync_bufs data_sync_bufs[WMM_NUM_AC];
2065         enum htc_endpoint_id ep_id;
2066         u8 index, num_pri_streams = 0;
2067         int ret = 0;
2068
2069         memset(data_sync_bufs, 0, sizeof(data_sync_bufs));
2070
2071         spin_lock_bh(&wmi->lock);
2072
2073         for (index = 0; index < WMM_NUM_AC; index++) {
2074                 if (wmi->fat_pipe_exist & (1 << index)) {
2075                         num_pri_streams++;
2076                         data_sync_bufs[num_pri_streams - 1].traffic_class =
2077                             index;
2078                 }
2079         }
2080
2081         spin_unlock_bh(&wmi->lock);
2082
2083         skb = ath6kl_wmi_get_new_buf(sizeof(*cmd));
2084         if (!skb) {
2085                 ret = -ENOMEM;
2086                 goto free_skb;
2087         }
2088
2089         cmd = (struct wmi_sync_cmd *) skb->data;
2090
2091         /*
2092          * In the SYNC cmd sent on the control Ep, send a bitmap
2093          * of the data eps on which the Data Sync will be sent
2094          */
2095         cmd->data_sync_map = wmi->fat_pipe_exist;
2096
2097         for (index = 0; index < num_pri_streams; index++) {
2098                 data_sync_bufs[index].skb = ath6kl_buf_alloc(0);
2099                 if (data_sync_bufs[index].skb == NULL) {
2100                         ret = -ENOMEM;
2101                         break;
2102                 }
2103         }
2104
2105         /*
2106          * If buffer allocation for any of the dataSync fails,
2107          * then do not send the Synchronize cmd on the control ep
2108          */
2109         if (ret)
2110                 goto free_skb;
2111
2112         /*
2113          * Send sync cmd followed by sync data messages on all
2114          * endpoints being used
2115          */
2116         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_SYNCHRONIZE_CMDID,
2117                                   NO_SYNC_WMIFLAG);
2118
2119         if (ret)
2120                 goto free_skb;
2121
2122         /* cmd buffer sent, we no longer own it */
2123         skb = NULL;
2124
2125         for (index = 0; index < num_pri_streams; index++) {
2126
2127                 if (WARN_ON(!data_sync_bufs[index].skb))
2128                         break;
2129
2130                 ep_id = ath6kl_ac2_endpoint_id(wmi->parent_dev,
2131                                                data_sync_bufs[index].
2132                                                traffic_class);
2133                 ret =
2134                     ath6kl_wmi_data_sync_send(wmi, data_sync_bufs[index].skb,
2135                                               ep_id);
2136
2137                 if (ret)
2138                         break;
2139
2140                 data_sync_bufs[index].skb = NULL;
2141         }
2142
2143 free_skb:
2144         /* free up any resources left over (possibly due to an error) */
2145         if (skb)
2146                 dev_kfree_skb(skb);
2147
2148         for (index = 0; index < num_pri_streams; index++) {
2149                 if (data_sync_bufs[index].skb != NULL) {
2150                         dev_kfree_skb((struct sk_buff *)data_sync_bufs[index].
2151                                       skb);
2152                 }
2153         }
2154
2155         return ret;
2156 }
2157
2158 int ath6kl_wmi_create_pstream_cmd(struct wmi *wmi,
2159                                   struct wmi_create_pstream_cmd *params)
2160 {
2161         struct sk_buff *skb;
2162         struct wmi_create_pstream_cmd *cmd;
2163         u8 fatpipe_exist_for_ac = 0;
2164         s32 min_phy = 0;
2165         s32 nominal_phy = 0;
2166         int ret;
2167
2168         if (!((params->user_pri < 8) &&
2169               (params->user_pri <= 0x7) &&
2170               (up_to_ac[params->user_pri & 0x7] == params->traffic_class) &&
2171               (params->traffic_direc == UPLINK_TRAFFIC ||
2172                params->traffic_direc == DNLINK_TRAFFIC ||
2173                params->traffic_direc == BIDIR_TRAFFIC) &&
2174               (params->traffic_type == TRAFFIC_TYPE_APERIODIC ||
2175                params->traffic_type == TRAFFIC_TYPE_PERIODIC) &&
2176               (params->voice_psc_cap == DISABLE_FOR_THIS_AC ||
2177                params->voice_psc_cap == ENABLE_FOR_THIS_AC ||
2178                params->voice_psc_cap == ENABLE_FOR_ALL_AC) &&
2179               (params->tsid == WMI_IMPLICIT_PSTREAM ||
2180                params->tsid <= WMI_MAX_THINSTREAM))) {
2181                 return -EINVAL;
2182         }
2183
2184         /*
2185          * Check nominal PHY rate is >= minimalPHY,
2186          * so that DUT can allow TSRS IE
2187          */
2188
2189         /* Get the physical rate (units of bps) */
2190         min_phy = ((le32_to_cpu(params->min_phy_rate) / 1000) / 1000);
2191
2192         /* Check minimal phy < nominal phy rate */
2193         if (params->nominal_phy >= min_phy) {
2194                 /* unit of 500 kbps */
2195                 nominal_phy = (params->nominal_phy * 1000) / 500;
2196                 ath6kl_dbg(ATH6KL_DBG_WMI,
2197                            "TSRS IE enabled::MinPhy %x->NominalPhy ===> %x\n",
2198                            min_phy, nominal_phy);
2199
2200                 params->nominal_phy = nominal_phy;
2201         } else {
2202                 params->nominal_phy = 0;
2203         }
2204
2205         skb = ath6kl_wmi_get_new_buf(sizeof(*cmd));
2206         if (!skb)
2207                 return -ENOMEM;
2208
2209         ath6kl_dbg(ATH6KL_DBG_WMI,
2210                    "sending create_pstream_cmd: ac=%d  tsid:%d\n",
2211                    params->traffic_class, params->tsid);
2212
2213         cmd = (struct wmi_create_pstream_cmd *) skb->data;
2214         memcpy(cmd, params, sizeof(*cmd));
2215
2216         /* This is an implicitly created Fat pipe */
2217         if ((u32) params->tsid == (u32) WMI_IMPLICIT_PSTREAM) {
2218                 spin_lock_bh(&wmi->lock);
2219                 fatpipe_exist_for_ac = (wmi->fat_pipe_exist &
2220                                         (1 << params->traffic_class));
2221                 wmi->fat_pipe_exist |= (1 << params->traffic_class);
2222                 spin_unlock_bh(&wmi->lock);
2223         } else {
2224                 /* explicitly created thin stream within a fat pipe */
2225                 spin_lock_bh(&wmi->lock);
2226                 fatpipe_exist_for_ac = (wmi->fat_pipe_exist &
2227                                         (1 << params->traffic_class));
2228                 wmi->stream_exist_for_ac[params->traffic_class] |=
2229                     (1 << params->tsid);
2230                 /*
2231                  * If a thinstream becomes active, the fat pipe automatically
2232                  * becomes active
2233                  */
2234                 wmi->fat_pipe_exist |= (1 << params->traffic_class);
2235                 spin_unlock_bh(&wmi->lock);
2236         }
2237
2238         /*
2239          * Indicate activty change to driver layer only if this is the
2240          * first TSID to get created in this AC explicitly or an implicit
2241          * fat pipe is getting created.
2242          */
2243         if (!fatpipe_exist_for_ac)
2244                 ath6kl_indicate_tx_activity(wmi->parent_dev,
2245                                             params->traffic_class, true);
2246
2247         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_CREATE_PSTREAM_CMDID,
2248                                   NO_SYNC_WMIFLAG);
2249         return ret;
2250 }
2251
2252 int ath6kl_wmi_delete_pstream_cmd(struct wmi *wmi, u8 traffic_class, u8 tsid)
2253 {
2254         struct sk_buff *skb;
2255         struct wmi_delete_pstream_cmd *cmd;
2256         u16 active_tsids = 0;
2257         int ret;
2258
2259         if (traffic_class > 3) {
2260                 ath6kl_err("invalid traffic class: %d\n", traffic_class);
2261                 return -EINVAL;
2262         }
2263
2264         skb = ath6kl_wmi_get_new_buf(sizeof(*cmd));
2265         if (!skb)
2266                 return -ENOMEM;
2267
2268         cmd = (struct wmi_delete_pstream_cmd *) skb->data;
2269         cmd->traffic_class = traffic_class;
2270         cmd->tsid = tsid;
2271
2272         spin_lock_bh(&wmi->lock);
2273         active_tsids = wmi->stream_exist_for_ac[traffic_class];
2274         spin_unlock_bh(&wmi->lock);
2275
2276         if (!(active_tsids & (1 << tsid))) {
2277                 dev_kfree_skb(skb);
2278                 ath6kl_dbg(ATH6KL_DBG_WMI,
2279                            "TSID %d doesn't exist for traffic class: %d\n",
2280                            tsid, traffic_class);
2281                 return -ENODATA;
2282         }
2283
2284         ath6kl_dbg(ATH6KL_DBG_WMI,
2285                    "sending delete_pstream_cmd: traffic class: %d tsid=%d\n",
2286                    traffic_class, tsid);
2287
2288         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_DELETE_PSTREAM_CMDID,
2289                                   SYNC_BEFORE_WMIFLAG);
2290
2291         spin_lock_bh(&wmi->lock);
2292         wmi->stream_exist_for_ac[traffic_class] &= ~(1 << tsid);
2293         active_tsids = wmi->stream_exist_for_ac[traffic_class];
2294         spin_unlock_bh(&wmi->lock);
2295
2296         /*
2297          * Indicate stream inactivity to driver layer only if all tsids
2298          * within this AC are deleted.
2299          */
2300         if (!active_tsids) {
2301                 ath6kl_indicate_tx_activity(wmi->parent_dev,
2302                                             traffic_class, false);
2303                 wmi->fat_pipe_exist &= ~(1 << traffic_class);
2304         }
2305
2306         return ret;
2307 }
2308
2309 int ath6kl_wmi_set_ip_cmd(struct wmi *wmi, struct wmi_set_ip_cmd *ip_cmd)
2310 {
2311         struct sk_buff *skb;
2312         struct wmi_set_ip_cmd *cmd;
2313         int ret;
2314
2315         /* Multicast address are not valid */
2316         if ((*((u8 *) &ip_cmd->ips[0]) >= 0xE0) ||
2317             (*((u8 *) &ip_cmd->ips[1]) >= 0xE0))
2318                 return -EINVAL;
2319
2320         skb = ath6kl_wmi_get_new_buf(sizeof(struct wmi_set_ip_cmd));
2321         if (!skb)
2322                 return -ENOMEM;
2323
2324         cmd = (struct wmi_set_ip_cmd *) skb->data;
2325         memcpy(cmd, ip_cmd, sizeof(struct wmi_set_ip_cmd));
2326
2327         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_SET_IP_CMDID, NO_SYNC_WMIFLAG);
2328         return ret;
2329 }
2330
2331 static int ath6kl_wmi_get_wow_list_event_rx(struct wmi *wmi, u8 * datap,
2332                                             int len)
2333 {
2334         if (len < sizeof(struct wmi_get_wow_list_reply))
2335                 return -EINVAL;
2336
2337         return 0;
2338 }
2339
2340 static int ath6kl_wmi_cmd_send_xtnd(struct wmi *wmi, struct sk_buff *skb,
2341                                     enum wmix_command_id cmd_id,
2342                                     enum wmi_sync_flag sync_flag)
2343 {
2344         struct wmix_cmd_hdr *cmd_hdr;
2345         int ret;
2346
2347         skb_push(skb, sizeof(struct wmix_cmd_hdr));
2348
2349         cmd_hdr = (struct wmix_cmd_hdr *) skb->data;
2350         cmd_hdr->cmd_id = cpu_to_le32(cmd_id);
2351
2352         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_EXTENSION_CMDID, sync_flag);
2353
2354         return ret;
2355 }
2356
2357 int ath6kl_wmi_get_challenge_resp_cmd(struct wmi *wmi, u32 cookie, u32 source)
2358 {
2359         struct sk_buff *skb;
2360         struct wmix_hb_challenge_resp_cmd *cmd;
2361         int ret;
2362
2363         skb = ath6kl_wmi_get_new_buf(sizeof(*cmd));
2364         if (!skb)
2365                 return -ENOMEM;
2366
2367         cmd = (struct wmix_hb_challenge_resp_cmd *) skb->data;
2368         cmd->cookie = cpu_to_le32(cookie);
2369         cmd->source = cpu_to_le32(source);
2370
2371         ret = ath6kl_wmi_cmd_send_xtnd(wmi, skb, WMIX_HB_CHALLENGE_RESP_CMDID,
2372                                        NO_SYNC_WMIFLAG);
2373         return ret;
2374 }
2375
2376 int ath6kl_wmi_get_stats_cmd(struct wmi *wmi)
2377 {
2378         return ath6kl_wmi_simple_cmd(wmi, WMI_GET_STATISTICS_CMDID);
2379 }
2380
2381 int ath6kl_wmi_set_tx_pwr_cmd(struct wmi *wmi, u8 dbM)
2382 {
2383         struct sk_buff *skb;
2384         struct wmi_set_tx_pwr_cmd *cmd;
2385         int ret;
2386
2387         skb = ath6kl_wmi_get_new_buf(sizeof(struct wmi_set_tx_pwr_cmd));
2388         if (!skb)
2389                 return -ENOMEM;
2390
2391         cmd = (struct wmi_set_tx_pwr_cmd *) skb->data;
2392         cmd->dbM = dbM;
2393
2394         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_SET_TX_PWR_CMDID,
2395                                   NO_SYNC_WMIFLAG);
2396
2397         return ret;
2398 }
2399
2400 int ath6kl_wmi_get_tx_pwr_cmd(struct wmi *wmi)
2401 {
2402         return ath6kl_wmi_simple_cmd(wmi, WMI_GET_TX_PWR_CMDID);
2403 }
2404
2405 int ath6kl_wmi_set_lpreamble_cmd(struct wmi *wmi, u8 status, u8 preamble_policy)
2406 {
2407         struct sk_buff *skb;
2408         struct wmi_set_lpreamble_cmd *cmd;
2409         int ret;
2410
2411         skb = ath6kl_wmi_get_new_buf(sizeof(struct wmi_set_lpreamble_cmd));
2412         if (!skb)
2413                 return -ENOMEM;
2414
2415         cmd = (struct wmi_set_lpreamble_cmd *) skb->data;
2416         cmd->status = status;
2417         cmd->preamble_policy = preamble_policy;
2418
2419         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_SET_LPREAMBLE_CMDID,
2420                                   NO_SYNC_WMIFLAG);
2421         return ret;
2422 }
2423
2424 int ath6kl_wmi_set_rts_cmd(struct wmi *wmi, u16 threshold)
2425 {
2426         struct sk_buff *skb;
2427         struct wmi_set_rts_cmd *cmd;
2428         int ret;
2429
2430         skb = ath6kl_wmi_get_new_buf(sizeof(struct wmi_set_rts_cmd));
2431         if (!skb)
2432                 return -ENOMEM;
2433
2434         cmd = (struct wmi_set_rts_cmd *) skb->data;
2435         cmd->threshold = cpu_to_le16(threshold);
2436
2437         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_SET_RTS_CMDID, NO_SYNC_WMIFLAG);
2438         return ret;
2439 }
2440
2441 int ath6kl_wmi_set_wmm_txop(struct wmi *wmi, enum wmi_txop_cfg cfg)
2442 {
2443         struct sk_buff *skb;
2444         struct wmi_set_wmm_txop_cmd *cmd;
2445         int ret;
2446
2447         if (!((cfg == WMI_TXOP_DISABLED) || (cfg == WMI_TXOP_ENABLED)))
2448                 return -EINVAL;
2449
2450         skb = ath6kl_wmi_get_new_buf(sizeof(struct wmi_set_wmm_txop_cmd));
2451         if (!skb)
2452                 return -ENOMEM;
2453
2454         cmd = (struct wmi_set_wmm_txop_cmd *) skb->data;
2455         cmd->txop_enable = cfg;
2456
2457         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_SET_WMM_TXOP_CMDID,
2458                                   NO_SYNC_WMIFLAG);
2459         return ret;
2460 }
2461
2462 int ath6kl_wmi_set_keepalive_cmd(struct wmi *wmi, u8 keep_alive_intvl)
2463 {
2464         struct sk_buff *skb;
2465         struct wmi_set_keepalive_cmd *cmd;
2466         int ret;
2467
2468         skb = ath6kl_wmi_get_new_buf(sizeof(*cmd));
2469         if (!skb)
2470                 return -ENOMEM;
2471
2472         cmd = (struct wmi_set_keepalive_cmd *) skb->data;
2473         cmd->keep_alive_intvl = keep_alive_intvl;
2474         wmi->keep_alive_intvl = keep_alive_intvl;
2475
2476         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_SET_KEEPALIVE_CMDID,
2477                                   NO_SYNC_WMIFLAG);
2478         return ret;
2479 }
2480
2481 s32 ath6kl_wmi_get_rate(s8 rate_index)
2482 {
2483         if (rate_index == RATE_AUTO)
2484                 return 0;
2485
2486         return wmi_rate_tbl[(u32) rate_index][0];
2487 }
2488
2489 void ath6kl_wmi_node_return(struct wmi *wmi, struct bss *bss)
2490 {
2491         if (bss)
2492                 wlan_node_return(&wmi->parent_dev->scan_table, bss);
2493 }
2494
2495 struct bss *ath6kl_wmi_find_ssid_node(struct wmi *wmi, u8 * ssid,
2496                                       u32 ssid_len, bool is_wpa2,
2497                                       bool match_ssid)
2498 {
2499         struct bss *node = NULL;
2500
2501         node = wlan_find_ssid_node(&wmi->parent_dev->scan_table, ssid,
2502                                   ssid_len, is_wpa2, match_ssid);
2503         return node;
2504 }
2505
2506 struct bss *ath6kl_wmi_find_node(struct wmi *wmi, const u8 * mac_addr)
2507 {
2508         struct bss *ni = NULL;
2509
2510         ni = wlan_find_node(&wmi->parent_dev->scan_table, mac_addr);
2511
2512         return ni;
2513 }
2514
2515 void ath6kl_wmi_node_free(struct wmi *wmi, const u8 * mac_addr)
2516 {
2517         struct bss *ni = NULL;
2518
2519         ni = wlan_find_node(&wmi->parent_dev->scan_table, mac_addr);
2520         if (ni != NULL)
2521                 wlan_node_reclaim(&wmi->parent_dev->scan_table, ni);
2522
2523         return;
2524 }
2525
2526 static int ath6kl_wmi_get_pmkid_list_event_rx(struct wmi *wmi, u8 *datap,
2527                                               u32 len)
2528 {
2529         struct wmi_pmkid_list_reply *reply;
2530         u32 expected_len;
2531
2532         if (len < sizeof(struct wmi_pmkid_list_reply))
2533                 return -EINVAL;
2534
2535         reply = (struct wmi_pmkid_list_reply *)datap;
2536         expected_len = sizeof(reply->num_pmkid) +
2537                 le32_to_cpu(reply->num_pmkid) * WMI_PMKID_LEN;
2538
2539         if (len < expected_len)
2540                 return -EINVAL;
2541
2542         return 0;
2543 }
2544
2545 static int ath6kl_wmi_addba_req_event_rx(struct wmi *wmi, u8 *datap, int len)
2546 {
2547         struct wmi_addba_req_event *cmd = (struct wmi_addba_req_event *) datap;
2548
2549         aggr_recv_addba_req_evt(wmi->parent_dev, cmd->tid,
2550                                 le16_to_cpu(cmd->st_seq_no), cmd->win_sz);
2551
2552         return 0;
2553 }
2554
2555 static int ath6kl_wmi_delba_req_event_rx(struct wmi *wmi, u8 *datap, int len)
2556 {
2557         struct wmi_delba_event *cmd = (struct wmi_delba_event *) datap;
2558
2559         aggr_recv_delba_req_evt(wmi->parent_dev, cmd->tid);
2560
2561         return 0;
2562 }
2563
2564 /*  AP mode functions */
2565
2566 int ath6kl_wmi_ap_profile_commit(struct wmi *wmip, struct wmi_connect_cmd *p)
2567 {
2568         struct sk_buff *skb;
2569         struct wmi_connect_cmd *cm;
2570         int res;
2571
2572         skb = ath6kl_wmi_get_new_buf(sizeof(*cm));
2573         if (!skb)
2574                 return -ENOMEM;
2575
2576         cm = (struct wmi_connect_cmd *) skb->data;
2577         memcpy(cm, p, sizeof(*cm));
2578
2579         res = ath6kl_wmi_cmd_send(wmip, skb, WMI_AP_CONFIG_COMMIT_CMDID,
2580                                   NO_SYNC_WMIFLAG);
2581         ath6kl_dbg(ATH6KL_DBG_WMI, "%s: nw_type=%u auth_mode=%u ch=%u "
2582                    "ctrl_flags=0x%x-> res=%d\n",
2583                    __func__, p->nw_type, p->auth_mode, le16_to_cpu(p->ch),
2584                    le32_to_cpu(p->ctrl_flags), res);
2585         return res;
2586 }
2587
2588 int ath6kl_wmi_ap_set_mlme(struct wmi *wmip, u8 cmd, const u8 *mac, u16 reason)
2589 {
2590         struct sk_buff *skb;
2591         struct wmi_ap_set_mlme_cmd *cm;
2592
2593         skb = ath6kl_wmi_get_new_buf(sizeof(*cm));
2594         if (!skb)
2595                 return -ENOMEM;
2596
2597         cm = (struct wmi_ap_set_mlme_cmd *) skb->data;
2598         memcpy(cm->mac, mac, ETH_ALEN);
2599         cm->reason = cpu_to_le16(reason);
2600         cm->cmd = cmd;
2601
2602         return ath6kl_wmi_cmd_send(wmip, skb, WMI_AP_SET_MLME_CMDID,
2603                                    NO_SYNC_WMIFLAG);
2604 }
2605
2606 static int ath6kl_wmi_pspoll_event_rx(struct wmi *wmi, u8 *datap, int len)
2607 {
2608         struct wmi_pspoll_event *ev;
2609
2610         if (len < sizeof(struct wmi_pspoll_event))
2611                 return -EINVAL;
2612
2613         ev = (struct wmi_pspoll_event *) datap;
2614
2615         ath6kl_pspoll_event(wmi->parent_dev, le16_to_cpu(ev->aid));
2616
2617         return 0;
2618 }
2619
2620 static int ath6kl_wmi_dtimexpiry_event_rx(struct wmi *wmi, u8 *datap, int len)
2621 {
2622         ath6kl_dtimexpiry_event(wmi->parent_dev);
2623
2624         return 0;
2625 }
2626
2627 int ath6kl_wmi_set_pvb_cmd(struct wmi *wmi, u16 aid, bool flag)
2628 {
2629         struct sk_buff *skb;
2630         struct wmi_ap_set_pvb_cmd *cmd;
2631         int ret;
2632
2633         skb = ath6kl_wmi_get_new_buf(sizeof(struct wmi_ap_set_pvb_cmd));
2634         if (!skb)
2635                 return -ENOMEM;
2636
2637         cmd = (struct wmi_ap_set_pvb_cmd *) skb->data;
2638         cmd->aid = cpu_to_le16(aid);
2639         cmd->flag = cpu_to_le32(flag);
2640
2641         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_AP_SET_PVB_CMDID,
2642                                   NO_SYNC_WMIFLAG);
2643
2644         return 0;
2645 }
2646
2647 int ath6kl_wmi_set_rx_frame_format_cmd(struct wmi *wmi, u8 rx_meta_ver,
2648                                        bool rx_dot11_hdr, bool defrag_on_host)
2649 {
2650         struct sk_buff *skb;
2651         struct wmi_rx_frame_format_cmd *cmd;
2652         int ret;
2653
2654         skb = ath6kl_wmi_get_new_buf(sizeof(*cmd));
2655         if (!skb)
2656                 return -ENOMEM;
2657
2658         cmd = (struct wmi_rx_frame_format_cmd *) skb->data;
2659         cmd->dot11_hdr = rx_dot11_hdr ? 1 : 0;
2660         cmd->defrag_on_host = defrag_on_host ? 1 : 0;
2661         cmd->meta_ver = rx_meta_ver;
2662
2663         /* Delete the local aggr state, on host */
2664         ret = ath6kl_wmi_cmd_send(wmi, skb, WMI_RX_FRAME_FORMAT_CMDID,
2665                                   NO_SYNC_WMIFLAG);
2666
2667         return ret;
2668 }
2669
2670 int ath6kl_wmi_set_appie_cmd(struct wmi *wmi, u8 mgmt_frm_type, const u8 *ie,
2671                              u8 ie_len)
2672 {
2673         struct sk_buff *skb;
2674         struct wmi_set_appie_cmd *p;
2675
2676         skb = ath6kl_wmi_get_new_buf(sizeof(*p) + ie_len);
2677         if (!skb)
2678                 return -ENOMEM;
2679
2680         ath6kl_dbg(ATH6KL_DBG_WMI, "set_appie_cmd: mgmt_frm_type=%u "
2681                    "ie_len=%u\n", mgmt_frm_type, ie_len);
2682         p = (struct wmi_set_appie_cmd *) skb->data;
2683         p->mgmt_frm_type = mgmt_frm_type;
2684         p->ie_len = ie_len;
2685         memcpy(p->ie_info, ie, ie_len);
2686         return ath6kl_wmi_cmd_send(wmi, skb, WMI_SET_APPIE_CMDID,
2687                                    NO_SYNC_WMIFLAG);
2688 }
2689
2690 int ath6kl_wmi_disable_11b_rates_cmd(struct wmi *wmi, bool disable)
2691 {
2692         struct sk_buff *skb;
2693         struct wmi_disable_11b_rates_cmd *cmd;
2694
2695         skb = ath6kl_wmi_get_new_buf(sizeof(*cmd));
2696         if (!skb)
2697                 return -ENOMEM;
2698
2699         ath6kl_dbg(ATH6KL_DBG_WMI, "disable_11b_rates_cmd: disable=%u\n",
2700                    disable);
2701         cmd = (struct wmi_disable_11b_rates_cmd *) skb->data;
2702         cmd->disable = disable ? 1 : 0;
2703
2704         return ath6kl_wmi_cmd_send(wmi, skb, WMI_DISABLE_11B_RATES_CMDID,
2705                                    NO_SYNC_WMIFLAG);
2706 }
2707
2708 int ath6kl_wmi_remain_on_chnl_cmd(struct wmi *wmi, u32 freq, u32 dur)
2709 {
2710         struct sk_buff *skb;
2711         struct wmi_remain_on_chnl_cmd *p;
2712
2713         skb = ath6kl_wmi_get_new_buf(sizeof(*p));
2714         if (!skb)
2715                 return -ENOMEM;
2716
2717         ath6kl_dbg(ATH6KL_DBG_WMI, "remain_on_chnl_cmd: freq=%u dur=%u\n",
2718                    freq, dur);
2719         p = (struct wmi_remain_on_chnl_cmd *) skb->data;
2720         p->freq = cpu_to_le32(freq);
2721         p->duration = cpu_to_le32(dur);
2722         return ath6kl_wmi_cmd_send(wmi, skb, WMI_REMAIN_ON_CHNL_CMDID,
2723                                    NO_SYNC_WMIFLAG);
2724 }
2725
2726 int ath6kl_wmi_send_action_cmd(struct wmi *wmi, u32 id, u32 freq, u32 wait,
2727                                const u8 *data, u16 data_len)
2728 {
2729         struct sk_buff *skb;
2730         struct wmi_send_action_cmd *p;
2731
2732         if (wait)
2733                 return -EINVAL; /* Offload for wait not supported */
2734
2735         skb = ath6kl_wmi_get_new_buf(sizeof(*p) + data_len);
2736         if (!skb)
2737                 return -ENOMEM;
2738
2739         ath6kl_dbg(ATH6KL_DBG_WMI, "send_action_cmd: id=%u freq=%u wait=%u "
2740                    "len=%u\n", id, freq, wait, data_len);
2741         p = (struct wmi_send_action_cmd *) skb->data;
2742         p->id = cpu_to_le32(id);
2743         p->freq = cpu_to_le32(freq);
2744         p->wait = cpu_to_le32(wait);
2745         p->len = cpu_to_le16(data_len);
2746         memcpy(p->data, data, data_len);
2747         return ath6kl_wmi_cmd_send(wmi, skb, WMI_SEND_ACTION_CMDID,
2748                                    NO_SYNC_WMIFLAG);
2749 }
2750
2751 int ath6kl_wmi_send_probe_response_cmd(struct wmi *wmi, u32 freq,
2752                                        const u8 *dst,
2753                                        const u8 *data, u16 data_len)
2754 {
2755         struct sk_buff *skb;
2756         struct wmi_p2p_probe_response_cmd *p;
2757
2758         skb = ath6kl_wmi_get_new_buf(sizeof(*p) + data_len);
2759         if (!skb)
2760                 return -ENOMEM;
2761
2762         ath6kl_dbg(ATH6KL_DBG_WMI, "send_probe_response_cmd: freq=%u dst=%pM "
2763                    "len=%u\n", freq, dst, data_len);
2764         p = (struct wmi_p2p_probe_response_cmd *) skb->data;
2765         p->freq = cpu_to_le32(freq);
2766         memcpy(p->destination_addr, dst, ETH_ALEN);
2767         p->len = cpu_to_le16(data_len);
2768         memcpy(p->data, data, data_len);
2769         return ath6kl_wmi_cmd_send(wmi, skb, WMI_SEND_PROBE_RESPONSE_CMDID,
2770                                    NO_SYNC_WMIFLAG);
2771 }
2772
2773 int ath6kl_wmi_probe_report_req_cmd(struct wmi *wmi, bool enable)
2774 {
2775         struct sk_buff *skb;
2776         struct wmi_probe_req_report_cmd *p;
2777
2778         skb = ath6kl_wmi_get_new_buf(sizeof(*p));
2779         if (!skb)
2780                 return -ENOMEM;
2781
2782         ath6kl_dbg(ATH6KL_DBG_WMI, "probe_report_req_cmd: enable=%u\n",
2783                    enable);
2784         p = (struct wmi_probe_req_report_cmd *) skb->data;
2785         p->enable = enable ? 1 : 0;
2786         return ath6kl_wmi_cmd_send(wmi, skb, WMI_PROBE_REQ_REPORT_CMDID,
2787                                    NO_SYNC_WMIFLAG);
2788 }
2789
2790 int ath6kl_wmi_info_req_cmd(struct wmi *wmi, u32 info_req_flags)
2791 {
2792         struct sk_buff *skb;
2793         struct wmi_get_p2p_info *p;
2794
2795         skb = ath6kl_wmi_get_new_buf(sizeof(*p));
2796         if (!skb)
2797                 return -ENOMEM;
2798
2799         ath6kl_dbg(ATH6KL_DBG_WMI, "info_req_cmd: flags=%x\n",
2800                    info_req_flags);
2801         p = (struct wmi_get_p2p_info *) skb->data;
2802         p->info_req_flags = cpu_to_le32(info_req_flags);
2803         return ath6kl_wmi_cmd_send(wmi, skb, WMI_GET_P2P_INFO_CMDID,
2804                                    NO_SYNC_WMIFLAG);
2805 }
2806
2807 int ath6kl_wmi_cancel_remain_on_chnl_cmd(struct wmi *wmi)
2808 {
2809         ath6kl_dbg(ATH6KL_DBG_WMI, "cancel_remain_on_chnl_cmd\n");
2810         return ath6kl_wmi_simple_cmd(wmi, WMI_CANCEL_REMAIN_ON_CHNL_CMDID);
2811 }
2812
2813 static int ath6kl_wmi_control_rx_xtnd(struct wmi *wmi, struct sk_buff *skb)
2814 {
2815         struct wmix_cmd_hdr *cmd;
2816         u32 len;
2817         u16 id;
2818         u8 *datap;
2819         int ret = 0;
2820
2821         if (skb->len < sizeof(struct wmix_cmd_hdr)) {
2822                 ath6kl_err("bad packet 1\n");
2823                 wmi->stat.cmd_len_err++;
2824                 return -EINVAL;
2825         }
2826
2827         cmd = (struct wmix_cmd_hdr *) skb->data;
2828         id = le32_to_cpu(cmd->cmd_id);
2829
2830         skb_pull(skb, sizeof(struct wmix_cmd_hdr));
2831
2832         datap = skb->data;
2833         len = skb->len;
2834
2835         switch (id) {
2836         case WMIX_HB_CHALLENGE_RESP_EVENTID:
2837                 break;
2838         case WMIX_DBGLOG_EVENTID:
2839                 break;
2840         default:
2841                 ath6kl_err("unknown cmd id 0x%x\n", id);
2842                 wmi->stat.cmd_id_err++;
2843                 ret = -EINVAL;
2844                 break;
2845         }
2846
2847         return ret;
2848 }
2849
2850 /* Control Path */
2851 int ath6kl_wmi_control_rx(struct wmi *wmi, struct sk_buff *skb)
2852 {
2853         struct wmi_cmd_hdr *cmd;
2854         u32 len;
2855         u16 id;
2856         u8 *datap;
2857         int ret = 0;
2858
2859         if (WARN_ON(skb == NULL))
2860                 return -EINVAL;
2861
2862         if (skb->len < sizeof(struct wmi_cmd_hdr)) {
2863                 ath6kl_err("bad packet 1\n");
2864                 dev_kfree_skb(skb);
2865                 wmi->stat.cmd_len_err++;
2866                 return -EINVAL;
2867         }
2868
2869         cmd = (struct wmi_cmd_hdr *) skb->data;
2870         id = le16_to_cpu(cmd->cmd_id);
2871
2872         skb_pull(skb, sizeof(struct wmi_cmd_hdr));
2873
2874         datap = skb->data;
2875         len = skb->len;
2876
2877         ath6kl_dbg(ATH6KL_DBG_WMI, "%s: wmi id: %d\n", __func__, id);
2878         ath6kl_dbg_dump(ATH6KL_DBG_RAW_BYTES, "msg payload ", datap, len);
2879
2880         switch (id) {
2881         case WMI_GET_BITRATE_CMDID:
2882                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_GET_BITRATE_CMDID\n");
2883                 ret = ath6kl_wmi_bitrate_reply_rx(wmi, datap, len);
2884                 break;
2885         case WMI_GET_CHANNEL_LIST_CMDID:
2886                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_GET_CHANNEL_LIST_CMDID\n");
2887                 ret = ath6kl_wmi_ch_list_reply_rx(wmi, datap, len);
2888                 break;
2889         case WMI_GET_TX_PWR_CMDID:
2890                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_GET_TX_PWR_CMDID\n");
2891                 ret = ath6kl_wmi_tx_pwr_reply_rx(wmi, datap, len);
2892                 break;
2893         case WMI_READY_EVENTID:
2894                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_READY_EVENTID\n");
2895                 ret = ath6kl_wmi_ready_event_rx(wmi, datap, len);
2896                 break;
2897         case WMI_CONNECT_EVENTID:
2898                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_CONNECT_EVENTID\n");
2899                 ret = ath6kl_wmi_connect_event_rx(wmi, datap, len);
2900                 break;
2901         case WMI_DISCONNECT_EVENTID:
2902                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_DISCONNECT_EVENTID\n");
2903                 ret = ath6kl_wmi_disconnect_event_rx(wmi, datap, len);
2904                 break;
2905         case WMI_PEER_NODE_EVENTID:
2906                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_PEER_NODE_EVENTID\n");
2907                 ret = ath6kl_wmi_peer_node_event_rx(wmi, datap, len);
2908                 break;
2909         case WMI_TKIP_MICERR_EVENTID:
2910                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_TKIP_MICERR_EVENTID\n");
2911                 ret = ath6kl_wmi_tkip_micerr_event_rx(wmi, datap, len);
2912                 break;
2913         case WMI_BSSINFO_EVENTID:
2914                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_BSSINFO_EVENTID\n");
2915                 ath6kl_wmi_convert_bssinfo_hdr2_to_hdr(skb, datap);
2916                 ret = ath6kl_wmi_bssinfo_event_rx(wmi, skb->data, skb->len);
2917                 break;
2918         case WMI_REGDOMAIN_EVENTID:
2919                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_REGDOMAIN_EVENTID\n");
2920                 break;
2921         case WMI_PSTREAM_TIMEOUT_EVENTID:
2922                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_PSTREAM_TIMEOUT_EVENTID\n");
2923                 ret = ath6kl_wmi_pstream_timeout_event_rx(wmi, datap, len);
2924                 break;
2925         case WMI_NEIGHBOR_REPORT_EVENTID:
2926                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_NEIGHBOR_REPORT_EVENTID\n");
2927                 break;
2928         case WMI_SCAN_COMPLETE_EVENTID:
2929                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_SCAN_COMPLETE_EVENTID\n");
2930                 ret = ath6kl_wmi_scan_complete_rx(wmi, datap, len);
2931                 break;
2932         case WMI_CMDERROR_EVENTID:
2933                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_CMDERROR_EVENTID\n");
2934                 ret = ath6kl_wmi_error_event_rx(wmi, datap, len);
2935                 break;
2936         case WMI_REPORT_STATISTICS_EVENTID:
2937                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_REPORT_STATISTICS_EVENTID\n");
2938                 ret = ath6kl_wmi_stats_event_rx(wmi, datap, len);
2939                 break;
2940         case WMI_RSSI_THRESHOLD_EVENTID:
2941                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_RSSI_THRESHOLD_EVENTID\n");
2942                 ret = ath6kl_wmi_rssi_threshold_event_rx(wmi, datap, len);
2943                 break;
2944         case WMI_ERROR_REPORT_EVENTID:
2945                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_ERROR_REPORT_EVENTID\n");
2946                 break;
2947         case WMI_OPT_RX_FRAME_EVENTID:
2948                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_OPT_RX_FRAME_EVENTID\n");
2949                 ret = ath6kl_wmi_opt_frame_event_rx(wmi, datap, len);
2950                 break;
2951         case WMI_REPORT_ROAM_TBL_EVENTID:
2952                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_REPORT_ROAM_TBL_EVENTID\n");
2953                 break;
2954         case WMI_EXTENSION_EVENTID:
2955                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_EXTENSION_EVENTID\n");
2956                 ret = ath6kl_wmi_control_rx_xtnd(wmi, skb);
2957                 break;
2958         case WMI_CAC_EVENTID:
2959                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_CAC_EVENTID\n");
2960                 ret = ath6kl_wmi_cac_event_rx(wmi, datap, len);
2961                 break;
2962         case WMI_CHANNEL_CHANGE_EVENTID:
2963                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_CHANNEL_CHANGE_EVENTID\n");
2964                 break;
2965         case WMI_REPORT_ROAM_DATA_EVENTID:
2966                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_REPORT_ROAM_DATA_EVENTID\n");
2967                 break;
2968         case WMI_GET_FIXRATES_CMDID:
2969                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_GET_FIXRATES_CMDID\n");
2970                 ret = ath6kl_wmi_ratemask_reply_rx(wmi, datap, len);
2971                 break;
2972         case WMI_TX_RETRY_ERR_EVENTID:
2973                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_TX_RETRY_ERR_EVENTID\n");
2974                 break;
2975         case WMI_SNR_THRESHOLD_EVENTID:
2976                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_SNR_THRESHOLD_EVENTID\n");
2977                 ret = ath6kl_wmi_snr_threshold_event_rx(wmi, datap, len);
2978                 break;
2979         case WMI_LQ_THRESHOLD_EVENTID:
2980                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_LQ_THRESHOLD_EVENTID\n");
2981                 break;
2982         case WMI_APLIST_EVENTID:
2983                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_APLIST_EVENTID\n");
2984                 ret = ath6kl_wmi_aplist_event_rx(wmi, datap, len);
2985                 break;
2986         case WMI_GET_KEEPALIVE_CMDID:
2987                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_GET_KEEPALIVE_CMDID\n");
2988                 ret = ath6kl_wmi_keepalive_reply_rx(wmi, datap, len);
2989                 break;
2990         case WMI_GET_WOW_LIST_EVENTID:
2991                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_GET_WOW_LIST_EVENTID\n");
2992                 ret = ath6kl_wmi_get_wow_list_event_rx(wmi, datap, len);
2993                 break;
2994         case WMI_GET_PMKID_LIST_EVENTID:
2995                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_GET_PMKID_LIST_EVENTID\n");
2996                 ret = ath6kl_wmi_get_pmkid_list_event_rx(wmi, datap, len);
2997                 break;
2998         case WMI_PSPOLL_EVENTID:
2999                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_PSPOLL_EVENTID\n");
3000                 ret = ath6kl_wmi_pspoll_event_rx(wmi, datap, len);
3001                 break;
3002         case WMI_DTIMEXPIRY_EVENTID:
3003                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_DTIMEXPIRY_EVENTID\n");
3004                 ret = ath6kl_wmi_dtimexpiry_event_rx(wmi, datap, len);
3005                 break;
3006         case WMI_SET_PARAMS_REPLY_EVENTID:
3007                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_SET_PARAMS_REPLY_EVENTID\n");
3008                 break;
3009         case WMI_ADDBA_REQ_EVENTID:
3010                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_ADDBA_REQ_EVENTID\n");
3011                 ret = ath6kl_wmi_addba_req_event_rx(wmi, datap, len);
3012                 break;
3013         case WMI_ADDBA_RESP_EVENTID:
3014                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_ADDBA_RESP_EVENTID\n");
3015                 break;
3016         case WMI_DELBA_REQ_EVENTID:
3017                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_DELBA_REQ_EVENTID\n");
3018                 ret = ath6kl_wmi_delba_req_event_rx(wmi, datap, len);
3019                 break;
3020         case WMI_REPORT_BTCOEX_CONFIG_EVENTID:
3021                 ath6kl_dbg(ATH6KL_DBG_WMI,
3022                            "WMI_REPORT_BTCOEX_CONFIG_EVENTID\n");
3023                 break;
3024         case WMI_REPORT_BTCOEX_STATS_EVENTID:
3025                 ath6kl_dbg(ATH6KL_DBG_WMI,
3026                            "WMI_REPORT_BTCOEX_STATS_EVENTID\n");
3027                 break;
3028         case WMI_TX_COMPLETE_EVENTID:
3029                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_TX_COMPLETE_EVENTID\n");
3030                 ret = ath6kl_wmi_tx_complete_event_rx(datap, len);
3031                 break;
3032         case WMI_REMAIN_ON_CHNL_EVENTID:
3033                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_REMAIN_ON_CHNL_EVENTID\n");
3034                 ret = ath6kl_wmi_remain_on_chnl_event_rx(wmi, datap, len);
3035                 break;
3036         case WMI_CANCEL_REMAIN_ON_CHNL_EVENTID:
3037                 ath6kl_dbg(ATH6KL_DBG_WMI,
3038                            "WMI_CANCEL_REMAIN_ON_CHNL_EVENTID\n");
3039                 ret = ath6kl_wmi_cancel_remain_on_chnl_event_rx(wmi, datap,
3040                                                                 len);
3041                 break;
3042         case WMI_TX_STATUS_EVENTID:
3043                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_TX_STATUS_EVENTID\n");
3044                 ret = ath6kl_wmi_tx_status_event_rx(datap, len);
3045                 break;
3046         case WMI_RX_PROBE_REQ_EVENTID:
3047                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_RX_PROBE_REQ_EVENTID\n");
3048                 ret = ath6kl_wmi_rx_probe_req_event_rx(datap, len);
3049                 break;
3050         case WMI_P2P_CAPABILITIES_EVENTID:
3051                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_P2P_CAPABILITIES_EVENTID\n");
3052                 ret = ath6kl_wmi_p2p_capabilities_event_rx(datap, len);
3053                 break;
3054         case WMI_RX_ACTION_EVENTID:
3055                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_RX_ACTION_EVENTID\n");
3056                 ret = ath6kl_wmi_rx_action_event_rx(datap, len);
3057                 break;
3058         case WMI_P2P_INFO_EVENTID:
3059                 ath6kl_dbg(ATH6KL_DBG_WMI, "WMI_P2P_INFO_EVENTID\n");
3060                 ret = ath6kl_wmi_p2p_info_event_rx(datap, len);
3061                 break;
3062         default:
3063                 ath6kl_dbg(ATH6KL_DBG_WMI, "unknown cmd id 0x%x\n", id);
3064                 wmi->stat.cmd_id_err++;
3065                 ret = -EINVAL;
3066                 break;
3067         }
3068
3069         dev_kfree_skb(skb);
3070
3071         return ret;
3072 }
3073
3074 static void ath6kl_wmi_qos_state_init(struct wmi *wmi)
3075 {
3076         if (!wmi)
3077                 return;
3078
3079         spin_lock_bh(&wmi->lock);
3080
3081         wmi->fat_pipe_exist = 0;
3082         memset(wmi->stream_exist_for_ac, 0, sizeof(wmi->stream_exist_for_ac));
3083
3084         spin_unlock_bh(&wmi->lock);
3085 }
3086
3087 void *ath6kl_wmi_init(struct ath6kl *dev)
3088 {
3089         struct wmi *wmi;
3090
3091         wmi = kzalloc(sizeof(struct wmi), GFP_KERNEL);
3092         if (!wmi)
3093                 return NULL;
3094
3095         spin_lock_init(&wmi->lock);
3096
3097         wmi->parent_dev = dev;
3098
3099         ath6kl_wmi_qos_state_init(wmi);
3100
3101         wmi->pwr_mode = REC_POWER;
3102         wmi->phy_mode = WMI_11G_MODE;
3103
3104         wmi->pair_crypto_type = NONE_CRYPT;
3105         wmi->grp_crypto_type = NONE_CRYPT;
3106
3107         wmi->ht_allowed[A_BAND_24GHZ] = 1;
3108         wmi->ht_allowed[A_BAND_5GHZ] = 1;
3109
3110         return wmi;
3111 }
3112
3113 void ath6kl_wmi_shutdown(struct wmi *wmi)
3114 {
3115         if (!wmi)
3116                 return;
3117
3118         kfree(wmi);
3119 }