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/kmod.h>
32 #include <linux/slab.h>
33 #include <linux/interrupt.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(fmt)
50 /* i2c address for tumbler */
51 #define TAS_I2C_ADDR 0x34
54 #define TAS_REG_MCS 0x01 /* main control */
55 #define TAS_REG_DRC 0x02
56 #define TAS_REG_VOL 0x04
57 #define TAS_REG_TREBLE 0x05
58 #define TAS_REG_BASS 0x06
59 #define TAS_REG_INPUT1 0x07
60 #define TAS_REG_INPUT2 0x08
63 #define TAS_REG_PCM TAS_REG_INPUT1
66 #define TAS_REG_LMIX TAS_REG_INPUT1
67 #define TAS_REG_RMIX TAS_REG_INPUT2
68 #define TAS_REG_MCS2 0x43 /* main control 2 */
69 #define TAS_REG_ACS 0x40 /* analog control */
71 /* mono volumes for tas3001c/tas3004 */
73 VOL_IDX_PCM_MONO
, /* tas3001c only */
74 VOL_IDX_BASS
, VOL_IDX_TREBLE
,
78 /* stereo volumes for tas3004 */
80 VOL_IDX_PCM
, VOL_IDX_PCM2
, VOL_IDX_ADC
,
92 struct pmac_keywest i2c
;
93 struct pmac_gpio audio_reset
;
94 struct pmac_gpio amp_mute
;
95 struct pmac_gpio line_mute
;
96 struct pmac_gpio line_detect
;
97 struct pmac_gpio hp_mute
;
98 struct pmac_gpio hp_detect
;
101 unsigned int save_master_vol
[2];
102 unsigned int master_vol
[2];
103 unsigned int save_master_switch
[2];
104 unsigned int master_switch
[2];
105 unsigned int mono_vol
[VOL_IDX_LAST_MONO
];
106 unsigned int mix_vol
[VOL_IDX_LAST_MIX
][2]; /* stereo volumes for tas3004 */
111 int auto_mute_notify
;
120 static int send_init_client(struct pmac_keywest
*i2c
, unsigned int *regs
)
125 err
= i2c_smbus_write_byte_data(i2c
->client
,
129 DBG("(W) i2c error %d\n", err
);
140 static int tumbler_init_client(struct pmac_keywest
*i2c
)
142 static unsigned int regs
[] = {
143 /* normal operation, SCLK=64fps, i2s output, i2s input, 16bit width */
144 TAS_REG_MCS
, (1<<6)|(2<<4)|(2<<2)|0,
147 DBG("(I) tumbler init client\n");
148 return send_init_client(i2c
, regs
);
151 static int snapper_init_client(struct pmac_keywest
*i2c
)
153 static unsigned int regs
[] = {
154 /* normal operation, SCLK=64fps, i2s output, 16bit width */
155 TAS_REG_MCS
, (1<<6)|(2<<4)|0,
156 /* normal operation, all-pass mode */
157 TAS_REG_MCS2
, (1<<1),
158 /* normal output, no deemphasis, A input, power-up, line-in */
162 DBG("(I) snapper init client\n");
163 return send_init_client(i2c
, regs
);
169 #define do_gpio_write(gp, val) \
170 pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, (gp)->addr, val)
171 #define do_gpio_read(gp) \
172 pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, (gp)->addr, 0)
173 #define tumbler_gpio_free(gp) /* NOP */
175 static void write_audio_gpio(struct pmac_gpio
*gp
, int active
)
179 active
= active
? gp
->active_val
: gp
->inactive_val
;
180 do_gpio_write(gp
, active
);
181 DBG("(I) gpio %x write %d\n", gp
->addr
, active
);
184 static int check_audio_gpio(struct pmac_gpio
*gp
)
191 ret
= do_gpio_read(gp
);
193 return (ret
& 0xd) == (gp
->active_val
& 0xd);
196 static int read_audio_gpio(struct pmac_gpio
*gp
)
201 ret
= ((do_gpio_read(gp
) & 0x02) !=0);
202 return ret
== gp
->active_state
;
206 * update master volume
208 static int tumbler_set_master_volume(struct pmac_tumbler
*mix
)
210 unsigned char block
[6];
211 unsigned int left_vol
, right_vol
;
213 if (! mix
->i2c
.client
)
216 if (! mix
->master_switch
[0])
219 left_vol
= mix
->master_vol
[0];
220 if (left_vol
>= ARRAY_SIZE(master_volume_table
))
221 left_vol
= ARRAY_SIZE(master_volume_table
) - 1;
222 left_vol
= master_volume_table
[left_vol
];
224 if (! mix
->master_switch
[1])
227 right_vol
= mix
->master_vol
[1];
228 if (right_vol
>= ARRAY_SIZE(master_volume_table
))
229 right_vol
= ARRAY_SIZE(master_volume_table
) - 1;
230 right_vol
= master_volume_table
[right_vol
];
233 block
[0] = (left_vol
>> 16) & 0xff;
234 block
[1] = (left_vol
>> 8) & 0xff;
235 block
[2] = (left_vol
>> 0) & 0xff;
237 block
[3] = (right_vol
>> 16) & 0xff;
238 block
[4] = (right_vol
>> 8) & 0xff;
239 block
[5] = (right_vol
>> 0) & 0xff;
241 if (i2c_smbus_write_i2c_block_data(mix
->i2c
.client
, TAS_REG_VOL
, 6,
243 snd_printk("failed to set volume \n");
251 static int tumbler_info_master_volume(struct snd_kcontrol
*kcontrol
,
252 struct snd_ctl_elem_info
*uinfo
)
254 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
256 uinfo
->value
.integer
.min
= 0;
257 uinfo
->value
.integer
.max
= ARRAY_SIZE(master_volume_table
) - 1;
261 static int tumbler_get_master_volume(struct snd_kcontrol
*kcontrol
,
262 struct snd_ctl_elem_value
*ucontrol
)
264 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
265 struct pmac_tumbler
*mix
= chip
->mixer_data
;
266 snd_assert(mix
, return -ENODEV
);
267 ucontrol
->value
.integer
.value
[0] = mix
->master_vol
[0];
268 ucontrol
->value
.integer
.value
[1] = mix
->master_vol
[1];
272 static int tumbler_put_master_volume(struct snd_kcontrol
*kcontrol
,
273 struct snd_ctl_elem_value
*ucontrol
)
275 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
276 struct pmac_tumbler
*mix
= chip
->mixer_data
;
279 snd_assert(mix
, return -ENODEV
);
280 change
= mix
->master_vol
[0] != ucontrol
->value
.integer
.value
[0] ||
281 mix
->master_vol
[1] != ucontrol
->value
.integer
.value
[1];
283 mix
->master_vol
[0] = ucontrol
->value
.integer
.value
[0];
284 mix
->master_vol
[1] = ucontrol
->value
.integer
.value
[1];
285 tumbler_set_master_volume(mix
);
291 static int tumbler_get_master_switch(struct snd_kcontrol
*kcontrol
,
292 struct snd_ctl_elem_value
*ucontrol
)
294 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
295 struct pmac_tumbler
*mix
= chip
->mixer_data
;
296 snd_assert(mix
, return -ENODEV
);
297 ucontrol
->value
.integer
.value
[0] = mix
->master_switch
[0];
298 ucontrol
->value
.integer
.value
[1] = mix
->master_switch
[1];
302 static int tumbler_put_master_switch(struct snd_kcontrol
*kcontrol
,
303 struct snd_ctl_elem_value
*ucontrol
)
305 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
306 struct pmac_tumbler
*mix
= chip
->mixer_data
;
309 snd_assert(mix
, return -ENODEV
);
310 change
= mix
->master_switch
[0] != ucontrol
->value
.integer
.value
[0] ||
311 mix
->master_switch
[1] != ucontrol
->value
.integer
.value
[1];
313 mix
->master_switch
[0] = !!ucontrol
->value
.integer
.value
[0];
314 mix
->master_switch
[1] = !!ucontrol
->value
.integer
.value
[1];
315 tumbler_set_master_volume(mix
);
322 * TAS3001c dynamic range compression
325 #define TAS3001_DRC_MAX 0x5f
327 static int tumbler_set_drc(struct pmac_tumbler
*mix
)
329 unsigned char val
[2];
331 if (! mix
->i2c
.client
)
334 if (mix
->drc_enable
) {
335 val
[0] = 0xc1; /* enable, 3:1 compression */
336 if (mix
->drc_range
> TAS3001_DRC_MAX
)
338 else if (mix
->drc_range
< 0)
341 val
[1] = mix
->drc_range
+ 0x91;
347 if (i2c_smbus_write_i2c_block_data(mix
->i2c
.client
, TAS_REG_DRC
,
349 snd_printk("failed to set DRC\n");
359 #define TAS3004_DRC_MAX 0xef
361 static int snapper_set_drc(struct pmac_tumbler
*mix
)
363 unsigned char val
[6];
365 if (! mix
->i2c
.client
)
369 val
[0] = 0x50; /* 3:1 above threshold */
371 val
[0] = 0x51; /* disabled */
372 val
[1] = 0x02; /* 1:1 below threshold */
373 if (mix
->drc_range
> 0xef)
375 else if (mix
->drc_range
< 0)
378 val
[2] = mix
->drc_range
;
383 if (i2c_smbus_write_i2c_block_data(mix
->i2c
.client
, TAS_REG_DRC
,
385 snd_printk("failed to set DRC\n");
391 static int tumbler_info_drc_value(struct snd_kcontrol
*kcontrol
,
392 struct snd_ctl_elem_info
*uinfo
)
394 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
395 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
397 uinfo
->value
.integer
.min
= 0;
398 uinfo
->value
.integer
.max
=
399 chip
->model
== PMAC_TUMBLER
? TAS3001_DRC_MAX
: TAS3004_DRC_MAX
;
403 static int tumbler_get_drc_value(struct snd_kcontrol
*kcontrol
,
404 struct snd_ctl_elem_value
*ucontrol
)
406 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
407 struct pmac_tumbler
*mix
;
408 if (! (mix
= chip
->mixer_data
))
410 ucontrol
->value
.integer
.value
[0] = mix
->drc_range
;
414 static int tumbler_put_drc_value(struct snd_kcontrol
*kcontrol
,
415 struct snd_ctl_elem_value
*ucontrol
)
417 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
418 struct pmac_tumbler
*mix
;
421 if (! (mix
= chip
->mixer_data
))
423 change
= mix
->drc_range
!= ucontrol
->value
.integer
.value
[0];
425 mix
->drc_range
= ucontrol
->value
.integer
.value
[0];
426 if (chip
->model
== PMAC_TUMBLER
)
427 tumbler_set_drc(mix
);
429 snapper_set_drc(mix
);
434 static int tumbler_get_drc_switch(struct snd_kcontrol
*kcontrol
,
435 struct snd_ctl_elem_value
*ucontrol
)
437 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
438 struct pmac_tumbler
*mix
;
439 if (! (mix
= chip
->mixer_data
))
441 ucontrol
->value
.integer
.value
[0] = mix
->drc_enable
;
445 static int tumbler_put_drc_switch(struct snd_kcontrol
*kcontrol
,
446 struct snd_ctl_elem_value
*ucontrol
)
448 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
449 struct pmac_tumbler
*mix
;
452 if (! (mix
= chip
->mixer_data
))
454 change
= mix
->drc_enable
!= ucontrol
->value
.integer
.value
[0];
456 mix
->drc_enable
= !!ucontrol
->value
.integer
.value
[0];
457 if (chip
->model
== PMAC_TUMBLER
)
458 tumbler_set_drc(mix
);
460 snapper_set_drc(mix
);
470 struct tumbler_mono_vol
{
478 static int tumbler_set_mono_volume(struct pmac_tumbler
*mix
,
479 struct tumbler_mono_vol
*info
)
481 unsigned char block
[4];
485 if (! mix
->i2c
.client
)
488 vol
= mix
->mono_vol
[info
->index
];
489 if (vol
>= info
->max
)
491 vol
= info
->table
[vol
];
492 for (i
= 0; i
< info
->bytes
; i
++)
493 block
[i
] = (vol
>> ((info
->bytes
- i
- 1) * 8)) & 0xff;
494 if (i2c_smbus_write_i2c_block_data(mix
->i2c
.client
, info
->reg
,
495 info
->bytes
, block
) < 0) {
496 snd_printk("failed to set mono volume %d\n", info
->index
);
502 static int tumbler_info_mono(struct snd_kcontrol
*kcontrol
,
503 struct snd_ctl_elem_info
*uinfo
)
505 struct tumbler_mono_vol
*info
= (struct tumbler_mono_vol
*)kcontrol
->private_value
;
507 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
509 uinfo
->value
.integer
.min
= 0;
510 uinfo
->value
.integer
.max
= info
->max
- 1;
514 static int tumbler_get_mono(struct snd_kcontrol
*kcontrol
,
515 struct snd_ctl_elem_value
*ucontrol
)
517 struct tumbler_mono_vol
*info
= (struct tumbler_mono_vol
*)kcontrol
->private_value
;
518 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
519 struct pmac_tumbler
*mix
;
520 if (! (mix
= chip
->mixer_data
))
522 ucontrol
->value
.integer
.value
[0] = mix
->mono_vol
[info
->index
];
526 static int tumbler_put_mono(struct snd_kcontrol
*kcontrol
,
527 struct snd_ctl_elem_value
*ucontrol
)
529 struct tumbler_mono_vol
*info
= (struct tumbler_mono_vol
*)kcontrol
->private_value
;
530 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
531 struct pmac_tumbler
*mix
;
534 if (! (mix
= chip
->mixer_data
))
536 change
= mix
->mono_vol
[info
->index
] != ucontrol
->value
.integer
.value
[0];
538 mix
->mono_vol
[info
->index
] = ucontrol
->value
.integer
.value
[0];
539 tumbler_set_mono_volume(mix
, info
);
544 /* TAS3001c mono volumes */
545 static struct tumbler_mono_vol tumbler_pcm_vol_info
= {
546 .index
= VOL_IDX_PCM_MONO
,
549 .max
= ARRAY_SIZE(mixer_volume_table
),
550 .table
= mixer_volume_table
,
553 static struct tumbler_mono_vol tumbler_bass_vol_info
= {
554 .index
= VOL_IDX_BASS
,
557 .max
= ARRAY_SIZE(bass_volume_table
),
558 .table
= bass_volume_table
,
561 static struct tumbler_mono_vol tumbler_treble_vol_info
= {
562 .index
= VOL_IDX_TREBLE
,
563 .reg
= TAS_REG_TREBLE
,
565 .max
= ARRAY_SIZE(treble_volume_table
),
566 .table
= treble_volume_table
,
569 /* TAS3004 mono volumes */
570 static struct tumbler_mono_vol snapper_bass_vol_info
= {
571 .index
= VOL_IDX_BASS
,
574 .max
= ARRAY_SIZE(snapper_bass_volume_table
),
575 .table
= snapper_bass_volume_table
,
578 static struct tumbler_mono_vol snapper_treble_vol_info
= {
579 .index
= VOL_IDX_TREBLE
,
580 .reg
= TAS_REG_TREBLE
,
582 .max
= ARRAY_SIZE(snapper_treble_volume_table
),
583 .table
= snapper_treble_volume_table
,
587 #define DEFINE_MONO(xname,type) { \
588 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
590 .info = tumbler_info_mono, \
591 .get = tumbler_get_mono, \
592 .put = tumbler_put_mono, \
593 .private_value = (unsigned long)(&tumbler_##type##_vol_info), \
596 #define DEFINE_SNAPPER_MONO(xname,type) { \
597 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
599 .info = tumbler_info_mono, \
600 .get = tumbler_get_mono, \
601 .put = tumbler_put_mono, \
602 .private_value = (unsigned long)(&snapper_##type##_vol_info), \
607 * snapper mixer volumes
610 static int snapper_set_mix_vol1(struct pmac_tumbler
*mix
, int idx
, int ch
, int reg
)
613 unsigned char block
[9];
615 vol
= mix
->mix_vol
[idx
][ch
];
616 if (vol
>= ARRAY_SIZE(mixer_volume_table
)) {
617 vol
= ARRAY_SIZE(mixer_volume_table
) - 1;
618 mix
->mix_vol
[idx
][ch
] = vol
;
621 for (i
= 0; i
< 3; i
++) {
622 vol
= mix
->mix_vol
[i
][ch
];
623 vol
= mixer_volume_table
[vol
];
624 for (j
= 0; j
< 3; j
++)
625 block
[i
* 3 + j
] = (vol
>> ((2 - j
) * 8)) & 0xff;
627 if (i2c_smbus_write_i2c_block_data(mix
->i2c
.client
, reg
,
629 snd_printk("failed to set mono volume %d\n", reg
);
635 static int snapper_set_mix_vol(struct pmac_tumbler
*mix
, int idx
)
637 if (! mix
->i2c
.client
)
639 if (snapper_set_mix_vol1(mix
, idx
, 0, TAS_REG_LMIX
) < 0 ||
640 snapper_set_mix_vol1(mix
, idx
, 1, TAS_REG_RMIX
) < 0)
645 static int snapper_info_mix(struct snd_kcontrol
*kcontrol
,
646 struct snd_ctl_elem_info
*uinfo
)
648 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
650 uinfo
->value
.integer
.min
= 0;
651 uinfo
->value
.integer
.max
= ARRAY_SIZE(mixer_volume_table
) - 1;
655 static int snapper_get_mix(struct snd_kcontrol
*kcontrol
,
656 struct snd_ctl_elem_value
*ucontrol
)
658 int idx
= (int)kcontrol
->private_value
;
659 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
660 struct pmac_tumbler
*mix
;
661 if (! (mix
= chip
->mixer_data
))
663 ucontrol
->value
.integer
.value
[0] = mix
->mix_vol
[idx
][0];
664 ucontrol
->value
.integer
.value
[1] = mix
->mix_vol
[idx
][1];
668 static int snapper_put_mix(struct snd_kcontrol
*kcontrol
,
669 struct snd_ctl_elem_value
*ucontrol
)
671 int idx
= (int)kcontrol
->private_value
;
672 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
673 struct pmac_tumbler
*mix
;
676 if (! (mix
= chip
->mixer_data
))
678 change
= mix
->mix_vol
[idx
][0] != ucontrol
->value
.integer
.value
[0] ||
679 mix
->mix_vol
[idx
][1] != ucontrol
->value
.integer
.value
[1];
681 mix
->mix_vol
[idx
][0] = ucontrol
->value
.integer
.value
[0];
682 mix
->mix_vol
[idx
][1] = ucontrol
->value
.integer
.value
[1];
683 snapper_set_mix_vol(mix
, idx
);
690 * mute switches. FIXME: Turn that into software mute when both outputs are muted
691 * to avoid codec reset on ibook M7
694 enum { TUMBLER_MUTE_HP
, TUMBLER_MUTE_AMP
, TUMBLER_MUTE_LINE
};
696 static int tumbler_get_mute_switch(struct snd_kcontrol
*kcontrol
,
697 struct snd_ctl_elem_value
*ucontrol
)
699 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
700 struct pmac_tumbler
*mix
;
701 struct pmac_gpio
*gp
;
702 if (! (mix
= chip
->mixer_data
))
704 switch(kcontrol
->private_value
) {
705 case TUMBLER_MUTE_HP
:
706 gp
= &mix
->hp_mute
; break;
707 case TUMBLER_MUTE_AMP
:
708 gp
= &mix
->amp_mute
; break;
709 case TUMBLER_MUTE_LINE
:
710 gp
= &mix
->line_mute
; break;
716 ucontrol
->value
.integer
.value
[0] = !check_audio_gpio(gp
);
720 static int tumbler_put_mute_switch(struct snd_kcontrol
*kcontrol
,
721 struct snd_ctl_elem_value
*ucontrol
)
723 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
724 struct pmac_tumbler
*mix
;
725 struct pmac_gpio
*gp
;
727 #ifdef PMAC_SUPPORT_AUTOMUTE
728 if (chip
->update_automute
&& chip
->auto_mute
)
729 return 0; /* don't touch in the auto-mute mode */
731 if (! (mix
= chip
->mixer_data
))
733 switch(kcontrol
->private_value
) {
734 case TUMBLER_MUTE_HP
:
735 gp
= &mix
->hp_mute
; break;
736 case TUMBLER_MUTE_AMP
:
737 gp
= &mix
->amp_mute
; break;
738 case TUMBLER_MUTE_LINE
:
739 gp
= &mix
->line_mute
; break;
745 val
= ! check_audio_gpio(gp
);
746 if (val
!= ucontrol
->value
.integer
.value
[0]) {
747 write_audio_gpio(gp
, ! ucontrol
->value
.integer
.value
[0]);
753 static int snapper_set_capture_source(struct pmac_tumbler
*mix
)
755 if (! mix
->i2c
.client
)
757 if (mix
->capture_source
)
758 mix
->acs
= mix
->acs
|= 2;
761 return i2c_smbus_write_byte_data(mix
->i2c
.client
, TAS_REG_ACS
, mix
->acs
);
764 static int snapper_info_capture_source(struct snd_kcontrol
*kcontrol
,
765 struct snd_ctl_elem_info
*uinfo
)
767 static char *texts
[2] = {
770 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
772 uinfo
->value
.enumerated
.items
= 2;
773 if (uinfo
->value
.enumerated
.item
> 1)
774 uinfo
->value
.enumerated
.item
= 1;
775 strcpy(uinfo
->value
.enumerated
.name
, texts
[uinfo
->value
.enumerated
.item
]);
779 static int snapper_get_capture_source(struct snd_kcontrol
*kcontrol
,
780 struct snd_ctl_elem_value
*ucontrol
)
782 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
783 struct pmac_tumbler
*mix
= chip
->mixer_data
;
785 snd_assert(mix
, return -ENODEV
);
786 ucontrol
->value
.integer
.value
[0] = mix
->capture_source
;
790 static int snapper_put_capture_source(struct snd_kcontrol
*kcontrol
,
791 struct snd_ctl_elem_value
*ucontrol
)
793 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
794 struct pmac_tumbler
*mix
= chip
->mixer_data
;
797 snd_assert(mix
, return -ENODEV
);
798 change
= ucontrol
->value
.integer
.value
[0] != mix
->capture_source
;
800 mix
->capture_source
= !!ucontrol
->value
.integer
.value
[0];
801 snapper_set_capture_source(mix
);
806 #define DEFINE_SNAPPER_MIX(xname,idx,ofs) { \
807 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
809 .info = snapper_info_mix, \
810 .get = snapper_get_mix, \
811 .put = snapper_put_mix, \
813 .private_value = ofs, \
819 static struct snd_kcontrol_new tumbler_mixers
[] __initdata
= {
820 { .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
821 .name
= "Master Playback Volume",
822 .info
= tumbler_info_master_volume
,
823 .get
= tumbler_get_master_volume
,
824 .put
= tumbler_put_master_volume
826 { .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
827 .name
= "Master Playback Switch",
828 .info
= snd_pmac_boolean_stereo_info
,
829 .get
= tumbler_get_master_switch
,
830 .put
= tumbler_put_master_switch
832 DEFINE_MONO("Tone Control - Bass", bass
),
833 DEFINE_MONO("Tone Control - Treble", treble
),
834 DEFINE_MONO("PCM Playback Volume", pcm
),
835 { .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
837 .info
= tumbler_info_drc_value
,
838 .get
= tumbler_get_drc_value
,
839 .put
= tumbler_put_drc_value
843 static struct snd_kcontrol_new snapper_mixers
[] __initdata
= {
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_SNAPPER_MIX("PCM Playback Volume", 0, VOL_IDX_PCM
),
857 DEFINE_SNAPPER_MIX("PCM Playback Volume", 1, VOL_IDX_PCM2
),
858 DEFINE_SNAPPER_MIX("Monitor Mix Volume", 0, VOL_IDX_ADC
),
859 DEFINE_SNAPPER_MONO("Tone Control - Bass", bass
),
860 DEFINE_SNAPPER_MONO("Tone Control - Treble", treble
),
861 { .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
863 .info
= tumbler_info_drc_value
,
864 .get
= tumbler_get_drc_value
,
865 .put
= tumbler_put_drc_value
867 { .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
868 .name
= "Input Source", /* FIXME: "Capture Source" doesn't work properly */
869 .info
= snapper_info_capture_source
,
870 .get
= snapper_get_capture_source
,
871 .put
= snapper_put_capture_source
875 static struct snd_kcontrol_new tumbler_hp_sw __initdata
= {
876 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
877 .name
= "Headphone Playback Switch",
878 .info
= snd_pmac_boolean_mono_info
,
879 .get
= tumbler_get_mute_switch
,
880 .put
= tumbler_put_mute_switch
,
881 .private_value
= TUMBLER_MUTE_HP
,
883 static struct snd_kcontrol_new tumbler_speaker_sw __initdata
= {
884 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
885 .name
= "PC Speaker Playback Switch",
886 .info
= snd_pmac_boolean_mono_info
,
887 .get
= tumbler_get_mute_switch
,
888 .put
= tumbler_put_mute_switch
,
889 .private_value
= TUMBLER_MUTE_AMP
,
891 static struct snd_kcontrol_new tumbler_lineout_sw __initdata
= {
892 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
893 .name
= "Line Out Playback Switch",
894 .info
= snd_pmac_boolean_mono_info
,
895 .get
= tumbler_get_mute_switch
,
896 .put
= tumbler_put_mute_switch
,
897 .private_value
= TUMBLER_MUTE_LINE
,
899 static struct snd_kcontrol_new tumbler_drc_sw __initdata
= {
900 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
901 .name
= "DRC Switch",
902 .info
= snd_pmac_boolean_mono_info
,
903 .get
= tumbler_get_drc_switch
,
904 .put
= tumbler_put_drc_switch
908 #ifdef PMAC_SUPPORT_AUTOMUTE
912 static int tumbler_detect_headphone(struct snd_pmac
*chip
)
914 struct pmac_tumbler
*mix
= chip
->mixer_data
;
917 if (mix
->hp_detect
.addr
)
918 detect
|= read_audio_gpio(&mix
->hp_detect
);
922 static int tumbler_detect_lineout(struct snd_pmac
*chip
)
924 struct pmac_tumbler
*mix
= chip
->mixer_data
;
927 if (mix
->line_detect
.addr
)
928 detect
|= read_audio_gpio(&mix
->line_detect
);
932 static void check_mute(struct snd_pmac
*chip
, struct pmac_gpio
*gp
, int val
, int do_notify
,
933 struct snd_kcontrol
*sw
)
935 if (check_audio_gpio(gp
) != val
) {
936 write_audio_gpio(gp
, val
);
938 snd_ctl_notify(chip
->card
, SNDRV_CTL_EVENT_MASK_VALUE
,
943 static struct work_struct device_change
;
945 static void device_change_handler(void *self
)
947 struct snd_pmac
*chip
= self
;
948 struct pmac_tumbler
*mix
;
949 int headphone
, lineout
;
954 mix
= chip
->mixer_data
;
955 snd_assert(mix
, return);
957 headphone
= tumbler_detect_headphone(chip
);
958 lineout
= tumbler_detect_lineout(chip
);
960 DBG("headphone: %d, lineout: %d\n", headphone
, lineout
);
962 if (headphone
|| lineout
) {
963 /* unmute headphone/lineout & mute speaker */
965 check_mute(chip
, &mix
->hp_mute
, 0, mix
->auto_mute_notify
,
966 chip
->master_sw_ctl
);
967 if (lineout
&& mix
->line_mute
.addr
!= 0)
968 check_mute(chip
, &mix
->line_mute
, 0, mix
->auto_mute_notify
,
969 chip
->lineout_sw_ctl
);
970 if (mix
->anded_reset
)
972 check_mute(chip
, &mix
->amp_mute
, 1, mix
->auto_mute_notify
,
973 chip
->speaker_sw_ctl
);
975 /* unmute speaker, mute others */
976 check_mute(chip
, &mix
->amp_mute
, 0, mix
->auto_mute_notify
,
977 chip
->speaker_sw_ctl
);
978 if (mix
->anded_reset
)
980 check_mute(chip
, &mix
->hp_mute
, 1, mix
->auto_mute_notify
,
981 chip
->master_sw_ctl
);
982 if (mix
->line_mute
.addr
!= 0)
983 check_mute(chip
, &mix
->line_mute
, 1, mix
->auto_mute_notify
,
984 chip
->lineout_sw_ctl
);
986 if (mix
->auto_mute_notify
)
987 snd_ctl_notify(chip
->card
, SNDRV_CTL_EVENT_MASK_VALUE
,
988 &chip
->hp_detect_ctl
->id
);
990 #ifdef CONFIG_SND_POWERMAC_AUTO_DRC
991 mix
->drc_enable
= ! (headphone
|| lineout
);
992 if (mix
->auto_mute_notify
)
993 snd_ctl_notify(chip
->card
, SNDRV_CTL_EVENT_MASK_VALUE
,
994 &chip
->drc_sw_ctl
->id
);
995 if (chip
->model
== PMAC_TUMBLER
)
996 tumbler_set_drc(mix
);
998 snapper_set_drc(mix
);
1001 /* reset the master volume so the correct amplification is applied */
1002 tumbler_set_master_volume(mix
);
1005 static void tumbler_update_automute(struct snd_pmac
*chip
, int do_notify
)
1007 if (chip
->auto_mute
) {
1008 struct pmac_tumbler
*mix
;
1009 mix
= chip
->mixer_data
;
1010 snd_assert(mix
, return);
1011 mix
->auto_mute_notify
= do_notify
;
1012 schedule_work(&device_change
);
1015 #endif /* PMAC_SUPPORT_AUTOMUTE */
1018 /* interrupt - headphone plug changed */
1019 static irqreturn_t
headphone_intr(int irq
, void *devid
, struct pt_regs
*regs
)
1021 struct snd_pmac
*chip
= devid
;
1022 if (chip
->update_automute
&& chip
->initialized
) {
1023 chip
->update_automute(chip
, 1);
1029 /* look for audio-gpio device */
1030 static struct device_node
*find_audio_device(const char *name
)
1032 struct device_node
*np
;
1034 if (! (np
= find_devices("gpio")))
1037 for (np
= np
->child
; np
; np
= np
->sibling
) {
1038 const char *property
= get_property(np
, "audio-gpio", NULL
);
1039 if (property
&& strcmp(property
, name
) == 0)
1045 /* look for audio-gpio device */
1046 static struct device_node
*find_compatible_audio_device(const char *name
)
1048 struct device_node
*np
;
1050 if (! (np
= find_devices("gpio")))
1053 for (np
= np
->child
; np
; np
= np
->sibling
) {
1054 if (device_is_compatible(np
, name
))
1060 /* find an audio device and get its address */
1061 static long tumbler_find_device(const char *device
, const char *platform
,
1062 struct pmac_gpio
*gp
, int is_compatible
)
1064 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
= get_property(node
, "AAPL,address", NULL
);
1080 base
= 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
= 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;
1100 const u32
*prop
= NULL
;
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
= 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 irq_of_parse_and_map(node
, 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-powermac");
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);