| 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 = timer_container_of(adapter, t, bl_cmd_timer); |
| 494 |
|
| 495 |
adapter->blcmd_timer_expired = true; |
| 496 |
timer_delete(&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 |
timer_delete(&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 |
®in_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 |
®out_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 *)®out_val)[0] & 0xffff; |
| 589 |
|
| 590 |
output = ((u8 *)®out_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, ®out_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_obj(*bl_hdr); |
| 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 |
®out_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 |
|