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/firmware.h>
18 #include <net/bluetooth/bluetooth.h>
19 #include "rsi_mgmt.h"
20 #include "rsi_hal.h"
21 #include "rsi_sdio.h"
22 #include "rsi_common.h"
23 
24 /* FLASH Firmware */
25 static struct ta_metadata metadata_flash_content[] = {
26 	{"flash_content", 0x00010000},
27 	{"rsi/rs9113_wlan_qspi.rps", 0x00010000},
28 	{"rsi/rs9113_wlan_bt_dual_mode.rps", 0x00010000},
29 	{"flash_content", 0x00010000},
30 	{"rsi/rs9113_ap_bt_dual_mode.rps", 0x00010000},
31 
32 };
33 
34 static struct ta_metadata metadata[] = {{"pmemdata_dummy", 0x00000000},
35 	{"rsi/rs9116_wlan.rps", 0x00000000},
36 	{"rsi/rs9116_wlan_bt_classic.rps", 0x00000000},
37 	{"rsi/pmemdata_dummy", 0x00000000},
38 	{"rsi/rs9116_wlan_bt_classic.rps", 0x00000000}
39 };
40 
41 int rsi_send_pkt_to_bus(struct rsi_common *common, struct sk_buff *skb)
42 {
43 	struct rsi_hw *adapter = common->priv;
44 	int status;
45 
46 	if (common->coex_mode > 1)
47 		mutex_lock(&common->tx_bus_mutex);
48 
49 	status = adapter->host_intf_ops->write_pkt(common->priv,
50 						   skb->data, skb->len);
51 
52 	if (common->coex_mode > 1)
53 		mutex_unlock(&common->tx_bus_mutex);
54 
55 	return status;
56 }
57 
58 int rsi_prepare_mgmt_desc(struct rsi_common *common, struct sk_buff *skb)
59 {
60 	struct rsi_hw *adapter = common->priv;
61 	struct ieee80211_hdr *wh = NULL;
62 	struct ieee80211_tx_info *info;
63 	struct ieee80211_conf *conf = &adapter->hw->conf;
64 	struct ieee80211_vif *vif;
65 	struct rsi_mgmt_desc *mgmt_desc;
66 	struct skb_info *tx_params;
67 	struct rsi_xtended_desc *xtend_desc = NULL;
68 	u8 header_size;
69 	u32 dword_align_bytes = 0;
70 
71 	if (skb->len > MAX_MGMT_PKT_SIZE) {
72 		rsi_dbg(INFO_ZONE, "%s: Dropping mgmt pkt > 512\n", __func__);
73 		return -EINVAL;
74 	}
75 
76 	info = IEEE80211_SKB_CB(skb);
77 	tx_params = (struct skb_info *)info->driver_data;
78 	vif = tx_params->vif;
79 
80 	/* Update header size */
81 	header_size = FRAME_DESC_SZ + sizeof(struct rsi_xtended_desc);
82 	if (header_size > skb_headroom(skb)) {
83 		rsi_dbg(ERR_ZONE,
84 			"%s: Failed to add extended descriptor\n",
85 			__func__);
86 		return -ENOSPC;
87 	}
88 	skb_push(skb, header_size);
89 	dword_align_bytes = ((unsigned long)skb->data & 0x3f);
90 	if (dword_align_bytes > skb_headroom(skb)) {
91 		rsi_dbg(ERR_ZONE,
92 			"%s: Failed to add dword align\n", __func__);
93 		return -ENOSPC;
94 	}
95 	skb_push(skb, dword_align_bytes);
96 	header_size += dword_align_bytes;
97 
98 	tx_params->internal_hdr_size = header_size;
99 	memset(&skb->data[0], 0, header_size);
100 	wh = (struct ieee80211_hdr *)&skb->data[header_size];
101 
102 	mgmt_desc = (struct rsi_mgmt_desc *)skb->data;
103 	xtend_desc = (struct rsi_xtended_desc *)&skb->data[FRAME_DESC_SZ];
104 
105 	rsi_set_len_qno(&mgmt_desc->len_qno, (skb->len - FRAME_DESC_SZ),
106 			RSI_WIFI_MGMT_Q);
107 	mgmt_desc->frame_type = TX_DOT11_MGMT;
108 	mgmt_desc->header_len = MIN_802_11_HDR_LEN;
109 	mgmt_desc->xtend_desc_size = header_size - FRAME_DESC_SZ;
110 
111 	if (ieee80211_is_probe_req(wh->frame_control))
112 		mgmt_desc->frame_info = cpu_to_le16(RSI_INSERT_SEQ_IN_FW);
113 	mgmt_desc->frame_info |= cpu_to_le16(RATE_INFO_ENABLE);
114 	if (is_broadcast_ether_addr(wh->addr1))
115 		mgmt_desc->frame_info |= cpu_to_le16(RSI_BROADCAST_PKT);
116 
117 	mgmt_desc->seq_ctrl =
118 		cpu_to_le16(IEEE80211_SEQ_TO_SN(le16_to_cpu(wh->seq_ctrl)));
119 	if ((common->band == NL80211_BAND_2GHZ) && !common->p2p_enabled)
120 		mgmt_desc->rate_info = cpu_to_le16(RSI_RATE_1);
121 	else
122 		mgmt_desc->rate_info = cpu_to_le16(RSI_RATE_6);
123 
124 	if (conf_is_ht40(conf))
125 		mgmt_desc->bbp_info = cpu_to_le16(FULL40M_ENABLE);
126 
127 	if (ieee80211_is_probe_resp(wh->frame_control)) {
128 		mgmt_desc->misc_flags |= (RSI_ADD_DELTA_TSF_VAP_ID |
129 					  RSI_FETCH_RETRY_CNT_FRM_HST);
130 #define PROBE_RESP_RETRY_CNT	3
131 		xtend_desc->retry_cnt = PROBE_RESP_RETRY_CNT;
132 	}
133 
134 	if (((vif->type == NL80211_IFTYPE_AP) ||
135 	     (vif->type == NL80211_IFTYPE_P2P_GO)) &&
136 	    (ieee80211_is_action(wh->frame_control))) {
137 		struct rsi_sta *rsta = rsi_find_sta(common, wh->addr1);
138 
139 		if (rsta)
140 			mgmt_desc->sta_id = tx_params->sta_id;
141 		else
142 			return -EINVAL;
143 	}
144 	mgmt_desc->rate_info |=
145 		cpu_to_le16((tx_params->vap_id << RSI_DESC_VAP_ID_OFST) &
146 			    RSI_DESC_VAP_ID_MASK);
147 
148 	return 0;
149 }
150 
151 /* This function prepares descriptor for given data packet */
152 int rsi_prepare_data_desc(struct rsi_common *common, struct sk_buff *skb)
153 {
154 	struct rsi_hw *adapter = common->priv;
155 	struct ieee80211_vif *vif;
156 	struct ieee80211_hdr *wh = NULL;
157 	struct ieee80211_tx_info *info;
158 	struct skb_info *tx_params;
159 	struct rsi_data_desc *data_desc;
160 	struct rsi_xtended_desc *xtend_desc;
161 	u8 ieee80211_size = MIN_802_11_HDR_LEN;
162 	u8 header_size;
163 	u8 vap_id = 0;
164 	u8 dword_align_bytes;
165 	bool tx_eapol;
166 	u16 seq_num;
167 
168 	info = IEEE80211_SKB_CB(skb);
169 	vif = info->control.vif;
170 	tx_params = (struct skb_info *)info->driver_data;
171 
172 	tx_eapol = IEEE80211_SKB_CB(skb)->control.flags &
173 		   IEEE80211_TX_CTRL_PORT_CTRL_PROTO;
174 
175 	header_size = FRAME_DESC_SZ + sizeof(struct rsi_xtended_desc);
176 	if (header_size > skb_headroom(skb)) {
177 		rsi_dbg(ERR_ZONE, "%s: Unable to send pkt\n", __func__);
178 		return -ENOSPC;
179 	}
180 	skb_push(skb, header_size);
181 	dword_align_bytes = ((unsigned long)skb->data & 0x3f);
182 	if (header_size > skb_headroom(skb)) {
183 		rsi_dbg(ERR_ZONE, "%s: Not enough headroom\n", __func__);
184 		return -ENOSPC;
185 	}
186 	skb_push(skb, dword_align_bytes);
187 	header_size += dword_align_bytes;
188 
189 	tx_params->internal_hdr_size = header_size;
190 	data_desc = (struct rsi_data_desc *)skb->data;
191 	memset(data_desc, 0, header_size);
192 
193 	xtend_desc = (struct rsi_xtended_desc *)&skb->data[FRAME_DESC_SZ];
194 	wh = (struct ieee80211_hdr *)&skb->data[header_size];
195 	seq_num = IEEE80211_SEQ_TO_SN(le16_to_cpu(wh->seq_ctrl));
196 
197 	data_desc->xtend_desc_size = header_size - FRAME_DESC_SZ;
198 
199 	if (ieee80211_is_data_qos(wh->frame_control)) {
200 		ieee80211_size += 2;
201 		data_desc->mac_flags |= cpu_to_le16(RSI_QOS_ENABLE);
202 	}
203 
204 	if (((vif->type == NL80211_IFTYPE_STATION) ||
205 	     (vif->type == NL80211_IFTYPE_P2P_CLIENT)) &&
206 	    (adapter->ps_state == PS_ENABLED))
207 		wh->frame_control |= cpu_to_le16(RSI_SET_PS_ENABLE);
208 
209 	if ((!(info->flags & IEEE80211_TX_INTFL_DONT_ENCRYPT)) &&
210 	    tx_params->have_key) {
211 		if (rsi_is_cipher_wep(common))
212 			ieee80211_size += 4;
213 		else
214 			ieee80211_size += 8;
215 		data_desc->mac_flags |= cpu_to_le16(RSI_ENCRYPT_PKT);
216 	}
217 	rsi_set_len_qno(&data_desc->len_qno, (skb->len - FRAME_DESC_SZ),
218 			RSI_WIFI_DATA_Q);
219 	data_desc->header_len = ieee80211_size;
220 
221 	if (common->rate_config[common->band].fixed_enabled) {
222 		/* Send fixed rate */
223 		u16 fixed_rate = common->rate_config[common->band].fixed_hw_rate;
224 
225 		data_desc->frame_info = cpu_to_le16(RATE_INFO_ENABLE);
226 		data_desc->rate_info = cpu_to_le16(fixed_rate);
227 
228 		if (conf_is_ht40(&common->priv->hw->conf))
229 			data_desc->bbp_info = cpu_to_le16(FULL40M_ENABLE);
230 
231 		if (common->vif_info[0].sgi && (fixed_rate & 0x100)) {
232 		       /* Only MCS rates */
233 			data_desc->rate_info |=
234 				cpu_to_le16(ENABLE_SHORTGI_RATE);
235 		}
236 	}
237 
238 	if (tx_eapol) {
239 		rsi_dbg(INFO_ZONE, "*** Tx EAPOL ***\n");
240 
241 		data_desc->frame_info = cpu_to_le16(RATE_INFO_ENABLE);
242 		if (common->band == NL80211_BAND_5GHZ)
243 			data_desc->rate_info = cpu_to_le16(RSI_RATE_6);
244 		else
245 			data_desc->rate_info = cpu_to_le16(RSI_RATE_1);
246 		data_desc->mac_flags |= cpu_to_le16(RSI_REKEY_PURPOSE);
247 		data_desc->misc_flags |= RSI_FETCH_RETRY_CNT_FRM_HST;
248 #define EAPOL_RETRY_CNT 15
249 		xtend_desc->retry_cnt = EAPOL_RETRY_CNT;
250 
251 		if (common->eapol4_confirm)
252 			skb->priority = VO_Q;
253 		else
254 			rsi_set_len_qno(&data_desc->len_qno,
255 					(skb->len - FRAME_DESC_SZ),
256 					RSI_WIFI_MGMT_Q);
257 		if (((skb->len - header_size) == EAPOL4_PACKET_LEN) ||
258 		    ((skb->len - header_size) == EAPOL4_PACKET_LEN - 2)) {
259 			data_desc->misc_flags |=
260 				RSI_DESC_REQUIRE_CFM_TO_HOST;
261 			xtend_desc->confirm_frame_type = EAPOL4_CONFIRM;
262 		}
263 	}
264 
265 	data_desc->mac_flags |= cpu_to_le16(seq_num & 0xfff);
266 	data_desc->qid_tid = ((skb->priority & 0xf) |
267 			      ((tx_params->tid & 0xf) << 4));
268 	data_desc->sta_id = tx_params->sta_id;
269 
270 	if ((is_broadcast_ether_addr(wh->addr1)) ||
271 	    (is_multicast_ether_addr(wh->addr1))) {
272 		data_desc->frame_info = cpu_to_le16(RATE_INFO_ENABLE);
273 		data_desc->frame_info |= cpu_to_le16(RSI_BROADCAST_PKT);
274 		data_desc->sta_id = vap_id;
275 
276 		if ((vif->type == NL80211_IFTYPE_AP) ||
277 		    (vif->type == NL80211_IFTYPE_P2P_GO)) {
278 			if (common->band == NL80211_BAND_5GHZ)
279 				data_desc->rate_info = cpu_to_le16(RSI_RATE_6);
280 			else
281 				data_desc->rate_info = cpu_to_le16(RSI_RATE_1);
282 		}
283 	}
284 	if (((vif->type == NL80211_IFTYPE_AP) ||
285 	     (vif->type == NL80211_IFTYPE_P2P_GO)) &&
286 	    (ieee80211_has_moredata(wh->frame_control)))
287 		data_desc->frame_info |= cpu_to_le16(MORE_DATA_PRESENT);
288 
289 	data_desc->rate_info |=
290 		cpu_to_le16((tx_params->vap_id << RSI_DESC_VAP_ID_OFST) &
291 			    RSI_DESC_VAP_ID_MASK);
292 
293 	return 0;
294 }
295 
296 /* This function sends received data packet from driver to device */
297 int rsi_send_data_pkt(struct rsi_common *common, struct sk_buff *skb)
298 {
299 	struct rsi_hw *adapter = common->priv;
300 	struct ieee80211_vif *vif;
301 	struct ieee80211_tx_info *info;
302 	int status = -EINVAL;
303 
304 	if (!skb)
305 		return 0;
306 	if (common->iface_down)
307 		goto err;
308 
309 	info = IEEE80211_SKB_CB(skb);
310 	if (!info->control.vif)
311 		goto err;
312 	vif = info->control.vif;
313 
314 	if (((vif->type == NL80211_IFTYPE_STATION) ||
315 	     (vif->type == NL80211_IFTYPE_P2P_CLIENT)) &&
316 	    (!vif->cfg.assoc))
317 		goto err;
318 
319 	status = rsi_send_pkt_to_bus(common, skb);
320 	if (status)
321 		rsi_dbg(ERR_ZONE, "%s: Failed to write pkt\n", __func__);
322 
323 err:
324 	++common->tx_stats.total_tx_pkt_freed[skb->priority];
325 	rsi_indicate_tx_status(adapter, skb, status);
326 	return status;
327 }
328 
329 /**
330  * rsi_send_mgmt_pkt() - This functions sends the received management packet
331  *			 from driver to device.
332  * @common: Pointer to the driver private structure.
333  * @skb: Pointer to the socket buffer structure.
334  *
335  * Return: status: 0 on success, -1 on failure.
336  */
337 int rsi_send_mgmt_pkt(struct rsi_common *common,
338 		      struct sk_buff *skb)
339 {
340 	struct rsi_hw *adapter = common->priv;
341 	struct ieee80211_hdr *wh;
342 	struct ieee80211_tx_info *info;
343 	struct skb_info *tx_params;
344 	struct rsi_mgmt_desc *mgmt_desc;
345 	struct rsi_xtended_desc *xtend_desc;
346 	int status = -E2BIG;
347 	u8 header_size;
348 
349 	info = IEEE80211_SKB_CB(skb);
350 	tx_params = (struct skb_info *)info->driver_data;
351 	header_size = tx_params->internal_hdr_size;
352 
353 	if (tx_params->flags & INTERNAL_MGMT_PKT) {
354 		status = adapter->host_intf_ops->write_pkt(common->priv,
355 							   (u8 *)skb->data,
356 							   skb->len);
357 		if (status) {
358 			rsi_dbg(ERR_ZONE,
359 				"%s: Failed to write the packet\n", __func__);
360 		}
361 		dev_kfree_skb(skb);
362 		return status;
363 	}
364 
365 	wh = (struct ieee80211_hdr *)&skb->data[header_size];
366 	mgmt_desc = (struct rsi_mgmt_desc *)skb->data;
367 	xtend_desc = (struct rsi_xtended_desc *)&skb->data[FRAME_DESC_SZ];
368 
369 	/* Indicate to firmware to give cfm for probe */
370 	if (ieee80211_is_probe_req(wh->frame_control) &&
371 	    !info->control.vif->cfg.assoc) {
372 		rsi_dbg(INFO_ZONE,
373 			"%s: blocking mgmt queue\n", __func__);
374 		mgmt_desc->misc_flags = RSI_DESC_REQUIRE_CFM_TO_HOST;
375 		xtend_desc->confirm_frame_type = PROBEREQ_CONFIRM;
376 		common->mgmt_q_block = true;
377 		rsi_dbg(INFO_ZONE, "Mgmt queue blocked\n");
378 	}
379 
380 	status = rsi_send_pkt_to_bus(common, skb);
381 	if (status)
382 		rsi_dbg(ERR_ZONE, "%s: Failed to write the packet\n", __func__);
383 
384 	rsi_indicate_tx_status(common->priv, skb, status);
385 	return status;
386 }
387 
388 int rsi_send_bt_pkt(struct rsi_common *common, struct sk_buff *skb)
389 {
390 	int status = -EINVAL;
391 	u8 header_size = 0;
392 	struct rsi_bt_desc *bt_desc;
393 	u8 queueno = ((skb->data[1] >> 4) & 0xf);
394 
395 	if (queueno == RSI_BT_MGMT_Q) {
396 		status = rsi_send_pkt_to_bus(common, skb);
397 		if (status)
398 			rsi_dbg(ERR_ZONE, "%s: Failed to write bt mgmt pkt\n",
399 				__func__);
400 		goto out;
401 	}
402 	header_size = FRAME_DESC_SZ;
403 	if (header_size > skb_headroom(skb)) {
404 		rsi_dbg(ERR_ZONE, "%s: Not enough headroom\n", __func__);
405 		status = -ENOSPC;
406 		goto out;
407 	}
408 	skb_push(skb, header_size);
409 	memset(skb->data, 0, header_size);
410 	bt_desc = (struct rsi_bt_desc *)skb->data;
411 
412 	rsi_set_len_qno(&bt_desc->len_qno, (skb->len - FRAME_DESC_SZ),
413 			RSI_BT_DATA_Q);
414 	bt_desc->bt_pkt_type = cpu_to_le16(bt_cb(skb)->pkt_type);
415 
416 	status = rsi_send_pkt_to_bus(common, skb);
417 	if (status)
418 		rsi_dbg(ERR_ZONE, "%s: Failed to write bt pkt\n", __func__);
419 
420 out:
421 	dev_kfree_skb(skb);
422 	return status;
423 }
424 
425 int rsi_prepare_beacon(struct rsi_common *common, struct sk_buff *skb)
426 {
427 	struct rsi_hw *adapter = common->priv;
428 	struct rsi_data_desc *bcn_frm;
429 	struct ieee80211_hw *hw = common->priv->hw;
430 	struct ieee80211_conf *conf = &hw->conf;
431 	struct ieee80211_vif *vif;
432 	struct sk_buff *mac_bcn;
433 	u8 vap_id = 0, i;
434 	u16 tim_offset = 0;
435 
436 	for (i = 0; i < RSI_MAX_VIFS; i++) {
437 		vif = adapter->vifs[i];
438 		if (!vif)
439 			continue;
440 		if ((vif->type == NL80211_IFTYPE_AP) ||
441 		    (vif->type == NL80211_IFTYPE_P2P_GO))
442 			break;
443 	}
444 	if (!vif)
445 		return -EINVAL;
446 	mac_bcn = ieee80211_beacon_get_tim(adapter->hw,
447 					   vif,
448 					   &tim_offset, NULL, 0);
449 	if (!mac_bcn) {
450 		rsi_dbg(ERR_ZONE, "Failed to get beacon from mac80211\n");
451 		return -EINVAL;
452 	}
453 
454 	common->beacon_cnt++;
455 	bcn_frm = (struct rsi_data_desc *)skb->data;
456 	rsi_set_len_qno(&bcn_frm->len_qno, mac_bcn->len, RSI_WIFI_DATA_Q);
457 	bcn_frm->header_len = MIN_802_11_HDR_LEN;
458 	bcn_frm->frame_info = cpu_to_le16(RSI_DATA_DESC_MAC_BBP_INFO |
459 					  RSI_DATA_DESC_NO_ACK_IND |
460 					  RSI_DATA_DESC_BEACON_FRAME |
461 					  RSI_DATA_DESC_INSERT_TSF |
462 					  RSI_DATA_DESC_INSERT_SEQ_NO |
463 					  RATE_INFO_ENABLE);
464 	bcn_frm->rate_info = cpu_to_le16(vap_id << 14);
465 	bcn_frm->qid_tid = BEACON_HW_Q;
466 
467 	if (conf_is_ht40_plus(conf)) {
468 		bcn_frm->bbp_info = cpu_to_le16(LOWER_20_ENABLE);
469 		bcn_frm->bbp_info |= cpu_to_le16(LOWER_20_ENABLE >> 12);
470 	} else if (conf_is_ht40_minus(conf)) {
471 		bcn_frm->bbp_info = cpu_to_le16(UPPER_20_ENABLE);
472 		bcn_frm->bbp_info |= cpu_to_le16(UPPER_20_ENABLE >> 12);
473 	}
474 
475 	if (common->band == NL80211_BAND_2GHZ)
476 		bcn_frm->rate_info |= cpu_to_le16(RSI_RATE_1);
477 	else
478 		bcn_frm->rate_info |= cpu_to_le16(RSI_RATE_6);
479 
480 	if (mac_bcn->data[tim_offset + 2] == 0)
481 		bcn_frm->frame_info |= cpu_to_le16(RSI_DATA_DESC_DTIM_BEACON);
482 
483 	memcpy(&skb->data[FRAME_DESC_SZ], mac_bcn->data, mac_bcn->len);
484 	skb_put(skb, mac_bcn->len + FRAME_DESC_SZ);
485 
486 	dev_kfree_skb(mac_bcn);
487 
488 	return 0;
489 }
490 
491 static void bl_cmd_timeout(struct timer_list *t)
492 {
493 	struct rsi_hw *adapter = from_timer(adapter, t, bl_cmd_timer);
494 
495 	adapter->blcmd_timer_expired = true;
496 	del_timer(&adapter->bl_cmd_timer);
497 }
498 
499 static int bl_start_cmd_timer(struct rsi_hw *adapter, u32 timeout)
500 {
501 	timer_setup(&adapter->bl_cmd_timer, bl_cmd_timeout, 0);
502 	adapter->bl_cmd_timer.expires = (msecs_to_jiffies(timeout) + jiffies);
503 
504 	adapter->blcmd_timer_expired = false;
505 	add_timer(&adapter->bl_cmd_timer);
506 
507 	return 0;
508 }
509 
510 static int bl_stop_cmd_timer(struct rsi_hw *adapter)
511 {
512 	adapter->blcmd_timer_expired = false;
513 	if (timer_pending(&adapter->bl_cmd_timer))
514 		del_timer(&adapter->bl_cmd_timer);
515 
516 	return 0;
517 }
518 
519 static int bl_write_cmd(struct rsi_hw *adapter, u8 cmd, u8 exp_resp,
520 			u16 *cmd_resp)
521 {
522 	struct rsi_host_intf_ops *hif_ops = adapter->host_intf_ops;
523 	u32 regin_val = 0, regout_val = 0;
524 	u32 regin_input = 0;
525 	u8 output = 0;
526 	int status;
527 
528 	regin_input = (REGIN_INPUT | adapter->priv->coex_mode);
529 
530 	while (!adapter->blcmd_timer_expired) {
531 		regin_val = 0;
532 		status = hif_ops->master_reg_read(adapter, SWBL_REGIN,
533 						  &regin_val, 2);
534 		if (status < 0) {
535 			rsi_dbg(ERR_ZONE,
536 				"%s: Command %0x REGIN reading failed..\n",
537 				__func__, cmd);
538 			return status;
539 		}
540 		mdelay(1);
541 		if ((regin_val >> 12) != REGIN_VALID)
542 			break;
543 	}
544 	if (adapter->blcmd_timer_expired) {
545 		rsi_dbg(ERR_ZONE,
546 			"%s: Command %0x REGIN reading timed out..\n",
547 			__func__, cmd);
548 		return -ETIMEDOUT;
549 	}
550 
551 	rsi_dbg(INFO_ZONE,
552 		"Issuing write to Regin val:%0x sending cmd:%0x\n",
553 		regin_val, (cmd | regin_input << 8));
554 	status = hif_ops->master_reg_write(adapter, SWBL_REGIN,
555 					   (cmd | regin_input << 8), 2);
556 	if (status < 0)
557 		return status;
558 	mdelay(1);
559 
560 	if (cmd == LOAD_HOSTED_FW || cmd == JUMP_TO_ZERO_PC) {
561 		/* JUMP_TO_ZERO_PC doesn't expect
562 		 * any response. So return from here
563 		 */
564 		return 0;
565 	}
566 
567 	while (!adapter->blcmd_timer_expired) {
568 		regout_val = 0;
569 		status = hif_ops->master_reg_read(adapter, SWBL_REGOUT,
570 					     &regout_val, 2);
571 		if (status < 0) {
572 			rsi_dbg(ERR_ZONE,
573 				"%s: Command %0x REGOUT reading failed..\n",
574 				__func__, cmd);
575 			return status;
576 		}
577 		mdelay(1);
578 		if ((regout_val >> 8) == REGOUT_VALID)
579 			break;
580 	}
581 	if (adapter->blcmd_timer_expired) {
582 		rsi_dbg(ERR_ZONE,
583 			"%s: Command %0x REGOUT reading timed out..\n",
584 			__func__, cmd);
585 		return status;
586 	}
587 
588 	*cmd_resp = ((u16 *)&regout_val)[0] & 0xffff;
589 
590 	output = ((u8 *)&regout_val)[0] & 0xff;
591 
592 	status = hif_ops->master_reg_write(adapter, SWBL_REGOUT,
593 					   (cmd | REGOUT_INVALID << 8), 2);
594 	if (status < 0) {
595 		rsi_dbg(ERR_ZONE,
596 			"%s: Command %0x REGOUT writing failed..\n",
597 			__func__, cmd);
598 		return status;
599 	}
600 	mdelay(1);
601 
602 	if (output != exp_resp) {
603 		rsi_dbg(ERR_ZONE,
604 			"%s: Recvd resp %x for cmd %0x\n",
605 			__func__, output, cmd);
606 		return -EINVAL;
607 	}
608 	rsi_dbg(INFO_ZONE,
609 		"%s: Recvd Expected resp %x for cmd %0x\n",
610 		__func__, output, cmd);
611 
612 	return 0;
613 }
614 
615 static int bl_cmd(struct rsi_hw *adapter, u8 cmd, u8 exp_resp, char *str)
616 {
617 	u16 regout_val = 0;
618 	u32 timeout;
619 	int status;
620 
621 	if ((cmd == EOF_REACHED) || (cmd == PING_VALID) || (cmd == PONG_VALID))
622 		timeout = BL_BURN_TIMEOUT;
623 	else
624 		timeout = BL_CMD_TIMEOUT;
625 
626 	bl_start_cmd_timer(adapter, timeout);
627 	status = bl_write_cmd(adapter, cmd, exp_resp, &regout_val);
628 	if (status < 0) {
629 		bl_stop_cmd_timer(adapter);
630 		rsi_dbg(ERR_ZONE,
631 			"%s: Command %s (%0x) writing failed..\n",
632 			__func__, str, cmd);
633 		return status;
634 	}
635 	bl_stop_cmd_timer(adapter);
636 	return 0;
637 }
638 
639 #define CHECK_SUM_OFFSET 20
640 #define LEN_OFFSET 8
641 #define ADDR_OFFSET 16
642 static int bl_write_header(struct rsi_hw *adapter, u8 *flash_content,
643 			   u32 content_size)
644 {
645 	struct rsi_host_intf_ops *hif_ops = adapter->host_intf_ops;
646 	struct bl_header *bl_hdr;
647 	u32 write_addr, write_len;
648 	int status;
649 
650 	bl_hdr = kzalloc(sizeof(*bl_hdr), GFP_KERNEL);
651 	if (!bl_hdr)
652 		return -ENOMEM;
653 
654 	bl_hdr->flags = 0;
655 	bl_hdr->image_no = cpu_to_le32(adapter->priv->coex_mode);
656 	bl_hdr->check_sum =
657 		cpu_to_le32(*(u32 *)&flash_content[CHECK_SUM_OFFSET]);
658 	bl_hdr->flash_start_address =
659 		cpu_to_le32(*(u32 *)&flash_content[ADDR_OFFSET]);
660 	bl_hdr->flash_len = cpu_to_le32(*(u32 *)&flash_content[LEN_OFFSET]);
661 	write_len = sizeof(struct bl_header);
662 
663 	if (adapter->rsi_host_intf == RSI_HOST_INTF_USB) {
664 		write_addr = PING_BUFFER_ADDRESS;
665 		status = hif_ops->write_reg_multiple(adapter, write_addr,
666 						 (u8 *)bl_hdr, write_len);
667 		if (status < 0) {
668 			rsi_dbg(ERR_ZONE,
669 				"%s: Failed to load Version/CRC structure\n",
670 				__func__);
671 			goto fail;
672 		}
673 	} else {
674 		write_addr = PING_BUFFER_ADDRESS >> 16;
675 		status = hif_ops->master_access_msword(adapter, write_addr);
676 		if (status < 0) {
677 			rsi_dbg(ERR_ZONE,
678 				"%s: Unable to set ms word to common reg\n",
679 				__func__);
680 			goto fail;
681 		}
682 		write_addr = RSI_SD_REQUEST_MASTER |
683 			     (PING_BUFFER_ADDRESS & 0xFFFF);
684 		status = hif_ops->write_reg_multiple(adapter, write_addr,
685 						 (u8 *)bl_hdr, write_len);
686 		if (status < 0) {
687 			rsi_dbg(ERR_ZONE,
688 				"%s: Failed to load Version/CRC structure\n",
689 				__func__);
690 			goto fail;
691 		}
692 	}
693 	status = 0;
694 fail:
695 	kfree(bl_hdr);
696 	return status;
697 }
698 
699 static u32 read_flash_capacity(struct rsi_hw *adapter)
700 {
701 	u32 flash_sz = 0;
702 
703 	if ((adapter->host_intf_ops->master_reg_read(adapter, FLASH_SIZE_ADDR,
704 						     &flash_sz, 2)) < 0) {
705 		rsi_dbg(ERR_ZONE,
706 			"%s: Flash size reading failed..\n",
707 			__func__);
708 		return 0;
709 	}
710 	rsi_dbg(INIT_ZONE, "Flash capacity: %d KiloBytes\n", flash_sz);
711 
712 	return (flash_sz * 1024); /* Return size in kbytes */
713 }
714 
715 static int ping_pong_write(struct rsi_hw *adapter, u8 cmd, u8 *addr, u32 size)
716 {
717 	struct rsi_host_intf_ops *hif_ops = adapter->host_intf_ops;
718 	u32 block_size = adapter->block_size;
719 	u32 cmd_addr;
720 	u16 cmd_resp, cmd_req;
721 	u8 *str;
722 	int status;
723 
724 	if (cmd == PING_WRITE) {
725 		cmd_addr = PING_BUFFER_ADDRESS;
726 		cmd_resp = PONG_AVAIL;
727 		cmd_req = PING_VALID;
728 		str = "PING_VALID";
729 	} else {
730 		cmd_addr = PONG_BUFFER_ADDRESS;
731 		cmd_resp = PING_AVAIL;
732 		cmd_req = PONG_VALID;
733 		str = "PONG_VALID";
734 	}
735 
736 	status = hif_ops->load_data_master_write(adapter, cmd_addr, size,
737 					    block_size, addr);
738 	if (status) {
739 		rsi_dbg(ERR_ZONE, "%s: Unable to write blk at addr %0x\n",
740 			__func__, *addr);
741 		return status;
742 	}
743 
744 	status = bl_cmd(adapter, cmd_req, cmd_resp, str);
745 	if (status)
746 		return status;
747 
748 	return 0;
749 }
750 
751 static int auto_fw_upgrade(struct rsi_hw *adapter, u8 *flash_content,
752 			   u32 content_size)
753 {
754 	u8 cmd;
755 	u32 temp_content_size, num_flash, index;
756 	u32 flash_start_address;
757 	int status;
758 
759 	if (content_size > MAX_FLASH_FILE_SIZE) {
760 		rsi_dbg(ERR_ZONE,
761 			"%s: Flash Content size is more than 400K %u\n",
762 			__func__, MAX_FLASH_FILE_SIZE);
763 		return -EINVAL;
764 	}
765 
766 	flash_start_address = *(u32 *)&flash_content[FLASH_START_ADDRESS];
767 	rsi_dbg(INFO_ZONE, "flash start address: %08x\n", flash_start_address);
768 
769 	if (flash_start_address < FW_IMAGE_MIN_ADDRESS) {
770 		rsi_dbg(ERR_ZONE,
771 			"%s: Fw image Flash Start Address is less than 64K\n",
772 			__func__);
773 		return -EINVAL;
774 	}
775 
776 	if (flash_start_address % FLASH_SECTOR_SIZE) {
777 		rsi_dbg(ERR_ZONE,
778 			"%s: Flash Start Address is not multiple of 4K\n",
779 			__func__);
780 		return -EINVAL;
781 	}
782 
783 	if ((flash_start_address + content_size) > adapter->flash_capacity) {
784 		rsi_dbg(ERR_ZONE,
785 			"%s: Flash Content will cross max flash size\n",
786 			__func__);
787 		return -EINVAL;
788 	}
789 
790 	temp_content_size  = content_size;
791 	num_flash = content_size / FLASH_WRITE_CHUNK_SIZE;
792 
793 	rsi_dbg(INFO_ZONE, "content_size: %d, num_flash: %d\n",
794 		content_size, num_flash);
795 
796 	for (index = 0; index <= num_flash; index++) {
797 		rsi_dbg(INFO_ZONE, "flash index: %d\n", index);
798 		if (index != num_flash) {
799 			content_size = FLASH_WRITE_CHUNK_SIZE;
800 			rsi_dbg(INFO_ZONE, "QSPI content_size:%d\n",
801 				content_size);
802 		} else {
803 			content_size =
804 				temp_content_size % FLASH_WRITE_CHUNK_SIZE;
805 			rsi_dbg(INFO_ZONE,
806 				"Writing last sector content_size:%d\n",
807 				content_size);
808 			if (!content_size) {
809 				rsi_dbg(INFO_ZONE, "instruction size zero\n");
810 				break;
811 			}
812 		}
813 
814 		if (index % 2)
815 			cmd = PING_WRITE;
816 		else
817 			cmd = PONG_WRITE;
818 
819 		status = ping_pong_write(adapter, cmd, flash_content,
820 					 content_size);
821 		if (status) {
822 			rsi_dbg(ERR_ZONE, "%s: Unable to load %d block\n",
823 				__func__, index);
824 			return status;
825 		}
826 
827 		rsi_dbg(INFO_ZONE,
828 			"%s: Successfully loaded %d instructions\n",
829 			__func__, index);
830 		flash_content += content_size;
831 	}
832 
833 	status = bl_cmd(adapter, EOF_REACHED, FW_LOADING_SUCCESSFUL,
834 			"EOF_REACHED");
835 	if (status)
836 		return status;
837 
838 	rsi_dbg(INFO_ZONE, "FW loading is done and FW is running..\n");
839 	return 0;
840 }
841 
842 static int rsi_hal_prepare_fwload(struct rsi_hw *adapter)
843 {
844 	struct rsi_host_intf_ops *hif_ops = adapter->host_intf_ops;
845 	u32 regout_val = 0;
846 	int status;
847 
848 	bl_start_cmd_timer(adapter, BL_CMD_TIMEOUT);
849 
850 	while (!adapter->blcmd_timer_expired) {
851 		status = hif_ops->master_reg_read(adapter, SWBL_REGOUT,
852 						  &regout_val,
853 						  RSI_COMMON_REG_SIZE);
854 		if (status < 0) {
855 			bl_stop_cmd_timer(adapter);
856 			rsi_dbg(ERR_ZONE,
857 				"%s: REGOUT read failed\n", __func__);
858 			return status;
859 		}
860 		mdelay(1);
861 		if ((regout_val >> 8) == REGOUT_VALID)
862 			break;
863 	}
864 	if (adapter->blcmd_timer_expired) {
865 		rsi_dbg(ERR_ZONE, "%s: REGOUT read timedout\n", __func__);
866 		rsi_dbg(ERR_ZONE,
867 			"%s: Soft boot loader not present\n", __func__);
868 		return -ETIMEDOUT;
869 	}
870 	bl_stop_cmd_timer(adapter);
871 
872 	rsi_dbg(INFO_ZONE, "Received Board Version Number: %x\n",
873 		(regout_val & 0xff));
874 
875 	status = hif_ops->master_reg_write(adapter, SWBL_REGOUT,
876 					   (REGOUT_INVALID |
877 					    REGOUT_INVALID << 8),
878 					   RSI_COMMON_REG_SIZE);
879 	if (status < 0)
880 		rsi_dbg(ERR_ZONE, "%s: REGOUT writing failed..\n", __func__);
881 	else
882 		rsi_dbg(INFO_ZONE,
883 			"===> Device is ready to load firmware <===\n");
884 
885 	return status;
886 }
887 
888 static int rsi_load_9113_firmware(struct rsi_hw *adapter)
889 {
890 	struct rsi_common *common = adapter->priv;
891 	const struct firmware *fw_entry = NULL;
892 	u32 content_size;
893 	u16 tmp_regout_val = 0;
894 	struct ta_metadata *metadata_p;
895 	int status;
896 
897 	status = bl_cmd(adapter, AUTO_READ_MODE, CMD_PASS,
898 			"AUTO_READ_CMD");
899 	if (status < 0)
900 		return status;
901 
902 	adapter->flash_capacity = read_flash_capacity(adapter);
903 	if (adapter->flash_capacity <= 0) {
904 		rsi_dbg(ERR_ZONE,
905 			"%s: Unable to read flash size from EEPROM\n",
906 			__func__);
907 		return -EINVAL;
908 	}
909 
910 	metadata_p = &metadata_flash_content[adapter->priv->coex_mode];
911 
912 	rsi_dbg(INIT_ZONE, "%s: Loading file %s\n", __func__, metadata_p->name);
913 	adapter->fw_file_name = metadata_p->name;
914 
915 	status = request_firmware(&fw_entry, metadata_p->name, adapter->device);
916 	if (status < 0) {
917 		rsi_dbg(ERR_ZONE, "%s: Failed to open file %s\n",
918 			__func__, metadata_p->name);
919 		return status;
920 	}
921 	content_size = fw_entry->size;
922 	rsi_dbg(INFO_ZONE, "FW Length = %d bytes\n", content_size);
923 
924 	/* Get the firmware version */
925 	common->lmac_ver.ver.info.fw_ver[0] =
926 		fw_entry->data[LMAC_VER_OFFSET_9113] & 0xFF;
927 	common->lmac_ver.ver.info.fw_ver[1] =
928 		fw_entry->data[LMAC_VER_OFFSET_9113 + 1] & 0xFF;
929 	common->lmac_ver.major =
930 		fw_entry->data[LMAC_VER_OFFSET_9113 + 2] & 0xFF;
931 	common->lmac_ver.release_num =
932 		fw_entry->data[LMAC_VER_OFFSET_9113 + 3] & 0xFF;
933 	common->lmac_ver.minor =
934 		fw_entry->data[LMAC_VER_OFFSET_9113 + 4] & 0xFF;
935 	common->lmac_ver.patch_num = 0;
936 	rsi_print_version(common);
937 
938 	status = bl_write_header(adapter, (u8 *)fw_entry->data, content_size);
939 	if (status) {
940 		rsi_dbg(ERR_ZONE,
941 			"%s: RPS Image header loading failed\n",
942 			__func__);
943 		goto fail;
944 	}
945 
946 	bl_start_cmd_timer(adapter, BL_CMD_TIMEOUT);
947 	status = bl_write_cmd(adapter, CHECK_CRC, CMD_PASS, &tmp_regout_val);
948 	if (status) {
949 		bl_stop_cmd_timer(adapter);
950 		rsi_dbg(ERR_ZONE,
951 			"%s: CHECK_CRC Command writing failed..\n",
952 			__func__);
953 		if ((tmp_regout_val & 0xff) == CMD_FAIL) {
954 			rsi_dbg(ERR_ZONE,
955 				"CRC Fail.. Proceeding to Upgrade mode\n");
956 			goto fw_upgrade;
957 		}
958 	}
959 	bl_stop_cmd_timer(adapter);
960 
961 	status = bl_cmd(adapter, POLLING_MODE, CMD_PASS, "POLLING_MODE");
962 	if (status)
963 		goto fail;
964 
965 load_image_cmd:
966 	status = bl_cmd(adapter, LOAD_HOSTED_FW, LOADING_INITIATED,
967 			"LOAD_HOSTED_FW");
968 	if (status)
969 		goto fail;
970 	rsi_dbg(INFO_ZONE, "Load Image command passed..\n");
971 	goto success;
972 
973 fw_upgrade:
974 	status = bl_cmd(adapter, BURN_HOSTED_FW, SEND_RPS_FILE, "FW_UPGRADE");
975 	if (status)
976 		goto fail;
977 
978 	rsi_dbg(INFO_ZONE, "Burn Command Pass.. Upgrading the firmware\n");
979 
980 	status = auto_fw_upgrade(adapter, (u8 *)fw_entry->data, content_size);
981 	if (status == 0) {
982 		rsi_dbg(ERR_ZONE, "Firmware upgradation Done\n");
983 		goto load_image_cmd;
984 	}
985 	rsi_dbg(ERR_ZONE, "Firmware upgrade failed\n");
986 
987 	status = bl_cmd(adapter, AUTO_READ_MODE, CMD_PASS,
988 			"AUTO_READ_MODE");
989 	if (status)
990 		goto fail;
991 
992 success:
993 	rsi_dbg(ERR_ZONE, "***** Firmware Loading successful *****\n");
994 	release_firmware(fw_entry);
995 	return 0;
996 
997 fail:
998 	rsi_dbg(ERR_ZONE, "##### Firmware loading failed #####\n");
999 	release_firmware(fw_entry);
1000 	return status;
1001 }
1002 
1003 static int rsi_load_9116_firmware(struct rsi_hw *adapter)
1004 {
1005 	struct rsi_common *common = adapter->priv;
1006 	struct rsi_host_intf_ops *hif_ops = adapter->host_intf_ops;
1007 	const struct firmware *fw_entry;
1008 	struct ta_metadata *metadata_p;
1009 	u8 *ta_firmware, *fw_p;
1010 	struct bootload_ds bootload_ds;
1011 	u32 instructions_sz, base_address;
1012 	u16 block_size = adapter->block_size;
1013 	u32 dest, len;
1014 	int status, cnt;
1015 
1016 	rsi_dbg(INIT_ZONE, "***** Load 9116 TA Instructions *****\n");
1017 
1018 	if (adapter->rsi_host_intf == RSI_HOST_INTF_USB) {
1019 		status = bl_cmd(adapter, POLLING_MODE, CMD_PASS,
1020 				"POLLING_MODE");
1021 		if (status < 0)
1022 			return status;
1023 	}
1024 
1025 	status = hif_ops->master_reg_write(adapter, MEM_ACCESS_CTRL_FROM_HOST,
1026 					   RAM_384K_ACCESS_FROM_TA,
1027 					   RSI_9116_REG_SIZE);
1028 	if (status < 0) {
1029 		rsi_dbg(ERR_ZONE, "%s: Unable to access full RAM memory\n",
1030 			__func__);
1031 		return status;
1032 	}
1033 
1034 	metadata_p = &metadata[adapter->priv->coex_mode];
1035 	rsi_dbg(INIT_ZONE, "%s: loading file %s\n", __func__, metadata_p->name);
1036 	status = request_firmware(&fw_entry, metadata_p->name, adapter->device);
1037 	if (status < 0) {
1038 		rsi_dbg(ERR_ZONE, "%s: Failed to open file %s\n",
1039 			__func__, metadata_p->name);
1040 		return status;
1041 	}
1042 
1043 	ta_firmware = kmemdup(fw_entry->data, fw_entry->size, GFP_KERNEL);
1044 	if (!ta_firmware) {
1045 		status = -ENOMEM;
1046 		goto fail_release_fw;
1047 	}
1048 	fw_p = ta_firmware;
1049 	instructions_sz = fw_entry->size;
1050 	rsi_dbg(INFO_ZONE, "FW Length = %d bytes\n", instructions_sz);
1051 
1052 	common->lmac_ver.major = ta_firmware[LMAC_VER_OFFSET_9116];
1053 	common->lmac_ver.minor = ta_firmware[LMAC_VER_OFFSET_9116 + 1];
1054 	common->lmac_ver.release_num = ta_firmware[LMAC_VER_OFFSET_9116 + 2];
1055 	common->lmac_ver.patch_num = ta_firmware[LMAC_VER_OFFSET_9116 + 3];
1056 	common->lmac_ver.ver.info.fw_ver[0] =
1057 		ta_firmware[LMAC_VER_OFFSET_9116 + 4];
1058 
1059 	if (instructions_sz % FW_ALIGN_SIZE)
1060 		instructions_sz +=
1061 			(FW_ALIGN_SIZE - (instructions_sz % FW_ALIGN_SIZE));
1062 	rsi_dbg(INFO_ZONE, "instructions_sz : %d\n", instructions_sz);
1063 
1064 	if (*(u16 *)fw_p == RSI_9116_FW_MAGIC_WORD) {
1065 		memcpy(&bootload_ds, fw_p, sizeof(struct bootload_ds));
1066 		fw_p += le16_to_cpu(bootload_ds.offset);
1067 		rsi_dbg(INFO_ZONE, "FW start = %x\n", *(u32 *)fw_p);
1068 
1069 		cnt = 0;
1070 		do {
1071 			rsi_dbg(ERR_ZONE, "%s: Loading chunk %d\n",
1072 				__func__, cnt);
1073 
1074 			dest = le32_to_cpu(bootload_ds.bl_entry[cnt].dst_addr);
1075 			len = le32_to_cpu(bootload_ds.bl_entry[cnt].control) &
1076 			      RSI_BL_CTRL_LEN_MASK;
1077 			rsi_dbg(INFO_ZONE, "length %d destination %x\n",
1078 				len, dest);
1079 
1080 			status = hif_ops->load_data_master_write(adapter, dest,
1081 								 len,
1082 								 block_size,
1083 								 fw_p);
1084 			if (status < 0) {
1085 				rsi_dbg(ERR_ZONE,
1086 					"Failed to load chunk %d\n", cnt);
1087 				break;
1088 			}
1089 			fw_p += len;
1090 			if (le32_to_cpu(bootload_ds.bl_entry[cnt].control) &
1091 			    RSI_BL_CTRL_LAST_ENTRY)
1092 				break;
1093 			cnt++;
1094 		} while (1);
1095 	} else {
1096 		base_address = metadata_p->address;
1097 		status = hif_ops->load_data_master_write(adapter,
1098 							 base_address,
1099 							 instructions_sz,
1100 							 block_size,
1101 							 ta_firmware);
1102 	}
1103 	if (status) {
1104 		rsi_dbg(ERR_ZONE,
1105 			"%s: Unable to load %s blk\n",
1106 			__func__, metadata_p->name);
1107 		goto fail_free_fw;
1108 	}
1109 
1110 	rsi_dbg(INIT_ZONE, "%s: Successfully loaded %s instructions\n",
1111 		__func__, metadata_p->name);
1112 
1113 	if (adapter->rsi_host_intf == RSI_HOST_INTF_SDIO) {
1114 		if (hif_ops->ta_reset(adapter))
1115 			rsi_dbg(ERR_ZONE, "Unable to put ta in reset\n");
1116 	} else {
1117 		if (bl_cmd(adapter, JUMP_TO_ZERO_PC,
1118 			   CMD_PASS, "JUMP_TO_ZERO") < 0)
1119 			rsi_dbg(INFO_ZONE, "Jump to zero command failed\n");
1120 		else
1121 			rsi_dbg(INFO_ZONE, "Jump to zero command successful\n");
1122 	}
1123 
1124 fail_free_fw:
1125 	kfree(ta_firmware);
1126 fail_release_fw:
1127 	release_firmware(fw_entry);
1128 
1129 	return status;
1130 }
1131 
1132 int rsi_hal_device_init(struct rsi_hw *adapter)
1133 {
1134 	struct rsi_common *common = adapter->priv;
1135 	int status;
1136 
1137 	switch (adapter->device_model) {
1138 	case RSI_DEV_9113:
1139 		status = rsi_hal_prepare_fwload(adapter);
1140 		if (status < 0)
1141 			return status;
1142 		if (rsi_load_9113_firmware(adapter)) {
1143 			rsi_dbg(ERR_ZONE,
1144 				"%s: Failed to load TA instructions\n",
1145 				__func__);
1146 			return -EINVAL;
1147 		}
1148 		break;
1149 	case RSI_DEV_9116:
1150 		status = rsi_hal_prepare_fwload(adapter);
1151 		if (status < 0)
1152 			return status;
1153 		if (rsi_load_9116_firmware(adapter)) {
1154 			rsi_dbg(ERR_ZONE,
1155 				"%s: Failed to load firmware to 9116 device\n",
1156 				__func__);
1157 			return -EINVAL;
1158 		}
1159 		break;
1160 	default:
1161 		return -EINVAL;
1162 	}
1163 	common->fsm_state = FSM_CARD_NOT_READY;
1164 
1165 	return 0;
1166 }
1167 EXPORT_SYMBOL_GPL(rsi_hal_device_init);
1168 
1169