1 /*
2 * Copyright (c) 2019-2022, Xilinx, Inc. All rights reserved.
3 * Copyright (c) 2022-2025, Advanced Micro Devices, Inc. All rights reserved.
4 *
5 * SPDX-License-Identifier: BSD-3-Clause
6 */
7
8 /*
9 * Versal system level PM-API functions and communication with PMC via
10 * IPI interrupts
11 */
12
13 #include <common/ep_info.h>
14 #include <common/debug.h>
15 #include <drivers/arm/gic_common.h>
16 #include <lib/mmio.h>
17 #include <lib/utils.h>
18 #include <plat/common/platform.h>
19 #include <platform_def.h>
20 #include <pm_api_sys.h>
21 #include <pm_client.h>
22 #include <pm_common.h>
23 #include <pm_defs.h>
24 #include <pm_ipi.h>
25 #include "pm_svc_main.h"
26
27 #define NUM_GICD_ISENABLER ((IRQ_MAX >> 5U) + 1U)
28
29 /* default shutdown/reboot scope is system(2) */
30 static uint32_t pm_shutdown_scope = XPM_SHUTDOWN_SUBTYPE_RST_SYSTEM;
31
32 /**
33 * pm_get_shutdown_scope() - Get the currently set shutdown scope.
34 *
35 * Return: Shutdown scope value.
36 *
37 */
pm_get_shutdown_scope(void)38 uint32_t pm_get_shutdown_scope(void)
39 {
40 return pm_shutdown_scope;
41 }
42
43 /* PM API functions */
44
45 /**
46 * pm_client_set_wakeup_sources - Set all devices with enabled interrupts as
47 * wake sources in the XilPM.
48 * @node_id: Node id of processor.
49 * @flag: 0 - Call from secure source.
50 * 1 - Call from non-secure source.
51 *
52 */
pm_client_set_wakeup_sources(uint32_t node_id,uint32_t flag)53 void pm_client_set_wakeup_sources(uint32_t node_id, uint32_t flag)
54 {
55 uint32_t reg_num, device_id;
56 uint8_t pm_wakeup_nodes_set[XPM_NODEIDX_DEV_MAX] = {0U};
57 uint32_t isenabler1 = PLAT_ARM_GICD_BASE + GICD_ISENABLER + 4U;
58
59 zeromem(&pm_wakeup_nodes_set, (u_register_t)sizeof(pm_wakeup_nodes_set));
60
61 for (reg_num = 0U; reg_num < NUM_GICD_ISENABLER; reg_num++) {
62 uint32_t base_irq = reg_num << ISENABLER_SHIFT;
63 uint32_t reg = mmio_read_32((uint64_t)(isenabler1 + (reg_num << 2)));
64
65 if (reg == 0U) {
66 continue;
67 }
68
69 while (reg != 0U) {
70 enum pm_device_node_idx node_idx;
71 uint32_t idx, irq, lowest_set = reg & (-reg);
72 enum pm_ret_status ret;
73
74 idx = (uint32_t)__builtin_ctz(lowest_set);
75 irq = base_irq + idx;
76
77 if (irq > IRQ_MAX) {
78 break;
79 }
80
81 node_idx = irq_to_pm_node_idx(irq);
82 reg &= ~lowest_set;
83
84 if (node_idx > XPM_NODEIDX_DEV_MIN) {
85 if (pm_wakeup_nodes_set[node_idx] == 0U) {
86 /* Get device ID from node index */
87 device_id = PERIPH_DEVID((uint32_t)node_idx);
88 ret = pm_set_wakeup_source(node_id,
89 device_id, 1U,
90 flag);
91 pm_wakeup_nodes_set[node_idx] = (ret == PM_RET_SUCCESS) ?
92 1U : 0U;
93 }
94 }
95 }
96 }
97 }
98
99 /**
100 * pm_handle_eemi_call() - PM call for processor to send eemi payload.
101 * @flag: 0 - Call from secure source.
102 * 1 - Call from non-secure source.
103 * @x0: Arguments received per SMC64 standard.
104 * @x1: Arguments received per SMC64 standard.
105 * @x2: Arguments received per SMC64 standard.
106 * @x3: Arguments received per SMC64 standard.
107 * @x4: Arguments received per SMC64 standard.
108 * @x5: Arguments received per SMC64 standard.
109 * @result: Payload received from firmware.
110 *
111 * Return: PM_RET_SUCCESS on success or error code.
112 *
113 */
pm_handle_eemi_call(uint32_t flag,uint32_t x0,uint32_t x1,uint32_t x2,uint32_t x3,uint32_t x4,uint32_t x5,uint32_t * result)114 enum pm_ret_status pm_handle_eemi_call(uint32_t flag, uint32_t x0, uint32_t x1,
115 uint32_t x2, uint32_t x3, uint32_t x4,
116 uint32_t x5, uint32_t *result)
117 {
118 uint32_t payload[PAYLOAD_ARG_CNT] = {0};
119 uint32_t module_id;
120
121 module_id = (x0 & MODULE_ID_MASK) >> 8U;
122
123 //default module id is for LIBPM
124 if (module_id == 0U) {
125 module_id = LIBPM_MODULE_ID;
126 }
127
128 PM_PACK_PAYLOAD6(payload, module_id, flag, x0, x1, x2, x3, x4, x5);
129 return pm_ipi_send_sync(primary_proc, payload, result, RET_PAYLOAD_ARG_CNT);
130 }
131
132 /**
133 * pm_self_suspend() - PM call for processor to suspend itself
134 * @nid: Node id of the processor or subsystem.
135 * @latency: Requested maximum wakeup latency (not supported).
136 * @state: Requested state.
137 * @address: Resume address.
138 * @flag: 0 - Call from secure source.
139 * 1 - Call from non-secure source.
140 *
141 * This is a blocking call, it will return only once PMU has responded.
142 * On a wakeup, resume address will be automatically set by PMU.
143 *
144 * Return: Returns status, either success or error+reason.
145 *
146 */
pm_self_suspend(uint32_t nid,uint32_t latency,uint32_t state,uintptr_t address,uint32_t flag)147 enum pm_ret_status pm_self_suspend(uint32_t nid,
148 uint32_t latency,
149 uint32_t state,
150 uintptr_t address, uint32_t flag)
151 {
152 uint32_t payload[PAYLOAD_ARG_CNT];
153 uint32_t cpuid = plat_my_core_pos();
154 const struct pm_proc *proc = pm_get_proc(cpuid);
155 enum pm_ret_status ret = PM_RET_ERROR_INTERNAL;
156
157 if (proc == NULL) {
158 WARN("Failed to get proc %d\n", cpuid);
159 goto exit_label;
160 }
161
162 /*
163 * Do client specific suspend operations
164 * (e.g. set powerdown request bit)
165 */
166 pm_client_suspend(proc, state, flag);
167
168 /* Send request to the PLM */
169 PM_PACK_PAYLOAD6(payload, LIBPM_MODULE_ID, flag, PM_SELF_SUSPEND,
170 nid, latency, state, address, (address >> 32));
171 ret = pm_ipi_send_sync(proc, payload, NULL, 0);
172
173 exit_label:
174 return ret;
175 }
176
177 /**
178 * pm_req_wakeup() - PM call for processor to wake up selected processor
179 * or subsystem.
180 * @target: Device ID of the processor or subsystem to wake up.
181 * @set_address: Resume address presence indicator.
182 * 1 - resume address specified, 0 - otherwise.
183 * @address: Resume address.
184 * @ack: Flag to specify whether acknowledge requested.
185 * @flag: 0 - Call from secure source.
186 * 1 - Call from non-secure source.
187 *
188 * This API function is either used to power up another APU core for SMP
189 * (by PSCI) or to power up an entirely different PU or subsystem, such
190 * as RPU0, RPU, or PL_CORE_xx. Resume address for the target PU will be
191 * automatically set by PMC.
192 *
193 * Return: Returns status, either success or error+reason.
194 *
195 */
pm_req_wakeup(uint32_t target,uint32_t set_address,uintptr_t address,uint8_t ack,uint32_t flag)196 enum pm_ret_status pm_req_wakeup(uint32_t target, uint32_t set_address,
197 uintptr_t address, uint8_t ack, uint32_t flag)
198 {
199 uint32_t payload[PAYLOAD_ARG_CNT];
200
201 /* Send request to the PMC to perform the wake of the PU */
202 PM_PACK_PAYLOAD5(payload, LIBPM_MODULE_ID, flag, PM_REQ_WAKEUP, target,
203 set_address, address, ack);
204
205 return pm_ipi_send_sync(primary_proc, payload, NULL, 0);
206 }
207
208 /**
209 * pm_get_callbackdata() - Read from IPI response buffer.
210 * @data: array of PAYLOAD_ARG_CNT elements.
211 * @count: Number of values to return.
212 * @flag: 0 - Call from secure source.
213 * 1 - Call from non-secure source.
214 * @ack: 0 - Do not ack IPI after reading payload.
215 * 1 - Ack IPI after reading payload.
216 *
217 * Read value from ipi buffer response buffer.
218 * Return: Returns status, either success or error.
219 *
220 */
pm_get_callbackdata(uint32_t * data,size_t count,uint32_t flag,uint32_t ack)221 enum pm_ret_status pm_get_callbackdata(uint32_t *data, size_t count, uint32_t flag, uint32_t ack)
222 {
223 enum pm_ret_status ret = PM_RET_SUCCESS;
224
225 /*
226 * Typecasting to void to intentionally retain the variable and avoid
227 * MISRA violation for unused parameters. This may be used in the
228 * future if callbacks to a secure target are required.
229 */
230 (void)flag;
231
232 /* Return if interrupt is not from PMU */
233 if (pm_ipi_irq_status(primary_proc) != 0U) {
234
235 ret = pm_ipi_buff_read_callb(data, count);
236
237 if (ack != 0U) {
238 pm_ipi_irq_clear(primary_proc);
239 }
240 }
241
242 return ret;
243 }
244
245 /**
246 * pm_force_powerdown() - PM call to request for another PU or subsystem to
247 * be powered down forcefully.
248 * @target: Device ID of the PU node to be forced powered down.
249 * @ack: Flag to specify whether acknowledge is requested
250 * @flag: 0 - Call from secure source
251 * 1 - Call from non-secure source
252 *
253 * Return: Returns status, either success or error+reason.
254 *
255 */
pm_force_powerdown(uint32_t target,uint8_t ack,uint32_t flag)256 enum pm_ret_status pm_force_powerdown(uint32_t target, uint8_t ack,
257 uint32_t flag)
258 {
259 uint32_t payload[PAYLOAD_ARG_CNT];
260 enum pm_ret_status ret = PM_RET_SUCCESS;
261
262 /* Send request to the PMC */
263 PM_PACK_PAYLOAD3(payload, LIBPM_MODULE_ID, flag, PM_FORCE_POWERDOWN,
264 target, ack);
265
266 if (ack == (uint32_t)IPI_BLOCKING) {
267 ret = pm_ipi_send_sync(primary_proc, payload, NULL, 0);
268 } else {
269 ret = pm_ipi_send(primary_proc, payload);
270 }
271
272 return ret;
273 }
274
275 /**
276 * pm_system_shutdown() - PM call to request a system shutdown or restart.
277 * @type: Shutdown or restart? 0=shutdown, 1=restart, 2=setscope.
278 * @subtype: Scope: 0=APU-subsystem, 1=PS, 2=system.
279 * @flag: 0 - Call from secure source.
280 * 1 - Call from non-secure source.
281 *
282 * Return: Returns status, either success or error+reason.
283 *
284 */
pm_system_shutdown(uint32_t type,uint32_t subtype,uint32_t flag)285 enum pm_ret_status pm_system_shutdown(uint32_t type, uint32_t subtype,
286 uint32_t flag)
287 {
288 uint32_t payload[PAYLOAD_ARG_CNT];
289 enum pm_ret_status ret = PM_RET_SUCCESS;
290
291 if (type == XPM_SHUTDOWN_TYPE_SETSCOPE_ONLY) {
292 /* Setting scope for subsequent PSCI reboot or shutdown */
293 pm_shutdown_scope = subtype;
294 goto exit_label;
295 }
296
297 /* Send request to the PMC */
298 PM_PACK_PAYLOAD3(payload, LIBPM_MODULE_ID, flag, PM_SYSTEM_SHUTDOWN,
299 type, subtype);
300
301 ret = pm_ipi_send_non_blocking(primary_proc, payload);
302
303 exit_label:
304 return ret;
305 }
306
307 /**
308 * pm_set_wakeup_source() - PM call to specify the wakeup source while
309 * suspended.
310 * @target: Device id of the targeted PU or subsystem
311 * @wkup_device: Device id of the wakeup peripheral
312 * @enable: Enable or disable the specified peripheral as wake source
313 * @flag: 0 - Call from secure source
314 * 1 - Call from non-secure source
315 *
316 * Return: Returns status, either success or error+reason.
317 *
318 */
pm_set_wakeup_source(uint32_t target,uint32_t wkup_device,uint8_t enable,uint32_t flag)319 enum pm_ret_status pm_set_wakeup_source(uint32_t target, uint32_t wkup_device,
320 uint8_t enable, uint32_t flag)
321 {
322 uint32_t payload[PAYLOAD_ARG_CNT];
323
324 PM_PACK_PAYLOAD4(payload, LIBPM_MODULE_ID, flag, PM_SET_WAKEUP_SOURCE,
325 target, wkup_device, enable);
326 return pm_ipi_send_sync(primary_proc, payload, NULL, 0);
327 }
328
329 /**
330 * tfa_api_feature_check() - Returns the supported TF-A API version if supported.
331 * @api_id: TF-A specific API ID to check.
332 * @ret_payload: pointer to array of PAYLOAD_ARG_CNT number of
333 * words Returned supported API version
334 *
335 * Return: Returns status, either success or error+reason.
336 */
tfa_api_feature_check(uint32_t api_id,uint32_t * ret_payload)337 enum pm_ret_status tfa_api_feature_check(uint32_t api_id, uint32_t *ret_payload)
338 {
339 enum pm_ret_status ret;
340
341 /* Return version of API which are implemented in TF-A only */
342 switch (api_id) {
343 case PM_GET_CALLBACK_DATA:
344 case PM_GET_TRUSTZONE_VERSION:
345 ret_payload[0] = PM_API_VERSION_2;
346 ret = PM_RET_SUCCESS;
347 break;
348 case TF_A_PM_REGISTER_SGI:
349 case TF_A_FEATURE_CHECK:
350 case TF_A_CLEAR_PM_STATE:
351 ret_payload[0] = PM_API_BASE_VERSION;
352 ret = PM_RET_SUCCESS;
353 break;
354 default:
355 ret = PM_RET_ERROR_NO_FEATURE;
356 break;
357 }
358
359 return ret;
360 }
361
362 /**
363 * pm_feature_check() - Returns the supported API version if supported.
364 * @api_id: API ID to check.
365 * @flag: 0 - Call from secure source.
366 * 1 - Call from non-secure source.
367 * @ret_payload: pointer to array of PAYLOAD_ARG_CNT number of
368 * words Returned supported API version and bitmasks
369 * for IOCTL and QUERY ID
370 *
371 * Return: Returns status, either success or error+reason.
372 *
373 */
pm_feature_check(uint32_t api_id,uint32_t * ret_payload,uint32_t flag)374 enum pm_ret_status pm_feature_check(uint32_t api_id, uint32_t *ret_payload,
375 uint32_t flag)
376 {
377 uint32_t payload[PAYLOAD_ARG_CNT];
378 uint32_t module_id;
379 enum pm_ret_status ret;
380 static bool deprecation_warned;
381
382 if (!deprecation_warned) {
383 WARN("%s will be deprecated in 2027.1 release. Use tfa_api_feature_check() for TF-A specific APIs.\n",
384 __func__);
385 deprecation_warned = true;
386 }
387
388 /* Return version of API which are implemented in TF-A only */
389 switch (api_id) {
390 case PM_GET_CALLBACK_DATA:
391 case PM_GET_TRUSTZONE_VERSION:
392 ret_payload[0] = PM_API_VERSION_2;
393 ret = PM_RET_SUCCESS;
394 break;
395 case TF_A_PM_REGISTER_SGI:
396 ret_payload[0] = PM_API_BASE_VERSION;
397 ret = PM_RET_SUCCESS;
398 break;
399 default:
400 module_id = (api_id & MODULE_ID_MASK) >> 8U;
401
402 /*
403 * feature check should be done only for LIBPM module
404 * If module_id is 0, then we consider it LIBPM module as default id
405 */
406 if ((module_id > 0U) && (module_id != LIBPM_MODULE_ID)) {
407 ret = PM_RET_SUCCESS;
408 break;
409 }
410
411 PM_PACK_PAYLOAD2(payload, LIBPM_MODULE_ID, flag,
412 PM_FEATURE_CHECK, api_id);
413 ret = pm_ipi_send_sync(primary_proc, payload, ret_payload, RET_PAYLOAD_ARG_CNT);
414
415 break;
416 }
417
418 return ret;
419 }
420
421 /**
422 * pm_load_pdi() - Load the PDI. This function provides support to load
423 * PDI from linux.
424 *
425 * @src: Source device of pdi(DDR, OCM, SD etc).
426 * @address_low: lower 32-bit Linear memory space address.
427 * @address_high: higher 32-bit Linear memory space address.
428 * @flag: 0 - Call from secure source.
429 * 1 - Call from non-secure source.
430 *
431 * Return: Returns status, either success or error+reason.
432 *
433 */
pm_load_pdi(uint32_t src,uint32_t address_low,uint32_t address_high,uint32_t flag)434 enum pm_ret_status pm_load_pdi(uint32_t src, uint32_t address_low,
435 uint32_t address_high, uint32_t flag)
436 {
437 uint32_t payload[PAYLOAD_ARG_CNT];
438
439 /* Send request to the PMU */
440 PM_PACK_PAYLOAD4(payload, LOADER_MODULE_ID, flag, PM_LOAD_PDI, src,
441 address_high, address_low);
442 return pm_ipi_send_sync(primary_proc, payload, NULL, 0);
443 }
444
445 /**
446 * pm_register_notifier() - PM call to register a subsystem to be notified
447 * about the device event.
448 * @device_id: Device ID for the Node to which the event is related.
449 * @event: Event in question.
450 * @wake: Wake subsystem upon capturing the event if value 1.
451 * @enable: Enable the registration for value 1, disable for value 0.
452 * @flag: 0 - Call from secure source.
453 * 1 - Call from non-secure source.
454 *
455 * Return: Returns status, either success or error+reason.
456 *
457 */
pm_register_notifier(uint32_t device_id,uint32_t event,uint32_t wake,uint32_t enable,uint32_t flag)458 enum pm_ret_status pm_register_notifier(uint32_t device_id, uint32_t event,
459 uint32_t wake, uint32_t enable,
460 uint32_t flag)
461 {
462 uint32_t payload[PAYLOAD_ARG_CNT];
463
464 /* Send request to the PMC */
465 PM_PACK_PAYLOAD5(payload, LIBPM_MODULE_ID, flag, PM_REGISTER_NOTIFIER,
466 device_id, event, wake, enable);
467
468 return pm_ipi_send_sync(primary_proc, payload, NULL, 0);
469 }
470
471 /**
472 * pm_get_chipid() - Read silicon ID registers.
473 * @value: Buffer for two 32bit words.
474 *
475 * Return: Returns status, either success or error+reason and,
476 * optionally, @value.
477 */
pm_get_chipid(uint32_t * value)478 enum pm_ret_status pm_get_chipid(uint32_t *value)
479 {
480 uint32_t payload[PAYLOAD_ARG_CNT];
481
482 PM_PACK_PAYLOAD1(payload, LIBPM_MODULE_ID, SECURE, PM_GET_CHIPID);
483
484 return pm_ipi_send_sync(primary_proc, payload, value, 2);
485 }
486