2 * HD audio interface patch for Creative CA0132 chip
4 * Copyright (c) 2011, Creative Technology Ltd.
6 * Based on patch_ca0110.c
7 * Copyright (c) 2008 Takashi Iwai <tiwai@suse.de>
9 * This driver is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This driver is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include <linux/init.h>
25 #include <linux/delay.h>
26 #include <linux/slab.h>
27 #include <linux/pci.h>
28 #include <linux/mutex.h>
29 #include <linux/module.h>
30 #include <linux/firmware.h>
31 #include <sound/core.h>
32 #include "hda_codec.h"
33 #include "hda_local.h"
34 #include "hda_auto_parser.h"
37 #include "ca0132_regs.h"
39 /* Enable this to see controls for tuning purpose. */
40 /*#define ENABLE_TUNING_CONTROLS*/
42 #define FLOAT_ZERO 0x00000000
43 #define FLOAT_ONE 0x3f800000
44 #define FLOAT_TWO 0x40000000
45 #define FLOAT_MINUS_5 0xc0a00000
47 #define UNSOL_TAG_HP 0x10
48 #define UNSOL_TAG_AMIC1 0x12
49 #define UNSOL_TAG_DSP 0x16
51 #define DSP_DMA_WRITE_BUFLEN_INIT (1UL<<18)
52 #define DSP_DMA_WRITE_BUFLEN_OVLY (1UL<<15)
54 #define DMA_TRANSFER_FRAME_SIZE_NWORDS 8
55 #define DMA_TRANSFER_MAX_FRAME_SIZE_NWORDS 32
56 #define DMA_OVERLAY_FRAME_SIZE_NWORDS 2
58 #define MASTERCONTROL 0x80
59 #define MASTERCONTROL_ALLOC_DMA_CHAN 10
60 #define MASTERCONTROL_QUERY_SPEAKER_EQ_ADDRESS 60
62 #define WIDGET_CHIP_CTRL 0x15
63 #define WIDGET_DSP_CTRL 0x16
65 #define MEM_CONNID_MICIN1 3
66 #define MEM_CONNID_MICIN2 5
67 #define MEM_CONNID_MICOUT1 12
68 #define MEM_CONNID_MICOUT2 14
69 #define MEM_CONNID_WUH 10
70 #define MEM_CONNID_DSP 16
71 #define MEM_CONNID_DMIC 100
76 #define EFX_FILE "ctefx.bin"
78 #ifdef CONFIG_SND_HDA_CODEC_CA0132_DSP
79 MODULE_FIRMWARE(EFX_FILE);
82 static char *dirstr[2] = { "Playback", "Capture" };
95 #define VNODE_START_NID 0x80
96 VNID_SPK = VNODE_START_NID, /* Speaker vnid */
103 #define VNODES_COUNT (VNODE_END_NID - VNODE_START_NID)
105 #define EFFECT_START_NID 0x90
106 #define OUT_EFFECT_START_NID EFFECT_START_NID
107 SURROUND = OUT_EFFECT_START_NID,
114 #define OUT_EFFECTS_COUNT (OUT_EFFECT_END_NID - OUT_EFFECT_START_NID)
116 #define IN_EFFECT_START_NID OUT_EFFECT_END_NID
117 ECHO_CANCELLATION = IN_EFFECT_START_NID,
122 #define IN_EFFECTS_COUNT (IN_EFFECT_END_NID - IN_EFFECT_START_NID)
124 VOICEFX = IN_EFFECT_END_NID,
128 #define EFFECTS_COUNT (EFFECT_END_NID - EFFECT_START_NID)
131 /* Effects values size*/
132 #define EFFECT_VALS_MAX_COUNT 12
137 int mid; /*effect module ID*/
138 int reqs[EFFECT_VALS_MAX_COUNT]; /*effect module request*/
139 int direct; /* 0:output; 1:input*/
140 int params; /* number of default non-on/off params */
141 /*effect default values, 1st is on/off. */
142 unsigned int def_vals[EFFECT_VALS_MAX_COUNT];
145 #define EFX_DIR_OUT 0
148 static struct ct_effect ca0132_effects[EFFECTS_COUNT] = {
149 { .name = "Surround",
153 .direct = EFX_DIR_OUT,
155 .def_vals = {0x3F800000, 0x3F2B851F}
157 { .name = "Crystalizer",
161 .direct = EFX_DIR_OUT,
163 .def_vals = {0x3F800000, 0x3F266666}
165 { .name = "Dialog Plus",
169 .direct = EFX_DIR_OUT,
171 .def_vals = {0x00000000, 0x3F000000}
173 { .name = "Smart Volume",
177 .direct = EFX_DIR_OUT,
179 .def_vals = {0x3F800000, 0x3F3D70A4, 0x00000000}
184 .reqs = {24, 23, 25},
185 .direct = EFX_DIR_OUT,
187 .def_vals = {0x3F800000, 0x42A00000, 0x3F000000}
189 { .name = "Equalizer",
192 .reqs = {9, 10, 11, 12, 13, 14,
193 15, 16, 17, 18, 19, 20},
194 .direct = EFX_DIR_OUT,
196 .def_vals = {0x00000000, 0x00000000, 0x00000000, 0x00000000,
197 0x00000000, 0x00000000, 0x00000000, 0x00000000,
198 0x00000000, 0x00000000, 0x00000000, 0x00000000}
200 { .name = "Echo Cancellation",
201 .nid = ECHO_CANCELLATION,
203 .reqs = {0, 1, 2, 3},
204 .direct = EFX_DIR_IN,
206 .def_vals = {0x00000000, 0x3F3A9692, 0x00000000, 0x00000000}
208 { .name = "Voice Focus",
211 .reqs = {6, 7, 8, 9},
212 .direct = EFX_DIR_IN,
214 .def_vals = {0x3F800000, 0x3D7DF3B6, 0x41F00000, 0x41F00000}
220 .direct = EFX_DIR_IN,
222 .def_vals = {0x00000000, 0x3F3D70A4}
224 { .name = "Noise Reduction",
225 .nid = NOISE_REDUCTION,
228 .direct = EFX_DIR_IN,
230 .def_vals = {0x3F800000, 0x3F000000}
235 .reqs = {10, 11, 12, 13, 14, 15, 16, 17, 18},
236 .direct = EFX_DIR_IN,
238 .def_vals = {0x00000000, 0x43C80000, 0x44AF0000, 0x44FA0000,
239 0x3F800000, 0x3F800000, 0x3F800000, 0x00000000,
244 /* Tuning controls */
245 #ifdef ENABLE_TUNING_CONTROLS
248 #define TUNING_CTL_START_NID 0xC0
249 WEDGE_ANGLE = TUNING_CTL_START_NID,
262 #define TUNING_CTLS_COUNT (TUNING_CTL_END_NID - TUNING_CTL_START_NID)
265 struct ct_tuning_ctl {
267 hda_nid_t parent_nid;
269 int mid; /*effect module ID*/
270 int req; /*effect module request*/
271 int direct; /* 0:output; 1:input*/
272 unsigned int def_val;/*effect default values*/
275 static struct ct_tuning_ctl ca0132_tuning_ctls[] = {
276 { .name = "Wedge Angle",
277 .parent_nid = VOICE_FOCUS,
281 .direct = EFX_DIR_IN,
282 .def_val = 0x41F00000
284 { .name = "SVM Level",
285 .parent_nid = MIC_SVM,
289 .direct = EFX_DIR_IN,
290 .def_val = 0x3F3D70A4
292 { .name = "EQ Band0",
293 .parent_nid = EQUALIZER,
294 .nid = EQUALIZER_BAND_0,
297 .direct = EFX_DIR_OUT,
298 .def_val = 0x00000000
300 { .name = "EQ Band1",
301 .parent_nid = EQUALIZER,
302 .nid = EQUALIZER_BAND_1,
305 .direct = EFX_DIR_OUT,
306 .def_val = 0x00000000
308 { .name = "EQ Band2",
309 .parent_nid = EQUALIZER,
310 .nid = EQUALIZER_BAND_2,
313 .direct = EFX_DIR_OUT,
314 .def_val = 0x00000000
316 { .name = "EQ Band3",
317 .parent_nid = EQUALIZER,
318 .nid = EQUALIZER_BAND_3,
321 .direct = EFX_DIR_OUT,
322 .def_val = 0x00000000
324 { .name = "EQ Band4",
325 .parent_nid = EQUALIZER,
326 .nid = EQUALIZER_BAND_4,
329 .direct = EFX_DIR_OUT,
330 .def_val = 0x00000000
332 { .name = "EQ Band5",
333 .parent_nid = EQUALIZER,
334 .nid = EQUALIZER_BAND_5,
337 .direct = EFX_DIR_OUT,
338 .def_val = 0x00000000
340 { .name = "EQ Band6",
341 .parent_nid = EQUALIZER,
342 .nid = EQUALIZER_BAND_6,
345 .direct = EFX_DIR_OUT,
346 .def_val = 0x00000000
348 { .name = "EQ Band7",
349 .parent_nid = EQUALIZER,
350 .nid = EQUALIZER_BAND_7,
353 .direct = EFX_DIR_OUT,
354 .def_val = 0x00000000
356 { .name = "EQ Band8",
357 .parent_nid = EQUALIZER,
358 .nid = EQUALIZER_BAND_8,
361 .direct = EFX_DIR_OUT,
362 .def_val = 0x00000000
364 { .name = "EQ Band9",
365 .parent_nid = EQUALIZER,
366 .nid = EQUALIZER_BAND_9,
369 .direct = EFX_DIR_OUT,
370 .def_val = 0x00000000
375 /* Voice FX Presets */
376 #define VOICEFX_MAX_PARAM_COUNT 9
382 int reqs[VOICEFX_MAX_PARAM_COUNT]; /*effect module request*/
385 struct ct_voicefx_preset {
386 char *name; /*preset name*/
387 unsigned int vals[VOICEFX_MAX_PARAM_COUNT];
390 static struct ct_voicefx ca0132_voicefx = {
391 .name = "VoiceFX Capture Switch",
394 .reqs = {10, 11, 12, 13, 14, 15, 16, 17, 18}
397 static struct ct_voicefx_preset ca0132_voicefx_presets[] = {
399 .vals = { 0x00000000, 0x43C80000, 0x44AF0000,
400 0x44FA0000, 0x3F800000, 0x3F800000,
401 0x3F800000, 0x00000000, 0x00000000 }
403 { .name = "Female2Male",
404 .vals = { 0x3F800000, 0x43C80000, 0x44AF0000,
405 0x44FA0000, 0x3F19999A, 0x3F866666,
406 0x3F800000, 0x00000000, 0x00000000 }
408 { .name = "Male2Female",
409 .vals = { 0x3F800000, 0x43C80000, 0x44AF0000,
410 0x450AC000, 0x4017AE14, 0x3F6B851F,
411 0x3F800000, 0x00000000, 0x00000000 }
413 { .name = "ScrappyKid",
414 .vals = { 0x3F800000, 0x43C80000, 0x44AF0000,
415 0x44FA0000, 0x40400000, 0x3F28F5C3,
416 0x3F800000, 0x00000000, 0x00000000 }
419 .vals = { 0x3F800000, 0x44324000, 0x44BB8000,
420 0x44E10000, 0x3FB33333, 0x3FB9999A,
421 0x3F800000, 0x3E3A2E43, 0x00000000 }
424 .vals = { 0x3F800000, 0x43EA0000, 0x44A52000,
425 0x45098000, 0x3F266666, 0x3FC00000,
426 0x3F800000, 0x00000000, 0x00000000 }
429 .vals = { 0x3F800000, 0x43C70000, 0x44AE6000,
430 0x45193000, 0x3F8E147B, 0x3F75C28F,
431 0x3F800000, 0x00000000, 0x00000000 }
434 .vals = { 0x3F800000, 0x43930000, 0x44BEE000,
435 0x45007000, 0x3F451EB8, 0x3F7851EC,
436 0x3F800000, 0x00000000, 0x00000000 }
438 { .name = "AlienBrute",
439 .vals = { 0x3F800000, 0x43BFC5AC, 0x44B28FDF,
440 0x451F6000, 0x3F266666, 0x3FA7D945,
441 0x3F800000, 0x3CF5C28F, 0x00000000 }
444 .vals = { 0x3F800000, 0x43C80000, 0x44AF0000,
445 0x44FA0000, 0x3FB2718B, 0x3F800000,
446 0xBC07010E, 0x00000000, 0x00000000 }
449 .vals = { 0x3F800000, 0x43C20000, 0x44906000,
450 0x44E70000, 0x3F4CCCCD, 0x3F8A3D71,
451 0x3F0A3D71, 0x00000000, 0x00000000 }
454 .vals = { 0x3F800000, 0x43C80000, 0x44AF0000,
455 0x44FA0000, 0x3F800000, 0x3F800000,
456 0x3E4CCCCD, 0x00000000, 0x00000000 }
458 { .name = "DeepVoice",
459 .vals = { 0x3F800000, 0x43A9C5AC, 0x44AA4FDF,
460 0x44FFC000, 0x3EDBB56F, 0x3F99C4CA,
461 0x3F800000, 0x00000000, 0x00000000 }
463 { .name = "Munchkin",
464 .vals = { 0x3F800000, 0x43C80000, 0x44AF0000,
465 0x44FA0000, 0x3F800000, 0x3F1A043C,
466 0x3F800000, 0x00000000, 0x00000000 }
470 enum hda_cmd_vendor_io {
472 VENDOR_DSPIO_SCP_WRITE_DATA_LOW = 0x000,
473 VENDOR_DSPIO_SCP_WRITE_DATA_HIGH = 0x100,
475 VENDOR_DSPIO_STATUS = 0xF01,
476 VENDOR_DSPIO_SCP_POST_READ_DATA = 0x702,
477 VENDOR_DSPIO_SCP_READ_DATA = 0xF02,
478 VENDOR_DSPIO_DSP_INIT = 0x703,
479 VENDOR_DSPIO_SCP_POST_COUNT_QUERY = 0x704,
480 VENDOR_DSPIO_SCP_READ_COUNT = 0xF04,
482 /* for ChipIO node */
483 VENDOR_CHIPIO_ADDRESS_LOW = 0x000,
484 VENDOR_CHIPIO_ADDRESS_HIGH = 0x100,
485 VENDOR_CHIPIO_STREAM_FORMAT = 0x200,
486 VENDOR_CHIPIO_DATA_LOW = 0x300,
487 VENDOR_CHIPIO_DATA_HIGH = 0x400,
489 VENDOR_CHIPIO_GET_PARAMETER = 0xF00,
490 VENDOR_CHIPIO_STATUS = 0xF01,
491 VENDOR_CHIPIO_HIC_POST_READ = 0x702,
492 VENDOR_CHIPIO_HIC_READ_DATA = 0xF03,
494 VENDOR_CHIPIO_8051_DATA_WRITE = 0x707,
495 VENDOR_CHIPIO_8051_DATA_READ = 0xF07,
497 VENDOR_CHIPIO_CT_EXTENSIONS_ENABLE = 0x70A,
498 VENDOR_CHIPIO_CT_EXTENSIONS_GET = 0xF0A,
500 VENDOR_CHIPIO_PLL_PMU_WRITE = 0x70C,
501 VENDOR_CHIPIO_PLL_PMU_READ = 0xF0C,
502 VENDOR_CHIPIO_8051_ADDRESS_LOW = 0x70D,
503 VENDOR_CHIPIO_8051_ADDRESS_HIGH = 0x70E,
504 VENDOR_CHIPIO_FLAG_SET = 0x70F,
505 VENDOR_CHIPIO_FLAGS_GET = 0xF0F,
506 VENDOR_CHIPIO_PARAM_SET = 0x710,
507 VENDOR_CHIPIO_PARAM_GET = 0xF10,
509 VENDOR_CHIPIO_PORT_ALLOC_CONFIG_SET = 0x711,
510 VENDOR_CHIPIO_PORT_ALLOC_SET = 0x712,
511 VENDOR_CHIPIO_PORT_ALLOC_GET = 0xF12,
512 VENDOR_CHIPIO_PORT_FREE_SET = 0x713,
514 VENDOR_CHIPIO_PARAM_EX_ID_GET = 0xF17,
515 VENDOR_CHIPIO_PARAM_EX_ID_SET = 0x717,
516 VENDOR_CHIPIO_PARAM_EX_VALUE_GET = 0xF18,
517 VENDOR_CHIPIO_PARAM_EX_VALUE_SET = 0x718,
519 VENDOR_CHIPIO_DMIC_CTL_SET = 0x788,
520 VENDOR_CHIPIO_DMIC_CTL_GET = 0xF88,
521 VENDOR_CHIPIO_DMIC_PIN_SET = 0x789,
522 VENDOR_CHIPIO_DMIC_PIN_GET = 0xF89,
523 VENDOR_CHIPIO_DMIC_MCLK_SET = 0x78A,
524 VENDOR_CHIPIO_DMIC_MCLK_GET = 0xF8A,
526 VENDOR_CHIPIO_EAPD_SEL_SET = 0x78D
532 enum control_flag_id {
533 /* Connection manager stream setup is bypassed/enabled */
534 CONTROL_FLAG_C_MGR = 0,
535 /* DSP DMA is bypassed/enabled */
536 CONTROL_FLAG_DMA = 1,
537 /* 8051 'idle' mode is disabled/enabled */
538 CONTROL_FLAG_IDLE_ENABLE = 2,
539 /* Tracker for the SPDIF-in path is bypassed/enabled */
540 CONTROL_FLAG_TRACKER = 3,
541 /* DigitalOut to Spdif2Out connection is disabled/enabled */
542 CONTROL_FLAG_SPDIF2OUT = 4,
543 /* Digital Microphone is disabled/enabled */
544 CONTROL_FLAG_DMIC = 5,
545 /* ADC_B rate is 48 kHz/96 kHz */
546 CONTROL_FLAG_ADC_B_96KHZ = 6,
547 /* ADC_C rate is 48 kHz/96 kHz */
548 CONTROL_FLAG_ADC_C_96KHZ = 7,
549 /* DAC rate is 48 kHz/96 kHz (affects all DACs) */
550 CONTROL_FLAG_DAC_96KHZ = 8,
551 /* DSP rate is 48 kHz/96 kHz */
552 CONTROL_FLAG_DSP_96KHZ = 9,
553 /* SRC clock is 98 MHz/196 MHz (196 MHz forces rate to 96 KHz) */
554 CONTROL_FLAG_SRC_CLOCK_196MHZ = 10,
555 /* SRC rate is 48 kHz/96 kHz (48 kHz disabled when clock is 196 MHz) */
556 CONTROL_FLAG_SRC_RATE_96KHZ = 11,
557 /* Decode Loop (DSP->SRC->DSP) is disabled/enabled */
558 CONTROL_FLAG_DECODE_LOOP = 12,
559 /* De-emphasis filter on DAC-1 disabled/enabled */
560 CONTROL_FLAG_DAC1_DEEMPHASIS = 13,
561 /* De-emphasis filter on DAC-2 disabled/enabled */
562 CONTROL_FLAG_DAC2_DEEMPHASIS = 14,
563 /* De-emphasis filter on DAC-3 disabled/enabled */
564 CONTROL_FLAG_DAC3_DEEMPHASIS = 15,
565 /* High-pass filter on ADC_B disabled/enabled */
566 CONTROL_FLAG_ADC_B_HIGH_PASS = 16,
567 /* High-pass filter on ADC_C disabled/enabled */
568 CONTROL_FLAG_ADC_C_HIGH_PASS = 17,
569 /* Common mode on Port_A disabled/enabled */
570 CONTROL_FLAG_PORT_A_COMMON_MODE = 18,
571 /* Common mode on Port_D disabled/enabled */
572 CONTROL_FLAG_PORT_D_COMMON_MODE = 19,
573 /* Impedance for ramp generator on Port_A 16 Ohm/10K Ohm */
574 CONTROL_FLAG_PORT_A_10KOHM_LOAD = 20,
575 /* Impedance for ramp generator on Port_D, 16 Ohm/10K Ohm */
576 CONTROL_FLAG_PORT_D_10KOHM_LOAD = 21,
577 /* ASI rate is 48kHz/96kHz */
578 CONTROL_FLAG_ASI_96KHZ = 22,
579 /* DAC power settings able to control attached ports no/yes */
580 CONTROL_FLAG_DACS_CONTROL_PORTS = 23,
581 /* Clock Stop OK reporting is disabled/enabled */
582 CONTROL_FLAG_CONTROL_STOP_OK_ENABLE = 24,
583 /* Number of control flags */
584 CONTROL_FLAGS_MAX = (CONTROL_FLAG_CONTROL_STOP_OK_ENABLE+1)
588 * Control parameter IDs
590 enum control_param_id {
591 /* 0: None, 1: Mic1In*/
592 CONTROL_PARAM_VIP_SOURCE = 1,
593 /* 0: force HDA, 1: allow DSP if HDA Spdif1Out stream is idle */
594 CONTROL_PARAM_SPDIF1_SOURCE = 2,
595 /* Port A output stage gain setting to use when 16 Ohm output
596 * impedance is selected*/
597 CONTROL_PARAM_PORTA_160OHM_GAIN = 8,
598 /* Port D output stage gain setting to use when 16 Ohm output
599 * impedance is selected*/
600 CONTROL_PARAM_PORTD_160OHM_GAIN = 10,
604 /* Select stream with the given ID */
605 CONTROL_PARAM_STREAM_ID = 24,
606 /* Source connection point for the selected stream */
607 CONTROL_PARAM_STREAM_SOURCE_CONN_POINT = 25,
608 /* Destination connection point for the selected stream */
609 CONTROL_PARAM_STREAM_DEST_CONN_POINT = 26,
610 /* Number of audio channels in the selected stream */
611 CONTROL_PARAM_STREAMS_CHANNELS = 27,
612 /*Enable control for the selected stream */
613 CONTROL_PARAM_STREAM_CONTROL = 28,
615 /* Connection Point Control */
617 /* Select connection point with the given ID */
618 CONTROL_PARAM_CONN_POINT_ID = 29,
619 /* Connection point sample rate */
620 CONTROL_PARAM_CONN_POINT_SAMPLE_RATE = 30,
624 /* Select HDA node with the given ID */
625 CONTROL_PARAM_NODE_ID = 31
629 * Dsp Io Status codes
631 enum hda_vendor_status_dspio {
633 VENDOR_STATUS_DSPIO_OK = 0x00,
634 /* Busy, unable to accept new command, the host must retry */
635 VENDOR_STATUS_DSPIO_BUSY = 0x01,
636 /* SCP command queue is full */
637 VENDOR_STATUS_DSPIO_SCP_COMMAND_QUEUE_FULL = 0x02,
638 /* SCP response queue is empty */
639 VENDOR_STATUS_DSPIO_SCP_RESPONSE_QUEUE_EMPTY = 0x03
643 * Chip Io Status codes
645 enum hda_vendor_status_chipio {
647 VENDOR_STATUS_CHIPIO_OK = 0x00,
648 /* Busy, unable to accept new command, the host must retry */
649 VENDOR_STATUS_CHIPIO_BUSY = 0x01
655 enum ca0132_sample_rate {
675 SR_RATE_UNKNOWN = 0x1F
678 enum dsp_download_state {
679 DSP_DOWNLOAD_FAILED = -1,
680 DSP_DOWNLOAD_INIT = 0,
685 /* retrieve parameters from hda format */
686 #define get_hdafmt_chs(fmt) (fmt & 0xf)
687 #define get_hdafmt_bits(fmt) ((fmt >> 4) & 0x7)
688 #define get_hdafmt_rate(fmt) ((fmt >> 8) & 0x7f)
689 #define get_hdafmt_type(fmt) ((fmt >> 15) & 0x1)
696 struct snd_kcontrol_new *mixers[5];
697 unsigned int num_mixers;
698 const struct hda_verb *base_init_verbs;
699 const struct hda_verb *base_exit_verbs;
700 const struct hda_verb *init_verbs[5];
701 unsigned int num_init_verbs; /* exclude base init verbs */
702 struct auto_pin_cfg autocfg;
704 /* Nodes configurations */
705 struct hda_multi_out multiout;
706 hda_nid_t out_pins[AUTO_CFG_MAX_OUTS];
707 hda_nid_t dacs[AUTO_CFG_MAX_OUTS];
708 unsigned int num_outputs;
709 hda_nid_t input_pins[AUTO_PIN_LAST];
710 hda_nid_t adcs[AUTO_PIN_LAST];
713 unsigned int num_inputs;
714 hda_nid_t shared_mic_nid;
715 hda_nid_t shared_out_nid;
716 struct hda_pcm pcm_rec[5]; /* PCM information */
719 struct mutex chipio_mutex; /* chip access mutex */
722 /* DSP download related */
723 enum dsp_download_state dsp_state;
724 unsigned int dsp_stream_id;
725 unsigned int wait_scp;
726 unsigned int wait_scp_header;
727 unsigned int wait_num_data;
728 unsigned int scp_resp_header;
729 unsigned int scp_resp_data[4];
730 unsigned int scp_resp_count;
732 /* mixer and effects related */
733 unsigned char dmic_ctl;
736 long vnode_lvol[VNODES_COUNT];
737 long vnode_rvol[VNODES_COUNT];
738 long vnode_lswitch[VNODES_COUNT];
739 long vnode_rswitch[VNODES_COUNT];
740 long effects_switch[EFFECTS_COUNT];
744 #ifdef ENABLE_TUNING_CONTROLS
745 long cur_ctl_vals[TUNING_CTLS_COUNT];
750 * CA0132 codec access
752 unsigned int codec_send_command(struct hda_codec *codec, hda_nid_t nid,
753 unsigned int verb, unsigned int parm, unsigned int *res)
755 unsigned int response;
756 response = snd_hda_codec_read(codec, nid, 0, verb, parm);
759 return ((response == -1) ? -1 : 0);
762 static int codec_set_converter_format(struct hda_codec *codec, hda_nid_t nid,
763 unsigned short converter_format, unsigned int *res)
765 return codec_send_command(codec, nid, VENDOR_CHIPIO_STREAM_FORMAT,
766 converter_format & 0xffff, res);
769 static int codec_set_converter_stream_channel(struct hda_codec *codec,
770 hda_nid_t nid, unsigned char stream,
771 unsigned char channel, unsigned int *res)
773 unsigned char converter_stream_channel = 0;
775 converter_stream_channel = (stream << 4) | (channel & 0x0f);
776 return codec_send_command(codec, nid, AC_VERB_SET_CHANNEL_STREAMID,
777 converter_stream_channel, res);
780 /* Chip access helper function */
781 static int chipio_send(struct hda_codec *codec,
786 unsigned long timeout = jiffies + msecs_to_jiffies(1000);
788 /* send bits of data specified by reg */
790 res = snd_hda_codec_read(codec, WIDGET_CHIP_CTRL, 0,
792 if (res == VENDOR_STATUS_CHIPIO_OK)
795 } while (time_before(jiffies, timeout));
801 * Write chip address through the vendor widget -- NOT protected by the Mutex!
803 static int chipio_write_address(struct hda_codec *codec,
804 unsigned int chip_addx)
806 struct ca0132_spec *spec = codec->spec;
809 if (spec->curr_chip_addx == chip_addx)
812 /* send low 16 bits of the address */
813 res = chipio_send(codec, VENDOR_CHIPIO_ADDRESS_LOW,
817 /* send high 16 bits of the address */
818 res = chipio_send(codec, VENDOR_CHIPIO_ADDRESS_HIGH,
822 spec->curr_chip_addx = (res < 0) ? ~0UL : chip_addx;
828 * Write data through the vendor widget -- NOT protected by the Mutex!
830 static int chipio_write_data(struct hda_codec *codec, unsigned int data)
832 struct ca0132_spec *spec = codec->spec;
835 /* send low 16 bits of the data */
836 res = chipio_send(codec, VENDOR_CHIPIO_DATA_LOW, data & 0xffff);
839 /* send high 16 bits of the data */
840 res = chipio_send(codec, VENDOR_CHIPIO_DATA_HIGH,
844 /*If no error encountered, automatically increment the address
845 as per chip behaviour*/
846 spec->curr_chip_addx = (res != -EIO) ?
847 (spec->curr_chip_addx + 4) : ~0UL;
852 * Write multiple data through the vendor widget -- NOT protected by the Mutex!
854 static int chipio_write_data_multiple(struct hda_codec *codec,
861 snd_printdd(KERN_ERR "chipio_write_data null ptr\n");
865 while ((count-- != 0) && (status == 0))
866 status = chipio_write_data(codec, *data++);
873 * Read data through the vendor widget -- NOT protected by the Mutex!
875 static int chipio_read_data(struct hda_codec *codec, unsigned int *data)
877 struct ca0132_spec *spec = codec->spec;
881 res = chipio_send(codec, VENDOR_CHIPIO_HIC_POST_READ, 0);
885 res = chipio_send(codec, VENDOR_CHIPIO_STATUS, 0);
890 *data = snd_hda_codec_read(codec, WIDGET_CHIP_CTRL, 0,
891 VENDOR_CHIPIO_HIC_READ_DATA,
895 /*If no error encountered, automatically increment the address
896 as per chip behaviour*/
897 spec->curr_chip_addx = (res != -EIO) ?
898 (spec->curr_chip_addx + 4) : ~0UL;
903 * Write given value to the given address through the chip I/O widget.
904 * protected by the Mutex
906 static int chipio_write(struct hda_codec *codec,
907 unsigned int chip_addx, const unsigned int data)
909 struct ca0132_spec *spec = codec->spec;
912 mutex_lock(&spec->chipio_mutex);
914 /* write the address, and if successful proceed to write data */
915 err = chipio_write_address(codec, chip_addx);
919 err = chipio_write_data(codec, data);
924 mutex_unlock(&spec->chipio_mutex);
929 * Write multiple values to the given address through the chip I/O widget.
930 * protected by the Mutex
932 static int chipio_write_multiple(struct hda_codec *codec,
937 struct ca0132_spec *spec = codec->spec;
940 mutex_lock(&spec->chipio_mutex);
941 status = chipio_write_address(codec, chip_addx);
945 status = chipio_write_data_multiple(codec, data, count);
947 mutex_unlock(&spec->chipio_mutex);
953 * Read the given address through the chip I/O widget
954 * protected by the Mutex
956 static int chipio_read(struct hda_codec *codec,
957 unsigned int chip_addx, unsigned int *data)
959 struct ca0132_spec *spec = codec->spec;
962 mutex_lock(&spec->chipio_mutex);
964 /* write the address, and if successful proceed to write data */
965 err = chipio_write_address(codec, chip_addx);
969 err = chipio_read_data(codec, data);
974 mutex_unlock(&spec->chipio_mutex);
979 * Set chip control flags through the chip I/O widget.
981 static void chipio_set_control_flag(struct hda_codec *codec,
982 enum control_flag_id flag_id,
986 unsigned int flag_bit;
988 flag_bit = (flag_state ? 1 : 0);
989 val = (flag_bit << 7) | (flag_id);
990 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
991 VENDOR_CHIPIO_FLAG_SET, val);
995 * Set chip parameters through the chip I/O widget.
997 static void chipio_set_control_param(struct hda_codec *codec,
998 enum control_param_id param_id, int param_val)
1000 struct ca0132_spec *spec = codec->spec;
1003 if ((param_id < 32) && (param_val < 8)) {
1004 val = (param_val << 5) | (param_id);
1005 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1006 VENDOR_CHIPIO_PARAM_SET, val);
1008 mutex_lock(&spec->chipio_mutex);
1009 if (chipio_send(codec, VENDOR_CHIPIO_STATUS, 0) == 0) {
1010 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1011 VENDOR_CHIPIO_PARAM_EX_ID_SET,
1013 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1014 VENDOR_CHIPIO_PARAM_EX_VALUE_SET,
1017 mutex_unlock(&spec->chipio_mutex);
1022 * Set sampling rate of the connection point.
1024 static void chipio_set_conn_rate(struct hda_codec *codec,
1025 int connid, enum ca0132_sample_rate rate)
1027 chipio_set_control_param(codec, CONTROL_PARAM_CONN_POINT_ID, connid);
1028 chipio_set_control_param(codec, CONTROL_PARAM_CONN_POINT_SAMPLE_RATE,
1035 static void chipio_enable_clocks(struct hda_codec *codec)
1037 struct ca0132_spec *spec = codec->spec;
1039 mutex_lock(&spec->chipio_mutex);
1040 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1041 VENDOR_CHIPIO_8051_ADDRESS_LOW, 0);
1042 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1043 VENDOR_CHIPIO_PLL_PMU_WRITE, 0xff);
1044 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1045 VENDOR_CHIPIO_8051_ADDRESS_LOW, 5);
1046 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1047 VENDOR_CHIPIO_PLL_PMU_WRITE, 0x0b);
1048 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1049 VENDOR_CHIPIO_8051_ADDRESS_LOW, 6);
1050 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1051 VENDOR_CHIPIO_PLL_PMU_WRITE, 0xff);
1052 mutex_unlock(&spec->chipio_mutex);
1056 * CA0132 DSP IO stuffs
1058 static int dspio_send(struct hda_codec *codec, unsigned int reg,
1062 unsigned long timeout = jiffies + msecs_to_jiffies(1000);
1064 /* send bits of data specified by reg to dsp */
1066 res = snd_hda_codec_read(codec, WIDGET_DSP_CTRL, 0, reg, data);
1067 if ((res >= 0) && (res != VENDOR_STATUS_DSPIO_BUSY))
1070 } while (time_before(jiffies, timeout));
1076 * Wait for DSP to be ready for commands
1078 static void dspio_write_wait(struct hda_codec *codec)
1081 unsigned long timeout = jiffies + msecs_to_jiffies(1000);
1084 status = snd_hda_codec_read(codec, WIDGET_DSP_CTRL, 0,
1085 VENDOR_DSPIO_STATUS, 0);
1086 if ((status == VENDOR_STATUS_DSPIO_OK) ||
1087 (status == VENDOR_STATUS_DSPIO_SCP_RESPONSE_QUEUE_EMPTY))
1090 } while (time_before(jiffies, timeout));
1094 * Write SCP data to DSP
1096 static int dspio_write(struct hda_codec *codec, unsigned int scp_data)
1098 struct ca0132_spec *spec = codec->spec;
1101 dspio_write_wait(codec);
1103 mutex_lock(&spec->chipio_mutex);
1104 status = dspio_send(codec, VENDOR_DSPIO_SCP_WRITE_DATA_LOW,
1109 status = dspio_send(codec, VENDOR_DSPIO_SCP_WRITE_DATA_HIGH,
1114 /* OK, now check if the write itself has executed*/
1115 status = snd_hda_codec_read(codec, WIDGET_DSP_CTRL, 0,
1116 VENDOR_DSPIO_STATUS, 0);
1118 mutex_unlock(&spec->chipio_mutex);
1120 return (status == VENDOR_STATUS_DSPIO_SCP_COMMAND_QUEUE_FULL) ?
1125 * Write multiple SCP data to DSP
1127 static int dspio_write_multiple(struct hda_codec *codec,
1128 unsigned int *buffer, unsigned int size)
1133 if ((buffer == NULL))
1137 while (count < size) {
1138 status = dspio_write(codec, *buffer++);
1147 static int dspio_read(struct hda_codec *codec, unsigned int *data)
1151 status = dspio_send(codec, VENDOR_DSPIO_SCP_POST_READ_DATA, 0);
1155 status = dspio_send(codec, VENDOR_DSPIO_STATUS, 0);
1156 if (status == -EIO ||
1157 status == VENDOR_STATUS_DSPIO_SCP_RESPONSE_QUEUE_EMPTY)
1160 *data = snd_hda_codec_read(codec, WIDGET_DSP_CTRL, 0,
1161 VENDOR_DSPIO_SCP_READ_DATA, 0);
1166 static int dspio_read_multiple(struct hda_codec *codec, unsigned int *buffer,
1167 unsigned int *buf_size, unsigned int size_count)
1170 unsigned int size = *buf_size;
1172 unsigned int skip_count;
1175 if ((buffer == NULL))
1179 while (count < size && count < size_count) {
1180 status = dspio_read(codec, buffer++);
1188 while (skip_count < size) {
1189 status = dspio_read(codec, &dummy);
1201 * Construct the SCP header using corresponding fields
1203 static inline unsigned int
1204 make_scp_header(unsigned int target_id, unsigned int source_id,
1205 unsigned int get_flag, unsigned int req,
1206 unsigned int device_flag, unsigned int resp_flag,
1207 unsigned int error_flag, unsigned int data_size)
1209 unsigned int header = 0;
1211 header = (data_size & 0x1f) << 27;
1212 header |= (error_flag & 0x01) << 26;
1213 header |= (resp_flag & 0x01) << 25;
1214 header |= (device_flag & 0x01) << 24;
1215 header |= (req & 0x7f) << 17;
1216 header |= (get_flag & 0x01) << 16;
1217 header |= (source_id & 0xff) << 8;
1218 header |= target_id & 0xff;
1224 * Extract corresponding fields from SCP header
1227 extract_scp_header(unsigned int header,
1228 unsigned int *target_id, unsigned int *source_id,
1229 unsigned int *get_flag, unsigned int *req,
1230 unsigned int *device_flag, unsigned int *resp_flag,
1231 unsigned int *error_flag, unsigned int *data_size)
1234 *data_size = (header >> 27) & 0x1f;
1236 *error_flag = (header >> 26) & 0x01;
1238 *resp_flag = (header >> 25) & 0x01;
1240 *device_flag = (header >> 24) & 0x01;
1242 *req = (header >> 17) & 0x7f;
1244 *get_flag = (header >> 16) & 0x01;
1246 *source_id = (header >> 8) & 0xff;
1248 *target_id = header & 0xff;
1251 #define SCP_MAX_DATA_WORDS (16)
1253 /* Structure to contain any SCP message */
1256 unsigned int data[SCP_MAX_DATA_WORDS];
1259 static void dspio_clear_response_queue(struct hda_codec *codec)
1261 unsigned int dummy = 0;
1264 /* clear all from the response queue */
1266 status = dspio_read(codec, &dummy);
1267 } while (status == 0);
1270 static int dspio_get_response_data(struct hda_codec *codec)
1272 struct ca0132_spec *spec = codec->spec;
1273 unsigned int data = 0;
1276 if (dspio_read(codec, &data) < 0)
1279 if ((data & 0x00ffffff) == spec->wait_scp_header) {
1280 spec->scp_resp_header = data;
1281 spec->scp_resp_count = data >> 27;
1282 count = spec->wait_num_data;
1283 dspio_read_multiple(codec, spec->scp_resp_data,
1284 &spec->scp_resp_count, count);
1292 * Send SCP message to DSP
1294 static int dspio_send_scp_message(struct hda_codec *codec,
1295 unsigned char *send_buf,
1296 unsigned int send_buf_size,
1297 unsigned char *return_buf,
1298 unsigned int return_buf_size,
1299 unsigned int *bytes_returned)
1301 struct ca0132_spec *spec = codec->spec;
1303 unsigned int scp_send_size = 0;
1304 unsigned int total_size;
1305 bool waiting_for_resp = false;
1306 unsigned int header;
1307 struct scp_msg *ret_msg;
1308 unsigned int resp_src_id, resp_target_id;
1309 unsigned int data_size, src_id, target_id, get_flag, device_flag;
1312 *bytes_returned = 0;
1314 /* get scp header from buffer */
1315 header = *((unsigned int *)send_buf);
1316 extract_scp_header(header, &target_id, &src_id, &get_flag, NULL,
1317 &device_flag, NULL, NULL, &data_size);
1318 scp_send_size = data_size + 1;
1319 total_size = (scp_send_size * 4);
1321 if (send_buf_size < total_size)
1324 if (get_flag || device_flag) {
1325 if (!return_buf || return_buf_size < 4 || !bytes_returned)
1328 spec->wait_scp_header = *((unsigned int *)send_buf);
1330 /* swap source id with target id */
1331 resp_target_id = src_id;
1332 resp_src_id = target_id;
1333 spec->wait_scp_header &= 0xffff0000;
1334 spec->wait_scp_header |= (resp_src_id << 8) | (resp_target_id);
1335 spec->wait_num_data = return_buf_size/sizeof(unsigned int) - 1;
1337 waiting_for_resp = true;
1340 status = dspio_write_multiple(codec, (unsigned int *)send_buf,
1347 if (waiting_for_resp) {
1348 unsigned long timeout = jiffies + msecs_to_jiffies(1000);
1349 memset(return_buf, 0, return_buf_size);
1352 } while (spec->wait_scp && time_before(jiffies, timeout));
1353 waiting_for_resp = false;
1354 if (!spec->wait_scp) {
1355 ret_msg = (struct scp_msg *)return_buf;
1356 memcpy(&ret_msg->hdr, &spec->scp_resp_header, 4);
1357 memcpy(&ret_msg->data, spec->scp_resp_data,
1358 spec->wait_num_data);
1359 *bytes_returned = (spec->scp_resp_count + 1) * 4;
1371 * Prepare and send the SCP message to DSP
1372 * @codec: the HDA codec
1373 * @mod_id: ID of the DSP module to send the command
1374 * @req: ID of request to send to the DSP module
1376 * @data: pointer to the data to send with the request, request specific
1377 * @len: length of the data, in bytes
1378 * @reply: point to the buffer to hold data returned for a reply
1379 * @reply_len: length of the reply buffer returned from GET
1381 * Returns zero or a negative error code.
1383 static int dspio_scp(struct hda_codec *codec,
1384 int mod_id, int req, int dir, void *data, unsigned int len,
1385 void *reply, unsigned int *reply_len)
1388 struct scp_msg scp_send, scp_reply;
1389 unsigned int ret_bytes, send_size, ret_size;
1390 unsigned int send_get_flag, reply_resp_flag, reply_error_flag;
1391 unsigned int reply_data_size;
1393 memset(&scp_send, 0, sizeof(scp_send));
1394 memset(&scp_reply, 0, sizeof(scp_reply));
1396 if ((len != 0 && data == NULL) || (len > SCP_MAX_DATA_WORDS))
1399 if (dir == SCP_GET && reply == NULL) {
1400 snd_printdd(KERN_ERR "dspio_scp get but has no buffer\n");
1404 if (reply != NULL && (reply_len == NULL || (*reply_len == 0))) {
1405 snd_printdd(KERN_ERR "dspio_scp bad resp buf len parms\n");
1409 scp_send.hdr = make_scp_header(mod_id, 0x20, (dir == SCP_GET), req,
1410 0, 0, 0, len/sizeof(unsigned int));
1411 if (data != NULL && len > 0) {
1412 len = min((unsigned int)(sizeof(scp_send.data)), len);
1413 memcpy(scp_send.data, data, len);
1417 send_size = sizeof(unsigned int) + len;
1418 status = dspio_send_scp_message(codec, (unsigned char *)&scp_send,
1419 send_size, (unsigned char *)&scp_reply,
1420 sizeof(scp_reply), &ret_bytes);
1423 snd_printdd(KERN_ERR "dspio_scp: send scp msg failed\n");
1427 /* extract send and reply headers members */
1428 extract_scp_header(scp_send.hdr, NULL, NULL, &send_get_flag,
1429 NULL, NULL, NULL, NULL, NULL);
1430 extract_scp_header(scp_reply.hdr, NULL, NULL, NULL, NULL, NULL,
1431 &reply_resp_flag, &reply_error_flag,
1437 if (reply_resp_flag && !reply_error_flag) {
1438 ret_size = (ret_bytes - sizeof(scp_reply.hdr))
1439 / sizeof(unsigned int);
1441 if (*reply_len < ret_size*sizeof(unsigned int)) {
1442 snd_printdd(KERN_ERR "reply too long for buf\n");
1444 } else if (ret_size != reply_data_size) {
1445 snd_printdd(KERN_ERR "RetLen and HdrLen .NE.\n");
1448 *reply_len = ret_size*sizeof(unsigned int);
1449 memcpy(reply, scp_reply.data, *reply_len);
1452 snd_printdd(KERN_ERR "reply ill-formed or errflag set\n");
1460 * Set DSP parameters
1462 static int dspio_set_param(struct hda_codec *codec, int mod_id,
1463 int req, void *data, unsigned int len)
1465 return dspio_scp(codec, mod_id, req, SCP_SET, data, len, NULL, NULL);
1468 static int dspio_set_uint_param(struct hda_codec *codec, int mod_id,
1469 int req, unsigned int data)
1471 return dspio_set_param(codec, mod_id, req, &data, sizeof(unsigned int));
1475 * Allocate a DSP DMA channel via an SCP message
1477 static int dspio_alloc_dma_chan(struct hda_codec *codec, unsigned int *dma_chan)
1480 unsigned int size = sizeof(dma_chan);
1482 snd_printdd(KERN_INFO " dspio_alloc_dma_chan() -- begin\n");
1483 status = dspio_scp(codec, MASTERCONTROL, MASTERCONTROL_ALLOC_DMA_CHAN,
1484 SCP_GET, NULL, 0, dma_chan, &size);
1487 snd_printdd(KERN_INFO "dspio_alloc_dma_chan: SCP Failed\n");
1491 if ((*dma_chan + 1) == 0) {
1492 snd_printdd(KERN_INFO "no free dma channels to allocate\n");
1496 snd_printdd("dspio_alloc_dma_chan: chan=%d\n", *dma_chan);
1497 snd_printdd(KERN_INFO " dspio_alloc_dma_chan() -- complete\n");
1503 * Free a DSP DMA via an SCP message
1505 static int dspio_free_dma_chan(struct hda_codec *codec, unsigned int dma_chan)
1508 unsigned int dummy = 0;
1510 snd_printdd(KERN_INFO " dspio_free_dma_chan() -- begin\n");
1511 snd_printdd("dspio_free_dma_chan: chan=%d\n", dma_chan);
1513 status = dspio_scp(codec, MASTERCONTROL, MASTERCONTROL_ALLOC_DMA_CHAN,
1514 SCP_SET, &dma_chan, sizeof(dma_chan), NULL, &dummy);
1517 snd_printdd(KERN_INFO "dspio_free_dma_chan: SCP Failed\n");
1521 snd_printdd(KERN_INFO " dspio_free_dma_chan() -- complete\n");
1529 static int dsp_set_run_state(struct hda_codec *codec)
1531 unsigned int dbg_ctrl_reg;
1532 unsigned int halt_state;
1535 err = chipio_read(codec, DSP_DBGCNTL_INST_OFFSET, &dbg_ctrl_reg);
1539 halt_state = (dbg_ctrl_reg & DSP_DBGCNTL_STATE_MASK) >>
1540 DSP_DBGCNTL_STATE_LOBIT;
1542 if (halt_state != 0) {
1543 dbg_ctrl_reg &= ~((halt_state << DSP_DBGCNTL_SS_LOBIT) &
1544 DSP_DBGCNTL_SS_MASK);
1545 err = chipio_write(codec, DSP_DBGCNTL_INST_OFFSET,
1550 dbg_ctrl_reg |= (halt_state << DSP_DBGCNTL_EXEC_LOBIT) &
1551 DSP_DBGCNTL_EXEC_MASK;
1552 err = chipio_write(codec, DSP_DBGCNTL_INST_OFFSET,
1564 static int dsp_reset(struct hda_codec *codec)
1569 snd_printdd("dsp_reset\n");
1571 res = dspio_send(codec, VENDOR_DSPIO_DSP_INIT, 0);
1573 } while (res == -EIO && retry);
1576 snd_printdd("dsp_reset timeout\n");
1584 * Convert chip address to DSP address
1586 static unsigned int dsp_chip_to_dsp_addx(unsigned int chip_addx,
1587 bool *code, bool *yram)
1589 *code = *yram = false;
1591 if (UC_RANGE(chip_addx, 1)) {
1593 return UC_OFF(chip_addx);
1594 } else if (X_RANGE_ALL(chip_addx, 1)) {
1595 return X_OFF(chip_addx);
1596 } else if (Y_RANGE_ALL(chip_addx, 1)) {
1598 return Y_OFF(chip_addx);
1601 return INVALID_CHIP_ADDRESS;
1605 * Check if the DSP DMA is active
1607 static bool dsp_is_dma_active(struct hda_codec *codec, unsigned int dma_chan)
1609 unsigned int dma_chnlstart_reg;
1611 chipio_read(codec, DSPDMAC_CHNLSTART_INST_OFFSET, &dma_chnlstart_reg);
1613 return ((dma_chnlstart_reg & (1 <<
1614 (DSPDMAC_CHNLSTART_EN_LOBIT + dma_chan))) != 0);
1617 static int dsp_dma_setup_common(struct hda_codec *codec,
1618 unsigned int chip_addx,
1619 unsigned int dma_chan,
1620 unsigned int port_map_mask,
1624 unsigned int chnl_prop;
1625 unsigned int dsp_addx;
1626 unsigned int active;
1629 snd_printdd(KERN_INFO "-- dsp_dma_setup_common() -- Begin ---------\n");
1631 if (dma_chan >= DSPDMAC_DMA_CFG_CHANNEL_COUNT) {
1632 snd_printdd(KERN_ERR "dma chan num invalid\n");
1636 if (dsp_is_dma_active(codec, dma_chan)) {
1637 snd_printdd(KERN_ERR "dma already active\n");
1641 dsp_addx = dsp_chip_to_dsp_addx(chip_addx, &code, &yram);
1643 if (dsp_addx == INVALID_CHIP_ADDRESS) {
1644 snd_printdd(KERN_ERR "invalid chip addr\n");
1648 chnl_prop = DSPDMAC_CHNLPROP_AC_MASK;
1651 snd_printdd(KERN_INFO " dsp_dma_setup_common() start reg pgm\n");
1654 status = chipio_read(codec, DSPDMAC_CHNLPROP_INST_OFFSET,
1658 snd_printdd(KERN_ERR "read CHNLPROP Reg fail\n");
1661 snd_printdd(KERN_INFO "dsp_dma_setup_common() Read CHNLPROP\n");
1665 chnl_prop &= ~(1 << (DSPDMAC_CHNLPROP_MSPCE_LOBIT + dma_chan));
1667 chnl_prop |= (1 << (DSPDMAC_CHNLPROP_MSPCE_LOBIT + dma_chan));
1669 chnl_prop &= ~(1 << (DSPDMAC_CHNLPROP_DCON_LOBIT + dma_chan));
1671 status = chipio_write(codec, DSPDMAC_CHNLPROP_INST_OFFSET, chnl_prop);
1673 snd_printdd(KERN_ERR "write CHNLPROP Reg fail\n");
1676 snd_printdd(KERN_INFO " dsp_dma_setup_common() Write CHNLPROP\n");
1679 status = chipio_read(codec, DSPDMAC_ACTIVE_INST_OFFSET,
1683 snd_printdd(KERN_ERR "read ACTIVE Reg fail\n");
1686 snd_printdd(KERN_INFO "dsp_dma_setup_common() Read ACTIVE\n");
1689 active &= (~(1 << (DSPDMAC_ACTIVE_AAR_LOBIT + dma_chan))) &
1690 DSPDMAC_ACTIVE_AAR_MASK;
1692 status = chipio_write(codec, DSPDMAC_ACTIVE_INST_OFFSET, active);
1694 snd_printdd(KERN_ERR "write ACTIVE Reg fail\n");
1698 snd_printdd(KERN_INFO " dsp_dma_setup_common() Write ACTIVE\n");
1700 status = chipio_write(codec, DSPDMAC_AUDCHSEL_INST_OFFSET(dma_chan),
1703 snd_printdd(KERN_ERR "write AUDCHSEL Reg fail\n");
1706 snd_printdd(KERN_INFO " dsp_dma_setup_common() Write AUDCHSEL\n");
1708 status = chipio_write(codec, DSPDMAC_IRQCNT_INST_OFFSET(dma_chan),
1709 DSPDMAC_IRQCNT_BICNT_MASK | DSPDMAC_IRQCNT_CICNT_MASK);
1711 snd_printdd(KERN_ERR "write IRQCNT Reg fail\n");
1714 snd_printdd(KERN_INFO " dsp_dma_setup_common() Write IRQCNT\n");
1717 "ChipA=0x%x,DspA=0x%x,dmaCh=%u, "
1718 "CHSEL=0x%x,CHPROP=0x%x,Active=0x%x\n",
1719 chip_addx, dsp_addx, dma_chan,
1720 port_map_mask, chnl_prop, active);
1722 snd_printdd(KERN_INFO "-- dsp_dma_setup_common() -- Complete ------\n");
1728 * Setup the DSP DMA per-transfer-specific registers
1730 static int dsp_dma_setup(struct hda_codec *codec,
1731 unsigned int chip_addx,
1733 unsigned int dma_chan)
1737 unsigned int dsp_addx;
1738 unsigned int addr_field;
1739 unsigned int incr_field;
1740 unsigned int base_cnt;
1741 unsigned int cur_cnt;
1742 unsigned int dma_cfg = 0;
1743 unsigned int adr_ofs = 0;
1744 unsigned int xfr_cnt = 0;
1745 const unsigned int max_dma_count = 1 << (DSPDMAC_XFRCNT_BCNT_HIBIT -
1746 DSPDMAC_XFRCNT_BCNT_LOBIT + 1);
1748 snd_printdd(KERN_INFO "-- dsp_dma_setup() -- Begin ---------\n");
1750 if (count > max_dma_count) {
1751 snd_printdd(KERN_ERR "count too big\n");
1755 dsp_addx = dsp_chip_to_dsp_addx(chip_addx, &code, &yram);
1756 if (dsp_addx == INVALID_CHIP_ADDRESS) {
1757 snd_printdd(KERN_ERR "invalid chip addr\n");
1761 snd_printdd(KERN_INFO " dsp_dma_setup() start reg pgm\n");
1763 addr_field = dsp_addx << DSPDMAC_DMACFG_DBADR_LOBIT;
1769 addr_field |= (1 << DSPDMAC_DMACFG_DBADR_LOBIT);
1771 incr_field = (1 << DSPDMAC_DMACFG_AINCR_LOBIT);
1774 dma_cfg = addr_field + incr_field;
1775 status = chipio_write(codec, DSPDMAC_DMACFG_INST_OFFSET(dma_chan),
1778 snd_printdd(KERN_ERR "write DMACFG Reg fail\n");
1781 snd_printdd(KERN_INFO " dsp_dma_setup() Write DMACFG\n");
1783 adr_ofs = (count - 1) << (DSPDMAC_DSPADROFS_BOFS_LOBIT +
1786 status = chipio_write(codec, DSPDMAC_DSPADROFS_INST_OFFSET(dma_chan),
1789 snd_printdd(KERN_ERR "write DSPADROFS Reg fail\n");
1792 snd_printdd(KERN_INFO " dsp_dma_setup() Write DSPADROFS\n");
1794 base_cnt = (count - 1) << DSPDMAC_XFRCNT_BCNT_LOBIT;
1796 cur_cnt = (count - 1) << DSPDMAC_XFRCNT_CCNT_LOBIT;
1798 xfr_cnt = base_cnt | cur_cnt;
1800 status = chipio_write(codec,
1801 DSPDMAC_XFRCNT_INST_OFFSET(dma_chan), xfr_cnt);
1803 snd_printdd(KERN_ERR "write XFRCNT Reg fail\n");
1806 snd_printdd(KERN_INFO " dsp_dma_setup() Write XFRCNT\n");
1809 "ChipA=0x%x, cnt=0x%x, DMACFG=0x%x, "
1810 "ADROFS=0x%x, XFRCNT=0x%x\n",
1811 chip_addx, count, dma_cfg, adr_ofs, xfr_cnt);
1813 snd_printdd(KERN_INFO "-- dsp_dma_setup() -- Complete ---------\n");
1821 static int dsp_dma_start(struct hda_codec *codec,
1822 unsigned int dma_chan, bool ovly)
1824 unsigned int reg = 0;
1827 snd_printdd(KERN_INFO "-- dsp_dma_start() -- Begin ---------\n");
1830 status = chipio_read(codec,
1831 DSPDMAC_CHNLSTART_INST_OFFSET, ®);
1834 snd_printdd(KERN_ERR "read CHNLSTART reg fail\n");
1837 snd_printdd(KERN_INFO "-- dsp_dma_start() Read CHNLSTART\n");
1839 reg &= ~(DSPDMAC_CHNLSTART_EN_MASK |
1840 DSPDMAC_CHNLSTART_DIS_MASK);
1843 status = chipio_write(codec, DSPDMAC_CHNLSTART_INST_OFFSET,
1844 reg | (1 << (dma_chan + DSPDMAC_CHNLSTART_EN_LOBIT)));
1846 snd_printdd(KERN_ERR "write CHNLSTART reg fail\n");
1849 snd_printdd(KERN_INFO "-- dsp_dma_start() -- Complete ---------\n");
1857 static int dsp_dma_stop(struct hda_codec *codec,
1858 unsigned int dma_chan, bool ovly)
1860 unsigned int reg = 0;
1863 snd_printdd(KERN_INFO "-- dsp_dma_stop() -- Begin ---------\n");
1866 status = chipio_read(codec,
1867 DSPDMAC_CHNLSTART_INST_OFFSET, ®);
1870 snd_printdd(KERN_ERR "read CHNLSTART reg fail\n");
1873 snd_printdd(KERN_INFO "-- dsp_dma_stop() Read CHNLSTART\n");
1874 reg &= ~(DSPDMAC_CHNLSTART_EN_MASK |
1875 DSPDMAC_CHNLSTART_DIS_MASK);
1878 status = chipio_write(codec, DSPDMAC_CHNLSTART_INST_OFFSET,
1879 reg | (1 << (dma_chan + DSPDMAC_CHNLSTART_DIS_LOBIT)));
1881 snd_printdd(KERN_ERR "write CHNLSTART reg fail\n");
1884 snd_printdd(KERN_INFO "-- dsp_dma_stop() -- Complete ---------\n");
1890 * Allocate router ports
1892 * @codec: the HDA codec
1893 * @num_chans: number of channels in the stream
1894 * @ports_per_channel: number of ports per channel
1895 * @start_device: start device
1896 * @port_map: pointer to the port list to hold the allocated ports
1898 * Returns zero or a negative error code.
1900 static int dsp_allocate_router_ports(struct hda_codec *codec,
1901 unsigned int num_chans,
1902 unsigned int ports_per_channel,
1903 unsigned int start_device,
1904 unsigned int *port_map)
1910 status = chipio_send(codec, VENDOR_CHIPIO_STATUS, 0);
1914 val = start_device << 6;
1915 val |= (ports_per_channel - 1) << 4;
1916 val |= num_chans - 1;
1918 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1919 VENDOR_CHIPIO_PORT_ALLOC_CONFIG_SET,
1922 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1923 VENDOR_CHIPIO_PORT_ALLOC_SET,
1926 status = chipio_send(codec, VENDOR_CHIPIO_STATUS, 0);
1930 res = snd_hda_codec_read(codec, WIDGET_CHIP_CTRL, 0,
1931 VENDOR_CHIPIO_PORT_ALLOC_GET, 0);
1935 return (res < 0) ? res : 0;
1941 static int dsp_free_router_ports(struct hda_codec *codec)
1945 status = chipio_send(codec, VENDOR_CHIPIO_STATUS, 0);
1949 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1950 VENDOR_CHIPIO_PORT_FREE_SET,
1953 status = chipio_send(codec, VENDOR_CHIPIO_STATUS, 0);
1959 * Allocate DSP ports for the download stream
1961 static int dsp_allocate_ports(struct hda_codec *codec,
1962 unsigned int num_chans,
1963 unsigned int rate_multi, unsigned int *port_map)
1967 snd_printdd(KERN_INFO " dsp_allocate_ports() -- begin\n");
1969 if ((rate_multi != 1) && (rate_multi != 2) && (rate_multi != 4)) {
1970 snd_printdd(KERN_ERR "bad rate multiple\n");
1974 status = dsp_allocate_router_ports(codec, num_chans,
1975 rate_multi, 0, port_map);
1977 snd_printdd(KERN_INFO " dsp_allocate_ports() -- complete\n");
1982 static int dsp_allocate_ports_format(struct hda_codec *codec,
1983 const unsigned short fmt,
1984 unsigned int *port_map)
1987 unsigned int num_chans;
1989 unsigned int sample_rate_div = ((get_hdafmt_rate(fmt) >> 0) & 3) + 1;
1990 unsigned int sample_rate_mul = ((get_hdafmt_rate(fmt) >> 3) & 3) + 1;
1991 unsigned int rate_multi = sample_rate_mul / sample_rate_div;
1993 if ((rate_multi != 1) && (rate_multi != 2) && (rate_multi != 4)) {
1994 snd_printdd(KERN_ERR "bad rate multiple\n");
1998 num_chans = get_hdafmt_chs(fmt) + 1;
2000 status = dsp_allocate_ports(codec, num_chans, rate_multi, port_map);
2008 static int dsp_free_ports(struct hda_codec *codec)
2012 snd_printdd(KERN_INFO " dsp_free_ports() -- begin\n");
2014 status = dsp_free_router_ports(codec);
2016 snd_printdd(KERN_ERR "free router ports fail\n");
2019 snd_printdd(KERN_INFO " dsp_free_ports() -- complete\n");
2025 * HDA DMA engine stuffs for DSP code download
2028 struct hda_codec *codec;
2029 unsigned short m_converter_format;
2030 struct snd_dma_buffer *dmab;
2031 unsigned int buf_size;
2040 static int dma_convert_to_hda_format(
2041 unsigned int sample_rate,
2042 unsigned short channels,
2043 unsigned short *hda_format)
2045 unsigned int format_val;
2047 format_val = snd_hda_calc_stream_format(
2050 SNDRV_PCM_FORMAT_S32_LE,
2054 *hda_format = (unsigned short)format_val;
2060 * Reset DMA for DSP download
2062 static int dma_reset(struct dma_engine *dma)
2064 struct hda_codec *codec = dma->codec;
2065 struct ca0132_spec *spec = codec->spec;
2068 if (dma->dmab->area)
2069 snd_hda_codec_load_dsp_cleanup(codec, dma->dmab);
2071 status = snd_hda_codec_load_dsp_prepare(codec,
2072 dma->m_converter_format,
2077 spec->dsp_stream_id = status;
2081 static int dma_set_state(struct dma_engine *dma, enum dma_state state)
2085 snd_printdd("dma_set_state state=%d\n", state);
2088 case DMA_STATE_STOP:
2098 snd_hda_codec_load_dsp_trigger(dma->codec, cmd);
2102 static unsigned int dma_get_buffer_size(struct dma_engine *dma)
2104 return dma->dmab->bytes;
2107 static unsigned char *dma_get_buffer_addr(struct dma_engine *dma)
2109 return dma->dmab->area;
2112 static int dma_xfer(struct dma_engine *dma,
2113 const unsigned int *data,
2116 memcpy(dma->dmab->area, data, count);
2120 static void dma_get_converter_format(
2121 struct dma_engine *dma,
2122 unsigned short *format)
2125 *format = dma->m_converter_format;
2128 static unsigned int dma_get_stream_id(struct dma_engine *dma)
2130 struct ca0132_spec *spec = dma->codec->spec;
2132 return spec->dsp_stream_id;
2135 struct dsp_image_seg {
2142 static const u32 g_magic_value = 0x4c46584d;
2143 static const u32 g_chip_addr_magic_value = 0xFFFFFF01;
2145 static bool is_valid(const struct dsp_image_seg *p)
2147 return p->magic == g_magic_value;
2150 static bool is_hci_prog_list_seg(const struct dsp_image_seg *p)
2152 return g_chip_addr_magic_value == p->chip_addr;
2155 static bool is_last(const struct dsp_image_seg *p)
2157 return p->count == 0;
2160 static size_t dsp_sizeof(const struct dsp_image_seg *p)
2162 return sizeof(*p) + p->count*sizeof(u32);
2165 static const struct dsp_image_seg *get_next_seg_ptr(
2166 const struct dsp_image_seg *p)
2168 return (struct dsp_image_seg *)((unsigned char *)(p) + dsp_sizeof(p));
2172 * CA0132 chip DSP transfer stuffs. For DSP download.
2174 #define INVALID_DMA_CHANNEL (~0U)
2177 * Program a list of address/data pairs via the ChipIO widget.
2178 * The segment data is in the format of successive pairs of words.
2179 * These are repeated as indicated by the segment's count field.
2181 static int dspxfr_hci_write(struct hda_codec *codec,
2182 const struct dsp_image_seg *fls)
2188 if (fls == NULL || fls->chip_addr != g_chip_addr_magic_value) {
2189 snd_printdd(KERN_ERR "hci_write invalid params\n");
2194 data = (u32 *)(fls->data);
2195 while (count >= 2) {
2196 status = chipio_write(codec, data[0], data[1]);
2198 snd_printdd(KERN_ERR "hci_write chipio failed\n");
2208 * Write a block of data into DSP code or data RAM using pre-allocated
2211 * @codec: the HDA codec
2212 * @fls: pointer to a fast load image
2213 * @reloc: Relocation address for loading single-segment overlays, or 0 for
2215 * @dma_engine: pointer to DMA engine to be used for DSP download
2216 * @dma_chan: The number of DMA channels used for DSP download
2217 * @port_map_mask: port mapping
2218 * @ovly: TRUE if overlay format is required
2220 * Returns zero or a negative error code.
2222 static int dspxfr_one_seg(struct hda_codec *codec,
2223 const struct dsp_image_seg *fls,
2225 struct dma_engine *dma_engine,
2226 unsigned int dma_chan,
2227 unsigned int port_map_mask,
2231 bool comm_dma_setup_done = false;
2232 const unsigned int *data;
2233 unsigned int chip_addx;
2234 unsigned int words_to_write;
2235 unsigned int buffer_size_words;
2236 unsigned char *buffer_addx;
2237 unsigned short hda_format;
2238 unsigned int sample_rate_div;
2239 unsigned int sample_rate_mul;
2240 unsigned int num_chans;
2241 unsigned int hda_frame_size_words;
2242 unsigned int remainder_words;
2243 const u32 *data_remainder;
2244 u32 chip_addx_remainder;
2245 unsigned int run_size_words;
2246 const struct dsp_image_seg *hci_write = NULL;
2247 unsigned long timeout;
2252 if (is_hci_prog_list_seg(fls)) {
2254 fls = get_next_seg_ptr(fls);
2257 if (hci_write && (!fls || is_last(fls))) {
2258 snd_printdd("hci_write\n");
2259 return dspxfr_hci_write(codec, hci_write);
2262 if (fls == NULL || dma_engine == NULL || port_map_mask == 0) {
2263 snd_printdd("Invalid Params\n");
2268 chip_addx = fls->chip_addr,
2269 words_to_write = fls->count;
2271 if (!words_to_write)
2272 return hci_write ? dspxfr_hci_write(codec, hci_write) : 0;
2274 chip_addx = (chip_addx & (0xFFFF0000 << 2)) + (reloc << 2);
2276 if (!UC_RANGE(chip_addx, words_to_write) &&
2277 !X_RANGE_ALL(chip_addx, words_to_write) &&
2278 !Y_RANGE_ALL(chip_addx, words_to_write)) {
2279 snd_printdd("Invalid chip_addx Params\n");
2283 buffer_size_words = (unsigned int)dma_get_buffer_size(dma_engine) /
2286 buffer_addx = dma_get_buffer_addr(dma_engine);
2288 if (buffer_addx == NULL) {
2289 snd_printdd(KERN_ERR "dma_engine buffer NULL\n");
2293 dma_get_converter_format(dma_engine, &hda_format);
2294 sample_rate_div = ((get_hdafmt_rate(hda_format) >> 0) & 3) + 1;
2295 sample_rate_mul = ((get_hdafmt_rate(hda_format) >> 3) & 3) + 1;
2296 num_chans = get_hdafmt_chs(hda_format) + 1;
2298 hda_frame_size_words = ((sample_rate_div == 0) ? 0 :
2299 (num_chans * sample_rate_mul / sample_rate_div));
2301 buffer_size_words = min(buffer_size_words,
2302 (unsigned int)(UC_RANGE(chip_addx, 1) ?
2304 buffer_size_words -= buffer_size_words % hda_frame_size_words;
2306 "chpadr=0x%08x frmsz=%u nchan=%u "
2307 "rate_mul=%u div=%u bufsz=%u\n",
2308 chip_addx, hda_frame_size_words, num_chans,
2309 sample_rate_mul, sample_rate_div, buffer_size_words);
2311 if ((buffer_addx == NULL) || (hda_frame_size_words == 0) ||
2312 (buffer_size_words < hda_frame_size_words)) {
2313 snd_printdd(KERN_ERR "dspxfr_one_seg:failed\n");
2317 remainder_words = words_to_write % hda_frame_size_words;
2318 data_remainder = data;
2319 chip_addx_remainder = chip_addx;
2321 data += remainder_words;
2322 chip_addx += remainder_words*sizeof(u32);
2323 words_to_write -= remainder_words;
2325 while (words_to_write != 0) {
2326 run_size_words = min(buffer_size_words, words_to_write);
2327 snd_printdd("dspxfr (seg loop)cnt=%u rs=%u remainder=%u\n",
2328 words_to_write, run_size_words, remainder_words);
2329 dma_xfer(dma_engine, data, run_size_words*sizeof(u32));
2330 if (!comm_dma_setup_done) {
2331 status = dsp_dma_stop(codec, dma_chan, ovly);
2334 status = dsp_dma_setup_common(codec, chip_addx,
2335 dma_chan, port_map_mask, ovly);
2338 comm_dma_setup_done = true;
2341 status = dsp_dma_setup(codec, chip_addx,
2342 run_size_words, dma_chan);
2345 status = dsp_dma_start(codec, dma_chan, ovly);
2348 if (!dsp_is_dma_active(codec, dma_chan)) {
2349 snd_printdd(KERN_ERR "dspxfr:DMA did not start\n");
2352 status = dma_set_state(dma_engine, DMA_STATE_RUN);
2355 if (remainder_words != 0) {
2356 status = chipio_write_multiple(codec,
2357 chip_addx_remainder,
2362 remainder_words = 0;
2365 status = dspxfr_hci_write(codec, hci_write);
2371 timeout = jiffies + msecs_to_jiffies(2000);
2373 dma_active = dsp_is_dma_active(codec, dma_chan);
2377 } while (time_before(jiffies, timeout));
2381 snd_printdd(KERN_INFO "+++++ DMA complete\n");
2382 dma_set_state(dma_engine, DMA_STATE_STOP);
2383 status = dma_reset(dma_engine);
2388 data += run_size_words;
2389 chip_addx += run_size_words*sizeof(u32);
2390 words_to_write -= run_size_words;
2393 if (remainder_words != 0) {
2394 status = chipio_write_multiple(codec, chip_addx_remainder,
2395 data_remainder, remainder_words);
2402 * Write the entire DSP image of a DSP code/data overlay to DSP memories
2404 * @codec: the HDA codec
2405 * @fls_data: pointer to a fast load image
2406 * @reloc: Relocation address for loading single-segment overlays, or 0 for
2408 * @sample_rate: sampling rate of the stream used for DSP download
2409 * @number_channels: channels of the stream used for DSP download
2410 * @ovly: TRUE if overlay format is required
2412 * Returns zero or a negative error code.
2414 static int dspxfr_image(struct hda_codec *codec,
2415 const struct dsp_image_seg *fls_data,
2417 unsigned int sample_rate,
2418 unsigned short channels,
2421 struct ca0132_spec *spec = codec->spec;
2423 unsigned short hda_format = 0;
2424 unsigned int response;
2425 unsigned char stream_id = 0;
2426 struct dma_engine *dma_engine;
2427 unsigned int dma_chan;
2428 unsigned int port_map_mask;
2430 if (fls_data == NULL)
2433 dma_engine = kzalloc(sizeof(*dma_engine), GFP_KERNEL);
2437 dma_engine->dmab = kzalloc(sizeof(*dma_engine->dmab), GFP_KERNEL);
2438 if (!dma_engine->dmab) {
2443 dma_engine->codec = codec;
2444 dma_convert_to_hda_format(sample_rate, channels, &hda_format);
2445 dma_engine->m_converter_format = hda_format;
2446 dma_engine->buf_size = (ovly ? DSP_DMA_WRITE_BUFLEN_OVLY :
2447 DSP_DMA_WRITE_BUFLEN_INIT) * 2;
2449 dma_chan = ovly ? INVALID_DMA_CHANNEL : 0;
2451 status = codec_set_converter_format(codec, WIDGET_CHIP_CTRL,
2452 hda_format, &response);
2455 snd_printdd(KERN_ERR "set converter format fail\n");
2459 status = snd_hda_codec_load_dsp_prepare(codec,
2460 dma_engine->m_converter_format,
2461 dma_engine->buf_size,
2465 spec->dsp_stream_id = status;
2468 status = dspio_alloc_dma_chan(codec, &dma_chan);
2470 snd_printdd(KERN_ERR "alloc dmachan fail\n");
2471 dma_chan = INVALID_DMA_CHANNEL;
2477 status = dsp_allocate_ports_format(codec, hda_format,
2480 snd_printdd(KERN_ERR "alloc ports fail\n");
2484 stream_id = dma_get_stream_id(dma_engine);
2485 status = codec_set_converter_stream_channel(codec,
2486 WIDGET_CHIP_CTRL, stream_id, 0, &response);
2488 snd_printdd(KERN_ERR "set stream chan fail\n");
2492 while ((fls_data != NULL) && !is_last(fls_data)) {
2493 if (!is_valid(fls_data)) {
2494 snd_printdd(KERN_ERR "FLS check fail\n");
2498 status = dspxfr_one_seg(codec, fls_data, reloc,
2499 dma_engine, dma_chan,
2500 port_map_mask, ovly);
2504 if (is_hci_prog_list_seg(fls_data))
2505 fls_data = get_next_seg_ptr(fls_data);
2507 if ((fls_data != NULL) && !is_last(fls_data))
2508 fls_data = get_next_seg_ptr(fls_data);
2511 if (port_map_mask != 0)
2512 status = dsp_free_ports(codec);
2517 status = codec_set_converter_stream_channel(codec,
2518 WIDGET_CHIP_CTRL, 0, 0, &response);
2521 if (ovly && (dma_chan != INVALID_DMA_CHANNEL))
2522 dspio_free_dma_chan(codec, dma_chan);
2524 if (dma_engine->dmab->area)
2525 snd_hda_codec_load_dsp_cleanup(codec, dma_engine->dmab);
2526 kfree(dma_engine->dmab);
2533 * CA0132 DSP download stuffs.
2535 static void dspload_post_setup(struct hda_codec *codec)
2537 snd_printdd(KERN_INFO "---- dspload_post_setup ------\n");
2539 /*set DSP speaker to 2.0 configuration*/
2540 chipio_write(codec, XRAM_XRAM_INST_OFFSET(0x18), 0x08080080);
2541 chipio_write(codec, XRAM_XRAM_INST_OFFSET(0x19), 0x3f800000);
2543 /*update write pointer*/
2544 chipio_write(codec, XRAM_XRAM_INST_OFFSET(0x29), 0x00000002);
2548 * Download DSP from a DSP Image Fast Load structure. This structure is a
2549 * linear, non-constant sized element array of structures, each of which
2550 * contain the count of the data to be loaded, the data itself, and the
2551 * corresponding starting chip address of the starting data location.
2553 * @codec: the HDA codec
2554 * @fls: pointer to a fast load image
2555 * @ovly: TRUE if overlay format is required
2556 * @reloc: Relocation address for loading single-segment overlays, or 0 for
2558 * @autostart: TRUE if DSP starts after loading; ignored if ovly is TRUE
2559 * @router_chans: number of audio router channels to be allocated (0 means use
2560 * internal defaults; max is 32)
2562 * Returns zero or a negative error code.
2564 static int dspload_image(struct hda_codec *codec,
2565 const struct dsp_image_seg *fls,
2572 unsigned int sample_rate;
2573 unsigned short channels;
2575 snd_printdd(KERN_INFO "---- dspload_image begin ------\n");
2576 if (router_chans == 0) {
2578 router_chans = DMA_TRANSFER_FRAME_SIZE_NWORDS;
2580 router_chans = DMA_OVERLAY_FRAME_SIZE_NWORDS;
2583 sample_rate = 48000;
2584 channels = (unsigned short)router_chans;
2586 while (channels > 16) {
2592 snd_printdd(KERN_INFO "Ready to program DMA\n");
2594 status = dsp_reset(codec);
2599 snd_printdd(KERN_INFO "dsp_reset() complete\n");
2600 status = dspxfr_image(codec, fls, reloc, sample_rate, channels,
2606 snd_printdd(KERN_INFO "dspxfr_image() complete\n");
2607 if (autostart && !ovly) {
2608 dspload_post_setup(codec);
2609 status = dsp_set_run_state(codec);
2612 snd_printdd(KERN_INFO "LOAD FINISHED\n");
2618 #ifdef CONFIG_SND_HDA_CODEC_CA0132_DSP
2619 static bool dspload_is_loaded(struct hda_codec *codec)
2621 unsigned int data = 0;
2624 status = chipio_read(codec, 0x40004, &data);
2625 if ((status < 0) || (data != 1))
2631 #define dspload_is_loaded(codec) false
2634 static bool dspload_wait_loaded(struct hda_codec *codec)
2636 unsigned long timeout = jiffies + msecs_to_jiffies(2000);
2639 if (dspload_is_loaded(codec)) {
2640 pr_info("ca0132 DOWNLOAD OK :-) DSP IS RUNNING.\n");
2644 } while (time_before(jiffies, timeout));
2646 pr_err("ca0132 DOWNLOAD FAILED!!! DSP IS NOT RUNNING.\n");
2653 static void ca0132_setup_stream(struct hda_codec *codec, hda_nid_t nid,
2655 int channel_id, int format)
2657 unsigned int oldval, newval;
2663 "ca0132_setup_stream: NID=0x%x, stream=0x%x, "
2664 "channel=%d, format=0x%x\n",
2665 nid, stream_tag, channel_id, format);
2667 /* update the format-id if changed */
2668 oldval = snd_hda_codec_read(codec, nid, 0,
2669 AC_VERB_GET_STREAM_FORMAT,
2671 if (oldval != format) {
2673 snd_hda_codec_write(codec, nid, 0,
2674 AC_VERB_SET_STREAM_FORMAT,
2678 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
2679 newval = (stream_tag << 4) | channel_id;
2680 if (oldval != newval) {
2681 snd_hda_codec_write(codec, nid, 0,
2682 AC_VERB_SET_CHANNEL_STREAMID,
2687 static void ca0132_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
2694 snd_printdd(KERN_INFO "ca0132_cleanup_stream: NID=0x%x\n", nid);
2696 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
2700 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
2701 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
2707 static int ca0132_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2708 struct hda_codec *codec,
2709 unsigned int stream_tag,
2710 unsigned int format,
2711 struct snd_pcm_substream *substream)
2713 struct ca0132_spec *spec = codec->spec;
2715 ca0132_setup_stream(codec, spec->dacs[0], stream_tag, 0, format);
2720 static int ca0132_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2721 struct hda_codec *codec,
2722 struct snd_pcm_substream *substream)
2724 struct ca0132_spec *spec = codec->spec;
2726 if (spec->dsp_state == DSP_DOWNLOADING)
2729 /*If Playback effects are on, allow stream some time to flush
2731 if (spec->effects_switch[PLAY_ENHANCEMENT - EFFECT_START_NID])
2734 ca0132_cleanup_stream(codec, spec->dacs[0]);
2742 static int ca0132_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2743 struct hda_codec *codec,
2744 struct snd_pcm_substream *substream)
2746 struct ca0132_spec *spec = codec->spec;
2747 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2750 static int ca0132_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2751 struct hda_codec *codec,
2752 unsigned int stream_tag,
2753 unsigned int format,
2754 struct snd_pcm_substream *substream)
2756 struct ca0132_spec *spec = codec->spec;
2757 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2758 stream_tag, format, substream);
2761 static int ca0132_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2762 struct hda_codec *codec,
2763 struct snd_pcm_substream *substream)
2765 struct ca0132_spec *spec = codec->spec;
2766 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2769 static int ca0132_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2770 struct hda_codec *codec,
2771 struct snd_pcm_substream *substream)
2773 struct ca0132_spec *spec = codec->spec;
2774 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2780 static int ca0132_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2781 struct hda_codec *codec,
2782 unsigned int stream_tag,
2783 unsigned int format,
2784 struct snd_pcm_substream *substream)
2786 struct ca0132_spec *spec = codec->spec;
2788 ca0132_setup_stream(codec, spec->adcs[substream->number],
2789 stream_tag, 0, format);
2794 static int ca0132_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2795 struct hda_codec *codec,
2796 struct snd_pcm_substream *substream)
2798 struct ca0132_spec *spec = codec->spec;
2800 if (spec->dsp_state == DSP_DOWNLOADING)
2803 ca0132_cleanup_stream(codec, hinfo->nid);
2812 * Mixer controls helpers.
2814 #define CA0132_CODEC_VOL_MONO(xname, nid, channel, dir) \
2815 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2817 .subdevice = HDA_SUBDEV_AMP_FLAG, \
2818 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2819 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2820 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \
2821 .info = ca0132_volume_info, \
2822 .get = ca0132_volume_get, \
2823 .put = ca0132_volume_put, \
2824 .tlv = { .c = ca0132_volume_tlv }, \
2825 .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, 0, dir) }
2827 #define CA0132_CODEC_MUTE_MONO(xname, nid, channel, dir) \
2828 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2830 .subdevice = HDA_SUBDEV_AMP_FLAG, \
2831 .info = snd_hda_mixer_amp_switch_info, \
2832 .get = ca0132_switch_get, \
2833 .put = ca0132_switch_put, \
2834 .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, 0, dir) }
2837 #define CA0132_CODEC_VOL(xname, nid, dir) \
2838 CA0132_CODEC_VOL_MONO(xname, nid, 3, dir)
2839 #define CA0132_CODEC_MUTE(xname, nid, dir) \
2840 CA0132_CODEC_MUTE_MONO(xname, nid, 3, dir)
2842 /* The followings are for tuning of products */
2843 #ifdef ENABLE_TUNING_CONTROLS
2845 static unsigned int voice_focus_vals_lookup[] = {
2846 0x41A00000, 0x41A80000, 0x41B00000, 0x41B80000, 0x41C00000, 0x41C80000,
2847 0x41D00000, 0x41D80000, 0x41E00000, 0x41E80000, 0x41F00000, 0x41F80000,
2848 0x42000000, 0x42040000, 0x42080000, 0x420C0000, 0x42100000, 0x42140000,
2849 0x42180000, 0x421C0000, 0x42200000, 0x42240000, 0x42280000, 0x422C0000,
2850 0x42300000, 0x42340000, 0x42380000, 0x423C0000, 0x42400000, 0x42440000,
2851 0x42480000, 0x424C0000, 0x42500000, 0x42540000, 0x42580000, 0x425C0000,
2852 0x42600000, 0x42640000, 0x42680000, 0x426C0000, 0x42700000, 0x42740000,
2853 0x42780000, 0x427C0000, 0x42800000, 0x42820000, 0x42840000, 0x42860000,
2854 0x42880000, 0x428A0000, 0x428C0000, 0x428E0000, 0x42900000, 0x42920000,
2855 0x42940000, 0x42960000, 0x42980000, 0x429A0000, 0x429C0000, 0x429E0000,
2856 0x42A00000, 0x42A20000, 0x42A40000, 0x42A60000, 0x42A80000, 0x42AA0000,
2857 0x42AC0000, 0x42AE0000, 0x42B00000, 0x42B20000, 0x42B40000, 0x42B60000,
2858 0x42B80000, 0x42BA0000, 0x42BC0000, 0x42BE0000, 0x42C00000, 0x42C20000,
2859 0x42C40000, 0x42C60000, 0x42C80000, 0x42CA0000, 0x42CC0000, 0x42CE0000,
2860 0x42D00000, 0x42D20000, 0x42D40000, 0x42D60000, 0x42D80000, 0x42DA0000,
2861 0x42DC0000, 0x42DE0000, 0x42E00000, 0x42E20000, 0x42E40000, 0x42E60000,
2862 0x42E80000, 0x42EA0000, 0x42EC0000, 0x42EE0000, 0x42F00000, 0x42F20000,
2863 0x42F40000, 0x42F60000, 0x42F80000, 0x42FA0000, 0x42FC0000, 0x42FE0000,
2864 0x43000000, 0x43010000, 0x43020000, 0x43030000, 0x43040000, 0x43050000,
2865 0x43060000, 0x43070000, 0x43080000, 0x43090000, 0x430A0000, 0x430B0000,
2866 0x430C0000, 0x430D0000, 0x430E0000, 0x430F0000, 0x43100000, 0x43110000,
2867 0x43120000, 0x43130000, 0x43140000, 0x43150000, 0x43160000, 0x43170000,
2868 0x43180000, 0x43190000, 0x431A0000, 0x431B0000, 0x431C0000, 0x431D0000,
2869 0x431E0000, 0x431F0000, 0x43200000, 0x43210000, 0x43220000, 0x43230000,
2870 0x43240000, 0x43250000, 0x43260000, 0x43270000, 0x43280000, 0x43290000,
2871 0x432A0000, 0x432B0000, 0x432C0000, 0x432D0000, 0x432E0000, 0x432F0000,
2872 0x43300000, 0x43310000, 0x43320000, 0x43330000, 0x43340000
2875 static unsigned int mic_svm_vals_lookup[] = {
2876 0x00000000, 0x3C23D70A, 0x3CA3D70A, 0x3CF5C28F, 0x3D23D70A, 0x3D4CCCCD,
2877 0x3D75C28F, 0x3D8F5C29, 0x3DA3D70A, 0x3DB851EC, 0x3DCCCCCD, 0x3DE147AE,
2878 0x3DF5C28F, 0x3E051EB8, 0x3E0F5C29, 0x3E19999A, 0x3E23D70A, 0x3E2E147B,
2879 0x3E3851EC, 0x3E428F5C, 0x3E4CCCCD, 0x3E570A3D, 0x3E6147AE, 0x3E6B851F,
2880 0x3E75C28F, 0x3E800000, 0x3E851EB8, 0x3E8A3D71, 0x3E8F5C29, 0x3E947AE1,
2881 0x3E99999A, 0x3E9EB852, 0x3EA3D70A, 0x3EA8F5C3, 0x3EAE147B, 0x3EB33333,
2882 0x3EB851EC, 0x3EBD70A4, 0x3EC28F5C, 0x3EC7AE14, 0x3ECCCCCD, 0x3ED1EB85,
2883 0x3ED70A3D, 0x3EDC28F6, 0x3EE147AE, 0x3EE66666, 0x3EEB851F, 0x3EF0A3D7,
2884 0x3EF5C28F, 0x3EFAE148, 0x3F000000, 0x3F028F5C, 0x3F051EB8, 0x3F07AE14,
2885 0x3F0A3D71, 0x3F0CCCCD, 0x3F0F5C29, 0x3F11EB85, 0x3F147AE1, 0x3F170A3D,
2886 0x3F19999A, 0x3F1C28F6, 0x3F1EB852, 0x3F2147AE, 0x3F23D70A, 0x3F266666,
2887 0x3F28F5C3, 0x3F2B851F, 0x3F2E147B, 0x3F30A3D7, 0x3F333333, 0x3F35C28F,
2888 0x3F3851EC, 0x3F3AE148, 0x3F3D70A4, 0x3F400000, 0x3F428F5C, 0x3F451EB8,
2889 0x3F47AE14, 0x3F4A3D71, 0x3F4CCCCD, 0x3F4F5C29, 0x3F51EB85, 0x3F547AE1,
2890 0x3F570A3D, 0x3F59999A, 0x3F5C28F6, 0x3F5EB852, 0x3F6147AE, 0x3F63D70A,
2891 0x3F666666, 0x3F68F5C3, 0x3F6B851F, 0x3F6E147B, 0x3F70A3D7, 0x3F733333,
2892 0x3F75C28F, 0x3F7851EC, 0x3F7AE148, 0x3F7D70A4, 0x3F800000
2895 static unsigned int equalizer_vals_lookup[] = {
2896 0xC1C00000, 0xC1B80000, 0xC1B00000, 0xC1A80000, 0xC1A00000, 0xC1980000,
2897 0xC1900000, 0xC1880000, 0xC1800000, 0xC1700000, 0xC1600000, 0xC1500000,
2898 0xC1400000, 0xC1300000, 0xC1200000, 0xC1100000, 0xC1000000, 0xC0E00000,
2899 0xC0C00000, 0xC0A00000, 0xC0800000, 0xC0400000, 0xC0000000, 0xBF800000,
2900 0x00000000, 0x3F800000, 0x40000000, 0x40400000, 0x40800000, 0x40A00000,
2901 0x40C00000, 0x40E00000, 0x41000000, 0x41100000, 0x41200000, 0x41300000,
2902 0x41400000, 0x41500000, 0x41600000, 0x41700000, 0x41800000, 0x41880000,
2903 0x41900000, 0x41980000, 0x41A00000, 0x41A80000, 0x41B00000, 0x41B80000,
2907 static int tuning_ctl_set(struct hda_codec *codec, hda_nid_t nid,
2908 unsigned int *lookup, int idx)
2912 for (i = 0; i < TUNING_CTLS_COUNT; i++)
2913 if (nid == ca0132_tuning_ctls[i].nid)
2916 snd_hda_power_up(codec);
2917 dspio_set_param(codec, ca0132_tuning_ctls[i].mid,
2918 ca0132_tuning_ctls[i].req,
2919 &(lookup[idx]), sizeof(unsigned int));
2920 snd_hda_power_down(codec);
2925 static int tuning_ctl_get(struct snd_kcontrol *kcontrol,
2926 struct snd_ctl_elem_value *ucontrol)
2928 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2929 struct ca0132_spec *spec = codec->spec;
2930 hda_nid_t nid = get_amp_nid(kcontrol);
2931 long *valp = ucontrol->value.integer.value;
2932 int idx = nid - TUNING_CTL_START_NID;
2934 *valp = spec->cur_ctl_vals[idx];
2938 static int voice_focus_ctl_info(struct snd_kcontrol *kcontrol,
2939 struct snd_ctl_elem_info *uinfo)
2941 int chs = get_amp_channels(kcontrol);
2942 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2943 uinfo->count = chs == 3 ? 2 : 1;
2944 uinfo->value.integer.min = 20;
2945 uinfo->value.integer.max = 180;
2946 uinfo->value.integer.step = 1;
2951 static int voice_focus_ctl_put(struct snd_kcontrol *kcontrol,
2952 struct snd_ctl_elem_value *ucontrol)
2954 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2955 struct ca0132_spec *spec = codec->spec;
2956 hda_nid_t nid = get_amp_nid(kcontrol);
2957 long *valp = ucontrol->value.integer.value;
2960 idx = nid - TUNING_CTL_START_NID;
2962 if (spec->cur_ctl_vals[idx] == *valp)
2965 spec->cur_ctl_vals[idx] = *valp;
2968 tuning_ctl_set(codec, nid, voice_focus_vals_lookup, idx);
2973 static int mic_svm_ctl_info(struct snd_kcontrol *kcontrol,
2974 struct snd_ctl_elem_info *uinfo)
2976 int chs = get_amp_channels(kcontrol);
2977 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2978 uinfo->count = chs == 3 ? 2 : 1;
2979 uinfo->value.integer.min = 0;
2980 uinfo->value.integer.max = 100;
2981 uinfo->value.integer.step = 1;
2986 static int mic_svm_ctl_put(struct snd_kcontrol *kcontrol,
2987 struct snd_ctl_elem_value *ucontrol)
2989 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2990 struct ca0132_spec *spec = codec->spec;
2991 hda_nid_t nid = get_amp_nid(kcontrol);
2992 long *valp = ucontrol->value.integer.value;
2995 idx = nid - TUNING_CTL_START_NID;
2997 if (spec->cur_ctl_vals[idx] == *valp)
3000 spec->cur_ctl_vals[idx] = *valp;
3003 tuning_ctl_set(codec, nid, mic_svm_vals_lookup, idx);
3008 static int equalizer_ctl_info(struct snd_kcontrol *kcontrol,
3009 struct snd_ctl_elem_info *uinfo)
3011 int chs = get_amp_channels(kcontrol);
3012 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3013 uinfo->count = chs == 3 ? 2 : 1;
3014 uinfo->value.integer.min = 0;
3015 uinfo->value.integer.max = 48;
3016 uinfo->value.integer.step = 1;
3021 static int equalizer_ctl_put(struct snd_kcontrol *kcontrol,
3022 struct snd_ctl_elem_value *ucontrol)
3024 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3025 struct ca0132_spec *spec = codec->spec;
3026 hda_nid_t nid = get_amp_nid(kcontrol);
3027 long *valp = ucontrol->value.integer.value;
3030 idx = nid - TUNING_CTL_START_NID;
3032 if (spec->cur_ctl_vals[idx] == *valp)
3035 spec->cur_ctl_vals[idx] = *valp;
3038 tuning_ctl_set(codec, nid, equalizer_vals_lookup, idx);
3043 static const DECLARE_TLV_DB_SCALE(voice_focus_db_scale, 2000, 100, 0);
3044 static const DECLARE_TLV_DB_SCALE(eq_db_scale, -2400, 100, 0);
3046 static int add_tuning_control(struct hda_codec *codec,
3047 hda_nid_t pnid, hda_nid_t nid,
3048 const char *name, int dir)
3051 int type = dir ? HDA_INPUT : HDA_OUTPUT;
3052 struct snd_kcontrol_new knew =
3053 HDA_CODEC_VOLUME_MONO(namestr, nid, 1, 0, type);
3055 knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
3056 SNDRV_CTL_ELEM_ACCESS_TLV_READ;
3061 knew.info = voice_focus_ctl_info;
3062 knew.get = tuning_ctl_get;
3063 knew.put = voice_focus_ctl_put;
3064 knew.tlv.p = voice_focus_db_scale;
3067 knew.info = mic_svm_ctl_info;
3068 knew.get = tuning_ctl_get;
3069 knew.put = mic_svm_ctl_put;
3072 knew.info = equalizer_ctl_info;
3073 knew.get = tuning_ctl_get;
3074 knew.put = equalizer_ctl_put;
3075 knew.tlv.p = eq_db_scale;
3080 knew.private_value =
3081 HDA_COMPOSE_AMP_VAL(nid, 1, 0, type);
3082 sprintf(namestr, "%s %s Volume", name, dirstr[dir]);
3083 return snd_hda_ctl_add(codec, nid, snd_ctl_new1(&knew, codec));
3086 static int add_tuning_ctls(struct hda_codec *codec)
3091 for (i = 0; i < TUNING_CTLS_COUNT; i++) {
3092 err = add_tuning_control(codec,
3093 ca0132_tuning_ctls[i].parent_nid,
3094 ca0132_tuning_ctls[i].nid,
3095 ca0132_tuning_ctls[i].name,
3096 ca0132_tuning_ctls[i].direct);
3104 static void ca0132_init_tuning_defaults(struct hda_codec *codec)
3106 struct ca0132_spec *spec = codec->spec;
3109 /* Wedge Angle defaults to 30. 10 below is 30 - 20. 20 is min. */
3110 spec->cur_ctl_vals[WEDGE_ANGLE - TUNING_CTL_START_NID] = 10;
3111 /* SVM level defaults to 0.74. */
3112 spec->cur_ctl_vals[SVM_LEVEL - TUNING_CTL_START_NID] = 74;
3114 /* EQ defaults to 0dB. */
3115 for (i = 2; i < TUNING_CTLS_COUNT; i++)
3116 spec->cur_ctl_vals[i] = 24;
3118 #endif /*ENABLE_TUNING_CONTROLS*/
3121 * Select the active output.
3122 * If autodetect is enabled, output will be selected based on jack detection.
3123 * If jack inserted, headphone will be selected, else built-in speakers
3124 * If autodetect is disabled, output will be selected based on selection.
3126 static int ca0132_select_out(struct hda_codec *codec)
3128 struct ca0132_spec *spec = codec->spec;
3129 unsigned int pin_ctl;
3135 snd_printdd(KERN_INFO "ca0132_select_out\n");
3137 snd_hda_power_up(codec);
3139 auto_jack = spec->vnode_lswitch[VNID_HP_ASEL - VNODE_START_NID];
3142 jack_present = snd_hda_jack_detect(codec, spec->out_pins[1]);
3145 spec->vnode_lswitch[VNID_HP_SEL - VNODE_START_NID];
3148 spec->cur_out_type = HEADPHONE_OUT;
3150 spec->cur_out_type = SPEAKER_OUT;
3152 if (spec->cur_out_type == SPEAKER_OUT) {
3153 snd_printdd(KERN_INFO "ca0132_select_out speaker\n");
3154 /*speaker out config*/
3156 err = dspio_set_uint_param(codec, 0x80, 0x04, tmp);
3159 /*enable speaker EQ*/
3161 err = dspio_set_uint_param(codec, 0x8f, 0x00, tmp);
3166 snd_hda_codec_write(codec, spec->out_pins[1], 0,
3167 VENDOR_CHIPIO_EAPD_SEL_SET, 0x02);
3168 snd_hda_codec_write(codec, spec->out_pins[0], 0,
3169 AC_VERB_SET_EAPD_BTLENABLE, 0x00);
3170 snd_hda_codec_write(codec, spec->out_pins[0], 0,
3171 VENDOR_CHIPIO_EAPD_SEL_SET, 0x00);
3172 snd_hda_codec_write(codec, spec->out_pins[0], 0,
3173 AC_VERB_SET_EAPD_BTLENABLE, 0x02);
3175 /* disable headphone node */
3176 pin_ctl = snd_hda_codec_read(codec, spec->out_pins[1], 0,
3177 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3178 snd_hda_set_pin_ctl(codec, spec->out_pins[1],
3180 /* enable speaker node */
3181 pin_ctl = snd_hda_codec_read(codec, spec->out_pins[0], 0,
3182 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3183 snd_hda_set_pin_ctl(codec, spec->out_pins[0],
3186 snd_printdd(KERN_INFO "ca0132_select_out hp\n");
3187 /*headphone out config*/
3189 err = dspio_set_uint_param(codec, 0x80, 0x04, tmp);
3192 /*disable speaker EQ*/
3194 err = dspio_set_uint_param(codec, 0x8f, 0x00, tmp);
3199 snd_hda_codec_write(codec, spec->out_pins[0], 0,
3200 VENDOR_CHIPIO_EAPD_SEL_SET, 0x00);
3201 snd_hda_codec_write(codec, spec->out_pins[0], 0,
3202 AC_VERB_SET_EAPD_BTLENABLE, 0x00);
3203 snd_hda_codec_write(codec, spec->out_pins[1], 0,
3204 VENDOR_CHIPIO_EAPD_SEL_SET, 0x02);
3205 snd_hda_codec_write(codec, spec->out_pins[0], 0,
3206 AC_VERB_SET_EAPD_BTLENABLE, 0x02);
3208 /* disable speaker*/
3209 pin_ctl = snd_hda_codec_read(codec, spec->out_pins[0], 0,
3210 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3211 snd_hda_set_pin_ctl(codec, spec->out_pins[0],
3213 /* enable headphone*/
3214 pin_ctl = snd_hda_codec_read(codec, spec->out_pins[1], 0,
3215 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3216 snd_hda_set_pin_ctl(codec, spec->out_pins[1],
3221 snd_hda_power_down(codec);
3223 return err < 0 ? err : 0;
3226 static void ca0132_set_dmic(struct hda_codec *codec, int enable);
3227 static int ca0132_mic_boost_set(struct hda_codec *codec, long val);
3228 static int ca0132_effects_set(struct hda_codec *codec, hda_nid_t nid, long val);
3231 * Select the active VIP source
3233 static int ca0132_set_vipsource(struct hda_codec *codec, int val)
3235 struct ca0132_spec *spec = codec->spec;
3238 if (!dspload_is_loaded(codec))
3241 /* if CrystalVoice if off, vipsource should be 0 */
3242 if (!spec->effects_switch[CRYSTAL_VOICE - EFFECT_START_NID] ||
3244 chipio_set_control_param(codec, CONTROL_PARAM_VIP_SOURCE, 0);
3245 chipio_set_conn_rate(codec, MEM_CONNID_MICIN1, SR_96_000);
3246 chipio_set_conn_rate(codec, MEM_CONNID_MICOUT1, SR_96_000);
3247 if (spec->cur_mic_type == DIGITAL_MIC)
3251 dspio_set_uint_param(codec, 0x80, 0x00, tmp);
3253 dspio_set_uint_param(codec, 0x80, 0x05, tmp);
3255 chipio_set_conn_rate(codec, MEM_CONNID_MICIN1, SR_16_000);
3256 chipio_set_conn_rate(codec, MEM_CONNID_MICOUT1, SR_16_000);
3257 if (spec->cur_mic_type == DIGITAL_MIC)
3261 dspio_set_uint_param(codec, 0x80, 0x00, tmp);
3263 dspio_set_uint_param(codec, 0x80, 0x05, tmp);
3265 chipio_set_control_param(codec, CONTROL_PARAM_VIP_SOURCE, val);
3272 * Select the active microphone.
3273 * If autodetect is enabled, mic will be selected based on jack detection.
3274 * If jack inserted, ext.mic will be selected, else built-in mic
3275 * If autodetect is disabled, mic will be selected based on selection.
3277 static int ca0132_select_mic(struct hda_codec *codec)
3279 struct ca0132_spec *spec = codec->spec;
3283 snd_printdd(KERN_INFO "ca0132_select_mic\n");
3285 snd_hda_power_up(codec);
3287 auto_jack = spec->vnode_lswitch[VNID_AMIC1_ASEL - VNODE_START_NID];
3290 jack_present = snd_hda_jack_detect(codec, spec->input_pins[0]);
3293 spec->vnode_lswitch[VNID_AMIC1_SEL - VNODE_START_NID];
3296 spec->cur_mic_type = LINE_MIC_IN;
3298 spec->cur_mic_type = DIGITAL_MIC;
3300 if (spec->cur_mic_type == DIGITAL_MIC) {
3301 /* enable digital Mic */
3302 chipio_set_conn_rate(codec, MEM_CONNID_DMIC, SR_32_000);
3303 ca0132_set_dmic(codec, 1);
3304 ca0132_mic_boost_set(codec, 0);
3305 /* set voice focus */
3306 ca0132_effects_set(codec, VOICE_FOCUS,
3307 spec->effects_switch
3308 [VOICE_FOCUS - EFFECT_START_NID]);
3310 /* disable digital Mic */
3311 chipio_set_conn_rate(codec, MEM_CONNID_DMIC, SR_96_000);
3312 ca0132_set_dmic(codec, 0);
3313 ca0132_mic_boost_set(codec, spec->cur_mic_boost);
3314 /* disable voice focus */
3315 ca0132_effects_set(codec, VOICE_FOCUS, 0);
3318 snd_hda_power_down(codec);
3324 * Check if VNODE settings take effect immediately.
3326 static bool ca0132_is_vnode_effective(struct hda_codec *codec,
3328 hda_nid_t *shared_nid)
3330 struct ca0132_spec *spec = codec->spec;
3335 nid = spec->shared_out_nid;
3338 nid = spec->shared_mic_nid;
3351 * The following functions are control change helpers.
3352 * They return 0 if no changed. Return 1 if changed.
3354 static int ca0132_voicefx_set(struct hda_codec *codec, int enable)
3356 struct ca0132_spec *spec = codec->spec;
3359 /* based on CrystalVoice state to enable VoiceFX. */
3361 tmp = spec->effects_switch[CRYSTAL_VOICE - EFFECT_START_NID] ?
3362 FLOAT_ONE : FLOAT_ZERO;
3367 dspio_set_uint_param(codec, ca0132_voicefx.mid,
3368 ca0132_voicefx.reqs[0], tmp);
3374 * Set the effects parameters
3376 static int ca0132_effects_set(struct hda_codec *codec, hda_nid_t nid, long val)
3378 struct ca0132_spec *spec = codec->spec;
3380 int num_fx = OUT_EFFECTS_COUNT + IN_EFFECTS_COUNT;
3382 int idx = nid - EFFECT_START_NID;
3384 if ((idx < 0) || (idx >= num_fx))
3385 return 0; /* no changed */
3387 /* for out effect, qualify with PE */
3388 if ((nid >= OUT_EFFECT_START_NID) && (nid < OUT_EFFECT_END_NID)) {
3389 /* if PE if off, turn off out effects. */
3390 if (!spec->effects_switch[PLAY_ENHANCEMENT - EFFECT_START_NID])
3394 /* for in effect, qualify with CrystalVoice */
3395 if ((nid >= IN_EFFECT_START_NID) && (nid < IN_EFFECT_END_NID)) {
3396 /* if CrystalVoice if off, turn off in effects. */
3397 if (!spec->effects_switch[CRYSTAL_VOICE - EFFECT_START_NID])
3400 /* Voice Focus applies to 2-ch Mic, Digital Mic */
3401 if ((nid == VOICE_FOCUS) && (spec->cur_mic_type != DIGITAL_MIC))
3405 snd_printdd(KERN_INFO "ca0132_effect_set: nid=0x%x, val=%ld\n",
3408 on = (val == 0) ? FLOAT_ZERO : FLOAT_ONE;
3409 err = dspio_set_uint_param(codec, ca0132_effects[idx].mid,
3410 ca0132_effects[idx].reqs[0], on);
3413 return 0; /* no changed */
3419 * Turn on/off Playback Enhancements
3421 static int ca0132_pe_switch_set(struct hda_codec *codec)
3423 struct ca0132_spec *spec = codec->spec;
3427 snd_printdd(KERN_INFO "ca0132_pe_switch_set: val=%ld\n",
3428 spec->effects_switch[PLAY_ENHANCEMENT - EFFECT_START_NID]);
3430 i = OUT_EFFECT_START_NID - EFFECT_START_NID;
3431 nid = OUT_EFFECT_START_NID;
3432 /* PE affects all out effects */
3433 for (; nid < OUT_EFFECT_END_NID; nid++, i++)
3434 ret |= ca0132_effects_set(codec, nid, spec->effects_switch[i]);
3439 /* Check if Mic1 is streaming, if so, stop streaming */
3440 static int stop_mic1(struct hda_codec *codec)
3442 struct ca0132_spec *spec = codec->spec;
3443 unsigned int oldval = snd_hda_codec_read(codec, spec->adcs[0], 0,
3444 AC_VERB_GET_CONV, 0);
3446 snd_hda_codec_write(codec, spec->adcs[0], 0,
3447 AC_VERB_SET_CHANNEL_STREAMID,
3452 /* Resume Mic1 streaming if it was stopped. */
3453 static void resume_mic1(struct hda_codec *codec, unsigned int oldval)
3455 struct ca0132_spec *spec = codec->spec;
3456 /* Restore the previous stream and channel */
3458 snd_hda_codec_write(codec, spec->adcs[0], 0,
3459 AC_VERB_SET_CHANNEL_STREAMID,
3464 * Turn on/off CrystalVoice
3466 static int ca0132_cvoice_switch_set(struct hda_codec *codec)
3468 struct ca0132_spec *spec = codec->spec;
3471 unsigned int oldval;
3473 snd_printdd(KERN_INFO "ca0132_cvoice_switch_set: val=%ld\n",
3474 spec->effects_switch[CRYSTAL_VOICE - EFFECT_START_NID]);
3476 i = IN_EFFECT_START_NID - EFFECT_START_NID;
3477 nid = IN_EFFECT_START_NID;
3478 /* CrystalVoice affects all in effects */
3479 for (; nid < IN_EFFECT_END_NID; nid++, i++)
3480 ret |= ca0132_effects_set(codec, nid, spec->effects_switch[i]);
3482 /* including VoiceFX */
3483 ret |= ca0132_voicefx_set(codec, (spec->voicefx_val ? 1 : 0));
3485 /* set correct vipsource */
3486 oldval = stop_mic1(codec);
3487 ret |= ca0132_set_vipsource(codec, 1);
3488 resume_mic1(codec, oldval);
3492 static int ca0132_mic_boost_set(struct hda_codec *codec, long val)
3494 struct ca0132_spec *spec = codec->spec;
3498 ret = snd_hda_codec_amp_update(codec, spec->input_pins[0], 0,
3499 HDA_INPUT, 0, HDA_AMP_VOLMASK, 3);
3501 ret = snd_hda_codec_amp_update(codec, spec->input_pins[0], 0,
3502 HDA_INPUT, 0, HDA_AMP_VOLMASK, 0);
3507 static int ca0132_vnode_switch_set(struct snd_kcontrol *kcontrol,
3508 struct snd_ctl_elem_value *ucontrol)
3510 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3511 hda_nid_t nid = get_amp_nid(kcontrol);
3512 hda_nid_t shared_nid = 0;
3515 struct ca0132_spec *spec = codec->spec;
3518 if (nid == VNID_HP_SEL) {
3520 spec->vnode_lswitch[VNID_HP_ASEL - VNODE_START_NID];
3522 ca0132_select_out(codec);
3526 if (nid == VNID_AMIC1_SEL) {
3528 spec->vnode_lswitch[VNID_AMIC1_ASEL - VNODE_START_NID];
3530 ca0132_select_mic(codec);
3534 if (nid == VNID_HP_ASEL) {
3535 ca0132_select_out(codec);
3539 if (nid == VNID_AMIC1_ASEL) {
3540 ca0132_select_mic(codec);
3544 /* if effective conditions, then update hw immediately. */
3545 effective = ca0132_is_vnode_effective(codec, nid, &shared_nid);
3547 int dir = get_amp_direction(kcontrol);
3548 int ch = get_amp_channels(kcontrol);
3551 mutex_lock(&codec->control_mutex);
3552 pval = kcontrol->private_value;
3553 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(shared_nid, ch,
3555 ret = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3556 kcontrol->private_value = pval;
3557 mutex_unlock(&codec->control_mutex);
3562 /* End of control change helpers. */
3564 static int ca0132_voicefx_info(struct snd_kcontrol *kcontrol,
3565 struct snd_ctl_elem_info *uinfo)
3567 unsigned int items = sizeof(ca0132_voicefx_presets)
3568 / sizeof(struct ct_voicefx_preset);
3570 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3572 uinfo->value.enumerated.items = items;
3573 if (uinfo->value.enumerated.item >= items)
3574 uinfo->value.enumerated.item = items - 1;
3575 strcpy(uinfo->value.enumerated.name,
3576 ca0132_voicefx_presets[uinfo->value.enumerated.item].name);
3580 static int ca0132_voicefx_get(struct snd_kcontrol *kcontrol,
3581 struct snd_ctl_elem_value *ucontrol)
3583 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3584 struct ca0132_spec *spec = codec->spec;
3586 ucontrol->value.enumerated.item[0] = spec->voicefx_val;
3590 static int ca0132_voicefx_put(struct snd_kcontrol *kcontrol,
3591 struct snd_ctl_elem_value *ucontrol)
3593 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3594 struct ca0132_spec *spec = codec->spec;
3596 int sel = ucontrol->value.enumerated.item[0];
3597 unsigned int items = sizeof(ca0132_voicefx_presets)
3598 / sizeof(struct ct_voicefx_preset);
3603 snd_printdd(KERN_INFO "ca0132_voicefx_put: sel=%d, preset=%s\n",
3604 sel, ca0132_voicefx_presets[sel].name);
3608 * Default needs to qualify with CrystalVoice state.
3610 for (i = 0; i < VOICEFX_MAX_PARAM_COUNT; i++) {
3611 err = dspio_set_uint_param(codec, ca0132_voicefx.mid,
3612 ca0132_voicefx.reqs[i],
3613 ca0132_voicefx_presets[sel].vals[i]);
3619 spec->voicefx_val = sel;
3620 /* enable voice fx */
3621 ca0132_voicefx_set(codec, (sel ? 1 : 0));
3627 static int ca0132_switch_get(struct snd_kcontrol *kcontrol,
3628 struct snd_ctl_elem_value *ucontrol)
3630 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3631 struct ca0132_spec *spec = codec->spec;
3632 hda_nid_t nid = get_amp_nid(kcontrol);
3633 int ch = get_amp_channels(kcontrol);
3634 long *valp = ucontrol->value.integer.value;
3637 if ((nid >= VNODE_START_NID) && (nid < VNODE_END_NID)) {
3639 *valp = spec->vnode_lswitch[nid - VNODE_START_NID];
3643 *valp = spec->vnode_rswitch[nid - VNODE_START_NID];
3649 /* effects, include PE and CrystalVoice */
3650 if ((nid >= EFFECT_START_NID) && (nid < EFFECT_END_NID)) {
3651 *valp = spec->effects_switch[nid - EFFECT_START_NID];
3656 if (nid == spec->input_pins[0]) {
3657 *valp = spec->cur_mic_boost;
3664 static int ca0132_switch_put(struct snd_kcontrol *kcontrol,
3665 struct snd_ctl_elem_value *ucontrol)
3667 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3668 struct ca0132_spec *spec = codec->spec;
3669 hda_nid_t nid = get_amp_nid(kcontrol);
3670 int ch = get_amp_channels(kcontrol);
3671 long *valp = ucontrol->value.integer.value;
3674 snd_printdd(KERN_INFO "ca0132_switch_put: nid=0x%x, val=%ld\n",
3677 snd_hda_power_up(codec);
3679 if ((nid >= VNODE_START_NID) && (nid < VNODE_END_NID)) {
3681 spec->vnode_lswitch[nid - VNODE_START_NID] = *valp;
3685 spec->vnode_rswitch[nid - VNODE_START_NID] = *valp;
3688 changed = ca0132_vnode_switch_set(kcontrol, ucontrol);
3693 if (nid == PLAY_ENHANCEMENT) {
3694 spec->effects_switch[nid - EFFECT_START_NID] = *valp;
3695 changed = ca0132_pe_switch_set(codec);
3700 if (nid == CRYSTAL_VOICE) {
3701 spec->effects_switch[nid - EFFECT_START_NID] = *valp;
3702 changed = ca0132_cvoice_switch_set(codec);
3706 /* out and in effects */
3707 if (((nid >= OUT_EFFECT_START_NID) && (nid < OUT_EFFECT_END_NID)) ||
3708 ((nid >= IN_EFFECT_START_NID) && (nid < IN_EFFECT_END_NID))) {
3709 spec->effects_switch[nid - EFFECT_START_NID] = *valp;
3710 changed = ca0132_effects_set(codec, nid, *valp);
3715 if (nid == spec->input_pins[0]) {
3716 spec->cur_mic_boost = *valp;
3718 /* Mic boost does not apply to Digital Mic */
3719 if (spec->cur_mic_type != DIGITAL_MIC)
3720 changed = ca0132_mic_boost_set(codec, *valp);
3725 snd_hda_power_down(codec);
3732 static int ca0132_volume_info(struct snd_kcontrol *kcontrol,
3733 struct snd_ctl_elem_info *uinfo)
3735 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3736 struct ca0132_spec *spec = codec->spec;
3737 hda_nid_t nid = get_amp_nid(kcontrol);
3738 int ch = get_amp_channels(kcontrol);
3739 int dir = get_amp_direction(kcontrol);
3745 /* follow shared_out info */
3746 nid = spec->shared_out_nid;
3747 mutex_lock(&codec->control_mutex);
3748 pval = kcontrol->private_value;
3749 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(nid, ch, 0, dir);
3750 err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
3751 kcontrol->private_value = pval;
3752 mutex_unlock(&codec->control_mutex);
3755 /* follow shared_mic info */
3756 nid = spec->shared_mic_nid;
3757 mutex_lock(&codec->control_mutex);
3758 pval = kcontrol->private_value;
3759 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(nid, ch, 0, dir);
3760 err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
3761 kcontrol->private_value = pval;
3762 mutex_unlock(&codec->control_mutex);
3765 err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
3770 static int ca0132_volume_get(struct snd_kcontrol *kcontrol,
3771 struct snd_ctl_elem_value *ucontrol)
3773 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3774 struct ca0132_spec *spec = codec->spec;
3775 hda_nid_t nid = get_amp_nid(kcontrol);
3776 int ch = get_amp_channels(kcontrol);
3777 long *valp = ucontrol->value.integer.value;
3779 /* store the left and right volume */
3781 *valp = spec->vnode_lvol[nid - VNODE_START_NID];
3785 *valp = spec->vnode_rvol[nid - VNODE_START_NID];
3791 static int ca0132_volume_put(struct snd_kcontrol *kcontrol,
3792 struct snd_ctl_elem_value *ucontrol)
3794 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3795 struct ca0132_spec *spec = codec->spec;
3796 hda_nid_t nid = get_amp_nid(kcontrol);
3797 int ch = get_amp_channels(kcontrol);
3798 long *valp = ucontrol->value.integer.value;
3799 hda_nid_t shared_nid = 0;
3803 /* store the left and right volume */
3805 spec->vnode_lvol[nid - VNODE_START_NID] = *valp;
3809 spec->vnode_rvol[nid - VNODE_START_NID] = *valp;
3813 /* if effective conditions, then update hw immediately. */
3814 effective = ca0132_is_vnode_effective(codec, nid, &shared_nid);
3816 int dir = get_amp_direction(kcontrol);
3819 snd_hda_power_up(codec);
3820 mutex_lock(&codec->control_mutex);
3821 pval = kcontrol->private_value;
3822 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(shared_nid, ch,
3824 changed = snd_hda_mixer_amp_volume_put(kcontrol, ucontrol);
3825 kcontrol->private_value = pval;
3826 mutex_unlock(&codec->control_mutex);
3827 snd_hda_power_down(codec);
3833 static int ca0132_volume_tlv(struct snd_kcontrol *kcontrol, int op_flag,
3834 unsigned int size, unsigned int __user *tlv)
3836 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3837 struct ca0132_spec *spec = codec->spec;
3838 hda_nid_t nid = get_amp_nid(kcontrol);
3839 int ch = get_amp_channels(kcontrol);
3840 int dir = get_amp_direction(kcontrol);
3846 /* follow shared_out tlv */
3847 nid = spec->shared_out_nid;
3848 mutex_lock(&codec->control_mutex);
3849 pval = kcontrol->private_value;
3850 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(nid, ch, 0, dir);
3851 err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
3852 kcontrol->private_value = pval;
3853 mutex_unlock(&codec->control_mutex);
3856 /* follow shared_mic tlv */
3857 nid = spec->shared_mic_nid;
3858 mutex_lock(&codec->control_mutex);
3859 pval = kcontrol->private_value;
3860 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(nid, ch, 0, dir);
3861 err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
3862 kcontrol->private_value = pval;
3863 mutex_unlock(&codec->control_mutex);
3866 err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
3871 static int add_fx_switch(struct hda_codec *codec, hda_nid_t nid,
3872 const char *pfx, int dir)
3875 int type = dir ? HDA_INPUT : HDA_OUTPUT;
3876 struct snd_kcontrol_new knew =
3877 CA0132_CODEC_MUTE_MONO(namestr, nid, 1, type);
3878 sprintf(namestr, "%s %s Switch", pfx, dirstr[dir]);
3879 return snd_hda_ctl_add(codec, nid, snd_ctl_new1(&knew, codec));
3882 static int add_voicefx(struct hda_codec *codec)
3884 struct snd_kcontrol_new knew =
3885 HDA_CODEC_MUTE_MONO(ca0132_voicefx.name,
3886 VOICEFX, 1, 0, HDA_INPUT);
3887 knew.info = ca0132_voicefx_info;
3888 knew.get = ca0132_voicefx_get;
3889 knew.put = ca0132_voicefx_put;
3890 return snd_hda_ctl_add(codec, VOICEFX, snd_ctl_new1(&knew, codec));
3894 * When changing Node IDs for Mixer Controls below, make sure to update
3895 * Node IDs in ca0132_config() as well.
3897 static struct snd_kcontrol_new ca0132_mixer[] = {
3898 CA0132_CODEC_VOL("Master Playback Volume", VNID_SPK, HDA_OUTPUT),
3899 CA0132_CODEC_MUTE("Master Playback Switch", VNID_SPK, HDA_OUTPUT),
3900 CA0132_CODEC_VOL("Capture Volume", VNID_MIC, HDA_INPUT),
3901 CA0132_CODEC_MUTE("Capture Switch", VNID_MIC, HDA_INPUT),
3902 HDA_CODEC_VOLUME("Analog-Mic2 Capture Volume", 0x08, 0, HDA_INPUT),
3903 HDA_CODEC_MUTE("Analog-Mic2 Capture Switch", 0x08, 0, HDA_INPUT),
3904 HDA_CODEC_VOLUME("What U Hear Capture Volume", 0x0a, 0, HDA_INPUT),
3905 HDA_CODEC_MUTE("What U Hear Capture Switch", 0x0a, 0, HDA_INPUT),
3906 CA0132_CODEC_MUTE_MONO("Mic1-Boost (30dB) Capture Switch",
3907 0x12, 1, HDA_INPUT),
3908 CA0132_CODEC_MUTE_MONO("HP/Speaker Playback Switch",
3909 VNID_HP_SEL, 1, HDA_OUTPUT),
3910 CA0132_CODEC_MUTE_MONO("AMic1/DMic Capture Switch",
3911 VNID_AMIC1_SEL, 1, HDA_INPUT),
3912 CA0132_CODEC_MUTE_MONO("HP/Speaker Auto Detect Playback Switch",
3913 VNID_HP_ASEL, 1, HDA_OUTPUT),
3914 CA0132_CODEC_MUTE_MONO("AMic1/DMic Auto Detect Capture Switch",
3915 VNID_AMIC1_ASEL, 1, HDA_INPUT),
3919 static int ca0132_build_controls(struct hda_codec *codec)
3921 struct ca0132_spec *spec = codec->spec;
3925 /* Add Mixer controls */
3926 for (i = 0; i < spec->num_mixers; i++) {
3927 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
3932 /* Add in and out effects controls.
3933 * VoiceFX, PE and CrystalVoice are added separately.
3935 num_fx = OUT_EFFECTS_COUNT + IN_EFFECTS_COUNT;
3936 for (i = 0; i < num_fx; i++) {
3937 err = add_fx_switch(codec, ca0132_effects[i].nid,
3938 ca0132_effects[i].name,
3939 ca0132_effects[i].direct);
3944 err = add_fx_switch(codec, PLAY_ENHANCEMENT, "PlayEnhancement", 0);
3948 err = add_fx_switch(codec, CRYSTAL_VOICE, "CrystalVoice", 1);
3954 #ifdef ENABLE_TUNING_CONTROLS
3955 add_tuning_ctls(codec);
3958 err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
3962 if (spec->dig_out) {
3963 err = snd_hda_create_spdif_out_ctls(codec, spec->dig_out,
3967 err = snd_hda_create_spdif_share_sw(codec, &spec->multiout);
3970 /* spec->multiout.share_spdif = 1; */
3974 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in);
3984 static struct hda_pcm_stream ca0132_pcm_analog_playback = {
3989 .prepare = ca0132_playback_pcm_prepare,
3990 .cleanup = ca0132_playback_pcm_cleanup
3994 static struct hda_pcm_stream ca0132_pcm_analog_capture = {
3999 .prepare = ca0132_capture_pcm_prepare,
4000 .cleanup = ca0132_capture_pcm_cleanup
4004 static struct hda_pcm_stream ca0132_pcm_digital_playback = {
4009 .open = ca0132_dig_playback_pcm_open,
4010 .close = ca0132_dig_playback_pcm_close,
4011 .prepare = ca0132_dig_playback_pcm_prepare,
4012 .cleanup = ca0132_dig_playback_pcm_cleanup
4016 static struct hda_pcm_stream ca0132_pcm_digital_capture = {
4022 static int ca0132_build_pcms(struct hda_codec *codec)
4024 struct ca0132_spec *spec = codec->spec;
4025 struct hda_pcm *info = spec->pcm_rec;
4027 codec->pcm_info = info;
4028 codec->num_pcms = 0;
4030 info->name = "CA0132 Analog";
4031 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ca0132_pcm_analog_playback;
4032 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->dacs[0];
4033 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
4034 spec->multiout.max_channels;
4035 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ca0132_pcm_analog_capture;
4036 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 1;
4037 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adcs[0];
4041 info->name = "CA0132 Analog Mic-In2";
4042 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ca0132_pcm_analog_capture;
4043 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 1;
4044 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adcs[1];
4048 info->name = "CA0132 What U Hear";
4049 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ca0132_pcm_analog_capture;
4050 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 1;
4051 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adcs[2];
4054 if (!spec->dig_out && !spec->dig_in)
4058 info->name = "CA0132 Digital";
4059 info->pcm_type = HDA_PCM_TYPE_SPDIF;
4060 if (spec->dig_out) {
4061 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4062 ca0132_pcm_digital_playback;
4063 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->dig_out;
4066 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4067 ca0132_pcm_digital_capture;
4068 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in;
4075 static void init_output(struct hda_codec *codec, hda_nid_t pin, hda_nid_t dac)
4078 snd_hda_set_pin_ctl(codec, pin, PIN_HP);
4079 if (get_wcaps(codec, pin) & AC_WCAP_OUT_AMP)
4080 snd_hda_codec_write(codec, pin, 0,
4081 AC_VERB_SET_AMP_GAIN_MUTE,
4084 if (dac && (get_wcaps(codec, dac) & AC_WCAP_OUT_AMP))
4085 snd_hda_codec_write(codec, dac, 0,
4086 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO);
4089 static void init_input(struct hda_codec *codec, hda_nid_t pin, hda_nid_t adc)
4092 snd_hda_set_pin_ctl(codec, pin, PIN_VREF80);
4093 if (get_wcaps(codec, pin) & AC_WCAP_IN_AMP)
4094 snd_hda_codec_write(codec, pin, 0,
4095 AC_VERB_SET_AMP_GAIN_MUTE,
4098 if (adc && (get_wcaps(codec, adc) & AC_WCAP_IN_AMP)) {
4099 snd_hda_codec_write(codec, adc, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4102 /* init to 0 dB and unmute. */
4103 snd_hda_codec_amp_stereo(codec, adc, HDA_INPUT, 0,
4104 HDA_AMP_VOLMASK, 0x5a);
4105 snd_hda_codec_amp_stereo(codec, adc, HDA_INPUT, 0,
4110 static void ca0132_init_unsol(struct hda_codec *codec)
4112 snd_hda_jack_detect_enable(codec, UNSOL_TAG_HP, UNSOL_TAG_HP);
4113 snd_hda_jack_detect_enable(codec, UNSOL_TAG_AMIC1, UNSOL_TAG_AMIC1);
4116 static void refresh_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir)
4120 caps = snd_hda_param_read(codec, nid, dir == HDA_OUTPUT ?
4121 AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
4122 snd_hda_override_amp_caps(codec, nid, dir, caps);
4126 * Switch between Digital built-in mic and analog mic.
4128 static void ca0132_set_dmic(struct hda_codec *codec, int enable)
4130 struct ca0132_spec *spec = codec->spec;
4133 unsigned int oldval;
4135 snd_printdd(KERN_INFO "ca0132_set_dmic: enable=%d\n", enable);
4137 oldval = stop_mic1(codec);
4138 ca0132_set_vipsource(codec, 0);
4140 /* set DMic input as 2-ch */
4142 dspio_set_uint_param(codec, 0x80, 0x00, tmp);
4144 val = spec->dmic_ctl;
4146 snd_hda_codec_write(codec, spec->input_pins[0], 0,
4147 VENDOR_CHIPIO_DMIC_CTL_SET, val);
4149 if (!(spec->dmic_ctl & 0x20))
4150 chipio_set_control_flag(codec, CONTROL_FLAG_DMIC, 1);
4152 /* set AMic input as mono */
4154 dspio_set_uint_param(codec, 0x80, 0x00, tmp);
4156 val = spec->dmic_ctl;
4157 /* clear bit7 and bit5 to disable dmic */
4159 snd_hda_codec_write(codec, spec->input_pins[0], 0,
4160 VENDOR_CHIPIO_DMIC_CTL_SET, val);
4162 if (!(spec->dmic_ctl & 0x20))
4163 chipio_set_control_flag(codec, CONTROL_FLAG_DMIC, 0);
4165 ca0132_set_vipsource(codec, 1);
4166 resume_mic1(codec, oldval);
4170 * Initialization for Digital Mic.
4172 static void ca0132_init_dmic(struct hda_codec *codec)
4174 struct ca0132_spec *spec = codec->spec;
4177 /* Setup Digital Mic here, but don't enable.
4178 * Enable based on jack detect.
4181 /* MCLK uses MPIO1, set to enable.
4182 * Bit 2-0: MPIO select
4183 * Bit 3: set to disable
4187 snd_hda_codec_write(codec, spec->input_pins[0], 0,
4188 VENDOR_CHIPIO_DMIC_MCLK_SET, val);
4190 /* Data1 uses MPIO3. Data2 not use
4191 * Bit 2-0: Data1 MPIO select
4192 * Bit 3: set disable Data1
4193 * Bit 6-4: Data2 MPIO select
4194 * Bit 7: set disable Data2
4197 snd_hda_codec_write(codec, spec->input_pins[0], 0,
4198 VENDOR_CHIPIO_DMIC_PIN_SET, val);
4200 /* Use Ch-0 and Ch-1. Rate is 48K, mode 1. Disable DMic first.
4201 * Bit 3-0: Channel mask
4202 * Bit 4: set for 48KHz, clear for 32KHz
4204 * Bit 6: set to select Data2, clear for Data1
4205 * Bit 7: set to enable DMic, clear for AMic
4208 /* keep a copy of dmic ctl val for enable/disable dmic purpuse */
4209 spec->dmic_ctl = val;
4210 snd_hda_codec_write(codec, spec->input_pins[0], 0,
4211 VENDOR_CHIPIO_DMIC_CTL_SET, val);
4215 * Initialization for Analog Mic 2
4217 static void ca0132_init_analog_mic2(struct hda_codec *codec)
4219 struct ca0132_spec *spec = codec->spec;
4221 mutex_lock(&spec->chipio_mutex);
4222 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
4223 VENDOR_CHIPIO_8051_ADDRESS_LOW, 0x20);
4224 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
4225 VENDOR_CHIPIO_8051_ADDRESS_HIGH, 0x19);
4226 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
4227 VENDOR_CHIPIO_8051_DATA_WRITE, 0x00);
4228 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
4229 VENDOR_CHIPIO_8051_ADDRESS_LOW, 0x2D);
4230 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
4231 VENDOR_CHIPIO_8051_ADDRESS_HIGH, 0x19);
4232 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
4233 VENDOR_CHIPIO_8051_DATA_WRITE, 0x00);
4234 mutex_unlock(&spec->chipio_mutex);
4237 static void ca0132_refresh_widget_caps(struct hda_codec *codec)
4239 struct ca0132_spec *spec = codec->spec;
4243 snd_printdd(KERN_INFO "ca0132_refresh_widget_caps.\n");
4244 nid = codec->start_nid;
4245 for (i = 0; i < codec->num_nodes; i++, nid++)
4246 codec->wcaps[i] = snd_hda_param_read(codec, nid,
4247 AC_PAR_AUDIO_WIDGET_CAP);
4249 for (i = 0; i < spec->multiout.num_dacs; i++)
4250 refresh_amp_caps(codec, spec->dacs[i], HDA_OUTPUT);
4252 for (i = 0; i < spec->num_outputs; i++)
4253 refresh_amp_caps(codec, spec->out_pins[i], HDA_OUTPUT);
4255 for (i = 0; i < spec->num_inputs; i++) {
4256 refresh_amp_caps(codec, spec->adcs[i], HDA_INPUT);
4257 refresh_amp_caps(codec, spec->input_pins[i], HDA_INPUT);
4262 * Setup default parameters for DSP
4264 static void ca0132_setup_defaults(struct hda_codec *codec)
4270 if (!dspload_is_loaded(codec))
4273 /* out, in effects + voicefx */
4274 num_fx = OUT_EFFECTS_COUNT + IN_EFFECTS_COUNT + 1;
4275 for (idx = 0; idx < num_fx; idx++) {
4276 for (i = 0; i <= ca0132_effects[idx].params; i++) {
4277 dspio_set_uint_param(codec, ca0132_effects[idx].mid,
4278 ca0132_effects[idx].reqs[i],
4279 ca0132_effects[idx].def_vals[i]);
4283 /*remove DSP headroom*/
4285 dspio_set_uint_param(codec, 0x96, 0x3C, tmp);
4287 /*set speaker EQ bypass attenuation*/
4288 dspio_set_uint_param(codec, 0x8f, 0x01, tmp);
4290 /* set AMic1 and AMic2 as mono mic */
4292 dspio_set_uint_param(codec, 0x80, 0x00, tmp);
4293 dspio_set_uint_param(codec, 0x80, 0x01, tmp);
4295 /* set AMic1 as CrystalVoice input */
4297 dspio_set_uint_param(codec, 0x80, 0x05, tmp);
4299 /* set WUH source */
4301 dspio_set_uint_param(codec, 0x31, 0x00, tmp);
4305 * Initialization of flags in chip
4307 static void ca0132_init_flags(struct hda_codec *codec)
4309 chipio_set_control_flag(codec, CONTROL_FLAG_IDLE_ENABLE, 0);
4310 chipio_set_control_flag(codec, CONTROL_FLAG_PORT_A_COMMON_MODE, 0);
4311 chipio_set_control_flag(codec, CONTROL_FLAG_PORT_D_COMMON_MODE, 0);
4312 chipio_set_control_flag(codec, CONTROL_FLAG_PORT_A_10KOHM_LOAD, 0);
4313 chipio_set_control_flag(codec, CONTROL_FLAG_PORT_D_10KOHM_LOAD, 0);
4314 chipio_set_control_flag(codec, CONTROL_FLAG_ADC_C_HIGH_PASS, 1);
4318 * Initialization of parameters in chip
4320 static void ca0132_init_params(struct hda_codec *codec)
4322 chipio_set_control_param(codec, CONTROL_PARAM_PORTA_160OHM_GAIN, 6);
4323 chipio_set_control_param(codec, CONTROL_PARAM_PORTD_160OHM_GAIN, 6);
4326 static void ca0132_set_dsp_msr(struct hda_codec *codec, bool is96k)
4328 chipio_set_control_flag(codec, CONTROL_FLAG_DSP_96KHZ, is96k);
4329 chipio_set_control_flag(codec, CONTROL_FLAG_DAC_96KHZ, is96k);
4330 chipio_set_control_flag(codec, CONTROL_FLAG_SRC_RATE_96KHZ, is96k);
4331 chipio_set_control_flag(codec, CONTROL_FLAG_SRC_CLOCK_196MHZ, is96k);
4332 chipio_set_control_flag(codec, CONTROL_FLAG_ADC_B_96KHZ, is96k);
4333 chipio_set_control_flag(codec, CONTROL_FLAG_ADC_C_96KHZ, is96k);
4335 chipio_set_conn_rate(codec, MEM_CONNID_MICIN1, SR_96_000);
4336 chipio_set_conn_rate(codec, MEM_CONNID_MICOUT1, SR_96_000);
4337 chipio_set_conn_rate(codec, MEM_CONNID_WUH, SR_48_000);
4340 static bool ca0132_download_dsp_images(struct hda_codec *codec)
4342 bool dsp_loaded = false;
4343 const struct dsp_image_seg *dsp_os_image;
4344 const struct firmware *fw_entry;
4346 if (request_firmware(&fw_entry, EFX_FILE, codec->bus->card->dev) != 0)
4349 dsp_os_image = (struct dsp_image_seg *)(fw_entry->data);
4350 dspload_image(codec, dsp_os_image, 0, 0, true, 0);
4351 dsp_loaded = dspload_wait_loaded(codec);
4353 release_firmware(fw_entry);
4359 static void ca0132_download_dsp(struct hda_codec *codec)
4361 struct ca0132_spec *spec = codec->spec;
4363 #ifndef CONFIG_SND_HDA_CODEC_CA0132_DSP
4366 spec->dsp_state = DSP_DOWNLOAD_INIT;
4368 if (spec->dsp_state == DSP_DOWNLOAD_INIT) {
4369 chipio_enable_clocks(codec);
4370 spec->dsp_state = DSP_DOWNLOADING;
4371 if (!ca0132_download_dsp_images(codec))
4372 spec->dsp_state = DSP_DOWNLOAD_FAILED;
4374 spec->dsp_state = DSP_DOWNLOADED;
4377 if (spec->dsp_state == DSP_DOWNLOADED)
4378 ca0132_set_dsp_msr(codec, true);
4381 static void ca0132_process_dsp_response(struct hda_codec *codec)
4383 struct ca0132_spec *spec = codec->spec;
4385 snd_printdd(KERN_INFO "ca0132_process_dsp_response\n");
4386 if (spec->wait_scp) {
4387 if (dspio_get_response_data(codec) >= 0)
4391 dspio_clear_response_queue(codec);
4394 static void ca0132_unsol_event(struct hda_codec *codec, unsigned int res)
4396 snd_printdd(KERN_INFO "ca0132_unsol_event: 0x%x\n", res);
4399 if (((res >> AC_UNSOL_RES_TAG_SHIFT) & 0x3f) == UNSOL_TAG_DSP) {
4400 ca0132_process_dsp_response(codec);
4402 res = snd_hda_jack_get_action(codec,
4403 (res >> AC_UNSOL_RES_TAG_SHIFT) & 0x3f);
4405 snd_printdd(KERN_INFO "snd_hda_jack_get_action: 0x%x\n", res);
4409 ca0132_select_out(codec);
4410 snd_hda_jack_report_sync(codec);
4412 case UNSOL_TAG_AMIC1:
4413 ca0132_select_mic(codec);
4414 snd_hda_jack_report_sync(codec);
4426 /* Sends before DSP download. */
4427 static struct hda_verb ca0132_base_init_verbs[] = {
4428 /*enable ct extension*/
4429 {0x15, VENDOR_CHIPIO_CT_EXTENSIONS_ENABLE, 0x1},
4430 /*enable DSP node unsol, needed for DSP download*/
4431 {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | UNSOL_TAG_DSP},
4436 static struct hda_verb ca0132_base_exit_verbs[] = {
4438 {0x01, AC_VERB_SET_POWER_STATE, 0x03},
4439 /*disable ct extension*/
4440 {0x15, VENDOR_CHIPIO_CT_EXTENSIONS_ENABLE, 0},
4444 /* Other verbs tables. Sends after DSP download. */
4445 static struct hda_verb ca0132_init_verbs0[] = {
4446 /* chip init verbs */
4447 {0x15, 0x70D, 0xF0},
4448 {0x15, 0x70E, 0xFE},
4449 {0x15, 0x707, 0x75},
4450 {0x15, 0x707, 0xD3},
4451 {0x15, 0x707, 0x09},
4452 {0x15, 0x707, 0x53},
4453 {0x15, 0x707, 0xD4},
4454 {0x15, 0x707, 0xEF},
4455 {0x15, 0x707, 0x75},
4456 {0x15, 0x707, 0xD3},
4457 {0x15, 0x707, 0x09},
4458 {0x15, 0x707, 0x02},
4459 {0x15, 0x707, 0x37},
4460 {0x15, 0x707, 0x78},
4461 {0x15, 0x53C, 0xCE},
4462 {0x15, 0x575, 0xC9},
4463 {0x15, 0x53D, 0xCE},
4464 {0x15, 0x5B7, 0xC9},
4465 {0x15, 0x70D, 0xE8},
4466 {0x15, 0x70E, 0xFE},
4467 {0x15, 0x707, 0x02},
4468 {0x15, 0x707, 0x68},
4469 {0x15, 0x707, 0x62},
4470 {0x15, 0x53A, 0xCE},
4471 {0x15, 0x546, 0xC9},
4472 {0x15, 0x53B, 0xCE},
4473 {0x15, 0x5E8, 0xC9},
4474 {0x15, 0x717, 0x0D},
4475 {0x15, 0x718, 0x20},
4479 static struct hda_verb ca0132_init_verbs1[] = {
4480 {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | UNSOL_TAG_HP},
4481 {0x12, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | UNSOL_TAG_AMIC1},
4483 {0x0b, 0x78D, 0x00},
4484 /*{0x0b, AC_VERB_SET_EAPD_BTLENABLE, 0x02},*/
4485 /*{0x10, 0x78D, 0x02},*/
4486 /*{0x10, AC_VERB_SET_EAPD_BTLENABLE, 0x02},*/
4490 static void ca0132_init_chip(struct hda_codec *codec)
4492 struct ca0132_spec *spec = codec->spec;
4497 mutex_init(&spec->chipio_mutex);
4499 spec->cur_out_type = SPEAKER_OUT;
4500 spec->cur_mic_type = DIGITAL_MIC;
4501 spec->cur_mic_boost = 0;
4503 for (i = 0; i < VNODES_COUNT; i++) {
4504 spec->vnode_lvol[i] = 0x5a;
4505 spec->vnode_rvol[i] = 0x5a;
4506 spec->vnode_lswitch[i] = 0;
4507 spec->vnode_rswitch[i] = 0;
4511 * Default states for effects are in ca0132_effects[].
4513 num_fx = OUT_EFFECTS_COUNT + IN_EFFECTS_COUNT;
4514 for (i = 0; i < num_fx; i++) {
4515 on = (unsigned int)ca0132_effects[i].reqs[0];
4516 spec->effects_switch[i] = on ? 1 : 0;
4519 spec->voicefx_val = 0;
4520 spec->effects_switch[PLAY_ENHANCEMENT - EFFECT_START_NID] = 1;
4521 spec->effects_switch[CRYSTAL_VOICE - EFFECT_START_NID] = 0;
4523 #ifdef ENABLE_TUNING_CONTROLS
4524 ca0132_init_tuning_defaults(codec);
4528 static void ca0132_exit_chip(struct hda_codec *codec)
4530 /* put any chip cleanup stuffs here. */
4532 if (dspload_is_loaded(codec))
4536 static int ca0132_init(struct hda_codec *codec)
4538 struct ca0132_spec *spec = codec->spec;
4539 struct auto_pin_cfg *cfg = &spec->autocfg;
4542 spec->dsp_state = DSP_DOWNLOAD_INIT;
4543 spec->curr_chip_addx = INVALID_CHIP_ADDRESS;
4545 snd_hda_power_up(codec);
4547 ca0132_init_params(codec);
4548 ca0132_init_flags(codec);
4549 snd_hda_sequence_write(codec, spec->base_init_verbs);
4550 ca0132_download_dsp(codec);
4551 ca0132_refresh_widget_caps(codec);
4552 ca0132_setup_defaults(codec);
4553 ca0132_init_analog_mic2(codec);
4554 ca0132_init_dmic(codec);
4556 for (i = 0; i < spec->num_outputs; i++)
4557 init_output(codec, spec->out_pins[i], spec->dacs[0]);
4559 init_output(codec, cfg->dig_out_pins[0], spec->dig_out);
4561 for (i = 0; i < spec->num_inputs; i++)
4562 init_input(codec, spec->input_pins[i], spec->adcs[i]);
4564 init_input(codec, cfg->dig_in_pin, spec->dig_in);
4566 for (i = 0; i < spec->num_init_verbs; i++)
4567 snd_hda_sequence_write(codec, spec->init_verbs[i]);
4569 ca0132_init_unsol(codec);
4571 ca0132_select_out(codec);
4572 ca0132_select_mic(codec);
4574 snd_hda_jack_report_sync(codec);
4576 snd_hda_power_down(codec);
4581 static void ca0132_free(struct hda_codec *codec)
4583 struct ca0132_spec *spec = codec->spec;
4585 snd_hda_power_up(codec);
4586 snd_hda_sequence_write(codec, spec->base_exit_verbs);
4587 ca0132_exit_chip(codec);
4588 snd_hda_power_down(codec);
4592 static struct hda_codec_ops ca0132_patch_ops = {
4593 .build_controls = ca0132_build_controls,
4594 .build_pcms = ca0132_build_pcms,
4595 .init = ca0132_init,
4596 .free = ca0132_free,
4597 .unsol_event = ca0132_unsol_event,
4600 static void ca0132_config(struct hda_codec *codec)
4602 struct ca0132_spec *spec = codec->spec;
4603 struct auto_pin_cfg *cfg = &spec->autocfg;
4605 spec->dacs[0] = 0x2;
4606 spec->dacs[1] = 0x3;
4607 spec->dacs[2] = 0x4;
4609 spec->multiout.dac_nids = spec->dacs;
4610 spec->multiout.num_dacs = 3;
4611 spec->multiout.max_channels = 2;
4613 spec->num_outputs = 2;
4614 spec->out_pins[0] = 0x0b; /* speaker out */
4615 spec->out_pins[1] = 0x10; /* headphone out */
4616 spec->shared_out_nid = 0x2;
4618 spec->num_inputs = 3;
4619 spec->adcs[0] = 0x7; /* digital mic / analog mic1 */
4620 spec->adcs[1] = 0x8; /* analog mic2 */
4621 spec->adcs[2] = 0xa; /* what u hear */
4622 spec->shared_mic_nid = 0x7;
4624 spec->input_pins[0] = 0x12;
4625 spec->input_pins[1] = 0x11;
4626 spec->input_pins[2] = 0x13;
4629 spec->dig_out = 0x05;
4630 spec->multiout.dig_out_nid = spec->dig_out;
4631 cfg->dig_out_pins[0] = 0x0c;
4633 cfg->dig_out_type[0] = HDA_PCM_TYPE_SPDIF;
4634 spec->dig_in = 0x09;
4635 cfg->dig_in_pin = 0x0e;
4636 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
4639 static int patch_ca0132(struct hda_codec *codec)
4641 struct ca0132_spec *spec;
4644 snd_printdd("patch_ca0132\n");
4646 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4651 spec->num_mixers = 1;
4652 spec->mixers[0] = ca0132_mixer;
4654 spec->base_init_verbs = ca0132_base_init_verbs;
4655 spec->base_exit_verbs = ca0132_base_exit_verbs;
4656 spec->init_verbs[0] = ca0132_init_verbs0;
4657 spec->init_verbs[1] = ca0132_init_verbs1;
4658 spec->num_init_verbs = 2;
4660 ca0132_init_chip(codec);
4662 ca0132_config(codec);
4664 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
4668 codec->patch_ops = ca0132_patch_ops;
4676 static struct hda_codec_preset snd_hda_preset_ca0132[] = {
4677 { .id = 0x11020011, .name = "CA0132", .patch = patch_ca0132 },
4681 MODULE_ALIAS("snd-hda-codec-id:11020011");
4683 MODULE_LICENSE("GPL");
4684 MODULE_DESCRIPTION("Creative Sound Core3D codec");
4686 static struct hda_codec_preset_list ca0132_list = {
4687 .preset = snd_hda_preset_ca0132,
4688 .owner = THIS_MODULE,
4691 static int __init patch_ca0132_init(void)
4693 return snd_hda_add_codec_preset(&ca0132_list);
4696 static void __exit patch_ca0132_exit(void)
4698 snd_hda_delete_codec_preset(&ca0132_list);
4701 module_init(patch_ca0132_init)
4702 module_exit(patch_ca0132_exit)