/* $NetBSD: bcm2835_vcaudio.c,v 1.11 2016/10/14 20:29:45 nat Exp $ */ /*- * Copyright (c) 2013 Jared D. McNeill * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ /* * VideoCore audio interface */ #include __KERNEL_RCSID(0, "$NetBSD: bcm2835_vcaudio.c,v 1.11 2016/10/14 20:29:45 nat Exp $"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "bcm2835_vcaudioreg.h" /* levels with 5% volume step */ static int vcaudio_levels[] = { -10239, -4605, -3794, -3218, -2772, -2407, -2099, -1832, -1597, -1386, -1195, -1021, -861, -713, -575, -446, -325, -210, -102, 0, }; #define vol2db(vol) vcaudio_levels[((vol) * 20) >> 8] #define vol2vc(vol) ((uint32_t)(-(vol2db((vol)) << 8) / 100)) enum { VCAUDIO_OUTPUT_CLASS, VCAUDIO_INPUT_CLASS, VCAUDIO_OUTPUT_MASTER_VOLUME, VCAUDIO_INPUT_DAC_VOLUME, VCAUDIO_OUTPUT_AUTO_VOLUME, VCAUDIO_OUTPUT_HEADPHONE_VOLUME, VCAUDIO_OUTPUT_HDMI_VOLUME, VCAUDIO_OUTPUT_SELECT, VCAUDIO_ENUM_LAST, }; enum vcaudio_dest { VCAUDIO_DEST_AUTO = 0, VCAUDIO_DEST_HP = 1, VCAUDIO_DEST_HDMI = 2, }; /* * Maximum message size is 4000 bytes and VCHIQ can accept 16 messages. * * 4000 bytes of 16bit 48kHz stereo is approximately 21ms. * * We get complete messages at ~10ms intervals. * * Setting blocksize to 4 x 1600 means that we send approx 33ms of audio. We * prefill by two blocks before starting audio meaning we have 50ms of latency. * * Six messages of 1600 bytes was chosen working back from a desired latency of * 50ms. */ #define VCAUDIO_MSGSIZE 1600 #define VCAUDIO_NUMMSGS 4 #define VCAUDIO_BLOCKSIZE (VCAUDIO_MSGSIZE * VCAUDIO_NUMMSGS) #define VCAUDIO_BUFFERSIZE 128000 #define VCAUDIO_PREFILLCOUNT 2 struct vcaudio_softc { device_t sc_dev; device_t sc_audiodev; lwp_t *sc_lwp; kmutex_t sc_lock; kmutex_t sc_intr_lock; kcondvar_t sc_datacv; kmutex_t sc_msglock; kcondvar_t sc_msgcv; struct audio_format sc_format; struct audio_encoding_set *sc_encodings; void (*sc_pint)(void *); void *sc_pintarg; audio_params_t sc_pparam; bool sc_started; int sc_pblkcnt; // prefill block count int sc_abytes; // available bytes int sc_pbytes; // played bytes off_t sc_ppos; void *sc_pstart; void *sc_pend; int sc_pblksize; bool sc_msgdone; int sc_success; VCHI_INSTANCE_T sc_instance; VCHI_CONNECTION_T sc_connection; VCHI_SERVICE_HANDLE_T sc_service; short sc_peer_version; int sc_hwvol[3]; enum vcaudio_dest sc_dest; uint8_t sc_swvol; }; static int vcaudio_match(device_t, cfdata_t, void *); static void vcaudio_attach(device_t, device_t, void *); static int vcaudio_rescan(device_t, const char *, const int *); static void vcaudio_childdet(device_t, device_t); static int vcaudio_init(struct vcaudio_softc *); static void vcaudio_service_callback(void *, const VCHI_CALLBACK_REASON_T, void *); static int vcaudio_msg_sync(struct vcaudio_softc *, VC_AUDIO_MSG_T *, size_t); static void vcaudio_worker(void *); static int vcaudio_open(void *, int); static void vcaudio_close(void *); static int vcaudio_query_encoding(void *, struct audio_encoding *); static int vcaudio_set_params(void *, int, int, audio_params_t *, audio_params_t *, stream_filter_list_t *, stream_filter_list_t *); static int vcaudio_halt_output(void *); static int vcaudio_halt_input(void *); static int vcaudio_set_port(void *, mixer_ctrl_t *); static int vcaudio_get_port(void *, mixer_ctrl_t *); static int vcaudio_query_devinfo(void *, mixer_devinfo_t *); static int vcaudio_getdev(void *, struct audio_device *); static int vcaudio_get_props(void *); static int vcaudio_round_blocksize(void *, int, int, const audio_params_t *); static size_t vcaudio_round_buffersize(void *, int, size_t); static int vcaudio_trigger_output(void *, void *, void *, int, void (*)(void *), void *, const audio_params_t *); static int vcaudio_trigger_input(void *, void *, void *, int, void (*)(void *), void *, const audio_params_t *); static void vcaudio_get_locks(void *, kmutex_t **, kmutex_t **); static stream_filter_t *vcaudio_swvol_filter(struct audio_softc *, const audio_params_t *, const audio_params_t *); static void vcaudio_swvol_dtor(stream_filter_t *); static const struct audio_hw_if vcaudio_hw_if = { .open = vcaudio_open, .close = vcaudio_close, .query_encoding = vcaudio_query_encoding, .set_params = vcaudio_set_params, .halt_output = vcaudio_halt_output, .halt_input = vcaudio_halt_input, .getdev = vcaudio_getdev, .set_port = vcaudio_set_port, .get_port = vcaudio_get_port, .query_devinfo = vcaudio_query_devinfo, .get_props = vcaudio_get_props, .round_blocksize = vcaudio_round_blocksize, .round_buffersize = vcaudio_round_buffersize, .trigger_output = vcaudio_trigger_output, .trigger_input = vcaudio_trigger_input, .get_locks = vcaudio_get_locks, }; CFATTACH_DECL2_NEW(vcaudio, sizeof(struct vcaudio_softc), vcaudio_match, vcaudio_attach, NULL, NULL, vcaudio_rescan, vcaudio_childdet); static int vcaudio_match(device_t parent, cfdata_t match, void *aux) { struct vchiq_attach_args *vaa = aux; return !strcmp(vaa->vaa_name, "AUDS"); } static void vcaudio_attach(device_t parent, device_t self, void *aux) { struct vcaudio_softc *sc = device_private(self); int error; sc->sc_dev = self; mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE); mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_NONE); mutex_init(&sc->sc_msglock, MUTEX_DEFAULT, IPL_NONE); cv_init(&sc->sc_msgcv, "msg"); cv_init(&sc->sc_datacv, "data"); sc->sc_success = -1; error = kthread_create(PRI_BIO, KTHREAD_MPSAFE, NULL, vcaudio_worker, sc, &sc->sc_lwp, "vcaudio"); if (error) { aprint_error(": couldn't create thread (%d)\n", error); return; } aprint_naive("\n"); aprint_normal(": auds\n"); error = vcaudio_rescan(self, NULL, NULL); if (error) aprint_error_dev(self, "not configured\n"); } static int vcaudio_rescan(device_t self, const char *ifattr, const int *locs) { struct vcaudio_softc *sc = device_private(self); int error; if (ifattr_match(ifattr, "audiobus") && sc->sc_audiodev == NULL) { error = vcaudio_init(sc); if (error) { return error; } sc->sc_audiodev = audio_attach_mi(&vcaudio_hw_if, sc, sc->sc_dev); } return 0; } static void vcaudio_childdet(device_t self, device_t child) { struct vcaudio_softc *sc = device_private(self); if (sc->sc_audiodev == child) sc->sc_audiodev = NULL; } static int vcaudio_init(struct vcaudio_softc *sc) { VC_AUDIO_MSG_T msg; int error; sc->sc_swvol = 255; sc->sc_hwvol[VCAUDIO_DEST_AUTO] = 255; sc->sc_hwvol[VCAUDIO_DEST_HP] = 255; sc->sc_hwvol[VCAUDIO_DEST_HDMI] = 255; sc->sc_dest = VCAUDIO_DEST_AUTO; sc->sc_format.mode = AUMODE_PLAY|AUMODE_RECORD; sc->sc_format.encoding = AUDIO_ENCODING_SLINEAR_LE; sc->sc_format.validbits = 16; sc->sc_format.precision = 16; sc->sc_format.channels = 2; sc->sc_format.channel_mask = AUFMT_STEREO; sc->sc_format.frequency_type = 0; sc->sc_format.frequency[0] = 48000; sc->sc_format.frequency[1] = 48000; error = auconv_create_encodings(&sc->sc_format, 1, &sc->sc_encodings); if (error) { aprint_error_dev(sc->sc_dev, "couldn't create encodings (error=%d)\n", error); return error; } error = vchi_initialise(&sc->sc_instance); if (error) { aprint_error_dev(sc->sc_dev, "couldn't init vchi instance (%d)\n", error); return EIO; } error = vchi_connect(NULL, 0, sc->sc_instance); if (error) { aprint_error_dev(sc->sc_dev, "couldn't connect vchi (%d)\n", error); return EIO; } SERVICE_CREATION_T setup = { .version = VCHI_VERSION(VC_AUDIOSERV_VER), .service_id = VC_AUDIO_SERVER_NAME, .connection = &sc->sc_connection, .rx_fifo_size = 0, .tx_fifo_size = 0, .callback = vcaudio_service_callback, .callback_param = sc, .want_unaligned_bulk_rx = 1, .want_unaligned_bulk_tx = 1, .want_crc = 0, }; error = vchi_service_open(sc->sc_instance, &setup, &sc->sc_service); if (error) { aprint_error_dev(sc->sc_dev, "couldn't open service (%d)\n", error); return EIO; } vchi_get_peer_version(sc->sc_service, &sc->sc_peer_version); if (sc->sc_peer_version < 2) { aprint_error_dev(sc->sc_dev, "peer version (%d) is less than the required version (2)\n", sc->sc_peer_version); return EINVAL; } memset(&msg, 0, sizeof(msg)); msg.type = VC_AUDIO_MSG_TYPE_OPEN; error = vchi_msg_queue(sc->sc_service, &msg, sizeof(msg), VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL); if (error) { aprint_error_dev(sc->sc_dev, "couldn't send OPEN message (%d)\n", error); } memset(&msg, 0, sizeof(msg)); msg.type = VC_AUDIO_MSG_TYPE_CONFIG; msg.u.config.channels = 2; msg.u.config.samplerate = 48000; msg.u.config.bps = 16; error = vcaudio_msg_sync(sc, &msg, sizeof(msg)); if (error) { aprint_error_dev(sc->sc_dev, "couldn't send CONFIG message (%d)\n", error); } memset(&msg, 0, sizeof(msg)); msg.type = VC_AUDIO_MSG_TYPE_CONTROL; msg.u.control.volume = vol2vc(sc->sc_hwvol[sc->sc_dest]); msg.u.control.dest = sc->sc_dest; error = vcaudio_msg_sync(sc, &msg, sizeof(msg)); if (error) { aprint_error_dev(sc->sc_dev, "couldn't send CONTROL message (%d)\n", error); } vchi_service_release(sc->sc_service); return 0; } static void vcaudio_service_callback(void *priv, const VCHI_CALLBACK_REASON_T reason, void *msg_handle) { struct vcaudio_softc *sc = priv; VC_AUDIO_MSG_T msg; int32_t msglen = 0; int error; void (*intr)(void *) = NULL; void *intrarg = NULL; if (sc == NULL || reason != VCHI_CALLBACK_MSG_AVAILABLE) return; memset(&msg, 0, sizeof(msg)); error = vchi_msg_dequeue(sc->sc_service, &msg, sizeof(msg), &msglen, VCHI_FLAGS_NONE); if (error) { device_printf(sc->sc_dev, "couldn't dequeue msg (%d)\n", error); return; } switch (msg.type) { case VC_AUDIO_MSG_TYPE_RESULT: mutex_enter(&sc->sc_msglock); sc->sc_success = msg.u.result.success; sc->sc_msgdone = true; cv_broadcast(&sc->sc_msgcv); mutex_exit(&sc->sc_msglock); break; case VC_AUDIO_MSG_TYPE_COMPLETE: intr = msg.u.complete.callback; intrarg = msg.u.complete.cookie; if (intr && intrarg) { int count = msg.u.complete.count & 0xffff; int perr = (msg.u.complete.count & __BIT(30)) != 0; bool sched = false; mutex_enter(&sc->sc_intr_lock); if (count > 0) { sc->sc_pbytes += count; } if (perr && sc->sc_started) { #ifdef VCAUDIO_DEBUG device_printf(sc->sc_dev, "underrun\n"); #endif sched = true; } if (sc->sc_pbytes >= sc->sc_pblksize) { sc->sc_pbytes -= sc->sc_pblksize; sched = true; } if (sched && sc->sc_pint) { intr(intrarg); sc->sc_abytes += sc->sc_pblksize; cv_signal(&sc->sc_datacv); } mutex_exit(&sc->sc_intr_lock); } break; default: break; } } static void vcaudio_worker(void *priv) { struct vcaudio_softc *sc = priv; VC_AUDIO_MSG_T msg; void (*intr)(void *); void *intrarg; void *block; int error, resid, off, nb, count; mutex_enter(&sc->sc_intr_lock); while (true) { intr = sc->sc_pint; intrarg = sc->sc_pintarg; if (intr == NULL || intrarg == NULL) { cv_wait_sig(&sc->sc_datacv, &sc->sc_intr_lock); continue; } KASSERT(sc->sc_pblksize != 0); if (sc->sc_abytes < sc->sc_pblksize) { cv_wait_sig(&sc->sc_datacv, &sc->sc_intr_lock); continue; } count = sc->sc_pblksize; memset(&msg, 0, sizeof(msg)); msg.type = VC_AUDIO_MSG_TYPE_WRITE; msg.u.write.max_packet = VCAUDIO_MSGSIZE; msg.u.write.count = count; msg.u.write.callback = intr; msg.u.write.cookie = intrarg; msg.u.write.silence = 0; block = (uint8_t *)sc->sc_pstart + sc->sc_ppos; resid = count; off = 0; vchi_service_use(sc->sc_service); error = vchi_msg_queue(sc->sc_service, &msg, sizeof(msg), VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL); if (error) { printf("%s: failed to write (%d)\n", __func__, error); goto done; } while (resid > 0) { nb = min(resid, msg.u.write.max_packet); error = vchi_msg_queue(sc->sc_service, (char *)block + off, nb, VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL); if (error) { /* XXX What to do here? */ device_printf(sc->sc_dev, "failed to queue data (%d)\n", error); goto done; } off += nb; resid -= nb; } sc->sc_abytes -= count; sc->sc_ppos += count; if ((uint8_t *)sc->sc_pstart + sc->sc_ppos >= (uint8_t *)sc->sc_pend) sc->sc_ppos = 0; if (!sc->sc_started) { ++sc->sc_pblkcnt; if (sc->sc_pblkcnt == VCAUDIO_PREFILLCOUNT) { memset(&msg, 0, sizeof(msg)); msg.type = VC_AUDIO_MSG_TYPE_START; error = vchi_msg_queue(sc->sc_service, &msg, sizeof(msg), VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL); if (error) { device_printf(sc->sc_dev, "failed to start (%d)\n", error); goto done; } sc->sc_started = true; sc->sc_pbytes = 0; } else { intr(intrarg); sc->sc_abytes += sc->sc_pblksize; } } done: vchi_service_release(sc->sc_service); } } static int vcaudio_msg_sync(struct vcaudio_softc *sc, VC_AUDIO_MSG_T *msg, size_t msglen) { int error = 0; mutex_enter(&sc->sc_msglock); sc->sc_success = -1; sc->sc_msgdone = false; error = vchi_msg_queue(sc->sc_service, msg, msglen, VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL); if (error) { printf("%s: failed to queue message (%d)\n", __func__, error); goto done; } while (!sc->sc_msgdone) { error = cv_wait_sig(&sc->sc_msgcv, &sc->sc_msglock); if (error) break; } if (sc->sc_success != 0) error = EIO; done: mutex_exit(&sc->sc_msglock); return error; } static int vcaudio_open(void *priv, int flags) { return 0; } static void vcaudio_close(void *priv) { } static int vcaudio_query_encoding(void *priv, struct audio_encoding *ae) { struct vcaudio_softc *sc = priv; return auconv_query_encoding(sc->sc_encodings, ae); } static int vcaudio_set_params(void *priv, int setmode, int usemode, audio_params_t *play, audio_params_t *rec, stream_filter_list_t *pfil, stream_filter_list_t *rfil) { struct vcaudio_softc *sc = priv; int index; if (play && (setmode & AUMODE_PLAY)) { index = auconv_set_converter(&sc->sc_format, 1, AUMODE_PLAY, play, true, pfil); if (index < 0) return EINVAL; if (pfil->req_size > 0) play = &pfil->filters[0].param; pfil->prepend(pfil, vcaudio_swvol_filter, play); } return 0; } static int vcaudio_halt_output(void *priv) { struct vcaudio_softc *sc = priv; VC_AUDIO_MSG_T msg; int error = 0; KASSERT(mutex_owned(&sc->sc_intr_lock)); vchi_service_use(sc->sc_service); memset(&msg, 0, sizeof(msg)); msg.type = VC_AUDIO_MSG_TYPE_STOP; msg.u.stop.draining = 0; error = vchi_msg_queue(sc->sc_service, &msg, sizeof(msg), VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL); if (error) { device_printf(sc->sc_dev, "couldn't send STOP message (%d)\n", error); } vchi_service_release(sc->sc_service); sc->sc_pint = NULL; sc->sc_pintarg = NULL; sc->sc_started = false; #ifdef VCAUDIO_DEBUG device_printf(sc->sc_dev, "halting output\n"); #endif return error; } static int vcaudio_halt_input(void *priv) { return EINVAL; } static int vcaudio_set_volume(struct vcaudio_softc *sc, enum vcaudio_dest dest, int hwvol) { VC_AUDIO_MSG_T msg; int error; sc->sc_hwvol[dest] = hwvol; if (dest != sc->sc_dest) return 0; vchi_service_use(sc->sc_service); memset(&msg, 0, sizeof(msg)); msg.type = VC_AUDIO_MSG_TYPE_CONTROL; msg.u.control.volume = vol2vc(hwvol); msg.u.control.dest = dest; error = vcaudio_msg_sync(sc, &msg, sizeof(msg)); if (error) { device_printf(sc->sc_dev, "couldn't send CONTROL message (%d)\n", error); } vchi_service_release(sc->sc_service); return error; } static int vcaudio_set_port(void *priv, mixer_ctrl_t *mc) { struct vcaudio_softc *sc = priv; switch (mc->dev) { case VCAUDIO_OUTPUT_MASTER_VOLUME: case VCAUDIO_INPUT_DAC_VOLUME: sc->sc_swvol = mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT]; return 0; case VCAUDIO_OUTPUT_AUTO_VOLUME: return vcaudio_set_volume(sc, VCAUDIO_DEST_AUTO, mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT]); case VCAUDIO_OUTPUT_HEADPHONE_VOLUME: return vcaudio_set_volume(sc, VCAUDIO_DEST_HP, mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT]); case VCAUDIO_OUTPUT_HDMI_VOLUME: return vcaudio_set_volume(sc, VCAUDIO_DEST_HDMI, mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT]); case VCAUDIO_OUTPUT_SELECT: if (mc->un.ord < 0 || mc->un.ord > 2) return EINVAL; sc->sc_dest = mc->un.ord; return vcaudio_set_volume(sc, mc->un.ord, sc->sc_hwvol[mc->un.ord]); } return ENXIO; } static int vcaudio_get_port(void *priv, mixer_ctrl_t *mc) { struct vcaudio_softc *sc = priv; switch (mc->dev) { case VCAUDIO_OUTPUT_MASTER_VOLUME: case VCAUDIO_INPUT_DAC_VOLUME: mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = sc->sc_swvol; return 0; case VCAUDIO_OUTPUT_AUTO_VOLUME: mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = sc->sc_hwvol[VCAUDIO_DEST_AUTO]; return 0; case VCAUDIO_OUTPUT_HEADPHONE_VOLUME: mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = sc->sc_hwvol[VCAUDIO_DEST_HP]; return 0; case VCAUDIO_OUTPUT_HDMI_VOLUME: mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = sc->sc_hwvol[VCAUDIO_DEST_HDMI]; return 0; case VCAUDIO_OUTPUT_SELECT: mc->un.ord = sc->sc_dest; return 0; } return ENXIO; } static int vcaudio_query_devinfo(void *priv, mixer_devinfo_t *di) { switch (di->index) { case VCAUDIO_OUTPUT_CLASS: di->mixer_class = VCAUDIO_OUTPUT_CLASS; strcpy(di->label.name, AudioCoutputs); di->type = AUDIO_MIXER_CLASS; di->next = di->prev = AUDIO_MIXER_LAST; return 0; case VCAUDIO_INPUT_CLASS: di->mixer_class = VCAUDIO_INPUT_CLASS; strcpy(di->label.name, AudioCinputs); di->type = AUDIO_MIXER_CLASS; di->next = di->prev = AUDIO_MIXER_LAST; return 0; case VCAUDIO_OUTPUT_MASTER_VOLUME: di->mixer_class = VCAUDIO_OUTPUT_CLASS; strcpy(di->label.name, AudioNmaster); di->type = AUDIO_MIXER_VALUE; di->next = di->prev = AUDIO_MIXER_LAST; di->un.v.num_channels = 2; strcpy(di->un.v.units.name, AudioNvolume); return 0; case VCAUDIO_OUTPUT_AUTO_VOLUME: di->mixer_class = VCAUDIO_OUTPUT_CLASS; strcpy(di->label.name, "auto"); di->type = AUDIO_MIXER_VALUE; di->next = di->prev = AUDIO_MIXER_LAST; di->un.v.num_channels = 2; di->un.v.delta = 13; strcpy(di->un.v.units.name, AudioNvolume); return 0; case VCAUDIO_OUTPUT_HEADPHONE_VOLUME: di->mixer_class = VCAUDIO_OUTPUT_CLASS; strcpy(di->label.name, AudioNheadphone); di->type = AUDIO_MIXER_VALUE; di->next = di->prev = AUDIO_MIXER_LAST; di->un.v.num_channels = 2; di->un.v.delta = 13; strcpy(di->un.v.units.name, AudioNvolume); return 0; case VCAUDIO_OUTPUT_HDMI_VOLUME: di->mixer_class = VCAUDIO_OUTPUT_CLASS; strcpy(di->label.name, "hdmi"); di->type = AUDIO_MIXER_VALUE; di->next = di->prev = AUDIO_MIXER_LAST; di->un.v.num_channels = 2; di->un.v.delta = 13; strcpy(di->un.v.units.name, AudioNvolume); return 0; case VCAUDIO_INPUT_DAC_VOLUME: di->mixer_class = VCAUDIO_INPUT_CLASS; strcpy(di->label.name, AudioNdac); di->type = AUDIO_MIXER_VALUE; di->next = di->prev = AUDIO_MIXER_LAST; di->un.v.num_channels = 2; strcpy(di->un.v.units.name, AudioNvolume); return 0; case VCAUDIO_OUTPUT_SELECT: di->mixer_class = VCAUDIO_OUTPUT_CLASS; strcpy(di->label.name, AudioNselect); di->type = AUDIO_MIXER_ENUM; di->next = di->prev = AUDIO_MIXER_LAST; di->un.e.num_mem = 3; di->un.e.member[0].ord = 0; strcpy(di->un.e.member[0].label.name, "auto"); di->un.e.member[1].ord = 1; strcpy(di->un.e.member[1].label.name, AudioNheadphone); di->un.e.member[2].ord = 2; strcpy(di->un.e.member[2].label.name, "hdmi"); return 0; } return ENXIO; } static int vcaudio_getdev(void *priv, struct audio_device *audiodev) { struct vcaudio_softc *sc = priv; snprintf(audiodev->name, sizeof(audiodev->name), "vchiq auds"); snprintf(audiodev->version, sizeof(audiodev->version), "%d", sc->sc_peer_version); snprintf(audiodev->config, sizeof(audiodev->config), "vcaudio"); return 0; } static int vcaudio_get_props(void *priv) { return AUDIO_PROP_PLAYBACK|AUDIO_PROP_CAPTURE|AUDIO_PROP_INDEPENDENT; } static int vcaudio_round_blocksize(void *priv, int bs, int mode, const audio_params_t *params) { return VCAUDIO_BLOCKSIZE; } static size_t vcaudio_round_buffersize(void *priv, int direction, size_t bufsize) { return VCAUDIO_BUFFERSIZE; } static int vcaudio_trigger_output(void *priv, void *start, void *end, int blksize, void (*intr)(void *), void *intrarg, const audio_params_t *params) { struct vcaudio_softc *sc = priv; ASSERT_SLEEPABLE(); KASSERT(mutex_owned(&sc->sc_intr_lock)); sc->sc_pparam = *params; sc->sc_pint = intr; sc->sc_pintarg = intrarg; sc->sc_ppos = 0; sc->sc_pstart = start; sc->sc_pend = end; sc->sc_pblksize = blksize; sc->sc_pblkcnt = 0; sc->sc_pbytes = 0; sc->sc_abytes = blksize; cv_signal(&sc->sc_datacv); return 0; } static int vcaudio_trigger_input(void *priv, void *start, void *end, int blksize, void (*intr)(void *), void *intrarg, const audio_params_t *params) { return EINVAL; } static void vcaudio_get_locks(void *priv, kmutex_t **intr, kmutex_t **thread) { struct vcaudio_softc *sc = priv; *intr = &sc->sc_intr_lock; *thread = &sc->sc_lock; } static stream_filter_t * vcaudio_swvol_filter(struct audio_softc *asc, const audio_params_t *from, const audio_params_t *to) { auvolconv_filter_t *this; device_t dev = audio_get_device(asc); struct vcaudio_softc *sc = device_private(dev); this = kmem_alloc(sizeof(auvolconv_filter_t), KM_SLEEP); this->base.base.fetch_to = auvolconv_slinear16_le_fetch_to; this->base.dtor = vcaudio_swvol_dtor; this->base.set_fetcher = stream_filter_set_fetcher; this->base.set_inputbuffer = stream_filter_set_inputbuffer; this->vol = &sc->sc_swvol; return (stream_filter_t *)this; } static void vcaudio_swvol_dtor(stream_filter_t *this) { if (this) kmem_free(this, sizeof(auvolconv_filter_t)); }