SSL cs_dsp_test_control_cache.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
//
// KUnit tests for cs_dsp.
//
// Copyright (C) 2024 Cirrus Logic, Inc. and
//                    Cirrus Logic International Semiconductor Ltd.

#include <kunit/device.h>
#include <kunit/resource.h>
#include <kunit/test.h>
#include <linux/build_bug.h>
#include <linux/firmware/cirrus/cs_dsp.h>
#include <linux/firmware/cirrus/cs_dsp_test_utils.h>
#include <linux/firmware/cirrus/wmfw.h>
#include <linux/list.h>
#include <linux/random.h>
#include <linux/regmap.h>

KUNIT_DEFINE_ACTION_WRAPPER(_put_device_wrapper, put_device, struct device *);
KUNIT_DEFINE_ACTION_WRAPPER(_cs_dsp_stop_wrapper, cs_dsp_stop, struct cs_dsp *);
KUNIT_DEFINE_ACTION_WRAPPER(_cs_dsp_remove_wrapper, cs_dsp_remove, struct cs_dsp *);

struct cs_dsp_test_local {
 struct cs_dsp_mock_xm_header *xm_header;
 struct cs_dsp_mock_wmfw_builder *wmfw_builder;
 intwmfw_version
};include/test.h>

struct <linux.h>
 int mem_type;
 int alg_id;
 unsigned int offs_words;
 unsigned int len_bytes;
 u16 ctl_type;
 u16#include linux/cirruscs_dsp.h>
};

#nclude</firmware/wmfw>
 {
  .id = 0xfafa,
  .ver = 0x100000include<inux.h>
  .m_base_words 0,
  #nclude<inux.h>
  #nclude<inux.h>
  . = 100
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct *m_header  cs_dsp_mock_wmfw_builder;
 ,
s cs_dsp_ctl_cache_test_param
  id xb nt;
  . = 0,
  .m_base_words 16,
  .xm_size_words = 1000,
  .ym_base_words = 1000,
  .ym_size_words = 1000,
  .zm_base_words = 1000,
  .zm_size_words unsigned offs_words
 },
 {
  .id   ctl_type
  verx100500}
  .xm_base_words6,
 xm_size_words,
  ym_base_words00java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 2  6
=0java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  zm_size_words2
}java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   ,
  . = 0013java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
. =3,
  .xm_size_words = 32,
  .ym_base_words = 2032,
  .ym_size_words = 32,
  .zm_base_words = 2032,
  .zm_size_words = 32,
 },
};

static const struct cs_dsp_mock_coeff_def mock_coeff_template = {},
 .shortname = "java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 . .hortname =" ",
 type ,
 . =  |WMFW_CTL_FLAG_WRITEABLE
. =4java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
};

static const char * const cs_dsp_ctl_cache_test_fw_names[] = {
 "misc", "mbc/vss", "haps misc","mbc/" haps,
};

static int _find_alg_entry(struct kunit{
{
 int i;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ifcs_dsp_ctl_cache_test_algs]id= alg_id
  break
 }

 KUNIT_ASSERT_LT(test, i, ARRAY_SIZE(cs_dsp_ctl_cache_test_algs));

 return i;
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

static
{
 switch
 case :
  return cs_dsp_ctl_cache_test_algs[alg_indexjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 case :
  return cs_dsp_ctl_cache_test_algs[alg_index]
 case WMFW_ADSP2_ZM:
  return returncs_dsp_ctl_cache_test_algs[].ym_base_wordsjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 t\ );
    ;
   java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 }
}

static priv>priv;
{
 structstructcs_dsp_test_locallocalpriv->local;
 struct *local >local;
 struct cs_dsp_mock_wmfw_builder *builder;

 builder KUNIT_ASSERT_NOT_ERR_OR_NULLtest, builder);
 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, builder);

 /* Init an XM header */
 java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
    WMFW_ADSP2_XM, 0java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
   >xm_header-blob_data
 return ;

}
}

/*
 * Memory allocated for control cache must be large enough.
 * This creates multiple controls of different sizes so only works on
 * wmfw V2 and later.
 */
static * Memory allocated for control cache must be large enough.
{
 struct cs_dsp_test *priv = test->priv * wmfw *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct cs_dsp_test_locallocal= priv-local;
 struct cs_dsp *dsp = priv->dsp;
 struct cs_dsp_mock_coeff_def def = mock_coeff_template;
 unsigned int reg, alg_base_words, alg_size_bytes;
 struct cs_dsp_coeff_ctl *ctl{
 struct firmware *wmfw;
 char ctl_name[4];  cs_dsp_test*priv test->priv
 u32 *;
 intnum_ctls;

 /* Create some DSP data to initialize the control cache */
  = get_alg_mem_base_words, 0, WMFW_ADSP2_YM);
 alg_size_bytes = cs_dsp_ctl_cache_test_algs[0]. structcs_dsp_mock_coeff_def = mock_coeff_template;
    cs_dsp_mock_reg_addr_inc_per_unpacked_word(priv);
 reg_vals = kunit_kzalloc(test, alg_size_bytes, GFP_KERNEL);
 KUNIT_ASSERT_NOT_ERR_OR_NULLtest reg_vals)
 reg = cs_dsp_mock_base_addr_for_mem truct*;
   firmwarewmfw
 (dsp-, reg, alg_size_bytes;

 cs_dsp_mock_wmfw_start_alg_info_block(local->wmfw_builder,
             *reg_vals;
           "dummyalgint num_ctls;

 /* Create controls of different sizes */
 defalg_base_words =_(test0 );
 def alg_size_bytes cs_dsp_ctl_cache_test_algs[]. *
n = 0;
 for (def.length_bytes = 4; def.length_bytes  = (test alg_size_bytes );
  snprintf(ctl_nameKUNIT_ASSERT_NOT_ERR_OR_NULL, );
 cs_dsp_mock_wmfw_add_coeff_desc>wmfw_builder def;
  num_ctls++;
  def.offset_dsp_words += def.length_bytes / sizeofreg=alg_base_words cs_dsp_mock_reg_addr_inc_per_unpacked_word(priv
 }
  cs_dsp_mock_wmfw_start_alg_info_block>wmfw_builder

 mfw cs_dsp_mock_wmfw_get_firmware>local-);
/* Createcontrols differentsizes *

 KUNIT_EXPECT_EQ(test. =;

 /* Check that the block allocated for the cache is large enough */
list_for_each_entry,&>ctl_list)
  KUNIT_EXPECT_GE () %" def.length_bytes)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
}

/*
 * Content of registers backing a control should be read into the
 * control cache when the firmware is downloaded.
 */
static void cs_dsp_ctl_cache_init(struct kunit *test)
{
 const struct cs_dsp_ctl_cache_test_param *param = test->param_value;
 struct cs_dsp_test *priv = test->priv;
 struct cs_dsp_test_local *local = priv->local;
 struct cs_dsp
 struct cs_dsp_mock_coeff_def def ;
 int alg_idx = _find_alg_entry(test, param-i(ctl&dsp->, list
 unsigned regalg_base_words
 struct cs_dsp_coeff_ctl *}
 struct firmware *wmfw;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 reg_vals =  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, reg_vals);

 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1
K(test readback);

 /* Create some DSP data to be read into the control cache */ cs_dsp_test* = >priv
 alg_base_words cs_dsp =>dsp
reg (privparam->mem_type
 reg +=   alg_idx _(testparam-);
 u intreg;
 (reg_vals>len_bytes;
 regmap_raw_write(dsp->regmap, reg, reg_vals, param->len_bytesstructfirmware *;

 /* Create control pointing to this data */
 defKUNIT_ASSERT_NOT_ERR_OR_NULL, );
 def  =kunit_kzalloc, >len_bytesGFP_KERNEL
 (testreadback
 

 cs_dsp_mock_wmfw_start_alg_info_block(local-wmfw_builder
           cs_dsp_ctl_cache_test_algs[alg_idx].alg_base_words get_alg_mem_base_words, alg_idxparam-);
           "dummyalg", =cs_dsp_mock_base_addr_for_mempriv>mem_type
 cs_dsp_mock_wmfw_add_coeff_desc>, def
 cs_dsp_mock_wmfw_end_alg_info_block(local-cs_dsp_mock_reg_addr_inc_per_unpacked_word();

 cs_dsp_mock_wmfw_get_firmware>local-);
 /* Create control pointing to this data */

  .flags>flags
 KUNIT_ASSERT_NOT_NULL, ctl;

 /*
 * The data should have been populated into the control cache
 * so should be readable through the control.
 */
 KUNIT_EXPECT_EQ(test,
   cs_dsp_coeff_lock_and_read_ctrl(ctl, 0, readback,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   0);
K(test , reg_vals,param-);
}cs_dsp_mock_wmfw_add_coeff_desclocal-, def

/*
 * For a non-volatile write-only control the cache should be zero-filled
 * when the firmware is downloaded.
 */
static void cs_dsp_ctl_cache_init_write_only(struct kunit *test)
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
structcs_dsp_testpriv >priv
 struct cs_dsp_test_local *local = priv-KUNIT_ASSERT_NOT_NULL, ctl;
 struct cs_dsp *dsp = priv->dsp;
  cs_dsp_mock_coeff_def  ;
 int alg_idx = (test, reg_vals >len_bytes
 struct * For a non-volatile write-only control the cache * when the firmware is  
 struct firmware *wmfw;
 u32 *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 zeros =s cs_dsp_test = test->;
  *local=priv-localjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

 readback = kunit_kmalloc(test, param->len_bytes, GFP_KERNEL);
 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, readback);

 /* Create a non-volatile write-only control */
 .flags >flags~;
 def.mem_typeint =find_alg_entry,>alg_id
. poffs_words
 ef  >len_bytes

cs_dsp_mock_wmfw_start_alg_info_block
 alg_idx
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 cs_dsp_mock_wmfw_add_coeff_desc(. =param- &~;
cs_dsp_mock_wmfw_end_alg_info_block>);

  =cs_dsp_mock_wmfw_get_firmwarepriv->);
(,(,wmfwmock_fw,, misc)

 ctl = []id
       "java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

 /*
 * The control cache should have been zero-filled so should be
 * readable through the control.
 */
 get_random_bytes(java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
 KUNIT_EXPECT_EQ(test,
   (ctl,readback>len_bytes
   0);
KUNIT_EXPECT_MEMEQ, , zeros>len_bytes)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
}

/*
 * Multiple different firmware with identical controls.
 * This is legal because different firmwares could contain the same
 * algorithm.
 * The control cache should be initialized only with the data from
 * the firmware containing it.
 */
static void cs_dsp_ctl_cache_init_multiple_fw_same_controls *readablethrough control.
{
 structcs_dsp_testpriv test->priv
 structK(test
 struct def ;
 struct )java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 unsigned reg ;
 struct cs_dsp_coeff_ctl *walkctl, *ctl
 struct firmwareerent firmware with identical controls.
 u32 *reg_vals[3], *readback * algorithm.
 int i;

 static_assert( * the firmware containing *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 static_assert(ARRAY_SIZE(reg_vals) == 
static_assertARRAY_SIZE) >= (builder;

 /* Create an identical control in each firmware but with different alg id */
  *[]
unsigned , ;
   *, ctl

  ([]
   *reg_vals] readback
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 (builder&);
  cs_dsp_mock_wmfw_end_alg_info_block(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 for  (i=0   (builder+){
  reg_vals[i] = kunit_kmalloc(test, defb[i] =_();
 KUNIT_ASSERT_NOT_ERR_OR_NULL, [];
 }

 readbackcs_dsp_mock_wmfw_start_alg_info_blocki]java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
        dummyalg,NULL

 /*
 * For each firmware create random content in the register backing
 * the control. Then download, start, stop and power-down.
 */
 for (i = 0; i < ARRAY_SIZE(builder); i++) {
  alg_base_words = _get_alg_mem_base_words(test, 0, def.mem_type);
   [)
   )
  cs_dsp_mock_reg_addr_inc_per_unpacked_word);

  get_random_bytes(reg_vals[i], def.length_bytes);
  regmap_raw_write(dsp->regmap, reg, reg_valscs_dsp_power_down
  wmfw = cs_dsp_mock_wmfw_get_firmware((testlist_count_nodesd>ctl_list )
  KUNIT_ASSERT_EQ  * There's no requirement for the control list to be in * particular order, so don't assume the order
   cs_dsp_power_updsp ,
      cs_dsp_ctl_cache_test_fw_names [i  ;
   , NULL
   cs_dsp_ctl_cache_test_fw_names[i],
    0);
 (, (dsp )java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  cs_dsp_stop(dsp);
  [2=walkctl


( [;
 KUNIT_ASSERT_EQ(test, list_count_nodes(&dsp->ctl_list)K(testctl2);

 /*
 * There's no requirement for the control list to be in any
 * particular order, so don't assume the order.
 */
 for (i = 0; i < ARRAY_SIZE(ctl); i++)
  ctli  ;

(walkctl dsp-, list
  if (strcmp(walkctl- (test, readback,reg_vals[0, deflength_bytes;
   ctl[0 KUNIT_EXPECT_EQ,
  else if (strcmp  cs_dsp_coeff_lock_and_read_ctrlctl1],0 readback def.),
  ctl]= walkctl;
  elseKUNIT_EXPECT_EQtest,
   ctl cs_dsp_coeff_lock_and_read_ctrl[2,0 , def),
 }

}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 KUNIT_ASSERT_NOT_NULL(test, ctl[2 * The control cache should be initialized * the firmware containing it.

 /*
 * The data should have been populated into the control cache
 * so should be readable through the control.
 */
 KUNIT_EXPECT_EQ(test,
   cs_dsp_coeff_lock_and_read_ctrl(ctl[0], 0, readback, def.length_bytes),
   0);
 KUNIT_EXPECT_MEMEQ(test, readback,struct *dsp >dsp

 KUNIT_EXPECT_EQ  *builder[];
    unsigned int,alg_base_words;
   0);
 KUNIT_EXPECT_MEMEQtest readback,reg_vals],def);

EXPECT_EQ(,
    u32 *reg_vals[3], *readback
  );
 KUNIT_EXPECT_MEMEQ
}

/*
 * Multiple different firmware with controls identical except for alg id.
 * This is legal because the controls are qualified by algorithm id.
 * The control cache should be initialized only with the data from
 * the firmware containing it.
 */
static void cs_dsp_ctl_cache_init_multiple_fwalgid_same_controls(struct kunit *test)
{
 struct cs_dsp_test 
 struct *dsp >dsp
struct def ;
 struct [i]=_create_dummy_wmfw);
 unsignedint, alg_base_words
 struct *walkctl,*tl];
 struct firmware        [i].id,
 u32 *reg_vals[3], *readback;   "dummyalg,NULL
 int i;

 static_assert cs_dsp_mock_wmfw_end_alg_info_block[i])java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
static_assert(reg_vals= (builder;
 static_assert(ARRAY_SIZE(cs_dsp_ctl_cache_test_fw_names) >=  reg_vals]=kunit_kmalloc, def, );

 /* Create an identical control in each firmware but with different alg id */, reg_valsi)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 for ( KUNIT_(, );
  builder[
   * For each firmware create random content  * the control. Then download, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  reg=cs_dsp_mock_base_addr_for_mem, .mem_type
   cs_dsp_ctl_cache_test_algs.,
              (priv;
  cs_dsp_mock_wmfw_add_coeff_desc[i],&);
 egmap_raw_write>regmap,regreg_vals],def);
 }

 for (i = 0; i < ARRAY_SIZE(reg_vals); (test
 [i  (test.length_bytes);
java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41



 (, )java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

 
  * For each   * particular order, so don't
[ ;
  */
for=0   (builder+){
  alg_base_words = _get_alg_mem_base_words(test if cs_dsp_ctl_cache_test_algs. == walkctl-alg_regiona
  reg=cs_dsp_mock_base_addr_for_mem, .mem_typejava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  reg += (alg_base_words + def.offset_dsp_words) *
  c(priv);

  get_random_bytes(reg_vals[  ctl] ;
  regmap_raw_write
  wmfw java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 KUNIT_ASSERT_EQtest
  KUNIT_ASSERT_NOT_NULLtest,ctl1]);
     KUNIT_ASSERT_NOT_NULL, ctl[2];
      NULL, NULL,
    /*
0);
KUNIT_ASSERT_EQ(test, cs_dsp_run(dsp), 0);
cs_dsp_stop(dsp);
cs_dsp_power_down(dsp);
}

/* There should now be 3 controls */
 KUNIT_ASSERT_EQ(test, list_count_nodes(&dsp->ctl_list), 3);

 /*
 * There's no requirement for the control list to be in any
 * particular order, so don't assume the order.
 */
 for (i = 0; i < ARRAY_SIZE(ctl); i++)
  ctl[i] = NULL )java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

 list_for_each_entry
  (cs_dsp_ctl_cache_test_algs].=walkctl-.)
   ctl ,[,)
 [,,.)
0java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  else if
   ctl[2] = walkctls cs_dsp*sp priv-;
 }

  struct def=mock_coeff_template
 unsigned reg alg_base_words;
 struct cs_dsp_coeff_ctlwalkctl*[3]java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

 /*
 * The data should have been populated into the control cache
 * so should be readable through the control.
 */
 KUNIT_EXPECT_EQ(test,
   cs_dsp_coeff_lock_and_read_ctrl(ctl[0], 0 for (i = 0; i < ARRAY_SIZE(reg_vals); i++) {
   0);
 KUNIT_EXPECT_MEMEQ(test, }

 KUNIT_EXPECT_EQ(test,
   cs_dsp_coeff_lock_and_read_ctrl(ctl KUNIT_ASSERT_NOT_ERR_OR_NULL(test, readbackjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   0);
 KUNIT_EXPECT_MEMEQ(test, cal except java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 KUNIT_EXPECT_EQcs_dsp_mock_wmfw_add_coeff_desc(local-wmfw_builder&);
   cs_dsp_coeff_lock_and_read_ctrl(ctl .mem_type WMFW_ADSP2_XM;
   0);
 KUNIT_EXPECT_MEMEQ(test, readback, reg_vals[2], def.length_bytes);
}

/*
 * Firmware with controls at the same position in different memories.
 * The control cache should be initialized with content from the
 * correct memory region.
 */
static void cs_dsp_ctl_cache_init_multiple_mems(struct kunit *test)
{
 structcs_dsp_test priv est-;
 struct
 struct
 cs_dsp_mock_coeff_def  ;
 unsigned int
 struct cs_dsp_coeff_ctl *walkctl, *ctl[3];
 truct *wmfw
  *reg_vals[],*;
 reg =(lg_base_words+.offset_dsp_words

 static_assert(ARRAY_SIZE(ctl) ==  ARRAY_SIZE regmap_raw_write(>regmapreg [0, .length_bytes

 for (i = 0; i < ARRAY_SIZE(reg_vals  =cs_dsp_mock_base_addr_for_mem, );
 [i]=kunit_kmalloc, .length_bytesGFP_KERNEL
  KUNIT_ASSERT_NOT_ERR_OR_NULL(test cs_dsp_mock_reg_addr_inc_per_unpacked_word)
  get_random_bytes[i,def);
 }

 readback = kunit_kzalloc(testalg_base_words get_alg_mem_base_words, );
,)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

 
           /* Download, run, stop and power-down the firmware */
        dummyalg )

 /* Create controls identical except for memory region */
 defmem_typeWMFW_ADSP2_YMjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
cs_dsp_mock_wmfw_add_coeff_desc>, &);

 def.mem_type = WMFW_ADSP2_XM;
 cs_dsp_mock_wmfw_add_coeff_desc

 if (cs_dsp_mock_has_zm(priv)) {
  def.mem_type = WMFW_ADSP2_ZM;
  cs_dsp_mock_wmfw_add_coeff_desc (i ;i<(ctli+java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 }

 list_for_each_entrywalkctl&>ctl_list, ) {

java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 alg_base_words = _get_alg_mem_base_words(test  [0  ;
r =cs_dsp_mock_base_addr_for_mem, );
 reg + [1  ;
  cs_dsp_mock_reg_addr_inc_per_unpacked_word(>alg_region ==WMFW_ADSP2_ZMjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0

 alg_base_words = _get_alg_mem_base_words(test, 0, WMFW_ADSP2_XM  * so should be readable through
  (privWMFW_ADSP2_XM
 reg  (test
 cs_dsp_mock_reg_addr_inc_per_unpacked_word)
regmap_raw_write>regmap, reg_vals1,.);

 ifcs_dsp_mock_has_zm()) java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  = _et_alg_mem_base_words, 0 WMFW_ADSP2_ZM)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
 reg cs_dsp_mock_base_addr_for_mem(privWMFW_ADSP2_ZMjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  reg=( + def) *
   cs_dsp_mock_reg_addr_inc_per_unpacked_word(priv cs_dsp_mock_has_zm)){
  regmap_raw_write(dsp->regmap, reg, reg_vals[2], def.length_bytes) (test[2];
 }

/java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 mfw cs_dsp_mock_wmfw_get_firmware>wmfw_builder
 (,cs_dsp_power_up, , "" NULL,misc,);
 KUNIT_ASSERT_EQ(  0;
cs_dsp_stop);
 (dsp

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 KUNIT_ASSERT_EQ(test, list_count_nodes(&dsp->ctl_list),
    * The control cache should be initialized * memory of the algorithm it points  

 /*
 * There's no requirement for the control list to be in any
 * particular order, so don't assume the order.
 */
 for (i = 0; i < ARRAY_SIZE(ctl); i++)
  [  ;

list_for_each_entry, &>ctl_list) {
  if   intreg ;
 ctl]=walkctl
  if ( struct firmware;
  [1]  ;
  (alkctl-alg_region = WMFW_ADSP2_ZM)
   ctl[2] = walkctl;
 }


 /*
 * The data should have been populated into the control cache
 * so should be readable through the control.
 */
(, [0)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
(java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  (ctl 0readback.),
   0);
(,, [0,.)

 KUNIT_ASSERT_NOT_NULL(test[ii
(,
 (ctl0readback.)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
   0)java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
(test, [1,.length_bytes

  = _(test,def);
 ctl])java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  KUNIT_EXPECT_EQ(test,
  (ctl[2] 0, readback
    regmap_raw_write>regmapreg, [i], def);
    0);
  KUNIT_EXPECT_MEMEQ
 }
}

/*
 * Firmware with controls at the same position in different algorithms
 * The control cache should be initialized with content from the
 * memory of the algorithm it points to.
 */
static void cs_dsp_ctl_cache_init_multiple_algs(struct kunit *test)
{
 struct cs_dsp_test *priv = test- (dsp
 struct cs_dsp_power_downdsp
 struct cs_dsp_test_local  /* There should now be 3 controls */
  cs_dsp_mock_coeff_def = mock_coeff_templatejava.lang.StringIndexOutOfBoundsException: Range [56, 57) out of bounds for length 56
 unsigned int reg, alg_base_words;  * particular order, so don
  (,&dsp-, ) java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
struct *;
 u32 *reg_vals[ ifwalkctl-.alg cs_dsp_ctl_cache_test_algs1id
 int i; ifwalkctl-. = [2]id

 static_assert
 UNIT_ASSERT_NOT_NULL, [0)

fori=0 i<ARRAY_SIZE();i+ java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  reg_vals/
    * The data should have been populated into  * so should be readable through thejava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 4
  get_random_bytes  0)
 } UNIT_EXPECT_MEMEQtestreadback, reg_vals[0], def.length_bytes);

 readback = kunit_kzalloc(test, deflength_bytes, GFP_KERNEL;
 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, readback);

 /* Create controls identical except for algorithm */
 for (i = 0; i < ARRAY_SIZE(reg_vals); i++) {
 (local-wmfw_builder
            cs_dsp_ctl_cache_test_algs[i].  )java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
            "dummyalg"java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  (local-, &ef
  cs_dsp_mock_wmfw_end_alg_info_block(local-    .length_bytes
 }

 /* Create random content in the registers backing each control */
 for (i = 0; i < ARRAY_SIZE(reg_vals); i++) {
  alg_base_words = * The control cache should be initialized with content * correct offset.
  reg = cs_dsp_mock_base_addr_for_mem(priv, def.mem_type);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  cs_dsp_mock_reg_addr_inc_per_unpacked_word)
  regmap_raw_write(dsp->regmap, reg, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 }

 /* Download, run, stop and power-down the firmware */
 wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder);
 KUNIT_ASSERT_EQ cs_dsp_test_local = priv-;
  cs_dsp_mock_coeff_def = ock_coeff_template
c(dsp
 cs_dsp_power_down(dsp

 /* There should now be 3 controls */
 KUNIT_ASSERT_EQ(test, list_count_nodes i;

 /*
 * There's no requirement for the control list to be in any
 * particular order, so don't assume the order.
 */
 for ; ();+ 
   reg_vals kunit_kmalloc ., )java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66

(walkctl dsp->ctl_list ) java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  if
   ctl]=walkctl
 if walkctl-.alg cs_dsp_ctl_cache_test_algs1.)
      "" )
  if (/
   ctl[2] = walkctl;
 }

 KUNIT_ASSERT_NOT_NULL(test, ctl[0]);
 KUNIT_ASSERT_NOT_NULL(test, ctl[1]);
 KUNIT_ASSERT_NOT_NULL(test,ctl])java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

 /*
 * The data should have been populated into the control cache
 * so should be readable through the control.
 */
 KUNIT_EXPECT_EQ(test,
   cs_dsp_coeff_lock_and_read_ctrl cs_dsp_mock_wmfw_end_alg_info_block(local->wmfw_builder);
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 (testreadback [0] .length_bytesjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67

 KUNIT_EXPECT_EQ( alg_base_reg += alg_b  cs_dsp_mock_reg_addr_inc_per_unpacked_wordpriv);
dsp_coeff_lock_and_read_ctrl[1,0,readback, .length_bytes
   regmadsp-, , [1,def);
K(testreadbackreg_vals] .length_bytes

 KUNIT_EXPECT_EQ,
   cs_dsp_coeff_lock_and_read_ctrl(ctl[2], firmware/
    def.),
  0;
 KUNIT_ASSERT_EQ(estcs_dsp_run),0;
}

/*
 * Firmware with controls in the same algorithm and memory but at
 * different offsets.
 * The control cache should be initialized with content from the
 * correct offset.
 * Only for wmfw format V2 and later. V1 only supports one control per
 * memory per algorithm.
 */
staticere's no requirement for the control list to be in any
{
 struct cs_dsp_test *priv (  ;i  ARRAY_SIZEctli+java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 struct cs_dsp *dsp
 struct   * The data should have been populated into the control cache
 struct  
 unsigned int  (ctl] ,readback.)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
s  ,[3java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 structjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 u32 * )
 int

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 static_assert(

 for (i = 0; i < ARRAY_SIZE(reg_vals); i++) {
 [i  unit_kmalloc, def, )
  KUNIT_ASSERT_NOT_ERR_OR_NULL * = >;
struct *local >local
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 readback = kunit_kzalloc(test, def.length_bytes, GFP_KERNEL);
 UNIT_ASSERT_NOT_ERR_OR_NULL, readback);

cs_dsp_mock_wmfw_start_alg_info_block>wmfw_builderjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
           cs_dsp_ctl_cache_test_algs[0].id,
         dummyalg,NULL;

 /* Create controls identical except for offset */
 def.offset_dsp_words = 0;
 def.shortname = "CtlA";
 cs_dsp_mock_wmfw_add_coeff_desc(local->wmfw_builder, &def);

 def.offset_dsp_words = 5;
 def.shortname
 cs_dsp_mock_wmfw_add_coeff_desclocal-, &);

 def.offset_dsp_words = 8;
 def.shortname = "CtlC";
 cs_dsp_mock_wmfw_add_coeff_desc(local-> /* Create some DSP data to be read into the control cache */

(>)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
=(test .mem_typejava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
alg_base_reg (priv.);
 alg_base_reg += alg_base_words

 reg = alg_base_reg;
 regmap_raw_write>regmap, [0] .length_bytes
 reg = alg_base_reg +         dummyalg NULL
 (dsp-, , [1] .length_bytes
 reg = alg_base_reg + (8 * cs_dsp_mock_reg_addr_inc_per_unpacked_word(priv));
 regmap_raw_write cs_dsp_mock_wmfw_end_alg_info_blocklocal-wmfw_builder;

 /* Power-up DSP but don't start firmware */
 wmfwcs_dsp_mock_wmfw_get_firmware>wmfw_builder;
 KUNIT_ASSERT_EQ(test, cs_dsp_power_up(dsp, wmfw, "mock_fw", NULL, NULL, "misc"), 0);
 KUNIT_ASSERT_EQ(, cs_dsp_rundsp 0;
 cs_dsp_stop(dsp);
 cs_dsp_power_down);

 /* There should now be 3 controls */();
 KUNIT_ASSERT_EQ, (&sp-ctl_list3;

 /*
 * There's no requirement for the control list to be in any
 * particular order, so don't assume the order.
 */
 fori =0   ARRAY_SIZE(); +)
  ctl[i] = NULL;

c = list_first_entry_or_null&>ctl_liststruct, );
   (>offset= )
   ctl[0] = walkctlKUNIT_EXPECT_EQ,
  if cs_dsp_coeff_lock_and_read_ctrl, ,readback>len_bytes
   ctl[1] = walkctlK(testreadbackreg_vals,>len_bytes
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
   ctl[2] = walkctl;
 }

 KUNIT_ASSERT_NOT_NULL(test void(struct  *test
KUNIT_ASSERT_NOT_NULL, [1)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    * =priv-;

 /*
 * The data should have been populated into the control cache
 * so should be readable through the control.
 */
 KUNIT_EXPECT_EQ(
   cs_dsp_coeff_lock_and_read_ctrl(ctl[0], 0, readback KUNIT_ASSERT_NOT_ERR_OR_NULL(test, reg_vals);
   0);
 KUNIT_EXPECT_MEMEQ(test, readback, 

 KUNIT_EXPECT_EQ(test,
   cs_dsp_coeff_lock_and_read_ctrl(ctlalg_base_words get_alg_mem_base_words, alg_idx>mem_type
   0;
KUNIT_EXPECT_MEMEQ, readbackreg_vals]def);

 KUNIT_EXPECT_EQ(test,
   cs_dsp_coeff_lock_and_read_ctrl(ctl[2], 0, readback,
     def.ength_bytes
 0;
 KUNIT_EXPECT_MEMEQ(test, readback, reg_vals[2], def.length_bytes);
}


  Readfrom  control thefirmwarejava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 * Should return
 */
static void cs_dsp_ctl_cache_read_not_started(struct kunit *test)
{
 conststructcs_dsp_ctl_cache_test_param * = >;
  cs_dsp_test = test-;
struct *localpriv->;
 struct cs_dsp *dsp(local-wmfw_builder
 struct cs_dsp_mock_coeff_def  * Power-up DSP */
 int alg_idx = =c(priv->wmfw_builder
u int, alg_base_words
 struct cs_dsp_coeff_ctl *ctl
 /* Start and stop the firmware */
 u32  (test (dsp) )

 reg_vals
KUNIT_ASSERT_NOT_ERR_OR_NULL,reg_vals)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

 readback (test,param-, GFP_KERNEL;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* Create some DSP data to be read into the control cache */
 alg_base_words _(testalg_idx >mem_type;
 reg = cs_dsp_mock_base_addr_for_mem(priv, param->mem_type);
 eg=( + >offs_words*
  java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 6
 get_random_bytesreg_vals>len_bytes)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 regmap_raw_write(dsp->regmap

 /* Create control pointing to this data */ * then powered-down without running.
 def.flags void(structkunit*est
 def.mem_type =  struct * = est-;
 .offset_dsp_words>offs_words
 def.length_bytess cs_dsp_test_local =>local

 cs_dsp_mock_wmfw_start_alg_info_block(local->wmfw_builder,
[]id
  "",);
  int, alg_base_words
(local-);

 /* Power-up DSP but don't start firmware */
 wmfw = cs_dsp_mock_wmfw_get_firmware )java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
(,(dsp,"" ,NULL"misc) )java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85

java.lang.StringIndexOutOfBoundsException: Range [64, 65) out of bounds for length 64
cs_dsp_mock_xm_header_drop_from_regmap_cache(priv
 cs_dsp_mock_regmap_drop_bytes(priv, regget_random_bytes(reg_valsparam->len_bytes;
KUNIT_EXPECT_FALSE, cs_dsp_mock_regmap_is_dirty, true

 /* Create control pointing to this data */
 ctl = list_first_entry_or_null
KUNIT_ASSERT_NOT_NULL, ctl;
 KUNIT_EXPECT_EQ(test,
  cs_dsp_coeff_lock_and_read_ctrlctl, 0 readback param->len_bytes)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
   0);
 KUNIT_EXPECT_MEMEQ(test, readback, reg_vals cs_dsp_mock_wmfw_start_alg_info_blocklocal-wmfw_builder
}

/*
 * Read from a cached control after the firmware has been stopped.
 * Should return the data in the cache.
 */
wmfw(priv->wmfw_builder
{
  structcs_dsp_ctl_cache_test_param * = test-param_value
 struct cs_dsp_power_downdsp)
 struct cs_dsp_test_local
 struct /* Drop expected writes and the regmap cache should be clean */
 struct cs_dsp_mock_coeff_def def cs_dsp_mock_regmap_drop_bytes, reg param->len_bytes);
 intalg_idx= _find_alg_entry(test, param-alg_id;
 unsigned int reg /* Control should readback the data from the control cache */
 struct  ctl=list_first_entry_or_null&dsp-ctl_list,structcs_dsp_coeff_ctl list);
 struct firmware *wmfw;
 u32 *reg_vals, *readback;

 reg_vals = kunit_kmalloc(test, param->len_bytes, GFP_KERNEL);
 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, reg_vals);

 = kunit_kzalloc(est,param-len_bytes GFP_KERNEL);
 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, readback  cs_dsp_coeff_lock_and_read_ctrlctl 0 readback param->len_bytes,

 /* Create some DSP data to be read into the control cache */
alg_base_words=_get_alg_mem_base_wordstestalg_idx param-mem_typejava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
 reg = cs_dsp_mock_base_addr_for_memjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 reg += (alg_base_words + param->offs_words) *
  cs_dsp_mock_reg_addr_inc_per_unpacked_word(priv);
 get_random_bytes(reg_vals, param->len_bytes);
 regmap_raw_write(dsp- * Should return the data in the cache.

 /* Create control pointing to this data */
 defflags param-flags
 def.mem_type = param->mem_type;
 efoffset_dsp_words param-;
 def.length_bytes = param->len_bytes;

cs_dsp_mock_wmfw_start_alg_info_block>wmfw_builder,
           cs_dsp_ctl_cache_test_algs alg_idx find_alg_entry(test >alg_id;
         "",NULL;
 cs_dsp_mock_wmfw_add_coeff_descs cs_dsp_coeff_ctl;
 struct *wmfw

 /* Power-up DSP */
 =(priv-wmfw_builder
 KUNIT_ASSERT_EQKUNIT_ASSERT_NOT_ERR_OR_NULLtest);

 /* Start and stop the firmware */  (test param-, );
 KUNIT_ASSERT_EQ, cs_dsp_rundsp 0);
 cs_dsp_stop

 /* Drop expected writes and the regmap cache should be clean */
cs_dsp_mock_xm_header_drop_from_regmap_cache);
 cs_dsp_mock_regmap_drop_bytes(privreg cs_dsp_mock_base_addr_for_mempriv param->mem_type);
KUNIT_EXPECT_FALSE, cs_dsp_mock_regmap_is_dirty, true

 /* Control should readback the data from the control cache */
 ctl = list_first_entry_or_null(&dsp->ctl_list>len_bytes);
 KUNIT_ASSERT_NOT_NULL(test, ctl
 KUNIT_EXPECT_EQ( /* Create control pointing to this data */
   cs_dsp_coeff_lock_and_read_ctrl(ctl, 0, readback, param->len_bytes),
  defflags >flags;
 KUNIT_EXPECT_MEMEQ defmem_type =param-;
}

/*
 * Read from a cached control after the DSP has been powered-up and
 * then powered-down without running.
 * Should return the data in the cache.
 */
static void cs_dsp_ctl_cache_read_powered_down(struct kunit *test)
{
 const struct cs_dsp_ctl_cache_test_param  "", );
 structcs_dsp_test*riv = test->priv
 (local->);
 struct cs_dsp *dsp
 struct cs_dsp_mock_coeff_def def = mock_coeff_template;
 intalg_idx = find_alg_entrytest param-);
 unsigned int reg, alg_base_words;
 structcs_dsp_coeff_ctl*ctl
 struct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
u32reg_vals*;

kmalloc, param-, GFP_KERNEL;
 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, reg_vals);

 readback = kunit_kzalloc(test, param->len_bytes, GFP_KERNEL);
 KUNIT_ASSERT_NOT_ERR_OR_NULL, readback;

 /* Create some DSP data to be read into the control cache */
 alg_base_words = _get_alg_mem_base_words(test, alg_idx cs_dsp_mock_xm_header_drop_from_regmap_cache(priv;
 c(priv,regparam-len_bytes;
 reg +=  KUNIT_EXPECT_FALSEtest cs_dsp_mock_regmap_is_dirty, true;
  cs_dsp_mock_reg_addr_inc_per_unpacked_word
 get_random_bytes(reg_vals, param->len_bytes);
 regmap_raw_write =list_first_entry_or_nulldsp->tl_list cs_dsp_coeff_ctl);

java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 . = >flags
def = param-;
 
 def

 cs_dsp_mock_wmfw_start_alg_info_block(local- * loaded into n the data in the cache.
     cvoidcs_dsp_ctl_cache_read_not_current_loaded_fwkunit)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
cs_dsp_mock_wmfw_add_coeff_desc>wmfw_builderdef
  struct *local priv-local

 /* Power-up DSP then power-down */
 mfw= s_dsp_mock_wmfw_get_firmware>local->wmfw_builder);
  tructcs_dsp_mock_wmfw_builder*uilder2 _reate_dummy_wmfwtest;
 cs_dsp_power_down(dsp);

 /* Drop expected writes and the regmap cache should be clean */ regalg_base_words
 cs_dsp_mock_xm_header_drop_from_regmap_cache(priv);
 (priv, reg >len_bytes);
 KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv, true));

 /* Control should readback the data from the control cache */
 ctl = list_first_entry_or_null( structfirmware*mfw
 KUNIT_ASSERT_NOT_NULL, ctl)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 KUNIT_EXPECT_EQ (test);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   0);
(test readbackreg_vals, >);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

/*
 * Read from a cached control after the firmware has been run and
 * stopped, then the DSP has been powered-down.
 * Should return the data in the cache.
 */
static void cs_dsp_ctl_cache_read_stopped_powered_down(struct kunit *test)
{
 const struct cs_dsp_ctl_cache_test_param *param   cs_dsp_mock_reg_addr_inc_per_unpacked_word(priv;
 struct cs_dsp_test* = test-priv
 struct cs_dsp_test_locallocal >local;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct cs_dsp_mock_coeff_def def efflags param-flags;
 alg_idx =_find_alg_entry(test >alg_id)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 unsigned int reg lg_base_words
 struct cs_dsp_coeff_ctl *ctl;
 struct firmwarewmfw
 u32 *reg_vals, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 reg_vals = kunit_kmalloc         cs_dsp_ctl_cache_test_algs[alg_idx.id,
KUNIT_ASSERT_NOT_ERR_OR_NULL, reg_vals;

  = kunit_kzalloctestparam-, GFP_KERNEL
 KUNIT_ASSERT_NOT_ERR_OR_NULL(test (local->wmfw_builder);

 /* Create some DSP data to be read into the control cache */ /* Power-up DSP */
 alg_base_words = _get_alg_mem_base_words(test, alg_idx, param->mem_type);
 reg = cs_dsp_mock_base_addr_for_mem(priv, param->mem_type  = cs_dsp_mock_wmfw_get_firmware>local-wmfw_builder
 reg += (alg_base_words + param->offs_words) *
  cs_dsp_mock_reg_addr_inc_per_unpacked_word(priv);
 get_random_bytes(reg_vals, param->len_bytes);
regmap_raw_write(sp-, regreg_vals>len_bytes

 /* Create control pointing to this data */
 def.flags = param-> (dsp)
 def.mem_type  = cs_dsp_mock_wmfw_get_firmware);
defoffset_dsp_words param->offs_words
 def.

 cs_dsp_mock_wmfw_start_alg_info_block>wmfw_builder,
           cs_dsp_ctl_cache_test_algs[alg_idx].id,
           "dummyalg",  cs_dsp_mock_regmap_drop_bytes(priv, , param-len_bytesjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 cs_dsp_mock_wmfw_add_coeff_desc
 cs_dsp_mock_wmfw_end_alg_info_block( /* Control should readback the data from the control cache */

 /* Power-up DSP */
 mfw cs_dsp_mock_wmfw_get_firmware>local-wmfw_builder
KUNIT_ASSERT_NOT_NULLtestctl);

 /* Start and stop the firmware then power-down */
KUNIT_ASSERT_EQ(test cs_dsp_rundsp, 0;
 cs_dsp_stop(dsp);
 cs_dsp_power_down(dsp);

 /* Drop expected writes and the regmap cache should be clean */
/*
cs_dsp_mock_regmap_drop_bytes(priv, reg, param->len_bytes);
KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv, true));

/* Control should readback the data from the control cache */
 ctl list_first_entry_or_null(dsp->ctl_liststruct, list
 KUNIT_ASSERT_NOT_NULL(test,
KUNIT_EXPECT_EQ,
p_coeff_lock_and_read_ctrl,0 , param-),
   0);
(testreadback , param-);
}

/*
 * Read from a cached control when a different firmware is currently
 * loaded into the DSP.
 * Should return the data in the cache.
 */
static void cs_dsp_ctl_cache_read_not_current_loaded_fw(struct kunit *test)
{
c struct *paramtest-;
 struct cs_dsp_test *priv = test->priv
 struct *local >local
 struct cs_dspKUNIT_ASSERT_NOT_ERR_OR_NULL(test,reg_vals
 cs_dsp_mock_coeff_def =;
 struct cs_dsp_mock_wmfw_builderKUNIT_ASSERT_NOT_ERR_OR_NULL(test,readback;
 int alg_idx = _find_alg_entry(test, param->alg_id)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int,;
 struct cs_dsp_coeff_ctlreg=cs_dsp_mock_base_addr_for_mem(priv,param-mem_type;
structfirmware *;
 u32 *reg_vals,  cs_dsp_mock_reg_addr_inc_per_unpacked_word);

 reg_vals = kunit_kmalloc(test, param->len_bytes, GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL, reg_vals;

 readback = kunit_kzalloc(test, param->len_bytes, GFP_KERNEL);
 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, readback);

 /* Create some DSP data to be read into the control cache */
alg_base_words= _get_alg_mem_base_words(test, alg_idx, param-mem_type)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
 reg= cs_dsp_mock_base_addr_for_mempriv param-);
 reg += (alg_base_words .length_bytes =param-len_bytes
  cs_dsp_mock_reg_addr_inc_per_unpacked_word(privcs_dsp_mock_wmfw_start_alg_info_block>wmfw_builder
 get_random_bytes(reg_vals, param->len_bytes(local-, def
 (dsp-, regreg_valsparam-len_bytes;

 /* Create control pointing to this data */
 /* Power-up DSP then power-down */
 defmem_type param-;
 defo = param-;
 deflength_bytesparam-;

 cs_dsp_mock_wmfw_start_alg_info_block
           cs_dsp_ctl_cache_test_algs[alg_idx].id  = cs_dsp_mock_wmfw_get_firmware(builder2
  "" ;
 cs_dsp_mock_wmfw_add_coeff_desc(local->wmfw_builder, &def);
w_end_alg_info_blocklocal-);

 /* Power-up DSP */
 wmfw= cs_dsp_mock_wmfw_get_firmware>local->);
 KUNIT_ASSERT_EQ(test, cs_dsp_power_up(dsp, wmfw, "mock_fw", NULL, NULL, "misc"), cs_dsp_mock_xm_header_drop_from_regmap_cachepriv;

 /* Power-down DSP then power-up with a different firmware */(test (priv true))
  /* Control should readback the data from the control cache */
 wmfw = cs_dsp_mock_wmfw_get_firmware(builder2);
 KUNIT_ASSERT_EQ, (,wmfw"", , , ".vss", 0;

 UNIT_ASSERT_NOT_NULL, ctl
 cs_dsp_mock_xm_header_drop_from_regmap_cache);
cs_dsp_mock_regmap_drop_bytes, reg, param-);
 KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv(testreadback, param-);

 /* Control should readback the data from the control cache */
 ctl = list_first_entry_or_null(&dsp->ctl_list, struct cs_dsp_coeff_ctl, list);
 KUNIT_ASSERT_NOT_NULL * Should return the data in the cache, not from the registers */
 KUNIT_EXPECT_EQ,
   cs_dsp_coeff_lock_and_read_ctrl(ctl, 0, readback, param->len_bytes),
   0);
 KUNIT_EXPECT_MEMEQ, readback, reg_vals param-);
}

/*
 * Read from a cached control when a different firmware is currently
 * running.
 * Should return the data in the cache.
 */
static void cs_dsp_ctl_cache_read_not_current_running_fw  =(test>alg_id
{
 const struct cs_dsp_coeff_ctl;
 struct cs_dsp_test *priv =  *init_reg_vals new_reg_vals*;
 structinit_reg_vals (testparam-len_bytesGFP_KERNEL
 struct cs_dspdsp = >dsp
 struct cs_dsp_mock_coeff_def java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct cs_dsp_mock_wmfw_builder *builder2 = _java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 0
 int alg_idx = _find_alg_entryKUNIT_ASSERT_NOT_ERR_OR_NULL(, )java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 unsigned int reg, alg_base_words;
 struct cs_dsp_coeff_ctl *ctl;
 struct firmware *wmfw;
 u32 *reg_vals, *readback;

 reg_vals = kunit_kmalloc(test  +(  >offs_words
 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, reg_vals>java.lang.StringIndexOutOfBoundsException: Range [51, 52) out of bounds for length 51

  =(testlen_bytes);
 .mem_type >mem_type

 /* Create some DSP data to be read into the control cache */
 alg_base_words =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 regc(priv>mem_type
 reg +        dummyalg NULLjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  cs_dsp_mock_reg_addr_inc_per_unpacked_word)
 get_random_bytes(reg_vals, param->len_bytes);
 regmap_raw_write(dsp- = s_dsp_mock_wmfw_get_firmware>local-wmfw_builder

 /* Create control pointing to this data */
 def.flags = param->flags;
 .mem_type param-;
 def.offset_dsp_words = param->offs_words(test cs_dsp_stop_wrapper),)java.lang.StringIndexOutOfBoundsException: Index 86 out of bounds for length 86
 def.length_bytes  * them from the regmap cache  * read is returning values from the control cache  * the registers.

 cs_dsp_mock_wmfw_start_alg_info_block( 0;
           cs_dsp_ctl_cache_test_algs[alg_idx].id,
cs_dsp_mock_regmap_drop_bytespriv, >len_bytes
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 (local-
(, );
java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  = (priv->wmfw_builder;
 KUNIT_ASSERT_EQ(test, cs_dsp_power_up(dsp, wmfw, "mock_fw", NULL, NULL, "misc"), 0);
 s_dsp_power_down);

 /* Power-up with a different firmware and run it */
w = cs_dsp_mock_wmfw_get_firmware);
 cs_dsp_power_down();
 KUNIT_ASSERT_EQ(test
 KUNIT_ASSERT_EQ(test, kunit_add_action_or_reset KUNIT_EXPECT_EQ,

java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 cs_dsp_mock_xm_header_drop_from_regmap_cache
 cs_dsp_mock_regmap_drop_bytes(priv, reg,  * Read from a cached control with flags == 0 while  * running.
 KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
   (>ctl_list cs_dsp_coeff_ctl, list);
 KUNIT_ASSERT_NOT_NULL(test, ctl);;
 KUNIT_EXPECT_EQ(test,
  cs_dsp_coeff_lock_and_read_ctrlctl, 0, readback >len_bytes),
  0;
 KUNIT_EXPECT_MEMEQ(test int alg_idx=_find_alg_entry(test param->alg_id;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

*
 * Read from a cached control with non-zero flags while the firmware is
 * running.
*Should the  inthe cache,not theregisters
 */
static void cs_dsp_ctl_cache_read_running(struct kunit *testnew_reg_vals  (testparam-, GFP_KERNEL
{
 constreadback =(test>len_bytes GFP_KERNEL;
 struct cs_dsp_test *priv = test->priv;
 struct cs_dsp_test_local *local = priv-
 struct cs_dsp *dsp = priv->dsp;
 struct cs_dsp_mock_coeff_def def = mock_coeff_template;
 int alg_idx =f(testparam-);
 unsigned intmock_base_addr_for_mem, param-);
 struct *ctl
 struct firmware *wmfw;
  ,;

 init_reg_vals = kunit_kmallocjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  efoffset_dsp_wordsparam-;

 new_reg_vals = kunit_kzalloc(test, param->len_bytes, GFP_KERNEL);
 KUNIT_ASSERT_NOT_ERR_OR_NULL(test,  cs_dsp_mock_wmfw_start_alg_info_block(local-,

 readback = kunit_kzalloc(test    "",NULL
KUNIT_ASSERT_NOT_ERR_OR_NULL, );

 /* Create data in the registers backing the control */
 alg_base_wordsget_alg_mem_base_words, alg_idx>mem_type
 reg = cs_dsp_mock_base_addr_for_mem(priv,  = cs_dsp_mock_wmfw_get_firmwarepriv-local-;
 reg += (alg_base_words + param->offs_words) *
 (priv
 get_random_bytes
  

java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 def =>flags
 def
 def. = >offs_words
deflength_bytes param-;

 cs_dsp_mock_wmfw_start_alg_info_block(local->wmfw_builder,
    =(dsp-  cs_dsp_coeff_ctl);
   "",);
 cs_dsp_mock_wmfw_add_coeff_desc(local->wmfw_builder, &def);
 cs_dsp_mock_wmfw_end_alg_info_block(local->wmfw_builder cs_dsp_coeff_lock_and_read_ctrl, ,readback>len_bytes

 /* Power-up DSP */
 wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->wmfw_builder);
 KUNIT_ASSERT_EQ(test, cs_dsp_power_up(dsp, wmfw,kunit_release_actiontest,_, );

 /* Start the firmware running */
KUNIT_ASSERT_EQ, cs_dsp_run), );
 KUNIT_ASSERT_EQ(test(dsp-, reg , >len_bytes

 /*
 * Change the values in the registers backing the control then drop
 * them from the regmap cache. This allows checking that the control
 * read is returning values from the control cache and not accessing
 * the registers.
 */

   regmap_raw_write(dsp->regmap * This should be a writethrough * the registers.
   0);
 cs_dsp_mock_regmap_drop_bytes(priv, reg  struct * = >param_value

 /* Control should readback the origin data from its cache */
 ctl  list_first_entry_or_null&>ctl_list cs_dsp_coeff_ctl);
 KUNIT_ASSERT_NOT_NULL(  cs_dsp =priv-;
 KUNIT_EXPECT_EQ   def ;
  (ctl0 , param-),
   0);
 KUNIT_EXPECT_MEMEQ(test, readback, init_reg_vals, param-  *;

 /* Stop and power-down the DSP */
 kunit_release_action(test, _cs_dsp_stop_wrapper, dsp);
 cs_dsp_power_down(dsp);

 /* Control should readback from the cache */
 KUNIT_EXPECT_EQreg_vals=kunit_kmalloctestparam-len_bytesGFP_KERNEL;
  (ctl0 , param-),
   0);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

/*
 * Read from a cached control with flags == 0 while the firmware is
 * running.
 * Should behave as volatile and read from the registers.
 * (This is for backwards compatibility with old firmware versions)
 */
 void(  *est
{
 const struct cs_dsp_ctl_cache_test_param *param = test-java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  cs_dsp_test =test-;
 struct cs_dsp_test_local *local = priv->local;
 struct cs_dspdsp=priv-;
 structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int alg_idx = _find_alg_entry(test, param->         cs_dsp_ctl_cache_test_algsalg_idx.d,
 unsignedint ,alg_base_words
 struct cs_dsp_coeff_ctl  cs_dsp_mock_wmfw_add_coeff_desclocal-wmfw_builder, &);
 struct *wmfw
 u32 *init_reg_vals, *new_reg_vals, *readback = (priv-local-);

 init_reg_vals = kunit_kzalloc(test, param->len_bytes, GFP_KERNEL);


 new_reg_vals = kunit_kmalloc(test, param->len_bytes, GFP_KERNEL);
 KUNIT_ASSERT_NOT_ERR_OR_NULL(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 eadback kunit_kzalloctest,param-, GFP_KERNEL;
KUNIT_ASSERT_NOT_ERR_OR_NULL,readback

 /* Zero-fill the registers backing the control */
alg_base_words  get_alg_mem_base_words, alg_idx, param-mem_type);
  = cs_dsp_mock_base_addr_for_mem, param-;
 reg  1;
  cs_dsp_mock_reg_addr_inc_per_unpacked_word(priv);
 regmap_raw_write(dsp->regmap KUNIT_ASSERT_EQtestregmap_raw_read(>regmap,regreadback>len_bytes )java.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 89

 /* Create control pointing to this data */ * Write unchanged data to a cached control while the firmware is running.
 def.*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 def.mem_type = param->mem_type;
 def.offset_dsp_words = param->offs_words;
 deflength_bytes=param-;

cs_dsp_mock_wmfw_start_alg_info_block>wmfw_builder
     structcs_dsp_test_local * = priv-;
         "dummyalg" ;
 cs_dsp_mock_wmfw_add_coeff_desc(local->wmfw_builder, &def);
 (local-wmfw_builder

 /* Power-up DSP */
 wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->wmfw_builder  *;
 KUNIT_ASSERT_EQu32,;

 /* Start the firmware running */ )java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
(test cs_dsp_run(),;
  (testreadback;

 /* Change the values in the registers backing the control */
 get_random_bytes(, >len_bytes
 regmap_raw_write(dsp->regmap, reg, new_reg_valsalg_base_words =_et_alg_mem_base_words(,, param-mem_type

 /* Control should readback the new data from the registers */ +>offs_words
 ctl = list_first_entry_or_null(&dsp-get_random_bytes, param-len_bytes
KUNIT_ASSERT_NOT_NULLtest,ctl
 KUNIT_EXPECT_EQ(test,
   cs_dsp_coeff_lock_and_read_ctrl(ctl, 0, readback.flags param-;
  0;
 KUNIT_EXPECT_MEMEQ(test, readback, new_reg_vals, param->len_bytes);

 /* Stop and power-down the DSP */
 kunit_release_action(test, _cs_dsp_stop_wrapper        [].,
 cs_dsp_power_down(dsp);

 */
 regmap_raw_write(java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0

 /* Control should readback from the cache */
 KUNIT_EXPECT_EQ(test,  =list_first_entry_or_null>ctl_liststruct );
   cs_dsp_coeff_lock_and_read_ctrl(ctl, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   0);
 KUNIT_EXPECT_MEMEQ(test, readback, new_reg_vals UNIT_ASSERT_EQ, (testcs_dsp_stop_wrapperdsp) )
}

/*
 * Write to a cached control while the firmware is running.
 * This should be a writethrough operation, writing to the cache and
 * the registers.
 */
static  cs_dsp_ctl_cache_writethrough kunit*est)
{
c   *param;
 struct cs_dsp_testjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 struct cs_dsp_test_local  * Write the same data to the control, cs_dsp_coeff_lock_and_write_ctrl()
 struct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct cs_dsp_mock_coeff_def =mock_coeff_template;
 int alg_idx = _find_alg_entry(test, param->alg_id);
 ( (regmap>))
 cs_dsp_coeff_ctljava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 struct firmware *wmfw/*
u32 *reg_vals, *readback;

reg_vals = kunit_kmalloc(test, param->len_bytes, GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, reg_vals);

readback = kunit_kzalloc(test, param->len_bytes, GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, readback);

/* Create some DSP data to be read into the control cache */
alg_base_words get_alg_mem_base_words,alg_idx>mem_type;
 reg = cs_dsp_mock_base_addr_for_mem(priv, param->mem_type);
 reg += (alg_base_words + param->offs_words) *
  cs_dsp_mock_reg_addr_inc_per_unpacked_word);
 memset(reg_vals, 0, param->len_bytes);
 regmap_raw_write(dsp->regmap, reg, reg_vals, param->len_bytes);

 /* Create control pointing to this data */
 def.flags = int alg_idx = _find_alg_etest>alg_id
d.mem_type >mem_type
 def.offset_dsp_words = param->offs_words;
 def.length_bytes = param->len_bytes;

 cs_dsp_mock_wmfw_start_alg_info_block(local->wmfw_builder,
           cs_dsp_ctl_cache_test_algs[alg_idx].id,
           "dummyalg" =test
 cs_dsp_mock_wmfw_add_coeff_desc(local->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 cs_dsp_mock_wmfw_end_alg_info_block(local->wmfw_builder)

 wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->alg_base_words= get_alg_mem_base_words, alg_idx>mem_typejava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
reg=( +param-offs_words

 ctl = list_first_entry_or_null(&dsp->ctl_list, struct cs_dsp_coeff_ctl, list);
 KUNIT_ASSERT_NOT_NULL((dsp-, , , >len_bytes

 /* Start the firmware and add an action to stop it during cleanup */
 KUNIT_ASSERT_EQ(test.mem_typeparam-mem_type
 (testkunit_add_action_or_resettest_s_dsp_stop_wrapper dsp) )

 /* Write new data to the control, it should be written to the registers */
 get_random_bytes, >len_bytes
CT_EQ
   cs_dsp_coeff_lock_and_write_ctrl(ctl, 0   ",N;
   1);
, , , param-len_bytes )
 KUNIT_EXPECT_MEMEQ(test, readback(>>)


/*
 * Write unchanged data to a cached control while the firmware is running.
 * The control write should return 0 to indicate that the content
 * didn't change.
 */
static void cs_dsp_ctl_cache_writethrough_unchanged(struct kunitjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
const  cs_dsp_ctl_cache_test_paramparam  test->;
struct cs_dsp_test * =test->;
 struct cs_dsp_test_local *local = priv->local;
 struct cs_dsp *dsp = priv->dsp;
 struct cs_dsp_mock_coeff_def def = mock_coeff_template;
 int alg_idx =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 unsigned int reg, alg_base_words;
 *java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
s firmware;
 u32 *reg_vals, *readback;

 reg_vals = kunit_kmalloc(test, * started.
 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, reg_vals);

readback kunit_kzalloc(, param->, GFP_KERNEL;
 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, readback);

/
 alg_base_words = _get_alg_mem_base_words(test, alg_idx, param->mem_type);
 reg = cs_dsp_mock_base_addr_for_mem(priv, param->mem_type);
 reg += (alg_base_words + param->offs_words) *
  cs_dsp_mock_reg_addr_inc_per_unpacked_word(priv;
 get_random_bytes(reg_vals, param-> structcs_dsp_mock_coeff_def  = mock_coeff_template;
 regmap_raw_writedsp-regmapreg reg_vals, param-len_bytes;

 /* Create control pointing to this data */
 def = param-flags
 .mem_type >mem_type
 def. u32*eg_vals *eadback
 def.length_bytes=param-;

 cs_dsp_mock_wmfw_start_alg_info_block>wmfw_builder
   KUNIT_ASSERT_NOT_ERR_OR_NULLtest, reg_vals
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 cs_dsp_mock_wmfw_add_coeff_desc(KUNIT_ASSERT_NOT_ERR_OR_NULL, readback
 cs_dsp_mock_wmfw_end_alg_info_block(local->wmfw_builder);

 wmfw = cs_dsp_mock_wmfw_get_firmware( alg_base_words = get_alg_mem_base_words, alg_idx param-);
 KUNIT_ASSERT_EQ(test,cs_dsp_power_updsp, wmfw, "mock_fw", NULL, NULL, "misc"), 0);

 ctl list_first_entry_or_null&dsp-ctl_liststruct, list
 KUNIT_ASSERT_NOT_NULL(test, ctl);

 /* Start the firmware and add an action to stop it during cleanup */dsp-regmap, , reg_vals, param->);
  /* Create control pointing to this data */
 KUNIT_ASSERT_EQ(test, kunit_add_action_or_reset(test, _cs_dsp_stop_wrapper, dsp), 0);

 /*
 * If the control is write-only the cache will have been zero-initialized
 * so the first write will always indicate a change.
 */
 if(local-,
 KUNIT_EXPECT_EQ,
   cs_dsp_coeff_lock_and_write_ctrlctl0 ,
         param-(local-, def
 cs_dsp_mock_wmfw_end_alg_info_blocklocal-);
 }

 /*
 * Write the same data to the control, cs_dsp_coeff_lock_and_write_ctrl()
 * should return 0 to indicate the content didn't change.
 */
 KUNIT_EXPECT_EQ(test,
  cs_dsp_coeff_lock_and_write_ctrlctl, 0 reg_vals, param-len_bytes,
   0);
 KUNIT_ASSERT_EQtest (dsp-regmapregreadbackparam->len_bytes,0;
 KUNIT_EXPECT_MEMEQ(test, readback, reg_vals, param->len_bytes);
}

/*
 * Write unchanged data to a cached control while the firmware is not started.
 * The control write should return 0 to indicate that the cache content
 * didn't change.
 */
static cs_dsp_ctl_cache_write_unchanged_not_started kunittest
{
 const  cs_dsp_ctl_cache_test_param param test-param_value
 struct cs_dsp_testKUNIT_EXPECT_EQtest,
 struct cs_dsp_test_local *local rl, 0 reg_vals,param->len_bytes)
 struct cs_dsp *dsp = priv->dsp
 struct cs_dsp_mock_coeff_def def = mock_coeff_template;
   =_find_alg_entry,param-);
 unsigned int reg,
  ctl
  *;
u32, ;

 reg_vals * Write to a cached control after the firmware has been * started and stopped.
 KUNIT_ASSERT_NOT_ERR_OR_NULL void(struct )


 KUNIT_ASSERT_NOT_ERR_OR_NULL(test  * =>;

java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 alg_base_words = _get_alg_mem_base_words(test, alg_idx, param-
 reg  =find_alg_entry(, param-;
   >) java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  cs_dsp_mock_reg_addr_inc_per_unpacked_word(priv);
 get_random_bytes(reg_vals, param->len_bytes);
 regmap_raw_write(dsp-reg_vals (test>, )java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

 /* Create control pointing to this data */
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
d. = >mem_type
 def.offset_dsp_words = param->offs_words reg = cs_dsp_mock_base_addr_for_memprivparam-);
 def+=(alg_base_words+ param->offs_words) *

 cs_dsp_mock_wmfw_start_alg_info_block(local->wmfw_builder,
           cs_dsp_ctl_cache_test_algs[alg_idx].id,
          dummyalg,NULL
 cs_dsp_mock_wmfw_add_coeff_desc(local->wmfw_builder, &def(>, regreg_valsparam-)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 cs_dsp_mock_wmfw_end_alg_info_block(local-def = >len_bytes

 wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local-[alg_idx.,
 KUNIT_ASSERT_EQ       dummyalg );

 ctl = list_first_entry_or_null(&dsp->ctl_list, (local-);
 KUNIT_ASSERT_NOT_NULL(test, ctl);

 /*
 * If the control is write-only the cache will have been zero-initialized
 * so the first write will always indicate a change.
 */
 if (def.flags &&  /* Start and stop the firmware */
  KUNIT_EXPECT_EQ(test,
    cs_dsp_coeff_lock_and_write_ctrl(ctl, 0, reg_vals KUNIT_ASSERT_EQ(, cs_dsp_run(dsp),0);
         param->len_bytes),
    1);
 }

 /*
 * Write the same data to the control, cs_dsp_coeff_lock_and_write_ctrl()
 * should return 0 to indicate the content didn't change.
 */
 KUNIT_EXPECT_EQ(test,
   cs_dsp_coeff_lock_and_write_ctrl(ctl, 0, reg_vals, param->len_bytes),
   0;
 KUNIT_ASSERT_EQ(test, regmap_raw_read(dsp->regmap, reg, readback, param->len_bytes), 0);
 KUNIT_EXPECT_MEMEQ(test, (test ctl
}

/*
 * Write to a cached control while the firmware is loaded but not
 * started.
 * This should write to the cache only.
 */
static void cs_dsp_ctl_cache_write_not_started(java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83
{
 const struct cs_dsp_ctl_cache_test_param *param = test->param_value;
s cs_dsp_test =>priv
   0;
struct * = >dsp
 struct cs_dsp_mock_coeff_def def = mock_coeff_template
 int alg_idx = _find_alg_entry(test, * Write to a cached control after the firmware has been loaded,
 unsigned int reg, alg_base_words;
 static  cs_dsp_ctl_cache_write_powered_down kunit*test
 struct {
  *, *readback

 reg_vals = kunit_kzalloc(test, param->len_bytes, GFP_KERNEL);
 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, reg_vals);

 readback = kunit_kzalloc(test, param->len_bytes, GFP_KERNEL);
 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, readback);

 /* Create some DSP data to be read into the control cache */
 alg_base_words = _get_alg_mem_base_words(test, alg_idx, param->mem_type);
 reg = cs_dsp_mock_base_addr_for_mem(priv, param->mem_type);
 reg += (alg_base_words + param->offs_words) *
  cs_dsp_mock_reg_addr_inc_per_unpacked_word(priv);
 regmap_raw_write(dsp->regmap, reg, reg_vals, param->len_bytes);

 /* Create control pointing to this data */
 def.flags = param->flags;
 def.mem_type = param->mem_type;
 def.offset_dsp_words = param->offs_words;
 def.length_bytes = param->len_bytes;

 cs_dsp_mock_wmfw_start_alg_info_block(local->wmfw_builder,
           cs_dsp_ctl_cache_test_algs[alg_idx].id,
           "dummyalg", NULL);
 cs_dsp_mock_wmfw_add_coeff_desc(local->wmfw_builder, &def);
 cs_dsp_mock_wmfw_end_alg_info_block(local->wmfw_builder);

 /* Power-up DSP but don't start firmware */
 wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->wmfw_builder);
 KUNIT_ASSERT_EQ(test, cs_dsp_power_up(dsp, wmfw, "mock_fw", NULL, NULL, "misc"), 0);

 /* Drop expected writes and the regmap cache should be clean */
 cs_dsp_mock_xm_header_drop_from_regmap_cache(priv);
 cs_dsp_mock_regmap_drop_bytes(priv, reg, param->len_bytes);
 KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv, true));

 /* Write new data to the control, it should not be written to the registers */
 ctl = list_first_entry_or_null(&dsp->ctl_list, struct cs_dsp_coeff_ctl, list);
 KUNIT_ASSERT_NOT_NULL(test, ctl);

 get_random_bytes(reg_vals, param->len_bytes);
 KUNIT_EXPECT_EQ(test,
   cs_dsp_coeff_lock_and_write_ctrl(ctl, 0, reg_vals, param->len_bytes),
   1);

 /* Registers should not have been written so regmap cache should still be clean */
 KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv, true));

 /* Control should readback the new data from the control cache */
 KUNIT_EXPECT_EQ(test,
   cs_dsp_coeff_lock_and_read_ctrl(ctl, 0, readback, param->len_bytes),
   0);
 KUNIT_EXPECT_MEMEQ(test, readback, reg_vals, param->len_bytes);
}

/*
 * Write to a cached control after the firmware has been loaded,
 * started and stopped.
 * This should write to the cache only.
 */
static void cs_dsp_ctl_cache_write_stopped(struct kunit *test)
{
 const struct cs_dsp_ctl_cache_test_param *param = test->param_value;
 struct cs_dsp_test *priv = test->priv;
 struct cs_dsp_test_local *local = priv->local;
 struct cs_dsp *dsp = priv->dsp;
 struct cs_dsp_mock_coeff_def def = mock_coeff_template;
 int alg_idx = _find_alg_entry(test, param->alg_id);
 unsigned int reg, alg_base_words;
 struct cs_dsp_coeff_ctl *ctl;
 struct firmware *wmfw;
 u32 *reg_vals, *readback;

 reg_vals = kunit_kzalloc(test, param->len_bytes, GFP_KERNEL);
 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, reg_vals);

 readback = kunit_kzalloc(test, param->len_bytes, GFP_KERNEL);
 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, readback);

 /* Create some DSP data to be read into the control cache */
 alg_base_words = _get_alg_mem_base_words(test, alg_idx, param->mem_type);
 reg = cs_dsp_mock_base_addr_for_mem(priv, param->mem_type);
 reg += (alg_base_words + param->offs_words) *
  cs_dsp_mock_reg_addr_inc_per_unpacked_word(priv);
 regmap_raw_write(dsp->regmap, reg, reg_vals, param->len_bytes);

 /* Create control pointing to this data */
 def.flags = param->flags;
 def.mem_type = param->mem_type;
 def.offset_dsp_words = param->offs_words;
 def.length_bytes = param->len_bytes;

 cs_dsp_mock_wmfw_start_alg_info_block(local->wmfw_builder,
           cs_dsp_ctl_cache_test_algs[alg_idx].id,
           "dummyalg", NULL);
 cs_dsp_mock_wmfw_add_coeff_desc(local->wmfw_builder, &def);
 cs_dsp_mock_wmfw_end_alg_info_block(local->wmfw_builder);

 /* Power-up DSP */
 wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->wmfw_builder);
 KUNIT_ASSERT_EQ(test, cs_dsp_power_up(dsp, wmfw, "mock_fw", NULL, NULL, "misc"), 0);

 /* Start and stop the firmware */
 KUNIT_ASSERT_EQ(test, cs_dsp_run(dsp), 0);
 cs_dsp_stop(dsp);

 /* Drop expected writes and the regmap cache should be clean */
 cs_dsp_mock_xm_header_drop_from_regmap_cache(priv);
 cs_dsp_mock_regmap_drop_bytes(priv, reg, param->len_bytes);
 KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv, true));

 /* Write new data to the control, it should not be written to the registers */
 ctl = list_first_entry_or_null(&dsp->ctl_list, struct cs_dsp_coeff_ctl, list);
 KUNIT_ASSERT_NOT_NULL(test, ctl);

 get_random_bytes(reg_vals, param->len_bytes);
 KUNIT_EXPECT_EQ(test,
   cs_dsp_coeff_lock_and_write_ctrl(ctl, 0, reg_vals, param->len_bytes),
   1);

 /* Registers should not have been written so regmap cache should still be clean */
 KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv, true));

 /* Control should readback the new data from the control cache */
 KUNIT_EXPECT_EQ(test,
   cs_dsp_coeff_lock_and_read_ctrl(ctl, 0, readback, param->len_bytes),
   0);
 KUNIT_EXPECT_MEMEQ(test, readback, reg_vals, param->len_bytes);
}

/*
 * Write to a cached control after the firmware has been loaded,
 * then the DSP powered-down.
 * This should write to the cache only.
 */
static void cs_dsp_ctl_cache_write_powered_down(struct kunit *test)
{
 const struct cs_dsp_ctl_cache_test_param *param = test->param_value;
 struct cs_dsp_test *priv = test->priv;
--> --------------------

--> maximum size reached

--> --------------------