?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
initial commit with v2.6.32.60
[linux-2.6.32.60-moxart.git] / sound / ppc / tumbler.c
blob578c9f2af7d3d7992f9bd0ef9da11d8f3c89236d
1 /*
2 * PMac Tumbler/Snapper lowlevel functions
3 *
4 * Copyright (c) by Takashi Iwai <tiwai@suse.de>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 * Rene Rebe <rene.rebe@gmx.net>:
21 * * update from shadow registers on wakeup and headphone plug
22 * * automatically toggle DRC on headphone plug
23 *
24 */
25
26
27 #include <linux/init.h>
28 #include <linux/delay.h>
29 #include <linux/i2c.h>
30 #include <linux/kmod.h>
31 #include <linux/slab.h>
32 #include <linux/interrupt.h>
33 #include <linux/string.h>
34 #include <sound/core.h>
35 #include <asm/io.h>
36 #include <asm/irq.h>
37 #include <asm/machdep.h>
38 #include <asm/pmac_feature.h>
39 #include "pmac.h"
40 #include "tumbler_volume.h"
41
42 #undef DEBUG
43
44 #ifdef DEBUG
45 #define DBG(fmt...) printk(KERN_DEBUG fmt)
46 #else
47 #define DBG(fmt...)
48 #endif
49
50 #define IS_G4DA (machine_is_compatible("PowerMac3,4"))
51
52 /* i2c address for tumbler */
53 #define TAS_I2C_ADDR 0x34
54
55 /* registers */
56 #define TAS_REG_MCS 0x01 /* main control */
57 #define TAS_REG_DRC 0x02
58 #define TAS_REG_VOL 0x04
59 #define TAS_REG_TREBLE 0x05
60 #define TAS_REG_BASS 0x06
61 #define TAS_REG_INPUT1 0x07
62 #define TAS_REG_INPUT2 0x08
63
64 /* tas3001c */
65 #define TAS_REG_PCM TAS_REG_INPUT1
66
67 /* tas3004 */
68 #define TAS_REG_LMIX TAS_REG_INPUT1
69 #define TAS_REG_RMIX TAS_REG_INPUT2
70 #define TAS_REG_MCS2 0x43 /* main control 2 */
71 #define TAS_REG_ACS 0x40 /* analog control */
72
73 /* mono volumes for tas3001c/tas3004 */
74 enum {
75 VOL_IDX_PCM_MONO, /* tas3001c only */
76 VOL_IDX_BASS, VOL_IDX_TREBLE,
77 VOL_IDX_LAST_MONO
78 };
79
80 /* stereo volumes for tas3004 */
81 enum {
82 VOL_IDX_PCM, VOL_IDX_PCM2, VOL_IDX_ADC,
83 VOL_IDX_LAST_MIX
84 };
85
86 struct pmac_gpio {
87 unsigned int addr;
88 u8 active_val;
89 u8 inactive_val;
90 u8 active_state;
91 };
92
93 struct pmac_tumbler {
94 struct pmac_keywest i2c;
95 struct pmac_gpio audio_reset;
96 struct pmac_gpio amp_mute;
97 struct pmac_gpio line_mute;
98 struct pmac_gpio line_detect;
99 struct pmac_gpio hp_mute;
100 struct pmac_gpio hp_detect;
101 int headphone_irq;
102 int lineout_irq;
103 unsigned int save_master_vol[2];
104 unsigned int master_vol[2];
105 unsigned int save_master_switch[2];
106 unsigned int master_switch[2];
107 unsigned int mono_vol[VOL_IDX_LAST_MONO];
108 unsigned int mix_vol[VOL_IDX_LAST_MIX][2]; /* stereo volumes for tas3004 */
109 int drc_range;
110 int drc_enable;
111 int capture_source;
112 int anded_reset;
113 int auto_mute_notify;
114 int reset_on_sleep;
115 u8 acs;
116 };
117
118
119 /*
120 */
121
122 static int send_init_client(struct pmac_keywest *i2c, unsigned int *regs)
123 {
124 while (*regs > 0) {
125 int err, count = 10;
126 do {
127 err = i2c_smbus_write_byte_data(i2c->client,
128 regs[0], regs[1]);
129 if (err >= 0)
130 break;
131 DBG("(W) i2c error %d\n", err);
132 mdelay(10);
133 } while (count--);
134 if (err < 0)
135 return -ENXIO;
136 regs += 2;
137 }
138 return 0;
139 }
140
141
142 static int tumbler_init_client(struct pmac_keywest *i2c)
143 {
144 static unsigned int regs[] = {
145 /* normal operation, SCLK=64fps, i2s output, i2s input, 16bit width */
146 TAS_REG_MCS, (1<<6)|(2<<4)|(2<<2)|0,
147 0, /* terminator */
148 };
149 DBG("(I) tumbler init client\n");
150 return send_init_client(i2c, regs);
151 }
152
153 static int snapper_init_client(struct pmac_keywest *i2c)
154 {
155 static unsigned int regs[] = {
156 /* normal operation, SCLK=64fps, i2s output, 16bit width */
157 TAS_REG_MCS, (1<<6)|(2<<4)|0,
158 /* normal operation, all-pass mode */
159 TAS_REG_MCS2, (1<<1),
160 /* normal output, no deemphasis, A input, power-up, line-in */
161 TAS_REG_ACS, 0,
162 0, /* terminator */
163 };
164 DBG("(I) snapper init client\n");
165 return send_init_client(i2c, regs);
166 }
167
168 /*
169 * gpio access
170 */
171 #define do_gpio_write(gp, val) \
172 pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, (gp)->addr, val)
173 #define do_gpio_read(gp) \
174 pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, (gp)->addr, 0)
175 #define tumbler_gpio_free(gp) /* NOP */
176
177 static void write_audio_gpio(struct pmac_gpio *gp, int active)
178 {
179 if (! gp->addr)
180 return;
181 active = active ? gp->active_val : gp->inactive_val;
182 do_gpio_write(gp, active);
183 DBG("(I) gpio %x write %d\n", gp->addr, active);
184 }
185
186 static int check_audio_gpio(struct pmac_gpio *gp)
187 {
188 int ret;
189
190 if (! gp->addr)
191 return 0;
192
193 ret = do_gpio_read(gp);
194
195 return (ret & 0x1) == (gp->active_val & 0x1);
196 }
197
198 static int read_audio_gpio(struct pmac_gpio *gp)
199 {
200 int ret;
201 if (! gp->addr)
202 return 0;
203 ret = do_gpio_read(gp);
204 ret = (ret & 0x02) !=0;
205 return ret == gp->active_state;
206 }
207
208 /*
209 * update master volume
210 */
211 static int tumbler_set_master_volume(struct pmac_tumbler *mix)
212 {
213 unsigned char block[6];
214 unsigned int left_vol, right_vol;
215
216 if (! mix->i2c.client)
217 return -ENODEV;
218
219 if (! mix->master_switch[0])
220 left_vol = 0;
221 else {
222 left_vol = mix->master_vol[0];
223 if (left_vol >= ARRAY_SIZE(master_volume_table))
224 left_vol = ARRAY_SIZE(master_volume_table) - 1;
225 left_vol = master_volume_table[left_vol];
226 }
227 if (! mix->master_switch[1])
228 right_vol = 0;
229 else {
230 right_vol = mix->master_vol[1];
231 if (right_vol >= ARRAY_SIZE(master_volume_table))
232 right_vol = ARRAY_SIZE(master_volume_table) - 1;
233 right_vol = master_volume_table[right_vol];
234 }
235
236 block[0] = (left_vol >> 16) & 0xff;
237 block[1] = (left_vol >> 8) & 0xff;
238 block[2] = (left_vol >> 0) & 0xff;
239
240 block[3] = (right_vol >> 16) & 0xff;
241 block[4] = (right_vol >> 8) & 0xff;
242 block[5] = (right_vol >> 0) & 0xff;
243
244 if (i2c_smbus_write_i2c_block_data(mix->i2c.client, TAS_REG_VOL, 6,
245 block) < 0) {
246 snd_printk(KERN_ERR "failed to set volume \n");
247 return -EINVAL;
248 }
249 return 0;
250 }
251
252
253 /* output volume */
254 static int tumbler_info_master_volume(struct snd_kcontrol *kcontrol,
255 struct snd_ctl_elem_info *uinfo)
256 {
257 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
258 uinfo->count = 2;
259 uinfo->value.integer.min = 0;
260 uinfo->value.integer.max = ARRAY_SIZE(master_volume_table) - 1;
261 return 0;
262 }
263
264 static int tumbler_get_master_volume(struct snd_kcontrol *kcontrol,
265 struct snd_ctl_elem_value *ucontrol)
266 {
267 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
268 struct pmac_tumbler *mix = chip->mixer_data;
269
270 ucontrol->value.integer.value[0] = mix->master_vol[0];
271 ucontrol->value.integer.value[1] = mix->master_vol[1];
272 return 0;
273 }
274
275 static int tumbler_put_master_volume(struct snd_kcontrol *kcontrol,
276 struct snd_ctl_elem_value *ucontrol)
277 {
278 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
279 struct pmac_tumbler *mix = chip->mixer_data;
280 unsigned int vol[2];
281 int change;
282
283 vol[0] = ucontrol->value.integer.value[0];
284 vol[1] = ucontrol->value.integer.value[1];
285 if (vol[0] >= ARRAY_SIZE(master_volume_table) ||
286 vol[1] >= ARRAY_SIZE(master_volume_table))
287 return -EINVAL;
288 change = mix->master_vol[0] != vol[0] ||
289 mix->master_vol[1] != vol[1];
290 if (change) {
291 mix->master_vol[0] = vol[0];
292 mix->master_vol[1] = vol[1];
293 tumbler_set_master_volume(mix);
294 }
295 return change;
296 }
297
298 /* output switch */
299 static int tumbler_get_master_switch(struct snd_kcontrol *kcontrol,
300 struct snd_ctl_elem_value *ucontrol)
301 {
302 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
303 struct pmac_tumbler *mix = chip->mixer_data;
304
305 ucontrol->value.integer.value[0] = mix->master_switch[0];
306 ucontrol->value.integer.value[1] = mix->master_switch[1];
307 return 0;
308 }
309
310 static int tumbler_put_master_switch(struct snd_kcontrol *kcontrol,
311 struct snd_ctl_elem_value *ucontrol)
312 {
313 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
314 struct pmac_tumbler *mix = chip->mixer_data;
315 int change;
316
317 change = mix->master_switch[0] != ucontrol->value.integer.value[0] ||
318 mix->master_switch[1] != ucontrol->value.integer.value[1];
319 if (change) {
320 mix->master_switch[0] = !!ucontrol->value.integer.value[0];
321 mix->master_switch[1] = !!ucontrol->value.integer.value[1];
322 tumbler_set_master_volume(mix);
323 }
324 return change;
325 }
326
327
328 /*
329 * TAS3001c dynamic range compression
330 */
331
332 #define TAS3001_DRC_MAX 0x5f
333
334 static int tumbler_set_drc(struct pmac_tumbler *mix)
335 {
336 unsigned char val[2];
337
338 if (! mix->i2c.client)
339 return -ENODEV;
340
341 if (mix->drc_enable) {
342 val[0] = 0xc1; /* enable, 3:1 compression */
343 if (mix->drc_range > TAS3001_DRC_MAX)
344 val[1] = 0xf0;
345 else if (mix->drc_range < 0)
346 val[1] = 0x91;
347 else
348 val[1] = mix->drc_range + 0x91;
349 } else {
350 val[0] = 0;
351 val[1] = 0;
352 }
353
354 if (i2c_smbus_write_i2c_block_data(mix->i2c.client, TAS_REG_DRC,
355 2, val) < 0) {
356 snd_printk(KERN_ERR "failed to set DRC\n");
357 return -EINVAL;
358 }
359 return 0;
360 }
361
362 /*
363 * TAS3004
364 */
365
366 #define TAS3004_DRC_MAX 0xef
367
368 static int snapper_set_drc(struct pmac_tumbler *mix)
369 {
370 unsigned char val[6];
371
372 if (! mix->i2c.client)
373 return -ENODEV;
374
375 if (mix->drc_enable)
376 val[0] = 0x50; /* 3:1 above threshold */
377 else
378 val[0] = 0x51; /* disabled */
379 val[1] = 0x02; /* 1:1 below threshold */
380 if (mix->drc_range > 0xef)
381 val[2] = 0xef;
382 else if (mix->drc_range < 0)
383 val[2] = 0x00;
384 else
385 val[2] = mix->drc_range;
386 val[3] = 0xb0;
387 val[4] = 0x60;
388 val[5] = 0xa0;
389
390 if (i2c_smbus_write_i2c_block_data(mix->i2c.client, TAS_REG_DRC,
391 6, val) < 0) {
392 snd_printk(KERN_ERR "failed to set DRC\n");
393 return -EINVAL;
394 }
395 return 0;
396 }
397
398 static int tumbler_info_drc_value(struct snd_kcontrol *kcontrol,
399 struct snd_ctl_elem_info *uinfo)
400 {
401 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
402 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
403 uinfo->count = 1;
404 uinfo->value.integer.min = 0;
405 uinfo->value.integer.max =
406 chip->model == PMAC_TUMBLER ? TAS3001_DRC_MAX : TAS3004_DRC_MAX;
407 return 0;
408 }
409
410 static int tumbler_get_drc_value(struct snd_kcontrol *kcontrol,
411 struct snd_ctl_elem_value *ucontrol)
412 {
413 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
414 struct pmac_tumbler *mix;
415 if (! (mix = chip->mixer_data))
416 return -ENODEV;
417 ucontrol->value.integer.value[0] = mix->drc_range;
418 return 0;
419 }
420
421 static int tumbler_put_drc_value(struct snd_kcontrol *kcontrol,
422 struct snd_ctl_elem_value *ucontrol)
423 {
424 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
425 struct pmac_tumbler *mix;
426 unsigned int val;
427 int change;
428
429 if (! (mix = chip->mixer_data))
430 return -ENODEV;
431 val = ucontrol->value.integer.value[0];
432 if (chip->model == PMAC_TUMBLER) {
433 if (val > TAS3001_DRC_MAX)
434 return -EINVAL;
435 } else {
436 if (val > TAS3004_DRC_MAX)
437 return -EINVAL;
438 }
439 change = mix->drc_range != val;
440 if (change) {
441 mix->drc_range = val;
442 if (chip->model == PMAC_TUMBLER)
443 tumbler_set_drc(mix);
444 else
445 snapper_set_drc(mix);
446 }
447 return change;
448 }
449
450 static int tumbler_get_drc_switch(struct snd_kcontrol *kcontrol,
451 struct snd_ctl_elem_value *ucontrol)
452 {
453 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
454 struct pmac_tumbler *mix;
455 if (! (mix = chip->mixer_data))
456 return -ENODEV;
457 ucontrol->value.integer.value[0] = mix->drc_enable;
458 return 0;
459 }
460
461 static int tumbler_put_drc_switch(struct snd_kcontrol *kcontrol,
462 struct snd_ctl_elem_value *ucontrol)
463 {
464 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
465 struct pmac_tumbler *mix;
466 int change;
467
468 if (! (mix = chip->mixer_data))
469 return -ENODEV;
470 change = mix->drc_enable != ucontrol->value.integer.value[0];
471 if (change) {
472 mix->drc_enable = !!ucontrol->value.integer.value[0];
473 if (chip->model == PMAC_TUMBLER)
474 tumbler_set_drc(mix);
475 else
476 snapper_set_drc(mix);
477 }
478 return change;
479 }
480
481
482 /*
483 * mono volumes
484 */
485
486 struct tumbler_mono_vol {
487 int index;
488 int reg;
489 int bytes;
490 unsigned int max;
491 unsigned int *table;
492 };
493
494 static int tumbler_set_mono_volume(struct pmac_tumbler *mix,
495 struct tumbler_mono_vol *info)
496 {
497 unsigned char block[4];
498 unsigned int vol;
499 int i;
500
501 if (! mix->i2c.client)
502 return -ENODEV;
503
504 vol = mix->mono_vol[info->index];
505 if (vol >= info->max)
506 vol = info->max - 1;
507 vol = info->table[vol];
508 for (i = 0; i < info->bytes; i++)
509 block[i] = (vol >> ((info->bytes - i - 1) * 8)) & 0xff;
510 if (i2c_smbus_write_i2c_block_data(mix->i2c.client, info->reg,
511 info->bytes, block) < 0) {
512 snd_printk(KERN_ERR "failed to set mono volume %d\n",
513 info->index);
514 return -EINVAL;
515 }
516 return 0;
517 }
518
519 static int tumbler_info_mono(struct snd_kcontrol *kcontrol,
520 struct snd_ctl_elem_info *uinfo)
521 {
522 struct tumbler_mono_vol *info = (struct tumbler_mono_vol *)kcontrol->private_value;
523
524 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
525 uinfo->count = 1;
526 uinfo->value.integer.min = 0;
527 uinfo->value.integer.max = info->max - 1;
528 return 0;
529 }
530
531 static int tumbler_get_mono(struct snd_kcontrol *kcontrol,
532 struct snd_ctl_elem_value *ucontrol)
533 {
534 struct tumbler_mono_vol *info = (struct tumbler_mono_vol *)kcontrol->private_value;
535 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
536 struct pmac_tumbler *mix;
537 if (! (mix = chip->mixer_data))
538 return -ENODEV;
539 ucontrol->value.integer.value[0] = mix->mono_vol[info->index];
540 return 0;
541 }
542
543 static int tumbler_put_mono(struct snd_kcontrol *kcontrol,
544 struct snd_ctl_elem_value *ucontrol)
545 {
546 struct tumbler_mono_vol *info = (struct tumbler_mono_vol *)kcontrol->private_value;
547 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
548 struct pmac_tumbler *mix;
549 unsigned int vol;
550 int change;
551
552 if (! (mix = chip->mixer_data))
553 return -ENODEV;
554 vol = ucontrol->value.integer.value[0];
555 if (vol >= info->max)
556 return -EINVAL;
557 change = mix->mono_vol[info->index] != vol;
558 if (change) {
559 mix->mono_vol[info->index] = vol;
560 tumbler_set_mono_volume(mix, info);
561 }
562 return change;
563 }
564
565 /* TAS3001c mono volumes */
566 static struct tumbler_mono_vol tumbler_pcm_vol_info = {
567 .index = VOL_IDX_PCM_MONO,
568 .reg = TAS_REG_PCM,
569 .bytes = 3,
570 .max = ARRAY_SIZE(mixer_volume_table),
571 .table = mixer_volume_table,
572 };
573
574 static struct tumbler_mono_vol tumbler_bass_vol_info = {
575 .index = VOL_IDX_BASS,
576 .reg = TAS_REG_BASS,
577 .bytes = 1,
578 .max = ARRAY_SIZE(bass_volume_table),
579 .table = bass_volume_table,
580 };
581
582 static struct tumbler_mono_vol tumbler_treble_vol_info = {
583 .index = VOL_IDX_TREBLE,
584 .reg = TAS_REG_TREBLE,
585 .bytes = 1,
586 .max = ARRAY_SIZE(treble_volume_table),
587 .table = treble_volume_table,
588 };
589
590 /* TAS3004 mono volumes */
591 static struct tumbler_mono_vol snapper_bass_vol_info = {
592 .index = VOL_IDX_BASS,
593 .reg = TAS_REG_BASS,
594 .bytes = 1,
595 .max = ARRAY_SIZE(snapper_bass_volume_table),
596 .table = snapper_bass_volume_table,
597 };
598
599 static struct tumbler_mono_vol snapper_treble_vol_info = {
600 .index = VOL_IDX_TREBLE,
601 .reg = TAS_REG_TREBLE,
602 .bytes = 1,
603 .max = ARRAY_SIZE(snapper_treble_volume_table),
604 .table = snapper_treble_volume_table,
605 };
606
607
608 #define DEFINE_MONO(xname,type) { \
609 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
610 .name = xname, \
611 .info = tumbler_info_mono, \
612 .get = tumbler_get_mono, \
613 .put = tumbler_put_mono, \
614 .private_value = (unsigned long)(&tumbler_##type##_vol_info), \
615 }
616
617 #define DEFINE_SNAPPER_MONO(xname,type) { \
618 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
619 .name = xname, \
620 .info = tumbler_info_mono, \
621 .get = tumbler_get_mono, \
622 .put = tumbler_put_mono, \
623 .private_value = (unsigned long)(&snapper_##type##_vol_info), \
624 }
625
626
627 /*
628 * snapper mixer volumes
629 */
630
631 static int snapper_set_mix_vol1(struct pmac_tumbler *mix, int idx, int ch, int reg)
632 {
633 int i, j, vol;
634 unsigned char block[9];
635
636 vol = mix->mix_vol[idx][ch];
637 if (vol >= ARRAY_SIZE(mixer_volume_table)) {
638 vol = ARRAY_SIZE(mixer_volume_table) - 1;
639 mix->mix_vol[idx][ch] = vol;
640 }
641
642 for (i = 0; i < 3; i++) {
643 vol = mix->mix_vol[i][ch];
644 vol = mixer_volume_table[vol];
645 for (j = 0; j < 3; j++)
646 block[i * 3 + j] = (vol >> ((2 - j) * 8)) & 0xff;
647 }
648 if (i2c_smbus_write_i2c_block_data(mix->i2c.client, reg,
649 9, block) < 0) {
650 snd_printk(KERN_ERR "failed to set mono volume %d\n", reg);
651 return -EINVAL;
652 }
653 return 0;
654 }
655
656 static int snapper_set_mix_vol(struct pmac_tumbler *mix, int idx)
657 {
658 if (! mix->i2c.client)
659 return -ENODEV;
660 if (snapper_set_mix_vol1(mix, idx, 0, TAS_REG_LMIX) < 0 ||
661 snapper_set_mix_vol1(mix, idx, 1, TAS_REG_RMIX) < 0)
662 return -EINVAL;
663 return 0;
664 }
665
666 static int snapper_info_mix(struct snd_kcontrol *kcontrol,
667 struct snd_ctl_elem_info *uinfo)
668 {
669 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
670 uinfo->count = 2;
671 uinfo->value.integer.min = 0;
672 uinfo->value.integer.max = ARRAY_SIZE(mixer_volume_table) - 1;
673 return 0;
674 }
675
676 static int snapper_get_mix(struct snd_kcontrol *kcontrol,
677 struct snd_ctl_elem_value *ucontrol)
678 {
679 int idx = (int)kcontrol->private_value;
680 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
681 struct pmac_tumbler *mix;
682 if (! (mix = chip->mixer_data))
683 return -ENODEV;
684 ucontrol->value.integer.value[0] = mix->mix_vol[idx][0];
685 ucontrol->value.integer.value[1] = mix->mix_vol[idx][1];
686 return 0;
687 }
688
689 static int snapper_put_mix(struct snd_kcontrol *kcontrol,
690 struct snd_ctl_elem_value *ucontrol)
691 {
692 int idx = (int)kcontrol->private_value;
693 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
694 struct pmac_tumbler *mix;
695 unsigned int vol[2];
696 int change;
697
698 if (! (mix = chip->mixer_data))
699 return -ENODEV;
700 vol[0] = ucontrol->value.integer.value[0];
701 vol[1] = ucontrol->value.integer.value[1];
702 if (vol[0] >= ARRAY_SIZE(mixer_volume_table) ||
703 vol[1] >= ARRAY_SIZE(mixer_volume_table))
704 return -EINVAL;
705 change = mix->mix_vol[idx][0] != vol[0] ||
706 mix->mix_vol[idx][1] != vol[1];
707 if (change) {
708 mix->mix_vol[idx][0] = vol[0];
709 mix->mix_vol[idx][1] = vol[1];
710 snapper_set_mix_vol(mix, idx);
711 }
712 return change;
713 }
714
715
716 /*
717 * mute switches. FIXME: Turn that into software mute when both outputs are muted
718 * to avoid codec reset on ibook M7
719 */
720
721 enum { TUMBLER_MUTE_HP, TUMBLER_MUTE_AMP, TUMBLER_MUTE_LINE };
722
723 static int tumbler_get_mute_switch(struct snd_kcontrol *kcontrol,
724 struct snd_ctl_elem_value *ucontrol)
725 {
726 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
727 struct pmac_tumbler *mix;
728 struct pmac_gpio *gp;
729 if (! (mix = chip->mixer_data))
730 return -ENODEV;
731 switch(kcontrol->private_value) {
732 case TUMBLER_MUTE_HP:
733 gp = &mix->hp_mute; break;
734 case TUMBLER_MUTE_AMP:
735 gp = &mix->amp_mute; break;
736 case TUMBLER_MUTE_LINE:
737 gp = &mix->line_mute; break;
738 default:
739 gp = NULL;
740 }
741 if (gp == NULL)
742 return -EINVAL;
743 ucontrol->value.integer.value[0] = !check_audio_gpio(gp);
744 return 0;
745 }
746
747 static int tumbler_put_mute_switch(struct snd_kcontrol *kcontrol,
748 struct snd_ctl_elem_value *ucontrol)
749 {
750 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
751 struct pmac_tumbler *mix;
752 struct pmac_gpio *gp;
753 int val;
754 #ifdef PMAC_SUPPORT_AUTOMUTE
755 if (chip->update_automute && chip->auto_mute)
756 return 0; /* don't touch in the auto-mute mode */
757 #endif
758 if (! (mix = chip->mixer_data))
759 return -ENODEV;
760 switch(kcontrol->private_value) {
761 case TUMBLER_MUTE_HP:
762 gp = &mix->hp_mute; break;
763 case TUMBLER_MUTE_AMP:
764 gp = &mix->amp_mute; break;
765 case TUMBLER_MUTE_LINE:
766 gp = &mix->line_mute; break;
767 default:
768 gp = NULL;
769 }
770 if (gp == NULL)
771 return -EINVAL;
772 val = ! check_audio_gpio(gp);
773 if (val != ucontrol->value.integer.value[0]) {
774 write_audio_gpio(gp, ! ucontrol->value.integer.value[0]);
775 return 1;
776 }
777 return 0;
778 }
779
780 static int snapper_set_capture_source(struct pmac_tumbler *mix)
781 {
782 if (! mix->i2c.client)
783 return -ENODEV;
784 if (mix->capture_source)
785 mix->acs = mix->acs |= 2;
786 else
787 mix->acs &= ~2;
788 return i2c_smbus_write_byte_data(mix->i2c.client, TAS_REG_ACS, mix->acs);
789 }
790
791 static int snapper_info_capture_source(struct snd_kcontrol *kcontrol,
792 struct snd_ctl_elem_info *uinfo)
793 {
794 static char *texts[2] = {
795 "Line", "Mic"
796 };
797 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
798 uinfo->count = 1;
799 uinfo->value.enumerated.items = 2;
800 if (uinfo->value.enumerated.item > 1)
801 uinfo->value.enumerated.item = 1;
802 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
803 return 0;
804 }
805
806 static int snapper_get_capture_source(struct snd_kcontrol *kcontrol,
807 struct snd_ctl_elem_value *ucontrol)
808 {
809 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
810 struct pmac_tumbler *mix = chip->mixer_data;
811
812 ucontrol->value.enumerated.item[0] = mix->capture_source;
813 return 0;
814 }
815
816 static int snapper_put_capture_source(struct snd_kcontrol *kcontrol,
817 struct snd_ctl_elem_value *ucontrol)
818 {
819 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
820 struct pmac_tumbler *mix = chip->mixer_data;
821 int change;
822
823 change = ucontrol->value.enumerated.item[0] != mix->capture_source;
824 if (change) {
825 mix->capture_source = !!ucontrol->value.enumerated.item[0];
826 snapper_set_capture_source(mix);
827 }
828 return change;
829 }
830
831 #define DEFINE_SNAPPER_MIX(xname,idx,ofs) { \
832 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
833 .name = xname, \
834 .info = snapper_info_mix, \
835 .get = snapper_get_mix, \
836 .put = snapper_put_mix, \
837 .index = idx,\
838 .private_value = ofs, \
839 }
840
841
842 /*
843 */
844 static struct snd_kcontrol_new tumbler_mixers[] __devinitdata = {
845 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
846 .name = "Master Playback Volume",
847 .info = tumbler_info_master_volume,
848 .get = tumbler_get_master_volume,
849 .put = tumbler_put_master_volume
850 },
851 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
852 .name = "Master Playback Switch",
853 .info = snd_pmac_boolean_stereo_info,
854 .get = tumbler_get_master_switch,
855 .put = tumbler_put_master_switch
856 },
857 DEFINE_MONO("Tone Control - Bass", bass),
858 DEFINE_MONO("Tone Control - Treble", treble),
859 DEFINE_MONO("PCM Playback Volume", pcm),
860 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
861 .name = "DRC Range",
862 .info = tumbler_info_drc_value,
863 .get = tumbler_get_drc_value,
864 .put = tumbler_put_drc_value
865 },
866 };
867
868 static struct snd_kcontrol_new snapper_mixers[] __devinitdata = {
869 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
870 .name = "Master Playback Volume",
871 .info = tumbler_info_master_volume,
872 .get = tumbler_get_master_volume,
873 .put = tumbler_put_master_volume
874 },
875 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
876 .name = "Master Playback Switch",
877 .info = snd_pmac_boolean_stereo_info,
878 .get = tumbler_get_master_switch,
879 .put = tumbler_put_master_switch
880 },
881 DEFINE_SNAPPER_MIX("PCM Playback Volume", 0, VOL_IDX_PCM),
882 /* Alternative PCM is assigned to Mic analog loopback on iBook G4 */
883 DEFINE_SNAPPER_MIX("Mic Playback Volume", 0, VOL_IDX_PCM2),
884 DEFINE_SNAPPER_MIX("Monitor Mix Volume", 0, VOL_IDX_ADC),
885 DEFINE_SNAPPER_MONO("Tone Control - Bass", bass),
886 DEFINE_SNAPPER_MONO("Tone Control - Treble", treble),
887 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
888 .name = "DRC Range",
889 .info = tumbler_info_drc_value,
890 .get = tumbler_get_drc_value,
891 .put = tumbler_put_drc_value
892 },
893 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
894 .name = "Input Source", /* FIXME: "Capture Source" doesn't work properly */
895 .info = snapper_info_capture_source,
896 .get = snapper_get_capture_source,
897 .put = snapper_put_capture_source
898 },
899 };
900
901 static struct snd_kcontrol_new tumbler_hp_sw __devinitdata = {
902 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
903 .name = "Headphone Playback Switch",
904 .info = snd_pmac_boolean_mono_info,
905 .get = tumbler_get_mute_switch,
906 .put = tumbler_put_mute_switch,
907 .private_value = TUMBLER_MUTE_HP,
908 };
909 static struct snd_kcontrol_new tumbler_speaker_sw __devinitdata = {
910 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
911 .name = "PC Speaker Playback Switch",
912 .info = snd_pmac_boolean_mono_info,
913 .get = tumbler_get_mute_switch,
914 .put = tumbler_put_mute_switch,
915 .private_value = TUMBLER_MUTE_AMP,
916 };
917 static struct snd_kcontrol_new tumbler_lineout_sw __devinitdata = {
918 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
919 .name = "Line Out Playback Switch",
920 .info = snd_pmac_boolean_mono_info,
921 .get = tumbler_get_mute_switch,
922 .put = tumbler_put_mute_switch,
923 .private_value = TUMBLER_MUTE_LINE,
924 };
925 static struct snd_kcontrol_new tumbler_drc_sw __devinitdata = {
926 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
927 .name = "DRC Switch",
928 .info = snd_pmac_boolean_mono_info,
929 .get = tumbler_get_drc_switch,
930 .put = tumbler_put_drc_switch
931 };
932
933
934 #ifdef PMAC_SUPPORT_AUTOMUTE
935 /*
936 * auto-mute stuffs
937 */
938 static int tumbler_detect_headphone(struct snd_pmac *chip)
939 {
940 struct pmac_tumbler *mix = chip->mixer_data;
941 int detect = 0;
942
943 if (mix->hp_detect.addr)
944 detect |= read_audio_gpio(&mix->hp_detect);
945 return detect;
946 }
947
948 static int tumbler_detect_lineout(struct snd_pmac *chip)
949 {
950 struct pmac_tumbler *mix = chip->mixer_data;
951 int detect = 0;
952
953 if (mix->line_detect.addr)
954 detect |= read_audio_gpio(&mix->line_detect);
955 return detect;
956 }
957
958 static void check_mute(struct snd_pmac *chip, struct pmac_gpio *gp, int val, int do_notify,
959 struct snd_kcontrol *sw)
960 {
961 if (check_audio_gpio(gp) != val) {
962 write_audio_gpio(gp, val);
963 if (do_notify)
964 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
965 &sw->id);
966 }
967 }
968
969 static struct work_struct device_change;
970 static struct snd_pmac *device_change_chip;
971
972 static void device_change_handler(struct work_struct *work)
973 {
974 struct snd_pmac *chip = device_change_chip;
975 struct pmac_tumbler *mix;
976 int headphone, lineout;
977
978 if (!chip)
979 return;
980
981 mix = chip->mixer_data;
982 if (snd_BUG_ON(!mix))
983 return;
984
985 headphone = tumbler_detect_headphone(chip);
986 lineout = tumbler_detect_lineout(chip);
987
988 DBG("headphone: %d, lineout: %d\n", headphone, lineout);
989
990 if (headphone || lineout) {
991 /* unmute headphone/lineout & mute speaker */
992 if (headphone)
993 check_mute(chip, &mix->hp_mute, 0, mix->auto_mute_notify,
994 chip->master_sw_ctl);
995 if (lineout && mix->line_mute.addr != 0)
996 check_mute(chip, &mix->line_mute, 0, mix->auto_mute_notify,
997 chip->lineout_sw_ctl);
998 if (mix->anded_reset)
999 msleep(10);
1000 check_mute(chip, &mix->amp_mute, 1, mix->auto_mute_notify,
1001 chip->speaker_sw_ctl);
1002 } else {
1003 /* unmute speaker, mute others */
1004 check_mute(chip, &mix->amp_mute, 0, mix->auto_mute_notify,
1005 chip->speaker_sw_ctl);
1006 if (mix->anded_reset)
1007 msleep(10);
1008 check_mute(chip, &mix->hp_mute, 1, mix->auto_mute_notify,
1009 chip->master_sw_ctl);
1010 if (mix->line_mute.addr != 0)
1011 check_mute(chip, &mix->line_mute, 1, mix->auto_mute_notify,
1012 chip->lineout_sw_ctl);
1013 }
1014 if (mix->auto_mute_notify)
1015 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1016 &chip->hp_detect_ctl->id);
1017
1018 #ifdef CONFIG_SND_POWERMAC_AUTO_DRC
1019 mix->drc_enable = ! (headphone || lineout);
1020 if (mix->auto_mute_notify)
1021 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1022 &chip->drc_sw_ctl->id);
1023 if (chip->model == PMAC_TUMBLER)
1024 tumbler_set_drc(mix);
1025 else
1026 snapper_set_drc(mix);
1027 #endif
1028
1029 /* reset the master volume so the correct amplification is applied */
1030 tumbler_set_master_volume(mix);
1031 }
1032
1033 static void tumbler_update_automute(struct snd_pmac *chip, int do_notify)
1034 {
1035 if (chip->auto_mute) {
1036 struct pmac_tumbler *mix;
1037 mix = chip->mixer_data;
1038 if (snd_BUG_ON(!mix))
1039 return;
1040 mix->auto_mute_notify = do_notify;
1041 schedule_work(&device_change);
1042 }
1043 }
1044 #endif /* PMAC_SUPPORT_AUTOMUTE */
1045
1046
1047 /* interrupt - headphone plug changed */
1048 static irqreturn_t headphone_intr(int irq, void *devid)
1049 {
1050 struct snd_pmac *chip = devid;
1051 if (chip->update_automute && chip->initialized) {
1052 chip->update_automute(chip, 1);
1053 return IRQ_HANDLED;
1054 }
1055 return IRQ_NONE;
1056 }
1057
1058 /* look for audio-gpio device */
1059 static struct device_node *find_audio_device(const char *name)
1060 {
1061 struct device_node *gpiop;
1062 struct device_node *np;
1063
1064 gpiop = of_find_node_by_name(NULL, "gpio");
1065 if (! gpiop)
1066 return NULL;
1067
1068 for (np = of_get_next_child(gpiop, NULL); np;
1069 np = of_get_next_child(gpiop, np)) {
1070 const char *property = of_get_property(np, "audio-gpio", NULL);
1071 if (property && strcmp(property, name) == 0)
1072 break;
1073 }
1074 of_node_put(gpiop);
1075 return np;
1076 }
1077
1078 /* look for audio-gpio device */
1079 static struct device_node *find_compatible_audio_device(const char *name)
1080 {
1081 struct device_node *gpiop;
1082 struct device_node *np;
1083
1084 gpiop = of_find_node_by_name(NULL, "gpio");
1085 if (!gpiop)
1086 return NULL;
1087
1088 for (np = of_get_next_child(gpiop, NULL); np;
1089 np = of_get_next_child(gpiop, np)) {
1090 if (of_device_is_compatible(np, name))
1091 break;
1092 }
1093 of_node_put(gpiop);
1094 return np;
1095 }
1096
1097 /* find an audio device and get its address */
1098 static long tumbler_find_device(const char *device, const char *platform,
1099 struct pmac_gpio *gp, int is_compatible)
1100 {
1101 struct device_node *node;
1102 const u32 *base;
1103 u32 addr;
1104 long ret;
1105
1106 if (is_compatible)
1107 node = find_compatible_audio_device(device);
1108 else
1109 node = find_audio_device(device);
1110 if (! node) {
1111 DBG("(W) cannot find audio device %s !\n", device);
1112 snd_printdd("cannot find device %s\n", device);
1113 return -ENODEV;
1114 }
1115
1116 base = of_get_property(node, "AAPL,address", NULL);
1117 if (! base) {
1118 base = of_get_property(node, "reg", NULL);
1119 if (!base) {
1120 DBG("(E) cannot find address for device %s !\n", device);
1121 snd_printd("cannot find address for device %s\n", device);
1122 of_node_put(node);
1123 return -ENODEV;
1124 }
1125 addr = *base;
1126 if (addr < 0x50)
1127 addr += 0x50;
1128 } else
1129 addr = *base;
1130
1131 gp->addr = addr & 0x0000ffff;
1132 /* Try to find the active state, default to 0 ! */
1133 base = of_get_property(node, "audio-gpio-active-state", NULL);
1134 if (base) {
1135 gp->active_state = *base;
1136 gp->active_val = (*base) ? 0x5 : 0x4;
1137 gp->inactive_val = (*base) ? 0x4 : 0x5;
1138 } else {
1139 const u32 *prop = NULL;
1140 gp->active_state = IS_G4DA
1141 && !strncmp(device, "keywest-gpio1", 13);
1142 gp->active_val = 0x4;
1143 gp->inactive_val = 0x5;
1144 /* Here are some crude hacks to extract the GPIO polarity and
1145 * open collector informations out of the do-platform script
1146 * as we don't yet have an interpreter for these things
1147 */
1148 if (platform)
1149 prop = of_get_property(node, platform, NULL);
1150 if (prop) {
1151 if (prop[3] == 0x9 && prop[4] == 0x9) {
1152 gp->active_val = 0xd;
1153 gp->inactive_val = 0xc;
1154 }
1155 if (prop[3] == 0x1 && prop[4] == 0x1) {
1156 gp->active_val = 0x5;
1157 gp->inactive_val = 0x4;
1158 }
1159 }
1160 }
1161
1162 DBG("(I) GPIO device %s found, offset: %x, active state: %d !\n",
1163 device, gp->addr, gp->active_state);
1164
1165 ret = irq_of_parse_and_map(node, 0);
1166 of_node_put(node);
1167 return ret;
1168 }
1169
1170 /* reset audio */
1171 static void tumbler_reset_audio(struct snd_pmac *chip)
1172 {
1173 struct pmac_tumbler *mix = chip->mixer_data;
1174
1175 if (mix->anded_reset) {
1176 DBG("(I) codec anded reset !\n");
1177 write_audio_gpio(&mix->hp_mute, 0);
1178 write_audio_gpio(&mix->amp_mute, 0);
1179 msleep(200);
1180 write_audio_gpio(&mix->hp_mute, 1);
1181 write_audio_gpio(&mix->amp_mute, 1);
1182 msleep(100);
1183 write_audio_gpio(&mix->hp_mute, 0);
1184 write_audio_gpio(&mix->amp_mute, 0);
1185 msleep(100);
1186 } else {
1187 DBG("(I) codec normal reset !\n");
1188
1189 write_audio_gpio(&mix->audio_reset, 0);
1190 msleep(200);
1191 write_audio_gpio(&mix->audio_reset, 1);
1192 msleep(100);
1193 write_audio_gpio(&mix->audio_reset, 0);
1194 msleep(100);
1195 }
1196 }
1197
1198 #ifdef CONFIG_PM
1199 /* suspend mixer */
1200 static void tumbler_suspend(struct snd_pmac *chip)
1201 {
1202 struct pmac_tumbler *mix = chip->mixer_data;
1203
1204 if (mix->headphone_irq >= 0)
1205 disable_irq(mix->headphone_irq);
1206 if (mix->lineout_irq >= 0)
1207 disable_irq(mix->lineout_irq);
1208 mix->save_master_switch[0] = mix->master_switch[0];
1209 mix->save_master_switch[1] = mix->master_switch[1];
1210 mix->save_master_vol[0] = mix->master_vol[0];
1211 mix->save_master_vol[1] = mix->master_vol[1];
1212 mix->master_switch[0] = mix->master_switch[1] = 0;
1213 tumbler_set_master_volume(mix);
1214 if (!mix->anded_reset) {
1215 write_audio_gpio(&mix->amp_mute, 1);
1216 write_audio_gpio(&mix->hp_mute, 1);
1217 }
1218 if (chip->model == PMAC_SNAPPER) {
1219 mix->acs |= 1;
1220 i2c_smbus_write_byte_data(mix->i2c.client, TAS_REG_ACS, mix->acs);
1221 }
1222 if (mix->anded_reset) {
1223 write_audio_gpio(&mix->amp_mute, 1);
1224 write_audio_gpio(&mix->hp_mute, 1);
1225 } else
1226 write_audio_gpio(&mix->audio_reset, 1);
1227 }
1228
1229 /* resume mixer */
1230 static void tumbler_resume(struct snd_pmac *chip)
1231 {
1232 struct pmac_tumbler *mix = chip->mixer_data;
1233
1234 mix->acs &= ~1;
1235 mix->master_switch[0] = mix->save_master_switch[0];
1236 mix->master_switch[1] = mix->save_master_switch[1];
1237 mix->master_vol[0] = mix->save_master_vol[0];
1238 mix->master_vol[1] = mix->save_master_vol[1];
1239 tumbler_reset_audio(chip);
1240 if (mix->i2c.client && mix->i2c.init_client) {
1241 if (mix->i2c.init_client(&mix->i2c) < 0)
1242 printk(KERN_ERR "tumbler_init_client error\n");
1243 } else
1244 printk(KERN_ERR "tumbler: i2c is not initialized\n");
1245 if (chip->model == PMAC_TUMBLER) {
1246 tumbler_set_mono_volume(mix, &tumbler_pcm_vol_info);
1247 tumbler_set_mono_volume(mix, &tumbler_bass_vol_info);
1248 tumbler_set_mono_volume(mix, &tumbler_treble_vol_info);
1249 tumbler_set_drc(mix);
1250 } else {
1251 snapper_set_mix_vol(mix, VOL_IDX_PCM);
1252 snapper_set_mix_vol(mix, VOL_IDX_PCM2);
1253 snapper_set_mix_vol(mix, VOL_IDX_ADC);
1254 tumbler_set_mono_volume(mix, &snapper_bass_vol_info);
1255 tumbler_set_mono_volume(mix, &snapper_treble_vol_info);
1256 snapper_set_drc(mix);
1257 snapper_set_capture_source(mix);
1258 }
1259 tumbler_set_master_volume(mix);
1260 if (chip->update_automute)
1261 chip->update_automute(chip, 0);
1262 if (mix->headphone_irq >= 0) {
1263 unsigned char val;
1264
1265 enable_irq(mix->headphone_irq);
1266 /* activate headphone status interrupts */
1267 val = do_gpio_read(&mix->hp_detect);
1268 do_gpio_write(&mix->hp_detect, val | 0x80);
1269 }
1270 if (mix->lineout_irq >= 0)
1271 enable_irq(mix->lineout_irq);
1272 }
1273 #endif
1274
1275 /* initialize tumbler */
1276 static int __devinit tumbler_init(struct snd_pmac *chip)
1277 {
1278 int irq;
1279 struct pmac_tumbler *mix = chip->mixer_data;
1280
1281 if (tumbler_find_device("audio-hw-reset",
1282 "platform-do-hw-reset",
1283 &mix->audio_reset, 0) < 0)
1284 tumbler_find_device("hw-reset",
1285 "platform-do-hw-reset",
1286 &mix->audio_reset, 1);
1287 if (tumbler_find_device("amp-mute",
1288 "platform-do-amp-mute",
1289 &mix->amp_mute, 0) < 0)
1290 tumbler_find_device("amp-mute",
1291 "platform-do-amp-mute",
1292 &mix->amp_mute, 1);
1293 if (tumbler_find_device("headphone-mute",
1294 "platform-do-headphone-mute",
1295 &mix->hp_mute, 0) < 0)
1296 tumbler_find_device("headphone-mute",
1297 "platform-do-headphone-mute",
1298 &mix->hp_mute, 1);
1299 if (tumbler_find_device("line-output-mute",
1300 "platform-do-lineout-mute",
1301 &mix->line_mute, 0) < 0)
1302 tumbler_find_device("line-output-mute",
1303 "platform-do-lineout-mute",
1304 &mix->line_mute, 1);
1305 irq = tumbler_find_device("headphone-detect",
1306 NULL, &mix->hp_detect, 0);
1307 if (irq <= NO_IRQ)
1308 irq = tumbler_find_device("headphone-detect",
1309 NULL, &mix->hp_detect, 1);
1310 if (irq <= NO_IRQ)
1311 irq = tumbler_find_device("keywest-gpio15",
1312 NULL, &mix->hp_detect, 1);
1313 mix->headphone_irq = irq;
1314 irq = tumbler_find_device("line-output-detect",
1315 NULL, &mix->line_detect, 0);
1316 if (irq <= NO_IRQ)
1317 irq = tumbler_find_device("line-output-detect",
1318 NULL, &mix->line_detect, 1);
1319 if (IS_G4DA && irq <= NO_IRQ)
1320 irq = tumbler_find_device("keywest-gpio16",
1321 NULL, &mix->line_detect, 1);
1322 mix->lineout_irq = irq;
1323
1324 tumbler_reset_audio(chip);
1325
1326 return 0;
1327 }
1328
1329 static void tumbler_cleanup(struct snd_pmac *chip)
1330 {
1331 struct pmac_tumbler *mix = chip->mixer_data;
1332 if (! mix)
1333 return;
1334
1335 if (mix->headphone_irq >= 0)
1336 free_irq(mix->headphone_irq, chip);
1337 if (mix->lineout_irq >= 0)
1338 free_irq(mix->lineout_irq, chip);
1339 tumbler_gpio_free(&mix->audio_reset);
1340 tumbler_gpio_free(&mix->amp_mute);
1341 tumbler_gpio_free(&mix->hp_mute);
1342 tumbler_gpio_free(&mix->hp_detect);
1343 snd_pmac_keywest_cleanup(&mix->i2c);
1344 kfree(mix);
1345 chip->mixer_data = NULL;
1346 }
1347
1348 /* exported */
1349 int __devinit snd_pmac_tumbler_init(struct snd_pmac *chip)
1350 {
1351 int i, err;
1352 struct pmac_tumbler *mix;
1353 const u32 *paddr;
1354 struct device_node *tas_node, *np;
1355 char *chipname;
1356
1357 request_module("i2c-powermac");
1358
1359 mix = kzalloc(sizeof(*mix), GFP_KERNEL);
1360 if (! mix)
1361 return -ENOMEM;
1362 mix->headphone_irq = -1;
1363
1364 chip->mixer_data = mix;
1365 chip->mixer_free = tumbler_cleanup;
1366 mix->anded_reset = 0;
1367 mix->reset_on_sleep = 1;
1368
1369 for (np = chip->node->child; np; np = np->sibling) {
1370 if (!strcmp(np->name, "sound")) {
1371 if (of_get_property(np, "has-anded-reset", NULL))
1372 mix->anded_reset = 1;
1373 if (of_get_property(np, "layout-id", NULL))
1374 mix->reset_on_sleep = 0;
1375 break;
1376 }
1377 }
1378 if ((err = tumbler_init(chip)) < 0)
1379 return err;
1380
1381 /* set up TAS */
1382 tas_node = of_find_node_by_name(NULL, "deq");
1383 if (tas_node == NULL)
1384 tas_node = of_find_node_by_name(NULL, "codec");
1385 if (tas_node == NULL)
1386 return -ENODEV;
1387
1388 paddr = of_get_property(tas_node, "i2c-address", NULL);
1389 if (paddr == NULL)
1390 paddr = of_get_property(tas_node, "reg", NULL);
1391 if (paddr)
1392 mix->i2c.addr = (*paddr) >> 1;
1393 else
1394 mix->i2c.addr = TAS_I2C_ADDR;
1395 of_node_put(tas_node);
1396
1397 DBG("(I) TAS i2c address is: %x\n", mix->i2c.addr);
1398
1399 if (chip->model == PMAC_TUMBLER) {
1400 mix->i2c.init_client = tumbler_init_client;
1401 mix->i2c.name = "TAS3001c";
1402 chipname = "Tumbler";
1403 } else {
1404 mix->i2c.init_client = snapper_init_client;
1405 mix->i2c.name = "TAS3004";
1406 chipname = "Snapper";
1407 }
1408
1409 if ((err = snd_pmac_keywest_init(&mix->i2c)) < 0)
1410 return err;
1411
1412 /*
1413 * build mixers
1414 */
1415 sprintf(chip->card->mixername, "PowerMac %s", chipname);
1416
1417 if (chip->model == PMAC_TUMBLER) {
1418 for (i = 0; i < ARRAY_SIZE(tumbler_mixers); i++) {
1419 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&tumbler_mixers[i], chip))) < 0)
1420 return err;
1421 }
1422 } else {
1423 for (i = 0; i < ARRAY_SIZE(snapper_mixers); i++) {
1424 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snapper_mixers[i], chip))) < 0)
1425 return err;
1426 }
1427 }
1428 chip->master_sw_ctl = snd_ctl_new1(&tumbler_hp_sw, chip);
1429 if ((err = snd_ctl_add(chip->card, chip->master_sw_ctl)) < 0)
1430 return err;
1431 chip->speaker_sw_ctl = snd_ctl_new1(&tumbler_speaker_sw, chip);
1432 if ((err = snd_ctl_add(chip->card, chip->speaker_sw_ctl)) < 0)
1433 return err;
1434 if (mix->line_mute.addr != 0) {
1435 chip->lineout_sw_ctl = snd_ctl_new1(&tumbler_lineout_sw, chip);
1436 if ((err = snd_ctl_add(chip->card, chip->lineout_sw_ctl)) < 0)
1437 return err;
1438 }
1439 chip->drc_sw_ctl = snd_ctl_new1(&tumbler_drc_sw, chip);
1440 if ((err = snd_ctl_add(chip->card, chip->drc_sw_ctl)) < 0)
1441 return err;
1442
1443 /* set initial DRC range to 60% */
1444 if (chip->model == PMAC_TUMBLER)
1445 mix->drc_range = (TAS3001_DRC_MAX * 6) / 10;
1446 else
1447 mix->drc_range = (TAS3004_DRC_MAX * 6) / 10;
1448 mix->drc_enable = 1; /* will be changed later if AUTO_DRC is set */
1449 if (chip->model == PMAC_TUMBLER)
1450 tumbler_set_drc(mix);
1451 else
1452 snapper_set_drc(mix);
1453
1454 #ifdef CONFIG_PM
1455 chip->suspend = tumbler_suspend;
1456 chip->resume = tumbler_resume;
1457 #endif
1458
1459 INIT_WORK(&device_change, device_change_handler);
1460 device_change_chip = chip;
1461
1462 #ifdef PMAC_SUPPORT_AUTOMUTE
1463 if ((mix->headphone_irq >=0 || mix->lineout_irq >= 0)
1464 && (err = snd_pmac_add_automute(chip)) < 0)
1465 return err;
1466 chip->detect_headphone = tumbler_detect_headphone;
1467 chip->update_automute = tumbler_update_automute;
1468 tumbler_update_automute(chip, 0); /* update the status only */
1469
1470 /* activate headphone status interrupts */
1471 if (mix->headphone_irq >= 0) {
1472 unsigned char val;
1473 if ((err = request_irq(mix->headphone_irq, headphone_intr, 0,
1474 "Sound Headphone Detection", chip)) < 0)
1475 return 0;
1476 /* activate headphone status interrupts */
1477 val = do_gpio_read(&mix->hp_detect);
1478 do_gpio_write(&mix->hp_detect, val | 0x80);
1479 }
1480 if (mix->lineout_irq >= 0) {
1481 unsigned char val;
1482 if ((err = request_irq(mix->lineout_irq, headphone_intr, 0,
1483 "Sound Lineout Detection", chip)) < 0)
1484 return 0;
1485 /* activate headphone status interrupts */
1486 val = do_gpio_read(&mix->line_detect);
1487 do_gpio_write(&mix->line_detect, val | 0x80);
1488 }
1489 #endif
1490
1491 return 0;
1492 }
Linux ARM platform port for MOXA ART SoC