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