drivers/remoteproc/remoteproc_core.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Remote Processor Framework
   4  *
   5  * Copyright (C) 2011 Texas Instruments, Inc.
   6  * Copyright (C) 2011 Google, Inc.
   7  *
   8  * Ohad Ben-Cohen <ohad@wizery.com>
   9  * Brian Swetland <swetland@google.com>
  10  * Mark Grosen <mgrosen@ti.com>
  11  * Fernando Guzman Lugo <fernando.lugo@ti.com>
  12  * Suman Anna <s-anna@ti.com>
  13  * Robert Tivy <rtivy@ti.com>
  14  * Armando Uribe De Leon <x0095078@ti.com>
  15  */
  16
  17 #define pr_fmt(fmt)    "%s: " fmt, __func__
  18
  19 #include <linux/delay.h>
  20 #include <linux/kernel.h>
  21 #include <linux/module.h>
  22 #include <linux/device.h>
  23 #include <linux/panic_notifier.h>
  24 #include <linux/slab.h>
  25 #include <linux/mutex.h>
  26 #include <linux/dma-mapping.h>
  27 #include <linux/firmware.h>
  28 #include <linux/string.h>
  29 #include <linux/debugfs.h>
  30 #include <linux/rculist.h>
  31 #include <linux/remoteproc.h>
  32 #include <linux/iommu.h>
  33 #include <linux/idr.h>
  34 #include <linux/elf.h>
  35 #include <linux/crc32.h>
  36 #include <linux/of_reserved_mem.h>
  37 #include <linux/virtio_ids.h>
  38 #include <linux/virtio_ring.h>
  39 #include <asm/byteorder.h>
  40 #include <linux/platform_device.h>
  41
  42 #include "remoteproc_internal.h"
  43
  44 #define HIGH_BITS_MASK 0xFFFFFFFF00000000ULL
  45
  46 static DEFINE_MUTEX(rproc_list_mutex);
  47 static LIST_HEAD(rproc_list);
  48 static struct notifier_block rproc_panic_nb;
  49
  50 typedef int (*rproc_handle_resource_t)(struct rproc *rproc,
  51                                  void *, int offset, int avail);
  52
  53 static int rproc_alloc_carveout(struct rproc *rproc,
  54                                 struct rproc_mem_entry *mem);
  55 static int rproc_release_carveout(struct rproc *rproc,
  56                                   struct rproc_mem_entry *mem);
  57
  58 /* Unique indices for remoteproc devices */
  59 static DEFINE_IDA(rproc_dev_index);
  60 static struct workqueue_struct *rproc_recovery_wq;
  61
  62 static const char * const rproc_crash_names[] = {
  63         [RPROC_MMUFAULT]        = "mmufault",
  64         [RPROC_WATCHDOG]        = "watchdog",
  65         [RPROC_FATAL_ERROR]     = "fatal error",
  66 };
  67
  68 /* translate rproc_crash_type to string */
  69 static const char *rproc_crash_to_string(enum rproc_crash_type type)
  70 {
  71         if (type < ARRAY_SIZE(rproc_crash_names))
  72                 return rproc_crash_names[type];
  73         return "unknown";
  74 }
  75
  76 /*
  77  * This is the IOMMU fault handler we register with the IOMMU API
  78  * (when relevant; not all remote processors access memory through
  79  * an IOMMU).
  80  *
  81  * IOMMU core will invoke this handler whenever the remote processor
  82  * will try to access an unmapped device address.
  83  */
  84 static int rproc_iommu_fault(struct iommu_domain *domain, struct device *dev,
  85                              unsigned long iova, int flags, void *token)
  86 {
  87         struct rproc *rproc = token;
  88
  89         dev_err(dev, "iommu fault: da 0x%lx flags 0x%x\n", iova, flags);
  90
  91         rproc_report_crash(rproc, RPROC_MMUFAULT);
  92
  93         /*
  94          * Let the iommu core know we're not really handling this fault;
  95          * we just used it as a recovery trigger.
  96          */
  97         return -ENOSYS;
  98 }
  99
 100 static int rproc_enable_iommu(struct rproc *rproc)
 101 {
 102         struct iommu_domain *domain;
 103         struct device *dev = rproc->dev.parent;
 104         int ret;
 105
 106         if (!rproc->has_iommu) {
 107                 dev_dbg(dev, "iommu not present\n");
 108                 return 0;
 109         }
 110
 111         domain = iommu_domain_alloc(dev->bus);
 112         if (!domain) {
 113                 dev_err(dev, "can't alloc iommu domain\n");
 114                 return -ENOMEM;
 115         }
 116
 117         iommu_set_fault_handler(domain, rproc_iommu_fault, rproc);
 118
 119         ret = iommu_attach_device(domain, dev);
 120         if (ret) {
 121                 dev_err(dev, "can't attach iommu device: %d\n", ret);
 122                 goto free_domain;
 123         }
 124
 125         rproc->domain = domain;
 126
 127         return 0;
 128
 129 free_domain:
 130         iommu_domain_free(domain);
 131         return ret;
 132 }
 133
 134 static void rproc_disable_iommu(struct rproc *rproc)
 135 {
 136         struct iommu_domain *domain = rproc->domain;
 137         struct device *dev = rproc->dev.parent;
 138
 139         if (!domain)
 140                 return;
 141
 142         iommu_detach_device(domain, dev);
 143         iommu_domain_free(domain);
 144 }
 145
 146 phys_addr_t rproc_va_to_pa(void *cpu_addr)
 147 {
 148         /*
 149          * Return physical address according to virtual address location
 150          * - in vmalloc: if region ioremapped or defined as dma_alloc_coherent
 151          * - in kernel: if region allocated in generic dma memory pool
 152          */
 153         if (is_vmalloc_addr(cpu_addr)) {
 154                 return page_to_phys(vmalloc_to_page(cpu_addr)) +
 155                                     offset_in_page(cpu_addr);
 156         }
 157
 158         WARN_ON(!virt_addr_valid(cpu_addr));
 159         return virt_to_phys(cpu_addr);
 160 }
 161 EXPORT_SYMBOL(rproc_va_to_pa);
 162
 163 /**
 164  * rproc_da_to_va() - lookup the kernel virtual address for a remoteproc address
 165  * @rproc: handle of a remote processor
 166  * @da: remoteproc device address to translate
 167  * @len: length of the memory region @da is pointing to
 168  * @is_iomem: optional pointer filled in to indicate if @da is iomapped memory
 169  *
 170  * Some remote processors will ask us to allocate them physically contiguous
 171  * memory regions (which we call "carveouts"), and map them to specific
 172  * device addresses (which are hardcoded in the firmware). They may also have
 173  * dedicated memory regions internal to the processors, and use them either
 174  * exclusively or alongside carveouts.
 175  *
 176  * They may then ask us to copy objects into specific device addresses (e.g.
 177  * code/data sections) or expose us certain symbols in other device address
 178  * (e.g. their trace buffer).
 179  *
 180  * This function is a helper function with which we can go over the allocated
 181  * carveouts and translate specific device addresses to kernel virtual addresses
 182  * so we can access the referenced memory. This function also allows to perform
 183  * translations on the internal remoteproc memory regions through a platform
 184  * implementation specific da_to_va ops, if present.
 185  *
 186  * Note: phys_to_virt(iommu_iova_to_phys(rproc->domain, da)) will work too,
 187  * but only on kernel direct mapped RAM memory. Instead, we're just using
 188  * here the output of the DMA API for the carveouts, which should be more
 189  * correct.
 190  *
 191  * Return: a valid kernel address on success or NULL on failure
 192  */
 193 void *rproc_da_to_va(struct rproc *rproc, u64 da, size_t len, bool *is_iomem)
 194 {
 195         struct rproc_mem_entry *carveout;
 196         void *ptr = NULL;
 197
 198         if (rproc->ops->da_to_va) {
 199                 ptr = rproc->ops->da_to_va(rproc, da, len, is_iomem);
 200                 if (ptr)
 201                         goto out;
 202         }
 203
 204         list_for_each_entry(carveout, &rproc->carveouts, node) {
 205                 int offset = da - carveout->da;
 206
 207                 /*  Verify that carveout is allocated */
 208                 if (!carveout->va)
 209                         continue;
 210
 211                 /* try next carveout if da is too small */
 212                 if (offset < 0)
 213                         continue;
 214
 215                 /* try next carveout if da is too large */
 216                 if (offset + len > carveout->len)
 217                         continue;
 218
 219                 ptr = carveout->va + offset;
 220
 221                 if (is_iomem)
 222                         *is_iomem = carveout->is_iomem;
 223
 224                 break;
 225         }
 226
 227 out:
 228         return ptr;
 229 }
 230 EXPORT_SYMBOL(rproc_da_to_va);
 231
 232 /**
 233  * rproc_find_carveout_by_name() - lookup the carveout region by a name
 234  * @rproc: handle of a remote processor
 235  * @name: carveout name to find (format string)
 236  * @...: optional parameters matching @name string
 237  *
 238  * Platform driver has the capability to register some pre-allacoted carveout
 239  * (physically contiguous memory regions) before rproc firmware loading and
 240  * associated resource table analysis. These regions may be dedicated memory
 241  * regions internal to the coprocessor or specified DDR region with specific
 242  * attributes
 243  *
 244  * This function is a helper function with which we can go over the
 245  * allocated carveouts and return associated region characteristics like
 246  * coprocessor address, length or processor virtual address.
 247  *
 248  * Return: a valid pointer on carveout entry on success or NULL on failure.
 249  */
 250 __printf(2, 3)
 251 struct rproc_mem_entry *
 252 rproc_find_carveout_by_name(struct rproc *rproc, const char *name, ...)
 253 {
 254         va_list args;
 255         char _name[32];
 256         struct rproc_mem_entry *carveout, *mem = NULL;
 257
 258         if (!name)
 259                 return NULL;
 260
 261         va_start(args, name);
 262         vsnprintf(_name, sizeof(_name), name, args);
 263         va_end(args);
 264
 265         list_for_each_entry(carveout, &rproc->carveouts, node) {
 266                 /* Compare carveout and requested names */
 267                 if (!strcmp(carveout->name, _name)) {
 268                         mem = carveout;
 269                         break;
 270                 }
 271         }
 272
 273         return mem;
 274 }
 275
 276 /**
 277  * rproc_check_carveout_da() - Check specified carveout da configuration
 278  * @rproc: handle of a remote processor
 279  * @mem: pointer on carveout to check
 280  * @da: area device address
 281  * @len: associated area size
 282  *
 283  * This function is a helper function to verify requested device area (couple
 284  * da, len) is part of specified carveout.
 285  * If da is not set (defined as FW_RSC_ADDR_ANY), only requested length is
 286  * checked.
 287  *
 288  * Return: 0 if carveout matches request else error
 289  */
 290 static int rproc_check_carveout_da(struct rproc *rproc,
 291                                    struct rproc_mem_entry *mem, u32 da, u32 len)
 292 {
 293         struct device *dev = &rproc->dev;
 294         int delta;
 295
 296         /* Check requested resource length */
 297         if (len > mem->len) {
 298                 dev_err(dev, "Registered carveout doesn't fit len request\n");
 299                 return -EINVAL;
 300         }
 301
 302         if (da != FW_RSC_ADDR_ANY && mem->da == FW_RSC_ADDR_ANY) {
 303                 /* Address doesn't match registered carveout configuration */
 304                 return -EINVAL;
 305         } else if (da != FW_RSC_ADDR_ANY && mem->da != FW_RSC_ADDR_ANY) {
 306                 delta = da - mem->da;
 307
 308                 /* Check requested resource belongs to registered carveout */
 309                 if (delta < 0) {
 310                         dev_err(dev,
 311                                 "Registered carveout doesn't fit da request\n");
 312                         return -EINVAL;
 313                 }
 314
 315                 if (delta + len > mem->len) {
 316                         dev_err(dev,
 317                                 "Registered carveout doesn't fit len request\n");
 318                         return -EINVAL;
 319                 }
 320         }
 321
 322         return 0;
 323 }
 324
 325 int rproc_alloc_vring(struct rproc_vdev *rvdev, int i)
 326 {
 327         struct rproc *rproc = rvdev->rproc;
 328         struct device *dev = &rproc->dev;
 329         struct rproc_vring *rvring = &rvdev->vring[i];
 330         struct fw_rsc_vdev *rsc;
 331         int ret, notifyid;
 332         struct rproc_mem_entry *mem;
 333         size_t size;
 334
 335         /* actual size of vring (in bytes) */
 336         size = PAGE_ALIGN(vring_size(rvring->num, rvring->align));
 337
 338         rsc = (void *)rproc->table_ptr + rvdev->rsc_offset;
 339
 340         /* Search for pre-registered carveout */
 341         mem = rproc_find_carveout_by_name(rproc, "vdev%dvring%d", rvdev->index,
 342                                           i);
 343         if (mem) {
 344                 if (rproc_check_carveout_da(rproc, mem, rsc->vring[i].da, size))
 345                         return -ENOMEM;
 346         } else {
 347                 /* Register carveout in list */
 348                 mem = rproc_mem_entry_init(dev, NULL, 0,
 349                                            size, rsc->vring[i].da,
 350                                            rproc_alloc_carveout,
 351                                            rproc_release_carveout,
 352                                            "vdev%dvring%d",
 353                                            rvdev->index, i);
 354                 if (!mem) {
 355                         dev_err(dev, "Can't allocate memory entry structure\n");
 356                         return -ENOMEM;
 357                 }
 358
 359                 rproc_add_carveout(rproc, mem);
 360         }
 361
 362         /*
 363          * Assign an rproc-wide unique index for this vring
 364          * TODO: assign a notifyid for rvdev updates as well
 365          * TODO: support predefined notifyids (via resource table)
 366          */
 367         ret = idr_alloc(&rproc->notifyids, rvring, 0, 0, GFP_KERNEL);
 368         if (ret < 0) {
 369                 dev_err(dev, "idr_alloc failed: %d\n", ret);
 370                 return ret;
 371         }
 372         notifyid = ret;
 373
 374         /* Potentially bump max_notifyid */
 375         if (notifyid > rproc->max_notifyid)
 376                 rproc->max_notifyid = notifyid;
 377
 378         rvring->notifyid = notifyid;
 379
 380         /* Let the rproc know the notifyid of this vring.*/
 381         rsc->vring[i].notifyid = notifyid;
 382         return 0;
 383 }
 384
 385 int
 386 rproc_parse_vring(struct rproc_vdev *rvdev, struct fw_rsc_vdev *rsc, int i)
 387 {
 388         struct rproc *rproc = rvdev->rproc;
 389         struct device *dev = &rproc->dev;
 390         struct fw_rsc_vdev_vring *vring = &rsc->vring[i];
 391         struct rproc_vring *rvring = &rvdev->vring[i];
 392
 393         dev_dbg(dev, "vdev rsc: vring%d: da 0x%x, qsz %d, align %d\n",
 394                 i, vring->da, vring->num, vring->align);
 395
 396         /* verify queue size and vring alignment are sane */
 397         if (!vring->num || !vring->align) {
 398                 dev_err(dev, "invalid qsz (%d) or alignment (%d)\n",
 399                         vring->num, vring->align);
 400                 return -EINVAL;
 401         }
 402
 403         rvring->num = vring->num;
 404         rvring->align = vring->align;
 405         rvring->rvdev = rvdev;
 406
 407         return 0;
 408 }
 409
 410 void rproc_free_vring(struct rproc_vring *rvring)
 411 {
 412         struct rproc *rproc = rvring->rvdev->rproc;
 413         int idx = rvring - rvring->rvdev->vring;
 414         struct fw_rsc_vdev *rsc;
 415
 416         idr_remove(&rproc->notifyids, rvring->notifyid);
 417
 418         /*
 419          * At this point rproc_stop() has been called and the installed resource
 420          * table in the remote processor memory may no longer be accessible. As
 421          * such and as per rproc_stop(), rproc->table_ptr points to the cached
 422          * resource table (rproc->cached_table).  The cached resource table is
 423          * only available when a remote processor has been booted by the
 424          * remoteproc core, otherwise it is NULL.
 425          *
 426          * Based on the above, reset the virtio device section in the cached
 427          * resource table only if there is one to work with.
 428          */
 429         if (rproc->table_ptr) {
 430                 rsc = (void *)rproc->table_ptr + rvring->rvdev->rsc_offset;
 431                 rsc->vring[idx].da = 0;
 432                 rsc->vring[idx].notifyid = -1;
 433         }
 434 }
 435
 436 void rproc_add_rvdev(struct rproc *rproc, struct rproc_vdev *rvdev)
 437 {
 438         if (rvdev && rproc)
 439                 list_add_tail(&rvdev->node, &rproc->rvdevs);
 440 }
 441
 442 void rproc_remove_rvdev(struct rproc_vdev *rvdev)
 443 {
 444         if (rvdev)
 445                 list_del(&rvdev->node);
 446 }
 447 /**
 448  * rproc_handle_vdev() - handle a vdev fw resource
 449  * @rproc: the remote processor
 450  * @ptr: the vring resource descriptor
 451  * @offset: offset of the resource entry
 452  * @avail: size of available data (for sanity checking the image)
 453  *
 454  * This resource entry requests the host to statically register a virtio
 455  * device (vdev), and setup everything needed to support it. It contains
 456  * everything needed to make it possible: the virtio device id, virtio
 457  * device features, vrings information, virtio config space, etc...
 458  *
 459  * Before registering the vdev, the vrings are allocated from non-cacheable
 460  * physically contiguous memory. Currently we only support two vrings per
 461  * remote processor (temporary limitation). We might also want to consider
 462  * doing the vring allocation only later when ->find_vqs() is invoked, and
 463  * then release them upon ->del_vqs().
 464  *
 465  * Note: @da is currently not really handled correctly: we dynamically
 466  * allocate it using the DMA API, ignoring requested hard coded addresses,
 467  * and we don't take care of any required IOMMU programming. This is all
 468  * going to be taken care of when the generic iommu-based DMA API will be
 469  * merged. Meanwhile, statically-addressed iommu-based firmware images should
 470  * use RSC_DEVMEM resource entries to map their required @da to the physical
 471  * address of their base CMA region (ouch, hacky!).
 472  *
 473  * Return: 0 on success, or an appropriate error code otherwise
 474  */
 475 static int rproc_handle_vdev(struct rproc *rproc, void *ptr,
 476                              int offset, int avail)
 477 {
 478         struct fw_rsc_vdev *rsc = ptr;
 479         struct device *dev = &rproc->dev;
 480         struct rproc_vdev *rvdev;
 481         size_t rsc_size;
 482         struct rproc_vdev_data rvdev_data;
 483         struct platform_device *pdev;
 484
 485         /* make sure resource isn't truncated */
 486         rsc_size = struct_size(rsc, vring, rsc->num_of_vrings);
 487         if (size_add(rsc_size, rsc->config_len) > avail) {
 488                 dev_err(dev, "vdev rsc is truncated\n");
 489                 return -EINVAL;
 490         }
 491
 492         /* make sure reserved bytes are zeroes */
 493         if (rsc->reserved[0] || rsc->reserved[1]) {
 494                 dev_err(dev, "vdev rsc has non zero reserved bytes\n");
 495                 return -EINVAL;
 496         }
 497
 498         dev_dbg(dev, "vdev rsc: id %d, dfeatures 0x%x, cfg len %d, %d vrings\n",
 499                 rsc->id, rsc->dfeatures, rsc->config_len, rsc->num_of_vrings);
 500
 501         /* we currently support only two vrings per rvdev */
 502         if (rsc->num_of_vrings > ARRAY_SIZE(rvdev->vring)) {
 503                 dev_err(dev, "too many vrings: %d\n", rsc->num_of_vrings);
 504                 return -EINVAL;
 505         }
 506
 507         rvdev_data.id = rsc->id;
 508         rvdev_data.index = rproc->nb_vdev++;
 509         rvdev_data.rsc_offset = offset;
 510         rvdev_data.rsc = rsc;
 511
 512         /*
 513          * When there is more than one remote processor, rproc->nb_vdev number is
 514          * same for each separate instances of "rproc". If rvdev_data.index is used
 515          * as device id, then we get duplication in sysfs, so need to use
 516          * PLATFORM_DEVID_AUTO to auto select device id.
 517          */
 518         pdev = platform_device_register_data(dev, "rproc-virtio", PLATFORM_DEVID_AUTO, &rvdev_data,
 519                                              sizeof(rvdev_data));
 520         if (IS_ERR(pdev)) {
 521                 dev_err(dev, "failed to create rproc-virtio device\n");
 522                 return PTR_ERR(pdev);
 523         }
 524
 525         return 0;
 526 }
 527
 528 /**
 529  * rproc_handle_trace() - handle a shared trace buffer resource
 530  * @rproc: the remote processor
 531  * @ptr: the trace resource descriptor
 532  * @offset: offset of the resource entry
 533  * @avail: size of available data (for sanity checking the image)
 534  *
 535  * In case the remote processor dumps trace logs into memory,
 536  * export it via debugfs.
 537  *
 538  * Currently, the 'da' member of @rsc should contain the device address
 539  * where the remote processor is dumping the traces. Later we could also
 540  * support dynamically allocating this address using the generic
 541  * DMA API (but currently there isn't a use case for that).
 542  *
 543  * Return: 0 on success, or an appropriate error code otherwise
 544  */
 545 static int rproc_handle_trace(struct rproc *rproc, void *ptr,
 546                               int offset, int avail)
 547 {
 548         struct fw_rsc_trace *rsc = ptr;
 549         struct rproc_debug_trace *trace;
 550         struct device *dev = &rproc->dev;
 551         char name[15];
 552
 553         if (sizeof(*rsc) > avail) {
 554                 dev_err(dev, "trace rsc is truncated\n");
 555                 return -EINVAL;
 556         }
 557
 558         /* make sure reserved bytes are zeroes */
 559         if (rsc->reserved) {
 560                 dev_err(dev, "trace rsc has non zero reserved bytes\n");
 561                 return -EINVAL;
 562         }
 563
 564         trace = kzalloc(sizeof(*trace), GFP_KERNEL);
 565         if (!trace)
 566                 return -ENOMEM;
 567
 568         /* set the trace buffer dma properties */
 569         trace->trace_mem.len = rsc->len;
 570         trace->trace_mem.da = rsc->da;
 571
 572         /* set pointer on rproc device */
 573         trace->rproc = rproc;
 574
 575         /* make sure snprintf always null terminates, even if truncating */
 576         snprintf(name, sizeof(name), "trace%d", rproc->num_traces);
 577
 578         /* create the debugfs entry */
 579         trace->tfile = rproc_create_trace_file(name, rproc, trace);
 580
 581         list_add_tail(&trace->node, &rproc->traces);
 582
 583         rproc->num_traces++;
 584
 585         dev_dbg(dev, "%s added: da 0x%x, len 0x%x\n",
 586                 name, rsc->da, rsc->len);
 587
 588         return 0;
 589 }
 590
 591 /**
 592  * rproc_handle_devmem() - handle devmem resource entry
 593  * @rproc: remote processor handle
 594  * @ptr: the devmem resource entry
 595  * @offset: offset of the resource entry
 596  * @avail: size of available data (for sanity checking the image)
 597  *
 598  * Remote processors commonly need to access certain on-chip peripherals.
 599  *
 600  * Some of these remote processors access memory via an iommu device,
 601  * and might require us to configure their iommu before they can access
 602  * the on-chip peripherals they need.
 603  *
 604  * This resource entry is a request to map such a peripheral device.
 605  *
 606  * These devmem entries will contain the physical address of the device in
 607  * the 'pa' member. If a specific device address is expected, then 'da' will
 608  * contain it (currently this is the only use case supported). 'len' will
 609  * contain the size of the physical region we need to map.
 610  *
 611  * Currently we just "trust" those devmem entries to contain valid physical
 612  * addresses, but this is going to change: we want the implementations to
 613  * tell us ranges of physical addresses the firmware is allowed to request,
 614  * and not allow firmwares to request access to physical addresses that
 615  * are outside those ranges.
 616  *
 617  * Return: 0 on success, or an appropriate error code otherwise
 618  */
 619 static int rproc_handle_devmem(struct rproc *rproc, void *ptr,
 620                                int offset, int avail)
 621 {
 622         struct fw_rsc_devmem *rsc = ptr;
 623         struct rproc_mem_entry *mapping;
 624         struct device *dev = &rproc->dev;
 625         int ret;
 626
 627         /* no point in handling this resource without a valid iommu domain */
 628         if (!rproc->domain)
 629                 return -EINVAL;
 630
 631         if (sizeof(*rsc) > avail) {
 632                 dev_err(dev, "devmem rsc is truncated\n");
 633                 return -EINVAL;
 634         }
 635
 636         /* make sure reserved bytes are zeroes */
 637         if (rsc->reserved) {
 638                 dev_err(dev, "devmem rsc has non zero reserved bytes\n");
 639                 return -EINVAL;
 640         }
 641
 642         mapping = kzalloc(sizeof(*mapping), GFP_KERNEL);
 643         if (!mapping)
 644                 return -ENOMEM;
 645
 646         ret = iommu_map(rproc->domain, rsc->da, rsc->pa, rsc->len, rsc->flags,
 647                         GFP_KERNEL);
 648         if (ret) {
 649                 dev_err(dev, "failed to map devmem: %d\n", ret);
 650                 goto out;
 651         }
 652
 653         /*
 654          * We'll need this info later when we'll want to unmap everything
 655          * (e.g. on shutdown).
 656          *
 657          * We can't trust the remote processor not to change the resource
 658          * table, so we must maintain this info independently.
 659          */
 660         mapping->da = rsc->da;
 661         mapping->len = rsc->len;
 662         list_add_tail(&mapping->node, &rproc->mappings);
 663
 664         dev_dbg(dev, "mapped devmem pa 0x%x, da 0x%x, len 0x%x\n",
 665                 rsc->pa, rsc->da, rsc->len);
 666
 667         return 0;
 668
 669 out:
 670         kfree(mapping);
 671         return ret;
 672 }
 673
 674 /**
 675  * rproc_alloc_carveout() - allocated specified carveout
 676  * @rproc: rproc handle
 677  * @mem: the memory entry to allocate
 678  *
 679  * This function allocate specified memory entry @mem using
 680  * dma_alloc_coherent() as default allocator
 681  *
 682  * Return: 0 on success, or an appropriate error code otherwise
 683  */
 684 static int rproc_alloc_carveout(struct rproc *rproc,
 685                                 struct rproc_mem_entry *mem)
 686 {
 687         struct rproc_mem_entry *mapping = NULL;
 688         struct device *dev = &rproc->dev;
 689         dma_addr_t dma;
 690         void *va;
 691         int ret;
 692
 693         va = dma_alloc_coherent(dev->parent, mem->len, &dma, GFP_KERNEL);
 694         if (!va) {
 695                 dev_err(dev->parent,
 696                         "failed to allocate dma memory: len 0x%zx\n",
 697                         mem->len);
 698                 return -ENOMEM;
 699         }
 700
 701         dev_dbg(dev, "carveout va %pK, dma %pad, len 0x%zx\n",
 702                 va, &dma, mem->len);
 703
 704         if (mem->da != FW_RSC_ADDR_ANY && !rproc->domain) {
 705                 /*
 706                  * Check requested da is equal to dma address
 707                  * and print a warn message in case of missalignment.
 708                  * Don't stop rproc_start sequence as coprocessor may
 709                  * build pa to da translation on its side.
 710                  */
 711                 if (mem->da != (u32)dma)
 712                         dev_warn(dev->parent,
 713                                  "Allocated carveout doesn't fit device address request\n");
 714         }
 715
 716         /*
 717          * Ok, this is non-standard.
 718          *
 719          * Sometimes we can't rely on the generic iommu-based DMA API
 720          * to dynamically allocate the device address and then set the IOMMU
 721          * tables accordingly, because some remote processors might
 722          * _require_ us to use hard coded device addresses that their
 723          * firmware was compiled with.
 724          *
 725          * In this case, we must use the IOMMU API directly and map
 726          * the memory to the device address as expected by the remote
 727          * processor.
 728          *
 729          * Obviously such remote processor devices should not be configured
 730          * to use the iommu-based DMA API: we expect 'dma' to contain the
 731          * physical address in this case.
 732          */
 733         if (mem->da != FW_RSC_ADDR_ANY && rproc->domain) {
 734                 mapping = kzalloc(sizeof(*mapping), GFP_KERNEL);
 735                 if (!mapping) {
 736                         ret = -ENOMEM;
 737                         goto dma_free;
 738                 }
 739
 740                 ret = iommu_map(rproc->domain, mem->da, dma, mem->len,
 741                                 mem->flags, GFP_KERNEL);
 742                 if (ret) {
 743                         dev_err(dev, "iommu_map failed: %d\n", ret);
 744                         goto free_mapping;
 745                 }
 746
 747                 /*
 748                  * We'll need this info later when we'll want to unmap
 749                  * everything (e.g. on shutdown).
 750                  *
 751                  * We can't trust the remote processor not to change the
 752                  * resource table, so we must maintain this info independently.
 753                  */
 754                 mapping->da = mem->da;
 755                 mapping->len = mem->len;
 756                 list_add_tail(&mapping->node, &rproc->mappings);
 757
 758                 dev_dbg(dev, "carveout mapped 0x%x to %pad\n",
 759                         mem->da, &dma);
 760         }
 761
 762         if (mem->da == FW_RSC_ADDR_ANY) {
 763                 /* Update device address as undefined by requester */
 764                 if ((u64)dma & HIGH_BITS_MASK)
 765                         dev_warn(dev, "DMA address cast in 32bit to fit resource table format\n");
 766
 767                 mem->da = (u32)dma;
 768         }
 769
 770         mem->dma = dma;
 771         mem->va = va;
 772
 773         return 0;
 774
 775 free_mapping:
 776         kfree(mapping);
 777 dma_free:
 778         dma_free_coherent(dev->parent, mem->len, va, dma);
 779         return ret;
 780 }
 781
 782 /**
 783  * rproc_release_carveout() - release acquired carveout
 784  * @rproc: rproc handle
 785  * @mem: the memory entry to release
 786  *
 787  * This function releases specified memory entry @mem allocated via
 788  * rproc_alloc_carveout() function by @rproc.
 789  *
 790  * Return: 0 on success, or an appropriate error code otherwise
 791  */
 792 static int rproc_release_carveout(struct rproc *rproc,
 793                                   struct rproc_mem_entry *mem)
 794 {
 795         struct device *dev = &rproc->dev;
 796
 797         /* clean up carveout allocations */
 798         dma_free_coherent(dev->parent, mem->len, mem->va, mem->dma);
 799         return 0;
 800 }
 801
 802 /**
 803  * rproc_handle_carveout() - handle phys contig memory allocation requests
 804  * @rproc: rproc handle
 805  * @ptr: the resource entry
 806  * @offset: offset of the resource entry
 807  * @avail: size of available data (for image validation)
 808  *
 809  * This function will handle firmware requests for allocation of physically
 810  * contiguous memory regions.
 811  *
 812  * These request entries should come first in the firmware's resource table,
 813  * as other firmware entries might request placing other data objects inside
 814  * these memory regions (e.g. data/code segments, trace resource entries, ...).
 815  *
 816  * Allocating memory this way helps utilizing the reserved physical memory
 817  * (e.g. CMA) more efficiently, and also minimizes the number of TLB entries
 818  * needed to map it (in case @rproc is using an IOMMU). Reducing the TLB
 819  * pressure is important; it may have a substantial impact on performance.
 820  *
 821  * Return: 0 on success, or an appropriate error code otherwise
 822  */
 823 static int rproc_handle_carveout(struct rproc *rproc,
 824                                  void *ptr, int offset, int avail)
 825 {
 826         struct fw_rsc_carveout *rsc = ptr;
 827         struct rproc_mem_entry *carveout;
 828         struct device *dev = &rproc->dev;
 829
 830         if (sizeof(*rsc) > avail) {
 831                 dev_err(dev, "carveout rsc is truncated\n");
 832                 return -EINVAL;
 833         }
 834
 835         /* make sure reserved bytes are zeroes */
 836         if (rsc->reserved) {
 837                 dev_err(dev, "carveout rsc has non zero reserved bytes\n");
 838                 return -EINVAL;
 839         }
 840
 841         dev_dbg(dev, "carveout rsc: name: %s, da 0x%x, pa 0x%x, len 0x%x, flags 0x%x\n",
 842                 rsc->name, rsc->da, rsc->pa, rsc->len, rsc->flags);
 843
 844         /*
 845          * Check carveout rsc already part of a registered carveout,
 846          * Search by name, then check the da and length
 847          */
 848         carveout = rproc_find_carveout_by_name(rproc, rsc->name);
 849
 850         if (carveout) {
 851                 if (carveout->rsc_offset != FW_RSC_ADDR_ANY) {
 852                         dev_err(dev,
 853                                 "Carveout already associated to resource table\n");
 854                         return -ENOMEM;
 855                 }
 856
 857                 if (rproc_check_carveout_da(rproc, carveout, rsc->da, rsc->len))
 858                         return -ENOMEM;
 859
 860                 /* Update memory carveout with resource table info */
 861                 carveout->rsc_offset = offset;
 862                 carveout->flags = rsc->flags;
 863
 864                 return 0;
 865         }
 866
 867         /* Register carveout in list */
 868         carveout = rproc_mem_entry_init(dev, NULL, 0, rsc->len, rsc->da,
 869                                         rproc_alloc_carveout,
 870                                         rproc_release_carveout, rsc->name);
 871         if (!carveout) {
 872                 dev_err(dev, "Can't allocate memory entry structure\n");
 873                 return -ENOMEM;
 874         }
 875
 876         carveout->flags = rsc->flags;
 877         carveout->rsc_offset = offset;
 878         rproc_add_carveout(rproc, carveout);
 879
 880         return 0;
 881 }
 882
 883 /**
 884  * rproc_add_carveout() - register an allocated carveout region
 885  * @rproc: rproc handle
 886  * @mem: memory entry to register
 887  *
 888  * This function registers specified memory entry in @rproc carveouts list.
 889  * Specified carveout should have been allocated before registering.
 890  */
 891 void rproc_add_carveout(struct rproc *rproc, struct rproc_mem_entry *mem)
 892 {
 893         list_add_tail(&mem->node, &rproc->carveouts);
 894 }
 895 EXPORT_SYMBOL(rproc_add_carveout);
 896
 897 /**
 898  * rproc_mem_entry_init() - allocate and initialize rproc_mem_entry struct
 899  * @dev: pointer on device struct
 900  * @va: virtual address
 901  * @dma: dma address
 902  * @len: memory carveout length
 903  * @da: device address
 904  * @alloc: memory carveout allocation function
 905  * @release: memory carveout release function
 906  * @name: carveout name
 907  *
 908  * This function allocates a rproc_mem_entry struct and fill it with parameters
 909  * provided by client.
 910  *
 911  * Return: a valid pointer on success, or NULL on failure
 912  */
 913 __printf(8, 9)
 914 struct rproc_mem_entry *
 915 rproc_mem_entry_init(struct device *dev,
 916                      void *va, dma_addr_t dma, size_t len, u32 da,
 917                      int (*alloc)(struct rproc *, struct rproc_mem_entry *),
 918                      int (*release)(struct rproc *, struct rproc_mem_entry *),
 919                      const char *name, ...)
 920 {
 921         struct rproc_mem_entry *mem;
 922         va_list args;
 923
 924         mem = kzalloc(sizeof(*mem), GFP_KERNEL);
 925         if (!mem)
 926                 return mem;
 927
 928         mem->va = va;
 929         mem->dma = dma;
 930         mem->da = da;
 931         mem->len = len;
 932         mem->alloc = alloc;
 933         mem->release = release;
 934         mem->rsc_offset = FW_RSC_ADDR_ANY;
 935         mem->of_resm_idx = -1;
 936
 937         va_start(args, name);
 938         vsnprintf(mem->name, sizeof(mem->name), name, args);
 939         va_end(args);
 940
 941         return mem;
 942 }
 943 EXPORT_SYMBOL(rproc_mem_entry_init);
 944
 945 /**
 946  * rproc_of_resm_mem_entry_init() - allocate and initialize rproc_mem_entry struct
 947  * from a reserved memory phandle
 948  * @dev: pointer on device struct
 949  * @of_resm_idx: reserved memory phandle index in "memory-region"
 950  * @len: memory carveout length
 951  * @da: device address
 952  * @name: carveout name
 953  *
 954  * This function allocates a rproc_mem_entry struct and fill it with parameters
 955  * provided by client.
 956  *
 957  * Return: a valid pointer on success, or NULL on failure
 958  */
 959 __printf(5, 6)
 960 struct rproc_mem_entry *
 961 rproc_of_resm_mem_entry_init(struct device *dev, u32 of_resm_idx, size_t len,
 962                              u32 da, const char *name, ...)
 963 {
 964         struct rproc_mem_entry *mem;
 965         va_list args;
 966
 967         mem = kzalloc(sizeof(*mem), GFP_KERNEL);
 968         if (!mem)
 969                 return mem;
 970
 971         mem->da = da;
 972         mem->len = len;
 973         mem->rsc_offset = FW_RSC_ADDR_ANY;
 974         mem->of_resm_idx = of_resm_idx;
 975
 976         va_start(args, name);
 977         vsnprintf(mem->name, sizeof(mem->name), name, args);
 978         va_end(args);
 979
 980         return mem;
 981 }
 982 EXPORT_SYMBOL(rproc_of_resm_mem_entry_init);
 983
 984 /**
 985  * rproc_of_parse_firmware() - parse and return the firmware-name
 986  * @dev: pointer on device struct representing a rproc
 987  * @index: index to use for the firmware-name retrieval
 988  * @fw_name: pointer to a character string, in which the firmware
 989  *           name is returned on success and unmodified otherwise.
 990  *
 991  * This is an OF helper function that parses a device's DT node for
 992  * the "firmware-name" property and returns the firmware name pointer
 993  * in @fw_name on success.
 994  *
 995  * Return: 0 on success, or an appropriate failure.
 996  */
 997 int rproc_of_parse_firmware(struct device *dev, int index, const char **fw_name)
 998 {
 999         int ret;
1000
1001         ret = of_property_read_string_index(dev->of_node, "firmware-name",
1002                                             index, fw_name);
1003         return ret ? ret : 0;
1004 }
1005 EXPORT_SYMBOL(rproc_of_parse_firmware);
1006
1007 /*
1008  * A lookup table for resource handlers. The indices are defined in
1009  * enum fw_resource_type.
1010  */
1011 static rproc_handle_resource_t rproc_loading_handlers[RSC_LAST] = {
1012         [RSC_CARVEOUT] = rproc_handle_carveout,
1013         [RSC_DEVMEM] = rproc_handle_devmem,
1014         [RSC_TRACE] = rproc_handle_trace,
1015         [RSC_VDEV] = rproc_handle_vdev,
1016 };
1017
1018 /* handle firmware resource entries before booting the remote processor */
1019 static int rproc_handle_resources(struct rproc *rproc,
1020                                   rproc_handle_resource_t handlers[RSC_LAST])
1021 {
1022         struct device *dev = &rproc->dev;
1023         rproc_handle_resource_t handler;
1024         int ret = 0, i;
1025
1026         if (!rproc->table_ptr)
1027                 return 0;
1028
1029         for (i = 0; i < rproc->table_ptr->num; i++) {
1030                 int offset = rproc->table_ptr->offset[i];
1031                 struct fw_rsc_hdr *hdr = (void *)rproc->table_ptr + offset;
1032                 int avail = rproc->table_sz - offset - sizeof(*hdr);
1033                 void *rsc = (void *)hdr + sizeof(*hdr);
1034
1035                 /* make sure table isn't truncated */
1036                 if (avail < 0) {
1037                         dev_err(dev, "rsc table is truncated\n");
1038                         return -EINVAL;
1039                 }
1040
1041                 dev_dbg(dev, "rsc: type %d\n", hdr->type);
1042
1043                 if (hdr->type >= RSC_VENDOR_START &&
1044                     hdr->type <= RSC_VENDOR_END) {
1045                         ret = rproc_handle_rsc(rproc, hdr->type, rsc,
1046                                                offset + sizeof(*hdr), avail);
1047                         if (ret == RSC_HANDLED)
1048                                 continue;
1049                         else if (ret < 0)
1050                                 break;
1051
1052                         dev_warn(dev, "unsupported vendor resource %d\n",
1053                                  hdr->type);
1054                         continue;
1055                 }
1056
1057                 if (hdr->type >= RSC_LAST) {
1058                         dev_warn(dev, "unsupported resource %d\n", hdr->type);
1059                         continue;
1060                 }
1061
1062                 handler = handlers[hdr->type];
1063                 if (!handler)
1064                         continue;
1065
1066                 ret = handler(rproc, rsc, offset + sizeof(*hdr), avail);
1067                 if (ret)
1068                         break;
1069         }
1070
1071         return ret;
1072 }
1073
1074 static int rproc_prepare_subdevices(struct rproc *rproc)
1075 {
1076         struct rproc_subdev *subdev;
1077         int ret;
1078
1079         list_for_each_entry(subdev, &rproc->subdevs, node) {
1080                 if (subdev->prepare) {
1081                         ret = subdev->prepare(subdev);
1082                         if (ret)
1083                                 goto unroll_preparation;
1084                 }
1085         }
1086
1087         return 0;
1088
1089 unroll_preparation:
1090         list_for_each_entry_continue_reverse(subdev, &rproc->subdevs, node) {
1091                 if (subdev->unprepare)
1092                         subdev->unprepare(subdev);
1093         }
1094
1095         return ret;
1096 }
1097
1098 static int rproc_start_subdevices(struct rproc *rproc)
1099 {
1100         struct rproc_subdev *subdev;
1101         int ret;
1102
1103         list_for_each_entry(subdev, &rproc->subdevs, node) {
1104                 if (subdev->start) {
1105                         ret = subdev->start(subdev);
1106                         if (ret)
1107                                 goto unroll_registration;
1108                 }
1109         }
1110
1111         return 0;
1112
1113 unroll_registration:
1114         list_for_each_entry_continue_reverse(subdev, &rproc->subdevs, node) {
1115                 if (subdev->stop)
1116                         subdev->stop(subdev, true);
1117         }
1118
1119         return ret;
1120 }
1121
1122 static void rproc_stop_subdevices(struct rproc *rproc, bool crashed)
1123 {
1124         struct rproc_subdev *subdev;
1125
1126         list_for_each_entry_reverse(subdev, &rproc->subdevs, node) {
1127                 if (subdev->stop)
1128                         subdev->stop(subdev, crashed);
1129         }
1130 }
1131
1132 static void rproc_unprepare_subdevices(struct rproc *rproc)
1133 {
1134         struct rproc_subdev *subdev;
1135
1136         list_for_each_entry_reverse(subdev, &rproc->subdevs, node) {
1137                 if (subdev->unprepare)
1138                         subdev->unprepare(subdev);
1139         }
1140 }
1141
1142 /**
1143  * rproc_alloc_registered_carveouts() - allocate all carveouts registered
1144  * in the list
1145  * @rproc: the remote processor handle
1146  *
1147  * This function parses registered carveout list, performs allocation
1148  * if alloc() ops registered and updates resource table information
1149  * if rsc_offset set.
1150  *
1151  * Return: 0 on success
1152  */
1153 static int rproc_alloc_registered_carveouts(struct rproc *rproc)
1154 {
1155         struct rproc_mem_entry *entry, *tmp;
1156         struct fw_rsc_carveout *rsc;
1157         struct device *dev = &rproc->dev;
1158         u64 pa;
1159         int ret;
1160
1161         list_for_each_entry_safe(entry, tmp, &rproc->carveouts, node) {
1162                 if (entry->alloc) {
1163                         ret = entry->alloc(rproc, entry);
1164                         if (ret) {
1165                                 dev_err(dev, "Unable to allocate carveout %s: %d\n",
1166                                         entry->name, ret);
1167                                 return -ENOMEM;
1168                         }
1169                 }
1170
1171                 if (entry->rsc_offset != FW_RSC_ADDR_ANY) {
1172                         /* update resource table */
1173                         rsc = (void *)rproc->table_ptr + entry->rsc_offset;
1174
1175                         /*
1176                          * Some remote processors might need to know the pa
1177                          * even though they are behind an IOMMU. E.g., OMAP4's
1178                          * remote M3 processor needs this so it can control
1179                          * on-chip hardware accelerators that are not behind
1180                          * the IOMMU, and therefor must know the pa.
1181                          *
1182                          * Generally we don't want to expose physical addresses
1183                          * if we don't have to (remote processors are generally
1184                          * _not_ trusted), so we might want to do this only for
1185                          * remote processor that _must_ have this (e.g. OMAP4's
1186                          * dual M3 subsystem).
1187                          *
1188                          * Non-IOMMU processors might also want to have this info.
1189                          * In this case, the device address and the physical address
1190                          * are the same.
1191                          */
1192
1193                         /* Use va if defined else dma to generate pa */
1194                         if (entry->va)
1195                                 pa = (u64)rproc_va_to_pa(entry->va);
1196                         else
1197                                 pa = (u64)entry->dma;
1198
1199                         if (((u64)pa) & HIGH_BITS_MASK)
1200                                 dev_warn(dev,
1201                                          "Physical address cast in 32bit to fit resource table format\n");
1202
1203                         rsc->pa = (u32)pa;
1204                         rsc->da = entry->da;
1205                         rsc->len = entry->len;
1206                 }
1207         }
1208
1209         return 0;
1210 }
1211
1212
1213 /**
1214  * rproc_resource_cleanup() - clean up and free all acquired resources
1215  * @rproc: rproc handle
1216  *
1217  * This function will free all resources acquired for @rproc, and it
1218  * is called whenever @rproc either shuts down or fails to boot.
1219  */
1220 void rproc_resource_cleanup(struct rproc *rproc)
1221 {
1222         struct rproc_mem_entry *entry, *tmp;
1223         struct rproc_debug_trace *trace, *ttmp;
1224         struct rproc_vdev *rvdev, *rvtmp;
1225         struct device *dev = &rproc->dev;
1226
1227         /* clean up debugfs trace entries */
1228         list_for_each_entry_safe(trace, ttmp, &rproc->traces, node) {
1229                 rproc_remove_trace_file(trace->tfile);
1230                 rproc->num_traces--;
1231                 list_del(&trace->node);
1232                 kfree(trace);
1233         }
1234
1235         /* clean up iommu mapping entries */
1236         list_for_each_entry_safe(entry, tmp, &rproc->mappings, node) {
1237                 size_t unmapped;
1238
1239                 unmapped = iommu_unmap(rproc->domain, entry->da, entry->len);
1240                 if (unmapped != entry->len) {
1241                         /* nothing much to do besides complaining */
1242                         dev_err(dev, "failed to unmap %zx/%zu\n", entry->len,
1243                                 unmapped);
1244                 }
1245
1246                 list_del(&entry->node);
1247                 kfree(entry);
1248         }
1249
1250         /* clean up carveout allocations */
1251         list_for_each_entry_safe(entry, tmp, &rproc->carveouts, node) {
1252                 if (entry->release)
1253                         entry->release(rproc, entry);
1254                 list_del(&entry->node);
1255                 kfree(entry);
1256         }
1257
1258         /* clean up remote vdev entries */
1259         list_for_each_entry_safe(rvdev, rvtmp, &rproc->rvdevs, node)
1260                 platform_device_unregister(rvdev->pdev);
1261
1262         rproc_coredump_cleanup(rproc);
1263 }
1264 EXPORT_SYMBOL(rproc_resource_cleanup);
1265
1266 static int rproc_start(struct rproc *rproc, const struct firmware *fw)
1267 {
1268         struct resource_table *loaded_table;
1269         struct device *dev = &rproc->dev;
1270         int ret;
1271
1272         /* load the ELF segments to memory */
1273         ret = rproc_load_segments(rproc, fw);
1274         if (ret) {
1275                 dev_err(dev, "Failed to load program segments: %d\n", ret);
1276                 return ret;
1277         }
1278
1279         /*
1280          * The starting device has been given the rproc->cached_table as the
1281          * resource table. The address of the vring along with the other
1282          * allocated resources (carveouts etc) is stored in cached_table.
1283          * In order to pass this information to the remote device we must copy
1284          * this information to device memory. We also update the table_ptr so
1285          * that any subsequent changes will be applied to the loaded version.
1286          */
1287         loaded_table = rproc_find_loaded_rsc_table(rproc, fw);
1288         if (loaded_table) {
1289                 memcpy(loaded_table, rproc->cached_table, rproc->table_sz);
1290                 rproc->table_ptr = loaded_table;
1291         }
1292
1293         ret = rproc_prepare_subdevices(rproc);
1294         if (ret) {
1295                 dev_err(dev, "failed to prepare subdevices for %s: %d\n",
1296                         rproc->name, ret);
1297                 goto reset_table_ptr;
1298         }
1299
1300         /* power up the remote processor */
1301         ret = rproc->ops->start(rproc);
1302         if (ret) {
1303                 dev_err(dev, "can't start rproc %s: %d\n", rproc->name, ret);
1304                 goto unprepare_subdevices;
1305         }
1306
1307         /* Start any subdevices for the remote processor */
1308         ret = rproc_start_subdevices(rproc);
1309         if (ret) {
1310                 dev_err(dev, "failed to probe subdevices for %s: %d\n",
1311                         rproc->name, ret);
1312                 goto stop_rproc;
1313         }
1314
1315         rproc->state = RPROC_RUNNING;
1316
1317         dev_info(dev, "remote processor %s is now up\n", rproc->name);
1318
1319         return 0;
1320
1321 stop_rproc:
1322         rproc->ops->stop(rproc);
1323 unprepare_subdevices:
1324         rproc_unprepare_subdevices(rproc);
1325 reset_table_ptr:
1326         rproc->table_ptr = rproc->cached_table;
1327
1328         return ret;
1329 }
1330
1331 static int __rproc_attach(struct rproc *rproc)
1332 {
1333         struct device *dev = &rproc->dev;
1334         int ret;
1335
1336         ret = rproc_prepare_subdevices(rproc);
1337         if (ret) {
1338                 dev_err(dev, "failed to prepare subdevices for %s: %d\n",
1339                         rproc->name, ret);
1340                 goto out;
1341         }
1342
1343         /* Attach to the remote processor */
1344         ret = rproc_attach_device(rproc);
1345         if (ret) {
1346                 dev_err(dev, "can't attach to rproc %s: %d\n",
1347                         rproc->name, ret);
1348                 goto unprepare_subdevices;
1349         }
1350
1351         /* Start any subdevices for the remote processor */
1352         ret = rproc_start_subdevices(rproc);
1353         if (ret) {
1354                 dev_err(dev, "failed to probe subdevices for %s: %d\n",
1355                         rproc->name, ret);
1356                 goto stop_rproc;
1357         }
1358
1359         rproc->state = RPROC_ATTACHED;
1360
1361         dev_info(dev, "remote processor %s is now attached\n", rproc->name);
1362
1363         return 0;
1364
1365 stop_rproc:
1366         rproc->ops->stop(rproc);
1367 unprepare_subdevices:
1368         rproc_unprepare_subdevices(rproc);
1369 out:
1370         return ret;
1371 }
1372
1373 /*
1374  * take a firmware and boot a remote processor with it.
1375  */
1376 static int rproc_fw_boot(struct rproc *rproc, const struct firmware *fw)
1377 {
1378         struct device *dev = &rproc->dev;
1379         const char *name = rproc->firmware;
1380         int ret;
1381
1382         ret = rproc_fw_sanity_check(rproc, fw);
1383         if (ret)
1384                 return ret;
1385
1386         dev_info(dev, "Booting fw image %s, size %zd\n", name, fw->size);
1387
1388         /*
1389          * if enabling an IOMMU isn't relevant for this rproc, this is
1390          * just a nop
1391          */
1392         ret = rproc_enable_iommu(rproc);
1393         if (ret) {
1394                 dev_err(dev, "can't enable iommu: %d\n", ret);
1395                 return ret;
1396         }
1397
1398         /* Prepare rproc for firmware loading if needed */
1399         ret = rproc_prepare_device(rproc);
1400         if (ret) {
1401                 dev_err(dev, "can't prepare rproc %s: %d\n", rproc->name, ret);
1402                 goto disable_iommu;
1403         }
1404
1405         rproc->bootaddr = rproc_get_boot_addr(rproc, fw);
1406
1407         /* Load resource table, core dump segment list etc from the firmware */
1408         ret = rproc_parse_fw(rproc, fw);
1409         if (ret)
1410                 goto unprepare_rproc;
1411
1412         /* reset max_notifyid */
1413         rproc->max_notifyid = -1;
1414
1415         /* reset handled vdev */
1416         rproc->nb_vdev = 0;
1417
1418         /* handle fw resources which are required to boot rproc */
1419         ret = rproc_handle_resources(rproc, rproc_loading_handlers);
1420         if (ret) {
1421                 dev_err(dev, "Failed to process resources: %d\n", ret);
1422                 goto clean_up_resources;
1423         }
1424
1425         /* Allocate carveout resources associated to rproc */
1426         ret = rproc_alloc_registered_carveouts(rproc);
1427         if (ret) {
1428                 dev_err(dev, "Failed to allocate associated carveouts: %d\n",
1429                         ret);
1430                 goto clean_up_resources;
1431         }
1432
1433         ret = rproc_start(rproc, fw);
1434         if (ret)
1435                 goto clean_up_resources;
1436
1437         return 0;
1438
1439 clean_up_resources:
1440         rproc_resource_cleanup(rproc);
1441         kfree(rproc->cached_table);
1442         rproc->cached_table = NULL;
1443         rproc->table_ptr = NULL;
1444 unprepare_rproc:
1445         /* release HW resources if needed */
1446         rproc_unprepare_device(rproc);
1447 disable_iommu:
1448         rproc_disable_iommu(rproc);
1449         return ret;
1450 }
1451
1452 static int rproc_set_rsc_table(struct rproc *rproc)
1453 {
1454         struct resource_table *table_ptr;
1455         struct device *dev = &rproc->dev;
1456         size_t table_sz;
1457         int ret;
1458
1459         table_ptr = rproc_get_loaded_rsc_table(rproc, &table_sz);
1460         if (!table_ptr) {
1461                 /* Not having a resource table is acceptable */
1462                 return 0;
1463         }
1464
1465         if (IS_ERR(table_ptr)) {
1466                 ret = PTR_ERR(table_ptr);
1467                 dev_err(dev, "can't load resource table: %d\n", ret);
1468                 return ret;
1469         }
1470
1471         /*
1472          * If it is possible to detach the remote processor, keep an untouched
1473          * copy of the resource table.  That way we can start fresh again when
1474          * the remote processor is re-attached, that is:
1475          *
1476          *      DETACHED -> ATTACHED -> DETACHED -> ATTACHED
1477          *
1478          * Free'd in rproc_reset_rsc_table_on_detach() and
1479          * rproc_reset_rsc_table_on_stop().
1480          */
1481         if (rproc->ops->detach) {
1482                 rproc->clean_table = kmemdup(table_ptr, table_sz, GFP_KERNEL);
1483                 if (!rproc->clean_table)
1484                         return -ENOMEM;
1485         } else {
1486                 rproc->clean_table = NULL;
1487         }
1488
1489         rproc->cached_table = NULL;
1490         rproc->table_ptr = table_ptr;
1491         rproc->table_sz = table_sz;
1492
1493         return 0;
1494 }
1495
1496 static int rproc_reset_rsc_table_on_detach(struct rproc *rproc)
1497 {
1498         struct resource_table *table_ptr;
1499
1500         /* A resource table was never retrieved, nothing to do here */
1501         if (!rproc->table_ptr)
1502                 return 0;
1503
1504         /*
1505          * If we made it to this point a clean_table _must_ have been
1506          * allocated in rproc_set_rsc_table().  If one isn't present
1507          * something went really wrong and we must complain.
1508          */
1509         if (WARN_ON(!rproc->clean_table))
1510                 return -EINVAL;
1511
1512         /* Remember where the external entity installed the resource table */
1513         table_ptr = rproc->table_ptr;
1514
1515         /*
1516          * If we made it here the remote processor was started by another
1517          * entity and a cache table doesn't exist.  As such make a copy of
1518          * the resource table currently used by the remote processor and
1519          * use that for the rest of the shutdown process.  The memory
1520          * allocated here is free'd in rproc_detach().
1521          */
1522         rproc->cached_table = kmemdup(rproc->table_ptr,
1523                                       rproc->table_sz, GFP_KERNEL);
1524         if (!rproc->cached_table)
1525                 return -ENOMEM;
1526
1527         /*
1528          * Use a copy of the resource table for the remainder of the
1529          * shutdown process.
1530          */
1531         rproc->table_ptr = rproc->cached_table;
1532
1533         /*
1534          * Reset the memory area where the firmware loaded the resource table
1535          * to its original value.  That way when we re-attach the remote
1536          * processor the resource table is clean and ready to be used again.
1537          */
1538         memcpy(table_ptr, rproc->clean_table, rproc->table_sz);
1539
1540         /*
1541          * The clean resource table is no longer needed.  Allocated in
1542          * rproc_set_rsc_table().
1543          */
1544         kfree(rproc->clean_table);
1545
1546         return 0;
1547 }
1548
1549 static int rproc_reset_rsc_table_on_stop(struct rproc *rproc)
1550 {
1551         /* A resource table was never retrieved, nothing to do here */
1552         if (!rproc->table_ptr)
1553                 return 0;
1554
1555         /*
1556          * If a cache table exists the remote processor was started by
1557          * the remoteproc core.  That cache table should be used for
1558          * the rest of the shutdown process.
1559          */
1560         if (rproc->cached_table)
1561                 goto out;
1562
1563         /*
1564          * If we made it here the remote processor was started by another
1565          * entity and a cache table doesn't exist.  As such make a copy of
1566          * the resource table currently used by the remote processor and
1567          * use that for the rest of the shutdown process.  The memory
1568          * allocated here is free'd in rproc_shutdown().
1569          */
1570         rproc->cached_table = kmemdup(rproc->table_ptr,
1571                                       rproc->table_sz, GFP_KERNEL);
1572         if (!rproc->cached_table)
1573                 return -ENOMEM;
1574
1575         /*
1576          * Since the remote processor is being switched off the clean table
1577          * won't be needed.  Allocated in rproc_set_rsc_table().
1578          */
1579         kfree(rproc->clean_table);
1580
1581 out:
1582         /*
1583          * Use a copy of the resource table for the remainder of the
1584          * shutdown process.
1585          */
1586         rproc->table_ptr = rproc->cached_table;
1587         return 0;
1588 }
1589
1590 /*
1591  * Attach to remote processor - similar to rproc_fw_boot() but without
1592  * the steps that deal with the firmware image.
1593  */
1594 static int rproc_attach(struct rproc *rproc)
1595 {
1596         struct device *dev = &rproc->dev;
1597         int ret;
1598
1599         /*
1600          * if enabling an IOMMU isn't relevant for this rproc, this is
1601          * just a nop
1602          */
1603         ret = rproc_enable_iommu(rproc);
1604         if (ret) {
1605                 dev_err(dev, "can't enable iommu: %d\n", ret);
1606                 return ret;
1607         }
1608
1609         /* Do anything that is needed to boot the remote processor */
1610         ret = rproc_prepare_device(rproc);
1611         if (ret) {
1612                 dev_err(dev, "can't prepare rproc %s: %d\n", rproc->name, ret);
1613                 goto disable_iommu;
1614         }
1615
1616         ret = rproc_set_rsc_table(rproc);
1617         if (ret) {
1618                 dev_err(dev, "can't load resource table: %d\n", ret);
1619                 goto unprepare_device;
1620         }
1621
1622         /* reset max_notifyid */
1623         rproc->max_notifyid = -1;
1624
1625         /* reset handled vdev */
1626         rproc->nb_vdev = 0;
1627
1628         /*
1629          * Handle firmware resources required to attach to a remote processor.
1630          * Because we are attaching rather than booting the remote processor,
1631          * we expect the platform driver to properly set rproc->table_ptr.
1632          */
1633         ret = rproc_handle_resources(rproc, rproc_loading_handlers);
1634         if (ret) {
1635                 dev_err(dev, "Failed to process resources: %d\n", ret);
1636                 goto unprepare_device;
1637         }
1638
1639         /* Allocate carveout resources associated to rproc */
1640         ret = rproc_alloc_registered_carveouts(rproc);
1641         if (ret) {
1642                 dev_err(dev, "Failed to allocate associated carveouts: %d\n",
1643                         ret);
1644                 goto clean_up_resources;
1645         }
1646
1647         ret = __rproc_attach(rproc);
1648         if (ret)
1649                 goto clean_up_resources;
1650
1651         return 0;
1652
1653 clean_up_resources:
1654         rproc_resource_cleanup(rproc);
1655 unprepare_device:
1656         /* release HW resources if needed */
1657         rproc_unprepare_device(rproc);
1658 disable_iommu:
1659         rproc_disable_iommu(rproc);
1660         return ret;
1661 }
1662
1663 /*
1664  * take a firmware and boot it up.
1665  *
1666  * Note: this function is called asynchronously upon registration of the
1667  * remote processor (so we must wait until it completes before we try
1668  * to unregister the device. one other option is just to use kref here,
1669  * that might be cleaner).
1670  */
1671 static void rproc_auto_boot_callback(const struct firmware *fw, void *context)
1672 {
1673         struct rproc *rproc = context;
1674
1675         rproc_boot(rproc);
1676
1677         release_firmware(fw);
1678 }
1679
1680 static int rproc_trigger_auto_boot(struct rproc *rproc)
1681 {
1682         int ret;
1683
1684         /*
1685          * Since the remote processor is in a detached state, it has already
1686          * been booted by another entity.  As such there is no point in waiting
1687          * for a firmware image to be loaded, we can simply initiate the process
1688          * of attaching to it immediately.
1689          */
1690         if (rproc->state == RPROC_DETACHED)
1691                 return rproc_boot(rproc);
1692
1693         /*
1694          * We're initiating an asynchronous firmware loading, so we can
1695          * be built-in kernel code, without hanging the boot process.
1696          */
1697         ret = request_firmware_nowait(THIS_MODULE, FW_ACTION_UEVENT,
1698                                       rproc->firmware, &rproc->dev, GFP_KERNEL,
1699                                       rproc, rproc_auto_boot_callback);
1700         if (ret < 0)
1701                 dev_err(&rproc->dev, "request_firmware_nowait err: %d\n", ret);
1702
1703         return ret;
1704 }
1705
1706 static int rproc_stop(struct rproc *rproc, bool crashed)
1707 {
1708         struct device *dev = &rproc->dev;
1709         int ret;
1710
1711         /* No need to continue if a stop() operation has not been provided */
1712         if (!rproc->ops->stop)
1713                 return -EINVAL;
1714
1715         /* Stop any subdevices for the remote processor */
1716         rproc_stop_subdevices(rproc, crashed);
1717
1718         /* the installed resource table is no longer accessible */
1719         ret = rproc_reset_rsc_table_on_stop(rproc);
1720         if (ret) {
1721                 dev_err(dev, "can't reset resource table: %d\n", ret);
1722                 return ret;
1723         }
1724
1725
1726         /* power off the remote processor */
1727         ret = rproc->ops->stop(rproc);
1728         if (ret) {
1729                 dev_err(dev, "can't stop rproc: %d\n", ret);
1730                 return ret;
1731         }
1732
1733         rproc_unprepare_subdevices(rproc);
1734
1735         rproc->state = RPROC_OFFLINE;
1736
1737         dev_info(dev, "stopped remote processor %s\n", rproc->name);
1738
1739         return 0;
1740 }
1741
1742 /*
1743  * __rproc_detach(): Does the opposite of __rproc_attach()
1744  */
1745 static int __rproc_detach(struct rproc *rproc)
1746 {
1747         struct device *dev = &rproc->dev;
1748         int ret;
1749
1750         /* No need to continue if a detach() operation has not been provided */
1751         if (!rproc->ops->detach)
1752                 return -EINVAL;
1753
1754         /* Stop any subdevices for the remote processor */
1755         rproc_stop_subdevices(rproc, false);
1756
1757         /* the installed resource table is no longer accessible */
1758         ret = rproc_reset_rsc_table_on_detach(rproc);
1759         if (ret) {
1760                 dev_err(dev, "can't reset resource table: %d\n", ret);
1761                 return ret;
1762         }
1763
1764         /* Tell the remote processor the core isn't available anymore */
1765         ret = rproc->ops->detach(rproc);
1766         if (ret) {
1767                 dev_err(dev, "can't detach from rproc: %d\n", ret);
1768                 return ret;
1769         }
1770
1771         rproc_unprepare_subdevices(rproc);
1772
1773         rproc->state = RPROC_DETACHED;
1774
1775         dev_info(dev, "detached remote processor %s\n", rproc->name);
1776
1777         return 0;
1778 }
1779
1780 static int rproc_attach_recovery(struct rproc *rproc)
1781 {
1782         int ret;
1783
1784         ret = __rproc_detach(rproc);
1785         if (ret)
1786                 return ret;
1787
1788         return __rproc_attach(rproc);
1789 }
1790
1791 static int rproc_boot_recovery(struct rproc *rproc)
1792 {
1793         const struct firmware *firmware_p;
1794         struct device *dev = &rproc->dev;
1795         int ret;
1796
1797         ret = rproc_stop(rproc, true);
1798         if (ret)
1799                 return ret;
1800
1801         /* generate coredump */
1802         rproc->ops->coredump(rproc);
1803
1804         /* load firmware */
1805         ret = request_firmware(&firmware_p, rproc->firmware, dev);
1806         if (ret < 0) {
1807                 dev_err(dev, "request_firmware failed: %d\n", ret);
1808                 return ret;
1809         }
1810
1811         /* boot the remote processor up again */
1812         ret = rproc_start(rproc, firmware_p);
1813
1814         release_firmware(firmware_p);
1815
1816         return ret;
1817 }
1818
1819 /**
1820  * rproc_trigger_recovery() - recover a remoteproc
1821  * @rproc: the remote processor
1822  *
1823  * The recovery is done by resetting all the virtio devices, that way all the
1824  * rpmsg drivers will be reseted along with the remote processor making the
1825  * remoteproc functional again.
1826  *
1827  * This function can sleep, so it cannot be called from atomic context.
1828  *
1829  * Return: 0 on success or a negative value upon failure
1830  */
1831 int rproc_trigger_recovery(struct rproc *rproc)
1832 {
1833         struct device *dev = &rproc->dev;
1834         int ret;
1835
1836         ret = mutex_lock_interruptible(&rproc->lock);
1837         if (ret)
1838                 return ret;
1839
1840         /* State could have changed before we got the mutex */
1841         if (rproc->state != RPROC_CRASHED)
1842                 goto unlock_mutex;
1843
1844         dev_err(dev, "recovering %s\n", rproc->name);
1845
1846         if (rproc_has_feature(rproc, RPROC_FEAT_ATTACH_ON_RECOVERY))
1847                 ret = rproc_attach_recovery(rproc);
1848         else
1849                 ret = rproc_boot_recovery(rproc);
1850
1851 unlock_mutex:
1852         mutex_unlock(&rproc->lock);
1853         return ret;
1854 }
1855
1856 /**
1857  * rproc_crash_handler_work() - handle a crash
1858  * @work: work treating the crash
1859  *
1860  * This function needs to handle everything related to a crash, like cpu
1861  * registers and stack dump, information to help to debug the fatal error, etc.
1862  */
1863 static void rproc_crash_handler_work(struct work_struct *work)
1864 {
1865         struct rproc *rproc = container_of(work, struct rproc, crash_handler);
1866         struct device *dev = &rproc->dev;
1867
1868         dev_dbg(dev, "enter %s\n", __func__);
1869
1870         mutex_lock(&rproc->lock);
1871
1872         if (rproc->state == RPROC_CRASHED) {
1873                 /* handle only the first crash detected */
1874                 mutex_unlock(&rproc->lock);
1875                 return;
1876         }
1877
1878         if (rproc->state == RPROC_OFFLINE) {
1879                 /* Don't recover if the remote processor was stopped */
1880                 mutex_unlock(&rproc->lock);
1881                 goto out;
1882         }
1883
1884         rproc->state = RPROC_CRASHED;
1885         dev_err(dev, "handling crash #%u in %s\n", ++rproc->crash_cnt,
1886                 rproc->name);
1887
1888         mutex_unlock(&rproc->lock);
1889
1890         if (!rproc->recovery_disabled)
1891                 rproc_trigger_recovery(rproc);
1892
1893 out:
1894         pm_relax(rproc->dev.parent);
1895 }
1896
1897 /**
1898  * rproc_boot() - boot a remote processor
1899  * @rproc: handle of a remote processor
1900  *
1901  * Boot a remote processor (i.e. load its firmware, power it on, ...).
1902  *
1903  * If the remote processor is already powered on, this function immediately
1904  * returns (successfully).
1905  *
1906  * Return: 0 on success, and an appropriate error value otherwise
1907  */
1908 int rproc_boot(struct rproc *rproc)
1909 {
1910         const struct firmware *firmware_p;
1911         struct device *dev;
1912         int ret;
1913
1914         if (!rproc) {
1915                 pr_err("invalid rproc handle\n");
1916                 return -EINVAL;
1917         }
1918
1919         dev = &rproc->dev;
1920
1921         ret = mutex_lock_interruptible(&rproc->lock);
1922         if (ret) {
1923                 dev_err(dev, "can't lock rproc %s: %d\n", rproc->name, ret);
1924                 return ret;
1925         }
1926
1927         if (rproc->state == RPROC_DELETED) {
1928                 ret = -ENODEV;
1929                 dev_err(dev, "can't boot deleted rproc %s\n", rproc->name);
1930                 goto unlock_mutex;
1931         }
1932
1933         /* skip the boot or attach process if rproc is already powered up */
1934         if (atomic_inc_return(&rproc->power) > 1) {
1935                 ret = 0;
1936                 goto unlock_mutex;
1937         }
1938
1939         if (rproc->state == RPROC_DETACHED) {
1940                 dev_info(dev, "attaching to %s\n", rproc->name);
1941
1942                 ret = rproc_attach(rproc);
1943         } else {
1944                 dev_info(dev, "powering up %s\n", rproc->name);
1945
1946                 /* load firmware */
1947                 ret = request_firmware(&firmware_p, rproc->firmware, dev);
1948                 if (ret < 0) {
1949                         dev_err(dev, "request_firmware failed: %d\n", ret);
1950                         goto downref_rproc;
1951                 }
1952
1953                 ret = rproc_fw_boot(rproc, firmware_p);
1954
1955                 release_firmware(firmware_p);
1956         }
1957
1958 downref_rproc:
1959         if (ret)
1960                 atomic_dec(&rproc->power);
1961 unlock_mutex:
1962         mutex_unlock(&rproc->lock);
1963         return ret;
1964 }
1965 EXPORT_SYMBOL(rproc_boot);
1966
1967 /**
1968  * rproc_shutdown() - power off the remote processor
1969  * @rproc: the remote processor
1970  *
1971  * Power off a remote processor (previously booted with rproc_boot()).
1972  *
1973  * In case @rproc is still being used by an additional user(s), then
1974  * this function will just decrement the power refcount and exit,
1975  * without really powering off the device.
1976  *
1977  * Every call to rproc_boot() must (eventually) be accompanied by a call
1978  * to rproc_shutdown(). Calling rproc_shutdown() redundantly is a bug.
1979  *
1980  * Notes:
1981  * - we're not decrementing the rproc's refcount, only the power refcount.
1982  *   which means that the @rproc handle stays valid even after rproc_shutdown()
1983  *   returns, and users can still use it with a subsequent rproc_boot(), if
1984  *   needed.
1985  *
1986  * Return: 0 on success, and an appropriate error value otherwise
1987  */
1988 int rproc_shutdown(struct rproc *rproc)
1989 {
1990         struct device *dev = &rproc->dev;
1991         int ret = 0;
1992
1993         ret = mutex_lock_interruptible(&rproc->lock);
1994         if (ret) {
1995                 dev_err(dev, "can't lock rproc %s: %d\n", rproc->name, ret);
1996                 return ret;
1997         }
1998
1999         if (rproc->state != RPROC_RUNNING &&
2000             rproc->state != RPROC_ATTACHED) {
2001                 ret = -EINVAL;
2002                 goto out;
2003         }
2004
2005         /* if the remote proc is still needed, bail out */
2006         if (!atomic_dec_and_test(&rproc->power))
2007                 goto out;
2008
2009         ret = rproc_stop(rproc, false);
2010         if (ret) {
2011                 atomic_inc(&rproc->power);
2012                 goto out;
2013         }
2014
2015         /* clean up all acquired resources */
2016         rproc_resource_cleanup(rproc);
2017
2018         /* release HW resources if needed */
2019         rproc_unprepare_device(rproc);
2020
2021         rproc_disable_iommu(rproc);
2022
2023         /* Free the copy of the resource table */
2024         kfree(rproc->cached_table);
2025         rproc->cached_table = NULL;
2026         rproc->table_ptr = NULL;
2027 out:
2028         mutex_unlock(&rproc->lock);
2029         return ret;
2030 }
2031 EXPORT_SYMBOL(rproc_shutdown);
2032
2033 /**
2034  * rproc_detach() - Detach the remote processor from the
2035  * remoteproc core
2036  *
2037  * @rproc: the remote processor
2038  *
2039  * Detach a remote processor (previously attached to with rproc_attach()).
2040  *
2041  * In case @rproc is still being used by an additional user(s), then
2042  * this function will just decrement the power refcount and exit,
2043  * without disconnecting the device.
2044  *
2045  * Function rproc_detach() calls __rproc_detach() in order to let a remote
2046  * processor know that services provided by the application processor are
2047  * no longer available.  From there it should be possible to remove the
2048  * platform driver and even power cycle the application processor (if the HW
2049  * supports it) without needing to switch off the remote processor.
2050  *
2051  * Return: 0 on success, and an appropriate error value otherwise
2052  */
2053 int rproc_detach(struct rproc *rproc)
2054 {
2055         struct device *dev = &rproc->dev;
2056         int ret;
2057
2058         ret = mutex_lock_interruptible(&rproc->lock);
2059         if (ret) {
2060                 dev_err(dev, "can't lock rproc %s: %d\n", rproc->name, ret);
2061                 return ret;
2062         }
2063
2064         if (rproc->state != RPROC_ATTACHED) {
2065                 ret = -EINVAL;
2066                 goto out;
2067         }
2068
2069         /* if the remote proc is still needed, bail out */
2070         if (!atomic_dec_and_test(&rproc->power)) {
2071                 ret = 0;
2072                 goto out;
2073         }
2074
2075         ret = __rproc_detach(rproc);
2076         if (ret) {
2077                 atomic_inc(&rproc->power);
2078                 goto out;
2079         }
2080
2081         /* clean up all acquired resources */
2082         rproc_resource_cleanup(rproc);
2083
2084         /* release HW resources if needed */
2085         rproc_unprepare_device(rproc);
2086
2087         rproc_disable_iommu(rproc);
2088
2089         /* Free the copy of the resource table */
2090         kfree(rproc->cached_table);
2091         rproc->cached_table = NULL;
2092         rproc->table_ptr = NULL;
2093 out:
2094         mutex_unlock(&rproc->lock);
2095         return ret;
2096 }
2097 EXPORT_SYMBOL(rproc_detach);
2098
2099 /**
2100  * rproc_get_by_phandle() - find a remote processor by phandle
2101  * @phandle: phandle to the rproc
2102  *
2103  * Finds an rproc handle using the remote processor's phandle, and then
2104  * return a handle to the rproc.
2105  *
2106  * This function increments the remote processor's refcount, so always
2107  * use rproc_put() to decrement it back once rproc isn't needed anymore.
2108  *
2109  * Return: rproc handle on success, and NULL on failure
2110  */
2111 #ifdef CONFIG_OF
2112 struct rproc *rproc_get_by_phandle(phandle phandle)
2113 {
2114         struct rproc *rproc = NULL, *r;
2115         struct device_node *np;
2116
2117         np = of_find_node_by_phandle(phandle);
2118         if (!np)
2119                 return NULL;
2120
2121         rcu_read_lock();
2122         list_for_each_entry_rcu(r, &rproc_list, node) {
2123                 if (r->dev.parent && device_match_of_node(r->dev.parent, np)) {
2124                         /* prevent underlying implementation from being removed */
2125                         if (!try_module_get(r->dev.parent->driver->owner)) {
2126                                 dev_err(&r->dev, "can't get owner\n");
2127                                 break;
2128                         }
2129
2130                         rproc = r;
2131                         get_device(&rproc->dev);
2132                         break;
2133                 }
2134         }
2135         rcu_read_unlock();
2136
2137         of_node_put(np);
2138
2139         return rproc;
2140 }
2141 #else
2142 struct rproc *rproc_get_by_phandle(phandle phandle)
2143 {
2144         return NULL;
2145 }
2146 #endif
2147 EXPORT_SYMBOL(rproc_get_by_phandle);
2148
2149 /**
2150  * rproc_set_firmware() - assign a new firmware
2151  * @rproc: rproc handle to which the new firmware is being assigned
2152  * @fw_name: new firmware name to be assigned
2153  *
2154  * This function allows remoteproc drivers or clients to configure a custom
2155  * firmware name that is different from the default name used during remoteproc
2156  * registration. The function does not trigger a remote processor boot,
2157  * only sets the firmware name used for a subsequent boot. This function
2158  * should also be called only when the remote processor is offline.
2159  *
2160  * This allows either the userspace to configure a different name through
2161  * sysfs or a kernel-level remoteproc or a remoteproc client driver to set
2162  * a specific firmware when it is controlling the boot and shutdown of the
2163  * remote processor.
2164  *
2165  * Return: 0 on success or a negative value upon failure
2166  */
2167 int rproc_set_firmware(struct rproc *rproc, const char *fw_name)
2168 {
2169         struct device *dev;
2170         int ret, len;
2171         char *p;
2172
2173         if (!rproc || !fw_name)
2174                 return -EINVAL;
2175
2176         dev = rproc->dev.parent;
2177
2178         ret = mutex_lock_interruptible(&rproc->lock);
2179         if (ret) {
2180                 dev_err(dev, "can't lock rproc %s: %d\n", rproc->name, ret);
2181                 return -EINVAL;
2182         }
2183
2184         if (rproc->state != RPROC_OFFLINE) {
2185                 dev_err(dev, "can't change firmware while running\n");
2186                 ret = -EBUSY;
2187                 goto out;
2188         }
2189
2190         len = strcspn(fw_name, "\n");
2191         if (!len) {
2192                 dev_err(dev, "can't provide empty string for firmware name\n");
2193                 ret = -EINVAL;
2194                 goto out;
2195         }
2196
2197         p = kstrndup(fw_name, len, GFP_KERNEL);
2198         if (!p) {
2199                 ret = -ENOMEM;
2200                 goto out;
2201         }
2202
2203         kfree_const(rproc->firmware);
2204         rproc->firmware = p;
2205
2206 out:
2207         mutex_unlock(&rproc->lock);
2208         return ret;
2209 }
2210 EXPORT_SYMBOL(rproc_set_firmware);
2211
2212 static int rproc_validate(struct rproc *rproc)
2213 {
2214         switch (rproc->state) {
2215         case RPROC_OFFLINE:
2216                 /*
2217                  * An offline processor without a start()
2218                  * function makes no sense.
2219                  */
2220                 if (!rproc->ops->start)
2221                         return -EINVAL;
2222                 break;
2223         case RPROC_DETACHED:
2224                 /*
2225                  * A remote processor in a detached state without an
2226                  * attach() function makes not sense.
2227                  */
2228                 if (!rproc->ops->attach)
2229                         return -EINVAL;
2230                 /*
2231                  * When attaching to a remote processor the device memory
2232                  * is already available and as such there is no need to have a
2233                  * cached table.
2234                  */
2235                 if (rproc->cached_table)
2236                         return -EINVAL;
2237                 break;
2238         default:
2239                 /*
2240                  * When adding a remote processor, the state of the device
2241                  * can be offline or detached, nothing else.
2242                  */
2243                 return -EINVAL;
2244         }
2245
2246         return 0;
2247 }
2248
2249 /**
2250  * rproc_add() - register a remote processor
2251  * @rproc: the remote processor handle to register
2252  *
2253  * Registers @rproc with the remoteproc framework, after it has been
2254  * allocated with rproc_alloc().
2255  *
2256  * This is called by the platform-specific rproc implementation, whenever
2257  * a new remote processor device is probed.
2258  *
2259  * Note: this function initiates an asynchronous firmware loading
2260  * context, which will look for virtio devices supported by the rproc's
2261  * firmware.
2262  *
2263  * If found, those virtio devices will be created and added, so as a result
2264  * of registering this remote processor, additional virtio drivers might be
2265  * probed.
2266  *
2267  * Return: 0 on success and an appropriate error code otherwise
2268  */
2269 int rproc_add(struct rproc *rproc)
2270 {
2271         struct device *dev = &rproc->dev;
2272         int ret;
2273
2274         ret = rproc_validate(rproc);
2275         if (ret < 0)
2276                 return ret;
2277
2278         /* add char device for this remoteproc */
2279         ret = rproc_char_device_add(rproc);
2280         if (ret < 0)
2281                 return ret;
2282
2283         ret = device_add(dev);
2284         if (ret < 0) {
2285                 put_device(dev);
2286                 goto rproc_remove_cdev;
2287         }
2288
2289         dev_info(dev, "%s is available\n", rproc->name);
2290
2291         /* create debugfs entries */
2292         rproc_create_debug_dir(rproc);
2293
2294         /* if rproc is marked always-on, request it to boot */
2295         if (rproc->auto_boot) {
2296                 ret = rproc_trigger_auto_boot(rproc);
2297                 if (ret < 0)
2298                         goto rproc_remove_dev;
2299         }
2300
2301         /* expose to rproc_get_by_phandle users */
2302         mutex_lock(&rproc_list_mutex);
2303         list_add_rcu(&rproc->node, &rproc_list);
2304         mutex_unlock(&rproc_list_mutex);
2305
2306         return 0;
2307
2308 rproc_remove_dev:
2309         rproc_delete_debug_dir(rproc);
2310         device_del(dev);
2311 rproc_remove_cdev:
2312         rproc_char_device_remove(rproc);
2313         return ret;
2314 }
2315 EXPORT_SYMBOL(rproc_add);
2316
2317 static void devm_rproc_remove(void *rproc)
2318 {
2319         rproc_del(rproc);
2320 }
2321
2322 /**
2323  * devm_rproc_add() - resource managed rproc_add()
2324  * @dev: the underlying device
2325  * @rproc: the remote processor handle to register
2326  *
2327  * This function performs like rproc_add() but the registered rproc device will
2328  * automatically be removed on driver detach.
2329  *
2330  * Return: 0 on success, negative errno on failure
2331  */
2332 int devm_rproc_add(struct device *dev, struct rproc *rproc)
2333 {
2334         int err;
2335
2336         err = rproc_add(rproc);
2337         if (err)
2338                 return err;
2339
2340         return devm_add_action_or_reset(dev, devm_rproc_remove, rproc);
2341 }
2342 EXPORT_SYMBOL(devm_rproc_add);
2343
2344 /**
2345  * rproc_type_release() - release a remote processor instance
2346  * @dev: the rproc's device
2347  *
2348  * This function should _never_ be called directly.
2349  *
2350  * It will be called by the driver core when no one holds a valid pointer
2351  * to @dev anymore.
2352  */
2353 static void rproc_type_release(struct device *dev)
2354 {
2355         struct rproc *rproc = container_of(dev, struct rproc, dev);
2356
2357         dev_info(&rproc->dev, "releasing %s\n", rproc->name);
2358
2359         idr_destroy(&rproc->notifyids);
2360
2361         if (rproc->index >= 0)
2362                 ida_free(&rproc_dev_index, rproc->index);
2363
2364         kfree_const(rproc->firmware);
2365         kfree_const(rproc->name);
2366         kfree(rproc->ops);
2367         kfree(rproc);
2368 }
2369
2370 static const struct device_type rproc_type = {
2371         .name           = "remoteproc",
2372         .release        = rproc_type_release,
2373 };
2374
2375 static int rproc_alloc_firmware(struct rproc *rproc,
2376                                 const char *name, const char *firmware)
2377 {
2378         const char *p;
2379
2380         /*
2381          * Allocate a firmware name if the caller gave us one to work
2382          * with.  Otherwise construct a new one using a default pattern.
2383          */
2384         if (firmware)
2385                 p = kstrdup_const(firmware, GFP_KERNEL);
2386         else
2387                 p = kasprintf(GFP_KERNEL, "rproc-%s-fw", name);
2388
2389         if (!p)
2390                 return -ENOMEM;
2391
2392         rproc->firmware = p;
2393
2394         return 0;
2395 }
2396
2397 static int rproc_alloc_ops(struct rproc *rproc, const struct rproc_ops *ops)
2398 {
2399         rproc->ops = kmemdup(ops, sizeof(*ops), GFP_KERNEL);
2400         if (!rproc->ops)
2401                 return -ENOMEM;
2402
2403         /* Default to rproc_coredump if no coredump function is specified */
2404         if (!rproc->ops->coredump)
2405                 rproc->ops->coredump = rproc_coredump;
2406
2407         if (rproc->ops->load)
2408                 return 0;
2409
2410         /* Default to ELF loader if no load function is specified */
2411         rproc->ops->load = rproc_elf_load_segments;
2412         rproc->ops->parse_fw = rproc_elf_load_rsc_table;
2413         rproc->ops->find_loaded_rsc_table = rproc_elf_find_loaded_rsc_table;
2414         rproc->ops->sanity_check = rproc_elf_sanity_check;
2415         rproc->ops->get_boot_addr = rproc_elf_get_boot_addr;
2416
2417         return 0;
2418 }
2419
2420 /**
2421  * rproc_alloc() - allocate a remote processor handle
2422  * @dev: the underlying device
2423  * @name: name of this remote processor
2424  * @ops: platform-specific handlers (mainly start/stop)
2425  * @firmware: name of firmware file to load, can be NULL
2426  * @len: length of private data needed by the rproc driver (in bytes)
2427  *
2428  * Allocates a new remote processor handle, but does not register
2429  * it yet. if @firmware is NULL, a default name is used.
2430  *
2431  * This function should be used by rproc implementations during initialization
2432  * of the remote processor.
2433  *
2434  * After creating an rproc handle using this function, and when ready,
2435  * implementations should then call rproc_add() to complete
2436  * the registration of the remote processor.
2437  *
2438  * Note: _never_ directly deallocate @rproc, even if it was not registered
2439  * yet. Instead, when you need to unroll rproc_alloc(), use rproc_free().
2440  *
2441  * Return: new rproc pointer on success, and NULL on failure
2442  */
2443 struct rproc *rproc_alloc(struct device *dev, const char *name,
2444                           const struct rproc_ops *ops,
2445                           const char *firmware, int len)
2446 {
2447         struct rproc *rproc;
2448
2449         if (!dev || !name || !ops)
2450                 return NULL;
2451
2452         rproc = kzalloc(sizeof(struct rproc) + len, GFP_KERNEL);
2453         if (!rproc)
2454                 return NULL;
2455
2456         rproc->priv = &rproc[1];
2457         rproc->auto_boot = true;
2458         rproc->elf_class = ELFCLASSNONE;
2459         rproc->elf_machine = EM_NONE;
2460
2461         device_initialize(&rproc->dev);
2462         rproc->dev.parent = dev;
2463         rproc->dev.type = &rproc_type;
2464         rproc->dev.class = &rproc_class;
2465         rproc->dev.driver_data = rproc;
2466         idr_init(&rproc->notifyids);
2467
2468         rproc->name = kstrdup_const(name, GFP_KERNEL);
2469         if (!rproc->name)
2470                 goto put_device;
2471
2472         if (rproc_alloc_firmware(rproc, name, firmware))
2473                 goto put_device;
2474
2475         if (rproc_alloc_ops(rproc, ops))
2476                 goto put_device;
2477
2478         /* Assign a unique device index and name */
2479         rproc->index = ida_alloc(&rproc_dev_index, GFP_KERNEL);
2480         if (rproc->index < 0) {
2481                 dev_err(dev, "ida_alloc failed: %d\n", rproc->index);
2482                 goto put_device;
2483         }
2484
2485         dev_set_name(&rproc->dev, "remoteproc%d", rproc->index);
2486
2487         atomic_set(&rproc->power, 0);
2488
2489         mutex_init(&rproc->lock);
2490
2491         INIT_LIST_HEAD(&rproc->carveouts);
2492         INIT_LIST_HEAD(&rproc->mappings);
2493         INIT_LIST_HEAD(&rproc->traces);
2494         INIT_LIST_HEAD(&rproc->rvdevs);
2495         INIT_LIST_HEAD(&rproc->subdevs);
2496         INIT_LIST_HEAD(&rproc->dump_segments);
2497
2498         INIT_WORK(&rproc->crash_handler, rproc_crash_handler_work);
2499
2500         rproc->state = RPROC_OFFLINE;
2501
2502         return rproc;
2503
2504 put_device:
2505         put_device(&rproc->dev);
2506         return NULL;
2507 }
2508 EXPORT_SYMBOL(rproc_alloc);
2509
2510 /**
2511  * rproc_free() - unroll rproc_alloc()
2512  * @rproc: the remote processor handle
2513  *
2514  * This function decrements the rproc dev refcount.
2515  *
2516  * If no one holds any reference to rproc anymore, then its refcount would
2517  * now drop to zero, and it would be freed.
2518  */
2519 void rproc_free(struct rproc *rproc)
2520 {
2521         put_device(&rproc->dev);
2522 }
2523 EXPORT_SYMBOL(rproc_free);
2524
2525 /**
2526  * rproc_put() - release rproc reference
2527  * @rproc: the remote processor handle
2528  *
2529  * This function decrements the rproc dev refcount.
2530  *
2531  * If no one holds any reference to rproc anymore, then its refcount would
2532  * now drop to zero, and it would be freed.
2533  */
2534 void rproc_put(struct rproc *rproc)
2535 {
2536         module_put(rproc->dev.parent->driver->owner);
2537         put_device(&rproc->dev);
2538 }
2539 EXPORT_SYMBOL(rproc_put);
2540
2541 /**
2542  * rproc_del() - unregister a remote processor
2543  * @rproc: rproc handle to unregister
2544  *
2545  * This function should be called when the platform specific rproc
2546  * implementation decides to remove the rproc device. it should
2547  * _only_ be called if a previous invocation of rproc_add()
2548  * has completed successfully.
2549  *
2550  * After rproc_del() returns, @rproc isn't freed yet, because
2551  * of the outstanding reference created by rproc_alloc. To decrement that
2552  * one last refcount, one still needs to call rproc_free().
2553  *
2554  * Return: 0 on success and -EINVAL if @rproc isn't valid
2555  */
2556 int rproc_del(struct rproc *rproc)
2557 {
2558         if (!rproc)
2559                 return -EINVAL;
2560
2561         /* TODO: make sure this works with rproc->power > 1 */
2562         rproc_shutdown(rproc);
2563
2564         mutex_lock(&rproc->lock);
2565         rproc->state = RPROC_DELETED;
2566         mutex_unlock(&rproc->lock);
2567
2568         rproc_delete_debug_dir(rproc);
2569
2570         /* the rproc is downref'ed as soon as it's removed from the klist */
2571         mutex_lock(&rproc_list_mutex);
2572         list_del_rcu(&rproc->node);
2573         mutex_unlock(&rproc_list_mutex);
2574
2575         /* Ensure that no readers of rproc_list are still active */
2576         synchronize_rcu();
2577
2578         device_del(&rproc->dev);
2579         rproc_char_device_remove(rproc);
2580
2581         return 0;
2582 }
2583 EXPORT_SYMBOL(rproc_del);
2584
2585 static void devm_rproc_free(struct device *dev, void *res)
2586 {
2587         rproc_free(*(struct rproc **)res);
2588 }
2589
2590 /**
2591  * devm_rproc_alloc() - resource managed rproc_alloc()
2592  * @dev: the underlying device
2593  * @name: name of this remote processor
2594  * @ops: platform-specific handlers (mainly start/stop)
2595  * @firmware: name of firmware file to load, can be NULL
2596  * @len: length of private data needed by the rproc driver (in bytes)
2597  *
2598  * This function performs like rproc_alloc() but the acquired rproc device will
2599  * automatically be released on driver detach.
2600  *
2601  * Return: new rproc instance, or NULL on failure
2602  */
2603 struct rproc *devm_rproc_alloc(struct device *dev, const char *name,
2604                                const struct rproc_ops *ops,
2605                                const char *firmware, int len)
2606 {
2607         struct rproc **ptr, *rproc;
2608
2609         ptr = devres_alloc(devm_rproc_free, sizeof(*ptr), GFP_KERNEL);
2610         if (!ptr)
2611                 return NULL;
2612
2613         rproc = rproc_alloc(dev, name, ops, firmware, len);
2614         if (rproc) {
2615                 *ptr = rproc;
2616                 devres_add(dev, ptr);
2617         } else {
2618                 devres_free(ptr);
2619         }
2620
2621         return rproc;
2622 }
2623 EXPORT_SYMBOL(devm_rproc_alloc);
2624
2625 /**
2626  * rproc_add_subdev() - add a subdevice to a remoteproc
2627  * @rproc: rproc handle to add the subdevice to
2628  * @subdev: subdev handle to register
2629  *
2630  * Caller is responsible for populating optional subdevice function pointers.
2631  */
2632 void rproc_add_subdev(struct rproc *rproc, struct rproc_subdev *subdev)
2633 {
2634         list_add_tail(&subdev->node, &rproc->subdevs);
2635 }
2636 EXPORT_SYMBOL(rproc_add_subdev);
2637
2638 /**
2639  * rproc_remove_subdev() - remove a subdevice from a remoteproc
2640  * @rproc: rproc handle to remove the subdevice from
2641  * @subdev: subdev handle, previously registered with rproc_add_subdev()
2642  */
2643 void rproc_remove_subdev(struct rproc *rproc, struct rproc_subdev *subdev)
2644 {
2645         list_del(&subdev->node);
2646 }
2647 EXPORT_SYMBOL(rproc_remove_subdev);
2648
2649 /**
2650  * rproc_get_by_child() - acquire rproc handle of @dev's ancestor
2651  * @dev:        child device to find ancestor of
2652  *
2653  * Return: the ancestor rproc instance, or NULL if not found
2654  */
2655 struct rproc *rproc_get_by_child(struct device *dev)
2656 {
2657         for (dev = dev->parent; dev; dev = dev->parent) {
2658                 if (dev->type == &rproc_type)
2659                         return dev->driver_data;
2660         }
2661
2662         return NULL;
2663 }
2664 EXPORT_SYMBOL(rproc_get_by_child);
2665
2666 /**
2667  * rproc_report_crash() - rproc crash reporter function
2668  * @rproc: remote processor
2669  * @type: crash type
2670  *
2671  * This function must be called every time a crash is detected by the low-level
2672  * drivers implementing a specific remoteproc. This should not be called from a
2673  * non-remoteproc driver.
2674  *
2675  * This function can be called from atomic/interrupt context.
2676  */
2677 void rproc_report_crash(struct rproc *rproc, enum rproc_crash_type type)
2678 {
2679         if (!rproc) {
2680                 pr_err("NULL rproc pointer\n");
2681                 return;
2682         }
2683
2684         /* Prevent suspend while the remoteproc is being recovered */
2685         pm_stay_awake(rproc->dev.parent);
2686
2687         dev_err(&rproc->dev, "crash detected in %s: type %s\n",
2688                 rproc->name, rproc_crash_to_string(type));
2689
2690         queue_work(rproc_recovery_wq, &rproc->crash_handler);
2691 }
2692 EXPORT_SYMBOL(rproc_report_crash);
2693
2694 static int rproc_panic_handler(struct notifier_block *nb, unsigned long event,
2695                                void *ptr)
2696 {
2697         unsigned int longest = 0;
2698         struct rproc *rproc;
2699         unsigned int d;
2700
2701         rcu_read_lock();
2702         list_for_each_entry_rcu(rproc, &rproc_list, node) {
2703                 if (!rproc->ops->panic)
2704                         continue;
2705
2706                 if (rproc->state != RPROC_RUNNING &&
2707                     rproc->state != RPROC_ATTACHED)
2708                         continue;
2709
2710                 d = rproc->ops->panic(rproc);
2711                 longest = max(longest, d);
2712         }
2713         rcu_read_unlock();
2714
2715         /*
2716          * Delay for the longest requested duration before returning. This can
2717          * be used by the remoteproc drivers to give the remote processor time
2718          * to perform any requested operations (such as flush caches), when
2719          * it's not possible to signal the Linux side due to the panic.
2720          */
2721         mdelay(longest);
2722
2723         return NOTIFY_DONE;
2724 }
2725
2726 static void __init rproc_init_panic(void)
2727 {
2728         rproc_panic_nb.notifier_call = rproc_panic_handler;
2729         atomic_notifier_chain_register(&panic_notifier_list, &rproc_panic_nb);
2730 }
2731
2732 static void __exit rproc_exit_panic(void)
2733 {
2734         atomic_notifier_chain_unregister(&panic_notifier_list, &rproc_panic_nb);
2735 }
2736
2737 static int __init remoteproc_init(void)
2738 {
2739         rproc_recovery_wq = alloc_workqueue("rproc_recovery_wq",
2740                                                 WQ_UNBOUND | WQ_FREEZABLE, 0);
2741         if (!rproc_recovery_wq) {
2742                 pr_err("remoteproc: creation of rproc_recovery_wq failed\n");
2743                 return -ENOMEM;
2744         }
2745
2746         rproc_init_sysfs();
2747         rproc_init_debugfs();
2748         rproc_init_cdev();
2749         rproc_init_panic();
2750
2751         return 0;
2752 }
2753 subsys_initcall(remoteproc_init);
2754
2755 static void __exit remoteproc_exit(void)
2756 {
2757         ida_destroy(&rproc_dev_index);
2758
2759         if (!rproc_recovery_wq)
2760                 return;
2761
2762         rproc_exit_panic();
2763         rproc_exit_debugfs();
2764         rproc_exit_sysfs();
2765         destroy_workqueue(rproc_recovery_wq);
2766 }
2767 module_exit(remoteproc_exit);
2768
2769 MODULE_DESCRIPTION("Generic Remote Processor Framework");