drivers/remoteproc/imx_rproc.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2017 Pengutronix, Oleksij Rempel <kernel@pengutronix.de>
   4  */
   5
   6 #include <linux/arm-smccc.h>
   7 #include <linux/clk.h>
   8 #include <linux/err.h>
   9 #include <linux/interrupt.h>
  10 #include <linux/kernel.h>
  11 #include <linux/mailbox_client.h>
  12 #include <linux/mfd/syscon.h>
  13 #include <linux/module.h>
  14 #include <linux/of_address.h>
  15 #include <linux/of_reserved_mem.h>
  16 #include <linux/of_device.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/regmap.h>
  19 #include <linux/remoteproc.h>
  20 #include <linux/workqueue.h>
  21
  22 #include "remoteproc_internal.h"
  23
  24 #define IMX7D_SRC_SCR                   0x0C
  25 #define IMX7D_ENABLE_M4                 BIT(3)
  26 #define IMX7D_SW_M4P_RST                BIT(2)
  27 #define IMX7D_SW_M4C_RST                BIT(1)
  28 #define IMX7D_SW_M4C_NON_SCLR_RST       BIT(0)
  29
  30 #define IMX7D_M4_RST_MASK               (IMX7D_ENABLE_M4 | IMX7D_SW_M4P_RST \
  31                                          | IMX7D_SW_M4C_RST \
  32                                          | IMX7D_SW_M4C_NON_SCLR_RST)
  33
  34 #define IMX7D_M4_START                  (IMX7D_ENABLE_M4 | IMX7D_SW_M4P_RST \
  35                                          | IMX7D_SW_M4C_RST)
  36 #define IMX7D_M4_STOP                   IMX7D_SW_M4C_NON_SCLR_RST
  37
  38 /* Address: 0x020D8000 */
  39 #define IMX6SX_SRC_SCR                  0x00
  40 #define IMX6SX_ENABLE_M4                BIT(22)
  41 #define IMX6SX_SW_M4P_RST               BIT(12)
  42 #define IMX6SX_SW_M4C_NON_SCLR_RST      BIT(4)
  43 #define IMX6SX_SW_M4C_RST               BIT(3)
  44
  45 #define IMX6SX_M4_START                 (IMX6SX_ENABLE_M4 | IMX6SX_SW_M4P_RST \
  46                                          | IMX6SX_SW_M4C_RST)
  47 #define IMX6SX_M4_STOP                  IMX6SX_SW_M4C_NON_SCLR_RST
  48 #define IMX6SX_M4_RST_MASK              (IMX6SX_ENABLE_M4 | IMX6SX_SW_M4P_RST \
  49                                          | IMX6SX_SW_M4C_NON_SCLR_RST \
  50                                          | IMX6SX_SW_M4C_RST)
  51
  52 #define IMX_RPROC_MEM_MAX               32
  53
  54 #define IMX_SIP_RPROC                   0xC2000005
  55 #define IMX_SIP_RPROC_START             0x00
  56 #define IMX_SIP_RPROC_STARTED           0x01
  57 #define IMX_SIP_RPROC_STOP              0x02
  58
  59 /**
  60  * struct imx_rproc_mem - slim internal memory structure
  61  * @cpu_addr: MPU virtual address of the memory region
  62  * @sys_addr: Bus address used to access the memory region
  63  * @size: Size of the memory region
  64  */
  65 struct imx_rproc_mem {
  66         void __iomem *cpu_addr;
  67         phys_addr_t sys_addr;
  68         size_t size;
  69 };
  70
  71 /* att flags */
  72 /* M4 own area. Can be mapped at probe */
  73 #define ATT_OWN         BIT(1)
  74 #define ATT_IOMEM       BIT(2)
  75
  76 /* address translation table */
  77 struct imx_rproc_att {
  78         u32 da; /* device address (From Cortex M4 view)*/
  79         u32 sa; /* system bus address */
  80         u32 size; /* size of reg range */
  81         int flags;
  82 };
  83
  84 /* Remote core start/stop method */
  85 enum imx_rproc_method {
  86         IMX_RPROC_NONE,
  87         /* Through syscon regmap */
  88         IMX_RPROC_MMIO,
  89         /* Through ARM SMCCC */
  90         IMX_RPROC_SMC,
  91 };
  92
  93 struct imx_rproc_dcfg {
  94         u32                             src_reg;
  95         u32                             src_mask;
  96         u32                             src_start;
  97         u32                             src_stop;
  98         const struct imx_rproc_att      *att;
  99         size_t                          att_size;
 100         enum imx_rproc_method           method;
 101 };
 102
 103 struct imx_rproc {
 104         struct device                   *dev;
 105         struct regmap                   *regmap;
 106         struct rproc                    *rproc;
 107         const struct imx_rproc_dcfg     *dcfg;
 108         struct imx_rproc_mem            mem[IMX_RPROC_MEM_MAX];
 109         struct clk                      *clk;
 110         struct mbox_client              cl;
 111         struct mbox_chan                *tx_ch;
 112         struct mbox_chan                *rx_ch;
 113         struct work_struct              rproc_work;
 114         struct workqueue_struct         *workqueue;
 115         void __iomem                    *rsc_table;
 116 };
 117
 118 static const struct imx_rproc_att imx_rproc_att_imx8mn[] = {
 119         /* dev addr , sys addr  , size      , flags */
 120         /* ITCM   */
 121         { 0x00000000, 0x007E0000, 0x00020000, ATT_OWN | ATT_IOMEM },
 122         /* OCRAM_S */
 123         { 0x00180000, 0x00180000, 0x00009000, 0 },
 124         /* OCRAM */
 125         { 0x00900000, 0x00900000, 0x00020000, 0 },
 126         /* OCRAM */
 127         { 0x00920000, 0x00920000, 0x00020000, 0 },
 128         /* OCRAM */
 129         { 0x00940000, 0x00940000, 0x00050000, 0 },
 130         /* QSPI Code - alias */
 131         { 0x08000000, 0x08000000, 0x08000000, 0 },
 132         /* DDR (Code) - alias */
 133         { 0x10000000, 0x40000000, 0x0FFE0000, 0 },
 134         /* DTCM */
 135         { 0x20000000, 0x00800000, 0x00020000, ATT_OWN | ATT_IOMEM },
 136         /* OCRAM_S - alias */
 137         { 0x20180000, 0x00180000, 0x00008000, ATT_OWN },
 138         /* OCRAM */
 139         { 0x20200000, 0x00900000, 0x00020000, ATT_OWN },
 140         /* OCRAM */
 141         { 0x20220000, 0x00920000, 0x00020000, ATT_OWN },
 142         /* OCRAM */
 143         { 0x20240000, 0x00940000, 0x00040000, ATT_OWN },
 144         /* DDR (Data) */
 145         { 0x40000000, 0x40000000, 0x80000000, 0 },
 146 };
 147
 148 static const struct imx_rproc_att imx_rproc_att_imx8mq[] = {
 149         /* dev addr , sys addr  , size      , flags */
 150         /* TCML - alias */
 151         { 0x00000000, 0x007e0000, 0x00020000, ATT_IOMEM},
 152         /* OCRAM_S */
 153         { 0x00180000, 0x00180000, 0x00008000, 0 },
 154         /* OCRAM */
 155         { 0x00900000, 0x00900000, 0x00020000, 0 },
 156         /* OCRAM */
 157         { 0x00920000, 0x00920000, 0x00020000, 0 },
 158         /* QSPI Code - alias */
 159         { 0x08000000, 0x08000000, 0x08000000, 0 },
 160         /* DDR (Code) - alias */
 161         { 0x10000000, 0x80000000, 0x0FFE0000, 0 },
 162         /* TCML */
 163         { 0x1FFE0000, 0x007E0000, 0x00020000, ATT_OWN  | ATT_IOMEM},
 164         /* TCMU */
 165         { 0x20000000, 0x00800000, 0x00020000, ATT_OWN  | ATT_IOMEM},
 166         /* OCRAM_S */
 167         { 0x20180000, 0x00180000, 0x00008000, ATT_OWN },
 168         /* OCRAM */
 169         { 0x20200000, 0x00900000, 0x00020000, ATT_OWN },
 170         /* OCRAM */
 171         { 0x20220000, 0x00920000, 0x00020000, ATT_OWN },
 172         /* DDR (Data) */
 173         { 0x40000000, 0x40000000, 0x80000000, 0 },
 174 };
 175
 176 static const struct imx_rproc_att imx_rproc_att_imx8ulp[] = {
 177         {0x1FFC0000, 0x1FFC0000, 0xC0000, ATT_OWN},
 178         {0x21000000, 0x21000000, 0x10000, ATT_OWN},
 179         {0x80000000, 0x80000000, 0x60000000, 0}
 180 };
 181
 182 static const struct imx_rproc_att imx_rproc_att_imx7ulp[] = {
 183         {0x1FFD0000, 0x1FFD0000, 0x30000, ATT_OWN},
 184         {0x20000000, 0x20000000, 0x10000, ATT_OWN},
 185         {0x2F000000, 0x2F000000, 0x20000, ATT_OWN},
 186         {0x2F020000, 0x2F020000, 0x20000, ATT_OWN},
 187         {0x60000000, 0x60000000, 0x40000000, 0}
 188 };
 189
 190 static const struct imx_rproc_att imx_rproc_att_imx7d[] = {
 191         /* dev addr , sys addr  , size      , flags */
 192         /* OCRAM_S (M4 Boot code) - alias */
 193         { 0x00000000, 0x00180000, 0x00008000, 0 },
 194         /* OCRAM_S (Code) */
 195         { 0x00180000, 0x00180000, 0x00008000, ATT_OWN },
 196         /* OCRAM (Code) - alias */
 197         { 0x00900000, 0x00900000, 0x00020000, 0 },
 198         /* OCRAM_EPDC (Code) - alias */
 199         { 0x00920000, 0x00920000, 0x00020000, 0 },
 200         /* OCRAM_PXP (Code) - alias */
 201         { 0x00940000, 0x00940000, 0x00008000, 0 },
 202         /* TCML (Code) */
 203         { 0x1FFF8000, 0x007F8000, 0x00008000, ATT_OWN | ATT_IOMEM },
 204         /* DDR (Code) - alias, first part of DDR (Data) */
 205         { 0x10000000, 0x80000000, 0x0FFF0000, 0 },
 206
 207         /* TCMU (Data) */
 208         { 0x20000000, 0x00800000, 0x00008000, ATT_OWN | ATT_IOMEM },
 209         /* OCRAM (Data) */
 210         { 0x20200000, 0x00900000, 0x00020000, 0 },
 211         /* OCRAM_EPDC (Data) */
 212         { 0x20220000, 0x00920000, 0x00020000, 0 },
 213         /* OCRAM_PXP (Data) */
 214         { 0x20240000, 0x00940000, 0x00008000, 0 },
 215         /* DDR (Data) */
 216         { 0x80000000, 0x80000000, 0x60000000, 0 },
 217 };
 218
 219 static const struct imx_rproc_att imx_rproc_att_imx6sx[] = {
 220         /* dev addr , sys addr  , size      , flags */
 221         /* TCML (M4 Boot Code) - alias */
 222         { 0x00000000, 0x007F8000, 0x00008000, ATT_IOMEM },
 223         /* OCRAM_S (Code) */
 224         { 0x00180000, 0x008F8000, 0x00004000, 0 },
 225         /* OCRAM_S (Code) - alias */
 226         { 0x00180000, 0x008FC000, 0x00004000, 0 },
 227         /* TCML (Code) */
 228         { 0x1FFF8000, 0x007F8000, 0x00008000, ATT_OWN | ATT_IOMEM },
 229         /* DDR (Code) - alias, first part of DDR (Data) */
 230         { 0x10000000, 0x80000000, 0x0FFF8000, 0 },
 231
 232         /* TCMU (Data) */
 233         { 0x20000000, 0x00800000, 0x00008000, ATT_OWN | ATT_IOMEM },
 234         /* OCRAM_S (Data) - alias? */
 235         { 0x208F8000, 0x008F8000, 0x00004000, 0 },
 236         /* DDR (Data) */
 237         { 0x80000000, 0x80000000, 0x60000000, 0 },
 238 };
 239
 240 static const struct imx_rproc_dcfg imx_rproc_cfg_imx8mn = {
 241         .att            = imx_rproc_att_imx8mn,
 242         .att_size       = ARRAY_SIZE(imx_rproc_att_imx8mn),
 243         .method         = IMX_RPROC_SMC,
 244 };
 245
 246 static const struct imx_rproc_dcfg imx_rproc_cfg_imx8mq = {
 247         .src_reg        = IMX7D_SRC_SCR,
 248         .src_mask       = IMX7D_M4_RST_MASK,
 249         .src_start      = IMX7D_M4_START,
 250         .src_stop       = IMX7D_M4_STOP,
 251         .att            = imx_rproc_att_imx8mq,
 252         .att_size       = ARRAY_SIZE(imx_rproc_att_imx8mq),
 253         .method         = IMX_RPROC_MMIO,
 254 };
 255
 256 static const struct imx_rproc_dcfg imx_rproc_cfg_imx8ulp = {
 257         .att            = imx_rproc_att_imx8ulp,
 258         .att_size       = ARRAY_SIZE(imx_rproc_att_imx8ulp),
 259         .method         = IMX_RPROC_NONE,
 260 };
 261
 262 static const struct imx_rproc_dcfg imx_rproc_cfg_imx7ulp = {
 263         .att            = imx_rproc_att_imx7ulp,
 264         .att_size       = ARRAY_SIZE(imx_rproc_att_imx7ulp),
 265         .method         = IMX_RPROC_NONE,
 266 };
 267
 268 static const struct imx_rproc_dcfg imx_rproc_cfg_imx7d = {
 269         .src_reg        = IMX7D_SRC_SCR,
 270         .src_mask       = IMX7D_M4_RST_MASK,
 271         .src_start      = IMX7D_M4_START,
 272         .src_stop       = IMX7D_M4_STOP,
 273         .att            = imx_rproc_att_imx7d,
 274         .att_size       = ARRAY_SIZE(imx_rproc_att_imx7d),
 275         .method         = IMX_RPROC_MMIO,
 276 };
 277
 278 static const struct imx_rproc_dcfg imx_rproc_cfg_imx6sx = {
 279         .src_reg        = IMX6SX_SRC_SCR,
 280         .src_mask       = IMX6SX_M4_RST_MASK,
 281         .src_start      = IMX6SX_M4_START,
 282         .src_stop       = IMX6SX_M4_STOP,
 283         .att            = imx_rproc_att_imx6sx,
 284         .att_size       = ARRAY_SIZE(imx_rproc_att_imx6sx),
 285         .method         = IMX_RPROC_MMIO,
 286 };
 287
 288 static int imx_rproc_start(struct rproc *rproc)
 289 {
 290         struct imx_rproc *priv = rproc->priv;
 291         const struct imx_rproc_dcfg *dcfg = priv->dcfg;
 292         struct device *dev = priv->dev;
 293         struct arm_smccc_res res;
 294         int ret;
 295
 296         switch (dcfg->method) {
 297         case IMX_RPROC_MMIO:
 298                 ret = regmap_update_bits(priv->regmap, dcfg->src_reg, dcfg->src_mask,
 299                                          dcfg->src_start);
 300                 break;
 301         case IMX_RPROC_SMC:
 302                 arm_smccc_smc(IMX_SIP_RPROC, IMX_SIP_RPROC_START, 0, 0, 0, 0, 0, 0, &res);
 303                 ret = res.a0;
 304                 break;
 305         default:
 306                 return -EOPNOTSUPP;
 307         }
 308
 309         if (ret)
 310                 dev_err(dev, "Failed to enable remote core!\n");
 311
 312         return ret;
 313 }
 314
 315 static int imx_rproc_stop(struct rproc *rproc)
 316 {
 317         struct imx_rproc *priv = rproc->priv;
 318         const struct imx_rproc_dcfg *dcfg = priv->dcfg;
 319         struct device *dev = priv->dev;
 320         struct arm_smccc_res res;
 321         int ret;
 322
 323         switch (dcfg->method) {
 324         case IMX_RPROC_MMIO:
 325                 ret = regmap_update_bits(priv->regmap, dcfg->src_reg, dcfg->src_mask,
 326                                          dcfg->src_stop);
 327                 break;
 328         case IMX_RPROC_SMC:
 329                 arm_smccc_smc(IMX_SIP_RPROC, IMX_SIP_RPROC_STOP, 0, 0, 0, 0, 0, 0, &res);
 330                 ret = res.a0;
 331                 if (res.a1)
 332                         dev_info(dev, "Not in wfi, force stopped\n");
 333                 break;
 334         default:
 335                 return -EOPNOTSUPP;
 336         }
 337
 338         if (ret)
 339                 dev_err(dev, "Failed to stop remote core\n");
 340
 341         return ret;
 342 }
 343
 344 static int imx_rproc_da_to_sys(struct imx_rproc *priv, u64 da,
 345                                size_t len, u64 *sys, bool *is_iomem)
 346 {
 347         const struct imx_rproc_dcfg *dcfg = priv->dcfg;
 348         int i;
 349
 350         /* parse address translation table */
 351         for (i = 0; i < dcfg->att_size; i++) {
 352                 const struct imx_rproc_att *att = &dcfg->att[i];
 353
 354                 if (da >= att->da && da + len < att->da + att->size) {
 355                         unsigned int offset = da - att->da;
 356
 357                         *sys = att->sa + offset;
 358                         if (is_iomem)
 359                                 *is_iomem = att->flags & ATT_IOMEM;
 360                         return 0;
 361                 }
 362         }
 363
 364         dev_warn(priv->dev, "Translation failed: da = 0x%llx len = 0x%zx\n",
 365                  da, len);
 366         return -ENOENT;
 367 }
 368
 369 static void *imx_rproc_da_to_va(struct rproc *rproc, u64 da, size_t len, bool *is_iomem)
 370 {
 371         struct imx_rproc *priv = rproc->priv;
 372         void *va = NULL;
 373         u64 sys;
 374         int i;
 375
 376         if (len == 0)
 377                 return NULL;
 378
 379         /*
 380          * On device side we have many aliases, so we need to convert device
 381          * address (M4) to system bus address first.
 382          */
 383         if (imx_rproc_da_to_sys(priv, da, len, &sys, is_iomem))
 384                 return NULL;
 385
 386         for (i = 0; i < IMX_RPROC_MEM_MAX; i++) {
 387                 if (sys >= priv->mem[i].sys_addr && sys + len <
 388                     priv->mem[i].sys_addr +  priv->mem[i].size) {
 389                         unsigned int offset = sys - priv->mem[i].sys_addr;
 390                         /* __force to make sparse happy with type conversion */
 391                         va = (__force void *)(priv->mem[i].cpu_addr + offset);
 392                         break;
 393                 }
 394         }
 395
 396         dev_dbg(&rproc->dev, "da = 0x%llx len = 0x%zx va = 0x%p\n",
 397                 da, len, va);
 398
 399         return va;
 400 }
 401
 402 static int imx_rproc_mem_alloc(struct rproc *rproc,
 403                                struct rproc_mem_entry *mem)
 404 {
 405         struct device *dev = rproc->dev.parent;
 406         void *va;
 407
 408         dev_dbg(dev, "map memory: %p+%zx\n", &mem->dma, mem->len);
 409         va = ioremap_wc(mem->dma, mem->len);
 410         if (IS_ERR_OR_NULL(va)) {
 411                 dev_err(dev, "Unable to map memory region: %p+%zx\n",
 412                         &mem->dma, mem->len);
 413                 return -ENOMEM;
 414         }
 415
 416         /* Update memory entry va */
 417         mem->va = va;
 418
 419         return 0;
 420 }
 421
 422 static int imx_rproc_mem_release(struct rproc *rproc,
 423                                  struct rproc_mem_entry *mem)
 424 {
 425         dev_dbg(rproc->dev.parent, "unmap memory: %pa\n", &mem->dma);
 426         iounmap(mem->va);
 427
 428         return 0;
 429 }
 430
 431 static int imx_rproc_prepare(struct rproc *rproc)
 432 {
 433         struct imx_rproc *priv = rproc->priv;
 434         struct device_node *np = priv->dev->of_node;
 435         struct of_phandle_iterator it;
 436         struct rproc_mem_entry *mem;
 437         struct reserved_mem *rmem;
 438         u32 da;
 439
 440         /* Register associated reserved memory regions */
 441         of_phandle_iterator_init(&it, np, "memory-region", NULL, 0);
 442         while (of_phandle_iterator_next(&it) == 0) {
 443                 /*
 444                  * Ignore the first memory region which will be used vdev buffer.
 445                  * No need to do extra handlings, rproc_add_virtio_dev will handle it.
 446                  */
 447                 if (!strcmp(it.node->name, "vdev0buffer"))
 448                         continue;
 449
 450                 if (!strcmp(it.node->name, "rsc-table"))
 451                         continue;
 452
 453                 rmem = of_reserved_mem_lookup(it.node);
 454                 if (!rmem) {
 455                         dev_err(priv->dev, "unable to acquire memory-region\n");
 456                         return -EINVAL;
 457                 }
 458
 459                 /* No need to translate pa to da, i.MX use same map */
 460                 da = rmem->base;
 461
 462                 /* Register memory region */
 463                 mem = rproc_mem_entry_init(priv->dev, NULL, (dma_addr_t)rmem->base, rmem->size, da,
 464                                            imx_rproc_mem_alloc, imx_rproc_mem_release,
 465                                            it.node->name);
 466
 467                 if (mem)
 468                         rproc_coredump_add_segment(rproc, da, rmem->size);
 469                 else
 470                         return -ENOMEM;
 471
 472                 rproc_add_carveout(rproc, mem);
 473         }
 474
 475         return  0;
 476 }
 477
 478 static int imx_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw)
 479 {
 480         int ret;
 481
 482         ret = rproc_elf_load_rsc_table(rproc, fw);
 483         if (ret)
 484                 dev_info(&rproc->dev, "No resource table in elf\n");
 485
 486         return 0;
 487 }
 488
 489 static void imx_rproc_kick(struct rproc *rproc, int vqid)
 490 {
 491         struct imx_rproc *priv = rproc->priv;
 492         int err;
 493         __u32 mmsg;
 494
 495         if (!priv->tx_ch) {
 496                 dev_err(priv->dev, "No initialized mbox tx channel\n");
 497                 return;
 498         }
 499
 500         /*
 501          * Send the index of the triggered virtqueue as the mu payload.
 502          * Let remote processor know which virtqueue is used.
 503          */
 504         mmsg = vqid << 16;
 505
 506         err = mbox_send_message(priv->tx_ch, (void *)&mmsg);
 507         if (err < 0)
 508                 dev_err(priv->dev, "%s: failed (%d, err:%d)\n",
 509                         __func__, vqid, err);
 510 }
 511
 512 static int imx_rproc_attach(struct rproc *rproc)
 513 {
 514         return 0;
 515 }
 516
 517 static struct resource_table *imx_rproc_get_loaded_rsc_table(struct rproc *rproc, size_t *table_sz)
 518 {
 519         struct imx_rproc *priv = rproc->priv;
 520
 521         /* The resource table has already been mapped in imx_rproc_addr_init */
 522         if (!priv->rsc_table)
 523                 return NULL;
 524
 525         *table_sz = SZ_1K;
 526         return (struct resource_table *)priv->rsc_table;
 527 }
 528
 529 static const struct rproc_ops imx_rproc_ops = {
 530         .prepare        = imx_rproc_prepare,
 531         .attach         = imx_rproc_attach,
 532         .start          = imx_rproc_start,
 533         .stop           = imx_rproc_stop,
 534         .kick           = imx_rproc_kick,
 535         .da_to_va       = imx_rproc_da_to_va,
 536         .load           = rproc_elf_load_segments,
 537         .parse_fw       = imx_rproc_parse_fw,
 538         .find_loaded_rsc_table = rproc_elf_find_loaded_rsc_table,
 539         .get_loaded_rsc_table = imx_rproc_get_loaded_rsc_table,
 540         .sanity_check   = rproc_elf_sanity_check,
 541         .get_boot_addr  = rproc_elf_get_boot_addr,
 542 };
 543
 544 static int imx_rproc_addr_init(struct imx_rproc *priv,
 545                                struct platform_device *pdev)
 546 {
 547         const struct imx_rproc_dcfg *dcfg = priv->dcfg;
 548         struct device *dev = &pdev->dev;
 549         struct device_node *np = dev->of_node;
 550         int a, b = 0, err, nph;
 551
 552         /* remap required addresses */
 553         for (a = 0; a < dcfg->att_size; a++) {
 554                 const struct imx_rproc_att *att = &dcfg->att[a];
 555
 556                 if (!(att->flags & ATT_OWN))
 557                         continue;
 558
 559                 if (b >= IMX_RPROC_MEM_MAX)
 560                         break;
 561
 562                 if (att->flags & ATT_IOMEM)
 563                         priv->mem[b].cpu_addr = devm_ioremap(&pdev->dev,
 564                                                              att->sa, att->size);
 565                 else
 566                         priv->mem[b].cpu_addr = devm_ioremap_wc(&pdev->dev,
 567                                                                 att->sa, att->size);
 568                 if (!priv->mem[b].cpu_addr) {
 569                         dev_err(dev, "failed to remap %#x bytes from %#x\n", att->size, att->sa);
 570                         return -ENOMEM;
 571                 }
 572                 priv->mem[b].sys_addr = att->sa;
 573                 priv->mem[b].size = att->size;
 574                 b++;
 575         }
 576
 577         /* memory-region is optional property */
 578         nph = of_count_phandle_with_args(np, "memory-region", NULL);
 579         if (nph <= 0)
 580                 return 0;
 581
 582         /* remap optional addresses */
 583         for (a = 0; a < nph; a++) {
 584                 struct device_node *node;
 585                 struct resource res;
 586
 587                 node = of_parse_phandle(np, "memory-region", a);
 588                 /* Not map vdevbuffer, vdevring region */
 589                 if (!strncmp(node->name, "vdev", strlen("vdev")))
 590                         continue;
 591                 err = of_address_to_resource(node, 0, &res);
 592                 if (err) {
 593                         dev_err(dev, "unable to resolve memory region\n");
 594                         return err;
 595                 }
 596
 597                 of_node_put(node);
 598
 599                 if (b >= IMX_RPROC_MEM_MAX)
 600                         break;
 601
 602                 /* Not use resource version, because we might share region */
 603                 priv->mem[b].cpu_addr = devm_ioremap(&pdev->dev, res.start, resource_size(&res));
 604                 if (!priv->mem[b].cpu_addr) {
 605                         dev_err(dev, "failed to remap %pr\n", &res);
 606                         return -ENOMEM;
 607                 }
 608                 priv->mem[b].sys_addr = res.start;
 609                 priv->mem[b].size = resource_size(&res);
 610                 if (!strcmp(node->name, "rsc-table"))
 611                         priv->rsc_table = priv->mem[b].cpu_addr;
 612                 b++;
 613         }
 614
 615         return 0;
 616 }
 617
 618 static void imx_rproc_vq_work(struct work_struct *work)
 619 {
 620         struct imx_rproc *priv = container_of(work, struct imx_rproc,
 621                                               rproc_work);
 622
 623         rproc_vq_interrupt(priv->rproc, 0);
 624         rproc_vq_interrupt(priv->rproc, 1);
 625 }
 626
 627 static void imx_rproc_rx_callback(struct mbox_client *cl, void *msg)
 628 {
 629         struct rproc *rproc = dev_get_drvdata(cl->dev);
 630         struct imx_rproc *priv = rproc->priv;
 631
 632         queue_work(priv->workqueue, &priv->rproc_work);
 633 }
 634
 635 static int imx_rproc_xtr_mbox_init(struct rproc *rproc)
 636 {
 637         struct imx_rproc *priv = rproc->priv;
 638         struct device *dev = priv->dev;
 639         struct mbox_client *cl;
 640         int ret;
 641
 642         if (!of_get_property(dev->of_node, "mbox-names", NULL))
 643                 return 0;
 644
 645         cl = &priv->cl;
 646         cl->dev = dev;
 647         cl->tx_block = true;
 648         cl->tx_tout = 100;
 649         cl->knows_txdone = false;
 650         cl->rx_callback = imx_rproc_rx_callback;
 651
 652         priv->tx_ch = mbox_request_channel_byname(cl, "tx");
 653         if (IS_ERR(priv->tx_ch)) {
 654                 ret = PTR_ERR(priv->tx_ch);
 655                 return dev_err_probe(cl->dev, ret,
 656                                      "failed to request tx mailbox channel: %d\n", ret);
 657         }
 658
 659         priv->rx_ch = mbox_request_channel_byname(cl, "rx");
 660         if (IS_ERR(priv->rx_ch)) {
 661                 mbox_free_channel(priv->tx_ch);
 662                 ret = PTR_ERR(priv->rx_ch);
 663                 return dev_err_probe(cl->dev, ret,
 664                                      "failed to request rx mailbox channel: %d\n", ret);
 665         }
 666
 667         return 0;
 668 }
 669
 670 static void imx_rproc_free_mbox(struct rproc *rproc)
 671 {
 672         struct imx_rproc *priv = rproc->priv;
 673
 674         mbox_free_channel(priv->tx_ch);
 675         mbox_free_channel(priv->rx_ch);
 676 }
 677
 678 static int imx_rproc_detect_mode(struct imx_rproc *priv)
 679 {
 680         struct regmap_config config = { .name = "imx-rproc" };
 681         const struct imx_rproc_dcfg *dcfg = priv->dcfg;
 682         struct device *dev = priv->dev;
 683         struct regmap *regmap;
 684         struct arm_smccc_res res;
 685         int ret;
 686         u32 val;
 687
 688         switch (dcfg->method) {
 689         case IMX_RPROC_NONE:
 690                 priv->rproc->state = RPROC_DETACHED;
 691                 return 0;
 692         case IMX_RPROC_SMC:
 693                 arm_smccc_smc(IMX_SIP_RPROC, IMX_SIP_RPROC_STARTED, 0, 0, 0, 0, 0, 0, &res);
 694                 if (res.a0)
 695                         priv->rproc->state = RPROC_DETACHED;
 696                 return 0;
 697         default:
 698                 break;
 699         }
 700
 701         regmap = syscon_regmap_lookup_by_phandle(dev->of_node, "syscon");
 702         if (IS_ERR(regmap)) {
 703                 dev_err(dev, "failed to find syscon\n");
 704                 return PTR_ERR(regmap);
 705         }
 706
 707         priv->regmap = regmap;
 708         regmap_attach_dev(dev, regmap, &config);
 709
 710         ret = regmap_read(regmap, dcfg->src_reg, &val);
 711         if (ret) {
 712                 dev_err(dev, "Failed to read src\n");
 713                 return ret;
 714         }
 715
 716         if (!(val & dcfg->src_stop))
 717                 priv->rproc->state = RPROC_DETACHED;
 718
 719         return 0;
 720 }
 721
 722 static int imx_rproc_clk_enable(struct imx_rproc *priv)
 723 {
 724         const struct imx_rproc_dcfg *dcfg = priv->dcfg;
 725         struct device *dev = priv->dev;
 726         int ret;
 727
 728         /* Remote core is not under control of Linux */
 729         if (dcfg->method == IMX_RPROC_NONE)
 730                 return 0;
 731
 732         priv->clk = devm_clk_get(dev, NULL);
 733         if (IS_ERR(priv->clk)) {
 734                 dev_err(dev, "Failed to get clock\n");
 735                 return PTR_ERR(priv->clk);
 736         }
 737
 738         /*
 739          * clk for M4 block including memory. Should be
 740          * enabled before .start for FW transfer.
 741          */
 742         ret = clk_prepare_enable(priv->clk);
 743         if (ret) {
 744                 dev_err(dev, "Failed to enable clock\n");
 745                 return ret;
 746         }
 747
 748         return 0;
 749 }
 750
 751 static int imx_rproc_probe(struct platform_device *pdev)
 752 {
 753         struct device *dev = &pdev->dev;
 754         struct device_node *np = dev->of_node;
 755         struct imx_rproc *priv;
 756         struct rproc *rproc;
 757         const struct imx_rproc_dcfg *dcfg;
 758         int ret;
 759
 760         /* set some other name then imx */
 761         rproc = rproc_alloc(dev, "imx-rproc", &imx_rproc_ops,
 762                             NULL, sizeof(*priv));
 763         if (!rproc)
 764                 return -ENOMEM;
 765
 766         dcfg = of_device_get_match_data(dev);
 767         if (!dcfg) {
 768                 ret = -EINVAL;
 769                 goto err_put_rproc;
 770         }
 771
 772         priv = rproc->priv;
 773         priv->rproc = rproc;
 774         priv->dcfg = dcfg;
 775         priv->dev = dev;
 776
 777         dev_set_drvdata(dev, rproc);
 778         priv->workqueue = create_workqueue(dev_name(dev));
 779         if (!priv->workqueue) {
 780                 dev_err(dev, "cannot create workqueue\n");
 781                 ret = -ENOMEM;
 782                 goto err_put_rproc;
 783         }
 784
 785         ret = imx_rproc_xtr_mbox_init(rproc);
 786         if (ret)
 787                 goto err_put_wkq;
 788
 789         ret = imx_rproc_addr_init(priv, pdev);
 790         if (ret) {
 791                 dev_err(dev, "failed on imx_rproc_addr_init\n");
 792                 goto err_put_mbox;
 793         }
 794
 795         ret = imx_rproc_detect_mode(priv);
 796         if (ret)
 797                 goto err_put_mbox;
 798
 799         ret = imx_rproc_clk_enable(priv);
 800         if (ret)
 801                 goto err_put_mbox;
 802
 803         INIT_WORK(&priv->rproc_work, imx_rproc_vq_work);
 804
 805         if (rproc->state != RPROC_DETACHED)
 806                 rproc->auto_boot = of_property_read_bool(np, "fsl,auto-boot");
 807
 808         ret = rproc_add(rproc);
 809         if (ret) {
 810                 dev_err(dev, "rproc_add failed\n");
 811                 goto err_put_clk;
 812         }
 813
 814         return 0;
 815
 816 err_put_clk:
 817         clk_disable_unprepare(priv->clk);
 818 err_put_mbox:
 819         imx_rproc_free_mbox(rproc);
 820 err_put_wkq:
 821         destroy_workqueue(priv->workqueue);
 822 err_put_rproc:
 823         rproc_free(rproc);
 824
 825         return ret;
 826 }
 827
 828 static int imx_rproc_remove(struct platform_device *pdev)
 829 {
 830         struct rproc *rproc = platform_get_drvdata(pdev);
 831         struct imx_rproc *priv = rproc->priv;
 832
 833         clk_disable_unprepare(priv->clk);
 834         rproc_del(rproc);
 835         imx_rproc_free_mbox(rproc);
 836         destroy_workqueue(priv->workqueue);
 837         rproc_free(rproc);
 838
 839         return 0;
 840 }
 841
 842 static const struct of_device_id imx_rproc_of_match[] = {
 843         { .compatible = "fsl,imx7ulp-cm4", .data = &imx_rproc_cfg_imx7ulp },
 844         { .compatible = "fsl,imx7d-cm4", .data = &imx_rproc_cfg_imx7d },
 845         { .compatible = "fsl,imx6sx-cm4", .data = &imx_rproc_cfg_imx6sx },
 846         { .compatible = "fsl,imx8mq-cm4", .data = &imx_rproc_cfg_imx8mq },
 847         { .compatible = "fsl,imx8mm-cm4", .data = &imx_rproc_cfg_imx8mq },
 848         { .compatible = "fsl,imx8mn-cm7", .data = &imx_rproc_cfg_imx8mn },
 849         { .compatible = "fsl,imx8mp-cm7", .data = &imx_rproc_cfg_imx8mn },
 850         { .compatible = "fsl,imx8ulp-cm33", .data = &imx_rproc_cfg_imx8ulp },
 851         {},
 852 };
 853 MODULE_DEVICE_TABLE(of, imx_rproc_of_match);
 854
 855 static struct platform_driver imx_rproc_driver = {
 856         .probe = imx_rproc_probe,
 857         .remove = imx_rproc_remove,
 858         .driver = {
 859                 .name = "imx-rproc",
 860                 .of_match_table = imx_rproc_of_match,
 861         },
 862 };
 863
 864 module_platform_driver(imx_rproc_driver);
 865
 866 MODULE_LICENSE("GPL v2");
 867 MODULE_DESCRIPTION("i.MX remote processor control driver");
 868 MODULE_AUTHOR("Oleksij Rempel <o.rempel@pengutronix.de>");