?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 3.12.39
[linux/fpc-iii.git] / sound / pci / hda / patch_ca0132.c
blob8458b6e50efc00ef46d85b28eb8554de847a0c42
1 /*
2 * HD audio interface patch for Creative CA0132 chip
3 *
4 * Copyright (c) 2011, Creative Technology Ltd.
5 *
6 * Based on patch_ca0110.c
7 * Copyright (c) 2008 Takashi Iwai <tiwai@suse.de>
8 *
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.
13 *
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.
18 *
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
22 */
23
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"
35 #include "hda_jack.h"
36
37 #include "ca0132_regs.h"
38
39 /* Enable this to see controls for tuning purpose. */
40 /*#define ENABLE_TUNING_CONTROLS*/
41
42 #define FLOAT_ZERO 0x00000000
43 #define FLOAT_ONE 0x3f800000
44 #define FLOAT_TWO 0x40000000
45 #define FLOAT_MINUS_5 0xc0a00000
46
47 #define UNSOL_TAG_HP 0x10
48 #define UNSOL_TAG_AMIC1 0x12
49 #define UNSOL_TAG_DSP 0x16
50
51 #define DSP_DMA_WRITE_BUFLEN_INIT (1UL<<18)
52 #define DSP_DMA_WRITE_BUFLEN_OVLY (1UL<<15)
53
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
57
58 #define MASTERCONTROL 0x80
59 #define MASTERCONTROL_ALLOC_DMA_CHAN 10
60 #define MASTERCONTROL_QUERY_SPEAKER_EQ_ADDRESS 60
61
62 #define WIDGET_CHIP_CTRL 0x15
63 #define WIDGET_DSP_CTRL 0x16
64
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
72
73 #define SCP_SET 0
74 #define SCP_GET 1
75
76 #define EFX_FILE "ctefx.bin"
77
78 #ifdef CONFIG_SND_HDA_CODEC_CA0132_DSP
79 MODULE_FIRMWARE(EFX_FILE);
80 #endif
81
82 static char *dirstr[2] = { "Playback", "Capture" };
83
84 enum {
85 SPEAKER_OUT,
86 HEADPHONE_OUT
87 };
88
89 enum {
90 DIGITAL_MIC,
91 LINE_MIC_IN
92 };
93
94 enum {
95 #define VNODE_START_NID 0x80
96 VNID_SPK = VNODE_START_NID, /* Speaker vnid */
97 VNID_MIC,
98 VNID_HP_SEL,
99 VNID_AMIC1_SEL,
100 VNID_HP_ASEL,
101 VNID_AMIC1_ASEL,
102 VNODE_END_NID,
103 #define VNODES_COUNT (VNODE_END_NID - VNODE_START_NID)
104
105 #define EFFECT_START_NID 0x90
106 #define OUT_EFFECT_START_NID EFFECT_START_NID
107 SURROUND = OUT_EFFECT_START_NID,
108 CRYSTALIZER,
109 DIALOG_PLUS,
110 SMART_VOLUME,
111 X_BASS,
112 EQUALIZER,
113 OUT_EFFECT_END_NID,
114 #define OUT_EFFECTS_COUNT (OUT_EFFECT_END_NID - OUT_EFFECT_START_NID)
115
116 #define IN_EFFECT_START_NID OUT_EFFECT_END_NID
117 ECHO_CANCELLATION = IN_EFFECT_START_NID,
118 VOICE_FOCUS,
119 MIC_SVM,
120 NOISE_REDUCTION,
121 IN_EFFECT_END_NID,
122 #define IN_EFFECTS_COUNT (IN_EFFECT_END_NID - IN_EFFECT_START_NID)
123
124 VOICEFX = IN_EFFECT_END_NID,
125 PLAY_ENHANCEMENT,
126 CRYSTAL_VOICE,
127 EFFECT_END_NID
128 #define EFFECTS_COUNT (EFFECT_END_NID - EFFECT_START_NID)
129 };
130
131 /* Effects values size*/
132 #define EFFECT_VALS_MAX_COUNT 12
133
134 /* Latency introduced by DSP blocks in milliseconds. */
135 #define DSP_CAPTURE_INIT_LATENCY 0
136 #define DSP_CRYSTAL_VOICE_LATENCY 124
137 #define DSP_PLAYBACK_INIT_LATENCY 13
138 #define DSP_PLAY_ENHANCEMENT_LATENCY 30
139 #define DSP_SPEAKER_OUT_LATENCY 7
140
141 struct ct_effect {
142 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
143 hda_nid_t nid;
144 int mid; /*effect module ID*/
145 int reqs[EFFECT_VALS_MAX_COUNT]; /*effect module request*/
146 int direct; /* 0:output; 1:input*/
147 int params; /* number of default non-on/off params */
148 /*effect default values, 1st is on/off. */
149 unsigned int def_vals[EFFECT_VALS_MAX_COUNT];
150 };
151
152 #define EFX_DIR_OUT 0
153 #define EFX_DIR_IN 1
154
155 static struct ct_effect ca0132_effects[EFFECTS_COUNT] = {
156 { .name = "Surround",
157 .nid = SURROUND,
158 .mid = 0x96,
159 .reqs = {0, 1},
160 .direct = EFX_DIR_OUT,
161 .params = 1,
162 .def_vals = {0x3F800000, 0x3F2B851F}
163 },
164 { .name = "Crystalizer",
165 .nid = CRYSTALIZER,
166 .mid = 0x96,
167 .reqs = {7, 8},
168 .direct = EFX_DIR_OUT,
169 .params = 1,
170 .def_vals = {0x3F800000, 0x3F266666}
171 },
172 { .name = "Dialog Plus",
173 .nid = DIALOG_PLUS,
174 .mid = 0x96,
175 .reqs = {2, 3},
176 .direct = EFX_DIR_OUT,
177 .params = 1,
178 .def_vals = {0x00000000, 0x3F000000}
179 },
180 { .name = "Smart Volume",
181 .nid = SMART_VOLUME,
182 .mid = 0x96,
183 .reqs = {4, 5, 6},
184 .direct = EFX_DIR_OUT,
185 .params = 2,
186 .def_vals = {0x3F800000, 0x3F3D70A4, 0x00000000}
187 },
188 { .name = "X-Bass",
189 .nid = X_BASS,
190 .mid = 0x96,
191 .reqs = {24, 23, 25},
192 .direct = EFX_DIR_OUT,
193 .params = 2,
194 .def_vals = {0x3F800000, 0x42A00000, 0x3F000000}
195 },
196 { .name = "Equalizer",
197 .nid = EQUALIZER,
198 .mid = 0x96,
199 .reqs = {9, 10, 11, 12, 13, 14,
200 15, 16, 17, 18, 19, 20},
201 .direct = EFX_DIR_OUT,
202 .params = 11,
203 .def_vals = {0x00000000, 0x00000000, 0x00000000, 0x00000000,
204 0x00000000, 0x00000000, 0x00000000, 0x00000000,
205 0x00000000, 0x00000000, 0x00000000, 0x00000000}
206 },
207 { .name = "Echo Cancellation",
208 .nid = ECHO_CANCELLATION,
209 .mid = 0x95,
210 .reqs = {0, 1, 2, 3},
211 .direct = EFX_DIR_IN,
212 .params = 3,
213 .def_vals = {0x00000000, 0x3F3A9692, 0x00000000, 0x00000000}
214 },
215 { .name = "Voice Focus",
216 .nid = VOICE_FOCUS,
217 .mid = 0x95,
218 .reqs = {6, 7, 8, 9},
219 .direct = EFX_DIR_IN,
220 .params = 3,
221 .def_vals = {0x3F800000, 0x3D7DF3B6, 0x41F00000, 0x41F00000}
222 },
223 { .name = "Mic SVM",
224 .nid = MIC_SVM,
225 .mid = 0x95,
226 .reqs = {44, 45},
227 .direct = EFX_DIR_IN,
228 .params = 1,
229 .def_vals = {0x00000000, 0x3F3D70A4}
230 },
231 { .name = "Noise Reduction",
232 .nid = NOISE_REDUCTION,
233 .mid = 0x95,
234 .reqs = {4, 5},
235 .direct = EFX_DIR_IN,
236 .params = 1,
237 .def_vals = {0x3F800000, 0x3F000000}
238 },
239 { .name = "VoiceFX",
240 .nid = VOICEFX,
241 .mid = 0x95,
242 .reqs = {10, 11, 12, 13, 14, 15, 16, 17, 18},
243 .direct = EFX_DIR_IN,
244 .params = 8,
245 .def_vals = {0x00000000, 0x43C80000, 0x44AF0000, 0x44FA0000,
246 0x3F800000, 0x3F800000, 0x3F800000, 0x00000000,
247 0x00000000}
248 }
249 };
250
251 /* Tuning controls */
252 #ifdef ENABLE_TUNING_CONTROLS
253
254 enum {
255 #define TUNING_CTL_START_NID 0xC0
256 WEDGE_ANGLE = TUNING_CTL_START_NID,
257 SVM_LEVEL,
258 EQUALIZER_BAND_0,
259 EQUALIZER_BAND_1,
260 EQUALIZER_BAND_2,
261 EQUALIZER_BAND_3,
262 EQUALIZER_BAND_4,
263 EQUALIZER_BAND_5,
264 EQUALIZER_BAND_6,
265 EQUALIZER_BAND_7,
266 EQUALIZER_BAND_8,
267 EQUALIZER_BAND_9,
268 TUNING_CTL_END_NID
269 #define TUNING_CTLS_COUNT (TUNING_CTL_END_NID - TUNING_CTL_START_NID)
270 };
271
272 struct ct_tuning_ctl {
273 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
274 hda_nid_t parent_nid;
275 hda_nid_t nid;
276 int mid; /*effect module ID*/
277 int req; /*effect module request*/
278 int direct; /* 0:output; 1:input*/
279 unsigned int def_val;/*effect default values*/
280 };
281
282 static struct ct_tuning_ctl ca0132_tuning_ctls[] = {
283 { .name = "Wedge Angle",
284 .parent_nid = VOICE_FOCUS,
285 .nid = WEDGE_ANGLE,
286 .mid = 0x95,
287 .req = 8,
288 .direct = EFX_DIR_IN,
289 .def_val = 0x41F00000
290 },
291 { .name = "SVM Level",
292 .parent_nid = MIC_SVM,
293 .nid = SVM_LEVEL,
294 .mid = 0x95,
295 .req = 45,
296 .direct = EFX_DIR_IN,
297 .def_val = 0x3F3D70A4
298 },
299 { .name = "EQ Band0",
300 .parent_nid = EQUALIZER,
301 .nid = EQUALIZER_BAND_0,
302 .mid = 0x96,
303 .req = 11,
304 .direct = EFX_DIR_OUT,
305 .def_val = 0x00000000
306 },
307 { .name = "EQ Band1",
308 .parent_nid = EQUALIZER,
309 .nid = EQUALIZER_BAND_1,
310 .mid = 0x96,
311 .req = 12,
312 .direct = EFX_DIR_OUT,
313 .def_val = 0x00000000
314 },
315 { .name = "EQ Band2",
316 .parent_nid = EQUALIZER,
317 .nid = EQUALIZER_BAND_2,
318 .mid = 0x96,
319 .req = 13,
320 .direct = EFX_DIR_OUT,
321 .def_val = 0x00000000
322 },
323 { .name = "EQ Band3",
324 .parent_nid = EQUALIZER,
325 .nid = EQUALIZER_BAND_3,
326 .mid = 0x96,
327 .req = 14,
328 .direct = EFX_DIR_OUT,
329 .def_val = 0x00000000
330 },
331 { .name = "EQ Band4",
332 .parent_nid = EQUALIZER,
333 .nid = EQUALIZER_BAND_4,
334 .mid = 0x96,
335 .req = 15,
336 .direct = EFX_DIR_OUT,
337 .def_val = 0x00000000
338 },
339 { .name = "EQ Band5",
340 .parent_nid = EQUALIZER,
341 .nid = EQUALIZER_BAND_5,
342 .mid = 0x96,
343 .req = 16,
344 .direct = EFX_DIR_OUT,
345 .def_val = 0x00000000
346 },
347 { .name = "EQ Band6",
348 .parent_nid = EQUALIZER,
349 .nid = EQUALIZER_BAND_6,
350 .mid = 0x96,
351 .req = 17,
352 .direct = EFX_DIR_OUT,
353 .def_val = 0x00000000
354 },
355 { .name = "EQ Band7",
356 .parent_nid = EQUALIZER,
357 .nid = EQUALIZER_BAND_7,
358 .mid = 0x96,
359 .req = 18,
360 .direct = EFX_DIR_OUT,
361 .def_val = 0x00000000
362 },
363 { .name = "EQ Band8",
364 .parent_nid = EQUALIZER,
365 .nid = EQUALIZER_BAND_8,
366 .mid = 0x96,
367 .req = 19,
368 .direct = EFX_DIR_OUT,
369 .def_val = 0x00000000
370 },
371 { .name = "EQ Band9",
372 .parent_nid = EQUALIZER,
373 .nid = EQUALIZER_BAND_9,
374 .mid = 0x96,
375 .req = 20,
376 .direct = EFX_DIR_OUT,
377 .def_val = 0x00000000
378 }
379 };
380 #endif
381
382 /* Voice FX Presets */
383 #define VOICEFX_MAX_PARAM_COUNT 9
384
385 struct ct_voicefx {
386 char *name;
387 hda_nid_t nid;
388 int mid;
389 int reqs[VOICEFX_MAX_PARAM_COUNT]; /*effect module request*/
390 };
391
392 struct ct_voicefx_preset {
393 char *name; /*preset name*/
394 unsigned int vals[VOICEFX_MAX_PARAM_COUNT];
395 };
396
397 static struct ct_voicefx ca0132_voicefx = {
398 .name = "VoiceFX Capture Switch",
399 .nid = VOICEFX,
400 .mid = 0x95,
401 .reqs = {10, 11, 12, 13, 14, 15, 16, 17, 18}
402 };
403
404 static struct ct_voicefx_preset ca0132_voicefx_presets[] = {
405 { .name = "Neutral",
406 .vals = { 0x00000000, 0x43C80000, 0x44AF0000,
407 0x44FA0000, 0x3F800000, 0x3F800000,
408 0x3F800000, 0x00000000, 0x00000000 }
409 },
410 { .name = "Female2Male",
411 .vals = { 0x3F800000, 0x43C80000, 0x44AF0000,
412 0x44FA0000, 0x3F19999A, 0x3F866666,
413 0x3F800000, 0x00000000, 0x00000000 }
414 },
415 { .name = "Male2Female",
416 .vals = { 0x3F800000, 0x43C80000, 0x44AF0000,
417 0x450AC000, 0x4017AE14, 0x3F6B851F,
418 0x3F800000, 0x00000000, 0x00000000 }
419 },
420 { .name = "ScrappyKid",
421 .vals = { 0x3F800000, 0x43C80000, 0x44AF0000,
422 0x44FA0000, 0x40400000, 0x3F28F5C3,
423 0x3F800000, 0x00000000, 0x00000000 }
424 },
425 { .name = "Elderly",
426 .vals = { 0x3F800000, 0x44324000, 0x44BB8000,
427 0x44E10000, 0x3FB33333, 0x3FB9999A,
428 0x3F800000, 0x3E3A2E43, 0x00000000 }
429 },
430 { .name = "Orc",
431 .vals = { 0x3F800000, 0x43EA0000, 0x44A52000,
432 0x45098000, 0x3F266666, 0x3FC00000,
433 0x3F800000, 0x00000000, 0x00000000 }
434 },
435 { .name = "Elf",
436 .vals = { 0x3F800000, 0x43C70000, 0x44AE6000,
437 0x45193000, 0x3F8E147B, 0x3F75C28F,
438 0x3F800000, 0x00000000, 0x00000000 }
439 },
440 { .name = "Dwarf",
441 .vals = { 0x3F800000, 0x43930000, 0x44BEE000,
442 0x45007000, 0x3F451EB8, 0x3F7851EC,
443 0x3F800000, 0x00000000, 0x00000000 }
444 },
445 { .name = "AlienBrute",
446 .vals = { 0x3F800000, 0x43BFC5AC, 0x44B28FDF,
447 0x451F6000, 0x3F266666, 0x3FA7D945,
448 0x3F800000, 0x3CF5C28F, 0x00000000 }
449 },
450 { .name = "Robot",
451 .vals = { 0x3F800000, 0x43C80000, 0x44AF0000,
452 0x44FA0000, 0x3FB2718B, 0x3F800000,
453 0xBC07010E, 0x00000000, 0x00000000 }
454 },
455 { .name = "Marine",
456 .vals = { 0x3F800000, 0x43C20000, 0x44906000,
457 0x44E70000, 0x3F4CCCCD, 0x3F8A3D71,
458 0x3F0A3D71, 0x00000000, 0x00000000 }
459 },
460 { .name = "Emo",
461 .vals = { 0x3F800000, 0x43C80000, 0x44AF0000,
462 0x44FA0000, 0x3F800000, 0x3F800000,
463 0x3E4CCCCD, 0x00000000, 0x00000000 }
464 },
465 { .name = "DeepVoice",
466 .vals = { 0x3F800000, 0x43A9C5AC, 0x44AA4FDF,
467 0x44FFC000, 0x3EDBB56F, 0x3F99C4CA,
468 0x3F800000, 0x00000000, 0x00000000 }
469 },
470 { .name = "Munchkin",
471 .vals = { 0x3F800000, 0x43C80000, 0x44AF0000,
472 0x44FA0000, 0x3F800000, 0x3F1A043C,
473 0x3F800000, 0x00000000, 0x00000000 }
474 }
475 };
476
477 enum hda_cmd_vendor_io {
478 /* for DspIO node */
479 VENDOR_DSPIO_SCP_WRITE_DATA_LOW = 0x000,
480 VENDOR_DSPIO_SCP_WRITE_DATA_HIGH = 0x100,
481
482 VENDOR_DSPIO_STATUS = 0xF01,
483 VENDOR_DSPIO_SCP_POST_READ_DATA = 0x702,
484 VENDOR_DSPIO_SCP_READ_DATA = 0xF02,
485 VENDOR_DSPIO_DSP_INIT = 0x703,
486 VENDOR_DSPIO_SCP_POST_COUNT_QUERY = 0x704,
487 VENDOR_DSPIO_SCP_READ_COUNT = 0xF04,
488
489 /* for ChipIO node */
490 VENDOR_CHIPIO_ADDRESS_LOW = 0x000,
491 VENDOR_CHIPIO_ADDRESS_HIGH = 0x100,
492 VENDOR_CHIPIO_STREAM_FORMAT = 0x200,
493 VENDOR_CHIPIO_DATA_LOW = 0x300,
494 VENDOR_CHIPIO_DATA_HIGH = 0x400,
495
496 VENDOR_CHIPIO_GET_PARAMETER = 0xF00,
497 VENDOR_CHIPIO_STATUS = 0xF01,
498 VENDOR_CHIPIO_HIC_POST_READ = 0x702,
499 VENDOR_CHIPIO_HIC_READ_DATA = 0xF03,
500
501 VENDOR_CHIPIO_8051_DATA_WRITE = 0x707,
502 VENDOR_CHIPIO_8051_DATA_READ = 0xF07,
503
504 VENDOR_CHIPIO_CT_EXTENSIONS_ENABLE = 0x70A,
505 VENDOR_CHIPIO_CT_EXTENSIONS_GET = 0xF0A,
506
507 VENDOR_CHIPIO_PLL_PMU_WRITE = 0x70C,
508 VENDOR_CHIPIO_PLL_PMU_READ = 0xF0C,
509 VENDOR_CHIPIO_8051_ADDRESS_LOW = 0x70D,
510 VENDOR_CHIPIO_8051_ADDRESS_HIGH = 0x70E,
511 VENDOR_CHIPIO_FLAG_SET = 0x70F,
512 VENDOR_CHIPIO_FLAGS_GET = 0xF0F,
513 VENDOR_CHIPIO_PARAM_SET = 0x710,
514 VENDOR_CHIPIO_PARAM_GET = 0xF10,
515
516 VENDOR_CHIPIO_PORT_ALLOC_CONFIG_SET = 0x711,
517 VENDOR_CHIPIO_PORT_ALLOC_SET = 0x712,
518 VENDOR_CHIPIO_PORT_ALLOC_GET = 0xF12,
519 VENDOR_CHIPIO_PORT_FREE_SET = 0x713,
520
521 VENDOR_CHIPIO_PARAM_EX_ID_GET = 0xF17,
522 VENDOR_CHIPIO_PARAM_EX_ID_SET = 0x717,
523 VENDOR_CHIPIO_PARAM_EX_VALUE_GET = 0xF18,
524 VENDOR_CHIPIO_PARAM_EX_VALUE_SET = 0x718,
525
526 VENDOR_CHIPIO_DMIC_CTL_SET = 0x788,
527 VENDOR_CHIPIO_DMIC_CTL_GET = 0xF88,
528 VENDOR_CHIPIO_DMIC_PIN_SET = 0x789,
529 VENDOR_CHIPIO_DMIC_PIN_GET = 0xF89,
530 VENDOR_CHIPIO_DMIC_MCLK_SET = 0x78A,
531 VENDOR_CHIPIO_DMIC_MCLK_GET = 0xF8A,
532
533 VENDOR_CHIPIO_EAPD_SEL_SET = 0x78D
534 };
535
536 /*
537 * Control flag IDs
538 */
539 enum control_flag_id {
540 /* Connection manager stream setup is bypassed/enabled */
541 CONTROL_FLAG_C_MGR = 0,
542 /* DSP DMA is bypassed/enabled */
543 CONTROL_FLAG_DMA = 1,
544 /* 8051 'idle' mode is disabled/enabled */
545 CONTROL_FLAG_IDLE_ENABLE = 2,
546 /* Tracker for the SPDIF-in path is bypassed/enabled */
547 CONTROL_FLAG_TRACKER = 3,
548 /* DigitalOut to Spdif2Out connection is disabled/enabled */
549 CONTROL_FLAG_SPDIF2OUT = 4,
550 /* Digital Microphone is disabled/enabled */
551 CONTROL_FLAG_DMIC = 5,
552 /* ADC_B rate is 48 kHz/96 kHz */
553 CONTROL_FLAG_ADC_B_96KHZ = 6,
554 /* ADC_C rate is 48 kHz/96 kHz */
555 CONTROL_FLAG_ADC_C_96KHZ = 7,
556 /* DAC rate is 48 kHz/96 kHz (affects all DACs) */
557 CONTROL_FLAG_DAC_96KHZ = 8,
558 /* DSP rate is 48 kHz/96 kHz */
559 CONTROL_FLAG_DSP_96KHZ = 9,
560 /* SRC clock is 98 MHz/196 MHz (196 MHz forces rate to 96 KHz) */
561 CONTROL_FLAG_SRC_CLOCK_196MHZ = 10,
562 /* SRC rate is 48 kHz/96 kHz (48 kHz disabled when clock is 196 MHz) */
563 CONTROL_FLAG_SRC_RATE_96KHZ = 11,
564 /* Decode Loop (DSP->SRC->DSP) is disabled/enabled */
565 CONTROL_FLAG_DECODE_LOOP = 12,
566 /* De-emphasis filter on DAC-1 disabled/enabled */
567 CONTROL_FLAG_DAC1_DEEMPHASIS = 13,
568 /* De-emphasis filter on DAC-2 disabled/enabled */
569 CONTROL_FLAG_DAC2_DEEMPHASIS = 14,
570 /* De-emphasis filter on DAC-3 disabled/enabled */
571 CONTROL_FLAG_DAC3_DEEMPHASIS = 15,
572 /* High-pass filter on ADC_B disabled/enabled */
573 CONTROL_FLAG_ADC_B_HIGH_PASS = 16,
574 /* High-pass filter on ADC_C disabled/enabled */
575 CONTROL_FLAG_ADC_C_HIGH_PASS = 17,
576 /* Common mode on Port_A disabled/enabled */
577 CONTROL_FLAG_PORT_A_COMMON_MODE = 18,
578 /* Common mode on Port_D disabled/enabled */
579 CONTROL_FLAG_PORT_D_COMMON_MODE = 19,
580 /* Impedance for ramp generator on Port_A 16 Ohm/10K Ohm */
581 CONTROL_FLAG_PORT_A_10KOHM_LOAD = 20,
582 /* Impedance for ramp generator on Port_D, 16 Ohm/10K Ohm */
583 CONTROL_FLAG_PORT_D_10KOHM_LOAD = 21,
584 /* ASI rate is 48kHz/96kHz */
585 CONTROL_FLAG_ASI_96KHZ = 22,
586 /* DAC power settings able to control attached ports no/yes */
587 CONTROL_FLAG_DACS_CONTROL_PORTS = 23,
588 /* Clock Stop OK reporting is disabled/enabled */
589 CONTROL_FLAG_CONTROL_STOP_OK_ENABLE = 24,
590 /* Number of control flags */
591 CONTROL_FLAGS_MAX = (CONTROL_FLAG_CONTROL_STOP_OK_ENABLE+1)
592 };
593
594 /*
595 * Control parameter IDs
596 */
597 enum control_param_id {
598 /* 0: None, 1: Mic1In*/
599 CONTROL_PARAM_VIP_SOURCE = 1,
600 /* 0: force HDA, 1: allow DSP if HDA Spdif1Out stream is idle */
601 CONTROL_PARAM_SPDIF1_SOURCE = 2,
602 /* Port A output stage gain setting to use when 16 Ohm output
603 * impedance is selected*/
604 CONTROL_PARAM_PORTA_160OHM_GAIN = 8,
605 /* Port D output stage gain setting to use when 16 Ohm output
606 * impedance is selected*/
607 CONTROL_PARAM_PORTD_160OHM_GAIN = 10,
608
609 /* Stream Control */
610
611 /* Select stream with the given ID */
612 CONTROL_PARAM_STREAM_ID = 24,
613 /* Source connection point for the selected stream */
614 CONTROL_PARAM_STREAM_SOURCE_CONN_POINT = 25,
615 /* Destination connection point for the selected stream */
616 CONTROL_PARAM_STREAM_DEST_CONN_POINT = 26,
617 /* Number of audio channels in the selected stream */
618 CONTROL_PARAM_STREAMS_CHANNELS = 27,
619 /*Enable control for the selected stream */
620 CONTROL_PARAM_STREAM_CONTROL = 28,
621
622 /* Connection Point Control */
623
624 /* Select connection point with the given ID */
625 CONTROL_PARAM_CONN_POINT_ID = 29,
626 /* Connection point sample rate */
627 CONTROL_PARAM_CONN_POINT_SAMPLE_RATE = 30,
628
629 /* Node Control */
630
631 /* Select HDA node with the given ID */
632 CONTROL_PARAM_NODE_ID = 31
633 };
634
635 /*
636 * Dsp Io Status codes
637 */
638 enum hda_vendor_status_dspio {
639 /* Success */
640 VENDOR_STATUS_DSPIO_OK = 0x00,
641 /* Busy, unable to accept new command, the host must retry */
642 VENDOR_STATUS_DSPIO_BUSY = 0x01,
643 /* SCP command queue is full */
644 VENDOR_STATUS_DSPIO_SCP_COMMAND_QUEUE_FULL = 0x02,
645 /* SCP response queue is empty */
646 VENDOR_STATUS_DSPIO_SCP_RESPONSE_QUEUE_EMPTY = 0x03
647 };
648
649 /*
650 * Chip Io Status codes
651 */
652 enum hda_vendor_status_chipio {
653 /* Success */
654 VENDOR_STATUS_CHIPIO_OK = 0x00,
655 /* Busy, unable to accept new command, the host must retry */
656 VENDOR_STATUS_CHIPIO_BUSY = 0x01
657 };
658
659 /*
660 * CA0132 sample rate
661 */
662 enum ca0132_sample_rate {
663 SR_6_000 = 0x00,
664 SR_8_000 = 0x01,
665 SR_9_600 = 0x02,
666 SR_11_025 = 0x03,
667 SR_16_000 = 0x04,
668 SR_22_050 = 0x05,
669 SR_24_000 = 0x06,
670 SR_32_000 = 0x07,
671 SR_44_100 = 0x08,
672 SR_48_000 = 0x09,
673 SR_88_200 = 0x0A,
674 SR_96_000 = 0x0B,
675 SR_144_000 = 0x0C,
676 SR_176_400 = 0x0D,
677 SR_192_000 = 0x0E,
678 SR_384_000 = 0x0F,
679
680 SR_COUNT = 0x10,
681
682 SR_RATE_UNKNOWN = 0x1F
683 };
684
685 enum dsp_download_state {
686 DSP_DOWNLOAD_FAILED = -1,
687 DSP_DOWNLOAD_INIT = 0,
688 DSP_DOWNLOADING = 1,
689 DSP_DOWNLOADED = 2
690 };
691
692 /* retrieve parameters from hda format */
693 #define get_hdafmt_chs(fmt) (fmt & 0xf)
694 #define get_hdafmt_bits(fmt) ((fmt >> 4) & 0x7)
695 #define get_hdafmt_rate(fmt) ((fmt >> 8) & 0x7f)
696 #define get_hdafmt_type(fmt) ((fmt >> 15) & 0x1)
697
698 /*
699 * CA0132 specific
700 */
701
702 struct ca0132_spec {
703 struct snd_kcontrol_new *mixers[5];
704 unsigned int num_mixers;
705 const struct hda_verb *base_init_verbs;
706 const struct hda_verb *base_exit_verbs;
707 const struct hda_verb *init_verbs[5];
708 unsigned int num_init_verbs; /* exclude base init verbs */
709 struct auto_pin_cfg autocfg;
710
711 /* Nodes configurations */
712 struct hda_multi_out multiout;
713 hda_nid_t out_pins[AUTO_CFG_MAX_OUTS];
714 hda_nid_t dacs[AUTO_CFG_MAX_OUTS];
715 unsigned int num_outputs;
716 hda_nid_t input_pins[AUTO_PIN_LAST];
717 hda_nid_t adcs[AUTO_PIN_LAST];
718 hda_nid_t dig_out;
719 hda_nid_t dig_in;
720 unsigned int num_inputs;
721 hda_nid_t shared_mic_nid;
722 hda_nid_t shared_out_nid;
723 struct hda_pcm pcm_rec[5]; /* PCM information */
724
725 /* chip access */
726 struct mutex chipio_mutex; /* chip access mutex */
727 u32 curr_chip_addx;
728
729 /* DSP download related */
730 enum dsp_download_state dsp_state;
731 unsigned int dsp_stream_id;
732 unsigned int wait_scp;
733 unsigned int wait_scp_header;
734 unsigned int wait_num_data;
735 unsigned int scp_resp_header;
736 unsigned int scp_resp_data[4];
737 unsigned int scp_resp_count;
738
739 /* mixer and effects related */
740 unsigned char dmic_ctl;
741 int cur_out_type;
742 int cur_mic_type;
743 long vnode_lvol[VNODES_COUNT];
744 long vnode_rvol[VNODES_COUNT];
745 long vnode_lswitch[VNODES_COUNT];
746 long vnode_rswitch[VNODES_COUNT];
747 long effects_switch[EFFECTS_COUNT];
748 long voicefx_val;
749 long cur_mic_boost;
750
751 struct hda_codec *codec;
752 struct delayed_work unsol_hp_work;
753
754 #ifdef ENABLE_TUNING_CONTROLS
755 long cur_ctl_vals[TUNING_CTLS_COUNT];
756 #endif
757 };
758
759 /*
760 * CA0132 codec access
761 */
762 unsigned int codec_send_command(struct hda_codec *codec, hda_nid_t nid,
763 unsigned int verb, unsigned int parm, unsigned int *res)
764 {
765 unsigned int response;
766 response = snd_hda_codec_read(codec, nid, 0, verb, parm);
767 *res = response;
768
769 return ((response == -1) ? -1 : 0);
770 }
771
772 static int codec_set_converter_format(struct hda_codec *codec, hda_nid_t nid,
773 unsigned short converter_format, unsigned int *res)
774 {
775 return codec_send_command(codec, nid, VENDOR_CHIPIO_STREAM_FORMAT,
776 converter_format & 0xffff, res);
777 }
778
779 static int codec_set_converter_stream_channel(struct hda_codec *codec,
780 hda_nid_t nid, unsigned char stream,
781 unsigned char channel, unsigned int *res)
782 {
783 unsigned char converter_stream_channel = 0;
784
785 converter_stream_channel = (stream << 4) | (channel & 0x0f);
786 return codec_send_command(codec, nid, AC_VERB_SET_CHANNEL_STREAMID,
787 converter_stream_channel, res);
788 }
789
790 /* Chip access helper function */
791 static int chipio_send(struct hda_codec *codec,
792 unsigned int reg,
793 unsigned int data)
794 {
795 unsigned int res;
796 unsigned long timeout = jiffies + msecs_to_jiffies(1000);
797
798 /* send bits of data specified by reg */
799 do {
800 res = snd_hda_codec_read(codec, WIDGET_CHIP_CTRL, 0,
801 reg, data);
802 if (res == VENDOR_STATUS_CHIPIO_OK)
803 return 0;
804 msleep(20);
805 } while (time_before(jiffies, timeout));
806
807 return -EIO;
808 }
809
810 /*
811 * Write chip address through the vendor widget -- NOT protected by the Mutex!
812 */
813 static int chipio_write_address(struct hda_codec *codec,
814 unsigned int chip_addx)
815 {
816 struct ca0132_spec *spec = codec->spec;
817 int res;
818
819 if (spec->curr_chip_addx == chip_addx)
820 return 0;
821
822 /* send low 16 bits of the address */
823 res = chipio_send(codec, VENDOR_CHIPIO_ADDRESS_LOW,
824 chip_addx & 0xffff);
825
826 if (res != -EIO) {
827 /* send high 16 bits of the address */
828 res = chipio_send(codec, VENDOR_CHIPIO_ADDRESS_HIGH,
829 chip_addx >> 16);
830 }
831
832 spec->curr_chip_addx = (res < 0) ? ~0UL : chip_addx;
833
834 return res;
835 }
836
837 /*
838 * Write data through the vendor widget -- NOT protected by the Mutex!
839 */
840 static int chipio_write_data(struct hda_codec *codec, unsigned int data)
841 {
842 struct ca0132_spec *spec = codec->spec;
843 int res;
844
845 /* send low 16 bits of the data */
846 res = chipio_send(codec, VENDOR_CHIPIO_DATA_LOW, data & 0xffff);
847
848 if (res != -EIO) {
849 /* send high 16 bits of the data */
850 res = chipio_send(codec, VENDOR_CHIPIO_DATA_HIGH,
851 data >> 16);
852 }
853
854 /*If no error encountered, automatically increment the address
855 as per chip behaviour*/
856 spec->curr_chip_addx = (res != -EIO) ?
857 (spec->curr_chip_addx + 4) : ~0UL;
858 return res;
859 }
860
861 /*
862 * Write multiple data through the vendor widget -- NOT protected by the Mutex!
863 */
864 static int chipio_write_data_multiple(struct hda_codec *codec,
865 const u32 *data,
866 unsigned int count)
867 {
868 int status = 0;
869
870 if (data == NULL) {
871 snd_printdd(KERN_ERR "chipio_write_data null ptr\n");
872 return -EINVAL;
873 }
874
875 while ((count-- != 0) && (status == 0))
876 status = chipio_write_data(codec, *data++);
877
878 return status;
879 }
880
881
882 /*
883 * Read data through the vendor widget -- NOT protected by the Mutex!
884 */
885 static int chipio_read_data(struct hda_codec *codec, unsigned int *data)
886 {
887 struct ca0132_spec *spec = codec->spec;
888 int res;
889
890 /* post read */
891 res = chipio_send(codec, VENDOR_CHIPIO_HIC_POST_READ, 0);
892
893 if (res != -EIO) {
894 /* read status */
895 res = chipio_send(codec, VENDOR_CHIPIO_STATUS, 0);
896 }
897
898 if (res != -EIO) {
899 /* read data */
900 *data = snd_hda_codec_read(codec, WIDGET_CHIP_CTRL, 0,
901 VENDOR_CHIPIO_HIC_READ_DATA,
902 0);
903 }
904
905 /*If no error encountered, automatically increment the address
906 as per chip behaviour*/
907 spec->curr_chip_addx = (res != -EIO) ?
908 (spec->curr_chip_addx + 4) : ~0UL;
909 return res;
910 }
911
912 /*
913 * Write given value to the given address through the chip I/O widget.
914 * protected by the Mutex
915 */
916 static int chipio_write(struct hda_codec *codec,
917 unsigned int chip_addx, const unsigned int data)
918 {
919 struct ca0132_spec *spec = codec->spec;
920 int err;
921
922 mutex_lock(&spec->chipio_mutex);
923
924 /* write the address, and if successful proceed to write data */
925 err = chipio_write_address(codec, chip_addx);
926 if (err < 0)
927 goto exit;
928
929 err = chipio_write_data(codec, data);
930 if (err < 0)
931 goto exit;
932
933 exit:
934 mutex_unlock(&spec->chipio_mutex);
935 return err;
936 }
937
938 /*
939 * Write multiple values to the given address through the chip I/O widget.
940 * protected by the Mutex
941 */
942 static int chipio_write_multiple(struct hda_codec *codec,
943 u32 chip_addx,
944 const u32 *data,
945 unsigned int count)
946 {
947 struct ca0132_spec *spec = codec->spec;
948 int status;
949
950 mutex_lock(&spec->chipio_mutex);
951 status = chipio_write_address(codec, chip_addx);
952 if (status < 0)
953 goto error;
954
955 status = chipio_write_data_multiple(codec, data, count);
956 error:
957 mutex_unlock(&spec->chipio_mutex);
958
959 return status;
960 }
961
962 /*
963 * Read the given address through the chip I/O widget
964 * protected by the Mutex
965 */
966 static int chipio_read(struct hda_codec *codec,
967 unsigned int chip_addx, unsigned int *data)
968 {
969 struct ca0132_spec *spec = codec->spec;
970 int err;
971
972 mutex_lock(&spec->chipio_mutex);
973
974 /* write the address, and if successful proceed to write data */
975 err = chipio_write_address(codec, chip_addx);
976 if (err < 0)
977 goto exit;
978
979 err = chipio_read_data(codec, data);
980 if (err < 0)
981 goto exit;
982
983 exit:
984 mutex_unlock(&spec->chipio_mutex);
985 return err;
986 }
987
988 /*
989 * Set chip control flags through the chip I/O widget.
990 */
991 static void chipio_set_control_flag(struct hda_codec *codec,
992 enum control_flag_id flag_id,
993 bool flag_state)
994 {
995 unsigned int val;
996 unsigned int flag_bit;
997
998 flag_bit = (flag_state ? 1 : 0);
999 val = (flag_bit << 7) | (flag_id);
1000 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1001 VENDOR_CHIPIO_FLAG_SET, val);
1002 }
1003
1004 /*
1005 * Set chip parameters through the chip I/O widget.
1006 */
1007 static void chipio_set_control_param(struct hda_codec *codec,
1008 enum control_param_id param_id, int param_val)
1009 {
1010 struct ca0132_spec *spec = codec->spec;
1011 int val;
1012
1013 if ((param_id < 32) && (param_val < 8)) {
1014 val = (param_val << 5) | (param_id);
1015 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1016 VENDOR_CHIPIO_PARAM_SET, val);
1017 } else {
1018 mutex_lock(&spec->chipio_mutex);
1019 if (chipio_send(codec, VENDOR_CHIPIO_STATUS, 0) == 0) {
1020 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1021 VENDOR_CHIPIO_PARAM_EX_ID_SET,
1022 param_id);
1023 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1024 VENDOR_CHIPIO_PARAM_EX_VALUE_SET,
1025 param_val);
1026 }
1027 mutex_unlock(&spec->chipio_mutex);
1028 }
1029 }
1030
1031 /*
1032 * Set sampling rate of the connection point.
1033 */
1034 static void chipio_set_conn_rate(struct hda_codec *codec,
1035 int connid, enum ca0132_sample_rate rate)
1036 {
1037 chipio_set_control_param(codec, CONTROL_PARAM_CONN_POINT_ID, connid);
1038 chipio_set_control_param(codec, CONTROL_PARAM_CONN_POINT_SAMPLE_RATE,
1039 rate);
1040 }
1041
1042 /*
1043 * Enable clocks.
1044 */
1045 static void chipio_enable_clocks(struct hda_codec *codec)
1046 {
1047 struct ca0132_spec *spec = codec->spec;
1048
1049 mutex_lock(&spec->chipio_mutex);
1050 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1051 VENDOR_CHIPIO_8051_ADDRESS_LOW, 0);
1052 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1053 VENDOR_CHIPIO_PLL_PMU_WRITE, 0xff);
1054 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1055 VENDOR_CHIPIO_8051_ADDRESS_LOW, 5);
1056 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1057 VENDOR_CHIPIO_PLL_PMU_WRITE, 0x0b);
1058 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1059 VENDOR_CHIPIO_8051_ADDRESS_LOW, 6);
1060 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1061 VENDOR_CHIPIO_PLL_PMU_WRITE, 0xff);
1062 mutex_unlock(&spec->chipio_mutex);
1063 }
1064
1065 /*
1066 * CA0132 DSP IO stuffs
1067 */
1068 static int dspio_send(struct hda_codec *codec, unsigned int reg,
1069 unsigned int data)
1070 {
1071 int res;
1072 unsigned long timeout = jiffies + msecs_to_jiffies(1000);
1073
1074 /* send bits of data specified by reg to dsp */
1075 do {
1076 res = snd_hda_codec_read(codec, WIDGET_DSP_CTRL, 0, reg, data);
1077 if ((res >= 0) && (res != VENDOR_STATUS_DSPIO_BUSY))
1078 return res;
1079 msleep(20);
1080 } while (time_before(jiffies, timeout));
1081
1082 return -EIO;
1083 }
1084
1085 /*
1086 * Wait for DSP to be ready for commands
1087 */
1088 static void dspio_write_wait(struct hda_codec *codec)
1089 {
1090 int status;
1091 unsigned long timeout = jiffies + msecs_to_jiffies(1000);
1092
1093 do {
1094 status = snd_hda_codec_read(codec, WIDGET_DSP_CTRL, 0,
1095 VENDOR_DSPIO_STATUS, 0);
1096 if ((status == VENDOR_STATUS_DSPIO_OK) ||
1097 (status == VENDOR_STATUS_DSPIO_SCP_RESPONSE_QUEUE_EMPTY))
1098 break;
1099 msleep(1);
1100 } while (time_before(jiffies, timeout));
1101 }
1102
1103 /*
1104 * Write SCP data to DSP
1105 */
1106 static int dspio_write(struct hda_codec *codec, unsigned int scp_data)
1107 {
1108 struct ca0132_spec *spec = codec->spec;
1109 int status;
1110
1111 dspio_write_wait(codec);
1112
1113 mutex_lock(&spec->chipio_mutex);
1114 status = dspio_send(codec, VENDOR_DSPIO_SCP_WRITE_DATA_LOW,
1115 scp_data & 0xffff);
1116 if (status < 0)
1117 goto error;
1118
1119 status = dspio_send(codec, VENDOR_DSPIO_SCP_WRITE_DATA_HIGH,
1120 scp_data >> 16);
1121 if (status < 0)
1122 goto error;
1123
1124 /* OK, now check if the write itself has executed*/
1125 status = snd_hda_codec_read(codec, WIDGET_DSP_CTRL, 0,
1126 VENDOR_DSPIO_STATUS, 0);
1127 error:
1128 mutex_unlock(&spec->chipio_mutex);
1129
1130 return (status == VENDOR_STATUS_DSPIO_SCP_COMMAND_QUEUE_FULL) ?
1131 -EIO : 0;
1132 }
1133
1134 /*
1135 * Write multiple SCP data to DSP
1136 */
1137 static int dspio_write_multiple(struct hda_codec *codec,
1138 unsigned int *buffer, unsigned int size)
1139 {
1140 int status = 0;
1141 unsigned int count;
1142
1143 if ((buffer == NULL))
1144 return -EINVAL;
1145
1146 count = 0;
1147 while (count < size) {
1148 status = dspio_write(codec, *buffer++);
1149 if (status != 0)
1150 break;
1151 count++;
1152 }
1153
1154 return status;
1155 }
1156
1157 static int dspio_read(struct hda_codec *codec, unsigned int *data)
1158 {
1159 int status;
1160
1161 status = dspio_send(codec, VENDOR_DSPIO_SCP_POST_READ_DATA, 0);
1162 if (status == -EIO)
1163 return status;
1164
1165 status = dspio_send(codec, VENDOR_DSPIO_STATUS, 0);
1166 if (status == -EIO ||
1167 status == VENDOR_STATUS_DSPIO_SCP_RESPONSE_QUEUE_EMPTY)
1168 return -EIO;
1169
1170 *data = snd_hda_codec_read(codec, WIDGET_DSP_CTRL, 0,
1171 VENDOR_DSPIO_SCP_READ_DATA, 0);
1172
1173 return 0;
1174 }
1175
1176 static int dspio_read_multiple(struct hda_codec *codec, unsigned int *buffer,
1177 unsigned int *buf_size, unsigned int size_count)
1178 {
1179 int status = 0;
1180 unsigned int size = *buf_size;
1181 unsigned int count;
1182 unsigned int skip_count;
1183 unsigned int dummy;
1184
1185 if ((buffer == NULL))
1186 return -1;
1187
1188 count = 0;
1189 while (count < size && count < size_count) {
1190 status = dspio_read(codec, buffer++);
1191 if (status != 0)
1192 break;
1193 count++;
1194 }
1195
1196 skip_count = count;
1197 if (status == 0) {
1198 while (skip_count < size) {
1199 status = dspio_read(codec, &dummy);
1200 if (status != 0)
1201 break;
1202 skip_count++;
1203 }
1204 }
1205 *buf_size = count;
1206
1207 return status;
1208 }
1209
1210 /*
1211 * Construct the SCP header using corresponding fields
1212 */
1213 static inline unsigned int
1214 make_scp_header(unsigned int target_id, unsigned int source_id,
1215 unsigned int get_flag, unsigned int req,
1216 unsigned int device_flag, unsigned int resp_flag,
1217 unsigned int error_flag, unsigned int data_size)
1218 {
1219 unsigned int header = 0;
1220
1221 header = (data_size & 0x1f) << 27;
1222 header |= (error_flag & 0x01) << 26;
1223 header |= (resp_flag & 0x01) << 25;
1224 header |= (device_flag & 0x01) << 24;
1225 header |= (req & 0x7f) << 17;
1226 header |= (get_flag & 0x01) << 16;
1227 header |= (source_id & 0xff) << 8;
1228 header |= target_id & 0xff;
1229
1230 return header;
1231 }
1232
1233 /*
1234 * Extract corresponding fields from SCP header
1235 */
1236 static inline void
1237 extract_scp_header(unsigned int header,
1238 unsigned int *target_id, unsigned int *source_id,
1239 unsigned int *get_flag, unsigned int *req,
1240 unsigned int *device_flag, unsigned int *resp_flag,
1241 unsigned int *error_flag, unsigned int *data_size)
1242 {
1243 if (data_size)
1244 *data_size = (header >> 27) & 0x1f;
1245 if (error_flag)
1246 *error_flag = (header >> 26) & 0x01;
1247 if (resp_flag)
1248 *resp_flag = (header >> 25) & 0x01;
1249 if (device_flag)
1250 *device_flag = (header >> 24) & 0x01;
1251 if (req)
1252 *req = (header >> 17) & 0x7f;
1253 if (get_flag)
1254 *get_flag = (header >> 16) & 0x01;
1255 if (source_id)
1256 *source_id = (header >> 8) & 0xff;
1257 if (target_id)
1258 *target_id = header & 0xff;
1259 }
1260
1261 #define SCP_MAX_DATA_WORDS (16)
1262
1263 /* Structure to contain any SCP message */
1264 struct scp_msg {
1265 unsigned int hdr;
1266 unsigned int data[SCP_MAX_DATA_WORDS];
1267 };
1268
1269 static void dspio_clear_response_queue(struct hda_codec *codec)
1270 {
1271 unsigned int dummy = 0;
1272 int status = -1;
1273
1274 /* clear all from the response queue */
1275 do {
1276 status = dspio_read(codec, &dummy);
1277 } while (status == 0);
1278 }
1279
1280 static int dspio_get_response_data(struct hda_codec *codec)
1281 {
1282 struct ca0132_spec *spec = codec->spec;
1283 unsigned int data = 0;
1284 unsigned int count;
1285
1286 if (dspio_read(codec, &data) < 0)
1287 return -EIO;
1288
1289 if ((data & 0x00ffffff) == spec->wait_scp_header) {
1290 spec->scp_resp_header = data;
1291 spec->scp_resp_count = data >> 27;
1292 count = spec->wait_num_data;
1293 dspio_read_multiple(codec, spec->scp_resp_data,
1294 &spec->scp_resp_count, count);
1295 return 0;
1296 }
1297
1298 return -EIO;
1299 }
1300
1301 /*
1302 * Send SCP message to DSP
1303 */
1304 static int dspio_send_scp_message(struct hda_codec *codec,
1305 unsigned char *send_buf,
1306 unsigned int send_buf_size,
1307 unsigned char *return_buf,
1308 unsigned int return_buf_size,
1309 unsigned int *bytes_returned)
1310 {
1311 struct ca0132_spec *spec = codec->spec;
1312 int status = -1;
1313 unsigned int scp_send_size = 0;
1314 unsigned int total_size;
1315 bool waiting_for_resp = false;
1316 unsigned int header;
1317 struct scp_msg *ret_msg;
1318 unsigned int resp_src_id, resp_target_id;
1319 unsigned int data_size, src_id, target_id, get_flag, device_flag;
1320
1321 if (bytes_returned)
1322 *bytes_returned = 0;
1323
1324 /* get scp header from buffer */
1325 header = *((unsigned int *)send_buf);
1326 extract_scp_header(header, &target_id, &src_id, &get_flag, NULL,
1327 &device_flag, NULL, NULL, &data_size);
1328 scp_send_size = data_size + 1;
1329 total_size = (scp_send_size * 4);
1330
1331 if (send_buf_size < total_size)
1332 return -EINVAL;
1333
1334 if (get_flag || device_flag) {
1335 if (!return_buf || return_buf_size < 4 || !bytes_returned)
1336 return -EINVAL;
1337
1338 spec->wait_scp_header = *((unsigned int *)send_buf);
1339
1340 /* swap source id with target id */
1341 resp_target_id = src_id;
1342 resp_src_id = target_id;
1343 spec->wait_scp_header &= 0xffff0000;
1344 spec->wait_scp_header |= (resp_src_id << 8) | (resp_target_id);
1345 spec->wait_num_data = return_buf_size/sizeof(unsigned int) - 1;
1346 spec->wait_scp = 1;
1347 waiting_for_resp = true;
1348 }
1349
1350 status = dspio_write_multiple(codec, (unsigned int *)send_buf,
1351 scp_send_size);
1352 if (status < 0) {
1353 spec->wait_scp = 0;
1354 return status;
1355 }
1356
1357 if (waiting_for_resp) {
1358 unsigned long timeout = jiffies + msecs_to_jiffies(1000);
1359 memset(return_buf, 0, return_buf_size);
1360 do {
1361 msleep(20);
1362 } while (spec->wait_scp && time_before(jiffies, timeout));
1363 waiting_for_resp = false;
1364 if (!spec->wait_scp) {
1365 ret_msg = (struct scp_msg *)return_buf;
1366 memcpy(&ret_msg->hdr, &spec->scp_resp_header, 4);
1367 memcpy(&ret_msg->data, spec->scp_resp_data,
1368 spec->wait_num_data);
1369 *bytes_returned = (spec->scp_resp_count + 1) * 4;
1370 status = 0;
1371 } else {
1372 status = -EIO;
1373 }
1374 spec->wait_scp = 0;
1375 }
1376
1377 return status;
1378 }
1379
1380 /**
1381 * Prepare and send the SCP message to DSP
1382 * @codec: the HDA codec
1383 * @mod_id: ID of the DSP module to send the command
1384 * @req: ID of request to send to the DSP module
1385 * @dir: SET or GET
1386 * @data: pointer to the data to send with the request, request specific
1387 * @len: length of the data, in bytes
1388 * @reply: point to the buffer to hold data returned for a reply
1389 * @reply_len: length of the reply buffer returned from GET
1390 *
1391 * Returns zero or a negative error code.
1392 */
1393 static int dspio_scp(struct hda_codec *codec,
1394 int mod_id, int req, int dir, void *data, unsigned int len,
1395 void *reply, unsigned int *reply_len)
1396 {
1397 int status = 0;
1398 struct scp_msg scp_send, scp_reply;
1399 unsigned int ret_bytes, send_size, ret_size;
1400 unsigned int send_get_flag, reply_resp_flag, reply_error_flag;
1401 unsigned int reply_data_size;
1402
1403 memset(&scp_send, 0, sizeof(scp_send));
1404 memset(&scp_reply, 0, sizeof(scp_reply));
1405
1406 if ((len != 0 && data == NULL) || (len > SCP_MAX_DATA_WORDS))
1407 return -EINVAL;
1408
1409 if (dir == SCP_GET && reply == NULL) {
1410 snd_printdd(KERN_ERR "dspio_scp get but has no buffer\n");
1411 return -EINVAL;
1412 }
1413
1414 if (reply != NULL && (reply_len == NULL || (*reply_len == 0))) {
1415 snd_printdd(KERN_ERR "dspio_scp bad resp buf len parms\n");
1416 return -EINVAL;
1417 }
1418
1419 scp_send.hdr = make_scp_header(mod_id, 0x20, (dir == SCP_GET), req,
1420 0, 0, 0, len/sizeof(unsigned int));
1421 if (data != NULL && len > 0) {
1422 len = min((unsigned int)(sizeof(scp_send.data)), len);
1423 memcpy(scp_send.data, data, len);
1424 }
1425
1426 ret_bytes = 0;
1427 send_size = sizeof(unsigned int) + len;
1428 status = dspio_send_scp_message(codec, (unsigned char *)&scp_send,
1429 send_size, (unsigned char *)&scp_reply,
1430 sizeof(scp_reply), &ret_bytes);
1431
1432 if (status < 0) {
1433 snd_printdd(KERN_ERR "dspio_scp: send scp msg failed\n");
1434 return status;
1435 }
1436
1437 /* extract send and reply headers members */
1438 extract_scp_header(scp_send.hdr, NULL, NULL, &send_get_flag,
1439 NULL, NULL, NULL, NULL, NULL);
1440 extract_scp_header(scp_reply.hdr, NULL, NULL, NULL, NULL, NULL,
1441 &reply_resp_flag, &reply_error_flag,
1442 &reply_data_size);
1443
1444 if (!send_get_flag)
1445 return 0;
1446
1447 if (reply_resp_flag && !reply_error_flag) {
1448 ret_size = (ret_bytes - sizeof(scp_reply.hdr))
1449 / sizeof(unsigned int);
1450
1451 if (*reply_len < ret_size*sizeof(unsigned int)) {
1452 snd_printdd(KERN_ERR "reply too long for buf\n");
1453 return -EINVAL;
1454 } else if (ret_size != reply_data_size) {
1455 snd_printdd(KERN_ERR "RetLen and HdrLen .NE.\n");
1456 return -EINVAL;
1457 } else {
1458 *reply_len = ret_size*sizeof(unsigned int);
1459 memcpy(reply, scp_reply.data, *reply_len);
1460 }
1461 } else {
1462 snd_printdd(KERN_ERR "reply ill-formed or errflag set\n");
1463 return -EIO;
1464 }
1465
1466 return status;
1467 }
1468
1469 /*
1470 * Set DSP parameters
1471 */
1472 static int dspio_set_param(struct hda_codec *codec, int mod_id,
1473 int req, void *data, unsigned int len)
1474 {
1475 return dspio_scp(codec, mod_id, req, SCP_SET, data, len, NULL, NULL);
1476 }
1477
1478 static int dspio_set_uint_param(struct hda_codec *codec, int mod_id,
1479 int req, unsigned int data)
1480 {
1481 return dspio_set_param(codec, mod_id, req, &data, sizeof(unsigned int));
1482 }
1483
1484 /*
1485 * Allocate a DSP DMA channel via an SCP message
1486 */
1487 static int dspio_alloc_dma_chan(struct hda_codec *codec, unsigned int *dma_chan)
1488 {
1489 int status = 0;
1490 unsigned int size = sizeof(dma_chan);
1491
1492 snd_printdd(KERN_INFO " dspio_alloc_dma_chan() -- begin\n");
1493 status = dspio_scp(codec, MASTERCONTROL, MASTERCONTROL_ALLOC_DMA_CHAN,
1494 SCP_GET, NULL, 0, dma_chan, &size);
1495
1496 if (status < 0) {
1497 snd_printdd(KERN_INFO "dspio_alloc_dma_chan: SCP Failed\n");
1498 return status;
1499 }
1500
1501 if ((*dma_chan + 1) == 0) {
1502 snd_printdd(KERN_INFO "no free dma channels to allocate\n");
1503 return -EBUSY;
1504 }
1505
1506 snd_printdd("dspio_alloc_dma_chan: chan=%d\n", *dma_chan);
1507 snd_printdd(KERN_INFO " dspio_alloc_dma_chan() -- complete\n");
1508
1509 return status;
1510 }
1511
1512 /*
1513 * Free a DSP DMA via an SCP message
1514 */
1515 static int dspio_free_dma_chan(struct hda_codec *codec, unsigned int dma_chan)
1516 {
1517 int status = 0;
1518 unsigned int dummy = 0;
1519
1520 snd_printdd(KERN_INFO " dspio_free_dma_chan() -- begin\n");
1521 snd_printdd("dspio_free_dma_chan: chan=%d\n", dma_chan);
1522
1523 status = dspio_scp(codec, MASTERCONTROL, MASTERCONTROL_ALLOC_DMA_CHAN,
1524 SCP_SET, &dma_chan, sizeof(dma_chan), NULL, &dummy);
1525
1526 if (status < 0) {
1527 snd_printdd(KERN_INFO "dspio_free_dma_chan: SCP Failed\n");
1528 return status;
1529 }
1530
1531 snd_printdd(KERN_INFO " dspio_free_dma_chan() -- complete\n");
1532
1533 return status;
1534 }
1535
1536 /*
1537 * (Re)start the DSP
1538 */
1539 static int dsp_set_run_state(struct hda_codec *codec)
1540 {
1541 unsigned int dbg_ctrl_reg;
1542 unsigned int halt_state;
1543 int err;
1544
1545 err = chipio_read(codec, DSP_DBGCNTL_INST_OFFSET, &dbg_ctrl_reg);
1546 if (err < 0)
1547 return err;
1548
1549 halt_state = (dbg_ctrl_reg & DSP_DBGCNTL_STATE_MASK) >>
1550 DSP_DBGCNTL_STATE_LOBIT;
1551
1552 if (halt_state != 0) {
1553 dbg_ctrl_reg &= ~((halt_state << DSP_DBGCNTL_SS_LOBIT) &
1554 DSP_DBGCNTL_SS_MASK);
1555 err = chipio_write(codec, DSP_DBGCNTL_INST_OFFSET,
1556 dbg_ctrl_reg);
1557 if (err < 0)
1558 return err;
1559
1560 dbg_ctrl_reg |= (halt_state << DSP_DBGCNTL_EXEC_LOBIT) &
1561 DSP_DBGCNTL_EXEC_MASK;
1562 err = chipio_write(codec, DSP_DBGCNTL_INST_OFFSET,
1563 dbg_ctrl_reg);
1564 if (err < 0)
1565 return err;
1566 }
1567
1568 return 0;
1569 }
1570
1571 /*
1572 * Reset the DSP
1573 */
1574 static int dsp_reset(struct hda_codec *codec)
1575 {
1576 unsigned int res;
1577 int retry = 20;
1578
1579 snd_printdd("dsp_reset\n");
1580 do {
1581 res = dspio_send(codec, VENDOR_DSPIO_DSP_INIT, 0);
1582 retry--;
1583 } while (res == -EIO && retry);
1584
1585 if (!retry) {
1586 snd_printdd("dsp_reset timeout\n");
1587 return -EIO;
1588 }
1589
1590 return 0;
1591 }
1592
1593 /*
1594 * Convert chip address to DSP address
1595 */
1596 static unsigned int dsp_chip_to_dsp_addx(unsigned int chip_addx,
1597 bool *code, bool *yram)
1598 {
1599 *code = *yram = false;
1600
1601 if (UC_RANGE(chip_addx, 1)) {
1602 *code = true;
1603 return UC_OFF(chip_addx);
1604 } else if (X_RANGE_ALL(chip_addx, 1)) {
1605 return X_OFF(chip_addx);
1606 } else if (Y_RANGE_ALL(chip_addx, 1)) {
1607 *yram = true;
1608 return Y_OFF(chip_addx);
1609 }
1610
1611 return INVALID_CHIP_ADDRESS;
1612 }
1613
1614 /*
1615 * Check if the DSP DMA is active
1616 */
1617 static bool dsp_is_dma_active(struct hda_codec *codec, unsigned int dma_chan)
1618 {
1619 unsigned int dma_chnlstart_reg;
1620
1621 chipio_read(codec, DSPDMAC_CHNLSTART_INST_OFFSET, &dma_chnlstart_reg);
1622
1623 return ((dma_chnlstart_reg & (1 <<
1624 (DSPDMAC_CHNLSTART_EN_LOBIT + dma_chan))) != 0);
1625 }
1626
1627 static int dsp_dma_setup_common(struct hda_codec *codec,
1628 unsigned int chip_addx,
1629 unsigned int dma_chan,
1630 unsigned int port_map_mask,
1631 bool ovly)
1632 {
1633 int status = 0;
1634 unsigned int chnl_prop;
1635 unsigned int dsp_addx;
1636 unsigned int active;
1637 bool code, yram;
1638
1639 snd_printdd(KERN_INFO "-- dsp_dma_setup_common() -- Begin ---------\n");
1640
1641 if (dma_chan >= DSPDMAC_DMA_CFG_CHANNEL_COUNT) {
1642 snd_printdd(KERN_ERR "dma chan num invalid\n");
1643 return -EINVAL;
1644 }
1645
1646 if (dsp_is_dma_active(codec, dma_chan)) {
1647 snd_printdd(KERN_ERR "dma already active\n");
1648 return -EBUSY;
1649 }
1650
1651 dsp_addx = dsp_chip_to_dsp_addx(chip_addx, &code, &yram);
1652
1653 if (dsp_addx == INVALID_CHIP_ADDRESS) {
1654 snd_printdd(KERN_ERR "invalid chip addr\n");
1655 return -ENXIO;
1656 }
1657
1658 chnl_prop = DSPDMAC_CHNLPROP_AC_MASK;
1659 active = 0;
1660
1661 snd_printdd(KERN_INFO " dsp_dma_setup_common() start reg pgm\n");
1662
1663 if (ovly) {
1664 status = chipio_read(codec, DSPDMAC_CHNLPROP_INST_OFFSET,
1665 &chnl_prop);
1666
1667 if (status < 0) {
1668 snd_printdd(KERN_ERR "read CHNLPROP Reg fail\n");
1669 return status;
1670 }
1671 snd_printdd(KERN_INFO "dsp_dma_setup_common() Read CHNLPROP\n");
1672 }
1673
1674 if (!code)
1675 chnl_prop &= ~(1 << (DSPDMAC_CHNLPROP_MSPCE_LOBIT + dma_chan));
1676 else
1677 chnl_prop |= (1 << (DSPDMAC_CHNLPROP_MSPCE_LOBIT + dma_chan));
1678
1679 chnl_prop &= ~(1 << (DSPDMAC_CHNLPROP_DCON_LOBIT + dma_chan));
1680
1681 status = chipio_write(codec, DSPDMAC_CHNLPROP_INST_OFFSET, chnl_prop);
1682 if (status < 0) {
1683 snd_printdd(KERN_ERR "write CHNLPROP Reg fail\n");
1684 return status;
1685 }
1686 snd_printdd(KERN_INFO " dsp_dma_setup_common() Write CHNLPROP\n");
1687
1688 if (ovly) {
1689 status = chipio_read(codec, DSPDMAC_ACTIVE_INST_OFFSET,
1690 &active);
1691
1692 if (status < 0) {
1693 snd_printdd(KERN_ERR "read ACTIVE Reg fail\n");
1694 return status;
1695 }
1696 snd_printdd(KERN_INFO "dsp_dma_setup_common() Read ACTIVE\n");
1697 }
1698
1699 active &= (~(1 << (DSPDMAC_ACTIVE_AAR_LOBIT + dma_chan))) &
1700 DSPDMAC_ACTIVE_AAR_MASK;
1701
1702 status = chipio_write(codec, DSPDMAC_ACTIVE_INST_OFFSET, active);
1703 if (status < 0) {
1704 snd_printdd(KERN_ERR "write ACTIVE Reg fail\n");
1705 return status;
1706 }
1707
1708 snd_printdd(KERN_INFO " dsp_dma_setup_common() Write ACTIVE\n");
1709
1710 status = chipio_write(codec, DSPDMAC_AUDCHSEL_INST_OFFSET(dma_chan),
1711 port_map_mask);
1712 if (status < 0) {
1713 snd_printdd(KERN_ERR "write AUDCHSEL Reg fail\n");
1714 return status;
1715 }
1716 snd_printdd(KERN_INFO " dsp_dma_setup_common() Write AUDCHSEL\n");
1717
1718 status = chipio_write(codec, DSPDMAC_IRQCNT_INST_OFFSET(dma_chan),
1719 DSPDMAC_IRQCNT_BICNT_MASK | DSPDMAC_IRQCNT_CICNT_MASK);
1720 if (status < 0) {
1721 snd_printdd(KERN_ERR "write IRQCNT Reg fail\n");
1722 return status;
1723 }
1724 snd_printdd(KERN_INFO " dsp_dma_setup_common() Write IRQCNT\n");
1725
1726 snd_printdd(
1727 "ChipA=0x%x,DspA=0x%x,dmaCh=%u, "
1728 "CHSEL=0x%x,CHPROP=0x%x,Active=0x%x\n",
1729 chip_addx, dsp_addx, dma_chan,
1730 port_map_mask, chnl_prop, active);
1731
1732 snd_printdd(KERN_INFO "-- dsp_dma_setup_common() -- Complete ------\n");
1733
1734 return 0;
1735 }
1736
1737 /*
1738 * Setup the DSP DMA per-transfer-specific registers
1739 */
1740 static int dsp_dma_setup(struct hda_codec *codec,
1741 unsigned int chip_addx,
1742 unsigned int count,
1743 unsigned int dma_chan)
1744 {
1745 int status = 0;
1746 bool code, yram;
1747 unsigned int dsp_addx;
1748 unsigned int addr_field;
1749 unsigned int incr_field;
1750 unsigned int base_cnt;
1751 unsigned int cur_cnt;
1752 unsigned int dma_cfg = 0;
1753 unsigned int adr_ofs = 0;
1754 unsigned int xfr_cnt = 0;
1755 const unsigned int max_dma_count = 1 << (DSPDMAC_XFRCNT_BCNT_HIBIT -
1756 DSPDMAC_XFRCNT_BCNT_LOBIT + 1);
1757
1758 snd_printdd(KERN_INFO "-- dsp_dma_setup() -- Begin ---------\n");
1759
1760 if (count > max_dma_count) {
1761 snd_printdd(KERN_ERR "count too big\n");
1762 return -EINVAL;
1763 }
1764
1765 dsp_addx = dsp_chip_to_dsp_addx(chip_addx, &code, &yram);
1766 if (dsp_addx == INVALID_CHIP_ADDRESS) {
1767 snd_printdd(KERN_ERR "invalid chip addr\n");
1768 return -ENXIO;
1769 }
1770
1771 snd_printdd(KERN_INFO " dsp_dma_setup() start reg pgm\n");
1772
1773 addr_field = dsp_addx << DSPDMAC_DMACFG_DBADR_LOBIT;
1774 incr_field = 0;
1775
1776 if (!code) {
1777 addr_field <<= 1;
1778 if (yram)
1779 addr_field |= (1 << DSPDMAC_DMACFG_DBADR_LOBIT);
1780
1781 incr_field = (1 << DSPDMAC_DMACFG_AINCR_LOBIT);
1782 }
1783
1784 dma_cfg = addr_field + incr_field;
1785 status = chipio_write(codec, DSPDMAC_DMACFG_INST_OFFSET(dma_chan),
1786 dma_cfg);
1787 if (status < 0) {
1788 snd_printdd(KERN_ERR "write DMACFG Reg fail\n");
1789 return status;
1790 }
1791 snd_printdd(KERN_INFO " dsp_dma_setup() Write DMACFG\n");
1792
1793 adr_ofs = (count - 1) << (DSPDMAC_DSPADROFS_BOFS_LOBIT +
1794 (code ? 0 : 1));
1795
1796 status = chipio_write(codec, DSPDMAC_DSPADROFS_INST_OFFSET(dma_chan),
1797 adr_ofs);
1798 if (status < 0) {
1799 snd_printdd(KERN_ERR "write DSPADROFS Reg fail\n");
1800 return status;
1801 }
1802 snd_printdd(KERN_INFO " dsp_dma_setup() Write DSPADROFS\n");
1803
1804 base_cnt = (count - 1) << DSPDMAC_XFRCNT_BCNT_LOBIT;
1805
1806 cur_cnt = (count - 1) << DSPDMAC_XFRCNT_CCNT_LOBIT;
1807
1808 xfr_cnt = base_cnt | cur_cnt;
1809
1810 status = chipio_write(codec,
1811 DSPDMAC_XFRCNT_INST_OFFSET(dma_chan), xfr_cnt);
1812 if (status < 0) {
1813 snd_printdd(KERN_ERR "write XFRCNT Reg fail\n");
1814 return status;
1815 }
1816 snd_printdd(KERN_INFO " dsp_dma_setup() Write XFRCNT\n");
1817
1818 snd_printdd(
1819 "ChipA=0x%x, cnt=0x%x, DMACFG=0x%x, "
1820 "ADROFS=0x%x, XFRCNT=0x%x\n",
1821 chip_addx, count, dma_cfg, adr_ofs, xfr_cnt);
1822
1823 snd_printdd(KERN_INFO "-- dsp_dma_setup() -- Complete ---------\n");
1824
1825 return 0;
1826 }
1827
1828 /*
1829 * Start the DSP DMA
1830 */
1831 static int dsp_dma_start(struct hda_codec *codec,
1832 unsigned int dma_chan, bool ovly)
1833 {
1834 unsigned int reg = 0;
1835 int status = 0;
1836
1837 snd_printdd(KERN_INFO "-- dsp_dma_start() -- Begin ---------\n");
1838
1839 if (ovly) {
1840 status = chipio_read(codec,
1841 DSPDMAC_CHNLSTART_INST_OFFSET, &reg);
1842
1843 if (status < 0) {
1844 snd_printdd(KERN_ERR "read CHNLSTART reg fail\n");
1845 return status;
1846 }
1847 snd_printdd(KERN_INFO "-- dsp_dma_start() Read CHNLSTART\n");
1848
1849 reg &= ~(DSPDMAC_CHNLSTART_EN_MASK |
1850 DSPDMAC_CHNLSTART_DIS_MASK);
1851 }
1852
1853 status = chipio_write(codec, DSPDMAC_CHNLSTART_INST_OFFSET,
1854 reg | (1 << (dma_chan + DSPDMAC_CHNLSTART_EN_LOBIT)));
1855 if (status < 0) {
1856 snd_printdd(KERN_ERR "write CHNLSTART reg fail\n");
1857 return status;
1858 }
1859 snd_printdd(KERN_INFO "-- dsp_dma_start() -- Complete ---------\n");
1860
1861 return status;
1862 }
1863
1864 /*
1865 * Stop the DSP DMA
1866 */
1867 static int dsp_dma_stop(struct hda_codec *codec,
1868 unsigned int dma_chan, bool ovly)
1869 {
1870 unsigned int reg = 0;
1871 int status = 0;
1872
1873 snd_printdd(KERN_INFO "-- dsp_dma_stop() -- Begin ---------\n");
1874
1875 if (ovly) {
1876 status = chipio_read(codec,
1877 DSPDMAC_CHNLSTART_INST_OFFSET, &reg);
1878
1879 if (status < 0) {
1880 snd_printdd(KERN_ERR "read CHNLSTART reg fail\n");
1881 return status;
1882 }
1883 snd_printdd(KERN_INFO "-- dsp_dma_stop() Read CHNLSTART\n");
1884 reg &= ~(DSPDMAC_CHNLSTART_EN_MASK |
1885 DSPDMAC_CHNLSTART_DIS_MASK);
1886 }
1887
1888 status = chipio_write(codec, DSPDMAC_CHNLSTART_INST_OFFSET,
1889 reg | (1 << (dma_chan + DSPDMAC_CHNLSTART_DIS_LOBIT)));
1890 if (status < 0) {
1891 snd_printdd(KERN_ERR "write CHNLSTART reg fail\n");
1892 return status;
1893 }
1894 snd_printdd(KERN_INFO "-- dsp_dma_stop() -- Complete ---------\n");
1895
1896 return status;
1897 }
1898
1899 /**
1900 * Allocate router ports
1901 *
1902 * @codec: the HDA codec
1903 * @num_chans: number of channels in the stream
1904 * @ports_per_channel: number of ports per channel
1905 * @start_device: start device
1906 * @port_map: pointer to the port list to hold the allocated ports
1907 *
1908 * Returns zero or a negative error code.
1909 */
1910 static int dsp_allocate_router_ports(struct hda_codec *codec,
1911 unsigned int num_chans,
1912 unsigned int ports_per_channel,
1913 unsigned int start_device,
1914 unsigned int *port_map)
1915 {
1916 int status = 0;
1917 int res;
1918 u8 val;
1919
1920 status = chipio_send(codec, VENDOR_CHIPIO_STATUS, 0);
1921 if (status < 0)
1922 return status;
1923
1924 val = start_device << 6;
1925 val |= (ports_per_channel - 1) << 4;
1926 val |= num_chans - 1;
1927
1928 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1929 VENDOR_CHIPIO_PORT_ALLOC_CONFIG_SET,
1930 val);
1931
1932 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1933 VENDOR_CHIPIO_PORT_ALLOC_SET,
1934 MEM_CONNID_DSP);
1935
1936 status = chipio_send(codec, VENDOR_CHIPIO_STATUS, 0);
1937 if (status < 0)
1938 return status;
1939
1940 res = snd_hda_codec_read(codec, WIDGET_CHIP_CTRL, 0,
1941 VENDOR_CHIPIO_PORT_ALLOC_GET, 0);
1942
1943 *port_map = res;
1944
1945 return (res < 0) ? res : 0;
1946 }
1947
1948 /*
1949 * Free router ports
1950 */
1951 static int dsp_free_router_ports(struct hda_codec *codec)
1952 {
1953 int status = 0;
1954
1955 status = chipio_send(codec, VENDOR_CHIPIO_STATUS, 0);
1956 if (status < 0)
1957 return status;
1958
1959 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1960 VENDOR_CHIPIO_PORT_FREE_SET,
1961 MEM_CONNID_DSP);
1962
1963 status = chipio_send(codec, VENDOR_CHIPIO_STATUS, 0);
1964
1965 return status;
1966 }
1967
1968 /*
1969 * Allocate DSP ports for the download stream
1970 */
1971 static int dsp_allocate_ports(struct hda_codec *codec,
1972 unsigned int num_chans,
1973 unsigned int rate_multi, unsigned int *port_map)
1974 {
1975 int status;
1976
1977 snd_printdd(KERN_INFO " dsp_allocate_ports() -- begin\n");
1978
1979 if ((rate_multi != 1) && (rate_multi != 2) && (rate_multi != 4)) {
1980 snd_printdd(KERN_ERR "bad rate multiple\n");
1981 return -EINVAL;
1982 }
1983
1984 status = dsp_allocate_router_ports(codec, num_chans,
1985 rate_multi, 0, port_map);
1986
1987 snd_printdd(KERN_INFO " dsp_allocate_ports() -- complete\n");
1988
1989 return status;
1990 }
1991
1992 static int dsp_allocate_ports_format(struct hda_codec *codec,
1993 const unsigned short fmt,
1994 unsigned int *port_map)
1995 {
1996 int status;
1997 unsigned int num_chans;
1998
1999 unsigned int sample_rate_div = ((get_hdafmt_rate(fmt) >> 0) & 3) + 1;
2000 unsigned int sample_rate_mul = ((get_hdafmt_rate(fmt) >> 3) & 3) + 1;
2001 unsigned int rate_multi = sample_rate_mul / sample_rate_div;
2002
2003 if ((rate_multi != 1) && (rate_multi != 2) && (rate_multi != 4)) {
2004 snd_printdd(KERN_ERR "bad rate multiple\n");
2005 return -EINVAL;
2006 }
2007
2008 num_chans = get_hdafmt_chs(fmt) + 1;
2009
2010 status = dsp_allocate_ports(codec, num_chans, rate_multi, port_map);
2011
2012 return status;
2013 }
2014
2015 /*
2016 * free DSP ports
2017 */
2018 static int dsp_free_ports(struct hda_codec *codec)
2019 {
2020 int status;
2021
2022 snd_printdd(KERN_INFO " dsp_free_ports() -- begin\n");
2023
2024 status = dsp_free_router_ports(codec);
2025 if (status < 0) {
2026 snd_printdd(KERN_ERR "free router ports fail\n");
2027 return status;
2028 }
2029 snd_printdd(KERN_INFO " dsp_free_ports() -- complete\n");
2030
2031 return status;
2032 }
2033
2034 /*
2035 * HDA DMA engine stuffs for DSP code download
2036 */
2037 struct dma_engine {
2038 struct hda_codec *codec;
2039 unsigned short m_converter_format;
2040 struct snd_dma_buffer *dmab;
2041 unsigned int buf_size;
2042 };
2043
2044
2045 enum dma_state {
2046 DMA_STATE_STOP = 0,
2047 DMA_STATE_RUN = 1
2048 };
2049
2050 static int dma_convert_to_hda_format(
2051 unsigned int sample_rate,
2052 unsigned short channels,
2053 unsigned short *hda_format)
2054 {
2055 unsigned int format_val;
2056
2057 format_val = snd_hda_calc_stream_format(
2058 sample_rate,
2059 channels,
2060 SNDRV_PCM_FORMAT_S32_LE,
2061 32, 0);
2062
2063 if (hda_format)
2064 *hda_format = (unsigned short)format_val;
2065
2066 return 0;
2067 }
2068
2069 /*
2070 * Reset DMA for DSP download
2071 */
2072 static int dma_reset(struct dma_engine *dma)
2073 {
2074 struct hda_codec *codec = dma->codec;
2075 struct ca0132_spec *spec = codec->spec;
2076 int status;
2077
2078 if (dma->dmab->area)
2079 snd_hda_codec_load_dsp_cleanup(codec, dma->dmab);
2080
2081 status = snd_hda_codec_load_dsp_prepare(codec,
2082 dma->m_converter_format,
2083 dma->buf_size,
2084 dma->dmab);
2085 if (status < 0)
2086 return status;
2087 spec->dsp_stream_id = status;
2088 return 0;
2089 }
2090
2091 static int dma_set_state(struct dma_engine *dma, enum dma_state state)
2092 {
2093 bool cmd;
2094
2095 snd_printdd("dma_set_state state=%d\n", state);
2096
2097 switch (state) {
2098 case DMA_STATE_STOP:
2099 cmd = false;
2100 break;
2101 case DMA_STATE_RUN:
2102 cmd = true;
2103 break;
2104 default:
2105 return 0;
2106 }
2107
2108 snd_hda_codec_load_dsp_trigger(dma->codec, cmd);
2109 return 0;
2110 }
2111
2112 static unsigned int dma_get_buffer_size(struct dma_engine *dma)
2113 {
2114 return dma->dmab->bytes;
2115 }
2116
2117 static unsigned char *dma_get_buffer_addr(struct dma_engine *dma)
2118 {
2119 return dma->dmab->area;
2120 }
2121
2122 static int dma_xfer(struct dma_engine *dma,
2123 const unsigned int *data,
2124 unsigned int count)
2125 {
2126 memcpy(dma->dmab->area, data, count);
2127 return 0;
2128 }
2129
2130 static void dma_get_converter_format(
2131 struct dma_engine *dma,
2132 unsigned short *format)
2133 {
2134 if (format)
2135 *format = dma->m_converter_format;
2136 }
2137
2138 static unsigned int dma_get_stream_id(struct dma_engine *dma)
2139 {
2140 struct ca0132_spec *spec = dma->codec->spec;
2141
2142 return spec->dsp_stream_id;
2143 }
2144
2145 struct dsp_image_seg {
2146 u32 magic;
2147 u32 chip_addr;
2148 u32 count;
2149 u32 data[0];
2150 };
2151
2152 static const u32 g_magic_value = 0x4c46584d;
2153 static const u32 g_chip_addr_magic_value = 0xFFFFFF01;
2154
2155 static bool is_valid(const struct dsp_image_seg *p)
2156 {
2157 return p->magic == g_magic_value;
2158 }
2159
2160 static bool is_hci_prog_list_seg(const struct dsp_image_seg *p)
2161 {
2162 return g_chip_addr_magic_value == p->chip_addr;
2163 }
2164
2165 static bool is_last(const struct dsp_image_seg *p)
2166 {
2167 return p->count == 0;
2168 }
2169
2170 static size_t dsp_sizeof(const struct dsp_image_seg *p)
2171 {
2172 return sizeof(*p) + p->count*sizeof(u32);
2173 }
2174
2175 static const struct dsp_image_seg *get_next_seg_ptr(
2176 const struct dsp_image_seg *p)
2177 {
2178 return (struct dsp_image_seg *)((unsigned char *)(p) + dsp_sizeof(p));
2179 }
2180
2181 /*
2182 * CA0132 chip DSP transfer stuffs. For DSP download.
2183 */
2184 #define INVALID_DMA_CHANNEL (~0U)
2185
2186 /*
2187 * Program a list of address/data pairs via the ChipIO widget.
2188 * The segment data is in the format of successive pairs of words.
2189 * These are repeated as indicated by the segment's count field.
2190 */
2191 static int dspxfr_hci_write(struct hda_codec *codec,
2192 const struct dsp_image_seg *fls)
2193 {
2194 int status;
2195 const u32 *data;
2196 unsigned int count;
2197
2198 if (fls == NULL || fls->chip_addr != g_chip_addr_magic_value) {
2199 snd_printdd(KERN_ERR "hci_write invalid params\n");
2200 return -EINVAL;
2201 }
2202
2203 count = fls->count;
2204 data = (u32 *)(fls->data);
2205 while (count >= 2) {
2206 status = chipio_write(codec, data[0], data[1]);
2207 if (status < 0) {
2208 snd_printdd(KERN_ERR "hci_write chipio failed\n");
2209 return status;
2210 }
2211 count -= 2;
2212 data += 2;
2213 }
2214 return 0;
2215 }
2216
2217 /**
2218 * Write a block of data into DSP code or data RAM using pre-allocated
2219 * DMA engine.
2220 *
2221 * @codec: the HDA codec
2222 * @fls: pointer to a fast load image
2223 * @reloc: Relocation address for loading single-segment overlays, or 0 for
2224 * no relocation
2225 * @dma_engine: pointer to DMA engine to be used for DSP download
2226 * @dma_chan: The number of DMA channels used for DSP download
2227 * @port_map_mask: port mapping
2228 * @ovly: TRUE if overlay format is required
2229 *
2230 * Returns zero or a negative error code.
2231 */
2232 static int dspxfr_one_seg(struct hda_codec *codec,
2233 const struct dsp_image_seg *fls,
2234 unsigned int reloc,
2235 struct dma_engine *dma_engine,
2236 unsigned int dma_chan,
2237 unsigned int port_map_mask,
2238 bool ovly)
2239 {
2240 int status = 0;
2241 bool comm_dma_setup_done = false;
2242 const unsigned int *data;
2243 unsigned int chip_addx;
2244 unsigned int words_to_write;
2245 unsigned int buffer_size_words;
2246 unsigned char *buffer_addx;
2247 unsigned short hda_format;
2248 unsigned int sample_rate_div;
2249 unsigned int sample_rate_mul;
2250 unsigned int num_chans;
2251 unsigned int hda_frame_size_words;
2252 unsigned int remainder_words;
2253 const u32 *data_remainder;
2254 u32 chip_addx_remainder;
2255 unsigned int run_size_words;
2256 const struct dsp_image_seg *hci_write = NULL;
2257 unsigned long timeout;
2258 bool dma_active;
2259
2260 if (fls == NULL)
2261 return -EINVAL;
2262 if (is_hci_prog_list_seg(fls)) {
2263 hci_write = fls;
2264 fls = get_next_seg_ptr(fls);
2265 }
2266
2267 if (hci_write && (!fls || is_last(fls))) {
2268 snd_printdd("hci_write\n");
2269 return dspxfr_hci_write(codec, hci_write);
2270 }
2271
2272 if (fls == NULL || dma_engine == NULL || port_map_mask == 0) {
2273 snd_printdd("Invalid Params\n");
2274 return -EINVAL;
2275 }
2276
2277 data = fls->data;
2278 chip_addx = fls->chip_addr,
2279 words_to_write = fls->count;
2280
2281 if (!words_to_write)
2282 return hci_write ? dspxfr_hci_write(codec, hci_write) : 0;
2283 if (reloc)
2284 chip_addx = (chip_addx & (0xFFFF0000 << 2)) + (reloc << 2);
2285
2286 if (!UC_RANGE(chip_addx, words_to_write) &&
2287 !X_RANGE_ALL(chip_addx, words_to_write) &&
2288 !Y_RANGE_ALL(chip_addx, words_to_write)) {
2289 snd_printdd("Invalid chip_addx Params\n");
2290 return -EINVAL;
2291 }
2292
2293 buffer_size_words = (unsigned int)dma_get_buffer_size(dma_engine) /
2294 sizeof(u32);
2295
2296 buffer_addx = dma_get_buffer_addr(dma_engine);
2297
2298 if (buffer_addx == NULL) {
2299 snd_printdd(KERN_ERR "dma_engine buffer NULL\n");
2300 return -EINVAL;
2301 }
2302
2303 dma_get_converter_format(dma_engine, &hda_format);
2304 sample_rate_div = ((get_hdafmt_rate(hda_format) >> 0) & 3) + 1;
2305 sample_rate_mul = ((get_hdafmt_rate(hda_format) >> 3) & 3) + 1;
2306 num_chans = get_hdafmt_chs(hda_format) + 1;
2307
2308 hda_frame_size_words = ((sample_rate_div == 0) ? 0 :
2309 (num_chans * sample_rate_mul / sample_rate_div));
2310
2311 if (hda_frame_size_words == 0) {
2312 snd_printdd(KERN_ERR "frmsz zero\n");
2313 return -EINVAL;
2314 }
2315
2316 buffer_size_words = min(buffer_size_words,
2317 (unsigned int)(UC_RANGE(chip_addx, 1) ?
2318 65536 : 32768));
2319 buffer_size_words -= buffer_size_words % hda_frame_size_words;
2320 snd_printdd(
2321 "chpadr=0x%08x frmsz=%u nchan=%u "
2322 "rate_mul=%u div=%u bufsz=%u\n",
2323 chip_addx, hda_frame_size_words, num_chans,
2324 sample_rate_mul, sample_rate_div, buffer_size_words);
2325
2326 if (buffer_size_words < hda_frame_size_words) {
2327 snd_printdd(KERN_ERR "dspxfr_one_seg:failed\n");
2328 return -EINVAL;
2329 }
2330
2331 remainder_words = words_to_write % hda_frame_size_words;
2332 data_remainder = data;
2333 chip_addx_remainder = chip_addx;
2334
2335 data += remainder_words;
2336 chip_addx += remainder_words*sizeof(u32);
2337 words_to_write -= remainder_words;
2338
2339 while (words_to_write != 0) {
2340 run_size_words = min(buffer_size_words, words_to_write);
2341 snd_printdd("dspxfr (seg loop)cnt=%u rs=%u remainder=%u\n",
2342 words_to_write, run_size_words, remainder_words);
2343 dma_xfer(dma_engine, data, run_size_words*sizeof(u32));
2344 if (!comm_dma_setup_done) {
2345 status = dsp_dma_stop(codec, dma_chan, ovly);
2346 if (status < 0)
2347 return status;
2348 status = dsp_dma_setup_common(codec, chip_addx,
2349 dma_chan, port_map_mask, ovly);
2350 if (status < 0)
2351 return status;
2352 comm_dma_setup_done = true;
2353 }
2354
2355 status = dsp_dma_setup(codec, chip_addx,
2356 run_size_words, dma_chan);
2357 if (status < 0)
2358 return status;
2359 status = dsp_dma_start(codec, dma_chan, ovly);
2360 if (status < 0)
2361 return status;
2362 if (!dsp_is_dma_active(codec, dma_chan)) {
2363 snd_printdd(KERN_ERR "dspxfr:DMA did not start\n");
2364 return -EIO;
2365 }
2366 status = dma_set_state(dma_engine, DMA_STATE_RUN);
2367 if (status < 0)
2368 return status;
2369 if (remainder_words != 0) {
2370 status = chipio_write_multiple(codec,
2371 chip_addx_remainder,
2372 data_remainder,
2373 remainder_words);
2374 if (status < 0)
2375 return status;
2376 remainder_words = 0;
2377 }
2378 if (hci_write) {
2379 status = dspxfr_hci_write(codec, hci_write);
2380 if (status < 0)
2381 return status;
2382 hci_write = NULL;
2383 }
2384
2385 timeout = jiffies + msecs_to_jiffies(2000);
2386 do {
2387 dma_active = dsp_is_dma_active(codec, dma_chan);
2388 if (!dma_active)
2389 break;
2390 msleep(20);
2391 } while (time_before(jiffies, timeout));
2392 if (dma_active)
2393 break;
2394
2395 snd_printdd(KERN_INFO "+++++ DMA complete\n");
2396 dma_set_state(dma_engine, DMA_STATE_STOP);
2397 status = dma_reset(dma_engine);
2398
2399 if (status < 0)
2400 return status;
2401
2402 data += run_size_words;
2403 chip_addx += run_size_words*sizeof(u32);
2404 words_to_write -= run_size_words;
2405 }
2406
2407 if (remainder_words != 0) {
2408 status = chipio_write_multiple(codec, chip_addx_remainder,
2409 data_remainder, remainder_words);
2410 }
2411
2412 return status;
2413 }
2414
2415 /**
2416 * Write the entire DSP image of a DSP code/data overlay to DSP memories
2417 *
2418 * @codec: the HDA codec
2419 * @fls_data: pointer to a fast load image
2420 * @reloc: Relocation address for loading single-segment overlays, or 0 for
2421 * no relocation
2422 * @sample_rate: sampling rate of the stream used for DSP download
2423 * @number_channels: channels of the stream used for DSP download
2424 * @ovly: TRUE if overlay format is required
2425 *
2426 * Returns zero or a negative error code.
2427 */
2428 static int dspxfr_image(struct hda_codec *codec,
2429 const struct dsp_image_seg *fls_data,
2430 unsigned int reloc,
2431 unsigned int sample_rate,
2432 unsigned short channels,
2433 bool ovly)
2434 {
2435 struct ca0132_spec *spec = codec->spec;
2436 int status;
2437 unsigned short hda_format = 0;
2438 unsigned int response;
2439 unsigned char stream_id = 0;
2440 struct dma_engine *dma_engine;
2441 unsigned int dma_chan;
2442 unsigned int port_map_mask;
2443
2444 if (fls_data == NULL)
2445 return -EINVAL;
2446
2447 dma_engine = kzalloc(sizeof(*dma_engine), GFP_KERNEL);
2448 if (!dma_engine)
2449 return -ENOMEM;
2450
2451 dma_engine->dmab = kzalloc(sizeof(*dma_engine->dmab), GFP_KERNEL);
2452 if (!dma_engine->dmab) {
2453 kfree(dma_engine);
2454 return -ENOMEM;
2455 }
2456
2457 dma_engine->codec = codec;
2458 dma_convert_to_hda_format(sample_rate, channels, &hda_format);
2459 dma_engine->m_converter_format = hda_format;
2460 dma_engine->buf_size = (ovly ? DSP_DMA_WRITE_BUFLEN_OVLY :
2461 DSP_DMA_WRITE_BUFLEN_INIT) * 2;
2462
2463 dma_chan = ovly ? INVALID_DMA_CHANNEL : 0;
2464
2465 status = codec_set_converter_format(codec, WIDGET_CHIP_CTRL,
2466 hda_format, &response);
2467
2468 if (status < 0) {
2469 snd_printdd(KERN_ERR "set converter format fail\n");
2470 goto exit;
2471 }
2472
2473 status = snd_hda_codec_load_dsp_prepare(codec,
2474 dma_engine->m_converter_format,
2475 dma_engine->buf_size,
2476 dma_engine->dmab);
2477 if (status < 0)
2478 goto exit;
2479 spec->dsp_stream_id = status;
2480
2481 if (ovly) {
2482 status = dspio_alloc_dma_chan(codec, &dma_chan);
2483 if (status < 0) {
2484 snd_printdd(KERN_ERR "alloc dmachan fail\n");
2485 dma_chan = INVALID_DMA_CHANNEL;
2486 goto exit;
2487 }
2488 }
2489
2490 port_map_mask = 0;
2491 status = dsp_allocate_ports_format(codec, hda_format,
2492 &port_map_mask);
2493 if (status < 0) {
2494 snd_printdd(KERN_ERR "alloc ports fail\n");
2495 goto exit;
2496 }
2497
2498 stream_id = dma_get_stream_id(dma_engine);
2499 status = codec_set_converter_stream_channel(codec,
2500 WIDGET_CHIP_CTRL, stream_id, 0, &response);
2501 if (status < 0) {
2502 snd_printdd(KERN_ERR "set stream chan fail\n");
2503 goto exit;
2504 }
2505
2506 while ((fls_data != NULL) && !is_last(fls_data)) {
2507 if (!is_valid(fls_data)) {
2508 snd_printdd(KERN_ERR "FLS check fail\n");
2509 status = -EINVAL;
2510 goto exit;
2511 }
2512 status = dspxfr_one_seg(codec, fls_data, reloc,
2513 dma_engine, dma_chan,
2514 port_map_mask, ovly);
2515 if (status < 0)
2516 break;
2517
2518 if (is_hci_prog_list_seg(fls_data))
2519 fls_data = get_next_seg_ptr(fls_data);
2520
2521 if ((fls_data != NULL) && !is_last(fls_data))
2522 fls_data = get_next_seg_ptr(fls_data);
2523 }
2524
2525 if (port_map_mask != 0)
2526 status = dsp_free_ports(codec);
2527
2528 if (status < 0)
2529 goto exit;
2530
2531 status = codec_set_converter_stream_channel(codec,
2532 WIDGET_CHIP_CTRL, 0, 0, &response);
2533
2534 exit:
2535 if (ovly && (dma_chan != INVALID_DMA_CHANNEL))
2536 dspio_free_dma_chan(codec, dma_chan);
2537
2538 if (dma_engine->dmab->area)
2539 snd_hda_codec_load_dsp_cleanup(codec, dma_engine->dmab);
2540 kfree(dma_engine->dmab);
2541 kfree(dma_engine);
2542
2543 return status;
2544 }
2545
2546 /*
2547 * CA0132 DSP download stuffs.
2548 */
2549 static void dspload_post_setup(struct hda_codec *codec)
2550 {
2551 snd_printdd(KERN_INFO "---- dspload_post_setup ------\n");
2552
2553 /*set DSP speaker to 2.0 configuration*/
2554 chipio_write(codec, XRAM_XRAM_INST_OFFSET(0x18), 0x08080080);
2555 chipio_write(codec, XRAM_XRAM_INST_OFFSET(0x19), 0x3f800000);
2556
2557 /*update write pointer*/
2558 chipio_write(codec, XRAM_XRAM_INST_OFFSET(0x29), 0x00000002);
2559 }
2560
2561 /**
2562 * Download DSP from a DSP Image Fast Load structure. This structure is a
2563 * linear, non-constant sized element array of structures, each of which
2564 * contain the count of the data to be loaded, the data itself, and the
2565 * corresponding starting chip address of the starting data location.
2566 *
2567 * @codec: the HDA codec
2568 * @fls: pointer to a fast load image
2569 * @ovly: TRUE if overlay format is required
2570 * @reloc: Relocation address for loading single-segment overlays, or 0 for
2571 * no relocation
2572 * @autostart: TRUE if DSP starts after loading; ignored if ovly is TRUE
2573 * @router_chans: number of audio router channels to be allocated (0 means use
2574 * internal defaults; max is 32)
2575 *
2576 * Returns zero or a negative error code.
2577 */
2578 static int dspload_image(struct hda_codec *codec,
2579 const struct dsp_image_seg *fls,
2580 bool ovly,
2581 unsigned int reloc,
2582 bool autostart,
2583 int router_chans)
2584 {
2585 int status = 0;
2586 unsigned int sample_rate;
2587 unsigned short channels;
2588
2589 snd_printdd(KERN_INFO "---- dspload_image begin ------\n");
2590 if (router_chans == 0) {
2591 if (!ovly)
2592 router_chans = DMA_TRANSFER_FRAME_SIZE_NWORDS;
2593 else
2594 router_chans = DMA_OVERLAY_FRAME_SIZE_NWORDS;
2595 }
2596
2597 sample_rate = 48000;
2598 channels = (unsigned short)router_chans;
2599
2600 while (channels > 16) {
2601 sample_rate *= 2;
2602 channels /= 2;
2603 }
2604
2605 do {
2606 snd_printdd(KERN_INFO "Ready to program DMA\n");
2607 if (!ovly)
2608 status = dsp_reset(codec);
2609
2610 if (status < 0)
2611 break;
2612
2613 snd_printdd(KERN_INFO "dsp_reset() complete\n");
2614 status = dspxfr_image(codec, fls, reloc, sample_rate, channels,
2615 ovly);
2616
2617 if (status < 0)
2618 break;
2619
2620 snd_printdd(KERN_INFO "dspxfr_image() complete\n");
2621 if (autostart && !ovly) {
2622 dspload_post_setup(codec);
2623 status = dsp_set_run_state(codec);
2624 }
2625
2626 snd_printdd(KERN_INFO "LOAD FINISHED\n");
2627 } while (0);
2628
2629 return status;
2630 }
2631
2632 #ifdef CONFIG_SND_HDA_CODEC_CA0132_DSP
2633 static bool dspload_is_loaded(struct hda_codec *codec)
2634 {
2635 unsigned int data = 0;
2636 int status = 0;
2637
2638 status = chipio_read(codec, 0x40004, &data);
2639 if ((status < 0) || (data != 1))
2640 return false;
2641
2642 return true;
2643 }
2644 #else
2645 #define dspload_is_loaded(codec) false
2646 #endif
2647
2648 static bool dspload_wait_loaded(struct hda_codec *codec)
2649 {
2650 unsigned long timeout = jiffies + msecs_to_jiffies(2000);
2651
2652 do {
2653 if (dspload_is_loaded(codec)) {
2654 pr_info("ca0132 DOWNLOAD OK :-) DSP IS RUNNING.\n");
2655 return true;
2656 }
2657 msleep(20);
2658 } while (time_before(jiffies, timeout));
2659
2660 pr_err("ca0132 DOWNLOAD FAILED!!! DSP IS NOT RUNNING.\n");
2661 return false;
2662 }
2663
2664 /*
2665 * PCM callbacks
2666 */
2667 static int ca0132_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2668 struct hda_codec *codec,
2669 unsigned int stream_tag,
2670 unsigned int format,
2671 struct snd_pcm_substream *substream)
2672 {
2673 struct ca0132_spec *spec = codec->spec;
2674
2675 snd_hda_codec_setup_stream(codec, spec->dacs[0], stream_tag, 0, format);
2676
2677 return 0;
2678 }
2679
2680 static int ca0132_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2681 struct hda_codec *codec,
2682 struct snd_pcm_substream *substream)
2683 {
2684 struct ca0132_spec *spec = codec->spec;
2685
2686 if (spec->dsp_state == DSP_DOWNLOADING)
2687 return 0;
2688
2689 /*If Playback effects are on, allow stream some time to flush
2690 *effects tail*/
2691 if (spec->effects_switch[PLAY_ENHANCEMENT - EFFECT_START_NID])
2692 msleep(50);
2693
2694 snd_hda_codec_cleanup_stream(codec, spec->dacs[0]);
2695
2696 return 0;
2697 }
2698
2699 static unsigned int ca0132_playback_pcm_delay(struct hda_pcm_stream *info,
2700 struct hda_codec *codec,
2701 struct snd_pcm_substream *substream)
2702 {
2703 struct ca0132_spec *spec = codec->spec;
2704 unsigned int latency = DSP_PLAYBACK_INIT_LATENCY;
2705 struct snd_pcm_runtime *runtime = substream->runtime;
2706
2707 if (spec->dsp_state != DSP_DOWNLOADED)
2708 return 0;
2709
2710 /* Add latency if playback enhancement and either effect is enabled. */
2711 if (spec->effects_switch[PLAY_ENHANCEMENT - EFFECT_START_NID]) {
2712 if ((spec->effects_switch[SURROUND - EFFECT_START_NID]) ||
2713 (spec->effects_switch[DIALOG_PLUS - EFFECT_START_NID]))
2714 latency += DSP_PLAY_ENHANCEMENT_LATENCY;
2715 }
2716
2717 /* Applying Speaker EQ adds latency as well. */
2718 if (spec->cur_out_type == SPEAKER_OUT)
2719 latency += DSP_SPEAKER_OUT_LATENCY;
2720
2721 return (latency * runtime->rate) / 1000;
2722 }
2723
2724 /*
2725 * Digital out
2726 */
2727 static int ca0132_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2728 struct hda_codec *codec,
2729 struct snd_pcm_substream *substream)
2730 {
2731 struct ca0132_spec *spec = codec->spec;
2732 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2733 }
2734
2735 static int ca0132_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2736 struct hda_codec *codec,
2737 unsigned int stream_tag,
2738 unsigned int format,
2739 struct snd_pcm_substream *substream)
2740 {
2741 struct ca0132_spec *spec = codec->spec;
2742 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2743 stream_tag, format, substream);
2744 }
2745
2746 static int ca0132_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2747 struct hda_codec *codec,
2748 struct snd_pcm_substream *substream)
2749 {
2750 struct ca0132_spec *spec = codec->spec;
2751 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2752 }
2753
2754 static int ca0132_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2755 struct hda_codec *codec,
2756 struct snd_pcm_substream *substream)
2757 {
2758 struct ca0132_spec *spec = codec->spec;
2759 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2760 }
2761
2762 /*
2763 * Analog capture
2764 */
2765 static int ca0132_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2766 struct hda_codec *codec,
2767 unsigned int stream_tag,
2768 unsigned int format,
2769 struct snd_pcm_substream *substream)
2770 {
2771 snd_hda_codec_setup_stream(codec, hinfo->nid,
2772 stream_tag, 0, format);
2773
2774 return 0;
2775 }
2776
2777 static int ca0132_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2778 struct hda_codec *codec,
2779 struct snd_pcm_substream *substream)
2780 {
2781 struct ca0132_spec *spec = codec->spec;
2782
2783 if (spec->dsp_state == DSP_DOWNLOADING)
2784 return 0;
2785
2786 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
2787 return 0;
2788 }
2789
2790 static unsigned int ca0132_capture_pcm_delay(struct hda_pcm_stream *info,
2791 struct hda_codec *codec,
2792 struct snd_pcm_substream *substream)
2793 {
2794 struct ca0132_spec *spec = codec->spec;
2795 unsigned int latency = DSP_CAPTURE_INIT_LATENCY;
2796 struct snd_pcm_runtime *runtime = substream->runtime;
2797
2798 if (spec->dsp_state != DSP_DOWNLOADED)
2799 return 0;
2800
2801 if (spec->effects_switch[CRYSTAL_VOICE - EFFECT_START_NID])
2802 latency += DSP_CRYSTAL_VOICE_LATENCY;
2803
2804 return (latency * runtime->rate) / 1000;
2805 }
2806
2807 /*
2808 * Controls stuffs.
2809 */
2810
2811 /*
2812 * Mixer controls helpers.
2813 */
2814 #define CA0132_CODEC_VOL_MONO(xname, nid, channel, dir) \
2815 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2816 .name = xname, \
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) }
2826
2827 #define CA0132_CODEC_MUTE_MONO(xname, nid, channel, dir) \
2828 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2829 .name = xname, \
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) }
2835
2836 /* stereo */
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)
2841
2842 /* The followings are for tuning of products */
2843 #ifdef ENABLE_TUNING_CONTROLS
2844
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
2873 };
2874
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
2893 };
2894
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,
2904 0x41C00000
2905 };
2906
2907 static int tuning_ctl_set(struct hda_codec *codec, hda_nid_t nid,
2908 unsigned int *lookup, int idx)
2909 {
2910 int i = 0;
2911
2912 for (i = 0; i < TUNING_CTLS_COUNT; i++)
2913 if (nid == ca0132_tuning_ctls[i].nid)
2914 break;
2915
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);
2921
2922 return 1;
2923 }
2924
2925 static int tuning_ctl_get(struct snd_kcontrol *kcontrol,
2926 struct snd_ctl_elem_value *ucontrol)
2927 {
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;
2933
2934 *valp = spec->cur_ctl_vals[idx];
2935 return 0;
2936 }
2937
2938 static int voice_focus_ctl_info(struct snd_kcontrol *kcontrol,
2939 struct snd_ctl_elem_info *uinfo)
2940 {
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;
2947
2948 return 0;
2949 }
2950
2951 static int voice_focus_ctl_put(struct snd_kcontrol *kcontrol,
2952 struct snd_ctl_elem_value *ucontrol)
2953 {
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;
2958 int idx;
2959
2960 idx = nid - TUNING_CTL_START_NID;
2961 /* any change? */
2962 if (spec->cur_ctl_vals[idx] == *valp)
2963 return 0;
2964
2965 spec->cur_ctl_vals[idx] = *valp;
2966
2967 idx = *valp - 20;
2968 tuning_ctl_set(codec, nid, voice_focus_vals_lookup, idx);
2969
2970 return 1;
2971 }
2972
2973 static int mic_svm_ctl_info(struct snd_kcontrol *kcontrol,
2974 struct snd_ctl_elem_info *uinfo)
2975 {
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;
2982
2983 return 0;
2984 }
2985
2986 static int mic_svm_ctl_put(struct snd_kcontrol *kcontrol,
2987 struct snd_ctl_elem_value *ucontrol)
2988 {
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;
2993 int idx;
2994
2995 idx = nid - TUNING_CTL_START_NID;
2996 /* any change? */
2997 if (spec->cur_ctl_vals[idx] == *valp)
2998 return 0;
2999
3000 spec->cur_ctl_vals[idx] = *valp;
3001
3002 idx = *valp;
3003 tuning_ctl_set(codec, nid, mic_svm_vals_lookup, idx);
3004
3005 return 0;
3006 }
3007
3008 static int equalizer_ctl_info(struct snd_kcontrol *kcontrol,
3009 struct snd_ctl_elem_info *uinfo)
3010 {
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;
3017
3018 return 0;
3019 }
3020
3021 static int equalizer_ctl_put(struct snd_kcontrol *kcontrol,
3022 struct snd_ctl_elem_value *ucontrol)
3023 {
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;
3028 int idx;
3029
3030 idx = nid - TUNING_CTL_START_NID;
3031 /* any change? */
3032 if (spec->cur_ctl_vals[idx] == *valp)
3033 return 0;
3034
3035 spec->cur_ctl_vals[idx] = *valp;
3036
3037 idx = *valp;
3038 tuning_ctl_set(codec, nid, equalizer_vals_lookup, idx);
3039
3040 return 1;
3041 }
3042
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);
3045
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)
3049 {
3050 char namestr[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3051 int type = dir ? HDA_INPUT : HDA_OUTPUT;
3052 struct snd_kcontrol_new knew =
3053 HDA_CODEC_VOLUME_MONO(namestr, nid, 1, 0, type);
3054
3055 knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
3056 SNDRV_CTL_ELEM_ACCESS_TLV_READ;
3057 knew.tlv.c = 0;
3058 knew.tlv.p = 0;
3059 switch (pnid) {
3060 case VOICE_FOCUS:
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;
3065 break;
3066 case MIC_SVM:
3067 knew.info = mic_svm_ctl_info;
3068 knew.get = tuning_ctl_get;
3069 knew.put = mic_svm_ctl_put;
3070 break;
3071 case EQUALIZER:
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;
3076 break;
3077 default:
3078 return 0;
3079 }
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));
3084 }
3085
3086 static int add_tuning_ctls(struct hda_codec *codec)
3087 {
3088 int i;
3089 int err;
3090
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);
3097 if (err < 0)
3098 return err;
3099 }
3100
3101 return 0;
3102 }
3103
3104 static void ca0132_init_tuning_defaults(struct hda_codec *codec)
3105 {
3106 struct ca0132_spec *spec = codec->spec;
3107 int i;
3108
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;
3113
3114 /* EQ defaults to 0dB. */
3115 for (i = 2; i < TUNING_CTLS_COUNT; i++)
3116 spec->cur_ctl_vals[i] = 24;
3117 }
3118 #endif /*ENABLE_TUNING_CONTROLS*/
3119
3120 /*
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.
3125 */
3126 static int ca0132_select_out(struct hda_codec *codec)
3127 {
3128 struct ca0132_spec *spec = codec->spec;
3129 unsigned int pin_ctl;
3130 int jack_present;
3131 int auto_jack;
3132 unsigned int tmp;
3133 int err;
3134
3135 snd_printdd(KERN_INFO "ca0132_select_out\n");
3136
3137 snd_hda_power_up(codec);
3138
3139 auto_jack = spec->vnode_lswitch[VNID_HP_ASEL - VNODE_START_NID];
3140
3141 if (auto_jack)
3142 jack_present = snd_hda_jack_detect(codec, spec->out_pins[1]);
3143 else
3144 jack_present =
3145 spec->vnode_lswitch[VNID_HP_SEL - VNODE_START_NID];
3146
3147 if (jack_present)
3148 spec->cur_out_type = HEADPHONE_OUT;
3149 else
3150 spec->cur_out_type = SPEAKER_OUT;
3151
3152 if (spec->cur_out_type == SPEAKER_OUT) {
3153 snd_printdd(KERN_INFO "ca0132_select_out speaker\n");
3154 /*speaker out config*/
3155 tmp = FLOAT_ONE;
3156 err = dspio_set_uint_param(codec, 0x80, 0x04, tmp);
3157 if (err < 0)
3158 goto exit;
3159 /*enable speaker EQ*/
3160 tmp = FLOAT_ONE;
3161 err = dspio_set_uint_param(codec, 0x8f, 0x00, tmp);
3162 if (err < 0)
3163 goto exit;
3164
3165 /* Setup EAPD */
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);
3174
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],
3179 pin_ctl & ~PIN_HP);
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],
3184 pin_ctl | PIN_OUT);
3185 } else {
3186 snd_printdd(KERN_INFO "ca0132_select_out hp\n");
3187 /*headphone out config*/
3188 tmp = FLOAT_ZERO;
3189 err = dspio_set_uint_param(codec, 0x80, 0x04, tmp);
3190 if (err < 0)
3191 goto exit;
3192 /*disable speaker EQ*/
3193 tmp = FLOAT_ZERO;
3194 err = dspio_set_uint_param(codec, 0x8f, 0x00, tmp);
3195 if (err < 0)
3196 goto exit;
3197
3198 /* Setup EAPD */
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);
3207
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],
3212 pin_ctl & ~PIN_HP);
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],
3217 pin_ctl | PIN_HP);
3218 }
3219
3220 exit:
3221 snd_hda_power_down(codec);
3222
3223 return err < 0 ? err : 0;
3224 }
3225
3226 static void ca0132_unsol_hp_delayed(struct work_struct *work)
3227 {
3228 struct ca0132_spec *spec = container_of(
3229 to_delayed_work(work), struct ca0132_spec, unsol_hp_work);
3230 ca0132_select_out(spec->codec);
3231 snd_hda_jack_report_sync(spec->codec);
3232 }
3233
3234 static void ca0132_set_dmic(struct hda_codec *codec, int enable);
3235 static int ca0132_mic_boost_set(struct hda_codec *codec, long val);
3236 static int ca0132_effects_set(struct hda_codec *codec, hda_nid_t nid, long val);
3237
3238 /*
3239 * Select the active VIP source
3240 */
3241 static int ca0132_set_vipsource(struct hda_codec *codec, int val)
3242 {
3243 struct ca0132_spec *spec = codec->spec;
3244 unsigned int tmp;
3245
3246 if (spec->dsp_state != DSP_DOWNLOADED)
3247 return 0;
3248
3249 /* if CrystalVoice if off, vipsource should be 0 */
3250 if (!spec->effects_switch[CRYSTAL_VOICE - EFFECT_START_NID] ||
3251 (val == 0)) {
3252 chipio_set_control_param(codec, CONTROL_PARAM_VIP_SOURCE, 0);
3253 chipio_set_conn_rate(codec, MEM_CONNID_MICIN1, SR_96_000);
3254 chipio_set_conn_rate(codec, MEM_CONNID_MICOUT1, SR_96_000);
3255 if (spec->cur_mic_type == DIGITAL_MIC)
3256 tmp = FLOAT_TWO;
3257 else
3258 tmp = FLOAT_ONE;
3259 dspio_set_uint_param(codec, 0x80, 0x00, tmp);
3260 tmp = FLOAT_ZERO;
3261 dspio_set_uint_param(codec, 0x80, 0x05, tmp);
3262 } else {
3263 chipio_set_conn_rate(codec, MEM_CONNID_MICIN1, SR_16_000);
3264 chipio_set_conn_rate(codec, MEM_CONNID_MICOUT1, SR_16_000);
3265 if (spec->cur_mic_type == DIGITAL_MIC)
3266 tmp = FLOAT_TWO;
3267 else
3268 tmp = FLOAT_ONE;
3269 dspio_set_uint_param(codec, 0x80, 0x00, tmp);
3270 tmp = FLOAT_ONE;
3271 dspio_set_uint_param(codec, 0x80, 0x05, tmp);
3272 msleep(20);
3273 chipio_set_control_param(codec, CONTROL_PARAM_VIP_SOURCE, val);
3274 }
3275
3276 return 1;
3277 }
3278
3279 /*
3280 * Select the active microphone.
3281 * If autodetect is enabled, mic will be selected based on jack detection.
3282 * If jack inserted, ext.mic will be selected, else built-in mic
3283 * If autodetect is disabled, mic will be selected based on selection.
3284 */
3285 static int ca0132_select_mic(struct hda_codec *codec)
3286 {
3287 struct ca0132_spec *spec = codec->spec;
3288 int jack_present;
3289 int auto_jack;
3290
3291 snd_printdd(KERN_INFO "ca0132_select_mic\n");
3292
3293 snd_hda_power_up(codec);
3294
3295 auto_jack = spec->vnode_lswitch[VNID_AMIC1_ASEL - VNODE_START_NID];
3296
3297 if (auto_jack)
3298 jack_present = snd_hda_jack_detect(codec, spec->input_pins[0]);
3299 else
3300 jack_present =
3301 spec->vnode_lswitch[VNID_AMIC1_SEL - VNODE_START_NID];
3302
3303 if (jack_present)
3304 spec->cur_mic_type = LINE_MIC_IN;
3305 else
3306 spec->cur_mic_type = DIGITAL_MIC;
3307
3308 if (spec->cur_mic_type == DIGITAL_MIC) {
3309 /* enable digital Mic */
3310 chipio_set_conn_rate(codec, MEM_CONNID_DMIC, SR_32_000);
3311 ca0132_set_dmic(codec, 1);
3312 ca0132_mic_boost_set(codec, 0);
3313 /* set voice focus */
3314 ca0132_effects_set(codec, VOICE_FOCUS,
3315 spec->effects_switch
3316 [VOICE_FOCUS - EFFECT_START_NID]);
3317 } else {
3318 /* disable digital Mic */
3319 chipio_set_conn_rate(codec, MEM_CONNID_DMIC, SR_96_000);
3320 ca0132_set_dmic(codec, 0);
3321 ca0132_mic_boost_set(codec, spec->cur_mic_boost);
3322 /* disable voice focus */
3323 ca0132_effects_set(codec, VOICE_FOCUS, 0);
3324 }
3325
3326 snd_hda_power_down(codec);
3327
3328 return 0;
3329 }
3330
3331 /*
3332 * Check if VNODE settings take effect immediately.
3333 */
3334 static bool ca0132_is_vnode_effective(struct hda_codec *codec,
3335 hda_nid_t vnid,
3336 hda_nid_t *shared_nid)
3337 {
3338 struct ca0132_spec *spec = codec->spec;
3339 hda_nid_t nid;
3340
3341 switch (vnid) {
3342 case VNID_SPK:
3343 nid = spec->shared_out_nid;
3344 break;
3345 case VNID_MIC:
3346 nid = spec->shared_mic_nid;
3347 break;
3348 default:
3349 return false;
3350 }
3351
3352 if (shared_nid)
3353 *shared_nid = nid;
3354
3355 return true;
3356 }
3357
3358 /*
3359 * The following functions are control change helpers.
3360 * They return 0 if no changed. Return 1 if changed.
3361 */
3362 static int ca0132_voicefx_set(struct hda_codec *codec, int enable)
3363 {
3364 struct ca0132_spec *spec = codec->spec;
3365 unsigned int tmp;
3366
3367 /* based on CrystalVoice state to enable VoiceFX. */
3368 if (enable) {
3369 tmp = spec->effects_switch[CRYSTAL_VOICE - EFFECT_START_NID] ?
3370 FLOAT_ONE : FLOAT_ZERO;
3371 } else {
3372 tmp = FLOAT_ZERO;
3373 }
3374
3375 dspio_set_uint_param(codec, ca0132_voicefx.mid,
3376 ca0132_voicefx.reqs[0], tmp);
3377
3378 return 1;
3379 }
3380
3381 /*
3382 * Set the effects parameters
3383 */
3384 static int ca0132_effects_set(struct hda_codec *codec, hda_nid_t nid, long val)
3385 {
3386 struct ca0132_spec *spec = codec->spec;
3387 unsigned int on;
3388 int num_fx = OUT_EFFECTS_COUNT + IN_EFFECTS_COUNT;
3389 int err = 0;
3390 int idx = nid - EFFECT_START_NID;
3391
3392 if ((idx < 0) || (idx >= num_fx))
3393 return 0; /* no changed */
3394
3395 /* for out effect, qualify with PE */
3396 if ((nid >= OUT_EFFECT_START_NID) && (nid < OUT_EFFECT_END_NID)) {
3397 /* if PE if off, turn off out effects. */
3398 if (!spec->effects_switch[PLAY_ENHANCEMENT - EFFECT_START_NID])
3399 val = 0;
3400 }
3401
3402 /* for in effect, qualify with CrystalVoice */
3403 if ((nid >= IN_EFFECT_START_NID) && (nid < IN_EFFECT_END_NID)) {
3404 /* if CrystalVoice if off, turn off in effects. */
3405 if (!spec->effects_switch[CRYSTAL_VOICE - EFFECT_START_NID])
3406 val = 0;
3407
3408 /* Voice Focus applies to 2-ch Mic, Digital Mic */
3409 if ((nid == VOICE_FOCUS) && (spec->cur_mic_type != DIGITAL_MIC))
3410 val = 0;
3411 }
3412
3413 snd_printdd(KERN_INFO "ca0132_effect_set: nid=0x%x, val=%ld\n",
3414 nid, val);
3415
3416 on = (val == 0) ? FLOAT_ZERO : FLOAT_ONE;
3417 err = dspio_set_uint_param(codec, ca0132_effects[idx].mid,
3418 ca0132_effects[idx].reqs[0], on);
3419
3420 if (err < 0)
3421 return 0; /* no changed */
3422
3423 return 1;
3424 }
3425
3426 /*
3427 * Turn on/off Playback Enhancements
3428 */
3429 static int ca0132_pe_switch_set(struct hda_codec *codec)
3430 {
3431 struct ca0132_spec *spec = codec->spec;
3432 hda_nid_t nid;
3433 int i, ret = 0;
3434
3435 snd_printdd(KERN_INFO "ca0132_pe_switch_set: val=%ld\n",
3436 spec->effects_switch[PLAY_ENHANCEMENT - EFFECT_START_NID]);
3437
3438 i = OUT_EFFECT_START_NID - EFFECT_START_NID;
3439 nid = OUT_EFFECT_START_NID;
3440 /* PE affects all out effects */
3441 for (; nid < OUT_EFFECT_END_NID; nid++, i++)
3442 ret |= ca0132_effects_set(codec, nid, spec->effects_switch[i]);
3443
3444 return ret;
3445 }
3446
3447 /* Check if Mic1 is streaming, if so, stop streaming */
3448 static int stop_mic1(struct hda_codec *codec)
3449 {
3450 struct ca0132_spec *spec = codec->spec;
3451 unsigned int oldval = snd_hda_codec_read(codec, spec->adcs[0], 0,
3452 AC_VERB_GET_CONV, 0);
3453 if (oldval != 0)
3454 snd_hda_codec_write(codec, spec->adcs[0], 0,
3455 AC_VERB_SET_CHANNEL_STREAMID,
3456 0);
3457 return oldval;
3458 }
3459
3460 /* Resume Mic1 streaming if it was stopped. */
3461 static void resume_mic1(struct hda_codec *codec, unsigned int oldval)
3462 {
3463 struct ca0132_spec *spec = codec->spec;
3464 /* Restore the previous stream and channel */
3465 if (oldval != 0)
3466 snd_hda_codec_write(codec, spec->adcs[0], 0,
3467 AC_VERB_SET_CHANNEL_STREAMID,
3468 oldval);
3469 }
3470
3471 /*
3472 * Turn on/off CrystalVoice
3473 */
3474 static int ca0132_cvoice_switch_set(struct hda_codec *codec)
3475 {
3476 struct ca0132_spec *spec = codec->spec;
3477 hda_nid_t nid;
3478 int i, ret = 0;
3479 unsigned int oldval;
3480
3481 snd_printdd(KERN_INFO "ca0132_cvoice_switch_set: val=%ld\n",
3482 spec->effects_switch[CRYSTAL_VOICE - EFFECT_START_NID]);
3483
3484 i = IN_EFFECT_START_NID - EFFECT_START_NID;
3485 nid = IN_EFFECT_START_NID;
3486 /* CrystalVoice affects all in effects */
3487 for (; nid < IN_EFFECT_END_NID; nid++, i++)
3488 ret |= ca0132_effects_set(codec, nid, spec->effects_switch[i]);
3489
3490 /* including VoiceFX */
3491 ret |= ca0132_voicefx_set(codec, (spec->voicefx_val ? 1 : 0));
3492
3493 /* set correct vipsource */
3494 oldval = stop_mic1(codec);
3495 ret |= ca0132_set_vipsource(codec, 1);
3496 resume_mic1(codec, oldval);
3497 return ret;
3498 }
3499
3500 static int ca0132_mic_boost_set(struct hda_codec *codec, long val)
3501 {
3502 struct ca0132_spec *spec = codec->spec;
3503 int ret = 0;
3504
3505 if (val) /* on */
3506 ret = snd_hda_codec_amp_update(codec, spec->input_pins[0], 0,
3507 HDA_INPUT, 0, HDA_AMP_VOLMASK, 3);
3508 else /* off */
3509 ret = snd_hda_codec_amp_update(codec, spec->input_pins[0], 0,
3510 HDA_INPUT, 0, HDA_AMP_VOLMASK, 0);
3511
3512 return ret;
3513 }
3514
3515 static int ca0132_vnode_switch_set(struct snd_kcontrol *kcontrol,
3516 struct snd_ctl_elem_value *ucontrol)
3517 {
3518 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3519 hda_nid_t nid = get_amp_nid(kcontrol);
3520 hda_nid_t shared_nid = 0;
3521 bool effective;
3522 int ret = 0;
3523 struct ca0132_spec *spec = codec->spec;
3524 int auto_jack;
3525
3526 if (nid == VNID_HP_SEL) {
3527 auto_jack =
3528 spec->vnode_lswitch[VNID_HP_ASEL - VNODE_START_NID];
3529 if (!auto_jack)
3530 ca0132_select_out(codec);
3531 return 1;
3532 }
3533
3534 if (nid == VNID_AMIC1_SEL) {
3535 auto_jack =
3536 spec->vnode_lswitch[VNID_AMIC1_ASEL - VNODE_START_NID];
3537 if (!auto_jack)
3538 ca0132_select_mic(codec);
3539 return 1;
3540 }
3541
3542 if (nid == VNID_HP_ASEL) {
3543 ca0132_select_out(codec);
3544 return 1;
3545 }
3546
3547 if (nid == VNID_AMIC1_ASEL) {
3548 ca0132_select_mic(codec);
3549 return 1;
3550 }
3551
3552 /* if effective conditions, then update hw immediately. */
3553 effective = ca0132_is_vnode_effective(codec, nid, &shared_nid);
3554 if (effective) {
3555 int dir = get_amp_direction(kcontrol);
3556 int ch = get_amp_channels(kcontrol);
3557 unsigned long pval;
3558
3559 mutex_lock(&codec->control_mutex);
3560 pval = kcontrol->private_value;
3561 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(shared_nid, ch,
3562 0, dir);
3563 ret = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3564 kcontrol->private_value = pval;
3565 mutex_unlock(&codec->control_mutex);
3566 }
3567
3568 return ret;
3569 }
3570 /* End of control change helpers. */
3571
3572 static int ca0132_voicefx_info(struct snd_kcontrol *kcontrol,
3573 struct snd_ctl_elem_info *uinfo)
3574 {
3575 unsigned int items = sizeof(ca0132_voicefx_presets)
3576 / sizeof(struct ct_voicefx_preset);
3577
3578 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3579 uinfo->count = 1;
3580 uinfo->value.enumerated.items = items;
3581 if (uinfo->value.enumerated.item >= items)
3582 uinfo->value.enumerated.item = items - 1;
3583 strcpy(uinfo->value.enumerated.name,
3584 ca0132_voicefx_presets[uinfo->value.enumerated.item].name);
3585 return 0;
3586 }
3587
3588 static int ca0132_voicefx_get(struct snd_kcontrol *kcontrol,
3589 struct snd_ctl_elem_value *ucontrol)
3590 {
3591 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3592 struct ca0132_spec *spec = codec->spec;
3593
3594 ucontrol->value.enumerated.item[0] = spec->voicefx_val;
3595 return 0;
3596 }
3597
3598 static int ca0132_voicefx_put(struct snd_kcontrol *kcontrol,
3599 struct snd_ctl_elem_value *ucontrol)
3600 {
3601 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3602 struct ca0132_spec *spec = codec->spec;
3603 int i, err = 0;
3604 int sel = ucontrol->value.enumerated.item[0];
3605 unsigned int items = sizeof(ca0132_voicefx_presets)
3606 / sizeof(struct ct_voicefx_preset);
3607
3608 if (sel >= items)
3609 return 0;
3610
3611 snd_printdd(KERN_INFO "ca0132_voicefx_put: sel=%d, preset=%s\n",
3612 sel, ca0132_voicefx_presets[sel].name);
3613
3614 /*
3615 * Idx 0 is default.
3616 * Default needs to qualify with CrystalVoice state.
3617 */
3618 for (i = 0; i < VOICEFX_MAX_PARAM_COUNT; i++) {
3619 err = dspio_set_uint_param(codec, ca0132_voicefx.mid,
3620 ca0132_voicefx.reqs[i],
3621 ca0132_voicefx_presets[sel].vals[i]);
3622 if (err < 0)
3623 break;
3624 }
3625
3626 if (err >= 0) {
3627 spec->voicefx_val = sel;
3628 /* enable voice fx */
3629 ca0132_voicefx_set(codec, (sel ? 1 : 0));
3630 }
3631
3632 return 1;
3633 }
3634
3635 static int ca0132_switch_get(struct snd_kcontrol *kcontrol,
3636 struct snd_ctl_elem_value *ucontrol)
3637 {
3638 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3639 struct ca0132_spec *spec = codec->spec;
3640 hda_nid_t nid = get_amp_nid(kcontrol);
3641 int ch = get_amp_channels(kcontrol);
3642 long *valp = ucontrol->value.integer.value;
3643
3644 /* vnode */
3645 if ((nid >= VNODE_START_NID) && (nid < VNODE_END_NID)) {
3646 if (ch & 1) {
3647 *valp = spec->vnode_lswitch[nid - VNODE_START_NID];
3648 valp++;
3649 }
3650 if (ch & 2) {
3651 *valp = spec->vnode_rswitch[nid - VNODE_START_NID];
3652 valp++;
3653 }
3654 return 0;
3655 }
3656
3657 /* effects, include PE and CrystalVoice */
3658 if ((nid >= EFFECT_START_NID) && (nid < EFFECT_END_NID)) {
3659 *valp = spec->effects_switch[nid - EFFECT_START_NID];
3660 return 0;
3661 }
3662
3663 /* mic boost */
3664 if (nid == spec->input_pins[0]) {
3665 *valp = spec->cur_mic_boost;
3666 return 0;
3667 }
3668
3669 return 0;
3670 }
3671
3672 static int ca0132_switch_put(struct snd_kcontrol *kcontrol,
3673 struct snd_ctl_elem_value *ucontrol)
3674 {
3675 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3676 struct ca0132_spec *spec = codec->spec;
3677 hda_nid_t nid = get_amp_nid(kcontrol);
3678 int ch = get_amp_channels(kcontrol);
3679 long *valp = ucontrol->value.integer.value;
3680 int changed = 1;
3681
3682 snd_printdd(KERN_INFO "ca0132_switch_put: nid=0x%x, val=%ld\n",
3683 nid, *valp);
3684
3685 snd_hda_power_up(codec);
3686 /* vnode */
3687 if ((nid >= VNODE_START_NID) && (nid < VNODE_END_NID)) {
3688 if (ch & 1) {
3689 spec->vnode_lswitch[nid - VNODE_START_NID] = *valp;
3690 valp++;
3691 }
3692 if (ch & 2) {
3693 spec->vnode_rswitch[nid - VNODE_START_NID] = *valp;
3694 valp++;
3695 }
3696 changed = ca0132_vnode_switch_set(kcontrol, ucontrol);
3697 goto exit;
3698 }
3699
3700 /* PE */
3701 if (nid == PLAY_ENHANCEMENT) {
3702 spec->effects_switch[nid - EFFECT_START_NID] = *valp;
3703 changed = ca0132_pe_switch_set(codec);
3704 goto exit;
3705 }
3706
3707 /* CrystalVoice */
3708 if (nid == CRYSTAL_VOICE) {
3709 spec->effects_switch[nid - EFFECT_START_NID] = *valp;
3710 changed = ca0132_cvoice_switch_set(codec);
3711 goto exit;
3712 }
3713
3714 /* out and in effects */
3715 if (((nid >= OUT_EFFECT_START_NID) && (nid < OUT_EFFECT_END_NID)) ||
3716 ((nid >= IN_EFFECT_START_NID) && (nid < IN_EFFECT_END_NID))) {
3717 spec->effects_switch[nid - EFFECT_START_NID] = *valp;
3718 changed = ca0132_effects_set(codec, nid, *valp);
3719 goto exit;
3720 }
3721
3722 /* mic boost */
3723 if (nid == spec->input_pins[0]) {
3724 spec->cur_mic_boost = *valp;
3725
3726 /* Mic boost does not apply to Digital Mic */
3727 if (spec->cur_mic_type != DIGITAL_MIC)
3728 changed = ca0132_mic_boost_set(codec, *valp);
3729 goto exit;
3730 }
3731
3732 exit:
3733 snd_hda_power_down(codec);
3734 return changed;
3735 }
3736
3737 /*
3738 * Volume related
3739 */
3740 static int ca0132_volume_info(struct snd_kcontrol *kcontrol,
3741 struct snd_ctl_elem_info *uinfo)
3742 {
3743 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3744 struct ca0132_spec *spec = codec->spec;
3745 hda_nid_t nid = get_amp_nid(kcontrol);
3746 int ch = get_amp_channels(kcontrol);
3747 int dir = get_amp_direction(kcontrol);
3748 unsigned long pval;
3749 int err;
3750
3751 switch (nid) {
3752 case VNID_SPK:
3753 /* follow shared_out info */
3754 nid = spec->shared_out_nid;
3755 mutex_lock(&codec->control_mutex);
3756 pval = kcontrol->private_value;
3757 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(nid, ch, 0, dir);
3758 err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
3759 kcontrol->private_value = pval;
3760 mutex_unlock(&codec->control_mutex);
3761 break;
3762 case VNID_MIC:
3763 /* follow shared_mic info */
3764 nid = spec->shared_mic_nid;
3765 mutex_lock(&codec->control_mutex);
3766 pval = kcontrol->private_value;
3767 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(nid, ch, 0, dir);
3768 err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
3769 kcontrol->private_value = pval;
3770 mutex_unlock(&codec->control_mutex);
3771 break;
3772 default:
3773 err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
3774 }
3775 return err;
3776 }
3777
3778 static int ca0132_volume_get(struct snd_kcontrol *kcontrol,
3779 struct snd_ctl_elem_value *ucontrol)
3780 {
3781 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3782 struct ca0132_spec *spec = codec->spec;
3783 hda_nid_t nid = get_amp_nid(kcontrol);
3784 int ch = get_amp_channels(kcontrol);
3785 long *valp = ucontrol->value.integer.value;
3786
3787 /* store the left and right volume */
3788 if (ch & 1) {
3789 *valp = spec->vnode_lvol[nid - VNODE_START_NID];
3790 valp++;
3791 }
3792 if (ch & 2) {
3793 *valp = spec->vnode_rvol[nid - VNODE_START_NID];
3794 valp++;
3795 }
3796 return 0;
3797 }
3798
3799 static int ca0132_volume_put(struct snd_kcontrol *kcontrol,
3800 struct snd_ctl_elem_value *ucontrol)
3801 {
3802 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3803 struct ca0132_spec *spec = codec->spec;
3804 hda_nid_t nid = get_amp_nid(kcontrol);
3805 int ch = get_amp_channels(kcontrol);
3806 long *valp = ucontrol->value.integer.value;
3807 hda_nid_t shared_nid = 0;
3808 bool effective;
3809 int changed = 1;
3810
3811 /* store the left and right volume */
3812 if (ch & 1) {
3813 spec->vnode_lvol[nid - VNODE_START_NID] = *valp;
3814 valp++;
3815 }
3816 if (ch & 2) {
3817 spec->vnode_rvol[nid - VNODE_START_NID] = *valp;
3818 valp++;
3819 }
3820
3821 /* if effective conditions, then update hw immediately. */
3822 effective = ca0132_is_vnode_effective(codec, nid, &shared_nid);
3823 if (effective) {
3824 int dir = get_amp_direction(kcontrol);
3825 unsigned long pval;
3826
3827 snd_hda_power_up(codec);
3828 mutex_lock(&codec->control_mutex);
3829 pval = kcontrol->private_value;
3830 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(shared_nid, ch,
3831 0, dir);
3832 changed = snd_hda_mixer_amp_volume_put(kcontrol, ucontrol);
3833 kcontrol->private_value = pval;
3834 mutex_unlock(&codec->control_mutex);
3835 snd_hda_power_down(codec);
3836 }
3837
3838 return changed;
3839 }
3840
3841 static int ca0132_volume_tlv(struct snd_kcontrol *kcontrol, int op_flag,
3842 unsigned int size, unsigned int __user *tlv)
3843 {
3844 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3845 struct ca0132_spec *spec = codec->spec;
3846 hda_nid_t nid = get_amp_nid(kcontrol);
3847 int ch = get_amp_channels(kcontrol);
3848 int dir = get_amp_direction(kcontrol);
3849 unsigned long pval;
3850 int err;
3851
3852 switch (nid) {
3853 case VNID_SPK:
3854 /* follow shared_out tlv */
3855 nid = spec->shared_out_nid;
3856 mutex_lock(&codec->control_mutex);
3857 pval = kcontrol->private_value;
3858 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(nid, ch, 0, dir);
3859 err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
3860 kcontrol->private_value = pval;
3861 mutex_unlock(&codec->control_mutex);
3862 break;
3863 case VNID_MIC:
3864 /* follow shared_mic tlv */
3865 nid = spec->shared_mic_nid;
3866 mutex_lock(&codec->control_mutex);
3867 pval = kcontrol->private_value;
3868 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(nid, ch, 0, dir);
3869 err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
3870 kcontrol->private_value = pval;
3871 mutex_unlock(&codec->control_mutex);
3872 break;
3873 default:
3874 err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
3875 }
3876 return err;
3877 }
3878
3879 static int add_fx_switch(struct hda_codec *codec, hda_nid_t nid,
3880 const char *pfx, int dir)
3881 {
3882 char namestr[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3883 int type = dir ? HDA_INPUT : HDA_OUTPUT;
3884 struct snd_kcontrol_new knew =
3885 CA0132_CODEC_MUTE_MONO(namestr, nid, 1, type);
3886 sprintf(namestr, "%s %s Switch", pfx, dirstr[dir]);
3887 return snd_hda_ctl_add(codec, nid, snd_ctl_new1(&knew, codec));
3888 }
3889
3890 static int add_voicefx(struct hda_codec *codec)
3891 {
3892 struct snd_kcontrol_new knew =
3893 HDA_CODEC_MUTE_MONO(ca0132_voicefx.name,
3894 VOICEFX, 1, 0, HDA_INPUT);
3895 knew.info = ca0132_voicefx_info;
3896 knew.get = ca0132_voicefx_get;
3897 knew.put = ca0132_voicefx_put;
3898 return snd_hda_ctl_add(codec, VOICEFX, snd_ctl_new1(&knew, codec));
3899 }
3900
3901 /*
3902 * When changing Node IDs for Mixer Controls below, make sure to update
3903 * Node IDs in ca0132_config() as well.
3904 */
3905 static struct snd_kcontrol_new ca0132_mixer[] = {
3906 CA0132_CODEC_VOL("Master Playback Volume", VNID_SPK, HDA_OUTPUT),
3907 CA0132_CODEC_MUTE("Master Playback Switch", VNID_SPK, HDA_OUTPUT),
3908 CA0132_CODEC_VOL("Capture Volume", VNID_MIC, HDA_INPUT),
3909 CA0132_CODEC_MUTE("Capture Switch", VNID_MIC, HDA_INPUT),
3910 HDA_CODEC_VOLUME("Analog-Mic2 Capture Volume", 0x08, 0, HDA_INPUT),
3911 HDA_CODEC_MUTE("Analog-Mic2 Capture Switch", 0x08, 0, HDA_INPUT),
3912 HDA_CODEC_VOLUME("What U Hear Capture Volume", 0x0a, 0, HDA_INPUT),
3913 HDA_CODEC_MUTE("What U Hear Capture Switch", 0x0a, 0, HDA_INPUT),
3914 CA0132_CODEC_MUTE_MONO("Mic1-Boost (30dB) Capture Switch",
3915 0x12, 1, HDA_INPUT),
3916 CA0132_CODEC_MUTE_MONO("HP/Speaker Playback Switch",
3917 VNID_HP_SEL, 1, HDA_OUTPUT),
3918 CA0132_CODEC_MUTE_MONO("AMic1/DMic Capture Switch",
3919 VNID_AMIC1_SEL, 1, HDA_INPUT),
3920 CA0132_CODEC_MUTE_MONO("HP/Speaker Auto Detect Playback Switch",
3921 VNID_HP_ASEL, 1, HDA_OUTPUT),
3922 CA0132_CODEC_MUTE_MONO("AMic1/DMic Auto Detect Capture Switch",
3923 VNID_AMIC1_ASEL, 1, HDA_INPUT),
3924 { } /* end */
3925 };
3926
3927 static int ca0132_build_controls(struct hda_codec *codec)
3928 {
3929 struct ca0132_spec *spec = codec->spec;
3930 int i, num_fx;
3931 int err = 0;
3932
3933 /* Add Mixer controls */
3934 for (i = 0; i < spec->num_mixers; i++) {
3935 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
3936 if (err < 0)
3937 return err;
3938 }
3939
3940 /* Add in and out effects controls.
3941 * VoiceFX, PE and CrystalVoice are added separately.
3942 */
3943 num_fx = OUT_EFFECTS_COUNT + IN_EFFECTS_COUNT;
3944 for (i = 0; i < num_fx; i++) {
3945 err = add_fx_switch(codec, ca0132_effects[i].nid,
3946 ca0132_effects[i].name,
3947 ca0132_effects[i].direct);
3948 if (err < 0)
3949 return err;
3950 }
3951
3952 err = add_fx_switch(codec, PLAY_ENHANCEMENT, "PlayEnhancement", 0);
3953 if (err < 0)
3954 return err;
3955
3956 err = add_fx_switch(codec, CRYSTAL_VOICE, "CrystalVoice", 1);
3957 if (err < 0)
3958 return err;
3959
3960 add_voicefx(codec);
3961
3962 #ifdef ENABLE_TUNING_CONTROLS
3963 add_tuning_ctls(codec);
3964 #endif
3965
3966 err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
3967 if (err < 0)
3968 return err;
3969
3970 if (spec->dig_out) {
3971 err = snd_hda_create_spdif_out_ctls(codec, spec->dig_out,
3972 spec->dig_out);
3973 if (err < 0)
3974 return err;
3975 err = snd_hda_create_spdif_share_sw(codec, &spec->multiout);
3976 if (err < 0)
3977 return err;
3978 /* spec->multiout.share_spdif = 1; */
3979 }
3980
3981 if (spec->dig_in) {
3982 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in);
3983 if (err < 0)
3984 return err;
3985 }
3986 return 0;
3987 }
3988
3989 /*
3990 * PCM
3991 */
3992 static struct hda_pcm_stream ca0132_pcm_analog_playback = {
3993 .substreams = 1,
3994 .channels_min = 2,
3995 .channels_max = 6,
3996 .ops = {
3997 .prepare = ca0132_playback_pcm_prepare,
3998 .cleanup = ca0132_playback_pcm_cleanup,
3999 .get_delay = ca0132_playback_pcm_delay,
4000 },
4001 };
4002
4003 static struct hda_pcm_stream ca0132_pcm_analog_capture = {
4004 .substreams = 1,
4005 .channels_min = 2,
4006 .channels_max = 2,
4007 .ops = {
4008 .prepare = ca0132_capture_pcm_prepare,
4009 .cleanup = ca0132_capture_pcm_cleanup,
4010 .get_delay = ca0132_capture_pcm_delay,
4011 },
4012 };
4013
4014 static struct hda_pcm_stream ca0132_pcm_digital_playback = {
4015 .substreams = 1,
4016 .channels_min = 2,
4017 .channels_max = 2,
4018 .ops = {
4019 .open = ca0132_dig_playback_pcm_open,
4020 .close = ca0132_dig_playback_pcm_close,
4021 .prepare = ca0132_dig_playback_pcm_prepare,
4022 .cleanup = ca0132_dig_playback_pcm_cleanup
4023 },
4024 };
4025
4026 static struct hda_pcm_stream ca0132_pcm_digital_capture = {
4027 .substreams = 1,
4028 .channels_min = 2,
4029 .channels_max = 2,
4030 };
4031
4032 static int ca0132_build_pcms(struct hda_codec *codec)
4033 {
4034 struct ca0132_spec *spec = codec->spec;
4035 struct hda_pcm *info = spec->pcm_rec;
4036
4037 codec->pcm_info = info;
4038 codec->num_pcms = 0;
4039
4040 info->name = "CA0132 Analog";
4041 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ca0132_pcm_analog_playback;
4042 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->dacs[0];
4043 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
4044 spec->multiout.max_channels;
4045 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ca0132_pcm_analog_capture;
4046 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 1;
4047 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adcs[0];
4048 codec->num_pcms++;
4049
4050 info++;
4051 info->name = "CA0132 Analog Mic-In2";
4052 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ca0132_pcm_analog_capture;
4053 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 1;
4054 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adcs[1];
4055 codec->num_pcms++;
4056
4057 info++;
4058 info->name = "CA0132 What U Hear";
4059 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ca0132_pcm_analog_capture;
4060 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 1;
4061 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adcs[2];
4062 codec->num_pcms++;
4063
4064 if (!spec->dig_out && !spec->dig_in)
4065 return 0;
4066
4067 info++;
4068 info->name = "CA0132 Digital";
4069 info->pcm_type = HDA_PCM_TYPE_SPDIF;
4070 if (spec->dig_out) {
4071 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4072 ca0132_pcm_digital_playback;
4073 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->dig_out;
4074 }
4075 if (spec->dig_in) {
4076 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4077 ca0132_pcm_digital_capture;
4078 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in;
4079 }
4080 codec->num_pcms++;
4081
4082 return 0;
4083 }
4084
4085 static void init_output(struct hda_codec *codec, hda_nid_t pin, hda_nid_t dac)
4086 {
4087 if (pin) {
4088 snd_hda_set_pin_ctl(codec, pin, PIN_HP);
4089 if (get_wcaps(codec, pin) & AC_WCAP_OUT_AMP)
4090 snd_hda_codec_write(codec, pin, 0,
4091 AC_VERB_SET_AMP_GAIN_MUTE,
4092 AMP_OUT_UNMUTE);
4093 }
4094 if (dac && (get_wcaps(codec, dac) & AC_WCAP_OUT_AMP))
4095 snd_hda_codec_write(codec, dac, 0,
4096 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO);
4097 }
4098
4099 static void init_input(struct hda_codec *codec, hda_nid_t pin, hda_nid_t adc)
4100 {
4101 if (pin) {
4102 snd_hda_set_pin_ctl(codec, pin, PIN_VREF80);
4103 if (get_wcaps(codec, pin) & AC_WCAP_IN_AMP)
4104 snd_hda_codec_write(codec, pin, 0,
4105 AC_VERB_SET_AMP_GAIN_MUTE,
4106 AMP_IN_UNMUTE(0));
4107 }
4108 if (adc && (get_wcaps(codec, adc) & AC_WCAP_IN_AMP)) {
4109 snd_hda_codec_write(codec, adc, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4110 AMP_IN_UNMUTE(0));
4111
4112 /* init to 0 dB and unmute. */
4113 snd_hda_codec_amp_stereo(codec, adc, HDA_INPUT, 0,
4114 HDA_AMP_VOLMASK, 0x5a);
4115 snd_hda_codec_amp_stereo(codec, adc, HDA_INPUT, 0,
4116 HDA_AMP_MUTE, 0);
4117 }
4118 }
4119
4120 static void ca0132_init_unsol(struct hda_codec *codec)
4121 {
4122 snd_hda_jack_detect_enable(codec, UNSOL_TAG_HP, UNSOL_TAG_HP);
4123 snd_hda_jack_detect_enable(codec, UNSOL_TAG_AMIC1, UNSOL_TAG_AMIC1);
4124 }
4125
4126 static void refresh_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir)
4127 {
4128 unsigned int caps;
4129
4130 caps = snd_hda_param_read(codec, nid, dir == HDA_OUTPUT ?
4131 AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
4132 snd_hda_override_amp_caps(codec, nid, dir, caps);
4133 }
4134
4135 /*
4136 * Switch between Digital built-in mic and analog mic.
4137 */
4138 static void ca0132_set_dmic(struct hda_codec *codec, int enable)
4139 {
4140 struct ca0132_spec *spec = codec->spec;
4141 unsigned int tmp;
4142 u8 val;
4143 unsigned int oldval;
4144
4145 snd_printdd(KERN_INFO "ca0132_set_dmic: enable=%d\n", enable);
4146
4147 oldval = stop_mic1(codec);
4148 ca0132_set_vipsource(codec, 0);
4149 if (enable) {
4150 /* set DMic input as 2-ch */
4151 tmp = FLOAT_TWO;
4152 dspio_set_uint_param(codec, 0x80, 0x00, tmp);
4153
4154 val = spec->dmic_ctl;
4155 val |= 0x80;
4156 snd_hda_codec_write(codec, spec->input_pins[0], 0,
4157 VENDOR_CHIPIO_DMIC_CTL_SET, val);
4158
4159 if (!(spec->dmic_ctl & 0x20))
4160 chipio_set_control_flag(codec, CONTROL_FLAG_DMIC, 1);
4161 } else {
4162 /* set AMic input as mono */
4163 tmp = FLOAT_ONE;
4164 dspio_set_uint_param(codec, 0x80, 0x00, tmp);
4165
4166 val = spec->dmic_ctl;
4167 /* clear bit7 and bit5 to disable dmic */
4168 val &= 0x5f;
4169 snd_hda_codec_write(codec, spec->input_pins[0], 0,
4170 VENDOR_CHIPIO_DMIC_CTL_SET, val);
4171
4172 if (!(spec->dmic_ctl & 0x20))
4173 chipio_set_control_flag(codec, CONTROL_FLAG_DMIC, 0);
4174 }
4175 ca0132_set_vipsource(codec, 1);
4176 resume_mic1(codec, oldval);
4177 }
4178
4179 /*
4180 * Initialization for Digital Mic.
4181 */
4182 static void ca0132_init_dmic(struct hda_codec *codec)
4183 {
4184 struct ca0132_spec *spec = codec->spec;
4185 u8 val;
4186
4187 /* Setup Digital Mic here, but don't enable.
4188 * Enable based on jack detect.
4189 */
4190
4191 /* MCLK uses MPIO1, set to enable.
4192 * Bit 2-0: MPIO select
4193 * Bit 3: set to disable
4194 * Bit 7-4: reserved
4195 */
4196 val = 0x01;
4197 snd_hda_codec_write(codec, spec->input_pins[0], 0,
4198 VENDOR_CHIPIO_DMIC_MCLK_SET, val);
4199
4200 /* Data1 uses MPIO3. Data2 not use
4201 * Bit 2-0: Data1 MPIO select
4202 * Bit 3: set disable Data1
4203 * Bit 6-4: Data2 MPIO select
4204 * Bit 7: set disable Data2
4205 */
4206 val = 0x83;
4207 snd_hda_codec_write(codec, spec->input_pins[0], 0,
4208 VENDOR_CHIPIO_DMIC_PIN_SET, val);
4209
4210 /* Use Ch-0 and Ch-1. Rate is 48K, mode 1. Disable DMic first.
4211 * Bit 3-0: Channel mask
4212 * Bit 4: set for 48KHz, clear for 32KHz
4213 * Bit 5: mode
4214 * Bit 6: set to select Data2, clear for Data1
4215 * Bit 7: set to enable DMic, clear for AMic
4216 */
4217 val = 0x23;
4218 /* keep a copy of dmic ctl val for enable/disable dmic purpuse */
4219 spec->dmic_ctl = val;
4220 snd_hda_codec_write(codec, spec->input_pins[0], 0,
4221 VENDOR_CHIPIO_DMIC_CTL_SET, val);
4222 }
4223
4224 /*
4225 * Initialization for Analog Mic 2
4226 */
4227 static void ca0132_init_analog_mic2(struct hda_codec *codec)
4228 {
4229 struct ca0132_spec *spec = codec->spec;
4230
4231 mutex_lock(&spec->chipio_mutex);
4232 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
4233 VENDOR_CHIPIO_8051_ADDRESS_LOW, 0x20);
4234 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
4235 VENDOR_CHIPIO_8051_ADDRESS_HIGH, 0x19);
4236 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
4237 VENDOR_CHIPIO_8051_DATA_WRITE, 0x00);
4238 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
4239 VENDOR_CHIPIO_8051_ADDRESS_LOW, 0x2D);
4240 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
4241 VENDOR_CHIPIO_8051_ADDRESS_HIGH, 0x19);
4242 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
4243 VENDOR_CHIPIO_8051_DATA_WRITE, 0x00);
4244 mutex_unlock(&spec->chipio_mutex);
4245 }
4246
4247 static void ca0132_refresh_widget_caps(struct hda_codec *codec)
4248 {
4249 struct ca0132_spec *spec = codec->spec;
4250 int i;
4251 hda_nid_t nid;
4252
4253 snd_printdd(KERN_INFO "ca0132_refresh_widget_caps.\n");
4254 nid = codec->start_nid;
4255 for (i = 0; i < codec->num_nodes; i++, nid++)
4256 codec->wcaps[i] = snd_hda_param_read(codec, nid,
4257 AC_PAR_AUDIO_WIDGET_CAP);
4258
4259 for (i = 0; i < spec->multiout.num_dacs; i++)
4260 refresh_amp_caps(codec, spec->dacs[i], HDA_OUTPUT);
4261
4262 for (i = 0; i < spec->num_outputs; i++)
4263 refresh_amp_caps(codec, spec->out_pins[i], HDA_OUTPUT);
4264
4265 for (i = 0; i < spec->num_inputs; i++) {
4266 refresh_amp_caps(codec, spec->adcs[i], HDA_INPUT);
4267 refresh_amp_caps(codec, spec->input_pins[i], HDA_INPUT);
4268 }
4269 }
4270
4271 /*
4272 * Setup default parameters for DSP
4273 */
4274 static void ca0132_setup_defaults(struct hda_codec *codec)
4275 {
4276 struct ca0132_spec *spec = codec->spec;
4277 unsigned int tmp;
4278 int num_fx;
4279 int idx, i;
4280
4281 if (spec->dsp_state != DSP_DOWNLOADED)
4282 return;
4283
4284 /* out, in effects + voicefx */
4285 num_fx = OUT_EFFECTS_COUNT + IN_EFFECTS_COUNT + 1;
4286 for (idx = 0; idx < num_fx; idx++) {
4287 for (i = 0; i <= ca0132_effects[idx].params; i++) {
4288 dspio_set_uint_param(codec, ca0132_effects[idx].mid,
4289 ca0132_effects[idx].reqs[i],
4290 ca0132_effects[idx].def_vals[i]);
4291 }
4292 }
4293
4294 /*remove DSP headroom*/
4295 tmp = FLOAT_ZERO;
4296 dspio_set_uint_param(codec, 0x96, 0x3C, tmp);
4297
4298 /*set speaker EQ bypass attenuation*/
4299 dspio_set_uint_param(codec, 0x8f, 0x01, tmp);
4300
4301 /* set AMic1 and AMic2 as mono mic */
4302 tmp = FLOAT_ONE;
4303 dspio_set_uint_param(codec, 0x80, 0x00, tmp);
4304 dspio_set_uint_param(codec, 0x80, 0x01, tmp);
4305
4306 /* set AMic1 as CrystalVoice input */
4307 tmp = FLOAT_ONE;
4308 dspio_set_uint_param(codec, 0x80, 0x05, tmp);
4309
4310 /* set WUH source */
4311 tmp = FLOAT_TWO;
4312 dspio_set_uint_param(codec, 0x31, 0x00, tmp);
4313 }
4314
4315 /*
4316 * Initialization of flags in chip
4317 */
4318 static void ca0132_init_flags(struct hda_codec *codec)
4319 {
4320 chipio_set_control_flag(codec, CONTROL_FLAG_IDLE_ENABLE, 0);
4321 chipio_set_control_flag(codec, CONTROL_FLAG_PORT_A_COMMON_MODE, 0);
4322 chipio_set_control_flag(codec, CONTROL_FLAG_PORT_D_COMMON_MODE, 0);
4323 chipio_set_control_flag(codec, CONTROL_FLAG_PORT_A_10KOHM_LOAD, 0);
4324 chipio_set_control_flag(codec, CONTROL_FLAG_PORT_D_10KOHM_LOAD, 0);
4325 chipio_set_control_flag(codec, CONTROL_FLAG_ADC_C_HIGH_PASS, 1);
4326 }
4327
4328 /*
4329 * Initialization of parameters in chip
4330 */
4331 static void ca0132_init_params(struct hda_codec *codec)
4332 {
4333 chipio_set_control_param(codec, CONTROL_PARAM_PORTA_160OHM_GAIN, 6);
4334 chipio_set_control_param(codec, CONTROL_PARAM_PORTD_160OHM_GAIN, 6);
4335 }
4336
4337 static void ca0132_set_dsp_msr(struct hda_codec *codec, bool is96k)
4338 {
4339 chipio_set_control_flag(codec, CONTROL_FLAG_DSP_96KHZ, is96k);
4340 chipio_set_control_flag(codec, CONTROL_FLAG_DAC_96KHZ, is96k);
4341 chipio_set_control_flag(codec, CONTROL_FLAG_SRC_RATE_96KHZ, is96k);
4342 chipio_set_control_flag(codec, CONTROL_FLAG_SRC_CLOCK_196MHZ, is96k);
4343 chipio_set_control_flag(codec, CONTROL_FLAG_ADC_B_96KHZ, is96k);
4344 chipio_set_control_flag(codec, CONTROL_FLAG_ADC_C_96KHZ, is96k);
4345
4346 chipio_set_conn_rate(codec, MEM_CONNID_MICIN1, SR_96_000);
4347 chipio_set_conn_rate(codec, MEM_CONNID_MICOUT1, SR_96_000);
4348 chipio_set_conn_rate(codec, MEM_CONNID_WUH, SR_48_000);
4349 }
4350
4351 static bool ca0132_download_dsp_images(struct hda_codec *codec)
4352 {
4353 bool dsp_loaded = false;
4354 const struct dsp_image_seg *dsp_os_image;
4355 const struct firmware *fw_entry;
4356
4357 if (request_firmware(&fw_entry, EFX_FILE, codec->bus->card->dev) != 0)
4358 return false;
4359
4360 dsp_os_image = (struct dsp_image_seg *)(fw_entry->data);
4361 if (dspload_image(codec, dsp_os_image, 0, 0, true, 0)) {
4362 pr_err("ca0132 dspload_image failed.\n");
4363 goto exit_download;
4364 }
4365
4366 dsp_loaded = dspload_wait_loaded(codec);
4367
4368 exit_download:
4369 release_firmware(fw_entry);
4370
4371 return dsp_loaded;
4372 }
4373
4374 static void ca0132_download_dsp(struct hda_codec *codec)
4375 {
4376 struct ca0132_spec *spec = codec->spec;
4377
4378 #ifndef CONFIG_SND_HDA_CODEC_CA0132_DSP
4379 return; /* NOP */
4380 #endif
4381
4382 if (spec->dsp_state == DSP_DOWNLOAD_FAILED)
4383 return; /* don't retry failures */
4384
4385 chipio_enable_clocks(codec);
4386 spec->dsp_state = DSP_DOWNLOADING;
4387 if (!ca0132_download_dsp_images(codec))
4388 spec->dsp_state = DSP_DOWNLOAD_FAILED;
4389 else
4390 spec->dsp_state = DSP_DOWNLOADED;
4391
4392 if (spec->dsp_state == DSP_DOWNLOADED)
4393 ca0132_set_dsp_msr(codec, true);
4394 }
4395
4396 static void ca0132_process_dsp_response(struct hda_codec *codec)
4397 {
4398 struct ca0132_spec *spec = codec->spec;
4399
4400 snd_printdd(KERN_INFO "ca0132_process_dsp_response\n");
4401 if (spec->wait_scp) {
4402 if (dspio_get_response_data(codec) >= 0)
4403 spec->wait_scp = 0;
4404 }
4405
4406 dspio_clear_response_queue(codec);
4407 }
4408
4409 static void ca0132_unsol_event(struct hda_codec *codec, unsigned int res)
4410 {
4411 struct ca0132_spec *spec = codec->spec;
4412
4413 if (((res >> AC_UNSOL_RES_TAG_SHIFT) & 0x3f) == UNSOL_TAG_DSP) {
4414 ca0132_process_dsp_response(codec);
4415 } else {
4416 res = snd_hda_jack_get_action(codec,
4417 (res >> AC_UNSOL_RES_TAG_SHIFT) & 0x3f);
4418
4419 snd_printdd(KERN_INFO "snd_hda_jack_get_action: 0x%x\n", res);
4420
4421 switch (res) {
4422 case UNSOL_TAG_HP:
4423 /* Delay enabling the HP amp, to let the mic-detection
4424 * state machine run.
4425 */
4426 cancel_delayed_work_sync(&spec->unsol_hp_work);
4427 queue_delayed_work(codec->bus->workq,
4428 &spec->unsol_hp_work,
4429 msecs_to_jiffies(500));
4430 break;
4431 case UNSOL_TAG_AMIC1:
4432 ca0132_select_mic(codec);
4433 snd_hda_jack_report_sync(codec);
4434 break;
4435 default:
4436 break;
4437 }
4438 }
4439 }
4440
4441 /*
4442 * Verbs tables.
4443 */
4444
4445 /* Sends before DSP download. */
4446 static struct hda_verb ca0132_base_init_verbs[] = {
4447 /*enable ct extension*/
4448 {0x15, VENDOR_CHIPIO_CT_EXTENSIONS_ENABLE, 0x1},
4449 /*enable DSP node unsol, needed for DSP download*/
4450 {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | UNSOL_TAG_DSP},
4451 {}
4452 };
4453
4454 /* Send at exit. */
4455 static struct hda_verb ca0132_base_exit_verbs[] = {
4456 /*set afg to D3*/
4457 {0x01, AC_VERB_SET_POWER_STATE, 0x03},
4458 /*disable ct extension*/
4459 {0x15, VENDOR_CHIPIO_CT_EXTENSIONS_ENABLE, 0},
4460 {}
4461 };
4462
4463 /* Other verbs tables. Sends after DSP download. */
4464 static struct hda_verb ca0132_init_verbs0[] = {
4465 /* chip init verbs */
4466 {0x15, 0x70D, 0xF0},
4467 {0x15, 0x70E, 0xFE},
4468 {0x15, 0x707, 0x75},
4469 {0x15, 0x707, 0xD3},
4470 {0x15, 0x707, 0x09},
4471 {0x15, 0x707, 0x53},
4472 {0x15, 0x707, 0xD4},
4473 {0x15, 0x707, 0xEF},
4474 {0x15, 0x707, 0x75},
4475 {0x15, 0x707, 0xD3},
4476 {0x15, 0x707, 0x09},
4477 {0x15, 0x707, 0x02},
4478 {0x15, 0x707, 0x37},
4479 {0x15, 0x707, 0x78},
4480 {0x15, 0x53C, 0xCE},
4481 {0x15, 0x575, 0xC9},
4482 {0x15, 0x53D, 0xCE},
4483 {0x15, 0x5B7, 0xC9},
4484 {0x15, 0x70D, 0xE8},
4485 {0x15, 0x70E, 0xFE},
4486 {0x15, 0x707, 0x02},
4487 {0x15, 0x707, 0x68},
4488 {0x15, 0x707, 0x62},
4489 {0x15, 0x53A, 0xCE},
4490 {0x15, 0x546, 0xC9},
4491 {0x15, 0x53B, 0xCE},
4492 {0x15, 0x5E8, 0xC9},
4493 {0x15, 0x717, 0x0D},
4494 {0x15, 0x718, 0x20},
4495 {}
4496 };
4497
4498 static struct hda_verb ca0132_init_verbs1[] = {
4499 {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | UNSOL_TAG_HP},
4500 {0x12, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | UNSOL_TAG_AMIC1},
4501 /* config EAPD */
4502 {0x0b, 0x78D, 0x00},
4503 /*{0x0b, AC_VERB_SET_EAPD_BTLENABLE, 0x02},*/
4504 /*{0x10, 0x78D, 0x02},*/
4505 /*{0x10, AC_VERB_SET_EAPD_BTLENABLE, 0x02},*/
4506 {}
4507 };
4508
4509 static void ca0132_init_chip(struct hda_codec *codec)
4510 {
4511 struct ca0132_spec *spec = codec->spec;
4512 int num_fx;
4513 int i;
4514 unsigned int on;
4515
4516 mutex_init(&spec->chipio_mutex);
4517
4518 spec->cur_out_type = SPEAKER_OUT;
4519 spec->cur_mic_type = DIGITAL_MIC;
4520 spec->cur_mic_boost = 0;
4521
4522 for (i = 0; i < VNODES_COUNT; i++) {
4523 spec->vnode_lvol[i] = 0x5a;
4524 spec->vnode_rvol[i] = 0x5a;
4525 spec->vnode_lswitch[i] = 0;
4526 spec->vnode_rswitch[i] = 0;
4527 }
4528
4529 /*
4530 * Default states for effects are in ca0132_effects[].
4531 */
4532 num_fx = OUT_EFFECTS_COUNT + IN_EFFECTS_COUNT;
4533 for (i = 0; i < num_fx; i++) {
4534 on = (unsigned int)ca0132_effects[i].reqs[0];
4535 spec->effects_switch[i] = on ? 1 : 0;
4536 }
4537
4538 spec->voicefx_val = 0;
4539 spec->effects_switch[PLAY_ENHANCEMENT - EFFECT_START_NID] = 1;
4540 spec->effects_switch[CRYSTAL_VOICE - EFFECT_START_NID] = 0;
4541
4542 #ifdef ENABLE_TUNING_CONTROLS
4543 ca0132_init_tuning_defaults(codec);
4544 #endif
4545 }
4546
4547 static void ca0132_exit_chip(struct hda_codec *codec)
4548 {
4549 /* put any chip cleanup stuffs here. */
4550
4551 if (dspload_is_loaded(codec))
4552 dsp_reset(codec);
4553 }
4554
4555 static int ca0132_init(struct hda_codec *codec)
4556 {
4557 struct ca0132_spec *spec = codec->spec;
4558 struct auto_pin_cfg *cfg = &spec->autocfg;
4559 int i;
4560
4561 if (spec->dsp_state != DSP_DOWNLOAD_FAILED)
4562 spec->dsp_state = DSP_DOWNLOAD_INIT;
4563 spec->curr_chip_addx = INVALID_CHIP_ADDRESS;
4564
4565 snd_hda_power_up(codec);
4566
4567 ca0132_init_params(codec);
4568 ca0132_init_flags(codec);
4569 snd_hda_sequence_write(codec, spec->base_init_verbs);
4570 ca0132_download_dsp(codec);
4571 ca0132_refresh_widget_caps(codec);
4572 ca0132_setup_defaults(codec);
4573 ca0132_init_analog_mic2(codec);
4574 ca0132_init_dmic(codec);
4575
4576 for (i = 0; i < spec->num_outputs; i++)
4577 init_output(codec, spec->out_pins[i], spec->dacs[0]);
4578
4579 init_output(codec, cfg->dig_out_pins[0], spec->dig_out);
4580
4581 for (i = 0; i < spec->num_inputs; i++)
4582 init_input(codec, spec->input_pins[i], spec->adcs[i]);
4583
4584 init_input(codec, cfg->dig_in_pin, spec->dig_in);
4585
4586 for (i = 0; i < spec->num_init_verbs; i++)
4587 snd_hda_sequence_write(codec, spec->init_verbs[i]);
4588
4589 ca0132_init_unsol(codec);
4590
4591 ca0132_select_out(codec);
4592 ca0132_select_mic(codec);
4593
4594 snd_hda_jack_report_sync(codec);
4595
4596 snd_hda_power_down(codec);
4597
4598 return 0;
4599 }
4600
4601 static void ca0132_free(struct hda_codec *codec)
4602 {
4603 struct ca0132_spec *spec = codec->spec;
4604
4605 cancel_delayed_work_sync(&spec->unsol_hp_work);
4606 snd_hda_power_up(codec);
4607 snd_hda_sequence_write(codec, spec->base_exit_verbs);
4608 ca0132_exit_chip(codec);
4609 snd_hda_power_down(codec);
4610 kfree(codec->spec);
4611 }
4612
4613 static struct hda_codec_ops ca0132_patch_ops = {
4614 .build_controls = ca0132_build_controls,
4615 .build_pcms = ca0132_build_pcms,
4616 .init = ca0132_init,
4617 .free = ca0132_free,
4618 .unsol_event = ca0132_unsol_event,
4619 };
4620
4621 static void ca0132_config(struct hda_codec *codec)
4622 {
4623 struct ca0132_spec *spec = codec->spec;
4624 struct auto_pin_cfg *cfg = &spec->autocfg;
4625
4626 spec->dacs[0] = 0x2;
4627 spec->dacs[1] = 0x3;
4628 spec->dacs[2] = 0x4;
4629
4630 spec->multiout.dac_nids = spec->dacs;
4631 spec->multiout.num_dacs = 3;
4632 spec->multiout.max_channels = 2;
4633
4634 spec->num_outputs = 2;
4635 spec->out_pins[0] = 0x0b; /* speaker out */
4636 spec->out_pins[1] = 0x10; /* headphone out */
4637 spec->shared_out_nid = 0x2;
4638
4639 spec->num_inputs = 3;
4640 spec->adcs[0] = 0x7; /* digital mic / analog mic1 */
4641 spec->adcs[1] = 0x8; /* analog mic2 */
4642 spec->adcs[2] = 0xa; /* what u hear */
4643 spec->shared_mic_nid = 0x7;
4644
4645 spec->input_pins[0] = 0x12;
4646 spec->input_pins[1] = 0x11;
4647 spec->input_pins[2] = 0x13;
4648
4649 /* SPDIF I/O */
4650 spec->dig_out = 0x05;
4651 spec->multiout.dig_out_nid = spec->dig_out;
4652 cfg->dig_out_pins[0] = 0x0c;
4653 cfg->dig_outs = 1;
4654 cfg->dig_out_type[0] = HDA_PCM_TYPE_SPDIF;
4655 spec->dig_in = 0x09;
4656 cfg->dig_in_pin = 0x0e;
4657 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
4658 }
4659
4660 static int patch_ca0132(struct hda_codec *codec)
4661 {
4662 struct ca0132_spec *spec;
4663 int err;
4664
4665 snd_printdd("patch_ca0132\n");
4666
4667 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4668 if (!spec)
4669 return -ENOMEM;
4670 codec->spec = spec;
4671 spec->codec = codec;
4672
4673 spec->dsp_state = DSP_DOWNLOAD_INIT;
4674 spec->num_mixers = 1;
4675 spec->mixers[0] = ca0132_mixer;
4676
4677 spec->base_init_verbs = ca0132_base_init_verbs;
4678 spec->base_exit_verbs = ca0132_base_exit_verbs;
4679 spec->init_verbs[0] = ca0132_init_verbs0;
4680 spec->init_verbs[1] = ca0132_init_verbs1;
4681 spec->num_init_verbs = 2;
4682
4683 INIT_DELAYED_WORK(&spec->unsol_hp_work, ca0132_unsol_hp_delayed);
4684
4685 ca0132_init_chip(codec);
4686
4687 ca0132_config(codec);
4688
4689 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
4690 if (err < 0)
4691 return err;
4692
4693 codec->patch_ops = ca0132_patch_ops;
4694 codec->pcm_format_first = 1;
4695 codec->no_sticky_stream = 1;
4696
4697 return 0;
4698 }
4699
4700 /*
4701 * patch entries
4702 */
4703 static struct hda_codec_preset snd_hda_preset_ca0132[] = {
4704 { .id = 0x11020011, .name = "CA0132", .patch = patch_ca0132 },
4705 {} /* terminator */
4706 };
4707
4708 MODULE_ALIAS("snd-hda-codec-id:11020011");
4709
4710 MODULE_LICENSE("GPL");
4711 MODULE_DESCRIPTION("Creative Sound Core3D codec");
4712
4713 static struct hda_codec_preset_list ca0132_list = {
4714 .preset = snd_hda_preset_ca0132,
4715 .owner = THIS_MODULE,
4716 };
4717
4718 static int __init patch_ca0132_init(void)
4719 {
4720 return snd_hda_add_codec_preset(&ca0132_list);
4721 }
4722
4723 static void __exit patch_ca0132_exit(void)
4724 {
4725 snd_hda_delete_codec_preset(&ca0132_list);
4726 }
4727
4728 module_init(patch_ca0132_init)
4729 module_exit(patch_ca0132_exit)
Linux with added FPC-III support