blob: 44178eddd32044ed1688521325404e1516b16fd3 [file] [log] [blame]
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +01001/*
Balint Dobszayd0dbd5e2019-12-18 15:28:00 +01002 * Copyright (c) 2017-2020, ARM Limited and Contributors. All rights reserved.
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +01003 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 */
6
7#include <arch_helpers.h>
8#include <assert.h>
Scott Brandene5dcf982020-08-25 13:49:32 -07009#include <inttypes.h>
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +010010#include <stddef.h>
Scott Brandene5dcf982020-08-25 13:49:32 -070011#include <stdint.h>
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +010012#include <string.h>
Antonio Nino Diaze0f90632018-12-14 00:18:21 +000013
14#include <bl31/bl31.h>
15#include <bl31/ehf.h>
16#include <bl31/interrupt_mgmt.h>
17#include <common/bl_common.h>
18#include <common/debug.h>
19#include <common/runtime_svc.h>
20#include <context.h>
21#include <lib/cassert.h>
22#include <lib/el3_runtime/pubsub.h>
23#include <lib/utils.h>
24#include <plat/common/platform.h>
25#include <services/sdei.h>
26
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +010027#include "sdei_private.h"
28
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +010029#define MAJOR_VERSION 1ULL
30#define MINOR_VERSION 0ULL
31#define VENDOR_VERSION 0ULL
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +010032
33#define MAKE_SDEI_VERSION(_major, _minor, _vendor) \
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +010034 ((((_major)) << 48ULL) | (((_minor)) << 32ULL) | (_vendor))
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +010035
36#define LOWEST_INTR_PRIORITY 0xff
37
38#define is_valid_affinity(_mpidr) (plat_core_pos_by_mpidr(_mpidr) >= 0)
39
40CASSERT(PLAT_SDEI_CRITICAL_PRI < PLAT_SDEI_NORMAL_PRI,
41 sdei_critical_must_have_higher_priority);
42
43static unsigned int num_dyn_priv_slots, num_dyn_shrd_slots;
44
45/* Initialise SDEI map entries */
46static void init_map(sdei_ev_map_t *map)
47{
48 map->reg_count = 0;
49}
50
51/* Convert mapping to SDEI class */
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +010052static sdei_class_t map_to_class(sdei_ev_map_t *map)
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +010053{
54 return is_event_critical(map) ? SDEI_CRITICAL : SDEI_NORMAL;
55}
56
57/* Clear SDEI event entries except state */
58static void clear_event_entries(sdei_entry_t *se)
59{
60 se->ep = 0;
61 se->arg = 0;
62 se->affinity = 0;
63 se->reg_flags = 0;
64}
65
66/* Perform CPU-specific state initialisation */
67static void *sdei_cpu_on_init(const void *arg)
68{
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +010069 unsigned int i;
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +010070 sdei_ev_map_t *map;
71 sdei_entry_t *se;
72
73 /* Initialize private mappings on this CPU */
74 for_each_private_map(i, map) {
75 se = get_event_entry(map);
76 clear_event_entries(se);
77 se->state = 0;
78 }
79
80 SDEI_LOG("Private events initialized on %lx\n", read_mpidr_el1());
81
82 /* All PEs start with SDEI events masked */
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +010083 (void) sdei_pe_mask();
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +010084
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +010085 return NULL;
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +010086}
87
Jeenu Viswambharanf5ee3832018-02-01 08:05:36 +000088/* CPU initialisation after wakeup from suspend */
89static void *sdei_cpu_wakeup_init(const void *arg)
90{
91 SDEI_LOG("Events masked on %lx\n", read_mpidr_el1());
92
93 /* All PEs wake up with SDEI events masked */
94 sdei_pe_mask();
95
96 return 0;
97}
98
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +010099/* Initialise an SDEI class */
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100100static void sdei_class_init(sdei_class_t class)
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100101{
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100102 unsigned int i;
103 bool zero_found __unused = false;
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100104 int ev_num_so_far __unused;
105 sdei_ev_map_t *map;
106
107 /* Sanity check and configuration of shared events */
108 ev_num_so_far = -1;
109 for_each_shared_map(i, map) {
110#if ENABLE_ASSERTIONS
111 /* Ensure mappings are sorted */
112 assert((ev_num_so_far < 0) || (map->ev_num > ev_num_so_far));
113
114 ev_num_so_far = map->ev_num;
115
116 /* Event 0 must not be shared */
117 assert(map->ev_num != SDEI_EVENT_0);
118
119 /* Check for valid event */
120 assert(map->ev_num >= 0);
121
122 /* Make sure it's a shared event */
123 assert(is_event_shared(map));
124
125 /* No shared mapping should have signalable property */
126 assert(!is_event_signalable(map));
Jeenu Viswambharan34392302018-01-17 12:30:11 +0000127
128 /* Shared mappings can't be explicit */
129 assert(!is_map_explicit(map));
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100130#endif
131
132 /* Skip initializing the wrong priority */
133 if (map_to_class(map) != class)
134 continue;
135
136 /* Platform events are always bound, so set the bound flag */
137 if (is_map_dynamic(map)) {
138 assert(map->intr == SDEI_DYN_IRQ);
Jeenu Viswambharanc3fcec12017-11-16 12:06:34 +0000139 assert(is_event_normal(map));
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100140 num_dyn_shrd_slots++;
141 } else {
142 /* Shared mappings must be bound to shared interrupt */
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100143 assert(plat_ic_is_spi(map->intr) != 0);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100144 set_map_bound(map);
145 }
146
147 init_map(map);
148 }
149
150 /* Sanity check and configuration of private events for this CPU */
151 ev_num_so_far = -1;
152 for_each_private_map(i, map) {
153#if ENABLE_ASSERTIONS
154 /* Ensure mappings are sorted */
155 assert((ev_num_so_far < 0) || (map->ev_num > ev_num_so_far));
156
157 ev_num_so_far = map->ev_num;
158
159 if (map->ev_num == SDEI_EVENT_0) {
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100160 zero_found = true;
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100161
162 /* Event 0 must be a Secure SGI */
163 assert(is_secure_sgi(map->intr));
164
165 /*
166 * Event 0 can have only have signalable flag (apart
167 * from being private
168 */
169 assert(map->map_flags == (SDEI_MAPF_SIGNALABLE |
170 SDEI_MAPF_PRIVATE));
171 } else {
172 /* No other mapping should have signalable property */
173 assert(!is_event_signalable(map));
174 }
175
176 /* Check for valid event */
177 assert(map->ev_num >= 0);
178
179 /* Make sure it's a private event */
180 assert(is_event_private(map));
Jeenu Viswambharan34392302018-01-17 12:30:11 +0000181
182 /*
183 * Other than priority, explicit events can only have explicit
184 * and private flags set.
185 */
186 if (is_map_explicit(map)) {
187 assert((map->map_flags | SDEI_MAPF_CRITICAL) ==
188 (SDEI_MAPF_EXPLICIT | SDEI_MAPF_PRIVATE
189 | SDEI_MAPF_CRITICAL));
190 }
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100191#endif
192
193 /* Skip initializing the wrong priority */
194 if (map_to_class(map) != class)
195 continue;
196
197 /* Platform events are always bound, so set the bound flag */
198 if (map->ev_num != SDEI_EVENT_0) {
199 if (is_map_dynamic(map)) {
200 assert(map->intr == SDEI_DYN_IRQ);
Jeenu Viswambharanc3fcec12017-11-16 12:06:34 +0000201 assert(is_event_normal(map));
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100202 num_dyn_priv_slots++;
Jeenu Viswambharan34392302018-01-17 12:30:11 +0000203 } else if (is_map_explicit(map)) {
204 /*
205 * Explicit mappings don't have a backing
206 * SDEI interrupt, but verify that anyway.
207 */
208 assert(map->intr == SDEI_DYN_IRQ);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100209 } else {
210 /*
211 * Private mappings must be bound to private
212 * interrupt.
213 */
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100214 assert(plat_ic_is_ppi((unsigned) map->intr) != 0);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100215 set_map_bound(map);
216 }
217 }
218
219 init_map(map);
220 }
221
222 /* Ensure event 0 is in the mapping */
223 assert(zero_found);
224
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100225 (void) sdei_cpu_on_init(NULL);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100226}
227
228/* SDEI dispatcher initialisation */
229void sdei_init(void)
230{
Balint Dobszayd0dbd5e2019-12-18 15:28:00 +0100231 plat_sdei_setup();
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100232 sdei_class_init(SDEI_CRITICAL);
233 sdei_class_init(SDEI_NORMAL);
234
235 /* Register priority level handlers */
236 ehf_register_priority_handler(PLAT_SDEI_CRITICAL_PRI,
237 sdei_intr_handler);
238 ehf_register_priority_handler(PLAT_SDEI_NORMAL_PRI,
239 sdei_intr_handler);
240}
241
242/* Populate SDEI event entry */
243static void set_sdei_entry(sdei_entry_t *se, uint64_t ep, uint64_t arg,
244 unsigned int flags, uint64_t affinity)
245{
246 assert(se != NULL);
247
248 se->ep = ep;
249 se->arg = arg;
250 se->affinity = (affinity & MPIDR_AFFINITY_MASK);
251 se->reg_flags = flags;
252}
253
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100254static uint64_t sdei_version(void)
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100255{
256 return MAKE_SDEI_VERSION(MAJOR_VERSION, MINOR_VERSION, VENDOR_VERSION);
257}
258
259/* Validate flags and MPIDR values for REGISTER and ROUTING_SET calls */
260static int validate_flags(uint64_t flags, uint64_t mpidr)
261{
262 /* Validate flags */
263 switch (flags) {
264 case SDEI_REGF_RM_PE:
265 if (!is_valid_affinity(mpidr))
266 return SDEI_EINVAL;
267 break;
268 case SDEI_REGF_RM_ANY:
269 break;
270 default:
271 /* Unknown flags */
272 return SDEI_EINVAL;
273 }
274
275 return 0;
276}
277
278/* Set routing of an SDEI event */
279static int sdei_event_routing_set(int ev_num, uint64_t flags, uint64_t mpidr)
280{
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100281 int ret;
282 unsigned int routing;
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100283 sdei_ev_map_t *map;
284 sdei_entry_t *se;
285
286 ret = validate_flags(flags, mpidr);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100287 if (ret != 0)
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100288 return ret;
289
290 /* Check if valid event number */
291 map = find_event_map(ev_num);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100292 if (map == NULL)
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100293 return SDEI_EINVAL;
294
295 /* The event must not be private */
296 if (is_event_private(map))
297 return SDEI_EINVAL;
298
299 se = get_event_entry(map);
300
301 sdei_map_lock(map);
302
303 if (!is_map_bound(map) || is_event_private(map)) {
304 ret = SDEI_EINVAL;
305 goto finish;
306 }
307
308 if (!can_sdei_state_trans(se, DO_ROUTING)) {
309 ret = SDEI_EDENY;
310 goto finish;
311 }
312
313 /* Choose appropriate routing */
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100314 routing = (unsigned int) ((flags == SDEI_REGF_RM_ANY) ?
315 INTR_ROUTING_MODE_ANY : INTR_ROUTING_MODE_PE);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100316
317 /* Update event registration flag */
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100318 se->reg_flags = (unsigned int) flags;
Tony Xiec55ff342020-12-31 11:25:15 +0800319 if (flags == SDEI_REGF_RM_PE) {
320 se->affinity = (mpidr & MPIDR_AFFINITY_MASK);
321 }
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100322
323 /*
324 * ROUTING_SET is permissible only when event composite state is
325 * 'registered, disabled, and not running'. This means that the
326 * interrupt is currently disabled, and not active.
327 */
328 plat_ic_set_spi_routing(map->intr, routing, (u_register_t) mpidr);
329
330finish:
331 sdei_map_unlock(map);
332
333 return ret;
334}
335
336/* Register handler and argument for an SDEI event */
Balint Dobszayd0dbd5e2019-12-18 15:28:00 +0100337static int64_t sdei_event_register(int ev_num,
338 uint64_t ep,
339 uint64_t arg,
340 uint64_t flags,
341 uint64_t mpidr)
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100342{
343 int ret;
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100344 unsigned int routing;
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100345 sdei_entry_t *se;
346 sdei_ev_map_t *map;
347 sdei_state_t backup_state;
348
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100349 if ((ep == 0U) || (plat_sdei_validate_entry_point(
350 ep, sdei_client_el()) != 0)) {
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100351 return SDEI_EINVAL;
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100352 }
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100353
354 ret = validate_flags(flags, mpidr);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100355 if (ret != 0)
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100356 return ret;
357
358 /* Check if valid event number */
359 map = find_event_map(ev_num);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100360 if (map == NULL)
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100361 return SDEI_EINVAL;
362
363 /* Private events always target the PE */
Ming Huangcceb7852021-09-09 17:42:27 +0800364 if (is_event_private(map)) {
365 /*
366 * SDEI internally handles private events in the same manner
367 * as public events with routing mode=RM_PE, since the routing
368 * mode flag and affinity fields are not used when registering
369 * a private event, set them here.
370 */
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100371 flags = SDEI_REGF_RM_PE;
Ming Huangcceb7852021-09-09 17:42:27 +0800372 /*
373 * Kernel may pass 0 as mpidr, as we set flags to
374 * SDEI_REGF_RM_PE, so set mpidr also.
375 */
376 mpidr = read_mpidr_el1();
377 }
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100378
379 se = get_event_entry(map);
380
381 /*
382 * Even though register operation is per-event (additionally for private
383 * events, registration is required individually), it has to be
384 * serialised with respect to bind/release, which are global operations.
385 * So we hold the lock throughout, unconditionally.
386 */
387 sdei_map_lock(map);
388
389 backup_state = se->state;
390 if (!can_sdei_state_trans(se, DO_REGISTER))
391 goto fallback;
392
393 /*
394 * When registering for dynamic events, make sure it's been bound
395 * already. This has to be the case as, without binding, the client
396 * can't know about the event number to register for.
397 */
398 if (is_map_dynamic(map) && !is_map_bound(map))
399 goto fallback;
400
401 if (is_event_private(map)) {
402 /* Multiple calls to register are possible for private events */
403 assert(map->reg_count >= 0);
404 } else {
405 /* Only single call to register is possible for shared events */
406 assert(map->reg_count == 0);
407 }
408
409 if (is_map_bound(map)) {
410 /* Meanwhile, did any PE ACK the interrupt? */
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100411 if (plat_ic_get_interrupt_active(map->intr) != 0U)
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100412 goto fallback;
413
414 /* The interrupt must currently owned by Non-secure */
415 if (plat_ic_get_interrupt_type(map->intr) != INTR_TYPE_NS)
416 goto fallback;
417
418 /*
419 * Disable forwarding of new interrupt triggers to CPU
420 * interface.
421 */
422 plat_ic_disable_interrupt(map->intr);
423
424 /*
425 * Any events that are triggered after register and before
426 * enable should remain pending. Clear any previous interrupt
427 * triggers which are pending (except for SGIs). This has no
428 * affect on level-triggered interrupts.
429 */
430 if (ev_num != SDEI_EVENT_0)
431 plat_ic_clear_interrupt_pending(map->intr);
432
433 /* Map interrupt to EL3 and program the correct priority */
434 plat_ic_set_interrupt_type(map->intr, INTR_TYPE_EL3);
435
436 /* Program the appropriate interrupt priority */
437 plat_ic_set_interrupt_priority(map->intr, sdei_event_priority(map));
438
439 /*
440 * Set the routing mode for shared event as requested. We
441 * already ensure that shared events get bound to SPIs.
442 */
443 if (is_event_shared(map)) {
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100444 routing = (unsigned int) ((flags == SDEI_REGF_RM_ANY) ?
445 INTR_ROUTING_MODE_ANY : INTR_ROUTING_MODE_PE);
446 plat_ic_set_spi_routing(map->intr, routing,
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100447 (u_register_t) mpidr);
448 }
449 }
450
451 /* Populate event entries */
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100452 set_sdei_entry(se, ep, arg, (unsigned int) flags, mpidr);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100453
454 /* Increment register count */
455 map->reg_count++;
456
457 sdei_map_unlock(map);
458
459 return 0;
460
461fallback:
462 /* Reinstate previous state */
463 se->state = backup_state;
464
465 sdei_map_unlock(map);
466
467 return SDEI_EDENY;
468}
469
470/* Enable SDEI event */
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100471static int64_t sdei_event_enable(int ev_num)
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100472{
473 sdei_ev_map_t *map;
474 sdei_entry_t *se;
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100475 int ret;
476 bool before, after;
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100477
478 /* Check if valid event number */
479 map = find_event_map(ev_num);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100480 if (map == NULL)
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100481 return SDEI_EINVAL;
482
483 se = get_event_entry(map);
484 ret = SDEI_EDENY;
485
486 if (is_event_shared(map))
487 sdei_map_lock(map);
488
489 before = GET_EV_STATE(se, ENABLED);
490 if (!can_sdei_state_trans(se, DO_ENABLE))
491 goto finish;
492 after = GET_EV_STATE(se, ENABLED);
493
494 /*
495 * Enable interrupt for bound events only if there's a change in enabled
496 * state.
497 */
498 if (is_map_bound(map) && (!before && after))
499 plat_ic_enable_interrupt(map->intr);
500
501 ret = 0;
502
503finish:
504 if (is_event_shared(map))
505 sdei_map_unlock(map);
506
507 return ret;
508}
509
510/* Disable SDEI event */
511static int sdei_event_disable(int ev_num)
512{
513 sdei_ev_map_t *map;
514 sdei_entry_t *se;
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100515 int ret;
516 bool before, after;
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100517
518 /* Check if valid event number */
519 map = find_event_map(ev_num);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100520 if (map == NULL)
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100521 return SDEI_EINVAL;
522
523 se = get_event_entry(map);
524 ret = SDEI_EDENY;
525
526 if (is_event_shared(map))
527 sdei_map_lock(map);
528
529 before = GET_EV_STATE(se, ENABLED);
530 if (!can_sdei_state_trans(se, DO_DISABLE))
531 goto finish;
532 after = GET_EV_STATE(se, ENABLED);
533
534 /*
535 * Disable interrupt for bound events only if there's a change in
536 * enabled state.
537 */
538 if (is_map_bound(map) && (before && !after))
539 plat_ic_disable_interrupt(map->intr);
540
541 ret = 0;
542
543finish:
544 if (is_event_shared(map))
545 sdei_map_unlock(map);
546
547 return ret;
548}
549
550/* Query SDEI event information */
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100551static int64_t sdei_event_get_info(int ev_num, int info)
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100552{
553 sdei_entry_t *se;
554 sdei_ev_map_t *map;
555
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100556 uint64_t flags;
557 bool registered;
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100558 uint64_t affinity;
559
560 /* Check if valid event number */
561 map = find_event_map(ev_num);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100562 if (map == NULL)
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100563 return SDEI_EINVAL;
564
565 se = get_event_entry(map);
566
567 if (is_event_shared(map))
568 sdei_map_lock(map);
569
570 /* Sample state under lock */
571 registered = GET_EV_STATE(se, REGISTERED);
572 flags = se->reg_flags;
573 affinity = se->affinity;
574
575 if (is_event_shared(map))
576 sdei_map_unlock(map);
577
578 switch (info) {
579 case SDEI_INFO_EV_TYPE:
580 return is_event_shared(map);
581
582 case SDEI_INFO_EV_NOT_SIGNALED:
583 return !is_event_signalable(map);
584
585 case SDEI_INFO_EV_PRIORITY:
586 return is_event_critical(map);
587
588 case SDEI_INFO_EV_ROUTING_MODE:
589 if (!is_event_shared(map))
590 return SDEI_EINVAL;
591 if (!registered)
592 return SDEI_EDENY;
593 return (flags == SDEI_REGF_RM_PE);
594
595 case SDEI_INFO_EV_ROUTING_AFF:
596 if (!is_event_shared(map))
597 return SDEI_EINVAL;
598 if (!registered)
599 return SDEI_EDENY;
600 if (flags != SDEI_REGF_RM_PE)
601 return SDEI_EINVAL;
602 return affinity;
603
604 default:
605 return SDEI_EINVAL;
606 }
607}
608
609/* Unregister an SDEI event */
610static int sdei_event_unregister(int ev_num)
611{
612 int ret = 0;
613 sdei_entry_t *se;
614 sdei_ev_map_t *map;
615
616 /* Check if valid event number */
617 map = find_event_map(ev_num);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100618 if (map == NULL)
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100619 return SDEI_EINVAL;
620
621 se = get_event_entry(map);
622
623 /*
624 * Even though unregister operation is per-event (additionally for
625 * private events, unregistration is required individually), it has to
626 * be serialised with respect to bind/release, which are global
627 * operations. So we hold the lock throughout, unconditionally.
628 */
629 sdei_map_lock(map);
630
631 if (!can_sdei_state_trans(se, DO_UNREGISTER)) {
632 /*
633 * Even if the call is invalid, and the handler is running (for
634 * example, having unregistered from a running handler earlier),
635 * return pending error code; otherwise, return deny.
636 */
637 ret = GET_EV_STATE(se, RUNNING) ? SDEI_EPEND : SDEI_EDENY;
638
639 goto finish;
640 }
641
642 map->reg_count--;
643 if (is_event_private(map)) {
644 /* Multiple calls to register are possible for private events */
645 assert(map->reg_count >= 0);
646 } else {
647 /* Only single call to register is possible for shared events */
648 assert(map->reg_count == 0);
649 }
650
651 if (is_map_bound(map)) {
652 plat_ic_disable_interrupt(map->intr);
653
654 /*
655 * Clear pending interrupt. Skip for SGIs as they may not be
656 * cleared on interrupt controllers.
657 */
658 if (ev_num != SDEI_EVENT_0)
659 plat_ic_clear_interrupt_pending(map->intr);
660
661 assert(plat_ic_get_interrupt_type(map->intr) == INTR_TYPE_EL3);
662 plat_ic_set_interrupt_type(map->intr, INTR_TYPE_NS);
663 plat_ic_set_interrupt_priority(map->intr, LOWEST_INTR_PRIORITY);
664 }
665
666 clear_event_entries(se);
667
668 /*
669 * If the handler is running at the time of unregister, return the
670 * pending error code.
671 */
672 if (GET_EV_STATE(se, RUNNING))
673 ret = SDEI_EPEND;
674
675finish:
676 sdei_map_unlock(map);
677
678 return ret;
679}
680
681/* Query status of an SDEI event */
682static int sdei_event_status(int ev_num)
683{
684 sdei_ev_map_t *map;
685 sdei_entry_t *se;
686 sdei_state_t state;
687
688 /* Check if valid event number */
689 map = find_event_map(ev_num);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100690 if (map == NULL)
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100691 return SDEI_EINVAL;
692
693 se = get_event_entry(map);
694
695 if (is_event_shared(map))
696 sdei_map_lock(map);
697
698 /* State value directly maps to the expected return format */
699 state = se->state;
700
701 if (is_event_shared(map))
702 sdei_map_unlock(map);
703
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100704 return (int) state;
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100705}
706
707/* Bind an SDEI event to an interrupt */
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100708static int sdei_interrupt_bind(unsigned int intr_num)
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100709{
710 sdei_ev_map_t *map;
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100711 bool retry = true, shared_mapping;
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100712
713 /* SGIs are not allowed to be bound */
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100714 if (plat_ic_is_sgi(intr_num) != 0)
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100715 return SDEI_EINVAL;
716
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100717 shared_mapping = (plat_ic_is_spi(intr_num) != 0);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100718 do {
719 /*
720 * Bail out if there is already an event for this interrupt,
721 * either platform-defined or dynamic.
722 */
723 map = find_event_map_by_intr(intr_num, shared_mapping);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100724 if (map != NULL) {
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100725 if (is_map_dynamic(map)) {
726 if (is_map_bound(map)) {
727 /*
728 * Dynamic event, already bound. Return
729 * event number.
730 */
731 return map->ev_num;
732 }
733 } else {
734 /* Binding non-dynamic event */
735 return SDEI_EINVAL;
736 }
737 }
738
739 /*
740 * The interrupt is not bound yet. Try to find a free slot to
741 * bind it. Free dynamic mappings have their interrupt set as
742 * SDEI_DYN_IRQ.
743 */
744 map = find_event_map_by_intr(SDEI_DYN_IRQ, shared_mapping);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100745 if (map == NULL)
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100746 return SDEI_ENOMEM;
747
748 /* The returned mapping must be dynamic */
749 assert(is_map_dynamic(map));
750
751 /*
752 * We cannot assert for bound maps here, as we might be racing
753 * with another bind.
754 */
755
756 /* The requested interrupt must already belong to NS */
757 if (plat_ic_get_interrupt_type(intr_num) != INTR_TYPE_NS)
758 return SDEI_EDENY;
759
760 /*
761 * Interrupt programming and ownership transfer are deferred
762 * until register.
763 */
764
765 sdei_map_lock(map);
766 if (!is_map_bound(map)) {
767 map->intr = intr_num;
768 set_map_bound(map);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100769 retry = false;
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100770 }
771 sdei_map_unlock(map);
772 } while (retry);
773
774 return map->ev_num;
775}
776
777/* Release a bound SDEI event previously to an interrupt */
778static int sdei_interrupt_release(int ev_num)
779{
780 int ret = 0;
781 sdei_ev_map_t *map;
782 sdei_entry_t *se;
783
784 /* Check if valid event number */
785 map = find_event_map(ev_num);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100786 if (map == NULL)
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100787 return SDEI_EINVAL;
788
789 if (!is_map_dynamic(map))
790 return SDEI_EINVAL;
791
792 se = get_event_entry(map);
793
794 sdei_map_lock(map);
795
796 /* Event must have been unregistered before release */
797 if (map->reg_count != 0) {
798 ret = SDEI_EDENY;
799 goto finish;
800 }
801
802 /*
803 * Interrupt release never causes the state to change. We only check
804 * whether it's permissible or not.
805 */
806 if (!can_sdei_state_trans(se, DO_RELEASE)) {
807 ret = SDEI_EDENY;
808 goto finish;
809 }
810
811 if (is_map_bound(map)) {
812 /*
813 * Deny release if the interrupt is active, which means it's
814 * probably being acknowledged and handled elsewhere.
815 */
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100816 if (plat_ic_get_interrupt_active(map->intr) != 0U) {
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100817 ret = SDEI_EDENY;
818 goto finish;
819 }
820
821 /*
822 * Interrupt programming and ownership transfer are already done
823 * during unregister.
824 */
825
826 map->intr = SDEI_DYN_IRQ;
827 clr_map_bound(map);
828 } else {
829 SDEI_LOG("Error release bound:%d cnt:%d\n", is_map_bound(map),
830 map->reg_count);
831 ret = SDEI_EINVAL;
832 }
833
834finish:
835 sdei_map_unlock(map);
836
837 return ret;
838}
839
840/* Perform reset of private SDEI events */
841static int sdei_private_reset(void)
842{
843 sdei_ev_map_t *map;
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100844 int ret = 0, final_ret = 0;
845 unsigned int i;
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100846
847 /* Unregister all private events */
848 for_each_private_map(i, map) {
849 /*
850 * The unregister can fail if the event is not registered, which
851 * is allowed, and a deny will be returned. But if the event is
852 * running or unregister pending, the call fails.
853 */
854 ret = sdei_event_unregister(map->ev_num);
855 if ((ret == SDEI_EPEND) && (final_ret == 0))
Jeenu Viswambharanc94cf262017-11-30 10:25:10 +0000856 final_ret = SDEI_EDENY;
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100857 }
858
859 return final_ret;
860}
861
862/* Perform reset of shared SDEI events */
863static int sdei_shared_reset(void)
864{
865 const sdei_mapping_t *mapping;
866 sdei_ev_map_t *map;
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100867 int ret = 0, final_ret = 0;
868 unsigned int i, j;
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100869
870 /* Unregister all shared events */
871 for_each_shared_map(i, map) {
872 /*
873 * The unregister can fail if the event is not registered, which
874 * is allowed, and a deny will be returned. But if the event is
875 * running or unregister pending, the call fails.
876 */
877 ret = sdei_event_unregister(map->ev_num);
878 if ((ret == SDEI_EPEND) && (final_ret == 0))
Jeenu Viswambharanc94cf262017-11-30 10:25:10 +0000879 final_ret = SDEI_EDENY;
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100880 }
881
882 if (final_ret != 0)
883 return final_ret;
884
885 /*
886 * Loop through both private and shared mappings, and release all
887 * bindings.
888 */
889 for_each_mapping_type(i, mapping) {
890 iterate_mapping(mapping, j, map) {
891 /*
892 * Release bindings for mappings that are dynamic and
893 * bound.
894 */
895 if (is_map_dynamic(map) && is_map_bound(map)) {
896 /*
897 * Any failure to release would mean there is at
898 * least a PE registered for the event.
899 */
900 ret = sdei_interrupt_release(map->ev_num);
901 if ((ret != 0) && (final_ret == 0))
902 final_ret = ret;
903 }
904 }
905 }
906
907 return final_ret;
908}
909
910/* Send a signal to another SDEI client PE */
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100911static int sdei_signal(int ev_num, uint64_t target_pe)
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100912{
913 sdei_ev_map_t *map;
914
915 /* Only event 0 can be signalled */
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100916 if (ev_num != SDEI_EVENT_0)
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100917 return SDEI_EINVAL;
918
919 /* Find mapping for event 0 */
920 map = find_event_map(SDEI_EVENT_0);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100921 if (map == NULL)
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100922 return SDEI_EINVAL;
923
924 /* The event must be signalable */
925 if (!is_event_signalable(map))
926 return SDEI_EINVAL;
927
928 /* Validate target */
929 if (plat_core_pos_by_mpidr(target_pe) < 0)
930 return SDEI_EINVAL;
931
932 /* Raise SGI. Platform will validate target_pe */
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100933 plat_ic_raise_el3_sgi((int) map->intr, (u_register_t) target_pe);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100934
935 return 0;
936}
937
938/* Query SDEI dispatcher features */
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100939static uint64_t sdei_features(unsigned int feature)
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100940{
941 if (feature == SDEI_FEATURE_BIND_SLOTS) {
942 return FEATURE_BIND_SLOTS(num_dyn_priv_slots,
943 num_dyn_shrd_slots);
944 }
945
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100946 return (uint64_t) SDEI_EINVAL;
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100947}
948
949/* SDEI top level handler for servicing SMCs */
950uint64_t sdei_smc_handler(uint32_t smc_fid,
951 uint64_t x1,
952 uint64_t x2,
953 uint64_t x3,
954 uint64_t x4,
955 void *cookie,
956 void *handle,
957 uint64_t flags)
958{
959
960 uint64_t x5;
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100961 unsigned int ss = (unsigned int) get_interrupt_src_ss(flags);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100962 int64_t ret;
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100963 bool resume = false;
964 cpu_context_t *ctx = handle;
965 int ev_num = (int) x1;
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100966
967 if (ss != NON_SECURE)
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100968 SMC_RET1(ctx, SMC_UNK);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100969
970 /* Verify the caller EL */
971 if (GET_EL(read_spsr_el3()) != sdei_client_el())
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100972 SMC_RET1(ctx, SMC_UNK);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100973
974 switch (smc_fid) {
975 case SDEI_VERSION:
976 SDEI_LOG("> VER\n");
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100977 ret = (int64_t) sdei_version();
Scott Brandene5dcf982020-08-25 13:49:32 -0700978 SDEI_LOG("< VER:%" PRIx64 "\n", ret);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100979 SMC_RET1(ctx, ret);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100980
981 case SDEI_EVENT_REGISTER:
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100982 x5 = SMC_GET_GP(ctx, CTX_GPREG_X5);
Scott Brandene5dcf982020-08-25 13:49:32 -0700983 SDEI_LOG("> REG(n:%d e:%" PRIx64 " a:%" PRIx64 " f:%x m:%" PRIx64 "\n", ev_num,
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100984 x2, x3, (int) x4, x5);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100985 ret = sdei_event_register(ev_num, x2, x3, x4, x5);
Scott Brandene5dcf982020-08-25 13:49:32 -0700986 SDEI_LOG("< REG:%" PRId64 "\n", ret);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100987 SMC_RET1(ctx, ret);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100988
989 case SDEI_EVENT_ENABLE:
990 SDEI_LOG("> ENABLE(n:%d)\n", (int) x1);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100991 ret = sdei_event_enable(ev_num);
Scott Brandene5dcf982020-08-25 13:49:32 -0700992 SDEI_LOG("< ENABLE:%" PRId64 "\n", ret);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100993 SMC_RET1(ctx, ret);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +0100994
995 case SDEI_EVENT_DISABLE:
Vasyl Gomonovychab5d76b2021-09-01 10:30:55 -0700996 SDEI_LOG("> DISABLE(n:0x%x)\n", ev_num);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100997 ret = sdei_event_disable(ev_num);
Scott Brandene5dcf982020-08-25 13:49:32 -0700998 SDEI_LOG("< DISABLE:%" PRId64 "\n", ret);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +0100999 SMC_RET1(ctx, ret);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +01001000
1001 case SDEI_EVENT_CONTEXT:
1002 SDEI_LOG("> CTX(p:%d):%lx\n", (int) x1, read_mpidr_el1());
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001003 ret = sdei_event_context(ctx, (unsigned int) x1);
Scott Brandene5dcf982020-08-25 13:49:32 -07001004 SDEI_LOG("< CTX:%" PRId64 "\n", ret);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001005 SMC_RET1(ctx, ret);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +01001006
1007 case SDEI_EVENT_COMPLETE_AND_RESUME:
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001008 resume = true;
1009 /* Fallthrough */
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +01001010
1011 case SDEI_EVENT_COMPLETE:
Scott Brandene5dcf982020-08-25 13:49:32 -07001012 SDEI_LOG("> COMPLETE(r:%u sta/ep:%" PRIx64 "):%lx\n",
1013 (unsigned int) resume, x1, read_mpidr_el1());
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +01001014 ret = sdei_event_complete(resume, x1);
Scott Brandene5dcf982020-08-25 13:49:32 -07001015 SDEI_LOG("< COMPLETE:%" PRIx64 "\n", ret);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +01001016
1017 /*
1018 * Set error code only if the call failed. If the call
1019 * succeeded, we discard the dispatched context, and restore the
1020 * interrupted context to a pristine condition, and therefore
1021 * shouldn't be modified. We don't return to the caller in this
1022 * case anyway.
1023 */
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001024 if (ret != 0)
1025 SMC_RET1(ctx, ret);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +01001026
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001027 SMC_RET0(ctx);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +01001028
1029 case SDEI_EVENT_STATUS:
Vasyl Gomonovychab5d76b2021-09-01 10:30:55 -07001030 SDEI_LOG("> STAT(n:0x%x)\n", ev_num);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001031 ret = sdei_event_status(ev_num);
Scott Brandene5dcf982020-08-25 13:49:32 -07001032 SDEI_LOG("< STAT:%" PRId64 "\n", ret);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001033 SMC_RET1(ctx, ret);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +01001034
1035 case SDEI_EVENT_GET_INFO:
Vasyl Gomonovychab5d76b2021-09-01 10:30:55 -07001036 SDEI_LOG("> INFO(n:0x%x, %d)\n", ev_num, (int) x2);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001037 ret = sdei_event_get_info(ev_num, (int) x2);
Scott Brandene5dcf982020-08-25 13:49:32 -07001038 SDEI_LOG("< INFO:%" PRId64 "\n", ret);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001039 SMC_RET1(ctx, ret);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +01001040
1041 case SDEI_EVENT_UNREGISTER:
Vasyl Gomonovychab5d76b2021-09-01 10:30:55 -07001042 SDEI_LOG("> UNREG(n:0x%x)\n", ev_num);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001043 ret = sdei_event_unregister(ev_num);
Scott Brandene5dcf982020-08-25 13:49:32 -07001044 SDEI_LOG("< UNREG:%" PRId64 "\n", ret);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001045 SMC_RET1(ctx, ret);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +01001046
1047 case SDEI_PE_UNMASK:
1048 SDEI_LOG("> UNMASK:%lx\n", read_mpidr_el1());
1049 sdei_pe_unmask();
Jeenu Viswambharan22a16f92017-11-13 12:30:45 +00001050 SDEI_LOG("< UNMASK:%d\n", 0);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001051 SMC_RET1(ctx, 0);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +01001052
1053 case SDEI_PE_MASK:
1054 SDEI_LOG("> MASK:%lx\n", read_mpidr_el1());
1055 ret = sdei_pe_mask();
Scott Brandene5dcf982020-08-25 13:49:32 -07001056 SDEI_LOG("< MASK:%" PRId64 "\n", ret);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001057 SMC_RET1(ctx, ret);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +01001058
1059 case SDEI_INTERRUPT_BIND:
1060 SDEI_LOG("> BIND(%d)\n", (int) x1);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001061 ret = sdei_interrupt_bind((unsigned int) x1);
Scott Brandene5dcf982020-08-25 13:49:32 -07001062 SDEI_LOG("< BIND:%" PRId64 "\n", ret);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001063 SMC_RET1(ctx, ret);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +01001064
1065 case SDEI_INTERRUPT_RELEASE:
Vasyl Gomonovychab5d76b2021-09-01 10:30:55 -07001066 SDEI_LOG("> REL(0x%x)\n", ev_num);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001067 ret = sdei_interrupt_release(ev_num);
Scott Brandene5dcf982020-08-25 13:49:32 -07001068 SDEI_LOG("< REL:%" PRId64 "\n", ret);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001069 SMC_RET1(ctx, ret);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +01001070
1071 case SDEI_SHARED_RESET:
1072 SDEI_LOG("> S_RESET():%lx\n", read_mpidr_el1());
1073 ret = sdei_shared_reset();
Scott Brandene5dcf982020-08-25 13:49:32 -07001074 SDEI_LOG("< S_RESET:%" PRId64 "\n", ret);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001075 SMC_RET1(ctx, ret);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +01001076
1077 case SDEI_PRIVATE_RESET:
1078 SDEI_LOG("> P_RESET():%lx\n", read_mpidr_el1());
1079 ret = sdei_private_reset();
Scott Brandene5dcf982020-08-25 13:49:32 -07001080 SDEI_LOG("< P_RESET:%" PRId64 "\n", ret);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001081 SMC_RET1(ctx, ret);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +01001082
1083 case SDEI_EVENT_ROUTING_SET:
Scott Brandene5dcf982020-08-25 13:49:32 -07001084 SDEI_LOG("> ROUTE_SET(n:%d f:%" PRIx64 " aff:%" PRIx64 ")\n", ev_num, x2, x3);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001085 ret = sdei_event_routing_set(ev_num, x2, x3);
Scott Brandene5dcf982020-08-25 13:49:32 -07001086 SDEI_LOG("< ROUTE_SET:%" PRId64 "\n", ret);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001087 SMC_RET1(ctx, ret);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +01001088
1089 case SDEI_FEATURES:
Scott Brandene5dcf982020-08-25 13:49:32 -07001090 SDEI_LOG("> FTRS(f:%" PRIx64 ")\n", x1);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001091 ret = (int64_t) sdei_features((unsigned int) x1);
Scott Brandene5dcf982020-08-25 13:49:32 -07001092 SDEI_LOG("< FTRS:%" PRIx64 "\n", ret);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001093 SMC_RET1(ctx, ret);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +01001094
1095 case SDEI_EVENT_SIGNAL:
Scott Brandene5dcf982020-08-25 13:49:32 -07001096 SDEI_LOG("> SIGNAL(e:%d t:%" PRIx64 ")\n", ev_num, x2);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001097 ret = sdei_signal(ev_num, x2);
Scott Brandene5dcf982020-08-25 13:49:32 -07001098 SDEI_LOG("< SIGNAL:%" PRId64 "\n", ret);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001099 SMC_RET1(ctx, ret);
Jonathan Wright75a5d8b2018-03-14 15:56:21 +00001100
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +01001101 default:
Jonathan Wright75a5d8b2018-03-14 15:56:21 +00001102 /* Do nothing in default case */
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +01001103 break;
1104 }
1105
1106 WARN("Unimplemented SDEI Call: 0x%x\n", smc_fid);
Jeenu Viswambharan32ceef52018-08-02 10:14:12 +01001107 SMC_RET1(ctx, SMC_UNK);
Jeenu Viswambharan04e3a7f2017-10-16 08:43:14 +01001108}
1109
1110/* Subscribe to PSCI CPU on to initialize per-CPU SDEI configuration */
1111SUBSCRIBE_TO_EVENT(psci_cpu_on_finish, sdei_cpu_on_init);
Jeenu Viswambharanf5ee3832018-02-01 08:05:36 +00001112
1113/* Subscribe to PSCI CPU suspend finisher for per-CPU configuration */
1114SUBSCRIBE_TO_EVENT(psci_suspend_pwrdown_finish, sdei_cpu_wakeup_init);