drivers/remoteproc/qcom_adsp_pil.c

   1 /*
   2  * Qualcomm ADSP/SLPI Peripheral Image Loader for MSM8974 and MSM8996
   3  *
   4  * Copyright (C) 2016 Linaro Ltd
   5  * Copyright (C) 2014 Sony Mobile Communications AB
   6  * Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * version 2 as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  */
  17
  18 #include <linux/clk.h>
  19 #include <linux/firmware.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/kernel.h>
  22 #include <linux/module.h>
  23 #include <linux/of_address.h>
  24 #include <linux/of_device.h>
  25 #include <linux/platform_device.h>
  26 #include <linux/qcom_scm.h>
  27 #include <linux/regulator/consumer.h>
  28 #include <linux/remoteproc.h>
  29 #include <linux/soc/qcom/mdt_loader.h>
  30 #include <linux/soc/qcom/smem.h>
  31 #include <linux/soc/qcom/smem_state.h>
  32
  33 #include "qcom_common.h"
  34 #include "remoteproc_internal.h"
  35
  36 struct adsp_data {
  37         int crash_reason_smem;
  38         const char *firmware_name;
  39         int pas_id;
  40         bool has_aggre2_clk;
  41         const char *ssr_name;
  42 };
  43
  44 struct qcom_adsp {
  45         struct device *dev;
  46         struct rproc *rproc;
  47
  48         int wdog_irq;
  49         int fatal_irq;
  50         int ready_irq;
  51         int handover_irq;
  52         int stop_ack_irq;
  53
  54         struct qcom_smem_state *state;
  55         unsigned stop_bit;
  56
  57         struct clk *xo;
  58         struct clk *aggre2_clk;
  59
  60         struct regulator *cx_supply;
  61         struct regulator *px_supply;
  62
  63         int pas_id;
  64         int crash_reason_smem;
  65         bool has_aggre2_clk;
  66
  67         struct completion start_done;
  68         struct completion stop_done;
  69
  70         phys_addr_t mem_phys;
  71         phys_addr_t mem_reloc;
  72         void *mem_region;
  73         size_t mem_size;
  74
  75         struct qcom_rproc_subdev smd_subdev;
  76         struct qcom_rproc_ssr ssr_subdev;
  77 };
  78
  79 static int adsp_load(struct rproc *rproc, const struct firmware *fw)
  80 {
  81         struct qcom_adsp *adsp = (struct qcom_adsp *)rproc->priv;
  82
  83         return qcom_mdt_load(adsp->dev, fw, rproc->firmware, adsp->pas_id,
  84                              adsp->mem_region, adsp->mem_phys, adsp->mem_size);
  85 }
  86
  87 static const struct rproc_fw_ops adsp_fw_ops = {
  88         .find_rsc_table = qcom_mdt_find_rsc_table,
  89         .load = adsp_load,
  90 };
  91
  92 static int adsp_start(struct rproc *rproc)
  93 {
  94         struct qcom_adsp *adsp = (struct qcom_adsp *)rproc->priv;
  95         int ret;
  96
  97         ret = clk_prepare_enable(adsp->xo);
  98         if (ret)
  99                 return ret;
 100
 101         ret = clk_prepare_enable(adsp->aggre2_clk);
 102         if (ret)
 103                 goto disable_xo_clk;
 104
 105         ret = regulator_enable(adsp->cx_supply);
 106         if (ret)
 107                 goto disable_aggre2_clk;
 108
 109         ret = regulator_enable(adsp->px_supply);
 110         if (ret)
 111                 goto disable_cx_supply;
 112
 113         ret = qcom_scm_pas_auth_and_reset(adsp->pas_id);
 114         if (ret) {
 115                 dev_err(adsp->dev,
 116                         "failed to authenticate image and release reset\n");
 117                 goto disable_px_supply;
 118         }
 119
 120         ret = wait_for_completion_timeout(&adsp->start_done,
 121                                           msecs_to_jiffies(5000));
 122         if (!ret) {
 123                 dev_err(adsp->dev, "start timed out\n");
 124                 qcom_scm_pas_shutdown(adsp->pas_id);
 125                 ret = -ETIMEDOUT;
 126                 goto disable_px_supply;
 127         }
 128
 129         ret = 0;
 130
 131 disable_px_supply:
 132         regulator_disable(adsp->px_supply);
 133 disable_cx_supply:
 134         regulator_disable(adsp->cx_supply);
 135 disable_aggre2_clk:
 136         clk_disable_unprepare(adsp->aggre2_clk);
 137 disable_xo_clk:
 138         clk_disable_unprepare(adsp->xo);
 139
 140         return ret;
 141 }
 142
 143 static int adsp_stop(struct rproc *rproc)
 144 {
 145         struct qcom_adsp *adsp = (struct qcom_adsp *)rproc->priv;
 146         int ret;
 147
 148         qcom_smem_state_update_bits(adsp->state,
 149                                     BIT(adsp->stop_bit),
 150                                     BIT(adsp->stop_bit));
 151
 152         ret = wait_for_completion_timeout(&adsp->stop_done,
 153                                           msecs_to_jiffies(5000));
 154         if (ret == 0)
 155                 dev_err(adsp->dev, "timed out on wait\n");
 156
 157         qcom_smem_state_update_bits(adsp->state,
 158                                     BIT(adsp->stop_bit),
 159                                     0);
 160
 161         ret = qcom_scm_pas_shutdown(adsp->pas_id);
 162         if (ret)
 163                 dev_err(adsp->dev, "failed to shutdown: %d\n", ret);
 164
 165         return ret;
 166 }
 167
 168 static void *adsp_da_to_va(struct rproc *rproc, u64 da, int len)
 169 {
 170         struct qcom_adsp *adsp = (struct qcom_adsp *)rproc->priv;
 171         int offset;
 172
 173         offset = da - adsp->mem_reloc;
 174         if (offset < 0 || offset + len > adsp->mem_size)
 175                 return NULL;
 176
 177         return adsp->mem_region + offset;
 178 }
 179
 180 static const struct rproc_ops adsp_ops = {
 181         .start = adsp_start,
 182         .stop = adsp_stop,
 183         .da_to_va = adsp_da_to_va,
 184 };
 185
 186 static irqreturn_t adsp_wdog_interrupt(int irq, void *dev)
 187 {
 188         struct qcom_adsp *adsp = dev;
 189
 190         rproc_report_crash(adsp->rproc, RPROC_WATCHDOG);
 191
 192         return IRQ_HANDLED;
 193 }
 194
 195 static irqreturn_t adsp_fatal_interrupt(int irq, void *dev)
 196 {
 197         struct qcom_adsp *adsp = dev;
 198         size_t len;
 199         char *msg;
 200
 201         msg = qcom_smem_get(QCOM_SMEM_HOST_ANY, adsp->crash_reason_smem, &len);
 202         if (!IS_ERR(msg) && len > 0 && msg[0])
 203                 dev_err(adsp->dev, "fatal error received: %s\n", msg);
 204
 205         rproc_report_crash(adsp->rproc, RPROC_FATAL_ERROR);
 206
 207         if (!IS_ERR(msg))
 208                 msg[0] = '\0';
 209
 210         return IRQ_HANDLED;
 211 }
 212
 213 static irqreturn_t adsp_ready_interrupt(int irq, void *dev)
 214 {
 215         return IRQ_HANDLED;
 216 }
 217
 218 static irqreturn_t adsp_handover_interrupt(int irq, void *dev)
 219 {
 220         struct qcom_adsp *adsp = dev;
 221
 222         complete(&adsp->start_done);
 223
 224         return IRQ_HANDLED;
 225 }
 226
 227 static irqreturn_t adsp_stop_ack_interrupt(int irq, void *dev)
 228 {
 229         struct qcom_adsp *adsp = dev;
 230
 231         complete(&adsp->stop_done);
 232
 233         return IRQ_HANDLED;
 234 }
 235
 236 static int adsp_init_clock(struct qcom_adsp *adsp)
 237 {
 238         int ret;
 239
 240         adsp->xo = devm_clk_get(adsp->dev, "xo");
 241         if (IS_ERR(adsp->xo)) {
 242                 ret = PTR_ERR(adsp->xo);
 243                 if (ret != -EPROBE_DEFER)
 244                         dev_err(adsp->dev, "failed to get xo clock");
 245                 return ret;
 246         }
 247
 248         if (adsp->has_aggre2_clk) {
 249                 adsp->aggre2_clk = devm_clk_get(adsp->dev, "aggre2");
 250                 if (IS_ERR(adsp->aggre2_clk)) {
 251                         ret = PTR_ERR(adsp->aggre2_clk);
 252                         if (ret != -EPROBE_DEFER)
 253                                 dev_err(adsp->dev,
 254                                         "failed to get aggre2 clock");
 255                         return ret;
 256                 }
 257         }
 258
 259         return 0;
 260 }
 261
 262 static int adsp_init_regulator(struct qcom_adsp *adsp)
 263 {
 264         adsp->cx_supply = devm_regulator_get(adsp->dev, "cx");
 265         if (IS_ERR(adsp->cx_supply))
 266                 return PTR_ERR(adsp->cx_supply);
 267
 268         regulator_set_load(adsp->cx_supply, 100000);
 269
 270         adsp->px_supply = devm_regulator_get(adsp->dev, "px");
 271         if (IS_ERR(adsp->px_supply))
 272                 return PTR_ERR(adsp->px_supply);
 273
 274         return 0;
 275 }
 276
 277 static int adsp_request_irq(struct qcom_adsp *adsp,
 278                              struct platform_device *pdev,
 279                              const char *name,
 280                              irq_handler_t thread_fn)
 281 {
 282         int ret;
 283
 284         ret = platform_get_irq_byname(pdev, name);
 285         if (ret < 0) {
 286                 dev_err(&pdev->dev, "no %s IRQ defined\n", name);
 287                 return ret;
 288         }
 289
 290         ret = devm_request_threaded_irq(&pdev->dev, ret,
 291                                         NULL, thread_fn,
 292                                         IRQF_ONESHOT,
 293                                         "adsp", adsp);
 294         if (ret)
 295                 dev_err(&pdev->dev, "request %s IRQ failed\n", name);
 296
 297         return ret;
 298 }
 299
 300 static int adsp_alloc_memory_region(struct qcom_adsp *adsp)
 301 {
 302         struct device_node *node;
 303         struct resource r;
 304         int ret;
 305
 306         node = of_parse_phandle(adsp->dev->of_node, "memory-region", 0);
 307         if (!node) {
 308                 dev_err(adsp->dev, "no memory-region specified\n");
 309                 return -EINVAL;
 310         }
 311
 312         ret = of_address_to_resource(node, 0, &r);
 313         if (ret)
 314                 return ret;
 315
 316         adsp->mem_phys = adsp->mem_reloc = r.start;
 317         adsp->mem_size = resource_size(&r);
 318         adsp->mem_region = devm_ioremap_wc(adsp->dev, adsp->mem_phys, adsp->mem_size);
 319         if (!adsp->mem_region) {
 320                 dev_err(adsp->dev, "unable to map memory region: %pa+%zx\n",
 321                         &r.start, adsp->mem_size);
 322                 return -EBUSY;
 323         }
 324
 325         return 0;
 326 }
 327
 328 static int adsp_probe(struct platform_device *pdev)
 329 {
 330         const struct adsp_data *desc;
 331         struct qcom_adsp *adsp;
 332         struct rproc *rproc;
 333         int ret;
 334
 335         desc = of_device_get_match_data(&pdev->dev);
 336         if (!desc)
 337                 return -EINVAL;
 338
 339         if (!qcom_scm_is_available())
 340                 return -EPROBE_DEFER;
 341
 342         rproc = rproc_alloc(&pdev->dev, pdev->name, &adsp_ops,
 343                             desc->firmware_name, sizeof(*adsp));
 344         if (!rproc) {
 345                 dev_err(&pdev->dev, "unable to allocate remoteproc\n");
 346                 return -ENOMEM;
 347         }
 348
 349         rproc->fw_ops = &adsp_fw_ops;
 350
 351         adsp = (struct qcom_adsp *)rproc->priv;
 352         adsp->dev = &pdev->dev;
 353         adsp->rproc = rproc;
 354         adsp->pas_id = desc->pas_id;
 355         adsp->crash_reason_smem = desc->crash_reason_smem;
 356         adsp->has_aggre2_clk = desc->has_aggre2_clk;
 357         platform_set_drvdata(pdev, adsp);
 358
 359         init_completion(&adsp->start_done);
 360         init_completion(&adsp->stop_done);
 361
 362         ret = adsp_alloc_memory_region(adsp);
 363         if (ret)
 364                 goto free_rproc;
 365
 366         ret = adsp_init_clock(adsp);
 367         if (ret)
 368                 goto free_rproc;
 369
 370         ret = adsp_init_regulator(adsp);
 371         if (ret)
 372                 goto free_rproc;
 373
 374         ret = adsp_request_irq(adsp, pdev, "wdog", adsp_wdog_interrupt);
 375         if (ret < 0)
 376                 goto free_rproc;
 377         adsp->wdog_irq = ret;
 378
 379         ret = adsp_request_irq(adsp, pdev, "fatal", adsp_fatal_interrupt);
 380         if (ret < 0)
 381                 goto free_rproc;
 382         adsp->fatal_irq = ret;
 383
 384         ret = adsp_request_irq(adsp, pdev, "ready", adsp_ready_interrupt);
 385         if (ret < 0)
 386                 goto free_rproc;
 387         adsp->ready_irq = ret;
 388
 389         ret = adsp_request_irq(adsp, pdev, "handover", adsp_handover_interrupt);
 390         if (ret < 0)
 391                 goto free_rproc;
 392         adsp->handover_irq = ret;
 393
 394         ret = adsp_request_irq(adsp, pdev, "stop-ack", adsp_stop_ack_interrupt);
 395         if (ret < 0)
 396                 goto free_rproc;
 397         adsp->stop_ack_irq = ret;
 398
 399         adsp->state = qcom_smem_state_get(&pdev->dev, "stop",
 400                                           &adsp->stop_bit);
 401         if (IS_ERR(adsp->state)) {
 402                 ret = PTR_ERR(adsp->state);
 403                 goto free_rproc;
 404         }
 405
 406         qcom_add_smd_subdev(rproc, &adsp->smd_subdev);
 407         qcom_add_ssr_subdev(rproc, &adsp->ssr_subdev, desc->ssr_name);
 408
 409         ret = rproc_add(rproc);
 410         if (ret)
 411                 goto free_rproc;
 412
 413         return 0;
 414
 415 free_rproc:
 416         rproc_free(rproc);
 417
 418         return ret;
 419 }
 420
 421 static int adsp_remove(struct platform_device *pdev)
 422 {
 423         struct qcom_adsp *adsp = platform_get_drvdata(pdev);
 424
 425         qcom_smem_state_put(adsp->state);
 426         rproc_del(adsp->rproc);
 427
 428         qcom_remove_smd_subdev(adsp->rproc, &adsp->smd_subdev);
 429         qcom_remove_ssr_subdev(adsp->rproc, &adsp->ssr_subdev);
 430         rproc_free(adsp->rproc);
 431
 432         return 0;
 433 }
 434
 435 static const struct adsp_data adsp_resource_init = {
 436                 .crash_reason_smem = 423,
 437                 .firmware_name = "adsp.mdt",
 438                 .pas_id = 1,
 439                 .has_aggre2_clk = false,
 440                 .ssr_name = "lpass",
 441 };
 442
 443 static const struct adsp_data slpi_resource_init = {
 444                 .crash_reason_smem = 424,
 445                 .firmware_name = "slpi.mdt",
 446                 .pas_id = 12,
 447                 .has_aggre2_clk = true,
 448                 .ssr_name = "dsps",
 449 };
 450
 451 static const struct of_device_id adsp_of_match[] = {
 452         { .compatible = "qcom,msm8974-adsp-pil", .data = &adsp_resource_init},
 453         { .compatible = "qcom,msm8996-adsp-pil", .data = &adsp_resource_init},
 454         { .compatible = "qcom,msm8996-slpi-pil", .data = &slpi_resource_init},
 455         { },
 456 };
 457 MODULE_DEVICE_TABLE(of, adsp_of_match);
 458
 459 static struct platform_driver adsp_driver = {
 460         .probe = adsp_probe,
 461         .remove = adsp_remove,
 462         .driver = {
 463                 .name = "qcom_adsp_pil",
 464                 .of_match_table = adsp_of_match,
 465         },
 466 };
 467
 468 module_platform_driver(adsp_driver);
 469 MODULE_DESCRIPTION("Qualcomm MSM8974/MSM8996 ADSP Peripherial Image Loader");
 470 MODULE_LICENSE("GPL v2");