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/compat.h> 8 #include <linux/mm.h> 9 #include <linux/module.h> 10 #include <linux/file.h> 11 #include <linux/slab.h> 12 #include <linux/sched/signal.h> 13 #include <linux/time.h> 14 #include <linux/pm_qos.h> 15 #include <linux/io.h> 16 #include <linux/dma-mapping.h> 17 #include <linux/vmalloc.h> 18 #include <sound/core.h> 19 #include <sound/control.h> 20 #include <sound/info.h> 21 #include <sound/pcm.h> 22 #include <sound/pcm_params.h> 23 #include <sound/timer.h> 24 #include <sound/minors.h> 25 #include <linux/uio.h> 26 #include <linux/delay.h> 27 28 #include "pcm_local.h" 29 30 #ifdef CONFIG_SND_DEBUG 31 #define CREATE_TRACE_POINTS 32 #include "pcm_param_trace.h" 33 #else 34 #define trace_hw_mask_param_enabled() 0 35 #define trace_hw_interval_param_enabled() 0 36 #define trace_hw_mask_param(substream, type, index, prev, curr) 37 #define trace_hw_interval_param(substream, type, index, prev, curr) 38 #endif 39 40 /* 41 * Compatibility 42 */ 43 44 struct snd_pcm_hw_params_old { 45 unsigned int flags; 46 unsigned int masks[SNDRV_PCM_HW_PARAM_SUBFORMAT - 47 SNDRV_PCM_HW_PARAM_ACCESS + 1]; 48 struct snd_interval intervals[SNDRV_PCM_HW_PARAM_TICK_TIME - 49 SNDRV_PCM_HW_PARAM_SAMPLE_BITS + 1]; 50 unsigned int rmask; 51 unsigned int cmask; 52 unsigned int info; 53 unsigned int msbits; 54 unsigned int rate_num; 55 unsigned int rate_den; 56 snd_pcm_uframes_t fifo_size; 57 unsigned char reserved[64]; 58 }; 59 60 #ifdef CONFIG_SND_SUPPORT_OLD_API 61 #define SNDRV_PCM_IOCTL_HW_REFINE_OLD _IOWR('A', 0x10, struct snd_pcm_hw_params_old) 62 #define SNDRV_PCM_IOCTL_HW_PARAMS_OLD _IOWR('A', 0x11, struct snd_pcm_hw_params_old) 63 64 static int snd_pcm_hw_refine_old_user(struct snd_pcm_substream *substream, 65 struct snd_pcm_hw_params_old __user * _oparams); 66 static int snd_pcm_hw_params_old_user(struct snd_pcm_substream *substream, 67 struct snd_pcm_hw_params_old __user * _oparams); 68 #endif 69 static int snd_pcm_open(struct file *file, struct snd_pcm *pcm, int stream); 70 71 /* 72 * 73 */ 74 75 static DECLARE_RWSEM(snd_pcm_link_rwsem); 76 77 void snd_pcm_group_init(struct snd_pcm_group *group) 78 { 79 spin_lock_init(&group->lock); 80 mutex_init(&group->mutex); 81 INIT_LIST_HEAD(&group->substreams); 82 refcount_set(&group->refs, 1); 83 } 84 85 /* define group lock helpers */ 86 #define DEFINE_PCM_GROUP_LOCK(action, mutex_action) \ 87 static void snd_pcm_group_ ## action(struct snd_pcm_group *group, bool nonatomic) \ 88 { \ 89 if (nonatomic) \ 90 mutex_ ## mutex_action(&group->mutex); \ 91 else \ 92 spin_ ## action(&group->lock); \ 93 } 94 95 DEFINE_PCM_GROUP_LOCK(lock, lock); 96 DEFINE_PCM_GROUP_LOCK(unlock, unlock); 97 DEFINE_PCM_GROUP_LOCK(lock_irq, lock); 98 DEFINE_PCM_GROUP_LOCK(unlock_irq, unlock); 99 100 /** 101 * snd_pcm_stream_lock - Lock the PCM stream 102 * @substream: PCM substream 103 * 104 * This locks the PCM stream's spinlock or mutex depending on the nonatomic 105 * flag of the given substream. This also takes the global link rw lock 106 * (or rw sem), too, for avoiding the race with linked streams. 107 */ 108 void snd_pcm_stream_lock(struct snd_pcm_substream *substream) 109 { 110 snd_pcm_group_lock(&substream->self_group, substream->pcm->nonatomic); 111 } 112 EXPORT_SYMBOL_GPL(snd_pcm_stream_lock); 113 114 /** 115 * snd_pcm_stream_unlock - Unlock the PCM stream 116 * @substream: PCM substream 117 * 118 * This unlocks the PCM stream that has been locked via snd_pcm_stream_lock(). 119 */ 120 void snd_pcm_stream_unlock(struct snd_pcm_substream *substream) 121 { 122 snd_pcm_group_unlock(&substream->self_group, substream->pcm->nonatomic); 123 } 124 EXPORT_SYMBOL_GPL(snd_pcm_stream_unlock); 125 126 /** 127 * snd_pcm_stream_lock_irq - Lock the PCM stream 128 * @substream: PCM substream 129 * 130 * This locks the PCM stream like snd_pcm_stream_lock() and disables the local 131 * IRQ (only when nonatomic is false). In nonatomic case, this is identical 132 * as snd_pcm_stream_lock(). 133 */ 134 void snd_pcm_stream_lock_irq(struct snd_pcm_substream *substream) 135 { 136 snd_pcm_group_lock_irq(&substream->self_group, 137 substream->pcm->nonatomic); 138 } 139 EXPORT_SYMBOL_GPL(snd_pcm_stream_lock_irq); 140 141 static void snd_pcm_stream_lock_nested(struct snd_pcm_substream *substream) 142 { 143 struct snd_pcm_group *group = &substream->self_group; 144 145 if (substream->pcm->nonatomic) 146 mutex_lock_nested(&group->mutex, SINGLE_DEPTH_NESTING); 147 else 148 spin_lock_nested(&group->lock, SINGLE_DEPTH_NESTING); 149 } 150 151 /** 152 * snd_pcm_stream_unlock_irq - Unlock the PCM stream 153 * @substream: PCM substream 154 * 155 * This is a counter-part of snd_pcm_stream_lock_irq(). 156 */ 157 void snd_pcm_stream_unlock_irq(struct snd_pcm_substream *substream) 158 { 159 snd_pcm_group_unlock_irq(&substream->self_group, 160 substream->pcm->nonatomic); 161 } 162 EXPORT_SYMBOL_GPL(snd_pcm_stream_unlock_irq); 163 164 unsigned long _snd_pcm_stream_lock_irqsave(struct snd_pcm_substream *substream) 165 { 166 unsigned long flags = 0; 167 if (substream->pcm->nonatomic) 168 mutex_lock(&substream->self_group.mutex); 169 else 170 spin_lock_irqsave(&substream->self_group.lock, flags); 171 return flags; 172 } 173 EXPORT_SYMBOL_GPL(_snd_pcm_stream_lock_irqsave); 174 175 unsigned long _snd_pcm_stream_lock_irqsave_nested(struct snd_pcm_substream *substream) 176 { 177 unsigned long flags = 0; 178 if (substream->pcm->nonatomic) 179 mutex_lock_nested(&substream->self_group.mutex, 180 SINGLE_DEPTH_NESTING); 181 else 182 spin_lock_irqsave_nested(&substream->self_group.lock, flags, 183 SINGLE_DEPTH_NESTING); 184 return flags; 185 } 186 EXPORT_SYMBOL_GPL(_snd_pcm_stream_lock_irqsave_nested); 187 188 /** 189 * snd_pcm_stream_unlock_irqrestore - Unlock the PCM stream 190 * @substream: PCM substream 191 * @flags: irq flags 192 * 193 * This is a counter-part of snd_pcm_stream_lock_irqsave(). 194 */ 195 void snd_pcm_stream_unlock_irqrestore(struct snd_pcm_substream *substream, 196 unsigned long flags) 197 { 198 if (substream->pcm->nonatomic) 199 mutex_unlock(&substream->self_group.mutex); 200 else 201 spin_unlock_irqrestore(&substream->self_group.lock, flags); 202 } 203 EXPORT_SYMBOL_GPL(snd_pcm_stream_unlock_irqrestore); 204 205 /* Run PCM ioctl ops */ 206 static int snd_pcm_ops_ioctl(struct snd_pcm_substream *substream, 207 unsigned cmd, void *arg) 208 { 209 if (substream->ops->ioctl) 210 return substream->ops->ioctl(substream, cmd, arg); 211 else 212 return snd_pcm_lib_ioctl(substream, cmd, arg); 213 } 214 215 int snd_pcm_info(struct snd_pcm_substream *substream, struct snd_pcm_info *info) 216 { 217 struct snd_pcm *pcm = substream->pcm; 218 struct snd_pcm_str *pstr = substream->pstr; 219 220 memset(info, 0, sizeof(*info)); 221 info->card = pcm->card->number; 222 info->device = pcm->device; 223 info->stream = substream->stream; 224 info->subdevice = substream->number; 225 strscpy(info->id, pcm->id, sizeof(info->id)); 226 strscpy(info->name, pcm->name, sizeof(info->name)); 227 info->dev_class = pcm->dev_class; 228 info->dev_subclass = pcm->dev_subclass; 229 info->subdevices_count = pstr->substream_count; 230 info->subdevices_avail = pstr->substream_count - pstr->substream_opened; 231 strscpy(info->subname, substream->name, sizeof(info->subname)); 232 233 return 0; 234 } 235 236 int snd_pcm_info_user(struct snd_pcm_substream *substream, 237 struct snd_pcm_info __user * _info) 238 { 239 struct snd_pcm_info *info __free(kfree) = NULL; 240 int err; 241 242 info = kmalloc(sizeof(*info), GFP_KERNEL); 243 if (! info) 244 return -ENOMEM; 245 err = snd_pcm_info(substream, info); 246 if (err >= 0) { 247 if (copy_to_user(_info, info, sizeof(*info))) 248 err = -EFAULT; 249 } 250 return err; 251 } 252 253 /* macro for simplified cast */ 254 #define PARAM_MASK_BIT(b) (1U << (__force int)(b)) 255 256 static bool hw_support_mmap(struct snd_pcm_substream *substream) 257 { 258 struct snd_dma_buffer *dmabuf; 259 260 if (!(substream->runtime->hw.info & SNDRV_PCM_INFO_MMAP)) 261 return false; 262 263 if (substream->ops->mmap || substream->ops->page) 264 return true; 265 266 dmabuf = snd_pcm_get_dma_buf(substream); 267 if (!dmabuf) 268 dmabuf = &substream->dma_buffer; 269 switch (dmabuf->dev.type) { 270 case SNDRV_DMA_TYPE_UNKNOWN: 271 /* we can't know the device, so just assume that the driver does 272 * everything right 273 */ 274 return true; 275 case SNDRV_DMA_TYPE_CONTINUOUS: 276 case SNDRV_DMA_TYPE_VMALLOC: 277 return true; 278 default: 279 return dma_can_mmap(dmabuf->dev.dev); 280 } 281 } 282 283 static int constrain_mask_params(struct snd_pcm_substream *substream, 284 struct snd_pcm_hw_params *params) 285 { 286 struct snd_pcm_hw_constraints *constrs = 287 &substream->runtime->hw_constraints; 288 struct snd_mask *m; 289 unsigned int k; 290 struct snd_mask old_mask __maybe_unused; 291 int changed; 292 293 for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++) { 294 m = hw_param_mask(params, k); 295 if (snd_mask_empty(m)) 296 return -EINVAL; 297 298 /* This parameter is not requested to change by a caller. */ 299 if (!(params->rmask & PARAM_MASK_BIT(k))) 300 continue; 301 302 if (trace_hw_mask_param_enabled()) 303 old_mask = *m; 304 305 changed = snd_mask_refine(m, constrs_mask(constrs, k)); 306 if (changed < 0) 307 return changed; 308 if (changed == 0) 309 continue; 310 311 /* Set corresponding flag so that the caller gets it. */ 312 trace_hw_mask_param(substream, k, 0, &old_mask, m); 313 params->cmask |= PARAM_MASK_BIT(k); 314 } 315 316 return 0; 317 } 318 319 static int constrain_interval_params(struct snd_pcm_substream *substream, 320 struct snd_pcm_hw_params *params) 321 { 322 struct snd_pcm_hw_constraints *constrs = 323 &substream->runtime->hw_constraints; 324 struct snd_interval *i; 325 unsigned int k; 326 struct snd_interval old_interval __maybe_unused; 327 int changed; 328 329 for (k = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++) { 330 i = hw_param_interval(params, k); 331 if (snd_interval_empty(i)) 332 return -EINVAL; 333 334 /* This parameter is not requested to change by a caller. */ 335 if (!(params->rmask & PARAM_MASK_BIT(k))) 336 continue; 337 338 if (trace_hw_interval_param_enabled()) 339 old_interval = *i; 340 341 changed = snd_interval_refine(i, constrs_interval(constrs, k)); 342 if (changed < 0) 343 return changed; 344 if (changed == 0) 345 continue; 346 347 /* Set corresponding flag so that the caller gets it. */ 348 trace_hw_interval_param(substream, k, 0, &old_interval, i); 349 params->cmask |= PARAM_MASK_BIT(k); 350 } 351 352 return 0; 353 } 354 355 static int constrain_params_by_rules(struct snd_pcm_substream *substream, 356 struct snd_pcm_hw_params *params) 357 { 358 struct snd_pcm_hw_constraints *constrs = 359 &substream->runtime->hw_constraints; 360 unsigned int k; 361 unsigned int *rstamps __free(kfree) = NULL; 362 unsigned int vstamps[SNDRV_PCM_HW_PARAM_LAST_INTERVAL + 1]; 363 unsigned int stamp; 364 struct snd_pcm_hw_rule *r; 365 unsigned int d; 366 struct snd_mask old_mask __maybe_unused; 367 struct snd_interval old_interval __maybe_unused; 368 bool again; 369 int changed, err = 0; 370 371 /* 372 * Each application of rule has own sequence number. 373 * 374 * Each member of 'rstamps' array represents the sequence number of 375 * recent application of corresponding rule. 376 */ 377 rstamps = kcalloc(constrs->rules_num, sizeof(unsigned int), GFP_KERNEL); 378 if (!rstamps) 379 return -ENOMEM; 380 381 /* 382 * Each member of 'vstamps' array represents the sequence number of 383 * recent application of rule in which corresponding parameters were 384 * changed. 385 * 386 * In initial state, elements corresponding to parameters requested by 387 * a caller is 1. For unrequested parameters, corresponding members 388 * have 0 so that the parameters are never changed anymore. 389 */ 390 for (k = 0; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++) 391 vstamps[k] = (params->rmask & PARAM_MASK_BIT(k)) ? 1 : 0; 392 393 /* Due to the above design, actual sequence number starts at 2. */ 394 stamp = 2; 395 retry: 396 /* Apply all rules in order. */ 397 again = false; 398 for (k = 0; k < constrs->rules_num; k++) { 399 r = &constrs->rules[k]; 400 401 /* 402 * Check condition bits of this rule. When the rule has 403 * some condition bits, parameter without the bits is 404 * never processed. SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP 405 * is an example of the condition bits. 406 */ 407 if (r->cond && !(r->cond & params->flags)) 408 continue; 409 410 /* 411 * The 'deps' array includes maximum four dependencies 412 * to SNDRV_PCM_HW_PARAM_XXXs for this rule. The fifth 413 * member of this array is a sentinel and should be 414 * negative value. 415 * 416 * This rule should be processed in this time when dependent 417 * parameters were changed at former applications of the other 418 * rules. 419 */ 420 for (d = 0; r->deps[d] >= 0; d++) { 421 if (vstamps[r->deps[d]] > rstamps[k]) 422 break; 423 } 424 if (r->deps[d] < 0) 425 continue; 426 427 if (trace_hw_mask_param_enabled()) { 428 if (hw_is_mask(r->var)) 429 old_mask = *hw_param_mask(params, r->var); 430 } 431 if (trace_hw_interval_param_enabled()) { 432 if (hw_is_interval(r->var)) 433 old_interval = *hw_param_interval(params, r->var); 434 } 435 436 changed = r->func(params, r); 437 if (changed < 0) 438 return changed; 439 440 /* 441 * When the parameter is changed, notify it to the caller 442 * by corresponding returned bit, then preparing for next 443 * iteration. 444 */ 445 if (changed && r->var >= 0) { 446 if (hw_is_mask(r->var)) { 447 trace_hw_mask_param(substream, r->var, 448 k + 1, &old_mask, 449 hw_param_mask(params, r->var)); 450 } 451 if (hw_is_interval(r->var)) { 452 trace_hw_interval_param(substream, r->var, 453 k + 1, &old_interval, 454 hw_param_interval(params, r->var)); 455 } 456 457 params->cmask |= PARAM_MASK_BIT(r->var); 458 vstamps[r->var] = stamp; 459 again = true; 460 } 461 462 rstamps[k] = stamp++; 463 } 464 465 /* Iterate to evaluate all rules till no parameters are changed. */ 466 if (again) 467 goto retry; 468 469 return err; 470 } 471 472 static int fixup_unreferenced_params(struct snd_pcm_substream *substream, 473 struct snd_pcm_hw_params *params) 474 { 475 const struct snd_interval *i; 476 const struct snd_mask *m; 477 struct snd_mask *m_rw; 478 int err; 479 480 if (!params->msbits) { 481 i = hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS); 482 if (snd_interval_single(i)) 483 params->msbits = snd_interval_value(i); 484 m = hw_param_mask_c(params, SNDRV_PCM_HW_PARAM_FORMAT); 485 if (snd_mask_single(m)) { 486 snd_pcm_format_t format = (__force snd_pcm_format_t)snd_mask_min(m); 487 params->msbits = snd_pcm_format_width(format); 488 } 489 } 490 491 if (params->msbits) { 492 m = hw_param_mask_c(params, SNDRV_PCM_HW_PARAM_FORMAT); 493 if (snd_mask_single(m)) { 494 snd_pcm_format_t format = (__force snd_pcm_format_t)snd_mask_min(m); 495 496 if (snd_pcm_format_linear(format) && 497 snd_pcm_format_width(format) != params->msbits) { 498 m_rw = hw_param_mask(params, SNDRV_PCM_HW_PARAM_SUBFORMAT); 499 snd_mask_reset(m_rw, 500 (__force unsigned)SNDRV_PCM_SUBFORMAT_MSBITS_MAX); 501 if (snd_mask_empty(m_rw)) 502 return -EINVAL; 503 } 504 } 505 } 506 507 if (!params->rate_den) { 508 i = hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_RATE); 509 if (snd_interval_single(i)) { 510 params->rate_num = snd_interval_value(i); 511 params->rate_den = 1; 512 } 513 } 514 515 if (!params->fifo_size) { 516 m = hw_param_mask_c(params, SNDRV_PCM_HW_PARAM_FORMAT); 517 i = hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_CHANNELS); 518 if (snd_mask_single(m) && snd_interval_single(i)) { 519 err = snd_pcm_ops_ioctl(substream, 520 SNDRV_PCM_IOCTL1_FIFO_SIZE, 521 params); 522 if (err < 0) 523 return err; 524 } 525 } 526 527 if (!params->info) { 528 params->info = substream->runtime->hw.info; 529 params->info &= ~(SNDRV_PCM_INFO_FIFO_IN_FRAMES | 530 SNDRV_PCM_INFO_DRAIN_TRIGGER); 531 if (!hw_support_mmap(substream)) 532 params->info &= ~(SNDRV_PCM_INFO_MMAP | 533 SNDRV_PCM_INFO_MMAP_VALID); 534 } 535 536 err = snd_pcm_ops_ioctl(substream, 537 SNDRV_PCM_IOCTL1_SYNC_ID, 538 params); 539 if (err < 0) 540 return err; 541 542 return 0; 543 } 544 545 int snd_pcm_hw_refine(struct snd_pcm_substream *substream, 546 struct snd_pcm_hw_params *params) 547 { 548 int err; 549 550 params->info = 0; 551 params->fifo_size = 0; 552 if (params->rmask & PARAM_MASK_BIT(SNDRV_PCM_HW_PARAM_SAMPLE_BITS)) 553 params->msbits = 0; 554 if (params->rmask & PARAM_MASK_BIT(SNDRV_PCM_HW_PARAM_RATE)) { 555 params->rate_num = 0; 556 params->rate_den = 0; 557 } 558 559 err = constrain_mask_params(substream, params); 560 if (err < 0) 561 return err; 562 563 err = constrain_interval_params(substream, params); 564 if (err < 0) 565 return err; 566 567 err = constrain_params_by_rules(substream, params); 568 if (err < 0) 569 return err; 570 571 params->rmask = 0; 572 573 return 0; 574 } 575 EXPORT_SYMBOL(snd_pcm_hw_refine); 576 577 static int snd_pcm_hw_refine_user(struct snd_pcm_substream *substream, 578 struct snd_pcm_hw_params __user * _params) 579 { 580 struct snd_pcm_hw_params *params __free(kfree) = NULL; 581 int err; 582 583 params = memdup_user(_params, sizeof(*params)); 584 if (IS_ERR(params)) 585 return PTR_ERR(no_free_ptr(params)); 586 587 err = snd_pcm_hw_refine(substream, params); 588 if (err < 0) 589 return err; 590 591 err = fixup_unreferenced_params(substream, params); 592 if (err < 0) 593 return err; 594 595 if (copy_to_user(_params, params, sizeof(*params))) 596 return -EFAULT; 597 return 0; 598 } 599 600 static int period_to_usecs(struct snd_pcm_runtime *runtime) 601 { 602 int usecs; 603 604 if (! runtime->rate) 605 return -1; /* invalid */ 606 607 /* take 75% of period time as the deadline */ 608 usecs = (750000 / runtime->rate) * runtime->period_size; 609 usecs += ((750000 % runtime->rate) * runtime->period_size) / 610 runtime->rate; 611 612 return usecs; 613 } 614 615 static void snd_pcm_set_state(struct snd_pcm_substream *substream, 616 snd_pcm_state_t state) 617 { 618 guard(pcm_stream_lock_irq)(substream); 619 if (substream->runtime->state != SNDRV_PCM_STATE_DISCONNECTED) 620 __snd_pcm_set_state(substream->runtime, state); 621 } 622 623 static inline void snd_pcm_timer_notify(struct snd_pcm_substream *substream, 624 int event) 625 { 626 #ifdef CONFIG_SND_PCM_TIMER 627 if (substream->timer) 628 snd_timer_notify(substream->timer, event, 629 &substream->runtime->trigger_tstamp); 630 #endif 631 } 632 633 void snd_pcm_sync_stop(struct snd_pcm_substream *substream, bool sync_irq) 634 { 635 if (substream->runtime && substream->runtime->stop_operating) { 636 substream->runtime->stop_operating = false; 637 if (substream->ops && substream->ops->sync_stop) 638 substream->ops->sync_stop(substream); 639 else if (sync_irq && substream->pcm->card->sync_irq > 0) 640 synchronize_irq(substream->pcm->card->sync_irq); 641 } 642 } 643 644 /** 645 * snd_pcm_hw_params_choose - choose a configuration defined by @params 646 * @pcm: PCM instance 647 * @params: the hw_params instance 648 * 649 * Choose one configuration from configuration space defined by @params. 650 * The configuration chosen is that obtained fixing in this order: 651 * first access, first format, first subformat, min channels, 652 * min rate, min period time, max buffer size, min tick time 653 * 654 * Return: Zero if successful, or a negative error code on failure. 655 */ 656 static int snd_pcm_hw_params_choose(struct snd_pcm_substream *pcm, 657 struct snd_pcm_hw_params *params) 658 { 659 static const int vars[] = { 660 SNDRV_PCM_HW_PARAM_ACCESS, 661 SNDRV_PCM_HW_PARAM_FORMAT, 662 SNDRV_PCM_HW_PARAM_SUBFORMAT, 663 SNDRV_PCM_HW_PARAM_CHANNELS, 664 SNDRV_PCM_HW_PARAM_RATE, 665 SNDRV_PCM_HW_PARAM_PERIOD_TIME, 666 SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 667 SNDRV_PCM_HW_PARAM_TICK_TIME, 668 -1 669 }; 670 const int *v; 671 struct snd_mask old_mask __maybe_unused; 672 struct snd_interval old_interval __maybe_unused; 673 int changed; 674 675 for (v = vars; *v != -1; v++) { 676 /* Keep old parameter to trace. */ 677 if (trace_hw_mask_param_enabled()) { 678 if (hw_is_mask(*v)) 679 old_mask = *hw_param_mask(params, *v); 680 } 681 if (trace_hw_interval_param_enabled()) { 682 if (hw_is_interval(*v)) 683 old_interval = *hw_param_interval(params, *v); 684 } 685 if (*v != SNDRV_PCM_HW_PARAM_BUFFER_SIZE) 686 changed = snd_pcm_hw_param_first(pcm, params, *v, NULL); 687 else 688 changed = snd_pcm_hw_param_last(pcm, params, *v, NULL); 689 if (changed < 0) 690 return changed; 691 if (changed == 0) 692 continue; 693 694 /* Trace the changed parameter. */ 695 if (hw_is_mask(*v)) { 696 trace_hw_mask_param(pcm, *v, 0, &old_mask, 697 hw_param_mask(params, *v)); 698 } 699 if (hw_is_interval(*v)) { 700 trace_hw_interval_param(pcm, *v, 0, &old_interval, 701 hw_param_interval(params, *v)); 702 } 703 } 704 705 return 0; 706 } 707 708 /* acquire buffer_mutex; if it's in r/w operation, return -EBUSY, otherwise 709 * block the further r/w operations 710 */ 711 static int snd_pcm_buffer_access_lock(struct snd_pcm_runtime *runtime) 712 { 713 if (!atomic_dec_unless_positive(&runtime->buffer_accessing)) 714 return -EBUSY; 715 mutex_lock(&runtime->buffer_mutex); 716 return 0; /* keep buffer_mutex, unlocked by below */ 717 } 718 719 /* release buffer_mutex and clear r/w access flag */ 720 static void snd_pcm_buffer_access_unlock(struct snd_pcm_runtime *runtime) 721 { 722 mutex_unlock(&runtime->buffer_mutex); 723 atomic_inc(&runtime->buffer_accessing); 724 } 725 726 #if IS_ENABLED(CONFIG_SND_PCM_OSS) 727 #define is_oss_stream(substream) ((substream)->oss.oss) 728 #else 729 #define is_oss_stream(substream) false 730 #endif 731 732 static int snd_pcm_hw_params(struct snd_pcm_substream *substream, 733 struct snd_pcm_hw_params *params) 734 { 735 struct snd_pcm_runtime *runtime; 736 int err, usecs; 737 unsigned int bits; 738 snd_pcm_uframes_t frames; 739 740 if (PCM_RUNTIME_CHECK(substream)) 741 return -ENXIO; 742 runtime = substream->runtime; 743 err = snd_pcm_buffer_access_lock(runtime); 744 if (err < 0) 745 return err; 746 scoped_guard(pcm_stream_lock_irq, substream) { 747 switch (runtime->state) { 748 case SNDRV_PCM_STATE_OPEN: 749 case SNDRV_PCM_STATE_SETUP: 750 case SNDRV_PCM_STATE_PREPARED: 751 if (!is_oss_stream(substream) && 752 atomic_read(&substream->mmap_count)) 753 err = -EBADFD; 754 break; 755 default: 756 err = -EBADFD; 757 break; 758 } 759 } 760 if (err) 761 goto unlock; 762 763 snd_pcm_sync_stop(substream, true); 764 765 params->rmask = ~0U; 766 err = snd_pcm_hw_refine(substream, params); 767 if (err < 0) 768 goto _error; 769 770 err = snd_pcm_hw_params_choose(substream, params); 771 if (err < 0) 772 goto _error; 773 774 err = fixup_unreferenced_params(substream, params); 775 if (err < 0) 776 goto _error; 777 778 if (substream->managed_buffer_alloc) { 779 err = snd_pcm_lib_malloc_pages(substream, 780 params_buffer_bytes(params)); 781 if (err < 0) 782 goto _error; 783 runtime->buffer_changed = err > 0; 784 } 785 786 if (substream->ops->hw_params != NULL) { 787 err = substream->ops->hw_params(substream, params); 788 if (err < 0) 789 goto _error; 790 } 791 792 runtime->access = params_access(params); 793 runtime->format = params_format(params); 794 runtime->subformat = params_subformat(params); 795 runtime->channels = params_channels(params); 796 runtime->rate = params_rate(params); 797 runtime->period_size = params_period_size(params); 798 runtime->periods = params_periods(params); 799 runtime->buffer_size = params_buffer_size(params); 800 runtime->info = params->info; 801 runtime->rate_num = params->rate_num; 802 runtime->rate_den = params->rate_den; 803 runtime->no_period_wakeup = 804 (params->info & SNDRV_PCM_INFO_NO_PERIOD_WAKEUP) && 805 (params->flags & SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP); 806 807 bits = snd_pcm_format_physical_width(runtime->format); 808 runtime->sample_bits = bits; 809 bits *= runtime->channels; 810 runtime->frame_bits = bits; 811 frames = 1; 812 while (bits % 8 != 0) { 813 bits *= 2; 814 frames *= 2; 815 } 816 runtime->byte_align = bits / 8; 817 runtime->min_align = frames; 818 819 /* Default sw params */ 820 runtime->tstamp_mode = SNDRV_PCM_TSTAMP_NONE; 821 runtime->period_step = 1; 822 runtime->control->avail_min = runtime->period_size; 823 runtime->start_threshold = 1; 824 runtime->stop_threshold = runtime->buffer_size; 825 runtime->silence_threshold = 0; 826 runtime->silence_size = 0; 827 runtime->boundary = runtime->buffer_size; 828 while (runtime->boundary * 2 <= LONG_MAX - runtime->buffer_size) 829 runtime->boundary *= 2; 830 831 /* clear the buffer for avoiding possible kernel info leaks */ 832 if (runtime->dma_area && !substream->ops->copy) { 833 size_t size = runtime->dma_bytes; 834 835 if (runtime->info & SNDRV_PCM_INFO_MMAP) 836 size = PAGE_ALIGN(size); 837 memset(runtime->dma_area, 0, size); 838 } 839 840 snd_pcm_timer_resolution_change(substream); 841 snd_pcm_set_state(substream, SNDRV_PCM_STATE_SETUP); 842 843 if (cpu_latency_qos_request_active(&substream->latency_pm_qos_req)) 844 cpu_latency_qos_remove_request(&substream->latency_pm_qos_req); 845 usecs = period_to_usecs(runtime); 846 if (usecs >= 0) 847 cpu_latency_qos_add_request(&substream->latency_pm_qos_req, 848 usecs); 849 err = 0; 850 _error: 851 if (err) { 852 /* hardware might be unusable from this time, 853 * so we force application to retry to set 854 * the correct hardware parameter settings 855 */ 856 snd_pcm_set_state(substream, SNDRV_PCM_STATE_OPEN); 857 if (substream->ops->hw_free != NULL) 858 substream->ops->hw_free(substream); 859 if (substream->managed_buffer_alloc) 860 snd_pcm_lib_free_pages(substream); 861 } 862 unlock: 863 snd_pcm_buffer_access_unlock(runtime); 864 return err; 865 } 866 867 static int snd_pcm_hw_params_user(struct snd_pcm_substream *substream, 868 struct snd_pcm_hw_params __user * _params) 869 { 870 struct snd_pcm_hw_params *params __free(kfree) = NULL; 871 int err; 872 873 params = memdup_user(_params, sizeof(*params)); 874 if (IS_ERR(params)) 875 return PTR_ERR(no_free_ptr(params)); 876 877 err = snd_pcm_hw_params(substream, params); 878 if (err < 0) 879 return err; 880 881 if (copy_to_user(_params, params, sizeof(*params))) 882 return -EFAULT; 883 return err; 884 } 885 886 static int do_hw_free(struct snd_pcm_substream *substream) 887 { 888 int result = 0; 889 890 snd_pcm_sync_stop(substream, true); 891 if (substream->ops->hw_free) 892 result = substream->ops->hw_free(substream); 893 if (substream->managed_buffer_alloc) 894 snd_pcm_lib_free_pages(substream); 895 return result; 896 } 897 898 static int snd_pcm_hw_free(struct snd_pcm_substream *substream) 899 { 900 struct snd_pcm_runtime *runtime; 901 int result = 0; 902 903 if (PCM_RUNTIME_CHECK(substream)) 904 return -ENXIO; 905 runtime = substream->runtime; 906 result = snd_pcm_buffer_access_lock(runtime); 907 if (result < 0) 908 return result; 909 scoped_guard(pcm_stream_lock_irq, substream) { 910 switch (runtime->state) { 911 case SNDRV_PCM_STATE_SETUP: 912 case SNDRV_PCM_STATE_PREPARED: 913 if (atomic_read(&substream->mmap_count)) 914 result = -EBADFD; 915 break; 916 default: 917 result = -EBADFD; 918 break; 919 } 920 } 921 if (result) 922 goto unlock; 923 result = do_hw_free(substream); 924 snd_pcm_set_state(substream, SNDRV_PCM_STATE_OPEN); 925 cpu_latency_qos_remove_request(&substream->latency_pm_qos_req); 926 unlock: 927 snd_pcm_buffer_access_unlock(runtime); 928 return result; 929 } 930 931 static int snd_pcm_sw_params(struct snd_pcm_substream *substream, 932 struct snd_pcm_sw_params *params) 933 { 934 struct snd_pcm_runtime *runtime; 935 int err; 936 937 if (PCM_RUNTIME_CHECK(substream)) 938 return -ENXIO; 939 runtime = substream->runtime; 940 scoped_guard(pcm_stream_lock_irq, substream) { 941 if (runtime->state == SNDRV_PCM_STATE_OPEN) 942 return -EBADFD; 943 } 944 945 if (params->tstamp_mode < 0 || 946 params->tstamp_mode > SNDRV_PCM_TSTAMP_LAST) 947 return -EINVAL; 948 if (params->proto >= SNDRV_PROTOCOL_VERSION(2, 0, 12) && 949 params->tstamp_type > SNDRV_PCM_TSTAMP_TYPE_LAST) 950 return -EINVAL; 951 if (params->avail_min == 0) 952 return -EINVAL; 953 if (params->silence_size >= runtime->boundary) { 954 if (params->silence_threshold != 0) 955 return -EINVAL; 956 } else { 957 if (params->silence_size > params->silence_threshold) 958 return -EINVAL; 959 if (params->silence_threshold > runtime->buffer_size) 960 return -EINVAL; 961 } 962 err = 0; 963 scoped_guard(pcm_stream_lock_irq, substream) { 964 runtime->tstamp_mode = params->tstamp_mode; 965 if (params->proto >= SNDRV_PROTOCOL_VERSION(2, 0, 12)) 966 runtime->tstamp_type = params->tstamp_type; 967 runtime->period_step = params->period_step; 968 runtime->control->avail_min = params->avail_min; 969 runtime->start_threshold = params->start_threshold; 970 runtime->stop_threshold = params->stop_threshold; 971 runtime->silence_threshold = params->silence_threshold; 972 runtime->silence_size = params->silence_size; 973 params->boundary = runtime->boundary; 974 if (snd_pcm_running(substream)) { 975 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && 976 runtime->silence_size > 0) 977 snd_pcm_playback_silence(substream, ULONG_MAX); 978 err = snd_pcm_update_state(substream, runtime); 979 } 980 } 981 return err; 982 } 983 984 static int snd_pcm_sw_params_user(struct snd_pcm_substream *substream, 985 struct snd_pcm_sw_params __user * _params) 986 { 987 struct snd_pcm_sw_params params; 988 int err; 989 if (copy_from_user(¶ms, _params, sizeof(params))) 990 return -EFAULT; 991 err = snd_pcm_sw_params(substream, ¶ms); 992 if (copy_to_user(_params, ¶ms, sizeof(params))) 993 return -EFAULT; 994 return err; 995 } 996 997 static inline snd_pcm_uframes_t 998 snd_pcm_calc_delay(struct snd_pcm_substream *substream) 999 { 1000 snd_pcm_uframes_t delay; 1001 1002 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 1003 delay = snd_pcm_playback_hw_avail(substream->runtime); 1004 else 1005 delay = snd_pcm_capture_avail(substream->runtime); 1006 return delay + substream->runtime->delay; 1007 } 1008 1009 int snd_pcm_status64(struct snd_pcm_substream *substream, 1010 struct snd_pcm_status64 *status) 1011 { 1012 struct snd_pcm_runtime *runtime = substream->runtime; 1013 1014 guard(pcm_stream_lock_irq)(substream); 1015 1016 snd_pcm_unpack_audio_tstamp_config(status->audio_tstamp_data, 1017 &runtime->audio_tstamp_config); 1018 1019 /* backwards compatible behavior */ 1020 if (runtime->audio_tstamp_config.type_requested == 1021 SNDRV_PCM_AUDIO_TSTAMP_TYPE_COMPAT) { 1022 if (runtime->hw.info & SNDRV_PCM_INFO_HAS_WALL_CLOCK) 1023 runtime->audio_tstamp_config.type_requested = 1024 SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK; 1025 else 1026 runtime->audio_tstamp_config.type_requested = 1027 SNDRV_PCM_AUDIO_TSTAMP_TYPE_DEFAULT; 1028 runtime->audio_tstamp_report.valid = 0; 1029 } else 1030 runtime->audio_tstamp_report.valid = 1; 1031 1032 status->state = runtime->state; 1033 status->suspended_state = runtime->suspended_state; 1034 if (status->state == SNDRV_PCM_STATE_OPEN) 1035 return 0; 1036 status->trigger_tstamp_sec = runtime->trigger_tstamp.tv_sec; 1037 status->trigger_tstamp_nsec = runtime->trigger_tstamp.tv_nsec; 1038 if (snd_pcm_running(substream)) { 1039 snd_pcm_update_hw_ptr(substream); 1040 if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE) { 1041 status->tstamp_sec = runtime->status->tstamp.tv_sec; 1042 status->tstamp_nsec = 1043 runtime->status->tstamp.tv_nsec; 1044 status->driver_tstamp_sec = 1045 runtime->driver_tstamp.tv_sec; 1046 status->driver_tstamp_nsec = 1047 runtime->driver_tstamp.tv_nsec; 1048 status->audio_tstamp_sec = 1049 runtime->status->audio_tstamp.tv_sec; 1050 status->audio_tstamp_nsec = 1051 runtime->status->audio_tstamp.tv_nsec; 1052 if (runtime->audio_tstamp_report.valid == 1) 1053 /* backwards compatibility, no report provided in COMPAT mode */ 1054 snd_pcm_pack_audio_tstamp_report(&status->audio_tstamp_data, 1055 &status->audio_tstamp_accuracy, 1056 &runtime->audio_tstamp_report); 1057 1058 goto _tstamp_end; 1059 } 1060 } else { 1061 /* get tstamp only in fallback mode and only if enabled */ 1062 if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE) { 1063 struct timespec64 tstamp; 1064 1065 snd_pcm_gettime(runtime, &tstamp); 1066 status->tstamp_sec = tstamp.tv_sec; 1067 status->tstamp_nsec = tstamp.tv_nsec; 1068 } 1069 } 1070 _tstamp_end: 1071 status->appl_ptr = runtime->control->appl_ptr; 1072 status->hw_ptr = runtime->status->hw_ptr; 1073 status->avail = snd_pcm_avail(substream); 1074 status->delay = snd_pcm_running(substream) ? 1075 snd_pcm_calc_delay(substream) : 0; 1076 status->avail_max = runtime->avail_max; 1077 status->overrange = runtime->overrange; 1078 runtime->avail_max = 0; 1079 runtime->overrange = 0; 1080 return 0; 1081 } 1082 1083 static int snd_pcm_status_user64(struct snd_pcm_substream *substream, 1084 struct snd_pcm_status64 __user * _status, 1085 bool ext) 1086 { 1087 struct snd_pcm_status64 status; 1088 int res; 1089 1090 memset(&status, 0, sizeof(status)); 1091 /* 1092 * with extension, parameters are read/write, 1093 * get audio_tstamp_data from user, 1094 * ignore rest of status structure 1095 */ 1096 if (ext && get_user(status.audio_tstamp_data, 1097 (u32 __user *)(&_status->audio_tstamp_data))) 1098 return -EFAULT; 1099 res = snd_pcm_status64(substream, &status); 1100 if (res < 0) 1101 return res; 1102 if (copy_to_user(_status, &status, sizeof(status))) 1103 return -EFAULT; 1104 return 0; 1105 } 1106 1107 static int snd_pcm_status_user32(struct snd_pcm_substream *substream, 1108 struct snd_pcm_status32 __user * _status, 1109 bool ext) 1110 { 1111 struct snd_pcm_status64 status64; 1112 struct snd_pcm_status32 status32; 1113 int res; 1114 1115 memset(&status64, 0, sizeof(status64)); 1116 memset(&status32, 0, sizeof(status32)); 1117 /* 1118 * with extension, parameters are read/write, 1119 * get audio_tstamp_data from user, 1120 * ignore rest of status structure 1121 */ 1122 if (ext && get_user(status64.audio_tstamp_data, 1123 (u32 __user *)(&_status->audio_tstamp_data))) 1124 return -EFAULT; 1125 res = snd_pcm_status64(substream, &status64); 1126 if (res < 0) 1127 return res; 1128 1129 status32 = (struct snd_pcm_status32) { 1130 .state = status64.state, 1131 .trigger_tstamp_sec = status64.trigger_tstamp_sec, 1132 .trigger_tstamp_nsec = status64.trigger_tstamp_nsec, 1133 .tstamp_sec = status64.tstamp_sec, 1134 .tstamp_nsec = status64.tstamp_nsec, 1135 .appl_ptr = status64.appl_ptr, 1136 .hw_ptr = status64.hw_ptr, 1137 .delay = status64.delay, 1138 .avail = status64.avail, 1139 .avail_max = status64.avail_max, 1140 .overrange = status64.overrange, 1141 .suspended_state = status64.suspended_state, 1142 .audio_tstamp_data = status64.audio_tstamp_data, 1143 .audio_tstamp_sec = status64.audio_tstamp_sec, 1144 .audio_tstamp_nsec = status64.audio_tstamp_nsec, 1145 .driver_tstamp_sec = status64.audio_tstamp_sec, 1146 .driver_tstamp_nsec = status64.audio_tstamp_nsec, 1147 .audio_tstamp_accuracy = status64.audio_tstamp_accuracy, 1148 }; 1149 1150 if (copy_to_user(_status, &status32, sizeof(status32))) 1151 return -EFAULT; 1152 1153 return 0; 1154 } 1155 1156 static int snd_pcm_channel_info(struct snd_pcm_substream *substream, 1157 struct snd_pcm_channel_info * info) 1158 { 1159 struct snd_pcm_runtime *runtime; 1160 unsigned int channel; 1161 1162 channel = info->channel; 1163 runtime = substream->runtime; 1164 scoped_guard(pcm_stream_lock_irq, substream) { 1165 if (runtime->state == SNDRV_PCM_STATE_OPEN) 1166 return -EBADFD; 1167 } 1168 if (channel >= runtime->channels) 1169 return -EINVAL; 1170 memset(info, 0, sizeof(*info)); 1171 info->channel = channel; 1172 return snd_pcm_ops_ioctl(substream, SNDRV_PCM_IOCTL1_CHANNEL_INFO, info); 1173 } 1174 1175 static int snd_pcm_channel_info_user(struct snd_pcm_substream *substream, 1176 struct snd_pcm_channel_info __user * _info) 1177 { 1178 struct snd_pcm_channel_info info; 1179 int res; 1180 1181 if (copy_from_user(&info, _info, sizeof(info))) 1182 return -EFAULT; 1183 res = snd_pcm_channel_info(substream, &info); 1184 if (res < 0) 1185 return res; 1186 if (copy_to_user(_info, &info, sizeof(info))) 1187 return -EFAULT; 1188 return 0; 1189 } 1190 1191 static void snd_pcm_trigger_tstamp(struct snd_pcm_substream *substream) 1192 { 1193 struct snd_pcm_runtime *runtime = substream->runtime; 1194 if (runtime->trigger_master == NULL) 1195 return; 1196 if (runtime->trigger_master == substream) { 1197 if (!runtime->trigger_tstamp_latched) 1198 snd_pcm_gettime(runtime, &runtime->trigger_tstamp); 1199 } else { 1200 snd_pcm_trigger_tstamp(runtime->trigger_master); 1201 runtime->trigger_tstamp = runtime->trigger_master->runtime->trigger_tstamp; 1202 } 1203 runtime->trigger_master = NULL; 1204 } 1205 1206 #define ACTION_ARG_IGNORE (__force snd_pcm_state_t)0 1207 1208 struct action_ops { 1209 int (*pre_action)(struct snd_pcm_substream *substream, 1210 snd_pcm_state_t state); 1211 int (*do_action)(struct snd_pcm_substream *substream, 1212 snd_pcm_state_t state); 1213 void (*undo_action)(struct snd_pcm_substream *substream, 1214 snd_pcm_state_t state); 1215 void (*post_action)(struct snd_pcm_substream *substream, 1216 snd_pcm_state_t state); 1217 }; 1218 1219 /* 1220 * this functions is core for handling of linked stream 1221 * Note: the stream state might be changed also on failure 1222 * Note2: call with calling stream lock + link lock 1223 */ 1224 static int snd_pcm_action_group(const struct action_ops *ops, 1225 struct snd_pcm_substream *substream, 1226 snd_pcm_state_t state, 1227 bool stream_lock) 1228 { 1229 struct snd_pcm_substream *s = NULL; 1230 struct snd_pcm_substream *s1; 1231 int res = 0, depth = 1; 1232 1233 snd_pcm_group_for_each_entry(s, substream) { 1234 if (s != substream) { 1235 if (!stream_lock) 1236 mutex_lock_nested(&s->runtime->buffer_mutex, depth); 1237 else if (s->pcm->nonatomic) 1238 mutex_lock_nested(&s->self_group.mutex, depth); 1239 else 1240 spin_lock_nested(&s->self_group.lock, depth); 1241 depth++; 1242 } 1243 res = ops->pre_action(s, state); 1244 if (res < 0) 1245 goto _unlock; 1246 } 1247 snd_pcm_group_for_each_entry(s, substream) { 1248 res = ops->do_action(s, state); 1249 if (res < 0) { 1250 if (ops->undo_action) { 1251 snd_pcm_group_for_each_entry(s1, substream) { 1252 if (s1 == s) /* failed stream */ 1253 break; 1254 ops->undo_action(s1, state); 1255 } 1256 } 1257 s = NULL; /* unlock all */ 1258 goto _unlock; 1259 } 1260 } 1261 snd_pcm_group_for_each_entry(s, substream) { 1262 ops->post_action(s, state); 1263 } 1264 _unlock: 1265 /* unlock streams */ 1266 snd_pcm_group_for_each_entry(s1, substream) { 1267 if (s1 != substream) { 1268 if (!stream_lock) 1269 mutex_unlock(&s1->runtime->buffer_mutex); 1270 else if (s1->pcm->nonatomic) 1271 mutex_unlock(&s1->self_group.mutex); 1272 else 1273 spin_unlock(&s1->self_group.lock); 1274 } 1275 if (s1 == s) /* end */ 1276 break; 1277 } 1278 return res; 1279 } 1280 1281 /* 1282 * Note: call with stream lock 1283 */ 1284 static int snd_pcm_action_single(const struct action_ops *ops, 1285 struct snd_pcm_substream *substream, 1286 snd_pcm_state_t state) 1287 { 1288 int res; 1289 1290 res = ops->pre_action(substream, state); 1291 if (res < 0) 1292 return res; 1293 res = ops->do_action(substream, state); 1294 if (res == 0) 1295 ops->post_action(substream, state); 1296 else if (ops->undo_action) 1297 ops->undo_action(substream, state); 1298 return res; 1299 } 1300 1301 static void snd_pcm_group_assign(struct snd_pcm_substream *substream, 1302 struct snd_pcm_group *new_group) 1303 { 1304 substream->group = new_group; 1305 list_move(&substream->link_list, &new_group->substreams); 1306 } 1307 1308 /* 1309 * Unref and unlock the group, but keep the stream lock; 1310 * when the group becomes empty and no longer referred, destroy itself 1311 */ 1312 static void snd_pcm_group_unref(struct snd_pcm_group *group, 1313 struct snd_pcm_substream *substream) 1314 { 1315 bool do_free; 1316 1317 if (!group) 1318 return; 1319 do_free = refcount_dec_and_test(&group->refs); 1320 snd_pcm_group_unlock(group, substream->pcm->nonatomic); 1321 if (do_free) 1322 kfree(group); 1323 } 1324 1325 /* 1326 * Lock the group inside a stream lock and reference it; 1327 * return the locked group object, or NULL if not linked 1328 */ 1329 static struct snd_pcm_group * 1330 snd_pcm_stream_group_ref(struct snd_pcm_substream *substream) 1331 { 1332 bool nonatomic = substream->pcm->nonatomic; 1333 struct snd_pcm_group *group; 1334 bool trylock; 1335 1336 for (;;) { 1337 if (!snd_pcm_stream_linked(substream)) 1338 return NULL; 1339 group = substream->group; 1340 /* block freeing the group object */ 1341 refcount_inc(&group->refs); 1342 1343 trylock = nonatomic ? mutex_trylock(&group->mutex) : 1344 spin_trylock(&group->lock); 1345 if (trylock) 1346 break; /* OK */ 1347 1348 /* re-lock for avoiding ABBA deadlock */ 1349 snd_pcm_stream_unlock(substream); 1350 snd_pcm_group_lock(group, nonatomic); 1351 snd_pcm_stream_lock(substream); 1352 1353 /* check the group again; the above opens a small race window */ 1354 if (substream->group == group) 1355 break; /* OK */ 1356 /* group changed, try again */ 1357 snd_pcm_group_unref(group, substream); 1358 } 1359 return group; 1360 } 1361 1362 /* 1363 * Note: call with stream lock 1364 */ 1365 static int snd_pcm_action(const struct action_ops *ops, 1366 struct snd_pcm_substream *substream, 1367 snd_pcm_state_t state) 1368 { 1369 struct snd_pcm_group *group; 1370 int res; 1371 1372 group = snd_pcm_stream_group_ref(substream); 1373 if (group) 1374 res = snd_pcm_action_group(ops, substream, state, true); 1375 else 1376 res = snd_pcm_action_single(ops, substream, state); 1377 snd_pcm_group_unref(group, substream); 1378 return res; 1379 } 1380 1381 /* 1382 * Note: don't use any locks before 1383 */ 1384 static int snd_pcm_action_lock_irq(const struct action_ops *ops, 1385 struct snd_pcm_substream *substream, 1386 snd_pcm_state_t state) 1387 { 1388 guard(pcm_stream_lock_irq)(substream); 1389 return snd_pcm_action(ops, substream, state); 1390 } 1391 1392 /* 1393 */ 1394 static int snd_pcm_action_nonatomic(const struct action_ops *ops, 1395 struct snd_pcm_substream *substream, 1396 snd_pcm_state_t state) 1397 { 1398 int res; 1399 1400 /* Guarantee the group members won't change during non-atomic action */ 1401 guard(rwsem_read)(&snd_pcm_link_rwsem); 1402 res = snd_pcm_buffer_access_lock(substream->runtime); 1403 if (res < 0) 1404 return res; 1405 if (snd_pcm_stream_linked(substream)) 1406 res = snd_pcm_action_group(ops, substream, state, false); 1407 else 1408 res = snd_pcm_action_single(ops, substream, state); 1409 snd_pcm_buffer_access_unlock(substream->runtime); 1410 return res; 1411 } 1412 1413 /* 1414 * start callbacks 1415 */ 1416 static int snd_pcm_pre_start(struct snd_pcm_substream *substream, 1417 snd_pcm_state_t state) 1418 { 1419 struct snd_pcm_runtime *runtime = substream->runtime; 1420 if (runtime->state != SNDRV_PCM_STATE_PREPARED) 1421 return -EBADFD; 1422 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && 1423 !snd_pcm_playback_data(substream)) 1424 return -EPIPE; 1425 runtime->trigger_tstamp_latched = false; 1426 runtime->trigger_master = substream; 1427 return 0; 1428 } 1429 1430 static int snd_pcm_do_start(struct snd_pcm_substream *substream, 1431 snd_pcm_state_t state) 1432 { 1433 int err; 1434 1435 if (substream->runtime->trigger_master != substream) 1436 return 0; 1437 err = substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_START); 1438 /* XRUN happened during the start */ 1439 if (err == -EPIPE) 1440 __snd_pcm_set_state(substream->runtime, SNDRV_PCM_STATE_XRUN); 1441 return err; 1442 } 1443 1444 static void snd_pcm_undo_start(struct snd_pcm_substream *substream, 1445 snd_pcm_state_t state) 1446 { 1447 if (substream->runtime->trigger_master == substream) { 1448 substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_STOP); 1449 substream->runtime->stop_operating = true; 1450 } 1451 } 1452 1453 static void snd_pcm_post_start(struct snd_pcm_substream *substream, 1454 snd_pcm_state_t state) 1455 { 1456 struct snd_pcm_runtime *runtime = substream->runtime; 1457 snd_pcm_trigger_tstamp(substream); 1458 runtime->hw_ptr_jiffies = jiffies; 1459 runtime->hw_ptr_buffer_jiffies = (runtime->buffer_size * HZ) / 1460 runtime->rate; 1461 __snd_pcm_set_state(runtime, state); 1462 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && 1463 runtime->silence_size > 0) 1464 snd_pcm_playback_silence(substream, ULONG_MAX); 1465 snd_pcm_timer_notify(substream, SNDRV_TIMER_EVENT_MSTART); 1466 } 1467 1468 static const struct action_ops snd_pcm_action_start = { 1469 .pre_action = snd_pcm_pre_start, 1470 .do_action = snd_pcm_do_start, 1471 .undo_action = snd_pcm_undo_start, 1472 .post_action = snd_pcm_post_start 1473 }; 1474 1475 /** 1476 * snd_pcm_start - start all linked streams 1477 * @substream: the PCM substream instance 1478 * 1479 * Return: Zero if successful, or a negative error code. 1480 * The stream lock must be acquired before calling this function. 1481 */ 1482 int snd_pcm_start(struct snd_pcm_substream *substream) 1483 { 1484 return snd_pcm_action(&snd_pcm_action_start, substream, 1485 SNDRV_PCM_STATE_RUNNING); 1486 } 1487 1488 /* take the stream lock and start the streams */ 1489 static int snd_pcm_start_lock_irq(struct snd_pcm_substream *substream) 1490 { 1491 return snd_pcm_action_lock_irq(&snd_pcm_action_start, substream, 1492 SNDRV_PCM_STATE_RUNNING); 1493 } 1494 1495 /* 1496 * stop callbacks 1497 */ 1498 static int snd_pcm_pre_stop(struct snd_pcm_substream *substream, 1499 snd_pcm_state_t state) 1500 { 1501 struct snd_pcm_runtime *runtime = substream->runtime; 1502 if (runtime->state == SNDRV_PCM_STATE_OPEN) 1503 return -EBADFD; 1504 runtime->trigger_master = substream; 1505 return 0; 1506 } 1507 1508 static int snd_pcm_do_stop(struct snd_pcm_substream *substream, 1509 snd_pcm_state_t state) 1510 { 1511 if (substream->runtime->trigger_master == substream && 1512 snd_pcm_running(substream)) { 1513 substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_STOP); 1514 substream->runtime->stop_operating = true; 1515 } 1516 return 0; /* unconditionally stop all substreams */ 1517 } 1518 1519 static void snd_pcm_post_stop(struct snd_pcm_substream *substream, 1520 snd_pcm_state_t state) 1521 { 1522 struct snd_pcm_runtime *runtime = substream->runtime; 1523 if (runtime->state != state) { 1524 snd_pcm_trigger_tstamp(substream); 1525 __snd_pcm_set_state(runtime, state); 1526 snd_pcm_timer_notify(substream, SNDRV_TIMER_EVENT_MSTOP); 1527 } 1528 wake_up(&runtime->sleep); 1529 wake_up(&runtime->tsleep); 1530 } 1531 1532 static const struct action_ops snd_pcm_action_stop = { 1533 .pre_action = snd_pcm_pre_stop, 1534 .do_action = snd_pcm_do_stop, 1535 .post_action = snd_pcm_post_stop 1536 }; 1537 1538 /** 1539 * snd_pcm_stop - try to stop all running streams in the substream group 1540 * @substream: the PCM substream instance 1541 * @state: PCM state after stopping the stream 1542 * 1543 * The state of each stream is then changed to the given state unconditionally. 1544 * 1545 * Return: Zero if successful, or a negative error code. 1546 */ 1547 int snd_pcm_stop(struct snd_pcm_substream *substream, snd_pcm_state_t state) 1548 { 1549 return snd_pcm_action(&snd_pcm_action_stop, substream, state); 1550 } 1551 EXPORT_SYMBOL(snd_pcm_stop); 1552 1553 /** 1554 * snd_pcm_drain_done - stop the DMA only when the given stream is playback 1555 * @substream: the PCM substream 1556 * 1557 * After stopping, the state is changed to SETUP. 1558 * Unlike snd_pcm_stop(), this affects only the given stream. 1559 * 1560 * Return: Zero if successful, or a negative error code. 1561 */ 1562 int snd_pcm_drain_done(struct snd_pcm_substream *substream) 1563 { 1564 return snd_pcm_action_single(&snd_pcm_action_stop, substream, 1565 SNDRV_PCM_STATE_SETUP); 1566 } 1567 1568 /** 1569 * snd_pcm_stop_xrun - stop the running streams as XRUN 1570 * @substream: the PCM substream instance 1571 * 1572 * This stops the given running substream (and all linked substreams) as XRUN. 1573 * Unlike snd_pcm_stop(), this function takes the substream lock by itself. 1574 * 1575 * Return: Zero if successful, or a negative error code. 1576 */ 1577 int snd_pcm_stop_xrun(struct snd_pcm_substream *substream) 1578 { 1579 guard(pcm_stream_lock_irqsave)(substream); 1580 if (substream->runtime && snd_pcm_running(substream)) 1581 __snd_pcm_xrun(substream); 1582 return 0; 1583 } 1584 EXPORT_SYMBOL_GPL(snd_pcm_stop_xrun); 1585 1586 /* 1587 * pause callbacks: pass boolean (to start pause or resume) as state argument 1588 */ 1589 #define pause_pushed(state) (__force bool)(state) 1590 1591 static int snd_pcm_pre_pause(struct snd_pcm_substream *substream, 1592 snd_pcm_state_t state) 1593 { 1594 struct snd_pcm_runtime *runtime = substream->runtime; 1595 if (!(runtime->info & SNDRV_PCM_INFO_PAUSE)) 1596 return -ENOSYS; 1597 if (pause_pushed(state)) { 1598 if (runtime->state != SNDRV_PCM_STATE_RUNNING) 1599 return -EBADFD; 1600 } else if (runtime->state != SNDRV_PCM_STATE_PAUSED) 1601 return -EBADFD; 1602 runtime->trigger_master = substream; 1603 return 0; 1604 } 1605 1606 static int snd_pcm_do_pause(struct snd_pcm_substream *substream, 1607 snd_pcm_state_t state) 1608 { 1609 if (substream->runtime->trigger_master != substream) 1610 return 0; 1611 /* The jiffies check in snd_pcm_update_hw_ptr*() is done by 1612 * a delta between the current jiffies, this gives a large enough 1613 * delta, effectively to skip the check once. 1614 */ 1615 substream->runtime->hw_ptr_jiffies = jiffies - HZ * 1000; 1616 return substream->ops->trigger(substream, 1617 pause_pushed(state) ? 1618 SNDRV_PCM_TRIGGER_PAUSE_PUSH : 1619 SNDRV_PCM_TRIGGER_PAUSE_RELEASE); 1620 } 1621 1622 static void snd_pcm_undo_pause(struct snd_pcm_substream *substream, 1623 snd_pcm_state_t state) 1624 { 1625 if (substream->runtime->trigger_master == substream) 1626 substream->ops->trigger(substream, 1627 pause_pushed(state) ? 1628 SNDRV_PCM_TRIGGER_PAUSE_RELEASE : 1629 SNDRV_PCM_TRIGGER_PAUSE_PUSH); 1630 } 1631 1632 static void snd_pcm_post_pause(struct snd_pcm_substream *substream, 1633 snd_pcm_state_t state) 1634 { 1635 struct snd_pcm_runtime *runtime = substream->runtime; 1636 snd_pcm_trigger_tstamp(substream); 1637 if (pause_pushed(state)) { 1638 __snd_pcm_set_state(runtime, SNDRV_PCM_STATE_PAUSED); 1639 snd_pcm_timer_notify(substream, SNDRV_TIMER_EVENT_MPAUSE); 1640 wake_up(&runtime->sleep); 1641 wake_up(&runtime->tsleep); 1642 } else { 1643 __snd_pcm_set_state(runtime, SNDRV_PCM_STATE_RUNNING); 1644 snd_pcm_timer_notify(substream, SNDRV_TIMER_EVENT_MCONTINUE); 1645 } 1646 } 1647 1648 static const struct action_ops snd_pcm_action_pause = { 1649 .pre_action = snd_pcm_pre_pause, 1650 .do_action = snd_pcm_do_pause, 1651 .undo_action = snd_pcm_undo_pause, 1652 .post_action = snd_pcm_post_pause 1653 }; 1654 1655 /* 1656 * Push/release the pause for all linked streams. 1657 */ 1658 static int snd_pcm_pause(struct snd_pcm_substream *substream, bool push) 1659 { 1660 return snd_pcm_action(&snd_pcm_action_pause, substream, 1661 (__force snd_pcm_state_t)push); 1662 } 1663 1664 static int snd_pcm_pause_lock_irq(struct snd_pcm_substream *substream, 1665 bool push) 1666 { 1667 return snd_pcm_action_lock_irq(&snd_pcm_action_pause, substream, 1668 (__force snd_pcm_state_t)push); 1669 } 1670 1671 #ifdef CONFIG_PM 1672 /* suspend callback: state argument ignored */ 1673 1674 static int snd_pcm_pre_suspend(struct snd_pcm_substream *substream, 1675 snd_pcm_state_t state) 1676 { 1677 struct snd_pcm_runtime *runtime = substream->runtime; 1678 switch (runtime->state) { 1679 case SNDRV_PCM_STATE_SUSPENDED: 1680 return -EBUSY; 1681 /* unresumable PCM state; return -EBUSY for skipping suspend */ 1682 case SNDRV_PCM_STATE_OPEN: 1683 case SNDRV_PCM_STATE_SETUP: 1684 case SNDRV_PCM_STATE_DISCONNECTED: 1685 return -EBUSY; 1686 } 1687 runtime->trigger_master = substream; 1688 return 0; 1689 } 1690 1691 static int snd_pcm_do_suspend(struct snd_pcm_substream *substream, 1692 snd_pcm_state_t state) 1693 { 1694 struct snd_pcm_runtime *runtime = substream->runtime; 1695 if (runtime->trigger_master != substream) 1696 return 0; 1697 if (! snd_pcm_running(substream)) 1698 return 0; 1699 substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_SUSPEND); 1700 runtime->stop_operating = true; 1701 return 0; /* suspend unconditionally */ 1702 } 1703 1704 static void snd_pcm_post_suspend(struct snd_pcm_substream *substream, 1705 snd_pcm_state_t state) 1706 { 1707 struct snd_pcm_runtime *runtime = substream->runtime; 1708 snd_pcm_trigger_tstamp(substream); 1709 runtime->suspended_state = runtime->state; 1710 runtime->status->suspended_state = runtime->suspended_state; 1711 __snd_pcm_set_state(runtime, SNDRV_PCM_STATE_SUSPENDED); 1712 snd_pcm_timer_notify(substream, SNDRV_TIMER_EVENT_MSUSPEND); 1713 wake_up(&runtime->sleep); 1714 wake_up(&runtime->tsleep); 1715 } 1716 1717 static const struct action_ops snd_pcm_action_suspend = { 1718 .pre_action = snd_pcm_pre_suspend, 1719 .do_action = snd_pcm_do_suspend, 1720 .post_action = snd_pcm_post_suspend 1721 }; 1722 1723 /* 1724 * snd_pcm_suspend - trigger SUSPEND to all linked streams 1725 * @substream: the PCM substream 1726 * 1727 * After this call, all streams are changed to SUSPENDED state. 1728 * 1729 * Return: Zero if successful, or a negative error code. 1730 */ 1731 static int snd_pcm_suspend(struct snd_pcm_substream *substream) 1732 { 1733 guard(pcm_stream_lock_irqsave)(substream); 1734 return snd_pcm_action(&snd_pcm_action_suspend, substream, 1735 ACTION_ARG_IGNORE); 1736 } 1737 1738 /** 1739 * snd_pcm_suspend_all - trigger SUSPEND to all substreams in the given pcm 1740 * @pcm: the PCM instance 1741 * 1742 * After this call, all streams are changed to SUSPENDED state. 1743 * 1744 * Return: Zero if successful (or @pcm is %NULL), or a negative error code. 1745 */ 1746 int snd_pcm_suspend_all(struct snd_pcm *pcm) 1747 { 1748 struct snd_pcm_substream *substream; 1749 int stream, err = 0; 1750 1751 if (! pcm) 1752 return 0; 1753 1754 for_each_pcm_substream(pcm, stream, substream) { 1755 /* FIXME: the open/close code should lock this as well */ 1756 if (!substream->runtime) 1757 continue; 1758 1759 /* 1760 * Skip BE dai link PCM's that are internal and may 1761 * not have their substream ops set. 1762 */ 1763 if (!substream->ops) 1764 continue; 1765 1766 err = snd_pcm_suspend(substream); 1767 if (err < 0 && err != -EBUSY) 1768 return err; 1769 } 1770 1771 for_each_pcm_substream(pcm, stream, substream) 1772 snd_pcm_sync_stop(substream, false); 1773 1774 return 0; 1775 } 1776 EXPORT_SYMBOL(snd_pcm_suspend_all); 1777 1778 /* resume callbacks: state argument ignored */ 1779 1780 static int snd_pcm_pre_resume(struct snd_pcm_substream *substream, 1781 snd_pcm_state_t state) 1782 { 1783 struct snd_pcm_runtime *runtime = substream->runtime; 1784 if (runtime->state != SNDRV_PCM_STATE_SUSPENDED) 1785 return -EBADFD; 1786 if (!(runtime->info & SNDRV_PCM_INFO_RESUME)) 1787 return -ENOSYS; 1788 runtime->trigger_master = substream; 1789 return 0; 1790 } 1791 1792 static int snd_pcm_do_resume(struct snd_pcm_substream *substream, 1793 snd_pcm_state_t state) 1794 { 1795 struct snd_pcm_runtime *runtime = substream->runtime; 1796 if (runtime->trigger_master != substream) 1797 return 0; 1798 /* DMA not running previously? */ 1799 if (runtime->suspended_state != SNDRV_PCM_STATE_RUNNING && 1800 (runtime->suspended_state != SNDRV_PCM_STATE_DRAINING || 1801 substream->stream != SNDRV_PCM_STREAM_PLAYBACK)) 1802 return 0; 1803 return substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_RESUME); 1804 } 1805 1806 static void snd_pcm_undo_resume(struct snd_pcm_substream *substream, 1807 snd_pcm_state_t state) 1808 { 1809 if (substream->runtime->trigger_master == substream && 1810 snd_pcm_running(substream)) 1811 substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_SUSPEND); 1812 } 1813 1814 static void snd_pcm_post_resume(struct snd_pcm_substream *substream, 1815 snd_pcm_state_t state) 1816 { 1817 struct snd_pcm_runtime *runtime = substream->runtime; 1818 snd_pcm_trigger_tstamp(substream); 1819 __snd_pcm_set_state(runtime, runtime->suspended_state); 1820 snd_pcm_timer_notify(substream, SNDRV_TIMER_EVENT_MRESUME); 1821 } 1822 1823 static const struct action_ops snd_pcm_action_resume = { 1824 .pre_action = snd_pcm_pre_resume, 1825 .do_action = snd_pcm_do_resume, 1826 .undo_action = snd_pcm_undo_resume, 1827 .post_action = snd_pcm_post_resume 1828 }; 1829 1830 static int snd_pcm_resume(struct snd_pcm_substream *substream) 1831 { 1832 return snd_pcm_action_lock_irq(&snd_pcm_action_resume, substream, 1833 ACTION_ARG_IGNORE); 1834 } 1835 1836 #else 1837 1838 static int snd_pcm_resume(struct snd_pcm_substream *substream) 1839 { 1840 return -ENOSYS; 1841 } 1842 1843 #endif /* CONFIG_PM */ 1844 1845 /* 1846 * xrun ioctl 1847 * 1848 * Change the RUNNING stream(s) to XRUN state. 1849 */ 1850 static int snd_pcm_xrun(struct snd_pcm_substream *substream) 1851 { 1852 struct snd_pcm_runtime *runtime = substream->runtime; 1853 1854 guard(pcm_stream_lock_irq)(substream); 1855 switch (runtime->state) { 1856 case SNDRV_PCM_STATE_XRUN: 1857 return 0; /* already there */ 1858 case SNDRV_PCM_STATE_RUNNING: 1859 __snd_pcm_xrun(substream); 1860 return 0; 1861 default: 1862 return -EBADFD; 1863 } 1864 } 1865 1866 /* 1867 * reset ioctl 1868 */ 1869 /* reset callbacks: state argument ignored */ 1870 static int snd_pcm_pre_reset(struct snd_pcm_substream *substream, 1871 snd_pcm_state_t state) 1872 { 1873 struct snd_pcm_runtime *runtime = substream->runtime; 1874 switch (runtime->state) { 1875 case SNDRV_PCM_STATE_RUNNING: 1876 case SNDRV_PCM_STATE_PREPARED: 1877 case SNDRV_PCM_STATE_PAUSED: 1878 case SNDRV_PCM_STATE_SUSPENDED: 1879 return 0; 1880 default: 1881 return -EBADFD; 1882 } 1883 } 1884 1885 static int snd_pcm_do_reset(struct snd_pcm_substream *substream, 1886 snd_pcm_state_t state) 1887 { 1888 struct snd_pcm_runtime *runtime = substream->runtime; 1889 int err = snd_pcm_ops_ioctl(substream, SNDRV_PCM_IOCTL1_RESET, NULL); 1890 if (err < 0) 1891 return err; 1892 guard(pcm_stream_lock_irq)(substream); 1893 runtime->hw_ptr_base = 0; 1894 runtime->hw_ptr_interrupt = runtime->status->hw_ptr - 1895 runtime->status->hw_ptr % runtime->period_size; 1896 runtime->silence_start = runtime->status->hw_ptr; 1897 runtime->silence_filled = 0; 1898 return 0; 1899 } 1900 1901 static void snd_pcm_post_reset(struct snd_pcm_substream *substream, 1902 snd_pcm_state_t state) 1903 { 1904 struct snd_pcm_runtime *runtime = substream->runtime; 1905 guard(pcm_stream_lock_irq)(substream); 1906 runtime->control->appl_ptr = runtime->status->hw_ptr; 1907 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && 1908 runtime->silence_size > 0) 1909 snd_pcm_playback_silence(substream, ULONG_MAX); 1910 } 1911 1912 static const struct action_ops snd_pcm_action_reset = { 1913 .pre_action = snd_pcm_pre_reset, 1914 .do_action = snd_pcm_do_reset, 1915 .post_action = snd_pcm_post_reset 1916 }; 1917 1918 static int snd_pcm_reset(struct snd_pcm_substream *substream) 1919 { 1920 return snd_pcm_action_nonatomic(&snd_pcm_action_reset, substream, 1921 ACTION_ARG_IGNORE); 1922 } 1923 1924 /* 1925 * prepare ioctl 1926 */ 1927 /* pass f_flags as state argument */ 1928 static int snd_pcm_pre_prepare(struct snd_pcm_substream *substream, 1929 snd_pcm_state_t state) 1930 { 1931 struct snd_pcm_runtime *runtime = substream->runtime; 1932 int f_flags = (__force int)state; 1933 1934 if (runtime->state == SNDRV_PCM_STATE_OPEN || 1935 runtime->state == SNDRV_PCM_STATE_DISCONNECTED) 1936 return -EBADFD; 1937 if (snd_pcm_running(substream)) 1938 return -EBUSY; 1939 substream->f_flags = f_flags; 1940 return 0; 1941 } 1942 1943 static int snd_pcm_do_prepare(struct snd_pcm_substream *substream, 1944 snd_pcm_state_t state) 1945 { 1946 int err; 1947 snd_pcm_sync_stop(substream, true); 1948 err = substream->ops->prepare(substream); 1949 if (err < 0) 1950 return err; 1951 return snd_pcm_do_reset(substream, state); 1952 } 1953 1954 static void snd_pcm_post_prepare(struct snd_pcm_substream *substream, 1955 snd_pcm_state_t state) 1956 { 1957 struct snd_pcm_runtime *runtime = substream->runtime; 1958 runtime->control->appl_ptr = runtime->status->hw_ptr; 1959 snd_pcm_set_state(substream, SNDRV_PCM_STATE_PREPARED); 1960 } 1961 1962 static const struct action_ops snd_pcm_action_prepare = { 1963 .pre_action = snd_pcm_pre_prepare, 1964 .do_action = snd_pcm_do_prepare, 1965 .post_action = snd_pcm_post_prepare 1966 }; 1967 1968 /** 1969 * snd_pcm_prepare - prepare the PCM substream to be triggerable 1970 * @substream: the PCM substream instance 1971 * @file: file to refer f_flags 1972 * 1973 * Return: Zero if successful, or a negative error code. 1974 */ 1975 static int snd_pcm_prepare(struct snd_pcm_substream *substream, 1976 struct file *file) 1977 { 1978 int f_flags; 1979 1980 if (file) 1981 f_flags = file->f_flags; 1982 else 1983 f_flags = substream->f_flags; 1984 1985 scoped_guard(pcm_stream_lock_irq, substream) { 1986 switch (substream->runtime->state) { 1987 case SNDRV_PCM_STATE_PAUSED: 1988 snd_pcm_pause(substream, false); 1989 fallthrough; 1990 case SNDRV_PCM_STATE_SUSPENDED: 1991 snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP); 1992 break; 1993 } 1994 } 1995 1996 return snd_pcm_action_nonatomic(&snd_pcm_action_prepare, 1997 substream, 1998 (__force snd_pcm_state_t)f_flags); 1999 } 2000 2001 /* 2002 * drain ioctl 2003 */ 2004 2005 /* drain init callbacks: state argument ignored */ 2006 static int snd_pcm_pre_drain_init(struct snd_pcm_substream *substream, 2007 snd_pcm_state_t state) 2008 { 2009 struct snd_pcm_runtime *runtime = substream->runtime; 2010 switch (runtime->state) { 2011 case SNDRV_PCM_STATE_OPEN: 2012 case SNDRV_PCM_STATE_DISCONNECTED: 2013 case SNDRV_PCM_STATE_SUSPENDED: 2014 return -EBADFD; 2015 } 2016 runtime->trigger_master = substream; 2017 return 0; 2018 } 2019 2020 static int snd_pcm_do_drain_init(struct snd_pcm_substream *substream, 2021 snd_pcm_state_t state) 2022 { 2023 struct snd_pcm_runtime *runtime = substream->runtime; 2024 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 2025 switch (runtime->state) { 2026 case SNDRV_PCM_STATE_PREPARED: 2027 /* start playback stream if possible */ 2028 if (! snd_pcm_playback_empty(substream)) { 2029 snd_pcm_do_start(substream, SNDRV_PCM_STATE_DRAINING); 2030 snd_pcm_post_start(substream, SNDRV_PCM_STATE_DRAINING); 2031 } else { 2032 __snd_pcm_set_state(runtime, SNDRV_PCM_STATE_SETUP); 2033 } 2034 break; 2035 case SNDRV_PCM_STATE_RUNNING: 2036 __snd_pcm_set_state(runtime, SNDRV_PCM_STATE_DRAINING); 2037 break; 2038 case SNDRV_PCM_STATE_XRUN: 2039 __snd_pcm_set_state(runtime, SNDRV_PCM_STATE_SETUP); 2040 break; 2041 default: 2042 break; 2043 } 2044 } else { 2045 /* stop running stream */ 2046 if (runtime->state == SNDRV_PCM_STATE_RUNNING) { 2047 snd_pcm_state_t new_state; 2048 2049 new_state = snd_pcm_capture_avail(runtime) > 0 ? 2050 SNDRV_PCM_STATE_DRAINING : SNDRV_PCM_STATE_SETUP; 2051 snd_pcm_do_stop(substream, new_state); 2052 snd_pcm_post_stop(substream, new_state); 2053 } 2054 } 2055 2056 if (runtime->state == SNDRV_PCM_STATE_DRAINING && 2057 runtime->trigger_master == substream && 2058 (runtime->hw.info & SNDRV_PCM_INFO_DRAIN_TRIGGER)) 2059 return substream->ops->trigger(substream, 2060 SNDRV_PCM_TRIGGER_DRAIN); 2061 2062 return 0; 2063 } 2064 2065 static void snd_pcm_post_drain_init(struct snd_pcm_substream *substream, 2066 snd_pcm_state_t state) 2067 { 2068 } 2069 2070 static const struct action_ops snd_pcm_action_drain_init = { 2071 .pre_action = snd_pcm_pre_drain_init, 2072 .do_action = snd_pcm_do_drain_init, 2073 .post_action = snd_pcm_post_drain_init 2074 }; 2075 2076 /* 2077 * Drain the stream(s). 2078 * When the substream is linked, sync until the draining of all playback streams 2079 * is finished. 2080 * After this call, all streams are supposed to be either SETUP or DRAINING 2081 * (capture only) state. 2082 */ 2083 static int snd_pcm_drain(struct snd_pcm_substream *substream, 2084 struct file *file) 2085 { 2086 struct snd_card *card; 2087 struct snd_pcm_runtime *runtime; 2088 struct snd_pcm_substream *s; 2089 struct snd_pcm_group *group; 2090 wait_queue_entry_t wait; 2091 int result = 0; 2092 int nonblock = 0; 2093 2094 card = substream->pcm->card; 2095 runtime = substream->runtime; 2096 2097 if (runtime->state == SNDRV_PCM_STATE_OPEN) 2098 return -EBADFD; 2099 2100 if (file) { 2101 if (file->f_flags & O_NONBLOCK) 2102 nonblock = 1; 2103 } else if (substream->f_flags & O_NONBLOCK) 2104 nonblock = 1; 2105 2106 snd_pcm_stream_lock_irq(substream); 2107 /* resume pause */ 2108 if (runtime->state == SNDRV_PCM_STATE_PAUSED) 2109 snd_pcm_pause(substream, false); 2110 2111 /* pre-start/stop - all running streams are changed to DRAINING state */ 2112 result = snd_pcm_action(&snd_pcm_action_drain_init, substream, 2113 ACTION_ARG_IGNORE); 2114 if (result < 0) 2115 goto unlock; 2116 /* in non-blocking, we don't wait in ioctl but let caller poll */ 2117 if (nonblock) { 2118 result = -EAGAIN; 2119 goto unlock; 2120 } 2121 2122 for (;;) { 2123 long tout; 2124 struct snd_pcm_runtime *to_check; 2125 if (signal_pending(current)) { 2126 result = -ERESTARTSYS; 2127 break; 2128 } 2129 /* find a substream to drain */ 2130 to_check = NULL; 2131 group = snd_pcm_stream_group_ref(substream); 2132 snd_pcm_group_for_each_entry(s, substream) { 2133 if (s->stream != SNDRV_PCM_STREAM_PLAYBACK) 2134 continue; 2135 runtime = s->runtime; 2136 if (runtime->state == SNDRV_PCM_STATE_DRAINING) { 2137 to_check = runtime; 2138 break; 2139 } 2140 } 2141 snd_pcm_group_unref(group, substream); 2142 if (!to_check) 2143 break; /* all drained */ 2144 init_waitqueue_entry(&wait, current); 2145 set_current_state(TASK_INTERRUPTIBLE); 2146 add_wait_queue(&to_check->sleep, &wait); 2147 snd_pcm_stream_unlock_irq(substream); 2148 if (runtime->no_period_wakeup) 2149 tout = MAX_SCHEDULE_TIMEOUT; 2150 else { 2151 tout = 100; 2152 if (runtime->rate) { 2153 long t = runtime->buffer_size * 1100 / runtime->rate; 2154 tout = max(t, tout); 2155 } 2156 tout = msecs_to_jiffies(tout); 2157 } 2158 tout = schedule_timeout(tout); 2159 2160 snd_pcm_stream_lock_irq(substream); 2161 group = snd_pcm_stream_group_ref(substream); 2162 snd_pcm_group_for_each_entry(s, substream) { 2163 if (s->runtime == to_check) { 2164 remove_wait_queue(&to_check->sleep, &wait); 2165 break; 2166 } 2167 } 2168 snd_pcm_group_unref(group, substream); 2169 2170 if (card->shutdown) { 2171 result = -ENODEV; 2172 break; 2173 } 2174 if (tout == 0) { 2175 if (substream->runtime->state == SNDRV_PCM_STATE_SUSPENDED) 2176 result = -ESTRPIPE; 2177 else { 2178 dev_dbg(substream->pcm->card->dev, 2179 "playback drain timeout (DMA or IRQ trouble?)\n"); 2180 snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP); 2181 result = -EIO; 2182 } 2183 break; 2184 } 2185 } 2186 2187 unlock: 2188 snd_pcm_stream_unlock_irq(substream); 2189 2190 return result; 2191 } 2192 2193 /* 2194 * drop ioctl 2195 * 2196 * Immediately put all linked substreams into SETUP state. 2197 */ 2198 static int snd_pcm_drop(struct snd_pcm_substream *substream) 2199 { 2200 struct snd_pcm_runtime *runtime; 2201 int result = 0; 2202 2203 if (PCM_RUNTIME_CHECK(substream)) 2204 return -ENXIO; 2205 runtime = substream->runtime; 2206 2207 if (runtime->state == SNDRV_PCM_STATE_OPEN || 2208 runtime->state == SNDRV_PCM_STATE_DISCONNECTED) 2209 return -EBADFD; 2210 2211 guard(pcm_stream_lock_irq)(substream); 2212 /* resume pause */ 2213 if (runtime->state == SNDRV_PCM_STATE_PAUSED) 2214 snd_pcm_pause(substream, false); 2215 2216 snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP); 2217 /* runtime->control->appl_ptr = runtime->status->hw_ptr; */ 2218 2219 return result; 2220 } 2221 2222 2223 static bool is_pcm_file(struct file *file) 2224 { 2225 struct inode *inode = file_inode(file); 2226 struct snd_pcm *pcm; 2227 unsigned int minor; 2228 2229 if (!S_ISCHR(inode->i_mode) || imajor(inode) != snd_major) 2230 return false; 2231 minor = iminor(inode); 2232 pcm = snd_lookup_minor_data(minor, SNDRV_DEVICE_TYPE_PCM_PLAYBACK); 2233 if (!pcm) 2234 pcm = snd_lookup_minor_data(minor, SNDRV_DEVICE_TYPE_PCM_CAPTURE); 2235 if (!pcm) 2236 return false; 2237 snd_card_unref(pcm->card); 2238 return true; 2239 } 2240 2241 /* 2242 * PCM link handling 2243 */ 2244 static int snd_pcm_link(struct snd_pcm_substream *substream, int fd) 2245 { 2246 struct snd_pcm_file *pcm_file; 2247 struct snd_pcm_substream *substream1; 2248 struct snd_pcm_group *group __free(kfree) = NULL; 2249 struct snd_pcm_group *target_group; 2250 bool nonatomic = substream->pcm->nonatomic; 2251 CLASS(fd, f)(fd); 2252 2253 if (!f.file) 2254 return -EBADFD; 2255 if (!is_pcm_file(f.file)) 2256 return -EBADFD; 2257 2258 pcm_file = f.file->private_data; 2259 substream1 = pcm_file->substream; 2260 2261 if (substream == substream1) 2262 return -EINVAL; 2263 2264 group = kzalloc(sizeof(*group), GFP_KERNEL); 2265 if (!group) 2266 return -ENOMEM; 2267 snd_pcm_group_init(group); 2268 2269 guard(rwsem_write)(&snd_pcm_link_rwsem); 2270 if (substream->runtime->state == SNDRV_PCM_STATE_OPEN || 2271 substream->runtime->state != substream1->runtime->state || 2272 substream->pcm->nonatomic != substream1->pcm->nonatomic) 2273 return -EBADFD; 2274 if (snd_pcm_stream_linked(substream1)) 2275 return -EALREADY; 2276 2277 scoped_guard(pcm_stream_lock_irq, substream) { 2278 if (!snd_pcm_stream_linked(substream)) { 2279 snd_pcm_group_assign(substream, group); 2280 group = NULL; /* assigned, don't free this one below */ 2281 } 2282 target_group = substream->group; 2283 } 2284 2285 snd_pcm_group_lock_irq(target_group, nonatomic); 2286 snd_pcm_stream_lock_nested(substream1); 2287 snd_pcm_group_assign(substream1, target_group); 2288 refcount_inc(&target_group->refs); 2289 snd_pcm_stream_unlock(substream1); 2290 snd_pcm_group_unlock_irq(target_group, nonatomic); 2291 return 0; 2292 } 2293 2294 static void relink_to_local(struct snd_pcm_substream *substream) 2295 { 2296 snd_pcm_stream_lock_nested(substream); 2297 snd_pcm_group_assign(substream, &substream->self_group); 2298 snd_pcm_stream_unlock(substream); 2299 } 2300 2301 static int snd_pcm_unlink(struct snd_pcm_substream *substream) 2302 { 2303 struct snd_pcm_group *group; 2304 bool nonatomic = substream->pcm->nonatomic; 2305 bool do_free = false; 2306 2307 guard(rwsem_write)(&snd_pcm_link_rwsem); 2308 2309 if (!snd_pcm_stream_linked(substream)) 2310 return -EALREADY; 2311 2312 group = substream->group; 2313 snd_pcm_group_lock_irq(group, nonatomic); 2314 2315 relink_to_local(substream); 2316 refcount_dec(&group->refs); 2317 2318 /* detach the last stream, too */ 2319 if (list_is_singular(&group->substreams)) { 2320 relink_to_local(list_first_entry(&group->substreams, 2321 struct snd_pcm_substream, 2322 link_list)); 2323 do_free = refcount_dec_and_test(&group->refs); 2324 } 2325 2326 snd_pcm_group_unlock_irq(group, nonatomic); 2327 if (do_free) 2328 kfree(group); 2329 return 0; 2330 } 2331 2332 /* 2333 * hw configurator 2334 */ 2335 static int snd_pcm_hw_rule_mul(struct snd_pcm_hw_params *params, 2336 struct snd_pcm_hw_rule *rule) 2337 { 2338 struct snd_interval t; 2339 snd_interval_mul(hw_param_interval_c(params, rule->deps[0]), 2340 hw_param_interval_c(params, rule->deps[1]), &t); 2341 return snd_interval_refine(hw_param_interval(params, rule->var), &t); 2342 } 2343 2344 static int snd_pcm_hw_rule_div(struct snd_pcm_hw_params *params, 2345 struct snd_pcm_hw_rule *rule) 2346 { 2347 struct snd_interval t; 2348 snd_interval_div(hw_param_interval_c(params, rule->deps[0]), 2349 hw_param_interval_c(params, rule->deps[1]), &t); 2350 return snd_interval_refine(hw_param_interval(params, rule->var), &t); 2351 } 2352 2353 static int snd_pcm_hw_rule_muldivk(struct snd_pcm_hw_params *params, 2354 struct snd_pcm_hw_rule *rule) 2355 { 2356 struct snd_interval t; 2357 snd_interval_muldivk(hw_param_interval_c(params, rule->deps[0]), 2358 hw_param_interval_c(params, rule->deps[1]), 2359 (unsigned long) rule->private, &t); 2360 return snd_interval_refine(hw_param_interval(params, rule->var), &t); 2361 } 2362 2363 static int snd_pcm_hw_rule_mulkdiv(struct snd_pcm_hw_params *params, 2364 struct snd_pcm_hw_rule *rule) 2365 { 2366 struct snd_interval t; 2367 snd_interval_mulkdiv(hw_param_interval_c(params, rule->deps[0]), 2368 (unsigned long) rule->private, 2369 hw_param_interval_c(params, rule->deps[1]), &t); 2370 return snd_interval_refine(hw_param_interval(params, rule->var), &t); 2371 } 2372 2373 static int snd_pcm_hw_rule_format(struct snd_pcm_hw_params *params, 2374 struct snd_pcm_hw_rule *rule) 2375 { 2376 snd_pcm_format_t k; 2377 const struct snd_interval *i = 2378 hw_param_interval_c(params, rule->deps[0]); 2379 struct snd_mask m; 2380 struct snd_mask *mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); 2381 snd_mask_any(&m); 2382 pcm_for_each_format(k) { 2383 int bits; 2384 if (!snd_mask_test_format(mask, k)) 2385 continue; 2386 bits = snd_pcm_format_physical_width(k); 2387 if (bits <= 0) 2388 continue; /* ignore invalid formats */ 2389 if ((unsigned)bits < i->min || (unsigned)bits > i->max) 2390 snd_mask_reset(&m, (__force unsigned)k); 2391 } 2392 return snd_mask_refine(mask, &m); 2393 } 2394 2395 static int snd_pcm_hw_rule_sample_bits(struct snd_pcm_hw_params *params, 2396 struct snd_pcm_hw_rule *rule) 2397 { 2398 struct snd_interval t; 2399 snd_pcm_format_t k; 2400 2401 t.min = UINT_MAX; 2402 t.max = 0; 2403 t.openmin = 0; 2404 t.openmax = 0; 2405 pcm_for_each_format(k) { 2406 int bits; 2407 if (!snd_mask_test_format(hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT), k)) 2408 continue; 2409 bits = snd_pcm_format_physical_width(k); 2410 if (bits <= 0) 2411 continue; /* ignore invalid formats */ 2412 if (t.min > (unsigned)bits) 2413 t.min = bits; 2414 if (t.max < (unsigned)bits) 2415 t.max = bits; 2416 } 2417 t.integer = 1; 2418 return snd_interval_refine(hw_param_interval(params, rule->var), &t); 2419 } 2420 2421 #if SNDRV_PCM_RATE_5512 != 1 << 0 || SNDRV_PCM_RATE_192000 != 1 << 12 2422 #error "Change this table" 2423 #endif 2424 2425 static const unsigned int rates[] = { 2426 5512, 8000, 11025, 16000, 22050, 32000, 44100, 2427 48000, 64000, 88200, 96000, 176400, 192000, 352800, 384000, 705600, 768000 2428 }; 2429 2430 const struct snd_pcm_hw_constraint_list snd_pcm_known_rates = { 2431 .count = ARRAY_SIZE(rates), 2432 .list = rates, 2433 }; 2434 2435 static int snd_pcm_hw_rule_rate(struct snd_pcm_hw_params *params, 2436 struct snd_pcm_hw_rule *rule) 2437 { 2438 struct snd_pcm_hardware *hw = rule->private; 2439 return snd_interval_list(hw_param_interval(params, rule->var), 2440 snd_pcm_known_rates.count, 2441 snd_pcm_known_rates.list, hw->rates); 2442 } 2443 2444 static int snd_pcm_hw_rule_buffer_bytes_max(struct snd_pcm_hw_params *params, 2445 struct snd_pcm_hw_rule *rule) 2446 { 2447 struct snd_interval t; 2448 struct snd_pcm_substream *substream = rule->private; 2449 t.min = 0; 2450 t.max = substream->buffer_bytes_max; 2451 t.openmin = 0; 2452 t.openmax = 0; 2453 t.integer = 1; 2454 return snd_interval_refine(hw_param_interval(params, rule->var), &t); 2455 } 2456 2457 static int snd_pcm_hw_rule_subformats(struct snd_pcm_hw_params *params, 2458 struct snd_pcm_hw_rule *rule) 2459 { 2460 struct snd_mask *sfmask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_SUBFORMAT); 2461 struct snd_mask *fmask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); 2462 u32 *subformats = rule->private; 2463 snd_pcm_format_t f; 2464 struct snd_mask m; 2465 2466 snd_mask_none(&m); 2467 /* All PCMs support at least the default STD subformat. */ 2468 snd_mask_set(&m, (__force unsigned)SNDRV_PCM_SUBFORMAT_STD); 2469 2470 pcm_for_each_format(f) { 2471 if (!snd_mask_test(fmask, (__force unsigned)f)) 2472 continue; 2473 2474 if (f == SNDRV_PCM_FORMAT_S32_LE && *subformats) 2475 m.bits[0] |= *subformats; 2476 else if (snd_pcm_format_linear(f)) 2477 snd_mask_set(&m, (__force unsigned)SNDRV_PCM_SUBFORMAT_MSBITS_MAX); 2478 } 2479 2480 return snd_mask_refine(sfmask, &m); 2481 } 2482 2483 static int snd_pcm_hw_constraint_subformats(struct snd_pcm_runtime *runtime, 2484 unsigned int cond, u32 *subformats) 2485 { 2486 return snd_pcm_hw_rule_add(runtime, cond, -1, 2487 snd_pcm_hw_rule_subformats, (void *)subformats, 2488 SNDRV_PCM_HW_PARAM_SUBFORMAT, 2489 SNDRV_PCM_HW_PARAM_FORMAT, -1); 2490 } 2491 2492 static int snd_pcm_hw_constraints_init(struct snd_pcm_substream *substream) 2493 { 2494 struct snd_pcm_runtime *runtime = substream->runtime; 2495 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; 2496 int k, err; 2497 2498 for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++) { 2499 snd_mask_any(constrs_mask(constrs, k)); 2500 } 2501 2502 for (k = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++) { 2503 snd_interval_any(constrs_interval(constrs, k)); 2504 } 2505 2506 snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_CHANNELS)); 2507 snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_BUFFER_SIZE)); 2508 snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_BUFFER_BYTES)); 2509 snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_SAMPLE_BITS)); 2510 snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_FRAME_BITS)); 2511 2512 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT, 2513 snd_pcm_hw_rule_format, NULL, 2514 SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1); 2515 if (err < 0) 2516 return err; 2517 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, 2518 snd_pcm_hw_rule_sample_bits, NULL, 2519 SNDRV_PCM_HW_PARAM_FORMAT, 2520 SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1); 2521 if (err < 0) 2522 return err; 2523 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, 2524 snd_pcm_hw_rule_div, NULL, 2525 SNDRV_PCM_HW_PARAM_FRAME_BITS, SNDRV_PCM_HW_PARAM_CHANNELS, -1); 2526 if (err < 0) 2527 return err; 2528 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS, 2529 snd_pcm_hw_rule_mul, NULL, 2530 SNDRV_PCM_HW_PARAM_SAMPLE_BITS, SNDRV_PCM_HW_PARAM_CHANNELS, -1); 2531 if (err < 0) 2532 return err; 2533 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS, 2534 snd_pcm_hw_rule_mulkdiv, (void*) 8, 2535 SNDRV_PCM_HW_PARAM_PERIOD_BYTES, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1); 2536 if (err < 0) 2537 return err; 2538 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS, 2539 snd_pcm_hw_rule_mulkdiv, (void*) 8, 2540 SNDRV_PCM_HW_PARAM_BUFFER_BYTES, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, -1); 2541 if (err < 0) 2542 return err; 2543 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, 2544 snd_pcm_hw_rule_div, NULL, 2545 SNDRV_PCM_HW_PARAM_FRAME_BITS, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1); 2546 if (err < 0) 2547 return err; 2548 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 2549 snd_pcm_hw_rule_mulkdiv, (void*) 1000000, 2550 SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_PERIOD_TIME, -1); 2551 if (err < 0) 2552 return err; 2553 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 2554 snd_pcm_hw_rule_mulkdiv, (void*) 1000000, 2555 SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_BUFFER_TIME, -1); 2556 if (err < 0) 2557 return err; 2558 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIODS, 2559 snd_pcm_hw_rule_div, NULL, 2560 SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1); 2561 if (err < 0) 2562 return err; 2563 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 2564 snd_pcm_hw_rule_div, NULL, 2565 SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_PERIODS, -1); 2566 if (err < 0) 2567 return err; 2568 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 2569 snd_pcm_hw_rule_mulkdiv, (void*) 8, 2570 SNDRV_PCM_HW_PARAM_PERIOD_BYTES, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1); 2571 if (err < 0) 2572 return err; 2573 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 2574 snd_pcm_hw_rule_muldivk, (void*) 1000000, 2575 SNDRV_PCM_HW_PARAM_PERIOD_TIME, SNDRV_PCM_HW_PARAM_RATE, -1); 2576 if (err < 0) 2577 return err; 2578 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 2579 snd_pcm_hw_rule_mul, NULL, 2580 SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_PERIODS, -1); 2581 if (err < 0) 2582 return err; 2583 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 2584 snd_pcm_hw_rule_mulkdiv, (void*) 8, 2585 SNDRV_PCM_HW_PARAM_BUFFER_BYTES, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1); 2586 if (err < 0) 2587 return err; 2588 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 2589 snd_pcm_hw_rule_muldivk, (void*) 1000000, 2590 SNDRV_PCM_HW_PARAM_BUFFER_TIME, SNDRV_PCM_HW_PARAM_RATE, -1); 2591 if (err < 0) 2592 return err; 2593 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 2594 snd_pcm_hw_rule_muldivk, (void*) 8, 2595 SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1); 2596 if (err < 0) 2597 return err; 2598 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 2599 snd_pcm_hw_rule_muldivk, (void*) 8, 2600 SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1); 2601 if (err < 0) 2602 return err; 2603 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_TIME, 2604 snd_pcm_hw_rule_mulkdiv, (void*) 1000000, 2605 SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_RATE, -1); 2606 if (err < 0) 2607 return err; 2608 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_TIME, 2609 snd_pcm_hw_rule_mulkdiv, (void*) 1000000, 2610 SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_RATE, -1); 2611 if (err < 0) 2612 return err; 2613 return 0; 2614 } 2615 2616 static int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream) 2617 { 2618 struct snd_pcm_runtime *runtime = substream->runtime; 2619 struct snd_pcm_hardware *hw = &runtime->hw; 2620 int err; 2621 unsigned int mask = 0; 2622 2623 if (hw->info & SNDRV_PCM_INFO_INTERLEAVED) 2624 mask |= PARAM_MASK_BIT(SNDRV_PCM_ACCESS_RW_INTERLEAVED); 2625 if (hw->info & SNDRV_PCM_INFO_NONINTERLEAVED) 2626 mask |= PARAM_MASK_BIT(SNDRV_PCM_ACCESS_RW_NONINTERLEAVED); 2627 if (hw_support_mmap(substream)) { 2628 if (hw->info & SNDRV_PCM_INFO_INTERLEAVED) 2629 mask |= PARAM_MASK_BIT(SNDRV_PCM_ACCESS_MMAP_INTERLEAVED); 2630 if (hw->info & SNDRV_PCM_INFO_NONINTERLEAVED) 2631 mask |= PARAM_MASK_BIT(SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED); 2632 if (hw->info & SNDRV_PCM_INFO_COMPLEX) 2633 mask |= PARAM_MASK_BIT(SNDRV_PCM_ACCESS_MMAP_COMPLEX); 2634 } 2635 err = snd_pcm_hw_constraint_mask(runtime, SNDRV_PCM_HW_PARAM_ACCESS, mask); 2636 if (err < 0) 2637 return err; 2638 2639 err = snd_pcm_hw_constraint_mask64(runtime, SNDRV_PCM_HW_PARAM_FORMAT, hw->formats); 2640 if (err < 0) 2641 return err; 2642 2643 err = snd_pcm_hw_constraint_subformats(runtime, 0, &hw->subformats); 2644 if (err < 0) 2645 return err; 2646 2647 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_CHANNELS, 2648 hw->channels_min, hw->channels_max); 2649 if (err < 0) 2650 return err; 2651 2652 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_RATE, 2653 hw->rate_min, hw->rate_max); 2654 if (err < 0) 2655 return err; 2656 2657 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 2658 hw->period_bytes_min, hw->period_bytes_max); 2659 if (err < 0) 2660 return err; 2661 2662 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIODS, 2663 hw->periods_min, hw->periods_max); 2664 if (err < 0) 2665 return err; 2666 2667 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 2668 hw->period_bytes_min, hw->buffer_bytes_max); 2669 if (err < 0) 2670 return err; 2671 2672 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 2673 snd_pcm_hw_rule_buffer_bytes_max, substream, 2674 SNDRV_PCM_HW_PARAM_BUFFER_BYTES, -1); 2675 if (err < 0) 2676 return err; 2677 2678 /* FIXME: remove */ 2679 if (runtime->dma_bytes) { 2680 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, runtime->dma_bytes); 2681 if (err < 0) 2682 return err; 2683 } 2684 2685 if (!(hw->rates & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))) { 2686 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 2687 snd_pcm_hw_rule_rate, hw, 2688 SNDRV_PCM_HW_PARAM_RATE, -1); 2689 if (err < 0) 2690 return err; 2691 } 2692 2693 /* FIXME: this belong to lowlevel */ 2694 snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE); 2695 2696 return 0; 2697 } 2698 2699 static void pcm_release_private(struct snd_pcm_substream *substream) 2700 { 2701 if (snd_pcm_stream_linked(substream)) 2702 snd_pcm_unlink(substream); 2703 } 2704 2705 void snd_pcm_release_substream(struct snd_pcm_substream *substream) 2706 { 2707 substream->ref_count--; 2708 if (substream->ref_count > 0) 2709 return; 2710 2711 snd_pcm_drop(substream); 2712 if (substream->hw_opened) { 2713 if (substream->runtime->state != SNDRV_PCM_STATE_OPEN) 2714 do_hw_free(substream); 2715 substream->ops->close(substream); 2716 substream->hw_opened = 0; 2717 } 2718 if (cpu_latency_qos_request_active(&substream->latency_pm_qos_req)) 2719 cpu_latency_qos_remove_request(&substream->latency_pm_qos_req); 2720 if (substream->pcm_release) { 2721 substream->pcm_release(substream); 2722 substream->pcm_release = NULL; 2723 } 2724 snd_pcm_detach_substream(substream); 2725 } 2726 EXPORT_SYMBOL(snd_pcm_release_substream); 2727 2728 int snd_pcm_open_substream(struct snd_pcm *pcm, int stream, 2729 struct file *file, 2730 struct snd_pcm_substream **rsubstream) 2731 { 2732 struct snd_pcm_substream *substream; 2733 int err; 2734 2735 err = snd_pcm_attach_substream(pcm, stream, file, &substream); 2736 if (err < 0) 2737 return err; 2738 if (substream->ref_count > 1) { 2739 *rsubstream = substream; 2740 return 0; 2741 } 2742 2743 err = snd_pcm_hw_constraints_init(substream); 2744 if (err < 0) { 2745 pcm_dbg(pcm, "snd_pcm_hw_constraints_init failed\n"); 2746 goto error; 2747 } 2748 2749 err = substream->ops->open(substream); 2750 if (err < 0) 2751 goto error; 2752 2753 substream->hw_opened = 1; 2754 2755 err = snd_pcm_hw_constraints_complete(substream); 2756 if (err < 0) { 2757 pcm_dbg(pcm, "snd_pcm_hw_constraints_complete failed\n"); 2758 goto error; 2759 } 2760 2761 /* automatically set EXPLICIT_SYNC flag in the managed mode whenever 2762 * the DMA buffer requires it 2763 */ 2764 if (substream->managed_buffer_alloc && 2765 substream->dma_buffer.dev.need_sync) 2766 substream->runtime->hw.info |= SNDRV_PCM_INFO_EXPLICIT_SYNC; 2767 2768 *rsubstream = substream; 2769 return 0; 2770 2771 error: 2772 snd_pcm_release_substream(substream); 2773 return err; 2774 } 2775 EXPORT_SYMBOL(snd_pcm_open_substream); 2776 2777 static int snd_pcm_open_file(struct file *file, 2778 struct snd_pcm *pcm, 2779 int stream) 2780 { 2781 struct snd_pcm_file *pcm_file; 2782 struct snd_pcm_substream *substream; 2783 int err; 2784 2785 err = snd_pcm_open_substream(pcm, stream, file, &substream); 2786 if (err < 0) 2787 return err; 2788 2789 pcm_file = kzalloc(sizeof(*pcm_file), GFP_KERNEL); 2790 if (pcm_file == NULL) { 2791 snd_pcm_release_substream(substream); 2792 return -ENOMEM; 2793 } 2794 pcm_file->substream = substream; 2795 if (substream->ref_count == 1) 2796 substream->pcm_release = pcm_release_private; 2797 file->private_data = pcm_file; 2798 2799 return 0; 2800 } 2801 2802 static int snd_pcm_playback_open(struct inode *inode, struct file *file) 2803 { 2804 struct snd_pcm *pcm; 2805 int err = nonseekable_open(inode, file); 2806 if (err < 0) 2807 return err; 2808 pcm = snd_lookup_minor_data(iminor(inode), 2809 SNDRV_DEVICE_TYPE_PCM_PLAYBACK); 2810 err = snd_pcm_open(file, pcm, SNDRV_PCM_STREAM_PLAYBACK); 2811 if (pcm) 2812 snd_card_unref(pcm->card); 2813 return err; 2814 } 2815 2816 static int snd_pcm_capture_open(struct inode *inode, struct file *file) 2817 { 2818 struct snd_pcm *pcm; 2819 int err = nonseekable_open(inode, file); 2820 if (err < 0) 2821 return err; 2822 pcm = snd_lookup_minor_data(iminor(inode), 2823 SNDRV_DEVICE_TYPE_PCM_CAPTURE); 2824 err = snd_pcm_open(file, pcm, SNDRV_PCM_STREAM_CAPTURE); 2825 if (pcm) 2826 snd_card_unref(pcm->card); 2827 return err; 2828 } 2829 2830 static int snd_pcm_open(struct file *file, struct snd_pcm *pcm, int stream) 2831 { 2832 int err; 2833 wait_queue_entry_t wait; 2834 2835 if (pcm == NULL) { 2836 err = -ENODEV; 2837 goto __error1; 2838 } 2839 err = snd_card_file_add(pcm->card, file); 2840 if (err < 0) 2841 goto __error1; 2842 if (!try_module_get(pcm->card->module)) { 2843 err = -EFAULT; 2844 goto __error2; 2845 } 2846 init_waitqueue_entry(&wait, current); 2847 add_wait_queue(&pcm->open_wait, &wait); 2848 mutex_lock(&pcm->open_mutex); 2849 while (1) { 2850 err = snd_pcm_open_file(file, pcm, stream); 2851 if (err >= 0) 2852 break; 2853 if (err == -EAGAIN) { 2854 if (file->f_flags & O_NONBLOCK) { 2855 err = -EBUSY; 2856 break; 2857 } 2858 } else 2859 break; 2860 set_current_state(TASK_INTERRUPTIBLE); 2861 mutex_unlock(&pcm->open_mutex); 2862 schedule(); 2863 mutex_lock(&pcm->open_mutex); 2864 if (pcm->card->shutdown) { 2865 err = -ENODEV; 2866 break; 2867 } 2868 if (signal_pending(current)) { 2869 err = -ERESTARTSYS; 2870 break; 2871 } 2872 } 2873 remove_wait_queue(&pcm->open_wait, &wait); 2874 mutex_unlock(&pcm->open_mutex); 2875 if (err < 0) 2876 goto __error; 2877 return err; 2878 2879 __error: 2880 module_put(pcm->card->module); 2881 __error2: 2882 snd_card_file_remove(pcm->card, file); 2883 __error1: 2884 return err; 2885 } 2886 2887 static int snd_pcm_release(struct inode *inode, struct file *file) 2888 { 2889 struct snd_pcm *pcm; 2890 struct snd_pcm_substream *substream; 2891 struct snd_pcm_file *pcm_file; 2892 2893 pcm_file = file->private_data; 2894 substream = pcm_file->substream; 2895 if (snd_BUG_ON(!substream)) 2896 return -ENXIO; 2897 pcm = substream->pcm; 2898 2899 /* block until the device gets woken up as it may touch the hardware */ 2900 snd_power_wait(pcm->card); 2901 2902 scoped_guard(mutex, &pcm->open_mutex) { 2903 snd_pcm_release_substream(substream); 2904 kfree(pcm_file); 2905 } 2906 wake_up(&pcm->open_wait); 2907 module_put(pcm->card->module); 2908 snd_card_file_remove(pcm->card, file); 2909 return 0; 2910 } 2911 2912 /* check and update PCM state; return 0 or a negative error 2913 * call this inside PCM lock 2914 */ 2915 static int do_pcm_hwsync(struct snd_pcm_substream *substream) 2916 { 2917 switch (substream->runtime->state) { 2918 case SNDRV_PCM_STATE_DRAINING: 2919 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) 2920 return -EBADFD; 2921 fallthrough; 2922 case SNDRV_PCM_STATE_RUNNING: 2923 return snd_pcm_update_hw_ptr(substream); 2924 case SNDRV_PCM_STATE_PREPARED: 2925 case SNDRV_PCM_STATE_PAUSED: 2926 return 0; 2927 case SNDRV_PCM_STATE_SUSPENDED: 2928 return -ESTRPIPE; 2929 case SNDRV_PCM_STATE_XRUN: 2930 return -EPIPE; 2931 default: 2932 return -EBADFD; 2933 } 2934 } 2935 2936 /* increase the appl_ptr; returns the processed frames or a negative error */ 2937 static snd_pcm_sframes_t forward_appl_ptr(struct snd_pcm_substream *substream, 2938 snd_pcm_uframes_t frames, 2939 snd_pcm_sframes_t avail) 2940 { 2941 struct snd_pcm_runtime *runtime = substream->runtime; 2942 snd_pcm_sframes_t appl_ptr; 2943 int ret; 2944 2945 if (avail <= 0) 2946 return 0; 2947 if (frames > (snd_pcm_uframes_t)avail) 2948 frames = avail; 2949 appl_ptr = runtime->control->appl_ptr + frames; 2950 if (appl_ptr >= (snd_pcm_sframes_t)runtime->boundary) 2951 appl_ptr -= runtime->boundary; 2952 ret = pcm_lib_apply_appl_ptr(substream, appl_ptr); 2953 return ret < 0 ? ret : frames; 2954 } 2955 2956 /* decrease the appl_ptr; returns the processed frames or zero for error */ 2957 static snd_pcm_sframes_t rewind_appl_ptr(struct snd_pcm_substream *substream, 2958 snd_pcm_uframes_t frames, 2959 snd_pcm_sframes_t avail) 2960 { 2961 struct snd_pcm_runtime *runtime = substream->runtime; 2962 snd_pcm_sframes_t appl_ptr; 2963 int ret; 2964 2965 if (avail <= 0) 2966 return 0; 2967 if (frames > (snd_pcm_uframes_t)avail) 2968 frames = avail; 2969 appl_ptr = runtime->control->appl_ptr - frames; 2970 if (appl_ptr < 0) 2971 appl_ptr += runtime->boundary; 2972 ret = pcm_lib_apply_appl_ptr(substream, appl_ptr); 2973 /* NOTE: we return zero for errors because PulseAudio gets depressed 2974 * upon receiving an error from rewind ioctl and stops processing 2975 * any longer. Returning zero means that no rewind is done, so 2976 * it's not absolutely wrong to answer like that. 2977 */ 2978 return ret < 0 ? 0 : frames; 2979 } 2980 2981 static snd_pcm_sframes_t snd_pcm_rewind(struct snd_pcm_substream *substream, 2982 snd_pcm_uframes_t frames) 2983 { 2984 snd_pcm_sframes_t ret; 2985 2986 if (frames == 0) 2987 return 0; 2988 2989 scoped_guard(pcm_stream_lock_irq, substream) { 2990 ret = do_pcm_hwsync(substream); 2991 if (!ret) 2992 ret = rewind_appl_ptr(substream, frames, 2993 snd_pcm_hw_avail(substream)); 2994 } 2995 if (ret >= 0) 2996 snd_pcm_dma_buffer_sync(substream, SNDRV_DMA_SYNC_DEVICE); 2997 return ret; 2998 } 2999 3000 static snd_pcm_sframes_t snd_pcm_forward(struct snd_pcm_substream *substream, 3001 snd_pcm_uframes_t frames) 3002 { 3003 snd_pcm_sframes_t ret; 3004 3005 if (frames == 0) 3006 return 0; 3007 3008 scoped_guard(pcm_stream_lock_irq, substream) { 3009 ret = do_pcm_hwsync(substream); 3010 if (!ret) 3011 ret = forward_appl_ptr(substream, frames, 3012 snd_pcm_avail(substream)); 3013 } 3014 if (ret >= 0) 3015 snd_pcm_dma_buffer_sync(substream, SNDRV_DMA_SYNC_DEVICE); 3016 return ret; 3017 } 3018 3019 static int snd_pcm_delay(struct snd_pcm_substream *substream, 3020 snd_pcm_sframes_t *delay) 3021 { 3022 int err; 3023 3024 scoped_guard(pcm_stream_lock_irq, substream) { 3025 err = do_pcm_hwsync(substream); 3026 if (delay && !err) 3027 *delay = snd_pcm_calc_delay(substream); 3028 } 3029 snd_pcm_dma_buffer_sync(substream, SNDRV_DMA_SYNC_CPU); 3030 3031 return err; 3032 } 3033 3034 static inline int snd_pcm_hwsync(struct snd_pcm_substream *substream) 3035 { 3036 return snd_pcm_delay(substream, NULL); 3037 } 3038 3039 static int snd_pcm_sync_ptr(struct snd_pcm_substream *substream, 3040 struct snd_pcm_sync_ptr __user *_sync_ptr) 3041 { 3042 struct snd_pcm_runtime *runtime = substream->runtime; 3043 struct snd_pcm_sync_ptr sync_ptr; 3044 volatile struct snd_pcm_mmap_status *status; 3045 volatile struct snd_pcm_mmap_control *control; 3046 int err; 3047 3048 memset(&sync_ptr, 0, sizeof(sync_ptr)); 3049 if (get_user(sync_ptr.flags, (unsigned __user *)&(_sync_ptr->flags))) 3050 return -EFAULT; 3051 if (copy_from_user(&sync_ptr.c.control, &(_sync_ptr->c.control), sizeof(struct snd_pcm_mmap_control))) 3052 return -EFAULT; 3053 status = runtime->status; 3054 control = runtime->control; 3055 if (sync_ptr.flags & SNDRV_PCM_SYNC_PTR_HWSYNC) { 3056 err = snd_pcm_hwsync(substream); 3057 if (err < 0) 3058 return err; 3059 } 3060 scoped_guard(pcm_stream_lock_irq, substream) { 3061 if (!(sync_ptr.flags & SNDRV_PCM_SYNC_PTR_APPL)) { 3062 err = pcm_lib_apply_appl_ptr(substream, 3063 sync_ptr.c.control.appl_ptr); 3064 if (err < 0) 3065 return err; 3066 } else { 3067 sync_ptr.c.control.appl_ptr = control->appl_ptr; 3068 } 3069 if (!(sync_ptr.flags & SNDRV_PCM_SYNC_PTR_AVAIL_MIN)) 3070 control->avail_min = sync_ptr.c.control.avail_min; 3071 else 3072 sync_ptr.c.control.avail_min = control->avail_min; 3073 sync_ptr.s.status.state = status->state; 3074 sync_ptr.s.status.hw_ptr = status->hw_ptr; 3075 sync_ptr.s.status.tstamp = status->tstamp; 3076 sync_ptr.s.status.suspended_state = status->suspended_state; 3077 sync_ptr.s.status.audio_tstamp = status->audio_tstamp; 3078 } 3079 if (!(sync_ptr.flags & SNDRV_PCM_SYNC_PTR_APPL)) 3080 snd_pcm_dma_buffer_sync(substream, SNDRV_DMA_SYNC_DEVICE); 3081 if (copy_to_user(_sync_ptr, &sync_ptr, sizeof(sync_ptr))) 3082 return -EFAULT; 3083 return 0; 3084 } 3085 3086 struct snd_pcm_mmap_status32 { 3087 snd_pcm_state_t state; 3088 s32 pad1; 3089 u32 hw_ptr; 3090 s32 tstamp_sec; 3091 s32 tstamp_nsec; 3092 snd_pcm_state_t suspended_state; 3093 s32 audio_tstamp_sec; 3094 s32 audio_tstamp_nsec; 3095 } __packed; 3096 3097 struct snd_pcm_mmap_control32 { 3098 u32 appl_ptr; 3099 u32 avail_min; 3100 }; 3101 3102 struct snd_pcm_sync_ptr32 { 3103 u32 flags; 3104 union { 3105 struct snd_pcm_mmap_status32 status; 3106 unsigned char reserved[64]; 3107 } s; 3108 union { 3109 struct snd_pcm_mmap_control32 control; 3110 unsigned char reserved[64]; 3111 } c; 3112 } __packed; 3113 3114 /* recalcuate the boundary within 32bit */ 3115 static snd_pcm_uframes_t recalculate_boundary(struct snd_pcm_runtime *runtime) 3116 { 3117 snd_pcm_uframes_t boundary; 3118 3119 if (! runtime->buffer_size) 3120 return 0; 3121 boundary = runtime->buffer_size; 3122 while (boundary * 2 <= 0x7fffffffUL - runtime->buffer_size) 3123 boundary *= 2; 3124 return boundary; 3125 } 3126 3127 static int snd_pcm_ioctl_sync_ptr_compat(struct snd_pcm_substream *substream, 3128 struct snd_pcm_sync_ptr32 __user *src) 3129 { 3130 struct snd_pcm_runtime *runtime = substream->runtime; 3131 volatile struct snd_pcm_mmap_status *status; 3132 volatile struct snd_pcm_mmap_control *control; 3133 u32 sflags; 3134 struct snd_pcm_mmap_control scontrol; 3135 struct snd_pcm_mmap_status sstatus; 3136 snd_pcm_uframes_t boundary; 3137 int err; 3138 3139 if (snd_BUG_ON(!runtime)) 3140 return -EINVAL; 3141 3142 if (get_user(sflags, &src->flags) || 3143 get_user(scontrol.appl_ptr, &src->c.control.appl_ptr) || 3144 get_user(scontrol.avail_min, &src->c.control.avail_min)) 3145 return -EFAULT; 3146 if (sflags & SNDRV_PCM_SYNC_PTR_HWSYNC) { 3147 err = snd_pcm_hwsync(substream); 3148 if (err < 0) 3149 return err; 3150 } 3151 status = runtime->status; 3152 control = runtime->control; 3153 boundary = recalculate_boundary(runtime); 3154 if (! boundary) 3155 boundary = 0x7fffffff; 3156 scoped_guard(pcm_stream_lock_irq, substream) { 3157 /* FIXME: we should consider the boundary for the sync from app */ 3158 if (!(sflags & SNDRV_PCM_SYNC_PTR_APPL)) { 3159 err = pcm_lib_apply_appl_ptr(substream, 3160 scontrol.appl_ptr); 3161 if (err < 0) 3162 return err; 3163 } else 3164 scontrol.appl_ptr = control->appl_ptr % boundary; 3165 if (!(sflags & SNDRV_PCM_SYNC_PTR_AVAIL_MIN)) 3166 control->avail_min = scontrol.avail_min; 3167 else 3168 scontrol.avail_min = control->avail_min; 3169 sstatus.state = status->state; 3170 sstatus.hw_ptr = status->hw_ptr % boundary; 3171 sstatus.tstamp = status->tstamp; 3172 sstatus.suspended_state = status->suspended_state; 3173 sstatus.audio_tstamp = status->audio_tstamp; 3174 } 3175 if (!(sflags & SNDRV_PCM_SYNC_PTR_APPL)) 3176 snd_pcm_dma_buffer_sync(substream, SNDRV_DMA_SYNC_DEVICE); 3177 if (put_user(sstatus.state, &src->s.status.state) || 3178 put_user(sstatus.hw_ptr, &src->s.status.hw_ptr) || 3179 put_user(sstatus.tstamp.tv_sec, &src->s.status.tstamp_sec) || 3180 put_user(sstatus.tstamp.tv_nsec, &src->s.status.tstamp_nsec) || 3181 put_user(sstatus.suspended_state, &src->s.status.suspended_state) || 3182 put_user(sstatus.audio_tstamp.tv_sec, &src->s.status.audio_tstamp_sec) || 3183 put_user(sstatus.audio_tstamp.tv_nsec, &src->s.status.audio_tstamp_nsec) || 3184 put_user(scontrol.appl_ptr, &src->c.control.appl_ptr) || 3185 put_user(scontrol.avail_min, &src->c.control.avail_min)) 3186 return -EFAULT; 3187 3188 return 0; 3189 } 3190 #define __SNDRV_PCM_IOCTL_SYNC_PTR32 _IOWR('A', 0x23, struct snd_pcm_sync_ptr32) 3191 3192 static int snd_pcm_tstamp(struct snd_pcm_substream *substream, int __user *_arg) 3193 { 3194 struct snd_pcm_runtime *runtime = substream->runtime; 3195 int arg; 3196 3197 if (get_user(arg, _arg)) 3198 return -EFAULT; 3199 if (arg < 0 || arg > SNDRV_PCM_TSTAMP_TYPE_LAST) 3200 return -EINVAL; 3201 runtime->tstamp_type = arg; 3202 return 0; 3203 } 3204 3205 static int snd_pcm_xferi_frames_ioctl(struct snd_pcm_substream *substream, 3206 struct snd_xferi __user *_xferi) 3207 { 3208 struct snd_xferi xferi; 3209 struct snd_pcm_runtime *runtime = substream->runtime; 3210 snd_pcm_sframes_t result; 3211 3212 if (runtime->state == SNDRV_PCM_STATE_OPEN) 3213 return -EBADFD; 3214 if (put_user(0, &_xferi->result)) 3215 return -EFAULT; 3216 if (copy_from_user(&xferi, _xferi, sizeof(xferi))) 3217 return -EFAULT; 3218 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 3219 result = snd_pcm_lib_write(substream, xferi.buf, xferi.frames); 3220 else 3221 result = snd_pcm_lib_read(substream, xferi.buf, xferi.frames); 3222 if (put_user(result, &_xferi->result)) 3223 return -EFAULT; 3224 return result < 0 ? result : 0; 3225 } 3226 3227 static int snd_pcm_xfern_frames_ioctl(struct snd_pcm_substream *substream, 3228 struct snd_xfern __user *_xfern) 3229 { 3230 struct snd_xfern xfern; 3231 struct snd_pcm_runtime *runtime = substream->runtime; 3232 void *bufs __free(kfree) = NULL; 3233 snd_pcm_sframes_t result; 3234 3235 if (runtime->state == SNDRV_PCM_STATE_OPEN) 3236 return -EBADFD; 3237 if (runtime->channels > 128) 3238 return -EINVAL; 3239 if (put_user(0, &_xfern->result)) 3240 return -EFAULT; 3241 if (copy_from_user(&xfern, _xfern, sizeof(xfern))) 3242 return -EFAULT; 3243 3244 bufs = memdup_user(xfern.bufs, sizeof(void *) * runtime->channels); 3245 if (IS_ERR(bufs)) 3246 return PTR_ERR(no_free_ptr(bufs)); 3247 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 3248 result = snd_pcm_lib_writev(substream, bufs, xfern.frames); 3249 else 3250 result = snd_pcm_lib_readv(substream, bufs, xfern.frames); 3251 if (put_user(result, &_xfern->result)) 3252 return -EFAULT; 3253 return result < 0 ? result : 0; 3254 } 3255 3256 static int snd_pcm_rewind_ioctl(struct snd_pcm_substream *substream, 3257 snd_pcm_uframes_t __user *_frames) 3258 { 3259 snd_pcm_uframes_t frames; 3260 snd_pcm_sframes_t result; 3261 3262 if (get_user(frames, _frames)) 3263 return -EFAULT; 3264 if (put_user(0, _frames)) 3265 return -EFAULT; 3266 result = snd_pcm_rewind(substream, frames); 3267 if (put_user(result, _frames)) 3268 return -EFAULT; 3269 return result < 0 ? result : 0; 3270 } 3271 3272 static int snd_pcm_forward_ioctl(struct snd_pcm_substream *substream, 3273 snd_pcm_uframes_t __user *_frames) 3274 { 3275 snd_pcm_uframes_t frames; 3276 snd_pcm_sframes_t result; 3277 3278 if (get_user(frames, _frames)) 3279 return -EFAULT; 3280 if (put_user(0, _frames)) 3281 return -EFAULT; 3282 result = snd_pcm_forward(substream, frames); 3283 if (put_user(result, _frames)) 3284 return -EFAULT; 3285 return result < 0 ? result : 0; 3286 } 3287 3288 static int snd_pcm_common_ioctl(struct file *file, 3289 struct snd_pcm_substream *substream, 3290 unsigned int cmd, void __user *arg) 3291 { 3292 struct snd_pcm_file *pcm_file = file->private_data; 3293 int res; 3294 3295 if (PCM_RUNTIME_CHECK(substream)) 3296 return -ENXIO; 3297 3298 if (substream->runtime->state == SNDRV_PCM_STATE_DISCONNECTED) 3299 return -EBADFD; 3300 3301 res = snd_power_wait(substream->pcm->card); 3302 if (res < 0) 3303 return res; 3304 3305 switch (cmd) { 3306 case SNDRV_PCM_IOCTL_PVERSION: 3307 return put_user(SNDRV_PCM_VERSION, (int __user *)arg) ? -EFAULT : 0; 3308 case SNDRV_PCM_IOCTL_INFO: 3309 return snd_pcm_info_user(substream, arg); 3310 case SNDRV_PCM_IOCTL_TSTAMP: /* just for compatibility */ 3311 return 0; 3312 case SNDRV_PCM_IOCTL_TTSTAMP: 3313 return snd_pcm_tstamp(substream, arg); 3314 case SNDRV_PCM_IOCTL_USER_PVERSION: 3315 if (get_user(pcm_file->user_pversion, 3316 (unsigned int __user *)arg)) 3317 return -EFAULT; 3318 return 0; 3319 case SNDRV_PCM_IOCTL_HW_REFINE: 3320 return snd_pcm_hw_refine_user(substream, arg); 3321 case SNDRV_PCM_IOCTL_HW_PARAMS: 3322 return snd_pcm_hw_params_user(substream, arg); 3323 case SNDRV_PCM_IOCTL_HW_FREE: 3324 return snd_pcm_hw_free(substream); 3325 case SNDRV_PCM_IOCTL_SW_PARAMS: 3326 return snd_pcm_sw_params_user(substream, arg); 3327 case SNDRV_PCM_IOCTL_STATUS32: 3328 return snd_pcm_status_user32(substream, arg, false); 3329 case SNDRV_PCM_IOCTL_STATUS_EXT32: 3330 return snd_pcm_status_user32(substream, arg, true); 3331 case SNDRV_PCM_IOCTL_STATUS64: 3332 return snd_pcm_status_user64(substream, arg, false); 3333 case SNDRV_PCM_IOCTL_STATUS_EXT64: 3334 return snd_pcm_status_user64(substream, arg, true); 3335 case SNDRV_PCM_IOCTL_CHANNEL_INFO: 3336 return snd_pcm_channel_info_user(substream, arg); 3337 case SNDRV_PCM_IOCTL_PREPARE: 3338 return snd_pcm_prepare(substream, file); 3339 case SNDRV_PCM_IOCTL_RESET: 3340 return snd_pcm_reset(substream); 3341 case SNDRV_PCM_IOCTL_START: 3342 return snd_pcm_start_lock_irq(substream); 3343 case SNDRV_PCM_IOCTL_LINK: 3344 return snd_pcm_link(substream, (int)(unsigned long) arg); 3345 case SNDRV_PCM_IOCTL_UNLINK: 3346 return snd_pcm_unlink(substream); 3347 case SNDRV_PCM_IOCTL_RESUME: 3348 return snd_pcm_resume(substream); 3349 case SNDRV_PCM_IOCTL_XRUN: 3350 return snd_pcm_xrun(substream); 3351 case SNDRV_PCM_IOCTL_HWSYNC: 3352 return snd_pcm_hwsync(substream); 3353 case SNDRV_PCM_IOCTL_DELAY: 3354 { 3355 snd_pcm_sframes_t delay = 0; 3356 snd_pcm_sframes_t __user *res = arg; 3357 int err; 3358 3359 err = snd_pcm_delay(substream, &delay); 3360 if (err) 3361 return err; 3362 if (put_user(delay, res)) 3363 return -EFAULT; 3364 return 0; 3365 } 3366 case __SNDRV_PCM_IOCTL_SYNC_PTR32: 3367 return snd_pcm_ioctl_sync_ptr_compat(substream, arg); 3368 case __SNDRV_PCM_IOCTL_SYNC_PTR64: 3369 return snd_pcm_sync_ptr(substream, arg); 3370 #ifdef CONFIG_SND_SUPPORT_OLD_API 3371 case SNDRV_PCM_IOCTL_HW_REFINE_OLD: 3372 return snd_pcm_hw_refine_old_user(substream, arg); 3373 case SNDRV_PCM_IOCTL_HW_PARAMS_OLD: 3374 return snd_pcm_hw_params_old_user(substream, arg); 3375 #endif 3376 case SNDRV_PCM_IOCTL_DRAIN: 3377 return snd_pcm_drain(substream, file); 3378 case SNDRV_PCM_IOCTL_DROP: 3379 return snd_pcm_drop(substream); 3380 case SNDRV_PCM_IOCTL_PAUSE: 3381 return snd_pcm_pause_lock_irq(substream, (unsigned long)arg); 3382 case SNDRV_PCM_IOCTL_WRITEI_FRAMES: 3383 case SNDRV_PCM_IOCTL_READI_FRAMES: 3384 return snd_pcm_xferi_frames_ioctl(substream, arg); 3385 case SNDRV_PCM_IOCTL_WRITEN_FRAMES: 3386 case SNDRV_PCM_IOCTL_READN_FRAMES: 3387 return snd_pcm_xfern_frames_ioctl(substream, arg); 3388 case SNDRV_PCM_IOCTL_REWIND: 3389 return snd_pcm_rewind_ioctl(substream, arg); 3390 case SNDRV_PCM_IOCTL_FORWARD: 3391 return snd_pcm_forward_ioctl(substream, arg); 3392 } 3393 pcm_dbg(substream->pcm, "unknown ioctl = 0x%x\n", cmd); 3394 return -ENOTTY; 3395 } 3396 3397 static long snd_pcm_ioctl(struct file *file, unsigned int cmd, 3398 unsigned long arg) 3399 { 3400 struct snd_pcm_file *pcm_file; 3401 3402 pcm_file = file->private_data; 3403 3404 if (((cmd >> 8) & 0xff) != 'A') 3405 return -ENOTTY; 3406 3407 return snd_pcm_common_ioctl(file, pcm_file->substream, cmd, 3408 (void __user *)arg); 3409 } 3410 3411 /** 3412 * snd_pcm_kernel_ioctl - Execute PCM ioctl in the kernel-space 3413 * @substream: PCM substream 3414 * @cmd: IOCTL cmd 3415 * @arg: IOCTL argument 3416 * 3417 * The function is provided primarily for OSS layer and USB gadget drivers, 3418 * and it allows only the limited set of ioctls (hw_params, sw_params, 3419 * prepare, start, drain, drop, forward). 3420 * 3421 * Return: zero if successful, or a negative error code 3422 */ 3423 int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream, 3424 unsigned int cmd, void *arg) 3425 { 3426 snd_pcm_uframes_t *frames = arg; 3427 snd_pcm_sframes_t result; 3428 3429 if (substream->runtime->state == SNDRV_PCM_STATE_DISCONNECTED) 3430 return -EBADFD; 3431 3432 switch (cmd) { 3433 case SNDRV_PCM_IOCTL_FORWARD: 3434 { 3435 /* provided only for OSS; capture-only and no value returned */ 3436 if (substream->stream != SNDRV_PCM_STREAM_CAPTURE) 3437 return -EINVAL; 3438 result = snd_pcm_forward(substream, *frames); 3439 return result < 0 ? result : 0; 3440 } 3441 case SNDRV_PCM_IOCTL_HW_PARAMS: 3442 return snd_pcm_hw_params(substream, arg); 3443 case SNDRV_PCM_IOCTL_SW_PARAMS: 3444 return snd_pcm_sw_params(substream, arg); 3445 case SNDRV_PCM_IOCTL_PREPARE: 3446 return snd_pcm_prepare(substream, NULL); 3447 case SNDRV_PCM_IOCTL_START: 3448 return snd_pcm_start_lock_irq(substream); 3449 case SNDRV_PCM_IOCTL_DRAIN: 3450 return snd_pcm_drain(substream, NULL); 3451 case SNDRV_PCM_IOCTL_DROP: 3452 return snd_pcm_drop(substream); 3453 case SNDRV_PCM_IOCTL_DELAY: 3454 return snd_pcm_delay(substream, frames); 3455 default: 3456 return -EINVAL; 3457 } 3458 } 3459 EXPORT_SYMBOL(snd_pcm_kernel_ioctl); 3460 3461 static ssize_t snd_pcm_read(struct file *file, char __user *buf, size_t count, 3462 loff_t * offset) 3463 { 3464 struct snd_pcm_file *pcm_file; 3465 struct snd_pcm_substream *substream; 3466 struct snd_pcm_runtime *runtime; 3467 snd_pcm_sframes_t result; 3468 3469 pcm_file = file->private_data; 3470 substream = pcm_file->substream; 3471 if (PCM_RUNTIME_CHECK(substream)) 3472 return -ENXIO; 3473 runtime = substream->runtime; 3474 if (runtime->state == SNDRV_PCM_STATE_OPEN || 3475 runtime->state == SNDRV_PCM_STATE_DISCONNECTED) 3476 return -EBADFD; 3477 if (!frame_aligned(runtime, count)) 3478 return -EINVAL; 3479 count = bytes_to_frames(runtime, count); 3480 result = snd_pcm_lib_read(substream, buf, count); 3481 if (result > 0) 3482 result = frames_to_bytes(runtime, result); 3483 return result; 3484 } 3485 3486 static ssize_t snd_pcm_write(struct file *file, const char __user *buf, 3487 size_t count, loff_t * offset) 3488 { 3489 struct snd_pcm_file *pcm_file; 3490 struct snd_pcm_substream *substream; 3491 struct snd_pcm_runtime *runtime; 3492 snd_pcm_sframes_t result; 3493 3494 pcm_file = file->private_data; 3495 substream = pcm_file->substream; 3496 if (PCM_RUNTIME_CHECK(substream)) 3497 return -ENXIO; 3498 runtime = substream->runtime; 3499 if (runtime->state == SNDRV_PCM_STATE_OPEN || 3500 runtime->state == SNDRV_PCM_STATE_DISCONNECTED) 3501 return -EBADFD; 3502 if (!frame_aligned(runtime, count)) 3503 return -EINVAL; 3504 count = bytes_to_frames(runtime, count); 3505 result = snd_pcm_lib_write(substream, buf, count); 3506 if (result > 0) 3507 result = frames_to_bytes(runtime, result); 3508 return result; 3509 } 3510 3511 static ssize_t snd_pcm_readv(struct kiocb *iocb, struct iov_iter *to) 3512 { 3513 struct snd_pcm_file *pcm_file; 3514 struct snd_pcm_substream *substream; 3515 struct snd_pcm_runtime *runtime; 3516 snd_pcm_sframes_t result; 3517 unsigned long i; 3518 void __user **bufs __free(kfree) = NULL; 3519 snd_pcm_uframes_t frames; 3520 const struct iovec *iov = iter_iov(to); 3521 3522 pcm_file = iocb->ki_filp->private_data; 3523 substream = pcm_file->substream; 3524 if (PCM_RUNTIME_CHECK(substream)) 3525 return -ENXIO; 3526 runtime = substream->runtime; 3527 if (runtime->state == SNDRV_PCM_STATE_OPEN || 3528 runtime->state == SNDRV_PCM_STATE_DISCONNECTED) 3529 return -EBADFD; 3530 if (!user_backed_iter(to)) 3531 return -EINVAL; 3532 if (to->nr_segs > 1024 || to->nr_segs != runtime->channels) 3533 return -EINVAL; 3534 if (!frame_aligned(runtime, iov->iov_len)) 3535 return -EINVAL; 3536 frames = bytes_to_samples(runtime, iov->iov_len); 3537 bufs = kmalloc_array(to->nr_segs, sizeof(void *), GFP_KERNEL); 3538 if (bufs == NULL) 3539 return -ENOMEM; 3540 for (i = 0; i < to->nr_segs; ++i) { 3541 bufs[i] = iov->iov_base; 3542 iov++; 3543 } 3544 result = snd_pcm_lib_readv(substream, bufs, frames); 3545 if (result > 0) 3546 result = frames_to_bytes(runtime, result); 3547 return result; 3548 } 3549 3550 static ssize_t snd_pcm_writev(struct kiocb *iocb, struct iov_iter *from) 3551 { 3552 struct snd_pcm_file *pcm_file; 3553 struct snd_pcm_substream *substream; 3554 struct snd_pcm_runtime *runtime; 3555 snd_pcm_sframes_t result; 3556 unsigned long i; 3557 void __user **bufs __free(kfree) = NULL; 3558 snd_pcm_uframes_t frames; 3559 const struct iovec *iov = iter_iov(from); 3560 3561 pcm_file = iocb->ki_filp->private_data; 3562 substream = pcm_file->substream; 3563 if (PCM_RUNTIME_CHECK(substream)) 3564 return -ENXIO; 3565 runtime = substream->runtime; 3566 if (runtime->state == SNDRV_PCM_STATE_OPEN || 3567 runtime->state == SNDRV_PCM_STATE_DISCONNECTED) 3568 return -EBADFD; 3569 if (!user_backed_iter(from)) 3570 return -EINVAL; 3571 if (from->nr_segs > 128 || from->nr_segs != runtime->channels || 3572 !frame_aligned(runtime, iov->iov_len)) 3573 return -EINVAL; 3574 frames = bytes_to_samples(runtime, iov->iov_len); 3575 bufs = kmalloc_array(from->nr_segs, sizeof(void *), GFP_KERNEL); 3576 if (bufs == NULL) 3577 return -ENOMEM; 3578 for (i = 0; i < from->nr_segs; ++i) { 3579 bufs[i] = iov->iov_base; 3580 iov++; 3581 } 3582 result = snd_pcm_lib_writev(substream, bufs, frames); 3583 if (result > 0) 3584 result = frames_to_bytes(runtime, result); 3585 return result; 3586 } 3587 3588 static __poll_t snd_pcm_poll(struct file *file, poll_table *wait) 3589 { 3590 struct snd_pcm_file *pcm_file; 3591 struct snd_pcm_substream *substream; 3592 struct snd_pcm_runtime *runtime; 3593 __poll_t mask, ok; 3594 snd_pcm_uframes_t avail; 3595 3596 pcm_file = file->private_data; 3597 3598 substream = pcm_file->substream; 3599 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 3600 ok = EPOLLOUT | EPOLLWRNORM; 3601 else 3602 ok = EPOLLIN | EPOLLRDNORM; 3603 if (PCM_RUNTIME_CHECK(substream)) 3604 return ok | EPOLLERR; 3605 3606 runtime = substream->runtime; 3607 if (runtime->state == SNDRV_PCM_STATE_DISCONNECTED) 3608 return ok | EPOLLERR; 3609 3610 poll_wait(file, &runtime->sleep, wait); 3611 3612 mask = 0; 3613 guard(pcm_stream_lock_irq)(substream); 3614 avail = snd_pcm_avail(substream); 3615 switch (runtime->state) { 3616 case SNDRV_PCM_STATE_RUNNING: 3617 case SNDRV_PCM_STATE_PREPARED: 3618 case SNDRV_PCM_STATE_PAUSED: 3619 if (avail >= runtime->control->avail_min) 3620 mask = ok; 3621 break; 3622 case SNDRV_PCM_STATE_DRAINING: 3623 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) { 3624 mask = ok; 3625 if (!avail) 3626 mask |= EPOLLERR; 3627 } 3628 break; 3629 default: 3630 mask = ok | EPOLLERR; 3631 break; 3632 } 3633 return mask; 3634 } 3635 3636 /* 3637 * mmap support 3638 */ 3639 3640 /* 3641 * Only on coherent architectures, we can mmap the status and the control records 3642 * for effcient data transfer. On others, we have to use HWSYNC ioctl... 3643 */ 3644 #if defined(CONFIG_X86) || defined(CONFIG_PPC) || defined(CONFIG_ALPHA) 3645 /* 3646 * mmap status record 3647 */ 3648 static vm_fault_t snd_pcm_mmap_status_fault(struct vm_fault *vmf) 3649 { 3650 struct snd_pcm_substream *substream = vmf->vma->vm_private_data; 3651 struct snd_pcm_runtime *runtime; 3652 3653 if (substream == NULL) 3654 return VM_FAULT_SIGBUS; 3655 runtime = substream->runtime; 3656 vmf->page = virt_to_page(runtime->status); 3657 get_page(vmf->page); 3658 return 0; 3659 } 3660 3661 static const struct vm_operations_struct snd_pcm_vm_ops_status = 3662 { 3663 .fault = snd_pcm_mmap_status_fault, 3664 }; 3665 3666 static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file *file, 3667 struct vm_area_struct *area) 3668 { 3669 long size; 3670 if (!(area->vm_flags & VM_READ)) 3671 return -EINVAL; 3672 size = area->vm_end - area->vm_start; 3673 if (size != PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status))) 3674 return -EINVAL; 3675 area->vm_ops = &snd_pcm_vm_ops_status; 3676 area->vm_private_data = substream; 3677 vm_flags_mod(area, VM_DONTEXPAND | VM_DONTDUMP, 3678 VM_WRITE | VM_MAYWRITE); 3679 3680 return 0; 3681 } 3682 3683 /* 3684 * mmap control record 3685 */ 3686 static vm_fault_t snd_pcm_mmap_control_fault(struct vm_fault *vmf) 3687 { 3688 struct snd_pcm_substream *substream = vmf->vma->vm_private_data; 3689 struct snd_pcm_runtime *runtime; 3690 3691 if (substream == NULL) 3692 return VM_FAULT_SIGBUS; 3693 runtime = substream->runtime; 3694 vmf->page = virt_to_page(runtime->control); 3695 get_page(vmf->page); 3696 return 0; 3697 } 3698 3699 static const struct vm_operations_struct snd_pcm_vm_ops_control = 3700 { 3701 .fault = snd_pcm_mmap_control_fault, 3702 }; 3703 3704 static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file *file, 3705 struct vm_area_struct *area) 3706 { 3707 long size; 3708 if (!(area->vm_flags & VM_READ)) 3709 return -EINVAL; 3710 size = area->vm_end - area->vm_start; 3711 if (size != PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control))) 3712 return -EINVAL; 3713 area->vm_ops = &snd_pcm_vm_ops_control; 3714 area->vm_private_data = substream; 3715 vm_flags_set(area, VM_DONTEXPAND | VM_DONTDUMP); 3716 return 0; 3717 } 3718 3719 static bool pcm_status_mmap_allowed(struct snd_pcm_file *pcm_file) 3720 { 3721 /* If drivers require the explicit sync (typically for non-coherent 3722 * pages), we have to disable the mmap of status and control data 3723 * to enforce the control via SYNC_PTR ioctl. 3724 */ 3725 if (pcm_file->substream->runtime->hw.info & SNDRV_PCM_INFO_EXPLICIT_SYNC) 3726 return false; 3727 /* See pcm_control_mmap_allowed() below. 3728 * Since older alsa-lib requires both status and control mmaps to be 3729 * coupled, we have to disable the status mmap for old alsa-lib, too. 3730 */ 3731 if (pcm_file->user_pversion < SNDRV_PROTOCOL_VERSION(2, 0, 14) && 3732 (pcm_file->substream->runtime->hw.info & SNDRV_PCM_INFO_SYNC_APPLPTR)) 3733 return false; 3734 return true; 3735 } 3736 3737 static bool pcm_control_mmap_allowed(struct snd_pcm_file *pcm_file) 3738 { 3739 if (pcm_file->no_compat_mmap) 3740 return false; 3741 /* see above */ 3742 if (pcm_file->substream->runtime->hw.info & SNDRV_PCM_INFO_EXPLICIT_SYNC) 3743 return false; 3744 /* Disallow the control mmap when SYNC_APPLPTR flag is set; 3745 * it enforces the user-space to fall back to snd_pcm_sync_ptr(), 3746 * thus it effectively assures the manual update of appl_ptr. 3747 */ 3748 if (pcm_file->substream->runtime->hw.info & SNDRV_PCM_INFO_SYNC_APPLPTR) 3749 return false; 3750 return true; 3751 } 3752 3753 #else /* ! coherent mmap */ 3754 /* 3755 * don't support mmap for status and control records. 3756 */ 3757 #define pcm_status_mmap_allowed(pcm_file) false 3758 #define pcm_control_mmap_allowed(pcm_file) false 3759 3760 static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file *file, 3761 struct vm_area_struct *area) 3762 { 3763 return -ENXIO; 3764 } 3765 static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file *file, 3766 struct vm_area_struct *area) 3767 { 3768 return -ENXIO; 3769 } 3770 #endif /* coherent mmap */ 3771 3772 /* 3773 * fault callback for mmapping a RAM page 3774 */ 3775 static vm_fault_t snd_pcm_mmap_data_fault(struct vm_fault *vmf) 3776 { 3777 struct snd_pcm_substream *substream = vmf->vma->vm_private_data; 3778 struct snd_pcm_runtime *runtime; 3779 unsigned long offset; 3780 struct page * page; 3781 size_t dma_bytes; 3782 3783 if (substream == NULL) 3784 return VM_FAULT_SIGBUS; 3785 runtime = substream->runtime; 3786 offset = vmf->pgoff << PAGE_SHIFT; 3787 dma_bytes = PAGE_ALIGN(runtime->dma_bytes); 3788 if (offset > dma_bytes - PAGE_SIZE) 3789 return VM_FAULT_SIGBUS; 3790 if (substream->ops->page) 3791 page = substream->ops->page(substream, offset); 3792 else if (!snd_pcm_get_dma_buf(substream)) 3793 page = virt_to_page(runtime->dma_area + offset); 3794 else 3795 page = snd_sgbuf_get_page(snd_pcm_get_dma_buf(substream), offset); 3796 if (!page) 3797 return VM_FAULT_SIGBUS; 3798 get_page(page); 3799 vmf->page = page; 3800 return 0; 3801 } 3802 3803 static const struct vm_operations_struct snd_pcm_vm_ops_data = { 3804 .open = snd_pcm_mmap_data_open, 3805 .close = snd_pcm_mmap_data_close, 3806 }; 3807 3808 static const struct vm_operations_struct snd_pcm_vm_ops_data_fault = { 3809 .open = snd_pcm_mmap_data_open, 3810 .close = snd_pcm_mmap_data_close, 3811 .fault = snd_pcm_mmap_data_fault, 3812 }; 3813 3814 /* 3815 * mmap the DMA buffer on RAM 3816 */ 3817 3818 /** 3819 * snd_pcm_lib_default_mmap - Default PCM data mmap function 3820 * @substream: PCM substream 3821 * @area: VMA 3822 * 3823 * This is the default mmap handler for PCM data. When mmap pcm_ops is NULL, 3824 * this function is invoked implicitly. 3825 * 3826 * Return: zero if successful, or a negative error code 3827 */ 3828 int snd_pcm_lib_default_mmap(struct snd_pcm_substream *substream, 3829 struct vm_area_struct *area) 3830 { 3831 vm_flags_set(area, VM_DONTEXPAND | VM_DONTDUMP); 3832 if (!substream->ops->page && 3833 !snd_dma_buffer_mmap(snd_pcm_get_dma_buf(substream), area)) 3834 return 0; 3835 /* mmap with fault handler */ 3836 area->vm_ops = &snd_pcm_vm_ops_data_fault; 3837 return 0; 3838 } 3839 EXPORT_SYMBOL_GPL(snd_pcm_lib_default_mmap); 3840 3841 /* 3842 * mmap the DMA buffer on I/O memory area 3843 */ 3844 #if SNDRV_PCM_INFO_MMAP_IOMEM 3845 /** 3846 * snd_pcm_lib_mmap_iomem - Default PCM data mmap function for I/O mem 3847 * @substream: PCM substream 3848 * @area: VMA 3849 * 3850 * When your hardware uses the iomapped pages as the hardware buffer and 3851 * wants to mmap it, pass this function as mmap pcm_ops. Note that this 3852 * is supposed to work only on limited architectures. 3853 * 3854 * Return: zero if successful, or a negative error code 3855 */ 3856 int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream, 3857 struct vm_area_struct *area) 3858 { 3859 struct snd_pcm_runtime *runtime = substream->runtime; 3860 3861 area->vm_page_prot = pgprot_noncached(area->vm_page_prot); 3862 return vm_iomap_memory(area, runtime->dma_addr, runtime->dma_bytes); 3863 } 3864 EXPORT_SYMBOL(snd_pcm_lib_mmap_iomem); 3865 #endif /* SNDRV_PCM_INFO_MMAP */ 3866 3867 /* 3868 * mmap DMA buffer 3869 */ 3870 int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file, 3871 struct vm_area_struct *area) 3872 { 3873 struct snd_pcm_runtime *runtime; 3874 long size; 3875 unsigned long offset; 3876 size_t dma_bytes; 3877 int err; 3878 3879 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 3880 if (!(area->vm_flags & (VM_WRITE|VM_READ))) 3881 return -EINVAL; 3882 } else { 3883 if (!(area->vm_flags & VM_READ)) 3884 return -EINVAL; 3885 } 3886 runtime = substream->runtime; 3887 if (runtime->state == SNDRV_PCM_STATE_OPEN) 3888 return -EBADFD; 3889 if (!(runtime->info & SNDRV_PCM_INFO_MMAP)) 3890 return -ENXIO; 3891 if (runtime->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED || 3892 runtime->access == SNDRV_PCM_ACCESS_RW_NONINTERLEAVED) 3893 return -EINVAL; 3894 size = area->vm_end - area->vm_start; 3895 offset = area->vm_pgoff << PAGE_SHIFT; 3896 dma_bytes = PAGE_ALIGN(runtime->dma_bytes); 3897 if ((size_t)size > dma_bytes) 3898 return -EINVAL; 3899 if (offset > dma_bytes - size) 3900 return -EINVAL; 3901 3902 area->vm_ops = &snd_pcm_vm_ops_data; 3903 area->vm_private_data = substream; 3904 if (substream->ops->mmap) 3905 err = substream->ops->mmap(substream, area); 3906 else 3907 err = snd_pcm_lib_default_mmap(substream, area); 3908 if (!err) 3909 atomic_inc(&substream->mmap_count); 3910 return err; 3911 } 3912 EXPORT_SYMBOL(snd_pcm_mmap_data); 3913 3914 static int snd_pcm_mmap(struct file *file, struct vm_area_struct *area) 3915 { 3916 struct snd_pcm_file * pcm_file; 3917 struct snd_pcm_substream *substream; 3918 unsigned long offset; 3919 3920 pcm_file = file->private_data; 3921 substream = pcm_file->substream; 3922 if (PCM_RUNTIME_CHECK(substream)) 3923 return -ENXIO; 3924 if (substream->runtime->state == SNDRV_PCM_STATE_DISCONNECTED) 3925 return -EBADFD; 3926 3927 offset = area->vm_pgoff << PAGE_SHIFT; 3928 switch (offset) { 3929 case SNDRV_PCM_MMAP_OFFSET_STATUS_OLD: 3930 if (pcm_file->no_compat_mmap || !IS_ENABLED(CONFIG_64BIT)) 3931 return -ENXIO; 3932 fallthrough; 3933 case SNDRV_PCM_MMAP_OFFSET_STATUS_NEW: 3934 if (!pcm_status_mmap_allowed(pcm_file)) 3935 return -ENXIO; 3936 return snd_pcm_mmap_status(substream, file, area); 3937 case SNDRV_PCM_MMAP_OFFSET_CONTROL_OLD: 3938 if (pcm_file->no_compat_mmap || !IS_ENABLED(CONFIG_64BIT)) 3939 return -ENXIO; 3940 fallthrough; 3941 case SNDRV_PCM_MMAP_OFFSET_CONTROL_NEW: 3942 if (!pcm_control_mmap_allowed(pcm_file)) 3943 return -ENXIO; 3944 return snd_pcm_mmap_control(substream, file, area); 3945 default: 3946 return snd_pcm_mmap_data(substream, file, area); 3947 } 3948 return 0; 3949 } 3950 3951 static int snd_pcm_fasync(int fd, struct file * file, int on) 3952 { 3953 struct snd_pcm_file * pcm_file; 3954 struct snd_pcm_substream *substream; 3955 struct snd_pcm_runtime *runtime; 3956 3957 pcm_file = file->private_data; 3958 substream = pcm_file->substream; 3959 if (PCM_RUNTIME_CHECK(substream)) 3960 return -ENXIO; 3961 runtime = substream->runtime; 3962 if (runtime->state == SNDRV_PCM_STATE_DISCONNECTED) 3963 return -EBADFD; 3964 return snd_fasync_helper(fd, file, on, &runtime->fasync); 3965 } 3966 3967 /* 3968 * ioctl32 compat 3969 */ 3970 #ifdef CONFIG_COMPAT 3971 #include "pcm_compat.c" 3972 #else 3973 #define snd_pcm_ioctl_compat NULL 3974 #endif 3975 3976 /* 3977 * To be removed helpers to keep binary compatibility 3978 */ 3979 3980 #ifdef CONFIG_SND_SUPPORT_OLD_API 3981 #define __OLD_TO_NEW_MASK(x) ((x&7)|((x&0x07fffff8)<<5)) 3982 #define __NEW_TO_OLD_MASK(x) ((x&7)|((x&0xffffff00)>>5)) 3983 3984 static void snd_pcm_hw_convert_from_old_params(struct snd_pcm_hw_params *params, 3985 struct snd_pcm_hw_params_old *oparams) 3986 { 3987 unsigned int i; 3988 3989 memset(params, 0, sizeof(*params)); 3990 params->flags = oparams->flags; 3991 for (i = 0; i < ARRAY_SIZE(oparams->masks); i++) 3992 params->masks[i].bits[0] = oparams->masks[i]; 3993 memcpy(params->intervals, oparams->intervals, sizeof(oparams->intervals)); 3994 params->rmask = __OLD_TO_NEW_MASK(oparams->rmask); 3995 params->cmask = __OLD_TO_NEW_MASK(oparams->cmask); 3996 params->info = oparams->info; 3997 params->msbits = oparams->msbits; 3998 params->rate_num = oparams->rate_num; 3999 params->rate_den = oparams->rate_den; 4000 params->fifo_size = oparams->fifo_size; 4001 } 4002 4003 static void snd_pcm_hw_convert_to_old_params(struct snd_pcm_hw_params_old *oparams, 4004 struct snd_pcm_hw_params *params) 4005 { 4006 unsigned int i; 4007 4008 memset(oparams, 0, sizeof(*oparams)); 4009 oparams->flags = params->flags; 4010 for (i = 0; i < ARRAY_SIZE(oparams->masks); i++) 4011 oparams->masks[i] = params->masks[i].bits[0]; 4012 memcpy(oparams->intervals, params->intervals, sizeof(oparams->intervals)); 4013 oparams->rmask = __NEW_TO_OLD_MASK(params->rmask); 4014 oparams->cmask = __NEW_TO_OLD_MASK(params->cmask); 4015 oparams->info = params->info; 4016 oparams->msbits = params->msbits; 4017 oparams->rate_num = params->rate_num; 4018 oparams->rate_den = params->rate_den; 4019 oparams->fifo_size = params->fifo_size; 4020 } 4021 4022 static int snd_pcm_hw_refine_old_user(struct snd_pcm_substream *substream, 4023 struct snd_pcm_hw_params_old __user * _oparams) 4024 { 4025 struct snd_pcm_hw_params *params __free(kfree) = NULL; 4026 struct snd_pcm_hw_params_old *oparams __free(kfree) = NULL; 4027 int err; 4028 4029 params = kmalloc(sizeof(*params), GFP_KERNEL); 4030 if (!params) 4031 return -ENOMEM; 4032 4033 oparams = memdup_user(_oparams, sizeof(*oparams)); 4034 if (IS_ERR(oparams)) 4035 return PTR_ERR(no_free_ptr(oparams)); 4036 snd_pcm_hw_convert_from_old_params(params, oparams); 4037 err = snd_pcm_hw_refine(substream, params); 4038 if (err < 0) 4039 return err; 4040 4041 err = fixup_unreferenced_params(substream, params); 4042 if (err < 0) 4043 return err; 4044 4045 snd_pcm_hw_convert_to_old_params(oparams, params); 4046 if (copy_to_user(_oparams, oparams, sizeof(*oparams))) 4047 return -EFAULT; 4048 return 0; 4049 } 4050 4051 static int snd_pcm_hw_params_old_user(struct snd_pcm_substream *substream, 4052 struct snd_pcm_hw_params_old __user * _oparams) 4053 { 4054 struct snd_pcm_hw_params *params __free(kfree) = NULL; 4055 struct snd_pcm_hw_params_old *oparams __free(kfree) = NULL; 4056 int err; 4057 4058 params = kmalloc(sizeof(*params), GFP_KERNEL); 4059 if (!params) 4060 return -ENOMEM; 4061 4062 oparams = memdup_user(_oparams, sizeof(*oparams)); 4063 if (IS_ERR(oparams)) 4064 return PTR_ERR(no_free_ptr(oparams)); 4065 4066 snd_pcm_hw_convert_from_old_params(params, oparams); 4067 err = snd_pcm_hw_params(substream, params); 4068 if (err < 0) 4069 return err; 4070 4071 snd_pcm_hw_convert_to_old_params(oparams, params); 4072 if (copy_to_user(_oparams, oparams, sizeof(*oparams))) 4073 return -EFAULT; 4074 return 0; 4075 } 4076 #endif /* CONFIG_SND_SUPPORT_OLD_API */ 4077 4078 #ifndef CONFIG_MMU 4079 static unsigned long snd_pcm_get_unmapped_area(struct file *file, 4080 unsigned long addr, 4081 unsigned long len, 4082 unsigned long pgoff, 4083 unsigned long flags) 4084 { 4085 struct snd_pcm_file *pcm_file = file->private_data; 4086 struct snd_pcm_substream *substream = pcm_file->substream; 4087 struct snd_pcm_runtime *runtime = substream->runtime; 4088 unsigned long offset = pgoff << PAGE_SHIFT; 4089 4090 switch (offset) { 4091 case SNDRV_PCM_MMAP_OFFSET_STATUS_NEW: 4092 return (unsigned long)runtime->status; 4093 case SNDRV_PCM_MMAP_OFFSET_CONTROL_NEW: 4094 return (unsigned long)runtime->control; 4095 default: 4096 return (unsigned long)runtime->dma_area + offset; 4097 } 4098 } 4099 #else 4100 # define snd_pcm_get_unmapped_area NULL 4101 #endif 4102 4103 /* 4104 * Register section 4105 */ 4106 4107 const struct file_operations snd_pcm_f_ops[2] = { 4108 { 4109 .owner = THIS_MODULE, 4110 .write = snd_pcm_write, 4111 .write_iter = snd_pcm_writev, 4112 .open = snd_pcm_playback_open, 4113 .release = snd_pcm_release, 4114 .llseek = no_llseek, 4115 .poll = snd_pcm_poll, 4116 .unlocked_ioctl = snd_pcm_ioctl, 4117 .compat_ioctl = snd_pcm_ioctl_compat, 4118 .mmap = snd_pcm_mmap, 4119 .fasync = snd_pcm_fasync, 4120 .get_unmapped_area = snd_pcm_get_unmapped_area, 4121 }, 4122 { 4123 .owner = THIS_MODULE, 4124 .read = snd_pcm_read, 4125 .read_iter = snd_pcm_readv, 4126 .open = snd_pcm_capture_open, 4127 .release = snd_pcm_release, 4128 .llseek = no_llseek, 4129 .poll = snd_pcm_poll, 4130 .unlocked_ioctl = snd_pcm_ioctl, 4131 .compat_ioctl = snd_pcm_ioctl_compat, 4132 .mmap = snd_pcm_mmap, 4133 .fasync = snd_pcm_fasync, 4134 .get_unmapped_area = snd_pcm_get_unmapped_area, 4135 } 4136 }; 4137