drivers/firmware/xilinx/zynqmp.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Xilinx Zynq MPSoC Firmware layer
   4  *
   5  *  Copyright (C) 2014-2022 Xilinx, Inc.
   6  *
   7  *  Michal Simek <[email protected]>
   8  *  Davorin Mista <[email protected]>
   9  *  Jolly Shah <[email protected]>
  10  *  Rajan Vaja <[email protected]>
  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/platform_device.h>
  22 #include <linux/slab.h>
  23 #include <linux/uaccess.h>
  24 #include <linux/hashtable.h>
  25
  26 #include <linux/firmware/xlnx-zynqmp.h>
  27 #include <linux/firmware/xlnx-event-manager.h>
  28 #include "zynqmp-debug.h"
  29
  30 /* Max HashMap Order for PM API feature check (1<<7 = 128) */
  31 #define PM_API_FEATURE_CHECK_MAX_ORDER  7
  32
  33 /* CRL registers and bitfields */
  34 #define CRL_APB_BASE                    0xFF5E0000U
  35 /* BOOT_PIN_CTRL- Used to control the mode pins after boot */
  36 #define CRL_APB_BOOT_PIN_CTRL           (CRL_APB_BASE + (0x250U))
  37 /* BOOT_PIN_CTRL_MASK- out_val[11:8], out_en[3:0] */
  38 #define CRL_APB_BOOTPIN_CTRL_MASK       0xF0FU
  39
  40 /* IOCTL/QUERY feature payload size */
  41 #define FEATURE_PAYLOAD_SIZE            2
  42
  43 /* Firmware feature check version mask */
  44 #define FIRMWARE_VERSION_MASK           GENMASK(15, 0)
  45
  46 static bool feature_check_enabled;
  47 static DEFINE_HASHTABLE(pm_api_features_map, PM_API_FEATURE_CHECK_MAX_ORDER);
  48 static u32 ioctl_features[FEATURE_PAYLOAD_SIZE];
  49 static u32 query_features[FEATURE_PAYLOAD_SIZE];
  50
  51 static struct platform_device *em_dev;
  52
  53 /**
  54  * struct zynqmp_devinfo - Structure for Zynqmp device instance
  55  * @dev:                Device Pointer
  56  * @feature_conf_id:    Feature conf id
  57  */
  58 struct zynqmp_devinfo {
  59         struct device *dev;
  60         u32 feature_conf_id;
  61 };
  62
  63 /**
  64  * struct pm_api_feature_data - PM API Feature data
  65  * @pm_api_id:          PM API Id, used as key to index into hashmap
  66  * @feature_status:     status of PM API feature: valid, invalid
  67  * @hentry:             hlist_node that hooks this entry into hashtable
  68  */
  69 struct pm_api_feature_data {
  70         u32 pm_api_id;
  71         int feature_status;
  72         struct hlist_node hentry;
  73 };
  74
  75 static const struct mfd_cell firmware_devs[] = {
  76         {
  77                 .name = "zynqmp_power_controller",
  78         },
  79 };
  80
  81 /**
  82  * zynqmp_pm_ret_code() - Convert PMU-FW error codes to Linux error codes
  83  * @ret_status:         PMUFW return code
  84  *
  85  * Return: corresponding Linux error code
  86  */
  87 static int zynqmp_pm_ret_code(u32 ret_status)
  88 {
  89         switch (ret_status) {
  90         case XST_PM_SUCCESS:
  91         case XST_PM_DOUBLE_REQ:
  92                 return 0;
  93         case XST_PM_NO_FEATURE:
  94                 return -ENOTSUPP;
  95         case XST_PM_NO_ACCESS:
  96                 return -EACCES;
  97         case XST_PM_ABORT_SUSPEND:
  98                 return -ECANCELED;
  99         case XST_PM_MULT_USER:
 100                 return -EUSERS;
 101         case XST_PM_INTERNAL:
 102         case XST_PM_CONFLICT:
 103         case XST_PM_INVALID_NODE:
 104         default:
 105                 return -EINVAL;
 106         }
 107 }
 108
 109 static noinline int do_fw_call_fail(u64 arg0, u64 arg1, u64 arg2,
 110                                     u32 *ret_payload)
 111 {
 112         return -ENODEV;
 113 }
 114
 115 /*
 116  * PM function call wrapper
 117  * Invoke do_fw_call_smc or do_fw_call_hvc, depending on the configuration
 118  */
 119 static int (*do_fw_call)(u64, u64, u64, u32 *ret_payload) = do_fw_call_fail;
 120
 121 /**
 122  * do_fw_call_smc() - Call system-level platform management layer (SMC)
 123  * @arg0:               Argument 0 to SMC call
 124  * @arg1:               Argument 1 to SMC call
 125  * @arg2:               Argument 2 to SMC call
 126  * @ret_payload:        Returned value array
 127  *
 128  * Invoke platform management function via SMC call (no hypervisor present).
 129  *
 130  * Return: Returns status, either success or error+reason
 131  */
 132 static noinline int do_fw_call_smc(u64 arg0, u64 arg1, u64 arg2,
 133                                    u32 *ret_payload)
 134 {
 135         struct arm_smccc_res res;
 136
 137         arm_smccc_smc(arg0, arg1, arg2, 0, 0, 0, 0, 0, &res);
 138
 139         if (ret_payload) {
 140                 ret_payload[0] = lower_32_bits(res.a0);
 141                 ret_payload[1] = upper_32_bits(res.a0);
 142                 ret_payload[2] = lower_32_bits(res.a1);
 143                 ret_payload[3] = upper_32_bits(res.a1);
 144         }
 145
 146         return zynqmp_pm_ret_code((enum pm_ret_status)res.a0);
 147 }
 148
 149 /**
 150  * do_fw_call_hvc() - Call system-level platform management layer (HVC)
 151  * @arg0:               Argument 0 to HVC call
 152  * @arg1:               Argument 1 to HVC call
 153  * @arg2:               Argument 2 to HVC call
 154  * @ret_payload:        Returned value array
 155  *
 156  * Invoke platform management function via HVC
 157  * HVC-based for communication through hypervisor
 158  * (no direct communication with ATF).
 159  *
 160  * Return: Returns status, either success or error+reason
 161  */
 162 static noinline int do_fw_call_hvc(u64 arg0, u64 arg1, u64 arg2,
 163                                    u32 *ret_payload)
 164 {
 165         struct arm_smccc_res res;
 166
 167         arm_smccc_hvc(arg0, arg1, arg2, 0, 0, 0, 0, 0, &res);
 168
 169         if (ret_payload) {
 170                 ret_payload[0] = lower_32_bits(res.a0);
 171                 ret_payload[1] = upper_32_bits(res.a0);
 172                 ret_payload[2] = lower_32_bits(res.a1);
 173                 ret_payload[3] = upper_32_bits(res.a1);
 174         }
 175
 176         return zynqmp_pm_ret_code((enum pm_ret_status)res.a0);
 177 }
 178
 179 static int __do_feature_check_call(const u32 api_id, u32 *ret_payload)
 180 {
 181         int ret;
 182         u64 smc_arg[2];
 183
 184         smc_arg[0] = PM_SIP_SVC | PM_FEATURE_CHECK;
 185         smc_arg[1] = api_id;
 186
 187         ret = do_fw_call(smc_arg[0], smc_arg[1], 0, ret_payload);
 188         if (ret)
 189                 ret = -EOPNOTSUPP;
 190         else
 191                 ret = ret_payload[1];
 192
 193         return ret;
 194 }
 195
 196 static int do_feature_check_call(const u32 api_id)
 197 {
 198         int ret;
 199         u32 ret_payload[PAYLOAD_ARG_CNT];
 200         struct pm_api_feature_data *feature_data;
 201
 202         /* Check for existing entry in hash table for given api */
 203         hash_for_each_possible(pm_api_features_map, feature_data, hentry,
 204                                api_id) {
 205                 if (feature_data->pm_api_id == api_id)
 206                         return feature_data->feature_status;
 207         }
 208
 209         /* Add new entry if not present */
 210         feature_data = kmalloc(sizeof(*feature_data), GFP_ATOMIC);
 211         if (!feature_data)
 212                 return -ENOMEM;
 213
 214         feature_data->pm_api_id = api_id;
 215         ret = __do_feature_check_call(api_id, ret_payload);
 216
 217         feature_data->feature_status = ret;
 218         hash_add(pm_api_features_map, &feature_data->hentry, api_id);
 219
 220         if (api_id == PM_IOCTL)
 221                 /* Store supported IOCTL IDs mask */
 222                 memcpy(ioctl_features, &ret_payload[2], FEATURE_PAYLOAD_SIZE * 4);
 223         else if (api_id == PM_QUERY_DATA)
 224                 /* Store supported QUERY IDs mask */
 225                 memcpy(query_features, &ret_payload[2], FEATURE_PAYLOAD_SIZE * 4);
 226
 227         return ret;
 228 }
 229
 230 /**
 231  * zynqmp_pm_feature() - Check whether given feature is supported or not and
 232  *                       store supported IOCTL/QUERY ID mask
 233  * @api_id:             API ID to check
 234  *
 235  * Return: Returns status, either success or error+reason
 236  */
 237 int zynqmp_pm_feature(const u32 api_id)
 238 {
 239         int ret;
 240
 241         if (!feature_check_enabled)
 242                 return 0;
 243
 244         ret = do_feature_check_call(api_id);
 245
 246         return ret;
 247 }
 248 EXPORT_SYMBOL_GPL(zynqmp_pm_feature);
 249
 250 /**
 251  * zynqmp_pm_is_function_supported() - Check whether given IOCTL/QUERY function
 252  *                                     is supported or not
 253  * @api_id:             PM_IOCTL or PM_QUERY_DATA
 254  * @id:                 IOCTL or QUERY function IDs
 255  *
 256  * Return: Returns status, either success or error+reason
 257  */
 258 int zynqmp_pm_is_function_supported(const u32 api_id, const u32 id)
 259 {
 260         int ret;
 261         u32 *bit_mask;
 262
 263         /* Input arguments validation */
 264         if (id >= 64 || (api_id != PM_IOCTL && api_id != PM_QUERY_DATA))
 265                 return -EINVAL;
 266
 267         /* Check feature check API version */
 268         ret = do_feature_check_call(PM_FEATURE_CHECK);
 269         if (ret < 0)
 270                 return ret;
 271
 272         /* Check if feature check version 2 is supported or not */
 273         if ((ret & FIRMWARE_VERSION_MASK) == PM_API_VERSION_2) {
 274                 /*
 275                  * Call feature check for IOCTL/QUERY API to get IOCTL ID or
 276                  * QUERY ID feature status.
 277                  */
 278                 ret = do_feature_check_call(api_id);
 279                 if (ret < 0)
 280                         return ret;
 281
 282                 bit_mask = (api_id == PM_IOCTL) ? ioctl_features : query_features;
 283
 284                 if ((bit_mask[(id / 32)] & BIT((id % 32))) == 0U)
 285                         return -EOPNOTSUPP;
 286         } else {
 287                 return -ENODATA;
 288         }
 289
 290         return 0;
 291 }
 292 EXPORT_SYMBOL_GPL(zynqmp_pm_is_function_supported);
 293
 294 /**
 295  * zynqmp_pm_invoke_fn() - Invoke the system-level platform management layer
 296  *                         caller function depending on the configuration
 297  * @pm_api_id:          Requested PM-API call
 298  * @arg0:               Argument 0 to requested PM-API call
 299  * @arg1:               Argument 1 to requested PM-API call
 300  * @arg2:               Argument 2 to requested PM-API call
 301  * @arg3:               Argument 3 to requested PM-API call
 302  * @ret_payload:        Returned value array
 303  *
 304  * Invoke platform management function for SMC or HVC call, depending on
 305  * configuration.
 306  * Following SMC Calling Convention (SMCCC) for SMC64:
 307  * Pm Function Identifier,
 308  * PM_SIP_SVC + PM_API_ID =
 309  *      ((SMC_TYPE_FAST << FUNCID_TYPE_SHIFT)
 310  *      ((SMC_64) << FUNCID_CC_SHIFT)
 311  *      ((SIP_START) << FUNCID_OEN_SHIFT)
 312  *      ((PM_API_ID) & FUNCID_NUM_MASK))
 313  *
 314  * PM_SIP_SVC   - Registered ZynqMP SIP Service Call.
 315  * PM_API_ID    - Platform Management API ID.
 316  *
 317  * Return: Returns status, either success or error+reason
 318  */
 319 int zynqmp_pm_invoke_fn(u32 pm_api_id, u32 arg0, u32 arg1,
 320                         u32 arg2, u32 arg3, u32 *ret_payload)
 321 {
 322         /*
 323          * Added SIP service call Function Identifier
 324          * Make sure to stay in x0 register
 325          */
 326         u64 smc_arg[4];
 327         int ret;
 328
 329         /* Check if feature is supported or not */
 330         ret = zynqmp_pm_feature(pm_api_id);
 331         if (ret < 0)
 332                 return ret;
 333
 334         smc_arg[0] = PM_SIP_SVC | pm_api_id;
 335         smc_arg[1] = ((u64)arg1 << 32) | arg0;
 336         smc_arg[2] = ((u64)arg3 << 32) | arg2;
 337
 338         return do_fw_call(smc_arg[0], smc_arg[1], smc_arg[2], ret_payload);
 339 }
 340
 341 static u32 pm_api_version;
 342 static u32 pm_tz_version;
 343 static u32 pm_family_code;
 344 static u32 pm_sub_family_code;
 345
 346 int zynqmp_pm_register_sgi(u32 sgi_num, u32 reset)
 347 {
 348         int ret;
 349
 350         ret = zynqmp_pm_invoke_fn(TF_A_PM_REGISTER_SGI, sgi_num, reset, 0, 0,
 351                                   NULL);
 352         if (!ret)
 353                 return ret;
 354
 355         /* try old implementation as fallback strategy if above fails */
 356         return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_REGISTER_SGI, sgi_num,
 357                                    reset, NULL);
 358 }
 359
 360 /**
 361  * zynqmp_pm_get_api_version() - Get version number of PMU PM firmware
 362  * @version:    Returned version value
 363  *
 364  * Return: Returns status, either success or error+reason
 365  */
 366 int zynqmp_pm_get_api_version(u32 *version)
 367 {
 368         u32 ret_payload[PAYLOAD_ARG_CNT];
 369         int ret;
 370
 371         if (!version)
 372                 return -EINVAL;
 373
 374         /* Check is PM API version already verified */
 375         if (pm_api_version > 0) {
 376                 *version = pm_api_version;
 377                 return 0;
 378         }
 379         ret = zynqmp_pm_invoke_fn(PM_GET_API_VERSION, 0, 0, 0, 0, ret_payload);
 380         *version = ret_payload[1];
 381
 382         return ret;
 383 }
 384 EXPORT_SYMBOL_GPL(zynqmp_pm_get_api_version);
 385
 386 /**
 387  * zynqmp_pm_get_chipid - Get silicon ID registers
 388  * @idcode:     IDCODE register
 389  * @version:    version register
 390  *
 391  * Return:      Returns the status of the operation and the idcode and version
 392  *              registers in @idcode and @version.
 393  */
 394 int zynqmp_pm_get_chipid(u32 *idcode, u32 *version)
 395 {
 396         u32 ret_payload[PAYLOAD_ARG_CNT];
 397         int ret;
 398
 399         if (!idcode || !version)
 400                 return -EINVAL;
 401
 402         ret = zynqmp_pm_invoke_fn(PM_GET_CHIPID, 0, 0, 0, 0, ret_payload);
 403         *idcode = ret_payload[1];
 404         *version = ret_payload[2];
 405
 406         return ret;
 407 }
 408 EXPORT_SYMBOL_GPL(zynqmp_pm_get_chipid);
 409
 410 /**
 411  * zynqmp_pm_get_family_info() - Get family info of platform
 412  * @family:     Returned family code value
 413  * @subfamily:  Returned sub-family code value
 414  *
 415  * Return: Returns status, either success or error+reason
 416  */
 417 static int zynqmp_pm_get_family_info(u32 *family, u32 *subfamily)
 418 {
 419         u32 ret_payload[PAYLOAD_ARG_CNT];
 420         u32 idcode;
 421         int ret;
 422
 423         /* Check is family or sub-family code already received */
 424         if (pm_family_code && pm_sub_family_code) {
 425                 *family = pm_family_code;
 426                 *subfamily = pm_sub_family_code;
 427                 return 0;
 428         }
 429
 430         ret = zynqmp_pm_invoke_fn(PM_GET_CHIPID, 0, 0, 0, 0, ret_payload);
 431         if (ret < 0)
 432                 return ret;
 433
 434         idcode = ret_payload[1];
 435         pm_family_code = FIELD_GET(FAMILY_CODE_MASK, idcode);
 436         pm_sub_family_code = FIELD_GET(SUB_FAMILY_CODE_MASK, idcode);
 437         *family = pm_family_code;
 438         *subfamily = pm_sub_family_code;
 439
 440         return 0;
 441 }
 442
 443 /**
 444  * zynqmp_pm_get_trustzone_version() - Get secure trustzone firmware version
 445  * @version:    Returned version value
 446  *
 447  * Return: Returns status, either success or error+reason
 448  */
 449 static int zynqmp_pm_get_trustzone_version(u32 *version)
 450 {
 451         u32 ret_payload[PAYLOAD_ARG_CNT];
 452         int ret;
 453
 454         if (!version)
 455                 return -EINVAL;
 456
 457         /* Check is PM trustzone version already verified */
 458         if (pm_tz_version > 0) {
 459                 *version = pm_tz_version;
 460                 return 0;
 461         }
 462         ret = zynqmp_pm_invoke_fn(PM_GET_TRUSTZONE_VERSION, 0, 0,
 463                                   0, 0, ret_payload);
 464         *version = ret_payload[1];
 465
 466         return ret;
 467 }
 468
 469 /**
 470  * get_set_conduit_method() - Choose SMC or HVC based communication
 471  * @np:         Pointer to the device_node structure
 472  *
 473  * Use SMC or HVC-based functions to communicate with EL2/EL3.
 474  *
 475  * Return: Returns 0 on success or error code
 476  */
 477 static int get_set_conduit_method(struct device_node *np)
 478 {
 479         const char *method;
 480
 481         if (of_property_read_string(np, "method", &method)) {
 482                 pr_warn("%s missing \"method\" property\n", __func__);
 483                 return -ENXIO;
 484         }
 485
 486         if (!strcmp("hvc", method)) {
 487                 do_fw_call = do_fw_call_hvc;
 488         } else if (!strcmp("smc", method)) {
 489                 do_fw_call = do_fw_call_smc;
 490         } else {
 491                 pr_warn("%s Invalid \"method\" property: %s\n",
 492                         __func__, method);
 493                 return -EINVAL;
 494         }
 495
 496         return 0;
 497 }
 498
 499 /**
 500  * zynqmp_pm_query_data() - Get query data from firmware
 501  * @qdata:      Variable to the zynqmp_pm_query_data structure
 502  * @out:        Returned output value
 503  *
 504  * Return: Returns status, either success or error+reason
 505  */
 506 int zynqmp_pm_query_data(struct zynqmp_pm_query_data qdata, u32 *out)
 507 {
 508         int ret;
 509
 510         ret = zynqmp_pm_invoke_fn(PM_QUERY_DATA, qdata.qid, qdata.arg1,
 511                                   qdata.arg2, qdata.arg3, out);
 512
 513         /*
 514          * For clock name query, all bytes in SMC response are clock name
 515          * characters and return code is always success. For invalid clocks,
 516          * clock name bytes would be zeros.
 517          */
 518         return qdata.qid == PM_QID_CLOCK_GET_NAME ? 0 : ret;
 519 }
 520 EXPORT_SYMBOL_GPL(zynqmp_pm_query_data);
 521
 522 /**
 523  * zynqmp_pm_clock_enable() - Enable the clock for given id
 524  * @clock_id:   ID of the clock to be enabled
 525  *
 526  * This function is used by master to enable the clock
 527  * including peripherals and PLL clocks.
 528  *
 529  * Return: Returns status, either success or error+reason
 530  */
 531 int zynqmp_pm_clock_enable(u32 clock_id)
 532 {
 533         return zynqmp_pm_invoke_fn(PM_CLOCK_ENABLE, clock_id, 0, 0, 0, NULL);
 534 }
 535 EXPORT_SYMBOL_GPL(zynqmp_pm_clock_enable);
 536
 537 /**
 538  * zynqmp_pm_clock_disable() - Disable the clock for given id
 539  * @clock_id:   ID of the clock to be disable
 540  *
 541  * This function is used by master to disable the clock
 542  * including peripherals and PLL clocks.
 543  *
 544  * Return: Returns status, either success or error+reason
 545  */
 546 int zynqmp_pm_clock_disable(u32 clock_id)
 547 {
 548         return zynqmp_pm_invoke_fn(PM_CLOCK_DISABLE, clock_id, 0, 0, 0, NULL);
 549 }
 550 EXPORT_SYMBOL_GPL(zynqmp_pm_clock_disable);
 551
 552 /**
 553  * zynqmp_pm_clock_getstate() - Get the clock state for given id
 554  * @clock_id:   ID of the clock to be queried
 555  * @state:      1/0 (Enabled/Disabled)
 556  *
 557  * This function is used by master to get the state of clock
 558  * including peripherals and PLL clocks.
 559  *
 560  * Return: Returns status, either success or error+reason
 561  */
 562 int zynqmp_pm_clock_getstate(u32 clock_id, u32 *state)
 563 {
 564         u32 ret_payload[PAYLOAD_ARG_CNT];
 565         int ret;
 566
 567         ret = zynqmp_pm_invoke_fn(PM_CLOCK_GETSTATE, clock_id, 0,
 568                                   0, 0, ret_payload);
 569         *state = ret_payload[1];
 570
 571         return ret;
 572 }
 573 EXPORT_SYMBOL_GPL(zynqmp_pm_clock_getstate);
 574
 575 /**
 576  * zynqmp_pm_clock_setdivider() - Set the clock divider for given id
 577  * @clock_id:   ID of the clock
 578  * @divider:    divider value
 579  *
 580  * This function is used by master to set divider for any clock
 581  * to achieve desired rate.
 582  *
 583  * Return: Returns status, either success or error+reason
 584  */
 585 int zynqmp_pm_clock_setdivider(u32 clock_id, u32 divider)
 586 {
 587         return zynqmp_pm_invoke_fn(PM_CLOCK_SETDIVIDER, clock_id, divider,
 588                                    0, 0, NULL);
 589 }
 590 EXPORT_SYMBOL_GPL(zynqmp_pm_clock_setdivider);
 591
 592 /**
 593  * zynqmp_pm_clock_getdivider() - Get the clock divider for given id
 594  * @clock_id:   ID of the clock
 595  * @divider:    divider value
 596  *
 597  * This function is used by master to get divider values
 598  * for any clock.
 599  *
 600  * Return: Returns status, either success or error+reason
 601  */
 602 int zynqmp_pm_clock_getdivider(u32 clock_id, u32 *divider)
 603 {
 604         u32 ret_payload[PAYLOAD_ARG_CNT];
 605         int ret;
 606
 607         ret = zynqmp_pm_invoke_fn(PM_CLOCK_GETDIVIDER, clock_id, 0,
 608                                   0, 0, ret_payload);
 609         *divider = ret_payload[1];
 610
 611         return ret;
 612 }
 613 EXPORT_SYMBOL_GPL(zynqmp_pm_clock_getdivider);
 614
 615 /**
 616  * zynqmp_pm_clock_setrate() - Set the clock rate for given id
 617  * @clock_id:   ID of the clock
 618  * @rate:       rate value in hz
 619  *
 620  * This function is used by master to set rate for any clock.
 621  *
 622  * Return: Returns status, either success or error+reason
 623  */
 624 int zynqmp_pm_clock_setrate(u32 clock_id, u64 rate)
 625 {
 626         return zynqmp_pm_invoke_fn(PM_CLOCK_SETRATE, clock_id,
 627                                    lower_32_bits(rate),
 628                                    upper_32_bits(rate),
 629                                    0, NULL);
 630 }
 631 EXPORT_SYMBOL_GPL(zynqmp_pm_clock_setrate);
 632
 633 /**
 634  * zynqmp_pm_clock_getrate() - Get the clock rate for given id
 635  * @clock_id:   ID of the clock
 636  * @rate:       rate value in hz
 637  *
 638  * This function is used by master to get rate
 639  * for any clock.
 640  *
 641  * Return: Returns status, either success or error+reason
 642  */
 643 int zynqmp_pm_clock_getrate(u32 clock_id, u64 *rate)
 644 {
 645         u32 ret_payload[PAYLOAD_ARG_CNT];
 646         int ret;
 647
 648         ret = zynqmp_pm_invoke_fn(PM_CLOCK_GETRATE, clock_id, 0,
 649                                   0, 0, ret_payload);
 650         *rate = ((u64)ret_payload[2] << 32) | ret_payload[1];
 651
 652         return ret;
 653 }
 654 EXPORT_SYMBOL_GPL(zynqmp_pm_clock_getrate);
 655
 656 /**
 657  * zynqmp_pm_clock_setparent() - Set the clock parent for given id
 658  * @clock_id:   ID of the clock
 659  * @parent_id:  parent id
 660  *
 661  * This function is used by master to set parent for any clock.
 662  *
 663  * Return: Returns status, either success or error+reason
 664  */
 665 int zynqmp_pm_clock_setparent(u32 clock_id, u32 parent_id)
 666 {
 667         return zynqmp_pm_invoke_fn(PM_CLOCK_SETPARENT, clock_id,
 668                                    parent_id, 0, 0, NULL);
 669 }
 670 EXPORT_SYMBOL_GPL(zynqmp_pm_clock_setparent);
 671
 672 /**
 673  * zynqmp_pm_clock_getparent() - Get the clock parent for given id
 674  * @clock_id:   ID of the clock
 675  * @parent_id:  parent id
 676  *
 677  * This function is used by master to get parent index
 678  * for any clock.
 679  *
 680  * Return: Returns status, either success or error+reason
 681  */
 682 int zynqmp_pm_clock_getparent(u32 clock_id, u32 *parent_id)
 683 {
 684         u32 ret_payload[PAYLOAD_ARG_CNT];
 685         int ret;
 686
 687         ret = zynqmp_pm_invoke_fn(PM_CLOCK_GETPARENT, clock_id, 0,
 688                                   0, 0, ret_payload);
 689         *parent_id = ret_payload[1];
 690
 691         return ret;
 692 }
 693 EXPORT_SYMBOL_GPL(zynqmp_pm_clock_getparent);
 694
 695 /**
 696  * zynqmp_pm_set_pll_frac_mode() - PM API for set PLL mode
 697  *
 698  * @clk_id:     PLL clock ID
 699  * @mode:       PLL mode (PLL_MODE_FRAC/PLL_MODE_INT)
 700  *
 701  * This function sets PLL mode
 702  *
 703  * Return: Returns status, either success or error+reason
 704  */
 705 int zynqmp_pm_set_pll_frac_mode(u32 clk_id, u32 mode)
 706 {
 707         return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_SET_PLL_FRAC_MODE,
 708                                    clk_id, mode, NULL);
 709 }
 710 EXPORT_SYMBOL_GPL(zynqmp_pm_set_pll_frac_mode);
 711
 712 /**
 713  * zynqmp_pm_get_pll_frac_mode() - PM API for get PLL mode
 714  *
 715  * @clk_id:     PLL clock ID
 716  * @mode:       PLL mode
 717  *
 718  * This function return current PLL mode
 719  *
 720  * Return: Returns status, either success or error+reason
 721  */
 722 int zynqmp_pm_get_pll_frac_mode(u32 clk_id, u32 *mode)
 723 {
 724         return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_GET_PLL_FRAC_MODE,
 725                                    clk_id, 0, mode);
 726 }
 727 EXPORT_SYMBOL_GPL(zynqmp_pm_get_pll_frac_mode);
 728
 729 /**
 730  * zynqmp_pm_set_pll_frac_data() - PM API for setting pll fraction data
 731  *
 732  * @clk_id:     PLL clock ID
 733  * @data:       fraction data
 734  *
 735  * This function sets fraction data.
 736  * It is valid for fraction mode only.
 737  *
 738  * Return: Returns status, either success or error+reason
 739  */
 740 int zynqmp_pm_set_pll_frac_data(u32 clk_id, u32 data)
 741 {
 742         return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_SET_PLL_FRAC_DATA,
 743                                    clk_id, data, NULL);
 744 }
 745 EXPORT_SYMBOL_GPL(zynqmp_pm_set_pll_frac_data);
 746
 747 /**
 748  * zynqmp_pm_get_pll_frac_data() - PM API for getting pll fraction data
 749  *
 750  * @clk_id:     PLL clock ID
 751  * @data:       fraction data
 752  *
 753  * This function returns fraction data value.
 754  *
 755  * Return: Returns status, either success or error+reason
 756  */
 757 int zynqmp_pm_get_pll_frac_data(u32 clk_id, u32 *data)
 758 {
 759         return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_GET_PLL_FRAC_DATA,
 760                                    clk_id, 0, data);
 761 }
 762 EXPORT_SYMBOL_GPL(zynqmp_pm_get_pll_frac_data);
 763
 764 /**
 765  * zynqmp_pm_set_sd_tapdelay() -  Set tap delay for the SD device
 766  *
 767  * @node_id:    Node ID of the device
 768  * @type:       Type of tap delay to set (input/output)
 769  * @value:      Value to set fot the tap delay
 770  *
 771  * This function sets input/output tap delay for the SD device.
 772  *
 773  * Return:      Returns status, either success or error+reason
 774  */
 775 int zynqmp_pm_set_sd_tapdelay(u32 node_id, u32 type, u32 value)
 776 {
 777         u32 reg = (type == PM_TAPDELAY_INPUT) ? SD_ITAPDLY : SD_OTAPDLYSEL;
 778         u32 mask = (node_id == NODE_SD_0) ? GENMASK(15, 0) : GENMASK(31, 16);
 779
 780         if (value) {
 781                 return zynqmp_pm_invoke_fn(PM_IOCTL, node_id,
 782                                            IOCTL_SET_SD_TAPDELAY,
 783                                            type, value, NULL);
 784         }
 785
 786         /*
 787          * Work around completely misdesigned firmware API on Xilinx ZynqMP.
 788          * The IOCTL_SET_SD_TAPDELAY firmware call allows the caller to only
 789          * ever set IOU_SLCR SD_ITAPDLY Register SD0_ITAPDLYENA/SD1_ITAPDLYENA
 790          * bits, but there is no matching call to clear those bits. If those
 791          * bits are not cleared, SDMMC tuning may fail.
 792          *
 793          * Luckily, there are PM_MMIO_READ/PM_MMIO_WRITE calls which seem to
 794          * allow complete unrestricted access to all address space, including
 795          * IOU_SLCR SD_ITAPDLY Register and all the other registers, access
 796          * to which was supposed to be protected by the current firmware API.
 797          *
 798          * Use PM_MMIO_READ/PM_MMIO_WRITE to re-implement the missing counter
 799          * part of IOCTL_SET_SD_TAPDELAY which clears SDx_ITAPDLYENA bits.
 800          */
 801         return zynqmp_pm_invoke_fn(PM_MMIO_WRITE, reg, mask, 0, 0, NULL);
 802 }
 803 EXPORT_SYMBOL_GPL(zynqmp_pm_set_sd_tapdelay);
 804
 805 /**
 806  * zynqmp_pm_sd_dll_reset() - Reset DLL logic
 807  *
 808  * @node_id:    Node ID of the device
 809  * @type:       Reset type
 810  *
 811  * This function resets DLL logic for the SD device.
 812  *
 813  * Return:      Returns status, either success or error+reason
 814  */
 815 int zynqmp_pm_sd_dll_reset(u32 node_id, u32 type)
 816 {
 817         return zynqmp_pm_invoke_fn(PM_IOCTL, node_id, IOCTL_SD_DLL_RESET,
 818                                    type, 0, NULL);
 819 }
 820 EXPORT_SYMBOL_GPL(zynqmp_pm_sd_dll_reset);
 821
 822 /**
 823  * zynqmp_pm_ospi_mux_select() - OSPI Mux selection
 824  *
 825  * @dev_id:     Device Id of the OSPI device.
 826  * @select:     OSPI Mux select value.
 827  *
 828  * This function select the OSPI Mux.
 829  *
 830  * Return:      Returns status, either success or error+reason
 831  */
 832 int zynqmp_pm_ospi_mux_select(u32 dev_id, u32 select)
 833 {
 834         return zynqmp_pm_invoke_fn(PM_IOCTL, dev_id, IOCTL_OSPI_MUX_SELECT,
 835                                    select, 0, NULL);
 836 }
 837 EXPORT_SYMBOL_GPL(zynqmp_pm_ospi_mux_select);
 838
 839 /**
 840  * zynqmp_pm_write_ggs() - PM API for writing global general storage (ggs)
 841  * @index:      GGS register index
 842  * @value:      Register value to be written
 843  *
 844  * This function writes value to GGS register.
 845  *
 846  * Return:      Returns status, either success or error+reason
 847  */
 848 int zynqmp_pm_write_ggs(u32 index, u32 value)
 849 {
 850         return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_WRITE_GGS,
 851                                    index, value, NULL);
 852 }
 853 EXPORT_SYMBOL_GPL(zynqmp_pm_write_ggs);
 854
 855 /**
 856  * zynqmp_pm_read_ggs() - PM API for reading global general storage (ggs)
 857  * @index:      GGS register index
 858  * @value:      Register value to be written
 859  *
 860  * This function returns GGS register value.
 861  *
 862  * Return:      Returns status, either success or error+reason
 863  */
 864 int zynqmp_pm_read_ggs(u32 index, u32 *value)
 865 {
 866         return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_READ_GGS,
 867                                    index, 0, value);
 868 }
 869 EXPORT_SYMBOL_GPL(zynqmp_pm_read_ggs);
 870
 871 /**
 872  * zynqmp_pm_write_pggs() - PM API for writing persistent global general
 873  *                           storage (pggs)
 874  * @index:      PGGS register index
 875  * @value:      Register value to be written
 876  *
 877  * This function writes value to PGGS register.
 878  *
 879  * Return:      Returns status, either success or error+reason
 880  */
 881 int zynqmp_pm_write_pggs(u32 index, u32 value)
 882 {
 883         return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_WRITE_PGGS, index, value,
 884                                    NULL);
 885 }
 886 EXPORT_SYMBOL_GPL(zynqmp_pm_write_pggs);
 887
 888 /**
 889  * zynqmp_pm_read_pggs() - PM API for reading persistent global general
 890  *                           storage (pggs)
 891  * @index:      PGGS register index
 892  * @value:      Register value to be written
 893  *
 894  * This function returns PGGS register value.
 895  *
 896  * Return:      Returns status, either success or error+reason
 897  */
 898 int zynqmp_pm_read_pggs(u32 index, u32 *value)
 899 {
 900         return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_READ_PGGS, index, 0,
 901                                    value);
 902 }
 903 EXPORT_SYMBOL_GPL(zynqmp_pm_read_pggs);
 904
 905 int zynqmp_pm_set_tapdelay_bypass(u32 index, u32 value)
 906 {
 907         return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_SET_TAPDELAY_BYPASS,
 908                                    index, value, NULL);
 909 }
 910 EXPORT_SYMBOL_GPL(zynqmp_pm_set_tapdelay_bypass);
 911
 912 /**
 913  * zynqmp_pm_set_boot_health_status() - PM API for setting healthy boot status
 914  * @value:      Status value to be written
 915  *
 916  * This function sets healthy bit value to indicate boot health status
 917  * to firmware.
 918  *
 919  * Return:      Returns status, either success or error+reason
 920  */
 921 int zynqmp_pm_set_boot_health_status(u32 value)
 922 {
 923         return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_SET_BOOT_HEALTH_STATUS,
 924                                    value, 0, NULL);
 925 }
 926
 927 /**
 928  * zynqmp_pm_reset_assert - Request setting of reset (1 - assert, 0 - release)
 929  * @reset:              Reset to be configured
 930  * @assert_flag:        Flag stating should reset be asserted (1) or
 931  *                      released (0)
 932  *
 933  * Return: Returns status, either success or error+reason
 934  */
 935 int zynqmp_pm_reset_assert(const enum zynqmp_pm_reset reset,
 936                            const enum zynqmp_pm_reset_action assert_flag)
 937 {
 938         return zynqmp_pm_invoke_fn(PM_RESET_ASSERT, reset, assert_flag,
 939                                    0, 0, NULL);
 940 }
 941 EXPORT_SYMBOL_GPL(zynqmp_pm_reset_assert);
 942
 943 /**
 944  * zynqmp_pm_reset_get_status - Get status of the reset
 945  * @reset:      Reset whose status should be returned
 946  * @status:     Returned status
 947  *
 948  * Return: Returns status, either success or error+reason
 949  */
 950 int zynqmp_pm_reset_get_status(const enum zynqmp_pm_reset reset, u32 *status)
 951 {
 952         u32 ret_payload[PAYLOAD_ARG_CNT];
 953         int ret;
 954
 955         if (!status)
 956                 return -EINVAL;
 957
 958         ret = zynqmp_pm_invoke_fn(PM_RESET_GET_STATUS, reset, 0,
 959                                   0, 0, ret_payload);
 960         *status = ret_payload[1];
 961
 962         return ret;
 963 }
 964 EXPORT_SYMBOL_GPL(zynqmp_pm_reset_get_status);
 965
 966 /**
 967  * zynqmp_pm_fpga_load - Perform the fpga load
 968  * @address:    Address to write to
 969  * @size:       pl bitstream size
 970  * @flags:      Bitstream type
 971  *      -XILINX_ZYNQMP_PM_FPGA_FULL:  FPGA full reconfiguration
 972  *      -XILINX_ZYNQMP_PM_FPGA_PARTIAL: FPGA partial reconfiguration
 973  *
 974  * This function provides access to pmufw. To transfer
 975  * the required bitstream into PL.
 976  *
 977  * Return: Returns status, either success or error+reason
 978  */
 979 int zynqmp_pm_fpga_load(const u64 address, const u32 size, const u32 flags)
 980 {
 981         u32 ret_payload[PAYLOAD_ARG_CNT];
 982         int ret;
 983
 984         ret = zynqmp_pm_invoke_fn(PM_FPGA_LOAD, lower_32_bits(address),
 985                                   upper_32_bits(address), size, flags,
 986                                   ret_payload);
 987         if (ret_payload[0])
 988                 return -ret_payload[0];
 989
 990         return ret;
 991 }
 992 EXPORT_SYMBOL_GPL(zynqmp_pm_fpga_load);
 993
 994 /**
 995  * zynqmp_pm_fpga_get_status - Read value from PCAP status register
 996  * @value: Value to read
 997  *
 998  * This function provides access to the pmufw to get the PCAP
 999  * status
1000  *
1001  * Return: Returns status, either success or error+reason
1002  */
1003 int zynqmp_pm_fpga_get_status(u32 *value)
1004 {
1005         u32 ret_payload[PAYLOAD_ARG_CNT];
1006         int ret;
1007
1008         if (!value)
1009                 return -EINVAL;
1010
1011         ret = zynqmp_pm_invoke_fn(PM_FPGA_GET_STATUS, 0, 0, 0, 0, ret_payload);
1012         *value = ret_payload[1];
1013
1014         return ret;
1015 }
1016 EXPORT_SYMBOL_GPL(zynqmp_pm_fpga_get_status);
1017
1018 /**
1019  * zynqmp_pm_fpga_get_config_status - Get the FPGA configuration status.
1020  * @value: Buffer to store FPGA configuration status.
1021  *
1022  * This function provides access to the pmufw to get the FPGA configuration
1023  * status
1024  *
1025  * Return: 0 on success, a negative value on error
1026  */
1027 int zynqmp_pm_fpga_get_config_status(u32 *value)
1028 {
1029         u32 ret_payload[PAYLOAD_ARG_CNT];
1030         u32 buf, lower_addr, upper_addr;
1031         int ret;
1032
1033         if (!value)
1034                 return -EINVAL;
1035
1036         lower_addr = lower_32_bits((u64)&buf);
1037         upper_addr = upper_32_bits((u64)&buf);
1038
1039         ret = zynqmp_pm_invoke_fn(PM_FPGA_READ,
1040                                   XILINX_ZYNQMP_PM_FPGA_CONFIG_STAT_OFFSET,
1041                                   lower_addr, upper_addr,
1042                                   XILINX_ZYNQMP_PM_FPGA_READ_CONFIG_REG,
1043                                   ret_payload);
1044
1045         *value = ret_payload[1];
1046
1047         return ret;
1048 }
1049 EXPORT_SYMBOL_GPL(zynqmp_pm_fpga_get_config_status);
1050
1051 /**
1052  * zynqmp_pm_pinctrl_request - Request Pin from firmware
1053  * @pin: Pin number to request
1054  *
1055  * This function requests pin from firmware.
1056  *
1057  * Return: Returns status, either success or error+reason.
1058  */
1059 int zynqmp_pm_pinctrl_request(const u32 pin)
1060 {
1061         return zynqmp_pm_invoke_fn(PM_PINCTRL_REQUEST, pin, 0, 0, 0, NULL);
1062 }
1063 EXPORT_SYMBOL_GPL(zynqmp_pm_pinctrl_request);
1064
1065 /**
1066  * zynqmp_pm_pinctrl_release - Inform firmware that Pin control is released
1067  * @pin: Pin number to release
1068  *
1069  * This function release pin from firmware.
1070  *
1071  * Return: Returns status, either success or error+reason.
1072  */
1073 int zynqmp_pm_pinctrl_release(const u32 pin)
1074 {
1075         return zynqmp_pm_invoke_fn(PM_PINCTRL_RELEASE, pin, 0, 0, 0, NULL);
1076 }
1077 EXPORT_SYMBOL_GPL(zynqmp_pm_pinctrl_release);
1078
1079 /**
1080  * zynqmp_pm_pinctrl_get_function - Read function id set for the given pin
1081  * @pin: Pin number
1082  * @id: Buffer to store function ID
1083  *
1084  * This function provides the function currently set for the given pin.
1085  *
1086  * Return: Returns status, either success or error+reason
1087  */
1088 int zynqmp_pm_pinctrl_get_function(const u32 pin, u32 *id)
1089 {
1090         u32 ret_payload[PAYLOAD_ARG_CNT];
1091         int ret;
1092
1093         if (!id)
1094                 return -EINVAL;
1095
1096         ret = zynqmp_pm_invoke_fn(PM_PINCTRL_GET_FUNCTION, pin, 0,
1097                                   0, 0, ret_payload);
1098         *id = ret_payload[1];
1099
1100         return ret;
1101 }
1102 EXPORT_SYMBOL_GPL(zynqmp_pm_pinctrl_get_function);
1103
1104 /**
1105  * zynqmp_pm_pinctrl_set_function - Set requested function for the pin
1106  * @pin: Pin number
1107  * @id: Function ID to set
1108  *
1109  * This function sets requested function for the given pin.
1110  *
1111  * Return: Returns status, either success or error+reason.
1112  */
1113 int zynqmp_pm_pinctrl_set_function(const u32 pin, const u32 id)
1114 {
1115         return zynqmp_pm_invoke_fn(PM_PINCTRL_SET_FUNCTION, pin, id,
1116                                    0, 0, NULL);
1117 }
1118 EXPORT_SYMBOL_GPL(zynqmp_pm_pinctrl_set_function);
1119
1120 /**
1121  * zynqmp_pm_pinctrl_get_config - Get configuration parameter for the pin
1122  * @pin: Pin number
1123  * @param: Parameter to get
1124  * @value: Buffer to store parameter value
1125  *
1126  * This function gets requested configuration parameter for the given pin.
1127  *
1128  * Return: Returns status, either success or error+reason.
1129  */
1130 int zynqmp_pm_pinctrl_get_config(const u32 pin, const u32 param,
1131                                  u32 *value)
1132 {
1133         u32 ret_payload[PAYLOAD_ARG_CNT];
1134         int ret;
1135
1136         if (!value)
1137                 return -EINVAL;
1138
1139         ret = zynqmp_pm_invoke_fn(PM_PINCTRL_CONFIG_PARAM_GET, pin, param,
1140                                   0, 0, ret_payload);
1141         *value = ret_payload[1];
1142
1143         return ret;
1144 }
1145 EXPORT_SYMBOL_GPL(zynqmp_pm_pinctrl_get_config);
1146
1147 /**
1148  * zynqmp_pm_pinctrl_set_config - Set configuration parameter for the pin
1149  * @pin: Pin number
1150  * @param: Parameter to set
1151  * @value: Parameter value to set
1152  *
1153  * This function sets requested configuration parameter for the given pin.
1154  *
1155  * Return: Returns status, either success or error+reason.
1156  */
1157 int zynqmp_pm_pinctrl_set_config(const u32 pin, const u32 param,
1158                                  u32 value)
1159 {
1160         int ret;
1161
1162         if (pm_family_code == ZYNQMP_FAMILY_CODE &&
1163             param == PM_PINCTRL_CONFIG_TRI_STATE) {
1164                 ret = zynqmp_pm_feature(PM_PINCTRL_CONFIG_PARAM_SET);
1165                 if (ret < PM_PINCTRL_PARAM_SET_VERSION)
1166                         return -EOPNOTSUPP;
1167         }
1168
1169         return zynqmp_pm_invoke_fn(PM_PINCTRL_CONFIG_PARAM_SET, pin,
1170                                    param, value, 0, NULL);
1171 }
1172 EXPORT_SYMBOL_GPL(zynqmp_pm_pinctrl_set_config);
1173
1174 /**
1175  * zynqmp_pm_bootmode_read() - PM Config API for read bootpin status
1176  * @ps_mode: Returned output value of ps_mode
1177  *
1178  * This API function is to be used for notify the power management controller
1179  * to read bootpin status.
1180  *
1181  * Return: status, either success or error+reason
1182  */
1183 unsigned int zynqmp_pm_bootmode_read(u32 *ps_mode)
1184 {
1185         unsigned int ret;
1186         u32 ret_payload[PAYLOAD_ARG_CNT];
1187
1188         ret = zynqmp_pm_invoke_fn(PM_MMIO_READ, CRL_APB_BOOT_PIN_CTRL, 0,
1189                                   0, 0, ret_payload);
1190
1191         *ps_mode = ret_payload[1];
1192
1193         return ret;
1194 }
1195 EXPORT_SYMBOL_GPL(zynqmp_pm_bootmode_read);
1196
1197 /**
1198  * zynqmp_pm_bootmode_write() - PM Config API for Configure bootpin
1199  * @ps_mode: Value to be written to the bootpin ctrl register
1200  *
1201  * This API function is to be used for notify the power management controller
1202  * to configure bootpin.
1203  *
1204  * Return: Returns status, either success or error+reason
1205  */
1206 int zynqmp_pm_bootmode_write(u32 ps_mode)
1207 {
1208         return zynqmp_pm_invoke_fn(PM_MMIO_WRITE, CRL_APB_BOOT_PIN_CTRL,
1209                                    CRL_APB_BOOTPIN_CTRL_MASK, ps_mode, 0, NULL);
1210 }
1211 EXPORT_SYMBOL_GPL(zynqmp_pm_bootmode_write);
1212
1213 /**
1214  * zynqmp_pm_init_finalize() - PM call to inform firmware that the caller
1215  *                             master has initialized its own power management
1216  *
1217  * Return: Returns status, either success or error+reason
1218  *
1219  * This API function is to be used for notify the power management controller
1220  * about the completed power management initialization.
1221  */
1222 int zynqmp_pm_init_finalize(void)
1223 {
1224         return zynqmp_pm_invoke_fn(PM_PM_INIT_FINALIZE, 0, 0, 0, 0, NULL);
1225 }
1226 EXPORT_SYMBOL_GPL(zynqmp_pm_init_finalize);
1227
1228 /**
1229  * zynqmp_pm_set_suspend_mode() - Set system suspend mode
1230  * @mode:       Mode to set for system suspend
1231  *
1232  * This API function is used to set mode of system suspend.
1233  *
1234  * Return: Returns status, either success or error+reason
1235  */
1236 int zynqmp_pm_set_suspend_mode(u32 mode)
1237 {
1238         return zynqmp_pm_invoke_fn(PM_SET_SUSPEND_MODE, mode, 0, 0, 0, NULL);
1239 }
1240 EXPORT_SYMBOL_GPL(zynqmp_pm_set_suspend_mode);
1241
1242 /**
1243  * zynqmp_pm_request_node() - Request a node with specific capabilities
1244  * @node:               Node ID of the slave
1245  * @capabilities:       Requested capabilities of the slave
1246  * @qos:                Quality of service (not supported)
1247  * @ack:                Flag to specify whether acknowledge is requested
1248  *
1249  * This function is used by master to request particular node from firmware.
1250  * Every master must request node before using it.
1251  *
1252  * Return: Returns status, either success or error+reason
1253  */
1254 int zynqmp_pm_request_node(const u32 node, const u32 capabilities,
1255                            const u32 qos, const enum zynqmp_pm_request_ack ack)
1256 {
1257         return zynqmp_pm_invoke_fn(PM_REQUEST_NODE, node, capabilities,
1258                                    qos, ack, NULL);
1259 }
1260 EXPORT_SYMBOL_GPL(zynqmp_pm_request_node);
1261
1262 /**
1263  * zynqmp_pm_release_node() - Release a node
1264  * @node:       Node ID of the slave
1265  *
1266  * This function is used by master to inform firmware that master
1267  * has released node. Once released, master must not use that node
1268  * without re-request.
1269  *
1270  * Return: Returns status, either success or error+reason
1271  */
1272 int zynqmp_pm_release_node(const u32 node)
1273 {
1274         return zynqmp_pm_invoke_fn(PM_RELEASE_NODE, node, 0, 0, 0, NULL);
1275 }
1276 EXPORT_SYMBOL_GPL(zynqmp_pm_release_node);
1277
1278 /**
1279  * zynqmp_pm_get_rpu_mode() - Get RPU mode
1280  * @node_id:    Node ID of the device
1281  * @rpu_mode:   return by reference value
1282  *              either split or lockstep
1283  *
1284  * Return:      return 0 on success or error+reason.
1285  *              if success, then  rpu_mode will be set
1286  *              to current rpu mode.
1287  */
1288 int zynqmp_pm_get_rpu_mode(u32 node_id, enum rpu_oper_mode *rpu_mode)
1289 {
1290         u32 ret_payload[PAYLOAD_ARG_CNT];
1291         int ret;
1292
1293         ret = zynqmp_pm_invoke_fn(PM_IOCTL, node_id,
1294                                   IOCTL_GET_RPU_OPER_MODE, 0, 0, ret_payload);
1295
1296         /* only set rpu_mode if no error */
1297         if (ret == XST_PM_SUCCESS)
1298                 *rpu_mode = ret_payload[0];
1299
1300         return ret;
1301 }
1302 EXPORT_SYMBOL_GPL(zynqmp_pm_get_rpu_mode);
1303
1304 /**
1305  * zynqmp_pm_set_rpu_mode() - Set RPU mode
1306  * @node_id:    Node ID of the device
1307  * @rpu_mode:   Argument 1 to requested IOCTL call. either split or lockstep
1308  *
1309  *              This function is used to set RPU mode to split or
1310  *              lockstep
1311  *
1312  * Return:      Returns status, either success or error+reason
1313  */
1314 int zynqmp_pm_set_rpu_mode(u32 node_id, enum rpu_oper_mode rpu_mode)
1315 {
1316         return zynqmp_pm_invoke_fn(PM_IOCTL, node_id,
1317                                    IOCTL_SET_RPU_OPER_MODE, (u32)rpu_mode,
1318                                    0, NULL);
1319 }
1320 EXPORT_SYMBOL_GPL(zynqmp_pm_set_rpu_mode);
1321
1322 /**
1323  * zynqmp_pm_set_tcm_config - configure TCM
1324  * @node_id:    Firmware specific TCM subsystem ID
1325  * @tcm_mode:   Argument 1 to requested IOCTL call
1326  *              either PM_RPU_TCM_COMB or PM_RPU_TCM_SPLIT
1327  *
1328  * This function is used to set RPU mode to split or combined
1329  *
1330  * Return: status: 0 for success, else failure
1331  */
1332 int zynqmp_pm_set_tcm_config(u32 node_id, enum rpu_tcm_comb tcm_mode)
1333 {
1334         return zynqmp_pm_invoke_fn(PM_IOCTL, node_id,
1335                                    IOCTL_TCM_COMB_CONFIG, (u32)tcm_mode, 0,
1336                                    NULL);
1337 }
1338 EXPORT_SYMBOL_GPL(zynqmp_pm_set_tcm_config);
1339
1340 /**
1341  * zynqmp_pm_force_pwrdwn - PM call to request for another PU or subsystem to
1342  *             be powered down forcefully
1343  * @node:  Node ID of the targeted PU or subsystem
1344  * @ack:   Flag to specify whether acknowledge is requested
1345  *
1346  * Return: status, either success or error+reason
1347  */
1348 int zynqmp_pm_force_pwrdwn(const u32 node,
1349                            const enum zynqmp_pm_request_ack ack)
1350 {
1351         return zynqmp_pm_invoke_fn(PM_FORCE_POWERDOWN, node, ack, 0, 0, NULL);
1352 }
1353 EXPORT_SYMBOL_GPL(zynqmp_pm_force_pwrdwn);
1354
1355 /**
1356  * zynqmp_pm_request_wake - PM call to wake up selected master or subsystem
1357  * @node:  Node ID of the master or subsystem
1358  * @set_addr:  Specifies whether the address argument is relevant
1359  * @address:   Address from which to resume when woken up
1360  * @ack:   Flag to specify whether acknowledge requested
1361  *
1362  * Return: status, either success or error+reason
1363  */
1364 int zynqmp_pm_request_wake(const u32 node,
1365                            const bool set_addr,
1366                            const u64 address,
1367                            const enum zynqmp_pm_request_ack ack)
1368 {
1369         /* set_addr flag is encoded into 1st bit of address */
1370         return zynqmp_pm_invoke_fn(PM_REQUEST_WAKEUP, node, address | set_addr,
1371                                    address >> 32, ack, NULL);
1372 }
1373 EXPORT_SYMBOL_GPL(zynqmp_pm_request_wake);
1374
1375 /**
1376  * zynqmp_pm_set_requirement() - PM call to set requirement for PM slaves
1377  * @node:               Node ID of the slave
1378  * @capabilities:       Requested capabilities of the slave
1379  * @qos:                Quality of service (not supported)
1380  * @ack:                Flag to specify whether acknowledge is requested
1381  *
1382  * This API function is to be used for slaves a PU already has requested
1383  * to change its capabilities.
1384  *
1385  * Return: Returns status, either success or error+reason
1386  */
1387 int zynqmp_pm_set_requirement(const u32 node, const u32 capabilities,
1388                               const u32 qos,
1389                               const enum zynqmp_pm_request_ack ack)
1390 {
1391         return zynqmp_pm_invoke_fn(PM_SET_REQUIREMENT, node, capabilities,
1392                                    qos, ack, NULL);
1393 }
1394 EXPORT_SYMBOL_GPL(zynqmp_pm_set_requirement);
1395
1396 /**
1397  * zynqmp_pm_load_pdi - Load and process PDI
1398  * @src:       Source device where PDI is located
1399  * @address:   PDI src address
1400  *
1401  * This function provides support to load PDI from linux
1402  *
1403  * Return: Returns status, either success or error+reason
1404  */
1405 int zynqmp_pm_load_pdi(const u32 src, const u64 address)
1406 {
1407         return zynqmp_pm_invoke_fn(PM_LOAD_PDI, src,
1408                                    lower_32_bits(address),
1409                                    upper_32_bits(address), 0, NULL);
1410 }
1411 EXPORT_SYMBOL_GPL(zynqmp_pm_load_pdi);
1412
1413 /**
1414  * zynqmp_pm_aes_engine - Access AES hardware to encrypt/decrypt the data using
1415  * AES-GCM core.
1416  * @address:    Address of the AesParams structure.
1417  * @out:        Returned output value
1418  *
1419  * Return:      Returns status, either success or error code.
1420  */
1421 int zynqmp_pm_aes_engine(const u64 address, u32 *out)
1422 {
1423         u32 ret_payload[PAYLOAD_ARG_CNT];
1424         int ret;
1425
1426         if (!out)
1427                 return -EINVAL;
1428
1429         ret = zynqmp_pm_invoke_fn(PM_SECURE_AES, upper_32_bits(address),
1430                                   lower_32_bits(address),
1431                                   0, 0, ret_payload);
1432         *out = ret_payload[1];
1433
1434         return ret;
1435 }
1436 EXPORT_SYMBOL_GPL(zynqmp_pm_aes_engine);
1437
1438 /**
1439  * zynqmp_pm_sha_hash - Access the SHA engine to calculate the hash
1440  * @address:    Address of the data/ Address of output buffer where
1441  *              hash should be stored.
1442  * @size:       Size of the data.
1443  * @flags:
1444  *      BIT(0) - for initializing csudma driver and SHA3(Here address
1445  *               and size inputs can be NULL).
1446  *      BIT(1) - to call Sha3_Update API which can be called multiple
1447  *               times when data is not contiguous.
1448  *      BIT(2) - to get final hash of the whole updated data.
1449  *               Hash will be overwritten at provided address with
1450  *               48 bytes.
1451  *
1452  * Return:      Returns status, either success or error code.
1453  */
1454 int zynqmp_pm_sha_hash(const u64 address, const u32 size, const u32 flags)
1455 {
1456         u32 lower_addr = lower_32_bits(address);
1457         u32 upper_addr = upper_32_bits(address);
1458
1459         return zynqmp_pm_invoke_fn(PM_SECURE_SHA, upper_addr, lower_addr,
1460                                    size, flags, NULL);
1461 }
1462 EXPORT_SYMBOL_GPL(zynqmp_pm_sha_hash);
1463
1464 /**
1465  * zynqmp_pm_register_notifier() - PM API for register a subsystem
1466  *                                to be notified about specific
1467  *                                event/error.
1468  * @node:       Node ID to which the event is related.
1469  * @event:      Event Mask of Error events for which wants to get notified.
1470  * @wake:       Wake subsystem upon capturing the event if value 1
1471  * @enable:     Enable the registration for value 1, disable for value 0
1472  *
1473  * This function is used to register/un-register for particular node-event
1474  * combination in firmware.
1475  *
1476  * Return: Returns status, either success or error+reason
1477  */
1478
1479 int zynqmp_pm_register_notifier(const u32 node, const u32 event,
1480                                 const u32 wake, const u32 enable)
1481 {
1482         return zynqmp_pm_invoke_fn(PM_REGISTER_NOTIFIER, node, event,
1483                                    wake, enable, NULL);
1484 }
1485 EXPORT_SYMBOL_GPL(zynqmp_pm_register_notifier);
1486
1487 /**
1488  * zynqmp_pm_system_shutdown - PM call to request a system shutdown or restart
1489  * @type:       Shutdown or restart? 0 for shutdown, 1 for restart
1490  * @subtype:    Specifies which system should be restarted or shut down
1491  *
1492  * Return:      Returns status, either success or error+reason
1493  */
1494 int zynqmp_pm_system_shutdown(const u32 type, const u32 subtype)
1495 {
1496         return zynqmp_pm_invoke_fn(PM_SYSTEM_SHUTDOWN, type, subtype,
1497                                    0, 0, NULL);
1498 }
1499
1500 /**
1501  * zynqmp_pm_set_feature_config - PM call to request IOCTL for feature config
1502  * @id:         The config ID of the feature to be configured
1503  * @value:      The config value of the feature to be configured
1504  *
1505  * Return:      Returns 0 on success or error value on failure.
1506  */
1507 int zynqmp_pm_set_feature_config(enum pm_feature_config_id id, u32 value)
1508 {
1509         return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_SET_FEATURE_CONFIG,
1510                                    id, value, NULL);
1511 }
1512
1513 /**
1514  * zynqmp_pm_get_feature_config - PM call to get value of configured feature
1515  * @id:         The config id of the feature to be queried
1516  * @payload:    Returned value array
1517  *
1518  * Return:      Returns 0 on success or error value on failure.
1519  */
1520 int zynqmp_pm_get_feature_config(enum pm_feature_config_id id,
1521                                  u32 *payload)
1522 {
1523         return zynqmp_pm_invoke_fn(PM_IOCTL, 0, IOCTL_GET_FEATURE_CONFIG,
1524                                    id, 0, payload);
1525 }
1526
1527 /**
1528  * zynqmp_pm_set_sd_config - PM call to set value of SD config registers
1529  * @node:       SD node ID
1530  * @config:     The config type of SD registers
1531  * @value:      Value to be set
1532  *
1533  * Return:      Returns 0 on success or error value on failure.
1534  */
1535 int zynqmp_pm_set_sd_config(u32 node, enum pm_sd_config_type config, u32 value)
1536 {
1537         return zynqmp_pm_invoke_fn(PM_IOCTL, node, IOCTL_SET_SD_CONFIG,
1538                                    config, value, NULL);
1539 }
1540 EXPORT_SYMBOL_GPL(zynqmp_pm_set_sd_config);
1541
1542 /**
1543  * zynqmp_pm_set_gem_config - PM call to set value of GEM config registers
1544  * @node:       GEM node ID
1545  * @config:     The config type of GEM registers
1546  * @value:      Value to be set
1547  *
1548  * Return:      Returns 0 on success or error value on failure.
1549  */
1550 int zynqmp_pm_set_gem_config(u32 node, enum pm_gem_config_type config,
1551                              u32 value)
1552 {
1553         return zynqmp_pm_invoke_fn(PM_IOCTL, node, IOCTL_SET_GEM_CONFIG,
1554                                    config, value, NULL);
1555 }
1556 EXPORT_SYMBOL_GPL(zynqmp_pm_set_gem_config);
1557
1558 /**
1559  * struct zynqmp_pm_shutdown_scope - Struct for shutdown scope
1560  * @subtype:    Shutdown subtype
1561  * @name:       Matching string for scope argument
1562  *
1563  * This struct encapsulates mapping between shutdown scope ID and string.
1564  */
1565 struct zynqmp_pm_shutdown_scope {
1566         const enum zynqmp_pm_shutdown_subtype subtype;
1567         const char *name;
1568 };
1569
1570 static struct zynqmp_pm_shutdown_scope shutdown_scopes[] = {
1571         [ZYNQMP_PM_SHUTDOWN_SUBTYPE_SUBSYSTEM] = {
1572                 .subtype = ZYNQMP_PM_SHUTDOWN_SUBTYPE_SUBSYSTEM,
1573                 .name = "subsystem",
1574         },
1575         [ZYNQMP_PM_SHUTDOWN_SUBTYPE_PS_ONLY] = {
1576                 .subtype = ZYNQMP_PM_SHUTDOWN_SUBTYPE_PS_ONLY,
1577                 .name = "ps_only",
1578         },
1579         [ZYNQMP_PM_SHUTDOWN_SUBTYPE_SYSTEM] = {
1580                 .subtype = ZYNQMP_PM_SHUTDOWN_SUBTYPE_SYSTEM,
1581                 .name = "system",
1582         },
1583 };
1584
1585 static struct zynqmp_pm_shutdown_scope *selected_scope =
1586                 &shutdown_scopes[ZYNQMP_PM_SHUTDOWN_SUBTYPE_SYSTEM];
1587
1588 /**
1589  * zynqmp_pm_is_shutdown_scope_valid - Check if shutdown scope string is valid
1590  * @scope_string:       Shutdown scope string
1591  *
1592  * Return:              Return pointer to matching shutdown scope struct from
1593  *                      array of available options in system if string is valid,
1594  *                      otherwise returns NULL.
1595  */
1596 static struct zynqmp_pm_shutdown_scope*
1597                 zynqmp_pm_is_shutdown_scope_valid(const char *scope_string)
1598 {
1599         int count;
1600
1601         for (count = 0; count < ARRAY_SIZE(shutdown_scopes); count++)
1602                 if (sysfs_streq(scope_string, shutdown_scopes[count].name))
1603                         return &shutdown_scopes[count];
1604
1605         return NULL;
1606 }
1607
1608 static ssize_t shutdown_scope_show(struct device *device,
1609                                    struct device_attribute *attr,
1610                                    char *buf)
1611 {
1612         int i;
1613
1614         for (i = 0; i < ARRAY_SIZE(shutdown_scopes); i++) {
1615                 if (&shutdown_scopes[i] == selected_scope) {
1616                         strcat(buf, "[");
1617                         strcat(buf, shutdown_scopes[i].name);
1618                         strcat(buf, "]");
1619                 } else {
1620                         strcat(buf, shutdown_scopes[i].name);
1621                 }
1622                 strcat(buf, " ");
1623         }
1624         strcat(buf, "\n");
1625
1626         return strlen(buf);
1627 }
1628
1629 static ssize_t shutdown_scope_store(struct device *device,
1630                                     struct device_attribute *attr,
1631                                     const char *buf, size_t count)
1632 {
1633         int ret;
1634         struct zynqmp_pm_shutdown_scope *scope;
1635
1636         scope = zynqmp_pm_is_shutdown_scope_valid(buf);
1637         if (!scope)
1638                 return -EINVAL;
1639
1640         ret = zynqmp_pm_system_shutdown(ZYNQMP_PM_SHUTDOWN_TYPE_SETSCOPE_ONLY,
1641                                         scope->subtype);
1642         if (ret) {
1643                 pr_err("unable to set shutdown scope %s\n", buf);
1644                 return ret;
1645         }
1646
1647         selected_scope = scope;
1648
1649         return count;
1650 }
1651
1652 static DEVICE_ATTR_RW(shutdown_scope);
1653
1654 static ssize_t health_status_store(struct device *device,
1655                                    struct device_attribute *attr,
1656                                    const char *buf, size_t count)
1657 {
1658         int ret;
1659         unsigned int value;
1660
1661         ret = kstrtouint(buf, 10, &value);
1662         if (ret)
1663                 return ret;
1664
1665         ret = zynqmp_pm_set_boot_health_status(value);
1666         if (ret) {
1667                 dev_err(device, "unable to set healthy bit value to %u\n",
1668                         value);
1669                 return ret;
1670         }
1671
1672         return count;
1673 }
1674
1675 static DEVICE_ATTR_WO(health_status);
1676
1677 static ssize_t ggs_show(struct device *device,
1678                         struct device_attribute *attr,
1679                         char *buf,
1680                         u32 reg)
1681 {
1682         int ret;
1683         u32 ret_payload[PAYLOAD_ARG_CNT];
1684
1685         ret = zynqmp_pm_read_ggs(reg, ret_payload);
1686         if (ret)
1687                 return ret;
1688
1689         return sprintf(buf, "0x%x\n", ret_payload[1]);
1690 }
1691
1692 static ssize_t ggs_store(struct device *device,
1693                          struct device_attribute *attr,
1694                          const char *buf, size_t count,
1695                          u32 reg)
1696 {
1697         long value;
1698         int ret;
1699
1700         if (reg >= GSS_NUM_REGS)
1701                 return -EINVAL;
1702
1703         ret = kstrtol(buf, 16, &value);
1704         if (ret) {
1705                 count = -EFAULT;
1706                 goto err;
1707         }
1708
1709         ret = zynqmp_pm_write_ggs(reg, value);
1710         if (ret)
1711                 count = -EFAULT;
1712 err:
1713         return count;
1714 }
1715
1716 /* GGS register show functions */
1717 #define GGS0_SHOW(N)                                            \
1718         ssize_t ggs##N##_show(struct device *device,            \
1719                               struct device_attribute *attr,    \
1720                               char *buf)                        \
1721         {                                                       \
1722                 return ggs_show(device, attr, buf, N);          \
1723         }
1724
1725 static GGS0_SHOW(0);
1726 static GGS0_SHOW(1);
1727 static GGS0_SHOW(2);
1728 static GGS0_SHOW(3);
1729
1730 /* GGS register store function */
1731 #define GGS0_STORE(N)                                           \
1732         ssize_t ggs##N##_store(struct device *device,           \
1733                                struct device_attribute *attr,   \
1734                                const char *buf,                 \
1735                                size_t count)                    \
1736         {                                                       \
1737                 return ggs_store(device, attr, buf, count, N);  \
1738         }
1739
1740 static GGS0_STORE(0);
1741 static GGS0_STORE(1);
1742 static GGS0_STORE(2);
1743 static GGS0_STORE(3);
1744
1745 static ssize_t pggs_show(struct device *device,
1746                          struct device_attribute *attr,
1747                          char *buf,
1748                          u32 reg)
1749 {
1750         int ret;
1751         u32 ret_payload[PAYLOAD_ARG_CNT];
1752
1753         ret = zynqmp_pm_read_pggs(reg, ret_payload);
1754         if (ret)
1755                 return ret;
1756
1757         return sprintf(buf, "0x%x\n", ret_payload[1]);
1758 }
1759
1760 static ssize_t pggs_store(struct device *device,
1761                           struct device_attribute *attr,
1762                           const char *buf, size_t count,
1763                           u32 reg)
1764 {
1765         long value;
1766         int ret;
1767
1768         if (reg >= GSS_NUM_REGS)
1769                 return -EINVAL;
1770
1771         ret = kstrtol(buf, 16, &value);
1772         if (ret) {
1773                 count = -EFAULT;
1774                 goto err;
1775         }
1776
1777         ret = zynqmp_pm_write_pggs(reg, value);
1778         if (ret)
1779                 count = -EFAULT;
1780
1781 err:
1782         return count;
1783 }
1784
1785 #define PGGS0_SHOW(N)                                           \
1786         ssize_t pggs##N##_show(struct device *device,           \
1787                                struct device_attribute *attr,   \
1788                                char *buf)                       \
1789         {                                                       \
1790                 return pggs_show(device, attr, buf, N);         \
1791         }
1792
1793 #define PGGS0_STORE(N)                                          \
1794         ssize_t pggs##N##_store(struct device *device,          \
1795                                 struct device_attribute *attr,  \
1796                                 const char *buf,                \
1797                                 size_t count)                   \
1798         {                                                       \
1799                 return pggs_store(device, attr, buf, count, N); \
1800         }
1801
1802 /* PGGS register show functions */
1803 static PGGS0_SHOW(0);
1804 static PGGS0_SHOW(1);
1805 static PGGS0_SHOW(2);
1806 static PGGS0_SHOW(3);
1807
1808 /* PGGS register store functions */
1809 static PGGS0_STORE(0);
1810 static PGGS0_STORE(1);
1811 static PGGS0_STORE(2);
1812 static PGGS0_STORE(3);
1813
1814 /* GGS register attributes */
1815 static DEVICE_ATTR_RW(ggs0);
1816 static DEVICE_ATTR_RW(ggs1);
1817 static DEVICE_ATTR_RW(ggs2);
1818 static DEVICE_ATTR_RW(ggs3);
1819
1820 /* PGGS register attributes */
1821 static DEVICE_ATTR_RW(pggs0);
1822 static DEVICE_ATTR_RW(pggs1);
1823 static DEVICE_ATTR_RW(pggs2);
1824 static DEVICE_ATTR_RW(pggs3);
1825
1826 static ssize_t feature_config_id_show(struct device *device,
1827                                       struct device_attribute *attr,
1828                                       char *buf)
1829 {
1830         struct zynqmp_devinfo *devinfo = dev_get_drvdata(device);
1831
1832         return sysfs_emit(buf, "%d\n", devinfo->feature_conf_id);
1833 }
1834
1835 static ssize_t feature_config_id_store(struct device *device,
1836                                        struct device_attribute *attr,
1837                                        const char *buf, size_t count)
1838 {
1839         u32 config_id;
1840         int ret;
1841         struct zynqmp_devinfo *devinfo = dev_get_drvdata(device);
1842
1843         if (!buf)
1844                 return -EINVAL;
1845
1846         ret = kstrtou32(buf, 10, &config_id);
1847         if (ret)
1848                 return ret;
1849
1850         devinfo->feature_conf_id = config_id;
1851
1852         return count;
1853 }
1854
1855 static DEVICE_ATTR_RW(feature_config_id);
1856
1857 static ssize_t feature_config_value_show(struct device *device,
1858                                          struct device_attribute *attr,
1859                                          char *buf)
1860 {
1861         int ret;
1862         u32 ret_payload[PAYLOAD_ARG_CNT];
1863         struct zynqmp_devinfo *devinfo = dev_get_drvdata(device);
1864
1865         ret = zynqmp_pm_get_feature_config(devinfo->feature_conf_id,
1866                                            ret_payload);
1867         if (ret)
1868                 return ret;
1869
1870         return sysfs_emit(buf, "%d\n", ret_payload[1]);
1871 }
1872
1873 static ssize_t feature_config_value_store(struct device *device,
1874                                           struct device_attribute *attr,
1875                                           const char *buf, size_t count)
1876 {
1877         u32 value;
1878         int ret;
1879         struct zynqmp_devinfo *devinfo = dev_get_drvdata(device);
1880
1881         if (!buf)
1882                 return -EINVAL;
1883
1884         ret = kstrtou32(buf, 10, &value);
1885         if (ret)
1886                 return ret;
1887
1888         ret = zynqmp_pm_set_feature_config(devinfo->feature_conf_id,
1889                                            value);
1890         if (ret)
1891                 return ret;
1892
1893         return count;
1894 }
1895
1896 static DEVICE_ATTR_RW(feature_config_value);
1897
1898 static struct attribute *zynqmp_firmware_attrs[] = {
1899         &dev_attr_ggs0.attr,
1900         &dev_attr_ggs1.attr,
1901         &dev_attr_ggs2.attr,
1902         &dev_attr_ggs3.attr,
1903         &dev_attr_pggs0.attr,
1904         &dev_attr_pggs1.attr,
1905         &dev_attr_pggs2.attr,
1906         &dev_attr_pggs3.attr,
1907         &dev_attr_shutdown_scope.attr,
1908         &dev_attr_health_status.attr,
1909         &dev_attr_feature_config_id.attr,
1910         &dev_attr_feature_config_value.attr,
1911         NULL,
1912 };
1913
1914 ATTRIBUTE_GROUPS(zynqmp_firmware);
1915
1916 static int zynqmp_firmware_probe(struct platform_device *pdev)
1917 {
1918         struct device *dev = &pdev->dev;
1919         struct device_node *np;
1920         struct zynqmp_devinfo *devinfo;
1921         int ret;
1922
1923         ret = get_set_conduit_method(dev->of_node);
1924         if (ret)
1925                 return ret;
1926
1927         np = of_find_compatible_node(NULL, NULL, "xlnx,zynqmp");
1928         if (!np) {
1929                 np = of_find_compatible_node(NULL, NULL, "xlnx,versal");
1930                 if (!np)
1931                         return 0;
1932
1933                 feature_check_enabled = true;
1934         }
1935
1936         if (!feature_check_enabled) {
1937                 ret = do_feature_check_call(PM_FEATURE_CHECK);
1938                 if (ret >= 0)
1939                         feature_check_enabled = true;
1940         }
1941
1942         of_node_put(np);
1943
1944         devinfo = devm_kzalloc(dev, sizeof(*devinfo), GFP_KERNEL);
1945         if (!devinfo)
1946                 return -ENOMEM;
1947
1948         devinfo->dev = dev;
1949
1950         platform_set_drvdata(pdev, devinfo);
1951
1952         /* Check PM API version number */
1953         ret = zynqmp_pm_get_api_version(&pm_api_version);
1954         if (ret)
1955                 return ret;
1956
1957         if (pm_api_version < ZYNQMP_PM_VERSION) {
1958                 panic("%s Platform Management API version error. Expected: v%d.%d - Found: v%d.%d\n",
1959                       __func__,
1960                       ZYNQMP_PM_VERSION_MAJOR, ZYNQMP_PM_VERSION_MINOR,
1961                       pm_api_version >> 16, pm_api_version & 0xFFFF);
1962         }
1963
1964         pr_info("%s Platform Management API v%d.%d\n", __func__,
1965                 pm_api_version >> 16, pm_api_version & 0xFFFF);
1966
1967         /* Get the Family code and sub family code of platform */
1968         ret = zynqmp_pm_get_family_info(&pm_family_code, &pm_sub_family_code);
1969         if (ret < 0)
1970                 return ret;
1971
1972         /* Check trustzone version number */
1973         ret = zynqmp_pm_get_trustzone_version(&pm_tz_version);
1974         if (ret)
1975                 panic("Legacy trustzone found without version support\n");
1976
1977         if (pm_tz_version < ZYNQMP_TZ_VERSION)
1978                 panic("%s Trustzone version error. Expected: v%d.%d - Found: v%d.%d\n",
1979                       __func__,
1980                       ZYNQMP_TZ_VERSION_MAJOR, ZYNQMP_TZ_VERSION_MINOR,
1981                       pm_tz_version >> 16, pm_tz_version & 0xFFFF);
1982
1983         pr_info("%s Trustzone version v%d.%d\n", __func__,
1984                 pm_tz_version >> 16, pm_tz_version & 0xFFFF);
1985
1986         ret = mfd_add_devices(&pdev->dev, PLATFORM_DEVID_NONE, firmware_devs,
1987                               ARRAY_SIZE(firmware_devs), NULL, 0, NULL);
1988         if (ret) {
1989                 dev_err(&pdev->dev, "failed to add MFD devices %d\n", ret);
1990                 return ret;
1991         }
1992
1993         zynqmp_pm_api_debugfs_init();
1994
1995         np = of_find_compatible_node(NULL, NULL, "xlnx,versal");
1996         if (np) {
1997                 em_dev = platform_device_register_data(&pdev->dev, "xlnx_event_manager",
1998                                                        -1, NULL, 0);
1999                 if (IS_ERR(em_dev))
2000                         dev_err_probe(&pdev->dev, PTR_ERR(em_dev), "EM register fail with error\n");
2001         }
2002         of_node_put(np);
2003
2004         return of_platform_populate(dev->of_node, NULL, NULL, dev);
2005 }
2006
2007 static int zynqmp_firmware_remove(struct platform_device *pdev)
2008 {
2009         struct pm_api_feature_data *feature_data;
2010         struct hlist_node *tmp;
2011         int i;
2012
2013         mfd_remove_devices(&pdev->dev);
2014         zynqmp_pm_api_debugfs_exit();
2015
2016         hash_for_each_safe(pm_api_features_map, i, tmp, feature_data, hentry) {
2017                 hash_del(&feature_data->hentry);
2018                 kfree(feature_data);
2019         }
2020
2021         platform_device_unregister(em_dev);
2022
2023         return 0;
2024 }
2025
2026 static const struct of_device_id zynqmp_firmware_of_match[] = {
2027         {.compatible = "xlnx,zynqmp-firmware"},
2028         {.compatible = "xlnx,versal-firmware"},
2029         {},
2030 };
2031 MODULE_DEVICE_TABLE(of, zynqmp_firmware_of_match);
2032
2033 static struct platform_driver zynqmp_firmware_driver = {
2034         .driver = {
2035                 .name = "zynqmp_firmware",
2036                 .of_match_table = zynqmp_firmware_of_match,
2037                 .dev_groups = zynqmp_firmware_groups,
2038         },
2039         .probe = zynqmp_firmware_probe,
2040         .remove = zynqmp_firmware_remove,
2041 };
2042 module_platform_driver(zynqmp_firmware_driver);