2 * Copyright (c) 2004-2011 Atheros Communications Inc.
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.
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.
22 #include "../regd_common.h"
24 static int ath6kl_wmi_sync_point(struct wmi
*wmi
, u8 if_idx
);
26 static const s32 wmi_rate_tbl
[][2] = {
27 /* {W/O SGI, with SGI} */
59 /* 802.1d to AC mapping. Refer pg 57 of WMM-test-plan-v1.2 */
60 static const u8 up_to_ac
[] = {
71 void ath6kl_wmi_set_control_ep(struct wmi
*wmi
, enum htc_endpoint_id ep_id
)
73 if (WARN_ON(ep_id
== ENDPOINT_UNUSED
|| ep_id
>= ENDPOINT_MAX
))
79 enum htc_endpoint_id
ath6kl_wmi_get_control_ep(struct wmi
*wmi
)
84 struct ath6kl_vif
*ath6kl_get_vif_by_index(struct ath6kl
*ar
, u8 if_idx
)
86 struct ath6kl_vif
*vif
, *found
= NULL
;
88 if (WARN_ON(if_idx
> (MAX_NUM_VIF
- 1)))
92 spin_lock(&ar
->list_lock
);
93 list_for_each_entry(vif
, &ar
->vif_list
, list
) {
94 if (vif
->fw_vif_idx
== if_idx
) {
99 spin_unlock(&ar
->list_lock
);
104 /* Performs DIX to 802.3 encapsulation for transmit packets.
105 * Assumes the entire DIX header is contigous and that there is
106 * enough room in the buffer for a 802.3 mac header and LLC+SNAP headers.
108 int ath6kl_wmi_dix_2_dot3(struct wmi
*wmi
, struct sk_buff
*skb
)
110 struct ath6kl_llc_snap_hdr
*llc_hdr
;
111 struct ethhdr
*eth_hdr
;
117 if (WARN_ON(skb
== NULL
))
120 size
= sizeof(struct ath6kl_llc_snap_hdr
) + sizeof(struct wmi_data_hdr
);
121 if (skb_headroom(skb
) < size
)
124 eth_hdr
= (struct ethhdr
*) skb
->data
;
125 type
= eth_hdr
->h_proto
;
127 if (!is_ethertype(be16_to_cpu(type
))) {
128 ath6kl_dbg(ATH6KL_DBG_WMI
,
129 "%s: pkt is already in 802.3 format\n", __func__
);
133 new_len
= skb
->len
- sizeof(*eth_hdr
) + sizeof(*llc_hdr
);
135 skb_push(skb
, sizeof(struct ath6kl_llc_snap_hdr
));
138 eth_hdr
->h_proto
= cpu_to_be16(new_len
);
140 memcpy(datap
, eth_hdr
, sizeof(*eth_hdr
));
142 llc_hdr
= (struct ath6kl_llc_snap_hdr
*)(datap
+ sizeof(*eth_hdr
));
143 llc_hdr
->dsap
= 0xAA;
144 llc_hdr
->ssap
= 0xAA;
145 llc_hdr
->cntl
= 0x03;
146 llc_hdr
->org_code
[0] = 0x0;
147 llc_hdr
->org_code
[1] = 0x0;
148 llc_hdr
->org_code
[2] = 0x0;
149 llc_hdr
->eth_type
= type
;
154 static int ath6kl_wmi_meta_add(struct wmi
*wmi
, struct sk_buff
*skb
,
155 u8
*version
, void *tx_meta_info
)
157 struct wmi_tx_meta_v1
*v1
;
158 struct wmi_tx_meta_v2
*v2
;
160 if (WARN_ON(skb
== NULL
|| version
== NULL
))
164 case WMI_META_VERSION_1
:
165 skb_push(skb
, WMI_MAX_TX_META_SZ
);
166 v1
= (struct wmi_tx_meta_v1
*) skb
->data
;
168 v1
->rate_plcy_id
= 0;
169 *version
= WMI_META_VERSION_1
;
171 case WMI_META_VERSION_2
:
172 skb_push(skb
, WMI_MAX_TX_META_SZ
);
173 v2
= (struct wmi_tx_meta_v2
*) skb
->data
;
174 memcpy(v2
, (struct wmi_tx_meta_v2
*) tx_meta_info
,
175 sizeof(struct wmi_tx_meta_v2
));
182 int ath6kl_wmi_data_hdr_add(struct wmi
*wmi
, struct sk_buff
*skb
,
183 u8 msg_type
, bool more_data
,
184 enum wmi_data_hdr_data_type data_type
,
185 u8 meta_ver
, void *tx_meta_info
, u8 if_idx
)
187 struct wmi_data_hdr
*data_hdr
;
190 if (WARN_ON(skb
== NULL
|| (if_idx
> MAX_NUM_VIF
- 1)))
194 ret
= ath6kl_wmi_meta_add(wmi
, skb
, &meta_ver
, tx_meta_info
);
199 skb_push(skb
, sizeof(struct wmi_data_hdr
));
201 data_hdr
= (struct wmi_data_hdr
*)skb
->data
;
202 memset(data_hdr
, 0, sizeof(struct wmi_data_hdr
));
204 data_hdr
->info
= msg_type
<< WMI_DATA_HDR_MSG_TYPE_SHIFT
;
205 data_hdr
->info
|= data_type
<< WMI_DATA_HDR_DATA_TYPE_SHIFT
;
209 WMI_DATA_HDR_MORE_MASK
<< WMI_DATA_HDR_MORE_SHIFT
;
211 data_hdr
->info2
= cpu_to_le16(meta_ver
<< WMI_DATA_HDR_META_SHIFT
);
212 data_hdr
->info3
= cpu_to_le16(if_idx
& WMI_DATA_HDR_IF_IDX_MASK
);
217 static u8
ath6kl_wmi_determine_user_priority(u8
*pkt
, u32 layer2_pri
)
219 struct iphdr
*ip_hdr
= (struct iphdr
*) pkt
;
223 * Determine IPTOS priority
226 * : DSCP(6-bits) ECN(2-bits)
227 * : DSCP - P2 P1 P0 X X X
228 * where (P2 P1 P0) form 802.1D
230 ip_pri
= ip_hdr
->tos
>> 5;
233 if ((layer2_pri
& 0x7) > ip_pri
)
234 return (u8
) layer2_pri
& 0x7;
239 int ath6kl_wmi_implicit_create_pstream(struct wmi
*wmi
, u8 if_idx
,
241 u32 layer2_priority
, bool wmm_enabled
,
244 struct wmi_data_hdr
*data_hdr
;
245 struct ath6kl_llc_snap_hdr
*llc_hdr
;
246 struct wmi_create_pstream_cmd cmd
;
247 u32 meta_size
, hdr_size
;
248 u16 ip_type
= IP_ETHERTYPE
;
249 u8 stream_exist
, usr_pri
;
250 u8 traffic_class
= WMM_AC_BE
;
253 if (WARN_ON(skb
== NULL
))
257 data_hdr
= (struct wmi_data_hdr
*) datap
;
259 meta_size
= ((le16_to_cpu(data_hdr
->info2
) >> WMI_DATA_HDR_META_SHIFT
) &
260 WMI_DATA_HDR_META_MASK
) ? WMI_MAX_TX_META_SZ
: 0;
263 /* If WMM is disabled all traffic goes as BE traffic */
266 hdr_size
= sizeof(struct ethhdr
);
268 llc_hdr
= (struct ath6kl_llc_snap_hdr
*)(datap
+
271 meta_size
+ hdr_size
);
273 if (llc_hdr
->eth_type
== htons(ip_type
)) {
275 * Extract the endpoint info from the TOS field
279 ath6kl_wmi_determine_user_priority(((u8
*) llc_hdr
) +
280 sizeof(struct ath6kl_llc_snap_hdr
),
283 usr_pri
= layer2_priority
& 0x7;
287 * workaround for WMM S5
289 * FIXME: wmi->traffic_class is always 100 so this test doesn't
292 if ((wmi
->traffic_class
== WMM_AC_VI
) &&
293 ((usr_pri
== 5) || (usr_pri
== 4)))
296 /* Convert user priority to traffic class */
297 traffic_class
= up_to_ac
[usr_pri
& 0x7];
299 wmi_data_hdr_set_up(data_hdr
, usr_pri
);
301 spin_lock_bh(&wmi
->lock
);
302 stream_exist
= wmi
->fat_pipe_exist
;
303 spin_unlock_bh(&wmi
->lock
);
305 if (!(stream_exist
& (1 << traffic_class
))) {
306 memset(&cmd
, 0, sizeof(cmd
));
307 cmd
.traffic_class
= traffic_class
;
308 cmd
.user_pri
= usr_pri
;
310 cpu_to_le32(WMI_IMPLICIT_PSTREAM_INACTIVITY_INT
);
311 /* Implicit streams are created with TSID 0xFF */
312 cmd
.tsid
= WMI_IMPLICIT_PSTREAM
;
313 ath6kl_wmi_create_pstream_cmd(wmi
, if_idx
, &cmd
);
321 int ath6kl_wmi_dot11_hdr_remove(struct wmi
*wmi
, struct sk_buff
*skb
)
323 struct ieee80211_hdr_3addr
*pwh
, wh
;
324 struct ath6kl_llc_snap_hdr
*llc_hdr
;
325 struct ethhdr eth_hdr
;
330 if (WARN_ON(skb
== NULL
))
334 pwh
= (struct ieee80211_hdr_3addr
*) datap
;
336 sub_type
= pwh
->frame_control
& cpu_to_le16(IEEE80211_FCTL_STYPE
);
338 memcpy((u8
*) &wh
, datap
, sizeof(struct ieee80211_hdr_3addr
));
340 /* Strip off the 802.11 header */
341 if (sub_type
== cpu_to_le16(IEEE80211_STYPE_QOS_DATA
)) {
342 hdr_size
= roundup(sizeof(struct ieee80211_qos_hdr
),
344 skb_pull(skb
, hdr_size
);
345 } else if (sub_type
== cpu_to_le16(IEEE80211_STYPE_DATA
))
346 skb_pull(skb
, sizeof(struct ieee80211_hdr_3addr
));
349 llc_hdr
= (struct ath6kl_llc_snap_hdr
*)(datap
);
351 memset(ð_hdr
, 0, sizeof(eth_hdr
));
352 eth_hdr
.h_proto
= llc_hdr
->eth_type
;
354 switch ((le16_to_cpu(wh
.frame_control
)) &
355 (IEEE80211_FCTL_FROMDS
| IEEE80211_FCTL_TODS
)) {
357 memcpy(eth_hdr
.h_dest
, wh
.addr1
, ETH_ALEN
);
358 memcpy(eth_hdr
.h_source
, wh
.addr2
, ETH_ALEN
);
360 case IEEE80211_FCTL_TODS
:
361 memcpy(eth_hdr
.h_dest
, wh
.addr3
, ETH_ALEN
);
362 memcpy(eth_hdr
.h_source
, wh
.addr2
, ETH_ALEN
);
364 case IEEE80211_FCTL_FROMDS
:
365 memcpy(eth_hdr
.h_dest
, wh
.addr1
, ETH_ALEN
);
366 memcpy(eth_hdr
.h_source
, wh
.addr3
, ETH_ALEN
);
368 case IEEE80211_FCTL_FROMDS
| IEEE80211_FCTL_TODS
:
372 skb_pull(skb
, sizeof(struct ath6kl_llc_snap_hdr
));
373 skb_push(skb
, sizeof(eth_hdr
));
377 memcpy(datap
, ð_hdr
, sizeof(eth_hdr
));
383 * Performs 802.3 to DIX encapsulation for received packets.
384 * Assumes the entire 802.3 header is contigous.
386 int ath6kl_wmi_dot3_2_dix(struct sk_buff
*skb
)
388 struct ath6kl_llc_snap_hdr
*llc_hdr
;
389 struct ethhdr eth_hdr
;
392 if (WARN_ON(skb
== NULL
))
397 memcpy(ð_hdr
, datap
, sizeof(eth_hdr
));
399 llc_hdr
= (struct ath6kl_llc_snap_hdr
*) (datap
+ sizeof(eth_hdr
));
400 eth_hdr
.h_proto
= llc_hdr
->eth_type
;
402 skb_pull(skb
, sizeof(struct ath6kl_llc_snap_hdr
));
405 memcpy(datap
, ð_hdr
, sizeof(eth_hdr
));
410 static int ath6kl_wmi_tx_complete_event_rx(u8
*datap
, int len
)
412 struct tx_complete_msg_v1
*msg_v1
;
413 struct wmi_tx_complete_event
*evt
;
417 evt
= (struct wmi_tx_complete_event
*) datap
;
419 ath6kl_dbg(ATH6KL_DBG_WMI
, "comp: %d %d %d\n",
420 evt
->num_msg
, evt
->msg_len
, evt
->msg_type
);
422 if (!AR_DBG_LVL_CHECK(ATH6KL_DBG_WMI
))
425 for (index
= 0; index
< evt
->num_msg
; index
++) {
426 size
= sizeof(struct wmi_tx_complete_event
) +
427 (index
* sizeof(struct tx_complete_msg_v1
));
428 msg_v1
= (struct tx_complete_msg_v1
*)(datap
+ size
);
430 ath6kl_dbg(ATH6KL_DBG_WMI
, "msg: %d %d %d %d\n",
431 msg_v1
->status
, msg_v1
->pkt_id
,
432 msg_v1
->rate_idx
, msg_v1
->ack_failures
);
438 static int ath6kl_wmi_remain_on_chnl_event_rx(struct wmi
*wmi
, u8
*datap
,
439 int len
, struct ath6kl_vif
*vif
)
441 struct wmi_remain_on_chnl_event
*ev
;
444 struct ieee80211_channel
*chan
;
445 struct ath6kl
*ar
= wmi
->parent_dev
;
447 if (len
< sizeof(*ev
))
450 ev
= (struct wmi_remain_on_chnl_event
*) datap
;
451 freq
= le32_to_cpu(ev
->freq
);
452 dur
= le32_to_cpu(ev
->duration
);
453 ath6kl_dbg(ATH6KL_DBG_WMI
, "remain_on_chnl: freq=%u dur=%u\n",
455 chan
= ieee80211_get_channel(ar
->wiphy
, freq
);
457 ath6kl_dbg(ATH6KL_DBG_WMI
, "remain_on_chnl: Unknown channel "
458 "(freq=%u)\n", freq
);
461 cfg80211_ready_on_channel(vif
->ndev
, 1, chan
, NL80211_CHAN_NO_HT
,
467 static int ath6kl_wmi_cancel_remain_on_chnl_event_rx(struct wmi
*wmi
,
469 struct ath6kl_vif
*vif
)
471 struct wmi_cancel_remain_on_chnl_event
*ev
;
474 struct ieee80211_channel
*chan
;
475 struct ath6kl
*ar
= wmi
->parent_dev
;
477 if (len
< sizeof(*ev
))
480 ev
= (struct wmi_cancel_remain_on_chnl_event
*) datap
;
481 freq
= le32_to_cpu(ev
->freq
);
482 dur
= le32_to_cpu(ev
->duration
);
483 ath6kl_dbg(ATH6KL_DBG_WMI
, "cancel_remain_on_chnl: freq=%u dur=%u "
484 "status=%u\n", freq
, dur
, ev
->status
);
485 chan
= ieee80211_get_channel(ar
->wiphy
, freq
);
487 ath6kl_dbg(ATH6KL_DBG_WMI
, "cancel_remain_on_chnl: Unknown "
488 "channel (freq=%u)\n", freq
);
491 cfg80211_remain_on_channel_expired(vif
->ndev
, 1, chan
,
492 NL80211_CHAN_NO_HT
, GFP_ATOMIC
);
497 static int ath6kl_wmi_tx_status_event_rx(struct wmi
*wmi
, u8
*datap
, int len
,
498 struct ath6kl_vif
*vif
)
500 struct wmi_tx_status_event
*ev
;
503 if (len
< sizeof(*ev
))
506 ev
= (struct wmi_tx_status_event
*) datap
;
507 id
= le32_to_cpu(ev
->id
);
508 ath6kl_dbg(ATH6KL_DBG_WMI
, "tx_status: id=%x ack_status=%u\n",
510 if (wmi
->last_mgmt_tx_frame
) {
511 cfg80211_mgmt_tx_status(vif
->ndev
, id
,
512 wmi
->last_mgmt_tx_frame
,
513 wmi
->last_mgmt_tx_frame_len
,
514 !!ev
->ack_status
, GFP_ATOMIC
);
515 kfree(wmi
->last_mgmt_tx_frame
);
516 wmi
->last_mgmt_tx_frame
= NULL
;
517 wmi
->last_mgmt_tx_frame_len
= 0;
523 static int ath6kl_wmi_rx_probe_req_event_rx(struct wmi
*wmi
, u8
*datap
, int len
,
524 struct ath6kl_vif
*vif
)
526 struct wmi_p2p_rx_probe_req_event
*ev
;
530 if (len
< sizeof(*ev
))
533 ev
= (struct wmi_p2p_rx_probe_req_event
*) datap
;
534 freq
= le32_to_cpu(ev
->freq
);
535 dlen
= le16_to_cpu(ev
->len
);
536 if (datap
+ len
< ev
->data
+ dlen
) {
537 ath6kl_err("invalid wmi_p2p_rx_probe_req_event: "
538 "len=%d dlen=%u\n", len
, dlen
);
541 ath6kl_dbg(ATH6KL_DBG_WMI
, "rx_probe_req: len=%u freq=%u "
542 "probe_req_report=%d\n",
543 dlen
, freq
, vif
->probe_req_report
);
545 if (vif
->probe_req_report
|| vif
->nw_type
== AP_NETWORK
)
546 cfg80211_rx_mgmt(vif
->ndev
, freq
, ev
->data
, dlen
, GFP_ATOMIC
);
551 static int ath6kl_wmi_p2p_capabilities_event_rx(u8
*datap
, int len
)
553 struct wmi_p2p_capabilities_event
*ev
;
556 if (len
< sizeof(*ev
))
559 ev
= (struct wmi_p2p_capabilities_event
*) datap
;
560 dlen
= le16_to_cpu(ev
->len
);
561 ath6kl_dbg(ATH6KL_DBG_WMI
, "p2p_capab: len=%u\n", dlen
);
566 static int ath6kl_wmi_rx_action_event_rx(struct wmi
*wmi
, u8
*datap
, int len
,
567 struct ath6kl_vif
*vif
)
569 struct wmi_rx_action_event
*ev
;
573 if (len
< sizeof(*ev
))
576 ev
= (struct wmi_rx_action_event
*) datap
;
577 freq
= le32_to_cpu(ev
->freq
);
578 dlen
= le16_to_cpu(ev
->len
);
579 if (datap
+ len
< ev
->data
+ dlen
) {
580 ath6kl_err("invalid wmi_rx_action_event: "
581 "len=%d dlen=%u\n", len
, dlen
);
584 ath6kl_dbg(ATH6KL_DBG_WMI
, "rx_action: len=%u freq=%u\n", dlen
, freq
);
585 cfg80211_rx_mgmt(vif
->ndev
, freq
, ev
->data
, dlen
, GFP_ATOMIC
);
590 static int ath6kl_wmi_p2p_info_event_rx(u8
*datap
, int len
)
592 struct wmi_p2p_info_event
*ev
;
596 if (len
< sizeof(*ev
))
599 ev
= (struct wmi_p2p_info_event
*) datap
;
600 flags
= le32_to_cpu(ev
->info_req_flags
);
601 dlen
= le16_to_cpu(ev
->len
);
602 ath6kl_dbg(ATH6KL_DBG_WMI
, "p2p_info: flags=%x len=%d\n", flags
, dlen
);
604 if (flags
& P2P_FLAG_CAPABILITIES_REQ
) {
605 struct wmi_p2p_capabilities
*cap
;
606 if (dlen
< sizeof(*cap
))
608 cap
= (struct wmi_p2p_capabilities
*) ev
->data
;
609 ath6kl_dbg(ATH6KL_DBG_WMI
, "p2p_info: GO Power Save = %d\n",
613 if (flags
& P2P_FLAG_MACADDR_REQ
) {
614 struct wmi_p2p_macaddr
*mac
;
615 if (dlen
< sizeof(*mac
))
617 mac
= (struct wmi_p2p_macaddr
*) ev
->data
;
618 ath6kl_dbg(ATH6KL_DBG_WMI
, "p2p_info: MAC Address = %pM\n",
622 if (flags
& P2P_FLAG_HMODEL_REQ
) {
623 struct wmi_p2p_hmodel
*mod
;
624 if (dlen
< sizeof(*mod
))
626 mod
= (struct wmi_p2p_hmodel
*) ev
->data
;
627 ath6kl_dbg(ATH6KL_DBG_WMI
, "p2p_info: P2P Model = %d (%s)\n",
629 mod
->p2p_model
? "host" : "firmware");
634 static inline struct sk_buff
*ath6kl_wmi_get_new_buf(u32 size
)
638 skb
= ath6kl_buf_alloc(size
);
644 memset(skb
->data
, 0, size
);
649 /* Send a "simple" wmi command -- one with no arguments */
650 static int ath6kl_wmi_simple_cmd(struct wmi
*wmi
, u8 if_idx
,
651 enum wmi_cmd_id cmd_id
)
656 skb
= ath6kl_wmi_get_new_buf(0);
660 ret
= ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, cmd_id
, NO_SYNC_WMIFLAG
);
665 static int ath6kl_wmi_ready_event_rx(struct wmi
*wmi
, u8
*datap
, int len
)
667 struct wmi_ready_event_2
*ev
= (struct wmi_ready_event_2
*) datap
;
669 if (len
< sizeof(struct wmi_ready_event_2
))
672 ath6kl_ready_event(wmi
->parent_dev
, ev
->mac_addr
,
673 le32_to_cpu(ev
->sw_version
),
674 le32_to_cpu(ev
->abi_version
));
680 * Mechanism to modify the roaming behavior in the firmware. The lower rssi
681 * at which the station has to roam can be passed with
682 * WMI_SET_LRSSI_SCAN_PARAMS. Subtract 96 from RSSI to get the signal level
685 int ath6kl_wmi_set_roam_lrssi_cmd(struct wmi
*wmi
, u8 lrssi
)
688 struct roam_ctrl_cmd
*cmd
;
690 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
694 cmd
= (struct roam_ctrl_cmd
*) skb
->data
;
696 cmd
->info
.params
.lrssi_scan_period
= cpu_to_le16(DEF_LRSSI_SCAN_PERIOD
);
697 cmd
->info
.params
.lrssi_scan_threshold
= a_cpu_to_sle16(lrssi
+
698 DEF_SCAN_FOR_ROAM_INTVL
);
699 cmd
->info
.params
.lrssi_roam_threshold
= a_cpu_to_sle16(lrssi
);
700 cmd
->info
.params
.roam_rssi_floor
= DEF_LRSSI_ROAM_FLOOR
;
701 cmd
->roam_ctrl
= WMI_SET_LRSSI_SCAN_PARAMS
;
703 ath6kl_wmi_cmd_send(wmi
, 0, skb
, WMI_SET_ROAM_CTRL_CMDID
,
709 int ath6kl_wmi_force_roam_cmd(struct wmi
*wmi
, const u8
*bssid
)
712 struct roam_ctrl_cmd
*cmd
;
714 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
718 cmd
= (struct roam_ctrl_cmd
*) skb
->data
;
719 memset(cmd
, 0, sizeof(*cmd
));
721 memcpy(cmd
->info
.bssid
, bssid
, ETH_ALEN
);
722 cmd
->roam_ctrl
= WMI_FORCE_ROAM
;
724 ath6kl_dbg(ATH6KL_DBG_WMI
, "force roam to %pM\n", bssid
);
725 return ath6kl_wmi_cmd_send(wmi
, 0, skb
, WMI_SET_ROAM_CTRL_CMDID
,
729 int ath6kl_wmi_set_roam_mode_cmd(struct wmi
*wmi
, enum wmi_roam_mode mode
)
732 struct roam_ctrl_cmd
*cmd
;
734 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
738 cmd
= (struct roam_ctrl_cmd
*) skb
->data
;
739 memset(cmd
, 0, sizeof(*cmd
));
741 cmd
->info
.roam_mode
= mode
;
742 cmd
->roam_ctrl
= WMI_SET_ROAM_MODE
;
744 ath6kl_dbg(ATH6KL_DBG_WMI
, "set roam mode %d\n", mode
);
745 return ath6kl_wmi_cmd_send(wmi
, 0, skb
, WMI_SET_ROAM_CTRL_CMDID
,
749 static int ath6kl_wmi_connect_event_rx(struct wmi
*wmi
, u8
*datap
, int len
,
750 struct ath6kl_vif
*vif
)
752 struct wmi_connect_event
*ev
;
755 if (len
< sizeof(struct wmi_connect_event
))
758 ev
= (struct wmi_connect_event
*) datap
;
760 if (vif
->nw_type
== AP_NETWORK
) {
761 /* AP mode start/STA connected event */
762 struct net_device
*dev
= vif
->ndev
;
763 if (memcmp(dev
->dev_addr
, ev
->u
.ap_bss
.bssid
, ETH_ALEN
) == 0) {
764 ath6kl_dbg(ATH6KL_DBG_WMI
, "%s: freq %d bssid %pM "
766 __func__
, le16_to_cpu(ev
->u
.ap_bss
.ch
),
768 ath6kl_connect_ap_mode_bss(
769 vif
, le16_to_cpu(ev
->u
.ap_bss
.ch
));
771 ath6kl_dbg(ATH6KL_DBG_WMI
, "%s: aid %u mac_addr %pM "
772 "auth=%u keymgmt=%u cipher=%u apsd_info=%u "
774 __func__
, ev
->u
.ap_sta
.aid
,
775 ev
->u
.ap_sta
.mac_addr
,
777 ev
->u
.ap_sta
.keymgmt
,
778 le16_to_cpu(ev
->u
.ap_sta
.cipher
),
779 ev
->u
.ap_sta
.apsd_info
);
780 ath6kl_connect_ap_mode_sta(
781 vif
, ev
->u
.ap_sta
.aid
, ev
->u
.ap_sta
.mac_addr
,
782 ev
->u
.ap_sta
.keymgmt
,
783 le16_to_cpu(ev
->u
.ap_sta
.cipher
),
784 ev
->u
.ap_sta
.auth
, ev
->assoc_req_len
,
785 ev
->assoc_info
+ ev
->beacon_ie_len
);
790 /* STA/IBSS mode connection event */
792 ath6kl_dbg(ATH6KL_DBG_WMI
,
793 "wmi event connect freq %d bssid %pM listen_intvl %d beacon_intvl %d type %d\n",
794 le16_to_cpu(ev
->u
.sta
.ch
), ev
->u
.sta
.bssid
,
795 le16_to_cpu(ev
->u
.sta
.listen_intvl
),
796 le16_to_cpu(ev
->u
.sta
.beacon_intvl
),
797 le32_to_cpu(ev
->u
.sta
.nw_type
));
799 /* Start of assoc rsp IEs */
800 pie
= ev
->assoc_info
+ ev
->beacon_ie_len
+
801 ev
->assoc_req_len
+ (sizeof(u16
) * 3); /* capinfo, status, aid */
803 /* End of assoc rsp IEs */
804 peie
= ev
->assoc_info
+ ev
->beacon_ie_len
+ ev
->assoc_req_len
+
809 case WLAN_EID_VENDOR_SPECIFIC
:
810 if (pie
[1] > 3 && pie
[2] == 0x00 && pie
[3] == 0x50 &&
811 pie
[4] == 0xf2 && pie
[5] == WMM_OUI_TYPE
) {
812 /* WMM OUT (00:50:F2) */
814 && pie
[6] == WMM_PARAM_OUI_SUBTYPE
)
815 wmi
->is_wmm_enabled
= true;
820 if (wmi
->is_wmm_enabled
)
826 ath6kl_connect_event(vif
, le16_to_cpu(ev
->u
.sta
.ch
),
828 le16_to_cpu(ev
->u
.sta
.listen_intvl
),
829 le16_to_cpu(ev
->u
.sta
.beacon_intvl
),
830 le32_to_cpu(ev
->u
.sta
.nw_type
),
831 ev
->beacon_ie_len
, ev
->assoc_req_len
,
832 ev
->assoc_resp_len
, ev
->assoc_info
);
837 static struct country_code_to_enum_rd
*
838 ath6kl_regd_find_country(u16 countryCode
)
842 for (i
= 0; i
< ARRAY_SIZE(allCountries
); i
++) {
843 if (allCountries
[i
].countryCode
== countryCode
)
844 return &allCountries
[i
];
850 static struct reg_dmn_pair_mapping
*
851 ath6kl_get_regpair(u16 regdmn
)
855 if (regdmn
== NO_ENUMRD
)
858 for (i
= 0; i
< ARRAY_SIZE(regDomainPairs
); i
++) {
859 if (regDomainPairs
[i
].regDmnEnum
== regdmn
)
860 return ®DomainPairs
[i
];
866 static struct country_code_to_enum_rd
*
867 ath6kl_regd_find_country_by_rd(u16 regdmn
)
871 for (i
= 0; i
< ARRAY_SIZE(allCountries
); i
++) {
872 if (allCountries
[i
].regDmnEnum
== regdmn
)
873 return &allCountries
[i
];
879 static void ath6kl_wmi_regdomain_event(struct wmi
*wmi
, u8
*datap
, int len
)
882 struct ath6kl_wmi_regdomain
*ev
;
883 struct country_code_to_enum_rd
*country
= NULL
;
884 struct reg_dmn_pair_mapping
*regpair
= NULL
;
888 ev
= (struct ath6kl_wmi_regdomain
*) datap
;
889 reg_code
= le32_to_cpu(ev
->reg_code
);
891 if ((reg_code
>> ATH6KL_COUNTRY_RD_SHIFT
) & COUNTRY_ERD_FLAG
)
892 country
= ath6kl_regd_find_country((u16
) reg_code
);
893 else if (!(((u16
) reg_code
& WORLD_SKU_MASK
) == WORLD_SKU_PREFIX
)) {
895 regpair
= ath6kl_get_regpair((u16
) reg_code
);
896 country
= ath6kl_regd_find_country_by_rd((u16
) reg_code
);
897 ath6kl_dbg(ATH6KL_DBG_WMI
, "Regpair used: 0x%0x\n",
898 regpair
->regDmnEnum
);
902 alpha2
[0] = country
->isoName
[0];
903 alpha2
[1] = country
->isoName
[1];
905 regulatory_hint(wmi
->parent_dev
->wiphy
, alpha2
);
907 ath6kl_dbg(ATH6KL_DBG_WMI
, "Country alpha2 being used: %c%c\n",
908 alpha2
[0], alpha2
[1]);
912 static int ath6kl_wmi_disconnect_event_rx(struct wmi
*wmi
, u8
*datap
, int len
,
913 struct ath6kl_vif
*vif
)
915 struct wmi_disconnect_event
*ev
;
916 wmi
->traffic_class
= 100;
918 if (len
< sizeof(struct wmi_disconnect_event
))
921 ev
= (struct wmi_disconnect_event
*) datap
;
923 ath6kl_dbg(ATH6KL_DBG_WMI
,
924 "wmi event disconnect proto_reason %d bssid %pM wmi_reason %d assoc_resp_len %d\n",
925 le16_to_cpu(ev
->proto_reason_status
), ev
->bssid
,
926 ev
->disconn_reason
, ev
->assoc_resp_len
);
928 wmi
->is_wmm_enabled
= false;
930 ath6kl_disconnect_event(vif
, ev
->disconn_reason
,
931 ev
->bssid
, ev
->assoc_resp_len
, ev
->assoc_info
,
932 le16_to_cpu(ev
->proto_reason_status
));
937 static int ath6kl_wmi_peer_node_event_rx(struct wmi
*wmi
, u8
*datap
, int len
)
939 struct wmi_peer_node_event
*ev
;
941 if (len
< sizeof(struct wmi_peer_node_event
))
944 ev
= (struct wmi_peer_node_event
*) datap
;
946 if (ev
->event_code
== PEER_NODE_JOIN_EVENT
)
947 ath6kl_dbg(ATH6KL_DBG_WMI
, "joined node with mac addr: %pM\n",
949 else if (ev
->event_code
== PEER_NODE_LEAVE_EVENT
)
950 ath6kl_dbg(ATH6KL_DBG_WMI
, "left node with mac addr: %pM\n",
956 static int ath6kl_wmi_tkip_micerr_event_rx(struct wmi
*wmi
, u8
*datap
, int len
,
957 struct ath6kl_vif
*vif
)
959 struct wmi_tkip_micerr_event
*ev
;
961 if (len
< sizeof(struct wmi_tkip_micerr_event
))
964 ev
= (struct wmi_tkip_micerr_event
*) datap
;
966 ath6kl_tkip_micerr_event(vif
, ev
->key_id
, ev
->is_mcast
);
971 static int ath6kl_wmi_bssinfo_event_rx(struct wmi
*wmi
, u8
*datap
, int len
,
972 struct ath6kl_vif
*vif
)
974 struct wmi_bss_info_hdr2
*bih
;
976 struct ieee80211_channel
*channel
;
977 struct ath6kl
*ar
= wmi
->parent_dev
;
978 struct ieee80211_mgmt
*mgmt
;
979 struct cfg80211_bss
*bss
;
981 if (len
<= sizeof(struct wmi_bss_info_hdr2
))
984 bih
= (struct wmi_bss_info_hdr2
*) datap
;
985 buf
= datap
+ sizeof(struct wmi_bss_info_hdr2
);
986 len
-= sizeof(struct wmi_bss_info_hdr2
);
988 ath6kl_dbg(ATH6KL_DBG_WMI
,
989 "bss info evt - ch %u, snr %d, rssi %d, bssid \"%pM\" "
991 bih
->ch
, bih
->snr
, bih
->snr
- 95, bih
->bssid
,
994 if (bih
->frame_type
!= BEACON_FTYPE
&&
995 bih
->frame_type
!= PROBERESP_FTYPE
)
996 return 0; /* Only update BSS table for now */
998 if (bih
->frame_type
== BEACON_FTYPE
&&
999 test_bit(CLEAR_BSSFILTER_ON_BEACON
, &vif
->flags
)) {
1000 clear_bit(CLEAR_BSSFILTER_ON_BEACON
, &vif
->flags
);
1001 ath6kl_wmi_bssfilter_cmd(ar
->wmi
, vif
->fw_vif_idx
,
1002 NONE_BSS_FILTER
, 0);
1005 channel
= ieee80211_get_channel(ar
->wiphy
, le16_to_cpu(bih
->ch
));
1006 if (channel
== NULL
)
1009 if (len
< 8 + 2 + 2)
1012 if (bih
->frame_type
== BEACON_FTYPE
&& test_bit(CONNECTED
, &vif
->flags
)
1013 && memcmp(bih
->bssid
, vif
->bssid
, ETH_ALEN
) == 0) {
1015 tim
= cfg80211_find_ie(WLAN_EID_TIM
, buf
+ 8 + 2 + 2,
1017 if (tim
&& tim
[1] >= 2) {
1018 vif
->assoc_bss_dtim_period
= tim
[3];
1019 set_bit(DTIM_PERIOD_AVAIL
, &vif
->flags
);
1024 * In theory, use of cfg80211_inform_bss() would be more natural here
1025 * since we do not have the full frame. However, at least for now,
1026 * cfg80211 can only distinguish Beacon and Probe Response frames from
1027 * each other when using cfg80211_inform_bss_frame(), so let's build a
1028 * fake IEEE 802.11 header to be able to take benefit of this.
1030 mgmt
= kmalloc(24 + len
, GFP_ATOMIC
);
1034 if (bih
->frame_type
== BEACON_FTYPE
) {
1035 mgmt
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
1036 IEEE80211_STYPE_BEACON
);
1037 memset(mgmt
->da
, 0xff, ETH_ALEN
);
1039 struct net_device
*dev
= vif
->ndev
;
1041 mgmt
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
1042 IEEE80211_STYPE_PROBE_RESP
);
1043 memcpy(mgmt
->da
, dev
->dev_addr
, ETH_ALEN
);
1045 mgmt
->duration
= cpu_to_le16(0);
1046 memcpy(mgmt
->sa
, bih
->bssid
, ETH_ALEN
);
1047 memcpy(mgmt
->bssid
, bih
->bssid
, ETH_ALEN
);
1048 mgmt
->seq_ctrl
= cpu_to_le16(0);
1050 memcpy(&mgmt
->u
.beacon
, buf
, len
);
1052 bss
= cfg80211_inform_bss_frame(ar
->wiphy
, channel
, mgmt
,
1053 24 + len
, (bih
->snr
- 95) * 100,
1058 cfg80211_put_bss(bss
);
1063 /* Inactivity timeout of a fatpipe(pstream) at the target */
1064 static int ath6kl_wmi_pstream_timeout_event_rx(struct wmi
*wmi
, u8
*datap
,
1067 struct wmi_pstream_timeout_event
*ev
;
1069 if (len
< sizeof(struct wmi_pstream_timeout_event
))
1072 ev
= (struct wmi_pstream_timeout_event
*) datap
;
1075 * When the pstream (fat pipe == AC) timesout, it means there were
1076 * no thinStreams within this pstream & it got implicitly created
1077 * due to data flow on this AC. We start the inactivity timer only
1078 * for implicitly created pstream. Just reset the host state.
1080 spin_lock_bh(&wmi
->lock
);
1081 wmi
->stream_exist_for_ac
[ev
->traffic_class
] = 0;
1082 wmi
->fat_pipe_exist
&= ~(1 << ev
->traffic_class
);
1083 spin_unlock_bh(&wmi
->lock
);
1085 /* Indicate inactivity to driver layer for this fatpipe (pstream) */
1086 ath6kl_indicate_tx_activity(wmi
->parent_dev
, ev
->traffic_class
, false);
1091 static int ath6kl_wmi_bitrate_reply_rx(struct wmi
*wmi
, u8
*datap
, int len
)
1093 struct wmi_bit_rate_reply
*reply
;
1097 if (len
< sizeof(struct wmi_bit_rate_reply
))
1100 reply
= (struct wmi_bit_rate_reply
*) datap
;
1102 ath6kl_dbg(ATH6KL_DBG_WMI
, "rateindex %d\n", reply
->rate_index
);
1104 if (reply
->rate_index
== (s8
) RATE_AUTO
) {
1107 index
= reply
->rate_index
& 0x7f;
1108 sgi
= (reply
->rate_index
& 0x80) ? 1 : 0;
1109 rate
= wmi_rate_tbl
[index
][sgi
];
1112 ath6kl_wakeup_event(wmi
->parent_dev
);
1117 static int ath6kl_wmi_tcmd_test_report_rx(struct wmi
*wmi
, u8
*datap
, int len
)
1119 ath6kl_tm_rx_report_event(wmi
->parent_dev
, datap
, len
);
1124 static int ath6kl_wmi_ratemask_reply_rx(struct wmi
*wmi
, u8
*datap
, int len
)
1126 if (len
< sizeof(struct wmi_fix_rates_reply
))
1129 ath6kl_wakeup_event(wmi
->parent_dev
);
1134 static int ath6kl_wmi_ch_list_reply_rx(struct wmi
*wmi
, u8
*datap
, int len
)
1136 if (len
< sizeof(struct wmi_channel_list_reply
))
1139 ath6kl_wakeup_event(wmi
->parent_dev
);
1144 static int ath6kl_wmi_tx_pwr_reply_rx(struct wmi
*wmi
, u8
*datap
, int len
)
1146 struct wmi_tx_pwr_reply
*reply
;
1148 if (len
< sizeof(struct wmi_tx_pwr_reply
))
1151 reply
= (struct wmi_tx_pwr_reply
*) datap
;
1152 ath6kl_txpwr_rx_evt(wmi
->parent_dev
, reply
->dbM
);
1157 static int ath6kl_wmi_keepalive_reply_rx(struct wmi
*wmi
, u8
*datap
, int len
)
1159 if (len
< sizeof(struct wmi_get_keepalive_cmd
))
1162 ath6kl_wakeup_event(wmi
->parent_dev
);
1167 static int ath6kl_wmi_scan_complete_rx(struct wmi
*wmi
, u8
*datap
, int len
,
1168 struct ath6kl_vif
*vif
)
1170 struct wmi_scan_complete_event
*ev
;
1172 ev
= (struct wmi_scan_complete_event
*) datap
;
1174 ath6kl_scan_complete_evt(vif
, a_sle32_to_cpu(ev
->status
));
1175 wmi
->is_probe_ssid
= false;
1180 static int ath6kl_wmi_neighbor_report_event_rx(struct wmi
*wmi
, u8
*datap
,
1181 int len
, struct ath6kl_vif
*vif
)
1183 struct wmi_neighbor_report_event
*ev
;
1186 if (len
< sizeof(*ev
))
1188 ev
= (struct wmi_neighbor_report_event
*) datap
;
1189 if (sizeof(*ev
) + ev
->num_neighbors
* sizeof(struct wmi_neighbor_info
)
1191 ath6kl_dbg(ATH6KL_DBG_WMI
, "truncated neighbor event "
1192 "(num=%d len=%d)\n", ev
->num_neighbors
, len
);
1195 for (i
= 0; i
< ev
->num_neighbors
; i
++) {
1196 ath6kl_dbg(ATH6KL_DBG_WMI
, "neighbor %d/%d - %pM 0x%x\n",
1197 i
+ 1, ev
->num_neighbors
, ev
->neighbor
[i
].bssid
,
1198 ev
->neighbor
[i
].bss_flags
);
1199 cfg80211_pmksa_candidate_notify(vif
->ndev
, i
,
1200 ev
->neighbor
[i
].bssid
,
1201 !!(ev
->neighbor
[i
].bss_flags
&
1202 WMI_PREAUTH_CAPABLE_BSS
),
1210 * Target is reporting a programming error. This is for
1211 * developer aid only. Target only checks a few common violations
1212 * and it is responsibility of host to do all error checking.
1213 * Behavior of target after wmi error event is undefined.
1214 * A reset is recommended.
1216 static int ath6kl_wmi_error_event_rx(struct wmi
*wmi
, u8
*datap
, int len
)
1218 const char *type
= "unknown error";
1219 struct wmi_cmd_error_event
*ev
;
1220 ev
= (struct wmi_cmd_error_event
*) datap
;
1222 switch (ev
->err_code
) {
1224 type
= "invalid parameter";
1227 type
= "invalid state";
1229 case INTERNAL_ERROR
:
1230 type
= "internal error";
1234 ath6kl_dbg(ATH6KL_DBG_WMI
, "programming error, cmd=%d %s\n",
1240 static int ath6kl_wmi_stats_event_rx(struct wmi
*wmi
, u8
*datap
, int len
,
1241 struct ath6kl_vif
*vif
)
1243 ath6kl_tgt_stats_event(vif
, datap
, len
);
1248 static u8
ath6kl_wmi_get_upper_threshold(s16 rssi
,
1249 struct sq_threshold_params
*sq_thresh
,
1253 u8 threshold
= (u8
) sq_thresh
->upper_threshold
[size
- 1];
1255 /* The list is already in sorted order. Get the next lower value */
1256 for (index
= 0; index
< size
; index
++) {
1257 if (rssi
< sq_thresh
->upper_threshold
[index
]) {
1258 threshold
= (u8
) sq_thresh
->upper_threshold
[index
];
1266 static u8
ath6kl_wmi_get_lower_threshold(s16 rssi
,
1267 struct sq_threshold_params
*sq_thresh
,
1271 u8 threshold
= (u8
) sq_thresh
->lower_threshold
[size
- 1];
1273 /* The list is already in sorted order. Get the next lower value */
1274 for (index
= 0; index
< size
; index
++) {
1275 if (rssi
> sq_thresh
->lower_threshold
[index
]) {
1276 threshold
= (u8
) sq_thresh
->lower_threshold
[index
];
1284 static int ath6kl_wmi_send_rssi_threshold_params(struct wmi
*wmi
,
1285 struct wmi_rssi_threshold_params_cmd
*rssi_cmd
)
1287 struct sk_buff
*skb
;
1288 struct wmi_rssi_threshold_params_cmd
*cmd
;
1290 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
1294 cmd
= (struct wmi_rssi_threshold_params_cmd
*) skb
->data
;
1295 memcpy(cmd
, rssi_cmd
, sizeof(struct wmi_rssi_threshold_params_cmd
));
1297 return ath6kl_wmi_cmd_send(wmi
, 0, skb
, WMI_RSSI_THRESHOLD_PARAMS_CMDID
,
1301 static int ath6kl_wmi_rssi_threshold_event_rx(struct wmi
*wmi
, u8
*datap
,
1304 struct wmi_rssi_threshold_event
*reply
;
1305 struct wmi_rssi_threshold_params_cmd cmd
;
1306 struct sq_threshold_params
*sq_thresh
;
1307 enum wmi_rssi_threshold_val new_threshold
;
1308 u8 upper_rssi_threshold
, lower_rssi_threshold
;
1312 if (len
< sizeof(struct wmi_rssi_threshold_event
))
1315 reply
= (struct wmi_rssi_threshold_event
*) datap
;
1316 new_threshold
= (enum wmi_rssi_threshold_val
) reply
->range
;
1317 rssi
= a_sle16_to_cpu(reply
->rssi
);
1319 sq_thresh
= &wmi
->sq_threshld
[SIGNAL_QUALITY_METRICS_RSSI
];
1322 * Identify the threshold breached and communicate that to the app.
1323 * After that install a new set of thresholds based on the signal
1324 * quality reported by the target
1326 if (new_threshold
) {
1327 /* Upper threshold breached */
1328 if (rssi
< sq_thresh
->upper_threshold
[0]) {
1329 ath6kl_dbg(ATH6KL_DBG_WMI
,
1330 "spurious upper rssi threshold event: %d\n",
1332 } else if ((rssi
< sq_thresh
->upper_threshold
[1]) &&
1333 (rssi
>= sq_thresh
->upper_threshold
[0])) {
1334 new_threshold
= WMI_RSSI_THRESHOLD1_ABOVE
;
1335 } else if ((rssi
< sq_thresh
->upper_threshold
[2]) &&
1336 (rssi
>= sq_thresh
->upper_threshold
[1])) {
1337 new_threshold
= WMI_RSSI_THRESHOLD2_ABOVE
;
1338 } else if ((rssi
< sq_thresh
->upper_threshold
[3]) &&
1339 (rssi
>= sq_thresh
->upper_threshold
[2])) {
1340 new_threshold
= WMI_RSSI_THRESHOLD3_ABOVE
;
1341 } else if ((rssi
< sq_thresh
->upper_threshold
[4]) &&
1342 (rssi
>= sq_thresh
->upper_threshold
[3])) {
1343 new_threshold
= WMI_RSSI_THRESHOLD4_ABOVE
;
1344 } else if ((rssi
< sq_thresh
->upper_threshold
[5]) &&
1345 (rssi
>= sq_thresh
->upper_threshold
[4])) {
1346 new_threshold
= WMI_RSSI_THRESHOLD5_ABOVE
;
1347 } else if (rssi
>= sq_thresh
->upper_threshold
[5]) {
1348 new_threshold
= WMI_RSSI_THRESHOLD6_ABOVE
;
1351 /* Lower threshold breached */
1352 if (rssi
> sq_thresh
->lower_threshold
[0]) {
1353 ath6kl_dbg(ATH6KL_DBG_WMI
,
1354 "spurious lower rssi threshold event: %d %d\n",
1355 rssi
, sq_thresh
->lower_threshold
[0]);
1356 } else if ((rssi
> sq_thresh
->lower_threshold
[1]) &&
1357 (rssi
<= sq_thresh
->lower_threshold
[0])) {
1358 new_threshold
= WMI_RSSI_THRESHOLD6_BELOW
;
1359 } else if ((rssi
> sq_thresh
->lower_threshold
[2]) &&
1360 (rssi
<= sq_thresh
->lower_threshold
[1])) {
1361 new_threshold
= WMI_RSSI_THRESHOLD5_BELOW
;
1362 } else if ((rssi
> sq_thresh
->lower_threshold
[3]) &&
1363 (rssi
<= sq_thresh
->lower_threshold
[2])) {
1364 new_threshold
= WMI_RSSI_THRESHOLD4_BELOW
;
1365 } else if ((rssi
> sq_thresh
->lower_threshold
[4]) &&
1366 (rssi
<= sq_thresh
->lower_threshold
[3])) {
1367 new_threshold
= WMI_RSSI_THRESHOLD3_BELOW
;
1368 } else if ((rssi
> sq_thresh
->lower_threshold
[5]) &&
1369 (rssi
<= sq_thresh
->lower_threshold
[4])) {
1370 new_threshold
= WMI_RSSI_THRESHOLD2_BELOW
;
1371 } else if (rssi
<= sq_thresh
->lower_threshold
[5]) {
1372 new_threshold
= WMI_RSSI_THRESHOLD1_BELOW
;
1376 /* Calculate and install the next set of thresholds */
1377 lower_rssi_threshold
= ath6kl_wmi_get_lower_threshold(rssi
, sq_thresh
,
1378 sq_thresh
->lower_threshold_valid_count
);
1379 upper_rssi_threshold
= ath6kl_wmi_get_upper_threshold(rssi
, sq_thresh
,
1380 sq_thresh
->upper_threshold_valid_count
);
1382 /* Issue a wmi command to install the thresholds */
1383 cmd
.thresh_above1_val
= a_cpu_to_sle16(upper_rssi_threshold
);
1384 cmd
.thresh_below1_val
= a_cpu_to_sle16(lower_rssi_threshold
);
1385 cmd
.weight
= sq_thresh
->weight
;
1386 cmd
.poll_time
= cpu_to_le32(sq_thresh
->polling_interval
);
1388 ret
= ath6kl_wmi_send_rssi_threshold_params(wmi
, &cmd
);
1390 ath6kl_err("unable to configure rssi thresholds\n");
1397 static int ath6kl_wmi_cac_event_rx(struct wmi
*wmi
, u8
*datap
, int len
,
1398 struct ath6kl_vif
*vif
)
1400 struct wmi_cac_event
*reply
;
1401 struct ieee80211_tspec_ie
*ts
;
1402 u16 active_tsids
, tsinfo
;
1406 if (len
< sizeof(struct wmi_cac_event
))
1409 reply
= (struct wmi_cac_event
*) datap
;
1411 if ((reply
->cac_indication
== CAC_INDICATION_ADMISSION_RESP
) &&
1412 (reply
->status_code
!= IEEE80211_TSPEC_STATUS_ADMISS_ACCEPTED
)) {
1414 ts
= (struct ieee80211_tspec_ie
*) &(reply
->tspec_suggestion
);
1415 tsinfo
= le16_to_cpu(ts
->tsinfo
);
1416 tsid
= (tsinfo
>> IEEE80211_WMM_IE_TSPEC_TID_SHIFT
) &
1417 IEEE80211_WMM_IE_TSPEC_TID_MASK
;
1419 ath6kl_wmi_delete_pstream_cmd(wmi
, vif
->fw_vif_idx
,
1421 } else if (reply
->cac_indication
== CAC_INDICATION_NO_RESP
) {
1423 * Following assumes that there is only one outstanding
1424 * ADDTS request when this event is received
1426 spin_lock_bh(&wmi
->lock
);
1427 active_tsids
= wmi
->stream_exist_for_ac
[reply
->ac
];
1428 spin_unlock_bh(&wmi
->lock
);
1430 for (index
= 0; index
< sizeof(active_tsids
) * 8; index
++) {
1431 if ((active_tsids
>> index
) & 1)
1434 if (index
< (sizeof(active_tsids
) * 8))
1435 ath6kl_wmi_delete_pstream_cmd(wmi
, vif
->fw_vif_idx
,
1440 * Clear active tsids and Add missing handling
1441 * for delete qos stream from AP
1443 else if (reply
->cac_indication
== CAC_INDICATION_DELETE
) {
1445 ts
= (struct ieee80211_tspec_ie
*) &(reply
->tspec_suggestion
);
1446 tsinfo
= le16_to_cpu(ts
->tsinfo
);
1447 ts_id
= ((tsinfo
>> IEEE80211_WMM_IE_TSPEC_TID_SHIFT
) &
1448 IEEE80211_WMM_IE_TSPEC_TID_MASK
);
1450 spin_lock_bh(&wmi
->lock
);
1451 wmi
->stream_exist_for_ac
[reply
->ac
] &= ~(1 << ts_id
);
1452 active_tsids
= wmi
->stream_exist_for_ac
[reply
->ac
];
1453 spin_unlock_bh(&wmi
->lock
);
1455 /* Indicate stream inactivity to driver layer only if all tsids
1456 * within this AC are deleted.
1458 if (!active_tsids
) {
1459 ath6kl_indicate_tx_activity(wmi
->parent_dev
, reply
->ac
,
1461 wmi
->fat_pipe_exist
&= ~(1 << reply
->ac
);
1468 static int ath6kl_wmi_send_snr_threshold_params(struct wmi
*wmi
,
1469 struct wmi_snr_threshold_params_cmd
*snr_cmd
)
1471 struct sk_buff
*skb
;
1472 struct wmi_snr_threshold_params_cmd
*cmd
;
1474 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
1478 cmd
= (struct wmi_snr_threshold_params_cmd
*) skb
->data
;
1479 memcpy(cmd
, snr_cmd
, sizeof(struct wmi_snr_threshold_params_cmd
));
1481 return ath6kl_wmi_cmd_send(wmi
, 0, skb
, WMI_SNR_THRESHOLD_PARAMS_CMDID
,
1485 static int ath6kl_wmi_snr_threshold_event_rx(struct wmi
*wmi
, u8
*datap
,
1488 struct wmi_snr_threshold_event
*reply
;
1489 struct sq_threshold_params
*sq_thresh
;
1490 struct wmi_snr_threshold_params_cmd cmd
;
1491 enum wmi_snr_threshold_val new_threshold
;
1492 u8 upper_snr_threshold
, lower_snr_threshold
;
1496 if (len
< sizeof(struct wmi_snr_threshold_event
))
1499 reply
= (struct wmi_snr_threshold_event
*) datap
;
1501 new_threshold
= (enum wmi_snr_threshold_val
) reply
->range
;
1504 sq_thresh
= &wmi
->sq_threshld
[SIGNAL_QUALITY_METRICS_SNR
];
1507 * Identify the threshold breached and communicate that to the app.
1508 * After that install a new set of thresholds based on the signal
1509 * quality reported by the target.
1511 if (new_threshold
) {
1512 /* Upper threshold breached */
1513 if (snr
< sq_thresh
->upper_threshold
[0]) {
1514 ath6kl_dbg(ATH6KL_DBG_WMI
,
1515 "spurious upper snr threshold event: %d\n",
1517 } else if ((snr
< sq_thresh
->upper_threshold
[1]) &&
1518 (snr
>= sq_thresh
->upper_threshold
[0])) {
1519 new_threshold
= WMI_SNR_THRESHOLD1_ABOVE
;
1520 } else if ((snr
< sq_thresh
->upper_threshold
[2]) &&
1521 (snr
>= sq_thresh
->upper_threshold
[1])) {
1522 new_threshold
= WMI_SNR_THRESHOLD2_ABOVE
;
1523 } else if ((snr
< sq_thresh
->upper_threshold
[3]) &&
1524 (snr
>= sq_thresh
->upper_threshold
[2])) {
1525 new_threshold
= WMI_SNR_THRESHOLD3_ABOVE
;
1526 } else if (snr
>= sq_thresh
->upper_threshold
[3]) {
1527 new_threshold
= WMI_SNR_THRESHOLD4_ABOVE
;
1530 /* Lower threshold breached */
1531 if (snr
> sq_thresh
->lower_threshold
[0]) {
1532 ath6kl_dbg(ATH6KL_DBG_WMI
,
1533 "spurious lower snr threshold event: %d\n",
1534 sq_thresh
->lower_threshold
[0]);
1535 } else if ((snr
> sq_thresh
->lower_threshold
[1]) &&
1536 (snr
<= sq_thresh
->lower_threshold
[0])) {
1537 new_threshold
= WMI_SNR_THRESHOLD4_BELOW
;
1538 } else if ((snr
> sq_thresh
->lower_threshold
[2]) &&
1539 (snr
<= sq_thresh
->lower_threshold
[1])) {
1540 new_threshold
= WMI_SNR_THRESHOLD3_BELOW
;
1541 } else if ((snr
> sq_thresh
->lower_threshold
[3]) &&
1542 (snr
<= sq_thresh
->lower_threshold
[2])) {
1543 new_threshold
= WMI_SNR_THRESHOLD2_BELOW
;
1544 } else if (snr
<= sq_thresh
->lower_threshold
[3]) {
1545 new_threshold
= WMI_SNR_THRESHOLD1_BELOW
;
1549 /* Calculate and install the next set of thresholds */
1550 lower_snr_threshold
= ath6kl_wmi_get_lower_threshold(snr
, sq_thresh
,
1551 sq_thresh
->lower_threshold_valid_count
);
1552 upper_snr_threshold
= ath6kl_wmi_get_upper_threshold(snr
, sq_thresh
,
1553 sq_thresh
->upper_threshold_valid_count
);
1555 /* Issue a wmi command to install the thresholds */
1556 cmd
.thresh_above1_val
= upper_snr_threshold
;
1557 cmd
.thresh_below1_val
= lower_snr_threshold
;
1558 cmd
.weight
= sq_thresh
->weight
;
1559 cmd
.poll_time
= cpu_to_le32(sq_thresh
->polling_interval
);
1561 ath6kl_dbg(ATH6KL_DBG_WMI
,
1562 "snr: %d, threshold: %d, lower: %d, upper: %d\n",
1564 lower_snr_threshold
, upper_snr_threshold
);
1566 ret
= ath6kl_wmi_send_snr_threshold_params(wmi
, &cmd
);
1568 ath6kl_err("unable to configure snr threshold\n");
1575 static int ath6kl_wmi_aplist_event_rx(struct wmi
*wmi
, u8
*datap
, int len
)
1577 u16 ap_info_entry_size
;
1578 struct wmi_aplist_event
*ev
= (struct wmi_aplist_event
*) datap
;
1579 struct wmi_ap_info_v1
*ap_info_v1
;
1582 if (len
< sizeof(struct wmi_aplist_event
) ||
1583 ev
->ap_list_ver
!= APLIST_VER1
)
1586 ap_info_entry_size
= sizeof(struct wmi_ap_info_v1
);
1587 ap_info_v1
= (struct wmi_ap_info_v1
*) ev
->ap_list
;
1589 ath6kl_dbg(ATH6KL_DBG_WMI
,
1590 "number of APs in aplist event: %d\n", ev
->num_ap
);
1592 if (len
< (int) (sizeof(struct wmi_aplist_event
) +
1593 (ev
->num_ap
- 1) * ap_info_entry_size
))
1596 /* AP list version 1 contents */
1597 for (index
= 0; index
< ev
->num_ap
; index
++) {
1598 ath6kl_dbg(ATH6KL_DBG_WMI
, "AP#%d BSSID %pM Channel %d\n",
1599 index
, ap_info_v1
->bssid
, ap_info_v1
->channel
);
1606 int ath6kl_wmi_cmd_send(struct wmi
*wmi
, u8 if_idx
, struct sk_buff
*skb
,
1607 enum wmi_cmd_id cmd_id
, enum wmi_sync_flag sync_flag
)
1609 struct wmi_cmd_hdr
*cmd_hdr
;
1610 enum htc_endpoint_id ep_id
= wmi
->ep_id
;
1614 if (WARN_ON(skb
== NULL
|| (if_idx
> (MAX_NUM_VIF
- 1))))
1617 ath6kl_dbg(ATH6KL_DBG_WMI
, "wmi tx id %d len %d flag %d\n",
1618 cmd_id
, skb
->len
, sync_flag
);
1619 ath6kl_dbg_dump(ATH6KL_DBG_WMI_DUMP
, NULL
, "wmi tx ",
1620 skb
->data
, skb
->len
);
1622 if (sync_flag
>= END_WMIFLAG
) {
1627 if ((sync_flag
== SYNC_BEFORE_WMIFLAG
) ||
1628 (sync_flag
== SYNC_BOTH_WMIFLAG
)) {
1630 * Make sure all data currently queued is transmitted before
1631 * the cmd execution. Establish a new sync point.
1633 ath6kl_wmi_sync_point(wmi
, if_idx
);
1636 skb_push(skb
, sizeof(struct wmi_cmd_hdr
));
1638 cmd_hdr
= (struct wmi_cmd_hdr
*) skb
->data
;
1639 cmd_hdr
->cmd_id
= cpu_to_le16(cmd_id
);
1640 info1
= if_idx
& WMI_CMD_HDR_IF_ID_MASK
;
1641 cmd_hdr
->info1
= cpu_to_le16(info1
);
1643 /* Only for OPT_TX_CMD, use BE endpoint. */
1644 if (cmd_id
== WMI_OPT_TX_FRAME_CMDID
) {
1645 ret
= ath6kl_wmi_data_hdr_add(wmi
, skb
, OPT_MSGTYPE
,
1646 false, false, 0, NULL
, if_idx
);
1651 ep_id
= ath6kl_ac2_endpoint_id(wmi
->parent_dev
, WMM_AC_BE
);
1654 ath6kl_control_tx(wmi
->parent_dev
, skb
, ep_id
);
1656 if ((sync_flag
== SYNC_AFTER_WMIFLAG
) ||
1657 (sync_flag
== SYNC_BOTH_WMIFLAG
)) {
1659 * Make sure all new data queued waits for the command to
1660 * execute. Establish a new sync point.
1662 ath6kl_wmi_sync_point(wmi
, if_idx
);
1668 int ath6kl_wmi_connect_cmd(struct wmi
*wmi
, u8 if_idx
,
1669 enum network_type nw_type
,
1670 enum dot11_auth_mode dot11_auth_mode
,
1671 enum auth_mode auth_mode
,
1672 enum crypto_type pairwise_crypto
,
1673 u8 pairwise_crypto_len
,
1674 enum crypto_type group_crypto
,
1675 u8 group_crypto_len
, int ssid_len
, u8
*ssid
,
1676 u8
*bssid
, u16 channel
, u32 ctrl_flags
)
1678 struct sk_buff
*skb
;
1679 struct wmi_connect_cmd
*cc
;
1682 ath6kl_dbg(ATH6KL_DBG_WMI
,
1683 "wmi connect bssid %pM freq %d flags 0x%x ssid_len %d "
1684 "type %d dot11_auth %d auth %d pairwise %d group %d\n",
1685 bssid
, channel
, ctrl_flags
, ssid_len
, nw_type
,
1686 dot11_auth_mode
, auth_mode
, pairwise_crypto
, group_crypto
);
1687 ath6kl_dbg_dump(ATH6KL_DBG_WMI
, NULL
, "ssid ", ssid
, ssid_len
);
1689 wmi
->traffic_class
= 100;
1691 if ((pairwise_crypto
== NONE_CRYPT
) && (group_crypto
!= NONE_CRYPT
))
1694 if ((pairwise_crypto
!= NONE_CRYPT
) && (group_crypto
== NONE_CRYPT
))
1697 skb
= ath6kl_wmi_get_new_buf(sizeof(struct wmi_connect_cmd
));
1701 cc
= (struct wmi_connect_cmd
*) skb
->data
;
1704 memcpy(cc
->ssid
, ssid
, ssid_len
);
1706 cc
->ssid_len
= ssid_len
;
1707 cc
->nw_type
= nw_type
;
1708 cc
->dot11_auth_mode
= dot11_auth_mode
;
1709 cc
->auth_mode
= auth_mode
;
1710 cc
->prwise_crypto_type
= pairwise_crypto
;
1711 cc
->prwise_crypto_len
= pairwise_crypto_len
;
1712 cc
->grp_crypto_type
= group_crypto
;
1713 cc
->grp_crypto_len
= group_crypto_len
;
1714 cc
->ch
= cpu_to_le16(channel
);
1715 cc
->ctrl_flags
= cpu_to_le32(ctrl_flags
);
1718 memcpy(cc
->bssid
, bssid
, ETH_ALEN
);
1720 ret
= ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_CONNECT_CMDID
,
1726 int ath6kl_wmi_reconnect_cmd(struct wmi
*wmi
, u8 if_idx
, u8
*bssid
,
1729 struct sk_buff
*skb
;
1730 struct wmi_reconnect_cmd
*cc
;
1733 ath6kl_dbg(ATH6KL_DBG_WMI
, "wmi reconnect bssid %pM freq %d\n",
1736 wmi
->traffic_class
= 100;
1738 skb
= ath6kl_wmi_get_new_buf(sizeof(struct wmi_reconnect_cmd
));
1742 cc
= (struct wmi_reconnect_cmd
*) skb
->data
;
1743 cc
->channel
= cpu_to_le16(channel
);
1746 memcpy(cc
->bssid
, bssid
, ETH_ALEN
);
1748 ret
= ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_RECONNECT_CMDID
,
1754 int ath6kl_wmi_disconnect_cmd(struct wmi
*wmi
, u8 if_idx
)
1758 ath6kl_dbg(ATH6KL_DBG_WMI
, "wmi disconnect\n");
1760 wmi
->traffic_class
= 100;
1762 /* Disconnect command does not need to do a SYNC before. */
1763 ret
= ath6kl_wmi_simple_cmd(wmi
, if_idx
, WMI_DISCONNECT_CMDID
);
1768 int ath6kl_wmi_startscan_cmd(struct wmi
*wmi
, u8 if_idx
,
1769 enum wmi_scan_type scan_type
,
1770 u32 force_fgscan
, u32 is_legacy
,
1771 u32 home_dwell_time
, u32 force_scan_interval
,
1772 s8 num_chan
, u16
*ch_list
)
1774 struct sk_buff
*skb
;
1775 struct wmi_start_scan_cmd
*sc
;
1779 size
= sizeof(struct wmi_start_scan_cmd
);
1781 if ((scan_type
!= WMI_LONG_SCAN
) && (scan_type
!= WMI_SHORT_SCAN
))
1784 if (num_chan
> WMI_MAX_CHANNELS
)
1788 size
+= sizeof(u16
) * (num_chan
- 1);
1790 skb
= ath6kl_wmi_get_new_buf(size
);
1794 sc
= (struct wmi_start_scan_cmd
*) skb
->data
;
1795 sc
->scan_type
= scan_type
;
1796 sc
->force_fg_scan
= cpu_to_le32(force_fgscan
);
1797 sc
->is_legacy
= cpu_to_le32(is_legacy
);
1798 sc
->home_dwell_time
= cpu_to_le32(home_dwell_time
);
1799 sc
->force_scan_intvl
= cpu_to_le32(force_scan_interval
);
1800 sc
->num_ch
= num_chan
;
1802 for (i
= 0; i
< num_chan
; i
++)
1803 sc
->ch_list
[i
] = cpu_to_le16(ch_list
[i
]);
1805 ret
= ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_START_SCAN_CMDID
,
1811 int ath6kl_wmi_scanparams_cmd(struct wmi
*wmi
, u8 if_idx
,
1813 u16 fg_end_sec
, u16 bg_sec
,
1814 u16 minact_chdw_msec
, u16 maxact_chdw_msec
,
1815 u16 pas_chdw_msec
, u8 short_scan_ratio
,
1816 u8 scan_ctrl_flag
, u32 max_dfsch_act_time
,
1817 u16 maxact_scan_per_ssid
)
1819 struct sk_buff
*skb
;
1820 struct wmi_scan_params_cmd
*sc
;
1823 skb
= ath6kl_wmi_get_new_buf(sizeof(*sc
));
1827 sc
= (struct wmi_scan_params_cmd
*) skb
->data
;
1828 sc
->fg_start_period
= cpu_to_le16(fg_start_sec
);
1829 sc
->fg_end_period
= cpu_to_le16(fg_end_sec
);
1830 sc
->bg_period
= cpu_to_le16(bg_sec
);
1831 sc
->minact_chdwell_time
= cpu_to_le16(minact_chdw_msec
);
1832 sc
->maxact_chdwell_time
= cpu_to_le16(maxact_chdw_msec
);
1833 sc
->pas_chdwell_time
= cpu_to_le16(pas_chdw_msec
);
1834 sc
->short_scan_ratio
= short_scan_ratio
;
1835 sc
->scan_ctrl_flags
= scan_ctrl_flag
;
1836 sc
->max_dfsch_act_time
= cpu_to_le32(max_dfsch_act_time
);
1837 sc
->maxact_scan_per_ssid
= cpu_to_le16(maxact_scan_per_ssid
);
1839 ret
= ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_SET_SCAN_PARAMS_CMDID
,
1844 int ath6kl_wmi_bssfilter_cmd(struct wmi
*wmi
, u8 if_idx
, u8 filter
, u32 ie_mask
)
1846 struct sk_buff
*skb
;
1847 struct wmi_bss_filter_cmd
*cmd
;
1850 if (filter
>= LAST_BSS_FILTER
)
1853 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
1857 cmd
= (struct wmi_bss_filter_cmd
*) skb
->data
;
1858 cmd
->bss_filter
= filter
;
1859 cmd
->ie_mask
= cpu_to_le32(ie_mask
);
1861 ret
= ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_SET_BSS_FILTER_CMDID
,
1866 int ath6kl_wmi_probedssid_cmd(struct wmi
*wmi
, u8 if_idx
, u8 index
, u8 flag
,
1867 u8 ssid_len
, u8
*ssid
)
1869 struct sk_buff
*skb
;
1870 struct wmi_probed_ssid_cmd
*cmd
;
1873 if (index
> MAX_PROBED_SSID_INDEX
)
1876 if (ssid_len
> sizeof(cmd
->ssid
))
1879 if ((flag
& (DISABLE_SSID_FLAG
| ANY_SSID_FLAG
)) && (ssid_len
> 0))
1882 if ((flag
& SPECIFIC_SSID_FLAG
) && !ssid_len
)
1885 if (flag
& SPECIFIC_SSID_FLAG
)
1886 wmi
->is_probe_ssid
= true;
1888 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
1892 cmd
= (struct wmi_probed_ssid_cmd
*) skb
->data
;
1893 cmd
->entry_index
= index
;
1895 cmd
->ssid_len
= ssid_len
;
1896 memcpy(cmd
->ssid
, ssid
, ssid_len
);
1898 ret
= ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_SET_PROBED_SSID_CMDID
,
1903 int ath6kl_wmi_listeninterval_cmd(struct wmi
*wmi
, u8 if_idx
,
1904 u16 listen_interval
,
1907 struct sk_buff
*skb
;
1908 struct wmi_listen_int_cmd
*cmd
;
1911 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
1915 cmd
= (struct wmi_listen_int_cmd
*) skb
->data
;
1916 cmd
->listen_intvl
= cpu_to_le16(listen_interval
);
1917 cmd
->num_beacons
= cpu_to_le16(listen_beacons
);
1919 ret
= ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_SET_LISTEN_INT_CMDID
,
1924 int ath6kl_wmi_powermode_cmd(struct wmi
*wmi
, u8 if_idx
, u8 pwr_mode
)
1926 struct sk_buff
*skb
;
1927 struct wmi_power_mode_cmd
*cmd
;
1930 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
1934 cmd
= (struct wmi_power_mode_cmd
*) skb
->data
;
1935 cmd
->pwr_mode
= pwr_mode
;
1936 wmi
->pwr_mode
= pwr_mode
;
1938 ret
= ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_SET_POWER_MODE_CMDID
,
1943 int ath6kl_wmi_pmparams_cmd(struct wmi
*wmi
, u8 if_idx
, u16 idle_period
,
1944 u16 ps_poll_num
, u16 dtim_policy
,
1945 u16 tx_wakeup_policy
, u16 num_tx_to_wakeup
,
1946 u16 ps_fail_event_policy
)
1948 struct sk_buff
*skb
;
1949 struct wmi_power_params_cmd
*pm
;
1952 skb
= ath6kl_wmi_get_new_buf(sizeof(*pm
));
1956 pm
= (struct wmi_power_params_cmd
*)skb
->data
;
1957 pm
->idle_period
= cpu_to_le16(idle_period
);
1958 pm
->pspoll_number
= cpu_to_le16(ps_poll_num
);
1959 pm
->dtim_policy
= cpu_to_le16(dtim_policy
);
1960 pm
->tx_wakeup_policy
= cpu_to_le16(tx_wakeup_policy
);
1961 pm
->num_tx_to_wakeup
= cpu_to_le16(num_tx_to_wakeup
);
1962 pm
->ps_fail_event_policy
= cpu_to_le16(ps_fail_event_policy
);
1964 ret
= ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_SET_POWER_PARAMS_CMDID
,
1969 int ath6kl_wmi_disctimeout_cmd(struct wmi
*wmi
, u8 if_idx
, u8 timeout
)
1971 struct sk_buff
*skb
;
1972 struct wmi_disc_timeout_cmd
*cmd
;
1975 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
1979 cmd
= (struct wmi_disc_timeout_cmd
*) skb
->data
;
1980 cmd
->discon_timeout
= timeout
;
1982 ret
= ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_SET_DISC_TIMEOUT_CMDID
,
1986 ath6kl_debug_set_disconnect_timeout(wmi
->parent_dev
, timeout
);
1991 int ath6kl_wmi_addkey_cmd(struct wmi
*wmi
, u8 if_idx
, u8 key_index
,
1992 enum crypto_type key_type
,
1993 u8 key_usage
, u8 key_len
,
1994 u8
*key_rsc
, u8
*key_material
,
1995 u8 key_op_ctrl
, u8
*mac_addr
,
1996 enum wmi_sync_flag sync_flag
)
1998 struct sk_buff
*skb
;
1999 struct wmi_add_cipher_key_cmd
*cmd
;
2002 ath6kl_dbg(ATH6KL_DBG_WMI
, "addkey cmd: key_index=%u key_type=%d "
2003 "key_usage=%d key_len=%d key_op_ctrl=%d\n",
2004 key_index
, key_type
, key_usage
, key_len
, key_op_ctrl
);
2006 if ((key_index
> WMI_MAX_KEY_INDEX
) || (key_len
> WMI_MAX_KEY_LEN
) ||
2007 (key_material
== NULL
))
2010 if ((WEP_CRYPT
!= key_type
) && (NULL
== key_rsc
))
2013 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
2017 cmd
= (struct wmi_add_cipher_key_cmd
*) skb
->data
;
2018 cmd
->key_index
= key_index
;
2019 cmd
->key_type
= key_type
;
2020 cmd
->key_usage
= key_usage
;
2021 cmd
->key_len
= key_len
;
2022 memcpy(cmd
->key
, key_material
, key_len
);
2024 if (key_rsc
!= NULL
)
2025 memcpy(cmd
->key_rsc
, key_rsc
, sizeof(cmd
->key_rsc
));
2027 cmd
->key_op_ctrl
= key_op_ctrl
;
2030 memcpy(cmd
->key_mac_addr
, mac_addr
, ETH_ALEN
);
2032 ret
= ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_ADD_CIPHER_KEY_CMDID
,
2038 int ath6kl_wmi_add_krk_cmd(struct wmi
*wmi
, u8 if_idx
, u8
*krk
)
2040 struct sk_buff
*skb
;
2041 struct wmi_add_krk_cmd
*cmd
;
2044 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
2048 cmd
= (struct wmi_add_krk_cmd
*) skb
->data
;
2049 memcpy(cmd
->krk
, krk
, WMI_KRK_LEN
);
2051 ret
= ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_ADD_KRK_CMDID
,
2057 int ath6kl_wmi_deletekey_cmd(struct wmi
*wmi
, u8 if_idx
, u8 key_index
)
2059 struct sk_buff
*skb
;
2060 struct wmi_delete_cipher_key_cmd
*cmd
;
2063 if (key_index
> WMI_MAX_KEY_INDEX
)
2066 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
2070 cmd
= (struct wmi_delete_cipher_key_cmd
*) skb
->data
;
2071 cmd
->key_index
= key_index
;
2073 ret
= ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_DELETE_CIPHER_KEY_CMDID
,
2079 int ath6kl_wmi_setpmkid_cmd(struct wmi
*wmi
, u8 if_idx
, const u8
*bssid
,
2080 const u8
*pmkid
, bool set
)
2082 struct sk_buff
*skb
;
2083 struct wmi_setpmkid_cmd
*cmd
;
2089 if (set
&& pmkid
== NULL
)
2092 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
2096 cmd
= (struct wmi_setpmkid_cmd
*) skb
->data
;
2097 memcpy(cmd
->bssid
, bssid
, ETH_ALEN
);
2099 memcpy(cmd
->pmkid
, pmkid
, sizeof(cmd
->pmkid
));
2100 cmd
->enable
= PMKID_ENABLE
;
2102 memset(cmd
->pmkid
, 0, sizeof(cmd
->pmkid
));
2103 cmd
->enable
= PMKID_DISABLE
;
2106 ret
= ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_SET_PMKID_CMDID
,
2112 static int ath6kl_wmi_data_sync_send(struct wmi
*wmi
, struct sk_buff
*skb
,
2113 enum htc_endpoint_id ep_id
, u8 if_idx
)
2115 struct wmi_data_hdr
*data_hdr
;
2118 if (WARN_ON(skb
== NULL
|| ep_id
== wmi
->ep_id
))
2121 skb_push(skb
, sizeof(struct wmi_data_hdr
));
2123 data_hdr
= (struct wmi_data_hdr
*) skb
->data
;
2124 data_hdr
->info
= SYNC_MSGTYPE
<< WMI_DATA_HDR_MSG_TYPE_SHIFT
;
2125 data_hdr
->info3
= cpu_to_le16(if_idx
& WMI_DATA_HDR_IF_IDX_MASK
);
2127 ret
= ath6kl_control_tx(wmi
->parent_dev
, skb
, ep_id
);
2132 static int ath6kl_wmi_sync_point(struct wmi
*wmi
, u8 if_idx
)
2134 struct sk_buff
*skb
;
2135 struct wmi_sync_cmd
*cmd
;
2136 struct wmi_data_sync_bufs data_sync_bufs
[WMM_NUM_AC
];
2137 enum htc_endpoint_id ep_id
;
2138 u8 index
, num_pri_streams
= 0;
2141 memset(data_sync_bufs
, 0, sizeof(data_sync_bufs
));
2143 spin_lock_bh(&wmi
->lock
);
2145 for (index
= 0; index
< WMM_NUM_AC
; index
++) {
2146 if (wmi
->fat_pipe_exist
& (1 << index
)) {
2148 data_sync_bufs
[num_pri_streams
- 1].traffic_class
=
2153 spin_unlock_bh(&wmi
->lock
);
2155 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
2161 cmd
= (struct wmi_sync_cmd
*) skb
->data
;
2164 * In the SYNC cmd sent on the control Ep, send a bitmap
2165 * of the data eps on which the Data Sync will be sent
2167 cmd
->data_sync_map
= wmi
->fat_pipe_exist
;
2169 for (index
= 0; index
< num_pri_streams
; index
++) {
2170 data_sync_bufs
[index
].skb
= ath6kl_buf_alloc(0);
2171 if (data_sync_bufs
[index
].skb
== NULL
) {
2178 * If buffer allocation for any of the dataSync fails,
2179 * then do not send the Synchronize cmd on the control ep
2185 * Send sync cmd followed by sync data messages on all
2186 * endpoints being used
2188 ret
= ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_SYNCHRONIZE_CMDID
,
2194 /* cmd buffer sent, we no longer own it */
2197 for (index
= 0; index
< num_pri_streams
; index
++) {
2199 if (WARN_ON(!data_sync_bufs
[index
].skb
))
2202 ep_id
= ath6kl_ac2_endpoint_id(wmi
->parent_dev
,
2203 data_sync_bufs
[index
].
2206 ath6kl_wmi_data_sync_send(wmi
, data_sync_bufs
[index
].skb
,
2212 data_sync_bufs
[index
].skb
= NULL
;
2216 /* free up any resources left over (possibly due to an error) */
2220 for (index
= 0; index
< num_pri_streams
; index
++) {
2221 if (data_sync_bufs
[index
].skb
!= NULL
) {
2222 dev_kfree_skb((struct sk_buff
*)data_sync_bufs
[index
].
2230 int ath6kl_wmi_create_pstream_cmd(struct wmi
*wmi
, u8 if_idx
,
2231 struct wmi_create_pstream_cmd
*params
)
2233 struct sk_buff
*skb
;
2234 struct wmi_create_pstream_cmd
*cmd
;
2235 u8 fatpipe_exist_for_ac
= 0;
2237 s32 nominal_phy
= 0;
2240 if (!((params
->user_pri
< 8) &&
2241 (params
->user_pri
<= 0x7) &&
2242 (up_to_ac
[params
->user_pri
& 0x7] == params
->traffic_class
) &&
2243 (params
->traffic_direc
== UPLINK_TRAFFIC
||
2244 params
->traffic_direc
== DNLINK_TRAFFIC
||
2245 params
->traffic_direc
== BIDIR_TRAFFIC
) &&
2246 (params
->traffic_type
== TRAFFIC_TYPE_APERIODIC
||
2247 params
->traffic_type
== TRAFFIC_TYPE_PERIODIC
) &&
2248 (params
->voice_psc_cap
== DISABLE_FOR_THIS_AC
||
2249 params
->voice_psc_cap
== ENABLE_FOR_THIS_AC
||
2250 params
->voice_psc_cap
== ENABLE_FOR_ALL_AC
) &&
2251 (params
->tsid
== WMI_IMPLICIT_PSTREAM
||
2252 params
->tsid
<= WMI_MAX_THINSTREAM
))) {
2257 * Check nominal PHY rate is >= minimalPHY,
2258 * so that DUT can allow TSRS IE
2261 /* Get the physical rate (units of bps) */
2262 min_phy
= ((le32_to_cpu(params
->min_phy_rate
) / 1000) / 1000);
2264 /* Check minimal phy < nominal phy rate */
2265 if (params
->nominal_phy
>= min_phy
) {
2266 /* unit of 500 kbps */
2267 nominal_phy
= (params
->nominal_phy
* 1000) / 500;
2268 ath6kl_dbg(ATH6KL_DBG_WMI
,
2269 "TSRS IE enabled::MinPhy %x->NominalPhy ===> %x\n",
2270 min_phy
, nominal_phy
);
2272 params
->nominal_phy
= nominal_phy
;
2274 params
->nominal_phy
= 0;
2277 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
2281 ath6kl_dbg(ATH6KL_DBG_WMI
,
2282 "sending create_pstream_cmd: ac=%d tsid:%d\n",
2283 params
->traffic_class
, params
->tsid
);
2285 cmd
= (struct wmi_create_pstream_cmd
*) skb
->data
;
2286 memcpy(cmd
, params
, sizeof(*cmd
));
2288 /* This is an implicitly created Fat pipe */
2289 if ((u32
) params
->tsid
== (u32
) WMI_IMPLICIT_PSTREAM
) {
2290 spin_lock_bh(&wmi
->lock
);
2291 fatpipe_exist_for_ac
= (wmi
->fat_pipe_exist
&
2292 (1 << params
->traffic_class
));
2293 wmi
->fat_pipe_exist
|= (1 << params
->traffic_class
);
2294 spin_unlock_bh(&wmi
->lock
);
2296 /* explicitly created thin stream within a fat pipe */
2297 spin_lock_bh(&wmi
->lock
);
2298 fatpipe_exist_for_ac
= (wmi
->fat_pipe_exist
&
2299 (1 << params
->traffic_class
));
2300 wmi
->stream_exist_for_ac
[params
->traffic_class
] |=
2301 (1 << params
->tsid
);
2303 * If a thinstream becomes active, the fat pipe automatically
2306 wmi
->fat_pipe_exist
|= (1 << params
->traffic_class
);
2307 spin_unlock_bh(&wmi
->lock
);
2311 * Indicate activty change to driver layer only if this is the
2312 * first TSID to get created in this AC explicitly or an implicit
2313 * fat pipe is getting created.
2315 if (!fatpipe_exist_for_ac
)
2316 ath6kl_indicate_tx_activity(wmi
->parent_dev
,
2317 params
->traffic_class
, true);
2319 ret
= ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_CREATE_PSTREAM_CMDID
,
2324 int ath6kl_wmi_delete_pstream_cmd(struct wmi
*wmi
, u8 if_idx
, u8 traffic_class
,
2327 struct sk_buff
*skb
;
2328 struct wmi_delete_pstream_cmd
*cmd
;
2329 u16 active_tsids
= 0;
2332 if (traffic_class
> 3) {
2333 ath6kl_err("invalid traffic class: %d\n", traffic_class
);
2337 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
2341 cmd
= (struct wmi_delete_pstream_cmd
*) skb
->data
;
2342 cmd
->traffic_class
= traffic_class
;
2345 spin_lock_bh(&wmi
->lock
);
2346 active_tsids
= wmi
->stream_exist_for_ac
[traffic_class
];
2347 spin_unlock_bh(&wmi
->lock
);
2349 if (!(active_tsids
& (1 << tsid
))) {
2351 ath6kl_dbg(ATH6KL_DBG_WMI
,
2352 "TSID %d doesn't exist for traffic class: %d\n",
2353 tsid
, traffic_class
);
2357 ath6kl_dbg(ATH6KL_DBG_WMI
,
2358 "sending delete_pstream_cmd: traffic class: %d tsid=%d\n",
2359 traffic_class
, tsid
);
2361 ret
= ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_DELETE_PSTREAM_CMDID
,
2362 SYNC_BEFORE_WMIFLAG
);
2364 spin_lock_bh(&wmi
->lock
);
2365 wmi
->stream_exist_for_ac
[traffic_class
] &= ~(1 << tsid
);
2366 active_tsids
= wmi
->stream_exist_for_ac
[traffic_class
];
2367 spin_unlock_bh(&wmi
->lock
);
2370 * Indicate stream inactivity to driver layer only if all tsids
2371 * within this AC are deleted.
2373 if (!active_tsids
) {
2374 ath6kl_indicate_tx_activity(wmi
->parent_dev
,
2375 traffic_class
, false);
2376 wmi
->fat_pipe_exist
&= ~(1 << traffic_class
);
2382 int ath6kl_wmi_set_ip_cmd(struct wmi
*wmi
, struct wmi_set_ip_cmd
*ip_cmd
)
2384 struct sk_buff
*skb
;
2385 struct wmi_set_ip_cmd
*cmd
;
2388 /* Multicast address are not valid */
2389 if ((*((u8
*) &ip_cmd
->ips
[0]) >= 0xE0) ||
2390 (*((u8
*) &ip_cmd
->ips
[1]) >= 0xE0))
2393 skb
= ath6kl_wmi_get_new_buf(sizeof(struct wmi_set_ip_cmd
));
2397 cmd
= (struct wmi_set_ip_cmd
*) skb
->data
;
2398 memcpy(cmd
, ip_cmd
, sizeof(struct wmi_set_ip_cmd
));
2400 ret
= ath6kl_wmi_cmd_send(wmi
, 0, skb
, WMI_SET_IP_CMDID
,
2405 static int ath6kl_wmi_get_wow_list_event_rx(struct wmi
*wmi
, u8
* datap
,
2408 if (len
< sizeof(struct wmi_get_wow_list_reply
))
2414 static int ath6kl_wmi_cmd_send_xtnd(struct wmi
*wmi
, struct sk_buff
*skb
,
2415 enum wmix_command_id cmd_id
,
2416 enum wmi_sync_flag sync_flag
)
2418 struct wmix_cmd_hdr
*cmd_hdr
;
2421 skb_push(skb
, sizeof(struct wmix_cmd_hdr
));
2423 cmd_hdr
= (struct wmix_cmd_hdr
*) skb
->data
;
2424 cmd_hdr
->cmd_id
= cpu_to_le32(cmd_id
);
2426 ret
= ath6kl_wmi_cmd_send(wmi
, 0, skb
, WMI_EXTENSION_CMDID
, sync_flag
);
2431 int ath6kl_wmi_get_challenge_resp_cmd(struct wmi
*wmi
, u32 cookie
, u32 source
)
2433 struct sk_buff
*skb
;
2434 struct wmix_hb_challenge_resp_cmd
*cmd
;
2437 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
2441 cmd
= (struct wmix_hb_challenge_resp_cmd
*) skb
->data
;
2442 cmd
->cookie
= cpu_to_le32(cookie
);
2443 cmd
->source
= cpu_to_le32(source
);
2445 ret
= ath6kl_wmi_cmd_send_xtnd(wmi
, skb
, WMIX_HB_CHALLENGE_RESP_CMDID
,
2450 int ath6kl_wmi_config_debug_module_cmd(struct wmi
*wmi
, u32 valid
, u32 config
)
2452 struct ath6kl_wmix_dbglog_cfg_module_cmd
*cmd
;
2453 struct sk_buff
*skb
;
2456 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
2460 cmd
= (struct ath6kl_wmix_dbglog_cfg_module_cmd
*) skb
->data
;
2461 cmd
->valid
= cpu_to_le32(valid
);
2462 cmd
->config
= cpu_to_le32(config
);
2464 ret
= ath6kl_wmi_cmd_send_xtnd(wmi
, skb
, WMIX_DBGLOG_CFG_MODULE_CMDID
,
2469 int ath6kl_wmi_get_stats_cmd(struct wmi
*wmi
, u8 if_idx
)
2471 return ath6kl_wmi_simple_cmd(wmi
, if_idx
, WMI_GET_STATISTICS_CMDID
);
2474 int ath6kl_wmi_set_tx_pwr_cmd(struct wmi
*wmi
, u8 if_idx
, u8 dbM
)
2476 struct sk_buff
*skb
;
2477 struct wmi_set_tx_pwr_cmd
*cmd
;
2480 skb
= ath6kl_wmi_get_new_buf(sizeof(struct wmi_set_tx_pwr_cmd
));
2484 cmd
= (struct wmi_set_tx_pwr_cmd
*) skb
->data
;
2487 ret
= ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_SET_TX_PWR_CMDID
,
2493 int ath6kl_wmi_get_tx_pwr_cmd(struct wmi
*wmi
, u8 if_idx
)
2495 return ath6kl_wmi_simple_cmd(wmi
, if_idx
, WMI_GET_TX_PWR_CMDID
);
2498 int ath6kl_wmi_get_roam_tbl_cmd(struct wmi
*wmi
)
2500 return ath6kl_wmi_simple_cmd(wmi
, 0, WMI_GET_ROAM_TBL_CMDID
);
2503 int ath6kl_wmi_set_lpreamble_cmd(struct wmi
*wmi
, u8 if_idx
, u8 status
,
2506 struct sk_buff
*skb
;
2507 struct wmi_set_lpreamble_cmd
*cmd
;
2510 skb
= ath6kl_wmi_get_new_buf(sizeof(struct wmi_set_lpreamble_cmd
));
2514 cmd
= (struct wmi_set_lpreamble_cmd
*) skb
->data
;
2515 cmd
->status
= status
;
2516 cmd
->preamble_policy
= preamble_policy
;
2518 ret
= ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_SET_LPREAMBLE_CMDID
,
2523 int ath6kl_wmi_set_rts_cmd(struct wmi
*wmi
, u16 threshold
)
2525 struct sk_buff
*skb
;
2526 struct wmi_set_rts_cmd
*cmd
;
2529 skb
= ath6kl_wmi_get_new_buf(sizeof(struct wmi_set_rts_cmd
));
2533 cmd
= (struct wmi_set_rts_cmd
*) skb
->data
;
2534 cmd
->threshold
= cpu_to_le16(threshold
);
2536 ret
= ath6kl_wmi_cmd_send(wmi
, 0, skb
, WMI_SET_RTS_CMDID
,
2541 int ath6kl_wmi_set_wmm_txop(struct wmi
*wmi
, u8 if_idx
, enum wmi_txop_cfg cfg
)
2543 struct sk_buff
*skb
;
2544 struct wmi_set_wmm_txop_cmd
*cmd
;
2547 if (!((cfg
== WMI_TXOP_DISABLED
) || (cfg
== WMI_TXOP_ENABLED
)))
2550 skb
= ath6kl_wmi_get_new_buf(sizeof(struct wmi_set_wmm_txop_cmd
));
2554 cmd
= (struct wmi_set_wmm_txop_cmd
*) skb
->data
;
2555 cmd
->txop_enable
= cfg
;
2557 ret
= ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_SET_WMM_TXOP_CMDID
,
2562 int ath6kl_wmi_set_keepalive_cmd(struct wmi
*wmi
, u8 if_idx
,
2563 u8 keep_alive_intvl
)
2565 struct sk_buff
*skb
;
2566 struct wmi_set_keepalive_cmd
*cmd
;
2569 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
2573 cmd
= (struct wmi_set_keepalive_cmd
*) skb
->data
;
2574 cmd
->keep_alive_intvl
= keep_alive_intvl
;
2576 ret
= ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_SET_KEEPALIVE_CMDID
,
2580 ath6kl_debug_set_keepalive(wmi
->parent_dev
, keep_alive_intvl
);
2585 int ath6kl_wmi_test_cmd(struct wmi
*wmi
, void *buf
, size_t len
)
2587 struct sk_buff
*skb
;
2590 skb
= ath6kl_wmi_get_new_buf(len
);
2594 memcpy(skb
->data
, buf
, len
);
2596 ret
= ath6kl_wmi_cmd_send(wmi
, 0, skb
, WMI_TEST_CMDID
, NO_SYNC_WMIFLAG
);
2602 s32
ath6kl_wmi_get_rate(s8 rate_index
)
2604 if (rate_index
== RATE_AUTO
)
2607 return wmi_rate_tbl
[(u32
) rate_index
][0];
2610 static int ath6kl_wmi_get_pmkid_list_event_rx(struct wmi
*wmi
, u8
*datap
,
2613 struct wmi_pmkid_list_reply
*reply
;
2616 if (len
< sizeof(struct wmi_pmkid_list_reply
))
2619 reply
= (struct wmi_pmkid_list_reply
*)datap
;
2620 expected_len
= sizeof(reply
->num_pmkid
) +
2621 le32_to_cpu(reply
->num_pmkid
) * WMI_PMKID_LEN
;
2623 if (len
< expected_len
)
2629 static int ath6kl_wmi_addba_req_event_rx(struct wmi
*wmi
, u8
*datap
, int len
,
2630 struct ath6kl_vif
*vif
)
2632 struct wmi_addba_req_event
*cmd
= (struct wmi_addba_req_event
*) datap
;
2634 aggr_recv_addba_req_evt(vif
, cmd
->tid
,
2635 le16_to_cpu(cmd
->st_seq_no
), cmd
->win_sz
);
2640 static int ath6kl_wmi_delba_req_event_rx(struct wmi
*wmi
, u8
*datap
, int len
,
2641 struct ath6kl_vif
*vif
)
2643 struct wmi_delba_event
*cmd
= (struct wmi_delba_event
*) datap
;
2645 aggr_recv_delba_req_evt(vif
, cmd
->tid
);
2650 /* AP mode functions */
2652 int ath6kl_wmi_ap_profile_commit(struct wmi
*wmip
, u8 if_idx
,
2653 struct wmi_connect_cmd
*p
)
2655 struct sk_buff
*skb
;
2656 struct wmi_connect_cmd
*cm
;
2659 skb
= ath6kl_wmi_get_new_buf(sizeof(*cm
));
2663 cm
= (struct wmi_connect_cmd
*) skb
->data
;
2664 memcpy(cm
, p
, sizeof(*cm
));
2666 res
= ath6kl_wmi_cmd_send(wmip
, if_idx
, skb
, WMI_AP_CONFIG_COMMIT_CMDID
,
2668 ath6kl_dbg(ATH6KL_DBG_WMI
, "%s: nw_type=%u auth_mode=%u ch=%u "
2669 "ctrl_flags=0x%x-> res=%d\n",
2670 __func__
, p
->nw_type
, p
->auth_mode
, le16_to_cpu(p
->ch
),
2671 le32_to_cpu(p
->ctrl_flags
), res
);
2675 int ath6kl_wmi_ap_set_mlme(struct wmi
*wmip
, u8 if_idx
, u8 cmd
, const u8
*mac
,
2678 struct sk_buff
*skb
;
2679 struct wmi_ap_set_mlme_cmd
*cm
;
2681 skb
= ath6kl_wmi_get_new_buf(sizeof(*cm
));
2685 cm
= (struct wmi_ap_set_mlme_cmd
*) skb
->data
;
2686 memcpy(cm
->mac
, mac
, ETH_ALEN
);
2687 cm
->reason
= cpu_to_le16(reason
);
2690 return ath6kl_wmi_cmd_send(wmip
, if_idx
, skb
, WMI_AP_SET_MLME_CMDID
,
2694 static int ath6kl_wmi_pspoll_event_rx(struct wmi
*wmi
, u8
*datap
, int len
,
2695 struct ath6kl_vif
*vif
)
2697 struct wmi_pspoll_event
*ev
;
2699 if (len
< sizeof(struct wmi_pspoll_event
))
2702 ev
= (struct wmi_pspoll_event
*) datap
;
2704 ath6kl_pspoll_event(vif
, le16_to_cpu(ev
->aid
));
2709 static int ath6kl_wmi_dtimexpiry_event_rx(struct wmi
*wmi
, u8
*datap
, int len
,
2710 struct ath6kl_vif
*vif
)
2712 ath6kl_dtimexpiry_event(vif
);
2717 int ath6kl_wmi_set_pvb_cmd(struct wmi
*wmi
, u8 if_idx
, u16 aid
,
2720 struct sk_buff
*skb
;
2721 struct wmi_ap_set_pvb_cmd
*cmd
;
2724 skb
= ath6kl_wmi_get_new_buf(sizeof(struct wmi_ap_set_pvb_cmd
));
2728 cmd
= (struct wmi_ap_set_pvb_cmd
*) skb
->data
;
2729 cmd
->aid
= cpu_to_le16(aid
);
2730 cmd
->rsvd
= cpu_to_le16(0);
2731 cmd
->flag
= cpu_to_le32(flag
);
2733 ret
= ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_AP_SET_PVB_CMDID
,
2739 int ath6kl_wmi_set_rx_frame_format_cmd(struct wmi
*wmi
, u8 if_idx
,
2741 bool rx_dot11_hdr
, bool defrag_on_host
)
2743 struct sk_buff
*skb
;
2744 struct wmi_rx_frame_format_cmd
*cmd
;
2747 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
2751 cmd
= (struct wmi_rx_frame_format_cmd
*) skb
->data
;
2752 cmd
->dot11_hdr
= rx_dot11_hdr
? 1 : 0;
2753 cmd
->defrag_on_host
= defrag_on_host
? 1 : 0;
2754 cmd
->meta_ver
= rx_meta_ver
;
2756 /* Delete the local aggr state, on host */
2757 ret
= ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_RX_FRAME_FORMAT_CMDID
,
2763 int ath6kl_wmi_set_appie_cmd(struct wmi
*wmi
, u8 if_idx
, u8 mgmt_frm_type
,
2764 const u8
*ie
, u8 ie_len
)
2766 struct sk_buff
*skb
;
2767 struct wmi_set_appie_cmd
*p
;
2769 skb
= ath6kl_wmi_get_new_buf(sizeof(*p
) + ie_len
);
2773 ath6kl_dbg(ATH6KL_DBG_WMI
, "set_appie_cmd: mgmt_frm_type=%u "
2774 "ie_len=%u\n", mgmt_frm_type
, ie_len
);
2775 p
= (struct wmi_set_appie_cmd
*) skb
->data
;
2776 p
->mgmt_frm_type
= mgmt_frm_type
;
2778 memcpy(p
->ie_info
, ie
, ie_len
);
2779 return ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_SET_APPIE_CMDID
,
2783 int ath6kl_wmi_disable_11b_rates_cmd(struct wmi
*wmi
, bool disable
)
2785 struct sk_buff
*skb
;
2786 struct wmi_disable_11b_rates_cmd
*cmd
;
2788 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
2792 ath6kl_dbg(ATH6KL_DBG_WMI
, "disable_11b_rates_cmd: disable=%u\n",
2794 cmd
= (struct wmi_disable_11b_rates_cmd
*) skb
->data
;
2795 cmd
->disable
= disable
? 1 : 0;
2797 return ath6kl_wmi_cmd_send(wmi
, 0, skb
, WMI_DISABLE_11B_RATES_CMDID
,
2801 int ath6kl_wmi_remain_on_chnl_cmd(struct wmi
*wmi
, u8 if_idx
, u32 freq
, u32 dur
)
2803 struct sk_buff
*skb
;
2804 struct wmi_remain_on_chnl_cmd
*p
;
2806 skb
= ath6kl_wmi_get_new_buf(sizeof(*p
));
2810 ath6kl_dbg(ATH6KL_DBG_WMI
, "remain_on_chnl_cmd: freq=%u dur=%u\n",
2812 p
= (struct wmi_remain_on_chnl_cmd
*) skb
->data
;
2813 p
->freq
= cpu_to_le32(freq
);
2814 p
->duration
= cpu_to_le32(dur
);
2815 return ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_REMAIN_ON_CHNL_CMDID
,
2819 int ath6kl_wmi_send_action_cmd(struct wmi
*wmi
, u8 if_idx
, u32 id
, u32 freq
,
2820 u32 wait
, const u8
*data
, u16 data_len
)
2822 struct sk_buff
*skb
;
2823 struct wmi_send_action_cmd
*p
;
2827 return -EINVAL
; /* Offload for wait not supported */
2829 buf
= kmalloc(data_len
, GFP_KERNEL
);
2833 skb
= ath6kl_wmi_get_new_buf(sizeof(*p
) + data_len
);
2839 kfree(wmi
->last_mgmt_tx_frame
);
2840 wmi
->last_mgmt_tx_frame
= buf
;
2841 wmi
->last_mgmt_tx_frame_len
= data_len
;
2843 ath6kl_dbg(ATH6KL_DBG_WMI
, "send_action_cmd: id=%u freq=%u wait=%u "
2844 "len=%u\n", id
, freq
, wait
, data_len
);
2845 p
= (struct wmi_send_action_cmd
*) skb
->data
;
2846 p
->id
= cpu_to_le32(id
);
2847 p
->freq
= cpu_to_le32(freq
);
2848 p
->wait
= cpu_to_le32(wait
);
2849 p
->len
= cpu_to_le16(data_len
);
2850 memcpy(p
->data
, data
, data_len
);
2851 return ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_SEND_ACTION_CMDID
,
2855 int ath6kl_wmi_send_probe_response_cmd(struct wmi
*wmi
, u8 if_idx
, u32 freq
,
2856 const u8
*dst
, const u8
*data
,
2859 struct sk_buff
*skb
;
2860 struct wmi_p2p_probe_response_cmd
*p
;
2862 skb
= ath6kl_wmi_get_new_buf(sizeof(*p
) + data_len
);
2866 ath6kl_dbg(ATH6KL_DBG_WMI
, "send_probe_response_cmd: freq=%u dst=%pM "
2867 "len=%u\n", freq
, dst
, data_len
);
2868 p
= (struct wmi_p2p_probe_response_cmd
*) skb
->data
;
2869 p
->freq
= cpu_to_le32(freq
);
2870 memcpy(p
->destination_addr
, dst
, ETH_ALEN
);
2871 p
->len
= cpu_to_le16(data_len
);
2872 memcpy(p
->data
, data
, data_len
);
2873 return ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
,
2874 WMI_SEND_PROBE_RESPONSE_CMDID
,
2878 int ath6kl_wmi_probe_report_req_cmd(struct wmi
*wmi
, u8 if_idx
, bool enable
)
2880 struct sk_buff
*skb
;
2881 struct wmi_probe_req_report_cmd
*p
;
2883 skb
= ath6kl_wmi_get_new_buf(sizeof(*p
));
2887 ath6kl_dbg(ATH6KL_DBG_WMI
, "probe_report_req_cmd: enable=%u\n",
2889 p
= (struct wmi_probe_req_report_cmd
*) skb
->data
;
2890 p
->enable
= enable
? 1 : 0;
2891 return ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_PROBE_REQ_REPORT_CMDID
,
2895 int ath6kl_wmi_info_req_cmd(struct wmi
*wmi
, u8 if_idx
, u32 info_req_flags
)
2897 struct sk_buff
*skb
;
2898 struct wmi_get_p2p_info
*p
;
2900 skb
= ath6kl_wmi_get_new_buf(sizeof(*p
));
2904 ath6kl_dbg(ATH6KL_DBG_WMI
, "info_req_cmd: flags=%x\n",
2906 p
= (struct wmi_get_p2p_info
*) skb
->data
;
2907 p
->info_req_flags
= cpu_to_le32(info_req_flags
);
2908 return ath6kl_wmi_cmd_send(wmi
, if_idx
, skb
, WMI_GET_P2P_INFO_CMDID
,
2912 int ath6kl_wmi_cancel_remain_on_chnl_cmd(struct wmi
*wmi
, u8 if_idx
)
2914 ath6kl_dbg(ATH6KL_DBG_WMI
, "cancel_remain_on_chnl_cmd\n");
2915 return ath6kl_wmi_simple_cmd(wmi
, if_idx
,
2916 WMI_CANCEL_REMAIN_ON_CHNL_CMDID
);
2919 static int ath6kl_wmi_control_rx_xtnd(struct wmi
*wmi
, struct sk_buff
*skb
)
2921 struct wmix_cmd_hdr
*cmd
;
2927 if (skb
->len
< sizeof(struct wmix_cmd_hdr
)) {
2928 ath6kl_err("bad packet 1\n");
2932 cmd
= (struct wmix_cmd_hdr
*) skb
->data
;
2933 id
= le32_to_cpu(cmd
->cmd_id
);
2935 skb_pull(skb
, sizeof(struct wmix_cmd_hdr
));
2941 case WMIX_HB_CHALLENGE_RESP_EVENTID
:
2942 ath6kl_dbg(ATH6KL_DBG_WMI
, "wmi event hb challenge resp\n");
2944 case WMIX_DBGLOG_EVENTID
:
2945 ath6kl_dbg(ATH6KL_DBG_WMI
, "wmi event dbglog len %d\n", len
);
2946 ath6kl_debug_fwlog_event(wmi
->parent_dev
, datap
, len
);
2949 ath6kl_warn("unknown cmd id 0x%x\n", id
);
2957 static int ath6kl_wmi_roam_tbl_event_rx(struct wmi
*wmi
, u8
*datap
, int len
)
2959 return ath6kl_debug_roam_tbl_event(wmi
->parent_dev
, datap
, len
);
2963 int ath6kl_wmi_control_rx(struct wmi
*wmi
, struct sk_buff
*skb
)
2965 struct wmi_cmd_hdr
*cmd
;
2966 struct ath6kl_vif
*vif
;
2973 if (WARN_ON(skb
== NULL
))
2976 if (skb
->len
< sizeof(struct wmi_cmd_hdr
)) {
2977 ath6kl_err("bad packet 1\n");
2982 cmd
= (struct wmi_cmd_hdr
*) skb
->data
;
2983 id
= le16_to_cpu(cmd
->cmd_id
);
2984 if_idx
= le16_to_cpu(cmd
->info1
) & WMI_CMD_HDR_IF_ID_MASK
;
2986 skb_pull(skb
, sizeof(struct wmi_cmd_hdr
));
2991 ath6kl_dbg(ATH6KL_DBG_WMI
, "wmi rx id %d len %d\n", id
, len
);
2992 ath6kl_dbg_dump(ATH6KL_DBG_WMI_DUMP
, NULL
, "wmi rx ",
2995 vif
= ath6kl_get_vif_by_index(wmi
->parent_dev
, if_idx
);
2997 ath6kl_dbg(ATH6KL_DBG_WMI
,
2998 "Wmi event for unavailable vif, vif_index:%d\n",
3005 case WMI_GET_BITRATE_CMDID
:
3006 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_GET_BITRATE_CMDID\n");
3007 ret
= ath6kl_wmi_bitrate_reply_rx(wmi
, datap
, len
);
3009 case WMI_GET_CHANNEL_LIST_CMDID
:
3010 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_GET_CHANNEL_LIST_CMDID\n");
3011 ret
= ath6kl_wmi_ch_list_reply_rx(wmi
, datap
, len
);
3013 case WMI_GET_TX_PWR_CMDID
:
3014 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_GET_TX_PWR_CMDID\n");
3015 ret
= ath6kl_wmi_tx_pwr_reply_rx(wmi
, datap
, len
);
3017 case WMI_READY_EVENTID
:
3018 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_READY_EVENTID\n");
3019 ret
= ath6kl_wmi_ready_event_rx(wmi
, datap
, len
);
3021 case WMI_CONNECT_EVENTID
:
3022 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_CONNECT_EVENTID\n");
3023 ret
= ath6kl_wmi_connect_event_rx(wmi
, datap
, len
, vif
);
3025 case WMI_DISCONNECT_EVENTID
:
3026 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_DISCONNECT_EVENTID\n");
3027 ret
= ath6kl_wmi_disconnect_event_rx(wmi
, datap
, len
, vif
);
3029 case WMI_PEER_NODE_EVENTID
:
3030 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_PEER_NODE_EVENTID\n");
3031 ret
= ath6kl_wmi_peer_node_event_rx(wmi
, datap
, len
);
3033 case WMI_TKIP_MICERR_EVENTID
:
3034 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_TKIP_MICERR_EVENTID\n");
3035 ret
= ath6kl_wmi_tkip_micerr_event_rx(wmi
, datap
, len
, vif
);
3037 case WMI_BSSINFO_EVENTID
:
3038 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_BSSINFO_EVENTID\n");
3039 ret
= ath6kl_wmi_bssinfo_event_rx(wmi
, datap
, len
, vif
);
3041 case WMI_REGDOMAIN_EVENTID
:
3042 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_REGDOMAIN_EVENTID\n");
3043 ath6kl_wmi_regdomain_event(wmi
, datap
, len
);
3045 case WMI_PSTREAM_TIMEOUT_EVENTID
:
3046 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_PSTREAM_TIMEOUT_EVENTID\n");
3047 ret
= ath6kl_wmi_pstream_timeout_event_rx(wmi
, datap
, len
);
3049 case WMI_NEIGHBOR_REPORT_EVENTID
:
3050 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_NEIGHBOR_REPORT_EVENTID\n");
3051 ret
= ath6kl_wmi_neighbor_report_event_rx(wmi
, datap
, len
,
3054 case WMI_SCAN_COMPLETE_EVENTID
:
3055 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_SCAN_COMPLETE_EVENTID\n");
3056 ret
= ath6kl_wmi_scan_complete_rx(wmi
, datap
, len
, vif
);
3058 case WMI_CMDERROR_EVENTID
:
3059 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_CMDERROR_EVENTID\n");
3060 ret
= ath6kl_wmi_error_event_rx(wmi
, datap
, len
);
3062 case WMI_REPORT_STATISTICS_EVENTID
:
3063 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_REPORT_STATISTICS_EVENTID\n");
3064 ret
= ath6kl_wmi_stats_event_rx(wmi
, datap
, len
, vif
);
3066 case WMI_RSSI_THRESHOLD_EVENTID
:
3067 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_RSSI_THRESHOLD_EVENTID\n");
3068 ret
= ath6kl_wmi_rssi_threshold_event_rx(wmi
, datap
, len
);
3070 case WMI_ERROR_REPORT_EVENTID
:
3071 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_ERROR_REPORT_EVENTID\n");
3073 case WMI_OPT_RX_FRAME_EVENTID
:
3074 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_OPT_RX_FRAME_EVENTID\n");
3075 /* this event has been deprecated */
3077 case WMI_REPORT_ROAM_TBL_EVENTID
:
3078 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_REPORT_ROAM_TBL_EVENTID\n");
3079 ret
= ath6kl_wmi_roam_tbl_event_rx(wmi
, datap
, len
);
3081 case WMI_EXTENSION_EVENTID
:
3082 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_EXTENSION_EVENTID\n");
3083 ret
= ath6kl_wmi_control_rx_xtnd(wmi
, skb
);
3085 case WMI_CAC_EVENTID
:
3086 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_CAC_EVENTID\n");
3087 ret
= ath6kl_wmi_cac_event_rx(wmi
, datap
, len
, vif
);
3089 case WMI_CHANNEL_CHANGE_EVENTID
:
3090 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_CHANNEL_CHANGE_EVENTID\n");
3092 case WMI_REPORT_ROAM_DATA_EVENTID
:
3093 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_REPORT_ROAM_DATA_EVENTID\n");
3095 case WMI_TEST_EVENTID
:
3096 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_TEST_EVENTID\n");
3097 ret
= ath6kl_wmi_tcmd_test_report_rx(wmi
, datap
, len
);
3099 case WMI_GET_FIXRATES_CMDID
:
3100 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_GET_FIXRATES_CMDID\n");
3101 ret
= ath6kl_wmi_ratemask_reply_rx(wmi
, datap
, len
);
3103 case WMI_TX_RETRY_ERR_EVENTID
:
3104 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_TX_RETRY_ERR_EVENTID\n");
3106 case WMI_SNR_THRESHOLD_EVENTID
:
3107 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_SNR_THRESHOLD_EVENTID\n");
3108 ret
= ath6kl_wmi_snr_threshold_event_rx(wmi
, datap
, len
);
3110 case WMI_LQ_THRESHOLD_EVENTID
:
3111 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_LQ_THRESHOLD_EVENTID\n");
3113 case WMI_APLIST_EVENTID
:
3114 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_APLIST_EVENTID\n");
3115 ret
= ath6kl_wmi_aplist_event_rx(wmi
, datap
, len
);
3117 case WMI_GET_KEEPALIVE_CMDID
:
3118 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_GET_KEEPALIVE_CMDID\n");
3119 ret
= ath6kl_wmi_keepalive_reply_rx(wmi
, datap
, len
);
3121 case WMI_GET_WOW_LIST_EVENTID
:
3122 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_GET_WOW_LIST_EVENTID\n");
3123 ret
= ath6kl_wmi_get_wow_list_event_rx(wmi
, datap
, len
);
3125 case WMI_GET_PMKID_LIST_EVENTID
:
3126 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_GET_PMKID_LIST_EVENTID\n");
3127 ret
= ath6kl_wmi_get_pmkid_list_event_rx(wmi
, datap
, len
);
3129 case WMI_PSPOLL_EVENTID
:
3130 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_PSPOLL_EVENTID\n");
3131 ret
= ath6kl_wmi_pspoll_event_rx(wmi
, datap
, len
, vif
);
3133 case WMI_DTIMEXPIRY_EVENTID
:
3134 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_DTIMEXPIRY_EVENTID\n");
3135 ret
= ath6kl_wmi_dtimexpiry_event_rx(wmi
, datap
, len
, vif
);
3137 case WMI_SET_PARAMS_REPLY_EVENTID
:
3138 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_SET_PARAMS_REPLY_EVENTID\n");
3140 case WMI_ADDBA_REQ_EVENTID
:
3141 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_ADDBA_REQ_EVENTID\n");
3142 ret
= ath6kl_wmi_addba_req_event_rx(wmi
, datap
, len
, vif
);
3144 case WMI_ADDBA_RESP_EVENTID
:
3145 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_ADDBA_RESP_EVENTID\n");
3147 case WMI_DELBA_REQ_EVENTID
:
3148 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_DELBA_REQ_EVENTID\n");
3149 ret
= ath6kl_wmi_delba_req_event_rx(wmi
, datap
, len
, vif
);
3151 case WMI_REPORT_BTCOEX_CONFIG_EVENTID
:
3152 ath6kl_dbg(ATH6KL_DBG_WMI
,
3153 "WMI_REPORT_BTCOEX_CONFIG_EVENTID\n");
3155 case WMI_REPORT_BTCOEX_STATS_EVENTID
:
3156 ath6kl_dbg(ATH6KL_DBG_WMI
,
3157 "WMI_REPORT_BTCOEX_STATS_EVENTID\n");
3159 case WMI_TX_COMPLETE_EVENTID
:
3160 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_TX_COMPLETE_EVENTID\n");
3161 ret
= ath6kl_wmi_tx_complete_event_rx(datap
, len
);
3163 case WMI_REMAIN_ON_CHNL_EVENTID
:
3164 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_REMAIN_ON_CHNL_EVENTID\n");
3165 ret
= ath6kl_wmi_remain_on_chnl_event_rx(wmi
, datap
, len
, vif
);
3167 case WMI_CANCEL_REMAIN_ON_CHNL_EVENTID
:
3168 ath6kl_dbg(ATH6KL_DBG_WMI
,
3169 "WMI_CANCEL_REMAIN_ON_CHNL_EVENTID\n");
3170 ret
= ath6kl_wmi_cancel_remain_on_chnl_event_rx(wmi
, datap
,
3173 case WMI_TX_STATUS_EVENTID
:
3174 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_TX_STATUS_EVENTID\n");
3175 ret
= ath6kl_wmi_tx_status_event_rx(wmi
, datap
, len
, vif
);
3177 case WMI_RX_PROBE_REQ_EVENTID
:
3178 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_RX_PROBE_REQ_EVENTID\n");
3179 ret
= ath6kl_wmi_rx_probe_req_event_rx(wmi
, datap
, len
, vif
);
3181 case WMI_P2P_CAPABILITIES_EVENTID
:
3182 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_P2P_CAPABILITIES_EVENTID\n");
3183 ret
= ath6kl_wmi_p2p_capabilities_event_rx(datap
, len
);
3185 case WMI_RX_ACTION_EVENTID
:
3186 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_RX_ACTION_EVENTID\n");
3187 ret
= ath6kl_wmi_rx_action_event_rx(wmi
, datap
, len
, vif
);
3189 case WMI_P2P_INFO_EVENTID
:
3190 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_P2P_INFO_EVENTID\n");
3191 ret
= ath6kl_wmi_p2p_info_event_rx(datap
, len
);
3194 ath6kl_dbg(ATH6KL_DBG_WMI
, "unknown cmd id 0x%x\n", id
);
3204 static void ath6kl_wmi_qos_state_init(struct wmi
*wmi
)
3209 spin_lock_bh(&wmi
->lock
);
3211 wmi
->fat_pipe_exist
= 0;
3212 memset(wmi
->stream_exist_for_ac
, 0, sizeof(wmi
->stream_exist_for_ac
));
3214 spin_unlock_bh(&wmi
->lock
);
3217 void *ath6kl_wmi_init(struct ath6kl
*dev
)
3221 wmi
= kzalloc(sizeof(struct wmi
), GFP_KERNEL
);
3225 spin_lock_init(&wmi
->lock
);
3227 wmi
->parent_dev
= dev
;
3229 wmi
->pwr_mode
= REC_POWER
;
3231 ath6kl_wmi_qos_state_init(wmi
);
3236 void ath6kl_wmi_shutdown(struct wmi
*wmi
)
3241 kfree(wmi
->last_mgmt_tx_frame
);