socfpga_mailbox.c 10.6 KB
Newer Older
1
/*
2
 * Copyright (c) 2020, Intel Corporation. All rights reserved.
3
4
5
6
7
8
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

#include <lib/mmio.h>
#include <common/debug.h>
9
#include <drivers/delay_timer.h>
10

11
#include "socfpga_mailbox.h"
12
#include "socfpga_sip_svc.h"
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

static bool is_mailbox_cmdbuf_full(uint32_t cin)
{
	uint32_t cout = mmio_read_32(MBOX_OFFSET + MBOX_COUT);

	return (((cin + 1U) % MBOX_CMD_BUFFER_SIZE) == cout);
}

static bool is_mailbox_cmdbuf_empty(uint32_t cin)
{
	uint32_t cout = mmio_read_32(MBOX_OFFSET + MBOX_COUT);

	return (((cout + 1U) % MBOX_CMD_BUFFER_SIZE) == cin);
}

static int wait_for_mailbox_cmdbuf_empty(uint32_t cin)
{
	uint32_t timeout = 200U;

	do {
		if (is_mailbox_cmdbuf_empty(cin)) {
			break;
		}
		mdelay(10U);
	} while (--timeout != 0U);

	if (timeout == 0U) {
		return MBOX_TIMEOUT;
	}

	return MBOX_RET_OK;
}

static int write_mailbox_cmd_buffer(uint32_t *cin, uint32_t cout,
				    uint32_t data,
				    bool *is_doorbell_triggered)
{
	uint32_t timeout = 100U;

	do {
		if (is_mailbox_cmdbuf_full(*cin)) {
			if (!(*is_doorbell_triggered)) {
				mmio_write_32(MBOX_OFFSET +
					      MBOX_DOORBELL_TO_SDM, 1);
				*is_doorbell_triggered = true;
			}
			mdelay(10U);
		} else {
			mmio_write_32(MBOX_OFFSET + MBOX_CMD_BUFFER +
				      (*cin * 4), data);
			(*cin)++;
			*cin %= MBOX_CMD_BUFFER_SIZE;
			mmio_write_32(MBOX_OFFSET + MBOX_CIN, *cin);
			break;
		}
	} while (--timeout != 0U);

	if (timeout == 0U) {
		return MBOX_TIMEOUT;
	}

	if (*is_doorbell_triggered) {
		int ret = wait_for_mailbox_cmdbuf_empty(*cin);
		return ret;
	}

	return MBOX_RET_OK;
}

83
static int fill_mailbox_circular_buffer(uint32_t header_cmd, uint32_t *args,
84
85
					int len)
{
86
	uint32_t sdm_read_offset, cmd_free_offset;
87
88
89
	uint32_t i;
	int ret;
	bool is_doorbell_triggered = false;
90
91

	cmd_free_offset = mmio_read_32(MBOX_OFFSET + MBOX_CIN);
92
93
	sdm_read_offset = mmio_read_32(MBOX_OFFSET + MBOX_COUT);

94
95
96
97
	ret = write_mailbox_cmd_buffer(&cmd_free_offset, sdm_read_offset,
				       header_cmd, &is_doorbell_triggered);
	if (ret != 0) {
		return ret;
98
	}
99

100
101
102
103
104
105
106
107
	for (i = 0U; i < len; i++) {
		is_doorbell_triggered = false;
		ret = write_mailbox_cmd_buffer(&cmd_free_offset,
					       sdm_read_offset, args[i],
					       &is_doorbell_triggered);
		if (ret != 0) {
			return ret;
		}
108
109
	}

110
111
112
	if (!is_doorbell_triggered) {
		mmio_write_32(MBOX_OFFSET + MBOX_DOORBELL_TO_SDM, 1);
	}
113

114
	return MBOX_RET_OK;
115
116
}

117
int mailbox_read_response(uint32_t *job_id, uint32_t *response, int resp_len)
118
119
120
{
	int rin = 0;
	int rout = 0;
121
	int resp_data = 0;
122
	int ret_resp_len;
123

124
125
	if (mmio_read_32(MBOX_OFFSET + MBOX_DOORBELL_FROM_SDM))
		mmio_write_32(MBOX_OFFSET + MBOX_DOORBELL_FROM_SDM, 0);
126
127
128
129

	rin = mmio_read_32(MBOX_OFFSET + MBOX_RIN);
	rout = mmio_read_32(MBOX_OFFSET + MBOX_ROUT);

130
	if (rout != rin) {
131
		resp_data = mmio_read_32(MBOX_OFFSET +
132
133
134
135
136
				    MBOX_RESP_BUFFER + ((rout++)*4));

		rout %= MBOX_RESP_BUFFER_SIZE;
		mmio_write_32(MBOX_OFFSET + MBOX_ROUT, rout);

137
138

		if (MBOX_RESP_CLIENT_ID(resp_data) != MBOX_ATF_CLIENT_ID) {
139
140
141
			return MBOX_WRONG_ID;
		}

142
143
		*job_id = MBOX_RESP_JOB_ID(resp_data);

144
145
146
147
148
149
150
		ret_resp_len = MBOX_RESP_LEN(resp_data);

		if (ret_resp_len != 0) {
			ret_resp_len = iterate_resp(ret_resp_len, response,
						    resp_len);
		}

151
152
153
		if (MBOX_RESP_ERR(resp_data) > 0) {
			INFO("Error in response: %x\n", resp_data);
			return -resp_data;
154
155
		}

156
		return ret_resp_len;
157
158
159
160
161
	}
	return MBOX_NO_RESPONSE;
}


162
int mailbox_poll_response(uint32_t job_id, int urgent, uint32_t *response,
163
				int resp_len)
164
{
165
	uint32_t timeout = 40U;
166
	uint32_t sdm_loop = 255U;
167
168
	int rin = 0;
	int rout = 0;
169
	int resp_data = 0;
170
	int ret_resp_len;
171

172
	while (sdm_loop != 0U) {
173

174
175
176
177
178
		do {
			if (mmio_read_32(MBOX_OFFSET + MBOX_DOORBELL_FROM_SDM)
			    & 1) {
				break;
			}
179
			mdelay(10U);
180
		} while (--timeout != 0U);
181

182
		if (timeout == 0U) {
183
			break;
184
185
186
187
188
		}

		mmio_write_32(MBOX_OFFSET + MBOX_DOORBELL_FROM_SDM, 0);

		if (urgent & 1) {
189
			mdelay(5);
190
191
192
193
			if ((mmio_read_32(MBOX_OFFSET + MBOX_STATUS) &
				MBOX_STATUS_UA_MASK) ^
				(urgent & MBOX_STATUS_UA_MASK)) {
				mmio_write_32(MBOX_OFFSET + MBOX_URG, 0);
194
				return MBOX_RET_OK;
195
196
197
198
			}

			mmio_write_32(MBOX_OFFSET + MBOX_URG, 0);
			INFO("Error: Mailbox did not get UA");
199
			return MBOX_RET_ERROR;
200
201
202
203
204
205
		}

		rin = mmio_read_32(MBOX_OFFSET + MBOX_RIN);
		rout = mmio_read_32(MBOX_OFFSET + MBOX_ROUT);

		while (rout != rin) {
206
			resp_data = mmio_read_32(MBOX_OFFSET +
207
208
209
210
211
					    MBOX_RESP_BUFFER + ((rout++)*4));

			rout %= MBOX_RESP_BUFFER_SIZE;
			mmio_write_32(MBOX_OFFSET + MBOX_ROUT, rout);

212
213
			if (MBOX_RESP_CLIENT_ID(resp_data) != MBOX_ATF_CLIENT_ID
				|| MBOX_RESP_JOB_ID(resp_data) != job_id)
214
215
				continue;

216
217
218
219
220
221
222
223
			ret_resp_len = MBOX_RESP_LEN(resp_data);

			if (ret_resp_len != 0) {
				ret_resp_len = iterate_resp(ret_resp_len,
							    response,
							    resp_len);
			}

224
225
226
			if (MBOX_RESP_ERR(resp_data) > 0) {
				INFO("Error in response: %x\n", resp_data);
				return -MBOX_RESP_ERR(resp_data);
227
			}
228

229
			return ret_resp_len;
230
		}
231
232

	sdm_loop--;
233
	}
234
235
236

	INFO("Timed out waiting for SDM\n");
	return MBOX_TIMEOUT;
237
238
239
240
241
242
243
244
245
246
}

int iterate_resp(int mbox_resp_len, uint32_t *resp_buf, int resp_len)
{
	uint32_t timeout;
	int resp_data = 0, total_resp_len = 0;
	int rin = mmio_read_32(MBOX_OFFSET + MBOX_RIN);
	int rout = mmio_read_32(MBOX_OFFSET + MBOX_ROUT);

	while (mbox_resp_len > 0) {
247
		timeout = 100U;
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
		mbox_resp_len--;
		resp_data = mmio_read_32(MBOX_OFFSET +
					MBOX_RESP_BUFFER +
					(rout)*4);
		if (resp_buf && resp_len) {
			*(resp_buf + total_resp_len)
					= resp_data;
			resp_len--;
			total_resp_len++;
		}
		rout++;
		rout %= MBOX_RESP_BUFFER_SIZE;
		mmio_write_32(MBOX_OFFSET + MBOX_ROUT, rout);

		do {
			rin = mmio_read_32(MBOX_OFFSET + MBOX_RIN);
264
			if (rout == rin) {
265
				mdelay(10U);
266
267
268
269
270
			} else {
				break;
			}
			timeout--;
		} while ((mbox_resp_len > 0) && (timeout != 0U));
271

272
		if (timeout == 0U) {
273
274
			INFO("Timed out waiting for SDM\n");
			return MBOX_TIMEOUT;
275
276
		}
	}
277
	return total_resp_len;
278
279
}

280
int mailbox_send_cmd_async(uint32_t *job_id, unsigned int cmd, uint32_t *args,
281
			  int len, int indirect)
282
{
283
284
285
286
287
288
289
290
291
292
293
	int status;

	status = fill_mailbox_circular_buffer(
				MBOX_CLIENT_ID_CMD(MBOX_ATF_CLIENT_ID) |
				MBOX_JOB_ID_CMD(*job_id) |
				MBOX_CMD_LEN_CMD(len) |
				MBOX_INDIRECT(indirect) |
				cmd, args, len);
	if (status < 0) {
		return status;
	}
294

295
	*job_id = (*job_id + 1) % MBOX_MAX_IND_JOB_ID;
296

297
	return MBOX_RET_OK;
298
299
}

300
int mailbox_send_cmd(uint32_t job_id, unsigned int cmd, uint32_t *args,
301
			int len, int urgent, uint32_t *response, int resp_len)
302
{
303
	int status = 0;
304
305
306
307
308

	if (urgent) {
		urgent |= mmio_read_32(MBOX_OFFSET + MBOX_STATUS) &
					MBOX_STATUS_UA_MASK;
		mmio_write_32(MBOX_OFFSET + MBOX_URG, cmd);
309
		mmio_write_32(MBOX_OFFSET + MBOX_DOORBELL_TO_SDM, 1);
310
311
312
	}

	else {
313
314
315
		status = fill_mailbox_circular_buffer(
			MBOX_CLIENT_ID_CMD(MBOX_ATF_CLIENT_ID) |
			MBOX_JOB_ID_CMD(job_id) |
316
			MBOX_CMD_LEN_CMD(len) |
317
318
319
320
321
322
			cmd, args, len);
	}

	if (status)
		return status;

323
	status = mailbox_poll_response(job_id, urgent, response, resp_len);
324
325
326
327
328
329
330
331

	return status;
}

void mailbox_clear_response(void)
{
	mmio_write_32(MBOX_OFFSET + MBOX_ROUT,
		mmio_read_32(MBOX_OFFSET + MBOX_RIN));
332
333
334
335
336
337
338
339
340
341
342
343
344
}

void mailbox_set_int(int interrupt)
{

	mmio_write_32(MBOX_OFFSET+MBOX_INT, MBOX_COE_BIT(interrupt) |
			MBOX_UAE_BIT(interrupt));
}


void mailbox_set_qspi_open(void)
{
	mailbox_set_int(MBOX_INT_FLAG_COE | MBOX_INT_FLAG_RIE);
345
346
	mailbox_send_cmd(MBOX_JOB_ID, MBOX_CMD_QSPI_OPEN, NULL, 0,
				CMD_CASUAL, NULL, 0);
347
348
349
350
}

void mailbox_set_qspi_direct(void)
{
351
352
	mailbox_send_cmd(MBOX_JOB_ID, MBOX_CMD_QSPI_DIRECT, NULL, 0,
				CMD_CASUAL, NULL, 0);
353
354
355
356
357
}

void mailbox_set_qspi_close(void)
{
	mailbox_set_int(MBOX_INT_FLAG_COE | MBOX_INT_FLAG_RIE);
358
359
	mailbox_send_cmd(MBOX_JOB_ID, MBOX_CMD_QSPI_CLOSE, NULL, 0,
				CMD_CASUAL, NULL, 0);
360
361
362
363
}

void mailbox_qspi_set_cs(int device_select)
{
364
	uint32_t cs_setting = device_select;
365
366
367
368
369

	/* QSPI device select settings at 31:28 */
	cs_setting = (cs_setting << 28);
	mailbox_set_int(MBOX_INT_FLAG_COE | MBOX_INT_FLAG_RIE);
	mailbox_send_cmd(MBOX_JOB_ID, MBOX_CMD_QSPI_SET_CS, &cs_setting,
370
				1, CMD_CASUAL, NULL, 0);
371
372
373
374
375
}

void mailbox_reset_cold(void)
{
	mailbox_set_int(MBOX_INT_FLAG_COE | MBOX_INT_FLAG_RIE);
376
377
	mailbox_send_cmd(MBOX_JOB_ID, MBOX_CMD_REBOOT_HPS, NULL, 0,
				CMD_CASUAL, NULL, 0);
378
379
}

380
381
382
int mailbox_rsu_get_spt_offset(uint32_t *resp_buf, uint32_t resp_buf_len)
{
	return mailbox_send_cmd(MBOX_JOB_ID, MBOX_GET_SUBPARTITION_TABLE,
383
				NULL, 0, CMD_CASUAL, (uint32_t *)resp_buf,
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
				resp_buf_len);
}

struct rsu_status_info {
	uint64_t current_image;
	uint64_t fail_image;
	uint32_t state;
	uint32_t version;
	uint32_t error_location;
	uint32_t error_details;
	uint32_t retry_counter;
};

int mailbox_rsu_status(uint32_t *resp_buf, uint32_t resp_buf_len)
{
	int ret;
	struct rsu_status_info *info = (struct rsu_status_info *)resp_buf;

	info->retry_counter = ~0;

404
405
406
	ret = mailbox_send_cmd(MBOX_JOB_ID, MBOX_RSU_STATUS, NULL, 0,
				CMD_CASUAL, (uint32_t *)resp_buf,
				resp_buf_len);
407
408
409
410
411
412
413
414
415
416
417

	if (ret < 0)
		return ret;

	if (info->retry_counter != ~0)
		if (!(info->version & RSU_VERSION_ACMF_MASK))
			info->version |= RSU_VERSION_ACMF;

	return ret;
}

418
int mailbox_rsu_update(uint32_t *flash_offset)
419
420
{
	return mailbox_send_cmd(MBOX_JOB_ID, MBOX_RSU_UPDATE,
421
422
				flash_offset, 2,
				CMD_CASUAL, NULL, 0);
423
424
}

425
int mailbox_hps_stage_notify(uint32_t execution_stage)
426
427
{
	return mailbox_send_cmd(MBOX_JOB_ID, MBOX_HPS_STAGE_NOTIFY,
428
429
				&execution_stage, 1, CMD_CASUAL,
				NULL, 0);
430
431
}

432
433
434
435
436
437
int mailbox_init(void)
{
	int status = 0;

	mailbox_set_int(MBOX_INT_FLAG_COE | MBOX_INT_FLAG_RIE |
			MBOX_INT_FLAG_UAE);
438
439
440
	mmio_write_32(MBOX_OFFSET + MBOX_URG, 0);
	mmio_write_32(MBOX_OFFSET + MBOX_DOORBELL_FROM_SDM, 0);

441
442
	status = mailbox_send_cmd(0, MBOX_CMD_RESTART, NULL, 0,
					CMD_URGENT, NULL, 0);
443
444
445
446

	if (status)
		return status;

447
448
	mailbox_set_int(MBOX_INT_FLAG_COE | MBOX_INT_FLAG_RIE |
			MBOX_INT_FLAG_UAE);
449

450
	return MBOX_RET_OK;
451
452
}

453
int intel_mailbox_get_config_status(uint32_t cmd)
454
{
455
456
	int status;
	uint32_t res, response[6];
457

458
459
	status = mailbox_send_cmd(MBOX_JOB_ID, cmd, NULL, 0, CMD_CASUAL, response,
				ARRAY_SIZE(response));
460
461

	if (status < 0)
462
		return status;
463
464
465

	res = response[RECONFIG_STATUS_STATE];
	if (res && res != MBOX_CFGSTAT_STATE_CONFIG)
466
		return res;
467
468
469

	res = response[RECONFIG_STATUS_PIN_STATUS];
	if (!(res & PIN_STATUS_NSTATUS))
470
		return MBOX_CFGSTAT_STATE_ERROR_HARDWARE;
471
472
473

	res = response[RECONFIG_STATUS_SOFTFUNC_STATUS];
	if (res & SOFTFUNC_STATUS_SEU_ERROR)
474
		return MBOX_CFGSTAT_STATE_ERROR_HARDWARE;
475
476
477

	if ((res & SOFTFUNC_STATUS_CONF_DONE) &&
		(res & SOFTFUNC_STATUS_INIT_DONE))
478
		return MBOX_RET_OK;
479

480
	return MBOX_CFGSTAT_STATE_CONFIG;
481
}
482
483
484
485
486
487
488
489
490
491

int intel_mailbox_is_fpga_not_ready(void)
{
	int ret = intel_mailbox_get_config_status(MBOX_RECONFIG_STATUS);

	if (ret && ret != MBOX_CFGSTAT_STATE_CONFIG)
		ret = intel_mailbox_get_config_status(MBOX_CONFIG_STATUS);

	return ret;
}