struct via_spec {
        /* codec parameterization */
-       struct snd_kcontrol_new *mixers[6];
+       const struct snd_kcontrol_new *mixers[6];
        unsigned int num_mixers;
 
-       struct hda_verb *init_verbs[5];
+       const struct hda_verb *init_verbs[5];
        unsigned int num_iverbs;
 
        char *stream_name_analog;
-       struct hda_pcm_stream *stream_analog_playback;
-       struct hda_pcm_stream *stream_analog_capture;
+       const struct hda_pcm_stream *stream_analog_playback;
+       const struct hda_pcm_stream *stream_analog_capture;
 
        char *stream_name_digital;
-       struct hda_pcm_stream *stream_digital_playback;
-       struct hda_pcm_stream *stream_digital_capture;
+       const struct hda_pcm_stream *stream_digital_playback;
+       const struct hda_pcm_stream *stream_digital_capture;
 
        /* playback */
        struct hda_multi_out multiout;
 
        /* capture */
        unsigned int num_adc_nids;
-       hda_nid_t *adc_nids;
+       const hda_nid_t *adc_nids;
        hda_nid_t mux_nids[3];
        hda_nid_t dig_in_nid;
        hda_nid_t dig_in_pin;
                        .put = bind_pin_switch_put,                     \
                        .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0) }
 
-static struct snd_kcontrol_new via_control_templates[] = {
+static const struct snd_kcontrol_new via_control_templates[] = {
        HDA_CODEC_VOLUME(NULL, 0, 0, 0),
        HDA_CODEC_MUTE(NULL, 0, 0, 0),
        ANALOG_INPUT_MUTE,
        BIND_PIN_MUTE,
 };
 
-static hda_nid_t vt1708_adc_nids[2] = {
+static const hda_nid_t vt1708_adc_nids[2] = {
        /* ADC1-2 */
        0x15, 0x27
 };
 
-static hda_nid_t vt1709_adc_nids[3] = {
+static const hda_nid_t vt1709_adc_nids[3] = {
        /* ADC1-2 */
        0x14, 0x15, 0x16
 };
 
-static hda_nid_t vt1708B_adc_nids[2] = {
+static const hda_nid_t vt1708B_adc_nids[2] = {
        /* ADC1-2 */
        0x13, 0x14
 };
 
-static hda_nid_t vt1708S_adc_nids[2] = {
+static const hda_nid_t vt1708S_adc_nids[2] = {
        /* ADC1-2 */
        0x13, 0x14
 };
 
-static hda_nid_t vt1702_adc_nids[3] = {
+static const hda_nid_t vt1702_adc_nids[3] = {
        /* ADC1-2 */
        0x12, 0x20, 0x1F
 };
 
-static hda_nid_t vt1718S_adc_nids[2] = {
+static const hda_nid_t vt1718S_adc_nids[2] = {
        /* ADC1-2 */
        0x10, 0x11
 };
 
-static hda_nid_t vt1716S_adc_nids[2] = {
+static const hda_nid_t vt1716S_adc_nids[2] = {
        /* ADC1-2 */
        0x13, 0x14
 };
 
-static hda_nid_t vt2002P_adc_nids[2] = {
+static const hda_nid_t vt2002P_adc_nids[2] = {
        /* ADC1-2 */
        0x10, 0x11
 };
 
-static hda_nid_t vt1812_adc_nids[2] = {
+static const hda_nid_t vt1812_adc_nids[2] = {
        /* ADC1-2 */
        0x10, 0x11
 };
        __via_add_control(spec, type, name, 0, val)
 
 static struct snd_kcontrol_new *via_clone_control(struct via_spec *spec,
-                                               struct snd_kcontrol_new *tmpl)
+                               const struct snd_kcontrol_new *tmpl)
 {
        struct snd_kcontrol_new *knew;
 
        return 0;
 }
 
-static struct snd_kcontrol_new via_hp_mixer[2] = {
+static const struct snd_kcontrol_new via_hp_mixer[2] = {
        {
                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                .name = "Independent HP",
        return 1;
 }
 
-static struct snd_kcontrol_new via_smart51_mixer[2] = {
+static const struct snd_kcontrol_new via_smart51_mixer[2] = {
        {
         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
         .name = "Smart 5.1",
 }
 
 /* capture mixer elements */
-static struct snd_kcontrol_new vt1708_capture_mixer[] = {
+static const struct snd_kcontrol_new vt1708_capture_mixer[] = {
        HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_INPUT),
        HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_INPUT),
        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x27, 0x0, HDA_INPUT),
 /*
  * generic initialization of ADC, input mixers and output mixers
  */
-static struct hda_verb vt1708_volume_init_verbs[] = {
+static const struct hda_verb vt1708_volume_init_verbs[] = {
        /*
         * Unmute ADC0-1 and set the default input to mic-in
         */
        return 0;
 }
 
-static struct hda_pcm_stream vt1708_pcm_analog_playback = {
+static const struct hda_pcm_stream vt1708_pcm_analog_playback = {
        .substreams = 2,
        .channels_min = 2,
        .channels_max = 8,
        },
 };
 
-static struct hda_pcm_stream vt1708_pcm_analog_s16_playback = {
+static const struct hda_pcm_stream vt1708_pcm_analog_s16_playback = {
        .substreams = 2,
        .channels_min = 2,
        .channels_max = 8,
        },
 };
 
-static struct hda_pcm_stream vt1708_pcm_analog_capture = {
+static const struct hda_pcm_stream vt1708_pcm_analog_capture = {
        .substreams = 2,
        .channels_min = 2,
        .channels_max = 2,
        },
 };
 
-static struct hda_pcm_stream vt1708_pcm_digital_playback = {
+static const struct hda_pcm_stream vt1708_pcm_digital_playback = {
        .substreams = 1,
        .channels_min = 2,
        .channels_max = 2,
        },
 };
 
-static struct hda_pcm_stream vt1708_pcm_digital_capture = {
+static const struct hda_pcm_stream vt1708_pcm_digital_capture = {
        .substreams = 1,
        .channels_min = 2,
        .channels_max = 2,
 {
        struct via_spec *spec = codec->spec;
        struct snd_kcontrol *kctl;
-       struct snd_kcontrol_new *knew;
+       const struct snd_kcontrol_new *knew;
        int err, i;
 
        for (i = 0; i < spec->num_mixers; i++) {
 
 /*
  */
-static struct hda_codec_ops via_patch_ops = {
+static const struct hda_codec_ops via_patch_ops = {
        .build_controls = via_build_controls,
        .build_pcms = via_build_pcms,
        .init = via_init,
 static int vt_auto_create_analog_input_ctls(struct hda_codec *codec,
                                            const struct auto_pin_cfg *cfg,
                                            hda_nid_t cap_nid,
-                                           hda_nid_t pin_idxs[], int num_idxs)
+                                           const hda_nid_t pin_idxs[],
+                                           int num_idxs)
 {
        struct via_spec *spec = codec->spec;
        struct hda_input_mux *imux = &spec->private_imux[0];
 static int vt1708_auto_create_analog_input_ctls(struct hda_codec *codec,
                                                const struct auto_pin_cfg *cfg)
 {
-       static hda_nid_t pin_idxs[] = { 0xff, 0x24, 0x1d, 0x1e, 0x21 };
+       static const hda_nid_t pin_idxs[] = { 0xff, 0x24, 0x1d, 0x1e, 0x21 };
        return vt_auto_create_analog_input_ctls(codec, cfg, 0x17, pin_idxs,
                                                ARRAY_SIZE(pin_idxs));
 }
 
 #ifdef CONFIG_SND_HDA_POWER_SAVE
-static struct hda_amp_list vt1708_loopbacks[] = {
+static const struct hda_amp_list vt1708_loopbacks[] = {
        { 0x17, HDA_INPUT, 1 },
        { 0x17, HDA_INPUT, 2 },
        { 0x17, HDA_INPUT, 3 },
        return change;
 }
 
-static struct snd_kcontrol_new vt1708_jack_detectect[] = {
+static const struct snd_kcontrol_new vt1708_jack_detectect[] = {
        {
                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                .name = "Jack Detect",
 }
 
 /* capture mixer elements */
-static struct snd_kcontrol_new vt1709_capture_mixer[] = {
+static const struct snd_kcontrol_new vt1709_capture_mixer[] = {
        HDA_CODEC_VOLUME("Capture Volume", 0x14, 0x0, HDA_INPUT),
        HDA_CODEC_MUTE("Capture Switch", 0x14, 0x0, HDA_INPUT),
        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x15, 0x0, HDA_INPUT),
        { } /* end */
 };
 
-static struct hda_verb vt1709_uniwill_init_verbs[] = {
+static const struct hda_verb vt1709_uniwill_init_verbs[] = {
        {0x20, AC_VERB_SET_UNSOLICITED_ENABLE,
         AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT},
        { }
 /*
  * generic initialization of ADC, input mixers and output mixers
  */
-static struct hda_verb vt1709_10ch_volume_init_verbs[] = {
+static const struct hda_verb vt1709_10ch_volume_init_verbs[] = {
        /*
         * Unmute ADC0-2 and set the default input to mic-in
         */
        { }
 };
 
-static struct hda_pcm_stream vt1709_10ch_pcm_analog_playback = {
+static const struct hda_pcm_stream vt1709_10ch_pcm_analog_playback = {
        .substreams = 1,
        .channels_min = 2,
        .channels_max = 10,
        },
 };
 
-static struct hda_pcm_stream vt1709_6ch_pcm_analog_playback = {
+static const struct hda_pcm_stream vt1709_6ch_pcm_analog_playback = {
        .substreams = 1,
        .channels_min = 2,
        .channels_max = 6,
        },
 };
 
-static struct hda_pcm_stream vt1709_pcm_analog_capture = {
+static const struct hda_pcm_stream vt1709_pcm_analog_capture = {
        .substreams = 2,
        .channels_min = 2,
        .channels_max = 2,
        },
 };
 
-static struct hda_pcm_stream vt1709_pcm_digital_playback = {
+static const struct hda_pcm_stream vt1709_pcm_digital_playback = {
        .substreams = 1,
        .channels_min = 2,
        .channels_max = 2,
        },
 };
 
-static struct hda_pcm_stream vt1709_pcm_digital_capture = {
+static const struct hda_pcm_stream vt1709_pcm_digital_capture = {
        .substreams = 1,
        .channels_min = 2,
        .channels_max = 2,
 static int vt1709_auto_create_analog_input_ctls(struct hda_codec *codec,
                                                const struct auto_pin_cfg *cfg)
 {
-       static hda_nid_t pin_idxs[] = { 0xff, 0x23, 0x1d, 0x1e, 0x21 };
+       static const hda_nid_t pin_idxs[] = { 0xff, 0x23, 0x1d, 0x1e, 0x21 };
        return vt_auto_create_analog_input_ctls(codec, cfg, 0x18, pin_idxs,
                                                ARRAY_SIZE(pin_idxs));
 }
 }
 
 #ifdef CONFIG_SND_HDA_POWER_SAVE
-static struct hda_amp_list vt1709_loopbacks[] = {
+static const struct hda_amp_list vt1709_loopbacks[] = {
        { 0x18, HDA_INPUT, 1 },
        { 0x18, HDA_INPUT, 2 },
        { 0x18, HDA_INPUT, 3 },
 /*
  * generic initialization of ADC, input mixers and output mixers
  */
-static struct hda_verb vt1709_6ch_volume_init_verbs[] = {
+static const struct hda_verb vt1709_6ch_volume_init_verbs[] = {
        /*
         * Unmute ADC0-2 and set the default input to mic-in
         */
 }
 
 /* capture mixer elements */
-static struct snd_kcontrol_new vt1708B_capture_mixer[] = {
+static const struct snd_kcontrol_new vt1708B_capture_mixer[] = {
        HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT),
        HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT),
        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT),
 /*
  * generic initialization of ADC, input mixers and output mixers
  */
-static struct hda_verb vt1708B_8ch_volume_init_verbs[] = {
+static const struct hda_verb vt1708B_8ch_volume_init_verbs[] = {
        /*
         * Unmute ADC0-1 and set the default input to mic-in
         */
        { }
 };
 
-static struct hda_verb vt1708B_4ch_volume_init_verbs[] = {
+static const struct hda_verb vt1708B_4ch_volume_init_verbs[] = {
        /*
         * Unmute ADC0-1 and set the default input to mic-in
         */
        { }
 };
 
-static struct hda_verb vt1708B_uniwill_init_verbs[] = {
+static const struct hda_verb vt1708B_uniwill_init_verbs[] = {
        {0x1d, AC_VERB_SET_UNSOLICITED_ENABLE,
         AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT},
        {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
        return 0;
 }
 
-static struct hda_pcm_stream vt1708B_8ch_pcm_analog_playback = {
+static const struct hda_pcm_stream vt1708B_8ch_pcm_analog_playback = {
        .substreams = 2,
        .channels_min = 2,
        .channels_max = 8,
        },
 };
 
-static struct hda_pcm_stream vt1708B_4ch_pcm_analog_playback = {
+static const struct hda_pcm_stream vt1708B_4ch_pcm_analog_playback = {
        .substreams = 2,
        .channels_min = 2,
        .channels_max = 4,
        },
 };
 
-static struct hda_pcm_stream vt1708B_pcm_analog_capture = {
+static const struct hda_pcm_stream vt1708B_pcm_analog_capture = {
        .substreams = 2,
        .channels_min = 2,
        .channels_max = 2,
        },
 };
 
-static struct hda_pcm_stream vt1708B_pcm_digital_playback = {
+static const struct hda_pcm_stream vt1708B_pcm_digital_playback = {
        .substreams = 1,
        .channels_min = 2,
        .channels_max = 2,
        },
 };
 
-static struct hda_pcm_stream vt1708B_pcm_digital_capture = {
+static const struct hda_pcm_stream vt1708B_pcm_digital_capture = {
        .substreams = 1,
        .channels_min = 2,
        .channels_max = 2,
 static int vt1708B_auto_create_analog_input_ctls(struct hda_codec *codec,
                                                const struct auto_pin_cfg *cfg)
 {
-       static hda_nid_t pin_idxs[] = { 0xff, 0x1f, 0x1a, 0x1b, 0x1e };
+       static const hda_nid_t pin_idxs[] = { 0xff, 0x1f, 0x1a, 0x1b, 0x1e };
        return vt_auto_create_analog_input_ctls(codec, cfg, 0x16, pin_idxs,
                                                ARRAY_SIZE(pin_idxs));
 }
 }
 
 #ifdef CONFIG_SND_HDA_POWER_SAVE
-static struct hda_amp_list vt1708B_loopbacks[] = {
+static const struct hda_amp_list vt1708B_loopbacks[] = {
        { 0x16, HDA_INPUT, 1 },
        { 0x16, HDA_INPUT, 2 },
        { 0x16, HDA_INPUT, 3 },
 /* Patch for VT1708S */
 
 /* capture mixer elements */
-static struct snd_kcontrol_new vt1708S_capture_mixer[] = {
+static const struct snd_kcontrol_new vt1708S_capture_mixer[] = {
        HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT),
        HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT),
        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT),
        { } /* end */
 };
 
-static struct hda_verb vt1708S_volume_init_verbs[] = {
+static const struct hda_verb vt1708S_volume_init_verbs[] = {
        /* Unmute ADC0-1 and set the default input to mic-in */
        {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
        { }
 };
 
-static struct hda_verb vt1708S_uniwill_init_verbs[] = {
+static const struct hda_verb vt1708S_uniwill_init_verbs[] = {
        {0x1d, AC_VERB_SET_UNSOLICITED_ENABLE,
         AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT},
        {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
        { }
 };
 
-static struct hda_verb vt1705_uniwill_init_verbs[] = {
+static const struct hda_verb vt1705_uniwill_init_verbs[] = {
        {0x1d, AC_VERB_SET_UNSOLICITED_ENABLE,
         AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT},
        {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
        { }
 };
 
-static struct hda_pcm_stream vt1708S_pcm_analog_playback = {
+static const struct hda_pcm_stream vt1708S_pcm_analog_playback = {
        .substreams = 2,
        .channels_min = 2,
        .channels_max = 8,
        },
 };
 
-static struct hda_pcm_stream vt1705_pcm_analog_playback = {
+static const struct hda_pcm_stream vt1705_pcm_analog_playback = {
        .substreams = 2,
        .channels_min = 2,
        .channels_max = 6,
        },
 };
 
-static struct hda_pcm_stream vt1708S_pcm_analog_capture = {
+static const struct hda_pcm_stream vt1708S_pcm_analog_capture = {
        .substreams = 2,
        .channels_min = 2,
        .channels_max = 2,
        },
 };
 
-static struct hda_pcm_stream vt1708S_pcm_digital_playback = {
+static const struct hda_pcm_stream vt1708S_pcm_digital_playback = {
        .substreams = 1,
        .channels_min = 2,
        .channels_max = 2,
 static int vt1708S_auto_create_analog_input_ctls(struct hda_codec *codec,
                                                const struct auto_pin_cfg *cfg)
 {
-       static hda_nid_t pin_idxs[] = { 0x1f, 0x1a, 0x1b, 0x1e, 0, 0xff };
+       static const hda_nid_t pin_idxs[] = { 0x1f, 0x1a, 0x1b, 0x1e, 0, 0xff };
        return vt_auto_create_analog_input_ctls(codec, cfg, 0x16, pin_idxs,
                                                ARRAY_SIZE(pin_idxs));
 }
 }
 
 #ifdef CONFIG_SND_HDA_POWER_SAVE
-static struct hda_amp_list vt1708S_loopbacks[] = {
+static const struct hda_amp_list vt1708S_loopbacks[] = {
        { 0x16, HDA_INPUT, 1 },
        { 0x16, HDA_INPUT, 2 },
        { 0x16, HDA_INPUT, 3 },
 /* Patch for VT1702 */
 
 /* capture mixer elements */
-static struct snd_kcontrol_new vt1702_capture_mixer[] = {
+static const struct snd_kcontrol_new vt1702_capture_mixer[] = {
        HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_INPUT),
        HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_INPUT),
        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x20, 0x0, HDA_INPUT),
        { } /* end */
 };
 
-static struct hda_verb vt1702_volume_init_verbs[] = {
+static const struct hda_verb vt1702_volume_init_verbs[] = {
        /*
         * Unmute ADC0-1 and set the default input to mic-in
         */
        { }
 };
 
-static struct hda_verb vt1702_uniwill_init_verbs[] = {
+static const struct hda_verb vt1702_uniwill_init_verbs[] = {
        {0x17, AC_VERB_SET_UNSOLICITED_ENABLE,
         AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT},
        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
        { }
 };
 
-static struct hda_pcm_stream vt1702_pcm_analog_playback = {
+static const struct hda_pcm_stream vt1702_pcm_analog_playback = {
        .substreams = 2,
        .channels_min = 2,
        .channels_max = 2,
        },
 };
 
-static struct hda_pcm_stream vt1702_pcm_analog_capture = {
+static const struct hda_pcm_stream vt1702_pcm_analog_capture = {
        .substreams = 3,
        .channels_min = 2,
        .channels_max = 2,
        },
 };
 
-static struct hda_pcm_stream vt1702_pcm_digital_playback = {
+static const struct hda_pcm_stream vt1702_pcm_digital_playback = {
        .substreams = 2,
        .channels_min = 2,
        .channels_max = 2,
 static int vt1702_auto_create_analog_input_ctls(struct hda_codec *codec,
                                                const struct auto_pin_cfg *cfg)
 {
-       static hda_nid_t pin_idxs[] = { 0x14, 0x15, 0x18, 0xff };
+       static const hda_nid_t pin_idxs[] = { 0x14, 0x15, 0x18, 0xff };
        return vt_auto_create_analog_input_ctls(codec, cfg, 0x1a, pin_idxs,
                                                ARRAY_SIZE(pin_idxs));
 }
 }
 
 #ifdef CONFIG_SND_HDA_POWER_SAVE
-static struct hda_amp_list vt1702_loopbacks[] = {
+static const struct hda_amp_list vt1702_loopbacks[] = {
        { 0x1A, HDA_INPUT, 1 },
        { 0x1A, HDA_INPUT, 2 },
        { 0x1A, HDA_INPUT, 3 },
 /* Patch for VT1718S */
 
 /* capture mixer elements */
-static struct snd_kcontrol_new vt1718S_capture_mixer[] = {
+static const struct snd_kcontrol_new vt1718S_capture_mixer[] = {
        HDA_CODEC_VOLUME("Capture Volume", 0x10, 0x0, HDA_INPUT),
        HDA_CODEC_MUTE("Capture Switch", 0x10, 0x0, HDA_INPUT),
        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x11, 0x0, HDA_INPUT),
        { } /* end */
 };
 
-static struct hda_verb vt1718S_volume_init_verbs[] = {
+static const struct hda_verb vt1718S_volume_init_verbs[] = {
        /*
         * Unmute ADC0-1 and set the default input to mic-in
         */
 };
 
 
-static struct hda_verb vt1718S_uniwill_init_verbs[] = {
+static const struct hda_verb vt1718S_uniwill_init_verbs[] = {
        {0x28, AC_VERB_SET_UNSOLICITED_ENABLE,
         AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT},
        {0x24, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
        { }
 };
 
-static struct hda_pcm_stream vt1718S_pcm_analog_playback = {
+static const struct hda_pcm_stream vt1718S_pcm_analog_playback = {
        .substreams = 2,
        .channels_min = 2,
        .channels_max = 10,
        },
 };
 
-static struct hda_pcm_stream vt1718S_pcm_analog_capture = {
+static const struct hda_pcm_stream vt1718S_pcm_analog_capture = {
        .substreams = 2,
        .channels_min = 2,
        .channels_max = 2,
        },
 };
 
-static struct hda_pcm_stream vt1718S_pcm_digital_playback = {
+static const struct hda_pcm_stream vt1718S_pcm_digital_playback = {
        .substreams = 2,
        .channels_min = 2,
        .channels_max = 2,
        },
 };
 
-static struct hda_pcm_stream vt1718S_pcm_digital_capture = {
+static const struct hda_pcm_stream vt1718S_pcm_digital_capture = {
        .substreams = 1,
        .channels_min = 2,
        .channels_max = 2,
 static int vt1718S_auto_create_analog_input_ctls(struct hda_codec *codec,
                                                const struct auto_pin_cfg *cfg)
 {
-       static hda_nid_t pin_idxs[] = { 0x2c, 0x2b, 0x2a, 0x29, 0, 0xff };
+       static const hda_nid_t pin_idxs[] = { 0x2c, 0x2b, 0x2a, 0x29, 0, 0xff };
        return vt_auto_create_analog_input_ctls(codec, cfg, 0x21, pin_idxs,
                                                ARRAY_SIZE(pin_idxs));
 }
 }
 
 #ifdef CONFIG_SND_HDA_POWER_SAVE
-static struct hda_amp_list vt1718S_loopbacks[] = {
+static const struct hda_amp_list vt1718S_loopbacks[] = {
        { 0x21, HDA_INPUT, 1 },
        { 0x21, HDA_INPUT, 2 },
        { 0x21, HDA_INPUT, 3 },
 }
 
 /* capture mixer elements */
-static struct snd_kcontrol_new vt1716S_capture_mixer[] = {
+static const struct snd_kcontrol_new vt1716S_capture_mixer[] = {
        HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT),
        HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT),
        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT),
        { } /* end */
 };
 
-static struct snd_kcontrol_new vt1716s_dmic_mixer[] = {
+static const struct snd_kcontrol_new vt1716s_dmic_mixer[] = {
        HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x22, 0x0, HDA_INPUT),
        {
         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 
 
 /* mono-out mixer elements */
-static struct snd_kcontrol_new vt1716S_mono_out_mixer[] = {
+static const struct snd_kcontrol_new vt1716S_mono_out_mixer[] = {
        HDA_CODEC_MUTE("Mono Playback Switch", 0x2a, 0x0, HDA_OUTPUT),
        { } /* end */
 };
 
-static struct hda_verb vt1716S_volume_init_verbs[] = {
+static const struct hda_verb vt1716S_volume_init_verbs[] = {
        /*
         * Unmute ADC0-1 and set the default input to mic-in
         */
 };
 
 
-static struct hda_verb vt1716S_uniwill_init_verbs[] = {
+static const struct hda_verb vt1716S_uniwill_init_verbs[] = {
        {0x1d, AC_VERB_SET_UNSOLICITED_ENABLE,
         AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT},
        {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
        { }
 };
 
-static struct hda_pcm_stream vt1716S_pcm_analog_playback = {
+static const struct hda_pcm_stream vt1716S_pcm_analog_playback = {
        .substreams = 2,
        .channels_min = 2,
        .channels_max = 6,
        },
 };
 
-static struct hda_pcm_stream vt1716S_pcm_analog_capture = {
+static const struct hda_pcm_stream vt1716S_pcm_analog_capture = {
        .substreams = 2,
        .channels_min = 2,
        .channels_max = 2,
        },
 };
 
-static struct hda_pcm_stream vt1716S_pcm_digital_playback = {
+static const struct hda_pcm_stream vt1716S_pcm_digital_playback = {
        .substreams = 2,
        .channels_min = 2,
        .channels_max = 2,
 static int vt1716S_auto_create_analog_input_ctls(struct hda_codec *codec,
                                                const struct auto_pin_cfg *cfg)
 {
-       static hda_nid_t pin_idxs[] = { 0x1f, 0x1a, 0x1b, 0x1e, 0, 0xff };
+       static const hda_nid_t pin_idxs[] = { 0x1f, 0x1a, 0x1b, 0x1e, 0, 0xff };
        return vt_auto_create_analog_input_ctls(codec, cfg, 0x16, pin_idxs,
                                                ARRAY_SIZE(pin_idxs));
 }
 }
 
 #ifdef CONFIG_SND_HDA_POWER_SAVE
-static struct hda_amp_list vt1716S_loopbacks[] = {
+static const struct hda_amp_list vt1716S_loopbacks[] = {
        { 0x16, HDA_INPUT, 1 },
        { 0x16, HDA_INPUT, 2 },
        { 0x16, HDA_INPUT, 3 },
 /* for vt2002P */
 
 /* capture mixer elements */
-static struct snd_kcontrol_new vt2002P_capture_mixer[] = {
+static const struct snd_kcontrol_new vt2002P_capture_mixer[] = {
        HDA_CODEC_VOLUME("Capture Volume", 0x10, 0x0, HDA_INPUT),
        HDA_CODEC_MUTE("Capture Switch", 0x10, 0x0, HDA_INPUT),
        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x11, 0x0, HDA_INPUT),
        { } /* end */
 };
 
-static struct hda_verb vt2002P_volume_init_verbs[] = {
+static const struct hda_verb vt2002P_volume_init_verbs[] = {
        /* Class-D speaker related verbs */
        {0x1, 0xfe0, 0x4},
        {0x1, 0xfe9, 0x80},
        {0x1, 0xfb8, 0x88},
        { }
 };
-static struct hda_verb vt1802_volume_init_verbs[] = {
+static const struct hda_verb vt1802_volume_init_verbs[] = {
        /*
         * Unmute ADC0-1 and set the default input to mic-in
         */
 };
 
 
-static struct hda_verb vt2002P_uniwill_init_verbs[] = {
+static const struct hda_verb vt2002P_uniwill_init_verbs[] = {
        {0x25, AC_VERB_SET_UNSOLICITED_ENABLE,
         AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT},
        {0x26, AC_VERB_SET_UNSOLICITED_ENABLE,
        {0x2b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
        { }
 };
-static struct hda_verb vt1802_uniwill_init_verbs[] = {
+static const struct hda_verb vt1802_uniwill_init_verbs[] = {
        {0x25, AC_VERB_SET_UNSOLICITED_ENABLE,
         AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT},
        {0x28, AC_VERB_SET_UNSOLICITED_ENABLE,
        { }
 };
 
-static struct hda_pcm_stream vt2002P_pcm_analog_playback = {
+static const struct hda_pcm_stream vt2002P_pcm_analog_playback = {
        .substreams = 2,
        .channels_min = 2,
        .channels_max = 2,
        },
 };
 
-static struct hda_pcm_stream vt2002P_pcm_analog_capture = {
+static const struct hda_pcm_stream vt2002P_pcm_analog_capture = {
        .substreams = 2,
        .channels_min = 2,
        .channels_max = 2,
        },
 };
 
-static struct hda_pcm_stream vt2002P_pcm_digital_playback = {
+static const struct hda_pcm_stream vt2002P_pcm_digital_playback = {
        .substreams = 1,
        .channels_min = 2,
        .channels_max = 2,
 {
        struct via_spec *spec = codec->spec;
        struct hda_input_mux *imux = &spec->private_imux[0];
-       static hda_nid_t pin_idxs[] = { 0x2b, 0x2a, 0x29, 0xff };
+       static const hda_nid_t pin_idxs[] = { 0x2b, 0x2a, 0x29, 0xff };
        int err;
 
        err = vt_auto_create_analog_input_ctls(codec, cfg, 0x21, pin_idxs,
 }
 
 #ifdef CONFIG_SND_HDA_POWER_SAVE
-static struct hda_amp_list vt2002P_loopbacks[] = {
+static const struct hda_amp_list vt2002P_loopbacks[] = {
        { 0x21, HDA_INPUT, 0 },
        { 0x21, HDA_INPUT, 1 },
        { 0x21, HDA_INPUT, 2 },
 /* for vt1812 */
 
 /* capture mixer elements */
-static struct snd_kcontrol_new vt1812_capture_mixer[] = {
+static const struct snd_kcontrol_new vt1812_capture_mixer[] = {
        HDA_CODEC_VOLUME("Capture Volume", 0x10, 0x0, HDA_INPUT),
        HDA_CODEC_MUTE("Capture Switch", 0x10, 0x0, HDA_INPUT),
        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x11, 0x0, HDA_INPUT),
        { } /* end */
 };
 
-static struct hda_verb vt1812_volume_init_verbs[] = {
+static const struct hda_verb vt1812_volume_init_verbs[] = {
        /*
         * Unmute ADC0-1 and set the default input to mic-in
         */
 };
 
 
-static struct hda_verb vt1812_uniwill_init_verbs[] = {
+static const struct hda_verb vt1812_uniwill_init_verbs[] = {
        {0x33, AC_VERB_SET_UNSOLICITED_ENABLE,
         AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT},
        {0x25, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT },
        { }
 };
 
-static struct hda_pcm_stream vt1812_pcm_analog_playback = {
+static const struct hda_pcm_stream vt1812_pcm_analog_playback = {
        .substreams = 2,
        .channels_min = 2,
        .channels_max = 2,
        },
 };
 
-static struct hda_pcm_stream vt1812_pcm_analog_capture = {
+static const struct hda_pcm_stream vt1812_pcm_analog_capture = {
        .substreams = 2,
        .channels_min = 2,
        .channels_max = 2,
        },
 };
 
-static struct hda_pcm_stream vt1812_pcm_digital_playback = {
+static const struct hda_pcm_stream vt1812_pcm_digital_playback = {
        .substreams = 1,
        .channels_min = 2,
        .channels_max = 2,
 {
        struct via_spec *spec = codec->spec;
        struct hda_input_mux *imux = &spec->private_imux[0];
-       static hda_nid_t pin_idxs[] = { 0x2b, 0x2a, 0x29, 0, 0, 0xff };
+       static const hda_nid_t pin_idxs[] = { 0x2b, 0x2a, 0x29, 0, 0, 0xff };
        int err;
 
        err = vt_auto_create_analog_input_ctls(codec, cfg, 0x21, pin_idxs,
 }
 
 #ifdef CONFIG_SND_HDA_POWER_SAVE
-static struct hda_amp_list vt1812_loopbacks[] = {
+static const struct hda_amp_list vt1812_loopbacks[] = {
        { 0x21, HDA_INPUT, 0 },
        { 0x21, HDA_INPUT, 1 },
        { 0x21, HDA_INPUT, 2 },
 /*
  * patch entries
  */
-static struct hda_codec_preset snd_hda_preset_via[] = {
+static const struct hda_codec_preset snd_hda_preset_via[] = {
        { .id = 0x11061708, .name = "VT1708", .patch = patch_vt1708},
        { .id = 0x11061709, .name = "VT1708", .patch = patch_vt1708},
        { .id = 0x1106170a, .name = "VT1708", .patch = patch_vt1708},