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
rsi_send_pkt_to_bus(struct rsi_common * common,struct sk_buff * skb)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
rsi_prepare_mgmt_desc(struct rsi_common * common,struct sk_buff * skb)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 */
rsi_prepare_data_desc(struct rsi_common * common,struct sk_buff * skb)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 */
rsi_send_data_pkt(struct rsi_common * common,struct sk_buff * skb)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 */
rsi_send_mgmt_pkt(struct rsi_common * common,struct sk_buff * skb)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
rsi_send_bt_pkt(struct rsi_common * common,struct sk_buff * skb)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
rsi_prepare_beacon(struct rsi_common * common,struct sk_buff * skb)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 unsigned int tailroom;
435 u16 tim_offset = 0;
436
437 for (i = 0; i < RSI_MAX_VIFS; i++) {
438 vif = adapter->vifs[i];
439 if (!vif)
440 continue;
441 if ((vif->type == NL80211_IFTYPE_AP) ||
442 (vif->type == NL80211_IFTYPE_P2P_GO))
443 break;
444 }
445 if (!vif)
446 return -EINVAL;
447 mac_bcn = ieee80211_beacon_get_tim(adapter->hw,
448 vif,
449 &tim_offset, NULL, 0);
450 if (!mac_bcn) {
451 rsi_dbg(ERR_ZONE, "Failed to get beacon from mac80211\n");
452 return -EINVAL;
453 }
454
455 common->beacon_cnt++;
456 bcn_frm = (struct rsi_data_desc *)skb->data;
457 rsi_set_len_qno(&bcn_frm->len_qno, mac_bcn->len, RSI_WIFI_DATA_Q);
458 bcn_frm->header_len = MIN_802_11_HDR_LEN;
459 bcn_frm->frame_info = cpu_to_le16(RSI_DATA_DESC_MAC_BBP_INFO |
460 RSI_DATA_DESC_NO_ACK_IND |
461 RSI_DATA_DESC_BEACON_FRAME |
462 RSI_DATA_DESC_INSERT_TSF |
463 RSI_DATA_DESC_INSERT_SEQ_NO |
464 RATE_INFO_ENABLE);
465 bcn_frm->rate_info = cpu_to_le16(vap_id << 14);
466 bcn_frm->qid_tid = BEACON_HW_Q;
467
468 if (conf_is_ht40_plus(conf)) {
469 bcn_frm->bbp_info = cpu_to_le16(LOWER_20_ENABLE);
470 bcn_frm->bbp_info |= cpu_to_le16(LOWER_20_ENABLE >> 12);
471 } else if (conf_is_ht40_minus(conf)) {
472 bcn_frm->bbp_info = cpu_to_le16(UPPER_20_ENABLE);
473 bcn_frm->bbp_info |= cpu_to_le16(UPPER_20_ENABLE >> 12);
474 }
475
476 if (common->band == NL80211_BAND_2GHZ)
477 bcn_frm->rate_info |= cpu_to_le16(RSI_RATE_1);
478 else
479 bcn_frm->rate_info |= cpu_to_le16(RSI_RATE_6);
480
481 if (mac_bcn->data[tim_offset + 2] == 0)
482 bcn_frm->frame_info |= cpu_to_le16(RSI_DATA_DESC_DTIM_BEACON);
483
484 tailroom = skb_tailroom(skb);
485 if (tailroom < FRAME_DESC_SZ ||
486 mac_bcn->len > tailroom - FRAME_DESC_SZ) {
487 dev_kfree_skb(mac_bcn);
488 return -EMSGSIZE;
489 }
490
491 memcpy(&skb->data[FRAME_DESC_SZ], mac_bcn->data, mac_bcn->len);
492 skb_put(skb, mac_bcn->len + FRAME_DESC_SZ);
493
494 dev_kfree_skb(mac_bcn);
495
496 return 0;
497 }
498
bl_cmd_timeout(struct timer_list * t)499 static void bl_cmd_timeout(struct timer_list *t)
500 {
501 struct rsi_hw *adapter = timer_container_of(adapter, t, bl_cmd_timer);
502
503 adapter->blcmd_timer_expired = true;
504 timer_delete(&adapter->bl_cmd_timer);
505 }
506
bl_start_cmd_timer(struct rsi_hw * adapter,u32 timeout)507 static int bl_start_cmd_timer(struct rsi_hw *adapter, u32 timeout)
508 {
509 timer_setup(&adapter->bl_cmd_timer, bl_cmd_timeout, 0);
510 adapter->bl_cmd_timer.expires = (msecs_to_jiffies(timeout) + jiffies);
511
512 adapter->blcmd_timer_expired = false;
513 add_timer(&adapter->bl_cmd_timer);
514
515 return 0;
516 }
517
bl_stop_cmd_timer(struct rsi_hw * adapter)518 static int bl_stop_cmd_timer(struct rsi_hw *adapter)
519 {
520 adapter->blcmd_timer_expired = false;
521 if (timer_pending(&adapter->bl_cmd_timer))
522 timer_delete(&adapter->bl_cmd_timer);
523
524 return 0;
525 }
526
bl_write_cmd(struct rsi_hw * adapter,u8 cmd,u8 exp_resp,u16 * cmd_resp)527 static int bl_write_cmd(struct rsi_hw *adapter, u8 cmd, u8 exp_resp,
528 u16 *cmd_resp)
529 {
530 struct rsi_host_intf_ops *hif_ops = adapter->host_intf_ops;
531 u32 regin_val = 0, regout_val = 0;
532 u32 regin_input = 0;
533 u8 output = 0;
534 int status;
535
536 regin_input = (REGIN_INPUT | adapter->priv->coex_mode);
537
538 while (!adapter->blcmd_timer_expired) {
539 regin_val = 0;
540 status = hif_ops->master_reg_read(adapter, SWBL_REGIN,
541 ®in_val, 2);
542 if (status < 0) {
543 rsi_dbg(ERR_ZONE,
544 "%s: Command %0x REGIN reading failed..\n",
545 __func__, cmd);
546 return status;
547 }
548 mdelay(1);
549 if ((regin_val >> 12) != REGIN_VALID)
550 break;
551 }
552 if (adapter->blcmd_timer_expired) {
553 rsi_dbg(ERR_ZONE,
554 "%s: Command %0x REGIN reading timed out..\n",
555 __func__, cmd);
556 return -ETIMEDOUT;
557 }
558
559 rsi_dbg(INFO_ZONE,
560 "Issuing write to Regin val:%0x sending cmd:%0x\n",
561 regin_val, (cmd | regin_input << 8));
562 status = hif_ops->master_reg_write(adapter, SWBL_REGIN,
563 (cmd | regin_input << 8), 2);
564 if (status < 0)
565 return status;
566 mdelay(1);
567
568 if (cmd == LOAD_HOSTED_FW || cmd == JUMP_TO_ZERO_PC) {
569 /* JUMP_TO_ZERO_PC doesn't expect
570 * any response. So return from here
571 */
572 return 0;
573 }
574
575 while (!adapter->blcmd_timer_expired) {
576 regout_val = 0;
577 status = hif_ops->master_reg_read(adapter, SWBL_REGOUT,
578 ®out_val, 2);
579 if (status < 0) {
580 rsi_dbg(ERR_ZONE,
581 "%s: Command %0x REGOUT reading failed..\n",
582 __func__, cmd);
583 return status;
584 }
585 mdelay(1);
586 if ((regout_val >> 8) == REGOUT_VALID)
587 break;
588 }
589 if (adapter->blcmd_timer_expired) {
590 rsi_dbg(ERR_ZONE,
591 "%s: Command %0x REGOUT reading timed out..\n",
592 __func__, cmd);
593 return status;
594 }
595
596 *cmd_resp = ((u16 *)®out_val)[0] & 0xffff;
597
598 output = ((u8 *)®out_val)[0] & 0xff;
599
600 status = hif_ops->master_reg_write(adapter, SWBL_REGOUT,
601 (cmd | REGOUT_INVALID << 8), 2);
602 if (status < 0) {
603 rsi_dbg(ERR_ZONE,
604 "%s: Command %0x REGOUT writing failed..\n",
605 __func__, cmd);
606 return status;
607 }
608 mdelay(1);
609
610 if (output != exp_resp) {
611 rsi_dbg(ERR_ZONE,
612 "%s: Recvd resp %x for cmd %0x\n",
613 __func__, output, cmd);
614 return -EINVAL;
615 }
616 rsi_dbg(INFO_ZONE,
617 "%s: Recvd Expected resp %x for cmd %0x\n",
618 __func__, output, cmd);
619
620 return 0;
621 }
622
bl_cmd(struct rsi_hw * adapter,u8 cmd,u8 exp_resp,char * str)623 static int bl_cmd(struct rsi_hw *adapter, u8 cmd, u8 exp_resp, char *str)
624 {
625 u16 regout_val = 0;
626 u32 timeout;
627 int status;
628
629 if ((cmd == EOF_REACHED) || (cmd == PING_VALID) || (cmd == PONG_VALID))
630 timeout = BL_BURN_TIMEOUT;
631 else
632 timeout = BL_CMD_TIMEOUT;
633
634 bl_start_cmd_timer(adapter, timeout);
635 status = bl_write_cmd(adapter, cmd, exp_resp, ®out_val);
636 if (status < 0) {
637 bl_stop_cmd_timer(adapter);
638 rsi_dbg(ERR_ZONE,
639 "%s: Command %s (%0x) writing failed..\n",
640 __func__, str, cmd);
641 return status;
642 }
643 bl_stop_cmd_timer(adapter);
644 return 0;
645 }
646
647 #define CHECK_SUM_OFFSET 20
648 #define LEN_OFFSET 8
649 #define ADDR_OFFSET 16
bl_write_header(struct rsi_hw * adapter,u8 * flash_content,u32 content_size)650 static int bl_write_header(struct rsi_hw *adapter, u8 *flash_content,
651 u32 content_size)
652 {
653 struct rsi_host_intf_ops *hif_ops = adapter->host_intf_ops;
654 struct bl_header *bl_hdr;
655 u32 write_addr, write_len;
656 int status;
657
658 bl_hdr = kzalloc_obj(*bl_hdr);
659 if (!bl_hdr)
660 return -ENOMEM;
661
662 bl_hdr->flags = 0;
663 bl_hdr->image_no = cpu_to_le32(adapter->priv->coex_mode);
664 bl_hdr->check_sum =
665 cpu_to_le32(*(u32 *)&flash_content[CHECK_SUM_OFFSET]);
666 bl_hdr->flash_start_address =
667 cpu_to_le32(*(u32 *)&flash_content[ADDR_OFFSET]);
668 bl_hdr->flash_len = cpu_to_le32(*(u32 *)&flash_content[LEN_OFFSET]);
669 write_len = sizeof(struct bl_header);
670
671 if (adapter->rsi_host_intf == RSI_HOST_INTF_USB) {
672 write_addr = PING_BUFFER_ADDRESS;
673 status = hif_ops->write_reg_multiple(adapter, write_addr,
674 (u8 *)bl_hdr, write_len);
675 if (status < 0) {
676 rsi_dbg(ERR_ZONE,
677 "%s: Failed to load Version/CRC structure\n",
678 __func__);
679 goto fail;
680 }
681 } else {
682 write_addr = PING_BUFFER_ADDRESS >> 16;
683 status = hif_ops->master_access_msword(adapter, write_addr);
684 if (status < 0) {
685 rsi_dbg(ERR_ZONE,
686 "%s: Unable to set ms word to common reg\n",
687 __func__);
688 goto fail;
689 }
690 write_addr = RSI_SD_REQUEST_MASTER |
691 (PING_BUFFER_ADDRESS & 0xFFFF);
692 status = hif_ops->write_reg_multiple(adapter, write_addr,
693 (u8 *)bl_hdr, write_len);
694 if (status < 0) {
695 rsi_dbg(ERR_ZONE,
696 "%s: Failed to load Version/CRC structure\n",
697 __func__);
698 goto fail;
699 }
700 }
701 status = 0;
702 fail:
703 kfree(bl_hdr);
704 return status;
705 }
706
read_flash_capacity(struct rsi_hw * adapter)707 static u32 read_flash_capacity(struct rsi_hw *adapter)
708 {
709 u32 flash_sz = 0;
710
711 if ((adapter->host_intf_ops->master_reg_read(adapter, FLASH_SIZE_ADDR,
712 &flash_sz, 2)) < 0) {
713 rsi_dbg(ERR_ZONE,
714 "%s: Flash size reading failed..\n",
715 __func__);
716 return 0;
717 }
718 rsi_dbg(INIT_ZONE, "Flash capacity: %d KiloBytes\n", flash_sz);
719
720 return (flash_sz * 1024); /* Return size in kbytes */
721 }
722
ping_pong_write(struct rsi_hw * adapter,u8 cmd,u8 * addr,u32 size)723 static int ping_pong_write(struct rsi_hw *adapter, u8 cmd, u8 *addr, u32 size)
724 {
725 struct rsi_host_intf_ops *hif_ops = adapter->host_intf_ops;
726 u32 block_size = adapter->block_size;
727 u32 cmd_addr;
728 u16 cmd_resp, cmd_req;
729 u8 *str;
730 int status;
731
732 if (cmd == PING_WRITE) {
733 cmd_addr = PING_BUFFER_ADDRESS;
734 cmd_resp = PONG_AVAIL;
735 cmd_req = PING_VALID;
736 str = "PING_VALID";
737 } else {
738 cmd_addr = PONG_BUFFER_ADDRESS;
739 cmd_resp = PING_AVAIL;
740 cmd_req = PONG_VALID;
741 str = "PONG_VALID";
742 }
743
744 status = hif_ops->load_data_master_write(adapter, cmd_addr, size,
745 block_size, addr);
746 if (status) {
747 rsi_dbg(ERR_ZONE, "%s: Unable to write blk at addr %0x\n",
748 __func__, *addr);
749 return status;
750 }
751
752 status = bl_cmd(adapter, cmd_req, cmd_resp, str);
753 if (status)
754 return status;
755
756 return 0;
757 }
758
auto_fw_upgrade(struct rsi_hw * adapter,u8 * flash_content,u32 content_size)759 static int auto_fw_upgrade(struct rsi_hw *adapter, u8 *flash_content,
760 u32 content_size)
761 {
762 u8 cmd;
763 u32 temp_content_size, num_flash, index;
764 u32 flash_start_address;
765 int status;
766
767 if (content_size > MAX_FLASH_FILE_SIZE) {
768 rsi_dbg(ERR_ZONE,
769 "%s: Flash Content size is more than 400K %u\n",
770 __func__, MAX_FLASH_FILE_SIZE);
771 return -EINVAL;
772 }
773
774 flash_start_address = *(u32 *)&flash_content[FLASH_START_ADDRESS];
775 rsi_dbg(INFO_ZONE, "flash start address: %08x\n", flash_start_address);
776
777 if (flash_start_address < FW_IMAGE_MIN_ADDRESS) {
778 rsi_dbg(ERR_ZONE,
779 "%s: Fw image Flash Start Address is less than 64K\n",
780 __func__);
781 return -EINVAL;
782 }
783
784 if (flash_start_address % FLASH_SECTOR_SIZE) {
785 rsi_dbg(ERR_ZONE,
786 "%s: Flash Start Address is not multiple of 4K\n",
787 __func__);
788 return -EINVAL;
789 }
790
791 if ((flash_start_address + content_size) > adapter->flash_capacity) {
792 rsi_dbg(ERR_ZONE,
793 "%s: Flash Content will cross max flash size\n",
794 __func__);
795 return -EINVAL;
796 }
797
798 temp_content_size = content_size;
799 num_flash = content_size / FLASH_WRITE_CHUNK_SIZE;
800
801 rsi_dbg(INFO_ZONE, "content_size: %d, num_flash: %d\n",
802 content_size, num_flash);
803
804 for (index = 0; index <= num_flash; index++) {
805 rsi_dbg(INFO_ZONE, "flash index: %d\n", index);
806 if (index != num_flash) {
807 content_size = FLASH_WRITE_CHUNK_SIZE;
808 rsi_dbg(INFO_ZONE, "QSPI content_size:%d\n",
809 content_size);
810 } else {
811 content_size =
812 temp_content_size % FLASH_WRITE_CHUNK_SIZE;
813 rsi_dbg(INFO_ZONE,
814 "Writing last sector content_size:%d\n",
815 content_size);
816 if (!content_size) {
817 rsi_dbg(INFO_ZONE, "instruction size zero\n");
818 break;
819 }
820 }
821
822 if (index % 2)
823 cmd = PING_WRITE;
824 else
825 cmd = PONG_WRITE;
826
827 status = ping_pong_write(adapter, cmd, flash_content,
828 content_size);
829 if (status) {
830 rsi_dbg(ERR_ZONE, "%s: Unable to load %d block\n",
831 __func__, index);
832 return status;
833 }
834
835 rsi_dbg(INFO_ZONE,
836 "%s: Successfully loaded %d instructions\n",
837 __func__, index);
838 flash_content += content_size;
839 }
840
841 status = bl_cmd(adapter, EOF_REACHED, FW_LOADING_SUCCESSFUL,
842 "EOF_REACHED");
843 if (status)
844 return status;
845
846 rsi_dbg(INFO_ZONE, "FW loading is done and FW is running..\n");
847 return 0;
848 }
849
rsi_hal_prepare_fwload(struct rsi_hw * adapter)850 static int rsi_hal_prepare_fwload(struct rsi_hw *adapter)
851 {
852 struct rsi_host_intf_ops *hif_ops = adapter->host_intf_ops;
853 u32 regout_val = 0;
854 int status;
855
856 bl_start_cmd_timer(adapter, BL_CMD_TIMEOUT);
857
858 while (!adapter->blcmd_timer_expired) {
859 status = hif_ops->master_reg_read(adapter, SWBL_REGOUT,
860 ®out_val,
861 RSI_COMMON_REG_SIZE);
862 if (status < 0) {
863 bl_stop_cmd_timer(adapter);
864 rsi_dbg(ERR_ZONE,
865 "%s: REGOUT read failed\n", __func__);
866 return status;
867 }
868 mdelay(1);
869 if ((regout_val >> 8) == REGOUT_VALID)
870 break;
871 }
872 if (adapter->blcmd_timer_expired) {
873 rsi_dbg(ERR_ZONE, "%s: REGOUT read timedout\n", __func__);
874 rsi_dbg(ERR_ZONE,
875 "%s: Soft boot loader not present\n", __func__);
876 return -ETIMEDOUT;
877 }
878 bl_stop_cmd_timer(adapter);
879
880 rsi_dbg(INFO_ZONE, "Received Board Version Number: %x\n",
881 (regout_val & 0xff));
882
883 status = hif_ops->master_reg_write(adapter, SWBL_REGOUT,
884 (REGOUT_INVALID |
885 REGOUT_INVALID << 8),
886 RSI_COMMON_REG_SIZE);
887 if (status < 0)
888 rsi_dbg(ERR_ZONE, "%s: REGOUT writing failed..\n", __func__);
889 else
890 rsi_dbg(INFO_ZONE,
891 "===> Device is ready to load firmware <===\n");
892
893 return status;
894 }
895
rsi_load_9113_firmware(struct rsi_hw * adapter)896 static int rsi_load_9113_firmware(struct rsi_hw *adapter)
897 {
898 struct rsi_common *common = adapter->priv;
899 const struct firmware *fw_entry = NULL;
900 u32 content_size;
901 u16 tmp_regout_val = 0;
902 struct ta_metadata *metadata_p;
903 int status;
904
905 status = bl_cmd(adapter, AUTO_READ_MODE, CMD_PASS,
906 "AUTO_READ_CMD");
907 if (status < 0)
908 return status;
909
910 adapter->flash_capacity = read_flash_capacity(adapter);
911 if (adapter->flash_capacity <= 0) {
912 rsi_dbg(ERR_ZONE,
913 "%s: Unable to read flash size from EEPROM\n",
914 __func__);
915 return -EINVAL;
916 }
917
918 metadata_p = &metadata_flash_content[adapter->priv->coex_mode];
919
920 rsi_dbg(INIT_ZONE, "%s: Loading file %s\n", __func__, metadata_p->name);
921 adapter->fw_file_name = metadata_p->name;
922
923 status = request_firmware(&fw_entry, metadata_p->name, adapter->device);
924 if (status < 0) {
925 rsi_dbg(ERR_ZONE, "%s: Failed to open file %s\n",
926 __func__, metadata_p->name);
927 return status;
928 }
929 content_size = fw_entry->size;
930 rsi_dbg(INFO_ZONE, "FW Length = %d bytes\n", content_size);
931
932 /* Get the firmware version */
933 common->lmac_ver.ver.info.fw_ver[0] =
934 fw_entry->data[LMAC_VER_OFFSET_9113] & 0xFF;
935 common->lmac_ver.ver.info.fw_ver[1] =
936 fw_entry->data[LMAC_VER_OFFSET_9113 + 1] & 0xFF;
937 common->lmac_ver.major =
938 fw_entry->data[LMAC_VER_OFFSET_9113 + 2] & 0xFF;
939 common->lmac_ver.release_num =
940 fw_entry->data[LMAC_VER_OFFSET_9113 + 3] & 0xFF;
941 common->lmac_ver.minor =
942 fw_entry->data[LMAC_VER_OFFSET_9113 + 4] & 0xFF;
943 common->lmac_ver.patch_num = 0;
944 rsi_print_version(common);
945
946 status = bl_write_header(adapter, (u8 *)fw_entry->data, content_size);
947 if (status) {
948 rsi_dbg(ERR_ZONE,
949 "%s: RPS Image header loading failed\n",
950 __func__);
951 goto fail;
952 }
953
954 bl_start_cmd_timer(adapter, BL_CMD_TIMEOUT);
955 status = bl_write_cmd(adapter, CHECK_CRC, CMD_PASS, &tmp_regout_val);
956 if (status) {
957 bl_stop_cmd_timer(adapter);
958 rsi_dbg(ERR_ZONE,
959 "%s: CHECK_CRC Command writing failed..\n",
960 __func__);
961 if ((tmp_regout_val & 0xff) == CMD_FAIL) {
962 rsi_dbg(ERR_ZONE,
963 "CRC Fail.. Proceeding to Upgrade mode\n");
964 goto fw_upgrade;
965 }
966 }
967 bl_stop_cmd_timer(adapter);
968
969 status = bl_cmd(adapter, POLLING_MODE, CMD_PASS, "POLLING_MODE");
970 if (status)
971 goto fail;
972
973 load_image_cmd:
974 status = bl_cmd(adapter, LOAD_HOSTED_FW, LOADING_INITIATED,
975 "LOAD_HOSTED_FW");
976 if (status)
977 goto fail;
978 rsi_dbg(INFO_ZONE, "Load Image command passed..\n");
979 goto success;
980
981 fw_upgrade:
982 status = bl_cmd(adapter, BURN_HOSTED_FW, SEND_RPS_FILE, "FW_UPGRADE");
983 if (status)
984 goto fail;
985
986 rsi_dbg(INFO_ZONE, "Burn Command Pass.. Upgrading the firmware\n");
987
988 status = auto_fw_upgrade(adapter, (u8 *)fw_entry->data, content_size);
989 if (status == 0) {
990 rsi_dbg(ERR_ZONE, "Firmware upgradation Done\n");
991 goto load_image_cmd;
992 }
993 rsi_dbg(ERR_ZONE, "Firmware upgrade failed\n");
994
995 status = bl_cmd(adapter, AUTO_READ_MODE, CMD_PASS,
996 "AUTO_READ_MODE");
997 if (status)
998 goto fail;
999
1000 success:
1001 rsi_dbg(ERR_ZONE, "***** Firmware Loading successful *****\n");
1002 release_firmware(fw_entry);
1003 return 0;
1004
1005 fail:
1006 rsi_dbg(ERR_ZONE, "##### Firmware loading failed #####\n");
1007 release_firmware(fw_entry);
1008 return status;
1009 }
1010
rsi_load_9116_firmware(struct rsi_hw * adapter)1011 static int rsi_load_9116_firmware(struct rsi_hw *adapter)
1012 {
1013 struct rsi_common *common = adapter->priv;
1014 struct rsi_host_intf_ops *hif_ops = adapter->host_intf_ops;
1015 const struct firmware *fw_entry;
1016 struct ta_metadata *metadata_p;
1017 u8 *ta_firmware, *fw_p;
1018 struct bootload_ds bootload_ds;
1019 u32 instructions_sz, base_address;
1020 u16 block_size = adapter->block_size;
1021 u32 dest, len;
1022 int status, cnt;
1023
1024 rsi_dbg(INIT_ZONE, "***** Load 9116 TA Instructions *****\n");
1025
1026 if (adapter->rsi_host_intf == RSI_HOST_INTF_USB) {
1027 status = bl_cmd(adapter, POLLING_MODE, CMD_PASS,
1028 "POLLING_MODE");
1029 if (status < 0)
1030 return status;
1031 }
1032
1033 status = hif_ops->master_reg_write(adapter, MEM_ACCESS_CTRL_FROM_HOST,
1034 RAM_384K_ACCESS_FROM_TA,
1035 RSI_9116_REG_SIZE);
1036 if (status < 0) {
1037 rsi_dbg(ERR_ZONE, "%s: Unable to access full RAM memory\n",
1038 __func__);
1039 return status;
1040 }
1041
1042 metadata_p = &metadata[adapter->priv->coex_mode];
1043 rsi_dbg(INIT_ZONE, "%s: loading file %s\n", __func__, metadata_p->name);
1044 status = request_firmware(&fw_entry, metadata_p->name, adapter->device);
1045 if (status < 0) {
1046 rsi_dbg(ERR_ZONE, "%s: Failed to open file %s\n",
1047 __func__, metadata_p->name);
1048 return status;
1049 }
1050
1051 ta_firmware = kmemdup(fw_entry->data, fw_entry->size, GFP_KERNEL);
1052 if (!ta_firmware) {
1053 status = -ENOMEM;
1054 goto fail_release_fw;
1055 }
1056 fw_p = ta_firmware;
1057 instructions_sz = fw_entry->size;
1058 rsi_dbg(INFO_ZONE, "FW Length = %d bytes\n", instructions_sz);
1059
1060 common->lmac_ver.major = ta_firmware[LMAC_VER_OFFSET_9116];
1061 common->lmac_ver.minor = ta_firmware[LMAC_VER_OFFSET_9116 + 1];
1062 common->lmac_ver.release_num = ta_firmware[LMAC_VER_OFFSET_9116 + 2];
1063 common->lmac_ver.patch_num = ta_firmware[LMAC_VER_OFFSET_9116 + 3];
1064 common->lmac_ver.ver.info.fw_ver[0] =
1065 ta_firmware[LMAC_VER_OFFSET_9116 + 4];
1066
1067 if (instructions_sz % FW_ALIGN_SIZE)
1068 instructions_sz +=
1069 (FW_ALIGN_SIZE - (instructions_sz % FW_ALIGN_SIZE));
1070 rsi_dbg(INFO_ZONE, "instructions_sz : %d\n", instructions_sz);
1071
1072 if (*(u16 *)fw_p == RSI_9116_FW_MAGIC_WORD) {
1073 memcpy(&bootload_ds, fw_p, sizeof(struct bootload_ds));
1074 fw_p += le16_to_cpu(bootload_ds.offset);
1075 rsi_dbg(INFO_ZONE, "FW start = %x\n", *(u32 *)fw_p);
1076
1077 cnt = 0;
1078 do {
1079 rsi_dbg(ERR_ZONE, "%s: Loading chunk %d\n",
1080 __func__, cnt);
1081
1082 dest = le32_to_cpu(bootload_ds.bl_entry[cnt].dst_addr);
1083 len = le32_to_cpu(bootload_ds.bl_entry[cnt].control) &
1084 RSI_BL_CTRL_LEN_MASK;
1085 rsi_dbg(INFO_ZONE, "length %d destination %x\n",
1086 len, dest);
1087
1088 status = hif_ops->load_data_master_write(adapter, dest,
1089 len,
1090 block_size,
1091 fw_p);
1092 if (status < 0) {
1093 rsi_dbg(ERR_ZONE,
1094 "Failed to load chunk %d\n", cnt);
1095 break;
1096 }
1097 fw_p += len;
1098 if (le32_to_cpu(bootload_ds.bl_entry[cnt].control) &
1099 RSI_BL_CTRL_LAST_ENTRY)
1100 break;
1101 cnt++;
1102 } while (1);
1103 } else {
1104 base_address = metadata_p->address;
1105 status = hif_ops->load_data_master_write(adapter,
1106 base_address,
1107 instructions_sz,
1108 block_size,
1109 ta_firmware);
1110 }
1111 if (status) {
1112 rsi_dbg(ERR_ZONE,
1113 "%s: Unable to load %s blk\n",
1114 __func__, metadata_p->name);
1115 goto fail_free_fw;
1116 }
1117
1118 rsi_dbg(INIT_ZONE, "%s: Successfully loaded %s instructions\n",
1119 __func__, metadata_p->name);
1120
1121 if (adapter->rsi_host_intf == RSI_HOST_INTF_SDIO) {
1122 if (hif_ops->ta_reset(adapter))
1123 rsi_dbg(ERR_ZONE, "Unable to put ta in reset\n");
1124 } else {
1125 if (bl_cmd(adapter, JUMP_TO_ZERO_PC,
1126 CMD_PASS, "JUMP_TO_ZERO") < 0)
1127 rsi_dbg(INFO_ZONE, "Jump to zero command failed\n");
1128 else
1129 rsi_dbg(INFO_ZONE, "Jump to zero command successful\n");
1130 }
1131
1132 fail_free_fw:
1133 kfree(ta_firmware);
1134 fail_release_fw:
1135 release_firmware(fw_entry);
1136
1137 return status;
1138 }
1139
rsi_hal_device_init(struct rsi_hw * adapter)1140 int rsi_hal_device_init(struct rsi_hw *adapter)
1141 {
1142 struct rsi_common *common = adapter->priv;
1143 int status;
1144
1145 switch (adapter->device_model) {
1146 case RSI_DEV_9113:
1147 status = rsi_hal_prepare_fwload(adapter);
1148 if (status < 0)
1149 return status;
1150 if (rsi_load_9113_firmware(adapter)) {
1151 rsi_dbg(ERR_ZONE,
1152 "%s: Failed to load TA instructions\n",
1153 __func__);
1154 return -EINVAL;
1155 }
1156 break;
1157 case RSI_DEV_9116:
1158 status = rsi_hal_prepare_fwload(adapter);
1159 if (status < 0)
1160 return status;
1161 if (rsi_load_9116_firmware(adapter)) {
1162 rsi_dbg(ERR_ZONE,
1163 "%s: Failed to load firmware to 9116 device\n",
1164 __func__);
1165 return -EINVAL;
1166 }
1167 break;
1168 default:
1169 return -EINVAL;
1170 }
1171 common->fsm_state = FSM_CARD_NOT_READY;
1172
1173 return 0;
1174 }
1175 EXPORT_SYMBOL_GPL(rsi_hal_device_init);
1176
1177