1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2017 Pengutronix, Oleksij Rempel <kernel@pengutronix.de>
4 */
5
6 #include <linux/arm-smccc.h>
7 #include <linux/clk.h>
8 #include <linux/err.h>
9 #include <linux/interrupt.h>
10 #include <linux/kernel.h>
11 #include <linux/mailbox_client.h>
12 #include <linux/mfd/syscon.h>
13 #include <linux/module.h>
14 #include <linux/of_address.h>
15 #include <linux/of_reserved_mem.h>
16 #include <linux/of_device.h>
17 #include <linux/platform_device.h>
18 #include <linux/regmap.h>
19 #include <linux/remoteproc.h>
20 #include <linux/workqueue.h>
21
22 #include "remoteproc_internal.h"
23
24 #define IMX7D_SRC_SCR 0x0C
25 #define IMX7D_ENABLE_M4 BIT(3)
26 #define IMX7D_SW_M4P_RST BIT(2)
27 #define IMX7D_SW_M4C_RST BIT(1)
28 #define IMX7D_SW_M4C_NON_SCLR_RST BIT(0)
29
30 #define IMX7D_M4_RST_MASK (IMX7D_ENABLE_M4 | IMX7D_SW_M4P_RST \
31 | IMX7D_SW_M4C_RST \
32 | IMX7D_SW_M4C_NON_SCLR_RST)
33
34 #define IMX7D_M4_START (IMX7D_ENABLE_M4 | IMX7D_SW_M4P_RST \
35 | IMX7D_SW_M4C_RST)
36 #define IMX7D_M4_STOP IMX7D_SW_M4C_NON_SCLR_RST
37
38 /* Address: 0x020D8000 */
39 #define IMX6SX_SRC_SCR 0x00
40 #define IMX6SX_ENABLE_M4 BIT(22)
41 #define IMX6SX_SW_M4P_RST BIT(12)
42 #define IMX6SX_SW_M4C_NON_SCLR_RST BIT(4)
43 #define IMX6SX_SW_M4C_RST BIT(3)
44
45 #define IMX6SX_M4_START (IMX6SX_ENABLE_M4 | IMX6SX_SW_M4P_RST \
46 | IMX6SX_SW_M4C_RST)
47 #define IMX6SX_M4_STOP IMX6SX_SW_M4C_NON_SCLR_RST
48 #define IMX6SX_M4_RST_MASK (IMX6SX_ENABLE_M4 | IMX6SX_SW_M4P_RST \
49 | IMX6SX_SW_M4C_NON_SCLR_RST \
50 | IMX6SX_SW_M4C_RST)
51
52 #define IMX_RPROC_MEM_MAX 32
53
54 #define IMX_SIP_RPROC 0xC2000005
55 #define IMX_SIP_RPROC_START 0x00
56 #define IMX_SIP_RPROC_STARTED 0x01
57 #define IMX_SIP_RPROC_STOP 0x02
58
59 /**
60 * struct imx_rproc_mem - slim internal memory structure
61 * @cpu_addr: MPU virtual address of the memory region
62 * @sys_addr: Bus address used to access the memory region
63 * @size: Size of the memory region
64 */
65 struct imx_rproc_mem {
66 void __iomem *cpu_addr;
67 phys_addr_t sys_addr;
68 size_t size;
69 };
70
71 /* att flags */
72 /* M4 own area. Can be mapped at probe */
73 #define ATT_OWN BIT(1)
74 #define ATT_IOMEM BIT(2)
75
76 /* address translation table */
77 struct imx_rproc_att {
78 u32 da; /* device address (From Cortex M4 view)*/
79 u32 sa; /* system bus address */
80 u32 size; /* size of reg range */
81 int flags;
82 };
83
84 /* Remote core start/stop method */
85 enum imx_rproc_method {
86 IMX_RPROC_NONE,
87 /* Through syscon regmap */
88 IMX_RPROC_MMIO,
89 /* Through ARM SMCCC */
90 IMX_RPROC_SMC,
91 };
92
93 struct imx_rproc_dcfg {
94 u32 src_reg;
95 u32 src_mask;
96 u32 src_start;
97 u32 src_stop;
98 const struct imx_rproc_att *att;
99 size_t att_size;
100 enum imx_rproc_method method;
101 };
102
103 struct imx_rproc {
104 struct device *dev;
105 struct regmap *regmap;
106 struct rproc *rproc;
107 const struct imx_rproc_dcfg *dcfg;
108 struct imx_rproc_mem mem[IMX_RPROC_MEM_MAX];
109 struct clk *clk;
110 struct mbox_client cl;
111 struct mbox_chan *tx_ch;
112 struct mbox_chan *rx_ch;
113 struct work_struct rproc_work;
114 struct workqueue_struct *workqueue;
115 void __iomem *rsc_table;
116 };
117
118 static const struct imx_rproc_att imx_rproc_att_imx8mn[] = {
119 /* dev addr , sys addr , size , flags */
120 /* ITCM */
121 { 0x00000000, 0x007E0000, 0x00020000, ATT_OWN | ATT_IOMEM },
122 /* OCRAM_S */
123 { 0x00180000, 0x00180000, 0x00009000, 0 },
124 /* OCRAM */
125 { 0x00900000, 0x00900000, 0x00020000, 0 },
126 /* OCRAM */
127 { 0x00920000, 0x00920000, 0x00020000, 0 },
128 /* OCRAM */
129 { 0x00940000, 0x00940000, 0x00050000, 0 },
130 /* QSPI Code - alias */
131 { 0x08000000, 0x08000000, 0x08000000, 0 },
132 /* DDR (Code) - alias */
133 { 0x10000000, 0x40000000, 0x0FFE0000, 0 },
134 /* DTCM */
135 { 0x20000000, 0x00800000, 0x00020000, ATT_OWN | ATT_IOMEM },
136 /* OCRAM_S - alias */
137 { 0x20180000, 0x00180000, 0x00008000, ATT_OWN },
138 /* OCRAM */
139 { 0x20200000, 0x00900000, 0x00020000, ATT_OWN },
140 /* OCRAM */
141 { 0x20220000, 0x00920000, 0x00020000, ATT_OWN },
142 /* OCRAM */
143 { 0x20240000, 0x00940000, 0x00040000, ATT_OWN },
144 /* DDR (Data) */
145 { 0x40000000, 0x40000000, 0x80000000, 0 },
146 };
147
148 static const struct imx_rproc_att imx_rproc_att_imx8mq[] = {
149 /* dev addr , sys addr , size , flags */
150 /* TCML - alias */
151 { 0x00000000, 0x007e0000, 0x00020000, ATT_IOMEM},
152 /* OCRAM_S */
153 { 0x00180000, 0x00180000, 0x00008000, 0 },
154 /* OCRAM */
155 { 0x00900000, 0x00900000, 0x00020000, 0 },
156 /* OCRAM */
157 { 0x00920000, 0x00920000, 0x00020000, 0 },
158 /* QSPI Code - alias */
159 { 0x08000000, 0x08000000, 0x08000000, 0 },
160 /* DDR (Code) - alias */
161 { 0x10000000, 0x80000000, 0x0FFE0000, 0 },
162 /* TCML */
163 { 0x1FFE0000, 0x007E0000, 0x00020000, ATT_OWN | ATT_IOMEM},
164 /* TCMU */
165 { 0x20000000, 0x00800000, 0x00020000, ATT_OWN | ATT_IOMEM},
166 /* OCRAM_S */
167 { 0x20180000, 0x00180000, 0x00008000, ATT_OWN },
168 /* OCRAM */
169 { 0x20200000, 0x00900000, 0x00020000, ATT_OWN },
170 /* OCRAM */
171 { 0x20220000, 0x00920000, 0x00020000, ATT_OWN },
172 /* DDR (Data) */
173 { 0x40000000, 0x40000000, 0x80000000, 0 },
174 };
175
176 static const struct imx_rproc_att imx_rproc_att_imx8ulp[] = {
177 {0x1FFC0000, 0x1FFC0000, 0xC0000, ATT_OWN},
178 {0x21000000, 0x21000000, 0x10000, ATT_OWN},
179 {0x80000000, 0x80000000, 0x60000000, 0}
180 };
181
182 static const struct imx_rproc_att imx_rproc_att_imx7ulp[] = {
183 {0x1FFD0000, 0x1FFD0000, 0x30000, ATT_OWN},
184 {0x20000000, 0x20000000, 0x10000, ATT_OWN},
185 {0x2F000000, 0x2F000000, 0x20000, ATT_OWN},
186 {0x2F020000, 0x2F020000, 0x20000, ATT_OWN},
187 {0x60000000, 0x60000000, 0x40000000, 0}
188 };
189
190 static const struct imx_rproc_att imx_rproc_att_imx7d[] = {
191 /* dev addr , sys addr , size , flags */
192 /* OCRAM_S (M4 Boot code) - alias */
193 { 0x00000000, 0x00180000, 0x00008000, 0 },
194 /* OCRAM_S (Code) */
195 { 0x00180000, 0x00180000, 0x00008000, ATT_OWN },
196 /* OCRAM (Code) - alias */
197 { 0x00900000, 0x00900000, 0x00020000, 0 },
198 /* OCRAM_EPDC (Code) - alias */
199 { 0x00920000, 0x00920000, 0x00020000, 0 },
200 /* OCRAM_PXP (Code) - alias */
201 { 0x00940000, 0x00940000, 0x00008000, 0 },
202 /* TCML (Code) */
203 { 0x1FFF8000, 0x007F8000, 0x00008000, ATT_OWN | ATT_IOMEM },
204 /* DDR (Code) - alias, first part of DDR (Data) */
205 { 0x10000000, 0x80000000, 0x0FFF0000, 0 },
206
207 /* TCMU (Data) */
208 { 0x20000000, 0x00800000, 0x00008000, ATT_OWN | ATT_IOMEM },
209 /* OCRAM (Data) */
210 { 0x20200000, 0x00900000, 0x00020000, 0 },
211 /* OCRAM_EPDC (Data) */
212 { 0x20220000, 0x00920000, 0x00020000, 0 },
213 /* OCRAM_PXP (Data) */
214 { 0x20240000, 0x00940000, 0x00008000, 0 },
215 /* DDR (Data) */
216 { 0x80000000, 0x80000000, 0x60000000, 0 },
217 };
218
219 static const struct imx_rproc_att imx_rproc_att_imx6sx[] = {
220 /* dev addr , sys addr , size , flags */
221 /* TCML (M4 Boot Code) - alias */
222 { 0x00000000, 0x007F8000, 0x00008000, ATT_IOMEM },
223 /* OCRAM_S (Code) */
224 { 0x00180000, 0x008F8000, 0x00004000, 0 },
225 /* OCRAM_S (Code) - alias */
226 { 0x00180000, 0x008FC000, 0x00004000, 0 },
227 /* TCML (Code) */
228 { 0x1FFF8000, 0x007F8000, 0x00008000, ATT_OWN | ATT_IOMEM },
229 /* DDR (Code) - alias, first part of DDR (Data) */
230 { 0x10000000, 0x80000000, 0x0FFF8000, 0 },
231
232 /* TCMU (Data) */
233 { 0x20000000, 0x00800000, 0x00008000, ATT_OWN | ATT_IOMEM },
234 /* OCRAM_S (Data) - alias? */
235 { 0x208F8000, 0x008F8000, 0x00004000, 0 },
236 /* DDR (Data) */
237 { 0x80000000, 0x80000000, 0x60000000, 0 },
238 };
239
240 static const struct imx_rproc_dcfg imx_rproc_cfg_imx8mn = {
241 .att = imx_rproc_att_imx8mn,
242 .att_size = ARRAY_SIZE(imx_rproc_att_imx8mn),
243 .method = IMX_RPROC_SMC,
244 };
245
246 static const struct imx_rproc_dcfg imx_rproc_cfg_imx8mq = {
247 .src_reg = IMX7D_SRC_SCR,
248 .src_mask = IMX7D_M4_RST_MASK,
249 .src_start = IMX7D_M4_START,
250 .src_stop = IMX7D_M4_STOP,
251 .att = imx_rproc_att_imx8mq,
252 .att_size = ARRAY_SIZE(imx_rproc_att_imx8mq),
253 .method = IMX_RPROC_MMIO,
254 };
255
256 static const struct imx_rproc_dcfg imx_rproc_cfg_imx8ulp = {
257 .att = imx_rproc_att_imx8ulp,
258 .att_size = ARRAY_SIZE(imx_rproc_att_imx8ulp),
259 .method = IMX_RPROC_NONE,
260 };
261
262 static const struct imx_rproc_dcfg imx_rproc_cfg_imx7ulp = {
263 .att = imx_rproc_att_imx7ulp,
264 .att_size = ARRAY_SIZE(imx_rproc_att_imx7ulp),
265 .method = IMX_RPROC_NONE,
266 };
267
268 static const struct imx_rproc_dcfg imx_rproc_cfg_imx7d = {
269 .src_reg = IMX7D_SRC_SCR,
270 .src_mask = IMX7D_M4_RST_MASK,
271 .src_start = IMX7D_M4_START,
272 .src_stop = IMX7D_M4_STOP,
273 .att = imx_rproc_att_imx7d,
274 .att_size = ARRAY_SIZE(imx_rproc_att_imx7d),
275 .method = IMX_RPROC_MMIO,
276 };
277
278 static const struct imx_rproc_dcfg imx_rproc_cfg_imx6sx = {
279 .src_reg = IMX6SX_SRC_SCR,
280 .src_mask = IMX6SX_M4_RST_MASK,
281 .src_start = IMX6SX_M4_START,
282 .src_stop = IMX6SX_M4_STOP,
283 .att = imx_rproc_att_imx6sx,
284 .att_size = ARRAY_SIZE(imx_rproc_att_imx6sx),
285 .method = IMX_RPROC_MMIO,
286 };
287
imx_rproc_start(struct rproc * rproc)288 static int imx_rproc_start(struct rproc *rproc)
289 {
290 struct imx_rproc *priv = rproc->priv;
291 const struct imx_rproc_dcfg *dcfg = priv->dcfg;
292 struct device *dev = priv->dev;
293 struct arm_smccc_res res;
294 int ret;
295
296 switch (dcfg->method) {
297 case IMX_RPROC_MMIO:
298 ret = regmap_update_bits(priv->regmap, dcfg->src_reg, dcfg->src_mask,
299 dcfg->src_start);
300 break;
301 case IMX_RPROC_SMC:
302 arm_smccc_smc(IMX_SIP_RPROC, IMX_SIP_RPROC_START, 0, 0, 0, 0, 0, 0, &res);
303 ret = res.a0;
304 break;
305 default:
306 return -EOPNOTSUPP;
307 }
308
309 if (ret)
310 dev_err(dev, "Failed to enable remote core!\n");
311
312 return ret;
313 }
314
imx_rproc_stop(struct rproc * rproc)315 static int imx_rproc_stop(struct rproc *rproc)
316 {
317 struct imx_rproc *priv = rproc->priv;
318 const struct imx_rproc_dcfg *dcfg = priv->dcfg;
319 struct device *dev = priv->dev;
320 struct arm_smccc_res res;
321 int ret;
322
323 switch (dcfg->method) {
324 case IMX_RPROC_MMIO:
325 ret = regmap_update_bits(priv->regmap, dcfg->src_reg, dcfg->src_mask,
326 dcfg->src_stop);
327 break;
328 case IMX_RPROC_SMC:
329 arm_smccc_smc(IMX_SIP_RPROC, IMX_SIP_RPROC_STOP, 0, 0, 0, 0, 0, 0, &res);
330 ret = res.a0;
331 if (res.a1)
332 dev_info(dev, "Not in wfi, force stopped\n");
333 break;
334 default:
335 return -EOPNOTSUPP;
336 }
337
338 if (ret)
339 dev_err(dev, "Failed to stop remote core\n");
340
341 return ret;
342 }
343
imx_rproc_da_to_sys(struct imx_rproc * priv,u64 da,size_t len,u64 * sys,bool * is_iomem)344 static int imx_rproc_da_to_sys(struct imx_rproc *priv, u64 da,
345 size_t len, u64 *sys, bool *is_iomem)
346 {
347 const struct imx_rproc_dcfg *dcfg = priv->dcfg;
348 int i;
349
350 /* parse address translation table */
351 for (i = 0; i < dcfg->att_size; i++) {
352 const struct imx_rproc_att *att = &dcfg->att[i];
353
354 if (da >= att->da && da + len < att->da + att->size) {
355 unsigned int offset = da - att->da;
356
357 *sys = att->sa + offset;
358 if (is_iomem)
359 *is_iomem = att->flags & ATT_IOMEM;
360 return 0;
361 }
362 }
363
364 dev_warn(priv->dev, "Translation failed: da = 0x%llx len = 0x%zx\n",
365 da, len);
366 return -ENOENT;
367 }
368
imx_rproc_da_to_va(struct rproc * rproc,u64 da,size_t len,bool * is_iomem)369 static void *imx_rproc_da_to_va(struct rproc *rproc, u64 da, size_t len, bool *is_iomem)
370 {
371 struct imx_rproc *priv = rproc->priv;
372 void *va = NULL;
373 u64 sys;
374 int i;
375
376 if (len == 0)
377 return NULL;
378
379 /*
380 * On device side we have many aliases, so we need to convert device
381 * address (M4) to system bus address first.
382 */
383 if (imx_rproc_da_to_sys(priv, da, len, &sys, is_iomem))
384 return NULL;
385
386 for (i = 0; i < IMX_RPROC_MEM_MAX; i++) {
387 if (sys >= priv->mem[i].sys_addr && sys + len <
388 priv->mem[i].sys_addr + priv->mem[i].size) {
389 unsigned int offset = sys - priv->mem[i].sys_addr;
390 /* __force to make sparse happy with type conversion */
391 va = (__force void *)(priv->mem[i].cpu_addr + offset);
392 break;
393 }
394 }
395
396 dev_dbg(&rproc->dev, "da = 0x%llx len = 0x%zx va = 0x%p\n",
397 da, len, va);
398
399 return va;
400 }
401
imx_rproc_mem_alloc(struct rproc * rproc,struct rproc_mem_entry * mem)402 static int imx_rproc_mem_alloc(struct rproc *rproc,
403 struct rproc_mem_entry *mem)
404 {
405 struct device *dev = rproc->dev.parent;
406 void *va;
407
408 dev_dbg(dev, "map memory: %p+%zx\n", &mem->dma, mem->len);
409 va = ioremap_wc(mem->dma, mem->len);
410 if (IS_ERR_OR_NULL(va)) {
411 dev_err(dev, "Unable to map memory region: %p+%zx\n",
412 &mem->dma, mem->len);
413 return -ENOMEM;
414 }
415
416 /* Update memory entry va */
417 mem->va = va;
418
419 return 0;
420 }
421
imx_rproc_mem_release(struct rproc * rproc,struct rproc_mem_entry * mem)422 static int imx_rproc_mem_release(struct rproc *rproc,
423 struct rproc_mem_entry *mem)
424 {
425 dev_dbg(rproc->dev.parent, "unmap memory: %pa\n", &mem->dma);
426 iounmap(mem->va);
427
428 return 0;
429 }
430
imx_rproc_prepare(struct rproc * rproc)431 static int imx_rproc_prepare(struct rproc *rproc)
432 {
433 struct imx_rproc *priv = rproc->priv;
434 struct device_node *np = priv->dev->of_node;
435 struct of_phandle_iterator it;
436 struct rproc_mem_entry *mem;
437 struct reserved_mem *rmem;
438 u32 da;
439
440 /* Register associated reserved memory regions */
441 of_phandle_iterator_init(&it, np, "memory-region", NULL, 0);
442 while (of_phandle_iterator_next(&it) == 0) {
443 /*
444 * Ignore the first memory region which will be used vdev buffer.
445 * No need to do extra handlings, rproc_add_virtio_dev will handle it.
446 */
447 if (!strcmp(it.node->name, "vdev0buffer"))
448 continue;
449
450 if (!strcmp(it.node->name, "rsc-table"))
451 continue;
452
453 rmem = of_reserved_mem_lookup(it.node);
454 if (!rmem) {
455 of_node_put(it.node);
456 dev_err(priv->dev, "unable to acquire memory-region\n");
457 return -EINVAL;
458 }
459
460 /* No need to translate pa to da, i.MX use same map */
461 da = rmem->base;
462
463 /* Register memory region */
464 mem = rproc_mem_entry_init(priv->dev, NULL, (dma_addr_t)rmem->base, rmem->size, da,
465 imx_rproc_mem_alloc, imx_rproc_mem_release,
466 it.node->name);
467
468 if (mem) {
469 rproc_coredump_add_segment(rproc, da, rmem->size);
470 } else {
471 of_node_put(it.node);
472 return -ENOMEM;
473 }
474
475 rproc_add_carveout(rproc, mem);
476 }
477
478 return 0;
479 }
480
imx_rproc_parse_fw(struct rproc * rproc,const struct firmware * fw)481 static int imx_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw)
482 {
483 int ret;
484
485 ret = rproc_elf_load_rsc_table(rproc, fw);
486 if (ret)
487 dev_info(&rproc->dev, "No resource table in elf\n");
488
489 return 0;
490 }
491
imx_rproc_kick(struct rproc * rproc,int vqid)492 static void imx_rproc_kick(struct rproc *rproc, int vqid)
493 {
494 struct imx_rproc *priv = rproc->priv;
495 int err;
496 __u32 mmsg;
497
498 if (!priv->tx_ch) {
499 dev_err(priv->dev, "No initialized mbox tx channel\n");
500 return;
501 }
502
503 /*
504 * Send the index of the triggered virtqueue as the mu payload.
505 * Let remote processor know which virtqueue is used.
506 */
507 mmsg = vqid << 16;
508
509 err = mbox_send_message(priv->tx_ch, (void *)&mmsg);
510 if (err < 0)
511 dev_err(priv->dev, "%s: failed (%d, err:%d)\n",
512 __func__, vqid, err);
513 }
514
imx_rproc_attach(struct rproc * rproc)515 static int imx_rproc_attach(struct rproc *rproc)
516 {
517 return 0;
518 }
519
imx_rproc_get_loaded_rsc_table(struct rproc * rproc,size_t * table_sz)520 static struct resource_table *imx_rproc_get_loaded_rsc_table(struct rproc *rproc, size_t *table_sz)
521 {
522 struct imx_rproc *priv = rproc->priv;
523
524 /* The resource table has already been mapped in imx_rproc_addr_init */
525 if (!priv->rsc_table)
526 return NULL;
527
528 *table_sz = SZ_1K;
529 return (struct resource_table *)priv->rsc_table;
530 }
531
532 static const struct rproc_ops imx_rproc_ops = {
533 .prepare = imx_rproc_prepare,
534 .attach = imx_rproc_attach,
535 .start = imx_rproc_start,
536 .stop = imx_rproc_stop,
537 .kick = imx_rproc_kick,
538 .da_to_va = imx_rproc_da_to_va,
539 .load = rproc_elf_load_segments,
540 .parse_fw = imx_rproc_parse_fw,
541 .find_loaded_rsc_table = rproc_elf_find_loaded_rsc_table,
542 .get_loaded_rsc_table = imx_rproc_get_loaded_rsc_table,
543 .sanity_check = rproc_elf_sanity_check,
544 .get_boot_addr = rproc_elf_get_boot_addr,
545 };
546
imx_rproc_addr_init(struct imx_rproc * priv,struct platform_device * pdev)547 static int imx_rproc_addr_init(struct imx_rproc *priv,
548 struct platform_device *pdev)
549 {
550 const struct imx_rproc_dcfg *dcfg = priv->dcfg;
551 struct device *dev = &pdev->dev;
552 struct device_node *np = dev->of_node;
553 int a, b = 0, err, nph;
554
555 /* remap required addresses */
556 for (a = 0; a < dcfg->att_size; a++) {
557 const struct imx_rproc_att *att = &dcfg->att[a];
558
559 if (!(att->flags & ATT_OWN))
560 continue;
561
562 if (b >= IMX_RPROC_MEM_MAX)
563 break;
564
565 if (att->flags & ATT_IOMEM)
566 priv->mem[b].cpu_addr = devm_ioremap(&pdev->dev,
567 att->sa, att->size);
568 else
569 priv->mem[b].cpu_addr = devm_ioremap_wc(&pdev->dev,
570 att->sa, att->size);
571 if (!priv->mem[b].cpu_addr) {
572 dev_err(dev, "failed to remap %#x bytes from %#x\n", att->size, att->sa);
573 return -ENOMEM;
574 }
575 priv->mem[b].sys_addr = att->sa;
576 priv->mem[b].size = att->size;
577 b++;
578 }
579
580 /* memory-region is optional property */
581 nph = of_count_phandle_with_args(np, "memory-region", NULL);
582 if (nph <= 0)
583 return 0;
584
585 /* remap optional addresses */
586 for (a = 0; a < nph; a++) {
587 struct device_node *node;
588 struct resource res;
589
590 node = of_parse_phandle(np, "memory-region", a);
591 /* Not map vdevbuffer, vdevring region */
592 if (!strncmp(node->name, "vdev", strlen("vdev"))) {
593 of_node_put(node);
594 continue;
595 }
596 err = of_address_to_resource(node, 0, &res);
597 of_node_put(node);
598 if (err) {
599 dev_err(dev, "unable to resolve memory region\n");
600 return err;
601 }
602
603 if (b >= IMX_RPROC_MEM_MAX)
604 break;
605
606 /* Not use resource version, because we might share region */
607 priv->mem[b].cpu_addr = devm_ioremap(&pdev->dev, res.start, resource_size(&res));
608 if (!priv->mem[b].cpu_addr) {
609 dev_err(dev, "failed to remap %pr\n", &res);
610 return -ENOMEM;
611 }
612 priv->mem[b].sys_addr = res.start;
613 priv->mem[b].size = resource_size(&res);
614 if (!strcmp(node->name, "rsc-table"))
615 priv->rsc_table = priv->mem[b].cpu_addr;
616 b++;
617 }
618
619 return 0;
620 }
621
imx_rproc_vq_work(struct work_struct * work)622 static void imx_rproc_vq_work(struct work_struct *work)
623 {
624 struct imx_rproc *priv = container_of(work, struct imx_rproc,
625 rproc_work);
626
627 rproc_vq_interrupt(priv->rproc, 0);
628 rproc_vq_interrupt(priv->rproc, 1);
629 }
630
imx_rproc_rx_callback(struct mbox_client * cl,void * msg)631 static void imx_rproc_rx_callback(struct mbox_client *cl, void *msg)
632 {
633 struct rproc *rproc = dev_get_drvdata(cl->dev);
634 struct imx_rproc *priv = rproc->priv;
635
636 queue_work(priv->workqueue, &priv->rproc_work);
637 }
638
imx_rproc_xtr_mbox_init(struct rproc * rproc)639 static int imx_rproc_xtr_mbox_init(struct rproc *rproc)
640 {
641 struct imx_rproc *priv = rproc->priv;
642 struct device *dev = priv->dev;
643 struct mbox_client *cl;
644 int ret;
645
646 if (!of_get_property(dev->of_node, "mbox-names", NULL))
647 return 0;
648
649 cl = &priv->cl;
650 cl->dev = dev;
651 cl->tx_block = true;
652 cl->tx_tout = 100;
653 cl->knows_txdone = false;
654 cl->rx_callback = imx_rproc_rx_callback;
655
656 priv->tx_ch = mbox_request_channel_byname(cl, "tx");
657 if (IS_ERR(priv->tx_ch)) {
658 ret = PTR_ERR(priv->tx_ch);
659 return dev_err_probe(cl->dev, ret,
660 "failed to request tx mailbox channel: %d\n", ret);
661 }
662
663 priv->rx_ch = mbox_request_channel_byname(cl, "rx");
664 if (IS_ERR(priv->rx_ch)) {
665 mbox_free_channel(priv->tx_ch);
666 ret = PTR_ERR(priv->rx_ch);
667 return dev_err_probe(cl->dev, ret,
668 "failed to request rx mailbox channel: %d\n", ret);
669 }
670
671 return 0;
672 }
673
imx_rproc_free_mbox(struct rproc * rproc)674 static void imx_rproc_free_mbox(struct rproc *rproc)
675 {
676 struct imx_rproc *priv = rproc->priv;
677
678 mbox_free_channel(priv->tx_ch);
679 mbox_free_channel(priv->rx_ch);
680 }
681
imx_rproc_detect_mode(struct imx_rproc * priv)682 static int imx_rproc_detect_mode(struct imx_rproc *priv)
683 {
684 struct regmap_config config = { .name = "imx-rproc" };
685 const struct imx_rproc_dcfg *dcfg = priv->dcfg;
686 struct device *dev = priv->dev;
687 struct regmap *regmap;
688 struct arm_smccc_res res;
689 int ret;
690 u32 val;
691
692 switch (dcfg->method) {
693 case IMX_RPROC_NONE:
694 priv->rproc->state = RPROC_DETACHED;
695 return 0;
696 case IMX_RPROC_SMC:
697 arm_smccc_smc(IMX_SIP_RPROC, IMX_SIP_RPROC_STARTED, 0, 0, 0, 0, 0, 0, &res);
698 if (res.a0)
699 priv->rproc->state = RPROC_DETACHED;
700 return 0;
701 default:
702 break;
703 }
704
705 regmap = syscon_regmap_lookup_by_phandle(dev->of_node, "syscon");
706 if (IS_ERR(regmap)) {
707 dev_err(dev, "failed to find syscon\n");
708 return PTR_ERR(regmap);
709 }
710
711 priv->regmap = regmap;
712 regmap_attach_dev(dev, regmap, &config);
713
714 ret = regmap_read(regmap, dcfg->src_reg, &val);
715 if (ret) {
716 dev_err(dev, "Failed to read src\n");
717 return ret;
718 }
719
720 if (!(val & dcfg->src_stop))
721 priv->rproc->state = RPROC_DETACHED;
722
723 return 0;
724 }
725
imx_rproc_clk_enable(struct imx_rproc * priv)726 static int imx_rproc_clk_enable(struct imx_rproc *priv)
727 {
728 const struct imx_rproc_dcfg *dcfg = priv->dcfg;
729 struct device *dev = priv->dev;
730 int ret;
731
732 /* Remote core is not under control of Linux */
733 if (dcfg->method == IMX_RPROC_NONE)
734 return 0;
735
736 priv->clk = devm_clk_get(dev, NULL);
737 if (IS_ERR(priv->clk)) {
738 dev_err(dev, "Failed to get clock\n");
739 return PTR_ERR(priv->clk);
740 }
741
742 /*
743 * clk for M4 block including memory. Should be
744 * enabled before .start for FW transfer.
745 */
746 ret = clk_prepare_enable(priv->clk);
747 if (ret) {
748 dev_err(dev, "Failed to enable clock\n");
749 return ret;
750 }
751
752 return 0;
753 }
754
imx_rproc_probe(struct platform_device * pdev)755 static int imx_rproc_probe(struct platform_device *pdev)
756 {
757 struct device *dev = &pdev->dev;
758 struct device_node *np = dev->of_node;
759 struct imx_rproc *priv;
760 struct rproc *rproc;
761 const struct imx_rproc_dcfg *dcfg;
762 int ret;
763
764 /* set some other name then imx */
765 rproc = rproc_alloc(dev, "imx-rproc", &imx_rproc_ops,
766 NULL, sizeof(*priv));
767 if (!rproc)
768 return -ENOMEM;
769
770 dcfg = of_device_get_match_data(dev);
771 if (!dcfg) {
772 ret = -EINVAL;
773 goto err_put_rproc;
774 }
775
776 priv = rproc->priv;
777 priv->rproc = rproc;
778 priv->dcfg = dcfg;
779 priv->dev = dev;
780
781 dev_set_drvdata(dev, rproc);
782 priv->workqueue = create_workqueue(dev_name(dev));
783 if (!priv->workqueue) {
784 dev_err(dev, "cannot create workqueue\n");
785 ret = -ENOMEM;
786 goto err_put_rproc;
787 }
788
789 ret = imx_rproc_xtr_mbox_init(rproc);
790 if (ret)
791 goto err_put_wkq;
792
793 ret = imx_rproc_addr_init(priv, pdev);
794 if (ret) {
795 dev_err(dev, "failed on imx_rproc_addr_init\n");
796 goto err_put_mbox;
797 }
798
799 ret = imx_rproc_detect_mode(priv);
800 if (ret)
801 goto err_put_mbox;
802
803 ret = imx_rproc_clk_enable(priv);
804 if (ret)
805 goto err_put_mbox;
806
807 INIT_WORK(&priv->rproc_work, imx_rproc_vq_work);
808
809 if (rproc->state != RPROC_DETACHED)
810 rproc->auto_boot = of_property_read_bool(np, "fsl,auto-boot");
811
812 ret = rproc_add(rproc);
813 if (ret) {
814 dev_err(dev, "rproc_add failed\n");
815 goto err_put_clk;
816 }
817
818 return 0;
819
820 err_put_clk:
821 clk_disable_unprepare(priv->clk);
822 err_put_mbox:
823 imx_rproc_free_mbox(rproc);
824 err_put_wkq:
825 destroy_workqueue(priv->workqueue);
826 err_put_rproc:
827 rproc_free(rproc);
828
829 return ret;
830 }
831
imx_rproc_remove(struct platform_device * pdev)832 static int imx_rproc_remove(struct platform_device *pdev)
833 {
834 struct rproc *rproc = platform_get_drvdata(pdev);
835 struct imx_rproc *priv = rproc->priv;
836
837 clk_disable_unprepare(priv->clk);
838 rproc_del(rproc);
839 imx_rproc_free_mbox(rproc);
840 destroy_workqueue(priv->workqueue);
841 rproc_free(rproc);
842
843 return 0;
844 }
845
846 static const struct of_device_id imx_rproc_of_match[] = {
847 { .compatible = "fsl,imx7ulp-cm4", .data = &imx_rproc_cfg_imx7ulp },
848 { .compatible = "fsl,imx7d-cm4", .data = &imx_rproc_cfg_imx7d },
849 { .compatible = "fsl,imx6sx-cm4", .data = &imx_rproc_cfg_imx6sx },
850 { .compatible = "fsl,imx8mq-cm4", .data = &imx_rproc_cfg_imx8mq },
851 { .compatible = "fsl,imx8mm-cm4", .data = &imx_rproc_cfg_imx8mq },
852 { .compatible = "fsl,imx8mn-cm7", .data = &imx_rproc_cfg_imx8mn },
853 { .compatible = "fsl,imx8mp-cm7", .data = &imx_rproc_cfg_imx8mn },
854 { .compatible = "fsl,imx8ulp-cm33", .data = &imx_rproc_cfg_imx8ulp },
855 {},
856 };
857 MODULE_DEVICE_TABLE(of, imx_rproc_of_match);
858
859 static struct platform_driver imx_rproc_driver = {
860 .probe = imx_rproc_probe,
861 .remove = imx_rproc_remove,
862 .driver = {
863 .name = "imx-rproc",
864 .of_match_table = imx_rproc_of_match,
865 },
866 };
867
868 module_platform_driver(imx_rproc_driver);
869
870 MODULE_LICENSE("GPL v2");
871 MODULE_DESCRIPTION("i.MX remote processor control driver");
872 MODULE_AUTHOR("Oleksij Rempel <o.rempel@pengutronix.de>");
873