Lines Matching refs:offset
79 unsigned char offset;
125 /* convert data[offset], data[offset + 1], data[offset + 2] and
126 * data[offset + 3] into host
215 int offset = 0;
230 fw_hdr->img_sz = be32_to_cpup((__be32 *)&buf[offset]);
231 offset += 4;
241 fw_hdr->checksum = be32_to_cpup((__be32 *)&buf[offset]);
242 offset += 4;
243 fw_hdr->binary_version_num = be32_to_cpup((__be32 *)&buf[offset]);
251 offset += 4;
252 fw_hdr->drv_fw_version = be32_to_cpup((__be32 *)&buf[offset]);
253 offset += 8;
254 fw_hdr->plat_type = buf[offset];
255 offset += 1;
256 fw_hdr->dev_family = buf[offset];
257 offset += 1;
258 fw_hdr->reserve = buf[offset];
259 offset += 1;
260 fw_hdr->ndev = buf[offset];
261 offset += 1;
270 if (offset + TASDEVICE_DEVICE_SUM > fw_hdr->img_sz) {
277 for (i = 0; i < TASDEVICE_DEVICE_SUM; i++, offset++)
278 fw_hdr->devs[i] = buf[offset];
280 fw_hdr->nconfig = be32_to_cpup((__be32 *)&buf[offset]);
281 offset += 4;
284 fw_hdr->config_size[i] = be32_to_cpup((__be32 *)&buf[offset]);
285 offset += 4;
289 if (fw_hdr->img_sz - total_config_sz != (unsigned int)offset) {
306 cfg_info[i] = tasdevice_add_config(tas_priv, &buf[offset],
312 offset += (int)fw_hdr->config_size[i];
320 struct tasdev_blk *block, const struct firmware *fmw, int offset)
324 if (offset + 16 > fmw->size) {
326 offset = -EINVAL;
330 /* convert data[offset], data[offset + 1], data[offset + 2] and
331 * data[offset + 3] into host
333 block->type = be32_to_cpup((__be32 *)&data[offset]);
334 offset += 4;
336 block->is_pchksum_present = data[offset];
337 offset++;
339 block->pchksum = data[offset];
340 offset++;
342 block->is_ychksum_present = data[offset];
343 offset++;
345 block->ychksum = data[offset];
346 offset++;
348 block->blk_size = be32_to_cpup((__be32 *)&data[offset]);
349 offset += 4;
351 block->nr_subblocks = be32_to_cpup((__be32 *)&data[offset]);
352 offset += 4;
354 if (offset + block->blk_size > fmw->size) {
356 offset = -EINVAL;
360 block->data = kmemdup(&data[offset], block->blk_size, GFP_KERNEL);
362 offset = -ENOMEM;
365 offset += block->blk_size;
368 return offset;
373 int offset)
379 if (offset + 4 > fmw->size) {
381 offset = -EINVAL;
384 img_data->nr_blk = be32_to_cpup((__be32 *)&data[offset]);
385 offset += 4;
390 offset = -ENOMEM;
396 offset = fw_parse_block_data_kernel(tas_fmw, blk, fmw, offset);
397 if (offset < 0) {
398 offset = -EINVAL;
404 return offset;
409 const struct firmware *fmw, int offset)
416 if (offset + 72 > fmw->size) {
418 offset = -EINVAL;
422 offset += 72;
424 offset = fw_parse_data_kernel(tas_fmw, &(program->dev_data),
425 fmw, offset);
426 if (offset < 0)
431 return offset;
436 struct tasdevice_fw *tas_fmw, const struct firmware *fmw, int offset)
444 if (offset + 80 > fmw->size) {
446 offset = -EINVAL;
449 memcpy(config->name, &data[offset], 64);
451 offset += 80;
453 offset = fw_parse_data_kernel(tas_fmw, &(config->dev_data),
454 fmw, offset);
455 if (offset < 0)
460 return offset;
465 int offset)
475 if (offset + 12 + 4 * TASDEVICE_MAXPROGRAM_NUM_KERNEL > fmw->size) {
477 offset = -EINVAL;
480 fw_hdr->device_family = be16_to_cpup((__be16 *)&buf[offset]);
483 offset = -EINVAL;
486 offset += 2;
487 fw_hdr->device = be16_to_cpup((__be16 *)&buf[offset]);
491 offset = -EINVAL;
494 offset += 2;
501 offset = -EINVAL;
505 tas_fmw->nr_programs = be32_to_cpup((__be32 *)&buf[offset]);
506 offset += 4;
511 offset = -EINVAL;
518 offset = -ENOMEM;
524 program->prog_size = be32_to_cpup((__be32 *)&buf[offset]);
525 offset += 4;
529 offset += 4 * (TASDEVICE_MAXPROGRAM_NUM_KERNEL - tas_fmw->nr_programs);
531 tas_fmw->nr_configurations = be32_to_cpup((__be32 *)&buf[offset]);
532 offset += 4;
544 offset = -EINVAL;
548 if (offset + 4 * max_confs > fmw->size) {
550 offset = -EINVAL;
557 offset = -ENOMEM;
563 config->cfg_size = be32_to_cpup((__be32 *)&buf[offset]);
564 offset += 4;
568 offset += 4 * (max_confs - tas_fmw->nr_programs);
571 return offset;
928 const struct firmware *fmw, int offset)
931 int len = strlen((char *)&buf[offset]);
935 if (offset + len + 8 > fmw->size) {
937 offset = -EINVAL;
941 offset += len;
943 fw_hdr->device_family = be32_to_cpup((__be32 *)&buf[offset]);
946 offset = -EINVAL;
949 offset += 4;
951 fw_hdr->device = be32_to_cpup((__be32 *)&buf[offset]);
955 offset = -EINVAL;
958 offset += 4;
962 return offset;
966 *tas_priv, const struct firmware *fmw, int offset)
971 offset = fw_parse_variable_hdr(tas_priv, fw_hdr, fmw, offset);
972 if (offset < 0)
978 offset = -EINVAL;
982 return offset;
986 struct tasdev_blk *block, const struct firmware *fmw, int offset)
991 if (offset + 8 > fmw->size) {
993 offset = -EINVAL;
996 block->type = be32_to_cpup((__be32 *)&data[offset]);
997 offset += 4;
1000 if (offset + 8 > fmw->size) {
1002 offset = -EINVAL;
1005 block->is_pchksum_present = data[offset];
1006 offset++;
1008 block->pchksum = data[offset];
1009 offset++;
1011 block->is_ychksum_present = data[offset];
1012 offset++;
1014 block->ychksum = data[offset];
1015 offset++;
1021 block->nr_cmds = be32_to_cpup((__be32 *)&data[offset]);
1022 offset += 4;
1025 if (offset + n > fmw->size) {
1027 "%s: File Size(%lu) error offset = %d n = %d\n",
1028 __func__, (unsigned long)fmw->size, offset, n);
1029 offset = -EINVAL;
1033 block->data = kmemdup(&data[offset], n, GFP_KERNEL);
1035 offset = -ENOMEM;
1038 offset += n;
1041 return offset;
1049 int offset)
1056 if (offset + 64 > fmw->size) {
1058 offset = -EINVAL;
1061 memcpy(img_data->name, &data[offset], 64);
1062 offset += 64;
1064 n = strlen((char *)&data[offset]);
1066 if (offset + n + 2 > fmw->size) {
1068 offset = -EINVAL;
1071 offset += n;
1072 img_data->nr_blk = be16_to_cpup((__be16 *)&data[offset]);
1073 offset += 2;
1078 offset = -ENOMEM;
1083 offset = fw_parse_block_data(tas_fmw, blk, fmw, offset);
1084 if (offset < 0) {
1085 offset = -EINVAL;
1091 return offset;
1098 struct tasdevice_fw *tas_fmw, const struct firmware *fmw, int offset)
1104 if (offset + 2 > fmw->size) {
1106 offset = -EINVAL;
1109 tas_fmw->nr_programs = be16_to_cpup((__be16 *)&buf[offset]);
1110 offset += 2;
1123 offset = -ENOMEM;
1130 if (offset + 64 > fmw->size) {
1132 offset = -EINVAL;
1135 offset += 64;
1137 n = strlen((char *)&buf[offset]);
1140 if (offset + n > fmw->size) {
1142 offset = -EINVAL;
1146 offset += n;
1148 offset = fw_parse_data(tas_fmw, &(program->dev_data), fmw,
1149 offset);
1150 if (offset < 0)
1155 return offset;
1164 const struct firmware *fmw, int offset)
1171 if (offset + 2 > fmw->size) {
1173 offset = -EINVAL;
1176 tas_fmw->nr_configurations = be16_to_cpup((__be16 *)&data[offset]);
1177 offset += 2;
1187 offset = -ENOMEM;
1192 if (offset + 64 > fmw->size) {
1194 offset = -EINVAL;
1197 memcpy(config->name, &data[offset], 64);
1198 offset += 64;
1200 n = strlen((char *)&data[offset]);
1202 if (offset + n > fmw->size) {
1204 offset = -EINVAL;
1208 offset += n;
1210 offset = fw_parse_data(tas_fmw, &(config->dev_data),
1211 fmw, offset);
1212 if (offset < 0)
1217 return offset;
1232 cd->offset = reg;
1236 cd->offset = TAS2781_YRAM5_START_REG;
1252 cd->offset = reg;
1256 cd->offset = TAS2781_YRAM1_START_REG;
1297 cd->offset = reg;
1302 cd->offset = TAS2781_YRAM2_START_REG;
1378 TASDEVICE_REG(book, page, crc_data.offset),
1387 && ((i + crc_data.offset)
1389 && ((i + crc_data.offset)
1566 unsigned char offset;
1590 offset = data[2];
1595 if (offset <= 0x7F) {
1597 TASDEVICE_REG(book, page, offset),
1603 block, chn, book, page, offset,
1611 if (offset == 0x81) {
1618 if (offset == 0x85) {
1623 offset = data[2];
1625 block, chn, book, page, offset, data,
1786 struct tasdevice_fw *tas_fmw, const struct firmware *fmw, int offset)
1793 if (offset + 92 > fmw->size) {
1795 offset = -EINVAL;
1798 if (memcmp(&buf[offset], magic_number, 4)) {
1800 offset = -EINVAL;
1803 offset += 4;
1805 /* Convert data[offset], data[offset + 1], data[offset + 2] and
1806 * data[offset + 3] into host
1808 fw_fixed_hdr->fwsize = be32_to_cpup((__be32 *)&buf[offset]);
1809 offset += 4;
1813 offset = -EINVAL;
1816 offset += 4;
1817 fw_fixed_hdr->ppcver = be32_to_cpup((__be32 *)&buf[offset]);
1818 offset += 8;
1819 fw_fixed_hdr->drv_ver = be32_to_cpup((__be32 *)&buf[offset]);
1820 offset += 72;
1823 return offset;
1827 struct tasdevice_fw *tas_fmw, const struct firmware *fmw, int offset)
1831 offset = fw_parse_variable_hdr(tas_priv, fw_hdr, fmw, offset);
1832 if (offset < 0)
1838 offset = -EINVAL;
1842 return offset;
1850 struct tasdevice_fw *tas_fmw, const struct firmware *fmw, int offset)
1856 if (offset + 2 > fmw->size) {
1858 offset = -EINVAL;
1861 tas_fmw->nr_calibrations = be16_to_cpup((__be16 *)&data[offset]);
1862 offset += 2;
1874 offset = -ENOMEM;
1878 if (offset + 64 > fmw->size) {
1880 offset = -EINVAL;
1884 offset += 64;
1886 n = strlen((char *)&data[offset]);
1889 if (offset + n > fmw->size) {
1891 offset = -EINVAL;
1894 offset += n;
1896 offset = fw_parse_data(tas_fmw, &(calibration->dev_data), fmw,
1897 offset);
1898 if (offset < 0)
1903 return offset;
1914 int offset = 0;
1940 offset = fw_parse_header(tas_priv, tas_fmw, &fmw, offset);
1941 if (offset == -EINVAL) {
1943 ret = offset;
1946 offset = fw_parse_variable_hdr_cal(tas_priv, tas_fmw, &fmw, offset);
1947 if (offset == -EINVAL) {
1950 ret = offset;
1953 offset = fw_parse_program_data(tas_priv, tas_fmw, &fmw, offset);
1954 if (offset < 0) {
1956 ret = offset;
1959 offset = fw_parse_configuration_data(tas_priv, tas_fmw, &fmw, offset);
1960 if (offset < 0) {
1962 ret = offset;
1965 offset = fw_parse_calibration_data(tas_priv, tas_fmw, &fmw, offset);
1966 if (offset < 0) {
1968 ret = offset;
1986 int offset = 0;
2003 offset = fw_parse_header(tas_priv, tas_fmw, fmw, offset);
2005 if (offset == -EINVAL) {
2044 offset = tas_priv->fw_parse_variable_header(tas_priv, fmw, offset);
2045 if (offset < 0) {
2046 ret = offset;
2049 offset = tas_priv->fw_parse_program_data(tas_priv, tas_fmw, fmw,
2050 offset);
2051 if (offset < 0) {
2052 ret = offset;
2055 offset = tas_priv->fw_parse_configuration_data(tas_priv,
2056 tas_fmw, fmw, offset);
2057 if (offset < 0)
2058 ret = offset;