drivers/remoteproc/pru_rproc.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * PRU-ICSS remoteproc driver for various TI SoCs
   4  *
   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 Instruments
  11  *      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           0x0000
  32 #define PRU_CTRL_STS            0x0004
  33 #define PRU_CTRL_WAKEUP_EN      0x0008
  34 #define PRU_CTRL_CYCLE          0x000C
  35 #define PRU_CTRL_STALL          0x0010
  36 #define PRU_CTRL_CTBIR0         0x0020
  37 #define PRU_CTRL_CTBIR1         0x0024
  38 #define PRU_CTRL_CTPPR0         0x0028
  39 #define PRU_CTRL_CTPPR1         0x002C
  40
  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      0x3ffff
  55 #define PRU0_IRAM_ADDR_MASK     0x34000
  56 #define PRU1_IRAM_ADDR_MASK     0x38000
  57 #define RTU0_IRAM_ADDR_MASK     0x4000
  58 #define RTU1_IRAM_ADDR_MASK     0x6000
  59 #define TX_PRU0_IRAM_ADDR_MASK  0xa000
  60 #define TX_PRU1_IRAM_ADDR_MASK  0xc000
  61
  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 160
  69
  70 /**
  71  * enum pru_iomem - PRU core memory/register range identifiers
  72  *
  73  * @PRU_IOMEM_IRAM: PRU Instruction RAM range
  74  * @PRU_IOMEM_CTRL: PRU Control register range
  75  * @PRU_IOMEM_DEBUG: PRU Debug register range
  76  * @PRU_IOMEM_MAX: just keep this one at the end
  77  */
  78 enum 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 core
  87  * @type: type of the PRU core (PRU, RTU, Tx_PRU)
  88  * @is_k3: flag used to identify the need for special load handling
  89  */
  90 struct pru_private_data {
  91         enum pru_type type;
  92         unsigned int is_k3 : 1;
  93 };
  94
  95 /**
  96  * struct pru_rproc - PRU remoteproc structure
  97  * @id: id of the PRU core within the PRUSS
  98  * @dev: PRU core device pointer
  99  * @pruss: back-reference to parent PRUSS structure
 100  * @rproc: remoteproc pointer for this PRU core
 101  * @data: PRU core specific data
 102  * @mem_regions: data for each of the PRU memory regions
 103  * @client_np: client device node
 104  * @lock: mutex to protect client usage
 105  * @fw_name: name of firmware image used during loading
 106  * @mapped_irq: virtual interrupt numbers of created fw specific mapping
 107  * @pru_interrupt_map: pointer to interrupt mapping description (firmware)
 108  * @pru_interrupt_map_sz: pru_interrupt_map size
 109  * @rmw_lock: lock for read, modify, write operations on registers
 110  * @dbg_single_step: debug state variable to set PRU into single step mode
 111  * @dbg_continuous: debug state variable to restore PRU execution mode
 112  * @evt_count: number of mapped events
 113  * @gpmux_save: saved value for gpmux config
 114  */
 115 struct 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
 135 static 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
 140 static inline
 141 void 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
 146 static inline
 147 void 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 core
 165  * @rproc: the rproc instance of the PRU
 166  * @fw_name: the new firmware name, or NULL if default is desired
 167  *
 168  * Return: 0 on success, or errno in error case.
 169  */
 170 static 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
 180 static 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 node
 207  * @np: the user/client device node
 208  * @index: index to use for the ti,prus property
 209  * @pru_id: optional pointer to return the PRU remoteproc processor id
 210  *
 211  * This function looks through a client device node's "ti,prus" property at
 212  * index @index and returns the rproc handle for a valid PRU remote processor if
 213  * found. The function allows only one user to own the PRU rproc resource at a
 214  * time. Caller must call pru_rproc_put() when done with using the rproc, not
 215  * required if the function returns a failure.
 216  *
 217  * When optional @pru_id pointer is passed the PRU remoteproc processor id is
 218  * returned.
 219  *
 220  * Return: rproc handle on success, and an ERR_PTR on failure using one
 221  * of the following error values
 222  *    -ENODEV if device is not found
 223  *    -EBUSY if PRU is already acquired by anyone
 224  *    -EPROBE_DEFER is PRU device is not probed yet
 225  */
 226 struct 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
 288 err_no_rproc_handle:
 289         rproc_put(rproc);
 290         return ERR_PTR(ret);
 291
 292 err:
 293         pru_rproc_put(rproc);
 294         return ERR_PTR(ret);
 295 }
 296 EXPORT_SYMBOL_GPL(pru_rproc_get);
 297
 298 /**
 299  * pru_rproc_put() - release the PRU rproc resource
 300  * @rproc: the rproc resource to release
 301  *
 302  * Releases the PRU rproc resource and makes it available to other
 303  * users.
 304  */
 305 void 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 }
 331 EXPORT_SYMBOL_GPL(pru_rproc_put);
 332
 333 /**
 334  * pru_rproc_set_ctable() - set the constant table index for the PRU
 335  * @rproc: the rproc instance of the PRU
 336  * @c: constant table index to set
 337  * @addr: physical address to set it to
 338  *
 339  * Return: 0 on success, or errno in error case.
 340  */
 341 int 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 }
 370 EXPORT_SYMBOL_GPL(pru_rproc_set_ctable);
 371
 372 static 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
 377 static 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 }
 421 DEFINE_SHOW_ATTRIBUTE(regs);
 422
 423 /*
 424  * Control PRU single-step mode
 425  *
 426  * This is a debug helper function used for controlling the single-step
 427  * mode of the PRU. The PRU Debug registers are not accessible when the
 428  * PRU is in RUNNING state.
 429  *
 430  * Writing a non-zero value sets the PRU into single-step mode irrespective
 431  * of its previous state. The PRU mode is saved only on the first set into
 432  * a single-step mode. Writing a zero value will restore the PRU into its
 433  * original mode.
 434  */
 435 static 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         else
 453                 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
 461 static 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 }
 470 DEFINE_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 entries
 475  *
 476  * The entries are created only if the parent remoteproc debugfs directory
 477  * exists, and will be cleaned up by the remoteproc core.
 478  */
 479 static 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, &regs_fops);
 486         debugfs_create_file("single_step", 0600, rproc->dbg_dir,
 487                             rproc, &pru_rproc_debug_ss_fops);
 488 }
 489
 490 static 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 INTC
 507  * appropriately.
 508  */
 509 static 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 and
 545          * channel-to-host mapping. The interrupt controller to be used
 546          * for these mappings for a given PRU remoteproc is always its
 547          * corresponding sibling PRUSS INTC node.
 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
 589 map_fail:
 590         pru_dispose_irq_mapping(pru);
 591         of_node_put(irq_parent);
 592
 593         return ret;
 594 }
 595
 596 static 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 valid
 610          * after rproc_start returns
 611          */
 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
 623 static 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 at
 646  * different ranges. So, look through both its primary and secondary Data
 647  * RAMs as well as any shared Data RAM to convert a PRU device address to
 648  * kernel virtual address. Data RAM0 is primary Data RAM for PRU0 and Data
 649  * RAM1 is primary Data RAM for PRU1.
 650  */
 651 static 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 own
 688  * private Instruction RAM, and its device address is identical to that of
 689  * its primary Data RAM device address.
 690  */
 691 static 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 GNU
 701          * linker's default linker script places IRAM at an arbitrary high
 702          * offset, in order to differentiate it from DRAM. Hence we need to
 703          * strip the artificial offset in the IRAM addresses coming from the
 704          * ELF file.
 705          *
 706          * The TI proprietary linker would never set those higher IRAM address
 707          * bits anyway. PRU architecture limits the program counter to 16-bit
 708          * word-address range. This in turn corresponds to 18-bit IRAM
 709          * byte-address range for ELF.
 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 banking
 713          * 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 remoteproc
 728  * core for any PRU client drivers. The PRU Instruction RAM access is restricted
 729  * only to the PRU loader code.
 730  */
 731 static 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. */
 739 static 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         else
 747                 va = pru_d_da_to_va(pru, da, len);
 748
 749         return va;
 750 }
 751
 752 static struct rproc_ops pru_rproc_ops = {
 753         .start          = pru_rproc_start,
 754         .stop           = pru_rproc_stop,
 755         .da_to_va       = pru_rproc_da_to_va,
 756 };
 757
 758 /*
 759  * Custom memory copy implementation for ICSSG PRU/RTU/Tx_PRU Cores
 760  *
 761  * The ICSSG PRU/RTU/Tx_PRU cores have a memory copying issue with IRAM
 762  * memories, that is not seen on previous generation SoCs. The data is reflected
 763  * properly in the IRAM memories only for integer (4-byte) copies. Any unaligned
 764  * copies result in all the other pre-existing bytes zeroed out within that
 765  * 4-byte boundary, thereby resulting in wrong text/code in the IRAMs. Also, the
 766  * IRAM memory port interface does not allow any 8-byte copies (as commonly used
 767  * by ARM64 memcpy implementation) and throws an exception. The DRAM memory
 768  * ports do not show this behavior.
 769  */
 770 static 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 copy
 779          * sizes
 780          */
 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
 800 static int
 801 pru_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
 869 static const void *
 870 pru_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 firmware
 917  * specific sections.
 918  *
 919  * The firmware blob can contain optional ELF sections: .resource_table section
 920  * and .pru_irq_map one. The second one contains the PRUSS interrupt mapping
 921  * description, which needs to be setup before powering on the PRU core. To
 922  * avoid RAM wastage this ELF section is not mapped to any ELF segment (by the
 923  * firmware linker) and therefore is not loaded to PRU memory.
 924  */
 925 static 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 are
 960  * always at a particular offset within the PRUSS address space.
 961  */
 962 static 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
 988 static 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 not
1028          * desired with PRU client driven boot-flow methodology. A PRU
1029          * application/client driver will boot the corresponding PRU
1030          * remote-processor as part of its state machine either through the
1031          * remoteproc sysfs interface or through the equivalent kernel API.
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
1082 static 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
1090 static const struct pru_private_data pru_data = {
1091         .type = PRU_TYPE_PRU,
1092 };
1093
1094 static const struct pru_private_data k3_pru_data = {
1095         .type = PRU_TYPE_PRU,
1096         .is_k3 = 1,
1097 };
1098
1099 static const struct pru_private_data k3_rtu_data = {
1100         .type = PRU_TYPE_RTU,
1101         .is_k3 = 1,
1102 };
1103
1104 static const struct pru_private_data k3_tx_pru_data = {
1105         .type = PRU_TYPE_TX_PRU,
1106         .is_k3 = 1,
1107 };
1108
1109 static const struct of_device_id pru_rproc_match[] = {
1110         { .compatible = "ti,am3356-pru",        .data = &pru_data },
1111         { .compatible = "ti,am4376-pru",        .data = &pru_data },
1112         { .compatible = "ti,am5728-pru",        .data = &pru_data },
1113         { .compatible = "ti,am642-pru",         .data = &k3_pru_data },
1114         { .compatible = "ti,am642-rtu",         .data = &k3_rtu_data },
1115         { .compatible = "ti,am642-tx-pru",      .data = &k3_tx_pru_data },
1116         { .compatible = "ti,k2g-pru",           .data = &pru_data },
1117         { .compatible = "ti,am654-pru",         .data = &k3_pru_data },
1118         { .compatible = "ti,am654-rtu",         .data = &k3_rtu_data },
1119         { .compatible = "ti,am654-tx-pru",      .data = &k3_tx_pru_data },
1120         { .compatible = "ti,j721e-pru",         .data = &k3_pru_data },
1121         { .compatible = "ti,j721e-rtu",         .data = &k3_rtu_data },
1122         { .compatible = "ti,j721e-tx-pru",      .data = &k3_tx_pru_data },
1123         { .compatible = "ti,am625-pru",         .data = &k3_pru_data },
1124         {},
1125 };
1126 MODULE_DEVICE_TABLE(of, pru_rproc_match);
1127
1128 static 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 };
1137 module_platform_driver(pru_rproc_driver);
1138
1139 MODULE_AUTHOR("Suman Anna <s-anna@ti.com>");
1140 MODULE_AUTHOR("Andrew F. Davis <afd@ti.com>");
1141 MODULE_AUTHOR("Grzegorz Jaszczyk <grzegorz.jaszczyk@linaro.org>");
1142 MODULE_AUTHOR("Puranjay Mohan <p-mohan@ti.com>");
1143 MODULE_AUTHOR("Md Danish Anwar <danishanwar@ti.com>");
1144 MODULE_DESCRIPTION("PRU-ICSS Remote Processor Driver");
1145 MODULE_LICENSE("GPL v2");