1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
|
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2017-2018 Intel Corporation <www.intel.com>
*
*/
#include <common.h>
#include <hang.h>
#include <wait_bit.h>
#include <asm/io.h>
#include <asm/arch/mailbox_s10.h>
#include <asm/arch/system_manager.h>
#include <asm/secure.h>
DECLARE_GLOBAL_DATA_PTR;
#define MBOX_READL(reg) \
readl(SOCFPGA_MAILBOX_ADDRESS + (reg))
#define MBOX_WRITEL(data, reg) \
writel(data, SOCFPGA_MAILBOX_ADDRESS + (reg))
#define MBOX_READ_RESP_BUF(rout) \
MBOX_READL(MBOX_RESP_BUF + ((rout) * sizeof(u32)))
#define MBOX_WRITE_CMD_BUF(data, cin) \
MBOX_WRITEL(data, MBOX_CMD_BUF + ((cin) * sizeof(u32)))
static __always_inline int mbox_polling_resp(u32 rout)
{
u32 rin;
unsigned long i = 2000;
while (i) {
rin = MBOX_READL(MBOX_RIN);
if (rout != rin)
return 0;
udelay(1000);
i--;
}
return -ETIMEDOUT;
}
/* Check for available slot and write to circular buffer.
* It also update command valid offset (cin) register.
*/
static __always_inline int mbox_fill_cmd_circular_buff(u32 header, u32 len,
u32 *arg)
{
u32 cin;
u32 cout;
u32 i;
cin = MBOX_READL(MBOX_CIN) % MBOX_CMD_BUFFER_SIZE;
cout = MBOX_READL(MBOX_COUT) % MBOX_CMD_BUFFER_SIZE;
/* if command buffer is full or not enough free space
* to fit the data. Note, len is in u32 unit.
*/
if (((cin + 1) % MBOX_CMD_BUFFER_SIZE) == cout ||
((MBOX_CMD_BUFFER_SIZE - cin + cout - 1) %
MBOX_CMD_BUFFER_SIZE) < (len + 1))
return -ENOMEM;
/* write header to circular buffer */
MBOX_WRITE_CMD_BUF(header, cin++);
/* wrapping around when it reach the buffer size */
cin %= MBOX_CMD_BUFFER_SIZE;
/* write arguments */
for (i = 0; i < len; i++) {
MBOX_WRITE_CMD_BUF(arg[i], cin++);
/* wrapping around when it reach the buffer size */
cin %= MBOX_CMD_BUFFER_SIZE;
}
/* write command valid offset */
MBOX_WRITEL(cin, MBOX_CIN);
return 0;
}
/* Check the command and fill it into circular buffer */
static __always_inline int mbox_prepare_cmd_only(u8 id, u32 cmd,
u8 is_indirect, u32 len,
u32 *arg)
{
u32 header;
int ret;
/* Total length is command + argument length */
if ((len + 1) > MBOX_CMD_BUFFER_SIZE)
return -EINVAL;
if (cmd > MBOX_MAX_CMD_INDEX)
return -EINVAL;
header = MBOX_CMD_HEADER(MBOX_CLIENT_ID_UBOOT, id, len,
(is_indirect) ? 1 : 0, cmd);
ret = mbox_fill_cmd_circular_buff(header, len, arg);
return ret;
}
/* Send command only without waiting for responses from SDM */
static __always_inline int mbox_send_cmd_only_common(u8 id, u32 cmd,
u8 is_indirect, u32 len,
u32 *arg)
{
int ret = mbox_prepare_cmd_only(id, cmd, is_indirect, len, arg);
/* write doorbell */
MBOX_WRITEL(1, MBOX_DOORBELL_TO_SDM);
return ret;
}
/* Return number of responses received in buffer */
static __always_inline int __mbox_rcv_resp(u32 *resp_buf, u32 resp_buf_max_len)
{
u32 rin;
u32 rout;
u32 resp_len = 0;
/* clear doorbell from SDM if it was SET */
if (MBOX_READL(MBOX_DOORBELL_FROM_SDM) & 1)
MBOX_WRITEL(0, MBOX_DOORBELL_FROM_SDM);
/* read current response offset */
rout = MBOX_READL(MBOX_ROUT);
/* read response valid offset */
rin = MBOX_READL(MBOX_RIN);
while (rin != rout && (resp_len < resp_buf_max_len)) {
/* Response received */
if (resp_buf)
resp_buf[resp_len++] = MBOX_READ_RESP_BUF(rout);
rout++;
/* wrapping around when it reach the buffer size */
rout %= MBOX_RESP_BUFFER_SIZE;
/* update next ROUT */
MBOX_WRITEL(rout, MBOX_ROUT);
}
return resp_len;
}
/* Support one command and up to 31 words argument length only */
static __always_inline int mbox_send_cmd_common(u8 id, u32 cmd, u8 is_indirect,
u32 len, u32 *arg, u8 urgent,
u32 *resp_buf_len,
u32 *resp_buf)
{
u32 rin;
u32 resp;
u32 rout;
u32 status;
u32 resp_len;
u32 buf_len;
int ret;
if (urgent) {
/* Read status because it is toggled */
status = MBOX_READL(MBOX_STATUS) & MBOX_STATUS_UA_MSK;
/* Write urgent command to urgent register */
MBOX_WRITEL(cmd, MBOX_URG);
} else {
ret = mbox_prepare_cmd_only(id, cmd, is_indirect, len, arg);
if (ret)
return ret;
}
/* write doorbell */
MBOX_WRITEL(1, MBOX_DOORBELL_TO_SDM);
while (1) {
ret = 1000;
/* Wait for doorbell from SDM */
do {
if (MBOX_READL(MBOX_DOORBELL_FROM_SDM))
break;
udelay(1000);
} while (--ret);
if (!ret)
return -ETIMEDOUT;
/* clear interrupt */
MBOX_WRITEL(0, MBOX_DOORBELL_FROM_SDM);
if (urgent) {
u32 new_status = MBOX_READL(MBOX_STATUS);
/* Urgent ACK is toggled */
if ((new_status & MBOX_STATUS_UA_MSK) ^ status)
return 0;
return -ECOMM;
}
/* read current response offset */
rout = MBOX_READL(MBOX_ROUT);
/* read response valid offset */
rin = MBOX_READL(MBOX_RIN);
if (rout != rin) {
/* Response received */
resp = MBOX_READ_RESP_BUF(rout);
rout++;
/* wrapping around when it reach the buffer size */
rout %= MBOX_RESP_BUFFER_SIZE;
/* update next ROUT */
MBOX_WRITEL(rout, MBOX_ROUT);
/* check client ID and ID */
if ((MBOX_RESP_CLIENT_GET(resp) ==
MBOX_CLIENT_ID_UBOOT) &&
(MBOX_RESP_ID_GET(resp) == id)) {
ret = MBOX_RESP_ERR_GET(resp);
if (ret)
return ret;
if (resp_buf_len) {
buf_len = *resp_buf_len;
*resp_buf_len = 0;
} else {
buf_len = 0;
}
resp_len = MBOX_RESP_LEN_GET(resp);
while (resp_len) {
ret = mbox_polling_resp(rout);
if (ret)
return ret;
/* we need to process response buffer
* even caller doesn't need it
*/
resp = MBOX_READ_RESP_BUF(rout);
rout++;
resp_len--;
rout %= MBOX_RESP_BUFFER_SIZE;
MBOX_WRITEL(rout, MBOX_ROUT);
if (buf_len) {
/* copy response to buffer */
resp_buf[*resp_buf_len] = resp;
(*resp_buf_len)++;
buf_len--;
}
}
return ret;
}
}
};
return -EIO;
}
int mbox_init(void)
{
int ret;
/* enable mailbox interrupts */
MBOX_WRITEL(MBOX_ALL_INTRS, MBOX_FLAGS);
/* Ensure urgent request is cleared */
MBOX_WRITEL(0, MBOX_URG);
/* Ensure the Doorbell Interrupt is cleared */
MBOX_WRITEL(0, MBOX_DOORBELL_FROM_SDM);
ret = mbox_send_cmd(MBOX_ID_UBOOT, MBOX_RESTART, MBOX_CMD_DIRECT, 0,
NULL, 1, 0, NULL);
if (ret)
return ret;
/* Renable mailbox interrupts after MBOX_RESTART */
MBOX_WRITEL(MBOX_ALL_INTRS, MBOX_FLAGS);
return 0;
}
#ifdef CONFIG_CADENCE_QSPI
int mbox_qspi_close(void)
{
return mbox_send_cmd(MBOX_ID_UBOOT, MBOX_QSPI_CLOSE, MBOX_CMD_DIRECT,
0, NULL, 0, 0, NULL);
}
int mbox_qspi_open(void)
{
int ret;
u32 resp_buf[1];
u32 resp_buf_len;
ret = mbox_send_cmd(MBOX_ID_UBOOT, MBOX_QSPI_OPEN, MBOX_CMD_DIRECT,
0, NULL, 0, 0, NULL);
if (ret) {
/* retry again by closing and reopen the QSPI again */
ret = mbox_qspi_close();
if (ret)
return ret;
ret = mbox_send_cmd(MBOX_ID_UBOOT, MBOX_QSPI_OPEN,
MBOX_CMD_DIRECT, 0, NULL, 0, 0, NULL);
if (ret)
return ret;
}
/* HPS will directly control the QSPI controller, no longer mailbox */
resp_buf_len = 1;
ret = mbox_send_cmd(MBOX_ID_UBOOT, MBOX_QSPI_DIRECT, MBOX_CMD_DIRECT,
0, NULL, 0, (u32 *)&resp_buf_len,
(u32 *)&resp_buf);
if (ret)
goto error;
/* We are getting QSPI ref clock and set into sysmgr boot register */
printf("QSPI: Reference clock at %d Hz\n", resp_buf[0]);
writel(resp_buf[0],
socfpga_get_sysmgr_addr() + SYSMGR_SOC64_BOOT_SCRATCH_COLD0);
return 0;
error:
mbox_qspi_close();
return ret;
}
#endif /* CONFIG_CADENCE_QSPI */
int mbox_reset_cold(void)
{
int ret;
ret = mbox_send_cmd(MBOX_ID_UBOOT, MBOX_REBOOT_HPS, MBOX_CMD_DIRECT,
0, NULL, 0, 0, NULL);
if (ret) {
/* mailbox sent failure, wait for watchdog to kick in */
hang();
}
return 0;
}
/* Accepted commands: CONFIG_STATUS or RECONFIG_STATUS */
static __always_inline int mbox_get_fpga_config_status_common(u32 cmd)
{
u32 reconfig_status_resp_len;
u32 reconfig_status_resp[RECONFIG_STATUS_RESPONSE_LEN];
int ret;
reconfig_status_resp_len = RECONFIG_STATUS_RESPONSE_LEN;
ret = mbox_send_cmd_common(MBOX_ID_UBOOT, cmd,
MBOX_CMD_DIRECT, 0, NULL, 0,
&reconfig_status_resp_len,
reconfig_status_resp);
if (ret)
return ret;
/* Check for any error */
ret = reconfig_status_resp[RECONFIG_STATUS_STATE];
if (ret && ret != MBOX_CFGSTAT_STATE_CONFIG)
return ret;
/* Make sure nStatus is not 0 */
ret = reconfig_status_resp[RECONFIG_STATUS_PIN_STATUS];
if (!(ret & RCF_PIN_STATUS_NSTATUS))
return MBOX_CFGSTAT_STATE_ERROR_HARDWARE;
ret = reconfig_status_resp[RECONFIG_STATUS_SOFTFUNC_STATUS];
if (ret & RCF_SOFTFUNC_STATUS_SEU_ERROR)
return MBOX_CFGSTAT_STATE_ERROR_HARDWARE;
if ((ret & RCF_SOFTFUNC_STATUS_CONF_DONE) &&
(ret & RCF_SOFTFUNC_STATUS_INIT_DONE) &&
!reconfig_status_resp[RECONFIG_STATUS_STATE])
return 0; /* configuration success */
return MBOX_CFGSTAT_STATE_CONFIG;
}
int mbox_get_fpga_config_status(u32 cmd)
{
return mbox_get_fpga_config_status_common(cmd);
}
int __secure mbox_get_fpga_config_status_psci(u32 cmd)
{
return mbox_get_fpga_config_status_common(cmd);
}
int mbox_send_cmd(u8 id, u32 cmd, u8 is_indirect, u32 len, u32 *arg,
u8 urgent, u32 *resp_buf_len, u32 *resp_buf)
{
return mbox_send_cmd_common(id, cmd, is_indirect, len, arg, urgent,
resp_buf_len, resp_buf);
}
int __secure mbox_send_cmd_psci(u8 id, u32 cmd, u8 is_indirect, u32 len,
u32 *arg, u8 urgent, u32 *resp_buf_len,
u32 *resp_buf)
{
return mbox_send_cmd_common(id, cmd, is_indirect, len, arg, urgent,
resp_buf_len, resp_buf);
}
int mbox_send_cmd_only(u8 id, u32 cmd, u8 is_indirect, u32 len, u32 *arg)
{
return mbox_send_cmd_only_common(id, cmd, is_indirect, len, arg);
}
int __secure mbox_send_cmd_only_psci(u8 id, u32 cmd, u8 is_indirect, u32 len,
u32 *arg)
{
return mbox_send_cmd_only_common(id, cmd, is_indirect, len, arg);
}
int mbox_rcv_resp(u32 *resp_buf, u32 resp_buf_max_len)
{
return __mbox_rcv_resp(resp_buf, resp_buf_max_len);
}
int __secure mbox_rcv_resp_psci(u32 *resp_buf, u32 resp_buf_max_len)
{
return __mbox_rcv_resp(resp_buf, resp_buf_max_len);
}
|