[POWERPC] Rename get_property to of_get_property: sound
[linux-2.6.git] / sound / ppc / daca.c
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 }