apps: machine: zynqmp_r5: correct IPI setting.
[processor-sdk/open-amp.git] / lib / remoteproc / rsc_table_parser.c
1 /*
2  * Copyright (c) 2014, Mentor Graphics Corporation
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are met:
7  *
8  * 1. Redistributions of source code must retain the above copyright notice,
9  *    this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright notice,
11  *    this list of conditions and the following disclaimer in the documentation
12  *    and/or other materials provided with the distribution.
13  * 3. Neither the name of Mentor Graphics Corporation nor the names of its
14  *    contributors may be used to endorse or promote products derived from this
15  *    software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
18  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
21  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
25  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27  * POSSIBILITY OF SUCH DAMAGE.
28  */
30 #include "openamp/rsc_table_parser.h"
31 #include "metal/io.h"
33 /* Resources handler */
34 rsc_handler rsc_handler_table[] = {
35         handle_carve_out_rsc,
36         handle_dev_mem_rsc,
37         handle_trace_rsc,
38         handle_vdev_rsc,
39         handle_rproc_mem_rsc,
40         handle_fw_chksum_rsc,
41         handle_mmu_rsc
42 };
44 /**
45  * handle_rsc_table
46  *
47  * This function parses resource table.
48  *
49  * @param rproc     - pointer to remote remote_proc
50  * @param rsc_table - resource table to parse
51  * @param size      -  size of rsc table
52  *
53  * @returns - execution status
54  *
55  */
56 int handle_rsc_table(struct remote_proc *rproc,
57                      struct resource_table *rsc_table, int size)
58 {
60         unsigned char *rsc_start;
61         unsigned int *rsc_offset;
62         unsigned int rsc_type;
63         unsigned int idx;
64         int status = 0;
66         /* Validate rsc table header fields */
68         /* Minimum rsc table size */
69         if (sizeof(struct resource_table) > (unsigned int)size) {
70                 return (RPROC_ERR_RSC_TAB_TRUNC);
71         }
73         /* Supported version */
74         if (rsc_table->ver != RSC_TAB_SUPPORTED_VERSION) {
75                 return (RPROC_ERR_RSC_TAB_VER);
76         }
78         /* Offset array */
79         if (sizeof(struct resource_table)
80             + rsc_table->num * sizeof(rsc_table->offset[0]) > (unsigned int)size) {
81                 return (RPROC_ERR_RSC_TAB_TRUNC);
82         }
84         /* Reserved fields - must be zero */
85         if ((rsc_table->reserved[0] != 0 || rsc_table->reserved[1]) != 0) {
86                 return RPROC_ERR_RSC_TAB_RSVD;
87         }
89         rsc_start = (unsigned char *)rsc_table;
91         /* Loop through the offset array and parse each resource entry */
92         for (idx = 0; idx < rsc_table->num; idx++) {
93                 rsc_offset =
94                     (unsigned int *)(rsc_start + rsc_table->offset[idx]);
95                 rsc_type = *rsc_offset;
96                 status =
97                     rsc_handler_table[rsc_type] (rproc, (void *)rsc_offset);
98                 if (status != RPROC_SUCCESS) {
99                         break;
100                 }
101         }
103         return status;
106 /**
107  * handle_carve_out_rsc
108  *
109  * Carveout resource handler.
110  *
111  * @param rproc - pointer to remote remote_proc
112  * @param rsc   - pointer to carveout resource
113  *
114  * @returns - execution status
115  *
116  */
117 int handle_carve_out_rsc(struct remote_proc *rproc, void *rsc)
119         struct fw_rsc_carveout *carve_rsc = (struct fw_rsc_carveout *)rsc;
121         /* Validate resource fields */
122         if (!carve_rsc) {
123                 return RPROC_ERR_RSC_TAB_NP;
124         }
126         if (carve_rsc->reserved) {
127                 return RPROC_ERR_RSC_TAB_RSVD;
128         }
130         if (rproc->role == RPROC_MASTER) {
131                 /* Map memory region for loading the image */
132                 /* Use generic I/O region here. This is a temporary solution.
133                  * It will not work in Linux userspace. It is not decided if use
134                  * linux kernel remmoteproc to load the firmware or do it in user
135                  * space. */
136                 metal_phys_addr_t carve_out_generic_base_addr = 0;
137                 struct metal_io_region generic_io = {
138                         (void *)0,
139                         &carve_out_generic_base_addr,
140                         (size_t)-1,
141                         (sizeof(metal_phys_addr_t) << 3),
142                         (unsigned long)(-1),
143                         METAL_UNCACHED | METAL_SHARED_MEM,
144                         {NULL},
145                 };
146                 metal_io_mem_map((metal_phys_addr_t)carve_rsc->da,
147                         &generic_io, carve_rsc->len);
148         }
150         return RPROC_SUCCESS;
153 /**
154  * handle_trace_rsc
155  *
156  * Trace resource handler.
157  *
158  * @param rproc - pointer to remote remote_proc
159  * @param rsc   - pointer to trace resource
160  *
161  * @returns - execution status
162  *
163  */
164 int handle_trace_rsc(struct remote_proc *rproc, void *rsc)
166         (void)rproc;
167         (void)rsc;
169         return RPROC_ERR_RSC_TAB_NS;
172 /**
173  * handle_dev_mem_rsc
174  *
175  * Device memory resource handler.
176  *
177  * @param rproc - pointer to remote remote_proc
178  * @param rsc   - pointer to device memory resource
179  *
180  * @returns - execution status
181  *
182  */
183 int handle_dev_mem_rsc(struct remote_proc *rproc, void *rsc)
185         (void)rproc;
186         (void)rsc;
188         return RPROC_ERR_RSC_TAB_NS;
191 /**
192  * handle_vdev_rsc
193  *
194  * Virtio device resource handler
195  *
196  * @param rproc - pointer to remote remote_proc
197  * @param rsc   - pointer to virtio device resource
198  *
199  * @returns - execution status
200  *
201  */
202 int handle_vdev_rsc(struct remote_proc *rproc, void *rsc)
205         struct fw_rsc_vdev *vdev_rsc = (struct fw_rsc_vdev *)rsc;
206         struct proc_vdev *vdev;
208         if (!vdev_rsc) {
209                 return RPROC_ERR_RSC_TAB_NP;
210         }
212         /* Maximum supported vrings per Virtio device */
213         if (vdev_rsc->num_of_vrings > RSC_TAB_MAX_VRINGS) {
214                 return RPROC_ERR_RSC_TAB_VDEV_NRINGS;
215         }
217         /* Reserved fields - must be zero */
218         if (vdev_rsc->reserved[0] || vdev_rsc->reserved[1]) {
219                 return RPROC_ERR_RSC_TAB_RSVD;
220         }
222         /* Get the Virtio device from HIL proc */
223         vdev = hil_get_vdev_info(rproc->proc);
225         /* Initialize HIL Virtio device resources */
226         vdev->num_vrings = vdev_rsc->num_of_vrings;
227         vdev->dfeatures = vdev_rsc->dfeatures;
228         vdev->gfeatures = vdev_rsc->gfeatures;
229         vdev->vdev_info = vdev_rsc;
231         return RPROC_SUCCESS;
234 /**
235  * handle_rproc_mem_rsc
236  *
237  * This function parses rproc_mem resource.
238  * This is the resource for the remote processor
239  * to tell the host the memory can be used as
240  * shared memory.
241  *
242  * @param rproc - pointer to remote remote_proc
243  * @param rsc   - pointer to mmu resource
244  *
245  * @returns - execution status
246  *
247  */
248 int handle_rproc_mem_rsc(struct remote_proc *rproc, void *rsc)
250         (void)rproc;
251         (void)rsc;
253         /* TODO: the firmware side should handle this resource properly
254          * when it is the master or when it is the remote. */
255         return RPROC_SUCCESS;
258 /*
259  * handle_fw_chksum_rsc
260  *
261  * This function parses firmware checksum resource.
262  *
263  * @param rproc - pointer to remote remote_proc
264  * @param rsc   - pointer to mmu resource
265  *
266  * @returns - execution status
267  *
268  */
269 int handle_fw_chksum_rsc(struct remote_proc *rproc, void *rsc)
271         (void)rproc;
272         (void)rsc;
274         /* TODO: the firmware side should handle this resource properly
275          * when it is the master or when it is the remote. */
276         return RPROC_SUCCESS;
279 /**
280  * handle_mmu_rsc
281  *
282  * This function parses mmu resource , requested by the peripheral.
283  *
284  * @param rproc - pointer to remote remote_proc
285  * @param rsc   - pointer to mmu resource
286  *
287  * @returns - execution status
288  *
289  */
290 int handle_mmu_rsc(struct remote_proc *rproc, void *rsc)
292         (void)rproc;
293         (void)rsc;
295         return RPROC_ERR_RSC_TAB_NS;