1 /*
2 * Copyright (c) 2018-2019, ARM Limited and Contributors. All rights reserved.
3 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 */
6
7 #include <assert.h>
8 #include <crypto/sha_dma.h>
9 #include <lib/mmio.h>
10 #include <plat/common/platform.h>
11 #include <platform_def.h>
12 #include <string.h>
13
14 #include "aml_private.h"
15
16 #define SIZE_SHIFT 20
17 #define SIZE_MASK 0x1FF
18 #define SIZE_FWBLK 0x200UL
19
20 /*
21 * Note: The Amlogic SCP firmware uses the legacy SCPI protocol.
22 */
23 #define SCPI_CMD_SET_CSS_POWER_STATE 0x04
24 #define SCPI_CMD_SET_SYS_POWER_STATE 0x08
25
26 #define SCPI_CMD_JTAG_SET_STATE 0xC0
27 #define SCPI_CMD_EFUSE_READ 0xC2
28 #define SCPI_CMD_CHIP_ID 0xC6
29
30 #define SCPI_CMD_COPY_FW 0xd4
31 #define SCPI_CMD_SET_FW_ADDR 0xd3
32 #define SCPI_CMD_FW_SIZE 0xd2
33
aml_scpi_cmd(uint32_t command,uint32_t size)34 static inline uint32_t aml_scpi_cmd(uint32_t command, uint32_t size)
35 {
36 return command | (size << SIZE_SHIFT);
37 }
38
aml_scpi_secure_message_send(uint32_t command,uint32_t size)39 static void aml_scpi_secure_message_send(uint32_t command, uint32_t size)
40 {
41 aml_mhu_secure_message_send(aml_scpi_cmd(command, size));
42 }
43
aml_scpi_secure_message_receive(void ** message_out,size_t * size_out)44 static uint32_t aml_scpi_secure_message_receive(void **message_out, size_t *size_out)
45 {
46 uint32_t response = aml_mhu_secure_message_wait();
47
48 size_t size = (response >> SIZE_SHIFT) & SIZE_MASK;
49
50 response &= ~(SIZE_MASK << SIZE_SHIFT);
51
52 if (size_out != NULL)
53 *size_out = size;
54
55 if (message_out != NULL)
56 *message_out = (void *)AML_MHU_SECURE_SCP_TO_AP_PAYLOAD;
57
58 return response;
59 }
60
aml_scpi_set_css_power_state(u_register_t mpidr,uint32_t cpu_state,uint32_t cluster_state,uint32_t css_state)61 void aml_scpi_set_css_power_state(u_register_t mpidr, uint32_t cpu_state,
62 uint32_t cluster_state, uint32_t css_state)
63 {
64 uint32_t state = (mpidr & 0x0F) | /* CPU ID */
65 ((mpidr & 0xF00) >> 4) | /* Cluster ID */
66 (cpu_state << 8) |
67 (cluster_state << 12) |
68 (css_state << 16);
69
70 aml_mhu_secure_message_start();
71 mmio_write_32(AML_MHU_SECURE_AP_TO_SCP_PAYLOAD, state);
72 aml_mhu_secure_message_send(aml_scpi_cmd(SCPI_CMD_SET_CSS_POWER_STATE, 4));
73 aml_mhu_secure_message_wait();
74 aml_mhu_secure_message_end();
75 }
76
aml_scpi_sys_power_state(uint64_t system_state)77 uint32_t aml_scpi_sys_power_state(uint64_t system_state)
78 {
79 uint32_t *response;
80 size_t size;
81
82 aml_mhu_secure_message_start();
83 mmio_write_8(AML_MHU_SECURE_AP_TO_SCP_PAYLOAD, system_state);
84 aml_mhu_secure_message_send(aml_scpi_cmd(SCPI_CMD_SET_SYS_POWER_STATE, 1));
85 aml_scpi_secure_message_receive((void *)&response, &size);
86 aml_mhu_secure_message_end();
87
88 return *response;
89 }
90
aml_scpi_jtag_set_state(uint32_t state,uint8_t select)91 void aml_scpi_jtag_set_state(uint32_t state, uint8_t select)
92 {
93 assert(state <= AML_JTAG_STATE_OFF);
94
95 if (select > AML_JTAG_A53_EE) {
96 WARN("BL31: Invalid JTAG select (0x%x).\n", select);
97 return;
98 }
99
100 aml_mhu_secure_message_start();
101 mmio_write_32(AML_MHU_SECURE_AP_TO_SCP_PAYLOAD,
102 (state << 8) | (uint32_t)select);
103 aml_mhu_secure_message_send(aml_scpi_cmd(SCPI_CMD_JTAG_SET_STATE, 4));
104 aml_mhu_secure_message_wait();
105 aml_mhu_secure_message_end();
106 }
107
aml_scpi_efuse_read(void * dst,uint32_t base,uint32_t size)108 uint32_t aml_scpi_efuse_read(void *dst, uint32_t base, uint32_t size)
109 {
110 uint32_t *response;
111 size_t resp_size;
112
113 if (size > 0x1FC)
114 return 0;
115
116 aml_mhu_secure_message_start();
117 mmio_write_32(AML_MHU_SECURE_AP_TO_SCP_PAYLOAD, base);
118 mmio_write_32(AML_MHU_SECURE_AP_TO_SCP_PAYLOAD + 4, size);
119 aml_mhu_secure_message_send(aml_scpi_cmd(SCPI_CMD_EFUSE_READ, 8));
120 aml_scpi_secure_message_receive((void *)&response, &resp_size);
121 aml_mhu_secure_message_end();
122
123 /*
124 * response[0] is the size of the response message.
125 * response[1 ... N] are the contents.
126 */
127 if (*response != 0)
128 memcpy(dst, response + 1, *response);
129
130 return *response;
131 }
132
aml_scpi_unknown_thermal(uint32_t arg0,uint32_t arg1,uint32_t arg2,uint32_t arg3)133 void aml_scpi_unknown_thermal(uint32_t arg0, uint32_t arg1,
134 uint32_t arg2, uint32_t arg3)
135 {
136 aml_mhu_secure_message_start();
137 mmio_write_32(AML_MHU_SECURE_AP_TO_SCP_PAYLOAD + 0x0, arg0);
138 mmio_write_32(AML_MHU_SECURE_AP_TO_SCP_PAYLOAD + 0x4, arg1);
139 mmio_write_32(AML_MHU_SECURE_AP_TO_SCP_PAYLOAD + 0x8, arg2);
140 mmio_write_32(AML_MHU_SECURE_AP_TO_SCP_PAYLOAD + 0xC, arg3);
141 aml_mhu_secure_message_send(aml_scpi_cmd(0xC3, 16));
142 aml_mhu_secure_message_wait();
143 aml_mhu_secure_message_end();
144 }
145
aml_scpi_get_chip_id(uint8_t * obuff,uint32_t osize)146 uint32_t aml_scpi_get_chip_id(uint8_t *obuff, uint32_t osize)
147 {
148 uint32_t *response;
149 size_t resp_size;
150
151 if ((osize != 16) && (osize != 12))
152 return 0;
153
154 aml_mhu_secure_message_start();
155 aml_mhu_secure_message_send(aml_scpi_cmd(SCPI_CMD_CHIP_ID, osize));
156 aml_scpi_secure_message_receive((void *)&response, &resp_size);
157 aml_mhu_secure_message_end();
158
159 if (!((resp_size == 16) && (osize == 16)) &&
160 !((resp_size == 0) && (osize == 12)))
161 return 0;
162
163 memcpy((void *)obuff, (const void *)response, osize);
164
165 return osize;
166 }
167
aml_scpi_copy_scp_data(uint8_t * data,size_t len)168 static inline void aml_scpi_copy_scp_data(uint8_t *data, size_t len)
169 {
170 void *dst = (void *)AML_MHU_SECURE_AP_TO_SCP_PAYLOAD;
171 size_t sz;
172
173 mmio_write_32(AML_MHU_SECURE_AP_TO_SCP_PAYLOAD, len);
174 aml_scpi_secure_message_send(SCPI_CMD_FW_SIZE, len);
175 aml_mhu_secure_message_wait();
176
177 for (sz = 0; sz < len; sz += SIZE_FWBLK) {
178 memcpy(dst, data + sz, MIN(SIZE_FWBLK, len - sz));
179 aml_mhu_secure_message_send(SCPI_CMD_COPY_FW);
180 }
181 }
182
aml_scpi_set_scp_addr(uint64_t addr,size_t len)183 static inline void aml_scpi_set_scp_addr(uint64_t addr, size_t len)
184 {
185 volatile uint64_t *dst = (uint64_t *)AML_MHU_SECURE_AP_TO_SCP_PAYLOAD;
186
187 /*
188 * It is ok as AML_MHU_SECURE_AP_TO_SCP_PAYLOAD is mapped as
189 * non cachable
190 */
191 *dst = addr;
192 aml_scpi_secure_message_send(SCPI_CMD_SET_FW_ADDR, sizeof(addr));
193 aml_mhu_secure_message_wait();
194
195 mmio_write_32(AML_MHU_SECURE_AP_TO_SCP_PAYLOAD, len);
196 aml_scpi_secure_message_send(SCPI_CMD_FW_SIZE, len);
197 aml_mhu_secure_message_wait();
198 }
199
aml_scpi_send_fw_hash(uint8_t hash[],size_t len)200 static inline void aml_scpi_send_fw_hash(uint8_t hash[], size_t len)
201 {
202 void *dst = (void *)AML_MHU_SECURE_AP_TO_SCP_PAYLOAD;
203
204 memcpy(dst, hash, len);
205 aml_mhu_secure_message_send(0xd0);
206 aml_mhu_secure_message_send(0xd1);
207 aml_mhu_secure_message_send(0xd5);
208 aml_mhu_secure_message_end();
209 }
210
211 /**
212 * Upload a FW to SCP.
213 *
214 * @param addr: firmware data address
215 * @param size: size of firmware
216 * @param send: If set, actually copy the firmware in SCP memory otherwise only
217 * send the firmware address.
218 */
aml_scpi_upload_scp_fw(uintptr_t addr,size_t size,int send)219 void aml_scpi_upload_scp_fw(uintptr_t addr, size_t size, int send)
220 {
221 struct asd_ctx ctx;
222
223 asd_sha_init(&ctx, ASM_SHA256);
224 asd_sha_update(&ctx, (void *)addr, size);
225 asd_sha_finalize(&ctx);
226
227 aml_mhu_secure_message_start();
228 if (send == 0)
229 aml_scpi_set_scp_addr(addr, size);
230 else
231 aml_scpi_copy_scp_data((void *)addr, size);
232
233 aml_scpi_send_fw_hash(ctx.digest, sizeof(ctx.digest));
234 }
235