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