drivers/net/wireless/ath/ath10k/qmi.c

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