1 /*
2 * Copyright (c) 2015-2018, ARM Limited and Contributors. All rights reserved.
3 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 */
6
7 /*!
8 * File containing client-side RPC functions for the RM service. These
9 * functions are ported to clients that communicate to the SC.
10 *
11 * @addtogroup RM_SVC
12 * @{
13 */
14
15 /* Includes */
16
17 #include <stdlib.h>
18
19 #include <sci/sci_types.h>
20 #include <sci/svc/rm/sci_rm_api.h>
21 #include <sci/sci_rpc.h>
22
23 #include "sci_rm_rpc.h"
24
25 /* Local Defines */
26
27 /* Local Types */
28
29 /* Local Functions */
30
sc_rm_partition_alloc(sc_ipc_t ipc,sc_rm_pt_t * pt,sc_bool_t secure,sc_bool_t isolated,sc_bool_t restricted,sc_bool_t grant,sc_bool_t coherent)31 sc_err_t sc_rm_partition_alloc(sc_ipc_t ipc, sc_rm_pt_t *pt, sc_bool_t secure,
32 sc_bool_t isolated, sc_bool_t restricted,
33 sc_bool_t grant, sc_bool_t coherent)
34 {
35 sc_rpc_msg_t msg;
36 uint8_t result;
37
38 RPC_VER(&msg) = SC_RPC_VERSION;
39 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
40 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_PARTITION_ALLOC;
41 RPC_U8(&msg, 0U) = (uint8_t)secure;
42 RPC_U8(&msg, 1U) = (uint8_t)isolated;
43 RPC_U8(&msg, 2U) = (uint8_t)restricted;
44 RPC_U8(&msg, 3U) = (uint8_t)grant;
45 RPC_U8(&msg, 4U) = (uint8_t)coherent;
46 RPC_SIZE(&msg) = 3U;
47
48 sc_call_rpc(ipc, &msg, SC_FALSE);
49
50 result = RPC_R8(&msg);
51 if (pt != NULL) {
52 *pt = RPC_U8(&msg, 0U);
53 }
54
55 return (sc_err_t)result;
56 }
57
sc_rm_set_confidential(sc_ipc_t ipc,sc_rm_pt_t pt,sc_bool_t retro)58 sc_err_t sc_rm_set_confidential(sc_ipc_t ipc, sc_rm_pt_t pt, sc_bool_t retro)
59 {
60 sc_rpc_msg_t msg;
61 uint8_t result;
62
63 RPC_VER(&msg) = SC_RPC_VERSION;
64 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
65 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_SET_CONFIDENTIAL;
66 RPC_U8(&msg, 0U) = (uint8_t)pt;
67 RPC_U8(&msg, 1U) = (uint8_t)retro;
68 RPC_SIZE(&msg) = 2U;
69
70 sc_call_rpc(ipc, &msg, SC_FALSE);
71
72 result = RPC_R8(&msg);
73 return (sc_err_t)result;
74 }
75
sc_rm_partition_free(sc_ipc_t ipc,sc_rm_pt_t pt)76 sc_err_t sc_rm_partition_free(sc_ipc_t ipc, sc_rm_pt_t pt)
77 {
78 sc_rpc_msg_t msg;
79 uint8_t result;
80
81 RPC_VER(&msg) = SC_RPC_VERSION;
82 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
83 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_PARTITION_FREE;
84 RPC_U8(&msg, 0U) = (uint8_t)pt;
85 RPC_SIZE(&msg) = 2U;
86
87 sc_call_rpc(ipc, &msg, SC_FALSE);
88
89 result = RPC_R8(&msg);
90 return (sc_err_t)result;
91 }
92
sc_rm_get_did(sc_ipc_t ipc)93 sc_rm_did_t sc_rm_get_did(sc_ipc_t ipc)
94 {
95 sc_rpc_msg_t msg;
96 uint8_t result;
97
98 RPC_VER(&msg) = SC_RPC_VERSION;
99 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
100 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_GET_DID;
101 RPC_SIZE(&msg) = 1U;
102
103 sc_call_rpc(ipc, &msg, SC_FALSE);
104
105 result = RPC_R8(&msg);
106 return (sc_rm_did_t) result;
107 }
108
sc_rm_partition_static(sc_ipc_t ipc,sc_rm_pt_t pt,sc_rm_did_t did)109 sc_err_t sc_rm_partition_static(sc_ipc_t ipc, sc_rm_pt_t pt, sc_rm_did_t did)
110 {
111 sc_rpc_msg_t msg;
112 uint8_t result;
113
114 RPC_VER(&msg) = SC_RPC_VERSION;
115 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
116 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_PARTITION_STATIC;
117 RPC_U8(&msg, 0U) = (uint8_t)pt;
118 RPC_U8(&msg, 1U) = (uint8_t)did;
119 RPC_SIZE(&msg) = 2U;
120
121 sc_call_rpc(ipc, &msg, SC_FALSE);
122
123 result = RPC_R8(&msg);
124 return (sc_err_t)result;
125 }
126
sc_rm_partition_lock(sc_ipc_t ipc,sc_rm_pt_t pt)127 sc_err_t sc_rm_partition_lock(sc_ipc_t ipc, sc_rm_pt_t pt)
128 {
129 sc_rpc_msg_t msg;
130 uint8_t result;
131
132 RPC_VER(&msg) = SC_RPC_VERSION;
133 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
134 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_PARTITION_LOCK;
135 RPC_U8(&msg, 0U) = (uint8_t)pt;
136 RPC_SIZE(&msg) = 2U;
137
138 sc_call_rpc(ipc, &msg, SC_FALSE);
139
140 result = RPC_R8(&msg);
141 return (sc_err_t)result;
142 }
143
sc_rm_get_partition(sc_ipc_t ipc,sc_rm_pt_t * pt)144 sc_err_t sc_rm_get_partition(sc_ipc_t ipc, sc_rm_pt_t *pt)
145 {
146 sc_rpc_msg_t msg;
147 uint8_t result;
148
149 RPC_VER(&msg) = SC_RPC_VERSION;
150 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
151 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_GET_PARTITION;
152 RPC_SIZE(&msg) = 1U;
153
154 sc_call_rpc(ipc, &msg, SC_FALSE);
155
156 result = RPC_R8(&msg);
157 if (pt != NULL) {
158 *pt = RPC_U8(&msg, 0U);
159 }
160
161 return (sc_err_t)result;
162 }
163
sc_rm_set_parent(sc_ipc_t ipc,sc_rm_pt_t pt,sc_rm_pt_t pt_parent)164 sc_err_t sc_rm_set_parent(sc_ipc_t ipc, sc_rm_pt_t pt, sc_rm_pt_t pt_parent)
165 {
166 sc_rpc_msg_t msg;
167 uint8_t result;
168
169 RPC_VER(&msg) = SC_RPC_VERSION;
170 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
171 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_SET_PARENT;
172 RPC_U8(&msg, 0U) = (uint8_t)pt;
173 RPC_U8(&msg, 1U) = (uint8_t)pt_parent;
174 RPC_SIZE(&msg) = 2U;
175
176 sc_call_rpc(ipc, &msg, SC_FALSE);
177
178 result = RPC_R8(&msg);
179 return (sc_err_t)result;
180 }
181
sc_rm_move_all(sc_ipc_t ipc,sc_rm_pt_t pt_src,sc_rm_pt_t pt_dst,sc_bool_t move_rsrc,sc_bool_t move_pads)182 sc_err_t sc_rm_move_all(sc_ipc_t ipc, sc_rm_pt_t pt_src, sc_rm_pt_t pt_dst,
183 sc_bool_t move_rsrc, sc_bool_t move_pads)
184 {
185 sc_rpc_msg_t msg;
186 uint8_t result;
187
188 RPC_VER(&msg) = SC_RPC_VERSION;
189 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
190 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_MOVE_ALL;
191 RPC_U8(&msg, 0U) = (uint8_t)pt_src;
192 RPC_U8(&msg, 1U) = (uint8_t)pt_dst;
193 RPC_U8(&msg, 2U) = (uint8_t)move_rsrc;
194 RPC_U8(&msg, 3U) = (uint8_t)move_pads;
195 RPC_SIZE(&msg) = 2U;
196
197 sc_call_rpc(ipc, &msg, SC_FALSE);
198
199 result = RPC_R8(&msg);
200 return (sc_err_t)result;
201 }
202
sc_rm_assign_resource(sc_ipc_t ipc,sc_rm_pt_t pt,sc_rsrc_t resource)203 sc_err_t sc_rm_assign_resource(sc_ipc_t ipc, sc_rm_pt_t pt, sc_rsrc_t resource)
204 {
205 sc_rpc_msg_t msg;
206 uint8_t result;
207
208 RPC_VER(&msg) = SC_RPC_VERSION;
209 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
210 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_ASSIGN_RESOURCE;
211 RPC_U16(&msg, 0U) = (uint16_t)resource;
212 RPC_U8(&msg, 2U) = (uint8_t)pt;
213 RPC_SIZE(&msg) = 2U;
214
215 sc_call_rpc(ipc, &msg, SC_FALSE);
216
217 result = RPC_R8(&msg);
218 return (sc_err_t)result;
219 }
220
sc_rm_set_resource_movable(sc_ipc_t ipc,sc_rsrc_t resource_fst,sc_rsrc_t resource_lst,sc_bool_t movable)221 sc_err_t sc_rm_set_resource_movable(sc_ipc_t ipc, sc_rsrc_t resource_fst,
222 sc_rsrc_t resource_lst, sc_bool_t movable)
223 {
224 sc_rpc_msg_t msg;
225 uint8_t result;
226
227 RPC_VER(&msg) = SC_RPC_VERSION;
228 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
229 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_SET_RESOURCE_MOVABLE;
230 RPC_U16(&msg, 0U) = (uint16_t)resource_fst;
231 RPC_U16(&msg, 2U) = (uint16_t)resource_lst;
232 RPC_U8(&msg, 4U) = (uint8_t)movable;
233 RPC_SIZE(&msg) = 3U;
234
235 sc_call_rpc(ipc, &msg, SC_FALSE);
236
237 result = RPC_R8(&msg);
238 return (sc_err_t)result;
239 }
240
sc_rm_set_subsys_rsrc_movable(sc_ipc_t ipc,sc_rsrc_t resource,sc_bool_t movable)241 sc_err_t sc_rm_set_subsys_rsrc_movable(sc_ipc_t ipc, sc_rsrc_t resource,
242 sc_bool_t movable)
243 {
244 sc_rpc_msg_t msg;
245 uint8_t result;
246
247 RPC_VER(&msg) = SC_RPC_VERSION;
248 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
249 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_SET_SUBSYS_RSRC_MOVABLE;
250 RPC_U16(&msg, 0U) = (uint16_t)resource;
251 RPC_U8(&msg, 2U) = (uint8_t)movable;
252 RPC_SIZE(&msg) = 2U;
253
254 sc_call_rpc(ipc, &msg, SC_FALSE);
255
256 result = RPC_R8(&msg);
257 return (sc_err_t)result;
258 }
259
sc_rm_set_master_attributes(sc_ipc_t ipc,sc_rsrc_t resource,sc_rm_spa_t sa,sc_rm_spa_t pa,sc_bool_t smmu_bypass)260 sc_err_t sc_rm_set_master_attributes(sc_ipc_t ipc, sc_rsrc_t resource,
261 sc_rm_spa_t sa, sc_rm_spa_t pa,
262 sc_bool_t smmu_bypass)
263 {
264 sc_rpc_msg_t msg;
265 uint8_t result;
266
267 RPC_VER(&msg) = SC_RPC_VERSION;
268 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
269 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_SET_MASTER_ATTRIBUTES;
270 RPC_U16(&msg, 0U) = (uint16_t)resource;
271 RPC_U8(&msg, 2U) = (uint8_t)sa;
272 RPC_U8(&msg, 3U) = (uint8_t)pa;
273 RPC_U8(&msg, 4U) = (uint8_t)smmu_bypass;
274 RPC_SIZE(&msg) = 3U;
275
276 sc_call_rpc(ipc, &msg, SC_FALSE);
277
278 result = RPC_R8(&msg);
279 return (sc_err_t)result;
280 }
281
sc_rm_set_master_sid(sc_ipc_t ipc,sc_rsrc_t resource,sc_rm_sid_t sid)282 sc_err_t sc_rm_set_master_sid(sc_ipc_t ipc, sc_rsrc_t resource, sc_rm_sid_t sid)
283 {
284 sc_rpc_msg_t msg;
285 uint8_t result;
286
287 RPC_VER(&msg) = SC_RPC_VERSION;
288 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
289 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_SET_MASTER_SID;
290 RPC_U16(&msg, 0U) = (uint16_t)resource;
291 RPC_U16(&msg, 2U) = (uint16_t)sid;
292 RPC_SIZE(&msg) = 2U;
293
294 sc_call_rpc(ipc, &msg, SC_FALSE);
295
296 result = RPC_R8(&msg);
297 return (sc_err_t)result;
298 }
299
sc_rm_set_peripheral_permissions(sc_ipc_t ipc,sc_rsrc_t resource,sc_rm_pt_t pt,sc_rm_perm_t perm)300 sc_err_t sc_rm_set_peripheral_permissions(sc_ipc_t ipc, sc_rsrc_t resource,
301 sc_rm_pt_t pt, sc_rm_perm_t perm)
302 {
303 sc_rpc_msg_t msg;
304 uint8_t result;
305
306 RPC_VER(&msg) = SC_RPC_VERSION;
307 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
308 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_SET_PERIPHERAL_PERMISSIONS;
309 RPC_U16(&msg, 0U) = (uint16_t)resource;
310 RPC_U8(&msg, 2U) = (uint8_t)pt;
311 RPC_U8(&msg, 3U) = (uint8_t)perm;
312 RPC_SIZE(&msg) = 2U;
313
314 sc_call_rpc(ipc, &msg, SC_FALSE);
315
316 result = RPC_R8(&msg);
317 return (sc_err_t)result;
318 }
319
sc_rm_is_resource_owned(sc_ipc_t ipc,sc_rsrc_t resource)320 sc_bool_t sc_rm_is_resource_owned(sc_ipc_t ipc, sc_rsrc_t resource)
321 {
322 sc_rpc_msg_t msg;
323 uint8_t result;
324
325 RPC_VER(&msg) = SC_RPC_VERSION;
326 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
327 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_IS_RESOURCE_OWNED;
328 RPC_U16(&msg, 0U) = (uint16_t)resource;
329 RPC_SIZE(&msg) = 2U;
330
331 sc_call_rpc(ipc, &msg, SC_FALSE);
332
333 result = RPC_R8(&msg);
334 return (sc_bool_t)result;
335 }
336
sc_rm_is_resource_master(sc_ipc_t ipc,sc_rsrc_t resource)337 sc_bool_t sc_rm_is_resource_master(sc_ipc_t ipc, sc_rsrc_t resource)
338 {
339 sc_rpc_msg_t msg;
340 uint8_t result;
341
342 RPC_VER(&msg) = SC_RPC_VERSION;
343 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
344 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_IS_RESOURCE_MASTER;
345 RPC_U16(&msg, 0U) = (uint16_t)resource;
346 RPC_SIZE(&msg) = 2U;
347
348 sc_call_rpc(ipc, &msg, SC_FALSE);
349
350 result = RPC_R8(&msg);
351 return (sc_bool_t)result;
352 }
353
sc_rm_is_resource_peripheral(sc_ipc_t ipc,sc_rsrc_t resource)354 sc_bool_t sc_rm_is_resource_peripheral(sc_ipc_t ipc, sc_rsrc_t resource)
355 {
356 sc_rpc_msg_t msg;
357 uint8_t result;
358
359 RPC_VER(&msg) = SC_RPC_VERSION;
360 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
361 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_IS_RESOURCE_PERIPHERAL;
362 RPC_U16(&msg, 0U) = (uint16_t)resource;
363 RPC_SIZE(&msg) = 2U;
364
365 sc_call_rpc(ipc, &msg, SC_FALSE);
366
367 result = RPC_R8(&msg);
368 return (sc_bool_t)result;
369 }
370
sc_rm_get_resource_info(sc_ipc_t ipc,sc_rsrc_t resource,sc_rm_sid_t * sid)371 sc_err_t sc_rm_get_resource_info(sc_ipc_t ipc, sc_rsrc_t resource,
372 sc_rm_sid_t *sid)
373 {
374 sc_rpc_msg_t msg;
375 uint8_t result;
376
377 RPC_VER(&msg) = SC_RPC_VERSION;
378 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
379 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_GET_RESOURCE_INFO;
380 RPC_U16(&msg, 0U) = (uint16_t)resource;
381 RPC_SIZE(&msg) = 2U;
382
383 sc_call_rpc(ipc, &msg, SC_FALSE);
384
385 if (sid != NULL) {
386 *sid = RPC_U16(&msg, 0U);
387 }
388
389 result = RPC_R8(&msg);
390 return (sc_err_t)result;
391 }
392
sc_rm_memreg_alloc(sc_ipc_t ipc,sc_rm_mr_t * mr,sc_faddr_t addr_start,sc_faddr_t addr_end)393 sc_err_t sc_rm_memreg_alloc(sc_ipc_t ipc, sc_rm_mr_t *mr,
394 sc_faddr_t addr_start, sc_faddr_t addr_end)
395 {
396 sc_rpc_msg_t msg;
397 uint8_t result;
398
399 RPC_VER(&msg) = SC_RPC_VERSION;
400 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
401 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_MEMREG_ALLOC;
402 RPC_U32(&msg, 0U) = (uint32_t)(addr_start >> 32U);
403 RPC_U32(&msg, 4U) = (uint32_t)addr_start;
404 RPC_U32(&msg, 8U) = (uint32_t)(addr_end >> 32U);
405 RPC_U32(&msg, 12U) = (uint32_t)addr_end;
406 RPC_SIZE(&msg) = 5U;
407
408 sc_call_rpc(ipc, &msg, SC_FALSE);
409
410 result = RPC_R8(&msg);
411 if (mr != NULL) {
412 *mr = RPC_U8(&msg, 0U);
413 }
414
415 return (sc_err_t)result;
416 }
417
sc_rm_memreg_split(sc_ipc_t ipc,sc_rm_mr_t mr,sc_rm_mr_t * mr_ret,sc_faddr_t addr_start,sc_faddr_t addr_end)418 sc_err_t sc_rm_memreg_split(sc_ipc_t ipc, sc_rm_mr_t mr,
419 sc_rm_mr_t *mr_ret, sc_faddr_t addr_start,
420 sc_faddr_t addr_end)
421 {
422 sc_rpc_msg_t msg;
423 uint8_t result;
424
425 RPC_VER(&msg) = SC_RPC_VERSION;
426 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
427 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_MEMREG_SPLIT;
428 RPC_U32(&msg, 0U) = (uint32_t)(addr_start >> 32U);
429 RPC_U32(&msg, 4U) = (uint32_t)addr_start;
430 RPC_U32(&msg, 8U) = (uint32_t)(addr_end >> 32U);
431 RPC_U32(&msg, 12U) = (uint32_t)addr_end;
432 RPC_U8(&msg, 16U) = (uint8_t)mr;
433 RPC_SIZE(&msg) = 6U;
434
435 sc_call_rpc(ipc, &msg, SC_FALSE);
436
437 result = RPC_R8(&msg);
438 if (mr_ret != NULL) {
439 *mr_ret = RPC_U8(&msg, 0U);
440 }
441
442 return (sc_err_t)result;
443 }
444
sc_rm_memreg_free(sc_ipc_t ipc,sc_rm_mr_t mr)445 sc_err_t sc_rm_memreg_free(sc_ipc_t ipc, sc_rm_mr_t mr)
446 {
447 sc_rpc_msg_t msg;
448 uint8_t result;
449
450 RPC_VER(&msg) = SC_RPC_VERSION;
451 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
452 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_MEMREG_FREE;
453 RPC_U8(&msg, 0U) = (uint8_t)mr;
454 RPC_SIZE(&msg) = 2U;
455
456 sc_call_rpc(ipc, &msg, SC_FALSE);
457
458 result = RPC_R8(&msg);
459 return (sc_err_t)result;
460 }
461
sc_rm_find_memreg(sc_ipc_t ipc,sc_rm_mr_t * mr,sc_faddr_t addr_start,sc_faddr_t addr_end)462 sc_err_t sc_rm_find_memreg(sc_ipc_t ipc, sc_rm_mr_t *mr,
463 sc_faddr_t addr_start, sc_faddr_t addr_end)
464 {
465 sc_rpc_msg_t msg;
466 uint8_t result;
467
468 RPC_VER(&msg) = SC_RPC_VERSION;
469 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
470 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_FIND_MEMREG;
471 RPC_U32(&msg, 0U) = (uint32_t)(addr_start >> 32U);
472 RPC_U32(&msg, 4U) = (uint32_t)addr_start;
473 RPC_U32(&msg, 8U) = (uint32_t)(addr_end >> 32U);
474 RPC_U32(&msg, 12U) = (uint32_t)addr_end;
475 RPC_SIZE(&msg) = 5U;
476
477 sc_call_rpc(ipc, &msg, SC_FALSE);
478
479 result = RPC_R8(&msg);
480 if (mr != NULL) {
481 *mr = RPC_U8(&msg, 0U);
482 }
483
484 return (sc_err_t)result;
485 }
486
sc_rm_assign_memreg(sc_ipc_t ipc,sc_rm_pt_t pt,sc_rm_mr_t mr)487 sc_err_t sc_rm_assign_memreg(sc_ipc_t ipc, sc_rm_pt_t pt, sc_rm_mr_t mr)
488 {
489 sc_rpc_msg_t msg;
490 uint8_t result;
491
492 RPC_VER(&msg) = SC_RPC_VERSION;
493 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
494 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_ASSIGN_MEMREG;
495 RPC_U8(&msg, 0U) = (uint8_t)pt;
496 RPC_U8(&msg, 1U) = (uint8_t)mr;
497 RPC_SIZE(&msg) = 2U;
498
499 sc_call_rpc(ipc, &msg, SC_FALSE);
500
501 result = RPC_R8(&msg);
502 return (sc_err_t)result;
503 }
504
sc_rm_set_memreg_permissions(sc_ipc_t ipc,sc_rm_mr_t mr,sc_rm_pt_t pt,sc_rm_perm_t perm)505 sc_err_t sc_rm_set_memreg_permissions(sc_ipc_t ipc, sc_rm_mr_t mr,
506 sc_rm_pt_t pt, sc_rm_perm_t perm)
507 {
508 sc_rpc_msg_t msg;
509 uint8_t result;
510
511 RPC_VER(&msg) = SC_RPC_VERSION;
512 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
513 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_SET_MEMREG_PERMISSIONS;
514 RPC_U8(&msg, 0U) = (uint8_t)mr;
515 RPC_U8(&msg, 1U) = (uint8_t)pt;
516 RPC_U8(&msg, 2U) = (uint8_t)perm;
517 RPC_SIZE(&msg) = 2U;
518
519 sc_call_rpc(ipc, &msg, SC_FALSE);
520
521 result = RPC_R8(&msg);
522 return (sc_err_t)result;
523 }
524
sc_rm_is_memreg_owned(sc_ipc_t ipc,sc_rm_mr_t mr)525 sc_bool_t sc_rm_is_memreg_owned(sc_ipc_t ipc, sc_rm_mr_t mr)
526 {
527 sc_rpc_msg_t msg;
528 uint8_t result;
529
530 RPC_VER(&msg) = SC_RPC_VERSION;
531 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
532 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_IS_MEMREG_OWNED;
533 RPC_U8(&msg, 0U) = (uint8_t)mr;
534 RPC_SIZE(&msg) = 2U;
535
536 sc_call_rpc(ipc, &msg, SC_FALSE);
537
538 result = RPC_R8(&msg);
539 return (sc_bool_t)result;
540 }
541
sc_rm_get_memreg_info(sc_ipc_t ipc,sc_rm_mr_t mr,sc_faddr_t * addr_start,sc_faddr_t * addr_end)542 sc_err_t sc_rm_get_memreg_info(sc_ipc_t ipc, sc_rm_mr_t mr,
543 sc_faddr_t *addr_start, sc_faddr_t *addr_end)
544 {
545 sc_rpc_msg_t msg;
546 uint8_t result;
547
548 RPC_VER(&msg) = SC_RPC_VERSION;
549 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
550 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_GET_MEMREG_INFO;
551 RPC_U8(&msg, 0U) = (uint8_t)mr;
552 RPC_SIZE(&msg) = 2U;
553
554 sc_call_rpc(ipc, &msg, SC_FALSE);
555
556 if (addr_start != NULL) {
557 *addr_start =
558 ((uint64_t) RPC_U32(&msg, 0U) << 32U) | RPC_U32(&msg, 4U);
559 }
560
561 if (addr_end != NULL) {
562 *addr_end =
563 ((uint64_t) RPC_U32(&msg, 8U) << 32U) | RPC_U32(&msg, 12U);
564 }
565
566 result = RPC_R8(&msg);
567 return (sc_err_t)result;
568 }
569
sc_rm_assign_pad(sc_ipc_t ipc,sc_rm_pt_t pt,sc_pad_t pad)570 sc_err_t sc_rm_assign_pad(sc_ipc_t ipc, sc_rm_pt_t pt, sc_pad_t pad)
571 {
572 sc_rpc_msg_t msg;
573 uint8_t result;
574
575 RPC_VER(&msg) = SC_RPC_VERSION;
576 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
577 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_ASSIGN_PAD;
578 RPC_U16(&msg, 0U) = (uint16_t)pad;
579 RPC_U8(&msg, 2U) = (uint8_t)pt;
580 RPC_SIZE(&msg) = 2U;
581
582 sc_call_rpc(ipc, &msg, SC_FALSE);
583
584 result = RPC_R8(&msg);
585 return (sc_err_t)result;
586 }
587
sc_rm_set_pad_movable(sc_ipc_t ipc,sc_pad_t pad_fst,sc_pad_t pad_lst,sc_bool_t movable)588 sc_err_t sc_rm_set_pad_movable(sc_ipc_t ipc, sc_pad_t pad_fst,
589 sc_pad_t pad_lst, sc_bool_t movable)
590 {
591 sc_rpc_msg_t msg;
592 uint8_t result;
593
594 RPC_VER(&msg) = SC_RPC_VERSION;
595 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
596 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_SET_PAD_MOVABLE;
597 RPC_U16(&msg, 0U) = (uint16_t)pad_fst;
598 RPC_U16(&msg, 2U) = (uint16_t)pad_lst;
599 RPC_U8(&msg, 4U) = (uint8_t)movable;
600 RPC_SIZE(&msg) = 3U;
601
602 sc_call_rpc(ipc, &msg, SC_FALSE);
603
604 result = RPC_R8(&msg);
605 return (sc_err_t)result;
606 }
607
sc_rm_is_pad_owned(sc_ipc_t ipc,sc_pad_t pad)608 sc_bool_t sc_rm_is_pad_owned(sc_ipc_t ipc, sc_pad_t pad)
609 {
610 sc_rpc_msg_t msg;
611 uint8_t result;
612
613 RPC_VER(&msg) = SC_RPC_VERSION;
614 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
615 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_IS_PAD_OWNED;
616 RPC_U8(&msg, 0U) = (uint8_t)pad;
617 RPC_SIZE(&msg) = 2U;
618
619 sc_call_rpc(ipc, &msg, SC_FALSE);
620
621 result = RPC_R8(&msg);
622 return (sc_bool_t)result;
623 }
624
sc_rm_dump(sc_ipc_t ipc)625 void sc_rm_dump(sc_ipc_t ipc)
626 {
627 sc_rpc_msg_t msg;
628
629 RPC_VER(&msg) = SC_RPC_VERSION;
630 RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
631 RPC_FUNC(&msg) = (uint8_t)RM_FUNC_DUMP;
632 RPC_SIZE(&msg) = 1U;
633
634 sc_call_rpc(ipc, &msg, SC_FALSE);
635 }
636
637 /**@}*/
638
