1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Xilinx Zynq MPSoC Firmware driver 4 * 5 * Copyright (C) 2018-2019 Xilinx, Inc. 6 */ 7 8#include <common.h> 9#include <cpu_func.h> 10#include <dm.h> 11#include <dm/device_compat.h> 12#include <dm/lists.h> 13#include <log.h> 14#include <zynqmp_firmware.h> 15#include <asm/cache.h> 16#include <asm/ptrace.h> 17 18#if defined(CONFIG_ZYNQMP_IPI) 19#include <mailbox.h> 20#include <asm/arch/sys_proto.h> 21 22#define PMUFW_PAYLOAD_ARG_CNT 8 23 24#define XST_PM_NO_ACCESS 2002L 25#define XST_PM_ALREADY_CONFIGURED 2009L 26 27static struct zynqmp_power { 28 struct mbox_chan tx_chan; 29 struct mbox_chan rx_chan; 30} zynqmp_power __section(".data"); 31 32#define NODE_ID_LOCATION 5 33 34static unsigned int xpm_configobject[] = { 35 /**********************************************************************/ 36 /* HEADER */ 37 2, /* Number of remaining words in the header */ 38 1, /* Number of sections included in config object */ 39 PM_CONFIG_OBJECT_TYPE_OVERLAY, /* Type of Config object as overlay */ 40 /**********************************************************************/ 41 /* SLAVE SECTION */ 42 43 PM_CONFIG_SLAVE_SECTION_ID, /* Section ID */ 44 1, /* Number of slaves */ 45 46 0, /* Node ID which will be changed below */ 47 PM_SLAVE_FLAG_IS_SHAREABLE, 48 PM_CONFIG_IPI_PSU_CORTEXA53_0_MASK | 49 PM_CONFIG_IPI_PSU_CORTEXR5_0_MASK | 50 PM_CONFIG_IPI_PSU_CORTEXR5_1_MASK, /* IPI Mask */ 51}; 52 53static unsigned int xpm_configobject_close[] = { 54 /**********************************************************************/ 55 /* HEADER */ 56 2, /* Number of remaining words in the header */ 57 1, /* Number of sections included in config object */ 58 PM_CONFIG_OBJECT_TYPE_OVERLAY, /* Type of Config object as overlay */ 59 /**********************************************************************/ 60 /* SET CONFIG SECTION */ 61 PM_CONFIG_SET_CONFIG_SECTION_ID, 62 0U, /* Loading permission to Overlay config object */ 63}; 64 65int zynqmp_pmufw_config_close(void) 66{ 67 return zynqmp_pmufw_load_config_object(xpm_configobject_close, 68 sizeof(xpm_configobject_close)); 69} 70 71int zynqmp_pmufw_node(u32 id) 72{ 73 static bool check = true; 74 static bool permission = true; 75 76 if (check) { 77 check = false; 78 79 if (zynqmp_pmufw_node(NODE_OCM_BANK_0) == -EACCES) { 80 printf("PMUFW: No permission to change config object\n"); 81 permission = false; 82 } 83 } 84 85 if (!permission) 86 return 0; 87 88 /* Record power domain id */ 89 xpm_configobject[NODE_ID_LOCATION] = id; 90 91 return zynqmp_pmufw_load_config_object(xpm_configobject, 92 sizeof(xpm_configobject)); 93} 94 95static int do_pm_probe(void) 96{ 97 struct udevice *dev; 98 int ret; 99 100 ret = uclass_get_device_by_driver(UCLASS_FIRMWARE, 101 DM_DRIVER_GET(zynqmp_power), 102 &dev); 103 if (ret) 104 debug("%s: Probing device failed: %d\n", __func__, ret); 105 106 return ret; 107} 108 109static int ipi_req(const u32 *req, size_t req_len, u32 *res, size_t res_maxlen) 110{ 111 struct zynqmp_ipi_msg msg; 112 int ret; 113 u32 buffer[PAYLOAD_ARG_CNT]; 114 115 if (!res) 116 res = buffer; 117 118 if (req_len > PMUFW_PAYLOAD_ARG_CNT || 119 res_maxlen > PMUFW_PAYLOAD_ARG_CNT) 120 return -EINVAL; 121 122 if (!(zynqmp_power.tx_chan.dev) || !(zynqmp_power.rx_chan.dev)) { 123 ret = do_pm_probe(); 124 if (ret) 125 return ret; 126 } 127 128 debug("%s, Sending IPI message with ID: 0x%0x\n", __func__, req[0]); 129 msg.buf = (u32 *)req; 130 msg.len = req_len; 131 ret = mbox_send(&zynqmp_power.tx_chan, &msg); 132 if (ret) { 133 debug("%s: Sending message failed\n", __func__); 134 return ret; 135 } 136 137 msg.buf = res; 138 msg.len = res_maxlen; 139 ret = mbox_recv(&zynqmp_power.rx_chan, &msg, 100); 140 if (ret) 141 debug("%s: Receiving message failed\n", __func__); 142 143 return ret; 144} 145 146unsigned int zynqmp_firmware_version(void) 147{ 148 int ret; 149 u32 ret_payload[PAYLOAD_ARG_CNT]; 150 static u32 pm_api_version = ZYNQMP_PM_VERSION_INVALID; 151 152 /* 153 * Get PMU version only once and later 154 * just return stored values instead of 155 * asking PMUFW again. 156 **/ 157 if (pm_api_version == ZYNQMP_PM_VERSION_INVALID) { 158 159 ret = xilinx_pm_request(PM_GET_API_VERSION, 0, 0, 0, 0, 160 ret_payload); 161 if (ret) 162 panic("PMUFW is not found - Please load it!\n"); 163 164 pm_api_version = ret_payload[1]; 165 if (pm_api_version < ZYNQMP_PM_VERSION) 166 panic("PMUFW version error. Expected: v%d.%d\n", 167 ZYNQMP_PM_VERSION_MAJOR, ZYNQMP_PM_VERSION_MINOR); 168 } 169 170 return pm_api_version; 171}; 172 173int zynqmp_pm_set_gem_config(u32 node, enum pm_gem_config_type config, u32 value) 174{ 175 int ret; 176 177 ret = xilinx_pm_request(PM_IOCTL, node, IOCTL_SET_GEM_CONFIG, 178 config, value, NULL); 179 if (ret) 180 printf("%s: node %d: set_gem_config %d failed\n", 181 __func__, node, config); 182 183 return ret; 184} 185 186int zynqmp_pm_set_sd_config(u32 node, enum pm_sd_config_type config, u32 value) 187{ 188 int ret; 189 190 ret = xilinx_pm_request(PM_IOCTL, node, IOCTL_SET_SD_CONFIG, 191 config, value, NULL); 192 if (ret) 193 printf("%s: node %d: set_sd_config %d failed\n", 194 __func__, node, config); 195 196 return ret; 197} 198 199int zynqmp_pm_feature(const u32 api_id) 200{ 201 int ret; 202 u32 ret_payload[PAYLOAD_ARG_CNT]; 203 204 /* Check feature check API version */ 205 ret = xilinx_pm_request(PM_FEATURE_CHECK, api_id, 0, 0, 0, 206 ret_payload); 207 if (ret) 208 return ret; 209 210 /* Return feature check version */ 211 return ret_payload[1] & FIRMWARE_VERSION_MASK; 212} 213 214int zynqmp_pm_is_function_supported(const u32 api_id, const u32 id) 215{ 216 int ret; 217 u32 *bit_mask; 218 u32 ret_payload[PAYLOAD_ARG_CNT]; 219 220 /* Input arguments validation */ 221 if (id >= 64 || (api_id != PM_IOCTL && api_id != PM_QUERY_DATA)) 222 return -EINVAL; 223 224 /* Check feature check API version */ 225 ret = xilinx_pm_request(PM_FEATURE_CHECK, PM_FEATURE_CHECK, 0, 0, 0, 226 ret_payload); 227 if (ret) 228 return ret; 229 230 /* Check if feature check version 2 is supported or not */ 231 if ((ret_payload[1] & FIRMWARE_VERSION_MASK) == PM_API_VERSION_2) { 232 /* 233 * Call feature check for IOCTL/QUERY API to get IOCTL ID or 234 * QUERY ID feature status. 235 */ 236 237 ret = xilinx_pm_request(PM_FEATURE_CHECK, api_id, 0, 0, 0, 238 ret_payload); 239 if (ret) 240 return ret; 241 242 bit_mask = &ret_payload[2]; 243 if ((bit_mask[(id / 32)] & BIT((id % 32))) == 0) 244 return -EOPNOTSUPP; 245 } else { 246 return -ENODATA; 247 } 248 249 return 0; 250} 251 252/** 253 * Send a configuration object to the PMU firmware. 254 * 255 * @cfg_obj: Pointer to the configuration object 256 * @size: Size of @cfg_obj in bytes 257 * Return: 0 on success otherwise negative errno. 258 */ 259int zynqmp_pmufw_load_config_object(const void *cfg_obj, size_t size) 260{ 261 int err; 262 u32 ret_payload[PAYLOAD_ARG_CNT]; 263 264 if (IS_ENABLED(CONFIG_SPL_BUILD)) 265 printf("Loading new PMUFW cfg obj (%ld bytes)\n", size); 266 267 flush_dcache_range((ulong)cfg_obj, (ulong)(cfg_obj + size)); 268 269 err = xilinx_pm_request(PM_SET_CONFIGURATION, (u32)(u64)cfg_obj, 0, 0, 270 0, ret_payload); 271 if (err == XST_PM_NO_ACCESS) { 272 return -EACCES; 273 } 274 275 if (err == XST_PM_ALREADY_CONFIGURED) { 276 debug("PMUFW Node is already configured\n"); 277 return -ENODEV; 278 } 279 280 if (err) 281 printf("Cannot load PMUFW configuration object (%d)\n", err); 282 283 if (ret_payload[0]) 284 printf("PMUFW returned 0x%08x status!\n", ret_payload[0]); 285 286 if ((err || ret_payload[0]) && IS_ENABLED(CONFIG_SPL_BUILD)) 287 panic("PMUFW config object loading failed in EL3\n"); 288 289 return 0; 290} 291 292static int zynqmp_power_probe(struct udevice *dev) 293{ 294 struct udevice *ipi_dev; 295 ofnode ipi_node; 296 int ret; 297 298 debug("%s, (dev=%p)\n", __func__, dev); 299 300 /* 301 * Probe all IPI parent node driver. It is important to have IPI 302 * devices available when requested by mbox_get_by* API. 303 * If IPI device isn't available, then mailbox request fails and 304 * that causes system boot failure. 305 * To avoid this make sure all IPI parent drivers are probed here, 306 * and IPI parent driver binds each child node to mailbox driver. 307 * This way mbox_get_by_* API will have correct mailbox device 308 * driver probed. 309 */ 310 ofnode_for_each_compatible_node(ipi_node, "xlnx,zynqmp-ipi-mailbox") { 311 ret = uclass_get_device_by_ofnode(UCLASS_NOP, ipi_node, &ipi_dev); 312 if (ret) { 313 dev_err(dev, "failed to get IPI device from node %s\n", 314 ofnode_get_name(ipi_node)); 315 return ret; 316 } 317 } 318 319 ret = mbox_get_by_name(dev, "tx", &zynqmp_power.tx_chan); 320 if (ret) { 321 debug("%s: Cannot find tx mailbox\n", __func__); 322 return ret; 323 } 324 325 ret = mbox_get_by_name(dev, "rx", &zynqmp_power.rx_chan); 326 if (ret) { 327 debug("%s: Cannot find rx mailbox\n", __func__); 328 return ret; 329 } 330 331 ret = zynqmp_firmware_version(); 332 printf("PMUFW:\tv%d.%d\n", 333 ret >> ZYNQMP_PM_VERSION_MAJOR_SHIFT, 334 ret & ZYNQMP_PM_VERSION_MINOR_MASK); 335 336 return 0; 337}; 338 339static const struct udevice_id zynqmp_power_ids[] = { 340 { .compatible = "xlnx,zynqmp-power" }, 341 { } 342}; 343 344U_BOOT_DRIVER(zynqmp_power) = { 345 .name = "zynqmp_power", 346 .id = UCLASS_FIRMWARE, 347 .of_match = zynqmp_power_ids, 348 .probe = zynqmp_power_probe, 349}; 350#endif 351 352int __maybe_unused xilinx_pm_request(u32 api_id, u32 arg0, u32 arg1, u32 arg2, 353 u32 arg3, u32 *ret_payload) 354{ 355 debug("%s at EL%d, API ID: 0x%0x, 0x%0x, 0x%0x, 0x%0x, 0x%0x\n", 356 __func__, current_el(), api_id, arg0, arg1, arg2, arg3); 357 358 if (IS_ENABLED(CONFIG_SPL_BUILD) || current_el() == 3) { 359#if defined(CONFIG_ZYNQMP_IPI) 360 /* 361 * Use fixed payload and arg size as the EL2 call. The firmware 362 * is capable to handle PMUFW_PAYLOAD_ARG_CNT bytes but the 363 * firmware API is limited by the SMC call size 364 */ 365 u32 regs[] = {api_id, arg0, arg1, arg2, arg3}; 366 int ret; 367 368 if (api_id == PM_FPGA_LOAD) { 369 /* Swap addr_hi/low because of incompatibility */ 370 u32 temp = regs[1]; 371 372 regs[1] = regs[2]; 373 regs[2] = temp; 374 } 375 376 ret = ipi_req(regs, PAYLOAD_ARG_CNT, ret_payload, 377 PAYLOAD_ARG_CNT); 378 if (ret) 379 return ret; 380#else 381 return -EPERM; 382#endif 383 } else { 384 /* 385 * Added SIP service call Function Identifier 386 * Make sure to stay in x0 register 387 */ 388 struct pt_regs regs; 389 390 regs.regs[0] = PM_SIP_SVC | api_id; 391 regs.regs[1] = ((u64)arg1 << 32) | arg0; 392 regs.regs[2] = ((u64)arg3 << 32) | arg2; 393 394 smc_call(®s); 395 396 if (ret_payload) { 397 ret_payload[0] = (u32)regs.regs[0]; 398 ret_payload[1] = upper_32_bits(regs.regs[0]); 399 ret_payload[2] = (u32)regs.regs[1]; 400 ret_payload[3] = upper_32_bits(regs.regs[1]); 401 ret_payload[4] = (u32)regs.regs[2]; 402 } 403 404 } 405 return (ret_payload) ? ret_payload[0] : 0; 406} 407 408static const struct udevice_id zynqmp_firmware_ids[] = { 409 { .compatible = "xlnx,zynqmp-firmware" }, 410 { .compatible = "xlnx,versal-firmware"}, 411 { .compatible = "xlnx,versal-net-firmware"}, 412 { } 413}; 414 415static int zynqmp_firmware_bind(struct udevice *dev) 416{ 417 int ret; 418 struct udevice *child; 419 420 if ((IS_ENABLED(CONFIG_SPL_BUILD) && 421 IS_ENABLED(CONFIG_SPL_POWER_DOMAIN) && 422 IS_ENABLED(CONFIG_ZYNQMP_POWER_DOMAIN)) || 423 (!IS_ENABLED(CONFIG_SPL_BUILD) && 424 IS_ENABLED(CONFIG_ZYNQMP_POWER_DOMAIN))) { 425 ret = device_bind_driver_to_node(dev, "zynqmp_power_domain", 426 "zynqmp_power_domain", 427 dev_ofnode(dev), &child); 428 if (ret) { 429 printf("zynqmp power domain driver is not bound: %d\n", ret); 430 return ret; 431 } 432 } 433 434 return 0; 435} 436 437U_BOOT_DRIVER(zynqmp_firmware) = { 438 .id = UCLASS_FIRMWARE, 439 .name = "zynqmp_firmware", 440 .of_match = zynqmp_firmware_ids, 441 .bind = zynqmp_firmware_bind, 442}; 443