Home | History | Annotate | Line # | Download | only in broadcom
      1 /* $NetBSD: bcm2835_vcaudio.c,v 1.20 2024/02/16 15:11:38 skrll Exp $ */
      2 
      3 /*-
      4  * Copyright (c) 2013 Jared D. McNeill <jmcneill (at) invisible.ca>
      5  * All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  *
     16  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     17  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     18  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     19  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     20  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     26  * POSSIBILITY OF SUCH DAMAGE.
     27  */
     28 
     29 /*
     30  * VideoCore audio interface
     31  */
     32 
     33 #include <sys/cdefs.h>
     34 __KERNEL_RCSID(0, "$NetBSD: bcm2835_vcaudio.c,v 1.20 2024/02/16 15:11:38 skrll Exp $");
     35 
     36 #include <sys/param.h>
     37 #include <sys/types.h>
     38 #include <sys/systm.h>
     39 #include <sys/device.h>
     40 #include <sys/conf.h>
     41 #include <sys/bus.h>
     42 #include <sys/kmem.h>
     43 
     44 #include <sys/audioio.h>
     45 #include <dev/audio/audio_if.h>
     46 
     47 #include <interface/compat/vchi_bsd.h>
     48 #include <interface/vchiq_arm/vchiq_netbsd.h>
     49 #include <interface/vchi/vchi.h>
     50 
     51 #include "bcm2835_vcaudioreg.h"
     52 
     53 /* levels with 5% volume step */
     54 static int vcaudio_levels[] = {
     55 	-10239, -4605, -3794, -3218, -2772,
     56 	-2407, -2099, -1832, -1597, -1386,
     57 	-1195, -1021, -861, -713, -575,
     58 	-446, -325, -210, -102, 0,
     59 };
     60 
     61 #define vol2db(vol)	vcaudio_levels[((vol) * 20) >> 8]
     62 #define vol2vc(vol)	((uint32_t)(-(vol2db((vol)) << 8) / 100))
     63 
     64 enum {
     65 	VCAUDIO_OUTPUT_CLASS,
     66 	VCAUDIO_INPUT_CLASS,
     67 	VCAUDIO_OUTPUT_MASTER_VOLUME,
     68 	VCAUDIO_INPUT_DAC_VOLUME,
     69 	VCAUDIO_OUTPUT_AUTO_VOLUME,
     70 	VCAUDIO_OUTPUT_HEADPHONE_VOLUME,
     71 	VCAUDIO_OUTPUT_HDMI_VOLUME,
     72 	VCAUDIO_OUTPUT_SELECT,
     73 	VCAUDIO_ENUM_LAST,
     74 };
     75 
     76 enum vcaudio_dest {
     77 	VCAUDIO_DEST_AUTO = 0,
     78 	VCAUDIO_DEST_HP = 1,
     79 	VCAUDIO_DEST_HDMI = 2,
     80 };
     81 
     82 /*
     83  * Maximum message size is 4000 bytes and VCHIQ can accept 16 messages.
     84  *
     85  * 4000 bytes of 16bit 48kHz stereo is approximately 21ms.
     86  *
     87  * We get complete messages at ~10ms intervals.
     88  *
     89  * Setting blocksize to 4 x 1600 means that we send approx 33ms of audio. We
     90  * prefill by two blocks before starting audio meaning we have 50ms of latency.
     91  *
     92  * Six messages of 1600 bytes was chosen working back from a desired latency of
     93  * 50ms.
     94  */
     95 
     96 /* 40ms block of 16bit 48kHz stereo is 7680 bytes. */
     97 #define VCAUDIO_MSGSIZE		1920
     98 #define VCAUDIO_NUMMSGS		4
     99 #define VCAUDIO_BLOCKSIZE	(VCAUDIO_MSGSIZE * VCAUDIO_NUMMSGS)
    100 /* The driver seems to have no buffer size restrictions. */
    101 #define VCAUDIO_PREFILLCOUNT	2
    102 
    103 struct vcaudio_softc {
    104 	device_t			sc_dev;
    105 	device_t			sc_audiodev;
    106 
    107 	lwp_t				*sc_lwp;
    108 
    109 	kmutex_t			sc_lock;
    110 	kmutex_t			sc_intr_lock;
    111 	kcondvar_t			sc_datacv;
    112 
    113 	kmutex_t			sc_msglock;
    114 	kcondvar_t			sc_msgcv;
    115 
    116 	struct audio_format		sc_format;
    117 
    118 	void				(*sc_pint)(void *);
    119 	void				*sc_pintarg;
    120 	audio_params_t			sc_pparam;
    121 	bool				sc_started;
    122 	int				sc_pblkcnt;	// prefill block count
    123 	int				sc_abytes;	// available bytes
    124 	int				sc_pbytes;	// played bytes
    125 	off_t				sc_ppos;
    126 	void				*sc_pstart;
    127 	void				*sc_pend;
    128 	int				sc_pblksize;
    129 
    130 	bool				sc_msgdone;
    131 	int				sc_success;
    132 
    133 	VCHI_INSTANCE_T			sc_instance;
    134 	VCHI_CONNECTION_T		sc_connection;
    135 	VCHI_SERVICE_HANDLE_T		sc_service;
    136 
    137 	short				sc_peer_version;
    138 
    139 	int				sc_hwvol[3];
    140 	enum vcaudio_dest		sc_dest;
    141 
    142 	uint8_t				sc_swvol;
    143 };
    144 
    145 static int	vcaudio_match(device_t, cfdata_t, void *);
    146 static void	vcaudio_attach(device_t, device_t, void *);
    147 static int	vcaudio_rescan(device_t, const char *, const int *);
    148 static void	vcaudio_childdet(device_t, device_t);
    149 
    150 static int	vcaudio_init(struct vcaudio_softc *);
    151 static void	vcaudio_service_callback(void *,
    152     const VCHI_CALLBACK_REASON_T, void *);
    153 static int	vcaudio_msg_sync(struct vcaudio_softc *, VC_AUDIO_MSG_T *,
    154     size_t);
    155 static void	vcaudio_worker(void *);
    156 
    157 static int	vcaudio_query_format(void *, audio_format_query_t *);
    158 static int	vcaudio_set_format(void *, int,
    159     const audio_params_t *, const audio_params_t *,
    160     audio_filter_reg_t *, audio_filter_reg_t *);
    161 static int	vcaudio_halt_output(void *);
    162 static int	vcaudio_set_port(void *, mixer_ctrl_t *);
    163 static int	vcaudio_get_port(void *, mixer_ctrl_t *);
    164 static int	vcaudio_query_devinfo(void *, mixer_devinfo_t *);
    165 static int	vcaudio_getdev(void *, struct audio_device *);
    166 static int	vcaudio_get_props(void *);
    167 
    168 static int	vcaudio_round_blocksize(void *, int, int,
    169     const audio_params_t *);
    170 
    171 static int	vcaudio_trigger_output(void *, void *, void *, int,
    172     void (*)(void *), void *, const audio_params_t *);
    173 
    174 static void	vcaudio_get_locks(void *, kmutex_t **, kmutex_t **);
    175 
    176 static void vcaudio_swvol_codec(audio_filter_arg_t *);
    177 
    178 static const struct audio_hw_if vcaudio_hw_if = {
    179 	.query_format = vcaudio_query_format,
    180 	.set_format = vcaudio_set_format,
    181 	.halt_output = vcaudio_halt_output,
    182 	.getdev = vcaudio_getdev,
    183 	.set_port = vcaudio_set_port,
    184 	.get_port = vcaudio_get_port,
    185 	.query_devinfo = vcaudio_query_devinfo,
    186 	.get_props = vcaudio_get_props,
    187 	.round_blocksize = vcaudio_round_blocksize,
    188 	.trigger_output = vcaudio_trigger_output,
    189 	.get_locks = vcaudio_get_locks,
    190 };
    191 
    192 CFATTACH_DECL2_NEW(vcaudio, sizeof(struct vcaudio_softc),
    193     vcaudio_match, vcaudio_attach, NULL, NULL, vcaudio_rescan,
    194     vcaudio_childdet);
    195 
    196 static int
    197 vcaudio_match(device_t parent, cfdata_t match, void *aux)
    198 {
    199 	struct vchiq_attach_args *vaa = aux;
    200 
    201 	return !strcmp(vaa->vaa_name, "AUDS");
    202 }
    203 
    204 static void
    205 vcaudio_attach(device_t parent, device_t self, void *aux)
    206 {
    207 	struct vcaudio_softc *sc = device_private(self);
    208 	int error;
    209 
    210 	sc->sc_dev = self;
    211 	mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
    212 	mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_NONE);
    213 	mutex_init(&sc->sc_msglock, MUTEX_DEFAULT, IPL_NONE);
    214 	cv_init(&sc->sc_msgcv, "msg");
    215 	cv_init(&sc->sc_datacv, "data");
    216 	sc->sc_success = -1;
    217 
    218 	error = kthread_create(PRI_BIO, KTHREAD_MPSAFE, NULL, vcaudio_worker,
    219 	    sc, &sc->sc_lwp, "vcaudio");
    220 	if (error) {
    221 		aprint_error(": couldn't create thread (%d)\n", error);
    222 		return;
    223 	}
    224 
    225 	aprint_naive("\n");
    226 	aprint_normal(": auds\n");
    227 
    228 	error = vcaudio_rescan(self, NULL, NULL);
    229 	if (error)
    230 		aprint_error_dev(self, "not configured\n");
    231 
    232 }
    233 
    234 static int
    235 vcaudio_rescan(device_t self, const char *ifattr, const int *locs)
    236 {
    237 	struct vcaudio_softc *sc = device_private(self);
    238 	int error;
    239 
    240 	if (sc->sc_audiodev == NULL) {
    241 		error = vcaudio_init(sc);
    242 		if (error) {
    243 			return error;
    244 		}
    245 
    246 		sc->sc_audiodev = audio_attach_mi(&vcaudio_hw_if,
    247 		    sc, sc->sc_dev);
    248 	}
    249 	return 0;
    250 }
    251 
    252 static void
    253 vcaudio_childdet(device_t self, device_t child)
    254 {
    255 	struct vcaudio_softc *sc = device_private(self);
    256 
    257 	if (sc->sc_audiodev == child)
    258 		sc->sc_audiodev = NULL;
    259 }
    260 
    261 static int
    262 vcaudio_init(struct vcaudio_softc *sc)
    263 {
    264 	VC_AUDIO_MSG_T msg;
    265 	int error;
    266 
    267 	sc->sc_swvol = 255;
    268 	sc->sc_hwvol[VCAUDIO_DEST_AUTO] = 255;
    269 	sc->sc_hwvol[VCAUDIO_DEST_HP] = 255;
    270 	sc->sc_hwvol[VCAUDIO_DEST_HDMI] = 255;
    271 	sc->sc_dest = VCAUDIO_DEST_AUTO;
    272 
    273 	sc->sc_format.mode = AUMODE_PLAY;
    274 	sc->sc_format.encoding = AUDIO_ENCODING_SLINEAR_LE;
    275 	sc->sc_format.validbits = 16;
    276 	sc->sc_format.precision = 16;
    277 	sc->sc_format.channels = 2;
    278 	sc->sc_format.channel_mask = AUFMT_STEREO;
    279 	sc->sc_format.frequency_type = 0;
    280 	sc->sc_format.frequency[0] = 48000;
    281 	sc->sc_format.frequency[1] = 48000;
    282 
    283 	error = vchi_initialise(&sc->sc_instance);
    284 	if (error) {
    285 		aprint_error_dev(sc->sc_dev,
    286 		    "couldn't init vchi instance (%d)\n", error);
    287 		return EIO;
    288 	}
    289 
    290 	error = vchi_connect(NULL, 0, sc->sc_instance);
    291 	if (error) {
    292 		aprint_error_dev(sc->sc_dev,
    293 		    "couldn't connect vchi (%d)\n", error);
    294 		return EIO;
    295 	}
    296 
    297 	SERVICE_CREATION_T setup = {
    298 		.version = VCHI_VERSION(VC_AUDIOSERV_VER),
    299 		.service_id = VC_AUDIO_SERVER_NAME,
    300 		.connection = &sc->sc_connection,
    301 		.rx_fifo_size = 0,
    302 		.tx_fifo_size = 0,
    303 		.callback = vcaudio_service_callback,
    304 		.callback_param = sc,
    305 		.want_unaligned_bulk_rx = 1,
    306 		.want_unaligned_bulk_tx = 1,
    307 		.want_crc = 0,
    308 	};
    309 
    310 	error = vchi_service_open(sc->sc_instance, &setup, &sc->sc_service);
    311 	if (error) {
    312 		aprint_error_dev(sc->sc_dev, "couldn't open service (%d)\n",
    313 		    error);
    314 		return EIO;
    315 	}
    316 
    317 	vchi_get_peer_version(sc->sc_service, &sc->sc_peer_version);
    318 
    319 	if (sc->sc_peer_version < 2) {
    320 		aprint_error_dev(sc->sc_dev,
    321 		    "peer version (%d) is less than the required version (2)\n",
    322 		    sc->sc_peer_version);
    323 		return EINVAL;
    324 	}
    325 
    326 	memset(&msg, 0, sizeof(msg));
    327 	msg.type = VC_AUDIO_MSG_TYPE_OPEN;
    328 	error = vchi_msg_queue(sc->sc_service, &msg, sizeof(msg),
    329 	    VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL);
    330 	if (error) {
    331 		aprint_error_dev(sc->sc_dev,
    332 		    "couldn't send OPEN message (%d)\n", error);
    333 	}
    334 
    335 	memset(&msg, 0, sizeof(msg));
    336 	msg.type = VC_AUDIO_MSG_TYPE_CONFIG;
    337 	msg.u.config.channels = 2;
    338 	msg.u.config.samplerate = 48000;
    339 	msg.u.config.bps = 16;
    340 	error = vcaudio_msg_sync(sc, &msg, sizeof(msg));
    341 	if (error) {
    342 		aprint_error_dev(sc->sc_dev,
    343 		    "couldn't send CONFIG message (%d)\n", error);
    344 	}
    345 
    346 	memset(&msg, 0, sizeof(msg));
    347 	msg.type = VC_AUDIO_MSG_TYPE_CONTROL;
    348 	msg.u.control.volume = vol2vc(sc->sc_hwvol[sc->sc_dest]);
    349 	msg.u.control.dest = sc->sc_dest;
    350 	error = vcaudio_msg_sync(sc, &msg, sizeof(msg));
    351 	if (error) {
    352 		aprint_error_dev(sc->sc_dev,
    353 		    "couldn't send CONTROL message (%d)\n", error);
    354 	}
    355 
    356 	vchi_service_release(sc->sc_service);
    357 
    358 	return 0;
    359 }
    360 
    361 static void
    362 vcaudio_service_callback(void *priv, const VCHI_CALLBACK_REASON_T reason,
    363     void *msg_handle)
    364 {
    365 	struct vcaudio_softc *sc = priv;
    366 	VC_AUDIO_MSG_T msg;
    367 	int32_t msglen = 0;
    368 	int error;
    369 
    370 	if (sc == NULL || reason != VCHI_CALLBACK_MSG_AVAILABLE)
    371 		return;
    372 
    373 	memset(&msg, 0, sizeof(msg));
    374 	error = vchi_msg_dequeue(sc->sc_service, &msg, sizeof(msg), &msglen,
    375 	    VCHI_FLAGS_NONE);
    376 	if (error) {
    377 		device_printf(sc->sc_dev, "couldn't dequeue msg (%d)\n",
    378 		    error);
    379 		return;
    380 	}
    381 
    382 	switch (msg.type) {
    383 	case VC_AUDIO_MSG_TYPE_RESULT:
    384 		mutex_enter(&sc->sc_msglock);
    385 		sc->sc_success = msg.u.result.success;
    386 		sc->sc_msgdone = true;
    387 		cv_broadcast(&sc->sc_msgcv);
    388 		mutex_exit(&sc->sc_msglock);
    389 		break;
    390 
    391 	case VC_AUDIO_MSG_TYPE_COMPLETE:
    392 		if (msg.u.complete.cookie1 == VC_AUDIO_WRITE_COOKIE1 &&
    393 		    msg.u.complete.cookie2 == VC_AUDIO_WRITE_COOKIE2) {
    394 			int count = msg.u.complete.count & 0xffff;
    395 			int perr = (msg.u.complete.count & __BIT(30)) != 0;
    396 			bool sched = false;
    397 
    398 			mutex_enter(&sc->sc_intr_lock);
    399 
    400 			if (count > 0) {
    401 				sc->sc_pbytes += count;
    402 			}
    403 			if (perr && sc->sc_started) {
    404 #ifdef VCAUDIO_DEBUG
    405 				device_printf(sc->sc_dev, "underrun\n");
    406 #endif
    407 				sched = true;
    408 			}
    409 			if (sc->sc_pbytes >= sc->sc_pblksize) {
    410 				sc->sc_pbytes -= sc->sc_pblksize;
    411 				sched = true;
    412 			}
    413 
    414 			if (sched && sc->sc_pint) {
    415 				sc->sc_pint(sc->sc_pintarg);
    416 				sc->sc_abytes += sc->sc_pblksize;
    417 				cv_signal(&sc->sc_datacv);
    418 			}
    419 			mutex_exit(&sc->sc_intr_lock);
    420 		}
    421 		break;
    422 	default:
    423 		break;
    424 	}
    425 }
    426 
    427 static void
    428 vcaudio_worker(void *priv)
    429 {
    430 	struct vcaudio_softc *sc = priv;
    431 	VC_AUDIO_MSG_T msg;
    432 	void (*intr)(void *);
    433 	void *intrarg;
    434 	void *block;
    435 	int error, resid, off, nb, count;
    436 
    437 	mutex_enter(&sc->sc_intr_lock);
    438 
    439 	while (true) {
    440 		intr = sc->sc_pint;
    441 		intrarg = sc->sc_pintarg;
    442 
    443 		if (intr == NULL || intrarg == NULL) {
    444 			cv_wait_sig(&sc->sc_datacv, &sc->sc_intr_lock);
    445 			continue;
    446 		}
    447 
    448 		KASSERT(sc->sc_pblksize != 0);
    449 
    450 		if (sc->sc_abytes < sc->sc_pblksize) {
    451 			cv_wait_sig(&sc->sc_datacv, &sc->sc_intr_lock);
    452 			continue;
    453 		}
    454 		count = sc->sc_pblksize;
    455 
    456 		memset(&msg, 0, sizeof(msg));
    457 		msg.type = VC_AUDIO_MSG_TYPE_WRITE;
    458 		msg.u.write.max_packet = VCAUDIO_MSGSIZE;
    459 		msg.u.write.count = count;
    460 		msg.u.write.cookie1 = VC_AUDIO_WRITE_COOKIE1;
    461 		msg.u.write.cookie2 = VC_AUDIO_WRITE_COOKIE2;
    462 		msg.u.write.silence = 0;
    463 
    464 		block = (uint8_t *)sc->sc_pstart + sc->sc_ppos;
    465 		resid = count;
    466 		off = 0;
    467 
    468 		vchi_service_use(sc->sc_service);
    469 
    470 		error = vchi_msg_queue(sc->sc_service, &msg, sizeof(msg),
    471 		    VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL);
    472 		if (error) {
    473 			printf("%s: failed to write (%d)\n", __func__, error);
    474 			goto done;
    475 		}
    476 
    477 		while (resid > 0) {
    478 			nb = uimin(resid, msg.u.write.max_packet);
    479 			error = vchi_msg_queue(sc->sc_service,
    480 			    (char *)block + off, nb,
    481 			    VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL);
    482 			if (error) {
    483 				/* XXX What to do here? */
    484 				device_printf(sc->sc_dev,
    485 				    "failed to queue data (%d)\n", error);
    486 				goto done;
    487 			}
    488 			off += nb;
    489 			resid -= nb;
    490 		}
    491 
    492 		sc->sc_abytes -= count;
    493 		sc->sc_ppos += count;
    494 		if ((uint8_t *)sc->sc_pstart + sc->sc_ppos >=
    495 		    (uint8_t *)sc->sc_pend)
    496 			sc->sc_ppos = 0;
    497 
    498 		if (!sc->sc_started) {
    499 			++sc->sc_pblkcnt;
    500 
    501 			if (sc->sc_pblkcnt == VCAUDIO_PREFILLCOUNT) {
    502 
    503 				memset(&msg, 0, sizeof(msg));
    504 				msg.type = VC_AUDIO_MSG_TYPE_START;
    505 				error = vchi_msg_queue(sc->sc_service, &msg,
    506 				    sizeof(msg), VCHI_FLAGS_BLOCK_UNTIL_QUEUED,
    507 				    NULL);
    508 				if (error) {
    509 					device_printf(sc->sc_dev,
    510 					    "failed to start (%d)\n", error);
    511 					goto done;
    512 				}
    513 				sc->sc_started = true;
    514 				sc->sc_pbytes = 0;
    515 			} else {
    516 				intr(intrarg);
    517 				sc->sc_abytes += sc->sc_pblksize;
    518 			}
    519 		}
    520 
    521 done:
    522 		vchi_service_release(sc->sc_service);
    523 	}
    524 }
    525 
    526 static int
    527 vcaudio_msg_sync(struct vcaudio_softc *sc, VC_AUDIO_MSG_T *msg, size_t msglen)
    528 {
    529 	int error = 0;
    530 
    531 	mutex_enter(&sc->sc_msglock);
    532 
    533 	sc->sc_success = -1;
    534 	sc->sc_msgdone = false;
    535 
    536 	error = vchi_msg_queue(sc->sc_service, msg, msglen,
    537 	    VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL);
    538 	if (error) {
    539 		printf("%s: failed to queue message (%d)\n", __func__, error);
    540 		goto done;
    541 	}
    542 
    543 	while (!sc->sc_msgdone) {
    544 		error = cv_wait_sig(&sc->sc_msgcv, &sc->sc_msglock);
    545 		if (error)
    546 			break;
    547 	}
    548 	if (sc->sc_success != 0)
    549 		error = EIO;
    550 done:
    551 	mutex_exit(&sc->sc_msglock);
    552 
    553 	return error;
    554 }
    555 
    556 static int
    557 vcaudio_query_format(void *priv, audio_format_query_t *afp)
    558 {
    559 	struct vcaudio_softc *sc = priv;
    560 
    561 	return audio_query_format(&sc->sc_format, 1, afp);
    562 }
    563 
    564 static int
    565 vcaudio_set_format(void *priv, int setmode,
    566     const audio_params_t *play, const audio_params_t *rec,
    567     audio_filter_reg_t *pfil, audio_filter_reg_t *rfil)
    568 {
    569 	struct vcaudio_softc *sc = priv;
    570 
    571 	pfil->codec = vcaudio_swvol_codec;
    572 	pfil->context = sc;
    573 
    574 	return 0;
    575 }
    576 
    577 static int
    578 vcaudio_halt_output(void *priv)
    579 {
    580 	struct vcaudio_softc *sc = priv;
    581 	VC_AUDIO_MSG_T msg;
    582 	int error = 0;
    583 
    584 	KASSERT(mutex_owned(&sc->sc_intr_lock));
    585 
    586 	vchi_service_use(sc->sc_service);
    587 	memset(&msg, 0, sizeof(msg));
    588 	msg.type = VC_AUDIO_MSG_TYPE_STOP;
    589 	msg.u.stop.draining = 0;
    590 	error = vchi_msg_queue(sc->sc_service, &msg, sizeof(msg),
    591 	    VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL);
    592 	if (error) {
    593 		device_printf(sc->sc_dev, "couldn't send STOP message (%d)\n",
    594 		    error);
    595 	}
    596 	vchi_service_release(sc->sc_service);
    597 
    598 	sc->sc_pint = NULL;
    599 	sc->sc_pintarg = NULL;
    600 	sc->sc_started = false;
    601 
    602 #ifdef VCAUDIO_DEBUG
    603 	device_printf(sc->sc_dev, "halting output\n");
    604 #endif
    605 
    606 	return error;
    607 }
    608 
    609 static int
    610 vcaudio_set_volume(struct vcaudio_softc *sc, enum vcaudio_dest dest,
    611     int hwvol)
    612 {
    613 	VC_AUDIO_MSG_T msg;
    614 	int error;
    615 
    616 	sc->sc_hwvol[dest] = hwvol;
    617 	if (dest != sc->sc_dest)
    618 		return 0;
    619 
    620 	vchi_service_use(sc->sc_service);
    621 
    622 	memset(&msg, 0, sizeof(msg));
    623 	msg.type = VC_AUDIO_MSG_TYPE_CONTROL;
    624 	msg.u.control.volume = vol2vc(hwvol);
    625 	msg.u.control.dest = dest;
    626 
    627 	error = vcaudio_msg_sync(sc, &msg, sizeof(msg));
    628 	if (error) {
    629 		device_printf(sc->sc_dev,
    630 		    "couldn't send CONTROL message (%d)\n", error);
    631 	}
    632 
    633 	vchi_service_release(sc->sc_service);
    634 
    635 	return error;
    636 }
    637 
    638 static int
    639 vcaudio_set_port(void *priv, mixer_ctrl_t *mc)
    640 {
    641 	struct vcaudio_softc *sc = priv;
    642 
    643 	switch (mc->dev) {
    644 	case VCAUDIO_OUTPUT_MASTER_VOLUME:
    645 	case VCAUDIO_INPUT_DAC_VOLUME:
    646 		sc->sc_swvol = mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT];
    647 		return 0;
    648 	case VCAUDIO_OUTPUT_AUTO_VOLUME:
    649 		return vcaudio_set_volume(sc, VCAUDIO_DEST_AUTO,
    650 		    mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT]);
    651 	case VCAUDIO_OUTPUT_HEADPHONE_VOLUME:
    652 		return vcaudio_set_volume(sc, VCAUDIO_DEST_HP,
    653 		    mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT]);
    654 	case VCAUDIO_OUTPUT_HDMI_VOLUME:
    655 		return vcaudio_set_volume(sc, VCAUDIO_DEST_HDMI,
    656 		    mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT]);
    657 	case VCAUDIO_OUTPUT_SELECT:
    658 		if (mc->un.ord < 0 || mc->un.ord > 2)
    659 			return EINVAL;
    660 		sc->sc_dest = mc->un.ord;
    661 		return vcaudio_set_volume(sc, mc->un.ord,
    662 		    sc->sc_hwvol[mc->un.ord]);
    663 	}
    664 	return ENXIO;
    665 }
    666 
    667 static int
    668 vcaudio_get_port(void *priv, mixer_ctrl_t *mc)
    669 {
    670 	struct vcaudio_softc *sc = priv;
    671 
    672 	switch (mc->dev) {
    673 	case VCAUDIO_OUTPUT_MASTER_VOLUME:
    674 	case VCAUDIO_INPUT_DAC_VOLUME:
    675 		mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
    676 		    mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
    677 		    sc->sc_swvol;
    678 		return 0;
    679 	case VCAUDIO_OUTPUT_AUTO_VOLUME:
    680 		mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
    681 		    mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
    682 		    sc->sc_hwvol[VCAUDIO_DEST_AUTO];
    683 		return 0;
    684 	case VCAUDIO_OUTPUT_HEADPHONE_VOLUME:
    685 		mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
    686 		    mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
    687 		    sc->sc_hwvol[VCAUDIO_DEST_HP];
    688 		return 0;
    689 	case VCAUDIO_OUTPUT_HDMI_VOLUME:
    690 		mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
    691 		    mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
    692 		    sc->sc_hwvol[VCAUDIO_DEST_HDMI];
    693 		return 0;
    694 	case VCAUDIO_OUTPUT_SELECT:
    695 		mc->un.ord = sc->sc_dest;
    696 		return 0;
    697 	}
    698 	return ENXIO;
    699 }
    700 
    701 static int
    702 vcaudio_query_devinfo(void *priv, mixer_devinfo_t *di)
    703 {
    704 	switch (di->index) {
    705 	case VCAUDIO_OUTPUT_CLASS:
    706 		di->mixer_class = VCAUDIO_OUTPUT_CLASS;
    707 		strcpy(di->label.name, AudioCoutputs);
    708 		di->type = AUDIO_MIXER_CLASS;
    709 		di->next = di->prev = AUDIO_MIXER_LAST;
    710 		return 0;
    711 	case VCAUDIO_INPUT_CLASS:
    712 		di->mixer_class = VCAUDIO_INPUT_CLASS;
    713 		strcpy(di->label.name, AudioCinputs);
    714 		di->type = AUDIO_MIXER_CLASS;
    715 		di->next = di->prev = AUDIO_MIXER_LAST;
    716 		return 0;
    717 	case VCAUDIO_OUTPUT_MASTER_VOLUME:
    718 		di->mixer_class = VCAUDIO_OUTPUT_CLASS;
    719 		strcpy(di->label.name, AudioNmaster);
    720 		di->type = AUDIO_MIXER_VALUE;
    721 		di->next = di->prev = AUDIO_MIXER_LAST;
    722 		di->un.v.num_channels = 2;
    723 		strcpy(di->un.v.units.name, AudioNvolume);
    724 		return 0;
    725 	case VCAUDIO_OUTPUT_AUTO_VOLUME:
    726 		di->mixer_class = VCAUDIO_OUTPUT_CLASS;
    727 		strcpy(di->label.name, "auto");
    728 		di->type = AUDIO_MIXER_VALUE;
    729 		di->next = di->prev = AUDIO_MIXER_LAST;
    730 		di->un.v.num_channels = 2;
    731 		di->un.v.delta = 13;
    732 		strcpy(di->un.v.units.name, AudioNvolume);
    733 		return 0;
    734 	case VCAUDIO_OUTPUT_HEADPHONE_VOLUME:
    735 		di->mixer_class = VCAUDIO_OUTPUT_CLASS;
    736 		strcpy(di->label.name, AudioNheadphone);
    737 		di->type = AUDIO_MIXER_VALUE;
    738 		di->next = di->prev = AUDIO_MIXER_LAST;
    739 		di->un.v.num_channels = 2;
    740 		di->un.v.delta = 13;
    741 		strcpy(di->un.v.units.name, AudioNvolume);
    742 		return 0;
    743 	case VCAUDIO_OUTPUT_HDMI_VOLUME:
    744 		di->mixer_class = VCAUDIO_OUTPUT_CLASS;
    745 		strcpy(di->label.name, "hdmi");
    746 		di->type = AUDIO_MIXER_VALUE;
    747 		di->next = di->prev = AUDIO_MIXER_LAST;
    748 		di->un.v.num_channels = 2;
    749 		di->un.v.delta = 13;
    750 		strcpy(di->un.v.units.name, AudioNvolume);
    751 		return 0;
    752 	case VCAUDIO_INPUT_DAC_VOLUME:
    753 		di->mixer_class = VCAUDIO_INPUT_CLASS;
    754 		strcpy(di->label.name, AudioNdac);
    755 		di->type = AUDIO_MIXER_VALUE;
    756 		di->next = di->prev = AUDIO_MIXER_LAST;
    757 		di->un.v.num_channels = 2;
    758 		strcpy(di->un.v.units.name, AudioNvolume);
    759 		return 0;
    760 	case VCAUDIO_OUTPUT_SELECT:
    761 		di->mixer_class = VCAUDIO_OUTPUT_CLASS;
    762 		strcpy(di->label.name, AudioNselect);
    763 		di->type = AUDIO_MIXER_ENUM;
    764 		di->next = di->prev = AUDIO_MIXER_LAST;
    765 		di->un.e.num_mem = 3;
    766 		di->un.e.member[0].ord = 0;
    767 		strcpy(di->un.e.member[0].label.name, "auto");
    768 		di->un.e.member[1].ord = 1;
    769 		strcpy(di->un.e.member[1].label.name, AudioNheadphone);
    770 		di->un.e.member[2].ord = 2;
    771 		strcpy(di->un.e.member[2].label.name, "hdmi");
    772 		return 0;
    773 	}
    774 
    775 	return ENXIO;
    776 }
    777 
    778 static int
    779 vcaudio_getdev(void *priv, struct audio_device *audiodev)
    780 {
    781 	struct vcaudio_softc *sc = priv;
    782 
    783 	snprintf(audiodev->name, sizeof(audiodev->name), "vchiq auds");
    784 	snprintf(audiodev->version, sizeof(audiodev->version),
    785 	    "%d", sc->sc_peer_version);
    786 	snprintf(audiodev->config, sizeof(audiodev->config), "vcaudio");
    787 
    788 	return 0;
    789 }
    790 
    791 static int
    792 vcaudio_get_props(void *priv)
    793 {
    794 	return AUDIO_PROP_PLAYBACK;
    795 }
    796 
    797 static int
    798 vcaudio_round_blocksize(void *priv, int bs, int mode,
    799     const audio_params_t *params)
    800 {
    801 	return VCAUDIO_BLOCKSIZE;
    802 }
    803 
    804 static int
    805 vcaudio_trigger_output(void *priv, void *start, void *end, int blksize,
    806     void (*intr)(void *), void *intrarg, const audio_params_t *params)
    807 {
    808 	struct vcaudio_softc *sc = priv;
    809 
    810 	ASSERT_SLEEPABLE();
    811 	KASSERT(mutex_owned(&sc->sc_intr_lock));
    812 
    813 	sc->sc_pparam = *params;
    814 	sc->sc_pint = intr;
    815 	sc->sc_pintarg = intrarg;
    816 	sc->sc_ppos = 0;
    817 	sc->sc_pstart = start;
    818 	sc->sc_pend = end;
    819 	sc->sc_pblksize = blksize;
    820 	sc->sc_pblkcnt = 0;
    821 	sc->sc_pbytes = 0;
    822 	sc->sc_abytes = blksize;
    823 
    824 	cv_signal(&sc->sc_datacv);
    825 
    826 	return 0;
    827 }
    828 
    829 static void
    830 vcaudio_get_locks(void *priv, kmutex_t **intr, kmutex_t **thread)
    831 {
    832 	struct vcaudio_softc *sc = priv;
    833 
    834 	*intr = &sc->sc_intr_lock;
    835 	*thread = &sc->sc_lock;
    836 }
    837 
    838 static void
    839 vcaudio_swvol_codec(audio_filter_arg_t *arg)
    840 {
    841 	struct vcaudio_softc *sc = arg->context;
    842 	const aint_t *src;
    843 	int16_t *dst;
    844 	u_int sample_count;
    845 	u_int i;
    846 
    847 	src = arg->src;
    848 	dst = arg->dst;
    849 	sample_count = arg->count * arg->srcfmt->channels;
    850 	for (i = 0; i < sample_count; i++) {
    851 		aint2_t v = (aint2_t)(*src++);
    852 		v = v * sc->sc_swvol / 255;
    853 		*dst++ = (aint_t)v;
    854 	}
    855 }
    856