1 /*
2 * Copyright (c) 2013-2020, ARM Limited and Contributors. All rights reserved.
3 * Copyright (c) 2019-2022, Xilinx, Inc. All rights reserved.
4 * Copyright (c) 2022, Advanced Micro Devices, Inc. All rights reserved.
5 *
6 * SPDX-License-Identifier: BSD-3-Clause
7 */
8
9
10 #include <arch_helpers.h>
11 #include <lib/bakery_lock.h>
12 #include <lib/mmio.h>
13 #include <ipi.h>
14 #include <plat_ipi.h>
15 #include <plat_private.h>
16 #include <plat/common/platform.h>
17
18 #include "pm_defs.h"
19 #include "pm_ipi.h"
20
21 #define ERROR_CODE_MASK (0xFFFFU)
22 #define PM_OFFSET (0U)
23
24 DEFINE_BAKERY_LOCK(pm_secure_lock);
25
26 /**
27 * pm_ipi_init() - Initialize IPI peripheral for communication with
28 * remote processor
29 *
30 * @proc Pointer to the processor who is initiating request
31 * @return On success, the initialization function must return 0.
32 * Any other return value will cause the framework to ignore
33 * the service
34 *
35 * Called from pm_setup initialization function
36 */
pm_ipi_init(const struct pm_proc * proc)37 void pm_ipi_init(const struct pm_proc *proc)
38 {
39 bakery_lock_init(&pm_secure_lock);
40 ipi_mb_open(proc->ipi->local_ipi_id, proc->ipi->remote_ipi_id);
41 }
42
43 /**
44 * pm_ipi_send_common() - Sends IPI request to the remote processor
45 * @proc Pointer to the processor who is initiating request
46 * @payload API id and call arguments to be written in IPI buffer
47 *
48 * Send an IPI request to the power controller. Caller needs to hold
49 * the 'pm_secure_lock' lock.
50 *
51 * @return Returns status, either success or error+reason
52 */
pm_ipi_send_common(const struct pm_proc * proc,uint32_t payload[PAYLOAD_ARG_CNT],uint32_t is_blocking)53 static enum pm_ret_status pm_ipi_send_common(const struct pm_proc *proc,
54 uint32_t payload[PAYLOAD_ARG_CNT],
55 uint32_t is_blocking)
56 {
57 uint32_t offset = PM_OFFSET;
58 uintptr_t buffer_base = proc->ipi->buffer_base +
59 IPI_BUFFER_TARGET_REMOTE_OFFSET +
60 IPI_BUFFER_REQ_OFFSET;
61 #if IPI_CRC_CHECK
62 payload[PAYLOAD_CRC_POS] = calculate_crc(payload, IPI_W0_TO_W6_SIZE);
63 #endif
64
65 /* Write payload into IPI buffer */
66 for (size_t i = 0; i < PAYLOAD_ARG_CNT; i++) {
67 mmio_write_32(buffer_base + offset, payload[i]);
68 offset += PAYLOAD_ARG_SIZE;
69 }
70
71 /* Generate IPI to remote processor */
72 ipi_mb_notify(proc->ipi->local_ipi_id, proc->ipi->remote_ipi_id,
73 is_blocking);
74
75 return PM_RET_SUCCESS;
76 }
77
78 /**
79 * pm_ipi_send_non_blocking() - Sends IPI request to the remote processor
80 * without blocking notification
81 * @proc Pointer to the processor who is initiating request
82 * @payload API id and call arguments to be written in IPI buffer
83 *
84 * Send an IPI request to the power controller.
85 *
86 * @return Returns status, either success or error+reason
87 */
pm_ipi_send_non_blocking(const struct pm_proc * proc,uint32_t payload[PAYLOAD_ARG_CNT])88 enum pm_ret_status pm_ipi_send_non_blocking(const struct pm_proc *proc,
89 uint32_t payload[PAYLOAD_ARG_CNT])
90 {
91 enum pm_ret_status ret;
92
93 bakery_lock_get(&pm_secure_lock);
94
95 ret = pm_ipi_send_common(proc, payload, IPI_NON_BLOCKING);
96
97 bakery_lock_release(&pm_secure_lock);
98
99 return ret;
100 }
101
102 /**
103 * pm_ipi_send() - Sends IPI request to the remote processor
104 * @proc Pointer to the processor who is initiating request
105 * @payload API id and call arguments to be written in IPI buffer
106 *
107 * Send an IPI request to the power controller.
108 *
109 * @return Returns status, either success or error+reason
110 */
pm_ipi_send(const struct pm_proc * proc,uint32_t payload[PAYLOAD_ARG_CNT])111 enum pm_ret_status pm_ipi_send(const struct pm_proc *proc,
112 uint32_t payload[PAYLOAD_ARG_CNT])
113 {
114 enum pm_ret_status ret;
115
116 bakery_lock_get(&pm_secure_lock);
117
118 ret = pm_ipi_send_common(proc, payload, IPI_BLOCKING);
119
120 bakery_lock_release(&pm_secure_lock);
121
122 return ret;
123 }
124
125
126 /**
127 * pm_ipi_buff_read() - Reads IPI response after remote processor has handled
128 * interrupt
129 * @proc Pointer to the processor who is waiting and reading response
130 * @value Used to return value from IPI buffer element (optional)
131 * @count Number of values to return in @value
132 *
133 * @return Returns status, either success or error+reason
134 */
pm_ipi_buff_read(const struct pm_proc * proc,uint32_t * value,size_t count)135 static enum pm_ret_status pm_ipi_buff_read(const struct pm_proc *proc,
136 uint32_t *value, size_t count)
137 {
138 size_t i;
139 #if IPI_CRC_CHECK
140 size_t j;
141 uint32_t response_payload[PAYLOAD_ARG_CNT];
142 #endif
143 uintptr_t buffer_base = proc->ipi->buffer_base +
144 IPI_BUFFER_TARGET_REMOTE_OFFSET +
145 IPI_BUFFER_RESP_OFFSET;
146
147 /*
148 * Read response from IPI buffer
149 * buf-0: success or error+reason
150 * buf-1: value
151 * buf-2: unused
152 * buf-3: unused
153 */
154 for (i = 1; i <= count; i++) {
155 *value = mmio_read_32(buffer_base + (i * PAYLOAD_ARG_SIZE));
156 value++;
157 }
158 #if IPI_CRC_CHECK
159 for (j = 0; j < PAYLOAD_ARG_CNT; j++) {
160 response_payload[j] = mmio_read_32(buffer_base +
161 (j * PAYLOAD_ARG_SIZE));
162 }
163
164 if (response_payload[PAYLOAD_CRC_POS] !=
165 calculate_crc(response_payload, IPI_W0_TO_W6_SIZE)) {
166 NOTICE("ERROR in CRC response payload value:0x%x\n",
167 response_payload[PAYLOAD_CRC_POS]);
168 }
169 #endif
170
171 return mmio_read_32(buffer_base);
172 }
173
174 /**
175 * pm_ipi_buff_read_callb() - Reads IPI response after remote processor has
176 * handled interrupt
177 * @value Used to return value from IPI buffer element (optional)
178 * @count Number of values to return in @value
179 *
180 * @return Returns status, either success or error+reason
181 */
pm_ipi_buff_read_callb(uint32_t * value,size_t count)182 void pm_ipi_buff_read_callb(uint32_t *value, size_t count)
183 {
184 size_t i;
185 #if IPI_CRC_CHECK
186 size_t j;
187 unsigned int response_payload[PAYLOAD_ARG_CNT] = {0};
188 #endif
189 uintptr_t buffer_base = IPI_BUFFER_REMOTE_BASE +
190 IPI_BUFFER_TARGET_LOCAL_OFFSET +
191 IPI_BUFFER_REQ_OFFSET;
192
193 if (count > IPI_BUFFER_MAX_WORDS) {
194 count = IPI_BUFFER_MAX_WORDS;
195 }
196
197 for (i = 0; i <= count; i++) {
198 *value = mmio_read_32(buffer_base + (i * PAYLOAD_ARG_SIZE));
199 value++;
200 }
201 #if IPI_CRC_CHECK
202 for (j = 0; j < PAYLOAD_ARG_CNT; j++) {
203 response_payload[j] = mmio_read_32(buffer_base +
204 (j * PAYLOAD_ARG_SIZE));
205 }
206
207 if (response_payload[PAYLOAD_CRC_POS] !=
208 calculate_crc(response_payload, IPI_W0_TO_W6_SIZE)) {
209 NOTICE("ERROR in CRC response payload value:0x%x\n",
210 response_payload[PAYLOAD_CRC_POS]);
211 }
212 #endif
213 }
214
215 /**
216 * pm_ipi_send_sync() - Sends IPI request to the remote processor
217 * @proc Pointer to the processor who is initiating request
218 * @payload API id and call arguments to be written in IPI buffer
219 * @value Used to return value from IPI buffer element (optional)
220 * @count Number of values to return in @value
221 *
222 * Send an IPI request to the power controller and wait for it to be handled.
223 *
224 * @return Returns status, either success or error+reason and, optionally,
225 * @value
226 */
pm_ipi_send_sync(const struct pm_proc * proc,uint32_t payload[PAYLOAD_ARG_CNT],uint32_t * value,size_t count)227 enum pm_ret_status pm_ipi_send_sync(const struct pm_proc *proc,
228 uint32_t payload[PAYLOAD_ARG_CNT],
229 uint32_t *value, size_t count)
230 {
231 enum pm_ret_status ret;
232
233 bakery_lock_get(&pm_secure_lock);
234
235 ret = pm_ipi_send_common(proc, payload, IPI_BLOCKING);
236 if (ret != PM_RET_SUCCESS) {
237 goto unlock;
238 }
239
240 ret = ERROR_CODE_MASK & (pm_ipi_buff_read(proc, value, count));
241
242 unlock:
243 bakery_lock_release(&pm_secure_lock);
244
245 return ret;
246 }
247
pm_ipi_irq_enable(const struct pm_proc * proc)248 void pm_ipi_irq_enable(const struct pm_proc *proc)
249 {
250 ipi_mb_enable_irq(proc->ipi->local_ipi_id, proc->ipi->remote_ipi_id);
251 }
252
pm_ipi_irq_clear(const struct pm_proc * proc)253 void pm_ipi_irq_clear(const struct pm_proc *proc)
254 {
255 ipi_mb_ack(proc->ipi->local_ipi_id, proc->ipi->remote_ipi_id);
256 }
257
pm_ipi_irq_status(const struct pm_proc * proc)258 uint32_t pm_ipi_irq_status(const struct pm_proc *proc)
259 {
260 int32_t ret;
261
262 ret = ipi_mb_enquire_status(proc->ipi->local_ipi_id,
263 proc->ipi->remote_ipi_id);
264 if (ret & IPI_MB_STATUS_RECV_PENDING) {
265 return 1;
266 } else {
267 return 0;
268 }
269 }
270
271 #if IPI_CRC_CHECK
calculate_crc(uint32_t payload[PAYLOAD_ARG_CNT],uint32_t bufsize)272 uint32_t calculate_crc(uint32_t payload[PAYLOAD_ARG_CNT], uint32_t bufsize)
273 {
274 uint32_t crcinit = CRC_INIT_VALUE;
275 uint32_t order = CRC_ORDER;
276 uint32_t polynom = CRC_POLYNOM;
277 uint32_t i, j, c, bit, datain, crcmask, crchighbit;
278 uint32_t crc = crcinit;
279
280 crcmask = ((uint32_t)((1U << (order - 1U)) - 1U) << 1U) | 1U;
281 crchighbit = (uint32_t)(1U << (order - 1U));
282
283 for (i = 0U; i < bufsize; i++) {
284 datain = mmio_read_8((unsigned long)payload + i);
285 c = datain;
286 j = 0x80U;
287 while (j != 0U) {
288 bit = crc & crchighbit;
289 crc <<= 1U;
290 if (0U != (c & j))
291 bit ^= crchighbit;
292 if (bit != 0U)
293 crc ^= polynom;
294 j >>= 1U;
295 }
296 crc &= crcmask;
297 }
298 return crc;
299 }
300 #endif
301