2 * Copyright (c) 2014 Redpine Signals Inc.
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.
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.
17 #include <linux/firmware.h>
18 #include <net/bluetooth/bluetooth.h>
22 #include "rsi_common.h"
25 static struct ta_metadata metadata_flash_content[] = {
26 {"flash_content", 0x00010000},
27 {"/*(DEBLOBBED)*/", 0x00010000},
28 {"rsi/rs9113_wlan_bt_dual_mode.rps", 0x00010000},
29 {"flash_content", 0x00010000},
30 {"rsi/rs9113_ap_bt_dual_mode.rps", 0x00010000},
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}
41 int rsi_send_pkt_to_bus(struct rsi_common *common, struct sk_buff *skb)
43 struct rsi_hw *adapter = common->priv;
46 if (common->coex_mode > 1)
47 mutex_lock(&common->tx_bus_mutex);
49 status = adapter->host_intf_ops->write_pkt(common->priv,
52 if (common->coex_mode > 1)
53 mutex_unlock(&common->tx_bus_mutex);
58 int rsi_prepare_mgmt_desc(struct rsi_common *common, struct sk_buff *skb)
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;
69 u32 dword_align_bytes = 0;
71 if (skb->len > MAX_MGMT_PKT_SIZE) {
72 rsi_dbg(INFO_ZONE, "%s: Dropping mgmt pkt > 512\n", __func__);
76 info = IEEE80211_SKB_CB(skb);
77 tx_params = (struct skb_info *)info->driver_data;
80 /* Update header size */
81 header_size = FRAME_DESC_SZ + sizeof(struct rsi_xtended_desc);
82 if (header_size > skb_headroom(skb)) {
84 "%s: Failed to add extended descriptor\n",
88 skb_push(skb, header_size);
89 dword_align_bytes = ((unsigned long)skb->data & 0x3f);
90 if (dword_align_bytes > skb_headroom(skb)) {
92 "%s: Failed to add dword align\n", __func__);
95 skb_push(skb, dword_align_bytes);
96 header_size += dword_align_bytes;
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];
102 mgmt_desc = (struct rsi_mgmt_desc *)skb->data;
103 xtend_desc = (struct rsi_xtended_desc *)&skb->data[FRAME_DESC_SZ];
105 rsi_set_len_qno(&mgmt_desc->len_qno, (skb->len - FRAME_DESC_SZ),
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;
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);
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);
122 mgmt_desc->rate_info = cpu_to_le16(RSI_RATE_6);
124 if (conf_is_ht40(conf))
125 mgmt_desc->bbp_info = cpu_to_le16(FULL40M_ENABLE);
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;
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);
140 mgmt_desc->sta_id = tx_params->sta_id;
144 mgmt_desc->rate_info |=
145 cpu_to_le16((tx_params->vap_id << RSI_DESC_VAP_ID_OFST) &
146 RSI_DESC_VAP_ID_MASK);
151 /* This function prepares descriptor for given data packet */
152 int rsi_prepare_data_desc(struct rsi_common *common, struct sk_buff *skb)
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;
164 u8 dword_align_bytes;
167 info = IEEE80211_SKB_CB(skb);
168 vif = info->control.vif;
169 tx_params = (struct skb_info *)info->driver_data;
171 header_size = FRAME_DESC_SZ + sizeof(struct rsi_xtended_desc);
172 if (header_size > skb_headroom(skb)) {
173 rsi_dbg(ERR_ZONE, "%s: Unable to send pkt\n", __func__);
176 skb_push(skb, header_size);
177 dword_align_bytes = ((unsigned long)skb->data & 0x3f);
178 if (header_size > skb_headroom(skb)) {
179 rsi_dbg(ERR_ZONE, "%s: Not enough headroom\n", __func__);
182 skb_push(skb, dword_align_bytes);
183 header_size += dword_align_bytes;
185 tx_params->internal_hdr_size = header_size;
186 data_desc = (struct rsi_data_desc *)skb->data;
187 memset(data_desc, 0, header_size);
189 xtend_desc = (struct rsi_xtended_desc *)&skb->data[FRAME_DESC_SZ];
190 wh = (struct ieee80211_hdr *)&skb->data[header_size];
191 seq_num = IEEE80211_SEQ_TO_SN(le16_to_cpu(wh->seq_ctrl));
193 data_desc->xtend_desc_size = header_size - FRAME_DESC_SZ;
195 if (ieee80211_is_data_qos(wh->frame_control)) {
197 data_desc->mac_flags |= cpu_to_le16(RSI_QOS_ENABLE);
200 if (((vif->type == NL80211_IFTYPE_STATION) ||
201 (vif->type == NL80211_IFTYPE_P2P_CLIENT)) &&
202 (adapter->ps_state == PS_ENABLED))
203 wh->frame_control |= cpu_to_le16(RSI_SET_PS_ENABLE);
205 if ((!(info->flags & IEEE80211_TX_INTFL_DONT_ENCRYPT)) &&
206 tx_params->have_key) {
207 if (rsi_is_cipher_wep(common))
211 data_desc->mac_flags |= cpu_to_le16(RSI_ENCRYPT_PKT);
213 rsi_set_len_qno(&data_desc->len_qno, (skb->len - FRAME_DESC_SZ),
215 data_desc->header_len = ieee80211_size;
217 if (common->rate_config[common->band].fixed_enabled) {
218 /* Send fixed rate */
219 u16 fixed_rate = common->rate_config[common->band].fixed_hw_rate;
221 data_desc->frame_info = cpu_to_le16(RATE_INFO_ENABLE);
222 data_desc->rate_info = cpu_to_le16(fixed_rate);
224 if (conf_is_ht40(&common->priv->hw->conf))
225 data_desc->bbp_info = cpu_to_le16(FULL40M_ENABLE);
227 if (common->vif_info[0].sgi && (fixed_rate & 0x100)) {
229 data_desc->rate_info |=
230 cpu_to_le16(ENABLE_SHORTGI_RATE);
234 if (skb->protocol == cpu_to_be16(ETH_P_PAE)) {
235 rsi_dbg(INFO_ZONE, "*** Tx EAPOL ***\n");
237 data_desc->frame_info = cpu_to_le16(RATE_INFO_ENABLE);
238 if (common->band == NL80211_BAND_5GHZ)
239 data_desc->rate_info = cpu_to_le16(RSI_RATE_6);
241 data_desc->rate_info = cpu_to_le16(RSI_RATE_1);
242 data_desc->mac_flags |= cpu_to_le16(RSI_REKEY_PURPOSE);
243 data_desc->misc_flags |= RSI_FETCH_RETRY_CNT_FRM_HST;
244 #define EAPOL_RETRY_CNT 15
245 xtend_desc->retry_cnt = EAPOL_RETRY_CNT;
247 if (common->eapol4_confirm)
248 skb->priority = VO_Q;
250 rsi_set_len_qno(&data_desc->len_qno,
251 (skb->len - FRAME_DESC_SZ),
253 if (((skb->len - header_size) == EAPOL4_PACKET_LEN) ||
254 ((skb->len - header_size) == EAPOL4_PACKET_LEN - 2)) {
255 data_desc->misc_flags |=
256 RSI_DESC_REQUIRE_CFM_TO_HOST;
257 xtend_desc->confirm_frame_type = EAPOL4_CONFIRM;
261 data_desc->mac_flags |= cpu_to_le16(seq_num & 0xfff);
262 data_desc->qid_tid = ((skb->priority & 0xf) |
263 ((tx_params->tid & 0xf) << 4));
264 data_desc->sta_id = tx_params->sta_id;
266 if ((is_broadcast_ether_addr(wh->addr1)) ||
267 (is_multicast_ether_addr(wh->addr1))) {
268 data_desc->frame_info = cpu_to_le16(RATE_INFO_ENABLE);
269 data_desc->frame_info |= cpu_to_le16(RSI_BROADCAST_PKT);
270 data_desc->sta_id = vap_id;
272 if ((vif->type == NL80211_IFTYPE_AP) ||
273 (vif->type == NL80211_IFTYPE_P2P_GO)) {
274 if (common->band == NL80211_BAND_5GHZ)
275 data_desc->rate_info = cpu_to_le16(RSI_RATE_6);
277 data_desc->rate_info = cpu_to_le16(RSI_RATE_1);
280 if (((vif->type == NL80211_IFTYPE_AP) ||
281 (vif->type == NL80211_IFTYPE_P2P_GO)) &&
282 (ieee80211_has_moredata(wh->frame_control)))
283 data_desc->frame_info |= cpu_to_le16(MORE_DATA_PRESENT);
285 data_desc->rate_info |=
286 cpu_to_le16((tx_params->vap_id << RSI_DESC_VAP_ID_OFST) &
287 RSI_DESC_VAP_ID_MASK);
292 /* This function sends received data packet from driver to device */
293 int rsi_send_data_pkt(struct rsi_common *common, struct sk_buff *skb)
295 struct rsi_hw *adapter = common->priv;
296 struct ieee80211_vif *vif;
297 struct ieee80211_tx_info *info;
298 struct ieee80211_bss_conf *bss;
299 int status = -EINVAL;
303 if (common->iface_down)
306 info = IEEE80211_SKB_CB(skb);
307 if (!info->control.vif)
309 vif = info->control.vif;
310 bss = &vif->bss_conf;
312 if (((vif->type == NL80211_IFTYPE_STATION) ||
313 (vif->type == NL80211_IFTYPE_P2P_CLIENT)) &&
317 status = rsi_send_pkt_to_bus(common, skb);
319 rsi_dbg(ERR_ZONE, "%s: Failed to write pkt\n", __func__);
322 ++common->tx_stats.total_tx_pkt_freed[skb->priority];
323 rsi_indicate_tx_status(adapter, skb, status);
328 * rsi_send_mgmt_pkt() - This functions sends the received management packet
329 * from driver to device.
330 * @common: Pointer to the driver private structure.
331 * @skb: Pointer to the socket buffer structure.
333 * Return: status: 0 on success, -1 on failure.
335 int rsi_send_mgmt_pkt(struct rsi_common *common,
338 struct rsi_hw *adapter = common->priv;
339 struct ieee80211_bss_conf *bss;
340 struct ieee80211_hdr *wh;
341 struct ieee80211_tx_info *info;
342 struct skb_info *tx_params;
343 struct rsi_mgmt_desc *mgmt_desc;
344 struct rsi_xtended_desc *xtend_desc;
348 info = IEEE80211_SKB_CB(skb);
349 tx_params = (struct skb_info *)info->driver_data;
350 header_size = tx_params->internal_hdr_size;
352 if (tx_params->flags & INTERNAL_MGMT_PKT) {
353 status = adapter->host_intf_ops->write_pkt(common->priv,
358 "%s: Failed to write the packet\n", __func__);
364 bss = &info->control.vif->bss_conf;
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];
369 /* Indicate to firmware to give cfm for probe */
370 if (ieee80211_is_probe_req(wh->frame_control) && !bss->assoc) {
372 "%s: blocking mgmt queue\n", __func__);
373 mgmt_desc->misc_flags = RSI_DESC_REQUIRE_CFM_TO_HOST;
374 xtend_desc->confirm_frame_type = PROBEREQ_CONFIRM;
375 common->mgmt_q_block = true;
376 rsi_dbg(INFO_ZONE, "Mgmt queue blocked\n");
379 status = rsi_send_pkt_to_bus(common, skb);
381 rsi_dbg(ERR_ZONE, "%s: Failed to write the packet\n", __func__);
383 rsi_indicate_tx_status(common->priv, skb, status);
387 int rsi_send_bt_pkt(struct rsi_common *common, struct sk_buff *skb)
389 int status = -EINVAL;
391 struct rsi_bt_desc *bt_desc;
392 u8 queueno = ((skb->data[1] >> 4) & 0xf);
394 if (queueno == RSI_BT_MGMT_Q) {
395 status = rsi_send_pkt_to_bus(common, skb);
397 rsi_dbg(ERR_ZONE, "%s: Failed to write bt mgmt pkt\n",
401 header_size = FRAME_DESC_SZ;
402 if (header_size > skb_headroom(skb)) {
403 rsi_dbg(ERR_ZONE, "%s: Not enough headroom\n", __func__);
407 skb_push(skb, header_size);
408 memset(skb->data, 0, header_size);
409 bt_desc = (struct rsi_bt_desc *)skb->data;
411 rsi_set_len_qno(&bt_desc->len_qno, (skb->len - FRAME_DESC_SZ),
413 bt_desc->bt_pkt_type = cpu_to_le16(bt_cb(skb)->pkt_type);
415 status = rsi_send_pkt_to_bus(common, skb);
417 rsi_dbg(ERR_ZONE, "%s: Failed to write bt pkt\n", __func__);
424 int rsi_prepare_beacon(struct rsi_common *common, struct sk_buff *skb)
426 struct rsi_hw *adapter = (struct rsi_hw *)common->priv;
427 struct rsi_data_desc *bcn_frm;
428 struct ieee80211_hw *hw = common->priv->hw;
429 struct ieee80211_conf *conf = &hw->conf;
430 struct ieee80211_vif *vif;
431 struct sk_buff *mac_bcn;
435 for (i = 0; i < RSI_MAX_VIFS; i++) {
436 vif = adapter->vifs[i];
439 if ((vif->type == NL80211_IFTYPE_AP) ||
440 (vif->type == NL80211_IFTYPE_P2P_GO))
445 mac_bcn = ieee80211_beacon_get_tim(adapter->hw,
449 rsi_dbg(ERR_ZONE, "Failed to get beacon from mac80211\n");
453 common->beacon_cnt++;
454 bcn_frm = (struct rsi_data_desc *)skb->data;
455 rsi_set_len_qno(&bcn_frm->len_qno, mac_bcn->len, RSI_WIFI_DATA_Q);
456 bcn_frm->header_len = MIN_802_11_HDR_LEN;
457 bcn_frm->frame_info = cpu_to_le16(RSI_DATA_DESC_MAC_BBP_INFO |
458 RSI_DATA_DESC_NO_ACK_IND |
459 RSI_DATA_DESC_BEACON_FRAME |
460 RSI_DATA_DESC_INSERT_TSF |
461 RSI_DATA_DESC_INSERT_SEQ_NO |
463 bcn_frm->rate_info = cpu_to_le16(vap_id << 14);
464 bcn_frm->qid_tid = BEACON_HW_Q;
466 if (conf_is_ht40_plus(conf)) {
467 bcn_frm->bbp_info = cpu_to_le16(LOWER_20_ENABLE);
468 bcn_frm->bbp_info |= cpu_to_le16(LOWER_20_ENABLE >> 12);
469 } else if (conf_is_ht40_minus(conf)) {
470 bcn_frm->bbp_info = cpu_to_le16(UPPER_20_ENABLE);
471 bcn_frm->bbp_info |= cpu_to_le16(UPPER_20_ENABLE >> 12);
474 if (common->band == NL80211_BAND_2GHZ)
475 bcn_frm->rate_info |= cpu_to_le16(RSI_RATE_1);
477 bcn_frm->rate_info |= cpu_to_le16(RSI_RATE_6);
479 if (mac_bcn->data[tim_offset + 2] == 0)
480 bcn_frm->frame_info |= cpu_to_le16(RSI_DATA_DESC_DTIM_BEACON);
482 memcpy(&skb->data[FRAME_DESC_SZ], mac_bcn->data, mac_bcn->len);
483 skb_put(skb, mac_bcn->len + FRAME_DESC_SZ);
485 dev_kfree_skb(mac_bcn);
490 static void bl_cmd_timeout(struct timer_list *t)
492 struct rsi_hw *adapter = from_timer(adapter, t, bl_cmd_timer);
494 adapter->blcmd_timer_expired = true;
495 del_timer(&adapter->bl_cmd_timer);
498 static int bl_start_cmd_timer(struct rsi_hw *adapter, u32 timeout)
500 timer_setup(&adapter->bl_cmd_timer, bl_cmd_timeout, 0);
501 adapter->bl_cmd_timer.expires = (msecs_to_jiffies(timeout) + jiffies);
503 adapter->blcmd_timer_expired = false;
504 add_timer(&adapter->bl_cmd_timer);
509 static int bl_stop_cmd_timer(struct rsi_hw *adapter)
511 adapter->blcmd_timer_expired = false;
512 if (timer_pending(&adapter->bl_cmd_timer))
513 del_timer(&adapter->bl_cmd_timer);
518 static int bl_write_cmd(struct rsi_hw *adapter, u8 cmd, u8 exp_resp,
521 struct rsi_host_intf_ops *hif_ops = adapter->host_intf_ops;
522 u32 regin_val = 0, regout_val = 0;
527 regin_input = (REGIN_INPUT | adapter->priv->coex_mode);
529 while (!adapter->blcmd_timer_expired) {
531 status = hif_ops->master_reg_read(adapter, SWBL_REGIN,
535 "%s: Command %0x REGIN reading failed..\n",
540 if ((regin_val >> 12) != REGIN_VALID)
543 if (adapter->blcmd_timer_expired) {
545 "%s: Command %0x REGIN reading timed out..\n",
551 "Issuing write to Regin val:%0x sending cmd:%0x\n",
552 regin_val, (cmd | regin_input << 8));
553 status = hif_ops->master_reg_write(adapter, SWBL_REGIN,
554 (cmd | regin_input << 8), 2);
559 if (cmd == LOAD_HOSTED_FW || cmd == JUMP_TO_ZERO_PC) {
560 /* JUMP_TO_ZERO_PC doesn't expect
561 * any response. So return from here
566 while (!adapter->blcmd_timer_expired) {
568 status = hif_ops->master_reg_read(adapter, SWBL_REGOUT,
572 "%s: Command %0x REGOUT reading failed..\n",
577 if ((regout_val >> 8) == REGOUT_VALID)
580 if (adapter->blcmd_timer_expired) {
582 "%s: Command %0x REGOUT reading timed out..\n",
587 *cmd_resp = ((u16 *)®out_val)[0] & 0xffff;
589 output = ((u8 *)®out_val)[0] & 0xff;
591 status = hif_ops->master_reg_write(adapter, SWBL_REGOUT,
592 (cmd | REGOUT_INVALID << 8), 2);
595 "%s: Command %0x REGOUT writing failed..\n",
601 if (output != exp_resp) {
603 "%s: Recvd resp %x for cmd %0x\n",
604 __func__, output, cmd);
608 "%s: Recvd Expected resp %x for cmd %0x\n",
609 __func__, output, cmd);
614 static int bl_cmd(struct rsi_hw *adapter, u8 cmd, u8 exp_resp, char *str)
620 if ((cmd == EOF_REACHED) || (cmd == PING_VALID) || (cmd == PONG_VALID))
621 timeout = BL_BURN_TIMEOUT;
623 timeout = BL_CMD_TIMEOUT;
625 bl_start_cmd_timer(adapter, timeout);
626 status = bl_write_cmd(adapter, cmd, exp_resp, ®out_val);
628 bl_stop_cmd_timer(adapter);
630 "%s: Command %s (%0x) writing failed..\n",
634 bl_stop_cmd_timer(adapter);
638 #define CHECK_SUM_OFFSET 20
640 #define ADDR_OFFSET 16
641 static int bl_write_header(struct rsi_hw *adapter, u8 *flash_content,
644 struct rsi_host_intf_ops *hif_ops = adapter->host_intf_ops;
645 struct bl_header *bl_hdr;
646 u32 write_addr, write_len;
649 bl_hdr = kzalloc(sizeof(*bl_hdr), GFP_KERNEL);
654 bl_hdr->image_no = cpu_to_le32(adapter->priv->coex_mode);
656 cpu_to_le32(*(u32 *)&flash_content[CHECK_SUM_OFFSET]);
657 bl_hdr->flash_start_address =
658 cpu_to_le32(*(u32 *)&flash_content[ADDR_OFFSET]);
659 bl_hdr->flash_len = cpu_to_le32(*(u32 *)&flash_content[LEN_OFFSET]);
660 write_len = sizeof(struct bl_header);
662 if (adapter->rsi_host_intf == RSI_HOST_INTF_USB) {
663 write_addr = PING_BUFFER_ADDRESS;
664 status = hif_ops->write_reg_multiple(adapter, write_addr,
665 (u8 *)bl_hdr, write_len);
668 "%s: Failed to load Version/CRC structure\n",
673 write_addr = PING_BUFFER_ADDRESS >> 16;
674 status = hif_ops->master_access_msword(adapter, write_addr);
677 "%s: Unable to set ms word to common reg\n",
681 write_addr = RSI_SD_REQUEST_MASTER |
682 (PING_BUFFER_ADDRESS & 0xFFFF);
683 status = hif_ops->write_reg_multiple(adapter, write_addr,
684 (u8 *)bl_hdr, write_len);
687 "%s: Failed to load Version/CRC structure\n",
698 static u32 read_flash_capacity(struct rsi_hw *adapter)
702 if ((adapter->host_intf_ops->master_reg_read(adapter, FLASH_SIZE_ADDR,
703 &flash_sz, 2)) < 0) {
705 "%s: Flash size reading failed..\n",
709 rsi_dbg(INIT_ZONE, "Flash capacity: %d KiloBytes\n", flash_sz);
711 return (flash_sz * 1024); /* Return size in kbytes */
714 static int ping_pong_write(struct rsi_hw *adapter, u8 cmd, u8 *addr, u32 size)
716 struct rsi_host_intf_ops *hif_ops = adapter->host_intf_ops;
717 u32 block_size = adapter->block_size;
719 u16 cmd_resp, cmd_req;
723 if (cmd == PING_WRITE) {
724 cmd_addr = PING_BUFFER_ADDRESS;
725 cmd_resp = PONG_AVAIL;
726 cmd_req = PING_VALID;
729 cmd_addr = PONG_BUFFER_ADDRESS;
730 cmd_resp = PING_AVAIL;
731 cmd_req = PONG_VALID;
735 status = hif_ops->load_data_master_write(adapter, cmd_addr, size,
738 rsi_dbg(ERR_ZONE, "%s: Unable to write blk at addr %0x\n",
743 status = bl_cmd(adapter, cmd_req, cmd_resp, str);
750 static int auto_fw_upgrade(struct rsi_hw *adapter, u8 *flash_content,
754 u32 temp_content_size, num_flash, index;
755 u32 flash_start_address;
758 if (content_size > MAX_FLASH_FILE_SIZE) {
760 "%s: Flash Content size is more than 400K %u\n",
761 __func__, MAX_FLASH_FILE_SIZE);
765 flash_start_address = *(u32 *)&flash_content[FLASH_START_ADDRESS];
766 rsi_dbg(INFO_ZONE, "flash start address: %08x\n", flash_start_address);
768 if (flash_start_address < FW_IMAGE_MIN_ADDRESS) {
770 "%s: Fw image Flash Start Address is less than 64K\n",
775 if (flash_start_address % FLASH_SECTOR_SIZE) {
777 "%s: Flash Start Address is not multiple of 4K\n",
782 if ((flash_start_address + content_size) > adapter->flash_capacity) {
784 "%s: Flash Content will cross max flash size\n",
789 temp_content_size = content_size;
790 num_flash = content_size / FLASH_WRITE_CHUNK_SIZE;
792 rsi_dbg(INFO_ZONE, "content_size: %d, num_flash: %d\n",
793 content_size, num_flash);
795 for (index = 0; index <= num_flash; index++) {
796 rsi_dbg(INFO_ZONE, "flash index: %d\n", index);
797 if (index != num_flash) {
798 content_size = FLASH_WRITE_CHUNK_SIZE;
799 rsi_dbg(INFO_ZONE, "QSPI content_size:%d\n",
803 temp_content_size % FLASH_WRITE_CHUNK_SIZE;
805 "Writing last sector content_size:%d\n",
808 rsi_dbg(INFO_ZONE, "instruction size zero\n");
818 status = ping_pong_write(adapter, cmd, flash_content,
821 rsi_dbg(ERR_ZONE, "%s: Unable to load %d block\n",
827 "%s: Successfully loaded %d instructions\n",
829 flash_content += content_size;
832 status = bl_cmd(adapter, EOF_REACHED, FW_LOADING_SUCCESSFUL,
837 rsi_dbg(INFO_ZONE, "FW loading is done and FW is running..\n");
841 static int rsi_hal_prepare_fwload(struct rsi_hw *adapter)
843 struct rsi_host_intf_ops *hif_ops = adapter->host_intf_ops;
847 bl_start_cmd_timer(adapter, BL_CMD_TIMEOUT);
849 while (!adapter->blcmd_timer_expired) {
850 status = hif_ops->master_reg_read(adapter, SWBL_REGOUT,
852 RSI_COMMON_REG_SIZE);
854 bl_stop_cmd_timer(adapter);
856 "%s: REGOUT read failed\n", __func__);
860 if ((regout_val >> 8) == REGOUT_VALID)
863 if (adapter->blcmd_timer_expired) {
864 rsi_dbg(ERR_ZONE, "%s: REGOUT read timedout\n", __func__);
866 "%s: Soft boot loader not present\n", __func__);
869 bl_stop_cmd_timer(adapter);
871 rsi_dbg(INFO_ZONE, "Received Board Version Number: %x\n",
872 (regout_val & 0xff));
874 status = hif_ops->master_reg_write(adapter, SWBL_REGOUT,
876 REGOUT_INVALID << 8),
877 RSI_COMMON_REG_SIZE);
879 rsi_dbg(ERR_ZONE, "%s: REGOUT writing failed..\n", __func__);
882 "===> Device is ready to load firmware <===\n");
887 static int rsi_load_9113_firmware(struct rsi_hw *adapter)
889 struct rsi_common *common = adapter->priv;
890 const struct firmware *fw_entry = NULL;
892 u16 tmp_regout_val = 0;
893 struct ta_metadata *metadata_p;
896 status = bl_cmd(adapter, CONFIG_AUTO_READ_MODE, CMD_PASS,
901 adapter->flash_capacity = read_flash_capacity(adapter);
902 if (adapter->flash_capacity <= 0) {
904 "%s: Unable to read flash size from EEPROM\n",
909 metadata_p = &metadata_flash_content[adapter->priv->coex_mode];
911 rsi_dbg(INIT_ZONE, "%s: Loading file %s\n", __func__, metadata_p->name);
912 adapter->fw_file_name = metadata_p->name;
914 status = reject_firmware(&fw_entry, metadata_p->name, adapter->device);
916 rsi_dbg(ERR_ZONE, "%s: Failed to open file %s\n",
917 __func__, metadata_p->name);
920 content_size = fw_entry->size;
921 rsi_dbg(INFO_ZONE, "FW Length = %d bytes\n", content_size);
923 /* Get the firmware version */
924 common->lmac_ver.ver.info.fw_ver[0] =
925 fw_entry->data[LMAC_VER_OFFSET_9113] & 0xFF;
926 common->lmac_ver.ver.info.fw_ver[1] =
927 fw_entry->data[LMAC_VER_OFFSET_9113 + 1] & 0xFF;
928 common->lmac_ver.major =
929 fw_entry->data[LMAC_VER_OFFSET_9113 + 2] & 0xFF;
930 common->lmac_ver.release_num =
931 fw_entry->data[LMAC_VER_OFFSET_9113 + 3] & 0xFF;
932 common->lmac_ver.minor =
933 fw_entry->data[LMAC_VER_OFFSET_9113 + 4] & 0xFF;
934 common->lmac_ver.patch_num = 0;
935 rsi_print_version(common);
937 status = bl_write_header(adapter, (u8 *)fw_entry->data, content_size);
940 "%s: RPS Image header loading failed\n",
945 bl_start_cmd_timer(adapter, BL_CMD_TIMEOUT);
946 status = bl_write_cmd(adapter, CHECK_CRC, CMD_PASS, &tmp_regout_val);
948 bl_stop_cmd_timer(adapter);
950 "%s: CHECK_CRC Command writing failed..\n",
952 if ((tmp_regout_val & 0xff) == CMD_FAIL) {
954 "CRC Fail.. Proceeding to Upgrade mode\n");
958 bl_stop_cmd_timer(adapter);
960 status = bl_cmd(adapter, POLLING_MODE, CMD_PASS, "POLLING_MODE");
965 status = bl_cmd(adapter, LOAD_HOSTED_FW, LOADING_INITIATED,
969 rsi_dbg(INFO_ZONE, "Load Image command passed..\n");
973 status = bl_cmd(adapter, BURN_HOSTED_FW, SEND_RPS_FILE, "FW_UPGRADE");
977 rsi_dbg(INFO_ZONE, "Burn Command Pass.. Upgrading the firmware\n");
979 status = auto_fw_upgrade(adapter, (u8 *)fw_entry->data, content_size);
981 rsi_dbg(ERR_ZONE, "Firmware upgradation Done\n");
984 rsi_dbg(ERR_ZONE, "Firmware upgrade failed\n");
986 status = bl_cmd(adapter, CONFIG_AUTO_READ_MODE, CMD_PASS,
992 rsi_dbg(ERR_ZONE, "***** Firmware Loading successful *****\n");
993 release_firmware(fw_entry);
997 rsi_dbg(ERR_ZONE, "##### Firmware loading failed #####\n");
998 release_firmware(fw_entry);
1002 static int rsi_load_9116_firmware(struct rsi_hw *adapter)
1004 struct rsi_common *common = adapter->priv;
1005 struct rsi_host_intf_ops *hif_ops = adapter->host_intf_ops;
1006 const struct firmware *fw_entry;
1007 struct ta_metadata *metadata_p;
1008 u8 *ta_firmware, *fw_p;
1009 struct bootload_ds bootload_ds;
1010 u32 instructions_sz, base_address;
1011 u16 block_size = adapter->block_size;
1015 rsi_dbg(INIT_ZONE, "***** Load 9116 TA Instructions *****\n");
1017 if (adapter->rsi_host_intf == RSI_HOST_INTF_USB) {
1018 status = bl_cmd(adapter, POLLING_MODE, CMD_PASS,
1024 status = hif_ops->master_reg_write(adapter, MEM_ACCESS_CTRL_FROM_HOST,
1025 RAM_384K_ACCESS_FROM_TA,
1028 rsi_dbg(ERR_ZONE, "%s: Unable to access full RAM memory\n",
1033 metadata_p = &metadata[adapter->priv->coex_mode];
1034 rsi_dbg(INIT_ZONE, "%s: loading file %s\n", __func__, metadata_p->name);
1035 status = reject_firmware(&fw_entry, metadata_p->name, adapter->device);
1037 rsi_dbg(ERR_ZONE, "%s: Failed to open file %s\n",
1038 __func__, metadata_p->name);
1042 ta_firmware = kmemdup(fw_entry->data, fw_entry->size, GFP_KERNEL);
1045 goto fail_release_fw;
1048 instructions_sz = fw_entry->size;
1049 rsi_dbg(INFO_ZONE, "FW Length = %d bytes\n", instructions_sz);
1051 common->lmac_ver.major = ta_firmware[LMAC_VER_OFFSET_9116];
1052 common->lmac_ver.minor = ta_firmware[LMAC_VER_OFFSET_9116 + 1];
1053 common->lmac_ver.release_num = ta_firmware[LMAC_VER_OFFSET_9116 + 2];
1054 common->lmac_ver.patch_num = ta_firmware[LMAC_VER_OFFSET_9116 + 3];
1055 common->lmac_ver.ver.info.fw_ver[0] =
1056 ta_firmware[LMAC_VER_OFFSET_9116 + 4];
1058 if (instructions_sz % FW_ALIGN_SIZE)
1060 (FW_ALIGN_SIZE - (instructions_sz % FW_ALIGN_SIZE));
1061 rsi_dbg(INFO_ZONE, "instructions_sz : %d\n", instructions_sz);
1063 if (*(u16 *)fw_p == RSI_9116_FW_MAGIC_WORD) {
1064 memcpy(&bootload_ds, fw_p, sizeof(struct bootload_ds));
1065 fw_p += le16_to_cpu(bootload_ds.offset);
1066 rsi_dbg(INFO_ZONE, "FW start = %x\n", *(u32 *)fw_p);
1070 rsi_dbg(ERR_ZONE, "%s: Loading chunk %d\n",
1073 dest = le32_to_cpu(bootload_ds.bl_entry[cnt].dst_addr);
1074 len = le32_to_cpu(bootload_ds.bl_entry[cnt].control) &
1075 RSI_BL_CTRL_LEN_MASK;
1076 rsi_dbg(INFO_ZONE, "length %d destination %x\n",
1079 status = hif_ops->load_data_master_write(adapter, dest,
1085 "Failed to load chunk %d\n", cnt);
1089 if (le32_to_cpu(bootload_ds.bl_entry[cnt].control) &
1090 RSI_BL_CTRL_LAST_ENTRY)
1095 base_address = metadata_p->address;
1096 status = hif_ops->load_data_master_write(adapter,
1104 "%s: Unable to load %s blk\n",
1105 __func__, metadata_p->name);
1109 rsi_dbg(INIT_ZONE, "%s: Successfully loaded %s instructions\n",
1110 __func__, metadata_p->name);
1112 if (adapter->rsi_host_intf == RSI_HOST_INTF_SDIO) {
1113 if (hif_ops->ta_reset(adapter))
1114 rsi_dbg(ERR_ZONE, "Unable to put ta in reset\n");
1116 if (bl_cmd(adapter, JUMP_TO_ZERO_PC,
1117 CMD_PASS, "JUMP_TO_ZERO") < 0)
1118 rsi_dbg(INFO_ZONE, "Jump to zero command failed\n");
1120 rsi_dbg(INFO_ZONE, "Jump to zero command successful\n");
1126 release_firmware(fw_entry);
1131 int rsi_hal_device_init(struct rsi_hw *adapter)
1133 struct rsi_common *common = adapter->priv;
1136 switch (adapter->device_model) {
1138 status = rsi_hal_prepare_fwload(adapter);
1141 if (rsi_load_9113_firmware(adapter)) {
1143 "%s: Failed to load TA instructions\n",
1149 status = rsi_hal_prepare_fwload(adapter);
1152 if (rsi_load_9116_firmware(adapter)) {
1154 "%s: Failed to load firmware to 9116 device\n",
1162 common->fsm_state = FSM_CARD_NOT_READY;
1166 EXPORT_SYMBOL_GPL(rsi_hal_device_init);