133965Sjdp// SPDX-License-Identifier: GPL-2.0 278828Sobrien/* 3218822Sdim * ZynqMP R5 Remote Processor driver 438889Sjdp * 533965Sjdp */ 633965Sjdp 7218822Sdim#include <dt-bindings/power/xlnx-zynqmp-power.h> 833965Sjdp#include <linux/dma-mapping.h> 9218822Sdim#include <linux/firmware/xlnx-zynqmp.h> 10218822Sdim#include <linux/kernel.h> 11218822Sdim#include <linux/mailbox_client.h> 12218822Sdim#include <linux/mailbox/zynqmp-ipi-message.h> 1333965Sjdp#include <linux/module.h> 14218822Sdim#include <linux/of_address.h> 15218822Sdim#include <linux/of_platform.h> 16218822Sdim#include <linux/of_reserved_mem.h> 17218822Sdim#include <linux/platform_device.h> 1833965Sjdp#include <linux/remoteproc.h> 19218822Sdim 20218822Sdim#include "remoteproc_internal.h" 21218822Sdim 2233965Sjdp/* IPI buffer MAX length */ 23218822Sdim#define IPI_BUF_LEN_MAX 32U 2433965Sjdp 2533965Sjdp/* RX mailbox client buffer max length */ 26218822Sdim#define MBOX_CLIENT_BUF_MAX (IPI_BUF_LEN_MAX + \ 2777298Sobrien sizeof(struct zynqmp_ipi_message)) 2833965Sjdp/* 2933965Sjdp * settings for RPU cluster mode which 3033965Sjdp * reflects possible values of xlnx,cluster-mode dt-property 3133965Sjdp */ 3233965Sjdpenum zynqmp_r5_cluster_mode { 3333965Sjdp SPLIT_MODE = 0, /* When cores run as separate processor */ 3433965Sjdp LOCKSTEP_MODE = 1, /* cores execute same code in lockstep,clk-for-clk */ 3533965Sjdp SINGLE_CPU_MODE = 2, /* core0 is held in reset and only core1 runs */ 3633965Sjdp}; 3733965Sjdp 3833965Sjdp/** 3933965Sjdp * struct mem_bank_data - Memory Bank description 4033965Sjdp * 4133965Sjdp * @addr: Start address of memory bank 4233965Sjdp * @da: device address 4333965Sjdp * @size: Size of Memory bank 4433965Sjdp * @pm_domain_id: Power-domains id of memory bank for firmware to turn on/off 4577298Sobrien * @bank_name: name of the bank for remoteproc framework 46218822Sdim */ 4733965Sjdpstruct mem_bank_data { 4877298Sobrien phys_addr_t addr; 49218822Sdim u32 da; 5033965Sjdp size_t size; 5133965Sjdp u32 pm_domain_id; 5233965Sjdp char *bank_name; 5333965Sjdp}; 5433965Sjdp 5533965Sjdp/** 5633965Sjdp * struct mbox_info 5733965Sjdp * 5833965Sjdp * @rx_mc_buf: to copy data from mailbox rx channel 5933965Sjdp * @tx_mc_buf: to copy data to mailbox tx channel 6033965Sjdp * @r5_core: this mailbox's corresponding r5_core pointer 6133965Sjdp * @mbox_work: schedule work after receiving data from mailbox 6233965Sjdp * @mbox_cl: mailbox client 6333965Sjdp * @tx_chan: mailbox tx channel 6477298Sobrien * @rx_chan: mailbox rx channel 6533965Sjdp */ 6633965Sjdpstruct mbox_info { 6733965Sjdp unsigned char rx_mc_buf[MBOX_CLIENT_BUF_MAX]; 6833965Sjdp unsigned char tx_mc_buf[MBOX_CLIENT_BUF_MAX]; 6933965Sjdp struct zynqmp_r5_core *r5_core; 7033965Sjdp struct work_struct mbox_work; 7133965Sjdp struct mbox_client mbox_cl; 7233965Sjdp struct mbox_chan *tx_chan; 7333965Sjdp struct mbox_chan *rx_chan; 74218822Sdim}; 7533965Sjdp 7633965Sjdp/* 77218822Sdim * Hardcoded TCM bank values. This will be removed once TCM bindings are 7833965Sjdp * accepted for system-dt specifications and upstreamed in linux kernel 7933965Sjdp */ 8033965Sjdpstatic const struct mem_bank_data zynqmp_tcm_banks_split[] = { 8133965Sjdp {0xffe00000UL, 0x0, 0x10000UL, PD_R5_0_ATCM, "atcm0"}, /* TCM 64KB each */ 8233965Sjdp {0xffe20000UL, 0x20000, 0x10000UL, PD_R5_0_BTCM, "btcm0"}, 8333965Sjdp {0xffe90000UL, 0x0, 0x10000UL, PD_R5_1_ATCM, "atcm1"}, 8433965Sjdp {0xffeb0000UL, 0x20000, 0x10000UL, PD_R5_1_BTCM, "btcm1"}, 8533965Sjdp}; 8633965Sjdp 8733965Sjdp/* In lockstep mode cluster combines each 64KB TCM and makes 128KB TCM */ 8833965Sjdpstatic const struct mem_bank_data zynqmp_tcm_banks_lockstep[] = { 89218822Sdim {0xffe00000UL, 0x0, 0x20000UL, PD_R5_0_ATCM, "atcm0"}, /* TCM 128KB each */ 9033965Sjdp {0xffe20000UL, 0x20000, 0x20000UL, PD_R5_0_BTCM, "btcm0"}, 9133965Sjdp {0, 0, 0, PD_R5_1_ATCM, ""}, 9233965Sjdp {0, 0, 0, PD_R5_1_BTCM, ""}, 9333965Sjdp}; 9433965Sjdp 9533965Sjdp/** 9633965Sjdp * struct zynqmp_r5_core 9733965Sjdp * 9833965Sjdp * @dev: device of RPU instance 9933965Sjdp * @np: device node of RPU instance 100218822Sdim * @tcm_bank_count: number TCM banks accessible to this RPU 10133965Sjdp * @tcm_banks: array of each TCM bank data 102218822Sdim * @rproc: rproc handle 10377298Sobrien * @pm_domain_id: RPU CPU power domain id 104218822Sdim * @ipi: pointer to mailbox information 10533965Sjdp */ 10633965Sjdpstruct zynqmp_r5_core { 10733965Sjdp struct device *dev; 10889857Sobrien struct device_node *np; 10933965Sjdp int tcm_bank_count; 11033965Sjdp struct mem_bank_data **tcm_banks; 11177298Sobrien struct rproc *rproc; 11233965Sjdp u32 pm_domain_id; 11389857Sobrien struct mbox_info *ipi; 11433965Sjdp}; 115218822Sdim 116218822Sdim/** 11733965Sjdp * struct zynqmp_r5_cluster 11833965Sjdp * 11933965Sjdp * @dev: r5f subsystem cluster device node 12033965Sjdp * @mode: cluster mode of type zynqmp_r5_cluster_mode 121218822Sdim * @core_count: number of r5 cores used for this cluster mode 12233965Sjdp * @r5_cores: Array of pointers pointing to r5 core 12394536Sobrien */ 12433965Sjdpstruct zynqmp_r5_cluster { 12533965Sjdp struct device *dev; 12677298Sobrien enum zynqmp_r5_cluster_mode mode; 12777298Sobrien int core_count; 12877298Sobrien struct zynqmp_r5_core **r5_cores; 12994536Sobrien}; 13077298Sobrien 13177298Sobrien/** 13277298Sobrien * event_notified_idr_cb() - callback for vq_interrupt per notifyid 13377298Sobrien * @id: rproc->notify id 13477298Sobrien * @ptr: pointer to idr private data 13577298Sobrien * @data: data passed to idr_for_each callback 13677298Sobrien * 137130561Sobrien * Pass notification to remoteproc virtio 13877298Sobrien * 13933965Sjdp * Return: 0. having return is to satisfy the idr_for_each() function 14033965Sjdp * pointer input argument requirement. 14133965Sjdp **/ 14233965Sjdpstatic int event_notified_idr_cb(int id, void *ptr, void *data) 14333965Sjdp{ 14433965Sjdp struct rproc *rproc = data; 14533965Sjdp 14633965Sjdp if (rproc_vq_interrupt(rproc, id) == IRQ_NONE) 14733965Sjdp dev_dbg(&rproc->dev, "data not found for vqid=%d\n", id); 14833965Sjdp 14933965Sjdp return 0; 15033965Sjdp} 15133965Sjdp 15233965Sjdp/** 15333965Sjdp * handle_event_notified() - remoteproc notification work function 15433965Sjdp * @work: pointer to the work structure 15533965Sjdp * 15633965Sjdp * It checks each registered remoteproc notify IDs. 15733965Sjdp */ 15833965Sjdpstatic void handle_event_notified(struct work_struct *work) 15933965Sjdp{ 16033965Sjdp struct mbox_info *ipi; 16133965Sjdp struct rproc *rproc; 16233965Sjdp 16333965Sjdp ipi = container_of(work, struct mbox_info, mbox_work); 16433965Sjdp rproc = ipi->r5_core->rproc; 16533965Sjdp 16633965Sjdp /* 16733965Sjdp * We only use IPI for interrupt. The RPU firmware side may or may 16833965Sjdp * not write the notifyid when it trigger IPI. 16933965Sjdp * And thus, we scan through all the registered notifyids and 17033965Sjdp * find which one is valid to get the message. 17133965Sjdp * Even if message from firmware is NULL, we attempt to get vqid 17233965Sjdp */ 17333965Sjdp idr_for_each(&rproc->notifyids, event_notified_idr_cb, rproc); 17433965Sjdp} 17533965Sjdp 176218822Sdim/** 17733965Sjdp * zynqmp_r5_mb_rx_cb() - receive channel mailbox callback 178218822Sdim * @cl: mailbox client 179218822Sdim * @msg: message pointer 180218822Sdim * 181218822Sdim * Receive data from ipi buffer, ack interrupt and then 182218822Sdim * it will schedule the R5 notification work. 183218822Sdim */ 184218822Sdimstatic void zynqmp_r5_mb_rx_cb(struct mbox_client *cl, void *msg) 185218822Sdim{ 186218822Sdim struct zynqmp_ipi_message *ipi_msg, *buf_msg; 187218822Sdim struct mbox_info *ipi; 188218822Sdim size_t len; 189218822Sdim 19033965Sjdp ipi = container_of(cl, struct mbox_info, mbox_cl); 19133965Sjdp 192130561Sobrien /* copy data from ipi buffer to r5_core */ 193218822Sdim ipi_msg = (struct zynqmp_ipi_message *)msg; 19433965Sjdp buf_msg = (struct zynqmp_ipi_message *)ipi->rx_mc_buf; 195104834Sobrien len = ipi_msg->len; 196104834Sobrien if (len > IPI_BUF_LEN_MAX) { 19733965Sjdp dev_warn(cl->dev, "msg size exceeded than %d\n", 19833965Sjdp IPI_BUF_LEN_MAX); 199218822Sdim len = IPI_BUF_LEN_MAX; 200104834Sobrien } 201130561Sobrien buf_msg->len = len; 202130561Sobrien memcpy(buf_msg->data, ipi_msg->data, len); 203104834Sobrien 204104834Sobrien /* received and processed interrupt ack */ 205104834Sobrien if (mbox_send_message(ipi->rx_chan, NULL) < 0) 206104834Sobrien dev_err(cl->dev, "ack failed to mbox rx_chan\n"); 207104834Sobrien 208104834Sobrien schedule_work(&ipi->mbox_work); 209104834Sobrien} 21033965Sjdp 211130561Sobrien/** 21233965Sjdp * zynqmp_r5_setup_mbox() - Setup mailboxes related properties 21333965Sjdp * this is used for each individual R5 core 21433965Sjdp * 21533965Sjdp * @cdev: child node device 21633965Sjdp * 21733965Sjdp * Function to setup mailboxes related properties 218218822Sdim * return : NULL if failed else pointer to mbox_info 21933965Sjdp */ 22033965Sjdpstatic struct mbox_info *zynqmp_r5_setup_mbox(struct device *cdev) 22133965Sjdp{ 22289857Sobrien struct mbox_client *mbox_cl; 22333965Sjdp struct mbox_info *ipi; 22433965Sjdp 225130561Sobrien ipi = kzalloc(sizeof(*ipi), GFP_KERNEL); 22633965Sjdp if (!ipi) 22733965Sjdp return NULL; 22833965Sjdp 22933965Sjdp mbox_cl = &ipi->mbox_cl; 23033965Sjdp mbox_cl->rx_callback = zynqmp_r5_mb_rx_cb; 23133965Sjdp mbox_cl->tx_block = false; 23233965Sjdp mbox_cl->knows_txdone = false; 23333965Sjdp mbox_cl->tx_done = NULL; 23433965Sjdp mbox_cl->dev = cdev; 23533965Sjdp 23633965Sjdp /* Request TX and RX channels */ 237218822Sdim ipi->tx_chan = mbox_request_channel_byname(mbox_cl, "tx"); 238218822Sdim if (IS_ERR(ipi->tx_chan)) { 239218822Sdim ipi->tx_chan = NULL; 240218822Sdim kfree(ipi); 24133965Sjdp dev_warn(cdev, "mbox tx channel request failed\n"); 24233965Sjdp return NULL; 24333965Sjdp } 24433965Sjdp 24533965Sjdp ipi->rx_chan = mbox_request_channel_byname(mbox_cl, "rx"); 24633965Sjdp if (IS_ERR(ipi->rx_chan)) { 24733965Sjdp mbox_free_channel(ipi->tx_chan); 24833965Sjdp ipi->rx_chan = NULL; 24933965Sjdp ipi->tx_chan = NULL; 25033965Sjdp kfree(ipi); 25189857Sobrien dev_warn(cdev, "mbox rx channel request failed\n"); 25233965Sjdp return NULL; 25333965Sjdp } 25433965Sjdp 25533965Sjdp INIT_WORK(&ipi->mbox_work, handle_event_notified); 25633965Sjdp 25733965Sjdp return ipi; 25833965Sjdp} 259218822Sdim 260218822Sdimstatic void zynqmp_r5_free_mbox(struct mbox_info *ipi) 26133965Sjdp{ 26233965Sjdp if (!ipi) 26333965Sjdp return; 26433965Sjdp 26533965Sjdp if (ipi->tx_chan) { 26633965Sjdp mbox_free_channel(ipi->tx_chan); 267130561Sobrien ipi->tx_chan = NULL; 268218822Sdim } 26933965Sjdp 27033965Sjdp if (ipi->rx_chan) { 27133965Sjdp mbox_free_channel(ipi->rx_chan); 272218822Sdim ipi->rx_chan = NULL; 27333965Sjdp } 274130561Sobrien 27533965Sjdp kfree(ipi); 27633965Sjdp} 27733965Sjdp 27833965Sjdp/* 27933965Sjdp * zynqmp_r5_core_kick() - kick a firmware if mbox is provided 28033965Sjdp * @rproc: r5 core's corresponding rproc structure 28133965Sjdp * @vqid: virtqueue ID 28233965Sjdp */ 28333965Sjdpstatic void zynqmp_r5_rproc_kick(struct rproc *rproc, int vqid) 28433965Sjdp{ 28533965Sjdp struct zynqmp_r5_core *r5_core = rproc->priv; 28633965Sjdp struct device *dev = r5_core->dev; 28733965Sjdp struct zynqmp_ipi_message *mb_msg; 288130561Sobrien struct mbox_info *ipi; 28933965Sjdp int ret; 29033965Sjdp 29133965Sjdp ipi = r5_core->ipi; 29233965Sjdp if (!ipi) 29333965Sjdp return; 294130561Sobrien 295218822Sdim mb_msg = (struct zynqmp_ipi_message *)ipi->tx_mc_buf; 29633965Sjdp memcpy(mb_msg->data, &vqid, sizeof(vqid)); 29733965Sjdp mb_msg->len = sizeof(vqid); 29833965Sjdp ret = mbox_send_message(ipi->tx_chan, mb_msg); 299130561Sobrien if (ret < 0) 30033965Sjdp dev_warn(dev, "failed to send message\n"); 30133965Sjdp} 30233965Sjdp 30333965Sjdp/* 30433965Sjdp * zynqmp_r5_set_mode() 30533965Sjdp * 30633965Sjdp * set RPU cluster and TCM operation mode 30733965Sjdp * 30833965Sjdp * @r5_core: pointer to zynqmp_r5_core type object 30933965Sjdp * @fw_reg_val: value expected by firmware to configure RPU cluster mode 31033965Sjdp * @tcm_mode: value expected by fw to configure TCM mode (lockstep or split) 311130561Sobrien * 31233965Sjdp * Return: 0 for success and < 0 for failure 31333965Sjdp */ 31433965Sjdpstatic int zynqmp_r5_set_mode(struct zynqmp_r5_core *r5_core, 31533965Sjdp enum rpu_oper_mode fw_reg_val, 31633965Sjdp enum rpu_tcm_comb tcm_mode) 31733965Sjdp{ 31833965Sjdp int ret; 31933965Sjdp 32033965Sjdp ret = zynqmp_pm_set_rpu_mode(r5_core->pm_domain_id, fw_reg_val); 32133965Sjdp if (ret < 0) { 32233965Sjdp dev_err(r5_core->dev, "failed to set RPU mode\n"); 32333965Sjdp return ret; 32433965Sjdp } 32533965Sjdp 32633965Sjdp ret = zynqmp_pm_set_tcm_config(r5_core->pm_domain_id, tcm_mode); 32733965Sjdp if (ret < 0) 32833965Sjdp dev_err(r5_core->dev, "failed to configure TCM\n"); 32933965Sjdp 33033965Sjdp return ret; 33133965Sjdp} 33233965Sjdp 33333965Sjdp/* 33433965Sjdp * zynqmp_r5_rproc_start() 33533965Sjdp * @rproc: single R5 core's corresponding rproc instance 33633965Sjdp * 33733965Sjdp * Start R5 Core from designated boot address. 33833965Sjdp * 33933965Sjdp * return 0 on success, otherwise non-zero value on failure 34033965Sjdp */ 34133965Sjdpstatic int zynqmp_r5_rproc_start(struct rproc *rproc) 34233965Sjdp{ 34333965Sjdp struct zynqmp_r5_core *r5_core = rproc->priv; 34433965Sjdp enum rpu_boot_mem bootmem; 34589857Sobrien int ret; 34633965Sjdp 34733965Sjdp /* 34833965Sjdp * The exception vector pointers (EVP) refer to the base-address of 34933965Sjdp * exception vectors (for reset, IRQ, FIQ, etc). The reset-vector 35033965Sjdp * starts at the base-address and subsequent vectors are on 4-byte 35133965Sjdp * boundaries. 35233965Sjdp * 35333965Sjdp * Exception vectors can start either from 0x0000_0000 (LOVEC) or 35460484Sobrien * from 0xFFFF_0000 (HIVEC) which is mapped in the OCM (On-Chip Memory) 35533965Sjdp * 35633965Sjdp * Usually firmware will put Exception vectors at LOVEC. 35733965Sjdp * 35833965Sjdp * It is not recommend that you change the exception vector. 35933965Sjdp * Changing the EVP to HIVEC will result in increased interrupt latency 36033965Sjdp * and jitter. Also, if the OCM is secured and the Cortex-R5F processor 36133965Sjdp * is non-secured, then the Cortex-R5F processor cannot access the 36233965Sjdp * HIVEC exception vectors in the OCM. 36333965Sjdp */ 364218822Sdim bootmem = (rproc->bootaddr >= 0xFFFC0000) ? 36533965Sjdp PM_RPU_BOOTMEM_HIVEC : PM_RPU_BOOTMEM_LOVEC; 36633965Sjdp 36733965Sjdp dev_dbg(r5_core->dev, "RPU boot addr 0x%llx from %s.", rproc->bootaddr, 36833965Sjdp bootmem == PM_RPU_BOOTMEM_HIVEC ? "OCM" : "TCM"); 36933965Sjdp 37033965Sjdp ret = zynqmp_pm_request_wake(r5_core->pm_domain_id, 1, 37133965Sjdp bootmem, ZYNQMP_PM_REQUEST_ACK_NO); 37289857Sobrien if (ret) 37333965Sjdp dev_err(r5_core->dev, 37489857Sobrien "failed to start RPU = 0x%x\n", r5_core->pm_domain_id); 37533965Sjdp return ret; 37633965Sjdp} 37733965Sjdp 37833965Sjdp/* 379218822Sdim * zynqmp_r5_rproc_stop() 38033965Sjdp * @rproc: single R5 core's corresponding rproc instance 38133965Sjdp * 38233965Sjdp * Power down R5 Core. 38333965Sjdp * 38433965Sjdp * return 0 on success, otherwise non-zero value on failure 38533965Sjdp */ 38633965Sjdpstatic int zynqmp_r5_rproc_stop(struct rproc *rproc) 38733965Sjdp{ 38833965Sjdp struct zynqmp_r5_core *r5_core = rproc->priv; 38933965Sjdp int ret; 39033965Sjdp 39133965Sjdp ret = zynqmp_pm_force_pwrdwn(r5_core->pm_domain_id, 39233965Sjdp ZYNQMP_PM_REQUEST_ACK_BLOCKING); 39333965Sjdp if (ret) 39433965Sjdp dev_err(r5_core->dev, "failed to stop remoteproc RPU %d\n", ret); 39533965Sjdp 39689857Sobrien return ret; 39733965Sjdp} 39833965Sjdp 39933965Sjdp/* 40033965Sjdp * zynqmp_r5_mem_region_map() 40133965Sjdp * @rproc: single R5 core's corresponding rproc instance 40233965Sjdp * @mem: mem descriptor to map reserved memory-regions 40333965Sjdp * 40433965Sjdp * Callback to map va for memory-region's carveout. 40533965Sjdp * 40633965Sjdp * return 0 on success, otherwise non-zero value on failure 40733965Sjdp */ 40833965Sjdpstatic int zynqmp_r5_mem_region_map(struct rproc *rproc, 40933965Sjdp struct rproc_mem_entry *mem) 41033965Sjdp{ 41133965Sjdp void __iomem *va; 41233965Sjdp 41333965Sjdp va = ioremap_wc(mem->dma, mem->len); 41433965Sjdp if (IS_ERR_OR_NULL(va)) 41533965Sjdp return -ENOMEM; 41633965Sjdp 41733965Sjdp mem->va = (void *)va; 41833965Sjdp 41933965Sjdp return 0; 42033965Sjdp} 42133965Sjdp 42233965Sjdp/* 42333965Sjdp * zynqmp_r5_rproc_mem_unmap 42433965Sjdp * @rproc: single R5 core's corresponding rproc instance 42533965Sjdp * @mem: mem entry to unmap 42633965Sjdp * 42733965Sjdp * Unmap memory-region carveout 42833965Sjdp * 42933965Sjdp * return: always returns 0 43033965Sjdp */ 43133965Sjdpstatic int zynqmp_r5_mem_region_unmap(struct rproc *rproc, 43233965Sjdp struct rproc_mem_entry *mem) 43333965Sjdp{ 43477298Sobrien iounmap((void __iomem *)mem->va); 43577298Sobrien return 0; 43633965Sjdp} 43760484Sobrien 43860484Sobrien/* 43960484Sobrien * add_mem_regions_carveout() 44033965Sjdp * @rproc: single R5 core's corresponding rproc instance 44133965Sjdp * 44233965Sjdp * Construct rproc mem carveouts from memory-region property nodes 44333965Sjdp * 44433965Sjdp * return 0 on success, otherwise non-zero value on failure 44533965Sjdp */ 44677298Sobrienstatic int add_mem_regions_carveout(struct rproc *rproc) 44733965Sjdp{ 44833965Sjdp struct rproc_mem_entry *rproc_mem; 44933965Sjdp struct zynqmp_r5_core *r5_core; 45033965Sjdp struct of_phandle_iterator it; 45133965Sjdp struct reserved_mem *rmem; 45233965Sjdp int i = 0; 45333965Sjdp 45433965Sjdp r5_core = rproc->priv; 45533965Sjdp 45633965Sjdp /* Register associated reserved memory regions */ 45733965Sjdp of_phandle_iterator_init(&it, r5_core->np, "memory-region", NULL, 0); 45833965Sjdp 45989857Sobrien while (of_phandle_iterator_next(&it) == 0) { 46033965Sjdp rmem = of_reserved_mem_lookup(it.node); 46133965Sjdp if (!rmem) { 46233965Sjdp of_node_put(it.node); 46333965Sjdp dev_err(&rproc->dev, "unable to acquire memory-region\n"); 46433965Sjdp return -EINVAL; 46533965Sjdp } 46633965Sjdp 46733965Sjdp if (!strcmp(it.node->name, "vdev0buffer")) { 46833965Sjdp /* Init reserved memory for vdev buffer */ 46933965Sjdp rproc_mem = rproc_of_resm_mem_entry_init(&rproc->dev, i, 47033965Sjdp rmem->size, 47133965Sjdp rmem->base, 47233965Sjdp it.node->name); 47333965Sjdp } else { 47433965Sjdp /* Register associated reserved memory regions */ 47533965Sjdp rproc_mem = rproc_mem_entry_init(&rproc->dev, NULL, 47633965Sjdp (dma_addr_t)rmem->base, 477218822Sdim rmem->size, rmem->base, 47833965Sjdp zynqmp_r5_mem_region_map, 47933965Sjdp zynqmp_r5_mem_region_unmap, 48033965Sjdp it.node->name); 48133965Sjdp } 48233965Sjdp 48389857Sobrien if (!rproc_mem) { 48433965Sjdp of_node_put(it.node); 48533965Sjdp return -ENOMEM; 48633965Sjdp } 48733965Sjdp 48833965Sjdp rproc_add_carveout(rproc, rproc_mem); 48933965Sjdp 49033965Sjdp dev_dbg(&rproc->dev, "reserved mem carveout %s addr=%llx, size=0x%llx", 49133965Sjdp it.node->name, rmem->base, rmem->size); 49233965Sjdp i++; 49333965Sjdp } 49433965Sjdp 49533965Sjdp return 0; 496130561Sobrien} 49733965Sjdp 49833965Sjdp/* 49933965Sjdp * tcm_mem_unmap() 50033965Sjdp * @rproc: single R5 core's corresponding rproc instance 50133965Sjdp * @mem: tcm mem entry to unmap 50233965Sjdp * 50333965Sjdp * Unmap TCM banks when powering down R5 core. 50433965Sjdp * 50533965Sjdp * return always 0 50633965Sjdp */ 50733965Sjdpstatic int tcm_mem_unmap(struct rproc *rproc, struct rproc_mem_entry *mem) 50833965Sjdp{ 50933965Sjdp iounmap((void __iomem *)mem->va); 51033965Sjdp 51133965Sjdp return 0; 51233965Sjdp} 51333965Sjdp 51433965Sjdp/* 51533965Sjdp * tcm_mem_map() 51633965Sjdp * @rproc: single R5 core's corresponding rproc instance 51733965Sjdp * @mem: tcm memory entry descriptor 518218822Sdim * 51933965Sjdp * Given TCM bank entry, this func setup virtual address for TCM bank 52033965Sjdp * remoteproc carveout. It also takes care of va to da address translation 521130561Sobrien * 522218822Sdim * return 0 on success, otherwise non-zero value on failure 52333965Sjdp */ 52433965Sjdpstatic int tcm_mem_map(struct rproc *rproc, 52533965Sjdp struct rproc_mem_entry *mem) 52633965Sjdp{ 52733965Sjdp void __iomem *va; 52889857Sobrien 529218822Sdim va = ioremap_wc(mem->dma, mem->len); 53033965Sjdp if (IS_ERR_OR_NULL(va)) 53133965Sjdp return -ENOMEM; 53289857Sobrien 533218822Sdim /* Update memory entry va */ 53433965Sjdp mem->va = (void *)va; 535218822Sdim 536218822Sdim /* clear TCMs */ 53733965Sjdp memset_io(va, 0, mem->len); 53833965Sjdp 53933965Sjdp return 0; 54033965Sjdp} 541218822Sdim 54233965Sjdp/* 54333965Sjdp * add_tcm_carveout_split_mode() 54433965Sjdp * @rproc: single R5 core's corresponding rproc instance 54533965Sjdp * 54633965Sjdp * allocate and add remoteproc carveout for TCM memory in split mode 54733965Sjdp * 54833965Sjdp * return 0 on success, otherwise non-zero value on failure 54933965Sjdp */ 55033965Sjdpstatic int add_tcm_carveout_split_mode(struct rproc *rproc) 55133965Sjdp{ 55233965Sjdp struct rproc_mem_entry *rproc_mem; 55333965Sjdp struct zynqmp_r5_core *r5_core; 55433965Sjdp int i, num_banks, ret; 55533965Sjdp phys_addr_t bank_addr; 55633965Sjdp struct device *dev; 55733965Sjdp u32 pm_domain_id; 55833965Sjdp size_t bank_size; 55933965Sjdp char *bank_name; 56033965Sjdp u32 da; 56133965Sjdp 56233965Sjdp r5_core = rproc->priv; 56333965Sjdp dev = r5_core->dev; 56433965Sjdp num_banks = r5_core->tcm_bank_count; 56533965Sjdp 566130561Sobrien /* 56733965Sjdp * Power-on Each 64KB TCM, 56833965Sjdp * register its address space, map and unmap functions 56933965Sjdp * and add carveouts accordingly 57033965Sjdp */ 57133965Sjdp for (i = 0; i < num_banks; i++) { 57233965Sjdp bank_addr = r5_core->tcm_banks[i]->addr; 57333965Sjdp da = r5_core->tcm_banks[i]->da; 57433965Sjdp bank_name = r5_core->tcm_banks[i]->bank_name; 57533965Sjdp bank_size = r5_core->tcm_banks[i]->size; 57633965Sjdp pm_domain_id = r5_core->tcm_banks[i]->pm_domain_id; 57733965Sjdp 57833965Sjdp ret = zynqmp_pm_request_node(pm_domain_id, 579130561Sobrien ZYNQMP_PM_CAPABILITY_ACCESS, 0, 58033965Sjdp ZYNQMP_PM_REQUEST_ACK_BLOCKING); 58133965Sjdp if (ret < 0) { 58233965Sjdp dev_err(dev, "failed to turn on TCM 0x%x", pm_domain_id); 58333965Sjdp goto release_tcm_split; 58433965Sjdp } 58533965Sjdp 586130561Sobrien dev_dbg(dev, "TCM carveout split mode %s addr=%llx, da=0x%x, size=0x%lx", 58733965Sjdp bank_name, bank_addr, da, bank_size); 58833965Sjdp 58933965Sjdp rproc_mem = rproc_mem_entry_init(dev, NULL, bank_addr, 59033965Sjdp bank_size, da, 59133965Sjdp tcm_mem_map, tcm_mem_unmap, 592218822Sdim bank_name); 59333965Sjdp if (!rproc_mem) { 594218822Sdim ret = -ENOMEM; 59533965Sjdp zynqmp_pm_release_node(pm_domain_id); 59633965Sjdp goto release_tcm_split; 59733965Sjdp } 59833965Sjdp 59933965Sjdp rproc_add_carveout(rproc, rproc_mem); 60089857Sobrien } 60133965Sjdp 60233965Sjdp return 0; 60333965Sjdp 60433965Sjdprelease_tcm_split: 60533965Sjdp /* If failed, Turn off all TCM banks turned on before */ 60633965Sjdp for (i--; i >= 0; i--) { 60733965Sjdp pm_domain_id = r5_core->tcm_banks[i]->pm_domain_id; 60833965Sjdp zynqmp_pm_release_node(pm_domain_id); 609104834Sobrien } 610104834Sobrien return ret; 611104834Sobrien} 612104834Sobrien 613104834Sobrien/* 614104834Sobrien * add_tcm_carveout_lockstep_mode() 615104834Sobrien * @rproc: single R5 core's corresponding rproc instance 616104834Sobrien * 61733965Sjdp * allocate and add remoteproc carveout for TCM memory in lockstep mode 61860484Sobrien * 61960484Sobrien * return 0 on success, otherwise non-zero value on failure 62060484Sobrien */ 62133965Sjdpstatic int add_tcm_carveout_lockstep_mode(struct rproc *rproc) 62233965Sjdp{ 62333965Sjdp struct rproc_mem_entry *rproc_mem; 62433965Sjdp struct zynqmp_r5_core *r5_core; 62533965Sjdp int i, num_banks, ret; 62633965Sjdp phys_addr_t bank_addr; 627218822Sdim size_t bank_size = 0; 62833965Sjdp struct device *dev; 629218822Sdim u32 pm_domain_id; 63033965Sjdp char *bank_name; 63133965Sjdp u32 da; 63233965Sjdp 63333965Sjdp r5_core = rproc->priv; 63433965Sjdp dev = r5_core->dev; 63589857Sobrien 63633965Sjdp /* Go through zynqmp banks for r5 node */ 63733965Sjdp num_banks = r5_core->tcm_bank_count; 63833965Sjdp 63933965Sjdp /* 64033965Sjdp * In lockstep mode, TCM is contiguous memory block 64133965Sjdp * However, each TCM block still needs to be enabled individually. 64233965Sjdp * So, Enable each TCM block individually. 64333965Sjdp * Although ATCM and BTCM is contiguous memory block, add two separate 644104834Sobrien * carveouts for both. 645104834Sobrien */ 646104834Sobrien for (i = 0; i < num_banks; i++) { 647104834Sobrien pm_domain_id = r5_core->tcm_banks[i]->pm_domain_id; 648104834Sobrien 649104834Sobrien /* Turn on each TCM bank individually */ 650104834Sobrien ret = zynqmp_pm_request_node(pm_domain_id, 651104834Sobrien ZYNQMP_PM_CAPABILITY_ACCESS, 0, 65233965Sjdp ZYNQMP_PM_REQUEST_ACK_BLOCKING); 65360484Sobrien if (ret < 0) { 65460484Sobrien dev_err(dev, "failed to turn on TCM 0x%x", pm_domain_id); 65560484Sobrien goto release_tcm_lockstep; 65633965Sjdp } 65733965Sjdp 65833965Sjdp bank_size = r5_core->tcm_banks[i]->size; 65933965Sjdp if (bank_size == 0) 66033965Sjdp continue; 661130561Sobrien 662218822Sdim bank_addr = r5_core->tcm_banks[i]->addr; 66333965Sjdp da = r5_core->tcm_banks[i]->da; 66433965Sjdp bank_name = r5_core->tcm_banks[i]->bank_name; 66533965Sjdp 666130561Sobrien /* Register TCM address range, TCM map and unmap functions */ 66733965Sjdp rproc_mem = rproc_mem_entry_init(dev, NULL, bank_addr, 66833965Sjdp bank_size, da, 66933965Sjdp tcm_mem_map, tcm_mem_unmap, 67033965Sjdp bank_name); 67133965Sjdp if (!rproc_mem) { 67233965Sjdp ret = -ENOMEM; 67333965Sjdp zynqmp_pm_release_node(pm_domain_id); 67433965Sjdp goto release_tcm_lockstep; 67533965Sjdp } 67633965Sjdp 67733965Sjdp /* If registration is success, add carveouts */ 67833965Sjdp rproc_add_carveout(rproc, rproc_mem); 67933965Sjdp 68033965Sjdp dev_dbg(dev, "TCM carveout lockstep mode %s addr=0x%llx, da=0x%x, size=0x%lx", 68133965Sjdp bank_name, bank_addr, da, bank_size); 68233965Sjdp } 68333965Sjdp 684130561Sobrien return 0; 68533965Sjdp 68633965Sjdprelease_tcm_lockstep: 68789857Sobrien /* If failed, Turn off all TCM banks turned on before */ 68833965Sjdp for (i--; i >= 0; i--) { 68933965Sjdp pm_domain_id = r5_core->tcm_banks[i]->pm_domain_id; 69033965Sjdp zynqmp_pm_release_node(pm_domain_id); 69133965Sjdp } 69233965Sjdp return ret; 69333965Sjdp} 69433965Sjdp 69533965Sjdp/* 69633965Sjdp * add_tcm_banks() 69733965Sjdp * @rproc: single R5 core's corresponding rproc instance 698218822Sdim * 69933965Sjdp * allocate and add remoteproc carveouts for TCM memory based on cluster mode 70033965Sjdp * 70133965Sjdp * return 0 on success, otherwise non-zero value on failure 70233965Sjdp */ 70333965Sjdpstatic int add_tcm_banks(struct rproc *rproc) 70489857Sobrien{ 70533965Sjdp struct zynqmp_r5_cluster *cluster; 70633965Sjdp struct zynqmp_r5_core *r5_core; 70733965Sjdp struct device *dev; 70833965Sjdp 70933965Sjdp r5_core = rproc->priv; 71033965Sjdp if (!r5_core) 71133965Sjdp return -EINVAL; 712218822Sdim 71333965Sjdp dev = r5_core->dev; 71433965Sjdp 715130561Sobrien cluster = dev_get_drvdata(dev->parent); 71633965Sjdp if (!cluster) { 71733965Sjdp dev_err(dev->parent, "Invalid driver data\n"); 71833965Sjdp return -EINVAL; 71933965Sjdp } 72033965Sjdp 72133965Sjdp /* 72233965Sjdp * In lockstep mode TCM banks are one contiguous memory region of 256Kb 72333965Sjdp * In split mode, each TCM bank is 64Kb and not contiguous. 72433965Sjdp * We add memory carveouts accordingly. 72533965Sjdp */ 72633965Sjdp if (cluster->mode == SPLIT_MODE) 72733965Sjdp return add_tcm_carveout_split_mode(rproc); 72833965Sjdp else if (cluster->mode == LOCKSTEP_MODE) 72933965Sjdp return add_tcm_carveout_lockstep_mode(rproc); 73033965Sjdp 73133965Sjdp return -EINVAL; 73233965Sjdp} 73333965Sjdp 73433965Sjdp/* 73533965Sjdp * zynqmp_r5_parse_fw() 73633965Sjdp * @rproc: single R5 core's corresponding rproc instance 737218822Sdim * @fw: ptr to firmware to be loaded onto r5 core 73833965Sjdp * 73933965Sjdp * get resource table if available 740130561Sobrien * 74133965Sjdp * return 0 on success, otherwise non-zero value on failure 74233965Sjdp */ 74333965Sjdpstatic int zynqmp_r5_parse_fw(struct rproc *rproc, const struct firmware *fw) 74433965Sjdp{ 74533965Sjdp int ret; 74633965Sjdp 74733965Sjdp ret = rproc_elf_load_rsc_table(rproc, fw); 74833965Sjdp if (ret == -EINVAL) { 74933965Sjdp /* 75033965Sjdp * resource table only required for IPC. 75133965Sjdp * if not present, this is not necessarily an error; 75233965Sjdp * for example, loading r5 hello world application 75333965Sjdp * so simply inform user and keep going. 75433965Sjdp */ 75533965Sjdp dev_info(&rproc->dev, "no resource table found.\n"); 75633965Sjdp ret = 0; 75733965Sjdp } 75833965Sjdp return ret; 75933965Sjdp} 760218822Sdim 76133965Sjdp/** 76233965Sjdp * zynqmp_r5_rproc_prepare() 76333965Sjdp * adds carveouts for TCM bank and reserved memory regions 76433965Sjdp * 765130561Sobrien * @rproc: Device node of each rproc 76633965Sjdp * 76733965Sjdp * Return: 0 for success else < 0 error code 76833965Sjdp */ 76933965Sjdpstatic int zynqmp_r5_rproc_prepare(struct rproc *rproc) 770130561Sobrien{ 77133965Sjdp int ret; 77233965Sjdp 77333965Sjdp ret = add_tcm_banks(rproc); 77433965Sjdp if (ret) { 775130561Sobrien dev_err(&rproc->dev, "failed to get TCM banks, err %d\n", ret); 776218822Sdim return ret; 777218822Sdim } 778218822Sdim 779218822Sdim ret = add_mem_regions_carveout(rproc); 780218822Sdim if (ret) { 78133965Sjdp dev_err(&rproc->dev, "failed to get reserve mem regions %d\n", ret); 78233965Sjdp return ret; 78333965Sjdp } 784218822Sdim 785218822Sdim return 0; 786130561Sobrien} 78733965Sjdp 78833965Sjdp/** 789130561Sobrien * zynqmp_r5_rproc_unprepare() 79033965Sjdp * Turns off TCM banks using power-domain id 79133965Sjdp * 79233965Sjdp * @rproc: Device node of each rproc 79333965Sjdp * 79433965Sjdp * Return: always 0 795130561Sobrien */ 79633965Sjdpstatic int zynqmp_r5_rproc_unprepare(struct rproc *rproc) 79733965Sjdp{ 79833965Sjdp struct zynqmp_r5_core *r5_core; 79933965Sjdp u32 pm_domain_id; 800130561Sobrien int i; 801218822Sdim 80233965Sjdp r5_core = rproc->priv; 803218822Sdim 804218822Sdim for (i = 0; i < r5_core->tcm_bank_count; i++) { 805218822Sdim pm_domain_id = r5_core->tcm_banks[i]->pm_domain_id; 806218822Sdim if (zynqmp_pm_release_node(pm_domain_id)) 807218822Sdim dev_warn(r5_core->dev, 80833965Sjdp "can't turn off TCM bank 0x%x", pm_domain_id); 80933965Sjdp } 81077298Sobrien 81133965Sjdp return 0; 812130561Sobrien} 813218822Sdim 814218822Sdimstatic const struct rproc_ops zynqmp_r5_rproc_ops = { 815218822Sdim .prepare = zynqmp_r5_rproc_prepare, 816218822Sdim .unprepare = zynqmp_r5_rproc_unprepare, 817218822Sdim .start = zynqmp_r5_rproc_start, 81833965Sjdp .stop = zynqmp_r5_rproc_stop, 81933965Sjdp .load = rproc_elf_load_segments, 820218822Sdim .parse_fw = zynqmp_r5_parse_fw, 82133965Sjdp .find_loaded_rsc_table = rproc_elf_find_loaded_rsc_table, 822218822Sdim .sanity_check = rproc_elf_sanity_check, 82333965Sjdp .get_boot_addr = rproc_elf_get_boot_addr, 824130561Sobrien .kick = zynqmp_r5_rproc_kick, 82533965Sjdp}; 82633965Sjdp 82733965Sjdp/** 82833965Sjdp * zynqmp_r5_add_rproc_core() 82933965Sjdp * Allocate and add struct rproc object for each r5f core 83089857Sobrien * This is called for each individual r5f core 83189857Sobrien * 832218822Sdim * @cdev: Device node of each r5 core 83333965Sjdp * 834130561Sobrien * Return: zynqmp_r5_core object for success else error code pointer 835218822Sdim */ 83633965Sjdpstatic struct zynqmp_r5_core *zynqmp_r5_add_rproc_core(struct device *cdev) 837130561Sobrien{ 83877298Sobrien struct zynqmp_r5_core *r5_core; 83977298Sobrien struct rproc *r5_rproc; 84077298Sobrien int ret; 84177298Sobrien 84277298Sobrien /* Set up DMA mask */ 84333965Sjdp ret = dma_set_coherent_mask(cdev, DMA_BIT_MASK(32)); 84460484Sobrien if (ret) 84577298Sobrien return ERR_PTR(ret); 84633965Sjdp 84777298Sobrien /* Allocate remoteproc instance */ 84833965Sjdp r5_rproc = rproc_alloc(cdev, dev_name(cdev), 84933965Sjdp &zynqmp_r5_rproc_ops, 85033965Sjdp NULL, sizeof(struct zynqmp_r5_core)); 85133965Sjdp if (!r5_rproc) { 85233965Sjdp dev_err(cdev, "failed to allocate memory for rproc instance\n"); 85333965Sjdp return ERR_PTR(-ENOMEM); 854130561Sobrien } 85533965Sjdp 85633965Sjdp r5_rproc->auto_boot = false; 85733965Sjdp r5_core = r5_rproc->priv; 85833965Sjdp r5_core->dev = cdev; 85933965Sjdp r5_core->np = dev_of_node(cdev); 86033965Sjdp if (!r5_core->np) { 86133965Sjdp dev_err(cdev, "can't get device node for r5 core\n"); 86233965Sjdp ret = -EINVAL; 86333965Sjdp goto free_rproc; 864218822Sdim } 86533965Sjdp 86633965Sjdp /* Add R5 remoteproc core */ 86733965Sjdp ret = rproc_add(r5_rproc); 86833965Sjdp if (ret) { 86933965Sjdp dev_err(cdev, "failed to add r5 remoteproc\n"); 87033965Sjdp goto free_rproc; 87133965Sjdp } 87233965Sjdp 87333965Sjdp r5_core->rproc = r5_rproc; 87433965Sjdp return r5_core; 87533965Sjdp 876130561Sobrienfree_rproc: 87733965Sjdp rproc_free(r5_rproc); 87833965Sjdp return ERR_PTR(ret); 87933965Sjdp} 88033965Sjdp 88177298Sobrien/** 88277298Sobrien * zynqmp_r5_get_tcm_node() 883130561Sobrien * Ideally this function should parse tcm node and store information 884218822Sdim * in r5_core instance. For now, Hardcoded TCM information is used. 885218822Sdim * This approach is used as TCM bindings for system-dt is being developed 886218822Sdim * 887218822Sdim * @cluster: pointer to zynqmp_r5_cluster type object 888218822Sdim * 88933965Sjdp * Return: 0 for success and < 0 error code for failure. 89094536Sobrien */ 89133965Sjdpstatic int zynqmp_r5_get_tcm_node(struct zynqmp_r5_cluster *cluster) 89289857Sobrien{ 89333965Sjdp const struct mem_bank_data *zynqmp_tcm_banks; 89433965Sjdp struct device *dev = cluster->dev; 89533965Sjdp struct zynqmp_r5_core *r5_core; 89633965Sjdp int tcm_bank_count, tcm_node; 89733965Sjdp int i, j; 89833965Sjdp 89933965Sjdp if (cluster->mode == SPLIT_MODE) { 90033965Sjdp zynqmp_tcm_banks = zynqmp_tcm_banks_split; 90177298Sobrien tcm_bank_count = ARRAY_SIZE(zynqmp_tcm_banks_split); 90233965Sjdp } else { 90333965Sjdp zynqmp_tcm_banks = zynqmp_tcm_banks_lockstep; 90433965Sjdp tcm_bank_count = ARRAY_SIZE(zynqmp_tcm_banks_lockstep); 90533965Sjdp } 90633965Sjdp 90733965Sjdp /* count per core tcm banks */ 90833965Sjdp tcm_bank_count = tcm_bank_count / cluster->core_count; 90933965Sjdp 91033965Sjdp /* 91133965Sjdp * r5 core 0 will use all of TCM banks in lockstep mode. 91233965Sjdp * In split mode, r5 core0 will use 128k and r5 core1 will use another 91333965Sjdp * 128k. Assign TCM banks to each core accordingly 91433965Sjdp */ 91533965Sjdp tcm_node = 0; 91633965Sjdp for (i = 0; i < cluster->core_count; i++) { 91733965Sjdp r5_core = cluster->r5_cores[i]; 91833965Sjdp r5_core->tcm_banks = devm_kcalloc(dev, tcm_bank_count, 91933965Sjdp sizeof(struct mem_bank_data *), 92033965Sjdp GFP_KERNEL); 92133965Sjdp if (!r5_core->tcm_banks) 92233965Sjdp return -ENOMEM; 92333965Sjdp 92433965Sjdp for (j = 0; j < tcm_bank_count; j++) { 92533965Sjdp /* 92633965Sjdp * Use pre-defined TCM reg values. 92733965Sjdp * Eventually this should be replaced by values 92833965Sjdp * parsed from dts. 92977298Sobrien */ 93033965Sjdp r5_core->tcm_banks[j] = 93133965Sjdp (struct mem_bank_data *)&zynqmp_tcm_banks[tcm_node]; 93233965Sjdp tcm_node++; 93333965Sjdp } 93433965Sjdp 93533965Sjdp r5_core->tcm_bank_count = tcm_bank_count; 93633965Sjdp } 93733965Sjdp 93833965Sjdp return 0; 939218822Sdim} 940218822Sdim 94133965Sjdp/* 94233965Sjdp * zynqmp_r5_core_init() 943130561Sobrien * Create and initialize zynqmp_r5_core type object 944218822Sdim * 94533965Sjdp * @cluster: pointer to zynqmp_r5_cluster type object 94694536Sobrien * @fw_reg_val: value expected by firmware to configure RPU cluster mode 94733965Sjdp * @tcm_mode: value expected by fw to configure TCM mode (lockstep or split) 948130561Sobrien * 94994536Sobrien * Return: 0 for success and error code for failure. 95094536Sobrien */ 95177298Sobrienstatic int zynqmp_r5_core_init(struct zynqmp_r5_cluster *cluster, 95294536Sobrien enum rpu_oper_mode fw_reg_val, 953218822Sdim enum rpu_tcm_comb tcm_mode) 954218822Sdim{ 95533965Sjdp struct device *dev = cluster->dev; 95633965Sjdp struct zynqmp_r5_core *r5_core; 957130561Sobrien int ret, i; 958218822Sdim 959218822Sdim ret = zynqmp_r5_get_tcm_node(cluster); 960218822Sdim if (ret < 0) { 96133965Sjdp dev_err(dev, "can't get tcm node, err %d\n", ret); 96260484Sobrien return ret; 96333965Sjdp } 96433965Sjdp 96594536Sobrien for (i = 0; i < cluster->core_count; i++) { 96694536Sobrien r5_core = cluster->r5_cores[i]; 96794536Sobrien 96894536Sobrien /* Initialize r5 cores with power-domains parsed from dts */ 96994536Sobrien ret = of_property_read_u32_index(r5_core->np, "power-domains", 97094536Sobrien 1, &r5_core->pm_domain_id); 97194536Sobrien if (ret) { 97294536Sobrien dev_err(dev, "failed to get power-domains property\n"); 97394536Sobrien return ret; 97494536Sobrien } 97594536Sobrien 97660484Sobrien ret = zynqmp_r5_set_mode(r5_core, fw_reg_val, tcm_mode); 97733965Sjdp if (ret) { 97833965Sjdp dev_err(dev, "failed to set r5 cluster mode %d, err %d\n", 97960484Sobrien cluster->mode, ret); 98033965Sjdp return ret; 98177298Sobrien } 98277298Sobrien } 98333965Sjdp 98460484Sobrien return 0; 98533965Sjdp} 98633965Sjdp 98733965Sjdp/* 98833965Sjdp * zynqmp_r5_cluster_init() 98933965Sjdp * Create and initialize zynqmp_r5_cluster type object 99060484Sobrien * 991130561Sobrien * @cluster: pointer to zynqmp_r5_cluster type object 99233965Sjdp * 99360484Sobrien * Return: 0 for success and error code for failure. 99460484Sobrien */ 99533965Sjdpstatic int zynqmp_r5_cluster_init(struct zynqmp_r5_cluster *cluster) 99633965Sjdp{ 997130561Sobrien enum zynqmp_r5_cluster_mode cluster_mode = LOCKSTEP_MODE; 99833965Sjdp struct device *dev = cluster->dev; 99933965Sjdp struct device_node *dev_node = dev_of_node(dev); 1000130561Sobrien struct platform_device *child_pdev; 1001218822Sdim struct zynqmp_r5_core **r5_cores; 100233965Sjdp enum rpu_oper_mode fw_reg_val; 100333965Sjdp struct device **child_devs; 100494536Sobrien struct device_node *child; 100533965Sjdp enum rpu_tcm_comb tcm_mode; 100633965Sjdp int core_count, ret, i; 1007130561Sobrien struct mbox_info *ipi; 1008218822Sdim 100933965Sjdp ret = of_property_read_u32(dev_node, "xlnx,cluster-mode", &cluster_mode); 101077298Sobrien 101133965Sjdp /* 101233965Sjdp * on success returns 0, if not defined then returns -EINVAL, 101333965Sjdp * In that case, default is LOCKSTEP mode. Other than that 101433965Sjdp * returns relative error code < 0. 101533965Sjdp */ 101689857Sobrien if (ret != -EINVAL && ret != 0) { 101733965Sjdp dev_err(dev, "Invalid xlnx,cluster-mode property\n"); 1018218822Sdim return ret; 101994536Sobrien } 102094536Sobrien 102194536Sobrien /* 102294536Sobrien * For now driver only supports split mode and lockstep mode. 1023130561Sobrien * fail driver probe if either of that is not set in dts. 102433965Sjdp */ 102533965Sjdp if (cluster_mode == LOCKSTEP_MODE) { 102633965Sjdp tcm_mode = PM_RPU_TCM_COMB; 102733965Sjdp fw_reg_val = PM_RPU_MODE_LOCKSTEP; 102860484Sobrien } else if (cluster_mode == SPLIT_MODE) { 102960484Sobrien tcm_mode = PM_RPU_TCM_SPLIT; 103033965Sjdp fw_reg_val = PM_RPU_MODE_SPLIT; 103177298Sobrien } else { 1032130561Sobrien dev_err(dev, "driver does not support cluster mode %d\n", cluster_mode); 103333965Sjdp return -EINVAL; 103494536Sobrien } 103594536Sobrien 103694536Sobrien /* 1037130561Sobrien * Number of cores is decided by number of child nodes of 103894536Sobrien * r5f subsystem node in dts. If Split mode is used in dts 1039130561Sobrien * 2 child nodes are expected. 104094536Sobrien * In lockstep mode if two child nodes are available, 104194536Sobrien * only use first child node and consider it as core0 1042130561Sobrien * and ignore core1 dt node. 104333965Sjdp */ 104433965Sjdp core_count = of_get_available_child_count(dev_node); 104594536Sobrien if (core_count == 0) { 104694536Sobrien dev_err(dev, "Invalid number of r5 cores %d", core_count); 104794536Sobrien return -EINVAL; 1048130561Sobrien } else if (cluster_mode == SPLIT_MODE && core_count != 2) { 104994536Sobrien dev_err(dev, "Invalid number of r5 cores for split mode\n"); 1050130561Sobrien return -EINVAL; 105194536Sobrien } else if (cluster_mode == LOCKSTEP_MODE && core_count == 2) { 1052130561Sobrien dev_warn(dev, "Only r5 core0 will be used\n"); 105333965Sjdp core_count = 1; 105433965Sjdp } 105594536Sobrien 1056130561Sobrien child_devs = kcalloc(core_count, sizeof(struct device *), GFP_KERNEL); 105733965Sjdp if (!child_devs) 105833965Sjdp return -ENOMEM; 1059130561Sobrien 106033965Sjdp r5_cores = kcalloc(core_count, 106133965Sjdp sizeof(struct zynqmp_r5_core *), GFP_KERNEL); 1062130561Sobrien if (!r5_cores) { 1063218822Sdim kfree(child_devs); 106433965Sjdp return -ENOMEM; 106533965Sjdp } 106633965Sjdp 106733965Sjdp i = 0; 106833965Sjdp for_each_available_child_of_node(dev_node, child) { 106933965Sjdp child_pdev = of_find_device_by_node(child); 107033965Sjdp if (!child_pdev) { 1071130561Sobrien of_node_put(child); 107233965Sjdp ret = -ENODEV; 107333965Sjdp goto release_r5_cores; 107433965Sjdp } 1075130561Sobrien 107633965Sjdp child_devs[i] = &child_pdev->dev; 107777298Sobrien 107833965Sjdp /* create and add remoteproc instance of type struct rproc */ 107933965Sjdp r5_cores[i] = zynqmp_r5_add_rproc_core(&child_pdev->dev); 108033965Sjdp if (IS_ERR(r5_cores[i])) { 108133965Sjdp of_node_put(child); 108233965Sjdp ret = PTR_ERR(r5_cores[i]); 1083130561Sobrien r5_cores[i] = NULL; 108433965Sjdp goto release_r5_cores; 108533965Sjdp } 108633965Sjdp 108733965Sjdp /* 108833965Sjdp * If mailbox nodes are disabled using "status" property then 1089130561Sobrien * setting up mailbox channels will fail. 1090218822Sdim */ 109133965Sjdp ipi = zynqmp_r5_setup_mbox(&child_pdev->dev); 109233965Sjdp if (ipi) { 109333965Sjdp r5_cores[i]->ipi = ipi; 109433965Sjdp ipi->r5_core = r5_cores[i]; 1095130561Sobrien } 1096218822Sdim 109733965Sjdp /* 109833965Sjdp * If two child nodes are available in dts in lockstep mode, 109933965Sjdp * then ignore second child node. 110033965Sjdp */ 110133965Sjdp if (cluster_mode == LOCKSTEP_MODE) { 1102218822Sdim of_node_put(child); 1103218822Sdim break; 110433965Sjdp } 110533965Sjdp 110633965Sjdp i++; 110733965Sjdp } 110833965Sjdp 110933965Sjdp cluster->mode = cluster_mode; 111033965Sjdp cluster->core_count = core_count; 1111218822Sdim cluster->r5_cores = r5_cores; 111233965Sjdp 111333965Sjdp ret = zynqmp_r5_core_init(cluster, fw_reg_val, tcm_mode); 111433965Sjdp if (ret < 0) { 111533965Sjdp dev_err(dev, "failed to init r5 core err %d\n", ret); 111633965Sjdp cluster->core_count = 0; 111733965Sjdp cluster->r5_cores = NULL; 111833965Sjdp 1119218822Sdim /* 112033965Sjdp * at this point rproc resources for each core are allocated. 112189857Sobrien * adjust index to free resources in reverse order 112233965Sjdp */ 112333965Sjdp i = core_count - 1; 112433965Sjdp goto release_r5_cores; 112533965Sjdp } 112633965Sjdp 112733965Sjdp kfree(child_devs); 112833965Sjdp return 0; 112933965Sjdp 113033965Sjdprelease_r5_cores: 1131218822Sdim while (i >= 0) { 113233965Sjdp put_device(child_devs[i]); 1133130561Sobrien if (r5_cores[i]) { 113433965Sjdp zynqmp_r5_free_mbox(r5_cores[i]->ipi); 113533965Sjdp of_reserved_mem_device_release(r5_cores[i]->dev); 113633965Sjdp rproc_del(r5_cores[i]->rproc); 113733965Sjdp rproc_free(r5_cores[i]->rproc); 113833965Sjdp } 113933965Sjdp i--; 114033965Sjdp } 114133965Sjdp kfree(r5_cores); 114233965Sjdp kfree(child_devs); 114333965Sjdp return ret; 114433965Sjdp} 114533965Sjdp 114633965Sjdpstatic void zynqmp_r5_cluster_exit(void *data) 114733965Sjdp{ 114877298Sobrien struct platform_device *pdev = data; 114933965Sjdp struct zynqmp_r5_cluster *cluster; 115033965Sjdp struct zynqmp_r5_core *r5_core; 115133965Sjdp int i; 115233965Sjdp 115333965Sjdp cluster = platform_get_drvdata(pdev); 115433965Sjdp if (!cluster) 115533965Sjdp return; 115633965Sjdp 1157218822Sdim for (i = 0; i < cluster->core_count; i++) { 1158218822Sdim r5_core = cluster->r5_cores[i]; 1159218822Sdim zynqmp_r5_free_mbox(r5_core->ipi); 116033965Sjdp of_reserved_mem_device_release(r5_core->dev); 116133965Sjdp put_device(r5_core->dev); 116233965Sjdp rproc_del(r5_core->rproc); 116333965Sjdp rproc_free(r5_core->rproc); 116433965Sjdp } 1165218822Sdim 1166218822Sdim kfree(cluster->r5_cores); 1167218822Sdim kfree(cluster); 1168218822Sdim platform_set_drvdata(pdev, NULL); 116933965Sjdp} 117033965Sjdp 1171218822Sdim/* 117233965Sjdp * zynqmp_r5_remoteproc_probe() 117333965Sjdp * parse device-tree, initialize hardware and allocate required resources 117433965Sjdp * and remoteproc ops 117533965Sjdp * 117633965Sjdp * @pdev: domain platform device for R5 cluster 117733965Sjdp * 1178218822Sdim * Return: 0 for success and < 0 for failure. 117933965Sjdp */ 118033965Sjdpstatic int zynqmp_r5_remoteproc_probe(struct platform_device *pdev) 118133965Sjdp{ 118233965Sjdp struct zynqmp_r5_cluster *cluster; 118333965Sjdp struct device *dev = &pdev->dev; 118433965Sjdp int ret; 1185218822Sdim 1186218822Sdim cluster = kzalloc(sizeof(*cluster), GFP_KERNEL); 1187218822Sdim if (!cluster) 1188218822Sdim return -ENOMEM; 1189218822Sdim 1190218822Sdim cluster->dev = dev; 1191218822Sdim 1192218822Sdim ret = devm_of_platform_populate(dev); 1193218822Sdim if (ret) { 1194218822Sdim dev_err_probe(dev, ret, "failed to populate platform dev\n"); 1195218822Sdim kfree(cluster); 1196218822Sdim return ret; 1197218822Sdim } 1198218822Sdim 1199218822Sdim /* wire in so each core can be cleaned up at driver remove */ 1200218822Sdim platform_set_drvdata(pdev, cluster); 1201218822Sdim 1202218822Sdim ret = zynqmp_r5_cluster_init(cluster); 1203218822Sdim if (ret) { 1204218822Sdim kfree(cluster); 1205218822Sdim platform_set_drvdata(pdev, NULL); 1206218822Sdim dev_err_probe(dev, ret, "Invalid r5f subsystem device tree\n"); 1207218822Sdim return ret; 1208218822Sdim } 1209218822Sdim 1210218822Sdim ret = devm_add_action_or_reset(dev, zynqmp_r5_cluster_exit, pdev); 121133965Sjdp if (ret) 121233965Sjdp return ret; 121333965Sjdp 1214218822Sdim return 0; 121533965Sjdp} 1216218822Sdim 1217218822Sdim/* Match table for OF platform binding */ 1218218822Sdimstatic const struct of_device_id zynqmp_r5_remoteproc_match[] = { 121933965Sjdp { .compatible = "xlnx,zynqmp-r5fss", }, 122033965Sjdp { /* end of list */ }, 122133965Sjdp}; 1222218822SdimMODULE_DEVICE_TABLE(of, zynqmp_r5_remoteproc_match); 1223218822Sdim 1224218822Sdimstatic struct platform_driver zynqmp_r5_remoteproc_driver = { 1225218822Sdim .probe = zynqmp_r5_remoteproc_probe, 122633965Sjdp .driver = { 122733965Sjdp .name = "zynqmp_r5_remoteproc", 1228218822Sdim .of_match_table = zynqmp_r5_remoteproc_match, 122933965Sjdp }, 123033965Sjdp}; 1231218822Sdimmodule_platform_driver(zynqmp_r5_remoteproc_driver); 123233965Sjdp 123333965SjdpMODULE_DESCRIPTION("Xilinx R5F remote processor driver"); 123433965SjdpMODULE_AUTHOR("Xilinx Inc."); 1235218822SdimMODULE_LICENSE("GPL"); 123633965Sjdp