1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include <asm/io.h>
25#include <linux/delay.h>
26#include <linux/interrupt.h>
27#include <linux/init.h>
28#include <linux/module.h>
29#include <sound/core.h>
30#include <sound/control.h>
31#include <sound/tlv.h>
32#include <sound/ak4xxx-adda.h>
33#include <sound/info.h>
34
35MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Takashi Iwai <tiwai@suse.de>");
36MODULE_DESCRIPTION("Routines for control of AK452x / AK43xx AD/DA converters");
37MODULE_LICENSE("GPL");
38
39
40void snd_akm4xxx_write(struct snd_akm4xxx *ak, int chip, unsigned char reg,
41 unsigned char val)
42{
43 ak->ops.lock(ak, chip);
44 ak->ops.write(ak, chip, reg, val);
45
46
47 snd_akm4xxx_set(ak, chip, reg, val);
48 ak->ops.unlock(ak, chip);
49}
50
51EXPORT_SYMBOL(snd_akm4xxx_write);
52
53
54static void ak4524_reset(struct snd_akm4xxx *ak, int state)
55{
56 unsigned int chip;
57 unsigned char reg;
58
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
64 for (reg = 0x04; reg < ak->total_regs; reg++)
65 snd_akm4xxx_write(ak, chip, reg,
66 snd_akm4xxx_get(ak, chip, reg));
67 }
68}
69
70
71static void ak435X_reset(struct snd_akm4xxx *ak, int state)
72{
73 unsigned char reg;
74
75 if (state) {
76 snd_akm4xxx_write(ak, 0, 0x01, 0x02);
77 return;
78 }
79 for (reg = 0x00; reg < ak->total_regs; reg++)
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);
84}
85
86
87static void ak4381_reset(struct snd_akm4xxx *ak, int state)
88{
89 unsigned int chip;
90 unsigned char reg;
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;
95 for (reg = 0x01; reg < ak->total_regs; reg++)
96 snd_akm4xxx_write(ak, chip, reg,
97 snd_akm4xxx_get(ak, chip, reg));
98 }
99}
100
101
102
103
104
105
106
107void snd_akm4xxx_reset(struct snd_akm4xxx *ak, int state)
108{
109 switch (ak->type) {
110 case SND_AK4524:
111 case SND_AK4528:
112 case SND_AK4620:
113 ak4524_reset(ak, state);
114 break;
115 case SND_AK4529:
116
117 break;
118 case SND_AK4355:
119 ak435X_reset(ak, state);
120 break;
121 case SND_AK4358:
122 ak435X_reset(ak, state);
123 break;
124 case SND_AK4381:
125 ak4381_reset(ak, state);
126 break;
127 default:
128 break;
129 }
130}
131
132EXPORT_SYMBOL(snd_akm4xxx_reset);
133
134
135
136
137
138
139
140
141
142static const unsigned char vol_cvt_datt[128] = {
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
163
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);
168
169
170
171
172void snd_akm4xxx_init(struct snd_akm4xxx *ak)
173{
174 static const unsigned char inits_ak4524[] = {
175 0x00, 0x07,
176 0x01, 0x00,
177 0x02, 0x60,
178 0x03, 0x19,
179 0x01, 0x03,
180 0x04, 0x00,
181 0x05, 0x00,
182 0x06, 0x00,
183 0x07, 0x00,
184 0xff, 0xff
185 };
186 static const unsigned char inits_ak4528[] = {
187 0x00, 0x07,
188 0x01, 0x00,
189 0x02, 0x60,
190 0x03, 0x0d,
191 0x01, 0x03,
192 0x04, 0x00,
193 0x05, 0x00,
194 0xff, 0xff
195 };
196 static const unsigned char inits_ak4529[] = {
197 0x09, 0x01,
198 0x0a, 0x3f,
199 0x00, 0x0c,
200 0x01, 0x00,
201 0x02, 0xff,
202 0x03, 0xff,
203 0x04, 0xff,
204 0x05, 0xff,
205 0x06, 0xff,
206 0x07, 0xff,
207 0x0b, 0xff,
208 0x0c, 0xff,
209 0x08, 0x55,
210 0xff, 0xff
211 };
212 static const unsigned char inits_ak4355[] = {
213 0x01, 0x02,
214 0x00, 0x06,
215
216 0x02, 0x0e,
217
218 0x03, 0x01,
219 0x04, 0x00,
220 0x05, 0x00,
221 0x06, 0x00,
222 0x07, 0x00,
223 0x08, 0x00,
224 0x09, 0x00,
225 0x0a, 0x00,
226 0x01, 0x01,
227 0xff, 0xff
228 };
229 static const unsigned char inits_ak4358[] = {
230 0x01, 0x02,
231 0x00, 0x06,
232
233 0x02, 0x4e,
234
235 0x03, 0x01,
236 0x04, 0x00,
237 0x05, 0x00,
238 0x06, 0x00,
239 0x07, 0x00,
240 0x08, 0x00,
241 0x09, 0x00,
242 0x0b, 0x00,
243 0x0c, 0x00,
244 0x0a, 0x00,
245 0x01, 0x01,
246 0xff, 0xff
247 };
248 static const unsigned char inits_ak4381[] = {
249 0x00, 0x0c,
250 0x01, 0x02,
251
252
253 0x02, 0x00,
254 0x03, 0x00,
255 0x04, 0x00,
256 0x00, 0x0f,
257 0xff, 0xff
258 };
259 static const unsigned char inits_ak4620[] = {
260 0x00, 0x07,
261 0x01, 0x00,
262 0x01, 0x02,
263 0x01, 0x03,
264 0x01, 0x0f,
265 0x02, 0x60,
266 0x03, 0x01,
267 0x04, 0x00,
268 0x05, 0x00,
269 0x06, 0x00,
270 0x07, 0x00,
271 0xff, 0xff
272 };
273
274 int chip;
275 const unsigned char *ptr, *inits;
276 unsigned char reg, data;
277
278 memset(ak->images, 0, sizeof(ak->images));
279 memset(ak->volumes, 0, sizeof(ak->volumes));
280
281 switch (ak->type) {
282 case SND_AK4524:
283 inits = inits_ak4524;
284 ak->num_chips = ak->num_dacs / 2;
285 ak->name = "ak4524";
286 ak->total_regs = 0x08;
287 break;
288 case SND_AK4528:
289 inits = inits_ak4528;
290 ak->num_chips = ak->num_dacs / 2;
291 ak->name = "ak4528";
292 ak->total_regs = 0x06;
293 break;
294 case SND_AK4529:
295 inits = inits_ak4529;
296 ak->num_chips = 1;
297 ak->name = "ak4529";
298 ak->total_regs = 0x0d;
299 break;
300 case SND_AK4355:
301 inits = inits_ak4355;
302 ak->num_chips = 1;
303 ak->name = "ak4355";
304 ak->total_regs = 0x0b;
305 break;
306 case SND_AK4358:
307 inits = inits_ak4358;
308 ak->num_chips = 1;
309 ak->name = "ak4358";
310 ak->total_regs = 0x10;
311 break;
312 case SND_AK4381:
313 inits = inits_ak4381;
314 ak->num_chips = ak->num_dacs / 2;
315 ak->name = "ak4381";
316 ak->total_regs = 0x05;
317 break;
318 case SND_AK5365:
319
320 ak->num_chips = 1;
321 ak->name = "ak5365";
322 ak->total_regs = 0x08;
323 return;
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;
330 default:
331 snd_BUG();
332 return;
333 }
334
335 for (chip = 0; chip < ak->num_chips; chip++) {
336 ptr = inits;
337 while (*ptr != 0xff) {
338 reg = *ptr++;
339 data = *ptr++;
340 snd_akm4xxx_write(ak, chip, reg, data);
341 udelay(10);
342 }
343 }
344}
345
346EXPORT_SYMBOL(snd_akm4xxx_init);
347
348
349
350
351#define AK_IPGA (1<<20)
352#define AK_VOL_CVT (1<<21)
353#define AK_NEEDSMSB (1<<22)
354#define AK_INVERT (1<<23)
355#define AK_GET_CHIP(val) (((val) >> 8) & 0xff)
356#define AK_GET_ADDR(val) ((val) & 0xff)
357#define AK_GET_SHIFT(val) (((val) >> 16) & 0x0f)
358#define AK_GET_VOL_CVT(val) (((val) >> 21) & 1)
359#define AK_GET_IPGA(val) (((val) >> 20) & 1)
360#define AK_GET_NEEDSMSB(val) (((val) >> 22) & 1)
361#define AK_GET_INVERT(val) (((val) >> 23) & 1)
362#define AK_GET_MASK(val) (((val) >> 24) & 0xff)
363#define AK_COMPOSE(chip,addr,shift,mask) \
364 (((chip) << 8) | (addr) | ((shift) << 16) | ((mask) << 24))
365
366static int snd_akm4xxx_volume_info(struct snd_kcontrol *kcontrol,
367 struct snd_ctl_elem_info *uinfo)
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
378static int snd_akm4xxx_volume_get(struct snd_kcontrol *kcontrol,
379 struct snd_ctl_elem_value *ucontrol)
380{
381 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
382 int chip = AK_GET_CHIP(kcontrol->private_value);
383 int addr = AK_GET_ADDR(kcontrol->private_value);
384
385 ucontrol->value.integer.value[0] = snd_akm4xxx_get_vol(ak, chip, addr);
386 return 0;
387}
388
389static int put_ak_reg(struct snd_kcontrol *kcontrol, int addr,
390 unsigned char nval)
391{
392 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
393 unsigned int mask = AK_GET_MASK(kcontrol->private_value);
394 int chip = AK_GET_CHIP(kcontrol->private_value);
395
396 if (snd_akm4xxx_get_vol(ak, chip, addr) == nval)
397 return 0;
398
399 snd_akm4xxx_set_vol(ak, chip, addr, nval);
400 if (AK_GET_VOL_CVT(kcontrol->private_value) && nval < 128)
401 nval = vol_cvt_datt[nval];
402 if (AK_GET_IPGA(kcontrol->private_value) && nval >= 128)
403 nval++;
404 if (AK_GET_INVERT(kcontrol->private_value))
405 nval = mask - nval;
406 if (AK_GET_NEEDSMSB(kcontrol->private_value))
407 nval |= 0x80;
408
409
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{
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);
422}
423
424static int snd_akm4xxx_stereo_volume_info(struct snd_kcontrol *kcontrol,
425 struct snd_ctl_elem_info *uinfo)
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,
437 struct snd_ctl_elem_value *ucontrol)
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);
442
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);
445 return 0;
446}
447
448static int snd_akm4xxx_stereo_volume_put(struct snd_kcontrol *kcontrol,
449 struct snd_ctl_elem_value *ucontrol)
450{
451 int addr = AK_GET_ADDR(kcontrol->private_value);
452 unsigned int mask = AK_GET_MASK(kcontrol->private_value);
453 unsigned int val[2];
454 int change;
455
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]);
462 return change;
463}
464
465static int snd_akm4xxx_deemphasis_info(struct snd_kcontrol *kcontrol,
466 struct snd_ctl_elem_info *uinfo)
467{
468 static char *texts[4] = {
469 "44.1kHz", "Off", "48kHz", "32kHz",
470 };
471 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
472 uinfo->count = 1;
473 uinfo->value.enumerated.items = 4;
474 if (uinfo->value.enumerated.item >= 4)
475 uinfo->value.enumerated.item = 3;
476 strcpy(uinfo->value.enumerated.name,
477 texts[uinfo->value.enumerated.item]);
478 return 0;
479}
480
481static int snd_akm4xxx_deemphasis_get(struct snd_kcontrol *kcontrol,
482 struct snd_ctl_elem_value *ucontrol)
483{
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 ucontrol->value.enumerated.item[0] =
489 (snd_akm4xxx_get(ak, chip, addr) >> shift) & 3;
490 return 0;
491}
492
493static int snd_akm4xxx_deemphasis_put(struct snd_kcontrol *kcontrol,
494 struct snd_ctl_elem_value *ucontrol)
495{
496 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
497 int chip = AK_GET_CHIP(kcontrol->private_value);
498 int addr = AK_GET_ADDR(kcontrol->private_value);
499 int shift = AK_GET_SHIFT(kcontrol->private_value);
500 unsigned char nval = ucontrol->value.enumerated.item[0] & 3;
501 int change;
502
503 nval = (nval << shift) |
504 (snd_akm4xxx_get(ak, chip, addr) & ~(3 << shift));
505 change = snd_akm4xxx_get(ak, chip, addr) != nval;
506 if (change)
507 snd_akm4xxx_write(ak, chip, addr, nval);
508 return change;
509}
510
511#define ak4xxx_switch_info snd_ctl_boolean_mono_info
512
513static int ak4xxx_switch_get(struct snd_kcontrol *kcontrol,
514 struct snd_ctl_elem_value *ucontrol)
515{
516 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
517 int chip = AK_GET_CHIP(kcontrol->private_value);
518 int addr = AK_GET_ADDR(kcontrol->private_value);
519 int shift = AK_GET_SHIFT(kcontrol->private_value);
520 int invert = AK_GET_INVERT(kcontrol->private_value);
521
522 unsigned char val = snd_akm4xxx_get(ak, chip, addr) & (1<<shift);
523 if (invert)
524 val = ! val;
525 ucontrol->value.integer.value[0] = (val & (1<<shift)) != 0;
526 return 0;
527}
528
529static int ak4xxx_switch_put(struct snd_kcontrol *kcontrol,
530 struct snd_ctl_elem_value *ucontrol)
531{
532 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
533 int chip = AK_GET_CHIP(kcontrol->private_value);
534 int addr = AK_GET_ADDR(kcontrol->private_value);
535 int shift = AK_GET_SHIFT(kcontrol->private_value);
536 int invert = AK_GET_INVERT(kcontrol->private_value);
537 long flag = ucontrol->value.integer.value[0];
538 unsigned char val, oval;
539 int change;
540
541 if (invert)
542 flag = ! flag;
543 oval = snd_akm4xxx_get(ak, chip, addr);
544 if (flag)
545 val = oval | (1<<shift);
546 else
547 val = oval & ~(1<<shift);
548 change = (oval != val);
549 if (change)
550 snd_akm4xxx_write(ak, chip, addr, val);
551 return change;
552}
553
554#define AK5365_NUM_INPUTS 5
555
556static int ak4xxx_capture_num_inputs(struct snd_akm4xxx *ak, int mixer_ch)
557{
558 int num_names;
559 const char **input_names;
560
561 input_names = ak->adc_info[mixer_ch].input_names;
562 num_names = 0;
563 while (num_names < AK5365_NUM_INPUTS && input_names[num_names])
564 ++num_names;
565 return num_names;
566}
567
568static int ak4xxx_capture_source_info(struct snd_kcontrol *kcontrol,
569 struct snd_ctl_elem_info *uinfo)
570{
571 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
572 int mixer_ch = AK_GET_SHIFT(kcontrol->private_value);
573 const char **input_names;
574 int num_names, idx;
575
576 num_names = ak4xxx_capture_num_inputs(ak, mixer_ch);
577 if (!num_names)
578 return -EINVAL;
579 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
580 uinfo->count = 1;
581 uinfo->value.enumerated.items = num_names;
582 idx = uinfo->value.enumerated.item;
583 if (idx >= num_names)
584 return -EINVAL;
585 input_names = ak->adc_info[mixer_ch].input_names;
586 strncpy(uinfo->value.enumerated.name, input_names[idx],
587 sizeof(uinfo->value.enumerated.name));
588 return 0;
589}
590
591static int ak4xxx_capture_source_get(struct snd_kcontrol *kcontrol,
592 struct snd_ctl_elem_value *ucontrol)
593{
594 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
595 int chip = AK_GET_CHIP(kcontrol->private_value);
596 int addr = AK_GET_ADDR(kcontrol->private_value);
597 int mask = AK_GET_MASK(kcontrol->private_value);
598 unsigned char val;
599
600 val = snd_akm4xxx_get(ak, chip, addr) & mask;
601 ucontrol->value.enumerated.item[0] = val;
602 return 0;
603}
604
605static int ak4xxx_capture_source_put(struct snd_kcontrol *kcontrol,
606 struct snd_ctl_elem_value *ucontrol)
607{
608 struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol);
609 int mixer_ch = AK_GET_SHIFT(kcontrol->private_value);
610 int chip = AK_GET_CHIP(kcontrol->private_value);
611 int addr = AK_GET_ADDR(kcontrol->private_value);
612 int mask = AK_GET_MASK(kcontrol->private_value);
613 unsigned char oval, val;
614 int num_names = ak4xxx_capture_num_inputs(ak, mixer_ch);
615
616 if (ucontrol->value.enumerated.item[0] >= num_names)
617 return -EINVAL;
618
619 oval = snd_akm4xxx_get(ak, chip, addr);
620 val = oval & ~mask;
621 val |= ucontrol->value.enumerated.item[0] & mask;
622 if (val != oval) {
623 snd_akm4xxx_write(ak, chip, addr, val);
624 return 1;
625 }
626 return 0;
627}
628
629
630
631
632
633static int build_dac_controls(struct snd_akm4xxx *ak)
634{
635 int idx, err, mixer_ch, num_stereo;
636 struct snd_kcontrol_new knew;
637
638 mixer_ch = 0;
639 for (idx = 0; idx < ak->num_dacs; ) {
640
641 if (ak->type == SND_AK4381
642 && ak->dac_info[mixer_ch].switch_name) {
643 memset(&knew, 0, sizeof(knew));
644 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
645 knew.count = 1;
646 knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
647 knew.name = ak->dac_info[mixer_ch].switch_name;
648 knew.info = ak4xxx_switch_info;
649 knew.get = ak4xxx_switch_get;
650 knew.put = ak4xxx_switch_put;
651 knew.access = 0;
652
653
654 knew.private_value =
655 AK_COMPOSE(idx/2, 1, 0, 0) | AK_INVERT;
656 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
657 if (err < 0)
658 return err;
659 }
660 memset(&knew, 0, sizeof(knew));
661 if (! ak->dac_info || ! ak->dac_info[mixer_ch].name) {
662 knew.name = "DAC Volume";
663 knew.index = mixer_ch + ak->idx_offset * 2;
664 num_stereo = 1;
665 } else {
666 knew.name = ak->dac_info[mixer_ch].name;
667 num_stereo = ak->dac_info[mixer_ch].num_channels;
668 }
669 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
670 knew.count = 1;
671 knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
672 SNDRV_CTL_ELEM_ACCESS_TLV_READ;
673 if (num_stereo == 2) {
674 knew.info = snd_akm4xxx_stereo_volume_info;
675 knew.get = snd_akm4xxx_stereo_volume_get;
676 knew.put = snd_akm4xxx_stereo_volume_put;
677 } else {
678 knew.info = snd_akm4xxx_volume_info;
679 knew.get = snd_akm4xxx_volume_get;
680 knew.put = snd_akm4xxx_volume_put;
681 }
682 switch (ak->type) {
683 case SND_AK4524:
684
685 knew.private_value =
686 AK_COMPOSE(idx/2, (idx%2) + 6, 0, 127) |
687 AK_VOL_CVT;
688 knew.tlv.p = db_scale_vol_datt;
689 break;
690 case SND_AK4528:
691
692 knew.private_value =
693 AK_COMPOSE(idx/2, (idx%2) + 4, 0, 127) |
694 AK_VOL_CVT;
695 knew.tlv.p = db_scale_vol_datt;
696 break;
697 case SND_AK4529: {
698
699 int val = idx < 6 ? idx + 2 : (idx - 6) + 0xb;
700 knew.private_value =
701 AK_COMPOSE(0, val, 0, 255) | AK_INVERT;
702 knew.tlv.p = db_scale_8bit;
703 break;
704 }
705 case SND_AK4355:
706
707 knew.private_value = AK_COMPOSE(0, idx + 4, 0, 255);
708 knew.tlv.p = db_scale_8bit;
709 break;
710 case SND_AK4358: {
711
712 int addr = idx < 6 ? idx + 4 : idx + 5;
713 knew.private_value =
714 AK_COMPOSE(0, addr, 0, 127) | AK_NEEDSMSB;
715 knew.tlv.p = db_scale_7bit;
716 break;
717 }
718 case SND_AK4381:
719
720 knew.private_value =
721 AK_COMPOSE(idx/2, (idx%2) + 3, 0, 255);
722 knew.tlv.p = db_scale_linear;
723 break;
724 case SND_AK4620:
725
726 knew.private_value =
727 AK_COMPOSE(idx/2, (idx%2) + 6, 0, 255);
728 knew.tlv.p = db_scale_linear;
729 break;
730 default:
731 return -EINVAL;
732 }
733
734 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
735 if (err < 0)
736 return err;
737
738 idx += num_stereo;
739 mixer_ch++;
740 }
741 return 0;
742}
743
744static int build_adc_controls(struct snd_akm4xxx *ak)
745{
746 int idx, err, mixer_ch, num_stereo, max_steps;
747 struct snd_kcontrol_new knew;
748
749 mixer_ch = 0;
750 if (ak->type == SND_AK4528)
751 return 0;
752 for (idx = 0; idx < ak->num_adcs;) {
753 memset(&knew, 0, sizeof(knew));
754 if (! ak->adc_info || ! ak->adc_info[mixer_ch].name) {
755 knew.name = "ADC Volume";
756 knew.index = mixer_ch + ak->idx_offset * 2;
757 num_stereo = 1;
758 } else {
759 knew.name = ak->adc_info[mixer_ch].name;
760 num_stereo = ak->adc_info[mixer_ch].num_channels;
761 }
762 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
763 knew.count = 1;
764 knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
765 SNDRV_CTL_ELEM_ACCESS_TLV_READ;
766 if (num_stereo == 2) {
767 knew.info = snd_akm4xxx_stereo_volume_info;
768 knew.get = snd_akm4xxx_stereo_volume_get;
769 knew.put = snd_akm4xxx_stereo_volume_put;
770 } else {
771 knew.info = snd_akm4xxx_volume_info;
772 knew.get = snd_akm4xxx_volume_get;
773 knew.put = snd_akm4xxx_volume_put;
774 }
775
776 if (ak->type == SND_AK5365)
777 max_steps = 152;
778 else
779 max_steps = 164;
780 knew.private_value =
781 AK_COMPOSE(idx/2, (idx%2) + 4, 0, max_steps) |
782 AK_VOL_CVT | AK_IPGA;
783 knew.tlv.p = db_scale_vol_datt;
784 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
785 if (err < 0)
786 return err;
787
788 if (ak->type == SND_AK5365 && (idx % 2) == 0) {
789 if (! ak->adc_info ||
790 ! ak->adc_info[mixer_ch].switch_name) {
791 knew.name = "Capture Switch";
792 knew.index = mixer_ch + ak->idx_offset * 2;
793 } else
794 knew.name = ak->adc_info[mixer_ch].switch_name;
795 knew.info = ak4xxx_switch_info;
796 knew.get = ak4xxx_switch_get;
797 knew.put = ak4xxx_switch_put;
798 knew.access = 0;
799
800
801 knew.private_value =
802 AK_COMPOSE(idx/2, 2, 0, 0) | AK_INVERT;
803 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
804 if (err < 0)
805 return err;
806
807 memset(&knew, 0, sizeof(knew));
808 knew.name = ak->adc_info[mixer_ch].selector_name;
809 if (!knew.name) {
810 knew.name = "Capture Channel";
811 knew.index = mixer_ch + ak->idx_offset * 2;
812 }
813
814 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
815 knew.info = ak4xxx_capture_source_info;
816 knew.get = ak4xxx_capture_source_get;
817 knew.put = ak4xxx_capture_source_put;
818 knew.access = 0;
819
820
821 knew.private_value
822 = AK_COMPOSE(idx/2, 1, mixer_ch, 0x07);
823 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
824 if (err < 0)
825 return err;
826 }
827
828 idx += num_stereo;
829 mixer_ch++;
830 }
831 return 0;
832}
833
834static int build_deemphasis(struct snd_akm4xxx *ak, int num_emphs)
835{
836 int idx, err;
837 struct snd_kcontrol_new knew;
838
839 for (idx = 0; idx < num_emphs; idx++) {
840 memset(&knew, 0, sizeof(knew));
841 knew.name = "Deemphasis";
842 knew.index = idx + ak->idx_offset;
843 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
844 knew.count = 1;
845 knew.info = snd_akm4xxx_deemphasis_info;
846 knew.get = snd_akm4xxx_deemphasis_get;
847 knew.put = snd_akm4xxx_deemphasis_put;
848 switch (ak->type) {
849 case SND_AK4524:
850 case SND_AK4528:
851 case SND_AK4620:
852
853 knew.private_value = AK_COMPOSE(idx, 3, 0, 0);
854 break;
855 case SND_AK4529: {
856 int shift = idx == 3 ? 6 : (2 - idx) * 2;
857
858 knew.private_value = AK_COMPOSE(0, 8, shift, 0);
859 break;
860 }
861 case SND_AK4355:
862 case SND_AK4358:
863 knew.private_value = AK_COMPOSE(idx, 3, 0, 0);
864 break;
865 case SND_AK4381:
866 knew.private_value = AK_COMPOSE(idx, 1, 1, 0);
867 break;
868 default:
869 return -EINVAL;
870 }
871 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
872 if (err < 0)
873 return err;
874 }
875 return 0;
876}
877
878#ifdef CONFIG_PROC_FS
879static void proc_regs_read(struct snd_info_entry *entry,
880 struct snd_info_buffer *buffer)
881{
882 struct snd_akm4xxx *ak = entry->private_data;
883 int reg, val, chip;
884 for (chip = 0; chip < ak->num_chips; chip++) {
885 for (reg = 0; reg < ak->total_regs; reg++) {
886 val = snd_akm4xxx_get(ak, chip, reg);
887 snd_iprintf(buffer, "chip %d: 0x%02x = 0x%02x\n", chip,
888 reg, val);
889 }
890 }
891}
892
893static int proc_init(struct snd_akm4xxx *ak)
894{
895 struct snd_info_entry *entry;
896 int err;
897 err = snd_card_proc_new(ak->card, ak->name, &entry);
898 if (err < 0)
899 return err;
900 snd_info_set_text_ops(entry, ak, proc_regs_read);
901 return 0;
902}
903#else
904static int proc_init(struct snd_akm4xxx *ak) { return 0; }
905#endif
906
907int snd_akm4xxx_build_controls(struct snd_akm4xxx *ak)
908{
909 int err, num_emphs;
910
911 err = build_dac_controls(ak);
912 if (err < 0)
913 return err;
914
915 err = build_adc_controls(ak);
916 if (err < 0)
917 return err;
918 if (ak->type == SND_AK4355 || ak->type == SND_AK4358)
919 num_emphs = 1;
920 else if (ak->type == SND_AK4620)
921 num_emphs = 0;
922 else
923 num_emphs = ak->num_dacs / 2;
924 err = build_deemphasis(ak, num_emphs);
925 if (err < 0)
926 return err;
927 err = proc_init(ak);
928 if (err < 0)
929 return err;
930
931 return 0;
932}
933EXPORT_SYMBOL(snd_akm4xxx_build_controls);
934
935static int __init alsa_akm4xxx_module_init(void)
936{
937 return 0;
938}
939
940static void __exit alsa_akm4xxx_module_exit(void)
941{
942}
943
944module_init(alsa_akm4xxx_module_init)
945module_exit(alsa_akm4xxx_module_exit)
946