1 /*
2 * Copyright (c) 2013-2017, ARM Limited and Contributors. All rights reserved.
3 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 */
6
7 #include <assert.h>
8 #include <debug.h>
9 #include <errno.h>
10 #include <runtime_svc.h>
11 #include <string.h>
12
13 /*******************************************************************************
14 * The 'rt_svc_descs' array holds the runtime service descriptors exported by
15 * services by placing them in the 'rt_svc_descs' linker section.
16 * The 'rt_svc_descs_indices' array holds the index of a descriptor in the
17 * 'rt_svc_descs' array. When an SMC arrives, the OEN[29:24] bits and the call
18 * type[31] bit in the function id are combined to get an index into the
19 * 'rt_svc_descs_indices' array. This gives the index of the descriptor in the
20 * 'rt_svc_descs' array which contains the SMC handler.
21 ******************************************************************************/
22 #define RT_SVC_DESCS_START ((uintptr_t) (&__RT_SVC_DESCS_START__))
23 #define RT_SVC_DESCS_END ((uintptr_t) (&__RT_SVC_DESCS_END__))
24 uint8_t rt_svc_descs_indices[MAX_RT_SVCS];
25 static rt_svc_desc_t *rt_svc_descs;
26
27 #define RT_SVC_DECS_NUM ((RT_SVC_DESCS_END - RT_SVC_DESCS_START)\
28 / sizeof(rt_svc_desc_t))
29
30 /*******************************************************************************
31 * Function to invoke the registered `handle` corresponding to the smc_fid.
32 ******************************************************************************/
handle_runtime_svc(uint32_t smc_fid,void * cookie,void * handle,unsigned int flags)33 uintptr_t handle_runtime_svc(uint32_t smc_fid,
34 void *cookie,
35 void *handle,
36 unsigned int flags)
37 {
38 u_register_t x1, x2, x3, x4;
39 int index;
40 unsigned int idx;
41 const rt_svc_desc_t *rt_svc_descs;
42
43 assert(handle);
44 idx = get_unique_oen_from_smc_fid(smc_fid);
45 assert(idx < MAX_RT_SVCS);
46
47 index = rt_svc_descs_indices[idx];
48 if (index < 0 || index >= (int)RT_SVC_DECS_NUM)
49 SMC_RET1(handle, SMC_UNK);
50
51 rt_svc_descs = (rt_svc_desc_t *) RT_SVC_DESCS_START;
52
53 get_smc_params_from_ctx(handle, x1, x2, x3, x4);
54
55 return rt_svc_descs[index].handle(smc_fid, x1, x2, x3, x4, cookie,
56 handle, flags);
57 }
58
59 /*******************************************************************************
60 * Simple routine to sanity check a runtime service descriptor before using it
61 ******************************************************************************/
validate_rt_svc_desc(const rt_svc_desc_t * desc)62 static int32_t validate_rt_svc_desc(const rt_svc_desc_t *desc)
63 {
64 if (desc == NULL)
65 return -EINVAL;
66
67 if (desc->start_oen > desc->end_oen)
68 return -EINVAL;
69
70 if (desc->end_oen >= OEN_LIMIT)
71 return -EINVAL;
72
73 if (desc->call_type != SMC_TYPE_FAST &&
74 desc->call_type != SMC_TYPE_YIELD)
75 return -EINVAL;
76
77 /* A runtime service having no init or handle function doesn't make sense */
78 if (desc->init == NULL && desc->handle == NULL)
79 return -EINVAL;
80
81 return 0;
82 }
83
84 /*******************************************************************************
85 * This function calls the initialisation routine in the descriptor exported by
86 * a runtime service. Once a descriptor has been validated, its start & end
87 * owning entity numbers and the call type are combined to form a unique oen.
88 * The unique oen is used as an index into the 'rt_svc_descs_indices' array.
89 * The index of the runtime service descriptor is stored at this index.
90 ******************************************************************************/
runtime_svc_init(void)91 void runtime_svc_init(void)
92 {
93 int rc = 0;
94 unsigned int index, start_idx, end_idx;
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 == 0)
102 return;
103
104 /* Initialise internal variables to invalid state */
105 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 = 0; 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) {
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) {
131 rc = service->init();
132 if (rc) {
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 = get_unique_oen(rt_svc_descs[index].start_oen,
146 service->call_type);
147 assert(start_idx < MAX_RT_SVCS);
148 end_idx = get_unique_oen(rt_svc_descs[index].end_oen,
149 service->call_type);
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