Lines Matching refs:offset
84 unsigned char offset;
192 /* convert data[offset], data[offset + 1], data[offset + 2] and
193 * data[offset + 3] into host
281 int offset = 0;
296 fw_hdr->img_sz = get_unaligned_be32(&buf[offset]);
297 offset += 4;
307 fw_hdr->checksum = get_unaligned_be32(&buf[offset]);
308 offset += 4;
309 fw_hdr->binary_version_num = get_unaligned_be32(&buf[offset]);
317 offset += 4;
318 fw_hdr->drv_fw_version = get_unaligned_be32(&buf[offset]);
319 offset += 8;
320 fw_hdr->plat_type = buf[offset];
321 offset += 1;
322 fw_hdr->dev_family = buf[offset];
323 offset += 1;
324 fw_hdr->reserve = buf[offset];
325 offset += 1;
326 fw_hdr->ndev = buf[offset];
327 offset += 1;
336 if (offset + TASDEVICE_DEVICE_SUM > fw_hdr->img_sz) {
343 for (i = 0; i < TASDEVICE_DEVICE_SUM; i++, offset++)
344 fw_hdr->devs[i] = buf[offset];
346 fw_hdr->nconfig = get_unaligned_be32(&buf[offset]);
347 offset += 4;
350 fw_hdr->config_size[i] = get_unaligned_be32(&buf[offset]);
351 offset += 4;
355 if (fw_hdr->img_sz - total_config_sz != (unsigned int)offset) {
372 cfg_info[i] = tasdevice_add_config(tas_priv, &buf[offset],
378 offset += (int)fw_hdr->config_size[i];
417 struct tasdev_blk *block, const struct firmware *fmw, int offset)
421 if (offset + 16 > fmw->size) {
423 offset = -EINVAL;
427 /* convert data[offset], data[offset + 1], data[offset + 2] and
428 * data[offset + 3] into host
430 block->type = get_unaligned_be32(&data[offset]);
431 offset += 4;
433 block->is_pchksum_present = data[offset];
434 offset++;
436 block->pchksum = data[offset];
437 offset++;
439 block->is_ychksum_present = data[offset];
440 offset++;
442 block->ychksum = data[offset];
443 offset++;
445 block->blk_size = get_unaligned_be32(&data[offset]);
446 offset += 4;
448 block->nr_subblocks = get_unaligned_be32(&data[offset]);
449 offset += 4;
459 if (offset + block->blk_size > fmw->size) {
461 offset = -EINVAL;
465 block->data = kmemdup(&data[offset], block->blk_size, GFP_KERNEL);
467 offset = -ENOMEM;
470 offset += block->blk_size;
473 return offset;
478 int offset)
484 if (offset + 4 > fmw->size) {
486 offset = -EINVAL;
489 img_data->nr_blk = get_unaligned_be32(&data[offset]);
490 offset += 4;
495 offset = -ENOMEM;
501 offset = fw_parse_block_data_kernel(tas_fmw, blk, fmw, offset);
502 if (offset < 0) {
503 offset = -EINVAL;
509 return offset;
514 const struct firmware *fmw, int offset)
521 if (offset + 72 > fmw->size) {
523 offset = -EINVAL;
527 offset += 72;
529 offset = fw_parse_data_kernel(tas_fmw, &(program->dev_data),
530 fmw, offset);
531 if (offset < 0)
536 return offset;
541 struct tasdevice_fw *tas_fmw, const struct firmware *fmw, int offset)
549 if (offset + 80 > fmw->size) {
551 offset = -EINVAL;
554 memcpy(config->name, &data[offset], 64);
556 offset += 80;
558 offset = fw_parse_data_kernel(tas_fmw, &(config->dev_data),
559 fmw, offset);
560 if (offset < 0)
565 return offset;
665 struct tasdevice_fw *tas_fmw, const struct firmware *fmw, int offset)
671 if (offset + 520 > fmw->size) {
677 offset += 40;
679 fct_param_address_parser(r, tas_fmw, &data[offset]);
681 offset += 480;
683 return offset;
688 int offset)
698 if (offset + 12 + 4 * TASDEVICE_MAXPROGRAM_NUM_KERNEL > fmw->size) {
700 offset = -EINVAL;
703 fw_hdr->device_family = get_unaligned_be16(&buf[offset]);
706 offset = -EINVAL;
709 offset += 2;
710 fw_hdr->device = get_unaligned_be16(&buf[offset]);
714 offset = -EINVAL;
717 offset += 2;
724 offset = -EINVAL;
728 tas_fmw->nr_programs = get_unaligned_be32(&buf[offset]);
729 offset += 4;
734 offset = -EINVAL;
741 offset = -ENOMEM;
747 program->prog_size = get_unaligned_be32(&buf[offset]);
748 offset += 4;
752 offset += 4 * (TASDEVICE_MAXPROGRAM_NUM_KERNEL - tas_fmw->nr_programs);
754 tas_fmw->nr_configurations = get_unaligned_be32(&buf[offset]);
755 offset += 4;
767 offset = -EINVAL;
771 if (offset + 4 * max_confs > fmw->size) {
773 offset = -EINVAL;
780 offset = -ENOMEM;
786 config->cfg_size = get_unaligned_be32(&buf[offset]);
787 offset += 4;
791 offset += 4 * (max_confs - tas_fmw->nr_programs);
794 return offset;
1025 const struct firmware *fmw, int offset)
1028 int len = strlen((char *)&buf[offset]);
1032 if (offset + len + 8 > fmw->size) {
1034 offset = -EINVAL;
1038 offset += len;
1040 fw_hdr->device_family = get_unaligned_be32(&buf[offset]);
1043 offset = -EINVAL;
1046 offset += 4;
1048 fw_hdr->device = get_unaligned_be32(&buf[offset]);
1052 offset = -EINVAL;
1055 offset += 4;
1059 return offset;
1063 *tas_priv, const struct firmware *fmw, int offset)
1068 offset = fw_parse_variable_hdr(tas_priv, fw_hdr, fmw, offset);
1069 if (offset < 0)
1075 offset = -EINVAL;
1079 return offset;
1083 struct tasdev_blk *block, const struct firmware *fmw, int offset)
1088 if (offset + 8 > fmw->size) {
1090 offset = -EINVAL;
1093 block->type = get_unaligned_be32(&data[offset]);
1094 offset += 4;
1097 if (offset + 8 > fmw->size) {
1099 offset = -EINVAL;
1102 block->is_pchksum_present = data[offset];
1103 offset++;
1105 block->pchksum = data[offset];
1106 offset++;
1108 block->is_ychksum_present = data[offset];
1109 offset++;
1111 block->ychksum = data[offset];
1112 offset++;
1118 block->nr_cmds = get_unaligned_be32(&data[offset]);
1119 offset += 4;
1122 if (offset + n > fmw->size) {
1124 "%s: File Size(%lu) error offset = %d n = %d\n",
1125 __func__, (unsigned long)fmw->size, offset, n);
1126 offset = -EINVAL;
1130 block->data = kmemdup(&data[offset], n, GFP_KERNEL);
1132 offset = -ENOMEM;
1135 offset += n;
1138 return offset;
1146 int offset)
1153 if (offset + 64 > fmw->size) {
1155 offset = -EINVAL;
1158 memcpy(img_data->name, &data[offset], 64);
1159 offset += 64;
1161 n = strlen((char *)&data[offset]);
1163 if (offset + n + 2 > fmw->size) {
1165 offset = -EINVAL;
1168 offset += n;
1169 img_data->nr_blk = get_unaligned_be16(&data[offset]);
1170 offset += 2;
1175 offset = -ENOMEM;
1180 offset = fw_parse_block_data(tas_fmw, blk, fmw, offset);
1181 if (offset < 0) {
1182 offset = -EINVAL;
1188 return offset;
1195 struct tasdevice_fw *tas_fmw, const struct firmware *fmw, int offset)
1201 if (offset + 2 > fmw->size) {
1203 offset = -EINVAL;
1206 tas_fmw->nr_programs = get_unaligned_be16(&buf[offset]);
1207 offset += 2;
1220 offset = -ENOMEM;
1227 if (offset + 64 > fmw->size) {
1229 offset = -EINVAL;
1232 offset += 64;
1234 n = strlen((char *)&buf[offset]);
1237 if (offset + n > fmw->size) {
1239 offset = -EINVAL;
1243 offset += n;
1245 offset = fw_parse_data(tas_fmw, &(program->dev_data), fmw,
1246 offset);
1247 if (offset < 0)
1252 return offset;
1261 const struct firmware *fmw, int offset)
1268 if (offset + 2 > fmw->size) {
1270 offset = -EINVAL;
1273 tas_fmw->nr_configurations = get_unaligned_be16(&data[offset]);
1274 offset += 2;
1284 offset = -ENOMEM;
1289 if (offset + 64 > fmw->size) {
1291 offset = -EINVAL;
1294 memcpy(config->name, &data[offset], 64);
1295 offset += 64;
1297 n = strlen((char *)&data[offset]);
1299 if (offset + n > fmw->size) {
1301 offset = -EINVAL;
1305 offset += n;
1307 offset = fw_parse_data(tas_fmw, &(config->dev_data),
1308 fmw, offset);
1309 if (offset < 0)
1314 return offset;
1329 cd->offset = reg;
1333 cd->offset = TAS2781_YRAM5_START_REG;
1349 cd->offset = reg;
1353 cd->offset = TAS2781_YRAM1_START_REG;
1394 cd->offset = reg;
1399 cd->offset = TAS2781_YRAM2_START_REG;
1475 TASDEVICE_REG(book, page, crc_data.offset),
1484 && ((i + crc_data.offset)
1486 && ((i + crc_data.offset)
1663 unsigned char offset;
1687 offset = data[2];
1692 if (offset <= 0x7F) {
1694 TASDEVICE_REG(book, page, offset),
1700 block, chn, book, page, offset,
1708 if (offset == 0x81) {
1715 if (offset == 0x85) {
1720 offset = data[2];
1722 block, chn, book, page, offset, data,
1900 struct tasdevice_fw *tas_fmw, const struct firmware *fmw, int offset)
1907 if (offset + 92 > fmw->size) {
1909 offset = -EINVAL;
1912 if (memcmp(&buf[offset], magic_number, 4)) {
1914 offset = -EINVAL;
1917 offset += 4;
1919 /* Convert data[offset], data[offset + 1], data[offset + 2] and
1920 * data[offset + 3] into host
1922 fw_fixed_hdr->fwsize = get_unaligned_be32(&buf[offset]);
1923 offset += 4;
1927 offset = -EINVAL;
1930 offset += 4;
1931 fw_fixed_hdr->ppcver = get_unaligned_be32(&buf[offset]);
1932 offset += 8;
1933 fw_fixed_hdr->drv_ver = get_unaligned_be32(&buf[offset]);
1934 offset += 72;
1937 return offset;
1941 struct tasdevice_fw *tas_fmw, const struct firmware *fmw, int offset)
1945 offset = fw_parse_variable_hdr(tas_priv, fw_hdr, fmw, offset);
1946 if (offset < 0)
1952 offset = -EINVAL;
1956 return offset;
1964 struct tasdevice_fw *tas_fmw, const struct firmware *fmw, int offset)
1970 if (offset + 2 > fmw->size) {
1972 offset = -EINVAL;
1975 tas_fmw->nr_calibrations = get_unaligned_be16(&data[offset]);
1976 offset += 2;
1988 offset = -ENOMEM;
1992 if (offset + 64 > fmw->size) {
1994 offset = -EINVAL;
1998 offset += 64;
2000 n = strlen((char *)&data[offset]);
2003 if (offset + n > fmw->size) {
2005 offset = -EINVAL;
2008 offset += n;
2010 offset = fw_parse_data(tas_fmw, &(calibration->dev_data), fmw,
2011 offset);
2012 if (offset < 0)
2017 return offset;
2028 int offset = 0;
2054 offset = fw_parse_header(tas_priv, tas_fmw, &fmw, offset);
2055 if (offset == -EINVAL) {
2057 ret = offset;
2060 offset = fw_parse_variable_hdr_cal(tas_priv, tas_fmw, &fmw, offset);
2061 if (offset == -EINVAL) {
2064 ret = offset;
2067 offset = fw_parse_program_data(tas_priv, tas_fmw, &fmw, offset);
2068 if (offset < 0) {
2070 ret = offset;
2073 offset = fw_parse_configuration_data(tas_priv, tas_fmw, &fmw, offset);
2074 if (offset < 0) {
2076 ret = offset;
2079 offset = fw_parse_calibration_data(tas_priv, tas_fmw, &fmw, offset);
2080 if (offset < 0) {
2082 ret = offset;
2099 int offset = 0;
2114 offset = fw_parse_header(tas_priv, tas_fmw, fmw, offset);
2116 if (offset == -EINVAL)
2155 offset = tas_priv->fw_parse_variable_header(tas_priv, fmw, offset);
2156 if (offset < 0)
2157 return offset;
2159 offset = tas_priv->fw_parse_program_data(tas_priv, tas_fmw, fmw,
2160 offset);
2161 if (offset < 0)
2162 return offset;
2164 offset = tas_priv->fw_parse_configuration_data(tas_priv,
2165 tas_fmw, fmw, offset);
2166 if (offset < 0)
2167 return offset;
2170 offset = tas_priv->fw_parse_fct_param_address(tas_priv,
2171 tas_fmw, fmw, offset);
2172 if (offset < 0)
2173 return offset;