1 // SPDX-License-Identifier: GPL-2.0-only 2 // 3 // aw88395_lib.c -- ACF bin parsing and check library file for aw88395 4 // 5 // Copyright (c) 2022-2023 AWINIC Technology CO., LTD 6 // 7 // Author: Bruce zhao <zhaolei@awinic.com> 8 // 9 10 #include <linux/crc8.h> 11 #include <linux/i2c.h> 12 #include "aw88395_lib.h" 13 #include "aw88395_device.h" 14 #include "aw88395_reg.h" 15 16 #define AW88395_CRC8_POLYNOMIAL 0x8C 17 DECLARE_CRC8_TABLE(aw_crc8_table); 18 19 static char *profile_name[AW88395_PROFILE_MAX] = { 20 "Music", "Voice", "Voip", "Ringtone", 21 "Ringtone_hs", "Lowpower", "Bypass", 22 "Mmi", "Fm", "Notification", "Receiver" 23 }; 24 25 static int aw_parse_bin_header(struct aw_device *aw_dev, struct aw_bin *bin); 26 27 static int aw_check_sum(struct aw_device *aw_dev, struct aw_bin *bin, int bin_num) 28 { 29 unsigned char *p_check_sum; 30 unsigned int sum_data = 0; 31 unsigned int check_sum; 32 unsigned int i, len; 33 34 p_check_sum = &(bin->info.data[(bin->header_info[bin_num].valid_data_addr - 35 bin->header_info[bin_num].header_len)]); 36 len = bin->header_info[bin_num].bin_data_len + bin->header_info[bin_num].header_len; 37 check_sum = le32_to_cpup((void *)p_check_sum); 38 39 for (i = 4; i < len; i++) 40 sum_data += *(p_check_sum + i); 41 42 dev_dbg(aw_dev->dev, "%s -- check_sum = %p, check_sum = 0x%x, sum_data = 0x%x", 43 __func__, p_check_sum, check_sum, sum_data); 44 if (sum_data != check_sum) { 45 dev_err(aw_dev->dev, "%s. CheckSum Fail.bin_num=%d, CheckSum:0x%x, SumData:0x%x", 46 __func__, bin_num, check_sum, sum_data); 47 return -EINVAL; 48 } 49 50 return 0; 51 } 52 53 static int aw_check_data_version(struct aw_device *aw_dev, struct aw_bin *bin, int bin_num) 54 { 55 if (bin->header_info[bin_num].bin_data_ver < DATA_VERSION_V1 || 56 bin->header_info[bin_num].bin_data_ver > DATA_VERSION_MAX) { 57 dev_err(aw_dev->dev, "aw_bin_parse Unrecognized this bin data version\n"); 58 return -EINVAL; 59 } 60 61 return 0; 62 } 63 64 static int aw_check_register_num(struct aw_device *aw_dev, struct aw_bin *bin, int bin_num) 65 { 66 struct bin_header_info temp_info = bin->header_info[bin_num]; 67 unsigned int check_register_num, parse_register_num; 68 unsigned char *p_check_sum; 69 70 p_check_sum = &(bin->info.data[(temp_info.valid_data_addr)]); 71 72 parse_register_num = le32_to_cpup((void *)p_check_sum); 73 check_register_num = (bin->header_info[bin_num].bin_data_len - CHECK_REGISTER_NUM_OFFSET) / 74 (bin->header_info[bin_num].reg_byte_len + 75 bin->header_info[bin_num].data_byte_len); 76 dev_dbg(aw_dev->dev, "%s,parse_register_num = 0x%x,check_register_num = 0x%x\n", 77 __func__, parse_register_num, check_register_num); 78 if (parse_register_num != check_register_num) { 79 dev_err(aw_dev->dev, "%s parse_register_num = 0x%x,check_register_num = 0x%x\n", 80 __func__, parse_register_num, check_register_num); 81 return -EINVAL; 82 } 83 84 bin->header_info[bin_num].reg_num = parse_register_num; 85 bin->header_info[bin_num].valid_data_len = temp_info.bin_data_len - VALID_DATA_LEN; 86 bin->header_info[bin_num].valid_data_addr = temp_info.valid_data_addr + VALID_DATA_ADDR; 87 88 return 0; 89 } 90 91 static int aw_check_dsp_reg_num(struct aw_device *aw_dev, struct aw_bin *bin, int bin_num) 92 { 93 struct bin_header_info temp_info = bin->header_info[bin_num]; 94 unsigned int check_dsp_reg_num, parse_dsp_reg_num; 95 unsigned char *p_check_sum; 96 97 p_check_sum = &(bin->info.data[(temp_info.valid_data_addr)]); 98 99 parse_dsp_reg_num = le32_to_cpup((void *)(p_check_sum + PARSE_DSP_REG_NUM)); 100 bin->header_info[bin_num].reg_data_byte_len = 101 le32_to_cpup((void *)(p_check_sum + REG_DATA_BYTP_LEN)); 102 check_dsp_reg_num = (bin->header_info[bin_num].bin_data_len - CHECK_DSP_REG_NUM) / 103 bin->header_info[bin_num].reg_data_byte_len; 104 dev_dbg(aw_dev->dev, "%s bin_num = %d, parse_dsp_reg_num = 0x%x, check_dsp_reg_num = 0x%x", 105 __func__, bin_num, check_dsp_reg_num, check_dsp_reg_num); 106 if (parse_dsp_reg_num != check_dsp_reg_num) { 107 dev_err(aw_dev->dev, "aw_bin_parse check dsp reg num error\n"); 108 dev_err(aw_dev->dev, "%s parse_dsp_reg_num = 0x%x, check_dsp_reg_num = 0x%x", 109 __func__, check_dsp_reg_num, check_dsp_reg_num); 110 return -EINVAL; 111 } 112 113 bin->header_info[bin_num].download_addr = le32_to_cpup((void *)p_check_sum); 114 bin->header_info[bin_num].reg_num = parse_dsp_reg_num; 115 bin->header_info[bin_num].valid_data_len = temp_info.bin_data_len - DSP_VALID_DATA_LEN; 116 bin->header_info[bin_num].valid_data_addr = temp_info.valid_data_addr + 117 DSP_VALID_DATA_ADDR; 118 119 return 0; 120 } 121 122 static int aw_check_soc_app_num(struct aw_device *aw_dev, struct aw_bin *bin, int bin_num) 123 { 124 struct bin_header_info temp_info = bin->header_info[bin_num]; 125 unsigned int check_soc_app_num, parse_soc_app_num; 126 unsigned char *p_check_sum; 127 128 p_check_sum = &(bin->info.data[(temp_info.valid_data_addr)]); 129 130 bin->header_info[bin_num].app_version = le32_to_cpup((void *)p_check_sum); 131 parse_soc_app_num = le32_to_cpup((void *)(p_check_sum + PARSE_SOC_APP_NUM)); 132 check_soc_app_num = bin->header_info[bin_num].bin_data_len - CHECK_SOC_APP_NUM; 133 dev_dbg(aw_dev->dev, "%s bin_num = %d, parse_soc_app_num=0x%x, check_soc_app_num = 0x%x\n", 134 __func__, bin_num, parse_soc_app_num, check_soc_app_num); 135 if (parse_soc_app_num != check_soc_app_num) { 136 dev_err(aw_dev->dev, "%s parse_soc_app_num=0x%x, check_soc_app_num = 0x%x\n", 137 __func__, parse_soc_app_num, check_soc_app_num); 138 return -EINVAL; 139 } 140 141 bin->header_info[bin_num].reg_num = parse_soc_app_num; 142 bin->header_info[bin_num].download_addr = le32_to_cpup((void *)(p_check_sum + 143 APP_DOWNLOAD_ADDR)); 144 bin->header_info[bin_num].valid_data_len = temp_info.bin_data_len - APP_VALID_DATA_LEN; 145 bin->header_info[bin_num].valid_data_addr = temp_info.valid_data_addr + 146 APP_VALID_DATA_ADDR; 147 148 return 0; 149 } 150 151 static void aw_get_single_bin_header(struct aw_bin *bin) 152 { 153 memcpy((void *)&bin->header_info[bin->all_bin_parse_num], bin->p_addr, DATA_LEN); 154 155 bin->header_info[bin->all_bin_parse_num].header_len = HEADER_LEN; 156 bin->all_bin_parse_num += 1; 157 } 158 159 static int aw_parse_one_of_multi_bins(struct aw_device *aw_dev, unsigned int bin_num, 160 int bin_serial_num, struct aw_bin *bin) 161 { 162 struct bin_header_info aw_bin_header_info; 163 unsigned int bin_start_addr; 164 unsigned int valid_data_len; 165 166 if (bin->info.len < sizeof(struct bin_header_info)) { 167 dev_err(aw_dev->dev, "bin_header_info size[%d] overflow file size[%d]\n", 168 (int)sizeof(struct bin_header_info), bin->info.len); 169 return -EINVAL; 170 } 171 172 aw_bin_header_info = bin->header_info[bin->all_bin_parse_num - 1]; 173 if (!bin_serial_num) { 174 bin_start_addr = le32_to_cpup((void *)(bin->p_addr + START_ADDR_OFFSET)); 175 bin->p_addr += (HEADER_LEN + bin_start_addr); 176 bin->header_info[bin->all_bin_parse_num].valid_data_addr = 177 aw_bin_header_info.valid_data_addr + VALID_DATA_ADDR + 8 * bin_num + 178 VALID_DATA_ADDR_OFFSET; 179 } else { 180 valid_data_len = aw_bin_header_info.bin_data_len; 181 bin->p_addr += (HDADER_LEN + valid_data_len); 182 bin->header_info[bin->all_bin_parse_num].valid_data_addr = 183 aw_bin_header_info.valid_data_addr + aw_bin_header_info.bin_data_len + 184 VALID_DATA_ADDR_OFFSET; 185 } 186 187 return aw_parse_bin_header(aw_dev, bin); 188 } 189 190 static int aw_get_multi_bin_header(struct aw_device *aw_dev, struct aw_bin *bin) 191 { 192 unsigned int bin_num, i; 193 int ret; 194 195 bin_num = le32_to_cpup((void *)(bin->p_addr + VALID_DATA_ADDR_OFFSET)); 196 if (bin->multi_bin_parse_num == 1) 197 bin->header_info[bin->all_bin_parse_num].valid_data_addr = 198 VALID_DATA_ADDR_OFFSET; 199 200 aw_get_single_bin_header(bin); 201 202 for (i = 0; i < bin_num; i++) { 203 dev_dbg(aw_dev->dev, "aw_bin_parse enter multi bin for is %d\n", i); 204 ret = aw_parse_one_of_multi_bins(aw_dev, bin_num, i, bin); 205 if (ret < 0) 206 return ret; 207 } 208 209 return 0; 210 } 211 212 static int aw_parse_bin_header(struct aw_device *aw_dev, struct aw_bin *bin) 213 { 214 unsigned int bin_data_type; 215 216 if (bin->info.len < sizeof(struct bin_header_info)) { 217 dev_err(aw_dev->dev, "bin_header_info size[%d] overflow file size[%d]\n", 218 (int)sizeof(struct bin_header_info), bin->info.len); 219 return -EINVAL; 220 } 221 222 bin_data_type = le32_to_cpup((void *)(bin->p_addr + BIN_DATA_TYPE_OFFSET)); 223 dev_dbg(aw_dev->dev, "aw_bin_parse bin_data_type 0x%x\n", bin_data_type); 224 switch (bin_data_type) { 225 case DATA_TYPE_REGISTER: 226 case DATA_TYPE_DSP_REG: 227 case DATA_TYPE_SOC_APP: 228 bin->single_bin_parse_num += 1; 229 dev_dbg(aw_dev->dev, "%s bin->single_bin_parse_num is %d\n", __func__, 230 bin->single_bin_parse_num); 231 if (!bin->multi_bin_parse_num) 232 bin->header_info[bin->all_bin_parse_num].valid_data_addr = 233 VALID_DATA_ADDR_OFFSET; 234 aw_get_single_bin_header(bin); 235 return 0; 236 case DATA_TYPE_MULTI_BINS: 237 bin->multi_bin_parse_num += 1; 238 dev_dbg(aw_dev->dev, "%s bin->multi_bin_parse_num is %d\n", __func__, 239 bin->multi_bin_parse_num); 240 return aw_get_multi_bin_header(aw_dev, bin); 241 default: 242 dev_dbg(aw_dev->dev, "%s There is no corresponding type\n", __func__); 243 return 0; 244 } 245 } 246 247 static int aw_check_bin_header_version(struct aw_device *aw_dev, struct aw_bin *bin) 248 { 249 unsigned int header_version; 250 251 header_version = le32_to_cpup((void *)(bin->p_addr + HEADER_VERSION_OFFSET)); 252 dev_dbg(aw_dev->dev, "aw_bin_parse header_version 0x%x\n", header_version); 253 254 switch (header_version) { 255 case HEADER_VERSION_V1: 256 return aw_parse_bin_header(aw_dev, bin); 257 default: 258 dev_err(aw_dev->dev, "aw_bin_parse Unrecognized this bin header version\n"); 259 return -EINVAL; 260 } 261 } 262 263 static int aw_parsing_bin_file(struct aw_device *aw_dev, struct aw_bin *bin) 264 { 265 int ret = -EINVAL; 266 int i; 267 268 if (!bin) { 269 dev_err(aw_dev->dev, "aw_bin_parse bin is NULL\n"); 270 return ret; 271 } 272 bin->p_addr = bin->info.data; 273 bin->all_bin_parse_num = 0; 274 bin->multi_bin_parse_num = 0; 275 bin->single_bin_parse_num = 0; 276 277 ret = aw_check_bin_header_version(aw_dev, bin); 278 if (ret < 0) { 279 dev_err(aw_dev->dev, "aw_bin_parse check bin header version error\n"); 280 return ret; 281 } 282 283 for (i = 0; i < bin->all_bin_parse_num; i++) { 284 ret = aw_check_sum(aw_dev, bin, i); 285 if (ret < 0) { 286 dev_err(aw_dev->dev, "aw_bin_parse check sum data error\n"); 287 return ret; 288 } 289 ret = aw_check_data_version(aw_dev, bin, i); 290 if (ret < 0) { 291 dev_err(aw_dev->dev, "aw_bin_parse check data version error\n"); 292 return ret; 293 } 294 if (bin->header_info[i].bin_data_ver == DATA_VERSION_V1) { 295 switch (bin->header_info[i].bin_data_type) { 296 case DATA_TYPE_REGISTER: 297 ret = aw_check_register_num(aw_dev, bin, i); 298 break; 299 case DATA_TYPE_DSP_REG: 300 ret = aw_check_dsp_reg_num(aw_dev, bin, i); 301 break; 302 case DATA_TYPE_SOC_APP: 303 ret = aw_check_soc_app_num(aw_dev, bin, i); 304 break; 305 default: 306 bin->header_info[i].valid_data_len = 307 bin->header_info[i].bin_data_len; 308 ret = 0; 309 break; 310 } 311 if (ret < 0) 312 return ret; 313 } 314 } 315 316 return 0; 317 } 318 319 static int aw_dev_parse_raw_reg(unsigned char *data, unsigned int data_len, 320 struct aw_prof_desc *prof_desc) 321 { 322 prof_desc->sec_desc[AW88395_DATA_TYPE_REG].data = data; 323 prof_desc->sec_desc[AW88395_DATA_TYPE_REG].len = data_len; 324 325 prof_desc->prof_st = AW88395_PROFILE_OK; 326 327 return 0; 328 } 329 330 static int aw_dev_parse_raw_dsp_cfg(unsigned char *data, unsigned int data_len, 331 struct aw_prof_desc *prof_desc) 332 { 333 if (data_len & 0x01) 334 return -EINVAL; 335 336 swab16_array((u16 *)data, data_len >> 1); 337 338 prof_desc->sec_desc[AW88395_DATA_TYPE_DSP_CFG].data = data; 339 prof_desc->sec_desc[AW88395_DATA_TYPE_DSP_CFG].len = data_len; 340 341 prof_desc->prof_st = AW88395_PROFILE_OK; 342 343 return 0; 344 } 345 346 static int aw_dev_parse_raw_dsp_fw(unsigned char *data, unsigned int data_len, 347 struct aw_prof_desc *prof_desc) 348 { 349 if (data_len & 0x01) 350 return -EINVAL; 351 352 swab16_array((u16 *)data, data_len >> 1); 353 354 prof_desc->sec_desc[AW88395_DATA_TYPE_DSP_FW].data = data; 355 prof_desc->sec_desc[AW88395_DATA_TYPE_DSP_FW].len = data_len; 356 357 prof_desc->prof_st = AW88395_PROFILE_OK; 358 359 return 0; 360 } 361 362 static int aw_dev_prof_parse_multi_bin(struct aw_device *aw_dev, unsigned char *data, 363 unsigned int data_len, struct aw_prof_desc *prof_desc) 364 { 365 struct aw_bin *aw_bin; 366 int ret; 367 int i; 368 369 aw_bin = devm_kzalloc(aw_dev->dev, data_len + sizeof(struct aw_bin), GFP_KERNEL); 370 if (!aw_bin) 371 return -ENOMEM; 372 373 aw_bin->info.len = data_len; 374 memcpy(aw_bin->info.data, data, data_len); 375 376 ret = aw_parsing_bin_file(aw_dev, aw_bin); 377 if (ret < 0) { 378 dev_err(aw_dev->dev, "parse bin failed"); 379 goto parse_bin_failed; 380 } 381 382 for (i = 0; i < aw_bin->all_bin_parse_num; i++) { 383 switch (aw_bin->header_info[i].bin_data_type) { 384 case DATA_TYPE_REGISTER: 385 prof_desc->sec_desc[AW88395_DATA_TYPE_REG].len = 386 aw_bin->header_info[i].valid_data_len; 387 prof_desc->sec_desc[AW88395_DATA_TYPE_REG].data = 388 data + aw_bin->header_info[i].valid_data_addr; 389 break; 390 case DATA_TYPE_DSP_REG: 391 if (aw_bin->header_info[i].valid_data_len & 0x01) { 392 ret = -EINVAL; 393 goto parse_bin_failed; 394 } 395 396 swab16_array((u16 *)(data + aw_bin->header_info[i].valid_data_addr), 397 aw_bin->header_info[i].valid_data_len >> 1); 398 399 prof_desc->sec_desc[AW88395_DATA_TYPE_DSP_CFG].len = 400 aw_bin->header_info[i].valid_data_len; 401 prof_desc->sec_desc[AW88395_DATA_TYPE_DSP_CFG].data = 402 data + aw_bin->header_info[i].valid_data_addr; 403 break; 404 case DATA_TYPE_DSP_FW: 405 case DATA_TYPE_SOC_APP: 406 if (aw_bin->header_info[i].valid_data_len & 0x01) { 407 ret = -EINVAL; 408 goto parse_bin_failed; 409 } 410 411 swab16_array((u16 *)(data + aw_bin->header_info[i].valid_data_addr), 412 aw_bin->header_info[i].valid_data_len >> 1); 413 414 prof_desc->fw_ver = aw_bin->header_info[i].app_version; 415 prof_desc->sec_desc[AW88395_DATA_TYPE_DSP_FW].len = 416 aw_bin->header_info[i].valid_data_len; 417 prof_desc->sec_desc[AW88395_DATA_TYPE_DSP_FW].data = 418 data + aw_bin->header_info[i].valid_data_addr; 419 break; 420 default: 421 dev_dbg(aw_dev->dev, "bin_data_type not found"); 422 break; 423 } 424 } 425 prof_desc->prof_st = AW88395_PROFILE_OK; 426 ret = 0; 427 428 parse_bin_failed: 429 devm_kfree(aw_dev->dev, aw_bin); 430 return ret; 431 } 432 433 static int aw_dev_parse_reg_bin_with_hdr(struct aw_device *aw_dev, 434 uint8_t *data, uint32_t data_len, struct aw_prof_desc *prof_desc) 435 { 436 struct aw_bin *aw_bin; 437 int ret; 438 439 aw_bin = devm_kzalloc(aw_dev->dev, data_len + sizeof(*aw_bin), GFP_KERNEL); 440 if (!aw_bin) 441 return -ENOMEM; 442 443 aw_bin->info.len = data_len; 444 memcpy(aw_bin->info.data, data, data_len); 445 446 ret = aw_parsing_bin_file(aw_dev, aw_bin); 447 if (ret < 0) { 448 dev_err(aw_dev->dev, "parse bin failed"); 449 goto parse_bin_failed; 450 } 451 452 if ((aw_bin->all_bin_parse_num != 1) || 453 (aw_bin->header_info[0].bin_data_type != DATA_TYPE_REGISTER)) { 454 dev_err(aw_dev->dev, "bin num or type error"); 455 ret = -EINVAL; 456 goto parse_bin_failed; 457 } 458 459 if (aw_dev->chip_id == AW88261_CHIP_ID) { 460 if (aw_bin->header_info[0].valid_data_len % 4) { 461 dev_err(aw_dev->dev, "bin data len get error!"); 462 ret = -EINVAL; 463 goto parse_bin_failed; 464 } 465 } 466 467 prof_desc->sec_desc[AW88395_DATA_TYPE_REG].data = 468 data + aw_bin->header_info[0].valid_data_addr; 469 prof_desc->sec_desc[AW88395_DATA_TYPE_REG].len = 470 aw_bin->header_info[0].valid_data_len; 471 prof_desc->prof_st = AW88395_PROFILE_OK; 472 473 devm_kfree(aw_dev->dev, aw_bin); 474 aw_bin = NULL; 475 476 return 0; 477 478 parse_bin_failed: 479 devm_kfree(aw_dev->dev, aw_bin); 480 aw_bin = NULL; 481 return ret; 482 } 483 484 static int aw_dev_parse_data_by_sec_type(struct aw_device *aw_dev, struct aw_cfg_hdr *cfg_hdr, 485 struct aw_cfg_dde *cfg_dde, struct aw_prof_desc *scene_prof_desc) 486 { 487 switch (cfg_dde->data_type) { 488 case ACF_SEC_TYPE_REG: 489 return aw_dev_parse_raw_reg((u8 *)cfg_hdr + cfg_dde->data_offset, 490 cfg_dde->data_size, scene_prof_desc); 491 case ACF_SEC_TYPE_DSP_CFG: 492 return aw_dev_parse_raw_dsp_cfg((u8 *)cfg_hdr + cfg_dde->data_offset, 493 cfg_dde->data_size, scene_prof_desc); 494 case ACF_SEC_TYPE_DSP_FW: 495 return aw_dev_parse_raw_dsp_fw( 496 (u8 *)cfg_hdr + cfg_dde->data_offset, 497 cfg_dde->data_size, scene_prof_desc); 498 case ACF_SEC_TYPE_MULTIPLE_BIN: 499 return aw_dev_prof_parse_multi_bin( 500 aw_dev, (u8 *)cfg_hdr + cfg_dde->data_offset, 501 cfg_dde->data_size, scene_prof_desc); 502 case ACF_SEC_TYPE_HDR_REG: 503 return aw_dev_parse_reg_bin_with_hdr(aw_dev, (u8 *)cfg_hdr + cfg_dde->data_offset, 504 cfg_dde->data_size, scene_prof_desc); 505 default: 506 dev_err(aw_dev->dev, "%s cfg_dde->data_type = %d\n", __func__, cfg_dde->data_type); 507 break; 508 } 509 510 return 0; 511 } 512 513 static int aw_dev_parse_dev_type(struct aw_device *aw_dev, 514 struct aw_cfg_hdr *prof_hdr, struct aw_all_prof_info *all_prof_info) 515 { 516 struct aw_cfg_dde *cfg_dde = 517 (struct aw_cfg_dde *)((char *)prof_hdr + prof_hdr->hdr_offset); 518 int sec_num = 0; 519 int ret, i; 520 521 for (i = 0; i < prof_hdr->ddt_num; i++) { 522 if ((aw_dev->i2c->adapter->nr == cfg_dde[i].dev_bus) && 523 (aw_dev->i2c->addr == cfg_dde[i].dev_addr) && 524 (cfg_dde[i].type == AW88395_DEV_TYPE_ID) && 525 (cfg_dde[i].data_type != ACF_SEC_TYPE_MONITOR)) { 526 if (cfg_dde[i].dev_profile >= AW88395_PROFILE_MAX) { 527 dev_err(aw_dev->dev, "dev_profile [%d] overflow", 528 cfg_dde[i].dev_profile); 529 return -EINVAL; 530 } 531 532 ret = aw_dev_parse_data_by_sec_type(aw_dev, prof_hdr, &cfg_dde[i], 533 &all_prof_info->prof_desc[cfg_dde[i].dev_profile]); 534 if (ret < 0) { 535 dev_err(aw_dev->dev, "parse failed"); 536 return ret; 537 } 538 sec_num++; 539 } 540 } 541 542 if (sec_num == 0) { 543 dev_dbg(aw_dev->dev, "get dev type num is %d, please use default", sec_num); 544 return AW88395_DEV_TYPE_NONE; 545 } 546 547 return AW88395_DEV_TYPE_OK; 548 } 549 550 static int aw_dev_parse_dev_default_type(struct aw_device *aw_dev, 551 struct aw_cfg_hdr *prof_hdr, struct aw_all_prof_info *all_prof_info) 552 { 553 struct aw_cfg_dde *cfg_dde = 554 (struct aw_cfg_dde *)((char *)prof_hdr + prof_hdr->hdr_offset); 555 int sec_num = 0; 556 int ret, i; 557 558 for (i = 0; i < prof_hdr->ddt_num; i++) { 559 if ((aw_dev->channel == cfg_dde[i].dev_index) && 560 (cfg_dde[i].type == AW88395_DEV_DEFAULT_TYPE_ID) && 561 (cfg_dde[i].data_type != ACF_SEC_TYPE_MONITOR)) { 562 if (cfg_dde[i].dev_profile >= AW88395_PROFILE_MAX) { 563 dev_err(aw_dev->dev, "dev_profile [%d] overflow", 564 cfg_dde[i].dev_profile); 565 return -EINVAL; 566 } 567 ret = aw_dev_parse_data_by_sec_type(aw_dev, prof_hdr, &cfg_dde[i], 568 &all_prof_info->prof_desc[cfg_dde[i].dev_profile]); 569 if (ret < 0) { 570 dev_err(aw_dev->dev, "parse failed"); 571 return ret; 572 } 573 sec_num++; 574 } 575 } 576 577 if (sec_num == 0) { 578 dev_err(aw_dev->dev, "get dev default type failed, get num[%d]", sec_num); 579 return -EINVAL; 580 } 581 582 return 0; 583 } 584 585 static int aw88261_dev_cfg_get_valid_prof(struct aw_device *aw_dev, 586 struct aw_all_prof_info *all_prof_info) 587 { 588 struct aw_prof_desc *prof_desc = all_prof_info->prof_desc; 589 struct aw_prof_info *prof_info = &aw_dev->prof_info; 590 int num = 0; 591 int i; 592 593 for (i = 0; i < AW88395_PROFILE_MAX; i++) { 594 if (prof_desc[i].prof_st == AW88395_PROFILE_OK) 595 prof_info->count++; 596 } 597 598 dev_dbg(aw_dev->dev, "get valid profile:%d", aw_dev->prof_info.count); 599 600 if (!prof_info->count) { 601 dev_err(aw_dev->dev, "no profile data"); 602 return -EPERM; 603 } 604 605 prof_info->prof_desc = devm_kcalloc(aw_dev->dev, 606 prof_info->count, sizeof(struct aw_prof_desc), 607 GFP_KERNEL); 608 if (!prof_info->prof_desc) 609 return -ENOMEM; 610 611 for (i = 0; i < AW88395_PROFILE_MAX; i++) { 612 if (prof_desc[i].prof_st == AW88395_PROFILE_OK) { 613 if (num >= prof_info->count) { 614 dev_err(aw_dev->dev, "overflow count[%d]", 615 prof_info->count); 616 return -EINVAL; 617 } 618 prof_info->prof_desc[num] = prof_desc[i]; 619 prof_info->prof_desc[num].id = i; 620 num++; 621 } 622 } 623 624 return 0; 625 } 626 627 static int aw88395_dev_cfg_get_valid_prof(struct aw_device *aw_dev, 628 struct aw_all_prof_info *all_prof_info) 629 { 630 struct aw_prof_desc *prof_desc = all_prof_info->prof_desc; 631 struct aw_prof_info *prof_info = &aw_dev->prof_info; 632 struct aw_sec_data_desc *sec_desc; 633 int num = 0; 634 int i; 635 636 for (i = 0; i < AW88395_PROFILE_MAX; i++) { 637 if (prof_desc[i].prof_st == AW88395_PROFILE_OK) { 638 sec_desc = prof_desc[i].sec_desc; 639 if ((sec_desc[AW88395_DATA_TYPE_REG].data != NULL) && 640 (sec_desc[AW88395_DATA_TYPE_REG].len != 0) && 641 (sec_desc[AW88395_DATA_TYPE_DSP_CFG].data != NULL) && 642 (sec_desc[AW88395_DATA_TYPE_DSP_CFG].len != 0) && 643 (sec_desc[AW88395_DATA_TYPE_DSP_FW].data != NULL) && 644 (sec_desc[AW88395_DATA_TYPE_DSP_FW].len != 0)) 645 prof_info->count++; 646 } 647 } 648 649 dev_dbg(aw_dev->dev, "get valid profile:%d", aw_dev->prof_info.count); 650 651 if (!prof_info->count) { 652 dev_err(aw_dev->dev, "no profile data"); 653 return -EPERM; 654 } 655 656 prof_info->prof_desc = devm_kcalloc(aw_dev->dev, 657 prof_info->count, sizeof(struct aw_prof_desc), 658 GFP_KERNEL); 659 if (!prof_info->prof_desc) 660 return -ENOMEM; 661 662 for (i = 0; i < AW88395_PROFILE_MAX; i++) { 663 if (prof_desc[i].prof_st == AW88395_PROFILE_OK) { 664 sec_desc = prof_desc[i].sec_desc; 665 if ((sec_desc[AW88395_DATA_TYPE_REG].data != NULL) && 666 (sec_desc[AW88395_DATA_TYPE_REG].len != 0) && 667 (sec_desc[AW88395_DATA_TYPE_DSP_CFG].data != NULL) && 668 (sec_desc[AW88395_DATA_TYPE_DSP_CFG].len != 0) && 669 (sec_desc[AW88395_DATA_TYPE_DSP_FW].data != NULL) && 670 (sec_desc[AW88395_DATA_TYPE_DSP_FW].len != 0)) { 671 if (num >= prof_info->count) { 672 dev_err(aw_dev->dev, "overflow count[%d]", 673 prof_info->count); 674 return -EINVAL; 675 } 676 prof_info->prof_desc[num] = prof_desc[i]; 677 prof_info->prof_desc[num].id = i; 678 num++; 679 } 680 } 681 } 682 683 return 0; 684 } 685 686 static int aw_dev_load_cfg_by_hdr(struct aw_device *aw_dev, 687 struct aw_cfg_hdr *prof_hdr) 688 { 689 struct aw_all_prof_info *all_prof_info; 690 int ret; 691 692 all_prof_info = devm_kzalloc(aw_dev->dev, sizeof(struct aw_all_prof_info), GFP_KERNEL); 693 if (!all_prof_info) 694 return -ENOMEM; 695 696 ret = aw_dev_parse_dev_type(aw_dev, prof_hdr, all_prof_info); 697 if (ret < 0) { 698 goto exit; 699 } else if (ret == AW88395_DEV_TYPE_NONE) { 700 dev_dbg(aw_dev->dev, "get dev type num is 0, parse default dev"); 701 ret = aw_dev_parse_dev_default_type(aw_dev, prof_hdr, all_prof_info); 702 if (ret < 0) 703 goto exit; 704 } 705 706 switch (aw_dev->chip_id) { 707 case AW88395_CHIP_ID: 708 case AW88399_CHIP_ID: 709 ret = aw88395_dev_cfg_get_valid_prof(aw_dev, all_prof_info); 710 if (ret < 0) 711 goto exit; 712 break; 713 case AW88261_CHIP_ID: 714 case AW87390_CHIP_ID: 715 ret = aw88261_dev_cfg_get_valid_prof(aw_dev, all_prof_info); 716 if (ret < 0) 717 goto exit; 718 break; 719 default: 720 dev_err(aw_dev->dev, "valid prof unsupported"); 721 ret = -EINVAL; 722 break; 723 } 724 725 aw_dev->prof_info.prof_name_list = profile_name; 726 727 exit: 728 devm_kfree(aw_dev->dev, all_prof_info); 729 return ret; 730 } 731 732 static int aw_dev_create_prof_name_list_v1(struct aw_device *aw_dev) 733 { 734 struct aw_prof_info *prof_info = &aw_dev->prof_info; 735 struct aw_prof_desc *prof_desc = prof_info->prof_desc; 736 int i; 737 738 if (!prof_desc) { 739 dev_err(aw_dev->dev, "prof_desc is NULL"); 740 return -EINVAL; 741 } 742 743 prof_info->prof_name_list = devm_kzalloc(aw_dev->dev, 744 prof_info->count * PROFILE_STR_MAX, 745 GFP_KERNEL); 746 if (!prof_info->prof_name_list) 747 return -ENOMEM; 748 749 for (i = 0; i < prof_info->count; i++) { 750 prof_desc[i].id = i; 751 prof_info->prof_name_list[i] = prof_desc[i].prf_str; 752 dev_dbg(aw_dev->dev, "prof name is %s", prof_info->prof_name_list[i]); 753 } 754 755 return 0; 756 } 757 758 static int aw_get_dde_type_info(struct aw_device *aw_dev, struct aw_container *aw_cfg) 759 { 760 struct aw_cfg_hdr *cfg_hdr = (struct aw_cfg_hdr *)aw_cfg->data; 761 struct aw_cfg_dde_v1 *cfg_dde = 762 (struct aw_cfg_dde_v1 *)(aw_cfg->data + cfg_hdr->hdr_offset); 763 int default_num = 0; 764 int dev_num = 0; 765 unsigned int i; 766 767 for (i = 0; i < cfg_hdr->ddt_num; i++) { 768 if (cfg_dde[i].type == AW88395_DEV_TYPE_ID) 769 dev_num++; 770 771 if (cfg_dde[i].type == AW88395_DEV_DEFAULT_TYPE_ID) 772 default_num++; 773 } 774 775 if (dev_num != 0) { 776 aw_dev->prof_info.prof_type = AW88395_DEV_TYPE_ID; 777 } else if (default_num != 0) { 778 aw_dev->prof_info.prof_type = AW88395_DEV_DEFAULT_TYPE_ID; 779 } else { 780 dev_err(aw_dev->dev, "can't find scene"); 781 return -EINVAL; 782 } 783 784 return 0; 785 } 786 787 static int aw_get_dev_scene_count_v1(struct aw_device *aw_dev, struct aw_container *aw_cfg, 788 unsigned int *scene_num) 789 { 790 struct aw_cfg_hdr *cfg_hdr = (struct aw_cfg_hdr *)aw_cfg->data; 791 struct aw_cfg_dde_v1 *cfg_dde = 792 (struct aw_cfg_dde_v1 *)(aw_cfg->data + cfg_hdr->hdr_offset); 793 unsigned int i; 794 int ret; 795 796 switch (aw_dev->chip_id) { 797 case AW88395_CHIP_ID: 798 case AW88399_CHIP_ID: 799 for (i = 0; i < cfg_hdr->ddt_num; ++i) { 800 if ((cfg_dde[i].data_type == ACF_SEC_TYPE_MULTIPLE_BIN) && 801 (aw_dev->chip_id == cfg_dde[i].chip_id) && 802 (aw_dev->i2c->adapter->nr == cfg_dde[i].dev_bus) && 803 (aw_dev->i2c->addr == cfg_dde[i].dev_addr)) 804 (*scene_num)++; 805 } 806 ret = 0; 807 break; 808 case AW88261_CHIP_ID: 809 case AW87390_CHIP_ID: 810 for (i = 0; i < cfg_hdr->ddt_num; ++i) { 811 if (((cfg_dde[i].data_type == ACF_SEC_TYPE_REG) || 812 (cfg_dde[i].data_type == ACF_SEC_TYPE_HDR_REG)) && 813 (aw_dev->chip_id == cfg_dde[i].chip_id) && 814 (aw_dev->i2c->adapter->nr == cfg_dde[i].dev_bus) && 815 (aw_dev->i2c->addr == cfg_dde[i].dev_addr)) 816 (*scene_num)++; 817 } 818 ret = 0; 819 break; 820 default: 821 dev_err(aw_dev->dev, "unsupported device"); 822 ret = -EINVAL; 823 break; 824 } 825 826 return ret; 827 } 828 829 static int aw_get_default_scene_count_v1(struct aw_device *aw_dev, 830 struct aw_container *aw_cfg, 831 unsigned int *scene_num) 832 { 833 struct aw_cfg_hdr *cfg_hdr = (struct aw_cfg_hdr *)aw_cfg->data; 834 struct aw_cfg_dde_v1 *cfg_dde = 835 (struct aw_cfg_dde_v1 *)(aw_cfg->data + cfg_hdr->hdr_offset); 836 unsigned int i; 837 int ret; 838 839 switch (aw_dev->chip_id) { 840 case AW88395_CHIP_ID: 841 case AW88399_CHIP_ID: 842 for (i = 0; i < cfg_hdr->ddt_num; ++i) { 843 if ((cfg_dde[i].data_type == ACF_SEC_TYPE_MULTIPLE_BIN) && 844 (aw_dev->chip_id == cfg_dde[i].chip_id) && 845 (aw_dev->channel == cfg_dde[i].dev_index)) 846 (*scene_num)++; 847 } 848 ret = 0; 849 break; 850 case AW88261_CHIP_ID: 851 case AW87390_CHIP_ID: 852 for (i = 0; i < cfg_hdr->ddt_num; ++i) { 853 if (((cfg_dde[i].data_type == ACF_SEC_TYPE_REG) || 854 (cfg_dde[i].data_type == ACF_SEC_TYPE_HDR_REG)) && 855 (aw_dev->chip_id == cfg_dde[i].chip_id) && 856 (aw_dev->channel == cfg_dde[i].dev_index)) 857 (*scene_num)++; 858 } 859 ret = 0; 860 break; 861 default: 862 dev_err(aw_dev->dev, "unsupported device"); 863 ret = -EINVAL; 864 break; 865 } 866 867 return ret; 868 } 869 870 static int aw_dev_parse_scene_count_v1(struct aw_device *aw_dev, 871 struct aw_container *aw_cfg, 872 unsigned int *count) 873 { 874 int ret; 875 876 ret = aw_get_dde_type_info(aw_dev, aw_cfg); 877 if (ret < 0) 878 return ret; 879 880 switch (aw_dev->prof_info.prof_type) { 881 case AW88395_DEV_TYPE_ID: 882 ret = aw_get_dev_scene_count_v1(aw_dev, aw_cfg, count); 883 break; 884 case AW88395_DEV_DEFAULT_TYPE_ID: 885 ret = aw_get_default_scene_count_v1(aw_dev, aw_cfg, count); 886 break; 887 default: 888 dev_err(aw_dev->dev, "unsupported prof_type[%x]", aw_dev->prof_info.prof_type); 889 ret = -EINVAL; 890 break; 891 } 892 893 return ret; 894 } 895 896 static int aw_dev_parse_data_by_sec_type_v1(struct aw_device *aw_dev, 897 struct aw_cfg_hdr *prof_hdr, 898 struct aw_cfg_dde_v1 *cfg_dde, 899 int *cur_scene_id) 900 { 901 struct aw_prof_info *prof_info = &aw_dev->prof_info; 902 int ret; 903 904 switch (cfg_dde->data_type) { 905 case ACF_SEC_TYPE_MULTIPLE_BIN: 906 ret = aw_dev_prof_parse_multi_bin(aw_dev, (u8 *)prof_hdr + cfg_dde->data_offset, 907 cfg_dde->data_size, &prof_info->prof_desc[*cur_scene_id]); 908 if (ret < 0) { 909 dev_err(aw_dev->dev, "parse multi bin failed"); 910 return ret; 911 } 912 prof_info->prof_desc[*cur_scene_id].prf_str = cfg_dde->dev_profile_str; 913 prof_info->prof_desc[*cur_scene_id].id = cfg_dde->dev_profile; 914 (*cur_scene_id)++; 915 break; 916 case ACF_SEC_TYPE_HDR_REG: 917 ret = aw_dev_parse_reg_bin_with_hdr(aw_dev, 918 (uint8_t *)prof_hdr + cfg_dde->data_offset, 919 cfg_dde->data_size, &prof_info->prof_desc[*cur_scene_id]); 920 if (ret < 0) { 921 dev_err(aw_dev->dev, "parse reg bin with hdr failed"); 922 return ret; 923 } 924 prof_info->prof_desc[*cur_scene_id].prf_str = cfg_dde->dev_profile_str; 925 prof_info->prof_desc[*cur_scene_id].id = cfg_dde->dev_profile; 926 (*cur_scene_id)++; 927 break; 928 default: 929 dev_err(aw_dev->dev, "unsupported SEC_TYPE [%d]", cfg_dde->data_type); 930 return -EINVAL; 931 } 932 933 return 0; 934 } 935 936 static int aw_dev_parse_dev_type_v1(struct aw_device *aw_dev, 937 struct aw_cfg_hdr *prof_hdr) 938 { 939 struct aw_cfg_dde_v1 *cfg_dde = 940 (struct aw_cfg_dde_v1 *)((char *)prof_hdr + prof_hdr->hdr_offset); 941 int cur_scene_id = 0; 942 unsigned int i; 943 int ret; 944 945 for (i = 0; i < prof_hdr->ddt_num; i++) { 946 if ((aw_dev->i2c->adapter->nr == cfg_dde[i].dev_bus) && 947 (aw_dev->i2c->addr == cfg_dde[i].dev_addr) && 948 (aw_dev->chip_id == cfg_dde[i].chip_id)) { 949 ret = aw_dev_parse_data_by_sec_type_v1(aw_dev, prof_hdr, 950 &cfg_dde[i], &cur_scene_id); 951 if (ret < 0) { 952 dev_err(aw_dev->dev, "parse failed"); 953 return ret; 954 } 955 } 956 } 957 958 if (cur_scene_id == 0) { 959 dev_err(aw_dev->dev, "get dev type failed, get num [%d]", cur_scene_id); 960 return -EINVAL; 961 } 962 963 return 0; 964 } 965 966 static int aw_dev_parse_default_type_v1(struct aw_device *aw_dev, 967 struct aw_cfg_hdr *prof_hdr) 968 { 969 struct aw_cfg_dde_v1 *cfg_dde = 970 (struct aw_cfg_dde_v1 *)((char *)prof_hdr + prof_hdr->hdr_offset); 971 int cur_scene_id = 0; 972 unsigned int i; 973 int ret; 974 975 for (i = 0; i < prof_hdr->ddt_num; i++) { 976 if ((aw_dev->channel == cfg_dde[i].dev_index) && 977 (aw_dev->chip_id == cfg_dde[i].chip_id)) { 978 ret = aw_dev_parse_data_by_sec_type_v1(aw_dev, prof_hdr, 979 &cfg_dde[i], &cur_scene_id); 980 if (ret < 0) { 981 dev_err(aw_dev->dev, "parse failed"); 982 return ret; 983 } 984 } 985 } 986 987 if (cur_scene_id == 0) { 988 dev_err(aw_dev->dev, "get dev default type failed, get num[%d]", cur_scene_id); 989 return -EINVAL; 990 } 991 992 return 0; 993 } 994 995 static int aw_dev_parse_by_hdr_v1(struct aw_device *aw_dev, 996 struct aw_cfg_hdr *cfg_hdr) 997 { 998 int ret; 999 1000 switch (aw_dev->prof_info.prof_type) { 1001 case AW88395_DEV_TYPE_ID: 1002 ret = aw_dev_parse_dev_type_v1(aw_dev, cfg_hdr); 1003 break; 1004 case AW88395_DEV_DEFAULT_TYPE_ID: 1005 ret = aw_dev_parse_default_type_v1(aw_dev, cfg_hdr); 1006 break; 1007 default: 1008 dev_err(aw_dev->dev, "prof type matched failed, get num[%d]", 1009 aw_dev->prof_info.prof_type); 1010 ret = -EINVAL; 1011 break; 1012 } 1013 1014 return ret; 1015 } 1016 1017 static int aw_dev_load_cfg_by_hdr_v1(struct aw_device *aw_dev, 1018 struct aw_container *aw_cfg) 1019 { 1020 struct aw_cfg_hdr *cfg_hdr = (struct aw_cfg_hdr *)aw_cfg->data; 1021 struct aw_prof_info *prof_info = &aw_dev->prof_info; 1022 int ret; 1023 1024 ret = aw_dev_parse_scene_count_v1(aw_dev, aw_cfg, &prof_info->count); 1025 if (ret < 0) { 1026 dev_err(aw_dev->dev, "get scene count failed"); 1027 return ret; 1028 } 1029 1030 prof_info->prof_desc = devm_kcalloc(aw_dev->dev, 1031 prof_info->count, sizeof(struct aw_prof_desc), 1032 GFP_KERNEL); 1033 if (!prof_info->prof_desc) 1034 return -ENOMEM; 1035 1036 ret = aw_dev_parse_by_hdr_v1(aw_dev, cfg_hdr); 1037 if (ret < 0) { 1038 dev_err(aw_dev->dev, "parse hdr failed"); 1039 return ret; 1040 } 1041 1042 ret = aw_dev_create_prof_name_list_v1(aw_dev); 1043 if (ret < 0) { 1044 dev_err(aw_dev->dev, "create prof name list failed"); 1045 return ret; 1046 } 1047 1048 return 0; 1049 } 1050 1051 int aw88395_dev_cfg_load(struct aw_device *aw_dev, struct aw_container *aw_cfg) 1052 { 1053 struct aw_cfg_hdr *cfg_hdr; 1054 int ret; 1055 1056 cfg_hdr = (struct aw_cfg_hdr *)aw_cfg->data; 1057 1058 switch (cfg_hdr->hdr_version) { 1059 case AW88395_CFG_HDR_VER: 1060 ret = aw_dev_load_cfg_by_hdr(aw_dev, cfg_hdr); 1061 if (ret < 0) { 1062 dev_err(aw_dev->dev, "hdr_version[0x%x] parse failed", 1063 cfg_hdr->hdr_version); 1064 return ret; 1065 } 1066 break; 1067 case AW88395_CFG_HDR_VER_V1: 1068 ret = aw_dev_load_cfg_by_hdr_v1(aw_dev, aw_cfg); 1069 if (ret < 0) { 1070 dev_err(aw_dev->dev, "hdr_version[0x%x] parse failed", 1071 cfg_hdr->hdr_version); 1072 return ret; 1073 } 1074 break; 1075 default: 1076 dev_err(aw_dev->dev, "unsupported hdr_version [0x%x]", cfg_hdr->hdr_version); 1077 return -EINVAL; 1078 } 1079 aw_dev->fw_status = AW88395_DEV_FW_OK; 1080 1081 return 0; 1082 } 1083 EXPORT_SYMBOL_GPL(aw88395_dev_cfg_load); 1084 1085 static int aw_dev_check_cfg_by_hdr(struct aw_device *aw_dev, struct aw_container *aw_cfg) 1086 { 1087 unsigned int end_data_offset; 1088 struct aw_cfg_hdr *cfg_hdr; 1089 struct aw_cfg_dde *cfg_dde; 1090 unsigned int act_data = 0; 1091 unsigned int hdr_ddt_len; 1092 unsigned int i; 1093 u8 act_crc8; 1094 1095 cfg_hdr = (struct aw_cfg_hdr *)aw_cfg->data; 1096 /* check file type id is awinic acf file */ 1097 if (cfg_hdr->id != ACF_FILE_ID) { 1098 dev_err(aw_dev->dev, "not acf type file"); 1099 return -EINVAL; 1100 } 1101 1102 hdr_ddt_len = cfg_hdr->hdr_offset + cfg_hdr->ddt_size; 1103 if (hdr_ddt_len > aw_cfg->len) { 1104 dev_err(aw_dev->dev, "hdr_len with ddt_len [%d] overflow file size[%d]", 1105 cfg_hdr->hdr_offset, aw_cfg->len); 1106 return -EINVAL; 1107 } 1108 1109 /* check data size */ 1110 cfg_dde = (struct aw_cfg_dde *)((char *)aw_cfg->data + cfg_hdr->hdr_offset); 1111 act_data += hdr_ddt_len; 1112 for (i = 0; i < cfg_hdr->ddt_num; i++) 1113 act_data += cfg_dde[i].data_size; 1114 1115 if (act_data != aw_cfg->len) { 1116 dev_err(aw_dev->dev, "act_data[%d] not equal to file size[%d]!", 1117 act_data, aw_cfg->len); 1118 return -EINVAL; 1119 } 1120 1121 for (i = 0; i < cfg_hdr->ddt_num; i++) { 1122 /* data check */ 1123 end_data_offset = cfg_dde[i].data_offset + cfg_dde[i].data_size; 1124 if (end_data_offset > aw_cfg->len) { 1125 dev_err(aw_dev->dev, "ddt_num[%d] end_data_offset[%d] overflow size[%d]", 1126 i, end_data_offset, aw_cfg->len); 1127 return -EINVAL; 1128 } 1129 1130 /* crc check */ 1131 act_crc8 = crc8(aw_crc8_table, aw_cfg->data + cfg_dde[i].data_offset, 1132 cfg_dde[i].data_size, 0); 1133 if (act_crc8 != cfg_dde[i].data_crc) { 1134 dev_err(aw_dev->dev, "ddt_num[%d] act_crc8:0x%x != data_crc:0x%x", 1135 i, (u32)act_crc8, cfg_dde[i].data_crc); 1136 return -EINVAL; 1137 } 1138 } 1139 1140 return 0; 1141 } 1142 1143 static int aw_dev_check_acf_by_hdr_v1(struct aw_device *aw_dev, struct aw_container *aw_cfg) 1144 { 1145 struct aw_cfg_dde_v1 *cfg_dde; 1146 unsigned int end_data_offset; 1147 struct aw_cfg_hdr *cfg_hdr; 1148 unsigned int act_data = 0; 1149 unsigned int hdr_ddt_len; 1150 u8 act_crc8; 1151 int i; 1152 1153 cfg_hdr = (struct aw_cfg_hdr *)aw_cfg->data; 1154 1155 /* check file type id is awinic acf file */ 1156 if (cfg_hdr->id != ACF_FILE_ID) { 1157 dev_err(aw_dev->dev, "not acf type file"); 1158 return -EINVAL; 1159 } 1160 1161 hdr_ddt_len = cfg_hdr->hdr_offset + cfg_hdr->ddt_size; 1162 if (hdr_ddt_len > aw_cfg->len) { 1163 dev_err(aw_dev->dev, "hdrlen with ddt_len [%d] overflow file size[%d]", 1164 cfg_hdr->hdr_offset, aw_cfg->len); 1165 return -EINVAL; 1166 } 1167 1168 /* check data size */ 1169 cfg_dde = (struct aw_cfg_dde_v1 *)((char *)aw_cfg->data + cfg_hdr->hdr_offset); 1170 act_data += hdr_ddt_len; 1171 for (i = 0; i < cfg_hdr->ddt_num; i++) 1172 act_data += cfg_dde[i].data_size; 1173 1174 if (act_data != aw_cfg->len) { 1175 dev_err(aw_dev->dev, "act_data[%d] not equal to file size[%d]!", 1176 act_data, aw_cfg->len); 1177 return -EINVAL; 1178 } 1179 1180 for (i = 0; i < cfg_hdr->ddt_num; i++) { 1181 /* data check */ 1182 end_data_offset = cfg_dde[i].data_offset + cfg_dde[i].data_size; 1183 if (end_data_offset > aw_cfg->len) { 1184 dev_err(aw_dev->dev, "ddt_num[%d] end_data_offset[%d] overflow size[%d]", 1185 i, end_data_offset, aw_cfg->len); 1186 return -EINVAL; 1187 } 1188 1189 /* crc check */ 1190 act_crc8 = crc8(aw_crc8_table, aw_cfg->data + cfg_dde[i].data_offset, 1191 cfg_dde[i].data_size, 0); 1192 if (act_crc8 != cfg_dde[i].data_crc) { 1193 dev_err(aw_dev->dev, "ddt_num[%d] act_crc8:0x%x != data_crc 0x%x", 1194 i, (u32)act_crc8, cfg_dde[i].data_crc); 1195 return -EINVAL; 1196 } 1197 } 1198 1199 return 0; 1200 } 1201 1202 int aw88395_dev_load_acf_check(struct aw_device *aw_dev, struct aw_container *aw_cfg) 1203 { 1204 struct aw_cfg_hdr *cfg_hdr; 1205 1206 if (!aw_cfg) { 1207 dev_err(aw_dev->dev, "aw_prof is NULL"); 1208 return -EINVAL; 1209 } 1210 1211 if (aw_cfg->len < sizeof(struct aw_cfg_hdr)) { 1212 dev_err(aw_dev->dev, "cfg hdr size[%d] overflow file size[%d]", 1213 aw_cfg->len, (int)sizeof(struct aw_cfg_hdr)); 1214 return -EINVAL; 1215 } 1216 1217 crc8_populate_lsb(aw_crc8_table, AW88395_CRC8_POLYNOMIAL); 1218 1219 cfg_hdr = (struct aw_cfg_hdr *)aw_cfg->data; 1220 switch (cfg_hdr->hdr_version) { 1221 case AW88395_CFG_HDR_VER: 1222 return aw_dev_check_cfg_by_hdr(aw_dev, aw_cfg); 1223 case AW88395_CFG_HDR_VER_V1: 1224 return aw_dev_check_acf_by_hdr_v1(aw_dev, aw_cfg); 1225 default: 1226 dev_err(aw_dev->dev, "unsupported hdr_version [0x%x]", cfg_hdr->hdr_version); 1227 return -EINVAL; 1228 } 1229 1230 return 0; 1231 } 1232 EXPORT_SYMBOL_GPL(aw88395_dev_load_acf_check); 1233 1234 MODULE_DESCRIPTION("AW88395 ACF File Parsing Lib"); 1235 MODULE_LICENSE("GPL v2"); 1236