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 34 static inline uint32_t aml_scpi_cmd(uint32_t command, uint32_t size) 35 { 36 return command | (size << SIZE_SHIFT); 37 } 38 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 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 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 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 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 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 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 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 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 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 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 */ 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