projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net
[linux-2.6-block.git] / sound / i2c / other / ak4xxx-adda.c
CommitLineData
1da177e4
LT		 1/*
2 * ALSA driver for AK4524 / AK4528 / AK4529 / AK4355 / AK4358 / AK4381
3 * AD and DA converters
4 *
c1017a4c 5 * Copyright (c) 2000-2004 Jaroslav Kysela <perex@perex.cz>,
1da177e4
LT		 6 * Takashi Iwai <tiwai@suse.de>
7 *
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.
12 *
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.
17 *
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
21 *
8f34692f 22 */
1da177e4 23
6cbbfe1c 24#include <linux/io.h>
1da177e4
LT		 25#include <linux/delay.h>
26#include <linux/interrupt.h>
27#include <linux/init.h>
da155d5b 28#include <linux/module.h>
1da177e4
LT		 29#include <sound/core.h>
30#include <sound/control.h>
723b2b0d 31#include <sound/tlv.h>
1da177e4 32#include <sound/ak4xxx-adda.h>
8f34692f 33#include <sound/info.h>
1da177e4 34
c1017a4c 35MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Takashi Iwai <tiwai@suse.de>");
1da177e4
LT		 36MODULE_DESCRIPTION("Routines for control of AK452x / AK43xx AD/DA converters");
37MODULE_LICENSE("GPL");
38
723b2b0d 39/* write the given register and save the data to the cache */
cb9d24e4
TI		 40void snd_akm4xxx_write(struct snd_akm4xxx *ak, int chip, unsigned char reg,
41 unsigned char val)
1da177e4
LT		 42{
43 ak->ops.lock(ak, chip);
44 ak->ops.write(ak, chip, reg, val);
45
46 /* save the data */
854b66e4 47 snd_akm4xxx_set(ak, chip, reg, val);
1da177e4
LT		 48 ak->ops.unlock(ak, chip);
49}
50
cb9d24e4
TI		 51EXPORT_SYMBOL(snd_akm4xxx_write);
52
53/* reset procedure for AK4524 and AK4528 */
54static void ak4524_reset(struct snd_akm4xxx *ak, int state)
55{
56 unsigned int chip;
8f34692f 57 unsigned char reg;
cb9d24e4 58
cb9d24e4
TI		 59 for (chip = 0; chip < ak->num_dacs/2; chip++) {
60 snd_akm4xxx_write(ak, chip, 0x01, state ? 0x00 : 0x03);
61 if (state)
62 continue;
63 /* DAC volumes */
8f34692f 64 for (reg = 0x04; reg < ak->total_regs; reg++)
cb9d24e4
TI		 65 snd_akm4xxx_write(ak, chip, reg,
66 snd_akm4xxx_get(ak, chip, reg));
cb9d24e4
TI		 67 }
68}
69
70/* reset procedure for AK4355 and AK4358 */
8f34692f 71static void ak435X_reset(struct snd_akm4xxx *ak, int state)
cb9d24e4
TI		 72{
73 unsigned char reg;
74
75 if (state) {
76 snd_akm4xxx_write(ak, 0, 0x01, 0x02); /* reset and soft-mute */
77 return;
78 }
8f34692f 79 for (reg = 0x00; reg < ak->total_regs; reg++)
cb9d24e4
TI		 80 if (reg != 0x01)
81 snd_akm4xxx_write(ak, 0, reg,
82 snd_akm4xxx_get(ak, 0, reg));
83 snd_akm4xxx_write(ak, 0, 0x01, 0x01); /* un-reset, unmute */
84}
85
86/* reset procedure for AK4381 */
87static void ak4381_reset(struct snd_akm4xxx *ak, int state)
88{
89 unsigned int chip;
90 unsigned char reg;
cb9d24e4
TI		 91 for (chip = 0; chip < ak->num_dacs/2; chip++) {
92 snd_akm4xxx_write(ak, chip, 0x00, state ? 0x0c : 0x0f);
93 if (state)
94 continue;
8f34692f 95 for (reg = 0x01; reg < ak->total_regs; reg++)
cb9d24e4
TI		 96 snd_akm4xxx_write(ak, chip, reg,
97 snd_akm4xxx_get(ak, chip, reg));
98 }
99}
100
1da177e4
LT		 101/*
102 * reset the AKM codecs
103 * @state: 1 = reset codec, 0 = restore the registers
104 *
105 * assert the reset operation and restores the register values to the chips.
106 */
97f02e05 107void snd_akm4xxx_reset(struct snd_akm4xxx *ak, int state)
1da177e4 108{
1da177e4
LT		 109 switch (ak->type) {
110 case SND_AK4524:
111 case SND_AK4528:
8f34692f 112 case SND_AK4620:
cb9d24e4 113 ak4524_reset(ak, state);
1da177e4
LT		 114 break;
115 case SND_AK4529:
116 /* FIXME: needed for ak4529? */
117 break;
118 case SND_AK4355:
8f34692f 119 ak435X_reset(ak, state);
841b23d4 120 break;
1da177e4 121 case SND_AK4358:
8f34692f 122 ak435X_reset(ak, state);
1da177e4
LT		 123 break;
124 case SND_AK4381:
cb9d24e4 125 ak4381_reset(ak, state);
1da177e4 126 break;
cf93907b
TI		 127 default:
128 break;
1da177e4
LT		 129 }
130}
131
cb9d24e4
TI		 132EXPORT_SYMBOL(snd_akm4xxx_reset);
133
723b2b0d
TI		 134
135/*
136 * Volume conversion table for non-linear volumes
137 * from -63.5dB (mute) to 0dB step 0.5dB
138 *
8f34692f 139 * Used for AK4524/AK4620 input/ouput attenuation, AK4528, and
723b2b0d
TI		 140 * AK5365 input attenuation
141 */
517400cb 142static const unsigned char vol_cvt_datt[128] = {
723b2b0d
TI		 143 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04,
144 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x06, 0x06,
145 0x06, 0x07, 0x07, 0x08, 0x08, 0x08, 0x09, 0x0a,
146 0x0a, 0x0b, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x0f,
147 0x10, 0x10, 0x11, 0x12, 0x12, 0x13, 0x13, 0x14,
148 0x15, 0x16, 0x17, 0x17, 0x18, 0x19, 0x1a, 0x1c,
149 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x23,
150 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a, 0x2b, 0x2d,
151 0x2e, 0x30, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
152 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3e, 0x3f, 0x40,
153 0x41, 0x42, 0x43, 0x44, 0x46, 0x47, 0x48, 0x4a,
154 0x4b, 0x4d, 0x4e, 0x50, 0x51, 0x52, 0x53, 0x54,
155 0x55, 0x56, 0x58, 0x59, 0x5b, 0x5c, 0x5e, 0x5f,
156 0x60, 0x61, 0x62, 0x64, 0x65, 0x66, 0x67, 0x69,
157 0x6a, 0x6c, 0x6d, 0x6f, 0x70, 0x71, 0x72, 0x73,
158 0x75, 0x76, 0x77, 0x79, 0x7a, 0x7c, 0x7d, 0x7f,
159};
160
161/*
162 * dB tables
163 */
0cb29ea0
TI		 164static const DECLARE_TLV_DB_SCALE(db_scale_vol_datt, -6350, 50, 1);
165static const DECLARE_TLV_DB_SCALE(db_scale_8bit, -12750, 50, 1);
166static const DECLARE_TLV_DB_SCALE(db_scale_7bit, -6350, 50, 1);
167static const DECLARE_TLV_DB_LINEAR(db_scale_linear, TLV_DB_GAIN_MUTE, 0);
723b2b0d 168
1da177e4
LT		 169/*
170 * initialize all the ak4xxx chips
171 */
97f02e05 172void snd_akm4xxx_init(struct snd_akm4xxx *ak)
1da177e4 173{
0cb29ea0 174 static const unsigned char inits_ak4524[] = {
1da177e4
LT		 175 0x00, 0x07, /* 0: all power up */
176 0x01, 0x00, /* 1: ADC/DAC reset */
177 0x02, 0x60, /* 2: 24bit I2S */
178 0x03, 0x19, /* 3: deemphasis off */
179 0x01, 0x03, /* 1: ADC/DAC enable */
180 0x04, 0x00, /* 4: ADC left muted */
181 0x05, 0x00, /* 5: ADC right muted */
1da177e4
LT		 182 0x06, 0x00, /* 6: DAC left muted */
183 0x07, 0x00, /* 7: DAC right muted */
184 0xff, 0xff
185 };
517400cb 186 static const unsigned char inits_ak4528[] = {
1da177e4
LT		 187 0x00, 0x07, /* 0: all power up */
188 0x01, 0x00, /* 1: ADC/DAC reset */
189 0x02, 0x60, /* 2: 24bit I2S */
190 0x03, 0x0d, /* 3: deemphasis off, turn LR highpass filters on */
191 0x01, 0x03, /* 1: ADC/DAC enable */
192 0x04, 0x00, /* 4: ADC left muted */
193 0x05, 0x00, /* 5: ADC right muted */
194 0xff, 0xff
195 };
517400cb 196 static const unsigned char inits_ak4529[] = {
1da177e4
LT		 197 0x09, 0x01, /* 9: ATS=0, RSTN=1 */
198 0x0a, 0x3f, /* A: all power up, no zero/overflow detection */
199 0x00, 0x0c, /* 0: TDM=0, 24bit I2S, SMUTE=0 */
200 0x01, 0x00, /* 1: ACKS=0, ADC, loop off */
201 0x02, 0xff, /* 2: LOUT1 muted */
202 0x03, 0xff, /* 3: ROUT1 muted */
203 0x04, 0xff, /* 4: LOUT2 muted */
204 0x05, 0xff, /* 5: ROUT2 muted */
205 0x06, 0xff, /* 6: LOUT3 muted */
206 0x07, 0xff, /* 7: ROUT3 muted */
207 0x0b, 0xff, /* B: LOUT4 muted */
208 0x0c, 0xff, /* C: ROUT4 muted */
209 0x08, 0x55, /* 8: deemphasis all off */
210 0xff, 0xff
211 };
517400cb 212 static const unsigned char inits_ak4355[] = {
1da177e4 213 0x01, 0x02, /* 1: reset and soft-mute */
cb9d24e4
TI		 214 0x00, 0x06, /* 0: mode3(i2s), disable auto-clock detect,
215 * disable DZF, sharp roll-off, RSTN#=0 */
1da177e4
LT		 216 0x02, 0x0e, /* 2: DA's power up, normal speed, RSTN#=0 */
217 // 0x02, 0x2e, /* quad speed */
218 0x03, 0x01, /* 3: de-emphasis off */
219 0x04, 0x00, /* 4: LOUT1 volume muted */
220 0x05, 0x00, /* 5: ROUT1 volume muted */
221 0x06, 0x00, /* 6: LOUT2 volume muted */
222 0x07, 0x00, /* 7: ROUT2 volume muted */
223 0x08, 0x00, /* 8: LOUT3 volume muted */
224 0x09, 0x00, /* 9: ROUT3 volume muted */
225 0x0a, 0x00, /* a: DATT speed=0, ignore DZF */
226 0x01, 0x01, /* 1: un-reset, unmute */
227 0xff, 0xff
228 };
517400cb 229 static const unsigned char inits_ak4358[] = {
1da177e4 230 0x01, 0x02, /* 1: reset and soft-mute */
cb9d24e4
TI		 231 0x00, 0x06, /* 0: mode3(i2s), disable auto-clock detect,
232 * disable DZF, sharp roll-off, RSTN#=0 */
46480b3a
AB		 233 0x02, 0x4e, /* 2: DA's power up, normal speed, RSTN#=0 */
234 /* 0x02, 0x6e,*/ /* quad speed */
1da177e4
LT		 235 0x03, 0x01, /* 3: de-emphasis off */
236 0x04, 0x00, /* 4: LOUT1 volume muted */
237 0x05, 0x00, /* 5: ROUT1 volume muted */
238 0x06, 0x00, /* 6: LOUT2 volume muted */
239 0x07, 0x00, /* 7: ROUT2 volume muted */
240 0x08, 0x00, /* 8: LOUT3 volume muted */
241 0x09, 0x00, /* 9: ROUT3 volume muted */
242 0x0b, 0x00, /* b: LOUT4 volume muted */
243 0x0c, 0x00, /* c: ROUT4 volume muted */
244 0x0a, 0x00, /* a: DATT speed=0, ignore DZF */
245 0x01, 0x01, /* 1: un-reset, unmute */
246 0xff, 0xff
247 };
517400cb 248 static const unsigned char inits_ak4381[] = {
1da177e4 249 0x00, 0x0c, /* 0: mode3(i2s), disable auto-clock detect */
cb9d24e4
TI		 250 0x01, 0x02, /* 1: de-emphasis off, normal speed,
251 * sharp roll-off, DZF off */
1da177e4
LT		 252 // 0x01, 0x12, /* quad speed */
253 0x02, 0x00, /* 2: DZF disabled */
254 0x03, 0x00, /* 3: LATT 0 */
255 0x04, 0x00, /* 4: RATT 0 */
256 0x00, 0x0f, /* 0: power-up, un-reset */
257 0xff, 0xff
258 };
8f34692f
PH		 259 static const unsigned char inits_ak4620[] = {
260 0x00, 0x07, /* 0: normal */
261 0x01, 0x00, /* 0: reset */
262 0x01, 0x02, /* 1: RSTAD */
263 0x01, 0x03, /* 1: RSTDA */
264 0x01, 0x0f, /* 1: normal */
265 0x02, 0x60, /* 2: 24bit I2S */
266 0x03, 0x01, /* 3: deemphasis off */
267 0x04, 0x00, /* 4: LIN muted */
268 0x05, 0x00, /* 5: RIN muted */
269 0x06, 0x00, /* 6: LOUT muted */
270 0x07, 0x00, /* 7: ROUT muted */
271 0xff, 0xff
272 };
1da177e4 273
8f34692f 274 int chip;
517400cb
TI		 275 const unsigned char *ptr, *inits;
276 unsigned char reg, data;
1da177e4 277
723b2b0d
TI		 278 memset(ak->images, 0, sizeof(ak->images));
279 memset(ak->volumes, 0, sizeof(ak->volumes));
280
1da177e4
LT		 281 switch (ak->type) {
282 case SND_AK4524:
283 inits = inits_ak4524;
8f34692f
PH		 284 ak->num_chips = ak->num_dacs / 2;
285 ak->name = "ak4524";
286 ak->total_regs = 0x08;
1da177e4
LT		 287 break;
288 case SND_AK4528:
289 inits = inits_ak4528;
8f34692f
PH		 290 ak->num_chips = ak->num_dacs / 2;
291 ak->name = "ak4528";
292 ak->total_regs = 0x06;
1da177e4
LT		 293 break;
294 case SND_AK4529:
295 inits = inits_ak4529;
8f34692f
PH		 296 ak->num_chips = 1;
297 ak->name = "ak4529";
298 ak->total_regs = 0x0d;
1da177e4
LT		 299 break;
300 case SND_AK4355:
301 inits = inits_ak4355;
8f34692f
PH		 302 ak->num_chips = 1;
303 ak->name = "ak4355";
304 ak->total_regs = 0x0b;
1da177e4
LT		 305 break;
306 case SND_AK4358:
307 inits = inits_ak4358;
8f34692f
PH		 308 ak->num_chips = 1;
309 ak->name = "ak4358";
310 ak->total_regs = 0x10;
1da177e4
LT		 311 break;
312 case SND_AK4381:
313 inits = inits_ak4381;
8f34692f
PH		 314 ak->num_chips = ak->num_dacs / 2;
315 ak->name = "ak4381";
316 ak->total_regs = 0x05;
1da177e4 317 break;
723b2b0d
TI		 318 case SND_AK5365:
319 /* FIXME: any init sequence? */
8f34692f
PH		 320 ak->num_chips = 1;
321 ak->name = "ak5365";
322 ak->total_regs = 0x08;
723b2b0d 323 return;
8f34692f
PH		 324 case SND_AK4620:
325 inits = inits_ak4620;
326 ak->num_chips = ak->num_dacs / 2;
327 ak->name = "ak4620";
328 ak->total_regs = 0x08;
329 break;
1da177e4
LT		 330 default:
331 snd_BUG();
332 return;
333 }
334
8f34692f 335 for (chip = 0; chip < ak->num_chips; chip++) {
1da177e4
LT		 336 ptr = inits;
337 while (*ptr != 0xff) {
338 reg = *ptr++;
339 data = *ptr++;
340 snd_akm4xxx_write(ak, chip, reg, data);
8f34692f 341 udelay(10);
1da177e4
LT		 342 }
343 }
344}
345
cb9d24e4
TI		 346EXPORT_SYMBOL(snd_akm4xxx_init);
347
723b2b0d
TI		 348/*
349 * Mixer callbacks
350 */
854b66e4 351#define AK_IPGA (1<<20) /* including IPGA */
723b2b0d
TI		 352#define AK_VOL_CVT (1<<21) /* need dB conversion */
353#define AK_NEEDSMSB (1<<22) /* need MSB update bit */
354#define AK_INVERT (1<<23) /* data is inverted */
1da177e4
LT		 355#define AK_GET_CHIP(val) (((val) >> 8) & 0xff)
356#define AK_GET_ADDR(val) ((val) & 0xff)
854b66e4 357#define AK_GET_SHIFT(val) (((val) >> 16) & 0x0f)
723b2b0d 358#define AK_GET_VOL_CVT(val) (((val) >> 21) & 1)
854b66e4 359#define AK_GET_IPGA(val) (((val) >> 20) & 1)
3479307f 360#define AK_GET_NEEDSMSB(val) (((val) >> 22) & 1)
1da177e4
LT		 361#define AK_GET_INVERT(val) (((val) >> 23) & 1)
362#define AK_GET_MASK(val) (((val) >> 24) & 0xff)
cb9d24e4
TI		 363#define AK_COMPOSE(chip,addr,shift,mask) \
364 (((chip) << 8) | (addr) | ((shift) << 16) | ((mask) << 24))
1da177e4 365
97f02e05
TI		 366static int snd_akm4xxx_volume_info(struct snd_kcontrol *kcontrol,
367 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 368{
369 unsigned int mask = AK_GET_MASK(kcontrol->private_value);
370
371 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
372 uinfo->count = 1;
373 uinfo->value.integer.min = 0;
374 uinfo->value.integer.max = mask;
375 return 0;
376}
377
97f02e05
TI		 378static int snd_akm4xxx_volume_get(struct snd_kcontrol *kcontrol,
379 struct snd_ctl_elem_value *ucontrol)
1da177e4 380{
97f02e05 381 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
1da177e4
LT		 382 int chip = AK_GET_CHIP(kcontrol->private_value);
383 int addr = AK_GET_ADDR(kcontrol->private_value);
3479307f 384
723b2b0d 385 ucontrol->value.integer.value[0] = snd_akm4xxx_get_vol(ak, chip, addr);
1da177e4
LT		 386 return 0;
387}
388
723b2b0d
TI		 389static int put_ak_reg(struct snd_kcontrol *kcontrol, int addr,
390 unsigned char nval)
1da177e4 391{
97f02e05 392 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
1da177e4 393 unsigned int mask = AK_GET_MASK(kcontrol->private_value);
723b2b0d 394 int chip = AK_GET_CHIP(kcontrol->private_value);
1da177e4 395
723b2b0d
TI		 396 if (snd_akm4xxx_get_vol(ak, chip, addr) == nval)
397 return 0;
398
399 snd_akm4xxx_set_vol(ak, chip, addr, nval);
854b66e4 400 if (AK_GET_VOL_CVT(kcontrol->private_value) && nval < 128)
723b2b0d 401 nval = vol_cvt_datt[nval];
854b66e4
TI		 402 if (AK_GET_IPGA(kcontrol->private_value) && nval >= 128)
403 nval++; /* need to correct + 1 since both 127 and 128 are 0dB */
723b2b0d 404 if (AK_GET_INVERT(kcontrol->private_value))
1da177e4 405 nval = mask - nval;
723b2b0d 406 if (AK_GET_NEEDSMSB(kcontrol->private_value))
3479307f 407 nval |= 0x80;
841b23d4
PH		 408 /* printk(KERN_DEBUG "DEBUG - AK writing reg: chip %x addr %x,
409 nval %x\n", chip, addr, nval); */
723b2b0d
TI		 410 snd_akm4xxx_write(ak, chip, addr, nval);
411 return 1;
412}
413
414static int snd_akm4xxx_volume_put(struct snd_kcontrol *kcontrol,
415 struct snd_ctl_elem_value *ucontrol)
416{
02ff1324
TI		 417 unsigned int mask = AK_GET_MASK(kcontrol->private_value);
418 unsigned int val = ucontrol->value.integer.value[0];
419 if (val > mask)
420 return -EINVAL;
421 return put_ak_reg(kcontrol, AK_GET_ADDR(kcontrol->private_value), val);
1da177e4
LT		 422}
423
c83c0c47 424static int snd_akm4xxx_stereo_volume_info(struct snd_kcontrol *kcontrol,
cb9d24e4 425 struct snd_ctl_elem_info *uinfo)
c83c0c47
JA		 426{
427 unsigned int mask = AK_GET_MASK(kcontrol->private_value);
428
429 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
430 uinfo->count = 2;
431 uinfo->value.integer.min = 0;
432 uinfo->value.integer.max = mask;
433 return 0;
434}
435
436static int snd_akm4xxx_stereo_volume_get(struct snd_kcontrol *kcontrol,
cb9d24e4 437 struct snd_ctl_elem_value *ucontrol)
c83c0c47
JA		 438{
439 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
440 int chip = AK_GET_CHIP(kcontrol->private_value);
441 int addr = AK_GET_ADDR(kcontrol->private_value);
c83c0c47 442
723b2b0d
TI		 443 ucontrol->value.integer.value[0] = snd_akm4xxx_get_vol(ak, chip, addr);
444 ucontrol->value.integer.value[1] = snd_akm4xxx_get_vol(ak, chip, addr+1);
c83c0c47
JA		 445 return 0;
446}
447
448static int snd_akm4xxx_stereo_volume_put(struct snd_kcontrol *kcontrol,
cb9d24e4 449 struct snd_ctl_elem_value *ucontrol)
c83c0c47 450{
c83c0c47 451 int addr = AK_GET_ADDR(kcontrol->private_value);
02ff1324
TI		 452 unsigned int mask = AK_GET_MASK(kcontrol->private_value);
453 unsigned int val[2];
723b2b0d 454 int change;
c83c0c47 455
02ff1324
TI		 456 val[0] = ucontrol->value.integer.value[0];
457 val[1] = ucontrol->value.integer.value[1];
458 if (val[0] > mask || val[1] > mask)
459 return -EINVAL;
460 change = put_ak_reg(kcontrol, addr, val[0]);
461 change |= put_ak_reg(kcontrol, addr + 1, val[1]);
723b2b0d 462 return change;
c83c0c47
JA		 463}
464
97f02e05
TI		 465static int snd_akm4xxx_deemphasis_info(struct snd_kcontrol *kcontrol,
466 struct snd_ctl_elem_info *uinfo)
1da177e4 467{
609e478b 468 static const char * const texts[4] = {
1da177e4
LT		 469 "44.1kHz", "Off", "48kHz", "32kHz",
470 };
609e478b 471 return snd_ctl_enum_info(uinfo, 1, 4, texts);
1da177e4
LT		 472}
473
97f02e05
TI		 474static int snd_akm4xxx_deemphasis_get(struct snd_kcontrol *kcontrol,
475 struct snd_ctl_elem_value *ucontrol)
1da177e4 476{
97f02e05 477 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
1da177e4
LT		 478 int chip = AK_GET_CHIP(kcontrol->private_value);
479 int addr = AK_GET_ADDR(kcontrol->private_value);
480 int shift = AK_GET_SHIFT(kcontrol->private_value);
cb9d24e4
TI		 481 ucontrol->value.enumerated.item[0] =
482 (snd_akm4xxx_get(ak, chip, addr) >> shift) & 3;
1da177e4
LT		 483 return 0;
484}
485
97f02e05
TI		 486static int snd_akm4xxx_deemphasis_put(struct snd_kcontrol *kcontrol,
487 struct snd_ctl_elem_value *ucontrol)
1da177e4 488{
97f02e05 489 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
1da177e4
LT		 490 int chip = AK_GET_CHIP(kcontrol->private_value);
491 int addr = AK_GET_ADDR(kcontrol->private_value);
492 int shift = AK_GET_SHIFT(kcontrol->private_value);
493 unsigned char nval = ucontrol->value.enumerated.item[0] & 3;
494 int change;
495
cb9d24e4
TI		 496 nval = (nval << shift) |
497 (snd_akm4xxx_get(ak, chip, addr) & ~(3 << shift));
1da177e4
LT		 498 change = snd_akm4xxx_get(ak, chip, addr) != nval;
499 if (change)
500 snd_akm4xxx_write(ak, chip, addr, nval);
501 return change;
502}
503
a5ce8890 504#define ak4xxx_switch_info snd_ctl_boolean_mono_info
30ba6e20
JV		 505
506static int ak4xxx_switch_get(struct snd_kcontrol *kcontrol,
507 struct snd_ctl_elem_value *ucontrol)
508{
509 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
510 int chip = AK_GET_CHIP(kcontrol->private_value);
511 int addr = AK_GET_ADDR(kcontrol->private_value);
512 int shift = AK_GET_SHIFT(kcontrol->private_value);
513 int invert = AK_GET_INVERT(kcontrol->private_value);
ea7cfcdf
PH		 514 /* we observe the (1<<shift) bit only */
515 unsigned char val = snd_akm4xxx_get(ak, chip, addr) & (1<<shift);
30ba6e20
JV		 516 if (invert)
517 val = ! val;
518 ucontrol->value.integer.value[0] = (val & (1<<shift)) != 0;
519 return 0;
520}
521
522static int ak4xxx_switch_put(struct snd_kcontrol *kcontrol,
523 struct snd_ctl_elem_value *ucontrol)
524{
525 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
526 int chip = AK_GET_CHIP(kcontrol->private_value);
527 int addr = AK_GET_ADDR(kcontrol->private_value);
528 int shift = AK_GET_SHIFT(kcontrol->private_value);
529 int invert = AK_GET_INVERT(kcontrol->private_value);
530 long flag = ucontrol->value.integer.value[0];
531 unsigned char val, oval;
532 int change;
533
534 if (invert)
535 flag = ! flag;
536 oval = snd_akm4xxx_get(ak, chip, addr);
537 if (flag)
538 val = oval | (1<<shift);
539 else
540 val = oval & ~(1<<shift);
541 change = (oval != val);
542 if (change)
543 snd_akm4xxx_write(ak, chip, addr, val);
544 return change;
545}
546
a58e7cb1
JV		 547#define AK5365_NUM_INPUTS 5
548
02ff1324
TI		 549static int ak4xxx_capture_num_inputs(struct snd_akm4xxx *ak, int mixer_ch)
550{
551 int num_names;
552 const char **input_names;
553
554 input_names = ak->adc_info[mixer_ch].input_names;
555 num_names = 0;
556 while (num_names < AK5365_NUM_INPUTS && input_names[num_names])
557 ++num_names;
558 return num_names;
559}
560
a58e7cb1
JV		 561static int ak4xxx_capture_source_info(struct snd_kcontrol *kcontrol,
562 struct snd_ctl_elem_info *uinfo)
563{
564 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
565 int mixer_ch = AK_GET_SHIFT(kcontrol->private_value);
609e478b 566 unsigned int num_names;
a58e7cb1 567
02ff1324
TI		 568 num_names = ak4xxx_capture_num_inputs(ak, mixer_ch);
569 if (!num_names)
570 return -EINVAL;
609e478b
TI		 571 return snd_ctl_enum_info(uinfo, 1, num_names,
572 ak->adc_info[mixer_ch].input_names);
a58e7cb1
JV		 573}
574
575static int ak4xxx_capture_source_get(struct snd_kcontrol *kcontrol,
576 struct snd_ctl_elem_value *ucontrol)
577{
578 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
579 int chip = AK_GET_CHIP(kcontrol->private_value);
580 int addr = AK_GET_ADDR(kcontrol->private_value);
581 int mask = AK_GET_MASK(kcontrol->private_value);
582 unsigned char val;
583
584 val = snd_akm4xxx_get(ak, chip, addr) & mask;
585 ucontrol->value.enumerated.item[0] = val;
586 return 0;
587}
588
589static int ak4xxx_capture_source_put(struct snd_kcontrol *kcontrol,
590 struct snd_ctl_elem_value *ucontrol)
591{
592 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
02ff1324 593 int mixer_ch = AK_GET_SHIFT(kcontrol->private_value);
a58e7cb1
JV		 594 int chip = AK_GET_CHIP(kcontrol->private_value);
595 int addr = AK_GET_ADDR(kcontrol->private_value);
596 int mask = AK_GET_MASK(kcontrol->private_value);
597 unsigned char oval, val;
02ff1324
TI		 598 int num_names = ak4xxx_capture_num_inputs(ak, mixer_ch);
599
600 if (ucontrol->value.enumerated.item[0] >= num_names)
601 return -EINVAL;
a58e7cb1
JV		 602
603 oval = snd_akm4xxx_get(ak, chip, addr);
604 val = oval & ~mask;
605 val |= ucontrol->value.enumerated.item[0] & mask;
606 if (val != oval) {
607 snd_akm4xxx_write(ak, chip, addr, val);
608 return 1;
609 }
610 return 0;
611}
612
1da177e4
LT		 613/*
614 * build AK4xxx controls
615 */
616
723b2b0d 617static int build_dac_controls(struct snd_akm4xxx *ak)
1da177e4 618{
723b2b0d
TI		 619 int idx, err, mixer_ch, num_stereo;
620 struct snd_kcontrol_new knew;
1da177e4 621
723b2b0d 622 mixer_ch = 0;
c83c0c47 623 for (idx = 0; idx < ak->num_dacs; ) {
ea7cfcdf
PH		 624 /* mute control for Revolution 7.1 - AK4381 */
625 if (ak->type == SND_AK4381
626 && ak->dac_info[mixer_ch].switch_name) {
627 memset(&knew, 0, sizeof(knew));
628 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
629 knew.count = 1;
630 knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
631 knew.name = ak->dac_info[mixer_ch].switch_name;
632 knew.info = ak4xxx_switch_info;
633 knew.get = ak4xxx_switch_get;
634 knew.put = ak4xxx_switch_put;
635 knew.access = 0;
636 /* register 1, bit 0 (SMUTE): 0 = normal operation,
637 1 = mute */
638 knew.private_value =
639 AK_COMPOSE(idx/2, 1, 0, 0) | AK_INVERT;
640 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
641 if (err < 0)
642 return err;
643 }
723b2b0d
TI		 644 memset(&knew, 0, sizeof(knew));
645 if (! ak->dac_info || ! ak->dac_info[mixer_ch].name) {
646 knew.name = "DAC Volume";
647 knew.index = mixer_ch + ak->idx_offset * 2;
c83c0c47 648 num_stereo = 1;
c83c0c47 649 } else {
723b2b0d
TI		 650 knew.name = ak->dac_info[mixer_ch].name;
651 num_stereo = ak->dac_info[mixer_ch].num_channels;
c83c0c47 652 }
723b2b0d
TI		 653 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
654 knew.count = 1;
655 knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
656 SNDRV_CTL_ELEM_ACCESS_TLV_READ;
c83c0c47 657 if (num_stereo == 2) {
723b2b0d
TI		 658 knew.info = snd_akm4xxx_stereo_volume_info;
659 knew.get = snd_akm4xxx_stereo_volume_get;
660 knew.put = snd_akm4xxx_stereo_volume_put;
c83c0c47 661 } else {
723b2b0d
TI		 662 knew.info = snd_akm4xxx_volume_info;
663 knew.get = snd_akm4xxx_volume_get;
664 knew.put = snd_akm4xxx_volume_put;
c83c0c47 665 }
1da177e4
LT		 666 switch (ak->type) {
667 case SND_AK4524:
cb9d24e4 668 /* register 6 & 7 */
723b2b0d
TI		 669 knew.private_value =
670 AK_COMPOSE(idx/2, (idx%2) + 6, 0, 127) |
671 AK_VOL_CVT;
672 knew.tlv.p = db_scale_vol_datt;
1da177e4
LT		 673 break;
674 case SND_AK4528:
cb9d24e4 675 /* register 4 & 5 */
723b2b0d
TI		 676 knew.private_value =
677 AK_COMPOSE(idx/2, (idx%2) + 4, 0, 127) |
678 AK_VOL_CVT;
679 knew.tlv.p = db_scale_vol_datt;
1da177e4
LT		 680 break;
681 case SND_AK4529: {
cb9d24e4
TI		 682 /* registers 2-7 and b,c */
683 int val = idx < 6 ? idx + 2 : (idx - 6) + 0xb;
723b2b0d 684 knew.private_value =
cb9d24e4 685 AK_COMPOSE(0, val, 0, 255) | AK_INVERT;
723b2b0d 686 knew.tlv.p = db_scale_8bit;
1da177e4
LT		 687 break;
688 }
689 case SND_AK4355:
cb9d24e4 690 /* register 4-9, chip #0 only */
723b2b0d
TI		 691 knew.private_value = AK_COMPOSE(0, idx + 4, 0, 255);
692 knew.tlv.p = db_scale_8bit;
1da177e4 693 break;
3479307f
JV		 694 case SND_AK4358: {
695 /* register 4-9 and 11-12, chip #0 only */
696 int addr = idx < 6 ? idx + 4 : idx + 5;
723b2b0d 697 knew.private_value =
3479307f 698 AK_COMPOSE(0, addr, 0, 127) | AK_NEEDSMSB;
723b2b0d 699 knew.tlv.p = db_scale_7bit;
1da177e4 700 break;
3479307f 701 }
1da177e4 702 case SND_AK4381:
cb9d24e4 703 /* register 3 & 4 */
723b2b0d 704 knew.private_value =
cb9d24e4 705 AK_COMPOSE(idx/2, (idx%2) + 3, 0, 255);
723b2b0d 706 knew.tlv.p = db_scale_linear;
1da177e4 707 break;
8f34692f
PH		 708 case SND_AK4620:
709 /* register 6 & 7 */
710 knew.private_value =
711 AK_COMPOSE(idx/2, (idx%2) + 6, 0, 255);
712 knew.tlv.p = db_scale_linear;
713 break;
1da177e4 714 default:
723b2b0d 715 return -EINVAL;
1da177e4 716 }
c83c0c47 717
723b2b0d 718 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
cb9d24e4 719 if (err < 0)
723b2b0d 720 return err;
c83c0c47
JA		 721
722 idx += num_stereo;
723 mixer_ch++;
1da177e4 724 }
723b2b0d
TI		 725 return 0;
726}
727
728static int build_adc_controls(struct snd_akm4xxx *ak)
729{
8f34692f 730 int idx, err, mixer_ch, num_stereo, max_steps;
723b2b0d
TI		 731 struct snd_kcontrol_new knew;
732
733 mixer_ch = 0;
8f34692f
PH		 734 if (ak->type == SND_AK4528)
735 return 0; /* no controls */
723b2b0d
TI		 736 for (idx = 0; idx < ak->num_adcs;) {
737 memset(&knew, 0, sizeof(knew));
738 if (! ak->adc_info || ! ak->adc_info[mixer_ch].name) {
739 knew.name = "ADC Volume";
740 knew.index = mixer_ch + ak->idx_offset * 2;
741 num_stereo = 1;
742 } else {
743 knew.name = ak->adc_info[mixer_ch].name;
744 num_stereo = ak->adc_info[mixer_ch].num_channels;
745 }
746 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
747 knew.count = 1;
748 knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
749 SNDRV_CTL_ELEM_ACCESS_TLV_READ;
750 if (num_stereo == 2) {
751 knew.info = snd_akm4xxx_stereo_volume_info;
752 knew.get = snd_akm4xxx_stereo_volume_get;
753 knew.put = snd_akm4xxx_stereo_volume_put;
754 } else {
755 knew.info = snd_akm4xxx_volume_info;
756 knew.get = snd_akm4xxx_volume_get;
757 knew.put = snd_akm4xxx_volume_put;
758 }
cb9d24e4 759 /* register 4 & 5 */
854b66e4 760 if (ak->type == SND_AK5365)
8f34692f 761 max_steps = 152;
683fe153 762 else
8f34692f
PH		 763 max_steps = 164;
764 knew.private_value =
765 AK_COMPOSE(idx/2, (idx%2) + 4, 0, max_steps) |
766 AK_VOL_CVT | AK_IPGA;
854b66e4 767 knew.tlv.p = db_scale_vol_datt;
723b2b0d 768 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
683fe153 769 if (err < 0)
723b2b0d
TI		 770 return err;
771
772 if (ak->type == SND_AK5365 && (idx % 2) == 0) {
773 if (! ak->adc_info ||
a58e7cb1 774 ! ak->adc_info[mixer_ch].switch_name) {
723b2b0d 775 knew.name = "Capture Switch";
a58e7cb1
JV		 776 knew.index = mixer_ch + ak->idx_offset * 2;
777 } else
723b2b0d
TI		 778 knew.name = ak->adc_info[mixer_ch].switch_name;
779 knew.info = ak4xxx_switch_info;
780 knew.get = ak4xxx_switch_get;
781 knew.put = ak4xxx_switch_put;
782 knew.access = 0;
783 /* register 2, bit 0 (SMUTE): 0 = normal operation,
784 1 = mute */
785 knew.private_value =
786 AK_COMPOSE(idx/2, 2, 0, 0) | AK_INVERT;
787 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
788 if (err < 0)
789 return err;
a58e7cb1
JV		 790
791 memset(&knew, 0, sizeof(knew));
792 knew.name = ak->adc_info[mixer_ch].selector_name;
793 if (!knew.name) {
794 knew.name = "Capture Channel";
795 knew.index = mixer_ch + ak->idx_offset * 2;
796 }
797
798 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
799 knew.info = ak4xxx_capture_source_info;
800 knew.get = ak4xxx_capture_source_get;
801 knew.put = ak4xxx_capture_source_put;
802 knew.access = 0;
803 /* input selector control: reg. 1, bits 0-2.
804 * mis-use 'shift' to pass mixer_ch */
805 knew.private_value
806 = AK_COMPOSE(idx/2, 1, mixer_ch, 0x07);
807 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
808 if (err < 0)
809 return err;
723b2b0d 810 }
30ba6e20 811
723b2b0d
TI		 812 idx += num_stereo;
813 mixer_ch++;
683fe153 814 }
723b2b0d
TI		 815 return 0;
816}
817
818static int build_deemphasis(struct snd_akm4xxx *ak, int num_emphs)
819{
820 int idx, err;
821 struct snd_kcontrol_new knew;
683fe153 822
1da177e4 823 for (idx = 0; idx < num_emphs; idx++) {
723b2b0d
TI		 824 memset(&knew, 0, sizeof(knew));
825 knew.name = "Deemphasis";
826 knew.index = idx + ak->idx_offset;
827 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
828 knew.count = 1;
829 knew.info = snd_akm4xxx_deemphasis_info;
830 knew.get = snd_akm4xxx_deemphasis_get;
831 knew.put = snd_akm4xxx_deemphasis_put;
1da177e4
LT		 832 switch (ak->type) {
833 case SND_AK4524:
834 case SND_AK4528:
8f34692f 835 case SND_AK4620:
cb9d24e4 836 /* register 3 */
723b2b0d 837 knew.private_value = AK_COMPOSE(idx, 3, 0, 0);
1da177e4
LT		 838 break;
839 case SND_AK4529: {
840 int shift = idx == 3 ? 6 : (2 - idx) * 2;
cb9d24e4 841 /* register 8 with shift */
723b2b0d 842 knew.private_value = AK_COMPOSE(0, 8, shift, 0);
1da177e4
LT		 843 break;
844 }
845 case SND_AK4355:
846 case SND_AK4358:
723b2b0d 847 knew.private_value = AK_COMPOSE(idx, 3, 0, 0);
1da177e4
LT		 848 break;
849 case SND_AK4381:
723b2b0d 850 knew.private_value = AK_COMPOSE(idx, 1, 1, 0);
1da177e4 851 break;
cf93907b 852 default:
723b2b0d 853 return -EINVAL;
1da177e4 854 }
723b2b0d 855 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
cb9d24e4 856 if (err < 0)
723b2b0d 857 return err;
1da177e4 858 }
723b2b0d 859 return 0;
1da177e4
LT		 860}
861
8f34692f
PH		 862#ifdef CONFIG_PROC_FS
863static void proc_regs_read(struct snd_info_entry *entry,
864 struct snd_info_buffer *buffer)
865{
9fe856e4 866 struct snd_akm4xxx *ak = entry->private_data;
8f34692f
PH		 867 int reg, val, chip;
868 for (chip = 0; chip < ak->num_chips; chip++) {
869 for (reg = 0; reg < ak->total_regs; reg++) {
870 val = snd_akm4xxx_get(ak, chip, reg);
871 snd_iprintf(buffer, "chip %d: 0x%02x = 0x%02x\n", chip,
872 reg, val);
873 }
874 }
875}
876
877static int proc_init(struct snd_akm4xxx *ak)
878{
879 struct snd_info_entry *entry;
880 int err;
881 err = snd_card_proc_new(ak->card, ak->name, &entry);
882 if (err < 0)
883 return err;
884 snd_info_set_text_ops(entry, ak, proc_regs_read);
885 return 0;
886}
887#else /* !CONFIG_PROC_FS */
e913b146 888static int proc_init(struct snd_akm4xxx *ak) { return 0; }
8f34692f
PH		 889#endif
890
723b2b0d
TI		 891int snd_akm4xxx_build_controls(struct snd_akm4xxx *ak)
892{
893 int err, num_emphs;
894
895 err = build_dac_controls(ak);
896 if (err < 0)
897 return err;
898
854b66e4
TI		 899 err = build_adc_controls(ak);
900 if (err < 0)
901 return err;
723b2b0d
TI		 902 if (ak->type == SND_AK4355 || ak->type == SND_AK4358)
903 num_emphs = 1;
8f34692f
PH		 904 else if (ak->type == SND_AK4620)
905 num_emphs = 0;
723b2b0d
TI		 906 else
907 num_emphs = ak->num_dacs / 2;
908 err = build_deemphasis(ak, num_emphs);
8f34692f
PH		 909 if (err < 0)
910 return err;
911 err = proc_init(ak);
723b2b0d
TI		 912 if (err < 0)
913 return err;
914
915 return 0;
916}
cb9d24e4
TI		 917EXPORT_SYMBOL(snd_akm4xxx_build_controls);
918
1da177e4
LT		 919static int __init alsa_akm4xxx_module_init(void)
920{
921 return 0;
922}
923
924static void __exit alsa_akm4xxx_module_exit(void)
925{
926}
927
928module_init(alsa_akm4xxx_module_init)
929module_exit(alsa_akm4xxx_module_exit)
Linux 6.x block layer and io_uring tree(s)