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 ret = aw88395_dev_cfg_get_valid_prof(aw_dev, all_prof_info); 709 if (ret < 0) 710 goto exit; 711 break; 712 case AW88261_CHIP_ID: 713 case AW87390_CHIP_ID: 714 ret = aw88261_dev_cfg_get_valid_prof(aw_dev, all_prof_info); 715 if (ret < 0) 716 goto exit; 717 break; 718 default: 719 dev_err(aw_dev->dev, "valid prof unsupported"); 720 ret = -EINVAL; 721 break; 722 } 723 724 aw_dev->prof_info.prof_name_list = profile_name; 725 726 exit: 727 devm_kfree(aw_dev->dev, all_prof_info); 728 return ret; 729 } 730 731 static int aw_dev_create_prof_name_list_v1(struct aw_device *aw_dev) 732 { 733 struct aw_prof_info *prof_info = &aw_dev->prof_info; 734 struct aw_prof_desc *prof_desc = prof_info->prof_desc; 735 int i; 736 737 if (!prof_desc) { 738 dev_err(aw_dev->dev, "prof_desc is NULL"); 739 return -EINVAL; 740 } 741 742 prof_info->prof_name_list = devm_kzalloc(aw_dev->dev, 743 prof_info->count * PROFILE_STR_MAX, 744 GFP_KERNEL); 745 if (!prof_info->prof_name_list) 746 return -ENOMEM; 747 748 for (i = 0; i < prof_info->count; i++) { 749 prof_desc[i].id = i; 750 prof_info->prof_name_list[i] = prof_desc[i].prf_str; 751 dev_dbg(aw_dev->dev, "prof name is %s", prof_info->prof_name_list[i]); 752 } 753 754 return 0; 755 } 756 757 static int aw_get_dde_type_info(struct aw_device *aw_dev, struct aw_container *aw_cfg) 758 { 759 struct aw_cfg_hdr *cfg_hdr = (struct aw_cfg_hdr *)aw_cfg->data; 760 struct aw_cfg_dde_v1 *cfg_dde = 761 (struct aw_cfg_dde_v1 *)(aw_cfg->data + cfg_hdr->hdr_offset); 762 int default_num = 0; 763 int dev_num = 0; 764 unsigned int i; 765 766 for (i = 0; i < cfg_hdr->ddt_num; i++) { 767 if (cfg_dde[i].type == AW88395_DEV_TYPE_ID) 768 dev_num++; 769 770 if (cfg_dde[i].type == AW88395_DEV_DEFAULT_TYPE_ID) 771 default_num++; 772 } 773 774 if (dev_num != 0) { 775 aw_dev->prof_info.prof_type = AW88395_DEV_TYPE_ID; 776 } else if (default_num != 0) { 777 aw_dev->prof_info.prof_type = AW88395_DEV_DEFAULT_TYPE_ID; 778 } else { 779 dev_err(aw_dev->dev, "can't find scene"); 780 return -EINVAL; 781 } 782 783 return 0; 784 } 785 786 static int aw_get_dev_scene_count_v1(struct aw_device *aw_dev, struct aw_container *aw_cfg, 787 unsigned int *scene_num) 788 { 789 struct aw_cfg_hdr *cfg_hdr = (struct aw_cfg_hdr *)aw_cfg->data; 790 struct aw_cfg_dde_v1 *cfg_dde = 791 (struct aw_cfg_dde_v1 *)(aw_cfg->data + cfg_hdr->hdr_offset); 792 unsigned int i; 793 int ret; 794 795 switch (aw_dev->chip_id) { 796 case AW88395_CHIP_ID: 797 for (i = 0; i < cfg_hdr->ddt_num; ++i) { 798 if ((cfg_dde[i].data_type == ACF_SEC_TYPE_MULTIPLE_BIN) && 799 (aw_dev->chip_id == cfg_dde[i].chip_id) && 800 (aw_dev->i2c->adapter->nr == cfg_dde[i].dev_bus) && 801 (aw_dev->i2c->addr == cfg_dde[i].dev_addr)) 802 (*scene_num)++; 803 } 804 ret = 0; 805 break; 806 case AW88261_CHIP_ID: 807 case AW87390_CHIP_ID: 808 for (i = 0; i < cfg_hdr->ddt_num; ++i) { 809 if (((cfg_dde[i].data_type == ACF_SEC_TYPE_REG) || 810 (cfg_dde[i].data_type == ACF_SEC_TYPE_HDR_REG)) && 811 (aw_dev->chip_id == cfg_dde[i].chip_id) && 812 (aw_dev->i2c->adapter->nr == cfg_dde[i].dev_bus) && 813 (aw_dev->i2c->addr == cfg_dde[i].dev_addr)) 814 (*scene_num)++; 815 } 816 ret = 0; 817 break; 818 default: 819 dev_err(aw_dev->dev, "unsupported device"); 820 ret = -EINVAL; 821 break; 822 } 823 824 return ret; 825 } 826 827 static int aw_get_default_scene_count_v1(struct aw_device *aw_dev, 828 struct aw_container *aw_cfg, 829 unsigned int *scene_num) 830 { 831 struct aw_cfg_hdr *cfg_hdr = (struct aw_cfg_hdr *)aw_cfg->data; 832 struct aw_cfg_dde_v1 *cfg_dde = 833 (struct aw_cfg_dde_v1 *)(aw_cfg->data + cfg_hdr->hdr_offset); 834 unsigned int i; 835 int ret; 836 837 switch (aw_dev->chip_id) { 838 case AW88395_CHIP_ID: 839 for (i = 0; i < cfg_hdr->ddt_num; ++i) { 840 if ((cfg_dde[i].data_type == ACF_SEC_TYPE_MULTIPLE_BIN) && 841 (aw_dev->chip_id == cfg_dde[i].chip_id) && 842 (aw_dev->channel == cfg_dde[i].dev_index)) 843 (*scene_num)++; 844 } 845 ret = 0; 846 break; 847 case AW88261_CHIP_ID: 848 case AW87390_CHIP_ID: 849 for (i = 0; i < cfg_hdr->ddt_num; ++i) { 850 if (((cfg_dde[i].data_type == ACF_SEC_TYPE_REG) || 851 (cfg_dde[i].data_type == ACF_SEC_TYPE_HDR_REG)) && 852 (aw_dev->chip_id == cfg_dde[i].chip_id) && 853 (aw_dev->channel == cfg_dde[i].dev_index)) 854 (*scene_num)++; 855 } 856 ret = 0; 857 break; 858 default: 859 dev_err(aw_dev->dev, "unsupported device"); 860 ret = -EINVAL; 861 break; 862 } 863 864 return ret; 865 } 866 867 static int aw_dev_parse_scene_count_v1(struct aw_device *aw_dev, 868 struct aw_container *aw_cfg, 869 unsigned int *count) 870 { 871 int ret; 872 873 ret = aw_get_dde_type_info(aw_dev, aw_cfg); 874 if (ret < 0) 875 return ret; 876 877 switch (aw_dev->prof_info.prof_type) { 878 case AW88395_DEV_TYPE_ID: 879 ret = aw_get_dev_scene_count_v1(aw_dev, aw_cfg, count); 880 break; 881 case AW88395_DEV_DEFAULT_TYPE_ID: 882 ret = aw_get_default_scene_count_v1(aw_dev, aw_cfg, count); 883 break; 884 default: 885 dev_err(aw_dev->dev, "unsupported prof_type[%x]", aw_dev->prof_info.prof_type); 886 ret = -EINVAL; 887 break; 888 } 889 890 return ret; 891 } 892 893 static int aw_dev_parse_data_by_sec_type_v1(struct aw_device *aw_dev, 894 struct aw_cfg_hdr *prof_hdr, 895 struct aw_cfg_dde_v1 *cfg_dde, 896 int *cur_scene_id) 897 { 898 struct aw_prof_info *prof_info = &aw_dev->prof_info; 899 int ret; 900 901 switch (cfg_dde->data_type) { 902 case ACF_SEC_TYPE_MULTIPLE_BIN: 903 ret = aw_dev_prof_parse_multi_bin(aw_dev, (u8 *)prof_hdr + cfg_dde->data_offset, 904 cfg_dde->data_size, &prof_info->prof_desc[*cur_scene_id]); 905 if (ret < 0) { 906 dev_err(aw_dev->dev, "parse multi bin failed"); 907 return ret; 908 } 909 prof_info->prof_desc[*cur_scene_id].prf_str = cfg_dde->dev_profile_str; 910 prof_info->prof_desc[*cur_scene_id].id = cfg_dde->dev_profile; 911 (*cur_scene_id)++; 912 break; 913 case ACF_SEC_TYPE_HDR_REG: 914 ret = aw_dev_parse_reg_bin_with_hdr(aw_dev, 915 (uint8_t *)prof_hdr + cfg_dde->data_offset, 916 cfg_dde->data_size, &prof_info->prof_desc[*cur_scene_id]); 917 if (ret < 0) { 918 dev_err(aw_dev->dev, "parse reg bin with hdr failed"); 919 return ret; 920 } 921 prof_info->prof_desc[*cur_scene_id].prf_str = cfg_dde->dev_profile_str; 922 prof_info->prof_desc[*cur_scene_id].id = cfg_dde->dev_profile; 923 (*cur_scene_id)++; 924 break; 925 default: 926 dev_err(aw_dev->dev, "unsupported SEC_TYPE [%d]", cfg_dde->data_type); 927 return -EINVAL; 928 } 929 930 return 0; 931 } 932 933 static int aw_dev_parse_dev_type_v1(struct aw_device *aw_dev, 934 struct aw_cfg_hdr *prof_hdr) 935 { 936 struct aw_cfg_dde_v1 *cfg_dde = 937 (struct aw_cfg_dde_v1 *)((char *)prof_hdr + prof_hdr->hdr_offset); 938 int cur_scene_id = 0; 939 unsigned int i; 940 int ret; 941 942 for (i = 0; i < prof_hdr->ddt_num; i++) { 943 if ((aw_dev->i2c->adapter->nr == cfg_dde[i].dev_bus) && 944 (aw_dev->i2c->addr == cfg_dde[i].dev_addr) && 945 (aw_dev->chip_id == cfg_dde[i].chip_id)) { 946 ret = aw_dev_parse_data_by_sec_type_v1(aw_dev, prof_hdr, 947 &cfg_dde[i], &cur_scene_id); 948 if (ret < 0) { 949 dev_err(aw_dev->dev, "parse failed"); 950 return ret; 951 } 952 } 953 } 954 955 if (cur_scene_id == 0) { 956 dev_err(aw_dev->dev, "get dev type failed, get num [%d]", cur_scene_id); 957 return -EINVAL; 958 } 959 960 return 0; 961 } 962 963 static int aw_dev_parse_default_type_v1(struct aw_device *aw_dev, 964 struct aw_cfg_hdr *prof_hdr) 965 { 966 struct aw_cfg_dde_v1 *cfg_dde = 967 (struct aw_cfg_dde_v1 *)((char *)prof_hdr + prof_hdr->hdr_offset); 968 int cur_scene_id = 0; 969 unsigned int i; 970 int ret; 971 972 for (i = 0; i < prof_hdr->ddt_num; i++) { 973 if ((aw_dev->channel == cfg_dde[i].dev_index) && 974 (aw_dev->chip_id == cfg_dde[i].chip_id)) { 975 ret = aw_dev_parse_data_by_sec_type_v1(aw_dev, prof_hdr, 976 &cfg_dde[i], &cur_scene_id); 977 if (ret < 0) { 978 dev_err(aw_dev->dev, "parse failed"); 979 return ret; 980 } 981 } 982 } 983 984 if (cur_scene_id == 0) { 985 dev_err(aw_dev->dev, "get dev default type failed, get num[%d]", cur_scene_id); 986 return -EINVAL; 987 } 988 989 return 0; 990 } 991 992 static int aw_dev_parse_by_hdr_v1(struct aw_device *aw_dev, 993 struct aw_cfg_hdr *cfg_hdr) 994 { 995 int ret; 996 997 switch (aw_dev->prof_info.prof_type) { 998 case AW88395_DEV_TYPE_ID: 999 ret = aw_dev_parse_dev_type_v1(aw_dev, cfg_hdr); 1000 break; 1001 case AW88395_DEV_DEFAULT_TYPE_ID: 1002 ret = aw_dev_parse_default_type_v1(aw_dev, cfg_hdr); 1003 break; 1004 default: 1005 dev_err(aw_dev->dev, "prof type matched failed, get num[%d]", 1006 aw_dev->prof_info.prof_type); 1007 ret = -EINVAL; 1008 break; 1009 } 1010 1011 return ret; 1012 } 1013 1014 static int aw_dev_load_cfg_by_hdr_v1(struct aw_device *aw_dev, 1015 struct aw_container *aw_cfg) 1016 { 1017 struct aw_cfg_hdr *cfg_hdr = (struct aw_cfg_hdr *)aw_cfg->data; 1018 struct aw_prof_info *prof_info = &aw_dev->prof_info; 1019 int ret; 1020 1021 ret = aw_dev_parse_scene_count_v1(aw_dev, aw_cfg, &prof_info->count); 1022 if (ret < 0) { 1023 dev_err(aw_dev->dev, "get scene count failed"); 1024 return ret; 1025 } 1026 1027 prof_info->prof_desc = devm_kcalloc(aw_dev->dev, 1028 prof_info->count, sizeof(struct aw_prof_desc), 1029 GFP_KERNEL); 1030 if (!prof_info->prof_desc) 1031 return -ENOMEM; 1032 1033 ret = aw_dev_parse_by_hdr_v1(aw_dev, cfg_hdr); 1034 if (ret < 0) { 1035 dev_err(aw_dev->dev, "parse hdr failed"); 1036 return ret; 1037 } 1038 1039 ret = aw_dev_create_prof_name_list_v1(aw_dev); 1040 if (ret < 0) { 1041 dev_err(aw_dev->dev, "create prof name list failed"); 1042 return ret; 1043 } 1044 1045 return 0; 1046 } 1047 1048 int aw88395_dev_cfg_load(struct aw_device *aw_dev, struct aw_container *aw_cfg) 1049 { 1050 struct aw_cfg_hdr *cfg_hdr; 1051 int ret; 1052 1053 cfg_hdr = (struct aw_cfg_hdr *)aw_cfg->data; 1054 1055 switch (cfg_hdr->hdr_version) { 1056 case AW88395_CFG_HDR_VER: 1057 ret = aw_dev_load_cfg_by_hdr(aw_dev, cfg_hdr); 1058 if (ret < 0) { 1059 dev_err(aw_dev->dev, "hdr_version[0x%x] parse failed", 1060 cfg_hdr->hdr_version); 1061 return ret; 1062 } 1063 break; 1064 case AW88395_CFG_HDR_VER_V1: 1065 ret = aw_dev_load_cfg_by_hdr_v1(aw_dev, aw_cfg); 1066 if (ret < 0) { 1067 dev_err(aw_dev->dev, "hdr_version[0x%x] parse failed", 1068 cfg_hdr->hdr_version); 1069 return ret; 1070 } 1071 break; 1072 default: 1073 dev_err(aw_dev->dev, "unsupported hdr_version [0x%x]", cfg_hdr->hdr_version); 1074 return -EINVAL; 1075 } 1076 aw_dev->fw_status = AW88395_DEV_FW_OK; 1077 1078 return 0; 1079 } 1080 EXPORT_SYMBOL_GPL(aw88395_dev_cfg_load); 1081 1082 static int aw_dev_check_cfg_by_hdr(struct aw_device *aw_dev, struct aw_container *aw_cfg) 1083 { 1084 unsigned int end_data_offset; 1085 struct aw_cfg_hdr *cfg_hdr; 1086 struct aw_cfg_dde *cfg_dde; 1087 unsigned int act_data = 0; 1088 unsigned int hdr_ddt_len; 1089 unsigned int i; 1090 u8 act_crc8; 1091 1092 cfg_hdr = (struct aw_cfg_hdr *)aw_cfg->data; 1093 /* check file type id is awinic acf file */ 1094 if (cfg_hdr->id != ACF_FILE_ID) { 1095 dev_err(aw_dev->dev, "not acf type file"); 1096 return -EINVAL; 1097 } 1098 1099 hdr_ddt_len = cfg_hdr->hdr_offset + cfg_hdr->ddt_size; 1100 if (hdr_ddt_len > aw_cfg->len) { 1101 dev_err(aw_dev->dev, "hdr_len with ddt_len [%d] overflow file size[%d]", 1102 cfg_hdr->hdr_offset, aw_cfg->len); 1103 return -EINVAL; 1104 } 1105 1106 /* check data size */ 1107 cfg_dde = (struct aw_cfg_dde *)((char *)aw_cfg->data + cfg_hdr->hdr_offset); 1108 act_data += hdr_ddt_len; 1109 for (i = 0; i < cfg_hdr->ddt_num; i++) 1110 act_data += cfg_dde[i].data_size; 1111 1112 if (act_data != aw_cfg->len) { 1113 dev_err(aw_dev->dev, "act_data[%d] not equal to file size[%d]!", 1114 act_data, aw_cfg->len); 1115 return -EINVAL; 1116 } 1117 1118 for (i = 0; i < cfg_hdr->ddt_num; i++) { 1119 /* data check */ 1120 end_data_offset = cfg_dde[i].data_offset + cfg_dde[i].data_size; 1121 if (end_data_offset > aw_cfg->len) { 1122 dev_err(aw_dev->dev, "ddt_num[%d] end_data_offset[%d] overflow size[%d]", 1123 i, end_data_offset, aw_cfg->len); 1124 return -EINVAL; 1125 } 1126 1127 /* crc check */ 1128 act_crc8 = crc8(aw_crc8_table, aw_cfg->data + cfg_dde[i].data_offset, 1129 cfg_dde[i].data_size, 0); 1130 if (act_crc8 != cfg_dde[i].data_crc) { 1131 dev_err(aw_dev->dev, "ddt_num[%d] act_crc8:0x%x != data_crc:0x%x", 1132 i, (u32)act_crc8, cfg_dde[i].data_crc); 1133 return -EINVAL; 1134 } 1135 } 1136 1137 return 0; 1138 } 1139 1140 static int aw_dev_check_acf_by_hdr_v1(struct aw_device *aw_dev, struct aw_container *aw_cfg) 1141 { 1142 struct aw_cfg_dde_v1 *cfg_dde; 1143 unsigned int end_data_offset; 1144 struct aw_cfg_hdr *cfg_hdr; 1145 unsigned int act_data = 0; 1146 unsigned int hdr_ddt_len; 1147 u8 act_crc8; 1148 int i; 1149 1150 cfg_hdr = (struct aw_cfg_hdr *)aw_cfg->data; 1151 1152 /* check file type id is awinic acf file */ 1153 if (cfg_hdr->id != ACF_FILE_ID) { 1154 dev_err(aw_dev->dev, "not acf type file"); 1155 return -EINVAL; 1156 } 1157 1158 hdr_ddt_len = cfg_hdr->hdr_offset + cfg_hdr->ddt_size; 1159 if (hdr_ddt_len > aw_cfg->len) { 1160 dev_err(aw_dev->dev, "hdrlen with ddt_len [%d] overflow file size[%d]", 1161 cfg_hdr->hdr_offset, aw_cfg->len); 1162 return -EINVAL; 1163 } 1164 1165 /* check data size */ 1166 cfg_dde = (struct aw_cfg_dde_v1 *)((char *)aw_cfg->data + cfg_hdr->hdr_offset); 1167 act_data += hdr_ddt_len; 1168 for (i = 0; i < cfg_hdr->ddt_num; i++) 1169 act_data += cfg_dde[i].data_size; 1170 1171 if (act_data != aw_cfg->len) { 1172 dev_err(aw_dev->dev, "act_data[%d] not equal to file size[%d]!", 1173 act_data, aw_cfg->len); 1174 return -EINVAL; 1175 } 1176 1177 for (i = 0; i < cfg_hdr->ddt_num; i++) { 1178 /* data check */ 1179 end_data_offset = cfg_dde[i].data_offset + cfg_dde[i].data_size; 1180 if (end_data_offset > aw_cfg->len) { 1181 dev_err(aw_dev->dev, "ddt_num[%d] end_data_offset[%d] overflow size[%d]", 1182 i, end_data_offset, aw_cfg->len); 1183 return -EINVAL; 1184 } 1185 1186 /* crc check */ 1187 act_crc8 = crc8(aw_crc8_table, aw_cfg->data + cfg_dde[i].data_offset, 1188 cfg_dde[i].data_size, 0); 1189 if (act_crc8 != cfg_dde[i].data_crc) { 1190 dev_err(aw_dev->dev, "ddt_num[%d] act_crc8:0x%x != data_crc 0x%x", 1191 i, (u32)act_crc8, cfg_dde[i].data_crc); 1192 return -EINVAL; 1193 } 1194 } 1195 1196 return 0; 1197 } 1198 1199 int aw88395_dev_load_acf_check(struct aw_device *aw_dev, struct aw_container *aw_cfg) 1200 { 1201 struct aw_cfg_hdr *cfg_hdr; 1202 1203 if (!aw_cfg) { 1204 dev_err(aw_dev->dev, "aw_prof is NULL"); 1205 return -EINVAL; 1206 } 1207 1208 if (aw_cfg->len < sizeof(struct aw_cfg_hdr)) { 1209 dev_err(aw_dev->dev, "cfg hdr size[%d] overflow file size[%d]", 1210 aw_cfg->len, (int)sizeof(struct aw_cfg_hdr)); 1211 return -EINVAL; 1212 } 1213 1214 crc8_populate_lsb(aw_crc8_table, AW88395_CRC8_POLYNOMIAL); 1215 1216 cfg_hdr = (struct aw_cfg_hdr *)aw_cfg->data; 1217 switch (cfg_hdr->hdr_version) { 1218 case AW88395_CFG_HDR_VER: 1219 return aw_dev_check_cfg_by_hdr(aw_dev, aw_cfg); 1220 case AW88395_CFG_HDR_VER_V1: 1221 return aw_dev_check_acf_by_hdr_v1(aw_dev, aw_cfg); 1222 default: 1223 dev_err(aw_dev->dev, "unsupported hdr_version [0x%x]", cfg_hdr->hdr_version); 1224 return -EINVAL; 1225 } 1226 1227 return 0; 1228 } 1229 EXPORT_SYMBOL_GPL(aw88395_dev_load_acf_check); 1230 1231 MODULE_DESCRIPTION("AW88395 ACF File Parsing Lib"); 1232 MODULE_LICENSE("GPL v2"); 1233