Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * PMac Tumbler/Snapper lowlevel functions
0004  *
0005  * Copyright (c) by Takashi Iwai <tiwai@suse.de>
0006  *
0007  *   Rene Rebe <rene.rebe@gmx.net>:
0008  *     * update from shadow registers on wakeup and headphone plug
0009  *     * automatically toggle DRC on headphone plug
0010  */
0011 
0012 
0013 #include <linux/init.h>
0014 #include <linux/delay.h>
0015 #include <linux/i2c.h>
0016 #include <linux/kmod.h>
0017 #include <linux/slab.h>
0018 #include <linux/interrupt.h>
0019 #include <linux/string.h>
0020 #include <linux/of_irq.h>
0021 #include <linux/io.h>
0022 #include <sound/core.h>
0023 #include <asm/irq.h>
0024 #include <asm/machdep.h>
0025 #include <asm/pmac_feature.h>
0026 #include "pmac.h"
0027 #include "tumbler_volume.h"
0028 
0029 #undef DEBUG
0030 
0031 #ifdef DEBUG
0032 #define DBG(fmt...) printk(KERN_DEBUG fmt)
0033 #else
0034 #define DBG(fmt...)
0035 #endif
0036 
0037 #define IS_G4DA (of_machine_is_compatible("PowerMac3,4"))
0038 
0039 /* i2c address for tumbler */
0040 #define TAS_I2C_ADDR    0x34
0041 
0042 /* registers */
0043 #define TAS_REG_MCS 0x01    /* main control */
0044 #define TAS_REG_DRC 0x02
0045 #define TAS_REG_VOL 0x04
0046 #define TAS_REG_TREBLE  0x05
0047 #define TAS_REG_BASS    0x06
0048 #define TAS_REG_INPUT1  0x07
0049 #define TAS_REG_INPUT2  0x08
0050 
0051 /* tas3001c */
0052 #define TAS_REG_PCM TAS_REG_INPUT1
0053  
0054 /* tas3004 */
0055 #define TAS_REG_LMIX    TAS_REG_INPUT1
0056 #define TAS_REG_RMIX    TAS_REG_INPUT2
0057 #define TAS_REG_MCS2    0x43        /* main control 2 */
0058 #define TAS_REG_ACS 0x40        /* analog control */
0059 
0060 /* mono volumes for tas3001c/tas3004 */
0061 enum {
0062     VOL_IDX_PCM_MONO, /* tas3001c only */
0063     VOL_IDX_BASS, VOL_IDX_TREBLE,
0064     VOL_IDX_LAST_MONO
0065 };
0066 
0067 /* stereo volumes for tas3004 */
0068 enum {
0069     VOL_IDX_PCM, VOL_IDX_PCM2, VOL_IDX_ADC,
0070     VOL_IDX_LAST_MIX
0071 };
0072 
0073 struct pmac_gpio {
0074     unsigned int addr;
0075     u8 active_val;
0076     u8 inactive_val;
0077     u8 active_state;
0078 };
0079 
0080 struct pmac_tumbler {
0081     struct pmac_keywest i2c;
0082     struct pmac_gpio audio_reset;
0083     struct pmac_gpio amp_mute;
0084     struct pmac_gpio line_mute;
0085     struct pmac_gpio line_detect;
0086     struct pmac_gpio hp_mute;
0087     struct pmac_gpio hp_detect;
0088     int headphone_irq;
0089     int lineout_irq;
0090     unsigned int save_master_vol[2];
0091     unsigned int master_vol[2];
0092     unsigned int save_master_switch[2];
0093     unsigned int master_switch[2];
0094     unsigned int mono_vol[VOL_IDX_LAST_MONO];
0095     unsigned int mix_vol[VOL_IDX_LAST_MIX][2]; /* stereo volumes for tas3004 */
0096     int drc_range;
0097     int drc_enable;
0098     int capture_source;
0099     int anded_reset;
0100     int auto_mute_notify;
0101     int reset_on_sleep;
0102     u8  acs;
0103 };
0104 
0105 
0106 /*
0107  */
0108 
0109 static int send_init_client(struct pmac_keywest *i2c, const unsigned int *regs)
0110 {
0111     while (*regs > 0) {
0112         int err, count = 10;
0113         do {
0114             err = i2c_smbus_write_byte_data(i2c->client,
0115                             regs[0], regs[1]);
0116             if (err >= 0)
0117                 break;
0118             DBG("(W) i2c error %d\n", err);
0119             mdelay(10);
0120         } while (count--);
0121         if (err < 0)
0122             return -ENXIO;
0123         regs += 2;
0124     }
0125     return 0;
0126 }
0127 
0128 
0129 static int tumbler_init_client(struct pmac_keywest *i2c)
0130 {
0131     static const unsigned int regs[] = {
0132         /* normal operation, SCLK=64fps, i2s output, i2s input, 16bit width */
0133         TAS_REG_MCS, (1<<6)|(2<<4)|(2<<2)|0,
0134         0, /* terminator */
0135     };
0136     DBG("(I) tumbler init client\n");
0137     return send_init_client(i2c, regs);
0138 }
0139 
0140 static int snapper_init_client(struct pmac_keywest *i2c)
0141 {
0142     static const unsigned int regs[] = {
0143         /* normal operation, SCLK=64fps, i2s output, 16bit width */
0144         TAS_REG_MCS, (1<<6)|(2<<4)|0,
0145         /* normal operation, all-pass mode */
0146         TAS_REG_MCS2, (1<<1),
0147         /* normal output, no deemphasis, A input, power-up, line-in */
0148         TAS_REG_ACS, 0,
0149         0, /* terminator */
0150     };
0151     DBG("(I) snapper init client\n");
0152     return send_init_client(i2c, regs);
0153 }
0154     
0155 /*
0156  * gpio access
0157  */
0158 #define do_gpio_write(gp, val) \
0159     pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, (gp)->addr, val)
0160 #define do_gpio_read(gp) \
0161     pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, (gp)->addr, 0)
0162 #define tumbler_gpio_free(gp) /* NOP */
0163 
0164 static void write_audio_gpio(struct pmac_gpio *gp, int active)
0165 {
0166     if (! gp->addr)
0167         return;
0168     active = active ? gp->active_val : gp->inactive_val;
0169     do_gpio_write(gp, active);
0170     DBG("(I) gpio %x write %d\n", gp->addr, active);
0171 }
0172 
0173 static int check_audio_gpio(struct pmac_gpio *gp)
0174 {
0175     int ret;
0176 
0177     if (! gp->addr)
0178         return 0;
0179 
0180     ret = do_gpio_read(gp);
0181 
0182     return (ret & 0x1) == (gp->active_val & 0x1);
0183 }
0184 
0185 static int read_audio_gpio(struct pmac_gpio *gp)
0186 {
0187     int ret;
0188     if (! gp->addr)
0189         return 0;
0190     ret = do_gpio_read(gp);
0191     ret = (ret & 0x02) !=0;
0192     return ret == gp->active_state;
0193 }
0194 
0195 /*
0196  * update master volume
0197  */
0198 static int tumbler_set_master_volume(struct pmac_tumbler *mix)
0199 {
0200     unsigned char block[6];
0201     unsigned int left_vol, right_vol;
0202   
0203     if (! mix->i2c.client)
0204         return -ENODEV;
0205   
0206     if (! mix->master_switch[0])
0207         left_vol = 0;
0208     else {
0209         left_vol = mix->master_vol[0];
0210         if (left_vol >= ARRAY_SIZE(master_volume_table))
0211             left_vol = ARRAY_SIZE(master_volume_table) - 1;
0212         left_vol = master_volume_table[left_vol];
0213     }
0214     if (! mix->master_switch[1])
0215         right_vol = 0;
0216     else {
0217         right_vol = mix->master_vol[1];
0218         if (right_vol >= ARRAY_SIZE(master_volume_table))
0219             right_vol = ARRAY_SIZE(master_volume_table) - 1;
0220         right_vol = master_volume_table[right_vol];
0221     }
0222 
0223     block[0] = (left_vol >> 16) & 0xff;
0224     block[1] = (left_vol >> 8)  & 0xff;
0225     block[2] = (left_vol >> 0)  & 0xff;
0226 
0227     block[3] = (right_vol >> 16) & 0xff;
0228     block[4] = (right_vol >> 8)  & 0xff;
0229     block[5] = (right_vol >> 0)  & 0xff;
0230   
0231     if (i2c_smbus_write_i2c_block_data(mix->i2c.client, TAS_REG_VOL, 6,
0232                        block) < 0) {
0233         snd_printk(KERN_ERR "failed to set volume \n");
0234         return -EINVAL;
0235     }
0236     DBG("(I) succeeded to set volume (%u, %u)\n", left_vol, right_vol);
0237     return 0;
0238 }
0239 
0240 
0241 /* output volume */
0242 static int tumbler_info_master_volume(struct snd_kcontrol *kcontrol,
0243                       struct snd_ctl_elem_info *uinfo)
0244 {
0245     uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
0246     uinfo->count = 2;
0247     uinfo->value.integer.min = 0;
0248     uinfo->value.integer.max = ARRAY_SIZE(master_volume_table) - 1;
0249     return 0;
0250 }
0251 
0252 static int tumbler_get_master_volume(struct snd_kcontrol *kcontrol,
0253                      struct snd_ctl_elem_value *ucontrol)
0254 {
0255     struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
0256     struct pmac_tumbler *mix = chip->mixer_data;
0257 
0258     ucontrol->value.integer.value[0] = mix->master_vol[0];
0259     ucontrol->value.integer.value[1] = mix->master_vol[1];
0260     return 0;
0261 }
0262 
0263 static int tumbler_put_master_volume(struct snd_kcontrol *kcontrol,
0264                      struct snd_ctl_elem_value *ucontrol)
0265 {
0266     struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
0267     struct pmac_tumbler *mix = chip->mixer_data;
0268     unsigned int vol[2];
0269     int change;
0270 
0271     vol[0] = ucontrol->value.integer.value[0];
0272     vol[1] = ucontrol->value.integer.value[1];
0273     if (vol[0] >= ARRAY_SIZE(master_volume_table) ||
0274         vol[1] >= ARRAY_SIZE(master_volume_table))
0275         return -EINVAL;
0276     change = mix->master_vol[0] != vol[0] ||
0277         mix->master_vol[1] != vol[1];
0278     if (change) {
0279         mix->master_vol[0] = vol[0];
0280         mix->master_vol[1] = vol[1];
0281         tumbler_set_master_volume(mix);
0282     }
0283     return change;
0284 }
0285 
0286 /* output switch */
0287 static int tumbler_get_master_switch(struct snd_kcontrol *kcontrol,
0288                      struct snd_ctl_elem_value *ucontrol)
0289 {
0290     struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
0291     struct pmac_tumbler *mix = chip->mixer_data;
0292 
0293     ucontrol->value.integer.value[0] = mix->master_switch[0];
0294     ucontrol->value.integer.value[1] = mix->master_switch[1];
0295     return 0;
0296 }
0297 
0298 static int tumbler_put_master_switch(struct snd_kcontrol *kcontrol,
0299                      struct snd_ctl_elem_value *ucontrol)
0300 {
0301     struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
0302     struct pmac_tumbler *mix = chip->mixer_data;
0303     int change;
0304 
0305     change = mix->master_switch[0] != ucontrol->value.integer.value[0] ||
0306         mix->master_switch[1] != ucontrol->value.integer.value[1];
0307     if (change) {
0308         mix->master_switch[0] = !!ucontrol->value.integer.value[0];
0309         mix->master_switch[1] = !!ucontrol->value.integer.value[1];
0310         tumbler_set_master_volume(mix);
0311     }
0312     return change;
0313 }
0314 
0315 
0316 /*
0317  * TAS3001c dynamic range compression
0318  */
0319 
0320 #define TAS3001_DRC_MAX     0x5f
0321 
0322 static int tumbler_set_drc(struct pmac_tumbler *mix)
0323 {
0324     unsigned char val[2];
0325 
0326     if (! mix->i2c.client)
0327         return -ENODEV;
0328   
0329     if (mix->drc_enable) {
0330         val[0] = 0xc1; /* enable, 3:1 compression */
0331         if (mix->drc_range > TAS3001_DRC_MAX)
0332             val[1] = 0xf0;
0333         else if (mix->drc_range < 0)
0334             val[1] = 0x91;
0335         else
0336             val[1] = mix->drc_range + 0x91;
0337     } else {
0338         val[0] = 0;
0339         val[1] = 0;
0340     }
0341 
0342     if (i2c_smbus_write_i2c_block_data(mix->i2c.client, TAS_REG_DRC,
0343                        2, val) < 0) {
0344         snd_printk(KERN_ERR "failed to set DRC\n");
0345         return -EINVAL;
0346     }
0347     DBG("(I) succeeded to set DRC (%u, %u)\n", val[0], val[1]);
0348     return 0;
0349 }
0350 
0351 /*
0352  * TAS3004
0353  */
0354 
0355 #define TAS3004_DRC_MAX     0xef
0356 
0357 static int snapper_set_drc(struct pmac_tumbler *mix)
0358 {
0359     unsigned char val[6];
0360 
0361     if (! mix->i2c.client)
0362         return -ENODEV;
0363   
0364     if (mix->drc_enable)
0365         val[0] = 0x50; /* 3:1 above threshold */
0366     else
0367         val[0] = 0x51; /* disabled */
0368     val[1] = 0x02; /* 1:1 below threshold */
0369     if (mix->drc_range > 0xef)
0370         val[2] = 0xef;
0371     else if (mix->drc_range < 0)
0372         val[2] = 0x00;
0373     else
0374         val[2] = mix->drc_range;
0375     val[3] = 0xb0;
0376     val[4] = 0x60;
0377     val[5] = 0xa0;
0378 
0379     if (i2c_smbus_write_i2c_block_data(mix->i2c.client, TAS_REG_DRC,
0380                        6, val) < 0) {
0381         snd_printk(KERN_ERR "failed to set DRC\n");
0382         return -EINVAL;
0383     }
0384     DBG("(I) succeeded to set DRC (%u, %u)\n", val[0], val[1]);
0385     return 0;
0386 }
0387 
0388 static int tumbler_info_drc_value(struct snd_kcontrol *kcontrol,
0389                   struct snd_ctl_elem_info *uinfo)
0390 {
0391     struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
0392     uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
0393     uinfo->count = 1;
0394     uinfo->value.integer.min = 0;
0395     uinfo->value.integer.max =
0396         chip->model == PMAC_TUMBLER ? TAS3001_DRC_MAX : TAS3004_DRC_MAX;
0397     return 0;
0398 }
0399 
0400 static int tumbler_get_drc_value(struct snd_kcontrol *kcontrol,
0401                  struct snd_ctl_elem_value *ucontrol)
0402 {
0403     struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
0404     struct pmac_tumbler *mix;
0405     mix = chip->mixer_data;
0406     if (!mix)
0407         return -ENODEV;
0408     ucontrol->value.integer.value[0] = mix->drc_range;
0409     return 0;
0410 }
0411 
0412 static int tumbler_put_drc_value(struct snd_kcontrol *kcontrol,
0413                  struct snd_ctl_elem_value *ucontrol)
0414 {
0415     struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
0416     struct pmac_tumbler *mix;
0417     unsigned int val;
0418     int change;
0419 
0420     mix = chip->mixer_data;
0421     if (!mix)
0422         return -ENODEV;
0423     val = ucontrol->value.integer.value[0];
0424     if (chip->model == PMAC_TUMBLER) {
0425         if (val > TAS3001_DRC_MAX)
0426             return -EINVAL;
0427     } else {
0428         if (val > TAS3004_DRC_MAX)
0429             return -EINVAL;
0430     }
0431     change = mix->drc_range != val;
0432     if (change) {
0433         mix->drc_range = val;
0434         if (chip->model == PMAC_TUMBLER)
0435             tumbler_set_drc(mix);
0436         else
0437             snapper_set_drc(mix);
0438     }
0439     return change;
0440 }
0441 
0442 static int tumbler_get_drc_switch(struct snd_kcontrol *kcontrol,
0443                   struct snd_ctl_elem_value *ucontrol)
0444 {
0445     struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
0446     struct pmac_tumbler *mix;
0447     mix = chip->mixer_data;
0448     if (!mix)
0449         return -ENODEV;
0450     ucontrol->value.integer.value[0] = mix->drc_enable;
0451     return 0;
0452 }
0453 
0454 static int tumbler_put_drc_switch(struct snd_kcontrol *kcontrol,
0455                   struct snd_ctl_elem_value *ucontrol)
0456 {
0457     struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
0458     struct pmac_tumbler *mix;
0459     int change;
0460 
0461     mix = chip->mixer_data;
0462     if (!mix)
0463         return -ENODEV;
0464     change = mix->drc_enable != ucontrol->value.integer.value[0];
0465     if (change) {
0466         mix->drc_enable = !!ucontrol->value.integer.value[0];
0467         if (chip->model == PMAC_TUMBLER)
0468             tumbler_set_drc(mix);
0469         else
0470             snapper_set_drc(mix);
0471     }
0472     return change;
0473 }
0474 
0475 
0476 /*
0477  * mono volumes
0478  */
0479 
0480 struct tumbler_mono_vol {
0481     int index;
0482     int reg;
0483     int bytes;
0484     unsigned int max;
0485     const unsigned int *table;
0486 };
0487 
0488 static int tumbler_set_mono_volume(struct pmac_tumbler *mix,
0489                    const struct tumbler_mono_vol *info)
0490 {
0491     unsigned char block[4];
0492     unsigned int vol;
0493     int i;
0494   
0495     if (! mix->i2c.client)
0496         return -ENODEV;
0497   
0498     vol = mix->mono_vol[info->index];
0499     if (vol >= info->max)
0500         vol = info->max - 1;
0501     vol = info->table[vol];
0502     for (i = 0; i < info->bytes; i++)
0503         block[i] = (vol >> ((info->bytes - i - 1) * 8)) & 0xff;
0504     if (i2c_smbus_write_i2c_block_data(mix->i2c.client, info->reg,
0505                        info->bytes, block) < 0) {
0506         snd_printk(KERN_ERR "failed to set mono volume %d\n",
0507                info->index);
0508         return -EINVAL;
0509     }
0510     return 0;
0511 }
0512 
0513 static int tumbler_info_mono(struct snd_kcontrol *kcontrol,
0514                  struct snd_ctl_elem_info *uinfo)
0515 {
0516     struct tumbler_mono_vol *info = (struct tumbler_mono_vol *)kcontrol->private_value;
0517 
0518     uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
0519     uinfo->count = 1;
0520     uinfo->value.integer.min = 0;
0521     uinfo->value.integer.max = info->max - 1;
0522     return 0;
0523 }
0524 
0525 static int tumbler_get_mono(struct snd_kcontrol *kcontrol,
0526                 struct snd_ctl_elem_value *ucontrol)
0527 {
0528     struct tumbler_mono_vol *info = (struct tumbler_mono_vol *)kcontrol->private_value;
0529     struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
0530     struct pmac_tumbler *mix;
0531     mix = chip->mixer_data;
0532     if (!mix)
0533         return -ENODEV;
0534     ucontrol->value.integer.value[0] = mix->mono_vol[info->index];
0535     return 0;
0536 }
0537 
0538 static int tumbler_put_mono(struct snd_kcontrol *kcontrol,
0539                 struct snd_ctl_elem_value *ucontrol)
0540 {
0541     struct tumbler_mono_vol *info = (struct tumbler_mono_vol *)kcontrol->private_value;
0542     struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
0543     struct pmac_tumbler *mix;
0544     unsigned int vol;
0545     int change;
0546 
0547     mix = chip->mixer_data;
0548     if (!mix)
0549         return -ENODEV;
0550     vol = ucontrol->value.integer.value[0];
0551     if (vol >= info->max)
0552         return -EINVAL;
0553     change = mix->mono_vol[info->index] != vol;
0554     if (change) {
0555         mix->mono_vol[info->index] = vol;
0556         tumbler_set_mono_volume(mix, info);
0557     }
0558     return change;
0559 }
0560 
0561 /* TAS3001c mono volumes */
0562 static const struct tumbler_mono_vol tumbler_pcm_vol_info = {
0563     .index = VOL_IDX_PCM_MONO,
0564     .reg = TAS_REG_PCM,
0565     .bytes = 3,
0566     .max = ARRAY_SIZE(mixer_volume_table),
0567     .table = mixer_volume_table,
0568 };
0569 
0570 static const struct tumbler_mono_vol tumbler_bass_vol_info = {
0571     .index = VOL_IDX_BASS,
0572     .reg = TAS_REG_BASS,
0573     .bytes = 1,
0574     .max = ARRAY_SIZE(bass_volume_table),
0575     .table = bass_volume_table,
0576 };
0577 
0578 static const struct tumbler_mono_vol tumbler_treble_vol_info = {
0579     .index = VOL_IDX_TREBLE,
0580     .reg = TAS_REG_TREBLE,
0581     .bytes = 1,
0582     .max = ARRAY_SIZE(treble_volume_table),
0583     .table = treble_volume_table,
0584 };
0585 
0586 /* TAS3004 mono volumes */
0587 static const struct tumbler_mono_vol snapper_bass_vol_info = {
0588     .index = VOL_IDX_BASS,
0589     .reg = TAS_REG_BASS,
0590     .bytes = 1,
0591     .max = ARRAY_SIZE(snapper_bass_volume_table),
0592     .table = snapper_bass_volume_table,
0593 };
0594 
0595 static const struct tumbler_mono_vol snapper_treble_vol_info = {
0596     .index = VOL_IDX_TREBLE,
0597     .reg = TAS_REG_TREBLE,
0598     .bytes = 1,
0599     .max = ARRAY_SIZE(snapper_treble_volume_table),
0600     .table = snapper_treble_volume_table,
0601 };
0602 
0603 
0604 #define DEFINE_MONO(xname,type) { \
0605     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
0606     .name = xname, \
0607     .info = tumbler_info_mono, \
0608     .get = tumbler_get_mono, \
0609     .put = tumbler_put_mono, \
0610     .private_value = (unsigned long)(&tumbler_##type##_vol_info), \
0611 }
0612 
0613 #define DEFINE_SNAPPER_MONO(xname,type) { \
0614     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
0615     .name = xname, \
0616     .info = tumbler_info_mono, \
0617     .get = tumbler_get_mono, \
0618     .put = tumbler_put_mono, \
0619     .private_value = (unsigned long)(&snapper_##type##_vol_info), \
0620 }
0621 
0622 
0623 /*
0624  * snapper mixer volumes
0625  */
0626 
0627 static int snapper_set_mix_vol1(struct pmac_tumbler *mix, int idx, int ch, int reg)
0628 {
0629     int i, j, vol;
0630     unsigned char block[9];
0631 
0632     vol = mix->mix_vol[idx][ch];
0633     if (vol >= ARRAY_SIZE(mixer_volume_table)) {
0634         vol = ARRAY_SIZE(mixer_volume_table) - 1;
0635         mix->mix_vol[idx][ch] = vol;
0636     }
0637 
0638     for (i = 0; i < 3; i++) {
0639         vol = mix->mix_vol[i][ch];
0640         vol = mixer_volume_table[vol];
0641         for (j = 0; j < 3; j++)
0642             block[i * 3 + j] = (vol >> ((2 - j) * 8)) & 0xff;
0643     }
0644     if (i2c_smbus_write_i2c_block_data(mix->i2c.client, reg,
0645                        9, block) < 0) {
0646         snd_printk(KERN_ERR "failed to set mono volume %d\n", reg);
0647         return -EINVAL;
0648     }
0649     return 0;
0650 }
0651 
0652 static int snapper_set_mix_vol(struct pmac_tumbler *mix, int idx)
0653 {
0654     if (! mix->i2c.client)
0655         return -ENODEV;
0656     if (snapper_set_mix_vol1(mix, idx, 0, TAS_REG_LMIX) < 0 ||
0657         snapper_set_mix_vol1(mix, idx, 1, TAS_REG_RMIX) < 0)
0658         return -EINVAL;
0659     return 0;
0660 }
0661 
0662 static int snapper_info_mix(struct snd_kcontrol *kcontrol,
0663                 struct snd_ctl_elem_info *uinfo)
0664 {
0665     uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
0666     uinfo->count = 2;
0667     uinfo->value.integer.min = 0;
0668     uinfo->value.integer.max = ARRAY_SIZE(mixer_volume_table) - 1;
0669     return 0;
0670 }
0671 
0672 static int snapper_get_mix(struct snd_kcontrol *kcontrol,
0673                struct snd_ctl_elem_value *ucontrol)
0674 {
0675     int idx = (int)kcontrol->private_value;
0676     struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
0677     struct pmac_tumbler *mix;
0678     mix = chip->mixer_data;
0679     if (!mix)
0680         return -ENODEV;
0681     ucontrol->value.integer.value[0] = mix->mix_vol[idx][0];
0682     ucontrol->value.integer.value[1] = mix->mix_vol[idx][1];
0683     return 0;
0684 }
0685 
0686 static int snapper_put_mix(struct snd_kcontrol *kcontrol,
0687                struct snd_ctl_elem_value *ucontrol)
0688 {
0689     int idx = (int)kcontrol->private_value;
0690     struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
0691     struct pmac_tumbler *mix;
0692     unsigned int vol[2];
0693     int change;
0694 
0695     mix = chip->mixer_data;
0696     if (!mix)
0697         return -ENODEV;
0698     vol[0] = ucontrol->value.integer.value[0];
0699     vol[1] = ucontrol->value.integer.value[1];
0700     if (vol[0] >= ARRAY_SIZE(mixer_volume_table) ||
0701         vol[1] >= ARRAY_SIZE(mixer_volume_table))
0702         return -EINVAL;
0703     change = mix->mix_vol[idx][0] != vol[0] ||
0704         mix->mix_vol[idx][1] != vol[1];
0705     if (change) {
0706         mix->mix_vol[idx][0] = vol[0];
0707         mix->mix_vol[idx][1] = vol[1];
0708         snapper_set_mix_vol(mix, idx);
0709     }
0710     return change;
0711 }
0712 
0713 
0714 /*
0715  * mute switches. FIXME: Turn that into software mute when both outputs are muted
0716  * to avoid codec reset on ibook M7
0717  */
0718 
0719 enum { TUMBLER_MUTE_HP, TUMBLER_MUTE_AMP, TUMBLER_MUTE_LINE };
0720 
0721 static int tumbler_get_mute_switch(struct snd_kcontrol *kcontrol,
0722                    struct snd_ctl_elem_value *ucontrol)
0723 {
0724     struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
0725     struct pmac_tumbler *mix;
0726     struct pmac_gpio *gp;
0727     mix = chip->mixer_data;
0728     if (!mix)
0729         return -ENODEV;
0730     switch(kcontrol->private_value) {
0731     case TUMBLER_MUTE_HP:
0732         gp = &mix->hp_mute; break;
0733     case TUMBLER_MUTE_AMP:
0734         gp = &mix->amp_mute;    break;
0735     case TUMBLER_MUTE_LINE:
0736         gp = &mix->line_mute;   break;
0737     default:
0738         gp = NULL;
0739     }
0740     if (gp == NULL)
0741         return -EINVAL;
0742     ucontrol->value.integer.value[0] = !check_audio_gpio(gp);
0743     return 0;
0744 }
0745 
0746 static int tumbler_put_mute_switch(struct snd_kcontrol *kcontrol,
0747                    struct snd_ctl_elem_value *ucontrol)
0748 {
0749     struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
0750     struct pmac_tumbler *mix;
0751     struct pmac_gpio *gp;
0752     int val;
0753 #ifdef PMAC_SUPPORT_AUTOMUTE
0754     if (chip->update_automute && chip->auto_mute)
0755         return 0; /* don't touch in the auto-mute mode */
0756 #endif  
0757     mix = chip->mixer_data;
0758     if (!mix)
0759         return -ENODEV;
0760     switch(kcontrol->private_value) {
0761     case TUMBLER_MUTE_HP:
0762         gp = &mix->hp_mute; break;
0763     case TUMBLER_MUTE_AMP:
0764         gp = &mix->amp_mute;    break;
0765     case TUMBLER_MUTE_LINE:
0766         gp = &mix->line_mute;   break;
0767     default:
0768         gp = NULL;
0769     }
0770     if (gp == NULL)
0771         return -EINVAL;
0772     val = ! check_audio_gpio(gp);
0773     if (val != ucontrol->value.integer.value[0]) {
0774         write_audio_gpio(gp, ! ucontrol->value.integer.value[0]);
0775         return 1;
0776     }
0777     return 0;
0778 }
0779 
0780 static int snapper_set_capture_source(struct pmac_tumbler *mix)
0781 {
0782     if (! mix->i2c.client)
0783         return -ENODEV;
0784     if (mix->capture_source)
0785         mix->acs |= 2;
0786     else
0787         mix->acs &= ~2;
0788     return i2c_smbus_write_byte_data(mix->i2c.client, TAS_REG_ACS, mix->acs);
0789 }
0790 
0791 static int snapper_info_capture_source(struct snd_kcontrol *kcontrol,
0792                        struct snd_ctl_elem_info *uinfo)
0793 {
0794     static const char * const texts[2] = {
0795         "Line", "Mic"
0796     };
0797 
0798     return snd_ctl_enum_info(uinfo, 1, 2, texts);
0799 }
0800 
0801 static int snapper_get_capture_source(struct snd_kcontrol *kcontrol,
0802                       struct snd_ctl_elem_value *ucontrol)
0803 {
0804     struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
0805     struct pmac_tumbler *mix = chip->mixer_data;
0806 
0807     ucontrol->value.enumerated.item[0] = mix->capture_source;
0808     return 0;
0809 }
0810 
0811 static int snapper_put_capture_source(struct snd_kcontrol *kcontrol,
0812                       struct snd_ctl_elem_value *ucontrol)
0813 {
0814     struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
0815     struct pmac_tumbler *mix = chip->mixer_data;
0816     int change;
0817 
0818     change = ucontrol->value.enumerated.item[0] != mix->capture_source;
0819     if (change) {
0820         mix->capture_source = !!ucontrol->value.enumerated.item[0];
0821         snapper_set_capture_source(mix);
0822     }
0823     return change;
0824 }
0825 
0826 #define DEFINE_SNAPPER_MIX(xname,idx,ofs) { \
0827     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
0828     .name = xname, \
0829     .info = snapper_info_mix, \
0830     .get = snapper_get_mix, \
0831     .put = snapper_put_mix, \
0832     .index = idx,\
0833     .private_value = ofs, \
0834 }
0835 
0836 
0837 /*
0838  */
0839 static const struct snd_kcontrol_new tumbler_mixers[] = {
0840     { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0841       .name = "Master Playback Volume",
0842       .info = tumbler_info_master_volume,
0843       .get = tumbler_get_master_volume,
0844       .put = tumbler_put_master_volume
0845     },
0846     { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0847       .name = "Master Playback Switch",
0848       .info = snd_pmac_boolean_stereo_info,
0849       .get = tumbler_get_master_switch,
0850       .put = tumbler_put_master_switch
0851     },
0852     DEFINE_MONO("Tone Control - Bass", bass),
0853     DEFINE_MONO("Tone Control - Treble", treble),
0854     DEFINE_MONO("PCM Playback Volume", pcm),
0855     { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0856       .name = "DRC Range",
0857       .info = tumbler_info_drc_value,
0858       .get = tumbler_get_drc_value,
0859       .put = tumbler_put_drc_value
0860     },
0861 };
0862 
0863 static const struct snd_kcontrol_new snapper_mixers[] = {
0864     { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0865       .name = "Master Playback Volume",
0866       .info = tumbler_info_master_volume,
0867       .get = tumbler_get_master_volume,
0868       .put = tumbler_put_master_volume
0869     },
0870     { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0871       .name = "Master Playback Switch",
0872       .info = snd_pmac_boolean_stereo_info,
0873       .get = tumbler_get_master_switch,
0874       .put = tumbler_put_master_switch
0875     },
0876     DEFINE_SNAPPER_MIX("PCM Playback Volume", 0, VOL_IDX_PCM),
0877     /* Alternative PCM is assigned to Mic analog loopback on iBook G4 */
0878     DEFINE_SNAPPER_MIX("Mic Playback Volume", 0, VOL_IDX_PCM2),
0879     DEFINE_SNAPPER_MIX("Monitor Mix Volume", 0, VOL_IDX_ADC),
0880     DEFINE_SNAPPER_MONO("Tone Control - Bass", bass),
0881     DEFINE_SNAPPER_MONO("Tone Control - Treble", treble),
0882     { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0883       .name = "DRC Range",
0884       .info = tumbler_info_drc_value,
0885       .get = tumbler_get_drc_value,
0886       .put = tumbler_put_drc_value
0887     },
0888     { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0889       .name = "Input Source", /* FIXME: "Capture Source" doesn't work properly */
0890       .info = snapper_info_capture_source,
0891       .get = snapper_get_capture_source,
0892       .put = snapper_put_capture_source
0893     },
0894 };
0895 
0896 static const struct snd_kcontrol_new tumbler_hp_sw = {
0897     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0898     .name = "Headphone Playback Switch",
0899     .info = snd_pmac_boolean_mono_info,
0900     .get = tumbler_get_mute_switch,
0901     .put = tumbler_put_mute_switch,
0902     .private_value = TUMBLER_MUTE_HP,
0903 };
0904 static const struct snd_kcontrol_new tumbler_speaker_sw = {
0905     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0906     .name = "Speaker Playback Switch",
0907     .info = snd_pmac_boolean_mono_info,
0908     .get = tumbler_get_mute_switch,
0909     .put = tumbler_put_mute_switch,
0910     .private_value = TUMBLER_MUTE_AMP,
0911 };
0912 static const struct snd_kcontrol_new tumbler_lineout_sw = {
0913     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0914     .name = "Line Out Playback Switch",
0915     .info = snd_pmac_boolean_mono_info,
0916     .get = tumbler_get_mute_switch,
0917     .put = tumbler_put_mute_switch,
0918     .private_value = TUMBLER_MUTE_LINE,
0919 };
0920 static const struct snd_kcontrol_new tumbler_drc_sw = {
0921     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0922     .name = "DRC Switch",
0923     .info = snd_pmac_boolean_mono_info,
0924     .get = tumbler_get_drc_switch,
0925     .put = tumbler_put_drc_switch
0926 };
0927 
0928 
0929 #ifdef PMAC_SUPPORT_AUTOMUTE
0930 /*
0931  * auto-mute stuffs
0932  */
0933 static int tumbler_detect_headphone(struct snd_pmac *chip)
0934 {
0935     struct pmac_tumbler *mix = chip->mixer_data;
0936     int detect = 0;
0937 
0938     if (mix->hp_detect.addr)
0939         detect |= read_audio_gpio(&mix->hp_detect);
0940     return detect;
0941 }
0942 
0943 static int tumbler_detect_lineout(struct snd_pmac *chip)
0944 {
0945     struct pmac_tumbler *mix = chip->mixer_data;
0946     int detect = 0;
0947 
0948     if (mix->line_detect.addr)
0949         detect |= read_audio_gpio(&mix->line_detect);
0950     return detect;
0951 }
0952 
0953 static void check_mute(struct snd_pmac *chip, struct pmac_gpio *gp, int val, int do_notify,
0954                struct snd_kcontrol *sw)
0955 {
0956     if (check_audio_gpio(gp) != val) {
0957         write_audio_gpio(gp, val);
0958         if (do_notify)
0959             snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
0960                        &sw->id);
0961     }
0962 }
0963 
0964 static struct work_struct device_change;
0965 static struct snd_pmac *device_change_chip;
0966 
0967 static void device_change_handler(struct work_struct *work)
0968 {
0969     struct snd_pmac *chip = device_change_chip;
0970     struct pmac_tumbler *mix;
0971     int headphone, lineout;
0972 
0973     if (!chip)
0974         return;
0975 
0976     mix = chip->mixer_data;
0977     if (snd_BUG_ON(!mix))
0978         return;
0979 
0980     headphone = tumbler_detect_headphone(chip);
0981     lineout = tumbler_detect_lineout(chip);
0982 
0983     DBG("headphone: %d, lineout: %d\n", headphone, lineout);
0984 
0985     if (headphone || lineout) {
0986         /* unmute headphone/lineout & mute speaker */
0987         if (headphone)
0988             check_mute(chip, &mix->hp_mute, 0, mix->auto_mute_notify,
0989                    chip->master_sw_ctl);
0990         if (lineout && mix->line_mute.addr != 0)
0991             check_mute(chip, &mix->line_mute, 0, mix->auto_mute_notify,
0992                    chip->lineout_sw_ctl);
0993         if (mix->anded_reset)
0994             msleep(10);
0995         check_mute(chip, &mix->amp_mute, !IS_G4DA, mix->auto_mute_notify,
0996                chip->speaker_sw_ctl);
0997     } else {
0998         /* unmute speaker, mute others */
0999         check_mute(chip, &mix->amp_mute, 0, mix->auto_mute_notify,
1000                chip->speaker_sw_ctl);
1001         if (mix->anded_reset)
1002             msleep(10);
1003         check_mute(chip, &mix->hp_mute, 1, mix->auto_mute_notify,
1004                chip->master_sw_ctl);
1005         if (mix->line_mute.addr != 0)
1006             check_mute(chip, &mix->line_mute, 1, mix->auto_mute_notify,
1007                    chip->lineout_sw_ctl);
1008     }
1009     if (mix->auto_mute_notify)
1010         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1011                        &chip->hp_detect_ctl->id);
1012 
1013 #ifdef CONFIG_SND_POWERMAC_AUTO_DRC
1014     mix->drc_enable = ! (headphone || lineout);
1015     if (mix->auto_mute_notify)
1016         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1017                    &chip->drc_sw_ctl->id);
1018     if (chip->model == PMAC_TUMBLER)
1019         tumbler_set_drc(mix);
1020     else
1021         snapper_set_drc(mix);
1022 #endif
1023 
1024     /* reset the master volume so the correct amplification is applied */
1025     tumbler_set_master_volume(mix);
1026 }
1027 
1028 static void tumbler_update_automute(struct snd_pmac *chip, int do_notify)
1029 {
1030     if (chip->auto_mute) {
1031         struct pmac_tumbler *mix;
1032         mix = chip->mixer_data;
1033         if (snd_BUG_ON(!mix))
1034             return;
1035         mix->auto_mute_notify = do_notify;
1036         schedule_work(&device_change);
1037     }
1038 }
1039 #endif /* PMAC_SUPPORT_AUTOMUTE */
1040 
1041 
1042 /* interrupt - headphone plug changed */
1043 static irqreturn_t headphone_intr(int irq, void *devid)
1044 {
1045     struct snd_pmac *chip = devid;
1046     if (chip->update_automute && chip->initialized) {
1047         chip->update_automute(chip, 1);
1048         return IRQ_HANDLED;
1049     }
1050     return IRQ_NONE;
1051 }
1052 
1053 /* look for audio-gpio device */
1054 static struct device_node *find_audio_device(const char *name)
1055 {
1056     struct device_node *gpiop;
1057     struct device_node *np;
1058   
1059     gpiop = of_find_node_by_name(NULL, "gpio");
1060     if (! gpiop)
1061         return NULL;
1062   
1063     for (np = of_get_next_child(gpiop, NULL); np;
1064             np = of_get_next_child(gpiop, np)) {
1065         const char *property = of_get_property(np, "audio-gpio", NULL);
1066         if (property && strcmp(property, name) == 0)
1067             break;
1068     }  
1069     of_node_put(gpiop);
1070     return np;
1071 }
1072 
1073 /* look for audio-gpio device */
1074 static struct device_node *find_compatible_audio_device(const char *name)
1075 {
1076     struct device_node *gpiop;
1077     struct device_node *np;
1078   
1079     gpiop = of_find_node_by_name(NULL, "gpio");
1080     if (!gpiop)
1081         return NULL;
1082   
1083     for (np = of_get_next_child(gpiop, NULL); np;
1084             np = of_get_next_child(gpiop, np)) {
1085         if (of_device_is_compatible(np, name))
1086             break;
1087     }  
1088     of_node_put(gpiop);
1089     return np;
1090 }
1091 
1092 /* find an audio device and get its address */
1093 static long tumbler_find_device(const char *device, const char *platform,
1094                 struct pmac_gpio *gp, int is_compatible)
1095 {
1096     struct device_node *node;
1097     const u32 *base;
1098     u32 addr;
1099     long ret;
1100 
1101     if (is_compatible)
1102         node = find_compatible_audio_device(device);
1103     else
1104         node = find_audio_device(device);
1105     if (! node) {
1106         DBG("(W) cannot find audio device %s !\n", device);
1107         snd_printdd("cannot find device %s\n", device);
1108         return -ENODEV;
1109     }
1110 
1111     base = of_get_property(node, "AAPL,address", NULL);
1112     if (! base) {
1113         base = of_get_property(node, "reg", NULL);
1114         if (!base) {
1115             DBG("(E) cannot find address for device %s !\n", device);
1116             snd_printd("cannot find address for device %s\n", device);
1117             of_node_put(node);
1118             return -ENODEV;
1119         }
1120         addr = *base;
1121         if (addr < 0x50)
1122             addr += 0x50;
1123     } else
1124         addr = *base;
1125 
1126     gp->addr = addr & 0x0000ffff;
1127     /* Try to find the active state, default to 0 ! */
1128     base = of_get_property(node, "audio-gpio-active-state", NULL);
1129     if (base) {
1130         gp->active_state = *base;
1131         gp->active_val = (*base) ? 0x5 : 0x4;
1132         gp->inactive_val = (*base) ? 0x4 : 0x5;
1133     } else {
1134         const u32 *prop = NULL;
1135         gp->active_state = IS_G4DA
1136                 && !strncmp(device, "keywest-gpio1", 13);
1137         gp->active_val = 0x4;
1138         gp->inactive_val = 0x5;
1139         /* Here are some crude hacks to extract the GPIO polarity and
1140          * open collector informations out of the do-platform script
1141          * as we don't yet have an interpreter for these things
1142          */
1143         if (platform)
1144             prop = of_get_property(node, platform, NULL);
1145         if (prop) {
1146             if (prop[3] == 0x9 && prop[4] == 0x9) {
1147                 gp->active_val = 0xd;
1148                 gp->inactive_val = 0xc;
1149             }
1150             if (prop[3] == 0x1 && prop[4] == 0x1) {
1151                 gp->active_val = 0x5;
1152                 gp->inactive_val = 0x4;
1153             }
1154         }
1155     }
1156 
1157     DBG("(I) GPIO device %s found, offset: %x, active state: %d !\n",
1158         device, gp->addr, gp->active_state);
1159 
1160     ret = irq_of_parse_and_map(node, 0);
1161     of_node_put(node);
1162     return ret;
1163 }
1164 
1165 /* reset audio */
1166 static void tumbler_reset_audio(struct snd_pmac *chip)
1167 {
1168     struct pmac_tumbler *mix = chip->mixer_data;
1169 
1170     if (mix->anded_reset) {
1171         DBG("(I) codec anded reset !\n");
1172         write_audio_gpio(&mix->hp_mute, 0);
1173         write_audio_gpio(&mix->amp_mute, 0);
1174         msleep(200);
1175         write_audio_gpio(&mix->hp_mute, 1);
1176         write_audio_gpio(&mix->amp_mute, 1);
1177         msleep(100);
1178         write_audio_gpio(&mix->hp_mute, 0);
1179         write_audio_gpio(&mix->amp_mute, 0);
1180         msleep(100);
1181     } else {
1182         DBG("(I) codec normal reset !\n");
1183 
1184         write_audio_gpio(&mix->audio_reset, 0);
1185         msleep(200);
1186         write_audio_gpio(&mix->audio_reset, 1);
1187         msleep(100);
1188         write_audio_gpio(&mix->audio_reset, 0);
1189         msleep(100);
1190     }
1191 }
1192 
1193 #ifdef CONFIG_PM
1194 /* suspend mixer */
1195 static void tumbler_suspend(struct snd_pmac *chip)
1196 {
1197     struct pmac_tumbler *mix = chip->mixer_data;
1198 
1199     if (mix->headphone_irq >= 0)
1200         disable_irq(mix->headphone_irq);
1201     if (mix->lineout_irq >= 0)
1202         disable_irq(mix->lineout_irq);
1203     mix->save_master_switch[0] = mix->master_switch[0];
1204     mix->save_master_switch[1] = mix->master_switch[1];
1205     mix->save_master_vol[0] = mix->master_vol[0];
1206     mix->save_master_vol[1] = mix->master_vol[1];
1207     mix->master_switch[0] = mix->master_switch[1] = 0;
1208     tumbler_set_master_volume(mix);
1209     if (!mix->anded_reset) {
1210         write_audio_gpio(&mix->amp_mute, 1);
1211         write_audio_gpio(&mix->hp_mute, 1);
1212     }
1213     if (chip->model == PMAC_SNAPPER) {
1214         mix->acs |= 1;
1215         i2c_smbus_write_byte_data(mix->i2c.client, TAS_REG_ACS, mix->acs);
1216     }
1217     if (mix->anded_reset) {
1218         write_audio_gpio(&mix->amp_mute, 1);
1219         write_audio_gpio(&mix->hp_mute, 1);
1220     } else
1221         write_audio_gpio(&mix->audio_reset, 1);
1222 }
1223 
1224 /* resume mixer */
1225 static void tumbler_resume(struct snd_pmac *chip)
1226 {
1227     struct pmac_tumbler *mix = chip->mixer_data;
1228 
1229     mix->acs &= ~1;
1230     mix->master_switch[0] = mix->save_master_switch[0];
1231     mix->master_switch[1] = mix->save_master_switch[1];
1232     mix->master_vol[0] = mix->save_master_vol[0];
1233     mix->master_vol[1] = mix->save_master_vol[1];
1234     tumbler_reset_audio(chip);
1235     if (mix->i2c.client && mix->i2c.init_client) {
1236         if (mix->i2c.init_client(&mix->i2c) < 0)
1237             printk(KERN_ERR "tumbler_init_client error\n");
1238     } else
1239         printk(KERN_ERR "tumbler: i2c is not initialized\n");
1240     if (chip->model == PMAC_TUMBLER) {
1241         tumbler_set_mono_volume(mix, &tumbler_pcm_vol_info);
1242         tumbler_set_mono_volume(mix, &tumbler_bass_vol_info);
1243         tumbler_set_mono_volume(mix, &tumbler_treble_vol_info);
1244         tumbler_set_drc(mix);
1245     } else {
1246         snapper_set_mix_vol(mix, VOL_IDX_PCM);
1247         snapper_set_mix_vol(mix, VOL_IDX_PCM2);
1248         snapper_set_mix_vol(mix, VOL_IDX_ADC);
1249         tumbler_set_mono_volume(mix, &snapper_bass_vol_info);
1250         tumbler_set_mono_volume(mix, &snapper_treble_vol_info);
1251         snapper_set_drc(mix);
1252         snapper_set_capture_source(mix);
1253     }
1254     tumbler_set_master_volume(mix);
1255     if (chip->update_automute)
1256         chip->update_automute(chip, 0);
1257     if (mix->headphone_irq >= 0) {
1258         unsigned char val;
1259 
1260         enable_irq(mix->headphone_irq);
1261         /* activate headphone status interrupts */
1262         val = do_gpio_read(&mix->hp_detect);
1263         do_gpio_write(&mix->hp_detect, val | 0x80);
1264     }
1265     if (mix->lineout_irq >= 0)
1266         enable_irq(mix->lineout_irq);
1267 }
1268 #endif
1269 
1270 /* initialize tumbler */
1271 static int tumbler_init(struct snd_pmac *chip)
1272 {
1273     int irq;
1274     struct pmac_tumbler *mix = chip->mixer_data;
1275 
1276     if (tumbler_find_device("audio-hw-reset",
1277                 "platform-do-hw-reset",
1278                 &mix->audio_reset, 0) < 0)
1279         tumbler_find_device("hw-reset",
1280                     "platform-do-hw-reset",
1281                     &mix->audio_reset, 1);
1282     if (tumbler_find_device("amp-mute",
1283                 "platform-do-amp-mute",
1284                 &mix->amp_mute, 0) < 0)
1285         tumbler_find_device("amp-mute",
1286                     "platform-do-amp-mute",
1287                     &mix->amp_mute, 1);
1288     if (tumbler_find_device("headphone-mute",
1289                 "platform-do-headphone-mute",
1290                 &mix->hp_mute, 0) < 0)
1291         tumbler_find_device("headphone-mute",
1292                     "platform-do-headphone-mute",
1293                     &mix->hp_mute, 1);
1294     if (tumbler_find_device("line-output-mute",
1295                 "platform-do-lineout-mute",
1296                 &mix->line_mute, 0) < 0)
1297         tumbler_find_device("line-output-mute",
1298                    "platform-do-lineout-mute",
1299                     &mix->line_mute, 1);
1300     irq = tumbler_find_device("headphone-detect",
1301                   NULL, &mix->hp_detect, 0);
1302     if (irq <= 0)
1303         irq = tumbler_find_device("headphone-detect",
1304                       NULL, &mix->hp_detect, 1);
1305     if (irq <= 0)
1306         irq = tumbler_find_device("keywest-gpio15",
1307                       NULL, &mix->hp_detect, 1);
1308     mix->headphone_irq = irq;
1309     irq = tumbler_find_device("line-output-detect",
1310                   NULL, &mix->line_detect, 0);
1311     if (irq <= 0)
1312         irq = tumbler_find_device("line-output-detect",
1313                       NULL, &mix->line_detect, 1);
1314     if (IS_G4DA && irq <= 0)
1315         irq = tumbler_find_device("keywest-gpio16",
1316                       NULL, &mix->line_detect, 1);
1317     mix->lineout_irq = irq;
1318 
1319     tumbler_reset_audio(chip);
1320   
1321     return 0;
1322 }
1323 
1324 static void tumbler_cleanup(struct snd_pmac *chip)
1325 {
1326     struct pmac_tumbler *mix = chip->mixer_data;
1327     if (! mix)
1328         return;
1329 
1330     if (mix->headphone_irq >= 0)
1331         free_irq(mix->headphone_irq, chip);
1332     if (mix->lineout_irq >= 0)
1333         free_irq(mix->lineout_irq, chip);
1334     tumbler_gpio_free(&mix->audio_reset);
1335     tumbler_gpio_free(&mix->amp_mute);
1336     tumbler_gpio_free(&mix->hp_mute);
1337     tumbler_gpio_free(&mix->hp_detect);
1338     snd_pmac_keywest_cleanup(&mix->i2c);
1339     kfree(mix);
1340     chip->mixer_data = NULL;
1341 }
1342 
1343 /* exported */
1344 int snd_pmac_tumbler_init(struct snd_pmac *chip)
1345 {
1346     int i, err;
1347     struct pmac_tumbler *mix;
1348     const u32 *paddr;
1349     struct device_node *tas_node, *np;
1350     char *chipname;
1351 
1352     request_module("i2c-powermac");
1353 
1354     mix = kzalloc(sizeof(*mix), GFP_KERNEL);
1355     if (! mix)
1356         return -ENOMEM;
1357     mix->headphone_irq = -1;
1358 
1359     chip->mixer_data = mix;
1360     chip->mixer_free = tumbler_cleanup;
1361     mix->anded_reset = 0;
1362     mix->reset_on_sleep = 1;
1363 
1364     for_each_child_of_node(chip->node, np) {
1365         if (of_node_name_eq(np, "sound")) {
1366             if (of_get_property(np, "has-anded-reset", NULL))
1367                 mix->anded_reset = 1;
1368             if (of_get_property(np, "layout-id", NULL))
1369                 mix->reset_on_sleep = 0;
1370             of_node_put(np);
1371             break;
1372         }
1373     }
1374     err = tumbler_init(chip);
1375     if (err < 0)
1376         return err;
1377 
1378     /* set up TAS */
1379     tas_node = of_find_node_by_name(NULL, "deq");
1380     if (tas_node == NULL)
1381         tas_node = of_find_node_by_name(NULL, "codec");
1382     if (tas_node == NULL)
1383         return -ENODEV;
1384 
1385     paddr = of_get_property(tas_node, "i2c-address", NULL);
1386     if (paddr == NULL)
1387         paddr = of_get_property(tas_node, "reg", NULL);
1388     if (paddr)
1389         mix->i2c.addr = (*paddr) >> 1;
1390     else
1391         mix->i2c.addr = TAS_I2C_ADDR;
1392     of_node_put(tas_node);
1393 
1394     DBG("(I) TAS i2c address is: %x\n", mix->i2c.addr);
1395 
1396     if (chip->model == PMAC_TUMBLER) {
1397         mix->i2c.init_client = tumbler_init_client;
1398         mix->i2c.name = "TAS3001c";
1399         chipname = "Tumbler";
1400     } else {
1401         mix->i2c.init_client = snapper_init_client;
1402         mix->i2c.name = "TAS3004";
1403         chipname = "Snapper";
1404     }
1405 
1406     err = snd_pmac_keywest_init(&mix->i2c);
1407     if (err < 0)
1408         return err;
1409 
1410     /*
1411      * build mixers
1412      */
1413     sprintf(chip->card->mixername, "PowerMac %s", chipname);
1414 
1415     if (chip->model == PMAC_TUMBLER) {
1416         for (i = 0; i < ARRAY_SIZE(tumbler_mixers); i++) {
1417             err = snd_ctl_add(chip->card, snd_ctl_new1(&tumbler_mixers[i], chip));
1418             if (err < 0)
1419                 return err;
1420         }
1421     } else {
1422         for (i = 0; i < ARRAY_SIZE(snapper_mixers); i++) {
1423             err = snd_ctl_add(chip->card, snd_ctl_new1(&snapper_mixers[i], chip));
1424             if (err < 0)
1425                 return err;
1426         }
1427     }
1428     chip->master_sw_ctl = snd_ctl_new1(&tumbler_hp_sw, chip);
1429     err = snd_ctl_add(chip->card, chip->master_sw_ctl);
1430     if (err < 0)
1431         return err;
1432     chip->speaker_sw_ctl = snd_ctl_new1(&tumbler_speaker_sw, chip);
1433     err = snd_ctl_add(chip->card, chip->speaker_sw_ctl);
1434     if (err < 0)
1435         return err;
1436     if (mix->line_mute.addr != 0) {
1437         chip->lineout_sw_ctl = snd_ctl_new1(&tumbler_lineout_sw, chip);
1438         err = snd_ctl_add(chip->card, chip->lineout_sw_ctl);
1439         if (err < 0)
1440             return err;
1441     }
1442     chip->drc_sw_ctl = snd_ctl_new1(&tumbler_drc_sw, chip);
1443     err = snd_ctl_add(chip->card, chip->drc_sw_ctl);
1444     if (err < 0)
1445         return err;
1446 
1447     /* set initial DRC range to 60% */
1448     if (chip->model == PMAC_TUMBLER)
1449         mix->drc_range = (TAS3001_DRC_MAX * 6) / 10;
1450     else
1451         mix->drc_range = (TAS3004_DRC_MAX * 6) / 10;
1452     mix->drc_enable = 1; /* will be changed later if AUTO_DRC is set */
1453     if (chip->model == PMAC_TUMBLER)
1454         tumbler_set_drc(mix);
1455     else
1456         snapper_set_drc(mix);
1457 
1458 #ifdef CONFIG_PM
1459     chip->suspend = tumbler_suspend;
1460     chip->resume = tumbler_resume;
1461 #endif
1462 
1463     INIT_WORK(&device_change, device_change_handler);
1464     device_change_chip = chip;
1465 
1466 #ifdef PMAC_SUPPORT_AUTOMUTE
1467     if (mix->headphone_irq >= 0 || mix->lineout_irq >= 0) {
1468         err = snd_pmac_add_automute(chip);
1469         if (err < 0)
1470             return err;
1471     }
1472     chip->detect_headphone = tumbler_detect_headphone;
1473     chip->update_automute = tumbler_update_automute;
1474     tumbler_update_automute(chip, 0); /* update the status only */
1475 
1476     /* activate headphone status interrupts */
1477     if (mix->headphone_irq >= 0) {
1478         unsigned char val;
1479         err = request_irq(mix->headphone_irq, headphone_intr, 0,
1480                   "Sound Headphone Detection", chip);
1481         if (err < 0)
1482             return 0;
1483         /* activate headphone status interrupts */
1484         val = do_gpio_read(&mix->hp_detect);
1485         do_gpio_write(&mix->hp_detect, val | 0x80);
1486     }
1487     if (mix->lineout_irq >= 0) {
1488         unsigned char val;
1489         err = request_irq(mix->lineout_irq, headphone_intr, 0,
1490                   "Sound Lineout Detection", chip);
1491         if (err < 0)
1492             return 0;
1493         /* activate headphone status interrupts */
1494         val = do_gpio_read(&mix->line_detect);
1495         do_gpio_write(&mix->line_detect, val | 0x80);
1496     }
1497 #endif
1498 
1499     return 0;
1500 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!