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.
21 static int ath6kl_wmi_sync_point(struct wmi
*wmi
);
23 static const s32 wmi_rate_tbl
[][2] = {
24 /* {W/O SGI, with SGI} */
56 /* 802.1d to AC mapping. Refer pg 57 of WMM-test-plan-v1.2 */
57 static const u8 up_to_ac
[] = {
68 void ath6kl_wmi_set_control_ep(struct wmi
*wmi
, enum htc_endpoint_id ep_id
)
70 if (WARN_ON(ep_id
== ENDPOINT_UNUSED
|| ep_id
>= ENDPOINT_MAX
))
76 enum htc_endpoint_id
ath6kl_wmi_get_control_ep(struct wmi
*wmi
)
81 /* Performs DIX to 802.3 encapsulation for transmit packets.
82 * Assumes the entire DIX header is contigous and that there is
83 * enough room in the buffer for a 802.3 mac header and LLC+SNAP headers.
85 int ath6kl_wmi_dix_2_dot3(struct wmi
*wmi
, struct sk_buff
*skb
)
87 struct ath6kl_llc_snap_hdr
*llc_hdr
;
88 struct ethhdr
*eth_hdr
;
94 if (WARN_ON(skb
== NULL
))
97 size
= sizeof(struct ath6kl_llc_snap_hdr
) + sizeof(struct wmi_data_hdr
);
98 if (skb_headroom(skb
) < size
)
101 eth_hdr
= (struct ethhdr
*) skb
->data
;
102 type
= eth_hdr
->h_proto
;
104 if (!is_ethertype(be16_to_cpu(type
))) {
105 ath6kl_dbg(ATH6KL_DBG_WMI
,
106 "%s: pkt is already in 802.3 format\n", __func__
);
110 new_len
= skb
->len
- sizeof(*eth_hdr
) + sizeof(*llc_hdr
);
112 skb_push(skb
, sizeof(struct ath6kl_llc_snap_hdr
));
115 eth_hdr
->h_proto
= cpu_to_be16(new_len
);
117 memcpy(datap
, eth_hdr
, sizeof(*eth_hdr
));
119 llc_hdr
= (struct ath6kl_llc_snap_hdr
*)(datap
+ sizeof(*eth_hdr
));
120 llc_hdr
->dsap
= 0xAA;
121 llc_hdr
->ssap
= 0xAA;
122 llc_hdr
->cntl
= 0x03;
123 llc_hdr
->org_code
[0] = 0x0;
124 llc_hdr
->org_code
[1] = 0x0;
125 llc_hdr
->org_code
[2] = 0x0;
126 llc_hdr
->eth_type
= type
;
131 static int ath6kl_wmi_meta_add(struct wmi
*wmi
, struct sk_buff
*skb
,
132 u8
*version
, void *tx_meta_info
)
134 struct wmi_tx_meta_v1
*v1
;
135 struct wmi_tx_meta_v2
*v2
;
137 if (WARN_ON(skb
== NULL
|| version
== NULL
))
141 case WMI_META_VERSION_1
:
142 skb_push(skb
, WMI_MAX_TX_META_SZ
);
143 v1
= (struct wmi_tx_meta_v1
*) skb
->data
;
145 v1
->rate_plcy_id
= 0;
146 *version
= WMI_META_VERSION_1
;
148 case WMI_META_VERSION_2
:
149 skb_push(skb
, WMI_MAX_TX_META_SZ
);
150 v2
= (struct wmi_tx_meta_v2
*) skb
->data
;
151 memcpy(v2
, (struct wmi_tx_meta_v2
*) tx_meta_info
,
152 sizeof(struct wmi_tx_meta_v2
));
159 int ath6kl_wmi_data_hdr_add(struct wmi
*wmi
, struct sk_buff
*skb
,
160 u8 msg_type
, bool more_data
,
161 enum wmi_data_hdr_data_type data_type
,
162 u8 meta_ver
, void *tx_meta_info
)
164 struct wmi_data_hdr
*data_hdr
;
167 if (WARN_ON(skb
== NULL
))
170 ret
= ath6kl_wmi_meta_add(wmi
, skb
, &meta_ver
, tx_meta_info
);
174 skb_push(skb
, sizeof(struct wmi_data_hdr
));
176 data_hdr
= (struct wmi_data_hdr
*)skb
->data
;
177 memset(data_hdr
, 0, sizeof(struct wmi_data_hdr
));
179 data_hdr
->info
= msg_type
<< WMI_DATA_HDR_MSG_TYPE_SHIFT
;
180 data_hdr
->info
|= data_type
<< WMI_DATA_HDR_DATA_TYPE_SHIFT
;
184 WMI_DATA_HDR_MORE_MASK
<< WMI_DATA_HDR_MORE_SHIFT
;
186 data_hdr
->info2
= cpu_to_le16(meta_ver
<< WMI_DATA_HDR_META_SHIFT
);
192 static u8
ath6kl_wmi_determine_user_priority(u8
*pkt
, u32 layer2_pri
)
194 struct iphdr
*ip_hdr
= (struct iphdr
*) pkt
;
198 * Determine IPTOS priority
201 * : DSCP(6-bits) ECN(2-bits)
202 * : DSCP - P2 P1 P0 X X X
203 * where (P2 P1 P0) form 802.1D
205 ip_pri
= ip_hdr
->tos
>> 5;
208 if ((layer2_pri
& 0x7) > ip_pri
)
209 return (u8
) layer2_pri
& 0x7;
214 int ath6kl_wmi_implicit_create_pstream(struct wmi
*wmi
, struct sk_buff
*skb
,
215 u32 layer2_priority
, bool wmm_enabled
,
218 struct wmi_data_hdr
*data_hdr
;
219 struct ath6kl_llc_snap_hdr
*llc_hdr
;
220 struct wmi_create_pstream_cmd cmd
;
221 u32 meta_size
, hdr_size
;
222 u16 ip_type
= IP_ETHERTYPE
;
223 u8 stream_exist
, usr_pri
;
224 u8 traffic_class
= WMM_AC_BE
;
227 if (WARN_ON(skb
== NULL
))
231 data_hdr
= (struct wmi_data_hdr
*) datap
;
233 meta_size
= ((le16_to_cpu(data_hdr
->info2
) >> WMI_DATA_HDR_META_SHIFT
) &
234 WMI_DATA_HDR_META_MASK
) ? WMI_MAX_TX_META_SZ
: 0;
237 /* If WMM is disabled all traffic goes as BE traffic */
240 hdr_size
= sizeof(struct ethhdr
);
242 llc_hdr
= (struct ath6kl_llc_snap_hdr
*)(datap
+
245 meta_size
+ hdr_size
);
247 if (llc_hdr
->eth_type
== htons(ip_type
)) {
249 * Extract the endpoint info from the TOS field
253 ath6kl_wmi_determine_user_priority(((u8
*) llc_hdr
) +
254 sizeof(struct ath6kl_llc_snap_hdr
),
257 usr_pri
= layer2_priority
& 0x7;
260 /* workaround for WMM S5 */
261 if ((wmi
->traffic_class
== WMM_AC_VI
) &&
262 ((usr_pri
== 5) || (usr_pri
== 4)))
265 /* Convert user priority to traffic class */
266 traffic_class
= up_to_ac
[usr_pri
& 0x7];
268 wmi_data_hdr_set_up(data_hdr
, usr_pri
);
270 spin_lock_bh(&wmi
->lock
);
271 stream_exist
= wmi
->fat_pipe_exist
;
272 spin_unlock_bh(&wmi
->lock
);
274 if (!(stream_exist
& (1 << traffic_class
))) {
275 memset(&cmd
, 0, sizeof(cmd
));
276 cmd
.traffic_class
= traffic_class
;
277 cmd
.user_pri
= usr_pri
;
279 cpu_to_le32(WMI_IMPLICIT_PSTREAM_INACTIVITY_INT
);
280 /* Implicit streams are created with TSID 0xFF */
281 cmd
.tsid
= WMI_IMPLICIT_PSTREAM
;
282 ath6kl_wmi_create_pstream_cmd(wmi
, &cmd
);
290 int ath6kl_wmi_dot11_hdr_remove(struct wmi
*wmi
, struct sk_buff
*skb
)
292 struct ieee80211_hdr_3addr
*pwh
, wh
;
293 struct ath6kl_llc_snap_hdr
*llc_hdr
;
294 struct ethhdr eth_hdr
;
299 if (WARN_ON(skb
== NULL
))
303 pwh
= (struct ieee80211_hdr_3addr
*) datap
;
305 sub_type
= pwh
->frame_control
& cpu_to_le16(IEEE80211_FCTL_STYPE
);
307 memcpy((u8
*) &wh
, datap
, sizeof(struct ieee80211_hdr_3addr
));
309 /* Strip off the 802.11 header */
310 if (sub_type
== cpu_to_le16(IEEE80211_STYPE_QOS_DATA
)) {
311 hdr_size
= roundup(sizeof(struct ieee80211_qos_hdr
),
313 skb_pull(skb
, hdr_size
);
314 } else if (sub_type
== cpu_to_le16(IEEE80211_STYPE_DATA
))
315 skb_pull(skb
, sizeof(struct ieee80211_hdr_3addr
));
318 llc_hdr
= (struct ath6kl_llc_snap_hdr
*)(datap
);
320 memset(ð_hdr
, 0, sizeof(eth_hdr
));
321 eth_hdr
.h_proto
= llc_hdr
->eth_type
;
323 switch ((le16_to_cpu(wh
.frame_control
)) &
324 (IEEE80211_FCTL_FROMDS
| IEEE80211_FCTL_TODS
)) {
326 memcpy(eth_hdr
.h_dest
, wh
.addr1
, ETH_ALEN
);
327 memcpy(eth_hdr
.h_source
, wh
.addr2
, ETH_ALEN
);
329 case IEEE80211_FCTL_TODS
:
330 memcpy(eth_hdr
.h_dest
, wh
.addr3
, ETH_ALEN
);
331 memcpy(eth_hdr
.h_source
, wh
.addr2
, ETH_ALEN
);
333 case IEEE80211_FCTL_FROMDS
:
334 memcpy(eth_hdr
.h_dest
, wh
.addr1
, ETH_ALEN
);
335 memcpy(eth_hdr
.h_source
, wh
.addr3
, ETH_ALEN
);
337 case IEEE80211_FCTL_FROMDS
| IEEE80211_FCTL_TODS
:
341 skb_pull(skb
, sizeof(struct ath6kl_llc_snap_hdr
));
342 skb_push(skb
, sizeof(eth_hdr
));
346 memcpy(datap
, ð_hdr
, sizeof(eth_hdr
));
352 * Performs 802.3 to DIX encapsulation for received packets.
353 * Assumes the entire 802.3 header is contigous.
355 int ath6kl_wmi_dot3_2_dix(struct sk_buff
*skb
)
357 struct ath6kl_llc_snap_hdr
*llc_hdr
;
358 struct ethhdr eth_hdr
;
361 if (WARN_ON(skb
== NULL
))
366 memcpy(ð_hdr
, datap
, sizeof(eth_hdr
));
368 llc_hdr
= (struct ath6kl_llc_snap_hdr
*) (datap
+ sizeof(eth_hdr
));
369 eth_hdr
.h_proto
= llc_hdr
->eth_type
;
371 skb_pull(skb
, sizeof(struct ath6kl_llc_snap_hdr
));
374 memcpy(datap
, ð_hdr
, sizeof(eth_hdr
));
379 int ath6kl_wmi_data_hdr_remove(struct wmi
*wmi
, struct sk_buff
*skb
)
381 if (WARN_ON(skb
== NULL
))
384 skb_pull(skb
, sizeof(struct wmi_data_hdr
));
389 static void ath6kl_wmi_convert_bssinfo_hdr2_to_hdr(struct sk_buff
*skb
,
392 struct wmi_bss_info_hdr2 bih2
;
393 struct wmi_bss_info_hdr
*bih
;
395 memcpy(&bih2
, datap
, sizeof(struct wmi_bss_info_hdr2
));
398 bih
= (struct wmi_bss_info_hdr
*) skb
->data
;
401 bih
->frame_type
= bih2
.frame_type
;
403 bih
->rssi
= a_cpu_to_sle16(bih2
.snr
- 95);
404 bih
->ie_mask
= cpu_to_le32(le16_to_cpu(bih2
.ie_mask
));
405 memcpy(bih
->bssid
, bih2
.bssid
, ETH_ALEN
);
408 static int ath6kl_wmi_tx_complete_event_rx(u8
*datap
, int len
)
410 struct tx_complete_msg_v1
*msg_v1
;
411 struct wmi_tx_complete_event
*evt
;
415 evt
= (struct wmi_tx_complete_event
*) datap
;
417 ath6kl_dbg(ATH6KL_DBG_WMI
, "comp: %d %d %d\n",
418 evt
->num_msg
, evt
->msg_len
, evt
->msg_type
);
420 if (!AR_DBG_LVL_CHECK(ATH6KL_DBG_WMI
))
423 for (index
= 0; index
< evt
->num_msg
; index
++) {
424 size
= sizeof(struct wmi_tx_complete_event
) +
425 (index
* sizeof(struct tx_complete_msg_v1
));
426 msg_v1
= (struct tx_complete_msg_v1
*)(datap
+ size
);
428 ath6kl_dbg(ATH6KL_DBG_WMI
, "msg: %d %d %d %d\n",
429 msg_v1
->status
, msg_v1
->pkt_id
,
430 msg_v1
->rate_idx
, msg_v1
->ack_failures
);
436 static inline struct sk_buff
*ath6kl_wmi_get_new_buf(u32 size
)
440 skb
= ath6kl_buf_alloc(size
);
446 memset(skb
->data
, 0, size
);
451 /* Send a "simple" wmi command -- one with no arguments */
452 static int ath6kl_wmi_simple_cmd(struct wmi
*wmi
, enum wmi_cmd_id cmd_id
)
457 skb
= ath6kl_wmi_get_new_buf(0);
461 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, cmd_id
, NO_SYNC_WMIFLAG
);
466 static int ath6kl_wmi_ready_event_rx(struct wmi
*wmi
, u8
*datap
, int len
)
468 struct wmi_ready_event_2
*ev
= (struct wmi_ready_event_2
*) datap
;
470 if (len
< sizeof(struct wmi_ready_event_2
))
474 ath6kl_ready_event(wmi
->parent_dev
, ev
->mac_addr
,
475 le32_to_cpu(ev
->sw_version
),
476 le32_to_cpu(ev
->abi_version
));
481 static int ath6kl_wmi_connect_event_rx(struct wmi
*wmi
, u8
*datap
, int len
)
483 struct wmi_connect_event
*ev
;
486 if (len
< sizeof(struct wmi_connect_event
))
489 ev
= (struct wmi_connect_event
*) datap
;
491 ath6kl_dbg(ATH6KL_DBG_WMI
, "%s: freq %d bssid %pM\n",
492 __func__
, ev
->ch
, ev
->bssid
);
494 /* Start of assoc rsp IEs */
495 pie
= ev
->assoc_info
+ ev
->beacon_ie_len
+
496 ev
->assoc_req_len
+ (sizeof(u16
) * 3); /* capinfo, status, aid */
498 /* End of assoc rsp IEs */
499 peie
= ev
->assoc_info
+ ev
->beacon_ie_len
+ ev
->assoc_req_len
+
504 case WLAN_EID_VENDOR_SPECIFIC
:
505 if (pie
[1] > 3 && pie
[2] == 0x00 && pie
[3] == 0x50 &&
506 pie
[4] == 0xf2 && pie
[5] == WMM_OUI_TYPE
) {
507 /* WMM OUT (00:50:F2) */
509 && pie
[6] == WMM_PARAM_OUI_SUBTYPE
)
510 wmi
->is_wmm_enabled
= true;
515 if (wmi
->is_wmm_enabled
)
521 ath6kl_connect_event(wmi
->parent_dev
, le16_to_cpu(ev
->ch
), ev
->bssid
,
522 le16_to_cpu(ev
->listen_intvl
),
523 le16_to_cpu(ev
->beacon_intvl
),
524 le32_to_cpu(ev
->nw_type
),
525 ev
->beacon_ie_len
, ev
->assoc_req_len
,
526 ev
->assoc_resp_len
, ev
->assoc_info
);
531 static int ath6kl_wmi_disconnect_event_rx(struct wmi
*wmi
, u8
*datap
, int len
)
533 struct wmi_disconnect_event
*ev
;
534 wmi
->traffic_class
= 100;
536 if (len
< sizeof(struct wmi_disconnect_event
))
539 ev
= (struct wmi_disconnect_event
*) datap
;
541 wmi
->is_wmm_enabled
= false;
542 wmi
->pair_crypto_type
= NONE_CRYPT
;
543 wmi
->grp_crypto_type
= NONE_CRYPT
;
545 ath6kl_disconnect_event(wmi
->parent_dev
, ev
->disconn_reason
,
546 ev
->bssid
, ev
->assoc_resp_len
, ev
->assoc_info
,
547 le16_to_cpu(ev
->proto_reason_status
));
552 static int ath6kl_wmi_peer_node_event_rx(struct wmi
*wmi
, u8
*datap
, int len
)
554 struct wmi_peer_node_event
*ev
;
556 if (len
< sizeof(struct wmi_peer_node_event
))
559 ev
= (struct wmi_peer_node_event
*) datap
;
561 if (ev
->event_code
== PEER_NODE_JOIN_EVENT
)
562 ath6kl_dbg(ATH6KL_DBG_WMI
, "joined node with mac addr: %pM\n",
564 else if (ev
->event_code
== PEER_NODE_LEAVE_EVENT
)
565 ath6kl_dbg(ATH6KL_DBG_WMI
, "left node with mac addr: %pM\n",
571 static int ath6kl_wmi_tkip_micerr_event_rx(struct wmi
*wmi
, u8
*datap
, int len
)
573 struct wmi_tkip_micerr_event
*ev
;
575 if (len
< sizeof(struct wmi_tkip_micerr_event
))
578 ev
= (struct wmi_tkip_micerr_event
*) datap
;
580 ath6kl_tkip_micerr_event(wmi
->parent_dev
, ev
->key_id
, ev
->is_mcast
);
585 static int ath6kl_wlan_parse_beacon(u8
*buf
, int frame_len
,
586 struct ath6kl_common_ie
*cie
)
589 u8 elemid_ssid
= false;
592 efrm
= (u8
*) (frm
+ frame_len
);
595 * beacon/probe response frame format
597 * [2] beacon interval
598 * [2] capability information
600 * [tlv] supported rates
601 * [tlv] country information
602 * [tlv] parameter set (FH/DS)
603 * [tlv] erp information
604 * [tlv] extended supported rates
607 * [tlv] Atheros Advanced Capabilities
609 if ((efrm
- frm
) < 12)
612 memset(cie
, 0, sizeof(*cie
));
614 cie
->ie_tstamp
= frm
;
616 cie
->ie_beaconInt
= *(u16
*) frm
;
618 cie
->ie_capInfo
= *(u16
*) frm
;
630 case WLAN_EID_SUPP_RATES
:
633 case WLAN_EID_COUNTRY
:
634 cie
->ie_country
= frm
;
636 case WLAN_EID_FH_PARAMS
:
638 case WLAN_EID_DS_PARAMS
:
639 cie
->ie_chan
= frm
[2];
644 case WLAN_EID_IBSS_PARAMS
:
646 case WLAN_EID_EXT_SUPP_RATES
:
647 cie
->ie_xrates
= frm
;
649 case WLAN_EID_ERP_INFO
:
653 cie
->ie_erp
= frm
[2];
658 case WLAN_EID_HT_CAPABILITY
:
661 case WLAN_EID_HT_INFORMATION
:
664 case WLAN_EID_VENDOR_SPECIFIC
:
665 if (frm
[1] > 3 && frm
[2] == 0x00 && frm
[3] == 0x50 &&
667 /* OUT Type (00:50:F2) */
669 if (frm
[5] == WPA_OUI_TYPE
) {
672 } else if (frm
[5] == WMM_OUI_TYPE
) {
675 } else if (frm
[5] == WSC_OUT_TYPE
) {
680 } else if (frm
[1] > 3 && frm
[2] == 0x00
681 && frm
[3] == 0x03 && frm
[4] == 0x7f
682 && frm
[5] == ATH_OUI_TYPE
) {
683 /* Atheros OUI (00:03:7f) */
693 if ((cie
->ie_rates
== NULL
)
694 || (cie
->ie_rates
[1] > ATH6KL_RATE_MAXSIZE
))
697 if ((cie
->ie_ssid
== NULL
)
698 || (cie
->ie_ssid
[1] > IEEE80211_MAX_SSID_LEN
))
704 static int ath6kl_wmi_bssinfo_event_rx(struct wmi
*wmi
, u8
*datap
, int len
)
706 struct bss
*bss
= NULL
;
707 struct wmi_bss_info_hdr
*bih
;
708 u8 cached_ssid_len
= 0;
709 u8 cached_ssid
[IEEE80211_MAX_SSID_LEN
] = { 0 };
710 u8 beacon_ssid_len
= 0;
717 if (len
<= sizeof(struct wmi_bss_info_hdr
))
720 bih
= (struct wmi_bss_info_hdr
*) datap
;
721 bss
= wlan_find_node(&wmi
->parent_dev
->scan_table
, bih
->bssid
);
723 if (a_sle16_to_cpu(bih
->rssi
) > 0) {
727 bih
->rssi
= a_cpu_to_sle16(bss
->ni_rssi
);
730 buf
= datap
+ sizeof(struct wmi_bss_info_hdr
);
731 len
-= sizeof(struct wmi_bss_info_hdr
);
733 ath6kl_dbg(ATH6KL_DBG_WMI
,
734 "bss info evt - ch %u, rssi %02x, bssid \"%pM\"\n",
735 bih
->ch
, a_sle16_to_cpu(bih
->rssi
), bih
->bssid
);
739 * Free up the node. We are about to allocate a new node.
740 * In case of hidden AP, beacon will not have ssid,
741 * but a directed probe response will have it,
742 * so cache the probe-resp-ssid if already present.
744 if (wmi
->is_probe_ssid
&& (bih
->frame_type
== BEACON_FTYPE
)) {
745 ie_ssid
= bss
->ni_cie
.ie_ssid
;
746 if (ie_ssid
&& (ie_ssid
[1] <= IEEE80211_MAX_SSID_LEN
) &&
748 cached_ssid_len
= ie_ssid
[1];
749 memcpy(cached_ssid
, ie_ssid
+ 2,
755 * Use the current average rssi of associated AP base on
757 * 1. Most os with GUI will update RSSI by
758 * ath6kl_wmi_get_stats_cmd() periodically.
759 * 2. ath6kl_wmi_get_stats_cmd(..) will be called when calling
760 * ath6kl_wmi_startscan_cmd(...)
761 * The average value of RSSI give end-user better feeling for
762 * instance value of scan result. It also sync up RSSI info
763 * in GUI between scan result and RSSI signal icon.
765 if (memcmp(wmi
->parent_dev
->bssid
, bih
->bssid
, ETH_ALEN
) == 0) {
766 bih
->rssi
= a_cpu_to_sle16(bss
->ni_rssi
);
767 bih
->snr
= bss
->ni_snr
;
770 wlan_node_reclaim(&wmi
->parent_dev
->scan_table
, bss
);
774 * beacon/probe response frame format
776 * [2] beacon interval
777 * [2] capability information
780 beacon_ssid_len
= buf
[SSID_IE_LEN_INDEX
];
783 * If ssid is cached for this hidden AP, then change
784 * buffer len accordingly.
786 if (wmi
->is_probe_ssid
&& (bih
->frame_type
== BEACON_FTYPE
) &&
787 (cached_ssid_len
!= 0) &&
788 (beacon_ssid_len
== 0 || (cached_ssid_len
> beacon_ssid_len
&&
789 buf
[SSID_IE_LEN_INDEX
+ 1] == 0))) {
791 len
+= (cached_ssid_len
- beacon_ssid_len
);
794 bss
= wlan_node_alloc(len
);
798 bss
->ni_snr
= bih
->snr
;
799 bss
->ni_rssi
= a_sle16_to_cpu(bih
->rssi
);
801 if (WARN_ON(!bss
->ni_buf
))
805 * In case of hidden AP, beacon will not have ssid,
806 * but a directed probe response will have it,
807 * so place the cached-ssid(probe-resp) in the bss info.
809 if (wmi
->is_probe_ssid
&& (bih
->frame_type
== BEACON_FTYPE
) &&
810 (cached_ssid_len
!= 0) &&
811 (beacon_ssid_len
== 0 || (beacon_ssid_len
&&
812 buf
[SSID_IE_LEN_INDEX
+ 1] == 0))) {
813 ni_buf
= bss
->ni_buf
;
817 * Copy the first 14 bytes:
818 * time-stamp(8), beacon-interval(2),
819 * cap-info(2), ssid-id(1), ssid-len(1).
821 memcpy(ni_buf
, buf
, SSID_IE_LEN_INDEX
+ 1);
823 ni_buf
[SSID_IE_LEN_INDEX
] = cached_ssid_len
;
824 ni_buf
+= (SSID_IE_LEN_INDEX
+ 1);
826 buf
+= (SSID_IE_LEN_INDEX
+ 1);
827 buf_len
-= (SSID_IE_LEN_INDEX
+ 1);
829 memcpy(ni_buf
, cached_ssid
, cached_ssid_len
);
830 ni_buf
+= cached_ssid_len
;
832 buf
+= beacon_ssid_len
;
833 buf_len
-= beacon_ssid_len
;
835 if (cached_ssid_len
> beacon_ssid_len
)
836 buf_len
-= (cached_ssid_len
- beacon_ssid_len
);
838 memcpy(ni_buf
, buf
, buf_len
);
840 memcpy(bss
->ni_buf
, buf
, len
);
842 bss
->ni_framelen
= len
;
844 ret
= ath6kl_wlan_parse_beacon(bss
->ni_buf
, len
, &bss
->ni_cie
);
851 * Update the frequency in ie_chan, overwriting of channel number
852 * which is done in ath6kl_wlan_parse_beacon
854 bss
->ni_cie
.ie_chan
= le16_to_cpu(bih
->ch
);
855 wlan_setup_node(&wmi
->parent_dev
->scan_table
, bss
, bih
->bssid
);
860 static int ath6kl_wmi_opt_frame_event_rx(struct wmi
*wmi
, u8
*datap
, int len
)
863 struct wmi_opt_rx_info_hdr
*bih
;
866 if (len
<= sizeof(struct wmi_opt_rx_info_hdr
))
869 bih
= (struct wmi_opt_rx_info_hdr
*) datap
;
870 buf
= datap
+ sizeof(struct wmi_opt_rx_info_hdr
);
871 len
-= sizeof(struct wmi_opt_rx_info_hdr
);
873 ath6kl_dbg(ATH6KL_DBG_WMI
, "opt frame event %2.2x:%2.2x\n",
874 bih
->bssid
[4], bih
->bssid
[5]);
876 bss
= wlan_find_node(&wmi
->parent_dev
->scan_table
, bih
->bssid
);
878 /* Free up the node. We are about to allocate a new node. */
879 wlan_node_reclaim(&wmi
->parent_dev
->scan_table
, bss
);
882 bss
= wlan_node_alloc(len
);
886 bss
->ni_snr
= bih
->snr
;
887 bss
->ni_cie
.ie_chan
= le16_to_cpu(bih
->ch
);
889 if (WARN_ON(!bss
->ni_buf
))
892 memcpy(bss
->ni_buf
, buf
, len
);
893 wlan_setup_node(&wmi
->parent_dev
->scan_table
, bss
, bih
->bssid
);
898 /* Inactivity timeout of a fatpipe(pstream) at the target */
899 static int ath6kl_wmi_pstream_timeout_event_rx(struct wmi
*wmi
, u8
*datap
,
902 struct wmi_pstream_timeout_event
*ev
;
904 if (len
< sizeof(struct wmi_pstream_timeout_event
))
907 ev
= (struct wmi_pstream_timeout_event
*) datap
;
910 * When the pstream (fat pipe == AC) timesout, it means there were
911 * no thinStreams within this pstream & it got implicitly created
912 * due to data flow on this AC. We start the inactivity timer only
913 * for implicitly created pstream. Just reset the host state.
915 spin_lock_bh(&wmi
->lock
);
916 wmi
->stream_exist_for_ac
[ev
->traffic_class
] = 0;
917 wmi
->fat_pipe_exist
&= ~(1 << ev
->traffic_class
);
918 spin_unlock_bh(&wmi
->lock
);
920 /* Indicate inactivity to driver layer for this fatpipe (pstream) */
921 ath6kl_indicate_tx_activity(wmi
->parent_dev
, ev
->traffic_class
, false);
926 static int ath6kl_wmi_bitrate_reply_rx(struct wmi
*wmi
, u8
*datap
, int len
)
928 struct wmi_bit_rate_reply
*reply
;
932 if (len
< sizeof(struct wmi_bit_rate_reply
))
935 reply
= (struct wmi_bit_rate_reply
*) datap
;
937 ath6kl_dbg(ATH6KL_DBG_WMI
, "rateindex %d\n", reply
->rate_index
);
939 if (reply
->rate_index
== (s8
) RATE_AUTO
) {
942 index
= reply
->rate_index
& 0x7f;
943 sgi
= (reply
->rate_index
& 0x80) ? 1 : 0;
944 rate
= wmi_rate_tbl
[index
][sgi
];
947 ath6kl_wakeup_event(wmi
->parent_dev
);
952 static int ath6kl_wmi_ratemask_reply_rx(struct wmi
*wmi
, u8
*datap
, int len
)
954 if (len
< sizeof(struct wmi_fix_rates_reply
))
957 ath6kl_wakeup_event(wmi
->parent_dev
);
962 static int ath6kl_wmi_ch_list_reply_rx(struct wmi
*wmi
, u8
*datap
, int len
)
964 if (len
< sizeof(struct wmi_channel_list_reply
))
967 ath6kl_wakeup_event(wmi
->parent_dev
);
972 static int ath6kl_wmi_tx_pwr_reply_rx(struct wmi
*wmi
, u8
*datap
, int len
)
974 struct wmi_tx_pwr_reply
*reply
;
976 if (len
< sizeof(struct wmi_tx_pwr_reply
))
979 reply
= (struct wmi_tx_pwr_reply
*) datap
;
980 ath6kl_txpwr_rx_evt(wmi
->parent_dev
, reply
->dbM
);
985 static int ath6kl_wmi_keepalive_reply_rx(struct wmi
*wmi
, u8
*datap
, int len
)
987 if (len
< sizeof(struct wmi_get_keepalive_cmd
))
990 ath6kl_wakeup_event(wmi
->parent_dev
);
995 static int ath6kl_wmi_scan_complete_rx(struct wmi
*wmi
, u8
*datap
, int len
)
997 struct wmi_scan_complete_event
*ev
;
999 ev
= (struct wmi_scan_complete_event
*) datap
;
1001 if (a_sle32_to_cpu(ev
->status
) == 0)
1002 wlan_refresh_inactive_nodes(wmi
->parent_dev
);
1004 ath6kl_scan_complete_evt(wmi
->parent_dev
, a_sle32_to_cpu(ev
->status
));
1005 wmi
->is_probe_ssid
= false;
1011 * Target is reporting a programming error. This is for
1012 * developer aid only. Target only checks a few common violations
1013 * and it is responsibility of host to do all error checking.
1014 * Behavior of target after wmi error event is undefined.
1015 * A reset is recommended.
1017 static int ath6kl_wmi_error_event_rx(struct wmi
*wmi
, u8
*datap
, int len
)
1019 const char *type
= "unknown error";
1020 struct wmi_cmd_error_event
*ev
;
1021 ev
= (struct wmi_cmd_error_event
*) datap
;
1023 switch (ev
->err_code
) {
1025 type
= "invalid parameter";
1028 type
= "invalid state";
1030 case INTERNAL_ERROR
:
1031 type
= "internal error";
1035 ath6kl_dbg(ATH6KL_DBG_WMI
, "programming error, cmd=%d %s\n",
1041 static int ath6kl_wmi_stats_event_rx(struct wmi
*wmi
, u8
*datap
, int len
)
1043 ath6kl_tgt_stats_event(wmi
->parent_dev
, datap
, len
);
1048 static u8
ath6kl_wmi_get_upper_threshold(s16 rssi
,
1049 struct sq_threshold_params
*sq_thresh
,
1053 u8 threshold
= (u8
) sq_thresh
->upper_threshold
[size
- 1];
1055 /* The list is already in sorted order. Get the next lower value */
1056 for (index
= 0; index
< size
; index
++) {
1057 if (rssi
< sq_thresh
->upper_threshold
[index
]) {
1058 threshold
= (u8
) sq_thresh
->upper_threshold
[index
];
1066 static u8
ath6kl_wmi_get_lower_threshold(s16 rssi
,
1067 struct sq_threshold_params
*sq_thresh
,
1071 u8 threshold
= (u8
) sq_thresh
->lower_threshold
[size
- 1];
1073 /* The list is already in sorted order. Get the next lower value */
1074 for (index
= 0; index
< size
; index
++) {
1075 if (rssi
> sq_thresh
->lower_threshold
[index
]) {
1076 threshold
= (u8
) sq_thresh
->lower_threshold
[index
];
1084 static int ath6kl_wmi_send_rssi_threshold_params(struct wmi
*wmi
,
1085 struct wmi_rssi_threshold_params_cmd
*rssi_cmd
)
1087 struct sk_buff
*skb
;
1088 struct wmi_rssi_threshold_params_cmd
*cmd
;
1090 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
1094 cmd
= (struct wmi_rssi_threshold_params_cmd
*) skb
->data
;
1095 memcpy(cmd
, rssi_cmd
, sizeof(struct wmi_rssi_threshold_params_cmd
));
1097 return ath6kl_wmi_cmd_send(wmi
, skb
, WMI_RSSI_THRESHOLD_PARAMS_CMDID
,
1101 static int ath6kl_wmi_rssi_threshold_event_rx(struct wmi
*wmi
, u8
*datap
,
1104 struct wmi_rssi_threshold_event
*reply
;
1105 struct wmi_rssi_threshold_params_cmd cmd
;
1106 struct sq_threshold_params
*sq_thresh
;
1107 enum wmi_rssi_threshold_val new_threshold
;
1108 u8 upper_rssi_threshold
, lower_rssi_threshold
;
1112 if (len
< sizeof(struct wmi_rssi_threshold_event
))
1115 reply
= (struct wmi_rssi_threshold_event
*) datap
;
1116 new_threshold
= (enum wmi_rssi_threshold_val
) reply
->range
;
1117 rssi
= a_sle16_to_cpu(reply
->rssi
);
1119 sq_thresh
= &wmi
->sq_threshld
[SIGNAL_QUALITY_METRICS_RSSI
];
1122 * Identify the threshold breached and communicate that to the app.
1123 * After that install a new set of thresholds based on the signal
1124 * quality reported by the target
1126 if (new_threshold
) {
1127 /* Upper threshold breached */
1128 if (rssi
< sq_thresh
->upper_threshold
[0]) {
1129 ath6kl_dbg(ATH6KL_DBG_WMI
,
1130 "spurious upper rssi threshold event: %d\n",
1132 } else if ((rssi
< sq_thresh
->upper_threshold
[1]) &&
1133 (rssi
>= sq_thresh
->upper_threshold
[0])) {
1134 new_threshold
= WMI_RSSI_THRESHOLD1_ABOVE
;
1135 } else if ((rssi
< sq_thresh
->upper_threshold
[2]) &&
1136 (rssi
>= sq_thresh
->upper_threshold
[1])) {
1137 new_threshold
= WMI_RSSI_THRESHOLD2_ABOVE
;
1138 } else if ((rssi
< sq_thresh
->upper_threshold
[3]) &&
1139 (rssi
>= sq_thresh
->upper_threshold
[2])) {
1140 new_threshold
= WMI_RSSI_THRESHOLD3_ABOVE
;
1141 } else if ((rssi
< sq_thresh
->upper_threshold
[4]) &&
1142 (rssi
>= sq_thresh
->upper_threshold
[3])) {
1143 new_threshold
= WMI_RSSI_THRESHOLD4_ABOVE
;
1144 } else if ((rssi
< sq_thresh
->upper_threshold
[5]) &&
1145 (rssi
>= sq_thresh
->upper_threshold
[4])) {
1146 new_threshold
= WMI_RSSI_THRESHOLD5_ABOVE
;
1147 } else if (rssi
>= sq_thresh
->upper_threshold
[5]) {
1148 new_threshold
= WMI_RSSI_THRESHOLD6_ABOVE
;
1151 /* Lower threshold breached */
1152 if (rssi
> sq_thresh
->lower_threshold
[0]) {
1153 ath6kl_dbg(ATH6KL_DBG_WMI
,
1154 "spurious lower rssi threshold event: %d %d\n",
1155 rssi
, sq_thresh
->lower_threshold
[0]);
1156 } else if ((rssi
> sq_thresh
->lower_threshold
[1]) &&
1157 (rssi
<= sq_thresh
->lower_threshold
[0])) {
1158 new_threshold
= WMI_RSSI_THRESHOLD6_BELOW
;
1159 } else if ((rssi
> sq_thresh
->lower_threshold
[2]) &&
1160 (rssi
<= sq_thresh
->lower_threshold
[1])) {
1161 new_threshold
= WMI_RSSI_THRESHOLD5_BELOW
;
1162 } else if ((rssi
> sq_thresh
->lower_threshold
[3]) &&
1163 (rssi
<= sq_thresh
->lower_threshold
[2])) {
1164 new_threshold
= WMI_RSSI_THRESHOLD4_BELOW
;
1165 } else if ((rssi
> sq_thresh
->lower_threshold
[4]) &&
1166 (rssi
<= sq_thresh
->lower_threshold
[3])) {
1167 new_threshold
= WMI_RSSI_THRESHOLD3_BELOW
;
1168 } else if ((rssi
> sq_thresh
->lower_threshold
[5]) &&
1169 (rssi
<= sq_thresh
->lower_threshold
[4])) {
1170 new_threshold
= WMI_RSSI_THRESHOLD2_BELOW
;
1171 } else if (rssi
<= sq_thresh
->lower_threshold
[5]) {
1172 new_threshold
= WMI_RSSI_THRESHOLD1_BELOW
;
1176 /* Calculate and install the next set of thresholds */
1177 lower_rssi_threshold
= ath6kl_wmi_get_lower_threshold(rssi
, sq_thresh
,
1178 sq_thresh
->lower_threshold_valid_count
);
1179 upper_rssi_threshold
= ath6kl_wmi_get_upper_threshold(rssi
, sq_thresh
,
1180 sq_thresh
->upper_threshold_valid_count
);
1182 /* Issue a wmi command to install the thresholds */
1183 cmd
.thresh_above1_val
= a_cpu_to_sle16(upper_rssi_threshold
);
1184 cmd
.thresh_below1_val
= a_cpu_to_sle16(lower_rssi_threshold
);
1185 cmd
.weight
= sq_thresh
->weight
;
1186 cmd
.poll_time
= cpu_to_le32(sq_thresh
->polling_interval
);
1188 ret
= ath6kl_wmi_send_rssi_threshold_params(wmi
, &cmd
);
1190 ath6kl_err("unable to configure rssi thresholds\n");
1197 static int ath6kl_wmi_cac_event_rx(struct wmi
*wmi
, u8
*datap
, int len
)
1199 struct wmi_cac_event
*reply
;
1200 struct ieee80211_tspec_ie
*ts
;
1201 u16 active_tsids
, tsinfo
;
1205 if (len
< sizeof(struct wmi_cac_event
))
1208 reply
= (struct wmi_cac_event
*) datap
;
1210 if ((reply
->cac_indication
== CAC_INDICATION_ADMISSION_RESP
) &&
1211 (reply
->status_code
!= IEEE80211_TSPEC_STATUS_ADMISS_ACCEPTED
)) {
1213 ts
= (struct ieee80211_tspec_ie
*) &(reply
->tspec_suggestion
);
1214 tsinfo
= le16_to_cpu(ts
->tsinfo
);
1215 tsid
= (tsinfo
>> IEEE80211_WMM_IE_TSPEC_TID_SHIFT
) &
1216 IEEE80211_WMM_IE_TSPEC_TID_MASK
;
1218 ath6kl_wmi_delete_pstream_cmd(wmi
, reply
->ac
, tsid
);
1219 } else if (reply
->cac_indication
== CAC_INDICATION_NO_RESP
) {
1221 * Following assumes that there is only one outstanding
1222 * ADDTS request when this event is received
1224 spin_lock_bh(&wmi
->lock
);
1225 active_tsids
= wmi
->stream_exist_for_ac
[reply
->ac
];
1226 spin_unlock_bh(&wmi
->lock
);
1228 for (index
= 0; index
< sizeof(active_tsids
) * 8; index
++) {
1229 if ((active_tsids
>> index
) & 1)
1232 if (index
< (sizeof(active_tsids
) * 8))
1233 ath6kl_wmi_delete_pstream_cmd(wmi
, reply
->ac
, index
);
1237 * Clear active tsids and Add missing handling
1238 * for delete qos stream from AP
1240 else if (reply
->cac_indication
== CAC_INDICATION_DELETE
) {
1242 ts
= (struct ieee80211_tspec_ie
*) &(reply
->tspec_suggestion
);
1243 tsinfo
= le16_to_cpu(ts
->tsinfo
);
1244 ts_id
= ((tsinfo
>> IEEE80211_WMM_IE_TSPEC_TID_SHIFT
) &
1245 IEEE80211_WMM_IE_TSPEC_TID_MASK
);
1247 spin_lock_bh(&wmi
->lock
);
1248 wmi
->stream_exist_for_ac
[reply
->ac
] &= ~(1 << ts_id
);
1249 active_tsids
= wmi
->stream_exist_for_ac
[reply
->ac
];
1250 spin_unlock_bh(&wmi
->lock
);
1252 /* Indicate stream inactivity to driver layer only if all tsids
1253 * within this AC are deleted.
1255 if (!active_tsids
) {
1256 ath6kl_indicate_tx_activity(wmi
->parent_dev
, reply
->ac
,
1258 wmi
->fat_pipe_exist
&= ~(1 << reply
->ac
);
1265 static int ath6kl_wmi_send_snr_threshold_params(struct wmi
*wmi
,
1266 struct wmi_snr_threshold_params_cmd
*snr_cmd
)
1268 struct sk_buff
*skb
;
1269 struct wmi_snr_threshold_params_cmd
*cmd
;
1271 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
1275 cmd
= (struct wmi_snr_threshold_params_cmd
*) skb
->data
;
1276 memcpy(cmd
, snr_cmd
, sizeof(struct wmi_snr_threshold_params_cmd
));
1278 return ath6kl_wmi_cmd_send(wmi
, skb
, WMI_SNR_THRESHOLD_PARAMS_CMDID
,
1282 static int ath6kl_wmi_snr_threshold_event_rx(struct wmi
*wmi
, u8
*datap
,
1285 struct wmi_snr_threshold_event
*reply
;
1286 struct sq_threshold_params
*sq_thresh
;
1287 struct wmi_snr_threshold_params_cmd cmd
;
1288 enum wmi_snr_threshold_val new_threshold
;
1289 u8 upper_snr_threshold
, lower_snr_threshold
;
1293 if (len
< sizeof(struct wmi_snr_threshold_event
))
1296 reply
= (struct wmi_snr_threshold_event
*) datap
;
1298 new_threshold
= (enum wmi_snr_threshold_val
) reply
->range
;
1301 sq_thresh
= &wmi
->sq_threshld
[SIGNAL_QUALITY_METRICS_SNR
];
1304 * Identify the threshold breached and communicate that to the app.
1305 * After that install a new set of thresholds based on the signal
1306 * quality reported by the target.
1308 if (new_threshold
) {
1309 /* Upper threshold breached */
1310 if (snr
< sq_thresh
->upper_threshold
[0]) {
1311 ath6kl_dbg(ATH6KL_DBG_WMI
,
1312 "spurious upper snr threshold event: %d\n",
1314 } else if ((snr
< sq_thresh
->upper_threshold
[1]) &&
1315 (snr
>= sq_thresh
->upper_threshold
[0])) {
1316 new_threshold
= WMI_SNR_THRESHOLD1_ABOVE
;
1317 } else if ((snr
< sq_thresh
->upper_threshold
[2]) &&
1318 (snr
>= sq_thresh
->upper_threshold
[1])) {
1319 new_threshold
= WMI_SNR_THRESHOLD2_ABOVE
;
1320 } else if ((snr
< sq_thresh
->upper_threshold
[3]) &&
1321 (snr
>= sq_thresh
->upper_threshold
[2])) {
1322 new_threshold
= WMI_SNR_THRESHOLD3_ABOVE
;
1323 } else if (snr
>= sq_thresh
->upper_threshold
[3]) {
1324 new_threshold
= WMI_SNR_THRESHOLD4_ABOVE
;
1327 /* Lower threshold breached */
1328 if (snr
> sq_thresh
->lower_threshold
[0]) {
1329 ath6kl_dbg(ATH6KL_DBG_WMI
,
1330 "spurious lower snr threshold event: %d\n",
1331 sq_thresh
->lower_threshold
[0]);
1332 } else if ((snr
> sq_thresh
->lower_threshold
[1]) &&
1333 (snr
<= sq_thresh
->lower_threshold
[0])) {
1334 new_threshold
= WMI_SNR_THRESHOLD4_BELOW
;
1335 } else if ((snr
> sq_thresh
->lower_threshold
[2]) &&
1336 (snr
<= sq_thresh
->lower_threshold
[1])) {
1337 new_threshold
= WMI_SNR_THRESHOLD3_BELOW
;
1338 } else if ((snr
> sq_thresh
->lower_threshold
[3]) &&
1339 (snr
<= sq_thresh
->lower_threshold
[2])) {
1340 new_threshold
= WMI_SNR_THRESHOLD2_BELOW
;
1341 } else if (snr
<= sq_thresh
->lower_threshold
[3]) {
1342 new_threshold
= WMI_SNR_THRESHOLD1_BELOW
;
1346 /* Calculate and install the next set of thresholds */
1347 lower_snr_threshold
= ath6kl_wmi_get_lower_threshold(snr
, sq_thresh
,
1348 sq_thresh
->lower_threshold_valid_count
);
1349 upper_snr_threshold
= ath6kl_wmi_get_upper_threshold(snr
, sq_thresh
,
1350 sq_thresh
->upper_threshold_valid_count
);
1352 /* Issue a wmi command to install the thresholds */
1353 cmd
.thresh_above1_val
= upper_snr_threshold
;
1354 cmd
.thresh_below1_val
= lower_snr_threshold
;
1355 cmd
.weight
= sq_thresh
->weight
;
1356 cmd
.poll_time
= cpu_to_le32(sq_thresh
->polling_interval
);
1358 ath6kl_dbg(ATH6KL_DBG_WMI
,
1359 "snr: %d, threshold: %d, lower: %d, upper: %d\n",
1361 lower_snr_threshold
, upper_snr_threshold
);
1363 ret
= ath6kl_wmi_send_snr_threshold_params(wmi
, &cmd
);
1365 ath6kl_err("unable to configure snr threshold\n");
1372 static int ath6kl_wmi_aplist_event_rx(struct wmi
*wmi
, u8
*datap
, int len
)
1374 u16 ap_info_entry_size
;
1375 struct wmi_aplist_event
*ev
= (struct wmi_aplist_event
*) datap
;
1376 struct wmi_ap_info_v1
*ap_info_v1
;
1379 if (len
< sizeof(struct wmi_aplist_event
) ||
1380 ev
->ap_list_ver
!= APLIST_VER1
)
1383 ap_info_entry_size
= sizeof(struct wmi_ap_info_v1
);
1384 ap_info_v1
= (struct wmi_ap_info_v1
*) ev
->ap_list
;
1386 ath6kl_dbg(ATH6KL_DBG_WMI
,
1387 "number of APs in aplist event: %d\n", ev
->num_ap
);
1389 if (len
< (int) (sizeof(struct wmi_aplist_event
) +
1390 (ev
->num_ap
- 1) * ap_info_entry_size
))
1393 /* AP list version 1 contents */
1394 for (index
= 0; index
< ev
->num_ap
; index
++) {
1395 ath6kl_dbg(ATH6KL_DBG_WMI
, "AP#%d BSSID %pM Channel %d\n",
1396 index
, ap_info_v1
->bssid
, ap_info_v1
->channel
);
1403 int ath6kl_wmi_cmd_send(struct wmi
*wmi
, struct sk_buff
*skb
,
1404 enum wmi_cmd_id cmd_id
, enum wmi_sync_flag sync_flag
)
1406 struct wmi_cmd_hdr
*cmd_hdr
;
1407 enum htc_endpoint_id ep_id
= wmi
->ep_id
;
1410 if (WARN_ON(skb
== NULL
))
1413 if (sync_flag
>= END_WMIFLAG
) {
1418 if ((sync_flag
== SYNC_BEFORE_WMIFLAG
) ||
1419 (sync_flag
== SYNC_BOTH_WMIFLAG
)) {
1421 * Make sure all data currently queued is transmitted before
1422 * the cmd execution. Establish a new sync point.
1424 ath6kl_wmi_sync_point(wmi
);
1427 skb_push(skb
, sizeof(struct wmi_cmd_hdr
));
1429 cmd_hdr
= (struct wmi_cmd_hdr
*) skb
->data
;
1430 cmd_hdr
->cmd_id
= cpu_to_le16(cmd_id
);
1431 cmd_hdr
->info1
= 0; /* added for virtual interface */
1433 /* Only for OPT_TX_CMD, use BE endpoint. */
1434 if (cmd_id
== WMI_OPT_TX_FRAME_CMDID
) {
1435 ret
= ath6kl_wmi_data_hdr_add(wmi
, skb
, OPT_MSGTYPE
,
1436 false, false, 0, NULL
);
1441 ep_id
= ath6kl_ac2_endpoint_id(wmi
->parent_dev
, WMM_AC_BE
);
1444 ath6kl_control_tx(wmi
->parent_dev
, skb
, ep_id
);
1446 if ((sync_flag
== SYNC_AFTER_WMIFLAG
) ||
1447 (sync_flag
== SYNC_BOTH_WMIFLAG
)) {
1449 * Make sure all new data queued waits for the command to
1450 * execute. Establish a new sync point.
1452 ath6kl_wmi_sync_point(wmi
);
1458 int ath6kl_wmi_connect_cmd(struct wmi
*wmi
, enum network_type nw_type
,
1459 enum dot11_auth_mode dot11_auth_mode
,
1460 enum auth_mode auth_mode
,
1461 enum crypto_type pairwise_crypto
,
1462 u8 pairwise_crypto_len
,
1463 enum crypto_type group_crypto
,
1464 u8 group_crypto_len
, int ssid_len
, u8
*ssid
,
1465 u8
*bssid
, u16 channel
, u32 ctrl_flags
)
1467 struct sk_buff
*skb
;
1468 struct wmi_connect_cmd
*cc
;
1471 wmi
->traffic_class
= 100;
1473 if ((pairwise_crypto
== NONE_CRYPT
) && (group_crypto
!= NONE_CRYPT
))
1476 if ((pairwise_crypto
!= NONE_CRYPT
) && (group_crypto
== NONE_CRYPT
))
1479 skb
= ath6kl_wmi_get_new_buf(sizeof(struct wmi_connect_cmd
));
1483 cc
= (struct wmi_connect_cmd
*) skb
->data
;
1486 memcpy(cc
->ssid
, ssid
, ssid_len
);
1488 cc
->ssid_len
= ssid_len
;
1489 cc
->nw_type
= nw_type
;
1490 cc
->dot11_auth_mode
= dot11_auth_mode
;
1491 cc
->auth_mode
= auth_mode
;
1492 cc
->prwise_crypto_type
= pairwise_crypto
;
1493 cc
->prwise_crypto_len
= pairwise_crypto_len
;
1494 cc
->grp_crypto_type
= group_crypto
;
1495 cc
->grp_crypto_len
= group_crypto_len
;
1496 cc
->ch
= cpu_to_le16(channel
);
1497 cc
->ctrl_flags
= cpu_to_le32(ctrl_flags
);
1500 memcpy(cc
->bssid
, bssid
, ETH_ALEN
);
1502 wmi
->pair_crypto_type
= pairwise_crypto
;
1503 wmi
->grp_crypto_type
= group_crypto
;
1505 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_CONNECT_CMDID
, NO_SYNC_WMIFLAG
);
1510 int ath6kl_wmi_reconnect_cmd(struct wmi
*wmi
, u8
*bssid
, u16 channel
)
1512 struct sk_buff
*skb
;
1513 struct wmi_reconnect_cmd
*cc
;
1516 wmi
->traffic_class
= 100;
1518 skb
= ath6kl_wmi_get_new_buf(sizeof(struct wmi_reconnect_cmd
));
1522 cc
= (struct wmi_reconnect_cmd
*) skb
->data
;
1523 cc
->channel
= cpu_to_le16(channel
);
1526 memcpy(cc
->bssid
, bssid
, ETH_ALEN
);
1528 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_RECONNECT_CMDID
,
1534 int ath6kl_wmi_disconnect_cmd(struct wmi
*wmi
)
1538 wmi
->traffic_class
= 100;
1540 /* Disconnect command does not need to do a SYNC before. */
1541 ret
= ath6kl_wmi_simple_cmd(wmi
, WMI_DISCONNECT_CMDID
);
1546 int ath6kl_wmi_startscan_cmd(struct wmi
*wmi
, enum wmi_scan_type scan_type
,
1547 u32 force_fgscan
, u32 is_legacy
,
1548 u32 home_dwell_time
, u32 force_scan_interval
,
1549 s8 num_chan
, u16
*ch_list
)
1551 struct sk_buff
*skb
;
1552 struct wmi_start_scan_cmd
*sc
;
1556 size
= sizeof(struct wmi_start_scan_cmd
);
1558 if ((scan_type
!= WMI_LONG_SCAN
) && (scan_type
!= WMI_SHORT_SCAN
))
1561 if (num_chan
> WMI_MAX_CHANNELS
)
1565 size
+= sizeof(u16
) * (num_chan
- 1);
1567 skb
= ath6kl_wmi_get_new_buf(size
);
1571 sc
= (struct wmi_start_scan_cmd
*) skb
->data
;
1572 sc
->scan_type
= scan_type
;
1573 sc
->force_fg_scan
= cpu_to_le32(force_fgscan
);
1574 sc
->is_legacy
= cpu_to_le32(is_legacy
);
1575 sc
->home_dwell_time
= cpu_to_le32(home_dwell_time
);
1576 sc
->force_scan_intvl
= cpu_to_le32(force_scan_interval
);
1577 sc
->num_ch
= num_chan
;
1580 memcpy(sc
->ch_list
, ch_list
, num_chan
* sizeof(u16
));
1582 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_START_SCAN_CMDID
,
1588 int ath6kl_wmi_scanparams_cmd(struct wmi
*wmi
, u16 fg_start_sec
,
1589 u16 fg_end_sec
, u16 bg_sec
,
1590 u16 minact_chdw_msec
, u16 maxact_chdw_msec
,
1591 u16 pas_chdw_msec
, u8 short_scan_ratio
,
1592 u8 scan_ctrl_flag
, u32 max_dfsch_act_time
,
1593 u16 maxact_scan_per_ssid
)
1595 struct sk_buff
*skb
;
1596 struct wmi_scan_params_cmd
*sc
;
1599 skb
= ath6kl_wmi_get_new_buf(sizeof(*sc
));
1603 sc
= (struct wmi_scan_params_cmd
*) skb
->data
;
1604 sc
->fg_start_period
= cpu_to_le16(fg_start_sec
);
1605 sc
->fg_end_period
= cpu_to_le16(fg_end_sec
);
1606 sc
->bg_period
= cpu_to_le16(bg_sec
);
1607 sc
->minact_chdwell_time
= cpu_to_le16(minact_chdw_msec
);
1608 sc
->maxact_chdwell_time
= cpu_to_le16(maxact_chdw_msec
);
1609 sc
->pas_chdwell_time
= cpu_to_le16(pas_chdw_msec
);
1610 sc
->short_scan_ratio
= short_scan_ratio
;
1611 sc
->scan_ctrl_flags
= scan_ctrl_flag
;
1612 sc
->max_dfsch_act_time
= cpu_to_le32(max_dfsch_act_time
);
1613 sc
->maxact_scan_per_ssid
= cpu_to_le16(maxact_scan_per_ssid
);
1615 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_SET_SCAN_PARAMS_CMDID
,
1620 int ath6kl_wmi_bssfilter_cmd(struct wmi
*wmi
, u8 filter
, u32 ie_mask
)
1622 struct sk_buff
*skb
;
1623 struct wmi_bss_filter_cmd
*cmd
;
1626 if (filter
>= LAST_BSS_FILTER
)
1629 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
1633 cmd
= (struct wmi_bss_filter_cmd
*) skb
->data
;
1634 cmd
->bss_filter
= filter
;
1635 cmd
->ie_mask
= cpu_to_le32(ie_mask
);
1637 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_SET_BSS_FILTER_CMDID
,
1642 int ath6kl_wmi_probedssid_cmd(struct wmi
*wmi
, u8 index
, u8 flag
,
1643 u8 ssid_len
, u8
*ssid
)
1645 struct sk_buff
*skb
;
1646 struct wmi_probed_ssid_cmd
*cmd
;
1649 if (index
> MAX_PROBED_SSID_INDEX
)
1652 if (ssid_len
> sizeof(cmd
->ssid
))
1655 if ((flag
& (DISABLE_SSID_FLAG
| ANY_SSID_FLAG
)) && (ssid_len
> 0))
1658 if ((flag
& SPECIFIC_SSID_FLAG
) && !ssid_len
)
1661 if (flag
& SPECIFIC_SSID_FLAG
)
1662 wmi
->is_probe_ssid
= true;
1664 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
1668 cmd
= (struct wmi_probed_ssid_cmd
*) skb
->data
;
1669 cmd
->entry_index
= index
;
1671 cmd
->ssid_len
= ssid_len
;
1672 memcpy(cmd
->ssid
, ssid
, ssid_len
);
1674 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_SET_PROBED_SSID_CMDID
,
1679 int ath6kl_wmi_listeninterval_cmd(struct wmi
*wmi
, u16 listen_interval
,
1682 struct sk_buff
*skb
;
1683 struct wmi_listen_int_cmd
*cmd
;
1686 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
1690 cmd
= (struct wmi_listen_int_cmd
*) skb
->data
;
1691 cmd
->listen_intvl
= cpu_to_le16(listen_interval
);
1692 cmd
->num_beacons
= cpu_to_le16(listen_beacons
);
1694 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_SET_LISTEN_INT_CMDID
,
1699 int ath6kl_wmi_powermode_cmd(struct wmi
*wmi
, u8 pwr_mode
)
1701 struct sk_buff
*skb
;
1702 struct wmi_power_mode_cmd
*cmd
;
1705 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
1709 cmd
= (struct wmi_power_mode_cmd
*) skb
->data
;
1710 cmd
->pwr_mode
= pwr_mode
;
1711 wmi
->pwr_mode
= pwr_mode
;
1713 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_SET_POWER_MODE_CMDID
,
1718 int ath6kl_wmi_pmparams_cmd(struct wmi
*wmi
, u16 idle_period
,
1719 u16 ps_poll_num
, u16 dtim_policy
,
1720 u16 tx_wakeup_policy
, u16 num_tx_to_wakeup
,
1721 u16 ps_fail_event_policy
)
1723 struct sk_buff
*skb
;
1724 struct wmi_power_params_cmd
*pm
;
1727 skb
= ath6kl_wmi_get_new_buf(sizeof(*pm
));
1731 pm
= (struct wmi_power_params_cmd
*)skb
->data
;
1732 pm
->idle_period
= cpu_to_le16(idle_period
);
1733 pm
->pspoll_number
= cpu_to_le16(ps_poll_num
);
1734 pm
->dtim_policy
= cpu_to_le16(dtim_policy
);
1735 pm
->tx_wakeup_policy
= cpu_to_le16(tx_wakeup_policy
);
1736 pm
->num_tx_to_wakeup
= cpu_to_le16(num_tx_to_wakeup
);
1737 pm
->ps_fail_event_policy
= cpu_to_le16(ps_fail_event_policy
);
1739 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_SET_POWER_PARAMS_CMDID
,
1744 int ath6kl_wmi_disctimeout_cmd(struct wmi
*wmi
, u8 timeout
)
1746 struct sk_buff
*skb
;
1747 struct wmi_disc_timeout_cmd
*cmd
;
1750 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
1754 cmd
= (struct wmi_disc_timeout_cmd
*) skb
->data
;
1755 cmd
->discon_timeout
= timeout
;
1757 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_SET_DISC_TIMEOUT_CMDID
,
1762 int ath6kl_wmi_addkey_cmd(struct wmi
*wmi
, u8 key_index
,
1763 enum crypto_type key_type
,
1764 u8 key_usage
, u8 key_len
,
1765 u8
*key_rsc
, u8
*key_material
,
1766 u8 key_op_ctrl
, u8
*mac_addr
,
1767 enum wmi_sync_flag sync_flag
)
1769 struct sk_buff
*skb
;
1770 struct wmi_add_cipher_key_cmd
*cmd
;
1773 if ((key_index
> WMI_MAX_KEY_INDEX
) || (key_len
> WMI_MAX_KEY_LEN
) ||
1774 (key_material
== NULL
))
1777 if ((WEP_CRYPT
!= key_type
) && (NULL
== key_rsc
))
1780 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
1784 cmd
= (struct wmi_add_cipher_key_cmd
*) skb
->data
;
1785 cmd
->key_index
= key_index
;
1786 cmd
->key_type
= key_type
;
1787 cmd
->key_usage
= key_usage
;
1788 cmd
->key_len
= key_len
;
1789 memcpy(cmd
->key
, key_material
, key_len
);
1791 if (key_rsc
!= NULL
)
1792 memcpy(cmd
->key_rsc
, key_rsc
, sizeof(cmd
->key_rsc
));
1794 cmd
->key_op_ctrl
= key_op_ctrl
;
1797 memcpy(cmd
->key_mac_addr
, mac_addr
, ETH_ALEN
);
1799 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_ADD_CIPHER_KEY_CMDID
,
1805 int ath6kl_wmi_add_krk_cmd(struct wmi
*wmi
, u8
*krk
)
1807 struct sk_buff
*skb
;
1808 struct wmi_add_krk_cmd
*cmd
;
1811 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
1815 cmd
= (struct wmi_add_krk_cmd
*) skb
->data
;
1816 memcpy(cmd
->krk
, krk
, WMI_KRK_LEN
);
1818 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_ADD_KRK_CMDID
, NO_SYNC_WMIFLAG
);
1823 int ath6kl_wmi_deletekey_cmd(struct wmi
*wmi
, u8 key_index
)
1825 struct sk_buff
*skb
;
1826 struct wmi_delete_cipher_key_cmd
*cmd
;
1829 if (key_index
> WMI_MAX_KEY_INDEX
)
1832 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
1836 cmd
= (struct wmi_delete_cipher_key_cmd
*) skb
->data
;
1837 cmd
->key_index
= key_index
;
1839 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_DELETE_CIPHER_KEY_CMDID
,
1845 int ath6kl_wmi_setpmkid_cmd(struct wmi
*wmi
, const u8
*bssid
,
1846 const u8
*pmkid
, bool set
)
1848 struct sk_buff
*skb
;
1849 struct wmi_setpmkid_cmd
*cmd
;
1855 if (set
&& pmkid
== NULL
)
1858 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
1862 cmd
= (struct wmi_setpmkid_cmd
*) skb
->data
;
1863 memcpy(cmd
->bssid
, bssid
, ETH_ALEN
);
1865 memcpy(cmd
->pmkid
, pmkid
, sizeof(cmd
->pmkid
));
1866 cmd
->enable
= PMKID_ENABLE
;
1868 memset(cmd
->pmkid
, 0, sizeof(cmd
->pmkid
));
1869 cmd
->enable
= PMKID_DISABLE
;
1872 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_SET_PMKID_CMDID
,
1878 static int ath6kl_wmi_data_sync_send(struct wmi
*wmi
, struct sk_buff
*skb
,
1879 enum htc_endpoint_id ep_id
)
1881 struct wmi_data_hdr
*data_hdr
;
1884 if (WARN_ON(skb
== NULL
|| ep_id
== wmi
->ep_id
))
1887 skb_push(skb
, sizeof(struct wmi_data_hdr
));
1889 data_hdr
= (struct wmi_data_hdr
*) skb
->data
;
1890 data_hdr
->info
= SYNC_MSGTYPE
<< WMI_DATA_HDR_MSG_TYPE_SHIFT
;
1891 data_hdr
->info3
= 0;
1893 ret
= ath6kl_control_tx(wmi
->parent_dev
, skb
, ep_id
);
1898 static int ath6kl_wmi_sync_point(struct wmi
*wmi
)
1900 struct sk_buff
*skb
;
1901 struct wmi_sync_cmd
*cmd
;
1902 struct wmi_data_sync_bufs data_sync_bufs
[WMM_NUM_AC
];
1903 enum htc_endpoint_id ep_id
;
1904 u8 index
, num_pri_streams
= 0;
1907 memset(data_sync_bufs
, 0, sizeof(data_sync_bufs
));
1909 spin_lock_bh(&wmi
->lock
);
1911 for (index
= 0; index
< WMM_NUM_AC
; index
++) {
1912 if (wmi
->fat_pipe_exist
& (1 << index
)) {
1914 data_sync_bufs
[num_pri_streams
- 1].traffic_class
=
1919 spin_unlock_bh(&wmi
->lock
);
1921 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
1927 cmd
= (struct wmi_sync_cmd
*) skb
->data
;
1930 * In the SYNC cmd sent on the control Ep, send a bitmap
1931 * of the data eps on which the Data Sync will be sent
1933 cmd
->data_sync_map
= wmi
->fat_pipe_exist
;
1935 for (index
= 0; index
< num_pri_streams
; index
++) {
1936 data_sync_bufs
[index
].skb
= ath6kl_buf_alloc(0);
1937 if (data_sync_bufs
[index
].skb
== NULL
) {
1944 * If buffer allocation for any of the dataSync fails,
1945 * then do not send the Synchronize cmd on the control ep
1951 * Send sync cmd followed by sync data messages on all
1952 * endpoints being used
1954 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_SYNCHRONIZE_CMDID
,
1960 /* cmd buffer sent, we no longer own it */
1963 for (index
= 0; index
< num_pri_streams
; index
++) {
1965 if (WARN_ON(!data_sync_bufs
[index
].skb
))
1968 ep_id
= ath6kl_ac2_endpoint_id(wmi
->parent_dev
,
1969 data_sync_bufs
[index
].
1972 ath6kl_wmi_data_sync_send(wmi
, data_sync_bufs
[index
].skb
,
1978 data_sync_bufs
[index
].skb
= NULL
;
1982 /* free up any resources left over (possibly due to an error) */
1986 for (index
= 0; index
< num_pri_streams
; index
++) {
1987 if (data_sync_bufs
[index
].skb
!= NULL
) {
1988 dev_kfree_skb((struct sk_buff
*)data_sync_bufs
[index
].
1996 int ath6kl_wmi_create_pstream_cmd(struct wmi
*wmi
,
1997 struct wmi_create_pstream_cmd
*params
)
1999 struct sk_buff
*skb
;
2000 struct wmi_create_pstream_cmd
*cmd
;
2001 u8 fatpipe_exist_for_ac
= 0;
2003 s32 nominal_phy
= 0;
2006 if (!((params
->user_pri
< 8) &&
2007 (params
->user_pri
<= 0x7) &&
2008 (up_to_ac
[params
->user_pri
& 0x7] == params
->traffic_class
) &&
2009 (params
->traffic_direc
== UPLINK_TRAFFIC
||
2010 params
->traffic_direc
== DNLINK_TRAFFIC
||
2011 params
->traffic_direc
== BIDIR_TRAFFIC
) &&
2012 (params
->traffic_type
== TRAFFIC_TYPE_APERIODIC
||
2013 params
->traffic_type
== TRAFFIC_TYPE_PERIODIC
) &&
2014 (params
->voice_psc_cap
== DISABLE_FOR_THIS_AC
||
2015 params
->voice_psc_cap
== ENABLE_FOR_THIS_AC
||
2016 params
->voice_psc_cap
== ENABLE_FOR_ALL_AC
) &&
2017 (params
->tsid
== WMI_IMPLICIT_PSTREAM
||
2018 params
->tsid
<= WMI_MAX_THINSTREAM
))) {
2023 * Check nominal PHY rate is >= minimalPHY,
2024 * so that DUT can allow TSRS IE
2027 /* Get the physical rate (units of bps) */
2028 min_phy
= ((le32_to_cpu(params
->min_phy_rate
) / 1000) / 1000);
2030 /* Check minimal phy < nominal phy rate */
2031 if (params
->nominal_phy
>= min_phy
) {
2032 /* unit of 500 kbps */
2033 nominal_phy
= (params
->nominal_phy
* 1000) / 500;
2034 ath6kl_dbg(ATH6KL_DBG_WMI
,
2035 "TSRS IE enabled::MinPhy %x->NominalPhy ===> %x\n",
2036 min_phy
, nominal_phy
);
2038 params
->nominal_phy
= nominal_phy
;
2040 params
->nominal_phy
= 0;
2043 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
2047 ath6kl_dbg(ATH6KL_DBG_WMI
,
2048 "sending create_pstream_cmd: ac=%d tsid:%d\n",
2049 params
->traffic_class
, params
->tsid
);
2051 cmd
= (struct wmi_create_pstream_cmd
*) skb
->data
;
2052 memcpy(cmd
, params
, sizeof(*cmd
));
2054 /* This is an implicitly created Fat pipe */
2055 if ((u32
) params
->tsid
== (u32
) WMI_IMPLICIT_PSTREAM
) {
2056 spin_lock_bh(&wmi
->lock
);
2057 fatpipe_exist_for_ac
= (wmi
->fat_pipe_exist
&
2058 (1 << params
->traffic_class
));
2059 wmi
->fat_pipe_exist
|= (1 << params
->traffic_class
);
2060 spin_unlock_bh(&wmi
->lock
);
2062 /* explicitly created thin stream within a fat pipe */
2063 spin_lock_bh(&wmi
->lock
);
2064 fatpipe_exist_for_ac
= (wmi
->fat_pipe_exist
&
2065 (1 << params
->traffic_class
));
2066 wmi
->stream_exist_for_ac
[params
->traffic_class
] |=
2067 (1 << params
->tsid
);
2069 * If a thinstream becomes active, the fat pipe automatically
2072 wmi
->fat_pipe_exist
|= (1 << params
->traffic_class
);
2073 spin_unlock_bh(&wmi
->lock
);
2077 * Indicate activty change to driver layer only if this is the
2078 * first TSID to get created in this AC explicitly or an implicit
2079 * fat pipe is getting created.
2081 if (!fatpipe_exist_for_ac
)
2082 ath6kl_indicate_tx_activity(wmi
->parent_dev
,
2083 params
->traffic_class
, true);
2085 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_CREATE_PSTREAM_CMDID
,
2090 int ath6kl_wmi_delete_pstream_cmd(struct wmi
*wmi
, u8 traffic_class
, u8 tsid
)
2092 struct sk_buff
*skb
;
2093 struct wmi_delete_pstream_cmd
*cmd
;
2094 u16 active_tsids
= 0;
2097 if (traffic_class
> 3) {
2098 ath6kl_err("invalid traffic class: %d\n", traffic_class
);
2102 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
2106 cmd
= (struct wmi_delete_pstream_cmd
*) skb
->data
;
2107 cmd
->traffic_class
= traffic_class
;
2110 spin_lock_bh(&wmi
->lock
);
2111 active_tsids
= wmi
->stream_exist_for_ac
[traffic_class
];
2112 spin_unlock_bh(&wmi
->lock
);
2114 if (!(active_tsids
& (1 << tsid
))) {
2116 ath6kl_dbg(ATH6KL_DBG_WMI
,
2117 "TSID %d doesn't exist for traffic class: %d\n",
2118 tsid
, traffic_class
);
2122 ath6kl_dbg(ATH6KL_DBG_WMI
,
2123 "sending delete_pstream_cmd: traffic class: %d tsid=%d\n",
2124 traffic_class
, tsid
);
2126 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_DELETE_PSTREAM_CMDID
,
2127 SYNC_BEFORE_WMIFLAG
);
2129 spin_lock_bh(&wmi
->lock
);
2130 wmi
->stream_exist_for_ac
[traffic_class
] &= ~(1 << tsid
);
2131 active_tsids
= wmi
->stream_exist_for_ac
[traffic_class
];
2132 spin_unlock_bh(&wmi
->lock
);
2135 * Indicate stream inactivity to driver layer only if all tsids
2136 * within this AC are deleted.
2138 if (!active_tsids
) {
2139 ath6kl_indicate_tx_activity(wmi
->parent_dev
,
2140 traffic_class
, false);
2141 wmi
->fat_pipe_exist
&= ~(1 << traffic_class
);
2147 int ath6kl_wmi_set_ip_cmd(struct wmi
*wmi
, struct wmi_set_ip_cmd
*ip_cmd
)
2149 struct sk_buff
*skb
;
2150 struct wmi_set_ip_cmd
*cmd
;
2153 /* Multicast address are not valid */
2154 if ((*((u8
*) &ip_cmd
->ips
[0]) >= 0xE0) ||
2155 (*((u8
*) &ip_cmd
->ips
[1]) >= 0xE0))
2158 skb
= ath6kl_wmi_get_new_buf(sizeof(struct wmi_set_ip_cmd
));
2162 cmd
= (struct wmi_set_ip_cmd
*) skb
->data
;
2163 memcpy(cmd
, ip_cmd
, sizeof(struct wmi_set_ip_cmd
));
2165 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_SET_IP_CMDID
, NO_SYNC_WMIFLAG
);
2169 static int ath6kl_wmi_get_wow_list_event_rx(struct wmi
*wmi
, u8
* datap
,
2172 if (len
< sizeof(struct wmi_get_wow_list_reply
))
2178 static int ath6kl_wmi_cmd_send_xtnd(struct wmi
*wmi
, struct sk_buff
*skb
,
2179 enum wmix_command_id cmd_id
,
2180 enum wmi_sync_flag sync_flag
)
2182 struct wmix_cmd_hdr
*cmd_hdr
;
2185 skb_push(skb
, sizeof(struct wmix_cmd_hdr
));
2187 cmd_hdr
= (struct wmix_cmd_hdr
*) skb
->data
;
2188 cmd_hdr
->cmd_id
= cpu_to_le32(cmd_id
);
2190 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_EXTENSION_CMDID
, sync_flag
);
2195 int ath6kl_wmi_get_challenge_resp_cmd(struct wmi
*wmi
, u32 cookie
, u32 source
)
2197 struct sk_buff
*skb
;
2198 struct wmix_hb_challenge_resp_cmd
*cmd
;
2201 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
2205 cmd
= (struct wmix_hb_challenge_resp_cmd
*) skb
->data
;
2206 cmd
->cookie
= cpu_to_le32(cookie
);
2207 cmd
->source
= cpu_to_le32(source
);
2209 ret
= ath6kl_wmi_cmd_send_xtnd(wmi
, skb
, WMIX_HB_CHALLENGE_RESP_CMDID
,
2214 int ath6kl_wmi_get_stats_cmd(struct wmi
*wmi
)
2216 return ath6kl_wmi_simple_cmd(wmi
, WMI_GET_STATISTICS_CMDID
);
2219 int ath6kl_wmi_set_tx_pwr_cmd(struct wmi
*wmi
, u8 dbM
)
2221 struct sk_buff
*skb
;
2222 struct wmi_set_tx_pwr_cmd
*cmd
;
2225 skb
= ath6kl_wmi_get_new_buf(sizeof(struct wmi_set_tx_pwr_cmd
));
2229 cmd
= (struct wmi_set_tx_pwr_cmd
*) skb
->data
;
2232 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_SET_TX_PWR_CMDID
,
2238 int ath6kl_wmi_get_tx_pwr_cmd(struct wmi
*wmi
)
2240 return ath6kl_wmi_simple_cmd(wmi
, WMI_GET_TX_PWR_CMDID
);
2243 int ath6kl_wmi_set_lpreamble_cmd(struct wmi
*wmi
, u8 status
, u8 preamble_policy
)
2245 struct sk_buff
*skb
;
2246 struct wmi_set_lpreamble_cmd
*cmd
;
2249 skb
= ath6kl_wmi_get_new_buf(sizeof(struct wmi_set_lpreamble_cmd
));
2253 cmd
= (struct wmi_set_lpreamble_cmd
*) skb
->data
;
2254 cmd
->status
= status
;
2255 cmd
->preamble_policy
= preamble_policy
;
2257 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_SET_LPREAMBLE_CMDID
,
2262 int ath6kl_wmi_set_rts_cmd(struct wmi
*wmi
, u16 threshold
)
2264 struct sk_buff
*skb
;
2265 struct wmi_set_rts_cmd
*cmd
;
2268 skb
= ath6kl_wmi_get_new_buf(sizeof(struct wmi_set_rts_cmd
));
2272 cmd
= (struct wmi_set_rts_cmd
*) skb
->data
;
2273 cmd
->threshold
= cpu_to_le16(threshold
);
2275 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_SET_RTS_CMDID
, NO_SYNC_WMIFLAG
);
2279 int ath6kl_wmi_set_wmm_txop(struct wmi
*wmi
, enum wmi_txop_cfg cfg
)
2281 struct sk_buff
*skb
;
2282 struct wmi_set_wmm_txop_cmd
*cmd
;
2285 if (!((cfg
== WMI_TXOP_DISABLED
) || (cfg
== WMI_TXOP_ENABLED
)))
2288 skb
= ath6kl_wmi_get_new_buf(sizeof(struct wmi_set_wmm_txop_cmd
));
2292 cmd
= (struct wmi_set_wmm_txop_cmd
*) skb
->data
;
2293 cmd
->txop_enable
= cfg
;
2295 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_SET_WMM_TXOP_CMDID
,
2300 int ath6kl_wmi_set_keepalive_cmd(struct wmi
*wmi
, u8 keep_alive_intvl
)
2302 struct sk_buff
*skb
;
2303 struct wmi_set_keepalive_cmd
*cmd
;
2306 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
2310 cmd
= (struct wmi_set_keepalive_cmd
*) skb
->data
;
2311 cmd
->keep_alive_intvl
= keep_alive_intvl
;
2312 wmi
->keep_alive_intvl
= keep_alive_intvl
;
2314 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_SET_KEEPALIVE_CMDID
,
2319 s32
ath6kl_wmi_get_rate(s8 rate_index
)
2321 if (rate_index
== RATE_AUTO
)
2324 return wmi_rate_tbl
[(u32
) rate_index
][0];
2327 void ath6kl_wmi_node_return(struct wmi
*wmi
, struct bss
*bss
)
2330 wlan_node_return(&wmi
->parent_dev
->scan_table
, bss
);
2333 struct bss
*ath6kl_wmi_find_ssid_node(struct wmi
*wmi
, u8
* ssid
,
2334 u32 ssid_len
, bool is_wpa2
,
2337 struct bss
*node
= NULL
;
2339 node
= wlan_find_ssid_node(&wmi
->parent_dev
->scan_table
, ssid
,
2340 ssid_len
, is_wpa2
, match_ssid
);
2344 struct bss
*ath6kl_wmi_find_node(struct wmi
*wmi
, const u8
* mac_addr
)
2346 struct bss
*ni
= NULL
;
2348 ni
= wlan_find_node(&wmi
->parent_dev
->scan_table
, mac_addr
);
2353 void ath6kl_wmi_node_free(struct wmi
*wmi
, const u8
* mac_addr
)
2355 struct bss
*ni
= NULL
;
2357 ni
= wlan_find_node(&wmi
->parent_dev
->scan_table
, mac_addr
);
2359 wlan_node_reclaim(&wmi
->parent_dev
->scan_table
, ni
);
2364 static int ath6kl_wmi_get_pmkid_list_event_rx(struct wmi
*wmi
, u8
*datap
,
2367 struct wmi_pmkid_list_reply
*reply
;
2370 if (len
< sizeof(struct wmi_pmkid_list_reply
))
2373 reply
= (struct wmi_pmkid_list_reply
*)datap
;
2374 expected_len
= sizeof(reply
->num_pmkid
) +
2375 le32_to_cpu(reply
->num_pmkid
) * WMI_PMKID_LEN
;
2377 if (len
< expected_len
)
2383 static int ath6kl_wmi_addba_req_event_rx(struct wmi
*wmi
, u8
*datap
, int len
)
2385 struct wmi_addba_req_event
*cmd
= (struct wmi_addba_req_event
*) datap
;
2387 aggr_recv_addba_req_evt(wmi
->parent_dev
, cmd
->tid
,
2388 le16_to_cpu(cmd
->st_seq_no
), cmd
->win_sz
);
2393 static int ath6kl_wmi_delba_req_event_rx(struct wmi
*wmi
, u8
*datap
, int len
)
2395 struct wmi_delba_event
*cmd
= (struct wmi_delba_event
*) datap
;
2397 aggr_recv_delba_req_evt(wmi
->parent_dev
, cmd
->tid
);
2402 /* AP mode functions */
2403 static int ath6kl_wmi_pspoll_event_rx(struct wmi
*wmi
, u8
*datap
, int len
)
2405 struct wmi_pspoll_event
*ev
;
2407 if (len
< sizeof(struct wmi_pspoll_event
))
2410 ev
= (struct wmi_pspoll_event
*) datap
;
2412 ath6kl_pspoll_event(wmi
->parent_dev
, le16_to_cpu(ev
->aid
));
2417 static int ath6kl_wmi_dtimexpiry_event_rx(struct wmi
*wmi
, u8
*datap
, int len
)
2419 ath6kl_dtimexpiry_event(wmi
->parent_dev
);
2424 int ath6kl_wmi_set_pvb_cmd(struct wmi
*wmi
, u16 aid
, bool flag
)
2426 struct sk_buff
*skb
;
2427 struct wmi_ap_set_pvb_cmd
*cmd
;
2430 skb
= ath6kl_wmi_get_new_buf(sizeof(struct wmi_ap_set_pvb_cmd
));
2434 cmd
= (struct wmi_ap_set_pvb_cmd
*) skb
->data
;
2435 cmd
->aid
= cpu_to_le16(aid
);
2436 cmd
->flag
= cpu_to_le32(flag
);
2438 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_AP_SET_PVB_CMDID
,
2444 int ath6kl_wmi_set_rx_frame_format_cmd(struct wmi
*wmi
, u8 rx_meta_ver
,
2445 bool rx_dot11_hdr
, bool defrag_on_host
)
2447 struct sk_buff
*skb
;
2448 struct wmi_rx_frame_format_cmd
*cmd
;
2451 skb
= ath6kl_wmi_get_new_buf(sizeof(*cmd
));
2455 cmd
= (struct wmi_rx_frame_format_cmd
*) skb
->data
;
2456 cmd
->dot11_hdr
= rx_dot11_hdr
? 1 : 0;
2457 cmd
->defrag_on_host
= defrag_on_host
? 1 : 0;
2458 cmd
->meta_ver
= rx_meta_ver
;
2460 /* Delete the local aggr state, on host */
2461 ret
= ath6kl_wmi_cmd_send(wmi
, skb
, WMI_RX_FRAME_FORMAT_CMDID
,
2467 static int ath6kl_wmi_control_rx_xtnd(struct wmi
*wmi
, struct sk_buff
*skb
)
2469 struct wmix_cmd_hdr
*cmd
;
2475 if (skb
->len
< sizeof(struct wmix_cmd_hdr
)) {
2476 ath6kl_err("bad packet 1\n");
2477 wmi
->stat
.cmd_len_err
++;
2481 cmd
= (struct wmix_cmd_hdr
*) skb
->data
;
2482 id
= le32_to_cpu(cmd
->cmd_id
);
2484 skb_pull(skb
, sizeof(struct wmix_cmd_hdr
));
2490 case WMIX_HB_CHALLENGE_RESP_EVENTID
:
2492 case WMIX_DBGLOG_EVENTID
:
2495 ath6kl_err("unknown cmd id 0x%x\n", id
);
2496 wmi
->stat
.cmd_id_err
++;
2505 int ath6kl_wmi_control_rx(struct wmi
*wmi
, struct sk_buff
*skb
)
2507 struct wmi_cmd_hdr
*cmd
;
2513 if (WARN_ON(skb
== NULL
))
2516 if (skb
->len
< sizeof(struct wmi_cmd_hdr
)) {
2517 ath6kl_err("bad packet 1\n");
2519 wmi
->stat
.cmd_len_err
++;
2523 cmd
= (struct wmi_cmd_hdr
*) skb
->data
;
2524 id
= le16_to_cpu(cmd
->cmd_id
);
2526 skb_pull(skb
, sizeof(struct wmi_cmd_hdr
));
2531 ath6kl_dbg(ATH6KL_DBG_WMI
, "%s: wmi id: %d\n", __func__
, id
);
2532 ath6kl_dbg_dump(ATH6KL_DBG_RAW_BYTES
, "msg payload ", datap
, len
);
2535 case WMI_GET_BITRATE_CMDID
:
2536 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_GET_BITRATE_CMDID\n");
2537 ret
= ath6kl_wmi_bitrate_reply_rx(wmi
, datap
, len
);
2539 case WMI_GET_CHANNEL_LIST_CMDID
:
2540 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_GET_CHANNEL_LIST_CMDID\n");
2541 ret
= ath6kl_wmi_ch_list_reply_rx(wmi
, datap
, len
);
2543 case WMI_GET_TX_PWR_CMDID
:
2544 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_GET_TX_PWR_CMDID\n");
2545 ret
= ath6kl_wmi_tx_pwr_reply_rx(wmi
, datap
, len
);
2547 case WMI_READY_EVENTID
:
2548 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_READY_EVENTID\n");
2549 ret
= ath6kl_wmi_ready_event_rx(wmi
, datap
, len
);
2551 case WMI_CONNECT_EVENTID
:
2552 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_CONNECT_EVENTID\n");
2553 ret
= ath6kl_wmi_connect_event_rx(wmi
, datap
, len
);
2555 case WMI_DISCONNECT_EVENTID
:
2556 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_DISCONNECT_EVENTID\n");
2557 ret
= ath6kl_wmi_disconnect_event_rx(wmi
, datap
, len
);
2559 case WMI_PEER_NODE_EVENTID
:
2560 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_PEER_NODE_EVENTID\n");
2561 ret
= ath6kl_wmi_peer_node_event_rx(wmi
, datap
, len
);
2563 case WMI_TKIP_MICERR_EVENTID
:
2564 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_TKIP_MICERR_EVENTID\n");
2565 ret
= ath6kl_wmi_tkip_micerr_event_rx(wmi
, datap
, len
);
2567 case WMI_BSSINFO_EVENTID
:
2568 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_BSSINFO_EVENTID\n");
2569 ath6kl_wmi_convert_bssinfo_hdr2_to_hdr(skb
, datap
);
2570 ret
= ath6kl_wmi_bssinfo_event_rx(wmi
, skb
->data
, skb
->len
);
2572 case WMI_REGDOMAIN_EVENTID
:
2573 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_REGDOMAIN_EVENTID\n");
2575 case WMI_PSTREAM_TIMEOUT_EVENTID
:
2576 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_PSTREAM_TIMEOUT_EVENTID\n");
2577 ret
= ath6kl_wmi_pstream_timeout_event_rx(wmi
, datap
, len
);
2579 case WMI_NEIGHBOR_REPORT_EVENTID
:
2580 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_NEIGHBOR_REPORT_EVENTID\n");
2582 case WMI_SCAN_COMPLETE_EVENTID
:
2583 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_SCAN_COMPLETE_EVENTID\n");
2584 ret
= ath6kl_wmi_scan_complete_rx(wmi
, datap
, len
);
2586 case WMI_CMDERROR_EVENTID
:
2587 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_CMDERROR_EVENTID\n");
2588 ret
= ath6kl_wmi_error_event_rx(wmi
, datap
, len
);
2590 case WMI_REPORT_STATISTICS_EVENTID
:
2591 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_REPORT_STATISTICS_EVENTID\n");
2592 ret
= ath6kl_wmi_stats_event_rx(wmi
, datap
, len
);
2594 case WMI_RSSI_THRESHOLD_EVENTID
:
2595 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_RSSI_THRESHOLD_EVENTID\n");
2596 ret
= ath6kl_wmi_rssi_threshold_event_rx(wmi
, datap
, len
);
2598 case WMI_ERROR_REPORT_EVENTID
:
2599 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_ERROR_REPORT_EVENTID\n");
2601 case WMI_OPT_RX_FRAME_EVENTID
:
2602 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_OPT_RX_FRAME_EVENTID\n");
2603 ret
= ath6kl_wmi_opt_frame_event_rx(wmi
, datap
, len
);
2605 case WMI_REPORT_ROAM_TBL_EVENTID
:
2606 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_REPORT_ROAM_TBL_EVENTID\n");
2608 case WMI_EXTENSION_EVENTID
:
2609 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_EXTENSION_EVENTID\n");
2610 ret
= ath6kl_wmi_control_rx_xtnd(wmi
, skb
);
2612 case WMI_CAC_EVENTID
:
2613 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_CAC_EVENTID\n");
2614 ret
= ath6kl_wmi_cac_event_rx(wmi
, datap
, len
);
2616 case WMI_CHANNEL_CHANGE_EVENTID
:
2617 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_CHANNEL_CHANGE_EVENTID\n");
2619 case WMI_REPORT_ROAM_DATA_EVENTID
:
2620 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_REPORT_ROAM_DATA_EVENTID\n");
2622 case WMI_GET_FIXRATES_CMDID
:
2623 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_GET_FIXRATES_CMDID\n");
2624 ret
= ath6kl_wmi_ratemask_reply_rx(wmi
, datap
, len
);
2626 case WMI_TX_RETRY_ERR_EVENTID
:
2627 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_TX_RETRY_ERR_EVENTID\n");
2629 case WMI_SNR_THRESHOLD_EVENTID
:
2630 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_SNR_THRESHOLD_EVENTID\n");
2631 ret
= ath6kl_wmi_snr_threshold_event_rx(wmi
, datap
, len
);
2633 case WMI_LQ_THRESHOLD_EVENTID
:
2634 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_LQ_THRESHOLD_EVENTID\n");
2636 case WMI_APLIST_EVENTID
:
2637 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_APLIST_EVENTID\n");
2638 ret
= ath6kl_wmi_aplist_event_rx(wmi
, datap
, len
);
2640 case WMI_GET_KEEPALIVE_CMDID
:
2641 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_GET_KEEPALIVE_CMDID\n");
2642 ret
= ath6kl_wmi_keepalive_reply_rx(wmi
, datap
, len
);
2644 case WMI_GET_WOW_LIST_EVENTID
:
2645 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_GET_WOW_LIST_EVENTID\n");
2646 ret
= ath6kl_wmi_get_wow_list_event_rx(wmi
, datap
, len
);
2648 case WMI_GET_PMKID_LIST_EVENTID
:
2649 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_GET_PMKID_LIST_EVENTID\n");
2650 ret
= ath6kl_wmi_get_pmkid_list_event_rx(wmi
, datap
, len
);
2652 case WMI_PSPOLL_EVENTID
:
2653 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_PSPOLL_EVENTID\n");
2654 ret
= ath6kl_wmi_pspoll_event_rx(wmi
, datap
, len
);
2656 case WMI_DTIMEXPIRY_EVENTID
:
2657 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_DTIMEXPIRY_EVENTID\n");
2658 ret
= ath6kl_wmi_dtimexpiry_event_rx(wmi
, datap
, len
);
2660 case WMI_SET_PARAMS_REPLY_EVENTID
:
2661 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_SET_PARAMS_REPLY_EVENTID\n");
2663 case WMI_ADDBA_REQ_EVENTID
:
2664 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_ADDBA_REQ_EVENTID\n");
2665 ret
= ath6kl_wmi_addba_req_event_rx(wmi
, datap
, len
);
2667 case WMI_ADDBA_RESP_EVENTID
:
2668 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_ADDBA_RESP_EVENTID\n");
2670 case WMI_DELBA_REQ_EVENTID
:
2671 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_DELBA_REQ_EVENTID\n");
2672 ret
= ath6kl_wmi_delba_req_event_rx(wmi
, datap
, len
);
2674 case WMI_REPORT_BTCOEX_CONFIG_EVENTID
:
2675 ath6kl_dbg(ATH6KL_DBG_WMI
,
2676 "WMI_REPORT_BTCOEX_CONFIG_EVENTID\n");
2678 case WMI_REPORT_BTCOEX_STATS_EVENTID
:
2679 ath6kl_dbg(ATH6KL_DBG_WMI
,
2680 "WMI_REPORT_BTCOEX_STATS_EVENTID\n");
2682 case WMI_TX_COMPLETE_EVENTID
:
2683 ath6kl_dbg(ATH6KL_DBG_WMI
, "WMI_TX_COMPLETE_EVENTID\n");
2684 ret
= ath6kl_wmi_tx_complete_event_rx(datap
, len
);
2687 ath6kl_dbg(ATH6KL_DBG_WMI
, "unknown cmd id 0x%x\n", id
);
2688 wmi
->stat
.cmd_id_err
++;
2698 static void ath6kl_wmi_qos_state_init(struct wmi
*wmi
)
2703 spin_lock_bh(&wmi
->lock
);
2705 wmi
->fat_pipe_exist
= 0;
2706 memset(wmi
->stream_exist_for_ac
, 0, sizeof(wmi
->stream_exist_for_ac
));
2708 spin_unlock_bh(&wmi
->lock
);
2711 void *ath6kl_wmi_init(struct ath6kl
*dev
)
2715 wmi
= kzalloc(sizeof(struct wmi
), GFP_KERNEL
);
2719 spin_lock_init(&wmi
->lock
);
2721 wmi
->parent_dev
= dev
;
2723 ath6kl_wmi_qos_state_init(wmi
);
2725 wmi
->pwr_mode
= REC_POWER
;
2726 wmi
->phy_mode
= WMI_11G_MODE
;
2728 wmi
->pair_crypto_type
= NONE_CRYPT
;
2729 wmi
->grp_crypto_type
= NONE_CRYPT
;
2731 wmi
->ht_allowed
[A_BAND_24GHZ
] = 1;
2732 wmi
->ht_allowed
[A_BAND_5GHZ
] = 1;
2737 void ath6kl_wmi_shutdown(struct wmi
*wmi
)