1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) 2 // 3 // This file is provided under a dual BSD/GPLv2 license. When using or 4 // redistributing this file, you may do so under either license. 5 // 6 // Copyright(c) 2022 Intel Corporation 7 8 #include <linux/firmware.h> 9 #include "sof-priv.h" 10 #include "sof-audio.h" 11 #include "ipc3-priv.h" 12 #include "ops.h" 13 14 static int ipc3_fw_ext_man_get_version(struct snd_sof_dev *sdev, 15 const struct sof_ext_man_elem_header *hdr) 16 { 17 const struct sof_ext_man_fw_version *v = 18 container_of(hdr, struct sof_ext_man_fw_version, hdr); 19 20 memcpy(&sdev->fw_ready.version, &v->version, sizeof(v->version)); 21 sdev->fw_ready.flags = v->flags; 22 23 /* log ABI versions and check FW compatibility */ 24 return sof_ipc3_validate_fw_version(sdev); 25 } 26 27 static int ipc3_fw_ext_man_get_windows(struct snd_sof_dev *sdev, 28 const struct sof_ext_man_elem_header *hdr) 29 { 30 const struct sof_ext_man_window *w; 31 32 w = container_of(hdr, struct sof_ext_man_window, hdr); 33 34 return sof_ipc3_get_ext_windows(sdev, &w->ipc_window.ext_hdr); 35 } 36 37 static int ipc3_fw_ext_man_get_cc_info(struct snd_sof_dev *sdev, 38 const struct sof_ext_man_elem_header *hdr) 39 { 40 const struct sof_ext_man_cc_version *cc; 41 42 cc = container_of(hdr, struct sof_ext_man_cc_version, hdr); 43 44 return sof_ipc3_get_cc_info(sdev, &cc->cc_version.ext_hdr); 45 } 46 47 static int ipc3_fw_ext_man_get_dbg_abi_info(struct snd_sof_dev *sdev, 48 const struct sof_ext_man_elem_header *hdr) 49 { 50 const struct ext_man_dbg_abi *dbg_abi = 51 container_of(hdr, struct ext_man_dbg_abi, hdr); 52 53 if (sdev->first_boot) 54 dev_dbg(sdev->dev, 55 "Firmware: DBG_ABI %d:%d:%d\n", 56 SOF_ABI_VERSION_MAJOR(dbg_abi->dbg_abi.abi_dbg_version), 57 SOF_ABI_VERSION_MINOR(dbg_abi->dbg_abi.abi_dbg_version), 58 SOF_ABI_VERSION_PATCH(dbg_abi->dbg_abi.abi_dbg_version)); 59 60 return 0; 61 } 62 63 static int ipc3_fw_ext_man_get_config_data(struct snd_sof_dev *sdev, 64 const struct sof_ext_man_elem_header *hdr) 65 { 66 const struct sof_ext_man_config_data *config = 67 container_of(hdr, struct sof_ext_man_config_data, hdr); 68 const struct sof_config_elem *elem; 69 int elems_counter; 70 int elems_size; 71 int ret = 0; 72 int i; 73 74 /* calculate elements counter */ 75 elems_size = config->hdr.size - sizeof(struct sof_ext_man_elem_header); 76 elems_counter = elems_size / sizeof(struct sof_config_elem); 77 78 dev_dbg(sdev->dev, "manifest can hold up to %d config elements\n", elems_counter); 79 80 for (i = 0; i < elems_counter; ++i) { 81 elem = &config->elems[i]; 82 dev_dbg(sdev->dev, "get index %d token %d val %d\n", 83 i, elem->token, elem->value); 84 switch (elem->token) { 85 case SOF_EXT_MAN_CONFIG_EMPTY: 86 /* unused memory space is zero filled - mapped to EMPTY elements */ 87 break; 88 case SOF_EXT_MAN_CONFIG_IPC_MSG_SIZE: 89 /* TODO: use ipc msg size from config data */ 90 break; 91 case SOF_EXT_MAN_CONFIG_MEMORY_USAGE_SCAN: 92 if (sdev->first_boot && elem->value) 93 ret = snd_sof_dbg_memory_info_init(sdev); 94 break; 95 default: 96 dev_info(sdev->dev, 97 "Unknown firmware configuration token %d value %d", 98 elem->token, elem->value); 99 break; 100 } 101 if (ret < 0) { 102 dev_err(sdev->dev, 103 "%s: processing failed for token %d value %#x, %d\n", 104 __func__, elem->token, elem->value, ret); 105 return ret; 106 } 107 } 108 109 return 0; 110 } 111 112 static ssize_t ipc3_fw_ext_man_size(struct snd_sof_dev *sdev, const struct firmware *fw) 113 { 114 const struct sof_ext_man_header *head; 115 116 head = (struct sof_ext_man_header *)fw->data; 117 118 /* 119 * assert fw size is big enough to contain extended manifest header, 120 * it prevents from reading unallocated memory from `head` in following 121 * step. 122 */ 123 if (fw->size < sizeof(*head)) 124 return -EINVAL; 125 126 /* 127 * When fw points to extended manifest, 128 * then first u32 must be equal SOF_EXT_MAN_MAGIC_NUMBER. 129 */ 130 if (head->magic == SOF_EXT_MAN_MAGIC_NUMBER) 131 return head->full_size; 132 133 /* otherwise given fw don't have an extended manifest */ 134 dev_dbg(sdev->dev, "Unexpected extended manifest magic number: %#x\n", 135 head->magic); 136 return 0; 137 } 138 139 static size_t sof_ipc3_fw_parse_ext_man(struct snd_sof_dev *sdev) 140 { 141 const struct firmware *fw = sdev->basefw.fw; 142 const struct sof_ext_man_elem_header *elem_hdr; 143 const struct sof_ext_man_header *head; 144 ssize_t ext_man_size; 145 ssize_t remaining; 146 uintptr_t iptr; 147 int ret = 0; 148 149 head = (struct sof_ext_man_header *)fw->data; 150 remaining = head->full_size - head->header_size; 151 if (remaining < 0 || remaining > sdev->basefw.fw->size) 152 return -EINVAL; 153 ext_man_size = ipc3_fw_ext_man_size(sdev, fw); 154 155 /* Assert firmware starts with extended manifest */ 156 if (ext_man_size <= 0) 157 return ext_man_size; 158 159 /* incompatible version */ 160 if (SOF_EXT_MAN_VERSION_INCOMPATIBLE(SOF_EXT_MAN_VERSION, 161 head->header_version)) { 162 dev_err(sdev->dev, 163 "extended manifest version %#x differ from used %#x\n", 164 head->header_version, SOF_EXT_MAN_VERSION); 165 return -EINVAL; 166 } 167 168 /* get first extended manifest element header */ 169 iptr = (uintptr_t)fw->data + head->header_size; 170 171 while (remaining > sizeof(*elem_hdr)) { 172 elem_hdr = (struct sof_ext_man_elem_header *)iptr; 173 174 dev_dbg(sdev->dev, "found sof_ext_man header type %d size %#x\n", 175 elem_hdr->type, elem_hdr->size); 176 177 if (elem_hdr->size < sizeof(*elem_hdr) || 178 elem_hdr->size > remaining) { 179 dev_err(sdev->dev, 180 "invalid sof_ext_man header size, type %d size %#x\n", 181 elem_hdr->type, elem_hdr->size); 182 return -EINVAL; 183 } 184 185 /* process structure data */ 186 switch (elem_hdr->type) { 187 case SOF_EXT_MAN_ELEM_FW_VERSION: 188 ret = ipc3_fw_ext_man_get_version(sdev, elem_hdr); 189 break; 190 case SOF_EXT_MAN_ELEM_WINDOW: 191 ret = ipc3_fw_ext_man_get_windows(sdev, elem_hdr); 192 break; 193 case SOF_EXT_MAN_ELEM_CC_VERSION: 194 ret = ipc3_fw_ext_man_get_cc_info(sdev, elem_hdr); 195 break; 196 case SOF_EXT_MAN_ELEM_DBG_ABI: 197 ret = ipc3_fw_ext_man_get_dbg_abi_info(sdev, elem_hdr); 198 break; 199 case SOF_EXT_MAN_ELEM_CONFIG_DATA: 200 ret = ipc3_fw_ext_man_get_config_data(sdev, elem_hdr); 201 break; 202 case SOF_EXT_MAN_ELEM_PLATFORM_CONFIG_DATA: 203 ret = snd_sof_dsp_parse_platform_ext_manifest(sdev, elem_hdr); 204 break; 205 default: 206 dev_info(sdev->dev, 207 "unknown sof_ext_man header type %d size %#x\n", 208 elem_hdr->type, elem_hdr->size); 209 break; 210 } 211 212 if (ret < 0) { 213 dev_err(sdev->dev, 214 "failed to parse sof_ext_man header type %d size %#x\n", 215 elem_hdr->type, elem_hdr->size); 216 return ret; 217 } 218 219 remaining -= elem_hdr->size; 220 iptr += elem_hdr->size; 221 } 222 223 if (remaining) { 224 dev_err(sdev->dev, "error: sof_ext_man header is inconsistent\n"); 225 return -EINVAL; 226 } 227 228 return ext_man_size; 229 } 230 231 /* generic module parser for mmaped DSPs */ 232 static int sof_ipc3_parse_module_memcpy(struct snd_sof_dev *sdev, 233 struct snd_sof_mod_hdr *module) 234 { 235 struct snd_sof_blk_hdr *block; 236 int count, ret; 237 u32 offset; 238 size_t remaining; 239 240 dev_dbg(sdev->dev, "new module size %#x blocks %#x type %#x\n", 241 module->size, module->num_blocks, module->type); 242 243 block = (struct snd_sof_blk_hdr *)((u8 *)module + sizeof(*module)); 244 245 /* module->size doesn't include header size */ 246 remaining = module->size; 247 for (count = 0; count < module->num_blocks; count++) { 248 /* check for wrap */ 249 if (remaining < sizeof(*block)) { 250 dev_err(sdev->dev, "not enough data remaining\n"); 251 return -EINVAL; 252 } 253 254 /* minus header size of block */ 255 remaining -= sizeof(*block); 256 257 if (block->size == 0) { 258 dev_warn(sdev->dev, 259 "warning: block %d size zero\n", count); 260 dev_warn(sdev->dev, " type %#x offset %#x\n", 261 block->type, block->offset); 262 continue; 263 } 264 265 switch (block->type) { 266 case SOF_FW_BLK_TYPE_RSRVD0: 267 case SOF_FW_BLK_TYPE_ROM...SOF_FW_BLK_TYPE_RSRVD14: 268 continue; /* not handled atm */ 269 case SOF_FW_BLK_TYPE_IRAM: 270 case SOF_FW_BLK_TYPE_DRAM: 271 case SOF_FW_BLK_TYPE_SRAM: 272 offset = block->offset; 273 break; 274 default: 275 dev_err(sdev->dev, "%s: bad type %#x for block %#x\n", 276 __func__, block->type, count); 277 return -EINVAL; 278 } 279 280 dev_dbg(sdev->dev, "block %d type %#x size %#x ==> offset %#x\n", 281 count, block->type, block->size, offset); 282 283 /* checking block->size to avoid unaligned access */ 284 if (block->size % sizeof(u32)) { 285 dev_err(sdev->dev, "%s: invalid block size %#x\n", 286 __func__, block->size); 287 return -EINVAL; 288 } 289 ret = snd_sof_dsp_block_write(sdev, block->type, offset, 290 block + 1, block->size); 291 if (ret < 0) { 292 dev_err(sdev->dev, "%s: write to block type %#x failed\n", 293 __func__, block->type); 294 return ret; 295 } 296 297 if (remaining < block->size) { 298 dev_err(sdev->dev, "%s: not enough data remaining\n", __func__); 299 return -EINVAL; 300 } 301 302 /* minus body size of block */ 303 remaining -= block->size; 304 /* next block */ 305 block = (struct snd_sof_blk_hdr *)((u8 *)block + sizeof(*block) 306 + block->size); 307 } 308 309 return 0; 310 } 311 312 static int sof_ipc3_load_fw_to_dsp(struct snd_sof_dev *sdev) 313 { 314 u32 payload_offset = sdev->basefw.payload_offset; 315 const struct firmware *fw = sdev->basefw.fw; 316 struct snd_sof_fw_header *header; 317 struct snd_sof_mod_hdr *module; 318 int (*load_module)(struct snd_sof_dev *sof_dev, struct snd_sof_mod_hdr *hdr); 319 size_t remaining; 320 int ret, count; 321 322 if (!fw) 323 return -EINVAL; 324 325 header = (struct snd_sof_fw_header *)(fw->data + payload_offset); 326 load_module = sof_ops(sdev)->load_module; 327 if (!load_module) { 328 dev_dbg(sdev->dev, "Using generic module loading\n"); 329 load_module = sof_ipc3_parse_module_memcpy; 330 } else { 331 dev_dbg(sdev->dev, "Using custom module loading\n"); 332 } 333 334 /* parse each module */ 335 module = (struct snd_sof_mod_hdr *)(fw->data + payload_offset + sizeof(*header)); 336 remaining = fw->size - sizeof(*header) - payload_offset; 337 /* check for wrap */ 338 if (remaining > fw->size) { 339 dev_err(sdev->dev, "%s: fw size smaller than header size\n", __func__); 340 return -EINVAL; 341 } 342 343 for (count = 0; count < header->num_modules; count++) { 344 /* check for wrap */ 345 if (remaining < sizeof(*module)) { 346 dev_err(sdev->dev, "%s: not enough data for a module\n", 347 __func__); 348 return -EINVAL; 349 } 350 351 /* minus header size of module */ 352 remaining -= sizeof(*module); 353 354 /* module */ 355 ret = load_module(sdev, module); 356 if (ret < 0) { 357 dev_err(sdev->dev, "%s: invalid module %d\n", __func__, count); 358 return ret; 359 } 360 361 if (remaining < module->size) { 362 dev_err(sdev->dev, "%s: not enough data remaining\n", __func__); 363 return -EINVAL; 364 } 365 366 /* minus body size of module */ 367 remaining -= module->size; 368 module = (struct snd_sof_mod_hdr *)((u8 *)module + 369 sizeof(*module) + module->size); 370 } 371 372 return 0; 373 } 374 375 static int sof_ipc3_validate_firmware(struct snd_sof_dev *sdev) 376 { 377 u32 payload_offset = sdev->basefw.payload_offset; 378 const struct firmware *fw = sdev->basefw.fw; 379 struct snd_sof_fw_header *header; 380 size_t fw_size = fw->size - payload_offset; 381 382 if (fw->size <= payload_offset) { 383 dev_err(sdev->dev, 384 "firmware size must be greater than firmware offset\n"); 385 return -EINVAL; 386 } 387 388 /* Read the header information from the data pointer */ 389 header = (struct snd_sof_fw_header *)(fw->data + payload_offset); 390 391 /* verify FW sig */ 392 if (strncmp(header->sig, SND_SOF_FW_SIG, SND_SOF_FW_SIG_SIZE) != 0) { 393 dev_err(sdev->dev, "invalid firmware signature\n"); 394 return -EINVAL; 395 } 396 397 /* check size is valid */ 398 if (fw_size != header->file_size + sizeof(*header)) { 399 dev_err(sdev->dev, 400 "invalid filesize mismatch got 0x%zx expected 0x%zx\n", 401 fw_size, header->file_size + sizeof(*header)); 402 return -EINVAL; 403 } 404 405 dev_dbg(sdev->dev, "header size=0x%x modules=0x%x abi=0x%x size=%zu\n", 406 header->file_size, header->num_modules, 407 header->abi, sizeof(*header)); 408 409 return 0; 410 } 411 412 const struct sof_ipc_fw_loader_ops ipc3_loader_ops = { 413 .validate = sof_ipc3_validate_firmware, 414 .parse_ext_manifest = sof_ipc3_fw_parse_ext_man, 415 .load_fw_to_dsp = sof_ipc3_load_fw_to_dsp, 416 }; 417