sound/soc/codecs/tas2781-fmwlib.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 //
   3 // tasdevice-fmw.c -- TASDEVICE firmware support
   4 //
   5 // Copyright 2023 Texas Instruments, Inc.
   6 //
   7 // Author: Shenghao Ding <shenghao-ding@ti.com>
   8
   9 #include <linux/crc8.h>
  10 #include <linux/firmware.h>
  11 #include <linux/i2c.h>
  12 #include <linux/init.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/module.h>
  15 #include <linux/of.h>
  16 #include <linux/of_gpio.h>
  17 #include <linux/of_irq.h>
  18 #include <linux/regmap.h>
  19 #include <linux/slab.h>
  20 #include <sound/pcm_params.h>
  21 #include <sound/soc.h>
  22 #include <sound/tlv.h>
  23 #include <sound/tas2781.h>
  24
  25
  26 #define ERROR_PRAM_CRCCHK                       0x0000000
  27 #define ERROR_YRAM_CRCCHK                       0x0000001
  28 #define PPC_DRIVER_CRCCHK                       0x00000200
  29
  30 #define TAS2781_SA_COEFF_SWAP_REG               TASDEVICE_REG(0, 0x35, 0x2c)
  31 #define TAS2781_YRAM_BOOK1                      140
  32 #define TAS2781_YRAM1_PAGE                      42
  33 #define TAS2781_YRAM1_START_REG                 88
  34
  35 #define TAS2781_YRAM2_START_PAGE                43
  36 #define TAS2781_YRAM2_END_PAGE                  49
  37 #define TAS2781_YRAM2_START_REG                 8
  38 #define TAS2781_YRAM2_END_REG                   127
  39
  40 #define TAS2781_YRAM3_PAGE                      50
  41 #define TAS2781_YRAM3_START_REG                 8
  42 #define TAS2781_YRAM3_END_REG                   27
  43
  44 /*should not include B0_P53_R44-R47 */
  45 #define TAS2781_YRAM_BOOK2                      0
  46 #define TAS2781_YRAM4_START_PAGE                50
  47 #define TAS2781_YRAM4_END_PAGE                  60
  48
  49 #define TAS2781_YRAM5_PAGE                      61
  50 #define TAS2781_YRAM5_START_REG                 TAS2781_YRAM3_START_REG
  51 #define TAS2781_YRAM5_END_REG                   TAS2781_YRAM3_END_REG
  52
  53 #define TASDEVICE_MAXPROGRAM_NUM_KERNEL                 5
  54 #define TASDEVICE_MAXCONFIG_NUM_KERNEL_MULTIPLE_AMPS    64
  55 #define TASDEVICE_MAXCONFIG_NUM_KERNEL                  10
  56 #define MAIN_ALL_DEVICES_1X                             0x01
  57 #define MAIN_DEVICE_A_1X                                0x02
  58 #define MAIN_DEVICE_B_1X                                0x03
  59 #define MAIN_DEVICE_C_1X                                0x04
  60 #define MAIN_DEVICE_D_1X                                0x05
  61 #define COEFF_DEVICE_A_1X                               0x12
  62 #define COEFF_DEVICE_B_1X                               0x13
  63 #define COEFF_DEVICE_C_1X                               0x14
  64 #define COEFF_DEVICE_D_1X                               0x15
  65 #define PRE_DEVICE_A_1X                                 0x22
  66 #define PRE_DEVICE_B_1X                                 0x23
  67 #define PRE_DEVICE_C_1X                                 0x24
  68 #define PRE_DEVICE_D_1X                                 0x25
  69 #define PRE_SOFTWARE_RESET_DEVICE_A                     0x41
  70 #define PRE_SOFTWARE_RESET_DEVICE_B                     0x42
  71 #define PRE_SOFTWARE_RESET_DEVICE_C                     0x43
  72 #define PRE_SOFTWARE_RESET_DEVICE_D                     0x44
  73 #define POST_SOFTWARE_RESET_DEVICE_A                    0x45
  74 #define POST_SOFTWARE_RESET_DEVICE_B                    0x46
  75 #define POST_SOFTWARE_RESET_DEVICE_C                    0x47
  76 #define POST_SOFTWARE_RESET_DEVICE_D                    0x48
  77
  78 struct tas_crc {
  79         unsigned char offset;
  80         unsigned char len;
  81 };
  82
  83 struct blktyp_devidx_map {
  84         unsigned char blktyp;
  85         unsigned char dev_idx;
  86 };
  87
  88 static const char deviceNumber[TASDEVICE_DSP_TAS_MAX_DEVICE] = {
  89         1, 2, 1, 2, 1, 1, 0, 2, 4, 3, 1, 2, 3, 4
  90 };
  91
  92 /* fixed m68k compiling issue: mapping table can save code field */
  93 static const struct blktyp_devidx_map ppc3_tas2781_mapping_table[] = {
  94         { MAIN_ALL_DEVICES_1X, 0x80 },
  95         { MAIN_DEVICE_A_1X, 0x81 },
  96         { COEFF_DEVICE_A_1X, 0xC1 },
  97         { PRE_DEVICE_A_1X, 0xC1 },
  98         { PRE_SOFTWARE_RESET_DEVICE_A, 0xC1 },
  99         { POST_SOFTWARE_RESET_DEVICE_A, 0xC1 },
 100         { MAIN_DEVICE_B_1X, 0x82 },
 101         { COEFF_DEVICE_B_1X, 0xC2 },
 102         { PRE_DEVICE_B_1X, 0xC2 },
 103         { PRE_SOFTWARE_RESET_DEVICE_B, 0xC2 },
 104         { POST_SOFTWARE_RESET_DEVICE_B, 0xC2 },
 105         { MAIN_DEVICE_C_1X, 0x83 },
 106         { COEFF_DEVICE_C_1X, 0xC3 },
 107         { PRE_DEVICE_C_1X, 0xC3 },
 108         { PRE_SOFTWARE_RESET_DEVICE_C, 0xC3 },
 109         { POST_SOFTWARE_RESET_DEVICE_C, 0xC3 },
 110         { MAIN_DEVICE_D_1X, 0x84 },
 111         { COEFF_DEVICE_D_1X, 0xC4 },
 112         { PRE_DEVICE_D_1X, 0xC4 },
 113         { PRE_SOFTWARE_RESET_DEVICE_D, 0xC4 },
 114         { POST_SOFTWARE_RESET_DEVICE_D, 0xC4 },
 115 };
 116
 117 static const struct blktyp_devidx_map ppc3_mapping_table[] = {
 118         { MAIN_ALL_DEVICES_1X, 0x80 },
 119         { MAIN_DEVICE_A_1X, 0x81 },
 120         { COEFF_DEVICE_A_1X, 0xC1 },
 121         { PRE_DEVICE_A_1X, 0xC1 },
 122         { MAIN_DEVICE_B_1X, 0x82 },
 123         { COEFF_DEVICE_B_1X, 0xC2 },
 124         { PRE_DEVICE_B_1X, 0xC2 },
 125         { MAIN_DEVICE_C_1X, 0x83 },
 126         { COEFF_DEVICE_C_1X, 0xC3 },
 127         { PRE_DEVICE_C_1X, 0xC3 },
 128         { MAIN_DEVICE_D_1X, 0x84 },
 129         { COEFF_DEVICE_D_1X, 0xC4 },
 130         { PRE_DEVICE_D_1X, 0xC4 },
 131 };
 132
 133 static const struct blktyp_devidx_map non_ppc3_mapping_table[] = {
 134         { MAIN_ALL_DEVICES, 0x80 },
 135         { MAIN_DEVICE_A, 0x81 },
 136         { COEFF_DEVICE_A, 0xC1 },
 137         { PRE_DEVICE_A, 0xC1 },
 138         { MAIN_DEVICE_B, 0x82 },
 139         { COEFF_DEVICE_B, 0xC2 },
 140         { PRE_DEVICE_B, 0xC2 },
 141         { MAIN_DEVICE_C, 0x83 },
 142         { COEFF_DEVICE_C, 0xC3 },
 143         { PRE_DEVICE_C, 0xC3 },
 144         { MAIN_DEVICE_D, 0x84 },
 145         { COEFF_DEVICE_D, 0xC4 },
 146         { PRE_DEVICE_D, 0xC4 },
 147 };
 148
 149 static struct tasdevice_config_info *tasdevice_add_config(
 150         struct tasdevice_priv *tas_priv, unsigned char *config_data,
 151         unsigned int config_size, int *status)
 152 {
 153         struct tasdevice_config_info *cfg_info;
 154         struct tasdev_blk_data **bk_da;
 155         unsigned int config_offset = 0;
 156         unsigned int i;
 157
 158         /* In most projects are many audio cases, such as music, handfree,
 159          * receiver, games, audio-to-haptics, PMIC record, bypass mode,
 160          * portrait, landscape, etc. Even in multiple audios, one or
 161          * two of the chips will work for the special case, such as
 162          * ultrasonic application. In order to support these variable-numbers
 163          * of audio cases, flexible configs have been introduced in the
 164          * dsp firmware.
 165          */
 166         cfg_info = kzalloc(sizeof(struct tasdevice_config_info), GFP_KERNEL);
 167         if (!cfg_info) {
 168                 *status = -ENOMEM;
 169                 goto out;
 170         }
 171
 172         if (tas_priv->rcabin.fw_hdr.binary_version_num >= 0x105) {
 173                 if (config_offset + 64 > (int)config_size) {
 174                         *status = -EINVAL;
 175                         dev_err(tas_priv->dev, "add conf: Out of boundary\n");
 176                         goto out;
 177                 }
 178                 config_offset += 64;
 179         }
 180
 181         if (config_offset + 4 > (int)config_size) {
 182                 *status = -EINVAL;
 183                 dev_err(tas_priv->dev, "add config: Out of boundary\n");
 184                 goto out;
 185         }
 186
 187         /* convert data[offset], data[offset + 1], data[offset + 2] and
 188          * data[offset + 3] into host
 189          */
 190         cfg_info->nblocks =
 191                 be32_to_cpup((__be32 *)&config_data[config_offset]);
 192         config_offset += 4;
 193
 194         /* Several kinds of dsp/algorithm firmwares can run on tas2781,
 195          * the number and size of blk are not fixed and different among
 196          * these firmwares.
 197          */
 198         bk_da = cfg_info->blk_data = kcalloc(cfg_info->nblocks,
 199                 sizeof(struct tasdev_blk_data *), GFP_KERNEL);
 200         if (!bk_da) {
 201                 *status = -ENOMEM;
 202                 goto out;
 203         }
 204         cfg_info->real_nblocks = 0;
 205         for (i = 0; i < cfg_info->nblocks; i++) {
 206                 if (config_offset + 12 > config_size) {
 207                         *status = -EINVAL;
 208                         dev_err(tas_priv->dev,
 209                                 "%s: Out of boundary: i = %d nblocks = %u!\n",
 210                                 __func__, i, cfg_info->nblocks);
 211                         break;
 212                 }
 213                 bk_da[i] = kzalloc(sizeof(struct tasdev_blk_data), GFP_KERNEL);
 214                 if (!bk_da[i]) {
 215                         *status = -ENOMEM;
 216                         break;
 217                 }
 218
 219                 bk_da[i]->dev_idx = config_data[config_offset];
 220                 config_offset++;
 221
 222                 bk_da[i]->block_type = config_data[config_offset];
 223                 config_offset++;
 224
 225                 if (bk_da[i]->block_type == TASDEVICE_BIN_BLK_PRE_POWER_UP) {
 226                         if (bk_da[i]->dev_idx == 0)
 227                                 cfg_info->active_dev =
 228                                         (1 << tas_priv->ndev) - 1;
 229                         else
 230                                 cfg_info->active_dev |= 1 <<
 231                                         (bk_da[i]->dev_idx - 1);
 232
 233                 }
 234                 bk_da[i]->yram_checksum =
 235                         be16_to_cpup((__be16 *)&config_data[config_offset]);
 236                 config_offset += 2;
 237                 bk_da[i]->block_size =
 238                         be32_to_cpup((__be32 *)&config_data[config_offset]);
 239                 config_offset += 4;
 240
 241                 bk_da[i]->n_subblks =
 242                         be32_to_cpup((__be32 *)&config_data[config_offset]);
 243
 244                 config_offset += 4;
 245
 246                 if (config_offset + bk_da[i]->block_size > config_size) {
 247                         *status = -EINVAL;
 248                         dev_err(tas_priv->dev,
 249                                 "%s: Out of boundary: i = %d blks = %u!\n",
 250                                 __func__, i, cfg_info->nblocks);
 251                         break;
 252                 }
 253                 /* instead of kzalloc+memcpy */
 254                 bk_da[i]->regdata = kmemdup(&config_data[config_offset],
 255                         bk_da[i]->block_size, GFP_KERNEL);
 256                 if (!bk_da[i]->regdata) {
 257                         *status = -ENOMEM;
 258                         goto out;
 259                 }
 260
 261                 config_offset += bk_da[i]->block_size;
 262                 cfg_info->real_nblocks += 1;
 263         }
 264
 265 out:
 266         return cfg_info;
 267 }
 268
 269 int tasdevice_rca_parser(void *context, const struct firmware *fmw)
 270 {
 271         struct tasdevice_priv *tas_priv = context;
 272         struct tasdevice_config_info **cfg_info;
 273         struct tasdevice_rca_hdr *fw_hdr;
 274         struct tasdevice_rca *rca;
 275         unsigned int total_config_sz = 0;
 276         unsigned char *buf;
 277         int offset = 0;
 278         int ret = 0;
 279         int i;
 280
 281         rca = &(tas_priv->rcabin);
 282         fw_hdr = &(rca->fw_hdr);
 283         if (!fmw || !fmw->data) {
 284                 dev_err(tas_priv->dev, "Failed to read %s\n",
 285                         tas_priv->rca_binaryname);
 286                 tas_priv->fw_state = TASDEVICE_DSP_FW_FAIL;
 287                 ret = -EINVAL;
 288                 goto out;
 289         }
 290         buf = (unsigned char *)fmw->data;
 291
 292         fw_hdr->img_sz = be32_to_cpup((__be32 *)&buf[offset]);
 293         offset += 4;
 294         if (fw_hdr->img_sz != fmw->size) {
 295                 dev_err(tas_priv->dev,
 296                         "File size not match, %d %u", (int)fmw->size,
 297                         fw_hdr->img_sz);
 298                 tas_priv->fw_state = TASDEVICE_DSP_FW_FAIL;
 299                 ret = -EINVAL;
 300                 goto out;
 301         }
 302
 303         fw_hdr->checksum = be32_to_cpup((__be32 *)&buf[offset]);
 304         offset += 4;
 305         fw_hdr->binary_version_num = be32_to_cpup((__be32 *)&buf[offset]);
 306         if (fw_hdr->binary_version_num < 0x103) {
 307                 dev_err(tas_priv->dev, "File version 0x%04x is too low",
 308                         fw_hdr->binary_version_num);
 309                 tas_priv->fw_state = TASDEVICE_DSP_FW_FAIL;
 310                 ret = -EINVAL;
 311                 goto out;
 312         }
 313         offset += 4;
 314         fw_hdr->drv_fw_version = be32_to_cpup((__be32 *)&buf[offset]);
 315         offset += 8;
 316         fw_hdr->plat_type = buf[offset];
 317         offset += 1;
 318         fw_hdr->dev_family = buf[offset];
 319         offset += 1;
 320         fw_hdr->reserve = buf[offset];
 321         offset += 1;
 322         fw_hdr->ndev = buf[offset];
 323         offset += 1;
 324         if (fw_hdr->ndev != tas_priv->ndev) {
 325                 dev_err(tas_priv->dev,
 326                         "ndev(%u) in rcabin mismatch ndev(%u) in DTS\n",
 327                         fw_hdr->ndev, tas_priv->ndev);
 328                 tas_priv->fw_state = TASDEVICE_DSP_FW_FAIL;
 329                 ret = -EINVAL;
 330                 goto out;
 331         }
 332         if (offset + TASDEVICE_DEVICE_SUM > fw_hdr->img_sz) {
 333                 dev_err(tas_priv->dev, "rca_ready: Out of boundary!\n");
 334                 ret = -EINVAL;
 335                 tas_priv->fw_state = TASDEVICE_DSP_FW_FAIL;
 336                 goto out;
 337         }
 338
 339         for (i = 0; i < TASDEVICE_DEVICE_SUM; i++, offset++)
 340                 fw_hdr->devs[i] = buf[offset];
 341
 342         fw_hdr->nconfig = be32_to_cpup((__be32 *)&buf[offset]);
 343         offset += 4;
 344
 345         for (i = 0; i < TASDEVICE_CONFIG_SUM; i++) {
 346                 fw_hdr->config_size[i] = be32_to_cpup((__be32 *)&buf[offset]);
 347                 offset += 4;
 348                 total_config_sz += fw_hdr->config_size[i];
 349         }
 350
 351         if (fw_hdr->img_sz - total_config_sz != (unsigned int)offset) {
 352                 dev_err(tas_priv->dev, "Bin file error!\n");
 353                 ret = -EINVAL;
 354                 tas_priv->fw_state = TASDEVICE_DSP_FW_FAIL;
 355                 goto out;
 356         }
 357
 358         cfg_info = kcalloc(fw_hdr->nconfig, sizeof(*cfg_info), GFP_KERNEL);
 359         if (!cfg_info) {
 360                 ret = -ENOMEM;
 361                 tas_priv->fw_state = TASDEVICE_DSP_FW_FAIL;
 362                 goto out;
 363         }
 364         rca->cfg_info = cfg_info;
 365         rca->ncfgs = 0;
 366         for (i = 0; i < (int)fw_hdr->nconfig; i++) {
 367                 rca->ncfgs += 1;
 368                 cfg_info[i] = tasdevice_add_config(tas_priv, &buf[offset],
 369                         fw_hdr->config_size[i], &ret);
 370                 if (ret) {
 371                         tas_priv->fw_state = TASDEVICE_DSP_FW_FAIL;
 372                         goto out;
 373                 }
 374                 offset += (int)fw_hdr->config_size[i];
 375         }
 376 out:
 377         return ret;
 378 }
 379 EXPORT_SYMBOL_NS_GPL(tasdevice_rca_parser, SND_SOC_TAS2781_FMWLIB);
 380
 381 /* fixed m68k compiling issue: mapping table can save code field */
 382 static unsigned char map_dev_idx(struct tasdevice_fw *tas_fmw,
 383         struct tasdev_blk *block)
 384 {
 385
 386         struct blktyp_devidx_map *p =
 387                 (struct blktyp_devidx_map *)non_ppc3_mapping_table;
 388         struct tasdevice_dspfw_hdr *fw_hdr = &(tas_fmw->fw_hdr);
 389         struct tasdevice_fw_fixed_hdr *fw_fixed_hdr = &(fw_hdr->fixed_hdr);
 390
 391         int i, n = ARRAY_SIZE(non_ppc3_mapping_table);
 392         unsigned char dev_idx = 0;
 393
 394         if (fw_fixed_hdr->ppcver >= PPC3_VERSION_TAS2781) {
 395                 p = (struct blktyp_devidx_map *)ppc3_tas2781_mapping_table;
 396                 n = ARRAY_SIZE(ppc3_tas2781_mapping_table);
 397         } else if (fw_fixed_hdr->ppcver >= PPC3_VERSION) {
 398                 p = (struct blktyp_devidx_map *)ppc3_mapping_table;
 399                 n = ARRAY_SIZE(ppc3_mapping_table);
 400         }
 401
 402         for (i = 0; i < n; i++) {
 403                 if (block->type == p[i].blktyp) {
 404                         dev_idx = p[i].dev_idx;
 405                         break;
 406                 }
 407         }
 408
 409         return dev_idx;
 410 }
 411
 412 static int fw_parse_block_data_kernel(struct tasdevice_fw *tas_fmw,
 413         struct tasdev_blk *block, const struct firmware *fmw, int offset)
 414 {
 415         const unsigned char *data = fmw->data;
 416
 417         if (offset + 16 > fmw->size) {
 418                 dev_err(tas_fmw->dev, "%s: File Size error\n", __func__);
 419                 offset = -EINVAL;
 420                 goto out;
 421         }
 422
 423         /* convert data[offset], data[offset + 1], data[offset + 2] and
 424          * data[offset + 3] into host
 425          */
 426         block->type = be32_to_cpup((__be32 *)&data[offset]);
 427         offset += 4;
 428
 429         block->is_pchksum_present = data[offset];
 430         offset++;
 431
 432         block->pchksum = data[offset];
 433         offset++;
 434
 435         block->is_ychksum_present = data[offset];
 436         offset++;
 437
 438         block->ychksum = data[offset];
 439         offset++;
 440
 441         block->blk_size = be32_to_cpup((__be32 *)&data[offset]);
 442         offset += 4;
 443
 444         block->nr_subblocks = be32_to_cpup((__be32 *)&data[offset]);
 445         offset += 4;
 446
 447         /* fixed m68k compiling issue:
 448          * 1. mapping table can save code field.
 449          * 2. storing the dev_idx as a member of block can reduce unnecessary
 450          *    time and system resource comsumption of dev_idx mapping every
 451          *    time the block data writing to the dsp.
 452          */
 453         block->dev_idx = map_dev_idx(tas_fmw, block);
 454
 455         if (offset + block->blk_size > fmw->size) {
 456                 dev_err(tas_fmw->dev, "%s: nSublocks error\n", __func__);
 457                 offset = -EINVAL;
 458                 goto out;
 459         }
 460         /* instead of kzalloc+memcpy */
 461         block->data = kmemdup(&data[offset], block->blk_size, GFP_KERNEL);
 462         if (!block->data) {
 463                 offset = -ENOMEM;
 464                 goto out;
 465         }
 466         offset += block->blk_size;
 467
 468 out:
 469         return offset;
 470 }
 471
 472 static int fw_parse_data_kernel(struct tasdevice_fw *tas_fmw,
 473         struct tasdevice_data *img_data, const struct firmware *fmw,
 474         int offset)
 475 {
 476         const unsigned char *data = fmw->data;
 477         struct tasdev_blk *blk;
 478         unsigned int i;
 479
 480         if (offset + 4 > fmw->size) {
 481                 dev_err(tas_fmw->dev, "%s: File Size error\n", __func__);
 482                 offset = -EINVAL;
 483                 goto out;
 484         }
 485         img_data->nr_blk = be32_to_cpup((__be32 *)&data[offset]);
 486         offset += 4;
 487
 488         img_data->dev_blks = kcalloc(img_data->nr_blk,
 489                 sizeof(struct tasdev_blk), GFP_KERNEL);
 490         if (!img_data->dev_blks) {
 491                 offset = -ENOMEM;
 492                 goto out;
 493         }
 494
 495         for (i = 0; i < img_data->nr_blk; i++) {
 496                 blk = &(img_data->dev_blks[i]);
 497                 offset = fw_parse_block_data_kernel(tas_fmw, blk, fmw, offset);
 498                 if (offset < 0) {
 499                         offset = -EINVAL;
 500                         break;
 501                 }
 502         }
 503
 504 out:
 505         return offset;
 506 }
 507
 508 static int fw_parse_program_data_kernel(
 509         struct tasdevice_priv *tas_priv, struct tasdevice_fw *tas_fmw,
 510         const struct firmware *fmw, int offset)
 511 {
 512         struct tasdevice_prog *program;
 513         unsigned int i;
 514
 515         for (i = 0; i < tas_fmw->nr_programs; i++) {
 516                 program = &(tas_fmw->programs[i]);
 517                 if (offset + 72 > fmw->size) {
 518                         dev_err(tas_priv->dev, "%s: mpName error\n", __func__);
 519                         offset = -EINVAL;
 520                         goto out;
 521                 }
 522                 /*skip 72 unused byts*/
 523                 offset += 72;
 524
 525                 offset = fw_parse_data_kernel(tas_fmw, &(program->dev_data),
 526                         fmw, offset);
 527                 if (offset < 0)
 528                         goto out;
 529         }
 530
 531 out:
 532         return offset;
 533 }
 534
 535 static int fw_parse_configuration_data_kernel(
 536         struct tasdevice_priv *tas_priv,
 537         struct tasdevice_fw *tas_fmw, const struct firmware *fmw, int offset)
 538 {
 539         const unsigned char *data = fmw->data;
 540         struct tasdevice_config *config;
 541         unsigned int i;
 542
 543         for (i = 0; i < tas_fmw->nr_configurations; i++) {
 544                 config = &(tas_fmw->configs[i]);
 545                 if (offset + 80 > fmw->size) {
 546                         dev_err(tas_priv->dev, "%s: mpName error\n", __func__);
 547                         offset = -EINVAL;
 548                         goto out;
 549                 }
 550                 memcpy(config->name, &data[offset], 64);
 551                 /*skip extra 16 bytes*/
 552                 offset += 80;
 553
 554                 offset = fw_parse_data_kernel(tas_fmw, &(config->dev_data),
 555                         fmw, offset);
 556                 if (offset < 0)
 557                         goto out;
 558         }
 559
 560 out:
 561         return offset;
 562 }
 563
 564 static int fw_parse_variable_header_kernel(
 565         struct tasdevice_priv *tas_priv, const struct firmware *fmw,
 566         int offset)
 567 {
 568         struct tasdevice_fw *tas_fmw = tas_priv->fmw;
 569         struct tasdevice_dspfw_hdr *fw_hdr = &(tas_fmw->fw_hdr);
 570         struct tasdevice_prog *program;
 571         struct tasdevice_config *config;
 572         const unsigned char *buf = fmw->data;
 573         unsigned short max_confs;
 574         unsigned int i;
 575
 576         if (offset + 12 + 4 * TASDEVICE_MAXPROGRAM_NUM_KERNEL > fmw->size) {
 577                 dev_err(tas_priv->dev, "%s: File Size error\n", __func__);
 578                 offset = -EINVAL;
 579                 goto out;
 580         }
 581         fw_hdr->device_family = be16_to_cpup((__be16 *)&buf[offset]);
 582         if (fw_hdr->device_family != 0) {
 583                 dev_err(tas_priv->dev, "%s:not TAS device\n", __func__);
 584                 offset = -EINVAL;
 585                 goto out;
 586         }
 587         offset += 2;
 588         fw_hdr->device = be16_to_cpup((__be16 *)&buf[offset]);
 589         if (fw_hdr->device >= TASDEVICE_DSP_TAS_MAX_DEVICE ||
 590                 fw_hdr->device == 6) {
 591                 dev_err(tas_priv->dev, "Unsupported dev %d\n", fw_hdr->device);
 592                 offset = -EINVAL;
 593                 goto out;
 594         }
 595         offset += 2;
 596         fw_hdr->ndev = deviceNumber[fw_hdr->device];
 597
 598         if (fw_hdr->ndev != tas_priv->ndev) {
 599                 dev_err(tas_priv->dev,
 600                         "%s: ndev(%u) in dspbin mismatch ndev(%u) in DTS\n",
 601                         __func__, fw_hdr->ndev, tas_priv->ndev);
 602                 offset = -EINVAL;
 603                 goto out;
 604         }
 605
 606         tas_fmw->nr_programs = be32_to_cpup((__be32 *)&buf[offset]);
 607         offset += 4;
 608
 609         if (tas_fmw->nr_programs == 0 || tas_fmw->nr_programs >
 610                 TASDEVICE_MAXPROGRAM_NUM_KERNEL) {
 611                 dev_err(tas_priv->dev, "mnPrograms is invalid\n");
 612                 offset = -EINVAL;
 613                 goto out;
 614         }
 615
 616         tas_fmw->programs = kcalloc(tas_fmw->nr_programs,
 617                 sizeof(struct tasdevice_prog), GFP_KERNEL);
 618         if (!tas_fmw->programs) {
 619                 offset = -ENOMEM;
 620                 goto out;
 621         }
 622
 623         for (i = 0; i < tas_fmw->nr_programs; i++) {
 624                 program = &(tas_fmw->programs[i]);
 625                 program->prog_size = be32_to_cpup((__be32 *)&buf[offset]);
 626                 offset += 4;
 627         }
 628
 629         /* Skip the unused prog_size */
 630         offset += 4 * (TASDEVICE_MAXPROGRAM_NUM_KERNEL - tas_fmw->nr_programs);
 631
 632         tas_fmw->nr_configurations = be32_to_cpup((__be32 *)&buf[offset]);
 633         offset += 4;
 634
 635         /* The max number of config in firmware greater than 4 pieces of
 636          * tas2781s is different from the one lower than 4 pieces of
 637          * tas2781s.
 638          */
 639         max_confs = (fw_hdr->ndev >= 4) ?
 640                 TASDEVICE_MAXCONFIG_NUM_KERNEL_MULTIPLE_AMPS :
 641                 TASDEVICE_MAXCONFIG_NUM_KERNEL;
 642         if (tas_fmw->nr_configurations == 0 ||
 643                 tas_fmw->nr_configurations > max_confs) {
 644                 dev_err(tas_priv->dev, "%s: Conf is invalid\n", __func__);
 645                 offset = -EINVAL;
 646                 goto out;
 647         }
 648
 649         if (offset + 4 * max_confs > fmw->size) {
 650                 dev_err(tas_priv->dev, "%s: mpConfigurations err\n", __func__);
 651                 offset = -EINVAL;
 652                 goto out;
 653         }
 654
 655         tas_fmw->configs = kcalloc(tas_fmw->nr_configurations,
 656                 sizeof(struct tasdevice_config), GFP_KERNEL);
 657         if (!tas_fmw->configs) {
 658                 offset = -ENOMEM;
 659                 goto out;
 660         }
 661
 662         for (i = 0; i < tas_fmw->nr_programs; i++) {
 663                 config = &(tas_fmw->configs[i]);
 664                 config->cfg_size = be32_to_cpup((__be32 *)&buf[offset]);
 665                 offset += 4;
 666         }
 667
 668         /* Skip the unused configs */
 669         offset += 4 * (max_confs - tas_fmw->nr_programs);
 670
 671 out:
 672         return offset;
 673 }
 674
 675 static int tasdevice_process_block(void *context, unsigned char *data,
 676         unsigned char dev_idx, int sublocksize)
 677 {
 678         struct tasdevice_priv *tas_priv = (struct tasdevice_priv *)context;
 679         int subblk_offset, chn, chnend, rc;
 680         unsigned char subblk_typ = data[1];
 681         int blktyp = dev_idx & 0xC0;
 682         int idx = dev_idx & 0x3F;
 683         bool is_err = false;
 684
 685         if (idx) {
 686                 chn = idx - 1;
 687                 chnend = idx;
 688         } else {
 689                 chn = 0;
 690                 chnend = tas_priv->ndev;
 691         }
 692
 693         for (; chn < chnend; chn++) {
 694                 if (tas_priv->tasdevice[chn].is_loading == false)
 695                         continue;
 696
 697                 is_err = false;
 698                 subblk_offset = 2;
 699                 switch (subblk_typ) {
 700                 case TASDEVICE_CMD_SING_W: {
 701                         int i;
 702                         unsigned short len = be16_to_cpup((__be16 *)&data[2]);
 703
 704                         subblk_offset += 2;
 705                         if (subblk_offset + 4 * len > sublocksize) {
 706                                 dev_err(tas_priv->dev,
 707                                         "process_block: Out of boundary\n");
 708                                 is_err = true;
 709                                 break;
 710                         }
 711
 712                         for (i = 0; i < len; i++) {
 713                                 rc = tasdevice_dev_write(tas_priv, chn,
 714                                         TASDEVICE_REG(data[subblk_offset],
 715                                                 data[subblk_offset + 1],
 716                                                 data[subblk_offset + 2]),
 717                                         data[subblk_offset + 3]);
 718                                 if (rc < 0) {
 719                                         is_err = true;
 720                                         dev_err(tas_priv->dev,
 721                                         "process_block: single write error\n");
 722                                 }
 723                                 subblk_offset += 4;
 724                         }
 725                 }
 726                         break;
 727                 case TASDEVICE_CMD_BURST: {
 728                         unsigned short len = be16_to_cpup((__be16 *)&data[2]);
 729
 730                         subblk_offset += 2;
 731                         if (subblk_offset + 4 + len > sublocksize) {
 732                                 dev_err(tas_priv->dev,
 733                                         "%s: BST Out of boundary\n",
 734                                         __func__);
 735                                 is_err = true;
 736                                 break;
 737                         }
 738                         if (len % 4) {
 739                                 dev_err(tas_priv->dev,
 740                                         "%s:Bst-len(%u)not div by 4\n",
 741                                         __func__, len);
 742                                 break;
 743                         }
 744
 745                         rc = tasdevice_dev_bulk_write(tas_priv, chn,
 746                                 TASDEVICE_REG(data[subblk_offset],
 747                                 data[subblk_offset + 1],
 748                                 data[subblk_offset + 2]),
 749                                 &(data[subblk_offset + 4]), len);
 750                         if (rc < 0) {
 751                                 is_err = true;
 752                                 dev_err(tas_priv->dev,
 753                                         "%s: bulk_write error = %d\n",
 754                                         __func__, rc);
 755                         }
 756                         subblk_offset += (len + 4);
 757                 }
 758                         break;
 759                 case TASDEVICE_CMD_DELAY: {
 760                         unsigned int sleep_time = 0;
 761
 762                         if (subblk_offset + 2 > sublocksize) {
 763                                 dev_err(tas_priv->dev,
 764                                         "%s: delay Out of boundary\n",
 765                                         __func__);
 766                                 is_err = true;
 767                                 break;
 768                         }
 769                         sleep_time = be16_to_cpup((__be16 *)&data[2]) * 1000;
 770                         usleep_range(sleep_time, sleep_time + 50);
 771                         subblk_offset += 2;
 772                 }
 773                         break;
 774                 case TASDEVICE_CMD_FIELD_W:
 775                         if (subblk_offset + 6 > sublocksize) {
 776                                 dev_err(tas_priv->dev,
 777                                         "%s: bit write Out of boundary\n",
 778                                         __func__);
 779                                 is_err = true;
 780                                 break;
 781                         }
 782                         rc = tasdevice_dev_update_bits(tas_priv, chn,
 783                                 TASDEVICE_REG(data[subblk_offset + 2],
 784                                 data[subblk_offset + 3],
 785                                 data[subblk_offset + 4]),
 786                                 data[subblk_offset + 1],
 787                                 data[subblk_offset + 5]);
 788                         if (rc < 0) {
 789                                 is_err = true;
 790                                 dev_err(tas_priv->dev,
 791                                         "%s: update_bits error = %d\n",
 792                                         __func__, rc);
 793                         }
 794                         subblk_offset += 6;
 795                         break;
 796                 default:
 797                         break;
 798                 }
 799                 if (is_err == true && blktyp != 0) {
 800                         if (blktyp == 0x80) {
 801                                 tas_priv->tasdevice[chn].cur_prog = -1;
 802                                 tas_priv->tasdevice[chn].cur_conf = -1;
 803                         } else
 804                                 tas_priv->tasdevice[chn].cur_conf = -1;
 805                 }
 806         }
 807
 808         return subblk_offset;
 809 }
 810
 811 void tasdevice_select_cfg_blk(void *pContext, int conf_no,
 812         unsigned char block_type)
 813 {
 814         struct tasdevice_priv *tas_priv = (struct tasdevice_priv *) pContext;
 815         struct tasdevice_rca *rca = &(tas_priv->rcabin);
 816         struct tasdevice_config_info **cfg_info = rca->cfg_info;
 817         struct tasdev_blk_data **blk_data;
 818         int j, k, chn, chnend;
 819
 820         if (conf_no >= rca->ncfgs || conf_no < 0 || !cfg_info) {
 821                 dev_err(tas_priv->dev, "conf_no should be not more than %u\n",
 822                         rca->ncfgs);
 823                 return;
 824         }
 825         blk_data = cfg_info[conf_no]->blk_data;
 826
 827         for (j = 0; j < (int)cfg_info[conf_no]->real_nblocks; j++) {
 828                 unsigned int length = 0, rc = 0;
 829
 830                 if (block_type > 5 || block_type < 2) {
 831                         dev_err(tas_priv->dev,
 832                                 "block_type should be in range from 2 to 5\n");
 833                         break;
 834                 }
 835                 if (block_type != blk_data[j]->block_type)
 836                         continue;
 837
 838                 for (k = 0; k < (int)blk_data[j]->n_subblks; k++) {
 839                         if (blk_data[j]->dev_idx) {
 840                                 chn = blk_data[j]->dev_idx - 1;
 841                                 chnend = blk_data[j]->dev_idx;
 842                         } else {
 843                                 chn = 0;
 844                                 chnend = tas_priv->ndev;
 845                         }
 846                         for (; chn < chnend; chn++)
 847                                 tas_priv->tasdevice[chn].is_loading = true;
 848
 849                         rc = tasdevice_process_block(tas_priv,
 850                                 blk_data[j]->regdata + length,
 851                                 blk_data[j]->dev_idx,
 852                                 blk_data[j]->block_size - length);
 853                         length += rc;
 854                         if (blk_data[j]->block_size < length) {
 855                                 dev_err(tas_priv->dev,
 856                                         "%s: %u %u out of boundary\n",
 857                                         __func__, length,
 858                                         blk_data[j]->block_size);
 859                                 break;
 860                         }
 861                 }
 862                 if (length != blk_data[j]->block_size)
 863                         dev_err(tas_priv->dev, "%s: %u %u size is not same\n",
 864                                 __func__, length, blk_data[j]->block_size);
 865         }
 866 }
 867 EXPORT_SYMBOL_NS_GPL(tasdevice_select_cfg_blk, SND_SOC_TAS2781_FMWLIB);
 868
 869 static int tasdevice_load_block_kernel(
 870         struct tasdevice_priv *tasdevice, struct tasdev_blk *block)
 871 {
 872         const unsigned int blk_size = block->blk_size;
 873         unsigned int i, length;
 874         unsigned char *data = block->data;
 875
 876         for (i = 0, length = 0; i < block->nr_subblocks; i++) {
 877                 int rc = tasdevice_process_block(tasdevice, data + length,
 878                         block->dev_idx, blk_size - length);
 879                 if (rc < 0) {
 880                         dev_err(tasdevice->dev,
 881                                 "%s: %u %u sublock write error\n",
 882                                 __func__, length, blk_size);
 883                         break;
 884                 }
 885                 length += (unsigned int)rc;
 886                 if (blk_size < length) {
 887                         dev_err(tasdevice->dev, "%s: %u %u out of boundary\n",
 888                                 __func__, length, blk_size);
 889                         break;
 890                 }
 891         }
 892
 893         return 0;
 894 }
 895
 896 static int fw_parse_variable_hdr(struct tasdevice_priv
 897         *tas_priv, struct tasdevice_dspfw_hdr *fw_hdr,
 898         const struct firmware *fmw, int offset)
 899 {
 900         const unsigned char *buf = fmw->data;
 901         int len = strlen((char *)&buf[offset]);
 902
 903         len++;
 904
 905         if (offset + len + 8 > fmw->size) {
 906                 dev_err(tas_priv->dev, "%s: File Size error\n", __func__);
 907                 offset = -EINVAL;
 908                 goto out;
 909         }
 910
 911         offset += len;
 912
 913         fw_hdr->device_family = be32_to_cpup((__be32 *)&buf[offset]);
 914         if (fw_hdr->device_family != 0) {
 915                 dev_err(tas_priv->dev, "%s: not TAS device\n", __func__);
 916                 offset = -EINVAL;
 917                 goto out;
 918         }
 919         offset += 4;
 920
 921         fw_hdr->device = be32_to_cpup((__be32 *)&buf[offset]);
 922         if (fw_hdr->device >= TASDEVICE_DSP_TAS_MAX_DEVICE ||
 923                 fw_hdr->device == 6) {
 924                 dev_err(tas_priv->dev, "Unsupported dev %d\n", fw_hdr->device);
 925                 offset = -EINVAL;
 926                 goto out;
 927         }
 928         offset += 4;
 929         fw_hdr->ndev = deviceNumber[fw_hdr->device];
 930
 931 out:
 932         return offset;
 933 }
 934
 935 static int fw_parse_variable_header_git(struct tasdevice_priv
 936         *tas_priv, const struct firmware *fmw, int offset)
 937 {
 938         struct tasdevice_fw *tas_fmw = tas_priv->fmw;
 939         struct tasdevice_dspfw_hdr *fw_hdr = &(tas_fmw->fw_hdr);
 940
 941         offset = fw_parse_variable_hdr(tas_priv, fw_hdr, fmw, offset);
 942         if (offset < 0)
 943                 goto out;
 944         if (fw_hdr->ndev != tas_priv->ndev) {
 945                 dev_err(tas_priv->dev,
 946                         "%s: ndev(%u) in dspbin mismatch ndev(%u) in DTS\n",
 947                         __func__, fw_hdr->ndev, tas_priv->ndev);
 948                 offset = -EINVAL;
 949         }
 950
 951 out:
 952         return offset;
 953 }
 954
 955 static int fw_parse_block_data(struct tasdevice_fw *tas_fmw,
 956         struct tasdev_blk *block, const struct firmware *fmw, int offset)
 957 {
 958         unsigned char *data = (unsigned char *)fmw->data;
 959         int n;
 960
 961         if (offset + 8 > fmw->size) {
 962                 dev_err(tas_fmw->dev, "%s: Type error\n", __func__);
 963                 offset = -EINVAL;
 964                 goto out;
 965         }
 966         block->type = be32_to_cpup((__be32 *)&data[offset]);
 967         offset += 4;
 968
 969         if (tas_fmw->fw_hdr.fixed_hdr.drv_ver >= PPC_DRIVER_CRCCHK) {
 970                 if (offset + 8 > fmw->size) {
 971                         dev_err(tas_fmw->dev, "PChkSumPresent error\n");
 972                         offset = -EINVAL;
 973                         goto out;
 974                 }
 975                 block->is_pchksum_present = data[offset];
 976                 offset++;
 977
 978                 block->pchksum = data[offset];
 979                 offset++;
 980
 981                 block->is_ychksum_present = data[offset];
 982                 offset++;
 983
 984                 block->ychksum = data[offset];
 985                 offset++;
 986         } else {
 987                 block->is_pchksum_present = 0;
 988                 block->is_ychksum_present = 0;
 989         }
 990
 991         block->nr_cmds = be32_to_cpup((__be32 *)&data[offset]);
 992         offset += 4;
 993
 994         n = block->nr_cmds * 4;
 995         if (offset + n > fmw->size) {
 996                 dev_err(tas_fmw->dev,
 997                         "%s: File Size(%lu) error offset = %d n = %d\n",
 998                         __func__, (unsigned long)fmw->size, offset, n);
 999                 offset = -EINVAL;
1000                 goto out;
1001         }
1002         /* instead of kzalloc+memcpy */
1003         block->data = kmemdup(&data[offset], n, GFP_KERNEL);
1004         if (!block->data) {
1005                 offset = -ENOMEM;
1006                 goto out;
1007         }
1008         offset += n;
1009
1010 out:
1011         return offset;
1012 }
1013
1014 /* When parsing error occurs, all the memory resource will be released
1015  * in the end of tasdevice_rca_ready.
1016  */
1017 static int fw_parse_data(struct tasdevice_fw *tas_fmw,
1018         struct tasdevice_data *img_data, const struct firmware *fmw,
1019         int offset)
1020 {
1021         const unsigned char *data = (unsigned char *)fmw->data;
1022         struct tasdev_blk *blk;
1023         unsigned int i;
1024         int n;
1025
1026         if (offset + 64 > fmw->size) {
1027                 dev_err(tas_fmw->dev, "%s: Name error\n", __func__);
1028                 offset = -EINVAL;
1029                 goto out;
1030         }
1031         memcpy(img_data->name, &data[offset], 64);
1032         offset += 64;
1033
1034         n = strlen((char *)&data[offset]);
1035         n++;
1036         if (offset + n + 2 > fmw->size) {
1037                 dev_err(tas_fmw->dev, "%s: Description error\n", __func__);
1038                 offset = -EINVAL;
1039                 goto out;
1040         }
1041         offset += n;
1042         img_data->nr_blk = be16_to_cpup((__be16 *)&data[offset]);
1043         offset += 2;
1044
1045         img_data->dev_blks = kcalloc(img_data->nr_blk,
1046                 sizeof(struct tasdev_blk), GFP_KERNEL);
1047         if (!img_data->dev_blks) {
1048                 offset = -ENOMEM;
1049                 goto out;
1050         }
1051         for (i = 0; i < img_data->nr_blk; i++) {
1052                 blk = &(img_data->dev_blks[i]);
1053                 offset = fw_parse_block_data(tas_fmw, blk, fmw, offset);
1054                 if (offset < 0) {
1055                         offset = -EINVAL;
1056                         goto out;
1057                 }
1058         }
1059
1060 out:
1061         return offset;
1062 }
1063
1064 /* When parsing error occurs, all the memory resource will be released
1065  * in the end of tasdevice_rca_ready.
1066  */
1067 static int fw_parse_program_data(struct tasdevice_priv *tas_priv,
1068         struct tasdevice_fw *tas_fmw, const struct firmware *fmw, int offset)
1069 {
1070         unsigned char *buf = (unsigned char *)fmw->data;
1071         struct tasdevice_prog *program;
1072         int i;
1073
1074         if (offset + 2 > fmw->size) {
1075                 dev_err(tas_priv->dev, "%s: File Size error\n", __func__);
1076                 offset = -EINVAL;
1077                 goto out;
1078         }
1079         tas_fmw->nr_programs = be16_to_cpup((__be16 *)&buf[offset]);
1080         offset += 2;
1081
1082         if (tas_fmw->nr_programs == 0) {
1083                 /*Not error in calibration Data file, return directly*/
1084                 dev_info(tas_priv->dev, "%s: No Programs data, maybe calbin\n",
1085                         __func__);
1086                 goto out;
1087         }
1088
1089         tas_fmw->programs =
1090                 kcalloc(tas_fmw->nr_programs, sizeof(struct tasdevice_prog),
1091                         GFP_KERNEL);
1092         if (!tas_fmw->programs) {
1093                 offset = -ENOMEM;
1094                 goto out;
1095         }
1096         for (i = 0; i < tas_fmw->nr_programs; i++) {
1097                 int n = 0;
1098
1099                 program = &(tas_fmw->programs[i]);
1100                 if (offset + 64 > fmw->size) {
1101                         dev_err(tas_priv->dev, "%s: mpName error\n", __func__);
1102                         offset = -EINVAL;
1103                         goto out;
1104                 }
1105                 offset += 64;
1106
1107                 n = strlen((char *)&buf[offset]);
1108                 /* skip '\0' and 5 unused bytes */
1109                 n += 6;
1110                 if (offset + n > fmw->size) {
1111                         dev_err(tas_priv->dev, "Description err\n");
1112                         offset = -EINVAL;
1113                         goto out;
1114                 }
1115
1116                 offset += n;
1117
1118                 offset = fw_parse_data(tas_fmw, &(program->dev_data), fmw,
1119                         offset);
1120                 if (offset < 0)
1121                         goto out;
1122         }
1123
1124 out:
1125         return offset;
1126 }
1127
1128 /* When parsing error occurs, all the memory resource will be released
1129  * in the end of tasdevice_rca_ready.
1130  */
1131 static int fw_parse_configuration_data(
1132         struct tasdevice_priv *tas_priv,
1133         struct tasdevice_fw *tas_fmw,
1134         const struct firmware *fmw, int offset)
1135 {
1136         unsigned char *data = (unsigned char *)fmw->data;
1137         struct tasdevice_config *config;
1138         unsigned int i;
1139         int n;
1140
1141         if (offset + 2 > fmw->size) {
1142                 dev_err(tas_priv->dev, "%s: File Size error\n", __func__);
1143                 offset = -EINVAL;
1144                 goto out;
1145         }
1146         tas_fmw->nr_configurations = be16_to_cpup((__be16 *)&data[offset]);
1147         offset += 2;
1148
1149         if (tas_fmw->nr_configurations == 0) {
1150                 dev_err(tas_priv->dev, "%s: Conf is zero\n", __func__);
1151                 /*Not error for calibration Data file, return directly*/
1152                 goto out;
1153         }
1154         tas_fmw->configs = kcalloc(tas_fmw->nr_configurations,
1155                         sizeof(struct tasdevice_config), GFP_KERNEL);
1156         if (!tas_fmw->configs) {
1157                 offset = -ENOMEM;
1158                 goto out;
1159         }
1160         for (i = 0; i < tas_fmw->nr_configurations; i++) {
1161                 config = &(tas_fmw->configs[i]);
1162                 if (offset + 64 > fmw->size) {
1163                         dev_err(tas_priv->dev, "File Size err\n");
1164                         offset = -EINVAL;
1165                         goto out;
1166                 }
1167                 memcpy(config->name, &data[offset], 64);
1168                 offset += 64;
1169
1170                 n = strlen((char *)&data[offset]);
1171                 n += 15;
1172                 if (offset + n > fmw->size) {
1173                         dev_err(tas_priv->dev, "Description err\n");
1174                         offset = -EINVAL;
1175                         goto out;
1176                 }
1177
1178                 offset += n;
1179
1180                 offset = fw_parse_data(tas_fmw, &(config->dev_data),
1181                         fmw, offset);
1182                 if (offset < 0)
1183                         goto out;
1184         }
1185
1186 out:
1187         return offset;
1188 }
1189
1190 static bool check_inpage_yram_rg(struct tas_crc *cd,
1191         unsigned char reg, unsigned char len)
1192 {
1193         bool in = false;
1194
1195
1196         if (reg <= TAS2781_YRAM5_END_REG &&
1197                 reg >= TAS2781_YRAM5_START_REG) {
1198                 if (reg + len > TAS2781_YRAM5_END_REG)
1199                         cd->len = TAS2781_YRAM5_END_REG - reg + 1;
1200                 else
1201                         cd->len = len;
1202                 cd->offset = reg;
1203                 in = true;
1204         } else if (reg < TAS2781_YRAM5_START_REG) {
1205                 if (reg + len > TAS2781_YRAM5_START_REG) {
1206                         cd->offset = TAS2781_YRAM5_START_REG;
1207                         cd->len = len - TAS2781_YRAM5_START_REG + reg;
1208                         in = true;
1209                 }
1210         }
1211
1212         return in;
1213 }
1214
1215 static bool check_inpage_yram_bk1(struct tas_crc *cd,
1216         unsigned char page, unsigned char reg, unsigned char len)
1217 {
1218         bool in = false;
1219
1220         if (page == TAS2781_YRAM1_PAGE) {
1221                 if (reg >= TAS2781_YRAM1_START_REG) {
1222                         cd->offset = reg;
1223                         cd->len = len;
1224                         in = true;
1225                 } else if (reg + len > TAS2781_YRAM1_START_REG) {
1226                         cd->offset = TAS2781_YRAM1_START_REG;
1227                         cd->len = len - TAS2781_YRAM1_START_REG + reg;
1228                         in = true;
1229                 }
1230         } else if (page == TAS2781_YRAM3_PAGE)
1231                 in = check_inpage_yram_rg(cd, reg, len);
1232
1233         return in;
1234 }
1235
1236 /* Return Code:
1237  * true -- the registers are in the inpage yram
1238  * false -- the registers are NOT in the inpage yram
1239  */
1240 static bool check_inpage_yram(struct tas_crc *cd, unsigned char book,
1241         unsigned char page, unsigned char reg, unsigned char len)
1242 {
1243         bool in = false;
1244
1245         if (book == TAS2781_YRAM_BOOK1) {
1246                 in = check_inpage_yram_bk1(cd, page, reg, len);
1247                 goto end;
1248         }
1249         if (book == TAS2781_YRAM_BOOK2 && page == TAS2781_YRAM5_PAGE)
1250                 in = check_inpage_yram_rg(cd, reg, len);
1251
1252 end:
1253         return in;
1254 }
1255
1256 static bool check_inblock_yram_bk(struct tas_crc *cd,
1257         unsigned char page, unsigned char reg, unsigned char len)
1258 {
1259         bool in = false;
1260
1261         if ((page >= TAS2781_YRAM4_START_PAGE &&
1262                 page <= TAS2781_YRAM4_END_PAGE) ||
1263                 (page >= TAS2781_YRAM2_START_PAGE &&
1264                 page <= TAS2781_YRAM2_END_PAGE)) {
1265                 if (reg <= TAS2781_YRAM2_END_REG &&
1266                         reg >= TAS2781_YRAM2_START_REG) {
1267                         cd->offset = reg;
1268                         cd->len = len;
1269                         in = true;
1270                 } else if (reg < TAS2781_YRAM2_START_REG) {
1271                         if (reg + len - 1 >= TAS2781_YRAM2_START_REG) {
1272                                 cd->offset = TAS2781_YRAM2_START_REG;
1273                                 cd->len = reg + len - TAS2781_YRAM2_START_REG;
1274                                 in = true;
1275                         }
1276                 }
1277         }
1278
1279         return in;
1280 }
1281
1282 /* Return Code:
1283  * true -- the registers are in the inblock yram
1284  * false -- the registers are NOT in the inblock yram
1285  */
1286 static bool check_inblock_yram(struct tas_crc *cd, unsigned char book,
1287         unsigned char page, unsigned char reg, unsigned char len)
1288 {
1289         bool in = false;
1290
1291         if (book == TAS2781_YRAM_BOOK1 || book == TAS2781_YRAM_BOOK2)
1292                 in = check_inblock_yram_bk(cd, page, reg, len);
1293
1294         return in;
1295 }
1296
1297 static bool check_yram(struct tas_crc *cd, unsigned char book,
1298         unsigned char page, unsigned char reg, unsigned char len)
1299 {
1300         bool in;
1301
1302         in = check_inpage_yram(cd, book, page, reg, len);
1303         if (in)
1304                 goto end;
1305         in = check_inblock_yram(cd, book, page, reg, len);
1306
1307 end:
1308         return in;
1309 }
1310
1311 static int tasdev_multibytes_chksum(struct tasdevice_priv *tasdevice,
1312         unsigned short chn, unsigned char book, unsigned char page,
1313         unsigned char reg, unsigned int len)
1314 {
1315         struct tas_crc crc_data;
1316         unsigned char crc_chksum = 0;
1317         unsigned char nBuf1[128];
1318         int ret = 0;
1319         int i;
1320         bool in;
1321
1322         if ((reg + len - 1) > 127) {
1323                 ret = -EINVAL;
1324                 dev_err(tasdevice->dev, "firmware error\n");
1325                 goto end;
1326         }
1327
1328         if ((book == TASDEVICE_BOOK_ID(TAS2781_SA_COEFF_SWAP_REG))
1329                 && (page == TASDEVICE_PAGE_ID(TAS2781_SA_COEFF_SWAP_REG))
1330                 && (reg == TASDEVICE_PAGE_REG(TAS2781_SA_COEFF_SWAP_REG))
1331                 && (len == 4)) {
1332                 /*DSP swap command, pass */
1333                 ret = 0;
1334                 goto end;
1335         }
1336
1337         in = check_yram(&crc_data, book, page, reg, len);
1338         if (!in)
1339                 goto end;
1340
1341         if (len == 1) {
1342                 dev_err(tasdevice->dev, "firmware error\n");
1343                 ret = -EINVAL;
1344                 goto end;
1345         }
1346
1347         ret = tasdevice_dev_bulk_read(tasdevice, chn,
1348                 TASDEVICE_REG(book, page, crc_data.offset),
1349                 nBuf1, crc_data.len);
1350         if (ret < 0)
1351                 goto end;
1352
1353         for (i = 0; i < crc_data.len; i++) {
1354                 if ((book == TASDEVICE_BOOK_ID(TAS2781_SA_COEFF_SWAP_REG))
1355                         && (page == TASDEVICE_PAGE_ID(
1356                         TAS2781_SA_COEFF_SWAP_REG))
1357                         && ((i + crc_data.offset)
1358                         >= TASDEVICE_PAGE_REG(TAS2781_SA_COEFF_SWAP_REG))
1359                         && ((i + crc_data.offset)
1360                         <= (TASDEVICE_PAGE_REG(TAS2781_SA_COEFF_SWAP_REG)
1361                         + 4)))
1362                         /*DSP swap command, bypass */
1363                         continue;
1364                 else
1365                         crc_chksum += crc8(tasdevice->crc8_lkp_tbl, &nBuf1[i],
1366                                 1, 0);
1367         }
1368
1369         ret = crc_chksum;
1370
1371 end:
1372         return ret;
1373 }
1374
1375 static int do_singlereg_checksum(struct tasdevice_priv *tasdevice,
1376         unsigned short chl, unsigned char book, unsigned char page,
1377         unsigned char reg, unsigned char val)
1378 {
1379         struct tas_crc crc_data;
1380         unsigned int nData1;
1381         int ret = 0;
1382         bool in;
1383
1384         if ((book == TASDEVICE_BOOK_ID(TAS2781_SA_COEFF_SWAP_REG))
1385                 && (page == TASDEVICE_PAGE_ID(TAS2781_SA_COEFF_SWAP_REG))
1386                 && (reg >= TASDEVICE_PAGE_REG(TAS2781_SA_COEFF_SWAP_REG))
1387                 && (reg <= (TASDEVICE_PAGE_REG(
1388                 TAS2781_SA_COEFF_SWAP_REG) + 4))) {
1389                 /*DSP swap command, pass */
1390                 ret = 0;
1391                 goto end;
1392         }
1393
1394         in = check_yram(&crc_data, book, page, reg, 1);
1395         if (!in)
1396                 goto end;
1397         ret = tasdevice_dev_read(tasdevice, chl,
1398                 TASDEVICE_REG(book, page, reg), &nData1);
1399         if (ret < 0)
1400                 goto end;
1401
1402         if (nData1 != val) {
1403                 dev_err(tasdevice->dev,
1404                         "B[0x%x]P[0x%x]R[0x%x] W[0x%x], R[0x%x]\n",
1405                         book, page, reg, val, nData1);
1406                 tasdevice->tasdevice[chl].err_code |= ERROR_YRAM_CRCCHK;
1407                 ret = -EAGAIN;
1408                 goto end;
1409         }
1410
1411         ret = crc8(tasdevice->crc8_lkp_tbl, &val, 1, 0);
1412
1413 end:
1414         return ret;
1415 }
1416
1417 static void set_err_prg_cfg(unsigned int type, struct tasdevice *dev)
1418 {
1419         if ((type == MAIN_ALL_DEVICES) || (type == MAIN_DEVICE_A)
1420                 || (type == MAIN_DEVICE_B) || (type == MAIN_DEVICE_C)
1421                 || (type == MAIN_DEVICE_D))
1422                 dev->cur_prog = -1;
1423         else
1424                 dev->cur_conf = -1;
1425 }
1426
1427 static int tasdev_bytes_chksum(struct tasdevice_priv *tas_priv,
1428         struct tasdev_blk *block, int chn, unsigned char book,
1429         unsigned char page, unsigned char reg, unsigned int len,
1430         unsigned char val, unsigned char *crc_chksum)
1431 {
1432         int ret;
1433
1434         if (len > 1)
1435                 ret = tasdev_multibytes_chksum(tas_priv, chn, book, page, reg,
1436                         len);
1437         else
1438                 ret = do_singlereg_checksum(tas_priv, chn, book, page, reg,
1439                         val);
1440
1441         if (ret > 0) {
1442                 *crc_chksum += (unsigned char)ret;
1443                 goto end;
1444         }
1445
1446         if (ret != -EAGAIN)
1447                 goto end;
1448
1449         block->nr_retry--;
1450         if (block->nr_retry > 0)
1451                 goto end;
1452
1453         set_err_prg_cfg(block->type, &tas_priv->tasdevice[chn]);
1454
1455 end:
1456         return ret;
1457 }
1458
1459 static int tasdev_multibytes_wr(struct tasdevice_priv *tas_priv,
1460         struct tasdev_blk *block, int chn, unsigned char book,
1461         unsigned char page, unsigned char reg, unsigned char *data,
1462         unsigned int len, unsigned int *nr_cmds,
1463         unsigned char *crc_chksum)
1464 {
1465         int ret;
1466
1467         if (len > 1) {
1468                 ret = tasdevice_dev_bulk_write(tas_priv, chn,
1469                         TASDEVICE_REG(book, page, reg), data + 3, len);
1470                 if (ret < 0)
1471                         goto end;
1472                 if (block->is_ychksum_present)
1473                         ret = tasdev_bytes_chksum(tas_priv, block, chn,
1474                                 book, page, reg, len, 0, crc_chksum);
1475         } else {
1476                 ret = tasdevice_dev_write(tas_priv, chn,
1477                         TASDEVICE_REG(book, page, reg), data[3]);
1478                 if (ret < 0)
1479                         goto end;
1480                 if (block->is_ychksum_present)
1481                         ret = tasdev_bytes_chksum(tas_priv, block, chn, book,
1482                                 page, reg, 1, data[3], crc_chksum);
1483         }
1484
1485         if (!block->is_ychksum_present || ret >= 0) {
1486                 *nr_cmds += 1;
1487                 if (len >= 2)
1488                         *nr_cmds += ((len - 2) / 4) + 1;
1489         }
1490
1491 end:
1492         return ret;
1493 }
1494
1495 static int tasdev_block_chksum(struct tasdevice_priv *tas_priv,
1496         struct tasdev_blk *block, int chn)
1497 {
1498         unsigned int nr_value;
1499         int ret;
1500
1501         ret = tasdevice_dev_read(tas_priv, chn, TASDEVICE_I2CChecksum,
1502                 &nr_value);
1503         if (ret < 0) {
1504                 dev_err(tas_priv->dev, "%s: Chn %d\n", __func__, chn);
1505                 set_err_prg_cfg(block->type, &tas_priv->tasdevice[chn]);
1506                 goto end;
1507         }
1508
1509         if ((nr_value & 0xff) != block->pchksum) {
1510                 dev_err(tas_priv->dev, "%s: Blk PChkSum Chn %d ", __func__,
1511                         chn);
1512                 dev_err(tas_priv->dev, "PChkSum = 0x%x, Reg = 0x%x\n",
1513                         block->pchksum, (nr_value & 0xff));
1514                 tas_priv->tasdevice[chn].err_code |= ERROR_PRAM_CRCCHK;
1515                 ret = -EAGAIN;
1516                 block->nr_retry--;
1517
1518                 if (block->nr_retry <= 0)
1519                         set_err_prg_cfg(block->type,
1520                                 &tas_priv->tasdevice[chn]);
1521         } else
1522                 tas_priv->tasdevice[chn].err_code &= ~ERROR_PRAM_CRCCHK;
1523
1524 end:
1525         return ret;
1526 }
1527
1528 static int tasdev_load_blk(struct tasdevice_priv *tas_priv,
1529         struct tasdev_blk *block, int chn)
1530 {
1531         unsigned int sleep_time;
1532         unsigned int len;
1533         unsigned int nr_cmds;
1534         unsigned char *data;
1535         unsigned char crc_chksum = 0;
1536         unsigned char offset;
1537         unsigned char book;
1538         unsigned char page;
1539         unsigned char val;
1540         int ret = 0;
1541
1542         while (block->nr_retry > 0) {
1543                 if (block->is_pchksum_present) {
1544                         ret = tasdevice_dev_write(tas_priv, chn,
1545                                 TASDEVICE_I2CChecksum, 0);
1546                         if (ret < 0)
1547                                 break;
1548                 }
1549
1550                 if (block->is_ychksum_present)
1551                         crc_chksum = 0;
1552
1553                 nr_cmds = 0;
1554
1555                 while (nr_cmds < block->nr_cmds) {
1556                         data = block->data + nr_cmds * 4;
1557
1558                         book = data[0];
1559                         page = data[1];
1560                         offset = data[2];
1561                         val = data[3];
1562
1563                         nr_cmds++;
1564                         /*Single byte write*/
1565                         if (offset <= 0x7F) {
1566                                 ret = tasdevice_dev_write(tas_priv, chn,
1567                                         TASDEVICE_REG(book, page, offset),
1568                                         val);
1569                                 if (ret < 0)
1570                                         goto end;
1571                                 if (block->is_ychksum_present) {
1572                                         ret = tasdev_bytes_chksum(tas_priv,
1573                                                 block, chn, book, page, offset,
1574                                                 1, val, &crc_chksum);
1575                                         if (ret < 0)
1576                                                 break;
1577                                 }
1578                                 continue;
1579                         }
1580                         /*sleep command*/
1581                         if (offset == 0x81) {
1582                                 /*book -- data[0] page -- data[1]*/
1583                                 sleep_time = ((book << 8) + page)*1000;
1584                                 usleep_range(sleep_time, sleep_time + 50);
1585                                 continue;
1586                         }
1587                         /*Multiple bytes write*/
1588                         if (offset == 0x85) {
1589                                 data += 4;
1590                                 len = (book << 8) + page;
1591                                 book = data[0];
1592                                 page = data[1];
1593                                 offset = data[2];
1594                                 ret = tasdev_multibytes_wr(tas_priv,
1595                                         block, chn, book, page, offset, data,
1596                                         len, &nr_cmds, &crc_chksum);
1597                                 if (ret < 0)
1598                                         break;
1599                         }
1600                 }
1601                 if (ret == -EAGAIN) {
1602                         if (block->nr_retry > 0)
1603                                 continue;
1604                 } else if (ret < 0) /*err in current device, skip it*/
1605                         break;
1606
1607                 if (block->is_pchksum_present) {
1608                         ret = tasdev_block_chksum(tas_priv, block, chn);
1609                         if (ret == -EAGAIN) {
1610                                 if (block->nr_retry > 0)
1611                                         continue;
1612                         } else if (ret < 0) /*err in current device, skip it*/
1613                                 break;
1614                 }
1615
1616                 if (block->is_ychksum_present) {
1617                         /* TBD, open it when FW ready */
1618                         dev_err(tas_priv->dev,
1619                                 "Blk YChkSum: FW = 0x%x, YCRC = 0x%x\n",
1620                                 block->ychksum, crc_chksum);
1621
1622                         tas_priv->tasdevice[chn].err_code &=
1623                                 ~ERROR_YRAM_CRCCHK;
1624                         ret = 0;
1625                 }
1626                 /*skip current blk*/
1627                 break;
1628         }
1629
1630 end:
1631         return ret;
1632 }
1633
1634 static int tasdevice_load_block(struct tasdevice_priv *tas_priv,
1635         struct tasdev_blk *block)
1636 {
1637         int chnend = 0;
1638         int ret = 0;
1639         int chn = 0;
1640         int rc = 0;
1641
1642         switch (block->type) {
1643         case MAIN_ALL_DEVICES:
1644                 chn = 0;
1645                 chnend = tas_priv->ndev;
1646                 break;
1647         case MAIN_DEVICE_A:
1648         case COEFF_DEVICE_A:
1649         case PRE_DEVICE_A:
1650                 chn = 0;
1651                 chnend = 1;
1652                 break;
1653         case MAIN_DEVICE_B:
1654         case COEFF_DEVICE_B:
1655         case PRE_DEVICE_B:
1656                 chn = 1;
1657                 chnend = 2;
1658                 break;
1659         case MAIN_DEVICE_C:
1660         case COEFF_DEVICE_C:
1661         case PRE_DEVICE_C:
1662                 chn = 2;
1663                 chnend = 3;
1664                 break;
1665         case MAIN_DEVICE_D:
1666         case COEFF_DEVICE_D:
1667         case PRE_DEVICE_D:
1668                 chn = 3;
1669                 chnend = 4;
1670                 break;
1671         default:
1672                 dev_dbg(tas_priv->dev, "load blk: Other Type = 0x%02x\n",
1673                         block->type);
1674                 break;
1675         }
1676
1677         for (; chn < chnend; chn++) {
1678                 block->nr_retry = 6;
1679                 if (tas_priv->tasdevice[chn].is_loading == false)
1680                         continue;
1681                 ret = tasdev_load_blk(tas_priv, block, chn);
1682                 if (ret < 0)
1683                         dev_err(tas_priv->dev, "dev %d, Blk (%d) load error\n",
1684                                 chn, block->type);
1685                 rc |= ret;
1686         }
1687
1688         return rc;
1689 }
1690
1691 static int dspfw_default_callback(struct tasdevice_priv *tas_priv,
1692         unsigned int drv_ver, unsigned int ppcver)
1693 {
1694         int rc = 0;
1695
1696         if (drv_ver == 0x100) {
1697                 if (ppcver >= PPC3_VERSION) {
1698                         tas_priv->fw_parse_variable_header =
1699                                 fw_parse_variable_header_kernel;
1700                         tas_priv->fw_parse_program_data =
1701                                 fw_parse_program_data_kernel;
1702                         tas_priv->fw_parse_configuration_data =
1703                                 fw_parse_configuration_data_kernel;
1704                         tas_priv->tasdevice_load_block =
1705                                 tasdevice_load_block_kernel;
1706                 } else {
1707                         switch (ppcver) {
1708                         case 0x00:
1709                                 tas_priv->fw_parse_variable_header =
1710                                         fw_parse_variable_header_git;
1711                                 tas_priv->fw_parse_program_data =
1712                                         fw_parse_program_data;
1713                                 tas_priv->fw_parse_configuration_data =
1714                                         fw_parse_configuration_data;
1715                                 tas_priv->tasdevice_load_block =
1716                                         tasdevice_load_block;
1717                                 break;
1718                         default:
1719                                 dev_err(tas_priv->dev,
1720                                         "%s: PPCVer must be 0x0 or 0x%02x",
1721                                         __func__, PPC3_VERSION);
1722                                 dev_err(tas_priv->dev, " Current:0x%02x\n",
1723                                         ppcver);
1724                                 rc = -EINVAL;
1725                                 break;
1726                         }
1727                 }
1728         } else {
1729                 dev_err(tas_priv->dev,
1730                         "DrvVer must be 0x0, 0x230 or above 0x230 ");
1731                 dev_err(tas_priv->dev, "current is 0x%02x\n", drv_ver);
1732                 rc = -EINVAL;
1733         }
1734
1735         return rc;
1736 }
1737
1738 static int load_calib_data(struct tasdevice_priv *tas_priv,
1739         struct tasdevice_data *dev_data)
1740 {
1741         struct tasdev_blk *block;
1742         unsigned int i;
1743         int ret = 0;
1744
1745         for (i = 0; i < dev_data->nr_blk; i++) {
1746                 block = &(dev_data->dev_blks[i]);
1747                 ret = tasdevice_load_block(tas_priv, block);
1748                 if (ret < 0)
1749                         break;
1750         }
1751
1752         return ret;
1753 }
1754
1755 static int fw_parse_header(struct tasdevice_priv *tas_priv,
1756         struct tasdevice_fw *tas_fmw, const struct firmware *fmw, int offset)
1757 {
1758         struct tasdevice_dspfw_hdr *fw_hdr = &(tas_fmw->fw_hdr);
1759         struct tasdevice_fw_fixed_hdr *fw_fixed_hdr = &(fw_hdr->fixed_hdr);
1760         static const unsigned char magic_number[] = { 0x35, 0x35, 0x35, 0x32 };
1761         const unsigned char *buf = (unsigned char *)fmw->data;
1762
1763         if (offset + 92 > fmw->size) {
1764                 dev_err(tas_priv->dev, "%s: File Size error\n", __func__);
1765                 offset = -EINVAL;
1766                 goto out;
1767         }
1768         if (memcmp(&buf[offset], magic_number, 4)) {
1769                 dev_err(tas_priv->dev, "%s: Magic num NOT match\n", __func__);
1770                 offset = -EINVAL;
1771                 goto out;
1772         }
1773         offset += 4;
1774
1775         /* Convert data[offset], data[offset + 1], data[offset + 2] and
1776          * data[offset + 3] into host
1777          */
1778         fw_fixed_hdr->fwsize = be32_to_cpup((__be32 *)&buf[offset]);
1779         offset += 4;
1780         if (fw_fixed_hdr->fwsize != fmw->size) {
1781                 dev_err(tas_priv->dev, "File size not match, %lu %u",
1782                         (unsigned long)fmw->size, fw_fixed_hdr->fwsize);
1783                 offset = -EINVAL;
1784                 goto out;
1785         }
1786         offset += 4;
1787         fw_fixed_hdr->ppcver = be32_to_cpup((__be32 *)&buf[offset]);
1788         offset += 8;
1789         fw_fixed_hdr->drv_ver = be32_to_cpup((__be32 *)&buf[offset]);
1790         offset += 72;
1791
1792  out:
1793         return offset;
1794 }
1795
1796 static int fw_parse_variable_hdr_cal(struct tasdevice_priv *tas_priv,
1797         struct tasdevice_fw *tas_fmw, const struct firmware *fmw, int offset)
1798 {
1799         struct tasdevice_dspfw_hdr *fw_hdr = &(tas_fmw->fw_hdr);
1800
1801         offset = fw_parse_variable_hdr(tas_priv, fw_hdr, fmw, offset);
1802         if (offset < 0)
1803                 goto out;
1804         if (fw_hdr->ndev != 1) {
1805                 dev_err(tas_priv->dev,
1806                         "%s: calbin must be 1, but currently ndev(%u)\n",
1807                         __func__, fw_hdr->ndev);
1808                 offset = -EINVAL;
1809         }
1810
1811 out:
1812         return offset;
1813 }
1814
1815 /* When calibrated data parsing error occurs, DSP can still work with default
1816  * calibrated data, memory resource related to calibrated data will be
1817  * released in the tasdevice_codec_remove.
1818  */
1819 static int fw_parse_calibration_data(struct tasdevice_priv *tas_priv,
1820         struct tasdevice_fw *tas_fmw, const struct firmware *fmw, int offset)
1821 {
1822         struct tasdevice_calibration *calibration;
1823         unsigned char *data = (unsigned char *)fmw->data;
1824         unsigned int i, n;
1825
1826         if (offset + 2 > fmw->size) {
1827                 dev_err(tas_priv->dev, "%s: Calibrations error\n", __func__);
1828                 offset = -EINVAL;
1829                 goto out;
1830         }
1831         tas_fmw->nr_calibrations = be16_to_cpup((__be16 *)&data[offset]);
1832         offset += 2;
1833
1834         if (tas_fmw->nr_calibrations != 1) {
1835                 dev_err(tas_priv->dev,
1836                         "%s: only supports one calibration (%d)!\n",
1837                         __func__, tas_fmw->nr_calibrations);
1838                 goto out;
1839         }
1840
1841         tas_fmw->calibrations = kcalloc(tas_fmw->nr_calibrations,
1842                 sizeof(struct tasdevice_calibration), GFP_KERNEL);
1843         if (!tas_fmw->calibrations) {
1844                 offset = -ENOMEM;
1845                 goto out;
1846         }
1847         for (i = 0; i < tas_fmw->nr_calibrations; i++) {
1848                 if (offset + 64 > fmw->size) {
1849                         dev_err(tas_priv->dev, "Calibrations error\n");
1850                         offset = -EINVAL;
1851                         goto out;
1852                 }
1853                 calibration = &(tas_fmw->calibrations[i]);
1854                 offset += 64;
1855
1856                 n = strlen((char *)&data[offset]);
1857                 /* skip '\0' and 2 unused bytes */
1858                 n += 3;
1859                 if (offset + n > fmw->size) {
1860                         dev_err(tas_priv->dev, "Description err\n");
1861                         offset = -EINVAL;
1862                         goto out;
1863                 }
1864                 offset += n;
1865
1866                 offset = fw_parse_data(tas_fmw, &(calibration->dev_data), fmw,
1867                         offset);
1868                 if (offset < 0)
1869                         goto out;
1870         }
1871
1872 out:
1873         return offset;
1874 }
1875
1876 int tas2781_load_calibration(void *context, char *file_name,
1877         unsigned short i)
1878 {
1879         struct tasdevice_priv *tas_priv = (struct tasdevice_priv *)context;
1880         struct tasdevice *tasdev = &(tas_priv->tasdevice[i]);
1881         const struct firmware *fw_entry;
1882         struct tasdevice_fw *tas_fmw;
1883         struct firmware fmw;
1884         int offset = 0;
1885         int ret;
1886
1887         ret = reject_firmware(&fw_entry, file_name, tas_priv->dev);
1888         if (ret) {
1889                 dev_err(tas_priv->dev, "%s: Request firmware %s failed\n",
1890                         __func__, file_name);
1891                 goto out;
1892         }
1893
1894         if (!fw_entry->size) {
1895                 dev_err(tas_priv->dev, "%s: file read error: size = %lu\n",
1896                         __func__, (unsigned long)fw_entry->size);
1897                 ret = -EINVAL;
1898                 goto out;
1899         }
1900         fmw.size = fw_entry->size;
1901         fmw.data = fw_entry->data;
1902
1903         tas_fmw = tasdev->cali_data_fmw = kzalloc(sizeof(struct tasdevice_fw),
1904                 GFP_KERNEL);
1905         if (!tasdev->cali_data_fmw) {
1906                 ret = -ENOMEM;
1907                 goto out;
1908         }
1909         tas_fmw->dev = tas_priv->dev;
1910         offset = fw_parse_header(tas_priv, tas_fmw, &fmw, offset);
1911         if (offset == -EINVAL) {
1912                 dev_err(tas_priv->dev, "fw_parse_header EXIT!\n");
1913                 ret = offset;
1914                 goto out;
1915         }
1916         offset = fw_parse_variable_hdr_cal(tas_priv, tas_fmw, &fmw, offset);
1917         if (offset == -EINVAL) {
1918                 dev_err(tas_priv->dev,
1919                         "%s: fw_parse_variable_header_cal EXIT!\n", __func__);
1920                 ret = offset;
1921                 goto out;
1922         }
1923         offset = fw_parse_program_data(tas_priv, tas_fmw, &fmw, offset);
1924         if (offset < 0) {
1925                 dev_err(tas_priv->dev, "fw_parse_program_data EXIT!\n");
1926                 ret = offset;
1927                 goto out;
1928         }
1929         offset = fw_parse_configuration_data(tas_priv, tas_fmw, &fmw, offset);
1930         if (offset < 0) {
1931                 dev_err(tas_priv->dev, "fw_parse_configuration_data EXIT!\n");
1932                 ret = offset;
1933                 goto out;
1934         }
1935         offset = fw_parse_calibration_data(tas_priv, tas_fmw, &fmw, offset);
1936         if (offset < 0) {
1937                 dev_err(tas_priv->dev, "fw_parse_calibration_data EXIT!\n");
1938                 ret = offset;
1939                 goto out;
1940         }
1941
1942 out:
1943         if (fw_entry)
1944                 release_firmware(fw_entry);
1945
1946         return ret;
1947 }
1948 EXPORT_SYMBOL_NS_GPL(tas2781_load_calibration, SND_SOC_TAS2781_FMWLIB);
1949
1950 static int tasdevice_dspfw_ready(const struct firmware *fmw,
1951         void *context)
1952 {
1953         struct tasdevice_priv *tas_priv = (struct tasdevice_priv *) context;
1954         struct tasdevice_fw_fixed_hdr *fw_fixed_hdr;
1955         struct tasdevice_fw *tas_fmw;
1956         int offset = 0;
1957         int ret = 0;
1958
1959         if (!fmw || !fmw->data) {
1960                 dev_err(tas_priv->dev, "%s: Failed to read firmware %s\n",
1961                         __func__, tas_priv->coef_binaryname);
1962                 ret = -EINVAL;
1963                 goto out;
1964         }
1965
1966         tas_priv->fmw = kzalloc(sizeof(struct tasdevice_fw), GFP_KERNEL);
1967         if (!tas_priv->fmw) {
1968                 ret = -ENOMEM;
1969                 goto out;
1970         }
1971         tas_fmw = tas_priv->fmw;
1972         tas_fmw->dev = tas_priv->dev;
1973         offset = fw_parse_header(tas_priv, tas_fmw, fmw, offset);
1974
1975         if (offset == -EINVAL) {
1976                 ret = -EINVAL;
1977                 goto out;
1978         }
1979         fw_fixed_hdr = &(tas_fmw->fw_hdr.fixed_hdr);
1980         /* Support different versions of firmware */
1981         switch (fw_fixed_hdr->drv_ver) {
1982         case 0x301:
1983         case 0x302:
1984         case 0x502:
1985         case 0x503:
1986                 tas_priv->fw_parse_variable_header =
1987                         fw_parse_variable_header_kernel;
1988                 tas_priv->fw_parse_program_data =
1989                         fw_parse_program_data_kernel;
1990                 tas_priv->fw_parse_configuration_data =
1991                         fw_parse_configuration_data_kernel;
1992                 tas_priv->tasdevice_load_block =
1993                         tasdevice_load_block_kernel;
1994                 break;
1995         case 0x202:
1996         case 0x400:
1997                 tas_priv->fw_parse_variable_header =
1998                         fw_parse_variable_header_git;
1999                 tas_priv->fw_parse_program_data =
2000                         fw_parse_program_data;
2001                 tas_priv->fw_parse_configuration_data =
2002                         fw_parse_configuration_data;
2003                 tas_priv->tasdevice_load_block =
2004                         tasdevice_load_block;
2005                 break;
2006         default:
2007                 ret = dspfw_default_callback(tas_priv,
2008                         fw_fixed_hdr->drv_ver, fw_fixed_hdr->ppcver);
2009                 if (ret)
2010                         goto out;
2011                 break;
2012         }
2013
2014         offset = tas_priv->fw_parse_variable_header(tas_priv, fmw, offset);
2015         if (offset < 0) {
2016                 ret = offset;
2017                 goto out;
2018         }
2019         offset = tas_priv->fw_parse_program_data(tas_priv, tas_fmw, fmw,
2020                 offset);
2021         if (offset < 0) {
2022                 ret = offset;
2023                 goto out;
2024         }
2025         offset = tas_priv->fw_parse_configuration_data(tas_priv,
2026                 tas_fmw, fmw, offset);
2027         if (offset < 0)
2028                 ret = offset;
2029
2030 out:
2031         return ret;
2032 }
2033
2034 int tasdevice_dsp_parser(void *context)
2035 {
2036         struct tasdevice_priv *tas_priv = (struct tasdevice_priv *)context;
2037         const struct firmware *fw_entry;
2038         int ret;
2039
2040         ret = reject_firmware(&fw_entry, tas_priv->coef_binaryname,
2041                 tas_priv->dev);
2042         if (ret) {
2043                 dev_err(tas_priv->dev, "%s: load %s error\n", __func__,
2044                         tas_priv->coef_binaryname);
2045                 goto out;
2046         }
2047
2048         ret = tasdevice_dspfw_ready(fw_entry, tas_priv);
2049         release_firmware(fw_entry);
2050         fw_entry = NULL;
2051
2052 out:
2053         return ret;
2054 }
2055 EXPORT_SYMBOL_NS_GPL(tasdevice_dsp_parser, SND_SOC_TAS2781_FMWLIB);
2056
2057 static void tas2781_clear_calfirmware(struct tasdevice_fw *tas_fmw)
2058 {
2059         struct tasdevice_calibration *calibration;
2060         struct tasdev_blk *block;
2061         struct tasdevice_data *im;
2062         unsigned int blks;
2063         int i;
2064
2065         if (!tas_fmw->calibrations)
2066                 goto out;
2067
2068         for (i = 0; i < tas_fmw->nr_calibrations; i++) {
2069                 calibration = &(tas_fmw->calibrations[i]);
2070                 if (!calibration)
2071                         continue;
2072
2073                 im = &(calibration->dev_data);
2074
2075                 if (!im->dev_blks)
2076                         continue;
2077
2078                 for (blks = 0; blks < im->nr_blk; blks++) {
2079                         block = &(im->dev_blks[blks]);
2080                         if (!block)
2081                                 continue;
2082                         kfree(block->data);
2083                 }
2084                 kfree(im->dev_blks);
2085         }
2086         kfree(tas_fmw->calibrations);
2087 out:
2088         kfree(tas_fmw);
2089 }
2090
2091 void tasdevice_calbin_remove(void *context)
2092 {
2093         struct tasdevice_priv *tas_priv = (struct tasdevice_priv *) context;
2094         struct tasdevice *tasdev;
2095         int i;
2096
2097         if (!tas_priv)
2098                 return;
2099
2100         for (i = 0; i < tas_priv->ndev; i++) {
2101                 tasdev = &(tas_priv->tasdevice[i]);
2102                 if (!tasdev->cali_data_fmw)
2103                         continue;
2104                 tas2781_clear_calfirmware(tasdev->cali_data_fmw);
2105                 tasdev->cali_data_fmw = NULL;
2106         }
2107 }
2108 EXPORT_SYMBOL_NS_GPL(tasdevice_calbin_remove, SND_SOC_TAS2781_FMWLIB);
2109
2110 void tasdevice_config_info_remove(void *context)
2111 {
2112         struct tasdevice_priv *tas_priv = (struct tasdevice_priv *) context;
2113         struct tasdevice_rca *rca = &(tas_priv->rcabin);
2114         struct tasdevice_config_info **ci = rca->cfg_info;
2115         int i, j;
2116
2117         if (!ci)
2118                 return;
2119         for (i = 0; i < rca->ncfgs; i++) {
2120                 if (!ci[i])
2121                         continue;
2122                 if (ci[i]->blk_data) {
2123                         for (j = 0; j < (int)ci[i]->real_nblocks; j++) {
2124                                 if (!ci[i]->blk_data[j])
2125                                         continue;
2126                                 kfree(ci[i]->blk_data[j]->regdata);
2127                                 kfree(ci[i]->blk_data[j]);
2128                         }
2129                         kfree(ci[i]->blk_data);
2130                 }
2131                 kfree(ci[i]);
2132         }
2133         kfree(ci);
2134 }
2135 EXPORT_SYMBOL_NS_GPL(tasdevice_config_info_remove, SND_SOC_TAS2781_FMWLIB);
2136
2137 static int tasdevice_load_data(struct tasdevice_priv *tas_priv,
2138         struct tasdevice_data *dev_data)
2139 {
2140         struct tasdev_blk *block;
2141         unsigned int i;
2142         int ret = 0;
2143
2144         for (i = 0; i < dev_data->nr_blk; i++) {
2145                 block = &(dev_data->dev_blks[i]);
2146                 ret = tas_priv->tasdevice_load_block(tas_priv, block);
2147                 if (ret < 0)
2148                         break;
2149         }
2150
2151         return ret;
2152 }
2153
2154 int tasdevice_select_tuningprm_cfg(void *context, int prm_no,
2155         int cfg_no, int rca_conf_no)
2156 {
2157         struct tasdevice_priv *tas_priv = (struct tasdevice_priv *) context;
2158         struct tasdevice_rca *rca = &(tas_priv->rcabin);
2159         struct tasdevice_config_info **cfg_info = rca->cfg_info;
2160         struct tasdevice_fw *tas_fmw = tas_priv->fmw;
2161         struct tasdevice_prog *program;
2162         struct tasdevice_config *conf;
2163         int prog_status = 0;
2164         int status, i;
2165
2166         if (!tas_fmw) {
2167                 dev_err(tas_priv->dev, "%s: Firmware is NULL\n", __func__);
2168                 goto out;
2169         }
2170
2171         if (cfg_no >= tas_fmw->nr_configurations) {
2172                 dev_err(tas_priv->dev,
2173                         "%s: cfg(%d) is not in range of conf %u\n",
2174                         __func__, cfg_no, tas_fmw->nr_configurations);
2175                 goto out;
2176         }
2177
2178         if (prm_no >= tas_fmw->nr_programs) {
2179                 dev_err(tas_priv->dev,
2180                         "%s: prm(%d) is not in range of Programs %u\n",
2181                         __func__, prm_no, tas_fmw->nr_programs);
2182                 goto out;
2183         }
2184
2185         if (rca_conf_no >= rca->ncfgs || rca_conf_no < 0 ||
2186                 !cfg_info) {
2187                 dev_err(tas_priv->dev,
2188                         "conf_no:%d should be in range from 0 to %u\n",
2189                         rca_conf_no, rca->ncfgs-1);
2190                 goto out;
2191         }
2192
2193         for (i = 0, prog_status = 0; i < tas_priv->ndev; i++) {
2194                 if (cfg_info[rca_conf_no]->active_dev & (1 << i)) {
2195                         if (prm_no >= 0
2196                                 && (tas_priv->tasdevice[i].cur_prog != prm_no
2197                                 || tas_priv->force_fwload_status)) {
2198                                 tas_priv->tasdevice[i].cur_conf = -1;
2199                                 tas_priv->tasdevice[i].is_loading = true;
2200                                 prog_status++;
2201                         }
2202                 } else
2203                         tas_priv->tasdevice[i].is_loading = false;
2204                 tas_priv->tasdevice[i].is_loaderr = false;
2205         }
2206
2207         if (prog_status) {
2208                 program = &(tas_fmw->programs[prm_no]);
2209                 tasdevice_load_data(tas_priv, &(program->dev_data));
2210                 for (i = 0; i < tas_priv->ndev; i++) {
2211                         if (tas_priv->tasdevice[i].is_loaderr == true)
2212                                 continue;
2213                         else if (tas_priv->tasdevice[i].is_loaderr == false
2214                                 && tas_priv->tasdevice[i].is_loading == true) {
2215                                 struct tasdevice_fw *cal_fmw =
2216                                         tas_priv->tasdevice[i].cali_data_fmw;
2217
2218                                 if (cal_fmw) {
2219                                         struct tasdevice_calibration
2220                                                 *cal = cal_fmw->calibrations;
2221
2222                                         if (cal)
2223                                                 load_calib_data(tas_priv,
2224                                                         &(cal->dev_data));
2225                                 }
2226                                 tas_priv->tasdevice[i].cur_prog = prm_no;
2227                         }
2228                 }
2229         }
2230
2231         for (i = 0, status = 0; i < tas_priv->ndev; i++) {
2232                 if (cfg_no >= 0
2233                         && tas_priv->tasdevice[i].cur_conf != cfg_no
2234                         && (cfg_info[rca_conf_no]->active_dev & (1 << i))
2235                         && (tas_priv->tasdevice[i].is_loaderr == false)) {
2236                         status++;
2237                         tas_priv->tasdevice[i].is_loading = true;
2238                 } else
2239                         tas_priv->tasdevice[i].is_loading = false;
2240         }
2241
2242         if (status) {
2243                 conf = &(tas_fmw->configs[cfg_no]);
2244                 status = 0;
2245                 tasdevice_load_data(tas_priv, &(conf->dev_data));
2246                 for (i = 0; i < tas_priv->ndev; i++) {
2247                         if (tas_priv->tasdevice[i].is_loaderr == true) {
2248                                 status |= 1 << (i + 4);
2249                                 continue;
2250                         } else if (tas_priv->tasdevice[i].is_loaderr == false
2251                                 && tas_priv->tasdevice[i].is_loading == true)
2252                                 tas_priv->tasdevice[i].cur_conf = cfg_no;
2253                 }
2254         } else
2255                 dev_dbg(tas_priv->dev, "%s: Unneeded loading dsp conf %d\n",
2256                         __func__, cfg_no);
2257
2258         status |= cfg_info[rca_conf_no]->active_dev;
2259
2260 out:
2261         return prog_status;
2262 }
2263 EXPORT_SYMBOL_NS_GPL(tasdevice_select_tuningprm_cfg,
2264         SND_SOC_TAS2781_FMWLIB);
2265
2266 int tasdevice_prmg_load(void *context, int prm_no)
2267 {
2268         struct tasdevice_priv *tas_priv = (struct tasdevice_priv *) context;
2269         struct tasdevice_fw *tas_fmw = tas_priv->fmw;
2270         struct tasdevice_prog *program;
2271         int prog_status = 0;
2272         int i;
2273
2274         if (!tas_fmw) {
2275                 dev_err(tas_priv->dev, "%s: Firmware is NULL\n", __func__);
2276                 goto out;
2277         }
2278
2279         if (prm_no >= tas_fmw->nr_programs) {
2280                 dev_err(tas_priv->dev,
2281                         "%s: prm(%d) is not in range of Programs %u\n",
2282                         __func__, prm_no, tas_fmw->nr_programs);
2283                 goto out;
2284         }
2285
2286         for (i = 0, prog_status = 0; i < tas_priv->ndev; i++) {
2287                 if (prm_no >= 0 && tas_priv->tasdevice[i].cur_prog != prm_no) {
2288                         tas_priv->tasdevice[i].cur_conf = -1;
2289                         tas_priv->tasdevice[i].is_loading = true;
2290                         prog_status++;
2291                 }
2292         }
2293
2294         if (prog_status) {
2295                 program = &(tas_fmw->programs[prm_no]);
2296                 tasdevice_load_data(tas_priv, &(program->dev_data));
2297                 for (i = 0; i < tas_priv->ndev; i++) {
2298                         if (tas_priv->tasdevice[i].is_loaderr == true)
2299                                 continue;
2300                         else if (tas_priv->tasdevice[i].is_loaderr == false
2301                                 && tas_priv->tasdevice[i].is_loading == true)
2302                                 tas_priv->tasdevice[i].cur_prog = prm_no;
2303                 }
2304         }
2305
2306 out:
2307         return prog_status;
2308 }
2309 EXPORT_SYMBOL_NS_GPL(tasdevice_prmg_load, SND_SOC_TAS2781_FMWLIB);
2310
2311 int tasdevice_prmg_calibdata_load(void *context, int prm_no)
2312 {
2313         struct tasdevice_priv *tas_priv = (struct tasdevice_priv *) context;
2314         struct tasdevice_fw *tas_fmw = tas_priv->fmw;
2315         struct tasdevice_prog *program;
2316         int prog_status = 0;
2317         int i;
2318
2319         if (!tas_fmw) {
2320                 dev_err(tas_priv->dev, "%s: Firmware is NULL\n", __func__);
2321                 goto out;
2322         }
2323
2324         if (prm_no >= tas_fmw->nr_programs) {
2325                 dev_err(tas_priv->dev,
2326                         "%s: prm(%d) is not in range of Programs %u\n",
2327                         __func__, prm_no, tas_fmw->nr_programs);
2328                 goto out;
2329         }
2330
2331         for (i = 0, prog_status = 0; i < tas_priv->ndev; i++) {
2332                 if (prm_no >= 0 && tas_priv->tasdevice[i].cur_prog != prm_no) {
2333                         tas_priv->tasdevice[i].cur_conf = -1;
2334                         tas_priv->tasdevice[i].is_loading = true;
2335                         prog_status++;
2336                 }
2337                 tas_priv->tasdevice[i].is_loaderr = false;
2338         }
2339
2340         if (prog_status) {
2341                 program = &(tas_fmw->programs[prm_no]);
2342                 tasdevice_load_data(tas_priv, &(program->dev_data));
2343                 for (i = 0; i < tas_priv->ndev; i++) {
2344                         if (tas_priv->tasdevice[i].is_loaderr == true)
2345                                 continue;
2346                         else if (tas_priv->tasdevice[i].is_loaderr == false
2347                                 && tas_priv->tasdevice[i].is_loading == true) {
2348                                 struct tasdevice_fw *cal_fmw =
2349                                         tas_priv->tasdevice[i].cali_data_fmw;
2350
2351                                 if (cal_fmw) {
2352                                         struct tasdevice_calibration *cal =
2353                                                 cal_fmw->calibrations;
2354
2355                                         if (cal)
2356                                                 load_calib_data(tas_priv,
2357                                                         &(cal->dev_data));
2358                                 }
2359                                 tas_priv->tasdevice[i].cur_prog = prm_no;
2360                         }
2361                 }
2362         }
2363
2364 out:
2365         return prog_status;
2366 }
2367 EXPORT_SYMBOL_NS_GPL(tasdevice_prmg_calibdata_load,
2368         SND_SOC_TAS2781_FMWLIB);
2369
2370 void tasdevice_tuning_switch(void *context, int state)
2371 {
2372         struct tasdevice_priv *tas_priv = (struct tasdevice_priv *) context;
2373         struct tasdevice_fw *tas_fmw = tas_priv->fmw;
2374         int profile_cfg_id = tas_priv->rcabin.profile_cfg_id;
2375
2376         if (tas_priv->fw_state == TASDEVICE_DSP_FW_FAIL) {
2377                 dev_err(tas_priv->dev, "DSP bin file not loaded\n");
2378                 return;
2379         }
2380
2381         if (state == 0) {
2382                 if (tas_priv->cur_prog < tas_fmw->nr_programs) {
2383                         /*dsp mode or tuning mode*/
2384                         profile_cfg_id = tas_priv->rcabin.profile_cfg_id;
2385                         tasdevice_select_tuningprm_cfg(tas_priv,
2386                                 tas_priv->cur_prog, tas_priv->cur_conf,
2387                                 profile_cfg_id);
2388                 }
2389
2390                 tasdevice_select_cfg_blk(tas_priv, profile_cfg_id,
2391                         TASDEVICE_BIN_BLK_PRE_POWER_UP);
2392         } else
2393                 tasdevice_select_cfg_blk(tas_priv, profile_cfg_id,
2394                         TASDEVICE_BIN_BLK_PRE_SHUTDOWN);
2395 }
2396 EXPORT_SYMBOL_NS_GPL(tasdevice_tuning_switch,
2397         SND_SOC_TAS2781_FMWLIB);
2398
2399 MODULE_DESCRIPTION("Texas Firmware Support");
2400 MODULE_AUTHOR("Shenghao Ding, TI, <shenghao-ding@ti.com>");
2401 MODULE_LICENSE("GPL");