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 struct snd_pcm_runtime *runtime; 496 497 snd_pcm_stream_lock_irq(substream); 498 runtime = substream->runtime; 499 if (runtime && runtime->status->state == SNDRV_PCM_STATE_RUNNING) 500 snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN); 501 snd_pcm_stream_unlock_irq(substream); 502 } 503 504 static void snd_pcm_xrun_debug_read(struct snd_info_entry *entry, 505 struct snd_info_buffer *buffer) 506 { 507 struct snd_pcm_str *pstr = entry->private_data; 508 snd_iprintf(buffer, "%d\n", pstr->xrun_debug); 509 } 510 511 static void snd_pcm_xrun_debug_write(struct snd_info_entry *entry, 512 struct snd_info_buffer *buffer) 513 { 514 struct snd_pcm_str *pstr = entry->private_data; 515 char line[64]; 516 if (!snd_info_get_line(buffer, line, sizeof(line))) 517 pstr->xrun_debug = simple_strtoul(line, NULL, 10); 518 } 519 #endif 520 521 static int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr) 522 { 523 struct snd_pcm *pcm = pstr->pcm; 524 struct snd_info_entry *entry; 525 char name[16]; 526 527 sprintf(name, "pcm%i%c", pcm->device, 528 pstr->stream == SNDRV_PCM_STREAM_PLAYBACK ? 'p' : 'c'); 529 entry = snd_info_create_card_entry(pcm->card, name, 530 pcm->card->proc_root); 531 if (!entry) 532 return -ENOMEM; 533 entry->mode = S_IFDIR | 0555; 534 if (snd_info_register(entry) < 0) { 535 snd_info_free_entry(entry); 536 return -ENOMEM; 537 } 538 pstr->proc_root = entry; 539 entry = snd_info_create_card_entry(pcm->card, "info", pstr->proc_root); 540 if (entry) { 541 snd_info_set_text_ops(entry, pstr, snd_pcm_stream_proc_info_read); 542 if (snd_info_register(entry) < 0) { 543 snd_info_free_entry(entry); 544 entry = NULL; 545 } 546 } 547 pstr->proc_info_entry = entry; 548 549 #ifdef CONFIG_SND_PCM_XRUN_DEBUG 550 entry = snd_info_create_card_entry(pcm->card, "xrun_debug", 551 pstr->proc_root); 552 if (entry) { 553 entry->c.text.read = snd_pcm_xrun_debug_read; 554 entry->c.text.write = snd_pcm_xrun_debug_write; 555 entry->mode |= 0200; 556 entry->private_data = pstr; 557 if (snd_info_register(entry) < 0) { 558 snd_info_free_entry(entry); 559 entry = NULL; 560 } 561 } 562 pstr->proc_xrun_debug_entry = entry; 563 #endif 564 return 0; 565 } 566 567 static int snd_pcm_stream_proc_done(struct snd_pcm_str *pstr) 568 { 569 #ifdef CONFIG_SND_PCM_XRUN_DEBUG 570 snd_info_free_entry(pstr->proc_xrun_debug_entry); 571 pstr->proc_xrun_debug_entry = NULL; 572 #endif 573 snd_info_free_entry(pstr->proc_info_entry); 574 pstr->proc_info_entry = NULL; 575 snd_info_free_entry(pstr->proc_root); 576 pstr->proc_root = NULL; 577 return 0; 578 } 579 580 static int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream) 581 { 582 struct snd_info_entry *entry; 583 struct snd_card *card; 584 char name[16]; 585 586 card = substream->pcm->card; 587 588 sprintf(name, "sub%i", substream->number); 589 entry = snd_info_create_card_entry(card, name, 590 substream->pstr->proc_root); 591 if (!entry) 592 return -ENOMEM; 593 entry->mode = S_IFDIR | 0555; 594 if (snd_info_register(entry) < 0) { 595 snd_info_free_entry(entry); 596 return -ENOMEM; 597 } 598 substream->proc_root = entry; 599 entry = snd_info_create_card_entry(card, "info", substream->proc_root); 600 if (entry) { 601 snd_info_set_text_ops(entry, substream, 602 snd_pcm_substream_proc_info_read); 603 if (snd_info_register(entry) < 0) { 604 snd_info_free_entry(entry); 605 entry = NULL; 606 } 607 } 608 substream->proc_info_entry = entry; 609 entry = snd_info_create_card_entry(card, "hw_params", 610 substream->proc_root); 611 if (entry) { 612 snd_info_set_text_ops(entry, substream, 613 snd_pcm_substream_proc_hw_params_read); 614 if (snd_info_register(entry) < 0) { 615 snd_info_free_entry(entry); 616 entry = NULL; 617 } 618 } 619 substream->proc_hw_params_entry = entry; 620 entry = snd_info_create_card_entry(card, "sw_params", 621 substream->proc_root); 622 if (entry) { 623 snd_info_set_text_ops(entry, substream, 624 snd_pcm_substream_proc_sw_params_read); 625 if (snd_info_register(entry) < 0) { 626 snd_info_free_entry(entry); 627 entry = NULL; 628 } 629 } 630 substream->proc_sw_params_entry = entry; 631 entry = snd_info_create_card_entry(card, "status", 632 substream->proc_root); 633 if (entry) { 634 snd_info_set_text_ops(entry, substream, 635 snd_pcm_substream_proc_status_read); 636 if (snd_info_register(entry) < 0) { 637 snd_info_free_entry(entry); 638 entry = NULL; 639 } 640 } 641 substream->proc_status_entry = entry; 642 643 #ifdef CONFIG_SND_PCM_XRUN_DEBUG 644 entry = snd_info_create_card_entry(card, "xrun_injection", 645 substream->proc_root); 646 if (entry) { 647 entry->private_data = substream; 648 entry->c.text.read = NULL; 649 entry->c.text.write = snd_pcm_xrun_injection_write; 650 entry->mode = S_IFREG | 0200; 651 if (snd_info_register(entry) < 0) { 652 snd_info_free_entry(entry); 653 entry = NULL; 654 } 655 } 656 substream->proc_xrun_injection_entry = entry; 657 #endif /* CONFIG_SND_PCM_XRUN_DEBUG */ 658 659 return 0; 660 } 661 662 static int snd_pcm_substream_proc_done(struct snd_pcm_substream *substream) 663 { 664 snd_info_free_entry(substream->proc_info_entry); 665 substream->proc_info_entry = NULL; 666 snd_info_free_entry(substream->proc_hw_params_entry); 667 substream->proc_hw_params_entry = NULL; 668 snd_info_free_entry(substream->proc_sw_params_entry); 669 substream->proc_sw_params_entry = NULL; 670 snd_info_free_entry(substream->proc_status_entry); 671 substream->proc_status_entry = NULL; 672 #ifdef CONFIG_SND_PCM_XRUN_DEBUG 673 snd_info_free_entry(substream->proc_xrun_injection_entry); 674 substream->proc_xrun_injection_entry = NULL; 675 #endif 676 snd_info_free_entry(substream->proc_root); 677 substream->proc_root = NULL; 678 return 0; 679 } 680 #else /* !CONFIG_SND_VERBOSE_PROCFS */ 681 static inline int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr) { return 0; } 682 static inline int snd_pcm_stream_proc_done(struct snd_pcm_str *pstr) { return 0; } 683 static inline int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream) { return 0; } 684 static inline int snd_pcm_substream_proc_done(struct snd_pcm_substream *substream) { return 0; } 685 #endif /* CONFIG_SND_VERBOSE_PROCFS */ 686 687 static const struct attribute_group *pcm_dev_attr_groups[]; 688 689 /** 690 * snd_pcm_new_stream - create a new PCM stream 691 * @pcm: the pcm instance 692 * @stream: the stream direction, SNDRV_PCM_STREAM_XXX 693 * @substream_count: the number of substreams 694 * 695 * Creates a new stream for the pcm. 696 * The corresponding stream on the pcm must have been empty before 697 * calling this, i.e. zero must be given to the argument of 698 * snd_pcm_new(). 699 * 700 * Return: Zero if successful, or a negative error code on failure. 701 */ 702 int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count) 703 { 704 int idx, err; 705 struct snd_pcm_str *pstr = &pcm->streams[stream]; 706 struct snd_pcm_substream *substream, *prev; 707 708 #if IS_ENABLED(CONFIG_SND_PCM_OSS) 709 mutex_init(&pstr->oss.setup_mutex); 710 #endif 711 pstr->stream = stream; 712 pstr->pcm = pcm; 713 pstr->substream_count = substream_count; 714 if (!substream_count) 715 return 0; 716 717 snd_device_initialize(&pstr->dev, pcm->card); 718 pstr->dev.groups = pcm_dev_attr_groups; 719 dev_set_name(&pstr->dev, "pcmC%iD%i%c", pcm->card->number, pcm->device, 720 stream == SNDRV_PCM_STREAM_PLAYBACK ? 'p' : 'c'); 721 722 if (!pcm->internal) { 723 err = snd_pcm_stream_proc_init(pstr); 724 if (err < 0) { 725 pcm_err(pcm, "Error in snd_pcm_stream_proc_init\n"); 726 return err; 727 } 728 } 729 prev = NULL; 730 for (idx = 0, prev = NULL; idx < substream_count; idx++) { 731 substream = kzalloc(sizeof(*substream), GFP_KERNEL); 732 if (!substream) 733 return -ENOMEM; 734 substream->pcm = pcm; 735 substream->pstr = pstr; 736 substream->number = idx; 737 substream->stream = stream; 738 sprintf(substream->name, "subdevice #%i", idx); 739 substream->buffer_bytes_max = UINT_MAX; 740 if (prev == NULL) 741 pstr->substream = substream; 742 else 743 prev->next = substream; 744 745 if (!pcm->internal) { 746 err = snd_pcm_substream_proc_init(substream); 747 if (err < 0) { 748 pcm_err(pcm, 749 "Error in snd_pcm_stream_proc_init\n"); 750 if (prev == NULL) 751 pstr->substream = NULL; 752 else 753 prev->next = NULL; 754 kfree(substream); 755 return err; 756 } 757 } 758 substream->group = &substream->self_group; 759 spin_lock_init(&substream->self_group.lock); 760 mutex_init(&substream->self_group.mutex); 761 INIT_LIST_HEAD(&substream->self_group.substreams); 762 list_add_tail(&substream->link_list, &substream->self_group.substreams); 763 atomic_set(&substream->mmap_count, 0); 764 prev = substream; 765 } 766 return 0; 767 } 768 EXPORT_SYMBOL(snd_pcm_new_stream); 769 770 static int _snd_pcm_new(struct snd_card *card, const char *id, int device, 771 int playback_count, int capture_count, bool internal, 772 struct snd_pcm **rpcm) 773 { 774 struct snd_pcm *pcm; 775 int err; 776 static struct snd_device_ops ops = { 777 .dev_free = snd_pcm_dev_free, 778 .dev_register = snd_pcm_dev_register, 779 .dev_disconnect = snd_pcm_dev_disconnect, 780 }; 781 static struct snd_device_ops internal_ops = { 782 .dev_free = snd_pcm_dev_free, 783 }; 784 785 if (snd_BUG_ON(!card)) 786 return -ENXIO; 787 if (rpcm) 788 *rpcm = NULL; 789 pcm = kzalloc(sizeof(*pcm), GFP_KERNEL); 790 if (!pcm) 791 return -ENOMEM; 792 pcm->card = card; 793 pcm->device = device; 794 pcm->internal = internal; 795 mutex_init(&pcm->open_mutex); 796 init_waitqueue_head(&pcm->open_wait); 797 INIT_LIST_HEAD(&pcm->list); 798 if (id) 799 strlcpy(pcm->id, id, sizeof(pcm->id)); 800 801 err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_PLAYBACK, 802 playback_count); 803 if (err < 0) 804 goto free_pcm; 805 806 err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_CAPTURE, capture_count); 807 if (err < 0) 808 goto free_pcm; 809 810 err = snd_device_new(card, SNDRV_DEV_PCM, pcm, 811 internal ? &internal_ops : &ops); 812 if (err < 0) 813 goto free_pcm; 814 815 if (rpcm) 816 *rpcm = pcm; 817 return 0; 818 819 free_pcm: 820 snd_pcm_free(pcm); 821 return err; 822 } 823 824 /** 825 * snd_pcm_new - create a new PCM instance 826 * @card: the card instance 827 * @id: the id string 828 * @device: the device index (zero based) 829 * @playback_count: the number of substreams for playback 830 * @capture_count: the number of substreams for capture 831 * @rpcm: the pointer to store the new pcm instance 832 * 833 * Creates a new PCM instance. 834 * 835 * The pcm operators have to be set afterwards to the new instance 836 * via snd_pcm_set_ops(). 837 * 838 * Return: Zero if successful, or a negative error code on failure. 839 */ 840 int snd_pcm_new(struct snd_card *card, const char *id, int device, 841 int playback_count, int capture_count, struct snd_pcm **rpcm) 842 { 843 return _snd_pcm_new(card, id, device, playback_count, capture_count, 844 false, rpcm); 845 } 846 EXPORT_SYMBOL(snd_pcm_new); 847 848 /** 849 * snd_pcm_new_internal - create a new internal PCM instance 850 * @card: the card instance 851 * @id: the id string 852 * @device: the device index (zero based - shared with normal PCMs) 853 * @playback_count: the number of substreams for playback 854 * @capture_count: the number of substreams for capture 855 * @rpcm: the pointer to store the new pcm instance 856 * 857 * Creates a new internal PCM instance with no userspace device or procfs 858 * entries. This is used by ASoC Back End PCMs in order to create a PCM that 859 * will only be used internally by kernel drivers. i.e. it cannot be opened 860 * by userspace. It provides existing ASoC components drivers with a substream 861 * and access to any private data. 862 * 863 * The pcm operators have to be set afterwards to the new instance 864 * via snd_pcm_set_ops(). 865 * 866 * Return: Zero if successful, or a negative error code on failure. 867 */ 868 int snd_pcm_new_internal(struct snd_card *card, const char *id, int device, 869 int playback_count, int capture_count, 870 struct snd_pcm **rpcm) 871 { 872 return _snd_pcm_new(card, id, device, playback_count, capture_count, 873 true, rpcm); 874 } 875 EXPORT_SYMBOL(snd_pcm_new_internal); 876 877 static void free_chmap(struct snd_pcm_str *pstr) 878 { 879 if (pstr->chmap_kctl) { 880 snd_ctl_remove(pstr->pcm->card, pstr->chmap_kctl); 881 pstr->chmap_kctl = NULL; 882 } 883 } 884 885 static void snd_pcm_free_stream(struct snd_pcm_str * pstr) 886 { 887 struct snd_pcm_substream *substream, *substream_next; 888 #if IS_ENABLED(CONFIG_SND_PCM_OSS) 889 struct snd_pcm_oss_setup *setup, *setupn; 890 #endif 891 substream = pstr->substream; 892 while (substream) { 893 substream_next = substream->next; 894 snd_pcm_timer_done(substream); 895 snd_pcm_substream_proc_done(substream); 896 kfree(substream); 897 substream = substream_next; 898 } 899 snd_pcm_stream_proc_done(pstr); 900 #if IS_ENABLED(CONFIG_SND_PCM_OSS) 901 for (setup = pstr->oss.setup_list; setup; setup = setupn) { 902 setupn = setup->next; 903 kfree(setup->task_name); 904 kfree(setup); 905 } 906 #endif 907 free_chmap(pstr); 908 if (pstr->substream_count) 909 put_device(&pstr->dev); 910 } 911 912 #if IS_ENABLED(CONFIG_SND_PCM_OSS) 913 #define pcm_call_notify(pcm, call) \ 914 do { \ 915 struct snd_pcm_notify *_notify; \ 916 list_for_each_entry(_notify, &snd_pcm_notify_list, list) \ 917 _notify->call(pcm); \ 918 } while (0) 919 #else 920 #define pcm_call_notify(pcm, call) do {} while (0) 921 #endif 922 923 static int snd_pcm_free(struct snd_pcm *pcm) 924 { 925 if (!pcm) 926 return 0; 927 if (!pcm->internal) 928 pcm_call_notify(pcm, n_unregister); 929 if (pcm->private_free) 930 pcm->private_free(pcm); 931 snd_pcm_lib_preallocate_free_for_all(pcm); 932 snd_pcm_free_stream(&pcm->streams[SNDRV_PCM_STREAM_PLAYBACK]); 933 snd_pcm_free_stream(&pcm->streams[SNDRV_PCM_STREAM_CAPTURE]); 934 kfree(pcm); 935 return 0; 936 } 937 938 static int snd_pcm_dev_free(struct snd_device *device) 939 { 940 struct snd_pcm *pcm = device->device_data; 941 return snd_pcm_free(pcm); 942 } 943 944 int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream, 945 struct file *file, 946 struct snd_pcm_substream **rsubstream) 947 { 948 struct snd_pcm_str * pstr; 949 struct snd_pcm_substream *substream; 950 struct snd_pcm_runtime *runtime; 951 struct snd_card *card; 952 int prefer_subdevice; 953 size_t size; 954 955 if (snd_BUG_ON(!pcm || !rsubstream)) 956 return -ENXIO; 957 if (snd_BUG_ON(stream != SNDRV_PCM_STREAM_PLAYBACK && 958 stream != SNDRV_PCM_STREAM_CAPTURE)) 959 return -EINVAL; 960 *rsubstream = NULL; 961 pstr = &pcm->streams[stream]; 962 if (pstr->substream == NULL || pstr->substream_count == 0) 963 return -ENODEV; 964 965 card = pcm->card; 966 prefer_subdevice = snd_ctl_get_preferred_subdevice(card, SND_CTL_SUBDEV_PCM); 967 968 if (pcm->info_flags & SNDRV_PCM_INFO_HALF_DUPLEX) { 969 int opposite = !stream; 970 971 for (substream = pcm->streams[opposite].substream; substream; 972 substream = substream->next) { 973 if (SUBSTREAM_BUSY(substream)) 974 return -EAGAIN; 975 } 976 } 977 978 if (file->f_flags & O_APPEND) { 979 if (prefer_subdevice < 0) { 980 if (pstr->substream_count > 1) 981 return -EINVAL; /* must be unique */ 982 substream = pstr->substream; 983 } else { 984 for (substream = pstr->substream; substream; 985 substream = substream->next) 986 if (substream->number == prefer_subdevice) 987 break; 988 } 989 if (! substream) 990 return -ENODEV; 991 if (! SUBSTREAM_BUSY(substream)) 992 return -EBADFD; 993 substream->ref_count++; 994 *rsubstream = substream; 995 return 0; 996 } 997 998 for (substream = pstr->substream; substream; substream = substream->next) { 999 if (!SUBSTREAM_BUSY(substream) && 1000 (prefer_subdevice == -1 || 1001 substream->number == prefer_subdevice)) 1002 break; 1003 } 1004 if (substream == NULL) 1005 return -EAGAIN; 1006 1007 runtime = kzalloc(sizeof(*runtime), GFP_KERNEL); 1008 if (runtime == NULL) 1009 return -ENOMEM; 1010 1011 size = PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)); 1012 runtime->status = snd_malloc_pages(size, GFP_KERNEL); 1013 if (runtime->status == NULL) { 1014 kfree(runtime); 1015 return -ENOMEM; 1016 } 1017 memset((void*)runtime->status, 0, size); 1018 1019 size = PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control)); 1020 runtime->control = snd_malloc_pages(size, GFP_KERNEL); 1021 if (runtime->control == NULL) { 1022 snd_free_pages((void*)runtime->status, 1023 PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status))); 1024 kfree(runtime); 1025 return -ENOMEM; 1026 } 1027 memset((void*)runtime->control, 0, size); 1028 1029 init_waitqueue_head(&runtime->sleep); 1030 init_waitqueue_head(&runtime->tsleep); 1031 1032 runtime->status->state = SNDRV_PCM_STATE_OPEN; 1033 1034 substream->runtime = runtime; 1035 substream->private_data = pcm->private_data; 1036 substream->ref_count = 1; 1037 substream->f_flags = file->f_flags; 1038 substream->pid = get_pid(task_pid(current)); 1039 pstr->substream_opened++; 1040 *rsubstream = substream; 1041 return 0; 1042 } 1043 1044 void snd_pcm_detach_substream(struct snd_pcm_substream *substream) 1045 { 1046 struct snd_pcm_runtime *runtime; 1047 1048 if (PCM_RUNTIME_CHECK(substream)) 1049 return; 1050 runtime = substream->runtime; 1051 if (runtime->private_free != NULL) 1052 runtime->private_free(runtime); 1053 snd_free_pages((void*)runtime->status, 1054 PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status))); 1055 snd_free_pages((void*)runtime->control, 1056 PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control))); 1057 kfree(runtime->hw_constraints.rules); 1058 /* Avoid concurrent access to runtime via PCM timer interface */ 1059 if (substream->timer) 1060 spin_lock_irq(&substream->timer->lock); 1061 substream->runtime = NULL; 1062 if (substream->timer) 1063 spin_unlock_irq(&substream->timer->lock); 1064 kfree(runtime); 1065 put_pid(substream->pid); 1066 substream->pid = NULL; 1067 substream->pstr->substream_opened--; 1068 } 1069 1070 static ssize_t show_pcm_class(struct device *dev, 1071 struct device_attribute *attr, char *buf) 1072 { 1073 struct snd_pcm_str *pstr = container_of(dev, struct snd_pcm_str, dev); 1074 struct snd_pcm *pcm = pstr->pcm; 1075 const char *str; 1076 static const char *strs[SNDRV_PCM_CLASS_LAST + 1] = { 1077 [SNDRV_PCM_CLASS_GENERIC] = "generic", 1078 [SNDRV_PCM_CLASS_MULTI] = "multi", 1079 [SNDRV_PCM_CLASS_MODEM] = "modem", 1080 [SNDRV_PCM_CLASS_DIGITIZER] = "digitizer", 1081 }; 1082 1083 if (pcm->dev_class > SNDRV_PCM_CLASS_LAST) 1084 str = "none"; 1085 else 1086 str = strs[pcm->dev_class]; 1087 return snprintf(buf, PAGE_SIZE, "%s\n", str); 1088 } 1089 1090 static DEVICE_ATTR(pcm_class, 0444, show_pcm_class, NULL); 1091 static struct attribute *pcm_dev_attrs[] = { 1092 &dev_attr_pcm_class.attr, 1093 NULL 1094 }; 1095 1096 static const struct attribute_group pcm_dev_attr_group = { 1097 .attrs = pcm_dev_attrs, 1098 }; 1099 1100 static const struct attribute_group *pcm_dev_attr_groups[] = { 1101 &pcm_dev_attr_group, 1102 NULL 1103 }; 1104 1105 static int snd_pcm_dev_register(struct snd_device *device) 1106 { 1107 int cidx, err; 1108 struct snd_pcm_substream *substream; 1109 struct snd_pcm *pcm; 1110 1111 if (snd_BUG_ON(!device || !device->device_data)) 1112 return -ENXIO; 1113 pcm = device->device_data; 1114 1115 mutex_lock(®ister_mutex); 1116 err = snd_pcm_add(pcm); 1117 if (err) 1118 goto unlock; 1119 for (cidx = 0; cidx < 2; cidx++) { 1120 int devtype = -1; 1121 if (pcm->streams[cidx].substream == NULL) 1122 continue; 1123 switch (cidx) { 1124 case SNDRV_PCM_STREAM_PLAYBACK: 1125 devtype = SNDRV_DEVICE_TYPE_PCM_PLAYBACK; 1126 break; 1127 case SNDRV_PCM_STREAM_CAPTURE: 1128 devtype = SNDRV_DEVICE_TYPE_PCM_CAPTURE; 1129 break; 1130 } 1131 /* register pcm */ 1132 err = snd_register_device(devtype, pcm->card, pcm->device, 1133 &snd_pcm_f_ops[cidx], pcm, 1134 &pcm->streams[cidx].dev); 1135 if (err < 0) { 1136 list_del_init(&pcm->list); 1137 goto unlock; 1138 } 1139 1140 for (substream = pcm->streams[cidx].substream; substream; substream = substream->next) 1141 snd_pcm_timer_init(substream); 1142 } 1143 1144 pcm_call_notify(pcm, n_register); 1145 1146 unlock: 1147 mutex_unlock(®ister_mutex); 1148 return err; 1149 } 1150 1151 static int snd_pcm_dev_disconnect(struct snd_device *device) 1152 { 1153 struct snd_pcm *pcm = device->device_data; 1154 struct snd_pcm_substream *substream; 1155 int cidx; 1156 1157 mutex_lock(®ister_mutex); 1158 mutex_lock(&pcm->open_mutex); 1159 wake_up(&pcm->open_wait); 1160 list_del_init(&pcm->list); 1161 for (cidx = 0; cidx < 2; cidx++) { 1162 for (substream = pcm->streams[cidx].substream; substream; substream = substream->next) { 1163 snd_pcm_stream_lock_irq(substream); 1164 if (substream->runtime) { 1165 if (snd_pcm_running(substream)) 1166 snd_pcm_stop(substream, 1167 SNDRV_PCM_STATE_DISCONNECTED); 1168 /* to be sure, set the state unconditionally */ 1169 substream->runtime->status->state = SNDRV_PCM_STATE_DISCONNECTED; 1170 wake_up(&substream->runtime->sleep); 1171 wake_up(&substream->runtime->tsleep); 1172 } 1173 snd_pcm_stream_unlock_irq(substream); 1174 } 1175 } 1176 1177 pcm_call_notify(pcm, n_disconnect); 1178 for (cidx = 0; cidx < 2; cidx++) { 1179 snd_unregister_device(&pcm->streams[cidx].dev); 1180 free_chmap(&pcm->streams[cidx]); 1181 } 1182 mutex_unlock(&pcm->open_mutex); 1183 mutex_unlock(®ister_mutex); 1184 return 0; 1185 } 1186 1187 #if IS_ENABLED(CONFIG_SND_PCM_OSS) 1188 /** 1189 * snd_pcm_notify - Add/remove the notify list 1190 * @notify: PCM notify list 1191 * @nfree: 0 = register, 1 = unregister 1192 * 1193 * This adds the given notifier to the global list so that the callback is 1194 * called for each registered PCM devices. This exists only for PCM OSS 1195 * emulation, so far. 1196 */ 1197 int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree) 1198 { 1199 struct snd_pcm *pcm; 1200 1201 if (snd_BUG_ON(!notify || 1202 !notify->n_register || 1203 !notify->n_unregister || 1204 !notify->n_disconnect)) 1205 return -EINVAL; 1206 mutex_lock(®ister_mutex); 1207 if (nfree) { 1208 list_del(¬ify->list); 1209 list_for_each_entry(pcm, &snd_pcm_devices, list) 1210 notify->n_unregister(pcm); 1211 } else { 1212 list_add_tail(¬ify->list, &snd_pcm_notify_list); 1213 list_for_each_entry(pcm, &snd_pcm_devices, list) 1214 notify->n_register(pcm); 1215 } 1216 mutex_unlock(®ister_mutex); 1217 return 0; 1218 } 1219 EXPORT_SYMBOL(snd_pcm_notify); 1220 #endif /* CONFIG_SND_PCM_OSS */ 1221 1222 #ifdef CONFIG_SND_PROC_FS 1223 /* 1224 * Info interface 1225 */ 1226 1227 static void snd_pcm_proc_read(struct snd_info_entry *entry, 1228 struct snd_info_buffer *buffer) 1229 { 1230 struct snd_pcm *pcm; 1231 1232 mutex_lock(®ister_mutex); 1233 list_for_each_entry(pcm, &snd_pcm_devices, list) { 1234 snd_iprintf(buffer, "%02i-%02i: %s : %s", 1235 pcm->card->number, pcm->device, pcm->id, pcm->name); 1236 if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream) 1237 snd_iprintf(buffer, " : playback %i", 1238 pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream_count); 1239 if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream) 1240 snd_iprintf(buffer, " : capture %i", 1241 pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream_count); 1242 snd_iprintf(buffer, "\n"); 1243 } 1244 mutex_unlock(®ister_mutex); 1245 } 1246 1247 static struct snd_info_entry *snd_pcm_proc_entry; 1248 1249 static void snd_pcm_proc_init(void) 1250 { 1251 struct snd_info_entry *entry; 1252 1253 entry = snd_info_create_module_entry(THIS_MODULE, "pcm", NULL); 1254 if (entry) { 1255 snd_info_set_text_ops(entry, NULL, snd_pcm_proc_read); 1256 if (snd_info_register(entry) < 0) { 1257 snd_info_free_entry(entry); 1258 entry = NULL; 1259 } 1260 } 1261 snd_pcm_proc_entry = entry; 1262 } 1263 1264 static void snd_pcm_proc_done(void) 1265 { 1266 snd_info_free_entry(snd_pcm_proc_entry); 1267 } 1268 1269 #else /* !CONFIG_SND_PROC_FS */ 1270 #define snd_pcm_proc_init() 1271 #define snd_pcm_proc_done() 1272 #endif /* CONFIG_SND_PROC_FS */ 1273 1274 1275 /* 1276 * ENTRY functions 1277 */ 1278 1279 static int __init alsa_pcm_init(void) 1280 { 1281 snd_ctl_register_ioctl(snd_pcm_control_ioctl); 1282 snd_ctl_register_ioctl_compat(snd_pcm_control_ioctl); 1283 snd_pcm_proc_init(); 1284 return 0; 1285 } 1286 1287 static void __exit alsa_pcm_exit(void) 1288 { 1289 snd_ctl_unregister_ioctl(snd_pcm_control_ioctl); 1290 snd_ctl_unregister_ioctl_compat(snd_pcm_control_ioctl); 1291 snd_pcm_proc_done(); 1292 } 1293 1294 module_init(alsa_pcm_init) 1295 module_exit(alsa_pcm_exit) 1296