1 // SPDX-License-Identifier: GPL-2.0
5 * Peng Fan <peng.fan@nxp.com>
13 #include <asm/arch/sci/sci.h>
16 DECLARE_GLOBAL_DATA_PTR;
18 #define B2U8(X) (((X) != SC_FALSE) ? (u8)(0x01U) : (u8)(0x00U))
21 int sc_pm_set_clock_rate(sc_ipc_t ipc, sc_rsrc_t resource, sc_pm_clk_t clk,
22 sc_pm_clock_rate_t *rate)
24 struct udevice *dev = gd->arch.scu_dev;
25 int size = sizeof(struct sc_rpc_msg_s);
26 struct sc_rpc_msg_s msg;
29 RPC_VER(&msg) = SC_RPC_VERSION;
30 RPC_SVC(&msg) = (u8)SC_RPC_SVC_PM;
31 RPC_FUNC(&msg) = (u8)PM_FUNC_SET_CLOCK_RATE;
32 RPC_U32(&msg, 0U) = *(u32 *)rate;
33 RPC_U16(&msg, 4U) = (u16)resource;
34 RPC_U8(&msg, 6U) = (u8)clk;
37 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
39 printf("%s: rate:%u resource:%u: clk:%u res:%d\n",
40 __func__, *rate, resource, clk, RPC_R8(&msg));
42 *rate = RPC_U32(&msg, 0U);
47 int sc_pm_get_clock_rate(sc_ipc_t ipc, sc_rsrc_t resource, sc_pm_clk_t clk,
48 sc_pm_clock_rate_t *rate)
50 struct udevice *dev = gd->arch.scu_dev;
51 int size = sizeof(struct sc_rpc_msg_s);
52 struct sc_rpc_msg_s msg;
55 RPC_VER(&msg) = SC_RPC_VERSION;
56 RPC_SVC(&msg) = (u8)SC_RPC_SVC_PM;
57 RPC_FUNC(&msg) = (u8)PM_FUNC_GET_CLOCK_RATE;
58 RPC_U16(&msg, 0U) = (u16)resource;
59 RPC_U8(&msg, 2U) = (u8)clk;
62 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
64 printf("%s: resource:%d clk:%d: res:%d\n",
65 __func__, resource, clk, RPC_R8(&msg));
70 *rate = RPC_U32(&msg, 0U);
75 int sc_pm_clock_enable(sc_ipc_t ipc, sc_rsrc_t resource, sc_pm_clk_t clk,
76 sc_bool_t enable, sc_bool_t autog)
78 struct udevice *dev = gd->arch.scu_dev;
79 int size = sizeof(struct sc_rpc_msg_s);
80 struct sc_rpc_msg_s msg;
83 RPC_VER(&msg) = SC_RPC_VERSION;
84 RPC_SVC(&msg) = (u8)SC_RPC_SVC_PM;
85 RPC_FUNC(&msg) = (u8)PM_FUNC_CLOCK_ENABLE;
86 RPC_U16(&msg, 0U) = (u16)resource;
87 RPC_U8(&msg, 2U) = (u8)clk;
88 RPC_U8(&msg, 3U) = (u8)enable;
89 RPC_U8(&msg, 4U) = (u8)autog;
92 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
94 printf("%s: resource:%d clk:%d: enable:%d autog: %d, res:%d\n",
95 __func__, resource, clk, enable, autog, RPC_R8(&msg));
100 int sc_pm_set_clock_parent(sc_ipc_t ipc, sc_rsrc_t resource,
101 sc_pm_clk_t clk, sc_pm_clk_parent_t parent)
103 struct udevice *dev = gd->arch.scu_dev;
104 int size = sizeof(struct sc_rpc_msg_s);
105 struct sc_rpc_msg_s msg;
108 RPC_VER(&msg) = SC_RPC_VERSION;
109 RPC_SVC(&msg) = (u8)SC_RPC_SVC_PM;
110 RPC_FUNC(&msg) = (u8)PM_FUNC_SET_CLOCK_PARENT;
111 RPC_U16(&msg, 0U) = (u16)resource;
112 RPC_U8(&msg, 2U) = (u8)clk;
113 RPC_U8(&msg, 3U) = (u8)parent;
116 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
118 printf("%s: resource:%d clk:%d: parent clk: %d, res:%d\n",
119 __func__, resource, clk, parent, RPC_R8(&msg));
124 int sc_pm_set_resource_power_mode(sc_ipc_t ipc, sc_rsrc_t resource,
125 sc_pm_power_mode_t mode)
127 struct udevice *dev = gd->arch.scu_dev;
128 int size = sizeof(struct sc_rpc_msg_s);
129 struct sc_rpc_msg_s msg;
135 RPC_VER(&msg) = SC_RPC_VERSION;
136 RPC_SVC(&msg) = (u8)SC_RPC_SVC_PM;
137 RPC_FUNC(&msg) = (u8)PM_FUNC_SET_RESOURCE_POWER_MODE;
138 RPC_U16(&msg, 0U) = (u16)resource;
139 RPC_U8(&msg, 2U) = (u8)mode;
142 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
144 printf("%s: resource:%d mode:%d: res:%d\n",
145 __func__, resource, mode, RPC_R8(&msg));
150 sc_bool_t sc_pm_is_partition_started(sc_ipc_t ipc, sc_rm_pt_t pt)
152 struct udevice *dev = gd->arch.scu_dev;
153 int size = sizeof(struct sc_rpc_msg_s);
154 struct sc_rpc_msg_s msg;
158 RPC_VER(&msg) = SC_RPC_VERSION;
159 RPC_SVC(&msg) = (u8)(SC_RPC_SVC_PM);
160 RPC_FUNC(&msg) = (u8)(PM_FUNC_IS_PARTITION_STARTED);
161 RPC_U8(&msg, 0U) = (u8)(pt);
164 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
166 result = RPC_R8(&msg);
167 if (result != 0 && result != 1) {
168 printf("%s: partition:%d res:%d\n",
169 __func__, pt, RPC_R8(&msg));
171 printf("%s: partition:%d res:%d\n", __func__, pt,
178 int sc_pad_set(sc_ipc_t ipc, sc_pad_t pad, u32 val)
180 struct udevice *dev = gd->arch.scu_dev;
181 int size = sizeof(struct sc_rpc_msg_s);
182 struct sc_rpc_msg_s msg;
188 RPC_VER(&msg) = SC_RPC_VERSION;
189 RPC_SVC(&msg) = (u8)SC_RPC_SVC_PAD;
190 RPC_FUNC(&msg) = (u8)PAD_FUNC_SET;
191 RPC_U32(&msg, 0U) = (u32)val;
192 RPC_U16(&msg, 4U) = (u16)pad;
195 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
197 printf("%s: val:%d pad:%d: res:%d\n",
198 __func__, val, pad, RPC_R8(&msg));
204 int sc_misc_set_control(sc_ipc_t ipc, sc_rsrc_t resource,
205 sc_ctrl_t ctrl, u32 val)
207 struct udevice *dev = gd->arch.scu_dev;
208 int size = sizeof(struct sc_rpc_msg_s);
209 struct sc_rpc_msg_s msg;
215 RPC_VER(&msg) = SC_RPC_VERSION;
216 RPC_SVC(&msg) = (u8)SC_RPC_SVC_MISC;
217 RPC_FUNC(&msg) = (u8)MISC_FUNC_SET_CONTROL;
218 RPC_U32(&msg, 0U) = (u32)ctrl;
219 RPC_U32(&msg, 4U) = (u32)val;
220 RPC_U16(&msg, 8U) = (u16)resource;
223 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
225 printf("%s: ctrl:%d resource:%d: res:%d\n",
226 __func__, ctrl, resource, RPC_R8(&msg));
231 int sc_misc_get_control(sc_ipc_t ipc, sc_rsrc_t resource, sc_ctrl_t ctrl,
234 struct udevice *dev = gd->arch.scu_dev;
235 int size = sizeof(struct sc_rpc_msg_s);
236 struct sc_rpc_msg_s msg;
242 RPC_VER(&msg) = SC_RPC_VERSION;
243 RPC_SVC(&msg) = (u8)SC_RPC_SVC_MISC;
244 RPC_FUNC(&msg) = (u8)MISC_FUNC_GET_CONTROL;
245 RPC_U32(&msg, 0U) = (u32)ctrl;
246 RPC_U16(&msg, 4U) = (u16)resource;
249 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
251 printf("%s: ctrl:%d resource:%d: res:%d\n",
252 __func__, ctrl, resource, RPC_R8(&msg));
255 *val = RPC_U32(&msg, 0U);
260 int sc_rm_set_master_sid(sc_ipc_t ipc, sc_rsrc_t resource, sc_rm_sid_t sid)
262 struct udevice *dev = gd->arch.scu_dev;
263 struct sc_rpc_msg_s msg;
264 int size = sizeof(struct sc_rpc_msg_s);
267 RPC_VER(&msg) = SC_RPC_VERSION;
268 RPC_SVC(&msg) = (u8)SC_RPC_SVC_RM;
269 RPC_FUNC(&msg) = (u8)RM_FUNC_SET_MASTER_SID;
270 RPC_U16(&msg, 0U) = (u16)resource;
271 RPC_U16(&msg, 2U) = (u16)sid;
274 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
276 printf("%s: resource:%d sid:%d: res:%d\n",
277 __func__, resource, sid, RPC_R8(&msg));
282 void sc_misc_get_boot_dev(sc_ipc_t ipc, sc_rsrc_t *boot_dev)
284 struct udevice *dev = gd->arch.scu_dev;
285 int size = sizeof(struct sc_rpc_msg_s);
286 struct sc_rpc_msg_s msg;
292 RPC_VER(&msg) = SC_RPC_VERSION;
293 RPC_SVC(&msg) = (u8)SC_RPC_SVC_MISC;
294 RPC_FUNC(&msg) = (u8)MISC_FUNC_GET_BOOT_DEV;
297 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
299 printf("%s: res:%d\n", __func__, RPC_R8(&msg));
302 *boot_dev = RPC_U16(&msg, 0U);
305 void sc_misc_boot_status(sc_ipc_t ipc, sc_misc_boot_status_t status)
307 struct udevice *dev = gd->arch.scu_dev;
308 int size = sizeof(struct sc_rpc_msg_s);
309 struct sc_rpc_msg_s msg;
315 RPC_VER(&msg) = SC_RPC_VERSION;
316 RPC_SVC(&msg) = (u8)SC_RPC_SVC_MISC;
317 RPC_FUNC(&msg) = (u8)MISC_FUNC_BOOT_STATUS;
318 RPC_U8(&msg, 0U) = (u8)status;
321 ret = misc_call(dev, SC_TRUE, &msg, size, &msg, size);
323 printf("%s: status:%d res:%d\n",
324 __func__, status, RPC_R8(&msg));
327 void sc_misc_build_info(sc_ipc_t ipc, u32 *build, u32 *commit)
329 struct udevice *dev = gd->arch.scu_dev;
330 int size = sizeof(struct sc_rpc_msg_s);
331 struct sc_rpc_msg_s msg;
337 RPC_VER(&msg) = SC_RPC_VERSION;
338 RPC_SVC(&msg) = SC_RPC_SVC_MISC;
339 RPC_FUNC(&msg) = MISC_FUNC_BUILD_INFO;
342 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
344 printf("%s: err: %d\n", __func__, ret);
349 *build = RPC_U32(&msg, 0);
351 *commit = RPC_U32(&msg, 4);
354 int sc_misc_otp_fuse_read(sc_ipc_t ipc, u32 word, u32 *val)
356 struct udevice *dev = gd->arch.scu_dev;
357 int size = sizeof(struct sc_rpc_msg_s);
358 struct sc_rpc_msg_s msg;
364 RPC_VER(&msg) = SC_RPC_VERSION;
365 RPC_SVC(&msg) = SC_RPC_SVC_MISC;
366 RPC_FUNC(&msg) = MISC_FUNC_OTP_FUSE_READ;
367 RPC_U32(&msg, 0) = word;
370 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
375 *val = RPC_U32(&msg, 0U);
380 int sc_misc_get_temp(sc_ipc_t ipc, sc_rsrc_t resource, sc_misc_temp_t temp,
381 s16 *celsius, s8 *tenths)
383 struct udevice *dev = gd->arch.scu_dev;
384 int size = sizeof(struct sc_rpc_msg_s);
385 struct sc_rpc_msg_s msg;
388 RPC_VER(&msg) = SC_RPC_VERSION;
389 RPC_SVC(&msg) = (u8)SC_RPC_SVC_MISC;
390 RPC_FUNC(&msg) = (u8)MISC_FUNC_GET_TEMP;
391 RPC_U16(&msg, 0U) = (u16)resource;
392 RPC_U8(&msg, 2U) = (u8)temp;
395 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
400 *celsius = RPC_I16(&msg, 0U);
403 *tenths = RPC_I8(&msg, 2U);
409 sc_bool_t sc_rm_is_memreg_owned(sc_ipc_t ipc, sc_rm_mr_t mr)
411 struct udevice *dev = gd->arch.scu_dev;
412 int size = sizeof(struct sc_rpc_msg_s);
413 struct sc_rpc_msg_s msg;
420 RPC_VER(&msg) = SC_RPC_VERSION;
421 RPC_SVC(&msg) = (u8)SC_RPC_SVC_RM;
422 RPC_FUNC(&msg) = (u8)RM_FUNC_IS_MEMREG_OWNED;
423 RPC_U8(&msg, 0U) = (u8)mr;
426 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
427 result = RPC_R8(&msg);
429 if (result != 0 && result != 1) {
430 printf("%s: mr:%d res:%d\n", __func__, mr, RPC_R8(&msg));
432 printf("%s: mr:%d res:%d\n", __func__, mr,
436 return (sc_bool_t)result;
439 int sc_rm_find_memreg(sc_ipc_t ipc, sc_rm_mr_t *mr, sc_faddr_t addr_start,
442 struct udevice *dev = gd->arch.scu_dev;
443 int size = sizeof(struct sc_rpc_msg_s);
444 struct sc_rpc_msg_s msg;
450 RPC_VER(&msg) = SC_RPC_VERSION;
451 RPC_SVC(&msg) = (u8)(SC_RPC_SVC_RM);
452 RPC_FUNC(&msg) = (u8)(RM_FUNC_FIND_MEMREG);
453 RPC_U32(&msg, 0U) = (u32)(addr_start >> 32ULL);
454 RPC_U32(&msg, 4U) = (u32)(addr_start);
455 RPC_U32(&msg, 8U) = (u32)(addr_end >> 32ULL);
456 RPC_U32(&msg, 12U) = (u32)(addr_end);
459 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
461 printf("%s: start:0x%llx, end:0x%llx res:%d\n", __func__, addr_start, addr_end, RPC_R8(&msg));
464 *mr = RPC_U8(&msg, 0U);
469 int sc_rm_set_memreg_permissions(sc_ipc_t ipc, sc_rm_mr_t mr,
470 sc_rm_pt_t pt, sc_rm_perm_t perm)
472 struct udevice *dev = gd->arch.scu_dev;
473 int size = sizeof(struct sc_rpc_msg_s);
474 struct sc_rpc_msg_s msg;
480 RPC_VER(&msg) = SC_RPC_VERSION;
481 RPC_SVC(&msg) = (u8)(SC_RPC_SVC_RM);
482 RPC_FUNC(&msg) = (u8)(RM_FUNC_SET_MEMREG_PERMISSIONS);
483 RPC_U8(&msg, 0U) = (u8)(mr);
484 RPC_U8(&msg, 1U) = (u8)(pt);
485 RPC_U8(&msg, 2U) = (u8)(perm);
488 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
490 printf("%s: mr:%u, pt:%u, perm:%u, res:%d\n", __func__,
491 mr, pt, perm, RPC_R8(&msg));
497 int sc_rm_get_memreg_info(sc_ipc_t ipc, sc_rm_mr_t mr, sc_faddr_t *addr_start,
498 sc_faddr_t *addr_end)
500 struct udevice *dev = gd->arch.scu_dev;
501 int size = sizeof(struct sc_rpc_msg_s);
502 struct sc_rpc_msg_s msg;
508 RPC_VER(&msg) = SC_RPC_VERSION;
509 RPC_SVC(&msg) = (u8)SC_RPC_SVC_RM;
510 RPC_FUNC(&msg) = (u8)RM_FUNC_GET_MEMREG_INFO;
511 RPC_U8(&msg, 0U) = (u8)mr;
514 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
516 printf("%s: mr:%d res:%d\n", __func__, mr, RPC_R8(&msg));
519 *addr_start = ((u64)RPC_U32(&msg, 0U) << 32U) |
523 *addr_end = ((u64)RPC_U32(&msg, 8U) << 32U) |
529 sc_bool_t sc_rm_is_resource_owned(sc_ipc_t ipc, sc_rsrc_t resource)
531 struct udevice *dev = gd->arch.scu_dev;
532 int size = sizeof(struct sc_rpc_msg_s);
533 struct sc_rpc_msg_s msg;
540 RPC_VER(&msg) = SC_RPC_VERSION;
541 RPC_SVC(&msg) = (u8)SC_RPC_SVC_RM;
542 RPC_FUNC(&msg) = (u8)RM_FUNC_IS_RESOURCE_OWNED;
543 RPC_U16(&msg, 0U) = (u16)resource;
546 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
547 result = RPC_R8(&msg);
548 if (result != 0 && result != 1) {
549 printf("%s: resource:%d res:%d\n",
550 __func__, resource, RPC_R8(&msg));
552 printf("%s: res:%d res:%d\n", __func__, resource,
559 int sc_rm_partition_alloc(sc_ipc_t ipc, sc_rm_pt_t *pt, sc_bool_t secure,
560 sc_bool_t isolated, sc_bool_t restricted,
561 sc_bool_t grant, sc_bool_t coherent)
563 struct udevice *dev = gd->arch.scu_dev;
564 struct sc_rpc_msg_s msg;
565 int size = sizeof(struct sc_rpc_msg_s);
568 RPC_VER(&msg) = SC_RPC_VERSION;
569 RPC_SVC(&msg) = (u8)SC_RPC_SVC_RM;
570 RPC_FUNC(&msg) = (u8)RM_FUNC_PARTITION_ALLOC;
571 RPC_U8(&msg, 0U) = B2U8(secure);
572 RPC_U8(&msg, 1U) = B2U8(isolated);
573 RPC_U8(&msg, 2U) = B2U8(restricted);
574 RPC_U8(&msg, 3U) = B2U8(grant);
575 RPC_U8(&msg, 4U) = B2U8(coherent);
578 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
580 printf("%s: secure:%u isolated:%u restricted:%u grant:%u coherent:%u res:%d\n",
581 __func__, secure, isolated, restricted, grant, coherent,
586 *pt = RPC_U8(&msg, 0U);
591 int sc_rm_partition_free(sc_ipc_t ipc, sc_rm_pt_t pt)
593 struct udevice *dev = gd->arch.scu_dev;
594 struct sc_rpc_msg_s msg;
595 int size = sizeof(struct sc_rpc_msg_s);
598 RPC_VER(&msg) = SC_RPC_VERSION;
599 RPC_SVC(&msg) = (u8)SC_RPC_SVC_RM;
600 RPC_FUNC(&msg) = (u8)RM_FUNC_PARTITION_FREE;
601 RPC_U8(&msg, 0U) = (u8)pt;
604 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
606 printf("%s: pt:%u res:%d\n",
607 __func__, pt, RPC_R8(&msg));
613 int sc_rm_get_partition(sc_ipc_t ipc, sc_rm_pt_t *pt)
615 struct udevice *dev = gd->arch.scu_dev;
616 struct sc_rpc_msg_s msg;
617 int size = sizeof(struct sc_rpc_msg_s);
620 RPC_VER(&msg) = SC_RPC_VERSION;
621 RPC_SVC(&msg) = (u8)SC_RPC_SVC_RM;
622 RPC_FUNC(&msg) = (u8)RM_FUNC_GET_PARTITION;
625 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
627 printf("%s: res:%d\n", __func__, RPC_R8(&msg));
630 *pt = RPC_U8(&msg, 0U);
635 int sc_rm_set_parent(sc_ipc_t ipc, sc_rm_pt_t pt, sc_rm_pt_t pt_parent)
637 struct udevice *dev = gd->arch.scu_dev;
638 struct sc_rpc_msg_s msg;
639 int size = sizeof(struct sc_rpc_msg_s);
642 RPC_VER(&msg) = SC_RPC_VERSION;
643 RPC_SVC(&msg) = (u8)SC_RPC_SVC_RM;
644 RPC_FUNC(&msg) = (u8)RM_FUNC_SET_PARENT;
645 RPC_U8(&msg, 0U) = (u8)pt;
646 RPC_U8(&msg, 1U) = (u8)pt_parent;
649 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
651 printf("%s: pt:%u, pt_parent:%u, res:%d\n",
652 __func__, pt, pt_parent, RPC_R8(&msg));
658 int sc_rm_assign_resource(sc_ipc_t ipc, sc_rm_pt_t pt, sc_rsrc_t resource)
660 struct udevice *dev = gd->arch.scu_dev;
661 struct sc_rpc_msg_s msg;
662 int size = sizeof(struct sc_rpc_msg_s);
665 RPC_VER(&msg) = SC_RPC_VERSION;
666 RPC_SVC(&msg) = (u8)SC_RPC_SVC_RM;
667 RPC_FUNC(&msg) = (u8)RM_FUNC_ASSIGN_RESOURCE;
668 RPC_U16(&msg, 0U) = (u16)resource;
669 RPC_U8(&msg, 2U) = (u8)pt;
672 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
674 printf("%s: pt:%u, resource:%u, res:%d\n",
675 __func__, pt, resource, RPC_R8(&msg));
681 int sc_rm_assign_pad(sc_ipc_t ipc, sc_rm_pt_t pt, sc_pad_t pad)
683 struct udevice *dev = gd->arch.scu_dev;
684 struct sc_rpc_msg_s msg;
685 int size = sizeof(struct sc_rpc_msg_s);
688 RPC_VER(&msg) = SC_RPC_VERSION;
689 RPC_SVC(&msg) = (u8)SC_RPC_SVC_RM;
690 RPC_FUNC(&msg) = (u8)RM_FUNC_ASSIGN_PAD;
691 RPC_U16(&msg, 0U) = (u16)pad;
692 RPC_U8(&msg, 2U) = (u8)pt;
695 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
697 printf("%s: pt:%u, pad:%u, res:%d\n",
698 __func__, pt, pad, RPC_R8(&msg));
704 sc_bool_t sc_rm_is_pad_owned(sc_ipc_t ipc, sc_pad_t pad)
706 struct udevice *dev = gd->arch.scu_dev;
707 struct sc_rpc_msg_s msg;
708 int size = sizeof(struct sc_rpc_msg_s);
712 RPC_VER(&msg) = SC_RPC_VERSION;
713 RPC_SVC(&msg) = (u8)SC_RPC_SVC_RM;
714 RPC_FUNC(&msg) = (u8)RM_FUNC_IS_PAD_OWNED;
715 RPC_U8(&msg, 0U) = (u8)pad;
718 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
719 result = RPC_R8(&msg);
720 if (result != 0 && result != 1) {
721 printf("%s: pad:%d res:%d\n", __func__, pad, RPC_R8(&msg));
723 printf("%s: pad:%d res:%d\n", __func__,
731 int sc_rm_get_resource_owner(sc_ipc_t ipc, sc_rsrc_t resource,
734 struct udevice *dev = gd->arch.scu_dev;
735 struct sc_rpc_msg_s msg;
736 int size = sizeof(struct sc_rpc_msg_s);
739 RPC_VER(&msg) = SC_RPC_VERSION;
740 RPC_SVC(&msg) = (u8)SC_RPC_SVC_RM;
741 RPC_FUNC(&msg) = (u8)RM_FUNC_GET_RESOURCE_OWNER;
742 RPC_U16(&msg, 0U) = (u16)resource;
745 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
747 *pt = RPC_U8(&msg, 0U);
752 int sc_pm_cpu_start(sc_ipc_t ipc, sc_rsrc_t resource, sc_bool_t enable,
755 struct udevice *dev = gd->arch.scu_dev;
756 struct sc_rpc_msg_s msg;
757 int size = sizeof(struct sc_rpc_msg_s);
760 RPC_VER(&msg) = SC_RPC_VERSION;
761 RPC_SVC(&msg) = (u8)SC_RPC_SVC_PM;
762 RPC_FUNC(&msg) = (u8)PM_FUNC_CPU_START;
763 RPC_U32(&msg, 0U) = (u32)(address >> 32ULL);
764 RPC_U32(&msg, 4U) = (u32)address;
765 RPC_U16(&msg, 8U) = (u16)resource;
766 RPC_U8(&msg, 10U) = B2U8(enable);
769 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
771 printf("%s: resource:%d address:0x%llx: res:%d\n",
772 __func__, resource, address, RPC_R8(&msg));
778 int sc_pm_get_resource_power_mode(sc_ipc_t ipc, sc_rsrc_t resource,
779 sc_pm_power_mode_t *mode)
781 struct udevice *dev = gd->arch.scu_dev;
782 struct sc_rpc_msg_s msg;
783 int size = sizeof(struct sc_rpc_msg_s);
786 RPC_VER(&msg) = SC_RPC_VERSION;
787 RPC_SVC(&msg) = (u8)SC_RPC_SVC_PM;
788 RPC_FUNC(&msg) = (u8)PM_FUNC_GET_RESOURCE_POWER_MODE;
789 RPC_U16(&msg, 0U) = (u16)resource;
792 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
794 printf("%s: resource:%d: res:%d\n",
795 __func__, resource, RPC_R8(&msg));
799 *mode = RPC_U8(&msg, 0U);
804 int sc_seco_authenticate(sc_ipc_t ipc, sc_seco_auth_cmd_t cmd,
807 struct udevice *dev = gd->arch.scu_dev;
808 struct sc_rpc_msg_s msg;
809 int size = sizeof(struct sc_rpc_msg_s);
812 RPC_VER(&msg) = SC_RPC_VERSION;
813 RPC_SVC(&msg) = (u8)SC_RPC_SVC_SECO;
814 RPC_FUNC(&msg) = (u8)SECO_FUNC_AUTHENTICATE;
815 RPC_U32(&msg, 0U) = (u32)(addr >> 32ULL);
816 RPC_U32(&msg, 4U) = (u32)addr;
817 RPC_U8(&msg, 8U) = (u8)cmd;
820 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
822 printf("%s: res:%d\n", __func__, RPC_R8(&msg));
827 int sc_seco_forward_lifecycle(sc_ipc_t ipc, u32 change)
829 struct udevice *dev = gd->arch.scu_dev;
830 struct sc_rpc_msg_s msg;
831 int size = sizeof(struct sc_rpc_msg_s);
834 RPC_VER(&msg) = SC_RPC_VERSION;
835 RPC_SVC(&msg) = (u8)SC_RPC_SVC_SECO;
836 RPC_FUNC(&msg) = (u8)SECO_FUNC_FORWARD_LIFECYCLE;
837 RPC_U32(&msg, 0U) = (u32)change;
840 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
842 printf("%s: change:%u, res:%d\n", __func__,
843 change, RPC_R8(&msg));
849 int sc_seco_chip_info(sc_ipc_t ipc, u16 *lc, u16 *monotonic, u32 *uid_l,
852 struct udevice *dev = gd->arch.scu_dev;
853 struct sc_rpc_msg_s msg;
854 int size = sizeof(struct sc_rpc_msg_s);
857 RPC_VER(&msg) = SC_RPC_VERSION;
858 RPC_SVC(&msg) = (u8)SC_RPC_SVC_SECO;
859 RPC_FUNC(&msg) = (u8)SECO_FUNC_CHIP_INFO;
862 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
864 printf("%s: res:%d\n", __func__, RPC_R8(&msg));
867 *uid_l = RPC_U32(&msg, 0U);
870 *uid_h = RPC_U32(&msg, 4U);
873 *lc = RPC_U16(&msg, 8U);
876 *monotonic = RPC_U16(&msg, 10U);
881 void sc_seco_build_info(sc_ipc_t ipc, u32 *version, u32 *commit)
883 struct udevice *dev = gd->arch.scu_dev;
884 struct sc_rpc_msg_s msg;
885 int size = sizeof(struct sc_rpc_msg_s);
887 RPC_VER(&msg) = SC_RPC_VERSION;
888 RPC_SVC(&msg) = (u8)(SC_RPC_SVC_SECO);
889 RPC_FUNC(&msg) = (u8)(SECO_FUNC_BUILD_INFO);
892 misc_call(dev, SC_FALSE, &msg, size, &msg, size);
895 *version = RPC_U32(&msg, 0U);
898 *commit = RPC_U32(&msg, 4U);
901 int sc_seco_get_event(sc_ipc_t ipc, u8 idx, u32 *event)
903 struct udevice *dev = gd->arch.scu_dev;
904 struct sc_rpc_msg_s msg;
905 int size = sizeof(struct sc_rpc_msg_s);
908 RPC_VER(&msg) = SC_RPC_VERSION;
909 RPC_SVC(&msg) = (u8)SC_RPC_SVC_SECO;
910 RPC_FUNC(&msg) = (u8)SECO_FUNC_GET_EVENT;
911 RPC_U8(&msg, 0U) = (u8)idx;
914 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
916 printf("%s: idx: %u, res:%d\n", __func__, idx, RPC_R8(&msg));
919 *event = RPC_U32(&msg, 0U);
924 int sc_seco_gen_key_blob(sc_ipc_t ipc, u32 id, sc_faddr_t load_addr,
925 sc_faddr_t export_addr, u16 max_size)
927 struct udevice *dev = gd->arch.scu_dev;
928 struct sc_rpc_msg_s msg;
929 int size = sizeof(struct sc_rpc_msg_s);
932 RPC_VER(&msg) = SC_RPC_VERSION;
933 RPC_SVC(&msg) = (u8)SC_RPC_SVC_SECO;
934 RPC_FUNC(&msg) = (u8)SECO_FUNC_GEN_KEY_BLOB;
935 RPC_U32(&msg, 0U) = (u32)(load_addr >> 32ULL);
936 RPC_U32(&msg, 4U) = (u32)load_addr;
937 RPC_U32(&msg, 8U) = (u32)(export_addr >> 32ULL);
938 RPC_U32(&msg, 12U) = (u32)export_addr;
939 RPC_U32(&msg, 16U) = (u32)id;
940 RPC_U16(&msg, 20U) = (u16)max_size;
943 ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
945 printf("%s: id: %u, load_addr 0x%llx, export_addr 0x%llx, res:%d\n",
946 __func__, id, load_addr, export_addr, RPC_R8(&msg));