plat/imx/common/sci/svc/rm/rm_rpc_clnt.c

   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
  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
  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
  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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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         return;
 637 }
 638
 639 /**@}*/