1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * PRU-ICSS remoteproc driver for various TI SoCs
4  *
5  * Copyright (C) 2014-2020 Texas Instruments Incorporated - https://www.ti.com/
6  *
7  * Author(s):
8  *	Suman Anna <s-anna@ti.com>
9  *	Andrew F. Davis <afd@ti.com>
10  *	Grzegorz Jaszczyk <grzegorz.jaszczyk@linaro.org> for Texas Instruments
11  */
12 
13 #include <linux/bitops.h>
14 #include <linux/debugfs.h>
15 #include <linux/irqdomain.h>
16 #include <linux/module.h>
17 #include <linux/of_device.h>
18 #include <linux/of_irq.h>
19 #include <linux/pruss_driver.h>
20 #include <linux/remoteproc.h>
21 
22 #include "remoteproc_internal.h"
23 #include "remoteproc_elf_helpers.h"
24 #include "pru_rproc.h"
25 
26 /* PRU_ICSS_PRU_CTRL registers */
27 #define PRU_CTRL_CTRL		0x0000
28 #define PRU_CTRL_STS		0x0004
29 #define PRU_CTRL_WAKEUP_EN	0x0008
30 #define PRU_CTRL_CYCLE		0x000C
31 #define PRU_CTRL_STALL		0x0010
32 #define PRU_CTRL_CTBIR0		0x0020
33 #define PRU_CTRL_CTBIR1		0x0024
34 #define PRU_CTRL_CTPPR0		0x0028
35 #define PRU_CTRL_CTPPR1		0x002C
36 
37 /* CTRL register bit-fields */
38 #define CTRL_CTRL_SOFT_RST_N	BIT(0)
39 #define CTRL_CTRL_EN		BIT(1)
40 #define CTRL_CTRL_SLEEPING	BIT(2)
41 #define CTRL_CTRL_CTR_EN	BIT(3)
42 #define CTRL_CTRL_SINGLE_STEP	BIT(8)
43 #define CTRL_CTRL_RUNSTATE	BIT(15)
44 
45 /* PRU_ICSS_PRU_DEBUG registers */
46 #define PRU_DEBUG_GPREG(x)	(0x0000 + (x) * 4)
47 #define PRU_DEBUG_CT_REG(x)	(0x0080 + (x) * 4)
48 
49 /* PRU/RTU/Tx_PRU Core IRAM address masks */
50 #define PRU_IRAM_ADDR_MASK	0x3ffff
51 #define PRU0_IRAM_ADDR_MASK	0x34000
52 #define PRU1_IRAM_ADDR_MASK	0x38000
53 #define RTU0_IRAM_ADDR_MASK	0x4000
54 #define RTU1_IRAM_ADDR_MASK	0x6000
55 #define TX_PRU0_IRAM_ADDR_MASK	0xa000
56 #define TX_PRU1_IRAM_ADDR_MASK	0xc000
57 
58 /* PRU device addresses for various type of PRU RAMs */
59 #define PRU_IRAM_DA	0	/* Instruction RAM */
60 #define PRU_PDRAM_DA	0	/* Primary Data RAM */
61 #define PRU_SDRAM_DA	0x2000	/* Secondary Data RAM */
62 #define PRU_SHRDRAM_DA	0x10000 /* Shared Data RAM */
63 
64 #define MAX_PRU_SYS_EVENTS 160
65 
66 /**
67  * enum pru_iomem - PRU core memory/register range identifiers
68  *
69  * @PRU_IOMEM_IRAM: PRU Instruction RAM range
70  * @PRU_IOMEM_CTRL: PRU Control register range
71  * @PRU_IOMEM_DEBUG: PRU Debug register range
72  * @PRU_IOMEM_MAX: just keep this one at the end
73  */
74 enum pru_iomem {
75 	PRU_IOMEM_IRAM = 0,
76 	PRU_IOMEM_CTRL,
77 	PRU_IOMEM_DEBUG,
78 	PRU_IOMEM_MAX,
79 };
80 
81 /**
82  * enum pru_type - PRU core type identifier
83  *
84  * @PRU_TYPE_PRU: Programmable Real-time Unit
85  * @PRU_TYPE_RTU: Auxiliary Programmable Real-Time Unit
86  * @PRU_TYPE_TX_PRU: Transmit Programmable Real-Time Unit
87  * @PRU_TYPE_MAX: just keep this one at the end
88  */
89 enum pru_type {
90 	PRU_TYPE_PRU = 0,
91 	PRU_TYPE_RTU,
92 	PRU_TYPE_TX_PRU,
93 	PRU_TYPE_MAX,
94 };
95 
96 /**
97  * struct pru_private_data - device data for a PRU core
98  * @type: type of the PRU core (PRU, RTU, Tx_PRU)
99  * @is_k3: flag used to identify the need for special load handling
100  */
101 struct pru_private_data {
102 	enum pru_type type;
103 	unsigned int is_k3 : 1;
104 };
105 
106 /**
107  * struct pru_rproc - PRU remoteproc structure
108  * @id: id of the PRU core within the PRUSS
109  * @dev: PRU core device pointer
110  * @pruss: back-reference to parent PRUSS structure
111  * @rproc: remoteproc pointer for this PRU core
112  * @data: PRU core specific data
113  * @mem_regions: data for each of the PRU memory regions
114  * @fw_name: name of firmware image used during loading
115  * @mapped_irq: virtual interrupt numbers of created fw specific mapping
116  * @pru_interrupt_map: pointer to interrupt mapping description (firmware)
117  * @pru_interrupt_map_sz: pru_interrupt_map size
118  * @dbg_single_step: debug state variable to set PRU into single step mode
119  * @dbg_continuous: debug state variable to restore PRU execution mode
120  * @evt_count: number of mapped events
121  */
122 struct pru_rproc {
123 	int id;
124 	struct device *dev;
125 	struct pruss *pruss;
126 	struct rproc *rproc;
127 	const struct pru_private_data *data;
128 	struct pruss_mem_region mem_regions[PRU_IOMEM_MAX];
129 	const char *fw_name;
130 	unsigned int *mapped_irq;
131 	struct pru_irq_rsc *pru_interrupt_map;
132 	size_t pru_interrupt_map_sz;
133 	u32 dbg_single_step;
134 	u32 dbg_continuous;
135 	u8 evt_count;
136 };
137 
138 static inline u32 pru_control_read_reg(struct pru_rproc *pru, unsigned int reg)
139 {
140 	return readl_relaxed(pru->mem_regions[PRU_IOMEM_CTRL].va + reg);
141 }
142 
143 static inline
144 void pru_control_write_reg(struct pru_rproc *pru, unsigned int reg, u32 val)
145 {
146 	writel_relaxed(val, pru->mem_regions[PRU_IOMEM_CTRL].va + reg);
147 }
148 
149 static inline u32 pru_debug_read_reg(struct pru_rproc *pru, unsigned int reg)
150 {
151 	return readl_relaxed(pru->mem_regions[PRU_IOMEM_DEBUG].va + reg);
152 }
153 
154 static int regs_show(struct seq_file *s, void *data)
155 {
156 	struct rproc *rproc = s->private;
157 	struct pru_rproc *pru = rproc->priv;
158 	int i, nregs = 32;
159 	u32 pru_sts;
160 	int pru_is_running;
161 
162 	seq_puts(s, "============== Control Registers ==============\n");
163 	seq_printf(s, "CTRL      := 0x%08x\n",
164 		   pru_control_read_reg(pru, PRU_CTRL_CTRL));
165 	pru_sts = pru_control_read_reg(pru, PRU_CTRL_STS);
166 	seq_printf(s, "STS (PC)  := 0x%08x (0x%08x)\n", pru_sts, pru_sts << 2);
167 	seq_printf(s, "WAKEUP_EN := 0x%08x\n",
168 		   pru_control_read_reg(pru, PRU_CTRL_WAKEUP_EN));
169 	seq_printf(s, "CYCLE     := 0x%08x\n",
170 		   pru_control_read_reg(pru, PRU_CTRL_CYCLE));
171 	seq_printf(s, "STALL     := 0x%08x\n",
172 		   pru_control_read_reg(pru, PRU_CTRL_STALL));
173 	seq_printf(s, "CTBIR0    := 0x%08x\n",
174 		   pru_control_read_reg(pru, PRU_CTRL_CTBIR0));
175 	seq_printf(s, "CTBIR1    := 0x%08x\n",
176 		   pru_control_read_reg(pru, PRU_CTRL_CTBIR1));
177 	seq_printf(s, "CTPPR0    := 0x%08x\n",
178 		   pru_control_read_reg(pru, PRU_CTRL_CTPPR0));
179 	seq_printf(s, "CTPPR1    := 0x%08x\n",
180 		   pru_control_read_reg(pru, PRU_CTRL_CTPPR1));
181 
182 	seq_puts(s, "=============== Debug Registers ===============\n");
183 	pru_is_running = pru_control_read_reg(pru, PRU_CTRL_CTRL) &
184 				CTRL_CTRL_RUNSTATE;
185 	if (pru_is_running) {
186 		seq_puts(s, "PRU is executing, cannot print/access debug registers.\n");
187 		return 0;
188 	}
189 
190 	for (i = 0; i < nregs; i++) {
191 		seq_printf(s, "GPREG%-2d := 0x%08x\tCT_REG%-2d := 0x%08x\n",
192 			   i, pru_debug_read_reg(pru, PRU_DEBUG_GPREG(i)),
193 			   i, pru_debug_read_reg(pru, PRU_DEBUG_CT_REG(i)));
194 	}
195 
196 	return 0;
197 }
198 DEFINE_SHOW_ATTRIBUTE(regs);
199 
200 /*
201  * Control PRU single-step mode
202  *
203  * This is a debug helper function used for controlling the single-step
204  * mode of the PRU. The PRU Debug registers are not accessible when the
205  * PRU is in RUNNING state.
206  *
207  * Writing a non-zero value sets the PRU into single-step mode irrespective
208  * of its previous state. The PRU mode is saved only on the first set into
209  * a single-step mode. Writing a zero value will restore the PRU into its
210  * original mode.
211  */
212 static int pru_rproc_debug_ss_set(void *data, u64 val)
213 {
214 	struct rproc *rproc = data;
215 	struct pru_rproc *pru = rproc->priv;
216 	u32 reg_val;
217 
218 	val = val ? 1 : 0;
219 	if (!val && !pru->dbg_single_step)
220 		return 0;
221 
222 	reg_val = pru_control_read_reg(pru, PRU_CTRL_CTRL);
223 
224 	if (val && !pru->dbg_single_step)
225 		pru->dbg_continuous = reg_val;
226 
227 	if (val)
228 		reg_val |= CTRL_CTRL_SINGLE_STEP | CTRL_CTRL_EN;
229 	else
230 		reg_val = pru->dbg_continuous;
231 
232 	pru->dbg_single_step = val;
233 	pru_control_write_reg(pru, PRU_CTRL_CTRL, reg_val);
234 
235 	return 0;
236 }
237 
238 static int pru_rproc_debug_ss_get(void *data, u64 *val)
239 {
240 	struct rproc *rproc = data;
241 	struct pru_rproc *pru = rproc->priv;
242 
243 	*val = pru->dbg_single_step;
244 
245 	return 0;
246 }
247 DEFINE_DEBUGFS_ATTRIBUTE(pru_rproc_debug_ss_fops, pru_rproc_debug_ss_get,
248 			 pru_rproc_debug_ss_set, "%llu\n");
249 
250 /*
251  * Create PRU-specific debugfs entries
252  *
253  * The entries are created only if the parent remoteproc debugfs directory
254  * exists, and will be cleaned up by the remoteproc core.
255  */
256 static void pru_rproc_create_debug_entries(struct rproc *rproc)
257 {
258 	if (!rproc->dbg_dir)
259 		return;
260 
261 	debugfs_create_file("regs", 0400, rproc->dbg_dir,
262 			    rproc, &regs_fops);
263 	debugfs_create_file("single_step", 0600, rproc->dbg_dir,
264 			    rproc, &pru_rproc_debug_ss_fops);
265 }
266 
267 static void pru_dispose_irq_mapping(struct pru_rproc *pru)
268 {
269 	if (!pru->mapped_irq)
270 		return;
271 
272 	while (pru->evt_count) {
273 		pru->evt_count--;
274 		if (pru->mapped_irq[pru->evt_count] > 0)
275 			irq_dispose_mapping(pru->mapped_irq[pru->evt_count]);
276 	}
277 
278 	kfree(pru->mapped_irq);
279 	pru->mapped_irq = NULL;
280 }
281 
282 /*
283  * Parse the custom PRU interrupt map resource and configure the INTC
284  * appropriately.
285  */
286 static int pru_handle_intrmap(struct rproc *rproc)
287 {
288 	struct device *dev = rproc->dev.parent;
289 	struct pru_rproc *pru = rproc->priv;
290 	struct pru_irq_rsc *rsc = pru->pru_interrupt_map;
291 	struct irq_fwspec fwspec;
292 	struct device_node *parent, *irq_parent;
293 	int i, ret = 0;
294 
295 	/* not having pru_interrupt_map is not an error */
296 	if (!rsc)
297 		return 0;
298 
299 	/* currently supporting only type 0 */
300 	if (rsc->type != 0) {
301 		dev_err(dev, "unsupported rsc type: %d\n", rsc->type);
302 		return -EINVAL;
303 	}
304 
305 	if (rsc->num_evts > MAX_PRU_SYS_EVENTS)
306 		return -EINVAL;
307 
308 	if (sizeof(*rsc) + rsc->num_evts * sizeof(struct pruss_int_map) !=
309 	    pru->pru_interrupt_map_sz)
310 		return -EINVAL;
311 
312 	pru->evt_count = rsc->num_evts;
313 	pru->mapped_irq = kcalloc(pru->evt_count, sizeof(unsigned int),
314 				  GFP_KERNEL);
315 	if (!pru->mapped_irq) {
316 		pru->evt_count = 0;
317 		return -ENOMEM;
318 	}
319 
320 	/*
321 	 * parse and fill in system event to interrupt channel and
322 	 * channel-to-host mapping. The interrupt controller to be used
323 	 * for these mappings for a given PRU remoteproc is always its
324 	 * corresponding sibling PRUSS INTC node.
325 	 */
326 	parent = of_get_parent(dev_of_node(pru->dev));
327 	if (!parent) {
328 		kfree(pru->mapped_irq);
329 		pru->mapped_irq = NULL;
330 		pru->evt_count = 0;
331 		return -ENODEV;
332 	}
333 
334 	irq_parent = of_get_child_by_name(parent, "interrupt-controller");
335 	of_node_put(parent);
336 	if (!irq_parent) {
337 		kfree(pru->mapped_irq);
338 		pru->mapped_irq = NULL;
339 		pru->evt_count = 0;
340 		return -ENODEV;
341 	}
342 
343 	fwspec.fwnode = of_node_to_fwnode(irq_parent);
344 	fwspec.param_count = 3;
345 	for (i = 0; i < pru->evt_count; i++) {
346 		fwspec.param[0] = rsc->pru_intc_map[i].event;
347 		fwspec.param[1] = rsc->pru_intc_map[i].chnl;
348 		fwspec.param[2] = rsc->pru_intc_map[i].host;
349 
350 		dev_dbg(dev, "mapping%d: event %d, chnl %d, host %d\n",
351 			i, fwspec.param[0], fwspec.param[1], fwspec.param[2]);
352 
353 		pru->mapped_irq[i] = irq_create_fwspec_mapping(&fwspec);
354 		if (!pru->mapped_irq[i]) {
355 			dev_err(dev, "failed to get virq for fw mapping %d: event %d chnl %d host %d\n",
356 				i, fwspec.param[0], fwspec.param[1],
357 				fwspec.param[2]);
358 			ret = -EINVAL;
359 			goto map_fail;
360 		}
361 	}
362 	of_node_put(irq_parent);
363 
364 	return ret;
365 
366 map_fail:
367 	pru_dispose_irq_mapping(pru);
368 	of_node_put(irq_parent);
369 
370 	return ret;
371 }
372 
373 static int pru_rproc_start(struct rproc *rproc)
374 {
375 	struct device *dev = &rproc->dev;
376 	struct pru_rproc *pru = rproc->priv;
377 	const char *names[PRU_TYPE_MAX] = { "PRU", "RTU", "Tx_PRU" };
378 	u32 val;
379 	int ret;
380 
381 	dev_dbg(dev, "starting %s%d: entry-point = 0x%llx\n",
382 		names[pru->data->type], pru->id, (rproc->bootaddr >> 2));
383 
384 	ret = pru_handle_intrmap(rproc);
385 	/*
386 	 * reset references to pru interrupt map - they will stop being valid
387 	 * after rproc_start returns
388 	 */
389 	pru->pru_interrupt_map = NULL;
390 	pru->pru_interrupt_map_sz = 0;
391 	if (ret)
392 		return ret;
393 
394 	val = CTRL_CTRL_EN | ((rproc->bootaddr >> 2) << 16);
395 	pru_control_write_reg(pru, PRU_CTRL_CTRL, val);
396 
397 	return 0;
398 }
399 
400 static int pru_rproc_stop(struct rproc *rproc)
401 {
402 	struct device *dev = &rproc->dev;
403 	struct pru_rproc *pru = rproc->priv;
404 	const char *names[PRU_TYPE_MAX] = { "PRU", "RTU", "Tx_PRU" };
405 	u32 val;
406 
407 	dev_dbg(dev, "stopping %s%d\n", names[pru->data->type], pru->id);
408 
409 	val = pru_control_read_reg(pru, PRU_CTRL_CTRL);
410 	val &= ~CTRL_CTRL_EN;
411 	pru_control_write_reg(pru, PRU_CTRL_CTRL, val);
412 
413 	/* dispose irq mapping - new firmware can provide new mapping */
414 	pru_dispose_irq_mapping(pru);
415 
416 	return 0;
417 }
418 
419 /*
420  * Convert PRU device address (data spaces only) to kernel virtual address.
421  *
422  * Each PRU has access to all data memories within the PRUSS, accessible at
423  * different ranges. So, look through both its primary and secondary Data
424  * RAMs as well as any shared Data RAM to convert a PRU device address to
425  * kernel virtual address. Data RAM0 is primary Data RAM for PRU0 and Data
426  * RAM1 is primary Data RAM for PRU1.
427  */
428 static void *pru_d_da_to_va(struct pru_rproc *pru, u32 da, size_t len)
429 {
430 	struct pruss_mem_region dram0, dram1, shrd_ram;
431 	struct pruss *pruss = pru->pruss;
432 	u32 offset;
433 	void *va = NULL;
434 
435 	if (len == 0)
436 		return NULL;
437 
438 	dram0 = pruss->mem_regions[PRUSS_MEM_DRAM0];
439 	dram1 = pruss->mem_regions[PRUSS_MEM_DRAM1];
440 	/* PRU1 has its local RAM addresses reversed */
441 	if (pru->id == 1)
442 		swap(dram0, dram1);
443 	shrd_ram = pruss->mem_regions[PRUSS_MEM_SHRD_RAM2];
444 
445 	if (da >= PRU_PDRAM_DA && da + len <= PRU_PDRAM_DA + dram0.size) {
446 		offset = da - PRU_PDRAM_DA;
447 		va = (__force void *)(dram0.va + offset);
448 	} else if (da >= PRU_SDRAM_DA &&
449 		   da + len <= PRU_SDRAM_DA + dram1.size) {
450 		offset = da - PRU_SDRAM_DA;
451 		va = (__force void *)(dram1.va + offset);
452 	} else if (da >= PRU_SHRDRAM_DA &&
453 		   da + len <= PRU_SHRDRAM_DA + shrd_ram.size) {
454 		offset = da - PRU_SHRDRAM_DA;
455 		va = (__force void *)(shrd_ram.va + offset);
456 	}
457 
458 	return va;
459 }
460 
461 /*
462  * Convert PRU device address (instruction space) to kernel virtual address.
463  *
464  * A PRU does not have an unified address space. Each PRU has its very own
465  * private Instruction RAM, and its device address is identical to that of
466  * its primary Data RAM device address.
467  */
468 static void *pru_i_da_to_va(struct pru_rproc *pru, u32 da, size_t len)
469 {
470 	u32 offset;
471 	void *va = NULL;
472 
473 	if (len == 0)
474 		return NULL;
475 
476 	/*
477 	 * GNU binutils do not support multiple address spaces. The GNU
478 	 * linker's default linker script places IRAM at an arbitrary high
479 	 * offset, in order to differentiate it from DRAM. Hence we need to
480 	 * strip the artificial offset in the IRAM addresses coming from the
481 	 * ELF file.
482 	 *
483 	 * The TI proprietary linker would never set those higher IRAM address
484 	 * bits anyway. PRU architecture limits the program counter to 16-bit
485 	 * word-address range. This in turn corresponds to 18-bit IRAM
486 	 * byte-address range for ELF.
487 	 *
488 	 * Two more bits are added just in case to make the final 20-bit mask.
489 	 * Idea is to have a safeguard in case TI decides to add banking
490 	 * in future SoCs.
491 	 */
492 	da &= 0xfffff;
493 
494 	if (da >= PRU_IRAM_DA &&
495 	    da + len <= PRU_IRAM_DA + pru->mem_regions[PRU_IOMEM_IRAM].size) {
496 		offset = da - PRU_IRAM_DA;
497 		va = (__force void *)(pru->mem_regions[PRU_IOMEM_IRAM].va +
498 				      offset);
499 	}
500 
501 	return va;
502 }
503 
504 /*
505  * Provide address translations for only PRU Data RAMs through the remoteproc
506  * core for any PRU client drivers. The PRU Instruction RAM access is restricted
507  * only to the PRU loader code.
508  */
509 static void *pru_rproc_da_to_va(struct rproc *rproc, u64 da, size_t len, bool *is_iomem)
510 {
511 	struct pru_rproc *pru = rproc->priv;
512 
513 	return pru_d_da_to_va(pru, da, len);
514 }
515 
516 /* PRU-specific address translator used by PRU loader. */
517 static void *pru_da_to_va(struct rproc *rproc, u64 da, size_t len, bool is_iram)
518 {
519 	struct pru_rproc *pru = rproc->priv;
520 	void *va;
521 
522 	if (is_iram)
523 		va = pru_i_da_to_va(pru, da, len);
524 	else
525 		va = pru_d_da_to_va(pru, da, len);
526 
527 	return va;
528 }
529 
530 static struct rproc_ops pru_rproc_ops = {
531 	.start		= pru_rproc_start,
532 	.stop		= pru_rproc_stop,
533 	.da_to_va	= pru_rproc_da_to_va,
534 };
535 
536 /*
537  * Custom memory copy implementation for ICSSG PRU/RTU/Tx_PRU Cores
538  *
539  * The ICSSG PRU/RTU/Tx_PRU cores have a memory copying issue with IRAM
540  * memories, that is not seen on previous generation SoCs. The data is reflected
541  * properly in the IRAM memories only for integer (4-byte) copies. Any unaligned
542  * copies result in all the other pre-existing bytes zeroed out within that
543  * 4-byte boundary, thereby resulting in wrong text/code in the IRAMs. Also, the
544  * IRAM memory port interface does not allow any 8-byte copies (as commonly used
545  * by ARM64 memcpy implementation) and throws an exception. The DRAM memory
546  * ports do not show this behavior.
547  */
548 static int pru_rproc_memcpy(void *dest, const void *src, size_t count)
549 {
550 	const u32 *s = src;
551 	u32 *d = dest;
552 	size_t size = count / 4;
553 	u32 *tmp_src = NULL;
554 
555 	/*
556 	 * TODO: relax limitation of 4-byte aligned dest addresses and copy
557 	 * sizes
558 	 */
559 	if ((long)dest % 4 || count % 4)
560 		return -EINVAL;
561 
562 	/* src offsets in ELF firmware image can be non-aligned */
563 	if ((long)src % 4) {
564 		tmp_src = kmemdup(src, count, GFP_KERNEL);
565 		if (!tmp_src)
566 			return -ENOMEM;
567 		s = tmp_src;
568 	}
569 
570 	while (size--)
571 		*d++ = *s++;
572 
573 	kfree(tmp_src);
574 
575 	return 0;
576 }
577 
578 static int
579 pru_rproc_load_elf_segments(struct rproc *rproc, const struct firmware *fw)
580 {
581 	struct pru_rproc *pru = rproc->priv;
582 	struct device *dev = &rproc->dev;
583 	struct elf32_hdr *ehdr;
584 	struct elf32_phdr *phdr;
585 	int i, ret = 0;
586 	const u8 *elf_data = fw->data;
587 
588 	ehdr = (struct elf32_hdr *)elf_data;
589 	phdr = (struct elf32_phdr *)(elf_data + ehdr->e_phoff);
590 
591 	/* go through the available ELF segments */
592 	for (i = 0; i < ehdr->e_phnum; i++, phdr++) {
593 		u32 da = phdr->p_paddr;
594 		u32 memsz = phdr->p_memsz;
595 		u32 filesz = phdr->p_filesz;
596 		u32 offset = phdr->p_offset;
597 		bool is_iram;
598 		void *ptr;
599 
600 		if (phdr->p_type != PT_LOAD || !filesz)
601 			continue;
602 
603 		dev_dbg(dev, "phdr: type %d da 0x%x memsz 0x%x filesz 0x%x\n",
604 			phdr->p_type, da, memsz, filesz);
605 
606 		if (filesz > memsz) {
607 			dev_err(dev, "bad phdr filesz 0x%x memsz 0x%x\n",
608 				filesz, memsz);
609 			ret = -EINVAL;
610 			break;
611 		}
612 
613 		if (offset + filesz > fw->size) {
614 			dev_err(dev, "truncated fw: need 0x%x avail 0x%zx\n",
615 				offset + filesz, fw->size);
616 			ret = -EINVAL;
617 			break;
618 		}
619 
620 		/* grab the kernel address for this device address */
621 		is_iram = phdr->p_flags & PF_X;
622 		ptr = pru_da_to_va(rproc, da, memsz, is_iram);
623 		if (!ptr) {
624 			dev_err(dev, "bad phdr da 0x%x mem 0x%x\n", da, memsz);
625 			ret = -EINVAL;
626 			break;
627 		}
628 
629 		if (pru->data->is_k3) {
630 			ret = pru_rproc_memcpy(ptr, elf_data + phdr->p_offset,
631 					       filesz);
632 			if (ret) {
633 				dev_err(dev, "PRU memory copy failed for da 0x%x memsz 0x%x\n",
634 					da, memsz);
635 				break;
636 			}
637 		} else {
638 			memcpy(ptr, elf_data + phdr->p_offset, filesz);
639 		}
640 
641 		/* skip the memzero logic performed by remoteproc ELF loader */
642 	}
643 
644 	return ret;
645 }
646 
647 static const void *
648 pru_rproc_find_interrupt_map(struct device *dev, const struct firmware *fw)
649 {
650 	struct elf32_shdr *shdr, *name_table_shdr;
651 	const char *name_table;
652 	const u8 *elf_data = fw->data;
653 	struct elf32_hdr *ehdr = (struct elf32_hdr *)elf_data;
654 	u16 shnum = ehdr->e_shnum;
655 	u16 shstrndx = ehdr->e_shstrndx;
656 	int i;
657 
658 	/* first, get the section header */
659 	shdr = (struct elf32_shdr *)(elf_data + ehdr->e_shoff);
660 	/* compute name table section header entry in shdr array */
661 	name_table_shdr = shdr + shstrndx;
662 	/* finally, compute the name table section address in elf */
663 	name_table = elf_data + name_table_shdr->sh_offset;
664 
665 	for (i = 0; i < shnum; i++, shdr++) {
666 		u32 size = shdr->sh_size;
667 		u32 offset = shdr->sh_offset;
668 		u32 name = shdr->sh_name;
669 
670 		if (strcmp(name_table + name, ".pru_irq_map"))
671 			continue;
672 
673 		/* make sure we have the entire irq map */
674 		if (offset + size > fw->size || offset + size < size) {
675 			dev_err(dev, ".pru_irq_map section truncated\n");
676 			return ERR_PTR(-EINVAL);
677 		}
678 
679 		/* make sure irq map has at least the header */
680 		if (sizeof(struct pru_irq_rsc) > size) {
681 			dev_err(dev, "header-less .pru_irq_map section\n");
682 			return ERR_PTR(-EINVAL);
683 		}
684 
685 		return shdr;
686 	}
687 
688 	dev_dbg(dev, "no .pru_irq_map section found for this fw\n");
689 
690 	return NULL;
691 }
692 
693 /*
694  * Use a custom parse_fw callback function for dealing with PRU firmware
695  * specific sections.
696  *
697  * The firmware blob can contain optional ELF sections: .resource_table section
698  * and .pru_irq_map one. The second one contains the PRUSS interrupt mapping
699  * description, which needs to be setup before powering on the PRU core. To
700  * avoid RAM wastage this ELF section is not mapped to any ELF segment (by the
701  * firmware linker) and therefore is not loaded to PRU memory.
702  */
703 static int pru_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw)
704 {
705 	struct device *dev = &rproc->dev;
706 	struct pru_rproc *pru = rproc->priv;
707 	const u8 *elf_data = fw->data;
708 	const void *shdr;
709 	u8 class = fw_elf_get_class(fw);
710 	u64 sh_offset;
711 	int ret;
712 
713 	/* load optional rsc table */
714 	ret = rproc_elf_load_rsc_table(rproc, fw);
715 	if (ret == -EINVAL)
716 		dev_dbg(&rproc->dev, "no resource table found for this fw\n");
717 	else if (ret)
718 		return ret;
719 
720 	/* find .pru_interrupt_map section, not having it is not an error */
721 	shdr = pru_rproc_find_interrupt_map(dev, fw);
722 	if (IS_ERR(shdr))
723 		return PTR_ERR(shdr);
724 
725 	if (!shdr)
726 		return 0;
727 
728 	/* preserve pointer to PRU interrupt map together with it size */
729 	sh_offset = elf_shdr_get_sh_offset(class, shdr);
730 	pru->pru_interrupt_map = (struct pru_irq_rsc *)(elf_data + sh_offset);
731 	pru->pru_interrupt_map_sz = elf_shdr_get_sh_size(class, shdr);
732 
733 	return 0;
734 }
735 
736 /*
737  * Compute PRU id based on the IRAM addresses. The PRU IRAMs are
738  * always at a particular offset within the PRUSS address space.
739  */
740 static int pru_rproc_set_id(struct pru_rproc *pru)
741 {
742 	int ret = 0;
743 
744 	switch (pru->mem_regions[PRU_IOMEM_IRAM].pa & PRU_IRAM_ADDR_MASK) {
745 	case TX_PRU0_IRAM_ADDR_MASK:
746 		fallthrough;
747 	case RTU0_IRAM_ADDR_MASK:
748 		fallthrough;
749 	case PRU0_IRAM_ADDR_MASK:
750 		pru->id = 0;
751 		break;
752 	case TX_PRU1_IRAM_ADDR_MASK:
753 		fallthrough;
754 	case RTU1_IRAM_ADDR_MASK:
755 		fallthrough;
756 	case PRU1_IRAM_ADDR_MASK:
757 		pru->id = 1;
758 		break;
759 	default:
760 		ret = -EINVAL;
761 	}
762 
763 	return ret;
764 }
765 
766 static int pru_rproc_probe(struct platform_device *pdev)
767 {
768 	struct device *dev = &pdev->dev;
769 	struct device_node *np = dev->of_node;
770 	struct platform_device *ppdev = to_platform_device(dev->parent);
771 	struct pru_rproc *pru;
772 	const char *fw_name;
773 	struct rproc *rproc = NULL;
774 	struct resource *res;
775 	int i, ret;
776 	const struct pru_private_data *data;
777 	const char *mem_names[PRU_IOMEM_MAX] = { "iram", "control", "debug" };
778 
779 	data = of_device_get_match_data(&pdev->dev);
780 	if (!data)
781 		return -ENODEV;
782 
783 	ret = of_property_read_string(np, "firmware-name", &fw_name);
784 	if (ret) {
785 		dev_err(dev, "unable to retrieve firmware-name %d\n", ret);
786 		return ret;
787 	}
788 
789 	rproc = devm_rproc_alloc(dev, pdev->name, &pru_rproc_ops, fw_name,
790 				 sizeof(*pru));
791 	if (!rproc) {
792 		dev_err(dev, "rproc_alloc failed\n");
793 		return -ENOMEM;
794 	}
795 	/* use a custom load function to deal with PRU-specific quirks */
796 	rproc->ops->load = pru_rproc_load_elf_segments;
797 
798 	/* use a custom parse function to deal with PRU-specific resources */
799 	rproc->ops->parse_fw = pru_rproc_parse_fw;
800 
801 	/* error recovery is not supported for PRUs */
802 	rproc->recovery_disabled = true;
803 
804 	/*
805 	 * rproc_add will auto-boot the processor normally, but this is not
806 	 * desired with PRU client driven boot-flow methodology. A PRU
807 	 * application/client driver will boot the corresponding PRU
808 	 * remote-processor as part of its state machine either through the
809 	 * remoteproc sysfs interface or through the equivalent kernel API.
810 	 */
811 	rproc->auto_boot = false;
812 
813 	pru = rproc->priv;
814 	pru->dev = dev;
815 	pru->data = data;
816 	pru->pruss = platform_get_drvdata(ppdev);
817 	pru->rproc = rproc;
818 	pru->fw_name = fw_name;
819 
820 	for (i = 0; i < ARRAY_SIZE(mem_names); i++) {
821 		res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
822 						   mem_names[i]);
823 		pru->mem_regions[i].va = devm_ioremap_resource(dev, res);
824 		if (IS_ERR(pru->mem_regions[i].va)) {
825 			dev_err(dev, "failed to parse and map memory resource %d %s\n",
826 				i, mem_names[i]);
827 			ret = PTR_ERR(pru->mem_regions[i].va);
828 			return ret;
829 		}
830 		pru->mem_regions[i].pa = res->start;
831 		pru->mem_regions[i].size = resource_size(res);
832 
833 		dev_dbg(dev, "memory %8s: pa %pa size 0x%zx va %pK\n",
834 			mem_names[i], &pru->mem_regions[i].pa,
835 			pru->mem_regions[i].size, pru->mem_regions[i].va);
836 	}
837 
838 	ret = pru_rproc_set_id(pru);
839 	if (ret < 0)
840 		return ret;
841 
842 	platform_set_drvdata(pdev, rproc);
843 
844 	ret = devm_rproc_add(dev, pru->rproc);
845 	if (ret) {
846 		dev_err(dev, "rproc_add failed: %d\n", ret);
847 		return ret;
848 	}
849 
850 	pru_rproc_create_debug_entries(rproc);
851 
852 	dev_dbg(dev, "PRU rproc node %pOF probed successfully\n", np);
853 
854 	return 0;
855 }
856 
857 static int pru_rproc_remove(struct platform_device *pdev)
858 {
859 	struct device *dev = &pdev->dev;
860 	struct rproc *rproc = platform_get_drvdata(pdev);
861 
862 	dev_dbg(dev, "%s: removing rproc %s\n", __func__, rproc->name);
863 
864 	return 0;
865 }
866 
867 static const struct pru_private_data pru_data = {
868 	.type = PRU_TYPE_PRU,
869 };
870 
871 static const struct pru_private_data k3_pru_data = {
872 	.type = PRU_TYPE_PRU,
873 	.is_k3 = 1,
874 };
875 
876 static const struct pru_private_data k3_rtu_data = {
877 	.type = PRU_TYPE_RTU,
878 	.is_k3 = 1,
879 };
880 
881 static const struct pru_private_data k3_tx_pru_data = {
882 	.type = PRU_TYPE_TX_PRU,
883 	.is_k3 = 1,
884 };
885 
886 static const struct of_device_id pru_rproc_match[] = {
887 	{ .compatible = "ti,am3356-pru",	.data = &pru_data },
888 	{ .compatible = "ti,am4376-pru",	.data = &pru_data },
889 	{ .compatible = "ti,am5728-pru",	.data = &pru_data },
890 	{ .compatible = "ti,am642-pru",		.data = &k3_pru_data },
891 	{ .compatible = "ti,am642-rtu",		.data = &k3_rtu_data },
892 	{ .compatible = "ti,am642-tx-pru",	.data = &k3_tx_pru_data },
893 	{ .compatible = "ti,k2g-pru",		.data = &pru_data },
894 	{ .compatible = "ti,am654-pru",		.data = &k3_pru_data },
895 	{ .compatible = "ti,am654-rtu",		.data = &k3_rtu_data },
896 	{ .compatible = "ti,am654-tx-pru",	.data = &k3_tx_pru_data },
897 	{ .compatible = "ti,j721e-pru",		.data = &k3_pru_data },
898 	{ .compatible = "ti,j721e-rtu",		.data = &k3_rtu_data },
899 	{ .compatible = "ti,j721e-tx-pru",	.data = &k3_tx_pru_data },
900 	{},
901 };
902 MODULE_DEVICE_TABLE(of, pru_rproc_match);
903 
904 static struct platform_driver pru_rproc_driver = {
905 	.driver = {
906 		.name   = "pru-rproc",
907 		.of_match_table = pru_rproc_match,
908 		.suppress_bind_attrs = true,
909 	},
910 	.probe  = pru_rproc_probe,
911 	.remove = pru_rproc_remove,
912 };
913 module_platform_driver(pru_rproc_driver);
914 
915 MODULE_AUTHOR("Suman Anna <s-anna@ti.com>");
916 MODULE_AUTHOR("Andrew F. Davis <afd@ti.com>");
917 MODULE_AUTHOR("Grzegorz Jaszczyk <grzegorz.jaszczyk@linaro.org>");
918 MODULE_DESCRIPTION("PRU-ICSS Remote Processor Driver");
919 MODULE_LICENSE("GPL v2");
920