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