drivers/remoteproc/pru_rproc.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * PRU-ICSS remoteproc driver for various TI SoCs
   4  *
   5  * Copyright (C) 2014-2019 Texas Instruments Incorporated - http://www.ti.com/
   6  *      Suman Anna <s-anna@ti.com>
   7  *      Andrew F. Davis <afd@ti.com>
   8  */
   9
  10 #include <linux/bitops.h>
  11 #include <linux/debugfs.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/mailbox_client.h>
  14 #include <linux/module.h>
  15 #include <linux/of_device.h>
  16 #include <linux/pruss.h>
  17 #include <linux/pruss_driver.h>
  18 #include <linux/remoteproc.h>
  19
  20 #include "remoteproc_internal.h"
  21 #include "pru_rproc.h"
  22
  23 /* PRU_ICSS_PRU_CTRL registers */
  24 #define PRU_CTRL_CTRL           0x0000
  25 #define PRU_CTRL_STS            0x0004
  26 #define PRU_CTRL_WAKEUP_EN      0x0008
  27 #define PRU_CTRL_CYCLE          0x000C
  28 #define PRU_CTRL_STALL          0x0010
  29 #define PRU_CTRL_CTBIR0         0x0020
  30 #define PRU_CTRL_CTBIR1         0x0024
  31 #define PRU_CTRL_CTPPR0         0x0028
  32 #define PRU_CTRL_CTPPR1         0x002C
  33
  34 /* CTRL register bit-fields */
  35 #define CTRL_CTRL_SOFT_RST_N    BIT(0)
  36 #define CTRL_CTRL_EN            BIT(1)
  37 #define CTRL_CTRL_SLEEPING      BIT(2)
  38 #define CTRL_CTRL_CTR_EN        BIT(3)
  39 #define CTRL_CTRL_SINGLE_STEP   BIT(8)
  40 #define CTRL_CTRL_RUNSTATE      BIT(15)
  41
  42 /* PRU_ICSS_PRU_DEBUG registers */
  43 #define PRU_DEBUG_GPREG(x)      (0x0000 + (x) * 4)
  44 #define PRU_DEBUG_CT_REG(x)     (0x0080 + (x) * 4)
  45
  46 /* PRU Core IRAM address masks */
  47 #define PRU0_IRAM_ADDR_MASK     0x34000
  48 #define PRU1_IRAM_ADDR_MASK     0x38000
  49
  50 /**
  51  * enum pru_iomem - PRU core memory/register range identifiers
  52  */
  53 enum pru_iomem {
  54         PRU_IOMEM_IRAM = 0,
  55         PRU_IOMEM_CTRL,
  56         PRU_IOMEM_DEBUG,
  57         PRU_IOMEM_MAX,
  58 };
  59
  60 /**
  61  * struct pru_rproc - PRU remoteproc structure
  62  * @id: id of the PRU core within the PRUSS
  63  * @pruss: back-reference to parent PRUSS structure
  64  * @rproc: remoteproc pointer for this PRU core
  65  * @client_np: client device node
  66  * @mbox: mailbox channel handle used for vring signalling with MPU
  67  * @client: mailbox client to request the mailbox channel
  68  * @irq_ring: IRQ number to use for processing vring buffers
  69  * @irq_kick: IRQ number to use to perform virtio kick
  70  * @mem_regions: data for each of the PRU memory regions
  71  * @intc_config: PRU INTC configuration data
  72  * @rmw_lock: lock for read, modify, write operations on registers
  73  * @iram_da: device address of Instruction RAM for this PRU
  74  * @pdram_da: device address of primary Data RAM for this PRU
  75  * @sdram_da: device address of secondary Data RAM for this PRU
  76  * @shrdram_da: device address of shared Data RAM
  77  * @fw_name: name of firmware image used during loading
  78  * @dt_irqs: number of irqs configured from DT
  79  * @lock: mutex to protect client usage
  80  * @dbg_single_step: debug state variable to set PRU into single step mode
  81  * @dbg_continuous: debug state variable to restore PRU execution mode
  82  * @fw_has_intc_rsc: boolean flag to indicate INTC config through firmware
  83  */
  84 struct pru_rproc {
  85         int id;
  86         struct pruss *pruss;
  87         struct rproc *rproc;
  88         struct device_node *client_np;
  89         struct mbox_chan *mbox;
  90         struct mbox_client client;
  91         int irq_vring;
  92         int irq_kick;
  93         struct pruss_mem_region mem_regions[PRU_IOMEM_MAX];
  94         struct pruss_intc_config intc_config;
  95         spinlock_t rmw_lock; /* register access lock */
  96         u32 iram_da;
  97         u32 pdram_da;
  98         u32 sdram_da;
  99         u32 shrdram_da;
 100         const char *fw_name;
 101         int dt_irqs;
 102         struct mutex lock; /* client access lock */
 103         u32 dbg_single_step;
 104         u32 dbg_continuous;
 105         unsigned int fw_has_intc_rsc : 1;
 106 };
 107
 108 static void *pru_d_da_to_va(struct pru_rproc *pru, u32 da, int len);
 109
 110 static inline u32 pru_control_read_reg(struct pru_rproc *pru, unsigned int reg)
 111 {
 112         return readl_relaxed(pru->mem_regions[PRU_IOMEM_CTRL].va + reg);
 113 }
 114
 115 static inline
 116 void pru_control_write_reg(struct pru_rproc *pru, unsigned int reg, u32 val)
 117 {
 118         writel_relaxed(val, pru->mem_regions[PRU_IOMEM_CTRL].va + reg);
 119 }
 120
 121 static inline
 122 void pru_control_set_reg(struct pru_rproc *pru, unsigned int reg,
 123                          u32 mask, u32 set)
 124 {
 125         u32 val;
 126         unsigned long flags;
 127
 128         spin_lock_irqsave(&pru->rmw_lock, flags);
 129
 130         val = pru_control_read_reg(pru, reg);
 131         val &= ~mask;
 132         val |= (set & mask);
 133         pru_control_write_reg(pru, reg, val);
 134
 135         spin_unlock_irqrestore(&pru->rmw_lock, flags);
 136 }
 137
 138 /**
 139  * pru_rproc_set_firmware() - set firmware for a pru core
 140  * @rproc: the rproc instance of the PRU
 141  * @fw_name: the new firmware name, or NULL if default is desired
 142  */
 143 static int pru_rproc_set_firmware(struct rproc *rproc, const char *fw_name)
 144 {
 145         struct pru_rproc *pru = rproc->priv;
 146
 147         if (!fw_name)
 148                 fw_name = pru->fw_name;
 149
 150         return rproc_set_firmware(rproc, fw_name);
 151 }
 152
 153 static int pru_rproc_intc_dt_config(struct pru_rproc *pru, int index)
 154 {
 155         struct device *dev = &pru->rproc->dev;
 156         struct device_node *np = pru->client_np;
 157         struct property *prop;
 158         const char *prop_name = "ti,pru-interrupt-map";
 159         int ret = 0, i;
 160         int dt_irqs;
 161         u32 *arr;
 162         bool has_irqs = false;
 163
 164         prop = of_find_property(np, prop_name, NULL);
 165         if (!prop)
 166                 return 0;
 167
 168         dt_irqs = of_property_count_u32_elems(np, prop_name);
 169         if (dt_irqs <= 0 || dt_irqs % 4) {
 170                 dev_err(dev, "bad interrupt map data %d, expected multiple of 4\n",
 171                         dt_irqs);
 172                 return -EINVAL;
 173         }
 174
 175         arr = kmalloc_array(dt_irqs, sizeof(u32), GFP_KERNEL);
 176         if (!arr)
 177                 return -ENOMEM;
 178
 179         ret = of_property_read_u32_array(np, prop_name, arr, dt_irqs);
 180         if (ret) {
 181                 dev_err(dev, "failed to read pru irq map: %d\n", ret);
 182                 goto out;
 183         }
 184
 185         for (i = 0; i < ARRAY_SIZE(pru->intc_config.sysev_to_ch); i++)
 186                 pru->intc_config.sysev_to_ch[i] = -1;
 187
 188         for (i = 0; i < ARRAY_SIZE(pru->intc_config.ch_to_host); i++)
 189                 pru->intc_config.ch_to_host[i] = -1;
 190
 191         for (i = 0; i < dt_irqs; i += 4) {
 192                 if (arr[i] != index)
 193                         continue;
 194
 195                 if (arr[i + 1] < 0 ||
 196                     arr[i + 1] >= MAX_PRU_SYS_EVENTS) {
 197                         dev_err(dev, "bad sys event %d\n", arr[i + 1]);
 198                         ret = -EINVAL;
 199                         goto out;
 200                 }
 201
 202                 if (arr[i + 2] < 0 ||
 203                     arr[i + 2] >= MAX_PRU_CHANNELS) {
 204                         dev_err(dev, "bad channel %d\n", arr[i + 2]);
 205                         ret = -EINVAL;
 206                         goto out;
 207                 }
 208
 209                 if (arr[i + 3] < 0 ||
 210                     arr[i + 3] >= MAX_PRU_HOST_INT) {
 211                         dev_err(dev, "bad irq %d\n", arr[i + 3]);
 212                         ret = -EINVAL;
 213                         goto out;
 214                 }
 215
 216                 pru->intc_config.sysev_to_ch[arr[i + 1]] = arr[i + 2];
 217                 dev_dbg(dev, "sysevt-to-ch[%d] -> %d\n", arr[i + 1],
 218                         arr[i + 2]);
 219
 220                 pru->intc_config.ch_to_host[arr[i + 2]] = arr[i + 3];
 221                 dev_dbg(dev, "chnl-to-host[%d] -> %d\n", arr[i + 2],
 222                         arr[i + 3]);
 223
 224                 has_irqs = true;
 225         }
 226
 227         /*
 228          * The property "ti,pru-interrupt-map" is used in a consumer node, but
 229          * need not necessarily have data for all referenced PRUs. Provide a
 230          * fallback to get the interrupt data from firmware for PRUs ith no
 231          * interrupt data.
 232          */
 233         if (!has_irqs) {
 234                 dev_dbg(dev, "no DT irqs, falling back to firmware intc rsc mode\n");
 235                 goto out;
 236         }
 237
 238         pru->dt_irqs = dt_irqs;
 239         ret = pruss_intc_configure(pru->pruss, &pru->intc_config);
 240         if (ret) {
 241                 dev_err(dev, "failed to configure intc %d\n", ret);
 242                 pru->dt_irqs = 0;
 243         }
 244
 245 out:
 246         kfree(arr);
 247
 248         return ret;
 249 }
 250
 251 static struct rproc *__pru_rproc_get(struct device_node *np, int index)
 252 {
 253         struct device_node *rproc_np = NULL;
 254         struct platform_device *pdev;
 255         struct rproc *rproc;
 256
 257         rproc_np = of_parse_phandle(np, "prus", index);
 258         if (!rproc_np || !of_device_is_available(rproc_np))
 259                 return ERR_PTR(-ENODEV);
 260
 261         pdev = of_find_device_by_node(rproc_np);
 262         of_node_put(rproc_np);
 263
 264         if (!pdev)
 265                 /* probably PRU not yet probed */
 266                 return ERR_PTR(-EPROBE_DEFER);
 267
 268         /* TODO: replace the crude string based check to make sure it is PRU */
 269         if (!strstr(dev_name(&pdev->dev), "pru")) {
 270                 put_device(&pdev->dev);
 271                 return ERR_PTR(-ENODEV);
 272         }
 273
 274         rproc = platform_get_drvdata(pdev);
 275         put_device(&pdev->dev);
 276         if (!rproc)
 277                 return ERR_PTR(-EPROBE_DEFER);
 278
 279         get_device(&rproc->dev);
 280
 281         return rproc;
 282 }
 283
 284 /**
 285  * pru_rproc_get() - get the PRU rproc instance from a device node
 286  * @np: the user/client device node
 287  * @index: index to use for the prus property
 288  *
 289  * This function looks through a client device node's "prus" property at index
 290  * @index and returns the rproc handle for a valid PRU remote processor if
 291  * found. The function allows only one user to own the PRU rproc resource at
 292  * a time. Caller must call pru_rproc_put() when done with using the rproc,
 293  * not required if the function returns a failure.
 294  *
 295  * Returns the rproc handle on success, and an ERR_PTR on failure using one
 296  * of the following error values
 297  *    -ENODEV if device is not found
 298  *    -EBUSY if PRU is already acquired by anyone
 299  *    -EPROBE_DEFER is PRU device is not probed yet
 300  */
 301 struct rproc *pru_rproc_get(struct device_node *np, int index)
 302 {
 303         struct rproc *rproc;
 304         struct pru_rproc *pru;
 305         const char *fw_name;
 306         struct device *dev;
 307         int ret;
 308
 309         rproc = __pru_rproc_get(np, index);
 310         if (IS_ERR(rproc))
 311                 return rproc;
 312
 313         pru = rproc->priv;
 314         dev = &rproc->dev;
 315
 316         mutex_lock(&pru->lock);
 317
 318         if (pru->client_np) {
 319                 mutex_unlock(&pru->lock);
 320                 put_device(&rproc->dev);
 321                 return ERR_PTR(-EBUSY);
 322         }
 323
 324         pru->client_np = np;
 325         rproc->deny_sysfs_ops = 1;
 326
 327         mutex_unlock(&pru->lock);
 328
 329         ret = of_property_read_string_index(np, "firmware-name", index,
 330                                             &fw_name);
 331         if (!ret) {
 332                 ret = pru_rproc_set_firmware(rproc, fw_name);
 333                 if (ret) {
 334                         dev_err(dev, "failed to set firmware: %d\n", ret);
 335                         goto err;
 336                 }
 337         }
 338
 339         ret = pru_rproc_intc_dt_config(pru, index);
 340         if (ret)
 341                 goto err;
 342
 343         return rproc;
 344
 345 err:
 346         pru_rproc_put(rproc);
 347         return ERR_PTR(ret);
 348 }
 349 EXPORT_SYMBOL_GPL(pru_rproc_get);
 350
 351 /**
 352  * pru_rproc_put() - release the PRU rproc resource
 353  * @rproc: the rproc resource to release
 354  *
 355  * Releases the PRU rproc resource and makes it available to other
 356  * users.
 357  */
 358 void pru_rproc_put(struct rproc *rproc)
 359 {
 360         struct pru_rproc *pru;
 361
 362         if (IS_ERR_OR_NULL(rproc))
 363                 return;
 364
 365         /* TODO: replace the crude string based check to make sure it is PRU */
 366         if (!strstr(dev_name(rproc->dev.parent), "pru"))
 367                 return;
 368
 369         pru = rproc->priv;
 370         if (!pru->client_np)
 371                 return;
 372
 373         if (pru->dt_irqs)
 374                 pruss_intc_unconfigure(pru->pruss, &pru->intc_config);
 375
 376         pru_rproc_set_firmware(rproc, NULL);
 377
 378         mutex_lock(&pru->lock);
 379         pru->client_np = NULL;
 380         rproc->deny_sysfs_ops = 0;
 381         mutex_unlock(&pru->lock);
 382
 383         put_device(&rproc->dev);
 384 }
 385 EXPORT_SYMBOL_GPL(pru_rproc_put);
 386
 387 /**
 388  * pru_rproc_set_ctable() - set the constant table index for the PRU
 389  * @rproc: the rproc instance of the PRU
 390  * @c: constant table index to set
 391  * @addr: physical address to set it to
 392  */
 393 int pru_rproc_set_ctable(struct rproc *rproc, enum pru_ctable_idx c, u32 addr)
 394 {
 395         struct pru_rproc *pru = rproc->priv;
 396         unsigned int reg;
 397         u32 mask, set;
 398         u16 idx;
 399         u16 idx_mask;
 400
 401         /* pointer is 16 bit and index is 8-bit so mask out the rest */
 402         idx_mask = (c >= PRU_C28) ? 0xFFFF : 0xFF;
 403
 404         /* ctable uses bit 8 and upwards only */
 405         idx = (addr >> 8) & idx_mask;
 406
 407         /* configurable ctable (i.e. C24) starts at PRU_CTRL_CTBIR0 */
 408         reg = PRU_CTRL_CTBIR0 + 4 * (c >> 1);
 409         mask = idx_mask << (16 * (c & 1));
 410         set = idx << (16 * (c & 1));
 411
 412         pru_control_set_reg(pru, reg, mask, set);
 413
 414         return 0;
 415 }
 416 EXPORT_SYMBOL_GPL(pru_rproc_set_ctable);
 417
 418 static inline u32 pru_debug_read_reg(struct pru_rproc *pru, unsigned int reg)
 419 {
 420         return readl_relaxed(pru->mem_regions[PRU_IOMEM_DEBUG].va + reg);
 421 }
 422
 423 static inline
 424 void pru_debug_write_reg(struct pru_rproc *pru, unsigned int reg, u32 val)
 425 {
 426         writel_relaxed(val, pru->mem_regions[PRU_IOMEM_DEBUG].va + reg);
 427 }
 428
 429 static int regs_show(struct seq_file *s, void *data)
 430 {
 431         struct rproc *rproc = s->private;
 432         struct pru_rproc *pru = rproc->priv;
 433         int i, nregs = 32;
 434         u32 pru_sts;
 435         int pru_is_running;
 436
 437         seq_puts(s, "============== Control Registers ==============\n");
 438         seq_printf(s, "CTRL      := 0x%08x\n",
 439                    pru_control_read_reg(pru, PRU_CTRL_CTRL));
 440         pru_sts = pru_control_read_reg(pru, PRU_CTRL_STS);
 441         seq_printf(s, "STS (PC)  := 0x%08x (0x%08x)\n", pru_sts, pru_sts << 2);
 442         seq_printf(s, "WAKEUP_EN := 0x%08x\n",
 443                    pru_control_read_reg(pru, PRU_CTRL_WAKEUP_EN));
 444         seq_printf(s, "CYCLE     := 0x%08x\n",
 445                    pru_control_read_reg(pru, PRU_CTRL_CYCLE));
 446         seq_printf(s, "STALL     := 0x%08x\n",
 447                    pru_control_read_reg(pru, PRU_CTRL_STALL));
 448         seq_printf(s, "CTBIR0    := 0x%08x\n",
 449                    pru_control_read_reg(pru, PRU_CTRL_CTBIR0));
 450         seq_printf(s, "CTBIR1    := 0x%08x\n",
 451                    pru_control_read_reg(pru, PRU_CTRL_CTBIR1));
 452         seq_printf(s, "CTPPR0    := 0x%08x\n",
 453                    pru_control_read_reg(pru, PRU_CTRL_CTPPR0));
 454         seq_printf(s, "CTPPR1    := 0x%08x\n",
 455                    pru_control_read_reg(pru, PRU_CTRL_CTPPR1));
 456
 457         seq_puts(s, "=============== Debug Registers ===============\n");
 458         pru_is_running = pru_control_read_reg(pru, PRU_CTRL_CTRL) &
 459                                 CTRL_CTRL_RUNSTATE;
 460         if (pru_is_running) {
 461                 seq_puts(s, "PRU is executing, cannot print/access debug registers.\n");
 462                 return 0;
 463         }
 464
 465         for (i = 0; i < nregs; i++) {
 466                 seq_printf(s, "GPREG%-2d := 0x%08x\tCT_REG%-2d := 0x%08x\n",
 467                            i, pru_debug_read_reg(pru, PRU_DEBUG_GPREG(i)),
 468                            i, pru_debug_read_reg(pru, PRU_DEBUG_CT_REG(i)));
 469         }
 470
 471         return 0;
 472 }
 473
 474 DEFINE_SHOW_ATTRIBUTE(regs);
 475
 476 /*
 477  * Control PRU single-step mode
 478  *
 479  * This is a debug helper function used for controlling the single-step
 480  * mode of the PRU. The PRU Debug registers are not accessible when the
 481  * PRU is in RUNNING state.
 482  *
 483  * Writing a non-zero value sets the PRU into single-step mode irrespective
 484  * of its previous state. The PRU mode is saved only on the first set into
 485  * a single-step mode. Writing a zero value will restore the PRU into its
 486  * original mode.
 487  */
 488 static int pru_rproc_debug_ss_set(void *data, u64 val)
 489 {
 490         struct rproc *rproc = data;
 491         struct pru_rproc *pru = rproc->priv;
 492         u32 reg_val;
 493
 494         val = val ? 1 : 0;
 495         if (!val && !pru->dbg_single_step)
 496                 return 0;
 497
 498         reg_val = pru_control_read_reg(pru, PRU_CTRL_CTRL);
 499
 500         if (val && !pru->dbg_single_step)
 501                 pru->dbg_continuous = reg_val;
 502
 503         if (val)
 504                 reg_val |= CTRL_CTRL_SINGLE_STEP | CTRL_CTRL_EN;
 505         else
 506                 reg_val = pru->dbg_continuous;
 507
 508         pru->dbg_single_step = val;
 509         pru_control_write_reg(pru, PRU_CTRL_CTRL, reg_val);
 510
 511         return 0;
 512 }
 513
 514 static int pru_rproc_debug_ss_get(void *data, u64 *val)
 515 {
 516         struct rproc *rproc = data;
 517         struct pru_rproc *pru = rproc->priv;
 518
 519         *val = pru->dbg_single_step;
 520
 521         return 0;
 522 }
 523 DEFINE_SIMPLE_ATTRIBUTE(pru_rproc_debug_ss_fops, pru_rproc_debug_ss_get,
 524                         pru_rproc_debug_ss_set, "%llu\n");
 525
 526 /*
 527  * Create PRU-specific debugfs entries
 528  *
 529  * The entries are created only if the parent remoteproc debugfs directory
 530  * exists, and will be cleaned up by the remoteproc core.
 531  */
 532 static void pru_rproc_create_debug_entries(struct rproc *rproc)
 533 {
 534         if (!rproc->dbg_dir)
 535                 return;
 536
 537         debugfs_create_file("regs", 0400, rproc->dbg_dir,
 538                             rproc, &regs_fops);
 539         debugfs_create_file("single_step", 0600, rproc->dbg_dir,
 540                             rproc, &pru_rproc_debug_ss_fops);
 541 }
 542
 543 /**
 544  * pru_rproc_mbox_callback() - inbound mailbox message handler
 545  * @client: mailbox client pointer used for requesting the mailbox channel
 546  * @data: mailbox payload
 547  *
 548  * This handler is invoked by omap's mailbox driver whenever a mailbox
 549  * message is received. Usually, the mailbox payload simply contains
 550  * the index of the virtqueue that is kicked by the PRU remote processor,
 551  * and we let remoteproc core handle it.
 552  *
 553  * In addition to virtqueue indices, we might also have some out-of-band
 554  * values that indicates different events. Those values are deliberately
 555  * very big so they don't coincide with virtqueue indices.
 556  */
 557 static void pru_rproc_mbox_callback(struct mbox_client *client, void *data)
 558 {
 559         struct pru_rproc *pru = container_of(client, struct pru_rproc, client);
 560         struct device *dev = &pru->rproc->dev;
 561         u32 msg = (u32)data;
 562
 563         dev_dbg(dev, "mbox msg: 0x%x\n", msg);
 564
 565         /* msg contains the index of the triggered vring */
 566         if (rproc_vq_interrupt(pru->rproc, msg) == IRQ_NONE)
 567                 dev_dbg(dev, "no message was found in vqid %d\n", msg);
 568 }
 569
 570 /**
 571  * pru_rproc_vring_interrupt() - interrupt handler for processing vrings
 572  * @irq: irq number associated with the PRU event MPU is listening on
 573  * @data: interrupt handler data, will be a PRU rproc structure
 574  *
 575  * This handler is used by the PRU remoteproc driver when using PRU system
 576  * events for processing the virtqueues. Unlike the mailbox IP, there is
 577  * no payload associated with an interrupt, so either a unique event is
 578  * used for each virtqueue kick, or a both virtqueues are processed on
 579  * a single event. The latter is chosen to conserve the usable PRU system
 580  * events.
 581  */
 582 static irqreturn_t pru_rproc_vring_interrupt(int irq, void *data)
 583 {
 584         struct pru_rproc *pru = data;
 585
 586         dev_dbg(&pru->rproc->dev, "got vring irq\n");
 587
 588         /* process incoming buffers on both the Rx and Tx vrings */
 589         rproc_vq_interrupt(pru->rproc, 0);
 590         rproc_vq_interrupt(pru->rproc, 1);
 591
 592         return IRQ_HANDLED;
 593 }
 594
 595 /* kick a virtqueue */
 596 static void pru_rproc_kick(struct rproc *rproc, int vq_id)
 597 {
 598         struct device *dev = &rproc->dev;
 599         struct pru_rproc *pru = rproc->priv;
 600         int ret;
 601
 602         dev_dbg(dev, "kicking vqid %d on PRU%d\n", vq_id, pru->id);
 603
 604         if (pru->irq_kick > 0) {
 605                 ret = pruss_intc_trigger(pru->irq_kick);
 606                 if (ret < 0)
 607                         dev_err(dev, "pruss_intc_trigger failed: %d\n", ret);
 608         } else if (pru->mbox) {
 609                 /*
 610                  * send the index of the triggered virtqueue in the mailbox
 611                  * payload
 612                  */
 613                 ret = mbox_send_message(pru->mbox, (void *)vq_id);
 614                 if (ret < 0)
 615                         dev_err(dev, "mbox_send_message failed: %d\n", ret);
 616         }
 617 }
 618
 619 /* start a PRU core */
 620 static int pru_rproc_start(struct rproc *rproc)
 621 {
 622         struct device *dev = &rproc->dev;
 623         struct pru_rproc *pru = rproc->priv;
 624         u32 val;
 625         int ret;
 626
 627         dev_dbg(dev, "starting PRU%d: entry-point = 0x%x\n",
 628                 pru->id, (rproc->bootaddr >> 2));
 629
 630         if (!list_empty(&pru->rproc->rvdevs)) {
 631                 if (!pru->mbox && (pru->irq_vring <= 0 || pru->irq_kick <= 0)) {
 632                         dev_err(dev, "virtio vring interrupt mechanisms are not provided\n");
 633                         ret = -EINVAL;
 634                         goto fail;
 635                 }
 636
 637                 if (!pru->mbox && pru->irq_vring > 0) {
 638                         ret = request_threaded_irq(pru->irq_vring, NULL,
 639                                                    pru_rproc_vring_interrupt,
 640                                                    IRQF_ONESHOT, dev_name(dev),
 641                                                    pru);
 642                         if (ret) {
 643                                 dev_err(dev, "failed to enable vring interrupt, ret = %d\n",
 644                                         ret);
 645                                 goto fail;
 646                         }
 647                 }
 648         }
 649
 650         val = CTRL_CTRL_EN | ((rproc->bootaddr >> 2) << 16);
 651         pru_control_write_reg(pru, PRU_CTRL_CTRL, val);
 652
 653         return 0;
 654
 655 fail:
 656         if (!pru->dt_irqs && pru->fw_has_intc_rsc)
 657                 pruss_intc_unconfigure(pru->pruss, &pru->intc_config);
 658         return ret;
 659 }
 660
 661 /* stop/disable a PRU core */
 662 static int pru_rproc_stop(struct rproc *rproc)
 663 {
 664         struct device *dev = &rproc->dev;
 665         struct pru_rproc *pru = rproc->priv;
 666         u32 val;
 667
 668         dev_dbg(dev, "stopping PRU%d\n", pru->id);
 669
 670         val = pru_control_read_reg(pru, PRU_CTRL_CTRL);
 671         val &= ~CTRL_CTRL_EN;
 672         pru_control_write_reg(pru, PRU_CTRL_CTRL, val);
 673
 674         if (!list_empty(&pru->rproc->rvdevs) &&
 675             !pru->mbox && pru->irq_vring > 0)
 676                 free_irq(pru->irq_vring, pru);
 677
 678         /* undo INTC config */
 679         if (!pru->dt_irqs && pru->fw_has_intc_rsc)
 680                 pruss_intc_unconfigure(pru->pruss, &pru->intc_config);
 681
 682         return 0;
 683 }
 684
 685 /*
 686  * parse the custom PRU interrupt map resource and configure the INTC
 687  * appropriately
 688  */
 689 static int pru_handle_vendor_intrmap(struct rproc *rproc,
 690                                      struct fw_rsc_vendor *rsc)
 691 {
 692         struct device *dev = rproc->dev.parent;
 693         struct pru_rproc *pru = rproc->priv;
 694         struct pruss *pruss = pru->pruss;
 695         struct pruss_event_chnl *event_chnl_map;
 696         struct fw_rsc_pruss_intrmap *intr_rsc =
 697                 (struct fw_rsc_pruss_intrmap *)rsc->data;
 698         int i, ret;
 699         s8 sys_evt, chnl, intr_no;
 700
 701         dev_dbg(dev, "version %d event_chnl_map_size %d event_chnl_map_addr 0x%x\n",
 702                 rsc->u.st.st_ver, intr_rsc->event_chnl_map_size,
 703                 intr_rsc->event_chnl_map_addr);
 704
 705         if (rsc->u.st.st_ver != 0) {
 706                 dev_err(dev, "only PRU interrupt resource version 0 supported\n");
 707                 return -EINVAL;
 708         }
 709
 710         if (intr_rsc->event_chnl_map_size < 0 ||
 711             intr_rsc->event_chnl_map_size >= MAX_PRU_SYS_EVENTS) {
 712                 dev_err(dev, "PRU interrupt resource has more events than present on hardware\n");
 713                 return -EINVAL;
 714         }
 715
 716         /*
 717          * XXX: The event_chnl_map_addr mapping is currently a pointer in device
 718          * memory, evaluate if this needs to be directly in firmware file.
 719          */
 720         event_chnl_map = pru_d_da_to_va(pru, intr_rsc->event_chnl_map_addr,
 721                                         intr_rsc->event_chnl_map_size *
 722                                         sizeof(*event_chnl_map));
 723         if (!event_chnl_map) {
 724                 dev_err(dev, "PRU interrupt resource has inadequate event_chnl_map configuration\n");
 725                 return -EINVAL;
 726         }
 727
 728         /* init intc_config to defaults */
 729         for (i = 0; i < ARRAY_SIZE(pru->intc_config.sysev_to_ch); i++)
 730                 pru->intc_config.sysev_to_ch[i] = -1;
 731
 732         for (i = 0; i < ARRAY_SIZE(pru->intc_config.ch_to_host); i++)
 733                 pru->intc_config.ch_to_host[i] = -1;
 734
 735         /* parse and fill in system event to interrupt channel mapping */
 736         for (i = 0; i < intr_rsc->event_chnl_map_size; i++) {
 737                 sys_evt = event_chnl_map[i].event;
 738                 chnl = event_chnl_map[i].chnl;
 739
 740                 if (sys_evt < 0 || sys_evt >= MAX_PRU_SYS_EVENTS) {
 741                         dev_err(dev, "[%d] bad sys event %d\n", i, sys_evt);
 742                         return -EINVAL;
 743                 }
 744                 if (chnl < 0 || chnl >= MAX_PRU_CHANNELS) {
 745                         dev_err(dev, "[%d] bad channel value %d\n", i, chnl);
 746                         return -EINVAL;
 747                 }
 748
 749                 pru->intc_config.sysev_to_ch[sys_evt] = chnl;
 750                 dev_dbg(dev, "sysevt-to-ch[%d] -> %d\n", sys_evt, chnl);
 751         }
 752
 753         /* parse and handle interrupt channel-to-host interrupt mapping */
 754         for (i = 0; i < MAX_PRU_CHANNELS; i++) {
 755                 intr_no = intr_rsc->chnl_host_intr_map[i];
 756                 if (intr_no < 0) {
 757                         dev_dbg(dev, "skip intr mapping for chnl %d\n", i);
 758                         continue;
 759                 }
 760
 761                 if (intr_no >= MAX_PRU_HOST_INT) {
 762                         dev_err(dev, "bad intr mapping for chnl %d, intr_no %d\n",
 763                                 i, intr_no);
 764                         return -EINVAL;
 765                 }
 766
 767                 pru->intc_config.ch_to_host[i] = intr_no;
 768                 dev_dbg(dev, "chnl-to-host[%d] -> %d\n", i, intr_no);
 769         }
 770
 771         pru->fw_has_intc_rsc = 1;
 772
 773         ret = pruss_intc_configure(pruss, &pru->intc_config);
 774         if (ret)
 775                 dev_err(dev, "failed to configure pruss intc %d\n", ret);
 776
 777         return ret;
 778 }
 779
 780 /* PRU-specific vendor resource handler */
 781 static int pru_rproc_handle_vendor_rsc(struct rproc *rproc,
 782                                        struct fw_rsc_vendor *rsc)
 783 {
 784         struct device *dev = rproc->dev.parent;
 785         struct pru_rproc *pru = rproc->priv;
 786         int ret = 0;
 787
 788         switch (rsc->u.st.st_type) {
 789         case PRUSS_RSC_INTRS:
 790                 if (!pru->dt_irqs)
 791                         ret = pru_handle_vendor_intrmap(rproc, rsc);
 792                 break;
 793         default:
 794                 dev_err(dev, "%s: cannot handle unknown type %d\n", __func__,
 795                         rsc->u.st.st_type);
 796                 ret = -EINVAL;
 797         }
 798
 799         return ret;
 800 }
 801
 802 /*
 803  * Convert PRU device address (data spaces only) to kernel virtual address
 804  *
 805  * Each PRU has access to all data memories within the PRUSS, accessible at
 806  * different ranges. So, look through both its primary and secondary Data
 807  * RAMs as well as any shared Data RAM to convert a PRU device address to
 808  * kernel virtual address. Data RAM0 is primary Data RAM for PRU0 and Data
 809  * RAM1 is primary Data RAM for PRU1.
 810  */
 811 static void *pru_d_da_to_va(struct pru_rproc *pru, u32 da, int len)
 812 {
 813         struct pruss_mem_region dram0, dram1, shrd_ram;
 814         struct pruss *pruss = pru->pruss;
 815         u32 offset;
 816         void *va = NULL;
 817
 818         if (len <= 0)
 819                 return NULL;
 820
 821         dram0 = pruss->mem_regions[PRUSS_MEM_DRAM0];
 822         dram1 = pruss->mem_regions[PRUSS_MEM_DRAM1];
 823         /* PRU1 has its local RAM addresses reversed */
 824         if (pru->id == 1)
 825                 swap(dram0, dram1);
 826         shrd_ram = pruss->mem_regions[PRUSS_MEM_SHRD_RAM2];
 827
 828         if (da >= pru->pdram_da && da + len <= pru->pdram_da + dram0.size) {
 829                 offset = da - pru->pdram_da;
 830                 va = (__force void *)(dram0.va + offset);
 831         } else if (da >= pru->sdram_da &&
 832                    da + len <= pru->sdram_da + dram1.size) {
 833                 offset = da - pru->sdram_da;
 834                 va = (__force void *)(dram1.va + offset);
 835         } else if (da >= pru->shrdram_da &&
 836                    da + len <= pru->shrdram_da + shrd_ram.size) {
 837                 offset = da - pru->shrdram_da;
 838                 va = (__force void *)(shrd_ram.va + offset);
 839         }
 840
 841         return va;
 842 }
 843
 844 /*
 845  * Convert PRU device address (instruction space) to kernel virtual address
 846  *
 847  * A PRU does not have an unified address space. Each PRU has its very own
 848  * private Instruction RAM, and its device address is identical to that of
 849  * its primary Data RAM device address.
 850  */
 851 static void *pru_i_da_to_va(struct pru_rproc *pru, u32 da, int len)
 852 {
 853         u32 offset;
 854         void *va = NULL;
 855
 856         if (len <= 0)
 857                 return NULL;
 858
 859         if (da >= pru->iram_da &&
 860             da + len <= pru->iram_da + pru->mem_regions[PRU_IOMEM_IRAM].size) {
 861                 offset = da - pru->iram_da;
 862                 va = (__force void *)(pru->mem_regions[PRU_IOMEM_IRAM].va +
 863                                       offset);
 864         }
 865
 866         return va;
 867 }
 868
 869 /* PRU-specific address translator */
 870 static void *pru_da_to_va(struct rproc *rproc, u64 da, int len, u32 flags)
 871 {
 872         struct pru_rproc *pru = rproc->priv;
 873         void *va;
 874         u32 exec_flag;
 875
 876         exec_flag = ((flags & RPROC_FLAGS_ELF_SHDR) ? flags & SHF_EXECINSTR :
 877                      ((flags & RPROC_FLAGS_ELF_PHDR) ? flags & PF_X : 0));
 878
 879         if (exec_flag)
 880                 va = pru_i_da_to_va(pru, da, len);
 881         else
 882                 va = pru_d_da_to_va(pru, da, len);
 883
 884         return va;
 885 }
 886
 887 static struct rproc_ops pru_rproc_ops = {
 888         .start                  = pru_rproc_start,
 889         .stop                   = pru_rproc_stop,
 890         .kick                   = pru_rproc_kick,
 891         .handle_vendor_rsc      = pru_rproc_handle_vendor_rsc,
 892         .da_to_va               = pru_da_to_va,
 893 };
 894
 895 /*
 896  * compute PRU id based on the IRAM addresses. The PRU IRAMs are
 897  * always at a particular offset within the PRUSS address space.
 898  * The other alternative is to use static data for each core (not a
 899  * hardware property to define it in DT), and the id can always be
 900  * computated using this inherent address logic.
 901  */
 902 static int pru_rproc_set_id(struct pru_rproc *pru)
 903 {
 904         int ret = 0;
 905         u32 mask1 = PRU0_IRAM_ADDR_MASK;
 906         u32 mask2 = PRU1_IRAM_ADDR_MASK;
 907
 908         if ((pru->mem_regions[PRU_IOMEM_IRAM].pa & mask1) == mask1)
 909                 pru->id = 0;
 910         else if ((pru->mem_regions[PRU_IOMEM_IRAM].pa & mask2) == mask2)
 911                 pru->id = 1;
 912         else
 913                 ret = -EINVAL;
 914
 915         return ret;
 916 }
 917
 918 static int pru_rproc_probe(struct platform_device *pdev)
 919 {
 920         struct device *dev = &pdev->dev;
 921         struct device_node *np = dev->of_node;
 922         struct platform_device *ppdev = to_platform_device(dev->parent);
 923         struct pru_rproc *pru;
 924         const char *fw_name;
 925         struct rproc *rproc = NULL;
 926         struct mbox_client *client;
 927         struct resource *res;
 928         int i, ret;
 929         const char *mem_names[PRU_IOMEM_MAX] = { "iram", "control", "debug" };
 930
 931         if (!np) {
 932                 dev_err(dev, "Non-DT platform device not supported\n");
 933                 return -ENODEV;
 934         }
 935
 936         ret = of_property_read_string(np, "firmware-name", &fw_name);
 937         if (ret) {
 938                 dev_err(dev, "unable to retrieve firmware-name %d\n", ret);
 939                 return ret;
 940         }
 941
 942         rproc = rproc_alloc(dev, pdev->name, &pru_rproc_ops, fw_name,
 943                             sizeof(*pru));
 944         if (!rproc) {
 945                 dev_err(dev, "rproc_alloc failed\n");
 946                 return -ENOMEM;
 947         }
 948         /* error recovery is not supported for PRUs */
 949         rproc->recovery_disabled = true;
 950
 951         /*
 952          * rproc_add will auto-boot the processor normally, but this is
 953          * not desired with PRU client driven boot-flow methodology. A PRU
 954          * application/client driver will boot the corresponding PRU
 955          * remote-processor as part of its state machine either through
 956          * the remoteproc sysfs interface or through the equivalent kernel API
 957          */
 958         rproc->auto_boot = false;
 959
 960         pru = rproc->priv;
 961         pru->pruss = platform_get_drvdata(ppdev);
 962         pru->rproc = rproc;
 963         pru->fw_name = fw_name;
 964         spin_lock_init(&pru->rmw_lock);
 965         mutex_init(&pru->lock);
 966
 967         /* XXX: get this from match data if different in the future */
 968         pru->iram_da = 0;
 969         pru->pdram_da = 0;
 970         pru->sdram_da = 0x2000;
 971         pru->shrdram_da = 0x10000;
 972
 973         for (i = 0; i < ARRAY_SIZE(mem_names); i++) {
 974                 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 975                                                    mem_names[i]);
 976                 pru->mem_regions[i].va = devm_ioremap_resource(dev, res);
 977                 if (IS_ERR(pru->mem_regions[i].va)) {
 978                         dev_err(dev, "failed to parse and map memory resource %d %s\n",
 979                                 i, mem_names[i]);
 980                         ret = PTR_ERR(pru->mem_regions[i].va);
 981                         goto free_rproc;
 982                 }
 983                 pru->mem_regions[i].pa = res->start;
 984                 pru->mem_regions[i].size = resource_size(res);
 985
 986                 dev_dbg(dev, "memory %8s: pa %pa size 0x%zx va %p\n",
 987                         mem_names[i], &pru->mem_regions[i].pa,
 988                         pru->mem_regions[i].size, pru->mem_regions[i].va);
 989         }
 990
 991         ret = pru_rproc_set_id(pru);
 992         if (ret < 0)
 993                 goto free_rproc;
 994
 995         platform_set_drvdata(pdev, rproc);
 996
 997         /* get optional vring and kick interrupts for supporting virtio rpmsg */
 998         pru->irq_vring = platform_get_irq_byname(pdev, "vring");
 999         if (pru->irq_vring <= 0) {
1000                 ret = pru->irq_vring;
1001                 if (ret == -EPROBE_DEFER)
1002                         goto free_rproc;
1003                 dev_dbg(dev, "unable to get vring interrupt, status = %d\n",
1004                         ret);
1005         }
1006
1007         pru->irq_kick = platform_get_irq_byname(pdev, "kick");
1008         if (pru->irq_kick <= 0) {
1009                 ret = pru->irq_kick;
1010                 if (ret == -EPROBE_DEFER)
1011                         goto free_rproc;
1012                 dev_dbg(dev, "unable to get kick interrupt, status = %d\n",
1013                         ret);
1014         }
1015
1016         /*
1017          * get optional mailbox for virtio rpmsg signalling if vring and kick
1018          * interrupts are not specified for OMAP architecture based SoCs
1019          */
1020         if (pru->irq_vring <= 0 && pru->irq_kick <= 0 &&
1021             !of_device_is_compatible(np, "ti,k2g-pru")) {
1022                 client = &pru->client;
1023                 client->dev = dev;
1024                 client->tx_done = NULL;
1025                 client->rx_callback = pru_rproc_mbox_callback;
1026                 client->tx_block = false;
1027                 client->knows_txdone = false;
1028                 pru->mbox = mbox_request_channel(client, 0);
1029                 if (IS_ERR(pru->mbox)) {
1030                         ret = PTR_ERR(pru->mbox);
1031                         pru->mbox = NULL;
1032                         dev_dbg(dev, "unable to get mailbox channel, status = %d\n",
1033                                 ret);
1034                 }
1035         }
1036
1037         ret = rproc_add(pru->rproc);
1038         if (ret) {
1039                 dev_err(dev, "rproc_add failed: %d\n", ret);
1040                 goto put_mbox;
1041         }
1042
1043         pru_rproc_create_debug_entries(rproc);
1044
1045         dev_info(dev, "PRU rproc node %s probed successfully\n", np->full_name);
1046
1047         return 0;
1048
1049 put_mbox:
1050         mbox_free_channel(pru->mbox);
1051 free_rproc:
1052         rproc_free(rproc);
1053         return ret;
1054 }
1055
1056 static int pru_rproc_remove(struct platform_device *pdev)
1057 {
1058         struct device *dev = &pdev->dev;
1059         struct rproc *rproc = platform_get_drvdata(pdev);
1060         struct pru_rproc *pru = rproc->priv;
1061
1062         dev_info(dev, "%s: removing rproc %s\n", __func__, rproc->name);
1063
1064         mbox_free_channel(pru->mbox);
1065
1066         rproc_del(rproc);
1067         rproc_free(rproc);
1068
1069         return 0;
1070 }
1071
1072 static const struct of_device_id pru_rproc_match[] = {
1073         { .compatible = "ti,am3356-pru", },
1074         { .compatible = "ti,am4376-pru", },
1075         { .compatible = "ti,am5728-pru", },
1076         { .compatible = "ti,k2g-pru",    },
1077         {},
1078 };
1079 MODULE_DEVICE_TABLE(of, pru_rproc_match);
1080
1081 static struct platform_driver pru_rproc_driver = {
1082         .driver = {
1083                 .name   = "pru-rproc",
1084                 .of_match_table = pru_rproc_match,
1085                 .suppress_bind_attrs = true,
1086         },
1087         .probe  = pru_rproc_probe,
1088         .remove = pru_rproc_remove,
1089 };
1090 module_platform_driver(pru_rproc_driver);
1091
1092 MODULE_AUTHOR("Suman Anna <s-anna@ti.com>");
1093 MODULE_DESCRIPTION("PRU-ICSS Remote Processor Driver");
1094 MODULE_LICENSE("GPL v2");