Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Xilinx Zynq MPSoC Firmware layer
4 *
5 * Copyright (C) 2014-2020 Xilinx, Inc.
6 *
7 * Michal Simek <michal.simek@xilinx.com>
8 * Davorin Mista <davorin.mista@aggios.com>
9 * Jolly Shah <jollys@xilinx.com>
10 * Rajan Vaja <rajanv@xilinx.com>
11 */
12
13#include <linux/arm-smccc.h>
14#include <linux/compiler.h>
15#include <linux/device.h>
16#include <linux/init.h>
17#include <linux/mfd/core.h>
18#include <linux/module.h>
19#include <linux/of.h>
20#include <linux/of_platform.h>
21#include <linux/slab.h>
22#include <linux/uaccess.h>
23
24#include <linux/firmware/xlnx-zynqmp.h>
25#include "zynqmp-debug.h"
26
27static bool feature_check_enabled;
28static u32 zynqmp_pm_features[PM_API_MAX];
29
30static const struct mfd_cell firmware_devs[] = {
31 {
32 .name = "zynqmp_power_controller",
33 },
34};
35
36/**
37 * zynqmp_pm_ret_code() - Convert PMU-FW error codes to Linux error codes
38 * @ret_status: PMUFW return code
39 *
40 * Return: corresponding Linux error code
41 */
42static int zynqmp_pm_ret_code(u32 ret_status)
43{
44 switch (ret_status) {
45 case XST_PM_SUCCESS:
46 case XST_PM_DOUBLE_REQ:
47 return 0;
48 case XST_PM_NO_FEATURE:
49 return -ENOTSUPP;
50 case XST_PM_NO_ACCESS:
51 return -EACCES;
52 case XST_PM_ABORT_SUSPEND:
53 return -ECANCELED;
54 case XST_PM_MULT_USER:
55 return -EUSERS;
56 case XST_PM_INTERNAL:
57 case XST_PM_CONFLICT:
58 case XST_PM_INVALID_NODE:
59 default:
60 return -EINVAL;
61 }
62}
63
64static noinline int do_fw_call_fail(u64 arg0, u64 arg1, u64 arg2,
65 u32 *ret_payload)
66{
67 return -ENODEV;
68}
69
70/*
71 * PM function call wrapper
72 * Invoke do_fw_call_smc or do_fw_call_hvc, depending on the configuration
73 */
74static int (*do_fw_call)(u64, u64, u64, u32 *ret_payload) = do_fw_call_fail;
75
76/**
77 * do_fw_call_smc() - Call system-level platform management layer (SMC)
78 * @arg0: Argument 0 to SMC call
79 * @arg1: Argument 1 to SMC call
80 * @arg2: Argument 2 to SMC call
81 * @ret_payload: Returned value array
82 *
83 * Invoke platform management function via SMC call (no hypervisor present).
84 *
85 * Return: Returns status, either success or error+reason
86 */
87static noinline int do_fw_call_smc(u64 arg0, u64 arg1, u64 arg2,
88 u32 *ret_payload)
89{
90 struct arm_smccc_res res;
91
92 arm_smccc_smc(arg0, arg1, arg2, 0, 0, 0, 0, 0, &res);
93
94 if (ret_payload) {
95 ret_payload[0] = lower_32_bits(res.a0);
96 ret_payload[1] = upper_32_bits(res.a0);
97 ret_payload[2] = lower_32_bits(res.a1);
98 ret_payload[3] = upper_32_bits(res.a1);
99 }
100
101 return zynqmp_pm_ret_code((enum pm_ret_status)res.a0);
102}
103
104/**
105 * do_fw_call_hvc() - Call system-level platform management layer (HVC)
106 * @arg0: Argument 0 to HVC call
107 * @arg1: Argument 1 to HVC call
108 * @arg2: Argument 2 to HVC call
109 * @ret_payload: Returned value array
110 *
111 * Invoke platform management function via HVC
112 * HVC-based for communication through hypervisor
113 * (no direct communication with ATF).
114 *
115 * Return: Returns status, either success or error+reason
116 */
117static noinline int do_fw_call_hvc(u64 arg0, u64 arg1, u64 arg2,
118 u32 *ret_payload)
119{
120 struct arm_smccc_res res;
121
122 arm_smccc_hvc(arg0, arg1, arg2, 0, 0, 0, 0, 0, &res);
123
124 if (ret_payload) {
125 ret_payload[0] = lower_32_bits(res.a0);
126 ret_payload[1] = upper_32_bits(res.a0);
127 ret_payload[2] = lower_32_bits(res.a1);
128 ret_payload[3] = upper_32_bits(res.a1);
129 }
130
131 return zynqmp_pm_ret_code((enum pm_ret_status)res.a0);
132}
133
134/**
135 * zynqmp_pm_feature() - Check weather given feature is supported or not
136 * @api_id: API ID to check
137 *
138 * Return: Returns status, either success or error+reason
139 */
140static int zynqmp_pm_feature(u32 api_id)
141{
142 int ret;
143 u32 ret_payload[PAYLOAD_ARG_CNT];
144 u64 smc_arg[2];
145
146 if (!feature_check_enabled)
147 return 0;
148
149 /* Return value if feature is already checked */
150 if (zynqmp_pm_features[api_id] != PM_FEATURE_UNCHECKED)
151 return zynqmp_pm_features[api_id];
152
153 smc_arg[0] = PM_SIP_SVC | PM_FEATURE_CHECK;
154 smc_arg[1] = api_id;
155
156 ret = do_fw_call(smc_arg[0], smc_arg[1], 0, ret_payload);
157 if (ret) {
158 zynqmp_pm_features[api_id] = PM_FEATURE_INVALID;
159 return PM_FEATURE_INVALID;
160 }
161
162 zynqmp_pm_features[api_id] = ret_payload[1];
163
164 return zynqmp_pm_features[api_id];
165}
166
167/**
168 * zynqmp_pm_invoke_fn() - Invoke the system-level platform management layer
169 * caller function depending on the configuration
170 * @pm_api_id: Requested PM-API call
171 * @arg0: Argument 0 to requested PM-API call
172 * @arg1: Argument 1 to requested PM-API call
173 * @arg2: Argument 2 to requested PM-API call
174 * @arg3: Argument 3 to requested PM-API call
175 * @ret_payload: Returned value array
176 *
177 * Invoke platform management function for SMC or HVC call, depending on
178 * configuration.
179 * Following SMC Calling Convention (SMCCC) for SMC64:
180 * Pm Function Identifier,
181 * PM_SIP_SVC + PM_API_ID =
182 * ((SMC_TYPE_FAST << FUNCID_TYPE_SHIFT)
183 * ((SMC_64) << FUNCID_CC_SHIFT)
184 * ((SIP_START) << FUNCID_OEN_SHIFT)
185 * ((PM_API_ID) & FUNCID_NUM_MASK))
186 *
187 * PM_SIP_SVC - Registered ZynqMP SIP Service Call.
188 * PM_API_ID - Platform Management API ID.
189 *
190 * Return: Returns status, either success or error+reason
191 */
192int zynqmp_pm_invoke_fn(u32 pm_api_id, u32 arg0, u32 arg1,
193 u32 arg2, u32 arg3, u32 *ret_payload)
194{
195 /*
196 * Added SIP service call Function Identifier
197 * Make sure to stay in x0 register
198 */
199 u64 smc_arg[4];
200
201 if (zynqmp_pm_feature(pm_api_id) == PM_FEATURE_INVALID)
202 return -ENOTSUPP;
203
204 smc_arg[0] = PM_SIP_SVC | pm_api_id;
205 smc_arg[1] = ((u64)arg1 << 32) | arg0;
206 smc_arg[2] = ((u64)arg3 << 32) | arg2;
207
208 return do_fw_call(smc_arg[0], smc_arg[1], smc_arg[2], ret_payload);
209}
210
211static u32 pm_api_version;
212static u32 pm_tz_version;
213
214/**
215 * zynqmp_pm_get_api_version() - Get version number of PMU PM firmware
216 * @version: Returned version value
217 *
218 * Return: Returns status, either success or error+reason
219 */
220int zynqmp_pm_get_api_version(u32 *version)
221{
222 u32 ret_payload[PAYLOAD_ARG_CNT];
223 int ret;
224
225 if (!version)
226 return -EINVAL;
227
228 /* Check is PM API version already verified */
229 if (pm_api_version > 0) {
230 *version = pm_api_version;
231 return 0;
232 }
233 ret = zynqmp_pm_invoke_fn(PM_GET_API_VERSION, 0, 0, 0, 0, ret_payload);
234 *version = ret_payload[1];
235
236 return ret;
237}
238EXPORT_SYMBOL_GPL(zynqmp_pm_get_api_version);
239
240/**
241 * zynqmp_pm_get_chipid - Get silicon ID registers
242 * @idcode: IDCODE register
243 * @version: version register
244 *
245 * Return: Returns the status of the operation and the idcode and version
246 * registers in @idcode and @version.
247 */
248int zynqmp_pm_get_chipid(u32 *idcode, u32 *version)
249{
250 u32 ret_payload[PAYLOAD_ARG_CNT];
251 int ret;
252
253 if (!idcode || !version)
254 return -EINVAL;
255
256 ret = zynqmp_pm_invoke_fn(PM_GET_CHIPID, 0, 0, 0, 0, ret_payload);
257 *idcode = ret_payload[1];
258 *version = ret_payload[2];
259
260 return ret;
261}
262EXPORT_SYMBOL_GPL(zynqmp_pm_get_chipid);
263
264/**
265 * zynqmp_pm_get_trustzone_version() - Get secure trustzone firmware version
266 * @version: Returned version value
267 *
268 * Return: Returns status, either success or error+reason
269 */
270static int zynqmp_pm_get_trustzone_version(u32 *version)
271{
272 u32 ret_payload[PAYLOAD_ARG_CNT];
273 int ret;
274
275 if (!version)
276 return -EINVAL;
277
278 /* Check is PM trustzone version already verified */
279 if (pm_tz_version > 0) {
280 *version = pm_tz_version;
281 return 0;
282 }
283 ret = zynqmp_pm_invoke_fn(PM_GET_TRUSTZONE_VERSION, 0, 0,
284 0, 0, ret_payload);
285 *version = ret_payload[1];
286
287 return ret;
288}
289
290/**
291 * get_set_conduit_method() - Choose SMC or HVC based communication
292 * @np: Pointer to the device_node structure
293 *
294 * Use SMC or HVC-based functions to communicate with EL2/EL3.
295 *
296 * Return: Returns 0 on success or error code
297 */
298static int get_set_conduit_method(struct device_node *np)
299{
300 const char *method;
301
302 if (of_property_read_string(np, "method", &method)) {
303 pr_warn("%s missing \"method\" property\n", __func__);
304 return -ENXIO;
305 }
306
307 if (!strcmp("hvc", method)) {
308 do_fw_call = do_fw_call_hvc;
309 } else if (!strcmp("smc", method)) {
310 do_fw_call = do_fw_call_smc;
311 } else {
312 pr_warn("%s Invalid \"method\" property: %s\n",
313 __func__, method);
314 return -EINVAL;
315 }
316
317 return 0;
318}
319
320/**
321 * zynqmp_pm_query_data() - Get query data from firmware
322 * @qdata: Variable to the zynqmp_pm_query_data structure
323 * @out: Returned output value
324 *
325 * Return: Returns status, either success or error+reason
326 */
327int zynqmp_pm_query_data(struct zynqmp_pm_query_data qdata, u32 *out)
328{
329 int ret;
330
331 ret = zynqmp_pm_invoke_fn(PM_QUERY_DATA, qdata.qid, qdata.arg1,
332 qdata.arg2, qdata.arg3, out);
333
334 /*
335 * For clock name query, all bytes in SMC response are clock name
336 * characters and return code is always success. For invalid clocks,
337 * clock name bytes would be zeros.
338 */
339 return qdata.qid == PM_QID_CLOCK_GET_NAME ? 0 : ret;
340}
341EXPORT_SYMBOL_GPL(zynqmp_pm_query_data);
342
343/**
344 * zynqmp_pm_clock_enable() - Enable the clock for given id
345 * @clock_id: ID of the clock to be enabled
346 *
347 * This function is used by master to enable the clock
348 * including peripherals and PLL clocks.
349 *
350 * Return: Returns status, either success or error+reason
351 */
352int zynqmp_pm_clock_enable(u32 clock_id)
353{
354 return zynqmp_pm_invoke_fn(PM_CLOCK_ENABLE, clock_id, 0, 0, 0, NULL);
355}
356EXPORT_SYMBOL_GPL(zynqmp_pm_clock_enable);
357
358/**
359 * zynqmp_pm_clock_disable() - Disable the clock for given id
360 * @clock_id: ID of the clock to be disable
361 *
362 * This function is used by master to disable the clock
363 * including peripherals and PLL clocks.
364 *
365 * Return: Returns status, either success or error+reason
366 */
367int zynqmp_pm_clock_disable(u32 clock_id)
368{
369 return zynqmp_pm_invoke_fn(PM_CLOCK_DISABLE, clock_id, 0, 0, 0, NULL);
370}
371EXPORT_SYMBOL_GPL(zynqmp_pm_clock_disable);
372
373/**
374 * zynqmp_pm_clock_getstate() - Get the clock state for given id
375 * @clock_id: ID of the clock to be queried
376 * @state: 1/0 (Enabled/Disabled)
377 *
378 * This function is used by master to get the state of clock
379 * including peripherals and PLL clocks.
380 *
381 * Return: Returns status, either success or error+reason
382 */
383int zynqmp_pm_clock_getstate(u32 clock_id, u32 *state)
384{
385 u32 ret_payload[PAYLOAD_ARG_CNT];
386 int ret;
387
388 ret = zynqmp_pm_invoke_fn(PM_CLOCK_GETSTATE, clock_id, 0,
389 0, 0, ret_payload);
390 *state = ret_payload[1];
391
392 return ret;
393}
394EXPORT_SYMBOL_GPL(zynqmp_pm_clock_getstate);
395
396/**
397 * zynqmp_pm_clock_setdivider() - Set the clock divider for given id
398 * @clock_id: ID of the clock
399 * @divider: divider value
400 *
401 * This function is used by master to set divider for any clock
402 * to achieve desired rate.
403 *
404 * Return: Returns status, either success or error+reason
405 */
406int zynqmp_pm_clock_setdivider(u32 clock_id, u32 divider)
407{
408 return zynqmp_pm_invoke_fn(PM_CLOCK_SETDIVIDER, clock_id, divider,
409 0, 0, NULL);
410}
411EXPORT_SYMBOL_GPL(zynqmp_pm_clock_setdivider);
412
413/**
414 * zynqmp_pm_clock_getdivider() - Get the clock divider for given id
415 * @clock_id: ID of the clock
416 * @divider: divider value
417 *
418 * This function is used by master to get divider values
419 * for any clock.
420 *
421 * Return: Returns status, either success or error+reason
422 */
423int zynqmp_pm_clock_getdivider(u32 clock_id, u32 *divider)
424{
425 u32 ret_payload[PAYLOAD_ARG_CNT];
426 int ret;
427
428 ret = zynqmp_pm_invoke_fn(PM_CLOCK_GETDIVIDER, clock_id, 0,
429 0, 0, ret_payload);
430 *divider = ret_payload[1];
431
432 return ret;
433}
434EXPORT_SYMBOL_GPL(zynqmp_pm_clock_getdivider);
435
436/**
437 * zynqmp_pm_clock_setrate() - Set the clock rate for given id
438 * @clock_id: ID of the clock
439 * @rate: rate value in hz
440 *
441 * This function is used by master to set rate for any clock.
442 *
443 * Return: Returns status, either success or error+reason
444 */
445int zynqmp_pm_clock_setrate(u32 clock_id, u64 rate)
446{
447 return zynqmp_pm_invoke_fn(PM_CLOCK_SETRATE, clock_id,
448 lower_32_bits(rate),
449 upper_32_bits(rate),
450 0, NULL);
451}
452EXPORT_SYMBOL_GPL(zynqmp_pm_clock_setrate);
453
454/**
455 * zynqmp_pm_clock_getrate() - Get the clock rate for given id
456 * @clock_id: ID of the clock
457 * @rate: rate value in hz
458 *
459 * This function is used by master to get rate
460 * for any clock.
461 *
462 * Return: Returns status, either success or error+reason
463 */
464int zynqmp_pm_clock_getrate(u32 clock_id, u64 *rate)
465{
466 u32 ret_payload[PAYLOAD_ARG_CNT];
467 int ret;
468
469 ret = zynqmp_pm_invoke_fn(PM_CLOCK_GETRATE, clock_id, 0,
470 0, 0, ret_payload);
471 *rate = ((u64)ret_payload[2] << 32) | ret_payload[1];
472
473 return ret;
474}
475EXPORT_SYMBOL_GPL(zynqmp_pm_clock_getrate);
476
477/**
478 * zynqmp_pm_clock_setparent() - Set the clock parent for given id
479 * @clock_id: ID of the clock
480 * @parent_id: parent id
481 *
482 * This function is used by master to set parent for any clock.
483 *
484 * Return: Returns status, either success or error+reason
485 */
486int zynqmp_pm_clock_setparent(u32 clock_id, u32 parent_id)
487{
488 return zynqmp_pm_invoke_fn(PM_CLOCK_SETPARENT, clock_id,
489 parent_id, 0, 0, NULL);
490}
491EXPORT_SYMBOL_GPL(zynqmp_pm_clock_setparent);
492
493/**
494 * zynqmp_pm_clock_getparent() - Get the clock parent for given id
495 * @clock_id: ID of the clock
496 * @parent_id: parent id
497 *
498 * This function is used by master to get parent index
499 * for any clock.
500 *
501 * Return: Returns status, either success or error+reason
502 */
503int zynqmp_pm_clock_getparent(u32 clock_id, u32 *parent_id)
504{
505 u32 ret_payload[PAYLOAD_ARG_CNT];
506 int ret;
507
508 ret = zynqmp_pm_invoke_fn(PM_CLOCK_GETPARENT, clock_id, 0,
509 0, 0, ret_payload);
510 *parent_id = ret_payload[1];
511
512 return ret;
513}
514EXPORT_SYMBOL_GPL(zynqmp_pm_clock_getparent);
515
516/**
517 * zynqmp_pm_set_pll_frac_mode() - PM API for set PLL mode
518 *
519 * @clk_id: PLL clock ID
520 * @mode: PLL mode (PLL_MODE_FRAC/PLL_MODE_INT)
521 *
522 * This function sets PLL mode
523 *
524 * Return: Returns status, either success or error+reason
525 */
526int zynqmp_pm_set_pll_frac_mode(u32 clk_id, u32 mode)
527{
528 return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_SET_PLL_FRAC_MODE,
529 clk_id, mode, NULL);
530}
531EXPORT_SYMBOL_GPL(zynqmp_pm_set_pll_frac_mode);
532
533/**
534 * zynqmp_pm_get_pll_frac_mode() - PM API for get PLL mode
535 *
536 * @clk_id: PLL clock ID
537 * @mode: PLL mode
538 *
539 * This function return current PLL mode
540 *
541 * Return: Returns status, either success or error+reason
542 */
543int zynqmp_pm_get_pll_frac_mode(u32 clk_id, u32 *mode)
544{
545 return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_GET_PLL_FRAC_MODE,
546 clk_id, 0, mode);
547}
548EXPORT_SYMBOL_GPL(zynqmp_pm_get_pll_frac_mode);
549
550/**
551 * zynqmp_pm_set_pll_frac_data() - PM API for setting pll fraction data
552 *
553 * @clk_id: PLL clock ID
554 * @data: fraction data
555 *
556 * This function sets fraction data.
557 * It is valid for fraction mode only.
558 *
559 * Return: Returns status, either success or error+reason
560 */
561int zynqmp_pm_set_pll_frac_data(u32 clk_id, u32 data)
562{
563 return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_SET_PLL_FRAC_DATA,
564 clk_id, data, NULL);
565}
566EXPORT_SYMBOL_GPL(zynqmp_pm_set_pll_frac_data);
567
568/**
569 * zynqmp_pm_get_pll_frac_data() - PM API for getting pll fraction data
570 *
571 * @clk_id: PLL clock ID
572 * @data: fraction data
573 *
574 * This function returns fraction data value.
575 *
576 * Return: Returns status, either success or error+reason
577 */
578int zynqmp_pm_get_pll_frac_data(u32 clk_id, u32 *data)
579{
580 return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_GET_PLL_FRAC_DATA,
581 clk_id, 0, data);
582}
583EXPORT_SYMBOL_GPL(zynqmp_pm_get_pll_frac_data);
584
585/**
586 * zynqmp_pm_set_sd_tapdelay() - Set tap delay for the SD device
587 *
588 * @node_id Node ID of the device
589 * @type Type of tap delay to set (input/output)
590 * @value Value to set fot the tap delay
591 *
592 * This function sets input/output tap delay for the SD device.
593 *
594 * @return Returns status, either success or error+reason
595 */
596int zynqmp_pm_set_sd_tapdelay(u32 node_id, u32 type, u32 value)
597{
598 return zynqmp_pm_invoke_fn(PM_IOCTL, node_id, IOCTL_SET_SD_TAPDELAY,
599 type, value, NULL);
600}
601EXPORT_SYMBOL_GPL(zynqmp_pm_set_sd_tapdelay);
602
603/**
604 * zynqmp_pm_sd_dll_reset() - Reset DLL logic
605 *
606 * @node_id Node ID of the device
607 * @type Reset type
608 *
609 * This function resets DLL logic for the SD device.
610 *
611 * @return Returns status, either success or error+reason
612 */
613int zynqmp_pm_sd_dll_reset(u32 node_id, u32 type)
614{
615 return zynqmp_pm_invoke_fn(PM_IOCTL, node_id, IOCTL_SET_SD_TAPDELAY,
616 type, 0, NULL);
617}
618EXPORT_SYMBOL_GPL(zynqmp_pm_sd_dll_reset);
619
620/**
621 * zynqmp_pm_write_ggs() - PM API for writing global general storage (ggs)
622 * @index GGS register index
623 * @value Register value to be written
624 *
625 * This function writes value to GGS register.
626 *
627 * @return Returns status, either success or error+reason
628 */
629int zynqmp_pm_write_ggs(u32 index, u32 value)
630{
631 return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_WRITE_GGS,
632 index, value, NULL);
633}
634EXPORT_SYMBOL_GPL(zynqmp_pm_write_ggs);
635
636/**
637 * zynqmp_pm_write_ggs() - PM API for reading global general storage (ggs)
638 * @index GGS register index
639 * @value Register value to be written
640 *
641 * This function returns GGS register value.
642 *
643 * @return Returns status, either success or error+reason
644 */
645int zynqmp_pm_read_ggs(u32 index, u32 *value)
646{
647 return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_READ_GGS,
648 index, 0, value);
649}
650EXPORT_SYMBOL_GPL(zynqmp_pm_read_ggs);
651
652/**
653 * zynqmp_pm_write_pggs() - PM API for writing persistent global general
654 * storage (pggs)
655 * @index PGGS register index
656 * @value Register value to be written
657 *
658 * This function writes value to PGGS register.
659 *
660 * @return Returns status, either success or error+reason
661 */
662int zynqmp_pm_write_pggs(u32 index, u32 value)
663{
664 return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_WRITE_PGGS, index, value,
665 NULL);
666}
667EXPORT_SYMBOL_GPL(zynqmp_pm_write_pggs);
668
669/**
670 * zynqmp_pm_write_pggs() - PM API for reading persistent global general
671 * storage (pggs)
672 * @index PGGS register index
673 * @value Register value to be written
674 *
675 * This function returns PGGS register value.
676 *
677 * @return Returns status, either success or error+reason
678 */
679int zynqmp_pm_read_pggs(u32 index, u32 *value)
680{
681 return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_READ_PGGS, index, 0,
682 value);
683}
684EXPORT_SYMBOL_GPL(zynqmp_pm_read_pggs);
685
686/**
687 * zynqmp_pm_set_boot_health_status() - PM API for setting healthy boot status
688 * @value Status value to be written
689 *
690 * This function sets healthy bit value to indicate boot health status
691 * to firmware.
692 *
693 * @return Returns status, either success or error+reason
694 */
695int zynqmp_pm_set_boot_health_status(u32 value)
696{
697 return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_SET_BOOT_HEALTH_STATUS,
698 value, 0, NULL);
699}
700
701/**
702 * zynqmp_pm_reset_assert - Request setting of reset (1 - assert, 0 - release)
703 * @reset: Reset to be configured
704 * @assert_flag: Flag stating should reset be asserted (1) or
705 * released (0)
706 *
707 * Return: Returns status, either success or error+reason
708 */
709int zynqmp_pm_reset_assert(const enum zynqmp_pm_reset reset,
710 const enum zynqmp_pm_reset_action assert_flag)
711{
712 return zynqmp_pm_invoke_fn(PM_RESET_ASSERT, reset, assert_flag,
713 0, 0, NULL);
714}
715EXPORT_SYMBOL_GPL(zynqmp_pm_reset_assert);
716
717/**
718 * zynqmp_pm_reset_get_status - Get status of the reset
719 * @reset: Reset whose status should be returned
720 * @status: Returned status
721 *
722 * Return: Returns status, either success or error+reason
723 */
724int zynqmp_pm_reset_get_status(const enum zynqmp_pm_reset reset, u32 *status)
725{
726 u32 ret_payload[PAYLOAD_ARG_CNT];
727 int ret;
728
729 if (!status)
730 return -EINVAL;
731
732 ret = zynqmp_pm_invoke_fn(PM_RESET_GET_STATUS, reset, 0,
733 0, 0, ret_payload);
734 *status = ret_payload[1];
735
736 return ret;
737}
738EXPORT_SYMBOL_GPL(zynqmp_pm_reset_get_status);
739
740/**
741 * zynqmp_pm_fpga_load - Perform the fpga load
742 * @address: Address to write to
743 * @size: pl bitstream size
744 * @flags: Bitstream type
745 * -XILINX_ZYNQMP_PM_FPGA_FULL: FPGA full reconfiguration
746 * -XILINX_ZYNQMP_PM_FPGA_PARTIAL: FPGA partial reconfiguration
747 *
748 * This function provides access to pmufw. To transfer
749 * the required bitstream into PL.
750 *
751 * Return: Returns status, either success or error+reason
752 */
753int zynqmp_pm_fpga_load(const u64 address, const u32 size, const u32 flags)
754{
755 return zynqmp_pm_invoke_fn(PM_FPGA_LOAD, lower_32_bits(address),
756 upper_32_bits(address), size, flags, NULL);
757}
758EXPORT_SYMBOL_GPL(zynqmp_pm_fpga_load);
759
760/**
761 * zynqmp_pm_fpga_get_status - Read value from PCAP status register
762 * @value: Value to read
763 *
764 * This function provides access to the pmufw to get the PCAP
765 * status
766 *
767 * Return: Returns status, either success or error+reason
768 */
769int zynqmp_pm_fpga_get_status(u32 *value)
770{
771 u32 ret_payload[PAYLOAD_ARG_CNT];
772 int ret;
773
774 if (!value)
775 return -EINVAL;
776
777 ret = zynqmp_pm_invoke_fn(PM_FPGA_GET_STATUS, 0, 0, 0, 0, ret_payload);
778 *value = ret_payload[1];
779
780 return ret;
781}
782EXPORT_SYMBOL_GPL(zynqmp_pm_fpga_get_status);
783
784/**
785 * zynqmp_pm_init_finalize() - PM call to inform firmware that the caller
786 * master has initialized its own power management
787 *
788 * This API function is to be used for notify the power management controller
789 * about the completed power management initialization.
790 *
791 * Return: Returns status, either success or error+reason
792 */
793int zynqmp_pm_init_finalize(void)
794{
795 return zynqmp_pm_invoke_fn(PM_PM_INIT_FINALIZE, 0, 0, 0, 0, NULL);
796}
797EXPORT_SYMBOL_GPL(zynqmp_pm_init_finalize);
798
799/**
800 * zynqmp_pm_set_suspend_mode() - Set system suspend mode
801 * @mode: Mode to set for system suspend
802 *
803 * This API function is used to set mode of system suspend.
804 *
805 * Return: Returns status, either success or error+reason
806 */
807int zynqmp_pm_set_suspend_mode(u32 mode)
808{
809 return zynqmp_pm_invoke_fn(PM_SET_SUSPEND_MODE, mode, 0, 0, 0, NULL);
810}
811EXPORT_SYMBOL_GPL(zynqmp_pm_set_suspend_mode);
812
813/**
814 * zynqmp_pm_request_node() - Request a node with specific capabilities
815 * @node: Node ID of the slave
816 * @capabilities: Requested capabilities of the slave
817 * @qos: Quality of service (not supported)
818 * @ack: Flag to specify whether acknowledge is requested
819 *
820 * This function is used by master to request particular node from firmware.
821 * Every master must request node before using it.
822 *
823 * Return: Returns status, either success or error+reason
824 */
825int zynqmp_pm_request_node(const u32 node, const u32 capabilities,
826 const u32 qos, const enum zynqmp_pm_request_ack ack)
827{
828 return zynqmp_pm_invoke_fn(PM_REQUEST_NODE, node, capabilities,
829 qos, ack, NULL);
830}
831EXPORT_SYMBOL_GPL(zynqmp_pm_request_node);
832
833/**
834 * zynqmp_pm_release_node() - Release a node
835 * @node: Node ID of the slave
836 *
837 * This function is used by master to inform firmware that master
838 * has released node. Once released, master must not use that node
839 * without re-request.
840 *
841 * Return: Returns status, either success or error+reason
842 */
843int zynqmp_pm_release_node(const u32 node)
844{
845 return zynqmp_pm_invoke_fn(PM_RELEASE_NODE, node, 0, 0, 0, NULL);
846}
847EXPORT_SYMBOL_GPL(zynqmp_pm_release_node);
848
849/**
850 * zynqmp_pm_set_requirement() - PM call to set requirement for PM slaves
851 * @node: Node ID of the slave
852 * @capabilities: Requested capabilities of the slave
853 * @qos: Quality of service (not supported)
854 * @ack: Flag to specify whether acknowledge is requested
855 *
856 * This API function is to be used for slaves a PU already has requested
857 * to change its capabilities.
858 *
859 * Return: Returns status, either success or error+reason
860 */
861int zynqmp_pm_set_requirement(const u32 node, const u32 capabilities,
862 const u32 qos,
863 const enum zynqmp_pm_request_ack ack)
864{
865 return zynqmp_pm_invoke_fn(PM_SET_REQUIREMENT, node, capabilities,
866 qos, ack, NULL);
867}
868EXPORT_SYMBOL_GPL(zynqmp_pm_set_requirement);
869
870/**
871 * zynqmp_pm_aes - Access AES hardware to encrypt/decrypt the data using
872 * AES-GCM core.
873 * @address: Address of the AesParams structure.
874 * @out: Returned output value
875 *
876 * Return: Returns status, either success or error code.
877 */
878int zynqmp_pm_aes_engine(const u64 address, u32 *out)
879{
880 u32 ret_payload[PAYLOAD_ARG_CNT];
881 int ret;
882
883 if (!out)
884 return -EINVAL;
885
886 ret = zynqmp_pm_invoke_fn(PM_SECURE_AES, upper_32_bits(address),
887 lower_32_bits(address),
888 0, 0, ret_payload);
889 *out = ret_payload[1];
890
891 return ret;
892}
893EXPORT_SYMBOL_GPL(zynqmp_pm_aes_engine);
894
895/**
896 * zynqmp_pm_system_shutdown - PM call to request a system shutdown or restart
897 * @type: Shutdown or restart? 0 for shutdown, 1 for restart
898 * @subtype: Specifies which system should be restarted or shut down
899 *
900 * Return: Returns status, either success or error+reason
901 */
902int zynqmp_pm_system_shutdown(const u32 type, const u32 subtype)
903{
904 return zynqmp_pm_invoke_fn(PM_SYSTEM_SHUTDOWN, type, subtype,
905 0, 0, NULL);
906}
907
908/**
909 * struct zynqmp_pm_shutdown_scope - Struct for shutdown scope
910 * @subtype: Shutdown subtype
911 * @name: Matching string for scope argument
912 *
913 * This struct encapsulates mapping between shutdown scope ID and string.
914 */
915struct zynqmp_pm_shutdown_scope {
916 const enum zynqmp_pm_shutdown_subtype subtype;
917 const char *name;
918};
919
920static struct zynqmp_pm_shutdown_scope shutdown_scopes[] = {
921 [ZYNQMP_PM_SHUTDOWN_SUBTYPE_SUBSYSTEM] = {
922 .subtype = ZYNQMP_PM_SHUTDOWN_SUBTYPE_SUBSYSTEM,
923 .name = "subsystem",
924 },
925 [ZYNQMP_PM_SHUTDOWN_SUBTYPE_PS_ONLY] = {
926 .subtype = ZYNQMP_PM_SHUTDOWN_SUBTYPE_PS_ONLY,
927 .name = "ps_only",
928 },
929 [ZYNQMP_PM_SHUTDOWN_SUBTYPE_SYSTEM] = {
930 .subtype = ZYNQMP_PM_SHUTDOWN_SUBTYPE_SYSTEM,
931 .name = "system",
932 },
933};
934
935static struct zynqmp_pm_shutdown_scope *selected_scope =
936 &shutdown_scopes[ZYNQMP_PM_SHUTDOWN_SUBTYPE_SYSTEM];
937
938/**
939 * zynqmp_pm_is_shutdown_scope_valid - Check if shutdown scope string is valid
940 * @scope_string: Shutdown scope string
941 *
942 * Return: Return pointer to matching shutdown scope struct from
943 * array of available options in system if string is valid,
944 * otherwise returns NULL.
945 */
946static struct zynqmp_pm_shutdown_scope*
947 zynqmp_pm_is_shutdown_scope_valid(const char *scope_string)
948{
949 int count;
950
951 for (count = 0; count < ARRAY_SIZE(shutdown_scopes); count++)
952 if (sysfs_streq(scope_string, shutdown_scopes[count].name))
953 return &shutdown_scopes[count];
954
955 return NULL;
956}
957
958static ssize_t shutdown_scope_show(struct device *device,
959 struct device_attribute *attr,
960 char *buf)
961{
962 int i;
963
964 for (i = 0; i < ARRAY_SIZE(shutdown_scopes); i++) {
965 if (&shutdown_scopes[i] == selected_scope) {
966 strcat(buf, "[");
967 strcat(buf, shutdown_scopes[i].name);
968 strcat(buf, "]");
969 } else {
970 strcat(buf, shutdown_scopes[i].name);
971 }
972 strcat(buf, " ");
973 }
974 strcat(buf, "\n");
975
976 return strlen(buf);
977}
978
979static ssize_t shutdown_scope_store(struct device *device,
980 struct device_attribute *attr,
981 const char *buf, size_t count)
982{
983 int ret;
984 struct zynqmp_pm_shutdown_scope *scope;
985
986 scope = zynqmp_pm_is_shutdown_scope_valid(buf);
987 if (!scope)
988 return -EINVAL;
989
990 ret = zynqmp_pm_system_shutdown(ZYNQMP_PM_SHUTDOWN_TYPE_SETSCOPE_ONLY,
991 scope->subtype);
992 if (ret) {
993 pr_err("unable to set shutdown scope %s\n", buf);
994 return ret;
995 }
996
997 selected_scope = scope;
998
999 return count;
1000}
1001
1002static DEVICE_ATTR_RW(shutdown_scope);
1003
1004static ssize_t health_status_store(struct device *device,
1005 struct device_attribute *attr,
1006 const char *buf, size_t count)
1007{
1008 int ret;
1009 unsigned int value;
1010
1011 ret = kstrtouint(buf, 10, &value);
1012 if (ret)
1013 return ret;
1014
1015 ret = zynqmp_pm_set_boot_health_status(value);
1016 if (ret) {
1017 dev_err(device, "unable to set healthy bit value to %u\n",
1018 value);
1019 return ret;
1020 }
1021
1022 return count;
1023}
1024
1025static DEVICE_ATTR_WO(health_status);
1026
1027static ssize_t ggs_show(struct device *device,
1028 struct device_attribute *attr,
1029 char *buf,
1030 u32 reg)
1031{
1032 int ret;
1033 u32 ret_payload[PAYLOAD_ARG_CNT];
1034
1035 ret = zynqmp_pm_read_ggs(reg, ret_payload);
1036 if (ret)
1037 return ret;
1038
1039 return sprintf(buf, "0x%x\n", ret_payload[1]);
1040}
1041
1042static ssize_t ggs_store(struct device *device,
1043 struct device_attribute *attr,
1044 const char *buf, size_t count,
1045 u32 reg)
1046{
1047 long value;
1048 int ret;
1049
1050 if (reg >= GSS_NUM_REGS)
1051 return -EINVAL;
1052
1053 ret = kstrtol(buf, 16, &value);
1054 if (ret) {
1055 count = -EFAULT;
1056 goto err;
1057 }
1058
1059 ret = zynqmp_pm_write_ggs(reg, value);
1060 if (ret)
1061 count = -EFAULT;
1062err:
1063 return count;
1064}
1065
1066/* GGS register show functions */
1067#define GGS0_SHOW(N) \
1068 ssize_t ggs##N##_show(struct device *device, \
1069 struct device_attribute *attr, \
1070 char *buf) \
1071 { \
1072 return ggs_show(device, attr, buf, N); \
1073 }
1074
1075static GGS0_SHOW(0);
1076static GGS0_SHOW(1);
1077static GGS0_SHOW(2);
1078static GGS0_SHOW(3);
1079
1080/* GGS register store function */
1081#define GGS0_STORE(N) \
1082 ssize_t ggs##N##_store(struct device *device, \
1083 struct device_attribute *attr, \
1084 const char *buf, \
1085 size_t count) \
1086 { \
1087 return ggs_store(device, attr, buf, count, N); \
1088 }
1089
1090static GGS0_STORE(0);
1091static GGS0_STORE(1);
1092static GGS0_STORE(2);
1093static GGS0_STORE(3);
1094
1095static ssize_t pggs_show(struct device *device,
1096 struct device_attribute *attr,
1097 char *buf,
1098 u32 reg)
1099{
1100 int ret;
1101 u32 ret_payload[PAYLOAD_ARG_CNT];
1102
1103 ret = zynqmp_pm_read_pggs(reg, ret_payload);
1104 if (ret)
1105 return ret;
1106
1107 return sprintf(buf, "0x%x\n", ret_payload[1]);
1108}
1109
1110static ssize_t pggs_store(struct device *device,
1111 struct device_attribute *attr,
1112 const char *buf, size_t count,
1113 u32 reg)
1114{
1115 long value;
1116 int ret;
1117
1118 if (reg >= GSS_NUM_REGS)
1119 return -EINVAL;
1120
1121 ret = kstrtol(buf, 16, &value);
1122 if (ret) {
1123 count = -EFAULT;
1124 goto err;
1125 }
1126
1127 ret = zynqmp_pm_write_pggs(reg, value);
1128 if (ret)
1129 count = -EFAULT;
1130
1131err:
1132 return count;
1133}
1134
1135#define PGGS0_SHOW(N) \
1136 ssize_t pggs##N##_show(struct device *device, \
1137 struct device_attribute *attr, \
1138 char *buf) \
1139 { \
1140 return pggs_show(device, attr, buf, N); \
1141 }
1142
1143#define PGGS0_STORE(N) \
1144 ssize_t pggs##N##_store(struct device *device, \
1145 struct device_attribute *attr, \
1146 const char *buf, \
1147 size_t count) \
1148 { \
1149 return pggs_store(device, attr, buf, count, N); \
1150 }
1151
1152/* PGGS register show functions */
1153static PGGS0_SHOW(0);
1154static PGGS0_SHOW(1);
1155static PGGS0_SHOW(2);
1156static PGGS0_SHOW(3);
1157
1158/* PGGS register store functions */
1159static PGGS0_STORE(0);
1160static PGGS0_STORE(1);
1161static PGGS0_STORE(2);
1162static PGGS0_STORE(3);
1163
1164/* GGS register attributes */
1165static DEVICE_ATTR_RW(ggs0);
1166static DEVICE_ATTR_RW(ggs1);
1167static DEVICE_ATTR_RW(ggs2);
1168static DEVICE_ATTR_RW(ggs3);
1169
1170/* PGGS register attributes */
1171static DEVICE_ATTR_RW(pggs0);
1172static DEVICE_ATTR_RW(pggs1);
1173static DEVICE_ATTR_RW(pggs2);
1174static DEVICE_ATTR_RW(pggs3);
1175
1176static struct attribute *zynqmp_firmware_attrs[] = {
1177 &dev_attr_ggs0.attr,
1178 &dev_attr_ggs1.attr,
1179 &dev_attr_ggs2.attr,
1180 &dev_attr_ggs3.attr,
1181 &dev_attr_pggs0.attr,
1182 &dev_attr_pggs1.attr,
1183 &dev_attr_pggs2.attr,
1184 &dev_attr_pggs3.attr,
1185 &dev_attr_shutdown_scope.attr,
1186 &dev_attr_health_status.attr,
1187 NULL,
1188};
1189
1190ATTRIBUTE_GROUPS(zynqmp_firmware);
1191
1192static int zynqmp_firmware_probe(struct platform_device *pdev)
1193{
1194 struct device *dev = &pdev->dev;
1195 struct device_node *np;
1196 int ret;
1197
1198 np = of_find_compatible_node(NULL, NULL, "xlnx,zynqmp");
1199 if (!np) {
1200 np = of_find_compatible_node(NULL, NULL, "xlnx,versal");
1201 if (!np)
1202 return 0;
1203
1204 feature_check_enabled = true;
1205 }
1206 of_node_put(np);
1207
1208 ret = get_set_conduit_method(dev->of_node);
1209 if (ret)
1210 return ret;
1211
1212 /* Check PM API version number */
1213 zynqmp_pm_get_api_version(&pm_api_version);
1214 if (pm_api_version < ZYNQMP_PM_VERSION) {
1215 panic("%s Platform Management API version error. Expected: v%d.%d - Found: v%d.%d\n",
1216 __func__,
1217 ZYNQMP_PM_VERSION_MAJOR, ZYNQMP_PM_VERSION_MINOR,
1218 pm_api_version >> 16, pm_api_version & 0xFFFF);
1219 }
1220
1221 pr_info("%s Platform Management API v%d.%d\n", __func__,
1222 pm_api_version >> 16, pm_api_version & 0xFFFF);
1223
1224 /* Check trustzone version number */
1225 ret = zynqmp_pm_get_trustzone_version(&pm_tz_version);
1226 if (ret)
1227 panic("Legacy trustzone found without version support\n");
1228
1229 if (pm_tz_version < ZYNQMP_TZ_VERSION)
1230 panic("%s Trustzone version error. Expected: v%d.%d - Found: v%d.%d\n",
1231 __func__,
1232 ZYNQMP_TZ_VERSION_MAJOR, ZYNQMP_TZ_VERSION_MINOR,
1233 pm_tz_version >> 16, pm_tz_version & 0xFFFF);
1234
1235 pr_info("%s Trustzone version v%d.%d\n", __func__,
1236 pm_tz_version >> 16, pm_tz_version & 0xFFFF);
1237
1238 ret = mfd_add_devices(&pdev->dev, PLATFORM_DEVID_NONE, firmware_devs,
1239 ARRAY_SIZE(firmware_devs), NULL, 0, NULL);
1240 if (ret) {
1241 dev_err(&pdev->dev, "failed to add MFD devices %d\n", ret);
1242 return ret;
1243 }
1244
1245 zynqmp_pm_api_debugfs_init();
1246
1247 return of_platform_populate(dev->of_node, NULL, NULL, dev);
1248}
1249
1250static int zynqmp_firmware_remove(struct platform_device *pdev)
1251{
1252 mfd_remove_devices(&pdev->dev);
1253 zynqmp_pm_api_debugfs_exit();
1254
1255 return 0;
1256}
1257
1258static const struct of_device_id zynqmp_firmware_of_match[] = {
1259 {.compatible = "xlnx,zynqmp-firmware"},
1260 {.compatible = "xlnx,versal-firmware"},
1261 {},
1262};
1263MODULE_DEVICE_TABLE(of, zynqmp_firmware_of_match);
1264
1265static struct platform_driver zynqmp_firmware_driver = {
1266 .driver = {
1267 .name = "zynqmp_firmware",
1268 .of_match_table = zynqmp_firmware_of_match,
1269 .dev_groups = zynqmp_firmware_groups,
1270 },
1271 .probe = zynqmp_firmware_probe,
1272 .remove = zynqmp_firmware_remove,
1273};
1274module_platform_driver(zynqmp_firmware_driver);
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Xilinx Zynq MPSoC Firmware layer
4 *
5 * Copyright (C) 2014-2021 Xilinx, Inc.
6 *
7 * Michal Simek <michal.simek@xilinx.com>
8 * Davorin Mista <davorin.mista@aggios.com>
9 * Jolly Shah <jollys@xilinx.com>
10 * Rajan Vaja <rajanv@xilinx.com>
11 */
12
13#include <linux/arm-smccc.h>
14#include <linux/compiler.h>
15#include <linux/device.h>
16#include <linux/init.h>
17#include <linux/mfd/core.h>
18#include <linux/module.h>
19#include <linux/of.h>
20#include <linux/of_platform.h>
21#include <linux/slab.h>
22#include <linux/uaccess.h>
23#include <linux/hashtable.h>
24
25#include <linux/firmware/xlnx-zynqmp.h>
26#include "zynqmp-debug.h"
27
28/* Max HashMap Order for PM API feature check (1<<7 = 128) */
29#define PM_API_FEATURE_CHECK_MAX_ORDER 7
30
31static bool feature_check_enabled;
32static DEFINE_HASHTABLE(pm_api_features_map, PM_API_FEATURE_CHECK_MAX_ORDER);
33
34/**
35 * struct pm_api_feature_data - PM API Feature data
36 * @pm_api_id: PM API Id, used as key to index into hashmap
37 * @feature_status: status of PM API feature: valid, invalid
38 * @hentry: hlist_node that hooks this entry into hashtable
39 */
40struct pm_api_feature_data {
41 u32 pm_api_id;
42 int feature_status;
43 struct hlist_node hentry;
44};
45
46static const struct mfd_cell firmware_devs[] = {
47 {
48 .name = "zynqmp_power_controller",
49 },
50};
51
52/**
53 * zynqmp_pm_ret_code() - Convert PMU-FW error codes to Linux error codes
54 * @ret_status: PMUFW return code
55 *
56 * Return: corresponding Linux error code
57 */
58static int zynqmp_pm_ret_code(u32 ret_status)
59{
60 switch (ret_status) {
61 case XST_PM_SUCCESS:
62 case XST_PM_DOUBLE_REQ:
63 return 0;
64 case XST_PM_NO_FEATURE:
65 return -ENOTSUPP;
66 case XST_PM_NO_ACCESS:
67 return -EACCES;
68 case XST_PM_ABORT_SUSPEND:
69 return -ECANCELED;
70 case XST_PM_MULT_USER:
71 return -EUSERS;
72 case XST_PM_INTERNAL:
73 case XST_PM_CONFLICT:
74 case XST_PM_INVALID_NODE:
75 default:
76 return -EINVAL;
77 }
78}
79
80static noinline int do_fw_call_fail(u64 arg0, u64 arg1, u64 arg2,
81 u32 *ret_payload)
82{
83 return -ENODEV;
84}
85
86/*
87 * PM function call wrapper
88 * Invoke do_fw_call_smc or do_fw_call_hvc, depending on the configuration
89 */
90static int (*do_fw_call)(u64, u64, u64, u32 *ret_payload) = do_fw_call_fail;
91
92/**
93 * do_fw_call_smc() - Call system-level platform management layer (SMC)
94 * @arg0: Argument 0 to SMC call
95 * @arg1: Argument 1 to SMC call
96 * @arg2: Argument 2 to SMC call
97 * @ret_payload: Returned value array
98 *
99 * Invoke platform management function via SMC call (no hypervisor present).
100 *
101 * Return: Returns status, either success or error+reason
102 */
103static noinline int do_fw_call_smc(u64 arg0, u64 arg1, u64 arg2,
104 u32 *ret_payload)
105{
106 struct arm_smccc_res res;
107
108 arm_smccc_smc(arg0, arg1, arg2, 0, 0, 0, 0, 0, &res);
109
110 if (ret_payload) {
111 ret_payload[0] = lower_32_bits(res.a0);
112 ret_payload[1] = upper_32_bits(res.a0);
113 ret_payload[2] = lower_32_bits(res.a1);
114 ret_payload[3] = upper_32_bits(res.a1);
115 }
116
117 return zynqmp_pm_ret_code((enum pm_ret_status)res.a0);
118}
119
120/**
121 * do_fw_call_hvc() - Call system-level platform management layer (HVC)
122 * @arg0: Argument 0 to HVC call
123 * @arg1: Argument 1 to HVC call
124 * @arg2: Argument 2 to HVC call
125 * @ret_payload: Returned value array
126 *
127 * Invoke platform management function via HVC
128 * HVC-based for communication through hypervisor
129 * (no direct communication with ATF).
130 *
131 * Return: Returns status, either success or error+reason
132 */
133static noinline int do_fw_call_hvc(u64 arg0, u64 arg1, u64 arg2,
134 u32 *ret_payload)
135{
136 struct arm_smccc_res res;
137
138 arm_smccc_hvc(arg0, arg1, arg2, 0, 0, 0, 0, 0, &res);
139
140 if (ret_payload) {
141 ret_payload[0] = lower_32_bits(res.a0);
142 ret_payload[1] = upper_32_bits(res.a0);
143 ret_payload[2] = lower_32_bits(res.a1);
144 ret_payload[3] = upper_32_bits(res.a1);
145 }
146
147 return zynqmp_pm_ret_code((enum pm_ret_status)res.a0);
148}
149
150/**
151 * zynqmp_pm_feature() - Check weather given feature is supported or not
152 * @api_id: API ID to check
153 *
154 * Return: Returns status, either success or error+reason
155 */
156static int zynqmp_pm_feature(u32 api_id)
157{
158 int ret;
159 u32 ret_payload[PAYLOAD_ARG_CNT];
160 u64 smc_arg[2];
161 struct pm_api_feature_data *feature_data;
162
163 if (!feature_check_enabled)
164 return 0;
165
166 /* Check for existing entry in hash table for given api */
167 hash_for_each_possible(pm_api_features_map, feature_data, hentry,
168 api_id) {
169 if (feature_data->pm_api_id == api_id)
170 return feature_data->feature_status;
171 }
172
173 /* Add new entry if not present */
174 feature_data = kmalloc(sizeof(*feature_data), GFP_KERNEL);
175 if (!feature_data)
176 return -ENOMEM;
177
178 feature_data->pm_api_id = api_id;
179 smc_arg[0] = PM_SIP_SVC | PM_FEATURE_CHECK;
180 smc_arg[1] = api_id;
181
182 ret = do_fw_call(smc_arg[0], smc_arg[1], 0, ret_payload);
183 if (ret)
184 ret = -EOPNOTSUPP;
185 else
186 ret = ret_payload[1];
187
188 feature_data->feature_status = ret;
189 hash_add(pm_api_features_map, &feature_data->hentry, api_id);
190
191 return ret;
192}
193
194/**
195 * zynqmp_pm_invoke_fn() - Invoke the system-level platform management layer
196 * caller function depending on the configuration
197 * @pm_api_id: Requested PM-API call
198 * @arg0: Argument 0 to requested PM-API call
199 * @arg1: Argument 1 to requested PM-API call
200 * @arg2: Argument 2 to requested PM-API call
201 * @arg3: Argument 3 to requested PM-API call
202 * @ret_payload: Returned value array
203 *
204 * Invoke platform management function for SMC or HVC call, depending on
205 * configuration.
206 * Following SMC Calling Convention (SMCCC) for SMC64:
207 * Pm Function Identifier,
208 * PM_SIP_SVC + PM_API_ID =
209 * ((SMC_TYPE_FAST << FUNCID_TYPE_SHIFT)
210 * ((SMC_64) << FUNCID_CC_SHIFT)
211 * ((SIP_START) << FUNCID_OEN_SHIFT)
212 * ((PM_API_ID) & FUNCID_NUM_MASK))
213 *
214 * PM_SIP_SVC - Registered ZynqMP SIP Service Call.
215 * PM_API_ID - Platform Management API ID.
216 *
217 * Return: Returns status, either success or error+reason
218 */
219int zynqmp_pm_invoke_fn(u32 pm_api_id, u32 arg0, u32 arg1,
220 u32 arg2, u32 arg3, u32 *ret_payload)
221{
222 /*
223 * Added SIP service call Function Identifier
224 * Make sure to stay in x0 register
225 */
226 u64 smc_arg[4];
227 int ret;
228
229 /* Check if feature is supported or not */
230 ret = zynqmp_pm_feature(pm_api_id);
231 if (ret < 0)
232 return ret;
233
234 smc_arg[0] = PM_SIP_SVC | pm_api_id;
235 smc_arg[1] = ((u64)arg1 << 32) | arg0;
236 smc_arg[2] = ((u64)arg3 << 32) | arg2;
237
238 return do_fw_call(smc_arg[0], smc_arg[1], smc_arg[2], ret_payload);
239}
240
241static u32 pm_api_version;
242static u32 pm_tz_version;
243
244/**
245 * zynqmp_pm_get_api_version() - Get version number of PMU PM firmware
246 * @version: Returned version value
247 *
248 * Return: Returns status, either success or error+reason
249 */
250int zynqmp_pm_get_api_version(u32 *version)
251{
252 u32 ret_payload[PAYLOAD_ARG_CNT];
253 int ret;
254
255 if (!version)
256 return -EINVAL;
257
258 /* Check is PM API version already verified */
259 if (pm_api_version > 0) {
260 *version = pm_api_version;
261 return 0;
262 }
263 ret = zynqmp_pm_invoke_fn(PM_GET_API_VERSION, 0, 0, 0, 0, ret_payload);
264 *version = ret_payload[1];
265
266 return ret;
267}
268EXPORT_SYMBOL_GPL(zynqmp_pm_get_api_version);
269
270/**
271 * zynqmp_pm_get_chipid - Get silicon ID registers
272 * @idcode: IDCODE register
273 * @version: version register
274 *
275 * Return: Returns the status of the operation and the idcode and version
276 * registers in @idcode and @version.
277 */
278int zynqmp_pm_get_chipid(u32 *idcode, u32 *version)
279{
280 u32 ret_payload[PAYLOAD_ARG_CNT];
281 int ret;
282
283 if (!idcode || !version)
284 return -EINVAL;
285
286 ret = zynqmp_pm_invoke_fn(PM_GET_CHIPID, 0, 0, 0, 0, ret_payload);
287 *idcode = ret_payload[1];
288 *version = ret_payload[2];
289
290 return ret;
291}
292EXPORT_SYMBOL_GPL(zynqmp_pm_get_chipid);
293
294/**
295 * zynqmp_pm_get_trustzone_version() - Get secure trustzone firmware version
296 * @version: Returned version value
297 *
298 * Return: Returns status, either success or error+reason
299 */
300static int zynqmp_pm_get_trustzone_version(u32 *version)
301{
302 u32 ret_payload[PAYLOAD_ARG_CNT];
303 int ret;
304
305 if (!version)
306 return -EINVAL;
307
308 /* Check is PM trustzone version already verified */
309 if (pm_tz_version > 0) {
310 *version = pm_tz_version;
311 return 0;
312 }
313 ret = zynqmp_pm_invoke_fn(PM_GET_TRUSTZONE_VERSION, 0, 0,
314 0, 0, ret_payload);
315 *version = ret_payload[1];
316
317 return ret;
318}
319
320/**
321 * get_set_conduit_method() - Choose SMC or HVC based communication
322 * @np: Pointer to the device_node structure
323 *
324 * Use SMC or HVC-based functions to communicate with EL2/EL3.
325 *
326 * Return: Returns 0 on success or error code
327 */
328static int get_set_conduit_method(struct device_node *np)
329{
330 const char *method;
331
332 if (of_property_read_string(np, "method", &method)) {
333 pr_warn("%s missing \"method\" property\n", __func__);
334 return -ENXIO;
335 }
336
337 if (!strcmp("hvc", method)) {
338 do_fw_call = do_fw_call_hvc;
339 } else if (!strcmp("smc", method)) {
340 do_fw_call = do_fw_call_smc;
341 } else {
342 pr_warn("%s Invalid \"method\" property: %s\n",
343 __func__, method);
344 return -EINVAL;
345 }
346
347 return 0;
348}
349
350/**
351 * zynqmp_pm_query_data() - Get query data from firmware
352 * @qdata: Variable to the zynqmp_pm_query_data structure
353 * @out: Returned output value
354 *
355 * Return: Returns status, either success or error+reason
356 */
357int zynqmp_pm_query_data(struct zynqmp_pm_query_data qdata, u32 *out)
358{
359 int ret;
360
361 ret = zynqmp_pm_invoke_fn(PM_QUERY_DATA, qdata.qid, qdata.arg1,
362 qdata.arg2, qdata.arg3, out);
363
364 /*
365 * For clock name query, all bytes in SMC response are clock name
366 * characters and return code is always success. For invalid clocks,
367 * clock name bytes would be zeros.
368 */
369 return qdata.qid == PM_QID_CLOCK_GET_NAME ? 0 : ret;
370}
371EXPORT_SYMBOL_GPL(zynqmp_pm_query_data);
372
373/**
374 * zynqmp_pm_clock_enable() - Enable the clock for given id
375 * @clock_id: ID of the clock to be enabled
376 *
377 * This function is used by master to enable the clock
378 * including peripherals and PLL clocks.
379 *
380 * Return: Returns status, either success or error+reason
381 */
382int zynqmp_pm_clock_enable(u32 clock_id)
383{
384 return zynqmp_pm_invoke_fn(PM_CLOCK_ENABLE, clock_id, 0, 0, 0, NULL);
385}
386EXPORT_SYMBOL_GPL(zynqmp_pm_clock_enable);
387
388/**
389 * zynqmp_pm_clock_disable() - Disable the clock for given id
390 * @clock_id: ID of the clock to be disable
391 *
392 * This function is used by master to disable the clock
393 * including peripherals and PLL clocks.
394 *
395 * Return: Returns status, either success or error+reason
396 */
397int zynqmp_pm_clock_disable(u32 clock_id)
398{
399 return zynqmp_pm_invoke_fn(PM_CLOCK_DISABLE, clock_id, 0, 0, 0, NULL);
400}
401EXPORT_SYMBOL_GPL(zynqmp_pm_clock_disable);
402
403/**
404 * zynqmp_pm_clock_getstate() - Get the clock state for given id
405 * @clock_id: ID of the clock to be queried
406 * @state: 1/0 (Enabled/Disabled)
407 *
408 * This function is used by master to get the state of clock
409 * including peripherals and PLL clocks.
410 *
411 * Return: Returns status, either success or error+reason
412 */
413int zynqmp_pm_clock_getstate(u32 clock_id, u32 *state)
414{
415 u32 ret_payload[PAYLOAD_ARG_CNT];
416 int ret;
417
418 ret = zynqmp_pm_invoke_fn(PM_CLOCK_GETSTATE, clock_id, 0,
419 0, 0, ret_payload);
420 *state = ret_payload[1];
421
422 return ret;
423}
424EXPORT_SYMBOL_GPL(zynqmp_pm_clock_getstate);
425
426/**
427 * zynqmp_pm_clock_setdivider() - Set the clock divider for given id
428 * @clock_id: ID of the clock
429 * @divider: divider value
430 *
431 * This function is used by master to set divider for any clock
432 * to achieve desired rate.
433 *
434 * Return: Returns status, either success or error+reason
435 */
436int zynqmp_pm_clock_setdivider(u32 clock_id, u32 divider)
437{
438 return zynqmp_pm_invoke_fn(PM_CLOCK_SETDIVIDER, clock_id, divider,
439 0, 0, NULL);
440}
441EXPORT_SYMBOL_GPL(zynqmp_pm_clock_setdivider);
442
443/**
444 * zynqmp_pm_clock_getdivider() - Get the clock divider for given id
445 * @clock_id: ID of the clock
446 * @divider: divider value
447 *
448 * This function is used by master to get divider values
449 * for any clock.
450 *
451 * Return: Returns status, either success or error+reason
452 */
453int zynqmp_pm_clock_getdivider(u32 clock_id, u32 *divider)
454{
455 u32 ret_payload[PAYLOAD_ARG_CNT];
456 int ret;
457
458 ret = zynqmp_pm_invoke_fn(PM_CLOCK_GETDIVIDER, clock_id, 0,
459 0, 0, ret_payload);
460 *divider = ret_payload[1];
461
462 return ret;
463}
464EXPORT_SYMBOL_GPL(zynqmp_pm_clock_getdivider);
465
466/**
467 * zynqmp_pm_clock_setrate() - Set the clock rate for given id
468 * @clock_id: ID of the clock
469 * @rate: rate value in hz
470 *
471 * This function is used by master to set rate for any clock.
472 *
473 * Return: Returns status, either success or error+reason
474 */
475int zynqmp_pm_clock_setrate(u32 clock_id, u64 rate)
476{
477 return zynqmp_pm_invoke_fn(PM_CLOCK_SETRATE, clock_id,
478 lower_32_bits(rate),
479 upper_32_bits(rate),
480 0, NULL);
481}
482EXPORT_SYMBOL_GPL(zynqmp_pm_clock_setrate);
483
484/**
485 * zynqmp_pm_clock_getrate() - Get the clock rate for given id
486 * @clock_id: ID of the clock
487 * @rate: rate value in hz
488 *
489 * This function is used by master to get rate
490 * for any clock.
491 *
492 * Return: Returns status, either success or error+reason
493 */
494int zynqmp_pm_clock_getrate(u32 clock_id, u64 *rate)
495{
496 u32 ret_payload[PAYLOAD_ARG_CNT];
497 int ret;
498
499 ret = zynqmp_pm_invoke_fn(PM_CLOCK_GETRATE, clock_id, 0,
500 0, 0, ret_payload);
501 *rate = ((u64)ret_payload[2] << 32) | ret_payload[1];
502
503 return ret;
504}
505EXPORT_SYMBOL_GPL(zynqmp_pm_clock_getrate);
506
507/**
508 * zynqmp_pm_clock_setparent() - Set the clock parent for given id
509 * @clock_id: ID of the clock
510 * @parent_id: parent id
511 *
512 * This function is used by master to set parent for any clock.
513 *
514 * Return: Returns status, either success or error+reason
515 */
516int zynqmp_pm_clock_setparent(u32 clock_id, u32 parent_id)
517{
518 return zynqmp_pm_invoke_fn(PM_CLOCK_SETPARENT, clock_id,
519 parent_id, 0, 0, NULL);
520}
521EXPORT_SYMBOL_GPL(zynqmp_pm_clock_setparent);
522
523/**
524 * zynqmp_pm_clock_getparent() - Get the clock parent for given id
525 * @clock_id: ID of the clock
526 * @parent_id: parent id
527 *
528 * This function is used by master to get parent index
529 * for any clock.
530 *
531 * Return: Returns status, either success or error+reason
532 */
533int zynqmp_pm_clock_getparent(u32 clock_id, u32 *parent_id)
534{
535 u32 ret_payload[PAYLOAD_ARG_CNT];
536 int ret;
537
538 ret = zynqmp_pm_invoke_fn(PM_CLOCK_GETPARENT, clock_id, 0,
539 0, 0, ret_payload);
540 *parent_id = ret_payload[1];
541
542 return ret;
543}
544EXPORT_SYMBOL_GPL(zynqmp_pm_clock_getparent);
545
546/**
547 * zynqmp_pm_set_pll_frac_mode() - PM API for set PLL mode
548 *
549 * @clk_id: PLL clock ID
550 * @mode: PLL mode (PLL_MODE_FRAC/PLL_MODE_INT)
551 *
552 * This function sets PLL mode
553 *
554 * Return: Returns status, either success or error+reason
555 */
556int zynqmp_pm_set_pll_frac_mode(u32 clk_id, u32 mode)
557{
558 return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_SET_PLL_FRAC_MODE,
559 clk_id, mode, NULL);
560}
561EXPORT_SYMBOL_GPL(zynqmp_pm_set_pll_frac_mode);
562
563/**
564 * zynqmp_pm_get_pll_frac_mode() - PM API for get PLL mode
565 *
566 * @clk_id: PLL clock ID
567 * @mode: PLL mode
568 *
569 * This function return current PLL mode
570 *
571 * Return: Returns status, either success or error+reason
572 */
573int zynqmp_pm_get_pll_frac_mode(u32 clk_id, u32 *mode)
574{
575 return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_GET_PLL_FRAC_MODE,
576 clk_id, 0, mode);
577}
578EXPORT_SYMBOL_GPL(zynqmp_pm_get_pll_frac_mode);
579
580/**
581 * zynqmp_pm_set_pll_frac_data() - PM API for setting pll fraction data
582 *
583 * @clk_id: PLL clock ID
584 * @data: fraction data
585 *
586 * This function sets fraction data.
587 * It is valid for fraction mode only.
588 *
589 * Return: Returns status, either success or error+reason
590 */
591int zynqmp_pm_set_pll_frac_data(u32 clk_id, u32 data)
592{
593 return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_SET_PLL_FRAC_DATA,
594 clk_id, data, NULL);
595}
596EXPORT_SYMBOL_GPL(zynqmp_pm_set_pll_frac_data);
597
598/**
599 * zynqmp_pm_get_pll_frac_data() - PM API for getting pll fraction data
600 *
601 * @clk_id: PLL clock ID
602 * @data: fraction data
603 *
604 * This function returns fraction data value.
605 *
606 * Return: Returns status, either success or error+reason
607 */
608int zynqmp_pm_get_pll_frac_data(u32 clk_id, u32 *data)
609{
610 return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_GET_PLL_FRAC_DATA,
611 clk_id, 0, data);
612}
613EXPORT_SYMBOL_GPL(zynqmp_pm_get_pll_frac_data);
614
615/**
616 * zynqmp_pm_set_sd_tapdelay() - Set tap delay for the SD device
617 *
618 * @node_id: Node ID of the device
619 * @type: Type of tap delay to set (input/output)
620 * @value: Value to set fot the tap delay
621 *
622 * This function sets input/output tap delay for the SD device.
623 *
624 * Return: Returns status, either success or error+reason
625 */
626int zynqmp_pm_set_sd_tapdelay(u32 node_id, u32 type, u32 value)
627{
628 return zynqmp_pm_invoke_fn(PM_IOCTL, node_id, IOCTL_SET_SD_TAPDELAY,
629 type, value, NULL);
630}
631EXPORT_SYMBOL_GPL(zynqmp_pm_set_sd_tapdelay);
632
633/**
634 * zynqmp_pm_sd_dll_reset() - Reset DLL logic
635 *
636 * @node_id: Node ID of the device
637 * @type: Reset type
638 *
639 * This function resets DLL logic for the SD device.
640 *
641 * Return: Returns status, either success or error+reason
642 */
643int zynqmp_pm_sd_dll_reset(u32 node_id, u32 type)
644{
645 return zynqmp_pm_invoke_fn(PM_IOCTL, node_id, IOCTL_SD_DLL_RESET,
646 type, 0, NULL);
647}
648EXPORT_SYMBOL_GPL(zynqmp_pm_sd_dll_reset);
649
650/**
651 * zynqmp_pm_write_ggs() - PM API for writing global general storage (ggs)
652 * @index: GGS register index
653 * @value: Register value to be written
654 *
655 * This function writes value to GGS register.
656 *
657 * Return: Returns status, either success or error+reason
658 */
659int zynqmp_pm_write_ggs(u32 index, u32 value)
660{
661 return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_WRITE_GGS,
662 index, value, NULL);
663}
664EXPORT_SYMBOL_GPL(zynqmp_pm_write_ggs);
665
666/**
667 * zynqmp_pm_write_ggs() - PM API for reading global general storage (ggs)
668 * @index: GGS register index
669 * @value: Register value to be written
670 *
671 * This function returns GGS register value.
672 *
673 * Return: Returns status, either success or error+reason
674 */
675int zynqmp_pm_read_ggs(u32 index, u32 *value)
676{
677 return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_READ_GGS,
678 index, 0, value);
679}
680EXPORT_SYMBOL_GPL(zynqmp_pm_read_ggs);
681
682/**
683 * zynqmp_pm_write_pggs() - PM API for writing persistent global general
684 * storage (pggs)
685 * @index: PGGS register index
686 * @value: Register value to be written
687 *
688 * This function writes value to PGGS register.
689 *
690 * Return: Returns status, either success or error+reason
691 */
692int zynqmp_pm_write_pggs(u32 index, u32 value)
693{
694 return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_WRITE_PGGS, index, value,
695 NULL);
696}
697EXPORT_SYMBOL_GPL(zynqmp_pm_write_pggs);
698
699/**
700 * zynqmp_pm_write_pggs() - PM API for reading persistent global general
701 * storage (pggs)
702 * @index: PGGS register index
703 * @value: Register value to be written
704 *
705 * This function returns PGGS register value.
706 *
707 * Return: Returns status, either success or error+reason
708 */
709int zynqmp_pm_read_pggs(u32 index, u32 *value)
710{
711 return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_READ_PGGS, index, 0,
712 value);
713}
714EXPORT_SYMBOL_GPL(zynqmp_pm_read_pggs);
715
716/**
717 * zynqmp_pm_set_boot_health_status() - PM API for setting healthy boot status
718 * @value: Status value to be written
719 *
720 * This function sets healthy bit value to indicate boot health status
721 * to firmware.
722 *
723 * Return: Returns status, either success or error+reason
724 */
725int zynqmp_pm_set_boot_health_status(u32 value)
726{
727 return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_SET_BOOT_HEALTH_STATUS,
728 value, 0, NULL);
729}
730
731/**
732 * zynqmp_pm_reset_assert - Request setting of reset (1 - assert, 0 - release)
733 * @reset: Reset to be configured
734 * @assert_flag: Flag stating should reset be asserted (1) or
735 * released (0)
736 *
737 * Return: Returns status, either success or error+reason
738 */
739int zynqmp_pm_reset_assert(const enum zynqmp_pm_reset reset,
740 const enum zynqmp_pm_reset_action assert_flag)
741{
742 return zynqmp_pm_invoke_fn(PM_RESET_ASSERT, reset, assert_flag,
743 0, 0, NULL);
744}
745EXPORT_SYMBOL_GPL(zynqmp_pm_reset_assert);
746
747/**
748 * zynqmp_pm_reset_get_status - Get status of the reset
749 * @reset: Reset whose status should be returned
750 * @status: Returned status
751 *
752 * Return: Returns status, either success or error+reason
753 */
754int zynqmp_pm_reset_get_status(const enum zynqmp_pm_reset reset, u32 *status)
755{
756 u32 ret_payload[PAYLOAD_ARG_CNT];
757 int ret;
758
759 if (!status)
760 return -EINVAL;
761
762 ret = zynqmp_pm_invoke_fn(PM_RESET_GET_STATUS, reset, 0,
763 0, 0, ret_payload);
764 *status = ret_payload[1];
765
766 return ret;
767}
768EXPORT_SYMBOL_GPL(zynqmp_pm_reset_get_status);
769
770/**
771 * zynqmp_pm_fpga_load - Perform the fpga load
772 * @address: Address to write to
773 * @size: pl bitstream size
774 * @flags: Bitstream type
775 * -XILINX_ZYNQMP_PM_FPGA_FULL: FPGA full reconfiguration
776 * -XILINX_ZYNQMP_PM_FPGA_PARTIAL: FPGA partial reconfiguration
777 *
778 * This function provides access to pmufw. To transfer
779 * the required bitstream into PL.
780 *
781 * Return: Returns status, either success or error+reason
782 */
783int zynqmp_pm_fpga_load(const u64 address, const u32 size, const u32 flags)
784{
785 return zynqmp_pm_invoke_fn(PM_FPGA_LOAD, lower_32_bits(address),
786 upper_32_bits(address), size, flags, NULL);
787}
788EXPORT_SYMBOL_GPL(zynqmp_pm_fpga_load);
789
790/**
791 * zynqmp_pm_fpga_get_status - Read value from PCAP status register
792 * @value: Value to read
793 *
794 * This function provides access to the pmufw to get the PCAP
795 * status
796 *
797 * Return: Returns status, either success or error+reason
798 */
799int zynqmp_pm_fpga_get_status(u32 *value)
800{
801 u32 ret_payload[PAYLOAD_ARG_CNT];
802 int ret;
803
804 if (!value)
805 return -EINVAL;
806
807 ret = zynqmp_pm_invoke_fn(PM_FPGA_GET_STATUS, 0, 0, 0, 0, ret_payload);
808 *value = ret_payload[1];
809
810 return ret;
811}
812EXPORT_SYMBOL_GPL(zynqmp_pm_fpga_get_status);
813
814/**
815 * zynqmp_pm_pinctrl_request - Request Pin from firmware
816 * @pin: Pin number to request
817 *
818 * This function requests pin from firmware.
819 *
820 * Return: Returns status, either success or error+reason.
821 */
822int zynqmp_pm_pinctrl_request(const u32 pin)
823{
824 return zynqmp_pm_invoke_fn(PM_PINCTRL_REQUEST, pin, 0, 0, 0, NULL);
825}
826EXPORT_SYMBOL_GPL(zynqmp_pm_pinctrl_request);
827
828/**
829 * zynqmp_pm_pinctrl_release - Inform firmware that Pin control is released
830 * @pin: Pin number to release
831 *
832 * This function release pin from firmware.
833 *
834 * Return: Returns status, either success or error+reason.
835 */
836int zynqmp_pm_pinctrl_release(const u32 pin)
837{
838 return zynqmp_pm_invoke_fn(PM_PINCTRL_RELEASE, pin, 0, 0, 0, NULL);
839}
840EXPORT_SYMBOL_GPL(zynqmp_pm_pinctrl_release);
841
842/**
843 * zynqmp_pm_pinctrl_get_function - Read function id set for the given pin
844 * @pin: Pin number
845 * @id: Buffer to store function ID
846 *
847 * This function provides the function currently set for the given pin.
848 *
849 * Return: Returns status, either success or error+reason
850 */
851int zynqmp_pm_pinctrl_get_function(const u32 pin, u32 *id)
852{
853 u32 ret_payload[PAYLOAD_ARG_CNT];
854 int ret;
855
856 if (!id)
857 return -EINVAL;
858
859 ret = zynqmp_pm_invoke_fn(PM_PINCTRL_GET_FUNCTION, pin, 0,
860 0, 0, ret_payload);
861 *id = ret_payload[1];
862
863 return ret;
864}
865EXPORT_SYMBOL_GPL(zynqmp_pm_pinctrl_get_function);
866
867/**
868 * zynqmp_pm_pinctrl_set_function - Set requested function for the pin
869 * @pin: Pin number
870 * @id: Function ID to set
871 *
872 * This function sets requested function for the given pin.
873 *
874 * Return: Returns status, either success or error+reason.
875 */
876int zynqmp_pm_pinctrl_set_function(const u32 pin, const u32 id)
877{
878 return zynqmp_pm_invoke_fn(PM_PINCTRL_SET_FUNCTION, pin, id,
879 0, 0, NULL);
880}
881EXPORT_SYMBOL_GPL(zynqmp_pm_pinctrl_set_function);
882
883/**
884 * zynqmp_pm_pinctrl_get_config - Get configuration parameter for the pin
885 * @pin: Pin number
886 * @param: Parameter to get
887 * @value: Buffer to store parameter value
888 *
889 * This function gets requested configuration parameter for the given pin.
890 *
891 * Return: Returns status, either success or error+reason.
892 */
893int zynqmp_pm_pinctrl_get_config(const u32 pin, const u32 param,
894 u32 *value)
895{
896 u32 ret_payload[PAYLOAD_ARG_CNT];
897 int ret;
898
899 if (!value)
900 return -EINVAL;
901
902 ret = zynqmp_pm_invoke_fn(PM_PINCTRL_CONFIG_PARAM_GET, pin, param,
903 0, 0, ret_payload);
904 *value = ret_payload[1];
905
906 return ret;
907}
908EXPORT_SYMBOL_GPL(zynqmp_pm_pinctrl_get_config);
909
910/**
911 * zynqmp_pm_pinctrl_set_config - Set configuration parameter for the pin
912 * @pin: Pin number
913 * @param: Parameter to set
914 * @value: Parameter value to set
915 *
916 * This function sets requested configuration parameter for the given pin.
917 *
918 * Return: Returns status, either success or error+reason.
919 */
920int zynqmp_pm_pinctrl_set_config(const u32 pin, const u32 param,
921 u32 value)
922{
923 return zynqmp_pm_invoke_fn(PM_PINCTRL_CONFIG_PARAM_SET, pin,
924 param, value, 0, NULL);
925}
926EXPORT_SYMBOL_GPL(zynqmp_pm_pinctrl_set_config);
927
928/**
929 * zynqmp_pm_init_finalize() - PM call to inform firmware that the caller
930 * master has initialized its own power management
931 *
932 * Return: Returns status, either success or error+reason
933 *
934 * This API function is to be used for notify the power management controller
935 * about the completed power management initialization.
936 */
937int zynqmp_pm_init_finalize(void)
938{
939 return zynqmp_pm_invoke_fn(PM_PM_INIT_FINALIZE, 0, 0, 0, 0, NULL);
940}
941EXPORT_SYMBOL_GPL(zynqmp_pm_init_finalize);
942
943/**
944 * zynqmp_pm_set_suspend_mode() - Set system suspend mode
945 * @mode: Mode to set for system suspend
946 *
947 * This API function is used to set mode of system suspend.
948 *
949 * Return: Returns status, either success or error+reason
950 */
951int zynqmp_pm_set_suspend_mode(u32 mode)
952{
953 return zynqmp_pm_invoke_fn(PM_SET_SUSPEND_MODE, mode, 0, 0, 0, NULL);
954}
955EXPORT_SYMBOL_GPL(zynqmp_pm_set_suspend_mode);
956
957/**
958 * zynqmp_pm_request_node() - Request a node with specific capabilities
959 * @node: Node ID of the slave
960 * @capabilities: Requested capabilities of the slave
961 * @qos: Quality of service (not supported)
962 * @ack: Flag to specify whether acknowledge is requested
963 *
964 * This function is used by master to request particular node from firmware.
965 * Every master must request node before using it.
966 *
967 * Return: Returns status, either success or error+reason
968 */
969int zynqmp_pm_request_node(const u32 node, const u32 capabilities,
970 const u32 qos, const enum zynqmp_pm_request_ack ack)
971{
972 return zynqmp_pm_invoke_fn(PM_REQUEST_NODE, node, capabilities,
973 qos, ack, NULL);
974}
975EXPORT_SYMBOL_GPL(zynqmp_pm_request_node);
976
977/**
978 * zynqmp_pm_release_node() - Release a node
979 * @node: Node ID of the slave
980 *
981 * This function is used by master to inform firmware that master
982 * has released node. Once released, master must not use that node
983 * without re-request.
984 *
985 * Return: Returns status, either success or error+reason
986 */
987int zynqmp_pm_release_node(const u32 node)
988{
989 return zynqmp_pm_invoke_fn(PM_RELEASE_NODE, node, 0, 0, 0, NULL);
990}
991EXPORT_SYMBOL_GPL(zynqmp_pm_release_node);
992
993/**
994 * zynqmp_pm_set_requirement() - PM call to set requirement for PM slaves
995 * @node: Node ID of the slave
996 * @capabilities: Requested capabilities of the slave
997 * @qos: Quality of service (not supported)
998 * @ack: Flag to specify whether acknowledge is requested
999 *
1000 * This API function is to be used for slaves a PU already has requested
1001 * to change its capabilities.
1002 *
1003 * Return: Returns status, either success or error+reason
1004 */
1005int zynqmp_pm_set_requirement(const u32 node, const u32 capabilities,
1006 const u32 qos,
1007 const enum zynqmp_pm_request_ack ack)
1008{
1009 return zynqmp_pm_invoke_fn(PM_SET_REQUIREMENT, node, capabilities,
1010 qos, ack, NULL);
1011}
1012EXPORT_SYMBOL_GPL(zynqmp_pm_set_requirement);
1013
1014/**
1015 * zynqmp_pm_aes - Access AES hardware to encrypt/decrypt the data using
1016 * AES-GCM core.
1017 * @address: Address of the AesParams structure.
1018 * @out: Returned output value
1019 *
1020 * Return: Returns status, either success or error code.
1021 */
1022int zynqmp_pm_aes_engine(const u64 address, u32 *out)
1023{
1024 u32 ret_payload[PAYLOAD_ARG_CNT];
1025 int ret;
1026
1027 if (!out)
1028 return -EINVAL;
1029
1030 ret = zynqmp_pm_invoke_fn(PM_SECURE_AES, upper_32_bits(address),
1031 lower_32_bits(address),
1032 0, 0, ret_payload);
1033 *out = ret_payload[1];
1034
1035 return ret;
1036}
1037EXPORT_SYMBOL_GPL(zynqmp_pm_aes_engine);
1038
1039/**
1040 * zynqmp_pm_system_shutdown - PM call to request a system shutdown or restart
1041 * @type: Shutdown or restart? 0 for shutdown, 1 for restart
1042 * @subtype: Specifies which system should be restarted or shut down
1043 *
1044 * Return: Returns status, either success or error+reason
1045 */
1046int zynqmp_pm_system_shutdown(const u32 type, const u32 subtype)
1047{
1048 return zynqmp_pm_invoke_fn(PM_SYSTEM_SHUTDOWN, type, subtype,
1049 0, 0, NULL);
1050}
1051
1052/**
1053 * struct zynqmp_pm_shutdown_scope - Struct for shutdown scope
1054 * @subtype: Shutdown subtype
1055 * @name: Matching string for scope argument
1056 *
1057 * This struct encapsulates mapping between shutdown scope ID and string.
1058 */
1059struct zynqmp_pm_shutdown_scope {
1060 const enum zynqmp_pm_shutdown_subtype subtype;
1061 const char *name;
1062};
1063
1064static struct zynqmp_pm_shutdown_scope shutdown_scopes[] = {
1065 [ZYNQMP_PM_SHUTDOWN_SUBTYPE_SUBSYSTEM] = {
1066 .subtype = ZYNQMP_PM_SHUTDOWN_SUBTYPE_SUBSYSTEM,
1067 .name = "subsystem",
1068 },
1069 [ZYNQMP_PM_SHUTDOWN_SUBTYPE_PS_ONLY] = {
1070 .subtype = ZYNQMP_PM_SHUTDOWN_SUBTYPE_PS_ONLY,
1071 .name = "ps_only",
1072 },
1073 [ZYNQMP_PM_SHUTDOWN_SUBTYPE_SYSTEM] = {
1074 .subtype = ZYNQMP_PM_SHUTDOWN_SUBTYPE_SYSTEM,
1075 .name = "system",
1076 },
1077};
1078
1079static struct zynqmp_pm_shutdown_scope *selected_scope =
1080 &shutdown_scopes[ZYNQMP_PM_SHUTDOWN_SUBTYPE_SYSTEM];
1081
1082/**
1083 * zynqmp_pm_is_shutdown_scope_valid - Check if shutdown scope string is valid
1084 * @scope_string: Shutdown scope string
1085 *
1086 * Return: Return pointer to matching shutdown scope struct from
1087 * array of available options in system if string is valid,
1088 * otherwise returns NULL.
1089 */
1090static struct zynqmp_pm_shutdown_scope*
1091 zynqmp_pm_is_shutdown_scope_valid(const char *scope_string)
1092{
1093 int count;
1094
1095 for (count = 0; count < ARRAY_SIZE(shutdown_scopes); count++)
1096 if (sysfs_streq(scope_string, shutdown_scopes[count].name))
1097 return &shutdown_scopes[count];
1098
1099 return NULL;
1100}
1101
1102static ssize_t shutdown_scope_show(struct device *device,
1103 struct device_attribute *attr,
1104 char *buf)
1105{
1106 int i;
1107
1108 for (i = 0; i < ARRAY_SIZE(shutdown_scopes); i++) {
1109 if (&shutdown_scopes[i] == selected_scope) {
1110 strcat(buf, "[");
1111 strcat(buf, shutdown_scopes[i].name);
1112 strcat(buf, "]");
1113 } else {
1114 strcat(buf, shutdown_scopes[i].name);
1115 }
1116 strcat(buf, " ");
1117 }
1118 strcat(buf, "\n");
1119
1120 return strlen(buf);
1121}
1122
1123static ssize_t shutdown_scope_store(struct device *device,
1124 struct device_attribute *attr,
1125 const char *buf, size_t count)
1126{
1127 int ret;
1128 struct zynqmp_pm_shutdown_scope *scope;
1129
1130 scope = zynqmp_pm_is_shutdown_scope_valid(buf);
1131 if (!scope)
1132 return -EINVAL;
1133
1134 ret = zynqmp_pm_system_shutdown(ZYNQMP_PM_SHUTDOWN_TYPE_SETSCOPE_ONLY,
1135 scope->subtype);
1136 if (ret) {
1137 pr_err("unable to set shutdown scope %s\n", buf);
1138 return ret;
1139 }
1140
1141 selected_scope = scope;
1142
1143 return count;
1144}
1145
1146static DEVICE_ATTR_RW(shutdown_scope);
1147
1148static ssize_t health_status_store(struct device *device,
1149 struct device_attribute *attr,
1150 const char *buf, size_t count)
1151{
1152 int ret;
1153 unsigned int value;
1154
1155 ret = kstrtouint(buf, 10, &value);
1156 if (ret)
1157 return ret;
1158
1159 ret = zynqmp_pm_set_boot_health_status(value);
1160 if (ret) {
1161 dev_err(device, "unable to set healthy bit value to %u\n",
1162 value);
1163 return ret;
1164 }
1165
1166 return count;
1167}
1168
1169static DEVICE_ATTR_WO(health_status);
1170
1171static ssize_t ggs_show(struct device *device,
1172 struct device_attribute *attr,
1173 char *buf,
1174 u32 reg)
1175{
1176 int ret;
1177 u32 ret_payload[PAYLOAD_ARG_CNT];
1178
1179 ret = zynqmp_pm_read_ggs(reg, ret_payload);
1180 if (ret)
1181 return ret;
1182
1183 return sprintf(buf, "0x%x\n", ret_payload[1]);
1184}
1185
1186static ssize_t ggs_store(struct device *device,
1187 struct device_attribute *attr,
1188 const char *buf, size_t count,
1189 u32 reg)
1190{
1191 long value;
1192 int ret;
1193
1194 if (reg >= GSS_NUM_REGS)
1195 return -EINVAL;
1196
1197 ret = kstrtol(buf, 16, &value);
1198 if (ret) {
1199 count = -EFAULT;
1200 goto err;
1201 }
1202
1203 ret = zynqmp_pm_write_ggs(reg, value);
1204 if (ret)
1205 count = -EFAULT;
1206err:
1207 return count;
1208}
1209
1210/* GGS register show functions */
1211#define GGS0_SHOW(N) \
1212 ssize_t ggs##N##_show(struct device *device, \
1213 struct device_attribute *attr, \
1214 char *buf) \
1215 { \
1216 return ggs_show(device, attr, buf, N); \
1217 }
1218
1219static GGS0_SHOW(0);
1220static GGS0_SHOW(1);
1221static GGS0_SHOW(2);
1222static GGS0_SHOW(3);
1223
1224/* GGS register store function */
1225#define GGS0_STORE(N) \
1226 ssize_t ggs##N##_store(struct device *device, \
1227 struct device_attribute *attr, \
1228 const char *buf, \
1229 size_t count) \
1230 { \
1231 return ggs_store(device, attr, buf, count, N); \
1232 }
1233
1234static GGS0_STORE(0);
1235static GGS0_STORE(1);
1236static GGS0_STORE(2);
1237static GGS0_STORE(3);
1238
1239static ssize_t pggs_show(struct device *device,
1240 struct device_attribute *attr,
1241 char *buf,
1242 u32 reg)
1243{
1244 int ret;
1245 u32 ret_payload[PAYLOAD_ARG_CNT];
1246
1247 ret = zynqmp_pm_read_pggs(reg, ret_payload);
1248 if (ret)
1249 return ret;
1250
1251 return sprintf(buf, "0x%x\n", ret_payload[1]);
1252}
1253
1254static ssize_t pggs_store(struct device *device,
1255 struct device_attribute *attr,
1256 const char *buf, size_t count,
1257 u32 reg)
1258{
1259 long value;
1260 int ret;
1261
1262 if (reg >= GSS_NUM_REGS)
1263 return -EINVAL;
1264
1265 ret = kstrtol(buf, 16, &value);
1266 if (ret) {
1267 count = -EFAULT;
1268 goto err;
1269 }
1270
1271 ret = zynqmp_pm_write_pggs(reg, value);
1272 if (ret)
1273 count = -EFAULT;
1274
1275err:
1276 return count;
1277}
1278
1279#define PGGS0_SHOW(N) \
1280 ssize_t pggs##N##_show(struct device *device, \
1281 struct device_attribute *attr, \
1282 char *buf) \
1283 { \
1284 return pggs_show(device, attr, buf, N); \
1285 }
1286
1287#define PGGS0_STORE(N) \
1288 ssize_t pggs##N##_store(struct device *device, \
1289 struct device_attribute *attr, \
1290 const char *buf, \
1291 size_t count) \
1292 { \
1293 return pggs_store(device, attr, buf, count, N); \
1294 }
1295
1296/* PGGS register show functions */
1297static PGGS0_SHOW(0);
1298static PGGS0_SHOW(1);
1299static PGGS0_SHOW(2);
1300static PGGS0_SHOW(3);
1301
1302/* PGGS register store functions */
1303static PGGS0_STORE(0);
1304static PGGS0_STORE(1);
1305static PGGS0_STORE(2);
1306static PGGS0_STORE(3);
1307
1308/* GGS register attributes */
1309static DEVICE_ATTR_RW(ggs0);
1310static DEVICE_ATTR_RW(ggs1);
1311static DEVICE_ATTR_RW(ggs2);
1312static DEVICE_ATTR_RW(ggs3);
1313
1314/* PGGS register attributes */
1315static DEVICE_ATTR_RW(pggs0);
1316static DEVICE_ATTR_RW(pggs1);
1317static DEVICE_ATTR_RW(pggs2);
1318static DEVICE_ATTR_RW(pggs3);
1319
1320static struct attribute *zynqmp_firmware_attrs[] = {
1321 &dev_attr_ggs0.attr,
1322 &dev_attr_ggs1.attr,
1323 &dev_attr_ggs2.attr,
1324 &dev_attr_ggs3.attr,
1325 &dev_attr_pggs0.attr,
1326 &dev_attr_pggs1.attr,
1327 &dev_attr_pggs2.attr,
1328 &dev_attr_pggs3.attr,
1329 &dev_attr_shutdown_scope.attr,
1330 &dev_attr_health_status.attr,
1331 NULL,
1332};
1333
1334ATTRIBUTE_GROUPS(zynqmp_firmware);
1335
1336static int zynqmp_firmware_probe(struct platform_device *pdev)
1337{
1338 struct device *dev = &pdev->dev;
1339 struct device_node *np;
1340 int ret;
1341
1342 np = of_find_compatible_node(NULL, NULL, "xlnx,zynqmp");
1343 if (!np) {
1344 np = of_find_compatible_node(NULL, NULL, "xlnx,versal");
1345 if (!np)
1346 return 0;
1347
1348 feature_check_enabled = true;
1349 }
1350 of_node_put(np);
1351
1352 ret = get_set_conduit_method(dev->of_node);
1353 if (ret)
1354 return ret;
1355
1356 /* Check PM API version number */
1357 zynqmp_pm_get_api_version(&pm_api_version);
1358 if (pm_api_version < ZYNQMP_PM_VERSION) {
1359 panic("%s Platform Management API version error. Expected: v%d.%d - Found: v%d.%d\n",
1360 __func__,
1361 ZYNQMP_PM_VERSION_MAJOR, ZYNQMP_PM_VERSION_MINOR,
1362 pm_api_version >> 16, pm_api_version & 0xFFFF);
1363 }
1364
1365 pr_info("%s Platform Management API v%d.%d\n", __func__,
1366 pm_api_version >> 16, pm_api_version & 0xFFFF);
1367
1368 /* Check trustzone version number */
1369 ret = zynqmp_pm_get_trustzone_version(&pm_tz_version);
1370 if (ret)
1371 panic("Legacy trustzone found without version support\n");
1372
1373 if (pm_tz_version < ZYNQMP_TZ_VERSION)
1374 panic("%s Trustzone version error. Expected: v%d.%d - Found: v%d.%d\n",
1375 __func__,
1376 ZYNQMP_TZ_VERSION_MAJOR, ZYNQMP_TZ_VERSION_MINOR,
1377 pm_tz_version >> 16, pm_tz_version & 0xFFFF);
1378
1379 pr_info("%s Trustzone version v%d.%d\n", __func__,
1380 pm_tz_version >> 16, pm_tz_version & 0xFFFF);
1381
1382 ret = mfd_add_devices(&pdev->dev, PLATFORM_DEVID_NONE, firmware_devs,
1383 ARRAY_SIZE(firmware_devs), NULL, 0, NULL);
1384 if (ret) {
1385 dev_err(&pdev->dev, "failed to add MFD devices %d\n", ret);
1386 return ret;
1387 }
1388
1389 zynqmp_pm_api_debugfs_init();
1390
1391 return of_platform_populate(dev->of_node, NULL, NULL, dev);
1392}
1393
1394static int zynqmp_firmware_remove(struct platform_device *pdev)
1395{
1396 struct pm_api_feature_data *feature_data;
1397 struct hlist_node *tmp;
1398 int i;
1399
1400 mfd_remove_devices(&pdev->dev);
1401 zynqmp_pm_api_debugfs_exit();
1402
1403 hash_for_each_safe(pm_api_features_map, i, tmp, feature_data, hentry) {
1404 hash_del(&feature_data->hentry);
1405 kfree(feature_data);
1406 }
1407
1408 return 0;
1409}
1410
1411static const struct of_device_id zynqmp_firmware_of_match[] = {
1412 {.compatible = "xlnx,zynqmp-firmware"},
1413 {.compatible = "xlnx,versal-firmware"},
1414 {},
1415};
1416MODULE_DEVICE_TABLE(of, zynqmp_firmware_of_match);
1417
1418static struct platform_driver zynqmp_firmware_driver = {
1419 .driver = {
1420 .name = "zynqmp_firmware",
1421 .of_match_table = zynqmp_firmware_of_match,
1422 .dev_groups = zynqmp_firmware_groups,
1423 },
1424 .probe = zynqmp_firmware_probe,
1425 .remove = zynqmp_firmware_remove,
1426};
1427module_platform_driver(zynqmp_firmware_driver);