linux/sound/core/pcm.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *  Digital Audio (PCM) abstract layer
   4 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
   5 */
   6
   7#include <linux/init.h>
   8#include <linux/slab.h>
   9#include <linux/module.h>
  10#include <linux/time.h>
  11#include <linux/mutex.h>
  12#include <linux/device.h>
  13#include <linux/nospec.h>
  14#include <sound/core.h>
  15#include <sound/minors.h>
  16#include <sound/pcm.h>
  17#include <sound/timer.h>
  18#include <sound/control.h>
  19#include <sound/info.h>
  20
  21#include "pcm_local.h"
  22
  23MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Abramo Bagnara <abramo@alsa-project.org>");
  24MODULE_DESCRIPTION("Midlevel PCM code for ALSA.");
  25MODULE_LICENSE("GPL");
  26
  27static LIST_HEAD(snd_pcm_devices);
  28static DEFINE_MUTEX(register_mutex);
  29#if IS_ENABLED(CONFIG_SND_PCM_OSS)
  30static LIST_HEAD(snd_pcm_notify_list);
  31#endif
  32
  33static int snd_pcm_free(struct snd_pcm *pcm);
  34static int snd_pcm_dev_free(struct snd_device *device);
  35static int snd_pcm_dev_register(struct snd_device *device);
  36static int snd_pcm_dev_disconnect(struct snd_device *device);
  37
  38static struct snd_pcm *snd_pcm_get(struct snd_card *card, int device)
  39{
  40        struct snd_pcm *pcm;
  41
  42        list_for_each_entry(pcm, &snd_pcm_devices, list) {
  43                if (pcm->card == card && pcm->device == device)
  44                        return pcm;
  45        }
  46        return NULL;
  47}
  48
  49static int snd_pcm_next(struct snd_card *card, int device)
  50{
  51        struct snd_pcm *pcm;
  52
  53        list_for_each_entry(pcm, &snd_pcm_devices, list) {
  54                if (pcm->card == card && pcm->device > device)
  55                        return pcm->device;
  56                else if (pcm->card->number > card->number)
  57                        return -1;
  58        }
  59        return -1;
  60}
  61
  62static int snd_pcm_add(struct snd_pcm *newpcm)
  63{
  64        struct snd_pcm *pcm;
  65
  66        if (newpcm->internal)
  67                return 0;
  68
  69        list_for_each_entry(pcm, &snd_pcm_devices, list) {
  70                if (pcm->card == newpcm->card && pcm->device == newpcm->device)
  71                        return -EBUSY;
  72                if (pcm->card->number > newpcm->card->number ||
  73                                (pcm->card == newpcm->card &&
  74                                pcm->device > newpcm->device)) {
  75                        list_add(&newpcm->list, pcm->list.prev);
  76                        return 0;
  77                }
  78        }
  79        list_add_tail(&newpcm->list, &snd_pcm_devices);
  80        return 0;
  81}
  82
  83static int snd_pcm_control_ioctl(struct snd_card *card,
  84                                 struct snd_ctl_file *control,
  85                                 unsigned int cmd, unsigned long arg)
  86{
  87        switch (cmd) {
  88        case SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE:
  89                {
  90                        int device;
  91
  92                        if (get_user(device, (int __user *)arg))
  93                                return -EFAULT;
  94                        mutex_lock(&register_mutex);
  95                        device = snd_pcm_next(card, device);
  96                        mutex_unlock(&register_mutex);
  97                        if (put_user(device, (int __user *)arg))
  98                                return -EFAULT;
  99                        return 0;
 100                }
 101        case SNDRV_CTL_IOCTL_PCM_INFO:
 102                {
 103                        struct snd_pcm_info __user *info;
 104                        unsigned int device, subdevice;
 105                        int stream;
 106                        struct snd_pcm *pcm;
 107                        struct snd_pcm_str *pstr;
 108                        struct snd_pcm_substream *substream;
 109                        int err;
 110
 111                        info = (struct snd_pcm_info __user *)arg;
 112                        if (get_user(device, &info->device))
 113                                return -EFAULT;
 114                        if (get_user(stream, &info->stream))
 115                                return -EFAULT;
 116                        if (stream < 0 || stream > 1)
 117                                return -EINVAL;
 118                        stream = array_index_nospec(stream, 2);
 119                        if (get_user(subdevice, &info->subdevice))
 120                                return -EFAULT;
 121                        mutex_lock(&register_mutex);
 122                        pcm = snd_pcm_get(card, device);
 123                        if (pcm == NULL) {
 124                                err = -ENXIO;
 125                                goto _error;
 126                        }
 127                        pstr = &pcm->streams[stream];
 128                        if (pstr->substream_count == 0) {
 129                                err = -ENOENT;
 130                                goto _error;
 131                        }
 132                        if (subdevice >= pstr->substream_count) {
 133                                err = -ENXIO;
 134                                goto _error;
 135                        }
 136                        for (substream = pstr->substream; substream;
 137                             substream = substream->next)
 138                                if (substream->number == (int)subdevice)
 139                                        break;
 140                        if (substream == NULL) {
 141                                err = -ENXIO;
 142                                goto _error;
 143                        }
 144                        mutex_lock(&pcm->open_mutex);
 145                        err = snd_pcm_info_user(substream, info);
 146                        mutex_unlock(&pcm->open_mutex);
 147                _error:
 148                        mutex_unlock(&register_mutex);
 149                        return err;
 150                }
 151        case SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE:
 152                {
 153                        int val;
 154                        
 155                        if (get_user(val, (int __user *)arg))
 156                                return -EFAULT;
 157                        control->preferred_subdevice[SND_CTL_SUBDEV_PCM] = val;
 158                        return 0;
 159                }
 160        }
 161        return -ENOIOCTLCMD;
 162}
 163
 164#define FORMAT(v) [SNDRV_PCM_FORMAT_##v] = #v
 165
 166static const char * const snd_pcm_format_names[] = {
 167        FORMAT(S8),
 168        FORMAT(U8),
 169        FORMAT(S16_LE),
 170        FORMAT(S16_BE),
 171        FORMAT(U16_LE),
 172        FORMAT(U16_BE),
 173        FORMAT(S24_LE),
 174        FORMAT(S24_BE),
 175        FORMAT(U24_LE),
 176        FORMAT(U24_BE),
 177        FORMAT(S32_LE),
 178        FORMAT(S32_BE),
 179        FORMAT(U32_LE),
 180        FORMAT(U32_BE),
 181        FORMAT(FLOAT_LE),
 182        FORMAT(FLOAT_BE),
 183        FORMAT(FLOAT64_LE),
 184        FORMAT(FLOAT64_BE),
 185        FORMAT(IEC958_SUBFRAME_LE),
 186        FORMAT(IEC958_SUBFRAME_BE),
 187        FORMAT(MU_LAW),
 188        FORMAT(A_LAW),
 189        FORMAT(IMA_ADPCM),
 190        FORMAT(MPEG),
 191        FORMAT(GSM),
 192        FORMAT(SPECIAL),
 193        FORMAT(S24_3LE),
 194        FORMAT(S24_3BE),
 195        FORMAT(U24_3LE),
 196        FORMAT(U24_3BE),
 197        FORMAT(S20_3LE),
 198        FORMAT(S20_3BE),
 199        FORMAT(U20_3LE),
 200        FORMAT(U20_3BE),
 201        FORMAT(S18_3LE),
 202        FORMAT(S18_3BE),
 203        FORMAT(U18_3LE),
 204        FORMAT(U18_3BE),
 205        FORMAT(G723_24),
 206        FORMAT(G723_24_1B),
 207        FORMAT(G723_40),
 208        FORMAT(G723_40_1B),
 209        FORMAT(DSD_U8),
 210        FORMAT(DSD_U16_LE),
 211        FORMAT(DSD_U32_LE),
 212        FORMAT(DSD_U16_BE),
 213        FORMAT(DSD_U32_BE),
 214};
 215
 216/**
 217 * snd_pcm_format_name - Return a name string for the given PCM format
 218 * @format: PCM format
 219 */
 220const char *snd_pcm_format_name(snd_pcm_format_t format)
 221{
 222        if ((__force unsigned int)format >= ARRAY_SIZE(snd_pcm_format_names))
 223                return "Unknown";
 224        return snd_pcm_format_names[(__force unsigned int)format];
 225}
 226EXPORT_SYMBOL_GPL(snd_pcm_format_name);
 227
 228#ifdef CONFIG_SND_VERBOSE_PROCFS
 229
 230#define STATE(v) [SNDRV_PCM_STATE_##v] = #v
 231#define STREAM(v) [SNDRV_PCM_STREAM_##v] = #v
 232#define READY(v) [SNDRV_PCM_READY_##v] = #v
 233#define XRUN(v) [SNDRV_PCM_XRUN_##v] = #v
 234#define SILENCE(v) [SNDRV_PCM_SILENCE_##v] = #v
 235#define TSTAMP(v) [SNDRV_PCM_TSTAMP_##v] = #v
 236#define ACCESS(v) [SNDRV_PCM_ACCESS_##v] = #v
 237#define START(v) [SNDRV_PCM_START_##v] = #v
 238#define SUBFORMAT(v) [SNDRV_PCM_SUBFORMAT_##v] = #v 
 239
 240static const char * const snd_pcm_stream_names[] = {
 241        STREAM(PLAYBACK),
 242        STREAM(CAPTURE),
 243};
 244
 245static const char * const snd_pcm_state_names[] = {
 246        STATE(OPEN),
 247        STATE(SETUP),
 248        STATE(PREPARED),
 249        STATE(RUNNING),
 250        STATE(XRUN),
 251        STATE(DRAINING),
 252        STATE(PAUSED),
 253        STATE(SUSPENDED),
 254};
 255
 256static const char * const snd_pcm_access_names[] = {
 257        ACCESS(MMAP_INTERLEAVED), 
 258        ACCESS(MMAP_NONINTERLEAVED),
 259        ACCESS(MMAP_COMPLEX),
 260        ACCESS(RW_INTERLEAVED),
 261        ACCESS(RW_NONINTERLEAVED),
 262};
 263
 264static const char * const snd_pcm_subformat_names[] = {
 265        SUBFORMAT(STD), 
 266};
 267
 268static const char * const snd_pcm_tstamp_mode_names[] = {
 269        TSTAMP(NONE),
 270        TSTAMP(ENABLE),
 271};
 272
 273static const char *snd_pcm_stream_name(int stream)
 274{
 275        return snd_pcm_stream_names[stream];
 276}
 277
 278static const char *snd_pcm_access_name(snd_pcm_access_t access)
 279{
 280        return snd_pcm_access_names[(__force int)access];
 281}
 282
 283static const char *snd_pcm_subformat_name(snd_pcm_subformat_t subformat)
 284{
 285        return snd_pcm_subformat_names[(__force int)subformat];
 286}
 287
 288static const char *snd_pcm_tstamp_mode_name(int mode)
 289{
 290        return snd_pcm_tstamp_mode_names[mode];
 291}
 292
 293static const char *snd_pcm_state_name(snd_pcm_state_t state)
 294{
 295        return snd_pcm_state_names[(__force int)state];
 296}
 297
 298#if IS_ENABLED(CONFIG_SND_PCM_OSS)
 299#include <linux/soundcard.h>
 300
 301static const char *snd_pcm_oss_format_name(int format)
 302{
 303        switch (format) {
 304        case AFMT_MU_LAW:
 305                return "MU_LAW";
 306        case AFMT_A_LAW:
 307                return "A_LAW";
 308        case AFMT_IMA_ADPCM:
 309                return "IMA_ADPCM";
 310        case AFMT_U8:
 311                return "U8";
 312        case AFMT_S16_LE:
 313                return "S16_LE";
 314        case AFMT_S16_BE:
 315                return "S16_BE";
 316        case AFMT_S8:
 317                return "S8";
 318        case AFMT_U16_LE:
 319                return "U16_LE";
 320        case AFMT_U16_BE:
 321                return "U16_BE";
 322        case AFMT_MPEG:
 323                return "MPEG";
 324        default:
 325                return "unknown";
 326        }
 327}
 328#endif
 329
 330static void snd_pcm_proc_info_read(struct snd_pcm_substream *substream,
 331                                   struct snd_info_buffer *buffer)
 332{
 333        struct snd_pcm_info *info;
 334        int err;
 335
 336        if (! substream)
 337                return;
 338
 339        info = kmalloc(sizeof(*info), GFP_KERNEL);
 340        if (!info)
 341                return;
 342
 343        err = snd_pcm_info(substream, info);
 344        if (err < 0) {
 345                snd_iprintf(buffer, "error %d\n", err);
 346                kfree(info);
 347                return;
 348        }
 349        snd_iprintf(buffer, "card: %d\n", info->card);
 350        snd_iprintf(buffer, "device: %d\n", info->device);
 351        snd_iprintf(buffer, "subdevice: %d\n", info->subdevice);
 352        snd_iprintf(buffer, "stream: %s\n", snd_pcm_stream_name(info->stream));
 353        snd_iprintf(buffer, "id: %s\n", info->id);
 354        snd_iprintf(buffer, "name: %s\n", info->name);
 355        snd_iprintf(buffer, "subname: %s\n", info->subname);
 356        snd_iprintf(buffer, "class: %d\n", info->dev_class);
 357        snd_iprintf(buffer, "subclass: %d\n", info->dev_subclass);
 358        snd_iprintf(buffer, "subdevices_count: %d\n", info->subdevices_count);
 359        snd_iprintf(buffer, "subdevices_avail: %d\n", info->subdevices_avail);
 360        kfree(info);
 361}
 362
 363static void snd_pcm_stream_proc_info_read(struct snd_info_entry *entry,
 364                                          struct snd_info_buffer *buffer)
 365{
 366        snd_pcm_proc_info_read(((struct snd_pcm_str *)entry->private_data)->substream,
 367                               buffer);
 368}
 369
 370static void snd_pcm_substream_proc_info_read(struct snd_info_entry *entry,
 371                                             struct snd_info_buffer *buffer)
 372{
 373        snd_pcm_proc_info_read(entry->private_data, buffer);
 374}
 375
 376static void snd_pcm_substream_proc_hw_params_read(struct snd_info_entry *entry,
 377                                                  struct snd_info_buffer *buffer)
 378{
 379        struct snd_pcm_substream *substream = entry->private_data;
 380        struct snd_pcm_runtime *runtime;
 381
 382        mutex_lock(&substream->pcm->open_mutex);
 383        runtime = substream->runtime;
 384        if (!runtime) {
 385                snd_iprintf(buffer, "closed\n");
 386                goto unlock;
 387        }
 388        if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
 389                snd_iprintf(buffer, "no setup\n");
 390                goto unlock;
 391        }
 392        snd_iprintf(buffer, "access: %s\n", snd_pcm_access_name(runtime->access));
 393        snd_iprintf(buffer, "format: %s\n", snd_pcm_format_name(runtime->format));
 394        snd_iprintf(buffer, "subformat: %s\n", snd_pcm_subformat_name(runtime->subformat));
 395        snd_iprintf(buffer, "channels: %u\n", runtime->channels);       
 396        snd_iprintf(buffer, "rate: %u (%u/%u)\n", runtime->rate, runtime->rate_num, runtime->rate_den); 
 397        snd_iprintf(buffer, "period_size: %lu\n", runtime->period_size);        
 398        snd_iprintf(buffer, "buffer_size: %lu\n", runtime->buffer_size);        
 399#if IS_ENABLED(CONFIG_SND_PCM_OSS)
 400        if (substream->oss.oss) {
 401                snd_iprintf(buffer, "OSS format: %s\n", snd_pcm_oss_format_name(runtime->oss.format));
 402                snd_iprintf(buffer, "OSS channels: %u\n", runtime->oss.channels);       
 403                snd_iprintf(buffer, "OSS rate: %u\n", runtime->oss.rate);
 404                snd_iprintf(buffer, "OSS period bytes: %lu\n", (unsigned long)runtime->oss.period_bytes);
 405                snd_iprintf(buffer, "OSS periods: %u\n", runtime->oss.periods);
 406                snd_iprintf(buffer, "OSS period frames: %lu\n", (unsigned long)runtime->oss.period_frames);
 407        }
 408#endif
 409 unlock:
 410        mutex_unlock(&substream->pcm->open_mutex);
 411}
 412
 413static void snd_pcm_substream_proc_sw_params_read(struct snd_info_entry *entry,
 414                                                  struct snd_info_buffer *buffer)
 415{
 416        struct snd_pcm_substream *substream = entry->private_data;
 417        struct snd_pcm_runtime *runtime;
 418
 419        mutex_lock(&substream->pcm->open_mutex);
 420        runtime = substream->runtime;
 421        if (!runtime) {
 422                snd_iprintf(buffer, "closed\n");
 423                goto unlock;
 424        }
 425        if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
 426                snd_iprintf(buffer, "no setup\n");
 427                goto unlock;
 428        }
 429        snd_iprintf(buffer, "tstamp_mode: %s\n", snd_pcm_tstamp_mode_name(runtime->tstamp_mode));
 430        snd_iprintf(buffer, "period_step: %u\n", runtime->period_step);
 431        snd_iprintf(buffer, "avail_min: %lu\n", runtime->control->avail_min);
 432        snd_iprintf(buffer, "start_threshold: %lu\n", runtime->start_threshold);
 433        snd_iprintf(buffer, "stop_threshold: %lu\n", runtime->stop_threshold);
 434        snd_iprintf(buffer, "silence_threshold: %lu\n", runtime->silence_threshold);
 435        snd_iprintf(buffer, "silence_size: %lu\n", runtime->silence_size);
 436        snd_iprintf(buffer, "boundary: %lu\n", runtime->boundary);
 437 unlock:
 438        mutex_unlock(&substream->pcm->open_mutex);
 439}
 440
 441static void snd_pcm_substream_proc_status_read(struct snd_info_entry *entry,
 442                                               struct snd_info_buffer *buffer)
 443{
 444        struct snd_pcm_substream *substream = entry->private_data;
 445        struct snd_pcm_runtime *runtime;
 446        struct snd_pcm_status64 status;
 447        int err;
 448
 449        mutex_lock(&substream->pcm->open_mutex);
 450        runtime = substream->runtime;
 451        if (!runtime) {
 452                snd_iprintf(buffer, "closed\n");
 453                goto unlock;
 454        }
 455        memset(&status, 0, sizeof(status));
 456        err = snd_pcm_status64(substream, &status);
 457        if (err < 0) {
 458                snd_iprintf(buffer, "error %d\n", err);
 459                goto unlock;
 460        }
 461        snd_iprintf(buffer, "state: %s\n", snd_pcm_state_name(status.state));
 462        snd_iprintf(buffer, "owner_pid   : %d\n", pid_vnr(substream->pid));
 463        snd_iprintf(buffer, "trigger_time: %lld.%09lld\n",
 464                status.trigger_tstamp_sec, status.trigger_tstamp_nsec);
 465        snd_iprintf(buffer, "tstamp      : %lld.%09lld\n",
 466                status.tstamp_sec, status.tstamp_nsec);
 467        snd_iprintf(buffer, "delay       : %ld\n", status.delay);
 468        snd_iprintf(buffer, "avail       : %ld\n", status.avail);
 469        snd_iprintf(buffer, "avail_max   : %ld\n", status.avail_max);
 470        snd_iprintf(buffer, "-----\n");
 471        snd_iprintf(buffer, "hw_ptr      : %ld\n", runtime->status->hw_ptr);
 472        snd_iprintf(buffer, "appl_ptr    : %ld\n", runtime->control->appl_ptr);
 473 unlock:
 474        mutex_unlock(&substream->pcm->open_mutex);
 475}
 476
 477#ifdef CONFIG_SND_PCM_XRUN_DEBUG
 478static void snd_pcm_xrun_injection_write(struct snd_info_entry *entry,
 479                                         struct snd_info_buffer *buffer)
 480{
 481        struct snd_pcm_substream *substream = entry->private_data;
 482
 483        snd_pcm_stop_xrun(substream);
 484}
 485
 486static void snd_pcm_xrun_debug_read(struct snd_info_entry *entry,
 487                                    struct snd_info_buffer *buffer)
 488{
 489        struct snd_pcm_str *pstr = entry->private_data;
 490        snd_iprintf(buffer, "%d\n", pstr->xrun_debug);
 491}
 492
 493static void snd_pcm_xrun_debug_write(struct snd_info_entry *entry,
 494                                     struct snd_info_buffer *buffer)
 495{
 496        struct snd_pcm_str *pstr = entry->private_data;
 497        char line[64];
 498        if (!snd_info_get_line(buffer, line, sizeof(line)))
 499                pstr->xrun_debug = simple_strtoul(line, NULL, 10);
 500}
 501#endif
 502
 503static int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr)
 504{
 505        struct snd_pcm *pcm = pstr->pcm;
 506        struct snd_info_entry *entry;
 507        char name[16];
 508
 509        sprintf(name, "pcm%i%c", pcm->device, 
 510                pstr->stream == SNDRV_PCM_STREAM_PLAYBACK ? 'p' : 'c');
 511        entry = snd_info_create_card_entry(pcm->card, name,
 512                                           pcm->card->proc_root);
 513        if (!entry)
 514                return -ENOMEM;
 515        entry->mode = S_IFDIR | 0555;
 516        pstr->proc_root = entry;
 517        entry = snd_info_create_card_entry(pcm->card, "info", pstr->proc_root);
 518        if (entry)
 519                snd_info_set_text_ops(entry, pstr, snd_pcm_stream_proc_info_read);
 520#ifdef CONFIG_SND_PCM_XRUN_DEBUG
 521        entry = snd_info_create_card_entry(pcm->card, "xrun_debug",
 522                                           pstr->proc_root);
 523        if (entry) {
 524                snd_info_set_text_ops(entry, pstr, snd_pcm_xrun_debug_read);
 525                entry->c.text.write = snd_pcm_xrun_debug_write;
 526                entry->mode |= 0200;
 527        }
 528#endif
 529        return 0;
 530}
 531
 532static int snd_pcm_stream_proc_done(struct snd_pcm_str *pstr)
 533{
 534        snd_info_free_entry(pstr->proc_root);
 535        pstr->proc_root = NULL;
 536        return 0;
 537}
 538
 539static struct snd_info_entry *
 540create_substream_info_entry(struct snd_pcm_substream *substream,
 541                            const char *name,
 542                            void (*read)(struct snd_info_entry *,
 543                                         struct snd_info_buffer *))
 544{
 545        struct snd_info_entry *entry;
 546
 547        entry = snd_info_create_card_entry(substream->pcm->card, name,
 548                                           substream->proc_root);
 549        if (entry)
 550                snd_info_set_text_ops(entry, substream, read);
 551        return entry;
 552}
 553
 554static int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream)
 555{
 556        struct snd_info_entry *entry;
 557        struct snd_card *card;
 558        char name[16];
 559
 560        card = substream->pcm->card;
 561
 562        sprintf(name, "sub%i", substream->number);
 563        entry = snd_info_create_card_entry(card, name,
 564                                           substream->pstr->proc_root);
 565        if (!entry)
 566                return -ENOMEM;
 567        entry->mode = S_IFDIR | 0555;
 568        substream->proc_root = entry;
 569
 570        create_substream_info_entry(substream, "info",
 571                                    snd_pcm_substream_proc_info_read);
 572        create_substream_info_entry(substream, "hw_params",
 573                                    snd_pcm_substream_proc_hw_params_read);
 574        create_substream_info_entry(substream, "sw_params",
 575                                    snd_pcm_substream_proc_sw_params_read);
 576        create_substream_info_entry(substream, "status",
 577                                    snd_pcm_substream_proc_status_read);
 578
 579#ifdef CONFIG_SND_PCM_XRUN_DEBUG
 580        entry = create_substream_info_entry(substream, "xrun_injection", NULL);
 581        if (entry) {
 582                entry->c.text.write = snd_pcm_xrun_injection_write;
 583                entry->mode = S_IFREG | 0200;
 584        }
 585#endif /* CONFIG_SND_PCM_XRUN_DEBUG */
 586
 587        return 0;
 588}
 589
 590#else /* !CONFIG_SND_VERBOSE_PROCFS */
 591static inline int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr) { return 0; }
 592static inline int snd_pcm_stream_proc_done(struct snd_pcm_str *pstr) { return 0; }
 593static inline int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream) { return 0; }
 594#endif /* CONFIG_SND_VERBOSE_PROCFS */
 595
 596static const struct attribute_group *pcm_dev_attr_groups[];
 597
 598/*
 599 * PM callbacks: we need to deal only with suspend here, as the resume is
 600 * triggered either from user-space or the driver's resume callback
 601 */
 602#ifdef CONFIG_PM_SLEEP
 603static int do_pcm_suspend(struct device *dev)
 604{
 605        struct snd_pcm_str *pstr = container_of(dev, struct snd_pcm_str, dev);
 606
 607        if (!pstr->pcm->no_device_suspend)
 608                snd_pcm_suspend_all(pstr->pcm);
 609        return 0;
 610}
 611#endif
 612
 613static const struct dev_pm_ops pcm_dev_pm_ops = {
 614        SET_SYSTEM_SLEEP_PM_OPS(do_pcm_suspend, NULL)
 615};
 616
 617/* device type for PCM -- basically only for passing PM callbacks */
 618static const struct device_type pcm_dev_type = {
 619        .name = "pcm",
 620        .pm = &pcm_dev_pm_ops,
 621};
 622
 623/**
 624 * snd_pcm_new_stream - create a new PCM stream
 625 * @pcm: the pcm instance
 626 * @stream: the stream direction, SNDRV_PCM_STREAM_XXX
 627 * @substream_count: the number of substreams
 628 *
 629 * Creates a new stream for the pcm.
 630 * The corresponding stream on the pcm must have been empty before
 631 * calling this, i.e. zero must be given to the argument of
 632 * snd_pcm_new().
 633 *
 634 * Return: Zero if successful, or a negative error code on failure.
 635 */
 636int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count)
 637{
 638        int idx, err;
 639        struct snd_pcm_str *pstr = &pcm->streams[stream];
 640        struct snd_pcm_substream *substream, *prev;
 641
 642#if IS_ENABLED(CONFIG_SND_PCM_OSS)
 643        mutex_init(&pstr->oss.setup_mutex);
 644#endif
 645        pstr->stream = stream;
 646        pstr->pcm = pcm;
 647        pstr->substream_count = substream_count;
 648        if (!substream_count)
 649                return 0;
 650
 651        snd_device_initialize(&pstr->dev, pcm->card);
 652        pstr->dev.groups = pcm_dev_attr_groups;
 653        pstr->dev.type = &pcm_dev_type;
 654        dev_set_name(&pstr->dev, "pcmC%iD%i%c", pcm->card->number, pcm->device,
 655                     stream == SNDRV_PCM_STREAM_PLAYBACK ? 'p' : 'c');
 656
 657        if (!pcm->internal) {
 658                err = snd_pcm_stream_proc_init(pstr);
 659                if (err < 0) {
 660                        pcm_err(pcm, "Error in snd_pcm_stream_proc_init\n");
 661                        return err;
 662                }
 663        }
 664        prev = NULL;
 665        for (idx = 0, prev = NULL; idx < substream_count; idx++) {
 666                substream = kzalloc(sizeof(*substream), GFP_KERNEL);
 667                if (!substream)
 668                        return -ENOMEM;
 669                substream->pcm = pcm;
 670                substream->pstr = pstr;
 671                substream->number = idx;
 672                substream->stream = stream;
 673                sprintf(substream->name, "subdevice #%i", idx);
 674                substream->buffer_bytes_max = UINT_MAX;
 675                if (prev == NULL)
 676                        pstr->substream = substream;
 677                else
 678                        prev->next = substream;
 679
 680                if (!pcm->internal) {
 681                        err = snd_pcm_substream_proc_init(substream);
 682                        if (err < 0) {
 683                                pcm_err(pcm,
 684                                        "Error in snd_pcm_stream_proc_init\n");
 685                                if (prev == NULL)
 686                                        pstr->substream = NULL;
 687                                else
 688                                        prev->next = NULL;
 689                                kfree(substream);
 690                                return err;
 691                        }
 692                }
 693                substream->group = &substream->self_group;
 694                snd_pcm_group_init(&substream->self_group);
 695                list_add_tail(&substream->link_list, &substream->self_group.substreams);
 696                atomic_set(&substream->mmap_count, 0);
 697                prev = substream;
 698        }
 699        return 0;
 700}                               
 701EXPORT_SYMBOL(snd_pcm_new_stream);
 702
 703static int _snd_pcm_new(struct snd_card *card, const char *id, int device,
 704                int playback_count, int capture_count, bool internal,
 705                struct snd_pcm **rpcm)
 706{
 707        struct snd_pcm *pcm;
 708        int err;
 709        static const struct snd_device_ops ops = {
 710                .dev_free = snd_pcm_dev_free,
 711                .dev_register = snd_pcm_dev_register,
 712                .dev_disconnect = snd_pcm_dev_disconnect,
 713        };
 714        static const struct snd_device_ops internal_ops = {
 715                .dev_free = snd_pcm_dev_free,
 716        };
 717
 718        if (snd_BUG_ON(!card))
 719                return -ENXIO;
 720        if (rpcm)
 721                *rpcm = NULL;
 722        pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);
 723        if (!pcm)
 724                return -ENOMEM;
 725        pcm->card = card;
 726        pcm->device = device;
 727        pcm->internal = internal;
 728        mutex_init(&pcm->open_mutex);
 729        init_waitqueue_head(&pcm->open_wait);
 730        INIT_LIST_HEAD(&pcm->list);
 731        if (id)
 732                strlcpy(pcm->id, id, sizeof(pcm->id));
 733
 734        err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_PLAYBACK,
 735                                 playback_count);
 736        if (err < 0)
 737                goto free_pcm;
 738
 739        err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_CAPTURE, capture_count);
 740        if (err < 0)
 741                goto free_pcm;
 742
 743        err = snd_device_new(card, SNDRV_DEV_PCM, pcm,
 744                             internal ? &internal_ops : &ops);
 745        if (err < 0)
 746                goto free_pcm;
 747
 748        if (rpcm)
 749                *rpcm = pcm;
 750        return 0;
 751
 752free_pcm:
 753        snd_pcm_free(pcm);
 754        return err;
 755}
 756
 757/**
 758 * snd_pcm_new - create a new PCM instance
 759 * @card: the card instance
 760 * @id: the id string
 761 * @device: the device index (zero based)
 762 * @playback_count: the number of substreams for playback
 763 * @capture_count: the number of substreams for capture
 764 * @rpcm: the pointer to store the new pcm instance
 765 *
 766 * Creates a new PCM instance.
 767 *
 768 * The pcm operators have to be set afterwards to the new instance
 769 * via snd_pcm_set_ops().
 770 *
 771 * Return: Zero if successful, or a negative error code on failure.
 772 */
 773int snd_pcm_new(struct snd_card *card, const char *id, int device,
 774                int playback_count, int capture_count, struct snd_pcm **rpcm)
 775{
 776        return _snd_pcm_new(card, id, device, playback_count, capture_count,
 777                        false, rpcm);
 778}
 779EXPORT_SYMBOL(snd_pcm_new);
 780
 781/**
 782 * snd_pcm_new_internal - create a new internal PCM instance
 783 * @card: the card instance
 784 * @id: the id string
 785 * @device: the device index (zero based - shared with normal PCMs)
 786 * @playback_count: the number of substreams for playback
 787 * @capture_count: the number of substreams for capture
 788 * @rpcm: the pointer to store the new pcm instance
 789 *
 790 * Creates a new internal PCM instance with no userspace device or procfs
 791 * entries. This is used by ASoC Back End PCMs in order to create a PCM that
 792 * will only be used internally by kernel drivers. i.e. it cannot be opened
 793 * by userspace. It provides existing ASoC components drivers with a substream
 794 * and access to any private data.
 795 *
 796 * The pcm operators have to be set afterwards to the new instance
 797 * via snd_pcm_set_ops().
 798 *
 799 * Return: Zero if successful, or a negative error code on failure.
 800 */
 801int snd_pcm_new_internal(struct snd_card *card, const char *id, int device,
 802        int playback_count, int capture_count,
 803        struct snd_pcm **rpcm)
 804{
 805        return _snd_pcm_new(card, id, device, playback_count, capture_count,
 806                        true, rpcm);
 807}
 808EXPORT_SYMBOL(snd_pcm_new_internal);
 809
 810static void free_chmap(struct snd_pcm_str *pstr)
 811{
 812        if (pstr->chmap_kctl) {
 813                snd_ctl_remove(pstr->pcm->card, pstr->chmap_kctl);
 814                pstr->chmap_kctl = NULL;
 815        }
 816}
 817
 818static void snd_pcm_free_stream(struct snd_pcm_str * pstr)
 819{
 820        struct snd_pcm_substream *substream, *substream_next;
 821#if IS_ENABLED(CONFIG_SND_PCM_OSS)
 822        struct snd_pcm_oss_setup *setup, *setupn;
 823#endif
 824
 825        /* free all proc files under the stream */
 826        snd_pcm_stream_proc_done(pstr);
 827
 828        substream = pstr->substream;
 829        while (substream) {
 830                substream_next = substream->next;
 831                snd_pcm_timer_done(substream);
 832                kfree(substream);
 833                substream = substream_next;
 834        }
 835#if IS_ENABLED(CONFIG_SND_PCM_OSS)
 836        for (setup = pstr->oss.setup_list; setup; setup = setupn) {
 837                setupn = setup->next;
 838                kfree(setup->task_name);
 839                kfree(setup);
 840        }
 841#endif
 842        free_chmap(pstr);
 843        if (pstr->substream_count)
 844                put_device(&pstr->dev);
 845}
 846
 847#if IS_ENABLED(CONFIG_SND_PCM_OSS)
 848#define pcm_call_notify(pcm, call)                                      \
 849        do {                                                            \
 850                struct snd_pcm_notify *_notify;                         \
 851                list_for_each_entry(_notify, &snd_pcm_notify_list, list) \
 852                        _notify->call(pcm);                             \
 853        } while (0)
 854#else
 855#define pcm_call_notify(pcm, call) do {} while (0)
 856#endif
 857
 858static int snd_pcm_free(struct snd_pcm *pcm)
 859{
 860        if (!pcm)
 861                return 0;
 862        if (!pcm->internal)
 863                pcm_call_notify(pcm, n_unregister);
 864        if (pcm->private_free)
 865                pcm->private_free(pcm);
 866        snd_pcm_lib_preallocate_free_for_all(pcm);
 867        snd_pcm_free_stream(&pcm->streams[SNDRV_PCM_STREAM_PLAYBACK]);
 868        snd_pcm_free_stream(&pcm->streams[SNDRV_PCM_STREAM_CAPTURE]);
 869        kfree(pcm);
 870        return 0;
 871}
 872
 873static int snd_pcm_dev_free(struct snd_device *device)
 874{
 875        struct snd_pcm *pcm = device->device_data;
 876        return snd_pcm_free(pcm);
 877}
 878
 879int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream,
 880                             struct file *file,
 881                             struct snd_pcm_substream **rsubstream)
 882{
 883        struct snd_pcm_str * pstr;
 884        struct snd_pcm_substream *substream;
 885        struct snd_pcm_runtime *runtime;
 886        struct snd_card *card;
 887        int prefer_subdevice;
 888        size_t size;
 889
 890        if (snd_BUG_ON(!pcm || !rsubstream))
 891                return -ENXIO;
 892        if (snd_BUG_ON(stream != SNDRV_PCM_STREAM_PLAYBACK &&
 893                       stream != SNDRV_PCM_STREAM_CAPTURE))
 894                return -EINVAL;
 895        *rsubstream = NULL;
 896        pstr = &pcm->streams[stream];
 897        if (pstr->substream == NULL || pstr->substream_count == 0)
 898                return -ENODEV;
 899
 900        card = pcm->card;
 901        prefer_subdevice = snd_ctl_get_preferred_subdevice(card, SND_CTL_SUBDEV_PCM);
 902
 903        if (pcm->info_flags & SNDRV_PCM_INFO_HALF_DUPLEX) {
 904                int opposite = !stream;
 905
 906                for (substream = pcm->streams[opposite].substream; substream;
 907                     substream = substream->next) {
 908                        if (SUBSTREAM_BUSY(substream))
 909                                return -EAGAIN;
 910                }
 911        }
 912
 913        if (file->f_flags & O_APPEND) {
 914                if (prefer_subdevice < 0) {
 915                        if (pstr->substream_count > 1)
 916                                return -EINVAL; /* must be unique */
 917                        substream = pstr->substream;
 918                } else {
 919                        for (substream = pstr->substream; substream;
 920                             substream = substream->next)
 921                                if (substream->number == prefer_subdevice)
 922                                        break;
 923                }
 924                if (! substream)
 925                        return -ENODEV;
 926                if (! SUBSTREAM_BUSY(substream))
 927                        return -EBADFD;
 928                substream->ref_count++;
 929                *rsubstream = substream;
 930                return 0;
 931        }
 932
 933        for (substream = pstr->substream; substream; substream = substream->next) {
 934                if (!SUBSTREAM_BUSY(substream) &&
 935                    (prefer_subdevice == -1 ||
 936                     substream->number == prefer_subdevice))
 937                        break;
 938        }
 939        if (substream == NULL)
 940                return -EAGAIN;
 941
 942        runtime = kzalloc(sizeof(*runtime), GFP_KERNEL);
 943        if (runtime == NULL)
 944                return -ENOMEM;
 945
 946        size = PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status));
 947        runtime->status = alloc_pages_exact(size, GFP_KERNEL);
 948        if (runtime->status == NULL) {
 949                kfree(runtime);
 950                return -ENOMEM;
 951        }
 952        memset(runtime->status, 0, size);
 953
 954        size = PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control));
 955        runtime->control = alloc_pages_exact(size, GFP_KERNEL);
 956        if (runtime->control == NULL) {
 957                free_pages_exact(runtime->status,
 958                               PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)));
 959                kfree(runtime);
 960                return -ENOMEM;
 961        }
 962        memset(runtime->control, 0, size);
 963
 964        init_waitqueue_head(&runtime->sleep);
 965        init_waitqueue_head(&runtime->tsleep);
 966
 967        runtime->status->state = SNDRV_PCM_STATE_OPEN;
 968
 969        substream->runtime = runtime;
 970        substream->private_data = pcm->private_data;
 971        substream->ref_count = 1;
 972        substream->f_flags = file->f_flags;
 973        substream->pid = get_pid(task_pid(current));
 974        pstr->substream_opened++;
 975        *rsubstream = substream;
 976        return 0;
 977}
 978
 979void snd_pcm_detach_substream(struct snd_pcm_substream *substream)
 980{
 981        struct snd_pcm_runtime *runtime;
 982
 983        if (PCM_RUNTIME_CHECK(substream))
 984                return;
 985        runtime = substream->runtime;
 986        if (runtime->private_free != NULL)
 987                runtime->private_free(runtime);
 988        free_pages_exact(runtime->status,
 989                       PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)));
 990        free_pages_exact(runtime->control,
 991                       PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control)));
 992        kfree(runtime->hw_constraints.rules);
 993        /* Avoid concurrent access to runtime via PCM timer interface */
 994        if (substream->timer)
 995                spin_lock_irq(&substream->timer->lock);
 996        substream->runtime = NULL;
 997        if (substream->timer)
 998                spin_unlock_irq(&substream->timer->lock);
 999        kfree(runtime);
1000        put_pid(substream->pid);
1001        substream->pid = NULL;
1002        substream->pstr->substream_opened--;
1003}
1004
1005static ssize_t show_pcm_class(struct device *dev,
1006                              struct device_attribute *attr, char *buf)
1007{
1008        struct snd_pcm_str *pstr = container_of(dev, struct snd_pcm_str, dev);
1009        struct snd_pcm *pcm = pstr->pcm;
1010        const char *str;
1011        static const char *strs[SNDRV_PCM_CLASS_LAST + 1] = {
1012                [SNDRV_PCM_CLASS_GENERIC] = "generic",
1013                [SNDRV_PCM_CLASS_MULTI] = "multi",
1014                [SNDRV_PCM_CLASS_MODEM] = "modem",
1015                [SNDRV_PCM_CLASS_DIGITIZER] = "digitizer",
1016        };
1017
1018        if (pcm->dev_class > SNDRV_PCM_CLASS_LAST)
1019                str = "none";
1020        else
1021                str = strs[pcm->dev_class];
1022        return snprintf(buf, PAGE_SIZE, "%s\n", str);
1023}
1024
1025static DEVICE_ATTR(pcm_class, 0444, show_pcm_class, NULL);
1026static struct attribute *pcm_dev_attrs[] = {
1027        &dev_attr_pcm_class.attr,
1028        NULL
1029};
1030
1031static const struct attribute_group pcm_dev_attr_group = {
1032        .attrs  = pcm_dev_attrs,
1033};
1034
1035static const struct attribute_group *pcm_dev_attr_groups[] = {
1036        &pcm_dev_attr_group,
1037        NULL
1038};
1039
1040static int snd_pcm_dev_register(struct snd_device *device)
1041{
1042        int cidx, err;
1043        struct snd_pcm_substream *substream;
1044        struct snd_pcm *pcm;
1045
1046        if (snd_BUG_ON(!device || !device->device_data))
1047                return -ENXIO;
1048        pcm = device->device_data;
1049
1050        mutex_lock(&register_mutex);
1051        err = snd_pcm_add(pcm);
1052        if (err)
1053                goto unlock;
1054        for (cidx = 0; cidx < 2; cidx++) {
1055                int devtype = -1;
1056                if (pcm->streams[cidx].substream == NULL)
1057                        continue;
1058                switch (cidx) {
1059                case SNDRV_PCM_STREAM_PLAYBACK:
1060                        devtype = SNDRV_DEVICE_TYPE_PCM_PLAYBACK;
1061                        break;
1062                case SNDRV_PCM_STREAM_CAPTURE:
1063                        devtype = SNDRV_DEVICE_TYPE_PCM_CAPTURE;
1064                        break;
1065                }
1066                /* register pcm */
1067                err = snd_register_device(devtype, pcm->card, pcm->device,
1068                                          &snd_pcm_f_ops[cidx], pcm,
1069                                          &pcm->streams[cidx].dev);
1070                if (err < 0) {
1071                        list_del_init(&pcm->list);
1072                        goto unlock;
1073                }
1074
1075                for (substream = pcm->streams[cidx].substream; substream; substream = substream->next)
1076                        snd_pcm_timer_init(substream);
1077        }
1078
1079        pcm_call_notify(pcm, n_register);
1080
1081 unlock:
1082        mutex_unlock(&register_mutex);
1083        return err;
1084}
1085
1086static int snd_pcm_dev_disconnect(struct snd_device *device)
1087{
1088        struct snd_pcm *pcm = device->device_data;
1089        struct snd_pcm_substream *substream;
1090        int cidx;
1091
1092        mutex_lock(&register_mutex);
1093        mutex_lock(&pcm->open_mutex);
1094        wake_up(&pcm->open_wait);
1095        list_del_init(&pcm->list);
1096        for (cidx = 0; cidx < 2; cidx++) {
1097                for (substream = pcm->streams[cidx].substream; substream; substream = substream->next) {
1098                        snd_pcm_stream_lock_irq(substream);
1099                        if (substream->runtime) {
1100                                if (snd_pcm_running(substream))
1101                                        snd_pcm_stop(substream,
1102                                                     SNDRV_PCM_STATE_DISCONNECTED);
1103                                /* to be sure, set the state unconditionally */
1104                                substream->runtime->status->state = SNDRV_PCM_STATE_DISCONNECTED;
1105                                wake_up(&substream->runtime->sleep);
1106                                wake_up(&substream->runtime->tsleep);
1107                        }
1108                        snd_pcm_stream_unlock_irq(substream);
1109                }
1110        }
1111
1112        pcm_call_notify(pcm, n_disconnect);
1113        for (cidx = 0; cidx < 2; cidx++) {
1114                snd_unregister_device(&pcm->streams[cidx].dev);
1115                free_chmap(&pcm->streams[cidx]);
1116        }
1117        mutex_unlock(&pcm->open_mutex);
1118        mutex_unlock(&register_mutex);
1119        return 0;
1120}
1121
1122#if IS_ENABLED(CONFIG_SND_PCM_OSS)
1123/**
1124 * snd_pcm_notify - Add/remove the notify list
1125 * @notify: PCM notify list
1126 * @nfree: 0 = register, 1 = unregister
1127 *
1128 * This adds the given notifier to the global list so that the callback is
1129 * called for each registered PCM devices.  This exists only for PCM OSS
1130 * emulation, so far.
1131 */
1132int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree)
1133{
1134        struct snd_pcm *pcm;
1135
1136        if (snd_BUG_ON(!notify ||
1137                       !notify->n_register ||
1138                       !notify->n_unregister ||
1139                       !notify->n_disconnect))
1140                return -EINVAL;
1141        mutex_lock(&register_mutex);
1142        if (nfree) {
1143                list_del(&notify->list);
1144                list_for_each_entry(pcm, &snd_pcm_devices, list)
1145                        notify->n_unregister(pcm);
1146        } else {
1147                list_add_tail(&notify->list, &snd_pcm_notify_list);
1148                list_for_each_entry(pcm, &snd_pcm_devices, list)
1149                        notify->n_register(pcm);
1150        }
1151        mutex_unlock(&register_mutex);
1152        return 0;
1153}
1154EXPORT_SYMBOL(snd_pcm_notify);
1155#endif /* CONFIG_SND_PCM_OSS */
1156
1157#ifdef CONFIG_SND_PROC_FS
1158/*
1159 *  Info interface
1160 */
1161
1162static void snd_pcm_proc_read(struct snd_info_entry *entry,
1163                              struct snd_info_buffer *buffer)
1164{
1165        struct snd_pcm *pcm;
1166
1167        mutex_lock(&register_mutex);
1168        list_for_each_entry(pcm, &snd_pcm_devices, list) {
1169                snd_iprintf(buffer, "%02i-%02i: %s : %s",
1170                            pcm->card->number, pcm->device, pcm->id, pcm->name);
1171                if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream)
1172                        snd_iprintf(buffer, " : playback %i",
1173                                    pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream_count);
1174                if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream)
1175                        snd_iprintf(buffer, " : capture %i",
1176                                    pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream_count);
1177                snd_iprintf(buffer, "\n");
1178        }
1179        mutex_unlock(&register_mutex);
1180}
1181
1182static struct snd_info_entry *snd_pcm_proc_entry;
1183
1184static void snd_pcm_proc_init(void)
1185{
1186        struct snd_info_entry *entry;
1187
1188        entry = snd_info_create_module_entry(THIS_MODULE, "pcm", NULL);
1189        if (entry) {
1190                snd_info_set_text_ops(entry, NULL, snd_pcm_proc_read);
1191                if (snd_info_register(entry) < 0) {
1192                        snd_info_free_entry(entry);
1193                        entry = NULL;
1194                }
1195        }
1196        snd_pcm_proc_entry = entry;
1197}
1198
1199static void snd_pcm_proc_done(void)
1200{
1201        snd_info_free_entry(snd_pcm_proc_entry);
1202}
1203
1204#else /* !CONFIG_SND_PROC_FS */
1205#define snd_pcm_proc_init()
1206#define snd_pcm_proc_done()
1207#endif /* CONFIG_SND_PROC_FS */
1208
1209
1210/*
1211 *  ENTRY functions
1212 */
1213
1214static int __init alsa_pcm_init(void)
1215{
1216        snd_ctl_register_ioctl(snd_pcm_control_ioctl);
1217        snd_ctl_register_ioctl_compat(snd_pcm_control_ioctl);
1218        snd_pcm_proc_init();
1219        return 0;
1220}
1221
1222static void __exit alsa_pcm_exit(void)
1223{
1224        snd_ctl_unregister_ioctl(snd_pcm_control_ioctl);
1225        snd_ctl_unregister_ioctl_compat(snd_pcm_control_ioctl);
1226        snd_pcm_proc_done();
1227}
1228
1229module_init(alsa_pcm_init)
1230module_exit(alsa_pcm_exit)
1231