1d4ce2de7SSuman Anna // SPDX-License-Identifier: GPL-2.0-only
2d4ce2de7SSuman Anna /*
3d4ce2de7SSuman Anna * PRU-ICSS remoteproc driver for various TI SoCs
4d4ce2de7SSuman Anna *
5919e8942SMD Danish Anwar * Copyright (C) 2014-2022 Texas Instruments Incorporated - https://www.ti.com/
6d4ce2de7SSuman Anna *
7d4ce2de7SSuman Anna * Author(s):
8d4ce2de7SSuman Anna * Suman Anna <s-anna@ti.com>
9d4ce2de7SSuman Anna * Andrew F. Davis <afd@ti.com>
10d4ce2de7SSuman Anna * Grzegorz Jaszczyk <grzegorz.jaszczyk@linaro.org> for Texas Instruments
11919e8942SMD Danish Anwar * Puranjay Mohan <p-mohan@ti.com>
12919e8942SMD Danish Anwar * Md Danish Anwar <danishanwar@ti.com>
13d4ce2de7SSuman Anna */
14d4ce2de7SSuman Anna
15d4ce2de7SSuman Anna #include <linux/bitops.h>
1620ad1de0SSuman Anna #include <linux/debugfs.h>
17c75c9fdaSGrzegorz Jaszczyk #include <linux/irqdomain.h>
18d4ce2de7SSuman Anna #include <linux/module.h>
193440d8daSRob Herring #include <linux/of.h>
20c75c9fdaSGrzegorz Jaszczyk #include <linux/of_irq.h>
213440d8daSRob Herring #include <linux/platform_device.h>
229b9ad70fSMD Danish Anwar #include <linux/remoteproc/pruss.h>
23d4ce2de7SSuman Anna #include <linux/pruss_driver.h>
24d4ce2de7SSuman Anna #include <linux/remoteproc.h>
25d4ce2de7SSuman Anna
26d4ce2de7SSuman Anna #include "remoteproc_internal.h"
27d4ce2de7SSuman Anna #include "remoteproc_elf_helpers.h"
28c75c9fdaSGrzegorz Jaszczyk #include "pru_rproc.h"
29d4ce2de7SSuman Anna
30d4ce2de7SSuman Anna /* PRU_ICSS_PRU_CTRL registers */
31d4ce2de7SSuman Anna #define PRU_CTRL_CTRL 0x0000
32d4ce2de7SSuman Anna #define PRU_CTRL_STS 0x0004
3320ad1de0SSuman Anna #define PRU_CTRL_WAKEUP_EN 0x0008
3420ad1de0SSuman Anna #define PRU_CTRL_CYCLE 0x000C
3520ad1de0SSuman Anna #define PRU_CTRL_STALL 0x0010
3620ad1de0SSuman Anna #define PRU_CTRL_CTBIR0 0x0020
3720ad1de0SSuman Anna #define PRU_CTRL_CTBIR1 0x0024
3820ad1de0SSuman Anna #define PRU_CTRL_CTPPR0 0x0028
3920ad1de0SSuman Anna #define PRU_CTRL_CTPPR1 0x002C
40d4ce2de7SSuman Anna
41d4ce2de7SSuman Anna /* CTRL register bit-fields */
42d4ce2de7SSuman Anna #define CTRL_CTRL_SOFT_RST_N BIT(0)
43d4ce2de7SSuman Anna #define CTRL_CTRL_EN BIT(1)
44d4ce2de7SSuman Anna #define CTRL_CTRL_SLEEPING BIT(2)
45d4ce2de7SSuman Anna #define CTRL_CTRL_CTR_EN BIT(3)
46d4ce2de7SSuman Anna #define CTRL_CTRL_SINGLE_STEP BIT(8)
47d4ce2de7SSuman Anna #define CTRL_CTRL_RUNSTATE BIT(15)
48d4ce2de7SSuman Anna
4920ad1de0SSuman Anna /* PRU_ICSS_PRU_DEBUG registers */
5020ad1de0SSuman Anna #define PRU_DEBUG_GPREG(x) (0x0000 + (x) * 4)
5120ad1de0SSuman Anna #define PRU_DEBUG_CT_REG(x) (0x0080 + (x) * 4)
5220ad1de0SSuman Anna
531d39f4d1SSuman Anna /* PRU/RTU/Tx_PRU Core IRAM address masks */
54d4ce2de7SSuman Anna #define PRU_IRAM_ADDR_MASK 0x3ffff
55d4ce2de7SSuman Anna #define PRU0_IRAM_ADDR_MASK 0x34000
56d4ce2de7SSuman Anna #define PRU1_IRAM_ADDR_MASK 0x38000
571d39f4d1SSuman Anna #define RTU0_IRAM_ADDR_MASK 0x4000
581d39f4d1SSuman Anna #define RTU1_IRAM_ADDR_MASK 0x6000
591d39f4d1SSuman Anna #define TX_PRU0_IRAM_ADDR_MASK 0xa000
601d39f4d1SSuman Anna #define TX_PRU1_IRAM_ADDR_MASK 0xc000
61d4ce2de7SSuman Anna
62d4ce2de7SSuman Anna /* PRU device addresses for various type of PRU RAMs */
63d4ce2de7SSuman Anna #define PRU_IRAM_DA 0 /* Instruction RAM */
64d4ce2de7SSuman Anna #define PRU_PDRAM_DA 0 /* Primary Data RAM */
65d4ce2de7SSuman Anna #define PRU_SDRAM_DA 0x2000 /* Secondary Data RAM */
66d4ce2de7SSuman Anna #define PRU_SHRDRAM_DA 0x10000 /* Shared Data RAM */
67d4ce2de7SSuman Anna
68c75c9fdaSGrzegorz Jaszczyk #define MAX_PRU_SYS_EVENTS 160
69c75c9fdaSGrzegorz Jaszczyk
70d4ce2de7SSuman Anna /**
71d4ce2de7SSuman Anna * enum pru_iomem - PRU core memory/register range identifiers
72d4ce2de7SSuman Anna *
73d4ce2de7SSuman Anna * @PRU_IOMEM_IRAM: PRU Instruction RAM range
74d4ce2de7SSuman Anna * @PRU_IOMEM_CTRL: PRU Control register range
75d4ce2de7SSuman Anna * @PRU_IOMEM_DEBUG: PRU Debug register range
76d4ce2de7SSuman Anna * @PRU_IOMEM_MAX: just keep this one at the end
77d4ce2de7SSuman Anna */
78d4ce2de7SSuman Anna enum pru_iomem {
79d4ce2de7SSuman Anna PRU_IOMEM_IRAM = 0,
80d4ce2de7SSuman Anna PRU_IOMEM_CTRL,
81d4ce2de7SSuman Anna PRU_IOMEM_DEBUG,
82d4ce2de7SSuman Anna PRU_IOMEM_MAX,
83d4ce2de7SSuman Anna };
84d4ce2de7SSuman Anna
85d4ce2de7SSuman Anna /**
861d39f4d1SSuman Anna * struct pru_private_data - device data for a PRU core
871d39f4d1SSuman Anna * @type: type of the PRU core (PRU, RTU, Tx_PRU)
881d39f4d1SSuman Anna * @is_k3: flag used to identify the need for special load handling
891d39f4d1SSuman Anna */
901d39f4d1SSuman Anna struct pru_private_data {
911d39f4d1SSuman Anna enum pru_type type;
921d39f4d1SSuman Anna unsigned int is_k3 : 1;
931d39f4d1SSuman Anna };
941d39f4d1SSuman Anna
951d39f4d1SSuman Anna /**
96d4ce2de7SSuman Anna * struct pru_rproc - PRU remoteproc structure
97d4ce2de7SSuman Anna * @id: id of the PRU core within the PRUSS
98d4ce2de7SSuman Anna * @dev: PRU core device pointer
99d4ce2de7SSuman Anna * @pruss: back-reference to parent PRUSS structure
100d4ce2de7SSuman Anna * @rproc: remoteproc pointer for this PRU core
1011d39f4d1SSuman Anna * @data: PRU core specific data
102d4ce2de7SSuman Anna * @mem_regions: data for each of the PRU memory regions
103919e8942SMD Danish Anwar * @client_np: client device node
104919e8942SMD Danish Anwar * @lock: mutex to protect client usage
105d4ce2de7SSuman Anna * @fw_name: name of firmware image used during loading
106c75c9fdaSGrzegorz Jaszczyk * @mapped_irq: virtual interrupt numbers of created fw specific mapping
107c75c9fdaSGrzegorz Jaszczyk * @pru_interrupt_map: pointer to interrupt mapping description (firmware)
108c75c9fdaSGrzegorz Jaszczyk * @pru_interrupt_map_sz: pru_interrupt_map size
10910285340SRoger Quadros * @rmw_lock: lock for read, modify, write operations on registers
11020ad1de0SSuman Anna * @dbg_single_step: debug state variable to set PRU into single step mode
11120ad1de0SSuman Anna * @dbg_continuous: debug state variable to restore PRU execution mode
112c75c9fdaSGrzegorz Jaszczyk * @evt_count: number of mapped events
113*18cf4fcdSTero Kristo * @gpmux_save: saved value for gpmux config
114d4ce2de7SSuman Anna */
115d4ce2de7SSuman Anna struct pru_rproc {
116d4ce2de7SSuman Anna int id;
117d4ce2de7SSuman Anna struct device *dev;
118d4ce2de7SSuman Anna struct pruss *pruss;
119d4ce2de7SSuman Anna struct rproc *rproc;
1201d39f4d1SSuman Anna const struct pru_private_data *data;
121d4ce2de7SSuman Anna struct pruss_mem_region mem_regions[PRU_IOMEM_MAX];
122919e8942SMD Danish Anwar struct device_node *client_np;
123919e8942SMD Danish Anwar struct mutex lock;
124d4ce2de7SSuman Anna const char *fw_name;
125c75c9fdaSGrzegorz Jaszczyk unsigned int *mapped_irq;
126c75c9fdaSGrzegorz Jaszczyk struct pru_irq_rsc *pru_interrupt_map;
127c75c9fdaSGrzegorz Jaszczyk size_t pru_interrupt_map_sz;
12810285340SRoger Quadros spinlock_t rmw_lock;
12920ad1de0SSuman Anna u32 dbg_single_step;
13020ad1de0SSuman Anna u32 dbg_continuous;
131c75c9fdaSGrzegorz Jaszczyk u8 evt_count;
132*18cf4fcdSTero Kristo u8 gpmux_save;
133d4ce2de7SSuman Anna };
134d4ce2de7SSuman Anna
pru_control_read_reg(struct pru_rproc * pru,unsigned int reg)135d4ce2de7SSuman Anna static inline u32 pru_control_read_reg(struct pru_rproc *pru, unsigned int reg)
136d4ce2de7SSuman Anna {
137d4ce2de7SSuman Anna return readl_relaxed(pru->mem_regions[PRU_IOMEM_CTRL].va + reg);
138d4ce2de7SSuman Anna }
139d4ce2de7SSuman Anna
140d4ce2de7SSuman Anna static inline
pru_control_write_reg(struct pru_rproc * pru,unsigned int reg,u32 val)141d4ce2de7SSuman Anna void pru_control_write_reg(struct pru_rproc *pru, unsigned int reg, u32 val)
142d4ce2de7SSuman Anna {
143d4ce2de7SSuman Anna writel_relaxed(val, pru->mem_regions[PRU_IOMEM_CTRL].va + reg);
144d4ce2de7SSuman Anna }
145d4ce2de7SSuman Anna
14610285340SRoger Quadros static inline
pru_control_set_reg(struct pru_rproc * pru,unsigned int reg,u32 mask,u32 set)14710285340SRoger Quadros void pru_control_set_reg(struct pru_rproc *pru, unsigned int reg,
14810285340SRoger Quadros u32 mask, u32 set)
14910285340SRoger Quadros {
15010285340SRoger Quadros u32 val;
15110285340SRoger Quadros unsigned long flags;
15210285340SRoger Quadros
15310285340SRoger Quadros spin_lock_irqsave(&pru->rmw_lock, flags);
15410285340SRoger Quadros
15510285340SRoger Quadros val = pru_control_read_reg(pru, reg);
15610285340SRoger Quadros val &= ~mask;
15710285340SRoger Quadros val |= (set & mask);
15810285340SRoger Quadros pru_control_write_reg(pru, reg, val);
15910285340SRoger Quadros
16010285340SRoger Quadros spin_unlock_irqrestore(&pru->rmw_lock, flags);
16110285340SRoger Quadros }
16210285340SRoger Quadros
163133f30d3STero Kristo /**
164133f30d3STero Kristo * pru_rproc_set_firmware() - set firmware for a PRU core
165133f30d3STero Kristo * @rproc: the rproc instance of the PRU
166133f30d3STero Kristo * @fw_name: the new firmware name, or NULL if default is desired
167133f30d3STero Kristo *
168133f30d3STero Kristo * Return: 0 on success, or errno in error case.
169133f30d3STero Kristo */
pru_rproc_set_firmware(struct rproc * rproc,const char * fw_name)170133f30d3STero Kristo static int pru_rproc_set_firmware(struct rproc *rproc, const char *fw_name)
171133f30d3STero Kristo {
172133f30d3STero Kristo struct pru_rproc *pru = rproc->priv;
173133f30d3STero Kristo
174133f30d3STero Kristo if (!fw_name)
175133f30d3STero Kristo fw_name = pru->fw_name;
176133f30d3STero Kristo
177133f30d3STero Kristo return rproc_set_firmware(rproc, fw_name);
178133f30d3STero Kristo }
179133f30d3STero Kristo
__pru_rproc_get(struct device_node * np,int index)180919e8942SMD Danish Anwar static struct rproc *__pru_rproc_get(struct device_node *np, int index)
181919e8942SMD Danish Anwar {
182919e8942SMD Danish Anwar struct rproc *rproc;
183919e8942SMD Danish Anwar phandle rproc_phandle;
184919e8942SMD Danish Anwar int ret;
185919e8942SMD Danish Anwar
186919e8942SMD Danish Anwar ret = of_property_read_u32_index(np, "ti,prus", index, &rproc_phandle);
187919e8942SMD Danish Anwar if (ret)
188919e8942SMD Danish Anwar return ERR_PTR(ret);
189919e8942SMD Danish Anwar
190919e8942SMD Danish Anwar rproc = rproc_get_by_phandle(rproc_phandle);
191919e8942SMD Danish Anwar if (!rproc) {
192919e8942SMD Danish Anwar ret = -EPROBE_DEFER;
193919e8942SMD Danish Anwar return ERR_PTR(ret);
194919e8942SMD Danish Anwar }
195919e8942SMD Danish Anwar
196919e8942SMD Danish Anwar /* make sure it is PRU rproc */
197919e8942SMD Danish Anwar if (!is_pru_rproc(rproc->dev.parent)) {
198919e8942SMD Danish Anwar rproc_put(rproc);
199919e8942SMD Danish Anwar return ERR_PTR(-ENODEV);
200919e8942SMD Danish Anwar }
201919e8942SMD Danish Anwar
202919e8942SMD Danish Anwar return rproc;
203919e8942SMD Danish Anwar }
204919e8942SMD Danish Anwar
205919e8942SMD Danish Anwar /**
206919e8942SMD Danish Anwar * pru_rproc_get() - get the PRU rproc instance from a device node
207919e8942SMD Danish Anwar * @np: the user/client device node
208919e8942SMD Danish Anwar * @index: index to use for the ti,prus property
209919e8942SMD Danish Anwar * @pru_id: optional pointer to return the PRU remoteproc processor id
210919e8942SMD Danish Anwar *
211919e8942SMD Danish Anwar * This function looks through a client device node's "ti,prus" property at
212919e8942SMD Danish Anwar * index @index and returns the rproc handle for a valid PRU remote processor if
213919e8942SMD Danish Anwar * found. The function allows only one user to own the PRU rproc resource at a
214919e8942SMD Danish Anwar * time. Caller must call pru_rproc_put() when done with using the rproc, not
215919e8942SMD Danish Anwar * required if the function returns a failure.
216919e8942SMD Danish Anwar *
217919e8942SMD Danish Anwar * When optional @pru_id pointer is passed the PRU remoteproc processor id is
218919e8942SMD Danish Anwar * returned.
219919e8942SMD Danish Anwar *
220919e8942SMD Danish Anwar * Return: rproc handle on success, and an ERR_PTR on failure using one
221919e8942SMD Danish Anwar * of the following error values
222919e8942SMD Danish Anwar * -ENODEV if device is not found
223919e8942SMD Danish Anwar * -EBUSY if PRU is already acquired by anyone
224919e8942SMD Danish Anwar * -EPROBE_DEFER is PRU device is not probed yet
225919e8942SMD Danish Anwar */
pru_rproc_get(struct device_node * np,int index,enum pruss_pru_id * pru_id)226919e8942SMD Danish Anwar struct rproc *pru_rproc_get(struct device_node *np, int index,
227919e8942SMD Danish Anwar enum pruss_pru_id *pru_id)
228919e8942SMD Danish Anwar {
229919e8942SMD Danish Anwar struct rproc *rproc;
230919e8942SMD Danish Anwar struct pru_rproc *pru;
231919e8942SMD Danish Anwar struct device *dev;
232133f30d3STero Kristo const char *fw_name;
233919e8942SMD Danish Anwar int ret;
234*18cf4fcdSTero Kristo u32 mux;
235919e8942SMD Danish Anwar
236919e8942SMD Danish Anwar rproc = __pru_rproc_get(np, index);
237919e8942SMD Danish Anwar if (IS_ERR(rproc))
238919e8942SMD Danish Anwar return rproc;
239919e8942SMD Danish Anwar
240919e8942SMD Danish Anwar pru = rproc->priv;
241919e8942SMD Danish Anwar dev = &rproc->dev;
242919e8942SMD Danish Anwar
243919e8942SMD Danish Anwar mutex_lock(&pru->lock);
244919e8942SMD Danish Anwar
245919e8942SMD Danish Anwar if (pru->client_np) {
246919e8942SMD Danish Anwar mutex_unlock(&pru->lock);
247919e8942SMD Danish Anwar ret = -EBUSY;
248919e8942SMD Danish Anwar goto err_no_rproc_handle;
249919e8942SMD Danish Anwar }
250919e8942SMD Danish Anwar
251919e8942SMD Danish Anwar pru->client_np = np;
2522da812ffSSuman Anna rproc->sysfs_read_only = true;
253919e8942SMD Danish Anwar
254919e8942SMD Danish Anwar mutex_unlock(&pru->lock);
255919e8942SMD Danish Anwar
256919e8942SMD Danish Anwar if (pru_id)
257919e8942SMD Danish Anwar *pru_id = pru->id;
258919e8942SMD Danish Anwar
259*18cf4fcdSTero Kristo ret = pruss_cfg_get_gpmux(pru->pruss, pru->id, &pru->gpmux_save);
260*18cf4fcdSTero Kristo if (ret) {
261*18cf4fcdSTero Kristo dev_err(dev, "failed to get cfg gpmux: %d\n", ret);
262*18cf4fcdSTero Kristo goto err;
263*18cf4fcdSTero Kristo }
264*18cf4fcdSTero Kristo
265*18cf4fcdSTero Kristo /* An error here is acceptable for backward compatibility */
266*18cf4fcdSTero Kristo ret = of_property_read_u32_index(np, "ti,pruss-gp-mux-sel", index,
267*18cf4fcdSTero Kristo &mux);
268*18cf4fcdSTero Kristo if (!ret) {
269*18cf4fcdSTero Kristo ret = pruss_cfg_set_gpmux(pru->pruss, pru->id, mux);
270*18cf4fcdSTero Kristo if (ret) {
271*18cf4fcdSTero Kristo dev_err(dev, "failed to set cfg gpmux: %d\n", ret);
272*18cf4fcdSTero Kristo goto err;
273*18cf4fcdSTero Kristo }
274*18cf4fcdSTero Kristo }
275*18cf4fcdSTero Kristo
276133f30d3STero Kristo ret = of_property_read_string_index(np, "firmware-name", index,
277133f30d3STero Kristo &fw_name);
278133f30d3STero Kristo if (!ret) {
279133f30d3STero Kristo ret = pru_rproc_set_firmware(rproc, fw_name);
280133f30d3STero Kristo if (ret) {
281133f30d3STero Kristo dev_err(dev, "failed to set firmware: %d\n", ret);
282133f30d3STero Kristo goto err;
283133f30d3STero Kristo }
284133f30d3STero Kristo }
285133f30d3STero Kristo
286919e8942SMD Danish Anwar return rproc;
287919e8942SMD Danish Anwar
288919e8942SMD Danish Anwar err_no_rproc_handle:
289919e8942SMD Danish Anwar rproc_put(rproc);
290919e8942SMD Danish Anwar return ERR_PTR(ret);
291133f30d3STero Kristo
292133f30d3STero Kristo err:
293133f30d3STero Kristo pru_rproc_put(rproc);
294133f30d3STero Kristo return ERR_PTR(ret);
295919e8942SMD Danish Anwar }
296919e8942SMD Danish Anwar EXPORT_SYMBOL_GPL(pru_rproc_get);
297919e8942SMD Danish Anwar
298919e8942SMD Danish Anwar /**
299919e8942SMD Danish Anwar * pru_rproc_put() - release the PRU rproc resource
300919e8942SMD Danish Anwar * @rproc: the rproc resource to release
301919e8942SMD Danish Anwar *
302919e8942SMD Danish Anwar * Releases the PRU rproc resource and makes it available to other
303919e8942SMD Danish Anwar * users.
304919e8942SMD Danish Anwar */
pru_rproc_put(struct rproc * rproc)305919e8942SMD Danish Anwar void pru_rproc_put(struct rproc *rproc)
306919e8942SMD Danish Anwar {
307919e8942SMD Danish Anwar struct pru_rproc *pru;
308919e8942SMD Danish Anwar
309919e8942SMD Danish Anwar if (IS_ERR_OR_NULL(rproc) || !is_pru_rproc(rproc->dev.parent))
310919e8942SMD Danish Anwar return;
311919e8942SMD Danish Anwar
312919e8942SMD Danish Anwar pru = rproc->priv;
313919e8942SMD Danish Anwar
314*18cf4fcdSTero Kristo pruss_cfg_set_gpmux(pru->pruss, pru->id, pru->gpmux_save);
315*18cf4fcdSTero Kristo
316133f30d3STero Kristo pru_rproc_set_firmware(rproc, NULL);
317133f30d3STero Kristo
318919e8942SMD Danish Anwar mutex_lock(&pru->lock);
319919e8942SMD Danish Anwar
320919e8942SMD Danish Anwar if (!pru->client_np) {
321919e8942SMD Danish Anwar mutex_unlock(&pru->lock);
322919e8942SMD Danish Anwar return;
323919e8942SMD Danish Anwar }
324919e8942SMD Danish Anwar
325919e8942SMD Danish Anwar pru->client_np = NULL;
3262da812ffSSuman Anna rproc->sysfs_read_only = false;
327919e8942SMD Danish Anwar mutex_unlock(&pru->lock);
328919e8942SMD Danish Anwar
329919e8942SMD Danish Anwar rproc_put(rproc);
330919e8942SMD Danish Anwar }
331919e8942SMD Danish Anwar EXPORT_SYMBOL_GPL(pru_rproc_put);
332919e8942SMD Danish Anwar
33310285340SRoger Quadros /**
33410285340SRoger Quadros * pru_rproc_set_ctable() - set the constant table index for the PRU
33510285340SRoger Quadros * @rproc: the rproc instance of the PRU
33610285340SRoger Quadros * @c: constant table index to set
33710285340SRoger Quadros * @addr: physical address to set it to
33810285340SRoger Quadros *
33910285340SRoger Quadros * Return: 0 on success, or errno in error case.
34010285340SRoger Quadros */
pru_rproc_set_ctable(struct rproc * rproc,enum pru_ctable_idx c,u32 addr)34110285340SRoger Quadros int pru_rproc_set_ctable(struct rproc *rproc, enum pru_ctable_idx c, u32 addr)
34210285340SRoger Quadros {
34310285340SRoger Quadros struct pru_rproc *pru = rproc->priv;
34410285340SRoger Quadros unsigned int reg;
34510285340SRoger Quadros u32 mask, set;
34610285340SRoger Quadros u16 idx;
34710285340SRoger Quadros u16 idx_mask;
34810285340SRoger Quadros
34910285340SRoger Quadros if (IS_ERR_OR_NULL(rproc))
35010285340SRoger Quadros return -EINVAL;
35110285340SRoger Quadros
35210285340SRoger Quadros if (!rproc->dev.parent || !is_pru_rproc(rproc->dev.parent))
35310285340SRoger Quadros return -ENODEV;
35410285340SRoger Quadros
35510285340SRoger Quadros /* pointer is 16 bit and index is 8-bit so mask out the rest */
35610285340SRoger Quadros idx_mask = (c >= PRU_C28) ? 0xFFFF : 0xFF;
35710285340SRoger Quadros
35810285340SRoger Quadros /* ctable uses bit 8 and upwards only */
35910285340SRoger Quadros idx = (addr >> 8) & idx_mask;
36010285340SRoger Quadros
36110285340SRoger Quadros /* configurable ctable (i.e. C24) starts at PRU_CTRL_CTBIR0 */
36210285340SRoger Quadros reg = PRU_CTRL_CTBIR0 + 4 * (c >> 1);
36310285340SRoger Quadros mask = idx_mask << (16 * (c & 1));
36410285340SRoger Quadros set = idx << (16 * (c & 1));
36510285340SRoger Quadros
36610285340SRoger Quadros pru_control_set_reg(pru, reg, mask, set);
36710285340SRoger Quadros
36810285340SRoger Quadros return 0;
36910285340SRoger Quadros }
37010285340SRoger Quadros EXPORT_SYMBOL_GPL(pru_rproc_set_ctable);
37110285340SRoger Quadros
pru_debug_read_reg(struct pru_rproc * pru,unsigned int reg)37220ad1de0SSuman Anna static inline u32 pru_debug_read_reg(struct pru_rproc *pru, unsigned int reg)
37320ad1de0SSuman Anna {
37420ad1de0SSuman Anna return readl_relaxed(pru->mem_regions[PRU_IOMEM_DEBUG].va + reg);
37520ad1de0SSuman Anna }
37620ad1de0SSuman Anna
regs_show(struct seq_file * s,void * data)37720ad1de0SSuman Anna static int regs_show(struct seq_file *s, void *data)
37820ad1de0SSuman Anna {
37920ad1de0SSuman Anna struct rproc *rproc = s->private;
38020ad1de0SSuman Anna struct pru_rproc *pru = rproc->priv;
38120ad1de0SSuman Anna int i, nregs = 32;
38220ad1de0SSuman Anna u32 pru_sts;
38320ad1de0SSuman Anna int pru_is_running;
38420ad1de0SSuman Anna
38520ad1de0SSuman Anna seq_puts(s, "============== Control Registers ==============\n");
38620ad1de0SSuman Anna seq_printf(s, "CTRL := 0x%08x\n",
38720ad1de0SSuman Anna pru_control_read_reg(pru, PRU_CTRL_CTRL));
38820ad1de0SSuman Anna pru_sts = pru_control_read_reg(pru, PRU_CTRL_STS);
38920ad1de0SSuman Anna seq_printf(s, "STS (PC) := 0x%08x (0x%08x)\n", pru_sts, pru_sts << 2);
39020ad1de0SSuman Anna seq_printf(s, "WAKEUP_EN := 0x%08x\n",
39120ad1de0SSuman Anna pru_control_read_reg(pru, PRU_CTRL_WAKEUP_EN));
39220ad1de0SSuman Anna seq_printf(s, "CYCLE := 0x%08x\n",
39320ad1de0SSuman Anna pru_control_read_reg(pru, PRU_CTRL_CYCLE));
39420ad1de0SSuman Anna seq_printf(s, "STALL := 0x%08x\n",
39520ad1de0SSuman Anna pru_control_read_reg(pru, PRU_CTRL_STALL));
39620ad1de0SSuman Anna seq_printf(s, "CTBIR0 := 0x%08x\n",
39720ad1de0SSuman Anna pru_control_read_reg(pru, PRU_CTRL_CTBIR0));
39820ad1de0SSuman Anna seq_printf(s, "CTBIR1 := 0x%08x\n",
39920ad1de0SSuman Anna pru_control_read_reg(pru, PRU_CTRL_CTBIR1));
40020ad1de0SSuman Anna seq_printf(s, "CTPPR0 := 0x%08x\n",
40120ad1de0SSuman Anna pru_control_read_reg(pru, PRU_CTRL_CTPPR0));
40220ad1de0SSuman Anna seq_printf(s, "CTPPR1 := 0x%08x\n",
40320ad1de0SSuman Anna pru_control_read_reg(pru, PRU_CTRL_CTPPR1));
40420ad1de0SSuman Anna
40520ad1de0SSuman Anna seq_puts(s, "=============== Debug Registers ===============\n");
40620ad1de0SSuman Anna pru_is_running = pru_control_read_reg(pru, PRU_CTRL_CTRL) &
40720ad1de0SSuman Anna CTRL_CTRL_RUNSTATE;
40820ad1de0SSuman Anna if (pru_is_running) {
40920ad1de0SSuman Anna seq_puts(s, "PRU is executing, cannot print/access debug registers.\n");
41020ad1de0SSuman Anna return 0;
41120ad1de0SSuman Anna }
41220ad1de0SSuman Anna
41320ad1de0SSuman Anna for (i = 0; i < nregs; i++) {
41420ad1de0SSuman Anna seq_printf(s, "GPREG%-2d := 0x%08x\tCT_REG%-2d := 0x%08x\n",
41520ad1de0SSuman Anna i, pru_debug_read_reg(pru, PRU_DEBUG_GPREG(i)),
41620ad1de0SSuman Anna i, pru_debug_read_reg(pru, PRU_DEBUG_CT_REG(i)));
41720ad1de0SSuman Anna }
41820ad1de0SSuman Anna
41920ad1de0SSuman Anna return 0;
42020ad1de0SSuman Anna }
42120ad1de0SSuman Anna DEFINE_SHOW_ATTRIBUTE(regs);
42220ad1de0SSuman Anna
42320ad1de0SSuman Anna /*
42420ad1de0SSuman Anna * Control PRU single-step mode
42520ad1de0SSuman Anna *
42620ad1de0SSuman Anna * This is a debug helper function used for controlling the single-step
42720ad1de0SSuman Anna * mode of the PRU. The PRU Debug registers are not accessible when the
42820ad1de0SSuman Anna * PRU is in RUNNING state.
42920ad1de0SSuman Anna *
43020ad1de0SSuman Anna * Writing a non-zero value sets the PRU into single-step mode irrespective
43120ad1de0SSuman Anna * of its previous state. The PRU mode is saved only on the first set into
43220ad1de0SSuman Anna * a single-step mode. Writing a zero value will restore the PRU into its
43320ad1de0SSuman Anna * original mode.
43420ad1de0SSuman Anna */
pru_rproc_debug_ss_set(void * data,u64 val)43520ad1de0SSuman Anna static int pru_rproc_debug_ss_set(void *data, u64 val)
43620ad1de0SSuman Anna {
43720ad1de0SSuman Anna struct rproc *rproc = data;
43820ad1de0SSuman Anna struct pru_rproc *pru = rproc->priv;
43920ad1de0SSuman Anna u32 reg_val;
44020ad1de0SSuman Anna
44120ad1de0SSuman Anna val = val ? 1 : 0;
44220ad1de0SSuman Anna if (!val && !pru->dbg_single_step)
44320ad1de0SSuman Anna return 0;
44420ad1de0SSuman Anna
44520ad1de0SSuman Anna reg_val = pru_control_read_reg(pru, PRU_CTRL_CTRL);
44620ad1de0SSuman Anna
44720ad1de0SSuman Anna if (val && !pru->dbg_single_step)
44820ad1de0SSuman Anna pru->dbg_continuous = reg_val;
44920ad1de0SSuman Anna
45020ad1de0SSuman Anna if (val)
45120ad1de0SSuman Anna reg_val |= CTRL_CTRL_SINGLE_STEP | CTRL_CTRL_EN;
45220ad1de0SSuman Anna else
45320ad1de0SSuman Anna reg_val = pru->dbg_continuous;
45420ad1de0SSuman Anna
45520ad1de0SSuman Anna pru->dbg_single_step = val;
45620ad1de0SSuman Anna pru_control_write_reg(pru, PRU_CTRL_CTRL, reg_val);
45720ad1de0SSuman Anna
45820ad1de0SSuman Anna return 0;
45920ad1de0SSuman Anna }
46020ad1de0SSuman Anna
pru_rproc_debug_ss_get(void * data,u64 * val)46120ad1de0SSuman Anna static int pru_rproc_debug_ss_get(void *data, u64 *val)
46220ad1de0SSuman Anna {
46320ad1de0SSuman Anna struct rproc *rproc = data;
46420ad1de0SSuman Anna struct pru_rproc *pru = rproc->priv;
46520ad1de0SSuman Anna
46620ad1de0SSuman Anna *val = pru->dbg_single_step;
46720ad1de0SSuman Anna
46820ad1de0SSuman Anna return 0;
46920ad1de0SSuman Anna }
470780a980eSYang Li DEFINE_DEBUGFS_ATTRIBUTE(pru_rproc_debug_ss_fops, pru_rproc_debug_ss_get,
47120ad1de0SSuman Anna pru_rproc_debug_ss_set, "%llu\n");
47220ad1de0SSuman Anna
47320ad1de0SSuman Anna /*
47420ad1de0SSuman Anna * Create PRU-specific debugfs entries
47520ad1de0SSuman Anna *
47620ad1de0SSuman Anna * The entries are created only if the parent remoteproc debugfs directory
47720ad1de0SSuman Anna * exists, and will be cleaned up by the remoteproc core.
47820ad1de0SSuman Anna */
pru_rproc_create_debug_entries(struct rproc * rproc)47920ad1de0SSuman Anna static void pru_rproc_create_debug_entries(struct rproc *rproc)
48020ad1de0SSuman Anna {
48120ad1de0SSuman Anna if (!rproc->dbg_dir)
48220ad1de0SSuman Anna return;
48320ad1de0SSuman Anna
48420ad1de0SSuman Anna debugfs_create_file("regs", 0400, rproc->dbg_dir,
48520ad1de0SSuman Anna rproc, ®s_fops);
48620ad1de0SSuman Anna debugfs_create_file("single_step", 0600, rproc->dbg_dir,
48720ad1de0SSuman Anna rproc, &pru_rproc_debug_ss_fops);
48820ad1de0SSuman Anna }
48920ad1de0SSuman Anna
pru_dispose_irq_mapping(struct pru_rproc * pru)490c75c9fdaSGrzegorz Jaszczyk static void pru_dispose_irq_mapping(struct pru_rproc *pru)
491c75c9fdaSGrzegorz Jaszczyk {
492880a66e0SSuman Anna if (!pru->mapped_irq)
493880a66e0SSuman Anna return;
494880a66e0SSuman Anna
495880a66e0SSuman Anna while (pru->evt_count) {
496880a66e0SSuman Anna pru->evt_count--;
497c75c9fdaSGrzegorz Jaszczyk if (pru->mapped_irq[pru->evt_count] > 0)
498c75c9fdaSGrzegorz Jaszczyk irq_dispose_mapping(pru->mapped_irq[pru->evt_count]);
499c75c9fdaSGrzegorz Jaszczyk }
500c75c9fdaSGrzegorz Jaszczyk
501c75c9fdaSGrzegorz Jaszczyk kfree(pru->mapped_irq);
502880a66e0SSuman Anna pru->mapped_irq = NULL;
503c75c9fdaSGrzegorz Jaszczyk }
504c75c9fdaSGrzegorz Jaszczyk
505c75c9fdaSGrzegorz Jaszczyk /*
506c75c9fdaSGrzegorz Jaszczyk * Parse the custom PRU interrupt map resource and configure the INTC
507c75c9fdaSGrzegorz Jaszczyk * appropriately.
508c75c9fdaSGrzegorz Jaszczyk */
pru_handle_intrmap(struct rproc * rproc)509c75c9fdaSGrzegorz Jaszczyk static int pru_handle_intrmap(struct rproc *rproc)
510c75c9fdaSGrzegorz Jaszczyk {
511c75c9fdaSGrzegorz Jaszczyk struct device *dev = rproc->dev.parent;
512c75c9fdaSGrzegorz Jaszczyk struct pru_rproc *pru = rproc->priv;
513c75c9fdaSGrzegorz Jaszczyk struct pru_irq_rsc *rsc = pru->pru_interrupt_map;
514c75c9fdaSGrzegorz Jaszczyk struct irq_fwspec fwspec;
5156d1f2803SSuman Anna struct device_node *parent, *irq_parent;
516c75c9fdaSGrzegorz Jaszczyk int i, ret = 0;
517c75c9fdaSGrzegorz Jaszczyk
518c75c9fdaSGrzegorz Jaszczyk /* not having pru_interrupt_map is not an error */
519c75c9fdaSGrzegorz Jaszczyk if (!rsc)
520c75c9fdaSGrzegorz Jaszczyk return 0;
521c75c9fdaSGrzegorz Jaszczyk
522c75c9fdaSGrzegorz Jaszczyk /* currently supporting only type 0 */
523c75c9fdaSGrzegorz Jaszczyk if (rsc->type != 0) {
524c75c9fdaSGrzegorz Jaszczyk dev_err(dev, "unsupported rsc type: %d\n", rsc->type);
525c75c9fdaSGrzegorz Jaszczyk return -EINVAL;
526c75c9fdaSGrzegorz Jaszczyk }
527c75c9fdaSGrzegorz Jaszczyk
528c75c9fdaSGrzegorz Jaszczyk if (rsc->num_evts > MAX_PRU_SYS_EVENTS)
529c75c9fdaSGrzegorz Jaszczyk return -EINVAL;
530c75c9fdaSGrzegorz Jaszczyk
531c75c9fdaSGrzegorz Jaszczyk if (sizeof(*rsc) + rsc->num_evts * sizeof(struct pruss_int_map) !=
532c75c9fdaSGrzegorz Jaszczyk pru->pru_interrupt_map_sz)
533c75c9fdaSGrzegorz Jaszczyk return -EINVAL;
534c75c9fdaSGrzegorz Jaszczyk
535c75c9fdaSGrzegorz Jaszczyk pru->evt_count = rsc->num_evts;
536c75c9fdaSGrzegorz Jaszczyk pru->mapped_irq = kcalloc(pru->evt_count, sizeof(unsigned int),
537c75c9fdaSGrzegorz Jaszczyk GFP_KERNEL);
538880a66e0SSuman Anna if (!pru->mapped_irq) {
539880a66e0SSuman Anna pru->evt_count = 0;
540c75c9fdaSGrzegorz Jaszczyk return -ENOMEM;
541880a66e0SSuman Anna }
542c75c9fdaSGrzegorz Jaszczyk
543c75c9fdaSGrzegorz Jaszczyk /*
544c75c9fdaSGrzegorz Jaszczyk * parse and fill in system event to interrupt channel and
5456d1f2803SSuman Anna * channel-to-host mapping. The interrupt controller to be used
5466d1f2803SSuman Anna * for these mappings for a given PRU remoteproc is always its
5476d1f2803SSuman Anna * corresponding sibling PRUSS INTC node.
548c75c9fdaSGrzegorz Jaszczyk */
5496d1f2803SSuman Anna parent = of_get_parent(dev_of_node(pru->dev));
550880a66e0SSuman Anna if (!parent) {
551880a66e0SSuman Anna kfree(pru->mapped_irq);
552880a66e0SSuman Anna pru->mapped_irq = NULL;
553880a66e0SSuman Anna pru->evt_count = 0;
5546d1f2803SSuman Anna return -ENODEV;
555880a66e0SSuman Anna }
5566d1f2803SSuman Anna
5576d1f2803SSuman Anna irq_parent = of_get_child_by_name(parent, "interrupt-controller");
5586d1f2803SSuman Anna of_node_put(parent);
559c75c9fdaSGrzegorz Jaszczyk if (!irq_parent) {
560c75c9fdaSGrzegorz Jaszczyk kfree(pru->mapped_irq);
561880a66e0SSuman Anna pru->mapped_irq = NULL;
562880a66e0SSuman Anna pru->evt_count = 0;
563c75c9fdaSGrzegorz Jaszczyk return -ENODEV;
564c75c9fdaSGrzegorz Jaszczyk }
565c75c9fdaSGrzegorz Jaszczyk
566c75c9fdaSGrzegorz Jaszczyk fwspec.fwnode = of_node_to_fwnode(irq_parent);
567c75c9fdaSGrzegorz Jaszczyk fwspec.param_count = 3;
568c75c9fdaSGrzegorz Jaszczyk for (i = 0; i < pru->evt_count; i++) {
569c75c9fdaSGrzegorz Jaszczyk fwspec.param[0] = rsc->pru_intc_map[i].event;
570c75c9fdaSGrzegorz Jaszczyk fwspec.param[1] = rsc->pru_intc_map[i].chnl;
571c75c9fdaSGrzegorz Jaszczyk fwspec.param[2] = rsc->pru_intc_map[i].host;
572c75c9fdaSGrzegorz Jaszczyk
573c75c9fdaSGrzegorz Jaszczyk dev_dbg(dev, "mapping%d: event %d, chnl %d, host %d\n",
574c75c9fdaSGrzegorz Jaszczyk i, fwspec.param[0], fwspec.param[1], fwspec.param[2]);
575c75c9fdaSGrzegorz Jaszczyk
576c75c9fdaSGrzegorz Jaszczyk pru->mapped_irq[i] = irq_create_fwspec_mapping(&fwspec);
577c75c9fdaSGrzegorz Jaszczyk if (!pru->mapped_irq[i]) {
5781fe72bcfSSuman Anna dev_err(dev, "failed to get virq for fw mapping %d: event %d chnl %d host %d\n",
5791fe72bcfSSuman Anna i, fwspec.param[0], fwspec.param[1],
5801fe72bcfSSuman Anna fwspec.param[2]);
5811fe72bcfSSuman Anna ret = -EINVAL;
582c75c9fdaSGrzegorz Jaszczyk goto map_fail;
583c75c9fdaSGrzegorz Jaszczyk }
584c75c9fdaSGrzegorz Jaszczyk }
5856d1f2803SSuman Anna of_node_put(irq_parent);
586c75c9fdaSGrzegorz Jaszczyk
587c75c9fdaSGrzegorz Jaszczyk return ret;
588c75c9fdaSGrzegorz Jaszczyk
589c75c9fdaSGrzegorz Jaszczyk map_fail:
590c75c9fdaSGrzegorz Jaszczyk pru_dispose_irq_mapping(pru);
5916d1f2803SSuman Anna of_node_put(irq_parent);
592c75c9fdaSGrzegorz Jaszczyk
593c75c9fdaSGrzegorz Jaszczyk return ret;
594c75c9fdaSGrzegorz Jaszczyk }
595c75c9fdaSGrzegorz Jaszczyk
pru_rproc_start(struct rproc * rproc)596d4ce2de7SSuman Anna static int pru_rproc_start(struct rproc *rproc)
597d4ce2de7SSuman Anna {
598d4ce2de7SSuman Anna struct device *dev = &rproc->dev;
599d4ce2de7SSuman Anna struct pru_rproc *pru = rproc->priv;
6001d39f4d1SSuman Anna const char *names[PRU_TYPE_MAX] = { "PRU", "RTU", "Tx_PRU" };
601d4ce2de7SSuman Anna u32 val;
602c75c9fdaSGrzegorz Jaszczyk int ret;
603d4ce2de7SSuman Anna
6041d39f4d1SSuman Anna dev_dbg(dev, "starting %s%d: entry-point = 0x%llx\n",
6051d39f4d1SSuman Anna names[pru->data->type], pru->id, (rproc->bootaddr >> 2));
606d4ce2de7SSuman Anna
607c75c9fdaSGrzegorz Jaszczyk ret = pru_handle_intrmap(rproc);
608c75c9fdaSGrzegorz Jaszczyk /*
609c75c9fdaSGrzegorz Jaszczyk * reset references to pru interrupt map - they will stop being valid
610c75c9fdaSGrzegorz Jaszczyk * after rproc_start returns
611c75c9fdaSGrzegorz Jaszczyk */
612c75c9fdaSGrzegorz Jaszczyk pru->pru_interrupt_map = NULL;
613c75c9fdaSGrzegorz Jaszczyk pru->pru_interrupt_map_sz = 0;
614c75c9fdaSGrzegorz Jaszczyk if (ret)
615c75c9fdaSGrzegorz Jaszczyk return ret;
616c75c9fdaSGrzegorz Jaszczyk
617d4ce2de7SSuman Anna val = CTRL_CTRL_EN | ((rproc->bootaddr >> 2) << 16);
618d4ce2de7SSuman Anna pru_control_write_reg(pru, PRU_CTRL_CTRL, val);
619d4ce2de7SSuman Anna
620d4ce2de7SSuman Anna return 0;
621d4ce2de7SSuman Anna }
622d4ce2de7SSuman Anna
pru_rproc_stop(struct rproc * rproc)623d4ce2de7SSuman Anna static int pru_rproc_stop(struct rproc *rproc)
624d4ce2de7SSuman Anna {
625d4ce2de7SSuman Anna struct device *dev = &rproc->dev;
626d4ce2de7SSuman Anna struct pru_rproc *pru = rproc->priv;
6271d39f4d1SSuman Anna const char *names[PRU_TYPE_MAX] = { "PRU", "RTU", "Tx_PRU" };
628d4ce2de7SSuman Anna u32 val;
629d4ce2de7SSuman Anna
6301d39f4d1SSuman Anna dev_dbg(dev, "stopping %s%d\n", names[pru->data->type], pru->id);
631d4ce2de7SSuman Anna
632d4ce2de7SSuman Anna val = pru_control_read_reg(pru, PRU_CTRL_CTRL);
633d4ce2de7SSuman Anna val &= ~CTRL_CTRL_EN;
634d4ce2de7SSuman Anna pru_control_write_reg(pru, PRU_CTRL_CTRL, val);
635d4ce2de7SSuman Anna
636c75c9fdaSGrzegorz Jaszczyk /* dispose irq mapping - new firmware can provide new mapping */
637c75c9fdaSGrzegorz Jaszczyk pru_dispose_irq_mapping(pru);
638c75c9fdaSGrzegorz Jaszczyk
639d4ce2de7SSuman Anna return 0;
640d4ce2de7SSuman Anna }
641d4ce2de7SSuman Anna
642d4ce2de7SSuman Anna /*
643d4ce2de7SSuman Anna * Convert PRU device address (data spaces only) to kernel virtual address.
644d4ce2de7SSuman Anna *
645d4ce2de7SSuman Anna * Each PRU has access to all data memories within the PRUSS, accessible at
646d4ce2de7SSuman Anna * different ranges. So, look through both its primary and secondary Data
647d4ce2de7SSuman Anna * RAMs as well as any shared Data RAM to convert a PRU device address to
648d4ce2de7SSuman Anna * kernel virtual address. Data RAM0 is primary Data RAM for PRU0 and Data
649d4ce2de7SSuman Anna * RAM1 is primary Data RAM for PRU1.
650d4ce2de7SSuman Anna */
pru_d_da_to_va(struct pru_rproc * pru,u32 da,size_t len)651d4ce2de7SSuman Anna static void *pru_d_da_to_va(struct pru_rproc *pru, u32 da, size_t len)
652d4ce2de7SSuman Anna {
653d4ce2de7SSuman Anna struct pruss_mem_region dram0, dram1, shrd_ram;
654d4ce2de7SSuman Anna struct pruss *pruss = pru->pruss;
655d4ce2de7SSuman Anna u32 offset;
656d4ce2de7SSuman Anna void *va = NULL;
657d4ce2de7SSuman Anna
658d4ce2de7SSuman Anna if (len == 0)
659d4ce2de7SSuman Anna return NULL;
660d4ce2de7SSuman Anna
661d4ce2de7SSuman Anna dram0 = pruss->mem_regions[PRUSS_MEM_DRAM0];
662d4ce2de7SSuman Anna dram1 = pruss->mem_regions[PRUSS_MEM_DRAM1];
663d4ce2de7SSuman Anna /* PRU1 has its local RAM addresses reversed */
6649b9ad70fSMD Danish Anwar if (pru->id == PRUSS_PRU1)
665d4ce2de7SSuman Anna swap(dram0, dram1);
666d4ce2de7SSuman Anna shrd_ram = pruss->mem_regions[PRUSS_MEM_SHRD_RAM2];
667d4ce2de7SSuman Anna
6683a87fc6fSSimon Horman if (da + len <= PRU_PDRAM_DA + dram0.size) {
669d4ce2de7SSuman Anna offset = da - PRU_PDRAM_DA;
670d4ce2de7SSuman Anna va = (__force void *)(dram0.va + offset);
671d4ce2de7SSuman Anna } else if (da >= PRU_SDRAM_DA &&
672d4ce2de7SSuman Anna da + len <= PRU_SDRAM_DA + dram1.size) {
673d4ce2de7SSuman Anna offset = da - PRU_SDRAM_DA;
674d4ce2de7SSuman Anna va = (__force void *)(dram1.va + offset);
675d4ce2de7SSuman Anna } else if (da >= PRU_SHRDRAM_DA &&
676d4ce2de7SSuman Anna da + len <= PRU_SHRDRAM_DA + shrd_ram.size) {
677d4ce2de7SSuman Anna offset = da - PRU_SHRDRAM_DA;
678d4ce2de7SSuman Anna va = (__force void *)(shrd_ram.va + offset);
679d4ce2de7SSuman Anna }
680d4ce2de7SSuman Anna
681d4ce2de7SSuman Anna return va;
682d4ce2de7SSuman Anna }
683d4ce2de7SSuman Anna
684d4ce2de7SSuman Anna /*
685d4ce2de7SSuman Anna * Convert PRU device address (instruction space) to kernel virtual address.
686d4ce2de7SSuman Anna *
687d4ce2de7SSuman Anna * A PRU does not have an unified address space. Each PRU has its very own
688d4ce2de7SSuman Anna * private Instruction RAM, and its device address is identical to that of
689d4ce2de7SSuman Anna * its primary Data RAM device address.
690d4ce2de7SSuman Anna */
pru_i_da_to_va(struct pru_rproc * pru,u32 da,size_t len)691d4ce2de7SSuman Anna static void *pru_i_da_to_va(struct pru_rproc *pru, u32 da, size_t len)
692d4ce2de7SSuman Anna {
693d4ce2de7SSuman Anna u32 offset;
694d4ce2de7SSuman Anna void *va = NULL;
695d4ce2de7SSuman Anna
696d4ce2de7SSuman Anna if (len == 0)
697d4ce2de7SSuman Anna return NULL;
698d4ce2de7SSuman Anna
699e6d9423dSDimitar Dimitrov /*
700e6d9423dSDimitar Dimitrov * GNU binutils do not support multiple address spaces. The GNU
701e6d9423dSDimitar Dimitrov * linker's default linker script places IRAM at an arbitrary high
702e6d9423dSDimitar Dimitrov * offset, in order to differentiate it from DRAM. Hence we need to
703e6d9423dSDimitar Dimitrov * strip the artificial offset in the IRAM addresses coming from the
704e6d9423dSDimitar Dimitrov * ELF file.
705e6d9423dSDimitar Dimitrov *
706e6d9423dSDimitar Dimitrov * The TI proprietary linker would never set those higher IRAM address
707e6d9423dSDimitar Dimitrov * bits anyway. PRU architecture limits the program counter to 16-bit
708e6d9423dSDimitar Dimitrov * word-address range. This in turn corresponds to 18-bit IRAM
709e6d9423dSDimitar Dimitrov * byte-address range for ELF.
710e6d9423dSDimitar Dimitrov *
711e6d9423dSDimitar Dimitrov * Two more bits are added just in case to make the final 20-bit mask.
712e6d9423dSDimitar Dimitrov * Idea is to have a safeguard in case TI decides to add banking
713e6d9423dSDimitar Dimitrov * in future SoCs.
714e6d9423dSDimitar Dimitrov */
715e6d9423dSDimitar Dimitrov da &= 0xfffff;
716e6d9423dSDimitar Dimitrov
7173a87fc6fSSimon Horman if (da + len <= PRU_IRAM_DA + pru->mem_regions[PRU_IOMEM_IRAM].size) {
718d4ce2de7SSuman Anna offset = da - PRU_IRAM_DA;
719d4ce2de7SSuman Anna va = (__force void *)(pru->mem_regions[PRU_IOMEM_IRAM].va +
720d4ce2de7SSuman Anna offset);
721d4ce2de7SSuman Anna }
722d4ce2de7SSuman Anna
723d4ce2de7SSuman Anna return va;
724d4ce2de7SSuman Anna }
725d4ce2de7SSuman Anna
726d4ce2de7SSuman Anna /*
727d4ce2de7SSuman Anna * Provide address translations for only PRU Data RAMs through the remoteproc
728d4ce2de7SSuman Anna * core for any PRU client drivers. The PRU Instruction RAM access is restricted
729d4ce2de7SSuman Anna * only to the PRU loader code.
730d4ce2de7SSuman Anna */
pru_rproc_da_to_va(struct rproc * rproc,u64 da,size_t len,bool * is_iomem)73140df0a91SPeng Fan static void *pru_rproc_da_to_va(struct rproc *rproc, u64 da, size_t len, bool *is_iomem)
732d4ce2de7SSuman Anna {
733d4ce2de7SSuman Anna struct pru_rproc *pru = rproc->priv;
734d4ce2de7SSuman Anna
735d4ce2de7SSuman Anna return pru_d_da_to_va(pru, da, len);
736d4ce2de7SSuman Anna }
737d4ce2de7SSuman Anna
738d4ce2de7SSuman Anna /* PRU-specific address translator used by PRU loader. */
pru_da_to_va(struct rproc * rproc,u64 da,size_t len,bool is_iram)739d4ce2de7SSuman Anna static void *pru_da_to_va(struct rproc *rproc, u64 da, size_t len, bool is_iram)
740d4ce2de7SSuman Anna {
741d4ce2de7SSuman Anna struct pru_rproc *pru = rproc->priv;
742d4ce2de7SSuman Anna void *va;
743d4ce2de7SSuman Anna
744d4ce2de7SSuman Anna if (is_iram)
745d4ce2de7SSuman Anna va = pru_i_da_to_va(pru, da, len);
746d4ce2de7SSuman Anna else
747d4ce2de7SSuman Anna va = pru_d_da_to_va(pru, da, len);
748d4ce2de7SSuman Anna
749d4ce2de7SSuman Anna return va;
750d4ce2de7SSuman Anna }
751d4ce2de7SSuman Anna
752d4ce2de7SSuman Anna static struct rproc_ops pru_rproc_ops = {
753d4ce2de7SSuman Anna .start = pru_rproc_start,
754d4ce2de7SSuman Anna .stop = pru_rproc_stop,
755d4ce2de7SSuman Anna .da_to_va = pru_rproc_da_to_va,
756d4ce2de7SSuman Anna };
757d4ce2de7SSuman Anna
7581d39f4d1SSuman Anna /*
7591d39f4d1SSuman Anna * Custom memory copy implementation for ICSSG PRU/RTU/Tx_PRU Cores
7601d39f4d1SSuman Anna *
7611d39f4d1SSuman Anna * The ICSSG PRU/RTU/Tx_PRU cores have a memory copying issue with IRAM
7621d39f4d1SSuman Anna * memories, that is not seen on previous generation SoCs. The data is reflected
7631d39f4d1SSuman Anna * properly in the IRAM memories only for integer (4-byte) copies. Any unaligned
7641d39f4d1SSuman Anna * copies result in all the other pre-existing bytes zeroed out within that
7651d39f4d1SSuman Anna * 4-byte boundary, thereby resulting in wrong text/code in the IRAMs. Also, the
7661d39f4d1SSuman Anna * IRAM memory port interface does not allow any 8-byte copies (as commonly used
7671d39f4d1SSuman Anna * by ARM64 memcpy implementation) and throws an exception. The DRAM memory
7681d39f4d1SSuman Anna * ports do not show this behavior.
7691d39f4d1SSuman Anna */
pru_rproc_memcpy(void * dest,const void * src,size_t count)7701d39f4d1SSuman Anna static int pru_rproc_memcpy(void *dest, const void *src, size_t count)
7711d39f4d1SSuman Anna {
7721d39f4d1SSuman Anna const u32 *s = src;
7731d39f4d1SSuman Anna u32 *d = dest;
7741d39f4d1SSuman Anna size_t size = count / 4;
7751d39f4d1SSuman Anna u32 *tmp_src = NULL;
7761d39f4d1SSuman Anna
7771d39f4d1SSuman Anna /*
7781d39f4d1SSuman Anna * TODO: relax limitation of 4-byte aligned dest addresses and copy
7791d39f4d1SSuman Anna * sizes
7801d39f4d1SSuman Anna */
7811d39f4d1SSuman Anna if ((long)dest % 4 || count % 4)
7821d39f4d1SSuman Anna return -EINVAL;
7831d39f4d1SSuman Anna
7841d39f4d1SSuman Anna /* src offsets in ELF firmware image can be non-aligned */
7851d39f4d1SSuman Anna if ((long)src % 4) {
7861d39f4d1SSuman Anna tmp_src = kmemdup(src, count, GFP_KERNEL);
7871d39f4d1SSuman Anna if (!tmp_src)
7881d39f4d1SSuman Anna return -ENOMEM;
7891d39f4d1SSuman Anna s = tmp_src;
7901d39f4d1SSuman Anna }
7911d39f4d1SSuman Anna
7921d39f4d1SSuman Anna while (size--)
7931d39f4d1SSuman Anna *d++ = *s++;
7941d39f4d1SSuman Anna
7951d39f4d1SSuman Anna kfree(tmp_src);
7961d39f4d1SSuman Anna
7971d39f4d1SSuman Anna return 0;
7981d39f4d1SSuman Anna }
7991d39f4d1SSuman Anna
800d4ce2de7SSuman Anna static int
pru_rproc_load_elf_segments(struct rproc * rproc,const struct firmware * fw)801d4ce2de7SSuman Anna pru_rproc_load_elf_segments(struct rproc *rproc, const struct firmware *fw)
802d4ce2de7SSuman Anna {
8031d39f4d1SSuman Anna struct pru_rproc *pru = rproc->priv;
804d4ce2de7SSuman Anna struct device *dev = &rproc->dev;
805d4ce2de7SSuman Anna struct elf32_hdr *ehdr;
806d4ce2de7SSuman Anna struct elf32_phdr *phdr;
807d4ce2de7SSuman Anna int i, ret = 0;
808d4ce2de7SSuman Anna const u8 *elf_data = fw->data;
809d4ce2de7SSuman Anna
810d4ce2de7SSuman Anna ehdr = (struct elf32_hdr *)elf_data;
811d4ce2de7SSuman Anna phdr = (struct elf32_phdr *)(elf_data + ehdr->e_phoff);
812d4ce2de7SSuman Anna
813d4ce2de7SSuman Anna /* go through the available ELF segments */
814d4ce2de7SSuman Anna for (i = 0; i < ehdr->e_phnum; i++, phdr++) {
815d4ce2de7SSuman Anna u32 da = phdr->p_paddr;
816d4ce2de7SSuman Anna u32 memsz = phdr->p_memsz;
817d4ce2de7SSuman Anna u32 filesz = phdr->p_filesz;
818d4ce2de7SSuman Anna u32 offset = phdr->p_offset;
819d4ce2de7SSuman Anna bool is_iram;
820d4ce2de7SSuman Anna void *ptr;
821d4ce2de7SSuman Anna
822d4ce2de7SSuman Anna if (phdr->p_type != PT_LOAD || !filesz)
823d4ce2de7SSuman Anna continue;
824d4ce2de7SSuman Anna
825d4ce2de7SSuman Anna dev_dbg(dev, "phdr: type %d da 0x%x memsz 0x%x filesz 0x%x\n",
826d4ce2de7SSuman Anna phdr->p_type, da, memsz, filesz);
827d4ce2de7SSuman Anna
828d4ce2de7SSuman Anna if (filesz > memsz) {
829d4ce2de7SSuman Anna dev_err(dev, "bad phdr filesz 0x%x memsz 0x%x\n",
830d4ce2de7SSuman Anna filesz, memsz);
831d4ce2de7SSuman Anna ret = -EINVAL;
832d4ce2de7SSuman Anna break;
833d4ce2de7SSuman Anna }
834d4ce2de7SSuman Anna
835d4ce2de7SSuman Anna if (offset + filesz > fw->size) {
836d4ce2de7SSuman Anna dev_err(dev, "truncated fw: need 0x%x avail 0x%zx\n",
837d4ce2de7SSuman Anna offset + filesz, fw->size);
838d4ce2de7SSuman Anna ret = -EINVAL;
839d4ce2de7SSuman Anna break;
840d4ce2de7SSuman Anna }
841d4ce2de7SSuman Anna
842d4ce2de7SSuman Anna /* grab the kernel address for this device address */
843d4ce2de7SSuman Anna is_iram = phdr->p_flags & PF_X;
844d4ce2de7SSuman Anna ptr = pru_da_to_va(rproc, da, memsz, is_iram);
845d4ce2de7SSuman Anna if (!ptr) {
846d4ce2de7SSuman Anna dev_err(dev, "bad phdr da 0x%x mem 0x%x\n", da, memsz);
847d4ce2de7SSuman Anna ret = -EINVAL;
848d4ce2de7SSuman Anna break;
849d4ce2de7SSuman Anna }
850d4ce2de7SSuman Anna
8519afeefcfSSuman Anna if (pru->data->is_k3) {
8521d39f4d1SSuman Anna ret = pru_rproc_memcpy(ptr, elf_data + phdr->p_offset,
8531d39f4d1SSuman Anna filesz);
8541d39f4d1SSuman Anna if (ret) {
8551d39f4d1SSuman Anna dev_err(dev, "PRU memory copy failed for da 0x%x memsz 0x%x\n",
8561d39f4d1SSuman Anna da, memsz);
8571d39f4d1SSuman Anna break;
8581d39f4d1SSuman Anna }
8591d39f4d1SSuman Anna } else {
860d4ce2de7SSuman Anna memcpy(ptr, elf_data + phdr->p_offset, filesz);
8611d39f4d1SSuman Anna }
862d4ce2de7SSuman Anna
863d4ce2de7SSuman Anna /* skip the memzero logic performed by remoteproc ELF loader */
864d4ce2de7SSuman Anna }
865d4ce2de7SSuman Anna
866d4ce2de7SSuman Anna return ret;
867d4ce2de7SSuman Anna }
868d4ce2de7SSuman Anna
869c75c9fdaSGrzegorz Jaszczyk static const void *
pru_rproc_find_interrupt_map(struct device * dev,const struct firmware * fw)870c75c9fdaSGrzegorz Jaszczyk pru_rproc_find_interrupt_map(struct device *dev, const struct firmware *fw)
871c75c9fdaSGrzegorz Jaszczyk {
872c75c9fdaSGrzegorz Jaszczyk struct elf32_shdr *shdr, *name_table_shdr;
873c75c9fdaSGrzegorz Jaszczyk const char *name_table;
874c75c9fdaSGrzegorz Jaszczyk const u8 *elf_data = fw->data;
875c75c9fdaSGrzegorz Jaszczyk struct elf32_hdr *ehdr = (struct elf32_hdr *)elf_data;
876c75c9fdaSGrzegorz Jaszczyk u16 shnum = ehdr->e_shnum;
877c75c9fdaSGrzegorz Jaszczyk u16 shstrndx = ehdr->e_shstrndx;
878c75c9fdaSGrzegorz Jaszczyk int i;
879c75c9fdaSGrzegorz Jaszczyk
880c75c9fdaSGrzegorz Jaszczyk /* first, get the section header */
881c75c9fdaSGrzegorz Jaszczyk shdr = (struct elf32_shdr *)(elf_data + ehdr->e_shoff);
882c75c9fdaSGrzegorz Jaszczyk /* compute name table section header entry in shdr array */
883c75c9fdaSGrzegorz Jaszczyk name_table_shdr = shdr + shstrndx;
884c75c9fdaSGrzegorz Jaszczyk /* finally, compute the name table section address in elf */
885c75c9fdaSGrzegorz Jaszczyk name_table = elf_data + name_table_shdr->sh_offset;
886c75c9fdaSGrzegorz Jaszczyk
887c75c9fdaSGrzegorz Jaszczyk for (i = 0; i < shnum; i++, shdr++) {
888c75c9fdaSGrzegorz Jaszczyk u32 size = shdr->sh_size;
889c75c9fdaSGrzegorz Jaszczyk u32 offset = shdr->sh_offset;
890c75c9fdaSGrzegorz Jaszczyk u32 name = shdr->sh_name;
891c75c9fdaSGrzegorz Jaszczyk
892c75c9fdaSGrzegorz Jaszczyk if (strcmp(name_table + name, ".pru_irq_map"))
893c75c9fdaSGrzegorz Jaszczyk continue;
894c75c9fdaSGrzegorz Jaszczyk
895c75c9fdaSGrzegorz Jaszczyk /* make sure we have the entire irq map */
896c75c9fdaSGrzegorz Jaszczyk if (offset + size > fw->size || offset + size < size) {
897c75c9fdaSGrzegorz Jaszczyk dev_err(dev, ".pru_irq_map section truncated\n");
898c75c9fdaSGrzegorz Jaszczyk return ERR_PTR(-EINVAL);
899c75c9fdaSGrzegorz Jaszczyk }
900c75c9fdaSGrzegorz Jaszczyk
901c75c9fdaSGrzegorz Jaszczyk /* make sure irq map has at least the header */
902c75c9fdaSGrzegorz Jaszczyk if (sizeof(struct pru_irq_rsc) > size) {
903c75c9fdaSGrzegorz Jaszczyk dev_err(dev, "header-less .pru_irq_map section\n");
904c75c9fdaSGrzegorz Jaszczyk return ERR_PTR(-EINVAL);
905c75c9fdaSGrzegorz Jaszczyk }
906c75c9fdaSGrzegorz Jaszczyk
907c75c9fdaSGrzegorz Jaszczyk return shdr;
908c75c9fdaSGrzegorz Jaszczyk }
909c75c9fdaSGrzegorz Jaszczyk
910c75c9fdaSGrzegorz Jaszczyk dev_dbg(dev, "no .pru_irq_map section found for this fw\n");
911c75c9fdaSGrzegorz Jaszczyk
912c75c9fdaSGrzegorz Jaszczyk return NULL;
913c75c9fdaSGrzegorz Jaszczyk }
914c75c9fdaSGrzegorz Jaszczyk
915d4ce2de7SSuman Anna /*
916d4ce2de7SSuman Anna * Use a custom parse_fw callback function for dealing with PRU firmware
917d4ce2de7SSuman Anna * specific sections.
918c75c9fdaSGrzegorz Jaszczyk *
919c75c9fdaSGrzegorz Jaszczyk * The firmware blob can contain optional ELF sections: .resource_table section
920c75c9fdaSGrzegorz Jaszczyk * and .pru_irq_map one. The second one contains the PRUSS interrupt mapping
921c75c9fdaSGrzegorz Jaszczyk * description, which needs to be setup before powering on the PRU core. To
922c75c9fdaSGrzegorz Jaszczyk * avoid RAM wastage this ELF section is not mapped to any ELF segment (by the
923c75c9fdaSGrzegorz Jaszczyk * firmware linker) and therefore is not loaded to PRU memory.
924d4ce2de7SSuman Anna */
pru_rproc_parse_fw(struct rproc * rproc,const struct firmware * fw)925d4ce2de7SSuman Anna static int pru_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw)
926d4ce2de7SSuman Anna {
927c75c9fdaSGrzegorz Jaszczyk struct device *dev = &rproc->dev;
928c75c9fdaSGrzegorz Jaszczyk struct pru_rproc *pru = rproc->priv;
929c75c9fdaSGrzegorz Jaszczyk const u8 *elf_data = fw->data;
930c75c9fdaSGrzegorz Jaszczyk const void *shdr;
931c75c9fdaSGrzegorz Jaszczyk u8 class = fw_elf_get_class(fw);
932c75c9fdaSGrzegorz Jaszczyk u64 sh_offset;
933d4ce2de7SSuman Anna int ret;
934d4ce2de7SSuman Anna
935d4ce2de7SSuman Anna /* load optional rsc table */
936d4ce2de7SSuman Anna ret = rproc_elf_load_rsc_table(rproc, fw);
937d4ce2de7SSuman Anna if (ret == -EINVAL)
938d4ce2de7SSuman Anna dev_dbg(&rproc->dev, "no resource table found for this fw\n");
939d4ce2de7SSuman Anna else if (ret)
940d4ce2de7SSuman Anna return ret;
941d4ce2de7SSuman Anna
942c75c9fdaSGrzegorz Jaszczyk /* find .pru_interrupt_map section, not having it is not an error */
943c75c9fdaSGrzegorz Jaszczyk shdr = pru_rproc_find_interrupt_map(dev, fw);
944c75c9fdaSGrzegorz Jaszczyk if (IS_ERR(shdr))
945c75c9fdaSGrzegorz Jaszczyk return PTR_ERR(shdr);
946c75c9fdaSGrzegorz Jaszczyk
947c75c9fdaSGrzegorz Jaszczyk if (!shdr)
948c75c9fdaSGrzegorz Jaszczyk return 0;
949c75c9fdaSGrzegorz Jaszczyk
950c75c9fdaSGrzegorz Jaszczyk /* preserve pointer to PRU interrupt map together with it size */
951c75c9fdaSGrzegorz Jaszczyk sh_offset = elf_shdr_get_sh_offset(class, shdr);
952c75c9fdaSGrzegorz Jaszczyk pru->pru_interrupt_map = (struct pru_irq_rsc *)(elf_data + sh_offset);
953c75c9fdaSGrzegorz Jaszczyk pru->pru_interrupt_map_sz = elf_shdr_get_sh_size(class, shdr);
954c75c9fdaSGrzegorz Jaszczyk
955d4ce2de7SSuman Anna return 0;
956d4ce2de7SSuman Anna }
957d4ce2de7SSuman Anna
958d4ce2de7SSuman Anna /*
959d4ce2de7SSuman Anna * Compute PRU id based on the IRAM addresses. The PRU IRAMs are
960d4ce2de7SSuman Anna * always at a particular offset within the PRUSS address space.
961d4ce2de7SSuman Anna */
pru_rproc_set_id(struct pru_rproc * pru)962d4ce2de7SSuman Anna static int pru_rproc_set_id(struct pru_rproc *pru)
963d4ce2de7SSuman Anna {
964d4ce2de7SSuman Anna int ret = 0;
965d4ce2de7SSuman Anna
966d4ce2de7SSuman Anna switch (pru->mem_regions[PRU_IOMEM_IRAM].pa & PRU_IRAM_ADDR_MASK) {
9671d39f4d1SSuman Anna case TX_PRU0_IRAM_ADDR_MASK:
9681d39f4d1SSuman Anna fallthrough;
9691d39f4d1SSuman Anna case RTU0_IRAM_ADDR_MASK:
9701d39f4d1SSuman Anna fallthrough;
971d4ce2de7SSuman Anna case PRU0_IRAM_ADDR_MASK:
9729b9ad70fSMD Danish Anwar pru->id = PRUSS_PRU0;
973d4ce2de7SSuman Anna break;
9741d39f4d1SSuman Anna case TX_PRU1_IRAM_ADDR_MASK:
9751d39f4d1SSuman Anna fallthrough;
9761d39f4d1SSuman Anna case RTU1_IRAM_ADDR_MASK:
9771d39f4d1SSuman Anna fallthrough;
978d4ce2de7SSuman Anna case PRU1_IRAM_ADDR_MASK:
9799b9ad70fSMD Danish Anwar pru->id = PRUSS_PRU1;
980d4ce2de7SSuman Anna break;
981d4ce2de7SSuman Anna default:
982d4ce2de7SSuman Anna ret = -EINVAL;
983d4ce2de7SSuman Anna }
984d4ce2de7SSuman Anna
985d4ce2de7SSuman Anna return ret;
986d4ce2de7SSuman Anna }
987d4ce2de7SSuman Anna
pru_rproc_probe(struct platform_device * pdev)988d4ce2de7SSuman Anna static int pru_rproc_probe(struct platform_device *pdev)
989d4ce2de7SSuman Anna {
990d4ce2de7SSuman Anna struct device *dev = &pdev->dev;
991d4ce2de7SSuman Anna struct device_node *np = dev->of_node;
992d4ce2de7SSuman Anna struct platform_device *ppdev = to_platform_device(dev->parent);
993d4ce2de7SSuman Anna struct pru_rproc *pru;
994d4ce2de7SSuman Anna const char *fw_name;
995d4ce2de7SSuman Anna struct rproc *rproc = NULL;
996d4ce2de7SSuman Anna struct resource *res;
997d4ce2de7SSuman Anna int i, ret;
9981d39f4d1SSuman Anna const struct pru_private_data *data;
999d4ce2de7SSuman Anna const char *mem_names[PRU_IOMEM_MAX] = { "iram", "control", "debug" };
1000d4ce2de7SSuman Anna
10011d39f4d1SSuman Anna data = of_device_get_match_data(&pdev->dev);
10021d39f4d1SSuman Anna if (!data)
10031d39f4d1SSuman Anna return -ENODEV;
10041d39f4d1SSuman Anna
1005d4ce2de7SSuman Anna ret = of_property_read_string(np, "firmware-name", &fw_name);
1006d4ce2de7SSuman Anna if (ret) {
1007d4ce2de7SSuman Anna dev_err(dev, "unable to retrieve firmware-name %d\n", ret);
1008d4ce2de7SSuman Anna return ret;
1009d4ce2de7SSuman Anna }
1010d4ce2de7SSuman Anna
1011d4ce2de7SSuman Anna rproc = devm_rproc_alloc(dev, pdev->name, &pru_rproc_ops, fw_name,
1012d4ce2de7SSuman Anna sizeof(*pru));
1013d4ce2de7SSuman Anna if (!rproc) {
1014d4ce2de7SSuman Anna dev_err(dev, "rproc_alloc failed\n");
1015d4ce2de7SSuman Anna return -ENOMEM;
1016d4ce2de7SSuman Anna }
1017d4ce2de7SSuman Anna /* use a custom load function to deal with PRU-specific quirks */
1018d4ce2de7SSuman Anna rproc->ops->load = pru_rproc_load_elf_segments;
1019d4ce2de7SSuman Anna
1020d4ce2de7SSuman Anna /* use a custom parse function to deal with PRU-specific resources */
1021d4ce2de7SSuman Anna rproc->ops->parse_fw = pru_rproc_parse_fw;
1022d4ce2de7SSuman Anna
1023d4ce2de7SSuman Anna /* error recovery is not supported for PRUs */
1024d4ce2de7SSuman Anna rproc->recovery_disabled = true;
1025d4ce2de7SSuman Anna
1026d4ce2de7SSuman Anna /*
1027d4ce2de7SSuman Anna * rproc_add will auto-boot the processor normally, but this is not
1028d4ce2de7SSuman Anna * desired with PRU client driven boot-flow methodology. A PRU
1029d4ce2de7SSuman Anna * application/client driver will boot the corresponding PRU
1030d4ce2de7SSuman Anna * remote-processor as part of its state machine either through the
1031d4ce2de7SSuman Anna * remoteproc sysfs interface or through the equivalent kernel API.
1032d4ce2de7SSuman Anna */
1033d4ce2de7SSuman Anna rproc->auto_boot = false;
1034d4ce2de7SSuman Anna
1035d4ce2de7SSuman Anna pru = rproc->priv;
1036d4ce2de7SSuman Anna pru->dev = dev;
10371d39f4d1SSuman Anna pru->data = data;
1038d4ce2de7SSuman Anna pru->pruss = platform_get_drvdata(ppdev);
1039d4ce2de7SSuman Anna pru->rproc = rproc;
1040d4ce2de7SSuman Anna pru->fw_name = fw_name;
1041919e8942SMD Danish Anwar pru->client_np = NULL;
104210285340SRoger Quadros spin_lock_init(&pru->rmw_lock);
1043919e8942SMD Danish Anwar mutex_init(&pru->lock);
1044d4ce2de7SSuman Anna
1045d4ce2de7SSuman Anna for (i = 0; i < ARRAY_SIZE(mem_names); i++) {
1046d4ce2de7SSuman Anna res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
1047d4ce2de7SSuman Anna mem_names[i]);
1048d4ce2de7SSuman Anna pru->mem_regions[i].va = devm_ioremap_resource(dev, res);
1049d4ce2de7SSuman Anna if (IS_ERR(pru->mem_regions[i].va)) {
1050d4ce2de7SSuman Anna dev_err(dev, "failed to parse and map memory resource %d %s\n",
1051d4ce2de7SSuman Anna i, mem_names[i]);
1052d4ce2de7SSuman Anna ret = PTR_ERR(pru->mem_regions[i].va);
1053d4ce2de7SSuman Anna return ret;
1054d4ce2de7SSuman Anna }
1055d4ce2de7SSuman Anna pru->mem_regions[i].pa = res->start;
1056d4ce2de7SSuman Anna pru->mem_regions[i].size = resource_size(res);
1057d4ce2de7SSuman Anna
1058d4ce2de7SSuman Anna dev_dbg(dev, "memory %8s: pa %pa size 0x%zx va %pK\n",
1059d4ce2de7SSuman Anna mem_names[i], &pru->mem_regions[i].pa,
1060d4ce2de7SSuman Anna pru->mem_regions[i].size, pru->mem_regions[i].va);
1061d4ce2de7SSuman Anna }
1062d4ce2de7SSuman Anna
1063d4ce2de7SSuman Anna ret = pru_rproc_set_id(pru);
1064d4ce2de7SSuman Anna if (ret < 0)
1065d4ce2de7SSuman Anna return ret;
1066d4ce2de7SSuman Anna
1067d4ce2de7SSuman Anna platform_set_drvdata(pdev, rproc);
1068d4ce2de7SSuman Anna
1069d4ce2de7SSuman Anna ret = devm_rproc_add(dev, pru->rproc);
1070d4ce2de7SSuman Anna if (ret) {
1071d4ce2de7SSuman Anna dev_err(dev, "rproc_add failed: %d\n", ret);
1072d4ce2de7SSuman Anna return ret;
1073d4ce2de7SSuman Anna }
1074d4ce2de7SSuman Anna
107520ad1de0SSuman Anna pru_rproc_create_debug_entries(rproc);
107620ad1de0SSuman Anna
1077d4ce2de7SSuman Anna dev_dbg(dev, "PRU rproc node %pOF probed successfully\n", np);
1078d4ce2de7SSuman Anna
1079d4ce2de7SSuman Anna return 0;
1080d4ce2de7SSuman Anna }
1081d4ce2de7SSuman Anna
pru_rproc_remove(struct platform_device * pdev)1082d6b862fdSUwe Kleine-König static void pru_rproc_remove(struct platform_device *pdev)
1083d4ce2de7SSuman Anna {
1084d4ce2de7SSuman Anna struct device *dev = &pdev->dev;
1085d4ce2de7SSuman Anna struct rproc *rproc = platform_get_drvdata(pdev);
1086d4ce2de7SSuman Anna
1087d4ce2de7SSuman Anna dev_dbg(dev, "%s: removing rproc %s\n", __func__, rproc->name);
1088d4ce2de7SSuman Anna }
1089d4ce2de7SSuman Anna
10901d39f4d1SSuman Anna static const struct pru_private_data pru_data = {
10911d39f4d1SSuman Anna .type = PRU_TYPE_PRU,
10921d39f4d1SSuman Anna };
10931d39f4d1SSuman Anna
10941d39f4d1SSuman Anna static const struct pru_private_data k3_pru_data = {
10951d39f4d1SSuman Anna .type = PRU_TYPE_PRU,
10961d39f4d1SSuman Anna .is_k3 = 1,
10971d39f4d1SSuman Anna };
10981d39f4d1SSuman Anna
10991d39f4d1SSuman Anna static const struct pru_private_data k3_rtu_data = {
11001d39f4d1SSuman Anna .type = PRU_TYPE_RTU,
11011d39f4d1SSuman Anna .is_k3 = 1,
11021d39f4d1SSuman Anna };
11031d39f4d1SSuman Anna
11041d39f4d1SSuman Anna static const struct pru_private_data k3_tx_pru_data = {
11051d39f4d1SSuman Anna .type = PRU_TYPE_TX_PRU,
11061d39f4d1SSuman Anna .is_k3 = 1,
11071d39f4d1SSuman Anna };
11081d39f4d1SSuman Anna
1109d4ce2de7SSuman Anna static const struct of_device_id pru_rproc_match[] = {
11101d39f4d1SSuman Anna { .compatible = "ti,am3356-pru", .data = &pru_data },
11111d39f4d1SSuman Anna { .compatible = "ti,am4376-pru", .data = &pru_data },
11121d39f4d1SSuman Anna { .compatible = "ti,am5728-pru", .data = &pru_data },
11130740ec08SSuman Anna { .compatible = "ti,am642-pru", .data = &k3_pru_data },
11140740ec08SSuman Anna { .compatible = "ti,am642-rtu", .data = &k3_rtu_data },
11150740ec08SSuman Anna { .compatible = "ti,am642-tx-pru", .data = &k3_tx_pru_data },
11161d39f4d1SSuman Anna { .compatible = "ti,k2g-pru", .data = &pru_data },
11171d39f4d1SSuman Anna { .compatible = "ti,am654-pru", .data = &k3_pru_data },
11181d39f4d1SSuman Anna { .compatible = "ti,am654-rtu", .data = &k3_rtu_data },
11191d39f4d1SSuman Anna { .compatible = "ti,am654-tx-pru", .data = &k3_tx_pru_data },
1120b44786c9SSuman Anna { .compatible = "ti,j721e-pru", .data = &k3_pru_data },
1121b44786c9SSuman Anna { .compatible = "ti,j721e-rtu", .data = &k3_rtu_data },
1122b44786c9SSuman Anna { .compatible = "ti,j721e-tx-pru", .data = &k3_tx_pru_data },
1123aa0cec24SKishon Vijay Abraham I { .compatible = "ti,am625-pru", .data = &k3_pru_data },
1124d4ce2de7SSuman Anna {},
1125d4ce2de7SSuman Anna };
1126d4ce2de7SSuman Anna MODULE_DEVICE_TABLE(of, pru_rproc_match);
1127d4ce2de7SSuman Anna
1128d4ce2de7SSuman Anna static struct platform_driver pru_rproc_driver = {
1129d4ce2de7SSuman Anna .driver = {
1130919e8942SMD Danish Anwar .name = PRU_RPROC_DRVNAME,
1131d4ce2de7SSuman Anna .of_match_table = pru_rproc_match,
1132d4ce2de7SSuman Anna .suppress_bind_attrs = true,
1133d4ce2de7SSuman Anna },
1134d4ce2de7SSuman Anna .probe = pru_rproc_probe,
1135d6b862fdSUwe Kleine-König .remove_new = pru_rproc_remove,
1136d4ce2de7SSuman Anna };
1137d4ce2de7SSuman Anna module_platform_driver(pru_rproc_driver);
1138d4ce2de7SSuman Anna
1139d4ce2de7SSuman Anna MODULE_AUTHOR("Suman Anna <s-anna@ti.com>");
1140d4ce2de7SSuman Anna MODULE_AUTHOR("Andrew F. Davis <afd@ti.com>");
1141d4ce2de7SSuman Anna MODULE_AUTHOR("Grzegorz Jaszczyk <grzegorz.jaszczyk@linaro.org>");
1142919e8942SMD Danish Anwar MODULE_AUTHOR("Puranjay Mohan <p-mohan@ti.com>");
1143919e8942SMD Danish Anwar MODULE_AUTHOR("Md Danish Anwar <danishanwar@ti.com>");
1144d4ce2de7SSuman Anna MODULE_DESCRIPTION("PRU-ICSS Remote Processor Driver");
1145d4ce2de7SSuman Anna MODULE_LICENSE("GPL v2");
1146