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