drivers/remoteproc/qcom_tz_pil.c

   1 /*
   2  * Qualcomm Peripheral Image Loader
   3  *
   4  * Copyright (C) 2014 Sony Mobile Communications AB
   5  * Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * version 2 as published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  */
  16
  17 #include <linux/kernel.h>
  18 #include <linux/module.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/dma-mapping.h>
  21 #include <linux/firmware.h>
  22 #include <linux/remoteproc.h>
  23 #include <linux/interrupt.h>
  24 #include <linux/memblock.h>
  25 #include <linux/gpio/consumer.h>
  26 #include <linux/of.h>
  27 #include <linux/elf.h>
  28 #include <linux/clk.h>
  29 #include <linux/slab.h>
  30 #include <linux/regulator/consumer.h>
  31 #include <linux/soc/qcom/smem.h>
  32
  33 #include "remoteproc_internal.h"
  34
  35 #include "../../arch/arm/mach-qcom/scm.h"
  36
  37 extern int scm_is_call_available(u32 svc_id, u32 cmd_id);
  38
  39 #define PAS_INIT_IMAGE_CMD      1
  40 #define PAS_MEM_SETUP_CMD       2
  41 #define PAS_AUTH_AND_RESET_CMD  5
  42 #define PAS_SHUTDOWN_CMD        6
  43 #define PAS_IS_SUPPORTED_CMD    7
  44
  45 struct qproc {
  46         struct device *dev;
  47         struct rproc *rproc;
  48
  49         int pas_id;
  50
  51         int wdog_irq;
  52         int fatal_irq;
  53         int ready_irq;
  54         int handover_irq;
  55         int stop_ack_irq;
  56
  57         struct gpio_desc *stop_gpio;
  58
  59         const char *name;
  60         struct regulator *pll;
  61
  62         unsigned proxy_clk_count;
  63         struct clk *scm_core_clk;
  64         struct clk *scm_iface_clk;
  65         struct clk *scm_bus_clk;
  66
  67         struct clk **proxy_clks;
  68
  69         struct completion start_done;
  70         struct completion stop_done;
  71
  72         struct qcom_smem_item crash_reason;
  73 };
  74
  75 static int pas_supported(int id)
  76 {
  77         u32 periph = id;
  78         u32 ret_val;
  79         int ret;
  80
  81         ret = scm_is_call_available(SCM_SVC_PIL, PAS_IS_SUPPORTED_CMD);
  82         if (ret <= 0)
  83                 return 0;
  84
  85         ret = scm_call(SCM_SVC_PIL, PAS_IS_SUPPORTED_CMD,
  86                        &periph, sizeof(periph),
  87                        &ret_val, sizeof(ret_val));
  88
  89         return ret ? : ret_val;
  90 }
  91
  92 static int pas_init_image(int id, const char *metadata, size_t size)
  93 {
  94         dma_addr_t mdata_phys;
  95         void *mdata_buf;
  96         u32 scm_ret;
  97         int ret;
  98         struct pas_init_image_req {
  99                 u32 proc;
 100                 u32 image_addr;
 101         } request;
 102
 103         mdata_buf = dma_alloc_coherent(NULL, size, &mdata_phys, GFP_KERNEL);
 104         if (!mdata_buf) {
 105                 pr_err("Allocation for metadata failed.\n");
 106                 return -ENOMEM;
 107         }
 108
 109         memcpy(mdata_buf, metadata, size);
 110         outer_flush_range(request.image_addr, request.image_addr + size);
 111
 112         request.proc = id;
 113         request.image_addr = mdata_phys;
 114
 115         ret = scm_call(SCM_SVC_PIL, PAS_INIT_IMAGE_CMD,
 116                        &request, sizeof(request),
 117                        &scm_ret, sizeof(scm_ret));
 118
 119         dma_free_coherent(NULL, size, mdata_buf, mdata_phys);
 120
 121         return ret ? : scm_ret;
 122 }
 123
 124 static int pas_mem_setup(int id, phys_addr_t start_addr, phys_addr_t size)
 125 {
 126         u32 scm_ret;
 127         int ret;
 128         struct pas_init_image_req {
 129                 u32 proc;
 130                 u32 start_addr;
 131                 u32 len;
 132         } request;
 133
 134         request.proc = id;
 135         request.start_addr = start_addr;
 136         request.len = size;
 137
 138         ret = scm_call(SCM_SVC_PIL, PAS_MEM_SETUP_CMD,
 139                        &request, sizeof(request),
 140                        &scm_ret, sizeof(scm_ret));
 141
 142         return ret ? : scm_ret;
 143 }
 144
 145 static int pas_auth_and_reset(int id)
 146 {
 147         u32 proc = id;
 148         u32 scm_ret;
 149         int ret;
 150
 151         ret = scm_call(SCM_SVC_PIL, PAS_AUTH_AND_RESET_CMD,
 152                        &proc, sizeof(proc),
 153                        &scm_ret, sizeof(scm_ret));
 154
 155         return ret ? : scm_ret;
 156 }
 157
 158 static int pas_shutdown(int id)
 159 {
 160         u32 scm_ret;
 161         u32 proc = id;
 162         int ret;
 163
 164         ret = scm_call(SCM_SVC_PIL, PAS_SHUTDOWN_CMD,
 165                        &proc, sizeof(proc),
 166                        &scm_ret, sizeof(scm_ret));
 167
 168         return ret ? : scm_ret;
 169 }
 170
 171 static int qproc_scm_clk_enable(struct qproc *qproc)
 172 {
 173         int ret;
 174
 175         ret = clk_prepare_enable(qproc->scm_core_clk);
 176         if (ret)
 177                 goto bail;
 178         ret = clk_prepare_enable(qproc->scm_iface_clk);
 179         if (ret)
 180                 goto disable_core;
 181         ret = clk_prepare_enable(qproc->scm_bus_clk);
 182         if (ret)
 183                 goto disable_iface;
 184
 185         return 0;
 186
 187 disable_iface:
 188         clk_disable_unprepare(qproc->scm_iface_clk);
 189 disable_core:
 190         clk_disable_unprepare(qproc->scm_core_clk);
 191 bail:
 192         return ret;
 193 }
 194
 195 static void qproc_scm_clk_disable(struct qproc *qproc)
 196 {
 197         clk_disable_unprepare(qproc->scm_core_clk);
 198         clk_disable_unprepare(qproc->scm_iface_clk);
 199         clk_disable_unprepare(qproc->scm_bus_clk);
 200 }
 201
 202 /**
 203  * struct pil_mdt - Representation of <name>.mdt file in memory
 204  * @hdr: ELF32 header
 205  * @phdr: ELF32 program headers
 206  */
 207 struct mdt_hdr {
 208         struct elf32_hdr hdr;
 209         struct elf32_phdr phdr[];
 210 };
 211
 212 #define segment_is_hash(flag) (((flag) & (0x7 << 24)) == (0x2 << 24))
 213
 214 static int segment_is_loadable(const struct elf32_phdr *p)
 215 {
 216         return (p->p_type == PT_LOAD) &&
 217                !segment_is_hash(p->p_flags) &&
 218                p->p_memsz;
 219 }
 220
 221 static bool segment_is_relocatable(const struct elf32_phdr *p)
 222 {
 223         return !!(p->p_flags & BIT(27));
 224 }
 225
 226 /**
 227  * rproc_mdt_sanity_check() - sanity check mdt firmware header
 228  * @rproc: the remote processor handle
 229  * @fw: the mdt header firmware image
 230  */
 231 static int qproc_sanity_check(struct rproc *rproc,
 232                                   const struct firmware *fw)
 233 {
 234         struct elf32_hdr *ehdr;
 235         struct mdt_hdr *mdt;
 236
 237         if (!fw) {
 238                 dev_err(&rproc->dev, "failed to load %s\n", rproc->name);
 239                 return -EINVAL;
 240         }
 241
 242         if (fw->size < sizeof(struct elf32_hdr)) {
 243                 dev_err(&rproc->dev, "image is too small\n");
 244                 return -EINVAL;
 245         }
 246
 247         mdt = (struct mdt_hdr *)fw->data;
 248         ehdr = &mdt->hdr;
 249
 250         if (memcmp(ehdr->e_ident, ELFMAG, SELFMAG)) {
 251                 dev_err(&rproc->dev, "image is corrupted (bad magic)\n");
 252                 return -EINVAL;
 253         }
 254
 255         if (ehdr->e_phnum == 0) {
 256                 dev_err(&rproc->dev, "no loadable segments\n");
 257                 return -EINVAL;
 258         }
 259
 260         if (sizeof(struct elf32_phdr) * ehdr->e_phnum +
 261             sizeof(struct elf32_hdr) > fw->size) {
 262                 dev_err(&rproc->dev, "firmware size is too small\n");
 263                 return -EINVAL;
 264         }
 265
 266         return 0;
 267 }
 268
 269 static struct resource_table * qproc_find_rsc_table(struct rproc *rproc,
 270                                                     const struct firmware *fw,
 271                                                     int *tablesz)
 272 {
 273         static struct resource_table table = { .ver = 1, };
 274
 275         *tablesz = sizeof(table);
 276         return &table;
 277 }
 278
 279 static int qproc_load_segment(struct rproc *rproc, const char *fw_name, const struct elf32_phdr *phdr)
 280 {
 281         const struct firmware *fw;
 282         void *ptr;
 283         int ret = 0;
 284
 285         ptr = ioremap(phdr->p_paddr, phdr->p_memsz);
 286         if (!ptr) {
 287                 dev_err(&rproc->dev, "failed to ioremap segment area (0x%x+0x%x)\n", phdr->p_paddr, phdr->p_memsz);
 288                 return -EBUSY;
 289         }
 290
 291         if (phdr->p_filesz) {
 292                 ret = request_firmware(&fw, fw_name, &rproc->dev);
 293                 if (ret) {
 294                         dev_err(&rproc->dev, "failed to load %s\n", fw_name);
 295                         goto out;
 296                 }
 297
 298                 memcpy(ptr, fw->data, fw->size);
 299
 300                 release_firmware(fw);
 301         }
 302
 303         if (phdr->p_memsz > phdr->p_filesz)
 304                 memset(ptr + phdr->p_filesz, 0, phdr->p_memsz - phdr->p_filesz);
 305
 306 out:
 307         iounmap(ptr);
 308         return ret;
 309 }
 310
 311 static int qproc_load(struct rproc *rproc, const struct firmware *fw)
 312 {
 313         const struct elf32_phdr *phdr;
 314         const struct elf32_hdr *ehdr;
 315         const struct mdt_hdr *mdt;
 316         phys_addr_t min_addr = (phys_addr_t)ULLONG_MAX;
 317         phys_addr_t max_addr = 0;
 318         struct qproc *qproc = rproc->priv;
 319         char *fw_name;
 320         int ret;
 321         int i;
 322
 323         ret = qproc_scm_clk_enable(qproc);
 324         if (ret)
 325                 return ret;
 326
 327         mdt = (struct mdt_hdr *)fw->data;
 328         ehdr = &mdt->hdr;
 329
 330         for (i = 0; i < ehdr->e_phnum; i++) {
 331                 phdr = &mdt->phdr[i];
 332
 333                 if (!segment_is_loadable(phdr))
 334                         continue;
 335
 336                 if (segment_is_relocatable(phdr)) {
 337                         dev_err(&rproc->dev, "relocation unsupported\n");
 338                         return -EINVAL;
 339                 }
 340
 341                 if (phdr->p_paddr < min_addr)
 342                         min_addr = phdr->p_paddr;
 343
 344                 if (phdr->p_paddr + phdr->p_memsz > max_addr)
 345                         max_addr = ALIGN(phdr->p_paddr + phdr->p_memsz, SZ_4K);
 346         }
 347
 348         ret = pas_init_image(qproc->pas_id, fw->data, fw->size);
 349         if (ret) {
 350                 dev_err(qproc->dev, "Invalid firmware metadata\n");
 351                 return -EINVAL;
 352         }
 353
 354         dev_dbg(qproc->dev, "pas_mem_setup(0x%x, 0x%x)\n", min_addr, max_addr - min_addr);
 355
 356         ret = pas_mem_setup(qproc->pas_id, min_addr, max_addr - min_addr);
 357         if (ret) {
 358                 dev_err(qproc->dev, "unable to setup memory for image\n");
 359                 return -EINVAL;
 360         }
 361
 362         fw_name = kzalloc(strlen(qproc->name) + 5, GFP_KERNEL);
 363         if (!fw_name)
 364                 return -ENOMEM;
 365
 366         for (i = 0; i < ehdr->e_phnum; i++) {
 367                 phdr = &mdt->phdr[i];
 368
 369                 if (!segment_is_loadable(phdr))
 370                         continue;
 371
 372                 sprintf(fw_name, "%s.b%02d", qproc->name, i);
 373                 ret = qproc_load_segment(rproc, fw_name, phdr);
 374                 if (ret)
 375                         break;
 376         }
 377
 378         kfree(fw_name);
 379
 380         qproc_scm_clk_disable(qproc);
 381
 382         return 0;
 383 }
 384
 385 const struct rproc_fw_ops qproc_fw_ops = {
 386         .find_rsc_table = qproc_find_rsc_table,
 387         .load = qproc_load,
 388         .sanity_check = qproc_sanity_check,
 389 };
 390
 391 static int qproc_start(struct rproc *rproc)
 392 {
 393         struct qproc *qproc = (struct qproc *)rproc->priv;
 394         int ret;
 395
 396         ret = regulator_enable(qproc->pll);
 397         if (ret) {
 398                 dev_err(qproc->dev, "failed to enable pll supply\n");
 399                 return ret;
 400         }
 401
 402         ret = qproc_scm_clk_enable(qproc);
 403         if (ret)
 404                 goto disable_regulator;
 405
 406         ret = pas_auth_and_reset(qproc->pas_id);
 407         if (ret) {
 408                 dev_err(qproc->dev,
 409                                 "failed to authenticate image and release reset\n");
 410                 goto unroll_clocks;
 411         }
 412
 413         ret = wait_for_completion_timeout(&qproc->start_done, msecs_to_jiffies(10000));
 414         if (ret == 0) {
 415                 dev_err(qproc->dev, "start timed out\n");
 416
 417                 pas_shutdown(qproc->pas_id);
 418                 goto unroll_clocks;
 419         }
 420
 421         return 0;
 422
 423 unroll_clocks:
 424         qproc_scm_clk_disable(qproc);
 425
 426 disable_regulator:
 427         regulator_disable(qproc->pll);
 428
 429         return ret;
 430 }
 431
 432 static int qproc_stop(struct rproc *rproc)
 433 {
 434         struct qproc *qproc = (struct qproc *)rproc->priv;
 435         int ret;
 436
 437         gpiod_set_value(qproc->stop_gpio, 1);
 438
 439         ret = wait_for_completion_timeout(&qproc->stop_done, msecs_to_jiffies(1000));
 440         if (ret == 0) {
 441                 dev_err(qproc->dev, "timed out on wait\n");
 442                 return ret;
 443         }
 444
 445         gpiod_set_value(qproc->stop_gpio, 0);
 446
 447         ret = pas_shutdown(qproc->pas_id);
 448         if (ret)
 449                 dev_err(qproc->dev, "failed to shutdown: %d\n", ret);
 450         return ret;
 451 }
 452
 453 static const struct rproc_ops qproc_ops = {
 454         .start = qproc_start,
 455         .stop = qproc_stop,
 456 };
 457
 458 static irqreturn_t qproc_wdog_interrupt(int irq, void *dev)
 459 {
 460         struct qproc *qproc = dev;
 461
 462         rproc_report_crash(qproc->rproc, RPROC_WATCHDOG);
 463         return IRQ_HANDLED;
 464 }
 465
 466 static irqreturn_t qproc_fatal_interrupt(int irq, void *dev)
 467 {
 468         struct qproc *qproc = dev;
 469         size_t len;
 470         char *msg;
 471         int ret;
 472
 473         ret = qcom_smem_get(&qproc->crash_reason, (void**)&msg, &len);
 474         if (!ret && len > 0 && msg[0])
 475                 dev_err(qproc->dev, "fatal error received: %s\n", msg);
 476
 477         rproc_report_crash(qproc->rproc, RPROC_FATAL_ERROR);
 478
 479         if (!ret) {
 480                 msg[0] = '\0';
 481 #if 0
 482                 qcom_smem_put(qproc->smem, msg);
 483 #endif
 484         }
 485
 486         return IRQ_HANDLED;
 487 }
 488
 489 static irqreturn_t qproc_ready_interrupt(int irq, void *dev)
 490 {
 491         struct qproc *qproc = dev;
 492
 493         complete(&qproc->start_done);
 494
 495         return IRQ_HANDLED;
 496 }
 497
 498 static irqreturn_t qproc_handover_interrupt(int irq, void *dev)
 499 {
 500         struct qproc *qproc = dev;
 501
 502         qproc_scm_clk_disable(qproc);
 503         regulator_disable(qproc->pll);
 504         return IRQ_HANDLED;
 505 }
 506
 507 static irqreturn_t qproc_stop_ack_interrupt(int irq, void *dev)
 508 {
 509         struct qproc *qproc = dev;
 510
 511         complete(&qproc->stop_done);
 512         return IRQ_HANDLED;
 513 }
 514
 515 static ssize_t qproc_boot_store(struct device *dev,
 516                                 struct device_attribute *attr,
 517                                 const char *buf, size_t size)
 518 {
 519         struct qproc *qproc = dev_get_drvdata(dev);
 520         int ret;
 521
 522         ret = rproc_boot(qproc->rproc);
 523         return ret ? : size;
 524 }
 525
 526 static ssize_t qproc_shutdown_store(struct device *dev,
 527                                     struct device_attribute *attr,
 528                                     const char *buf, size_t size)
 529 {
 530         struct qproc *qproc = dev_get_drvdata(dev);
 531
 532         rproc_shutdown(qproc->rproc);
 533         return size;
 534 }
 535
 536 static const struct device_attribute qproc_attrs[] = {
 537         __ATTR(boot, S_IWUSR, 0, qproc_boot_store),
 538         __ATTR(shutdown, S_IWUSR, 0, qproc_shutdown_store),
 539 };
 540
 541 static int qproc_init_pas(struct qproc *qproc)
 542 {
 543         char *key;
 544         int ret;
 545
 546         key = "qcom,pas-id";
 547         ret = of_property_read_u32(qproc->dev->of_node, key, &qproc->pas_id);
 548         if (ret) {
 549                 dev_err(qproc->dev, "Missing or incorrect %s\n", key);
 550                 return -EINVAL;
 551         }
 552
 553         if (!pas_supported(qproc->pas_id)) {
 554                 dev_err(qproc->dev, "PAS is not available for %d\n", qproc->pas_id);
 555                 return -EIO;
 556         }
 557
 558         return 0;
 559 }
 560
 561 static int qproc_init_clocks(struct qproc *qproc)
 562 {
 563         long rate;
 564         int ret;
 565
 566         qproc->scm_core_clk = devm_clk_get(qproc->dev, "scm_core_clk");
 567         if (IS_ERR(qproc->scm_core_clk)) {
 568                 if (PTR_ERR(qproc->scm_core_clk) != -EPROBE_DEFER)
 569                         dev_err(qproc->dev, "failed to acquire scm_core_clk\n");
 570                 return PTR_ERR(qproc->scm_core_clk);
 571         }
 572
 573         qproc->scm_iface_clk = devm_clk_get(qproc->dev, "scm_iface_clk");
 574         if (IS_ERR(qproc->scm_iface_clk)) {
 575                 if (PTR_ERR(qproc->scm_iface_clk) != -EPROBE_DEFER)
 576                         dev_err(qproc->dev, "failed to acquire scm_iface_clk\n");
 577                 return PTR_ERR(qproc->scm_iface_clk);
 578         }
 579
 580         qproc->scm_bus_clk = devm_clk_get(qproc->dev, "scm_bus_clk");
 581         if (IS_ERR(qproc->scm_bus_clk)) {
 582                 if (PTR_ERR(qproc->scm_bus_clk) != -EPROBE_DEFER)
 583                         dev_err(qproc->dev, "failed to acquire scm_bus_clk\n");
 584                 return PTR_ERR(qproc->scm_bus_clk);
 585         }
 586
 587         rate = clk_round_rate(qproc->scm_core_clk, 50000000);
 588         ret = clk_set_rate(qproc->scm_core_clk, rate);
 589         if (ret) {
 590                 dev_err(qproc->dev, "failed to set rate of scm_core_clk\n");
 591                 return ret;
 592         }
 593
 594         return 0;
 595 }
 596
 597 static int qproc_init_regulators(struct qproc *qproc)
 598 {
 599         int ret;
 600         u32 uA;
 601         u32 uV;
 602
 603         qproc->pll = devm_regulator_get(qproc->dev, "qcom,pll");
 604         if (IS_ERR(qproc->pll)) {
 605                 if (PTR_ERR(qproc->pll) != -EPROBE_DEFER)
 606                         dev_err(qproc->dev, "failed to aquire regulator\n");
 607                 return PTR_ERR(qproc->pll);
 608         }
 609
 610         ret = of_property_read_u32(qproc->dev->of_node, "qcom,pll-uV", &uV);
 611         if (ret)
 612                 dev_warn(qproc->dev, "failed to read qcom,pll_uV, skipping\n");
 613         else
 614                 regulator_set_voltage(qproc->pll, uV, uV);
 615
 616         ret = of_property_read_u32(qproc->dev->of_node, "qcom,pll-uA", &uA);
 617         if (ret)
 618                 dev_warn(qproc->dev, "failed to read qcom,pll_uA, skipping\n");
 619         else
 620                 regulator_set_optimum_mode(qproc->pll, uA);
 621
 622         return 0;
 623 }
 624
 625 static int qproc_request_irq(struct qproc *qproc, struct platform_device *pdev, const char *name, irq_handler_t thread_fn)
 626 {
 627         int ret;
 628
 629         ret = platform_get_irq_byname(pdev, name);
 630         if (ret < 0) {
 631                 dev_err(&pdev->dev, "no %s IRQ defined\n", name);
 632                 return ret;
 633         }
 634
 635         ret = devm_request_threaded_irq(&pdev->dev, ret,
 636                                         NULL, thread_fn,
 637                                         IRQF_TRIGGER_RISING | IRQF_ONESHOT,
 638                                         "qproc", qproc);
 639         if (ret)
 640                 dev_err(&pdev->dev, "request %s IRQ failed\n", name);
 641         return ret;
 642 }
 643
 644 static int qproc_probe(struct platform_device *pdev)
 645 {
 646         struct qproc *qproc;
 647         struct rproc *rproc;
 648         char *fw_name;
 649         const char *name;
 650         const char *key;
 651         int ret;
 652         int i;
 653
 654         key = "qcom,firmware-name";
 655         ret = of_property_read_string(pdev->dev.of_node, key, &name);
 656         if (ret) {
 657                 dev_err(&pdev->dev, "missing or incorrect %s\n", key);
 658                 return -EINVAL;
 659         }
 660
 661         fw_name = devm_kasprintf(&pdev->dev, GFP_KERNEL, "%s.mdt", name);
 662         if (!fw_name)
 663                 return -ENOMEM;
 664
 665         rproc = rproc_alloc(&pdev->dev, pdev->name, &qproc_ops,
 666                             fw_name, sizeof(*qproc));
 667         if (!rproc)
 668                 return -ENOMEM;
 669
 670         rproc->fw_ops = &qproc_fw_ops;
 671
 672         qproc = (struct qproc *)rproc->priv;
 673         qproc->dev = &pdev->dev;
 674         qproc->rproc = rproc;
 675         qproc->name = name;
 676         platform_set_drvdata(pdev, qproc);
 677
 678         init_completion(&qproc->start_done);
 679         init_completion(&qproc->stop_done);
 680
 681         ret = of_parse_qcom_smem_item(pdev->dev.of_node,
 682                                       "qcom,crash-reason", 0,
 683                                       &qproc->crash_reason);
 684         if (ret) {
 685                 if (ret != -EPROBE_DEFER)
 686                         dev_err(&pdev->dev, "failed to acquire smem handle\n");
 687                 return ret;
 688         }
 689
 690         ret = qproc_init_pas(qproc);
 691         if (ret)
 692                 goto free_rproc;
 693
 694         ret = qproc_init_clocks(qproc);
 695         if (ret)
 696                 goto free_rproc;
 697
 698         ret = qproc_init_regulators(qproc);
 699         if (ret)
 700                 goto free_rproc;
 701
 702         ret = qproc_request_irq(qproc, pdev, "wdog", qproc_wdog_interrupt);
 703         if (ret < 0)
 704                 goto free_rproc;
 705         qproc->wdog_irq = ret;
 706
 707         ret = qproc_request_irq(qproc, pdev, "fatal", qproc_fatal_interrupt);
 708         if (ret < 0)
 709                 goto free_rproc;
 710         qproc->fatal_irq = ret;
 711
 712         ret = qproc_request_irq(qproc, pdev, "ready", qproc_ready_interrupt);
 713         if (ret < 0)
 714                 goto free_rproc;
 715         qproc->ready_irq = ret;
 716
 717         ret = qproc_request_irq(qproc, pdev, "handover", qproc_handover_interrupt);
 718         if (ret < 0)
 719                 goto free_rproc;
 720         qproc->handover_irq = ret;
 721
 722         ret = qproc_request_irq(qproc, pdev, "stop-ack", qproc_stop_ack_interrupt);
 723         if (ret < 0)
 724                 goto free_rproc;
 725         qproc->stop_ack_irq = ret;
 726
 727         qproc->stop_gpio = devm_gpiod_get(&pdev->dev, "qcom,stop", GPIOD_OUT_LOW);
 728         if (IS_ERR(qproc->stop_gpio)) {
 729                 dev_err(&pdev->dev, "failed to acquire stop gpio\n");
 730                 return PTR_ERR(qproc->stop_gpio);
 731         }
 732
 733         for (i = 0; i < ARRAY_SIZE(qproc_attrs); i++) {
 734                 ret = device_create_file(&pdev->dev, &qproc_attrs[i]);
 735                 if (ret) {
 736                         dev_err(&pdev->dev, "unable to create sysfs file\n");
 737                         goto remove_device_files;
 738                 }
 739         }
 740
 741         ret = rproc_add(rproc);
 742         if (ret)
 743                 goto remove_device_files;
 744
 745         return 0;
 746
 747 remove_device_files:
 748         for (i--; i >= 0; i--)
 749                 device_remove_file(&pdev->dev, &qproc_attrs[i]);
 750
 751 free_rproc:
 752         rproc_put(rproc);
 753
 754         return ret;
 755 }
 756
 757 static int qproc_remove(struct platform_device *pdev)
 758 {
 759         struct qproc *qproc = platform_get_drvdata(pdev);
 760         int i;
 761
 762         for (i = 0; i < ARRAY_SIZE(qproc_attrs); i++)
 763                 device_remove_file(&pdev->dev, &qproc_attrs[i]);
 764
 765         rproc_put(qproc->rproc);
 766
 767         return 0;
 768 }
 769
 770 static const struct of_device_id qproc_of_match[] = {
 771         { .compatible = "qcom,tz-pil", },
 772         { },
 773 };
 774
 775 static struct platform_driver qproc_driver = {
 776         .probe = qproc_probe,
 777         .remove = qproc_remove,
 778         .driver = {
 779                 .name = "qcom-tz-pil",
 780                 .owner = THIS_MODULE,
 781                 .of_match_table = qproc_of_match,
 782         },
 783 };
 784
 785 module_platform_driver(qproc_driver);