1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // Copyright (c) 2019 MediaTek Inc. 4 5 #include <asm/barrier.h> 6 #include <linux/clk.h> 7 #include <linux/err.h> 8 #include <linux/io.h> 9 #include <linux/iopoll.h> 10 #include <linux/kernel.h> 11 #include <linux/module.h> 12 #include <linux/platform_device.h> 13 #include <linux/time64.h> 14 #include <linux/remoteproc/mtk_scp.h> 15 16 #include "mtk_common.h" 17 18 #define SCP_TIMEOUT_US (2000 * USEC_PER_MSEC) 19 20 /** 21 * scp_ipi_register() - register an ipi function 22 * 23 * @scp: mtk_scp structure 24 * @id: IPI ID 25 * @handler: IPI handler 26 * @priv: private data for IPI handler 27 * 28 * Register an ipi function to receive ipi interrupt from SCP. 29 * 30 * Return: 0 if ipi registers successfully, -error on error. 31 */ 32 int scp_ipi_register(struct mtk_scp *scp, 33 u32 id, 34 scp_ipi_handler_t handler, 35 void *priv) 36 { 37 if (!scp) 38 return -EPROBE_DEFER; 39 40 if (WARN_ON(id >= SCP_IPI_MAX) || WARN_ON(handler == NULL)) 41 return -EINVAL; 42 43 scp_ipi_lock(scp, id); 44 scp->ipi_desc[id].handler = handler; 45 scp->ipi_desc[id].priv = priv; 46 scp_ipi_unlock(scp, id); 47 48 return 0; 49 } 50 EXPORT_SYMBOL_GPL(scp_ipi_register); 51 52 /** 53 * scp_ipi_unregister() - unregister an ipi function 54 * 55 * @scp: mtk_scp structure 56 * @id: IPI ID 57 * 58 * Unregister an ipi function to receive ipi interrupt from SCP. 59 */ 60 void scp_ipi_unregister(struct mtk_scp *scp, u32 id) 61 { 62 if (!scp) 63 return; 64 65 if (WARN_ON(id >= SCP_IPI_MAX)) 66 return; 67 68 scp_ipi_lock(scp, id); 69 scp->ipi_desc[id].handler = NULL; 70 scp->ipi_desc[id].priv = NULL; 71 scp_ipi_unlock(scp, id); 72 } 73 EXPORT_SYMBOL_GPL(scp_ipi_unregister); 74 75 /* 76 * scp_memcpy_aligned() - Copy src to dst, where dst is in SCP SRAM region. 77 * 78 * @dst: Pointer to the destination buffer, should be in SCP SRAM region. 79 * @src: Pointer to the source buffer. 80 * @len: Length of the source buffer to be copied. 81 * 82 * Since AP access of SCP SRAM don't support byte write, this always write a 83 * full word at a time, and may cause some extra bytes to be written at the 84 * beginning & ending of dst. 85 */ 86 void scp_memcpy_aligned(void __iomem *dst, const void *src, unsigned int len) 87 { 88 void __iomem *ptr; 89 u32 val; 90 unsigned int i = 0, remain; 91 92 if (!IS_ALIGNED((unsigned long)dst, 4)) { 93 ptr = (void __iomem *)ALIGN_DOWN((unsigned long)dst, 4); 94 i = 4 - (dst - ptr); 95 val = readl_relaxed(ptr); 96 memcpy((u8 *)&val + (4 - i), src, i); 97 writel_relaxed(val, ptr); 98 } 99 100 __iowrite32_copy(dst + i, src + i, (len - i) / 4); 101 remain = (len - i) % 4; 102 103 if (remain > 0) { 104 val = readl_relaxed(dst + len - remain); 105 memcpy(&val, src + len - remain, remain); 106 writel_relaxed(val, dst + len - remain); 107 } 108 } 109 EXPORT_SYMBOL_GPL(scp_memcpy_aligned); 110 111 /** 112 * scp_ipi_lock() - Lock before operations of an IPI ID 113 * 114 * @scp: mtk_scp structure 115 * @id: IPI ID 116 * 117 * Note: This should not be used by drivers other than mtk_scp. 118 */ 119 void scp_ipi_lock(struct mtk_scp *scp, u32 id) 120 { 121 if (WARN_ON(id >= SCP_IPI_MAX)) 122 return; 123 mutex_lock(&scp->ipi_desc[id].lock); 124 } 125 EXPORT_SYMBOL_GPL(scp_ipi_lock); 126 127 /** 128 * scp_ipi_unlock() - Unlock after operations of an IPI ID 129 * 130 * @scp: mtk_scp structure 131 * @id: IPI ID 132 * 133 * Note: This should not be used by drivers other than mtk_scp. 134 */ 135 void scp_ipi_unlock(struct mtk_scp *scp, u32 id) 136 { 137 if (WARN_ON(id >= SCP_IPI_MAX)) 138 return; 139 mutex_unlock(&scp->ipi_desc[id].lock); 140 } 141 EXPORT_SYMBOL_GPL(scp_ipi_unlock); 142 143 /** 144 * scp_ipi_send() - send data from AP to scp. 145 * 146 * @scp: mtk_scp structure 147 * @id: IPI ID 148 * @buf: the data buffer 149 * @len: the data buffer length 150 * @wait: number of msecs to wait for ack. 0 to skip waiting. 151 * 152 * This function is thread-safe. When this function returns, 153 * SCP has received the data and starts the processing. 154 * When the processing completes, IPI handler registered 155 * by scp_ipi_register will be called in interrupt context. 156 * 157 * Return: 0 if sending data successfully, -error on error. 158 **/ 159 int scp_ipi_send(struct mtk_scp *scp, u32 id, void *buf, unsigned int len, 160 unsigned int wait) 161 { 162 struct mtk_share_obj __iomem *send_obj = scp->send_buf; 163 u32 val; 164 int ret; 165 166 if (WARN_ON(id <= SCP_IPI_INIT) || WARN_ON(id >= SCP_IPI_MAX) || 167 WARN_ON(id == SCP_IPI_NS_SERVICE) || 168 WARN_ON(len > sizeof(send_obj->share_buf)) || WARN_ON(!buf)) 169 return -EINVAL; 170 171 ret = clk_prepare_enable(scp->clk); 172 if (ret) { 173 dev_err(scp->dev, "failed to enable clock\n"); 174 return ret; 175 } 176 177 mutex_lock(&scp->send_lock); 178 179 /* Wait until SCP receives the last command */ 180 ret = readl_poll_timeout_atomic(scp->reg_base + scp->data->host_to_scp_reg, 181 val, !val, 0, SCP_TIMEOUT_US); 182 if (ret) { 183 dev_err(scp->dev, "%s: IPI timeout!\n", __func__); 184 goto unlock_mutex; 185 } 186 187 scp_memcpy_aligned(send_obj->share_buf, buf, len); 188 189 writel(len, &send_obj->len); 190 writel(id, &send_obj->id); 191 192 scp->ipi_id_ack[id] = false; 193 /* send the command to SCP */ 194 writel(scp->data->host_to_scp_int_bit, 195 scp->reg_base + scp->data->host_to_scp_reg); 196 197 if (wait) { 198 /* wait for SCP's ACK */ 199 ret = wait_event_timeout(scp->ack_wq, 200 scp->ipi_id_ack[id], 201 msecs_to_jiffies(wait)); 202 scp->ipi_id_ack[id] = false; 203 if (WARN(!ret, "scp ipi %d ack time out !", id)) 204 ret = -EIO; 205 else 206 ret = 0; 207 } 208 209 unlock_mutex: 210 mutex_unlock(&scp->send_lock); 211 clk_disable_unprepare(scp->clk); 212 213 return ret; 214 } 215 EXPORT_SYMBOL_GPL(scp_ipi_send); 216 217 MODULE_LICENSE("GPL v2"); 218 MODULE_DESCRIPTION("MediaTek scp IPI interface"); 219