1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#include <linux/delay.h>
27#include <linux/interrupt.h>
28#include <linux/init.h>
29#include <linux/slab.h>
30#include <sound/core.h>
31#include <sound/tlv.h>
32
33#include "ice1712.h"
34#include "envy24ht.h"
35#include "juli.h"
36
37struct juli_spec {
38 struct ak4114 *ak4114;
39 unsigned int analog:1;
40};
41
42
43
44
45#define AK4114_ADDR 0x20
46#define AK4358_ADDR 0x22
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77#define GPIO_FREQ_MASK (3<<0)
78#define GPIO_FREQ_32KHZ (0<<0)
79#define GPIO_FREQ_44KHZ (1<<0)
80#define GPIO_FREQ_48KHZ (2<<0)
81#define GPIO_MULTI_MASK (3<<2)
82#define GPIO_MULTI_4X (0<<2)
83#define GPIO_MULTI_2X (1<<2)
84#define GPIO_MULTI_1X (2<<2)
85#define GPIO_MULTI_HALF (3<<2)
86#define GPIO_INTERNAL_CLOCK (1<<4)
87#define GPIO_CLOCK_MASK (1<<4)
88#define GPIO_ANALOG_PRESENT (1<<5)
89#define GPIO_RXMCLK_SEL (1<<7)
90#define GPIO_AK5385A_CKS0 (1<<8)
91#define GPIO_AK5385A_DFS1 (1<<9)
92#define GPIO_AK5385A_DFS0 (1<<10)
93#define GPIO_DIGOUT_MONITOR (1<<11)
94#define GPIO_DIGIN_MONITOR (1<<12)
95#define GPIO_ANAIN_MONITOR (1<<13)
96#define GPIO_AK5385A_CKS1 (1<<14)
97#define GPIO_MUTE_CONTROL (1<<15)
98
99#define GPIO_RATE_MASK (GPIO_FREQ_MASK | GPIO_MULTI_MASK | \
100 GPIO_CLOCK_MASK)
101#define GPIO_AK5385A_MASK (GPIO_AK5385A_CKS0 | GPIO_AK5385A_DFS0 | \
102 GPIO_AK5385A_DFS1 | GPIO_AK5385A_CKS1)
103
104#define JULI_PCM_RATE (SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 | \
105 SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | \
106 SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_64000 | \
107 SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000 | \
108 SNDRV_PCM_RATE_176400 | SNDRV_PCM_RATE_192000)
109
110#define GPIO_RATE_16000 (GPIO_FREQ_32KHZ | GPIO_MULTI_HALF | \
111 GPIO_INTERNAL_CLOCK)
112#define GPIO_RATE_22050 (GPIO_FREQ_44KHZ | GPIO_MULTI_HALF | \
113 GPIO_INTERNAL_CLOCK)
114#define GPIO_RATE_24000 (GPIO_FREQ_48KHZ | GPIO_MULTI_HALF | \
115 GPIO_INTERNAL_CLOCK)
116#define GPIO_RATE_32000 (GPIO_FREQ_32KHZ | GPIO_MULTI_1X | \
117 GPIO_INTERNAL_CLOCK)
118#define GPIO_RATE_44100 (GPIO_FREQ_44KHZ | GPIO_MULTI_1X | \
119 GPIO_INTERNAL_CLOCK)
120#define GPIO_RATE_48000 (GPIO_FREQ_48KHZ | GPIO_MULTI_1X | \
121 GPIO_INTERNAL_CLOCK)
122#define GPIO_RATE_64000 (GPIO_FREQ_32KHZ | GPIO_MULTI_2X | \
123 GPIO_INTERNAL_CLOCK)
124#define GPIO_RATE_88200 (GPIO_FREQ_44KHZ | GPIO_MULTI_2X | \
125 GPIO_INTERNAL_CLOCK)
126#define GPIO_RATE_96000 (GPIO_FREQ_48KHZ | GPIO_MULTI_2X | \
127 GPIO_INTERNAL_CLOCK)
128#define GPIO_RATE_176400 (GPIO_FREQ_44KHZ | GPIO_MULTI_4X | \
129 GPIO_INTERNAL_CLOCK)
130#define GPIO_RATE_192000 (GPIO_FREQ_48KHZ | GPIO_MULTI_4X | \
131 GPIO_INTERNAL_CLOCK)
132
133
134
135
136static unsigned int juli_rates[] = {
137 16000, 22050, 24000, 32000,
138 44100, 48000, 64000, 88200,
139 96000, 176400, 192000,
140};
141
142static unsigned int gpio_vals[] = {
143 GPIO_RATE_16000, GPIO_RATE_22050, GPIO_RATE_24000, GPIO_RATE_32000,
144 GPIO_RATE_44100, GPIO_RATE_48000, GPIO_RATE_64000, GPIO_RATE_88200,
145 GPIO_RATE_96000, GPIO_RATE_176400, GPIO_RATE_192000,
146};
147
148static struct snd_pcm_hw_constraint_list juli_rates_info = {
149 .count = ARRAY_SIZE(juli_rates),
150 .list = juli_rates,
151 .mask = 0,
152};
153
154static int get_gpio_val(int rate)
155{
156 int i;
157 for (i = 0; i < ARRAY_SIZE(juli_rates); i++)
158 if (juli_rates[i] == rate)
159 return gpio_vals[i];
160 return 0;
161}
162
163static void juli_ak4114_write(void *private_data, unsigned char reg,
164 unsigned char val)
165{
166 snd_vt1724_write_i2c((struct snd_ice1712 *)private_data, AK4114_ADDR,
167 reg, val);
168}
169
170static unsigned char juli_ak4114_read(void *private_data, unsigned char reg)
171{
172 return snd_vt1724_read_i2c((struct snd_ice1712 *)private_data,
173 AK4114_ADDR, reg);
174}
175
176
177
178
179
180static void juli_spdif_in_open(struct snd_ice1712 *ice,
181 struct snd_pcm_substream *substream)
182{
183 struct juli_spec *spec = ice->spec;
184 struct snd_pcm_runtime *runtime = substream->runtime;
185 int rate;
186
187 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK ||
188 !ice->is_spdif_master(ice))
189 return;
190 rate = snd_ak4114_external_rate(spec->ak4114);
191 if (rate >= runtime->hw.rate_min && rate <= runtime->hw.rate_max) {
192 runtime->hw.rate_min = rate;
193 runtime->hw.rate_max = rate;
194 }
195}
196
197
198
199
200
201static void juli_akm_lock(struct snd_akm4xxx *ak, int chip)
202{
203}
204
205static void juli_akm_unlock(struct snd_akm4xxx *ak, int chip)
206{
207}
208
209static void juli_akm_write(struct snd_akm4xxx *ak, int chip,
210 unsigned char addr, unsigned char data)
211{
212 struct snd_ice1712 *ice = ak->private_data[0];
213
214 if (snd_BUG_ON(chip))
215 return;
216 snd_vt1724_write_i2c(ice, AK4358_ADDR, addr, data);
217}
218
219
220
221
222static void juli_akm_set_rate_val(struct snd_akm4xxx *ak, unsigned int rate)
223{
224 unsigned char old, tmp, ak4358_dfs;
225 unsigned int ak5385_pins, old_gpio, new_gpio;
226 struct snd_ice1712 *ice = ak->private_data[0];
227 struct juli_spec *spec = ice->spec;
228
229 if (rate == 0)
230
231 return;
232
233
234 if (rate > 96000) {
235 ak4358_dfs = 2;
236 ak5385_pins = GPIO_AK5385A_DFS1 | GPIO_AK5385A_CKS0;
237 } else if (rate > 48000) {
238 ak4358_dfs = 1;
239 ak5385_pins = GPIO_AK5385A_DFS0;
240 } else {
241 ak4358_dfs = 0;
242 ak5385_pins = 0;
243 }
244
245 old_gpio = ice->gpio.get_data(ice);
246 new_gpio = (old_gpio & ~GPIO_AK5385A_MASK) | ak5385_pins;
247
248
249 ice->gpio.set_data(ice, new_gpio);
250
251
252 old = inb(ICEMT1724(ice, AC97_CMD));
253 outb(old | VT1724_AC97_COLD, ICEMT1724(ice, AC97_CMD));
254 udelay(1);
255 outb(old & ~VT1724_AC97_COLD, ICEMT1724(ice, AC97_CMD));
256
257
258
259 tmp = snd_akm4xxx_get(ak, 0, 2);
260 snd_akm4xxx_reset(ak, 1);
261 tmp = snd_akm4xxx_get(ak, 0, 2);
262 tmp &= ~(0x03 << 4);
263 tmp |= ak4358_dfs << 4;
264 snd_akm4xxx_set(ak, 0, 2, tmp);
265 snd_akm4xxx_reset(ak, 0);
266
267
268 snd_ak4114_reinit(spec->ak4114);
269}
270
271#define AK_DAC(xname, xch) { .name = xname, .num_channels = xch }
272#define PCM_VOLUME "PCM Playback Volume"
273#define MONITOR_AN_IN_VOLUME "Monitor Analog In Volume"
274#define MONITOR_DIG_IN_VOLUME "Monitor Digital In Volume"
275#define MONITOR_DIG_OUT_VOLUME "Monitor Digital Out Volume"
276
277static const struct snd_akm4xxx_dac_channel juli_dac[] = {
278 AK_DAC(PCM_VOLUME, 2),
279 AK_DAC(MONITOR_AN_IN_VOLUME, 2),
280 AK_DAC(MONITOR_DIG_OUT_VOLUME, 2),
281 AK_DAC(MONITOR_DIG_IN_VOLUME, 2),
282};
283
284
285static struct snd_akm4xxx akm_juli_dac = {
286 .type = SND_AK4358,
287 .num_dacs = 8,
288
289
290
291
292 .ops = {
293 .lock = juli_akm_lock,
294 .unlock = juli_akm_unlock,
295 .write = juli_akm_write,
296 .set_rate_val = juli_akm_set_rate_val
297 },
298 .dac_info = juli_dac,
299};
300
301#define juli_mute_info snd_ctl_boolean_mono_info
302
303static int juli_mute_get(struct snd_kcontrol *kcontrol,
304 struct snd_ctl_elem_value *ucontrol)
305{
306 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
307 unsigned int val;
308 val = ice->gpio.get_data(ice) & (unsigned int) kcontrol->private_value;
309 if (kcontrol->private_value == GPIO_MUTE_CONTROL)
310
311 ucontrol->value.integer.value[0] = (val) ? 0 : 1;
312 else
313
314 ucontrol->value.integer.value[0] = (val) ? 1 : 0;
315 return 0;
316}
317
318static int juli_mute_put(struct snd_kcontrol *kcontrol,
319 struct snd_ctl_elem_value *ucontrol)
320{
321 struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
322 unsigned int old_gpio, new_gpio;
323 old_gpio = ice->gpio.get_data(ice);
324 if (ucontrol->value.integer.value[0]) {
325
326 if (kcontrol->private_value == GPIO_MUTE_CONTROL) {
327
328 new_gpio = old_gpio & ~GPIO_MUTE_CONTROL;
329
330 snd_akm4xxx_write(ice->akm, 0, 0x01, 0x01);
331 } else
332
333 new_gpio = old_gpio |
334 (unsigned int) kcontrol->private_value;
335 } else {
336
337 if (kcontrol->private_value == GPIO_MUTE_CONTROL) {
338
339 new_gpio = old_gpio | GPIO_MUTE_CONTROL;
340
341 snd_akm4xxx_write(ice->akm, 0, 0x01, 0x03);
342 } else
343
344 new_gpio = old_gpio &
345 ~((unsigned int) kcontrol->private_value);
346 }
347
348
349
350
351
352 if (old_gpio != new_gpio) {
353 ice->gpio.set_data(ice, new_gpio);
354 return 1;
355 }
356
357 return 0;
358}
359
360static struct snd_kcontrol_new juli_mute_controls[] = {
361 {
362 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
363 .name = "Master Playback Switch",
364 .info = juli_mute_info,
365 .get = juli_mute_get,
366 .put = juli_mute_put,
367 .private_value = GPIO_MUTE_CONTROL,
368 },
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388 {
389 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
390 .name = "Monitor Analog In Switch",
391 .info = juli_mute_info,
392 .get = juli_mute_get,
393 .put = juli_mute_put,
394 .private_value = GPIO_ANAIN_MONITOR,
395 },
396 {
397 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
398 .name = "Monitor Digital Out Switch",
399 .info = juli_mute_info,
400 .get = juli_mute_get,
401 .put = juli_mute_put,
402 .private_value = GPIO_DIGOUT_MONITOR,
403 },
404 {
405 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
406 .name = "Monitor Digital In Switch",
407 .info = juli_mute_info,
408 .get = juli_mute_get,
409 .put = juli_mute_put,
410 .private_value = GPIO_DIGIN_MONITOR,
411 },
412};
413
414static char *slave_vols[] = {
415 PCM_VOLUME,
416 MONITOR_AN_IN_VOLUME,
417 MONITOR_DIG_IN_VOLUME,
418 MONITOR_DIG_OUT_VOLUME,
419 NULL
420};
421
422static
423DECLARE_TLV_DB_SCALE(juli_master_db_scale, -6350, 50, 1);
424
425static struct snd_kcontrol *ctl_find(struct snd_card *card,
426 const char *name)
427{
428 struct snd_ctl_elem_id sid;
429 memset(&sid, 0, sizeof(sid));
430
431 strcpy(sid.name, name);
432 sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
433 return snd_ctl_find_id(card, &sid);
434}
435
436static void add_slaves(struct snd_card *card,
437 struct snd_kcontrol *master,
438 char * const *list)
439{
440 for (; *list; list++) {
441 struct snd_kcontrol *slave = ctl_find(card, *list);
442
443 if (slave) {
444
445 snd_ctl_add_slave(master, slave);
446 }
447 }
448}
449
450static int juli_add_controls(struct snd_ice1712 *ice)
451{
452 struct juli_spec *spec = ice->spec;
453 int err;
454 unsigned int i;
455 struct snd_kcontrol *vmaster;
456
457 err = snd_ice1712_akm4xxx_build_controls(ice);
458 if (err < 0)
459 return err;
460
461 for (i = 0; i < ARRAY_SIZE(juli_mute_controls); i++) {
462 err = snd_ctl_add(ice->card,
463 snd_ctl_new1(&juli_mute_controls[i], ice));
464 if (err < 0)
465 return err;
466 }
467
468 vmaster = snd_ctl_make_virtual_master("Master Playback Volume",
469 juli_master_db_scale);
470 if (!vmaster)
471 return -ENOMEM;
472 add_slaves(ice->card, vmaster, slave_vols);
473 err = snd_ctl_add(ice->card, vmaster);
474 if (err < 0)
475 return err;
476
477
478 err = snd_ak4114_build(spec->ak4114, NULL,
479 ice->pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream);
480 if (err < 0)
481 return err;
482 return 0;
483}
484
485
486
487
488
489#ifdef CONFIG_PM_SLEEP
490static int juli_resume(struct snd_ice1712 *ice)
491{
492 struct snd_akm4xxx *ak = ice->akm;
493 struct juli_spec *spec = ice->spec;
494
495 snd_akm4xxx_reset(ak, 0);
496
497 snd_ak4114_reinit(spec->ak4114);
498 return 0;
499}
500
501static int juli_suspend(struct snd_ice1712 *ice)
502{
503 struct snd_akm4xxx *ak = ice->akm;
504
505 snd_akm4xxx_reset(ak, 1);
506 return 0;
507}
508#endif
509
510
511
512
513
514static inline int juli_is_spdif_master(struct snd_ice1712 *ice)
515{
516 return (ice->gpio.get_data(ice) & GPIO_INTERNAL_CLOCK) ? 0 : 1;
517}
518
519static unsigned int juli_get_rate(struct snd_ice1712 *ice)
520{
521 int i;
522 unsigned char result;
523
524 result = ice->gpio.get_data(ice) & GPIO_RATE_MASK;
525 for (i = 0; i < ARRAY_SIZE(gpio_vals); i++)
526 if (gpio_vals[i] == result)
527 return juli_rates[i];
528 return 0;
529}
530
531
532static void juli_set_rate(struct snd_ice1712 *ice, unsigned int rate)
533{
534 unsigned int old, new;
535 unsigned char val;
536
537 old = ice->gpio.get_data(ice);
538 new = (old & ~GPIO_RATE_MASK) | get_gpio_val(rate);
539
540
541
542
543 ice->gpio.set_data(ice, new);
544
545 val = inb(ICEMT1724(ice, RATE));
546 outb(val | VT1724_SPDIF_MASTER, ICEMT1724(ice, RATE));
547}
548
549static inline unsigned char juli_set_mclk(struct snd_ice1712 *ice,
550 unsigned int rate)
551{
552
553 return 0;
554}
555
556
557static int juli_set_spdif_clock(struct snd_ice1712 *ice, int type)
558{
559 unsigned int old;
560 old = ice->gpio.get_data(ice);
561
562 ice->gpio.set_data(ice, (old & ~GPIO_RATE_MASK) | GPIO_MULTI_1X |
563 GPIO_FREQ_48KHZ);
564 return 0;
565}
566
567
568static void juli_ak4114_change(struct ak4114 *ak4114, unsigned char c0,
569 unsigned char c1)
570{
571 struct snd_ice1712 *ice = ak4114->change_callback_private;
572 int rate;
573 if (ice->is_spdif_master(ice) && c1) {
574
575 rate = snd_ak4114_external_rate(ak4114);
576
577
578 juli_akm_set_rate_val(ice->akm, rate);
579 }
580}
581
582static int juli_init(struct snd_ice1712 *ice)
583{
584 static const unsigned char ak4114_init_vals[] = {
585 AK4114_RST | AK4114_PWN |
586 AK4114_OCKS0 | AK4114_OCKS1,
587 AK4114_DIF_I24I2S,
588 AK4114_TX1E,
589 AK4114_EFH_1024 | AK4114_DIT |
590 AK4114_IPS(1),
591 0,
592 0
593 };
594 static const unsigned char ak4114_init_txcsb[] = {
595 0x41, 0x02, 0x2c, 0x00, 0x00
596 };
597 int err;
598 struct juli_spec *spec;
599 struct snd_akm4xxx *ak;
600
601 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
602 if (!spec)
603 return -ENOMEM;
604 ice->spec = spec;
605
606 err = snd_ak4114_create(ice->card,
607 juli_ak4114_read,
608 juli_ak4114_write,
609 ak4114_init_vals, ak4114_init_txcsb,
610 ice, &spec->ak4114);
611 if (err < 0)
612 return err;
613
614 spec->ak4114->change_callback = juli_ak4114_change;
615 spec->ak4114->change_callback_private = ice;
616
617 spec->ak4114->check_flags = 0;
618
619#if 0
620
621
622
623
624
625 spec->analog = (ice->gpio.get_data(ice) & GPIO_ANALOG_PRESENT) ? 0 : 1;
626#else
627 spec->analog = 1;
628#endif
629
630 if (spec->analog) {
631 printk(KERN_INFO "juli@: analog I/O detected\n");
632 ice->num_total_dacs = 2;
633 ice->num_total_adcs = 2;
634
635 ice->akm = kzalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL);
636 ak = ice->akm;
637 if (!ak)
638 return -ENOMEM;
639 ice->akm_codecs = 1;
640 err = snd_ice1712_akm4xxx_init(ak, &akm_juli_dac, NULL, ice);
641 if (err < 0)
642 return err;
643 }
644
645
646 ice->hw_rates = &juli_rates_info;
647 ice->is_spdif_master = juli_is_spdif_master;
648 ice->get_rate = juli_get_rate;
649 ice->set_rate = juli_set_rate;
650 ice->set_mclk = juli_set_mclk;
651 ice->set_spdif_clock = juli_set_spdif_clock;
652
653 ice->spdif.ops.open = juli_spdif_in_open;
654
655#ifdef CONFIG_PM_SLEEP
656 ice->pm_resume = juli_resume;
657 ice->pm_suspend = juli_suspend;
658 ice->pm_suspend_enabled = 1;
659#endif
660
661 return 0;
662}
663
664
665
666
667
668
669
670static unsigned char juli_eeprom[] = {
671 [ICE_EEP2_SYSCONF] = 0x2b,
672
673 [ICE_EEP2_ACLINK] = 0x80,
674 [ICE_EEP2_I2S] = 0xf8,
675 [ICE_EEP2_SPDIF] = 0xc3,
676 [ICE_EEP2_GPIO_DIR] = 0x9f,
677 [ICE_EEP2_GPIO_DIR1] = 0xff,
678 [ICE_EEP2_GPIO_DIR2] = 0x7f,
679 [ICE_EEP2_GPIO_MASK] = 0x60,
680 [ICE_EEP2_GPIO_MASK1] = 0x00,
681 [ICE_EEP2_GPIO_MASK2] = 0x7f,
682 [ICE_EEP2_GPIO_STATE] = GPIO_FREQ_48KHZ | GPIO_MULTI_1X |
683 GPIO_INTERNAL_CLOCK,
684 [ICE_EEP2_GPIO_STATE1] = 0x00,
685 [ICE_EEP2_GPIO_STATE2] = 0x00,
686};
687
688
689struct snd_ice1712_card_info snd_vt1724_juli_cards[] = {
690 {
691 .subvendor = VT1724_SUBDEVICE_JULI,
692 .name = "ESI Juli@",
693 .model = "juli",
694 .chip_init = juli_init,
695 .build_controls = juli_add_controls,
696 .eeprom_size = sizeof(juli_eeprom),
697 .eeprom_data = juli_eeprom,
698 },
699 { }
700};
701