1 /* 2 * PMac DACA lowlevel functions 3 * 4 * Copyright (c) by Takashi Iwai <tiwai@suse.de> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19 */ 20 21 22 #include <sound/driver.h> 23 #include <linux/init.h> 24 #include <linux/i2c.h> 25 #include <linux/kmod.h> 26 #include <linux/slab.h> 27 #include <sound/core.h> 28 #include "pmac.h" 29 30 /* i2c address */ 31 #define DACA_I2C_ADDR 0x4d 32 33 /* registers */ 34 #define DACA_REG_SR 0x01 35 #define DACA_REG_AVOL 0x02 36 #define DACA_REG_GCFG 0x03 37 38 /* maximum volume value */ 39 #define DACA_VOL_MAX 0x38 40 41 42 struct pmac_daca { 43 struct pmac_keywest i2c; 44 int left_vol, right_vol; 45 unsigned int deemphasis : 1; 46 unsigned int amp_on : 1; 47 }; 48 49 50 /* 51 * initialize / detect DACA 52 */ 53 static int daca_init_client(struct pmac_keywest *i2c) 54 { 55 unsigned short wdata = 0x00; 56 /* SR: no swap, 1bit delay, 32-48kHz */ 57 /* GCFG: power amp inverted, DAC on */ 58 if (i2c_smbus_write_byte_data(i2c->client, DACA_REG_SR, 0x08) < 0 || 59 i2c_smbus_write_byte_data(i2c->client, DACA_REG_GCFG, 0x05) < 0) 60 return -EINVAL; 61 return i2c_smbus_write_block_data(i2c->client, DACA_REG_AVOL, 62 2, (unsigned char*)&wdata); 63 } 64 65 /* 66 * update volume 67 */ 68 static int daca_set_volume(struct pmac_daca *mix) 69 { 70 unsigned char data[2]; 71 72 if (! mix->i2c.client) 73 return -ENODEV; 74 75 if (mix->left_vol > DACA_VOL_MAX) 76 data[0] = DACA_VOL_MAX; 77 else 78 data[0] = mix->left_vol; 79 if (mix->right_vol > DACA_VOL_MAX) 80 data[1] = DACA_VOL_MAX; 81 else 82 data[1] = mix->right_vol; 83 data[1] |= mix->deemphasis ? 0x40 : 0; 84 if (i2c_smbus_write_block_data(mix->i2c.client, DACA_REG_AVOL, 85 2, data) < 0) { 86 snd_printk("failed to set volume \n"); 87 return -EINVAL; 88 } 89 return 0; 90 } 91 92 93 /* deemphasis switch */ 94 #define daca_info_deemphasis snd_ctl_boolean_mono_info 95 96 static int daca_get_deemphasis(struct snd_kcontrol *kcontrol, 97 struct snd_ctl_elem_value *ucontrol) 98 { 99 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 100 struct pmac_daca *mix; 101 if (! (mix = chip->mixer_data)) 102 return -ENODEV; 103 ucontrol->value.integer.value[0] = mix->deemphasis ? 1 : 0; 104 return 0; 105 } 106 107 static int daca_put_deemphasis(struct snd_kcontrol *kcontrol, 108 struct snd_ctl_elem_value *ucontrol) 109 { 110 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 111 struct pmac_daca *mix; 112 int change; 113 114 if (! (mix = chip->mixer_data)) 115 return -ENODEV; 116 change = mix->deemphasis != ucontrol->value.integer.value[0]; 117 if (change) { 118 mix->deemphasis = ucontrol->value.integer.value[0]; 119 daca_set_volume(mix); 120 } 121 return change; 122 } 123 124 /* output volume */ 125 static int daca_info_volume(struct snd_kcontrol *kcontrol, 126 struct snd_ctl_elem_info *uinfo) 127 { 128 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 129 uinfo->count = 2; 130 uinfo->value.integer.min = 0; 131 uinfo->value.integer.max = DACA_VOL_MAX; 132 return 0; 133 } 134 135 static int daca_get_volume(struct snd_kcontrol *kcontrol, 136 struct snd_ctl_elem_value *ucontrol) 137 { 138 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 139 struct pmac_daca *mix; 140 if (! (mix = chip->mixer_data)) 141 return -ENODEV; 142 ucontrol->value.integer.value[0] = mix->left_vol; 143 ucontrol->value.integer.value[1] = mix->right_vol; 144 return 0; 145 } 146 147 static int daca_put_volume(struct snd_kcontrol *kcontrol, 148 struct snd_ctl_elem_value *ucontrol) 149 { 150 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 151 struct pmac_daca *mix; 152 int change; 153 154 if (! (mix = chip->mixer_data)) 155 return -ENODEV; 156 change = mix->left_vol != ucontrol->value.integer.value[0] || 157 mix->right_vol != ucontrol->value.integer.value[1]; 158 if (change) { 159 mix->left_vol = ucontrol->value.integer.value[0]; 160 mix->right_vol = ucontrol->value.integer.value[1]; 161 daca_set_volume(mix); 162 } 163 return change; 164 } 165 166 /* amplifier switch */ 167 #define daca_info_amp daca_info_deemphasis 168 169 static int daca_get_amp(struct snd_kcontrol *kcontrol, 170 struct snd_ctl_elem_value *ucontrol) 171 { 172 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 173 struct pmac_daca *mix; 174 if (! (mix = chip->mixer_data)) 175 return -ENODEV; 176 ucontrol->value.integer.value[0] = mix->amp_on ? 1 : 0; 177 return 0; 178 } 179 180 static int daca_put_amp(struct snd_kcontrol *kcontrol, 181 struct snd_ctl_elem_value *ucontrol) 182 { 183 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 184 struct pmac_daca *mix; 185 int change; 186 187 if (! (mix = chip->mixer_data)) 188 return -ENODEV; 189 change = mix->amp_on != ucontrol->value.integer.value[0]; 190 if (change) { 191 mix->amp_on = ucontrol->value.integer.value[0]; 192 i2c_smbus_write_byte_data(mix->i2c.client, DACA_REG_GCFG, 193 mix->amp_on ? 0x05 : 0x04); 194 } 195 return change; 196 } 197 198 static struct snd_kcontrol_new daca_mixers[] = { 199 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 200 .name = "Deemphasis Switch", 201 .info = daca_info_deemphasis, 202 .get = daca_get_deemphasis, 203 .put = daca_put_deemphasis 204 }, 205 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 206 .name = "Master Playback Volume", 207 .info = daca_info_volume, 208 .get = daca_get_volume, 209 .put = daca_put_volume 210 }, 211 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 212 .name = "Power Amplifier Switch", 213 .info = daca_info_amp, 214 .get = daca_get_amp, 215 .put = daca_put_amp 216 }, 217 }; 218 219 220 #ifdef CONFIG_PM 221 static void daca_resume(struct snd_pmac *chip) 222 { 223 struct pmac_daca *mix = chip->mixer_data; 224 i2c_smbus_write_byte_data(mix->i2c.client, DACA_REG_SR, 0x08); 225 i2c_smbus_write_byte_data(mix->i2c.client, DACA_REG_GCFG, 226 mix->amp_on ? 0x05 : 0x04); 227 daca_set_volume(mix); 228 } 229 #endif /* CONFIG_PM */ 230 231 232 static void daca_cleanup(struct snd_pmac *chip) 233 { 234 struct pmac_daca *mix = chip->mixer_data; 235 if (! mix) 236 return; 237 snd_pmac_keywest_cleanup(&mix->i2c); 238 kfree(mix); 239 chip->mixer_data = NULL; 240 } 241 242 /* exported */ 243 int __init snd_pmac_daca_init(struct snd_pmac *chip) 244 { 245 int i, err; 246 struct pmac_daca *mix; 247 248 #ifdef CONFIG_KMOD 249 if (current->fs->root) 250 request_module("i2c-powermac"); 251 #endif /* CONFIG_KMOD */ 252 253 mix = kzalloc(sizeof(*mix), GFP_KERNEL); 254 if (! mix) 255 return -ENOMEM; 256 chip->mixer_data = mix; 257 chip->mixer_free = daca_cleanup; 258 mix->amp_on = 1; /* default on */ 259 260 mix->i2c.addr = DACA_I2C_ADDR; 261 mix->i2c.init_client = daca_init_client; 262 mix->i2c.name = "DACA"; 263 if ((err = snd_pmac_keywest_init(&mix->i2c)) < 0) 264 return err; 265 266 /* 267 * build mixers 268 */ 269 strcpy(chip->card->mixername, "PowerMac DACA"); 270 271 for (i = 0; i < ARRAY_SIZE(daca_mixers); i++) { 272 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&daca_mixers[i], chip))) < 0) 273 return err; 274 } 275 276 #ifdef CONFIG_PM 277 chip->resume = daca_resume; 278 #endif 279 280 return 0; 281 } 282