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