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@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
vcaudio_match(device_t parent,cfdata_t match,void * aux)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
vcaudio_attach(device_t parent,device_t self,void * aux)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
vcaudio_rescan(device_t self,const char * ifattr,const int * locs)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
vcaudio_childdet(device_t self,device_t child)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
vcaudio_init(struct vcaudio_softc * sc)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
vcaudio_service_callback(void * priv,const VCHI_CALLBACK_REASON_T reason,void * msg_handle)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
vcaudio_worker(void * priv)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
vcaudio_msg_sync(struct vcaudio_softc * sc,VC_AUDIO_MSG_T * msg,size_t msglen)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
vcaudio_query_format(void * priv,audio_format_query_t * afp)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
vcaudio_set_format(void * priv,int setmode,const audio_params_t * play,const audio_params_t * rec,audio_filter_reg_t * pfil,audio_filter_reg_t * rfil)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
vcaudio_halt_output(void * priv)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
vcaudio_set_volume(struct vcaudio_softc * sc,enum vcaudio_dest dest,int hwvol)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
vcaudio_set_port(void * priv,mixer_ctrl_t * mc)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
vcaudio_get_port(void * priv,mixer_ctrl_t * mc)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
vcaudio_query_devinfo(void * priv,mixer_devinfo_t * di)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
vcaudio_getdev(void * priv,struct audio_device * audiodev)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
vcaudio_get_props(void * priv)792 vcaudio_get_props(void *priv)
793 {
794 return AUDIO_PROP_PLAYBACK;
795 }
796
797 static int
vcaudio_round_blocksize(void * priv,int bs,int mode,const audio_params_t * params)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
vcaudio_trigger_output(void * priv,void * start,void * end,int blksize,void (* intr)(void *),void * intrarg,const audio_params_t * params)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
vcaudio_get_locks(void * priv,kmutex_t ** intr,kmutex_t ** thread)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
vcaudio_swvol_codec(audio_filter_arg_t * arg)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