[ALSA] Add even more 'const' to everything related to TLV
[linux-2.6.git] / sound / i2c / other / pt2258.c
1 /*
2  *   ALSA Driver for the PT2258 volume controller.
3  *
4  *      Copyright (c) 2006  Jochen Voss <voss@seehuhn.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 <sound/core.h>
24 #include <sound/control.h>
25 #include <sound/tlv.h>
26 #include <sound/i2c.h>
27 #include <sound/pt2258.h>
28
29 MODULE_AUTHOR("Jochen Voss <voss@seehuhn.de>");
30 MODULE_DESCRIPTION("PT2258 volume controller (Princeton Technology Corp.)");
31 MODULE_LICENSE("GPL");
32
33 #define PT2258_CMD_RESET 0xc0
34 #define PT2258_CMD_UNMUTE 0xf8
35 #define PT2258_CMD_MUTE 0xf9
36
37 static const unsigned char pt2258_channel_code[12] = {
38         0x80, 0x90,             /* channel 1: -10dB, -1dB */
39         0x40, 0x50,             /* channel 2: -10dB, -1dB */
40         0x00, 0x10,             /* channel 3: -10dB, -1dB */
41         0x20, 0x30,             /* channel 4: -10dB, -1dB */
42         0x60, 0x70,             /* channel 5: -10dB, -1dB */
43         0xa0, 0xb0              /* channel 6: -10dB, -1dB */
44 };
45
46 int snd_pt2258_reset(struct snd_pt2258 *pt)
47 {
48         unsigned char bytes[2];
49         int i;
50
51         /* reset chip */
52         bytes[0] = PT2258_CMD_RESET;
53         snd_i2c_lock(pt->i2c_bus);
54         if (snd_i2c_sendbytes(pt->i2c_dev, bytes, 1) != 1)
55                 goto __error;
56         snd_i2c_unlock(pt->i2c_bus);
57
58         /* mute all channels */
59         pt->mute = 1;
60         bytes[0] = PT2258_CMD_MUTE;
61         snd_i2c_lock(pt->i2c_bus);
62         if (snd_i2c_sendbytes(pt->i2c_dev, bytes, 1) != 1)
63                 goto __error;
64         snd_i2c_unlock(pt->i2c_bus);
65
66         /* set all channels to 0dB */
67         for (i = 0; i < 6; ++i)
68                 pt->volume[i] = 0;
69         bytes[0] = 0xd0;
70         bytes[1] = 0xe0;
71         snd_i2c_lock(pt->i2c_bus);
72         if (snd_i2c_sendbytes(pt->i2c_dev, bytes, 2) != 2)
73                 goto __error;
74         snd_i2c_unlock(pt->i2c_bus);
75
76         return 0;
77
78       __error:
79         snd_i2c_unlock(pt->i2c_bus);
80         snd_printk(KERN_ERR "PT2258 reset failed\n");
81         return -EIO;
82 }
83
84 static int pt2258_stereo_volume_info(struct snd_kcontrol *kcontrol,
85                                      struct snd_ctl_elem_info *uinfo)
86 {
87         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
88         uinfo->count = 2;
89         uinfo->value.integer.min = 0;
90         uinfo->value.integer.max = 79;
91         return 0;
92 }
93
94 static int pt2258_stereo_volume_get(struct snd_kcontrol *kcontrol,
95                                     struct snd_ctl_elem_value *ucontrol)
96 {
97         struct snd_pt2258 *pt = kcontrol->private_data;
98         int base = kcontrol->private_value;
99
100         /* chip does not support register reads */
101         ucontrol->value.integer.value[0] = 79 - pt->volume[base];
102         ucontrol->value.integer.value[1] = 79 - pt->volume[base + 1];
103         return 0;
104 }
105
106 static int pt2258_stereo_volume_put(struct snd_kcontrol *kcontrol,
107                                     struct snd_ctl_elem_value *ucontrol)
108 {
109         struct snd_pt2258 *pt = kcontrol->private_data;
110         int base = kcontrol->private_value;
111         unsigned char bytes[2];
112         int val0, val1;
113
114         val0 = 79 - ucontrol->value.integer.value[0];
115         val1 = 79 - ucontrol->value.integer.value[1];
116         if (val0 == pt->volume[base] && val1 == pt->volume[base + 1])
117                 return 0;
118
119         pt->volume[base] = val0;
120         bytes[0] = pt2258_channel_code[2 * base] | (val0 / 10);
121         bytes[1] = pt2258_channel_code[2 * base + 1] | (val0 % 10);
122         snd_i2c_lock(pt->i2c_bus);
123         if (snd_i2c_sendbytes(pt->i2c_dev, bytes, 2) != 2)
124                 goto __error;
125         snd_i2c_unlock(pt->i2c_bus);
126
127         pt->volume[base + 1] = val1;
128         bytes[0] = pt2258_channel_code[2 * base + 2] | (val1 / 10);
129         bytes[1] = pt2258_channel_code[2 * base + 3] | (val1 % 10);
130         snd_i2c_lock(pt->i2c_bus);
131         if (snd_i2c_sendbytes(pt->i2c_dev, bytes, 2) != 2)
132                 goto __error;
133         snd_i2c_unlock(pt->i2c_bus);
134
135         return 1;
136
137       __error:
138         snd_i2c_unlock(pt->i2c_bus);
139         snd_printk(KERN_ERR "PT2258 access failed\n");
140         return -EIO;
141 }
142
143 static int pt2258_switch_info(struct snd_kcontrol *kcontrol,
144                               struct snd_ctl_elem_info *uinfo)
145 {
146         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
147         uinfo->count = 1;
148         uinfo->value.integer.min = 0;
149         uinfo->value.integer.max = 1;
150         return 0;
151 }
152
153 static int pt2258_switch_get(struct snd_kcontrol *kcontrol,
154                              struct snd_ctl_elem_value *ucontrol)
155 {
156         struct snd_pt2258 *pt = kcontrol->private_data;
157
158         ucontrol->value.integer.value[0] = !pt->mute;
159         return 0;
160 }
161
162 static int pt2258_switch_put(struct snd_kcontrol *kcontrol,
163                              struct snd_ctl_elem_value *ucontrol)
164 {
165         struct snd_pt2258 *pt = kcontrol->private_data;
166         unsigned char bytes[2];
167         int val;
168
169         val = !ucontrol->value.integer.value[0];
170         if (pt->mute == val)
171                 return 0;
172
173         pt->mute = val;
174         bytes[0] = val ? PT2258_CMD_MUTE : PT2258_CMD_UNMUTE;
175         snd_i2c_lock(pt->i2c_bus);
176         if (snd_i2c_sendbytes(pt->i2c_dev, bytes, 1) != 1)
177                 goto __error;
178         snd_i2c_unlock(pt->i2c_bus);
179
180         return 1;
181
182       __error:
183         snd_i2c_unlock(pt->i2c_bus);
184         snd_printk(KERN_ERR "PT2258 access failed 2\n");
185         return -EIO;
186 }
187
188 static const DECLARE_TLV_DB_SCALE(pt2258_db_scale, -7900, 100, 0);
189
190 int snd_pt2258_build_controls(struct snd_pt2258 *pt)
191 {
192         struct snd_kcontrol_new knew;
193         char *names[3] = {
194                 "Mic Loopback Playback Volume",
195                 "Line Loopback Playback Volume",
196                 "CD Loopback Playback Volume"
197         };
198         int i, err;
199
200         for (i = 0; i < 3; ++i) {
201                 memset(&knew, 0, sizeof(knew));
202                 knew.name = names[i];
203                 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
204                 knew.count = 1;
205                 knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
206                     SNDRV_CTL_ELEM_ACCESS_TLV_READ;
207                 knew.private_value = 2 * i;
208                 knew.info = pt2258_stereo_volume_info;
209                 knew.get = pt2258_stereo_volume_get;
210                 knew.put = pt2258_stereo_volume_put;
211                 knew.tlv.p = pt2258_db_scale;
212
213                 err = snd_ctl_add(pt->card, snd_ctl_new1(&knew, pt));
214                 if (err < 0)
215                         return err;
216         }
217
218         memset(&knew, 0, sizeof(knew));
219         knew.name = "Loopback Switch";
220         knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
221         knew.info = pt2258_switch_info;
222         knew.get = pt2258_switch_get;
223         knew.put = pt2258_switch_put;
224         knew.access = 0;
225         err = snd_ctl_add(pt->card, snd_ctl_new1(&knew, pt));
226         if (err < 0)
227                 return err;
228
229         return 0;
230 }
231
232 EXPORT_SYMBOL(snd_pt2258_reset);
233 EXPORT_SYMBOL(snd_pt2258_build_controls);