1/*
2 *  Hardware dependent layer
3 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
4 *
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 <linux/major.h>
23#include <linux/init.h>
24#include <linux/slab.h>
25#include <linux/time.h>
26#include <linux/mutex.h>
27#include <linux/module.h>
28#include <sound/core.h>
29#include <sound/control.h>
30#include <sound/minors.h>
31#include <sound/hwdep.h>
32#include <sound/info.h>
33
34MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
35MODULE_DESCRIPTION("Hardware dependent layer");
36MODULE_LICENSE("GPL");
37
38static LIST_HEAD(snd_hwdep_devices);
39static DEFINE_MUTEX(register_mutex);
40
41static int snd_hwdep_dev_free(struct snd_device *device);
42static int snd_hwdep_dev_register(struct snd_device *device);
43static int snd_hwdep_dev_disconnect(struct snd_device *device);
44
45
46static struct snd_hwdep *snd_hwdep_search(struct snd_card *card, int device)
47{
48	struct snd_hwdep *hwdep;
49
50	list_for_each_entry(hwdep, &snd_hwdep_devices, list)
51		if (hwdep->card == card && hwdep->device == device)
52			return hwdep;
53	return NULL;
54}
55
56static loff_t snd_hwdep_llseek(struct file * file, loff_t offset, int orig)
57{
58	struct snd_hwdep *hw = file->private_data;
59	if (hw->ops.llseek)
60		return hw->ops.llseek(hw, file, offset, orig);
61	return -ENXIO;
62}
63
64static ssize_t snd_hwdep_read(struct file * file, char __user *buf,
65			      size_t count, loff_t *offset)
66{
67	struct snd_hwdep *hw = file->private_data;
68	if (hw->ops.read)
69		return hw->ops.read(hw, buf, count, offset);
70	return -ENXIO;
71}
72
73static ssize_t snd_hwdep_write(struct file * file, const char __user *buf,
74			       size_t count, loff_t *offset)
75{
76	struct snd_hwdep *hw = file->private_data;
77	if (hw->ops.write)
78		return hw->ops.write(hw, buf, count, offset);
79	return -ENXIO;
80}
81
82static int snd_hwdep_open(struct inode *inode, struct file * file)
83{
84	int major = imajor(inode);
85	struct snd_hwdep *hw;
86	int err;
87	wait_queue_t wait;
88
89	if (major == snd_major) {
90		hw = snd_lookup_minor_data(iminor(inode),
91					   SNDRV_DEVICE_TYPE_HWDEP);
92#ifdef CONFIG_SND_OSSEMUL
93	} else if (major == SOUND_MAJOR) {
94		hw = snd_lookup_oss_minor_data(iminor(inode),
95					       SNDRV_OSS_DEVICE_TYPE_DMFM);
96#endif
97	} else
98		return -ENXIO;
99	if (hw == NULL)
100		return -ENODEV;
101
102	if (!try_module_get(hw->card->module)) {
103		snd_card_unref(hw->card);
104		return -EFAULT;
105	}
106
107	init_waitqueue_entry(&wait, current);
108	add_wait_queue(&hw->open_wait, &wait);
109	mutex_lock(&hw->open_mutex);
110	while (1) {
111		if (hw->exclusive && hw->used > 0) {
112			err = -EBUSY;
113			break;
114		}
115		if (!hw->ops.open) {
116			err = 0;
117			break;
118		}
119		err = hw->ops.open(hw, file);
120		if (err >= 0)
121			break;
122		if (err == -EAGAIN) {
123			if (file->f_flags & O_NONBLOCK) {
124				err = -EBUSY;
125				break;
126			}
127		} else
128			break;
129		set_current_state(TASK_INTERRUPTIBLE);
130		mutex_unlock(&hw->open_mutex);
131		schedule();
132		mutex_lock(&hw->open_mutex);
133		if (hw->card->shutdown) {
134			err = -ENODEV;
135			break;
136		}
137		if (signal_pending(current)) {
138			err = -ERESTARTSYS;
139			break;
140		}
141	}
142	remove_wait_queue(&hw->open_wait, &wait);
143	if (err >= 0) {
144		err = snd_card_file_add(hw->card, file);
145		if (err >= 0) {
146			file->private_data = hw;
147			hw->used++;
148		} else {
149			if (hw->ops.release)
150				hw->ops.release(hw, file);
151		}
152	}
153	mutex_unlock(&hw->open_mutex);
154	if (err < 0)
155		module_put(hw->card->module);
156	snd_card_unref(hw->card);
157	return err;
158}
159
160static int snd_hwdep_release(struct inode *inode, struct file * file)
161{
162	int err = 0;
163	struct snd_hwdep *hw = file->private_data;
164	struct module *mod = hw->card->module;
165
166	mutex_lock(&hw->open_mutex);
167	if (hw->ops.release)
168		err = hw->ops.release(hw, file);
169	if (hw->used > 0)
170		hw->used--;
171	mutex_unlock(&hw->open_mutex);
172	wake_up(&hw->open_wait);
173
174	snd_card_file_remove(hw->card, file);
175	module_put(mod);
176	return err;
177}
178
179static unsigned int snd_hwdep_poll(struct file * file, poll_table * wait)
180{
181	struct snd_hwdep *hw = file->private_data;
182	if (hw->ops.poll)
183		return hw->ops.poll(hw, file, wait);
184	return 0;
185}
186
187static int snd_hwdep_info(struct snd_hwdep *hw,
188			  struct snd_hwdep_info __user *_info)
189{
190	struct snd_hwdep_info info;
191
192	memset(&info, 0, sizeof(info));
193	info.card = hw->card->number;
194	strlcpy(info.id, hw->id, sizeof(info.id));
195	strlcpy(info.name, hw->name, sizeof(info.name));
196	info.iface = hw->iface;
197	if (copy_to_user(_info, &info, sizeof(info)))
198		return -EFAULT;
199	return 0;
200}
201
202static int snd_hwdep_dsp_status(struct snd_hwdep *hw,
203				struct snd_hwdep_dsp_status __user *_info)
204{
205	struct snd_hwdep_dsp_status info;
206	int err;
207
208	if (! hw->ops.dsp_status)
209		return -ENXIO;
210	memset(&info, 0, sizeof(info));
211	info.dsp_loaded = hw->dsp_loaded;
212	if ((err = hw->ops.dsp_status(hw, &info)) < 0)
213		return err;
214	if (copy_to_user(_info, &info, sizeof(info)))
215		return -EFAULT;
216	return 0;
217}
218
219static int snd_hwdep_dsp_load(struct snd_hwdep *hw,
220			      struct snd_hwdep_dsp_image __user *_info)
221{
222	struct snd_hwdep_dsp_image info;
223	int err;
224
225	if (! hw->ops.dsp_load)
226		return -ENXIO;
227	memset(&info, 0, sizeof(info));
228	if (copy_from_user(&info, _info, sizeof(info)))
229		return -EFAULT;
230	/* check whether the dsp was already loaded */
231	if (hw->dsp_loaded & (1 << info.index))
232		return -EBUSY;
233	if (!access_ok(VERIFY_READ, info.image, info.length))
234		return -EFAULT;
235	err = hw->ops.dsp_load(hw, &info);
236	if (err < 0)
237		return err;
238	hw->dsp_loaded |= (1 << info.index);
239	return 0;
240}
241
242static long snd_hwdep_ioctl(struct file * file, unsigned int cmd,
243			    unsigned long arg)
244{
245	struct snd_hwdep *hw = file->private_data;
246	void __user *argp = (void __user *)arg;
247	switch (cmd) {
248	case SNDRV_HWDEP_IOCTL_PVERSION:
249		return put_user(SNDRV_HWDEP_VERSION, (int __user *)argp);
250	case SNDRV_HWDEP_IOCTL_INFO:
251		return snd_hwdep_info(hw, argp);
252	case SNDRV_HWDEP_IOCTL_DSP_STATUS:
253		return snd_hwdep_dsp_status(hw, argp);
254	case SNDRV_HWDEP_IOCTL_DSP_LOAD:
255		return snd_hwdep_dsp_load(hw, argp);
256	}
257	if (hw->ops.ioctl)
258		return hw->ops.ioctl(hw, file, cmd, arg);
259	return -ENOTTY;
260}
261
262static int snd_hwdep_mmap(struct file * file, struct vm_area_struct * vma)
263{
264	struct snd_hwdep *hw = file->private_data;
265	if (hw->ops.mmap)
266		return hw->ops.mmap(hw, file, vma);
267	return -ENXIO;
268}
269
270static int snd_hwdep_control_ioctl(struct snd_card *card,
271				   struct snd_ctl_file * control,
272				   unsigned int cmd, unsigned long arg)
273{
274	switch (cmd) {
275	case SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE:
276		{
277			int device;
278
279			if (get_user(device, (int __user *)arg))
280				return -EFAULT;
281			mutex_lock(&register_mutex);
282
283			if (device < 0)
284				device = 0;
285			else if (device < SNDRV_MINOR_HWDEPS)
286				device++;
287			else
288				device = SNDRV_MINOR_HWDEPS;
289
290			while (device < SNDRV_MINOR_HWDEPS) {
291				if (snd_hwdep_search(card, device))
292					break;
293				device++;
294			}
295			if (device >= SNDRV_MINOR_HWDEPS)
296				device = -1;
297			mutex_unlock(&register_mutex);
298			if (put_user(device, (int __user *)arg))
299				return -EFAULT;
300			return 0;
301		}
302	case SNDRV_CTL_IOCTL_HWDEP_INFO:
303		{
304			struct snd_hwdep_info __user *info = (struct snd_hwdep_info __user *)arg;
305			int device, err;
306			struct snd_hwdep *hwdep;
307
308			if (get_user(device, &info->device))
309				return -EFAULT;
310			mutex_lock(&register_mutex);
311			hwdep = snd_hwdep_search(card, device);
312			if (hwdep)
313				err = snd_hwdep_info(hwdep, info);
314			else
315				err = -ENXIO;
316			mutex_unlock(&register_mutex);
317			return err;
318		}
319	}
320	return -ENOIOCTLCMD;
321}
322
323#ifdef CONFIG_COMPAT
324#include "hwdep_compat.c"
325#else
326#define snd_hwdep_ioctl_compat	NULL
327#endif
328
329/*
330
331 */
332
333static const struct file_operations snd_hwdep_f_ops =
334{
335	.owner = 	THIS_MODULE,
336	.llseek =	snd_hwdep_llseek,
337	.read = 	snd_hwdep_read,
338	.write =	snd_hwdep_write,
339	.open =		snd_hwdep_open,
340	.release =	snd_hwdep_release,
341	.poll =		snd_hwdep_poll,
342	.unlocked_ioctl =	snd_hwdep_ioctl,
343	.compat_ioctl =	snd_hwdep_ioctl_compat,
344	.mmap =		snd_hwdep_mmap,
345};
346
347static void release_hwdep_device(struct device *dev)
348{
349	kfree(container_of(dev, struct snd_hwdep, dev));
350}
351
352/**
353 * snd_hwdep_new - create a new hwdep instance
354 * @card: the card instance
355 * @id: the id string
356 * @device: the device index (zero-based)
357 * @rhwdep: the pointer to store the new hwdep instance
358 *
359 * Creates a new hwdep instance with the given index on the card.
360 * The callbacks (hwdep->ops) must be set on the returned instance
361 * after this call manually by the caller.
362 *
363 * Return: Zero if successful, or a negative error code on failure.
364 */
365int snd_hwdep_new(struct snd_card *card, char *id, int device,
366		  struct snd_hwdep **rhwdep)
367{
368	struct snd_hwdep *hwdep;
369	int err;
370	static struct snd_device_ops ops = {
371		.dev_free = snd_hwdep_dev_free,
372		.dev_register = snd_hwdep_dev_register,
373		.dev_disconnect = snd_hwdep_dev_disconnect,
374	};
375
376	if (snd_BUG_ON(!card))
377		return -ENXIO;
378	if (rhwdep)
379		*rhwdep = NULL;
380	hwdep = kzalloc(sizeof(*hwdep), GFP_KERNEL);
381	if (!hwdep)
382		return -ENOMEM;
383
384	init_waitqueue_head(&hwdep->open_wait);
385	mutex_init(&hwdep->open_mutex);
386	hwdep->card = card;
387	hwdep->device = device;
388	if (id)
389		strlcpy(hwdep->id, id, sizeof(hwdep->id));
390
391	snd_device_initialize(&hwdep->dev, card);
392	hwdep->dev.release = release_hwdep_device;
393	dev_set_name(&hwdep->dev, "hwC%iD%i", card->number, device);
394#ifdef CONFIG_SND_OSSEMUL
395	hwdep->oss_type = -1;
396#endif
397
398	err = snd_device_new(card, SNDRV_DEV_HWDEP, hwdep, &ops);
399	if (err < 0) {
400		put_device(&hwdep->dev);
401		return err;
402	}
403
404	if (rhwdep)
405		*rhwdep = hwdep;
406	return 0;
407}
408EXPORT_SYMBOL(snd_hwdep_new);
409
410static int snd_hwdep_dev_free(struct snd_device *device)
411{
412	struct snd_hwdep *hwdep = device->device_data;
413	if (!hwdep)
414		return 0;
415	if (hwdep->private_free)
416		hwdep->private_free(hwdep);
417	put_device(&hwdep->dev);
418	return 0;
419}
420
421static int snd_hwdep_dev_register(struct snd_device *device)
422{
423	struct snd_hwdep *hwdep = device->device_data;
424	struct snd_card *card = hwdep->card;
425	int err;
426
427	mutex_lock(&register_mutex);
428	if (snd_hwdep_search(card, hwdep->device)) {
429		mutex_unlock(&register_mutex);
430		return -EBUSY;
431	}
432	list_add_tail(&hwdep->list, &snd_hwdep_devices);
433	err = snd_register_device(SNDRV_DEVICE_TYPE_HWDEP,
434				  hwdep->card, hwdep->device,
435				  &snd_hwdep_f_ops, hwdep, &hwdep->dev);
436	if (err < 0) {
437		dev_err(&hwdep->dev, "unable to register\n");
438		list_del(&hwdep->list);
439		mutex_unlock(&register_mutex);
440		return err;
441	}
442
443#ifdef CONFIG_SND_OSSEMUL
444	hwdep->ossreg = 0;
445	if (hwdep->oss_type >= 0) {
446		if (hwdep->oss_type == SNDRV_OSS_DEVICE_TYPE_DMFM &&
447		    hwdep->device)
448			dev_warn(&hwdep->dev,
449				 "only hwdep device 0 can be registered as OSS direct FM device!\n");
450		else if (snd_register_oss_device(hwdep->oss_type,
451						 card, hwdep->device,
452						 &snd_hwdep_f_ops, hwdep) < 0)
453			dev_warn(&hwdep->dev,
454				 "unable to register OSS compatibility device\n");
455		else
456			hwdep->ossreg = 1;
457	}
458#endif
459	mutex_unlock(&register_mutex);
460	return 0;
461}
462
463static int snd_hwdep_dev_disconnect(struct snd_device *device)
464{
465	struct snd_hwdep *hwdep = device->device_data;
466
467	if (snd_BUG_ON(!hwdep))
468		return -ENXIO;
469	mutex_lock(&register_mutex);
470	if (snd_hwdep_search(hwdep->card, hwdep->device) != hwdep) {
471		mutex_unlock(&register_mutex);
472		return -EINVAL;
473	}
474	mutex_lock(&hwdep->open_mutex);
475	wake_up(&hwdep->open_wait);
476#ifdef CONFIG_SND_OSSEMUL
477	if (hwdep->ossreg)
478		snd_unregister_oss_device(hwdep->oss_type, hwdep->card, hwdep->device);
479#endif
480	snd_unregister_device(&hwdep->dev);
481	list_del_init(&hwdep->list);
482	mutex_unlock(&hwdep->open_mutex);
483	mutex_unlock(&register_mutex);
484	return 0;
485}
486
487#ifdef CONFIG_PROC_FS
488/*
489 *  Info interface
490 */
491
492static void snd_hwdep_proc_read(struct snd_info_entry *entry,
493				struct snd_info_buffer *buffer)
494{
495	struct snd_hwdep *hwdep;
496
497	mutex_lock(&register_mutex);
498	list_for_each_entry(hwdep, &snd_hwdep_devices, list)
499		snd_iprintf(buffer, "%02i-%02i: %s\n",
500			    hwdep->card->number, hwdep->device, hwdep->name);
501	mutex_unlock(&register_mutex);
502}
503
504static struct snd_info_entry *snd_hwdep_proc_entry;
505
506static void __init snd_hwdep_proc_init(void)
507{
508	struct snd_info_entry *entry;
509
510	if ((entry = snd_info_create_module_entry(THIS_MODULE, "hwdep", NULL)) != NULL) {
511		entry->c.text.read = snd_hwdep_proc_read;
512		if (snd_info_register(entry) < 0) {
513			snd_info_free_entry(entry);
514			entry = NULL;
515		}
516	}
517	snd_hwdep_proc_entry = entry;
518}
519
520static void __exit snd_hwdep_proc_done(void)
521{
522	snd_info_free_entry(snd_hwdep_proc_entry);
523}
524#else /* !CONFIG_PROC_FS */
525#define snd_hwdep_proc_init()
526#define snd_hwdep_proc_done()
527#endif /* CONFIG_PROC_FS */
528
529
530/*
531 *  ENTRY functions
532 */
533
534static int __init alsa_hwdep_init(void)
535{
536	snd_hwdep_proc_init();
537	snd_ctl_register_ioctl(snd_hwdep_control_ioctl);
538	snd_ctl_register_ioctl_compat(snd_hwdep_control_ioctl);
539	return 0;
540}
541
542static void __exit alsa_hwdep_exit(void)
543{
544	snd_ctl_unregister_ioctl(snd_hwdep_control_ioctl);
545	snd_ctl_unregister_ioctl_compat(snd_hwdep_control_ioctl);
546	snd_hwdep_proc_done();
547}
548
549module_init(alsa_hwdep_init)
550module_exit(alsa_hwdep_exit)
551