Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
pcm_lib.c
Go to the documentation of this file.
1 /*
2  * Digital Audio (PCM) abstract layer
3  * Copyright (c) by Jaroslav Kysela <[email protected]>
4  * Abramo Bagnara <[email protected]>
5  *
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20  *
21  */
22 
23 #include <linux/slab.h>
24 #include <linux/time.h>
25 #include <linux/math64.h>
26 #include <linux/export.h>
27 #include <sound/core.h>
28 #include <sound/control.h>
29 #include <sound/tlv.h>
30 #include <sound/info.h>
31 #include <sound/pcm.h>
32 #include <sound/pcm_params.h>
33 #include <sound/timer.h>
34 
35 /*
36  * fill ring buffer with silence
37  * runtime->silence_start: starting pointer to silence area
38  * runtime->silence_filled: size filled with silence
39  * runtime->silence_threshold: threshold from application
40  * runtime->silence_size: maximal size from application
41  *
42  * when runtime->silence_size >= runtime->boundary - fill processed area with silence immediately
43  */
44 void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_uframes_t new_hw_ptr)
45 {
46  struct snd_pcm_runtime *runtime = substream->runtime;
47  snd_pcm_uframes_t frames, ofs, transfer;
48 
49  if (runtime->silence_size < runtime->boundary) {
50  snd_pcm_sframes_t noise_dist, n;
51  if (runtime->silence_start != runtime->control->appl_ptr) {
52  n = runtime->control->appl_ptr - runtime->silence_start;
53  if (n < 0)
54  n += runtime->boundary;
55  if ((snd_pcm_uframes_t)n < runtime->silence_filled)
56  runtime->silence_filled -= n;
57  else
58  runtime->silence_filled = 0;
59  runtime->silence_start = runtime->control->appl_ptr;
60  }
61  if (runtime->silence_filled >= runtime->buffer_size)
62  return;
63  noise_dist = snd_pcm_playback_hw_avail(runtime) + runtime->silence_filled;
64  if (noise_dist >= (snd_pcm_sframes_t) runtime->silence_threshold)
65  return;
66  frames = runtime->silence_threshold - noise_dist;
67  if (frames > runtime->silence_size)
68  frames = runtime->silence_size;
69  } else {
70  if (new_hw_ptr == ULONG_MAX) { /* initialization */
71  snd_pcm_sframes_t avail = snd_pcm_playback_hw_avail(runtime);
72  if (avail > runtime->buffer_size)
73  avail = runtime->buffer_size;
74  runtime->silence_filled = avail > 0 ? avail : 0;
75  runtime->silence_start = (runtime->status->hw_ptr +
76  runtime->silence_filled) %
77  runtime->boundary;
78  } else {
79  ofs = runtime->status->hw_ptr;
80  frames = new_hw_ptr - ofs;
81  if ((snd_pcm_sframes_t)frames < 0)
82  frames += runtime->boundary;
83  runtime->silence_filled -= frames;
84  if ((snd_pcm_sframes_t)runtime->silence_filled < 0) {
85  runtime->silence_filled = 0;
86  runtime->silence_start = new_hw_ptr;
87  } else {
88  runtime->silence_start = ofs;
89  }
90  }
91  frames = runtime->buffer_size - runtime->silence_filled;
92  }
93  if (snd_BUG_ON(frames > runtime->buffer_size))
94  return;
95  if (frames == 0)
96  return;
97  ofs = runtime->silence_start % runtime->buffer_size;
98  while (frames > 0) {
99  transfer = ofs + frames > runtime->buffer_size ? runtime->buffer_size - ofs : frames;
100  if (runtime->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED ||
101  runtime->access == SNDRV_PCM_ACCESS_MMAP_INTERLEAVED) {
102  if (substream->ops->silence) {
103  int err;
104  err = substream->ops->silence(substream, -1, ofs, transfer);
105  snd_BUG_ON(err < 0);
106  } else {
107  char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, ofs);
108  snd_pcm_format_set_silence(runtime->format, hwbuf, transfer * runtime->channels);
109  }
110  } else {
111  unsigned int c;
112  unsigned int channels = runtime->channels;
113  if (substream->ops->silence) {
114  for (c = 0; c < channels; ++c) {
115  int err;
116  err = substream->ops->silence(substream, c, ofs, transfer);
117  snd_BUG_ON(err < 0);
118  }
119  } else {
120  size_t dma_csize = runtime->dma_bytes / channels;
121  for (c = 0; c < channels; ++c) {
122  char *hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, ofs);
123  snd_pcm_format_set_silence(runtime->format, hwbuf, transfer);
124  }
125  }
126  }
127  runtime->silence_filled += transfer;
128  frames -= transfer;
129  ofs = 0;
130  }
131 }
132 
133 #ifdef CONFIG_SND_DEBUG
134 void snd_pcm_debug_name(struct snd_pcm_substream *substream,
135  char *name, size_t len)
136 {
137  snprintf(name, len, "pcmC%dD%d%c:%d",
138  substream->pcm->card->number,
139  substream->pcm->device,
140  substream->stream ? 'c' : 'p',
141  substream->number);
142 }
143 EXPORT_SYMBOL(snd_pcm_debug_name);
144 #endif
145 
146 #define XRUN_DEBUG_BASIC (1<<0)
147 #define XRUN_DEBUG_STACK (1<<1) /* dump also stack */
148 #define XRUN_DEBUG_JIFFIESCHECK (1<<2) /* do jiffies check */
149 #define XRUN_DEBUG_PERIODUPDATE (1<<3) /* full period update info */
150 #define XRUN_DEBUG_HWPTRUPDATE (1<<4) /* full hwptr update info */
151 #define XRUN_DEBUG_LOG (1<<5) /* show last 10 positions on err */
152 #define XRUN_DEBUG_LOGONCE (1<<6) /* do above only once */
153 
154 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
155 
156 #define xrun_debug(substream, mask) \
157  ((substream)->pstr->xrun_debug & (mask))
158 #else
159 #define xrun_debug(substream, mask) 0
160 #endif
161 
162 #define dump_stack_on_xrun(substream) do { \
163  if (xrun_debug(substream, XRUN_DEBUG_STACK)) \
164  dump_stack(); \
165  } while (0)
166 
167 static void xrun(struct snd_pcm_substream *substream)
168 {
169  struct snd_pcm_runtime *runtime = substream->runtime;
170 
171  if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
172  snd_pcm_gettime(runtime, (struct timespec *)&runtime->status->tstamp);
173  snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
174  if (xrun_debug(substream, XRUN_DEBUG_BASIC)) {
175  char name[16];
176  snd_pcm_debug_name(substream, name, sizeof(name));
177  snd_printd(KERN_DEBUG "XRUN: %s\n", name);
178  dump_stack_on_xrun(substream);
179  }
180 }
181 
182 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
183 #define hw_ptr_error(substream, fmt, args...) \
184  do { \
185  if (xrun_debug(substream, XRUN_DEBUG_BASIC)) { \
186  xrun_log_show(substream); \
187  if (printk_ratelimit()) { \
188  snd_printd("PCM: " fmt, ##args); \
189  } \
190  dump_stack_on_xrun(substream); \
191  } \
192  } while (0)
193 
194 #define XRUN_LOG_CNT 10
195 
196 struct hwptr_log_entry {
197  unsigned int in_interrupt;
198  unsigned long jiffies;
199  snd_pcm_uframes_t pos;
200  snd_pcm_uframes_t period_size;
201  snd_pcm_uframes_t buffer_size;
202  snd_pcm_uframes_t old_hw_ptr;
203  snd_pcm_uframes_t hw_ptr_base;
204 };
205 
206 struct snd_pcm_hwptr_log {
207  unsigned int idx;
208  unsigned int hit: 1;
209  struct hwptr_log_entry entries[XRUN_LOG_CNT];
210 };
211 
212 static void xrun_log(struct snd_pcm_substream *substream,
213  snd_pcm_uframes_t pos, int in_interrupt)
214 {
215  struct snd_pcm_runtime *runtime = substream->runtime;
216  struct snd_pcm_hwptr_log *log = runtime->hwptr_log;
217  struct hwptr_log_entry *entry;
218 
219  if (log == NULL) {
220  log = kzalloc(sizeof(*log), GFP_ATOMIC);
221  if (log == NULL)
222  return;
223  runtime->hwptr_log = log;
224  } else {
225  if (xrun_debug(substream, XRUN_DEBUG_LOGONCE) && log->hit)
226  return;
227  }
228  entry = &log->entries[log->idx];
229  entry->in_interrupt = in_interrupt;
230  entry->jiffies = jiffies;
231  entry->pos = pos;
232  entry->period_size = runtime->period_size;
233  entry->buffer_size = runtime->buffer_size;
234  entry->old_hw_ptr = runtime->status->hw_ptr;
235  entry->hw_ptr_base = runtime->hw_ptr_base;
236  log->idx = (log->idx + 1) % XRUN_LOG_CNT;
237 }
238 
239 static void xrun_log_show(struct snd_pcm_substream *substream)
240 {
241  struct snd_pcm_hwptr_log *log = substream->runtime->hwptr_log;
242  struct hwptr_log_entry *entry;
243  char name[16];
244  unsigned int idx;
245  int cnt;
246 
247  if (log == NULL)
248  return;
249  if (xrun_debug(substream, XRUN_DEBUG_LOGONCE) && log->hit)
250  return;
251  snd_pcm_debug_name(substream, name, sizeof(name));
252  for (cnt = 0, idx = log->idx; cnt < XRUN_LOG_CNT; cnt++) {
253  entry = &log->entries[idx];
254  if (entry->period_size == 0)
255  break;
256  snd_printd("hwptr log: %s: %sj=%lu, pos=%ld/%ld/%ld, "
257  "hwptr=%ld/%ld\n",
258  name, entry->in_interrupt ? "[Q] " : "",
259  entry->jiffies,
260  (unsigned long)entry->pos,
261  (unsigned long)entry->period_size,
262  (unsigned long)entry->buffer_size,
263  (unsigned long)entry->old_hw_ptr,
264  (unsigned long)entry->hw_ptr_base);
265  idx++;
266  idx %= XRUN_LOG_CNT;
267  }
268  log->hit = 1;
269 }
270 
271 #else /* ! CONFIG_SND_PCM_XRUN_DEBUG */
272 
273 #define hw_ptr_error(substream, fmt, args...) do { } while (0)
274 #define xrun_log(substream, pos, in_interrupt) do { } while (0)
275 #define xrun_log_show(substream) do { } while (0)
276 
277 #endif
278 
279 int snd_pcm_update_state(struct snd_pcm_substream *substream,
280  struct snd_pcm_runtime *runtime)
281 {
282  snd_pcm_uframes_t avail;
283 
284  if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
285  avail = snd_pcm_playback_avail(runtime);
286  else
287  avail = snd_pcm_capture_avail(runtime);
288  if (avail > runtime->avail_max)
289  runtime->avail_max = avail;
290  if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
291  if (avail >= runtime->buffer_size) {
292  snd_pcm_drain_done(substream);
293  return -EPIPE;
294  }
295  } else {
296  if (avail >= runtime->stop_threshold) {
297  xrun(substream);
298  return -EPIPE;
299  }
300  }
301  if (runtime->twake) {
302  if (avail >= runtime->twake)
303  wake_up(&runtime->tsleep);
304  } else if (avail >= runtime->control->avail_min)
305  wake_up(&runtime->sleep);
306  return 0;
307 }
308 
309 static int snd_pcm_update_hw_ptr0(struct snd_pcm_substream *substream,
310  unsigned int in_interrupt)
311 {
312  struct snd_pcm_runtime *runtime = substream->runtime;
313  snd_pcm_uframes_t pos;
314  snd_pcm_uframes_t old_hw_ptr, new_hw_ptr, hw_base;
315  snd_pcm_sframes_t hdelta, delta;
316  unsigned long jdelta;
317  unsigned long curr_jiffies;
318  struct timespec curr_tstamp;
319 
320  old_hw_ptr = runtime->status->hw_ptr;
321 
322  /*
323  * group pointer, time and jiffies reads to allow for more
324  * accurate correlations/corrections.
325  * The values are stored at the end of this routine after
326  * corrections for hw_ptr position
327  */
328  pos = substream->ops->pointer(substream);
329  curr_jiffies = jiffies;
330  if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
331  snd_pcm_gettime(runtime, (struct timespec *)&curr_tstamp);
332 
333  if (pos == SNDRV_PCM_POS_XRUN) {
334  xrun(substream);
335  return -EPIPE;
336  }
337  if (pos >= runtime->buffer_size) {
338  if (printk_ratelimit()) {
339  char name[16];
340  snd_pcm_debug_name(substream, name, sizeof(name));
341  xrun_log_show(substream);
342  snd_printd(KERN_ERR "BUG: %s, pos = %ld, "
343  "buffer size = %ld, period size = %ld\n",
344  name, pos, runtime->buffer_size,
345  runtime->period_size);
346  }
347  pos = 0;
348  }
349  pos -= pos % runtime->min_align;
350  if (xrun_debug(substream, XRUN_DEBUG_LOG))
351  xrun_log(substream, pos, in_interrupt);
352  hw_base = runtime->hw_ptr_base;
353  new_hw_ptr = hw_base + pos;
354  if (in_interrupt) {
355  /* we know that one period was processed */
356  /* delta = "expected next hw_ptr" for in_interrupt != 0 */
357  delta = runtime->hw_ptr_interrupt + runtime->period_size;
358  if (delta > new_hw_ptr) {
359  /* check for double acknowledged interrupts */
360  hdelta = curr_jiffies - runtime->hw_ptr_jiffies;
361  if (hdelta > runtime->hw_ptr_buffer_jiffies/2) {
362  hw_base += runtime->buffer_size;
363  if (hw_base >= runtime->boundary)
364  hw_base = 0;
365  new_hw_ptr = hw_base + pos;
366  goto __delta;
367  }
368  }
369  }
370  /* new_hw_ptr might be lower than old_hw_ptr in case when */
371  /* pointer crosses the end of the ring buffer */
372  if (new_hw_ptr < old_hw_ptr) {
373  hw_base += runtime->buffer_size;
374  if (hw_base >= runtime->boundary)
375  hw_base = 0;
376  new_hw_ptr = hw_base + pos;
377  }
378  __delta:
379  delta = new_hw_ptr - old_hw_ptr;
380  if (delta < 0)
381  delta += runtime->boundary;
382  if (xrun_debug(substream, in_interrupt ?
383  XRUN_DEBUG_PERIODUPDATE : XRUN_DEBUG_HWPTRUPDATE)) {
384  char name[16];
385  snd_pcm_debug_name(substream, name, sizeof(name));
386  snd_printd("%s_update: %s: pos=%u/%u/%u, "
387  "hwptr=%ld/%ld/%ld/%ld\n",
388  in_interrupt ? "period" : "hwptr",
389  name,
390  (unsigned int)pos,
391  (unsigned int)runtime->period_size,
392  (unsigned int)runtime->buffer_size,
393  (unsigned long)delta,
394  (unsigned long)old_hw_ptr,
395  (unsigned long)new_hw_ptr,
396  (unsigned long)runtime->hw_ptr_base);
397  }
398 
399  if (runtime->no_period_wakeup) {
400  snd_pcm_sframes_t xrun_threshold;
401  /*
402  * Without regular period interrupts, we have to check
403  * the elapsed time to detect xruns.
404  */
405  jdelta = curr_jiffies - runtime->hw_ptr_jiffies;
406  if (jdelta < runtime->hw_ptr_buffer_jiffies / 2)
407  goto no_delta_check;
408  hdelta = jdelta - delta * HZ / runtime->rate;
409  xrun_threshold = runtime->hw_ptr_buffer_jiffies / 2 + 1;
410  while (hdelta > xrun_threshold) {
411  delta += runtime->buffer_size;
412  hw_base += runtime->buffer_size;
413  if (hw_base >= runtime->boundary)
414  hw_base = 0;
415  new_hw_ptr = hw_base + pos;
416  hdelta -= runtime->hw_ptr_buffer_jiffies;
417  }
418  goto no_delta_check;
419  }
420 
421  /* something must be really wrong */
422  if (delta >= runtime->buffer_size + runtime->period_size) {
423  hw_ptr_error(substream,
424  "Unexpected hw_pointer value %s"
425  "(stream=%i, pos=%ld, new_hw_ptr=%ld, "
426  "old_hw_ptr=%ld)\n",
427  in_interrupt ? "[Q] " : "[P]",
428  substream->stream, (long)pos,
429  (long)new_hw_ptr, (long)old_hw_ptr);
430  return 0;
431  }
432 
433  /* Do jiffies check only in xrun_debug mode */
434  if (!xrun_debug(substream, XRUN_DEBUG_JIFFIESCHECK))
435  goto no_jiffies_check;
436 
437  /* Skip the jiffies check for hardwares with BATCH flag.
438  * Such hardware usually just increases the position at each IRQ,
439  * thus it can't give any strange position.
440  */
441  if (runtime->hw.info & SNDRV_PCM_INFO_BATCH)
442  goto no_jiffies_check;
443  hdelta = delta;
444  if (hdelta < runtime->delay)
445  goto no_jiffies_check;
446  hdelta -= runtime->delay;
447  jdelta = curr_jiffies - runtime->hw_ptr_jiffies;
448  if (((hdelta * HZ) / runtime->rate) > jdelta + HZ/100) {
449  delta = jdelta /
450  (((runtime->period_size * HZ) / runtime->rate)
451  + HZ/100);
452  /* move new_hw_ptr according jiffies not pos variable */
453  new_hw_ptr = old_hw_ptr;
454  hw_base = delta;
455  /* use loop to avoid checks for delta overflows */
456  /* the delta value is small or zero in most cases */
457  while (delta > 0) {
458  new_hw_ptr += runtime->period_size;
459  if (new_hw_ptr >= runtime->boundary)
460  new_hw_ptr -= runtime->boundary;
461  delta--;
462  }
463  /* align hw_base to buffer_size */
464  hw_ptr_error(substream,
465  "hw_ptr skipping! %s"
466  "(pos=%ld, delta=%ld, period=%ld, "
467  "jdelta=%lu/%lu/%lu, hw_ptr=%ld/%ld)\n",
468  in_interrupt ? "[Q] " : "",
469  (long)pos, (long)hdelta,
470  (long)runtime->period_size, jdelta,
471  ((hdelta * HZ) / runtime->rate), hw_base,
472  (unsigned long)old_hw_ptr,
473  (unsigned long)new_hw_ptr);
474  /* reset values to proper state */
475  delta = 0;
476  hw_base = new_hw_ptr - (new_hw_ptr % runtime->buffer_size);
477  }
478  no_jiffies_check:
479  if (delta > runtime->period_size + runtime->period_size / 2) {
480  hw_ptr_error(substream,
481  "Lost interrupts? %s"
482  "(stream=%i, delta=%ld, new_hw_ptr=%ld, "
483  "old_hw_ptr=%ld)\n",
484  in_interrupt ? "[Q] " : "",
485  substream->stream, (long)delta,
486  (long)new_hw_ptr,
487  (long)old_hw_ptr);
488  }
489 
490  no_delta_check:
491  if (runtime->status->hw_ptr == new_hw_ptr)
492  return 0;
493 
494  if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
495  runtime->silence_size > 0)
496  snd_pcm_playback_silence(substream, new_hw_ptr);
497 
498  if (in_interrupt) {
499  delta = new_hw_ptr - runtime->hw_ptr_interrupt;
500  if (delta < 0)
501  delta += runtime->boundary;
502  delta -= (snd_pcm_uframes_t)delta % runtime->period_size;
503  runtime->hw_ptr_interrupt += delta;
504  if (runtime->hw_ptr_interrupt >= runtime->boundary)
505  runtime->hw_ptr_interrupt -= runtime->boundary;
506  }
507  runtime->hw_ptr_base = hw_base;
508  runtime->status->hw_ptr = new_hw_ptr;
509  runtime->hw_ptr_jiffies = curr_jiffies;
510  if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
511  runtime->status->tstamp = curr_tstamp;
512 
513  return snd_pcm_update_state(substream, runtime);
514 }
515 
516 /* CAUTION: call it with irq disabled */
517 int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream)
518 {
519  return snd_pcm_update_hw_ptr0(substream, 0);
520 }
521 
530 void snd_pcm_set_ops(struct snd_pcm *pcm, int direction, struct snd_pcm_ops *ops)
531 {
532  struct snd_pcm_str *stream = &pcm->streams[direction];
533  struct snd_pcm_substream *substream;
534 
535  for (substream = stream->substream; substream != NULL; substream = substream->next)
536  substream->ops = ops;
537 }
538 
539 EXPORT_SYMBOL(snd_pcm_set_ops);
540 
547 void snd_pcm_set_sync(struct snd_pcm_substream *substream)
548 {
549  struct snd_pcm_runtime *runtime = substream->runtime;
550 
551  runtime->sync.id32[0] = substream->pcm->card->number;
552  runtime->sync.id32[1] = -1;
553  runtime->sync.id32[2] = -1;
554  runtime->sync.id32[3] = -1;
555 }
556 
557 EXPORT_SYMBOL(snd_pcm_set_sync);
558 
559 /*
560  * Standard ioctl routine
561  */
562 
563 static inline unsigned int div32(unsigned int a, unsigned int b,
564  unsigned int *r)
565 {
566  if (b == 0) {
567  *r = 0;
568  return UINT_MAX;
569  }
570  *r = a % b;
571  return a / b;
572 }
573 
574 static inline unsigned int div_down(unsigned int a, unsigned int b)
575 {
576  if (b == 0)
577  return UINT_MAX;
578  return a / b;
579 }
580 
581 static inline unsigned int div_up(unsigned int a, unsigned int b)
582 {
583  unsigned int r;
584  unsigned int q;
585  if (b == 0)
586  return UINT_MAX;
587  q = div32(a, b, &r);
588  if (r)
589  ++q;
590  return q;
591 }
592 
593 static inline unsigned int mul(unsigned int a, unsigned int b)
594 {
595  if (a == 0)
596  return 0;
597  if (div_down(UINT_MAX, a) < b)
598  return UINT_MAX;
599  return a * b;
600 }
601 
602 static inline unsigned int muldiv32(unsigned int a, unsigned int b,
603  unsigned int c, unsigned int *r)
604 {
605  u_int64_t n = (u_int64_t) a * b;
606  if (c == 0) {
607  snd_BUG_ON(!n);
608  *r = 0;
609  return UINT_MAX;
610  }
611  n = div_u64_rem(n, c, r);
612  if (n >= UINT_MAX) {
613  *r = 0;
614  return UINT_MAX;
615  }
616  return n;
617 }
618 
630 int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v)
631 {
632  int changed = 0;
633  if (snd_BUG_ON(snd_interval_empty(i)))
634  return -EINVAL;
635  if (i->min < v->min) {
636  i->min = v->min;
637  i->openmin = v->openmin;
638  changed = 1;
639  } else if (i->min == v->min && !i->openmin && v->openmin) {
640  i->openmin = 1;
641  changed = 1;
642  }
643  if (i->max > v->max) {
644  i->max = v->max;
645  i->openmax = v->openmax;
646  changed = 1;
647  } else if (i->max == v->max && !i->openmax && v->openmax) {
648  i->openmax = 1;
649  changed = 1;
650  }
651  if (!i->integer && v->integer) {
652  i->integer = 1;
653  changed = 1;
654  }
655  if (i->integer) {
656  if (i->openmin) {
657  i->min++;
658  i->openmin = 0;
659  }
660  if (i->openmax) {
661  i->max--;
662  i->openmax = 0;
663  }
664  } else if (!i->openmin && !i->openmax && i->min == i->max)
665  i->integer = 1;
666  if (snd_interval_checkempty(i)) {
667  snd_interval_none(i);
668  return -EINVAL;
669  }
670  return changed;
671 }
672 
673 EXPORT_SYMBOL(snd_interval_refine);
674 
675 static int snd_interval_refine_first(struct snd_interval *i)
676 {
677  if (snd_BUG_ON(snd_interval_empty(i)))
678  return -EINVAL;
679  if (snd_interval_single(i))
680  return 0;
681  i->max = i->min;
682  i->openmax = i->openmin;
683  if (i->openmax)
684  i->max++;
685  return 1;
686 }
687 
688 static int snd_interval_refine_last(struct snd_interval *i)
689 {
690  if (snd_BUG_ON(snd_interval_empty(i)))
691  return -EINVAL;
692  if (snd_interval_single(i))
693  return 0;
694  i->min = i->max;
695  i->openmin = i->openmax;
696  if (i->openmin)
697  i->min--;
698  return 1;
699 }
700 
701 void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c)
702 {
703  if (a->empty || b->empty) {
704  snd_interval_none(c);
705  return;
706  }
707  c->empty = 0;
708  c->min = mul(a->min, b->min);
709  c->openmin = (a->openmin || b->openmin);
710  c->max = mul(a->max, b->max);
711  c->openmax = (a->openmax || b->openmax);
712  c->integer = (a->integer && b->integer);
713 }
714 
725 void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c)
726 {
727  unsigned int r;
728  if (a->empty || b->empty) {
729  snd_interval_none(c);
730  return;
731  }
732  c->empty = 0;
733  c->min = div32(a->min, b->max, &r);
734  c->openmin = (r || a->openmin || b->openmax);
735  if (b->min > 0) {
736  c->max = div32(a->max, b->min, &r);
737  if (r) {
738  c->max++;
739  c->openmax = 1;
740  } else
741  c->openmax = (a->openmax || b->openmin);
742  } else {
743  c->max = UINT_MAX;
744  c->openmax = 0;
745  }
746  c->integer = 0;
747 }
748 
760 void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b,
761  unsigned int k, struct snd_interval *c)
762 {
763  unsigned int r;
764  if (a->empty || b->empty) {
765  snd_interval_none(c);
766  return;
767  }
768  c->empty = 0;
769  c->min = muldiv32(a->min, b->min, k, &r);
770  c->openmin = (r || a->openmin || b->openmin);
771  c->max = muldiv32(a->max, b->max, k, &r);
772  if (r) {
773  c->max++;
774  c->openmax = 1;
775  } else
776  c->openmax = (a->openmax || b->openmax);
777  c->integer = 0;
778 }
779 
791 void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k,
792  const struct snd_interval *b, struct snd_interval *c)
793 {
794  unsigned int r;
795  if (a->empty || b->empty) {
796  snd_interval_none(c);
797  return;
798  }
799  c->empty = 0;
800  c->min = muldiv32(a->min, k, b->max, &r);
801  c->openmin = (r || a->openmin || b->openmax);
802  if (b->min > 0) {
803  c->max = muldiv32(a->max, k, b->min, &r);
804  if (r) {
805  c->max++;
806  c->openmax = 1;
807  } else
808  c->openmax = (a->openmax || b->openmin);
809  } else {
810  c->max = UINT_MAX;
811  c->openmax = 0;
812  }
813  c->integer = 0;
814 }
815 
816 /* ---- */
817 
818 
829 int snd_interval_ratnum(struct snd_interval *i,
830  unsigned int rats_count, struct snd_ratnum *rats,
831  unsigned int *nump, unsigned int *denp)
832 {
833  unsigned int best_num, best_den;
834  int best_diff;
835  unsigned int k;
836  struct snd_interval t;
837  int err;
838  unsigned int result_num, result_den;
839  int result_diff;
840 
841  best_num = best_den = best_diff = 0;
842  for (k = 0; k < rats_count; ++k) {
843  unsigned int num = rats[k].num;
844  unsigned int den;
845  unsigned int q = i->min;
846  int diff;
847  if (q == 0)
848  q = 1;
849  den = div_up(num, q);
850  if (den < rats[k].den_min)
851  continue;
852  if (den > rats[k].den_max)
853  den = rats[k].den_max;
854  else {
855  unsigned int r;
856  r = (den - rats[k].den_min) % rats[k].den_step;
857  if (r != 0)
858  den -= r;
859  }
860  diff = num - q * den;
861  if (diff < 0)
862  diff = -diff;
863  if (best_num == 0 ||
864  diff * best_den < best_diff * den) {
865  best_diff = diff;
866  best_den = den;
867  best_num = num;
868  }
869  }
870  if (best_den == 0) {
871  i->empty = 1;
872  return -EINVAL;
873  }
874  t.min = div_down(best_num, best_den);
875  t.openmin = !!(best_num % best_den);
876 
877  result_num = best_num;
878  result_diff = best_diff;
879  result_den = best_den;
880  best_num = best_den = best_diff = 0;
881  for (k = 0; k < rats_count; ++k) {
882  unsigned int num = rats[k].num;
883  unsigned int den;
884  unsigned int q = i->max;
885  int diff;
886  if (q == 0) {
887  i->empty = 1;
888  return -EINVAL;
889  }
890  den = div_down(num, q);
891  if (den > rats[k].den_max)
892  continue;
893  if (den < rats[k].den_min)
894  den = rats[k].den_min;
895  else {
896  unsigned int r;
897  r = (den - rats[k].den_min) % rats[k].den_step;
898  if (r != 0)
899  den += rats[k].den_step - r;
900  }
901  diff = q * den - num;
902  if (diff < 0)
903  diff = -diff;
904  if (best_num == 0 ||
905  diff * best_den < best_diff * den) {
906  best_diff = diff;
907  best_den = den;
908  best_num = num;
909  }
910  }
911  if (best_den == 0) {
912  i->empty = 1;
913  return -EINVAL;
914  }
915  t.max = div_up(best_num, best_den);
916  t.openmax = !!(best_num % best_den);
917  t.integer = 0;
918  err = snd_interval_refine(i, &t);
919  if (err < 0)
920  return err;
921 
922  if (snd_interval_single(i)) {
923  if (best_diff * result_den < result_diff * best_den) {
924  result_num = best_num;
925  result_den = best_den;
926  }
927  if (nump)
928  *nump = result_num;
929  if (denp)
930  *denp = result_den;
931  }
932  return err;
933 }
934 
935 EXPORT_SYMBOL(snd_interval_ratnum);
936 
947 static int snd_interval_ratden(struct snd_interval *i,
948  unsigned int rats_count, struct snd_ratden *rats,
949  unsigned int *nump, unsigned int *denp)
950 {
951  unsigned int best_num, best_diff, best_den;
952  unsigned int k;
953  struct snd_interval t;
954  int err;
955 
956  best_num = best_den = best_diff = 0;
957  for (k = 0; k < rats_count; ++k) {
958  unsigned int num;
959  unsigned int den = rats[k].den;
960  unsigned int q = i->min;
961  int diff;
962  num = mul(q, den);
963  if (num > rats[k].num_max)
964  continue;
965  if (num < rats[k].num_min)
966  num = rats[k].num_max;
967  else {
968  unsigned int r;
969  r = (num - rats[k].num_min) % rats[k].num_step;
970  if (r != 0)
971  num += rats[k].num_step - r;
972  }
973  diff = num - q * den;
974  if (best_num == 0 ||
975  diff * best_den < best_diff * den) {
976  best_diff = diff;
977  best_den = den;
978  best_num = num;
979  }
980  }
981  if (best_den == 0) {
982  i->empty = 1;
983  return -EINVAL;
984  }
985  t.min = div_down(best_num, best_den);
986  t.openmin = !!(best_num % best_den);
987 
988  best_num = best_den = best_diff = 0;
989  for (k = 0; k < rats_count; ++k) {
990  unsigned int num;
991  unsigned int den = rats[k].den;
992  unsigned int q = i->max;
993  int diff;
994  num = mul(q, den);
995  if (num < rats[k].num_min)
996  continue;
997  if (num > rats[k].num_max)
998  num = rats[k].num_max;
999  else {
1000  unsigned int r;
1001  r = (num - rats[k].num_min) % rats[k].num_step;
1002  if (r != 0)
1003  num -= r;
1004  }
1005  diff = q * den - num;
1006  if (best_num == 0 ||
1007  diff * best_den < best_diff * den) {
1008  best_diff = diff;
1009  best_den = den;
1010  best_num = num;
1011  }
1012  }
1013  if (best_den == 0) {
1014  i->empty = 1;
1015  return -EINVAL;
1016  }
1017  t.max = div_up(best_num, best_den);
1018  t.openmax = !!(best_num % best_den);
1019  t.integer = 0;
1020  err = snd_interval_refine(i, &t);
1021  if (err < 0)
1022  return err;
1023 
1024  if (snd_interval_single(i)) {
1025  if (nump)
1026  *nump = best_num;
1027  if (denp)
1028  *denp = best_den;
1029  }
1030  return err;
1031 }
1032 
1046 int snd_interval_list(struct snd_interval *i, unsigned int count,
1047  const unsigned int *list, unsigned int mask)
1048 {
1049  unsigned int k;
1050  struct snd_interval list_range;
1051 
1052  if (!count) {
1053  i->empty = 1;
1054  return -EINVAL;
1055  }
1056  snd_interval_any(&list_range);
1057  list_range.min = UINT_MAX;
1058  list_range.max = 0;
1059  for (k = 0; k < count; k++) {
1060  if (mask && !(mask & (1 << k)))
1061  continue;
1062  if (!snd_interval_test(i, list[k]))
1063  continue;
1064  list_range.min = min(list_range.min, list[k]);
1065  list_range.max = max(list_range.max, list[k]);
1066  }
1067  return snd_interval_refine(i, &list_range);
1068 }
1069 
1070 EXPORT_SYMBOL(snd_interval_list);
1071 
1072 static int snd_interval_step(struct snd_interval *i, unsigned int min, unsigned int step)
1073 {
1074  unsigned int n;
1075  int changed = 0;
1076  n = (i->min - min) % step;
1077  if (n != 0 || i->openmin) {
1078  i->min += step - n;
1079  changed = 1;
1080  }
1081  n = (i->max - min) % step;
1082  if (n != 0 || i->openmax) {
1083  i->max -= n;
1084  changed = 1;
1085  }
1086  if (snd_interval_checkempty(i)) {
1087  i->empty = 1;
1088  return -EINVAL;
1089  }
1090  return changed;
1091 }
1092 
1093 /* Info constraints helpers */
1094 
1106 int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, unsigned int cond,
1107  int var,
1108  snd_pcm_hw_rule_func_t func, void *private,
1109  int dep, ...)
1110 {
1111  struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1112  struct snd_pcm_hw_rule *c;
1113  unsigned int k;
1114  va_list args;
1115  va_start(args, dep);
1116  if (constrs->rules_num >= constrs->rules_all) {
1117  struct snd_pcm_hw_rule *new;
1118  unsigned int new_rules = constrs->rules_all + 16;
1119  new = kcalloc(new_rules, sizeof(*c), GFP_KERNEL);
1120  if (!new) {
1121  va_end(args);
1122  return -ENOMEM;
1123  }
1124  if (constrs->rules) {
1125  memcpy(new, constrs->rules,
1126  constrs->rules_num * sizeof(*c));
1127  kfree(constrs->rules);
1128  }
1129  constrs->rules = new;
1130  constrs->rules_all = new_rules;
1131  }
1132  c = &constrs->rules[constrs->rules_num];
1133  c->cond = cond;
1134  c->func = func;
1135  c->var = var;
1136  c->private = private;
1137  k = 0;
1138  while (1) {
1139  if (snd_BUG_ON(k >= ARRAY_SIZE(c->deps))) {
1140  va_end(args);
1141  return -EINVAL;
1142  }
1143  c->deps[k++] = dep;
1144  if (dep < 0)
1145  break;
1146  dep = va_arg(args, int);
1147  }
1148  constrs->rules_num++;
1149  va_end(args);
1150  return 0;
1151 }
1152 
1153 EXPORT_SYMBOL(snd_pcm_hw_rule_add);
1154 
1163 int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
1164  u_int32_t mask)
1165 {
1166  struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1167  struct snd_mask *maskp = constrs_mask(constrs, var);
1168  *maskp->bits &= mask;
1169  memset(maskp->bits + 1, 0, (SNDRV_MASK_MAX-32) / 8); /* clear rest */
1170  if (*maskp->bits == 0)
1171  return -EINVAL;
1172  return 0;
1173 }
1174 
1183 int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
1184  u_int64_t mask)
1185 {
1186  struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1187  struct snd_mask *maskp = constrs_mask(constrs, var);
1188  maskp->bits[0] &= (u_int32_t)mask;
1189  maskp->bits[1] &= (u_int32_t)(mask >> 32);
1190  memset(maskp->bits + 2, 0, (SNDRV_MASK_MAX-64) / 8); /* clear rest */
1191  if (! maskp->bits[0] && ! maskp->bits[1])
1192  return -EINVAL;
1193  return 0;
1194 }
1195 
1203 int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var)
1204 {
1205  struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1206  return snd_interval_setinteger(constrs_interval(constrs, var));
1207 }
1208 
1209 EXPORT_SYMBOL(snd_pcm_hw_constraint_integer);
1210 
1220 int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
1221  unsigned int min, unsigned int max)
1222 {
1223  struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1224  struct snd_interval t;
1225  t.min = min;
1226  t.max = max;
1227  t.openmin = t.openmax = 0;
1228  t.integer = 0;
1229  return snd_interval_refine(constrs_interval(constrs, var), &t);
1230 }
1231 
1232 EXPORT_SYMBOL(snd_pcm_hw_constraint_minmax);
1233 
1234 static int snd_pcm_hw_rule_list(struct snd_pcm_hw_params *params,
1235  struct snd_pcm_hw_rule *rule)
1236 {
1237  struct snd_pcm_hw_constraint_list *list = rule->private;
1238  return snd_interval_list(hw_param_interval(params, rule->var), list->count, list->list, list->mask);
1239 }
1240 
1241 
1251 int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime,
1252  unsigned int cond,
1253  snd_pcm_hw_param_t var,
1254  const struct snd_pcm_hw_constraint_list *l)
1255 {
1256  return snd_pcm_hw_rule_add(runtime, cond, var,
1257  snd_pcm_hw_rule_list, (void *)l,
1258  var, -1);
1259 }
1260 
1261 EXPORT_SYMBOL(snd_pcm_hw_constraint_list);
1262 
1263 static int snd_pcm_hw_rule_ratnums(struct snd_pcm_hw_params *params,
1264  struct snd_pcm_hw_rule *rule)
1265 {
1266  struct snd_pcm_hw_constraint_ratnums *r = rule->private;
1267  unsigned int num = 0, den = 0;
1268  int err;
1269  err = snd_interval_ratnum(hw_param_interval(params, rule->var),
1270  r->nrats, r->rats, &num, &den);
1271  if (err >= 0 && den && rule->var == SNDRV_PCM_HW_PARAM_RATE) {
1272  params->rate_num = num;
1273  params->rate_den = den;
1274  }
1275  return err;
1276 }
1277 
1285 int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime,
1286  unsigned int cond,
1287  snd_pcm_hw_param_t var,
1288  struct snd_pcm_hw_constraint_ratnums *r)
1289 {
1290  return snd_pcm_hw_rule_add(runtime, cond, var,
1291  snd_pcm_hw_rule_ratnums, r,
1292  var, -1);
1293 }
1294 
1295 EXPORT_SYMBOL(snd_pcm_hw_constraint_ratnums);
1296 
1297 static int snd_pcm_hw_rule_ratdens(struct snd_pcm_hw_params *params,
1298  struct snd_pcm_hw_rule *rule)
1299 {
1300  struct snd_pcm_hw_constraint_ratdens *r = rule->private;
1301  unsigned int num = 0, den = 0;
1302  int err = snd_interval_ratden(hw_param_interval(params, rule->var),
1303  r->nrats, r->rats, &num, &den);
1304  if (err >= 0 && den && rule->var == SNDRV_PCM_HW_PARAM_RATE) {
1305  params->rate_num = num;
1306  params->rate_den = den;
1307  }
1308  return err;
1309 }
1310 
1318 int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime,
1319  unsigned int cond,
1320  snd_pcm_hw_param_t var,
1321  struct snd_pcm_hw_constraint_ratdens *r)
1322 {
1323  return snd_pcm_hw_rule_add(runtime, cond, var,
1324  snd_pcm_hw_rule_ratdens, r,
1325  var, -1);
1326 }
1327 
1328 EXPORT_SYMBOL(snd_pcm_hw_constraint_ratdens);
1329 
1330 static int snd_pcm_hw_rule_msbits(struct snd_pcm_hw_params *params,
1331  struct snd_pcm_hw_rule *rule)
1332 {
1333  unsigned int l = (unsigned long) rule->private;
1334  int width = l & 0xffff;
1335  unsigned int msbits = l >> 16;
1336  struct snd_interval *i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS);
1337  if (snd_interval_single(i) && snd_interval_value(i) == width)
1338  params->msbits = msbits;
1339  return 0;
1340 }
1341 
1349 int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime,
1350  unsigned int cond,
1351  unsigned int width,
1352  unsigned int msbits)
1353 {
1354  unsigned long l = (msbits << 16) | width;
1355  return snd_pcm_hw_rule_add(runtime, cond, -1,
1356  snd_pcm_hw_rule_msbits,
1357  (void*) l,
1358  SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
1359 }
1360 
1361 EXPORT_SYMBOL(snd_pcm_hw_constraint_msbits);
1362 
1363 static int snd_pcm_hw_rule_step(struct snd_pcm_hw_params *params,
1364  struct snd_pcm_hw_rule *rule)
1365 {
1366  unsigned long step = (unsigned long) rule->private;
1367  return snd_interval_step(hw_param_interval(params, rule->var), 0, step);
1368 }
1369 
1377 int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime,
1378  unsigned int cond,
1379  snd_pcm_hw_param_t var,
1380  unsigned long step)
1381 {
1382  return snd_pcm_hw_rule_add(runtime, cond, var,
1383  snd_pcm_hw_rule_step, (void *) step,
1384  var, -1);
1385 }
1386 
1387 EXPORT_SYMBOL(snd_pcm_hw_constraint_step);
1388 
1389 static int snd_pcm_hw_rule_pow2(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule)
1390 {
1391  static unsigned int pow2_sizes[] = {
1392  1<<0, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1<<7,
1393  1<<8, 1<<9, 1<<10, 1<<11, 1<<12, 1<<13, 1<<14, 1<<15,
1394  1<<16, 1<<17, 1<<18, 1<<19, 1<<20, 1<<21, 1<<22, 1<<23,
1395  1<<24, 1<<25, 1<<26, 1<<27, 1<<28, 1<<29, 1<<30
1396  };
1397  return snd_interval_list(hw_param_interval(params, rule->var),
1398  ARRAY_SIZE(pow2_sizes), pow2_sizes, 0);
1399 }
1400 
1407 int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime,
1408  unsigned int cond,
1409  snd_pcm_hw_param_t var)
1410 {
1411  return snd_pcm_hw_rule_add(runtime, cond, var,
1412  snd_pcm_hw_rule_pow2, NULL,
1413  var, -1);
1414 }
1415 
1416 EXPORT_SYMBOL(snd_pcm_hw_constraint_pow2);
1417 
1418 static int snd_pcm_hw_rule_noresample_func(struct snd_pcm_hw_params *params,
1419  struct snd_pcm_hw_rule *rule)
1420 {
1421  unsigned int base_rate = (unsigned int)(uintptr_t)rule->private;
1422  struct snd_interval *rate;
1423 
1424  rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
1425  return snd_interval_list(rate, 1, &base_rate, 0);
1426 }
1427 
1433 int snd_pcm_hw_rule_noresample(struct snd_pcm_runtime *runtime,
1434  unsigned int base_rate)
1435 {
1436  return snd_pcm_hw_rule_add(runtime, SNDRV_PCM_HW_PARAMS_NORESAMPLE,
1437  SNDRV_PCM_HW_PARAM_RATE,
1438  snd_pcm_hw_rule_noresample_func,
1439  (void *)(uintptr_t)base_rate,
1440  SNDRV_PCM_HW_PARAM_RATE, -1);
1441 }
1442 EXPORT_SYMBOL(snd_pcm_hw_rule_noresample);
1443 
1444 static void _snd_pcm_hw_param_any(struct snd_pcm_hw_params *params,
1445  snd_pcm_hw_param_t var)
1446 {
1447  if (hw_is_mask(var)) {
1448  snd_mask_any(hw_param_mask(params, var));
1449  params->cmask |= 1 << var;
1450  params->rmask |= 1 << var;
1451  return;
1452  }
1453  if (hw_is_interval(var)) {
1454  snd_interval_any(hw_param_interval(params, var));
1455  params->cmask |= 1 << var;
1456  params->rmask |= 1 << var;
1457  return;
1458  }
1459  snd_BUG();
1460 }
1461 
1462 void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params)
1463 {
1464  unsigned int k;
1465  memset(params, 0, sizeof(*params));
1466  for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++)
1467  _snd_pcm_hw_param_any(params, k);
1468  for (k = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++)
1469  _snd_pcm_hw_param_any(params, k);
1470  params->info = ~0U;
1471 }
1472 
1473 EXPORT_SYMBOL(_snd_pcm_hw_params_any);
1474 
1484 int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params,
1485  snd_pcm_hw_param_t var, int *dir)
1486 {
1487  if (hw_is_mask(var)) {
1488  const struct snd_mask *mask = hw_param_mask_c(params, var);
1489  if (!snd_mask_single(mask))
1490  return -EINVAL;
1491  if (dir)
1492  *dir = 0;
1493  return snd_mask_value(mask);
1494  }
1495  if (hw_is_interval(var)) {
1496  const struct snd_interval *i = hw_param_interval_c(params, var);
1497  if (!snd_interval_single(i))
1498  return -EINVAL;
1499  if (dir)
1500  *dir = i->openmin;
1501  return snd_interval_value(i);
1502  }
1503  return -EINVAL;
1504 }
1505 
1506 EXPORT_SYMBOL(snd_pcm_hw_param_value);
1507 
1508 void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params,
1509  snd_pcm_hw_param_t var)
1510 {
1511  if (hw_is_mask(var)) {
1512  snd_mask_none(hw_param_mask(params, var));
1513  params->cmask |= 1 << var;
1514  params->rmask |= 1 << var;
1515  } else if (hw_is_interval(var)) {
1516  snd_interval_none(hw_param_interval(params, var));
1517  params->cmask |= 1 << var;
1518  params->rmask |= 1 << var;
1519  } else {
1520  snd_BUG();
1521  }
1522 }
1523 
1524 EXPORT_SYMBOL(_snd_pcm_hw_param_setempty);
1525 
1526 static int _snd_pcm_hw_param_first(struct snd_pcm_hw_params *params,
1527  snd_pcm_hw_param_t var)
1528 {
1529  int changed;
1530  if (hw_is_mask(var))
1531  changed = snd_mask_refine_first(hw_param_mask(params, var));
1532  else if (hw_is_interval(var))
1533  changed = snd_interval_refine_first(hw_param_interval(params, var));
1534  else
1535  return -EINVAL;
1536  if (changed) {
1537  params->cmask |= 1 << var;
1538  params->rmask |= 1 << var;
1539  }
1540  return changed;
1541 }
1542 
1543 
1555 int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm,
1556  struct snd_pcm_hw_params *params,
1557  snd_pcm_hw_param_t var, int *dir)
1558 {
1559  int changed = _snd_pcm_hw_param_first(params, var);
1560  if (changed < 0)
1561  return changed;
1562  if (params->rmask) {
1563  int err = snd_pcm_hw_refine(pcm, params);
1564  if (snd_BUG_ON(err < 0))
1565  return err;
1566  }
1567  return snd_pcm_hw_param_value(params, var, dir);
1568 }
1569 
1570 EXPORT_SYMBOL(snd_pcm_hw_param_first);
1571 
1572 static int _snd_pcm_hw_param_last(struct snd_pcm_hw_params *params,
1573  snd_pcm_hw_param_t var)
1574 {
1575  int changed;
1576  if (hw_is_mask(var))
1577  changed = snd_mask_refine_last(hw_param_mask(params, var));
1578  else if (hw_is_interval(var))
1579  changed = snd_interval_refine_last(hw_param_interval(params, var));
1580  else
1581  return -EINVAL;
1582  if (changed) {
1583  params->cmask |= 1 << var;
1584  params->rmask |= 1 << var;
1585  }
1586  return changed;
1587 }
1588 
1589 
1601 int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm,
1602  struct snd_pcm_hw_params *params,
1603  snd_pcm_hw_param_t var, int *dir)
1604 {
1605  int changed = _snd_pcm_hw_param_last(params, var);
1606  if (changed < 0)
1607  return changed;
1608  if (params->rmask) {
1609  int err = snd_pcm_hw_refine(pcm, params);
1610  if (snd_BUG_ON(err < 0))
1611  return err;
1612  }
1613  return snd_pcm_hw_param_value(params, var, dir);
1614 }
1615 
1616 EXPORT_SYMBOL(snd_pcm_hw_param_last);
1617 
1628 int snd_pcm_hw_params_choose(struct snd_pcm_substream *pcm,
1629  struct snd_pcm_hw_params *params)
1630 {
1631  static int vars[] = {
1632  SNDRV_PCM_HW_PARAM_ACCESS,
1633  SNDRV_PCM_HW_PARAM_FORMAT,
1634  SNDRV_PCM_HW_PARAM_SUBFORMAT,
1635  SNDRV_PCM_HW_PARAM_CHANNELS,
1636  SNDRV_PCM_HW_PARAM_RATE,
1637  SNDRV_PCM_HW_PARAM_PERIOD_TIME,
1638  SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
1639  SNDRV_PCM_HW_PARAM_TICK_TIME,
1640  -1
1641  };
1642  int err, *v;
1643 
1644  for (v = vars; *v != -1; v++) {
1645  if (*v != SNDRV_PCM_HW_PARAM_BUFFER_SIZE)
1646  err = snd_pcm_hw_param_first(pcm, params, *v, NULL);
1647  else
1648  err = snd_pcm_hw_param_last(pcm, params, *v, NULL);
1649  if (snd_BUG_ON(err < 0))
1650  return err;
1651  }
1652  return 0;
1653 }
1654 
1655 static int snd_pcm_lib_ioctl_reset(struct snd_pcm_substream *substream,
1656  void *arg)
1657 {
1658  struct snd_pcm_runtime *runtime = substream->runtime;
1659  unsigned long flags;
1660  snd_pcm_stream_lock_irqsave(substream, flags);
1661  if (snd_pcm_running(substream) &&
1662  snd_pcm_update_hw_ptr(substream) >= 0)
1663  runtime->status->hw_ptr %= runtime->buffer_size;
1664  else
1665  runtime->status->hw_ptr = 0;
1666  snd_pcm_stream_unlock_irqrestore(substream, flags);
1667  return 0;
1668 }
1669 
1670 static int snd_pcm_lib_ioctl_channel_info(struct snd_pcm_substream *substream,
1671  void *arg)
1672 {
1673  struct snd_pcm_channel_info *info = arg;
1674  struct snd_pcm_runtime *runtime = substream->runtime;
1675  int width;
1676  if (!(runtime->info & SNDRV_PCM_INFO_MMAP)) {
1677  info->offset = -1;
1678  return 0;
1679  }
1680  width = snd_pcm_format_physical_width(runtime->format);
1681  if (width < 0)
1682  return width;
1683  info->offset = 0;
1684  switch (runtime->access) {
1685  case SNDRV_PCM_ACCESS_MMAP_INTERLEAVED:
1686  case SNDRV_PCM_ACCESS_RW_INTERLEAVED:
1687  info->first = info->channel * width;
1688  info->step = runtime->channels * width;
1689  break;
1690  case SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED:
1691  case SNDRV_PCM_ACCESS_RW_NONINTERLEAVED:
1692  {
1693  size_t size = runtime->dma_bytes / runtime->channels;
1694  info->first = info->channel * size * 8;
1695  info->step = width;
1696  break;
1697  }
1698  default:
1699  snd_BUG();
1700  break;
1701  }
1702  return 0;
1703 }
1704 
1705 static int snd_pcm_lib_ioctl_fifo_size(struct snd_pcm_substream *substream,
1706  void *arg)
1707 {
1708  struct snd_pcm_hw_params *params = arg;
1709  snd_pcm_format_t format;
1710  int channels, width;
1711 
1712  params->fifo_size = substream->runtime->hw.fifo_size;
1713  if (!(substream->runtime->hw.info & SNDRV_PCM_INFO_FIFO_IN_FRAMES)) {
1714  format = params_format(params);
1715  channels = params_channels(params);
1716  width = snd_pcm_format_physical_width(format);
1717  params->fifo_size /= width * channels;
1718  }
1719  return 0;
1720 }
1721 
1733 int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream,
1734  unsigned int cmd, void *arg)
1735 {
1736  switch (cmd) {
1737  case SNDRV_PCM_IOCTL1_INFO:
1738  return 0;
1739  case SNDRV_PCM_IOCTL1_RESET:
1740  return snd_pcm_lib_ioctl_reset(substream, arg);
1741  case SNDRV_PCM_IOCTL1_CHANNEL_INFO:
1742  return snd_pcm_lib_ioctl_channel_info(substream, arg);
1743  case SNDRV_PCM_IOCTL1_FIFO_SIZE:
1744  return snd_pcm_lib_ioctl_fifo_size(substream, arg);
1745  }
1746  return -ENXIO;
1747 }
1748 
1749 EXPORT_SYMBOL(snd_pcm_lib_ioctl);
1750 
1762 void snd_pcm_period_elapsed(struct snd_pcm_substream *substream)
1763 {
1764  struct snd_pcm_runtime *runtime;
1765  unsigned long flags;
1766 
1767  if (PCM_RUNTIME_CHECK(substream))
1768  return;
1769  runtime = substream->runtime;
1770 
1771  if (runtime->transfer_ack_begin)
1772  runtime->transfer_ack_begin(substream);
1773 
1774  snd_pcm_stream_lock_irqsave(substream, flags);
1775  if (!snd_pcm_running(substream) ||
1776  snd_pcm_update_hw_ptr0(substream, 1) < 0)
1777  goto _end;
1778 
1779  if (substream->timer_running)
1780  snd_timer_interrupt(substream->timer, 1);
1781  _end:
1782  snd_pcm_stream_unlock_irqrestore(substream, flags);
1783  if (runtime->transfer_ack_end)
1784  runtime->transfer_ack_end(substream);
1785  kill_fasync(&runtime->fasync, SIGIO, POLL_IN);
1786 }
1787 
1788 EXPORT_SYMBOL(snd_pcm_period_elapsed);
1789 
1790 /*
1791  * Wait until avail_min data becomes available
1792  * Returns a negative error code if any error occurs during operation.
1793  * The available space is stored on availp. When err = 0 and avail = 0
1794  * on the capture stream, it indicates the stream is in DRAINING state.
1795  */
1796 static int wait_for_avail(struct snd_pcm_substream *substream,
1797  snd_pcm_uframes_t *availp)
1798 {
1799  struct snd_pcm_runtime *runtime = substream->runtime;
1800  int is_playback = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
1801  wait_queue_t wait;
1802  int err = 0;
1803  snd_pcm_uframes_t avail = 0;
1804  long wait_time, tout;
1805 
1806  init_waitqueue_entry(&wait, current);
1807  set_current_state(TASK_INTERRUPTIBLE);
1808  add_wait_queue(&runtime->tsleep, &wait);
1809 
1810  if (runtime->no_period_wakeup)
1811  wait_time = MAX_SCHEDULE_TIMEOUT;
1812  else {
1813  wait_time = 10;
1814  if (runtime->rate) {
1815  long t = runtime->period_size * 2 / runtime->rate;
1816  wait_time = max(t, wait_time);
1817  }
1818  wait_time = msecs_to_jiffies(wait_time * 1000);
1819  }
1820 
1821  for (;;) {
1822  if (signal_pending(current)) {
1823  err = -ERESTARTSYS;
1824  break;
1825  }
1826 
1827  /*
1828  * We need to check if space became available already
1829  * (and thus the wakeup happened already) first to close
1830  * the race of space already having become available.
1831  * This check must happen after been added to the waitqueue
1832  * and having current state be INTERRUPTIBLE.
1833  */
1834  if (is_playback)
1835  avail = snd_pcm_playback_avail(runtime);
1836  else
1837  avail = snd_pcm_capture_avail(runtime);
1838  if (avail >= runtime->twake)
1839  break;
1840  snd_pcm_stream_unlock_irq(substream);
1841 
1842  tout = schedule_timeout(wait_time);
1843 
1844  snd_pcm_stream_lock_irq(substream);
1845  set_current_state(TASK_INTERRUPTIBLE);
1846  switch (runtime->status->state) {
1847  case SNDRV_PCM_STATE_SUSPENDED:
1848  err = -ESTRPIPE;
1849  goto _endloop;
1850  case SNDRV_PCM_STATE_XRUN:
1851  err = -EPIPE;
1852  goto _endloop;
1853  case SNDRV_PCM_STATE_DRAINING:
1854  if (is_playback)
1855  err = -EPIPE;
1856  else
1857  avail = 0; /* indicate draining */
1858  goto _endloop;
1859  case SNDRV_PCM_STATE_OPEN:
1860  case SNDRV_PCM_STATE_SETUP:
1861  case SNDRV_PCM_STATE_DISCONNECTED:
1862  err = -EBADFD;
1863  goto _endloop;
1864  }
1865  if (!tout) {
1866  snd_printd("%s write error (DMA or IRQ trouble?)\n",
1867  is_playback ? "playback" : "capture");
1868  err = -EIO;
1869  break;
1870  }
1871  }
1872  _endloop:
1873  set_current_state(TASK_RUNNING);
1874  remove_wait_queue(&runtime->tsleep, &wait);
1875  *availp = avail;
1876  return err;
1877 }
1878 
1879 static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream,
1880  unsigned int hwoff,
1881  unsigned long data, unsigned int off,
1882  snd_pcm_uframes_t frames)
1883 {
1884  struct snd_pcm_runtime *runtime = substream->runtime;
1885  int err;
1886  char __user *buf = (char __user *) data + frames_to_bytes(runtime, off);
1887  if (substream->ops->copy) {
1888  if ((err = substream->ops->copy(substream, -1, hwoff, buf, frames)) < 0)
1889  return err;
1890  } else {
1891  char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff);
1892  if (copy_from_user(hwbuf, buf, frames_to_bytes(runtime, frames)))
1893  return -EFAULT;
1894  }
1895  return 0;
1896 }
1897 
1898 typedef int (*transfer_f)(struct snd_pcm_substream *substream, unsigned int hwoff,
1899  unsigned long data, unsigned int off,
1900  snd_pcm_uframes_t size);
1901 
1902 static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream,
1903  unsigned long data,
1904  snd_pcm_uframes_t size,
1905  int nonblock,
1906  transfer_f transfer)
1907 {
1908  struct snd_pcm_runtime *runtime = substream->runtime;
1909  snd_pcm_uframes_t xfer = 0;
1910  snd_pcm_uframes_t offset = 0;
1911  snd_pcm_uframes_t avail;
1912  int err = 0;
1913 
1914  if (size == 0)
1915  return 0;
1916 
1917  snd_pcm_stream_lock_irq(substream);
1918  switch (runtime->status->state) {
1919  case SNDRV_PCM_STATE_PREPARED:
1920  case SNDRV_PCM_STATE_RUNNING:
1921  case SNDRV_PCM_STATE_PAUSED:
1922  break;
1923  case SNDRV_PCM_STATE_XRUN:
1924  err = -EPIPE;
1925  goto _end_unlock;
1926  case SNDRV_PCM_STATE_SUSPENDED:
1927  err = -ESTRPIPE;
1928  goto _end_unlock;
1929  default:
1930  err = -EBADFD;
1931  goto _end_unlock;
1932  }
1933 
1934  runtime->twake = runtime->control->avail_min ? : 1;
1935  if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
1936  snd_pcm_update_hw_ptr(substream);
1937  avail = snd_pcm_playback_avail(runtime);
1938  while (size > 0) {
1939  snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
1940  snd_pcm_uframes_t cont;
1941  if (!avail) {
1942  if (nonblock) {
1943  err = -EAGAIN;
1944  goto _end_unlock;
1945  }
1946  runtime->twake = min_t(snd_pcm_uframes_t, size,
1947  runtime->control->avail_min ? : 1);
1948  err = wait_for_avail(substream, &avail);
1949  if (err < 0)
1950  goto _end_unlock;
1951  }
1952  frames = size > avail ? avail : size;
1953  cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;
1954  if (frames > cont)
1955  frames = cont;
1956  if (snd_BUG_ON(!frames)) {
1957  runtime->twake = 0;
1958  snd_pcm_stream_unlock_irq(substream);
1959  return -EINVAL;
1960  }
1961  appl_ptr = runtime->control->appl_ptr;
1962  appl_ofs = appl_ptr % runtime->buffer_size;
1963  snd_pcm_stream_unlock_irq(substream);
1964  err = transfer(substream, appl_ofs, data, offset, frames);
1965  snd_pcm_stream_lock_irq(substream);
1966  if (err < 0)
1967  goto _end_unlock;
1968  switch (runtime->status->state) {
1969  case SNDRV_PCM_STATE_XRUN:
1970  err = -EPIPE;
1971  goto _end_unlock;
1972  case SNDRV_PCM_STATE_SUSPENDED:
1973  err = -ESTRPIPE;
1974  goto _end_unlock;
1975  default:
1976  break;
1977  }
1978  appl_ptr += frames;
1979  if (appl_ptr >= runtime->boundary)
1980  appl_ptr -= runtime->boundary;
1981  runtime->control->appl_ptr = appl_ptr;
1982  if (substream->ops->ack)
1983  substream->ops->ack(substream);
1984 
1985  offset += frames;
1986  size -= frames;
1987  xfer += frames;
1988  avail -= frames;
1989  if (runtime->status->state == SNDRV_PCM_STATE_PREPARED &&
1990  snd_pcm_playback_hw_avail(runtime) >= (snd_pcm_sframes_t)runtime->start_threshold) {
1991  err = snd_pcm_start(substream);
1992  if (err < 0)
1993  goto _end_unlock;
1994  }
1995  }
1996  _end_unlock:
1997  runtime->twake = 0;
1998  if (xfer > 0 && err >= 0)
1999  snd_pcm_update_state(substream, runtime);
2000  snd_pcm_stream_unlock_irq(substream);
2001  return xfer > 0 ? (snd_pcm_sframes_t)xfer : err;
2002 }
2003 
2004 /* sanity-check for read/write methods */
2005 static int pcm_sanity_check(struct snd_pcm_substream *substream)
2006 {
2007  struct snd_pcm_runtime *runtime;
2008  if (PCM_RUNTIME_CHECK(substream))
2009  return -ENXIO;
2010  runtime = substream->runtime;
2011  if (snd_BUG_ON(!substream->ops->copy && !runtime->dma_area))
2012  return -EINVAL;
2013  if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2014  return -EBADFD;
2015  return 0;
2016 }
2017 
2018 snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const void __user *buf, snd_pcm_uframes_t size)
2019 {
2020  struct snd_pcm_runtime *runtime;
2021  int nonblock;
2022  int err;
2023 
2024  err = pcm_sanity_check(substream);
2025  if (err < 0)
2026  return err;
2027  runtime = substream->runtime;
2028  nonblock = !!(substream->f_flags & O_NONBLOCK);
2029 
2030  if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED &&
2031  runtime->channels > 1)
2032  return -EINVAL;
2033  return snd_pcm_lib_write1(substream, (unsigned long)buf, size, nonblock,
2034  snd_pcm_lib_write_transfer);
2035 }
2036 
2037 EXPORT_SYMBOL(snd_pcm_lib_write);
2038 
2039 static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream,
2040  unsigned int hwoff,
2041  unsigned long data, unsigned int off,
2042  snd_pcm_uframes_t frames)
2043 {
2044  struct snd_pcm_runtime *runtime = substream->runtime;
2045  int err;
2046  void __user **bufs = (void __user **)data;
2047  int channels = runtime->channels;
2048  int c;
2049  if (substream->ops->copy) {
2050  if (snd_BUG_ON(!substream->ops->silence))
2051  return -EINVAL;
2052  for (c = 0; c < channels; ++c, ++bufs) {
2053  if (*bufs == NULL) {
2054  if ((err = substream->ops->silence(substream, c, hwoff, frames)) < 0)
2055  return err;
2056  } else {
2057  char __user *buf = *bufs + samples_to_bytes(runtime, off);
2058  if ((err = substream->ops->copy(substream, c, hwoff, buf, frames)) < 0)
2059  return err;
2060  }
2061  }
2062  } else {
2063  /* default transfer behaviour */
2064  size_t dma_csize = runtime->dma_bytes / channels;
2065  for (c = 0; c < channels; ++c, ++bufs) {
2066  char *hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff);
2067  if (*bufs == NULL) {
2068  snd_pcm_format_set_silence(runtime->format, hwbuf, frames);
2069  } else {
2070  char __user *buf = *bufs + samples_to_bytes(runtime, off);
2071  if (copy_from_user(hwbuf, buf, samples_to_bytes(runtime, frames)))
2072  return -EFAULT;
2073  }
2074  }
2075  }
2076  return 0;
2077 }
2078 
2079 snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream,
2080  void __user **bufs,
2081  snd_pcm_uframes_t frames)
2082 {
2083  struct snd_pcm_runtime *runtime;
2084  int nonblock;
2085  int err;
2086 
2087  err = pcm_sanity_check(substream);
2088  if (err < 0)
2089  return err;
2090  runtime = substream->runtime;
2091  nonblock = !!(substream->f_flags & O_NONBLOCK);
2092 
2093  if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
2094  return -EINVAL;
2095  return snd_pcm_lib_write1(substream, (unsigned long)bufs, frames,
2096  nonblock, snd_pcm_lib_writev_transfer);
2097 }
2098 
2099 EXPORT_SYMBOL(snd_pcm_lib_writev);
2100 
2101 static int snd_pcm_lib_read_transfer(struct snd_pcm_substream *substream,
2102  unsigned int hwoff,
2103  unsigned long data, unsigned int off,
2104  snd_pcm_uframes_t frames)
2105 {
2106  struct snd_pcm_runtime *runtime = substream->runtime;
2107  int err;
2108  char __user *buf = (char __user *) data + frames_to_bytes(runtime, off);
2109  if (substream->ops->copy) {
2110  if ((err = substream->ops->copy(substream, -1, hwoff, buf, frames)) < 0)
2111  return err;
2112  } else {
2113  char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff);
2114  if (copy_to_user(buf, hwbuf, frames_to_bytes(runtime, frames)))
2115  return -EFAULT;
2116  }
2117  return 0;
2118 }
2119 
2120 static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,
2121  unsigned long data,
2122  snd_pcm_uframes_t size,
2123  int nonblock,
2124  transfer_f transfer)
2125 {
2126  struct snd_pcm_runtime *runtime = substream->runtime;
2127  snd_pcm_uframes_t xfer = 0;
2128  snd_pcm_uframes_t offset = 0;
2129  snd_pcm_uframes_t avail;
2130  int err = 0;
2131 
2132  if (size == 0)
2133  return 0;
2134 
2135  snd_pcm_stream_lock_irq(substream);
2136  switch (runtime->status->state) {
2137  case SNDRV_PCM_STATE_PREPARED:
2138  if (size >= runtime->start_threshold) {
2139  err = snd_pcm_start(substream);
2140  if (err < 0)
2141  goto _end_unlock;
2142  }
2143  break;
2144  case SNDRV_PCM_STATE_DRAINING:
2145  case SNDRV_PCM_STATE_RUNNING:
2146  case SNDRV_PCM_STATE_PAUSED:
2147  break;
2148  case SNDRV_PCM_STATE_XRUN:
2149  err = -EPIPE;
2150  goto _end_unlock;
2151  case SNDRV_PCM_STATE_SUSPENDED:
2152  err = -ESTRPIPE;
2153  goto _end_unlock;
2154  default:
2155  err = -EBADFD;
2156  goto _end_unlock;
2157  }
2158 
2159  runtime->twake = runtime->control->avail_min ? : 1;
2160  if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
2161  snd_pcm_update_hw_ptr(substream);
2162  avail = snd_pcm_capture_avail(runtime);
2163  while (size > 0) {
2164  snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
2165  snd_pcm_uframes_t cont;
2166  if (!avail) {
2167  if (runtime->status->state ==
2168  SNDRV_PCM_STATE_DRAINING) {
2169  snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
2170  goto _end_unlock;
2171  }
2172  if (nonblock) {
2173  err = -EAGAIN;
2174  goto _end_unlock;
2175  }
2176  runtime->twake = min_t(snd_pcm_uframes_t, size,
2177  runtime->control->avail_min ? : 1);
2178  err = wait_for_avail(substream, &avail);
2179  if (err < 0)
2180  goto _end_unlock;
2181  if (!avail)
2182  continue; /* draining */
2183  }
2184  frames = size > avail ? avail : size;
2185  cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;
2186  if (frames > cont)
2187  frames = cont;
2188  if (snd_BUG_ON(!frames)) {
2189  runtime->twake = 0;
2190  snd_pcm_stream_unlock_irq(substream);
2191  return -EINVAL;
2192  }
2193  appl_ptr = runtime->control->appl_ptr;
2194  appl_ofs = appl_ptr % runtime->buffer_size;
2195  snd_pcm_stream_unlock_irq(substream);
2196  err = transfer(substream, appl_ofs, data, offset, frames);
2197  snd_pcm_stream_lock_irq(substream);
2198  if (err < 0)
2199  goto _end_unlock;
2200  switch (runtime->status->state) {
2201  case SNDRV_PCM_STATE_XRUN:
2202  err = -EPIPE;
2203  goto _end_unlock;
2204  case SNDRV_PCM_STATE_SUSPENDED:
2205  err = -ESTRPIPE;
2206  goto _end_unlock;
2207  default:
2208  break;
2209  }
2210  appl_ptr += frames;
2211  if (appl_ptr >= runtime->boundary)
2212  appl_ptr -= runtime->boundary;
2213  runtime->control->appl_ptr = appl_ptr;
2214  if (substream->ops->ack)
2215  substream->ops->ack(substream);
2216 
2217  offset += frames;
2218  size -= frames;
2219  xfer += frames;
2220  avail -= frames;
2221  }
2222  _end_unlock:
2223  runtime->twake = 0;
2224  if (xfer > 0 && err >= 0)
2225  snd_pcm_update_state(substream, runtime);
2226  snd_pcm_stream_unlock_irq(substream);
2227  return xfer > 0 ? (snd_pcm_sframes_t)xfer : err;
2228 }
2229 
2230 snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, void __user *buf, snd_pcm_uframes_t size)
2231 {
2232  struct snd_pcm_runtime *runtime;
2233  int nonblock;
2234  int err;
2235 
2236  err = pcm_sanity_check(substream);
2237  if (err < 0)
2238  return err;
2239  runtime = substream->runtime;
2240  nonblock = !!(substream->f_flags & O_NONBLOCK);
2241  if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED)
2242  return -EINVAL;
2243  return snd_pcm_lib_read1(substream, (unsigned long)buf, size, nonblock, snd_pcm_lib_read_transfer);
2244 }
2245 
2246 EXPORT_SYMBOL(snd_pcm_lib_read);
2247 
2248 static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream,
2249  unsigned int hwoff,
2250  unsigned long data, unsigned int off,
2251  snd_pcm_uframes_t frames)
2252 {
2253  struct snd_pcm_runtime *runtime = substream->runtime;
2254  int err;
2255  void __user **bufs = (void __user **)data;
2256  int channels = runtime->channels;
2257  int c;
2258  if (substream->ops->copy) {
2259  for (c = 0; c < channels; ++c, ++bufs) {
2260  char __user *buf;
2261  if (*bufs == NULL)
2262  continue;
2263  buf = *bufs + samples_to_bytes(runtime, off);
2264  if ((err = substream->ops->copy(substream, c, hwoff, buf, frames)) < 0)
2265  return err;
2266  }
2267  } else {
2268  snd_pcm_uframes_t dma_csize = runtime->dma_bytes / channels;
2269  for (c = 0; c < channels; ++c, ++bufs) {
2270  char *hwbuf;
2271  char __user *buf;
2272  if (*bufs == NULL)
2273  continue;
2274 
2275  hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff);
2276  buf = *bufs + samples_to_bytes(runtime, off);
2277  if (copy_to_user(buf, hwbuf, samples_to_bytes(runtime, frames)))
2278  return -EFAULT;
2279  }
2280  }
2281  return 0;
2282 }
2283 
2284 snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream,
2285  void __user **bufs,
2286  snd_pcm_uframes_t frames)
2287 {
2288  struct snd_pcm_runtime *runtime;
2289  int nonblock;
2290  int err;
2291 
2292  err = pcm_sanity_check(substream);
2293  if (err < 0)
2294  return err;
2295  runtime = substream->runtime;
2296  if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2297  return -EBADFD;
2298 
2299  nonblock = !!(substream->f_flags & O_NONBLOCK);
2300  if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
2301  return -EINVAL;
2302  return snd_pcm_lib_read1(substream, (unsigned long)bufs, frames, nonblock, snd_pcm_lib_readv_transfer);
2303 }
2304 
2305 EXPORT_SYMBOL(snd_pcm_lib_readv);
2306 
2307 /*
2308  * standard channel mapping helpers
2309  */
2310 
2311 /* default channel maps for multi-channel playbacks, up to 8 channels */
2312 const struct snd_pcm_chmap_elem snd_pcm_std_chmaps[] = {
2313  { .channels = 1,
2314  .map = { SNDRV_CHMAP_MONO } },
2315  { .channels = 2,
2316  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
2317  { .channels = 4,
2318  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
2319  SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
2320  { .channels = 6,
2321  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
2322  SNDRV_CHMAP_RL, SNDRV_CHMAP_RR,
2323  SNDRV_CHMAP_FC, SNDRV_CHMAP_LFE } },
2324  { .channels = 8,
2325  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
2326  SNDRV_CHMAP_RL, SNDRV_CHMAP_RR,
2327  SNDRV_CHMAP_FC, SNDRV_CHMAP_LFE,
2328  SNDRV_CHMAP_SL, SNDRV_CHMAP_SR } },
2329  { }
2330 };
2331 EXPORT_SYMBOL_GPL(snd_pcm_std_chmaps);
2332 
2333 /* alternative channel maps with CLFE <-> surround swapped for 6/8 channels */
2334 const struct snd_pcm_chmap_elem snd_pcm_alt_chmaps[] = {
2335  { .channels = 1,
2336  .map = { SNDRV_CHMAP_MONO } },
2337  { .channels = 2,
2338  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
2339  { .channels = 4,
2340  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
2341  SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
2342  { .channels = 6,
2343  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
2344  SNDRV_CHMAP_FC, SNDRV_CHMAP_LFE,
2345  SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
2346  { .channels = 8,
2347  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
2348  SNDRV_CHMAP_FC, SNDRV_CHMAP_LFE,
2349  SNDRV_CHMAP_RL, SNDRV_CHMAP_RR,
2350  SNDRV_CHMAP_SL, SNDRV_CHMAP_SR } },
2351  { }
2352 };
2353 EXPORT_SYMBOL_GPL(snd_pcm_alt_chmaps);
2354 
2355 static bool valid_chmap_channels(const struct snd_pcm_chmap *info, int ch)
2356 {
2357  if (ch > info->max_channels)
2358  return false;
2359  return !info->channel_mask || (info->channel_mask & (1U << ch));
2360 }
2361 
2362 static int pcm_chmap_ctl_info(struct snd_kcontrol *kcontrol,
2363  struct snd_ctl_elem_info *uinfo)
2364 {
2365  struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
2366 
2367  uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2368  uinfo->count = 0;
2369  uinfo->count = info->max_channels;
2370  uinfo->value.integer.min = 0;
2371  uinfo->value.integer.max = SNDRV_CHMAP_LAST;
2372  return 0;
2373 }
2374 
2375 /* get callback for channel map ctl element
2376  * stores the channel position firstly matching with the current channels
2377  */
2378 static int pcm_chmap_ctl_get(struct snd_kcontrol *kcontrol,
2379  struct snd_ctl_elem_value *ucontrol)
2380 {
2381  struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
2382  unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2383  struct snd_pcm_substream *substream;
2384  const struct snd_pcm_chmap_elem *map;
2385 
2386  if (snd_BUG_ON(!info->chmap))
2387  return -EINVAL;
2388  substream = snd_pcm_chmap_substream(info, idx);
2389  if (!substream)
2390  return -ENODEV;
2391  memset(ucontrol->value.integer.value, 0,
2392  sizeof(ucontrol->value.integer.value));
2393  if (!substream->runtime)
2394  return 0; /* no channels set */
2395  for (map = info->chmap; map->channels; map++) {
2396  int i;
2397  if (map->channels == substream->runtime->channels &&
2398  valid_chmap_channels(info, map->channels)) {
2399  for (i = 0; i < map->channels; i++)
2400  ucontrol->value.integer.value[i] = map->map[i];
2401  return 0;
2402  }
2403  }
2404  return -EINVAL;
2405 }
2406 
2407 /* tlv callback for channel map ctl element
2408  * expands the pre-defined channel maps in a form of TLV
2409  */
2410 static int pcm_chmap_ctl_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2411  unsigned int size, unsigned int __user *tlv)
2412 {
2413  struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
2414  const struct snd_pcm_chmap_elem *map;
2415  unsigned int __user *dst;
2416  int c, count = 0;
2417 
2418  if (snd_BUG_ON(!info->chmap))
2419  return -EINVAL;
2420  if (size < 8)
2421  return -ENOMEM;
2422  if (put_user(SNDRV_CTL_TLVT_CONTAINER, tlv))
2423  return -EFAULT;
2424  size -= 8;
2425  dst = tlv + 2;
2426  for (map = info->chmap; map->channels; map++) {
2427  int chs_bytes = map->channels * 4;
2428  if (!valid_chmap_channels(info, map->channels))
2429  continue;
2430  if (size < 8)
2431  return -ENOMEM;
2432  if (put_user(SNDRV_CTL_TLVT_CHMAP_FIXED, dst) ||
2433  put_user(chs_bytes, dst + 1))
2434  return -EFAULT;
2435  dst += 2;
2436  size -= 8;
2437  count += 8;
2438  if (size < chs_bytes)
2439  return -ENOMEM;
2440  size -= chs_bytes;
2441  count += chs_bytes;
2442  for (c = 0; c < map->channels; c++) {
2443  if (put_user(map->map[c], dst))
2444  return -EFAULT;
2445  dst++;
2446  }
2447  }
2448  if (put_user(count, tlv + 1))
2449  return -EFAULT;
2450  return 0;
2451 }
2452 
2453 static void pcm_chmap_ctl_private_free(struct snd_kcontrol *kcontrol)
2454 {
2455  struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
2456  info->pcm->streams[info->stream].chmap_kctl = NULL;
2457  kfree(info);
2458 }
2459 
2472 int snd_pcm_add_chmap_ctls(struct snd_pcm *pcm, int stream,
2473  const struct snd_pcm_chmap_elem *chmap,
2474  int max_channels,
2475  unsigned long private_value,
2476  struct snd_pcm_chmap **info_ret)
2477 {
2478  struct snd_pcm_chmap *info;
2479  struct snd_kcontrol_new knew = {
2480  .iface = SNDRV_CTL_ELEM_IFACE_PCM,
2481  .access = SNDRV_CTL_ELEM_ACCESS_READ |
2482  SNDRV_CTL_ELEM_ACCESS_TLV_READ |
2483  SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK,
2484  .info = pcm_chmap_ctl_info,
2485  .get = pcm_chmap_ctl_get,
2486  .tlv.c = pcm_chmap_ctl_tlv,
2487  };
2488  int err;
2489 
2490  info = kzalloc(sizeof(*info), GFP_KERNEL);
2491  if (!info)
2492  return -ENOMEM;
2493  info->pcm = pcm;
2494  info->stream = stream;
2495  info->chmap = chmap;
2496  info->max_channels = max_channels;
2497  if (stream == SNDRV_PCM_STREAM_PLAYBACK)
2498  knew.name = "Playback Channel Map";
2499  else
2500  knew.name = "Capture Channel Map";
2501  knew.device = pcm->device;
2502  knew.count = pcm->streams[stream].substream_count;
2503  knew.private_value = private_value;
2504  info->kctl = snd_ctl_new1(&knew, info);
2505  if (!info->kctl) {
2506  kfree(info);
2507  return -ENOMEM;
2508  }
2509  info->kctl->private_free = pcm_chmap_ctl_private_free;
2510  err = snd_ctl_add(pcm->card, info->kctl);
2511  if (err < 0)
2512  return err;
2513  pcm->streams[stream].chmap_kctl = info->kctl;
2514  if (info_ret)
2515  *info_ret = info;
2516  return 0;
2517 }
2518 EXPORT_SYMBOL_GPL(snd_pcm_add_chmap_ctls);
Generated on Thu Jan 10 2013 15:03:50 for Linux Kernel by   doxygen 1.8.2