sound/core/pcm.c

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