1/*	$NetBSD: audio.c,v 1.146 2024/05/27 02:47:53 nia Exp $	*/
2
3/*-
4 * Copyright (c) 2008 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Andrew Doran.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 *    notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 *    notice, this list of conditions and the following disclaimer in the
17 *    documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32/*
33 * Copyright (c) 1991-1993 Regents of the University of California.
34 * All rights reserved.
35 *
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions
38 * are met:
39 * 1. Redistributions of source code must retain the above copyright
40 *    notice, this list of conditions and the following disclaimer.
41 * 2. Redistributions in binary form must reproduce the above copyright
42 *    notice, this list of conditions and the following disclaimer in the
43 *    documentation and/or other materials provided with the distribution.
44 * 3. All advertising materials mentioning features or use of this software
45 *    must display the following acknowledgement:
46 *	This product includes software developed by the Computer Systems
47 *	Engineering Group at Lawrence Berkeley Laboratory.
48 * 4. Neither the name of the University nor of the Laboratory may be used
49 *    to endorse or promote products derived from this software without
50 *    specific prior written permission.
51 *
52 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
53 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
54 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
55 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
56 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
57 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
58 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
59 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
60 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
61 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
62 * SUCH DAMAGE.
63 */
64
65/*
66 * Terminology: "sample", "channel", "frame", "block", "track":
67 *
68 *  channel       frame
69 *   |           ........
70 *   v           :      :                                    \
71 *        +------:------:------:-  -+------+ : +------+-..   |
72 *  #0(L) |sample|sample|sample| .. |sample| : |sample|      |
73 *        +------:------:------:-  -+------+ : +------+-..   |
74 *  #1(R) |sample|sample|sample| .. |sample| : |sample|      |
75 *        +------:------:------:-  -+------+ : +------+-..   | track
76 *   :           :      :                    :               |
77 *        +------:------:------:-  -+------+ : +------+-..   |
78 *        |sample|sample|sample| .. |sample| : |sample|      |
79 *        +------:------:------:-  -+------+ : +------+-..   |
80 *               :      :                                    /
81 *               ........
82 *
83 *        \--------------------------------/   \--------..
84 *                     block
85 *
86 * - A "frame" is the minimum unit in the time axis direction, and consists
87 *   of samples for the number of channels.
88 * - A "block" is basic length of processing.  The audio layer basically
89 *   handles audio data stream block by block, asks underlying hardware to
90 *   process them block by block, and then the hardware raises interrupt by
91 *   each block.
92 * - A "track" is single completed audio stream.
93 *
94 * For example, the hardware block is assumed to be 10 msec, and your audio
95 * track consists of 2.1(=3) channels 44.1kHz 16bit PCM,
96 *
97 * "channel" = 3
98 * "sample" = 2 [bytes]
99 * "frame" = 2 [bytes/sample] * 3 [channels] = 6 [bytes]
100 * "block" = 44100 [Hz] * (10/1000) [seconds] * 6 [bytes/frame] = 2646 [bytes]
101 *
102 * The terminologies shown here are only for this MI audio layer.  Note that
103 * different terminologies may be used in each manufacturer's datasheet, and
104 * each MD driver may follow it.  For example, what we call a "block" is
105 * called a "frame" in sys/dev/pci/yds.c.
106 */
107
108/*
109 * Locking: there are three locks per device.
110 *
111 * - sc_lock, provided by the underlying driver.  This is an adaptive lock,
112 *   returned in the second parameter to hw_if->get_locks().  It is known
113 *   as the "thread lock".
114 *
115 *   It serializes access to state in all places except the
116 *   driver's interrupt service routine.  This lock is taken from process
117 *   context (example: access to /dev/audio).  It is also taken from soft
118 *   interrupt handlers in this module, primarily to serialize delivery of
119 *   wakeups.  This lock may be used/provided by modules external to the
120 *   audio subsystem, so take care not to introduce a lock order problem.
121 *   LONG TERM SLEEPS MUST NOT OCCUR WITH THIS LOCK HELD.
122 *
123 * - sc_intr_lock, provided by the underlying driver.  This may be either a
124 *   spinlock (at IPL_SCHED or IPL_VM) or an adaptive lock (IPL_NONE or
125 *   IPL_SOFT*), returned in the first parameter to hw_if->get_locks().  It
126 *   is known as the "interrupt lock".
127 *
128 *   It provides atomic access to the device's hardware state, and to audio
129 *   channel data that may be accessed by the hardware driver's ISR.
130 *   In all places outside the ISR, sc_lock must be held before taking
131 *   sc_intr_lock.  This is to ensure that groups of hardware operations are
132 *   made atomically.  SLEEPS CANNOT OCCUR WITH THIS LOCK HELD.
133 *
134 * - sc_exlock, private to this module.  This is a variable protected by
135 *   sc_lock.  It is known as the "critical section".
136 *   Some operations release sc_lock in order to allocate memory, to wait
137 *   for in-flight I/O to complete, to copy to/from user context, etc.
138 *   sc_exlock provides a critical section even under the circumstance.
139 *   "+" in following list indicates the interfaces which necessary to be
140 *   protected by sc_exlock.
141 *
142 * List of hardware interface methods, and which locks are held when each
143 * is called by this module:
144 *
145 *	METHOD			INTR	THREAD  NOTES
146 *	----------------------- ------- -------	-------------------------
147 *	open 			x	x +
148 *	close 			x	x +
149 *	query_format		-	x
150 *	set_format		-	x
151 *	round_blocksize		-	x
152 *	commit_settings		-	x
153 *	init_output 		x	x
154 *	init_input 		x	x
155 *	start_output 		x	x +
156 *	start_input 		x	x +
157 *	halt_output 		x	x +
158 *	halt_input 		x	x +
159 *	speaker_ctl 		x	x
160 *	getdev 			-	-
161 *	set_port 		-	x +
162 *	get_port 		-	x +
163 *	query_devinfo 		-	x
164 *	allocm 			-	- +
165 *	freem 			-	- +
166 *	round_buffersize 	-	x
167 *	get_props 		-	-	Called at attach time
168 *	trigger_output 		x	x +
169 *	trigger_input 		x	x +
170 *	dev_ioctl 		-	x
171 *	get_locks 		-	-	Called at attach time
172 *
173 * In addition, there is an additional lock.
174 *
175 * - track->lock.  This is an atomic variable and is similar to the
176 *   "interrupt lock".  This is one for each track.  If any thread context
177 *   (and software interrupt context) and hardware interrupt context who
178 *   want to access some variables on this track, they must acquire this
179 *   lock before.  It protects track's consistency between hardware
180 *   interrupt context and others.
181 */
182
183#include <sys/cdefs.h>
184__KERNEL_RCSID(0, "$NetBSD: audio.c,v 1.146 2024/05/27 02:47:53 nia Exp $");
185
186#ifdef _KERNEL_OPT
187#include "audio.h"
188#include "midi.h"
189#endif
190
191#if NAUDIO > 0
192
193#include <sys/types.h>
194#include <sys/param.h>
195#include <sys/atomic.h>
196#include <sys/audioio.h>
197#include <sys/conf.h>
198#include <sys/cpu.h>
199#include <sys/device.h>
200#include <sys/fcntl.h>
201#include <sys/file.h>
202#include <sys/filedesc.h>
203#include <sys/intr.h>
204#include <sys/ioctl.h>
205#include <sys/kauth.h>
206#include <sys/kernel.h>
207#include <sys/kmem.h>
208#include <sys/lock.h>
209#include <sys/malloc.h>
210#include <sys/mman.h>
211#include <sys/module.h>
212#include <sys/poll.h>
213#include <sys/proc.h>
214#include <sys/queue.h>
215#include <sys/select.h>
216#include <sys/signalvar.h>
217#include <sys/stat.h>
218#include <sys/sysctl.h>
219#include <sys/systm.h>
220#include <sys/syslog.h>
221#include <sys/vnode.h>
222
223#include <dev/audio/audio_if.h>
224#include <dev/audio/audiovar.h>
225#include <dev/audio/audiodef.h>
226#include <dev/audio/linear.h>
227#include <dev/audio/mulaw.h>
228
229#include <machine/endian.h>
230
231#include <uvm/uvm_extern.h>
232
233#include "ioconf.h"
234
235/*
236 * 0: No debug logs
237 * 1: action changes like open/close/set_format/mmap...
238 * 2: + normal operations like read/write/ioctl...
239 * 3: + TRACEs except interrupt
240 * 4: + TRACEs including interrupt
241 */
242//#define AUDIO_DEBUG 1
243
244#if defined(AUDIO_DEBUG)
245
246int audiodebug = AUDIO_DEBUG;
247static void audio_vtrace(struct audio_softc *sc, const char *, const char *,
248	const char *, va_list);
249static void audio_trace(struct audio_softc *sc, const char *, const char *, ...)
250	__printflike(3, 4);
251static void audio_tracet(const char *, audio_track_t *, const char *, ...)
252	__printflike(3, 4);
253static void audio_tracef(const char *, audio_file_t *, const char *, ...)
254	__printflike(3, 4);
255
256/* XXX sloppy memory logger */
257static void audio_mlog_init(void);
258static void audio_mlog_free(void);
259static void audio_mlog_softintr(void *);
260extern void audio_mlog_flush(void);
261extern void audio_mlog_printf(const char *, ...);
262
263static int mlog_refs;		/* reference counter */
264static char *mlog_buf[2];	/* double buffer */
265static int mlog_buflen;		/* buffer length */
266static int mlog_used;		/* used length */
267static int mlog_full;		/* number of dropped lines by buffer full */
268static int mlog_drop;		/* number of dropped lines by busy */
269static volatile uint32_t mlog_inuse;	/* in-use */
270static int mlog_wpage;		/* active page */
271static void *mlog_sih;		/* softint handle */
272
273static void
274audio_mlog_init(void)
275{
276	mlog_refs++;
277	if (mlog_refs > 1)
278		return;
279	mlog_buflen = 4096;
280	mlog_buf[0] = kmem_zalloc(mlog_buflen, KM_SLEEP);
281	mlog_buf[1] = kmem_zalloc(mlog_buflen, KM_SLEEP);
282	mlog_used = 0;
283	mlog_full = 0;
284	mlog_drop = 0;
285	mlog_inuse = 0;
286	mlog_wpage = 0;
287	mlog_sih = softint_establish(SOFTINT_SERIAL, audio_mlog_softintr, NULL);
288	if (mlog_sih == NULL)
289		printf("%s: softint_establish failed\n", __func__);
290}
291
292static void
293audio_mlog_free(void)
294{
295	mlog_refs--;
296	if (mlog_refs > 0)
297		return;
298
299	audio_mlog_flush();
300	if (mlog_sih)
301		softint_disestablish(mlog_sih);
302	kmem_free(mlog_buf[0], mlog_buflen);
303	kmem_free(mlog_buf[1], mlog_buflen);
304}
305
306/*
307 * Flush memory buffer.
308 * It must not be called from hardware interrupt context.
309 */
310void
311audio_mlog_flush(void)
312{
313	if (mlog_refs == 0)
314		return;
315
316	/* Nothing to do if already in use ? */
317	if (atomic_swap_32(&mlog_inuse, 1) == 1)
318		return;
319	membar_acquire();
320
321	int rpage = mlog_wpage;
322	mlog_wpage ^= 1;
323	mlog_buf[mlog_wpage][0] = '\0';
324	mlog_used = 0;
325
326	atomic_store_release(&mlog_inuse, 0);
327
328	if (mlog_buf[rpage][0] != '\0') {
329		printf("%s", mlog_buf[rpage]);
330		if (mlog_drop > 0)
331			printf("mlog_drop %d\n", mlog_drop);
332		if (mlog_full > 0)
333			printf("mlog_full %d\n", mlog_full);
334	}
335	mlog_full = 0;
336	mlog_drop = 0;
337}
338
339static void
340audio_mlog_softintr(void *cookie)
341{
342	audio_mlog_flush();
343}
344
345void
346audio_mlog_printf(const char *fmt, ...)
347{
348	int len;
349	va_list ap;
350
351	if (atomic_swap_32(&mlog_inuse, 1) == 1) {
352		/* already inuse */
353		mlog_drop++;
354		return;
355	}
356	membar_acquire();
357
358	va_start(ap, fmt);
359	len = vsnprintf(
360	    mlog_buf[mlog_wpage] + mlog_used,
361	    mlog_buflen - mlog_used,
362	    fmt, ap);
363	va_end(ap);
364
365	mlog_used += len;
366	if (mlog_buflen - mlog_used <= 1) {
367		mlog_full++;
368	}
369
370	atomic_store_release(&mlog_inuse, 0);
371
372	if (mlog_sih)
373		softint_schedule(mlog_sih);
374}
375
376/* trace functions */
377static void
378audio_vtrace(struct audio_softc *sc, const char *funcname, const char *header,
379	const char *fmt, va_list ap)
380{
381	char buf[256];
382	int n;
383
384	n = 0;
385	buf[0] = '\0';
386	n += snprintf(buf + n, sizeof(buf) - n, "%s@%d %s",
387	    funcname, device_unit(sc->sc_dev), header);
388	n += vsnprintf(buf + n, sizeof(buf) - n, fmt, ap);
389
390	if (cpu_intr_p()) {
391		audio_mlog_printf("%s\n", buf);
392	} else {
393		audio_mlog_flush();
394		printf("%s\n", buf);
395	}
396}
397
398static void
399audio_trace(struct audio_softc *sc, const char *funcname, const char *fmt, ...)
400{
401	va_list ap;
402
403	va_start(ap, fmt);
404	audio_vtrace(sc, funcname, "", fmt, ap);
405	va_end(ap);
406}
407
408static void
409audio_tracet(const char *funcname, audio_track_t *track, const char *fmt, ...)
410{
411	char hdr[16];
412	va_list ap;
413
414	snprintf(hdr, sizeof(hdr), "#%d ", track->id);
415	va_start(ap, fmt);
416	audio_vtrace(track->mixer->sc, funcname, hdr, fmt, ap);
417	va_end(ap);
418}
419
420static void
421audio_tracef(const char *funcname, audio_file_t *file, const char *fmt, ...)
422{
423	char hdr[32];
424	char phdr[16], rhdr[16];
425	va_list ap;
426
427	phdr[0] = '\0';
428	rhdr[0] = '\0';
429	if (file->ptrack)
430		snprintf(phdr, sizeof(phdr), "#%d", file->ptrack->id);
431	if (file->rtrack)
432		snprintf(rhdr, sizeof(rhdr), "#%d", file->rtrack->id);
433	snprintf(hdr, sizeof(hdr), "{%s,%s} ", phdr, rhdr);
434
435	va_start(ap, fmt);
436	audio_vtrace(file->sc, funcname, hdr, fmt, ap);
437	va_end(ap);
438}
439
440#define DPRINTF(n, fmt...)	do {	\
441	if (audiodebug >= (n)) {	\
442		audio_mlog_flush();	\
443		printf(fmt);		\
444	}				\
445} while (0)
446#define TRACE(n, fmt...)	do { \
447	if (audiodebug >= (n)) audio_trace(sc, __func__, fmt); \
448} while (0)
449#define TRACET(n, t, fmt...)	do { \
450	if (audiodebug >= (n)) audio_tracet(__func__, t, fmt); \
451} while (0)
452#define TRACEF(n, f, fmt...)	do { \
453	if (audiodebug >= (n)) audio_tracef(__func__, f, fmt); \
454} while (0)
455
456struct audio_track_debugbuf {
457	char usrbuf[32];
458	char codec[32];
459	char chvol[32];
460	char chmix[32];
461	char freq[32];
462	char outbuf[32];
463};
464
465static void
466audio_track_bufstat(audio_track_t *track, struct audio_track_debugbuf *buf)
467{
468
469	memset(buf, 0, sizeof(*buf));
470
471	snprintf(buf->outbuf, sizeof(buf->outbuf), " out=%d/%d/%d",
472	    track->outbuf.head, track->outbuf.used, track->outbuf.capacity);
473	if (track->freq.filter)
474		snprintf(buf->freq, sizeof(buf->freq), " f=%d/%d/%d",
475		    track->freq.srcbuf.head,
476		    track->freq.srcbuf.used,
477		    track->freq.srcbuf.capacity);
478	if (track->chmix.filter)
479		snprintf(buf->chmix, sizeof(buf->chmix), " m=%d",
480		    track->chmix.srcbuf.used);
481	if (track->chvol.filter)
482		snprintf(buf->chvol, sizeof(buf->chvol), " v=%d",
483		    track->chvol.srcbuf.used);
484	if (track->codec.filter)
485		snprintf(buf->codec, sizeof(buf->codec), " e=%d",
486		    track->codec.srcbuf.used);
487	snprintf(buf->usrbuf, sizeof(buf->usrbuf), " usr=%d/%d/H%d",
488	    track->usrbuf.head, track->usrbuf.used, track->usrbuf_usedhigh);
489}
490#else
491#define DPRINTF(n, fmt...)	do { } while (0)
492#define TRACE(n, fmt, ...)	do { } while (0)
493#define TRACET(n, t, fmt, ...)	do { } while (0)
494#define TRACEF(n, f, fmt, ...)	do { } while (0)
495#endif
496
497#define SPECIFIED(x)	((x) != ~0)
498#define SPECIFIED_CH(x)	((x) != (u_char)~0)
499
500/*
501 * Default hardware blocksize in msec.
502 *
503 * We use 10 msec for most modern platforms.  This period is good enough to
504 * play audio and video synchronizely.
505 * In contrast, for very old platforms, this is usually too short and too
506 * severe.  Also such platforms usually can not play video confortably, so
507 * it's not so important to make the blocksize shorter.  If the platform
508 * defines its own value as __AUDIO_BLK_MS in its <machine/param.h>, it
509 * uses this instead.
510 *
511 * In either case, you can overwrite AUDIO_BLK_MS by your kernel
512 * configuration file if you wish.
513 */
514#if !defined(AUDIO_BLK_MS)
515# if defined(__AUDIO_BLK_MS)
516#  define AUDIO_BLK_MS __AUDIO_BLK_MS
517# else
518#  define AUDIO_BLK_MS (10)
519# endif
520#endif
521
522/* Device timeout in msec */
523#define AUDIO_TIMEOUT	(3000)
524
525/* #define AUDIO_PM_IDLE */
526#ifdef AUDIO_PM_IDLE
527int audio_idle_timeout = 30;
528#endif
529
530/* Number of elements of async mixer's pid */
531#define AM_CAPACITY	(4)
532
533struct portname {
534	const char *name;
535	int mask;
536};
537
538static int audiomatch(device_t, cfdata_t, void *);
539static void audioattach(device_t, device_t, void *);
540static int audiodetach(device_t, int);
541static int audioactivate(device_t, enum devact);
542static void audiochilddet(device_t, device_t);
543static int audiorescan(device_t, const char *, const int *);
544
545static int audio_modcmd(modcmd_t, void *);
546
547#ifdef AUDIO_PM_IDLE
548static void audio_idle(void *);
549static void audio_activity(device_t, devactive_t);
550#endif
551
552static bool audio_suspend(device_t dv, const pmf_qual_t *);
553static bool audio_resume(device_t dv, const pmf_qual_t *);
554static void audio_volume_down(device_t);
555static void audio_volume_up(device_t);
556static void audio_volume_toggle(device_t);
557
558static void audio_mixer_capture(struct audio_softc *);
559static void audio_mixer_restore(struct audio_softc *);
560
561static void audio_softintr_rd(void *);
562static void audio_softintr_wr(void *);
563
564static int audio_properties(struct audio_softc *);
565static void audio_printf(struct audio_softc *, const char *, ...)
566	__printflike(2, 3);
567static int audio_exlock_mutex_enter(struct audio_softc *);
568static void audio_exlock_mutex_exit(struct audio_softc *);
569static int audio_exlock_enter(struct audio_softc *);
570static void audio_exlock_exit(struct audio_softc *);
571static struct audio_softc *audio_sc_acquire_fromfile(audio_file_t *,
572	struct psref *);
573static void audio_sc_release(struct audio_softc *, struct psref *);
574static int audio_track_waitio(struct audio_softc *, audio_track_t *,
575	const char *mess);
576
577static int audioclose(struct file *);
578static int audioread(struct file *, off_t *, struct uio *, kauth_cred_t, int);
579static int audiowrite(struct file *, off_t *, struct uio *, kauth_cred_t, int);
580static int audioioctl(struct file *, u_long, void *);
581static int audiopoll(struct file *, int);
582static int audiokqfilter(struct file *, struct knote *);
583static int audiommap(struct file *, off_t *, size_t, int, int *, int *,
584	struct uvm_object **, int *);
585static int audiostat(struct file *, struct stat *);
586
587static void filt_audiowrite_detach(struct knote *);
588static int  filt_audiowrite_event(struct knote *, long);
589static void filt_audioread_detach(struct knote *);
590static int  filt_audioread_event(struct knote *, long);
591
592static int audio_open(dev_t, struct audio_softc *, int, int, struct lwp *,
593	audio_file_t **);
594static int audio_close(struct audio_softc *, audio_file_t *);
595static void audio_unlink(struct audio_softc *, audio_file_t *);
596static int audio_read(struct audio_softc *, struct uio *, int, audio_file_t *);
597static int audio_write(struct audio_softc *, struct uio *, int, audio_file_t *);
598static void audio_file_clear(struct audio_softc *, audio_file_t *);
599static int audio_ioctl(dev_t, struct audio_softc *, u_long, void *, int,
600	struct lwp *, audio_file_t *);
601static int audio_poll(struct audio_softc *, int, struct lwp *, audio_file_t *);
602static int audio_kqfilter(struct audio_softc *, audio_file_t *, struct knote *);
603static int audio_mmap(struct audio_softc *, off_t *, size_t, int, int *, int *,
604	struct uvm_object **, int *, audio_file_t *);
605
606static int audioctl_open(dev_t, struct audio_softc *, int, int, struct lwp *);
607
608static void audio_pintr(void *);
609static void audio_rintr(void *);
610
611static int audio_query_devinfo(struct audio_softc *, mixer_devinfo_t *);
612
613static int audio_track_inputblk_as_usrbyte(const audio_track_t *, int);
614static int audio_track_readablebytes(const audio_track_t *);
615static int audio_file_setinfo(struct audio_softc *, audio_file_t *,
616	const struct audio_info *);
617static int audio_track_setinfo_check(audio_track_t *,
618	audio_format2_t *, const struct audio_prinfo *);
619static void audio_track_setinfo_water(audio_track_t *,
620	const struct audio_info *);
621static int audio_hw_setinfo(struct audio_softc *, const struct audio_info *,
622	struct audio_info *);
623static int audio_hw_set_format(struct audio_softc *, int,
624	const audio_format2_t *, const audio_format2_t *,
625	audio_filter_reg_t *, audio_filter_reg_t *);
626static int audiogetinfo(struct audio_softc *, struct audio_info *, int,
627	audio_file_t *);
628static bool audio_can_playback(struct audio_softc *);
629static bool audio_can_capture(struct audio_softc *);
630static int audio_check_params(audio_format2_t *);
631static int audio_mixers_init(struct audio_softc *sc, int,
632	const audio_format2_t *, const audio_format2_t *,
633	const audio_filter_reg_t *, const audio_filter_reg_t *);
634static int audio_select_freq(const struct audio_format *);
635static int audio_hw_probe(struct audio_softc *, audio_format2_t *, int);
636static int audio_hw_validate_format(struct audio_softc *, int,
637	const audio_format2_t *);
638static int audio_mixers_set_format(struct audio_softc *,
639	const struct audio_info *);
640static void audio_mixers_get_format(struct audio_softc *, struct audio_info *);
641static int audio_sysctl_blk_ms(SYSCTLFN_PROTO);
642static int audio_sysctl_multiuser(SYSCTLFN_PROTO);
643#if defined(AUDIO_DEBUG)
644static int audio_sysctl_debug(SYSCTLFN_PROTO);
645static void audio_format2_tostr(char *, size_t, const audio_format2_t *);
646static void audio_print_format2(const char *, const audio_format2_t *) __unused;
647#endif
648
649static void *audio_realloc(void *, size_t);
650static void audio_free_usrbuf(audio_track_t *);
651
652static audio_track_t *audio_track_create(struct audio_softc *,
653	audio_trackmixer_t *);
654static void audio_track_destroy(audio_track_t *);
655static audio_filter_t audio_track_get_codec(audio_track_t *,
656	const audio_format2_t *, const audio_format2_t *);
657static int audio_track_set_format(audio_track_t *, audio_format2_t *);
658static void audio_track_play(audio_track_t *);
659static int audio_track_drain(struct audio_softc *, audio_track_t *);
660static void audio_track_record(audio_track_t *);
661static void audio_track_clear(struct audio_softc *, audio_track_t *);
662
663static int audio_mixer_init(struct audio_softc *, int,
664	const audio_format2_t *, const audio_filter_reg_t *);
665static void audio_mixer_destroy(struct audio_softc *, audio_trackmixer_t *);
666static void audio_pmixer_start(struct audio_softc *, bool);
667static void audio_pmixer_process(struct audio_softc *);
668static void audio_pmixer_agc(audio_trackmixer_t *, int);
669static int  audio_pmixer_mix_track(audio_trackmixer_t *, audio_track_t *, int);
670static void audio_pmixer_output(struct audio_softc *);
671static int  audio_pmixer_halt(struct audio_softc *);
672static void audio_rmixer_start(struct audio_softc *);
673static void audio_rmixer_process(struct audio_softc *);
674static void audio_rmixer_input(struct audio_softc *);
675static int  audio_rmixer_halt(struct audio_softc *);
676
677static void mixer_init(struct audio_softc *);
678static int mixer_open(dev_t, struct audio_softc *, int, int, struct lwp *);
679static int mixer_close(struct audio_softc *, audio_file_t *);
680static int mixer_ioctl(struct audio_softc *, u_long, void *, int, struct lwp *);
681static void mixer_async_add(struct audio_softc *, pid_t);
682static void mixer_async_remove(struct audio_softc *, pid_t);
683static void mixer_signal(struct audio_softc *);
684
685static int au_portof(struct audio_softc *, char *, int);
686
687static void au_setup_ports(struct audio_softc *, struct au_mixer_ports *,
688	mixer_devinfo_t *, const struct portname *);
689static int au_set_lr_value(struct audio_softc *, mixer_ctrl_t *, int, int);
690static int au_get_lr_value(struct audio_softc *, mixer_ctrl_t *, int *, int *);
691static int au_set_gain(struct audio_softc *, struct au_mixer_ports *, int, int);
692static void au_get_gain(struct audio_softc *, struct au_mixer_ports *,
693	u_int *, u_char *);
694static int au_set_port(struct audio_softc *, struct au_mixer_ports *, u_int);
695static int au_get_port(struct audio_softc *, struct au_mixer_ports *);
696static int au_set_monitor_gain(struct audio_softc *, int);
697static int au_get_monitor_gain(struct audio_softc *);
698static int audio_get_port(struct audio_softc *, mixer_ctrl_t *);
699static int audio_set_port(struct audio_softc *, mixer_ctrl_t *);
700
701void audio_mixsample_to_linear(audio_filter_arg_t *);
702
703static __inline struct audio_params
704format2_to_params(const audio_format2_t *f2)
705{
706	audio_params_t p;
707
708	/* validbits/precision <-> precision/stride */
709	p.sample_rate = f2->sample_rate;
710	p.channels    = f2->channels;
711	p.encoding    = f2->encoding;
712	p.validbits   = f2->precision;
713	p.precision   = f2->stride;
714	return p;
715}
716
717static __inline audio_format2_t
718params_to_format2(const struct audio_params *p)
719{
720	audio_format2_t f2;
721
722	/* precision/stride <-> validbits/precision */
723	f2.sample_rate = p->sample_rate;
724	f2.channels    = p->channels;
725	f2.encoding    = p->encoding;
726	f2.precision   = p->validbits;
727	f2.stride      = p->precision;
728	return f2;
729}
730
731/* Return true if this track is a playback track. */
732static __inline bool
733audio_track_is_playback(const audio_track_t *track)
734{
735
736	return ((track->mode & AUMODE_PLAY) != 0);
737}
738
739#if 0
740/* Return true if this track is a recording track. */
741static __inline bool
742audio_track_is_record(const audio_track_t *track)
743{
744
745	return ((track->mode & AUMODE_RECORD) != 0);
746}
747#endif
748
749#if 0 /* XXX Not used yet */
750/*
751 * Convert 0..255 volume used in userland to internal presentation 0..256.
752 */
753static __inline u_int
754audio_volume_to_inner(u_int v)
755{
756
757	return v < 127 ? v : v + 1;
758}
759
760/*
761 * Convert 0..256 internal presentation to 0..255 volume used in userland.
762 */
763static __inline u_int
764audio_volume_to_outer(u_int v)
765{
766
767	return v < 127 ? v : v - 1;
768}
769#endif /* 0 */
770
771static dev_type_open(audioopen);
772/* XXXMRG use more dev_type_xxx */
773
774static int
775audiounit(dev_t dev)
776{
777
778	return AUDIOUNIT(dev);
779}
780
781const struct cdevsw audio_cdevsw = {
782	.d_open = audioopen,
783	.d_close = noclose,
784	.d_read = noread,
785	.d_write = nowrite,
786	.d_ioctl = noioctl,
787	.d_stop = nostop,
788	.d_tty = notty,
789	.d_poll = nopoll,
790	.d_mmap = nommap,
791	.d_kqfilter = nokqfilter,
792	.d_discard = nodiscard,
793	.d_cfdriver = &audio_cd,
794	.d_devtounit = audiounit,
795	.d_flag = D_OTHER | D_MPSAFE
796};
797
798const struct fileops audio_fileops = {
799	.fo_name = "audio",
800	.fo_read = audioread,
801	.fo_write = audiowrite,
802	.fo_ioctl = audioioctl,
803	.fo_fcntl = fnullop_fcntl,
804	.fo_stat = audiostat,
805	.fo_poll = audiopoll,
806	.fo_close = audioclose,
807	.fo_mmap = audiommap,
808	.fo_kqfilter = audiokqfilter,
809	.fo_restart = fnullop_restart
810};
811
812/* The default audio mode: 8 kHz mono mu-law */
813static const struct audio_params audio_default = {
814	.sample_rate = 8000,
815	.encoding = AUDIO_ENCODING_ULAW,
816	.precision = 8,
817	.validbits = 8,
818	.channels = 1,
819};
820
821static const char *encoding_names[] = {
822	"none",
823	AudioEmulaw,
824	AudioEalaw,
825	"pcm16",
826	"pcm8",
827	AudioEadpcm,
828	AudioEslinear_le,
829	AudioEslinear_be,
830	AudioEulinear_le,
831	AudioEulinear_be,
832	AudioEslinear,
833	AudioEulinear,
834	AudioEmpeg_l1_stream,
835	AudioEmpeg_l1_packets,
836	AudioEmpeg_l1_system,
837	AudioEmpeg_l2_stream,
838	AudioEmpeg_l2_packets,
839	AudioEmpeg_l2_system,
840	AudioEac3,
841};
842
843/*
844 * Returns encoding name corresponding to AUDIO_ENCODING_*.
845 * Note that it may return a local buffer because it is mainly for debugging.
846 */
847const char *
848audio_encoding_name(int encoding)
849{
850	static char buf[16];
851
852	if (0 <= encoding && encoding < __arraycount(encoding_names)) {
853		return encoding_names[encoding];
854	} else {
855		snprintf(buf, sizeof(buf), "enc=%d", encoding);
856		return buf;
857	}
858}
859
860/*
861 * Supported encodings used by AUDIO_GETENC.
862 * index and flags are set by code.
863 * XXX is there any needs for SLINEAR_OE:>=16/ULINEAR_OE:>=16 ?
864 */
865static const audio_encoding_t audio_encodings[] = {
866	{ 0, AudioEmulaw,	AUDIO_ENCODING_ULAW,		8,  0 },
867	{ 0, AudioEalaw,	AUDIO_ENCODING_ALAW,		8,  0 },
868	{ 0, AudioEslinear,	AUDIO_ENCODING_SLINEAR,		8,  0 },
869	{ 0, AudioEulinear,	AUDIO_ENCODING_ULINEAR,		8,  0 },
870	{ 0, AudioEslinear_le,	AUDIO_ENCODING_SLINEAR_LE,	16, 0 },
871	{ 0, AudioEulinear_le,	AUDIO_ENCODING_ULINEAR_LE,	16, 0 },
872	{ 0, AudioEslinear_be,	AUDIO_ENCODING_SLINEAR_BE,	16, 0 },
873	{ 0, AudioEulinear_be,	AUDIO_ENCODING_ULINEAR_BE,	16, 0 },
874#if defined(AUDIO_SUPPORT_LINEAR24)
875	{ 0, AudioEslinear_le,	AUDIO_ENCODING_SLINEAR_LE,	24, 0 },
876	{ 0, AudioEulinear_le,	AUDIO_ENCODING_ULINEAR_LE,	24, 0 },
877	{ 0, AudioEslinear_be,	AUDIO_ENCODING_SLINEAR_BE,	24, 0 },
878	{ 0, AudioEulinear_be,	AUDIO_ENCODING_ULINEAR_BE,	24, 0 },
879#endif
880	{ 0, AudioEslinear_le,	AUDIO_ENCODING_SLINEAR_LE,	32, 0 },
881	{ 0, AudioEulinear_le,	AUDIO_ENCODING_ULINEAR_LE,	32, 0 },
882	{ 0, AudioEslinear_be,	AUDIO_ENCODING_SLINEAR_BE,	32, 0 },
883	{ 0, AudioEulinear_be,	AUDIO_ENCODING_ULINEAR_BE,	32, 0 },
884};
885
886static const struct portname itable[] = {
887	{ AudioNmicrophone,	AUDIO_MICROPHONE },
888	{ AudioNline,		AUDIO_LINE_IN },
889	{ AudioNcd,		AUDIO_CD },
890	{ 0, 0 }
891};
892static const struct portname otable[] = {
893	{ AudioNspeaker,	AUDIO_SPEAKER },
894	{ AudioNheadphone,	AUDIO_HEADPHONE },
895	{ AudioNline,		AUDIO_LINE_OUT },
896	{ 0, 0 }
897};
898
899static struct psref_class *audio_psref_class __read_mostly;
900
901CFATTACH_DECL3_NEW(audio, sizeof(struct audio_softc),
902    audiomatch, audioattach, audiodetach, audioactivate, audiorescan,
903    audiochilddet, DVF_DETACH_SHUTDOWN);
904
905static int
906audiomatch(device_t parent, cfdata_t match, void *aux)
907{
908	struct audio_attach_args *sa;
909
910	sa = aux;
911	DPRINTF(1, "%s: type=%d sa=%p hw=%p\n",
912	     __func__, sa->type, sa, sa->hwif);
913	return (sa->type == AUDIODEV_TYPE_AUDIO) ? 1 : 0;
914}
915
916static void
917audioattach(device_t parent, device_t self, void *aux)
918{
919	struct audio_softc *sc;
920	struct audio_attach_args *sa;
921	const struct audio_hw_if *hw_if;
922	audio_format2_t phwfmt;
923	audio_format2_t rhwfmt;
924	audio_filter_reg_t pfil;
925	audio_filter_reg_t rfil;
926	const struct sysctlnode *node;
927	void *hdlp;
928	bool has_playback;
929	bool has_capture;
930	bool has_indep;
931	bool has_fulldup;
932	int mode;
933	int error;
934
935	sc = device_private(self);
936	sc->sc_dev = self;
937	sa = (struct audio_attach_args *)aux;
938	hw_if = sa->hwif;
939	hdlp = sa->hdl;
940
941	if (hw_if == NULL) {
942		panic("audioattach: missing hw_if method");
943	}
944	if (hw_if->get_locks == NULL || hw_if->get_props == NULL) {
945		aprint_error(": missing mandatory method\n");
946		return;
947	}
948
949	hw_if->get_locks(hdlp, &sc->sc_intr_lock, &sc->sc_lock);
950	sc->sc_props = hw_if->get_props(hdlp);
951
952	has_playback = (sc->sc_props & AUDIO_PROP_PLAYBACK);
953	has_capture  = (sc->sc_props & AUDIO_PROP_CAPTURE);
954	has_indep    = (sc->sc_props & AUDIO_PROP_INDEPENDENT);
955	has_fulldup  = (sc->sc_props & AUDIO_PROP_FULLDUPLEX);
956
957#ifdef DIAGNOSTIC
958	if (hw_if->query_format == NULL ||
959	    hw_if->set_format == NULL ||
960	    hw_if->getdev == NULL ||
961	    hw_if->set_port == NULL ||
962	    hw_if->get_port == NULL ||
963	    hw_if->query_devinfo == NULL) {
964		aprint_error(": missing mandatory method\n");
965		return;
966	}
967	if (has_playback) {
968		if ((hw_if->start_output == NULL &&
969		     hw_if->trigger_output == NULL) ||
970		    hw_if->halt_output == NULL) {
971			aprint_error(": missing playback method\n");
972		}
973	}
974	if (has_capture) {
975		if ((hw_if->start_input == NULL &&
976		     hw_if->trigger_input == NULL) ||
977		    hw_if->halt_input == NULL) {
978			aprint_error(": missing capture method\n");
979		}
980	}
981#endif
982
983	sc->hw_if = hw_if;
984	sc->hw_hdl = hdlp;
985	sc->hw_dev = parent;
986
987	sc->sc_exlock = 1;
988	sc->sc_blk_ms = AUDIO_BLK_MS;
989	SLIST_INIT(&sc->sc_files);
990	cv_init(&sc->sc_exlockcv, "audiolk");
991	sc->sc_am_capacity = 0;
992	sc->sc_am_used = 0;
993	sc->sc_am = NULL;
994
995	/* MMAP is now supported by upper layer.  */
996	sc->sc_props |= AUDIO_PROP_MMAP;
997
998	KASSERT(has_playback || has_capture);
999	/* Unidirectional device must have neither FULLDUP nor INDEPENDENT. */
1000	if (!has_playback || !has_capture) {
1001		KASSERT(!has_indep);
1002		KASSERT(!has_fulldup);
1003	}
1004
1005	mode = 0;
1006	if (has_playback) {
1007		aprint_normal(": playback");
1008		mode |= AUMODE_PLAY;
1009	}
1010	if (has_capture) {
1011		aprint_normal("%c capture", has_playback ? ',' : ':');
1012		mode |= AUMODE_RECORD;
1013	}
1014	if (has_playback && has_capture) {
1015		if (has_fulldup)
1016			aprint_normal(", full duplex");
1017		else
1018			aprint_normal(", half duplex");
1019
1020		if (has_indep)
1021			aprint_normal(", independent");
1022	}
1023
1024	aprint_naive("\n");
1025	aprint_normal("\n");
1026
1027	/* probe hw params */
1028	memset(&phwfmt, 0, sizeof(phwfmt));
1029	memset(&rhwfmt, 0, sizeof(rhwfmt));
1030	memset(&pfil, 0, sizeof(pfil));
1031	memset(&rfil, 0, sizeof(rfil));
1032	if (has_indep) {
1033		int perror, rerror;
1034
1035		/* On independent devices, probe separately. */
1036		perror = audio_hw_probe(sc, &phwfmt, AUMODE_PLAY);
1037		rerror = audio_hw_probe(sc, &rhwfmt, AUMODE_RECORD);
1038		if (perror && rerror) {
1039			aprint_error_dev(self,
1040			    "audio_hw_probe failed: perror=%d, rerror=%d\n",
1041			    perror, rerror);
1042			goto bad;
1043		}
1044		if (perror) {
1045			mode &= ~AUMODE_PLAY;
1046			aprint_error_dev(self, "audio_hw_probe failed: "
1047			    "errno=%d, playback disabled\n", perror);
1048		}
1049		if (rerror) {
1050			mode &= ~AUMODE_RECORD;
1051			aprint_error_dev(self, "audio_hw_probe failed: "
1052			    "errno=%d, capture disabled\n", rerror);
1053		}
1054	} else {
1055		/*
1056		 * On non independent devices or uni-directional devices,
1057		 * probe once (simultaneously).
1058		 */
1059		audio_format2_t *fmt = has_playback ? &phwfmt : &rhwfmt;
1060		error = audio_hw_probe(sc, fmt, mode);
1061		if (error) {
1062			aprint_error_dev(self,
1063			    "audio_hw_probe failed: errno=%d\n", error);
1064			goto bad;
1065		}
1066		if (has_playback && has_capture)
1067			rhwfmt = phwfmt;
1068	}
1069
1070	/* Make device id available */
1071	if (audio_properties(sc))
1072		aprint_error_dev(self, "audio_properties failed\n");
1073
1074	/* Init hardware. */
1075	/* hw_probe() also validates [pr]hwfmt.  */
1076	error = audio_hw_set_format(sc, mode, &phwfmt, &rhwfmt, &pfil, &rfil);
1077	if (error) {
1078		aprint_error_dev(self,
1079		    "audio_hw_set_format failed: errno=%d\n", error);
1080		goto bad;
1081	}
1082
1083	/*
1084	 * Init track mixers.  If at least one direction is available on
1085	 * attach time, we assume a success.
1086	 */
1087	error = audio_mixers_init(sc, mode, &phwfmt, &rhwfmt, &pfil, &rfil);
1088	if (sc->sc_pmixer == NULL && sc->sc_rmixer == NULL) {
1089		aprint_error_dev(self,
1090		    "audio_mixers_init failed: errno=%d\n", error);
1091		goto bad;
1092	}
1093
1094	sc->sc_psz = pserialize_create();
1095	psref_target_init(&sc->sc_psref, audio_psref_class);
1096
1097	selinit(&sc->sc_wsel);
1098	selinit(&sc->sc_rsel);
1099
1100	/* Initial parameter of /dev/sound */
1101	sc->sc_sound_pparams = params_to_format2(&audio_default);
1102	sc->sc_sound_rparams = params_to_format2(&audio_default);
1103	sc->sc_sound_ppause = false;
1104	sc->sc_sound_rpause = false;
1105
1106	/* XXX TODO: consider about sc_ai */
1107
1108	mixer_init(sc);
1109	TRACE(2, "inputs ports=0x%x, input master=%d, "
1110	    "output ports=0x%x, output master=%d",
1111	    sc->sc_inports.allports, sc->sc_inports.master,
1112	    sc->sc_outports.allports, sc->sc_outports.master);
1113
1114	sysctl_createv(&sc->sc_log, 0, NULL, &node,
1115	    0,
1116	    CTLTYPE_NODE, device_xname(sc->sc_dev),
1117	    SYSCTL_DESCR("audio test"),
1118	    NULL, 0,
1119	    NULL, 0,
1120	    CTL_HW,
1121	    CTL_CREATE, CTL_EOL);
1122
1123	if (node != NULL) {
1124		sysctl_createv(&sc->sc_log, 0, NULL, NULL,
1125		    CTLFLAG_READWRITE,
1126		    CTLTYPE_INT, "blk_ms",
1127		    SYSCTL_DESCR("blocksize in msec"),
1128		    audio_sysctl_blk_ms, 0, (void *)sc, 0,
1129		    CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL);
1130
1131		sysctl_createv(&sc->sc_log, 0, NULL, NULL,
1132		    CTLFLAG_READWRITE,
1133		    CTLTYPE_BOOL, "multiuser",
1134		    SYSCTL_DESCR("allow multiple user access"),
1135		    audio_sysctl_multiuser, 0, (void *)sc, 0,
1136		    CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL);
1137
1138#if defined(AUDIO_DEBUG)
1139		sysctl_createv(&sc->sc_log, 0, NULL, NULL,
1140		    CTLFLAG_READWRITE,
1141		    CTLTYPE_INT, "debug",
1142		    SYSCTL_DESCR("debug level (0..4)"),
1143		    audio_sysctl_debug, 0, (void *)sc, 0,
1144		    CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL);
1145#endif
1146	}
1147
1148#ifdef AUDIO_PM_IDLE
1149	callout_init(&sc->sc_idle_counter, 0);
1150	callout_setfunc(&sc->sc_idle_counter, audio_idle, self);
1151#endif
1152
1153	if (!pmf_device_register(self, audio_suspend, audio_resume))
1154		aprint_error_dev(self, "couldn't establish power handler\n");
1155#ifdef AUDIO_PM_IDLE
1156	if (!device_active_register(self, audio_activity))
1157		aprint_error_dev(self, "couldn't register activity handler\n");
1158#endif
1159
1160	if (!pmf_event_register(self, PMFE_AUDIO_VOLUME_DOWN,
1161	    audio_volume_down, true))
1162		aprint_error_dev(self, "couldn't add volume down handler\n");
1163	if (!pmf_event_register(self, PMFE_AUDIO_VOLUME_UP,
1164	    audio_volume_up, true))
1165		aprint_error_dev(self, "couldn't add volume up handler\n");
1166	if (!pmf_event_register(self, PMFE_AUDIO_VOLUME_TOGGLE,
1167	    audio_volume_toggle, true))
1168		aprint_error_dev(self, "couldn't add volume toggle handler\n");
1169
1170#ifdef AUDIO_PM_IDLE
1171	callout_schedule(&sc->sc_idle_counter, audio_idle_timeout * hz);
1172#endif
1173
1174#if defined(AUDIO_DEBUG)
1175	audio_mlog_init();
1176#endif
1177
1178	audiorescan(self, NULL, NULL);
1179	sc->sc_exlock = 0;
1180	return;
1181
1182bad:
1183	/* Clearing hw_if means that device is attached but disabled. */
1184	sc->hw_if = NULL;
1185	sc->sc_exlock = 0;
1186	aprint_error_dev(sc->sc_dev, "disabled\n");
1187	return;
1188}
1189
1190/*
1191 * Identify audio backend device for drvctl.
1192 */
1193static int
1194audio_properties(struct audio_softc *sc)
1195{
1196	prop_dictionary_t dict = device_properties(sc->sc_dev);
1197	audio_device_t adev;
1198	int error;
1199
1200	error = sc->hw_if->getdev(sc->hw_hdl, &adev);
1201	if (error)
1202		return error;
1203
1204	prop_dictionary_set_string(dict, "name", adev.name);
1205	prop_dictionary_set_string(dict, "version", adev.version);
1206	prop_dictionary_set_string(dict, "config", adev.config);
1207
1208	return 0;
1209}
1210
1211/*
1212 * Initialize hardware mixer.
1213 * This function is called from audioattach().
1214 */
1215static void
1216mixer_init(struct audio_softc *sc)
1217{
1218	mixer_devinfo_t mi;
1219	int iclass, mclass, oclass, rclass;
1220	int record_master_found, record_source_found;
1221
1222	iclass = mclass = oclass = rclass = -1;
1223	sc->sc_inports.index = -1;
1224	sc->sc_inports.master = -1;
1225	sc->sc_inports.nports = 0;
1226	sc->sc_inports.isenum = false;
1227	sc->sc_inports.allports = 0;
1228	sc->sc_inports.isdual = false;
1229	sc->sc_inports.mixerout = -1;
1230	sc->sc_inports.cur_port = -1;
1231	sc->sc_outports.index = -1;
1232	sc->sc_outports.master = -1;
1233	sc->sc_outports.nports = 0;
1234	sc->sc_outports.isenum = false;
1235	sc->sc_outports.allports = 0;
1236	sc->sc_outports.isdual = false;
1237	sc->sc_outports.mixerout = -1;
1238	sc->sc_outports.cur_port = -1;
1239	sc->sc_monitor_port = -1;
1240	/*
1241	 * Read through the underlying driver's list, picking out the class
1242	 * names from the mixer descriptions. We'll need them to decode the
1243	 * mixer descriptions on the next pass through the loop.
1244	 */
1245	mutex_enter(sc->sc_lock);
1246	for(mi.index = 0; ; mi.index++) {
1247		if (audio_query_devinfo(sc, &mi) != 0)
1248			break;
1249		 /*
1250		  * The type of AUDIO_MIXER_CLASS merely introduces a class.
1251		  * All the other types describe an actual mixer.
1252		  */
1253		if (mi.type == AUDIO_MIXER_CLASS) {
1254			if (strcmp(mi.label.name, AudioCinputs) == 0)
1255				iclass = mi.mixer_class;
1256			if (strcmp(mi.label.name, AudioCmonitor) == 0)
1257				mclass = mi.mixer_class;
1258			if (strcmp(mi.label.name, AudioCoutputs) == 0)
1259				oclass = mi.mixer_class;
1260			if (strcmp(mi.label.name, AudioCrecord) == 0)
1261				rclass = mi.mixer_class;
1262		}
1263	}
1264	mutex_exit(sc->sc_lock);
1265
1266	/* Allocate save area.  Ensure non-zero allocation. */
1267	sc->sc_nmixer_states = mi.index;
1268	sc->sc_mixer_state = kmem_zalloc(sizeof(sc->sc_mixer_state[0]) *
1269	    (sc->sc_nmixer_states + 1), KM_SLEEP);
1270
1271	/*
1272	 * This is where we assign each control in the "audio" model, to the
1273	 * underlying "mixer" control.  We walk through the whole list once,
1274	 * assigning likely candidates as we come across them.
1275	 */
1276	record_master_found = 0;
1277	record_source_found = 0;
1278	mutex_enter(sc->sc_lock);
1279	for(mi.index = 0; ; mi.index++) {
1280		if (audio_query_devinfo(sc, &mi) != 0)
1281			break;
1282		KASSERT(mi.index < sc->sc_nmixer_states);
1283		if (mi.type == AUDIO_MIXER_CLASS)
1284			continue;
1285		if (mi.mixer_class == iclass) {
1286			/*
1287			 * AudioCinputs is only a fallback, when we don't
1288			 * find what we're looking for in AudioCrecord, so
1289			 * check the flags before accepting one of these.
1290			 */
1291			if (strcmp(mi.label.name, AudioNmaster) == 0
1292			    && record_master_found == 0)
1293				sc->sc_inports.master = mi.index;
1294			if (strcmp(mi.label.name, AudioNsource) == 0
1295			    && record_source_found == 0) {
1296				if (mi.type == AUDIO_MIXER_ENUM) {
1297				    int i;
1298				    for(i = 0; i < mi.un.e.num_mem; i++)
1299					if (strcmp(mi.un.e.member[i].label.name,
1300						    AudioNmixerout) == 0)
1301						sc->sc_inports.mixerout =
1302						    mi.un.e.member[i].ord;
1303				}
1304				au_setup_ports(sc, &sc->sc_inports, &mi,
1305				    itable);
1306			}
1307			if (strcmp(mi.label.name, AudioNdac) == 0 &&
1308			    sc->sc_outports.master == -1)
1309				sc->sc_outports.master = mi.index;
1310		} else if (mi.mixer_class == mclass) {
1311			if (strcmp(mi.label.name, AudioNmonitor) == 0)
1312				sc->sc_monitor_port = mi.index;
1313		} else if (mi.mixer_class == oclass) {
1314			if (strcmp(mi.label.name, AudioNmaster) == 0)
1315				sc->sc_outports.master = mi.index;
1316			if (strcmp(mi.label.name, AudioNselect) == 0)
1317				au_setup_ports(sc, &sc->sc_outports, &mi,
1318				    otable);
1319		} else if (mi.mixer_class == rclass) {
1320			/*
1321			 * These are the preferred mixers for the audio record
1322			 * controls, so set the flags here, but don't check.
1323			 */
1324			if (strcmp(mi.label.name, AudioNmaster) == 0) {
1325				sc->sc_inports.master = mi.index;
1326				record_master_found = 1;
1327			}
1328#if 1	/* Deprecated. Use AudioNmaster. */
1329			if (strcmp(mi.label.name, AudioNrecord) == 0) {
1330				sc->sc_inports.master = mi.index;
1331				record_master_found = 1;
1332			}
1333			if (strcmp(mi.label.name, AudioNvolume) == 0) {
1334				sc->sc_inports.master = mi.index;
1335				record_master_found = 1;
1336			}
1337#endif
1338			if (strcmp(mi.label.name, AudioNsource) == 0) {
1339				if (mi.type == AUDIO_MIXER_ENUM) {
1340				    int i;
1341				    for(i = 0; i < mi.un.e.num_mem; i++)
1342					if (strcmp(mi.un.e.member[i].label.name,
1343						    AudioNmixerout) == 0)
1344						sc->sc_inports.mixerout =
1345						    mi.un.e.member[i].ord;
1346				}
1347				au_setup_ports(sc, &sc->sc_inports, &mi,
1348				    itable);
1349				record_source_found = 1;
1350			}
1351		}
1352	}
1353	mutex_exit(sc->sc_lock);
1354}
1355
1356static int
1357audioactivate(device_t self, enum devact act)
1358{
1359	struct audio_softc *sc = device_private(self);
1360
1361	switch (act) {
1362	case DVACT_DEACTIVATE:
1363		mutex_enter(sc->sc_lock);
1364		sc->sc_dying = true;
1365		cv_broadcast(&sc->sc_exlockcv);
1366		mutex_exit(sc->sc_lock);
1367		return 0;
1368	default:
1369		return EOPNOTSUPP;
1370	}
1371}
1372
1373static int
1374audiodetach(device_t self, int flags)
1375{
1376	struct audio_softc *sc;
1377	struct audio_file *file;
1378	int maj, mn;
1379	int error;
1380
1381	sc = device_private(self);
1382	TRACE(2, "flags=%d", flags);
1383
1384	/* device is not initialized */
1385	if (sc->hw_if == NULL)
1386		return 0;
1387
1388	/* Start draining existing accessors of the device. */
1389	error = config_detach_children(self, flags);
1390	if (error)
1391		return error;
1392
1393	/*
1394	 * Prevent new opens and wait for existing opens to complete.
1395	 *
1396	 * At the moment there are only four bits in the minor for the
1397	 * unit number, so we only revoke if the unit number could be
1398	 * used in a device node.
1399	 *
1400	 * XXX If we want more audio units, we need to encode them
1401	 * more elaborately in the minor space.
1402	 */
1403	maj = cdevsw_lookup_major(&audio_cdevsw);
1404	mn = device_unit(self);
1405	if (mn <= 0xf) {
1406		vdevgone(maj, mn|SOUND_DEVICE, mn|SOUND_DEVICE, VCHR);
1407		vdevgone(maj, mn|AUDIO_DEVICE, mn|AUDIO_DEVICE, VCHR);
1408		vdevgone(maj, mn|AUDIOCTL_DEVICE, mn|AUDIOCTL_DEVICE, VCHR);
1409		vdevgone(maj, mn|MIXER_DEVICE, mn|MIXER_DEVICE, VCHR);
1410	}
1411
1412	/*
1413	 * This waits currently running sysctls to finish if exists.
1414	 * After this, no more new sysctls will come.
1415	 */
1416	sysctl_teardown(&sc->sc_log);
1417
1418	mutex_enter(sc->sc_lock);
1419	sc->sc_dying = true;
1420	cv_broadcast(&sc->sc_exlockcv);
1421	if (sc->sc_pmixer)
1422		cv_broadcast(&sc->sc_pmixer->outcv);
1423	if (sc->sc_rmixer)
1424		cv_broadcast(&sc->sc_rmixer->outcv);
1425
1426	/* Prevent new users */
1427	SLIST_FOREACH(file, &sc->sc_files, entry) {
1428		atomic_store_relaxed(&file->dying, true);
1429	}
1430	mutex_exit(sc->sc_lock);
1431
1432	/*
1433	 * Wait for existing users to drain.
1434	 * - pserialize_perform waits for all pserialize_read sections on
1435	 *   all CPUs; after this, no more new psref_acquire can happen.
1436	 * - psref_target_destroy waits for all extant acquired psrefs to
1437	 *   be psref_released.
1438	 */
1439	pserialize_perform(sc->sc_psz);
1440	psref_target_destroy(&sc->sc_psref, audio_psref_class);
1441
1442	/*
1443	 * We are now guaranteed that there are no calls to audio fileops
1444	 * that hold sc, and any new calls with files that were for sc will
1445	 * fail.  Thus, we now have exclusive access to the softc.
1446	 */
1447	sc->sc_exlock = 1;
1448
1449	/*
1450	 * Clean up all open instances.
1451	 */
1452	mutex_enter(sc->sc_lock);
1453	while ((file = SLIST_FIRST(&sc->sc_files)) != NULL) {
1454		mutex_enter(sc->sc_intr_lock);
1455		SLIST_REMOVE_HEAD(&sc->sc_files, entry);
1456		mutex_exit(sc->sc_intr_lock);
1457		if (file->ptrack || file->rtrack) {
1458			mutex_exit(sc->sc_lock);
1459			audio_unlink(sc, file);
1460			mutex_enter(sc->sc_lock);
1461		}
1462	}
1463	mutex_exit(sc->sc_lock);
1464
1465	pmf_event_deregister(self, PMFE_AUDIO_VOLUME_DOWN,
1466	    audio_volume_down, true);
1467	pmf_event_deregister(self, PMFE_AUDIO_VOLUME_UP,
1468	    audio_volume_up, true);
1469	pmf_event_deregister(self, PMFE_AUDIO_VOLUME_TOGGLE,
1470	    audio_volume_toggle, true);
1471
1472#ifdef AUDIO_PM_IDLE
1473	callout_halt(&sc->sc_idle_counter, sc->sc_lock);
1474
1475	device_active_deregister(self, audio_activity);
1476#endif
1477
1478	pmf_device_deregister(self);
1479
1480	/* Free resources */
1481	if (sc->sc_pmixer) {
1482		audio_mixer_destroy(sc, sc->sc_pmixer);
1483		kmem_free(sc->sc_pmixer, sizeof(*sc->sc_pmixer));
1484	}
1485	if (sc->sc_rmixer) {
1486		audio_mixer_destroy(sc, sc->sc_rmixer);
1487		kmem_free(sc->sc_rmixer, sizeof(*sc->sc_rmixer));
1488	}
1489	if (sc->sc_am)
1490		kern_free(sc->sc_am);
1491
1492	seldestroy(&sc->sc_wsel);
1493	seldestroy(&sc->sc_rsel);
1494
1495#ifdef AUDIO_PM_IDLE
1496	callout_destroy(&sc->sc_idle_counter);
1497#endif
1498
1499	cv_destroy(&sc->sc_exlockcv);
1500
1501#if defined(AUDIO_DEBUG)
1502	audio_mlog_free();
1503#endif
1504
1505	return 0;
1506}
1507
1508static void
1509audiochilddet(device_t self, device_t child)
1510{
1511
1512	/* we hold no child references, so do nothing */
1513}
1514
1515static int
1516audiosearch(device_t parent, cfdata_t cf, const int *locs, void *aux)
1517{
1518
1519	if (config_probe(parent, cf, aux))
1520		config_attach(parent, cf, aux, NULL,
1521		    CFARGS_NONE);
1522
1523	return 0;
1524}
1525
1526static int
1527audiorescan(device_t self, const char *ifattr, const int *locators)
1528{
1529	struct audio_softc *sc = device_private(self);
1530
1531	config_search(sc->sc_dev, NULL,
1532	    CFARGS(.search = audiosearch));
1533
1534	return 0;
1535}
1536
1537/*
1538 * Called from hardware driver.  This is where the MI audio driver gets
1539 * probed/attached to the hardware driver.
1540 */
1541device_t
1542audio_attach_mi(const struct audio_hw_if *ahwp, void *hdlp, device_t dev)
1543{
1544	struct audio_attach_args arg;
1545
1546#ifdef DIAGNOSTIC
1547	if (ahwp == NULL) {
1548		aprint_error("audio_attach_mi: NULL\n");
1549		return 0;
1550	}
1551#endif
1552	arg.type = AUDIODEV_TYPE_AUDIO;
1553	arg.hwif = ahwp;
1554	arg.hdl = hdlp;
1555	return config_found(dev, &arg, audioprint,
1556	    CFARGS(.iattr = "audiobus"));
1557}
1558
1559/*
1560 * audio_printf() outputs fmt... with the audio device name and MD device
1561 * name prefixed.  If the message is considered to be related to the MD
1562 * driver, use this one instead of device_printf().
1563 */
1564static void
1565audio_printf(struct audio_softc *sc, const char *fmt, ...)
1566{
1567	va_list ap;
1568
1569	printf("%s(%s): ", device_xname(sc->sc_dev), device_xname(sc->hw_dev));
1570	va_start(ap, fmt);
1571	vprintf(fmt, ap);
1572	va_end(ap);
1573}
1574
1575/*
1576 * Enter critical section and also keep sc_lock.
1577 * If successful, returns 0 with sc_lock held.  Otherwise returns errno.
1578 * Must be called without sc_lock held.
1579 */
1580static int
1581audio_exlock_mutex_enter(struct audio_softc *sc)
1582{
1583	int error;
1584
1585	mutex_enter(sc->sc_lock);
1586	if (sc->sc_dying) {
1587		mutex_exit(sc->sc_lock);
1588		return EIO;
1589	}
1590
1591	while (__predict_false(sc->sc_exlock != 0)) {
1592		error = cv_wait_sig(&sc->sc_exlockcv, sc->sc_lock);
1593		if (sc->sc_dying)
1594			error = EIO;
1595		if (error) {
1596			mutex_exit(sc->sc_lock);
1597			return error;
1598		}
1599	}
1600
1601	/* Acquire */
1602	sc->sc_exlock = 1;
1603	return 0;
1604}
1605
1606/*
1607 * Exit critical section and exit sc_lock.
1608 * Must be called with sc_lock held.
1609 */
1610static void
1611audio_exlock_mutex_exit(struct audio_softc *sc)
1612{
1613
1614	KASSERT(mutex_owned(sc->sc_lock));
1615
1616	sc->sc_exlock = 0;
1617	cv_broadcast(&sc->sc_exlockcv);
1618	mutex_exit(sc->sc_lock);
1619}
1620
1621/*
1622 * Enter critical section.
1623 * If successful, it returns 0.  Otherwise returns errno.
1624 * Must be called without sc_lock held.
1625 * This function returns without sc_lock held.
1626 */
1627static int
1628audio_exlock_enter(struct audio_softc *sc)
1629{
1630	int error;
1631
1632	error = audio_exlock_mutex_enter(sc);
1633	if (error)
1634		return error;
1635	mutex_exit(sc->sc_lock);
1636	return 0;
1637}
1638
1639/*
1640 * Exit critical section.
1641 * Must be called without sc_lock held.
1642 */
1643static void
1644audio_exlock_exit(struct audio_softc *sc)
1645{
1646
1647	mutex_enter(sc->sc_lock);
1648	audio_exlock_mutex_exit(sc);
1649}
1650
1651/*
1652 * Get sc from file, and increment reference counter for this sc.
1653 * This is intended to be used for methods other than open.
1654 * If successful, returns sc.  Otherwise returns NULL.
1655 */
1656struct audio_softc *
1657audio_sc_acquire_fromfile(audio_file_t *file, struct psref *refp)
1658{
1659	int s;
1660	bool dying;
1661
1662	/* Block audiodetach while we acquire a reference */
1663	s = pserialize_read_enter();
1664
1665	/* If close or audiodetach already ran, tough -- no more audio */
1666	dying = atomic_load_relaxed(&file->dying);
1667	if (dying) {
1668		pserialize_read_exit(s);
1669		return NULL;
1670	}
1671
1672	/* Acquire a reference */
1673	psref_acquire(refp, &file->sc->sc_psref, audio_psref_class);
1674
1675	/* Now sc won't go away until we drop the reference count */
1676	pserialize_read_exit(s);
1677
1678	return file->sc;
1679}
1680
1681/*
1682 * Decrement reference counter for this sc.
1683 */
1684void
1685audio_sc_release(struct audio_softc *sc, struct psref *refp)
1686{
1687
1688	psref_release(refp, &sc->sc_psref, audio_psref_class);
1689}
1690
1691/*
1692 * Wait for I/O to complete, releasing sc_lock.
1693 * Must be called with sc_lock held.
1694 */
1695static int
1696audio_track_waitio(struct audio_softc *sc, audio_track_t *track,
1697    const char *mess)
1698{
1699	int error;
1700
1701	KASSERT(track);
1702	KASSERT(mutex_owned(sc->sc_lock));
1703
1704	/* Wait for pending I/O to complete. */
1705	error = cv_timedwait_sig(&track->mixer->outcv, sc->sc_lock,
1706	    mstohz(AUDIO_TIMEOUT));
1707	if (sc->sc_suspending) {
1708		/* If it's about to suspend, ignore timeout error. */
1709		if (error == EWOULDBLOCK) {
1710			TRACET(2, track, "timeout (suspending)");
1711			return 0;
1712		}
1713	}
1714	if (sc->sc_dying) {
1715		error = EIO;
1716	}
1717	if (error) {
1718		TRACET(2, track, "cv_timedwait_sig failed %d", error);
1719		if (error == EWOULDBLOCK) {
1720			audio_ring_t *usrbuf = &track->usrbuf;
1721			audio_ring_t *outbuf = &track->outbuf;
1722			audio_printf(sc,
1723			    "%s: device timeout, seq=%d, usrbuf=%d/H%d, outbuf=%d/%d\n",
1724			    mess, (int)track->seq,
1725			    usrbuf->used, track->usrbuf_usedhigh,
1726			    outbuf->used, outbuf->capacity);
1727		}
1728	} else {
1729		TRACET(3, track, "wakeup");
1730	}
1731	return error;
1732}
1733
1734/*
1735 * Try to acquire track lock.
1736 * It doesn't block if the track lock is already acquired.
1737 * Returns true if the track lock was acquired, or false if the track
1738 * lock was already acquired.
1739 */
1740static __inline bool
1741audio_track_lock_tryenter(audio_track_t *track)
1742{
1743
1744	if (atomic_swap_uint(&track->lock, 1) != 0)
1745		return false;
1746	membar_acquire();
1747	return true;
1748}
1749
1750/*
1751 * Acquire track lock.
1752 */
1753static __inline void
1754audio_track_lock_enter(audio_track_t *track)
1755{
1756
1757	/* Don't sleep here. */
1758	while (audio_track_lock_tryenter(track) == false)
1759		SPINLOCK_BACKOFF_HOOK;
1760}
1761
1762/*
1763 * Release track lock.
1764 */
1765static __inline void
1766audio_track_lock_exit(audio_track_t *track)
1767{
1768
1769	atomic_store_release(&track->lock, 0);
1770}
1771
1772
1773static int
1774audioopen(dev_t dev, int flags, int ifmt, struct lwp *l)
1775{
1776	struct audio_softc *sc;
1777	int error;
1778
1779	/*
1780	 * Find the device.  Because we wired the cdevsw to the audio
1781	 * autoconf instance, the system ensures it will not go away
1782	 * until after we return.
1783	 */
1784	sc = device_lookup_private(&audio_cd, AUDIOUNIT(dev));
1785	if (sc == NULL || sc->hw_if == NULL)
1786		return ENXIO;
1787
1788	error = audio_exlock_enter(sc);
1789	if (error)
1790		return error;
1791
1792	device_active(sc->sc_dev, DVA_SYSTEM);
1793	switch (AUDIODEV(dev)) {
1794	case SOUND_DEVICE:
1795	case AUDIO_DEVICE:
1796		error = audio_open(dev, sc, flags, ifmt, l, NULL);
1797		break;
1798	case AUDIOCTL_DEVICE:
1799		error = audioctl_open(dev, sc, flags, ifmt, l);
1800		break;
1801	case MIXER_DEVICE:
1802		error = mixer_open(dev, sc, flags, ifmt, l);
1803		break;
1804	default:
1805		error = ENXIO;
1806		break;
1807	}
1808	audio_exlock_exit(sc);
1809
1810	return error;
1811}
1812
1813static int
1814audioclose(struct file *fp)
1815{
1816	struct audio_softc *sc;
1817	struct psref sc_ref;
1818	audio_file_t *file;
1819	int bound;
1820	int error;
1821	dev_t dev;
1822
1823	KASSERT(fp->f_audioctx);
1824	file = fp->f_audioctx;
1825	dev = file->dev;
1826	error = 0;
1827
1828	/*
1829	 * audioclose() must
1830	 * - unplug track from the trackmixer (and unplug anything from softc),
1831	 *   if sc exists.
1832	 * - free all memory objects, regardless of sc.
1833	 */
1834
1835	bound = curlwp_bind();
1836	sc = audio_sc_acquire_fromfile(file, &sc_ref);
1837	if (sc) {
1838		switch (AUDIODEV(dev)) {
1839		case SOUND_DEVICE:
1840		case AUDIO_DEVICE:
1841			error = audio_close(sc, file);
1842			break;
1843		case AUDIOCTL_DEVICE:
1844			mutex_enter(sc->sc_lock);
1845			mutex_enter(sc->sc_intr_lock);
1846			SLIST_REMOVE(&sc->sc_files, file, audio_file, entry);
1847			mutex_exit(sc->sc_intr_lock);
1848			mutex_exit(sc->sc_lock);
1849			error = 0;
1850			break;
1851		case MIXER_DEVICE:
1852			mutex_enter(sc->sc_lock);
1853			mutex_enter(sc->sc_intr_lock);
1854			SLIST_REMOVE(&sc->sc_files, file, audio_file, entry);
1855			mutex_exit(sc->sc_intr_lock);
1856			mutex_exit(sc->sc_lock);
1857			error = mixer_close(sc, file);
1858			break;
1859		default:
1860			error = ENXIO;
1861			break;
1862		}
1863
1864		audio_sc_release(sc, &sc_ref);
1865	}
1866	curlwp_bindx(bound);
1867
1868	/* Free memory objects anyway */
1869	TRACEF(2, file, "free memory");
1870	if (file->ptrack)
1871		audio_track_destroy(file->ptrack);
1872	if (file->rtrack)
1873		audio_track_destroy(file->rtrack);
1874	kmem_free(file, sizeof(*file));
1875	fp->f_audioctx = NULL;
1876
1877	return error;
1878}
1879
1880static int
1881audioread(struct file *fp, off_t *offp, struct uio *uio, kauth_cred_t cred,
1882	int ioflag)
1883{
1884	struct audio_softc *sc;
1885	struct psref sc_ref;
1886	audio_file_t *file;
1887	int bound;
1888	int error;
1889	dev_t dev;
1890
1891	KASSERT(fp->f_audioctx);
1892	file = fp->f_audioctx;
1893	dev = file->dev;
1894
1895	bound = curlwp_bind();
1896	sc = audio_sc_acquire_fromfile(file, &sc_ref);
1897	if (sc == NULL) {
1898		error = EIO;
1899		goto done;
1900	}
1901
1902	if (fp->f_flag & O_NONBLOCK)
1903		ioflag |= IO_NDELAY;
1904
1905	switch (AUDIODEV(dev)) {
1906	case SOUND_DEVICE:
1907	case AUDIO_DEVICE:
1908		error = audio_read(sc, uio, ioflag, file);
1909		break;
1910	case AUDIOCTL_DEVICE:
1911	case MIXER_DEVICE:
1912		error = ENODEV;
1913		break;
1914	default:
1915		error = ENXIO;
1916		break;
1917	}
1918
1919	audio_sc_release(sc, &sc_ref);
1920done:
1921	curlwp_bindx(bound);
1922	return error;
1923}
1924
1925static int
1926audiowrite(struct file *fp, off_t *offp, struct uio *uio, kauth_cred_t cred,
1927	int ioflag)
1928{
1929	struct audio_softc *sc;
1930	struct psref sc_ref;
1931	audio_file_t *file;
1932	int bound;
1933	int error;
1934	dev_t dev;
1935
1936	KASSERT(fp->f_audioctx);
1937	file = fp->f_audioctx;
1938	dev = file->dev;
1939
1940	bound = curlwp_bind();
1941	sc = audio_sc_acquire_fromfile(file, &sc_ref);
1942	if (sc == NULL) {
1943		error = EIO;
1944		goto done;
1945	}
1946
1947	if (fp->f_flag & O_NONBLOCK)
1948		ioflag |= IO_NDELAY;
1949
1950	switch (AUDIODEV(dev)) {
1951	case SOUND_DEVICE:
1952	case AUDIO_DEVICE:
1953		error = audio_write(sc, uio, ioflag, file);
1954		break;
1955	case AUDIOCTL_DEVICE:
1956	case MIXER_DEVICE:
1957		error = ENODEV;
1958		break;
1959	default:
1960		error = ENXIO;
1961		break;
1962	}
1963
1964	audio_sc_release(sc, &sc_ref);
1965done:
1966	curlwp_bindx(bound);
1967	return error;
1968}
1969
1970static int
1971audioioctl(struct file *fp, u_long cmd, void *addr)
1972{
1973	struct audio_softc *sc;
1974	struct psref sc_ref;
1975	audio_file_t *file;
1976	struct lwp *l = curlwp;
1977	int bound;
1978	int error;
1979	dev_t dev;
1980
1981	KASSERT(fp->f_audioctx);
1982	file = fp->f_audioctx;
1983	dev = file->dev;
1984
1985	bound = curlwp_bind();
1986	sc = audio_sc_acquire_fromfile(file, &sc_ref);
1987	if (sc == NULL) {
1988		error = EIO;
1989		goto done;
1990	}
1991
1992	switch (AUDIODEV(dev)) {
1993	case SOUND_DEVICE:
1994	case AUDIO_DEVICE:
1995	case AUDIOCTL_DEVICE:
1996		mutex_enter(sc->sc_lock);
1997		device_active(sc->sc_dev, DVA_SYSTEM);
1998		mutex_exit(sc->sc_lock);
1999		if (IOCGROUP(cmd) == IOCGROUP(AUDIO_MIXER_READ))
2000			error = mixer_ioctl(sc, cmd, addr, fp->f_flag, l);
2001		else
2002			error = audio_ioctl(dev, sc, cmd, addr, fp->f_flag, l,
2003			    file);
2004		break;
2005	case MIXER_DEVICE:
2006		error = mixer_ioctl(sc, cmd, addr, fp->f_flag, l);
2007		break;
2008	default:
2009		error = ENXIO;
2010		break;
2011	}
2012
2013	audio_sc_release(sc, &sc_ref);
2014done:
2015	curlwp_bindx(bound);
2016	return error;
2017}
2018
2019static int
2020audiostat(struct file *fp, struct stat *st)
2021{
2022	struct audio_softc *sc;
2023	struct psref sc_ref;
2024	audio_file_t *file;
2025	int bound;
2026	int error;
2027
2028	KASSERT(fp->f_audioctx);
2029	file = fp->f_audioctx;
2030
2031	bound = curlwp_bind();
2032	sc = audio_sc_acquire_fromfile(file, &sc_ref);
2033	if (sc == NULL) {
2034		error = EIO;
2035		goto done;
2036	}
2037
2038	error = 0;
2039	memset(st, 0, sizeof(*st));
2040
2041	st->st_dev = file->dev;
2042	st->st_uid = kauth_cred_geteuid(fp->f_cred);
2043	st->st_gid = kauth_cred_getegid(fp->f_cred);
2044	st->st_mode = S_IFCHR;
2045
2046	audio_sc_release(sc, &sc_ref);
2047done:
2048	curlwp_bindx(bound);
2049	return error;
2050}
2051
2052static int
2053audiopoll(struct file *fp, int events)
2054{
2055	struct audio_softc *sc;
2056	struct psref sc_ref;
2057	audio_file_t *file;
2058	struct lwp *l = curlwp;
2059	int bound;
2060	int revents;
2061	dev_t dev;
2062
2063	KASSERT(fp->f_audioctx);
2064	file = fp->f_audioctx;
2065	dev = file->dev;
2066
2067	bound = curlwp_bind();
2068	sc = audio_sc_acquire_fromfile(file, &sc_ref);
2069	if (sc == NULL) {
2070		revents = POLLERR;
2071		goto done;
2072	}
2073
2074	switch (AUDIODEV(dev)) {
2075	case SOUND_DEVICE:
2076	case AUDIO_DEVICE:
2077		revents = audio_poll(sc, events, l, file);
2078		break;
2079	case AUDIOCTL_DEVICE:
2080	case MIXER_DEVICE:
2081		revents = 0;
2082		break;
2083	default:
2084		revents = POLLERR;
2085		break;
2086	}
2087
2088	audio_sc_release(sc, &sc_ref);
2089done:
2090	curlwp_bindx(bound);
2091	return revents;
2092}
2093
2094static int
2095audiokqfilter(struct file *fp, struct knote *kn)
2096{
2097	struct audio_softc *sc;
2098	struct psref sc_ref;
2099	audio_file_t *file;
2100	dev_t dev;
2101	int bound;
2102	int error;
2103
2104	KASSERT(fp->f_audioctx);
2105	file = fp->f_audioctx;
2106	dev = file->dev;
2107
2108	bound = curlwp_bind();
2109	sc = audio_sc_acquire_fromfile(file, &sc_ref);
2110	if (sc == NULL) {
2111		error = EIO;
2112		goto done;
2113	}
2114
2115	switch (AUDIODEV(dev)) {
2116	case SOUND_DEVICE:
2117	case AUDIO_DEVICE:
2118		error = audio_kqfilter(sc, file, kn);
2119		break;
2120	case AUDIOCTL_DEVICE:
2121	case MIXER_DEVICE:
2122		error = ENODEV;
2123		break;
2124	default:
2125		error = ENXIO;
2126		break;
2127	}
2128
2129	audio_sc_release(sc, &sc_ref);
2130done:
2131	curlwp_bindx(bound);
2132	return error;
2133}
2134
2135static int
2136audiommap(struct file *fp, off_t *offp, size_t len, int prot, int *flagsp,
2137	int *advicep, struct uvm_object **uobjp, int *maxprotp)
2138{
2139	struct audio_softc *sc;
2140	struct psref sc_ref;
2141	audio_file_t *file;
2142	dev_t dev;
2143	int bound;
2144	int error;
2145
2146	KASSERT(len > 0);
2147
2148	KASSERT(fp->f_audioctx);
2149	file = fp->f_audioctx;
2150	dev = file->dev;
2151
2152	bound = curlwp_bind();
2153	sc = audio_sc_acquire_fromfile(file, &sc_ref);
2154	if (sc == NULL) {
2155		error = EIO;
2156		goto done;
2157	}
2158
2159	mutex_enter(sc->sc_lock);
2160	device_active(sc->sc_dev, DVA_SYSTEM); /* XXXJDM */
2161	mutex_exit(sc->sc_lock);
2162
2163	switch (AUDIODEV(dev)) {
2164	case SOUND_DEVICE:
2165	case AUDIO_DEVICE:
2166		error = audio_mmap(sc, offp, len, prot, flagsp, advicep,
2167		    uobjp, maxprotp, file);
2168		break;
2169	case AUDIOCTL_DEVICE:
2170	case MIXER_DEVICE:
2171	default:
2172		error = ENOTSUP;
2173		break;
2174	}
2175
2176	audio_sc_release(sc, &sc_ref);
2177done:
2178	curlwp_bindx(bound);
2179	return error;
2180}
2181
2182
2183/* Exported interfaces for audiobell. */
2184
2185/*
2186 * Open for audiobell.
2187 * It stores allocated file to *filep.
2188 * If successful returns 0, otherwise errno.
2189 */
2190int
2191audiobellopen(dev_t dev, audio_file_t **filep)
2192{
2193	device_t audiodev = NULL;
2194	struct audio_softc *sc;
2195	bool exlock = false;
2196	int error;
2197
2198	/*
2199	 * Find the autoconf instance and make sure it doesn't go away
2200	 * while we are opening it.
2201	 */
2202	audiodev = device_lookup_acquire(&audio_cd, AUDIOUNIT(dev));
2203	if (audiodev == NULL) {
2204		error = ENXIO;
2205		goto out;
2206	}
2207
2208	/* If attach failed, it's hopeless -- give up.  */
2209	sc = device_private(audiodev);
2210	if (sc->hw_if == NULL) {
2211		error = ENXIO;
2212		goto out;
2213	}
2214
2215	/* Take the exclusive configuration lock.  */
2216	error = audio_exlock_enter(sc);
2217	if (error)
2218		goto out;
2219	exlock = true;
2220
2221	/* Open the audio device.  */
2222	device_active(sc->sc_dev, DVA_SYSTEM);
2223	error = audio_open(dev, sc, FWRITE, 0, curlwp, filep);
2224
2225out:	if (exlock)
2226		audio_exlock_exit(sc);
2227	if (audiodev)
2228		device_release(audiodev);
2229	return error;
2230}
2231
2232/* Close for audiobell */
2233int
2234audiobellclose(audio_file_t *file)
2235{
2236	struct audio_softc *sc;
2237	struct psref sc_ref;
2238	int bound;
2239	int error;
2240
2241	error = 0;
2242	/*
2243	 * audiobellclose() must
2244	 * - unplug track from the trackmixer if sc exist.
2245	 * - free all memory objects, regardless of sc.
2246	 */
2247	bound = curlwp_bind();
2248	sc = audio_sc_acquire_fromfile(file, &sc_ref);
2249	if (sc) {
2250		error = audio_close(sc, file);
2251		audio_sc_release(sc, &sc_ref);
2252	}
2253	curlwp_bindx(bound);
2254
2255	/* Free memory objects anyway */
2256	KASSERT(file->ptrack);
2257	audio_track_destroy(file->ptrack);
2258	KASSERT(file->rtrack == NULL);
2259	kmem_free(file, sizeof(*file));
2260	return error;
2261}
2262
2263/* Set sample rate for audiobell */
2264int
2265audiobellsetrate(audio_file_t *file, u_int sample_rate)
2266{
2267	struct audio_softc *sc;
2268	struct psref sc_ref;
2269	struct audio_info ai;
2270	int bound;
2271	int error;
2272
2273	bound = curlwp_bind();
2274	sc = audio_sc_acquire_fromfile(file, &sc_ref);
2275	if (sc == NULL) {
2276		error = EIO;
2277		goto done1;
2278	}
2279
2280	AUDIO_INITINFO(&ai);
2281	ai.play.sample_rate = sample_rate;
2282
2283	error = audio_exlock_enter(sc);
2284	if (error)
2285		goto done2;
2286	error = audio_file_setinfo(sc, file, &ai);
2287	audio_exlock_exit(sc);
2288
2289done2:
2290	audio_sc_release(sc, &sc_ref);
2291done1:
2292	curlwp_bindx(bound);
2293	return error;
2294}
2295
2296/* Playback for audiobell */
2297int
2298audiobellwrite(audio_file_t *file, struct uio *uio)
2299{
2300	struct audio_softc *sc;
2301	struct psref sc_ref;
2302	int bound;
2303	int error;
2304
2305	bound = curlwp_bind();
2306	sc = audio_sc_acquire_fromfile(file, &sc_ref);
2307	if (sc == NULL) {
2308		error = EIO;
2309		goto done;
2310	}
2311
2312	error = audio_write(sc, uio, 0, file);
2313
2314	audio_sc_release(sc, &sc_ref);
2315done:
2316	curlwp_bindx(bound);
2317	return error;
2318}
2319
2320
2321/*
2322 * Audio driver
2323 */
2324
2325/*
2326 * Must be called with sc_exlock held and without sc_lock held.
2327 */
2328int
2329audio_open(dev_t dev, struct audio_softc *sc, int flags, int ifmt,
2330	struct lwp *l, audio_file_t **bellfile)
2331{
2332	struct audio_info ai;
2333	struct file *fp;
2334	audio_file_t *af;
2335	audio_ring_t *hwbuf;
2336	bool fullduplex;
2337	bool cred_held;
2338	bool hw_opened;
2339	bool rmixer_started;
2340	bool inserted;
2341	int fd;
2342	int error;
2343
2344	KASSERT(sc->sc_exlock);
2345
2346	TRACE(1, "%sdev=%s flags=0x%x po=%d ro=%d",
2347	    (audiodebug >= 3) ? "start " : "",
2348	    ISDEVSOUND(dev) ? "sound" : "audio",
2349	    flags, sc->sc_popens, sc->sc_ropens);
2350
2351	fp = NULL;
2352	cred_held = false;
2353	hw_opened = false;
2354	rmixer_started = false;
2355	inserted = false;
2356
2357	af = kmem_zalloc(sizeof(*af), KM_SLEEP);
2358	af->sc = sc;
2359	af->dev = dev;
2360	if ((flags & FWRITE) != 0 && audio_can_playback(sc))
2361		af->mode |= AUMODE_PLAY | AUMODE_PLAY_ALL;
2362	if ((flags & FREAD) != 0 && audio_can_capture(sc))
2363		af->mode |= AUMODE_RECORD;
2364	if (af->mode == 0) {
2365		error = ENXIO;
2366		goto bad;
2367	}
2368
2369	fullduplex = (sc->sc_props & AUDIO_PROP_FULLDUPLEX);
2370
2371	/*
2372	 * On half duplex hardware,
2373	 * 1. if mode is (PLAY | REC), let mode PLAY.
2374	 * 2. if mode is PLAY, let mode PLAY if no rec tracks, otherwise error.
2375	 * 3. if mode is REC, let mode REC if no play tracks, otherwise error.
2376	 */
2377	if (fullduplex == false) {
2378		if ((af->mode & AUMODE_PLAY)) {
2379			if (sc->sc_ropens != 0) {
2380				TRACE(1, "record track already exists");
2381				error = ENODEV;
2382				goto bad;
2383			}
2384			/* Play takes precedence */
2385			af->mode &= ~AUMODE_RECORD;
2386		}
2387		if ((af->mode & AUMODE_RECORD)) {
2388			if (sc->sc_popens != 0) {
2389				TRACE(1, "play track already exists");
2390				error = ENODEV;
2391				goto bad;
2392			}
2393		}
2394	}
2395
2396	/* Create tracks */
2397	if ((af->mode & AUMODE_PLAY))
2398		af->ptrack = audio_track_create(sc, sc->sc_pmixer);
2399	if ((af->mode & AUMODE_RECORD))
2400		af->rtrack = audio_track_create(sc, sc->sc_rmixer);
2401
2402	/* Set parameters */
2403	AUDIO_INITINFO(&ai);
2404	if (bellfile) {
2405		/* If audiobell, only sample_rate will be set later. */
2406		ai.play.sample_rate   = audio_default.sample_rate;
2407		ai.play.encoding      = AUDIO_ENCODING_SLINEAR_NE;
2408		ai.play.channels      = 1;
2409		ai.play.precision     = 16;
2410		ai.play.pause         = 0;
2411	} else if (ISDEVAUDIO(dev)) {
2412		/* If /dev/audio, initialize everytime. */
2413		ai.play.sample_rate   = audio_default.sample_rate;
2414		ai.play.encoding      = audio_default.encoding;
2415		ai.play.channels      = audio_default.channels;
2416		ai.play.precision     = audio_default.precision;
2417		ai.play.pause         = 0;
2418		ai.record.sample_rate = audio_default.sample_rate;
2419		ai.record.encoding    = audio_default.encoding;
2420		ai.record.channels    = audio_default.channels;
2421		ai.record.precision   = audio_default.precision;
2422		ai.record.pause       = 0;
2423	} else {
2424		/* If /dev/sound, take over the previous parameters. */
2425		ai.play.sample_rate   = sc->sc_sound_pparams.sample_rate;
2426		ai.play.encoding      = sc->sc_sound_pparams.encoding;
2427		ai.play.channels      = sc->sc_sound_pparams.channels;
2428		ai.play.precision     = sc->sc_sound_pparams.precision;
2429		ai.play.pause         = sc->sc_sound_ppause;
2430		ai.record.sample_rate = sc->sc_sound_rparams.sample_rate;
2431		ai.record.encoding    = sc->sc_sound_rparams.encoding;
2432		ai.record.channels    = sc->sc_sound_rparams.channels;
2433		ai.record.precision   = sc->sc_sound_rparams.precision;
2434		ai.record.pause       = sc->sc_sound_rpause;
2435	}
2436	error = audio_file_setinfo(sc, af, &ai);
2437	if (error)
2438		goto bad;
2439
2440	if (sc->sc_popens + sc->sc_ropens == 0) {
2441		/* First open */
2442
2443		sc->sc_cred = kauth_cred_get();
2444		kauth_cred_hold(sc->sc_cred);
2445		cred_held = true;
2446
2447		if (sc->hw_if->open) {
2448			int hwflags;
2449
2450			/*
2451			 * Call hw_if->open() only at first open of
2452			 * combination of playback and recording.
2453			 * On full duplex hardware, the flags passed to
2454			 * hw_if->open() is always (FREAD | FWRITE)
2455			 * regardless of this open()'s flags.
2456			 * see also dev/isa/aria.c
2457			 * On half duplex hardware, the flags passed to
2458			 * hw_if->open() is either FREAD or FWRITE.
2459			 * see also arch/evbarm/mini2440/audio_mini2440.c
2460			 */
2461			if (fullduplex) {
2462				hwflags = FREAD | FWRITE;
2463			} else {
2464				/* Construct hwflags from af->mode. */
2465				hwflags = 0;
2466				if ((af->mode & AUMODE_PLAY) != 0)
2467					hwflags |= FWRITE;
2468				if ((af->mode & AUMODE_RECORD) != 0)
2469					hwflags |= FREAD;
2470			}
2471
2472			mutex_enter(sc->sc_lock);
2473			mutex_enter(sc->sc_intr_lock);
2474			error = sc->hw_if->open(sc->hw_hdl, hwflags);
2475			mutex_exit(sc->sc_intr_lock);
2476			mutex_exit(sc->sc_lock);
2477			if (error)
2478				goto bad;
2479		}
2480		/*
2481		 * Regardless of whether we called hw_if->open (whether
2482		 * hw_if->open exists) or not, we move to the Opened phase
2483		 * here.  Therefore from this point, we have to call
2484		 * hw_if->close (if exists) whenever abort.
2485		 * Note that both of hw_if->{open,close} are optional.
2486		 */
2487		hw_opened = true;
2488
2489		/*
2490		 * Set speaker mode when a half duplex.
2491		 * XXX I'm not sure this is correct.
2492		 */
2493		if (1/*XXX*/) {
2494			if (sc->hw_if->speaker_ctl) {
2495				int on;
2496				if (af->ptrack) {
2497					on = 1;
2498				} else {
2499					on = 0;
2500				}
2501				mutex_enter(sc->sc_lock);
2502				mutex_enter(sc->sc_intr_lock);
2503				error = sc->hw_if->speaker_ctl(sc->hw_hdl, on);
2504				mutex_exit(sc->sc_intr_lock);
2505				mutex_exit(sc->sc_lock);
2506				if (error)
2507					goto bad;
2508			}
2509		}
2510	} else if (sc->sc_multiuser == false) {
2511		uid_t euid = kauth_cred_geteuid(kauth_cred_get());
2512		if (euid != 0 && euid != kauth_cred_geteuid(sc->sc_cred)) {
2513			error = EPERM;
2514			goto bad;
2515		}
2516	}
2517
2518	/* Call init_output if this is the first playback open. */
2519	if (af->ptrack && sc->sc_popens == 0) {
2520		if (sc->hw_if->init_output) {
2521			hwbuf = &sc->sc_pmixer->hwbuf;
2522			mutex_enter(sc->sc_lock);
2523			mutex_enter(sc->sc_intr_lock);
2524			error = sc->hw_if->init_output(sc->hw_hdl,
2525			    hwbuf->mem,
2526			    hwbuf->capacity *
2527			    hwbuf->fmt.channels * hwbuf->fmt.stride / NBBY);
2528			mutex_exit(sc->sc_intr_lock);
2529			mutex_exit(sc->sc_lock);
2530			if (error)
2531				goto bad;
2532		}
2533	}
2534	/*
2535	 * Call init_input and start rmixer, if this is the first recording
2536	 * open.  See pause consideration notes.
2537	 */
2538	if (af->rtrack && sc->sc_ropens == 0) {
2539		if (sc->hw_if->init_input) {
2540			hwbuf = &sc->sc_rmixer->hwbuf;
2541			mutex_enter(sc->sc_lock);
2542			mutex_enter(sc->sc_intr_lock);
2543			error = sc->hw_if->init_input(sc->hw_hdl,
2544			    hwbuf->mem,
2545			    hwbuf->capacity *
2546			    hwbuf->fmt.channels * hwbuf->fmt.stride / NBBY);
2547			mutex_exit(sc->sc_intr_lock);
2548			mutex_exit(sc->sc_lock);
2549			if (error)
2550				goto bad;
2551		}
2552
2553		mutex_enter(sc->sc_lock);
2554		audio_rmixer_start(sc);
2555		mutex_exit(sc->sc_lock);
2556		rmixer_started = true;
2557	}
2558
2559	/*
2560	 * This is the last sc_lock section in the function, so we have to
2561	 * examine sc_dying again before starting the rest tasks.  Because
2562	 * audiodeatch() may have been invoked (and it would set sc_dying)
2563	 * from the time audioopen() was executed until now.  If it happens,
2564	 * audiodetach() may already have set file->dying for all sc_files
2565	 * that exist at that point, so that audioopen() must abort without
2566	 * inserting af to sc_files, in order to keep consistency.
2567	 */
2568	mutex_enter(sc->sc_lock);
2569	if (sc->sc_dying) {
2570		mutex_exit(sc->sc_lock);
2571		error = ENXIO;
2572		goto bad;
2573	}
2574
2575	/* Count up finally */
2576	if (af->ptrack)
2577		sc->sc_popens++;
2578	if (af->rtrack)
2579		sc->sc_ropens++;
2580	mutex_enter(sc->sc_intr_lock);
2581	SLIST_INSERT_HEAD(&sc->sc_files, af, entry);
2582	mutex_exit(sc->sc_intr_lock);
2583	mutex_exit(sc->sc_lock);
2584	inserted = true;
2585
2586	if (bellfile) {
2587		*bellfile = af;
2588	} else {
2589		error = fd_allocfile(&fp, &fd);
2590		if (error)
2591			goto bad;
2592
2593		error = fd_clone(fp, fd, flags, &audio_fileops, af);
2594		KASSERTMSG(error == EMOVEFD, "error=%d", error);
2595	}
2596
2597	/* Be nothing else after fd_clone */
2598
2599	TRACEF(3, af, "done");
2600	return error;
2601
2602bad:
2603	if (inserted) {
2604		mutex_enter(sc->sc_lock);
2605		mutex_enter(sc->sc_intr_lock);
2606		SLIST_REMOVE(&sc->sc_files, af, audio_file, entry);
2607		mutex_exit(sc->sc_intr_lock);
2608		if (af->ptrack)
2609			sc->sc_popens--;
2610		if (af->rtrack)
2611			sc->sc_ropens--;
2612		mutex_exit(sc->sc_lock);
2613	}
2614
2615	if (rmixer_started) {
2616		mutex_enter(sc->sc_lock);
2617		audio_rmixer_halt(sc);
2618		mutex_exit(sc->sc_lock);
2619	}
2620
2621	if (hw_opened) {
2622		if (sc->hw_if->close) {
2623			mutex_enter(sc->sc_lock);
2624			mutex_enter(sc->sc_intr_lock);
2625			sc->hw_if->close(sc->hw_hdl);
2626			mutex_exit(sc->sc_intr_lock);
2627			mutex_exit(sc->sc_lock);
2628		}
2629	}
2630	if (cred_held) {
2631		kauth_cred_free(sc->sc_cred);
2632	}
2633
2634	/*
2635	 * Since track here is not yet linked to sc_files,
2636	 * you can call track_destroy() without sc_intr_lock.
2637	 */
2638	if (af->rtrack) {
2639		audio_track_destroy(af->rtrack);
2640		af->rtrack = NULL;
2641	}
2642	if (af->ptrack) {
2643		audio_track_destroy(af->ptrack);
2644		af->ptrack = NULL;
2645	}
2646
2647	kmem_free(af, sizeof(*af));
2648	return error;
2649}
2650
2651/*
2652 * Must be called without sc_lock nor sc_exlock held.
2653 */
2654int
2655audio_close(struct audio_softc *sc, audio_file_t *file)
2656{
2657	int error;
2658
2659	/*
2660	 * Drain first.
2661	 * It must be done before unlinking(acquiring exlock).
2662	 */
2663	if (file->ptrack) {
2664		mutex_enter(sc->sc_lock);
2665		audio_track_drain(sc, file->ptrack);
2666		mutex_exit(sc->sc_lock);
2667	}
2668
2669	mutex_enter(sc->sc_lock);
2670	mutex_enter(sc->sc_intr_lock);
2671	SLIST_REMOVE(&sc->sc_files, file, audio_file, entry);
2672	mutex_exit(sc->sc_intr_lock);
2673	mutex_exit(sc->sc_lock);
2674
2675	error = audio_exlock_enter(sc);
2676	if (error) {
2677		/*
2678		 * If EIO, this sc is about to detach.  In this case, even if
2679		 * we don't do subsequent _unlink(), audiodetach() will do it.
2680		 */
2681		if (error == EIO)
2682			return error;
2683
2684		/* XXX This should not happen but what should I do ? */
2685		panic("%s: can't acquire exlock: errno=%d", __func__, error);
2686	}
2687	audio_unlink(sc, file);
2688	audio_exlock_exit(sc);
2689
2690	return 0;
2691}
2692
2693/*
2694 * Unlink this file, but not freeing memory here.
2695 * Must be called with sc_exlock held and without sc_lock held.
2696 */
2697static void
2698audio_unlink(struct audio_softc *sc, audio_file_t *file)
2699{
2700	kauth_cred_t cred = NULL;
2701	int error;
2702
2703	mutex_enter(sc->sc_lock);
2704
2705	TRACEF(1, file, "%spid=%d.%d po=%d ro=%d",
2706	    (audiodebug >= 3) ? "start " : "",
2707	    (int)curproc->p_pid, (int)curlwp->l_lid,
2708	    sc->sc_popens, sc->sc_ropens);
2709	KASSERTMSG(sc->sc_popens + sc->sc_ropens > 0,
2710	    "sc->sc_popens=%d, sc->sc_ropens=%d",
2711	    sc->sc_popens, sc->sc_ropens);
2712
2713	device_active(sc->sc_dev, DVA_SYSTEM);
2714
2715	if (file->ptrack) {
2716		TRACET(3, file->ptrack, "dropframes=%" PRIu64,
2717		    file->ptrack->dropframes);
2718
2719		KASSERT(sc->sc_popens > 0);
2720		sc->sc_popens--;
2721
2722		/* Call hw halt_output if this is the last playback track. */
2723		if (sc->sc_popens == 0 && sc->sc_pbusy) {
2724			error = audio_pmixer_halt(sc);
2725			if (error) {
2726				audio_printf(sc,
2727				    "halt_output failed: errno=%d (ignored)\n",
2728				    error);
2729			}
2730		}
2731
2732		/* Restore mixing volume if all tracks are gone. */
2733		if (sc->sc_popens == 0) {
2734			/* intr_lock is not necessary, but just manners. */
2735			mutex_enter(sc->sc_intr_lock);
2736			sc->sc_pmixer->volume = 256;
2737			sc->sc_pmixer->voltimer = 0;
2738			mutex_exit(sc->sc_intr_lock);
2739		}
2740	}
2741	if (file->rtrack) {
2742		TRACET(3, file->rtrack, "dropframes=%" PRIu64,
2743		    file->rtrack->dropframes);
2744
2745		KASSERT(sc->sc_ropens > 0);
2746		sc->sc_ropens--;
2747
2748		/* Call hw halt_input if this is the last recording track. */
2749		if (sc->sc_ropens == 0 && sc->sc_rbusy) {
2750			error = audio_rmixer_halt(sc);
2751			if (error) {
2752				audio_printf(sc,
2753				    "halt_input failed: errno=%d (ignored)\n",
2754				    error);
2755			}
2756		}
2757
2758	}
2759
2760	/* Call hw close if this is the last track. */
2761	if (sc->sc_popens + sc->sc_ropens == 0) {
2762		if (sc->hw_if->close) {
2763			TRACE(2, "hw_if close");
2764			mutex_enter(sc->sc_intr_lock);
2765			sc->hw_if->close(sc->hw_hdl);
2766			mutex_exit(sc->sc_intr_lock);
2767		}
2768		cred = sc->sc_cred;
2769		sc->sc_cred = NULL;
2770	}
2771
2772	mutex_exit(sc->sc_lock);
2773	if (cred)
2774		kauth_cred_free(cred);
2775
2776	TRACE(3, "done");
2777}
2778
2779/*
2780 * Must be called without sc_lock nor sc_exlock held.
2781 */
2782int
2783audio_read(struct audio_softc *sc, struct uio *uio, int ioflag,
2784	audio_file_t *file)
2785{
2786	audio_track_t *track;
2787	audio_ring_t *usrbuf;
2788	audio_ring_t *input;
2789	int error;
2790
2791	/*
2792	 * On half-duplex hardware, O_RDWR is treated as O_WRONLY.
2793	 * However read() system call itself can be called because it's
2794	 * opened with O_RDWR.  So in this case, deny this read().
2795	 */
2796	track = file->rtrack;
2797	if (track == NULL) {
2798		return EBADF;
2799	}
2800
2801	/* I think it's better than EINVAL. */
2802	if (track->mmapped)
2803		return EPERM;
2804
2805	TRACET(2, track, "resid=%zd ioflag=0x%x", uio->uio_resid, ioflag);
2806
2807#ifdef AUDIO_PM_IDLE
2808	error = audio_exlock_mutex_enter(sc);
2809	if (error)
2810		return error;
2811
2812	if (device_is_active(&sc->sc_dev) || sc->sc_idle)
2813		device_active(&sc->sc_dev, DVA_SYSTEM);
2814
2815	/* In recording, unlike playback, read() never operates rmixer. */
2816
2817	audio_exlock_mutex_exit(sc);
2818#endif
2819
2820	usrbuf = &track->usrbuf;
2821	input = track->input;
2822	error = 0;
2823
2824	while (uio->uio_resid > 0 && error == 0) {
2825		int bytes;
2826
2827		TRACET(3, track,
2828		    "while resid=%zd input=%d/%d/%d usrbuf=%d/%d/C%d",
2829		    uio->uio_resid,
2830		    input->head, input->used, input->capacity,
2831		    usrbuf->head, usrbuf->used, usrbuf->capacity);
2832
2833		/* Wait when buffers are empty. */
2834		mutex_enter(sc->sc_lock);
2835		for (;;) {
2836			bool empty;
2837			audio_track_lock_enter(track);
2838			empty = (input->used == 0 && usrbuf->used == 0);
2839			audio_track_lock_exit(track);
2840			if (!empty)
2841				break;
2842
2843			if ((ioflag & IO_NDELAY)) {
2844				mutex_exit(sc->sc_lock);
2845				return EWOULDBLOCK;
2846			}
2847
2848			TRACET(3, track, "sleep");
2849			error = audio_track_waitio(sc, track, "audio_read");
2850			if (error) {
2851				mutex_exit(sc->sc_lock);
2852				return error;
2853			}
2854		}
2855		mutex_exit(sc->sc_lock);
2856
2857		audio_track_lock_enter(track);
2858		/* Convert one block if possible. */
2859		if (usrbuf->used == 0 && input->used > 0) {
2860			audio_track_record(track);
2861		}
2862
2863		/* uiomove from usrbuf as many bytes as possible. */
2864		bytes = uimin(usrbuf->used, uio->uio_resid);
2865		error = uiomove((uint8_t *)usrbuf->mem + usrbuf->head, bytes,
2866		    uio);
2867		if (error) {
2868			audio_track_lock_exit(track);
2869			device_printf(sc->sc_dev,
2870			    "%s: uiomove(%d) failed: errno=%d\n",
2871			    __func__, bytes, error);
2872			goto abort;
2873		}
2874		auring_take(usrbuf, bytes);
2875		TRACET(3, track, "uiomove(len=%d) usrbuf=%d/%d/C%d",
2876		    bytes,
2877		    usrbuf->head, usrbuf->used, usrbuf->capacity);
2878
2879		audio_track_lock_exit(track);
2880	}
2881
2882abort:
2883	return error;
2884}
2885
2886
2887/*
2888 * Clear file's playback and/or record track buffer immediately.
2889 */
2890static void
2891audio_file_clear(struct audio_softc *sc, audio_file_t *file)
2892{
2893
2894	if (file->ptrack)
2895		audio_track_clear(sc, file->ptrack);
2896	if (file->rtrack)
2897		audio_track_clear(sc, file->rtrack);
2898}
2899
2900/*
2901 * Must be called without sc_lock nor sc_exlock held.
2902 */
2903int
2904audio_write(struct audio_softc *sc, struct uio *uio, int ioflag,
2905	audio_file_t *file)
2906{
2907	audio_track_t *track;
2908	audio_ring_t *usrbuf;
2909	audio_ring_t *outbuf;
2910	int error;
2911
2912	track = file->ptrack;
2913	if (track == NULL)
2914		return EPERM;
2915
2916	/* I think it's better than EINVAL. */
2917	if (track->mmapped)
2918		return EPERM;
2919
2920	TRACET(2, track, "%sresid=%zd pid=%d.%d ioflag=0x%x",
2921	    audiodebug >= 3 ? "begin " : "",
2922	    uio->uio_resid, (int)curproc->p_pid, (int)curlwp->l_lid, ioflag);
2923
2924	if (uio->uio_resid == 0) {
2925		track->eofcounter++;
2926		return 0;
2927	}
2928
2929	error = audio_exlock_mutex_enter(sc);
2930	if (error)
2931		return error;
2932
2933#ifdef AUDIO_PM_IDLE
2934	if (device_is_active(&sc->sc_dev) || sc->sc_idle)
2935		device_active(&sc->sc_dev, DVA_SYSTEM);
2936#endif
2937
2938	/*
2939	 * The first write starts pmixer.
2940	 */
2941	if (sc->sc_pbusy == false)
2942		audio_pmixer_start(sc, false);
2943	audio_exlock_mutex_exit(sc);
2944
2945	usrbuf = &track->usrbuf;
2946	outbuf = &track->outbuf;
2947	track->pstate = AUDIO_STATE_RUNNING;
2948	error = 0;
2949
2950	while (uio->uio_resid > 0 && error == 0) {
2951		int bytes;
2952
2953		TRACET(3, track, "while resid=%zd usrbuf=%d/%d/H%d",
2954		    uio->uio_resid,
2955		    usrbuf->head, usrbuf->used, track->usrbuf_usedhigh);
2956
2957		/* Wait when buffers are full. */
2958		mutex_enter(sc->sc_lock);
2959		for (;;) {
2960			bool full;
2961			audio_track_lock_enter(track);
2962			full = (usrbuf->used >= track->usrbuf_usedhigh &&
2963			    outbuf->used >= outbuf->capacity);
2964			audio_track_lock_exit(track);
2965			if (!full)
2966				break;
2967
2968			if ((ioflag & IO_NDELAY)) {
2969				error = EWOULDBLOCK;
2970				mutex_exit(sc->sc_lock);
2971				goto abort;
2972			}
2973
2974			TRACET(3, track, "sleep usrbuf=%d/H%d",
2975			    usrbuf->used, track->usrbuf_usedhigh);
2976			error = audio_track_waitio(sc, track, "audio_write");
2977			if (error) {
2978				mutex_exit(sc->sc_lock);
2979				goto abort;
2980			}
2981		}
2982		mutex_exit(sc->sc_lock);
2983
2984		audio_track_lock_enter(track);
2985
2986		/* uiomove to usrbuf as many bytes as possible. */
2987		bytes = uimin(track->usrbuf_usedhigh - usrbuf->used,
2988		    uio->uio_resid);
2989		while (bytes > 0) {
2990			int tail = auring_tail(usrbuf);
2991			int len = uimin(bytes, usrbuf->capacity - tail);
2992			error = uiomove((uint8_t *)usrbuf->mem + tail, len,
2993			    uio);
2994			if (error) {
2995				audio_track_lock_exit(track);
2996				device_printf(sc->sc_dev,
2997				    "%s: uiomove(%d) failed: errno=%d\n",
2998				    __func__, len, error);
2999				goto abort;
3000			}
3001			auring_push(usrbuf, len);
3002			TRACET(3, track, "uiomove(len=%d) usrbuf=%d/%d/C%d",
3003			    len,
3004			    usrbuf->head, usrbuf->used, usrbuf->capacity);
3005			bytes -= len;
3006		}
3007
3008		/* Convert them as many blocks as possible. */
3009		while (usrbuf->used >= track->usrbuf_blksize &&
3010		    outbuf->used < outbuf->capacity) {
3011			audio_track_play(track);
3012		}
3013
3014		audio_track_lock_exit(track);
3015	}
3016
3017abort:
3018	TRACET(3, track, "done error=%d", error);
3019	return error;
3020}
3021
3022/*
3023 * Must be called without sc_lock nor sc_exlock held.
3024 */
3025int
3026audio_ioctl(dev_t dev, struct audio_softc *sc, u_long cmd, void *addr, int flag,
3027	struct lwp *l, audio_file_t *file)
3028{
3029	struct audio_offset *ao;
3030	struct audio_info ai;
3031	audio_track_t *track;
3032	audio_encoding_t *ae;
3033	audio_format_query_t *query;
3034	u_int stamp;
3035	u_int offset;
3036	int val;
3037	int index;
3038	int error;
3039
3040#if defined(AUDIO_DEBUG)
3041	const char *ioctlnames[] = {
3042		"AUDIO_GETINFO",	/* 21 */
3043		"AUDIO_SETINFO",	/* 22 */
3044		"AUDIO_DRAIN",		/* 23 */
3045		"AUDIO_FLUSH",		/* 24 */
3046		"AUDIO_WSEEK",		/* 25 */
3047		"AUDIO_RERROR",		/* 26 */
3048		"AUDIO_GETDEV",		/* 27 */
3049		"AUDIO_GETENC",		/* 28 */
3050		"AUDIO_GETFD",		/* 29 */
3051		"AUDIO_SETFD",		/* 30 */
3052		"AUDIO_PERROR",		/* 31 */
3053		"AUDIO_GETIOFFS",	/* 32 */
3054		"AUDIO_GETOOFFS",	/* 33 */
3055		"AUDIO_GETPROPS",	/* 34 */
3056		"AUDIO_GETBUFINFO",	/* 35 */
3057		"AUDIO_SETCHAN",	/* 36 */
3058		"AUDIO_GETCHAN",	/* 37 */
3059		"AUDIO_QUERYFORMAT",	/* 38 */
3060		"AUDIO_GETFORMAT",	/* 39 */
3061		"AUDIO_SETFORMAT",	/* 40 */
3062	};
3063	char pre[64];
3064	int nameidx = (cmd & 0xff);
3065	if (21 <= nameidx && nameidx <= 21 + __arraycount(ioctlnames)) {
3066		snprintf(pre, sizeof(pre), "pid=%d.%d %s",
3067		    (int)curproc->p_pid, (int)l->l_lid,
3068		    ioctlnames[nameidx - 21]);
3069	} else {
3070		snprintf(pre, sizeof(pre), "pid=%d.%d (%lu,'%c',%u)",
3071		    (int)curproc->p_pid, (int)l->l_lid,
3072		    IOCPARM_LEN(cmd), (char)IOCGROUP(cmd), nameidx);
3073	}
3074#endif
3075
3076	error = 0;
3077	switch (cmd) {
3078	case FIONBIO:
3079		/* All handled in the upper FS layer. */
3080		break;
3081
3082	case FIONREAD:
3083		/* Get the number of bytes that can be read. */
3084		track = file->rtrack;
3085		if (track) {
3086			val = audio_track_readablebytes(track);
3087			*(int *)addr = val;
3088			TRACET(2, track, "pid=%d.%d FIONREAD bytes=%d",
3089			    (int)curproc->p_pid, (int)l->l_lid, val);
3090		} else {
3091			TRACEF(2, file, "pid=%d.%d FIONREAD no track",
3092			    (int)curproc->p_pid, (int)l->l_lid);
3093		}
3094		break;
3095
3096	case FIOASYNC:
3097		/* Set/Clear ASYNC I/O. */
3098		if (*(int *)addr) {
3099			file->async_audio = curproc->p_pid;
3100		} else {
3101			file->async_audio = 0;
3102		}
3103		TRACEF(2, file, "pid=%d.%d FIOASYNC %s",
3104		    (int)curproc->p_pid, (int)l->l_lid,
3105		    file->async_audio ? "on" : "off");
3106		break;
3107
3108	case AUDIO_FLUSH:
3109		/* XXX TODO: clear errors and restart? */
3110		TRACEF(2, file, "%s", pre);
3111		audio_file_clear(sc, file);
3112		break;
3113
3114	case AUDIO_PERROR:
3115	case AUDIO_RERROR:
3116		/*
3117		 * Number of dropped bytes during playback/record.  We don't
3118		 * know where or when they were dropped (including conversion
3119		 * stage).  Therefore, the number of accurate bytes or samples
3120		 * is also unknown.
3121		 */
3122		track = (cmd == AUDIO_PERROR) ? file->ptrack : file->rtrack;
3123		if (track) {
3124			val = frametobyte(&track->usrbuf.fmt,
3125			    track->dropframes);
3126			*(int *)addr = val;
3127			TRACET(2, track, "%s bytes=%d", pre, val);
3128		} else {
3129			TRACEF(2, file, "%s no track", pre);
3130		}
3131		break;
3132
3133	case AUDIO_GETIOFFS:
3134		ao = (struct audio_offset *)addr;
3135		track = file->rtrack;
3136		if (track == NULL) {
3137			ao->samples = 0;
3138			ao->deltablks = 0;
3139			ao->offset = 0;
3140			TRACEF(2, file, "%s no rtrack", pre);
3141			break;
3142		}
3143		mutex_enter(sc->sc_lock);
3144		mutex_enter(sc->sc_intr_lock);
3145		/* figure out where next transfer will start */
3146		stamp = track->stamp;
3147		offset = auring_tail(track->input);
3148		mutex_exit(sc->sc_intr_lock);
3149		mutex_exit(sc->sc_lock);
3150
3151		/* samples will overflow soon but is as per spec. */
3152		ao->samples = stamp * track->usrbuf_blksize;
3153		ao->deltablks = stamp - track->last_stamp;
3154		ao->offset = audio_track_inputblk_as_usrbyte(track, offset);
3155		TRACET(2, track, "%s samples=%u deltablks=%u offset=%u",
3156		    pre, ao->samples, ao->deltablks, ao->offset);
3157
3158		track->last_stamp = stamp;
3159		break;
3160
3161	case AUDIO_GETOOFFS:
3162		ao = (struct audio_offset *)addr;
3163		track = file->ptrack;
3164		if (track == NULL) {
3165			ao->samples = 0;
3166			ao->deltablks = 0;
3167			ao->offset = 0;
3168			TRACEF(2, file, "%s no ptrack", pre);
3169			break;
3170		}
3171		mutex_enter(sc->sc_lock);
3172		mutex_enter(sc->sc_intr_lock);
3173		/* figure out where next transfer will start */
3174		stamp = track->stamp;
3175		offset = track->usrbuf.head;
3176		mutex_exit(sc->sc_intr_lock);
3177		mutex_exit(sc->sc_lock);
3178
3179		/* samples will overflow soon but is as per spec. */
3180		ao->samples = stamp * track->usrbuf_blksize;
3181		ao->deltablks = stamp - track->last_stamp;
3182		ao->offset = offset;
3183		TRACET(2, track, "%s samples=%u deltablks=%u offset=%u",
3184		    pre, ao->samples, ao->deltablks, ao->offset);
3185
3186		track->last_stamp = stamp;
3187		break;
3188
3189	case AUDIO_WSEEK:
3190		track = file->ptrack;
3191		if (track) {
3192			val = track->usrbuf.used;
3193			*(u_long *)addr = val;
3194			TRACET(2, track, "%s bytes=%d", pre, val);
3195		} else {
3196			TRACEF(2, file, "%s no ptrack", pre);
3197		}
3198		break;
3199
3200	case AUDIO_SETINFO:
3201		TRACEF(2, file, "%s", pre);
3202		error = audio_exlock_enter(sc);
3203		if (error)
3204			break;
3205		error = audio_file_setinfo(sc, file, (struct audio_info *)addr);
3206		if (error) {
3207			audio_exlock_exit(sc);
3208			break;
3209		}
3210		if (ISDEVSOUND(dev))
3211			error = audiogetinfo(sc, &sc->sc_ai, 0, file);
3212		audio_exlock_exit(sc);
3213		break;
3214
3215	case AUDIO_GETINFO:
3216		TRACEF(2, file, "%s", pre);
3217		error = audio_exlock_enter(sc);
3218		if (error)
3219			break;
3220		error = audiogetinfo(sc, (struct audio_info *)addr, 1, file);
3221		audio_exlock_exit(sc);
3222		break;
3223
3224	case AUDIO_GETBUFINFO:
3225		TRACEF(2, file, "%s", pre);
3226		error = audio_exlock_enter(sc);
3227		if (error)
3228			break;
3229		error = audiogetinfo(sc, (struct audio_info *)addr, 0, file);
3230		audio_exlock_exit(sc);
3231		break;
3232
3233	case AUDIO_DRAIN:
3234		track = file->ptrack;
3235		if (track) {
3236			TRACET(2, track, "%s", pre);
3237			mutex_enter(sc->sc_lock);
3238			error = audio_track_drain(sc, track);
3239			mutex_exit(sc->sc_lock);
3240		} else {
3241			TRACEF(2, file, "%s no ptrack", pre);
3242		}
3243		break;
3244
3245	case AUDIO_GETDEV:
3246		TRACEF(2, file, "%s", pre);
3247		error = sc->hw_if->getdev(sc->hw_hdl, (audio_device_t *)addr);
3248		break;
3249
3250	case AUDIO_GETENC:
3251		ae = (audio_encoding_t *)addr;
3252		index = ae->index;
3253		TRACEF(2, file, "%s index=%d", pre, index);
3254		if (index < 0 || index >= __arraycount(audio_encodings)) {
3255			error = EINVAL;
3256			break;
3257		}
3258		*ae = audio_encodings[index];
3259		ae->index = index;
3260		/*
3261		 * EMULATED always.
3262		 * EMULATED flag at that time used to mean that it could
3263		 * not be passed directly to the hardware as-is.  But
3264		 * currently, all formats including hardware native is not
3265		 * passed directly to the hardware.  So I set EMULATED
3266		 * flag for all formats.
3267		 */
3268		ae->flags = AUDIO_ENCODINGFLAG_EMULATED;
3269		break;
3270
3271	case AUDIO_GETFD:
3272		/*
3273		 * Returns the current setting of full duplex mode.
3274		 * If HW has full duplex mode and there are two mixers,
3275		 * it is full duplex.  Otherwise half duplex.
3276		 */
3277		error = audio_exlock_enter(sc);
3278		if (error)
3279			break;
3280		val = (sc->sc_props & AUDIO_PROP_FULLDUPLEX)
3281		    && (sc->sc_pmixer && sc->sc_rmixer);
3282		audio_exlock_exit(sc);
3283		*(int *)addr = val;
3284		TRACEF(2, file, "%s fulldup=%d", pre, val);
3285		break;
3286
3287	case AUDIO_GETPROPS:
3288		val = sc->sc_props;
3289		*(int *)addr = val;
3290#if defined(AUDIO_DEBUG)
3291		char pbuf[64];
3292		snprintb(pbuf, sizeof(pbuf), "\x10"
3293		    "\6CAPTURE" "\5PLAY" "\3INDEP" "\2MMAP" "\1FULLDUP", val);
3294		TRACEF(2, file, "%s %s", pre, pbuf);
3295#endif
3296		break;
3297
3298	case AUDIO_QUERYFORMAT:
3299		query = (audio_format_query_t *)addr;
3300		TRACEF(2, file, "%s index=%u", pre, query->index);
3301		mutex_enter(sc->sc_lock);
3302		error = sc->hw_if->query_format(sc->hw_hdl, query);
3303		mutex_exit(sc->sc_lock);
3304		/* Hide internal information */
3305		query->fmt.driver_data = NULL;
3306		break;
3307
3308	case AUDIO_GETFORMAT:
3309		TRACEF(2, file, "%s", pre);
3310		error = audio_exlock_enter(sc);
3311		if (error)
3312			break;
3313		audio_mixers_get_format(sc, (struct audio_info *)addr);
3314		audio_exlock_exit(sc);
3315		break;
3316
3317	case AUDIO_SETFORMAT:
3318		TRACEF(2, file, "%s", pre);
3319		error = audio_exlock_enter(sc);
3320		audio_mixers_get_format(sc, &ai);
3321		error = audio_mixers_set_format(sc, (struct audio_info *)addr);
3322		if (error) {
3323			/* Rollback */
3324			audio_mixers_set_format(sc, &ai);
3325		}
3326		audio_exlock_exit(sc);
3327		break;
3328
3329	case AUDIO_SETFD:
3330	case AUDIO_SETCHAN:
3331	case AUDIO_GETCHAN:
3332		/* Obsoleted */
3333		TRACEF(2, file, "%s", pre);
3334		break;
3335
3336	default:
3337		TRACEF(2, file, "%s", pre);
3338		if (sc->hw_if->dev_ioctl) {
3339			mutex_enter(sc->sc_lock);
3340			error = sc->hw_if->dev_ioctl(sc->hw_hdl,
3341			    cmd, addr, flag, l);
3342			mutex_exit(sc->sc_lock);
3343		} else {
3344			error = EINVAL;
3345		}
3346		break;
3347	}
3348
3349	if (error)
3350		TRACEF(2, file, "%s error=%d", pre, error);
3351	return error;
3352}
3353
3354/*
3355 * Convert n [frames] of the input buffer to bytes in the usrbuf format.
3356 * n is in frames but should be a multiple of frame/block.  Note that the
3357 * usrbuf's frame/block and the input buffer's frame/block may be different
3358 * (i.e., if frequencies are different).
3359 *
3360 * This function is for recording track only.
3361 */
3362static int
3363audio_track_inputblk_as_usrbyte(const audio_track_t *track, int n)
3364{
3365	int input_fpb;
3366
3367	/*
3368	 * In the input buffer on recording track, these are the same.
3369	 * input_fpb = frame_per_block(track->mixer, &track->input->fmt);
3370	 */
3371	input_fpb = track->mixer->frames_per_block;
3372
3373	return (n / input_fpb) * track->usrbuf_blksize;
3374}
3375
3376/*
3377 * Returns the number of bytes that can be read on recording buffer.
3378 */
3379static int
3380audio_track_readablebytes(const audio_track_t *track)
3381{
3382	int bytes;
3383
3384	KASSERT(track);
3385	KASSERT(track->mode == AUMODE_RECORD);
3386
3387	/*
3388	 * For recording, track->input is the main block-unit buffer and
3389	 * track->usrbuf holds less than one block of byte data ("fragment").
3390	 * Note that the input buffer is in frames and the usrbuf is in bytes.
3391	 *
3392	 * Actual total capacity of these two buffers is
3393	 *  input->capacity [frames] + usrbuf.capacity [bytes],
3394	 * but only input->capacity is reported to userland as buffer_size.
3395	 * So, even if the total used bytes exceed input->capacity, report it
3396	 * as input->capacity for consistency.
3397	 */
3398	bytes = audio_track_inputblk_as_usrbyte(track, track->input->used);
3399	if (track->input->used < track->input->capacity) {
3400		bytes += track->usrbuf.used;
3401	}
3402	return bytes;
3403}
3404
3405/*
3406 * Must be called without sc_lock nor sc_exlock held.
3407 */
3408int
3409audio_poll(struct audio_softc *sc, int events, struct lwp *l,
3410	audio_file_t *file)
3411{
3412	audio_track_t *track;
3413	int revents;
3414	bool in_is_valid;
3415	bool out_is_valid;
3416
3417#if defined(AUDIO_DEBUG)
3418#define POLLEV_BITMAP "\177\020" \
3419	    "b\10WRBAND\0" \
3420	    "b\7RDBAND\0" "b\6RDNORM\0" "b\5NVAL\0" "b\4HUP\0" \
3421	    "b\3ERR\0" "b\2OUT\0" "b\1PRI\0" "b\0IN\0"
3422	char evbuf[64];
3423	snprintb(evbuf, sizeof(evbuf), POLLEV_BITMAP, events);
3424	TRACEF(2, file, "pid=%d.%d events=%s",
3425	    (int)curproc->p_pid, (int)l->l_lid, evbuf);
3426#endif
3427
3428	revents = 0;
3429	in_is_valid = false;
3430	out_is_valid = false;
3431	if (events & (POLLIN | POLLRDNORM)) {
3432		track = file->rtrack;
3433		if (track) {
3434			int used;
3435			in_is_valid = true;
3436			used = audio_track_readablebytes(track);
3437			if (used > 0)
3438				revents |= events & (POLLIN | POLLRDNORM);
3439		}
3440	}
3441	if (events & (POLLOUT | POLLWRNORM)) {
3442		track = file->ptrack;
3443		if (track) {
3444			out_is_valid = true;
3445			if (track->usrbuf.used <= track->usrbuf_usedlow)
3446				revents |= events & (POLLOUT | POLLWRNORM);
3447		}
3448	}
3449
3450	if (revents == 0) {
3451		mutex_enter(sc->sc_lock);
3452		if (in_is_valid) {
3453			TRACEF(3, file, "selrecord rsel");
3454			selrecord(l, &sc->sc_rsel);
3455		}
3456		if (out_is_valid) {
3457			TRACEF(3, file, "selrecord wsel");
3458			selrecord(l, &sc->sc_wsel);
3459		}
3460		mutex_exit(sc->sc_lock);
3461	}
3462
3463#if defined(AUDIO_DEBUG)
3464	snprintb(evbuf, sizeof(evbuf), POLLEV_BITMAP, revents);
3465	TRACEF(2, file, "revents=%s", evbuf);
3466#endif
3467	return revents;
3468}
3469
3470static const struct filterops audioread_filtops = {
3471	.f_flags = FILTEROP_ISFD,
3472	.f_attach = NULL,
3473	.f_detach = filt_audioread_detach,
3474	.f_event = filt_audioread_event,
3475};
3476
3477static void
3478filt_audioread_detach(struct knote *kn)
3479{
3480	struct audio_softc *sc;
3481	audio_file_t *file;
3482
3483	file = kn->kn_hook;
3484	sc = file->sc;
3485	TRACEF(3, file, "called");
3486
3487	mutex_enter(sc->sc_lock);
3488	selremove_knote(&sc->sc_rsel, kn);
3489	mutex_exit(sc->sc_lock);
3490}
3491
3492static int
3493filt_audioread_event(struct knote *kn, long hint)
3494{
3495	audio_file_t *file;
3496	audio_track_t *track;
3497
3498	file = kn->kn_hook;
3499	track = file->rtrack;
3500
3501	/*
3502	 * kn_data must contain the number of bytes can be read.
3503	 * The return value indicates whether the event occurs or not.
3504	 */
3505
3506	if (track == NULL) {
3507		/* can not read with this descriptor. */
3508		kn->kn_data = 0;
3509		return 0;
3510	}
3511
3512	kn->kn_data = audio_track_readablebytes(track);
3513	TRACEF(3, file, "data=%" PRId64, kn->kn_data);
3514	return kn->kn_data > 0;
3515}
3516
3517static const struct filterops audiowrite_filtops = {
3518	.f_flags = FILTEROP_ISFD,
3519	.f_attach = NULL,
3520	.f_detach = filt_audiowrite_detach,
3521	.f_event = filt_audiowrite_event,
3522};
3523
3524static void
3525filt_audiowrite_detach(struct knote *kn)
3526{
3527	struct audio_softc *sc;
3528	audio_file_t *file;
3529
3530	file = kn->kn_hook;
3531	sc = file->sc;
3532	TRACEF(3, file, "called");
3533
3534	mutex_enter(sc->sc_lock);
3535	selremove_knote(&sc->sc_wsel, kn);
3536	mutex_exit(sc->sc_lock);
3537}
3538
3539static int
3540filt_audiowrite_event(struct knote *kn, long hint)
3541{
3542	audio_file_t *file;
3543	audio_track_t *track;
3544
3545	file = kn->kn_hook;
3546	track = file->ptrack;
3547
3548	/*
3549	 * kn_data must contain the number of bytes can be write.
3550	 * The return value indicates whether the event occurs or not.
3551	 */
3552
3553	if (track == NULL) {
3554		/* can not write with this descriptor. */
3555		kn->kn_data = 0;
3556		return 0;
3557	}
3558
3559	kn->kn_data = track->usrbuf_usedhigh - track->usrbuf.used;
3560	TRACEF(3, file, "data=%" PRId64, kn->kn_data);
3561	return (track->usrbuf.used < track->usrbuf_usedlow);
3562}
3563
3564/*
3565 * Must be called without sc_lock nor sc_exlock held.
3566 */
3567int
3568audio_kqfilter(struct audio_softc *sc, audio_file_t *file, struct knote *kn)
3569{
3570	struct selinfo *sip;
3571
3572	TRACEF(3, file, "kn=%p kn_filter=%x", kn, (int)kn->kn_filter);
3573
3574	switch (kn->kn_filter) {
3575	case EVFILT_READ:
3576		sip = &sc->sc_rsel;
3577		kn->kn_fop = &audioread_filtops;
3578		break;
3579
3580	case EVFILT_WRITE:
3581		sip = &sc->sc_wsel;
3582		kn->kn_fop = &audiowrite_filtops;
3583		break;
3584
3585	default:
3586		return EINVAL;
3587	}
3588
3589	kn->kn_hook = file;
3590
3591	mutex_enter(sc->sc_lock);
3592	selrecord_knote(sip, kn);
3593	mutex_exit(sc->sc_lock);
3594
3595	return 0;
3596}
3597
3598/*
3599 * Must be called without sc_lock nor sc_exlock held.
3600 */
3601int
3602audio_mmap(struct audio_softc *sc, off_t *offp, size_t len, int prot,
3603	int *flagsp, int *advicep, struct uvm_object **uobjp, int *maxprotp,
3604	audio_file_t *file)
3605{
3606	audio_track_t *track;
3607	struct uvm_object *uobj;
3608	vaddr_t vstart;
3609	vsize_t vsize;
3610	int error;
3611
3612	TRACEF(1, file, "off=%jd, len=%ju, prot=%d",
3613	    (intmax_t)(*offp), (uintmax_t)len, prot);
3614
3615	KASSERT(len > 0);
3616
3617	if (*offp < 0)
3618		return EINVAL;
3619
3620#if 0
3621	/* XXX
3622	 * The idea here was to use the protection to determine if
3623	 * we are mapping the read or write buffer, but it fails.
3624	 * The VM system is broken in (at least) two ways.
3625	 * 1) If you map memory VM_PROT_WRITE you SIGSEGV
3626	 *    when writing to it, so VM_PROT_READ|VM_PROT_WRITE
3627	 *    has to be used for mmapping the play buffer.
3628	 * 2) Even if calling mmap() with VM_PROT_READ|VM_PROT_WRITE
3629	 *    audio_mmap will get called at some point with VM_PROT_READ
3630	 *    only.
3631	 * So, alas, we always map the play buffer for now.
3632	 */
3633	if (prot == (VM_PROT_READ|VM_PROT_WRITE) ||
3634	    prot == VM_PROT_WRITE)
3635		track = file->ptrack;
3636	else if (prot == VM_PROT_READ)
3637		track = file->rtrack;
3638	else
3639		return EINVAL;
3640#else
3641	track = file->ptrack;
3642#endif
3643	if (track == NULL)
3644		return EACCES;
3645
3646	/* XXX TODO: what happens when mmap twice. */
3647	if (track->mmapped)
3648		return EIO;
3649
3650	/* Create a uvm anonymous object */
3651	vsize = roundup2(MAX(track->usrbuf.capacity, PAGE_SIZE), PAGE_SIZE);
3652	if (*offp + len > vsize)
3653		return EOVERFLOW;
3654	uobj = uao_create(vsize, 0);
3655
3656	/* Map it into the kernel virtual address space */
3657	vstart = 0;
3658	error = uvm_map(kernel_map, &vstart, vsize, uobj, 0, 0,
3659	    UVM_MAPFLAG(UVM_PROT_RW, UVM_PROT_RW, UVM_INH_NONE,
3660	    UVM_ADV_RANDOM, 0));
3661	if (error) {
3662		device_printf(sc->sc_dev, "uvm_map failed: errno=%d\n", error);
3663		uao_detach(uobj);	/* release reference */
3664		return error;
3665	}
3666
3667	error = uvm_map_pageable(kernel_map, vstart, vstart + vsize,
3668	    false, 0);
3669	if (error) {
3670		device_printf(sc->sc_dev, "uvm_map_pageable failed: errno=%d\n",
3671		    error);
3672		goto abort;
3673	}
3674
3675	error = audio_exlock_mutex_enter(sc);
3676	if (error)
3677		goto abort;
3678
3679	/*
3680	 * mmap() will start playing immediately.  XXX Maybe we lack API...
3681	 * If no one has played yet, start pmixer here.
3682	 */
3683	if (sc->sc_pbusy == false)
3684		audio_pmixer_start(sc, true);
3685	audio_exlock_mutex_exit(sc);
3686
3687	/* Finally, replace the usrbuf from kmem to uvm. */
3688	audio_track_lock_enter(track);
3689	kmem_free(track->usrbuf.mem, track->usrbuf_allocsize);
3690	track->usrbuf.mem = (void *)vstart;
3691	track->usrbuf_allocsize = vsize;
3692	memset(track->usrbuf.mem, 0, vsize);
3693	track->mmapped = true;
3694	audio_track_lock_exit(track);
3695
3696	/* Acquire a reference for the mmap.  munmap will release. */
3697	uao_reference(uobj);
3698	*uobjp = uobj;
3699	*maxprotp = prot;
3700	*advicep = UVM_ADV_RANDOM;
3701	*flagsp = MAP_SHARED;
3702
3703	return 0;
3704
3705abort:
3706	uvm_unmap(kernel_map, vstart, vstart + vsize);
3707	/* uvm_unmap also detach uobj */
3708	return error;
3709}
3710
3711/*
3712 * /dev/audioctl has to be able to open at any time without interference
3713 * with any /dev/audio or /dev/sound.
3714 * Must be called with sc_exlock held and without sc_lock held.
3715 */
3716static int
3717audioctl_open(dev_t dev, struct audio_softc *sc, int flags, int ifmt,
3718	struct lwp *l)
3719{
3720	struct file *fp;
3721	audio_file_t *af;
3722	int fd;
3723	int error;
3724
3725	KASSERT(sc->sc_exlock);
3726
3727	TRACE(1, "called");
3728
3729	error = fd_allocfile(&fp, &fd);
3730	if (error)
3731		return error;
3732
3733	af = kmem_zalloc(sizeof(*af), KM_SLEEP);
3734	af->sc = sc;
3735	af->dev = dev;
3736
3737	mutex_enter(sc->sc_lock);
3738	if (sc->sc_dying) {
3739		mutex_exit(sc->sc_lock);
3740		kmem_free(af, sizeof(*af));
3741		fd_abort(curproc, fp, fd);
3742		return ENXIO;
3743	}
3744	mutex_enter(sc->sc_intr_lock);
3745	SLIST_INSERT_HEAD(&sc->sc_files, af, entry);
3746	mutex_exit(sc->sc_intr_lock);
3747	mutex_exit(sc->sc_lock);
3748
3749	error = fd_clone(fp, fd, flags, &audio_fileops, af);
3750	KASSERTMSG(error == EMOVEFD, "error=%d", error);
3751
3752	return error;
3753}
3754
3755/*
3756 * Free 'mem' if available, and initialize the pointer.
3757 * For this reason, this is implemented as macro.
3758 */
3759#define audio_free(mem)	do {	\
3760	if (mem != NULL) {	\
3761		kern_free(mem);	\
3762		mem = NULL;	\
3763	}	\
3764} while (0)
3765
3766/*
3767 * (Re)allocate 'memblock' with specified 'bytes'.
3768 * bytes must not be 0.
3769 * This function never returns NULL.
3770 */
3771static void *
3772audio_realloc(void *memblock, size_t bytes)
3773{
3774
3775	KASSERT(bytes != 0);
3776	if (memblock)
3777		kern_free(memblock);
3778	return kern_malloc(bytes, M_WAITOK);
3779}
3780
3781/*
3782 * Free usrbuf (if available).
3783 */
3784static void
3785audio_free_usrbuf(audio_track_t *track)
3786{
3787	vaddr_t vstart;
3788	vsize_t vsize;
3789
3790	if (track->usrbuf_allocsize != 0) {
3791		if (track->mmapped) {
3792			/*
3793			 * Unmap the kernel mapping.  uvm_unmap releases the
3794			 * reference to the uvm object, and this should be the
3795			 * last virtual mapping of the uvm object, so no need
3796			 * to explicitly release (`detach') the object.
3797			 */
3798			vstart = (vaddr_t)track->usrbuf.mem;
3799			vsize = track->usrbuf_allocsize;
3800			uvm_unmap(kernel_map, vstart, vstart + vsize);
3801			track->mmapped = false;
3802		} else {
3803			kmem_free(track->usrbuf.mem, track->usrbuf_allocsize);
3804		}
3805	}
3806	track->usrbuf.mem = NULL;
3807	track->usrbuf.capacity = 0;
3808	track->usrbuf_allocsize = 0;
3809}
3810
3811/*
3812 * This filter changes the volume for each channel.
3813 * arg->context points track->ch_volume[].
3814 */
3815static void
3816audio_track_chvol(audio_filter_arg_t *arg)
3817{
3818	int16_t *ch_volume;
3819	const aint_t *s;
3820	aint_t *d;
3821	u_int i;
3822	u_int ch;
3823	u_int channels;
3824
3825	DIAGNOSTIC_filter_arg(arg);
3826	KASSERTMSG(arg->srcfmt->channels == arg->dstfmt->channels,
3827	    "arg->srcfmt->channels=%d, arg->dstfmt->channels=%d",
3828	    arg->srcfmt->channels, arg->dstfmt->channels);
3829	KASSERT(arg->context != NULL);
3830	KASSERTMSG(arg->srcfmt->channels <= AUDIO_MAX_CHANNELS,
3831	    "arg->srcfmt->channels=%d", arg->srcfmt->channels);
3832
3833	s = arg->src;
3834	d = arg->dst;
3835	ch_volume = arg->context;
3836
3837	channels = arg->srcfmt->channels;
3838	for (i = 0; i < arg->count; i++) {
3839		for (ch = 0; ch < channels; ch++) {
3840			aint2_t val;
3841			val = *s++;
3842			val = AUDIO_SCALEDOWN(val * ch_volume[ch], 8);
3843			*d++ = (aint_t)val;
3844		}
3845	}
3846}
3847
3848/*
3849 * This filter performs conversion from stereo (or more channels) to mono.
3850 */
3851static void
3852audio_track_chmix_mixLR(audio_filter_arg_t *arg)
3853{
3854	const aint_t *s;
3855	aint_t *d;
3856	u_int i;
3857
3858	DIAGNOSTIC_filter_arg(arg);
3859
3860	s = arg->src;
3861	d = arg->dst;
3862
3863	for (i = 0; i < arg->count; i++) {
3864		*d++ = AUDIO_SCALEDOWN(s[0], 1) + AUDIO_SCALEDOWN(s[1], 1);
3865		s += arg->srcfmt->channels;
3866	}
3867}
3868
3869/*
3870 * This filter performs conversion from mono to stereo (or more channels).
3871 */
3872static void
3873audio_track_chmix_dupLR(audio_filter_arg_t *arg)
3874{
3875	const aint_t *s;
3876	aint_t *d;
3877	u_int i;
3878	u_int ch;
3879	u_int dstchannels;
3880
3881	DIAGNOSTIC_filter_arg(arg);
3882
3883	s = arg->src;
3884	d = arg->dst;
3885	dstchannels = arg->dstfmt->channels;
3886
3887	for (i = 0; i < arg->count; i++) {
3888		d[0] = s[0];
3889		d[1] = s[0];
3890		s++;
3891		d += dstchannels;
3892	}
3893	if (dstchannels > 2) {
3894		d = arg->dst;
3895		for (i = 0; i < arg->count; i++) {
3896			for (ch = 2; ch < dstchannels; ch++) {
3897				d[ch] = 0;
3898			}
3899			d += dstchannels;
3900		}
3901	}
3902}
3903
3904/*
3905 * This filter shrinks M channels into N channels.
3906 * Extra channels are discarded.
3907 */
3908static void
3909audio_track_chmix_shrink(audio_filter_arg_t *arg)
3910{
3911	const aint_t *s;
3912	aint_t *d;
3913	u_int i;
3914	u_int ch;
3915
3916	DIAGNOSTIC_filter_arg(arg);
3917
3918	s = arg->src;
3919	d = arg->dst;
3920
3921	for (i = 0; i < arg->count; i++) {
3922		for (ch = 0; ch < arg->dstfmt->channels; ch++) {
3923			*d++ = s[ch];
3924		}
3925		s += arg->srcfmt->channels;
3926	}
3927}
3928
3929/*
3930 * This filter expands M channels into N channels.
3931 * Silence is inserted for missing channels.
3932 */
3933static void
3934audio_track_chmix_expand(audio_filter_arg_t *arg)
3935{
3936	const aint_t *s;
3937	aint_t *d;
3938	u_int i;
3939	u_int ch;
3940	u_int srcchannels;
3941	u_int dstchannels;
3942
3943	DIAGNOSTIC_filter_arg(arg);
3944
3945	s = arg->src;
3946	d = arg->dst;
3947
3948	srcchannels = arg->srcfmt->channels;
3949	dstchannels = arg->dstfmt->channels;
3950	for (i = 0; i < arg->count; i++) {
3951		for (ch = 0; ch < srcchannels; ch++) {
3952			*d++ = *s++;
3953		}
3954		for (; ch < dstchannels; ch++) {
3955			*d++ = 0;
3956		}
3957	}
3958}
3959
3960/*
3961 * This filter performs frequency conversion (up sampling).
3962 * It uses linear interpolation.
3963 */
3964static void
3965audio_track_freq_up(audio_filter_arg_t *arg)
3966{
3967	audio_track_t *track;
3968	audio_ring_t *src;
3969	audio_ring_t *dst;
3970	const aint_t *s;
3971	aint_t *d;
3972	aint_t prev[AUDIO_MAX_CHANNELS];
3973	aint_t curr[AUDIO_MAX_CHANNELS];
3974	aint_t grad[AUDIO_MAX_CHANNELS];
3975	u_int i;
3976	u_int t;
3977	u_int step;
3978	u_int channels;
3979	u_int ch;
3980	int srcused;
3981
3982	track = arg->context;
3983	KASSERT(track);
3984	src = &track->freq.srcbuf;
3985	dst = track->freq.dst;
3986	DIAGNOSTIC_ring(dst);
3987	DIAGNOSTIC_ring(src);
3988	KASSERT(src->used > 0);
3989	KASSERTMSG(src->fmt.channels == dst->fmt.channels,
3990	    "src->fmt.channels=%d dst->fmt.channels=%d",
3991	    src->fmt.channels, dst->fmt.channels);
3992	KASSERTMSG(src->head % track->mixer->frames_per_block == 0,
3993	    "src->head=%d track->mixer->frames_per_block=%d",
3994	    src->head, track->mixer->frames_per_block);
3995
3996	s = arg->src;
3997	d = arg->dst;
3998
3999	/*
4000	 * In order to facilitate interpolation for each block, slide (delay)
4001	 * input by one sample.  As a result, strictly speaking, the output
4002	 * phase is delayed by 1/dstfreq.  However, I believe there is no
4003	 * observable impact.
4004	 *
4005	 * Example)
4006	 * srcfreq:dstfreq = 1:3
4007	 *
4008	 *  A - -
4009	 *  |
4010	 *  |
4011	 *  |     B - -
4012	 *  +-----+-----> input timeframe
4013	 *  0     1
4014	 *
4015	 *  0     1
4016	 *  +-----+-----> input timeframe
4017	 *  |     A
4018	 *  |   x   x
4019	 *  | x       x
4020	 *  x          (B)
4021	 *  +-+-+-+-+-+-> output timeframe
4022	 *  0 1 2 3 4 5
4023	 */
4024
4025	/* Last samples in previous block */
4026	channels = src->fmt.channels;
4027	for (ch = 0; ch < channels; ch++) {
4028		prev[ch] = track->freq_prev[ch];
4029		curr[ch] = track->freq_curr[ch];
4030		grad[ch] = curr[ch] - prev[ch];
4031	}
4032
4033	step = track->freq_step;
4034	t = track->freq_current;
4035//#define FREQ_DEBUG
4036#if defined(FREQ_DEBUG)
4037#define PRINTF(fmt...)	printf(fmt)
4038#else
4039#define PRINTF(fmt...)	do { } while (0)
4040#endif
4041	srcused = src->used;
4042	PRINTF("upstart step=%d leap=%d", step, track->freq_leap);
4043	PRINTF(" srcused=%d arg->count=%u", src->used, arg->count);
4044	PRINTF(" prev=%d curr=%d grad=%d", prev[0], curr[0], grad[0]);
4045	PRINTF(" t=%d\n", t);
4046
4047	for (i = 0; i < arg->count; i++) {
4048		PRINTF("i=%d t=%5d", i, t);
4049		if (t >= 65536) {
4050			for (ch = 0; ch < channels; ch++) {
4051				prev[ch] = curr[ch];
4052				curr[ch] = *s++;
4053				grad[ch] = curr[ch] - prev[ch];
4054			}
4055			PRINTF(" prev=%d s[%d]=%d",
4056			    prev[0], src->used - srcused, curr[0]);
4057
4058			/* Update */
4059			t -= 65536;
4060			srcused--;
4061			if (srcused < 0) {
4062				PRINTF(" break\n");
4063				break;
4064			}
4065		}
4066
4067		for (ch = 0; ch < channels; ch++) {
4068			*d++ = prev[ch] + (aint2_t)grad[ch] * t / 65536;
4069#if defined(FREQ_DEBUG)
4070			if (ch == 0)
4071				printf(" t=%5d *d=%d", t, d[-1]);
4072#endif
4073		}
4074		t += step;
4075
4076		PRINTF("\n");
4077	}
4078	PRINTF("end prev=%d curr=%d\n", prev[0], curr[0]);
4079
4080	auring_take(src, src->used);
4081	auring_push(dst, i);
4082
4083	/* Adjust */
4084	t += track->freq_leap;
4085
4086	track->freq_current = t;
4087	for (ch = 0; ch < channels; ch++) {
4088		track->freq_prev[ch] = prev[ch];
4089		track->freq_curr[ch] = curr[ch];
4090	}
4091}
4092
4093/*
4094 * This filter performs frequency conversion (down sampling).
4095 * It uses simple thinning.
4096 */
4097static void
4098audio_track_freq_down(audio_filter_arg_t *arg)
4099{
4100	audio_track_t *track;
4101	audio_ring_t *src;
4102	audio_ring_t *dst;
4103	const aint_t *s0;
4104	aint_t *d;
4105	u_int i;
4106	u_int t;
4107	u_int step;
4108	u_int ch;
4109	u_int channels;
4110
4111	track = arg->context;
4112	KASSERT(track);
4113	src = &track->freq.srcbuf;
4114	dst = track->freq.dst;
4115
4116	DIAGNOSTIC_ring(dst);
4117	DIAGNOSTIC_ring(src);
4118	KASSERT(src->used > 0);
4119	KASSERTMSG(src->fmt.channels == dst->fmt.channels,
4120	    "src->fmt.channels=%d dst->fmt.channels=%d",
4121	    src->fmt.channels, dst->fmt.channels);
4122	KASSERTMSG(src->head % track->mixer->frames_per_block == 0,
4123	    "src->head=%d track->mixer->frames_per_block=%d",
4124	    src->head, track->mixer->frames_per_block);
4125
4126	s0 = arg->src;
4127	d = arg->dst;
4128	t = track->freq_current;
4129	step = track->freq_step;
4130	channels = dst->fmt.channels;
4131	PRINTF("downstart step=%d leap=%d", step, track->freq_leap);
4132	PRINTF(" srcused=%d arg->count=%u", src->used, arg->count);
4133	PRINTF(" t=%d\n", t);
4134
4135	for (i = 0; i < arg->count && t / 65536 < src->used; i++) {
4136		const aint_t *s;
4137		PRINTF("i=%4d t=%10d", i, t);
4138		s = s0 + (t / 65536) * channels;
4139		PRINTF(" s=%5ld", (s - s0) / channels);
4140		for (ch = 0; ch < channels; ch++) {
4141			if (ch == 0) PRINTF(" *s=%d", s[ch]);
4142			*d++ = s[ch];
4143		}
4144		PRINTF("\n");
4145		t += step;
4146	}
4147	t += track->freq_leap;
4148	PRINTF("end t=%d\n", t);
4149	auring_take(src, src->used);
4150	auring_push(dst, i);
4151	track->freq_current = t % 65536;
4152}
4153
4154/*
4155 * Creates track and returns it.
4156 * Must be called without sc_lock held.
4157 */
4158audio_track_t *
4159audio_track_create(struct audio_softc *sc, audio_trackmixer_t *mixer)
4160{
4161	audio_track_t *track;
4162	static int newid = 0;
4163
4164	track = kmem_zalloc(sizeof(*track), KM_SLEEP);
4165
4166	track->id = newid++;
4167	track->mixer = mixer;
4168	track->mode = mixer->mode;
4169
4170	/* Do TRACE after id is assigned. */
4171	TRACET(3, track, "for %s",
4172	    mixer->mode == AUMODE_PLAY ? "playback" : "recording");
4173
4174#if defined(AUDIO_SUPPORT_TRACK_VOLUME)
4175	track->volume = 256;
4176#endif
4177	for (int i = 0; i < AUDIO_MAX_CHANNELS; i++) {
4178		track->ch_volume[i] = 256;
4179	}
4180
4181	return track;
4182}
4183
4184/*
4185 * Release all resources of the track and track itself.
4186 * track must not be NULL.  Don't specify the track within the file
4187 * structure linked from sc->sc_files.
4188 */
4189static void
4190audio_track_destroy(audio_track_t *track)
4191{
4192
4193	KASSERT(track);
4194
4195	audio_free_usrbuf(track);
4196	audio_free(track->codec.srcbuf.mem);
4197	audio_free(track->chvol.srcbuf.mem);
4198	audio_free(track->chmix.srcbuf.mem);
4199	audio_free(track->freq.srcbuf.mem);
4200	audio_free(track->outbuf.mem);
4201
4202	kmem_free(track, sizeof(*track));
4203}
4204
4205/*
4206 * It returns encoding conversion filter according to src and dst format.
4207 * If it is not a convertible pair, it returns NULL.  Either src or dst
4208 * must be internal format.
4209 */
4210static audio_filter_t
4211audio_track_get_codec(audio_track_t *track, const audio_format2_t *src,
4212	const audio_format2_t *dst)
4213{
4214
4215	if (audio_format2_is_internal(src)) {
4216		if (dst->encoding == AUDIO_ENCODING_ULAW) {
4217			return audio_internal_to_mulaw;
4218		} else if (dst->encoding == AUDIO_ENCODING_ALAW) {
4219			return audio_internal_to_alaw;
4220		} else if (audio_format2_is_linear(dst)) {
4221			switch (dst->stride) {
4222			case 8:
4223				return audio_internal_to_linear8;
4224			case 16:
4225				return audio_internal_to_linear16;
4226#if defined(AUDIO_SUPPORT_LINEAR24)
4227			case 24:
4228				return audio_internal_to_linear24;
4229#endif
4230			case 32:
4231				return audio_internal_to_linear32;
4232			default:
4233				TRACET(1, track, "unsupported %s stride %d",
4234				    "dst", dst->stride);
4235				goto abort;
4236			}
4237		}
4238	} else if (audio_format2_is_internal(dst)) {
4239		if (src->encoding == AUDIO_ENCODING_ULAW) {
4240			return audio_mulaw_to_internal;
4241		} else if (src->encoding == AUDIO_ENCODING_ALAW) {
4242			return audio_alaw_to_internal;
4243		} else if (audio_format2_is_linear(src)) {
4244			switch (src->stride) {
4245			case 8:
4246				return audio_linear8_to_internal;
4247			case 16:
4248				return audio_linear16_to_internal;
4249#if defined(AUDIO_SUPPORT_LINEAR24)
4250			case 24:
4251				return audio_linear24_to_internal;
4252#endif
4253			case 32:
4254				return audio_linear32_to_internal;
4255			default:
4256				TRACET(1, track, "unsupported %s stride %d",
4257				    "src", src->stride);
4258				goto abort;
4259			}
4260		}
4261	}
4262
4263	TRACET(1, track, "unsupported encoding");
4264abort:
4265#if defined(AUDIO_DEBUG)
4266	if (audiodebug >= 2) {
4267		char buf[100];
4268		audio_format2_tostr(buf, sizeof(buf), src);
4269		TRACET(2, track, "src %s", buf);
4270		audio_format2_tostr(buf, sizeof(buf), dst);
4271		TRACET(2, track, "dst %s", buf);
4272	}
4273#endif
4274	return NULL;
4275}
4276
4277/*
4278 * Initialize the codec stage of this track as necessary.
4279 * If successful, it initializes the codec stage as necessary, stores updated
4280 * last_dst in *last_dstp in any case, and returns 0.
4281 * Otherwise, it returns errno without modifying *last_dstp.
4282 */
4283static int
4284audio_track_init_codec(audio_track_t *track, audio_ring_t **last_dstp)
4285{
4286	audio_ring_t *last_dst;
4287	audio_ring_t *srcbuf;
4288	audio_format2_t *srcfmt;
4289	audio_format2_t *dstfmt;
4290	audio_filter_arg_t *arg;
4291	u_int len;
4292	int error;
4293
4294	KASSERT(track);
4295
4296	last_dst = *last_dstp;
4297	dstfmt = &last_dst->fmt;
4298	srcfmt = &track->inputfmt;
4299	srcbuf = &track->codec.srcbuf;
4300	error = 0;
4301
4302	if (srcfmt->encoding != dstfmt->encoding
4303	 || srcfmt->precision != dstfmt->precision
4304	 || srcfmt->stride != dstfmt->stride) {
4305		track->codec.dst = last_dst;
4306
4307		srcbuf->fmt = *dstfmt;
4308		srcbuf->fmt.encoding = srcfmt->encoding;
4309		srcbuf->fmt.precision = srcfmt->precision;
4310		srcbuf->fmt.stride = srcfmt->stride;
4311
4312		track->codec.filter = audio_track_get_codec(track,
4313		    &srcbuf->fmt, dstfmt);
4314		if (track->codec.filter == NULL) {
4315			error = EINVAL;
4316			goto abort;
4317		}
4318
4319		srcbuf->head = 0;
4320		srcbuf->used = 0;
4321		srcbuf->capacity = frame_per_block(track->mixer, &srcbuf->fmt);
4322		len = auring_bytelen(srcbuf);
4323		srcbuf->mem = audio_realloc(srcbuf->mem, len);
4324
4325		arg = &track->codec.arg;
4326		arg->srcfmt = &srcbuf->fmt;
4327		arg->dstfmt = dstfmt;
4328		arg->context = NULL;
4329
4330		*last_dstp = srcbuf;
4331		return 0;
4332	}
4333
4334abort:
4335	track->codec.filter = NULL;
4336	audio_free(srcbuf->mem);
4337	return error;
4338}
4339
4340/*
4341 * Initialize the chvol stage of this track as necessary.
4342 * If successful, it initializes the chvol stage as necessary, stores updated
4343 * last_dst in *last_dstp in any case, and returns 0.
4344 * Otherwise, it returns errno without modifying *last_dstp.
4345 */
4346static int
4347audio_track_init_chvol(audio_track_t *track, audio_ring_t **last_dstp)
4348{
4349	audio_ring_t *last_dst;
4350	audio_ring_t *srcbuf;
4351	audio_format2_t *srcfmt;
4352	audio_format2_t *dstfmt;
4353	audio_filter_arg_t *arg;
4354	u_int len;
4355	int error;
4356
4357	KASSERT(track);
4358
4359	last_dst = *last_dstp;
4360	dstfmt = &last_dst->fmt;
4361	srcfmt = &track->inputfmt;
4362	srcbuf = &track->chvol.srcbuf;
4363	error = 0;
4364
4365	/* Check whether channel volume conversion is necessary. */
4366	bool use_chvol = false;
4367	for (int ch = 0; ch < srcfmt->channels; ch++) {
4368		if (track->ch_volume[ch] != 256) {
4369			use_chvol = true;
4370			break;
4371		}
4372	}
4373
4374	if (use_chvol == true) {
4375		track->chvol.dst = last_dst;
4376		track->chvol.filter = audio_track_chvol;
4377
4378		srcbuf->fmt = *dstfmt;
4379		/* no format conversion occurs */
4380
4381		srcbuf->head = 0;
4382		srcbuf->used = 0;
4383		srcbuf->capacity = frame_per_block(track->mixer, &srcbuf->fmt);
4384		len = auring_bytelen(srcbuf);
4385		srcbuf->mem = audio_realloc(srcbuf->mem, len);
4386
4387		arg = &track->chvol.arg;
4388		arg->srcfmt = &srcbuf->fmt;
4389		arg->dstfmt = dstfmt;
4390		arg->context = track->ch_volume;
4391
4392		*last_dstp = srcbuf;
4393		return 0;
4394	}
4395
4396	track->chvol.filter = NULL;
4397	audio_free(srcbuf->mem);
4398	return error;
4399}
4400
4401/*
4402 * Initialize the chmix stage of this track as necessary.
4403 * If successful, it initializes the chmix stage as necessary, stores updated
4404 * last_dst in *last_dstp in any case, and returns 0.
4405 * Otherwise, it returns errno without modifying *last_dstp.
4406 */
4407static int
4408audio_track_init_chmix(audio_track_t *track, audio_ring_t **last_dstp)
4409{
4410	audio_ring_t *last_dst;
4411	audio_ring_t *srcbuf;
4412	audio_format2_t *srcfmt;
4413	audio_format2_t *dstfmt;
4414	audio_filter_arg_t *arg;
4415	u_int srcch;
4416	u_int dstch;
4417	u_int len;
4418	int error;
4419
4420	KASSERT(track);
4421
4422	last_dst = *last_dstp;
4423	dstfmt = &last_dst->fmt;
4424	srcfmt = &track->inputfmt;
4425	srcbuf = &track->chmix.srcbuf;
4426	error = 0;
4427
4428	srcch = srcfmt->channels;
4429	dstch = dstfmt->channels;
4430	if (srcch != dstch) {
4431		track->chmix.dst = last_dst;
4432
4433		if (srcch >= 2 && dstch == 1) {
4434			track->chmix.filter = audio_track_chmix_mixLR;
4435		} else if (srcch == 1 && dstch >= 2) {
4436			track->chmix.filter = audio_track_chmix_dupLR;
4437		} else if (srcch > dstch) {
4438			track->chmix.filter = audio_track_chmix_shrink;
4439		} else {
4440			track->chmix.filter = audio_track_chmix_expand;
4441		}
4442
4443		srcbuf->fmt = *dstfmt;
4444		srcbuf->fmt.channels = srcch;
4445
4446		srcbuf->head = 0;
4447		srcbuf->used = 0;
4448		/* XXX The buffer size should be able to calculate. */
4449		srcbuf->capacity = frame_per_block(track->mixer, &srcbuf->fmt);
4450		len = auring_bytelen(srcbuf);
4451		srcbuf->mem = audio_realloc(srcbuf->mem, len);
4452
4453		arg = &track->chmix.arg;
4454		arg->srcfmt = &srcbuf->fmt;
4455		arg->dstfmt = dstfmt;
4456		arg->context = NULL;
4457
4458		*last_dstp = srcbuf;
4459		return 0;
4460	}
4461
4462	track->chmix.filter = NULL;
4463	audio_free(srcbuf->mem);
4464	return error;
4465}
4466
4467/*
4468 * Initialize the freq stage of this track as necessary.
4469 * If successful, it initializes the freq stage as necessary, stores updated
4470 * last_dst in *last_dstp in any case, and returns 0.
4471 * Otherwise, it returns errno without modifying *last_dstp.
4472 */
4473static int
4474audio_track_init_freq(audio_track_t *track, audio_ring_t **last_dstp)
4475{
4476	audio_ring_t *last_dst;
4477	audio_ring_t *srcbuf;
4478	audio_format2_t *srcfmt;
4479	audio_format2_t *dstfmt;
4480	audio_filter_arg_t *arg;
4481	uint32_t srcfreq;
4482	uint32_t dstfreq;
4483	u_int dst_capacity;
4484	u_int mod;
4485	u_int len;
4486	int error;
4487
4488	KASSERT(track);
4489
4490	last_dst = *last_dstp;
4491	dstfmt = &last_dst->fmt;
4492	srcfmt = &track->inputfmt;
4493	srcbuf = &track->freq.srcbuf;
4494	error = 0;
4495
4496	srcfreq = srcfmt->sample_rate;
4497	dstfreq = dstfmt->sample_rate;
4498	if (srcfreq != dstfreq) {
4499		track->freq.dst = last_dst;
4500
4501		memset(track->freq_prev, 0, sizeof(track->freq_prev));
4502		memset(track->freq_curr, 0, sizeof(track->freq_curr));
4503
4504		/* freq_step is the ratio of src/dst when let dst 65536. */
4505		track->freq_step = (uint64_t)srcfreq * 65536 / dstfreq;
4506
4507		dst_capacity = frame_per_block(track->mixer, dstfmt);
4508		mod = (uint64_t)srcfreq * 65536 % dstfreq;
4509		track->freq_leap = (mod * dst_capacity + dstfreq / 2) / dstfreq;
4510
4511		if (track->freq_step < 65536) {
4512			track->freq.filter = audio_track_freq_up;
4513			/* In order to carry at the first time. */
4514			track->freq_current = 65536;
4515		} else {
4516			track->freq.filter = audio_track_freq_down;
4517			track->freq_current = 0;
4518		}
4519
4520		srcbuf->fmt = *dstfmt;
4521		srcbuf->fmt.sample_rate = srcfreq;
4522
4523		srcbuf->head = 0;
4524		srcbuf->used = 0;
4525		srcbuf->capacity = frame_per_block(track->mixer, &srcbuf->fmt);
4526		len = auring_bytelen(srcbuf);
4527		srcbuf->mem = audio_realloc(srcbuf->mem, len);
4528
4529		arg = &track->freq.arg;
4530		arg->srcfmt = &srcbuf->fmt;
4531		arg->dstfmt = dstfmt;
4532		arg->context = track;
4533
4534		*last_dstp = srcbuf;
4535		return 0;
4536	}
4537
4538	track->freq.filter = NULL;
4539	audio_free(srcbuf->mem);
4540	return error;
4541}
4542
4543/*
4544 * There are two unit of buffers; A block buffer and a byte buffer.  Both use
4545 * audio_ring_t.  Internally, audio data is always handled in block unit.
4546 * Converting format, sythesizing tracks, transferring from/to the hardware,
4547 * and etc.  Only one exception is usrbuf.  To transfer with userland, usrbuf
4548 * is buffered in byte unit.
4549 * For playing back, write(2) writes arbitrary length of data to usrbuf.
4550 * When one block is filled, it is sent to the next stage (converting and/or
4551 * synthesizing).
4552 * For recording, the rmixer writes one block length of data to input buffer
4553 * (the bottom stage buffer) each time.  read(2) (converts one block if usrbuf
4554 * is empty and then) reads arbitrary length of data from usrbuf.
4555 *
4556 * The following charts show the data flow and buffer types for playback and
4557 * recording track.  In this example, both have two conversion stages, codec
4558 * and freq.  Every [**] represents a buffer described below.
4559 *
4560 * On playback track:
4561 *
4562 *               write(2)
4563 *                |
4564 *                | uiomove
4565 *                v
4566 *  usrbuf       [BB|BB ... BB|BB]     .. Byte ring buffer
4567 *                |
4568 *                | memcpy one block
4569 *                v
4570 *  codec.srcbuf [FF]                  .. 1 block (ring) buffer
4571 *       .dst ----+
4572 *                |
4573 *                | convert
4574 *                v
4575 *  freq.srcbuf  [FF]                  .. 1 block (ring) buffer
4576 *      .dst  ----+
4577 *                |
4578 *                | convert
4579 *                v
4580 *  outbuf       [FF|FF|FF|FF]         .. NBLKOUT blocks ring buffer
4581 *                |
4582 *                v
4583 *               pmixer
4584 *
4585 * There are three different types of buffers:
4586 *
4587 *  [BB|BB ... BB|BB]  usrbuf.  Is the buffer closest to userland.  Mandatory.
4588 *                     This is a byte buffer and its length is basically less
4589 *                     than or equal to 64KB or at least AUMINNOBLK blocks.
4590 *
4591 *  [FF]               Interim conversion stage's srcbuf if necessary.
4592 *                     This is one block (ring) buffer counted in frames.
4593 *
4594 *  [FF|FF|FF|FF]      outbuf.  Is the buffer closest to pmixer.  Mandatory.
4595 *                     This is NBLKOUT blocks ring buffer counted in frames.
4596 *
4597 *
4598 * On recording track:
4599 *
4600 *               read(2)
4601 *                ^
4602 *                | uiomove
4603 *                |
4604 *  usrbuf       [BB]                  .. Byte (ring) buffer
4605 *                ^
4606 *                | memcpy one block
4607 *                |
4608 *  outbuf       [FF]                  .. 1 block (ring) buffer
4609 *                ^
4610 *                | convert
4611 *                |
4612 *  codec.dst ----+
4613 *       .srcbuf [FF]                  .. 1 block (ring) buffer
4614 *                ^
4615 *                | convert
4616 *                |
4617 *  freq.dst  ----+
4618 *      .srcbuf  [FF|FF ... FF|FF]     .. NBLKIN blocks ring buffer
4619 *                ^
4620 *                |
4621 *               rmixer
4622 *
4623 * There are also three different types of buffers.
4624 *
4625 *  [BB]               usrbuf.  Is the buffer closest to userland.  Mandatory.
4626 *                     This is a byte buffer and its length is one block.
4627 *                     This buffer holds only "fragment".
4628 *
4629 *  [FF]               Interim conversion stage's srcbuf (or outbuf).
4630 *                     This is one block (ring) buffer counted in frames.
4631 *
4632 *  [FF|FF ... FF|FF]  The bottom conversion stage's srcbuf (or outbuf).
4633 *                     This is the buffer closest to rmixer, and mandatory.
4634 *                     This is NBLKIN blocks ring buffer counted in frames.
4635 *                     Also pointed by *input.
4636 */
4637
4638/*
4639 * Set the userland format of this track.
4640 * usrfmt argument should have been previously verified by
4641 * audio_track_setinfo_check().
4642 * This function may release and reallocate all internal conversion buffers.
4643 * It returns 0 if successful.  Otherwise it returns errno with clearing all
4644 * internal buffers.
4645 * It must be called without sc_intr_lock since uvm_* routines require non
4646 * intr_lock state.
4647 * It must be called with track lock held since it may release and reallocate
4648 * outbuf.
4649 */
4650static int
4651audio_track_set_format(audio_track_t *track, audio_format2_t *usrfmt)
4652{
4653	audio_ring_t *last_dst;
4654	int is_playback;
4655	u_int newbufsize;
4656	u_int newvsize;
4657	u_int len;
4658	int error;
4659
4660	KASSERT(track);
4661
4662	is_playback = audio_track_is_playback(track);
4663
4664	/* Once mmap is called, the track format cannot be changed. */
4665	if (track->mmapped)
4666		return EIO;
4667
4668	/* usrbuf is the closest buffer to the userland. */
4669	track->usrbuf.fmt = *usrfmt;
4670
4671	/*
4672	 * Usrbuf.
4673	 * On the playback track, its capacity is less than or equal to 64KB
4674	 * (for historical reason) and must be a multiple of a block
4675	 * (constraint in this implementation).  But at least AUMINNOBLK
4676	 * blocks.
4677	 * On the recording track, its capacity is one block.
4678	 */
4679	/*
4680	 * For references, one block size (in 40msec) is:
4681	 *  320 bytes    = 204 blocks/64KB for mulaw/8kHz/1ch
4682	 *  7680 bytes   = 8 blocks/64KB for s16/48kHz/2ch
4683	 *  30720 bytes  = 90 KB/3blocks for s16/48kHz/8ch
4684	 *  61440 bytes  = 180 KB/3blocks for s16/96kHz/8ch
4685	 *  245760 bytes = 720 KB/3blocks for s32/192kHz/8ch
4686	 *
4687	 * For example,
4688	 * 1) If usrbuf_blksize = 7056 (s16/44.1k/2ch) and PAGE_SIZE = 8192,
4689	 *     newbufsize = rounddown(65536 / 7056) = 63504
4690	 *     newvsize = roundup2(63504, PAGE_SIZE) = 65536
4691	 *    Therefore it maps 8 * 8K pages and usrbuf->capacity = 63504.
4692	 *
4693	 * 2) If usrbuf_blksize = 7680 (s16/48k/2ch) and PAGE_SIZE = 4096,
4694	 *     newbufsize = rounddown(65536 / 7680) = 61440
4695	 *     newvsize = roundup2(61440, PAGE_SIZE) = 61440 (= 15 pages)
4696	 *    Therefore it maps 15 * 4K pages and usrbuf->capacity = 61440.
4697	 */
4698	track->usrbuf_blksize = frametobyte(&track->usrbuf.fmt,
4699	    frame_per_block(track->mixer, &track->usrbuf.fmt));
4700	track->usrbuf.head = 0;
4701	track->usrbuf.used = 0;
4702	if (is_playback) {
4703		newbufsize = track->usrbuf_blksize * AUMINNOBLK;
4704		if (newbufsize < 65536)
4705			newbufsize = rounddown(65536, track->usrbuf_blksize);
4706		newvsize = roundup2(newbufsize, PAGE_SIZE);
4707	} else {
4708		newbufsize = track->usrbuf_blksize;
4709		newvsize = track->usrbuf_blksize;
4710	}
4711	/*
4712	 * Reallocate only if the number of pages changes.
4713	 * This is because we expect kmem to allocate memory on per page
4714	 * basis if the request size is about 64KB.
4715	 */
4716	if (newvsize != track->usrbuf_allocsize) {
4717		if (track->usrbuf_allocsize != 0) {
4718			kmem_free(track->usrbuf.mem, track->usrbuf_allocsize);
4719		}
4720		TRACET(2, track, "usrbuf_allocsize %d -> %d",
4721		    track->usrbuf_allocsize, newvsize);
4722		track->usrbuf.mem = kmem_alloc(newvsize, KM_SLEEP);
4723		track->usrbuf_allocsize = newvsize;
4724	}
4725	track->usrbuf.capacity = newbufsize;
4726
4727	/* Recalc water mark. */
4728	if (is_playback) {
4729		/* Set high at 100%, low at 75%. */
4730		track->usrbuf_usedhigh = track->usrbuf.capacity;
4731		track->usrbuf_usedlow = track->usrbuf.capacity * 3 / 4;
4732	} else {
4733		/* Set high at 100%, low at 0%. (But not used) */
4734		track->usrbuf_usedhigh = track->usrbuf.capacity;
4735		track->usrbuf_usedlow = 0;
4736	}
4737
4738	/* Stage buffer */
4739	last_dst = &track->outbuf;
4740	if (is_playback) {
4741		/* On playback, initialize from the mixer side in order. */
4742		track->inputfmt = *usrfmt;
4743		track->outbuf.fmt =  track->mixer->track_fmt;
4744
4745		if ((error = audio_track_init_freq(track, &last_dst)) != 0)
4746			goto error;
4747		if ((error = audio_track_init_chmix(track, &last_dst)) != 0)
4748			goto error;
4749		if ((error = audio_track_init_chvol(track, &last_dst)) != 0)
4750			goto error;
4751		if ((error = audio_track_init_codec(track, &last_dst)) != 0)
4752			goto error;
4753	} else {
4754		/* On recording, initialize from userland side in order. */
4755		track->inputfmt = track->mixer->track_fmt;
4756		track->outbuf.fmt = *usrfmt;
4757
4758		if ((error = audio_track_init_codec(track, &last_dst)) != 0)
4759			goto error;
4760		if ((error = audio_track_init_chvol(track, &last_dst)) != 0)
4761			goto error;
4762		if ((error = audio_track_init_chmix(track, &last_dst)) != 0)
4763			goto error;
4764		if ((error = audio_track_init_freq(track, &last_dst)) != 0)
4765			goto error;
4766	}
4767
4768#if defined(AUDIO_DEBUG)
4769	if (audiodebug >= 3) {
4770		if (track->freq.filter) {
4771			audio_print_format2("freq src",
4772			    &track->freq.srcbuf.fmt);
4773			audio_print_format2("freq dst",
4774			    &track->freq.dst->fmt);
4775		}
4776		if (track->chmix.filter) {
4777			audio_print_format2("chmix src",
4778			    &track->chmix.srcbuf.fmt);
4779			audio_print_format2("chmix dst",
4780			    &track->chmix.dst->fmt);
4781		}
4782		if (track->chvol.filter) {
4783			audio_print_format2("chvol src",
4784			    &track->chvol.srcbuf.fmt);
4785			audio_print_format2("chvol dst",
4786			    &track->chvol.dst->fmt);
4787		}
4788		if (track->codec.filter) {
4789			audio_print_format2("codec src",
4790			    &track->codec.srcbuf.fmt);
4791			audio_print_format2("codec dst",
4792			    &track->codec.dst->fmt);
4793		}
4794	}
4795#endif /* AUDIO_DEBUG */
4796
4797	/* Stage input buffer */
4798	track->input = last_dst;
4799
4800	/*
4801	 * Output buffer.
4802	 * On the playback track, its capacity is NBLKOUT blocks.
4803	 * On the recording track, its capacity is 1 block.
4804	 */
4805	track->outbuf.head = 0;
4806	track->outbuf.used = 0;
4807	track->outbuf.capacity = frame_per_block(track->mixer,
4808	    &track->outbuf.fmt);
4809	if (is_playback)
4810		track->outbuf.capacity *= NBLKOUT;
4811	len = auring_bytelen(&track->outbuf);
4812	track->outbuf.mem = audio_realloc(track->outbuf.mem, len);
4813
4814	/*
4815	 * On the recording track, expand the input stage buffer, which is
4816	 * the closest buffer to rmixer, to NBLKIN blocks.
4817	 * Note that input buffer may point to outbuf.
4818	 */
4819	if (!is_playback) {
4820		int input_fpb;
4821
4822		input_fpb = frame_per_block(track->mixer, &track->input->fmt);
4823		track->input->capacity = input_fpb * NBLKIN;
4824		len = auring_bytelen(track->input);
4825		track->input->mem = audio_realloc(track->input->mem, len);
4826	}
4827
4828#if defined(AUDIO_DEBUG)
4829	if (audiodebug >= 3) {
4830		struct audio_track_debugbuf m;
4831
4832		memset(&m, 0, sizeof(m));
4833		snprintf(m.outbuf, sizeof(m.outbuf), " out=%d",
4834		    track->outbuf.capacity * frametobyte(&track->outbuf.fmt,1));
4835		if (track->freq.filter)
4836			snprintf(m.freq, sizeof(m.freq), " freq=%d",
4837			    track->freq.srcbuf.capacity *
4838			    frametobyte(&track->freq.srcbuf.fmt, 1));
4839		if (track->chmix.filter)
4840			snprintf(m.chmix, sizeof(m.chmix), " chmix=%d",
4841			    track->chmix.srcbuf.capacity *
4842			    frametobyte(&track->chmix.srcbuf.fmt, 1));
4843		if (track->chvol.filter)
4844			snprintf(m.chvol, sizeof(m.chvol), " chvol=%d",
4845			    track->chvol.srcbuf.capacity *
4846			    frametobyte(&track->chvol.srcbuf.fmt, 1));
4847		if (track->codec.filter)
4848			snprintf(m.codec, sizeof(m.codec), " codec=%d",
4849			    track->codec.srcbuf.capacity *
4850			    frametobyte(&track->codec.srcbuf.fmt, 1));
4851		snprintf(m.usrbuf, sizeof(m.usrbuf),
4852		    " usr=%d", track->usrbuf.capacity);
4853
4854		if (is_playback) {
4855			TRACET(0, track, "bufsize%s%s%s%s%s%s",
4856			    m.outbuf, m.freq, m.chmix,
4857			    m.chvol, m.codec, m.usrbuf);
4858		} else {
4859			TRACET(0, track, "bufsize%s%s%s%s%s%s",
4860			    m.freq, m.chmix, m.chvol,
4861			    m.codec, m.outbuf, m.usrbuf);
4862		}
4863	}
4864#endif
4865	return 0;
4866
4867error:
4868	audio_free_usrbuf(track);
4869	audio_free(track->codec.srcbuf.mem);
4870	audio_free(track->chvol.srcbuf.mem);
4871	audio_free(track->chmix.srcbuf.mem);
4872	audio_free(track->freq.srcbuf.mem);
4873	audio_free(track->outbuf.mem);
4874	return error;
4875}
4876
4877/*
4878 * Fill silence frames (as the internal format) up to 1 block
4879 * if the ring is not empty and less than 1 block.
4880 * It returns the number of appended frames.
4881 */
4882static int
4883audio_append_silence(audio_track_t *track, audio_ring_t *ring)
4884{
4885	int fpb;
4886	int n;
4887
4888	KASSERT(track);
4889	KASSERT(audio_format2_is_internal(&ring->fmt));
4890
4891	/* XXX is n correct? */
4892	/* XXX memset uses frametobyte()? */
4893
4894	if (ring->used == 0)
4895		return 0;
4896
4897	fpb = frame_per_block(track->mixer, &ring->fmt);
4898	if (ring->used >= fpb)
4899		return 0;
4900
4901	n = (ring->capacity - ring->used) % fpb;
4902
4903	KASSERTMSG(auring_get_contig_free(ring) >= n,
4904	    "auring_get_contig_free(ring)=%d n=%d",
4905	    auring_get_contig_free(ring), n);
4906
4907	memset(auring_tailptr_aint(ring), 0,
4908	    n * ring->fmt.channels * sizeof(aint_t));
4909	auring_push(ring, n);
4910	return n;
4911}
4912
4913/*
4914 * Execute the conversion stage.
4915 * It prepares arg from this stage and executes stage->filter.
4916 * It must be called only if stage->filter is not NULL.
4917 *
4918 * For stages other than frequency conversion, the function increments
4919 * src and dst counters here.  For frequency conversion stage, on the
4920 * other hand, the function does not touch src and dst counters and
4921 * filter side has to increment them.
4922 */
4923static void
4924audio_apply_stage(audio_track_t *track, audio_stage_t *stage, bool isfreq)
4925{
4926	audio_filter_arg_t *arg;
4927	int srccount;
4928	int dstcount;
4929	int count;
4930
4931	KASSERT(track);
4932	KASSERT(stage->filter);
4933
4934	srccount = auring_get_contig_used(&stage->srcbuf);
4935	dstcount = auring_get_contig_free(stage->dst);
4936
4937	if (isfreq) {
4938		KASSERTMSG(srccount > 0, "freq but srccount=%d", srccount);
4939		count = uimin(dstcount, track->mixer->frames_per_block);
4940	} else {
4941		count = uimin(srccount, dstcount);
4942	}
4943
4944	if (count > 0) {
4945		arg = &stage->arg;
4946		arg->src = auring_headptr(&stage->srcbuf);
4947		arg->dst = auring_tailptr(stage->dst);
4948		arg->count = count;
4949
4950		stage->filter(arg);
4951
4952		if (!isfreq) {
4953			auring_take(&stage->srcbuf, count);
4954			auring_push(stage->dst, count);
4955		}
4956	}
4957}
4958
4959/*
4960 * Produce output buffer for playback from user input buffer.
4961 * It must be called only if usrbuf is not empty and outbuf is
4962 * available at least one free block.
4963 */
4964static void
4965audio_track_play(audio_track_t *track)
4966{
4967	audio_ring_t *usrbuf;
4968	audio_ring_t *input;
4969	int count;
4970	int framesize;
4971	int bytes;
4972
4973	KASSERT(track);
4974	KASSERT(track->lock);
4975	TRACET(4, track, "start pstate=%d", track->pstate);
4976
4977	/* At this point usrbuf must not be empty. */
4978	KASSERT(track->usrbuf.used > 0);
4979	/* Also, outbuf must be available at least one block. */
4980	count = auring_get_contig_free(&track->outbuf);
4981	KASSERTMSG(count >= frame_per_block(track->mixer, &track->outbuf.fmt),
4982	    "count=%d fpb=%d",
4983	    count, frame_per_block(track->mixer, &track->outbuf.fmt));
4984
4985	usrbuf = &track->usrbuf;
4986	input = track->input;
4987
4988	/*
4989	 * framesize is always 1 byte or more since all formats supported as
4990	 * usrfmt(=input) have 8bit or more stride.
4991	 */
4992	framesize = frametobyte(&input->fmt, 1);
4993	KASSERT(framesize >= 1);
4994
4995	/* The next stage of usrbuf (=input) must be available. */
4996	KASSERT(auring_get_contig_free(input) > 0);
4997
4998	/*
4999	 * Copy usrbuf up to 1block to input buffer.
5000	 * count is the number of frames to copy from usrbuf.
5001	 * bytes is the number of bytes to copy from usrbuf.  However it is
5002	 * not copied less than one frame.
5003	 */
5004	count = uimin(usrbuf->used, track->usrbuf_blksize) / framesize;
5005	bytes = count * framesize;
5006
5007	if (usrbuf->head + bytes < usrbuf->capacity) {
5008		memcpy((uint8_t *)input->mem + auring_tail(input) * framesize,
5009		    (uint8_t *)usrbuf->mem + usrbuf->head,
5010		    bytes);
5011		auring_push(input, count);
5012		auring_take(usrbuf, bytes);
5013	} else {
5014		int bytes1;
5015		int bytes2;
5016
5017		bytes1 = auring_get_contig_used(usrbuf);
5018		KASSERTMSG(bytes1 % framesize == 0,
5019		    "bytes1=%d framesize=%d", bytes1, framesize);
5020		memcpy((uint8_t *)input->mem + auring_tail(input) * framesize,
5021		    (uint8_t *)usrbuf->mem + usrbuf->head,
5022		    bytes1);
5023		auring_push(input, bytes1 / framesize);
5024		auring_take(usrbuf, bytes1);
5025
5026		bytes2 = bytes - bytes1;
5027		memcpy((uint8_t *)input->mem + auring_tail(input) * framesize,
5028		    (uint8_t *)usrbuf->mem + usrbuf->head,
5029		    bytes2);
5030		auring_push(input, bytes2 / framesize);
5031		auring_take(usrbuf, bytes2);
5032	}
5033
5034	/* Encoding conversion */
5035	if (track->codec.filter)
5036		audio_apply_stage(track, &track->codec, false);
5037
5038	/* Channel volume */
5039	if (track->chvol.filter)
5040		audio_apply_stage(track, &track->chvol, false);
5041
5042	/* Channel mix */
5043	if (track->chmix.filter)
5044		audio_apply_stage(track, &track->chmix, false);
5045
5046	/* Frequency conversion */
5047	/*
5048	 * Since the frequency conversion needs correction for each block,
5049	 * it rounds up to 1 block.
5050	 */
5051	if (track->freq.filter) {
5052		int n;
5053		n = audio_append_silence(track, &track->freq.srcbuf);
5054		if (n > 0) {
5055			TRACET(4, track,
5056			    "freq.srcbuf add silence %d -> %d/%d/%d",
5057			    n,
5058			    track->freq.srcbuf.head,
5059			    track->freq.srcbuf.used,
5060			    track->freq.srcbuf.capacity);
5061		}
5062		if (track->freq.srcbuf.used > 0) {
5063			audio_apply_stage(track, &track->freq, true);
5064		}
5065	}
5066
5067	if (bytes < track->usrbuf_blksize) {
5068		/*
5069		 * Clear all conversion buffer pointer if the conversion was
5070		 * not exactly one block.  These conversion stage buffers are
5071		 * certainly circular buffers because of symmetry with the
5072		 * previous and next stage buffer.  However, since they are
5073		 * treated as simple contiguous buffers in operation, so head
5074		 * always should point 0.  This may happen during drain-age.
5075		 */
5076		TRACET(4, track, "reset stage");
5077		if (track->codec.filter) {
5078			KASSERT(track->codec.srcbuf.used == 0);
5079			track->codec.srcbuf.head = 0;
5080		}
5081		if (track->chvol.filter) {
5082			KASSERT(track->chvol.srcbuf.used == 0);
5083			track->chvol.srcbuf.head = 0;
5084		}
5085		if (track->chmix.filter) {
5086			KASSERT(track->chmix.srcbuf.used == 0);
5087			track->chmix.srcbuf.head = 0;
5088		}
5089		if (track->freq.filter) {
5090			KASSERT(track->freq.srcbuf.used == 0);
5091			track->freq.srcbuf.head = 0;
5092		}
5093	}
5094
5095	track->stamp++;
5096
5097#if defined(AUDIO_DEBUG)
5098	if (audiodebug >= 3) {
5099		struct audio_track_debugbuf m;
5100		audio_track_bufstat(track, &m);
5101		TRACET(0, track, "end%s%s%s%s%s%s",
5102		    m.outbuf, m.freq, m.chvol, m.chmix, m.codec, m.usrbuf);
5103	}
5104#endif
5105}
5106
5107/*
5108 * Produce user output buffer for recording from input buffer.
5109 */
5110static void
5111audio_track_record(audio_track_t *track)
5112{
5113	audio_ring_t *outbuf;
5114	audio_ring_t *usrbuf;
5115	int count;
5116	int bytes;
5117	int framesize;
5118
5119	KASSERT(track);
5120	KASSERT(track->lock);
5121
5122	if (auring_get_contig_used(track->input) == 0) {
5123		TRACET(4, track, "input->used == 0");
5124		return;
5125	}
5126
5127	/* Frequency conversion */
5128	if (track->freq.filter) {
5129		if (track->freq.srcbuf.used > 0) {
5130			audio_apply_stage(track, &track->freq, true);
5131			/* XXX should input of freq be from beginning of buf? */
5132		}
5133	}
5134
5135	/* Channel mix */
5136	if (track->chmix.filter)
5137		audio_apply_stage(track, &track->chmix, false);
5138
5139	/* Channel volume */
5140	if (track->chvol.filter)
5141		audio_apply_stage(track, &track->chvol, false);
5142
5143	/* Encoding conversion */
5144	if (track->codec.filter)
5145		audio_apply_stage(track, &track->codec, false);
5146
5147	/* Copy outbuf to usrbuf */
5148	outbuf = &track->outbuf;
5149	usrbuf = &track->usrbuf;
5150	/* usrbuf should be empty. */
5151	KASSERT(usrbuf->used == 0);
5152	/*
5153	 * framesize is always 1 byte or more since all formats supported
5154	 * as usrfmt(=output) have 8bit or more stride.
5155	 */
5156	framesize = frametobyte(&outbuf->fmt, 1);
5157	KASSERT(framesize >= 1);
5158	/*
5159	 * count is the number of frames to copy to usrbuf.
5160	 * bytes is the number of bytes to copy to usrbuf.
5161	 */
5162	count = outbuf->used;
5163	count = uimin(count, track->usrbuf_blksize / framesize);
5164	bytes = count * framesize;
5165	if (auring_tail(usrbuf) + bytes < usrbuf->capacity) {
5166		memcpy((uint8_t *)usrbuf->mem + auring_tail(usrbuf),
5167		    (uint8_t *)outbuf->mem + outbuf->head * framesize,
5168		    bytes);
5169		auring_push(usrbuf, bytes);
5170		auring_take(outbuf, count);
5171	} else {
5172		int bytes1;
5173		int bytes2;
5174
5175		bytes1 = auring_get_contig_free(usrbuf);
5176		KASSERTMSG(bytes1 % framesize == 0,
5177		    "bytes1=%d framesize=%d", bytes1, framesize);
5178		memcpy((uint8_t *)usrbuf->mem + auring_tail(usrbuf),
5179		    (uint8_t *)outbuf->mem + outbuf->head * framesize,
5180		    bytes1);
5181		auring_push(usrbuf, bytes1);
5182		auring_take(outbuf, bytes1 / framesize);
5183
5184		bytes2 = bytes - bytes1;
5185		memcpy((uint8_t *)usrbuf->mem + auring_tail(usrbuf),
5186		    (uint8_t *)outbuf->mem + outbuf->head * framesize,
5187		    bytes2);
5188		auring_push(usrbuf, bytes2);
5189		auring_take(outbuf, bytes2 / framesize);
5190	}
5191
5192#if defined(AUDIO_DEBUG)
5193	if (audiodebug >= 3) {
5194		struct audio_track_debugbuf m;
5195		audio_track_bufstat(track, &m);
5196		TRACET(0, track, "end%s%s%s%s%s%s",
5197		    m.freq, m.chvol, m.chmix, m.codec, m.outbuf, m.usrbuf);
5198	}
5199#endif
5200}
5201
5202/*
5203 * Calculate blktime [msec] from mixer(.hwbuf.fmt).
5204 * Must be called with sc_exlock held.
5205 */
5206static u_int
5207audio_mixer_calc_blktime(struct audio_softc *sc, audio_trackmixer_t *mixer)
5208{
5209	audio_format2_t *fmt;
5210	u_int blktime;
5211	u_int frames_per_block;
5212
5213	KASSERT(sc->sc_exlock);
5214
5215	fmt = &mixer->hwbuf.fmt;
5216	blktime = sc->sc_blk_ms;
5217
5218	/*
5219	 * If stride is not multiples of 8, special treatment is necessary.
5220	 * For now, it is only x68k's vs(4), 4 bit/sample ADPCM.
5221	 */
5222	if (fmt->stride == 4) {
5223		frames_per_block = fmt->sample_rate * blktime / 1000;
5224		if ((frames_per_block & 1) != 0)
5225			blktime *= 2;
5226	}
5227#ifdef DIAGNOSTIC
5228	else if (fmt->stride % NBBY != 0) {
5229		panic("unsupported HW stride %d", fmt->stride);
5230	}
5231#endif
5232
5233	return blktime;
5234}
5235
5236/*
5237 * Initialize the mixer corresponding to the mode.
5238 * Set AUMODE_PLAY to the 'mode' for playback or AUMODE_RECORD for recording.
5239 * sc->sc_[pr]mixer (corresponding to the 'mode') must be zero-filled.
5240 * This function returns 0 on successful.  Otherwise returns errno.
5241 * Must be called with sc_exlock held and without sc_lock held.
5242 */
5243static int
5244audio_mixer_init(struct audio_softc *sc, int mode,
5245	const audio_format2_t *hwfmt, const audio_filter_reg_t *reg)
5246{
5247	char codecbuf[64];
5248	char blkdmsbuf[8];
5249	audio_trackmixer_t *mixer;
5250	void (*softint_handler)(void *);
5251	int len;
5252	int blksize;
5253	int capacity;
5254	size_t bufsize;
5255	int hwblks;
5256	int blkms;
5257	int blkdms;
5258	int error;
5259
5260	KASSERT(hwfmt != NULL);
5261	KASSERT(reg != NULL);
5262	KASSERT(sc->sc_exlock);
5263
5264	error = 0;
5265	if (mode == AUMODE_PLAY)
5266		mixer = sc->sc_pmixer;
5267	else
5268		mixer = sc->sc_rmixer;
5269
5270	mixer->sc = sc;
5271	mixer->mode = mode;
5272
5273	mixer->hwbuf.fmt = *hwfmt;
5274	mixer->volume = 256;
5275	mixer->blktime_d = 1000;
5276	mixer->blktime_n = audio_mixer_calc_blktime(sc, mixer);
5277	sc->sc_blk_ms = mixer->blktime_n;
5278	hwblks = NBLKHW;
5279
5280	mixer->frames_per_block = frame_per_block(mixer, &mixer->hwbuf.fmt);
5281	blksize = frametobyte(&mixer->hwbuf.fmt, mixer->frames_per_block);
5282	if (sc->hw_if->round_blocksize) {
5283		int rounded;
5284		audio_params_t p = format2_to_params(&mixer->hwbuf.fmt);
5285		mutex_enter(sc->sc_lock);
5286		rounded = sc->hw_if->round_blocksize(sc->hw_hdl, blksize,
5287		    mode, &p);
5288		mutex_exit(sc->sc_lock);
5289		TRACE(1, "round_blocksize %d -> %d", blksize, rounded);
5290		if (rounded != blksize) {
5291			if ((rounded * NBBY) % (mixer->hwbuf.fmt.stride *
5292			    mixer->hwbuf.fmt.channels) != 0) {
5293				audio_printf(sc,
5294				    "round_blocksize returned blocksize "
5295				    "indivisible by framesize: "
5296				    "blksize=%d rounded=%d "
5297				    "stride=%ubit channels=%u\n",
5298				    blksize, rounded,
5299				    mixer->hwbuf.fmt.stride,
5300				    mixer->hwbuf.fmt.channels);
5301				return EINVAL;
5302			}
5303			/* Recalculation */
5304			blksize = rounded;
5305			mixer->frames_per_block = blksize * NBBY /
5306			    (mixer->hwbuf.fmt.stride *
5307			     mixer->hwbuf.fmt.channels);
5308		}
5309	}
5310	mixer->blktime_n = mixer->frames_per_block;
5311	mixer->blktime_d = mixer->hwbuf.fmt.sample_rate;
5312
5313	capacity = mixer->frames_per_block * hwblks;
5314	bufsize = frametobyte(&mixer->hwbuf.fmt, capacity);
5315	if (sc->hw_if->round_buffersize) {
5316		size_t rounded;
5317		mutex_enter(sc->sc_lock);
5318		rounded = sc->hw_if->round_buffersize(sc->hw_hdl, mode,
5319		    bufsize);
5320		mutex_exit(sc->sc_lock);
5321		TRACE(1, "round_buffersize %zd -> %zd", bufsize, rounded);
5322		if (rounded < bufsize) {
5323			/* buffersize needs NBLKHW blocks at least. */
5324			audio_printf(sc,
5325			    "round_buffersize returned too small buffersize: "
5326			    "buffersize=%zd blksize=%d\n",
5327			    rounded, blksize);
5328			return EINVAL;
5329		}
5330		if (rounded % blksize != 0) {
5331			/* buffersize/blksize constraint mismatch? */
5332			audio_printf(sc,
5333			    "round_buffersize returned buffersize indivisible "
5334			    "by blksize: buffersize=%zu blksize=%d\n",
5335			    rounded, blksize);
5336			return EINVAL;
5337		}
5338		if (rounded != bufsize) {
5339			/* Recalculation */
5340			bufsize = rounded;
5341			hwblks = bufsize / blksize;
5342			capacity = mixer->frames_per_block * hwblks;
5343		}
5344	}
5345	TRACE(1, "buffersize for %s = %zu",
5346	    (mode == AUMODE_PLAY) ? "playback" : "recording",
5347	    bufsize);
5348	mixer->hwbuf.capacity = capacity;
5349
5350	if (sc->hw_if->allocm) {
5351		/* sc_lock is not necessary for allocm */
5352		mixer->hwbuf.mem = sc->hw_if->allocm(sc->hw_hdl, mode, bufsize);
5353		if (mixer->hwbuf.mem == NULL) {
5354			audio_printf(sc, "allocm(%zu) failed\n", bufsize);
5355			return ENOMEM;
5356		}
5357	} else {
5358		mixer->hwbuf.mem = kmem_alloc(bufsize, KM_SLEEP);
5359	}
5360
5361	/* From here, audio_mixer_destroy is necessary to exit. */
5362	if (mode == AUMODE_PLAY) {
5363		cv_init(&mixer->outcv, "audiowr");
5364	} else {
5365		cv_init(&mixer->outcv, "audiord");
5366	}
5367
5368	if (mode == AUMODE_PLAY) {
5369		softint_handler = audio_softintr_wr;
5370	} else {
5371		softint_handler = audio_softintr_rd;
5372	}
5373	mixer->sih = softint_establish(SOFTINT_SERIAL | SOFTINT_MPSAFE,
5374	    softint_handler, sc);
5375	if (mixer->sih == NULL) {
5376		device_printf(sc->sc_dev, "softint_establish failed\n");
5377		goto abort;
5378	}
5379
5380	mixer->track_fmt.encoding = AUDIO_ENCODING_SLINEAR_NE;
5381	mixer->track_fmt.precision = AUDIO_INTERNAL_BITS;
5382	mixer->track_fmt.stride = AUDIO_INTERNAL_BITS;
5383	mixer->track_fmt.channels = mixer->hwbuf.fmt.channels;
5384	mixer->track_fmt.sample_rate = mixer->hwbuf.fmt.sample_rate;
5385
5386	if (mixer->hwbuf.fmt.encoding == AUDIO_ENCODING_SLINEAR_OE &&
5387	    mixer->hwbuf.fmt.precision == AUDIO_INTERNAL_BITS) {
5388		mixer->swap_endian = true;
5389		TRACE(1, "swap_endian");
5390	}
5391
5392	if (mode == AUMODE_PLAY) {
5393		/* Mixing buffer */
5394		mixer->mixfmt = mixer->track_fmt;
5395		mixer->mixfmt.precision *= 2;
5396		mixer->mixfmt.stride *= 2;
5397		/* XXX TODO: use some macros? */
5398		len = mixer->frames_per_block * mixer->mixfmt.channels *
5399		    mixer->mixfmt.stride / NBBY;
5400		mixer->mixsample = audio_realloc(mixer->mixsample, len);
5401	} else if (reg->codec == NULL) {
5402		/*
5403		 * Recording requires an input conversion buffer
5404		 * unless the hardware provides a codec itself
5405		 */
5406		mixer->mixfmt = mixer->track_fmt;
5407		len = mixer->frames_per_block * mixer->mixfmt.channels *
5408		    mixer->mixfmt.stride / NBBY;
5409		mixer->mixsample = audio_realloc(mixer->mixsample, len);
5410	}
5411
5412	if (reg->codec) {
5413		mixer->codec = reg->codec;
5414		mixer->codecarg.context = reg->context;
5415		if (mode == AUMODE_PLAY) {
5416			mixer->codecarg.srcfmt = &mixer->track_fmt;
5417			mixer->codecarg.dstfmt = &mixer->hwbuf.fmt;
5418		} else {
5419			mixer->codecarg.srcfmt = &mixer->hwbuf.fmt;
5420			mixer->codecarg.dstfmt = &mixer->track_fmt;
5421		}
5422		mixer->codecbuf.fmt = mixer->track_fmt;
5423		mixer->codecbuf.capacity = mixer->frames_per_block;
5424		len = auring_bytelen(&mixer->codecbuf);
5425		mixer->codecbuf.mem = audio_realloc(mixer->codecbuf.mem, len);
5426	}
5427
5428	/* Succeeded so display it. */
5429	codecbuf[0] = '\0';
5430	if (mixer->codec || mixer->swap_endian) {
5431		snprintf(codecbuf, sizeof(codecbuf), " %s %s:%d",
5432		    (mode == AUMODE_PLAY) ? "->" : "<-",
5433		    audio_encoding_name(mixer->hwbuf.fmt.encoding),
5434		    mixer->hwbuf.fmt.precision);
5435	}
5436	blkms = mixer->blktime_n * 1000 / mixer->blktime_d;
5437	blkdms = (mixer->blktime_n * 10000 / mixer->blktime_d) % 10;
5438	blkdmsbuf[0] = '\0';
5439	if (blkdms != 0) {
5440		snprintf(blkdmsbuf, sizeof(blkdmsbuf), ".%1d", blkdms);
5441	}
5442	aprint_normal_dev(sc->sc_dev,
5443	    "%s:%d%s %dch %dHz, blk %d bytes (%d%sms) for %s\n",
5444	    audio_encoding_name(mixer->track_fmt.encoding),
5445	    mixer->track_fmt.precision,
5446	    codecbuf,
5447	    mixer->track_fmt.channels,
5448	    mixer->track_fmt.sample_rate,
5449	    blksize,
5450	    blkms, blkdmsbuf,
5451	    (mode == AUMODE_PLAY) ? "playback" : "recording");
5452
5453	return 0;
5454
5455abort:
5456	audio_mixer_destroy(sc, mixer);
5457	return error;
5458}
5459
5460/*
5461 * Releases all resources of 'mixer'.
5462 * Note that it does not release the memory area of 'mixer' itself.
5463 * Must be called with sc_exlock held and without sc_lock held.
5464 */
5465static void
5466audio_mixer_destroy(struct audio_softc *sc, audio_trackmixer_t *mixer)
5467{
5468	int bufsize;
5469
5470	KASSERT(sc->sc_exlock == 1);
5471
5472	bufsize = frametobyte(&mixer->hwbuf.fmt, mixer->hwbuf.capacity);
5473
5474	if (mixer->hwbuf.mem != NULL) {
5475		if (sc->hw_if->freem) {
5476			/* sc_lock is not necessary for freem */
5477			sc->hw_if->freem(sc->hw_hdl, mixer->hwbuf.mem, bufsize);
5478		} else {
5479			kmem_free(mixer->hwbuf.mem, bufsize);
5480		}
5481		mixer->hwbuf.mem = NULL;
5482	}
5483
5484	audio_free(mixer->codecbuf.mem);
5485	audio_free(mixer->mixsample);
5486
5487	cv_destroy(&mixer->outcv);
5488
5489	if (mixer->sih) {
5490		softint_disestablish(mixer->sih);
5491		mixer->sih = NULL;
5492	}
5493}
5494
5495/*
5496 * Starts playback mixer.
5497 * Must be called only if sc_pbusy is false.
5498 * Must be called with sc_lock && sc_exlock held.
5499 * Must not be called from the interrupt context.
5500 */
5501static void
5502audio_pmixer_start(struct audio_softc *sc, bool force)
5503{
5504	audio_trackmixer_t *mixer;
5505	int minimum;
5506
5507	KASSERT(mutex_owned(sc->sc_lock));
5508	KASSERT(sc->sc_exlock);
5509	KASSERT(sc->sc_pbusy == false);
5510
5511	mutex_enter(sc->sc_intr_lock);
5512
5513	mixer = sc->sc_pmixer;
5514	TRACE(2, "%smixseq=%d hwseq=%d hwbuf=%d/%d/%d%s",
5515	    (audiodebug >= 3) ? "begin " : "",
5516	    (int)mixer->mixseq, (int)mixer->hwseq,
5517	    mixer->hwbuf.head, mixer->hwbuf.used, mixer->hwbuf.capacity,
5518	    force ? " force" : "");
5519
5520	/* Need two blocks to start normally. */
5521	minimum = (force) ? 1 : 2;
5522	while (mixer->hwbuf.used < mixer->frames_per_block * minimum) {
5523		audio_pmixer_process(sc);
5524	}
5525
5526	/* Start output */
5527	audio_pmixer_output(sc);
5528	sc->sc_pbusy = true;
5529
5530	TRACE(3, "end   mixseq=%d hwseq=%d hwbuf=%d/%d/%d",
5531	    (int)mixer->mixseq, (int)mixer->hwseq,
5532	    mixer->hwbuf.head, mixer->hwbuf.used, mixer->hwbuf.capacity);
5533
5534	mutex_exit(sc->sc_intr_lock);
5535}
5536
5537/*
5538 * When playing back with MD filter:
5539 *
5540 *           track track ...
5541 *               v v
5542 *                +  mix (with aint2_t)
5543 *                |  master volume (with aint2_t)
5544 *                v
5545 *    mixsample [::::]                  wide-int 1 block (ring) buffer
5546 *                |
5547 *                |  convert aint2_t -> aint_t
5548 *                v
5549 *    codecbuf  [....]                  1 block (ring) buffer
5550 *                |
5551 *                |  convert to hw format
5552 *                v
5553 *    hwbuf     [............]          NBLKHW blocks ring buffer
5554 *
5555 * When playing back without MD filter:
5556 *
5557 *    mixsample [::::]                  wide-int 1 block (ring) buffer
5558 *                |
5559 *                |  convert aint2_t -> aint_t
5560 *                |  (with byte swap if necessary)
5561 *                v
5562 *    hwbuf     [............]          NBLKHW blocks ring buffer
5563 *
5564 * mixsample: slinear_NE, wide internal precision, HW ch, HW freq.
5565 * codecbuf:  slinear_NE, internal precision,      HW ch, HW freq.
5566 * hwbuf:     HW encoding, HW precision,           HW ch, HW freq.
5567 */
5568
5569/*
5570 * Performs track mixing and converts it to hwbuf.
5571 * Note that this function doesn't transfer hwbuf to hardware.
5572 * Must be called with sc_intr_lock held.
5573 */
5574static void
5575audio_pmixer_process(struct audio_softc *sc)
5576{
5577	audio_trackmixer_t *mixer;
5578	audio_file_t *f;
5579	int frame_count;
5580	int sample_count;
5581	int mixed;
5582	int i;
5583	aint2_t *m;
5584	aint_t *h;
5585
5586	mixer = sc->sc_pmixer;
5587
5588	frame_count = mixer->frames_per_block;
5589	KASSERTMSG(auring_get_contig_free(&mixer->hwbuf) >= frame_count,
5590	    "auring_get_contig_free()=%d frame_count=%d",
5591	    auring_get_contig_free(&mixer->hwbuf), frame_count);
5592	sample_count = frame_count * mixer->mixfmt.channels;
5593
5594	mixer->mixseq++;
5595
5596	/* Mix all tracks */
5597	mixed = 0;
5598	SLIST_FOREACH(f, &sc->sc_files, entry) {
5599		audio_track_t *track = f->ptrack;
5600
5601		if (track == NULL)
5602			continue;
5603
5604		if (track->is_pause) {
5605			TRACET(4, track, "skip; paused");
5606			continue;
5607		}
5608
5609		/* Skip if the track is used by process context. */
5610		if (audio_track_lock_tryenter(track) == false) {
5611			TRACET(4, track, "skip; in use");
5612			continue;
5613		}
5614
5615		/* Emulate mmap'ped track */
5616		if (track->mmapped) {
5617			auring_push(&track->usrbuf, track->usrbuf_blksize);
5618			TRACET(4, track, "mmap; usr=%d/%d/C%d",
5619			    track->usrbuf.head,
5620			    track->usrbuf.used,
5621			    track->usrbuf.capacity);
5622		}
5623
5624		if (track->outbuf.used < mixer->frames_per_block &&
5625		    track->usrbuf.used > 0) {
5626			TRACET(4, track, "process");
5627			audio_track_play(track);
5628		}
5629
5630		if (track->outbuf.used > 0) {
5631			mixed = audio_pmixer_mix_track(mixer, track, mixed);
5632		} else {
5633			TRACET(4, track, "skip; empty");
5634		}
5635
5636		audio_track_lock_exit(track);
5637	}
5638
5639	if (mixed == 0) {
5640		/* Silence */
5641		memset(mixer->mixsample, 0,
5642		    frametobyte(&mixer->mixfmt, frame_count));
5643	} else {
5644		if (mixed > 1) {
5645			/* If there are multiple tracks, do auto gain control */
5646			audio_pmixer_agc(mixer, sample_count);
5647		}
5648
5649		/* Apply master volume */
5650		if (mixer->volume < 256) {
5651			m = mixer->mixsample;
5652			for (i = 0; i < sample_count; i++) {
5653				*m = AUDIO_SCALEDOWN(*m * mixer->volume, 8);
5654				m++;
5655			}
5656
5657			/*
5658			 * Recover the volume gradually at the pace of
5659			 * several times per second.  If it's too fast, you
5660			 * can recognize that the volume changes up and down
5661			 * quickly and it's not so comfortable.
5662			 */
5663			mixer->voltimer += mixer->blktime_n;
5664			if (mixer->voltimer * 4 >= mixer->blktime_d) {
5665				mixer->volume++;
5666				mixer->voltimer = 0;
5667#if defined(AUDIO_DEBUG_AGC)
5668				TRACE(1, "volume recover: %d", mixer->volume);
5669#endif
5670			}
5671		}
5672	}
5673
5674	/*
5675	 * The rest is the hardware part.
5676	 */
5677
5678	m = mixer->mixsample;
5679
5680	if (mixer->codec) {
5681		TRACE(4, "codec count=%d", frame_count);
5682
5683		h = auring_tailptr_aint(&mixer->codecbuf);
5684		for (i=0; i<sample_count; ++i)
5685			*h++ = *m++;
5686
5687		/* Hardware driver's codec */
5688		auring_push(&mixer->codecbuf, frame_count);
5689		mixer->codecarg.src = auring_headptr(&mixer->codecbuf);
5690		mixer->codecarg.dst = auring_tailptr(&mixer->hwbuf);
5691		mixer->codecarg.count = frame_count;
5692		mixer->codec(&mixer->codecarg);
5693		auring_take(&mixer->codecbuf, mixer->codecarg.count);
5694	} else {
5695		TRACE(4, "direct count=%d", frame_count);
5696
5697		/* Direct conversion to linear output */
5698		mixer->codecarg.src = m;
5699		mixer->codecarg.dst = auring_tailptr(&mixer->hwbuf);
5700		mixer->codecarg.count = frame_count;
5701		mixer->codecarg.srcfmt = &mixer->mixfmt;
5702		mixer->codecarg.dstfmt = &mixer->hwbuf.fmt;
5703		audio_mixsample_to_linear(&mixer->codecarg);
5704	}
5705
5706	auring_push(&mixer->hwbuf, frame_count);
5707
5708	TRACE(4, "done mixseq=%d hwbuf=%d/%d/%d%s",
5709	    (int)mixer->mixseq,
5710	    mixer->hwbuf.head, mixer->hwbuf.used, mixer->hwbuf.capacity,
5711	    (mixed == 0) ? " silent" : "");
5712}
5713
5714/*
5715 * Do auto gain control.
5716 * Must be called sc_intr_lock held.
5717 */
5718static void
5719audio_pmixer_agc(audio_trackmixer_t *mixer, int sample_count)
5720{
5721	struct audio_softc *sc __unused;
5722	aint2_t val;
5723	aint2_t maxval;
5724	aint2_t minval;
5725	aint2_t over_plus;
5726	aint2_t over_minus;
5727	aint2_t *m;
5728	int newvol;
5729	int i;
5730
5731	sc = mixer->sc;
5732
5733	/* Overflow detection */
5734	maxval = AINT_T_MAX;
5735	minval = AINT_T_MIN;
5736	m = mixer->mixsample;
5737	for (i = 0; i < sample_count; i++) {
5738		val = *m++;
5739		if (val > maxval)
5740			maxval = val;
5741		else if (val < minval)
5742			minval = val;
5743	}
5744
5745	/* Absolute value of overflowed amount */
5746	over_plus = maxval - AINT_T_MAX;
5747	over_minus = AINT_T_MIN - minval;
5748
5749	if (over_plus > 0 || over_minus > 0) {
5750		if (over_plus > over_minus) {
5751			newvol = (int)((aint2_t)AINT_T_MAX * 256 / maxval);
5752		} else {
5753			newvol = (int)((aint2_t)AINT_T_MIN * 256 / minval);
5754		}
5755
5756		/*
5757		 * Change the volume only if new one is smaller.
5758		 * Reset the timer even if the volume isn't changed.
5759		 */
5760		if (newvol <= mixer->volume) {
5761			mixer->volume = newvol;
5762			mixer->voltimer = 0;
5763#if defined(AUDIO_DEBUG_AGC)
5764			TRACE(1, "auto volume adjust: %d", mixer->volume);
5765#endif
5766		}
5767	}
5768}
5769
5770/*
5771 * Mix one track.
5772 * 'mixed' specifies the number of tracks mixed so far.
5773 * It returns the number of tracks mixed.  In other words, it returns
5774 * mixed + 1 if this track is mixed.
5775 */
5776static int
5777audio_pmixer_mix_track(audio_trackmixer_t *mixer, audio_track_t *track,
5778	int mixed)
5779{
5780	int count;
5781	int sample_count;
5782	int remain;
5783	int i;
5784	const aint_t *s;
5785	aint2_t *d;
5786
5787	/* XXX TODO: Is this necessary for now? */
5788	if (mixer->mixseq < track->seq)
5789		return mixed;
5790
5791	count = auring_get_contig_used(&track->outbuf);
5792	count = uimin(count, mixer->frames_per_block);
5793
5794	s = auring_headptr_aint(&track->outbuf);
5795	d = mixer->mixsample;
5796
5797	/*
5798	 * Apply track volume with double-sized integer and perform
5799	 * additive synthesis.
5800	 *
5801	 * XXX If you limit the track volume to 1.0 or less (<= 256),
5802	 *     it would be better to do this in the track conversion stage
5803	 *     rather than here.  However, if you accept the volume to
5804	 *     be greater than 1.0 (> 256), it's better to do it here.
5805	 *     Because the operation here is done by double-sized integer.
5806	 */
5807	sample_count = count * mixer->mixfmt.channels;
5808	if (mixed == 0) {
5809		/* If this is the first track, assignment can be used. */
5810#if defined(AUDIO_SUPPORT_TRACK_VOLUME)
5811		if (track->volume != 256) {
5812			for (i = 0; i < sample_count; i++) {
5813				aint2_t v;
5814				v = *s++;
5815				*d++ = AUDIO_SCALEDOWN(v * track->volume, 8)
5816			}
5817		} else
5818#endif
5819		{
5820			for (i = 0; i < sample_count; i++) {
5821				*d++ = ((aint2_t)*s++);
5822			}
5823		}
5824		/* Fill silence if the first track is not filled. */
5825		for (; i < mixer->frames_per_block * mixer->mixfmt.channels; i++)
5826			*d++ = 0;
5827	} else {
5828		/* If this is the second or later, add it. */
5829#if defined(AUDIO_SUPPORT_TRACK_VOLUME)
5830		if (track->volume != 256) {
5831			for (i = 0; i < sample_count; i++) {
5832				aint2_t v;
5833				v = *s++;
5834				*d++ += AUDIO_SCALEDOWN(v * track->volume, 8);
5835			}
5836		} else
5837#endif
5838		{
5839			for (i = 0; i < sample_count; i++) {
5840				*d++ += ((aint2_t)*s++);
5841			}
5842		}
5843	}
5844
5845	auring_take(&track->outbuf, count);
5846	/*
5847	 * The counters have to align block even if outbuf is less than
5848	 * one block. XXX Is this still necessary?
5849	 */
5850	remain = mixer->frames_per_block - count;
5851	if (__predict_false(remain != 0)) {
5852		auring_push(&track->outbuf, remain);
5853		auring_take(&track->outbuf, remain);
5854	}
5855
5856	/*
5857	 * Update track sequence.
5858	 * mixseq has previous value yet at this point.
5859	 */
5860	track->seq = mixer->mixseq + 1;
5861
5862	return mixed + 1;
5863}
5864
5865/*
5866 * Output one block from hwbuf to HW.
5867 * Must be called with sc_intr_lock held.
5868 */
5869static void
5870audio_pmixer_output(struct audio_softc *sc)
5871{
5872	audio_trackmixer_t *mixer;
5873	audio_params_t params;
5874	void *start;
5875	void *end;
5876	int blksize;
5877	int error;
5878
5879	mixer = sc->sc_pmixer;
5880	TRACE(4, "pbusy=%d hwbuf=%d/%d/%d",
5881	    sc->sc_pbusy,
5882	    mixer->hwbuf.head, mixer->hwbuf.used, mixer->hwbuf.capacity);
5883	KASSERTMSG(mixer->hwbuf.used >= mixer->frames_per_block,
5884	    "mixer->hwbuf.used=%d mixer->frames_per_block=%d",
5885	    mixer->hwbuf.used, mixer->frames_per_block);
5886
5887	blksize = frametobyte(&mixer->hwbuf.fmt, mixer->frames_per_block);
5888
5889	if (sc->hw_if->trigger_output) {
5890		/* trigger (at once) */
5891		if (!sc->sc_pbusy) {
5892			start = mixer->hwbuf.mem;
5893			end = (uint8_t *)start + auring_bytelen(&mixer->hwbuf);
5894			params = format2_to_params(&mixer->hwbuf.fmt);
5895
5896			error = sc->hw_if->trigger_output(sc->hw_hdl,
5897			    start, end, blksize, audio_pintr, sc, &params);
5898			if (error) {
5899				audio_printf(sc,
5900				    "trigger_output failed: errno=%d\n",
5901				    error);
5902				return;
5903			}
5904		}
5905	} else {
5906		/* start (everytime) */
5907		start = auring_headptr(&mixer->hwbuf);
5908
5909		error = sc->hw_if->start_output(sc->hw_hdl,
5910		    start, blksize, audio_pintr, sc);
5911		if (error) {
5912			audio_printf(sc,
5913			    "start_output failed: errno=%d\n", error);
5914			return;
5915		}
5916	}
5917}
5918
5919/*
5920 * This is an interrupt handler for playback.
5921 * It is called with sc_intr_lock held.
5922 *
5923 * It is usually called from hardware interrupt.  However, note that
5924 * for some drivers (e.g. uaudio) it is called from software interrupt.
5925 */
5926static void
5927audio_pintr(void *arg)
5928{
5929	struct audio_softc *sc;
5930	audio_trackmixer_t *mixer;
5931
5932	sc = arg;
5933	KASSERT(mutex_owned(sc->sc_intr_lock));
5934
5935	if (sc->sc_dying)
5936		return;
5937	if (sc->sc_pbusy == false) {
5938#if defined(DIAGNOSTIC)
5939		audio_printf(sc, "DIAGNOSTIC: %s raised stray interrupt\n",
5940		    device_xname(sc->hw_dev));
5941#endif
5942		return;
5943	}
5944
5945	mixer = sc->sc_pmixer;
5946	mixer->hw_complete_counter += mixer->frames_per_block;
5947	mixer->hwseq++;
5948
5949	auring_take(&mixer->hwbuf, mixer->frames_per_block);
5950
5951	TRACE(4,
5952	    "HW_INT ++hwseq=%" PRIu64 " cmplcnt=%" PRIu64 " hwbuf=%d/%d/%d",
5953	    mixer->hwseq, mixer->hw_complete_counter,
5954	    mixer->hwbuf.head, mixer->hwbuf.used, mixer->hwbuf.capacity);
5955
5956#if defined(AUDIO_HW_SINGLE_BUFFER)
5957	/*
5958	 * Create a new block here and output it immediately.
5959	 * It makes a latency lower but needs machine power.
5960	 */
5961	audio_pmixer_process(sc);
5962	audio_pmixer_output(sc);
5963#else
5964	/*
5965	 * It is called when block N output is done.
5966	 * Output immediately block N+1 created by the last interrupt.
5967	 * And then create block N+2 for the next interrupt.
5968	 * This method makes playback robust even on slower machines.
5969	 * Instead the latency is increased by one block.
5970	 */
5971
5972	/* At first, output ready block. */
5973	if (mixer->hwbuf.used >= mixer->frames_per_block) {
5974		audio_pmixer_output(sc);
5975	}
5976
5977	bool later = false;
5978
5979	if (mixer->hwbuf.used < mixer->frames_per_block) {
5980		later = true;
5981	}
5982
5983	/* Then, process next block. */
5984	audio_pmixer_process(sc);
5985
5986	if (later) {
5987		audio_pmixer_output(sc);
5988	}
5989#endif
5990
5991	/*
5992	 * When this interrupt is the real hardware interrupt, disabling
5993	 * preemption here is not necessary.  But some drivers (e.g. uaudio)
5994	 * emulate it by software interrupt, so kpreempt_disable is necessary.
5995	 */
5996	kpreempt_disable();
5997	softint_schedule(mixer->sih);
5998	kpreempt_enable();
5999}
6000
6001/*
6002 * Starts record mixer.
6003 * Must be called only if sc_rbusy is false.
6004 * Must be called with sc_lock && sc_exlock held.
6005 * Must not be called from the interrupt context.
6006 */
6007static void
6008audio_rmixer_start(struct audio_softc *sc)
6009{
6010
6011	KASSERT(mutex_owned(sc->sc_lock));
6012	KASSERT(sc->sc_exlock);
6013	KASSERT(sc->sc_rbusy == false);
6014
6015	mutex_enter(sc->sc_intr_lock);
6016
6017	TRACE(2, "%s", (audiodebug >= 3) ? "begin" : "");
6018	audio_rmixer_input(sc);
6019	sc->sc_rbusy = true;
6020	TRACE(3, "end");
6021
6022	mutex_exit(sc->sc_intr_lock);
6023}
6024
6025/*
6026 * When recording with MD filter:
6027 *
6028 *    hwbuf     [............]          NBLKHW blocks ring buffer
6029 *                |
6030 *                | convert from hw format
6031 *                v
6032 *    codecbuf  [....]                  1 block (ring) buffer
6033 *               |  |
6034 *               v  v
6035 *            track track ...
6036 *
6037 * When recording without MD filter:
6038 *
6039 *    hwbuf     [............]          NBLKHW blocks ring buffer
6040 *               |  |
6041 *               v  v
6042 *            track track ...
6043 *
6044 * hwbuf:     HW encoding, HW precision, HW ch, HW freq.
6045 * codecbuf:  slinear_NE, internal precision, HW ch, HW freq.
6046 */
6047
6048/*
6049 * Distribute a recorded block to all recording tracks.
6050 */
6051static void
6052audio_rmixer_process(struct audio_softc *sc)
6053{
6054	audio_trackmixer_t *mixer;
6055	audio_ring_t *mixersrc;
6056	audio_ring_t tmpsrc;
6057	audio_filter_t codec;
6058	audio_filter_arg_t codecarg;
6059	audio_file_t *f;
6060	int count;
6061	int bytes;
6062
6063	mixer = sc->sc_rmixer;
6064
6065	/*
6066	 * count is the number of frames to be retrieved this time.
6067	 * count should be one block.
6068	 */
6069	count = auring_get_contig_used(&mixer->hwbuf);
6070	count = uimin(count, mixer->frames_per_block);
6071	if (count <= 0) {
6072		TRACE(4, "count %d: too short", count);
6073		return;
6074	}
6075	bytes = frametobyte(&mixer->track_fmt, count);
6076
6077	/* Hardware driver's codec */
6078	if (mixer->codec) {
6079		TRACE(4, "codec count=%d", count);
6080		mixer->codecarg.src = auring_headptr(&mixer->hwbuf);
6081		mixer->codecarg.dst = auring_tailptr(&mixer->codecbuf);
6082		mixer->codecarg.count = count;
6083		mixer->codec(&mixer->codecarg);
6084		mixersrc = &mixer->codecbuf;
6085	} else {
6086		TRACE(4, "direct count=%d", count);
6087		/* temporary ring using mixsample buffer */
6088		tmpsrc.fmt = mixer->mixfmt;
6089		tmpsrc.capacity = mixer->frames_per_block;
6090		tmpsrc.mem = mixer->mixsample;
6091		tmpsrc.head = 0;
6092		tmpsrc.used = 0;
6093
6094		/* ad-hoc codec */
6095		codecarg.srcfmt = &mixer->hwbuf.fmt;
6096		codecarg.dstfmt = &mixer->mixfmt;
6097		codec = NULL;
6098		if (audio_format2_is_linear(codecarg.srcfmt) &&
6099		    codecarg.srcfmt->stride == codecarg.srcfmt->precision) {
6100			switch (codecarg.srcfmt->stride) {
6101			case 8:
6102				codec = audio_linear8_to_internal;
6103				break;
6104			case 16:
6105				codec = audio_linear16_to_internal;
6106				break;
6107#if defined(AUDIO_SUPPORT_LINEAR24)
6108			case 24:
6109				codec = audio_linear24_to_internal;
6110				break;
6111#endif
6112			case 32:
6113				codec = audio_linear32_to_internal;
6114				break;
6115			}
6116		}
6117		if (codec == NULL) {
6118			TRACE(4, "unsupported hw format");
6119			/* drain hwbuf */
6120			auring_take(&mixer->hwbuf, count);
6121			return;
6122		}
6123
6124		codecarg.src = auring_headptr(&mixer->hwbuf);
6125		codecarg.dst = auring_tailptr(&tmpsrc);
6126		codecarg.count = count;
6127		codec(&codecarg);
6128		mixersrc = &tmpsrc;
6129	}
6130
6131	auring_take(&mixer->hwbuf, count);
6132	auring_push(mixersrc, count);
6133
6134	TRACE(4, "distribute");
6135
6136	/* Distribute to all tracks. */
6137	SLIST_FOREACH(f, &sc->sc_files, entry) {
6138		audio_track_t *track = f->rtrack;
6139		audio_ring_t *input;
6140
6141		if (track == NULL)
6142			continue;
6143
6144		if (track->is_pause) {
6145			TRACET(4, track, "skip; paused");
6146			continue;
6147		}
6148
6149		if (audio_track_lock_tryenter(track) == false) {
6150			TRACET(4, track, "skip; in use");
6151			continue;
6152		}
6153
6154		/*
6155		 * If the track buffer has less than one block of free space,
6156		 * make one block free.
6157		 */
6158		input = track->input;
6159		if (input->capacity - input->used < mixer->frames_per_block) {
6160			int drops = mixer->frames_per_block -
6161			    (input->capacity - input->used);
6162			track->dropframes += drops;
6163			TRACET(4, track, "drop %d frames: inp=%d/%d/%d",
6164			    drops,
6165			    input->head, input->used, input->capacity);
6166			auring_take(input, drops);
6167		}
6168
6169		KASSERTMSG(auring_tail(input) % mixer->frames_per_block == 0,
6170		    "inputtail=%d mixer->frames_per_block=%d",
6171		    auring_tail(input), mixer->frames_per_block);
6172		memcpy(auring_tailptr_aint(input),
6173		    auring_headptr_aint(mixersrc),
6174		    bytes);
6175		auring_push(input, count);
6176
6177		track->stamp++;
6178
6179		audio_track_lock_exit(track);
6180	}
6181
6182	auring_take(mixersrc, count);
6183}
6184
6185/*
6186 * Input one block from HW to hwbuf.
6187 * Must be called with sc_intr_lock held.
6188 */
6189static void
6190audio_rmixer_input(struct audio_softc *sc)
6191{
6192	audio_trackmixer_t *mixer;
6193	audio_params_t params;
6194	void *start;
6195	void *end;
6196	int blksize;
6197	int error;
6198
6199	mixer = sc->sc_rmixer;
6200	blksize = frametobyte(&mixer->hwbuf.fmt, mixer->frames_per_block);
6201
6202	if (sc->hw_if->trigger_input) {
6203		/* trigger (at once) */
6204		if (!sc->sc_rbusy) {
6205			start = mixer->hwbuf.mem;
6206			end = (uint8_t *)start + auring_bytelen(&mixer->hwbuf);
6207			params = format2_to_params(&mixer->hwbuf.fmt);
6208
6209			error = sc->hw_if->trigger_input(sc->hw_hdl,
6210			    start, end, blksize, audio_rintr, sc, &params);
6211			if (error) {
6212				audio_printf(sc,
6213				    "trigger_input failed: errno=%d\n",
6214				    error);
6215				return;
6216			}
6217		}
6218	} else {
6219		/* start (everytime) */
6220		start = auring_tailptr(&mixer->hwbuf);
6221
6222		error = sc->hw_if->start_input(sc->hw_hdl,
6223		    start, blksize, audio_rintr, sc);
6224		if (error) {
6225			audio_printf(sc,
6226			    "start_input failed: errno=%d\n", error);
6227			return;
6228		}
6229	}
6230}
6231
6232/*
6233 * This is an interrupt handler for recording.
6234 * It is called with sc_intr_lock.
6235 *
6236 * It is usually called from hardware interrupt.  However, note that
6237 * for some drivers (e.g. uaudio) it is called from software interrupt.
6238 */
6239static void
6240audio_rintr(void *arg)
6241{
6242	struct audio_softc *sc;
6243	audio_trackmixer_t *mixer;
6244
6245	sc = arg;
6246	KASSERT(mutex_owned(sc->sc_intr_lock));
6247
6248	if (sc->sc_dying)
6249		return;
6250	if (sc->sc_rbusy == false) {
6251#if defined(DIAGNOSTIC)
6252		audio_printf(sc, "DIAGNOSTIC: %s raised stray interrupt\n",
6253		    device_xname(sc->hw_dev));
6254#endif
6255		return;
6256	}
6257
6258	mixer = sc->sc_rmixer;
6259	mixer->hw_complete_counter += mixer->frames_per_block;
6260	mixer->hwseq++;
6261
6262	auring_push(&mixer->hwbuf, mixer->frames_per_block);
6263
6264	TRACE(4,
6265	    "HW_INT ++hwseq=%" PRIu64 " cmplcnt=%" PRIu64 " hwbuf=%d/%d/%d",
6266	    mixer->hwseq, mixer->hw_complete_counter,
6267	    mixer->hwbuf.head, mixer->hwbuf.used, mixer->hwbuf.capacity);
6268
6269	/* Distrubute recorded block */
6270	audio_rmixer_process(sc);
6271
6272	/* Request next block */
6273	audio_rmixer_input(sc);
6274
6275	/*
6276	 * When this interrupt is the real hardware interrupt, disabling
6277	 * preemption here is not necessary.  But some drivers (e.g. uaudio)
6278	 * emulate it by software interrupt, so kpreempt_disable is necessary.
6279	 */
6280	kpreempt_disable();
6281	softint_schedule(mixer->sih);
6282	kpreempt_enable();
6283}
6284
6285/*
6286 * Halts playback mixer.
6287 * This function also clears related parameters, so call this function
6288 * instead of calling halt_output directly.
6289 * Must be called only if sc_pbusy is true.
6290 * Must be called with sc_lock && sc_exlock held.
6291 */
6292static int
6293audio_pmixer_halt(struct audio_softc *sc)
6294{
6295	int error;
6296
6297	TRACE(2, "called");
6298	KASSERT(mutex_owned(sc->sc_lock));
6299	KASSERT(sc->sc_exlock);
6300
6301	mutex_enter(sc->sc_intr_lock);
6302	error = sc->hw_if->halt_output(sc->hw_hdl);
6303
6304	/* Halts anyway even if some error has occurred. */
6305	sc->sc_pbusy = false;
6306	sc->sc_pmixer->hwbuf.head = 0;
6307	sc->sc_pmixer->hwbuf.used = 0;
6308	sc->sc_pmixer->mixseq = 0;
6309	sc->sc_pmixer->hwseq = 0;
6310	mutex_exit(sc->sc_intr_lock);
6311
6312	return error;
6313}
6314
6315/*
6316 * Halts recording mixer.
6317 * This function also clears related parameters, so call this function
6318 * instead of calling halt_input directly.
6319 * Must be called only if sc_rbusy is true.
6320 * Must be called with sc_lock && sc_exlock held.
6321 */
6322static int
6323audio_rmixer_halt(struct audio_softc *sc)
6324{
6325	int error;
6326
6327	TRACE(2, "called");
6328	KASSERT(mutex_owned(sc->sc_lock));
6329	KASSERT(sc->sc_exlock);
6330
6331	mutex_enter(sc->sc_intr_lock);
6332	error = sc->hw_if->halt_input(sc->hw_hdl);
6333
6334	/* Halts anyway even if some error has occurred. */
6335	sc->sc_rbusy = false;
6336	sc->sc_rmixer->hwbuf.head = 0;
6337	sc->sc_rmixer->hwbuf.used = 0;
6338	sc->sc_rmixer->mixseq = 0;
6339	sc->sc_rmixer->hwseq = 0;
6340	mutex_exit(sc->sc_intr_lock);
6341
6342	return error;
6343}
6344
6345/*
6346 * Flush this track.
6347 * Halts all operations, clears all buffers, reset error counters.
6348 * XXX I'm not sure...
6349 */
6350static void
6351audio_track_clear(struct audio_softc *sc, audio_track_t *track)
6352{
6353
6354	KASSERT(track);
6355	TRACET(3, track, "clear");
6356
6357	audio_track_lock_enter(track);
6358
6359	/* Clear all internal parameters. */
6360	track->usrbuf.used = 0;
6361	track->usrbuf.head = 0;
6362	if (track->codec.filter) {
6363		track->codec.srcbuf.used = 0;
6364		track->codec.srcbuf.head = 0;
6365	}
6366	if (track->chvol.filter) {
6367		track->chvol.srcbuf.used = 0;
6368		track->chvol.srcbuf.head = 0;
6369	}
6370	if (track->chmix.filter) {
6371		track->chmix.srcbuf.used = 0;
6372		track->chmix.srcbuf.head = 0;
6373	}
6374	if (track->freq.filter) {
6375		track->freq.srcbuf.used = 0;
6376		track->freq.srcbuf.head = 0;
6377		if (track->freq_step < 65536)
6378			track->freq_current = 65536;
6379		else
6380			track->freq_current = 0;
6381		memset(track->freq_prev, 0, sizeof(track->freq_prev));
6382		memset(track->freq_curr, 0, sizeof(track->freq_curr));
6383	}
6384	/* Clear buffer, then operation halts naturally. */
6385	track->outbuf.used = 0;
6386
6387	/* Clear counters. */
6388	track->stamp = 0;
6389	track->last_stamp = 0;
6390	track->dropframes = 0;
6391
6392	audio_track_lock_exit(track);
6393}
6394
6395/*
6396 * Drain the track.
6397 * track must be present and for playback.
6398 * If successful, it returns 0.  Otherwise returns errno.
6399 * Must be called with sc_lock held.
6400 */
6401static int
6402audio_track_drain(struct audio_softc *sc, audio_track_t *track)
6403{
6404	audio_trackmixer_t *mixer;
6405	int done;
6406	int error;
6407
6408	KASSERT(track);
6409	TRACET(3, track, "start");
6410	mixer = track->mixer;
6411	KASSERT(mutex_owned(sc->sc_lock));
6412
6413	/* Ignore them if pause. */
6414	if (track->is_pause) {
6415		TRACET(3, track, "pause -> clear");
6416		track->pstate = AUDIO_STATE_CLEAR;
6417	}
6418	/* Terminate early here if there is no data in the track. */
6419	if (track->pstate == AUDIO_STATE_CLEAR) {
6420		TRACET(3, track, "no need to drain");
6421		return 0;
6422	}
6423	track->pstate = AUDIO_STATE_DRAINING;
6424
6425	for (;;) {
6426		/* I want to display it before condition evaluation. */
6427		TRACET(3, track, "pid=%d.%d trkseq=%d hwseq=%d out=%d/%d/%d",
6428		    (int)curproc->p_pid, (int)curlwp->l_lid,
6429		    (int)track->seq, (int)mixer->hwseq,
6430		    track->outbuf.head, track->outbuf.used,
6431		    track->outbuf.capacity);
6432
6433		/* Condition to terminate */
6434		audio_track_lock_enter(track);
6435		done = (track->usrbuf.used < frametobyte(&track->inputfmt, 1) &&
6436		    track->outbuf.used == 0 &&
6437		    track->seq <= mixer->hwseq);
6438		audio_track_lock_exit(track);
6439		if (done)
6440			break;
6441
6442		TRACET(3, track, "sleep");
6443		error = audio_track_waitio(sc, track, "audio_drain");
6444		if (error)
6445			return error;
6446
6447		/* XXX call audio_track_play here ? */
6448	}
6449
6450	track->pstate = AUDIO_STATE_CLEAR;
6451	TRACET(3, track, "done");
6452	return 0;
6453}
6454
6455/*
6456 * Send signal to process.
6457 * This is intended to be called only from audio_softintr_{rd,wr}.
6458 * Must be called without sc_intr_lock held.
6459 */
6460static inline void
6461audio_psignal(struct audio_softc *sc, pid_t pid, int signum)
6462{
6463	proc_t *p;
6464
6465	KASSERT(pid != 0);
6466
6467	/*
6468	 * psignal() must be called without spin lock held.
6469	 */
6470
6471	mutex_enter(&proc_lock);
6472	p = proc_find(pid);
6473	if (p)
6474		psignal(p, signum);
6475	mutex_exit(&proc_lock);
6476}
6477
6478/*
6479 * This is software interrupt handler for record.
6480 * It is called from recording hardware interrupt everytime.
6481 * It does:
6482 * - Deliver SIGIO for all async processes.
6483 * - Notify to audio_read() that data has arrived.
6484 * - selnotify() for select/poll-ing processes.
6485 */
6486/*
6487 * XXX If a process issues FIOASYNC between hardware interrupt and
6488 *     software interrupt, (stray) SIGIO will be sent to the process
6489 *     despite the fact that it has not receive recorded data yet.
6490 */
6491static void
6492audio_softintr_rd(void *cookie)
6493{
6494	struct audio_softc *sc = cookie;
6495	audio_file_t *f;
6496	pid_t pid;
6497
6498	mutex_enter(sc->sc_lock);
6499
6500	SLIST_FOREACH(f, &sc->sc_files, entry) {
6501		audio_track_t *track = f->rtrack;
6502
6503		if (track == NULL)
6504			continue;
6505
6506		TRACET(4, track, "broadcast; inp=%d/%d/%d",
6507		    track->input->head,
6508		    track->input->used,
6509		    track->input->capacity);
6510
6511		pid = f->async_audio;
6512		if (pid != 0) {
6513			TRACEF(4, f, "sending SIGIO %d", pid);
6514			audio_psignal(sc, pid, SIGIO);
6515		}
6516	}
6517
6518	/* Notify that data has arrived. */
6519	selnotify(&sc->sc_rsel, 0, NOTE_SUBMIT);
6520	cv_broadcast(&sc->sc_rmixer->outcv);
6521
6522	mutex_exit(sc->sc_lock);
6523}
6524
6525/*
6526 * This is software interrupt handler for playback.
6527 * It is called from playback hardware interrupt everytime.
6528 * It does:
6529 * - Deliver SIGIO for all async and writable (used < lowat) processes.
6530 * - Notify to audio_write() that outbuf block available.
6531 * - selnotify() for select/poll-ing processes if there are any writable
6532 *   (used < lowat) processes.  Checking each descriptor will be done by
6533 *   filt_audiowrite_event().
6534 */
6535static void
6536audio_softintr_wr(void *cookie)
6537{
6538	struct audio_softc *sc = cookie;
6539	audio_file_t *f;
6540	bool found;
6541	pid_t pid;
6542
6543	TRACE(4, "called");
6544	found = false;
6545
6546	mutex_enter(sc->sc_lock);
6547
6548	SLIST_FOREACH(f, &sc->sc_files, entry) {
6549		audio_track_t *track = f->ptrack;
6550
6551		if (track == NULL)
6552			continue;
6553
6554		TRACET(4, track, "broadcast; trkseq=%d out=%d/%d/%d",
6555		    (int)track->seq,
6556		    track->outbuf.head,
6557		    track->outbuf.used,
6558		    track->outbuf.capacity);
6559
6560		/*
6561		 * Send a signal if the process is async mode and
6562		 * used is lower than lowat.
6563		 */
6564		if (track->usrbuf.used <= track->usrbuf_usedlow &&
6565		    !track->is_pause) {
6566			/* For selnotify */
6567			found = true;
6568			/* For SIGIO */
6569			pid = f->async_audio;
6570			if (pid != 0) {
6571				TRACEF(4, f, "sending SIGIO %d", pid);
6572				audio_psignal(sc, pid, SIGIO);
6573			}
6574		}
6575	}
6576
6577	/*
6578	 * Notify for select/poll when someone become writable.
6579	 * It needs sc_lock (and not sc_intr_lock).
6580	 */
6581	if (found) {
6582		TRACE(4, "selnotify");
6583		selnotify(&sc->sc_wsel, 0, NOTE_SUBMIT);
6584	}
6585
6586	/* Notify to audio_write() that outbuf available. */
6587	cv_broadcast(&sc->sc_pmixer->outcv);
6588
6589	mutex_exit(sc->sc_lock);
6590}
6591
6592/*
6593 * Check (and convert) the format *p came from userland.
6594 * If successful, it writes back the converted format to *p if necessary and
6595 * returns 0.  Otherwise returns errno (*p may be changed even in this case).
6596 */
6597static int
6598audio_check_params(audio_format2_t *p)
6599{
6600
6601	/*
6602	 * Convert obsolete AUDIO_ENCODING_PCM encodings.
6603	 *
6604	 * AUDIO_ENCODING_PCM16 == AUDIO_ENCODING_LINEAR
6605	 * So, it's always signed, as in SunOS.
6606	 *
6607	 * AUDIO_ENCODING_PCM8 == AUDIO_ENCODING_LINEAR8
6608	 * So, it's always unsigned, as in SunOS.
6609	 */
6610	if (p->encoding == AUDIO_ENCODING_PCM16) {
6611		p->encoding = AUDIO_ENCODING_SLINEAR;
6612	} else if (p->encoding == AUDIO_ENCODING_PCM8) {
6613		if (p->precision == 8)
6614			p->encoding = AUDIO_ENCODING_ULINEAR;
6615		else
6616			return EINVAL;
6617	}
6618
6619	/*
6620	 * Convert obsoleted AUDIO_ENCODING_[SU]LINEAR without endianness
6621	 * suffix.
6622	 */
6623	if (p->encoding == AUDIO_ENCODING_SLINEAR)
6624		p->encoding = AUDIO_ENCODING_SLINEAR_NE;
6625	if (p->encoding == AUDIO_ENCODING_ULINEAR)
6626		p->encoding = AUDIO_ENCODING_ULINEAR_NE;
6627
6628	switch (p->encoding) {
6629	case AUDIO_ENCODING_ULAW:
6630	case AUDIO_ENCODING_ALAW:
6631		if (p->precision != 8)
6632			return EINVAL;
6633		break;
6634	case AUDIO_ENCODING_ADPCM:
6635		if (p->precision != 4 && p->precision != 8)
6636			return EINVAL;
6637		break;
6638	case AUDIO_ENCODING_SLINEAR_LE:
6639	case AUDIO_ENCODING_SLINEAR_BE:
6640	case AUDIO_ENCODING_ULINEAR_LE:
6641	case AUDIO_ENCODING_ULINEAR_BE:
6642		if (p->precision !=  8 && p->precision != 16 &&
6643		    p->precision != 24 && p->precision != 32)
6644			return EINVAL;
6645
6646		/* 8bit format does not have endianness. */
6647		if (p->precision == 8) {
6648			if (p->encoding == AUDIO_ENCODING_SLINEAR_OE)
6649				p->encoding = AUDIO_ENCODING_SLINEAR_NE;
6650			if (p->encoding == AUDIO_ENCODING_ULINEAR_OE)
6651				p->encoding = AUDIO_ENCODING_ULINEAR_NE;
6652		}
6653
6654		if (p->precision > p->stride)
6655			return EINVAL;
6656		break;
6657	case AUDIO_ENCODING_MPEG_L1_STREAM:
6658	case AUDIO_ENCODING_MPEG_L1_PACKETS:
6659	case AUDIO_ENCODING_MPEG_L1_SYSTEM:
6660	case AUDIO_ENCODING_MPEG_L2_STREAM:
6661	case AUDIO_ENCODING_MPEG_L2_PACKETS:
6662	case AUDIO_ENCODING_MPEG_L2_SYSTEM:
6663	case AUDIO_ENCODING_AC3:
6664		break;
6665	default:
6666		return EINVAL;
6667	}
6668
6669	/* sanity check # of channels*/
6670	if (p->channels < 1 || p->channels > AUDIO_MAX_CHANNELS)
6671		return EINVAL;
6672
6673	return 0;
6674}
6675
6676/*
6677 * Initialize playback and record mixers.
6678 * mode (AUMODE_{PLAY,RECORD}) indicates the mixer to be initialized.
6679 * phwfmt and rhwfmt indicate the hardware format.  pfil and rfil indicate
6680 * the filter registration information.  These four must not be NULL.
6681 * If successful returns 0.  Otherwise returns errno.
6682 * Must be called with sc_exlock held and without sc_lock held.
6683 * Must not be called if there are any tracks.
6684 * Caller should check that the initialization succeed by whether
6685 * sc_[pr]mixer is not NULL.
6686 */
6687static int
6688audio_mixers_init(struct audio_softc *sc, int mode,
6689	const audio_format2_t *phwfmt, const audio_format2_t *rhwfmt,
6690	const audio_filter_reg_t *pfil, const audio_filter_reg_t *rfil)
6691{
6692	int error;
6693
6694	KASSERT(phwfmt != NULL);
6695	KASSERT(rhwfmt != NULL);
6696	KASSERT(pfil != NULL);
6697	KASSERT(rfil != NULL);
6698	KASSERT(sc->sc_exlock);
6699
6700	if ((mode & AUMODE_PLAY)) {
6701		if (sc->sc_pmixer == NULL) {
6702			sc->sc_pmixer = kmem_zalloc(sizeof(*sc->sc_pmixer),
6703			    KM_SLEEP);
6704		} else {
6705			/* destroy() doesn't free memory. */
6706			audio_mixer_destroy(sc, sc->sc_pmixer);
6707			memset(sc->sc_pmixer, 0, sizeof(*sc->sc_pmixer));
6708		}
6709		error = audio_mixer_init(sc, AUMODE_PLAY, phwfmt, pfil);
6710		if (error) {
6711			/* audio_mixer_init already displayed error code */
6712			audio_printf(sc, "configuring playback mode failed\n");
6713			kmem_free(sc->sc_pmixer, sizeof(*sc->sc_pmixer));
6714			sc->sc_pmixer = NULL;
6715			return error;
6716		}
6717	}
6718	if ((mode & AUMODE_RECORD)) {
6719		if (sc->sc_rmixer == NULL) {
6720			sc->sc_rmixer = kmem_zalloc(sizeof(*sc->sc_rmixer),
6721			    KM_SLEEP);
6722		} else {
6723			/* destroy() doesn't free memory. */
6724			audio_mixer_destroy(sc, sc->sc_rmixer);
6725			memset(sc->sc_rmixer, 0, sizeof(*sc->sc_rmixer));
6726		}
6727		error = audio_mixer_init(sc, AUMODE_RECORD, rhwfmt, rfil);
6728		if (error) {
6729			/* audio_mixer_init already displayed error code */
6730			audio_printf(sc, "configuring record mode failed\n");
6731			kmem_free(sc->sc_rmixer, sizeof(*sc->sc_rmixer));
6732			sc->sc_rmixer = NULL;
6733			return error;
6734		}
6735	}
6736
6737	return 0;
6738}
6739
6740/*
6741 * Select a frequency.
6742 * Prioritize 48kHz and 44.1kHz.  Otherwise choose the highest one.
6743 * XXX Better algorithm?
6744 */
6745static int
6746audio_select_freq(const struct audio_format *fmt)
6747{
6748	int freq;
6749	int high;
6750	int low;
6751	int j;
6752
6753	if (fmt->frequency_type == 0) {
6754		low = fmt->frequency[0];
6755		high = fmt->frequency[1];
6756		freq = 48000;
6757		if (low <= freq && freq <= high) {
6758			return freq;
6759		}
6760		freq = 44100;
6761		if (low <= freq && freq <= high) {
6762			return freq;
6763		}
6764		return high;
6765	} else {
6766		for (j = 0; j < fmt->frequency_type; j++) {
6767			if (fmt->frequency[j] == 48000) {
6768				return fmt->frequency[j];
6769			}
6770		}
6771		high = 0;
6772		for (j = 0; j < fmt->frequency_type; j++) {
6773			if (fmt->frequency[j] == 44100) {
6774				return fmt->frequency[j];
6775			}
6776			if (fmt->frequency[j] > high) {
6777				high = fmt->frequency[j];
6778			}
6779		}
6780		return high;
6781	}
6782}
6783
6784/*
6785 * Choose the most preferred hardware format.
6786 * If successful, it will store the chosen format into *cand and return 0.
6787 * Otherwise, return errno.
6788 * Must be called without sc_lock held.
6789 */
6790static int
6791audio_hw_probe(struct audio_softc *sc, audio_format2_t *cand, int mode)
6792{
6793	audio_format_query_t query;
6794	int cand_score;
6795	int score;
6796	int i;
6797	int error;
6798
6799	/*
6800	 * Score each formats and choose the highest one.
6801	 *
6802	 *                 +---- priority(0-3)
6803	 *                 |+--- encoding/precision
6804	 *                 ||+-- channels
6805	 * score = 0x000000PEC
6806	 */
6807
6808	cand_score = 0;
6809	for (i = 0; ; i++) {
6810		memset(&query, 0, sizeof(query));
6811		query.index = i;
6812
6813		mutex_enter(sc->sc_lock);
6814		error = sc->hw_if->query_format(sc->hw_hdl, &query);
6815		mutex_exit(sc->sc_lock);
6816		if (error == EINVAL)
6817			break;
6818		if (error)
6819			return error;
6820
6821#if defined(AUDIO_DEBUG)
6822		DPRINTF(1, "fmt[%d] %c%c pri=%d %s,%d/%dbit,%dch,", i,
6823		    (query.fmt.mode & AUMODE_PLAY)   ? 'P' : '-',
6824		    (query.fmt.mode & AUMODE_RECORD) ? 'R' : '-',
6825		    query.fmt.priority,
6826		    audio_encoding_name(query.fmt.encoding),
6827		    query.fmt.validbits,
6828		    query.fmt.precision,
6829		    query.fmt.channels);
6830		if (query.fmt.frequency_type == 0) {
6831			DPRINTF(1, "{%d-%d",
6832			    query.fmt.frequency[0], query.fmt.frequency[1]);
6833		} else {
6834			int j;
6835			for (j = 0; j < query.fmt.frequency_type; j++) {
6836				DPRINTF(1, "%c%d",
6837				    (j == 0) ? '{' : ',',
6838				    query.fmt.frequency[j]);
6839			}
6840		}
6841		DPRINTF(1, "}\n");
6842#endif
6843
6844		if ((query.fmt.mode & mode) == 0) {
6845			DPRINTF(1, "fmt[%d] skip; mode not match %d\n", i,
6846			    mode);
6847			continue;
6848		}
6849
6850		if (query.fmt.priority < 0) {
6851			DPRINTF(1, "fmt[%d] skip; unsupported encoding\n", i);
6852			continue;
6853		}
6854
6855		/* Score */
6856		score = (query.fmt.priority & 3) * 0x100;
6857		if (query.fmt.encoding == AUDIO_ENCODING_SLINEAR_NE &&
6858		    query.fmt.validbits == AUDIO_INTERNAL_BITS &&
6859		    query.fmt.precision == AUDIO_INTERNAL_BITS) {
6860			score += 0x20;
6861		} else if (query.fmt.encoding == AUDIO_ENCODING_SLINEAR_OE &&
6862		    query.fmt.validbits == AUDIO_INTERNAL_BITS &&
6863		    query.fmt.precision == AUDIO_INTERNAL_BITS) {
6864			score += 0x10;
6865		}
6866
6867		/* Do not prefer surround formats */
6868		if (query.fmt.channels <= 2)
6869			score += query.fmt.channels;
6870
6871		if (score < cand_score) {
6872			DPRINTF(1, "fmt[%d] skip; score 0x%x < 0x%x\n", i,
6873			    score, cand_score);
6874			continue;
6875		}
6876
6877		/* Update candidate */
6878		cand_score = score;
6879		cand->encoding    = query.fmt.encoding;
6880		cand->precision   = query.fmt.validbits;
6881		cand->stride      = query.fmt.precision;
6882		cand->channels    = query.fmt.channels;
6883		cand->sample_rate = audio_select_freq(&query.fmt);
6884		DPRINTF(1, "fmt[%d] candidate (score=0x%x)"
6885		    " pri=%d %s,%d/%d,%dch,%dHz\n", i,
6886		    cand_score, query.fmt.priority,
6887		    audio_encoding_name(query.fmt.encoding),
6888		    cand->precision, cand->stride,
6889		    cand->channels, cand->sample_rate);
6890	}
6891
6892	if (cand_score == 0) {
6893		DPRINTF(1, "%s no fmt\n", __func__);
6894		return ENXIO;
6895	}
6896	DPRINTF(1, "%s selected: %s,%d/%d,%dch,%dHz\n", __func__,
6897	    audio_encoding_name(cand->encoding),
6898	    cand->precision, cand->stride, cand->channels, cand->sample_rate);
6899	return 0;
6900}
6901
6902/*
6903 * Validate fmt with query_format.
6904 * If fmt is included in the result of query_format, returns 0.
6905 * Otherwise returns EINVAL.
6906 * Must be called without sc_lock held.
6907 */
6908static int
6909audio_hw_validate_format(struct audio_softc *sc, int mode,
6910	const audio_format2_t *fmt)
6911{
6912	audio_format_query_t query;
6913	struct audio_format *q;
6914	int index;
6915	int error;
6916	int j;
6917
6918	for (index = 0; ; index++) {
6919		query.index = index;
6920		mutex_enter(sc->sc_lock);
6921		error = sc->hw_if->query_format(sc->hw_hdl, &query);
6922		mutex_exit(sc->sc_lock);
6923		if (error == EINVAL)
6924			break;
6925		if (error)
6926			return error;
6927
6928		q = &query.fmt;
6929		/*
6930		 * Note that fmt is audio_format2_t (precision/stride) but
6931		 * q is audio_format_t (validbits/precision).
6932		 */
6933		if ((q->mode & mode) == 0) {
6934			continue;
6935		}
6936		if (fmt->encoding != q->encoding) {
6937			continue;
6938		}
6939		if (fmt->precision != q->validbits) {
6940			continue;
6941		}
6942		if (fmt->stride != q->precision) {
6943			continue;
6944		}
6945		if (fmt->channels != q->channels) {
6946			continue;
6947		}
6948		if (q->frequency_type == 0) {
6949			if (fmt->sample_rate < q->frequency[0] ||
6950			    fmt->sample_rate > q->frequency[1]) {
6951				continue;
6952			}
6953		} else {
6954			for (j = 0; j < q->frequency_type; j++) {
6955				if (fmt->sample_rate == q->frequency[j])
6956					break;
6957			}
6958			if (j == query.fmt.frequency_type) {
6959				continue;
6960			}
6961		}
6962
6963		/* Matched. */
6964		return 0;
6965	}
6966
6967	return EINVAL;
6968}
6969
6970/*
6971 * Set track mixer's format depending on ai->mode.
6972 * If AUMODE_PLAY is set in ai->mode, it set up the playback mixer
6973 * with ai.play.*.
6974 * If AUMODE_RECORD is set in ai->mode, it set up the recording mixer
6975 * with ai.record.*.
6976 * All other fields in ai are ignored.
6977 * If successful returns 0.  Otherwise returns errno.
6978 * This function does not roll back even if it fails.
6979 * Must be called with sc_exlock held and without sc_lock held.
6980 */
6981static int
6982audio_mixers_set_format(struct audio_softc *sc, const struct audio_info *ai)
6983{
6984	audio_format2_t phwfmt;
6985	audio_format2_t rhwfmt;
6986	audio_filter_reg_t pfil;
6987	audio_filter_reg_t rfil;
6988	int mode;
6989	int error;
6990
6991	KASSERT(sc->sc_exlock);
6992
6993	/*
6994	 * Even when setting either one of playback and recording,
6995	 * both must be halted.
6996	 */
6997	if (sc->sc_popens + sc->sc_ropens > 0)
6998		return EBUSY;
6999
7000	if (!SPECIFIED(ai->mode) || ai->mode == 0)
7001		return ENOTTY;
7002
7003	mode = ai->mode;
7004	if ((mode & AUMODE_PLAY)) {
7005		phwfmt.encoding    = ai->play.encoding;
7006		phwfmt.precision   = ai->play.precision;
7007		phwfmt.stride      = ai->play.precision;
7008		phwfmt.channels    = ai->play.channels;
7009		phwfmt.sample_rate = ai->play.sample_rate;
7010	}
7011	if ((mode & AUMODE_RECORD)) {
7012		rhwfmt.encoding    = ai->record.encoding;
7013		rhwfmt.precision   = ai->record.precision;
7014		rhwfmt.stride      = ai->record.precision;
7015		rhwfmt.channels    = ai->record.channels;
7016		rhwfmt.sample_rate = ai->record.sample_rate;
7017	}
7018
7019	/* On non-independent devices, use the same format for both. */
7020	if ((sc->sc_props & AUDIO_PROP_INDEPENDENT) == 0) {
7021		if (mode == AUMODE_RECORD) {
7022			phwfmt = rhwfmt;
7023		} else {
7024			rhwfmt = phwfmt;
7025		}
7026		mode = AUMODE_PLAY | AUMODE_RECORD;
7027	}
7028
7029	/* Then, unset the direction not exist on the hardware. */
7030	if ((sc->sc_props & AUDIO_PROP_PLAYBACK) == 0)
7031		mode &= ~AUMODE_PLAY;
7032	if ((sc->sc_props & AUDIO_PROP_CAPTURE) == 0)
7033		mode &= ~AUMODE_RECORD;
7034
7035	/* debug */
7036	if ((mode & AUMODE_PLAY)) {
7037		TRACE(1, "play=%s/%d/%d/%dch/%dHz",
7038		    audio_encoding_name(phwfmt.encoding),
7039		    phwfmt.precision,
7040		    phwfmt.stride,
7041		    phwfmt.channels,
7042		    phwfmt.sample_rate);
7043	}
7044	if ((mode & AUMODE_RECORD)) {
7045		TRACE(1, "rec =%s/%d/%d/%dch/%dHz",
7046		    audio_encoding_name(rhwfmt.encoding),
7047		    rhwfmt.precision,
7048		    rhwfmt.stride,
7049		    rhwfmt.channels,
7050		    rhwfmt.sample_rate);
7051	}
7052
7053	/* Check the format */
7054	if ((mode & AUMODE_PLAY)) {
7055		if (audio_hw_validate_format(sc, AUMODE_PLAY, &phwfmt)) {
7056			TRACE(1, "invalid format");
7057			return EINVAL;
7058		}
7059	}
7060	if ((mode & AUMODE_RECORD)) {
7061		if (audio_hw_validate_format(sc, AUMODE_RECORD, &rhwfmt)) {
7062			TRACE(1, "invalid format");
7063			return EINVAL;
7064		}
7065	}
7066
7067	/* Configure the mixers. */
7068	memset(&pfil, 0, sizeof(pfil));
7069	memset(&rfil, 0, sizeof(rfil));
7070	error = audio_hw_set_format(sc, mode, &phwfmt, &rhwfmt, &pfil, &rfil);
7071	if (error)
7072		return error;
7073
7074	error = audio_mixers_init(sc, mode, &phwfmt, &rhwfmt, &pfil, &rfil);
7075	if (error)
7076		return error;
7077
7078	/*
7079	 * Reinitialize the sticky parameters for /dev/sound.
7080	 * If the number of the hardware channels becomes less than the number
7081	 * of channels that sticky parameters remember, subsequent /dev/sound
7082	 * open will fail.  To prevent this, reinitialize the sticky
7083	 * parameters whenever the hardware format is changed.
7084	 */
7085	sc->sc_sound_pparams = params_to_format2(&audio_default);
7086	sc->sc_sound_rparams = params_to_format2(&audio_default);
7087	sc->sc_sound_ppause = false;
7088	sc->sc_sound_rpause = false;
7089
7090	return 0;
7091}
7092
7093/*
7094 * Store current mixers format into *ai.
7095 * Must be called with sc_exlock held.
7096 */
7097static void
7098audio_mixers_get_format(struct audio_softc *sc, struct audio_info *ai)
7099{
7100
7101	KASSERT(sc->sc_exlock);
7102
7103	/*
7104	 * There is no stride information in audio_info but it doesn't matter.
7105	 * trackmixer always treats stride and precision as the same.
7106	 */
7107	AUDIO_INITINFO(ai);
7108	ai->mode = 0;
7109	if (sc->sc_pmixer) {
7110		audio_format2_t *fmt = &sc->sc_pmixer->track_fmt;
7111		ai->play.encoding    = fmt->encoding;
7112		ai->play.precision   = fmt->precision;
7113		ai->play.channels    = fmt->channels;
7114		ai->play.sample_rate = fmt->sample_rate;
7115		ai->mode |= AUMODE_PLAY;
7116	}
7117	if (sc->sc_rmixer) {
7118		audio_format2_t *fmt = &sc->sc_rmixer->track_fmt;
7119		ai->record.encoding    = fmt->encoding;
7120		ai->record.precision   = fmt->precision;
7121		ai->record.channels    = fmt->channels;
7122		ai->record.sample_rate = fmt->sample_rate;
7123		ai->mode |= AUMODE_RECORD;
7124	}
7125}
7126
7127/*
7128 * audio_info details:
7129 *
7130 * ai.{play,record}.sample_rate		(R/W)
7131 * ai.{play,record}.encoding		(R/W)
7132 * ai.{play,record}.precision		(R/W)
7133 * ai.{play,record}.channels		(R/W)
7134 *	These specify the playback or recording format.
7135 *	Ignore members within an inactive track.
7136 *
7137 * ai.mode				(R/W)
7138 *	It specifies the playback or recording mode, AUMODE_*.
7139 *	Currently, a mode change operation by ai.mode after opening is
7140 *	prohibited.  In addition, AUMODE_PLAY_ALL no longer makes sense.
7141 *	However, it's possible to get or to set for backward compatibility.
7142 *
7143 * ai.{hiwat,lowat}			(R/W)
7144 *	These specify the high water mark and low water mark for playback
7145 *	track.  The unit is block.
7146 *
7147 * ai.{play,record}.gain		(R/W)
7148 *	It specifies the HW mixer volume in 0-255.
7149 *	It is historical reason that the gain is connected to HW mixer.
7150 *
7151 * ai.{play,record}.balance		(R/W)
7152 *	It specifies the left-right balance of HW mixer in 0-64.
7153 *	32 means the center.
7154 *	It is historical reason that the balance is connected to HW mixer.
7155 *
7156 * ai.{play,record}.port		(R/W)
7157 *	It specifies the input/output port of HW mixer.
7158 *
7159 * ai.monitor_gain			(R/W)
7160 *	It specifies the recording monitor gain(?) of HW mixer.
7161 *
7162 * ai.{play,record}.pause		(R/W)
7163 *	Non-zero means the track is paused.
7164 *
7165 * ai.play.seek				(R/-)
7166 *	It indicates the number of bytes written but not processed.
7167 * ai.record.seek			(R/-)
7168 *	It indicates the number of bytes to be able to read.
7169 *
7170 * ai.{play,record}.avail_ports		(R/-)
7171 *	Mixer info.
7172 *
7173 * ai.{play,record}.buffer_size		(R/-)
7174 *	It indicates the buffer size in bytes.  Internally it means usrbuf.
7175 *
7176 * ai.{play,record}.samples		(R/-)
7177 *	It indicates the total number of bytes played or recorded.
7178 *
7179 * ai.{play,record}.eof			(R/-)
7180 *	It indicates the number of times reached EOF(?).
7181 *
7182 * ai.{play,record}.error		(R/-)
7183 *	Non-zero indicates overflow/underflow has occurred.
7184 *
7185 * ai.{play,record}.waiting		(R/-)
7186 *	Non-zero indicates that other process waits to open.
7187 *	It will never happen anymore.
7188 *
7189 * ai.{play,record}.open		(R/-)
7190 *	Non-zero indicates the direction is opened by this process(?).
7191 *	XXX Is this better to indicate that "the device is opened by
7192 *	at least one process"?
7193 *
7194 * ai.{play,record}.active		(R/-)
7195 *	Non-zero indicates that I/O is currently active.
7196 *
7197 * ai.blocksize				(R/-)
7198 *	It indicates the block size in bytes.
7199 *	XXX The blocksize of playback and recording may be different.
7200 */
7201
7202/*
7203 * Pause consideration:
7204 *
7205 * Pausing/unpausing never affect [pr]mixer.  This single rule makes
7206 * operation simple.  Note that playback and recording are asymmetric.
7207 *
7208 * For playback,
7209 *  1. Any playback open doesn't start pmixer regardless of initial pause
7210 *     state of this track.
7211 *  2. The first write access among playback tracks only starts pmixer
7212 *     regardless of this track's pause state.
7213 *  3. Even a pause of the last playback track doesn't stop pmixer.
7214 *  4. The last close of all playback tracks only stops pmixer.
7215 *
7216 * For recording,
7217 *  1. The first recording open only starts rmixer regardless of initial
7218 *     pause state of this track.
7219 *  2. Even a pause of the last track doesn't stop rmixer.
7220 *  3. The last close of all recording tracks only stops rmixer.
7221 */
7222
7223/*
7224 * Set both track's parameters within a file depending on ai.
7225 * Update sc_sound_[pr]* if set.
7226 * Must be called with sc_exlock held and without sc_lock held.
7227 */
7228static int
7229audio_file_setinfo(struct audio_softc *sc, audio_file_t *file,
7230	const struct audio_info *ai)
7231{
7232	const struct audio_prinfo *pi;
7233	const struct audio_prinfo *ri;
7234	audio_track_t *ptrack;
7235	audio_track_t *rtrack;
7236	audio_format2_t pfmt;
7237	audio_format2_t rfmt;
7238	int pchanges;
7239	int rchanges;
7240	int mode;
7241	struct audio_info saved_ai;
7242	audio_format2_t saved_pfmt;
7243	audio_format2_t saved_rfmt;
7244	int error;
7245
7246	KASSERT(sc->sc_exlock);
7247
7248	pi = &ai->play;
7249	ri = &ai->record;
7250	pchanges = 0;
7251	rchanges = 0;
7252
7253	ptrack = file->ptrack;
7254	rtrack = file->rtrack;
7255
7256#if defined(AUDIO_DEBUG)
7257	if (audiodebug >= 2) {
7258		char buf[256];
7259		char p[64];
7260		int buflen;
7261		int plen;
7262#define SPRINTF(var, fmt...) do {	\
7263	var##len += snprintf(var + var##len, sizeof(var) - var##len, fmt); \
7264} while (0)
7265
7266		buflen = 0;
7267		plen = 0;
7268		if (SPECIFIED(pi->encoding))
7269			SPRINTF(p, "/%s", audio_encoding_name(pi->encoding));
7270		if (SPECIFIED(pi->precision))
7271			SPRINTF(p, "/%dbit", pi->precision);
7272		if (SPECIFIED(pi->channels))
7273			SPRINTF(p, "/%dch", pi->channels);
7274		if (SPECIFIED(pi->sample_rate))
7275			SPRINTF(p, "/%dHz", pi->sample_rate);
7276		if (plen > 0)
7277			SPRINTF(buf, ",play.param=%s", p + 1);
7278
7279		plen = 0;
7280		if (SPECIFIED(ri->encoding))
7281			SPRINTF(p, "/%s", audio_encoding_name(ri->encoding));
7282		if (SPECIFIED(ri->precision))
7283			SPRINTF(p, "/%dbit", ri->precision);
7284		if (SPECIFIED(ri->channels))
7285			SPRINTF(p, "/%dch", ri->channels);
7286		if (SPECIFIED(ri->sample_rate))
7287			SPRINTF(p, "/%dHz", ri->sample_rate);
7288		if (plen > 0)
7289			SPRINTF(buf, ",record.param=%s", p + 1);
7290
7291		if (SPECIFIED(ai->mode))
7292			SPRINTF(buf, ",mode=%d", ai->mode);
7293		if (SPECIFIED(ai->hiwat))
7294			SPRINTF(buf, ",hiwat=%d", ai->hiwat);
7295		if (SPECIFIED(ai->lowat))
7296			SPRINTF(buf, ",lowat=%d", ai->lowat);
7297		if (SPECIFIED(ai->play.gain))
7298			SPRINTF(buf, ",play.gain=%d", ai->play.gain);
7299		if (SPECIFIED(ai->record.gain))
7300			SPRINTF(buf, ",record.gain=%d", ai->record.gain);
7301		if (SPECIFIED_CH(ai->play.balance))
7302			SPRINTF(buf, ",play.balance=%d", ai->play.balance);
7303		if (SPECIFIED_CH(ai->record.balance))
7304			SPRINTF(buf, ",record.balance=%d", ai->record.balance);
7305		if (SPECIFIED(ai->play.port))
7306			SPRINTF(buf, ",play.port=%d", ai->play.port);
7307		if (SPECIFIED(ai->record.port))
7308			SPRINTF(buf, ",record.port=%d", ai->record.port);
7309		if (SPECIFIED(ai->monitor_gain))
7310			SPRINTF(buf, ",monitor_gain=%d", ai->monitor_gain);
7311		if (SPECIFIED_CH(ai->play.pause))
7312			SPRINTF(buf, ",play.pause=%d", ai->play.pause);
7313		if (SPECIFIED_CH(ai->record.pause))
7314			SPRINTF(buf, ",record.pause=%d", ai->record.pause);
7315
7316		if (buflen > 0)
7317			TRACE(2, "specified %s", buf + 1);
7318	}
7319#endif
7320
7321	AUDIO_INITINFO(&saved_ai);
7322	/* XXX shut up gcc */
7323	memset(&saved_pfmt, 0, sizeof(saved_pfmt));
7324	memset(&saved_rfmt, 0, sizeof(saved_rfmt));
7325
7326	/*
7327	 * Set default value and save current parameters.
7328	 * For backward compatibility, use sticky parameters for nonexistent
7329	 * track.
7330	 */
7331	if (ptrack) {
7332		pfmt = ptrack->usrbuf.fmt;
7333		saved_pfmt = ptrack->usrbuf.fmt;
7334		saved_ai.play.pause = ptrack->is_pause;
7335	} else {
7336		pfmt = sc->sc_sound_pparams;
7337	}
7338	if (rtrack) {
7339		rfmt = rtrack->usrbuf.fmt;
7340		saved_rfmt = rtrack->usrbuf.fmt;
7341		saved_ai.record.pause = rtrack->is_pause;
7342	} else {
7343		rfmt = sc->sc_sound_rparams;
7344	}
7345	saved_ai.mode = file->mode;
7346
7347	/*
7348	 * Overwrite if specified.
7349	 */
7350	mode = file->mode;
7351	if (SPECIFIED(ai->mode)) {
7352		/*
7353		 * Setting ai->mode no longer does anything because it's
7354		 * prohibited to change playback/recording mode after open
7355		 * and AUMODE_PLAY_ALL is obsoleted.  However, it still
7356		 * keeps the state of AUMODE_PLAY_ALL itself for backward
7357		 * compatibility.
7358		 * In the internal, only file->mode has the state of
7359		 * AUMODE_PLAY_ALL flag and track->mode in both track does
7360		 * not have.
7361		 */
7362		if ((file->mode & AUMODE_PLAY)) {
7363			mode = (file->mode & (AUMODE_PLAY | AUMODE_RECORD))
7364			    | (ai->mode & AUMODE_PLAY_ALL);
7365		}
7366	}
7367
7368	pchanges = audio_track_setinfo_check(ptrack, &pfmt, pi);
7369	if (pchanges == -1) {
7370#if defined(AUDIO_DEBUG)
7371		TRACEF(1, file, "check play.params failed: "
7372		    "%s %ubit %uch %uHz",
7373		    audio_encoding_name(pi->encoding),
7374		    pi->precision,
7375		    pi->channels,
7376		    pi->sample_rate);
7377#endif
7378		return EINVAL;
7379	}
7380
7381	rchanges = audio_track_setinfo_check(rtrack, &rfmt, ri);
7382	if (rchanges == -1) {
7383#if defined(AUDIO_DEBUG)
7384		TRACEF(1, file, "check record.params failed: "
7385		    "%s %ubit %uch %uHz",
7386		    audio_encoding_name(ri->encoding),
7387		    ri->precision,
7388		    ri->channels,
7389		    ri->sample_rate);
7390#endif
7391		return EINVAL;
7392	}
7393
7394	if (SPECIFIED(ai->mode)) {
7395		pchanges = 1;
7396		rchanges = 1;
7397	}
7398
7399	/*
7400	 * Even when setting either one of playback and recording,
7401	 * both track must be halted.
7402	 */
7403	if (pchanges || rchanges) {
7404		audio_file_clear(sc, file);
7405#if defined(AUDIO_DEBUG)
7406		char nbuf[16];
7407		char fmtbuf[64];
7408		if (pchanges) {
7409			if (ptrack) {
7410				snprintf(nbuf, sizeof(nbuf), "%d", ptrack->id);
7411			} else {
7412				snprintf(nbuf, sizeof(nbuf), "-");
7413			}
7414			audio_format2_tostr(fmtbuf, sizeof(fmtbuf), &pfmt);
7415			DPRINTF(1, "audio track#%s play mode: %s\n",
7416			    nbuf, fmtbuf);
7417		}
7418		if (rchanges) {
7419			if (rtrack) {
7420				snprintf(nbuf, sizeof(nbuf), "%d", rtrack->id);
7421			} else {
7422				snprintf(nbuf, sizeof(nbuf), "-");
7423			}
7424			audio_format2_tostr(fmtbuf, sizeof(fmtbuf), &rfmt);
7425			DPRINTF(1, "audio track#%s rec  mode: %s\n",
7426			    nbuf, fmtbuf);
7427		}
7428#endif
7429	}
7430
7431	/* Set mixer parameters */
7432	mutex_enter(sc->sc_lock);
7433	error = audio_hw_setinfo(sc, ai, &saved_ai);
7434	mutex_exit(sc->sc_lock);
7435	if (error)
7436		goto abort1;
7437
7438	/*
7439	 * Set to track and update sticky parameters.
7440	 */
7441	error = 0;
7442	file->mode = mode;
7443
7444	if (SPECIFIED_CH(pi->pause)) {
7445		if (ptrack)
7446			ptrack->is_pause = pi->pause;
7447		sc->sc_sound_ppause = pi->pause;
7448	}
7449	if (pchanges) {
7450		if (ptrack) {
7451			audio_track_lock_enter(ptrack);
7452			error = audio_track_set_format(ptrack, &pfmt);
7453			audio_track_lock_exit(ptrack);
7454			if (error) {
7455				TRACET(1, ptrack, "set play.params failed");
7456				goto abort2;
7457			}
7458		}
7459		sc->sc_sound_pparams = pfmt;
7460	}
7461	/* Change water marks after initializing the buffers. */
7462	if (SPECIFIED(ai->hiwat) || SPECIFIED(ai->lowat)) {
7463		if (ptrack)
7464			audio_track_setinfo_water(ptrack, ai);
7465	}
7466
7467	if (SPECIFIED_CH(ri->pause)) {
7468		if (rtrack)
7469			rtrack->is_pause = ri->pause;
7470		sc->sc_sound_rpause = ri->pause;
7471	}
7472	if (rchanges) {
7473		if (rtrack) {
7474			audio_track_lock_enter(rtrack);
7475			error = audio_track_set_format(rtrack, &rfmt);
7476			audio_track_lock_exit(rtrack);
7477			if (error) {
7478				TRACET(1, rtrack, "set record.params failed");
7479				goto abort3;
7480			}
7481		}
7482		sc->sc_sound_rparams = rfmt;
7483	}
7484
7485	return 0;
7486
7487	/* Rollback */
7488abort3:
7489	if (error != ENOMEM) {
7490		rtrack->is_pause = saved_ai.record.pause;
7491		audio_track_lock_enter(rtrack);
7492		audio_track_set_format(rtrack, &saved_rfmt);
7493		audio_track_lock_exit(rtrack);
7494	}
7495	sc->sc_sound_rpause = saved_ai.record.pause;
7496	sc->sc_sound_rparams = saved_rfmt;
7497abort2:
7498	if (ptrack && error != ENOMEM) {
7499		ptrack->is_pause = saved_ai.play.pause;
7500		audio_track_lock_enter(ptrack);
7501		audio_track_set_format(ptrack, &saved_pfmt);
7502		audio_track_lock_exit(ptrack);
7503	}
7504	sc->sc_sound_ppause = saved_ai.play.pause;
7505	sc->sc_sound_pparams = saved_pfmt;
7506	file->mode = saved_ai.mode;
7507abort1:
7508	mutex_enter(sc->sc_lock);
7509	audio_hw_setinfo(sc, &saved_ai, NULL);
7510	mutex_exit(sc->sc_lock);
7511
7512	return error;
7513}
7514
7515/*
7516 * Write SPECIFIED() parameters within info back to fmt.
7517 * Note that track can be NULL here.
7518 * Return value of 1 indicates that fmt is modified.
7519 * Return value of 0 indicates that fmt is not modified.
7520 * Return value of -1 indicates that error EINVAL has occurred.
7521 */
7522static int
7523audio_track_setinfo_check(audio_track_t *track,
7524	audio_format2_t *fmt, const struct audio_prinfo *info)
7525{
7526	const audio_format2_t *hwfmt;
7527	int changes;
7528
7529	changes = 0;
7530	if (SPECIFIED(info->sample_rate)) {
7531		if (info->sample_rate < AUDIO_MIN_FREQUENCY)
7532			return -1;
7533		if (info->sample_rate > AUDIO_MAX_FREQUENCY)
7534			return -1;
7535		fmt->sample_rate = info->sample_rate;
7536		changes = 1;
7537	}
7538	if (SPECIFIED(info->encoding)) {
7539		fmt->encoding = info->encoding;
7540		changes = 1;
7541	}
7542	if (SPECIFIED(info->precision)) {
7543		fmt->precision = info->precision;
7544		/* we don't have API to specify stride */
7545		fmt->stride = info->precision;
7546		changes = 1;
7547	}
7548	if (SPECIFIED(info->channels)) {
7549		/*
7550		 * We can convert between monaural and stereo each other.
7551		 * We can reduce than the number of channels that the hardware
7552		 * supports.
7553		 */
7554		if (info->channels > 2) {
7555			if (track) {
7556				hwfmt = &track->mixer->hwbuf.fmt;
7557				if (info->channels > hwfmt->channels)
7558					return -1;
7559			} else {
7560				/*
7561				 * This should never happen.
7562				 * If track == NULL, channels should be <= 2.
7563				 */
7564				return -1;
7565			}
7566		}
7567		fmt->channels = info->channels;
7568		changes = 1;
7569	}
7570
7571	if (changes) {
7572		if (audio_check_params(fmt) != 0)
7573			return -1;
7574	}
7575
7576	return changes;
7577}
7578
7579/*
7580 * Change water marks for playback track if specified.
7581 */
7582static void
7583audio_track_setinfo_water(audio_track_t *track, const struct audio_info *ai)
7584{
7585	u_int blks;
7586	u_int maxblks;
7587	u_int blksize;
7588
7589	KASSERT(audio_track_is_playback(track));
7590
7591	blksize = track->usrbuf_blksize;
7592	maxblks = track->usrbuf.capacity / blksize;
7593
7594	if (SPECIFIED(ai->hiwat)) {
7595		blks = ai->hiwat;
7596		if (blks > maxblks)
7597			blks = maxblks;
7598		if (blks < 2)
7599			blks = 2;
7600		track->usrbuf_usedhigh = blks * blksize;
7601	}
7602	if (SPECIFIED(ai->lowat)) {
7603		blks = ai->lowat;
7604		if (blks > maxblks - 1)
7605			blks = maxblks - 1;
7606		track->usrbuf_usedlow = blks * blksize;
7607	}
7608	if (SPECIFIED(ai->hiwat) || SPECIFIED(ai->lowat)) {
7609		if (track->usrbuf_usedlow > track->usrbuf_usedhigh - blksize) {
7610			track->usrbuf_usedlow = track->usrbuf_usedhigh -
7611			    blksize;
7612		}
7613	}
7614}
7615
7616/*
7617 * Set hardware part of *newai.
7618 * The parameters handled here are *.port, *.gain, *.balance and monitor_gain.
7619 * If oldai is specified, previous parameters are stored.
7620 * This function itself does not roll back if error occurred.
7621 * Must be called with sc_lock && sc_exlock held.
7622 */
7623static int
7624audio_hw_setinfo(struct audio_softc *sc, const struct audio_info *newai,
7625	struct audio_info *oldai)
7626{
7627	const struct audio_prinfo *newpi;
7628	const struct audio_prinfo *newri;
7629	struct audio_prinfo *oldpi;
7630	struct audio_prinfo *oldri;
7631	u_int pgain;
7632	u_int rgain;
7633	u_char pbalance;
7634	u_char rbalance;
7635	int error;
7636
7637	KASSERT(mutex_owned(sc->sc_lock));
7638	KASSERT(sc->sc_exlock);
7639
7640	/* XXX shut up gcc */
7641	oldpi = NULL;
7642	oldri = NULL;
7643
7644	newpi = &newai->play;
7645	newri = &newai->record;
7646	if (oldai) {
7647		oldpi = &oldai->play;
7648		oldri = &oldai->record;
7649	}
7650	error = 0;
7651
7652	/*
7653	 * It looks like unnecessary to halt HW mixers to set HW mixers.
7654	 * mixer_ioctl(MIXER_WRITE) also doesn't halt.
7655	 */
7656
7657	if (SPECIFIED(newpi->port)) {
7658		if (oldai)
7659			oldpi->port = au_get_port(sc, &sc->sc_outports);
7660		error = au_set_port(sc, &sc->sc_outports, newpi->port);
7661		if (error) {
7662			audio_printf(sc,
7663			    "setting play.port=%d failed: errno=%d\n",
7664			    newpi->port, error);
7665			goto abort;
7666		}
7667	}
7668	if (SPECIFIED(newri->port)) {
7669		if (oldai)
7670			oldri->port = au_get_port(sc, &sc->sc_inports);
7671		error = au_set_port(sc, &sc->sc_inports, newri->port);
7672		if (error) {
7673			audio_printf(sc,
7674			    "setting record.port=%d failed: errno=%d\n",
7675			    newri->port, error);
7676			goto abort;
7677		}
7678	}
7679
7680	/* play.{gain,balance} */
7681	if (SPECIFIED(newpi->gain) || SPECIFIED_CH(newpi->balance)) {
7682		au_get_gain(sc, &sc->sc_outports, &pgain, &pbalance);
7683		if (oldai) {
7684			oldpi->gain = pgain;
7685			oldpi->balance = pbalance;
7686		}
7687
7688		if (SPECIFIED(newpi->gain))
7689			pgain = newpi->gain;
7690		if (SPECIFIED_CH(newpi->balance))
7691			pbalance = newpi->balance;
7692		error = au_set_gain(sc, &sc->sc_outports, pgain, pbalance);
7693		if (error) {
7694			audio_printf(sc,
7695			    "setting play.gain=%d/balance=%d failed: "
7696			    "errno=%d\n",
7697			    pgain, pbalance, error);
7698			goto abort;
7699		}
7700	}
7701
7702	/* record.{gain,balance} */
7703	if (SPECIFIED(newri->gain) || SPECIFIED_CH(newri->balance)) {
7704		au_get_gain(sc, &sc->sc_inports, &rgain, &rbalance);
7705		if (oldai) {
7706			oldri->gain = rgain;
7707			oldri->balance = rbalance;
7708		}
7709
7710		if (SPECIFIED(newri->gain))
7711			rgain = newri->gain;
7712		if (SPECIFIED_CH(newri->balance))
7713			rbalance = newri->balance;
7714		error = au_set_gain(sc, &sc->sc_inports, rgain, rbalance);
7715		if (error) {
7716			audio_printf(sc,
7717			    "setting record.gain=%d/balance=%d failed: "
7718			    "errno=%d\n",
7719			    rgain, rbalance, error);
7720			goto abort;
7721		}
7722	}
7723
7724	if (SPECIFIED(newai->monitor_gain) && sc->sc_monitor_port != -1) {
7725		if (oldai)
7726			oldai->monitor_gain = au_get_monitor_gain(sc);
7727		error = au_set_monitor_gain(sc, newai->monitor_gain);
7728		if (error) {
7729			audio_printf(sc,
7730			    "setting monitor_gain=%d failed: errno=%d\n",
7731			    newai->monitor_gain, error);
7732			goto abort;
7733		}
7734	}
7735
7736	/* XXX TODO */
7737	/* sc->sc_ai = *ai; */
7738
7739	error = 0;
7740abort:
7741	return error;
7742}
7743
7744/*
7745 * Setup the hardware with mixer format phwfmt, rhwfmt.
7746 * The arguments have following restrictions:
7747 * - setmode is the direction you want to set, AUMODE_PLAY or AUMODE_RECORD,
7748 *   or both.
7749 * - phwfmt and rhwfmt must not be NULL regardless of setmode.
7750 * - On non-independent devices, phwfmt and rhwfmt must have the same
7751 *   parameters.
7752 * - pfil and rfil must be zero-filled.
7753 * If successful,
7754 * - pfil, rfil will be filled with filter information specified by the
7755 *   hardware driver if necessary.
7756 * and then returns 0.  Otherwise returns errno.
7757 * Must be called without sc_lock held.
7758 */
7759static int
7760audio_hw_set_format(struct audio_softc *sc, int setmode,
7761	const audio_format2_t *phwfmt, const audio_format2_t *rhwfmt,
7762	audio_filter_reg_t *pfil, audio_filter_reg_t *rfil)
7763{
7764	audio_params_t pp, rp;
7765	int error;
7766
7767	KASSERT(phwfmt != NULL);
7768	KASSERT(rhwfmt != NULL);
7769
7770	pp = format2_to_params(phwfmt);
7771	rp = format2_to_params(rhwfmt);
7772
7773	mutex_enter(sc->sc_lock);
7774	error = sc->hw_if->set_format(sc->hw_hdl, setmode,
7775	    &pp, &rp, pfil, rfil);
7776	if (error) {
7777		mutex_exit(sc->sc_lock);
7778		audio_printf(sc, "set_format failed: errno=%d\n", error);
7779		return error;
7780	}
7781
7782	if (sc->hw_if->commit_settings) {
7783		error = sc->hw_if->commit_settings(sc->hw_hdl);
7784		if (error) {
7785			mutex_exit(sc->sc_lock);
7786			audio_printf(sc,
7787			    "commit_settings failed: errno=%d\n", error);
7788			return error;
7789		}
7790	}
7791	mutex_exit(sc->sc_lock);
7792
7793	return 0;
7794}
7795
7796/*
7797 * Fill audio_info structure.  If need_mixerinfo is true, it will also
7798 * fill the hardware mixer information.
7799 * Must be called with sc_exlock held and without sc_lock held.
7800 */
7801static int
7802audiogetinfo(struct audio_softc *sc, struct audio_info *ai, int need_mixerinfo,
7803	audio_file_t *file)
7804{
7805	struct audio_prinfo *ri, *pi;
7806	audio_track_t *track;
7807	audio_track_t *ptrack;
7808	audio_track_t *rtrack;
7809	int gain;
7810
7811	KASSERT(sc->sc_exlock);
7812
7813	ri = &ai->record;
7814	pi = &ai->play;
7815	ptrack = file->ptrack;
7816	rtrack = file->rtrack;
7817
7818	memset(ai, 0, sizeof(*ai));
7819
7820	if (ptrack) {
7821		pi->sample_rate = ptrack->usrbuf.fmt.sample_rate;
7822		pi->channels    = ptrack->usrbuf.fmt.channels;
7823		pi->precision   = ptrack->usrbuf.fmt.precision;
7824		pi->encoding    = ptrack->usrbuf.fmt.encoding;
7825		pi->pause       = ptrack->is_pause;
7826	} else {
7827		/* Use sticky parameters if the track is not available. */
7828		pi->sample_rate = sc->sc_sound_pparams.sample_rate;
7829		pi->channels    = sc->sc_sound_pparams.channels;
7830		pi->precision   = sc->sc_sound_pparams.precision;
7831		pi->encoding    = sc->sc_sound_pparams.encoding;
7832		pi->pause       = sc->sc_sound_ppause;
7833	}
7834	if (rtrack) {
7835		ri->sample_rate = rtrack->usrbuf.fmt.sample_rate;
7836		ri->channels    = rtrack->usrbuf.fmt.channels;
7837		ri->precision   = rtrack->usrbuf.fmt.precision;
7838		ri->encoding    = rtrack->usrbuf.fmt.encoding;
7839		ri->pause       = rtrack->is_pause;
7840	} else {
7841		/* Use sticky parameters if the track is not available. */
7842		ri->sample_rate = sc->sc_sound_rparams.sample_rate;
7843		ri->channels    = sc->sc_sound_rparams.channels;
7844		ri->precision   = sc->sc_sound_rparams.precision;
7845		ri->encoding    = sc->sc_sound_rparams.encoding;
7846		ri->pause       = sc->sc_sound_rpause;
7847	}
7848
7849	if (ptrack) {
7850		pi->seek = ptrack->usrbuf.used;
7851		pi->samples = ptrack->stamp * ptrack->usrbuf_blksize;
7852		pi->eof = ptrack->eofcounter;
7853		pi->error = (ptrack->dropframes != 0) ? 1 : 0;
7854		pi->open = 1;
7855		pi->buffer_size = ptrack->usrbuf.capacity;
7856	}
7857	pi->waiting = 0;		/* open never hangs */
7858	pi->active = sc->sc_pbusy;
7859
7860	if (rtrack) {
7861		ri->seek = audio_track_readablebytes(rtrack);
7862		ri->samples = rtrack->stamp * rtrack->usrbuf_blksize;
7863		ri->eof = 0;
7864		ri->error = (rtrack->dropframes != 0) ? 1 : 0;
7865		ri->open = 1;
7866		ri->buffer_size = audio_track_inputblk_as_usrbyte(rtrack,
7867		    rtrack->input->capacity);
7868	}
7869	ri->waiting = 0;		/* open never hangs */
7870	ri->active = sc->sc_rbusy;
7871
7872	/*
7873	 * XXX There may be different number of channels between playback
7874	 *     and recording, so that blocksize also may be different.
7875	 *     But struct audio_info has an united blocksize...
7876	 *     Here, I use play info precedencely if ptrack is available,
7877	 *     otherwise record info.
7878	 *
7879	 * XXX hiwat/lowat is a playback-only parameter.  What should I
7880	 *     return for a record-only descriptor?
7881	 */
7882	track = ptrack ? ptrack : rtrack;
7883	if (track) {
7884		ai->blocksize = track->usrbuf_blksize;
7885		ai->hiwat = track->usrbuf_usedhigh / track->usrbuf_blksize;
7886		ai->lowat = track->usrbuf_usedlow / track->usrbuf_blksize;
7887	}
7888	ai->mode = file->mode;
7889
7890	/*
7891	 * For backward compatibility, we have to pad these five fields
7892	 * a fake non-zero value even if there are no tracks.
7893	 */
7894	if (ptrack == NULL)
7895		pi->buffer_size = 65536;
7896	if (rtrack == NULL)
7897		ri->buffer_size = 65536;
7898	if (ptrack == NULL && rtrack == NULL) {
7899		ai->blocksize = 2048;
7900		ai->hiwat = ai->play.buffer_size / ai->blocksize;
7901		ai->lowat = ai->hiwat * 3 / 4;
7902	}
7903
7904	if (need_mixerinfo) {
7905		mutex_enter(sc->sc_lock);
7906
7907		pi->port = au_get_port(sc, &sc->sc_outports);
7908		ri->port = au_get_port(sc, &sc->sc_inports);
7909
7910		pi->avail_ports = sc->sc_outports.allports;
7911		ri->avail_ports = sc->sc_inports.allports;
7912
7913		au_get_gain(sc, &sc->sc_outports, &pi->gain, &pi->balance);
7914		au_get_gain(sc, &sc->sc_inports, &ri->gain, &ri->balance);
7915
7916		if (sc->sc_monitor_port != -1) {
7917			gain = au_get_monitor_gain(sc);
7918			if (gain != -1)
7919				ai->monitor_gain = gain;
7920		}
7921		mutex_exit(sc->sc_lock);
7922	}
7923
7924	return 0;
7925}
7926
7927/*
7928 * Return true if playback is configured.
7929 * This function can be used after audioattach.
7930 */
7931static bool
7932audio_can_playback(struct audio_softc *sc)
7933{
7934
7935	return (sc->sc_pmixer != NULL);
7936}
7937
7938/*
7939 * Return true if recording is configured.
7940 * This function can be used after audioattach.
7941 */
7942static bool
7943audio_can_capture(struct audio_softc *sc)
7944{
7945
7946	return (sc->sc_rmixer != NULL);
7947}
7948
7949/*
7950 * Get the afp->index'th item from the valid one of format[].
7951 * If found, stores it to afp->fmt and returns 0.  Otherwise return EINVAL.
7952 *
7953 * This is common routines for query_format.
7954 * If your hardware driver has struct audio_format[], the simplest case
7955 * you can write your query_format interface as follows:
7956 *
7957 * struct audio_format foo_format[] = { ... };
7958 *
7959 * int
7960 * foo_query_format(void *hdl, audio_format_query_t *afp)
7961 * {
7962 *   return audio_query_format(foo_format, __arraycount(foo_format), afp);
7963 * }
7964 */
7965int
7966audio_query_format(const struct audio_format *format, int nformats,
7967	audio_format_query_t *afp)
7968{
7969	const struct audio_format *f;
7970	int idx;
7971	int i;
7972
7973	idx = 0;
7974	for (i = 0; i < nformats; i++) {
7975		f = &format[i];
7976		if (!AUFMT_IS_VALID(f))
7977			continue;
7978		if (afp->index == idx) {
7979			afp->fmt = *f;
7980			return 0;
7981		}
7982		idx++;
7983	}
7984	return EINVAL;
7985}
7986
7987/*
7988 * This function is provided for the hardware driver's set_format() to
7989 * find index matches with 'param' from array of audio_format_t 'formats'.
7990 * 'mode' is either of AUMODE_PLAY or AUMODE_RECORD.
7991 * It returns the matched index and never fails.  Because param passed to
7992 * set_format() is selected from query_format().
7993 * This function will be an alternative to auconv_set_converter() to
7994 * find index.
7995 */
7996int
7997audio_indexof_format(const struct audio_format *formats, int nformats,
7998	int mode, const audio_params_t *param)
7999{
8000	const struct audio_format *f;
8001	int index;
8002	int j;
8003
8004	for (index = 0; index < nformats; index++) {
8005		f = &formats[index];
8006
8007		if (!AUFMT_IS_VALID(f))
8008			continue;
8009		if ((f->mode & mode) == 0)
8010			continue;
8011		if (f->encoding != param->encoding)
8012			continue;
8013		if (f->validbits != param->precision)
8014			continue;
8015		if (f->channels != param->channels)
8016			continue;
8017
8018		if (f->frequency_type == 0) {
8019			if (param->sample_rate < f->frequency[0] ||
8020			    param->sample_rate > f->frequency[1])
8021				continue;
8022		} else {
8023			for (j = 0; j < f->frequency_type; j++) {
8024				if (param->sample_rate == f->frequency[j])
8025					break;
8026			}
8027			if (j == f->frequency_type)
8028				continue;
8029		}
8030
8031		/* Then, matched */
8032		return index;
8033	}
8034
8035	/* Not matched.  This should not be happened. */
8036	panic("%s: cannot find matched format\n", __func__);
8037}
8038
8039/*
8040 * Get or set hardware blocksize in msec.
8041 * XXX It's for debug.
8042 */
8043static int
8044audio_sysctl_blk_ms(SYSCTLFN_ARGS)
8045{
8046	struct sysctlnode node;
8047	struct audio_softc *sc;
8048	audio_format2_t phwfmt;
8049	audio_format2_t rhwfmt;
8050	audio_filter_reg_t pfil;
8051	audio_filter_reg_t rfil;
8052	int t;
8053	int old_blk_ms;
8054	int mode;
8055	int error;
8056
8057	node = *rnode;
8058	sc = node.sysctl_data;
8059
8060	error = audio_exlock_enter(sc);
8061	if (error)
8062		return error;
8063
8064	old_blk_ms = sc->sc_blk_ms;
8065	t = old_blk_ms;
8066	node.sysctl_data = &t;
8067	error = sysctl_lookup(SYSCTLFN_CALL(&node));
8068	if (error || newp == NULL)
8069		goto abort;
8070
8071	if (t < 0) {
8072		error = EINVAL;
8073		goto abort;
8074	}
8075
8076	if (sc->sc_popens + sc->sc_ropens > 0) {
8077		error = EBUSY;
8078		goto abort;
8079	}
8080	sc->sc_blk_ms = t;
8081	mode = 0;
8082	if (sc->sc_pmixer) {
8083		mode |= AUMODE_PLAY;
8084		phwfmt = sc->sc_pmixer->hwbuf.fmt;
8085	}
8086	if (sc->sc_rmixer) {
8087		mode |= AUMODE_RECORD;
8088		rhwfmt = sc->sc_rmixer->hwbuf.fmt;
8089	}
8090
8091	/* re-init hardware */
8092	memset(&pfil, 0, sizeof(pfil));
8093	memset(&rfil, 0, sizeof(rfil));
8094	error = audio_hw_set_format(sc, mode, &phwfmt, &rhwfmt, &pfil, &rfil);
8095	if (error) {
8096		goto abort;
8097	}
8098
8099	/* re-init track mixer */
8100	error = audio_mixers_init(sc, mode, &phwfmt, &rhwfmt, &pfil, &rfil);
8101	if (error) {
8102		/* Rollback */
8103		sc->sc_blk_ms = old_blk_ms;
8104		audio_mixers_init(sc, mode, &phwfmt, &rhwfmt, &pfil, &rfil);
8105		goto abort;
8106	}
8107	error = 0;
8108abort:
8109	audio_exlock_exit(sc);
8110	return error;
8111}
8112
8113/*
8114 * Get or set multiuser mode.
8115 */
8116static int
8117audio_sysctl_multiuser(SYSCTLFN_ARGS)
8118{
8119	struct sysctlnode node;
8120	struct audio_softc *sc;
8121	bool t;
8122	int error;
8123
8124	node = *rnode;
8125	sc = node.sysctl_data;
8126
8127	error = audio_exlock_enter(sc);
8128	if (error)
8129		return error;
8130
8131	t = sc->sc_multiuser;
8132	node.sysctl_data = &t;
8133	error = sysctl_lookup(SYSCTLFN_CALL(&node));
8134	if (error || newp == NULL)
8135		goto abort;
8136
8137	sc->sc_multiuser = t;
8138	error = 0;
8139abort:
8140	audio_exlock_exit(sc);
8141	return error;
8142}
8143
8144#if defined(AUDIO_DEBUG)
8145/*
8146 * Get or set debug verbose level. (0..4)
8147 * XXX It's for debug.
8148 * XXX It is not separated per device.
8149 */
8150static int
8151audio_sysctl_debug(SYSCTLFN_ARGS)
8152{
8153	struct sysctlnode node;
8154	int t;
8155	int error;
8156
8157	node = *rnode;
8158	t = audiodebug;
8159	node.sysctl_data = &t;
8160	error = sysctl_lookup(SYSCTLFN_CALL(&node));
8161	if (error || newp == NULL)
8162		return error;
8163
8164	if (t < 0 || t > 4)
8165		return EINVAL;
8166	audiodebug = t;
8167	printf("audio: audiodebug = %d\n", audiodebug);
8168	return 0;
8169}
8170#endif /* AUDIO_DEBUG */
8171
8172#ifdef AUDIO_PM_IDLE
8173static void
8174audio_idle(void *arg)
8175{
8176	device_t dv = arg;
8177	struct audio_softc *sc = device_private(dv);
8178
8179#ifdef PNP_DEBUG
8180	extern int pnp_debug_idle;
8181	if (pnp_debug_idle)
8182		printf("%s: idle handler called\n", device_xname(dv));
8183#endif
8184
8185	sc->sc_idle = true;
8186
8187	/* XXX joerg Make pmf_device_suspend handle children? */
8188	if (!pmf_device_suspend(dv, PMF_Q_SELF))
8189		return;
8190
8191	if (!pmf_device_suspend(sc->hw_dev, PMF_Q_SELF))
8192		pmf_device_resume(dv, PMF_Q_SELF);
8193}
8194
8195static void
8196audio_activity(device_t dv, devactive_t type)
8197{
8198	struct audio_softc *sc = device_private(dv);
8199
8200	if (type != DVA_SYSTEM)
8201		return;
8202
8203	callout_schedule(&sc->sc_idle_counter, audio_idle_timeout * hz);
8204
8205	sc->sc_idle = false;
8206	if (!device_is_active(dv)) {
8207		/* XXX joerg How to deal with a failing resume... */
8208		pmf_device_resume(sc->hw_dev, PMF_Q_SELF);
8209		pmf_device_resume(dv, PMF_Q_SELF);
8210	}
8211}
8212#endif
8213
8214static bool
8215audio_suspend(device_t dv, const pmf_qual_t *qual)
8216{
8217	struct audio_softc *sc = device_private(dv);
8218	int error;
8219
8220	error = audio_exlock_mutex_enter(sc);
8221	if (error)
8222		return error;
8223	sc->sc_suspending = true;
8224	audio_mixer_capture(sc);
8225
8226	if (sc->sc_pbusy) {
8227		audio_pmixer_halt(sc);
8228		/* Reuse this as need-to-restart flag while suspending */
8229		sc->sc_pbusy = true;
8230	}
8231	if (sc->sc_rbusy) {
8232		audio_rmixer_halt(sc);
8233		/* Reuse this as need-to-restart flag while suspending */
8234		sc->sc_rbusy = true;
8235	}
8236
8237#ifdef AUDIO_PM_IDLE
8238	callout_halt(&sc->sc_idle_counter, sc->sc_lock);
8239#endif
8240	audio_exlock_mutex_exit(sc);
8241
8242	return true;
8243}
8244
8245static bool
8246audio_resume(device_t dv, const pmf_qual_t *qual)
8247{
8248	struct audio_softc *sc = device_private(dv);
8249	struct audio_info ai;
8250	int error;
8251
8252	error = audio_exlock_mutex_enter(sc);
8253	if (error)
8254		return error;
8255
8256	sc->sc_suspending = false;
8257	audio_mixer_restore(sc);
8258	/* XXX ? */
8259	AUDIO_INITINFO(&ai);
8260	audio_hw_setinfo(sc, &ai, NULL);
8261
8262	/*
8263	 * During from suspend to resume here, sc_[pr]busy is used as
8264	 * need-to-restart flag temporarily.  After this point,
8265	 * sc_[pr]busy is returned to its original usage (busy flag).
8266	 * And note that sc_[pr]busy must be false to call [pr]mixer_start().
8267	 */
8268	if (sc->sc_pbusy) {
8269		/* pmixer_start() requires pbusy is false */
8270		sc->sc_pbusy = false;
8271		audio_pmixer_start(sc, true);
8272	}
8273	if (sc->sc_rbusy) {
8274		/* rmixer_start() requires rbusy is false */
8275		sc->sc_rbusy = false;
8276		audio_rmixer_start(sc);
8277	}
8278
8279	audio_exlock_mutex_exit(sc);
8280
8281	return true;
8282}
8283
8284#if defined(AUDIO_DEBUG)
8285static void
8286audio_format2_tostr(char *buf, size_t bufsize, const audio_format2_t *fmt)
8287{
8288	int n;
8289
8290	n = 0;
8291	n += snprintf(buf + n, bufsize - n, "%s",
8292	    audio_encoding_name(fmt->encoding));
8293	if (fmt->precision == fmt->stride) {
8294		n += snprintf(buf + n, bufsize - n, " %dbit", fmt->precision);
8295	} else {
8296		n += snprintf(buf + n, bufsize - n, " %d/%dbit",
8297			fmt->precision, fmt->stride);
8298	}
8299
8300	snprintf(buf + n, bufsize - n, " %uch %uHz",
8301	    fmt->channels, fmt->sample_rate);
8302}
8303#endif
8304
8305#if defined(AUDIO_DEBUG)
8306static void
8307audio_print_format2(const char *s, const audio_format2_t *fmt)
8308{
8309	char fmtstr[64];
8310
8311	audio_format2_tostr(fmtstr, sizeof(fmtstr), fmt);
8312	printf("%s %s\n", s, fmtstr);
8313}
8314#endif
8315
8316#ifdef DIAGNOSTIC
8317void
8318audio_diagnostic_format2(const char *where, const audio_format2_t *fmt)
8319{
8320
8321	KASSERTMSG(fmt, "called from %s", where);
8322
8323	/* XXX MSM6258 vs(4) only has 4bit stride format. */
8324	if (fmt->encoding == AUDIO_ENCODING_ADPCM) {
8325		KASSERTMSG(fmt->stride == 4 || fmt->stride == 8,
8326		    "called from %s: fmt->stride=%d", where, fmt->stride);
8327	} else {
8328		KASSERTMSG(fmt->stride % NBBY == 0,
8329		    "called from %s: fmt->stride=%d", where, fmt->stride);
8330	}
8331	KASSERTMSG(fmt->precision <= fmt->stride,
8332	    "called from %s: fmt->precision=%d fmt->stride=%d",
8333	    where, fmt->precision, fmt->stride);
8334	KASSERTMSG(1 <= fmt->channels && fmt->channels <= AUDIO_MAX_CHANNELS,
8335	    "called from %s: fmt->channels=%d", where, fmt->channels);
8336
8337	/* XXX No check for encodings? */
8338}
8339
8340void
8341audio_diagnostic_filter_arg(const char *where, const audio_filter_arg_t *arg)
8342{
8343
8344	KASSERT(arg != NULL);
8345	KASSERT(arg->src != NULL);
8346	KASSERT(arg->dst != NULL);
8347	audio_diagnostic_format2(where, arg->srcfmt);
8348	audio_diagnostic_format2(where, arg->dstfmt);
8349	KASSERT(arg->count > 0);
8350}
8351
8352void
8353audio_diagnostic_ring(const char *where, const audio_ring_t *ring)
8354{
8355
8356	KASSERTMSG(ring, "called from %s", where);
8357	audio_diagnostic_format2(where, &ring->fmt);
8358	KASSERTMSG(0 <= ring->capacity && ring->capacity < INT_MAX / 2,
8359	    "called from %s: ring->capacity=%d", where, ring->capacity);
8360	KASSERTMSG(0 <= ring->used && ring->used <= ring->capacity,
8361	    "called from %s: ring->used=%d ring->capacity=%d",
8362	    where, ring->used, ring->capacity);
8363	if (ring->capacity == 0) {
8364		KASSERTMSG(ring->mem == NULL,
8365		    "called from %s: capacity == 0 but mem != NULL", where);
8366	} else {
8367		KASSERTMSG(ring->mem != NULL,
8368		    "called from %s: capacity != 0 but mem == NULL", where);
8369		KASSERTMSG(0 <= ring->head && ring->head < ring->capacity,
8370		    "called from %s: ring->head=%d ring->capacity=%d",
8371		    where, ring->head, ring->capacity);
8372	}
8373}
8374#endif /* DIAGNOSTIC */
8375
8376
8377/*
8378 * Mixer driver
8379 */
8380
8381/*
8382 * Must be called without sc_lock held.
8383 */
8384int
8385mixer_open(dev_t dev, struct audio_softc *sc, int flags, int ifmt,
8386	struct lwp *l)
8387{
8388	struct file *fp;
8389	audio_file_t *af;
8390	int error, fd;
8391
8392	TRACE(1, "flags=0x%x", flags);
8393
8394	error = fd_allocfile(&fp, &fd);
8395	if (error)
8396		return error;
8397
8398	af = kmem_zalloc(sizeof(*af), KM_SLEEP);
8399	af->sc = sc;
8400	af->dev = dev;
8401
8402	mutex_enter(sc->sc_lock);
8403	if (sc->sc_dying) {
8404		mutex_exit(sc->sc_lock);
8405		kmem_free(af, sizeof(*af));
8406		fd_abort(curproc, fp, fd);
8407		return ENXIO;
8408	}
8409	mutex_enter(sc->sc_intr_lock);
8410	SLIST_INSERT_HEAD(&sc->sc_files, af, entry);
8411	mutex_exit(sc->sc_intr_lock);
8412	mutex_exit(sc->sc_lock);
8413
8414	error = fd_clone(fp, fd, flags, &audio_fileops, af);
8415	KASSERT(error == EMOVEFD);
8416
8417	return error;
8418}
8419
8420/*
8421 * Add a process to those to be signalled on mixer activity.
8422 * If the process has already been added, do nothing.
8423 * Must be called with sc_exlock held and without sc_lock held.
8424 */
8425static void
8426mixer_async_add(struct audio_softc *sc, pid_t pid)
8427{
8428	int i;
8429
8430	KASSERT(sc->sc_exlock);
8431
8432	/* If already exists, returns without doing anything. */
8433	for (i = 0; i < sc->sc_am_used; i++) {
8434		if (sc->sc_am[i] == pid)
8435			return;
8436	}
8437
8438	/* Extend array if necessary. */
8439	if (sc->sc_am_used >= sc->sc_am_capacity) {
8440		sc->sc_am_capacity += AM_CAPACITY;
8441		sc->sc_am = kern_realloc(sc->sc_am,
8442		    sc->sc_am_capacity * sizeof(pid_t), M_WAITOK);
8443		TRACE(2, "realloc am_capacity=%d", sc->sc_am_capacity);
8444	}
8445
8446	TRACE(2, "am[%d]=%d", sc->sc_am_used, (int)pid);
8447	sc->sc_am[sc->sc_am_used++] = pid;
8448}
8449
8450/*
8451 * Remove a process from those to be signalled on mixer activity.
8452 * If the process has not been added, do nothing.
8453 * Must be called with sc_exlock held and without sc_lock held.
8454 */
8455static void
8456mixer_async_remove(struct audio_softc *sc, pid_t pid)
8457{
8458	int i;
8459
8460	KASSERT(sc->sc_exlock);
8461
8462	for (i = 0; i < sc->sc_am_used; i++) {
8463		if (sc->sc_am[i] == pid) {
8464			sc->sc_am[i] = sc->sc_am[--sc->sc_am_used];
8465			TRACE(2, "am[%d](%d) removed, used=%d",
8466			    i, (int)pid, sc->sc_am_used);
8467
8468			/* Empty array if no longer necessary. */
8469			if (sc->sc_am_used == 0) {
8470				kern_free(sc->sc_am);
8471				sc->sc_am = NULL;
8472				sc->sc_am_capacity = 0;
8473				TRACE(2, "released");
8474			}
8475			return;
8476		}
8477	}
8478}
8479
8480/*
8481 * Signal all processes waiting for the mixer.
8482 * Must be called with sc_exlock held.
8483 */
8484static void
8485mixer_signal(struct audio_softc *sc)
8486{
8487	proc_t *p;
8488	int i;
8489
8490	KASSERT(sc->sc_exlock);
8491
8492	for (i = 0; i < sc->sc_am_used; i++) {
8493		mutex_enter(&proc_lock);
8494		p = proc_find(sc->sc_am[i]);
8495		if (p)
8496			psignal(p, SIGIO);
8497		mutex_exit(&proc_lock);
8498	}
8499}
8500
8501/*
8502 * Close a mixer device
8503 */
8504int
8505mixer_close(struct audio_softc *sc, audio_file_t *file)
8506{
8507	int error;
8508
8509	error = audio_exlock_enter(sc);
8510	if (error)
8511		return error;
8512	TRACE(1, "called");
8513	mixer_async_remove(sc, curproc->p_pid);
8514	audio_exlock_exit(sc);
8515
8516	return 0;
8517}
8518
8519/*
8520 * Must be called without sc_lock nor sc_exlock held.
8521 */
8522int
8523mixer_ioctl(struct audio_softc *sc, u_long cmd, void *addr, int flag,
8524	struct lwp *l)
8525{
8526	mixer_devinfo_t *mi;
8527	mixer_ctrl_t *mc;
8528	int val;
8529	int error;
8530
8531#if defined(AUDIO_DEBUG)
8532	char pre[64];
8533	snprintf(pre, sizeof(pre), "pid=%d.%d",
8534	    (int)curproc->p_pid, (int)l->l_lid);
8535#endif
8536	error = EINVAL;
8537
8538	/* we can return cached values if we are sleeping */
8539	if (cmd != AUDIO_MIXER_READ) {
8540		mutex_enter(sc->sc_lock);
8541		device_active(sc->sc_dev, DVA_SYSTEM);
8542		mutex_exit(sc->sc_lock);
8543	}
8544
8545	switch (cmd) {
8546	case FIOASYNC:
8547		val = *(int *)addr;
8548		TRACE(2, "%s FIOASYNC %s", pre, val ? "on" : "off");
8549		error = audio_exlock_enter(sc);
8550		if (error)
8551			break;
8552		if (val) {
8553			mixer_async_add(sc, curproc->p_pid);
8554		} else {
8555			mixer_async_remove(sc, curproc->p_pid);
8556		}
8557		audio_exlock_exit(sc);
8558		break;
8559
8560	case AUDIO_GETDEV:
8561		TRACE(2, "%s AUDIO_GETDEV", pre);
8562		error = sc->hw_if->getdev(sc->hw_hdl, (audio_device_t *)addr);
8563		break;
8564
8565	case AUDIO_MIXER_DEVINFO:
8566		TRACE(2, "%s AUDIO_MIXER_DEVINFO", pre);
8567		mi = (mixer_devinfo_t *)addr;
8568
8569		mi->un.v.delta = 0; /* default */
8570		mutex_enter(sc->sc_lock);
8571		error = audio_query_devinfo(sc, mi);
8572		mutex_exit(sc->sc_lock);
8573		break;
8574
8575	case AUDIO_MIXER_READ:
8576		TRACE(2, "%s AUDIO_MIXER_READ", pre);
8577		mc = (mixer_ctrl_t *)addr;
8578
8579		error = audio_exlock_mutex_enter(sc);
8580		if (error)
8581			break;
8582		if (device_is_active(sc->hw_dev))
8583			error = audio_get_port(sc, mc);
8584		else if (mc->dev < 0 || mc->dev >= sc->sc_nmixer_states)
8585			error = ENXIO;
8586		else {
8587			int dev = mc->dev;
8588			memcpy(mc, &sc->sc_mixer_state[dev],
8589			    sizeof(mixer_ctrl_t));
8590			error = 0;
8591		}
8592		audio_exlock_mutex_exit(sc);
8593		break;
8594
8595	case AUDIO_MIXER_WRITE:
8596		TRACE(2, "%s AUDIO_MIXER_WRITE", pre);
8597		error = audio_exlock_mutex_enter(sc);
8598		if (error)
8599			break;
8600		error = audio_set_port(sc, (mixer_ctrl_t *)addr);
8601		if (error) {
8602			audio_exlock_mutex_exit(sc);
8603			break;
8604		}
8605
8606		if (sc->hw_if->commit_settings) {
8607			error = sc->hw_if->commit_settings(sc->hw_hdl);
8608			if (error) {
8609				audio_exlock_mutex_exit(sc);
8610				break;
8611			}
8612		}
8613		mutex_exit(sc->sc_lock);
8614		mixer_signal(sc);
8615		audio_exlock_exit(sc);
8616		break;
8617
8618	default:
8619		TRACE(2, "(%lu,'%c',%lu)",
8620		    IOCPARM_LEN(cmd), (char)IOCGROUP(cmd), cmd & 0xff);
8621		if (sc->hw_if->dev_ioctl) {
8622			mutex_enter(sc->sc_lock);
8623			error = sc->hw_if->dev_ioctl(sc->hw_hdl,
8624			    cmd, addr, flag, l);
8625			mutex_exit(sc->sc_lock);
8626		} else
8627			error = EINVAL;
8628		break;
8629	}
8630
8631	if (error)
8632		TRACE(2, "error=%d", error);
8633	return error;
8634}
8635
8636/*
8637 * Must be called with sc_lock held.
8638 */
8639int
8640au_portof(struct audio_softc *sc, char *name, int class)
8641{
8642	mixer_devinfo_t mi;
8643
8644	KASSERT(mutex_owned(sc->sc_lock));
8645
8646	for (mi.index = 0; audio_query_devinfo(sc, &mi) == 0; mi.index++) {
8647		if (mi.mixer_class == class && strcmp(mi.label.name, name) == 0)
8648			return mi.index;
8649	}
8650	return -1;
8651}
8652
8653/*
8654 * Must be called with sc_lock held.
8655 */
8656void
8657au_setup_ports(struct audio_softc *sc, struct au_mixer_ports *ports,
8658	mixer_devinfo_t *mi, const struct portname *tbl)
8659{
8660	int i, j;
8661
8662	KASSERT(mutex_owned(sc->sc_lock));
8663
8664	ports->index = mi->index;
8665	if (mi->type == AUDIO_MIXER_ENUM) {
8666		ports->isenum = true;
8667		for(i = 0; tbl[i].name; i++)
8668		    for(j = 0; j < mi->un.e.num_mem; j++)
8669			if (strcmp(mi->un.e.member[j].label.name,
8670						    tbl[i].name) == 0) {
8671				ports->allports |= tbl[i].mask;
8672				ports->aumask[ports->nports] = tbl[i].mask;
8673				ports->misel[ports->nports] =
8674				    mi->un.e.member[j].ord;
8675				ports->miport[ports->nports] =
8676				    au_portof(sc, mi->un.e.member[j].label.name,
8677				    mi->mixer_class);
8678				if (ports->mixerout != -1 &&
8679				    ports->miport[ports->nports] != -1)
8680					ports->isdual = true;
8681				++ports->nports;
8682			}
8683	} else if (mi->type == AUDIO_MIXER_SET) {
8684		for(i = 0; tbl[i].name; i++)
8685		    for(j = 0; j < mi->un.s.num_mem; j++)
8686			if (strcmp(mi->un.s.member[j].label.name,
8687						tbl[i].name) == 0) {
8688				ports->allports |= tbl[i].mask;
8689				ports->aumask[ports->nports] = tbl[i].mask;
8690				ports->misel[ports->nports] =
8691				    mi->un.s.member[j].mask;
8692				ports->miport[ports->nports] =
8693				    au_portof(sc, mi->un.s.member[j].label.name,
8694				    mi->mixer_class);
8695				++ports->nports;
8696			}
8697	}
8698}
8699
8700/*
8701 * Must be called with sc_lock && sc_exlock held.
8702 */
8703int
8704au_set_lr_value(struct audio_softc *sc, mixer_ctrl_t *ct, int l, int r)
8705{
8706
8707	KASSERT(mutex_owned(sc->sc_lock));
8708	KASSERT(sc->sc_exlock);
8709
8710	ct->type = AUDIO_MIXER_VALUE;
8711	ct->un.value.num_channels = 2;
8712	ct->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = l;
8713	ct->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = r;
8714	if (audio_set_port(sc, ct) == 0)
8715		return 0;
8716	ct->un.value.num_channels = 1;
8717	ct->un.value.level[AUDIO_MIXER_LEVEL_MONO] = (l+r)/2;
8718	return audio_set_port(sc, ct);
8719}
8720
8721/*
8722 * Must be called with sc_lock && sc_exlock held.
8723 */
8724int
8725au_get_lr_value(struct audio_softc *sc, mixer_ctrl_t *ct, int *l, int *r)
8726{
8727	int error;
8728
8729	KASSERT(mutex_owned(sc->sc_lock));
8730	KASSERT(sc->sc_exlock);
8731
8732	ct->un.value.num_channels = 2;
8733	if (audio_get_port(sc, ct) == 0) {
8734		*l = ct->un.value.level[AUDIO_MIXER_LEVEL_LEFT];
8735		*r = ct->un.value.level[AUDIO_MIXER_LEVEL_RIGHT];
8736	} else {
8737		ct->un.value.num_channels = 1;
8738		error = audio_get_port(sc, ct);
8739		if (error)
8740			return error;
8741		*r = *l = ct->un.value.level[AUDIO_MIXER_LEVEL_MONO];
8742	}
8743	return 0;
8744}
8745
8746/*
8747 * Must be called with sc_lock && sc_exlock held.
8748 */
8749int
8750au_set_gain(struct audio_softc *sc, struct au_mixer_ports *ports,
8751	int gain, int balance)
8752{
8753	mixer_ctrl_t ct;
8754	int i, error;
8755	int l, r;
8756	u_int mask;
8757	int nset;
8758
8759	KASSERT(mutex_owned(sc->sc_lock));
8760	KASSERT(sc->sc_exlock);
8761
8762	if (balance == AUDIO_MID_BALANCE) {
8763		l = r = gain;
8764	} else if (balance < AUDIO_MID_BALANCE) {
8765		l = gain;
8766		r = (balance * gain) / AUDIO_MID_BALANCE;
8767	} else {
8768		r = gain;
8769		l = ((AUDIO_RIGHT_BALANCE - balance) * gain)
8770		    / AUDIO_MID_BALANCE;
8771	}
8772	TRACE(2, "gain=%d balance=%d, l=%d r=%d", gain, balance, l, r);
8773
8774	if (ports->index == -1) {
8775	usemaster:
8776		if (ports->master == -1)
8777			return 0; /* just ignore it silently */
8778		ct.dev = ports->master;
8779		error = au_set_lr_value(sc, &ct, l, r);
8780	} else {
8781		ct.dev = ports->index;
8782		if (ports->isenum) {
8783			ct.type = AUDIO_MIXER_ENUM;
8784			error = audio_get_port(sc, &ct);
8785			if (error)
8786				return error;
8787			if (ports->isdual) {
8788				if (ports->cur_port == -1)
8789					ct.dev = ports->master;
8790				else
8791					ct.dev = ports->miport[ports->cur_port];
8792				error = au_set_lr_value(sc, &ct, l, r);
8793			} else {
8794				for(i = 0; i < ports->nports; i++)
8795				    if (ports->misel[i] == ct.un.ord) {
8796					    ct.dev = ports->miport[i];
8797					    if (ct.dev == -1 ||
8798						au_set_lr_value(sc, &ct, l, r))
8799						    goto usemaster;
8800					    else
8801						    break;
8802				    }
8803			}
8804		} else {
8805			ct.type = AUDIO_MIXER_SET;
8806			error = audio_get_port(sc, &ct);
8807			if (error)
8808				return error;
8809			mask = ct.un.mask;
8810			nset = 0;
8811			for(i = 0; i < ports->nports; i++) {
8812				if (ports->misel[i] & mask) {
8813				    ct.dev = ports->miport[i];
8814				    if (ct.dev != -1 &&
8815					au_set_lr_value(sc, &ct, l, r) == 0)
8816					    nset++;
8817				}
8818			}
8819			if (nset == 0)
8820				goto usemaster;
8821		}
8822	}
8823	if (!error)
8824		mixer_signal(sc);
8825	return error;
8826}
8827
8828/*
8829 * Must be called with sc_lock && sc_exlock held.
8830 */
8831void
8832au_get_gain(struct audio_softc *sc, struct au_mixer_ports *ports,
8833	u_int *pgain, u_char *pbalance)
8834{
8835	mixer_ctrl_t ct;
8836	int i, l, r, n;
8837	int lgain, rgain;
8838
8839	KASSERT(mutex_owned(sc->sc_lock));
8840	KASSERT(sc->sc_exlock);
8841
8842	lgain = AUDIO_MAX_GAIN / 2;
8843	rgain = AUDIO_MAX_GAIN / 2;
8844	if (ports->index == -1) {
8845	usemaster:
8846		if (ports->master == -1)
8847			goto bad;
8848		ct.dev = ports->master;
8849		ct.type = AUDIO_MIXER_VALUE;
8850		if (au_get_lr_value(sc, &ct, &lgain, &rgain))
8851			goto bad;
8852	} else {
8853		ct.dev = ports->index;
8854		if (ports->isenum) {
8855			ct.type = AUDIO_MIXER_ENUM;
8856			if (audio_get_port(sc, &ct))
8857				goto bad;
8858			ct.type = AUDIO_MIXER_VALUE;
8859			if (ports->isdual) {
8860				if (ports->cur_port == -1)
8861					ct.dev = ports->master;
8862				else
8863					ct.dev = ports->miport[ports->cur_port];
8864				au_get_lr_value(sc, &ct, &lgain, &rgain);
8865			} else {
8866				for(i = 0; i < ports->nports; i++)
8867				    if (ports->misel[i] == ct.un.ord) {
8868					    ct.dev = ports->miport[i];
8869					    if (ct.dev == -1 ||
8870						au_get_lr_value(sc, &ct,
8871								&lgain, &rgain))
8872						    goto usemaster;
8873					    else
8874						    break;
8875				    }
8876			}
8877		} else {
8878			ct.type = AUDIO_MIXER_SET;
8879			if (audio_get_port(sc, &ct))
8880				goto bad;
8881			ct.type = AUDIO_MIXER_VALUE;
8882			lgain = rgain = n = 0;
8883			for(i = 0; i < ports->nports; i++) {
8884				if (ports->misel[i] & ct.un.mask) {
8885					ct.dev = ports->miport[i];
8886					if (ct.dev == -1 ||
8887					    au_get_lr_value(sc, &ct, &l, &r))
8888						goto usemaster;
8889					else {
8890						lgain += l;
8891						rgain += r;
8892						n++;
8893					}
8894				}
8895			}
8896			if (n != 0) {
8897				lgain /= n;
8898				rgain /= n;
8899			}
8900		}
8901	}
8902bad:
8903	if (lgain == rgain) {	/* handles lgain==rgain==0 */
8904		*pgain = lgain;
8905		*pbalance = AUDIO_MID_BALANCE;
8906	} else if (lgain < rgain) {
8907		*pgain = rgain;
8908		/* balance should be > AUDIO_MID_BALANCE */
8909		*pbalance = AUDIO_RIGHT_BALANCE -
8910			(AUDIO_MID_BALANCE * lgain) / rgain;
8911	} else /* lgain > rgain */ {
8912		*pgain = lgain;
8913		/* balance should be < AUDIO_MID_BALANCE */
8914		*pbalance = (AUDIO_MID_BALANCE * rgain) / lgain;
8915	}
8916}
8917
8918/*
8919 * Must be called with sc_lock && sc_exlock held.
8920 */
8921int
8922au_set_port(struct audio_softc *sc, struct au_mixer_ports *ports, u_int port)
8923{
8924	mixer_ctrl_t ct;
8925	int i, error, use_mixerout;
8926
8927	KASSERT(mutex_owned(sc->sc_lock));
8928	KASSERT(sc->sc_exlock);
8929
8930	use_mixerout = 1;
8931	if (port == 0) {
8932		if (ports->allports == 0)
8933			return 0;		/* Allow this special case. */
8934		else if (ports->isdual) {
8935			if (ports->cur_port == -1) {
8936				return 0;
8937			} else {
8938				port = ports->aumask[ports->cur_port];
8939				ports->cur_port = -1;
8940				use_mixerout = 0;
8941			}
8942		}
8943	}
8944	if (ports->index == -1)
8945		return EINVAL;
8946	ct.dev = ports->index;
8947	if (ports->isenum) {
8948		if (port & (port-1))
8949			return EINVAL; /* Only one port allowed */
8950		ct.type = AUDIO_MIXER_ENUM;
8951		error = EINVAL;
8952		for(i = 0; i < ports->nports; i++)
8953			if (ports->aumask[i] == port) {
8954				if (ports->isdual && use_mixerout) {
8955					ct.un.ord = ports->mixerout;
8956					ports->cur_port = i;
8957				} else {
8958					ct.un.ord = ports->misel[i];
8959				}
8960				error = audio_set_port(sc, &ct);
8961				break;
8962			}
8963	} else {
8964		ct.type = AUDIO_MIXER_SET;
8965		ct.un.mask = 0;
8966		for(i = 0; i < ports->nports; i++)
8967			if (ports->aumask[i] & port)
8968				ct.un.mask |= ports->misel[i];
8969		if (port != 0 && ct.un.mask == 0)
8970			error = EINVAL;
8971		else
8972			error = audio_set_port(sc, &ct);
8973	}
8974	if (!error)
8975		mixer_signal(sc);
8976	return error;
8977}
8978
8979/*
8980 * Must be called with sc_lock && sc_exlock held.
8981 */
8982int
8983au_get_port(struct audio_softc *sc, struct au_mixer_ports *ports)
8984{
8985	mixer_ctrl_t ct;
8986	int i, aumask;
8987
8988	KASSERT(mutex_owned(sc->sc_lock));
8989	KASSERT(sc->sc_exlock);
8990
8991	if (ports->index == -1)
8992		return 0;
8993	ct.dev = ports->index;
8994	ct.type = ports->isenum ? AUDIO_MIXER_ENUM : AUDIO_MIXER_SET;
8995	if (audio_get_port(sc, &ct))
8996		return 0;
8997	aumask = 0;
8998	if (ports->isenum) {
8999		if (ports->isdual && ports->cur_port != -1) {
9000			if (ports->mixerout == ct.un.ord)
9001				aumask = ports->aumask[ports->cur_port];
9002			else
9003				ports->cur_port = -1;
9004		}
9005		if (aumask == 0)
9006			for(i = 0; i < ports->nports; i++)
9007				if (ports->misel[i] == ct.un.ord)
9008					aumask = ports->aumask[i];
9009	} else {
9010		for(i = 0; i < ports->nports; i++)
9011			if (ct.un.mask & ports->misel[i])
9012				aumask |= ports->aumask[i];
9013	}
9014	return aumask;
9015}
9016
9017/*
9018 * It returns 0 if success, otherwise errno.
9019 * Must be called only if sc->sc_monitor_port != -1.
9020 * Must be called with sc_lock && sc_exlock held.
9021 */
9022static int
9023au_set_monitor_gain(struct audio_softc *sc, int monitor_gain)
9024{
9025	mixer_ctrl_t ct;
9026
9027	KASSERT(mutex_owned(sc->sc_lock));
9028	KASSERT(sc->sc_exlock);
9029
9030	ct.dev = sc->sc_monitor_port;
9031	ct.type = AUDIO_MIXER_VALUE;
9032	ct.un.value.num_channels = 1;
9033	ct.un.value.level[AUDIO_MIXER_LEVEL_MONO] = monitor_gain;
9034	return audio_set_port(sc, &ct);
9035}
9036
9037/*
9038 * It returns monitor gain if success, otherwise -1.
9039 * Must be called only if sc->sc_monitor_port != -1.
9040 * Must be called with sc_lock && sc_exlock held.
9041 */
9042static int
9043au_get_monitor_gain(struct audio_softc *sc)
9044{
9045	mixer_ctrl_t ct;
9046
9047	KASSERT(mutex_owned(sc->sc_lock));
9048	KASSERT(sc->sc_exlock);
9049
9050	ct.dev = sc->sc_monitor_port;
9051	ct.type = AUDIO_MIXER_VALUE;
9052	ct.un.value.num_channels = 1;
9053	if (audio_get_port(sc, &ct))
9054		return -1;
9055	return ct.un.value.level[AUDIO_MIXER_LEVEL_MONO];
9056}
9057
9058/*
9059 * Must be called with sc_lock && sc_exlock held.
9060 */
9061static int
9062audio_set_port(struct audio_softc *sc, mixer_ctrl_t *mc)
9063{
9064
9065	KASSERT(mutex_owned(sc->sc_lock));
9066	KASSERT(sc->sc_exlock);
9067
9068	return sc->hw_if->set_port(sc->hw_hdl, mc);
9069}
9070
9071/*
9072 * Must be called with sc_lock && sc_exlock held.
9073 */
9074static int
9075audio_get_port(struct audio_softc *sc, mixer_ctrl_t *mc)
9076{
9077
9078	KASSERT(mutex_owned(sc->sc_lock));
9079	KASSERT(sc->sc_exlock);
9080
9081	return sc->hw_if->get_port(sc->hw_hdl, mc);
9082}
9083
9084/*
9085 * Must be called with sc_lock && sc_exlock held.
9086 */
9087static void
9088audio_mixer_capture(struct audio_softc *sc)
9089{
9090	mixer_devinfo_t mi;
9091	mixer_ctrl_t *mc;
9092
9093	KASSERT(mutex_owned(sc->sc_lock));
9094	KASSERT(sc->sc_exlock);
9095
9096	for (mi.index = 0;; mi.index++) {
9097		if (audio_query_devinfo(sc, &mi) != 0)
9098			break;
9099		KASSERT(mi.index < sc->sc_nmixer_states);
9100		if (mi.type == AUDIO_MIXER_CLASS)
9101			continue;
9102		mc = &sc->sc_mixer_state[mi.index];
9103		mc->dev = mi.index;
9104		mc->type = mi.type;
9105		mc->un.value.num_channels = mi.un.v.num_channels;
9106		(void)audio_get_port(sc, mc);
9107	}
9108
9109	return;
9110}
9111
9112/*
9113 * Must be called with sc_lock && sc_exlock held.
9114 */
9115static void
9116audio_mixer_restore(struct audio_softc *sc)
9117{
9118	mixer_devinfo_t mi;
9119	mixer_ctrl_t *mc;
9120
9121	KASSERT(mutex_owned(sc->sc_lock));
9122	KASSERT(sc->sc_exlock);
9123
9124	for (mi.index = 0; ; mi.index++) {
9125		if (audio_query_devinfo(sc, &mi) != 0)
9126			break;
9127		if (mi.type == AUDIO_MIXER_CLASS)
9128			continue;
9129		mc = &sc->sc_mixer_state[mi.index];
9130		(void)audio_set_port(sc, mc);
9131	}
9132	if (sc->hw_if->commit_settings)
9133		sc->hw_if->commit_settings(sc->hw_hdl);
9134
9135	return;
9136}
9137
9138static void
9139audio_volume_down(device_t dv)
9140{
9141	struct audio_softc *sc = device_private(dv);
9142	mixer_devinfo_t mi;
9143	int newgain;
9144	u_int gain;
9145	u_char balance;
9146
9147	if (audio_exlock_mutex_enter(sc) != 0)
9148		return;
9149	if (sc->sc_outports.index == -1 && sc->sc_outports.master != -1) {
9150		mi.index = sc->sc_outports.master;
9151		mi.un.v.delta = 0;
9152		if (audio_query_devinfo(sc, &mi) == 0) {
9153			au_get_gain(sc, &sc->sc_outports, &gain, &balance);
9154			/*
9155			 * delta is optional. 16 gives us about 16 increments
9156			 * to reach max or minimum gain which seems reasonable
9157			 * for keyboard key presses.
9158			 */
9159			if (mi.un.v.delta == 0)
9160				mi.un.v.delta = 16;
9161			newgain = gain - mi.un.v.delta;
9162			if (newgain < AUDIO_MIN_GAIN)
9163				newgain = AUDIO_MIN_GAIN;
9164			au_set_gain(sc, &sc->sc_outports, newgain, balance);
9165		}
9166	}
9167	audio_exlock_mutex_exit(sc);
9168}
9169
9170static void
9171audio_volume_up(device_t dv)
9172{
9173	struct audio_softc *sc = device_private(dv);
9174	mixer_devinfo_t mi;
9175	u_int gain, newgain;
9176	u_char balance;
9177
9178	if (audio_exlock_mutex_enter(sc) != 0)
9179		return;
9180	if (sc->sc_outports.index == -1 && sc->sc_outports.master != -1) {
9181		mi.index = sc->sc_outports.master;
9182		mi.un.v.delta = 0;
9183		if (audio_query_devinfo(sc, &mi) == 0) {
9184			au_get_gain(sc, &sc->sc_outports, &gain, &balance);
9185			if (mi.un.v.delta == 0)
9186				mi.un.v.delta = 16;
9187			newgain = gain + mi.un.v.delta;
9188			if (newgain > AUDIO_MAX_GAIN)
9189				newgain = AUDIO_MAX_GAIN;
9190			au_set_gain(sc, &sc->sc_outports, newgain, balance);
9191		}
9192	}
9193	audio_exlock_mutex_exit(sc);
9194}
9195
9196static void
9197audio_volume_toggle(device_t dv)
9198{
9199	struct audio_softc *sc = device_private(dv);
9200	u_int gain, newgain;
9201	u_char balance;
9202
9203	if (audio_exlock_mutex_enter(sc) != 0)
9204		return;
9205	au_get_gain(sc, &sc->sc_outports, &gain, &balance);
9206	if (gain != 0) {
9207		sc->sc_lastgain = gain;
9208		newgain = 0;
9209	} else
9210		newgain = sc->sc_lastgain;
9211	au_set_gain(sc, &sc->sc_outports, newgain, balance);
9212	audio_exlock_mutex_exit(sc);
9213}
9214
9215/*
9216 * Must be called with sc_lock held.
9217 */
9218static int
9219audio_query_devinfo(struct audio_softc *sc, mixer_devinfo_t *di)
9220{
9221
9222	KASSERT(mutex_owned(sc->sc_lock));
9223
9224	return sc->hw_if->query_devinfo(sc->hw_hdl, di);
9225}
9226
9227void
9228audio_mixsample_to_linear(audio_filter_arg_t *arg)
9229{
9230	const audio_format2_t *fmt;
9231	const aint2_t *m;
9232	uint8_t *p;
9233	u_int sample_count;
9234	aint2_t v, xor;
9235	u_int i, bps;
9236	bool little;
9237
9238	DIAGNOSTIC_filter_arg(arg);
9239	KASSERT(audio_format2_is_linear(arg->dstfmt));
9240	KASSERT(arg->srcfmt->channels == arg->dstfmt->channels);
9241
9242	fmt = arg->dstfmt;
9243	m = arg->src;
9244	p = arg->dst;
9245	sample_count = arg->count * fmt->channels;
9246	little = arg->dstfmt->encoding == AUDIO_ENCODING_SLINEAR_LE;
9247
9248	bps = fmt->stride / NBBY;
9249	xor = audio_format2_is_signed(fmt) ? 0 : (aint2_t)1 << 31;
9250
9251#if AUDIO_INTERNAL_BITS == 16
9252	if (little) {
9253		switch (bps) {
9254		case 4:
9255			for (i=0; i<sample_count; ++i) {
9256				v = *m++ ^ xor;
9257				*p++ = 0;
9258				*p++ = 0;
9259				*p++ = v;
9260				*p++ = v >> 8;
9261			}
9262			break;
9263		case 3:
9264			for (i=0; i<sample_count; ++i) {
9265				v = *m++ ^ xor;
9266				*p++ = 0;
9267				*p++ = v;
9268				*p++ = v >> 8;
9269			}
9270			break;
9271		case 2:
9272			for (i=0; i<sample_count; ++i) {
9273				v = *m++ ^ xor;
9274				*p++ = v;
9275				*p++ = v >> 8;
9276			}
9277			break;
9278		case 1:
9279			for (i=0; i<sample_count; ++i) {
9280				v = *m++ ^ xor;
9281				*p++ = v >> 8;
9282			}
9283			break;
9284		}
9285	} else {
9286		switch (bps) {
9287		case 4:
9288			for (i=0; i<sample_count; ++i) {
9289				v = *m++ ^ xor;
9290				*p++ = v >> 8;
9291				*p++ = v;
9292				*p++ = 0;
9293				*p++ = 0;
9294			}
9295			break;
9296		case 3:
9297			for (i=0; i<sample_count; ++i) {
9298				v = *m++ ^ xor;
9299				*p++ = v >> 8;
9300				*p++ = v;
9301				*p++ = 0;
9302			}
9303			break;
9304		case 2:
9305			for (i=0; i<sample_count; ++i) {
9306				v = *m++ ^ xor;
9307				*p++ = v >> 8;
9308				*p++ = v;
9309			}
9310			break;
9311		case 1:
9312			for (i=0; i<sample_count; ++i) {
9313				v = *m++ ^ xor;
9314				*p++ = v >> 8;
9315			}
9316			break;
9317		}
9318	}
9319#elif AUDIO_INTERNAL_BITS == 32
9320	if (little) {
9321		switch (bps) {
9322		case 4:
9323			for (i=0; i<sample_count; ++i) {
9324				v = *m++ ^ xor;
9325				*p++ = v;
9326				*p++ = v >> 8;
9327				*p++ = v >> 16;
9328				*p++ = v >> 24;
9329			}
9330			break;
9331		case 3:
9332			for (i=0; i<sample_count; ++i) {
9333				v = *m++ ^ xor;
9334				*p++ = v >> 8;
9335				*p++ = v >> 16;
9336				*p++ = v >> 24;
9337			}
9338			break;
9339		case 2:
9340			for (i=0; i<sample_count; ++i) {
9341				v = *m++ ^ xor;
9342				*p++ = v >> 16;
9343				*p++ = v >> 24;
9344			}
9345			break;
9346		case 1:
9347			for (i=0; i<sample_count; ++i) {
9348				v = *m++ ^ xor;
9349				*p++ = v >> 24;
9350			}
9351			break;
9352		}
9353	} else {
9354		switch (bps) {
9355		case 4:
9356			for (i=0; i<sample_count; ++i) {
9357				v = *m++ ^ xor;
9358				*p++ = v >> 24;
9359				*p++ = v >> 16;
9360				*p++ = v >> 8;
9361				*p++ = v;
9362			}
9363			break;
9364		case 3:
9365			for (i=0; i<sample_count; ++i) {
9366				v = *m++ ^ xor;
9367				*p++ = v >> 24;
9368				*p++ = v >> 16;
9369				*p++ = v >> 8;
9370			}
9371			break;
9372		case 2:
9373			for (i=0; i<sample_count; ++i) {
9374				v = *m++ ^ xor;
9375				*p++ = v >> 24;
9376				*p++ = v >> 16;
9377			}
9378			break;
9379		case 1:
9380			for (i=0; i<sample_count; ++i) {
9381				v = *m++ ^ xor;
9382				*p++ = v >> 24;
9383			}
9384			break;
9385		}
9386	}
9387#endif /* AUDIO_INTERNAL_BITS */
9388
9389}
9390
9391#endif /* NAUDIO > 0 */
9392
9393#if NAUDIO == 0 && (NMIDI > 0 || NMIDIBUS > 0)
9394#include <sys/param.h>
9395#include <sys/systm.h>
9396#include <sys/device.h>
9397#include <sys/audioio.h>
9398#include <dev/audio/audio_if.h>
9399#endif
9400
9401#if NAUDIO > 0 || (NMIDI > 0 || NMIDIBUS > 0)
9402int
9403audioprint(void *aux, const char *pnp)
9404{
9405	struct audio_attach_args *arg;
9406	const char *type;
9407
9408	if (pnp != NULL) {
9409		arg = aux;
9410		switch (arg->type) {
9411		case AUDIODEV_TYPE_AUDIO:
9412			type = "audio";
9413			break;
9414		case AUDIODEV_TYPE_MIDI:
9415			type = "midi";
9416			break;
9417		case AUDIODEV_TYPE_OPL:
9418			type = "opl";
9419			break;
9420		case AUDIODEV_TYPE_MPU:
9421			type = "mpu";
9422			break;
9423		case AUDIODEV_TYPE_AUX:
9424			type = "aux";
9425			break;
9426		default:
9427			panic("audioprint: unknown type %d", arg->type);
9428		}
9429		aprint_normal("%s at %s", type, pnp);
9430	}
9431	return UNCONF;
9432}
9433
9434#endif /* NAUDIO > 0 || (NMIDI > 0 || NMIDIBUS > 0) */
9435
9436#ifdef _MODULE
9437
9438devmajor_t audio_bmajor = -1, audio_cmajor = -1;
9439
9440#include "ioconf.c"
9441
9442#endif
9443
9444MODULE(MODULE_CLASS_DRIVER, audio, NULL);
9445
9446static int
9447audio_modcmd(modcmd_t cmd, void *arg)
9448{
9449	int error = 0;
9450
9451	switch (cmd) {
9452	case MODULE_CMD_INIT:
9453		/* XXX interrupt level? */
9454		audio_psref_class = psref_class_create("audio", IPL_SOFTSERIAL);
9455#ifdef _MODULE
9456		error = devsw_attach(audio_cd.cd_name, NULL, &audio_bmajor,
9457		    &audio_cdevsw, &audio_cmajor);
9458		if (error)
9459			break;
9460
9461		error = config_init_component(cfdriver_ioconf_audio,
9462		    cfattach_ioconf_audio, cfdata_ioconf_audio);
9463		if (error) {
9464			devsw_detach(NULL, &audio_cdevsw);
9465		}
9466#endif
9467		break;
9468	case MODULE_CMD_FINI:
9469#ifdef _MODULE
9470		error = config_fini_component(cfdriver_ioconf_audio,
9471		   cfattach_ioconf_audio, cfdata_ioconf_audio);
9472		if (error == 0)
9473			devsw_detach(NULL, &audio_cdevsw);
9474#endif
9475		if (error == 0)
9476			psref_class_destroy(audio_psref_class);
9477		break;
9478	default:
9479		error = ENOTTY;
9480		break;
9481	}
9482
9483	return error;
9484}
9485