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