2 * Support for Intel Camera Imaging ISP subsystem.
3 * Copyright (c) 2015, Intel Corporation.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 #include <linux/slab.h>
16 #include <linux/vmalloc.h>
18 #include <math_support.h>
19 #include "platform_support.h"
20 #include "sh_css_firmware.h"
22 #include "sh_css_defs.h"
23 #include "ia_css_debug.h"
24 #include "sh_css_internal.h"
25 #include "ia_css_isp_param.h"
27 #include "memory_access.h"
28 #include "assert_support.h"
29 #include "string_support.h"
31 #include "isp.h" /* PMEM_WIDTH_LOG2 */
33 #include "ia_css_isp_params.h"
34 #include "ia_css_isp_configs.h"
35 #include "ia_css_isp_states.h"
38 #define STR(x) _STR(x)
40 struct firmware_header {
41 struct sh_css_fw_bi_file_h file_header;
42 struct ia_css_fw_info binary_header;
50 /* Warning: same order as SH_CSS_BINARY_ID_* */
51 static struct firmware_header *firmware_header;
53 /* The string STR is a place holder
54 * which will be replaced with the actual RELEASE_VERSION
55 * during package generation. Please do not modify */
57 static const char *release_version = STR(irci_stable_candrpv_0415_20150521_0458);
59 static const char *release_version = STR(irci_ecr-master_20150911_0724);
62 #define MAX_FW_REL_VER_NAME 300
63 static char FW_rel_ver_name[MAX_FW_REL_VER_NAME] = "---";
65 struct ia_css_fw_info sh_css_sp_fw;
66 struct ia_css_blob_descr *sh_css_blob_info; /* Only ISP blob info (no SP) */
67 unsigned sh_css_num_binaries; /* This includes 1 SP binary */
69 static struct fw_param *fw_minibuffer;
72 char *sh_css_get_fw_version(void)
74 return FW_rel_ver_name;
79 * Split the loaded firmware into blobs
82 /* Setup sp/sp1 binary */
83 static enum ia_css_err
84 setup_binary(struct ia_css_fw_info *fw, const char *fw_data, struct ia_css_fw_info *sh_css_fw, unsigned binary_id)
86 const char *blob_data;
88 if ((fw == NULL) || (fw_data == NULL))
89 return IA_CSS_ERR_INVALID_ARGUMENTS;
91 blob_data = fw_data + fw->blob.offset;
95 sh_css_fw->blob.code = vmalloc(fw->blob.size);
96 if (sh_css_fw->blob.code == NULL)
97 return IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
99 memcpy((void *)sh_css_fw->blob.code, blob_data, fw->blob.size);
100 sh_css_fw->blob.data = (char *)sh_css_fw->blob.code + fw->blob.data_source;
101 fw_minibuffer[binary_id].buffer = sh_css_fw->blob.code;
103 return IA_CSS_SUCCESS;
106 sh_css_load_blob_info(const char *fw, const struct ia_css_fw_info *bi, struct ia_css_blob_descr *bd, unsigned index)
109 const unsigned char *blob;
111 if ((fw == NULL) || (bd == NULL))
112 return IA_CSS_ERR_INVALID_ARGUMENTS;
114 /* Special case: only one binary in fw */
115 if (bi == NULL) bi = (const struct ia_css_fw_info *)fw;
117 name = fw + bi->blob.prog_name_offset;
118 blob = (const unsigned char *)fw + bi->blob.offset;
121 if (bi->blob.size != bi->blob.text_size + bi->blob.icache_size + bi->blob.data_size + bi->blob.padding_size) {
122 /* sanity check, note the padding bytes added for section to DDR alignment */
123 return IA_CSS_ERR_INVALID_ARGUMENTS;
126 if ((bi->blob.offset % (1UL<<(ISP_PMEM_WIDTH_LOG2-3))) != 0)
127 return IA_CSS_ERR_INVALID_ARGUMENTS;
132 if (bi->type == ia_css_isp_firmware || bi->type == ia_css_sp_firmware) {
135 namebuffer = kstrdup(name, GFP_KERNEL);
137 return IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
138 bd->name = fw_minibuffer[index].name = namebuffer;
143 if (bi->type == ia_css_isp_firmware) {
144 size_t paramstruct_size = sizeof(struct ia_css_memory_offsets);
145 size_t configstruct_size = sizeof(struct ia_css_config_memory_offsets);
146 size_t statestruct_size = sizeof(struct ia_css_state_memory_offsets);
148 char *parambuf = (char *)kmalloc(paramstruct_size + configstruct_size + statestruct_size,
150 if (parambuf == NULL)
151 return IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
153 bd->mem_offsets.array[IA_CSS_PARAM_CLASS_PARAM].ptr = NULL;
154 bd->mem_offsets.array[IA_CSS_PARAM_CLASS_CONFIG].ptr = NULL;
155 bd->mem_offsets.array[IA_CSS_PARAM_CLASS_STATE].ptr = NULL;
157 fw_minibuffer[index].buffer = parambuf;
159 /* copy ia_css_memory_offsets */
160 memcpy(parambuf, (void *)(fw + bi->blob.memory_offsets.offsets[IA_CSS_PARAM_CLASS_PARAM]),
162 bd->mem_offsets.array[IA_CSS_PARAM_CLASS_PARAM].ptr = parambuf;
164 /* copy ia_css_config_memory_offsets */
165 memcpy(parambuf + paramstruct_size,
166 (void *)(fw + bi->blob.memory_offsets.offsets[IA_CSS_PARAM_CLASS_CONFIG]),
168 bd->mem_offsets.array[IA_CSS_PARAM_CLASS_CONFIG].ptr = parambuf + paramstruct_size;
170 /* copy ia_css_state_memory_offsets */
171 memcpy(parambuf + paramstruct_size + configstruct_size,
172 (void *)(fw + bi->blob.memory_offsets.offsets[IA_CSS_PARAM_CLASS_STATE]),
174 bd->mem_offsets.array[IA_CSS_PARAM_CLASS_STATE].ptr = parambuf + paramstruct_size + configstruct_size;
176 return IA_CSS_SUCCESS;
180 sh_css_check_firmware_version(const char *fw_data)
182 struct sh_css_fw_bi_file_h *file_header;
184 firmware_header = (struct firmware_header *)fw_data;
185 file_header = &firmware_header->file_header;
187 if (strcmp(file_header->version, release_version) != 0) {
190 /* firmware version matches */
196 sh_css_load_firmware(const char *fw_data,
197 unsigned int fw_size)
200 struct ia_css_fw_info *binaries;
201 struct sh_css_fw_bi_file_h *file_header;
202 bool valid_firmware = false;
204 firmware_header = (struct firmware_header *)fw_data;
205 file_header = &firmware_header->file_header;
206 binaries = &firmware_header->binary_header;
207 strncpy(FW_rel_ver_name, file_header->version, min(sizeof(FW_rel_ver_name), sizeof(file_header->version)) - 1);
208 valid_firmware = sh_css_check_firmware_version(fw_data);
209 if (!valid_firmware) {
210 #if !defined(HRT_RTL)
211 IA_CSS_ERROR("CSS code version (%s) and firmware version (%s) mismatch!",
212 file_header->version, release_version);
213 return IA_CSS_ERR_VERSION_MISMATCH;
216 IA_CSS_LOG("successfully load firmware version %s", release_version);
219 /* some sanity checks */
220 if (!fw_data || fw_size < sizeof(struct sh_css_fw_bi_file_h))
221 return IA_CSS_ERR_INTERNAL_ERROR;
223 if (file_header->h_size != sizeof(struct sh_css_fw_bi_file_h))
224 return IA_CSS_ERR_INTERNAL_ERROR;
226 sh_css_num_binaries = file_header->binary_nr;
227 /* Only allocate memory for ISP blob info */
228 if (sh_css_num_binaries > NUM_OF_SPS) {
229 sh_css_blob_info = kmalloc(
230 (sh_css_num_binaries - NUM_OF_SPS) *
231 sizeof(*sh_css_blob_info), GFP_KERNEL);
232 if (sh_css_blob_info == NULL)
233 return IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
235 sh_css_blob_info = NULL;
238 fw_minibuffer = kzalloc(sh_css_num_binaries * sizeof(struct fw_param), GFP_KERNEL);
239 if (fw_minibuffer == NULL)
240 return IA_CSS_ERR_CANNOT_ALLOCATE_MEMORY;
242 for (i = 0; i < sh_css_num_binaries; i++) {
243 struct ia_css_fw_info *bi = &binaries[i];
244 /* note: the var below is made static as it is quite large;
245 if it is not static it ends up on the stack which could
246 cause issues for drivers
248 static struct ia_css_blob_descr bd;
251 err = sh_css_load_blob_info(fw_data, bi, &bd, i);
253 if (err != IA_CSS_SUCCESS)
254 return IA_CSS_ERR_INTERNAL_ERROR;
256 if (bi->blob.offset + bi->blob.size > fw_size)
257 return IA_CSS_ERR_INTERNAL_ERROR;
259 if (bi->type == ia_css_sp_firmware) {
260 if (i != SP_FIRMWARE)
261 return IA_CSS_ERR_INTERNAL_ERROR;
262 err = setup_binary(bi, fw_data, &sh_css_sp_fw, i);
263 if (err != IA_CSS_SUCCESS)
266 /* All subsequent binaries (including bootloaders) (i>NUM_OF_SPS) are ISP firmware */
268 return IA_CSS_ERR_INTERNAL_ERROR;
270 if (bi->type != ia_css_isp_firmware)
271 return IA_CSS_ERR_INTERNAL_ERROR;
272 if (sh_css_blob_info == NULL) /* cannot happen but KW does not see this */
273 return IA_CSS_ERR_INTERNAL_ERROR;
274 sh_css_blob_info[i - NUM_OF_SPS] = bd;
278 return IA_CSS_SUCCESS;
281 void sh_css_unload_firmware(void)
284 /* release firmware minibuffer */
287 for (i = 0; i < sh_css_num_binaries; i++) {
288 if (fw_minibuffer[i].name)
289 kfree((void *)fw_minibuffer[i].name);
290 if (fw_minibuffer[i].buffer)
291 vfree((void *)fw_minibuffer[i].buffer);
293 kfree(fw_minibuffer);
294 fw_minibuffer = NULL;
297 memset(&sh_css_sp_fw, 0, sizeof(sh_css_sp_fw));
298 if (sh_css_blob_info) {
299 kfree(sh_css_blob_info);
300 sh_css_blob_info = NULL;
302 sh_css_num_binaries = 0;
306 sh_css_load_blob(const unsigned char *blob, unsigned size)
308 hrt_vaddress target_addr = mmgr_malloc(size);
309 /* this will allocate memory aligned to a DDR word boundary which
310 is required for the CSS DMA to read the instructions. */
312 assert(blob != NULL);
314 mmgr_store(target_addr, blob, size);