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