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