1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2017 Linaro Ltd. 4 */ 5 6 #include <linux/device.h> 7 #include <linux/firmware.h> 8 #include <linux/kernel.h> 9 #include <linux/iommu.h> 10 #include <linux/io.h> 11 #include <linux/of.h> 12 #include <linux/of_address.h> 13 #include <linux/platform_device.h> 14 #include <linux/of_device.h> 15 #include <linux/qcom_scm.h> 16 #include <linux/sizes.h> 17 #include <linux/soc/qcom/mdt_loader.h> 18 19 #include "core.h" 20 #include "firmware.h" 21 #include "hfi_venus_io.h" 22 23 #define VENUS_PAS_ID 9 24 #define VENUS_FW_MEM_SIZE (6 * SZ_1M) 25 #define VENUS_FW_START_ADDR 0x0 26 27 static void venus_reset_cpu(struct venus_core *core) 28 { 29 u32 fw_size = core->fw.mapped_mem_size; 30 void __iomem *base = core->base; 31 32 writel(0, base + WRAPPER_FW_START_ADDR); 33 writel(fw_size, base + WRAPPER_FW_END_ADDR); 34 writel(0, base + WRAPPER_CPA_START_ADDR); 35 writel(fw_size, base + WRAPPER_CPA_END_ADDR); 36 writel(fw_size, base + WRAPPER_NONPIX_START_ADDR); 37 writel(fw_size, base + WRAPPER_NONPIX_END_ADDR); 38 writel(0x0, base + WRAPPER_CPU_CGC_DIS); 39 writel(0x0, base + WRAPPER_CPU_CLOCK_CONFIG); 40 41 /* Bring ARM9 out of reset */ 42 writel(0, base + WRAPPER_A9SS_SW_RESET); 43 } 44 45 int venus_set_hw_state(struct venus_core *core, bool resume) 46 { 47 if (core->use_tz) 48 return qcom_scm_set_remote_state(resume, 0); 49 50 if (resume) 51 venus_reset_cpu(core); 52 else 53 writel(1, core->base + WRAPPER_A9SS_SW_RESET); 54 55 return 0; 56 } 57 58 static int venus_load_fw(struct venus_core *core, const char *fwname, 59 phys_addr_t *mem_phys, size_t *mem_size) 60 { 61 const struct firmware *mdt; 62 struct device_node *node; 63 struct device *dev; 64 struct resource r; 65 ssize_t fw_size; 66 void *mem_va; 67 int ret; 68 69 *mem_phys = 0; 70 *mem_size = 0; 71 72 dev = core->dev; 73 node = of_parse_phandle(dev->of_node, "memory-region", 0); 74 if (!node) { 75 dev_err(dev, "no memory-region specified\n"); 76 return -EINVAL; 77 } 78 79 ret = of_address_to_resource(node, 0, &r); 80 if (ret) 81 goto err_put_node; 82 83 ret = request_firmware(&mdt, fwname, dev); 84 if (ret < 0) 85 goto err_put_node; 86 87 fw_size = qcom_mdt_get_size(mdt); 88 if (fw_size < 0) { 89 ret = fw_size; 90 goto err_release_fw; 91 } 92 93 *mem_phys = r.start; 94 *mem_size = resource_size(&r); 95 96 if (*mem_size < fw_size || fw_size > VENUS_FW_MEM_SIZE) { 97 ret = -EINVAL; 98 goto err_release_fw; 99 } 100 101 mem_va = memremap(r.start, *mem_size, MEMREMAP_WC); 102 if (!mem_va) { 103 dev_err(dev, "unable to map memory region: %pR\n", &r); 104 ret = -ENOMEM; 105 goto err_release_fw; 106 } 107 108 if (core->use_tz) 109 ret = qcom_mdt_load(dev, mdt, fwname, VENUS_PAS_ID, 110 mem_va, *mem_phys, *mem_size, NULL); 111 else 112 ret = qcom_mdt_load_no_init(dev, mdt, fwname, VENUS_PAS_ID, 113 mem_va, *mem_phys, *mem_size, NULL); 114 115 memunmap(mem_va); 116 err_release_fw: 117 release_firmware(mdt); 118 err_put_node: 119 of_node_put(node); 120 return ret; 121 } 122 123 static int venus_boot_no_tz(struct venus_core *core, phys_addr_t mem_phys, 124 size_t mem_size) 125 { 126 struct iommu_domain *iommu; 127 struct device *dev; 128 int ret; 129 130 dev = core->fw.dev; 131 if (!dev) 132 return -EPROBE_DEFER; 133 134 iommu = core->fw.iommu_domain; 135 core->fw.mapped_mem_size = mem_size; 136 137 ret = iommu_map(iommu, VENUS_FW_START_ADDR, mem_phys, mem_size, 138 IOMMU_READ | IOMMU_WRITE | IOMMU_PRIV); 139 if (ret) { 140 dev_err(dev, "could not map video firmware region\n"); 141 return ret; 142 } 143 144 venus_reset_cpu(core); 145 146 return 0; 147 } 148 149 static int venus_shutdown_no_tz(struct venus_core *core) 150 { 151 const size_t mapped = core->fw.mapped_mem_size; 152 struct iommu_domain *iommu; 153 size_t unmapped; 154 u32 reg; 155 struct device *dev = core->fw.dev; 156 void __iomem *base = core->base; 157 158 /* Assert the reset to ARM9 */ 159 reg = readl_relaxed(base + WRAPPER_A9SS_SW_RESET); 160 reg |= WRAPPER_A9SS_SW_RESET_BIT; 161 writel_relaxed(reg, base + WRAPPER_A9SS_SW_RESET); 162 163 /* Make sure reset is asserted before the mapping is removed */ 164 mb(); 165 166 iommu = core->fw.iommu_domain; 167 168 unmapped = iommu_unmap(iommu, VENUS_FW_START_ADDR, mapped); 169 if (unmapped != mapped) 170 dev_err(dev, "failed to unmap firmware\n"); 171 172 return 0; 173 } 174 175 int venus_boot(struct venus_core *core) 176 { 177 struct device *dev = core->dev; 178 phys_addr_t mem_phys; 179 size_t mem_size; 180 int ret; 181 182 if (!IS_ENABLED(CONFIG_QCOM_MDT_LOADER) || 183 (core->use_tz && !qcom_scm_is_available())) 184 return -EPROBE_DEFER; 185 186 ret = venus_load_fw(core, core->res->fwname, &mem_phys, &mem_size); 187 if (ret) { 188 dev_err(dev, "fail to load video firmware\n"); 189 return -EINVAL; 190 } 191 192 if (core->use_tz) 193 ret = qcom_scm_pas_auth_and_reset(VENUS_PAS_ID); 194 else 195 ret = venus_boot_no_tz(core, mem_phys, mem_size); 196 197 return ret; 198 } 199 200 int venus_shutdown(struct venus_core *core) 201 { 202 int ret; 203 204 if (core->use_tz) 205 ret = qcom_scm_pas_shutdown(VENUS_PAS_ID); 206 else 207 ret = venus_shutdown_no_tz(core); 208 209 return ret; 210 } 211 212 int venus_firmware_init(struct venus_core *core) 213 { 214 struct platform_device_info info; 215 struct iommu_domain *iommu_dom; 216 struct platform_device *pdev; 217 struct device_node *np; 218 int ret; 219 220 np = of_get_child_by_name(core->dev->of_node, "video-firmware"); 221 if (!np) { 222 core->use_tz = true; 223 return 0; 224 } 225 226 memset(&info, 0, sizeof(info)); 227 info.fwnode = &np->fwnode; 228 info.parent = core->dev; 229 info.name = np->name; 230 info.dma_mask = DMA_BIT_MASK(32); 231 232 pdev = platform_device_register_full(&info); 233 if (IS_ERR(pdev)) { 234 of_node_put(np); 235 return PTR_ERR(pdev); 236 } 237 238 pdev->dev.of_node = np; 239 240 ret = of_dma_configure(&pdev->dev, np, true); 241 if (ret) { 242 dev_err(core->dev, "dma configure fail\n"); 243 goto err_unregister; 244 } 245 246 core->fw.dev = &pdev->dev; 247 248 iommu_dom = iommu_domain_alloc(&platform_bus_type); 249 if (!iommu_dom) { 250 dev_err(core->fw.dev, "Failed to allocate iommu domain\n"); 251 ret = -ENOMEM; 252 goto err_unregister; 253 } 254 255 ret = iommu_attach_device(iommu_dom, core->fw.dev); 256 if (ret) { 257 dev_err(core->fw.dev, "could not attach device\n"); 258 goto err_iommu_free; 259 } 260 261 core->fw.iommu_domain = iommu_dom; 262 263 of_node_put(np); 264 265 return 0; 266 267 err_iommu_free: 268 iommu_domain_free(iommu_dom); 269 err_unregister: 270 platform_device_unregister(pdev); 271 of_node_put(np); 272 return ret; 273 } 274 275 void venus_firmware_deinit(struct venus_core *core) 276 { 277 struct iommu_domain *iommu; 278 279 if (!core->fw.dev) 280 return; 281 282 iommu = core->fw.iommu_domain; 283 284 iommu_detach_device(iommu, core->fw.dev); 285 iommu_domain_free(iommu); 286 287 platform_device_unregister(to_platform_device(core->fw.dev)); 288 } 289