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