1	// SPDX-License-Identifier: ISC
2	/*
3	* Copyright (c) 2012-2017 Qualcomm Atheros, Inc.
4	* Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
5	*/
6
7	#include <linux/moduleparam.h>
8	#include <linux/etherdevice.h>
9	#include <linux/if_arp.h>
10
11	#include "wil6210.h"
12	#include "txrx.h"
13	#include "wmi.h"
14	#include "trace.h"
15
16	/* set the default max assoc sta to max supported by driver */
17	uint max_assoc_sta = WIL6210_MAX_CID;
18	module_param(max_assoc_sta, uint, 0444);
19	MODULE_PARM_DESC(max_assoc_sta, " Max number of stations associated to the AP");
20
21	int agg_wsize; /* = 0; */
22	module_param(agg_wsize, int, 0644);
23	MODULE_PARM_DESC(agg_wsize, " Window size for Tx Block Ack after connect;"
24	" 0 - use default; < 0 - don't auto-establish");
25
26	u8 led_id = WIL_LED_INVALID_ID;
27	module_param(led_id, byte, 0444);
28	MODULE_PARM_DESC(led_id,
29	" 60G device led enablement. Set the led ID (0-2) to enable");
30
31	#define WIL_WAIT_FOR_SUSPEND_RESUME_COMP 200
32	#define WIL_WMI_PCP_STOP_TO_MS 5000
33
34	/**
35	* DOC: WMI event receiving - theory of operations
36	*
37	* When firmware about to report WMI event, it fills memory area
38	* in the mailbox and raises misc. IRQ. Thread interrupt handler invoked for
39	* the misc IRQ, function @wmi_recv_cmd called by thread IRQ handler.
40	*
41	* @wmi_recv_cmd reads event, allocates memory chunk and attaches it to the
42	* event list @wil->pending_wmi_ev. Then, work queue @wil->wmi_wq wakes up
43	* and handles events within the @wmi_event_worker. Every event get detached
44	* from list, processed and deleted.
45	*
46	* Purpose for this mechanism is to release IRQ thread; otherwise,
47	* if WMI event handling involves another WMI command flow, this 2-nd flow
48	* won't be completed because of blocked IRQ thread.
49	*/
50
51	/**
52	* DOC: Addressing - theory of operations
53	*
54	* There are several buses present on the WIL6210 card.
55	* Same memory areas are visible at different address on
56	* the different busses. There are 3 main bus masters:
57	* - MAC CPU (ucode)
58	* - User CPU (firmware)
59	* - AHB (host)
60	*
61	* On the PCI bus, there is one BAR (BAR0) of 2Mb size, exposing
62	* AHB addresses starting from 0x880000
63	*
64	* Internally, firmware uses addresses that allow faster access but
65	* are invisible from the host. To read from these addresses, alternative
66	* AHB address must be used.
67	*/
68
69	/* sparrow_fw_mapping provides memory remapping table for sparrow
70	*
71	* array size should be in sync with the declaration in the wil6210.h
72	*
73	* Sparrow memory mapping:
74	* Linker address PCI/Host address
75	* 0x880000 .. 0xa80000 2Mb BAR0
76	* 0x800000 .. 0x808000 0x900000 .. 0x908000 32k DCCM
77	* 0x840000 .. 0x860000 0x908000 .. 0x928000 128k PERIPH
78	*/
79	const struct fw_map sparrow_fw_mapping[] = {
80	/* FW code RAM 256k */
81	{0x000000, 0x040000, 0x8c0000, "fw_code", true, true},
82	/* FW data RAM 32k */
83	{0x800000, 0x808000, 0x900000, "fw_data", true, true},
84	/* periph data 128k */
85	{0x840000, 0x860000, 0x908000, "fw_peri", true, true},
86	/* various RGF 40k */
87	{0x880000, 0x88a000, 0x880000, "rgf", true, true},
88	/* AGC table 4k */
89	{0x88a000, 0x88b000, 0x88a000, "AGC_tbl", true, true},
90	/* Pcie_ext_rgf 4k */
91	{0x88b000, 0x88c000, 0x88b000, "rgf_ext", true, true},
92	/* mac_ext_rgf 512b */
93	{0x88c000, 0x88c200, 0x88c000, "mac_rgf_ext", true, true},
94	/* upper area 548k */
95	{0x8c0000, 0x949000, 0x8c0000, "upper", true, true},
96	/* UCODE areas - accessible by debugfs blobs but not by
97	* wmi_addr_remap. UCODE areas MUST be added AFTER FW areas!
98	*/
99	/* ucode code RAM 128k */
100	{0x000000, 0x020000, 0x920000, "uc_code", false, false},
101	/* ucode data RAM 16k */
102	{0x800000, 0x804000, 0x940000, "uc_data", false, false},
103	};
104
105	/* sparrow_d0_mac_rgf_ext - mac_rgf_ext section for Sparrow D0
106	* it is a bit larger to support extra features
107	*/
108	const struct fw_map sparrow_d0_mac_rgf_ext = {
109	0x88c000, 0x88c500, 0x88c000, "mac_rgf_ext", true, true
110	};
111
112	/* talyn_fw_mapping provides memory remapping table for Talyn
113	*
114	* array size should be in sync with the declaration in the wil6210.h
115	*
116	* Talyn memory mapping:
117	* Linker address PCI/Host address
118	* 0x880000 .. 0xc80000 4Mb BAR0
119	* 0x800000 .. 0x820000 0xa00000 .. 0xa20000 128k DCCM
120	* 0x840000 .. 0x858000 0xa20000 .. 0xa38000 96k PERIPH
121	*/
122	const struct fw_map talyn_fw_mapping[] = {
123	/* FW code RAM 1M */
124	{.from: 0x000000, .to: 0x100000, .host: 0x900000, .name: "fw_code", .fw: true, .crash_dump: true},
125	/* FW data RAM 128k */
126	{0x800000, 0x820000, 0xa00000, "fw_data", true, true},
127	/* periph. data RAM 96k */
128	{0x840000, 0x858000, 0xa20000, "fw_peri", true, true},
129	/* various RGF 40k */
130	{0x880000, 0x88a000, 0x880000, "rgf", true, true},
131	/* AGC table 4k */
132	{0x88a000, 0x88b000, 0x88a000, "AGC_tbl", true, true},
133	/* Pcie_ext_rgf 4k */
134	{0x88b000, 0x88c000, 0x88b000, "rgf_ext", true, true},
135	/* mac_ext_rgf 1344b */
136	{0x88c000, 0x88c540, 0x88c000, "mac_rgf_ext", true, true},
137	/* ext USER RGF 4k */
138	{0x88d000, 0x88e000, 0x88d000, "ext_user_rgf", true, true},
139	/* OTP 4k */
140	{0x8a0000, 0x8a1000, 0x8a0000, "otp", true, false},
141	/* DMA EXT RGF 64k */
142	{0x8b0000, 0x8c0000, 0x8b0000, "dma_ext_rgf", true, true},
143	/* upper area 1536k */
144	{0x900000, 0xa80000, 0x900000, "upper", true, true},
145	/* UCODE areas - accessible by debugfs blobs but not by
146	* wmi_addr_remap. UCODE areas MUST be added AFTER FW areas!
147	*/
148	/* ucode code RAM 256k */
149	{0x000000, 0x040000, 0xa38000, "uc_code", false, false},
150	/* ucode data RAM 32k */
151	{0x800000, 0x808000, 0xa78000, "uc_data", false, false},
152	};
153
154	/* talyn_mb_fw_mapping provides memory remapping table for Talyn-MB
155	*
156	* array size should be in sync with the declaration in the wil6210.h
157	*
158	* Talyn MB memory mapping:
159	* Linker address PCI/Host address
160	* 0x880000 .. 0xc80000 4Mb BAR0
161	* 0x800000 .. 0x820000 0xa00000 .. 0xa20000 128k DCCM
162	* 0x840000 .. 0x858000 0xa20000 .. 0xa38000 96k PERIPH
163	*/
164	const struct fw_map talyn_mb_fw_mapping[] = {
165	/* FW code RAM 768k */
166	{0x000000, 0x0c0000, 0x900000, "fw_code", true, true},
167	/* FW data RAM 128k */
168	{0x800000, 0x820000, 0xa00000, "fw_data", true, true},
169	/* periph. data RAM 96k */
170	{0x840000, 0x858000, 0xa20000, "fw_peri", true, true},
171	/* various RGF 40k */
172	{0x880000, 0x88a000, 0x880000, "rgf", true, true},
173	/* AGC table 4k */
174	{0x88a000, 0x88b000, 0x88a000, "AGC_tbl", true, true},
175	/* Pcie_ext_rgf 4k */
176	{0x88b000, 0x88c000, 0x88b000, "rgf_ext", true, true},
177	/* mac_ext_rgf 2256b */
178	{0x88c000, 0x88c8d0, 0x88c000, "mac_rgf_ext", true, true},
179	/* ext USER RGF 4k */
180	{0x88d000, 0x88e000, 0x88d000, "ext_user_rgf", true, true},
181	/* SEC PKA 16k */
182	{0x890000, 0x894000, 0x890000, "sec_pka", true, true},
183	/* SEC KDF RGF 3096b */
184	{0x898000, 0x898c18, 0x898000, "sec_kdf_rgf", true, true},
185	/* SEC MAIN 2124b */
186	{0x89a000, 0x89a84c, 0x89a000, "sec_main", true, true},
187	/* OTP 4k */
188	{0x8a0000, 0x8a1000, 0x8a0000, "otp", true, false},
189	/* DMA EXT RGF 64k */
190	{0x8b0000, 0x8c0000, 0x8b0000, "dma_ext_rgf", true, true},
191	/* DUM USER RGF 528b */
192	{0x8c0000, 0x8c0210, 0x8c0000, "dum_user_rgf", true, true},
193	/* DMA OFU 296b */
194	{0x8c2000, 0x8c2128, 0x8c2000, "dma_ofu", true, true},
195	/* ucode debug 256b */
196	{0x8c3000, 0x8c3100, 0x8c3000, "ucode_debug", true, true},
197	/* upper area 1536k */
198	{0x900000, 0xa80000, 0x900000, "upper", true, true},
199	/* UCODE areas - accessible by debugfs blobs but not by
200	* wmi_addr_remap. UCODE areas MUST be added AFTER FW areas!
201	*/
202	/* ucode code RAM 256k */
203	{0x000000, 0x040000, 0xa38000, "uc_code", false, false},
204	/* ucode data RAM 32k */
205	{0x800000, 0x808000, 0xa78000, "uc_data", false, false},
206	};
207
208	struct fw_map fw_mapping[MAX_FW_MAPPING_TABLE_SIZE];
209
210	struct blink_on_off_time led_blink_time[] = {
211	{WIL_LED_BLINK_ON_SLOW_MS, WIL_LED_BLINK_OFF_SLOW_MS},
212	{WIL_LED_BLINK_ON_MED_MS, WIL_LED_BLINK_OFF_MED_MS},
213	{WIL_LED_BLINK_ON_FAST_MS, WIL_LED_BLINK_OFF_FAST_MS},
214	};
215
216	struct auth_no_hdr {
217	__le16 auth_alg;
218	__le16 auth_transaction;
219	__le16 status_code;
220	/* possibly followed by Challenge text */
221	u8 variable[];
222	} __packed;
223
224	u8 led_polarity = LED_POLARITY_LOW_ACTIVE;
225
226	/**
227	* wmi_addr_remap - return AHB address for given firmware internal (linker) address
228	* @x: internal address
229	* If address have no valid AHB mapping, return 0
230	*/
231	static u32 wmi_addr_remap(u32 x)
232	{
233	uint i;
234
235	for (i = 0; i < ARRAY_SIZE(fw_mapping); i++) {
236	if (fw_mapping[i].fw &&
237	((x >= fw_mapping[i].from) && (x < fw_mapping[i].to)))
238	return x + fw_mapping[i].host - fw_mapping[i].from;
239	}
240
241	return 0;
242	}
243
244	/**
245	* wil_find_fw_mapping - find fw_mapping entry by section name
246	* @section: section name
247	*
248	* Return pointer to section or NULL if not found
249	*/
250	struct fw_map *wil_find_fw_mapping(const char *section)
251	{
252	int i;
253
254	for (i = 0; i < ARRAY_SIZE(fw_mapping); i++)
255	if (fw_mapping[i].name &&
256	!strcmp(section, fw_mapping[i].name))
257	return &fw_mapping[i];
258
259	return NULL;
260	}
261
262	/**
263	* wmi_buffer_block - Check address validity for WMI buffer; remap if needed
264	* @wil: driver data
265	* @ptr_: internal (linker) fw/ucode address
266	* @size: if non zero, validate the block does not
267	* exceed the device memory (bar)
268	*
269	* Valid buffer should be DWORD aligned
270	*
271	* return address for accessing buffer from the host;
272	* if buffer is not valid, return NULL.
273	*/
274	void __iomem *wmi_buffer_block(struct wil6210_priv *wil, __le32 ptr_, u32 size)
275	{
276	u32 off;
277	u32 ptr = le32_to_cpu(ptr_);
278
279	if (ptr % 4)
280	return NULL;
281
282	ptr = wmi_addr_remap(x: ptr);
283	if (ptr < WIL6210_FW_HOST_OFF)
284	return NULL;
285
286	off = HOSTADDR(ptr);
287	if (off > wil->bar_size - 4)
288	return NULL;
289	if (size && ((off + size > wil->bar_size) || (off + size < off)))
290	return NULL;
291
292	return wil->csr + off;
293	}
294
295	void __iomem *wmi_buffer(struct wil6210_priv *wil, __le32 ptr_)
296	{
297	return wmi_buffer_block(wil, ptr_, size: 0);
298	}
299
300	/* Check address validity */
301	void __iomem *wmi_addr(struct wil6210_priv *wil, u32 ptr)
302	{
303	u32 off;
304
305	if (ptr % 4)
306	return NULL;
307
308	if (ptr < WIL6210_FW_HOST_OFF)
309	return NULL;
310
311	off = HOSTADDR(ptr);
312	if (off > wil->bar_size - 4)
313	return NULL;
314
315	return wil->csr + off;
316	}
317
318	int wmi_read_hdr(struct wil6210_priv *wil, __le32 ptr,
319	struct wil6210_mbox_hdr *hdr)
320	{
321	void __iomem *src = wmi_buffer(wil, ptr_: ptr);
322
323	if (!src)
324	return -EINVAL;
325
326	wil_memcpy_fromio_32(dst: hdr, src, count: sizeof(*hdr));
327
328	return 0;
329	}
330
331	static const char *cmdid2name(u16 cmdid)
332	{
333	switch (cmdid) {
334	case WMI_NOTIFY_REQ_CMDID:
335	return "WMI_NOTIFY_REQ_CMD";
336	case WMI_START_SCAN_CMDID:
337	return "WMI_START_SCAN_CMD";
338	case WMI_CONNECT_CMDID:
339	return "WMI_CONNECT_CMD";
340	case WMI_DISCONNECT_CMDID:
341	return "WMI_DISCONNECT_CMD";
342	case WMI_SW_TX_REQ_CMDID:
343	return "WMI_SW_TX_REQ_CMD";
344	case WMI_GET_RF_SECTOR_PARAMS_CMDID:
345	return "WMI_GET_RF_SECTOR_PARAMS_CMD";
346	case WMI_SET_RF_SECTOR_PARAMS_CMDID:
347	return "WMI_SET_RF_SECTOR_PARAMS_CMD";
348	case WMI_GET_SELECTED_RF_SECTOR_INDEX_CMDID:
349	return "WMI_GET_SELECTED_RF_SECTOR_INDEX_CMD";
350	case WMI_SET_SELECTED_RF_SECTOR_INDEX_CMDID:
351	return "WMI_SET_SELECTED_RF_SECTOR_INDEX_CMD";
352	case WMI_BRP_SET_ANT_LIMIT_CMDID:
353	return "WMI_BRP_SET_ANT_LIMIT_CMD";
354	case WMI_TOF_SESSION_START_CMDID:
355	return "WMI_TOF_SESSION_START_CMD";
356	case WMI_AOA_MEAS_CMDID:
357	return "WMI_AOA_MEAS_CMD";
358	case WMI_PMC_CMDID:
359	return "WMI_PMC_CMD";
360	case WMI_TOF_GET_TX_RX_OFFSET_CMDID:
361	return "WMI_TOF_GET_TX_RX_OFFSET_CMD";
362	case WMI_TOF_SET_TX_RX_OFFSET_CMDID:
363	return "WMI_TOF_SET_TX_RX_OFFSET_CMD";
364	case WMI_VRING_CFG_CMDID:
365	return "WMI_VRING_CFG_CMD";
366	case WMI_BCAST_VRING_CFG_CMDID:
367	return "WMI_BCAST_VRING_CFG_CMD";
368	case WMI_TRAFFIC_SUSPEND_CMDID:
369	return "WMI_TRAFFIC_SUSPEND_CMD";
370	case WMI_TRAFFIC_RESUME_CMDID:
371	return "WMI_TRAFFIC_RESUME_CMD";
372	case WMI_ECHO_CMDID:
373	return "WMI_ECHO_CMD";
374	case WMI_SET_MAC_ADDRESS_CMDID:
375	return "WMI_SET_MAC_ADDRESS_CMD";
376	case WMI_LED_CFG_CMDID:
377	return "WMI_LED_CFG_CMD";
378	case WMI_PCP_START_CMDID:
379	return "WMI_PCP_START_CMD";
380	case WMI_PCP_STOP_CMDID:
381	return "WMI_PCP_STOP_CMD";
382	case WMI_SET_SSID_CMDID:
383	return "WMI_SET_SSID_CMD";
384	case WMI_GET_SSID_CMDID:
385	return "WMI_GET_SSID_CMD";
386	case WMI_SET_PCP_CHANNEL_CMDID:
387	return "WMI_SET_PCP_CHANNEL_CMD";
388	case WMI_GET_PCP_CHANNEL_CMDID:
389	return "WMI_GET_PCP_CHANNEL_CMD";
390	case WMI_P2P_CFG_CMDID:
391	return "WMI_P2P_CFG_CMD";
392	case WMI_PORT_ALLOCATE_CMDID:
393	return "WMI_PORT_ALLOCATE_CMD";
394	case WMI_PORT_DELETE_CMDID:
395	return "WMI_PORT_DELETE_CMD";
396	case WMI_START_LISTEN_CMDID:
397	return "WMI_START_LISTEN_CMD";
398	case WMI_START_SEARCH_CMDID:
399	return "WMI_START_SEARCH_CMD";
400	case WMI_DISCOVERY_STOP_CMDID:
401	return "WMI_DISCOVERY_STOP_CMD";
402	case WMI_DELETE_CIPHER_KEY_CMDID:
403	return "WMI_DELETE_CIPHER_KEY_CMD";
404	case WMI_ADD_CIPHER_KEY_CMDID:
405	return "WMI_ADD_CIPHER_KEY_CMD";
406	case WMI_SET_APPIE_CMDID:
407	return "WMI_SET_APPIE_CMD";
408	case WMI_CFG_RX_CHAIN_CMDID:
409	return "WMI_CFG_RX_CHAIN_CMD";
410	case WMI_TEMP_SENSE_CMDID:
411	return "WMI_TEMP_SENSE_CMD";
412	case WMI_DEL_STA_CMDID:
413	return "WMI_DEL_STA_CMD";
414	case WMI_DISCONNECT_STA_CMDID:
415	return "WMI_DISCONNECT_STA_CMD";
416	case WMI_RING_BA_EN_CMDID:
417	return "WMI_RING_BA_EN_CMD";
418	case WMI_RING_BA_DIS_CMDID:
419	return "WMI_RING_BA_DIS_CMD";
420	case WMI_RCP_DELBA_CMDID:
421	return "WMI_RCP_DELBA_CMD";
422	case WMI_RCP_ADDBA_RESP_CMDID:
423	return "WMI_RCP_ADDBA_RESP_CMD";
424	case WMI_RCP_ADDBA_RESP_EDMA_CMDID:
425	return "WMI_RCP_ADDBA_RESP_EDMA_CMD";
426	case WMI_PS_DEV_PROFILE_CFG_CMDID:
427	return "WMI_PS_DEV_PROFILE_CFG_CMD";
428	case WMI_SET_MGMT_RETRY_LIMIT_CMDID:
429	return "WMI_SET_MGMT_RETRY_LIMIT_CMD";
430	case WMI_GET_MGMT_RETRY_LIMIT_CMDID:
431	return "WMI_GET_MGMT_RETRY_LIMIT_CMD";
432	case WMI_ABORT_SCAN_CMDID:
433	return "WMI_ABORT_SCAN_CMD";
434	case WMI_NEW_STA_CMDID:
435	return "WMI_NEW_STA_CMD";
436	case WMI_SET_THERMAL_THROTTLING_CFG_CMDID:
437	return "WMI_SET_THERMAL_THROTTLING_CFG_CMD";
438	case WMI_GET_THERMAL_THROTTLING_CFG_CMDID:
439	return "WMI_GET_THERMAL_THROTTLING_CFG_CMD";
440	case WMI_LINK_MAINTAIN_CFG_WRITE_CMDID:
441	return "WMI_LINK_MAINTAIN_CFG_WRITE_CMD";
442	case WMI_LO_POWER_CALIB_FROM_OTP_CMDID:
443	return "WMI_LO_POWER_CALIB_FROM_OTP_CMD";
444	case WMI_START_SCHED_SCAN_CMDID:
445	return "WMI_START_SCHED_SCAN_CMD";
446	case WMI_STOP_SCHED_SCAN_CMDID:
447	return "WMI_STOP_SCHED_SCAN_CMD";
448	case WMI_TX_STATUS_RING_ADD_CMDID:
449	return "WMI_TX_STATUS_RING_ADD_CMD";
450	case WMI_RX_STATUS_RING_ADD_CMDID:
451	return "WMI_RX_STATUS_RING_ADD_CMD";
452	case WMI_TX_DESC_RING_ADD_CMDID:
453	return "WMI_TX_DESC_RING_ADD_CMD";
454	case WMI_RX_DESC_RING_ADD_CMDID:
455	return "WMI_RX_DESC_RING_ADD_CMD";
456	case WMI_BCAST_DESC_RING_ADD_CMDID:
457	return "WMI_BCAST_DESC_RING_ADD_CMD";
458	case WMI_CFG_DEF_RX_OFFLOAD_CMDID:
459	return "WMI_CFG_DEF_RX_OFFLOAD_CMD";
460	case WMI_LINK_STATS_CMDID:
461	return "WMI_LINK_STATS_CMD";
462	case WMI_SW_TX_REQ_EXT_CMDID:
463	return "WMI_SW_TX_REQ_EXT_CMDID";
464	case WMI_FT_AUTH_CMDID:
465	return "WMI_FT_AUTH_CMD";
466	case WMI_FT_REASSOC_CMDID:
467	return "WMI_FT_REASSOC_CMD";
468	case WMI_UPDATE_FT_IES_CMDID:
469	return "WMI_UPDATE_FT_IES_CMD";
470	case WMI_RBUFCAP_CFG_CMDID:
471	return "WMI_RBUFCAP_CFG_CMD";
472	case WMI_TEMP_SENSE_ALL_CMDID:
473	return "WMI_TEMP_SENSE_ALL_CMDID";
474	case WMI_SET_LINK_MONITOR_CMDID:
475	return "WMI_SET_LINK_MONITOR_CMD";
476	default:
477	return "Untracked CMD";
478	}
479	}
480
481	static const char *eventid2name(u16 eventid)
482	{
483	switch (eventid) {
484	case WMI_NOTIFY_REQ_DONE_EVENTID:
485	return "WMI_NOTIFY_REQ_DONE_EVENT";
486	case WMI_DISCONNECT_EVENTID:
487	return "WMI_DISCONNECT_EVENT";
488	case WMI_SW_TX_COMPLETE_EVENTID:
489	return "WMI_SW_TX_COMPLETE_EVENT";
490	case WMI_GET_RF_SECTOR_PARAMS_DONE_EVENTID:
491	return "WMI_GET_RF_SECTOR_PARAMS_DONE_EVENT";
492	case WMI_SET_RF_SECTOR_PARAMS_DONE_EVENTID:
493	return "WMI_SET_RF_SECTOR_PARAMS_DONE_EVENT";
494	case WMI_GET_SELECTED_RF_SECTOR_INDEX_DONE_EVENTID:
495	return "WMI_GET_SELECTED_RF_SECTOR_INDEX_DONE_EVENT";
496	case WMI_SET_SELECTED_RF_SECTOR_INDEX_DONE_EVENTID:
497	return "WMI_SET_SELECTED_RF_SECTOR_INDEX_DONE_EVENT";
498	case WMI_BRP_SET_ANT_LIMIT_EVENTID:
499	return "WMI_BRP_SET_ANT_LIMIT_EVENT";
500	case WMI_FW_READY_EVENTID:
501	return "WMI_FW_READY_EVENT";
502	case WMI_TRAFFIC_RESUME_EVENTID:
503	return "WMI_TRAFFIC_RESUME_EVENT";
504	case WMI_TOF_GET_TX_RX_OFFSET_EVENTID:
505	return "WMI_TOF_GET_TX_RX_OFFSET_EVENT";
506	case WMI_TOF_SET_TX_RX_OFFSET_EVENTID:
507	return "WMI_TOF_SET_TX_RX_OFFSET_EVENT";
508	case WMI_VRING_CFG_DONE_EVENTID:
509	return "WMI_VRING_CFG_DONE_EVENT";
510	case WMI_READY_EVENTID:
511	return "WMI_READY_EVENT";
512	case WMI_RX_MGMT_PACKET_EVENTID:
513	return "WMI_RX_MGMT_PACKET_EVENT";
514	case WMI_TX_MGMT_PACKET_EVENTID:
515	return "WMI_TX_MGMT_PACKET_EVENT";
516	case WMI_SCAN_COMPLETE_EVENTID:
517	return "WMI_SCAN_COMPLETE_EVENT";
518	case WMI_ACS_PASSIVE_SCAN_COMPLETE_EVENTID:
519	return "WMI_ACS_PASSIVE_SCAN_COMPLETE_EVENT";
520	case WMI_CONNECT_EVENTID:
521	return "WMI_CONNECT_EVENT";
522	case WMI_EAPOL_RX_EVENTID:
523	return "WMI_EAPOL_RX_EVENT";
524	case WMI_BA_STATUS_EVENTID:
525	return "WMI_BA_STATUS_EVENT";
526	case WMI_RCP_ADDBA_REQ_EVENTID:
527	return "WMI_RCP_ADDBA_REQ_EVENT";
528	case WMI_DELBA_EVENTID:
529	return "WMI_DELBA_EVENT";
530	case WMI_RING_EN_EVENTID:
531	return "WMI_RING_EN_EVENT";
532	case WMI_DATA_PORT_OPEN_EVENTID:
533	return "WMI_DATA_PORT_OPEN_EVENT";
534	case WMI_AOA_MEAS_EVENTID:
535	return "WMI_AOA_MEAS_EVENT";
536	case WMI_TOF_SESSION_END_EVENTID:
537	return "WMI_TOF_SESSION_END_EVENT";
538	case WMI_TOF_GET_CAPABILITIES_EVENTID:
539	return "WMI_TOF_GET_CAPABILITIES_EVENT";
540	case WMI_TOF_SET_LCR_EVENTID:
541	return "WMI_TOF_SET_LCR_EVENT";
542	case WMI_TOF_SET_LCI_EVENTID:
543	return "WMI_TOF_SET_LCI_EVENT";
544	case WMI_TOF_FTM_PER_DEST_RES_EVENTID:
545	return "WMI_TOF_FTM_PER_DEST_RES_EVENT";
546	case WMI_TOF_CHANNEL_INFO_EVENTID:
547	return "WMI_TOF_CHANNEL_INFO_EVENT";
548	case WMI_TRAFFIC_SUSPEND_EVENTID:
549	return "WMI_TRAFFIC_SUSPEND_EVENT";
550	case WMI_ECHO_RSP_EVENTID:
551	return "WMI_ECHO_RSP_EVENT";
552	case WMI_LED_CFG_DONE_EVENTID:
553	return "WMI_LED_CFG_DONE_EVENT";
554	case WMI_PCP_STARTED_EVENTID:
555	return "WMI_PCP_STARTED_EVENT";
556	case WMI_PCP_STOPPED_EVENTID:
557	return "WMI_PCP_STOPPED_EVENT";
558	case WMI_GET_SSID_EVENTID:
559	return "WMI_GET_SSID_EVENT";
560	case WMI_GET_PCP_CHANNEL_EVENTID:
561	return "WMI_GET_PCP_CHANNEL_EVENT";
562	case WMI_P2P_CFG_DONE_EVENTID:
563	return "WMI_P2P_CFG_DONE_EVENT";
564	case WMI_PORT_ALLOCATED_EVENTID:
565	return "WMI_PORT_ALLOCATED_EVENT";
566	case WMI_PORT_DELETED_EVENTID:
567	return "WMI_PORT_DELETED_EVENT";
568	case WMI_LISTEN_STARTED_EVENTID:
569	return "WMI_LISTEN_STARTED_EVENT";
570	case WMI_SEARCH_STARTED_EVENTID:
571	return "WMI_SEARCH_STARTED_EVENT";
572	case WMI_DISCOVERY_STOPPED_EVENTID:
573	return "WMI_DISCOVERY_STOPPED_EVENT";
574	case WMI_CFG_RX_CHAIN_DONE_EVENTID:
575	return "WMI_CFG_RX_CHAIN_DONE_EVENT";
576	case WMI_TEMP_SENSE_DONE_EVENTID:
577	return "WMI_TEMP_SENSE_DONE_EVENT";
578	case WMI_RCP_ADDBA_RESP_SENT_EVENTID:
579	return "WMI_RCP_ADDBA_RESP_SENT_EVENT";
580	case WMI_PS_DEV_PROFILE_CFG_EVENTID:
581	return "WMI_PS_DEV_PROFILE_CFG_EVENT";
582	case WMI_SET_MGMT_RETRY_LIMIT_EVENTID:
583	return "WMI_SET_MGMT_RETRY_LIMIT_EVENT";
584	case WMI_GET_MGMT_RETRY_LIMIT_EVENTID:
585	return "WMI_GET_MGMT_RETRY_LIMIT_EVENT";
586	case WMI_SET_THERMAL_THROTTLING_CFG_EVENTID:
587	return "WMI_SET_THERMAL_THROTTLING_CFG_EVENT";
588	case WMI_GET_THERMAL_THROTTLING_CFG_EVENTID:
589	return "WMI_GET_THERMAL_THROTTLING_CFG_EVENT";
590	case WMI_LINK_MAINTAIN_CFG_WRITE_DONE_EVENTID:
591	return "WMI_LINK_MAINTAIN_CFG_WRITE_DONE_EVENT";
592	case WMI_LO_POWER_CALIB_FROM_OTP_EVENTID:
593	return "WMI_LO_POWER_CALIB_FROM_OTP_EVENT";
594	case WMI_START_SCHED_SCAN_EVENTID:
595	return "WMI_START_SCHED_SCAN_EVENT";
596	case WMI_STOP_SCHED_SCAN_EVENTID:
597	return "WMI_STOP_SCHED_SCAN_EVENT";
598	case WMI_SCHED_SCAN_RESULT_EVENTID:
599	return "WMI_SCHED_SCAN_RESULT_EVENT";
600	case WMI_TX_STATUS_RING_CFG_DONE_EVENTID:
601	return "WMI_TX_STATUS_RING_CFG_DONE_EVENT";
602	case WMI_RX_STATUS_RING_CFG_DONE_EVENTID:
603	return "WMI_RX_STATUS_RING_CFG_DONE_EVENT";
604	case WMI_TX_DESC_RING_CFG_DONE_EVENTID:
605	return "WMI_TX_DESC_RING_CFG_DONE_EVENT";
606	case WMI_RX_DESC_RING_CFG_DONE_EVENTID:
607	return "WMI_RX_DESC_RING_CFG_DONE_EVENT";
608	case WMI_CFG_DEF_RX_OFFLOAD_DONE_EVENTID:
609	return "WMI_CFG_DEF_RX_OFFLOAD_DONE_EVENT";
610	case WMI_LINK_STATS_CONFIG_DONE_EVENTID:
611	return "WMI_LINK_STATS_CONFIG_DONE_EVENT";
612	case WMI_LINK_STATS_EVENTID:
613	return "WMI_LINK_STATS_EVENT";
614	case WMI_COMMAND_NOT_SUPPORTED_EVENTID:
615	return "WMI_COMMAND_NOT_SUPPORTED_EVENT";
616	case WMI_FT_AUTH_STATUS_EVENTID:
617	return "WMI_FT_AUTH_STATUS_EVENT";
618	case WMI_FT_REASSOC_STATUS_EVENTID:
619	return "WMI_FT_REASSOC_STATUS_EVENT";
620	case WMI_RBUFCAP_CFG_EVENTID:
621	return "WMI_RBUFCAP_CFG_EVENT";
622	case WMI_TEMP_SENSE_ALL_DONE_EVENTID:
623	return "WMI_TEMP_SENSE_ALL_DONE_EVENTID";
624	case WMI_SET_LINK_MONITOR_EVENTID:
625	return "WMI_SET_LINK_MONITOR_EVENT";
626	case WMI_LINK_MONITOR_EVENTID:
627	return "WMI_LINK_MONITOR_EVENT";
628	default:
629	return "Untracked EVENT";
630	}
631	}
632
633	static int __wmi_send(struct wil6210_priv *wil, u16 cmdid, u8 mid,
634	void *buf, u16 len)
635	{
636	struct {
637	struct wil6210_mbox_hdr hdr;
638	struct wmi_cmd_hdr wmi;
639	} __packed cmd = {
640	.hdr = {
641	.type = WIL_MBOX_HDR_TYPE_WMI,
642	.flags = 0,
643	.len = cpu_to_le16(sizeof(cmd.wmi) + len),
644	},
645	.wmi = {
646	.mid = mid,
647	.command_id = cpu_to_le16(cmdid),
648	},
649	};
650	struct wil6210_mbox_ring *r = &wil->mbox_ctl.tx;
651	struct wil6210_mbox_ring_desc d_head;
652	u32 next_head;
653	void __iomem *dst;
654	void __iomem *head = wmi_addr(wil, ptr: r->head);
655	uint retry;
656	int rc = 0;
657
658	if (len > r->entry_size - sizeof(cmd)) {
659	wil_err(wil, "WMI size too large: %d bytes, max is %d\n",
660	(int)(sizeof(cmd) + len), r->entry_size);
661	return -ERANGE;
662	}
663
664	might_sleep();
665
666	if (!test_bit(wil_status_fwready, wil->status)) {
667	wil_err(wil, "WMI: cannot send command while FW not ready\n");
668	return -EAGAIN;
669	}
670
671	/* Allow sending only suspend / resume commands during susepnd flow */
672	if ((test_bit(wil_status_suspending, wil->status) ||
673	test_bit(wil_status_suspended, wil->status) ||
674	test_bit(wil_status_resuming, wil->status)) &&
675	((cmdid != WMI_TRAFFIC_SUSPEND_CMDID) &&
676	(cmdid != WMI_TRAFFIC_RESUME_CMDID))) {
677	wil_err(wil, "WMI: reject send_command during suspend\n");
678	return -EINVAL;
679	}
680
681	if (!head) {
682	wil_err(wil, "WMI head is garbage: 0x%08x\n", r->head);
683	return -EINVAL;
684	}
685
686	wil_halp_vote(wil);
687
688	/* read Tx head till it is not busy */
689	for (retry = 5; retry > 0; retry--) {
690	wil_memcpy_fromio_32(dst: &d_head, src: head, count: sizeof(d_head));
691	if (d_head.sync == 0)
692	break;
693	msleep(msecs: 20);
694	}
695	if (d_head.sync != 0) {
696	wil_err(wil, "WMI head busy\n");
697	rc = -EBUSY;
698	goto out;
699	}
700	/* next head */
701	next_head = r->base + ((r->head - r->base + sizeof(d_head)) % r->size);
702	wil_dbg_wmi(wil, "Head 0x%08x -> 0x%08x\n", r->head, next_head);
703	/* wait till FW finish with previous command */
704	for (retry = 5; retry > 0; retry--) {
705	if (!test_bit(wil_status_fwready, wil->status)) {
706	wil_err(wil, "WMI: cannot send command while FW not ready\n");
707	rc = -EAGAIN;
708	goto out;
709	}
710	r->tail = wil_r(wil, RGF_MBOX +
711	offsetof(struct wil6210_mbox_ctl, tx.tail));
712	if (next_head != r->tail)
713	break;
714	msleep(msecs: 20);
715	}
716	if (next_head == r->tail) {
717	wil_err(wil, "WMI ring full\n");
718	rc = -EBUSY;
719	goto out;
720	}
721	dst = wmi_buffer(wil, ptr_: d_head.addr);
722	if (!dst) {
723	wil_err(wil, "invalid WMI buffer: 0x%08x\n",
724	le32_to_cpu(d_head.addr));
725	rc = -EAGAIN;
726	goto out;
727	}
728	cmd.hdr.seq = cpu_to_le16(++wil->wmi_seq);
729	/* set command */
730	wil_dbg_wmi(wil, "sending %s (0x%04x) [%d] mid %d\n",
731	cmdid2name(cmdid), cmdid, len, mid);
732	wil_hex_dump_wmi("Cmd ", DUMP_PREFIX_OFFSET, 16, 1, &cmd,
733	sizeof(cmd), true);
734	wil_hex_dump_wmi("cmd ", DUMP_PREFIX_OFFSET, 16, 1, buf,
735	len, true);
736	wil_memcpy_toio_32(dst, src: &cmd, count: sizeof(cmd));
737	wil_memcpy_toio_32(dst: dst + sizeof(cmd), src: buf, count: len);
738	/* mark entry as full */
739	wil_w(wil, reg: r->head + offsetof(struct wil6210_mbox_ring_desc, sync), val: 1);
740	/* advance next ptr */
741	wil_w(wil, RGF_MBOX + offsetof(struct wil6210_mbox_ctl, tx.head),
742	val: r->head = next_head);
743
744	trace_wil6210_wmi_cmd(wmi: &cmd.wmi, buf, buf_len: len);
745
746	/* interrupt to FW */
747	wil_w(wil, RGF_USER_USER_ICR + offsetof(struct RGF_ICR, ICS),
748	SW_INT_MBOX);
749
750	out:
751	wil_halp_unvote(wil);
752	return rc;
753	}
754
755	int wmi_send(struct wil6210_priv *wil, u16 cmdid, u8 mid, void *buf, u16 len)
756	{
757	int rc;
758
759	mutex_lock(&wil->wmi_mutex);
760	rc = __wmi_send(wil, cmdid, mid, buf, len);
761	mutex_unlock(lock: &wil->wmi_mutex);
762
763	return rc;
764	}
765
766	/*=== Event handlers ===*/
767	static void wmi_evt_ready(struct wil6210_vif *vif, int id, void *d, int len)
768	{
769	struct wil6210_priv *wil = vif_to_wil(vif);
770	struct wiphy *wiphy = wil_to_wiphy(wil);
771	struct wmi_ready_event *evt = d;
772	u8 fw_max_assoc_sta;
773
774	wil_info(wil, "FW ver. %s(SW %d); MAC %pM; %d MID's\n",
775	wil->fw_version, le32_to_cpu(evt->sw_version),
776	evt->mac, evt->numof_additional_mids);
777	if (evt->numof_additional_mids + 1 < wil->max_vifs) {
778	wil_err(wil, "FW does not support enough MIDs (need %d)",
779	wil->max_vifs - 1);
780	return; /* FW load will fail after timeout */
781	}
782	/* ignore MAC address, we already have it from the boot loader */
783	strscpy(wiphy->fw_version, wil->fw_version, sizeof(wiphy->fw_version));
784
785	if (len > offsetof(struct wmi_ready_event, rfc_read_calib_result)) {
786	wil_dbg_wmi(wil, "rfc calibration result %d\n",
787	evt->rfc_read_calib_result);
788	wil->fw_calib_result = evt->rfc_read_calib_result;
789	}
790
791	fw_max_assoc_sta = WIL6210_RX_DESC_MAX_CID;
792	if (len > offsetof(struct wmi_ready_event, max_assoc_sta) &&
793	evt->max_assoc_sta > 0) {
794	fw_max_assoc_sta = evt->max_assoc_sta;
795	wil_dbg_wmi(wil, "fw reported max assoc sta %d\n",
796	fw_max_assoc_sta);
797
798	if (fw_max_assoc_sta > WIL6210_MAX_CID) {
799	wil_dbg_wmi(wil,
800	"fw max assoc sta %d exceeds max driver supported %d\n",
801	fw_max_assoc_sta, WIL6210_MAX_CID);
802	fw_max_assoc_sta = WIL6210_MAX_CID;
803	}
804	}
805
806	wil->max_assoc_sta = min_t(uint, max_assoc_sta, fw_max_assoc_sta);
807	wil_dbg_wmi(wil, "setting max assoc sta to %d\n", wil->max_assoc_sta);
808
809	wil_set_recovery_state(wil, state: fw_recovery_idle);
810	set_bit(nr: wil_status_fwready, addr: wil->status);
811	/* let the reset sequence continue */
812	complete(&wil->wmi_ready);
813	}
814
815	static void wmi_evt_rx_mgmt(struct wil6210_vif *vif, int id, void *d, int len)
816	{
817	struct wil6210_priv *wil = vif_to_wil(vif);
818	struct wmi_rx_mgmt_packet_event *data = d;
819	struct wiphy *wiphy = wil_to_wiphy(wil);
820	struct ieee80211_mgmt *rx_mgmt_frame =
821	(struct ieee80211_mgmt *)data->payload;
822	int flen = len - offsetof(struct wmi_rx_mgmt_packet_event, payload);
823	int ch_no;
824	u32 freq;
825	struct ieee80211_channel *channel;
826	s32 signal;
827	__le16 fc;
828	u32 d_len;
829	u16 d_status;
830
831	if (flen < 0) {
832	wil_err(wil, "MGMT Rx: short event, len %d\n", len);
833	return;
834	}
835
836	d_len = le32_to_cpu(data->info.len);
837	if (d_len != flen) {
838	wil_err(wil,
839	"MGMT Rx: length mismatch, d_len %d should be %d\n",
840	d_len, flen);
841	return;
842	}
843
844	ch_no = data->info.channel + 1;
845	freq = ieee80211_channel_to_frequency(chan: ch_no, band: NL80211_BAND_60GHZ);
846	channel = ieee80211_get_channel(wiphy, freq);
847	if (test_bit(WMI_FW_CAPABILITY_RSSI_REPORTING, wil->fw_capabilities))
848	signal = 100 * data->info.rssi;
849	else
850	signal = data->info.sqi;
851	d_status = le16_to_cpu(data->info.status);
852	fc = rx_mgmt_frame->frame_control;
853
854	wil_dbg_wmi(wil, "MGMT Rx: channel %d MCS %s RSSI %d SQI %d%%\n",
855	data->info.channel, WIL_EXTENDED_MCS_CHECK(data->info.mcs),
856	data->info.rssi, data->info.sqi);
857	wil_dbg_wmi(wil, "status 0x%04x len %d fc 0x%04x\n", d_status, d_len,
858	le16_to_cpu(fc));
859	wil_dbg_wmi(wil, "qid %d mid %d cid %d\n",
860	data->info.qid, data->info.mid, data->info.cid);
861	wil_hex_dump_wmi("MGMT Rx ", DUMP_PREFIX_OFFSET, 16, 1, rx_mgmt_frame,
862	d_len, true);
863
864	if (!channel) {
865	wil_err(wil, "Frame on unsupported channel\n");
866	return;
867	}
868
869	if (ieee80211_is_beacon(fc) || ieee80211_is_probe_resp(fc)) {
870	struct cfg80211_bss *bss;
871	struct cfg80211_inform_bss bss_data = {
872	.chan = channel,
873	.signal = signal,
874	.boottime_ns = ktime_to_ns(kt: ktime_get_boottime()),
875	};
876	u64 tsf = le64_to_cpu(rx_mgmt_frame->u.beacon.timestamp);
877	u16 cap = le16_to_cpu(rx_mgmt_frame->u.beacon.capab_info);
878	u16 bi = le16_to_cpu(rx_mgmt_frame->u.beacon.beacon_int);
879	const u8 *ie_buf = rx_mgmt_frame->u.beacon.variable;
880	size_t ie_len = d_len - offsetof(struct ieee80211_mgmt,
881	u.beacon.variable);
882	wil_dbg_wmi(wil, "Capability info : 0x%04x\n", cap);
883	wil_dbg_wmi(wil, "TSF : 0x%016llx\n", tsf);
884	wil_dbg_wmi(wil, "Beacon interval : %d\n", bi);
885	wil_hex_dump_wmi("IE ", DUMP_PREFIX_OFFSET, 16, 1, ie_buf,
886	ie_len, true);
887
888	wil_dbg_wmi(wil, "Capability info : 0x%04x\n", cap);
889
890	bss = cfg80211_inform_bss_frame_data(wiphy, data: &bss_data,
891	mgmt: rx_mgmt_frame,
892	len: d_len, GFP_KERNEL);
893	if (bss) {
894	wil_dbg_wmi(wil, "Added BSS %pM\n",
895	rx_mgmt_frame->bssid);
896	cfg80211_put_bss(wiphy, bss);
897	} else {
898	wil_err(wil, "cfg80211_inform_bss_frame() failed\n");
899	}
900	} else {
901	mutex_lock(&wil->vif_mutex);
902	cfg80211_rx_mgmt(wdev: vif_to_radio_wdev(wil, vif), freq, sig_dbm: signal,
903	buf: (void *)rx_mgmt_frame, len: d_len, flags: 0);
904	mutex_unlock(lock: &wil->vif_mutex);
905	}
906	}
907
908	static void wmi_evt_tx_mgmt(struct wil6210_vif *vif, int id, void *d, int len)
909	{
910	struct wmi_tx_mgmt_packet_event *data = d;
911	struct ieee80211_mgmt *mgmt_frame =
912	(struct ieee80211_mgmt *)data->payload;
913	int flen = len - offsetof(struct wmi_tx_mgmt_packet_event, payload);
914
915	wil_hex_dump_wmi("MGMT Tx ", DUMP_PREFIX_OFFSET, 16, 1, mgmt_frame,
916	flen, true);
917	}
918
919	static void wmi_evt_scan_complete(struct wil6210_vif *vif, int id,
920	void *d, int len)
921	{
922	struct wil6210_priv *wil = vif_to_wil(vif);
923
924	mutex_lock(&wil->vif_mutex);
925	if (vif->scan_request) {
926	struct wmi_scan_complete_event *data = d;
927	int status = le32_to_cpu(data->status);
928	struct cfg80211_scan_info info = {
929	.aborted = ((status != WMI_SCAN_SUCCESS) &&
930	(status != WMI_SCAN_ABORT_REJECTED)),
931	};
932
933	wil_dbg_wmi(wil, "SCAN_COMPLETE(0x%08x)\n", status);
934	wil_dbg_misc(wil, "Complete scan_request 0x%p aborted %d\n",
935	vif->scan_request, info.aborted);
936	del_timer_sync(timer: &vif->scan_timer);
937	cfg80211_scan_done(request: vif->scan_request, info: &info);
938	if (vif->mid == 0)
939	wil->radio_wdev = wil->main_ndev->ieee80211_ptr;
940	vif->scan_request = NULL;
941	wake_up_interruptible(&wil->wq);
942	if (vif->p2p.pending_listen_wdev) {
943	wil_dbg_misc(wil, "Scheduling delayed listen\n");
944	schedule_work(work: &vif->p2p.delayed_listen_work);
945	}
946	} else {
947	wil_err(wil, "SCAN_COMPLETE while not scanning\n");
948	}
949	mutex_unlock(lock: &wil->vif_mutex);
950	}
951
952	static void wmi_evt_connect(struct wil6210_vif *vif, int id, void *d, int len)
953	{
954	struct wil6210_priv *wil = vif_to_wil(vif);
955	struct net_device *ndev = vif_to_ndev(vif);
956	struct wireless_dev *wdev = vif_to_wdev(vif);
957	struct wmi_connect_event *evt = d;
958	int ch; /* channel number */
959	struct station_info *sinfo;
960	u8 *assoc_req_ie, *assoc_resp_ie;
961	size_t assoc_req_ielen, assoc_resp_ielen;
962	/* capinfo(u16) + listen_interval(u16) + IEs */
963	const size_t assoc_req_ie_offset = sizeof(u16) * 2;
964	/* capinfo(u16) + status_code(u16) + associd(u16) + IEs */
965	const size_t assoc_resp_ie_offset = sizeof(u16) * 3;
966	int rc;
967
968	if (len < sizeof(*evt)) {
969	wil_err(wil, "Connect event too short : %d bytes\n", len);
970	return;
971	}
972	if (len != sizeof(*evt) + evt->beacon_ie_len + evt->assoc_req_len +
973	evt->assoc_resp_len) {
974	wil_err(wil,
975	"Connect event corrupted : %d != %d + %d + %d + %d\n",
976	len, (int)sizeof(*evt), evt->beacon_ie_len,
977	evt->assoc_req_len, evt->assoc_resp_len);
978	return;
979	}
980	if (evt->cid >= wil->max_assoc_sta) {
981	wil_err(wil, "Connect CID invalid : %d\n", evt->cid);
982	return;
983	}
984
985	ch = evt->channel + 1;
986	wil_info(wil, "Connect %pM channel [%d] cid %d aid %d\n",
987	evt->bssid, ch, evt->cid, evt->aid);
988	wil_hex_dump_wmi("connect AI : ", DUMP_PREFIX_OFFSET, 16, 1,
989	evt->assoc_info, len - sizeof(*evt), true);
990
991	/* figure out IE's */
992	assoc_req_ie = &evt->assoc_info[evt->beacon_ie_len +
993	assoc_req_ie_offset];
994	assoc_req_ielen = evt->assoc_req_len - assoc_req_ie_offset;
995	if (evt->assoc_req_len <= assoc_req_ie_offset) {
996	assoc_req_ie = NULL;
997	assoc_req_ielen = 0;
998	}
999
1000	assoc_resp_ie = &evt->assoc_info[evt->beacon_ie_len +
1001	evt->assoc_req_len +
1002	assoc_resp_ie_offset];
1003	assoc_resp_ielen = evt->assoc_resp_len - assoc_resp_ie_offset;
1004	if (evt->assoc_resp_len <= assoc_resp_ie_offset) {
1005	assoc_resp_ie = NULL;
1006	assoc_resp_ielen = 0;
1007	}
1008
1009	if (test_bit(wil_status_resetting, wil->status) ||
1010	!test_bit(wil_status_fwready, wil->status)) {
1011	wil_err(wil, "status_resetting, cancel connect event, CID %d\n",
1012	evt->cid);
1013	/* no need for cleanup, wil_reset will do that */
1014	return;
1015	}
1016
1017	mutex_lock(&wil->mutex);
1018
1019	if ((wdev->iftype == NL80211_IFTYPE_STATION) ||
1020	(wdev->iftype == NL80211_IFTYPE_P2P_CLIENT)) {
1021	if (!test_bit(wil_vif_fwconnecting, vif->status)) {
1022	wil_err(wil, "Not in connecting state\n");
1023	mutex_unlock(lock: &wil->mutex);
1024	return;
1025	}
1026	del_timer_sync(timer: &vif->connect_timer);
1027	} else if ((wdev->iftype == NL80211_IFTYPE_AP) ||
1028	(wdev->iftype == NL80211_IFTYPE_P2P_GO)) {
1029	if (wil->sta[evt->cid].status != wil_sta_unused) {
1030	wil_err(wil, "AP: Invalid status %d for CID %d\n",
1031	wil->sta[evt->cid].status, evt->cid);
1032	mutex_unlock(lock: &wil->mutex);
1033	return;
1034	}
1035	}
1036
1037	ether_addr_copy(dst: wil->sta[evt->cid].addr, src: evt->bssid);
1038	wil->sta[evt->cid].mid = vif->mid;
1039	wil->sta[evt->cid].status = wil_sta_conn_pending;
1040
1041	rc = wil_ring_init_tx(vif, cid: evt->cid);
1042	if (rc) {
1043	wil_err(wil, "config tx vring failed for CID %d, rc (%d)\n",
1044	evt->cid, rc);
1045	wmi_disconnect_sta(vif, mac: wil->sta[evt->cid].addr,
1046	reason: WLAN_REASON_UNSPECIFIED, del_sta: false);
1047	} else {
1048	wil_info(wil, "successful connection to CID %d\n", evt->cid);
1049	}
1050
1051	if ((wdev->iftype == NL80211_IFTYPE_STATION) ||
1052	(wdev->iftype == NL80211_IFTYPE_P2P_CLIENT)) {
1053	if (rc) {
1054	netif_carrier_off(dev: ndev);
1055	wil6210_bus_request(wil, WIL_DEFAULT_BUS_REQUEST_KBPS);
1056	wil_err(wil, "cfg80211_connect_result with failure\n");
1057	cfg80211_connect_result(dev: ndev, bssid: evt->bssid, NULL, req_ie_len: 0,
1058	NULL, resp_ie_len: 0,
1059	status: WLAN_STATUS_UNSPECIFIED_FAILURE,
1060	GFP_KERNEL);
1061	goto out;
1062	} else {
1063	struct wiphy *wiphy = wil_to_wiphy(wil);
1064
1065	cfg80211_ref_bss(wiphy, bss: vif->bss);
1066	cfg80211_connect_bss(dev: ndev, bssid: evt->bssid, bss: vif->bss,
1067	req_ie: assoc_req_ie, req_ie_len: assoc_req_ielen,
1068	resp_ie: assoc_resp_ie, resp_ie_len: assoc_resp_ielen,
1069	status: WLAN_STATUS_SUCCESS, GFP_KERNEL,
1070	timeout_reason: NL80211_TIMEOUT_UNSPECIFIED);
1071	}
1072	vif->bss = NULL;
1073	} else if ((wdev->iftype == NL80211_IFTYPE_AP) ||
1074	(wdev->iftype == NL80211_IFTYPE_P2P_GO)) {
1075
1076	if (rc) {
1077	if (disable_ap_sme)
1078	/* notify new_sta has failed */
1079	cfg80211_del_sta(dev: ndev, mac_addr: evt->bssid, GFP_KERNEL);
1080	goto out;
1081	}
1082
1083	sinfo = kzalloc(size: sizeof(*sinfo), GFP_KERNEL);
1084	if (!sinfo) {
1085	rc = -ENOMEM;
1086	goto out;
1087	}
1088
1089	sinfo->generation = wil->sinfo_gen++;
1090
1091	if (assoc_req_ie) {
1092	sinfo->assoc_req_ies = assoc_req_ie;
1093	sinfo->assoc_req_ies_len = assoc_req_ielen;
1094	}
1095
1096	cfg80211_new_sta(dev: ndev, mac_addr: evt->bssid, sinfo, GFP_KERNEL);
1097
1098	kfree(objp: sinfo);
1099	} else {
1100	wil_err(wil, "unhandled iftype %d for CID %d\n", wdev->iftype,
1101	evt->cid);
1102	goto out;
1103	}
1104
1105	wil->sta[evt->cid].status = wil_sta_connected;
1106	wil->sta[evt->cid].aid = evt->aid;
1107	if (!test_and_set_bit(nr: wil_vif_fwconnected, addr: vif->status))
1108	atomic_inc(v: &wil->connected_vifs);
1109	wil_update_net_queues_bh(wil, vif, NULL, check_stop: false);
1110
1111	out:
1112	if (rc) {
1113	wil->sta[evt->cid].status = wil_sta_unused;
1114	wil->sta[evt->cid].mid = U8_MAX;
1115	}
1116	clear_bit(nr: wil_vif_fwconnecting, addr: vif->status);
1117	mutex_unlock(lock: &wil->mutex);
1118	}
1119
1120	static void wmi_evt_disconnect(struct wil6210_vif *vif, int id,
1121	void *d, int len)
1122	{
1123	struct wil6210_priv *wil = vif_to_wil(vif);
1124	struct wmi_disconnect_event *evt = d;
1125	u16 reason_code = le16_to_cpu(evt->protocol_reason_status);
1126
1127	wil_info(wil, "Disconnect %pM reason [proto %d wmi %d]\n",
1128	evt->bssid, reason_code, evt->disconnect_reason);
1129
1130	wil->sinfo_gen++;
1131
1132	if (test_bit(wil_status_resetting, wil->status) ||
1133	!test_bit(wil_status_fwready, wil->status)) {
1134	wil_err(wil, "status_resetting, cancel disconnect event\n");
1135	/* no need for cleanup, wil_reset will do that */
1136	return;
1137	}
1138
1139	mutex_lock(&wil->mutex);
1140	wil6210_disconnect_complete(vif, bssid: evt->bssid, reason_code);
1141	if (disable_ap_sme) {
1142	struct wireless_dev *wdev = vif_to_wdev(vif);
1143	struct net_device *ndev = vif_to_ndev(vif);
1144
1145	/* disconnect event in disable_ap_sme mode means link loss */
1146	switch (wdev->iftype) {
1147	/* AP-like interface */
1148	case NL80211_IFTYPE_AP:
1149	case NL80211_IFTYPE_P2P_GO:
1150	/* notify hostapd about link loss */
1151	cfg80211_cqm_pktloss_notify(dev: ndev, peer: evt->bssid, num_packets: 0,
1152	GFP_KERNEL);
1153	break;
1154	default:
1155	break;
1156	}
1157	}
1158	mutex_unlock(lock: &wil->mutex);
1159	}
1160
1161	/*
1162	* Firmware reports EAPOL frame using WME event.
1163	* Reconstruct Ethernet frame and deliver it via normal Rx
1164	*/
1165	static void wmi_evt_eapol_rx(struct wil6210_vif *vif, int id, void *d, int len)
1166	{
1167	struct wil6210_priv *wil = vif_to_wil(vif);
1168	struct net_device *ndev = vif_to_ndev(vif);
1169	struct wmi_eapol_rx_event *evt = d;
1170	u16 eapol_len = le16_to_cpu(evt->eapol_len);
1171	int sz = eapol_len + ETH_HLEN;
1172	struct sk_buff *skb;
1173	struct ethhdr *eth;
1174	int cid;
1175	struct wil_net_stats *stats = NULL;
1176
1177	wil_dbg_wmi(wil, "EAPOL len %d from %pM MID %d\n", eapol_len,
1178	evt->src_mac, vif->mid);
1179
1180	cid = wil_find_cid(wil, mid: vif->mid, mac: evt->src_mac);
1181	if (cid >= 0)
1182	stats = &wil->sta[cid].stats;
1183
1184	if (eapol_len > 196) { /* TODO: revisit size limit */
1185	wil_err(wil, "EAPOL too large\n");
1186	return;
1187	}
1188
1189	skb = alloc_skb(size: sz, GFP_KERNEL);
1190	if (!skb) {
1191	wil_err(wil, "Failed to allocate skb\n");
1192	return;
1193	}
1194
1195	eth = skb_put(skb, ETH_HLEN);
1196	ether_addr_copy(dst: eth->h_dest, src: ndev->dev_addr);
1197	ether_addr_copy(dst: eth->h_source, src: evt->src_mac);
1198	eth->h_proto = cpu_to_be16(ETH_P_PAE);
1199	skb_put_data(skb, data: evt->eapol, len: eapol_len);
1200	skb->protocol = eth_type_trans(skb, dev: ndev);
1201	if (likely(netif_rx(skb) == NET_RX_SUCCESS)) {
1202	ndev->stats.rx_packets++;
1203	ndev->stats.rx_bytes += sz;
1204	if (stats) {
1205	stats->rx_packets++;
1206	stats->rx_bytes += sz;
1207	}
1208	} else {
1209	ndev->stats.rx_dropped++;
1210	if (stats)
1211	stats->rx_dropped++;
1212	}
1213	}
1214
1215	static void wmi_evt_ring_en(struct wil6210_vif *vif, int id, void *d, int len)
1216	{
1217	struct wil6210_priv *wil = vif_to_wil(vif);
1218	struct wmi_ring_en_event *evt = d;
1219	u8 vri = evt->ring_index;
1220	struct wireless_dev *wdev = vif_to_wdev(vif);
1221	struct wil_sta_info *sta;
1222	u8 cid;
1223	struct key_params params;
1224
1225	wil_dbg_wmi(wil, "Enable vring %d MID %d\n", vri, vif->mid);
1226
1227	if (vri >= ARRAY_SIZE(wil->ring_tx)) {
1228	wil_err(wil, "Enable for invalid vring %d\n", vri);
1229	return;
1230	}
1231
1232	if (wdev->iftype != NL80211_IFTYPE_AP || !disable_ap_sme ||
1233	test_bit(wil_vif_ft_roam, vif->status))
1234	/* in AP mode with disable_ap_sme that is not FT,
1235	* this is done by wil_cfg80211_change_station()
1236	*/
1237	wil->ring_tx_data[vri].dot1x_open = true;
1238	if (vri == vif->bcast_ring) /* no BA for bcast */
1239	return;
1240
1241	cid = wil->ring2cid_tid[vri][0];
1242	if (!wil_cid_valid(wil, cid)) {
1243	wil_err(wil, "invalid cid %d for vring %d\n", cid, vri);
1244	return;
1245	}
1246
1247	/* In FT mode we get key but not store it as it is received
1248	* before WMI_CONNECT_EVENT received from FW.
1249	* wil_set_crypto_rx is called here to reset the security PN
1250	*/
1251	sta = &wil->sta[cid];
1252	if (test_bit(wil_vif_ft_roam, vif->status)) {
1253	memset(&params, 0, sizeof(params));
1254	wil_set_crypto_rx(key_index: 0, key_usage: WMI_KEY_USE_PAIRWISE, cs: sta, params: &params);
1255	if (wdev->iftype != NL80211_IFTYPE_AP)
1256	clear_bit(nr: wil_vif_ft_roam, addr: vif->status);
1257	}
1258
1259	if (agg_wsize >= 0)
1260	wil_addba_tx_request(wil, ringid: vri, wsize: agg_wsize);
1261	}
1262
1263	static void wmi_evt_ba_status(struct wil6210_vif *vif, int id,
1264	void *d, int len)
1265	{
1266	struct wil6210_priv *wil = vif_to_wil(vif);
1267	struct wmi_ba_status_event *evt = d;
1268	struct wil_ring_tx_data *txdata;
1269
1270	wil_dbg_wmi(wil, "BACK[%d] %s {%d} timeout %d AMSDU%s\n",
1271	evt->ringid,
1272	evt->status == WMI_BA_AGREED ? "OK" : "N/A",
1273	evt->agg_wsize, __le16_to_cpu(evt->ba_timeout),
1274	evt->amsdu ? "+" : "-");
1275
1276	if (evt->ringid >= WIL6210_MAX_TX_RINGS) {
1277	wil_err(wil, "invalid ring id %d\n", evt->ringid);
1278	return;
1279	}
1280
1281	if (evt->status != WMI_BA_AGREED) {
1282	evt->ba_timeout = 0;
1283	evt->agg_wsize = 0;
1284	evt->amsdu = 0;
1285	}
1286
1287	txdata = &wil->ring_tx_data[evt->ringid];
1288
1289	txdata->agg_timeout = le16_to_cpu(evt->ba_timeout);
1290	txdata->agg_wsize = evt->agg_wsize;
1291	txdata->agg_amsdu = evt->amsdu;
1292	txdata->addba_in_progress = false;
1293	}
1294
1295	static void wmi_evt_addba_rx_req(struct wil6210_vif *vif, int id,
1296	void *d, int len)
1297	{
1298	struct wil6210_priv *wil = vif_to_wil(vif);
1299	u8 cid, tid;
1300	struct wmi_rcp_addba_req_event *evt = d;
1301
1302	if (evt->cidxtid != CIDXTID_EXTENDED_CID_TID) {
1303	parse_cidxtid(cidxtid: evt->cidxtid, cid: &cid, tid: &tid);
1304	} else {
1305	cid = evt->cid;
1306	tid = evt->tid;
1307	}
1308	wil_addba_rx_request(wil, mid: vif->mid, cid, tid, dialog_token: evt->dialog_token,
1309	ba_param_set: evt->ba_param_set, ba_timeout: evt->ba_timeout,
1310	ba_seq_ctrl: evt->ba_seq_ctrl);
1311	}
1312
1313	static void wmi_evt_delba(struct wil6210_vif *vif, int id, void *d, int len)
1314	__acquires(&sta->tid_rx_lock) __releases(&sta->tid_rx_lock)
1315	{
1316	struct wil6210_priv *wil = vif_to_wil(vif);
1317	struct wmi_delba_event *evt = d;
1318	u8 cid, tid;
1319	u16 reason = __le16_to_cpu(evt->reason);
1320	struct wil_sta_info *sta;
1321	struct wil_tid_ampdu_rx *r;
1322
1323	might_sleep();
1324
1325	if (evt->cidxtid != CIDXTID_EXTENDED_CID_TID) {
1326	parse_cidxtid(cidxtid: evt->cidxtid, cid: &cid, tid: &tid);
1327	} else {
1328	cid = evt->cid;
1329	tid = evt->tid;
1330	}
1331
1332	if (!wil_cid_valid(wil, cid)) {
1333	wil_err(wil, "DELBA: Invalid CID %d\n", cid);
1334	return;
1335	}
1336
1337	wil_dbg_wmi(wil, "DELBA MID %d CID %d TID %d from %s reason %d\n",
1338	vif->mid, cid, tid,
1339	evt->from_initiator ? "originator" : "recipient",
1340	reason);
1341	if (!evt->from_initiator) {
1342	int i;
1343	/* find Tx vring it belongs to */
1344	for (i = 0; i < ARRAY_SIZE(wil->ring2cid_tid); i++) {
1345	if (wil->ring2cid_tid[i][0] == cid &&
1346	wil->ring2cid_tid[i][1] == tid) {
1347	struct wil_ring_tx_data *txdata =
1348	&wil->ring_tx_data[i];
1349
1350	wil_dbg_wmi(wil, "DELBA Tx vring %d\n", i);
1351	txdata->agg_timeout = 0;
1352	txdata->agg_wsize = 0;
1353	txdata->addba_in_progress = false;
1354
1355	break; /* max. 1 matching ring */
1356	}
1357	}
1358	if (i >= ARRAY_SIZE(wil->ring2cid_tid))
1359	wil_err(wil, "DELBA: unable to find Tx vring\n");
1360	return;
1361	}
1362
1363	sta = &wil->sta[cid];
1364
1365	spin_lock_bh(lock: &sta->tid_rx_lock);
1366
1367	r = sta->tid_rx[tid];
1368	sta->tid_rx[tid] = NULL;
1369	wil_tid_ampdu_rx_free(wil, r);
1370
1371	spin_unlock_bh(lock: &sta->tid_rx_lock);
1372	}
1373
1374	static void
1375	wmi_evt_sched_scan_result(struct wil6210_vif *vif, int id, void *d, int len)
1376	{
1377	struct wil6210_priv *wil = vif_to_wil(vif);
1378	struct wmi_sched_scan_result_event *data = d;
1379	struct wiphy *wiphy = wil_to_wiphy(wil);
1380	struct ieee80211_mgmt *rx_mgmt_frame =
1381	(struct ieee80211_mgmt *)data->payload;
1382	int flen = len - offsetof(struct wmi_sched_scan_result_event, payload);
1383	int ch_no;
1384	u32 freq;
1385	struct ieee80211_channel *channel;
1386	s32 signal;
1387	__le16 fc;
1388	u32 d_len;
1389	struct cfg80211_bss *bss;
1390	struct cfg80211_inform_bss bss_data = {
1391	.boottime_ns = ktime_to_ns(kt: ktime_get_boottime()),
1392	};
1393
1394	if (flen < 0) {
1395	wil_err(wil, "sched scan result event too short, len %d\n",
1396	len);
1397	return;
1398	}
1399
1400	d_len = le32_to_cpu(data->info.len);
1401	if (d_len != flen) {
1402	wil_err(wil,
1403	"sched scan result length mismatch, d_len %d should be %d\n",
1404	d_len, flen);
1405	return;
1406	}
1407
1408	fc = rx_mgmt_frame->frame_control;
1409	if (!ieee80211_is_probe_resp(fc)) {
1410	wil_err(wil, "sched scan result invalid frame, fc 0x%04x\n",
1411	fc);
1412	return;
1413	}
1414
1415	ch_no = data->info.channel + 1;
1416	freq = ieee80211_channel_to_frequency(chan: ch_no, band: NL80211_BAND_60GHZ);
1417	channel = ieee80211_get_channel(wiphy, freq);
1418	if (test_bit(WMI_FW_CAPABILITY_RSSI_REPORTING, wil->fw_capabilities))
1419	signal = 100 * data->info.rssi;
1420	else
1421	signal = data->info.sqi;
1422
1423	wil_dbg_wmi(wil, "sched scan result: channel %d MCS %s RSSI %d\n",
1424	data->info.channel, WIL_EXTENDED_MCS_CHECK(data->info.mcs),
1425	data->info.rssi);
1426	wil_dbg_wmi(wil, "len %d qid %d mid %d cid %d\n",
1427	d_len, data->info.qid, data->info.mid, data->info.cid);
1428	wil_hex_dump_wmi("PROBE ", DUMP_PREFIX_OFFSET, 16, 1, rx_mgmt_frame,
1429	d_len, true);
1430
1431	if (!channel) {
1432	wil_err(wil, "Frame on unsupported channel\n");
1433	return;
1434	}
1435
1436	bss_data.signal = signal;
1437	bss_data.chan = channel;
1438	bss = cfg80211_inform_bss_frame_data(wiphy, data: &bss_data, mgmt: rx_mgmt_frame,
1439	len: d_len, GFP_KERNEL);
1440	if (bss) {
1441	wil_dbg_wmi(wil, "Added BSS %pM\n", rx_mgmt_frame->bssid);
1442	cfg80211_put_bss(wiphy, bss);
1443	} else {
1444	wil_err(wil, "cfg80211_inform_bss_frame() failed\n");
1445	}
1446
1447	cfg80211_sched_scan_results(wiphy, reqid: 0);
1448	}
1449
1450	static void wil_link_stats_store_basic(struct wil6210_vif *vif,
1451	struct wmi_link_stats_basic *basic)
1452	{
1453	struct wil6210_priv *wil = vif_to_wil(vif);
1454	u8 cid = basic->cid;
1455	struct wil_sta_info *sta;
1456
1457	if (cid >= wil->max_assoc_sta) {
1458	wil_err(wil, "invalid cid %d\n", cid);
1459	return;
1460	}
1461
1462	sta = &wil->sta[cid];
1463	sta->fw_stats_basic = *basic;
1464	}
1465
1466	static void wil_link_stats_store_global(struct wil6210_vif *vif,
1467	struct wmi_link_stats_global *global)
1468	{
1469	struct wil6210_priv *wil = vif_to_wil(vif);
1470
1471	wil->fw_stats_global.stats = *global;
1472	}
1473
1474	static void wmi_link_stats_parse(struct wil6210_vif *vif, u64 tsf,
1475	bool has_next, void *payload,
1476	size_t payload_size)
1477	{
1478	struct wil6210_priv *wil = vif_to_wil(vif);
1479	size_t hdr_size = sizeof(struct wmi_link_stats_record);
1480	size_t stats_size, record_size, expected_size;
1481	struct wmi_link_stats_record *hdr;
1482
1483	if (payload_size < hdr_size) {
1484	wil_err(wil, "link stats wrong event size %zu\n", payload_size);
1485	return;
1486	}
1487
1488	while (payload_size >= hdr_size) {
1489	hdr = payload;
1490	stats_size = le16_to_cpu(hdr->record_size);
1491	record_size = hdr_size + stats_size;
1492
1493	if (payload_size < record_size) {
1494	wil_err(wil, "link stats payload ended unexpectedly, size %zu < %zu\n",
1495	payload_size, record_size);
1496	return;
1497	}
1498
1499	switch (hdr->record_type_id) {
1500	case WMI_LINK_STATS_TYPE_BASIC:
1501	expected_size = sizeof(struct wmi_link_stats_basic);
1502	if (stats_size < expected_size) {
1503	wil_err(wil, "link stats invalid basic record size %zu < %zu\n",
1504	stats_size, expected_size);
1505	return;
1506	}
1507	if (vif->fw_stats_ready) {
1508	/* clean old statistics */
1509	vif->fw_stats_tsf = 0;
1510	vif->fw_stats_ready = false;
1511	}
1512
1513	wil_link_stats_store_basic(vif, basic: payload + hdr_size);
1514
1515	if (!has_next) {
1516	vif->fw_stats_tsf = tsf;
1517	vif->fw_stats_ready = true;
1518	}
1519
1520	break;
1521	case WMI_LINK_STATS_TYPE_GLOBAL:
1522	expected_size = sizeof(struct wmi_link_stats_global);
1523	if (stats_size < sizeof(struct wmi_link_stats_global)) {
1524	wil_err(wil, "link stats invalid global record size %zu < %zu\n",
1525	stats_size, expected_size);
1526	return;
1527	}
1528
1529	if (wil->fw_stats_global.ready) {
1530	/* clean old statistics */
1531	wil->fw_stats_global.tsf = 0;
1532	wil->fw_stats_global.ready = false;
1533	}
1534
1535	wil_link_stats_store_global(vif, global: payload + hdr_size);
1536
1537	if (!has_next) {
1538	wil->fw_stats_global.tsf = tsf;
1539	wil->fw_stats_global.ready = true;
1540	}
1541
1542	break;
1543	default:
1544	break;
1545	}
1546
1547	/* skip to next record */
1548	payload += record_size;
1549	payload_size -= record_size;
1550	}
1551	}
1552
1553	static void
1554	wmi_evt_link_stats(struct wil6210_vif *vif, int id, void *d, int len)
1555	{
1556	struct wil6210_priv *wil = vif_to_wil(vif);
1557	struct wmi_link_stats_event *evt = d;
1558	size_t payload_size;
1559
1560	if (len < offsetof(struct wmi_link_stats_event, payload)) {
1561	wil_err(wil, "stats event way too short %d\n", len);
1562	return;
1563	}
1564	payload_size = le16_to_cpu(evt->payload_size);
1565	if (len < sizeof(struct wmi_link_stats_event) + payload_size) {
1566	wil_err(wil, "stats event too short %d\n", len);
1567	return;
1568	}
1569
1570	wmi_link_stats_parse(vif, le64_to_cpu(evt->tsf), has_next: evt->has_next,
1571	payload: evt->payload, payload_size);
1572	}
1573
1574	/* find cid and ringid for the station vif
1575	*
1576	* return error, if other interfaces are used or ring was not found
1577	*/
1578	static int wil_find_cid_ringid_sta(struct wil6210_priv *wil,
1579	struct wil6210_vif *vif,
1580	int *cid,
1581	int *ringid)
1582	{
1583	struct wil_ring *ring;
1584	struct wil_ring_tx_data *txdata;
1585	int min_ring_id = wil_get_min_tx_ring_id(wil);
1586	int i;
1587	u8 lcid;
1588
1589	if (!(vif->wdev.iftype == NL80211_IFTYPE_STATION ||
1590	vif->wdev.iftype == NL80211_IFTYPE_P2P_CLIENT)) {
1591	wil_err(wil, "invalid interface type %d\n", vif->wdev.iftype);
1592	return -EINVAL;
1593	}
1594
1595	/* In the STA mode, it is expected to have only one ring
1596	* for the AP we are connected to.
1597	* find it and return the cid associated with it.
1598	*/
1599	for (i = min_ring_id; i < WIL6210_MAX_TX_RINGS; i++) {
1600	ring = &wil->ring_tx[i];
1601	txdata = &wil->ring_tx_data[i];
1602	if (!ring->va || !txdata->enabled || txdata->mid != vif->mid)
1603	continue;
1604
1605	lcid = wil->ring2cid_tid[i][0];
1606	if (lcid >= wil->max_assoc_sta) /* skip BCAST */
1607	continue;
1608
1609	wil_dbg_wmi(wil, "find sta -> ringid %d cid %d\n", i, lcid);
1610	*cid = lcid;
1611	*ringid = i;
1612	return 0;
1613	}
1614
1615	wil_dbg_wmi(wil, "find sta cid while no rings active?\n");
1616
1617	return -ENOENT;
1618	}
1619
1620	static void
1621	wmi_evt_auth_status(struct wil6210_vif *vif, int id, void *d, int len)
1622	{
1623	struct wil6210_priv *wil = vif_to_wil(vif);
1624	struct net_device *ndev = vif_to_ndev(vif);
1625	struct wmi_ft_auth_status_event *data = d;
1626	int ie_len = len - offsetof(struct wmi_ft_auth_status_event, ie_info);
1627	int rc, cid = 0, ringid = 0;
1628	struct cfg80211_ft_event_params ft;
1629	u16 d_len;
1630	/* auth_alg(u16) + auth_transaction(u16) + status_code(u16) */
1631	const size_t auth_ie_offset = sizeof(u16) * 3;
1632	struct auth_no_hdr *auth = (struct auth_no_hdr *)data->ie_info;
1633
1634	/* check the status */
1635	if (ie_len >= 0 && data->status != WMI_FW_STATUS_SUCCESS) {
1636	wil_err(wil, "FT: auth failed. status %d\n", data->status);
1637	goto fail;
1638	}
1639
1640	if (ie_len < auth_ie_offset) {
1641	wil_err(wil, "FT: auth event too short, len %d\n", len);
1642	goto fail;
1643	}
1644
1645	d_len = le16_to_cpu(data->ie_len);
1646	if (d_len != ie_len) {
1647	wil_err(wil,
1648	"FT: auth ie length mismatch, d_len %d should be %d\n",
1649	d_len, ie_len);
1650	goto fail;
1651	}
1652
1653	if (!test_bit(wil_vif_ft_roam, wil->status)) {
1654	wil_err(wil, "FT: Not in roaming state\n");
1655	goto fail;
1656	}
1657
1658	if (le16_to_cpu(auth->auth_transaction) != 2) {
1659	wil_err(wil, "FT: auth error. auth_transaction %d\n",
1660	le16_to_cpu(auth->auth_transaction));
1661	goto fail;
1662	}
1663
1664	if (le16_to_cpu(auth->auth_alg) != WLAN_AUTH_FT) {
1665	wil_err(wil, "FT: auth error. auth_alg %d\n",
1666	le16_to_cpu(auth->auth_alg));
1667	goto fail;
1668	}
1669
1670	wil_dbg_wmi(wil, "FT: Auth to %pM successfully\n", data->mac_addr);
1671	wil_hex_dump_wmi("FT Auth ies : ", DUMP_PREFIX_OFFSET, 16, 1,
1672	data->ie_info, d_len, true);
1673
1674	/* find cid and ringid */
1675	rc = wil_find_cid_ringid_sta(wil, vif, cid: &cid, ringid: &ringid);
1676	if (rc) {
1677	wil_err(wil, "No valid cid found\n");
1678	goto fail;
1679	}
1680
1681	if (vif->privacy) {
1682	/* For secure assoc, remove old keys */
1683	rc = wmi_del_cipher_key(vif, key_index: 0, mac_addr: wil->sta[cid].addr,
1684	key_usage: WMI_KEY_USE_PAIRWISE);
1685	if (rc) {
1686	wil_err(wil, "WMI_DELETE_CIPHER_KEY_CMD(PTK) failed\n");
1687	goto fail;
1688	}
1689	rc = wmi_del_cipher_key(vif, key_index: 0, mac_addr: wil->sta[cid].addr,
1690	key_usage: WMI_KEY_USE_RX_GROUP);
1691	if (rc) {
1692	wil_err(wil, "WMI_DELETE_CIPHER_KEY_CMD(GTK) failed\n");
1693	goto fail;
1694	}
1695	}
1696
1697	memset(&ft, 0, sizeof(ft));
1698	ft.ies = data->ie_info + auth_ie_offset;
1699	ft.ies_len = d_len - auth_ie_offset;
1700	ft.target_ap = data->mac_addr;
1701	cfg80211_ft_event(netdev: ndev, ft_event: &ft);
1702
1703	return;
1704
1705	fail:
1706	wil6210_disconnect(vif, NULL, reason_code: WLAN_REASON_PREV_AUTH_NOT_VALID);
1707	}
1708
1709	static void
1710	wmi_evt_reassoc_status(struct wil6210_vif *vif, int id, void *d, int len)
1711	{
1712	struct wil6210_priv *wil = vif_to_wil(vif);
1713	struct net_device *ndev = vif_to_ndev(vif);
1714	struct wiphy *wiphy = wil_to_wiphy(wil);
1715	struct wmi_ft_reassoc_status_event *data = d;
1716	int ies_len = len - offsetof(struct wmi_ft_reassoc_status_event,
1717	ie_info);
1718	int rc = -ENOENT, cid = 0, ringid = 0;
1719	int ch; /* channel number (primary) */
1720	size_t assoc_req_ie_len = 0, assoc_resp_ie_len = 0;
1721	u8 *assoc_req_ie = NULL, *assoc_resp_ie = NULL;
1722	/* capinfo(u16) + listen_interval(u16) + current_ap mac addr + IEs */
1723	const size_t assoc_req_ie_offset = sizeof(u16) * 2 + ETH_ALEN;
1724	/* capinfo(u16) + status_code(u16) + associd(u16) + IEs */
1725	const size_t assoc_resp_ie_offset = sizeof(u16) * 3;
1726	u16 d_len;
1727	int freq;
1728	struct cfg80211_roam_info info;
1729
1730	if (ies_len < 0) {
1731	wil_err(wil, "ft reassoc event too short, len %d\n", len);
1732	goto fail;
1733	}
1734
1735	wil_dbg_wmi(wil, "Reasoc Status event: status=%d, aid=%d",
1736	data->status, data->aid);
1737	wil_dbg_wmi(wil, " mac_addr=%pM, beacon_ie_len=%d",
1738	data->mac_addr, data->beacon_ie_len);
1739	wil_dbg_wmi(wil, " reassoc_req_ie_len=%d, reassoc_resp_ie_len=%d",
1740	le16_to_cpu(data->reassoc_req_ie_len),
1741	le16_to_cpu(data->reassoc_resp_ie_len));
1742
1743	d_len = le16_to_cpu(data->beacon_ie_len) +
1744	le16_to_cpu(data->reassoc_req_ie_len) +
1745	le16_to_cpu(data->reassoc_resp_ie_len);
1746	if (d_len != ies_len) {
1747	wil_err(wil,
1748	"ft reassoc ie length mismatch, d_len %d should be %d\n",
1749	d_len, ies_len);
1750	goto fail;
1751	}
1752
1753	/* check the status */
1754	if (data->status != WMI_FW_STATUS_SUCCESS) {
1755	wil_err(wil, "ft reassoc failed. status %d\n", data->status);
1756	goto fail;
1757	}
1758
1759	/* find cid and ringid */
1760	rc = wil_find_cid_ringid_sta(wil, vif, cid: &cid, ringid: &ringid);
1761	if (rc) {
1762	wil_err(wil, "No valid cid found\n");
1763	goto fail;
1764	}
1765
1766	ch = data->channel + 1;
1767	wil_info(wil, "FT: Roam %pM channel [%d] cid %d aid %d\n",
1768	data->mac_addr, ch, cid, data->aid);
1769
1770	wil_hex_dump_wmi("reassoc AI : ", DUMP_PREFIX_OFFSET, 16, 1,
1771	data->ie_info, len - sizeof(*data), true);
1772
1773	/* figure out IE's */
1774	if (le16_to_cpu(data->reassoc_req_ie_len) > assoc_req_ie_offset) {
1775	assoc_req_ie = &data->ie_info[assoc_req_ie_offset];
1776	assoc_req_ie_len = le16_to_cpu(data->reassoc_req_ie_len) -
1777	assoc_req_ie_offset;
1778	}
1779	if (le16_to_cpu(data->reassoc_resp_ie_len) <= assoc_resp_ie_offset) {
1780	wil_err(wil, "FT: reassoc resp ie len is too short, len %d\n",
1781	le16_to_cpu(data->reassoc_resp_ie_len));
1782	goto fail;
1783	}
1784
1785	assoc_resp_ie = &data->ie_info[le16_to_cpu(data->reassoc_req_ie_len) +
1786	assoc_resp_ie_offset];
1787	assoc_resp_ie_len = le16_to_cpu(data->reassoc_resp_ie_len) -
1788	assoc_resp_ie_offset;
1789
1790	if (test_bit(wil_status_resetting, wil->status) ||
1791	!test_bit(wil_status_fwready, wil->status)) {
1792	wil_err(wil, "FT: status_resetting, cancel reassoc event\n");
1793	/* no need for cleanup, wil_reset will do that */
1794	return;
1795	}
1796
1797	mutex_lock(&wil->mutex);
1798
1799	/* ring modify to set the ring for the roamed AP settings */
1800	wil_dbg_wmi(wil,
1801	"ft modify tx config for connection CID %d ring %d\n",
1802	cid, ringid);
1803
1804	rc = wil->txrx_ops.tx_ring_modify(vif, ringid, cid, 0);
1805	if (rc) {
1806	wil_err(wil, "modify TX for CID %d MID %d ring %d failed (%d)\n",
1807	cid, vif->mid, ringid, rc);
1808	mutex_unlock(lock: &wil->mutex);
1809	goto fail;
1810	}
1811
1812	/* Update the driver STA members with the new bss */
1813	wil->sta[cid].aid = data->aid;
1814	wil->sta[cid].stats.ft_roams++;
1815	ether_addr_copy(dst: wil->sta[cid].addr, src: vif->bss->bssid);
1816	mutex_unlock(lock: &wil->mutex);
1817	del_timer_sync(timer: &vif->connect_timer);
1818
1819	cfg80211_ref_bss(wiphy, bss: vif->bss);
1820	freq = ieee80211_channel_to_frequency(chan: ch, band: NL80211_BAND_60GHZ);
1821
1822	memset(&info, 0, sizeof(info));
1823	info.links[0].channel = ieee80211_get_channel(wiphy, freq);
1824	info.links[0].bss = vif->bss;
1825	info.req_ie = assoc_req_ie;
1826	info.req_ie_len = assoc_req_ie_len;
1827	info.resp_ie = assoc_resp_ie;
1828	info.resp_ie_len = assoc_resp_ie_len;
1829	cfg80211_roamed(dev: ndev, info: &info, GFP_KERNEL);
1830	vif->bss = NULL;
1831
1832	return;
1833
1834	fail:
1835	wil6210_disconnect(vif, NULL, reason_code: WLAN_REASON_PREV_AUTH_NOT_VALID);
1836	}
1837
1838	static void
1839	wmi_evt_link_monitor(struct wil6210_vif *vif, int id, void *d, int len)
1840	{
1841	struct wil6210_priv *wil = vif_to_wil(vif);
1842	struct net_device *ndev = vif_to_ndev(vif);
1843	struct wmi_link_monitor_event *evt = d;
1844	enum nl80211_cqm_rssi_threshold_event event_type;
1845
1846	if (len < sizeof(*evt)) {
1847	wil_err(wil, "link monitor event too short %d\n", len);
1848	return;
1849	}
1850
1851	wil_dbg_wmi(wil, "link monitor event, type %d rssi %d (stored %d)\n",
1852	evt->type, evt->rssi_level, wil->cqm_rssi_thold);
1853
1854	if (evt->type != WMI_LINK_MONITOR_NOTIF_RSSI_THRESHOLD_EVT)
1855	/* ignore */
1856	return;
1857
1858	event_type = (evt->rssi_level > wil->cqm_rssi_thold ?
1859	NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH :
1860	NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW);
1861	cfg80211_cqm_rssi_notify(dev: ndev, rssi_event: event_type, rssi_level: evt->rssi_level, GFP_KERNEL);
1862	}
1863
1864	/* Some events are ignored for purpose; and need not be interpreted as
1865	* "unhandled events"
1866	*/
1867	static void wmi_evt_ignore(struct wil6210_vif *vif, int id, void *d, int len)
1868	{
1869	struct wil6210_priv *wil = vif_to_wil(vif);
1870
1871	wil_dbg_wmi(wil, "Ignore event 0x%04x len %d\n", id, len);
1872	}
1873
1874	static const struct {
1875	int eventid;
1876	void (*handler)(struct wil6210_vif *vif,
1877	int eventid, void *data, int data_len);
1878	} wmi_evt_handlers[] = {
1879	{WMI_READY_EVENTID, wmi_evt_ready},
1880	{WMI_FW_READY_EVENTID, wmi_evt_ignore},
1881	{WMI_RX_MGMT_PACKET_EVENTID, wmi_evt_rx_mgmt},
1882	{WMI_TX_MGMT_PACKET_EVENTID, wmi_evt_tx_mgmt},
1883	{WMI_SCAN_COMPLETE_EVENTID, wmi_evt_scan_complete},
1884	{WMI_CONNECT_EVENTID, wmi_evt_connect},
1885	{WMI_DISCONNECT_EVENTID, wmi_evt_disconnect},
1886	{WMI_EAPOL_RX_EVENTID, wmi_evt_eapol_rx},
1887	{WMI_BA_STATUS_EVENTID, wmi_evt_ba_status},
1888	{WMI_RCP_ADDBA_REQ_EVENTID, wmi_evt_addba_rx_req},
1889	{WMI_DELBA_EVENTID, wmi_evt_delba},
1890	{WMI_RING_EN_EVENTID, wmi_evt_ring_en},
1891	{WMI_DATA_PORT_OPEN_EVENTID, wmi_evt_ignore},
1892	{WMI_SCHED_SCAN_RESULT_EVENTID, wmi_evt_sched_scan_result},
1893	{WMI_LINK_STATS_EVENTID, wmi_evt_link_stats},
1894	{WMI_FT_AUTH_STATUS_EVENTID, wmi_evt_auth_status},
1895	{WMI_FT_REASSOC_STATUS_EVENTID, wmi_evt_reassoc_status},
1896	{WMI_LINK_MONITOR_EVENTID, wmi_evt_link_monitor},
1897	};
1898
1899	/*
1900	* Run in IRQ context
1901	* Extract WMI command from mailbox. Queue it to the @wil->pending_wmi_ev
1902	* that will be eventually handled by the @wmi_event_worker in the thread
1903	* context of thread "wil6210_wmi"
1904	*/
1905	void wmi_recv_cmd(struct wil6210_priv *wil)
1906	{
1907	struct wil6210_mbox_ring_desc d_tail;
1908	struct wil6210_mbox_hdr hdr;
1909	struct wil6210_mbox_ring *r = &wil->mbox_ctl.rx;
1910	struct pending_wmi_event *evt;
1911	u8 *cmd;
1912	void __iomem *src;
1913	ulong flags;
1914	unsigned n;
1915	unsigned int num_immed_reply = 0;
1916
1917	if (!test_bit(wil_status_mbox_ready, wil->status)) {
1918	wil_err(wil, "Reset in progress. Cannot handle WMI event\n");
1919	return;
1920	}
1921
1922	if (test_bit(wil_status_suspended, wil->status)) {
1923	wil_err(wil, "suspended. cannot handle WMI event\n");
1924	return;
1925	}
1926
1927	for (n = 0;; n++) {
1928	u16 len;
1929	bool q;
1930	bool immed_reply = false;
1931
1932	r->head = wil_r(wil, RGF_MBOX +
1933	offsetof(struct wil6210_mbox_ctl, rx.head));
1934	if (r->tail == r->head)
1935	break;
1936
1937	wil_dbg_wmi(wil, "Mbox head %08x tail %08x\n",
1938	r->head, r->tail);
1939	/* read cmd descriptor from tail */
1940	wil_memcpy_fromio_32(dst: &d_tail, src: wil->csr + HOSTADDR(r->tail),
1941	count: sizeof(struct wil6210_mbox_ring_desc));
1942	if (d_tail.sync == 0) {
1943	wil_err(wil, "Mbox evt not owned by FW?\n");
1944	break;
1945	}
1946
1947	/* read cmd header from descriptor */
1948	if (0 != wmi_read_hdr(wil, ptr: d_tail.addr, hdr: &hdr)) {
1949	wil_err(wil, "Mbox evt at 0x%08x?\n",
1950	le32_to_cpu(d_tail.addr));
1951	break;
1952	}
1953	len = le16_to_cpu(hdr.len);
1954	wil_dbg_wmi(wil, "Mbox evt %04x %04x %04x %02x\n",
1955	le16_to_cpu(hdr.seq), len, le16_to_cpu(hdr.type),
1956	hdr.flags);
1957
1958	/* read cmd buffer from descriptor */
1959	src = wmi_buffer(wil, ptr_: d_tail.addr) +
1960	sizeof(struct wil6210_mbox_hdr);
1961	evt = kmalloc(ALIGN(offsetof(struct pending_wmi_event,
1962	event.wmi) + len, 4),
1963	GFP_KERNEL);
1964	if (!evt)
1965	break;
1966
1967	evt->event.hdr = hdr;
1968	cmd = (void *)&evt->event.wmi;
1969	wil_memcpy_fromio_32(dst: cmd, src, count: len);
1970	/* mark entry as empty */
1971	wil_w(wil, reg: r->tail +
1972	offsetof(struct wil6210_mbox_ring_desc, sync), val: 0);
1973	/* indicate */
1974	if ((hdr.type == WIL_MBOX_HDR_TYPE_WMI) &&
1975	(len >= sizeof(struct wmi_cmd_hdr))) {
1976	struct wmi_cmd_hdr *wmi = &evt->event.wmi;
1977	u16 id = le16_to_cpu(wmi->command_id);
1978	u8 mid = wmi->mid;
1979	u32 tstamp = le32_to_cpu(wmi->fw_timestamp);
1980	if (test_bit(wil_status_resuming, wil->status)) {
1981	if (id == WMI_TRAFFIC_RESUME_EVENTID)
1982	clear_bit(nr: wil_status_resuming,
1983	addr: wil->status);
1984	else
1985	wil_err(wil,
1986	"WMI evt %d while resuming\n",
1987	id);
1988	}
1989	spin_lock_irqsave(&wil->wmi_ev_lock, flags);
1990	if (wil->reply_id && wil->reply_id == id &&
1991	wil->reply_mid == mid) {
1992	if (wil->reply_buf) {
1993	memcpy(wil->reply_buf, wmi,
1994	min(len, wil->reply_size));
1995	immed_reply = true;
1996	}
1997	if (id == WMI_TRAFFIC_SUSPEND_EVENTID) {
1998	wil_dbg_wmi(wil,
1999	"set suspend_resp_rcvd\n");
2000	wil->suspend_resp_rcvd = true;
2001	}
2002	}
2003	spin_unlock_irqrestore(lock: &wil->wmi_ev_lock, flags);
2004
2005	wil_dbg_wmi(wil, "recv %s (0x%04x) MID %d @%d msec\n",
2006	eventid2name(id), id, wmi->mid, tstamp);
2007	trace_wil6210_wmi_event(wmi, buf: &wmi[1],
2008	buf_len: len - sizeof(*wmi));
2009	}
2010	wil_hex_dump_wmi("evt ", DUMP_PREFIX_OFFSET, 16, 1,
2011	&evt->event.hdr, sizeof(hdr) + len, true);
2012
2013	/* advance tail */
2014	r->tail = r->base + ((r->tail - r->base +
2015	sizeof(struct wil6210_mbox_ring_desc)) % r->size);
2016	wil_w(wil, RGF_MBOX +
2017	offsetof(struct wil6210_mbox_ctl, rx.tail), val: r->tail);
2018
2019	if (immed_reply) {
2020	wil_dbg_wmi(wil, "recv_cmd: Complete WMI 0x%04x\n",
2021	wil->reply_id);
2022	kfree(objp: evt);
2023	num_immed_reply++;
2024	complete(&wil->wmi_call);
2025	} else {
2026	/* add to the pending list */
2027	spin_lock_irqsave(&wil->wmi_ev_lock, flags);
2028	list_add_tail(new: &evt->list, head: &wil->pending_wmi_ev);
2029	spin_unlock_irqrestore(lock: &wil->wmi_ev_lock, flags);
2030	q = queue_work(wq: wil->wmi_wq, work: &wil->wmi_event_worker);
2031	wil_dbg_wmi(wil, "queue_work -> %d\n", q);
2032	}
2033	}
2034	/* normally, 1 event per IRQ should be processed */
2035	wil_dbg_wmi(wil, "recv_cmd: -> %d events queued, %d completed\n",
2036	n - num_immed_reply, num_immed_reply);
2037	}
2038
2039	int wmi_call(struct wil6210_priv *wil, u16 cmdid, u8 mid, void *buf, u16 len,
2040	u16 reply_id, void *reply, u16 reply_size, int to_msec)
2041	{
2042	int rc;
2043	unsigned long remain;
2044	ulong flags;
2045
2046	mutex_lock(&wil->wmi_mutex);
2047
2048	spin_lock_irqsave(&wil->wmi_ev_lock, flags);
2049	wil->reply_id = reply_id;
2050	wil->reply_mid = mid;
2051	wil->reply_buf = reply;
2052	wil->reply_size = reply_size;
2053	reinit_completion(x: &wil->wmi_call);
2054	spin_unlock_irqrestore(lock: &wil->wmi_ev_lock, flags);
2055
2056	rc = __wmi_send(wil, cmdid, mid, buf, len);
2057	if (rc)
2058	goto out;
2059
2060	remain = wait_for_completion_timeout(x: &wil->wmi_call,
2061	timeout: msecs_to_jiffies(m: to_msec));
2062	if (0 == remain) {
2063	wil_err(wil, "wmi_call(0x%04x->0x%04x) timeout %d msec\n",
2064	cmdid, reply_id, to_msec);
2065	rc = -ETIME;
2066	} else {
2067	wil_dbg_wmi(wil,
2068	"wmi_call(0x%04x->0x%04x) completed in %d msec\n",
2069	cmdid, reply_id,
2070	to_msec - jiffies_to_msecs(remain));
2071	}
2072
2073	out:
2074	spin_lock_irqsave(&wil->wmi_ev_lock, flags);
2075	wil->reply_id = 0;
2076	wil->reply_mid = U8_MAX;
2077	wil->reply_buf = NULL;
2078	wil->reply_size = 0;
2079	spin_unlock_irqrestore(lock: &wil->wmi_ev_lock, flags);
2080
2081	mutex_unlock(lock: &wil->wmi_mutex);
2082
2083	return rc;
2084	}
2085
2086	int wmi_echo(struct wil6210_priv *wil)
2087	{
2088	struct wil6210_vif *vif = ndev_to_vif(wil->main_ndev);
2089	struct wmi_echo_cmd cmd = {
2090	.value = cpu_to_le32(0x12345678),
2091	};
2092
2093	return wmi_call(wil, cmdid: WMI_ECHO_CMDID, mid: vif->mid, buf: &cmd, len: sizeof(cmd),
2094	reply_id: WMI_ECHO_RSP_EVENTID, NULL, reply_size: 0,
2095	WIL_WMI_CALL_GENERAL_TO_MS);
2096	}
2097
2098	int wmi_set_mac_address(struct wil6210_priv *wil, const void *addr)
2099	{
2100	struct wil6210_vif *vif = ndev_to_vif(wil->main_ndev);
2101	struct wmi_set_mac_address_cmd cmd;
2102
2103	ether_addr_copy(dst: cmd.mac, src: addr);
2104
2105	wil_dbg_wmi(wil, "Set MAC %pM\n", addr);
2106
2107	return wmi_send(wil, cmdid: WMI_SET_MAC_ADDRESS_CMDID, mid: vif->mid,
2108	buf: &cmd, len: sizeof(cmd));
2109	}
2110
2111	int wmi_led_cfg(struct wil6210_priv *wil, bool enable)
2112	{
2113	struct wil6210_vif *vif = ndev_to_vif(wil->main_ndev);
2114	int rc = 0;
2115	struct wmi_led_cfg_cmd cmd = {
2116	.led_mode = enable,
2117	.id = led_id,
2118	.slow_blink_cfg.blink_on =
2119	cpu_to_le32(led_blink_time[WIL_LED_TIME_SLOW].on_ms),
2120	.slow_blink_cfg.blink_off =
2121	cpu_to_le32(led_blink_time[WIL_LED_TIME_SLOW].off_ms),
2122	.medium_blink_cfg.blink_on =
2123	cpu_to_le32(led_blink_time[WIL_LED_TIME_MED].on_ms),
2124	.medium_blink_cfg.blink_off =
2125	cpu_to_le32(led_blink_time[WIL_LED_TIME_MED].off_ms),
2126	.fast_blink_cfg.blink_on =
2127	cpu_to_le32(led_blink_time[WIL_LED_TIME_FAST].on_ms),
2128	.fast_blink_cfg.blink_off =
2129	cpu_to_le32(led_blink_time[WIL_LED_TIME_FAST].off_ms),
2130	.led_polarity = led_polarity,
2131	};
2132	struct {
2133	struct wmi_cmd_hdr wmi;
2134	struct wmi_led_cfg_done_event evt;
2135	} __packed reply = {
2136	.evt = {.status = cpu_to_le32(WMI_FW_STATUS_FAILURE)},
2137	};
2138
2139	if (led_id == WIL_LED_INVALID_ID)
2140	goto out;
2141
2142	if (led_id > WIL_LED_MAX_ID) {
2143	wil_err(wil, "Invalid led id %d\n", led_id);
2144	rc = -EINVAL;
2145	goto out;
2146	}
2147
2148	wil_dbg_wmi(wil,
2149	"%s led %d\n",
2150	enable ? "enabling" : "disabling", led_id);
2151
2152	rc = wmi_call(wil, cmdid: WMI_LED_CFG_CMDID, mid: vif->mid, buf: &cmd, len: sizeof(cmd),
2153	reply_id: WMI_LED_CFG_DONE_EVENTID, reply: &reply, reply_size: sizeof(reply),
2154	WIL_WMI_CALL_GENERAL_TO_MS);
2155	if (rc)
2156	goto out;
2157
2158	if (reply.evt.status) {
2159	wil_err(wil, "led %d cfg failed with status %d\n",
2160	led_id, le32_to_cpu(reply.evt.status));
2161	rc = -EINVAL;
2162	}
2163
2164	out:
2165	return rc;
2166	}
2167
2168	int wmi_rbufcap_cfg(struct wil6210_priv *wil, bool enable, u16 threshold)
2169	{
2170	struct wil6210_vif *vif = ndev_to_vif(wil->main_ndev);
2171	int rc;
2172
2173	struct wmi_rbufcap_cfg_cmd cmd = {
2174	.enable = enable,
2175	.rx_desc_threshold = cpu_to_le16(threshold),
2176	};
2177	struct {
2178	struct wmi_cmd_hdr wmi;
2179	struct wmi_rbufcap_cfg_event evt;
2180	} __packed reply = {
2181	.evt = {.status = WMI_FW_STATUS_FAILURE},
2182	};
2183
2184	rc = wmi_call(wil, cmdid: WMI_RBUFCAP_CFG_CMDID, mid: vif->mid, buf: &cmd, len: sizeof(cmd),
2185	reply_id: WMI_RBUFCAP_CFG_EVENTID, reply: &reply, reply_size: sizeof(reply),
2186	WIL_WMI_CALL_GENERAL_TO_MS);
2187	if (rc)
2188	return rc;
2189
2190	if (reply.evt.status != WMI_FW_STATUS_SUCCESS) {
2191	wil_err(wil, "RBUFCAP_CFG failed. status %d\n",
2192	reply.evt.status);
2193	rc = -EINVAL;
2194	}
2195
2196	return rc;
2197	}
2198
2199	int wmi_pcp_start(struct wil6210_vif *vif, int bi, u8 wmi_nettype,
2200	u8 chan, u8 wmi_edmg_chan, u8 hidden_ssid, u8 is_go)
2201	{
2202	struct wil6210_priv *wil = vif_to_wil(vif);
2203	int rc;
2204
2205	struct wmi_pcp_start_cmd cmd = {
2206	.bcon_interval = cpu_to_le16(bi),
2207	.network_type = wmi_nettype,
2208	.disable_sec_offload = 1,
2209	.channel = chan - 1,
2210	.edmg_channel = wmi_edmg_chan,
2211	.pcp_max_assoc_sta = wil->max_assoc_sta,
2212	.hidden_ssid = hidden_ssid,
2213	.is_go = is_go,
2214	.ap_sme_offload_mode = disable_ap_sme ?
2215	WMI_AP_SME_OFFLOAD_PARTIAL :
2216	WMI_AP_SME_OFFLOAD_FULL,
2217	.abft_len = wil->abft_len,
2218	};
2219	struct {
2220	struct wmi_cmd_hdr wmi;
2221	struct wmi_pcp_started_event evt;
2222	} __packed reply = {
2223	.evt = {.status = WMI_FW_STATUS_FAILURE},
2224	};
2225
2226	if (!vif->privacy)
2227	cmd.disable_sec = 1;
2228
2229	if ((cmd.pcp_max_assoc_sta > WIL6210_MAX_CID) ||
2230	(cmd.pcp_max_assoc_sta <= 0)) {
2231	wil_err(wil, "unexpected max_assoc_sta %d\n",
2232	cmd.pcp_max_assoc_sta);
2233	return -EOPNOTSUPP;
2234	}
2235
2236	if (disable_ap_sme &&
2237	!test_bit(WMI_FW_CAPABILITY_AP_SME_OFFLOAD_PARTIAL,
2238	wil->fw_capabilities)) {
2239	wil_err(wil, "disable_ap_sme not supported by FW\n");
2240	return -EOPNOTSUPP;
2241	}
2242
2243	/*
2244	* Processing time may be huge, in case of secure AP it takes about
2245	* 3500ms for FW to start AP
2246	*/
2247	rc = wmi_call(wil, cmdid: WMI_PCP_START_CMDID, mid: vif->mid, buf: &cmd, len: sizeof(cmd),
2248	reply_id: WMI_PCP_STARTED_EVENTID, reply: &reply, reply_size: sizeof(reply), to_msec: 5000);
2249	if (rc)
2250	return rc;
2251
2252	if (reply.evt.status != WMI_FW_STATUS_SUCCESS)
2253	rc = -EINVAL;
2254
2255	if (wmi_nettype != WMI_NETTYPE_P2P)
2256	/* Don't fail due to error in the led configuration */
2257	wmi_led_cfg(wil, enable: true);
2258
2259	return rc;
2260	}
2261
2262	int wmi_pcp_stop(struct wil6210_vif *vif)
2263	{
2264	struct wil6210_priv *wil = vif_to_wil(vif);
2265	int rc;
2266
2267	rc = wmi_led_cfg(wil, enable: false);
2268	if (rc)
2269	return rc;
2270
2271	return wmi_call(wil, cmdid: WMI_PCP_STOP_CMDID, mid: vif->mid, NULL, len: 0,
2272	reply_id: WMI_PCP_STOPPED_EVENTID, NULL, reply_size: 0,
2273	WIL_WMI_PCP_STOP_TO_MS);
2274	}
2275
2276	int wmi_set_ssid(struct wil6210_vif *vif, u8 ssid_len, const void *ssid)
2277	{
2278	struct wil6210_priv *wil = vif_to_wil(vif);
2279	struct wmi_set_ssid_cmd cmd = {
2280	.ssid_len = cpu_to_le32(ssid_len),
2281	};
2282
2283	if (ssid_len > sizeof(cmd.ssid))
2284	return -EINVAL;
2285
2286	memcpy(cmd.ssid, ssid, ssid_len);
2287
2288	return wmi_send(wil, cmdid: WMI_SET_SSID_CMDID, mid: vif->mid, buf: &cmd, len: sizeof(cmd));
2289	}
2290
2291	int wmi_get_ssid(struct wil6210_vif *vif, u8 *ssid_len, void *ssid)
2292	{
2293	struct wil6210_priv *wil = vif_to_wil(vif);
2294	int rc;
2295	struct {
2296	struct wmi_cmd_hdr wmi;
2297	struct wmi_set_ssid_cmd cmd;
2298	} __packed reply;
2299	int len; /* reply.cmd.ssid_len in CPU order */
2300
2301	memset(&reply, 0, sizeof(reply));
2302
2303	rc = wmi_call(wil, cmdid: WMI_GET_SSID_CMDID, mid: vif->mid, NULL, len: 0,
2304	reply_id: WMI_GET_SSID_EVENTID, reply: &reply, reply_size: sizeof(reply),
2305	WIL_WMI_CALL_GENERAL_TO_MS);
2306	if (rc)
2307	return rc;
2308
2309	len = le32_to_cpu(reply.cmd.ssid_len);
2310	if (len > sizeof(reply.cmd.ssid))
2311	return -EINVAL;
2312
2313	*ssid_len = len;
2314	memcpy(ssid, reply.cmd.ssid, len);
2315
2316	return 0;
2317	}
2318
2319	int wmi_set_channel(struct wil6210_priv *wil, int channel)
2320	{
2321	struct wil6210_vif *vif = ndev_to_vif(wil->main_ndev);
2322	struct wmi_set_pcp_channel_cmd cmd = {
2323	.channel = channel - 1,
2324	};
2325
2326	return wmi_send(wil, cmdid: WMI_SET_PCP_CHANNEL_CMDID, mid: vif->mid,
2327	buf: &cmd, len: sizeof(cmd));
2328	}
2329
2330	int wmi_get_channel(struct wil6210_priv *wil, int *channel)
2331	{
2332	struct wil6210_vif *vif = ndev_to_vif(wil->main_ndev);
2333	int rc;
2334	struct {
2335	struct wmi_cmd_hdr wmi;
2336	struct wmi_set_pcp_channel_cmd cmd;
2337	} __packed reply;
2338
2339	memset(&reply, 0, sizeof(reply));
2340
2341	rc = wmi_call(wil, cmdid: WMI_GET_PCP_CHANNEL_CMDID, mid: vif->mid, NULL, len: 0,
2342	reply_id: WMI_GET_PCP_CHANNEL_EVENTID, reply: &reply, reply_size: sizeof(reply),
2343	WIL_WMI_CALL_GENERAL_TO_MS);
2344	if (rc)
2345	return rc;
2346
2347	if (reply.cmd.channel > 3)
2348	return -EINVAL;
2349
2350	*channel = reply.cmd.channel + 1;
2351
2352	return 0;
2353	}
2354
2355	int wmi_p2p_cfg(struct wil6210_vif *vif, int channel, int bi)
2356	{
2357	struct wil6210_priv *wil = vif_to_wil(vif);
2358	int rc;
2359	struct wmi_p2p_cfg_cmd cmd = {
2360	.discovery_mode = WMI_DISCOVERY_MODE_PEER2PEER,
2361	.bcon_interval = cpu_to_le16(bi),
2362	.channel = channel - 1,
2363	};
2364	struct {
2365	struct wmi_cmd_hdr wmi;
2366	struct wmi_p2p_cfg_done_event evt;
2367	} __packed reply = {
2368	.evt = {.status = WMI_FW_STATUS_FAILURE},
2369	};
2370
2371	wil_dbg_wmi(wil, "sending WMI_P2P_CFG_CMDID\n");
2372
2373	rc = wmi_call(wil, cmdid: WMI_P2P_CFG_CMDID, mid: vif->mid, buf: &cmd, len: sizeof(cmd),
2374	reply_id: WMI_P2P_CFG_DONE_EVENTID, reply: &reply, reply_size: sizeof(reply), to_msec: 300);
2375	if (!rc && reply.evt.status != WMI_FW_STATUS_SUCCESS) {
2376	wil_err(wil, "P2P_CFG failed. status %d\n", reply.evt.status);
2377	rc = -EINVAL;
2378	}
2379
2380	return rc;
2381	}
2382
2383	int wmi_start_listen(struct wil6210_vif *vif)
2384	{
2385	struct wil6210_priv *wil = vif_to_wil(vif);
2386	int rc;
2387	struct {
2388	struct wmi_cmd_hdr wmi;
2389	struct wmi_listen_started_event evt;
2390	} __packed reply = {
2391	.evt = {.status = WMI_FW_STATUS_FAILURE},
2392	};
2393
2394	wil_dbg_wmi(wil, "sending WMI_START_LISTEN_CMDID\n");
2395
2396	rc = wmi_call(wil, cmdid: WMI_START_LISTEN_CMDID, mid: vif->mid, NULL, len: 0,
2397	reply_id: WMI_LISTEN_STARTED_EVENTID, reply: &reply, reply_size: sizeof(reply), to_msec: 300);
2398	if (!rc && reply.evt.status != WMI_FW_STATUS_SUCCESS) {
2399	wil_err(wil, "device failed to start listen. status %d\n",
2400	reply.evt.status);
2401	rc = -EINVAL;
2402	}
2403
2404	return rc;
2405	}
2406
2407	int wmi_start_search(struct wil6210_vif *vif)
2408	{
2409	struct wil6210_priv *wil = vif_to_wil(vif);
2410	int rc;
2411	struct {
2412	struct wmi_cmd_hdr wmi;
2413	struct wmi_search_started_event evt;
2414	} __packed reply = {
2415	.evt = {.status = WMI_FW_STATUS_FAILURE},
2416	};
2417
2418	wil_dbg_wmi(wil, "sending WMI_START_SEARCH_CMDID\n");
2419
2420	rc = wmi_call(wil, cmdid: WMI_START_SEARCH_CMDID, mid: vif->mid, NULL, len: 0,
2421	reply_id: WMI_SEARCH_STARTED_EVENTID, reply: &reply, reply_size: sizeof(reply), to_msec: 300);
2422	if (!rc && reply.evt.status != WMI_FW_STATUS_SUCCESS) {
2423	wil_err(wil, "device failed to start search. status %d\n",
2424	reply.evt.status);
2425	rc = -EINVAL;
2426	}
2427
2428	return rc;
2429	}
2430
2431	int wmi_stop_discovery(struct wil6210_vif *vif)
2432	{
2433	struct wil6210_priv *wil = vif_to_wil(vif);
2434	int rc;
2435
2436	wil_dbg_wmi(wil, "sending WMI_DISCOVERY_STOP_CMDID\n");
2437
2438	rc = wmi_call(wil, cmdid: WMI_DISCOVERY_STOP_CMDID, mid: vif->mid, NULL, len: 0,
2439	reply_id: WMI_DISCOVERY_STOPPED_EVENTID, NULL, reply_size: 0,
2440	WIL_WMI_CALL_GENERAL_TO_MS);
2441
2442	if (rc)
2443	wil_err(wil, "Failed to stop discovery\n");
2444
2445	return rc;
2446	}
2447
2448	int wmi_del_cipher_key(struct wil6210_vif *vif, u8 key_index,
2449	const void *mac_addr, int key_usage)
2450	{
2451	struct wil6210_priv *wil = vif_to_wil(vif);
2452	struct wmi_delete_cipher_key_cmd cmd = {
2453	.key_index = key_index,
2454	};
2455
2456	if (mac_addr)
2457	memcpy(cmd.mac, mac_addr, WMI_MAC_LEN);
2458
2459	return wmi_send(wil, cmdid: WMI_DELETE_CIPHER_KEY_CMDID, mid: vif->mid,
2460	buf: &cmd, len: sizeof(cmd));
2461	}
2462
2463	int wmi_add_cipher_key(struct wil6210_vif *vif, u8 key_index,
2464	const void *mac_addr, int key_len, const void *key,
2465	int key_usage)
2466	{
2467	struct wil6210_priv *wil = vif_to_wil(vif);
2468	struct wmi_add_cipher_key_cmd cmd = {
2469	.key_index = key_index,
2470	.key_usage = key_usage,
2471	.key_len = key_len,
2472	};
2473
2474	if (key_len > sizeof(cmd.key))
2475	return -EINVAL;
2476
2477	/* key len = 0 is allowed only for usage of WMI_KEY_USE_APPLY */
2478	if ((key_len == 0 || !key) &&
2479	key_usage != WMI_KEY_USE_APPLY_PTK)
2480	return -EINVAL;
2481
2482	if (key)
2483	memcpy(cmd.key, key, key_len);
2484
2485	if (mac_addr)
2486	memcpy(cmd.mac, mac_addr, WMI_MAC_LEN);
2487
2488	return wmi_send(wil, cmdid: WMI_ADD_CIPHER_KEY_CMDID, mid: vif->mid,
2489	buf: &cmd, len: sizeof(cmd));
2490	}
2491
2492	int wmi_set_ie(struct wil6210_vif *vif, u8 type, u16 ie_len, const void *ie)
2493	{
2494	struct wil6210_priv *wil = vif_to_wil(vif);
2495	static const char *const names[] = {
2496	[WMI_FRAME_BEACON] = "BEACON",
2497	[WMI_FRAME_PROBE_REQ] = "PROBE_REQ",
2498	[WMI_FRAME_PROBE_RESP] = "WMI_FRAME_PROBE_RESP",
2499	[WMI_FRAME_ASSOC_REQ] = "WMI_FRAME_ASSOC_REQ",
2500	[WMI_FRAME_ASSOC_RESP] = "WMI_FRAME_ASSOC_RESP",
2501	};
2502	int rc;
2503	u16 len = sizeof(struct wmi_set_appie_cmd) + ie_len;
2504	struct wmi_set_appie_cmd *cmd;
2505
2506	if (len < ie_len) {
2507	rc = -EINVAL;
2508	goto out;
2509	}
2510
2511	cmd = kzalloc(size: len, GFP_KERNEL);
2512	if (!cmd) {
2513	rc = -ENOMEM;
2514	goto out;
2515	}
2516	if (!ie)
2517	ie_len = 0;
2518
2519	cmd->mgmt_frm_type = type;
2520	/* BUG: FW API define ieLen as u8. Will fix FW */
2521	cmd->ie_len = cpu_to_le16(ie_len);
2522	if (ie_len)
2523	memcpy(cmd->ie_info, ie, ie_len);
2524	rc = wmi_send(wil, cmdid: WMI_SET_APPIE_CMDID, mid: vif->mid, buf: cmd, len);
2525	kfree(objp: cmd);
2526	out:
2527	if (rc) {
2528	const char *name = type < ARRAY_SIZE(names) ?
2529	names[type] : "??";
2530	wil_err(wil, "set_ie(%d %s) failed : %d\n", type, name, rc);
2531	}
2532
2533	return rc;
2534	}
2535
2536	int wmi_update_ft_ies(struct wil6210_vif *vif, u16 ie_len, const void *ie)
2537	{
2538	struct wil6210_priv *wil = vif_to_wil(vif);
2539	u16 len;
2540	struct wmi_update_ft_ies_cmd *cmd;
2541	int rc;
2542
2543	if (!ie)
2544	ie_len = 0;
2545
2546	len = sizeof(struct wmi_update_ft_ies_cmd) + ie_len;
2547	if (len < ie_len) {
2548	wil_err(wil, "wraparound. ie len %d\n", ie_len);
2549	return -EINVAL;
2550	}
2551
2552	cmd = kzalloc(size: len, GFP_KERNEL);
2553	if (!cmd) {
2554	rc = -ENOMEM;
2555	goto out;
2556	}
2557
2558	cmd->ie_len = cpu_to_le16(ie_len);
2559	if (ie_len)
2560	memcpy(cmd->ie_info, ie, ie_len);
2561	rc = wmi_send(wil, cmdid: WMI_UPDATE_FT_IES_CMDID, mid: vif->mid, buf: cmd, len);
2562	kfree(objp: cmd);
2563
2564	out:
2565	if (rc)
2566	wil_err(wil, "update ft ies failed : %d\n", rc);
2567
2568	return rc;
2569	}
2570
2571	/**
2572	* wmi_rxon - turn radio on/off
2573	* @wil: driver data
2574	* @on: turn on if true, off otherwise
2575	*
2576	* Only switch radio. Channel should be set separately.
2577	* No timeout for rxon - radio turned on forever unless some other call
2578	* turns it off
2579	*/
2580	int wmi_rxon(struct wil6210_priv *wil, bool on)
2581	{
2582	struct wil6210_vif *vif = ndev_to_vif(wil->main_ndev);
2583	int rc;
2584	struct {
2585	struct wmi_cmd_hdr wmi;
2586	struct wmi_listen_started_event evt;
2587	} __packed reply = {
2588	.evt = {.status = WMI_FW_STATUS_FAILURE},
2589	};
2590
2591	wil_info(wil, "(%s)\n", on ? "on" : "off");
2592
2593	if (on) {
2594	rc = wmi_call(wil, cmdid: WMI_START_LISTEN_CMDID, mid: vif->mid, NULL, len: 0,
2595	reply_id: WMI_LISTEN_STARTED_EVENTID,
2596	reply: &reply, reply_size: sizeof(reply),
2597	WIL_WMI_CALL_GENERAL_TO_MS);
2598	if ((rc == 0) && (reply.evt.status != WMI_FW_STATUS_SUCCESS))
2599	rc = -EINVAL;
2600	} else {
2601	rc = wmi_call(wil, cmdid: WMI_DISCOVERY_STOP_CMDID, mid: vif->mid, NULL, len: 0,
2602	reply_id: WMI_DISCOVERY_STOPPED_EVENTID, NULL, reply_size: 0,
2603	WIL_WMI_CALL_GENERAL_TO_MS);
2604	}
2605
2606	return rc;
2607	}
2608
2609	int wmi_rx_chain_add(struct wil6210_priv *wil, struct wil_ring *vring)
2610	{
2611	struct net_device *ndev = wil->main_ndev;
2612	struct wireless_dev *wdev = ndev->ieee80211_ptr;
2613	struct wil6210_vif *vif = ndev_to_vif(ndev);
2614	struct wmi_cfg_rx_chain_cmd cmd = {
2615	.action = WMI_RX_CHAIN_ADD,
2616	.rx_sw_ring = {
2617	.max_mpdu_size = cpu_to_le16(
2618	wil_mtu2macbuf(wil->rx_buf_len)),
2619	.ring_mem_base = cpu_to_le64(vring->pa),
2620	.ring_size = cpu_to_le16(vring->size),
2621	},
2622	.mid = 0, /* TODO - what is it? */
2623	.decap_trans_type = WMI_DECAP_TYPE_802_3,
2624	.reorder_type = WMI_RX_SW_REORDER,
2625	.host_thrsh = cpu_to_le16(rx_ring_overflow_thrsh),
2626	};
2627	struct {
2628	struct wmi_cmd_hdr wmi;
2629	struct wmi_cfg_rx_chain_done_event evt;
2630	} __packed evt;
2631	int rc;
2632
2633	memset(&evt, 0, sizeof(evt));
2634
2635	if (wdev->iftype == NL80211_IFTYPE_MONITOR) {
2636	struct ieee80211_channel *ch = wil->monitor_chandef.chan;
2637
2638	cmd.sniffer_cfg.mode = cpu_to_le32(WMI_SNIFFER_ON);
2639	if (ch)
2640	cmd.sniffer_cfg.channel = ch->hw_value - 1;
2641	cmd.sniffer_cfg.phy_info_mode =
2642	cpu_to_le32(WMI_SNIFFER_PHY_INFO_DISABLED);
2643	cmd.sniffer_cfg.phy_support =
2644	cpu_to_le32((wil->monitor_flags & MONITOR_FLAG_CONTROL)
2645	? WMI_SNIFFER_CP : WMI_SNIFFER_BOTH_PHYS);
2646	} else {
2647	/* Initialize offload (in non-sniffer mode).
2648	* Linux IP stack always calculates IP checksum
2649	* HW always calculate TCP/UDP checksum
2650	*/
2651	cmd.l3_l4_ctrl |= (1 << L3_L4_CTRL_TCPIP_CHECKSUM_EN_POS);
2652	}
2653
2654	if (rx_align_2)
2655	cmd.l2_802_3_offload_ctrl |=
2656	L2_802_3_OFFLOAD_CTRL_SNAP_KEEP_MSK;
2657
2658	/* typical time for secure PCP is 840ms */
2659	rc = wmi_call(wil, cmdid: WMI_CFG_RX_CHAIN_CMDID, mid: vif->mid, buf: &cmd, len: sizeof(cmd),
2660	reply_id: WMI_CFG_RX_CHAIN_DONE_EVENTID, reply: &evt, reply_size: sizeof(evt), to_msec: 2000);
2661	if (rc)
2662	return rc;
2663
2664	if (le32_to_cpu(evt.evt.status) != WMI_CFG_RX_CHAIN_SUCCESS)
2665	rc = -EINVAL;
2666
2667	vring->hwtail = le32_to_cpu(evt.evt.rx_ring_tail_ptr);
2668
2669	wil_dbg_misc(wil, "Rx init: status %d tail 0x%08x\n",
2670	le32_to_cpu(evt.evt.status), vring->hwtail);
2671
2672	return rc;
2673	}
2674
2675	int wmi_get_temperature(struct wil6210_priv *wil, u32 *t_bb, u32 *t_rf)
2676	{
2677	struct wil6210_vif *vif = ndev_to_vif(wil->main_ndev);
2678	int rc;
2679	struct wmi_temp_sense_cmd cmd = {
2680	.measure_baseband_en = cpu_to_le32(!!t_bb),
2681	.measure_rf_en = cpu_to_le32(!!t_rf),
2682	.measure_mode = cpu_to_le32(TEMPERATURE_MEASURE_NOW),
2683	};
2684	struct {
2685	struct wmi_cmd_hdr wmi;
2686	struct wmi_temp_sense_done_event evt;
2687	} __packed reply;
2688
2689	memset(&reply, 0, sizeof(reply));
2690
2691	rc = wmi_call(wil, cmdid: WMI_TEMP_SENSE_CMDID, mid: vif->mid, buf: &cmd, len: sizeof(cmd),
2692	reply_id: WMI_TEMP_SENSE_DONE_EVENTID, reply: &reply, reply_size: sizeof(reply),
2693	WIL_WMI_CALL_GENERAL_TO_MS);
2694	if (rc)
2695	return rc;
2696
2697	if (t_bb)
2698	*t_bb = le32_to_cpu(reply.evt.baseband_t1000);
2699	if (t_rf)
2700	*t_rf = le32_to_cpu(reply.evt.rf_t1000);
2701
2702	return 0;
2703	}
2704
2705	int wmi_get_all_temperatures(struct wil6210_priv *wil,
2706	struct wmi_temp_sense_all_done_event
2707	*sense_all_evt)
2708	{
2709	struct wil6210_vif *vif = ndev_to_vif(wil->main_ndev);
2710	int rc;
2711	struct wmi_temp_sense_all_cmd cmd = {
2712	.measure_baseband_en = true,
2713	.measure_rf_en = true,
2714	.measure_mode = TEMPERATURE_MEASURE_NOW,
2715	};
2716	struct {
2717	struct wmi_cmd_hdr wmi;
2718	struct wmi_temp_sense_all_done_event evt;
2719	} __packed reply;
2720
2721	if (!sense_all_evt) {
2722	wil_err(wil, "Invalid sense_all_evt value\n");
2723	return -EINVAL;
2724	}
2725
2726	memset(&reply, 0, sizeof(reply));
2727	reply.evt.status = WMI_FW_STATUS_FAILURE;
2728	rc = wmi_call(wil, cmdid: WMI_TEMP_SENSE_ALL_CMDID, mid: vif->mid, buf: &cmd,
2729	len: sizeof(cmd), reply_id: WMI_TEMP_SENSE_ALL_DONE_EVENTID,
2730	reply: &reply, reply_size: sizeof(reply), WIL_WMI_CALL_GENERAL_TO_MS);
2731	if (rc)
2732	return rc;
2733
2734	if (reply.evt.status == WMI_FW_STATUS_FAILURE) {
2735	wil_err(wil, "Failed getting TEMP_SENSE_ALL\n");
2736	return -EINVAL;
2737	}
2738
2739	memcpy(sense_all_evt, &reply.evt, sizeof(reply.evt));
2740	return 0;
2741	}
2742
2743	int wmi_disconnect_sta(struct wil6210_vif *vif, const u8 *mac, u16 reason,
2744	bool del_sta)
2745	{
2746	struct wil6210_priv *wil = vif_to_wil(vif);
2747	int rc;
2748	struct wmi_disconnect_sta_cmd disc_sta_cmd = {
2749	.disconnect_reason = cpu_to_le16(reason),
2750	};
2751	struct wmi_del_sta_cmd del_sta_cmd = {
2752	.disconnect_reason = cpu_to_le16(reason),
2753	};
2754	struct {
2755	struct wmi_cmd_hdr wmi;
2756	struct wmi_disconnect_event evt;
2757	} __packed reply;
2758
2759	wil_dbg_wmi(wil, "disconnect_sta: (%pM, reason %d)\n", mac, reason);
2760
2761	memset(&reply, 0, sizeof(reply));
2762	vif->locally_generated_disc = true;
2763	if (del_sta) {
2764	ether_addr_copy(dst: del_sta_cmd.dst_mac, src: mac);
2765	rc = wmi_call(wil, cmdid: WMI_DEL_STA_CMDID, mid: vif->mid, buf: &del_sta_cmd,
2766	len: sizeof(del_sta_cmd), reply_id: WMI_DISCONNECT_EVENTID,
2767	reply: &reply, reply_size: sizeof(reply), to_msec: 1000);
2768	} else {
2769	ether_addr_copy(dst: disc_sta_cmd.dst_mac, src: mac);
2770	rc = wmi_call(wil, cmdid: WMI_DISCONNECT_STA_CMDID, mid: vif->mid,
2771	buf: &disc_sta_cmd, len: sizeof(disc_sta_cmd),
2772	reply_id: WMI_DISCONNECT_EVENTID,
2773	reply: &reply, reply_size: sizeof(reply), to_msec: 1000);
2774	}
2775	/* failure to disconnect in reasonable time treated as FW error */
2776	if (rc) {
2777	wil_fw_error_recovery(wil);
2778	return rc;
2779	}
2780	wil->sinfo_gen++;
2781
2782	return 0;
2783	}
2784
2785	int wmi_addba(struct wil6210_priv *wil, u8 mid,
2786	u8 ringid, u8 size, u16 timeout)
2787	{
2788	u8 amsdu = wil->use_enhanced_dma_hw && wil->use_rx_hw_reordering &&
2789	test_bit(WMI_FW_CAPABILITY_AMSDU, wil->fw_capabilities) &&
2790	wil->amsdu_en;
2791	struct wmi_ring_ba_en_cmd cmd = {
2792	.ring_id = ringid,
2793	.agg_max_wsize = size,
2794	.ba_timeout = cpu_to_le16(timeout),
2795	.amsdu = amsdu,
2796	};
2797
2798	wil_dbg_wmi(wil, "addba: (ring %d size %d timeout %d amsdu %d)\n",
2799	ringid, size, timeout, amsdu);
2800
2801	return wmi_send(wil, cmdid: WMI_RING_BA_EN_CMDID, mid, buf: &cmd, len: sizeof(cmd));
2802	}
2803
2804	int wmi_delba_tx(struct wil6210_priv *wil, u8 mid, u8 ringid, u16 reason)
2805	{
2806	struct wmi_ring_ba_dis_cmd cmd = {
2807	.ring_id = ringid,
2808	.reason = cpu_to_le16(reason),
2809	};
2810
2811	wil_dbg_wmi(wil, "delba_tx: (ring %d reason %d)\n", ringid, reason);
2812
2813	return wmi_send(wil, cmdid: WMI_RING_BA_DIS_CMDID, mid, buf: &cmd, len: sizeof(cmd));
2814	}
2815
2816	int wmi_delba_rx(struct wil6210_priv *wil, u8 mid, u8 cid, u8 tid, u16 reason)
2817	{
2818	struct wmi_rcp_delba_cmd cmd = {
2819	.reason = cpu_to_le16(reason),
2820	};
2821
2822	if (cid >= WIL6210_RX_DESC_MAX_CID) {
2823	cmd.cidxtid = CIDXTID_EXTENDED_CID_TID;
2824	cmd.cid = cid;
2825	cmd.tid = tid;
2826	} else {
2827	cmd.cidxtid = mk_cidxtid(cid, tid);
2828	}
2829
2830	wil_dbg_wmi(wil, "delba_rx: (CID %d TID %d reason %d)\n", cid,
2831	tid, reason);
2832
2833	return wmi_send(wil, cmdid: WMI_RCP_DELBA_CMDID, mid, buf: &cmd, len: sizeof(cmd));
2834	}
2835
2836	int wmi_addba_rx_resp(struct wil6210_priv *wil,
2837	u8 mid, u8 cid, u8 tid, u8 token,
2838	u16 status, bool amsdu, u16 agg_wsize, u16 timeout)
2839	{
2840	int rc;
2841	struct wmi_rcp_addba_resp_cmd cmd = {
2842	.dialog_token = token,
2843	.status_code = cpu_to_le16(status),
2844	/* bit 0: A-MSDU supported
2845	* bit 1: policy (controlled by FW)
2846	* bits 2..5: TID
2847	* bits 6..15: buffer size
2848	*/
2849	.ba_param_set = cpu_to_le16((amsdu ? 1 : 0) | (tid << 2) |
2850	(agg_wsize << 6)),
2851	.ba_timeout = cpu_to_le16(timeout),
2852	};
2853	struct {
2854	struct wmi_cmd_hdr wmi;
2855	struct wmi_rcp_addba_resp_sent_event evt;
2856	} __packed reply = {
2857	.evt = {.status = cpu_to_le16(WMI_FW_STATUS_FAILURE)},
2858	};
2859
2860	if (cid >= WIL6210_RX_DESC_MAX_CID) {
2861	cmd.cidxtid = CIDXTID_EXTENDED_CID_TID;
2862	cmd.cid = cid;
2863	cmd.tid = tid;
2864	} else {
2865	cmd.cidxtid = mk_cidxtid(cid, tid);
2866	}
2867
2868	wil_dbg_wmi(wil,
2869	"ADDBA response for MID %d CID %d TID %d size %d timeout %d status %d AMSDU%s\n",
2870	mid, cid, tid, agg_wsize,
2871	timeout, status, amsdu ? "+" : "-");
2872
2873	rc = wmi_call(wil, cmdid: WMI_RCP_ADDBA_RESP_CMDID, mid, buf: &cmd, len: sizeof(cmd),
2874	reply_id: WMI_RCP_ADDBA_RESP_SENT_EVENTID, reply: &reply, reply_size: sizeof(reply),
2875	WIL_WMI_CALL_GENERAL_TO_MS);
2876	if (rc)
2877	return rc;
2878
2879	if (reply.evt.status) {
2880	wil_err(wil, "ADDBA response failed with status %d\n",
2881	le16_to_cpu(reply.evt.status));
2882	rc = -EINVAL;
2883	}
2884
2885	return rc;
2886	}
2887
2888	int wmi_addba_rx_resp_edma(struct wil6210_priv *wil, u8 mid, u8 cid, u8 tid,
2889	u8 token, u16 status, bool amsdu, u16 agg_wsize,
2890	u16 timeout)
2891	{
2892	int rc;
2893	struct wmi_rcp_addba_resp_edma_cmd cmd = {
2894	.cid = cid,
2895	.tid = tid,
2896	.dialog_token = token,
2897	.status_code = cpu_to_le16(status),
2898	/* bit 0: A-MSDU supported
2899	* bit 1: policy (controlled by FW)
2900	* bits 2..5: TID
2901	* bits 6..15: buffer size
2902	*/
2903	.ba_param_set = cpu_to_le16((amsdu ? 1 : 0) | (tid << 2) |
2904	(agg_wsize << 6)),
2905	.ba_timeout = cpu_to_le16(timeout),
2906	/* route all the connections to status ring 0 */
2907	.status_ring_id = WIL_DEFAULT_RX_STATUS_RING_ID,
2908	};
2909	struct {
2910	struct wmi_cmd_hdr wmi;
2911	struct wmi_rcp_addba_resp_sent_event evt;
2912	} __packed reply = {
2913	.evt = {.status = cpu_to_le16(WMI_FW_STATUS_FAILURE)},
2914	};
2915
2916	wil_dbg_wmi(wil,
2917	"ADDBA response for CID %d TID %d size %d timeout %d status %d AMSDU%s, sring_id %d\n",
2918	cid, tid, agg_wsize, timeout, status, amsdu ? "+" : "-",
2919	WIL_DEFAULT_RX_STATUS_RING_ID);
2920
2921	rc = wmi_call(wil, cmdid: WMI_RCP_ADDBA_RESP_EDMA_CMDID, mid, buf: &cmd,
2922	len: sizeof(cmd), reply_id: WMI_RCP_ADDBA_RESP_SENT_EVENTID, reply: &reply,
2923	reply_size: sizeof(reply), WIL_WMI_CALL_GENERAL_TO_MS);
2924	if (rc)
2925	return rc;
2926
2927	if (reply.evt.status) {
2928	wil_err(wil, "ADDBA response failed with status %d\n",
2929	le16_to_cpu(reply.evt.status));
2930	rc = -EINVAL;
2931	}
2932
2933	return rc;
2934	}
2935
2936	int wmi_ps_dev_profile_cfg(struct wil6210_priv *wil,
2937	enum wmi_ps_profile_type ps_profile)
2938	{
2939	struct wil6210_vif *vif = ndev_to_vif(wil->main_ndev);
2940	int rc;
2941	struct wmi_ps_dev_profile_cfg_cmd cmd = {
2942	.ps_profile = ps_profile,
2943	};
2944	struct {
2945	struct wmi_cmd_hdr wmi;
2946	struct wmi_ps_dev_profile_cfg_event evt;
2947	} __packed reply = {
2948	.evt = {.status = cpu_to_le32(WMI_PS_CFG_CMD_STATUS_ERROR)},
2949	};
2950	u32 status;
2951
2952	wil_dbg_wmi(wil, "Setting ps dev profile %d\n", ps_profile);
2953
2954	rc = wmi_call(wil, cmdid: WMI_PS_DEV_PROFILE_CFG_CMDID, mid: vif->mid,
2955	buf: &cmd, len: sizeof(cmd),
2956	reply_id: WMI_PS_DEV_PROFILE_CFG_EVENTID, reply: &reply, reply_size: sizeof(reply),
2957	WIL_WMI_CALL_GENERAL_TO_MS);
2958	if (rc)
2959	return rc;
2960
2961	status = le32_to_cpu(reply.evt.status);
2962
2963	if (status != WMI_PS_CFG_CMD_STATUS_SUCCESS) {
2964	wil_err(wil, "ps dev profile cfg failed with status %d\n",
2965	status);
2966	rc = -EINVAL;
2967	}
2968
2969	return rc;
2970	}
2971
2972	int wmi_set_mgmt_retry(struct wil6210_priv *wil, u8 retry_short)
2973	{
2974	struct wil6210_vif *vif = ndev_to_vif(wil->main_ndev);
2975	int rc;
2976	struct wmi_set_mgmt_retry_limit_cmd cmd = {
2977	.mgmt_retry_limit = retry_short,
2978	};
2979	struct {
2980	struct wmi_cmd_hdr wmi;
2981	struct wmi_set_mgmt_retry_limit_event evt;
2982	} __packed reply = {
2983	.evt = {.status = WMI_FW_STATUS_FAILURE},
2984	};
2985
2986	wil_dbg_wmi(wil, "Setting mgmt retry short %d\n", retry_short);
2987
2988	if (!test_bit(WMI_FW_CAPABILITY_MGMT_RETRY_LIMIT, wil->fw_capabilities))
2989	return -ENOTSUPP;
2990
2991	rc = wmi_call(wil, cmdid: WMI_SET_MGMT_RETRY_LIMIT_CMDID, mid: vif->mid,
2992	buf: &cmd, len: sizeof(cmd),
2993	reply_id: WMI_SET_MGMT_RETRY_LIMIT_EVENTID, reply: &reply, reply_size: sizeof(reply),
2994	WIL_WMI_CALL_GENERAL_TO_MS);
2995	if (rc)
2996	return rc;
2997
2998	if (reply.evt.status != WMI_FW_STATUS_SUCCESS) {
2999	wil_err(wil, "set mgmt retry limit failed with status %d\n",
3000	reply.evt.status);
3001	rc = -EINVAL;
3002	}
3003
3004	return rc;
3005	}
3006
3007	int wmi_get_mgmt_retry(struct wil6210_priv *wil, u8 *retry_short)
3008	{
3009	struct wil6210_vif *vif = ndev_to_vif(wil->main_ndev);
3010	int rc;
3011	struct {
3012	struct wmi_cmd_hdr wmi;
3013	struct wmi_get_mgmt_retry_limit_event evt;
3014	} __packed reply;
3015
3016	wil_dbg_wmi(wil, "getting mgmt retry short\n");
3017
3018	if (!test_bit(WMI_FW_CAPABILITY_MGMT_RETRY_LIMIT, wil->fw_capabilities))
3019	return -ENOTSUPP;
3020
3021	memset(&reply, 0, sizeof(reply));
3022	rc = wmi_call(wil, cmdid: WMI_GET_MGMT_RETRY_LIMIT_CMDID, mid: vif->mid, NULL, len: 0,
3023	reply_id: WMI_GET_MGMT_RETRY_LIMIT_EVENTID, reply: &reply, reply_size: sizeof(reply),
3024	WIL_WMI_CALL_GENERAL_TO_MS);
3025	if (rc)
3026	return rc;
3027
3028	if (retry_short)
3029	*retry_short = reply.evt.mgmt_retry_limit;
3030
3031	return 0;
3032	}
3033
3034	int wmi_abort_scan(struct wil6210_vif *vif)
3035	{
3036	struct wil6210_priv *wil = vif_to_wil(vif);
3037	int rc;
3038
3039	wil_dbg_wmi(wil, "sending WMI_ABORT_SCAN_CMDID\n");
3040
3041	rc = wmi_send(wil, cmdid: WMI_ABORT_SCAN_CMDID, mid: vif->mid, NULL, len: 0);
3042	if (rc)
3043	wil_err(wil, "Failed to abort scan (%d)\n", rc);
3044
3045	return rc;
3046	}
3047
3048	int wmi_new_sta(struct wil6210_vif *vif, const u8 *mac, u8 aid)
3049	{
3050	struct wil6210_priv *wil = vif_to_wil(vif);
3051	int rc;
3052	struct wmi_new_sta_cmd cmd = {
3053	.aid = aid,
3054	};
3055
3056	wil_dbg_wmi(wil, "new sta %pM, aid %d\n", mac, aid);
3057
3058	ether_addr_copy(dst: cmd.dst_mac, src: mac);
3059
3060	rc = wmi_send(wil, cmdid: WMI_NEW_STA_CMDID, mid: vif->mid, buf: &cmd, len: sizeof(cmd));
3061	if (rc)
3062	wil_err(wil, "Failed to send new sta (%d)\n", rc);
3063
3064	return rc;
3065	}
3066
3067	void wmi_event_flush(struct wil6210_priv *wil)
3068	{
3069	ulong flags;
3070	struct pending_wmi_event *evt, *t;
3071
3072	wil_dbg_wmi(wil, "event_flush\n");
3073
3074	spin_lock_irqsave(&wil->wmi_ev_lock, flags);
3075
3076	list_for_each_entry_safe(evt, t, &wil->pending_wmi_ev, list) {
3077	list_del(entry: &evt->list);
3078	kfree(objp: evt);
3079	}
3080
3081	spin_unlock_irqrestore(lock: &wil->wmi_ev_lock, flags);
3082	}
3083
3084	static const char *suspend_status2name(u8 status)
3085	{
3086	switch (status) {
3087	case WMI_TRAFFIC_SUSPEND_REJECTED_LINK_NOT_IDLE:
3088	return "LINK_NOT_IDLE";
3089	case WMI_TRAFFIC_SUSPEND_REJECTED_DISCONNECT:
3090	return "DISCONNECT";
3091	case WMI_TRAFFIC_SUSPEND_REJECTED_OTHER:
3092	return "OTHER";
3093	default:
3094	return "Untracked status";
3095	}
3096	}
3097
3098	int wmi_suspend(struct wil6210_priv *wil)
3099	{
3100	struct wil6210_vif *vif = ndev_to_vif(wil->main_ndev);
3101	int rc;
3102	struct wmi_traffic_suspend_cmd cmd = {
3103	.wakeup_trigger = wil->wakeup_trigger,
3104	};
3105	struct {
3106	struct wmi_cmd_hdr wmi;
3107	struct wmi_traffic_suspend_event evt;
3108	} __packed reply = {
3109	.evt = {.status = WMI_TRAFFIC_SUSPEND_REJECTED_LINK_NOT_IDLE},
3110	};
3111
3112	u32 suspend_to = WIL_WAIT_FOR_SUSPEND_RESUME_COMP;
3113
3114	wil->suspend_resp_rcvd = false;
3115	wil->suspend_resp_comp = false;
3116
3117	rc = wmi_call(wil, cmdid: WMI_TRAFFIC_SUSPEND_CMDID, mid: vif->mid,
3118	buf: &cmd, len: sizeof(cmd),
3119	reply_id: WMI_TRAFFIC_SUSPEND_EVENTID, reply: &reply, reply_size: sizeof(reply),
3120	to_msec: suspend_to);
3121	if (rc) {
3122	wil_err(wil, "wmi_call for suspend req failed, rc=%d\n", rc);
3123	if (rc == -ETIME)
3124	/* wmi_call TO */
3125	wil->suspend_stats.rejected_by_device++;
3126	else
3127	wil->suspend_stats.rejected_by_host++;
3128	goto out;
3129	}
3130
3131	wil_dbg_wmi(wil, "waiting for suspend_response_completed\n");
3132
3133	rc = wait_event_interruptible_timeout(wil->wq,
3134	wil->suspend_resp_comp,
3135	msecs_to_jiffies(suspend_to));
3136	if (rc == 0) {
3137	wil_err(wil, "TO waiting for suspend_response_completed\n");
3138	if (wil->suspend_resp_rcvd)
3139	/* Device responded but we TO due to another reason */
3140	wil->suspend_stats.rejected_by_host++;
3141	else
3142	wil->suspend_stats.rejected_by_device++;
3143	rc = -EBUSY;
3144	goto out;
3145	}
3146
3147	wil_dbg_wmi(wil, "suspend_response_completed rcvd\n");
3148	if (reply.evt.status != WMI_TRAFFIC_SUSPEND_APPROVED) {
3149	wil_dbg_pm(wil, "device rejected the suspend, %s\n",
3150	suspend_status2name(reply.evt.status));
3151	wil->suspend_stats.rejected_by_device++;
3152	}
3153	rc = reply.evt.status;
3154
3155	out:
3156	wil->suspend_resp_rcvd = false;
3157	wil->suspend_resp_comp = false;
3158
3159	return rc;
3160	}
3161
3162	static void resume_triggers2string(u32 triggers, char *string, int str_size)
3163	{
3164	string[0] = '\0';
3165
3166	if (!triggers) {
3167	strlcat(p: string, q: " UNKNOWN", avail: str_size);
3168	return;
3169	}
3170
3171	if (triggers & WMI_RESUME_TRIGGER_HOST)
3172	strlcat(p: string, q: " HOST", avail: str_size);
3173
3174	if (triggers & WMI_RESUME_TRIGGER_UCAST_RX)
3175	strlcat(p: string, q: " UCAST_RX", avail: str_size);
3176
3177	if (triggers & WMI_RESUME_TRIGGER_BCAST_RX)
3178	strlcat(p: string, q: " BCAST_RX", avail: str_size);
3179
3180	if (triggers & WMI_RESUME_TRIGGER_WMI_EVT)
3181	strlcat(p: string, q: " WMI_EVT", avail: str_size);
3182
3183	if (triggers & WMI_RESUME_TRIGGER_DISCONNECT)
3184	strlcat(p: string, q: " DISCONNECT", avail: str_size);
3185	}
3186
3187	int wmi_resume(struct wil6210_priv *wil)
3188	{
3189	struct wil6210_vif *vif = ndev_to_vif(wil->main_ndev);
3190	int rc;
3191	char string[100];
3192	struct {
3193	struct wmi_cmd_hdr wmi;
3194	struct wmi_traffic_resume_event evt;
3195	} __packed reply = {
3196	.evt = {.status = WMI_TRAFFIC_RESUME_FAILED,
3197	.resume_triggers =
3198	cpu_to_le32(WMI_RESUME_TRIGGER_UNKNOWN)},
3199	};
3200
3201	rc = wmi_call(wil, cmdid: WMI_TRAFFIC_RESUME_CMDID, mid: vif->mid, NULL, len: 0,
3202	reply_id: WMI_TRAFFIC_RESUME_EVENTID, reply: &reply, reply_size: sizeof(reply),
3203	WIL_WAIT_FOR_SUSPEND_RESUME_COMP);
3204	if (rc)
3205	return rc;
3206	resume_triggers2string(le32_to_cpu(reply.evt.resume_triggers), string,
3207	str_size: sizeof(string));
3208	wil_dbg_pm(wil, "device resume %s, resume triggers:%s (0x%x)\n",
3209	reply.evt.status ? "failed" : "passed", string,
3210	le32_to_cpu(reply.evt.resume_triggers));
3211
3212	return reply.evt.status;
3213	}
3214
3215	int wmi_port_allocate(struct wil6210_priv *wil, u8 mid,
3216	const u8 *mac, enum nl80211_iftype iftype)
3217	{
3218	int rc;
3219	struct wmi_port_allocate_cmd cmd = {
3220	.mid = mid,
3221	};
3222	struct {
3223	struct wmi_cmd_hdr wmi;
3224	struct wmi_port_allocated_event evt;
3225	} __packed reply = {
3226	.evt = {.status = WMI_FW_STATUS_FAILURE},
3227	};
3228
3229	wil_dbg_misc(wil, "port allocate, mid %d iftype %d, mac %pM\n",
3230	mid, iftype, mac);
3231
3232	ether_addr_copy(dst: cmd.mac, src: mac);
3233	switch (iftype) {
3234	case NL80211_IFTYPE_STATION:
3235	cmd.port_role = WMI_PORT_STA;
3236	break;
3237	case NL80211_IFTYPE_AP:
3238	cmd.port_role = WMI_PORT_AP;
3239	break;
3240	case NL80211_IFTYPE_P2P_CLIENT:
3241	cmd.port_role = WMI_PORT_P2P_CLIENT;
3242	break;
3243	case NL80211_IFTYPE_P2P_GO:
3244	cmd.port_role = WMI_PORT_P2P_GO;
3245	break;
3246	/* what about monitor??? */
3247	default:
3248	wil_err(wil, "unsupported iftype: %d\n", iftype);
3249	return -EINVAL;
3250	}
3251
3252	rc = wmi_call(wil, cmdid: WMI_PORT_ALLOCATE_CMDID, mid,
3253	buf: &cmd, len: sizeof(cmd),
3254	reply_id: WMI_PORT_ALLOCATED_EVENTID, reply: &reply,
3255	reply_size: sizeof(reply), to_msec: 300);
3256	if (rc) {
3257	wil_err(wil, "failed to allocate port, status %d\n", rc);
3258	return rc;
3259	}
3260	if (reply.evt.status != WMI_FW_STATUS_SUCCESS) {
3261	wil_err(wil, "WMI_PORT_ALLOCATE returned status %d\n",
3262	reply.evt.status);
3263	return -EINVAL;
3264	}
3265
3266	return 0;
3267	}
3268
3269	int wmi_port_delete(struct wil6210_priv *wil, u8 mid)
3270	{
3271	int rc;
3272	struct wmi_port_delete_cmd cmd = {
3273	.mid = mid,
3274	};
3275	struct {
3276	struct wmi_cmd_hdr wmi;
3277	struct wmi_port_deleted_event evt;
3278	} __packed reply = {
3279	.evt = {.status = WMI_FW_STATUS_FAILURE},
3280	};
3281
3282	wil_dbg_misc(wil, "port delete, mid %d\n", mid);
3283
3284	rc = wmi_call(wil, cmdid: WMI_PORT_DELETE_CMDID, mid,
3285	buf: &cmd, len: sizeof(cmd),
3286	reply_id: WMI_PORT_DELETED_EVENTID, reply: &reply,
3287	reply_size: sizeof(reply), to_msec: 2000);
3288	if (rc) {
3289	wil_err(wil, "failed to delete port, status %d\n", rc);
3290	return rc;
3291	}
3292	if (reply.evt.status != WMI_FW_STATUS_SUCCESS) {
3293	wil_err(wil, "WMI_PORT_DELETE returned status %d\n",
3294	reply.evt.status);
3295	return -EINVAL;
3296	}
3297
3298	return 0;
3299	}
3300
3301	static bool wmi_evt_call_handler(struct wil6210_vif *vif, int id,
3302	void *d, int len)
3303	{
3304	uint i;
3305
3306	for (i = 0; i < ARRAY_SIZE(wmi_evt_handlers); i++) {
3307	if (wmi_evt_handlers[i].eventid == id) {
3308	wmi_evt_handlers[i].handler(vif, id, d, len);
3309	return true;
3310	}
3311	}
3312
3313	return false;
3314	}
3315
3316	static void wmi_event_handle(struct wil6210_priv *wil,
3317	struct wil6210_mbox_hdr *hdr)
3318	{
3319	u16 len = le16_to_cpu(hdr->len);
3320	struct wil6210_vif *vif;
3321
3322	if ((hdr->type == WIL_MBOX_HDR_TYPE_WMI) &&
3323	(len >= sizeof(struct wmi_cmd_hdr))) {
3324	struct wmi_cmd_hdr *wmi = (void *)(&hdr[1]);
3325	void *evt_data = (void *)(&wmi[1]);
3326	u16 id = le16_to_cpu(wmi->command_id);
3327	u8 mid = wmi->mid;
3328
3329	wil_dbg_wmi(wil, "Handle %s (0x%04x) (reply_id 0x%04x,%d)\n",
3330	eventid2name(id), id, wil->reply_id,
3331	wil->reply_mid);
3332
3333	if (mid == MID_BROADCAST)
3334	mid = 0;
3335	if (mid >= GET_MAX_VIFS(wil)) {
3336	wil_dbg_wmi(wil, "invalid mid %d, event skipped\n",
3337	mid);
3338	return;
3339	}
3340	vif = wil->vifs[mid];
3341	if (!vif) {
3342	wil_dbg_wmi(wil, "event for empty VIF(%d), skipped\n",
3343	mid);
3344	return;
3345	}
3346
3347	/* check if someone waits for this event */
3348	if (wil->reply_id && wil->reply_id == id &&
3349	wil->reply_mid == mid) {
3350	if (wil->reply_buf) {
3351	/* event received while wmi_call is waiting
3352	* with a buffer. Such event should be handled
3353	* in wmi_recv_cmd function. Handling the event
3354	* here means a previous wmi_call was timeout.
3355	* Drop the event and do not handle it.
3356	*/
3357	wil_err(wil,
3358	"Old event (%d, %s) while wmi_call is waiting. Drop it and Continue waiting\n",
3359	id, eventid2name(id));
3360	return;
3361	}
3362
3363	wmi_evt_call_handler(vif, id, d: evt_data,
3364	len: len - sizeof(*wmi));
3365	wil_dbg_wmi(wil, "event_handle: Complete WMI 0x%04x\n",
3366	id);
3367	complete(&wil->wmi_call);
3368	return;
3369	}
3370	/* unsolicited event */
3371	/* search for handler */
3372	if (!wmi_evt_call_handler(vif, id, d: evt_data,
3373	len: len - sizeof(*wmi))) {
3374	wil_info(wil, "Unhandled event 0x%04x\n", id);
3375	}
3376	} else {
3377	wil_err(wil, "Unknown event type\n");
3378	print_hex_dump(KERN_ERR, prefix_str: "evt?? ", prefix_type: DUMP_PREFIX_OFFSET, rowsize: 16, groupsize: 1,
3379	buf: hdr, len: sizeof(*hdr) + len, ascii: true);
3380	}
3381	}
3382
3383	/*
3384	* Retrieve next WMI event from the pending list
3385	*/
3386	static struct list_head *next_wmi_ev(struct wil6210_priv *wil)
3387	{
3388	ulong flags;
3389	struct list_head *ret = NULL;
3390
3391	spin_lock_irqsave(&wil->wmi_ev_lock, flags);
3392
3393	if (!list_empty(head: &wil->pending_wmi_ev)) {
3394	ret = wil->pending_wmi_ev.next;
3395	list_del(entry: ret);
3396	}
3397
3398	spin_unlock_irqrestore(lock: &wil->wmi_ev_lock, flags);
3399
3400	return ret;
3401	}
3402
3403	/*
3404	* Handler for the WMI events
3405	*/
3406	void wmi_event_worker(struct work_struct *work)
3407	{
3408	struct wil6210_priv *wil = container_of(work, struct wil6210_priv,
3409	wmi_event_worker);
3410	struct pending_wmi_event *evt;
3411	struct list_head *lh;
3412
3413	wil_dbg_wmi(wil, "event_worker: Start\n");
3414	while ((lh = next_wmi_ev(wil)) != NULL) {
3415	evt = list_entry(lh, struct pending_wmi_event, list);
3416	wmi_event_handle(wil, hdr: &evt->event.hdr);
3417	kfree(objp: evt);
3418	}
3419	wil_dbg_wmi(wil, "event_worker: Finished\n");
3420	}
3421
3422	bool wil_is_wmi_idle(struct wil6210_priv *wil)
3423	{
3424	ulong flags;
3425	struct wil6210_mbox_ring *r = &wil->mbox_ctl.rx;
3426	bool rc = false;
3427
3428	spin_lock_irqsave(&wil->wmi_ev_lock, flags);
3429
3430	/* Check if there are pending WMI events in the events queue */
3431	if (!list_empty(head: &wil->pending_wmi_ev)) {
3432	wil_dbg_pm(wil, "Pending WMI events in queue\n");
3433	goto out;
3434	}
3435
3436	/* Check if there is a pending WMI call */
3437	if (wil->reply_id) {
3438	wil_dbg_pm(wil, "Pending WMI call\n");
3439	goto out;
3440	}
3441
3442	/* Check if there are pending RX events in mbox */
3443	r->head = wil_r(wil, RGF_MBOX +
3444	offsetof(struct wil6210_mbox_ctl, rx.head));
3445	if (r->tail != r->head)
3446	wil_dbg_pm(wil, "Pending WMI mbox events\n");
3447	else
3448	rc = true;
3449
3450	out:
3451	spin_unlock_irqrestore(lock: &wil->wmi_ev_lock, flags);
3452	return rc;
3453	}
3454
3455	static void
3456	wmi_sched_scan_set_ssids(struct wil6210_priv *wil,
3457	struct wmi_start_sched_scan_cmd *cmd,
3458	struct cfg80211_ssid *ssids, int n_ssids,
3459	struct cfg80211_match_set *match_sets,
3460	int n_match_sets)
3461	{
3462	int i;
3463
3464	if (n_match_sets > WMI_MAX_PNO_SSID_NUM) {
3465	wil_dbg_wmi(wil, "too many match sets (%d), use first %d\n",
3466	n_match_sets, WMI_MAX_PNO_SSID_NUM);
3467	n_match_sets = WMI_MAX_PNO_SSID_NUM;
3468	}
3469	cmd->num_of_ssids = n_match_sets;
3470
3471	for (i = 0; i < n_match_sets; i++) {
3472	struct wmi_sched_scan_ssid_match *wmi_match =
3473	&cmd->ssid_for_match[i];
3474	struct cfg80211_match_set *cfg_match = &match_sets[i];
3475	int j;
3476
3477	wmi_match->ssid_len = cfg_match->ssid.ssid_len;
3478	memcpy(wmi_match->ssid, cfg_match->ssid.ssid,
3479	min_t(u8, wmi_match->ssid_len, WMI_MAX_SSID_LEN));
3480	wmi_match->rssi_threshold = S8_MIN;
3481	if (cfg_match->rssi_thold >= S8_MIN &&
3482	cfg_match->rssi_thold <= S8_MAX)
3483	wmi_match->rssi_threshold = cfg_match->rssi_thold;
3484
3485	for (j = 0; j < n_ssids; j++)
3486	if (wmi_match->ssid_len == ssids[j].ssid_len &&
3487	memcmp(p: wmi_match->ssid, q: ssids[j].ssid,
3488	size: wmi_match->ssid_len) == 0)
3489	wmi_match->add_ssid_to_probe = true;
3490	}
3491	}
3492
3493	static void
3494	wmi_sched_scan_set_channels(struct wil6210_priv *wil,
3495	struct wmi_start_sched_scan_cmd *cmd,
3496	u32 n_channels,
3497	struct ieee80211_channel **channels)
3498	{
3499	int i;
3500
3501	if (n_channels > WMI_MAX_CHANNEL_NUM) {
3502	wil_dbg_wmi(wil, "too many channels (%d), use first %d\n",
3503	n_channels, WMI_MAX_CHANNEL_NUM);
3504	n_channels = WMI_MAX_CHANNEL_NUM;
3505	}
3506	cmd->num_of_channels = n_channels;
3507
3508	for (i = 0; i < n_channels; i++) {
3509	struct ieee80211_channel *cfg_chan = channels[i];
3510
3511	cmd->channel_list[i] = cfg_chan->hw_value - 1;
3512	}
3513	}
3514
3515	static void
3516	wmi_sched_scan_set_plans(struct wil6210_priv *wil,
3517	struct wmi_start_sched_scan_cmd *cmd,
3518	struct cfg80211_sched_scan_plan *scan_plans,
3519	int n_scan_plans)
3520	{
3521	int i;
3522
3523	if (n_scan_plans > WMI_MAX_PLANS_NUM) {
3524	wil_dbg_wmi(wil, "too many plans (%d), use first %d\n",
3525	n_scan_plans, WMI_MAX_PLANS_NUM);
3526	n_scan_plans = WMI_MAX_PLANS_NUM;
3527	}
3528
3529	for (i = 0; i < n_scan_plans; i++) {
3530	struct cfg80211_sched_scan_plan *cfg_plan = &scan_plans[i];
3531
3532	cmd->scan_plans[i].interval_sec =
3533	cpu_to_le16(cfg_plan->interval);
3534	cmd->scan_plans[i].num_of_iterations =
3535	cpu_to_le16(cfg_plan->iterations);
3536	}
3537	}
3538
3539	int wmi_start_sched_scan(struct wil6210_priv *wil,
3540	struct cfg80211_sched_scan_request *request)
3541	{
3542	struct wil6210_vif *vif = ndev_to_vif(wil->main_ndev);
3543	int rc;
3544	struct wmi_start_sched_scan_cmd cmd = {
3545	.min_rssi_threshold = S8_MIN,
3546	.initial_delay_sec = cpu_to_le16(request->delay),
3547	};
3548	struct {
3549	struct wmi_cmd_hdr wmi;
3550	struct wmi_start_sched_scan_event evt;
3551	} __packed reply = {
3552	.evt = {.result = WMI_PNO_REJECT},
3553	};
3554
3555	if (!test_bit(WMI_FW_CAPABILITY_PNO, wil->fw_capabilities))
3556	return -ENOTSUPP;
3557
3558	if (request->min_rssi_thold >= S8_MIN &&
3559	request->min_rssi_thold <= S8_MAX)
3560	cmd.min_rssi_threshold = request->min_rssi_thold;
3561
3562	wmi_sched_scan_set_ssids(wil, cmd: &cmd, ssids: request->ssids, n_ssids: request->n_ssids,
3563	match_sets: request->match_sets, n_match_sets: request->n_match_sets);
3564	wmi_sched_scan_set_channels(wil, cmd: &cmd,
3565	n_channels: request->n_channels, channels: request->channels);
3566	wmi_sched_scan_set_plans(wil, cmd: &cmd,
3567	scan_plans: request->scan_plans, n_scan_plans: request->n_scan_plans);
3568
3569	rc = wmi_call(wil, cmdid: WMI_START_SCHED_SCAN_CMDID, mid: vif->mid,
3570	buf: &cmd, len: sizeof(cmd),
3571	reply_id: WMI_START_SCHED_SCAN_EVENTID, reply: &reply, reply_size: sizeof(reply),
3572	WIL_WMI_CALL_GENERAL_TO_MS);
3573	if (rc)
3574	return rc;
3575
3576	if (reply.evt.result != WMI_PNO_SUCCESS) {
3577	wil_err(wil, "start sched scan failed, result %d\n",
3578	reply.evt.result);
3579	return -EINVAL;
3580	}
3581
3582	return 0;
3583	}
3584
3585	int wmi_stop_sched_scan(struct wil6210_priv *wil)
3586	{
3587	struct wil6210_vif *vif = ndev_to_vif(wil->main_ndev);
3588	int rc;
3589	struct {
3590	struct wmi_cmd_hdr wmi;
3591	struct wmi_stop_sched_scan_event evt;
3592	} __packed reply = {
3593	.evt = {.result = WMI_PNO_REJECT},
3594	};
3595
3596	if (!test_bit(WMI_FW_CAPABILITY_PNO, wil->fw_capabilities))
3597	return -ENOTSUPP;
3598
3599	rc = wmi_call(wil, cmdid: WMI_STOP_SCHED_SCAN_CMDID, mid: vif->mid, NULL, len: 0,
3600	reply_id: WMI_STOP_SCHED_SCAN_EVENTID, reply: &reply, reply_size: sizeof(reply),
3601	WIL_WMI_CALL_GENERAL_TO_MS);
3602	if (rc)
3603	return rc;
3604
3605	if (reply.evt.result != WMI_PNO_SUCCESS) {
3606	wil_err(wil, "stop sched scan failed, result %d\n",
3607	reply.evt.result);
3608	return -EINVAL;
3609	}
3610
3611	return 0;
3612	}
3613
3614	int wmi_mgmt_tx(struct wil6210_vif *vif, const u8 *buf, size_t len)
3615	{
3616	size_t total;
3617	struct wil6210_priv *wil = vif_to_wil(vif);
3618	struct ieee80211_mgmt *mgmt_frame = (void *)buf;
3619	struct wmi_sw_tx_req_cmd *cmd;
3620	struct {
3621	struct wmi_cmd_hdr wmi;
3622	struct wmi_sw_tx_complete_event evt;
3623	} __packed evt = {
3624	.evt = {.status = WMI_FW_STATUS_FAILURE},
3625	};
3626	int rc;
3627
3628	wil_dbg_misc(wil, "mgmt_tx mid %d\n", vif->mid);
3629	wil_hex_dump_misc("mgmt tx frame ", DUMP_PREFIX_OFFSET, 16, 1, buf,
3630	len, true);
3631
3632	if (len < sizeof(struct ieee80211_hdr_3addr))
3633	return -EINVAL;
3634
3635	total = sizeof(*cmd) + len;
3636	if (total < len) {
3637	wil_err(wil, "mgmt_tx invalid len %zu\n", len);
3638	return -EINVAL;
3639	}
3640
3641	cmd = kmalloc(size: total, GFP_KERNEL);
3642	if (!cmd)
3643	return -ENOMEM;
3644
3645	memcpy(cmd->dst_mac, mgmt_frame->da, WMI_MAC_LEN);
3646	cmd->len = cpu_to_le16(len);
3647	memcpy(cmd->payload, buf, len);
3648
3649	rc = wmi_call(wil, cmdid: WMI_SW_TX_REQ_CMDID, mid: vif->mid, buf: cmd, len: total,
3650	reply_id: WMI_SW_TX_COMPLETE_EVENTID, reply: &evt, reply_size: sizeof(evt), to_msec: 2000);
3651	if (!rc && evt.evt.status != WMI_FW_STATUS_SUCCESS) {
3652	wil_dbg_wmi(wil, "mgmt_tx failed with status %d\n",
3653	evt.evt.status);
3654	rc = -EAGAIN;
3655	}
3656
3657	kfree(objp: cmd);
3658
3659	return rc;
3660	}
3661
3662	int wmi_mgmt_tx_ext(struct wil6210_vif *vif, const u8 *buf, size_t len,
3663	u8 channel, u16 duration_ms)
3664	{
3665	size_t total;
3666	struct wil6210_priv *wil = vif_to_wil(vif);
3667	struct ieee80211_mgmt *mgmt_frame = (void *)buf;
3668	struct wmi_sw_tx_req_ext_cmd *cmd;
3669	struct {
3670	struct wmi_cmd_hdr wmi;
3671	struct wmi_sw_tx_complete_event evt;
3672	} __packed evt = {
3673	.evt = {.status = WMI_FW_STATUS_FAILURE},
3674	};
3675	int rc;
3676
3677	wil_dbg_wmi(wil, "mgmt_tx_ext mid %d channel %d duration %d\n",
3678	vif->mid, channel, duration_ms);
3679	wil_hex_dump_wmi("mgmt_tx_ext frame ", DUMP_PREFIX_OFFSET, 16, 1, buf,
3680	len, true);
3681
3682	if (len < sizeof(struct ieee80211_hdr_3addr)) {
3683	wil_err(wil, "short frame. len %zu\n", len);
3684	return -EINVAL;
3685	}
3686
3687	total = sizeof(*cmd) + len;
3688	if (total < len) {
3689	wil_err(wil, "mgmt_tx_ext invalid len %zu\n", len);
3690	return -EINVAL;
3691	}
3692
3693	cmd = kzalloc(size: total, GFP_KERNEL);
3694	if (!cmd)
3695	return -ENOMEM;
3696
3697	memcpy(cmd->dst_mac, mgmt_frame->da, WMI_MAC_LEN);
3698	cmd->len = cpu_to_le16(len);
3699	memcpy(cmd->payload, buf, len);
3700	cmd->channel = channel - 1;
3701	cmd->duration_ms = cpu_to_le16(duration_ms);
3702
3703	rc = wmi_call(wil, cmdid: WMI_SW_TX_REQ_EXT_CMDID, mid: vif->mid, buf: cmd, len: total,
3704	reply_id: WMI_SW_TX_COMPLETE_EVENTID, reply: &evt, reply_size: sizeof(evt), to_msec: 2000);
3705	if (!rc && evt.evt.status != WMI_FW_STATUS_SUCCESS) {
3706	wil_dbg_wmi(wil, "mgmt_tx_ext failed with status %d\n",
3707	evt.evt.status);
3708	rc = -EAGAIN;
3709	}
3710
3711	kfree(objp: cmd);
3712
3713	return rc;
3714	}
3715
3716	int wil_wmi_tx_sring_cfg(struct wil6210_priv *wil, int ring_id)
3717	{
3718	int rc;
3719	struct wil6210_vif *vif = ndev_to_vif(wil->main_ndev);
3720	struct wil_status_ring *sring = &wil->srings[ring_id];
3721	struct wmi_tx_status_ring_add_cmd cmd = {
3722	.ring_cfg = {
3723	.ring_size = cpu_to_le16(sring->size),
3724	},
3725	.irq_index = WIL_TX_STATUS_IRQ_IDX
3726	};
3727	struct {
3728	struct wmi_cmd_hdr hdr;
3729	struct wmi_tx_status_ring_cfg_done_event evt;
3730	} __packed reply = {
3731	.evt = {.status = WMI_FW_STATUS_FAILURE},
3732	};
3733
3734	cmd.ring_cfg.ring_id = ring_id;
3735
3736	cmd.ring_cfg.ring_mem_base = cpu_to_le64(sring->pa);
3737	rc = wmi_call(wil, cmdid: WMI_TX_STATUS_RING_ADD_CMDID, mid: vif->mid, buf: &cmd,
3738	len: sizeof(cmd), reply_id: WMI_TX_STATUS_RING_CFG_DONE_EVENTID,
3739	reply: &reply, reply_size: sizeof(reply), WIL_WMI_CALL_GENERAL_TO_MS);
3740	if (rc) {
3741	wil_err(wil, "TX_STATUS_RING_ADD_CMD failed, rc %d\n", rc);
3742	return rc;
3743	}
3744
3745	if (reply.evt.status != WMI_FW_STATUS_SUCCESS) {
3746	wil_err(wil, "TX_STATUS_RING_ADD_CMD failed, status %d\n",
3747	reply.evt.status);
3748	return -EINVAL;
3749	}
3750
3751	sring->hwtail = le32_to_cpu(reply.evt.ring_tail_ptr);
3752
3753	return 0;
3754	}
3755
3756	int wil_wmi_cfg_def_rx_offload(struct wil6210_priv *wil, u16 max_rx_pl_per_desc)
3757	{
3758	struct net_device *ndev = wil->main_ndev;
3759	struct wil6210_vif *vif = ndev_to_vif(ndev);
3760	int rc;
3761	struct wmi_cfg_def_rx_offload_cmd cmd = {
3762	.max_msdu_size = cpu_to_le16(wil_mtu2macbuf(WIL_MAX_ETH_MTU)),
3763	.max_rx_pl_per_desc = cpu_to_le16(max_rx_pl_per_desc),
3764	.decap_trans_type = WMI_DECAP_TYPE_802_3,
3765	.l2_802_3_offload_ctrl = 0,
3766	.l3_l4_ctrl = 1 << L3_L4_CTRL_TCPIP_CHECKSUM_EN_POS,
3767	};
3768	struct {
3769	struct wmi_cmd_hdr hdr;
3770	struct wmi_cfg_def_rx_offload_done_event evt;
3771	} __packed reply = {
3772	.evt = {.status = WMI_FW_STATUS_FAILURE},
3773	};
3774
3775	rc = wmi_call(wil, cmdid: WMI_CFG_DEF_RX_OFFLOAD_CMDID, mid: vif->mid, buf: &cmd,
3776	len: sizeof(cmd), reply_id: WMI_CFG_DEF_RX_OFFLOAD_DONE_EVENTID, reply: &reply,
3777	reply_size: sizeof(reply), WIL_WMI_CALL_GENERAL_TO_MS);
3778	if (rc) {
3779	wil_err(wil, "WMI_CFG_DEF_RX_OFFLOAD_CMD failed, rc %d\n", rc);
3780	return rc;
3781	}
3782
3783	if (reply.evt.status != WMI_FW_STATUS_SUCCESS) {
3784	wil_err(wil, "WMI_CFG_DEF_RX_OFFLOAD_CMD failed, status %d\n",
3785	reply.evt.status);
3786	return -EINVAL;
3787	}
3788
3789	return 0;
3790	}
3791
3792	int wil_wmi_rx_sring_add(struct wil6210_priv *wil, u16 ring_id)
3793	{
3794	struct net_device *ndev = wil->main_ndev;
3795	struct wil6210_vif *vif = ndev_to_vif(ndev);
3796	struct wil_status_ring *sring = &wil->srings[ring_id];
3797	int rc;
3798	struct wmi_rx_status_ring_add_cmd cmd = {
3799	.ring_cfg = {
3800	.ring_size = cpu_to_le16(sring->size),
3801	.ring_id = ring_id,
3802	},
3803	.rx_msg_type = wil->use_compressed_rx_status ?
3804	WMI_RX_MSG_TYPE_COMPRESSED :
3805	WMI_RX_MSG_TYPE_EXTENDED,
3806	.irq_index = WIL_RX_STATUS_IRQ_IDX,
3807	};
3808	struct {
3809	struct wmi_cmd_hdr hdr;
3810	struct wmi_rx_status_ring_cfg_done_event evt;
3811	} __packed reply = {
3812	.evt = {.status = WMI_FW_STATUS_FAILURE},
3813	};
3814
3815	cmd.ring_cfg.ring_mem_base = cpu_to_le64(sring->pa);
3816	rc = wmi_call(wil, cmdid: WMI_RX_STATUS_RING_ADD_CMDID, mid: vif->mid, buf: &cmd,
3817	len: sizeof(cmd), reply_id: WMI_RX_STATUS_RING_CFG_DONE_EVENTID, reply: &reply,
3818	reply_size: sizeof(reply), WIL_WMI_CALL_GENERAL_TO_MS);
3819	if (rc) {
3820	wil_err(wil, "RX_STATUS_RING_ADD_CMD failed, rc %d\n", rc);
3821	return rc;
3822	}
3823
3824	if (reply.evt.status != WMI_FW_STATUS_SUCCESS) {
3825	wil_err(wil, "RX_STATUS_RING_ADD_CMD failed, status %d\n",
3826	reply.evt.status);
3827	return -EINVAL;
3828	}
3829
3830	sring->hwtail = le32_to_cpu(reply.evt.ring_tail_ptr);
3831
3832	return 0;
3833	}
3834
3835	int wil_wmi_rx_desc_ring_add(struct wil6210_priv *wil, int status_ring_id)
3836	{
3837	struct net_device *ndev = wil->main_ndev;
3838	struct wil6210_vif *vif = ndev_to_vif(ndev);
3839	struct wil_ring *ring = &wil->ring_rx;
3840	int rc;
3841	struct wmi_rx_desc_ring_add_cmd cmd = {
3842	.ring_cfg = {
3843	.ring_size = cpu_to_le16(ring->size),
3844	.ring_id = WIL_RX_DESC_RING_ID,
3845	},
3846	.status_ring_id = status_ring_id,
3847	.irq_index = WIL_RX_STATUS_IRQ_IDX,
3848	};
3849	struct {
3850	struct wmi_cmd_hdr hdr;
3851	struct wmi_rx_desc_ring_cfg_done_event evt;
3852	} __packed reply = {
3853	.evt = {.status = WMI_FW_STATUS_FAILURE},
3854	};
3855
3856	cmd.ring_cfg.ring_mem_base = cpu_to_le64(ring->pa);
3857	cmd.sw_tail_host_addr = cpu_to_le64(ring->edma_rx_swtail.pa);
3858	rc = wmi_call(wil, cmdid: WMI_RX_DESC_RING_ADD_CMDID, mid: vif->mid, buf: &cmd,
3859	len: sizeof(cmd), reply_id: WMI_RX_DESC_RING_CFG_DONE_EVENTID, reply: &reply,
3860	reply_size: sizeof(reply), WIL_WMI_CALL_GENERAL_TO_MS);
3861	if (rc) {
3862	wil_err(wil, "WMI_RX_DESC_RING_ADD_CMD failed, rc %d\n", rc);
3863	return rc;
3864	}
3865
3866	if (reply.evt.status != WMI_FW_STATUS_SUCCESS) {
3867	wil_err(wil, "WMI_RX_DESC_RING_ADD_CMD failed, status %d\n",
3868	reply.evt.status);
3869	return -EINVAL;
3870	}
3871
3872	ring->hwtail = le32_to_cpu(reply.evt.ring_tail_ptr);
3873
3874	return 0;
3875	}
3876
3877	int wil_wmi_tx_desc_ring_add(struct wil6210_vif *vif, int ring_id, int cid,
3878	int tid)
3879	{
3880	struct wil6210_priv *wil = vif_to_wil(vif);
3881	int sring_id = wil->tx_sring_idx; /* there is only one TX sring */
3882	int rc;
3883	struct wil_ring *ring = &wil->ring_tx[ring_id];
3884	struct wil_ring_tx_data *txdata = &wil->ring_tx_data[ring_id];
3885	struct wmi_tx_desc_ring_add_cmd cmd = {
3886	.ring_cfg = {
3887	.ring_size = cpu_to_le16(ring->size),
3888	.ring_id = ring_id,
3889	},
3890	.status_ring_id = sring_id,
3891	.cid = cid,
3892	.tid = tid,
3893	.encap_trans_type = WMI_VRING_ENC_TYPE_802_3,
3894	.max_msdu_size = cpu_to_le16(wil_mtu2macbuf(mtu_max)),
3895	.schd_params = {
3896	.priority = cpu_to_le16(0),
3897	.timeslot_us = cpu_to_le16(0xfff),
3898	}
3899	};
3900	struct {
3901	struct wmi_cmd_hdr hdr;
3902	struct wmi_tx_desc_ring_cfg_done_event evt;
3903	} __packed reply = {
3904	.evt = {.status = WMI_FW_STATUS_FAILURE},
3905	};
3906
3907	cmd.ring_cfg.ring_mem_base = cpu_to_le64(ring->pa);
3908	rc = wmi_call(wil, cmdid: WMI_TX_DESC_RING_ADD_CMDID, mid: vif->mid, buf: &cmd,
3909	len: sizeof(cmd), reply_id: WMI_TX_DESC_RING_CFG_DONE_EVENTID, reply: &reply,
3910	reply_size: sizeof(reply), WIL_WMI_CALL_GENERAL_TO_MS);
3911	if (rc) {
3912	wil_err(wil, "WMI_TX_DESC_RING_ADD_CMD failed, rc %d\n", rc);
3913	return rc;
3914	}
3915
3916	if (reply.evt.status != WMI_FW_STATUS_SUCCESS) {
3917	wil_err(wil, "WMI_TX_DESC_RING_ADD_CMD failed, status %d\n",
3918	reply.evt.status);
3919	return -EINVAL;
3920	}
3921
3922	spin_lock_bh(lock: &txdata->lock);
3923	ring->hwtail = le32_to_cpu(reply.evt.ring_tail_ptr);
3924	txdata->mid = vif->mid;
3925	txdata->enabled = 1;
3926	spin_unlock_bh(lock: &txdata->lock);
3927
3928	return 0;
3929	}
3930
3931	int wil_wmi_bcast_desc_ring_add(struct wil6210_vif *vif, int ring_id)
3932	{
3933	struct wil6210_priv *wil = vif_to_wil(vif);
3934	struct wil_ring *ring = &wil->ring_tx[ring_id];
3935	int rc;
3936	struct wmi_bcast_desc_ring_add_cmd cmd = {
3937	.ring_cfg = {
3938	.ring_size = cpu_to_le16(ring->size),
3939	.ring_id = ring_id,
3940	},
3941	.max_msdu_size = cpu_to_le16(wil_mtu2macbuf(mtu_max)),
3942	.status_ring_id = wil->tx_sring_idx,
3943	.encap_trans_type = WMI_VRING_ENC_TYPE_802_3,
3944	};
3945	struct {
3946	struct wmi_cmd_hdr hdr;
3947	struct wmi_rx_desc_ring_cfg_done_event evt;
3948	} __packed reply = {
3949	.evt = {.status = WMI_FW_STATUS_FAILURE},
3950	};
3951	struct wil_ring_tx_data *txdata = &wil->ring_tx_data[ring_id];
3952
3953	cmd.ring_cfg.ring_mem_base = cpu_to_le64(ring->pa);
3954	rc = wmi_call(wil, cmdid: WMI_BCAST_DESC_RING_ADD_CMDID, mid: vif->mid, buf: &cmd,
3955	len: sizeof(cmd), reply_id: WMI_TX_DESC_RING_CFG_DONE_EVENTID, reply: &reply,
3956	reply_size: sizeof(reply), WIL_WMI_CALL_GENERAL_TO_MS);
3957	if (rc) {
3958	wil_err(wil, "WMI_BCAST_DESC_RING_ADD_CMD failed, rc %d\n", rc);
3959	return rc;
3960	}
3961
3962	if (reply.evt.status != WMI_FW_STATUS_SUCCESS) {
3963	wil_err(wil, "Broadcast Tx config failed, status %d\n",
3964	reply.evt.status);
3965	return -EINVAL;
3966	}
3967
3968	spin_lock_bh(lock: &txdata->lock);
3969	ring->hwtail = le32_to_cpu(reply.evt.ring_tail_ptr);
3970	txdata->mid = vif->mid;
3971	txdata->enabled = 1;
3972	spin_unlock_bh(lock: &txdata->lock);
3973
3974	return 0;
3975	}
3976
3977	int wmi_link_stats_cfg(struct wil6210_vif *vif, u32 type, u8 cid, u32 interval)
3978	{
3979	struct wil6210_priv *wil = vif_to_wil(vif);
3980	struct wmi_link_stats_cmd cmd = {
3981	.record_type_mask = cpu_to_le32(type),
3982	.cid = cid,
3983	.action = WMI_LINK_STATS_SNAPSHOT,
3984	.interval_msec = cpu_to_le32(interval),
3985	};
3986	struct {
3987	struct wmi_cmd_hdr wmi;
3988	struct wmi_link_stats_config_done_event evt;
3989	} __packed reply = {
3990	.evt = {.status = WMI_FW_STATUS_FAILURE},
3991	};
3992	int rc;
3993
3994	rc = wmi_call(wil, cmdid: WMI_LINK_STATS_CMDID, mid: vif->mid, buf: &cmd, len: sizeof(cmd),
3995	reply_id: WMI_LINK_STATS_CONFIG_DONE_EVENTID, reply: &reply,
3996	reply_size: sizeof(reply), WIL_WMI_CALL_GENERAL_TO_MS);
3997	if (rc) {
3998	wil_err(wil, "WMI_LINK_STATS_CMDID failed, rc %d\n", rc);
3999	return rc;
4000	}
4001
4002	if (reply.evt.status != WMI_FW_STATUS_SUCCESS) {
4003	wil_err(wil, "Link statistics config failed, status %d\n",
4004	reply.evt.status);
4005	return -EINVAL;
4006	}
4007
4008	return 0;
4009	}
4010
4011	int wmi_set_cqm_rssi_config(struct wil6210_priv *wil,
4012	s32 rssi_thold, u32 rssi_hyst)
4013	{
4014	struct net_device *ndev = wil->main_ndev;
4015	struct wil6210_vif *vif = ndev_to_vif(ndev);
4016	int rc;
4017	struct {
4018	struct wmi_set_link_monitor_cmd cmd;
4019	s8 rssi_thold;
4020	} __packed cmd = {
4021	.cmd = {
4022	.rssi_hyst = rssi_hyst,
4023	.rssi_thresholds_list_size = 1,
4024	},
4025	.rssi_thold = rssi_thold,
4026	};
4027	struct {
4028	struct wmi_cmd_hdr hdr;
4029	struct wmi_set_link_monitor_event evt;
4030	} __packed reply = {
4031	.evt = {.status = WMI_FW_STATUS_FAILURE},
4032	};
4033
4034	if (rssi_thold > S8_MAX || rssi_thold < S8_MIN || rssi_hyst > U8_MAX)
4035	return -EINVAL;
4036
4037	rc = wmi_call(wil, cmdid: WMI_SET_LINK_MONITOR_CMDID, mid: vif->mid, buf: &cmd,
4038	len: sizeof(cmd), reply_id: WMI_SET_LINK_MONITOR_EVENTID,
4039	reply: &reply, reply_size: sizeof(reply), WIL_WMI_CALL_GENERAL_TO_MS);
4040	if (rc) {
4041	wil_err(wil, "WMI_SET_LINK_MONITOR_CMDID failed, rc %d\n", rc);
4042	return rc;
4043	}
4044
4045	if (reply.evt.status != WMI_FW_STATUS_SUCCESS) {
4046	wil_err(wil, "WMI_SET_LINK_MONITOR_CMDID failed, status %d\n",
4047	reply.evt.status);
4048	return -EINVAL;
4049	}
4050
4051	return 0;
4052	}
4053