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