1 // SPDX-License-Identifier: GPL-2.0-only
3 * PRU-ICSS remoteproc driver for various TI SoCs
5 * Copyright (C) 2014-2022 Texas Instruments Incorporated - https://www.ti.com/
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 * Puranjay Mohan <p-mohan@ti.com>
12 * Md Danish Anwar <danishanwar@ti.com>
15 #include <linux/bitops.h>
16 #include <linux/debugfs.h>
17 #include <linux/irqdomain.h>
18 #include <linux/module.h>
20 #include <linux/of_irq.h>
21 #include <linux/platform_device.h>
22 #include <linux/remoteproc/pruss.h>
23 #include <linux/pruss_driver.h>
24 #include <linux/remoteproc.h>
26 #include "remoteproc_internal.h"
27 #include "remoteproc_elf_helpers.h"
28 #include "pru_rproc.h"
30 /* PRU_ICSS_PRU_CTRL registers */
31 #define PRU_CTRL_CTRL 0x0000
32 #define PRU_CTRL_STS 0x0004
33 #define PRU_CTRL_WAKEUP_EN 0x0008
34 #define PRU_CTRL_CYCLE 0x000C
35 #define PRU_CTRL_STALL 0x0010
36 #define PRU_CTRL_CTBIR0 0x0020
37 #define PRU_CTRL_CTBIR1 0x0024
38 #define PRU_CTRL_CTPPR0 0x0028
39 #define PRU_CTRL_CTPPR1 0x002C
41 /* CTRL register bit-fields */
42 #define CTRL_CTRL_SOFT_RST_N BIT(0)
43 #define CTRL_CTRL_EN BIT(1)
44 #define CTRL_CTRL_SLEEPING BIT(2)
45 #define CTRL_CTRL_CTR_EN BIT(3)
46 #define CTRL_CTRL_SINGLE_STEP BIT(8)
47 #define CTRL_CTRL_RUNSTATE BIT(15)
49 /* PRU_ICSS_PRU_DEBUG registers */
50 #define PRU_DEBUG_GPREG(x) (0x0000 + (x) * 4)
51 #define PRU_DEBUG_CT_REG(x) (0x0080 + (x) * 4)
53 /* PRU/RTU/Tx_PRU Core IRAM address masks */
54 #define PRU_IRAM_ADDR_MASK 0x3ffff
55 #define PRU0_IRAM_ADDR_MASK 0x34000
56 #define PRU1_IRAM_ADDR_MASK 0x38000
57 #define RTU0_IRAM_ADDR_MASK 0x4000
58 #define RTU1_IRAM_ADDR_MASK 0x6000
59 #define TX_PRU0_IRAM_ADDR_MASK 0xa000
60 #define TX_PRU1_IRAM_ADDR_MASK 0xc000
62 /* PRU device addresses for various type of PRU RAMs */
63 #define PRU_IRAM_DA 0 /* Instruction RAM */
64 #define PRU_PDRAM_DA 0 /* Primary Data RAM */
65 #define PRU_SDRAM_DA 0x2000 /* Secondary Data RAM */
66 #define PRU_SHRDRAM_DA 0x10000 /* Shared Data RAM */
68 #define MAX_PRU_SYS_EVENTS 160
71 * enum pru_iomem - PRU core memory/register range identifiers
73 * @PRU_IOMEM_IRAM: PRU Instruction RAM range
74 * @PRU_IOMEM_CTRL: PRU Control register range
75 * @PRU_IOMEM_DEBUG: PRU Debug register range
76 * @PRU_IOMEM_MAX: just keep this one at the end
86 * struct pru_private_data - device data for a PRU core
87 * @type: type of the PRU core (PRU, RTU, Tx_PRU)
88 * @is_k3: flag used to identify the need for special load handling
90 struct pru_private_data
{
92 unsigned int is_k3
: 1;
96 * struct pru_rproc - PRU remoteproc structure
97 * @id: id of the PRU core within the PRUSS
98 * @dev: PRU core device pointer
99 * @pruss: back-reference to parent PRUSS structure
100 * @rproc: remoteproc pointer for this PRU core
101 * @data: PRU core specific data
102 * @mem_regions: data for each of the PRU memory regions
103 * @client_np: client device node
104 * @lock: mutex to protect client usage
105 * @fw_name: name of firmware image used during loading
106 * @mapped_irq: virtual interrupt numbers of created fw specific mapping
107 * @pru_interrupt_map: pointer to interrupt mapping description (firmware)
108 * @pru_interrupt_map_sz: pru_interrupt_map size
109 * @rmw_lock: lock for read, modify, write operations on registers
110 * @dbg_single_step: debug state variable to set PRU into single step mode
111 * @dbg_continuous: debug state variable to restore PRU execution mode
112 * @evt_count: number of mapped events
113 * @gpmux_save: saved value for gpmux config
120 const struct pru_private_data
*data
;
121 struct pruss_mem_region mem_regions
[PRU_IOMEM_MAX
];
122 struct device_node
*client_np
;
125 unsigned int *mapped_irq
;
126 struct pru_irq_rsc
*pru_interrupt_map
;
127 size_t pru_interrupt_map_sz
;
135 static inline u32
pru_control_read_reg(struct pru_rproc
*pru
, unsigned int reg
)
137 return readl_relaxed(pru
->mem_regions
[PRU_IOMEM_CTRL
].va
+ reg
);
141 void pru_control_write_reg(struct pru_rproc
*pru
, unsigned int reg
, u32 val
)
143 writel_relaxed(val
, pru
->mem_regions
[PRU_IOMEM_CTRL
].va
+ reg
);
147 void pru_control_set_reg(struct pru_rproc
*pru
, unsigned int reg
,
153 spin_lock_irqsave(&pru
->rmw_lock
, flags
);
155 val
= pru_control_read_reg(pru
, reg
);
158 pru_control_write_reg(pru
, reg
, val
);
160 spin_unlock_irqrestore(&pru
->rmw_lock
, flags
);
164 * pru_rproc_set_firmware() - set firmware for a PRU core
165 * @rproc: the rproc instance of the PRU
166 * @fw_name: the new firmware name, or NULL if default is desired
168 * Return: 0 on success, or errno in error case.
170 static int pru_rproc_set_firmware(struct rproc
*rproc
, const char *fw_name
)
172 struct pru_rproc
*pru
= rproc
->priv
;
175 fw_name
= pru
->fw_name
;
177 return rproc_set_firmware(rproc
, fw_name
);
180 static struct rproc
*__pru_rproc_get(struct device_node
*np
, int index
)
183 phandle rproc_phandle
;
186 ret
= of_property_read_u32_index(np
, "ti,prus", index
, &rproc_phandle
);
190 rproc
= rproc_get_by_phandle(rproc_phandle
);
196 /* make sure it is PRU rproc */
197 if (!is_pru_rproc(rproc
->dev
.parent
)) {
199 return ERR_PTR(-ENODEV
);
206 * pru_rproc_get() - get the PRU rproc instance from a device node
207 * @np: the user/client device node
208 * @index: index to use for the ti,prus property
209 * @pru_id: optional pointer to return the PRU remoteproc processor id
211 * This function looks through a client device node's "ti,prus" property at
212 * index @index and returns the rproc handle for a valid PRU remote processor if
213 * found. The function allows only one user to own the PRU rproc resource at a
214 * time. Caller must call pru_rproc_put() when done with using the rproc, not
215 * required if the function returns a failure.
217 * When optional @pru_id pointer is passed the PRU remoteproc processor id is
220 * Return: rproc handle on success, and an ERR_PTR on failure using one
221 * of the following error values
222 * -ENODEV if device is not found
223 * -EBUSY if PRU is already acquired by anyone
224 * -EPROBE_DEFER is PRU device is not probed yet
226 struct rproc
*pru_rproc_get(struct device_node
*np
, int index
,
227 enum pruss_pru_id
*pru_id
)
230 struct pru_rproc
*pru
;
236 rproc
= __pru_rproc_get(np
, index
);
243 mutex_lock(&pru
->lock
);
245 if (pru
->client_np
) {
246 mutex_unlock(&pru
->lock
);
248 goto err_no_rproc_handle
;
252 rproc
->sysfs_read_only
= true;
254 mutex_unlock(&pru
->lock
);
259 ret
= pruss_cfg_get_gpmux(pru
->pruss
, pru
->id
, &pru
->gpmux_save
);
261 dev_err(dev
, "failed to get cfg gpmux: %d\n", ret
);
265 /* An error here is acceptable for backward compatibility */
266 ret
= of_property_read_u32_index(np
, "ti,pruss-gp-mux-sel", index
,
269 ret
= pruss_cfg_set_gpmux(pru
->pruss
, pru
->id
, mux
);
271 dev_err(dev
, "failed to set cfg gpmux: %d\n", ret
);
276 ret
= of_property_read_string_index(np
, "firmware-name", index
,
279 ret
= pru_rproc_set_firmware(rproc
, fw_name
);
281 dev_err(dev
, "failed to set firmware: %d\n", ret
);
293 pru_rproc_put(rproc
);
296 EXPORT_SYMBOL_GPL(pru_rproc_get
);
299 * pru_rproc_put() - release the PRU rproc resource
300 * @rproc: the rproc resource to release
302 * Releases the PRU rproc resource and makes it available to other
305 void pru_rproc_put(struct rproc
*rproc
)
307 struct pru_rproc
*pru
;
309 if (IS_ERR_OR_NULL(rproc
) || !is_pru_rproc(rproc
->dev
.parent
))
314 pruss_cfg_set_gpmux(pru
->pruss
, pru
->id
, pru
->gpmux_save
);
316 pru_rproc_set_firmware(rproc
, NULL
);
318 mutex_lock(&pru
->lock
);
320 if (!pru
->client_np
) {
321 mutex_unlock(&pru
->lock
);
325 pru
->client_np
= NULL
;
326 rproc
->sysfs_read_only
= false;
327 mutex_unlock(&pru
->lock
);
331 EXPORT_SYMBOL_GPL(pru_rproc_put
);
334 * pru_rproc_set_ctable() - set the constant table index for the PRU
335 * @rproc: the rproc instance of the PRU
336 * @c: constant table index to set
337 * @addr: physical address to set it to
339 * Return: 0 on success, or errno in error case.
341 int pru_rproc_set_ctable(struct rproc
*rproc
, enum pru_ctable_idx c
, u32 addr
)
343 struct pru_rproc
*pru
= rproc
->priv
;
349 if (IS_ERR_OR_NULL(rproc
))
352 if (!rproc
->dev
.parent
|| !is_pru_rproc(rproc
->dev
.parent
))
355 /* pointer is 16 bit and index is 8-bit so mask out the rest */
356 idx_mask
= (c
>= PRU_C28
) ? 0xFFFF : 0xFF;
358 /* ctable uses bit 8 and upwards only */
359 idx
= (addr
>> 8) & idx_mask
;
361 /* configurable ctable (i.e. C24) starts at PRU_CTRL_CTBIR0 */
362 reg
= PRU_CTRL_CTBIR0
+ 4 * (c
>> 1);
363 mask
= idx_mask
<< (16 * (c
& 1));
364 set
= idx
<< (16 * (c
& 1));
366 pru_control_set_reg(pru
, reg
, mask
, set
);
370 EXPORT_SYMBOL_GPL(pru_rproc_set_ctable
);
372 static inline u32
pru_debug_read_reg(struct pru_rproc
*pru
, unsigned int reg
)
374 return readl_relaxed(pru
->mem_regions
[PRU_IOMEM_DEBUG
].va
+ reg
);
377 static int regs_show(struct seq_file
*s
, void *data
)
379 struct rproc
*rproc
= s
->private;
380 struct pru_rproc
*pru
= rproc
->priv
;
385 seq_puts(s
, "============== Control Registers ==============\n");
386 seq_printf(s
, "CTRL := 0x%08x\n",
387 pru_control_read_reg(pru
, PRU_CTRL_CTRL
));
388 pru_sts
= pru_control_read_reg(pru
, PRU_CTRL_STS
);
389 seq_printf(s
, "STS (PC) := 0x%08x (0x%08x)\n", pru_sts
, pru_sts
<< 2);
390 seq_printf(s
, "WAKEUP_EN := 0x%08x\n",
391 pru_control_read_reg(pru
, PRU_CTRL_WAKEUP_EN
));
392 seq_printf(s
, "CYCLE := 0x%08x\n",
393 pru_control_read_reg(pru
, PRU_CTRL_CYCLE
));
394 seq_printf(s
, "STALL := 0x%08x\n",
395 pru_control_read_reg(pru
, PRU_CTRL_STALL
));
396 seq_printf(s
, "CTBIR0 := 0x%08x\n",
397 pru_control_read_reg(pru
, PRU_CTRL_CTBIR0
));
398 seq_printf(s
, "CTBIR1 := 0x%08x\n",
399 pru_control_read_reg(pru
, PRU_CTRL_CTBIR1
));
400 seq_printf(s
, "CTPPR0 := 0x%08x\n",
401 pru_control_read_reg(pru
, PRU_CTRL_CTPPR0
));
402 seq_printf(s
, "CTPPR1 := 0x%08x\n",
403 pru_control_read_reg(pru
, PRU_CTRL_CTPPR1
));
405 seq_puts(s
, "=============== Debug Registers ===============\n");
406 pru_is_running
= pru_control_read_reg(pru
, PRU_CTRL_CTRL
) &
408 if (pru_is_running
) {
409 seq_puts(s
, "PRU is executing, cannot print/access debug registers.\n");
413 for (i
= 0; i
< nregs
; i
++) {
414 seq_printf(s
, "GPREG%-2d := 0x%08x\tCT_REG%-2d := 0x%08x\n",
415 i
, pru_debug_read_reg(pru
, PRU_DEBUG_GPREG(i
)),
416 i
, pru_debug_read_reg(pru
, PRU_DEBUG_CT_REG(i
)));
421 DEFINE_SHOW_ATTRIBUTE(regs
);
424 * Control PRU single-step mode
426 * This is a debug helper function used for controlling the single-step
427 * mode of the PRU. The PRU Debug registers are not accessible when the
428 * PRU is in RUNNING state.
430 * Writing a non-zero value sets the PRU into single-step mode irrespective
431 * of its previous state. The PRU mode is saved only on the first set into
432 * a single-step mode. Writing a zero value will restore the PRU into its
435 static int pru_rproc_debug_ss_set(void *data
, u64 val
)
437 struct rproc
*rproc
= data
;
438 struct pru_rproc
*pru
= rproc
->priv
;
442 if (!val
&& !pru
->dbg_single_step
)
445 reg_val
= pru_control_read_reg(pru
, PRU_CTRL_CTRL
);
447 if (val
&& !pru
->dbg_single_step
)
448 pru
->dbg_continuous
= reg_val
;
451 reg_val
|= CTRL_CTRL_SINGLE_STEP
| CTRL_CTRL_EN
;
453 reg_val
= pru
->dbg_continuous
;
455 pru
->dbg_single_step
= val
;
456 pru_control_write_reg(pru
, PRU_CTRL_CTRL
, reg_val
);
461 static int pru_rproc_debug_ss_get(void *data
, u64
*val
)
463 struct rproc
*rproc
= data
;
464 struct pru_rproc
*pru
= rproc
->priv
;
466 *val
= pru
->dbg_single_step
;
470 DEFINE_DEBUGFS_ATTRIBUTE(pru_rproc_debug_ss_fops
, pru_rproc_debug_ss_get
,
471 pru_rproc_debug_ss_set
, "%llu\n");
474 * Create PRU-specific debugfs entries
476 * The entries are created only if the parent remoteproc debugfs directory
477 * exists, and will be cleaned up by the remoteproc core.
479 static void pru_rproc_create_debug_entries(struct rproc
*rproc
)
484 debugfs_create_file("regs", 0400, rproc
->dbg_dir
,
486 debugfs_create_file("single_step", 0600, rproc
->dbg_dir
,
487 rproc
, &pru_rproc_debug_ss_fops
);
490 static void pru_dispose_irq_mapping(struct pru_rproc
*pru
)
492 if (!pru
->mapped_irq
)
495 while (pru
->evt_count
) {
497 if (pru
->mapped_irq
[pru
->evt_count
] > 0)
498 irq_dispose_mapping(pru
->mapped_irq
[pru
->evt_count
]);
501 kfree(pru
->mapped_irq
);
502 pru
->mapped_irq
= NULL
;
506 * Parse the custom PRU interrupt map resource and configure the INTC
509 static int pru_handle_intrmap(struct rproc
*rproc
)
511 struct device
*dev
= rproc
->dev
.parent
;
512 struct pru_rproc
*pru
= rproc
->priv
;
513 struct pru_irq_rsc
*rsc
= pru
->pru_interrupt_map
;
514 struct irq_fwspec fwspec
;
515 struct device_node
*parent
, *irq_parent
;
518 /* not having pru_interrupt_map is not an error */
522 /* currently supporting only type 0 */
523 if (rsc
->type
!= 0) {
524 dev_err(dev
, "unsupported rsc type: %d\n", rsc
->type
);
528 if (rsc
->num_evts
> MAX_PRU_SYS_EVENTS
)
531 if (sizeof(*rsc
) + rsc
->num_evts
* sizeof(struct pruss_int_map
) !=
532 pru
->pru_interrupt_map_sz
)
535 pru
->evt_count
= rsc
->num_evts
;
536 pru
->mapped_irq
= kcalloc(pru
->evt_count
, sizeof(unsigned int),
538 if (!pru
->mapped_irq
) {
544 * parse and fill in system event to interrupt channel and
545 * channel-to-host mapping. The interrupt controller to be used
546 * for these mappings for a given PRU remoteproc is always its
547 * corresponding sibling PRUSS INTC node.
549 parent
= of_get_parent(dev_of_node(pru
->dev
));
551 kfree(pru
->mapped_irq
);
552 pru
->mapped_irq
= NULL
;
557 irq_parent
= of_get_child_by_name(parent
, "interrupt-controller");
560 kfree(pru
->mapped_irq
);
561 pru
->mapped_irq
= NULL
;
566 fwspec
.fwnode
= of_node_to_fwnode(irq_parent
);
567 fwspec
.param_count
= 3;
568 for (i
= 0; i
< pru
->evt_count
; i
++) {
569 fwspec
.param
[0] = rsc
->pru_intc_map
[i
].event
;
570 fwspec
.param
[1] = rsc
->pru_intc_map
[i
].chnl
;
571 fwspec
.param
[2] = rsc
->pru_intc_map
[i
].host
;
573 dev_dbg(dev
, "mapping%d: event %d, chnl %d, host %d\n",
574 i
, fwspec
.param
[0], fwspec
.param
[1], fwspec
.param
[2]);
576 pru
->mapped_irq
[i
] = irq_create_fwspec_mapping(&fwspec
);
577 if (!pru
->mapped_irq
[i
]) {
578 dev_err(dev
, "failed to get virq for fw mapping %d: event %d chnl %d host %d\n",
579 i
, fwspec
.param
[0], fwspec
.param
[1],
585 of_node_put(irq_parent
);
590 pru_dispose_irq_mapping(pru
);
591 of_node_put(irq_parent
);
596 static int pru_rproc_start(struct rproc
*rproc
)
598 struct device
*dev
= &rproc
->dev
;
599 struct pru_rproc
*pru
= rproc
->priv
;
600 const char *names
[PRU_TYPE_MAX
] = { "PRU", "RTU", "Tx_PRU" };
604 dev_dbg(dev
, "starting %s%d: entry-point = 0x%llx\n",
605 names
[pru
->data
->type
], pru
->id
, (rproc
->bootaddr
>> 2));
607 ret
= pru_handle_intrmap(rproc
);
609 * reset references to pru interrupt map - they will stop being valid
610 * after rproc_start returns
612 pru
->pru_interrupt_map
= NULL
;
613 pru
->pru_interrupt_map_sz
= 0;
617 val
= CTRL_CTRL_EN
| ((rproc
->bootaddr
>> 2) << 16);
618 pru_control_write_reg(pru
, PRU_CTRL_CTRL
, val
);
623 static int pru_rproc_stop(struct rproc
*rproc
)
625 struct device
*dev
= &rproc
->dev
;
626 struct pru_rproc
*pru
= rproc
->priv
;
627 const char *names
[PRU_TYPE_MAX
] = { "PRU", "RTU", "Tx_PRU" };
630 dev_dbg(dev
, "stopping %s%d\n", names
[pru
->data
->type
], pru
->id
);
632 val
= pru_control_read_reg(pru
, PRU_CTRL_CTRL
);
633 val
&= ~CTRL_CTRL_EN
;
634 pru_control_write_reg(pru
, PRU_CTRL_CTRL
, val
);
636 /* dispose irq mapping - new firmware can provide new mapping */
637 pru_dispose_irq_mapping(pru
);
643 * Convert PRU device address (data spaces only) to kernel virtual address.
645 * Each PRU has access to all data memories within the PRUSS, accessible at
646 * different ranges. So, look through both its primary and secondary Data
647 * RAMs as well as any shared Data RAM to convert a PRU device address to
648 * kernel virtual address. Data RAM0 is primary Data RAM for PRU0 and Data
649 * RAM1 is primary Data RAM for PRU1.
651 static void *pru_d_da_to_va(struct pru_rproc
*pru
, u32 da
, size_t len
)
653 struct pruss_mem_region dram0
, dram1
, shrd_ram
;
654 struct pruss
*pruss
= pru
->pruss
;
661 dram0
= pruss
->mem_regions
[PRUSS_MEM_DRAM0
];
662 dram1
= pruss
->mem_regions
[PRUSS_MEM_DRAM1
];
663 /* PRU1 has its local RAM addresses reversed */
664 if (pru
->id
== PRUSS_PRU1
)
666 shrd_ram
= pruss
->mem_regions
[PRUSS_MEM_SHRD_RAM2
];
668 if (da
+ len
<= PRU_PDRAM_DA
+ dram0
.size
) {
669 offset
= da
- PRU_PDRAM_DA
;
670 va
= (__force
void *)(dram0
.va
+ offset
);
671 } else if (da
>= PRU_SDRAM_DA
&&
672 da
+ len
<= PRU_SDRAM_DA
+ dram1
.size
) {
673 offset
= da
- PRU_SDRAM_DA
;
674 va
= (__force
void *)(dram1
.va
+ offset
);
675 } else if (da
>= PRU_SHRDRAM_DA
&&
676 da
+ len
<= PRU_SHRDRAM_DA
+ shrd_ram
.size
) {
677 offset
= da
- PRU_SHRDRAM_DA
;
678 va
= (__force
void *)(shrd_ram
.va
+ offset
);
685 * Convert PRU device address (instruction space) to kernel virtual address.
687 * A PRU does not have an unified address space. Each PRU has its very own
688 * private Instruction RAM, and its device address is identical to that of
689 * its primary Data RAM device address.
691 static void *pru_i_da_to_va(struct pru_rproc
*pru
, u32 da
, size_t len
)
700 * GNU binutils do not support multiple address spaces. The GNU
701 * linker's default linker script places IRAM at an arbitrary high
702 * offset, in order to differentiate it from DRAM. Hence we need to
703 * strip the artificial offset in the IRAM addresses coming from the
706 * The TI proprietary linker would never set those higher IRAM address
707 * bits anyway. PRU architecture limits the program counter to 16-bit
708 * word-address range. This in turn corresponds to 18-bit IRAM
709 * byte-address range for ELF.
711 * Two more bits are added just in case to make the final 20-bit mask.
712 * Idea is to have a safeguard in case TI decides to add banking
717 if (da
+ len
<= PRU_IRAM_DA
+ pru
->mem_regions
[PRU_IOMEM_IRAM
].size
) {
718 offset
= da
- PRU_IRAM_DA
;
719 va
= (__force
void *)(pru
->mem_regions
[PRU_IOMEM_IRAM
].va
+
727 * Provide address translations for only PRU Data RAMs through the remoteproc
728 * core for any PRU client drivers. The PRU Instruction RAM access is restricted
729 * only to the PRU loader code.
731 static void *pru_rproc_da_to_va(struct rproc
*rproc
, u64 da
, size_t len
, bool *is_iomem
)
733 struct pru_rproc
*pru
= rproc
->priv
;
735 return pru_d_da_to_va(pru
, da
, len
);
738 /* PRU-specific address translator used by PRU loader. */
739 static void *pru_da_to_va(struct rproc
*rproc
, u64 da
, size_t len
, bool is_iram
)
741 struct pru_rproc
*pru
= rproc
->priv
;
745 va
= pru_i_da_to_va(pru
, da
, len
);
747 va
= pru_d_da_to_va(pru
, da
, len
);
752 static struct rproc_ops pru_rproc_ops
= {
753 .start
= pru_rproc_start
,
754 .stop
= pru_rproc_stop
,
755 .da_to_va
= pru_rproc_da_to_va
,
759 * Custom memory copy implementation for ICSSG PRU/RTU/Tx_PRU Cores
761 * The ICSSG PRU/RTU/Tx_PRU cores have a memory copying issue with IRAM
762 * memories, that is not seen on previous generation SoCs. The data is reflected
763 * properly in the IRAM memories only for integer (4-byte) copies. Any unaligned
764 * copies result in all the other pre-existing bytes zeroed out within that
765 * 4-byte boundary, thereby resulting in wrong text/code in the IRAMs. Also, the
766 * IRAM memory port interface does not allow any 8-byte copies (as commonly used
767 * by ARM64 memcpy implementation) and throws an exception. The DRAM memory
768 * ports do not show this behavior.
770 static int pru_rproc_memcpy(void *dest
, const void *src
, size_t count
)
774 size_t size
= count
/ 4;
778 * TODO: relax limitation of 4-byte aligned dest addresses and copy
781 if ((long)dest
% 4 || count
% 4)
784 /* src offsets in ELF firmware image can be non-aligned */
786 tmp_src
= kmemdup(src
, count
, GFP_KERNEL
);
801 pru_rproc_load_elf_segments(struct rproc
*rproc
, const struct firmware
*fw
)
803 struct pru_rproc
*pru
= rproc
->priv
;
804 struct device
*dev
= &rproc
->dev
;
805 struct elf32_hdr
*ehdr
;
806 struct elf32_phdr
*phdr
;
808 const u8
*elf_data
= fw
->data
;
810 ehdr
= (struct elf32_hdr
*)elf_data
;
811 phdr
= (struct elf32_phdr
*)(elf_data
+ ehdr
->e_phoff
);
813 /* go through the available ELF segments */
814 for (i
= 0; i
< ehdr
->e_phnum
; i
++, phdr
++) {
815 u32 da
= phdr
->p_paddr
;
816 u32 memsz
= phdr
->p_memsz
;
817 u32 filesz
= phdr
->p_filesz
;
818 u32 offset
= phdr
->p_offset
;
822 if (phdr
->p_type
!= PT_LOAD
|| !filesz
)
825 dev_dbg(dev
, "phdr: type %d da 0x%x memsz 0x%x filesz 0x%x\n",
826 phdr
->p_type
, da
, memsz
, filesz
);
828 if (filesz
> memsz
) {
829 dev_err(dev
, "bad phdr filesz 0x%x memsz 0x%x\n",
835 if (offset
+ filesz
> fw
->size
) {
836 dev_err(dev
, "truncated fw: need 0x%x avail 0x%zx\n",
837 offset
+ filesz
, fw
->size
);
842 /* grab the kernel address for this device address */
843 is_iram
= phdr
->p_flags
& PF_X
;
844 ptr
= pru_da_to_va(rproc
, da
, memsz
, is_iram
);
846 dev_err(dev
, "bad phdr da 0x%x mem 0x%x\n", da
, memsz
);
851 if (pru
->data
->is_k3
) {
852 ret
= pru_rproc_memcpy(ptr
, elf_data
+ phdr
->p_offset
,
855 dev_err(dev
, "PRU memory copy failed for da 0x%x memsz 0x%x\n",
860 memcpy(ptr
, elf_data
+ phdr
->p_offset
, filesz
);
863 /* skip the memzero logic performed by remoteproc ELF loader */
870 pru_rproc_find_interrupt_map(struct device
*dev
, const struct firmware
*fw
)
872 struct elf32_shdr
*shdr
, *name_table_shdr
;
873 const char *name_table
;
874 const u8
*elf_data
= fw
->data
;
875 struct elf32_hdr
*ehdr
= (struct elf32_hdr
*)elf_data
;
876 u16 shnum
= ehdr
->e_shnum
;
877 u16 shstrndx
= ehdr
->e_shstrndx
;
880 /* first, get the section header */
881 shdr
= (struct elf32_shdr
*)(elf_data
+ ehdr
->e_shoff
);
882 /* compute name table section header entry in shdr array */
883 name_table_shdr
= shdr
+ shstrndx
;
884 /* finally, compute the name table section address in elf */
885 name_table
= elf_data
+ name_table_shdr
->sh_offset
;
887 for (i
= 0; i
< shnum
; i
++, shdr
++) {
888 u32 size
= shdr
->sh_size
;
889 u32 offset
= shdr
->sh_offset
;
890 u32 name
= shdr
->sh_name
;
892 if (strcmp(name_table
+ name
, ".pru_irq_map"))
895 /* make sure we have the entire irq map */
896 if (offset
+ size
> fw
->size
|| offset
+ size
< size
) {
897 dev_err(dev
, ".pru_irq_map section truncated\n");
898 return ERR_PTR(-EINVAL
);
901 /* make sure irq map has at least the header */
902 if (sizeof(struct pru_irq_rsc
) > size
) {
903 dev_err(dev
, "header-less .pru_irq_map section\n");
904 return ERR_PTR(-EINVAL
);
910 dev_dbg(dev
, "no .pru_irq_map section found for this fw\n");
916 * Use a custom parse_fw callback function for dealing with PRU firmware
919 * The firmware blob can contain optional ELF sections: .resource_table section
920 * and .pru_irq_map one. The second one contains the PRUSS interrupt mapping
921 * description, which needs to be setup before powering on the PRU core. To
922 * avoid RAM wastage this ELF section is not mapped to any ELF segment (by the
923 * firmware linker) and therefore is not loaded to PRU memory.
925 static int pru_rproc_parse_fw(struct rproc
*rproc
, const struct firmware
*fw
)
927 struct device
*dev
= &rproc
->dev
;
928 struct pru_rproc
*pru
= rproc
->priv
;
929 const u8
*elf_data
= fw
->data
;
931 u8
class = fw_elf_get_class(fw
);
935 /* load optional rsc table */
936 ret
= rproc_elf_load_rsc_table(rproc
, fw
);
938 dev_dbg(&rproc
->dev
, "no resource table found for this fw\n");
942 /* find .pru_interrupt_map section, not having it is not an error */
943 shdr
= pru_rproc_find_interrupt_map(dev
, fw
);
945 return PTR_ERR(shdr
);
950 /* preserve pointer to PRU interrupt map together with it size */
951 sh_offset
= elf_shdr_get_sh_offset(class, shdr
);
952 pru
->pru_interrupt_map
= (struct pru_irq_rsc
*)(elf_data
+ sh_offset
);
953 pru
->pru_interrupt_map_sz
= elf_shdr_get_sh_size(class, shdr
);
959 * Compute PRU id based on the IRAM addresses. The PRU IRAMs are
960 * always at a particular offset within the PRUSS address space.
962 static int pru_rproc_set_id(struct pru_rproc
*pru
)
966 switch (pru
->mem_regions
[PRU_IOMEM_IRAM
].pa
& PRU_IRAM_ADDR_MASK
) {
967 case TX_PRU0_IRAM_ADDR_MASK
:
969 case RTU0_IRAM_ADDR_MASK
:
971 case PRU0_IRAM_ADDR_MASK
:
972 pru
->id
= PRUSS_PRU0
;
974 case TX_PRU1_IRAM_ADDR_MASK
:
976 case RTU1_IRAM_ADDR_MASK
:
978 case PRU1_IRAM_ADDR_MASK
:
979 pru
->id
= PRUSS_PRU1
;
988 static int pru_rproc_probe(struct platform_device
*pdev
)
990 struct device
*dev
= &pdev
->dev
;
991 struct device_node
*np
= dev
->of_node
;
992 struct platform_device
*ppdev
= to_platform_device(dev
->parent
);
993 struct pru_rproc
*pru
;
995 struct rproc
*rproc
= NULL
;
996 struct resource
*res
;
998 const struct pru_private_data
*data
;
999 const char *mem_names
[PRU_IOMEM_MAX
] = { "iram", "control", "debug" };
1001 data
= of_device_get_match_data(&pdev
->dev
);
1005 ret
= of_property_read_string(np
, "firmware-name", &fw_name
);
1007 dev_err(dev
, "unable to retrieve firmware-name %d\n", ret
);
1011 rproc
= devm_rproc_alloc(dev
, pdev
->name
, &pru_rproc_ops
, fw_name
,
1014 dev_err(dev
, "rproc_alloc failed\n");
1017 /* use a custom load function to deal with PRU-specific quirks */
1018 rproc
->ops
->load
= pru_rproc_load_elf_segments
;
1020 /* use a custom parse function to deal with PRU-specific resources */
1021 rproc
->ops
->parse_fw
= pru_rproc_parse_fw
;
1023 /* error recovery is not supported for PRUs */
1024 rproc
->recovery_disabled
= true;
1027 * rproc_add will auto-boot the processor normally, but this is not
1028 * desired with PRU client driven boot-flow methodology. A PRU
1029 * application/client driver will boot the corresponding PRU
1030 * remote-processor as part of its state machine either through the
1031 * remoteproc sysfs interface or through the equivalent kernel API.
1033 rproc
->auto_boot
= false;
1038 pru
->pruss
= platform_get_drvdata(ppdev
);
1040 pru
->fw_name
= fw_name
;
1041 pru
->client_np
= NULL
;
1042 spin_lock_init(&pru
->rmw_lock
);
1043 mutex_init(&pru
->lock
);
1045 for (i
= 0; i
< ARRAY_SIZE(mem_names
); i
++) {
1046 res
= platform_get_resource_byname(pdev
, IORESOURCE_MEM
,
1048 pru
->mem_regions
[i
].va
= devm_ioremap_resource(dev
, res
);
1049 if (IS_ERR(pru
->mem_regions
[i
].va
)) {
1050 dev_err(dev
, "failed to parse and map memory resource %d %s\n",
1052 ret
= PTR_ERR(pru
->mem_regions
[i
].va
);
1055 pru
->mem_regions
[i
].pa
= res
->start
;
1056 pru
->mem_regions
[i
].size
= resource_size(res
);
1058 dev_dbg(dev
, "memory %8s: pa %pa size 0x%zx va %pK\n",
1059 mem_names
[i
], &pru
->mem_regions
[i
].pa
,
1060 pru
->mem_regions
[i
].size
, pru
->mem_regions
[i
].va
);
1063 ret
= pru_rproc_set_id(pru
);
1067 platform_set_drvdata(pdev
, rproc
);
1069 ret
= devm_rproc_add(dev
, pru
->rproc
);
1071 dev_err(dev
, "rproc_add failed: %d\n", ret
);
1075 pru_rproc_create_debug_entries(rproc
);
1077 dev_dbg(dev
, "PRU rproc node %pOF probed successfully\n", np
);
1082 static void pru_rproc_remove(struct platform_device
*pdev
)
1084 struct device
*dev
= &pdev
->dev
;
1085 struct rproc
*rproc
= platform_get_drvdata(pdev
);
1087 dev_dbg(dev
, "%s: removing rproc %s\n", __func__
, rproc
->name
);
1090 static const struct pru_private_data pru_data
= {
1091 .type
= PRU_TYPE_PRU
,
1094 static const struct pru_private_data k3_pru_data
= {
1095 .type
= PRU_TYPE_PRU
,
1099 static const struct pru_private_data k3_rtu_data
= {
1100 .type
= PRU_TYPE_RTU
,
1104 static const struct pru_private_data k3_tx_pru_data
= {
1105 .type
= PRU_TYPE_TX_PRU
,
1109 static const struct of_device_id pru_rproc_match
[] = {
1110 { .compatible
= "ti,am3356-pru", .data
= &pru_data
},
1111 { .compatible
= "ti,am4376-pru", .data
= &pru_data
},
1112 { .compatible
= "ti,am5728-pru", .data
= &pru_data
},
1113 { .compatible
= "ti,am642-pru", .data
= &k3_pru_data
},
1114 { .compatible
= "ti,am642-rtu", .data
= &k3_rtu_data
},
1115 { .compatible
= "ti,am642-tx-pru", .data
= &k3_tx_pru_data
},
1116 { .compatible
= "ti,k2g-pru", .data
= &pru_data
},
1117 { .compatible
= "ti,am654-pru", .data
= &k3_pru_data
},
1118 { .compatible
= "ti,am654-rtu", .data
= &k3_rtu_data
},
1119 { .compatible
= "ti,am654-tx-pru", .data
= &k3_tx_pru_data
},
1120 { .compatible
= "ti,j721e-pru", .data
= &k3_pru_data
},
1121 { .compatible
= "ti,j721e-rtu", .data
= &k3_rtu_data
},
1122 { .compatible
= "ti,j721e-tx-pru", .data
= &k3_tx_pru_data
},
1123 { .compatible
= "ti,am625-pru", .data
= &k3_pru_data
},
1126 MODULE_DEVICE_TABLE(of
, pru_rproc_match
);
1128 static struct platform_driver pru_rproc_driver
= {
1130 .name
= PRU_RPROC_DRVNAME
,
1131 .of_match_table
= pru_rproc_match
,
1132 .suppress_bind_attrs
= true,
1134 .probe
= pru_rproc_probe
,
1135 .remove
= pru_rproc_remove
,
1137 module_platform_driver(pru_rproc_driver
);
1139 MODULE_AUTHOR("Suman Anna <s-anna@ti.com>");
1140 MODULE_AUTHOR("Andrew F. Davis <afd@ti.com>");
1141 MODULE_AUTHOR("Grzegorz Jaszczyk <grzegorz.jaszczyk@linaro.org>");
1142 MODULE_AUTHOR("Puranjay Mohan <p-mohan@ti.com>");
1143 MODULE_AUTHOR("Md Danish Anwar <danishanwar@ti.com>");
1144 MODULE_DESCRIPTION("PRU-ICSS Remote Processor Driver");
1145 MODULE_LICENSE("GPL v2");