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