1
2
3
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
27static 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
42 writel(0, base + WRAPPER_A9SS_SW_RESET);
43}
44
45int venus_set_hw_state(struct venus_core *core, bool resume)
46{
47 int ret;
48
49 if (core->use_tz) {
50 ret = qcom_scm_set_remote_state(resume, 0);
51 if (resume && ret == -EINVAL)
52 ret = 0;
53 return ret;
54 }
55
56 if (resume)
57 venus_reset_cpu(core);
58 else
59 writel(1, core->base + WRAPPER_A9SS_SW_RESET);
60
61 return 0;
62}
63
64static int venus_load_fw(struct venus_core *core, const char *fwname,
65 phys_addr_t *mem_phys, size_t *mem_size)
66{
67 const struct firmware *mdt;
68 struct device_node *node;
69 struct device *dev;
70 struct resource r;
71 ssize_t fw_size;
72 void *mem_va;
73 int ret;
74
75 *mem_phys = 0;
76 *mem_size = 0;
77
78 dev = core->dev;
79 node = of_parse_phandle(dev->of_node, "memory-region", 0);
80 if (!node) {
81 dev_err(dev, "no memory-region specified\n");
82 return -EINVAL;
83 }
84
85 ret = of_address_to_resource(node, 0, &r);
86 if (ret)
87 goto err_put_node;
88
89 ret = request_firmware(&mdt, fwname, dev);
90 if (ret < 0)
91 goto err_put_node;
92
93 fw_size = qcom_mdt_get_size(mdt);
94 if (fw_size < 0) {
95 ret = fw_size;
96 goto err_release_fw;
97 }
98
99 *mem_phys = r.start;
100 *mem_size = resource_size(&r);
101
102 if (*mem_size < fw_size || fw_size > VENUS_FW_MEM_SIZE) {
103 ret = -EINVAL;
104 goto err_release_fw;
105 }
106
107 mem_va = memremap(r.start, *mem_size, MEMREMAP_WC);
108 if (!mem_va) {
109 dev_err(dev, "unable to map memory region: %pR\n", &r);
110 ret = -ENOMEM;
111 goto err_release_fw;
112 }
113
114 if (core->use_tz)
115 ret = qcom_mdt_load(dev, mdt, fwname, VENUS_PAS_ID,
116 mem_va, *mem_phys, *mem_size, NULL);
117 else
118 ret = qcom_mdt_load_no_init(dev, mdt, fwname, VENUS_PAS_ID,
119 mem_va, *mem_phys, *mem_size, NULL);
120
121 memunmap(mem_va);
122err_release_fw:
123 release_firmware(mdt);
124err_put_node:
125 of_node_put(node);
126 return ret;
127}
128
129static int venus_boot_no_tz(struct venus_core *core, phys_addr_t mem_phys,
130 size_t mem_size)
131{
132 struct iommu_domain *iommu;
133 struct device *dev;
134 int ret;
135
136 dev = core->fw.dev;
137 if (!dev)
138 return -EPROBE_DEFER;
139
140 iommu = core->fw.iommu_domain;
141 core->fw.mapped_mem_size = mem_size;
142
143 ret = iommu_map(iommu, VENUS_FW_START_ADDR, mem_phys, mem_size,
144 IOMMU_READ | IOMMU_WRITE | IOMMU_PRIV);
145 if (ret) {
146 dev_err(dev, "could not map video firmware region\n");
147 return ret;
148 }
149
150 venus_reset_cpu(core);
151
152 return 0;
153}
154
155static int venus_shutdown_no_tz(struct venus_core *core)
156{
157 const size_t mapped = core->fw.mapped_mem_size;
158 struct iommu_domain *iommu;
159 size_t unmapped;
160 u32 reg;
161 struct device *dev = core->fw.dev;
162 void __iomem *base = core->base;
163
164
165 reg = readl_relaxed(base + WRAPPER_A9SS_SW_RESET);
166 reg |= WRAPPER_A9SS_SW_RESET_BIT;
167 writel_relaxed(reg, base + WRAPPER_A9SS_SW_RESET);
168
169
170 mb();
171
172 iommu = core->fw.iommu_domain;
173
174 if (core->fw.mapped_mem_size && iommu) {
175 unmapped = iommu_unmap(iommu, VENUS_FW_START_ADDR, mapped);
176
177 if (unmapped != mapped)
178 dev_err(dev, "failed to unmap firmware\n");
179 else
180 core->fw.mapped_mem_size = 0;
181 }
182
183 return 0;
184}
185
186int venus_boot(struct venus_core *core)
187{
188 struct device *dev = core->dev;
189 const struct venus_resources *res = core->res;
190 phys_addr_t mem_phys;
191 size_t mem_size;
192 int ret;
193
194 if (!IS_ENABLED(CONFIG_QCOM_MDT_LOADER) ||
195 (core->use_tz && !qcom_scm_is_available()))
196 return -EPROBE_DEFER;
197
198 ret = venus_load_fw(core, core->res->fwname, &mem_phys, &mem_size);
199 if (ret) {
200 dev_err(dev, "fail to load video firmware\n");
201 return -EINVAL;
202 }
203
204 if (core->use_tz)
205 ret = qcom_scm_pas_auth_and_reset(VENUS_PAS_ID);
206 else
207 ret = venus_boot_no_tz(core, mem_phys, mem_size);
208
209 if (ret)
210 return ret;
211
212 if (core->use_tz && res->cp_size) {
213 ret = qcom_scm_mem_protect_video_var(res->cp_start,
214 res->cp_size,
215 res->cp_nonpixel_start,
216 res->cp_nonpixel_size);
217 if (ret) {
218 qcom_scm_pas_shutdown(VENUS_PAS_ID);
219 dev_err(dev, "set virtual address ranges fail (%d)\n",
220 ret);
221 return ret;
222 }
223 }
224
225 return 0;
226}
227
228int venus_shutdown(struct venus_core *core)
229{
230 int ret;
231
232 if (core->use_tz)
233 ret = qcom_scm_pas_shutdown(VENUS_PAS_ID);
234 else
235 ret = venus_shutdown_no_tz(core);
236
237 return ret;
238}
239
240int venus_firmware_init(struct venus_core *core)
241{
242 struct platform_device_info info;
243 struct iommu_domain *iommu_dom;
244 struct platform_device *pdev;
245 struct device_node *np;
246 int ret;
247
248 np = of_get_child_by_name(core->dev->of_node, "video-firmware");
249 if (!np) {
250 core->use_tz = true;
251 return 0;
252 }
253
254 memset(&info, 0, sizeof(info));
255 info.fwnode = &np->fwnode;
256 info.parent = core->dev;
257 info.name = np->name;
258 info.dma_mask = DMA_BIT_MASK(32);
259
260 pdev = platform_device_register_full(&info);
261 if (IS_ERR(pdev)) {
262 of_node_put(np);
263 return PTR_ERR(pdev);
264 }
265
266 pdev->dev.of_node = np;
267
268 ret = of_dma_configure(&pdev->dev, np, true);
269 if (ret) {
270 dev_err(core->dev, "dma configure fail\n");
271 goto err_unregister;
272 }
273
274 core->fw.dev = &pdev->dev;
275
276 iommu_dom = iommu_domain_alloc(&platform_bus_type);
277 if (!iommu_dom) {
278 dev_err(core->fw.dev, "Failed to allocate iommu domain\n");
279 ret = -ENOMEM;
280 goto err_unregister;
281 }
282
283 ret = iommu_attach_device(iommu_dom, core->fw.dev);
284 if (ret) {
285 dev_err(core->fw.dev, "could not attach device\n");
286 goto err_iommu_free;
287 }
288
289 core->fw.iommu_domain = iommu_dom;
290
291 of_node_put(np);
292
293 return 0;
294
295err_iommu_free:
296 iommu_domain_free(iommu_dom);
297err_unregister:
298 platform_device_unregister(pdev);
299 of_node_put(np);
300 return ret;
301}
302
303void venus_firmware_deinit(struct venus_core *core)
304{
305 struct iommu_domain *iommu;
306
307 if (!core->fw.dev)
308 return;
309
310 iommu = core->fw.iommu_domain;
311
312 iommu_detach_device(iommu, core->fw.dev);
313
314 if (core->fw.iommu_domain) {
315 iommu_domain_free(iommu);
316 core->fw.iommu_domain = NULL;
317 }
318
319 platform_device_unregister(to_platform_device(core->fw.dev));
320}
321
