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