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__))
24uint8_t rt_svc_descs_indices[MAX_RT_SVCS];
25static 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 ******************************************************************************/
33uintptr_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 ******************************************************************************/
62static 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 ******************************************************************************/
91void 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