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 */
scp_ipi_register(struct mtk_scp * scp,u32 id,scp_ipi_handler_t handler,void * priv)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 */
scp_ipi_unregister(struct mtk_scp * scp,u32 id)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 */
scp_memcpy_aligned(void __iomem * dst,const void * src,unsigned int len)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 */
scp_ipi_lock(struct mtk_scp * scp,u32 id)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 */
scp_ipi_unlock(struct mtk_scp * scp,u32 id)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 **/
scp_ipi_send(struct mtk_scp * scp,u32 id,void * buf,unsigned int len,unsigned int wait)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