1	/*
2	* Copyright (c) 2014 Redpine Signals Inc.
3	*
4	* Permission to use, copy, modify, and/or distribute this software for any
5	* purpose with or without fee is hereby granted, provided that the above
6	* copyright notice and this permission notice appear in all copies.
7	*
8	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15	*/
16
17	#include <linux/etherdevice.h>
18	#include <linux/timer.h>
19	#include "rsi_mgmt.h"
20	#include "rsi_common.h"
21	#include "rsi_ps.h"
22	#include "rsi_hal.h"
23
24	static struct bootup_params boot_params_20 = {
25	.magic_number = cpu_to_le16(0x5aa5),
26	.crystal_good_time = 0x0,
27	.valid = cpu_to_le32(VALID_20),
28	.reserved_for_valids = 0x0,
29	.bootup_mode_info = 0x0,
30	.digital_loop_back_params = 0x0,
31	.rtls_timestamp_en = 0x0,
32	.host_spi_intr_cfg = 0x0,
33	.device_clk_info = {{
34	.pll_config_g = {
35	.tapll_info_g = {
36	.pll_reg_1 = cpu_to_le16((TA_PLL_N_VAL_20 << 8)|
37	(TA_PLL_M_VAL_20)),
38	.pll_reg_2 = cpu_to_le16(TA_PLL_P_VAL_20),
39	},
40	.pll960_info_g = {
41	.pll_reg_1 = cpu_to_le16((PLL960_P_VAL_20 << 8)|
42	(PLL960_N_VAL_20)),
43	.pll_reg_2 = cpu_to_le16(PLL960_M_VAL_20),
44	.pll_reg_3 = 0x0,
45	},
46	.afepll_info_g = {
47	.pll_reg = cpu_to_le16(0x9f0),
48	}
49	},
50	.switch_clk_g = {
51	.switch_clk_info = cpu_to_le16(0xb),
52	.bbp_lmac_clk_reg_val = cpu_to_le16(0x111),
53	.umac_clock_reg_config = cpu_to_le16(0x48),
54	.qspi_uart_clock_reg_config = cpu_to_le16(0x1211)
55	}
56	},
57	{
58	.pll_config_g = {
59	.tapll_info_g = {
60	.pll_reg_1 = cpu_to_le16((TA_PLL_N_VAL_20 << 8)|
61	(TA_PLL_M_VAL_20)),
62	.pll_reg_2 = cpu_to_le16(TA_PLL_P_VAL_20),
63	},
64	.pll960_info_g = {
65	.pll_reg_1 = cpu_to_le16((PLL960_P_VAL_20 << 8)|
66	(PLL960_N_VAL_20)),
67	.pll_reg_2 = cpu_to_le16(PLL960_M_VAL_20),
68	.pll_reg_3 = 0x0,
69	},
70	.afepll_info_g = {
71	.pll_reg = cpu_to_le16(0x9f0),
72	}
73	},
74	.switch_clk_g = {
75	.switch_clk_info = 0x0,
76	.bbp_lmac_clk_reg_val = 0x0,
77	.umac_clock_reg_config = 0x0,
78	.qspi_uart_clock_reg_config = 0x0
79	}
80	},
81	{
82	.pll_config_g = {
83	.tapll_info_g = {
84	.pll_reg_1 = cpu_to_le16((TA_PLL_N_VAL_20 << 8)|
85	(TA_PLL_M_VAL_20)),
86	.pll_reg_2 = cpu_to_le16(TA_PLL_P_VAL_20),
87	},
88	.pll960_info_g = {
89	.pll_reg_1 = cpu_to_le16((PLL960_P_VAL_20 << 8)|
90	(PLL960_N_VAL_20)),
91	.pll_reg_2 = cpu_to_le16(PLL960_M_VAL_20),
92	.pll_reg_3 = 0x0,
93	},
94	.afepll_info_g = {
95	.pll_reg = cpu_to_le16(0x9f0),
96	}
97	},
98	.switch_clk_g = {
99	.switch_clk_info = 0x0,
100	.bbp_lmac_clk_reg_val = 0x0,
101	.umac_clock_reg_config = 0x0,
102	.qspi_uart_clock_reg_config = 0x0
103	}
104	} },
105	.buckboost_wakeup_cnt = 0x0,
106	.pmu_wakeup_wait = 0x0,
107	.shutdown_wait_time = 0x0,
108	.pmu_slp_clkout_sel = 0x0,
109	.wdt_prog_value = 0x0,
110	.wdt_soc_rst_delay = 0x0,
111	.dcdc_operation_mode = 0x0,
112	.soc_reset_wait_cnt = 0x0,
113	.waiting_time_at_fresh_sleep = 0x0,
114	.max_threshold_to_avoid_sleep = 0x0,
115	.beacon_resedue_alg_en = 0,
116	};
117
118	static struct bootup_params boot_params_40 = {
119	.magic_number = cpu_to_le16(0x5aa5),
120	.crystal_good_time = 0x0,
121	.valid = cpu_to_le32(VALID_40),
122	.reserved_for_valids = 0x0,
123	.bootup_mode_info = 0x0,
124	.digital_loop_back_params = 0x0,
125	.rtls_timestamp_en = 0x0,
126	.host_spi_intr_cfg = 0x0,
127	.device_clk_info = {{
128	.pll_config_g = {
129	.tapll_info_g = {
130	.pll_reg_1 = cpu_to_le16((TA_PLL_N_VAL_40 << 8)|
131	(TA_PLL_M_VAL_40)),
132	.pll_reg_2 = cpu_to_le16(TA_PLL_P_VAL_40),
133	},
134	.pll960_info_g = {
135	.pll_reg_1 = cpu_to_le16((PLL960_P_VAL_40 << 8)|
136	(PLL960_N_VAL_40)),
137	.pll_reg_2 = cpu_to_le16(PLL960_M_VAL_40),
138	.pll_reg_3 = 0x0,
139	},
140	.afepll_info_g = {
141	.pll_reg = cpu_to_le16(0x9f0),
142	}
143	},
144	.switch_clk_g = {
145	.switch_clk_info = cpu_to_le16(0x09),
146	.bbp_lmac_clk_reg_val = cpu_to_le16(0x1121),
147	.umac_clock_reg_config = cpu_to_le16(0x48),
148	.qspi_uart_clock_reg_config = cpu_to_le16(0x1211)
149	}
150	},
151	{
152	.pll_config_g = {
153	.tapll_info_g = {
154	.pll_reg_1 = cpu_to_le16((TA_PLL_N_VAL_40 << 8)|
155	(TA_PLL_M_VAL_40)),
156	.pll_reg_2 = cpu_to_le16(TA_PLL_P_VAL_40),
157	},
158	.pll960_info_g = {
159	.pll_reg_1 = cpu_to_le16((PLL960_P_VAL_40 << 8)|
160	(PLL960_N_VAL_40)),
161	.pll_reg_2 = cpu_to_le16(PLL960_M_VAL_40),
162	.pll_reg_3 = 0x0,
163	},
164	.afepll_info_g = {
165	.pll_reg = cpu_to_le16(0x9f0),
166	}
167	},
168	.switch_clk_g = {
169	.switch_clk_info = 0x0,
170	.bbp_lmac_clk_reg_val = 0x0,
171	.umac_clock_reg_config = 0x0,
172	.qspi_uart_clock_reg_config = 0x0
173	}
174	},
175	{
176	.pll_config_g = {
177	.tapll_info_g = {
178	.pll_reg_1 = cpu_to_le16((TA_PLL_N_VAL_40 << 8)|
179	(TA_PLL_M_VAL_40)),
180	.pll_reg_2 = cpu_to_le16(TA_PLL_P_VAL_40),
181	},
182	.pll960_info_g = {
183	.pll_reg_1 = cpu_to_le16((PLL960_P_VAL_40 << 8)|
184	(PLL960_N_VAL_40)),
185	.pll_reg_2 = cpu_to_le16(PLL960_M_VAL_40),
186	.pll_reg_3 = 0x0,
187	},
188	.afepll_info_g = {
189	.pll_reg = cpu_to_le16(0x9f0),
190	}
191	},
192	.switch_clk_g = {
193	.switch_clk_info = 0x0,
194	.bbp_lmac_clk_reg_val = 0x0,
195	.umac_clock_reg_config = 0x0,
196	.qspi_uart_clock_reg_config = 0x0
197	}
198	} },
199	.buckboost_wakeup_cnt = 0x0,
200	.pmu_wakeup_wait = 0x0,
201	.shutdown_wait_time = 0x0,
202	.pmu_slp_clkout_sel = 0x0,
203	.wdt_prog_value = 0x0,
204	.wdt_soc_rst_delay = 0x0,
205	.dcdc_operation_mode = 0x0,
206	.soc_reset_wait_cnt = 0x0,
207	.waiting_time_at_fresh_sleep = 0x0,
208	.max_threshold_to_avoid_sleep = 0x0,
209	.beacon_resedue_alg_en = 0,
210	};
211
212	static struct bootup_params_9116 boot_params_9116_20 = {
213	.magic_number = cpu_to_le16(LOADED_TOKEN),
214	.valid = cpu_to_le32(VALID_20),
215	.device_clk_info_9116 = {{
216	.pll_config_9116_g = {
217	.pll_ctrl_set_reg = cpu_to_le16(0xd518),
218	.pll_ctrl_clr_reg = cpu_to_le16(0x2ae7),
219	.pll_modem_conig_reg = cpu_to_le16(0x2000),
220	.soc_clk_config_reg = cpu_to_le16(0x0c18),
221	.adc_dac_strm1_config_reg = cpu_to_le16(0x1100),
222	.adc_dac_strm2_config_reg = cpu_to_le16(0x6600),
223	},
224	.switch_clk_9116_g = {
225	.switch_clk_info =
226	cpu_to_le32((RSI_SWITCH_TASS_CLK |
227	RSI_SWITCH_WLAN_BBP_LMAC_CLK_REG |
228	RSI_SWITCH_BBP_LMAC_CLK_REG)),
229	.tass_clock_reg = cpu_to_le32(0x083C0503),
230	.wlan_bbp_lmac_clk_reg_val = cpu_to_le32(0x01042001),
231	.zbbt_bbp_lmac_clk_reg_val = cpu_to_le32(0x02010001),
232	.bbp_lmac_clk_en_val = cpu_to_le32(0x0000003b),
233	}
234	},
235	},
236	};
237
238	static struct bootup_params_9116 boot_params_9116_40 = {
239	.magic_number = cpu_to_le16(LOADED_TOKEN),
240	.valid = cpu_to_le32(VALID_40),
241	.device_clk_info_9116 = {{
242	.pll_config_9116_g = {
243	.pll_ctrl_set_reg = cpu_to_le16(0xd518),
244	.pll_ctrl_clr_reg = cpu_to_le16(0x2ae7),
245	.pll_modem_conig_reg = cpu_to_le16(0x3000),
246	.soc_clk_config_reg = cpu_to_le16(0x0c18),
247	.adc_dac_strm1_config_reg = cpu_to_le16(0x0000),
248	.adc_dac_strm2_config_reg = cpu_to_le16(0x6600),
249	},
250	.switch_clk_9116_g = {
251	.switch_clk_info =
252	cpu_to_le32((RSI_SWITCH_TASS_CLK |
253	RSI_SWITCH_WLAN_BBP_LMAC_CLK_REG |
254	RSI_SWITCH_BBP_LMAC_CLK_REG |
255	RSI_MODEM_CLK_160MHZ)),
256	.tass_clock_reg = cpu_to_le32(0x083C0503),
257	.wlan_bbp_lmac_clk_reg_val = cpu_to_le32(0x01042002),
258	.zbbt_bbp_lmac_clk_reg_val = cpu_to_le32(0x04010002),
259	.bbp_lmac_clk_en_val = cpu_to_le32(0x0000003b),
260	}
261	},
262	},
263	};
264
265	static u16 mcs[] = {13, 26, 39, 52, 78, 104, 117, 130};
266
267	/**
268	* rsi_set_default_parameters() - This function sets default parameters.
269	* @common: Pointer to the driver private structure.
270	*
271	* Return: none
272	*/
273	static void rsi_set_default_parameters(struct rsi_common *common)
274	{
275	common->band = NL80211_BAND_2GHZ;
276	common->channel_width = BW_20MHZ;
277	common->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;
278	common->channel = 1;
279	memset(&common->rate_config, 0, sizeof(common->rate_config));
280	common->fsm_state = FSM_CARD_NOT_READY;
281	common->iface_down = true;
282	common->endpoint = EP_2GHZ_20MHZ;
283	common->driver_mode = 1; /* End to end mode */
284	common->lp_ps_handshake_mode = 0; /* Default no handShake mode*/
285	common->ulp_ps_handshake_mode = 2; /* Default PKT handShake mode*/
286	common->rf_power_val = 0; /* Default 1.9V */
287	common->wlan_rf_power_mode = 0;
288	common->obm_ant_sel_val = 2;
289	common->beacon_interval = RSI_BEACON_INTERVAL;
290	common->dtim_cnt = RSI_DTIM_COUNT;
291	common->w9116_features.pll_mode = 0x0;
292	common->w9116_features.rf_type = 1;
293	common->w9116_features.wireless_mode = 0;
294	common->w9116_features.enable_ppe = 0;
295	common->w9116_features.afe_type = 1;
296	common->w9116_features.dpd = 0;
297	common->w9116_features.sifs_tx_enable = 0;
298	common->w9116_features.ps_options = 0;
299	}
300
301	void init_bgscan_params(struct rsi_common *common)
302	{
303	memset((u8 *)&common->bgscan, 0, sizeof(struct rsi_bgscan_params));
304	common->bgscan.bgscan_threshold = RSI_DEF_BGSCAN_THRLD;
305	common->bgscan.roam_threshold = RSI_DEF_ROAM_THRLD;
306	common->bgscan.bgscan_periodicity = RSI_BGSCAN_PERIODICITY;
307	common->bgscan.num_bgscan_channels = 0;
308	common->bgscan.two_probe = 1;
309	common->bgscan.active_scan_duration = RSI_ACTIVE_SCAN_TIME;
310	common->bgscan.passive_scan_duration = RSI_PASSIVE_SCAN_TIME;
311	}
312
313	/**
314	* rsi_set_contention_vals() - This function sets the contention values for the
315	* backoff procedure.
316	* @common: Pointer to the driver private structure.
317	*
318	* Return: None.
319	*/
320	static void rsi_set_contention_vals(struct rsi_common *common)
321	{
322	u8 ii = 0;
323
324	for (; ii < NUM_EDCA_QUEUES; ii++) {
325	common->tx_qinfo[ii].wme_params =
326	(((common->edca_params[ii].cw_min / 2) +
327	(common->edca_params[ii].aifs)) *
328	WMM_SHORT_SLOT_TIME + SIFS_DURATION);
329	common->tx_qinfo[ii].weight = common->tx_qinfo[ii].wme_params;
330	common->tx_qinfo[ii].pkt_contended = 0;
331	}
332	}
333
334	/**
335	* rsi_send_internal_mgmt_frame() - This function sends management frames to
336	* firmware.Also schedules packet to queue
337	* for transmission.
338	* @common: Pointer to the driver private structure.
339	* @skb: Pointer to the socket buffer structure.
340	*
341	* Return: 0 on success, -1 on failure.
342	*/
343	static int rsi_send_internal_mgmt_frame(struct rsi_common *common,
344	struct sk_buff *skb)
345	{
346	struct skb_info *tx_params;
347	struct rsi_cmd_desc *desc;
348
349	if (skb == NULL) {
350	rsi_dbg(ERR_ZONE, fmt: "%s: Unable to allocate skb\n", __func__);
351	return -ENOMEM;
352	}
353	desc = (struct rsi_cmd_desc *)skb->data;
354	desc->desc_dword0.len_qno |= cpu_to_le16(DESC_IMMEDIATE_WAKEUP);
355	skb->priority = MGMT_SOFT_Q;
356	tx_params = (struct skb_info *)&IEEE80211_SKB_CB(skb)->driver_data;
357	tx_params->flags |= INTERNAL_MGMT_PKT;
358	skb_queue_tail(list: &common->tx_queue[MGMT_SOFT_Q], newsk: skb);
359	rsi_set_event(event: &common->tx_thread.event);
360	return 0;
361	}
362
363	/**
364	* rsi_load_radio_caps() - This function is used to send radio capabilities
365	* values to firmware.
366	* @common: Pointer to the driver private structure.
367	*
368	* Return: 0 on success, corresponding negative error code on failure.
369	*/
370	static int rsi_load_radio_caps(struct rsi_common *common)
371	{
372	struct rsi_radio_caps *radio_caps;
373	struct rsi_hw *adapter = common->priv;
374	u16 inx = 0;
375	u8 ii;
376	u8 radio_id = 0;
377	u16 gc[20] = {0xf0, 0xf0, 0xf0, 0xf0,
378	0xf0, 0xf0, 0xf0, 0xf0,
379	0xf0, 0xf0, 0xf0, 0xf0,
380	0xf0, 0xf0, 0xf0, 0xf0,
381	0xf0, 0xf0, 0xf0, 0xf0};
382	struct sk_buff *skb;
383	u16 frame_len = sizeof(struct rsi_radio_caps);
384
385	rsi_dbg(INFO_ZONE, fmt: "%s: Sending rate symbol req frame\n", __func__);
386
387	skb = dev_alloc_skb(length: frame_len);
388
389	if (!skb) {
390	rsi_dbg(ERR_ZONE, fmt: "%s: Failed in allocation of skb\n",
391	__func__);
392	return -ENOMEM;
393	}
394
395	memset(skb->data, 0, frame_len);
396	radio_caps = (struct rsi_radio_caps *)skb->data;
397
398	radio_caps->desc_dword0.frame_type = RADIO_CAPABILITIES;
399	radio_caps->channel_num = common->channel;
400	radio_caps->rf_model = RSI_RF_TYPE;
401
402	radio_caps->radio_cfg_info = RSI_LMAC_CLOCK_80MHZ;
403	if (common->channel_width == BW_40MHZ) {
404	radio_caps->radio_cfg_info |= RSI_ENABLE_40MHZ;
405
406	if (common->fsm_state == FSM_MAC_INIT_DONE) {
407	struct ieee80211_hw *hw = adapter->hw;
408	struct ieee80211_conf *conf = &hw->conf;
409
410	if (conf_is_ht40_plus(conf)) {
411	radio_caps->ppe_ack_rate =
412	cpu_to_le16(LOWER_20_ENABLE |
413	(LOWER_20_ENABLE >> 12));
414	} else if (conf_is_ht40_minus(conf)) {
415	radio_caps->ppe_ack_rate =
416	cpu_to_le16(UPPER_20_ENABLE |
417	(UPPER_20_ENABLE >> 12));
418	} else {
419	radio_caps->ppe_ack_rate =
420	cpu_to_le16((BW_40MHZ << 12) |
421	FULL40M_ENABLE);
422	}
423	}
424	}
425	radio_caps->radio_info |= radio_id;
426
427	if (adapter->device_model == RSI_DEV_9116 &&
428	common->channel_width == BW_20MHZ)
429	radio_caps->radio_cfg_info &= ~0x3;
430
431	radio_caps->sifs_tx_11n = cpu_to_le16(SIFS_TX_11N_VALUE);
432	radio_caps->sifs_tx_11b = cpu_to_le16(SIFS_TX_11B_VALUE);
433	radio_caps->slot_rx_11n = cpu_to_le16(SHORT_SLOT_VALUE);
434	radio_caps->ofdm_ack_tout = cpu_to_le16(OFDM_ACK_TOUT_VALUE);
435	radio_caps->cck_ack_tout = cpu_to_le16(CCK_ACK_TOUT_VALUE);
436	radio_caps->preamble_type = cpu_to_le16(LONG_PREAMBLE);
437
438	for (ii = 0; ii < MAX_HW_QUEUES; ii++) {
439	radio_caps->qos_params[ii].cont_win_min_q = cpu_to_le16(3);
440	radio_caps->qos_params[ii].cont_win_max_q = cpu_to_le16(0x3f);
441	radio_caps->qos_params[ii].aifsn_val_q = cpu_to_le16(2);
442	radio_caps->qos_params[ii].txop_q = 0;
443	}
444
445	for (ii = 0; ii < NUM_EDCA_QUEUES; ii++) {
446	if (common->edca_params[ii].cw_max > 0) {
447	radio_caps->qos_params[ii].cont_win_min_q =
448	cpu_to_le16(common->edca_params[ii].cw_min);
449	radio_caps->qos_params[ii].cont_win_max_q =
450	cpu_to_le16(common->edca_params[ii].cw_max);
451	radio_caps->qos_params[ii].aifsn_val_q =
452	cpu_to_le16(common->edca_params[ii].aifs << 8);
453	radio_caps->qos_params[ii].txop_q =
454	cpu_to_le16(common->edca_params[ii].txop);
455	}
456	}
457
458	radio_caps->qos_params[BROADCAST_HW_Q].txop_q = cpu_to_le16(0xffff);
459	radio_caps->qos_params[MGMT_HW_Q].txop_q = 0;
460	radio_caps->qos_params[BEACON_HW_Q].txop_q = cpu_to_le16(0xffff);
461
462	memcpy(&common->rate_pwr[0], &gc[0], 40);
463	for (ii = 0; ii < 20; ii++)
464	radio_caps->gcpd_per_rate[inx++] =
465	cpu_to_le16(common->rate_pwr[ii] & 0x00FF);
466
467	rsi_set_len_qno(addr: &radio_caps->desc_dword0.len_qno,
468	len: (frame_len - FRAME_DESC_SZ), RSI_WIFI_MGMT_Q);
469
470	skb_put(skb, len: frame_len);
471
472	return rsi_send_internal_mgmt_frame(common, skb);
473	}
474
475	/**
476	* rsi_mgmt_pkt_to_core() - This function is the entry point for Mgmt module.
477	* @common: Pointer to the driver private structure.
478	* @msg: Pointer to received packet.
479	* @msg_len: Length of the received packet.
480	*
481	* Return: 0 on success, -1 on failure.
482	*/
483	static int rsi_mgmt_pkt_to_core(struct rsi_common *common,
484	u8 *msg,
485	s32 msg_len)
486	{
487	struct rsi_hw *adapter = common->priv;
488	struct ieee80211_tx_info *info;
489	struct skb_info *rx_params;
490	u8 pad_bytes = msg[4];
491	struct sk_buff *skb;
492
493	if (!adapter->sc_nvifs)
494	return -ENOLINK;
495
496	msg_len -= pad_bytes;
497	if (msg_len <= 0) {
498	rsi_dbg(MGMT_RX_ZONE,
499	fmt: "%s: Invalid rx msg of len = %d\n",
500	__func__, msg_len);
501	return -EINVAL;
502	}
503
504	skb = dev_alloc_skb(length: msg_len);
505	if (!skb)
506	return -ENOMEM;
507
508	skb_put_data(skb,
509	data: (u8 *)(msg + FRAME_DESC_SZ + pad_bytes),
510	len: msg_len);
511
512	info = IEEE80211_SKB_CB(skb);
513	rx_params = (struct skb_info *)info->driver_data;
514	rx_params->rssi = rsi_get_rssi(addr: msg);
515	rx_params->channel = rsi_get_channel(addr: msg);
516	rsi_indicate_pkt_to_os(common, skb);
517
518	return 0;
519	}
520
521	/**
522	* rsi_hal_send_sta_notify_frame() - This function sends the station notify
523	* frame to firmware.
524	* @common: Pointer to the driver private structure.
525	* @opmode: Operating mode of device.
526	* @notify_event: Notification about station connection.
527	* @bssid: bssid.
528	* @qos_enable: Qos is enabled.
529	* @aid: Aid (unique for all STA).
530	* @sta_id: station id.
531	* @vif: Pointer to the ieee80211_vif structure.
532	*
533	* Return: status: 0 on success, corresponding negative error code on failure.
534	*/
535	int rsi_hal_send_sta_notify_frame(struct rsi_common *common, enum opmode opmode,
536	u8 notify_event, const unsigned char *bssid,
537	u8 qos_enable, u16 aid, u16 sta_id,
538	struct ieee80211_vif *vif)
539	{
540	struct sk_buff *skb = NULL;
541	struct rsi_peer_notify *peer_notify;
542	u16 vap_id = ((struct vif_priv *)vif->drv_priv)->vap_id;
543	int status;
544	u16 frame_len = sizeof(struct rsi_peer_notify);
545
546	rsi_dbg(MGMT_TX_ZONE, fmt: "%s: Sending sta notify frame\n", __func__);
547
548	skb = dev_alloc_skb(length: frame_len);
549
550	if (!skb) {
551	rsi_dbg(ERR_ZONE, fmt: "%s: Failed in allocation of skb\n",
552	__func__);
553	return -ENOMEM;
554	}
555
556	memset(skb->data, 0, frame_len);
557	peer_notify = (struct rsi_peer_notify *)skb->data;
558
559	if (opmode == RSI_OPMODE_STA)
560	peer_notify->command = cpu_to_le16(PEER_TYPE_AP << 1);
561	else if (opmode == RSI_OPMODE_AP)
562	peer_notify->command = cpu_to_le16(PEER_TYPE_STA << 1);
563
564	switch (notify_event) {
565	case STA_CONNECTED:
566	peer_notify->command |= cpu_to_le16(RSI_ADD_PEER);
567	break;
568	case STA_DISCONNECTED:
569	peer_notify->command |= cpu_to_le16(RSI_DELETE_PEER);
570	break;
571	default:
572	break;
573	}
574
575	peer_notify->command |= cpu_to_le16((aid & 0xfff) << 4);
576	ether_addr_copy(dst: peer_notify->mac_addr, src: bssid);
577	peer_notify->mpdu_density = cpu_to_le16(RSI_MPDU_DENSITY);
578	peer_notify->sta_flags = cpu_to_le32((qos_enable) ? 1 : 0);
579
580	rsi_set_len_qno(addr: &peer_notify->desc.desc_dword0.len_qno,
581	len: (frame_len - FRAME_DESC_SZ),
582	RSI_WIFI_MGMT_Q);
583	peer_notify->desc.desc_dword0.frame_type = PEER_NOTIFY;
584	peer_notify->desc.desc_dword3.qid_tid = sta_id;
585	peer_notify->desc.desc_dword3.sta_id = vap_id;
586
587	skb_put(skb, len: frame_len);
588
589	status = rsi_send_internal_mgmt_frame(common, skb);
590
591	if ((vif->type == NL80211_IFTYPE_STATION) &&
592	(!status && qos_enable)) {
593	rsi_set_contention_vals(common);
594	status = rsi_load_radio_caps(common);
595	}
596	return status;
597	}
598
599	/**
600	* rsi_send_aggregation_params_frame() - This function sends the ampdu
601	* indication frame to firmware.
602	* @common: Pointer to the driver private structure.
603	* @tid: traffic identifier.
604	* @ssn: ssn.
605	* @buf_size: buffer size.
606	* @event: notification about station connection.
607	* @sta_id: station id.
608	*
609	* Return: 0 on success, corresponding negative error code on failure.
610	*/
611	int rsi_send_aggregation_params_frame(struct rsi_common *common,
612	u16 tid,
613	u16 ssn,
614	u8 buf_size,
615	u8 event,
616	u8 sta_id)
617	{
618	struct sk_buff *skb = NULL;
619	struct rsi_aggr_params *aggr_params;
620	u16 frame_len = sizeof(struct rsi_aggr_params);
621
622	skb = dev_alloc_skb(length: frame_len);
623
624	if (!skb) {
625	rsi_dbg(ERR_ZONE, fmt: "%s: Failed in allocation of skb\n",
626	__func__);
627	return -ENOMEM;
628	}
629
630	memset(skb->data, 0, frame_len);
631	aggr_params = (struct rsi_aggr_params *)skb->data;
632
633	rsi_dbg(MGMT_TX_ZONE, fmt: "%s: Sending AMPDU indication frame\n", __func__);
634
635	rsi_set_len_qno(addr: &aggr_params->desc_dword0.len_qno, len: 0, RSI_WIFI_MGMT_Q);
636	aggr_params->desc_dword0.frame_type = AMPDU_IND;
637
638	aggr_params->aggr_params = tid & RSI_AGGR_PARAMS_TID_MASK;
639	aggr_params->peer_id = sta_id;
640	if (event == STA_TX_ADDBA_DONE) {
641	aggr_params->seq_start = cpu_to_le16(ssn);
642	aggr_params->baw_size = cpu_to_le16(buf_size);
643	aggr_params->aggr_params |= RSI_AGGR_PARAMS_START;
644	} else if (event == STA_RX_ADDBA_DONE) {
645	aggr_params->seq_start = cpu_to_le16(ssn);
646	aggr_params->aggr_params |= (RSI_AGGR_PARAMS_START |
647	RSI_AGGR_PARAMS_RX_AGGR);
648	} else if (event == STA_RX_DELBA) {
649	aggr_params->aggr_params |= RSI_AGGR_PARAMS_RX_AGGR;
650	}
651
652	skb_put(skb, len: frame_len);
653
654	return rsi_send_internal_mgmt_frame(common, skb);
655	}
656
657	/**
658	* rsi_program_bb_rf() - This function starts base band and RF programming.
659	* This is called after initial configurations are done.
660	* @common: Pointer to the driver private structure.
661	*
662	* Return: 0 on success, corresponding negative error code on failure.
663	*/
664	static int rsi_program_bb_rf(struct rsi_common *common)
665	{
666	struct sk_buff *skb;
667	struct rsi_bb_rf_prog *bb_rf_prog;
668	u16 frame_len = sizeof(struct rsi_bb_rf_prog);
669
670	rsi_dbg(MGMT_TX_ZONE, fmt: "%s: Sending program BB/RF frame\n", __func__);
671
672	skb = dev_alloc_skb(length: frame_len);
673	if (!skb) {
674	rsi_dbg(ERR_ZONE, fmt: "%s: Failed in allocation of skb\n",
675	__func__);
676	return -ENOMEM;
677	}
678
679	memset(skb->data, 0, frame_len);
680	bb_rf_prog = (struct rsi_bb_rf_prog *)skb->data;
681
682	rsi_set_len_qno(addr: &bb_rf_prog->desc_dword0.len_qno, len: 0, RSI_WIFI_MGMT_Q);
683	bb_rf_prog->desc_dword0.frame_type = BBP_PROG_IN_TA;
684	bb_rf_prog->endpoint = common->endpoint;
685	bb_rf_prog->rf_power_mode = common->wlan_rf_power_mode;
686
687	if (common->rf_reset) {
688	bb_rf_prog->flags = cpu_to_le16(RF_RESET_ENABLE);
689	rsi_dbg(MGMT_TX_ZONE, fmt: "%s: ===> RF RESET REQUEST SENT <===\n",
690	__func__);
691	common->rf_reset = 0;
692	}
693	common->bb_rf_prog_count = 1;
694	bb_rf_prog->flags |= cpu_to_le16(PUT_BBP_RESET | BBP_REG_WRITE |
695	(RSI_RF_TYPE << 4));
696	skb_put(skb, len: frame_len);
697
698	return rsi_send_internal_mgmt_frame(common, skb);
699	}
700
701	/**
702	* rsi_set_vap_capabilities() - This function send vap capability to firmware.
703	* @common: Pointer to the driver private structure.
704	* @mode: Operating mode of device.
705	* @mac_addr: MAC address
706	* @vap_id: Rate information - offset and mask
707	* @vap_status: VAP status - ADD, DELETE or UPDATE
708	*
709	* Return: 0 on success, corresponding negative error code on failure.
710	*/
711	int rsi_set_vap_capabilities(struct rsi_common *common,
712	enum opmode mode,
713	u8 *mac_addr,
714	u8 vap_id,
715	u8 vap_status)
716	{
717	struct sk_buff *skb = NULL;
718	struct rsi_vap_caps *vap_caps;
719	struct rsi_hw *adapter = common->priv;
720	struct ieee80211_hw *hw = adapter->hw;
721	struct ieee80211_conf *conf = &hw->conf;
722	u16 frame_len = sizeof(struct rsi_vap_caps);
723
724	rsi_dbg(MGMT_TX_ZONE, fmt: "%s: Sending VAP capabilities frame\n", __func__);
725
726	skb = dev_alloc_skb(length: frame_len);
727	if (!skb) {
728	rsi_dbg(ERR_ZONE, fmt: "%s: Failed in allocation of skb\n",
729	__func__);
730	return -ENOMEM;
731	}
732
733	memset(skb->data, 0, frame_len);
734	vap_caps = (struct rsi_vap_caps *)skb->data;
735
736	rsi_set_len_qno(addr: &vap_caps->desc_dword0.len_qno,
737	len: (frame_len - FRAME_DESC_SZ), RSI_WIFI_MGMT_Q);
738	vap_caps->desc_dword0.frame_type = VAP_CAPABILITIES;
739	vap_caps->status = vap_status;
740	vap_caps->vif_type = mode;
741	vap_caps->channel_bw = common->channel_width;
742	vap_caps->vap_id = vap_id;
743	vap_caps->radioid_macid = ((common->mac_id & 0xf) << 4) |
744	(common->radio_id & 0xf);
745
746	memcpy(vap_caps->mac_addr, mac_addr, IEEE80211_ADDR_LEN);
747	vap_caps->keep_alive_period = cpu_to_le16(90);
748	vap_caps->frag_threshold = cpu_to_le16(IEEE80211_MAX_FRAG_THRESHOLD);
749
750	vap_caps->rts_threshold = cpu_to_le16(common->rts_threshold);
751
752	if (common->band == NL80211_BAND_5GHZ) {
753	vap_caps->default_ctrl_rate = cpu_to_le16(RSI_RATE_6);
754	vap_caps->default_mgmt_rate = cpu_to_le32(RSI_RATE_6);
755	} else {
756	vap_caps->default_ctrl_rate = cpu_to_le16(RSI_RATE_1);
757	vap_caps->default_mgmt_rate = cpu_to_le32(RSI_RATE_1);
758	}
759	if (conf_is_ht40(conf)) {
760	if (conf_is_ht40_minus(conf))
761	vap_caps->ctrl_rate_flags =
762	cpu_to_le16(UPPER_20_ENABLE);
763	else if (conf_is_ht40_plus(conf))
764	vap_caps->ctrl_rate_flags =
765	cpu_to_le16(LOWER_20_ENABLE);
766	else
767	vap_caps->ctrl_rate_flags =
768	cpu_to_le16(FULL40M_ENABLE);
769	}
770
771	vap_caps->default_data_rate = 0;
772	vap_caps->beacon_interval = cpu_to_le16(common->beacon_interval);
773	vap_caps->dtim_period = cpu_to_le16(common->dtim_cnt);
774
775	skb_put(skb, len: frame_len);
776
777	return rsi_send_internal_mgmt_frame(common, skb);
778	}
779
780	/**
781	* rsi_hal_load_key() - This function is used to load keys within the firmware.
782	* @common: Pointer to the driver private structure.
783	* @data: Pointer to the key data.
784	* @key_len: Key length to be loaded.
785	* @key_type: Type of key: GROUP/PAIRWISE.
786	* @key_id: Key index.
787	* @cipher: Type of cipher used.
788	* @sta_id: Station id.
789	* @vif: Pointer to the ieee80211_vif structure.
790	*
791	* Return: 0 on success, -1 on failure.
792	*/
793	int rsi_hal_load_key(struct rsi_common *common,
794	u8 *data,
795	u16 key_len,
796	u8 key_type,
797	u8 key_id,
798	u32 cipher,
799	s16 sta_id,
800	struct ieee80211_vif *vif)
801	{
802	struct sk_buff *skb = NULL;
803	struct rsi_set_key *set_key;
804	u16 key_descriptor = 0;
805	u16 frame_len = sizeof(struct rsi_set_key);
806
807	rsi_dbg(MGMT_TX_ZONE, fmt: "%s: Sending load key frame\n", __func__);
808
809	skb = dev_alloc_skb(length: frame_len);
810	if (!skb) {
811	rsi_dbg(ERR_ZONE, fmt: "%s: Failed in allocation of skb\n",
812	__func__);
813	return -ENOMEM;
814	}
815
816	memset(skb->data, 0, frame_len);
817	set_key = (struct rsi_set_key *)skb->data;
818
819	if (key_type == RSI_GROUP_KEY) {
820	key_descriptor = RSI_KEY_TYPE_BROADCAST;
821	if (vif->type == NL80211_IFTYPE_AP)
822	key_descriptor |= RSI_KEY_MODE_AP;
823	}
824	if ((cipher == WLAN_CIPHER_SUITE_WEP40) ||
825	(cipher == WLAN_CIPHER_SUITE_WEP104)) {
826	key_id = 0;
827	key_descriptor |= RSI_WEP_KEY;
828	if (key_len >= 13)
829	key_descriptor |= RSI_WEP_KEY_104;
830	} else if (cipher != KEY_TYPE_CLEAR) {
831	key_descriptor |= RSI_CIPHER_WPA;
832	if (cipher == WLAN_CIPHER_SUITE_TKIP)
833	key_descriptor |= RSI_CIPHER_TKIP;
834	}
835	key_descriptor |= RSI_PROTECT_DATA_FRAMES;
836	key_descriptor |= (key_id << RSI_KEY_ID_OFFSET);
837
838	rsi_set_len_qno(addr: &set_key->desc_dword0.len_qno,
839	len: (frame_len - FRAME_DESC_SZ), RSI_WIFI_MGMT_Q);
840	set_key->desc_dword0.frame_type = SET_KEY_REQ;
841	set_key->key_desc = cpu_to_le16(key_descriptor);
842	set_key->sta_id = sta_id;
843
844	if (data) {
845	if ((cipher == WLAN_CIPHER_SUITE_WEP40) ||
846	(cipher == WLAN_CIPHER_SUITE_WEP104)) {
847	memcpy(&set_key->key[key_id][1], data, key_len * 2);
848	} else {
849	memcpy(&set_key->key[0][0], data, key_len);
850	}
851	memcpy(set_key->tx_mic_key, &data[16], 8);
852	memcpy(set_key->rx_mic_key, &data[24], 8);
853	} else {
854	memset(&set_key[FRAME_DESC_SZ], 0, frame_len - FRAME_DESC_SZ);
855	}
856
857	skb_put(skb, len: frame_len);
858
859	return rsi_send_internal_mgmt_frame(common, skb);
860	}
861
862	/*
863	* This function sends the common device configuration parameters to device.
864	* This frame includes the useful information to make device works on
865	* specific operating mode.
866	*/
867	static int rsi_send_common_dev_params(struct rsi_common *common)
868	{
869	struct sk_buff *skb;
870	u16 frame_len;
871	struct rsi_config_vals *dev_cfgs;
872
873	frame_len = sizeof(struct rsi_config_vals);
874
875	rsi_dbg(MGMT_TX_ZONE, fmt: "Sending common device config params\n");
876	skb = dev_alloc_skb(length: frame_len);
877	if (!skb) {
878	rsi_dbg(ERR_ZONE, fmt: "%s: Unable to allocate skb\n", __func__);
879	return -ENOMEM;
880	}
881
882	memset(skb->data, 0, frame_len);
883
884	dev_cfgs = (struct rsi_config_vals *)skb->data;
885	memset(dev_cfgs, 0, (sizeof(struct rsi_config_vals)));
886
887	rsi_set_len_qno(addr: &dev_cfgs->len_qno, len: (frame_len - FRAME_DESC_SZ),
888	RSI_COEX_Q);
889	dev_cfgs->pkt_type = COMMON_DEV_CONFIG;
890
891	dev_cfgs->lp_ps_handshake = common->lp_ps_handshake_mode;
892	dev_cfgs->ulp_ps_handshake = common->ulp_ps_handshake_mode;
893
894	dev_cfgs->unused_ulp_gpio = RSI_UNUSED_ULP_GPIO_BITMAP;
895	dev_cfgs->unused_soc_gpio_bitmap =
896	cpu_to_le32(RSI_UNUSED_SOC_GPIO_BITMAP);
897
898	dev_cfgs->opermode = common->oper_mode;
899	dev_cfgs->wlan_rf_pwr_mode = common->wlan_rf_power_mode;
900	dev_cfgs->driver_mode = common->driver_mode;
901	dev_cfgs->region_code = NL80211_DFS_FCC;
902	dev_cfgs->antenna_sel_val = common->obm_ant_sel_val;
903
904	skb_put(skb, len: frame_len);
905
906	return rsi_send_internal_mgmt_frame(common, skb);
907	}
908
909	/*
910	* rsi_load_bootup_params() - This function send bootup params to the firmware.
911	* @common: Pointer to the driver private structure.
912	*
913	* Return: 0 on success, corresponding error code on failure.
914	*/
915	static int rsi_load_bootup_params(struct rsi_common *common)
916	{
917	struct sk_buff *skb;
918	struct rsi_boot_params *boot_params;
919
920	rsi_dbg(MGMT_TX_ZONE, fmt: "%s: Sending boot params frame\n", __func__);
921	skb = dev_alloc_skb(length: sizeof(struct rsi_boot_params));
922	if (!skb) {
923	rsi_dbg(ERR_ZONE, fmt: "%s: Failed in allocation of skb\n",
924	__func__);
925	return -ENOMEM;
926	}
927
928	memset(skb->data, 0, sizeof(struct rsi_boot_params));
929	boot_params = (struct rsi_boot_params *)skb->data;
930
931	rsi_dbg(MGMT_TX_ZONE, fmt: "%s:\n", __func__);
932
933	if (common->channel_width == BW_40MHZ) {
934	memcpy(&boot_params->bootup_params,
935	&boot_params_40,
936	sizeof(struct bootup_params));
937	rsi_dbg(MGMT_TX_ZONE, fmt: "%s: Packet 40MHZ <=== %d\n", __func__,
938	UMAC_CLK_40BW);
939	boot_params->desc_word[7] = cpu_to_le16(UMAC_CLK_40BW);
940	} else {
941	memcpy(&boot_params->bootup_params,
942	&boot_params_20,
943	sizeof(struct bootup_params));
944	if (boot_params_20.valid != cpu_to_le32(VALID_20)) {
945	boot_params->desc_word[7] = cpu_to_le16(UMAC_CLK_20BW);
946	rsi_dbg(MGMT_TX_ZONE,
947	fmt: "%s: Packet 20MHZ <=== %d\n", __func__,
948	UMAC_CLK_20BW);
949	} else {
950	boot_params->desc_word[7] = cpu_to_le16(UMAC_CLK_40MHZ);
951	rsi_dbg(MGMT_TX_ZONE,
952	fmt: "%s: Packet 20MHZ <=== %d\n", __func__,
953	UMAC_CLK_40MHZ);
954	}
955	}
956
957	/**
958	* Bit{0:11} indicates length of the Packet
959	* Bit{12:15} indicates host queue number
960	*/
961	boot_params->desc_word[0] = cpu_to_le16(sizeof(struct bootup_params) |
962	(RSI_WIFI_MGMT_Q << 12));
963	boot_params->desc_word[1] = cpu_to_le16(BOOTUP_PARAMS_REQUEST);
964
965	skb_put(skb, len: sizeof(struct rsi_boot_params));
966
967	return rsi_send_internal_mgmt_frame(common, skb);
968	}
969
970	static int rsi_load_9116_bootup_params(struct rsi_common *common)
971	{
972	struct sk_buff *skb;
973	struct rsi_boot_params_9116 *boot_params;
974
975	rsi_dbg(MGMT_TX_ZONE, fmt: "%s: Sending boot params frame\n", __func__);
976
977	skb = dev_alloc_skb(length: sizeof(struct rsi_boot_params_9116));
978	if (!skb)
979	return -ENOMEM;
980	memset(skb->data, 0, sizeof(struct rsi_boot_params));
981	boot_params = (struct rsi_boot_params_9116 *)skb->data;
982
983	if (common->channel_width == BW_40MHZ) {
984	memcpy(&boot_params->bootup_params,
985	&boot_params_9116_40,
986	sizeof(struct bootup_params_9116));
987	rsi_dbg(MGMT_TX_ZONE, fmt: "%s: Packet 40MHZ <=== %d\n", __func__,
988	UMAC_CLK_40BW);
989	boot_params->umac_clk = cpu_to_le16(UMAC_CLK_40BW);
990	} else {
991	memcpy(&boot_params->bootup_params,
992	&boot_params_9116_20,
993	sizeof(struct bootup_params_9116));
994	if (boot_params_20.valid != cpu_to_le32(VALID_20)) {
995	boot_params->umac_clk = cpu_to_le16(UMAC_CLK_20BW);
996	rsi_dbg(MGMT_TX_ZONE,
997	fmt: "%s: Packet 20MHZ <=== %d\n", __func__,
998	UMAC_CLK_20BW);
999	} else {
1000	boot_params->umac_clk = cpu_to_le16(UMAC_CLK_40MHZ);
1001	rsi_dbg(MGMT_TX_ZONE,
1002	fmt: "%s: Packet 20MHZ <=== %d\n", __func__,
1003	UMAC_CLK_40MHZ);
1004	}
1005	}
1006	rsi_set_len_qno(addr: &boot_params->desc_dword0.len_qno,
1007	len: sizeof(struct bootup_params_9116), RSI_WIFI_MGMT_Q);
1008	boot_params->desc_dword0.frame_type = BOOTUP_PARAMS_REQUEST;
1009	skb_put(skb, len: sizeof(struct rsi_boot_params_9116));
1010
1011	return rsi_send_internal_mgmt_frame(common, skb);
1012	}
1013
1014	/**
1015	* rsi_send_reset_mac() - This function prepares reset MAC request and sends an
1016	* internal management frame to indicate it to firmware.
1017	* @common: Pointer to the driver private structure.
1018	*
1019	* Return: 0 on success, corresponding error code on failure.
1020	*/
1021	static int rsi_send_reset_mac(struct rsi_common *common)
1022	{
1023	struct sk_buff *skb;
1024	struct rsi_mac_frame *mgmt_frame;
1025
1026	rsi_dbg(MGMT_TX_ZONE, fmt: "%s: Sending reset MAC frame\n", __func__);
1027
1028	skb = dev_alloc_skb(FRAME_DESC_SZ);
1029	if (!skb) {
1030	rsi_dbg(ERR_ZONE, fmt: "%s: Failed in allocation of skb\n",
1031	__func__);
1032	return -ENOMEM;
1033	}
1034
1035	memset(skb->data, 0, FRAME_DESC_SZ);
1036	mgmt_frame = (struct rsi_mac_frame *)skb->data;
1037
1038	mgmt_frame->desc_word[0] = cpu_to_le16(RSI_WIFI_MGMT_Q << 12);
1039	mgmt_frame->desc_word[1] = cpu_to_le16(RESET_MAC_REQ);
1040	mgmt_frame->desc_word[4] = cpu_to_le16(RETRY_COUNT << 8);
1041
1042	#define RSI_9116_DEF_TA_AGGR 3
1043	if (common->priv->device_model == RSI_DEV_9116)
1044	mgmt_frame->desc_word[3] |=
1045	cpu_to_le16(RSI_9116_DEF_TA_AGGR << 8);
1046
1047	skb_put(skb, FRAME_DESC_SZ);
1048
1049	return rsi_send_internal_mgmt_frame(common, skb);
1050	}
1051
1052	/**
1053	* rsi_band_check() - This function programs the band
1054	* @common: Pointer to the driver private structure.
1055	* @curchan: Pointer to the current channel structure.
1056	*
1057	* Return: 0 on success, corresponding error code on failure.
1058	*/
1059	int rsi_band_check(struct rsi_common *common,
1060	struct ieee80211_channel *curchan)
1061	{
1062	struct rsi_hw *adapter = common->priv;
1063	struct ieee80211_hw *hw = adapter->hw;
1064	u8 prev_bw = common->channel_width;
1065	u8 prev_ep = common->endpoint;
1066	int status = 0;
1067
1068	if (common->band != curchan->band) {
1069	common->rf_reset = 1;
1070	common->band = curchan->band;
1071	}
1072
1073	if ((hw->conf.chandef.width == NL80211_CHAN_WIDTH_20_NOHT) ||
1074	(hw->conf.chandef.width == NL80211_CHAN_WIDTH_20))
1075	common->channel_width = BW_20MHZ;
1076	else
1077	common->channel_width = BW_40MHZ;
1078
1079	if (common->band == NL80211_BAND_2GHZ) {
1080	if (common->channel_width)
1081	common->endpoint = EP_2GHZ_40MHZ;
1082	else
1083	common->endpoint = EP_2GHZ_20MHZ;
1084	} else {
1085	if (common->channel_width)
1086	common->endpoint = EP_5GHZ_40MHZ;
1087	else
1088	common->endpoint = EP_5GHZ_20MHZ;
1089	}
1090
1091	if (common->endpoint != prev_ep) {
1092	status = rsi_program_bb_rf(common);
1093	if (status)
1094	return status;
1095	}
1096
1097	if (common->channel_width != prev_bw) {
1098	if (adapter->device_model == RSI_DEV_9116)
1099	status = rsi_load_9116_bootup_params(common);
1100	else
1101	status = rsi_load_bootup_params(common);
1102	if (status)
1103	return status;
1104
1105	status = rsi_load_radio_caps(common);
1106	if (status)
1107	return status;
1108	}
1109
1110	return status;
1111	}
1112
1113	/**
1114	* rsi_set_channel() - This function programs the channel.
1115	* @common: Pointer to the driver private structure.
1116	* @channel: Channel value to be set.
1117	*
1118	* Return: 0 on success, corresponding error code on failure.
1119	*/
1120	int rsi_set_channel(struct rsi_common *common,
1121	struct ieee80211_channel *channel)
1122	{
1123	struct sk_buff *skb = NULL;
1124	struct rsi_chan_config *chan_cfg;
1125	u16 frame_len = sizeof(struct rsi_chan_config);
1126
1127	rsi_dbg(MGMT_TX_ZONE,
1128	fmt: "%s: Sending scan req frame\n", __func__);
1129
1130	if (!channel)
1131	return 0;
1132
1133	skb = dev_alloc_skb(length: frame_len);
1134	if (!skb) {
1135	rsi_dbg(ERR_ZONE, fmt: "%s: Failed in allocation of skb\n",
1136	__func__);
1137	return -ENOMEM;
1138	}
1139
1140	memset(skb->data, 0, frame_len);
1141	chan_cfg = (struct rsi_chan_config *)skb->data;
1142
1143	rsi_set_len_qno(addr: &chan_cfg->desc_dword0.len_qno, len: 0, RSI_WIFI_MGMT_Q);
1144	chan_cfg->desc_dword0.frame_type = SCAN_REQUEST;
1145	chan_cfg->channel_number = channel->hw_value;
1146	chan_cfg->antenna_gain_offset_2g = channel->max_antenna_gain;
1147	chan_cfg->antenna_gain_offset_5g = channel->max_antenna_gain;
1148	chan_cfg->region_rftype = (RSI_RF_TYPE & 0xf) << 4;
1149
1150	if ((channel->flags & IEEE80211_CHAN_NO_IR) ||
1151	(channel->flags & IEEE80211_CHAN_RADAR)) {
1152	chan_cfg->antenna_gain_offset_2g |= RSI_CHAN_RADAR;
1153	} else {
1154	if (common->tx_power < channel->max_power)
1155	chan_cfg->tx_power = cpu_to_le16(common->tx_power);
1156	else
1157	chan_cfg->tx_power = cpu_to_le16(channel->max_power);
1158	}
1159	chan_cfg->region_rftype |= (common->priv->dfs_region & 0xf);
1160
1161	if (common->channel_width == BW_40MHZ)
1162	chan_cfg->channel_width = 0x1;
1163
1164	common->channel = channel->hw_value;
1165
1166	skb_put(skb, len: frame_len);
1167
1168	return rsi_send_internal_mgmt_frame(common, skb);
1169	}
1170
1171	/**
1172	* rsi_send_radio_params_update() - This function sends the radio
1173	* parameters update to device
1174	* @common: Pointer to the driver private structure.
1175	*
1176	* Return: 0 on success, corresponding error code on failure.
1177	*/
1178	int rsi_send_radio_params_update(struct rsi_common *common)
1179	{
1180	struct rsi_mac_frame *cmd_frame;
1181	struct sk_buff *skb = NULL;
1182
1183	rsi_dbg(MGMT_TX_ZONE,
1184	fmt: "%s: Sending Radio Params update frame\n", __func__);
1185
1186	skb = dev_alloc_skb(FRAME_DESC_SZ);
1187	if (!skb) {
1188	rsi_dbg(ERR_ZONE, fmt: "%s: Failed in allocation of skb\n",
1189	__func__);
1190	return -ENOMEM;
1191	}
1192
1193	memset(skb->data, 0, FRAME_DESC_SZ);
1194	cmd_frame = (struct rsi_mac_frame *)skb->data;
1195
1196	cmd_frame->desc_word[0] = cpu_to_le16(RSI_WIFI_MGMT_Q << 12);
1197	cmd_frame->desc_word[1] = cpu_to_le16(RADIO_PARAMS_UPDATE);
1198	cmd_frame->desc_word[3] = cpu_to_le16(BIT(0));
1199
1200	cmd_frame->desc_word[3] |= cpu_to_le16(common->tx_power << 8);
1201
1202	skb_put(skb, FRAME_DESC_SZ);
1203
1204	return rsi_send_internal_mgmt_frame(common, skb);
1205	}
1206
1207	/* This function programs the threshold. */
1208	int rsi_send_vap_dynamic_update(struct rsi_common *common)
1209	{
1210	struct sk_buff *skb;
1211	struct rsi_dynamic_s *dynamic_frame;
1212
1213	rsi_dbg(MGMT_TX_ZONE,
1214	fmt: "%s: Sending vap update indication frame\n", __func__);
1215
1216	skb = dev_alloc_skb(length: sizeof(struct rsi_dynamic_s));
1217	if (!skb)
1218	return -ENOMEM;
1219
1220	memset(skb->data, 0, sizeof(struct rsi_dynamic_s));
1221	dynamic_frame = (struct rsi_dynamic_s *)skb->data;
1222	rsi_set_len_qno(addr: &dynamic_frame->desc_dword0.len_qno,
1223	len: sizeof(dynamic_frame->frame_body), RSI_WIFI_MGMT_Q);
1224
1225	dynamic_frame->desc_dword0.frame_type = VAP_DYNAMIC_UPDATE;
1226	dynamic_frame->desc_dword2.pkt_info =
1227	cpu_to_le32(common->rts_threshold);
1228
1229	if (common->wow_flags & RSI_WOW_ENABLED) {
1230	/* Beacon miss threshold */
1231	dynamic_frame->desc_dword3.token =
1232	cpu_to_le16(RSI_BCN_MISS_THRESHOLD);
1233	dynamic_frame->frame_body.keep_alive_period =
1234	cpu_to_le16(RSI_WOW_KEEPALIVE);
1235	} else {
1236	dynamic_frame->frame_body.keep_alive_period =
1237	cpu_to_le16(RSI_DEF_KEEPALIVE);
1238	}
1239
1240	dynamic_frame->desc_dword3.sta_id = 0; /* vap id */
1241
1242	skb_put(skb, len: sizeof(struct rsi_dynamic_s));
1243
1244	return rsi_send_internal_mgmt_frame(common, skb);
1245	}
1246
1247	/**
1248	* rsi_compare() - This function is used to compare two integers
1249	* @a: pointer to the first integer
1250	* @b: pointer to the second integer
1251	*
1252	* Return: 0 if both are equal, -1 if the first is smaller, else 1
1253	*/
1254	static int rsi_compare(const void *a, const void *b)
1255	{
1256	u16 _a = *(const u16 *)(a);
1257	u16 _b = *(const u16 *)(b);
1258
1259	if (_a > _b)
1260	return -1;
1261
1262	if (_a < _b)
1263	return 1;
1264
1265	return 0;
1266	}
1267
1268	/**
1269	* rsi_map_rates() - This function is used to map selected rates to hw rates.
1270	* @rate: The standard rate to be mapped.
1271	* @offset: Offset that will be returned.
1272	*
1273	* Return: 0 if it is a mcs rate, else 1
1274	*/
1275	static bool rsi_map_rates(u16 rate, int *offset)
1276	{
1277	int kk;
1278	for (kk = 0; kk < ARRAY_SIZE(rsi_mcsrates); kk++) {
1279	if (rate == mcs[kk]) {
1280	*offset = kk;
1281	return false;
1282	}
1283	}
1284
1285	for (kk = 0; kk < ARRAY_SIZE(rsi_rates); kk++) {
1286	if (rate == rsi_rates[kk].bitrate / 5) {
1287	*offset = kk;
1288	break;
1289	}
1290	}
1291	return true;
1292	}
1293
1294	/**
1295	* rsi_send_auto_rate_request() - This function is to set rates for connection
1296	* and send autorate request to firmware.
1297	* @common: Pointer to the driver private structure.
1298	* @sta: mac80211 station.
1299	* @sta_id: station id.
1300	* @vif: Pointer to the ieee80211_vif structure.
1301	*
1302	* Return: 0 on success, corresponding error code on failure.
1303	*/
1304	static int rsi_send_auto_rate_request(struct rsi_common *common,
1305	struct ieee80211_sta *sta,
1306	u16 sta_id,
1307	struct ieee80211_vif *vif)
1308	{
1309	struct sk_buff *skb;
1310	struct rsi_auto_rate *auto_rate;
1311	int ii = 0, jj = 0, kk = 0;
1312	struct ieee80211_hw *hw = common->priv->hw;
1313	u8 band = hw->conf.chandef.chan->band;
1314	u8 num_supported_rates = 0;
1315	u8 rate_table_offset, rate_offset = 0;
1316	u32 rate_bitmap, configured_rates;
1317	u16 *selected_rates, min_rate;
1318	bool is_ht = false, is_sgi = false;
1319	u16 frame_len = sizeof(struct rsi_auto_rate);
1320
1321	rsi_dbg(MGMT_TX_ZONE,
1322	fmt: "%s: Sending auto rate request frame\n", __func__);
1323
1324	skb = dev_alloc_skb(length: frame_len);
1325	if (!skb) {
1326	rsi_dbg(ERR_ZONE, fmt: "%s: Failed in allocation of skb\n",
1327	__func__);
1328	return -ENOMEM;
1329	}
1330
1331	memset(skb->data, 0, frame_len);
1332	selected_rates = kzalloc(size: 2 * RSI_TBL_SZ, GFP_KERNEL);
1333	if (!selected_rates) {
1334	rsi_dbg(ERR_ZONE, fmt: "%s: Failed in allocation of mem\n",
1335	__func__);
1336	dev_kfree_skb(skb);
1337	return -ENOMEM;
1338	}
1339
1340	auto_rate = (struct rsi_auto_rate *)skb->data;
1341
1342	auto_rate->aarf_rssi = cpu_to_le16(((u16)3 << 6) | (u16)(18 & 0x3f));
1343	auto_rate->collision_tolerance = cpu_to_le16(3);
1344	auto_rate->failure_limit = cpu_to_le16(3);
1345	auto_rate->initial_boundary = cpu_to_le16(3);
1346	auto_rate->max_threshold_limt = cpu_to_le16(27);
1347
1348	auto_rate->desc.desc_dword0.frame_type = AUTO_RATE_IND;
1349
1350	if (common->channel_width == BW_40MHZ)
1351	auto_rate->desc.desc_dword3.qid_tid = BW_40MHZ;
1352	auto_rate->desc.desc_dword3.sta_id = sta_id;
1353
1354	if (vif->type == NL80211_IFTYPE_STATION) {
1355	rate_bitmap = common->bitrate_mask[band];
1356	is_ht = common->vif_info[0].is_ht;
1357	is_sgi = common->vif_info[0].sgi;
1358	} else {
1359	rate_bitmap = sta->deflink.supp_rates[band];
1360	is_ht = sta->deflink.ht_cap.ht_supported;
1361	if ((sta->deflink.ht_cap.cap & IEEE80211_HT_CAP_SGI_20) ||
1362	(sta->deflink.ht_cap.cap & IEEE80211_HT_CAP_SGI_40))
1363	is_sgi = true;
1364	}
1365
1366	/* Limit to any rates administratively configured by cfg80211 */
1367	configured_rates = common->rate_config[band].configured_mask ?: 0xffffffff;
1368	rate_bitmap &= configured_rates;
1369
1370	if (band == NL80211_BAND_2GHZ) {
1371	if ((rate_bitmap == 0) && (is_ht))
1372	min_rate = RSI_RATE_MCS0;
1373	else
1374	min_rate = RSI_RATE_1;
1375	rate_table_offset = 0;
1376	} else {
1377	if ((rate_bitmap == 0) && (is_ht))
1378	min_rate = RSI_RATE_MCS0;
1379	else
1380	min_rate = RSI_RATE_6;
1381	rate_table_offset = 4;
1382	}
1383
1384	for (ii = 0, jj = 0;
1385	ii < (ARRAY_SIZE(rsi_rates) - rate_table_offset); ii++) {
1386	if (rate_bitmap & BIT(ii)) {
1387	selected_rates[jj++] =
1388	(rsi_rates[ii + rate_table_offset].bitrate / 5);
1389	rate_offset++;
1390	}
1391	}
1392	num_supported_rates = jj;
1393
1394	if (is_ht) {
1395	for (ii = 0; ii < ARRAY_SIZE(mcs); ii++) {
1396	if (configured_rates & BIT(ii + ARRAY_SIZE(rsi_rates))) {
1397	selected_rates[jj++] = mcs[ii];
1398	num_supported_rates++;
1399	rate_offset++;
1400	}
1401	}
1402	}
1403
1404	sort(base: selected_rates, num: jj, size: sizeof(u16), cmp_func: &rsi_compare, NULL);
1405
1406	/* mapping the rates to RSI rates */
1407	for (ii = 0; ii < jj; ii++) {
1408	if (rsi_map_rates(rate: selected_rates[ii], offset: &kk)) {
1409	auto_rate->supported_rates[ii] =
1410	cpu_to_le16(rsi_rates[kk].hw_value);
1411	} else {
1412	auto_rate->supported_rates[ii] =
1413	cpu_to_le16(rsi_mcsrates[kk]);
1414	}
1415	}
1416
1417	/* loading HT rates in the bottom half of the auto rate table */
1418	if (is_ht) {
1419	for (ii = rate_offset, kk = ARRAY_SIZE(rsi_mcsrates) - 1;
1420	ii < rate_offset + 2 * ARRAY_SIZE(rsi_mcsrates); ii++) {
1421	if (is_sgi || conf_is_ht40(conf: &common->priv->hw->conf))
1422	auto_rate->supported_rates[ii++] =
1423	cpu_to_le16(rsi_mcsrates[kk] | BIT(9));
1424	else
1425	auto_rate->supported_rates[ii++] =
1426	cpu_to_le16(rsi_mcsrates[kk]);
1427	auto_rate->supported_rates[ii] =
1428	cpu_to_le16(rsi_mcsrates[kk--]);
1429	}
1430
1431	for (; ii < (RSI_TBL_SZ - 1); ii++) {
1432	auto_rate->supported_rates[ii] =
1433	cpu_to_le16(rsi_mcsrates[0]);
1434	}
1435	}
1436
1437	for (; ii < RSI_TBL_SZ; ii++)
1438	auto_rate->supported_rates[ii] = cpu_to_le16(min_rate);
1439
1440	auto_rate->num_supported_rates = cpu_to_le16(num_supported_rates * 2);
1441	auto_rate->moderate_rate_inx = cpu_to_le16(num_supported_rates / 2);
1442	num_supported_rates *= 2;
1443
1444	rsi_set_len_qno(addr: &auto_rate->desc.desc_dword0.len_qno,
1445	len: (frame_len - FRAME_DESC_SZ), RSI_WIFI_MGMT_Q);
1446
1447	skb_put(skb, len: frame_len);
1448	kfree(objp: selected_rates);
1449
1450	return rsi_send_internal_mgmt_frame(common, skb);
1451	}
1452
1453	/**
1454	* rsi_inform_bss_status() - This function informs about bss status with the
1455	* help of sta notify params by sending an internal
1456	* management frame to firmware.
1457	* @common: Pointer to the driver private structure.
1458	* @opmode: Operating mode of device.
1459	* @status: Bss status type.
1460	* @addr: Address of the register.
1461	* @qos_enable: Qos is enabled.
1462	* @aid: Aid (unique for all STAs).
1463	* @sta: mac80211 station.
1464	* @sta_id: station id.
1465	* @assoc_cap: capabilities.
1466	* @vif: Pointer to the ieee80211_vif structure.
1467	*
1468	* Return: None.
1469	*/
1470	void rsi_inform_bss_status(struct rsi_common *common,
1471	enum opmode opmode,
1472	u8 status,
1473	const u8 *addr,
1474	u8 qos_enable,
1475	u16 aid,
1476	struct ieee80211_sta *sta,
1477	u16 sta_id,
1478	u16 assoc_cap,
1479	struct ieee80211_vif *vif)
1480	{
1481	if (status) {
1482	if (opmode == RSI_OPMODE_STA)
1483	common->hw_data_qs_blocked = true;
1484	rsi_hal_send_sta_notify_frame(common,
1485	opmode,
1486	notify_event: STA_CONNECTED,
1487	bssid: addr,
1488	qos_enable,
1489	aid, sta_id,
1490	vif);
1491	if (!common->rate_config[common->band].fixed_enabled)
1492	rsi_send_auto_rate_request(common, sta, sta_id, vif);
1493	if (opmode == RSI_OPMODE_STA &&
1494	!(assoc_cap & WLAN_CAPABILITY_PRIVACY) &&
1495	!rsi_send_block_unblock_frame(common, event: false))
1496	common->hw_data_qs_blocked = false;
1497	} else {
1498	if (opmode == RSI_OPMODE_STA)
1499	common->hw_data_qs_blocked = true;
1500
1501	if (!(common->wow_flags & RSI_WOW_ENABLED))
1502	rsi_hal_send_sta_notify_frame(common, opmode,
1503	notify_event: STA_DISCONNECTED, bssid: addr,
1504	qos_enable, aid, sta_id,
1505	vif);
1506	if (opmode == RSI_OPMODE_STA)
1507	rsi_send_block_unblock_frame(common, event: true);
1508	}
1509	}
1510
1511	/**
1512	* rsi_eeprom_read() - This function sends a frame to read the mac address
1513	* from the eeprom.
1514	* @common: Pointer to the driver private structure.
1515	*
1516	* Return: 0 on success, -1 on failure.
1517	*/
1518	static int rsi_eeprom_read(struct rsi_common *common)
1519	{
1520	struct rsi_eeprom_read_frame *mgmt_frame;
1521	struct rsi_hw *adapter = common->priv;
1522	struct sk_buff *skb;
1523
1524	rsi_dbg(MGMT_TX_ZONE, fmt: "%s: Sending EEPROM read req frame\n", __func__);
1525
1526	skb = dev_alloc_skb(FRAME_DESC_SZ);
1527	if (!skb) {
1528	rsi_dbg(ERR_ZONE, fmt: "%s: Failed in allocation of skb\n",
1529	__func__);
1530	return -ENOMEM;
1531	}
1532
1533	memset(skb->data, 0, FRAME_DESC_SZ);
1534	mgmt_frame = (struct rsi_eeprom_read_frame *)skb->data;
1535
1536	/* FrameType */
1537	rsi_set_len_qno(addr: &mgmt_frame->len_qno, len: 0, RSI_WIFI_MGMT_Q);
1538	mgmt_frame->pkt_type = EEPROM_READ;
1539
1540	/* Number of bytes to read */
1541	mgmt_frame->pkt_info =
1542	cpu_to_le32((adapter->eeprom.length << RSI_EEPROM_LEN_OFFSET) &
1543	RSI_EEPROM_LEN_MASK);
1544	mgmt_frame->pkt_info |= cpu_to_le32((3 << RSI_EEPROM_HDR_SIZE_OFFSET) &
1545	RSI_EEPROM_HDR_SIZE_MASK);
1546
1547	/* Address to read */
1548	mgmt_frame->eeprom_offset = cpu_to_le32(adapter->eeprom.offset);
1549
1550	skb_put(skb, FRAME_DESC_SZ);
1551
1552	return rsi_send_internal_mgmt_frame(common, skb);
1553	}
1554
1555	/**
1556	* rsi_send_block_unblock_frame() - This function sends a frame to block/unblock
1557	* data queues in the firmware
1558	*
1559	* @common: Pointer to the driver private structure.
1560	* @block_event: Event block if true, unblock if false
1561	* returns 0 on success, -1 on failure.
1562	*/
1563	int rsi_send_block_unblock_frame(struct rsi_common *common, bool block_event)
1564	{
1565	struct rsi_block_unblock_data *mgmt_frame;
1566	struct sk_buff *skb;
1567
1568	rsi_dbg(MGMT_TX_ZONE, fmt: "%s: Sending block/unblock frame\n", __func__);
1569
1570	skb = dev_alloc_skb(FRAME_DESC_SZ);
1571	if (!skb) {
1572	rsi_dbg(ERR_ZONE, fmt: "%s: Failed in allocation of skb\n",
1573	__func__);
1574	return -ENOMEM;
1575	}
1576
1577	memset(skb->data, 0, FRAME_DESC_SZ);
1578	mgmt_frame = (struct rsi_block_unblock_data *)skb->data;
1579
1580	rsi_set_len_qno(addr: &mgmt_frame->desc_dword0.len_qno, len: 0, RSI_WIFI_MGMT_Q);
1581	mgmt_frame->desc_dword0.frame_type = BLOCK_HW_QUEUE;
1582	mgmt_frame->host_quiet_info = QUIET_INFO_VALID;
1583
1584	if (block_event) {
1585	rsi_dbg(INFO_ZONE, fmt: "blocking the data qs\n");
1586	mgmt_frame->block_q_bitmap = cpu_to_le16(0xf);
1587	mgmt_frame->block_q_bitmap |= cpu_to_le16(0xf << 4);
1588	} else {
1589	rsi_dbg(INFO_ZONE, fmt: "unblocking the data qs\n");
1590	mgmt_frame->unblock_q_bitmap = cpu_to_le16(0xf);
1591	mgmt_frame->unblock_q_bitmap |= cpu_to_le16(0xf << 4);
1592	}
1593
1594	skb_put(skb, FRAME_DESC_SZ);
1595
1596	return rsi_send_internal_mgmt_frame(common, skb);
1597	}
1598
1599	/**
1600	* rsi_send_rx_filter_frame() - Sends a frame to filter the RX packets
1601	*
1602	* @common: Pointer to the driver private structure.
1603	* @rx_filter_word: Flags of filter packets
1604	*
1605	* Returns 0 on success, -1 on failure.
1606	*/
1607	int rsi_send_rx_filter_frame(struct rsi_common *common, u16 rx_filter_word)
1608	{
1609	struct rsi_mac_frame *cmd_frame;
1610	struct sk_buff *skb;
1611
1612	rsi_dbg(MGMT_TX_ZONE, fmt: "Sending RX filter frame\n");
1613
1614	skb = dev_alloc_skb(FRAME_DESC_SZ);
1615	if (!skb) {
1616	rsi_dbg(ERR_ZONE, fmt: "%s: Failed in allocation of skb\n",
1617	__func__);
1618	return -ENOMEM;
1619	}
1620
1621	memset(skb->data, 0, FRAME_DESC_SZ);
1622	cmd_frame = (struct rsi_mac_frame *)skb->data;
1623
1624	cmd_frame->desc_word[0] = cpu_to_le16(RSI_WIFI_MGMT_Q << 12);
1625	cmd_frame->desc_word[1] = cpu_to_le16(SET_RX_FILTER);
1626	cmd_frame->desc_word[4] = cpu_to_le16(rx_filter_word);
1627
1628	skb_put(skb, FRAME_DESC_SZ);
1629
1630	return rsi_send_internal_mgmt_frame(common, skb);
1631	}
1632
1633	int rsi_send_ps_request(struct rsi_hw *adapter, bool enable,
1634	struct ieee80211_vif *vif)
1635	{
1636	struct rsi_common *common = adapter->priv;
1637	struct rsi_request_ps *ps;
1638	struct rsi_ps_info *ps_info;
1639	struct sk_buff *skb;
1640	int frame_len = sizeof(*ps);
1641
1642	skb = dev_alloc_skb(length: frame_len);
1643	if (!skb)
1644	return -ENOMEM;
1645	memset(skb->data, 0, frame_len);
1646
1647	ps = (struct rsi_request_ps *)skb->data;
1648	ps_info = &adapter->ps_info;
1649
1650	rsi_set_len_qno(addr: &ps->desc.desc_dword0.len_qno,
1651	len: (frame_len - FRAME_DESC_SZ), RSI_WIFI_MGMT_Q);
1652	ps->desc.desc_dword0.frame_type = WAKEUP_SLEEP_REQUEST;
1653	if (enable) {
1654	ps->ps_sleep.enable = RSI_PS_ENABLE;
1655	ps->desc.desc_dword3.token = cpu_to_le16(RSI_SLEEP_REQUEST);
1656	} else {
1657	ps->ps_sleep.enable = RSI_PS_DISABLE;
1658	ps->desc.desc_dword0.len_qno |= cpu_to_le16(RSI_PS_DISABLE_IND);
1659	ps->desc.desc_dword3.token = cpu_to_le16(RSI_WAKEUP_REQUEST);
1660	}
1661
1662	ps->ps_uapsd_acs = common->uapsd_bitmap;
1663
1664	ps->ps_sleep.sleep_type = ps_info->sleep_type;
1665	ps->ps_sleep.num_bcns_per_lis_int =
1666	cpu_to_le16(ps_info->num_bcns_per_lis_int);
1667	ps->ps_sleep.sleep_duration =
1668	cpu_to_le32(ps_info->deep_sleep_wakeup_period);
1669
1670	if (vif->cfg.assoc)
1671	ps->ps_sleep.connected_sleep = RSI_CONNECTED_SLEEP;
1672	else
1673	ps->ps_sleep.connected_sleep = RSI_DEEP_SLEEP;
1674
1675	ps->ps_listen_interval = cpu_to_le32(ps_info->listen_interval);
1676	ps->ps_dtim_interval_duration =
1677	cpu_to_le32(ps_info->dtim_interval_duration);
1678
1679	if (ps_info->listen_interval > ps_info->dtim_interval_duration)
1680	ps->ps_listen_interval = cpu_to_le32(RSI_PS_DISABLE);
1681
1682	ps->ps_num_dtim_intervals = cpu_to_le16(ps_info->num_dtims_per_sleep);
1683	skb_put(skb, len: frame_len);
1684
1685	return rsi_send_internal_mgmt_frame(common, skb);
1686	}
1687
1688	static int rsi_send_w9116_features(struct rsi_common *common)
1689	{
1690	struct rsi_wlan_9116_features *w9116_features;
1691	u16 frame_len = sizeof(struct rsi_wlan_9116_features);
1692	struct sk_buff *skb;
1693
1694	rsi_dbg(MGMT_TX_ZONE,
1695	fmt: "%s: Sending wlan 9116 features\n", __func__);
1696
1697	skb = dev_alloc_skb(length: frame_len);
1698	if (!skb)
1699	return -ENOMEM;
1700	memset(skb->data, 0, frame_len);
1701
1702	w9116_features = (struct rsi_wlan_9116_features *)skb->data;
1703
1704	w9116_features->pll_mode = common->w9116_features.pll_mode;
1705	w9116_features->rf_type = common->w9116_features.rf_type;
1706	w9116_features->wireless_mode = common->w9116_features.wireless_mode;
1707	w9116_features->enable_ppe = common->w9116_features.enable_ppe;
1708	w9116_features->afe_type = common->w9116_features.afe_type;
1709	if (common->w9116_features.dpd)
1710	w9116_features->feature_enable |= cpu_to_le32(RSI_DPD);
1711	if (common->w9116_features.sifs_tx_enable)
1712	w9116_features->feature_enable |=
1713	cpu_to_le32(RSI_SIFS_TX_ENABLE);
1714	if (common->w9116_features.ps_options & RSI_DUTY_CYCLING)
1715	w9116_features->feature_enable |= cpu_to_le32(RSI_DUTY_CYCLING);
1716	if (common->w9116_features.ps_options & RSI_END_OF_FRAME)
1717	w9116_features->feature_enable |= cpu_to_le32(RSI_END_OF_FRAME);
1718	w9116_features->feature_enable |=
1719	cpu_to_le32((common->w9116_features.ps_options & ~0x3) << 2);
1720
1721	rsi_set_len_qno(addr: &w9116_features->desc.desc_dword0.len_qno,
1722	len: frame_len - FRAME_DESC_SZ, RSI_WIFI_MGMT_Q);
1723	w9116_features->desc.desc_dword0.frame_type = FEATURES_ENABLE;
1724	skb_put(skb, len: frame_len);
1725
1726	return rsi_send_internal_mgmt_frame(common, skb);
1727	}
1728
1729	/**
1730	* rsi_set_antenna() - This function send antenna configuration request
1731	* to device
1732	*
1733	* @common: Pointer to the driver private structure.
1734	* @antenna: bitmap for tx antenna selection
1735	*
1736	* Return: 0 on Success, negative error code on failure
1737	*/
1738	int rsi_set_antenna(struct rsi_common *common, u8 antenna)
1739	{
1740	struct rsi_ant_sel_frame *ant_sel_frame;
1741	struct sk_buff *skb;
1742
1743	skb = dev_alloc_skb(FRAME_DESC_SZ);
1744	if (!skb) {
1745	rsi_dbg(ERR_ZONE, fmt: "%s: Failed in allocation of skb\n",
1746	__func__);
1747	return -ENOMEM;
1748	}
1749
1750	memset(skb->data, 0, FRAME_DESC_SZ);
1751
1752	ant_sel_frame = (struct rsi_ant_sel_frame *)skb->data;
1753	ant_sel_frame->desc_dword0.frame_type = ANT_SEL_FRAME;
1754	ant_sel_frame->sub_frame_type = ANTENNA_SEL_TYPE;
1755	ant_sel_frame->ant_value = cpu_to_le16(antenna & ANTENNA_MASK_VALUE);
1756	rsi_set_len_qno(addr: &ant_sel_frame->desc_dword0.len_qno,
1757	len: 0, RSI_WIFI_MGMT_Q);
1758	skb_put(skb, FRAME_DESC_SZ);
1759
1760	return rsi_send_internal_mgmt_frame(common, skb);
1761	}
1762
1763	static int rsi_send_beacon(struct rsi_common *common)
1764	{
1765	struct sk_buff *skb = NULL;
1766	u8 dword_align_bytes = 0;
1767
1768	skb = dev_alloc_skb(MAX_MGMT_PKT_SIZE);
1769	if (!skb)
1770	return -ENOMEM;
1771
1772	memset(skb->data, 0, MAX_MGMT_PKT_SIZE);
1773
1774	dword_align_bytes = ((unsigned long)skb->data & 0x3f);
1775	if (dword_align_bytes)
1776	skb_pull(skb, len: (64 - dword_align_bytes));
1777	if (rsi_prepare_beacon(common, skb)) {
1778	rsi_dbg(ERR_ZONE, fmt: "Failed to prepare beacon\n");
1779	dev_kfree_skb(skb);
1780	return -EINVAL;
1781	}
1782	skb_queue_tail(list: &common->tx_queue[MGMT_BEACON_Q], newsk: skb);
1783	rsi_set_event(event: &common->tx_thread.event);
1784	rsi_dbg(DATA_TX_ZONE, fmt: "%s: Added to beacon queue\n", __func__);
1785
1786	return 0;
1787	}
1788
1789	#ifdef CONFIG_PM
1790	int rsi_send_wowlan_request(struct rsi_common *common, u16 flags,
1791	u16 sleep_status)
1792	{
1793	struct rsi_wowlan_req *cmd_frame;
1794	struct sk_buff *skb;
1795	u8 length;
1796
1797	rsi_dbg(ERR_ZONE, fmt: "%s: Sending wowlan request frame\n", __func__);
1798
1799	length = sizeof(*cmd_frame);
1800	skb = dev_alloc_skb(length);
1801	if (!skb)
1802	return -ENOMEM;
1803	memset(skb->data, 0, length);
1804	cmd_frame = (struct rsi_wowlan_req *)skb->data;
1805
1806	rsi_set_len_qno(addr: &cmd_frame->desc.desc_dword0.len_qno,
1807	len: (length - FRAME_DESC_SZ),
1808	RSI_WIFI_MGMT_Q);
1809	cmd_frame->desc.desc_dword0.frame_type = WOWLAN_CONFIG_PARAMS;
1810	cmd_frame->host_sleep_status = sleep_status;
1811	if (common->secinfo.gtk_cipher)
1812	flags |= RSI_WOW_GTK_REKEY;
1813	if (sleep_status)
1814	cmd_frame->wow_flags = flags;
1815	rsi_dbg(INFO_ZONE, fmt: "Host_Sleep_Status : %d Flags : %d\n",
1816	cmd_frame->host_sleep_status, cmd_frame->wow_flags);
1817
1818	skb_put(skb, len: length);
1819
1820	return rsi_send_internal_mgmt_frame(common, skb);
1821	}
1822	#endif
1823
1824	int rsi_send_bgscan_params(struct rsi_common *common, int enable)
1825	{
1826	struct rsi_bgscan_params *params = &common->bgscan;
1827	struct cfg80211_scan_request *scan_req = common->hwscan;
1828	struct rsi_bgscan_config *bgscan;
1829	struct sk_buff *skb;
1830	u16 frame_len = sizeof(*bgscan);
1831	u8 i;
1832
1833	rsi_dbg(MGMT_TX_ZONE, fmt: "%s: Sending bgscan params frame\n", __func__);
1834
1835	skb = dev_alloc_skb(length: frame_len);
1836	if (!skb)
1837	return -ENOMEM;
1838	memset(skb->data, 0, frame_len);
1839
1840	bgscan = (struct rsi_bgscan_config *)skb->data;
1841	rsi_set_len_qno(addr: &bgscan->desc_dword0.len_qno,
1842	len: (frame_len - FRAME_DESC_SZ), RSI_WIFI_MGMT_Q);
1843	bgscan->desc_dword0.frame_type = BG_SCAN_PARAMS;
1844	bgscan->bgscan_threshold = cpu_to_le16(params->bgscan_threshold);
1845	bgscan->roam_threshold = cpu_to_le16(params->roam_threshold);
1846	if (enable)
1847	bgscan->bgscan_periodicity =
1848	cpu_to_le16(params->bgscan_periodicity);
1849	bgscan->active_scan_duration =
1850	cpu_to_le16(params->active_scan_duration);
1851	bgscan->passive_scan_duration =
1852	cpu_to_le16(params->passive_scan_duration);
1853	bgscan->two_probe = params->two_probe;
1854
1855	bgscan->num_bgscan_channels = scan_req->n_channels;
1856	for (i = 0; i < bgscan->num_bgscan_channels; i++)
1857	bgscan->channels2scan[i] =
1858	cpu_to_le16(scan_req->channels[i]->hw_value);
1859
1860	skb_put(skb, len: frame_len);
1861
1862	return rsi_send_internal_mgmt_frame(common, skb);
1863	}
1864
1865	/* This function sends the probe request to be used by firmware in
1866	* background scan
1867	*/
1868	int rsi_send_bgscan_probe_req(struct rsi_common *common,
1869	struct ieee80211_vif *vif)
1870	{
1871	struct cfg80211_scan_request *scan_req = common->hwscan;
1872	struct rsi_bgscan_probe *bgscan;
1873	struct sk_buff *skb;
1874	struct sk_buff *probereq_skb;
1875	u16 frame_len = sizeof(*bgscan);
1876	size_t ssid_len = 0;
1877	u8 *ssid = NULL;
1878
1879	rsi_dbg(MGMT_TX_ZONE,
1880	fmt: "%s: Sending bgscan probe req frame\n", __func__);
1881
1882	if (common->priv->sc_nvifs <= 0)
1883	return -ENODEV;
1884
1885	if (scan_req->n_ssids) {
1886	ssid = scan_req->ssids[0].ssid;
1887	ssid_len = scan_req->ssids[0].ssid_len;
1888	}
1889
1890	skb = dev_alloc_skb(length: frame_len + MAX_BGSCAN_PROBE_REQ_LEN);
1891	if (!skb)
1892	return -ENOMEM;
1893	memset(skb->data, 0, frame_len + MAX_BGSCAN_PROBE_REQ_LEN);
1894
1895	bgscan = (struct rsi_bgscan_probe *)skb->data;
1896	bgscan->desc_dword0.frame_type = BG_SCAN_PROBE_REQ;
1897	bgscan->flags = cpu_to_le16(HOST_BG_SCAN_TRIG);
1898	if (common->band == NL80211_BAND_5GHZ) {
1899	bgscan->mgmt_rate = cpu_to_le16(RSI_RATE_6);
1900	bgscan->def_chan = cpu_to_le16(40);
1901	} else {
1902	bgscan->mgmt_rate = cpu_to_le16(RSI_RATE_1);
1903	bgscan->def_chan = cpu_to_le16(11);
1904	}
1905	bgscan->channel_scan_time = cpu_to_le16(RSI_CHANNEL_SCAN_TIME);
1906
1907	probereq_skb = ieee80211_probereq_get(hw: common->priv->hw, src_addr: vif->addr, ssid,
1908	ssid_len, tailroom: scan_req->ie_len);
1909	if (!probereq_skb) {
1910	dev_kfree_skb(skb);
1911	return -ENOMEM;
1912	}
1913
1914	memcpy(&skb->data[frame_len], probereq_skb->data, probereq_skb->len);
1915
1916	bgscan->probe_req_length = cpu_to_le16(probereq_skb->len);
1917
1918	rsi_set_len_qno(addr: &bgscan->desc_dword0.len_qno,
1919	len: (frame_len - FRAME_DESC_SZ + probereq_skb->len),
1920	RSI_WIFI_MGMT_Q);
1921
1922	skb_put(skb, len: frame_len + probereq_skb->len);
1923
1924	dev_kfree_skb(probereq_skb);
1925
1926	return rsi_send_internal_mgmt_frame(common, skb);
1927	}
1928
1929	/**
1930	* rsi_handle_ta_confirm_type() - This function handles the confirm frames.
1931	* @common: Pointer to the driver private structure.
1932	* @msg: Pointer to received packet.
1933	*
1934	* Return: 0 on success, -1 on failure.
1935	*/
1936	static int rsi_handle_ta_confirm_type(struct rsi_common *common,
1937	u8 *msg)
1938	{
1939	struct rsi_hw *adapter = common->priv;
1940	u8 sub_type = (msg[15] & 0xff);
1941	u16 msg_len = ((u16 *)msg)[0] & 0xfff;
1942	u8 offset;
1943
1944	switch (sub_type) {
1945	case BOOTUP_PARAMS_REQUEST:
1946	rsi_dbg(FSM_ZONE, fmt: "%s: Boot up params confirm received\n",
1947	__func__);
1948	if (common->fsm_state == FSM_BOOT_PARAMS_SENT) {
1949	if (adapter->device_model == RSI_DEV_9116) {
1950	common->band = NL80211_BAND_5GHZ;
1951	common->num_supp_bands = 2;
1952
1953	if (rsi_send_reset_mac(common))
1954	goto out;
1955	else
1956	common->fsm_state = FSM_RESET_MAC_SENT;
1957	} else {
1958	adapter->eeprom.length =
1959	(IEEE80211_ADDR_LEN +
1960	WLAN_MAC_MAGIC_WORD_LEN +
1961	WLAN_HOST_MODE_LEN);
1962	adapter->eeprom.offset = WLAN_MAC_EEPROM_ADDR;
1963	if (rsi_eeprom_read(common)) {
1964	common->fsm_state = FSM_CARD_NOT_READY;
1965	goto out;
1966	}
1967	common->fsm_state = FSM_EEPROM_READ_MAC_ADDR;
1968	}
1969	} else {
1970	rsi_dbg(INFO_ZONE,
1971	fmt: "%s: Received bootup params cfm in %d state\n",
1972	__func__, common->fsm_state);
1973	return 0;
1974	}
1975	break;
1976
1977	case EEPROM_READ:
1978	rsi_dbg(FSM_ZONE, fmt: "EEPROM READ confirm received\n");
1979	if (msg_len <= 0) {
1980	rsi_dbg(FSM_ZONE,
1981	fmt: "%s: [EEPROM_READ] Invalid len %d\n",
1982	__func__, msg_len);
1983	goto out;
1984	}
1985	if (msg[16] != MAGIC_WORD) {
1986	rsi_dbg(FSM_ZONE,
1987	fmt: "%s: [EEPROM_READ] Invalid token\n", __func__);
1988	common->fsm_state = FSM_CARD_NOT_READY;
1989	goto out;
1990	}
1991	if (common->fsm_state == FSM_EEPROM_READ_MAC_ADDR) {
1992	offset = (FRAME_DESC_SZ + WLAN_HOST_MODE_LEN +
1993	WLAN_MAC_MAGIC_WORD_LEN);
1994	memcpy(common->mac_addr, &msg[offset], ETH_ALEN);
1995	adapter->eeprom.length =
1996	((WLAN_MAC_MAGIC_WORD_LEN + 3) & (~3));
1997	adapter->eeprom.offset = WLAN_EEPROM_RFTYPE_ADDR;
1998	if (rsi_eeprom_read(common)) {
1999	rsi_dbg(ERR_ZONE,
2000	fmt: "%s: Failed reading RF band\n",
2001	__func__);
2002	common->fsm_state = FSM_CARD_NOT_READY;
2003	goto out;
2004	}
2005	common->fsm_state = FSM_EEPROM_READ_RF_TYPE;
2006	} else if (common->fsm_state == FSM_EEPROM_READ_RF_TYPE) {
2007	if ((msg[17] & 0x3) == 0x3) {
2008	rsi_dbg(INIT_ZONE, fmt: "Dual band supported\n");
2009	common->band = NL80211_BAND_5GHZ;
2010	common->num_supp_bands = 2;
2011	} else if ((msg[17] & 0x3) == 0x1) {
2012	rsi_dbg(INIT_ZONE,
2013	fmt: "Only 2.4Ghz band supported\n");
2014	common->band = NL80211_BAND_2GHZ;
2015	common->num_supp_bands = 1;
2016	}
2017	if (rsi_send_reset_mac(common))
2018	goto out;
2019	common->fsm_state = FSM_RESET_MAC_SENT;
2020	} else {
2021	rsi_dbg(ERR_ZONE, fmt: "%s: Invalid EEPROM read type\n",
2022	__func__);
2023	return 0;
2024	}
2025	break;
2026
2027	case RESET_MAC_REQ:
2028	if (common->fsm_state == FSM_RESET_MAC_SENT) {
2029	rsi_dbg(FSM_ZONE, fmt: "%s: Reset MAC cfm received\n",
2030	__func__);
2031
2032	if (rsi_load_radio_caps(common))
2033	goto out;
2034	else
2035	common->fsm_state = FSM_RADIO_CAPS_SENT;
2036	} else {
2037	rsi_dbg(ERR_ZONE,
2038	fmt: "%s: Received reset mac cfm in %d state\n",
2039	__func__, common->fsm_state);
2040	return 0;
2041	}
2042	break;
2043
2044	case RADIO_CAPABILITIES:
2045	if (common->fsm_state == FSM_RADIO_CAPS_SENT) {
2046	common->rf_reset = 1;
2047	if (adapter->device_model == RSI_DEV_9116 &&
2048	rsi_send_w9116_features(common)) {
2049	rsi_dbg(ERR_ZONE,
2050	fmt: "Failed to send 9116 features\n");
2051	goto out;
2052	}
2053	if (rsi_program_bb_rf(common)) {
2054	goto out;
2055	} else {
2056	common->fsm_state = FSM_BB_RF_PROG_SENT;
2057	rsi_dbg(FSM_ZONE, fmt: "%s: Radio cap cfm received\n",
2058	__func__);
2059	}
2060	} else {
2061	rsi_dbg(INFO_ZONE,
2062	fmt: "%s: Received radio caps cfm in %d state\n",
2063	__func__, common->fsm_state);
2064	return 0;
2065	}
2066	break;
2067
2068	case BB_PROG_VALUES_REQUEST:
2069	case RF_PROG_VALUES_REQUEST:
2070	case BBP_PROG_IN_TA:
2071	rsi_dbg(FSM_ZONE, fmt: "%s: BB/RF cfm received\n", __func__);
2072	if (common->fsm_state == FSM_BB_RF_PROG_SENT) {
2073	common->bb_rf_prog_count--;
2074	if (!common->bb_rf_prog_count) {
2075	common->fsm_state = FSM_MAC_INIT_DONE;
2076	if (common->reinit_hw) {
2077	complete(&common->wlan_init_completion);
2078	} else {
2079	if (common->bt_defer_attach)
2080	rsi_attach_bt(common);
2081
2082	return rsi_mac80211_attach(common);
2083	}
2084	}
2085	} else {
2086	rsi_dbg(INFO_ZONE,
2087	fmt: "%s: Received bbb_rf cfm in %d state\n",
2088	__func__, common->fsm_state);
2089	return 0;
2090	}
2091	break;
2092
2093	case SCAN_REQUEST:
2094	rsi_dbg(INFO_ZONE, fmt: "Set channel confirm\n");
2095	break;
2096
2097	case WAKEUP_SLEEP_REQUEST:
2098	rsi_dbg(INFO_ZONE, fmt: "Wakeup/Sleep confirmation.\n");
2099	return rsi_handle_ps_confirm(adapter, msg);
2100
2101	case BG_SCAN_PROBE_REQ:
2102	rsi_dbg(INFO_ZONE, fmt: "BG scan complete event\n");
2103	if (common->bgscan_en) {
2104	struct cfg80211_scan_info info;
2105
2106	if (!rsi_send_bgscan_params(common, RSI_STOP_BGSCAN))
2107	common->bgscan_en = 0;
2108	info.aborted = false;
2109	ieee80211_scan_completed(hw: adapter->hw, info: &info);
2110	}
2111	rsi_dbg(INFO_ZONE, fmt: "Background scan completed\n");
2112	break;
2113
2114	default:
2115	rsi_dbg(INFO_ZONE, fmt: "%s: Invalid TA confirm pkt received\n",
2116	__func__);
2117	break;
2118	}
2119	return 0;
2120	out:
2121	rsi_dbg(ERR_ZONE, fmt: "%s: Unable to send pkt/Invalid frame received\n",
2122	__func__);
2123	return -EINVAL;
2124	}
2125
2126	int rsi_handle_card_ready(struct rsi_common *common, u8 *msg)
2127	{
2128	int status;
2129
2130	switch (common->fsm_state) {
2131	case FSM_CARD_NOT_READY:
2132	rsi_dbg(INIT_ZONE, fmt: "Card ready indication from Common HAL\n");
2133	rsi_set_default_parameters(common);
2134	if (rsi_send_common_dev_params(common) < 0)
2135	return -EINVAL;
2136	common->fsm_state = FSM_COMMON_DEV_PARAMS_SENT;
2137	break;
2138	case FSM_COMMON_DEV_PARAMS_SENT:
2139	rsi_dbg(INIT_ZONE, fmt: "Card ready indication from WLAN HAL\n");
2140
2141	if (common->priv->device_model == RSI_DEV_9116) {
2142	if (msg[16] != MAGIC_WORD) {
2143	rsi_dbg(FSM_ZONE,
2144	fmt: "%s: [EEPROM_READ] Invalid token\n",
2145	__func__);
2146	common->fsm_state = FSM_CARD_NOT_READY;
2147	return -EINVAL;
2148	}
2149	memcpy(common->mac_addr, &msg[20], ETH_ALEN);
2150	rsi_dbg(INIT_ZONE, fmt: "MAC Addr %pM", common->mac_addr);
2151	}
2152	/* Get usb buffer status register address */
2153	common->priv->usb_buffer_status_reg = *(u32 *)&msg[8];
2154	rsi_dbg(INFO_ZONE, fmt: "USB buffer status register = %x\n",
2155	common->priv->usb_buffer_status_reg);
2156
2157	if (common->priv->device_model == RSI_DEV_9116)
2158	status = rsi_load_9116_bootup_params(common);
2159	else
2160	status = rsi_load_bootup_params(common);
2161	if (status < 0) {
2162	common->fsm_state = FSM_CARD_NOT_READY;
2163	return status;
2164	}
2165	common->fsm_state = FSM_BOOT_PARAMS_SENT;
2166	break;
2167	default:
2168	rsi_dbg(ERR_ZONE,
2169	fmt: "%s: card ready indication in invalid state %d.\n",
2170	__func__, common->fsm_state);
2171	return -EINVAL;
2172	}
2173
2174	return 0;
2175	}
2176
2177	/**
2178	* rsi_mgmt_pkt_recv() - This function processes the management packets
2179	* received from the hardware.
2180	* @common: Pointer to the driver private structure.
2181	* @msg: Pointer to the received packet.
2182	*
2183	* Return: 0 on success, -1 on failure.
2184	*/
2185	int rsi_mgmt_pkt_recv(struct rsi_common *common, u8 *msg)
2186	{
2187	s32 msg_len = (le16_to_cpu(*(__le16 *)&msg[0]) & 0x0fff);
2188	u16 msg_type = (msg[2]);
2189
2190	rsi_dbg(FSM_ZONE, fmt: "%s: Msg Len: %d, Msg Type: %4x\n",
2191	__func__, msg_len, msg_type);
2192
2193	switch (msg_type) {
2194	case TA_CONFIRM_TYPE:
2195	return rsi_handle_ta_confirm_type(common, msg);
2196	case CARD_READY_IND:
2197	common->hibernate_resume = false;
2198	rsi_dbg(FSM_ZONE, fmt: "%s: Card ready indication received\n",
2199	__func__);
2200	return rsi_handle_card_ready(common, msg);
2201	case TX_STATUS_IND:
2202	switch (msg[RSI_TX_STATUS_TYPE]) {
2203	case PROBEREQ_CONFIRM:
2204	common->mgmt_q_block = false;
2205	rsi_dbg(FSM_ZONE, fmt: "%s: Probe confirm received\n",
2206	__func__);
2207	break;
2208	case EAPOL4_CONFIRM:
2209	if (msg[RSI_TX_STATUS]) {
2210	common->eapol4_confirm = true;
2211	if (!rsi_send_block_unblock_frame(common,
2212	block_event: false))
2213	common->hw_data_qs_blocked = false;
2214	}
2215	}
2216	break;
2217	case BEACON_EVENT_IND:
2218	rsi_dbg(INFO_ZONE, fmt: "Beacon event\n");
2219	if (common->fsm_state != FSM_MAC_INIT_DONE)
2220	return -1;
2221	if (common->iface_down)
2222	return -1;
2223	if (!common->beacon_enabled)
2224	return -1;
2225	rsi_send_beacon(common);
2226	break;
2227	case WOWLAN_WAKEUP_REASON:
2228	rsi_dbg(ERR_ZONE, fmt: "\n\nWakeup Type: %x\n", msg[15]);
2229	switch (msg[15]) {
2230	case RSI_UNICAST_MAGIC_PKT:
2231	rsi_dbg(ERR_ZONE,
2232	fmt: "*** Wakeup for Unicast magic packet ***\n");
2233	break;
2234	case RSI_BROADCAST_MAGICPKT:
2235	rsi_dbg(ERR_ZONE,
2236	fmt: "*** Wakeup for Broadcast magic packet ***\n");
2237	break;
2238	case RSI_EAPOL_PKT:
2239	rsi_dbg(ERR_ZONE,
2240	fmt: "*** Wakeup for GTK renewal ***\n");
2241	break;
2242	case RSI_DISCONNECT_PKT:
2243	rsi_dbg(ERR_ZONE,
2244	fmt: "*** Wakeup for Disconnect ***\n");
2245	break;
2246	case RSI_HW_BMISS_PKT:
2247	rsi_dbg(ERR_ZONE,
2248	fmt: "*** Wakeup for HW Beacon miss ***\n");
2249	break;
2250	default:
2251	rsi_dbg(ERR_ZONE,
2252	fmt: "##### Un-intentional Wakeup #####\n");
2253	break;
2254	}
2255	break;
2256	case RX_DOT11_MGMT:
2257	return rsi_mgmt_pkt_to_core(common, msg, msg_len);
2258	default:
2259	rsi_dbg(INFO_ZONE, fmt: "Received packet type: 0x%x\n", msg_type);
2260	}
2261	return 0;
2262	}
2263