1146 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * PRU-ICSS remoteproc driver for various TI SoCs4 *5 * Copyright (C) 2014-2022 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 Instruments11 * Puranjay Mohan <p-mohan@ti.com>12 * Md Danish Anwar <danishanwar@ti.com>13 */14 15#include <linux/bitops.h>16#include <linux/debugfs.h>17#include <linux/irqdomain.h>18#include <linux/module.h>19#include <linux/of.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>25 26#include "remoteproc_internal.h"27#include "remoteproc_elf_helpers.h"28#include "pru_rproc.h"29 30/* PRU_ICSS_PRU_CTRL registers */31#define PRU_CTRL_CTRL 0x000032#define PRU_CTRL_STS 0x000433#define PRU_CTRL_WAKEUP_EN 0x000834#define PRU_CTRL_CYCLE 0x000C35#define PRU_CTRL_STALL 0x001036#define PRU_CTRL_CTBIR0 0x002037#define PRU_CTRL_CTBIR1 0x002438#define PRU_CTRL_CTPPR0 0x002839#define PRU_CTRL_CTPPR1 0x002C40 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)48 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)52 53/* PRU/RTU/Tx_PRU Core IRAM address masks */54#define PRU_IRAM_ADDR_MASK 0x3ffff55#define PRU0_IRAM_ADDR_MASK 0x3400056#define PRU1_IRAM_ADDR_MASK 0x3800057#define RTU0_IRAM_ADDR_MASK 0x400058#define RTU1_IRAM_ADDR_MASK 0x600059#define TX_PRU0_IRAM_ADDR_MASK 0xa00060#define TX_PRU1_IRAM_ADDR_MASK 0xc00061 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 */67 68#define MAX_PRU_SYS_EVENTS 16069 70/**71 * enum pru_iomem - PRU core memory/register range identifiers72 *73 * @PRU_IOMEM_IRAM: PRU Instruction RAM range74 * @PRU_IOMEM_CTRL: PRU Control register range75 * @PRU_IOMEM_DEBUG: PRU Debug register range76 * @PRU_IOMEM_MAX: just keep this one at the end77 */78enum pru_iomem {79 PRU_IOMEM_IRAM = 0,80 PRU_IOMEM_CTRL,81 PRU_IOMEM_DEBUG,82 PRU_IOMEM_MAX,83};84 85/**86 * struct pru_private_data - device data for a PRU core87 * @type: type of the PRU core (PRU, RTU, Tx_PRU)88 * @is_k3: flag used to identify the need for special load handling89 */90struct pru_private_data {91 enum pru_type type;92 unsigned int is_k3 : 1;93};94 95/**96 * struct pru_rproc - PRU remoteproc structure97 * @id: id of the PRU core within the PRUSS98 * @dev: PRU core device pointer99 * @pruss: back-reference to parent PRUSS structure100 * @rproc: remoteproc pointer for this PRU core101 * @data: PRU core specific data102 * @mem_regions: data for each of the PRU memory regions103 * @client_np: client device node104 * @lock: mutex to protect client usage105 * @fw_name: name of firmware image used during loading106 * @mapped_irq: virtual interrupt numbers of created fw specific mapping107 * @pru_interrupt_map: pointer to interrupt mapping description (firmware)108 * @pru_interrupt_map_sz: pru_interrupt_map size109 * @rmw_lock: lock for read, modify, write operations on registers110 * @dbg_single_step: debug state variable to set PRU into single step mode111 * @dbg_continuous: debug state variable to restore PRU execution mode112 * @evt_count: number of mapped events113 * @gpmux_save: saved value for gpmux config114 */115struct pru_rproc {116 int id;117 struct device *dev;118 struct pruss *pruss;119 struct rproc *rproc;120 const struct pru_private_data *data;121 struct pruss_mem_region mem_regions[PRU_IOMEM_MAX];122 struct device_node *client_np;123 struct mutex lock;124 const char *fw_name;125 unsigned int *mapped_irq;126 struct pru_irq_rsc *pru_interrupt_map;127 size_t pru_interrupt_map_sz;128 spinlock_t rmw_lock;129 u32 dbg_single_step;130 u32 dbg_continuous;131 u8 evt_count;132 u8 gpmux_save;133};134 135static inline u32 pru_control_read_reg(struct pru_rproc *pru, unsigned int reg)136{137 return readl_relaxed(pru->mem_regions[PRU_IOMEM_CTRL].va + reg);138}139 140static inline141void pru_control_write_reg(struct pru_rproc *pru, unsigned int reg, u32 val)142{143 writel_relaxed(val, pru->mem_regions[PRU_IOMEM_CTRL].va + reg);144}145 146static inline147void pru_control_set_reg(struct pru_rproc *pru, unsigned int reg,148 u32 mask, u32 set)149{150 u32 val;151 unsigned long flags;152 153 spin_lock_irqsave(&pru->rmw_lock, flags);154 155 val = pru_control_read_reg(pru, reg);156 val &= ~mask;157 val |= (set & mask);158 pru_control_write_reg(pru, reg, val);159 160 spin_unlock_irqrestore(&pru->rmw_lock, flags);161}162 163/**164 * pru_rproc_set_firmware() - set firmware for a PRU core165 * @rproc: the rproc instance of the PRU166 * @fw_name: the new firmware name, or NULL if default is desired167 *168 * Return: 0 on success, or errno in error case.169 */170static int pru_rproc_set_firmware(struct rproc *rproc, const char *fw_name)171{172 struct pru_rproc *pru = rproc->priv;173 174 if (!fw_name)175 fw_name = pru->fw_name;176 177 return rproc_set_firmware(rproc, fw_name);178}179 180static struct rproc *__pru_rproc_get(struct device_node *np, int index)181{182 struct rproc *rproc;183 phandle rproc_phandle;184 int ret;185 186 ret = of_property_read_u32_index(np, "ti,prus", index, &rproc_phandle);187 if (ret)188 return ERR_PTR(ret);189 190 rproc = rproc_get_by_phandle(rproc_phandle);191 if (!rproc) {192 ret = -EPROBE_DEFER;193 return ERR_PTR(ret);194 }195 196 /* make sure it is PRU rproc */197 if (!is_pru_rproc(rproc->dev.parent)) {198 rproc_put(rproc);199 return ERR_PTR(-ENODEV);200 }201 202 return rproc;203}204 205/**206 * pru_rproc_get() - get the PRU rproc instance from a device node207 * @np: the user/client device node208 * @index: index to use for the ti,prus property209 * @pru_id: optional pointer to return the PRU remoteproc processor id210 *211 * This function looks through a client device node's "ti,prus" property at212 * index @index and returns the rproc handle for a valid PRU remote processor if213 * found. The function allows only one user to own the PRU rproc resource at a214 * time. Caller must call pru_rproc_put() when done with using the rproc, not215 * required if the function returns a failure.216 *217 * When optional @pru_id pointer is passed the PRU remoteproc processor id is218 * returned.219 *220 * Return: rproc handle on success, and an ERR_PTR on failure using one221 * of the following error values222 * -ENODEV if device is not found223 * -EBUSY if PRU is already acquired by anyone224 * -EPROBE_DEFER is PRU device is not probed yet225 */226struct rproc *pru_rproc_get(struct device_node *np, int index,227 enum pruss_pru_id *pru_id)228{229 struct rproc *rproc;230 struct pru_rproc *pru;231 struct device *dev;232 const char *fw_name;233 int ret;234 u32 mux;235 236 rproc = __pru_rproc_get(np, index);237 if (IS_ERR(rproc))238 return rproc;239 240 pru = rproc->priv;241 dev = &rproc->dev;242 243 mutex_lock(&pru->lock);244 245 if (pru->client_np) {246 mutex_unlock(&pru->lock);247 ret = -EBUSY;248 goto err_no_rproc_handle;249 }250 251 pru->client_np = np;252 rproc->sysfs_read_only = true;253 254 mutex_unlock(&pru->lock);255 256 if (pru_id)257 *pru_id = pru->id;258 259 ret = pruss_cfg_get_gpmux(pru->pruss, pru->id, &pru->gpmux_save);260 if (ret) {261 dev_err(dev, "failed to get cfg gpmux: %d\n", ret);262 goto err;263 }264 265 /* An error here is acceptable for backward compatibility */266 ret = of_property_read_u32_index(np, "ti,pruss-gp-mux-sel", index,267 &mux);268 if (!ret) {269 ret = pruss_cfg_set_gpmux(pru->pruss, pru->id, mux);270 if (ret) {271 dev_err(dev, "failed to set cfg gpmux: %d\n", ret);272 goto err;273 }274 }275 276 ret = of_property_read_string_index(np, "firmware-name", index,277 &fw_name);278 if (!ret) {279 ret = pru_rproc_set_firmware(rproc, fw_name);280 if (ret) {281 dev_err(dev, "failed to set firmware: %d\n", ret);282 goto err;283 }284 }285 286 return rproc;287 288err_no_rproc_handle:289 rproc_put(rproc);290 return ERR_PTR(ret);291 292err:293 pru_rproc_put(rproc);294 return ERR_PTR(ret);295}296EXPORT_SYMBOL_GPL(pru_rproc_get);297 298/**299 * pru_rproc_put() - release the PRU rproc resource300 * @rproc: the rproc resource to release301 *302 * Releases the PRU rproc resource and makes it available to other303 * users.304 */305void pru_rproc_put(struct rproc *rproc)306{307 struct pru_rproc *pru;308 309 if (IS_ERR_OR_NULL(rproc) || !is_pru_rproc(rproc->dev.parent))310 return;311 312 pru = rproc->priv;313 314 pruss_cfg_set_gpmux(pru->pruss, pru->id, pru->gpmux_save);315 316 pru_rproc_set_firmware(rproc, NULL);317 318 mutex_lock(&pru->lock);319 320 if (!pru->client_np) {321 mutex_unlock(&pru->lock);322 return;323 }324 325 pru->client_np = NULL;326 rproc->sysfs_read_only = false;327 mutex_unlock(&pru->lock);328 329 rproc_put(rproc);330}331EXPORT_SYMBOL_GPL(pru_rproc_put);332 333/**334 * pru_rproc_set_ctable() - set the constant table index for the PRU335 * @rproc: the rproc instance of the PRU336 * @c: constant table index to set337 * @addr: physical address to set it to338 *339 * Return: 0 on success, or errno in error case.340 */341int pru_rproc_set_ctable(struct rproc *rproc, enum pru_ctable_idx c, u32 addr)342{343 struct pru_rproc *pru = rproc->priv;344 unsigned int reg;345 u32 mask, set;346 u16 idx;347 u16 idx_mask;348 349 if (IS_ERR_OR_NULL(rproc))350 return -EINVAL;351 352 if (!rproc->dev.parent || !is_pru_rproc(rproc->dev.parent))353 return -ENODEV;354 355 /* pointer is 16 bit and index is 8-bit so mask out the rest */356 idx_mask = (c >= PRU_C28) ? 0xFFFF : 0xFF;357 358 /* ctable uses bit 8 and upwards only */359 idx = (addr >> 8) & idx_mask;360 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));365 366 pru_control_set_reg(pru, reg, mask, set);367 368 return 0;369}370EXPORT_SYMBOL_GPL(pru_rproc_set_ctable);371 372static inline u32 pru_debug_read_reg(struct pru_rproc *pru, unsigned int reg)373{374 return readl_relaxed(pru->mem_regions[PRU_IOMEM_DEBUG].va + reg);375}376 377static int regs_show(struct seq_file *s, void *data)378{379 struct rproc *rproc = s->private;380 struct pru_rproc *pru = rproc->priv;381 int i, nregs = 32;382 u32 pru_sts;383 int pru_is_running;384 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));404 405 seq_puts(s, "=============== Debug Registers ===============\n");406 pru_is_running = pru_control_read_reg(pru, PRU_CTRL_CTRL) &407 CTRL_CTRL_RUNSTATE;408 if (pru_is_running) {409 seq_puts(s, "PRU is executing, cannot print/access debug registers.\n");410 return 0;411 }412 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)));417 }418 419 return 0;420}421DEFINE_SHOW_ATTRIBUTE(regs);422 423/*424 * Control PRU single-step mode425 *426 * This is a debug helper function used for controlling the single-step427 * mode of the PRU. The PRU Debug registers are not accessible when the428 * PRU is in RUNNING state.429 *430 * Writing a non-zero value sets the PRU into single-step mode irrespective431 * of its previous state. The PRU mode is saved only on the first set into432 * a single-step mode. Writing a zero value will restore the PRU into its433 * original mode.434 */435static int pru_rproc_debug_ss_set(void *data, u64 val)436{437 struct rproc *rproc = data;438 struct pru_rproc *pru = rproc->priv;439 u32 reg_val;440 441 val = val ? 1 : 0;442 if (!val && !pru->dbg_single_step)443 return 0;444 445 reg_val = pru_control_read_reg(pru, PRU_CTRL_CTRL);446 447 if (val && !pru->dbg_single_step)448 pru->dbg_continuous = reg_val;449 450 if (val)451 reg_val |= CTRL_CTRL_SINGLE_STEP | CTRL_CTRL_EN;452 else453 reg_val = pru->dbg_continuous;454 455 pru->dbg_single_step = val;456 pru_control_write_reg(pru, PRU_CTRL_CTRL, reg_val);457 458 return 0;459}460 461static int pru_rproc_debug_ss_get(void *data, u64 *val)462{463 struct rproc *rproc = data;464 struct pru_rproc *pru = rproc->priv;465 466 *val = pru->dbg_single_step;467 468 return 0;469}470DEFINE_DEBUGFS_ATTRIBUTE(pru_rproc_debug_ss_fops, pru_rproc_debug_ss_get,471 pru_rproc_debug_ss_set, "%llu\n");472 473/*474 * Create PRU-specific debugfs entries475 *476 * The entries are created only if the parent remoteproc debugfs directory477 * exists, and will be cleaned up by the remoteproc core.478 */479static void pru_rproc_create_debug_entries(struct rproc *rproc)480{481 if (!rproc->dbg_dir)482 return;483 484 debugfs_create_file("regs", 0400, rproc->dbg_dir,485 rproc, ®s_fops);486 debugfs_create_file("single_step", 0600, rproc->dbg_dir,487 rproc, &pru_rproc_debug_ss_fops);488}489 490static void pru_dispose_irq_mapping(struct pru_rproc *pru)491{492 if (!pru->mapped_irq)493 return;494 495 while (pru->evt_count) {496 pru->evt_count--;497 if (pru->mapped_irq[pru->evt_count] > 0)498 irq_dispose_mapping(pru->mapped_irq[pru->evt_count]);499 }500 501 kfree(pru->mapped_irq);502 pru->mapped_irq = NULL;503}504 505/*506 * Parse the custom PRU interrupt map resource and configure the INTC507 * appropriately.508 */509static int pru_handle_intrmap(struct rproc *rproc)510{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;516 int i, ret = 0;517 518 /* not having pru_interrupt_map is not an error */519 if (!rsc)520 return 0;521 522 /* currently supporting only type 0 */523 if (rsc->type != 0) {524 dev_err(dev, "unsupported rsc type: %d\n", rsc->type);525 return -EINVAL;526 }527 528 if (rsc->num_evts > MAX_PRU_SYS_EVENTS)529 return -EINVAL;530 531 if (sizeof(*rsc) + rsc->num_evts * sizeof(struct pruss_int_map) !=532 pru->pru_interrupt_map_sz)533 return -EINVAL;534 535 pru->evt_count = rsc->num_evts;536 pru->mapped_irq = kcalloc(pru->evt_count, sizeof(unsigned int),537 GFP_KERNEL);538 if (!pru->mapped_irq) {539 pru->evt_count = 0;540 return -ENOMEM;541 }542 543 /*544 * parse and fill in system event to interrupt channel and545 * channel-to-host mapping. The interrupt controller to be used546 * for these mappings for a given PRU remoteproc is always its547 * corresponding sibling PRUSS INTC node.548 */549 parent = of_get_parent(dev_of_node(pru->dev));550 if (!parent) {551 kfree(pru->mapped_irq);552 pru->mapped_irq = NULL;553 pru->evt_count = 0;554 return -ENODEV;555 }556 557 irq_parent = of_get_child_by_name(parent, "interrupt-controller");558 of_node_put(parent);559 if (!irq_parent) {560 kfree(pru->mapped_irq);561 pru->mapped_irq = NULL;562 pru->evt_count = 0;563 return -ENODEV;564 }565 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;572 573 dev_dbg(dev, "mapping%d: event %d, chnl %d, host %d\n",574 i, fwspec.param[0], fwspec.param[1], fwspec.param[2]);575 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],580 fwspec.param[2]);581 ret = -EINVAL;582 goto map_fail;583 }584 }585 of_node_put(irq_parent);586 587 return ret;588 589map_fail:590 pru_dispose_irq_mapping(pru);591 of_node_put(irq_parent);592 593 return ret;594}595 596static int pru_rproc_start(struct rproc *rproc)597{598 struct device *dev = &rproc->dev;599 struct pru_rproc *pru = rproc->priv;600 const char *names[PRU_TYPE_MAX] = { "PRU", "RTU", "Tx_PRU" };601 u32 val;602 int ret;603 604 dev_dbg(dev, "starting %s%d: entry-point = 0x%llx\n",605 names[pru->data->type], pru->id, (rproc->bootaddr >> 2));606 607 ret = pru_handle_intrmap(rproc);608 /*609 * reset references to pru interrupt map - they will stop being valid610 * after rproc_start returns611 */612 pru->pru_interrupt_map = NULL;613 pru->pru_interrupt_map_sz = 0;614 if (ret)615 return ret;616 617 val = CTRL_CTRL_EN | ((rproc->bootaddr >> 2) << 16);618 pru_control_write_reg(pru, PRU_CTRL_CTRL, val);619 620 return 0;621}622 623static int pru_rproc_stop(struct rproc *rproc)624{625 struct device *dev = &rproc->dev;626 struct pru_rproc *pru = rproc->priv;627 const char *names[PRU_TYPE_MAX] = { "PRU", "RTU", "Tx_PRU" };628 u32 val;629 630 dev_dbg(dev, "stopping %s%d\n", names[pru->data->type], pru->id);631 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);635 636 /* dispose irq mapping - new firmware can provide new mapping */637 pru_dispose_irq_mapping(pru);638 639 return 0;640}641 642/*643 * Convert PRU device address (data spaces only) to kernel virtual address.644 *645 * Each PRU has access to all data memories within the PRUSS, accessible at646 * different ranges. So, look through both its primary and secondary Data647 * RAMs as well as any shared Data RAM to convert a PRU device address to648 * kernel virtual address. Data RAM0 is primary Data RAM for PRU0 and Data649 * RAM1 is primary Data RAM for PRU1.650 */651static void *pru_d_da_to_va(struct pru_rproc *pru, u32 da, size_t len)652{653 struct pruss_mem_region dram0, dram1, shrd_ram;654 struct pruss *pruss = pru->pruss;655 u32 offset;656 void *va = NULL;657 658 if (len == 0)659 return NULL;660 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)665 swap(dram0, dram1);666 shrd_ram = pruss->mem_regions[PRUSS_MEM_SHRD_RAM2];667 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);679 }680 681 return va;682}683 684/*685 * Convert PRU device address (instruction space) to kernel virtual address.686 *687 * A PRU does not have an unified address space. Each PRU has its very own688 * private Instruction RAM, and its device address is identical to that of689 * its primary Data RAM device address.690 */691static void *pru_i_da_to_va(struct pru_rproc *pru, u32 da, size_t len)692{693 u32 offset;694 void *va = NULL;695 696 if (len == 0)697 return NULL;698 699 /*700 * GNU binutils do not support multiple address spaces. The GNU701 * linker's default linker script places IRAM at an arbitrary high702 * offset, in order to differentiate it from DRAM. Hence we need to703 * strip the artificial offset in the IRAM addresses coming from the704 * ELF file.705 *706 * The TI proprietary linker would never set those higher IRAM address707 * bits anyway. PRU architecture limits the program counter to 16-bit708 * word-address range. This in turn corresponds to 18-bit IRAM709 * byte-address range for ELF.710 *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 banking713 * in future SoCs.714 */715 da &= 0xfffff;716 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 +720 offset);721 }722 723 return va;724}725 726/*727 * Provide address translations for only PRU Data RAMs through the remoteproc728 * core for any PRU client drivers. The PRU Instruction RAM access is restricted729 * only to the PRU loader code.730 */731static void *pru_rproc_da_to_va(struct rproc *rproc, u64 da, size_t len, bool *is_iomem)732{733 struct pru_rproc *pru = rproc->priv;734 735 return pru_d_da_to_va(pru, da, len);736}737 738/* PRU-specific address translator used by PRU loader. */739static void *pru_da_to_va(struct rproc *rproc, u64 da, size_t len, bool is_iram)740{741 struct pru_rproc *pru = rproc->priv;742 void *va;743 744 if (is_iram)745 va = pru_i_da_to_va(pru, da, len);746 else747 va = pru_d_da_to_va(pru, da, len);748 749 return va;750}751 752static 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,756};757 758/*759 * Custom memory copy implementation for ICSSG PRU/RTU/Tx_PRU Cores760 *761 * The ICSSG PRU/RTU/Tx_PRU cores have a memory copying issue with IRAM762 * memories, that is not seen on previous generation SoCs. The data is reflected763 * properly in the IRAM memories only for integer (4-byte) copies. Any unaligned764 * copies result in all the other pre-existing bytes zeroed out within that765 * 4-byte boundary, thereby resulting in wrong text/code in the IRAMs. Also, the766 * IRAM memory port interface does not allow any 8-byte copies (as commonly used767 * by ARM64 memcpy implementation) and throws an exception. The DRAM memory768 * ports do not show this behavior.769 */770static int pru_rproc_memcpy(void *dest, const void *src, size_t count)771{772 const u32 *s = src;773 u32 *d = dest;774 size_t size = count / 4;775 u32 *tmp_src = NULL;776 777 /*778 * TODO: relax limitation of 4-byte aligned dest addresses and copy779 * sizes780 */781 if ((long)dest % 4 || count % 4)782 return -EINVAL;783 784 /* src offsets in ELF firmware image can be non-aligned */785 if ((long)src % 4) {786 tmp_src = kmemdup(src, count, GFP_KERNEL);787 if (!tmp_src)788 return -ENOMEM;789 s = tmp_src;790 }791 792 while (size--)793 *d++ = *s++;794 795 kfree(tmp_src);796 797 return 0;798}799 800static int801pru_rproc_load_elf_segments(struct rproc *rproc, const struct firmware *fw)802{803 struct pru_rproc *pru = rproc->priv;804 struct device *dev = &rproc->dev;805 struct elf32_hdr *ehdr;806 struct elf32_phdr *phdr;807 int i, ret = 0;808 const u8 *elf_data = fw->data;809 810 ehdr = (struct elf32_hdr *)elf_data;811 phdr = (struct elf32_phdr *)(elf_data + ehdr->e_phoff);812 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;819 bool is_iram;820 void *ptr;821 822 if (phdr->p_type != PT_LOAD || !filesz)823 continue;824 825 dev_dbg(dev, "phdr: type %d da 0x%x memsz 0x%x filesz 0x%x\n",826 phdr->p_type, da, memsz, filesz);827 828 if (filesz > memsz) {829 dev_err(dev, "bad phdr filesz 0x%x memsz 0x%x\n",830 filesz, memsz);831 ret = -EINVAL;832 break;833 }834 835 if (offset + filesz > fw->size) {836 dev_err(dev, "truncated fw: need 0x%x avail 0x%zx\n",837 offset + filesz, fw->size);838 ret = -EINVAL;839 break;840 }841 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);845 if (!ptr) {846 dev_err(dev, "bad phdr da 0x%x mem 0x%x\n", da, memsz);847 ret = -EINVAL;848 break;849 }850 851 if (pru->data->is_k3) {852 ret = pru_rproc_memcpy(ptr, elf_data + phdr->p_offset,853 filesz);854 if (ret) {855 dev_err(dev, "PRU memory copy failed for da 0x%x memsz 0x%x\n",856 da, memsz);857 break;858 }859 } else {860 memcpy(ptr, elf_data + phdr->p_offset, filesz);861 }862 863 /* skip the memzero logic performed by remoteproc ELF loader */864 }865 866 return ret;867}868 869static const void *870pru_rproc_find_interrupt_map(struct device *dev, const struct firmware *fw)871{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;878 int i;879 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;886 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;891 892 if (strcmp(name_table + name, ".pru_irq_map"))893 continue;894 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);899 }900 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);905 }906 907 return shdr;908 }909 910 dev_dbg(dev, "no .pru_irq_map section found for this fw\n");911 912 return NULL;913}914 915/*916 * Use a custom parse_fw callback function for dealing with PRU firmware917 * specific sections.918 *919 * The firmware blob can contain optional ELF sections: .resource_table section920 * and .pru_irq_map one. The second one contains the PRUSS interrupt mapping921 * description, which needs to be setup before powering on the PRU core. To922 * avoid RAM wastage this ELF section is not mapped to any ELF segment (by the923 * firmware linker) and therefore is not loaded to PRU memory.924 */925static int pru_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw)926{927 struct device *dev = &rproc->dev;928 struct pru_rproc *pru = rproc->priv;929 const u8 *elf_data = fw->data;930 const void *shdr;931 u8 class = fw_elf_get_class(fw);932 u64 sh_offset;933 int ret;934 935 /* load optional rsc table */936 ret = rproc_elf_load_rsc_table(rproc, fw);937 if (ret == -EINVAL)938 dev_dbg(&rproc->dev, "no resource table found for this fw\n");939 else if (ret)940 return ret;941 942 /* find .pru_interrupt_map section, not having it is not an error */943 shdr = pru_rproc_find_interrupt_map(dev, fw);944 if (IS_ERR(shdr))945 return PTR_ERR(shdr);946 947 if (!shdr)948 return 0;949 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);954 955 return 0;956}957 958/*959 * Compute PRU id based on the IRAM addresses. The PRU IRAMs are960 * always at a particular offset within the PRUSS address space.961 */962static int pru_rproc_set_id(struct pru_rproc *pru)963{964 int ret = 0;965 966 switch (pru->mem_regions[PRU_IOMEM_IRAM].pa & PRU_IRAM_ADDR_MASK) {967 case TX_PRU0_IRAM_ADDR_MASK:968 fallthrough;969 case RTU0_IRAM_ADDR_MASK:970 fallthrough;971 case PRU0_IRAM_ADDR_MASK:972 pru->id = PRUSS_PRU0;973 break;974 case TX_PRU1_IRAM_ADDR_MASK:975 fallthrough;976 case RTU1_IRAM_ADDR_MASK:977 fallthrough;978 case PRU1_IRAM_ADDR_MASK:979 pru->id = PRUSS_PRU1;980 break;981 default:982 ret = -EINVAL;983 }984 985 return ret;986}987 988static int pru_rproc_probe(struct platform_device *pdev)989{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;994 const char *fw_name;995 struct rproc *rproc = NULL;996 struct resource *res;997 int i, ret;998 const struct pru_private_data *data;999 const char *mem_names[PRU_IOMEM_MAX] = { "iram", "control", "debug" };1000 1001 data = of_device_get_match_data(&pdev->dev);1002 if (!data)1003 return -ENODEV;1004 1005 ret = of_property_read_string(np, "firmware-name", &fw_name);1006 if (ret) {1007 dev_err(dev, "unable to retrieve firmware-name %d\n", ret);1008 return ret;1009 }1010 1011 rproc = devm_rproc_alloc(dev, pdev->name, &pru_rproc_ops, fw_name,1012 sizeof(*pru));1013 if (!rproc) {1014 dev_err(dev, "rproc_alloc failed\n");1015 return -ENOMEM;1016 }1017 /* use a custom load function to deal with PRU-specific quirks */1018 rproc->ops->load = pru_rproc_load_elf_segments;1019 1020 /* use a custom parse function to deal with PRU-specific resources */1021 rproc->ops->parse_fw = pru_rproc_parse_fw;1022 1023 /* error recovery is not supported for PRUs */1024 rproc->recovery_disabled = true;1025 1026 /*1027 * rproc_add will auto-boot the processor normally, but this is not1028 * desired with PRU client driven boot-flow methodology. A PRU1029 * application/client driver will boot the corresponding PRU1030 * remote-processor as part of its state machine either through the1031 * remoteproc sysfs interface or through the equivalent kernel API.1032 */1033 rproc->auto_boot = false;1034 1035 pru = rproc->priv;1036 pru->dev = dev;1037 pru->data = data;1038 pru->pruss = platform_get_drvdata(ppdev);1039 pru->rproc = rproc;1040 pru->fw_name = fw_name;1041 pru->client_np = NULL;1042 spin_lock_init(&pru->rmw_lock);1043 mutex_init(&pru->lock);1044 1045 for (i = 0; i < ARRAY_SIZE(mem_names); i++) {1046 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,1047 mem_names[i]);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",1051 i, mem_names[i]);1052 ret = PTR_ERR(pru->mem_regions[i].va);1053 return ret;1054 }1055 pru->mem_regions[i].pa = res->start;1056 pru->mem_regions[i].size = resource_size(res);1057 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);1061 }1062 1063 ret = pru_rproc_set_id(pru);1064 if (ret < 0)1065 return ret;1066 1067 platform_set_drvdata(pdev, rproc);1068 1069 ret = devm_rproc_add(dev, pru->rproc);1070 if (ret) {1071 dev_err(dev, "rproc_add failed: %d\n", ret);1072 return ret;1073 }1074 1075 pru_rproc_create_debug_entries(rproc);1076 1077 dev_dbg(dev, "PRU rproc node %pOF probed successfully\n", np);1078 1079 return 0;1080}1081 1082static void pru_rproc_remove(struct platform_device *pdev)1083{1084 struct device *dev = &pdev->dev;1085 struct rproc *rproc = platform_get_drvdata(pdev);1086 1087 dev_dbg(dev, "%s: removing rproc %s\n", __func__, rproc->name);1088}1089 1090static const struct pru_private_data pru_data = {1091 .type = PRU_TYPE_PRU,1092};1093 1094static const struct pru_private_data k3_pru_data = {1095 .type = PRU_TYPE_PRU,1096 .is_k3 = 1,1097};1098 1099static const struct pru_private_data k3_rtu_data = {1100 .type = PRU_TYPE_RTU,1101 .is_k3 = 1,1102};1103 1104static const struct pru_private_data k3_tx_pru_data = {1105 .type = PRU_TYPE_TX_PRU,1106 .is_k3 = 1,1107};1108 1109static 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 },1124 {},1125};1126MODULE_DEVICE_TABLE(of, pru_rproc_match);1127 1128static struct platform_driver pru_rproc_driver = {1129 .driver = {1130 .name = PRU_RPROC_DRVNAME,1131 .of_match_table = pru_rproc_match,1132 .suppress_bind_attrs = true,1133 },1134 .probe = pru_rproc_probe,1135 .remove_new = pru_rproc_remove,1136};1137module_platform_driver(pru_rproc_driver);1138 1139MODULE_AUTHOR("Suman Anna <s-anna@ti.com>");1140MODULE_AUTHOR("Andrew F. Davis <afd@ti.com>");1141MODULE_AUTHOR("Grzegorz Jaszczyk <grzegorz.jaszczyk@linaro.org>");1142MODULE_AUTHOR("Puranjay Mohan <p-mohan@ti.com>");1143MODULE_AUTHOR("Md Danish Anwar <danishanwar@ti.com>");1144MODULE_DESCRIPTION("PRU-ICSS Remote Processor Driver");1145MODULE_LICENSE("GPL v2");1146