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