1 /*-
2 * Copyright (c) 2005-2009 Ariff Abdullah <ariff@FreeBSD.org>
3 * Portions Copyright (c) Ryan Beasley <ryan.beasley@gmail.com> - GSoC 2006
4 * Copyright (c) 1999 Cameron Grant <cg@FreeBSD.org>
5 * Portions Copyright (c) Luigi Rizzo <luigi@FreeBSD.org> - 1997-99
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 */
29
30 #include "opt_isa.h"
31
32 #ifdef HAVE_KERNEL_OPTION_HEADERS
33 #include "opt_snd.h"
34 #endif
35
36 #include <dev/sound/pcm/sound.h>
37 #include <dev/sound/pcm/vchan.h>
38
39 #include "feeder_if.h"
40
41 SND_DECLARE_FILE("$FreeBSD: releng/9.0/sys/dev/sound/pcm/channel.c 214332 2010-10-25 08:25:44Z mav $");
42
43 int report_soft_formats = 1;
44 SYSCTL_INT(_hw_snd, OID_AUTO, report_soft_formats, CTLFLAG_RW,
45 &report_soft_formats, 1, "report software-emulated formats");
46
47 int report_soft_matrix = 1;
48 SYSCTL_INT(_hw_snd, OID_AUTO, report_soft_matrix, CTLFLAG_RW,
49 &report_soft_matrix, 1, "report software-emulated channel matrixing");
50
51 int chn_latency = CHN_LATENCY_DEFAULT;
52 TUNABLE_INT("hw.snd.latency", &chn_latency);
53
54 static int
55 sysctl_hw_snd_latency(SYSCTL_HANDLER_ARGS)
56 {
57 int err, val;
58
59 val = chn_latency;
60 err = sysctl_handle_int(oidp, &val, 0, req);
61 if (err != 0 || req->newptr == NULL)
62 return err;
63 if (val < CHN_LATENCY_MIN || val > CHN_LATENCY_MAX)
64 err = EINVAL;
65 else
66 chn_latency = val;
67
68 return err;
69 }
70 SYSCTL_PROC(_hw_snd, OID_AUTO, latency, CTLTYPE_INT | CTLFLAG_RW,
71 0, sizeof(int), sysctl_hw_snd_latency, "I",
72 "buffering latency (0=low ... 10=high)");
73
74 int chn_latency_profile = CHN_LATENCY_PROFILE_DEFAULT;
75 TUNABLE_INT("hw.snd.latency_profile", &chn_latency_profile);
76
77 static int
78 sysctl_hw_snd_latency_profile(SYSCTL_HANDLER_ARGS)
79 {
80 int err, val;
81
82 val = chn_latency_profile;
83 err = sysctl_handle_int(oidp, &val, 0, req);
84 if (err != 0 || req->newptr == NULL)
85 return err;
86 if (val < CHN_LATENCY_PROFILE_MIN || val > CHN_LATENCY_PROFILE_MAX)
87 err = EINVAL;
88 else
89 chn_latency_profile = val;
90
91 return err;
92 }
93 SYSCTL_PROC(_hw_snd, OID_AUTO, latency_profile, CTLTYPE_INT | CTLFLAG_RW,
94 0, sizeof(int), sysctl_hw_snd_latency_profile, "I",
95 "buffering latency profile (0=aggresive 1=safe)");
96
97 static int chn_timeout = CHN_TIMEOUT;
98 TUNABLE_INT("hw.snd.timeout", &chn_timeout);
99 #ifdef SND_DEBUG
100 static int
101 sysctl_hw_snd_timeout(SYSCTL_HANDLER_ARGS)
102 {
103 int err, val;
104
105 val = chn_timeout;
106 err = sysctl_handle_int(oidp, &val, 0, req);
107 if (err != 0 || req->newptr == NULL)
108 return err;
109 if (val < CHN_TIMEOUT_MIN || val > CHN_TIMEOUT_MAX)
110 err = EINVAL;
111 else
112 chn_timeout = val;
113
114 return err;
115 }
116 SYSCTL_PROC(_hw_snd, OID_AUTO, timeout, CTLTYPE_INT | CTLFLAG_RW,
117 0, sizeof(int), sysctl_hw_snd_timeout, "I",
118 "interrupt timeout (1 - 10) seconds");
119 #endif
120
121 static int chn_vpc_autoreset = 1;
122 TUNABLE_INT("hw.snd.vpc_autoreset", &chn_vpc_autoreset);
123 SYSCTL_INT(_hw_snd, OID_AUTO, vpc_autoreset, CTLFLAG_RW,
124 &chn_vpc_autoreset, 0, "automatically reset channels volume to 0db");
125
126 static int chn_vol_0db_pcm = SND_VOL_0DB_PCM;
127 TUNABLE_INT("hw.snd.vpc_0db", &chn_vol_0db_pcm);
128
129 static void
130 chn_vpc_proc(int reset, int db)
131 {
132 struct snddev_info *d;
133 struct pcm_channel *c;
134 int i;
135
136 for (i = 0; pcm_devclass != NULL &&
137 i < devclass_get_maxunit(pcm_devclass); i++) {
138 d = devclass_get_softc(pcm_devclass, i);
139 if (!PCM_REGISTERED(d))
140 continue;
141 PCM_LOCK(d);
142 PCM_WAIT(d);
143 PCM_ACQUIRE(d);
144 CHN_FOREACH(c, d, channels.pcm) {
145 CHN_LOCK(c);
146 CHN_SETVOLUME(c, SND_VOL_C_PCM, SND_CHN_T_VOL_0DB, db);
147 if (reset != 0)
148 chn_vpc_reset(c, SND_VOL_C_PCM, 1);
149 CHN_UNLOCK(c);
150 }
151 PCM_RELEASE(d);
152 PCM_UNLOCK(d);
153 }
154 }
155
156 static int
157 sysctl_hw_snd_vpc_0db(SYSCTL_HANDLER_ARGS)
158 {
159 int err, val;
160
161 val = chn_vol_0db_pcm;
162 err = sysctl_handle_int(oidp, &val, 0, req);
163 if (err != 0 || req->newptr == NULL)
164 return (err);
165 if (val < SND_VOL_0DB_MIN || val > SND_VOL_0DB_MAX)
166 return (EINVAL);
167
168 chn_vol_0db_pcm = val;
169 chn_vpc_proc(0, val);
170
171 return (0);
172 }
173 SYSCTL_PROC(_hw_snd, OID_AUTO, vpc_0db, CTLTYPE_INT | CTLFLAG_RW,
174 0, sizeof(int), sysctl_hw_snd_vpc_0db, "I",
175 "0db relative level");
176
177 static int
178 sysctl_hw_snd_vpc_reset(SYSCTL_HANDLER_ARGS)
179 {
180 int err, val;
181
182 val = 0;
183 err = sysctl_handle_int(oidp, &val, 0, req);
184 if (err != 0 || req->newptr == NULL || val == 0)
185 return (err);
186
187 chn_vol_0db_pcm = SND_VOL_0DB_PCM;
188 chn_vpc_proc(1, SND_VOL_0DB_PCM);
189
190 return (0);
191 }
192 SYSCTL_PROC(_hw_snd, OID_AUTO, vpc_reset, CTLTYPE_INT | CTLFLAG_RW,
193 0, sizeof(int), sysctl_hw_snd_vpc_reset, "I",
194 "reset volume on all channels");
195
196 static int chn_usefrags = 0;
197 TUNABLE_INT("hw.snd.usefrags", &chn_usefrags);
198 static int chn_syncdelay = -1;
199 TUNABLE_INT("hw.snd.syncdelay", &chn_syncdelay);
200 #ifdef SND_DEBUG
201 SYSCTL_INT(_hw_snd, OID_AUTO, usefrags, CTLFLAG_RW,
202 &chn_usefrags, 1, "prefer setfragments() over setblocksize()");
203 SYSCTL_INT(_hw_snd, OID_AUTO, syncdelay, CTLFLAG_RW,
204 &chn_syncdelay, 1,
205 "append (0-1000) millisecond trailing buffer delay on each sync");
206 #endif
207
208 /**
209 * @brief Channel sync group lock
210 *
211 * Clients should acquire this lock @b without holding any channel locks
212 * before touching syncgroups or the main syncgroup list.
213 */
214 struct mtx snd_pcm_syncgroups_mtx;
215 MTX_SYSINIT(pcm_syncgroup, &snd_pcm_syncgroups_mtx, "PCM channel sync group lock", MTX_DEF);
216 /**
217 * @brief syncgroups' master list
218 *
219 * Each time a channel syncgroup is created, it's added to this list. This
220 * list should only be accessed with @sa snd_pcm_syncgroups_mtx held.
221 *
222 * See SNDCTL_DSP_SYNCGROUP for more information.
223 */
224 struct pcm_synclist snd_pcm_syncgroups = SLIST_HEAD_INITIALIZER(snd_pcm_syncgroups);
225
226 static void
227 chn_lockinit(struct pcm_channel *c, int dir)
228 {
229 switch (dir) {
230 case PCMDIR_PLAY:
231 c->lock = snd_mtxcreate(c->name, "pcm play channel");
232 cv_init(&c->intr_cv, "pcmwr");
233 break;
234 case PCMDIR_PLAY_VIRTUAL:
235 c->lock = snd_mtxcreate(c->name, "pcm virtual play channel");
236 cv_init(&c->intr_cv, "pcmwrv");
237 break;
238 case PCMDIR_REC:
239 c->lock = snd_mtxcreate(c->name, "pcm record channel");
240 cv_init(&c->intr_cv, "pcmrd");
241 break;
242 case PCMDIR_REC_VIRTUAL:
243 c->lock = snd_mtxcreate(c->name, "pcm virtual record channel");
244 cv_init(&c->intr_cv, "pcmrdv");
245 break;
246 default:
247 panic("%s(): Invalid direction=%d", __func__, dir);
248 break;
249 }
250
251 cv_init(&c->cv, "pcmchn");
252 }
253
254 static void
255 chn_lockdestroy(struct pcm_channel *c)
256 {
257 CHN_LOCKASSERT(c);
258
259 CHN_BROADCAST(&c->cv);
260 CHN_BROADCAST(&c->intr_cv);
261
262 cv_destroy(&c->cv);
263 cv_destroy(&c->intr_cv);
264
265 snd_mtxfree(c->lock);
266 }
267
268 /**
269 * @brief Determine channel is ready for I/O
270 *
271 * @retval 1 = ready for I/O
272 * @retval 0 = not ready for I/O
273 */
274 static int
275 chn_polltrigger(struct pcm_channel *c)
276 {
277 struct snd_dbuf *bs = c->bufsoft;
278 u_int delta;
279
280 CHN_LOCKASSERT(c);
281
282 if (c->flags & CHN_F_MMAP) {
283 if (sndbuf_getprevtotal(bs) < c->lw)
284 delta = c->lw;
285 else
286 delta = sndbuf_gettotal(bs) - sndbuf_getprevtotal(bs);
287 } else {
288 if (c->direction == PCMDIR_PLAY)
289 delta = sndbuf_getfree(bs);
290 else
291 delta = sndbuf_getready(bs);
292 }
293
294 return ((delta < c->lw) ? 0 : 1);
295 }
296
297 static void
298 chn_pollreset(struct pcm_channel *c)
299 {
300
301 CHN_LOCKASSERT(c);
302 sndbuf_updateprevtotal(c->bufsoft);
303 }
304
305 static void
306 chn_wakeup(struct pcm_channel *c)
307 {
308 struct snd_dbuf *bs;
309 struct pcm_channel *ch;
310
311 CHN_LOCKASSERT(c);
312
313 bs = c->bufsoft;
314
315 if (CHN_EMPTY(c, children.busy)) {
316 if (SEL_WAITING(sndbuf_getsel(bs)) && chn_polltrigger(c))
317 selwakeuppri(sndbuf_getsel(bs), PRIBIO);
318 if (c->flags & CHN_F_SLEEPING) {
319 /*
320 * Ok, I can just panic it right here since it is
321 * quite obvious that we never allow multiple waiters
322 * from userland. I'm too generous...
323 */
324 CHN_BROADCAST(&c->intr_cv);
325 }
326 } else {
327 CHN_FOREACH(ch, c, children.busy) {
328 CHN_LOCK(ch);
329 chn_wakeup(ch);
330 CHN_UNLOCK(ch);
331 }
332 }
333 }
334
335 static int
336 chn_sleep(struct pcm_channel *c, int timeout)
337 {
338 int ret;
339
340 CHN_LOCKASSERT(c);
341
342 if (c->flags & CHN_F_DEAD)
343 return (EINVAL);
344
345 c->flags |= CHN_F_SLEEPING;
346 ret = cv_timedwait_sig(&c->intr_cv, c->lock, timeout);
347 c->flags &= ~CHN_F_SLEEPING;
348
349 return ((c->flags & CHN_F_DEAD) ? EINVAL : ret);
350 }
351
352 /*
353 * chn_dmaupdate() tracks the status of a dma transfer,
354 * updating pointers.
355 */
356
357 static unsigned int
358 chn_dmaupdate(struct pcm_channel *c)
359 {
360 struct snd_dbuf *b = c->bufhard;
361 unsigned int delta, old, hwptr, amt;
362
363 KASSERT(sndbuf_getsize(b) > 0, ("bufsize == 0"));
364 CHN_LOCKASSERT(c);
365
366 old = sndbuf_gethwptr(b);
367 hwptr = chn_getptr(c);
368 delta = (sndbuf_getsize(b) + hwptr - old) % sndbuf_getsize(b);
369 sndbuf_sethwptr(b, hwptr);
370
371 if (c->direction == PCMDIR_PLAY) {
372 amt = min(delta, sndbuf_getready(b));
373 amt -= amt % sndbuf_getalign(b);
374 if (amt > 0)
375 sndbuf_dispose(b, NULL, amt);
376 } else {
377 amt = min(delta, sndbuf_getfree(b));
378 amt -= amt % sndbuf_getalign(b);
379 if (amt > 0)
380 sndbuf_acquire(b, NULL, amt);
381 }
382 if (snd_verbose > 3 && CHN_STARTED(c) && delta == 0) {
383 device_printf(c->dev, "WARNING: %s DMA completion "
384 "too fast/slow ! hwptr=%u, old=%u "
385 "delta=%u amt=%u ready=%u free=%u\n",
386 CHN_DIRSTR(c), hwptr, old, delta, amt,
387 sndbuf_getready(b), sndbuf_getfree(b));
388 }
389
390 return delta;
391 }
392
393 static void
394 chn_wrfeed(struct pcm_channel *c)
395 {
396 struct snd_dbuf *b = c->bufhard;
397 struct snd_dbuf *bs = c->bufsoft;
398 unsigned int amt;
399
400 CHN_LOCKASSERT(c);
401
402 if ((c->flags & CHN_F_MMAP) && !(c->flags & CHN_F_CLOSING))
403 sndbuf_acquire(bs, NULL, sndbuf_getfree(bs));
404
405 amt = sndbuf_getfree(b);
406 if (amt > 0)
407 sndbuf_feed(bs, b, c, c->feeder, amt);
408
409 /*
410 * Possible xruns. There should be no empty space left in buffer.
411 */
412 if (sndbuf_getfree(b) > 0)
413 c->xruns++;
414
415 if (sndbuf_getfree(b) < amt)
416 chn_wakeup(c);
417 }
418
419 #if 0
420 static void
421 chn_wrupdate(struct pcm_channel *c)
422 {
423
424 CHN_LOCKASSERT(c);
425 KASSERT(c->direction == PCMDIR_PLAY, ("%s(): bad channel", __func__));
426
427 if ((c->flags & (CHN_F_MMAP | CHN_F_VIRTUAL)) || CHN_STOPPED(c))
428 return;
429 chn_dmaupdate(c);
430 chn_wrfeed(c);
431 /* tell the driver we've updated the primary buffer */
432 chn_trigger(c, PCMTRIG_EMLDMAWR);
433 }
434 #endif
435
436 static void
437 chn_wrintr(struct pcm_channel *c)
438 {
439
440 CHN_LOCKASSERT(c);
441 /* update pointers in primary buffer */
442 chn_dmaupdate(c);
443 /* ...and feed from secondary to primary */
444 chn_wrfeed(c);
445 /* tell the driver we've updated the primary buffer */
446 chn_trigger(c, PCMTRIG_EMLDMAWR);
447 }
448
449 /*
450 * user write routine - uiomove data into secondary buffer, trigger if necessary
451 * if blocking, sleep, rinse and repeat.
452 *
453 * called externally, so must handle locking
454 */
455
456 int
457 chn_write(struct pcm_channel *c, struct uio *buf)
458 {
459 struct snd_dbuf *bs = c->bufsoft;
460 void *off;
461 int ret, timeout, sz, t, p;
462
463 CHN_LOCKASSERT(c);
464
465 ret = 0;
466 timeout = chn_timeout * hz;
467
468 while (ret == 0 && buf->uio_resid > 0) {
469 sz = min(buf->uio_resid, sndbuf_getfree(bs));
470 if (sz > 0) {
471 /*
472 * The following assumes that the free space in
473 * the buffer can never be less around the
474 * unlock-uiomove-lock sequence.
475 */
476 while (ret == 0 && sz > 0) {
477 p = sndbuf_getfreeptr(bs);
478 t = min(sz, sndbuf_getsize(bs) - p);
479 off = sndbuf_getbufofs(bs, p);
480 CHN_UNLOCK(c);
481 ret = uiomove(off, t, buf);
482 CHN_LOCK(c);
483 sz -= t;
484 sndbuf_acquire(bs, NULL, t);
485 }
486 ret = 0;
487 if (CHN_STOPPED(c) && !(c->flags & CHN_F_NOTRIGGER)) {
488 ret = chn_start(c, 0);
489 if (ret != 0)
490 c->flags |= CHN_F_DEAD;
491 }
492 } else if (c->flags & (CHN_F_NBIO | CHN_F_NOTRIGGER)) {
493 /**
494 * @todo Evaluate whether EAGAIN is truly desirable.
495 * 4Front drivers behave like this, but I'm
496 * not sure if it at all violates the "write
497 * should be allowed to block" model.
498 *
499 * The idea is that, while set with CHN_F_NOTRIGGER,
500 * a channel isn't playing, *but* without this we
501 * end up with "interrupt timeout / channel dead".
502 */
503 ret = EAGAIN;
504 } else {
505 ret = chn_sleep(c, timeout);
506 if (ret == EAGAIN) {
507 ret = EINVAL;
508 c->flags |= CHN_F_DEAD;
509 device_printf(c->dev, "%s(): %s: "
510 "play interrupt timeout, channel dead\n",
511 __func__, c->name);
512 } else if (ret == ERESTART || ret == EINTR)
513 c->flags |= CHN_F_ABORTING;
514 }
515 }
516
517 return (ret);
518 }
519
520 /*
521 * Feed new data from the read buffer. Can be called in the bottom half.
522 */
523 static void
524 chn_rdfeed(struct pcm_channel *c)
525 {
526 struct snd_dbuf *b = c->bufhard;
527 struct snd_dbuf *bs = c->bufsoft;
528 unsigned int amt;
529
530 CHN_LOCKASSERT(c);
531
532 if (c->flags & CHN_F_MMAP)
533 sndbuf_dispose(bs, NULL, sndbuf_getready(bs));
534
535 amt = sndbuf_getfree(bs);
536 if (amt > 0)
537 sndbuf_feed(b, bs, c, c->feeder, amt);
538
539 amt = sndbuf_getready(b);
540 if (amt > 0) {
541 c->xruns++;
542 sndbuf_dispose(b, NULL, amt);
543 }
544
545 if (sndbuf_getready(bs) > 0)
546 chn_wakeup(c);
547 }
548
549 #if 0
550 static void
551 chn_rdupdate(struct pcm_channel *c)
552 {
553
554 CHN_LOCKASSERT(c);
555 KASSERT(c->direction == PCMDIR_REC, ("chn_rdupdate on bad channel"));
556
557 if ((c->flags & (CHN_F_MMAP | CHN_F_VIRTUAL)) || CHN_STOPPED(c))
558 return;
559 chn_trigger(c, PCMTRIG_EMLDMARD);
560 chn_dmaupdate(c);
561 chn_rdfeed(c);
562 }
563 #endif
564
565 /* read interrupt routine. Must be called with interrupts blocked. */
566 static void
567 chn_rdintr(struct pcm_channel *c)
568 {
569
570 CHN_LOCKASSERT(c);
571 /* tell the driver to update the primary buffer if non-dma */
572 chn_trigger(c, PCMTRIG_EMLDMARD);
573 /* update pointers in primary buffer */
574 chn_dmaupdate(c);
575 /* ...and feed from primary to secondary */
576 chn_rdfeed(c);
577 }
578
579 /*
580 * user read routine - trigger if necessary, uiomove data from secondary buffer
581 * if blocking, sleep, rinse and repeat.
582 *
583 * called externally, so must handle locking
584 */
585
586 int
587 chn_read(struct pcm_channel *c, struct uio *buf)
588 {
589 struct snd_dbuf *bs = c->bufsoft;
590 void *off;
591 int ret, timeout, sz, t, p;
592
593 CHN_LOCKASSERT(c);
594
595 if (CHN_STOPPED(c) && !(c->flags & CHN_F_NOTRIGGER)) {
596 ret = chn_start(c, 0);
597 if (ret != 0) {
598 c->flags |= CHN_F_DEAD;
599 return (ret);
600 }
601 }
602
603 ret = 0;
604 timeout = chn_timeout * hz;
605
606 while (ret == 0 && buf->uio_resid > 0) {
607 sz = min(buf->uio_resid, sndbuf_getready(bs));
608 if (sz > 0) {
609 /*
610 * The following assumes that the free space in
611 * the buffer can never be less around the
612 * unlock-uiomove-lock sequence.
613 */
614 while (ret == 0 && sz > 0) {
615 p = sndbuf_getreadyptr(bs);
616 t = min(sz, sndbuf_getsize(bs) - p);
617 off = sndbuf_getbufofs(bs, p);
618 CHN_UNLOCK(c);
619 ret = uiomove(off, t, buf);
620 CHN_LOCK(c);
621 sz -= t;
622 sndbuf_dispose(bs, NULL, t);
623 }
624 ret = 0;
625 } else if (c->flags & (CHN_F_NBIO | CHN_F_NOTRIGGER))
626 ret = EAGAIN;
627 else {
628 ret = chn_sleep(c, timeout);
629 if (ret == EAGAIN) {
630 ret = EINVAL;
631 c->flags |= CHN_F_DEAD;
632 device_printf(c->dev, "%s(): %s: "
633 "record interrupt timeout, channel dead\n",
634 __func__, c->name);
635 } else if (ret == ERESTART || ret == EINTR)
636 c->flags |= CHN_F_ABORTING;
637 }
638 }
639
640 return (ret);
641 }
642
643 void
644 chn_intr_locked(struct pcm_channel *c)
645 {
646
647 CHN_LOCKASSERT(c);
648
649 c->interrupts++;
650
651 if (c->direction == PCMDIR_PLAY)
652 chn_wrintr(c);
653 else
654 chn_rdintr(c);
655 }
656
657 void
658 chn_intr(struct pcm_channel *c)
659 {
660
661 if (CHN_LOCKOWNED(c)) {
662 chn_intr_locked(c);
663 return;
664 }
665
666 CHN_LOCK(c);
667 chn_intr_locked(c);
668 CHN_UNLOCK(c);
669 }
670
671 u_int32_t
672 chn_start(struct pcm_channel *c, int force)
673 {
674 u_int32_t i, j;
675 struct snd_dbuf *b = c->bufhard;
676 struct snd_dbuf *bs = c->bufsoft;
677 int err;
678
679 CHN_LOCKASSERT(c);
680 /* if we're running, or if we're prevented from triggering, bail */
681 if (CHN_STARTED(c) || ((c->flags & CHN_F_NOTRIGGER) && !force))
682 return (EINVAL);
683
684 err = 0;
685
686 if (force) {
687 i = 1;
688 j = 0;
689 } else {
690 if (c->direction == PCMDIR_REC) {
691 i = sndbuf_getfree(bs);
692 j = (i > 0) ? 1 : sndbuf_getready(b);
693 } else {
694 if (sndbuf_getfree(bs) == 0) {
695 i = 1;
696 j = 0;
697 } else {
698 struct snd_dbuf *pb;
699
700 pb = CHN_BUF_PARENT(c, b);
701 i = sndbuf_xbytes(sndbuf_getready(bs), bs, pb);
702 j = sndbuf_getalign(pb);
703 }
704 }
705 if (snd_verbose > 3 && CHN_EMPTY(c, children))
706 device_printf(c->dev, "%s(): %s (%s) threshold "
707 "i=%d j=%d\n", __func__, CHN_DIRSTR(c),
708 (c->flags & CHN_F_VIRTUAL) ? "virtual" :
709 "hardware", i, j);
710 }
711
712 if (i >= j) {
713 c->flags |= CHN_F_TRIGGERED;
714 sndbuf_setrun(b, 1);
715 if (c->flags & CHN_F_CLOSING)
716 c->feedcount = 2;
717 else {
718 c->feedcount = 0;
719 c->interrupts = 0;
720 c->xruns = 0;
721 }
722 if (c->parentchannel == NULL) {
723 if (c->direction == PCMDIR_PLAY)
724 sndbuf_fillsilence(b);
725 if (snd_verbose > 3)
726 device_printf(c->dev,
727 "%s(): %s starting! (%s/%s) "
728 "(ready=%d force=%d i=%d j=%d "
729 "intrtimeout=%u latency=%dms)\n",
730 __func__,
731 (c->flags & CHN_F_HAS_VCHAN) ?
732 "VCHAN PARENT" : "HW", CHN_DIRSTR(c),
733 (c->flags & CHN_F_CLOSING) ? "closing" :
734 "running",
735 sndbuf_getready(b),
736 force, i, j, c->timeout,
737 (sndbuf_getsize(b) * 1000) /
738 (sndbuf_getalign(b) * sndbuf_getspd(b)));
739 }
740 err = chn_trigger(c, PCMTRIG_START);
741 }
742
743 return (err);
744 }
745
746 void
747 chn_resetbuf(struct pcm_channel *c)
748 {
749 struct snd_dbuf *b = c->bufhard;
750 struct snd_dbuf *bs = c->bufsoft;
751
752 c->blocks = 0;
753 sndbuf_reset(b);
754 sndbuf_reset(bs);
755 }
756
757 /*
758 * chn_sync waits until the space in the given channel goes above
759 * a threshold. The threshold is checked against fl or rl respectively.
760 * Assume that the condition can become true, do not check here...
761 */
762 int
763 chn_sync(struct pcm_channel *c, int threshold)
764 {
765 struct snd_dbuf *b, *bs;
766 int ret, count, hcount, minflush, resid, residp, syncdelay, blksz;
767 u_int32_t cflag;
768
769 CHN_LOCKASSERT(c);
770
771 if (c->direction != PCMDIR_PLAY)
772 return (EINVAL);
773
774 bs = c->bufsoft;
775
776 if ((c->flags & (CHN_F_DEAD | CHN_F_ABORTING)) ||
777 (threshold < 1 && sndbuf_getready(bs) < 1))
778 return (0);
779
780 /* if we haven't yet started and nothing is buffered, else start*/
781 if (CHN_STOPPED(c)) {
782 if (threshold > 0 || sndbuf_getready(bs) > 0) {
783 ret = chn_start(c, 1);
784 if (ret != 0)
785 return (ret);
786 } else
787 return (0);
788 }
789
790 b = CHN_BUF_PARENT(c, c->bufhard);
791
792 minflush = threshold + sndbuf_xbytes(sndbuf_getready(b), b, bs);
793
794 syncdelay = chn_syncdelay;
795
796 if (syncdelay < 0 && (threshold > 0 || sndbuf_getready(bs) > 0))
797 minflush += sndbuf_xbytes(sndbuf_getsize(b), b, bs);
798
799 /*
800 * Append (0-1000) millisecond trailing buffer (if needed)
801 * for slower / high latency hardwares (notably USB audio)
802 * to avoid audible truncation.
803 */
804 if (syncdelay > 0)
805 minflush += (sndbuf_getalign(bs) * sndbuf_getspd(bs) *
806 ((syncdelay > 1000) ? 1000 : syncdelay)) / 1000;
807
808 minflush -= minflush % sndbuf_getalign(bs);
809
810 if (minflush > 0) {
811 threshold = min(minflush, sndbuf_getfree(bs));
812 sndbuf_clear(bs, threshold);
813 sndbuf_acquire(bs, NULL, threshold);
814 minflush -= threshold;
815 }
816
817 resid = sndbuf_getready(bs);
818 residp = resid;
819 blksz = sndbuf_getblksz(b);
820 if (blksz < 1) {
821 device_printf(c->dev,
822 "%s(): WARNING: blksz < 1 ! maxsize=%d [%d/%d/%d]\n",
823 __func__, sndbuf_getmaxsize(b), sndbuf_getsize(b),
824 sndbuf_getblksz(b), sndbuf_getblkcnt(b));
825 if (sndbuf_getblkcnt(b) > 0)
826 blksz = sndbuf_getsize(b) / sndbuf_getblkcnt(b);
827 if (blksz < 1)
828 blksz = 1;
829 }
830 count = sndbuf_xbytes(minflush + resid, bs, b) / blksz;
831 hcount = count;
832 ret = 0;
833
834 if (snd_verbose > 3)
835 device_printf(c->dev, "%s(): [begin] timeout=%d count=%d "
836 "minflush=%d resid=%d\n", __func__, c->timeout, count,
837 minflush, resid);
838
839 cflag = c->flags & CHN_F_CLOSING;
840 c->flags |= CHN_F_CLOSING;
841 while (count > 0 && (resid > 0 || minflush > 0)) {
842 ret = chn_sleep(c, c->timeout);
843 if (ret == ERESTART || ret == EINTR) {
844 c->flags |= CHN_F_ABORTING;
845 break;
846 } else if (ret == 0 || ret == EAGAIN) {
847 resid = sndbuf_getready(bs);
848 if (resid == residp) {
849 --count;
850 if (snd_verbose > 3)
851 device_printf(c->dev,
852 "%s(): [stalled] timeout=%d "
853 "count=%d hcount=%d "
854 "resid=%d minflush=%d\n",
855 __func__, c->timeout, count,
856 hcount, resid, minflush);
857 } else if (resid < residp && count < hcount) {
858 ++count;
859 if (snd_verbose > 3)
860 device_printf(c->dev,
861 "%s((): [resume] timeout=%d "
862 "count=%d hcount=%d "
863 "resid=%d minflush=%d\n",
864 __func__, c->timeout, count,
865 hcount, resid, minflush);
866 }
867 if (minflush > 0 && sndbuf_getfree(bs) > 0) {
868 threshold = min(minflush,
869 sndbuf_getfree(bs));
870 sndbuf_clear(bs, threshold);
871 sndbuf_acquire(bs, NULL, threshold);
872 resid = sndbuf_getready(bs);
873 minflush -= threshold;
874 }
875 residp = resid;
876 } else
877 break;
878 }
879 c->flags &= ~CHN_F_CLOSING;
880 c->flags |= cflag;
881
882 if (snd_verbose > 3)
883 device_printf(c->dev,
884 "%s(): timeout=%d count=%d hcount=%d resid=%d residp=%d "
885 "minflush=%d ret=%d\n",
886 __func__, c->timeout, count, hcount, resid, residp,
887 minflush, ret);
888
889 return (0);
890 }
891
892 /* called externally, handle locking */
893 int
894 chn_poll(struct pcm_channel *c, int ev, struct thread *td)
895 {
896 struct snd_dbuf *bs = c->bufsoft;
897 int ret;
898
899 CHN_LOCKASSERT(c);
900
901 if (!(c->flags & (CHN_F_MMAP | CHN_F_TRIGGERED))) {
902 ret = chn_start(c, 1);
903 if (ret != 0)
904 return (0);
905 }
906
907 ret = 0;
908 if (chn_polltrigger(c)) {
909 chn_pollreset(c);
910 ret = ev;
911 } else
912 selrecord(td, sndbuf_getsel(bs));
913
914 return (ret);
915 }
916
917 /*
918 * chn_abort terminates a running dma transfer. it may sleep up to 200ms.
919 * it returns the number of bytes that have not been transferred.
920 *
921 * called from: dsp_close, dsp_ioctl, with channel locked
922 */
923 int
924 chn_abort(struct pcm_channel *c)
925 {
926 int missing = 0;
927 struct snd_dbuf *b = c->bufhard;
928 struct snd_dbuf *bs = c->bufsoft;
929
930 CHN_LOCKASSERT(c);
931 if (CHN_STOPPED(c))
932 return 0;
933 c->flags |= CHN_F_ABORTING;
934
935 c->flags &= ~CHN_F_TRIGGERED;
936 /* kill the channel */
937 chn_trigger(c, PCMTRIG_ABORT);
938 sndbuf_setrun(b, 0);
939 if (!(c->flags & CHN_F_VIRTUAL))
940 chn_dmaupdate(c);
941 missing = sndbuf_getready(bs);
942
943 c->flags &= ~CHN_F_ABORTING;
944 return missing;
945 }
946
947 /*
948 * this routine tries to flush the dma transfer. It is called
949 * on a close of a playback channel.
950 * first, if there is data in the buffer, but the dma has not yet
951 * begun, we need to start it.
952 * next, we wait for the play buffer to drain
953 * finally, we stop the dma.
954 *
955 * called from: dsp_close, not valid for record channels.
956 */
957
958 int
959 chn_flush(struct pcm_channel *c)
960 {
961 struct snd_dbuf *b = c->bufhard;
962
963 CHN_LOCKASSERT(c);
964 KASSERT(c->direction == PCMDIR_PLAY, ("chn_flush on bad channel"));
965 DEB(printf("chn_flush: c->flags 0x%08x\n", c->flags));
966
967 c->flags |= CHN_F_CLOSING;
968 chn_sync(c, 0);
969 c->flags &= ~CHN_F_TRIGGERED;
970 /* kill the channel */
971 chn_trigger(c, PCMTRIG_ABORT);
972 sndbuf_setrun(b, 0);
973
974 c->flags &= ~CHN_F_CLOSING;
975 return 0;
976 }
977
978 int
979 snd_fmtvalid(uint32_t fmt, uint32_t *fmtlist)
980 {
981 int i;
982
983 for (i = 0; fmtlist[i] != 0; i++) {
984 if (fmt == fmtlist[i] ||
985 ((fmt & AFMT_PASSTHROUGH) &&
986 (AFMT_ENCODING(fmt) & fmtlist[i])))
987 return (1);
988 }
989
990 return (0);
991 }
992
993 static const struct {
994 char *name, *alias1, *alias2;
995 uint32_t afmt;
996 } afmt_tab[] = {
997 { "alaw", NULL, NULL, AFMT_A_LAW },
998 { "mulaw", NULL, NULL, AFMT_MU_LAW },
999 { "u8", "8", NULL, AFMT_U8 },
1000 { "s8", NULL, NULL, AFMT_S8 },
1001 #if BYTE_ORDER == LITTLE_ENDIAN
1002 { "s16le", "s16", "16", AFMT_S16_LE },
1003 { "s16be", NULL, NULL, AFMT_S16_BE },
1004 #else
1005 { "s16le", NULL, NULL, AFMT_S16_LE },
1006 { "s16be", "s16", "16", AFMT_S16_BE },
1007 #endif
1008 { "u16le", NULL, NULL, AFMT_U16_LE },
1009 { "u16be", NULL, NULL, AFMT_U16_BE },
1010 { "s24le", NULL, NULL, AFMT_S24_LE },
1011 { "s24be", NULL, NULL, AFMT_S24_BE },
1012 { "u24le", NULL, NULL, AFMT_U24_LE },
1013 { "u24be", NULL, NULL, AFMT_U24_BE },
1014 #if BYTE_ORDER == LITTLE_ENDIAN
1015 { "s32le", "s32", "32", AFMT_S32_LE },
1016 { "s32be", NULL, NULL, AFMT_S32_BE },
1017 #else
1018 { "s32le", NULL, NULL, AFMT_S32_LE },
1019 { "s32be", "s32", "32", AFMT_S32_BE },
1020 #endif
1021 { "u32le", NULL, NULL, AFMT_U32_LE },
1022 { "u32be", NULL, NULL, AFMT_U32_BE },
1023 { "ac3", NULL, NULL, AFMT_AC3 },
1024 { NULL, NULL, NULL, 0 }
1025 };
1026
1027 static const struct {
1028 char *name, *alias1, *alias2;
1029 int matrix_id;
1030 } matrix_id_tab[] = {
1031 { "1.0", "1", "mono", SND_CHN_MATRIX_1_0 },
1032 { "2.0", "2", "stereo", SND_CHN_MATRIX_2_0 },
1033 { "2.1", NULL, NULL, SND_CHN_MATRIX_2_1 },
1034 { "3.0", "3", NULL, SND_CHN_MATRIX_3_0 },
1035 { "4.0", "4", "quad", SND_CHN_MATRIX_4_0 },
1036 { "4.1", NULL, NULL, SND_CHN_MATRIX_4_1 },
1037 { "5.0", "5", NULL, SND_CHN_MATRIX_5_0 },
1038 { "5.1", "6", NULL, SND_CHN_MATRIX_5_1 },
1039 { "6.0", NULL, NULL, SND_CHN_MATRIX_6_0 },
1040 { "6.1", "7", NULL, SND_CHN_MATRIX_6_1 },
1041 { "7.1", "8", NULL, SND_CHN_MATRIX_7_1 },
1042 { NULL, NULL, NULL, SND_CHN_MATRIX_UNKNOWN }
1043 };
1044
1045 uint32_t
1046 snd_str2afmt(const char *req)
1047 {
1048 uint32_t i, afmt;
1049 int matrix_id;
1050 char b1[8], b2[8];
1051
1052 i = sscanf(req, "%5[^:]:%6s", b1, b2);
1053
1054 if (i == 1) {
1055 if (strlen(req) != strlen(b1))
1056 return (0);
1057 strlcpy(b2, "2.0", sizeof(b2));
1058 } else if (i == 2) {
1059 if (strlen(req) != (strlen(b1) + 1 + strlen(b2)))
1060 return (0);
1061 } else
1062 return (0);
1063
1064 afmt = 0;
1065 matrix_id = SND_CHN_MATRIX_UNKNOWN;
1066
1067 for (i = 0; afmt == 0 && afmt_tab[i].name != NULL; i++) {
1068 if (strcasecmp(afmt_tab[i].name, b1) == 0 ||
1069 (afmt_tab[i].alias1 != NULL &&
1070 strcasecmp(afmt_tab[i].alias1, b1) == 0) ||
1071 (afmt_tab[i].alias2 != NULL &&
1072 strcasecmp(afmt_tab[i].alias2, b1) == 0)) {
1073 afmt = afmt_tab[i].afmt;
1074 strlcpy(b1, afmt_tab[i].name, sizeof(b1));
1075 }
1076 }
1077
1078 if (afmt == 0)
1079 return (0);
1080
1081 for (i = 0; matrix_id == SND_CHN_MATRIX_UNKNOWN &&
1082 matrix_id_tab[i].name != NULL; i++) {
1083 if (strcmp(matrix_id_tab[i].name, b2) == 0 ||
1084 (matrix_id_tab[i].alias1 != NULL &&
1085 strcmp(matrix_id_tab[i].alias1, b2) == 0) ||
1086 (matrix_id_tab[i].alias2 != NULL &&
1087 strcasecmp(matrix_id_tab[i].alias2, b2) == 0)) {
1088 matrix_id = matrix_id_tab[i].matrix_id;
1089 strlcpy(b2, matrix_id_tab[i].name, sizeof(b2));
1090 }
1091 }
1092
1093 if (matrix_id == SND_CHN_MATRIX_UNKNOWN)
1094 return (0);
1095
1096 #ifndef _KERNEL
1097 printf("Parse OK: '%s' -> '%s:%s' %d\n", req, b1, b2,
1098 (int)(b2[0]) - '' + (int)(b2[2]) - '');
1099 #endif
1100
1101 return (SND_FORMAT(afmt, b2[0] - '' + b2[2] - '', b2[2] - ''));
1102 }
1103
1104 uint32_t
1105 snd_afmt2str(uint32_t afmt, char *buf, size_t len)
1106 {
1107 uint32_t i, enc, ch, ext;
1108 char tmp[AFMTSTR_LEN];
1109
1110 if (buf == NULL || len < AFMTSTR_LEN)
1111 return (0);
1112
1113
1114 bzero(tmp, sizeof(tmp));
1115
1116 enc = AFMT_ENCODING(afmt);
1117 ch = AFMT_CHANNEL(afmt);
1118 ext = AFMT_EXTCHANNEL(afmt);
1119
1120 for (i = 0; afmt_tab[i].name != NULL; i++) {
1121 if (enc == afmt_tab[i].afmt) {
1122 strlcpy(tmp, afmt_tab[i].name, sizeof(tmp));
1123 strlcat(tmp, ":", sizeof(tmp));
1124 break;
1125 }
1126 }
1127
1128 if (strlen(tmp) == 0)
1129 return (0);
1130
1131 for (i = 0; matrix_id_tab[i].name != NULL; i++) {
1132 if (ch == (matrix_id_tab[i].name[0] - '' +
1133 matrix_id_tab[i].name[2] - '') &&
1134 ext == (matrix_id_tab[i].name[2] - '')) {
1135 strlcat(tmp, matrix_id_tab[i].name, sizeof(tmp));
1136 break;
1137 }
1138 }
1139
1140 if (strlen(tmp) == 0)
1141 return (0);
1142
1143 strlcpy(buf, tmp, len);
1144
1145 return (snd_str2afmt(buf));
1146 }
1147
1148 int
1149 chn_reset(struct pcm_channel *c, uint32_t fmt, uint32_t spd)
1150 {
1151 int r;
1152
1153 CHN_LOCKASSERT(c);
1154 c->feedcount = 0;
1155 c->flags &= CHN_F_RESET;
1156 c->interrupts = 0;
1157 c->timeout = 1;
1158 c->xruns = 0;
1159
1160 c->flags |= (pcm_getflags(c->dev) & SD_F_BITPERFECT) ?
1161 CHN_F_BITPERFECT : 0;
1162
1163 r = CHANNEL_RESET(c->methods, c->devinfo);
1164 if (r == 0 && fmt != 0 && spd != 0) {
1165 r = chn_setparam(c, fmt, spd);
1166 fmt = 0;
1167 spd = 0;
1168 }
1169 if (r == 0 && fmt != 0)
1170 r = chn_setformat(c, fmt);
1171 if (r == 0 && spd != 0)
1172 r = chn_setspeed(c, spd);
1173 if (r == 0)
1174 r = chn_setlatency(c, chn_latency);
1175 if (r == 0) {
1176 chn_resetbuf(c);
1177 r = CHANNEL_RESETDONE(c->methods, c->devinfo);
1178 }
1179 return r;
1180 }
1181
1182 int
1183 chn_init(struct pcm_channel *c, void *devinfo, int dir, int direction)
1184 {
1185 struct feeder_class *fc;
1186 struct snd_dbuf *b, *bs;
1187 int i, ret;
1188
1189 if (chn_timeout < CHN_TIMEOUT_MIN || chn_timeout > CHN_TIMEOUT_MAX)
1190 chn_timeout = CHN_TIMEOUT;
1191
1192 chn_lockinit(c, dir);
1193
1194 b = NULL;
1195 bs = NULL;
1196 CHN_INIT(c, children);
1197 CHN_INIT(c, children.busy);
1198 c->devinfo = NULL;
1199 c->feeder = NULL;
1200 c->latency = -1;
1201 c->timeout = 1;
1202
1203 ret = ENOMEM;
1204 b = sndbuf_create(c->dev, c->name, "primary", c);
1205 if (b == NULL)
1206 goto out;
1207 bs = sndbuf_create(c->dev, c->name, "secondary", c);
1208 if (bs == NULL)
1209 goto out;
1210
1211 CHN_LOCK(c);
1212
1213 ret = EINVAL;
1214 fc = feeder_getclass(NULL);
1215 if (fc == NULL)
1216 goto out;
1217 if (chn_addfeeder(c, fc, NULL))
1218 goto out;
1219
1220 /*
1221 * XXX - sndbuf_setup() & sndbuf_resize() expect to be called
1222 * with the channel unlocked because they are also called
1223 * from driver methods that don't know about locking
1224 */
1225 CHN_UNLOCK(c);
1226 sndbuf_setup(bs, NULL, 0);
1227 CHN_LOCK(c);
1228 c->bufhard = b;
1229 c->bufsoft = bs;
1230 c->flags = 0;
1231 c->feederflags = 0;
1232 c->sm = NULL;
1233 c->format = SND_FORMAT(AFMT_U8, 1, 0);
1234 c->speed = DSP_DEFAULT_SPEED;
1235
1236 c->matrix = *feeder_matrix_id_map(SND_CHN_MATRIX_1_0);
1237 c->matrix.id = SND_CHN_MATRIX_PCMCHANNEL;
1238
1239 for (i = 0; i < SND_CHN_T_MAX; i++) {
1240 c->volume[SND_VOL_C_MASTER][i] = SND_VOL_0DB_MASTER;
1241 }
1242
1243 c->volume[SND_VOL_C_MASTER][SND_CHN_T_VOL_0DB] = SND_VOL_0DB_MASTER;
1244 c->volume[SND_VOL_C_PCM][SND_CHN_T_VOL_0DB] = chn_vol_0db_pcm;
1245
1246 chn_vpc_reset(c, SND_VOL_C_PCM, 1);
1247
1248 ret = ENODEV;
1249 CHN_UNLOCK(c); /* XXX - Unlock for CHANNEL_INIT() malloc() call */
1250 c->devinfo = CHANNEL_INIT(c->methods, devinfo, b, c, direction);
1251 CHN_LOCK(c);
1252 if (c->devinfo == NULL)
1253 goto out;
1254
1255 ret = ENOMEM;
1256 if ((sndbuf_getsize(b) == 0) && ((c->flags & CHN_F_VIRTUAL) == 0))
1257 goto out;
1258
1259 ret = 0;
1260 c->direction = direction;
1261
1262 sndbuf_setfmt(b, c->format);
1263 sndbuf_setspd(b, c->speed);
1264 sndbuf_setfmt(bs, c->format);
1265 sndbuf_setspd(bs, c->speed);
1266
1267 /**
1268 * @todo Should this be moved somewhere else? The primary buffer
1269 * is allocated by the driver or via DMA map setup, and tmpbuf
1270 * seems to only come into existence in sndbuf_resize().
1271 */
1272 if (c->direction == PCMDIR_PLAY) {
1273 bs->sl = sndbuf_getmaxsize(bs);
1274 bs->shadbuf = malloc(bs->sl, M_DEVBUF, M_NOWAIT);
1275 if (bs->shadbuf == NULL) {
1276 ret = ENOMEM;
1277 goto out;
1278 }
1279 }
1280
1281 out:
1282 CHN_UNLOCK(c);
1283 if (ret) {
1284 if (c->devinfo) {
1285 if (CHANNEL_FREE(c->methods, c->devinfo))
1286 sndbuf_free(b);
1287 }
1288 if (bs)
1289 sndbuf_destroy(bs);
1290 if (b)
1291 sndbuf_destroy(b);
1292 CHN_LOCK(c);
1293 c->flags |= CHN_F_DEAD;
1294 chn_lockdestroy(c);
1295
1296 return ret;
1297 }
1298
1299 return 0;
1300 }
1301
1302 int
1303 chn_kill(struct pcm_channel *c)
1304 {
1305 struct snd_dbuf *b = c->bufhard;
1306 struct snd_dbuf *bs = c->bufsoft;
1307
1308 if (CHN_STARTED(c)) {
1309 CHN_LOCK(c);
1310 chn_trigger(c, PCMTRIG_ABORT);
1311 CHN_UNLOCK(c);
1312 }
1313 while (chn_removefeeder(c) == 0)
1314 ;
1315 if (CHANNEL_FREE(c->methods, c->devinfo))
1316 sndbuf_free(b);
1317 sndbuf_destroy(bs);
1318 sndbuf_destroy(b);
1319 CHN_LOCK(c);
1320 c->flags |= CHN_F_DEAD;
1321 chn_lockdestroy(c);
1322
1323 return (0);
1324 }
1325
1326 /* XXX Obsolete. Use *_matrix() variant instead. */
1327 int
1328 chn_setvolume(struct pcm_channel *c, int left, int right)
1329 {
1330 int ret;
1331
1332 ret = chn_setvolume_matrix(c, SND_VOL_C_MASTER, SND_CHN_T_FL, left);
1333 ret |= chn_setvolume_matrix(c, SND_VOL_C_MASTER, SND_CHN_T_FR,
1334 right) << 8;
1335
1336 return (ret);
1337 }
1338
1339 int
1340 chn_setvolume_multi(struct pcm_channel *c, int vc, int left, int right,
1341 int center)
1342 {
1343 int i, ret;
1344
1345 ret = 0;
1346
1347 for (i = 0; i < SND_CHN_T_MAX; i++) {
1348 if ((1 << i) & SND_CHN_LEFT_MASK)
1349 ret |= chn_setvolume_matrix(c, vc, i, left);
1350 else if ((1 << i) & SND_CHN_RIGHT_MASK)
1351 ret |= chn_setvolume_matrix(c, vc, i, right) << 8;
1352 else
1353 ret |= chn_setvolume_matrix(c, vc, i, center) << 16;
1354 }
1355
1356 return (ret);
1357 }
1358
1359 int
1360 chn_setvolume_matrix(struct pcm_channel *c, int vc, int vt, int val)
1361 {
1362 int i;
1363
1364 KASSERT(c != NULL && vc >= SND_VOL_C_MASTER && vc < SND_VOL_C_MAX &&
1365 (vc == SND_VOL_C_MASTER || (vc & 1)) &&
1366 (vt == SND_CHN_T_VOL_0DB || (vt >= SND_CHN_T_BEGIN &&
1367 vt <= SND_CHN_T_END)) && (vt != SND_CHN_T_VOL_0DB ||
1368 (val >= SND_VOL_0DB_MIN && val <= SND_VOL_0DB_MAX)),
1369 ("%s(): invalid volume matrix c=%p vc=%d vt=%d val=%d",
1370 __func__, c, vc, vt, val));
1371 CHN_LOCKASSERT(c);
1372
1373 if (val < 0)
1374 val = 0;
1375 if (val > 100)
1376 val = 100;
1377
1378 c->volume[vc][vt] = val;
1379
1380 /*
1381 * Do relative calculation here and store it into class + 1
1382 * to ease the job of feeder_volume.
1383 */
1384 if (vc == SND_VOL_C_MASTER) {
1385 for (vc = SND_VOL_C_BEGIN; vc <= SND_VOL_C_END;
1386 vc += SND_VOL_C_STEP)
1387 c->volume[SND_VOL_C_VAL(vc)][vt] =
1388 SND_VOL_CALC_VAL(c->volume, vc, vt);
1389 } else if (vc & 1) {
1390 if (vt == SND_CHN_T_VOL_0DB)
1391 for (i = SND_CHN_T_BEGIN; i <= SND_CHN_T_END;
1392 i += SND_CHN_T_STEP) {
1393 c->volume[SND_VOL_C_VAL(vc)][i] =
1394 SND_VOL_CALC_VAL(c->volume, vc, i);
1395 }
1396 else
1397 c->volume[SND_VOL_C_VAL(vc)][vt] =
1398 SND_VOL_CALC_VAL(c->volume, vc, vt);
1399 }
1400
1401 return (val);
1402 }
1403
1404 int
1405 chn_getvolume_matrix(struct pcm_channel *c, int vc, int vt)
1406 {
1407 KASSERT(c != NULL && vc >= SND_VOL_C_MASTER && vc < SND_VOL_C_MAX &&
1408 (vt == SND_CHN_T_VOL_0DB ||
1409 (vt >= SND_CHN_T_BEGIN && vt <= SND_CHN_T_END)),
1410 ("%s(): invalid volume matrix c=%p vc=%d vt=%d",
1411 __func__, c, vc, vt));
1412 CHN_LOCKASSERT(c);
1413
1414 return (c->volume[vc][vt]);
1415 }
1416
1417 struct pcmchan_matrix *
1418 chn_getmatrix(struct pcm_channel *c)
1419 {
1420
1421 KASSERT(c != NULL, ("%s(): NULL channel", __func__));
1422 CHN_LOCKASSERT(c);
1423
1424 if (!(c->format & AFMT_CONVERTIBLE))
1425 return (NULL);
1426
1427 return (&c->matrix);
1428 }
1429
1430 int
1431 chn_setmatrix(struct pcm_channel *c, struct pcmchan_matrix *m)
1432 {
1433
1434 KASSERT(c != NULL && m != NULL,
1435 ("%s(): NULL channel or matrix", __func__));
1436 CHN_LOCKASSERT(c);
1437
1438 if (!(c->format & AFMT_CONVERTIBLE))
1439 return (EINVAL);
1440
1441 c->matrix = *m;
1442 c->matrix.id = SND_CHN_MATRIX_PCMCHANNEL;
1443
1444 return (chn_setformat(c, SND_FORMAT(c->format, m->channels, m->ext)));
1445 }
1446
1447 /*
1448 * XXX chn_oss_* exists for the sake of compatibility.
1449 */
1450 int
1451 chn_oss_getorder(struct pcm_channel *c, unsigned long long *map)
1452 {
1453
1454 KASSERT(c != NULL && map != NULL,
1455 ("%s(): NULL channel or map", __func__));
1456 CHN_LOCKASSERT(c);
1457
1458 if (!(c->format & AFMT_CONVERTIBLE))
1459 return (EINVAL);
1460
1461 return (feeder_matrix_oss_get_channel_order(&c->matrix, map));
1462 }
1463
1464 int
1465 chn_oss_setorder(struct pcm_channel *c, unsigned long long *map)
1466 {
1467 struct pcmchan_matrix m;
1468 int ret;
1469
1470 KASSERT(c != NULL && map != NULL,
1471 ("%s(): NULL channel or map", __func__));
1472 CHN_LOCKASSERT(c);
1473
1474 if (!(c->format & AFMT_CONVERTIBLE))
1475 return (EINVAL);
1476
1477 m = c->matrix;
1478 ret = feeder_matrix_oss_set_channel_order(&m, map);
1479 if (ret != 0)
1480 return (ret);
1481
1482 return (chn_setmatrix(c, &m));
1483 }
1484
1485 #define SND_CHN_OSS_FRONT (SND_CHN_T_MASK_FL | SND_CHN_T_MASK_FR)
1486 #define SND_CHN_OSS_SURR (SND_CHN_T_MASK_SL | SND_CHN_T_MASK_SR)
1487 #define SND_CHN_OSS_CENTER_LFE (SND_CHN_T_MASK_FC | SND_CHN_T_MASK_LF)
1488 #define SND_CHN_OSS_REAR (SND_CHN_T_MASK_BL | SND_CHN_T_MASK_BR)
1489
1490 int
1491 chn_oss_getmask(struct pcm_channel *c, uint32_t *retmask)
1492 {
1493 struct pcmchan_matrix *m;
1494 struct pcmchan_caps *caps;
1495 uint32_t i, format;
1496
1497 KASSERT(c != NULL && retmask != NULL,
1498 ("%s(): NULL channel or retmask", __func__));
1499 CHN_LOCKASSERT(c);
1500
1501 caps = chn_getcaps(c);
1502 if (caps == NULL || caps->fmtlist == NULL)
1503 return (ENODEV);
1504
1505 for (i = 0; caps->fmtlist[i] != 0; i++) {
1506 format = caps->fmtlist[i];
1507 if (!(format & AFMT_CONVERTIBLE)) {
1508 *retmask |= DSP_BIND_SPDIF;
1509 continue;
1510 }
1511 m = CHANNEL_GETMATRIX(c->methods, c->devinfo, format);
1512 if (m == NULL)
1513 continue;
1514 if (m->mask & SND_CHN_OSS_FRONT)
1515 *retmask |= DSP_BIND_FRONT;
1516 if (m->mask & SND_CHN_OSS_SURR)
1517 *retmask |= DSP_BIND_SURR;
1518 if (m->mask & SND_CHN_OSS_CENTER_LFE)
1519 *retmask |= DSP_BIND_CENTER_LFE;
1520 if (m->mask & SND_CHN_OSS_REAR)
1521 *retmask |= DSP_BIND_REAR;
1522 }
1523
1524 /* report software-supported binding mask */
1525 if (!CHN_BITPERFECT(c) && report_soft_matrix)
1526 *retmask |= DSP_BIND_FRONT | DSP_BIND_SURR |
1527 DSP_BIND_CENTER_LFE | DSP_BIND_REAR;
1528
1529 return (0);
1530 }
1531
1532 void
1533 chn_vpc_reset(struct pcm_channel *c, int vc, int force)
1534 {
1535 int i;
1536
1537 KASSERT(c != NULL && vc >= SND_VOL_C_BEGIN && vc <= SND_VOL_C_END,
1538 ("%s(): invalid reset c=%p vc=%d", __func__, c, vc));
1539 CHN_LOCKASSERT(c);
1540
1541 if (force == 0 && chn_vpc_autoreset == 0)
1542 return;
1543
1544 for (i = SND_CHN_T_BEGIN; i <= SND_CHN_T_END; i += SND_CHN_T_STEP)
1545 CHN_SETVOLUME(c, vc, i, c->volume[vc][SND_CHN_T_VOL_0DB]);
1546 }
1547
1548 static u_int32_t
1549 round_pow2(u_int32_t v)
1550 {
1551 u_int32_t ret;
1552
1553 if (v < 2)
1554 v = 2;
1555 ret = 0;
1556 while (v >> ret)
1557 ret++;
1558 ret = 1 << (ret - 1);
1559 while (ret < v)
1560 ret <<= 1;
1561 return ret;
1562 }
1563
1564 static u_int32_t
1565 round_blksz(u_int32_t v, int round)
1566 {
1567 u_int32_t ret, tmp;
1568
1569 if (round < 1)
1570 round = 1;
1571
1572 ret = min(round_pow2(v), CHN_2NDBUFMAXSIZE >> 1);
1573
1574 if (ret > v && (ret >> 1) > 0 && (ret >> 1) >= ((v * 3) >> 2))
1575 ret >>= 1;
1576
1577 tmp = ret - (ret % round);
1578 while (tmp < 16 || tmp < round) {
1579 ret <<= 1;
1580 tmp = ret - (ret % round);
1581 }
1582
1583 return ret;
1584 }
1585
1586 /*
1587 * 4Front call it DSP Policy, while we call it "Latency Profile". The idea
1588 * is to keep 2nd buffer short so that it doesn't cause long queue during
1589 * buffer transfer.
1590 *
1591 * Latency reference table for 48khz stereo 16bit: (PLAY)
1592 *
1593 * +---------+------------+-----------+------------+
1594 * | Latency | Blockcount | Blocksize | Buffersize |
1595 * +---------+------------+-----------+------------+
1596 * | 0 | 2 | 64 | 128 |
1597 * +---------+------------+-----------+------------+
1598 * | 1 | 4 | 128 | 512 |
1599 * +---------+------------+-----------+------------+
1600 * | 2 | 8 | 512 | 4096 |
1601 * +---------+------------+-----------+------------+
1602 * | 3 | 16 | 512 | 8192 |
1603 * +---------+------------+-----------+------------+
1604 * | 4 | 32 | 512 | 16384 |
1605 * +---------+------------+-----------+------------+
1606 * | 5 | 32 | 1024 | 32768 |
1607 * +---------+------------+-----------+------------+
1608 * | 6 | 16 | 2048 | 32768 |
1609 * +---------+------------+-----------+------------+
1610 * | 7 | 8 | 4096 | 32768 |
1611 * +---------+------------+-----------+------------+
1612 * | 8 | 4 | 8192 | 32768 |
1613 * +---------+------------+-----------+------------+
1614 * | 9 | 2 | 16384 | 32768 |
1615 * +---------+------------+-----------+------------+
1616 * | 10 | 2 | 32768 | 65536 |
1617 * +---------+------------+-----------+------------+
1618 *
1619 * Recording need a different reference table. All we care is
1620 * gobbling up everything within reasonable buffering threshold.
1621 *
1622 * Latency reference table for 48khz stereo 16bit: (REC)
1623 *
1624 * +---------+------------+-----------+------------+
1625 * | Latency | Blockcount | Blocksize | Buffersize |
1626 * +---------+------------+-----------+------------+
1627 * | 0 | 512 | 32 | 16384 |
1628 * +---------+------------+-----------+------------+
1629 * | 1 | 256 | 64 | 16384 |
1630 * +---------+------------+-----------+------------+
1631 * | 2 | 128 | 128 | 16384 |
1632 * +---------+------------+-----------+------------+
1633 * | 3 | 64 | 256 | 16384 |
1634 * +---------+------------+-----------+------------+
1635 * | 4 | 32 | 512 | 16384 |
1636 * +---------+------------+-----------+------------+
1637 * | 5 | 32 | 1024 | 32768 |
1638 * +---------+------------+-----------+------------+
1639 * | 6 | 16 | 2048 | 32768 |
1640 * +---------+------------+-----------+------------+
1641 * | 7 | 8 | 4096 | 32768 |
1642 * +---------+------------+-----------+------------+
1643 * | 8 | 4 | 8192 | 32768 |
1644 * +---------+------------+-----------+------------+
1645 * | 9 | 2 | 16384 | 32768 |
1646 * +---------+------------+-----------+------------+
1647 * | 10 | 2 | 32768 | 65536 |
1648 * +---------+------------+-----------+------------+
1649 *
1650 * Calculations for other data rate are entirely based on these reference
1651 * tables. For normal operation, Latency 5 seems give the best, well
1652 * balanced performance for typical workload. Anything below 5 will
1653 * eat up CPU to keep up with increasing context switches because of
1654 * shorter buffer space and usually require the application to handle it
1655 * aggresively through possibly real time programming technique.
1656 *
1657 */
1658 #define CHN_LATENCY_PBLKCNT_REF \
1659 {{1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 1}, \
1660 {1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 1}}
1661 #define CHN_LATENCY_PBUFSZ_REF \
1662 {{7, 9, 12, 13, 14, 15, 15, 15, 15, 15, 16}, \
1663 {11, 12, 13, 14, 15, 16, 16, 16, 16, 16, 17}}
1664
1665 #define CHN_LATENCY_RBLKCNT_REF \
1666 {{9, 8, 7, 6, 5, 5, 4, 3, 2, 1, 1}, \
1667 {9, 8, 7, 6, 5, 5, 4, 3, 2, 1, 1}}
1668 #define CHN_LATENCY_RBUFSZ_REF \
1669 {{14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 16}, \
1670 {15, 15, 15, 15, 15, 16, 16, 16, 16, 16, 17}}
1671
1672 #define CHN_LATENCY_DATA_REF 192000 /* 48khz stereo 16bit ~ 48000 x 2 x 2 */
1673
1674 static int
1675 chn_calclatency(int dir, int latency, int bps, u_int32_t datarate,
1676 u_int32_t max, int *rblksz, int *rblkcnt)
1677 {
1678 static int pblkcnts[CHN_LATENCY_PROFILE_MAX + 1][CHN_LATENCY_MAX + 1] =
1679 CHN_LATENCY_PBLKCNT_REF;
1680 static int pbufszs[CHN_LATENCY_PROFILE_MAX + 1][CHN_LATENCY_MAX + 1] =
1681 CHN_LATENCY_PBUFSZ_REF;
1682 static int rblkcnts[CHN_LATENCY_PROFILE_MAX + 1][CHN_LATENCY_MAX + 1] =
1683 CHN_LATENCY_RBLKCNT_REF;
1684 static int rbufszs[CHN_LATENCY_PROFILE_MAX + 1][CHN_LATENCY_MAX + 1] =
1685 CHN_LATENCY_RBUFSZ_REF;
1686 u_int32_t bufsz;
1687 int lprofile, blksz, blkcnt;
1688
1689 if (latency < CHN_LATENCY_MIN || latency > CHN_LATENCY_MAX ||
1690 bps < 1 || datarate < 1 ||
1691 !(dir == PCMDIR_PLAY || dir == PCMDIR_REC)) {
1692 if (rblksz != NULL)
1693 *rblksz = CHN_2NDBUFMAXSIZE >> 1;
1694 if (rblkcnt != NULL)
1695 *rblkcnt = 2;
1696 printf("%s(): FAILED dir=%d latency=%d bps=%d "
1697 "datarate=%u max=%u\n",
1698 __func__, dir, latency, bps, datarate, max);
1699 return CHN_2NDBUFMAXSIZE;
1700 }
1701
1702 lprofile = chn_latency_profile;
1703
1704 if (dir == PCMDIR_PLAY) {
1705 blkcnt = pblkcnts[lprofile][latency];
1706 bufsz = pbufszs[lprofile][latency];
1707 } else {
1708 blkcnt = rblkcnts[lprofile][latency];
1709 bufsz = rbufszs[lprofile][latency];
1710 }
1711
1712 bufsz = round_pow2(snd_xbytes(1 << bufsz, CHN_LATENCY_DATA_REF,
1713 datarate));
1714 if (bufsz > max)
1715 bufsz = max;
1716 blksz = round_blksz(bufsz >> blkcnt, bps);
1717
1718 if (rblksz != NULL)
1719 *rblksz = blksz;
1720 if (rblkcnt != NULL)
1721 *rblkcnt = 1 << blkcnt;
1722
1723 return blksz << blkcnt;
1724 }
1725
1726 static int
1727 chn_resizebuf(struct pcm_channel *c, int latency,
1728 int blkcnt, int blksz)
1729 {
1730 struct snd_dbuf *b, *bs, *pb;
1731 int sblksz, sblkcnt, hblksz, hblkcnt, limit = 1;
1732 int ret;
1733
1734 CHN_LOCKASSERT(c);
1735
1736 if ((c->flags & (CHN_F_MMAP | CHN_F_TRIGGERED)) ||
1737 !(c->direction == PCMDIR_PLAY || c->direction == PCMDIR_REC))
1738 return EINVAL;
1739
1740 if (latency == -1) {
1741 c->latency = -1;
1742 latency = chn_latency;
1743 } else if (latency == -2) {
1744 latency = c->latency;
1745 if (latency < CHN_LATENCY_MIN || latency > CHN_LATENCY_MAX)
1746 latency = chn_latency;
1747 } else if (latency < CHN_LATENCY_MIN || latency > CHN_LATENCY_MAX)
1748 return EINVAL;
1749 else {
1750 c->latency = latency;
1751 limit = 0;
1752 }
1753
1754 bs = c->bufsoft;
1755 b = c->bufhard;
1756
1757 if (!(blksz == 0 || blkcnt == -1) &&
1758 (blksz < 16 || blksz < sndbuf_getalign(bs) || blkcnt < 2 ||
1759 (blksz * blkcnt) > CHN_2NDBUFMAXSIZE))
1760 return EINVAL;
1761
1762 chn_calclatency(c->direction, latency, sndbuf_getalign(bs),
1763 sndbuf_getalign(bs) * sndbuf_getspd(bs), CHN_2NDBUFMAXSIZE,
1764 &sblksz, &sblkcnt);
1765
1766 if (blksz == 0 || blkcnt == -1) {
1767 if (blkcnt == -1)
1768 c->flags &= ~CHN_F_HAS_SIZE;
1769 if (c->flags & CHN_F_HAS_SIZE) {
1770 blksz = sndbuf_getblksz(bs);
1771 blkcnt = sndbuf_getblkcnt(bs);
1772 }
1773 } else
1774 c->flags |= CHN_F_HAS_SIZE;
1775
1776 if (c->flags & CHN_F_HAS_SIZE) {
1777 /*
1778 * The application has requested their own blksz/blkcnt.
1779 * Just obey with it, and let them toast alone. We can
1780 * clamp it to the nearest latency profile, but that would
1781 * defeat the purpose of having custom control. The least
1782 * we can do is round it to the nearest ^2 and align it.
1783 */
1784 sblksz = round_blksz(blksz, sndbuf_getalign(bs));
1785 sblkcnt = round_pow2(blkcnt);
1786 limit = 0;
1787 }
1788
1789 if (c->parentchannel != NULL) {
1790 pb = CHN_BUF_PARENT(c, NULL);
1791 CHN_UNLOCK(c);
1792 CHN_LOCK(c->parentchannel);
1793 chn_notify(c->parentchannel, CHN_N_BLOCKSIZE);
1794 CHN_UNLOCK(c->parentchannel);
1795 CHN_LOCK(c);
1796 limit = (limit != 0 && pb != NULL) ?
1797 sndbuf_xbytes(sndbuf_getsize(pb), pb, bs) : 0;
1798 c->timeout = c->parentchannel->timeout;
1799 } else {
1800 hblkcnt = 2;
1801 if (c->flags & CHN_F_HAS_SIZE) {
1802 hblksz = round_blksz(sndbuf_xbytes(sblksz, bs, b),
1803 sndbuf_getalign(b));
1804 hblkcnt = round_pow2(sndbuf_getblkcnt(bs));
1805 } else
1806 chn_calclatency(c->direction, latency,
1807 sndbuf_getalign(b),
1808 sndbuf_getalign(b) * sndbuf_getspd(b),
1809 CHN_2NDBUFMAXSIZE, &hblksz, &hblkcnt);
1810
1811 if ((hblksz << 1) > sndbuf_getmaxsize(b))
1812 hblksz = round_blksz(sndbuf_getmaxsize(b) >> 1,
1813 sndbuf_getalign(b));
1814
1815 while ((hblksz * hblkcnt) > sndbuf_getmaxsize(b)) {
1816 if (hblkcnt < 4)
1817 hblksz >>= 1;
1818 else
1819 hblkcnt >>= 1;
1820 }
1821
1822 hblksz -= hblksz % sndbuf_getalign(b);
1823
1824 #if 0
1825 hblksz = sndbuf_getmaxsize(b) >> 1;
1826 hblksz -= hblksz % sndbuf_getalign(b);
1827 hblkcnt = 2;
1828 #endif
1829
1830 CHN_UNLOCK(c);
1831 if (chn_usefrags == 0 ||
1832 CHANNEL_SETFRAGMENTS(c->methods, c->devinfo,
1833 hblksz, hblkcnt) != 0)
1834 sndbuf_setblksz(b, CHANNEL_SETBLOCKSIZE(c->methods,
1835 c->devinfo, hblksz));
1836 CHN_LOCK(c);
1837
1838 if (!CHN_EMPTY(c, children)) {
1839 sblksz = round_blksz(
1840 sndbuf_xbytes(sndbuf_getsize(b) >> 1, b, bs),
1841 sndbuf_getalign(bs));
1842 sblkcnt = 2;
1843 limit = 0;
1844 } else if (limit != 0)
1845 limit = sndbuf_xbytes(sndbuf_getsize(b), b, bs);
1846
1847 /*
1848 * Interrupt timeout
1849 */
1850 c->timeout = ((u_int64_t)hz * sndbuf_getsize(b)) /
1851 ((u_int64_t)sndbuf_getspd(b) * sndbuf_getalign(b));
1852 if (c->timeout < 1)
1853 c->timeout = 1;
1854 }
1855
1856 if (limit > CHN_2NDBUFMAXSIZE)
1857 limit = CHN_2NDBUFMAXSIZE;
1858
1859 #if 0
1860 while (limit > 0 && (sblksz * sblkcnt) > limit) {
1861 if (sblkcnt < 4)
1862 break;
1863 sblkcnt >>= 1;
1864 }
1865 #endif
1866
1867 while ((sblksz * sblkcnt) < limit)
1868 sblkcnt <<= 1;
1869
1870 while ((sblksz * sblkcnt) > CHN_2NDBUFMAXSIZE) {
1871 if (sblkcnt < 4)
1872 sblksz >>= 1;
1873 else
1874 sblkcnt >>= 1;
1875 }
1876
1877 sblksz -= sblksz % sndbuf_getalign(bs);
1878
1879 if (sndbuf_getblkcnt(bs) != sblkcnt || sndbuf_getblksz(bs) != sblksz ||
1880 sndbuf_getsize(bs) != (sblkcnt * sblksz)) {
1881 ret = sndbuf_remalloc(bs, sblkcnt, sblksz);
1882 if (ret != 0) {
1883 device_printf(c->dev, "%s(): Failed: %d %d\n",
1884 __func__, sblkcnt, sblksz);
1885 return ret;
1886 }
1887 }
1888
1889 /*
1890 * OSSv4 docs: "By default OSS will set the low water level equal
1891 * to the fragment size which is optimal in most cases."
1892 */
1893 c->lw = sndbuf_getblksz(bs);
1894 chn_resetbuf(c);
1895
1896 if (snd_verbose > 3)
1897 device_printf(c->dev, "%s(): %s (%s) timeout=%u "
1898 "b[%d/%d/%d] bs[%d/%d/%d] limit=%d\n",
1899 __func__, CHN_DIRSTR(c),
1900 (c->flags & CHN_F_VIRTUAL) ? "virtual" : "hardware",
1901 c->timeout,
1902 sndbuf_getsize(b), sndbuf_getblksz(b),
1903 sndbuf_getblkcnt(b),
1904 sndbuf_getsize(bs), sndbuf_getblksz(bs),
1905 sndbuf_getblkcnt(bs), limit);
1906
1907 return 0;
1908 }
1909
1910 int
1911 chn_setlatency(struct pcm_channel *c, int latency)
1912 {
1913 CHN_LOCKASSERT(c);
1914 /* Destroy blksz/blkcnt, enforce latency profile. */
1915 return chn_resizebuf(c, latency, -1, 0);
1916 }
1917
1918 int
1919 chn_setblocksize(struct pcm_channel *c, int blkcnt, int blksz)
1920 {
1921 CHN_LOCKASSERT(c);
1922 /* Destroy latency profile, enforce blksz/blkcnt */
1923 return chn_resizebuf(c, -1, blkcnt, blksz);
1924 }
1925
1926 int
1927 chn_setparam(struct pcm_channel *c, uint32_t format, uint32_t speed)
1928 {
1929 struct pcmchan_caps *caps;
1930 uint32_t hwspeed, delta;
1931 int ret;
1932
1933 CHN_LOCKASSERT(c);
1934
1935 if (speed < 1 || format == 0 || CHN_STARTED(c))
1936 return (EINVAL);
1937
1938 c->format = format;
1939 c->speed = speed;
1940
1941 caps = chn_getcaps(c);
1942
1943 hwspeed = speed;
1944 RANGE(hwspeed, caps->minspeed, caps->maxspeed);
1945
1946 sndbuf_setspd(c->bufhard, CHANNEL_SETSPEED(c->methods, c->devinfo,
1947 hwspeed));
1948 hwspeed = sndbuf_getspd(c->bufhard);
1949
1950 delta = (hwspeed > speed) ? (hwspeed - speed) : (speed - hwspeed);
1951
1952 if (delta <= feeder_rate_round)
1953 c->speed = hwspeed;
1954
1955 ret = feeder_chain(c);
1956
1957 if (ret == 0)
1958 ret = CHANNEL_SETFORMAT(c->methods, c->devinfo,
1959 sndbuf_getfmt(c->bufhard));
1960
1961 if (ret == 0)
1962 ret = chn_resizebuf(c, -2, 0, 0);
1963
1964 return (ret);
1965 }
1966
1967 int
1968 chn_setspeed(struct pcm_channel *c, uint32_t speed)
1969 {
1970 uint32_t oldformat, oldspeed, format;
1971 int ret;
1972
1973 #if 0
1974 /* XXX force 48k */
1975 if (c->format & AFMT_PASSTHROUGH)
1976 speed = AFMT_PASSTHROUGH_RATE;
1977 #endif
1978
1979 oldformat = c->format;
1980 oldspeed = c->speed;
1981 format = oldformat;
1982
1983 ret = chn_setparam(c, format, speed);
1984 if (ret != 0) {
1985 if (snd_verbose > 3)
1986 device_printf(c->dev,
1987 "%s(): Setting speed %d failed, "
1988 "falling back to %d\n",
1989 __func__, speed, oldspeed);
1990 chn_setparam(c, c->format, oldspeed);
1991 }
1992
1993 return (ret);
1994 }
1995
1996 int
1997 chn_setformat(struct pcm_channel *c, uint32_t format)
1998 {
1999 uint32_t oldformat, oldspeed, speed;
2000 int ret;
2001
2002 /* XXX force stereo */
2003 if (format & AFMT_PASSTHROUGH)
2004 format = SND_FORMAT(format, AFMT_PASSTHROUGH_CHANNEL,
2005 AFMT_PASSTHROUGH_EXTCHANNEL);
2006
2007 oldformat = c->format;
2008 oldspeed = c->speed;
2009 speed = oldspeed;
2010
2011 ret = chn_setparam(c, format, speed);
2012 if (ret != 0) {
2013 if (snd_verbose > 3)
2014 device_printf(c->dev,
2015 "%s(): Format change 0x%08x failed, "
2016 "falling back to 0x%08x\n",
2017 __func__, format, oldformat);
2018 chn_setparam(c, oldformat, oldspeed);
2019 }
2020
2021 return (ret);
2022 }
2023
2024 void
2025 chn_syncstate(struct pcm_channel *c)
2026 {
2027 struct snddev_info *d;
2028 struct snd_mixer *m;
2029
2030 d = (c != NULL) ? c->parentsnddev : NULL;
2031 m = (d != NULL && d->mixer_dev != NULL) ? d->mixer_dev->si_drv1 :
2032 NULL;
2033
2034 if (d == NULL || m == NULL)
2035 return;
2036
2037 CHN_LOCKASSERT(c);
2038
2039 if (c->feederflags & (1 << FEEDER_VOLUME)) {
2040 uint32_t parent;
2041 int vol, pvol, left, right, center;
2042
2043 if (c->direction == PCMDIR_PLAY &&
2044 (d->flags & SD_F_SOFTPCMVOL)) {
2045 /* CHN_UNLOCK(c); */
2046 vol = mix_get(m, SOUND_MIXER_PCM);
2047 parent = mix_getparent(m, SOUND_MIXER_PCM);
2048 if (parent != SOUND_MIXER_NONE)
2049 pvol = mix_get(m, parent);
2050 else
2051 pvol = 100 | (100 << 8);
2052 /* CHN_LOCK(c); */
2053 } else {
2054 vol = 100 | (100 << 8);
2055 pvol = vol;
2056 }
2057
2058 if (vol == -1) {
2059 device_printf(c->dev,
2060 "Soft PCM Volume: Failed to read pcm "
2061 "default value\n");
2062 vol = 100 | (100 << 8);
2063 }
2064
2065 if (pvol == -1) {
2066 device_printf(c->dev,
2067 "Soft PCM Volume: Failed to read parent "
2068 "default value\n");
2069 pvol = 100 | (100 << 8);
2070 }
2071
2072 left = ((vol & 0x7f) * (pvol & 0x7f)) / 100;
2073 right = (((vol >> 8) & 0x7f) * ((pvol >> 8) & 0x7f)) / 100;
2074 center = (left + right) >> 1;
2075
2076 chn_setvolume_multi(c, SND_VOL_C_MASTER, left, right, center);
2077 }
2078
2079 if (c->feederflags & (1 << FEEDER_EQ)) {
2080 struct pcm_feeder *f;
2081 int treble, bass, state;
2082
2083 /* CHN_UNLOCK(c); */
2084 treble = mix_get(m, SOUND_MIXER_TREBLE);
2085 bass = mix_get(m, SOUND_MIXER_BASS);
2086 /* CHN_LOCK(c); */
2087
2088 if (treble == -1)
2089 treble = 50;
2090 else
2091 treble = ((treble & 0x7f) +
2092 ((treble >> 8) & 0x7f)) >> 1;
2093
2094 if (bass == -1)
2095 bass = 50;
2096 else
2097 bass = ((bass & 0x7f) + ((bass >> 8) & 0x7f)) >> 1;
2098
2099 f = chn_findfeeder(c, FEEDER_EQ);
2100 if (f != NULL) {
2101 if (FEEDER_SET(f, FEEDEQ_TREBLE, treble) != 0)
2102 device_printf(c->dev,
2103 "EQ: Failed to set treble -- %d\n",
2104 treble);
2105 if (FEEDER_SET(f, FEEDEQ_BASS, bass) != 0)
2106 device_printf(c->dev,
2107 "EQ: Failed to set bass -- %d\n",
2108 bass);
2109 if (FEEDER_SET(f, FEEDEQ_PREAMP, d->eqpreamp) != 0)
2110 device_printf(c->dev,
2111 "EQ: Failed to set preamp -- %d\n",
2112 d->eqpreamp);
2113 if (d->flags & SD_F_EQ_BYPASSED)
2114 state = FEEDEQ_BYPASS;
2115 else if (d->flags & SD_F_EQ_ENABLED)
2116 state = FEEDEQ_ENABLE;
2117 else
2118 state = FEEDEQ_DISABLE;
2119 if (FEEDER_SET(f, FEEDEQ_STATE, state) != 0)
2120 device_printf(c->dev,
2121 "EQ: Failed to set state -- %d\n", state);
2122 }
2123 }
2124 }
2125
2126 int
2127 chn_trigger(struct pcm_channel *c, int go)
2128 {
2129 #ifdef DEV_ISA
2130 struct snd_dbuf *b = c->bufhard;
2131 #endif
2132 struct snddev_info *d = c->parentsnddev;
2133 int ret;
2134
2135 CHN_LOCKASSERT(c);
2136 #ifdef DEV_ISA
2137 if (SND_DMA(b) && (go == PCMTRIG_EMLDMAWR || go == PCMTRIG_EMLDMARD))
2138 sndbuf_dmabounce(b);
2139 #endif
2140 if (!PCMTRIG_COMMON(go))
2141 return (CHANNEL_TRIGGER(c->methods, c->devinfo, go));
2142
2143 if (go == c->trigger)
2144 return (0);
2145
2146 ret = CHANNEL_TRIGGER(c->methods, c->devinfo, go);
2147 if (ret != 0)
2148 return (ret);
2149
2150 switch (go) {
2151 case PCMTRIG_START:
2152 if (snd_verbose > 3)
2153 device_printf(c->dev,
2154 "%s() %s: calling go=0x%08x , "
2155 "prev=0x%08x\n", __func__, c->name, go,
2156 c->trigger);
2157 if (c->trigger != PCMTRIG_START) {
2158 c->trigger = go;
2159 CHN_UNLOCK(c);
2160 PCM_LOCK(d);
2161 CHN_INSERT_HEAD(d, c, channels.pcm.busy);
2162 PCM_UNLOCK(d);
2163 CHN_LOCK(c);
2164 chn_syncstate(c);
2165 }
2166 break;
2167 case PCMTRIG_STOP:
2168 case PCMTRIG_ABORT:
2169 if (snd_verbose > 3)
2170 device_printf(c->dev,
2171 "%s() %s: calling go=0x%08x , "
2172 "prev=0x%08x\n", __func__, c->name, go,
2173 c->trigger);
2174 if (c->trigger == PCMTRIG_START) {
2175 c->trigger = go;
2176 CHN_UNLOCK(c);
2177 PCM_LOCK(d);
2178 CHN_REMOVE(d, c, channels.pcm.busy);
2179 PCM_UNLOCK(d);
2180 CHN_LOCK(c);
2181 }
2182 break;
2183 default:
2184 break;
2185 }
2186
2187 return (0);
2188 }
2189
2190 /**
2191 * @brief Queries sound driver for sample-aligned hardware buffer pointer index
2192 *
2193 * This function obtains the hardware pointer location, then aligns it to
2194 * the current bytes-per-sample value before returning. (E.g., a channel
2195 * running in 16 bit stereo mode would require 4 bytes per sample, so a
2196 * hwptr value ranging from 32-35 would be returned as 32.)
2197 *
2198 * @param c PCM channel context
2199 * @returns sample-aligned hardware buffer pointer index
2200 */
2201 int
2202 chn_getptr(struct pcm_channel *c)
2203 {
2204 int hwptr;
2205
2206 CHN_LOCKASSERT(c);
2207 hwptr = (CHN_STARTED(c)) ? CHANNEL_GETPTR(c->methods, c->devinfo) : 0;
2208 return (hwptr - (hwptr % sndbuf_getalign(c->bufhard)));
2209 }
2210
2211 struct pcmchan_caps *
2212 chn_getcaps(struct pcm_channel *c)
2213 {
2214 CHN_LOCKASSERT(c);
2215 return CHANNEL_GETCAPS(c->methods, c->devinfo);
2216 }
2217
2218 u_int32_t
2219 chn_getformats(struct pcm_channel *c)
2220 {
2221 u_int32_t *fmtlist, fmts;
2222 int i;
2223
2224 fmtlist = chn_getcaps(c)->fmtlist;
2225 fmts = 0;
2226 for (i = 0; fmtlist[i]; i++)
2227 fmts |= fmtlist[i];
2228
2229 /* report software-supported formats */
2230 if (!CHN_BITPERFECT(c) && report_soft_formats)
2231 fmts |= AFMT_CONVERTIBLE;
2232
2233 return (AFMT_ENCODING(fmts));
2234 }
2235
2236 int
2237 chn_notify(struct pcm_channel *c, u_int32_t flags)
2238 {
2239 struct pcm_channel *ch;
2240 struct pcmchan_caps *caps;
2241 uint32_t bestformat, bestspeed, besthwformat, *vchanformat, *vchanrate;
2242 uint32_t vpflags;
2243 int dirty, err, run, nrun;
2244
2245 CHN_LOCKASSERT(c);
2246
2247 if (CHN_EMPTY(c, children))
2248 return (ENODEV);
2249
2250 err = 0;
2251
2252 /*
2253 * If the hwchan is running, we can't change its rate, format or
2254 * blocksize
2255 */
2256 run = (CHN_STARTED(c)) ? 1 : 0;
2257 if (run)
2258 flags &= CHN_N_VOLUME | CHN_N_TRIGGER;
2259
2260 if (flags & CHN_N_RATE) {
2261 /*
2262 * XXX I'll make good use of this someday.
2263 * However this is currently being superseded by
2264 * the availability of CHN_F_VCHAN_DYNAMIC.
2265 */
2266 }
2267
2268 if (flags & CHN_N_FORMAT) {
2269 /*
2270 * XXX I'll make good use of this someday.
2271 * However this is currently being superseded by
2272 * the availability of CHN_F_VCHAN_DYNAMIC.
2273 */
2274 }
2275
2276 if (flags & CHN_N_VOLUME) {
2277 /*
2278 * XXX I'll make good use of this someday, though
2279 * soft volume control is currently pretty much
2280 * integrated.
2281 */
2282 }
2283
2284 if (flags & CHN_N_BLOCKSIZE) {
2285 /*
2286 * Set to default latency profile
2287 */
2288 chn_setlatency(c, chn_latency);
2289 }
2290
2291 if ((flags & CHN_N_TRIGGER) && !(c->flags & CHN_F_VCHAN_DYNAMIC)) {
2292 nrun = CHN_EMPTY(c, children.busy) ? 0 : 1;
2293 if (nrun && !run)
2294 err = chn_start(c, 1);
2295 if (!nrun && run)
2296 chn_abort(c);
2297 flags &= ~CHN_N_TRIGGER;
2298 }
2299
2300 if (flags & CHN_N_TRIGGER) {
2301 if (c->direction == PCMDIR_PLAY) {
2302 vchanformat = &c->parentsnddev->pvchanformat;
2303 vchanrate = &c->parentsnddev->pvchanrate;
2304 } else {
2305 vchanformat = &c->parentsnddev->rvchanformat;
2306 vchanrate = &c->parentsnddev->rvchanrate;
2307 }
2308
2309 /* Dynamic Virtual Channel */
2310 if (!(c->flags & CHN_F_VCHAN_ADAPTIVE)) {
2311 bestformat = *vchanformat;
2312 bestspeed = *vchanrate;
2313 } else {
2314 bestformat = 0;
2315 bestspeed = 0;
2316 }
2317
2318 besthwformat = 0;
2319 nrun = 0;
2320 caps = chn_getcaps(c);
2321 dirty = 0;
2322 vpflags = 0;
2323
2324 CHN_FOREACH(ch, c, children.busy) {
2325 CHN_LOCK(ch);
2326 if ((ch->format & AFMT_PASSTHROUGH) &&
2327 snd_fmtvalid(ch->format, caps->fmtlist)) {
2328 bestformat = ch->format;
2329 bestspeed = ch->speed;
2330 CHN_UNLOCK(ch);
2331 vpflags = CHN_F_PASSTHROUGH;
2332 nrun++;
2333 break;
2334 }
2335 if ((ch->flags & CHN_F_EXCLUSIVE) && vpflags == 0) {
2336 if (c->flags & CHN_F_VCHAN_ADAPTIVE) {
2337 bestspeed = ch->speed;
2338 RANGE(bestspeed, caps->minspeed,
2339 caps->maxspeed);
2340 besthwformat = snd_fmtbest(ch->format,
2341 caps->fmtlist);
2342 if (besthwformat != 0)
2343 bestformat = besthwformat;
2344 }
2345 CHN_UNLOCK(ch);
2346 vpflags = CHN_F_EXCLUSIVE;
2347 nrun++;
2348 continue;
2349 }
2350 if (!(c->flags & CHN_F_VCHAN_ADAPTIVE) ||
2351 vpflags != 0) {
2352 CHN_UNLOCK(ch);
2353 nrun++;
2354 continue;
2355 }
2356 if (ch->speed > bestspeed) {
2357 bestspeed = ch->speed;
2358 RANGE(bestspeed, caps->minspeed,
2359 caps->maxspeed);
2360 }
2361 besthwformat = snd_fmtbest(ch->format, caps->fmtlist);
2362 if (!(besthwformat & AFMT_VCHAN)) {
2363 CHN_UNLOCK(ch);
2364 nrun++;
2365 continue;
2366 }
2367 if (AFMT_CHANNEL(besthwformat) >
2368 AFMT_CHANNEL(bestformat))
2369 bestformat = besthwformat;
2370 else if (AFMT_CHANNEL(besthwformat) ==
2371 AFMT_CHANNEL(bestformat) &&
2372 AFMT_BIT(besthwformat) > AFMT_BIT(bestformat))
2373 bestformat = besthwformat;
2374 CHN_UNLOCK(ch);
2375 nrun++;
2376 }
2377
2378 if (bestformat == 0)
2379 bestformat = c->format;
2380 if (bestspeed == 0)
2381 bestspeed = c->speed;
2382
2383 if (bestformat != c->format || bestspeed != c->speed)
2384 dirty = 1;
2385
2386 c->flags &= ~(CHN_F_PASSTHROUGH | CHN_F_EXCLUSIVE);
2387 c->flags |= vpflags;
2388
2389 if (nrun && !run) {
2390 if (dirty) {
2391 bestspeed = CHANNEL_SETSPEED(c->methods,
2392 c->devinfo, bestspeed);
2393 err = chn_reset(c, bestformat, bestspeed);
2394 }
2395 if (err == 0 && dirty) {
2396 CHN_FOREACH(ch, c, children.busy) {
2397 CHN_LOCK(ch);
2398 if (VCHAN_SYNC_REQUIRED(ch))
2399 vchan_sync(ch);
2400 CHN_UNLOCK(ch);
2401 }
2402 }
2403 if (err == 0) {
2404 if (dirty)
2405 c->flags |= CHN_F_DIRTY;
2406 err = chn_start(c, 1);
2407 }
2408 }
2409
2410 if (nrun && run && dirty) {
2411 chn_abort(c);
2412 bestspeed = CHANNEL_SETSPEED(c->methods, c->devinfo,
2413 bestspeed);
2414 err = chn_reset(c, bestformat, bestspeed);
2415 if (err == 0) {
2416 CHN_FOREACH(ch, c, children.busy) {
2417 CHN_LOCK(ch);
2418 if (VCHAN_SYNC_REQUIRED(ch))
2419 vchan_sync(ch);
2420 CHN_UNLOCK(ch);
2421 }
2422 }
2423 if (err == 0) {
2424 c->flags |= CHN_F_DIRTY;
2425 err = chn_start(c, 1);
2426 }
2427 }
2428
2429 if (err == 0 && !(bestformat & AFMT_PASSTHROUGH) &&
2430 (bestformat & AFMT_VCHAN)) {
2431 *vchanformat = bestformat;
2432 *vchanrate = bestspeed;
2433 }
2434
2435 if (!nrun && run) {
2436 c->flags &= ~(CHN_F_PASSTHROUGH | CHN_F_EXCLUSIVE);
2437 bestformat = *vchanformat;
2438 bestspeed = *vchanrate;
2439 chn_abort(c);
2440 if (c->format != bestformat || c->speed != bestspeed)
2441 chn_reset(c, bestformat, bestspeed);
2442 }
2443 }
2444
2445 return (err);
2446 }
2447
2448 /**
2449 * @brief Fetch array of supported discrete sample rates
2450 *
2451 * Wrapper for CHANNEL_GETRATES. Please see channel_if.m:getrates() for
2452 * detailed information.
2453 *
2454 * @note If the operation isn't supported, this function will just return 0
2455 * (no rates in the array), and *rates will be set to NULL. Callers
2456 * should examine rates @b only if this function returns non-zero.
2457 *
2458 * @param c pcm channel to examine
2459 * @param rates pointer to array of integers; rate table will be recorded here
2460 *
2461 * @return number of rates in the array pointed to be @c rates
2462 */
2463 int
2464 chn_getrates(struct pcm_channel *c, int **rates)
2465 {
2466 KASSERT(rates != NULL, ("rates is null"));
2467 CHN_LOCKASSERT(c);
2468 return CHANNEL_GETRATES(c->methods, c->devinfo, rates);
2469 }
2470
2471 /**
2472 * @brief Remove channel from a sync group, if there is one.
2473 *
2474 * This function is initially intended for the following conditions:
2475 * - Starting a syncgroup (@c SNDCTL_DSP_SYNCSTART ioctl)
2476 * - Closing a device. (A channel can't be destroyed if it's still in use.)
2477 *
2478 * @note Before calling this function, the syncgroup list mutex must be
2479 * held. (Consider pcm_channel::sm protected by the SG list mutex
2480 * whether @c c is locked or not.)
2481 *
2482 * @param c channel device to be started or closed
2483 * @returns If this channel was the only member of a group, the group ID
2484 * is returned to the caller so that the caller can release it
2485 * via free_unr() after giving up the syncgroup lock. Else it
2486 * returns 0.
2487 */
2488 int
2489 chn_syncdestroy(struct pcm_channel *c)
2490 {
2491 struct pcmchan_syncmember *sm;
2492 struct pcmchan_syncgroup *sg;
2493 int sg_id;
2494
2495 sg_id = 0;
2496
2497 PCM_SG_LOCKASSERT(MA_OWNED);
2498
2499 if (c->sm != NULL) {
2500 sm = c->sm;
2501 sg = sm->parent;
2502 c->sm = NULL;
2503
2504 KASSERT(sg != NULL, ("syncmember has null parent"));
2505
2506 SLIST_REMOVE(&sg->members, sm, pcmchan_syncmember, link);
2507 free(sm, M_DEVBUF);
2508
2509 if (SLIST_EMPTY(&sg->members)) {
2510 SLIST_REMOVE(&snd_pcm_syncgroups, sg, pcmchan_syncgroup, link);
2511 sg_id = sg->id;
2512 free(sg, M_DEVBUF);
2513 }
2514 }
2515
2516 return sg_id;
2517 }
2518
2519 #ifdef OSSV4_EXPERIMENT
2520 int
2521 chn_getpeaks(struct pcm_channel *c, int *lpeak, int *rpeak)
2522 {
2523 CHN_LOCKASSERT(c);
2524 return CHANNEL_GETPEAKS(c->methods, c->devinfo, lpeak, rpeak);
2525 }
2526 #endif
Cache object: e110a89e8dbbc18ba8cfc5c7fb5a4c6c
|