Merge tag 'rproc-v4.20' of git://github.com/andersson/remoteproc
[sfrench/cifs-2.6.git] / drivers / remoteproc / remoteproc_core.c
1 /*
2  * Remote Processor Framework
3  *
4  * Copyright (C) 2011 Texas Instruments, Inc.
5  * Copyright (C) 2011 Google, Inc.
6  *
7  * Ohad Ben-Cohen <ohad@wizery.com>
8  * Brian Swetland <swetland@google.com>
9  * Mark Grosen <mgrosen@ti.com>
10  * Fernando Guzman Lugo <fernando.lugo@ti.com>
11  * Suman Anna <s-anna@ti.com>
12  * Robert Tivy <rtivy@ti.com>
13  * Armando Uribe De Leon <x0095078@ti.com>
14  *
15  * This program is free software; you can redistribute it and/or
16  * modify it under the terms of the GNU General Public License
17  * version 2 as published by the Free Software Foundation.
18  *
19  * This program is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  * GNU General Public License for more details.
23  */
24
25 #define pr_fmt(fmt)    "%s: " fmt, __func__
26
27 #include <linux/kernel.h>
28 #include <linux/module.h>
29 #include <linux/device.h>
30 #include <linux/slab.h>
31 #include <linux/mutex.h>
32 #include <linux/dma-mapping.h>
33 #include <linux/firmware.h>
34 #include <linux/string.h>
35 #include <linux/debugfs.h>
36 #include <linux/devcoredump.h>
37 #include <linux/remoteproc.h>
38 #include <linux/iommu.h>
39 #include <linux/idr.h>
40 #include <linux/elf.h>
41 #include <linux/crc32.h>
42 #include <linux/virtio_ids.h>
43 #include <linux/virtio_ring.h>
44 #include <asm/byteorder.h>
45
46 #include "remoteproc_internal.h"
47
48 static DEFINE_MUTEX(rproc_list_mutex);
49 static LIST_HEAD(rproc_list);
50
51 typedef int (*rproc_handle_resources_t)(struct rproc *rproc,
52                                 struct resource_table *table, int len);
53 typedef int (*rproc_handle_resource_t)(struct rproc *rproc,
54                                  void *, int offset, int avail);
55
56 static int rproc_alloc_carveout(struct rproc *rproc,
57                                 struct rproc_mem_entry *mem);
58 static int rproc_release_carveout(struct rproc *rproc,
59                                   struct rproc_mem_entry *mem);
60
61 /* Unique indices for remoteproc devices */
62 static DEFINE_IDA(rproc_dev_index);
63
64 static const char * const rproc_crash_names[] = {
65         [RPROC_MMUFAULT]        = "mmufault",
66         [RPROC_WATCHDOG]        = "watchdog",
67         [RPROC_FATAL_ERROR]     = "fatal error",
68 };
69
70 /* translate rproc_crash_type to string */
71 static const char *rproc_crash_to_string(enum rproc_crash_type type)
72 {
73         if (type < ARRAY_SIZE(rproc_crash_names))
74                 return rproc_crash_names[type];
75         return "unknown";
76 }
77
78 /*
79  * This is the IOMMU fault handler we register with the IOMMU API
80  * (when relevant; not all remote processors access memory through
81  * an IOMMU).
82  *
83  * IOMMU core will invoke this handler whenever the remote processor
84  * will try to access an unmapped device address.
85  */
86 static int rproc_iommu_fault(struct iommu_domain *domain, struct device *dev,
87                              unsigned long iova, int flags, void *token)
88 {
89         struct rproc *rproc = token;
90
91         dev_err(dev, "iommu fault: da 0x%lx flags 0x%x\n", iova, flags);
92
93         rproc_report_crash(rproc, RPROC_MMUFAULT);
94
95         /*
96          * Let the iommu core know we're not really handling this fault;
97          * we just used it as a recovery trigger.
98          */
99         return -ENOSYS;
100 }
101
102 static int rproc_enable_iommu(struct rproc *rproc)
103 {
104         struct iommu_domain *domain;
105         struct device *dev = rproc->dev.parent;
106         int ret;
107
108         if (!rproc->has_iommu) {
109                 dev_dbg(dev, "iommu not present\n");
110                 return 0;
111         }
112
113         domain = iommu_domain_alloc(dev->bus);
114         if (!domain) {
115                 dev_err(dev, "can't alloc iommu domain\n");
116                 return -ENOMEM;
117         }
118
119         iommu_set_fault_handler(domain, rproc_iommu_fault, rproc);
120
121         ret = iommu_attach_device(domain, dev);
122         if (ret) {
123                 dev_err(dev, "can't attach iommu device: %d\n", ret);
124                 goto free_domain;
125         }
126
127         rproc->domain = domain;
128
129         return 0;
130
131 free_domain:
132         iommu_domain_free(domain);
133         return ret;
134 }
135
136 static void rproc_disable_iommu(struct rproc *rproc)
137 {
138         struct iommu_domain *domain = rproc->domain;
139         struct device *dev = rproc->dev.parent;
140
141         if (!domain)
142                 return;
143
144         iommu_detach_device(domain, dev);
145         iommu_domain_free(domain);
146 }
147
148 static phys_addr_t rproc_va_to_pa(void *cpu_addr)
149 {
150         /*
151          * Return physical address according to virtual address location
152          * - in vmalloc: if region ioremapped or defined as dma_alloc_coherent
153          * - in kernel: if region allocated in generic dma memory pool
154          */
155         if (is_vmalloc_addr(cpu_addr)) {
156                 return page_to_phys(vmalloc_to_page(cpu_addr)) +
157                                     offset_in_page(cpu_addr);
158         }
159
160         WARN_ON(!virt_addr_valid(cpu_addr));
161         return virt_to_phys(cpu_addr);
162 }
163
164 /**
165  * rproc_da_to_va() - lookup the kernel virtual address for a remoteproc address
166  * @rproc: handle of a remote processor
167  * @da: remoteproc device address to translate
168  * @len: length of the memory region @da is pointing to
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  * The function returns a valid kernel address on success or NULL on failure.
187  *
188  * Note: phys_to_virt(iommu_iova_to_phys(rproc->domain, da)) will work too,
189  * but only on kernel direct mapped RAM memory. Instead, we're just using
190  * here the output of the DMA API for the carveouts, which should be more
191  * correct.
192  */
193 void *rproc_da_to_va(struct rproc *rproc, u64 da, int len)
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);
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                 /* try next carveout if da is too small */
208                 if (offset < 0)
209                         continue;
210
211                 /* try next carveout if da is too large */
212                 if (offset + len > carveout->len)
213                         continue;
214
215                 ptr = carveout->va + offset;
216
217                 break;
218         }
219
220 out:
221         return ptr;
222 }
223 EXPORT_SYMBOL(rproc_da_to_va);
224
225 /**
226  * rproc_find_carveout_by_name() - lookup the carveout region by a name
227  * @rproc: handle of a remote processor
228  * @name,..: carveout name to find (standard printf format)
229  *
230  * Platform driver has the capability to register some pre-allacoted carveout
231  * (physically contiguous memory regions) before rproc firmware loading and
232  * associated resource table analysis. These regions may be dedicated memory
233  * regions internal to the coprocessor or specified DDR region with specific
234  * attributes
235  *
236  * This function is a helper function with which we can go over the
237  * allocated carveouts and return associated region characteristics like
238  * coprocessor address, length or processor virtual address.
239  *
240  * Return: a valid pointer on carveout entry on success or NULL on failure.
241  */
242 struct rproc_mem_entry *
243 rproc_find_carveout_by_name(struct rproc *rproc, const char *name, ...)
244 {
245         va_list args;
246         char _name[32];
247         struct rproc_mem_entry *carveout, *mem = NULL;
248
249         if (!name)
250                 return NULL;
251
252         va_start(args, name);
253         vsnprintf(_name, sizeof(_name), name, args);
254         va_end(args);
255
256         list_for_each_entry(carveout, &rproc->carveouts, node) {
257                 /* Compare carveout and requested names */
258                 if (!strcmp(carveout->name, _name)) {
259                         mem = carveout;
260                         break;
261                 }
262         }
263
264         return mem;
265 }
266
267 /**
268  * rproc_check_carveout_da() - Check specified carveout da configuration
269  * @rproc: handle of a remote processor
270  * @mem: pointer on carveout to check
271  * @da: area device address
272  * @len: associated area size
273  *
274  * This function is a helper function to verify requested device area (couple
275  * da, len) is part of specified carevout.
276  *
277  * Return: 0 if carveout match request else -ENOMEM
278  */
279 int rproc_check_carveout_da(struct rproc *rproc, struct rproc_mem_entry *mem,
280                             u32 da, u32 len)
281 {
282         struct device *dev = &rproc->dev;
283         int delta = 0;
284
285         /* Check requested resource length */
286         if (len > mem->len) {
287                 dev_err(dev, "Registered carveout doesn't fit len request\n");
288                 return -ENOMEM;
289         }
290
291         if (da != FW_RSC_ADDR_ANY && mem->da == FW_RSC_ADDR_ANY) {
292                 /* Update existing carveout da */
293                 mem->da = da;
294         } else if (da != FW_RSC_ADDR_ANY && mem->da != FW_RSC_ADDR_ANY) {
295                 delta = da - mem->da;
296
297                 /* Check requested resource belongs to registered carveout */
298                 if (delta < 0) {
299                         dev_err(dev,
300                                 "Registered carveout doesn't fit da request\n");
301                         return -ENOMEM;
302                 }
303
304                 if (delta + len > mem->len) {
305                         dev_err(dev,
306                                 "Registered carveout doesn't fit len request\n");
307                         return -ENOMEM;
308                 }
309         }
310
311         return 0;
312 }
313
314 int rproc_alloc_vring(struct rproc_vdev *rvdev, int i)
315 {
316         struct rproc *rproc = rvdev->rproc;
317         struct device *dev = &rproc->dev;
318         struct rproc_vring *rvring = &rvdev->vring[i];
319         struct fw_rsc_vdev *rsc;
320         int ret, size, notifyid;
321         struct rproc_mem_entry *mem;
322
323         /* actual size of vring (in bytes) */
324         size = PAGE_ALIGN(vring_size(rvring->len, rvring->align));
325
326         rsc = (void *)rproc->table_ptr + rvdev->rsc_offset;
327
328         /* Search for pre-registered carveout */
329         mem = rproc_find_carveout_by_name(rproc, "vdev%dvring%d", rvdev->index,
330                                           i);
331         if (mem) {
332                 if (rproc_check_carveout_da(rproc, mem, rsc->vring[i].da, size))
333                         return -ENOMEM;
334         } else {
335                 /* Register carveout in in list */
336                 mem = rproc_mem_entry_init(dev, 0, 0, size, rsc->vring[i].da,
337                                            rproc_alloc_carveout,
338                                            rproc_release_carveout,
339                                            "vdev%dvring%d",
340                                            rvdev->index, i);
341                 if (!mem) {
342                         dev_err(dev, "Can't allocate memory entry structure\n");
343                         return -ENOMEM;
344                 }
345
346                 rproc_add_carveout(rproc, mem);
347         }
348
349         /*
350          * Assign an rproc-wide unique index for this vring
351          * TODO: assign a notifyid for rvdev updates as well
352          * TODO: support predefined notifyids (via resource table)
353          */
354         ret = idr_alloc(&rproc->notifyids, rvring, 0, 0, GFP_KERNEL);
355         if (ret < 0) {
356                 dev_err(dev, "idr_alloc failed: %d\n", ret);
357                 return ret;
358         }
359         notifyid = ret;
360
361         /* Potentially bump max_notifyid */
362         if (notifyid > rproc->max_notifyid)
363                 rproc->max_notifyid = notifyid;
364
365         rvring->notifyid = notifyid;
366
367         /* Let the rproc know the notifyid of this vring.*/
368         rsc->vring[i].notifyid = notifyid;
369         return 0;
370 }
371
372 static int
373 rproc_parse_vring(struct rproc_vdev *rvdev, struct fw_rsc_vdev *rsc, int i)
374 {
375         struct rproc *rproc = rvdev->rproc;
376         struct device *dev = &rproc->dev;
377         struct fw_rsc_vdev_vring *vring = &rsc->vring[i];
378         struct rproc_vring *rvring = &rvdev->vring[i];
379
380         dev_dbg(dev, "vdev rsc: vring%d: da 0x%x, qsz %d, align %d\n",
381                 i, vring->da, vring->num, vring->align);
382
383         /* verify queue size and vring alignment are sane */
384         if (!vring->num || !vring->align) {
385                 dev_err(dev, "invalid qsz (%d) or alignment (%d)\n",
386                         vring->num, vring->align);
387                 return -EINVAL;
388         }
389
390         rvring->len = vring->num;
391         rvring->align = vring->align;
392         rvring->rvdev = rvdev;
393
394         return 0;
395 }
396
397 void rproc_free_vring(struct rproc_vring *rvring)
398 {
399         struct rproc *rproc = rvring->rvdev->rproc;
400         int idx = rvring->rvdev->vring - rvring;
401         struct fw_rsc_vdev *rsc;
402
403         idr_remove(&rproc->notifyids, rvring->notifyid);
404
405         /* reset resource entry info */
406         rsc = (void *)rproc->table_ptr + rvring->rvdev->rsc_offset;
407         rsc->vring[idx].da = 0;
408         rsc->vring[idx].notifyid = -1;
409 }
410
411 static int rproc_vdev_do_start(struct rproc_subdev *subdev)
412 {
413         struct rproc_vdev *rvdev = container_of(subdev, struct rproc_vdev, subdev);
414
415         return rproc_add_virtio_dev(rvdev, rvdev->id);
416 }
417
418 static void rproc_vdev_do_stop(struct rproc_subdev *subdev, bool crashed)
419 {
420         struct rproc_vdev *rvdev = container_of(subdev, struct rproc_vdev, subdev);
421
422         rproc_remove_virtio_dev(rvdev);
423 }
424
425 /**
426  * rproc_handle_vdev() - handle a vdev fw resource
427  * @rproc: the remote processor
428  * @rsc: the vring resource descriptor
429  * @avail: size of available data (for sanity checking the image)
430  *
431  * This resource entry requests the host to statically register a virtio
432  * device (vdev), and setup everything needed to support it. It contains
433  * everything needed to make it possible: the virtio device id, virtio
434  * device features, vrings information, virtio config space, etc...
435  *
436  * Before registering the vdev, the vrings are allocated from non-cacheable
437  * physically contiguous memory. Currently we only support two vrings per
438  * remote processor (temporary limitation). We might also want to consider
439  * doing the vring allocation only later when ->find_vqs() is invoked, and
440  * then release them upon ->del_vqs().
441  *
442  * Note: @da is currently not really handled correctly: we dynamically
443  * allocate it using the DMA API, ignoring requested hard coded addresses,
444  * and we don't take care of any required IOMMU programming. This is all
445  * going to be taken care of when the generic iommu-based DMA API will be
446  * merged. Meanwhile, statically-addressed iommu-based firmware images should
447  * use RSC_DEVMEM resource entries to map their required @da to the physical
448  * address of their base CMA region (ouch, hacky!).
449  *
450  * Returns 0 on success, or an appropriate error code otherwise
451  */
452 static int rproc_handle_vdev(struct rproc *rproc, struct fw_rsc_vdev *rsc,
453                              int offset, int avail)
454 {
455         struct device *dev = &rproc->dev;
456         struct rproc_vdev *rvdev;
457         int i, ret;
458
459         /* make sure resource isn't truncated */
460         if (sizeof(*rsc) + rsc->num_of_vrings * sizeof(struct fw_rsc_vdev_vring)
461                         + rsc->config_len > avail) {
462                 dev_err(dev, "vdev rsc is truncated\n");
463                 return -EINVAL;
464         }
465
466         /* make sure reserved bytes are zeroes */
467         if (rsc->reserved[0] || rsc->reserved[1]) {
468                 dev_err(dev, "vdev rsc has non zero reserved bytes\n");
469                 return -EINVAL;
470         }
471
472         dev_dbg(dev, "vdev rsc: id %d, dfeatures 0x%x, cfg len %d, %d vrings\n",
473                 rsc->id, rsc->dfeatures, rsc->config_len, rsc->num_of_vrings);
474
475         /* we currently support only two vrings per rvdev */
476         if (rsc->num_of_vrings > ARRAY_SIZE(rvdev->vring)) {
477                 dev_err(dev, "too many vrings: %d\n", rsc->num_of_vrings);
478                 return -EINVAL;
479         }
480
481         rvdev = kzalloc(sizeof(*rvdev), GFP_KERNEL);
482         if (!rvdev)
483                 return -ENOMEM;
484
485         kref_init(&rvdev->refcount);
486
487         rvdev->id = rsc->id;
488         rvdev->rproc = rproc;
489         rvdev->index = rproc->nb_vdev++;
490
491         /* parse the vrings */
492         for (i = 0; i < rsc->num_of_vrings; i++) {
493                 ret = rproc_parse_vring(rvdev, rsc, i);
494                 if (ret)
495                         goto free_rvdev;
496         }
497
498         /* remember the resource offset*/
499         rvdev->rsc_offset = offset;
500
501         /* allocate the vring resources */
502         for (i = 0; i < rsc->num_of_vrings; i++) {
503                 ret = rproc_alloc_vring(rvdev, i);
504                 if (ret)
505                         goto unwind_vring_allocations;
506         }
507
508         list_add_tail(&rvdev->node, &rproc->rvdevs);
509
510         rvdev->subdev.start = rproc_vdev_do_start;
511         rvdev->subdev.stop = rproc_vdev_do_stop;
512
513         rproc_add_subdev(rproc, &rvdev->subdev);
514
515         return 0;
516
517 unwind_vring_allocations:
518         for (i--; i >= 0; i--)
519                 rproc_free_vring(&rvdev->vring[i]);
520 free_rvdev:
521         kfree(rvdev);
522         return ret;
523 }
524
525 void rproc_vdev_release(struct kref *ref)
526 {
527         struct rproc_vdev *rvdev = container_of(ref, struct rproc_vdev, refcount);
528         struct rproc_vring *rvring;
529         struct rproc *rproc = rvdev->rproc;
530         int id;
531
532         for (id = 0; id < ARRAY_SIZE(rvdev->vring); id++) {
533                 rvring = &rvdev->vring[id];
534                 rproc_free_vring(rvring);
535         }
536
537         rproc_remove_subdev(rproc, &rvdev->subdev);
538         list_del(&rvdev->node);
539         kfree(rvdev);
540 }
541
542 /**
543  * rproc_handle_trace() - handle a shared trace buffer resource
544  * @rproc: the remote processor
545  * @rsc: the trace resource descriptor
546  * @avail: size of available data (for sanity checking the image)
547  *
548  * In case the remote processor dumps trace logs into memory,
549  * export it via debugfs.
550  *
551  * Currently, the 'da' member of @rsc should contain the device address
552  * where the remote processor is dumping the traces. Later we could also
553  * support dynamically allocating this address using the generic
554  * DMA API (but currently there isn't a use case for that).
555  *
556  * Returns 0 on success, or an appropriate error code otherwise
557  */
558 static int rproc_handle_trace(struct rproc *rproc, struct fw_rsc_trace *rsc,
559                               int offset, int avail)
560 {
561         struct rproc_mem_entry *trace;
562         struct device *dev = &rproc->dev;
563         void *ptr;
564         char name[15];
565
566         if (sizeof(*rsc) > avail) {
567                 dev_err(dev, "trace rsc is truncated\n");
568                 return -EINVAL;
569         }
570
571         /* make sure reserved bytes are zeroes */
572         if (rsc->reserved) {
573                 dev_err(dev, "trace rsc has non zero reserved bytes\n");
574                 return -EINVAL;
575         }
576
577         /* what's the kernel address of this resource ? */
578         ptr = rproc_da_to_va(rproc, rsc->da, rsc->len);
579         if (!ptr) {
580                 dev_err(dev, "erroneous trace resource entry\n");
581                 return -EINVAL;
582         }
583
584         trace = kzalloc(sizeof(*trace), GFP_KERNEL);
585         if (!trace)
586                 return -ENOMEM;
587
588         /* set the trace buffer dma properties */
589         trace->len = rsc->len;
590         trace->va = ptr;
591
592         /* make sure snprintf always null terminates, even if truncating */
593         snprintf(name, sizeof(name), "trace%d", rproc->num_traces);
594
595         /* create the debugfs entry */
596         trace->priv = rproc_create_trace_file(name, rproc, trace);
597         if (!trace->priv) {
598                 trace->va = NULL;
599                 kfree(trace);
600                 return -EINVAL;
601         }
602
603         list_add_tail(&trace->node, &rproc->traces);
604
605         rproc->num_traces++;
606
607         dev_dbg(dev, "%s added: va %pK, da 0x%x, len 0x%x\n",
608                 name, ptr, rsc->da, rsc->len);
609
610         return 0;
611 }
612
613 /**
614  * rproc_handle_devmem() - handle devmem resource entry
615  * @rproc: remote processor handle
616  * @rsc: the devmem resource entry
617  * @avail: size of available data (for sanity checking the image)
618  *
619  * Remote processors commonly need to access certain on-chip peripherals.
620  *
621  * Some of these remote processors access memory via an iommu device,
622  * and might require us to configure their iommu before they can access
623  * the on-chip peripherals they need.
624  *
625  * This resource entry is a request to map such a peripheral device.
626  *
627  * These devmem entries will contain the physical address of the device in
628  * the 'pa' member. If a specific device address is expected, then 'da' will
629  * contain it (currently this is the only use case supported). 'len' will
630  * contain the size of the physical region we need to map.
631  *
632  * Currently we just "trust" those devmem entries to contain valid physical
633  * addresses, but this is going to change: we want the implementations to
634  * tell us ranges of physical addresses the firmware is allowed to request,
635  * and not allow firmwares to request access to physical addresses that
636  * are outside those ranges.
637  */
638 static int rproc_handle_devmem(struct rproc *rproc, struct fw_rsc_devmem *rsc,
639                                int offset, int avail)
640 {
641         struct rproc_mem_entry *mapping;
642         struct device *dev = &rproc->dev;
643         int ret;
644
645         /* no point in handling this resource without a valid iommu domain */
646         if (!rproc->domain)
647                 return -EINVAL;
648
649         if (sizeof(*rsc) > avail) {
650                 dev_err(dev, "devmem rsc is truncated\n");
651                 return -EINVAL;
652         }
653
654         /* make sure reserved bytes are zeroes */
655         if (rsc->reserved) {
656                 dev_err(dev, "devmem rsc has non zero reserved bytes\n");
657                 return -EINVAL;
658         }
659
660         mapping = kzalloc(sizeof(*mapping), GFP_KERNEL);
661         if (!mapping)
662                 return -ENOMEM;
663
664         ret = iommu_map(rproc->domain, rsc->da, rsc->pa, rsc->len, rsc->flags);
665         if (ret) {
666                 dev_err(dev, "failed to map devmem: %d\n", ret);
667                 goto out;
668         }
669
670         /*
671          * We'll need this info later when we'll want to unmap everything
672          * (e.g. on shutdown).
673          *
674          * We can't trust the remote processor not to change the resource
675          * table, so we must maintain this info independently.
676          */
677         mapping->da = rsc->da;
678         mapping->len = rsc->len;
679         list_add_tail(&mapping->node, &rproc->mappings);
680
681         dev_dbg(dev, "mapped devmem pa 0x%x, da 0x%x, len 0x%x\n",
682                 rsc->pa, rsc->da, rsc->len);
683
684         return 0;
685
686 out:
687         kfree(mapping);
688         return ret;
689 }
690
691 /**
692  * rproc_alloc_carveout() - allocated specified carveout
693  * @rproc: rproc handle
694  * @mem: the memory entry to allocate
695  *
696  * This function allocate specified memory entry @mem using
697  * dma_alloc_coherent() as default allocator
698  */
699 static int rproc_alloc_carveout(struct rproc *rproc,
700                                 struct rproc_mem_entry *mem)
701 {
702         struct rproc_mem_entry *mapping = NULL;
703         struct device *dev = &rproc->dev;
704         dma_addr_t dma;
705         void *va;
706         int ret;
707
708         va = dma_alloc_coherent(dev->parent, mem->len, &dma, GFP_KERNEL);
709         if (!va) {
710                 dev_err(dev->parent,
711                         "failed to allocate dma memory: len 0x%x\n", mem->len);
712                 return -ENOMEM;
713         }
714
715         dev_dbg(dev, "carveout va %pK, dma %pad, len 0x%x\n",
716                 va, &dma, mem->len);
717
718         /*
719          * Ok, this is non-standard.
720          *
721          * Sometimes we can't rely on the generic iommu-based DMA API
722          * to dynamically allocate the device address and then set the IOMMU
723          * tables accordingly, because some remote processors might
724          * _require_ us to use hard coded device addresses that their
725          * firmware was compiled with.
726          *
727          * In this case, we must use the IOMMU API directly and map
728          * the memory to the device address as expected by the remote
729          * processor.
730          *
731          * Obviously such remote processor devices should not be configured
732          * to use the iommu-based DMA API: we expect 'dma' to contain the
733          * physical address in this case.
734          */
735
736         if (mem->da != FW_RSC_ADDR_ANY) {
737                 if (!rproc->domain) {
738                         dev_err(dev->parent,
739                                 "Bad carveout rsc configuration\n");
740                         ret = -ENOMEM;
741                         goto dma_free;
742                 }
743
744                 mapping = kzalloc(sizeof(*mapping), GFP_KERNEL);
745                 if (!mapping) {
746                         ret = -ENOMEM;
747                         goto dma_free;
748                 }
749
750                 ret = iommu_map(rproc->domain, mem->da, dma, mem->len,
751                                 mem->flags);
752                 if (ret) {
753                         dev_err(dev, "iommu_map failed: %d\n", ret);
754                         goto free_mapping;
755                 }
756
757                 /*
758                  * We'll need this info later when we'll want to unmap
759                  * everything (e.g. on shutdown).
760                  *
761                  * We can't trust the remote processor not to change the
762                  * resource table, so we must maintain this info independently.
763                  */
764                 mapping->da = mem->da;
765                 mapping->len = mem->len;
766                 list_add_tail(&mapping->node, &rproc->mappings);
767
768                 dev_dbg(dev, "carveout mapped 0x%x to %pad\n",
769                         mem->da, &dma);
770         } else {
771                 mem->da = (u32)dma;
772         }
773
774         mem->dma = (u32)dma;
775         mem->va = va;
776
777         return 0;
778
779 free_mapping:
780         kfree(mapping);
781 dma_free:
782         dma_free_coherent(dev->parent, mem->len, va, dma);
783         return ret;
784 }
785
786 /**
787  * rproc_release_carveout() - release acquired carveout
788  * @rproc: rproc handle
789  * @mem: the memory entry to release
790  *
791  * This function releases specified memory entry @mem allocated via
792  * rproc_alloc_carveout() function by @rproc.
793  */
794 static int rproc_release_carveout(struct rproc *rproc,
795                                   struct rproc_mem_entry *mem)
796 {
797         struct device *dev = &rproc->dev;
798
799         /* clean up carveout allocations */
800         dma_free_coherent(dev->parent, mem->len, mem->va, mem->dma);
801         return 0;
802 }
803
804 /**
805  * rproc_handle_carveout() - handle phys contig memory allocation requests
806  * @rproc: rproc handle
807  * @rsc: the resource entry
808  * @avail: size of available data (for image validation)
809  *
810  * This function will handle firmware requests for allocation of physically
811  * contiguous memory regions.
812  *
813  * These request entries should come first in the firmware's resource table,
814  * as other firmware entries might request placing other data objects inside
815  * these memory regions (e.g. data/code segments, trace resource entries, ...).
816  *
817  * Allocating memory this way helps utilizing the reserved physical memory
818  * (e.g. CMA) more efficiently, and also minimizes the number of TLB entries
819  * needed to map it (in case @rproc is using an IOMMU). Reducing the TLB
820  * pressure is important; it may have a substantial impact on performance.
821  */
822 static int rproc_handle_carveout(struct rproc *rproc,
823                                  struct fw_rsc_carveout *rsc,
824                                  int offset, int avail)
825 {
826         struct rproc_mem_entry *carveout;
827         struct device *dev = &rproc->dev;
828
829         if (sizeof(*rsc) > avail) {
830                 dev_err(dev, "carveout rsc is truncated\n");
831                 return -EINVAL;
832         }
833
834         /* make sure reserved bytes are zeroes */
835         if (rsc->reserved) {
836                 dev_err(dev, "carveout rsc has non zero reserved bytes\n");
837                 return -EINVAL;
838         }
839
840         dev_dbg(dev, "carveout rsc: name: %s, da 0x%x, pa 0x%x, len 0x%x, flags 0x%x\n",
841                 rsc->name, rsc->da, rsc->pa, rsc->len, rsc->flags);
842
843         /*
844          * Check carveout rsc already part of a registered carveout,
845          * Search by name, then check the da and length
846          */
847         carveout = rproc_find_carveout_by_name(rproc, rsc->name);
848
849         if (carveout) {
850                 if (carveout->rsc_offset != FW_RSC_ADDR_ANY) {
851                         dev_err(dev,
852                                 "Carveout already associated to resource table\n");
853                         return -ENOMEM;
854                 }
855
856                 if (rproc_check_carveout_da(rproc, carveout, rsc->da, rsc->len))
857                         return -ENOMEM;
858
859                 /* Update memory carveout with resource table info */
860                 carveout->rsc_offset = offset;
861                 carveout->flags = rsc->flags;
862
863                 return 0;
864         }
865
866         /* Register carveout in in list */
867         carveout = rproc_mem_entry_init(dev, 0, 0, rsc->len, rsc->da,
868                                         rproc_alloc_carveout,
869                                         rproc_release_carveout, rsc->name);
870         if (!carveout) {
871                 dev_err(dev, "Can't allocate memory entry structure\n");
872                 return -ENOMEM;
873         }
874
875         carveout->flags = rsc->flags;
876         carveout->rsc_offset = offset;
877         rproc_add_carveout(rproc, carveout);
878
879         return 0;
880 }
881
882 /**
883  * rproc_add_carveout() - register an allocated carveout region
884  * @rproc: rproc handle
885  * @mem: memory entry to register
886  *
887  * This function registers specified memory entry in @rproc carveouts list.
888  * Specified carveout should have been allocated before registering.
889  */
890 void rproc_add_carveout(struct rproc *rproc, struct rproc_mem_entry *mem)
891 {
892         list_add_tail(&mem->node, &rproc->carveouts);
893 }
894 EXPORT_SYMBOL(rproc_add_carveout);
895
896 /**
897  * rproc_mem_entry_init() - allocate and initialize rproc_mem_entry struct
898  * @dev: pointer on device struct
899  * @va: virtual address
900  * @dma: dma address
901  * @len: memory carveout length
902  * @da: device address
903  * @release: memory carveout function
904  * @name: carveout name
905  *
906  * This function allocates a rproc_mem_entry struct and fill it with parameters
907  * provided by client.
908  */
909 struct rproc_mem_entry *
910 rproc_mem_entry_init(struct device *dev,
911                      void *va, dma_addr_t dma, int len, u32 da,
912                      int (*alloc)(struct rproc *, struct rproc_mem_entry *),
913                      int (*release)(struct rproc *, struct rproc_mem_entry *),
914                      const char *name, ...)
915 {
916         struct rproc_mem_entry *mem;
917         va_list args;
918
919         mem = kzalloc(sizeof(*mem), GFP_KERNEL);
920         if (!mem)
921                 return mem;
922
923         mem->va = va;
924         mem->dma = dma;
925         mem->da = da;
926         mem->len = len;
927         mem->alloc = alloc;
928         mem->release = release;
929         mem->rsc_offset = FW_RSC_ADDR_ANY;
930         mem->of_resm_idx = -1;
931
932         va_start(args, name);
933         vsnprintf(mem->name, sizeof(mem->name), name, args);
934         va_end(args);
935
936         return mem;
937 }
938 EXPORT_SYMBOL(rproc_mem_entry_init);
939
940 /**
941  * rproc_of_resm_mem_entry_init() - allocate and initialize rproc_mem_entry struct
942  * from a reserved memory phandle
943  * @dev: pointer on device struct
944  * @of_resm_idx: reserved memory phandle index in "memory-region"
945  * @len: memory carveout length
946  * @da: device address
947  * @name: carveout name
948  *
949  * This function allocates a rproc_mem_entry struct and fill it with parameters
950  * provided by client.
951  */
952 struct rproc_mem_entry *
953 rproc_of_resm_mem_entry_init(struct device *dev, u32 of_resm_idx, int len,
954                              u32 da, const char *name, ...)
955 {
956         struct rproc_mem_entry *mem;
957         va_list args;
958
959         mem = kzalloc(sizeof(*mem), GFP_KERNEL);
960         if (!mem)
961                 return mem;
962
963         mem->da = da;
964         mem->len = len;
965         mem->rsc_offset = FW_RSC_ADDR_ANY;
966         mem->of_resm_idx = of_resm_idx;
967
968         va_start(args, name);
969         vsnprintf(mem->name, sizeof(mem->name), name, args);
970         va_end(args);
971
972         return mem;
973 }
974 EXPORT_SYMBOL(rproc_of_resm_mem_entry_init);
975
976 /**
977  * A lookup table for resource handlers. The indices are defined in
978  * enum fw_resource_type.
979  */
980 static rproc_handle_resource_t rproc_loading_handlers[RSC_LAST] = {
981         [RSC_CARVEOUT] = (rproc_handle_resource_t)rproc_handle_carveout,
982         [RSC_DEVMEM] = (rproc_handle_resource_t)rproc_handle_devmem,
983         [RSC_TRACE] = (rproc_handle_resource_t)rproc_handle_trace,
984         [RSC_VDEV] = (rproc_handle_resource_t)rproc_handle_vdev,
985 };
986
987 /* handle firmware resource entries before booting the remote processor */
988 static int rproc_handle_resources(struct rproc *rproc,
989                                   rproc_handle_resource_t handlers[RSC_LAST])
990 {
991         struct device *dev = &rproc->dev;
992         rproc_handle_resource_t handler;
993         int ret = 0, i;
994
995         if (!rproc->table_ptr)
996                 return 0;
997
998         for (i = 0; i < rproc->table_ptr->num; i++) {
999                 int offset = rproc->table_ptr->offset[i];
1000                 struct fw_rsc_hdr *hdr = (void *)rproc->table_ptr + offset;
1001                 int avail = rproc->table_sz - offset - sizeof(*hdr);
1002                 void *rsc = (void *)hdr + sizeof(*hdr);
1003
1004                 /* make sure table isn't truncated */
1005                 if (avail < 0) {
1006                         dev_err(dev, "rsc table is truncated\n");
1007                         return -EINVAL;
1008                 }
1009
1010                 dev_dbg(dev, "rsc: type %d\n", hdr->type);
1011
1012                 if (hdr->type >= RSC_LAST) {
1013                         dev_warn(dev, "unsupported resource %d\n", hdr->type);
1014                         continue;
1015                 }
1016
1017                 handler = handlers[hdr->type];
1018                 if (!handler)
1019                         continue;
1020
1021                 ret = handler(rproc, rsc, offset + sizeof(*hdr), avail);
1022                 if (ret)
1023                         break;
1024         }
1025
1026         return ret;
1027 }
1028
1029 static int rproc_prepare_subdevices(struct rproc *rproc)
1030 {
1031         struct rproc_subdev *subdev;
1032         int ret;
1033
1034         list_for_each_entry(subdev, &rproc->subdevs, node) {
1035                 if (subdev->prepare) {
1036                         ret = subdev->prepare(subdev);
1037                         if (ret)
1038                                 goto unroll_preparation;
1039                 }
1040         }
1041
1042         return 0;
1043
1044 unroll_preparation:
1045         list_for_each_entry_continue_reverse(subdev, &rproc->subdevs, node) {
1046                 if (subdev->unprepare)
1047                         subdev->unprepare(subdev);
1048         }
1049
1050         return ret;
1051 }
1052
1053 static int rproc_start_subdevices(struct rproc *rproc)
1054 {
1055         struct rproc_subdev *subdev;
1056         int ret;
1057
1058         list_for_each_entry(subdev, &rproc->subdevs, node) {
1059                 if (subdev->start) {
1060                         ret = subdev->start(subdev);
1061                         if (ret)
1062                                 goto unroll_registration;
1063                 }
1064         }
1065
1066         return 0;
1067
1068 unroll_registration:
1069         list_for_each_entry_continue_reverse(subdev, &rproc->subdevs, node) {
1070                 if (subdev->stop)
1071                         subdev->stop(subdev, true);
1072         }
1073
1074         return ret;
1075 }
1076
1077 static void rproc_stop_subdevices(struct rproc *rproc, bool crashed)
1078 {
1079         struct rproc_subdev *subdev;
1080
1081         list_for_each_entry_reverse(subdev, &rproc->subdevs, node) {
1082                 if (subdev->stop)
1083                         subdev->stop(subdev, crashed);
1084         }
1085 }
1086
1087 static void rproc_unprepare_subdevices(struct rproc *rproc)
1088 {
1089         struct rproc_subdev *subdev;
1090
1091         list_for_each_entry_reverse(subdev, &rproc->subdevs, node) {
1092                 if (subdev->unprepare)
1093                         subdev->unprepare(subdev);
1094         }
1095 }
1096
1097 /**
1098  * rproc_alloc_registered_carveouts() - allocate all carveouts registered
1099  * in the list
1100  * @rproc: the remote processor handle
1101  *
1102  * This function parses registered carveout list, performs allocation
1103  * if alloc() ops registered and updates resource table information
1104  * if rsc_offset set.
1105  *
1106  * Return: 0 on success
1107  */
1108 static int rproc_alloc_registered_carveouts(struct rproc *rproc)
1109 {
1110         struct rproc_mem_entry *entry, *tmp;
1111         struct fw_rsc_carveout *rsc;
1112         struct device *dev = &rproc->dev;
1113         int ret;
1114
1115         list_for_each_entry_safe(entry, tmp, &rproc->carveouts, node) {
1116                 if (entry->alloc) {
1117                         ret = entry->alloc(rproc, entry);
1118                         if (ret) {
1119                                 dev_err(dev, "Unable to allocate carveout %s: %d\n",
1120                                         entry->name, ret);
1121                                 return -ENOMEM;
1122                         }
1123                 }
1124
1125                 if (entry->rsc_offset != FW_RSC_ADDR_ANY) {
1126                         /* update resource table */
1127                         rsc = (void *)rproc->table_ptr + entry->rsc_offset;
1128
1129                         /*
1130                          * Some remote processors might need to know the pa
1131                          * even though they are behind an IOMMU. E.g., OMAP4's
1132                          * remote M3 processor needs this so it can control
1133                          * on-chip hardware accelerators that are not behind
1134                          * the IOMMU, and therefor must know the pa.
1135                          *
1136                          * Generally we don't want to expose physical addresses
1137                          * if we don't have to (remote processors are generally
1138                          * _not_ trusted), so we might want to do this only for
1139                          * remote processor that _must_ have this (e.g. OMAP4's
1140                          * dual M3 subsystem).
1141                          *
1142                          * Non-IOMMU processors might also want to have this info.
1143                          * In this case, the device address and the physical address
1144                          * are the same.
1145                          */
1146
1147                         /* Use va if defined else dma to generate pa */
1148                         if (entry->va)
1149                                 rsc->pa = (u32)rproc_va_to_pa(entry->va);
1150                         else
1151                                 rsc->pa = (u32)entry->dma;
1152
1153                         rsc->da = entry->da;
1154                         rsc->len = entry->len;
1155                 }
1156         }
1157
1158         return 0;
1159 }
1160
1161 /**
1162  * rproc_coredump_cleanup() - clean up dump_segments list
1163  * @rproc: the remote processor handle
1164  */
1165 static void rproc_coredump_cleanup(struct rproc *rproc)
1166 {
1167         struct rproc_dump_segment *entry, *tmp;
1168
1169         list_for_each_entry_safe(entry, tmp, &rproc->dump_segments, node) {
1170                 list_del(&entry->node);
1171                 kfree(entry);
1172         }
1173 }
1174
1175 /**
1176  * rproc_resource_cleanup() - clean up and free all acquired resources
1177  * @rproc: rproc handle
1178  *
1179  * This function will free all resources acquired for @rproc, and it
1180  * is called whenever @rproc either shuts down or fails to boot.
1181  */
1182 static void rproc_resource_cleanup(struct rproc *rproc)
1183 {
1184         struct rproc_mem_entry *entry, *tmp;
1185         struct rproc_vdev *rvdev, *rvtmp;
1186         struct device *dev = &rproc->dev;
1187
1188         /* clean up debugfs trace entries */
1189         list_for_each_entry_safe(entry, tmp, &rproc->traces, node) {
1190                 rproc_remove_trace_file(entry->priv);
1191                 rproc->num_traces--;
1192                 list_del(&entry->node);
1193                 kfree(entry);
1194         }
1195
1196         /* clean up iommu mapping entries */
1197         list_for_each_entry_safe(entry, tmp, &rproc->mappings, node) {
1198                 size_t unmapped;
1199
1200                 unmapped = iommu_unmap(rproc->domain, entry->da, entry->len);
1201                 if (unmapped != entry->len) {
1202                         /* nothing much to do besides complaining */
1203                         dev_err(dev, "failed to unmap %u/%zu\n", entry->len,
1204                                 unmapped);
1205                 }
1206
1207                 list_del(&entry->node);
1208                 kfree(entry);
1209         }
1210
1211         /* clean up carveout allocations */
1212         list_for_each_entry_safe(entry, tmp, &rproc->carveouts, node) {
1213                 if (entry->release)
1214                         entry->release(rproc, entry);
1215                 list_del(&entry->node);
1216                 kfree(entry);
1217         }
1218
1219         /* clean up remote vdev entries */
1220         list_for_each_entry_safe(rvdev, rvtmp, &rproc->rvdevs, node)
1221                 kref_put(&rvdev->refcount, rproc_vdev_release);
1222
1223         rproc_coredump_cleanup(rproc);
1224 }
1225
1226 static int rproc_start(struct rproc *rproc, const struct firmware *fw)
1227 {
1228         struct resource_table *loaded_table;
1229         struct device *dev = &rproc->dev;
1230         int ret;
1231
1232         /* load the ELF segments to memory */
1233         ret = rproc_load_segments(rproc, fw);
1234         if (ret) {
1235                 dev_err(dev, "Failed to load program segments: %d\n", ret);
1236                 return ret;
1237         }
1238
1239         /*
1240          * The starting device has been given the rproc->cached_table as the
1241          * resource table. The address of the vring along with the other
1242          * allocated resources (carveouts etc) is stored in cached_table.
1243          * In order to pass this information to the remote device we must copy
1244          * this information to device memory. We also update the table_ptr so
1245          * that any subsequent changes will be applied to the loaded version.
1246          */
1247         loaded_table = rproc_find_loaded_rsc_table(rproc, fw);
1248         if (loaded_table) {
1249                 memcpy(loaded_table, rproc->cached_table, rproc->table_sz);
1250                 rproc->table_ptr = loaded_table;
1251         }
1252
1253         ret = rproc_prepare_subdevices(rproc);
1254         if (ret) {
1255                 dev_err(dev, "failed to prepare subdevices for %s: %d\n",
1256                         rproc->name, ret);
1257                 goto reset_table_ptr;
1258         }
1259
1260         /* power up the remote processor */
1261         ret = rproc->ops->start(rproc);
1262         if (ret) {
1263                 dev_err(dev, "can't start rproc %s: %d\n", rproc->name, ret);
1264                 goto unprepare_subdevices;
1265         }
1266
1267         /* Start any subdevices for the remote processor */
1268         ret = rproc_start_subdevices(rproc);
1269         if (ret) {
1270                 dev_err(dev, "failed to probe subdevices for %s: %d\n",
1271                         rproc->name, ret);
1272                 goto stop_rproc;
1273         }
1274
1275         rproc->state = RPROC_RUNNING;
1276
1277         dev_info(dev, "remote processor %s is now up\n", rproc->name);
1278
1279         return 0;
1280
1281 stop_rproc:
1282         rproc->ops->stop(rproc);
1283 unprepare_subdevices:
1284         rproc_unprepare_subdevices(rproc);
1285 reset_table_ptr:
1286         rproc->table_ptr = rproc->cached_table;
1287
1288         return ret;
1289 }
1290
1291 /*
1292  * take a firmware and boot a remote processor with it.
1293  */
1294 static int rproc_fw_boot(struct rproc *rproc, const struct firmware *fw)
1295 {
1296         struct device *dev = &rproc->dev;
1297         const char *name = rproc->firmware;
1298         int ret;
1299
1300         ret = rproc_fw_sanity_check(rproc, fw);
1301         if (ret)
1302                 return ret;
1303
1304         dev_info(dev, "Booting fw image %s, size %zd\n", name, fw->size);
1305
1306         /*
1307          * if enabling an IOMMU isn't relevant for this rproc, this is
1308          * just a nop
1309          */
1310         ret = rproc_enable_iommu(rproc);
1311         if (ret) {
1312                 dev_err(dev, "can't enable iommu: %d\n", ret);
1313                 return ret;
1314         }
1315
1316         rproc->bootaddr = rproc_get_boot_addr(rproc, fw);
1317
1318         /* Load resource table, core dump segment list etc from the firmware */
1319         ret = rproc_parse_fw(rproc, fw);
1320         if (ret)
1321                 goto disable_iommu;
1322
1323         /* reset max_notifyid */
1324         rproc->max_notifyid = -1;
1325
1326         /* reset handled vdev */
1327         rproc->nb_vdev = 0;
1328
1329         /* handle fw resources which are required to boot rproc */
1330         ret = rproc_handle_resources(rproc, rproc_loading_handlers);
1331         if (ret) {
1332                 dev_err(dev, "Failed to process resources: %d\n", ret);
1333                 goto clean_up_resources;
1334         }
1335
1336         /* Allocate carveout resources associated to rproc */
1337         ret = rproc_alloc_registered_carveouts(rproc);
1338         if (ret) {
1339                 dev_err(dev, "Failed to allocate associated carveouts: %d\n",
1340                         ret);
1341                 goto clean_up_resources;
1342         }
1343
1344         ret = rproc_start(rproc, fw);
1345         if (ret)
1346                 goto clean_up_resources;
1347
1348         return 0;
1349
1350 clean_up_resources:
1351         rproc_resource_cleanup(rproc);
1352         kfree(rproc->cached_table);
1353         rproc->cached_table = NULL;
1354         rproc->table_ptr = NULL;
1355 disable_iommu:
1356         rproc_disable_iommu(rproc);
1357         return ret;
1358 }
1359
1360 /*
1361  * take a firmware and boot it up.
1362  *
1363  * Note: this function is called asynchronously upon registration of the
1364  * remote processor (so we must wait until it completes before we try
1365  * to unregister the device. one other option is just to use kref here,
1366  * that might be cleaner).
1367  */
1368 static void rproc_auto_boot_callback(const struct firmware *fw, void *context)
1369 {
1370         struct rproc *rproc = context;
1371
1372         rproc_boot(rproc);
1373
1374         release_firmware(fw);
1375 }
1376
1377 static int rproc_trigger_auto_boot(struct rproc *rproc)
1378 {
1379         int ret;
1380
1381         /*
1382          * We're initiating an asynchronous firmware loading, so we can
1383          * be built-in kernel code, without hanging the boot process.
1384          */
1385         ret = request_firmware_nowait(THIS_MODULE, FW_ACTION_HOTPLUG,
1386                                       rproc->firmware, &rproc->dev, GFP_KERNEL,
1387                                       rproc, rproc_auto_boot_callback);
1388         if (ret < 0)
1389                 dev_err(&rproc->dev, "request_firmware_nowait err: %d\n", ret);
1390
1391         return ret;
1392 }
1393
1394 static int rproc_stop(struct rproc *rproc, bool crashed)
1395 {
1396         struct device *dev = &rproc->dev;
1397         int ret;
1398
1399         /* Stop any subdevices for the remote processor */
1400         rproc_stop_subdevices(rproc, crashed);
1401
1402         /* the installed resource table is no longer accessible */
1403         rproc->table_ptr = rproc->cached_table;
1404
1405         /* power off the remote processor */
1406         ret = rproc->ops->stop(rproc);
1407         if (ret) {
1408                 dev_err(dev, "can't stop rproc: %d\n", ret);
1409                 return ret;
1410         }
1411
1412         rproc_unprepare_subdevices(rproc);
1413
1414         rproc->state = RPROC_OFFLINE;
1415
1416         dev_info(dev, "stopped remote processor %s\n", rproc->name);
1417
1418         return 0;
1419 }
1420
1421 /**
1422  * rproc_coredump_add_segment() - add segment of device memory to coredump
1423  * @rproc:      handle of a remote processor
1424  * @da:         device address
1425  * @size:       size of segment
1426  *
1427  * Add device memory to the list of segments to be included in a coredump for
1428  * the remoteproc.
1429  *
1430  * Return: 0 on success, negative errno on error.
1431  */
1432 int rproc_coredump_add_segment(struct rproc *rproc, dma_addr_t da, size_t size)
1433 {
1434         struct rproc_dump_segment *segment;
1435
1436         segment = kzalloc(sizeof(*segment), GFP_KERNEL);
1437         if (!segment)
1438                 return -ENOMEM;
1439
1440         segment->da = da;
1441         segment->size = size;
1442
1443         list_add_tail(&segment->node, &rproc->dump_segments);
1444
1445         return 0;
1446 }
1447 EXPORT_SYMBOL(rproc_coredump_add_segment);
1448
1449 /**
1450  * rproc_coredump_add_custom_segment() - add custom coredump segment
1451  * @rproc:      handle of a remote processor
1452  * @da:         device address
1453  * @size:       size of segment
1454  * @dumpfn:     custom dump function called for each segment during coredump
1455  * @priv:       private data
1456  *
1457  * Add device memory to the list of segments to be included in the coredump
1458  * and associate the segment with the given custom dump function and private
1459  * data.
1460  *
1461  * Return: 0 on success, negative errno on error.
1462  */
1463 int rproc_coredump_add_custom_segment(struct rproc *rproc,
1464                                       dma_addr_t da, size_t size,
1465                                       void (*dumpfn)(struct rproc *rproc,
1466                                                      struct rproc_dump_segment *segment,
1467                                                      void *dest),
1468                                       void *priv)
1469 {
1470         struct rproc_dump_segment *segment;
1471
1472         segment = kzalloc(sizeof(*segment), GFP_KERNEL);
1473         if (!segment)
1474                 return -ENOMEM;
1475
1476         segment->da = da;
1477         segment->size = size;
1478         segment->priv = priv;
1479         segment->dump = dumpfn;
1480
1481         list_add_tail(&segment->node, &rproc->dump_segments);
1482
1483         return 0;
1484 }
1485 EXPORT_SYMBOL(rproc_coredump_add_custom_segment);
1486
1487 /**
1488  * rproc_coredump() - perform coredump
1489  * @rproc:      rproc handle
1490  *
1491  * This function will generate an ELF header for the registered segments
1492  * and create a devcoredump device associated with rproc.
1493  */
1494 static void rproc_coredump(struct rproc *rproc)
1495 {
1496         struct rproc_dump_segment *segment;
1497         struct elf32_phdr *phdr;
1498         struct elf32_hdr *ehdr;
1499         size_t data_size;
1500         size_t offset;
1501         void *data;
1502         void *ptr;
1503         int phnum = 0;
1504
1505         if (list_empty(&rproc->dump_segments))
1506                 return;
1507
1508         data_size = sizeof(*ehdr);
1509         list_for_each_entry(segment, &rproc->dump_segments, node) {
1510                 data_size += sizeof(*phdr) + segment->size;
1511
1512                 phnum++;
1513         }
1514
1515         data = vmalloc(data_size);
1516         if (!data)
1517                 return;
1518
1519         ehdr = data;
1520
1521         memset(ehdr, 0, sizeof(*ehdr));
1522         memcpy(ehdr->e_ident, ELFMAG, SELFMAG);
1523         ehdr->e_ident[EI_CLASS] = ELFCLASS32;
1524         ehdr->e_ident[EI_DATA] = ELFDATA2LSB;
1525         ehdr->e_ident[EI_VERSION] = EV_CURRENT;
1526         ehdr->e_ident[EI_OSABI] = ELFOSABI_NONE;
1527         ehdr->e_type = ET_CORE;
1528         ehdr->e_machine = EM_NONE;
1529         ehdr->e_version = EV_CURRENT;
1530         ehdr->e_entry = rproc->bootaddr;
1531         ehdr->e_phoff = sizeof(*ehdr);
1532         ehdr->e_ehsize = sizeof(*ehdr);
1533         ehdr->e_phentsize = sizeof(*phdr);
1534         ehdr->e_phnum = phnum;
1535
1536         phdr = data + ehdr->e_phoff;
1537         offset = ehdr->e_phoff + sizeof(*phdr) * ehdr->e_phnum;
1538         list_for_each_entry(segment, &rproc->dump_segments, node) {
1539                 memset(phdr, 0, sizeof(*phdr));
1540                 phdr->p_type = PT_LOAD;
1541                 phdr->p_offset = offset;
1542                 phdr->p_vaddr = segment->da;
1543                 phdr->p_paddr = segment->da;
1544                 phdr->p_filesz = segment->size;
1545                 phdr->p_memsz = segment->size;
1546                 phdr->p_flags = PF_R | PF_W | PF_X;
1547                 phdr->p_align = 0;
1548
1549                 if (segment->dump) {
1550                         segment->dump(rproc, segment, data + offset);
1551                 } else {
1552                         ptr = rproc_da_to_va(rproc, segment->da, segment->size);
1553                         if (!ptr) {
1554                                 dev_err(&rproc->dev,
1555                                         "invalid coredump segment (%pad, %zu)\n",
1556                                         &segment->da, segment->size);
1557                                 memset(data + offset, 0xff, segment->size);
1558                         } else {
1559                                 memcpy(data + offset, ptr, segment->size);
1560                         }
1561                 }
1562
1563                 offset += phdr->p_filesz;
1564                 phdr++;
1565         }
1566
1567         dev_coredumpv(&rproc->dev, data, data_size, GFP_KERNEL);
1568 }
1569
1570 /**
1571  * rproc_trigger_recovery() - recover a remoteproc
1572  * @rproc: the remote processor
1573  *
1574  * The recovery is done by resetting all the virtio devices, that way all the
1575  * rpmsg drivers will be reseted along with the remote processor making the
1576  * remoteproc functional again.
1577  *
1578  * This function can sleep, so it cannot be called from atomic context.
1579  */
1580 int rproc_trigger_recovery(struct rproc *rproc)
1581 {
1582         const struct firmware *firmware_p;
1583         struct device *dev = &rproc->dev;
1584         int ret;
1585
1586         dev_err(dev, "recovering %s\n", rproc->name);
1587
1588         ret = mutex_lock_interruptible(&rproc->lock);
1589         if (ret)
1590                 return ret;
1591
1592         ret = rproc_stop(rproc, true);
1593         if (ret)
1594                 goto unlock_mutex;
1595
1596         /* generate coredump */
1597         rproc_coredump(rproc);
1598
1599         /* load firmware */
1600         ret = request_firmware(&firmware_p, rproc->firmware, dev);
1601         if (ret < 0) {
1602                 dev_err(dev, "request_firmware failed: %d\n", ret);
1603                 goto unlock_mutex;
1604         }
1605
1606         /* boot the remote processor up again */
1607         ret = rproc_start(rproc, firmware_p);
1608
1609         release_firmware(firmware_p);
1610
1611 unlock_mutex:
1612         mutex_unlock(&rproc->lock);
1613         return ret;
1614 }
1615
1616 /**
1617  * rproc_crash_handler_work() - handle a crash
1618  *
1619  * This function needs to handle everything related to a crash, like cpu
1620  * registers and stack dump, information to help to debug the fatal error, etc.
1621  */
1622 static void rproc_crash_handler_work(struct work_struct *work)
1623 {
1624         struct rproc *rproc = container_of(work, struct rproc, crash_handler);
1625         struct device *dev = &rproc->dev;
1626
1627         dev_dbg(dev, "enter %s\n", __func__);
1628
1629         mutex_lock(&rproc->lock);
1630
1631         if (rproc->state == RPROC_CRASHED || rproc->state == RPROC_OFFLINE) {
1632                 /* handle only the first crash detected */
1633                 mutex_unlock(&rproc->lock);
1634                 return;
1635         }
1636
1637         rproc->state = RPROC_CRASHED;
1638         dev_err(dev, "handling crash #%u in %s\n", ++rproc->crash_cnt,
1639                 rproc->name);
1640
1641         mutex_unlock(&rproc->lock);
1642
1643         if (!rproc->recovery_disabled)
1644                 rproc_trigger_recovery(rproc);
1645 }
1646
1647 /**
1648  * rproc_boot() - boot a remote processor
1649  * @rproc: handle of a remote processor
1650  *
1651  * Boot a remote processor (i.e. load its firmware, power it on, ...).
1652  *
1653  * If the remote processor is already powered on, this function immediately
1654  * returns (successfully).
1655  *
1656  * Returns 0 on success, and an appropriate error value otherwise.
1657  */
1658 int rproc_boot(struct rproc *rproc)
1659 {
1660         const struct firmware *firmware_p;
1661         struct device *dev;
1662         int ret;
1663
1664         if (!rproc) {
1665                 pr_err("invalid rproc handle\n");
1666                 return -EINVAL;
1667         }
1668
1669         dev = &rproc->dev;
1670
1671         ret = mutex_lock_interruptible(&rproc->lock);
1672         if (ret) {
1673                 dev_err(dev, "can't lock rproc %s: %d\n", rproc->name, ret);
1674                 return ret;
1675         }
1676
1677         if (rproc->state == RPROC_DELETED) {
1678                 ret = -ENODEV;
1679                 dev_err(dev, "can't boot deleted rproc %s\n", rproc->name);
1680                 goto unlock_mutex;
1681         }
1682
1683         /* skip the boot process if rproc is already powered up */
1684         if (atomic_inc_return(&rproc->power) > 1) {
1685                 ret = 0;
1686                 goto unlock_mutex;
1687         }
1688
1689         dev_info(dev, "powering up %s\n", rproc->name);
1690
1691         /* load firmware */
1692         ret = request_firmware(&firmware_p, rproc->firmware, dev);
1693         if (ret < 0) {
1694                 dev_err(dev, "request_firmware failed: %d\n", ret);
1695                 goto downref_rproc;
1696         }
1697
1698         ret = rproc_fw_boot(rproc, firmware_p);
1699
1700         release_firmware(firmware_p);
1701
1702 downref_rproc:
1703         if (ret)
1704                 atomic_dec(&rproc->power);
1705 unlock_mutex:
1706         mutex_unlock(&rproc->lock);
1707         return ret;
1708 }
1709 EXPORT_SYMBOL(rproc_boot);
1710
1711 /**
1712  * rproc_shutdown() - power off the remote processor
1713  * @rproc: the remote processor
1714  *
1715  * Power off a remote processor (previously booted with rproc_boot()).
1716  *
1717  * In case @rproc is still being used by an additional user(s), then
1718  * this function will just decrement the power refcount and exit,
1719  * without really powering off the device.
1720  *
1721  * Every call to rproc_boot() must (eventually) be accompanied by a call
1722  * to rproc_shutdown(). Calling rproc_shutdown() redundantly is a bug.
1723  *
1724  * Notes:
1725  * - we're not decrementing the rproc's refcount, only the power refcount.
1726  *   which means that the @rproc handle stays valid even after rproc_shutdown()
1727  *   returns, and users can still use it with a subsequent rproc_boot(), if
1728  *   needed.
1729  */
1730 void rproc_shutdown(struct rproc *rproc)
1731 {
1732         struct device *dev = &rproc->dev;
1733         int ret;
1734
1735         ret = mutex_lock_interruptible(&rproc->lock);
1736         if (ret) {
1737                 dev_err(dev, "can't lock rproc %s: %d\n", rproc->name, ret);
1738                 return;
1739         }
1740
1741         /* if the remote proc is still needed, bail out */
1742         if (!atomic_dec_and_test(&rproc->power))
1743                 goto out;
1744
1745         ret = rproc_stop(rproc, false);
1746         if (ret) {
1747                 atomic_inc(&rproc->power);
1748                 goto out;
1749         }
1750
1751         /* clean up all acquired resources */
1752         rproc_resource_cleanup(rproc);
1753
1754         rproc_disable_iommu(rproc);
1755
1756         /* Free the copy of the resource table */
1757         kfree(rproc->cached_table);
1758         rproc->cached_table = NULL;
1759         rproc->table_ptr = NULL;
1760 out:
1761         mutex_unlock(&rproc->lock);
1762 }
1763 EXPORT_SYMBOL(rproc_shutdown);
1764
1765 /**
1766  * rproc_get_by_phandle() - find a remote processor by phandle
1767  * @phandle: phandle to the rproc
1768  *
1769  * Finds an rproc handle using the remote processor's phandle, and then
1770  * return a handle to the rproc.
1771  *
1772  * This function increments the remote processor's refcount, so always
1773  * use rproc_put() to decrement it back once rproc isn't needed anymore.
1774  *
1775  * Returns the rproc handle on success, and NULL on failure.
1776  */
1777 #ifdef CONFIG_OF
1778 struct rproc *rproc_get_by_phandle(phandle phandle)
1779 {
1780         struct rproc *rproc = NULL, *r;
1781         struct device_node *np;
1782
1783         np = of_find_node_by_phandle(phandle);
1784         if (!np)
1785                 return NULL;
1786
1787         mutex_lock(&rproc_list_mutex);
1788         list_for_each_entry(r, &rproc_list, node) {
1789                 if (r->dev.parent && r->dev.parent->of_node == np) {
1790                         /* prevent underlying implementation from being removed */
1791                         if (!try_module_get(r->dev.parent->driver->owner)) {
1792                                 dev_err(&r->dev, "can't get owner\n");
1793                                 break;
1794                         }
1795
1796                         rproc = r;
1797                         get_device(&rproc->dev);
1798                         break;
1799                 }
1800         }
1801         mutex_unlock(&rproc_list_mutex);
1802
1803         of_node_put(np);
1804
1805         return rproc;
1806 }
1807 #else
1808 struct rproc *rproc_get_by_phandle(phandle phandle)
1809 {
1810         return NULL;
1811 }
1812 #endif
1813 EXPORT_SYMBOL(rproc_get_by_phandle);
1814
1815 /**
1816  * rproc_add() - register a remote processor
1817  * @rproc: the remote processor handle to register
1818  *
1819  * Registers @rproc with the remoteproc framework, after it has been
1820  * allocated with rproc_alloc().
1821  *
1822  * This is called by the platform-specific rproc implementation, whenever
1823  * a new remote processor device is probed.
1824  *
1825  * Returns 0 on success and an appropriate error code otherwise.
1826  *
1827  * Note: this function initiates an asynchronous firmware loading
1828  * context, which will look for virtio devices supported by the rproc's
1829  * firmware.
1830  *
1831  * If found, those virtio devices will be created and added, so as a result
1832  * of registering this remote processor, additional virtio drivers might be
1833  * probed.
1834  */
1835 int rproc_add(struct rproc *rproc)
1836 {
1837         struct device *dev = &rproc->dev;
1838         int ret;
1839
1840         ret = device_add(dev);
1841         if (ret < 0)
1842                 return ret;
1843
1844         dev_info(dev, "%s is available\n", rproc->name);
1845
1846         /* create debugfs entries */
1847         rproc_create_debug_dir(rproc);
1848
1849         /* if rproc is marked always-on, request it to boot */
1850         if (rproc->auto_boot) {
1851                 ret = rproc_trigger_auto_boot(rproc);
1852                 if (ret < 0)
1853                         return ret;
1854         }
1855
1856         /* expose to rproc_get_by_phandle users */
1857         mutex_lock(&rproc_list_mutex);
1858         list_add(&rproc->node, &rproc_list);
1859         mutex_unlock(&rproc_list_mutex);
1860
1861         return 0;
1862 }
1863 EXPORT_SYMBOL(rproc_add);
1864
1865 /**
1866  * rproc_type_release() - release a remote processor instance
1867  * @dev: the rproc's device
1868  *
1869  * This function should _never_ be called directly.
1870  *
1871  * It will be called by the driver core when no one holds a valid pointer
1872  * to @dev anymore.
1873  */
1874 static void rproc_type_release(struct device *dev)
1875 {
1876         struct rproc *rproc = container_of(dev, struct rproc, dev);
1877
1878         dev_info(&rproc->dev, "releasing %s\n", rproc->name);
1879
1880         idr_destroy(&rproc->notifyids);
1881
1882         if (rproc->index >= 0)
1883                 ida_simple_remove(&rproc_dev_index, rproc->index);
1884
1885         kfree(rproc->firmware);
1886         kfree(rproc->ops);
1887         kfree(rproc);
1888 }
1889
1890 static const struct device_type rproc_type = {
1891         .name           = "remoteproc",
1892         .release        = rproc_type_release,
1893 };
1894
1895 /**
1896  * rproc_alloc() - allocate a remote processor handle
1897  * @dev: the underlying device
1898  * @name: name of this remote processor
1899  * @ops: platform-specific handlers (mainly start/stop)
1900  * @firmware: name of firmware file to load, can be NULL
1901  * @len: length of private data needed by the rproc driver (in bytes)
1902  *
1903  * Allocates a new remote processor handle, but does not register
1904  * it yet. if @firmware is NULL, a default name is used.
1905  *
1906  * This function should be used by rproc implementations during initialization
1907  * of the remote processor.
1908  *
1909  * After creating an rproc handle using this function, and when ready,
1910  * implementations should then call rproc_add() to complete
1911  * the registration of the remote processor.
1912  *
1913  * On success the new rproc is returned, and on failure, NULL.
1914  *
1915  * Note: _never_ directly deallocate @rproc, even if it was not registered
1916  * yet. Instead, when you need to unroll rproc_alloc(), use rproc_free().
1917  */
1918 struct rproc *rproc_alloc(struct device *dev, const char *name,
1919                           const struct rproc_ops *ops,
1920                           const char *firmware, int len)
1921 {
1922         struct rproc *rproc;
1923         char *p, *template = "rproc-%s-fw";
1924         int name_len;
1925
1926         if (!dev || !name || !ops)
1927                 return NULL;
1928
1929         if (!firmware) {
1930                 /*
1931                  * If the caller didn't pass in a firmware name then
1932                  * construct a default name.
1933                  */
1934                 name_len = strlen(name) + strlen(template) - 2 + 1;
1935                 p = kmalloc(name_len, GFP_KERNEL);
1936                 if (!p)
1937                         return NULL;
1938                 snprintf(p, name_len, template, name);
1939         } else {
1940                 p = kstrdup(firmware, GFP_KERNEL);
1941                 if (!p)
1942                         return NULL;
1943         }
1944
1945         rproc = kzalloc(sizeof(struct rproc) + len, GFP_KERNEL);
1946         if (!rproc) {
1947                 kfree(p);
1948                 return NULL;
1949         }
1950
1951         rproc->ops = kmemdup(ops, sizeof(*ops), GFP_KERNEL);
1952         if (!rproc->ops) {
1953                 kfree(p);
1954                 kfree(rproc);
1955                 return NULL;
1956         }
1957
1958         rproc->firmware = p;
1959         rproc->name = name;
1960         rproc->priv = &rproc[1];
1961         rproc->auto_boot = true;
1962
1963         device_initialize(&rproc->dev);
1964         rproc->dev.parent = dev;
1965         rproc->dev.type = &rproc_type;
1966         rproc->dev.class = &rproc_class;
1967         rproc->dev.driver_data = rproc;
1968
1969         /* Assign a unique device index and name */
1970         rproc->index = ida_simple_get(&rproc_dev_index, 0, 0, GFP_KERNEL);
1971         if (rproc->index < 0) {
1972                 dev_err(dev, "ida_simple_get failed: %d\n", rproc->index);
1973                 put_device(&rproc->dev);
1974                 return NULL;
1975         }
1976
1977         dev_set_name(&rproc->dev, "remoteproc%d", rproc->index);
1978
1979         atomic_set(&rproc->power, 0);
1980
1981         /* Default to ELF loader if no load function is specified */
1982         if (!rproc->ops->load) {
1983                 rproc->ops->load = rproc_elf_load_segments;
1984                 rproc->ops->parse_fw = rproc_elf_load_rsc_table;
1985                 rproc->ops->find_loaded_rsc_table = rproc_elf_find_loaded_rsc_table;
1986                 rproc->ops->sanity_check = rproc_elf_sanity_check;
1987                 rproc->ops->get_boot_addr = rproc_elf_get_boot_addr;
1988         }
1989
1990         mutex_init(&rproc->lock);
1991
1992         idr_init(&rproc->notifyids);
1993
1994         INIT_LIST_HEAD(&rproc->carveouts);
1995         INIT_LIST_HEAD(&rproc->mappings);
1996         INIT_LIST_HEAD(&rproc->traces);
1997         INIT_LIST_HEAD(&rproc->rvdevs);
1998         INIT_LIST_HEAD(&rproc->subdevs);
1999         INIT_LIST_HEAD(&rproc->dump_segments);
2000
2001         INIT_WORK(&rproc->crash_handler, rproc_crash_handler_work);
2002
2003         rproc->state = RPROC_OFFLINE;
2004
2005         return rproc;
2006 }
2007 EXPORT_SYMBOL(rproc_alloc);
2008
2009 /**
2010  * rproc_free() - unroll rproc_alloc()
2011  * @rproc: the remote processor handle
2012  *
2013  * This function decrements the rproc dev refcount.
2014  *
2015  * If no one holds any reference to rproc anymore, then its refcount would
2016  * now drop to zero, and it would be freed.
2017  */
2018 void rproc_free(struct rproc *rproc)
2019 {
2020         put_device(&rproc->dev);
2021 }
2022 EXPORT_SYMBOL(rproc_free);
2023
2024 /**
2025  * rproc_put() - release rproc reference
2026  * @rproc: the remote processor handle
2027  *
2028  * This function decrements the rproc dev refcount.
2029  *
2030  * If no one holds any reference to rproc anymore, then its refcount would
2031  * now drop to zero, and it would be freed.
2032  */
2033 void rproc_put(struct rproc *rproc)
2034 {
2035         module_put(rproc->dev.parent->driver->owner);
2036         put_device(&rproc->dev);
2037 }
2038 EXPORT_SYMBOL(rproc_put);
2039
2040 /**
2041  * rproc_del() - unregister a remote processor
2042  * @rproc: rproc handle to unregister
2043  *
2044  * This function should be called when the platform specific rproc
2045  * implementation decides to remove the rproc device. it should
2046  * _only_ be called if a previous invocation of rproc_add()
2047  * has completed successfully.
2048  *
2049  * After rproc_del() returns, @rproc isn't freed yet, because
2050  * of the outstanding reference created by rproc_alloc. To decrement that
2051  * one last refcount, one still needs to call rproc_free().
2052  *
2053  * Returns 0 on success and -EINVAL if @rproc isn't valid.
2054  */
2055 int rproc_del(struct rproc *rproc)
2056 {
2057         if (!rproc)
2058                 return -EINVAL;
2059
2060         /* if rproc is marked always-on, rproc_add() booted it */
2061         /* TODO: make sure this works with rproc->power > 1 */
2062         if (rproc->auto_boot)
2063                 rproc_shutdown(rproc);
2064
2065         mutex_lock(&rproc->lock);
2066         rproc->state = RPROC_DELETED;
2067         mutex_unlock(&rproc->lock);
2068
2069         rproc_delete_debug_dir(rproc);
2070
2071         /* the rproc is downref'ed as soon as it's removed from the klist */
2072         mutex_lock(&rproc_list_mutex);
2073         list_del(&rproc->node);
2074         mutex_unlock(&rproc_list_mutex);
2075
2076         device_del(&rproc->dev);
2077
2078         return 0;
2079 }
2080 EXPORT_SYMBOL(rproc_del);
2081
2082 /**
2083  * rproc_add_subdev() - add a subdevice to a remoteproc
2084  * @rproc: rproc handle to add the subdevice to
2085  * @subdev: subdev handle to register
2086  *
2087  * Caller is responsible for populating optional subdevice function pointers.
2088  */
2089 void rproc_add_subdev(struct rproc *rproc, struct rproc_subdev *subdev)
2090 {
2091         list_add_tail(&subdev->node, &rproc->subdevs);
2092 }
2093 EXPORT_SYMBOL(rproc_add_subdev);
2094
2095 /**
2096  * rproc_remove_subdev() - remove a subdevice from a remoteproc
2097  * @rproc: rproc handle to remove the subdevice from
2098  * @subdev: subdev handle, previously registered with rproc_add_subdev()
2099  */
2100 void rproc_remove_subdev(struct rproc *rproc, struct rproc_subdev *subdev)
2101 {
2102         list_del(&subdev->node);
2103 }
2104 EXPORT_SYMBOL(rproc_remove_subdev);
2105
2106 /**
2107  * rproc_get_by_child() - acquire rproc handle of @dev's ancestor
2108  * @dev:        child device to find ancestor of
2109  *
2110  * Returns the ancestor rproc instance, or NULL if not found.
2111  */
2112 struct rproc *rproc_get_by_child(struct device *dev)
2113 {
2114         for (dev = dev->parent; dev; dev = dev->parent) {
2115                 if (dev->type == &rproc_type)
2116                         return dev->driver_data;
2117         }
2118
2119         return NULL;
2120 }
2121 EXPORT_SYMBOL(rproc_get_by_child);
2122
2123 /**
2124  * rproc_report_crash() - rproc crash reporter function
2125  * @rproc: remote processor
2126  * @type: crash type
2127  *
2128  * This function must be called every time a crash is detected by the low-level
2129  * drivers implementing a specific remoteproc. This should not be called from a
2130  * non-remoteproc driver.
2131  *
2132  * This function can be called from atomic/interrupt context.
2133  */
2134 void rproc_report_crash(struct rproc *rproc, enum rproc_crash_type type)
2135 {
2136         if (!rproc) {
2137                 pr_err("NULL rproc pointer\n");
2138                 return;
2139         }
2140
2141         dev_err(&rproc->dev, "crash detected in %s: type %s\n",
2142                 rproc->name, rproc_crash_to_string(type));
2143
2144         /* create a new task to handle the error */
2145         schedule_work(&rproc->crash_handler);
2146 }
2147 EXPORT_SYMBOL(rproc_report_crash);
2148
2149 static int __init remoteproc_init(void)
2150 {
2151         rproc_init_sysfs();
2152         rproc_init_debugfs();
2153
2154         return 0;
2155 }
2156 module_init(remoteproc_init);
2157
2158 static void __exit remoteproc_exit(void)
2159 {
2160         ida_destroy(&rproc_dev_index);
2161
2162         rproc_exit_debugfs();
2163         rproc_exit_sysfs();
2164 }
2165 module_exit(remoteproc_exit);
2166
2167 MODULE_LICENSE("GPL v2");
2168 MODULE_DESCRIPTION("Generic Remote Processor Framework");