sound/core/pcm.c

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