1 /*
2 * Copyright (c) 2013-2019, ARM Limited and Contributors. All rights reserved.
3 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 */
6
7 #include <assert.h>
8 #include <errno.h>
9 #include <string.h>
10
11 #include <common/debug.h>
12 #include <common/runtime_svc.h>
13
14 /*******************************************************************************
15 * The 'rt_svc_descs' array holds the runtime service descriptors exported by
16 * services by placing them in the 'rt_svc_descs' linker section.
17 * The 'rt_svc_descs_indices' array holds the index of a descriptor in the
18 * 'rt_svc_descs' array. When an SMC arrives, the OEN[29:24] bits and the call
19 * type[31] bit in the function id are combined to get an index into the
20 * 'rt_svc_descs_indices' array. This gives the index of the descriptor in the
21 * 'rt_svc_descs' array which contains the SMC handler.
22 ******************************************************************************/
23 uint8_t rt_svc_descs_indices[MAX_RT_SVCS];
24
25 #define RT_SVC_DECS_NUM ((RT_SVC_DESCS_END - RT_SVC_DESCS_START)\
26 / sizeof(rt_svc_desc_t))
27
28 /*******************************************************************************
29 * Function to invoke the registered `handle` corresponding to the smc_fid in
30 * AArch32 mode.
31 ******************************************************************************/
handle_runtime_svc(uint32_t smc_fid,void * cookie,void * handle,unsigned int flags)32 uintptr_t handle_runtime_svc(uint32_t smc_fid,
33 void *cookie,
34 void *handle,
35 unsigned int flags)
36 {
37 u_register_t x1, x2, x3, x4;
38 unsigned int index;
39 unsigned int idx;
40 const rt_svc_desc_t *rt_svc_descs;
41
42 assert(handle != NULL);
43 idx = get_unique_oen_from_smc_fid(smc_fid);
44 assert(idx < MAX_RT_SVCS);
45
46 index = rt_svc_descs_indices[idx];
47 if (index >= RT_SVC_DECS_NUM)
48 SMC_RET1(handle, SMC_UNK);
49
50 rt_svc_descs = (rt_svc_desc_t *) RT_SVC_DESCS_START;
51
52 get_smc_params_from_ctx(handle, x1, x2, x3, x4);
53
54 return rt_svc_descs[index].handle(smc_fid, x1, x2, x3, x4, cookie,
55 handle, flags);
56 }
57
58 /*******************************************************************************
59 * Simple routine to sanity check a runtime service descriptor before using it
60 ******************************************************************************/
validate_rt_svc_desc(const rt_svc_desc_t * desc)61 static int32_t validate_rt_svc_desc(const rt_svc_desc_t *desc)
62 {
63 if (desc == NULL)
64 return -EINVAL;
65
66 if (desc->start_oen > desc->end_oen)
67 return -EINVAL;
68
69 if (desc->end_oen >= OEN_LIMIT)
70 return -EINVAL;
71
72 if ((desc->call_type != SMC_TYPE_FAST) &&
73 (desc->call_type != SMC_TYPE_YIELD))
74 return -EINVAL;
75
76 /* A runtime service having no init or handle function doesn't make sense */
77 if ((desc->init == NULL) && (desc->handle == NULL))
78 return -EINVAL;
79
80 return 0;
81 }
82
83 /*******************************************************************************
84 * This function calls the initialisation routine in the descriptor exported by
85 * a runtime service. Once a descriptor has been validated, its start & end
86 * owning entity numbers and the call type are combined to form a unique oen.
87 * The unique oen is used as an index into the 'rt_svc_descs_indices' array.
88 * The index of the runtime service descriptor is stored at this index.
89 ******************************************************************************/
runtime_svc_init(void)90 void __init runtime_svc_init(void)
91 {
92 int rc = 0;
93 uint8_t index, start_idx, end_idx;
94 rt_svc_desc_t *rt_svc_descs;
95
96 /* Assert the number of descriptors detected are less than maximum indices */
97 assert((RT_SVC_DESCS_END >= RT_SVC_DESCS_START) &&
98 (RT_SVC_DECS_NUM < MAX_RT_SVCS));
99
100 /* If no runtime services are implemented then simply bail out */
101 if (RT_SVC_DECS_NUM == 0U)
102 return;
103
104 /* Initialise internal variables to invalid state */
105 (void)memset(rt_svc_descs_indices, -1, sizeof(rt_svc_descs_indices));
106
107 rt_svc_descs = (rt_svc_desc_t *) RT_SVC_DESCS_START;
108 for (index = 0U; index < RT_SVC_DECS_NUM; index++) {
109 rt_svc_desc_t *service = &rt_svc_descs[index];
110
111 /*
112 * An invalid descriptor is an error condition since it is
113 * difficult to predict the system behaviour in the absence
114 * of this service.
115 */
116 rc = validate_rt_svc_desc(service);
117 if (rc != 0) {
118 ERROR("Invalid runtime service descriptor %p\n",
119 (void *) service);
120 panic();
121 }
122
123 /*
124 * The runtime service may have separate rt_svc_desc_t
125 * for its fast smc and yielding smc. Since the service itself
126 * need to be initialized only once, only one of them will have
127 * an initialisation routine defined. Call the initialisation
128 * routine for this runtime service, if it is defined.
129 */
130 if (service->init != NULL) {
131 rc = service->init();
132 if (rc != 0) {
133 ERROR("Error initializing runtime service %s\n",
134 service->name);
135 continue;
136 }
137 }
138
139 /*
140 * Fill the indices corresponding to the start and end
141 * owning entity numbers with the index of the
142 * descriptor which will handle the SMCs for this owning
143 * entity range.
144 */
145 start_idx = (uint8_t)get_unique_oen(service->start_oen,
146 service->call_type);
147 end_idx = (uint8_t)get_unique_oen(service->end_oen,
148 service->call_type);
149 assert(start_idx <= end_idx);
150 assert(end_idx < MAX_RT_SVCS);
151 for (; start_idx <= end_idx; start_idx++)
152 rt_svc_descs_indices[start_idx] = index;
153 }
154 }
155