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 static int daca_info_deemphasis(struct snd_kcontrol *kcontrol, 95 struct snd_ctl_elem_info *uinfo) 96 { 97 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 98 uinfo->count = 1; 99 uinfo->value.integer.min = 0; 100 uinfo->value.integer.max = 1; 101 return 0; 102 } 103 104 static int daca_get_deemphasis(struct snd_kcontrol *kcontrol, 105 struct snd_ctl_elem_value *ucontrol) 106 { 107 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 108 struct pmac_daca *mix; 109 if (! (mix = chip->mixer_data)) 110 return -ENODEV; 111 ucontrol->value.integer.value[0] = mix->deemphasis ? 1 : 0; 112 return 0; 113 } 114 115 static int daca_put_deemphasis(struct snd_kcontrol *kcontrol, 116 struct snd_ctl_elem_value *ucontrol) 117 { 118 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 119 struct pmac_daca *mix; 120 int change; 121 122 if (! (mix = chip->mixer_data)) 123 return -ENODEV; 124 change = mix->deemphasis != ucontrol->value.integer.value[0]; 125 if (change) { 126 mix->deemphasis = ucontrol->value.integer.value[0]; 127 daca_set_volume(mix); 128 } 129 return change; 130 } 131 132 /* output volume */ 133 static int daca_info_volume(struct snd_kcontrol *kcontrol, 134 struct snd_ctl_elem_info *uinfo) 135 { 136 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 137 uinfo->count = 2; 138 uinfo->value.integer.min = 0; 139 uinfo->value.integer.max = DACA_VOL_MAX; 140 return 0; 141 } 142 143 static int daca_get_volume(struct snd_kcontrol *kcontrol, 144 struct snd_ctl_elem_value *ucontrol) 145 { 146 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 147 struct pmac_daca *mix; 148 if (! (mix = chip->mixer_data)) 149 return -ENODEV; 150 ucontrol->value.integer.value[0] = mix->left_vol; 151 ucontrol->value.integer.value[1] = mix->right_vol; 152 return 0; 153 } 154 155 static int daca_put_volume(struct snd_kcontrol *kcontrol, 156 struct snd_ctl_elem_value *ucontrol) 157 { 158 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 159 struct pmac_daca *mix; 160 int change; 161 162 if (! (mix = chip->mixer_data)) 163 return -ENODEV; 164 change = mix->left_vol != ucontrol->value.integer.value[0] || 165 mix->right_vol != ucontrol->value.integer.value[1]; 166 if (change) { 167 mix->left_vol = ucontrol->value.integer.value[0]; 168 mix->right_vol = ucontrol->value.integer.value[1]; 169 daca_set_volume(mix); 170 } 171 return change; 172 } 173 174 /* amplifier switch */ 175 #define daca_info_amp daca_info_deemphasis 176 177 static int daca_get_amp(struct snd_kcontrol *kcontrol, 178 struct snd_ctl_elem_value *ucontrol) 179 { 180 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 181 struct pmac_daca *mix; 182 if (! (mix = chip->mixer_data)) 183 return -ENODEV; 184 ucontrol->value.integer.value[0] = mix->amp_on ? 1 : 0; 185 return 0; 186 } 187 188 static int daca_put_amp(struct snd_kcontrol *kcontrol, 189 struct snd_ctl_elem_value *ucontrol) 190 { 191 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 192 struct pmac_daca *mix; 193 int change; 194 195 if (! (mix = chip->mixer_data)) 196 return -ENODEV; 197 change = mix->amp_on != ucontrol->value.integer.value[0]; 198 if (change) { 199 mix->amp_on = ucontrol->value.integer.value[0]; 200 i2c_smbus_write_byte_data(mix->i2c.client, DACA_REG_GCFG, 201 mix->amp_on ? 0x05 : 0x04); 202 } 203 return change; 204 } 205 206 static struct snd_kcontrol_new daca_mixers[] = { 207 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 208 .name = "Deemphasis Switch", 209 .info = daca_info_deemphasis, 210 .get = daca_get_deemphasis, 211 .put = daca_put_deemphasis 212 }, 213 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 214 .name = "Master Playback Volume", 215 .info = daca_info_volume, 216 .get = daca_get_volume, 217 .put = daca_put_volume 218 }, 219 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 220 .name = "Power Amplifier Switch", 221 .info = daca_info_amp, 222 .get = daca_get_amp, 223 .put = daca_put_amp 224 }, 225 }; 226 227 228 #ifdef CONFIG_PM 229 static void daca_resume(struct snd_pmac *chip) 230 { 231 struct pmac_daca *mix = chip->mixer_data; 232 i2c_smbus_write_byte_data(mix->i2c.client, DACA_REG_SR, 0x08); 233 i2c_smbus_write_byte_data(mix->i2c.client, DACA_REG_GCFG, 234 mix->amp_on ? 0x05 : 0x04); 235 daca_set_volume(mix); 236 } 237 #endif /* CONFIG_PM */ 238 239 240 static void daca_cleanup(struct snd_pmac *chip) 241 { 242 struct pmac_daca *mix = chip->mixer_data; 243 if (! mix) 244 return; 245 snd_pmac_keywest_cleanup(&mix->i2c); 246 kfree(mix); 247 chip->mixer_data = NULL; 248 } 249 250 /* exported */ 251 int __init snd_pmac_daca_init(struct snd_pmac *chip) 252 { 253 int i, err; 254 struct pmac_daca *mix; 255 256 #ifdef CONFIG_KMOD 257 if (current->fs->root) 258 request_module("i2c-powermac"); 259 #endif /* CONFIG_KMOD */ 260 261 mix = kzalloc(sizeof(*mix), GFP_KERNEL); 262 if (! mix) 263 return -ENOMEM; 264 chip->mixer_data = mix; 265 chip->mixer_free = daca_cleanup; 266 mix->amp_on = 1; /* default on */ 267 268 mix->i2c.addr = DACA_I2C_ADDR; 269 mix->i2c.init_client = daca_init_client; 270 mix->i2c.name = "DACA"; 271 if ((err = snd_pmac_keywest_init(&mix->i2c)) < 0) 272 return err; 273 274 /* 275 * build mixers 276 */ 277 strcpy(chip->card->mixername, "PowerMac DACA"); 278 279 for (i = 0; i < ARRAY_SIZE(daca_mixers); i++) { 280 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&daca_mixers[i], chip))) < 0) 281 return err; 282 } 283 284 #ifdef CONFIG_PM 285 chip->resume = daca_resume; 286 #endif 287 288 return 0; 289 } 290