2 * PMac Tumbler/Snapper lowlevel functions
4 * Copyright (c) by Takashi Iwai <tiwai@suse.de>
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.
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.
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
20 * Rene Rebe <rene.rebe@gmx.net>:
21 * * update from shadow registers on wakeup and headphone plug
22 * * automatically toggle DRC on headphone plug
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>
37 #include <asm/machdep.h>
38 #include <asm/pmac_feature.h>
40 #include "tumbler_volume.h"
45 #define DBG(fmt...) printk(KERN_DEBUG fmt)
50 #define IS_G4DA (of_machine_is_compatible("PowerMac3,4"))
52 /* i2c address for tumbler */
53 #define TAS_I2C_ADDR 0x34
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
65 #define TAS_REG_PCM TAS_REG_INPUT1
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 */
73 /* mono volumes for tas3001c/tas3004 */
75 VOL_IDX_PCM_MONO
, /* tas3001c only */
76 VOL_IDX_BASS
, VOL_IDX_TREBLE
,
80 /* stereo volumes for tas3004 */
82 VOL_IDX_PCM
, VOL_IDX_PCM2
, VOL_IDX_ADC
,
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
;
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 */
113 int auto_mute_notify
;
122 static int send_init_client(struct pmac_keywest
*i2c
, unsigned int *regs
)
127 err
= i2c_smbus_write_byte_data(i2c
->client
,
131 DBG("(W) i2c error %d\n", err
);
142 static int tumbler_init_client(struct pmac_keywest
*i2c
)
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,
149 DBG("(I) tumbler init client\n");
150 return send_init_client(i2c
, regs
);
153 static int snapper_init_client(struct pmac_keywest
*i2c
)
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 */
164 DBG("(I) snapper init client\n");
165 return send_init_client(i2c
, regs
);
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 */
177 static void write_audio_gpio(struct pmac_gpio
*gp
, int active
)
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
);
186 static int check_audio_gpio(struct pmac_gpio
*gp
)
193 ret
= do_gpio_read(gp
);
195 return (ret
& 0x1) == (gp
->active_val
& 0x1);
198 static int read_audio_gpio(struct pmac_gpio
*gp
)
203 ret
= do_gpio_read(gp
);
204 ret
= (ret
& 0x02) !=0;
205 return ret
== gp
->active_state
;
209 * update master volume
211 static int tumbler_set_master_volume(struct pmac_tumbler
*mix
)
213 unsigned char block
[6];
214 unsigned int left_vol
, right_vol
;
216 if (! mix
->i2c
.client
)
219 if (! mix
->master_switch
[0])
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
];
227 if (! mix
->master_switch
[1])
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
];
236 block
[0] = (left_vol
>> 16) & 0xff;
237 block
[1] = (left_vol
>> 8) & 0xff;
238 block
[2] = (left_vol
>> 0) & 0xff;
240 block
[3] = (right_vol
>> 16) & 0xff;
241 block
[4] = (right_vol
>> 8) & 0xff;
242 block
[5] = (right_vol
>> 0) & 0xff;
244 if (i2c_smbus_write_i2c_block_data(mix
->i2c
.client
, TAS_REG_VOL
, 6,
246 snd_printk(KERN_ERR
"failed to set volume \n");
249 DBG("(I) succeeded to set volume (%u, %u)\n", left_vol
, right_vol
);
255 static int tumbler_info_master_volume(struct snd_kcontrol
*kcontrol
,
256 struct snd_ctl_elem_info
*uinfo
)
258 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
260 uinfo
->value
.integer
.min
= 0;
261 uinfo
->value
.integer
.max
= ARRAY_SIZE(master_volume_table
) - 1;
265 static int tumbler_get_master_volume(struct snd_kcontrol
*kcontrol
,
266 struct snd_ctl_elem_value
*ucontrol
)
268 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
269 struct pmac_tumbler
*mix
= chip
->mixer_data
;
271 ucontrol
->value
.integer
.value
[0] = mix
->master_vol
[0];
272 ucontrol
->value
.integer
.value
[1] = mix
->master_vol
[1];
276 static int tumbler_put_master_volume(struct snd_kcontrol
*kcontrol
,
277 struct snd_ctl_elem_value
*ucontrol
)
279 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
280 struct pmac_tumbler
*mix
= chip
->mixer_data
;
284 vol
[0] = ucontrol
->value
.integer
.value
[0];
285 vol
[1] = ucontrol
->value
.integer
.value
[1];
286 if (vol
[0] >= ARRAY_SIZE(master_volume_table
) ||
287 vol
[1] >= ARRAY_SIZE(master_volume_table
))
289 change
= mix
->master_vol
[0] != vol
[0] ||
290 mix
->master_vol
[1] != vol
[1];
292 mix
->master_vol
[0] = vol
[0];
293 mix
->master_vol
[1] = vol
[1];
294 tumbler_set_master_volume(mix
);
300 static int tumbler_get_master_switch(struct snd_kcontrol
*kcontrol
,
301 struct snd_ctl_elem_value
*ucontrol
)
303 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
304 struct pmac_tumbler
*mix
= chip
->mixer_data
;
306 ucontrol
->value
.integer
.value
[0] = mix
->master_switch
[0];
307 ucontrol
->value
.integer
.value
[1] = mix
->master_switch
[1];
311 static int tumbler_put_master_switch(struct snd_kcontrol
*kcontrol
,
312 struct snd_ctl_elem_value
*ucontrol
)
314 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
315 struct pmac_tumbler
*mix
= chip
->mixer_data
;
318 change
= mix
->master_switch
[0] != ucontrol
->value
.integer
.value
[0] ||
319 mix
->master_switch
[1] != ucontrol
->value
.integer
.value
[1];
321 mix
->master_switch
[0] = !!ucontrol
->value
.integer
.value
[0];
322 mix
->master_switch
[1] = !!ucontrol
->value
.integer
.value
[1];
323 tumbler_set_master_volume(mix
);
330 * TAS3001c dynamic range compression
333 #define TAS3001_DRC_MAX 0x5f
335 static int tumbler_set_drc(struct pmac_tumbler
*mix
)
337 unsigned char val
[2];
339 if (! mix
->i2c
.client
)
342 if (mix
->drc_enable
) {
343 val
[0] = 0xc1; /* enable, 3:1 compression */
344 if (mix
->drc_range
> TAS3001_DRC_MAX
)
346 else if (mix
->drc_range
< 0)
349 val
[1] = mix
->drc_range
+ 0x91;
355 if (i2c_smbus_write_i2c_block_data(mix
->i2c
.client
, TAS_REG_DRC
,
357 snd_printk(KERN_ERR
"failed to set DRC\n");
360 DBG("(I) succeeded to set DRC (%u, %u)\n", val
[0], val
[1]);
368 #define TAS3004_DRC_MAX 0xef
370 static int snapper_set_drc(struct pmac_tumbler
*mix
)
372 unsigned char val
[6];
374 if (! mix
->i2c
.client
)
378 val
[0] = 0x50; /* 3:1 above threshold */
380 val
[0] = 0x51; /* disabled */
381 val
[1] = 0x02; /* 1:1 below threshold */
382 if (mix
->drc_range
> 0xef)
384 else if (mix
->drc_range
< 0)
387 val
[2] = mix
->drc_range
;
392 if (i2c_smbus_write_i2c_block_data(mix
->i2c
.client
, TAS_REG_DRC
,
394 snd_printk(KERN_ERR
"failed to set DRC\n");
397 DBG("(I) succeeded to set DRC (%u, %u)\n", val
[0], val
[1]);
401 static int tumbler_info_drc_value(struct snd_kcontrol
*kcontrol
,
402 struct snd_ctl_elem_info
*uinfo
)
404 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
405 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
407 uinfo
->value
.integer
.min
= 0;
408 uinfo
->value
.integer
.max
=
409 chip
->model
== PMAC_TUMBLER
? TAS3001_DRC_MAX
: TAS3004_DRC_MAX
;
413 static int tumbler_get_drc_value(struct snd_kcontrol
*kcontrol
,
414 struct snd_ctl_elem_value
*ucontrol
)
416 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
417 struct pmac_tumbler
*mix
;
418 if (! (mix
= chip
->mixer_data
))
420 ucontrol
->value
.integer
.value
[0] = mix
->drc_range
;
424 static int tumbler_put_drc_value(struct snd_kcontrol
*kcontrol
,
425 struct snd_ctl_elem_value
*ucontrol
)
427 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
428 struct pmac_tumbler
*mix
;
432 if (! (mix
= chip
->mixer_data
))
434 val
= ucontrol
->value
.integer
.value
[0];
435 if (chip
->model
== PMAC_TUMBLER
) {
436 if (val
> TAS3001_DRC_MAX
)
439 if (val
> TAS3004_DRC_MAX
)
442 change
= mix
->drc_range
!= val
;
444 mix
->drc_range
= val
;
445 if (chip
->model
== PMAC_TUMBLER
)
446 tumbler_set_drc(mix
);
448 snapper_set_drc(mix
);
453 static int tumbler_get_drc_switch(struct snd_kcontrol
*kcontrol
,
454 struct snd_ctl_elem_value
*ucontrol
)
456 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
457 struct pmac_tumbler
*mix
;
458 if (! (mix
= chip
->mixer_data
))
460 ucontrol
->value
.integer
.value
[0] = mix
->drc_enable
;
464 static int tumbler_put_drc_switch(struct snd_kcontrol
*kcontrol
,
465 struct snd_ctl_elem_value
*ucontrol
)
467 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
468 struct pmac_tumbler
*mix
;
471 if (! (mix
= chip
->mixer_data
))
473 change
= mix
->drc_enable
!= ucontrol
->value
.integer
.value
[0];
475 mix
->drc_enable
= !!ucontrol
->value
.integer
.value
[0];
476 if (chip
->model
== PMAC_TUMBLER
)
477 tumbler_set_drc(mix
);
479 snapper_set_drc(mix
);
489 struct tumbler_mono_vol
{
497 static int tumbler_set_mono_volume(struct pmac_tumbler
*mix
,
498 struct tumbler_mono_vol
*info
)
500 unsigned char block
[4];
504 if (! mix
->i2c
.client
)
507 vol
= mix
->mono_vol
[info
->index
];
508 if (vol
>= info
->max
)
510 vol
= info
->table
[vol
];
511 for (i
= 0; i
< info
->bytes
; i
++)
512 block
[i
] = (vol
>> ((info
->bytes
- i
- 1) * 8)) & 0xff;
513 if (i2c_smbus_write_i2c_block_data(mix
->i2c
.client
, info
->reg
,
514 info
->bytes
, block
) < 0) {
515 snd_printk(KERN_ERR
"failed to set mono volume %d\n",
522 static int tumbler_info_mono(struct snd_kcontrol
*kcontrol
,
523 struct snd_ctl_elem_info
*uinfo
)
525 struct tumbler_mono_vol
*info
= (struct tumbler_mono_vol
*)kcontrol
->private_value
;
527 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
529 uinfo
->value
.integer
.min
= 0;
530 uinfo
->value
.integer
.max
= info
->max
- 1;
534 static int tumbler_get_mono(struct snd_kcontrol
*kcontrol
,
535 struct snd_ctl_elem_value
*ucontrol
)
537 struct tumbler_mono_vol
*info
= (struct tumbler_mono_vol
*)kcontrol
->private_value
;
538 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
539 struct pmac_tumbler
*mix
;
540 if (! (mix
= chip
->mixer_data
))
542 ucontrol
->value
.integer
.value
[0] = mix
->mono_vol
[info
->index
];
546 static int tumbler_put_mono(struct snd_kcontrol
*kcontrol
,
547 struct snd_ctl_elem_value
*ucontrol
)
549 struct tumbler_mono_vol
*info
= (struct tumbler_mono_vol
*)kcontrol
->private_value
;
550 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
551 struct pmac_tumbler
*mix
;
555 if (! (mix
= chip
->mixer_data
))
557 vol
= ucontrol
->value
.integer
.value
[0];
558 if (vol
>= info
->max
)
560 change
= mix
->mono_vol
[info
->index
] != vol
;
562 mix
->mono_vol
[info
->index
] = vol
;
563 tumbler_set_mono_volume(mix
, info
);
568 /* TAS3001c mono volumes */
569 static struct tumbler_mono_vol tumbler_pcm_vol_info
= {
570 .index
= VOL_IDX_PCM_MONO
,
573 .max
= ARRAY_SIZE(mixer_volume_table
),
574 .table
= mixer_volume_table
,
577 static struct tumbler_mono_vol tumbler_bass_vol_info
= {
578 .index
= VOL_IDX_BASS
,
581 .max
= ARRAY_SIZE(bass_volume_table
),
582 .table
= bass_volume_table
,
585 static struct tumbler_mono_vol tumbler_treble_vol_info
= {
586 .index
= VOL_IDX_TREBLE
,
587 .reg
= TAS_REG_TREBLE
,
589 .max
= ARRAY_SIZE(treble_volume_table
),
590 .table
= treble_volume_table
,
593 /* TAS3004 mono volumes */
594 static struct tumbler_mono_vol snapper_bass_vol_info
= {
595 .index
= VOL_IDX_BASS
,
598 .max
= ARRAY_SIZE(snapper_bass_volume_table
),
599 .table
= snapper_bass_volume_table
,
602 static struct tumbler_mono_vol snapper_treble_vol_info
= {
603 .index
= VOL_IDX_TREBLE
,
604 .reg
= TAS_REG_TREBLE
,
606 .max
= ARRAY_SIZE(snapper_treble_volume_table
),
607 .table
= snapper_treble_volume_table
,
611 #define DEFINE_MONO(xname,type) { \
612 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
614 .info = tumbler_info_mono, \
615 .get = tumbler_get_mono, \
616 .put = tumbler_put_mono, \
617 .private_value = (unsigned long)(&tumbler_##type##_vol_info), \
620 #define DEFINE_SNAPPER_MONO(xname,type) { \
621 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
623 .info = tumbler_info_mono, \
624 .get = tumbler_get_mono, \
625 .put = tumbler_put_mono, \
626 .private_value = (unsigned long)(&snapper_##type##_vol_info), \
631 * snapper mixer volumes
634 static int snapper_set_mix_vol1(struct pmac_tumbler
*mix
, int idx
, int ch
, int reg
)
637 unsigned char block
[9];
639 vol
= mix
->mix_vol
[idx
][ch
];
640 if (vol
>= ARRAY_SIZE(mixer_volume_table
)) {
641 vol
= ARRAY_SIZE(mixer_volume_table
) - 1;
642 mix
->mix_vol
[idx
][ch
] = vol
;
645 for (i
= 0; i
< 3; i
++) {
646 vol
= mix
->mix_vol
[i
][ch
];
647 vol
= mixer_volume_table
[vol
];
648 for (j
= 0; j
< 3; j
++)
649 block
[i
* 3 + j
] = (vol
>> ((2 - j
) * 8)) & 0xff;
651 if (i2c_smbus_write_i2c_block_data(mix
->i2c
.client
, reg
,
653 snd_printk(KERN_ERR
"failed to set mono volume %d\n", reg
);
659 static int snapper_set_mix_vol(struct pmac_tumbler
*mix
, int idx
)
661 if (! mix
->i2c
.client
)
663 if (snapper_set_mix_vol1(mix
, idx
, 0, TAS_REG_LMIX
) < 0 ||
664 snapper_set_mix_vol1(mix
, idx
, 1, TAS_REG_RMIX
) < 0)
669 static int snapper_info_mix(struct snd_kcontrol
*kcontrol
,
670 struct snd_ctl_elem_info
*uinfo
)
672 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
674 uinfo
->value
.integer
.min
= 0;
675 uinfo
->value
.integer
.max
= ARRAY_SIZE(mixer_volume_table
) - 1;
679 static int snapper_get_mix(struct snd_kcontrol
*kcontrol
,
680 struct snd_ctl_elem_value
*ucontrol
)
682 int idx
= (int)kcontrol
->private_value
;
683 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
684 struct pmac_tumbler
*mix
;
685 if (! (mix
= chip
->mixer_data
))
687 ucontrol
->value
.integer
.value
[0] = mix
->mix_vol
[idx
][0];
688 ucontrol
->value
.integer
.value
[1] = mix
->mix_vol
[idx
][1];
692 static int snapper_put_mix(struct snd_kcontrol
*kcontrol
,
693 struct snd_ctl_elem_value
*ucontrol
)
695 int idx
= (int)kcontrol
->private_value
;
696 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
697 struct pmac_tumbler
*mix
;
701 if (! (mix
= chip
->mixer_data
))
703 vol
[0] = ucontrol
->value
.integer
.value
[0];
704 vol
[1] = ucontrol
->value
.integer
.value
[1];
705 if (vol
[0] >= ARRAY_SIZE(mixer_volume_table
) ||
706 vol
[1] >= ARRAY_SIZE(mixer_volume_table
))
708 change
= mix
->mix_vol
[idx
][0] != vol
[0] ||
709 mix
->mix_vol
[idx
][1] != vol
[1];
711 mix
->mix_vol
[idx
][0] = vol
[0];
712 mix
->mix_vol
[idx
][1] = vol
[1];
713 snapper_set_mix_vol(mix
, idx
);
720 enum { TUMBLER_MUTE_HP
, TUMBLER_MUTE_AMP
, TUMBLER_MUTE_LINE
};
722 static int tumbler_get_mute_switch(struct snd_kcontrol
*kcontrol
,
723 struct snd_ctl_elem_value
*ucontrol
)
725 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
726 struct pmac_tumbler
*mix
;
727 struct pmac_gpio
*gp
;
728 if (! (mix
= chip
->mixer_data
))
730 switch(kcontrol
->private_value
) {
731 case TUMBLER_MUTE_HP
:
732 gp
= &mix
->hp_mute
; break;
733 case TUMBLER_MUTE_AMP
:
734 gp
= &mix
->amp_mute
; break;
735 case TUMBLER_MUTE_LINE
:
736 gp
= &mix
->line_mute
; break;
742 ucontrol
->value
.integer
.value
[0] = !check_audio_gpio(gp
);
746 static int tumbler_put_mute_switch(struct snd_kcontrol
*kcontrol
,
747 struct snd_ctl_elem_value
*ucontrol
)
749 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
750 struct pmac_tumbler
*mix
;
751 struct pmac_gpio
*gp
;
753 #ifdef PMAC_SUPPORT_AUTOMUTE
754 if (chip
->update_automute
&& chip
->auto_mute
)
755 return 0; /* don't touch in the auto-mute mode */
757 if (! (mix
= chip
->mixer_data
))
759 switch(kcontrol
->private_value
) {
760 case TUMBLER_MUTE_HP
:
761 gp
= &mix
->hp_mute
; break;
762 case TUMBLER_MUTE_AMP
:
763 gp
= &mix
->amp_mute
; break;
764 case TUMBLER_MUTE_LINE
:
765 gp
= &mix
->line_mute
; break;
771 val
= ! check_audio_gpio(gp
);
772 if (val
!= ucontrol
->value
.integer
.value
[0]) {
773 write_audio_gpio(gp
, ! ucontrol
->value
.integer
.value
[0]);
779 static int snapper_set_capture_source(struct pmac_tumbler
*mix
)
781 if (! mix
->i2c
.client
)
783 if (mix
->capture_source
)
784 mix
->acs
= mix
->acs
|= 2;
787 return i2c_smbus_write_byte_data(mix
->i2c
.client
, TAS_REG_ACS
, mix
->acs
);
790 static int snapper_info_capture_source(struct snd_kcontrol
*kcontrol
,
791 struct snd_ctl_elem_info
*uinfo
)
793 static char *texts
[2] = {
796 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
798 uinfo
->value
.enumerated
.items
= 2;
799 if (uinfo
->value
.enumerated
.item
> 1)
800 uinfo
->value
.enumerated
.item
= 1;
801 strcpy(uinfo
->value
.enumerated
.name
, texts
[uinfo
->value
.enumerated
.item
]);
805 static int snapper_get_capture_source(struct snd_kcontrol
*kcontrol
,
806 struct snd_ctl_elem_value
*ucontrol
)
808 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
809 struct pmac_tumbler
*mix
= chip
->mixer_data
;
811 ucontrol
->value
.enumerated
.item
[0] = mix
->capture_source
;
815 static int snapper_put_capture_source(struct snd_kcontrol
*kcontrol
,
816 struct snd_ctl_elem_value
*ucontrol
)
818 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
819 struct pmac_tumbler
*mix
= chip
->mixer_data
;
822 change
= ucontrol
->value
.enumerated
.item
[0] != mix
->capture_source
;
824 mix
->capture_source
= !!ucontrol
->value
.enumerated
.item
[0];
825 snapper_set_capture_source(mix
);
830 #define DEFINE_SNAPPER_MIX(xname,idx,ofs) { \
831 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
833 .info = snapper_info_mix, \
834 .get = snapper_get_mix, \
835 .put = snapper_put_mix, \
837 .private_value = ofs, \
843 static struct snd_kcontrol_new tumbler_mixers
[] __devinitdata
= {
844 { .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
845 .name
= "Master Playback Volume",
846 .info
= tumbler_info_master_volume
,
847 .get
= tumbler_get_master_volume
,
848 .put
= tumbler_put_master_volume
850 { .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
851 .name
= "Master Playback Switch",
852 .info
= snd_pmac_boolean_stereo_info
,
853 .get
= tumbler_get_master_switch
,
854 .put
= tumbler_put_master_switch
856 DEFINE_MONO("Tone Control - Bass", bass
),
857 DEFINE_MONO("Tone Control - Treble", treble
),
858 DEFINE_MONO("PCM Playback Volume", pcm
),
859 { .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
861 .info
= tumbler_info_drc_value
,
862 .get
= tumbler_get_drc_value
,
863 .put
= tumbler_put_drc_value
867 static struct snd_kcontrol_new snapper_mixers
[] __devinitdata
= {
868 { .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
869 .name
= "Master Playback Volume",
870 .info
= tumbler_info_master_volume
,
871 .get
= tumbler_get_master_volume
,
872 .put
= tumbler_put_master_volume
874 { .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
875 .name
= "Master Playback Switch",
876 .info
= snd_pmac_boolean_stereo_info
,
877 .get
= tumbler_get_master_switch
,
878 .put
= tumbler_put_master_switch
880 DEFINE_SNAPPER_MIX("PCM Playback Volume", 0, VOL_IDX_PCM
),
881 /* Alternative PCM is assigned to Mic analog loopback on iBook G4 */
882 DEFINE_SNAPPER_MIX("Mic Playback Volume", 0, VOL_IDX_PCM2
),
883 DEFINE_SNAPPER_MIX("Monitor Mix Volume", 0, VOL_IDX_ADC
),
884 DEFINE_SNAPPER_MONO("Tone Control - Bass", bass
),
885 DEFINE_SNAPPER_MONO("Tone Control - Treble", treble
),
886 { .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
888 .info
= tumbler_info_drc_value
,
889 .get
= tumbler_get_drc_value
,
890 .put
= tumbler_put_drc_value
892 { .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
893 .name
= "Input Source",
894 .info
= snapper_info_capture_source
,
895 .get
= snapper_get_capture_source
,
896 .put
= snapper_put_capture_source
900 static struct snd_kcontrol_new tumbler_hp_sw __devinitdata
= {
901 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
902 .name
= "Headphone Playback Switch",
903 .info
= snd_pmac_boolean_mono_info
,
904 .get
= tumbler_get_mute_switch
,
905 .put
= tumbler_put_mute_switch
,
906 .private_value
= TUMBLER_MUTE_HP
,
908 static struct snd_kcontrol_new tumbler_speaker_sw __devinitdata
= {
909 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
910 .name
= "Speaker Playback Switch",
911 .info
= snd_pmac_boolean_mono_info
,
912 .get
= tumbler_get_mute_switch
,
913 .put
= tumbler_put_mute_switch
,
914 .private_value
= TUMBLER_MUTE_AMP
,
916 static struct snd_kcontrol_new tumbler_lineout_sw __devinitdata
= {
917 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
918 .name
= "Line Out Playback Switch",
919 .info
= snd_pmac_boolean_mono_info
,
920 .get
= tumbler_get_mute_switch
,
921 .put
= tumbler_put_mute_switch
,
922 .private_value
= TUMBLER_MUTE_LINE
,
924 static struct snd_kcontrol_new tumbler_drc_sw __devinitdata
= {
925 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
926 .name
= "DRC Switch",
927 .info
= snd_pmac_boolean_mono_info
,
928 .get
= tumbler_get_drc_switch
,
929 .put
= tumbler_put_drc_switch
933 #ifdef PMAC_SUPPORT_AUTOMUTE
937 static int tumbler_detect_headphone(struct snd_pmac
*chip
)
939 struct pmac_tumbler
*mix
= chip
->mixer_data
;
942 if (mix
->hp_detect
.addr
)
943 detect
|= read_audio_gpio(&mix
->hp_detect
);
947 static int tumbler_detect_lineout(struct snd_pmac
*chip
)
949 struct pmac_tumbler
*mix
= chip
->mixer_data
;
952 if (mix
->line_detect
.addr
)
953 detect
|= read_audio_gpio(&mix
->line_detect
);
957 static void check_mute(struct snd_pmac
*chip
, struct pmac_gpio
*gp
, int val
, int do_notify
,
958 struct snd_kcontrol
*sw
)
960 if (check_audio_gpio(gp
) != val
) {
961 write_audio_gpio(gp
, val
);
963 snd_ctl_notify(chip
->card
, SNDRV_CTL_EVENT_MASK_VALUE
,
968 static struct work_struct device_change
;
969 static struct snd_pmac
*device_change_chip
;
971 static void device_change_handler(struct work_struct
*work
)
973 struct snd_pmac
*chip
= device_change_chip
;
974 struct pmac_tumbler
*mix
;
975 int headphone
, lineout
;
980 mix
= chip
->mixer_data
;
981 if (snd_BUG_ON(!mix
))
984 headphone
= tumbler_detect_headphone(chip
);
985 lineout
= tumbler_detect_lineout(chip
);
987 DBG("headphone: %d, lineout: %d\n", headphone
, lineout
);
989 if (headphone
|| lineout
) {
990 /* unmute headphone/lineout & mute speaker */
992 check_mute(chip
, &mix
->hp_mute
, 0, mix
->auto_mute_notify
,
993 chip
->master_sw_ctl
);
994 if (lineout
&& mix
->line_mute
.addr
!= 0)
995 check_mute(chip
, &mix
->line_mute
, 0, mix
->auto_mute_notify
,
996 chip
->lineout_sw_ctl
);
997 if (mix
->anded_reset
)
999 check_mute(chip
, &mix
->amp_mute
, 1, mix
->auto_mute_notify
,
1000 chip
->speaker_sw_ctl
);
1002 /* unmute speaker, mute others */
1003 check_mute(chip
, &mix
->amp_mute
, 0, mix
->auto_mute_notify
,
1004 chip
->speaker_sw_ctl
);
1005 if (mix
->anded_reset
)
1007 check_mute(chip
, &mix
->hp_mute
, 1, mix
->auto_mute_notify
,
1008 chip
->master_sw_ctl
);
1009 if (mix
->line_mute
.addr
!= 0)
1010 check_mute(chip
, &mix
->line_mute
, 1, mix
->auto_mute_notify
,
1011 chip
->lineout_sw_ctl
);
1013 if (mix
->auto_mute_notify
)
1014 snd_ctl_notify(chip
->card
, SNDRV_CTL_EVENT_MASK_VALUE
,
1015 &chip
->hp_detect_ctl
->id
);
1017 #ifdef CONFIG_SND_POWERMAC_AUTO_DRC
1018 mix
->drc_enable
= ! (headphone
|| lineout
);
1019 if (mix
->auto_mute_notify
)
1020 snd_ctl_notify(chip
->card
, SNDRV_CTL_EVENT_MASK_VALUE
,
1021 &chip
->drc_sw_ctl
->id
);
1022 if (chip
->model
== PMAC_TUMBLER
)
1023 tumbler_set_drc(mix
);
1025 snapper_set_drc(mix
);
1028 /* reset the master volume so the correct amplification is applied */
1029 tumbler_set_master_volume(mix
);
1032 static void tumbler_update_automute(struct snd_pmac
*chip
, int do_notify
)
1034 if (chip
->auto_mute
) {
1035 struct pmac_tumbler
*mix
;
1036 mix
= chip
->mixer_data
;
1037 if (snd_BUG_ON(!mix
))
1039 mix
->auto_mute_notify
= do_notify
;
1040 schedule_work(&device_change
);
1043 #endif /* PMAC_SUPPORT_AUTOMUTE */
1046 /* interrupt - headphone plug changed */
1047 static irqreturn_t
headphone_intr(int irq
, void *devid
)
1049 struct snd_pmac
*chip
= devid
;
1050 if (chip
->update_automute
&& chip
->initialized
) {
1051 chip
->update_automute(chip
, 1);
1057 /* look for audio-gpio device */
1058 static struct device_node
*find_audio_device(const char *name
)
1060 struct device_node
*gpiop
;
1061 struct device_node
*np
;
1063 gpiop
= of_find_node_by_name(NULL
, "gpio");
1067 for (np
= of_get_next_child(gpiop
, NULL
); np
;
1068 np
= of_get_next_child(gpiop
, np
)) {
1069 const char *property
= of_get_property(np
, "audio-gpio", NULL
);
1070 if (property
&& strcmp(property
, name
) == 0)
1077 /* look for audio-gpio device */
1078 static struct device_node
*find_compatible_audio_device(const char *name
)
1080 struct device_node
*gpiop
;
1081 struct device_node
*np
;
1083 gpiop
= of_find_node_by_name(NULL
, "gpio");
1087 for (np
= of_get_next_child(gpiop
, NULL
); np
;
1088 np
= of_get_next_child(gpiop
, np
)) {
1089 if (of_device_is_compatible(np
, name
))
1096 /* find an audio device and get its address */
1097 static long tumbler_find_device(const char *device
, const char *platform
,
1098 struct pmac_gpio
*gp
, int is_compatible
)
1100 struct device_node
*node
;
1106 node
= find_compatible_audio_device(device
);
1108 node
= find_audio_device(device
);
1110 DBG("(W) cannot find audio device %s !\n", device
);
1111 snd_printdd("cannot find device %s\n", device
);
1115 base
= of_get_property(node
, "AAPL,address", NULL
);
1117 base
= of_get_property(node
, "reg", NULL
);
1119 DBG("(E) cannot find address for device %s !\n", device
);
1120 snd_printd("cannot find address for device %s\n", device
);
1130 gp
->addr
= addr
& 0x0000ffff;
1131 /* Try to find the active state, default to 0 ! */
1132 base
= of_get_property(node
, "audio-gpio-active-state", NULL
);
1134 gp
->active_state
= *base
;
1135 gp
->active_val
= (*base
) ? 0x5 : 0x4;
1136 gp
->inactive_val
= (*base
) ? 0x4 : 0x5;
1138 const u32
*prop
= NULL
;
1139 gp
->active_state
= IS_G4DA
1140 && !strncmp(device
, "keywest-gpio1", 13);
1141 gp
->active_val
= 0x4;
1142 gp
->inactive_val
= 0x5;
1143 /* Here are some crude hacks to extract the GPIO polarity and
1144 * open collector informations out of the do-platform script
1145 * as we don't yet have an interpreter for these things
1148 prop
= of_get_property(node
, platform
, NULL
);
1150 if (prop
[3] == 0x9 && prop
[4] == 0x9) {
1151 gp
->active_val
= 0xd;
1152 gp
->inactive_val
= 0xc;
1154 if (prop
[3] == 0x1 && prop
[4] == 0x1) {
1155 gp
->active_val
= 0x5;
1156 gp
->inactive_val
= 0x4;
1161 DBG("(I) GPIO device %s found, offset: %x, active state: %d !\n",
1162 device
, gp
->addr
, gp
->active_state
);
1164 ret
= irq_of_parse_and_map(node
, 0);
1170 static void tumbler_reset_audio(struct snd_pmac
*chip
)
1172 struct pmac_tumbler
*mix
= chip
->mixer_data
;
1174 if (mix
->anded_reset
) {
1175 DBG("(I) codec anded reset !\n");
1176 write_audio_gpio(&mix
->hp_mute
, 0);
1177 write_audio_gpio(&mix
->amp_mute
, 0);
1179 write_audio_gpio(&mix
->hp_mute
, 1);
1180 write_audio_gpio(&mix
->amp_mute
, 1);
1182 write_audio_gpio(&mix
->hp_mute
, 0);
1183 write_audio_gpio(&mix
->amp_mute
, 0);
1186 DBG("(I) codec normal reset !\n");
1188 write_audio_gpio(&mix
->audio_reset
, 0);
1190 write_audio_gpio(&mix
->audio_reset
, 1);
1192 write_audio_gpio(&mix
->audio_reset
, 0);
1199 static void tumbler_suspend(struct snd_pmac
*chip
)
1201 struct pmac_tumbler
*mix
= chip
->mixer_data
;
1203 if (mix
->headphone_irq
>= 0)
1204 disable_irq(mix
->headphone_irq
);
1205 if (mix
->lineout_irq
>= 0)
1206 disable_irq(mix
->lineout_irq
);
1207 mix
->save_master_switch
[0] = mix
->master_switch
[0];
1208 mix
->save_master_switch
[1] = mix
->master_switch
[1];
1209 mix
->save_master_vol
[0] = mix
->master_vol
[0];
1210 mix
->save_master_vol
[1] = mix
->master_vol
[1];
1211 mix
->master_switch
[0] = mix
->master_switch
[1] = 0;
1212 tumbler_set_master_volume(mix
);
1213 if (!mix
->anded_reset
) {
1214 write_audio_gpio(&mix
->amp_mute
, 1);
1215 write_audio_gpio(&mix
->hp_mute
, 1);
1217 if (chip
->model
== PMAC_SNAPPER
) {
1219 i2c_smbus_write_byte_data(mix
->i2c
.client
, TAS_REG_ACS
, mix
->acs
);
1221 if (mix
->anded_reset
) {
1222 write_audio_gpio(&mix
->amp_mute
, 1);
1223 write_audio_gpio(&mix
->hp_mute
, 1);
1225 write_audio_gpio(&mix
->audio_reset
, 1);
1229 static void tumbler_resume(struct snd_pmac
*chip
)
1231 struct pmac_tumbler
*mix
= chip
->mixer_data
;
1234 mix
->master_switch
[0] = mix
->save_master_switch
[0];
1235 mix
->master_switch
[1] = mix
->save_master_switch
[1];
1236 mix
->master_vol
[0] = mix
->save_master_vol
[0];
1237 mix
->master_vol
[1] = mix
->save_master_vol
[1];
1238 tumbler_reset_audio(chip
);
1239 if (mix
->i2c
.client
&& mix
->i2c
.init_client
) {
1240 if (mix
->i2c
.init_client(&mix
->i2c
) < 0)
1241 printk(KERN_ERR
"tumbler_init_client error\n");
1243 printk(KERN_ERR
"tumbler: i2c is not initialized\n");
1244 if (chip
->model
== PMAC_TUMBLER
) {
1245 tumbler_set_mono_volume(mix
, &tumbler_pcm_vol_info
);
1246 tumbler_set_mono_volume(mix
, &tumbler_bass_vol_info
);
1247 tumbler_set_mono_volume(mix
, &tumbler_treble_vol_info
);
1248 tumbler_set_drc(mix
);
1250 snapper_set_mix_vol(mix
, VOL_IDX_PCM
);
1251 snapper_set_mix_vol(mix
, VOL_IDX_PCM2
);
1252 snapper_set_mix_vol(mix
, VOL_IDX_ADC
);
1253 tumbler_set_mono_volume(mix
, &snapper_bass_vol_info
);
1254 tumbler_set_mono_volume(mix
, &snapper_treble_vol_info
);
1255 snapper_set_drc(mix
);
1256 snapper_set_capture_source(mix
);
1258 tumbler_set_master_volume(mix
);
1259 if (chip
->update_automute
)
1260 chip
->update_automute(chip
, 0);
1261 if (mix
->headphone_irq
>= 0) {
1264 enable_irq(mix
->headphone_irq
);
1265 /* activate headphone status interrupts */
1266 val
= do_gpio_read(&mix
->hp_detect
);
1267 do_gpio_write(&mix
->hp_detect
, val
| 0x80);
1269 if (mix
->lineout_irq
>= 0)
1270 enable_irq(mix
->lineout_irq
);
1274 /* initialize tumbler */
1275 static int __devinit
tumbler_init(struct snd_pmac
*chip
)
1278 struct pmac_tumbler
*mix
= chip
->mixer_data
;
1280 if (tumbler_find_device("audio-hw-reset",
1281 "platform-do-hw-reset",
1282 &mix
->audio_reset
, 0) < 0)
1283 tumbler_find_device("hw-reset",
1284 "platform-do-hw-reset",
1285 &mix
->audio_reset
, 1);
1286 if (tumbler_find_device("amp-mute",
1287 "platform-do-amp-mute",
1288 &mix
->amp_mute
, 0) < 0)
1289 tumbler_find_device("amp-mute",
1290 "platform-do-amp-mute",
1292 if (tumbler_find_device("headphone-mute",
1293 "platform-do-headphone-mute",
1294 &mix
->hp_mute
, 0) < 0)
1295 tumbler_find_device("headphone-mute",
1296 "platform-do-headphone-mute",
1298 if (tumbler_find_device("line-output-mute",
1299 "platform-do-lineout-mute",
1300 &mix
->line_mute
, 0) < 0)
1301 tumbler_find_device("line-output-mute",
1302 "platform-do-lineout-mute",
1303 &mix
->line_mute
, 1);
1304 irq
= tumbler_find_device("headphone-detect",
1305 NULL
, &mix
->hp_detect
, 0);
1307 irq
= tumbler_find_device("headphone-detect",
1308 NULL
, &mix
->hp_detect
, 1);
1310 irq
= tumbler_find_device("keywest-gpio15",
1311 NULL
, &mix
->hp_detect
, 1);
1312 mix
->headphone_irq
= irq
;
1313 irq
= tumbler_find_device("line-output-detect",
1314 NULL
, &mix
->line_detect
, 0);
1316 irq
= tumbler_find_device("line-output-detect",
1317 NULL
, &mix
->line_detect
, 1);
1318 if (IS_G4DA
&& irq
<= NO_IRQ
)
1319 irq
= tumbler_find_device("keywest-gpio16",
1320 NULL
, &mix
->line_detect
, 1);
1321 mix
->lineout_irq
= irq
;
1323 tumbler_reset_audio(chip
);
1328 static void tumbler_cleanup(struct snd_pmac
*chip
)
1330 struct pmac_tumbler
*mix
= chip
->mixer_data
;
1334 if (mix
->headphone_irq
>= 0)
1335 free_irq(mix
->headphone_irq
, chip
);
1336 if (mix
->lineout_irq
>= 0)
1337 free_irq(mix
->lineout_irq
, chip
);
1338 tumbler_gpio_free(&mix
->audio_reset
);
1339 tumbler_gpio_free(&mix
->amp_mute
);
1340 tumbler_gpio_free(&mix
->hp_mute
);
1341 tumbler_gpio_free(&mix
->hp_detect
);
1342 snd_pmac_keywest_cleanup(&mix
->i2c
);
1344 chip
->mixer_data
= NULL
;
1348 int __devinit
snd_pmac_tumbler_init(struct snd_pmac
*chip
)
1351 struct pmac_tumbler
*mix
;
1353 struct device_node
*tas_node
, *np
;
1356 request_module("i2c-powermac");
1358 mix
= kzalloc(sizeof(*mix
), GFP_KERNEL
);
1361 mix
->headphone_irq
= -1;
1363 chip
->mixer_data
= mix
;
1364 chip
->mixer_free
= tumbler_cleanup
;
1365 mix
->anded_reset
= 0;
1366 mix
->reset_on_sleep
= 1;
1368 for (np
= chip
->node
->child
; np
; np
= np
->sibling
) {
1369 if (!strcmp(np
->name
, "sound")) {
1370 if (of_get_property(np
, "has-anded-reset", NULL
))
1371 mix
->anded_reset
= 1;
1372 if (of_get_property(np
, "layout-id", NULL
))
1373 mix
->reset_on_sleep
= 0;
1377 if ((err
= tumbler_init(chip
)) < 0)
1381 tas_node
= of_find_node_by_name(NULL
, "deq");
1382 if (tas_node
== NULL
)
1383 tas_node
= of_find_node_by_name(NULL
, "codec");
1384 if (tas_node
== NULL
)
1387 paddr
= of_get_property(tas_node
, "i2c-address", NULL
);
1389 paddr
= of_get_property(tas_node
, "reg", NULL
);
1391 mix
->i2c
.addr
= (*paddr
) >> 1;
1393 mix
->i2c
.addr
= TAS_I2C_ADDR
;
1394 of_node_put(tas_node
);
1396 DBG("(I) TAS i2c address is: %x\n", mix
->i2c
.addr
);
1398 if (chip
->model
== PMAC_TUMBLER
) {
1399 mix
->i2c
.init_client
= tumbler_init_client
;
1400 mix
->i2c
.name
= "TAS3001c";
1401 chipname
= "Tumbler";
1403 mix
->i2c
.init_client
= snapper_init_client
;
1404 mix
->i2c
.name
= "TAS3004";
1405 chipname
= "Snapper";
1408 if ((err
= snd_pmac_keywest_init(&mix
->i2c
)) < 0)
1414 sprintf(chip
->card
->mixername
, "PowerMac %s", chipname
);
1416 if (chip
->model
== PMAC_TUMBLER
) {
1417 for (i
= 0; i
< ARRAY_SIZE(tumbler_mixers
); i
++) {
1418 if ((err
= snd_ctl_add(chip
->card
, snd_ctl_new1(&tumbler_mixers
[i
], chip
))) < 0)
1422 for (i
= 0; i
< ARRAY_SIZE(snapper_mixers
); i
++) {
1423 if ((err
= snd_ctl_add(chip
->card
, snd_ctl_new1(&snapper_mixers
[i
], chip
))) < 0)
1427 chip
->master_sw_ctl
= snd_ctl_new1(&tumbler_hp_sw
, chip
);
1428 if ((err
= snd_ctl_add(chip
->card
, chip
->master_sw_ctl
)) < 0)
1430 chip
->speaker_sw_ctl
= snd_ctl_new1(&tumbler_speaker_sw
, chip
);
1431 if ((err
= snd_ctl_add(chip
->card
, chip
->speaker_sw_ctl
)) < 0)
1433 if (mix
->line_mute
.addr
!= 0) {
1434 chip
->lineout_sw_ctl
= snd_ctl_new1(&tumbler_lineout_sw
, chip
);
1435 if ((err
= snd_ctl_add(chip
->card
, chip
->lineout_sw_ctl
)) < 0)
1438 chip
->drc_sw_ctl
= snd_ctl_new1(&tumbler_drc_sw
, chip
);
1439 if ((err
= snd_ctl_add(chip
->card
, chip
->drc_sw_ctl
)) < 0)
1442 /* set initial DRC range to 60% */
1443 if (chip
->model
== PMAC_TUMBLER
)
1444 mix
->drc_range
= (TAS3001_DRC_MAX
* 6) / 10;
1446 mix
->drc_range
= (TAS3004_DRC_MAX
* 6) / 10;
1447 mix
->drc_enable
= 1; /* will be changed later if AUTO_DRC is set */
1448 if (chip
->model
== PMAC_TUMBLER
)
1449 tumbler_set_drc(mix
);
1451 snapper_set_drc(mix
);
1454 chip
->suspend
= tumbler_suspend
;
1455 chip
->resume
= tumbler_resume
;
1458 INIT_WORK(&device_change
, device_change_handler
);
1459 device_change_chip
= chip
;
1461 #ifdef PMAC_SUPPORT_AUTOMUTE
1462 if ((mix
->headphone_irq
>=0 || mix
->lineout_irq
>= 0)
1463 && (err
= snd_pmac_add_automute(chip
)) < 0)
1465 chip
->detect_headphone
= tumbler_detect_headphone
;
1466 chip
->update_automute
= tumbler_update_automute
;
1467 tumbler_update_automute(chip
, 0); /* update the status only */
1469 /* activate headphone status interrupts */
1470 if (mix
->headphone_irq
>= 0) {
1472 if ((err
= request_irq(mix
->headphone_irq
, headphone_intr
, 0,
1473 "Sound Headphone Detection", chip
)) < 0)
1475 /* activate headphone status interrupts */
1476 val
= do_gpio_read(&mix
->hp_detect
);
1477 do_gpio_write(&mix
->hp_detect
, val
| 0x80);
1479 if (mix
->lineout_irq
>= 0) {
1481 if ((err
= request_irq(mix
->lineout_irq
, headphone_intr
, 0,
1482 "Sound Lineout Detection", chip
)) < 0)
1484 /* activate headphone status interrupts */
1485 val
= do_gpio_read(&mix
->line_detect
);
1486 do_gpio_write(&mix
->line_detect
, val
| 0x80);