ALSA: hda - Register (new) devices at reconfig
[linux-2.6.git] / sound / pci / hda / hda_hwdep.c
1 /*
2  * HWDEP Interface for HD-audio codec
3  *
4  * Copyright (c) 2007 Takashi Iwai <tiwai@suse.de>
5  *
6  *  This driver 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 driver 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 #include <linux/init.h>
22 #include <linux/slab.h>
23 #include <linux/pci.h>
24 #include <linux/compat.h>
25 #include <linux/mutex.h>
26 #include <linux/ctype.h>
27 #include <sound/core.h>
28 #include "hda_codec.h"
29 #include "hda_local.h"
30 #include <sound/hda_hwdep.h>
31 #include <sound/minors.h>
32
33 /*
34  * write/read an out-of-bound verb
35  */
36 static int verb_write_ioctl(struct hda_codec *codec,
37                             struct hda_verb_ioctl __user *arg)
38 {
39         u32 verb, res;
40
41         if (get_user(verb, &arg->verb))
42                 return -EFAULT;
43         res = snd_hda_codec_read(codec, verb >> 24, 0,
44                                  (verb >> 8) & 0xffff, verb & 0xff);
45         if (put_user(res, &arg->res))
46                 return -EFAULT;
47         return 0;
48 }
49
50 static int get_wcap_ioctl(struct hda_codec *codec,
51                           struct hda_verb_ioctl __user *arg)
52 {
53         u32 verb, res;
54         
55         if (get_user(verb, &arg->verb))
56                 return -EFAULT;
57         res = get_wcaps(codec, verb >> 24);
58         if (put_user(res, &arg->res))
59                 return -EFAULT;
60         return 0;
61 }
62
63
64 /*
65  */
66 static int hda_hwdep_ioctl(struct snd_hwdep *hw, struct file *file,
67                            unsigned int cmd, unsigned long arg)
68 {
69         struct hda_codec *codec = hw->private_data;
70         void __user *argp = (void __user *)arg;
71
72         switch (cmd) {
73         case HDA_IOCTL_PVERSION:
74                 return put_user(HDA_HWDEP_VERSION, (int __user *)argp);
75         case HDA_IOCTL_VERB_WRITE:
76                 return verb_write_ioctl(codec, argp);
77         case HDA_IOCTL_GET_WCAP:
78                 return get_wcap_ioctl(codec, argp);
79         }
80         return -ENOIOCTLCMD;
81 }
82
83 #ifdef CONFIG_COMPAT
84 static int hda_hwdep_ioctl_compat(struct snd_hwdep *hw, struct file *file,
85                                   unsigned int cmd, unsigned long arg)
86 {
87         return hda_hwdep_ioctl(hw, file, cmd, (unsigned long)compat_ptr(arg));
88 }
89 #endif
90
91 static int hda_hwdep_open(struct snd_hwdep *hw, struct file *file)
92 {
93 #ifndef CONFIG_SND_DEBUG_VERBOSE
94         if (!capable(CAP_SYS_RAWIO))
95                 return -EACCES;
96 #endif
97         return 0;
98 }
99
100 static void clear_hwdep_elements(struct hda_codec *codec)
101 {
102         char **head;
103         int i;
104
105         /* clear init verbs */
106         snd_array_free(&codec->init_verbs);
107         /* clear hints */
108         head = codec->hints.list;
109         for (i = 0; i < codec->hints.used; i++, head++)
110                 kfree(*head);
111         snd_array_free(&codec->hints);
112 }
113
114 static void hwdep_free(struct snd_hwdep *hwdep)
115 {
116         clear_hwdep_elements(hwdep->private_data);
117 }
118
119 int /*__devinit*/ snd_hda_create_hwdep(struct hda_codec *codec)
120 {
121         char hwname[16];
122         struct snd_hwdep *hwdep;
123         int err;
124
125         sprintf(hwname, "HDA Codec %d", codec->addr);
126         err = snd_hwdep_new(codec->bus->card, hwname, codec->addr, &hwdep);
127         if (err < 0)
128                 return err;
129         codec->hwdep = hwdep;
130         sprintf(hwdep->name, "HDA Codec %d", codec->addr);
131         hwdep->iface = SNDRV_HWDEP_IFACE_HDA;
132         hwdep->private_data = codec;
133         hwdep->private_free = hwdep_free;
134         hwdep->exclusive = 1;
135
136         hwdep->ops.open = hda_hwdep_open;
137         hwdep->ops.ioctl = hda_hwdep_ioctl;
138 #ifdef CONFIG_COMPAT
139         hwdep->ops.ioctl_compat = hda_hwdep_ioctl_compat;
140 #endif
141
142         snd_array_init(&codec->init_verbs, sizeof(struct hda_verb), 32);
143         snd_array_init(&codec->hints, sizeof(char *), 32);
144
145         return 0;
146 }
147
148 #ifdef CONFIG_SND_HDA_RECONFIG
149
150 /*
151  * sysfs interface
152  */
153
154 static int clear_codec(struct hda_codec *codec)
155 {
156         snd_hda_codec_reset(codec);
157         clear_hwdep_elements(codec);
158         return 0;
159 }
160
161 static int reconfig_codec(struct hda_codec *codec)
162 {
163         int err;
164
165         snd_printk(KERN_INFO "hda-codec: reconfiguring\n");
166         snd_hda_codec_reset(codec);
167         err = snd_hda_codec_configure(codec);
168         if (err < 0)
169                 return err;
170         /* rebuild PCMs */
171         err = snd_hda_codec_build_pcms(codec);
172         if (err < 0)
173                 return err;
174         /* rebuild mixers */
175         err = snd_hda_codec_build_controls(codec);
176         if (err < 0)
177                 return err;
178         return snd_card_register(codec->bus->card);
179 }
180
181 /*
182  * allocate a string at most len chars, and remove the trailing EOL
183  */
184 static char *kstrndup_noeol(const char *src, size_t len)
185 {
186         char *s = kstrndup(src, len, GFP_KERNEL);
187         char *p;
188         if (!s)
189                 return NULL;
190         p = strchr(s, '\n');
191         if (p)
192                 *p = 0;
193         return s;
194 }
195
196 #define CODEC_INFO_SHOW(type)                                   \
197 static ssize_t type##_show(struct device *dev,                  \
198                            struct device_attribute *attr,       \
199                            char *buf)                           \
200 {                                                               \
201         struct snd_hwdep *hwdep = dev_get_drvdata(dev);         \
202         struct hda_codec *codec = hwdep->private_data;          \
203         return sprintf(buf, "0x%x\n", codec->type);             \
204 }
205
206 #define CODEC_INFO_STR_SHOW(type)                               \
207 static ssize_t type##_show(struct device *dev,                  \
208                              struct device_attribute *attr,     \
209                                         char *buf)              \
210 {                                                               \
211         struct snd_hwdep *hwdep = dev_get_drvdata(dev);         \
212         struct hda_codec *codec = hwdep->private_data;          \
213         return sprintf(buf, "%s\n",                             \
214                        codec->type ? codec->type : "");         \
215 }
216
217 CODEC_INFO_SHOW(vendor_id);
218 CODEC_INFO_SHOW(subsystem_id);
219 CODEC_INFO_SHOW(revision_id);
220 CODEC_INFO_SHOW(afg);
221 CODEC_INFO_SHOW(mfg);
222 CODEC_INFO_STR_SHOW(name);
223 CODEC_INFO_STR_SHOW(modelname);
224
225 #define CODEC_INFO_STORE(type)                                  \
226 static ssize_t type##_store(struct device *dev,                 \
227                             struct device_attribute *attr,      \
228                             const char *buf, size_t count)      \
229 {                                                               \
230         struct snd_hwdep *hwdep = dev_get_drvdata(dev);         \
231         struct hda_codec *codec = hwdep->private_data;          \
232         char *after;                                            \
233         codec->type = simple_strtoul(buf, &after, 0);           \
234         return count;                                           \
235 }
236
237 #define CODEC_INFO_STR_STORE(type)                              \
238 static ssize_t type##_store(struct device *dev,                 \
239                             struct device_attribute *attr,      \
240                             const char *buf, size_t count)      \
241 {                                                               \
242         struct snd_hwdep *hwdep = dev_get_drvdata(dev);         \
243         struct hda_codec *codec = hwdep->private_data;          \
244         char *s = kstrndup_noeol(buf, 64);                      \
245         if (!s)                                                 \
246                 return -ENOMEM;                                 \
247         kfree(codec->type);                                     \
248         codec->type = s;                                        \
249         return count;                                           \
250 }
251
252 CODEC_INFO_STORE(vendor_id);
253 CODEC_INFO_STORE(subsystem_id);
254 CODEC_INFO_STORE(revision_id);
255 CODEC_INFO_STR_STORE(name);
256 CODEC_INFO_STR_STORE(modelname);
257
258 #define CODEC_ACTION_STORE(type)                                \
259 static ssize_t type##_store(struct device *dev,                 \
260                             struct device_attribute *attr,      \
261                             const char *buf, size_t count)      \
262 {                                                               \
263         struct snd_hwdep *hwdep = dev_get_drvdata(dev);         \
264         struct hda_codec *codec = hwdep->private_data;          \
265         int err = 0;                                            \
266         if (*buf)                                               \
267                 err = type##_codec(codec);                      \
268         return err < 0 ? err : count;                           \
269 }
270
271 CODEC_ACTION_STORE(reconfig);
272 CODEC_ACTION_STORE(clear);
273
274 static ssize_t init_verbs_store(struct device *dev,
275                                 struct device_attribute *attr,
276                                 const char *buf, size_t count)
277 {
278         struct snd_hwdep *hwdep = dev_get_drvdata(dev);
279         struct hda_codec *codec = hwdep->private_data;
280         char *p;
281         struct hda_verb verb, *v;
282
283         verb.nid = simple_strtoul(buf, &p, 0);
284         verb.verb = simple_strtoul(p, &p, 0);
285         verb.param = simple_strtoul(p, &p, 0);
286         if (!verb.nid || !verb.verb || !verb.param)
287                 return -EINVAL;
288         v = snd_array_new(&codec->init_verbs);
289         if (!v)
290                 return -ENOMEM;
291         *v = verb;
292         return count;
293 }
294
295 static ssize_t hints_store(struct device *dev,
296                            struct device_attribute *attr,
297                            const char *buf, size_t count)
298 {
299         struct snd_hwdep *hwdep = dev_get_drvdata(dev);
300         struct hda_codec *codec = hwdep->private_data;
301         char *p;
302         char **hint;
303
304         if (!*buf || isspace(*buf) || *buf == '#' || *buf == '\n')
305                 return count;
306         p = kstrndup_noeol(buf, 1024);
307         if (!p)
308                 return -ENOMEM;
309         hint = snd_array_new(&codec->hints);
310         if (!hint) {
311                 kfree(p);
312                 return -ENOMEM;
313         }
314         *hint = p;
315         return count;
316 }
317
318 #define CODEC_ATTR_RW(type) \
319         __ATTR(type, 0644, type##_show, type##_store)
320 #define CODEC_ATTR_RO(type) \
321         __ATTR_RO(type)
322 #define CODEC_ATTR_WO(type) \
323         __ATTR(type, 0200, NULL, type##_store)
324
325 static struct device_attribute codec_attrs[] = {
326         CODEC_ATTR_RW(vendor_id),
327         CODEC_ATTR_RW(subsystem_id),
328         CODEC_ATTR_RW(revision_id),
329         CODEC_ATTR_RO(afg),
330         CODEC_ATTR_RO(mfg),
331         CODEC_ATTR_RW(name),
332         CODEC_ATTR_RW(modelname),
333         CODEC_ATTR_WO(init_verbs),
334         CODEC_ATTR_WO(hints),
335         CODEC_ATTR_WO(reconfig),
336         CODEC_ATTR_WO(clear),
337 };
338
339 /*
340  * create sysfs files on hwdep directory
341  */
342 int snd_hda_hwdep_add_sysfs(struct hda_codec *codec)
343 {
344         struct snd_hwdep *hwdep = codec->hwdep;
345         int i;
346
347         for (i = 0; i < ARRAY_SIZE(codec_attrs); i++)
348                 snd_add_device_sysfs_file(SNDRV_DEVICE_TYPE_HWDEP, hwdep->card,
349                                           hwdep->device, &codec_attrs[i]);
350         return 0;
351 }
352
353 #endif /* CONFIG_SND_HDA_RECONFIG */