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