1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) STMicroelectronics 2018 - All Rights Reserved 4 * Authors: Ludovic Barre <ludovic.barre@st.com> for STMicroelectronics. 5 * Fabien Dessenne <fabien.dessenne@st.com> for STMicroelectronics. 6 */ 7 8 #include <linux/arm-smccc.h> 9 #include <linux/dma-mapping.h> 10 #include <linux/interrupt.h> 11 #include <linux/io.h> 12 #include <linux/mailbox_client.h> 13 #include <linux/mfd/syscon.h> 14 #include <linux/module.h> 15 #include <linux/of_address.h> 16 #include <linux/of_device.h> 17 #include <linux/of_reserved_mem.h> 18 #include <linux/pm_wakeirq.h> 19 #include <linux/regmap.h> 20 #include <linux/remoteproc.h> 21 #include <linux/reset.h> 22 #include <linux/slab.h> 23 #include <linux/workqueue.h> 24 25 #include "remoteproc_internal.h" 26 27 #define HOLD_BOOT 0 28 #define RELEASE_BOOT 1 29 30 #define MBOX_NB_VQ 2 31 #define MBOX_NB_MBX 4 32 33 #define STM32_SMC_RCC 0x82001000 34 #define STM32_SMC_REG_WRITE 0x1 35 36 #define STM32_MBX_VQ0 "vq0" 37 #define STM32_MBX_VQ0_ID 0 38 #define STM32_MBX_VQ1 "vq1" 39 #define STM32_MBX_VQ1_ID 1 40 #define STM32_MBX_SHUTDOWN "shutdown" 41 #define STM32_MBX_DETACH "detach" 42 43 #define RSC_TBL_SIZE 1024 44 45 #define M4_STATE_OFF 0 46 #define M4_STATE_INI 1 47 #define M4_STATE_CRUN 2 48 #define M4_STATE_CSTOP 3 49 #define M4_STATE_STANDBY 4 50 #define M4_STATE_CRASH 5 51 52 struct stm32_syscon { 53 struct regmap *map; 54 u32 reg; 55 u32 mask; 56 }; 57 58 struct stm32_rproc_mem { 59 char name[20]; 60 void __iomem *cpu_addr; 61 phys_addr_t bus_addr; 62 u32 dev_addr; 63 size_t size; 64 }; 65 66 struct stm32_rproc_mem_ranges { 67 u32 dev_addr; 68 u32 bus_addr; 69 u32 size; 70 }; 71 72 struct stm32_mbox { 73 const unsigned char name[10]; 74 struct mbox_chan *chan; 75 struct mbox_client client; 76 struct work_struct vq_work; 77 int vq_id; 78 }; 79 80 struct stm32_rproc { 81 struct reset_control *rst; 82 struct stm32_syscon hold_boot; 83 struct stm32_syscon pdds; 84 struct stm32_syscon m4_state; 85 struct stm32_syscon rsctbl; 86 int wdg_irq; 87 u32 nb_rmems; 88 struct stm32_rproc_mem *rmems; 89 struct stm32_mbox mb[MBOX_NB_MBX]; 90 struct workqueue_struct *workqueue; 91 bool secured_soc; 92 void __iomem *rsc_va; 93 }; 94 95 static int stm32_rproc_pa_to_da(struct rproc *rproc, phys_addr_t pa, u64 *da) 96 { 97 unsigned int i; 98 struct stm32_rproc *ddata = rproc->priv; 99 struct stm32_rproc_mem *p_mem; 100 101 for (i = 0; i < ddata->nb_rmems; i++) { 102 p_mem = &ddata->rmems[i]; 103 104 if (pa < p_mem->bus_addr || 105 pa >= p_mem->bus_addr + p_mem->size) 106 continue; 107 *da = pa - p_mem->bus_addr + p_mem->dev_addr; 108 dev_dbg(rproc->dev.parent, "pa %pa to da %llx\n", &pa, *da); 109 return 0; 110 } 111 112 return -EINVAL; 113 } 114 115 static int stm32_rproc_mem_alloc(struct rproc *rproc, 116 struct rproc_mem_entry *mem) 117 { 118 struct device *dev = rproc->dev.parent; 119 void *va; 120 121 dev_dbg(dev, "map memory: %pa+%x\n", &mem->dma, mem->len); 122 va = ioremap_wc(mem->dma, mem->len); 123 if (IS_ERR_OR_NULL(va)) { 124 dev_err(dev, "Unable to map memory region: %pa+%x\n", 125 &mem->dma, mem->len); 126 return -ENOMEM; 127 } 128 129 /* Update memory entry va */ 130 mem->va = va; 131 132 return 0; 133 } 134 135 static int stm32_rproc_mem_release(struct rproc *rproc, 136 struct rproc_mem_entry *mem) 137 { 138 dev_dbg(rproc->dev.parent, "unmap memory: %pa\n", &mem->dma); 139 iounmap(mem->va); 140 141 return 0; 142 } 143 144 static int stm32_rproc_of_memory_translations(struct platform_device *pdev, 145 struct stm32_rproc *ddata) 146 { 147 struct device *parent, *dev = &pdev->dev; 148 struct device_node *np; 149 struct stm32_rproc_mem *p_mems; 150 struct stm32_rproc_mem_ranges *mem_range; 151 int cnt, array_size, i, ret = 0; 152 153 parent = dev->parent; 154 np = parent->of_node; 155 156 cnt = of_property_count_elems_of_size(np, "dma-ranges", 157 sizeof(*mem_range)); 158 if (cnt <= 0) { 159 dev_err(dev, "%s: dma-ranges property not defined\n", __func__); 160 return -EINVAL; 161 } 162 163 p_mems = devm_kcalloc(dev, cnt, sizeof(*p_mems), GFP_KERNEL); 164 if (!p_mems) 165 return -ENOMEM; 166 mem_range = kcalloc(cnt, sizeof(*mem_range), GFP_KERNEL); 167 if (!mem_range) 168 return -ENOMEM; 169 170 array_size = cnt * sizeof(struct stm32_rproc_mem_ranges) / sizeof(u32); 171 172 ret = of_property_read_u32_array(np, "dma-ranges", 173 (u32 *)mem_range, array_size); 174 if (ret) { 175 dev_err(dev, "error while get dma-ranges property: %x\n", ret); 176 goto free_mem; 177 } 178 179 for (i = 0; i < cnt; i++) { 180 p_mems[i].bus_addr = mem_range[i].bus_addr; 181 p_mems[i].dev_addr = mem_range[i].dev_addr; 182 p_mems[i].size = mem_range[i].size; 183 184 dev_dbg(dev, "memory range[%i]: da %#x, pa %pa, size %#zx:\n", 185 i, p_mems[i].dev_addr, &p_mems[i].bus_addr, 186 p_mems[i].size); 187 } 188 189 ddata->rmems = p_mems; 190 ddata->nb_rmems = cnt; 191 192 free_mem: 193 kfree(mem_range); 194 return ret; 195 } 196 197 static int stm32_rproc_mbox_idx(struct rproc *rproc, const unsigned char *name) 198 { 199 struct stm32_rproc *ddata = rproc->priv; 200 int i; 201 202 for (i = 0; i < ARRAY_SIZE(ddata->mb); i++) { 203 if (!strncmp(ddata->mb[i].name, name, strlen(name))) 204 return i; 205 } 206 dev_err(&rproc->dev, "mailbox %s not found\n", name); 207 208 return -EINVAL; 209 } 210 211 static int stm32_rproc_prepare(struct rproc *rproc) 212 { 213 struct device *dev = rproc->dev.parent; 214 struct device_node *np = dev->of_node; 215 struct of_phandle_iterator it; 216 struct rproc_mem_entry *mem; 217 struct reserved_mem *rmem; 218 u64 da; 219 int index = 0; 220 221 /* Register associated reserved memory regions */ 222 of_phandle_iterator_init(&it, np, "memory-region", NULL, 0); 223 while (of_phandle_iterator_next(&it) == 0) { 224 rmem = of_reserved_mem_lookup(it.node); 225 if (!rmem) { 226 dev_err(dev, "unable to acquire memory-region\n"); 227 return -EINVAL; 228 } 229 230 if (stm32_rproc_pa_to_da(rproc, rmem->base, &da) < 0) { 231 dev_err(dev, "memory region not valid %pa\n", 232 &rmem->base); 233 return -EINVAL; 234 } 235 236 /* No need to map vdev buffer */ 237 if (strcmp(it.node->name, "vdev0buffer")) { 238 /* Register memory region */ 239 mem = rproc_mem_entry_init(dev, NULL, 240 (dma_addr_t)rmem->base, 241 rmem->size, da, 242 stm32_rproc_mem_alloc, 243 stm32_rproc_mem_release, 244 it.node->name); 245 246 if (mem) 247 rproc_coredump_add_segment(rproc, da, 248 rmem->size); 249 } else { 250 /* Register reserved memory for vdev buffer alloc */ 251 mem = rproc_of_resm_mem_entry_init(dev, index, 252 rmem->size, 253 rmem->base, 254 it.node->name); 255 } 256 257 if (!mem) 258 return -ENOMEM; 259 260 rproc_add_carveout(rproc, mem); 261 index++; 262 } 263 264 return 0; 265 } 266 267 static int stm32_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw) 268 { 269 if (rproc_elf_load_rsc_table(rproc, fw)) 270 dev_warn(&rproc->dev, "no resource table found for this firmware\n"); 271 272 return 0; 273 } 274 275 static irqreturn_t stm32_rproc_wdg(int irq, void *data) 276 { 277 struct platform_device *pdev = data; 278 struct rproc *rproc = platform_get_drvdata(pdev); 279 280 rproc_report_crash(rproc, RPROC_WATCHDOG); 281 282 return IRQ_HANDLED; 283 } 284 285 static void stm32_rproc_mb_vq_work(struct work_struct *work) 286 { 287 struct stm32_mbox *mb = container_of(work, struct stm32_mbox, vq_work); 288 struct rproc *rproc = dev_get_drvdata(mb->client.dev); 289 290 if (rproc_vq_interrupt(rproc, mb->vq_id) == IRQ_NONE) 291 dev_dbg(&rproc->dev, "no message found in vq%d\n", mb->vq_id); 292 } 293 294 static void stm32_rproc_mb_callback(struct mbox_client *cl, void *data) 295 { 296 struct rproc *rproc = dev_get_drvdata(cl->dev); 297 struct stm32_mbox *mb = container_of(cl, struct stm32_mbox, client); 298 struct stm32_rproc *ddata = rproc->priv; 299 300 queue_work(ddata->workqueue, &mb->vq_work); 301 } 302 303 static void stm32_rproc_free_mbox(struct rproc *rproc) 304 { 305 struct stm32_rproc *ddata = rproc->priv; 306 unsigned int i; 307 308 for (i = 0; i < ARRAY_SIZE(ddata->mb); i++) { 309 if (ddata->mb[i].chan) 310 mbox_free_channel(ddata->mb[i].chan); 311 ddata->mb[i].chan = NULL; 312 } 313 } 314 315 static const struct stm32_mbox stm32_rproc_mbox[MBOX_NB_MBX] = { 316 { 317 .name = STM32_MBX_VQ0, 318 .vq_id = STM32_MBX_VQ0_ID, 319 .client = { 320 .rx_callback = stm32_rproc_mb_callback, 321 .tx_block = false, 322 }, 323 }, 324 { 325 .name = STM32_MBX_VQ1, 326 .vq_id = STM32_MBX_VQ1_ID, 327 .client = { 328 .rx_callback = stm32_rproc_mb_callback, 329 .tx_block = false, 330 }, 331 }, 332 { 333 .name = STM32_MBX_SHUTDOWN, 334 .vq_id = -1, 335 .client = { 336 .tx_block = true, 337 .tx_done = NULL, 338 .tx_tout = 500, /* 500 ms time out */ 339 }, 340 }, 341 { 342 .name = STM32_MBX_DETACH, 343 .vq_id = -1, 344 .client = { 345 .tx_block = true, 346 .tx_done = NULL, 347 .tx_tout = 200, /* 200 ms time out to detach should be fair enough */ 348 }, 349 } 350 }; 351 352 static int stm32_rproc_request_mbox(struct rproc *rproc) 353 { 354 struct stm32_rproc *ddata = rproc->priv; 355 struct device *dev = &rproc->dev; 356 unsigned int i; 357 int j; 358 const unsigned char *name; 359 struct mbox_client *cl; 360 361 /* Initialise mailbox structure table */ 362 memcpy(ddata->mb, stm32_rproc_mbox, sizeof(stm32_rproc_mbox)); 363 364 for (i = 0; i < MBOX_NB_MBX; i++) { 365 name = ddata->mb[i].name; 366 367 cl = &ddata->mb[i].client; 368 cl->dev = dev->parent; 369 370 ddata->mb[i].chan = mbox_request_channel_byname(cl, name); 371 if (IS_ERR(ddata->mb[i].chan)) { 372 if (PTR_ERR(ddata->mb[i].chan) == -EPROBE_DEFER) { 373 dev_err_probe(dev->parent, 374 PTR_ERR(ddata->mb[i].chan), 375 "failed to request mailbox %s\n", 376 name); 377 goto err_probe; 378 } 379 dev_warn(dev, "cannot get %s mbox\n", name); 380 ddata->mb[i].chan = NULL; 381 } 382 if (ddata->mb[i].vq_id >= 0) { 383 INIT_WORK(&ddata->mb[i].vq_work, 384 stm32_rproc_mb_vq_work); 385 } 386 } 387 388 return 0; 389 390 err_probe: 391 for (j = i - 1; j >= 0; j--) 392 if (ddata->mb[j].chan) 393 mbox_free_channel(ddata->mb[j].chan); 394 return -EPROBE_DEFER; 395 } 396 397 static int stm32_rproc_set_hold_boot(struct rproc *rproc, bool hold) 398 { 399 struct stm32_rproc *ddata = rproc->priv; 400 struct stm32_syscon hold_boot = ddata->hold_boot; 401 struct arm_smccc_res smc_res; 402 int val, err; 403 404 val = hold ? HOLD_BOOT : RELEASE_BOOT; 405 406 if (IS_ENABLED(CONFIG_HAVE_ARM_SMCCC) && ddata->secured_soc) { 407 arm_smccc_smc(STM32_SMC_RCC, STM32_SMC_REG_WRITE, 408 hold_boot.reg, val, 0, 0, 0, 0, &smc_res); 409 err = smc_res.a0; 410 } else { 411 err = regmap_update_bits(hold_boot.map, hold_boot.reg, 412 hold_boot.mask, val); 413 } 414 415 if (err) 416 dev_err(&rproc->dev, "failed to set hold boot\n"); 417 418 return err; 419 } 420 421 static void stm32_rproc_add_coredump_trace(struct rproc *rproc) 422 { 423 struct rproc_debug_trace *trace; 424 struct rproc_dump_segment *segment; 425 bool already_added; 426 427 list_for_each_entry(trace, &rproc->traces, node) { 428 already_added = false; 429 430 list_for_each_entry(segment, &rproc->dump_segments, node) { 431 if (segment->da == trace->trace_mem.da) { 432 already_added = true; 433 break; 434 } 435 } 436 437 if (!already_added) 438 rproc_coredump_add_segment(rproc, trace->trace_mem.da, 439 trace->trace_mem.len); 440 } 441 } 442 443 static int stm32_rproc_start(struct rproc *rproc) 444 { 445 struct stm32_rproc *ddata = rproc->priv; 446 int err; 447 448 stm32_rproc_add_coredump_trace(rproc); 449 450 /* clear remote proc Deep Sleep */ 451 if (ddata->pdds.map) { 452 err = regmap_update_bits(ddata->pdds.map, ddata->pdds.reg, 453 ddata->pdds.mask, 0); 454 if (err) { 455 dev_err(&rproc->dev, "failed to clear pdds\n"); 456 return err; 457 } 458 } 459 460 err = stm32_rproc_set_hold_boot(rproc, false); 461 if (err) 462 return err; 463 464 return stm32_rproc_set_hold_boot(rproc, true); 465 } 466 467 static int stm32_rproc_attach(struct rproc *rproc) 468 { 469 stm32_rproc_add_coredump_trace(rproc); 470 471 return stm32_rproc_set_hold_boot(rproc, true); 472 } 473 474 static int stm32_rproc_detach(struct rproc *rproc) 475 { 476 struct stm32_rproc *ddata = rproc->priv; 477 int err, dummy_data, idx; 478 479 /* Inform the remote processor of the detach */ 480 idx = stm32_rproc_mbox_idx(rproc, STM32_MBX_DETACH); 481 if (idx >= 0 && ddata->mb[idx].chan) { 482 /* A dummy data is sent to allow to block on transmit */ 483 err = mbox_send_message(ddata->mb[idx].chan, 484 &dummy_data); 485 if (err < 0) 486 dev_warn(&rproc->dev, "warning: remote FW detach without ack\n"); 487 } 488 489 /* Allow remote processor to auto-reboot */ 490 return stm32_rproc_set_hold_boot(rproc, false); 491 } 492 493 static int stm32_rproc_stop(struct rproc *rproc) 494 { 495 struct stm32_rproc *ddata = rproc->priv; 496 int err, dummy_data, idx; 497 498 /* request shutdown of the remote processor */ 499 if (rproc->state != RPROC_OFFLINE) { 500 idx = stm32_rproc_mbox_idx(rproc, STM32_MBX_SHUTDOWN); 501 if (idx >= 0 && ddata->mb[idx].chan) { 502 /* a dummy data is sent to allow to block on transmit */ 503 err = mbox_send_message(ddata->mb[idx].chan, 504 &dummy_data); 505 if (err < 0) 506 dev_warn(&rproc->dev, "warning: remote FW shutdown without ack\n"); 507 } 508 } 509 510 err = stm32_rproc_set_hold_boot(rproc, true); 511 if (err) 512 return err; 513 514 err = reset_control_assert(ddata->rst); 515 if (err) { 516 dev_err(&rproc->dev, "failed to assert the reset\n"); 517 return err; 518 } 519 520 /* to allow platform Standby power mode, set remote proc Deep Sleep */ 521 if (ddata->pdds.map) { 522 err = regmap_update_bits(ddata->pdds.map, ddata->pdds.reg, 523 ddata->pdds.mask, 1); 524 if (err) { 525 dev_err(&rproc->dev, "failed to set pdds\n"); 526 return err; 527 } 528 } 529 530 /* update coprocessor state to OFF if available */ 531 if (ddata->m4_state.map) { 532 err = regmap_update_bits(ddata->m4_state.map, 533 ddata->m4_state.reg, 534 ddata->m4_state.mask, 535 M4_STATE_OFF); 536 if (err) { 537 dev_err(&rproc->dev, "failed to set copro state\n"); 538 return err; 539 } 540 } 541 542 return 0; 543 } 544 545 static void stm32_rproc_kick(struct rproc *rproc, int vqid) 546 { 547 struct stm32_rproc *ddata = rproc->priv; 548 unsigned int i; 549 int err; 550 551 if (WARN_ON(vqid >= MBOX_NB_VQ)) 552 return; 553 554 for (i = 0; i < MBOX_NB_MBX; i++) { 555 if (vqid != ddata->mb[i].vq_id) 556 continue; 557 if (!ddata->mb[i].chan) 558 return; 559 err = mbox_send_message(ddata->mb[i].chan, (void *)(long)vqid); 560 if (err < 0) 561 dev_err(&rproc->dev, "%s: failed (%s, err:%d)\n", 562 __func__, ddata->mb[i].name, err); 563 return; 564 } 565 } 566 567 static int stm32_rproc_da_to_pa(struct rproc *rproc, 568 u64 da, phys_addr_t *pa) 569 { 570 struct stm32_rproc *ddata = rproc->priv; 571 struct device *dev = rproc->dev.parent; 572 struct stm32_rproc_mem *p_mem; 573 unsigned int i; 574 575 for (i = 0; i < ddata->nb_rmems; i++) { 576 p_mem = &ddata->rmems[i]; 577 578 if (da < p_mem->dev_addr || 579 da >= p_mem->dev_addr + p_mem->size) 580 continue; 581 582 *pa = da - p_mem->dev_addr + p_mem->bus_addr; 583 dev_dbg(dev, "da %llx to pa %#x\n", da, *pa); 584 585 return 0; 586 } 587 588 dev_err(dev, "can't translate da %llx\n", da); 589 590 return -EINVAL; 591 } 592 593 static struct resource_table * 594 stm32_rproc_get_loaded_rsc_table(struct rproc *rproc, size_t *table_sz) 595 { 596 struct stm32_rproc *ddata = rproc->priv; 597 struct device *dev = rproc->dev.parent; 598 phys_addr_t rsc_pa; 599 u32 rsc_da; 600 int err; 601 602 /* The resource table has already been mapped, nothing to do */ 603 if (ddata->rsc_va) 604 goto done; 605 606 err = regmap_read(ddata->rsctbl.map, ddata->rsctbl.reg, &rsc_da); 607 if (err) { 608 dev_err(dev, "failed to read rsc tbl addr\n"); 609 return ERR_PTR(-EINVAL); 610 } 611 612 if (!rsc_da) 613 /* no rsc table */ 614 return ERR_PTR(-ENOENT); 615 616 err = stm32_rproc_da_to_pa(rproc, rsc_da, &rsc_pa); 617 if (err) 618 return ERR_PTR(err); 619 620 ddata->rsc_va = devm_ioremap_wc(dev, rsc_pa, RSC_TBL_SIZE); 621 if (IS_ERR_OR_NULL(ddata->rsc_va)) { 622 dev_err(dev, "Unable to map memory region: %pa+%zx\n", 623 &rsc_pa, RSC_TBL_SIZE); 624 ddata->rsc_va = NULL; 625 return ERR_PTR(-ENOMEM); 626 } 627 628 done: 629 /* 630 * Assuming the resource table fits in 1kB is fair. 631 * Notice for the detach, that this 1 kB memory area has to be reserved in the coprocessor 632 * firmware for the resource table. On detach, the remoteproc core re-initializes this 633 * entire area by overwriting it with the initial values stored in rproc->clean_table. 634 */ 635 *table_sz = RSC_TBL_SIZE; 636 return (struct resource_table *)ddata->rsc_va; 637 } 638 639 static const struct rproc_ops st_rproc_ops = { 640 .prepare = stm32_rproc_prepare, 641 .start = stm32_rproc_start, 642 .stop = stm32_rproc_stop, 643 .attach = stm32_rproc_attach, 644 .detach = stm32_rproc_detach, 645 .kick = stm32_rproc_kick, 646 .load = rproc_elf_load_segments, 647 .parse_fw = stm32_rproc_parse_fw, 648 .find_loaded_rsc_table = rproc_elf_find_loaded_rsc_table, 649 .get_loaded_rsc_table = stm32_rproc_get_loaded_rsc_table, 650 .sanity_check = rproc_elf_sanity_check, 651 .get_boot_addr = rproc_elf_get_boot_addr, 652 }; 653 654 static const struct of_device_id stm32_rproc_match[] = { 655 { .compatible = "st,stm32mp1-m4" }, 656 {}, 657 }; 658 MODULE_DEVICE_TABLE(of, stm32_rproc_match); 659 660 static int stm32_rproc_get_syscon(struct device_node *np, const char *prop, 661 struct stm32_syscon *syscon) 662 { 663 int err = 0; 664 665 syscon->map = syscon_regmap_lookup_by_phandle(np, prop); 666 if (IS_ERR(syscon->map)) { 667 err = PTR_ERR(syscon->map); 668 syscon->map = NULL; 669 goto out; 670 } 671 672 err = of_property_read_u32_index(np, prop, 1, &syscon->reg); 673 if (err) 674 goto out; 675 676 err = of_property_read_u32_index(np, prop, 2, &syscon->mask); 677 678 out: 679 return err; 680 } 681 682 static int stm32_rproc_parse_dt(struct platform_device *pdev, 683 struct stm32_rproc *ddata, bool *auto_boot) 684 { 685 struct device *dev = &pdev->dev; 686 struct device_node *np = dev->of_node; 687 struct stm32_syscon tz; 688 unsigned int tzen; 689 int err, irq; 690 691 irq = platform_get_irq(pdev, 0); 692 if (irq == -EPROBE_DEFER) 693 return dev_err_probe(dev, irq, "failed to get interrupt\n"); 694 695 if (irq > 0) { 696 err = devm_request_irq(dev, irq, stm32_rproc_wdg, 0, 697 dev_name(dev), pdev); 698 if (err) 699 return dev_err_probe(dev, err, 700 "failed to request wdg irq\n"); 701 702 ddata->wdg_irq = irq; 703 704 if (of_property_read_bool(np, "wakeup-source")) { 705 device_init_wakeup(dev, true); 706 dev_pm_set_wake_irq(dev, irq); 707 } 708 709 dev_info(dev, "wdg irq registered\n"); 710 } 711 712 ddata->rst = devm_reset_control_get_by_index(dev, 0); 713 if (IS_ERR(ddata->rst)) 714 return dev_err_probe(dev, PTR_ERR(ddata->rst), 715 "failed to get mcu_reset\n"); 716 717 /* 718 * if platform is secured the hold boot bit must be written by 719 * smc call and read normally. 720 * if not secure the hold boot bit could be read/write normally 721 */ 722 err = stm32_rproc_get_syscon(np, "st,syscfg-tz", &tz); 723 if (err) { 724 dev_err(dev, "failed to get tz syscfg\n"); 725 return err; 726 } 727 728 err = regmap_read(tz.map, tz.reg, &tzen); 729 if (err) { 730 dev_err(dev, "failed to read tzen\n"); 731 return err; 732 } 733 ddata->secured_soc = tzen & tz.mask; 734 735 err = stm32_rproc_get_syscon(np, "st,syscfg-holdboot", 736 &ddata->hold_boot); 737 if (err) { 738 dev_err(dev, "failed to get hold boot\n"); 739 return err; 740 } 741 742 err = stm32_rproc_get_syscon(np, "st,syscfg-pdds", &ddata->pdds); 743 if (err) 744 dev_info(dev, "failed to get pdds\n"); 745 746 *auto_boot = of_property_read_bool(np, "st,auto-boot"); 747 748 /* 749 * See if we can check the M4 status, i.e if it was started 750 * from the boot loader or not. 751 */ 752 err = stm32_rproc_get_syscon(np, "st,syscfg-m4-state", 753 &ddata->m4_state); 754 if (err) { 755 /* remember this */ 756 ddata->m4_state.map = NULL; 757 /* no coprocessor state syscon (optional) */ 758 dev_warn(dev, "m4 state not supported\n"); 759 760 /* no need to go further */ 761 return 0; 762 } 763 764 /* See if we can get the resource table */ 765 err = stm32_rproc_get_syscon(np, "st,syscfg-rsc-tbl", 766 &ddata->rsctbl); 767 if (err) { 768 /* no rsc table syscon (optional) */ 769 dev_warn(dev, "rsc tbl syscon not supported\n"); 770 } 771 772 return 0; 773 } 774 775 static int stm32_rproc_get_m4_status(struct stm32_rproc *ddata, 776 unsigned int *state) 777 { 778 /* See stm32_rproc_parse_dt() */ 779 if (!ddata->m4_state.map) { 780 /* 781 * We couldn't get the coprocessor's state, assume 782 * it is not running. 783 */ 784 *state = M4_STATE_OFF; 785 return 0; 786 } 787 788 return regmap_read(ddata->m4_state.map, ddata->m4_state.reg, state); 789 } 790 791 static int stm32_rproc_probe(struct platform_device *pdev) 792 { 793 struct device *dev = &pdev->dev; 794 struct stm32_rproc *ddata; 795 struct device_node *np = dev->of_node; 796 struct rproc *rproc; 797 unsigned int state; 798 int ret; 799 800 ret = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(32)); 801 if (ret) 802 return ret; 803 804 rproc = rproc_alloc(dev, np->name, &st_rproc_ops, NULL, sizeof(*ddata)); 805 if (!rproc) 806 return -ENOMEM; 807 808 ddata = rproc->priv; 809 810 rproc_coredump_set_elf_info(rproc, ELFCLASS32, EM_NONE); 811 812 ret = stm32_rproc_parse_dt(pdev, ddata, &rproc->auto_boot); 813 if (ret) 814 goto free_rproc; 815 816 ret = stm32_rproc_of_memory_translations(pdev, ddata); 817 if (ret) 818 goto free_rproc; 819 820 ret = stm32_rproc_get_m4_status(ddata, &state); 821 if (ret) 822 goto free_rproc; 823 824 if (state == M4_STATE_CRUN) 825 rproc->state = RPROC_DETACHED; 826 827 rproc->has_iommu = false; 828 ddata->workqueue = create_workqueue(dev_name(dev)); 829 if (!ddata->workqueue) { 830 dev_err(dev, "cannot create workqueue\n"); 831 ret = -ENOMEM; 832 goto free_resources; 833 } 834 835 platform_set_drvdata(pdev, rproc); 836 837 ret = stm32_rproc_request_mbox(rproc); 838 if (ret) 839 goto free_wkq; 840 841 ret = rproc_add(rproc); 842 if (ret) 843 goto free_mb; 844 845 return 0; 846 847 free_mb: 848 stm32_rproc_free_mbox(rproc); 849 free_wkq: 850 destroy_workqueue(ddata->workqueue); 851 free_resources: 852 rproc_resource_cleanup(rproc); 853 free_rproc: 854 if (device_may_wakeup(dev)) { 855 dev_pm_clear_wake_irq(dev); 856 device_init_wakeup(dev, false); 857 } 858 rproc_free(rproc); 859 return ret; 860 } 861 862 static int stm32_rproc_remove(struct platform_device *pdev) 863 { 864 struct rproc *rproc = platform_get_drvdata(pdev); 865 struct stm32_rproc *ddata = rproc->priv; 866 struct device *dev = &pdev->dev; 867 868 if (atomic_read(&rproc->power) > 0) 869 rproc_shutdown(rproc); 870 871 rproc_del(rproc); 872 stm32_rproc_free_mbox(rproc); 873 destroy_workqueue(ddata->workqueue); 874 875 if (device_may_wakeup(dev)) { 876 dev_pm_clear_wake_irq(dev); 877 device_init_wakeup(dev, false); 878 } 879 rproc_free(rproc); 880 881 return 0; 882 } 883 884 static int __maybe_unused stm32_rproc_suspend(struct device *dev) 885 { 886 struct rproc *rproc = dev_get_drvdata(dev); 887 struct stm32_rproc *ddata = rproc->priv; 888 889 if (device_may_wakeup(dev)) 890 return enable_irq_wake(ddata->wdg_irq); 891 892 return 0; 893 } 894 895 static int __maybe_unused stm32_rproc_resume(struct device *dev) 896 { 897 struct rproc *rproc = dev_get_drvdata(dev); 898 struct stm32_rproc *ddata = rproc->priv; 899 900 if (device_may_wakeup(dev)) 901 return disable_irq_wake(ddata->wdg_irq); 902 903 return 0; 904 } 905 906 static SIMPLE_DEV_PM_OPS(stm32_rproc_pm_ops, 907 stm32_rproc_suspend, stm32_rproc_resume); 908 909 static struct platform_driver stm32_rproc_driver = { 910 .probe = stm32_rproc_probe, 911 .remove = stm32_rproc_remove, 912 .driver = { 913 .name = "stm32-rproc", 914 .pm = &stm32_rproc_pm_ops, 915 .of_match_table = of_match_ptr(stm32_rproc_match), 916 }, 917 }; 918 module_platform_driver(stm32_rproc_driver); 919 920 MODULE_DESCRIPTION("STM32 Remote Processor Control Driver"); 921 MODULE_AUTHOR("Ludovic Barre <ludovic.barre@st.com>"); 922 MODULE_AUTHOR("Fabien Dessenne <fabien.dessenne@st.com>"); 923 MODULE_LICENSE("GPL v2"); 924 925