2 * ALSA driver for AK4524 / AK4528 / AK4529 / AK4355 / AK4358 / AK4381
5 * Copyright (c) 2000-2004 Jaroslav Kysela <perex@perex.cz>,
6 * Takashi Iwai <tiwai@suse.de>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include <sound/driver.h>
26 #include <linux/delay.h>
27 #include <linux/interrupt.h>
28 #include <linux/init.h>
29 #include <sound/core.h>
30 #include <sound/control.h>
31 #include <sound/tlv.h>
32 #include <sound/ak4xxx-adda.h>
34 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Takashi Iwai <tiwai@suse.de>");
35 MODULE_DESCRIPTION("Routines for control of AK452x / AK43xx AD/DA converters");
36 MODULE_LICENSE("GPL");
38 /* write the given register and save the data to the cache */
39 void snd_akm4xxx_write(struct snd_akm4xxx
*ak
, int chip
, unsigned char reg
,
42 ak
->ops
.lock(ak
, chip
);
43 ak
->ops
.write(ak
, chip
, reg
, val
);
46 snd_akm4xxx_set(ak
, chip
, reg
, val
);
47 ak
->ops
.unlock(ak
, chip
);
50 EXPORT_SYMBOL(snd_akm4xxx_write
);
52 /* reset procedure for AK4524 and AK4528 */
53 static void ak4524_reset(struct snd_akm4xxx
*ak
, int state
)
56 unsigned char reg
, maxreg
;
58 if (ak
->type
== SND_AK4528
)
62 for (chip
= 0; chip
< ak
->num_dacs
/2; chip
++) {
63 snd_akm4xxx_write(ak
, chip
, 0x01, state
? 0x00 : 0x03);
67 for (reg
= 0x04; reg
< maxreg
; reg
++)
68 snd_akm4xxx_write(ak
, chip
, reg
,
69 snd_akm4xxx_get(ak
, chip
, reg
));
73 /* reset procedure for AK4355 and AK4358 */
74 static void ak4355_reset(struct snd_akm4xxx
*ak
, int state
)
79 snd_akm4xxx_write(ak
, 0, 0x01, 0x02); /* reset and soft-mute */
82 for (reg
= 0x00; reg
< 0x0b; reg
++)
84 snd_akm4xxx_write(ak
, 0, reg
,
85 snd_akm4xxx_get(ak
, 0, reg
));
86 snd_akm4xxx_write(ak
, 0, 0x01, 0x01); /* un-reset, unmute */
89 /* reset procedure for AK4381 */
90 static void ak4381_reset(struct snd_akm4xxx
*ak
, int state
)
95 for (chip
= 0; chip
< ak
->num_dacs
/2; chip
++) {
96 snd_akm4xxx_write(ak
, chip
, 0x00, state
? 0x0c : 0x0f);
99 for (reg
= 0x01; reg
< 0x05; reg
++)
100 snd_akm4xxx_write(ak
, chip
, reg
,
101 snd_akm4xxx_get(ak
, chip
, reg
));
106 * reset the AKM codecs
107 * @state: 1 = reset codec, 0 = restore the registers
109 * assert the reset operation and restores the register values to the chips.
111 void snd_akm4xxx_reset(struct snd_akm4xxx
*ak
, int state
)
116 ak4524_reset(ak
, state
);
119 /* FIXME: needed for ak4529? */
123 ak4355_reset(ak
, state
);
126 ak4381_reset(ak
, state
);
133 EXPORT_SYMBOL(snd_akm4xxx_reset
);
137 * Volume conversion table for non-linear volumes
138 * from -63.5dB (mute) to 0dB step 0.5dB
140 * Used for AK4524 input/ouput attenuation, AK4528, and
141 * AK5365 input attenuation
143 static const unsigned char vol_cvt_datt
[128] = {
144 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04,
145 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x06, 0x06,
146 0x06, 0x07, 0x07, 0x08, 0x08, 0x08, 0x09, 0x0a,
147 0x0a, 0x0b, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x0f,
148 0x10, 0x10, 0x11, 0x12, 0x12, 0x13, 0x13, 0x14,
149 0x15, 0x16, 0x17, 0x17, 0x18, 0x19, 0x1a, 0x1c,
150 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x23,
151 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a, 0x2b, 0x2d,
152 0x2e, 0x30, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
153 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3e, 0x3f, 0x40,
154 0x41, 0x42, 0x43, 0x44, 0x46, 0x47, 0x48, 0x4a,
155 0x4b, 0x4d, 0x4e, 0x50, 0x51, 0x52, 0x53, 0x54,
156 0x55, 0x56, 0x58, 0x59, 0x5b, 0x5c, 0x5e, 0x5f,
157 0x60, 0x61, 0x62, 0x64, 0x65, 0x66, 0x67, 0x69,
158 0x6a, 0x6c, 0x6d, 0x6f, 0x70, 0x71, 0x72, 0x73,
159 0x75, 0x76, 0x77, 0x79, 0x7a, 0x7c, 0x7d, 0x7f,
165 static const DECLARE_TLV_DB_SCALE(db_scale_vol_datt
, -6350, 50, 1);
166 static const DECLARE_TLV_DB_SCALE(db_scale_8bit
, -12750, 50, 1);
167 static const DECLARE_TLV_DB_SCALE(db_scale_7bit
, -6350, 50, 1);
168 static const DECLARE_TLV_DB_LINEAR(db_scale_linear
, TLV_DB_GAIN_MUTE
, 0);
171 * initialize all the ak4xxx chips
173 void snd_akm4xxx_init(struct snd_akm4xxx
*ak
)
175 static const unsigned char inits_ak4524
[] = {
176 0x00, 0x07, /* 0: all power up */
177 0x01, 0x00, /* 1: ADC/DAC reset */
178 0x02, 0x60, /* 2: 24bit I2S */
179 0x03, 0x19, /* 3: deemphasis off */
180 0x01, 0x03, /* 1: ADC/DAC enable */
181 0x04, 0x00, /* 4: ADC left muted */
182 0x05, 0x00, /* 5: ADC right muted */
183 0x06, 0x00, /* 6: DAC left muted */
184 0x07, 0x00, /* 7: DAC right muted */
187 static const unsigned char inits_ak4528
[] = {
188 0x00, 0x07, /* 0: all power up */
189 0x01, 0x00, /* 1: ADC/DAC reset */
190 0x02, 0x60, /* 2: 24bit I2S */
191 0x03, 0x0d, /* 3: deemphasis off, turn LR highpass filters on */
192 0x01, 0x03, /* 1: ADC/DAC enable */
193 0x04, 0x00, /* 4: ADC left muted */
194 0x05, 0x00, /* 5: ADC right muted */
197 static const unsigned char inits_ak4529
[] = {
198 0x09, 0x01, /* 9: ATS=0, RSTN=1 */
199 0x0a, 0x3f, /* A: all power up, no zero/overflow detection */
200 0x00, 0x0c, /* 0: TDM=0, 24bit I2S, SMUTE=0 */
201 0x01, 0x00, /* 1: ACKS=0, ADC, loop off */
202 0x02, 0xff, /* 2: LOUT1 muted */
203 0x03, 0xff, /* 3: ROUT1 muted */
204 0x04, 0xff, /* 4: LOUT2 muted */
205 0x05, 0xff, /* 5: ROUT2 muted */
206 0x06, 0xff, /* 6: LOUT3 muted */
207 0x07, 0xff, /* 7: ROUT3 muted */
208 0x0b, 0xff, /* B: LOUT4 muted */
209 0x0c, 0xff, /* C: ROUT4 muted */
210 0x08, 0x55, /* 8: deemphasis all off */
213 static const unsigned char inits_ak4355
[] = {
214 0x01, 0x02, /* 1: reset and soft-mute */
215 0x00, 0x06, /* 0: mode3(i2s), disable auto-clock detect,
216 * disable DZF, sharp roll-off, RSTN#=0 */
217 0x02, 0x0e, /* 2: DA's power up, normal speed, RSTN#=0 */
218 // 0x02, 0x2e, /* quad speed */
219 0x03, 0x01, /* 3: de-emphasis off */
220 0x04, 0x00, /* 4: LOUT1 volume muted */
221 0x05, 0x00, /* 5: ROUT1 volume muted */
222 0x06, 0x00, /* 6: LOUT2 volume muted */
223 0x07, 0x00, /* 7: ROUT2 volume muted */
224 0x08, 0x00, /* 8: LOUT3 volume muted */
225 0x09, 0x00, /* 9: ROUT3 volume muted */
226 0x0a, 0x00, /* a: DATT speed=0, ignore DZF */
227 0x01, 0x01, /* 1: un-reset, unmute */
230 static const unsigned char inits_ak4358
[] = {
231 0x01, 0x02, /* 1: reset and soft-mute */
232 0x00, 0x06, /* 0: mode3(i2s), disable auto-clock detect,
233 * disable DZF, sharp roll-off, RSTN#=0 */
234 0x02, 0x0e, /* 2: DA's power up, normal speed, RSTN#=0 */
235 // 0x02, 0x2e, /* quad speed */
236 0x03, 0x01, /* 3: de-emphasis off */
237 0x04, 0x00, /* 4: LOUT1 volume muted */
238 0x05, 0x00, /* 5: ROUT1 volume muted */
239 0x06, 0x00, /* 6: LOUT2 volume muted */
240 0x07, 0x00, /* 7: ROUT2 volume muted */
241 0x08, 0x00, /* 8: LOUT3 volume muted */
242 0x09, 0x00, /* 9: ROUT3 volume muted */
243 0x0b, 0x00, /* b: LOUT4 volume muted */
244 0x0c, 0x00, /* c: ROUT4 volume muted */
245 0x0a, 0x00, /* a: DATT speed=0, ignore DZF */
246 0x01, 0x01, /* 1: un-reset, unmute */
249 static const unsigned char inits_ak4381
[] = {
250 0x00, 0x0c, /* 0: mode3(i2s), disable auto-clock detect */
251 0x01, 0x02, /* 1: de-emphasis off, normal speed,
252 * sharp roll-off, DZF off */
253 // 0x01, 0x12, /* quad speed */
254 0x02, 0x00, /* 2: DZF disabled */
255 0x03, 0x00, /* 3: LATT 0 */
256 0x04, 0x00, /* 4: RATT 0 */
257 0x00, 0x0f, /* 0: power-up, un-reset */
262 const unsigned char *ptr
, *inits
;
263 unsigned char reg
, data
;
265 memset(ak
->images
, 0, sizeof(ak
->images
));
266 memset(ak
->volumes
, 0, sizeof(ak
->volumes
));
270 inits
= inits_ak4524
;
271 num_chips
= ak
->num_dacs
/ 2;
274 inits
= inits_ak4528
;
275 num_chips
= ak
->num_dacs
/ 2;
278 inits
= inits_ak4529
;
282 inits
= inits_ak4355
;
286 inits
= inits_ak4358
;
290 inits
= inits_ak4381
;
291 num_chips
= ak
->num_dacs
/ 2;
294 /* FIXME: any init sequence? */
297 /* fake value for non-akm codecs using akm infrastructure
298 * (e.g. of ice1724) - certainly FIXME
306 for (chip
= 0; chip
< num_chips
; chip
++) {
308 while (*ptr
!= 0xff) {
311 snd_akm4xxx_write(ak
, chip
, reg
, data
);
316 EXPORT_SYMBOL(snd_akm4xxx_init
);
321 #define AK_IPGA (1<<20) /* including IPGA */
322 #define AK_VOL_CVT (1<<21) /* need dB conversion */
323 #define AK_NEEDSMSB (1<<22) /* need MSB update bit */
324 #define AK_INVERT (1<<23) /* data is inverted */
325 #define AK_GET_CHIP(val) (((val) >> 8) & 0xff)
326 #define AK_GET_ADDR(val) ((val) & 0xff)
327 #define AK_GET_SHIFT(val) (((val) >> 16) & 0x0f)
328 #define AK_GET_VOL_CVT(val) (((val) >> 21) & 1)
329 #define AK_GET_IPGA(val) (((val) >> 20) & 1)
330 #define AK_GET_NEEDSMSB(val) (((val) >> 22) & 1)
331 #define AK_GET_INVERT(val) (((val) >> 23) & 1)
332 #define AK_GET_MASK(val) (((val) >> 24) & 0xff)
333 #define AK_COMPOSE(chip,addr,shift,mask) \
334 (((chip) << 8) | (addr) | ((shift) << 16) | ((mask) << 24))
336 static int snd_akm4xxx_volume_info(struct snd_kcontrol
*kcontrol
,
337 struct snd_ctl_elem_info
*uinfo
)
339 unsigned int mask
= AK_GET_MASK(kcontrol
->private_value
);
341 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
343 uinfo
->value
.integer
.min
= 0;
344 uinfo
->value
.integer
.max
= mask
;
348 static int snd_akm4xxx_volume_get(struct snd_kcontrol
*kcontrol
,
349 struct snd_ctl_elem_value
*ucontrol
)
351 struct snd_akm4xxx
*ak
= snd_kcontrol_chip(kcontrol
);
352 int chip
= AK_GET_CHIP(kcontrol
->private_value
);
353 int addr
= AK_GET_ADDR(kcontrol
->private_value
);
355 ucontrol
->value
.integer
.value
[0] = snd_akm4xxx_get_vol(ak
, chip
, addr
);
359 static int put_ak_reg(struct snd_kcontrol
*kcontrol
, int addr
,
362 struct snd_akm4xxx
*ak
= snd_kcontrol_chip(kcontrol
);
363 unsigned int mask
= AK_GET_MASK(kcontrol
->private_value
);
364 int chip
= AK_GET_CHIP(kcontrol
->private_value
);
366 if (snd_akm4xxx_get_vol(ak
, chip
, addr
) == nval
)
369 snd_akm4xxx_set_vol(ak
, chip
, addr
, nval
);
370 if (AK_GET_VOL_CVT(kcontrol
->private_value
) && nval
< 128)
371 nval
= vol_cvt_datt
[nval
];
372 if (AK_GET_IPGA(kcontrol
->private_value
) && nval
>= 128)
373 nval
++; /* need to correct + 1 since both 127 and 128 are 0dB */
374 if (AK_GET_INVERT(kcontrol
->private_value
))
376 if (AK_GET_NEEDSMSB(kcontrol
->private_value
))
378 snd_akm4xxx_write(ak
, chip
, addr
, nval
);
382 static int snd_akm4xxx_volume_put(struct snd_kcontrol
*kcontrol
,
383 struct snd_ctl_elem_value
*ucontrol
)
385 unsigned int mask
= AK_GET_MASK(kcontrol
->private_value
);
386 unsigned int val
= ucontrol
->value
.integer
.value
[0];
389 return put_ak_reg(kcontrol
, AK_GET_ADDR(kcontrol
->private_value
), val
);
392 static int snd_akm4xxx_stereo_volume_info(struct snd_kcontrol
*kcontrol
,
393 struct snd_ctl_elem_info
*uinfo
)
395 unsigned int mask
= AK_GET_MASK(kcontrol
->private_value
);
397 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
399 uinfo
->value
.integer
.min
= 0;
400 uinfo
->value
.integer
.max
= mask
;
404 static int snd_akm4xxx_stereo_volume_get(struct snd_kcontrol
*kcontrol
,
405 struct snd_ctl_elem_value
*ucontrol
)
407 struct snd_akm4xxx
*ak
= snd_kcontrol_chip(kcontrol
);
408 int chip
= AK_GET_CHIP(kcontrol
->private_value
);
409 int addr
= AK_GET_ADDR(kcontrol
->private_value
);
411 ucontrol
->value
.integer
.value
[0] = snd_akm4xxx_get_vol(ak
, chip
, addr
);
412 ucontrol
->value
.integer
.value
[1] = snd_akm4xxx_get_vol(ak
, chip
, addr
+1);
416 static int snd_akm4xxx_stereo_volume_put(struct snd_kcontrol
*kcontrol
,
417 struct snd_ctl_elem_value
*ucontrol
)
419 int addr
= AK_GET_ADDR(kcontrol
->private_value
);
420 unsigned int mask
= AK_GET_MASK(kcontrol
->private_value
);
424 val
[0] = ucontrol
->value
.integer
.value
[0];
425 val
[1] = ucontrol
->value
.integer
.value
[1];
426 if (val
[0] > mask
|| val
[1] > mask
)
428 change
= put_ak_reg(kcontrol
, addr
, val
[0]);
429 change
|= put_ak_reg(kcontrol
, addr
+ 1, val
[1]);
433 static int snd_akm4xxx_deemphasis_info(struct snd_kcontrol
*kcontrol
,
434 struct snd_ctl_elem_info
*uinfo
)
436 static char *texts
[4] = {
437 "44.1kHz", "Off", "48kHz", "32kHz",
439 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
441 uinfo
->value
.enumerated
.items
= 4;
442 if (uinfo
->value
.enumerated
.item
>= 4)
443 uinfo
->value
.enumerated
.item
= 3;
444 strcpy(uinfo
->value
.enumerated
.name
,
445 texts
[uinfo
->value
.enumerated
.item
]);
449 static int snd_akm4xxx_deemphasis_get(struct snd_kcontrol
*kcontrol
,
450 struct snd_ctl_elem_value
*ucontrol
)
452 struct snd_akm4xxx
*ak
= snd_kcontrol_chip(kcontrol
);
453 int chip
= AK_GET_CHIP(kcontrol
->private_value
);
454 int addr
= AK_GET_ADDR(kcontrol
->private_value
);
455 int shift
= AK_GET_SHIFT(kcontrol
->private_value
);
456 ucontrol
->value
.enumerated
.item
[0] =
457 (snd_akm4xxx_get(ak
, chip
, addr
) >> shift
) & 3;
461 static int snd_akm4xxx_deemphasis_put(struct snd_kcontrol
*kcontrol
,
462 struct snd_ctl_elem_value
*ucontrol
)
464 struct snd_akm4xxx
*ak
= snd_kcontrol_chip(kcontrol
);
465 int chip
= AK_GET_CHIP(kcontrol
->private_value
);
466 int addr
= AK_GET_ADDR(kcontrol
->private_value
);
467 int shift
= AK_GET_SHIFT(kcontrol
->private_value
);
468 unsigned char nval
= ucontrol
->value
.enumerated
.item
[0] & 3;
471 nval
= (nval
<< shift
) |
472 (snd_akm4xxx_get(ak
, chip
, addr
) & ~(3 << shift
));
473 change
= snd_akm4xxx_get(ak
, chip
, addr
) != nval
;
475 snd_akm4xxx_write(ak
, chip
, addr
, nval
);
479 #define ak4xxx_switch_info snd_ctl_boolean_mono_info
481 static int ak4xxx_switch_get(struct snd_kcontrol
*kcontrol
,
482 struct snd_ctl_elem_value
*ucontrol
)
484 struct snd_akm4xxx
*ak
= snd_kcontrol_chip(kcontrol
);
485 int chip
= AK_GET_CHIP(kcontrol
->private_value
);
486 int addr
= AK_GET_ADDR(kcontrol
->private_value
);
487 int shift
= AK_GET_SHIFT(kcontrol
->private_value
);
488 int invert
= AK_GET_INVERT(kcontrol
->private_value
);
489 /* we observe the (1<<shift) bit only */
490 unsigned char val
= snd_akm4xxx_get(ak
, chip
, addr
) & (1<<shift
);
493 ucontrol
->value
.integer
.value
[0] = (val
& (1<<shift
)) != 0;
497 static int ak4xxx_switch_put(struct snd_kcontrol
*kcontrol
,
498 struct snd_ctl_elem_value
*ucontrol
)
500 struct snd_akm4xxx
*ak
= snd_kcontrol_chip(kcontrol
);
501 int chip
= AK_GET_CHIP(kcontrol
->private_value
);
502 int addr
= AK_GET_ADDR(kcontrol
->private_value
);
503 int shift
= AK_GET_SHIFT(kcontrol
->private_value
);
504 int invert
= AK_GET_INVERT(kcontrol
->private_value
);
505 long flag
= ucontrol
->value
.integer
.value
[0];
506 unsigned char val
, oval
;
511 oval
= snd_akm4xxx_get(ak
, chip
, addr
);
513 val
= oval
| (1<<shift
);
515 val
= oval
& ~(1<<shift
);
516 change
= (oval
!= val
);
518 snd_akm4xxx_write(ak
, chip
, addr
, val
);
522 #define AK5365_NUM_INPUTS 5
524 static int ak4xxx_capture_num_inputs(struct snd_akm4xxx
*ak
, int mixer_ch
)
527 const char **input_names
;
529 input_names
= ak
->adc_info
[mixer_ch
].input_names
;
531 while (num_names
< AK5365_NUM_INPUTS
&& input_names
[num_names
])
536 static int ak4xxx_capture_source_info(struct snd_kcontrol
*kcontrol
,
537 struct snd_ctl_elem_info
*uinfo
)
539 struct snd_akm4xxx
*ak
= snd_kcontrol_chip(kcontrol
);
540 int mixer_ch
= AK_GET_SHIFT(kcontrol
->private_value
);
541 const char **input_names
;
544 num_names
= ak4xxx_capture_num_inputs(ak
, mixer_ch
);
547 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
549 uinfo
->value
.enumerated
.items
= num_names
;
550 idx
= uinfo
->value
.enumerated
.item
;
551 if (idx
>= num_names
)
553 input_names
= ak
->adc_info
[mixer_ch
].input_names
;
554 strncpy(uinfo
->value
.enumerated
.name
, input_names
[idx
],
555 sizeof(uinfo
->value
.enumerated
.name
));
559 static int ak4xxx_capture_source_get(struct snd_kcontrol
*kcontrol
,
560 struct snd_ctl_elem_value
*ucontrol
)
562 struct snd_akm4xxx
*ak
= snd_kcontrol_chip(kcontrol
);
563 int chip
= AK_GET_CHIP(kcontrol
->private_value
);
564 int addr
= AK_GET_ADDR(kcontrol
->private_value
);
565 int mask
= AK_GET_MASK(kcontrol
->private_value
);
568 val
= snd_akm4xxx_get(ak
, chip
, addr
) & mask
;
569 ucontrol
->value
.enumerated
.item
[0] = val
;
573 static int ak4xxx_capture_source_put(struct snd_kcontrol
*kcontrol
,
574 struct snd_ctl_elem_value
*ucontrol
)
576 struct snd_akm4xxx
*ak
= snd_kcontrol_chip(kcontrol
);
577 int mixer_ch
= AK_GET_SHIFT(kcontrol
->private_value
);
578 int chip
= AK_GET_CHIP(kcontrol
->private_value
);
579 int addr
= AK_GET_ADDR(kcontrol
->private_value
);
580 int mask
= AK_GET_MASK(kcontrol
->private_value
);
581 unsigned char oval
, val
;
582 int num_names
= ak4xxx_capture_num_inputs(ak
, mixer_ch
);
584 if (ucontrol
->value
.enumerated
.item
[0] >= num_names
)
587 oval
= snd_akm4xxx_get(ak
, chip
, addr
);
589 val
|= ucontrol
->value
.enumerated
.item
[0] & mask
;
591 snd_akm4xxx_write(ak
, chip
, addr
, val
);
598 * build AK4xxx controls
601 static int build_dac_controls(struct snd_akm4xxx
*ak
)
603 int idx
, err
, mixer_ch
, num_stereo
;
604 struct snd_kcontrol_new knew
;
607 for (idx
= 0; idx
< ak
->num_dacs
; ) {
608 /* mute control for Revolution 7.1 - AK4381 */
609 if (ak
->type
== SND_AK4381
610 && ak
->dac_info
[mixer_ch
].switch_name
) {
611 memset(&knew
, 0, sizeof(knew
));
612 knew
.iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
614 knew
.access
= SNDRV_CTL_ELEM_ACCESS_READWRITE
;
615 knew
.name
= ak
->dac_info
[mixer_ch
].switch_name
;
616 knew
.info
= ak4xxx_switch_info
;
617 knew
.get
= ak4xxx_switch_get
;
618 knew
.put
= ak4xxx_switch_put
;
620 /* register 1, bit 0 (SMUTE): 0 = normal operation,
623 AK_COMPOSE(idx
/2, 1, 0, 0) | AK_INVERT
;
624 err
= snd_ctl_add(ak
->card
, snd_ctl_new1(&knew
, ak
));
628 memset(&knew
, 0, sizeof(knew
));
629 if (! ak
->dac_info
|| ! ak
->dac_info
[mixer_ch
].name
) {
630 knew
.name
= "DAC Volume";
631 knew
.index
= mixer_ch
+ ak
->idx_offset
* 2;
634 knew
.name
= ak
->dac_info
[mixer_ch
].name
;
635 num_stereo
= ak
->dac_info
[mixer_ch
].num_channels
;
637 knew
.iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
639 knew
.access
= SNDRV_CTL_ELEM_ACCESS_READWRITE
|
640 SNDRV_CTL_ELEM_ACCESS_TLV_READ
;
641 if (num_stereo
== 2) {
642 knew
.info
= snd_akm4xxx_stereo_volume_info
;
643 knew
.get
= snd_akm4xxx_stereo_volume_get
;
644 knew
.put
= snd_akm4xxx_stereo_volume_put
;
646 knew
.info
= snd_akm4xxx_volume_info
;
647 knew
.get
= snd_akm4xxx_volume_get
;
648 knew
.put
= snd_akm4xxx_volume_put
;
654 AK_COMPOSE(idx
/2, (idx
%2) + 6, 0, 127) |
656 knew
.tlv
.p
= db_scale_vol_datt
;
661 AK_COMPOSE(idx
/2, (idx
%2) + 4, 0, 127) |
663 knew
.tlv
.p
= db_scale_vol_datt
;
666 /* registers 2-7 and b,c */
667 int val
= idx
< 6 ? idx
+ 2 : (idx
- 6) + 0xb;
669 AK_COMPOSE(0, val
, 0, 255) | AK_INVERT
;
670 knew
.tlv
.p
= db_scale_8bit
;
674 /* register 4-9, chip #0 only */
675 knew
.private_value
= AK_COMPOSE(0, idx
+ 4, 0, 255);
676 knew
.tlv
.p
= db_scale_8bit
;
679 /* register 4-9 and 11-12, chip #0 only */
680 int addr
= idx
< 6 ? idx
+ 4 : idx
+ 5;
682 AK_COMPOSE(0, addr
, 0, 127) | AK_NEEDSMSB
;
683 knew
.tlv
.p
= db_scale_7bit
;
689 AK_COMPOSE(idx
/2, (idx
%2) + 3, 0, 255);
690 knew
.tlv
.p
= db_scale_linear
;
696 err
= snd_ctl_add(ak
->card
, snd_ctl_new1(&knew
, ak
));
706 static int build_adc_controls(struct snd_akm4xxx
*ak
)
708 int idx
, err
, mixer_ch
, num_stereo
;
709 struct snd_kcontrol_new knew
;
712 for (idx
= 0; idx
< ak
->num_adcs
;) {
713 memset(&knew
, 0, sizeof(knew
));
714 if (! ak
->adc_info
|| ! ak
->adc_info
[mixer_ch
].name
) {
715 knew
.name
= "ADC Volume";
716 knew
.index
= mixer_ch
+ ak
->idx_offset
* 2;
719 knew
.name
= ak
->adc_info
[mixer_ch
].name
;
720 num_stereo
= ak
->adc_info
[mixer_ch
].num_channels
;
722 knew
.iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
724 knew
.access
= SNDRV_CTL_ELEM_ACCESS_READWRITE
|
725 SNDRV_CTL_ELEM_ACCESS_TLV_READ
;
726 if (num_stereo
== 2) {
727 knew
.info
= snd_akm4xxx_stereo_volume_info
;
728 knew
.get
= snd_akm4xxx_stereo_volume_get
;
729 knew
.put
= snd_akm4xxx_stereo_volume_put
;
731 knew
.info
= snd_akm4xxx_volume_info
;
732 knew
.get
= snd_akm4xxx_volume_get
;
733 knew
.put
= snd_akm4xxx_volume_put
;
736 if (ak
->type
== SND_AK5365
)
738 AK_COMPOSE(idx
/2, (idx
%2) + 4, 0, 151) |
739 AK_VOL_CVT
| AK_IPGA
;
742 AK_COMPOSE(idx
/2, (idx
%2) + 4, 0, 163) |
743 AK_VOL_CVT
| AK_IPGA
;
744 knew
.tlv
.p
= db_scale_vol_datt
;
745 err
= snd_ctl_add(ak
->card
, snd_ctl_new1(&knew
, ak
));
749 if (ak
->type
== SND_AK5365
&& (idx
% 2) == 0) {
750 if (! ak
->adc_info
||
751 ! ak
->adc_info
[mixer_ch
].switch_name
) {
752 knew
.name
= "Capture Switch";
753 knew
.index
= mixer_ch
+ ak
->idx_offset
* 2;
755 knew
.name
= ak
->adc_info
[mixer_ch
].switch_name
;
756 knew
.info
= ak4xxx_switch_info
;
757 knew
.get
= ak4xxx_switch_get
;
758 knew
.put
= ak4xxx_switch_put
;
760 /* register 2, bit 0 (SMUTE): 0 = normal operation,
763 AK_COMPOSE(idx
/2, 2, 0, 0) | AK_INVERT
;
764 err
= snd_ctl_add(ak
->card
, snd_ctl_new1(&knew
, ak
));
768 memset(&knew
, 0, sizeof(knew
));
769 knew
.name
= ak
->adc_info
[mixer_ch
].selector_name
;
771 knew
.name
= "Capture Channel";
772 knew
.index
= mixer_ch
+ ak
->idx_offset
* 2;
775 knew
.iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
776 knew
.info
= ak4xxx_capture_source_info
;
777 knew
.get
= ak4xxx_capture_source_get
;
778 knew
.put
= ak4xxx_capture_source_put
;
780 /* input selector control: reg. 1, bits 0-2.
781 * mis-use 'shift' to pass mixer_ch */
783 = AK_COMPOSE(idx
/2, 1, mixer_ch
, 0x07);
784 err
= snd_ctl_add(ak
->card
, snd_ctl_new1(&knew
, ak
));
795 static int build_deemphasis(struct snd_akm4xxx
*ak
, int num_emphs
)
798 struct snd_kcontrol_new knew
;
800 for (idx
= 0; idx
< num_emphs
; idx
++) {
801 memset(&knew
, 0, sizeof(knew
));
802 knew
.name
= "Deemphasis";
803 knew
.index
= idx
+ ak
->idx_offset
;
804 knew
.iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
806 knew
.info
= snd_akm4xxx_deemphasis_info
;
807 knew
.get
= snd_akm4xxx_deemphasis_get
;
808 knew
.put
= snd_akm4xxx_deemphasis_put
;
813 knew
.private_value
= AK_COMPOSE(idx
, 3, 0, 0);
816 int shift
= idx
== 3 ? 6 : (2 - idx
) * 2;
817 /* register 8 with shift */
818 knew
.private_value
= AK_COMPOSE(0, 8, shift
, 0);
823 knew
.private_value
= AK_COMPOSE(idx
, 3, 0, 0);
826 knew
.private_value
= AK_COMPOSE(idx
, 1, 1, 0);
831 err
= snd_ctl_add(ak
->card
, snd_ctl_new1(&knew
, ak
));
838 int snd_akm4xxx_build_controls(struct snd_akm4xxx
*ak
)
842 err
= build_dac_controls(ak
);
846 err
= build_adc_controls(ak
);
850 if (ak
->type
== SND_AK4355
|| ak
->type
== SND_AK4358
)
853 num_emphs
= ak
->num_dacs
/ 2;
854 err
= build_deemphasis(ak
, num_emphs
);
861 EXPORT_SYMBOL(snd_akm4xxx_build_controls
);
863 static int __init
alsa_akm4xxx_module_init(void)
868 static void __exit
alsa_akm4xxx_module_exit(void)
872 module_init(alsa_akm4xxx_module_init
)
873 module_exit(alsa_akm4xxx_module_exit
)