]> Git Repo - J-linux.git/blob - drivers/net/wireless/rsi/rsi_91x_hal.c
Merge tag 'vfs-6.13-rc7.fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs
[J-linux.git] / drivers / net / wireless / rsi / rsi_91x_hal.c
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
This page took 0.098269 seconds and 4 git commands to generate.