1 | // SPDX-License-Identifier: ISC |
2 | /* |
3 | * Copyright (c) 2018 The Linux Foundation. All rights reserved. |
4 | * Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved. |
5 | */ |
6 | |
7 | #include <linux/completion.h> |
8 | #include <linux/device.h> |
9 | #include <linux/debugfs.h> |
10 | #include <linux/idr.h> |
11 | #include <linux/kernel.h> |
12 | #include <linux/of.h> |
13 | #include <linux/of_address.h> |
14 | #include <linux/module.h> |
15 | #include <linux/net.h> |
16 | #include <linux/platform_device.h> |
17 | #include <linux/firmware/qcom/qcom_scm.h> |
18 | #include <linux/soc/qcom/smem.h> |
19 | #include <linux/string.h> |
20 | #include <net/sock.h> |
21 | |
22 | #include "debug.h" |
23 | #include "snoc.h" |
24 | |
25 | #define ATH10K_QMI_CLIENT_ID 0x4b4e454c |
26 | #define ATH10K_QMI_TIMEOUT 30 |
27 | #define SMEM_IMAGE_VERSION_TABLE 469 |
28 | #define SMEM_IMAGE_TABLE_CNSS_INDEX 13 |
29 | #define SMEM_IMAGE_VERSION_ENTRY_SIZE 128 |
30 | #define SMEM_IMAGE_VERSION_NAME_SIZE 75 |
31 | |
32 | static int ath10k_qmi_map_msa_permission(struct ath10k_qmi *qmi, |
33 | struct ath10k_msa_mem_info *mem_info) |
34 | { |
35 | struct qcom_scm_vmperm dst_perms[3]; |
36 | struct ath10k *ar = qmi->ar; |
37 | u64 src_perms; |
38 | u32 perm_count; |
39 | int ret; |
40 | |
41 | src_perms = BIT(QCOM_SCM_VMID_HLOS); |
42 | |
43 | dst_perms[0].vmid = QCOM_SCM_VMID_MSS_MSA; |
44 | dst_perms[0].perm = QCOM_SCM_PERM_RW; |
45 | dst_perms[1].vmid = QCOM_SCM_VMID_WLAN; |
46 | dst_perms[1].perm = QCOM_SCM_PERM_RW; |
47 | |
48 | if (mem_info->secure) { |
49 | perm_count = 2; |
50 | } else { |
51 | dst_perms[2].vmid = QCOM_SCM_VMID_WLAN_CE; |
52 | dst_perms[2].perm = QCOM_SCM_PERM_RW; |
53 | perm_count = 3; |
54 | } |
55 | |
56 | ret = qcom_scm_assign_mem(mem_addr: mem_info->addr, mem_sz: mem_info->size, |
57 | src: &src_perms, newvm: dst_perms, dest_cnt: perm_count); |
58 | if (ret < 0) |
59 | ath10k_err(ar, fmt: "failed to assign msa map permissions: %d\n" , ret); |
60 | |
61 | return ret; |
62 | } |
63 | |
64 | static int ath10k_qmi_unmap_msa_permission(struct ath10k_qmi *qmi, |
65 | struct ath10k_msa_mem_info *mem_info) |
66 | { |
67 | struct qcom_scm_vmperm dst_perms; |
68 | struct ath10k *ar = qmi->ar; |
69 | u64 src_perms; |
70 | int ret; |
71 | |
72 | src_perms = BIT(QCOM_SCM_VMID_MSS_MSA) | BIT(QCOM_SCM_VMID_WLAN); |
73 | |
74 | if (!mem_info->secure) |
75 | src_perms |= BIT(QCOM_SCM_VMID_WLAN_CE); |
76 | |
77 | dst_perms.vmid = QCOM_SCM_VMID_HLOS; |
78 | dst_perms.perm = QCOM_SCM_PERM_RW; |
79 | |
80 | ret = qcom_scm_assign_mem(mem_addr: mem_info->addr, mem_sz: mem_info->size, |
81 | src: &src_perms, newvm: &dst_perms, dest_cnt: 1); |
82 | if (ret < 0) |
83 | ath10k_err(ar, fmt: "failed to unmap msa permissions: %d\n" , ret); |
84 | |
85 | return ret; |
86 | } |
87 | |
88 | static int ath10k_qmi_setup_msa_permissions(struct ath10k_qmi *qmi) |
89 | { |
90 | int ret; |
91 | int i; |
92 | |
93 | if (qmi->msa_fixed_perm) |
94 | return 0; |
95 | |
96 | for (i = 0; i < qmi->nr_mem_region; i++) { |
97 | ret = ath10k_qmi_map_msa_permission(qmi, mem_info: &qmi->mem_region[i]); |
98 | if (ret) |
99 | goto err_unmap; |
100 | } |
101 | |
102 | return 0; |
103 | |
104 | err_unmap: |
105 | for (i--; i >= 0; i--) |
106 | ath10k_qmi_unmap_msa_permission(qmi, mem_info: &qmi->mem_region[i]); |
107 | return ret; |
108 | } |
109 | |
110 | static void ath10k_qmi_remove_msa_permission(struct ath10k_qmi *qmi) |
111 | { |
112 | int i; |
113 | |
114 | if (qmi->msa_fixed_perm) |
115 | return; |
116 | |
117 | for (i = 0; i < qmi->nr_mem_region; i++) |
118 | ath10k_qmi_unmap_msa_permission(qmi, mem_info: &qmi->mem_region[i]); |
119 | } |
120 | |
121 | static int ath10k_qmi_msa_mem_info_send_sync_msg(struct ath10k_qmi *qmi) |
122 | { |
123 | struct wlfw_msa_info_resp_msg_v01 resp = {}; |
124 | struct wlfw_msa_info_req_msg_v01 req = {}; |
125 | struct ath10k *ar = qmi->ar; |
126 | phys_addr_t max_mapped_addr; |
127 | struct qmi_txn txn; |
128 | int ret; |
129 | int i; |
130 | |
131 | req.msa_addr = ar->msa.paddr; |
132 | req.size = ar->msa.mem_size; |
133 | |
134 | ret = qmi_txn_init(qmi: &qmi->qmi_hdl, txn: &txn, |
135 | ei: wlfw_msa_info_resp_msg_v01_ei, c_struct: &resp); |
136 | if (ret < 0) |
137 | goto out; |
138 | |
139 | ret = qmi_send_request(qmi: &qmi->qmi_hdl, NULL, txn: &txn, |
140 | QMI_WLFW_MSA_INFO_REQ_V01, |
141 | WLFW_MSA_INFO_REQ_MSG_V01_MAX_MSG_LEN, |
142 | ei: wlfw_msa_info_req_msg_v01_ei, c_struct: &req); |
143 | if (ret < 0) { |
144 | qmi_txn_cancel(txn: &txn); |
145 | ath10k_err(ar, fmt: "failed to send msa mem info req: %d\n" , ret); |
146 | goto out; |
147 | } |
148 | |
149 | ret = qmi_txn_wait(txn: &txn, ATH10K_QMI_TIMEOUT * HZ); |
150 | if (ret < 0) |
151 | goto out; |
152 | |
153 | if (resp.resp.result != QMI_RESULT_SUCCESS_V01) { |
154 | ath10k_err(ar, fmt: "msa info req rejected: %d\n" , resp.resp.error); |
155 | ret = -EINVAL; |
156 | goto out; |
157 | } |
158 | |
159 | if (resp.mem_region_info_len > QMI_WLFW_MAX_MEM_REG_V01) { |
160 | ath10k_err(ar, fmt: "invalid memory region length received: %d\n" , |
161 | resp.mem_region_info_len); |
162 | ret = -EINVAL; |
163 | goto out; |
164 | } |
165 | |
166 | max_mapped_addr = ar->msa.paddr + ar->msa.mem_size; |
167 | qmi->nr_mem_region = resp.mem_region_info_len; |
168 | for (i = 0; i < resp.mem_region_info_len; i++) { |
169 | if (resp.mem_region_info[i].size > ar->msa.mem_size || |
170 | resp.mem_region_info[i].region_addr > max_mapped_addr || |
171 | resp.mem_region_info[i].region_addr < ar->msa.paddr || |
172 | resp.mem_region_info[i].size + |
173 | resp.mem_region_info[i].region_addr > max_mapped_addr) { |
174 | ath10k_err(ar, fmt: "received out of range memory region address 0x%llx with size 0x%x, aborting\n" , |
175 | resp.mem_region_info[i].region_addr, |
176 | resp.mem_region_info[i].size); |
177 | ret = -EINVAL; |
178 | goto fail_unwind; |
179 | } |
180 | qmi->mem_region[i].addr = resp.mem_region_info[i].region_addr; |
181 | qmi->mem_region[i].size = resp.mem_region_info[i].size; |
182 | qmi->mem_region[i].secure = resp.mem_region_info[i].secure_flag; |
183 | ath10k_dbg(ar, ATH10K_DBG_QMI, |
184 | "qmi msa mem region %d addr 0x%pa size 0x%x flag 0x%08x\n" , |
185 | i, &qmi->mem_region[i].addr, |
186 | qmi->mem_region[i].size, |
187 | qmi->mem_region[i].secure); |
188 | } |
189 | |
190 | ath10k_dbg(ar, ATH10K_DBG_QMI, "qmi msa mem info request completed\n" ); |
191 | return 0; |
192 | |
193 | fail_unwind: |
194 | memset(&qmi->mem_region[0], 0, sizeof(qmi->mem_region[0]) * i); |
195 | out: |
196 | return ret; |
197 | } |
198 | |
199 | static int ath10k_qmi_msa_ready_send_sync_msg(struct ath10k_qmi *qmi) |
200 | { |
201 | struct wlfw_msa_ready_resp_msg_v01 resp = {}; |
202 | struct wlfw_msa_ready_req_msg_v01 req = {}; |
203 | struct ath10k *ar = qmi->ar; |
204 | struct qmi_txn txn; |
205 | int ret; |
206 | |
207 | ret = qmi_txn_init(qmi: &qmi->qmi_hdl, txn: &txn, |
208 | ei: wlfw_msa_ready_resp_msg_v01_ei, c_struct: &resp); |
209 | if (ret < 0) |
210 | goto out; |
211 | |
212 | ret = qmi_send_request(qmi: &qmi->qmi_hdl, NULL, txn: &txn, |
213 | QMI_WLFW_MSA_READY_REQ_V01, |
214 | WLFW_MSA_READY_REQ_MSG_V01_MAX_MSG_LEN, |
215 | ei: wlfw_msa_ready_req_msg_v01_ei, c_struct: &req); |
216 | if (ret < 0) { |
217 | qmi_txn_cancel(txn: &txn); |
218 | ath10k_err(ar, fmt: "failed to send msa mem ready request: %d\n" , ret); |
219 | goto out; |
220 | } |
221 | |
222 | ret = qmi_txn_wait(txn: &txn, ATH10K_QMI_TIMEOUT * HZ); |
223 | if (ret < 0) |
224 | goto out; |
225 | |
226 | if (resp.resp.result != QMI_RESULT_SUCCESS_V01) { |
227 | ath10k_err(ar, fmt: "msa ready request rejected: %d\n" , resp.resp.error); |
228 | ret = -EINVAL; |
229 | } |
230 | |
231 | ath10k_dbg(ar, ATH10K_DBG_QMI, "qmi msa mem ready request completed\n" ); |
232 | return 0; |
233 | |
234 | out: |
235 | return ret; |
236 | } |
237 | |
238 | static int ath10k_qmi_bdf_dnld_send_sync(struct ath10k_qmi *qmi) |
239 | { |
240 | struct wlfw_bdf_download_resp_msg_v01 resp = {}; |
241 | struct wlfw_bdf_download_req_msg_v01 *req; |
242 | struct ath10k *ar = qmi->ar; |
243 | unsigned int remaining; |
244 | struct qmi_txn txn; |
245 | const u8 *temp; |
246 | int ret; |
247 | |
248 | req = kzalloc(size: sizeof(*req), GFP_KERNEL); |
249 | if (!req) |
250 | return -ENOMEM; |
251 | |
252 | temp = ar->normal_mode_fw.board_data; |
253 | remaining = ar->normal_mode_fw.board_len; |
254 | |
255 | while (remaining) { |
256 | req->valid = 1; |
257 | req->file_id_valid = 1; |
258 | req->file_id = 0; |
259 | req->total_size_valid = 1; |
260 | req->total_size = ar->normal_mode_fw.board_len; |
261 | req->seg_id_valid = 1; |
262 | req->data_valid = 1; |
263 | req->end_valid = 1; |
264 | |
265 | if (remaining > QMI_WLFW_MAX_DATA_SIZE_V01) { |
266 | req->data_len = QMI_WLFW_MAX_DATA_SIZE_V01; |
267 | } else { |
268 | req->data_len = remaining; |
269 | req->end = 1; |
270 | } |
271 | |
272 | memcpy(req->data, temp, req->data_len); |
273 | |
274 | ret = qmi_txn_init(qmi: &qmi->qmi_hdl, txn: &txn, |
275 | ei: wlfw_bdf_download_resp_msg_v01_ei, |
276 | c_struct: &resp); |
277 | if (ret < 0) |
278 | goto out; |
279 | |
280 | ret = qmi_send_request(qmi: &qmi->qmi_hdl, NULL, txn: &txn, |
281 | QMI_WLFW_BDF_DOWNLOAD_REQ_V01, |
282 | WLFW_BDF_DOWNLOAD_REQ_MSG_V01_MAX_MSG_LEN, |
283 | ei: wlfw_bdf_download_req_msg_v01_ei, c_struct: req); |
284 | if (ret < 0) { |
285 | qmi_txn_cancel(txn: &txn); |
286 | goto out; |
287 | } |
288 | |
289 | ret = qmi_txn_wait(txn: &txn, ATH10K_QMI_TIMEOUT * HZ); |
290 | |
291 | if (ret < 0) |
292 | goto out; |
293 | |
294 | /* end = 1 triggers a CRC check on the BDF. If this fails, we |
295 | * get a QMI_ERR_MALFORMED_MSG_V01 error, but the FW is still |
296 | * willing to use the BDF. For some platforms, all the valid |
297 | * released BDFs fail this CRC check, so attempt to detect this |
298 | * scenario and treat it as non-fatal. |
299 | */ |
300 | if (resp.resp.result != QMI_RESULT_SUCCESS_V01 && |
301 | !(req->end == 1 && |
302 | resp.resp.result == QMI_ERR_MALFORMED_MSG_V01)) { |
303 | ath10k_err(ar, fmt: "failed to download board data file: %d\n" , |
304 | resp.resp.error); |
305 | ret = -EINVAL; |
306 | goto out; |
307 | } |
308 | |
309 | remaining -= req->data_len; |
310 | temp += req->data_len; |
311 | req->seg_id++; |
312 | } |
313 | |
314 | ath10k_dbg(ar, ATH10K_DBG_QMI, "qmi bdf download request completed\n" ); |
315 | |
316 | kfree(objp: req); |
317 | return 0; |
318 | |
319 | out: |
320 | kfree(objp: req); |
321 | return ret; |
322 | } |
323 | |
324 | static int ath10k_qmi_send_cal_report_req(struct ath10k_qmi *qmi) |
325 | { |
326 | struct wlfw_cal_report_resp_msg_v01 resp = {}; |
327 | struct wlfw_cal_report_req_msg_v01 req = {}; |
328 | struct ath10k *ar = qmi->ar; |
329 | struct ath10k_snoc *ar_snoc = ath10k_snoc_priv(ar); |
330 | struct qmi_txn txn; |
331 | int i, j = 0; |
332 | int ret; |
333 | |
334 | if (ar_snoc->xo_cal_supported) { |
335 | req.xo_cal_data_valid = 1; |
336 | req.xo_cal_data = ar_snoc->xo_cal_data; |
337 | } |
338 | |
339 | ret = qmi_txn_init(qmi: &qmi->qmi_hdl, txn: &txn, ei: wlfw_cal_report_resp_msg_v01_ei, |
340 | c_struct: &resp); |
341 | if (ret < 0) |
342 | goto out; |
343 | |
344 | for (i = 0; i < QMI_WLFW_MAX_NUM_CAL_V01; i++) { |
345 | if (qmi->cal_data[i].total_size && |
346 | qmi->cal_data[i].data) { |
347 | req.meta_data[j] = qmi->cal_data[i].cal_id; |
348 | j++; |
349 | } |
350 | } |
351 | req.meta_data_len = j; |
352 | |
353 | ret = qmi_send_request(qmi: &qmi->qmi_hdl, NULL, txn: &txn, |
354 | QMI_WLFW_CAL_REPORT_REQ_V01, |
355 | WLFW_CAL_REPORT_REQ_MSG_V01_MAX_MSG_LEN, |
356 | ei: wlfw_cal_report_req_msg_v01_ei, c_struct: &req); |
357 | if (ret < 0) { |
358 | qmi_txn_cancel(txn: &txn); |
359 | ath10k_err(ar, fmt: "failed to send calibration request: %d\n" , ret); |
360 | goto out; |
361 | } |
362 | |
363 | ret = qmi_txn_wait(txn: &txn, ATH10K_QMI_TIMEOUT * HZ); |
364 | if (ret < 0) |
365 | goto out; |
366 | |
367 | if (resp.resp.result != QMI_RESULT_SUCCESS_V01) { |
368 | ath10k_err(ar, fmt: "calibration request rejected: %d\n" , resp.resp.error); |
369 | ret = -EINVAL; |
370 | goto out; |
371 | } |
372 | |
373 | ath10k_dbg(ar, ATH10K_DBG_QMI, "qmi cal report request completed\n" ); |
374 | return 0; |
375 | |
376 | out: |
377 | return ret; |
378 | } |
379 | |
380 | static int |
381 | ath10k_qmi_mode_send_sync_msg(struct ath10k *ar, enum wlfw_driver_mode_enum_v01 mode) |
382 | { |
383 | struct ath10k_snoc *ar_snoc = ath10k_snoc_priv(ar); |
384 | struct ath10k_qmi *qmi = ar_snoc->qmi; |
385 | struct wlfw_wlan_mode_resp_msg_v01 resp = {}; |
386 | struct wlfw_wlan_mode_req_msg_v01 req = {}; |
387 | struct qmi_txn txn; |
388 | int ret; |
389 | |
390 | ret = qmi_txn_init(qmi: &qmi->qmi_hdl, txn: &txn, |
391 | ei: wlfw_wlan_mode_resp_msg_v01_ei, |
392 | c_struct: &resp); |
393 | if (ret < 0) |
394 | goto out; |
395 | |
396 | req.mode = mode; |
397 | req.hw_debug_valid = 1; |
398 | req.hw_debug = 0; |
399 | |
400 | ret = qmi_send_request(qmi: &qmi->qmi_hdl, NULL, txn: &txn, |
401 | QMI_WLFW_WLAN_MODE_REQ_V01, |
402 | WLFW_WLAN_MODE_REQ_MSG_V01_MAX_MSG_LEN, |
403 | ei: wlfw_wlan_mode_req_msg_v01_ei, c_struct: &req); |
404 | if (ret < 0) { |
405 | qmi_txn_cancel(txn: &txn); |
406 | ath10k_err(ar, fmt: "failed to send wlan mode %d request: %d\n" , mode, ret); |
407 | goto out; |
408 | } |
409 | |
410 | ret = qmi_txn_wait(txn: &txn, ATH10K_QMI_TIMEOUT * HZ); |
411 | if (ret < 0) |
412 | goto out; |
413 | |
414 | if (resp.resp.result != QMI_RESULT_SUCCESS_V01) { |
415 | ath10k_err(ar, fmt: "more request rejected: %d\n" , resp.resp.error); |
416 | ret = -EINVAL; |
417 | goto out; |
418 | } |
419 | |
420 | ath10k_dbg(ar, ATH10K_DBG_QMI, "qmi wlan mode req completed: %d\n" , mode); |
421 | return 0; |
422 | |
423 | out: |
424 | return ret; |
425 | } |
426 | |
427 | static int |
428 | ath10k_qmi_cfg_send_sync_msg(struct ath10k *ar, |
429 | struct ath10k_qmi_wlan_enable_cfg *config, |
430 | const char *version) |
431 | { |
432 | struct ath10k_snoc *ar_snoc = ath10k_snoc_priv(ar); |
433 | struct ath10k_qmi *qmi = ar_snoc->qmi; |
434 | struct wlfw_wlan_cfg_resp_msg_v01 resp = {}; |
435 | struct wlfw_wlan_cfg_req_msg_v01 *req; |
436 | struct qmi_txn txn; |
437 | int ret; |
438 | u32 i; |
439 | |
440 | req = kzalloc(size: sizeof(*req), GFP_KERNEL); |
441 | if (!req) |
442 | return -ENOMEM; |
443 | |
444 | ret = qmi_txn_init(qmi: &qmi->qmi_hdl, txn: &txn, |
445 | ei: wlfw_wlan_cfg_resp_msg_v01_ei, |
446 | c_struct: &resp); |
447 | if (ret < 0) |
448 | goto out; |
449 | |
450 | req->host_version_valid = 0; |
451 | |
452 | req->tgt_cfg_valid = 1; |
453 | if (config->num_ce_tgt_cfg > QMI_WLFW_MAX_NUM_CE_V01) |
454 | req->tgt_cfg_len = QMI_WLFW_MAX_NUM_CE_V01; |
455 | else |
456 | req->tgt_cfg_len = config->num_ce_tgt_cfg; |
457 | for (i = 0; i < req->tgt_cfg_len; i++) { |
458 | req->tgt_cfg[i].pipe_num = config->ce_tgt_cfg[i].pipe_num; |
459 | req->tgt_cfg[i].pipe_dir = config->ce_tgt_cfg[i].pipe_dir; |
460 | req->tgt_cfg[i].nentries = config->ce_tgt_cfg[i].nentries; |
461 | req->tgt_cfg[i].nbytes_max = config->ce_tgt_cfg[i].nbytes_max; |
462 | req->tgt_cfg[i].flags = config->ce_tgt_cfg[i].flags; |
463 | } |
464 | |
465 | req->svc_cfg_valid = 1; |
466 | if (config->num_ce_svc_pipe_cfg > QMI_WLFW_MAX_NUM_SVC_V01) |
467 | req->svc_cfg_len = QMI_WLFW_MAX_NUM_SVC_V01; |
468 | else |
469 | req->svc_cfg_len = config->num_ce_svc_pipe_cfg; |
470 | for (i = 0; i < req->svc_cfg_len; i++) { |
471 | req->svc_cfg[i].service_id = config->ce_svc_cfg[i].service_id; |
472 | req->svc_cfg[i].pipe_dir = config->ce_svc_cfg[i].pipe_dir; |
473 | req->svc_cfg[i].pipe_num = config->ce_svc_cfg[i].pipe_num; |
474 | } |
475 | |
476 | req->shadow_reg_valid = 1; |
477 | if (config->num_shadow_reg_cfg > |
478 | QMI_WLFW_MAX_NUM_SHADOW_REG_V01) |
479 | req->shadow_reg_len = QMI_WLFW_MAX_NUM_SHADOW_REG_V01; |
480 | else |
481 | req->shadow_reg_len = config->num_shadow_reg_cfg; |
482 | |
483 | memcpy(req->shadow_reg, config->shadow_reg_cfg, |
484 | sizeof(struct wlfw_shadow_reg_cfg_s_v01) * req->shadow_reg_len); |
485 | |
486 | ret = qmi_send_request(qmi: &qmi->qmi_hdl, NULL, txn: &txn, |
487 | QMI_WLFW_WLAN_CFG_REQ_V01, |
488 | WLFW_WLAN_CFG_REQ_MSG_V01_MAX_MSG_LEN, |
489 | ei: wlfw_wlan_cfg_req_msg_v01_ei, c_struct: req); |
490 | if (ret < 0) { |
491 | qmi_txn_cancel(txn: &txn); |
492 | ath10k_err(ar, fmt: "failed to send config request: %d\n" , ret); |
493 | goto out; |
494 | } |
495 | |
496 | ret = qmi_txn_wait(txn: &txn, ATH10K_QMI_TIMEOUT * HZ); |
497 | if (ret < 0) |
498 | goto out; |
499 | |
500 | if (resp.resp.result != QMI_RESULT_SUCCESS_V01) { |
501 | ath10k_err(ar, fmt: "config request rejected: %d\n" , resp.resp.error); |
502 | ret = -EINVAL; |
503 | goto out; |
504 | } |
505 | |
506 | ath10k_dbg(ar, ATH10K_DBG_QMI, "qmi config request completed\n" ); |
507 | kfree(objp: req); |
508 | return 0; |
509 | |
510 | out: |
511 | kfree(objp: req); |
512 | return ret; |
513 | } |
514 | |
515 | int ath10k_qmi_wlan_enable(struct ath10k *ar, |
516 | struct ath10k_qmi_wlan_enable_cfg *config, |
517 | enum wlfw_driver_mode_enum_v01 mode, |
518 | const char *version) |
519 | { |
520 | int ret; |
521 | |
522 | ath10k_dbg(ar, ATH10K_DBG_QMI, "qmi mode %d config %p\n" , |
523 | mode, config); |
524 | |
525 | ret = ath10k_qmi_cfg_send_sync_msg(ar, config, version); |
526 | if (ret) { |
527 | ath10k_err(ar, fmt: "failed to send qmi config: %d\n" , ret); |
528 | return ret; |
529 | } |
530 | |
531 | ret = ath10k_qmi_mode_send_sync_msg(ar, mode); |
532 | if (ret) { |
533 | ath10k_err(ar, fmt: "failed to send qmi mode: %d\n" , ret); |
534 | return ret; |
535 | } |
536 | |
537 | return 0; |
538 | } |
539 | |
540 | int ath10k_qmi_wlan_disable(struct ath10k *ar) |
541 | { |
542 | return ath10k_qmi_mode_send_sync_msg(ar, mode: QMI_WLFW_OFF_V01); |
543 | } |
544 | |
545 | static void ath10k_qmi_add_wlan_ver_smem(struct ath10k *ar, const char *fw_build_id) |
546 | { |
547 | u8 *table_ptr; |
548 | size_t smem_item_size; |
549 | const u32 smem_img_idx_wlan = SMEM_IMAGE_TABLE_CNSS_INDEX * |
550 | SMEM_IMAGE_VERSION_ENTRY_SIZE; |
551 | |
552 | table_ptr = qcom_smem_get(QCOM_SMEM_HOST_ANY, |
553 | SMEM_IMAGE_VERSION_TABLE, |
554 | size: &smem_item_size); |
555 | |
556 | if (IS_ERR(ptr: table_ptr)) { |
557 | ath10k_err(ar, fmt: "smem image version table not found\n" ); |
558 | return; |
559 | } |
560 | |
561 | if (smem_img_idx_wlan + SMEM_IMAGE_VERSION_ENTRY_SIZE > |
562 | smem_item_size) { |
563 | ath10k_err(ar, fmt: "smem block size too small: %zu\n" , |
564 | smem_item_size); |
565 | return; |
566 | } |
567 | |
568 | strscpy(table_ptr + smem_img_idx_wlan, fw_build_id, |
569 | SMEM_IMAGE_VERSION_NAME_SIZE); |
570 | } |
571 | |
572 | static int ath10k_qmi_cap_send_sync_msg(struct ath10k_qmi *qmi) |
573 | { |
574 | struct wlfw_cap_resp_msg_v01 *resp; |
575 | struct wlfw_cap_req_msg_v01 req = {}; |
576 | struct ath10k *ar = qmi->ar; |
577 | struct ath10k_snoc *ar_snoc = ath10k_snoc_priv(ar); |
578 | struct qmi_txn txn; |
579 | int ret; |
580 | |
581 | resp = kzalloc(size: sizeof(*resp), GFP_KERNEL); |
582 | if (!resp) |
583 | return -ENOMEM; |
584 | |
585 | ret = qmi_txn_init(qmi: &qmi->qmi_hdl, txn: &txn, ei: wlfw_cap_resp_msg_v01_ei, c_struct: resp); |
586 | if (ret < 0) |
587 | goto out; |
588 | |
589 | ret = qmi_send_request(qmi: &qmi->qmi_hdl, NULL, txn: &txn, |
590 | QMI_WLFW_CAP_REQ_V01, |
591 | WLFW_CAP_REQ_MSG_V01_MAX_MSG_LEN, |
592 | ei: wlfw_cap_req_msg_v01_ei, c_struct: &req); |
593 | if (ret < 0) { |
594 | qmi_txn_cancel(txn: &txn); |
595 | ath10k_err(ar, fmt: "failed to send capability request: %d\n" , ret); |
596 | goto out; |
597 | } |
598 | |
599 | ret = qmi_txn_wait(txn: &txn, ATH10K_QMI_TIMEOUT * HZ); |
600 | if (ret < 0) |
601 | goto out; |
602 | |
603 | if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { |
604 | ath10k_err(ar, fmt: "capability req rejected: %d\n" , resp->resp.error); |
605 | ret = -EINVAL; |
606 | goto out; |
607 | } |
608 | |
609 | if (resp->chip_info_valid) { |
610 | qmi->chip_info.chip_id = resp->chip_info.chip_id; |
611 | qmi->chip_info.chip_family = resp->chip_info.chip_family; |
612 | } else { |
613 | qmi->chip_info.chip_id = 0xFF; |
614 | } |
615 | |
616 | if (resp->board_info_valid) |
617 | qmi->board_info.board_id = resp->board_info.board_id; |
618 | else |
619 | qmi->board_info.board_id = 0xFF; |
620 | |
621 | if (resp->soc_info_valid) |
622 | qmi->soc_info.soc_id = resp->soc_info.soc_id; |
623 | |
624 | if (resp->fw_version_info_valid) { |
625 | qmi->fw_version = resp->fw_version_info.fw_version; |
626 | strscpy(qmi->fw_build_timestamp, resp->fw_version_info.fw_build_timestamp, |
627 | sizeof(qmi->fw_build_timestamp)); |
628 | } |
629 | |
630 | if (resp->fw_build_id_valid) |
631 | strscpy(qmi->fw_build_id, resp->fw_build_id, |
632 | MAX_BUILD_ID_LEN + 1); |
633 | |
634 | if (!test_bit(ATH10K_SNOC_FLAG_REGISTERED, &ar_snoc->flags)) { |
635 | ath10k_info(ar, fmt: "qmi chip_id 0x%x chip_family 0x%x board_id 0x%x soc_id 0x%x" , |
636 | qmi->chip_info.chip_id, qmi->chip_info.chip_family, |
637 | qmi->board_info.board_id, qmi->soc_info.soc_id); |
638 | ath10k_info(ar, fmt: "qmi fw_version 0x%x fw_build_timestamp %s fw_build_id %s" , |
639 | qmi->fw_version, qmi->fw_build_timestamp, qmi->fw_build_id); |
640 | } |
641 | |
642 | if (resp->fw_build_id_valid) |
643 | ath10k_qmi_add_wlan_ver_smem(ar, fw_build_id: qmi->fw_build_id); |
644 | |
645 | kfree(objp: resp); |
646 | return 0; |
647 | |
648 | out: |
649 | kfree(objp: resp); |
650 | return ret; |
651 | } |
652 | |
653 | static int ath10k_qmi_host_cap_send_sync(struct ath10k_qmi *qmi) |
654 | { |
655 | struct wlfw_host_cap_resp_msg_v01 resp = {}; |
656 | struct wlfw_host_cap_req_msg_v01 req = {}; |
657 | const struct qmi_elem_info *req_ei; |
658 | struct ath10k *ar = qmi->ar; |
659 | struct ath10k_snoc *ar_snoc = ath10k_snoc_priv(ar); |
660 | struct qmi_txn txn; |
661 | int ret; |
662 | |
663 | req.daemon_support_valid = 1; |
664 | req.daemon_support = 0; |
665 | |
666 | ret = qmi_txn_init(qmi: &qmi->qmi_hdl, txn: &txn, ei: wlfw_host_cap_resp_msg_v01_ei, |
667 | c_struct: &resp); |
668 | if (ret < 0) |
669 | goto out; |
670 | |
671 | if (test_bit(ATH10K_SNOC_FLAG_8BIT_HOST_CAP_QUIRK, &ar_snoc->flags)) |
672 | req_ei = wlfw_host_cap_8bit_req_msg_v01_ei; |
673 | else |
674 | req_ei = wlfw_host_cap_req_msg_v01_ei; |
675 | |
676 | ret = qmi_send_request(qmi: &qmi->qmi_hdl, NULL, txn: &txn, |
677 | QMI_WLFW_HOST_CAP_REQ_V01, |
678 | WLFW_HOST_CAP_REQ_MSG_V01_MAX_MSG_LEN, |
679 | ei: req_ei, c_struct: &req); |
680 | if (ret < 0) { |
681 | qmi_txn_cancel(txn: &txn); |
682 | ath10k_err(ar, fmt: "failed to send host capability request: %d\n" , ret); |
683 | goto out; |
684 | } |
685 | |
686 | ret = qmi_txn_wait(txn: &txn, ATH10K_QMI_TIMEOUT * HZ); |
687 | if (ret < 0) |
688 | goto out; |
689 | |
690 | /* older FW didn't support this request, which is not fatal */ |
691 | if (resp.resp.result != QMI_RESULT_SUCCESS_V01 && |
692 | resp.resp.error != QMI_ERR_NOT_SUPPORTED_V01) { |
693 | ath10k_err(ar, fmt: "host capability request rejected: %d\n" , resp.resp.error); |
694 | ret = -EINVAL; |
695 | goto out; |
696 | } |
697 | |
698 | ath10k_dbg(ar, ATH10K_DBG_QMI, "qmi host capability request completed\n" ); |
699 | return 0; |
700 | |
701 | out: |
702 | return ret; |
703 | } |
704 | |
705 | int ath10k_qmi_set_fw_log_mode(struct ath10k *ar, u8 fw_log_mode) |
706 | { |
707 | struct ath10k_snoc *ar_snoc = ath10k_snoc_priv(ar); |
708 | struct wlfw_ini_resp_msg_v01 resp = {}; |
709 | struct ath10k_qmi *qmi = ar_snoc->qmi; |
710 | struct wlfw_ini_req_msg_v01 req = {}; |
711 | struct qmi_txn txn; |
712 | int ret; |
713 | |
714 | req.enablefwlog_valid = 1; |
715 | req.enablefwlog = fw_log_mode; |
716 | |
717 | ret = qmi_txn_init(qmi: &qmi->qmi_hdl, txn: &txn, ei: wlfw_ini_resp_msg_v01_ei, |
718 | c_struct: &resp); |
719 | if (ret < 0) |
720 | goto out; |
721 | |
722 | ret = qmi_send_request(qmi: &qmi->qmi_hdl, NULL, txn: &txn, |
723 | QMI_WLFW_INI_REQ_V01, |
724 | WLFW_INI_REQ_MSG_V01_MAX_MSG_LEN, |
725 | ei: wlfw_ini_req_msg_v01_ei, c_struct: &req); |
726 | if (ret < 0) { |
727 | qmi_txn_cancel(txn: &txn); |
728 | ath10k_err(ar, fmt: "failed to send fw log request: %d\n" , ret); |
729 | goto out; |
730 | } |
731 | |
732 | ret = qmi_txn_wait(txn: &txn, ATH10K_QMI_TIMEOUT * HZ); |
733 | if (ret < 0) |
734 | goto out; |
735 | |
736 | if (resp.resp.result != QMI_RESULT_SUCCESS_V01) { |
737 | ath10k_err(ar, fmt: "fw log request rejected: %d\n" , |
738 | resp.resp.error); |
739 | ret = -EINVAL; |
740 | goto out; |
741 | } |
742 | ath10k_dbg(ar, ATH10K_DBG_QMI, "qmi fw log request completed, mode: %d\n" , |
743 | fw_log_mode); |
744 | return 0; |
745 | |
746 | out: |
747 | return ret; |
748 | } |
749 | |
750 | static int |
751 | ath10k_qmi_ind_register_send_sync_msg(struct ath10k_qmi *qmi) |
752 | { |
753 | struct wlfw_ind_register_resp_msg_v01 resp = {}; |
754 | struct wlfw_ind_register_req_msg_v01 req = {}; |
755 | struct ath10k *ar = qmi->ar; |
756 | struct ath10k_snoc *ar_snoc = ath10k_snoc_priv(ar); |
757 | struct qmi_txn txn; |
758 | int ret; |
759 | |
760 | req.client_id_valid = 1; |
761 | req.client_id = ATH10K_QMI_CLIENT_ID; |
762 | req.fw_ready_enable_valid = 1; |
763 | req.fw_ready_enable = 1; |
764 | req.msa_ready_enable_valid = 1; |
765 | req.msa_ready_enable = 1; |
766 | |
767 | if (ar_snoc->xo_cal_supported) { |
768 | req.xo_cal_enable_valid = 1; |
769 | req.xo_cal_enable = 1; |
770 | } |
771 | |
772 | ret = qmi_txn_init(qmi: &qmi->qmi_hdl, txn: &txn, |
773 | ei: wlfw_ind_register_resp_msg_v01_ei, c_struct: &resp); |
774 | if (ret < 0) |
775 | goto out; |
776 | |
777 | ret = qmi_send_request(qmi: &qmi->qmi_hdl, NULL, txn: &txn, |
778 | QMI_WLFW_IND_REGISTER_REQ_V01, |
779 | WLFW_IND_REGISTER_REQ_MSG_V01_MAX_MSG_LEN, |
780 | ei: wlfw_ind_register_req_msg_v01_ei, c_struct: &req); |
781 | if (ret < 0) { |
782 | qmi_txn_cancel(txn: &txn); |
783 | ath10k_err(ar, fmt: "failed to send indication registered request: %d\n" , ret); |
784 | goto out; |
785 | } |
786 | |
787 | ret = qmi_txn_wait(txn: &txn, ATH10K_QMI_TIMEOUT * HZ); |
788 | if (ret < 0) |
789 | goto out; |
790 | |
791 | if (resp.resp.result != QMI_RESULT_SUCCESS_V01) { |
792 | ath10k_err(ar, fmt: "indication request rejected: %d\n" , resp.resp.error); |
793 | ret = -EINVAL; |
794 | goto out; |
795 | } |
796 | |
797 | if (resp.fw_status_valid) { |
798 | if (resp.fw_status & QMI_WLFW_FW_READY_V01) |
799 | qmi->fw_ready = true; |
800 | } |
801 | ath10k_dbg(ar, ATH10K_DBG_QMI, "qmi indication register request completed\n" ); |
802 | return 0; |
803 | |
804 | out: |
805 | return ret; |
806 | } |
807 | |
808 | static void ath10k_qmi_event_server_arrive(struct ath10k_qmi *qmi) |
809 | { |
810 | struct ath10k *ar = qmi->ar; |
811 | int ret; |
812 | |
813 | ret = ath10k_qmi_ind_register_send_sync_msg(qmi); |
814 | if (ret) |
815 | return; |
816 | |
817 | if (qmi->fw_ready) { |
818 | ath10k_snoc_fw_indication(ar, type: ATH10K_QMI_EVENT_FW_READY_IND); |
819 | return; |
820 | } |
821 | |
822 | ret = ath10k_qmi_host_cap_send_sync(qmi); |
823 | if (ret) |
824 | return; |
825 | |
826 | ret = ath10k_qmi_msa_mem_info_send_sync_msg(qmi); |
827 | if (ret) |
828 | return; |
829 | |
830 | /* |
831 | * HACK: sleep for a while between receiving the msa info response |
832 | * and the XPU update to prevent SDM845 from crashing due to a security |
833 | * violation, when running MPSS.AT.4.0.c2-01184-SDM845_GEN_PACK-1. |
834 | */ |
835 | msleep(msecs: 20); |
836 | |
837 | ret = ath10k_qmi_setup_msa_permissions(qmi); |
838 | if (ret) |
839 | return; |
840 | |
841 | ret = ath10k_qmi_msa_ready_send_sync_msg(qmi); |
842 | if (ret) |
843 | goto err_setup_msa; |
844 | |
845 | ret = ath10k_qmi_cap_send_sync_msg(qmi); |
846 | if (ret) |
847 | goto err_setup_msa; |
848 | |
849 | return; |
850 | |
851 | err_setup_msa: |
852 | ath10k_qmi_remove_msa_permission(qmi); |
853 | } |
854 | |
855 | static int ath10k_qmi_fetch_board_file(struct ath10k_qmi *qmi) |
856 | { |
857 | struct ath10k *ar = qmi->ar; |
858 | int ret; |
859 | |
860 | ar->hif.bus = ATH10K_BUS_SNOC; |
861 | ar->id.qmi_ids_valid = true; |
862 | ar->id.qmi_board_id = qmi->board_info.board_id; |
863 | ar->id.qmi_chip_id = qmi->chip_info.chip_id; |
864 | ar->hw_params.fw.dir = WCN3990_HW_1_0_FW_DIR; |
865 | |
866 | ret = ath10k_core_check_dt(ar); |
867 | if (ret) |
868 | ath10k_dbg(ar, ATH10K_DBG_QMI, "DT bdf variant name not set.\n" ); |
869 | |
870 | return ath10k_core_fetch_board_file(ar: qmi->ar, bd_ie_type: ATH10K_BD_IE_BOARD); |
871 | } |
872 | |
873 | static int |
874 | ath10k_qmi_driver_event_post(struct ath10k_qmi *qmi, |
875 | enum ath10k_qmi_driver_event_type type, |
876 | void *data) |
877 | { |
878 | struct ath10k_qmi_driver_event *event; |
879 | |
880 | event = kzalloc(size: sizeof(*event), GFP_ATOMIC); |
881 | if (!event) |
882 | return -ENOMEM; |
883 | |
884 | event->type = type; |
885 | event->data = data; |
886 | |
887 | spin_lock(lock: &qmi->event_lock); |
888 | list_add_tail(new: &event->list, head: &qmi->event_list); |
889 | spin_unlock(lock: &qmi->event_lock); |
890 | |
891 | queue_work(wq: qmi->event_wq, work: &qmi->event_work); |
892 | |
893 | return 0; |
894 | } |
895 | |
896 | static void ath10k_qmi_event_server_exit(struct ath10k_qmi *qmi) |
897 | { |
898 | struct ath10k *ar = qmi->ar; |
899 | struct ath10k_snoc *ar_snoc = ath10k_snoc_priv(ar); |
900 | |
901 | ath10k_qmi_remove_msa_permission(qmi); |
902 | ath10k_core_free_board_files(ar); |
903 | if (!test_bit(ATH10K_SNOC_FLAG_UNREGISTERING, &ar_snoc->flags) && |
904 | !test_bit(ATH10K_SNOC_FLAG_MODEM_STOPPED, &ar_snoc->flags)) |
905 | ath10k_snoc_fw_crashed_dump(ar); |
906 | |
907 | ath10k_snoc_fw_indication(ar, type: ATH10K_QMI_EVENT_FW_DOWN_IND); |
908 | ath10k_dbg(ar, ATH10K_DBG_QMI, "wifi fw qmi service disconnected\n" ); |
909 | } |
910 | |
911 | static void ath10k_qmi_event_msa_ready(struct ath10k_qmi *qmi) |
912 | { |
913 | int ret; |
914 | |
915 | ret = ath10k_qmi_fetch_board_file(qmi); |
916 | if (ret) |
917 | goto out; |
918 | |
919 | ret = ath10k_qmi_bdf_dnld_send_sync(qmi); |
920 | if (ret) |
921 | goto out; |
922 | |
923 | ret = ath10k_qmi_send_cal_report_req(qmi); |
924 | |
925 | out: |
926 | return; |
927 | } |
928 | |
929 | static int ath10k_qmi_event_fw_ready_ind(struct ath10k_qmi *qmi) |
930 | { |
931 | struct ath10k *ar = qmi->ar; |
932 | |
933 | ath10k_dbg(ar, ATH10K_DBG_QMI, "wifi fw ready event received\n" ); |
934 | ath10k_snoc_fw_indication(ar, type: ATH10K_QMI_EVENT_FW_READY_IND); |
935 | |
936 | return 0; |
937 | } |
938 | |
939 | static void ath10k_qmi_fw_ready_ind(struct qmi_handle *qmi_hdl, |
940 | struct sockaddr_qrtr *sq, |
941 | struct qmi_txn *txn, const void *data) |
942 | { |
943 | struct ath10k_qmi *qmi = container_of(qmi_hdl, struct ath10k_qmi, qmi_hdl); |
944 | |
945 | ath10k_qmi_driver_event_post(qmi, type: ATH10K_QMI_EVENT_FW_READY_IND, NULL); |
946 | } |
947 | |
948 | static void ath10k_qmi_msa_ready_ind(struct qmi_handle *qmi_hdl, |
949 | struct sockaddr_qrtr *sq, |
950 | struct qmi_txn *txn, const void *data) |
951 | { |
952 | struct ath10k_qmi *qmi = container_of(qmi_hdl, struct ath10k_qmi, qmi_hdl); |
953 | |
954 | ath10k_qmi_driver_event_post(qmi, type: ATH10K_QMI_EVENT_MSA_READY_IND, NULL); |
955 | } |
956 | |
957 | static const struct qmi_msg_handler qmi_msg_handler[] = { |
958 | { |
959 | .type = QMI_INDICATION, |
960 | .msg_id = QMI_WLFW_FW_READY_IND_V01, |
961 | .ei = wlfw_fw_ready_ind_msg_v01_ei, |
962 | .decoded_size = sizeof(struct wlfw_fw_ready_ind_msg_v01), |
963 | .fn = ath10k_qmi_fw_ready_ind, |
964 | }, |
965 | { |
966 | .type = QMI_INDICATION, |
967 | .msg_id = QMI_WLFW_MSA_READY_IND_V01, |
968 | .ei = wlfw_msa_ready_ind_msg_v01_ei, |
969 | .decoded_size = sizeof(struct wlfw_msa_ready_ind_msg_v01), |
970 | .fn = ath10k_qmi_msa_ready_ind, |
971 | }, |
972 | {} |
973 | }; |
974 | |
975 | static int ath10k_qmi_new_server(struct qmi_handle *qmi_hdl, |
976 | struct qmi_service *service) |
977 | { |
978 | struct ath10k_qmi *qmi = container_of(qmi_hdl, struct ath10k_qmi, qmi_hdl); |
979 | struct sockaddr_qrtr *sq = &qmi->sq; |
980 | struct ath10k *ar = qmi->ar; |
981 | int ret; |
982 | |
983 | sq->sq_family = AF_QIPCRTR; |
984 | sq->sq_node = service->node; |
985 | sq->sq_port = service->port; |
986 | |
987 | ath10k_dbg(ar, ATH10K_DBG_QMI, "wifi fw qmi service found\n" ); |
988 | |
989 | ret = kernel_connect(sock: qmi_hdl->sock, addr: (struct sockaddr *)&qmi->sq, |
990 | addrlen: sizeof(qmi->sq), flags: 0); |
991 | if (ret) { |
992 | ath10k_err(ar, fmt: "failed to connect to a remote QMI service port\n" ); |
993 | return ret; |
994 | } |
995 | |
996 | ath10k_dbg(ar, ATH10K_DBG_QMI, "qmi wifi fw qmi service connected\n" ); |
997 | ath10k_qmi_driver_event_post(qmi, type: ATH10K_QMI_EVENT_SERVER_ARRIVE, NULL); |
998 | |
999 | return ret; |
1000 | } |
1001 | |
1002 | static void ath10k_qmi_del_server(struct qmi_handle *qmi_hdl, |
1003 | struct qmi_service *service) |
1004 | { |
1005 | struct ath10k_qmi *qmi = |
1006 | container_of(qmi_hdl, struct ath10k_qmi, qmi_hdl); |
1007 | |
1008 | qmi->fw_ready = false; |
1009 | |
1010 | /* |
1011 | * The del_server event is to be processed only if coming from |
1012 | * the qmi server. The qmi infrastructure sends del_server, when |
1013 | * any client releases the qmi handle. In this case do not process |
1014 | * this del_server event. |
1015 | */ |
1016 | if (qmi->state == ATH10K_QMI_STATE_INIT_DONE) |
1017 | ath10k_qmi_driver_event_post(qmi, type: ATH10K_QMI_EVENT_SERVER_EXIT, |
1018 | NULL); |
1019 | } |
1020 | |
1021 | static const struct qmi_ops ath10k_qmi_ops = { |
1022 | .new_server = ath10k_qmi_new_server, |
1023 | .del_server = ath10k_qmi_del_server, |
1024 | }; |
1025 | |
1026 | static void ath10k_qmi_driver_event_work(struct work_struct *work) |
1027 | { |
1028 | struct ath10k_qmi *qmi = container_of(work, struct ath10k_qmi, |
1029 | event_work); |
1030 | struct ath10k_qmi_driver_event *event; |
1031 | struct ath10k *ar = qmi->ar; |
1032 | |
1033 | spin_lock(lock: &qmi->event_lock); |
1034 | while (!list_empty(head: &qmi->event_list)) { |
1035 | event = list_first_entry(&qmi->event_list, |
1036 | struct ath10k_qmi_driver_event, list); |
1037 | list_del(entry: &event->list); |
1038 | spin_unlock(lock: &qmi->event_lock); |
1039 | |
1040 | switch (event->type) { |
1041 | case ATH10K_QMI_EVENT_SERVER_ARRIVE: |
1042 | ath10k_qmi_event_server_arrive(qmi); |
1043 | break; |
1044 | case ATH10K_QMI_EVENT_SERVER_EXIT: |
1045 | ath10k_qmi_event_server_exit(qmi); |
1046 | break; |
1047 | case ATH10K_QMI_EVENT_FW_READY_IND: |
1048 | ath10k_qmi_event_fw_ready_ind(qmi); |
1049 | break; |
1050 | case ATH10K_QMI_EVENT_MSA_READY_IND: |
1051 | ath10k_qmi_event_msa_ready(qmi); |
1052 | break; |
1053 | default: |
1054 | ath10k_warn(ar, fmt: "invalid event type: %d" , event->type); |
1055 | break; |
1056 | } |
1057 | kfree(objp: event); |
1058 | spin_lock(lock: &qmi->event_lock); |
1059 | } |
1060 | spin_unlock(lock: &qmi->event_lock); |
1061 | } |
1062 | |
1063 | int ath10k_qmi_init(struct ath10k *ar, u32 msa_size) |
1064 | { |
1065 | struct ath10k_snoc *ar_snoc = ath10k_snoc_priv(ar); |
1066 | struct device *dev = ar->dev; |
1067 | struct ath10k_qmi *qmi; |
1068 | int ret; |
1069 | |
1070 | qmi = kzalloc(size: sizeof(*qmi), GFP_KERNEL); |
1071 | if (!qmi) |
1072 | return -ENOMEM; |
1073 | |
1074 | qmi->ar = ar; |
1075 | ar_snoc->qmi = qmi; |
1076 | |
1077 | if (of_property_read_bool(np: dev->of_node, propname: "qcom,msa-fixed-perm" )) |
1078 | qmi->msa_fixed_perm = true; |
1079 | |
1080 | ret = qmi_handle_init(qmi: &qmi->qmi_hdl, |
1081 | WLFW_BDF_DOWNLOAD_REQ_MSG_V01_MAX_MSG_LEN, |
1082 | ops: &ath10k_qmi_ops, handlers: qmi_msg_handler); |
1083 | if (ret) |
1084 | goto err; |
1085 | |
1086 | qmi->event_wq = alloc_ordered_workqueue("ath10k_qmi_driver_event" , 0); |
1087 | if (!qmi->event_wq) { |
1088 | ath10k_err(ar, fmt: "failed to allocate workqueue\n" ); |
1089 | ret = -EFAULT; |
1090 | goto err_release_qmi_handle; |
1091 | } |
1092 | |
1093 | INIT_LIST_HEAD(list: &qmi->event_list); |
1094 | spin_lock_init(&qmi->event_lock); |
1095 | INIT_WORK(&qmi->event_work, ath10k_qmi_driver_event_work); |
1096 | |
1097 | ret = qmi_add_lookup(qmi: &qmi->qmi_hdl, WLFW_SERVICE_ID_V01, |
1098 | WLFW_SERVICE_VERS_V01, instance: 0); |
1099 | if (ret) |
1100 | goto err_qmi_lookup; |
1101 | |
1102 | qmi->state = ATH10K_QMI_STATE_INIT_DONE; |
1103 | return 0; |
1104 | |
1105 | err_qmi_lookup: |
1106 | destroy_workqueue(wq: qmi->event_wq); |
1107 | |
1108 | err_release_qmi_handle: |
1109 | qmi_handle_release(qmi: &qmi->qmi_hdl); |
1110 | |
1111 | err: |
1112 | kfree(objp: qmi); |
1113 | return ret; |
1114 | } |
1115 | |
1116 | int ath10k_qmi_deinit(struct ath10k *ar) |
1117 | { |
1118 | struct ath10k_snoc *ar_snoc = ath10k_snoc_priv(ar); |
1119 | struct ath10k_qmi *qmi = ar_snoc->qmi; |
1120 | |
1121 | qmi->state = ATH10K_QMI_STATE_DEINIT; |
1122 | qmi_handle_release(qmi: &qmi->qmi_hdl); |
1123 | cancel_work_sync(work: &qmi->event_work); |
1124 | destroy_workqueue(wq: qmi->event_wq); |
1125 | kfree(objp: qmi); |
1126 | ar_snoc->qmi = NULL; |
1127 | |
1128 | return 0; |
1129 | } |
1130 | |