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