1 // SPDX-License-Identifier: GPL-2.0
3 * Support for Intel Camera Imaging ISP subsystem.
4 * Copyright (c) 2015, Intel Corporation.
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 #include <linux/string.h> /* for memcpy() */
17 #include <linux/slab.h>
18 #include <linux/vmalloc.h>
22 #include <math_support.h>
23 #include "platform_support.h"
24 #include "sh_css_firmware.h"
26 #include "sh_css_defs.h"
27 #include "ia_css_debug.h"
28 #include "sh_css_internal.h"
29 #include "ia_css_isp_param.h"
31 #include "assert_support.h"
33 #include "isp.h" /* PMEM_WIDTH_LOG2 */
35 #include "ia_css_isp_params.h"
36 #include "ia_css_isp_configs.h"
37 #include "ia_css_isp_states.h"
40 #define STR(x) _STR(x)
42 struct firmware_header {
43 struct sh_css_fw_bi_file_h file_header;
44 struct ia_css_fw_info binary_header;
52 static struct firmware_header *firmware_header;
55 * The string STR is a place holder
56 * which will be replaced with the actual RELEASE_VERSION
57 * during package generation. Please do not modify
60 static const char *release_version = STR(irci_stable_candrpv_0415_20150521_0458);
62 static const char *release_version = STR(irci_stable_candrpv_0415_20150423_1753);
65 #define MAX_FW_REL_VER_NAME 300
66 static char FW_rel_ver_name[MAX_FW_REL_VER_NAME] = "---";
68 struct ia_css_fw_info sh_css_sp_fw;
69 struct ia_css_blob_descr *sh_css_blob_info; /* Only ISP blob info (no SP) */
70 unsigned int sh_css_num_binaries; /* This includes 1 SP binary */
72 static struct fw_param *fw_minibuffer;
74 char *sh_css_get_fw_version(void)
76 return FW_rel_ver_name;
80 * Split the loaded firmware into blobs
83 /* Setup sp/sp1 binary */
85 setup_binary(struct ia_css_fw_info *fw, const char *fw_data,
86 struct ia_css_fw_info *sh_css_fw, unsigned int binary_id)
88 const char *blob_data;
90 if ((!fw) || (!fw_data))
93 blob_data = fw_data + fw->blob.offset;
97 sh_css_fw->blob.code = vmalloc(fw->blob.size);
98 if (!sh_css_fw->blob.code)
101 memcpy((void *)sh_css_fw->blob.code, blob_data, fw->blob.size);
102 sh_css_fw->blob.data = (char *)sh_css_fw->blob.code + fw->blob.data_source;
103 fw_minibuffer[binary_id].buffer = sh_css_fw->blob.code;
109 sh_css_load_blob_info(const char *fw, const struct ia_css_fw_info *bi,
110 struct ia_css_blob_descr *bd,
114 const unsigned char *blob;
119 /* Special case: only one binary in fw */
121 bi = (const struct ia_css_fw_info *)fw;
123 name = fw + bi->blob.prog_name_offset;
124 blob = (const unsigned char *)fw + bi->blob.offset;
128 bi->blob.text_size + bi->blob.icache_size +
129 bi->blob.data_size + bi->blob.padding_size) {
130 /* sanity check, note the padding bytes added for section to DDR alignment */
134 if ((bi->blob.offset % (1UL << (ISP_PMEM_WIDTH_LOG2 - 3))) != 0)
140 if (bi->type == ia_css_isp_firmware || bi->type == ia_css_sp_firmware) {
143 namebuffer = kstrdup(name, GFP_KERNEL);
146 bd->name = fw_minibuffer[index].name = namebuffer;
151 if (bi->type == ia_css_isp_firmware) {
152 size_t paramstruct_size = sizeof(struct ia_css_memory_offsets);
153 size_t configstruct_size = sizeof(struct ia_css_config_memory_offsets);
154 size_t statestruct_size = sizeof(struct ia_css_state_memory_offsets);
156 char *parambuf = kmalloc(paramstruct_size + configstruct_size +
162 bd->mem_offsets.array[IA_CSS_PARAM_CLASS_PARAM].ptr = NULL;
163 bd->mem_offsets.array[IA_CSS_PARAM_CLASS_CONFIG].ptr = NULL;
164 bd->mem_offsets.array[IA_CSS_PARAM_CLASS_STATE].ptr = NULL;
166 fw_minibuffer[index].buffer = parambuf;
168 /* copy ia_css_memory_offsets */
169 memcpy(parambuf, (void *)(fw +
170 bi->blob.memory_offsets.offsets[IA_CSS_PARAM_CLASS_PARAM]),
172 bd->mem_offsets.array[IA_CSS_PARAM_CLASS_PARAM].ptr = parambuf;
174 /* copy ia_css_config_memory_offsets */
175 memcpy(parambuf + paramstruct_size,
176 (void *)(fw + bi->blob.memory_offsets.offsets[IA_CSS_PARAM_CLASS_CONFIG]),
178 bd->mem_offsets.array[IA_CSS_PARAM_CLASS_CONFIG].ptr = parambuf +
181 /* copy ia_css_state_memory_offsets */
182 memcpy(parambuf + paramstruct_size + configstruct_size,
183 (void *)(fw + bi->blob.memory_offsets.offsets[IA_CSS_PARAM_CLASS_STATE]),
185 bd->mem_offsets.array[IA_CSS_PARAM_CLASS_STATE].ptr = parambuf +
186 paramstruct_size + configstruct_size;
192 sh_css_check_firmware_version(struct device *dev, const char *fw_data)
194 struct sh_css_fw_bi_file_h *file_header;
196 firmware_header = (struct firmware_header *)fw_data;
197 file_header = &firmware_header->file_header;
199 if (strcmp(file_header->version, release_version) != 0) {
200 dev_err(dev, "Firmware version may not be compatible with this driver\n");
201 dev_err(dev, "Expecting version '%s', but firmware is '%s'.\n",
202 release_version, file_header->version);
205 /* For now, let's just accept a wrong version, even if wrong */
209 static const char * const fw_type_name[] = {
210 [ia_css_sp_firmware] = "SP",
211 [ia_css_isp_firmware] = "ISP",
212 [ia_css_bootloader_firmware] = "BootLoader",
213 [ia_css_acc_firmware] = "accel",
216 static const char * const fw_acc_type_name[] = {
217 [IA_CSS_ACC_NONE] = "Normal",
218 [IA_CSS_ACC_OUTPUT] = "Accel for output",
219 [IA_CSS_ACC_VIEWFINDER] = "Accel for viewfinder",
220 [IA_CSS_ACC_STANDALONE] = "Stand-alone accel",
224 sh_css_load_firmware(struct device *dev, const char *fw_data,
225 unsigned int fw_size)
228 struct ia_css_fw_info *binaries;
229 struct sh_css_fw_bi_file_h *file_header;
232 firmware_header = (struct firmware_header *)fw_data;
233 file_header = &firmware_header->file_header;
234 binaries = &firmware_header->binary_header;
235 strscpy(FW_rel_ver_name, file_header->version,
236 min(sizeof(FW_rel_ver_name), sizeof(file_header->version)));
237 ret = sh_css_check_firmware_version(dev, fw_data);
239 IA_CSS_ERROR("CSS code version (%s) and firmware version (%s) mismatch!",
240 file_header->version, release_version);
243 IA_CSS_LOG("successfully load firmware version %s", release_version);
246 /* some sanity checks */
247 if (!fw_data || fw_size < sizeof(struct sh_css_fw_bi_file_h))
250 if (file_header->h_size != sizeof(struct sh_css_fw_bi_file_h))
253 sh_css_num_binaries = file_header->binary_nr;
254 /* Only allocate memory for ISP blob info */
255 if (sh_css_num_binaries > NUM_OF_SPS) {
256 sh_css_blob_info = kmalloc(
257 (sh_css_num_binaries - NUM_OF_SPS) *
258 sizeof(*sh_css_blob_info), GFP_KERNEL);
259 if (!sh_css_blob_info)
262 sh_css_blob_info = NULL;
265 fw_minibuffer = kcalloc(sh_css_num_binaries, sizeof(struct fw_param),
270 for (i = 0; i < sh_css_num_binaries; i++) {
271 struct ia_css_fw_info *bi = &binaries[i];
273 * note: the var below is made static as it is quite large;
274 * if it is not static it ends up on the stack which could
275 * cause issues for drivers
277 static struct ia_css_blob_descr bd;
280 err = sh_css_load_blob_info(fw_data, bi, &bd, i);
285 if (bi->blob.offset + bi->blob.size > fw_size)
288 switch (bd.header.type) {
289 case ia_css_isp_firmware:
290 if (bd.header.info.isp.type > IA_CSS_ACC_STANDALONE) {
291 dev_err(dev, "binary #%2d: invalid SP type\n",
297 "binary #%-2d type %s (%s), binary id is %2d: %s\n",
299 fw_type_name[bd.header.type],
300 fw_acc_type_name[bd.header.info.isp.type],
301 bd.header.info.isp.sp.id,
304 case ia_css_sp_firmware:
305 case ia_css_bootloader_firmware:
306 case ia_css_acc_firmware:
308 "binary #%-2d type %s: %s\n",
309 i, fw_type_name[bd.header.type],
313 if (bd.header.info.isp.type > IA_CSS_ACC_STANDALONE) {
315 "binary #%2d: invalid firmware type\n",
322 if (bi->type == ia_css_sp_firmware) {
323 if (i != SP_FIRMWARE)
325 err = setup_binary(bi, fw_data, &sh_css_sp_fw, i);
331 * All subsequent binaries
332 * (including bootloaders) (i>NUM_OF_SPS)
338 if (bi->type != ia_css_isp_firmware)
340 if (!sh_css_blob_info) /* cannot happen but KW does not see this */
342 sh_css_blob_info[i - NUM_OF_SPS] = bd;
349 void sh_css_unload_firmware(void)
351 /* release firmware minibuffer */
355 for (i = 0; i < sh_css_num_binaries; i++) {
356 kfree(fw_minibuffer[i].name);
357 kvfree(fw_minibuffer[i].buffer);
359 kfree(fw_minibuffer);
360 fw_minibuffer = NULL;
363 memset(&sh_css_sp_fw, 0, sizeof(sh_css_sp_fw));
364 kfree(sh_css_blob_info);
365 sh_css_blob_info = NULL;
366 sh_css_num_binaries = 0;
370 sh_css_load_blob(const unsigned char *blob, unsigned int size)
372 ia_css_ptr target_addr = hmm_alloc(size, HMM_BO_PRIVATE, 0, NULL, 0);
374 * this will allocate memory aligned to a DDR word boundary which
375 * is required for the CSS DMA to read the instructions.
380 hmm_store(target_addr, blob, size);