Lines Matching defs:offset
84 unsigned char offset;
202 /* convert data[offset], data[offset + 1], data[offset + 2] and
203 * data[offset + 3] into host
291 int offset = 0;
308 fw_hdr->img_sz = get_unaligned_be32(&buf[offset]);
309 offset += 4;
319 fw_hdr->checksum = get_unaligned_be32(&buf[offset]);
320 offset += 4;
321 fw_hdr->binary_version_num = get_unaligned_be32(&buf[offset]);
329 offset += 4;
330 fw_hdr->drv_fw_version = get_unaligned_be32(&buf[offset]);
331 offset += 8;
332 fw_hdr->plat_type = buf[offset];
333 offset += 1;
334 fw_hdr->dev_family = buf[offset];
335 offset += 1;
336 fw_hdr->reserve = buf[offset];
337 offset += 1;
338 fw_hdr->ndev = buf[offset];
339 offset += 1;
348 if (offset + TASDEVICE_DEVICE_SUM > fw_hdr->img_sz) {
355 for (i = 0; i < TASDEVICE_DEVICE_SUM; i++, offset++)
356 fw_hdr->devs[i] = buf[offset];
358 fw_hdr->nconfig = get_unaligned_be32(&buf[offset]);
359 offset += 4;
362 fw_hdr->config_size[i] = get_unaligned_be32(&buf[offset]);
363 offset += 4;
367 if (fw_hdr->img_sz - total_config_sz != (unsigned int)offset) {
384 cfg_info[i] = tasdevice_add_config(tas_priv, &buf[offset],
390 offset += (int)fw_hdr->config_size[i];
429 struct tasdev_blk *block, const struct firmware *fmw, int offset)
433 if (offset + 16 > fmw->size) {
435 offset = -EINVAL;
439 /* convert data[offset], data[offset + 1], data[offset + 2] and
440 * data[offset + 3] into host
442 block->type = get_unaligned_be32(&data[offset]);
443 offset += 4;
445 block->is_pchksum_present = data[offset];
446 offset++;
448 block->pchksum = data[offset];
449 offset++;
451 block->is_ychksum_present = data[offset];
452 offset++;
454 block->ychksum = data[offset];
455 offset++;
457 block->blk_size = get_unaligned_be32(&data[offset]);
458 offset += 4;
460 block->nr_subblocks = get_unaligned_be32(&data[offset]);
461 offset += 4;
471 if (offset + block->blk_size > fmw->size) {
473 offset = -EINVAL;
477 block->data = kmemdup(&data[offset], block->blk_size, GFP_KERNEL);
479 offset = -ENOMEM;
482 offset += block->blk_size;
485 return offset;
490 int offset)
496 if (offset + 4 > fmw->size) {
498 offset = -EINVAL;
501 img_data->nr_blk = get_unaligned_be32(&data[offset]);
502 offset += 4;
507 offset = -ENOMEM;
513 offset = fw_parse_block_data_kernel(tas_fmw, blk, fmw, offset);
514 if (offset < 0) {
515 offset = -EINVAL;
521 return offset;
526 const struct firmware *fmw, int offset)
533 if (offset + 72 > fmw->size) {
538 offset += 65;
539 offset = fw_parse_data_kernel(tas_fmw, &(program->dev_data),
540 fmw, offset);
541 if (offset < 0)
542 return offset;
545 return offset;
550 struct tasdevice_fw *tas_fmw, const struct firmware *fmw, int offset)
558 if (offset + 80 > fmw->size) {
562 memcpy(config->name, &data[offset], 64);
564 offset += 72;
565 offset = fw_parse_data_kernel(tas_fmw, &(config->dev_data),
566 fmw, offset);
567 if (offset < 0)
568 return offset;
571 return offset;
576 const struct firmware *fmw, int offset)
583 if (offset + 72 > fmw->size) {
585 offset = -EINVAL;
589 offset += 72;
591 offset = fw_parse_data_kernel(tas_fmw, &(program->dev_data),
592 fmw, offset);
593 if (offset < 0)
598 return offset;
603 struct tasdevice_fw *tas_fmw, const struct firmware *fmw, int offset)
611 if (offset + 80 > fmw->size) {
613 offset = -EINVAL;
616 memcpy(config->name, &data[offset], 64);
618 offset += 80;
620 offset = fw_parse_data_kernel(tas_fmw, &(config->dev_data),
621 fmw, offset);
622 if (offset < 0)
627 return offset;
727 struct tasdevice_fw *tas_fmw, const struct firmware *fmw, int offset)
733 if (offset + 520 > fmw->size) {
739 offset += 40;
741 fct_param_address_parser(r, tas_fmw, &data[offset]);
743 offset += 480;
745 return offset;
750 int offset)
760 if (offset + 12 + 4 * TASDEVICE_MAXPROGRAM_NUM_KERNEL > fmw->size) {
762 offset = -EINVAL;
765 fw_hdr->device_family = get_unaligned_be16(&buf[offset]);
768 offset = -EINVAL;
771 offset += 2;
772 fw_hdr->device = get_unaligned_be16(&buf[offset]);
776 offset = -EINVAL;
779 offset += 2;
786 offset = -EINVAL;
790 tas_fmw->nr_programs = get_unaligned_be32(&buf[offset]);
791 offset += 4;
796 offset = -EINVAL;
803 offset = -ENOMEM;
809 program->prog_size = get_unaligned_be32(&buf[offset]);
810 offset += 4;
814 offset += 4 * (TASDEVICE_MAXPROGRAM_NUM_KERNEL - tas_fmw->nr_programs);
816 tas_fmw->nr_configurations = get_unaligned_be32(&buf[offset]);
817 offset += 4;
829 offset = -EINVAL;
833 if (offset + 4 * max_confs > fmw->size) {
835 offset = -EINVAL;
842 offset = -ENOMEM;
848 config->cfg_size = get_unaligned_be32(&buf[offset]);
849 offset += 4;
853 offset += 4 * (max_confs - tas_fmw->nr_programs);
856 return offset;
1087 const struct firmware *fmw, int offset)
1090 int len = strlen((char *)&buf[offset]);
1094 if (offset + len + 8 > fmw->size) {
1096 offset = -EINVAL;
1100 offset += len;
1102 fw_hdr->device_family = get_unaligned_be32(&buf[offset]);
1105 offset = -EINVAL;
1108 offset += 4;
1110 fw_hdr->device = get_unaligned_be32(&buf[offset]);
1114 offset = -EINVAL;
1117 offset += 4;
1121 return offset;
1125 *tas_priv, const struct firmware *fmw, int offset)
1130 offset = fw_parse_variable_hdr(tas_priv, fw_hdr, fmw, offset);
1131 if (offset < 0)
1137 offset = -EINVAL;
1141 return offset;
1145 struct tasdev_blk *block, const struct firmware *fmw, int offset)
1150 if (offset + 8 > fmw->size) {
1152 offset = -EINVAL;
1155 block->type = get_unaligned_be32(&data[offset]);
1156 offset += 4;
1159 if (offset + 8 > fmw->size) {
1161 offset = -EINVAL;
1164 block->is_pchksum_present = data[offset];
1165 offset++;
1167 block->pchksum = data[offset];
1168 offset++;
1170 block->is_ychksum_present = data[offset];
1171 offset++;
1173 block->ychksum = data[offset];
1174 offset++;
1180 block->nr_cmds = get_unaligned_be32(&data[offset]);
1181 offset += 4;
1184 if (offset + n > fmw->size) {
1186 "%s: File Size(%lu) error offset = %d n = %d\n",
1187 __func__, (unsigned long)fmw->size, offset, n);
1188 offset = -EINVAL;
1192 block->data = kmemdup(&data[offset], n, GFP_KERNEL);
1194 offset = -ENOMEM;
1197 offset += n;
1200 return offset;
1208 int offset)
1215 if (offset + 64 > fmw->size) {
1217 offset = -EINVAL;
1220 memcpy(img_data->name, &data[offset], 64);
1221 offset += 64;
1223 n = strlen((char *)&data[offset]);
1225 if (offset + n + 2 > fmw->size) {
1227 offset = -EINVAL;
1230 offset += n;
1231 img_data->nr_blk = get_unaligned_be16(&data[offset]);
1232 offset += 2;
1237 offset = -ENOMEM;
1242 offset = fw_parse_block_data(tas_fmw, blk, fmw, offset);
1243 if (offset < 0) {
1244 offset = -EINVAL;
1250 return offset;
1257 struct tasdevice_fw *tas_fmw, const struct firmware *fmw, int offset)
1263 if (offset + 2 > fmw->size) {
1265 offset = -EINVAL;
1268 tas_fmw->nr_programs = get_unaligned_be16(&buf[offset]);
1269 offset += 2;
1282 offset = -ENOMEM;
1289 if (offset + 64 > fmw->size) {
1291 offset = -EINVAL;
1294 offset += 64;
1296 n = strlen((char *)&buf[offset]);
1299 if (offset + n > fmw->size) {
1301 offset = -EINVAL;
1305 offset += n;
1307 offset = fw_parse_data(tas_fmw, &(program->dev_data), fmw,
1308 offset);
1309 if (offset < 0)
1314 return offset;
1323 const struct firmware *fmw, int offset)
1330 if (offset + 2 > fmw->size) {
1332 offset = -EINVAL;
1335 tas_fmw->nr_configurations = get_unaligned_be16(&data[offset]);
1336 offset += 2;
1346 offset = -ENOMEM;
1351 if (offset + 64 > fmw->size) {
1353 offset = -EINVAL;
1356 memcpy(config->name, &data[offset], 64);
1357 offset += 64;
1359 n = strlen((char *)&data[offset]);
1361 if (offset + n > fmw->size) {
1363 offset = -EINVAL;
1367 offset += n;
1369 offset = fw_parse_data(tas_fmw, &(config->dev_data),
1370 fmw, offset);
1371 if (offset < 0)
1376 return offset;
1391 cd->offset = reg;
1395 cd->offset = TAS2781_YRAM5_START_REG;
1411 cd->offset = reg;
1415 cd->offset = TAS2781_YRAM1_START_REG;
1456 cd->offset = reg;
1461 cd->offset = TAS2781_YRAM2_START_REG;
1537 TASDEVICE_REG(book, page, crc_data.offset),
1546 && ((i + crc_data.offset)
1548 && ((i + crc_data.offset)
1725 unsigned char offset;
1749 offset = data[2];
1754 if (offset <= 0x7F) {
1756 TASDEVICE_REG(book, page, offset),
1762 block, chn, book, page, offset,
1770 if (offset == 0x81) {
1777 if (offset == 0x85) {
1782 offset = data[2];
1784 block, chn, book, page, offset, data,
1973 struct tasdevice_fw *tas_fmw, const struct firmware *fmw, int offset)
1980 if (offset + 92 > fmw->size) {
1982 offset = -EINVAL;
1985 if (memcmp(&buf[offset], magic_number, 4)) {
1987 offset = -EINVAL;
1990 offset += 4;
1992 /* Convert data[offset], data[offset + 1], data[offset + 2] and
1993 * data[offset + 3] into host
1995 fw_fixed_hdr->fwsize = get_unaligned_be32(&buf[offset]);
1996 offset += 4;
2000 offset = -EINVAL;
2003 offset += 4;
2004 fw_fixed_hdr->ppcver = get_unaligned_be32(&buf[offset]);
2005 offset += 8;
2006 fw_fixed_hdr->drv_ver = get_unaligned_be32(&buf[offset]);
2007 offset += 72;
2010 return offset;
2014 struct tasdevice_fw *tas_fmw, const struct firmware *fmw, int offset)
2018 offset = fw_parse_variable_hdr(tas_priv, fw_hdr, fmw, offset);
2019 if (offset < 0)
2025 offset = -EINVAL;
2029 return offset;
2037 struct tasdevice_fw *tas_fmw, const struct firmware *fmw, int offset)
2043 if (offset + 2 > fmw->size) {
2045 offset = -EINVAL;
2048 tas_fmw->nr_calibrations = get_unaligned_be16(&data[offset]);
2049 offset += 2;
2061 offset = -ENOMEM;
2065 if (offset + 64 > fmw->size) {
2067 offset = -EINVAL;
2071 offset += 64;
2073 n = strlen((char *)&data[offset]);
2076 if (offset + n > fmw->size) {
2078 offset = -EINVAL;
2081 offset += n;
2083 offset = fw_parse_data(tas_fmw, &(calibration->dev_data), fmw,
2084 offset);
2085 if (offset < 0)
2090 return offset;
2101 int offset = 0;
2127 offset = fw_parse_header(tas_priv, tas_fmw, &fmw, offset);
2128 if (offset == -EINVAL) {
2130 ret = offset;
2133 offset = fw_parse_variable_hdr_cal(tas_priv, tas_fmw, &fmw, offset);
2134 if (offset == -EINVAL) {
2137 ret = offset;
2140 offset = fw_parse_program_data(tas_priv, tas_fmw, &fmw, offset);
2141 if (offset < 0) {
2143 ret = offset;
2146 offset = fw_parse_configuration_data(tas_priv, tas_fmw, &fmw, offset);
2147 if (offset < 0) {
2149 ret = offset;
2152 offset = fw_parse_calibration_data(tas_priv, tas_fmw, &fmw, offset);
2153 if (offset < 0) {
2155 ret = offset;
2172 int offset = 0;
2187 offset = fw_parse_header(tas_priv, tas_fmw, fmw, offset);
2189 if (offset == -EINVAL)
2228 offset = tas_priv->fw_parse_variable_header(tas_priv, fmw, offset);
2229 if (offset < 0)
2230 return offset;
2232 offset = tas_priv->fw_parse_program_data(tas_priv, tas_fmw, fmw,
2233 offset);
2234 if (offset < 0)
2235 return offset;
2237 offset = tas_priv->fw_parse_configuration_data(tas_priv,
2238 tas_fmw, fmw, offset);
2239 if (offset < 0)
2240 return offset;
2243 offset = tas_priv->fw_parse_fct_param_address(tas_priv,
2244 tas_fmw, fmw, offset);
2245 if (offset < 0)
2246 return offset;