2 * Hardware dependent layer
3 * Copyright (c) by Jaroslav Kysela <perex@suse.cz>
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.
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.
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
22 #include <sound/driver.h>
23 #include <linux/major.h>
24 #include <linux/init.h>
25 #include <linux/smp_lock.h>
26 #include <linux/slab.h>
27 #include <linux/time.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>
34 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
35 MODULE_DESCRIPTION("Hardware dependent layer");
36 MODULE_LICENSE("GPL");
38 static struct snd_hwdep
*snd_hwdep_devices
[SNDRV_CARDS
* SNDRV_MINOR_HWDEPS
];
40 static DECLARE_MUTEX(register_mutex
);
42 static int snd_hwdep_free(struct snd_hwdep
*hwdep
);
43 static int snd_hwdep_dev_free(struct snd_device
*device
);
44 static int snd_hwdep_dev_register(struct snd_device
*device
);
45 static int snd_hwdep_dev_unregister(struct snd_device
*device
);
51 static loff_t
snd_hwdep_llseek(struct file
* file
, loff_t offset
, int orig
)
53 struct snd_hwdep
*hw
= file
->private_data
;
55 return hw
->ops
.llseek(hw
, file
, offset
, orig
);
59 static ssize_t
snd_hwdep_read(struct file
* file
, char __user
*buf
,
60 size_t count
, loff_t
*offset
)
62 struct snd_hwdep
*hw
= file
->private_data
;
64 return hw
->ops
.read(hw
, buf
, count
, offset
);
68 static ssize_t
snd_hwdep_write(struct file
* file
, const char __user
*buf
,
69 size_t count
, loff_t
*offset
)
71 struct snd_hwdep
*hw
= file
->private_data
;
73 return hw
->ops
.write(hw
, buf
, count
, offset
);
77 static int snd_hwdep_open(struct inode
*inode
, struct file
* file
)
79 int major
= imajor(inode
);
86 if (major
== snd_major
) {
87 cardnum
= SNDRV_MINOR_CARD(iminor(inode
));
88 device
= SNDRV_MINOR_DEVICE(iminor(inode
)) - SNDRV_MINOR_HWDEP
;
89 #ifdef CONFIG_SND_OSSEMUL
90 } else if (major
== SOUND_MAJOR
) {
91 cardnum
= SNDRV_MINOR_OSS_CARD(iminor(inode
));
96 cardnum
%= SNDRV_CARDS
;
97 device
%= SNDRV_MINOR_HWDEPS
;
98 hw
= snd_hwdep_devices
[(cardnum
* SNDRV_MINOR_HWDEPS
) + device
];
104 #ifdef CONFIG_SND_OSSEMUL
105 if (major
== SOUND_MAJOR
&& hw
->oss_type
< 0)
109 if (!try_module_get(hw
->card
->module
))
112 init_waitqueue_entry(&wait
, current
);
113 add_wait_queue(&hw
->open_wait
, &wait
);
114 down(&hw
->open_mutex
);
116 if (hw
->exclusive
&& hw
->used
> 0) {
120 err
= hw
->ops
.open(hw
, file
);
123 if (err
== -EAGAIN
) {
124 if (file
->f_flags
& O_NONBLOCK
) {
130 set_current_state(TASK_INTERRUPTIBLE
);
133 down(&hw
->open_mutex
);
134 if (signal_pending(current
)) {
139 remove_wait_queue(&hw
->open_wait
, &wait
);
141 err
= snd_card_file_add(hw
->card
, file
);
143 file
->private_data
= hw
;
147 hw
->ops
.release(hw
, file
);
152 module_put(hw
->card
->module
);
156 static int snd_hwdep_release(struct inode
*inode
, struct file
* file
)
159 struct snd_hwdep
*hw
= file
->private_data
;
160 down(&hw
->open_mutex
);
161 if (hw
->ops
.release
) {
162 err
= hw
->ops
.release(hw
, file
);
163 wake_up(&hw
->open_wait
);
167 snd_card_file_remove(hw
->card
, file
);
169 module_put(hw
->card
->module
);
173 static unsigned int snd_hwdep_poll(struct file
* file
, poll_table
* wait
)
175 struct snd_hwdep
*hw
= file
->private_data
;
177 return hw
->ops
.poll(hw
, file
, wait
);
181 static int snd_hwdep_info(struct snd_hwdep
*hw
,
182 struct snd_hwdep_info __user
*_info
)
184 struct snd_hwdep_info info
;
186 memset(&info
, 0, sizeof(info
));
187 info
.card
= hw
->card
->number
;
188 strlcpy(info
.id
, hw
->id
, sizeof(info
.id
));
189 strlcpy(info
.name
, hw
->name
, sizeof(info
.name
));
190 info
.iface
= hw
->iface
;
191 if (copy_to_user(_info
, &info
, sizeof(info
)))
196 static int snd_hwdep_dsp_status(struct snd_hwdep
*hw
,
197 struct snd_hwdep_dsp_status __user
*_info
)
199 struct snd_hwdep_dsp_status info
;
202 if (! hw
->ops
.dsp_status
)
204 memset(&info
, 0, sizeof(info
));
205 info
.dsp_loaded
= hw
->dsp_loaded
;
206 if ((err
= hw
->ops
.dsp_status(hw
, &info
)) < 0)
208 if (copy_to_user(_info
, &info
, sizeof(info
)))
213 static int snd_hwdep_dsp_load(struct snd_hwdep
*hw
,
214 struct snd_hwdep_dsp_image __user
*_info
)
216 struct snd_hwdep_dsp_image info
;
219 if (! hw
->ops
.dsp_load
)
221 memset(&info
, 0, sizeof(info
));
222 if (copy_from_user(&info
, _info
, sizeof(info
)))
224 /* check whether the dsp was already loaded */
225 if (hw
->dsp_loaded
& (1 << info
.index
))
227 if (!access_ok(VERIFY_READ
, info
.image
, info
.length
))
229 err
= hw
->ops
.dsp_load(hw
, &info
);
232 hw
->dsp_loaded
|= (1 << info
.index
);
236 static long snd_hwdep_ioctl(struct file
* file
, unsigned int cmd
,
239 struct snd_hwdep
*hw
= file
->private_data
;
240 void __user
*argp
= (void __user
*)arg
;
242 case SNDRV_HWDEP_IOCTL_PVERSION
:
243 return put_user(SNDRV_HWDEP_VERSION
, (int __user
*)argp
);
244 case SNDRV_HWDEP_IOCTL_INFO
:
245 return snd_hwdep_info(hw
, argp
);
246 case SNDRV_HWDEP_IOCTL_DSP_STATUS
:
247 return snd_hwdep_dsp_status(hw
, argp
);
248 case SNDRV_HWDEP_IOCTL_DSP_LOAD
:
249 return snd_hwdep_dsp_load(hw
, argp
);
252 return hw
->ops
.ioctl(hw
, file
, cmd
, arg
);
256 static int snd_hwdep_mmap(struct file
* file
, struct vm_area_struct
* vma
)
258 struct snd_hwdep
*hw
= file
->private_data
;
260 return hw
->ops
.mmap(hw
, file
, vma
);
264 static int snd_hwdep_control_ioctl(struct snd_card
*card
,
265 struct snd_ctl_file
* control
,
266 unsigned int cmd
, unsigned long arg
)
270 tmp
= card
->number
* SNDRV_MINOR_HWDEPS
;
272 case SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE
:
276 if (get_user(device
, (int __user
*)arg
))
278 device
= device
< 0 ? 0 : device
+ 1;
279 while (device
< SNDRV_MINOR_HWDEPS
) {
280 if (snd_hwdep_devices
[tmp
+ device
])
284 if (device
>= SNDRV_MINOR_HWDEPS
)
286 if (put_user(device
, (int __user
*)arg
))
290 case SNDRV_CTL_IOCTL_HWDEP_INFO
:
292 struct snd_hwdep_info __user
*info
= (struct snd_hwdep_info __user
*)arg
;
294 struct snd_hwdep
*hwdep
;
296 if (get_user(device
, &info
->device
))
298 if (device
< 0 || device
>= SNDRV_MINOR_HWDEPS
)
300 hwdep
= snd_hwdep_devices
[tmp
+ device
];
303 return snd_hwdep_info(hwdep
, info
);
310 #include "hwdep_compat.c"
312 #define snd_hwdep_ioctl_compat NULL
319 static struct file_operations snd_hwdep_f_ops
=
321 .owner
= THIS_MODULE
,
322 .llseek
= snd_hwdep_llseek
,
323 .read
= snd_hwdep_read
,
324 .write
= snd_hwdep_write
,
325 .open
= snd_hwdep_open
,
326 .release
= snd_hwdep_release
,
327 .poll
= snd_hwdep_poll
,
328 .unlocked_ioctl
= snd_hwdep_ioctl
,
329 .compat_ioctl
= snd_hwdep_ioctl_compat
,
330 .mmap
= snd_hwdep_mmap
,
333 static struct snd_minor snd_hwdep_reg
=
335 .comment
= "hardware dependent",
336 .f_ops
= &snd_hwdep_f_ops
,
340 * snd_hwdep_new - create a new hwdep instance
341 * @card: the card instance
343 * @device: the device index (zero-based)
344 * @rhwdep: the pointer to store the new hwdep instance
346 * Creates a new hwdep instance with the given index on the card.
347 * The callbacks (hwdep->ops) must be set on the returned instance
348 * after this call manually by the caller.
350 * Returns zero if successful, or a negative error code on failure.
352 int snd_hwdep_new(struct snd_card
*card
, char *id
, int device
,
353 struct snd_hwdep
**rhwdep
)
355 struct snd_hwdep
*hwdep
;
357 static struct snd_device_ops ops
= {
358 .dev_free
= snd_hwdep_dev_free
,
359 .dev_register
= snd_hwdep_dev_register
,
360 .dev_unregister
= snd_hwdep_dev_unregister
363 snd_assert(rhwdep
!= NULL
, return -EINVAL
);
365 snd_assert(card
!= NULL
, return -ENXIO
);
366 hwdep
= kzalloc(sizeof(*hwdep
), GFP_KERNEL
);
368 snd_printk(KERN_ERR
"hwdep: cannot allocate\n");
372 hwdep
->device
= device
;
374 strlcpy(hwdep
->id
, id
, sizeof(hwdep
->id
));
375 #ifdef CONFIG_SND_OSSEMUL
376 hwdep
->oss_type
= -1;
378 if ((err
= snd_device_new(card
, SNDRV_DEV_HWDEP
, hwdep
, &ops
)) < 0) {
379 snd_hwdep_free(hwdep
);
382 init_waitqueue_head(&hwdep
->open_wait
);
383 init_MUTEX(&hwdep
->open_mutex
);
388 static int snd_hwdep_free(struct snd_hwdep
*hwdep
)
390 snd_assert(hwdep
!= NULL
, return -ENXIO
);
391 if (hwdep
->private_free
)
392 hwdep
->private_free(hwdep
);
397 static int snd_hwdep_dev_free(struct snd_device
*device
)
399 struct snd_hwdep
*hwdep
= device
->device_data
;
400 return snd_hwdep_free(hwdep
);
403 static int snd_hwdep_dev_register(struct snd_device
*device
)
405 struct snd_hwdep
*hwdep
= device
->device_data
;
409 down(®ister_mutex
);
410 idx
= (hwdep
->card
->number
* SNDRV_MINOR_HWDEPS
) + hwdep
->device
;
411 if (snd_hwdep_devices
[idx
]) {
415 snd_hwdep_devices
[idx
] = hwdep
;
416 sprintf(name
, "hwC%iD%i", hwdep
->card
->number
, hwdep
->device
);
417 if ((err
= snd_register_device(SNDRV_DEVICE_TYPE_HWDEP
,
418 hwdep
->card
, hwdep
->device
,
419 &snd_hwdep_reg
, name
)) < 0) {
420 snd_printk(KERN_ERR
"unable to register hardware dependent device %i:%i\n",
421 hwdep
->card
->number
, hwdep
->device
);
422 snd_hwdep_devices
[idx
] = NULL
;
426 #ifdef CONFIG_SND_OSSEMUL
428 if (hwdep
->oss_type
>= 0) {
429 if ((hwdep
->oss_type
== SNDRV_OSS_DEVICE_TYPE_DMFM
) && (hwdep
->device
!= 0)) {
430 snd_printk (KERN_WARNING
"only hwdep device 0 can be registered as OSS direct FM device!\n");
432 if (snd_register_oss_device(hwdep
->oss_type
,
433 hwdep
->card
, hwdep
->device
,
434 &snd_hwdep_reg
, hwdep
->oss_dev
) < 0) {
435 snd_printk(KERN_ERR
"unable to register OSS compatibility device %i:%i\n",
436 hwdep
->card
->number
, hwdep
->device
);
446 static int snd_hwdep_dev_unregister(struct snd_device
*device
)
448 struct snd_hwdep
*hwdep
= device
->device_data
;
451 snd_assert(hwdep
!= NULL
, return -ENXIO
);
452 down(®ister_mutex
);
453 idx
= (hwdep
->card
->number
* SNDRV_MINOR_HWDEPS
) + hwdep
->device
;
454 if (snd_hwdep_devices
[idx
] != hwdep
) {
458 #ifdef CONFIG_SND_OSSEMUL
460 snd_unregister_oss_device(hwdep
->oss_type
, hwdep
->card
, hwdep
->device
);
462 snd_unregister_device(SNDRV_DEVICE_TYPE_HWDEP
, hwdep
->card
, hwdep
->device
);
463 snd_hwdep_devices
[idx
] = NULL
;
465 return snd_hwdep_free(hwdep
);
472 static void snd_hwdep_proc_read(struct snd_info_entry
*entry
,
473 struct snd_info_buffer
*buffer
)
476 struct snd_hwdep
*hwdep
;
478 down(®ister_mutex
);
479 for (idx
= 0; idx
< SNDRV_CARDS
* SNDRV_MINOR_HWDEPS
; idx
++) {
480 hwdep
= snd_hwdep_devices
[idx
];
483 snd_iprintf(buffer
, "%02i-%02i: %s\n",
484 idx
/ SNDRV_MINOR_HWDEPS
,
485 idx
% SNDRV_MINOR_HWDEPS
,
495 static struct snd_info_entry
*snd_hwdep_proc_entry
= NULL
;
497 static int __init
alsa_hwdep_init(void)
499 struct snd_info_entry
*entry
;
501 memset(snd_hwdep_devices
, 0, sizeof(snd_hwdep_devices
));
502 if ((entry
= snd_info_create_module_entry(THIS_MODULE
, "hwdep", NULL
)) != NULL
) {
503 entry
->c
.text
.read_size
= 512;
504 entry
->c
.text
.read
= snd_hwdep_proc_read
;
505 if (snd_info_register(entry
) < 0) {
506 snd_info_free_entry(entry
);
510 snd_hwdep_proc_entry
= entry
;
511 snd_ctl_register_ioctl(snd_hwdep_control_ioctl
);
512 snd_ctl_register_ioctl_compat(snd_hwdep_control_ioctl
);
516 static void __exit
alsa_hwdep_exit(void)
518 snd_ctl_unregister_ioctl(snd_hwdep_control_ioctl
);
519 snd_ctl_unregister_ioctl_compat(snd_hwdep_control_ioctl
);
520 if (snd_hwdep_proc_entry
) {
521 snd_info_unregister(snd_hwdep_proc_entry
);
522 snd_hwdep_proc_entry
= NULL
;
526 module_init(alsa_hwdep_init
)
527 module_exit(alsa_hwdep_exit
)
529 EXPORT_SYMBOL(snd_hwdep_new
);