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