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 <sound/driver.h>
28 #include <linux/init.h>
29 #include <linux/delay.h>
30 #include <linux/i2c.h>
31 #include <linux/i2c-dev.h>
32 #include <linux/kmod.h>
33 #include <linux/slab.h>
34 #include <linux/interrupt.h>
35 #include <sound/core.h>
38 #include <asm/machdep.h>
39 #include <asm/pmac_feature.h>
41 #include "tumbler_volume.h"
46 #define DBG(fmt...) printk(fmt)
51 /* i2c address for tumbler */
52 #define TAS_I2C_ADDR 0x34
55 #define TAS_REG_MCS 0x01 /* main control */
56 #define TAS_REG_DRC 0x02
57 #define TAS_REG_VOL 0x04
58 #define TAS_REG_TREBLE 0x05
59 #define TAS_REG_BASS 0x06
60 #define TAS_REG_INPUT1 0x07
61 #define TAS_REG_INPUT2 0x08
64 #define TAS_REG_PCM TAS_REG_INPUT1
67 #define TAS_REG_LMIX TAS_REG_INPUT1
68 #define TAS_REG_RMIX TAS_REG_INPUT2
69 #define TAS_REG_MCS2 0x43 /* main control 2 */
70 #define TAS_REG_ACS 0x40 /* analog control */
72 /* mono volumes for tas3001c/tas3004 */
74 VOL_IDX_PCM_MONO
, /* tas3001c only */
75 VOL_IDX_BASS
, VOL_IDX_TREBLE
,
79 /* stereo volumes for tas3004 */
81 VOL_IDX_PCM
, VOL_IDX_PCM2
, VOL_IDX_ADC
,
93 struct pmac_keywest i2c
;
94 struct pmac_gpio audio_reset
;
95 struct pmac_gpio amp_mute
;
96 struct pmac_gpio line_mute
;
97 struct pmac_gpio line_detect
;
98 struct pmac_gpio hp_mute
;
99 struct pmac_gpio hp_detect
;
102 unsigned int save_master_vol
[2];
103 unsigned int master_vol
[2];
104 unsigned int save_master_switch
[2];
105 unsigned int master_switch
[2];
106 unsigned int mono_vol
[VOL_IDX_LAST_MONO
];
107 unsigned int mix_vol
[VOL_IDX_LAST_MIX
][2]; /* stereo volumes for tas3004 */
112 int auto_mute_notify
;
121 static int send_init_client(struct pmac_keywest
*i2c
, unsigned int *regs
)
126 err
= i2c_smbus_write_byte_data(i2c
->client
,
130 DBG("(W) i2c error %d\n", err
);
141 static int tumbler_init_client(struct pmac_keywest
*i2c
)
143 static unsigned int regs
[] = {
144 /* normal operation, SCLK=64fps, i2s output, i2s input, 16bit width */
145 TAS_REG_MCS
, (1<<6)|(2<<4)|(2<<2)|0,
148 DBG("(I) tumbler init client\n");
149 return send_init_client(i2c
, regs
);
152 static int snapper_init_client(struct pmac_keywest
*i2c
)
154 static unsigned int regs
[] = {
155 /* normal operation, SCLK=64fps, i2s output, 16bit width */
156 TAS_REG_MCS
, (1<<6)|(2<<4)|0,
157 /* normal operation, all-pass mode */
158 TAS_REG_MCS2
, (1<<1),
159 /* normal output, no deemphasis, A input, power-up, line-in */
163 DBG("(I) snapper init client\n");
164 return send_init_client(i2c
, regs
);
170 #define do_gpio_write(gp, val) \
171 pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, (gp)->addr, val)
172 #define do_gpio_read(gp) \
173 pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, (gp)->addr, 0)
174 #define tumbler_gpio_free(gp) /* NOP */
176 static void write_audio_gpio(struct pmac_gpio
*gp
, int active
)
180 active
= active
? gp
->active_val
: gp
->inactive_val
;
181 do_gpio_write(gp
, active
);
182 DBG("(I) gpio %x write %d\n", gp
->addr
, active
);
185 static int check_audio_gpio(struct pmac_gpio
*gp
)
192 ret
= do_gpio_read(gp
);
194 return (ret
& 0xd) == (gp
->active_val
& 0xd);
197 static int read_audio_gpio(struct pmac_gpio
*gp
)
202 ret
= ((do_gpio_read(gp
) & 0x02) !=0);
203 return ret
== gp
->active_state
;
207 * update master volume
209 static int tumbler_set_master_volume(struct pmac_tumbler
*mix
)
211 unsigned char block
[6];
212 unsigned int left_vol
, right_vol
;
214 if (! mix
->i2c
.client
)
217 if (! mix
->master_switch
[0])
220 left_vol
= mix
->master_vol
[0];
221 if (left_vol
>= ARRAY_SIZE(master_volume_table
))
222 left_vol
= ARRAY_SIZE(master_volume_table
) - 1;
223 left_vol
= master_volume_table
[left_vol
];
225 if (! mix
->master_switch
[1])
228 right_vol
= mix
->master_vol
[1];
229 if (right_vol
>= ARRAY_SIZE(master_volume_table
))
230 right_vol
= ARRAY_SIZE(master_volume_table
) - 1;
231 right_vol
= master_volume_table
[right_vol
];
234 block
[0] = (left_vol
>> 16) & 0xff;
235 block
[1] = (left_vol
>> 8) & 0xff;
236 block
[2] = (left_vol
>> 0) & 0xff;
238 block
[3] = (right_vol
>> 16) & 0xff;
239 block
[4] = (right_vol
>> 8) & 0xff;
240 block
[5] = (right_vol
>> 0) & 0xff;
242 if (i2c_smbus_write_i2c_block_data(mix
->i2c
.client
, TAS_REG_VOL
, 6,
244 snd_printk("failed to set volume \n");
252 static int tumbler_info_master_volume(struct snd_kcontrol
*kcontrol
,
253 struct snd_ctl_elem_info
*uinfo
)
255 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
257 uinfo
->value
.integer
.min
= 0;
258 uinfo
->value
.integer
.max
= ARRAY_SIZE(master_volume_table
) - 1;
262 static int tumbler_get_master_volume(struct snd_kcontrol
*kcontrol
,
263 struct snd_ctl_elem_value
*ucontrol
)
265 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
266 struct pmac_tumbler
*mix
= chip
->mixer_data
;
267 snd_assert(mix
, return -ENODEV
);
268 ucontrol
->value
.integer
.value
[0] = mix
->master_vol
[0];
269 ucontrol
->value
.integer
.value
[1] = mix
->master_vol
[1];
273 static int tumbler_put_master_volume(struct snd_kcontrol
*kcontrol
,
274 struct snd_ctl_elem_value
*ucontrol
)
276 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
277 struct pmac_tumbler
*mix
= chip
->mixer_data
;
280 snd_assert(mix
, return -ENODEV
);
281 change
= mix
->master_vol
[0] != ucontrol
->value
.integer
.value
[0] ||
282 mix
->master_vol
[1] != ucontrol
->value
.integer
.value
[1];
284 mix
->master_vol
[0] = ucontrol
->value
.integer
.value
[0];
285 mix
->master_vol
[1] = ucontrol
->value
.integer
.value
[1];
286 tumbler_set_master_volume(mix
);
292 static int tumbler_get_master_switch(struct snd_kcontrol
*kcontrol
,
293 struct snd_ctl_elem_value
*ucontrol
)
295 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
296 struct pmac_tumbler
*mix
= chip
->mixer_data
;
297 snd_assert(mix
, return -ENODEV
);
298 ucontrol
->value
.integer
.value
[0] = mix
->master_switch
[0];
299 ucontrol
->value
.integer
.value
[1] = mix
->master_switch
[1];
303 static int tumbler_put_master_switch(struct snd_kcontrol
*kcontrol
,
304 struct snd_ctl_elem_value
*ucontrol
)
306 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
307 struct pmac_tumbler
*mix
= chip
->mixer_data
;
310 snd_assert(mix
, return -ENODEV
);
311 change
= mix
->master_switch
[0] != ucontrol
->value
.integer
.value
[0] ||
312 mix
->master_switch
[1] != ucontrol
->value
.integer
.value
[1];
314 mix
->master_switch
[0] = !!ucontrol
->value
.integer
.value
[0];
315 mix
->master_switch
[1] = !!ucontrol
->value
.integer
.value
[1];
316 tumbler_set_master_volume(mix
);
323 * TAS3001c dynamic range compression
326 #define TAS3001_DRC_MAX 0x5f
328 static int tumbler_set_drc(struct pmac_tumbler
*mix
)
330 unsigned char val
[2];
332 if (! mix
->i2c
.client
)
335 if (mix
->drc_enable
) {
336 val
[0] = 0xc1; /* enable, 3:1 compression */
337 if (mix
->drc_range
> TAS3001_DRC_MAX
)
339 else if (mix
->drc_range
< 0)
342 val
[1] = mix
->drc_range
+ 0x91;
348 if (i2c_smbus_write_i2c_block_data(mix
->i2c
.client
, TAS_REG_DRC
,
350 snd_printk("failed to set DRC\n");
360 #define TAS3004_DRC_MAX 0xef
362 static int snapper_set_drc(struct pmac_tumbler
*mix
)
364 unsigned char val
[6];
366 if (! mix
->i2c
.client
)
370 val
[0] = 0x50; /* 3:1 above threshold */
372 val
[0] = 0x51; /* disabled */
373 val
[1] = 0x02; /* 1:1 below threshold */
374 if (mix
->drc_range
> 0xef)
376 else if (mix
->drc_range
< 0)
379 val
[2] = mix
->drc_range
;
384 if (i2c_smbus_write_i2c_block_data(mix
->i2c
.client
, TAS_REG_DRC
,
386 snd_printk("failed to set DRC\n");
392 static int tumbler_info_drc_value(struct snd_kcontrol
*kcontrol
,
393 struct snd_ctl_elem_info
*uinfo
)
395 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
396 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
398 uinfo
->value
.integer
.min
= 0;
399 uinfo
->value
.integer
.max
=
400 chip
->model
== PMAC_TUMBLER
? TAS3001_DRC_MAX
: TAS3004_DRC_MAX
;
404 static int tumbler_get_drc_value(struct snd_kcontrol
*kcontrol
,
405 struct snd_ctl_elem_value
*ucontrol
)
407 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
408 struct pmac_tumbler
*mix
;
409 if (! (mix
= chip
->mixer_data
))
411 ucontrol
->value
.integer
.value
[0] = mix
->drc_range
;
415 static int tumbler_put_drc_value(struct snd_kcontrol
*kcontrol
,
416 struct snd_ctl_elem_value
*ucontrol
)
418 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
419 struct pmac_tumbler
*mix
;
422 if (! (mix
= chip
->mixer_data
))
424 change
= mix
->drc_range
!= ucontrol
->value
.integer
.value
[0];
426 mix
->drc_range
= ucontrol
->value
.integer
.value
[0];
427 if (chip
->model
== PMAC_TUMBLER
)
428 tumbler_set_drc(mix
);
430 snapper_set_drc(mix
);
435 static int tumbler_get_drc_switch(struct snd_kcontrol
*kcontrol
,
436 struct snd_ctl_elem_value
*ucontrol
)
438 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
439 struct pmac_tumbler
*mix
;
440 if (! (mix
= chip
->mixer_data
))
442 ucontrol
->value
.integer
.value
[0] = mix
->drc_enable
;
446 static int tumbler_put_drc_switch(struct snd_kcontrol
*kcontrol
,
447 struct snd_ctl_elem_value
*ucontrol
)
449 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
450 struct pmac_tumbler
*mix
;
453 if (! (mix
= chip
->mixer_data
))
455 change
= mix
->drc_enable
!= ucontrol
->value
.integer
.value
[0];
457 mix
->drc_enable
= !!ucontrol
->value
.integer
.value
[0];
458 if (chip
->model
== PMAC_TUMBLER
)
459 tumbler_set_drc(mix
);
461 snapper_set_drc(mix
);
471 struct tumbler_mono_vol
{
479 static int tumbler_set_mono_volume(struct pmac_tumbler
*mix
,
480 struct tumbler_mono_vol
*info
)
482 unsigned char block
[4];
486 if (! mix
->i2c
.client
)
489 vol
= mix
->mono_vol
[info
->index
];
490 if (vol
>= info
->max
)
492 vol
= info
->table
[vol
];
493 for (i
= 0; i
< info
->bytes
; i
++)
494 block
[i
] = (vol
>> ((info
->bytes
- i
- 1) * 8)) & 0xff;
495 if (i2c_smbus_write_i2c_block_data(mix
->i2c
.client
, info
->reg
,
496 info
->bytes
, block
) < 0) {
497 snd_printk("failed to set mono volume %d\n", info
->index
);
503 static int tumbler_info_mono(struct snd_kcontrol
*kcontrol
,
504 struct snd_ctl_elem_info
*uinfo
)
506 struct tumbler_mono_vol
*info
= (struct tumbler_mono_vol
*)kcontrol
->private_value
;
508 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
510 uinfo
->value
.integer
.min
= 0;
511 uinfo
->value
.integer
.max
= info
->max
- 1;
515 static int tumbler_get_mono(struct snd_kcontrol
*kcontrol
,
516 struct snd_ctl_elem_value
*ucontrol
)
518 struct tumbler_mono_vol
*info
= (struct tumbler_mono_vol
*)kcontrol
->private_value
;
519 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
520 struct pmac_tumbler
*mix
;
521 if (! (mix
= chip
->mixer_data
))
523 ucontrol
->value
.integer
.value
[0] = mix
->mono_vol
[info
->index
];
527 static int tumbler_put_mono(struct snd_kcontrol
*kcontrol
,
528 struct snd_ctl_elem_value
*ucontrol
)
530 struct tumbler_mono_vol
*info
= (struct tumbler_mono_vol
*)kcontrol
->private_value
;
531 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
532 struct pmac_tumbler
*mix
;
535 if (! (mix
= chip
->mixer_data
))
537 change
= mix
->mono_vol
[info
->index
] != ucontrol
->value
.integer
.value
[0];
539 mix
->mono_vol
[info
->index
] = ucontrol
->value
.integer
.value
[0];
540 tumbler_set_mono_volume(mix
, info
);
545 /* TAS3001c mono volumes */
546 static struct tumbler_mono_vol tumbler_pcm_vol_info
= {
547 .index
= VOL_IDX_PCM_MONO
,
550 .max
= ARRAY_SIZE(mixer_volume_table
),
551 .table
= mixer_volume_table
,
554 static struct tumbler_mono_vol tumbler_bass_vol_info
= {
555 .index
= VOL_IDX_BASS
,
558 .max
= ARRAY_SIZE(bass_volume_table
),
559 .table
= bass_volume_table
,
562 static struct tumbler_mono_vol tumbler_treble_vol_info
= {
563 .index
= VOL_IDX_TREBLE
,
564 .reg
= TAS_REG_TREBLE
,
566 .max
= ARRAY_SIZE(treble_volume_table
),
567 .table
= treble_volume_table
,
570 /* TAS3004 mono volumes */
571 static struct tumbler_mono_vol snapper_bass_vol_info
= {
572 .index
= VOL_IDX_BASS
,
575 .max
= ARRAY_SIZE(snapper_bass_volume_table
),
576 .table
= snapper_bass_volume_table
,
579 static struct tumbler_mono_vol snapper_treble_vol_info
= {
580 .index
= VOL_IDX_TREBLE
,
581 .reg
= TAS_REG_TREBLE
,
583 .max
= ARRAY_SIZE(snapper_treble_volume_table
),
584 .table
= snapper_treble_volume_table
,
588 #define DEFINE_MONO(xname,type) { \
589 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
591 .info = tumbler_info_mono, \
592 .get = tumbler_get_mono, \
593 .put = tumbler_put_mono, \
594 .private_value = (unsigned long)(&tumbler_##type##_vol_info), \
597 #define DEFINE_SNAPPER_MONO(xname,type) { \
598 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
600 .info = tumbler_info_mono, \
601 .get = tumbler_get_mono, \
602 .put = tumbler_put_mono, \
603 .private_value = (unsigned long)(&snapper_##type##_vol_info), \
608 * snapper mixer volumes
611 static int snapper_set_mix_vol1(struct pmac_tumbler
*mix
, int idx
, int ch
, int reg
)
614 unsigned char block
[9];
616 vol
= mix
->mix_vol
[idx
][ch
];
617 if (vol
>= ARRAY_SIZE(mixer_volume_table
)) {
618 vol
= ARRAY_SIZE(mixer_volume_table
) - 1;
619 mix
->mix_vol
[idx
][ch
] = vol
;
622 for (i
= 0; i
< 3; i
++) {
623 vol
= mix
->mix_vol
[i
][ch
];
624 vol
= mixer_volume_table
[vol
];
625 for (j
= 0; j
< 3; j
++)
626 block
[i
* 3 + j
] = (vol
>> ((2 - j
) * 8)) & 0xff;
628 if (i2c_smbus_write_i2c_block_data(mix
->i2c
.client
, reg
,
630 snd_printk("failed to set mono volume %d\n", reg
);
636 static int snapper_set_mix_vol(struct pmac_tumbler
*mix
, int idx
)
638 if (! mix
->i2c
.client
)
640 if (snapper_set_mix_vol1(mix
, idx
, 0, TAS_REG_LMIX
) < 0 ||
641 snapper_set_mix_vol1(mix
, idx
, 1, TAS_REG_RMIX
) < 0)
646 static int snapper_info_mix(struct snd_kcontrol
*kcontrol
,
647 struct snd_ctl_elem_info
*uinfo
)
649 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
651 uinfo
->value
.integer
.min
= 0;
652 uinfo
->value
.integer
.max
= ARRAY_SIZE(mixer_volume_table
) - 1;
656 static int snapper_get_mix(struct snd_kcontrol
*kcontrol
,
657 struct snd_ctl_elem_value
*ucontrol
)
659 int idx
= (int)kcontrol
->private_value
;
660 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
661 struct pmac_tumbler
*mix
;
662 if (! (mix
= chip
->mixer_data
))
664 ucontrol
->value
.integer
.value
[0] = mix
->mix_vol
[idx
][0];
665 ucontrol
->value
.integer
.value
[1] = mix
->mix_vol
[idx
][1];
669 static int snapper_put_mix(struct snd_kcontrol
*kcontrol
,
670 struct snd_ctl_elem_value
*ucontrol
)
672 int idx
= (int)kcontrol
->private_value
;
673 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
674 struct pmac_tumbler
*mix
;
677 if (! (mix
= chip
->mixer_data
))
679 change
= mix
->mix_vol
[idx
][0] != ucontrol
->value
.integer
.value
[0] ||
680 mix
->mix_vol
[idx
][1] != ucontrol
->value
.integer
.value
[1];
682 mix
->mix_vol
[idx
][0] = ucontrol
->value
.integer
.value
[0];
683 mix
->mix_vol
[idx
][1] = ucontrol
->value
.integer
.value
[1];
684 snapper_set_mix_vol(mix
, idx
);
691 * mute switches. FIXME: Turn that into software mute when both outputs are muted
692 * to avoid codec reset on ibook M7
695 enum { TUMBLER_MUTE_HP
, TUMBLER_MUTE_AMP
, TUMBLER_MUTE_LINE
};
697 static int tumbler_get_mute_switch(struct snd_kcontrol
*kcontrol
,
698 struct snd_ctl_elem_value
*ucontrol
)
700 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
701 struct pmac_tumbler
*mix
;
702 struct pmac_gpio
*gp
;
703 if (! (mix
= chip
->mixer_data
))
705 switch(kcontrol
->private_value
) {
706 case TUMBLER_MUTE_HP
:
707 gp
= &mix
->hp_mute
; break;
708 case TUMBLER_MUTE_AMP
:
709 gp
= &mix
->amp_mute
; break;
710 case TUMBLER_MUTE_LINE
:
711 gp
= &mix
->line_mute
; break;
717 ucontrol
->value
.integer
.value
[0] = !check_audio_gpio(gp
);
721 static int tumbler_put_mute_switch(struct snd_kcontrol
*kcontrol
,
722 struct snd_ctl_elem_value
*ucontrol
)
724 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
725 struct pmac_tumbler
*mix
;
726 struct pmac_gpio
*gp
;
728 #ifdef PMAC_SUPPORT_AUTOMUTE
729 if (chip
->update_automute
&& chip
->auto_mute
)
730 return 0; /* don't touch in the auto-mute mode */
732 if (! (mix
= chip
->mixer_data
))
734 switch(kcontrol
->private_value
) {
735 case TUMBLER_MUTE_HP
:
736 gp
= &mix
->hp_mute
; break;
737 case TUMBLER_MUTE_AMP
:
738 gp
= &mix
->amp_mute
; break;
739 case TUMBLER_MUTE_LINE
:
740 gp
= &mix
->line_mute
; break;
746 val
= ! check_audio_gpio(gp
);
747 if (val
!= ucontrol
->value
.integer
.value
[0]) {
748 write_audio_gpio(gp
, ! ucontrol
->value
.integer
.value
[0]);
754 static int snapper_set_capture_source(struct pmac_tumbler
*mix
)
756 if (! mix
->i2c
.client
)
758 if (mix
->capture_source
)
759 mix
->acs
= mix
->acs
|= 2;
762 return i2c_smbus_write_byte_data(mix
->i2c
.client
, TAS_REG_ACS
, mix
->acs
);
765 static int snapper_info_capture_source(struct snd_kcontrol
*kcontrol
,
766 struct snd_ctl_elem_info
*uinfo
)
768 static char *texts
[2] = {
771 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
773 uinfo
->value
.enumerated
.items
= 2;
774 if (uinfo
->value
.enumerated
.item
> 1)
775 uinfo
->value
.enumerated
.item
= 1;
776 strcpy(uinfo
->value
.enumerated
.name
, texts
[uinfo
->value
.enumerated
.item
]);
780 static int snapper_get_capture_source(struct snd_kcontrol
*kcontrol
,
781 struct snd_ctl_elem_value
*ucontrol
)
783 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
784 struct pmac_tumbler
*mix
= chip
->mixer_data
;
786 snd_assert(mix
, return -ENODEV
);
787 ucontrol
->value
.integer
.value
[0] = mix
->capture_source
;
791 static int snapper_put_capture_source(struct snd_kcontrol
*kcontrol
,
792 struct snd_ctl_elem_value
*ucontrol
)
794 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
795 struct pmac_tumbler
*mix
= chip
->mixer_data
;
798 snd_assert(mix
, return -ENODEV
);
799 change
= ucontrol
->value
.integer
.value
[0] != mix
->capture_source
;
801 mix
->capture_source
= !!ucontrol
->value
.integer
.value
[0];
802 snapper_set_capture_source(mix
);
807 #define DEFINE_SNAPPER_MIX(xname,idx,ofs) { \
808 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
810 .info = snapper_info_mix, \
811 .get = snapper_get_mix, \
812 .put = snapper_put_mix, \
814 .private_value = ofs, \
820 static struct snd_kcontrol_new tumbler_mixers
[] __initdata
= {
821 { .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
822 .name
= "Master Playback Volume",
823 .info
= tumbler_info_master_volume
,
824 .get
= tumbler_get_master_volume
,
825 .put
= tumbler_put_master_volume
827 { .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
828 .name
= "Master Playback Switch",
829 .info
= snd_pmac_boolean_stereo_info
,
830 .get
= tumbler_get_master_switch
,
831 .put
= tumbler_put_master_switch
833 DEFINE_MONO("Tone Control - Bass", bass
),
834 DEFINE_MONO("Tone Control - Treble", treble
),
835 DEFINE_MONO("PCM Playback Volume", pcm
),
836 { .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
838 .info
= tumbler_info_drc_value
,
839 .get
= tumbler_get_drc_value
,
840 .put
= tumbler_put_drc_value
844 static struct snd_kcontrol_new snapper_mixers
[] __initdata
= {
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
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
857 DEFINE_SNAPPER_MIX("PCM Playback Volume", 0, VOL_IDX_PCM
),
858 DEFINE_SNAPPER_MIX("PCM Playback Volume", 1, VOL_IDX_PCM2
),
859 DEFINE_SNAPPER_MIX("Monitor Mix Volume", 0, VOL_IDX_ADC
),
860 DEFINE_SNAPPER_MONO("Tone Control - Bass", bass
),
861 DEFINE_SNAPPER_MONO("Tone Control - Treble", treble
),
862 { .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
864 .info
= tumbler_info_drc_value
,
865 .get
= tumbler_get_drc_value
,
866 .put
= tumbler_put_drc_value
868 { .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
869 .name
= "Input Source", /* FIXME: "Capture Source" doesn't work properly */
870 .info
= snapper_info_capture_source
,
871 .get
= snapper_get_capture_source
,
872 .put
= snapper_put_capture_source
876 static struct snd_kcontrol_new tumbler_hp_sw __initdata
= {
877 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
878 .name
= "Headphone Playback Switch",
879 .info
= snd_pmac_boolean_mono_info
,
880 .get
= tumbler_get_mute_switch
,
881 .put
= tumbler_put_mute_switch
,
882 .private_value
= TUMBLER_MUTE_HP
,
884 static struct snd_kcontrol_new tumbler_speaker_sw __initdata
= {
885 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
886 .name
= "PC Speaker Playback Switch",
887 .info
= snd_pmac_boolean_mono_info
,
888 .get
= tumbler_get_mute_switch
,
889 .put
= tumbler_put_mute_switch
,
890 .private_value
= TUMBLER_MUTE_AMP
,
892 static struct snd_kcontrol_new tumbler_lineout_sw __initdata
= {
893 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
894 .name
= "Line Out Playback Switch",
895 .info
= snd_pmac_boolean_mono_info
,
896 .get
= tumbler_get_mute_switch
,
897 .put
= tumbler_put_mute_switch
,
898 .private_value
= TUMBLER_MUTE_LINE
,
900 static struct snd_kcontrol_new tumbler_drc_sw __initdata
= {
901 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
902 .name
= "DRC Switch",
903 .info
= snd_pmac_boolean_mono_info
,
904 .get
= tumbler_get_drc_switch
,
905 .put
= tumbler_put_drc_switch
909 #ifdef PMAC_SUPPORT_AUTOMUTE
913 static int tumbler_detect_headphone(struct snd_pmac
*chip
)
915 struct pmac_tumbler
*mix
= chip
->mixer_data
;
918 if (mix
->hp_detect
.addr
)
919 detect
|= read_audio_gpio(&mix
->hp_detect
);
923 static int tumbler_detect_lineout(struct snd_pmac
*chip
)
925 struct pmac_tumbler
*mix
= chip
->mixer_data
;
928 if (mix
->line_detect
.addr
)
929 detect
|= read_audio_gpio(&mix
->line_detect
);
933 static void check_mute(struct snd_pmac
*chip
, struct pmac_gpio
*gp
, int val
, int do_notify
,
934 struct snd_kcontrol
*sw
)
936 if (check_audio_gpio(gp
) != val
) {
937 write_audio_gpio(gp
, val
);
939 snd_ctl_notify(chip
->card
, SNDRV_CTL_EVENT_MASK_VALUE
,
944 static struct work_struct device_change
;
946 static void device_change_handler(void *self
)
948 struct snd_pmac
*chip
= self
;
949 struct pmac_tumbler
*mix
;
950 int headphone
, lineout
;
955 mix
= chip
->mixer_data
;
956 snd_assert(mix
, return);
958 headphone
= tumbler_detect_headphone(chip
);
959 lineout
= tumbler_detect_lineout(chip
);
961 DBG("headphone: %d, lineout: %d\n", headphone
, lineout
);
963 if (headphone
|| lineout
) {
964 /* unmute headphone/lineout & mute speaker */
966 check_mute(chip
, &mix
->hp_mute
, 0, mix
->auto_mute_notify
,
967 chip
->master_sw_ctl
);
968 if (lineout
&& mix
->line_mute
.addr
!= 0)
969 check_mute(chip
, &mix
->line_mute
, 0, mix
->auto_mute_notify
,
970 chip
->lineout_sw_ctl
);
971 if (mix
->anded_reset
)
973 check_mute(chip
, &mix
->amp_mute
, 1, mix
->auto_mute_notify
,
974 chip
->speaker_sw_ctl
);
976 /* unmute speaker, mute others */
977 check_mute(chip
, &mix
->amp_mute
, 0, mix
->auto_mute_notify
,
978 chip
->speaker_sw_ctl
);
979 if (mix
->anded_reset
)
981 check_mute(chip
, &mix
->hp_mute
, 1, mix
->auto_mute_notify
,
982 chip
->master_sw_ctl
);
983 if (mix
->line_mute
.addr
!= 0)
984 check_mute(chip
, &mix
->line_mute
, 1, mix
->auto_mute_notify
,
985 chip
->lineout_sw_ctl
);
987 if (mix
->auto_mute_notify
)
988 snd_ctl_notify(chip
->card
, SNDRV_CTL_EVENT_MASK_VALUE
,
989 &chip
->hp_detect_ctl
->id
);
991 #ifdef CONFIG_SND_POWERMAC_AUTO_DRC
992 mix
->drc_enable
= ! (headphone
|| lineout
);
993 if (mix
->auto_mute_notify
)
994 snd_ctl_notify(chip
->card
, SNDRV_CTL_EVENT_MASK_VALUE
,
995 &chip
->drc_sw_ctl
->id
);
996 if (chip
->model
== PMAC_TUMBLER
)
997 tumbler_set_drc(mix
);
999 snapper_set_drc(mix
);
1002 /* reset the master volume so the correct amplification is applied */
1003 tumbler_set_master_volume(mix
);
1006 static void tumbler_update_automute(struct snd_pmac
*chip
, int do_notify
)
1008 if (chip
->auto_mute
) {
1009 struct pmac_tumbler
*mix
;
1010 mix
= chip
->mixer_data
;
1011 snd_assert(mix
, return);
1012 mix
->auto_mute_notify
= do_notify
;
1013 schedule_work(&device_change
);
1016 #endif /* PMAC_SUPPORT_AUTOMUTE */
1019 /* interrupt - headphone plug changed */
1020 static irqreturn_t
headphone_intr(int irq
, void *devid
, struct pt_regs
*regs
)
1022 struct snd_pmac
*chip
= devid
;
1023 if (chip
->update_automute
&& chip
->initialized
) {
1024 chip
->update_automute(chip
, 1);
1030 /* look for audio-gpio device */
1031 static struct device_node
*find_audio_device(const char *name
)
1033 struct device_node
*np
;
1035 if (! (np
= find_devices("gpio")))
1038 for (np
= np
->child
; np
; np
= np
->sibling
) {
1039 char *property
= get_property(np
, "audio-gpio", NULL
);
1040 if (property
&& strcmp(property
, name
) == 0)
1046 /* look for audio-gpio device */
1047 static struct device_node
*find_compatible_audio_device(const char *name
)
1049 struct device_node
*np
;
1051 if (! (np
= find_devices("gpio")))
1054 for (np
= np
->child
; np
; np
= np
->sibling
) {
1055 if (device_is_compatible(np
, name
))
1061 /* find an audio device and get its address */
1062 static long tumbler_find_device(const char *device
, const char *platform
,
1063 struct pmac_gpio
*gp
, int is_compatible
)
1065 struct device_node
*node
;
1069 node
= find_compatible_audio_device(device
);
1071 node
= find_audio_device(device
);
1073 DBG("(W) cannot find audio device %s !\n", device
);
1074 snd_printdd("cannot find device %s\n", device
);
1078 base
= (u32
*)get_property(node
, "AAPL,address", NULL
);
1080 base
= (u32
*)get_property(node
, "reg", NULL
);
1082 DBG("(E) cannot find address for device %s !\n", device
);
1083 snd_printd("cannot find address for device %s\n", device
);
1092 gp
->addr
= addr
& 0x0000ffff;
1093 /* Try to find the active state, default to 0 ! */
1094 base
= (u32
*)get_property(node
, "audio-gpio-active-state", NULL
);
1096 gp
->active_state
= *base
;
1097 gp
->active_val
= (*base
) ? 0x5 : 0x4;
1098 gp
->inactive_val
= (*base
) ? 0x4 : 0x5;
1101 gp
->active_state
= 0;
1102 gp
->active_val
= 0x4;
1103 gp
->inactive_val
= 0x5;
1104 /* Here are some crude hacks to extract the GPIO polarity and
1105 * open collector informations out of the do-platform script
1106 * as we don't yet have an interpreter for these things
1109 prop
= (u32
*)get_property(node
, platform
, NULL
);
1111 if (prop
[3] == 0x9 && prop
[4] == 0x9) {
1112 gp
->active_val
= 0xd;
1113 gp
->inactive_val
= 0xc;
1115 if (prop
[3] == 0x1 && prop
[4] == 0x1) {
1116 gp
->active_val
= 0x5;
1117 gp
->inactive_val
= 0x4;
1122 DBG("(I) GPIO device %s found, offset: %x, active state: %d !\n",
1123 device
, gp
->addr
, gp
->active_state
);
1125 return (node
->n_intrs
> 0) ? node
->intrs
[0].line
: 0;
1129 static void tumbler_reset_audio(struct snd_pmac
*chip
)
1131 struct pmac_tumbler
*mix
= chip
->mixer_data
;
1133 if (mix
->anded_reset
) {
1134 DBG("(I) codec anded reset !\n");
1135 write_audio_gpio(&mix
->hp_mute
, 0);
1136 write_audio_gpio(&mix
->amp_mute
, 0);
1138 write_audio_gpio(&mix
->hp_mute
, 1);
1139 write_audio_gpio(&mix
->amp_mute
, 1);
1141 write_audio_gpio(&mix
->hp_mute
, 0);
1142 write_audio_gpio(&mix
->amp_mute
, 0);
1145 DBG("(I) codec normal reset !\n");
1147 write_audio_gpio(&mix
->audio_reset
, 0);
1149 write_audio_gpio(&mix
->audio_reset
, 1);
1151 write_audio_gpio(&mix
->audio_reset
, 0);
1158 static void tumbler_suspend(struct snd_pmac
*chip
)
1160 struct pmac_tumbler
*mix
= chip
->mixer_data
;
1162 if (mix
->headphone_irq
>= 0)
1163 disable_irq(mix
->headphone_irq
);
1164 if (mix
->lineout_irq
>= 0)
1165 disable_irq(mix
->lineout_irq
);
1166 mix
->save_master_switch
[0] = mix
->master_switch
[0];
1167 mix
->save_master_switch
[1] = mix
->master_switch
[1];
1168 mix
->save_master_vol
[0] = mix
->master_vol
[0];
1169 mix
->save_master_vol
[1] = mix
->master_vol
[1];
1170 mix
->master_switch
[0] = mix
->master_switch
[1] = 0;
1171 tumbler_set_master_volume(mix
);
1172 if (!mix
->anded_reset
) {
1173 write_audio_gpio(&mix
->amp_mute
, 1);
1174 write_audio_gpio(&mix
->hp_mute
, 1);
1176 if (chip
->model
== PMAC_SNAPPER
) {
1178 i2c_smbus_write_byte_data(mix
->i2c
.client
, TAS_REG_ACS
, mix
->acs
);
1180 if (mix
->anded_reset
) {
1181 write_audio_gpio(&mix
->amp_mute
, 1);
1182 write_audio_gpio(&mix
->hp_mute
, 1);
1184 write_audio_gpio(&mix
->audio_reset
, 1);
1188 static void tumbler_resume(struct snd_pmac
*chip
)
1190 struct pmac_tumbler
*mix
= chip
->mixer_data
;
1192 snd_assert(mix
, return);
1195 mix
->master_switch
[0] = mix
->save_master_switch
[0];
1196 mix
->master_switch
[1] = mix
->save_master_switch
[1];
1197 mix
->master_vol
[0] = mix
->save_master_vol
[0];
1198 mix
->master_vol
[1] = mix
->save_master_vol
[1];
1199 tumbler_reset_audio(chip
);
1200 if (mix
->i2c
.client
&& mix
->i2c
.init_client
) {
1201 if (mix
->i2c
.init_client(&mix
->i2c
) < 0)
1202 printk(KERN_ERR
"tumbler_init_client error\n");
1204 printk(KERN_ERR
"tumbler: i2c is not initialized\n");
1205 if (chip
->model
== PMAC_TUMBLER
) {
1206 tumbler_set_mono_volume(mix
, &tumbler_pcm_vol_info
);
1207 tumbler_set_mono_volume(mix
, &tumbler_bass_vol_info
);
1208 tumbler_set_mono_volume(mix
, &tumbler_treble_vol_info
);
1209 tumbler_set_drc(mix
);
1211 snapper_set_mix_vol(mix
, VOL_IDX_PCM
);
1212 snapper_set_mix_vol(mix
, VOL_IDX_PCM2
);
1213 snapper_set_mix_vol(mix
, VOL_IDX_ADC
);
1214 tumbler_set_mono_volume(mix
, &snapper_bass_vol_info
);
1215 tumbler_set_mono_volume(mix
, &snapper_treble_vol_info
);
1216 snapper_set_drc(mix
);
1217 snapper_set_capture_source(mix
);
1219 tumbler_set_master_volume(mix
);
1220 if (chip
->update_automute
)
1221 chip
->update_automute(chip
, 0);
1222 if (mix
->headphone_irq
>= 0) {
1225 enable_irq(mix
->headphone_irq
);
1226 /* activate headphone status interrupts */
1227 val
= do_gpio_read(&mix
->hp_detect
);
1228 do_gpio_write(&mix
->hp_detect
, val
| 0x80);
1230 if (mix
->lineout_irq
>= 0)
1231 enable_irq(mix
->lineout_irq
);
1235 /* initialize tumbler */
1236 static int __init
tumbler_init(struct snd_pmac
*chip
)
1239 struct pmac_tumbler
*mix
= chip
->mixer_data
;
1240 snd_assert(mix
, return -EINVAL
);
1242 if (tumbler_find_device("audio-hw-reset",
1243 "platform-do-hw-reset",
1244 &mix
->audio_reset
, 0) < 0)
1245 tumbler_find_device("hw-reset",
1246 "platform-do-hw-reset",
1247 &mix
->audio_reset
, 1);
1248 if (tumbler_find_device("amp-mute",
1249 "platform-do-amp-mute",
1250 &mix
->amp_mute
, 0) < 0)
1251 tumbler_find_device("amp-mute",
1252 "platform-do-amp-mute",
1254 if (tumbler_find_device("headphone-mute",
1255 "platform-do-headphone-mute",
1256 &mix
->hp_mute
, 0) < 0)
1257 tumbler_find_device("headphone-mute",
1258 "platform-do-headphone-mute",
1260 if (tumbler_find_device("line-output-mute",
1261 "platform-do-lineout-mute",
1262 &mix
->line_mute
, 0) < 0)
1263 tumbler_find_device("line-output-mute",
1264 "platform-do-lineout-mute",
1265 &mix
->line_mute
, 1);
1266 irq
= tumbler_find_device("headphone-detect",
1267 NULL
, &mix
->hp_detect
, 0);
1269 irq
= tumbler_find_device("headphone-detect",
1270 NULL
, &mix
->hp_detect
, 1);
1272 irq
= tumbler_find_device("keywest-gpio15",
1273 NULL
, &mix
->hp_detect
, 1);
1274 mix
->headphone_irq
= irq
;
1275 irq
= tumbler_find_device("line-output-detect",
1276 NULL
, &mix
->line_detect
, 0);
1278 irq
= tumbler_find_device("line-output-detect",
1279 NULL
, &mix
->line_detect
, 1);
1280 mix
->lineout_irq
= irq
;
1282 tumbler_reset_audio(chip
);
1287 static void tumbler_cleanup(struct snd_pmac
*chip
)
1289 struct pmac_tumbler
*mix
= chip
->mixer_data
;
1293 if (mix
->headphone_irq
>= 0)
1294 free_irq(mix
->headphone_irq
, chip
);
1295 if (mix
->lineout_irq
>= 0)
1296 free_irq(mix
->lineout_irq
, chip
);
1297 tumbler_gpio_free(&mix
->audio_reset
);
1298 tumbler_gpio_free(&mix
->amp_mute
);
1299 tumbler_gpio_free(&mix
->hp_mute
);
1300 tumbler_gpio_free(&mix
->hp_detect
);
1301 snd_pmac_keywest_cleanup(&mix
->i2c
);
1303 chip
->mixer_data
= NULL
;
1307 int __init
snd_pmac_tumbler_init(struct snd_pmac
*chip
)
1310 struct pmac_tumbler
*mix
;
1312 struct device_node
*tas_node
, *np
;
1316 if (current
->fs
->root
)
1317 request_module("i2c-keywest");
1318 #endif /* CONFIG_KMOD */
1320 mix
= kmalloc(sizeof(*mix
), GFP_KERNEL
);
1323 memset(mix
, 0, sizeof(*mix
));
1324 mix
->headphone_irq
= -1;
1326 chip
->mixer_data
= mix
;
1327 chip
->mixer_free
= tumbler_cleanup
;
1328 mix
->anded_reset
= 0;
1329 mix
->reset_on_sleep
= 1;
1331 for (np
= chip
->node
->child
; np
; np
= np
->sibling
) {
1332 if (!strcmp(np
->name
, "sound")) {
1333 if (get_property(np
, "has-anded-reset", NULL
))
1334 mix
->anded_reset
= 1;
1335 if (get_property(np
, "layout-id", NULL
))
1336 mix
->reset_on_sleep
= 0;
1340 if ((err
= tumbler_init(chip
)) < 0)
1344 tas_node
= find_devices("deq");
1345 if (tas_node
== NULL
)
1346 tas_node
= find_devices("codec");
1347 if (tas_node
== NULL
)
1350 paddr
= (u32
*)get_property(tas_node
, "i2c-address", NULL
);
1352 paddr
= (u32
*)get_property(tas_node
, "reg", NULL
);
1354 mix
->i2c
.addr
= (*paddr
) >> 1;
1356 mix
->i2c
.addr
= TAS_I2C_ADDR
;
1358 DBG("(I) TAS i2c address is: %x\n", mix
->i2c
.addr
);
1360 if (chip
->model
== PMAC_TUMBLER
) {
1361 mix
->i2c
.init_client
= tumbler_init_client
;
1362 mix
->i2c
.name
= "TAS3001c";
1363 chipname
= "Tumbler";
1365 mix
->i2c
.init_client
= snapper_init_client
;
1366 mix
->i2c
.name
= "TAS3004";
1367 chipname
= "Snapper";
1370 if ((err
= snd_pmac_keywest_init(&mix
->i2c
)) < 0)
1376 sprintf(chip
->card
->mixername
, "PowerMac %s", chipname
);
1378 if (chip
->model
== PMAC_TUMBLER
) {
1379 for (i
= 0; i
< ARRAY_SIZE(tumbler_mixers
); i
++) {
1380 if ((err
= snd_ctl_add(chip
->card
, snd_ctl_new1(&tumbler_mixers
[i
], chip
))) < 0)
1384 for (i
= 0; i
< ARRAY_SIZE(snapper_mixers
); i
++) {
1385 if ((err
= snd_ctl_add(chip
->card
, snd_ctl_new1(&snapper_mixers
[i
], chip
))) < 0)
1389 chip
->master_sw_ctl
= snd_ctl_new1(&tumbler_hp_sw
, chip
);
1390 if ((err
= snd_ctl_add(chip
->card
, chip
->master_sw_ctl
)) < 0)
1392 chip
->speaker_sw_ctl
= snd_ctl_new1(&tumbler_speaker_sw
, chip
);
1393 if ((err
= snd_ctl_add(chip
->card
, chip
->speaker_sw_ctl
)) < 0)
1395 if (mix
->line_mute
.addr
!= 0) {
1396 chip
->lineout_sw_ctl
= snd_ctl_new1(&tumbler_lineout_sw
, chip
);
1397 if ((err
= snd_ctl_add(chip
->card
, chip
->lineout_sw_ctl
)) < 0)
1400 chip
->drc_sw_ctl
= snd_ctl_new1(&tumbler_drc_sw
, chip
);
1401 if ((err
= snd_ctl_add(chip
->card
, chip
->drc_sw_ctl
)) < 0)
1404 /* set initial DRC range to 60% */
1405 if (chip
->model
== PMAC_TUMBLER
)
1406 mix
->drc_range
= (TAS3001_DRC_MAX
* 6) / 10;
1408 mix
->drc_range
= (TAS3004_DRC_MAX
* 6) / 10;
1409 mix
->drc_enable
= 1; /* will be changed later if AUTO_DRC is set */
1410 if (chip
->model
== PMAC_TUMBLER
)
1411 tumbler_set_drc(mix
);
1413 snapper_set_drc(mix
);
1416 chip
->suspend
= tumbler_suspend
;
1417 chip
->resume
= tumbler_resume
;
1420 INIT_WORK(&device_change
, device_change_handler
, (void *)chip
);
1422 #ifdef PMAC_SUPPORT_AUTOMUTE
1423 if ((mix
->headphone_irq
>=0 || mix
->lineout_irq
>= 0)
1424 && (err
= snd_pmac_add_automute(chip
)) < 0)
1426 chip
->detect_headphone
= tumbler_detect_headphone
;
1427 chip
->update_automute
= tumbler_update_automute
;
1428 tumbler_update_automute(chip
, 0); /* update the status only */
1430 /* activate headphone status interrupts */
1431 if (mix
->headphone_irq
>= 0) {
1433 if ((err
= request_irq(mix
->headphone_irq
, headphone_intr
, 0,
1434 "Sound Headphone Detection", chip
)) < 0)
1436 /* activate headphone status interrupts */
1437 val
= do_gpio_read(&mix
->hp_detect
);
1438 do_gpio_write(&mix
->hp_detect
, val
| 0x80);
1440 if (mix
->lineout_irq
>= 0) {
1442 if ((err
= request_irq(mix
->lineout_irq
, headphone_intr
, 0,
1443 "Sound Lineout Detection", chip
)) < 0)
1445 /* activate headphone status interrupts */
1446 val
= do_gpio_read(&mix
->line_detect
);
1447 do_gpio_write(&mix
->line_detect
, val
| 0x80);