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