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