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