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