drivers/remoteproc/qcom_q6v5_pas.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Qualcomm ADSP/SLPI Peripheral Image Loader for MSM8974 and MSM8996
   4  *
   5  * Copyright (C) 2016 Linaro Ltd
   6  * Copyright (C) 2014 Sony Mobile Communications AB
   7  * Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
   8  */
   9
  10 #include <linux/clk.h>
  11 #include <linux/firmware.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/kernel.h>
  14 #include <linux/module.h>
  15 #include <linux/of_address.h>
  16 #include <linux/of_device.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/pm_domain.h>
  19 #include <linux/pm_runtime.h>
  20 #include <linux/qcom_scm.h>
  21 #include <linux/regulator/consumer.h>
  22 #include <linux/remoteproc.h>
  23 #include <linux/soc/qcom/mdt_loader.h>
  24 #include <linux/soc/qcom/smem.h>
  25 #include <linux/soc/qcom/smem_state.h>
  26
  27 #include "qcom_common.h"
  28 #include "qcom_pil_info.h"
  29 #include "qcom_q6v5.h"
  30 #include "remoteproc_internal.h"
  31
  32 struct adsp_data {
  33         int crash_reason_smem;
  34         const char *firmware_name;
  35         int pas_id;
  36         bool has_aggre2_clk;
  37         bool auto_boot;
  38
  39         char **active_pd_names;
  40         char **proxy_pd_names;
  41
  42         const char *ssr_name;
  43         const char *sysmon_name;
  44         int ssctl_id;
  45 };
  46
  47 struct qcom_adsp {
  48         struct device *dev;
  49         struct rproc *rproc;
  50
  51         struct qcom_q6v5 q6v5;
  52
  53         struct clk *xo;
  54         struct clk *aggre2_clk;
  55
  56         struct regulator *cx_supply;
  57         struct regulator *px_supply;
  58
  59         struct device *active_pds[1];
  60         struct device *proxy_pds[3];
  61
  62         int active_pd_count;
  63         int proxy_pd_count;
  64
  65         int pas_id;
  66         int crash_reason_smem;
  67         bool has_aggre2_clk;
  68         const char *info_name;
  69
  70         struct completion start_done;
  71         struct completion stop_done;
  72
  73         phys_addr_t mem_phys;
  74         phys_addr_t mem_reloc;
  75         void *mem_region;
  76         size_t mem_size;
  77
  78         struct qcom_rproc_glink glink_subdev;
  79         struct qcom_rproc_subdev smd_subdev;
  80         struct qcom_rproc_ssr ssr_subdev;
  81         struct qcom_sysmon *sysmon;
  82 };
  83
  84 static int adsp_pds_enable(struct qcom_adsp *adsp, struct device **pds,
  85                            size_t pd_count)
  86 {
  87         int ret;
  88         int i;
  89
  90         for (i = 0; i < pd_count; i++) {
  91                 dev_pm_genpd_set_performance_state(pds[i], INT_MAX);
  92                 ret = pm_runtime_get_sync(pds[i]);
  93                 if (ret < 0) {
  94                         pm_runtime_put_noidle(pds[i]);
  95                         dev_pm_genpd_set_performance_state(pds[i], 0);
  96                         goto unroll_pd_votes;
  97                 }
  98         }
  99
 100         return 0;
 101
 102 unroll_pd_votes:
 103         for (i--; i >= 0; i--) {
 104                 dev_pm_genpd_set_performance_state(pds[i], 0);
 105                 pm_runtime_put(pds[i]);
 106         }
 107
 108         return ret;
 109 };
 110
 111 static void adsp_pds_disable(struct qcom_adsp *adsp, struct device **pds,
 112                              size_t pd_count)
 113 {
 114         int i;
 115
 116         for (i = 0; i < pd_count; i++) {
 117                 dev_pm_genpd_set_performance_state(pds[i], 0);
 118                 pm_runtime_put(pds[i]);
 119         }
 120 }
 121
 122 static int adsp_load(struct rproc *rproc, const struct firmware *fw)
 123 {
 124         struct qcom_adsp *adsp = (struct qcom_adsp *)rproc->priv;
 125         int ret;
 126
 127         ret = qcom_mdt_load(adsp->dev, fw, rproc->firmware, adsp->pas_id,
 128                             adsp->mem_region, adsp->mem_phys, adsp->mem_size,
 129                             &adsp->mem_reloc);
 130         if (ret)
 131                 return ret;
 132
 133         qcom_pil_info_store(adsp->info_name, adsp->mem_phys, adsp->mem_size);
 134
 135         return 0;
 136 }
 137
 138 static int adsp_start(struct rproc *rproc)
 139 {
 140         struct qcom_adsp *adsp = (struct qcom_adsp *)rproc->priv;
 141         int ret;
 142
 143         qcom_q6v5_prepare(&adsp->q6v5);
 144
 145         ret = adsp_pds_enable(adsp, adsp->active_pds, adsp->active_pd_count);
 146         if (ret < 0)
 147                 goto disable_irqs;
 148
 149         ret = adsp_pds_enable(adsp, adsp->proxy_pds, adsp->proxy_pd_count);
 150         if (ret < 0)
 151                 goto disable_active_pds;
 152
 153         ret = clk_prepare_enable(adsp->xo);
 154         if (ret)
 155                 goto disable_proxy_pds;
 156
 157         ret = clk_prepare_enable(adsp->aggre2_clk);
 158         if (ret)
 159                 goto disable_xo_clk;
 160
 161         ret = regulator_enable(adsp->cx_supply);
 162         if (ret)
 163                 goto disable_aggre2_clk;
 164
 165         ret = regulator_enable(adsp->px_supply);
 166         if (ret)
 167                 goto disable_cx_supply;
 168
 169         ret = qcom_scm_pas_auth_and_reset(adsp->pas_id);
 170         if (ret) {
 171                 dev_err(adsp->dev,
 172                         "failed to authenticate image and release reset\n");
 173                 goto disable_px_supply;
 174         }
 175
 176         ret = qcom_q6v5_wait_for_start(&adsp->q6v5, msecs_to_jiffies(5000));
 177         if (ret == -ETIMEDOUT) {
 178                 dev_err(adsp->dev, "start timed out\n");
 179                 qcom_scm_pas_shutdown(adsp->pas_id);
 180                 goto disable_px_supply;
 181         }
 182
 183         return 0;
 184
 185 disable_px_supply:
 186         regulator_disable(adsp->px_supply);
 187 disable_cx_supply:
 188         regulator_disable(adsp->cx_supply);
 189 disable_aggre2_clk:
 190         clk_disable_unprepare(adsp->aggre2_clk);
 191 disable_xo_clk:
 192         clk_disable_unprepare(adsp->xo);
 193 disable_proxy_pds:
 194         adsp_pds_disable(adsp, adsp->proxy_pds, adsp->proxy_pd_count);
 195 disable_active_pds:
 196         adsp_pds_disable(adsp, adsp->active_pds, adsp->active_pd_count);
 197 disable_irqs:
 198         qcom_q6v5_unprepare(&adsp->q6v5);
 199
 200         return ret;
 201 }
 202
 203 static void qcom_pas_handover(struct qcom_q6v5 *q6v5)
 204 {
 205         struct qcom_adsp *adsp = container_of(q6v5, struct qcom_adsp, q6v5);
 206
 207         regulator_disable(adsp->px_supply);
 208         regulator_disable(adsp->cx_supply);
 209         clk_disable_unprepare(adsp->aggre2_clk);
 210         clk_disable_unprepare(adsp->xo);
 211         adsp_pds_disable(adsp, adsp->proxy_pds, adsp->proxy_pd_count);
 212 }
 213
 214 static int adsp_stop(struct rproc *rproc)
 215 {
 216         struct qcom_adsp *adsp = (struct qcom_adsp *)rproc->priv;
 217         int handover;
 218         int ret;
 219
 220         ret = qcom_q6v5_request_stop(&adsp->q6v5);
 221         if (ret == -ETIMEDOUT)
 222                 dev_err(adsp->dev, "timed out on wait\n");
 223
 224         ret = qcom_scm_pas_shutdown(adsp->pas_id);
 225         if (ret)
 226                 dev_err(adsp->dev, "failed to shutdown: %d\n", ret);
 227
 228         adsp_pds_disable(adsp, adsp->active_pds, adsp->active_pd_count);
 229         handover = qcom_q6v5_unprepare(&adsp->q6v5);
 230         if (handover)
 231                 qcom_pas_handover(&adsp->q6v5);
 232
 233         return ret;
 234 }
 235
 236 static void *adsp_da_to_va(struct rproc *rproc, u64 da, size_t len)
 237 {
 238         struct qcom_adsp *adsp = (struct qcom_adsp *)rproc->priv;
 239         int offset;
 240
 241         offset = da - adsp->mem_reloc;
 242         if (offset < 0 || offset + len > adsp->mem_size)
 243                 return NULL;
 244
 245         return adsp->mem_region + offset;
 246 }
 247
 248 static unsigned long adsp_panic(struct rproc *rproc)
 249 {
 250         struct qcom_adsp *adsp = (struct qcom_adsp *)rproc->priv;
 251
 252         return qcom_q6v5_panic(&adsp->q6v5);
 253 }
 254
 255 static const struct rproc_ops adsp_ops = {
 256         .start = adsp_start,
 257         .stop = adsp_stop,
 258         .da_to_va = adsp_da_to_va,
 259         .parse_fw = qcom_register_dump_segments,
 260         .load = adsp_load,
 261         .panic = adsp_panic,
 262 };
 263
 264 static int adsp_init_clock(struct qcom_adsp *adsp)
 265 {
 266         int ret;
 267
 268         adsp->xo = devm_clk_get(adsp->dev, "xo");
 269         if (IS_ERR(adsp->xo)) {
 270                 ret = PTR_ERR(adsp->xo);
 271                 if (ret != -EPROBE_DEFER)
 272                         dev_err(adsp->dev, "failed to get xo clock");
 273                 return ret;
 274         }
 275
 276         if (adsp->has_aggre2_clk) {
 277                 adsp->aggre2_clk = devm_clk_get(adsp->dev, "aggre2");
 278                 if (IS_ERR(adsp->aggre2_clk)) {
 279                         ret = PTR_ERR(adsp->aggre2_clk);
 280                         if (ret != -EPROBE_DEFER)
 281                                 dev_err(adsp->dev,
 282                                         "failed to get aggre2 clock");
 283                         return ret;
 284                 }
 285         }
 286
 287         return 0;
 288 }
 289
 290 static int adsp_init_regulator(struct qcom_adsp *adsp)
 291 {
 292         adsp->cx_supply = devm_regulator_get(adsp->dev, "cx");
 293         if (IS_ERR(adsp->cx_supply))
 294                 return PTR_ERR(adsp->cx_supply);
 295
 296         regulator_set_load(adsp->cx_supply, 100000);
 297
 298         adsp->px_supply = devm_regulator_get(adsp->dev, "px");
 299         return PTR_ERR_OR_ZERO(adsp->px_supply);
 300 }
 301
 302 static int adsp_pds_attach(struct device *dev, struct device **devs,
 303                            char **pd_names)
 304 {
 305         size_t num_pds = 0;
 306         int ret;
 307         int i;
 308
 309         if (!pd_names)
 310                 return 0;
 311
 312         /* Handle single power domain */
 313         if (dev->pm_domain) {
 314                 devs[0] = dev;
 315                 pm_runtime_enable(dev);
 316                 return 1;
 317         }
 318
 319         while (pd_names[num_pds])
 320                 num_pds++;
 321
 322         for (i = 0; i < num_pds; i++) {
 323                 devs[i] = dev_pm_domain_attach_by_name(dev, pd_names[i]);
 324                 if (IS_ERR_OR_NULL(devs[i])) {
 325                         ret = PTR_ERR(devs[i]) ? : -ENODATA;
 326                         goto unroll_attach;
 327                 }
 328         }
 329
 330         return num_pds;
 331
 332 unroll_attach:
 333         for (i--; i >= 0; i--)
 334                 dev_pm_domain_detach(devs[i], false);
 335
 336         return ret;
 337 };
 338
 339 static void adsp_pds_detach(struct qcom_adsp *adsp, struct device **pds,
 340                             size_t pd_count)
 341 {
 342         struct device *dev = adsp->dev;
 343         int i;
 344
 345         /* Handle single power domain */
 346         if (dev->pm_domain && pd_count) {
 347                 pm_runtime_disable(dev);
 348                 return;
 349         }
 350
 351         for (i = 0; i < pd_count; i++)
 352                 dev_pm_domain_detach(pds[i], false);
 353 }
 354
 355 static int adsp_alloc_memory_region(struct qcom_adsp *adsp)
 356 {
 357         struct device_node *node;
 358         struct resource r;
 359         int ret;
 360
 361         node = of_parse_phandle(adsp->dev->of_node, "memory-region", 0);
 362         if (!node) {
 363                 dev_err(adsp->dev, "no memory-region specified\n");
 364                 return -EINVAL;
 365         }
 366
 367         ret = of_address_to_resource(node, 0, &r);
 368         if (ret)
 369                 return ret;
 370
 371         adsp->mem_phys = adsp->mem_reloc = r.start;
 372         adsp->mem_size = resource_size(&r);
 373         adsp->mem_region = devm_ioremap_wc(adsp->dev, adsp->mem_phys, adsp->mem_size);
 374         if (!adsp->mem_region) {
 375                 dev_err(adsp->dev, "unable to map memory region: %pa+%zx\n",
 376                         &r.start, adsp->mem_size);
 377                 return -EBUSY;
 378         }
 379
 380         return 0;
 381 }
 382
 383 static int adsp_probe(struct platform_device *pdev)
 384 {
 385         const struct adsp_data *desc;
 386         struct qcom_adsp *adsp;
 387         struct rproc *rproc;
 388         const char *fw_name;
 389         int ret;
 390
 391         desc = of_device_get_match_data(&pdev->dev);
 392         if (!desc)
 393                 return -EINVAL;
 394
 395         if (!qcom_scm_is_available())
 396                 return -EPROBE_DEFER;
 397
 398         fw_name = desc->firmware_name;
 399         ret = of_property_read_string(pdev->dev.of_node, "firmware-name",
 400                                       &fw_name);
 401         if (ret < 0 && ret != -EINVAL)
 402                 return ret;
 403
 404         rproc = rproc_alloc(&pdev->dev, pdev->name, &adsp_ops,
 405                             fw_name, sizeof(*adsp));
 406         if (!rproc) {
 407                 dev_err(&pdev->dev, "unable to allocate remoteproc\n");
 408                 return -ENOMEM;
 409         }
 410
 411         rproc->auto_boot = desc->auto_boot;
 412         rproc_coredump_set_elf_info(rproc, ELFCLASS32, EM_NONE);
 413
 414         adsp = (struct qcom_adsp *)rproc->priv;
 415         adsp->dev = &pdev->dev;
 416         adsp->rproc = rproc;
 417         adsp->pas_id = desc->pas_id;
 418         adsp->has_aggre2_clk = desc->has_aggre2_clk;
 419         adsp->info_name = desc->sysmon_name;
 420         platform_set_drvdata(pdev, adsp);
 421
 422         device_wakeup_enable(adsp->dev);
 423
 424         ret = adsp_alloc_memory_region(adsp);
 425         if (ret)
 426                 goto free_rproc;
 427
 428         ret = adsp_init_clock(adsp);
 429         if (ret)
 430                 goto free_rproc;
 431
 432         ret = adsp_init_regulator(adsp);
 433         if (ret)
 434                 goto free_rproc;
 435
 436         ret = adsp_pds_attach(&pdev->dev, adsp->active_pds,
 437                               desc->active_pd_names);
 438         if (ret < 0)
 439                 goto free_rproc;
 440         adsp->active_pd_count = ret;
 441
 442         ret = adsp_pds_attach(&pdev->dev, adsp->proxy_pds,
 443                               desc->proxy_pd_names);
 444         if (ret < 0)
 445                 goto detach_active_pds;
 446         adsp->proxy_pd_count = ret;
 447
 448         ret = qcom_q6v5_init(&adsp->q6v5, pdev, rproc, desc->crash_reason_smem,
 449                              qcom_pas_handover);
 450         if (ret)
 451                 goto detach_proxy_pds;
 452
 453         qcom_add_glink_subdev(rproc, &adsp->glink_subdev, desc->ssr_name);
 454         qcom_add_smd_subdev(rproc, &adsp->smd_subdev);
 455         qcom_add_ssr_subdev(rproc, &adsp->ssr_subdev, desc->ssr_name);
 456         adsp->sysmon = qcom_add_sysmon_subdev(rproc,
 457                                               desc->sysmon_name,
 458                                               desc->ssctl_id);
 459         if (IS_ERR(adsp->sysmon)) {
 460                 ret = PTR_ERR(adsp->sysmon);
 461                 goto detach_proxy_pds;
 462         }
 463
 464         ret = rproc_add(rproc);
 465         if (ret)
 466                 goto detach_proxy_pds;
 467
 468         return 0;
 469
 470 detach_proxy_pds:
 471         adsp_pds_detach(adsp, adsp->proxy_pds, adsp->proxy_pd_count);
 472 detach_active_pds:
 473         adsp_pds_detach(adsp, adsp->active_pds, adsp->active_pd_count);
 474 free_rproc:
 475         rproc_free(rproc);
 476
 477         return ret;
 478 }
 479
 480 static int adsp_remove(struct platform_device *pdev)
 481 {
 482         struct qcom_adsp *adsp = platform_get_drvdata(pdev);
 483
 484         rproc_del(adsp->rproc);
 485
 486         qcom_remove_glink_subdev(adsp->rproc, &adsp->glink_subdev);
 487         qcom_remove_sysmon_subdev(adsp->sysmon);
 488         qcom_remove_smd_subdev(adsp->rproc, &adsp->smd_subdev);
 489         qcom_remove_ssr_subdev(adsp->rproc, &adsp->ssr_subdev);
 490         rproc_free(adsp->rproc);
 491
 492         return 0;
 493 }
 494
 495 static const struct adsp_data adsp_resource_init = {
 496                 .crash_reason_smem = 423,
 497                 .firmware_name = "/*(DEBLOBBED)*/",
 498                 .pas_id = 1,
 499                 .has_aggre2_clk = false,
 500                 .auto_boot = true,
 501                 .ssr_name = "lpass",
 502                 .sysmon_name = "adsp",
 503                 .ssctl_id = 0x14,
 504 };
 505
 506 static const struct adsp_data sm8150_adsp_resource = {
 507                 .crash_reason_smem = 423,
 508                 .firmware_name = "/*(DEBLOBBED)*/",
 509                 .pas_id = 1,
 510                 .has_aggre2_clk = false,
 511                 .auto_boot = true,
 512                 .active_pd_names = (char*[]){
 513                         "load_state",
 514                         NULL
 515                 },
 516                 .proxy_pd_names = (char*[]){
 517                         "cx",
 518                         NULL
 519                 },
 520                 .ssr_name = "lpass",
 521                 .sysmon_name = "adsp",
 522                 .ssctl_id = 0x14,
 523 };
 524
 525 static const struct adsp_data sm8250_adsp_resource = {
 526         .crash_reason_smem = 423,
 527         .firmware_name = "/*(DEBLOBBED)*/",
 528         .pas_id = 1,
 529         .has_aggre2_clk = false,
 530         .auto_boot = true,
 531         .active_pd_names = (char*[]){
 532                 "load_state",
 533                 NULL
 534         },
 535         .proxy_pd_names = (char*[]){
 536                 "lcx",
 537                 "lmx",
 538                 NULL
 539         },
 540         .ssr_name = "lpass",
 541         .sysmon_name = "adsp",
 542         .ssctl_id = 0x14,
 543 };
 544
 545 static const struct adsp_data msm8998_adsp_resource = {
 546                 .crash_reason_smem = 423,
 547                 .firmware_name = "/*(DEBLOBBED)*/",
 548                 .pas_id = 1,
 549                 .has_aggre2_clk = false,
 550                 .auto_boot = true,
 551                 .proxy_pd_names = (char*[]){
 552                         "cx",
 553                         NULL
 554                 },
 555                 .ssr_name = "lpass",
 556                 .sysmon_name = "adsp",
 557                 .ssctl_id = 0x14,
 558 };
 559
 560 static const struct adsp_data cdsp_resource_init = {
 561         .crash_reason_smem = 601,
 562         .firmware_name = "/*(DEBLOBBED)*/",
 563         .pas_id = 18,
 564         .has_aggre2_clk = false,
 565         .auto_boot = true,
 566         .ssr_name = "cdsp",
 567         .sysmon_name = "cdsp",
 568         .ssctl_id = 0x17,
 569 };
 570
 571 static const struct adsp_data sm8150_cdsp_resource = {
 572         .crash_reason_smem = 601,
 573         .firmware_name = "/*(DEBLOBBED)*/",
 574         .pas_id = 18,
 575         .has_aggre2_clk = false,
 576         .auto_boot = true,
 577         .active_pd_names = (char*[]){
 578                 "load_state",
 579                 NULL
 580         },
 581         .proxy_pd_names = (char*[]){
 582                 "cx",
 583                 NULL
 584         },
 585         .ssr_name = "cdsp",
 586         .sysmon_name = "cdsp",
 587         .ssctl_id = 0x17,
 588 };
 589
 590 static const struct adsp_data sm8250_cdsp_resource = {
 591         .crash_reason_smem = 601,
 592         .firmware_name = "/*(DEBLOBBED)*/",
 593         .pas_id = 18,
 594         .has_aggre2_clk = false,
 595         .auto_boot = true,
 596         .active_pd_names = (char*[]){
 597                 "load_state",
 598                 NULL
 599         },
 600         .proxy_pd_names = (char*[]){
 601                 "cx",
 602                 NULL
 603         },
 604         .ssr_name = "cdsp",
 605         .sysmon_name = "cdsp",
 606         .ssctl_id = 0x17,
 607 };
 608
 609 static const struct adsp_data mpss_resource_init = {
 610         .crash_reason_smem = 421,
 611         .firmware_name = "/*(DEBLOBBED)*/",
 612         .pas_id = 4,
 613         .has_aggre2_clk = false,
 614         .auto_boot = false,
 615         .active_pd_names = (char*[]){
 616                 "load_state",
 617                 NULL
 618         },
 619         .proxy_pd_names = (char*[]){
 620                 "cx",
 621                 "mss",
 622                 NULL
 623         },
 624         .ssr_name = "mpss",
 625         .sysmon_name = "modem",
 626         .ssctl_id = 0x12,
 627 };
 628
 629 static const struct adsp_data slpi_resource_init = {
 630                 .crash_reason_smem = 424,
 631                 .firmware_name = "/*(DEBLOBBED)*/",
 632                 .pas_id = 12,
 633                 .has_aggre2_clk = true,
 634                 .auto_boot = true,
 635                 .ssr_name = "dsps",
 636                 .sysmon_name = "slpi",
 637                 .ssctl_id = 0x16,
 638 };
 639
 640 static const struct adsp_data sm8150_slpi_resource = {
 641                 .crash_reason_smem = 424,
 642                 .firmware_name = "/*(DEBLOBBED)*/",
 643                 .pas_id = 12,
 644                 .has_aggre2_clk = false,
 645                 .auto_boot = true,
 646                 .active_pd_names = (char*[]){
 647                         "load_state",
 648                         NULL
 649                 },
 650                 .proxy_pd_names = (char*[]){
 651                         "lcx",
 652                         "lmx",
 653                         NULL
 654                 },
 655                 .ssr_name = "dsps",
 656                 .sysmon_name = "slpi",
 657                 .ssctl_id = 0x16,
 658 };
 659
 660 static const struct adsp_data sm8250_slpi_resource = {
 661         .crash_reason_smem = 424,
 662         .firmware_name = "/*(DEBLOBBED)*/",
 663         .pas_id = 12,
 664         .has_aggre2_clk = false,
 665         .auto_boot = true,
 666         .active_pd_names = (char*[]){
 667                 "load_state",
 668                 NULL
 669         },
 670         .proxy_pd_names = (char*[]){
 671                 "lcx",
 672                 "lmx",
 673                 NULL
 674         },
 675         .ssr_name = "dsps",
 676         .sysmon_name = "slpi",
 677         .ssctl_id = 0x16,
 678 };
 679
 680 static const struct adsp_data msm8998_slpi_resource = {
 681                 .crash_reason_smem = 424,
 682                 .firmware_name = "/*(DEBLOBBED)*/",
 683                 .pas_id = 12,
 684                 .has_aggre2_clk = true,
 685                 .auto_boot = true,
 686                 .proxy_pd_names = (char*[]){
 687                         "ssc_cx",
 688                         NULL
 689                 },
 690                 .ssr_name = "dsps",
 691                 .sysmon_name = "slpi",
 692                 .ssctl_id = 0x16,
 693 };
 694
 695 static const struct adsp_data wcss_resource_init = {
 696         .crash_reason_smem = 421,
 697         .firmware_name = "/*(DEBLOBBED)*/",
 698         .pas_id = 6,
 699         .auto_boot = true,
 700         .ssr_name = "mpss",
 701         .sysmon_name = "wcnss",
 702         .ssctl_id = 0x12,
 703 };
 704
 705 static const struct of_device_id adsp_of_match[] = {
 706         { .compatible = "qcom,msm8974-adsp-pil", .data = &adsp_resource_init},
 707         { .compatible = "qcom,msm8996-adsp-pil", .data = &adsp_resource_init},
 708         { .compatible = "qcom,msm8996-slpi-pil", .data = &slpi_resource_init},
 709         { .compatible = "qcom,msm8998-adsp-pas", .data = &msm8998_adsp_resource},
 710         { .compatible = "qcom,msm8998-slpi-pas", .data = &msm8998_slpi_resource},
 711         { .compatible = "qcom,qcs404-adsp-pas", .data = &adsp_resource_init },
 712         { .compatible = "qcom,qcs404-cdsp-pas", .data = &cdsp_resource_init },
 713         { .compatible = "qcom,qcs404-wcss-pas", .data = &wcss_resource_init },
 714         { .compatible = "qcom,sc7180-mpss-pas", .data = &mpss_resource_init},
 715         { .compatible = "qcom,sdm845-adsp-pas", .data = &adsp_resource_init},
 716         { .compatible = "qcom,sdm845-cdsp-pas", .data = &cdsp_resource_init},
 717         { .compatible = "qcom,sm8150-adsp-pas", .data = &sm8150_adsp_resource},
 718         { .compatible = "qcom,sm8150-cdsp-pas", .data = &sm8150_cdsp_resource},
 719         { .compatible = "qcom,sm8150-mpss-pas", .data = &mpss_resource_init},
 720         { .compatible = "qcom,sm8150-slpi-pas", .data = &sm8150_slpi_resource},
 721         { .compatible = "qcom,sm8250-adsp-pas", .data = &sm8250_adsp_resource},
 722         { .compatible = "qcom,sm8250-cdsp-pas", .data = &sm8250_cdsp_resource},
 723         { .compatible = "qcom,sm8250-slpi-pas", .data = &sm8250_slpi_resource},
 724         { },
 725 };
 726 MODULE_DEVICE_TABLE(of, adsp_of_match);
 727
 728 static struct platform_driver adsp_driver = {
 729         .probe = adsp_probe,
 730         .remove = adsp_remove,
 731         .driver = {
 732                 .name = "qcom_q6v5_pas",
 733                 .of_match_table = adsp_of_match,
 734         },
 735 };
 736
 737 module_platform_driver(adsp_driver);
 738 MODULE_DESCRIPTION("Qualcomm Hexagon v5 Peripheral Authentication Service driver");
 739 MODULE_LICENSE("GPL v2");