Home | History | Annotate | Line # | Download | only in pad
pad.c revision 1.22.2.5
      1 /* $NetBSD: pad.c,v 1.22.2.5 2017/02/05 13:40:29 skrll Exp $ */
      2 
      3 /*-
      4  * Copyright (c) 2007 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 #include <sys/cdefs.h>
     30 __KERNEL_RCSID(0, "$NetBSD: pad.c,v 1.22.2.5 2017/02/05 13:40:29 skrll Exp $");
     31 
     32 #include <sys/types.h>
     33 #include <sys/param.h>
     34 #include <sys/conf.h>
     35 #include <sys/buf.h>
     36 #include <sys/kmem.h>
     37 #include <sys/kernel.h>
     38 #include <sys/device.h>
     39 #include <sys/proc.h>
     40 #include <sys/condvar.h>
     41 #include <sys/select.h>
     42 #include <sys/audioio.h>
     43 #include <sys/vnode.h>
     44 #include <sys/module.h>
     45 #include <sys/atomic.h>
     46 #include <sys/time.h>
     47 
     48 #include <dev/audio_if.h>
     49 #include <dev/audiovar.h>
     50 #include <dev/auconv.h>
     51 #include <dev/auvolconv.h>
     52 
     53 #include <dev/pad/padvar.h>
     54 
     55 #define PADUNIT(x)	minor(x)
     56 
     57 extern struct cfdriver pad_cd;
     58 
     59 typedef struct pad_block {
     60 	uint8_t		*pb_ptr;
     61 	int		pb_len;
     62 } pad_block_t;
     63 
     64 enum {
     65 	PAD_OUTPUT_CLASS,
     66 	PAD_INPUT_CLASS,
     67 	PAD_OUTPUT_MASTER_VOLUME,
     68 	PAD_INPUT_DAC_VOLUME,
     69 	PAD_ENUM_LAST,
     70 };
     71 
     72 static int	pad_match(device_t, cfdata_t, void *);
     73 static void	pad_attach(device_t, device_t, void *);
     74 static int	pad_detach(device_t, int);
     75 static void	pad_childdet(device_t, device_t);
     76 
     77 static int	pad_audio_open(void *, int);
     78 static int	pad_query_encoding(void *, struct audio_encoding *);
     79 static int	pad_set_params(void *, int, int,
     80 				audio_params_t *, audio_params_t *,
     81 				stream_filter_list_t *, stream_filter_list_t *);
     82 static int	pad_start_output(void *, void *, int,
     83 				    void (*)(void *), void *);
     84 static int	pad_start_input(void *, void *, int,
     85 				   void (*)(void *), void *);
     86 static int	pad_halt_output(void *);
     87 static int	pad_halt_input(void *);
     88 static int	pad_getdev(void *, struct audio_device *);
     89 static int	pad_set_port(void *, mixer_ctrl_t *);
     90 static int	pad_get_port(void *, mixer_ctrl_t *);
     91 static int	pad_query_devinfo(void *, mixer_devinfo_t *);
     92 static int	pad_get_props(void *);
     93 static int	pad_round_blocksize(void *, int, int, const audio_params_t *);
     94 static void	pad_get_locks(void *, kmutex_t **, kmutex_t **);
     95 
     96 static stream_filter_t *pad_swvol_filter_le(struct audio_softc *,
     97     const audio_params_t *, const audio_params_t *);
     98 static stream_filter_t *pad_swvol_filter_be(struct audio_softc *,
     99     const audio_params_t *, const audio_params_t *);
    100 static void	pad_swvol_dtor(stream_filter_t *);
    101 
    102 static const struct audio_hw_if pad_hw_if = {
    103 	.open = pad_audio_open,
    104 	.query_encoding = pad_query_encoding,
    105 	.set_params = pad_set_params,
    106 	.start_output = pad_start_output,
    107 	.start_input = pad_start_input,
    108 	.halt_output = pad_halt_output,
    109 	.halt_input = pad_halt_input,
    110 	.getdev = pad_getdev,
    111 	.set_port = pad_set_port,
    112 	.get_port = pad_get_port,
    113 	.query_devinfo = pad_query_devinfo,
    114 	.get_props = pad_get_props,
    115 	.round_blocksize = pad_round_blocksize,
    116 	.get_locks = pad_get_locks,
    117 };
    118 
    119 #define PAD_NFORMATS	1
    120 static const struct audio_format pad_formats[PAD_NFORMATS] = {
    121 	{ NULL, AUMODE_PLAY|AUMODE_RECORD, AUDIO_ENCODING_SLINEAR_LE, 16, 16,
    122 	  2, AUFMT_STEREO, 1, { 44100 } },
    123 };
    124 
    125 extern void	padattach(int);
    126 
    127 static int	pad_add_block(pad_softc_t *, uint8_t *, int);
    128 static int	pad_get_block(pad_softc_t *, pad_block_t *, int);
    129 
    130 dev_type_open(pad_open);
    131 dev_type_close(pad_close);
    132 dev_type_read(pad_read);
    133 
    134 const struct cdevsw pad_cdevsw = {
    135 	.d_open = pad_open,
    136 	.d_close = pad_close,
    137 	.d_read = pad_read,
    138 	.d_write = nowrite,
    139 	.d_ioctl = noioctl,
    140 	.d_stop = nostop,
    141 	.d_tty = notty,
    142 	.d_poll = nopoll,
    143 	.d_mmap = nommap,
    144 	.d_kqfilter = nokqfilter,
    145 	.d_discard = nodiscard,
    146 	.d_flag = D_OTHER | D_MPSAFE,
    147 };
    148 
    149 CFATTACH_DECL2_NEW(pad, sizeof(pad_softc_t), pad_match, pad_attach, pad_detach,
    150     NULL, NULL, pad_childdet);
    151 
    152 void
    153 padattach(int n)
    154 {
    155 	int i, err;
    156 	cfdata_t cf;
    157 
    158 	aprint_debug("pad: requested %d units\n", n);
    159 
    160 	err = config_cfattach_attach(pad_cd.cd_name, &pad_ca);
    161 	if (err) {
    162 		aprint_error("%s: couldn't register cfattach: %d\n",
    163 		    pad_cd.cd_name, err);
    164 		config_cfdriver_detach(&pad_cd);
    165 		return;
    166 	}
    167 
    168 	for (i = 0; i < n; i++) {
    169 		cf = kmem_alloc(sizeof(struct cfdata), KM_SLEEP);
    170 		if (cf == NULL) {
    171 			aprint_error("%s: couldn't allocate cfdata\n",
    172 			    pad_cd.cd_name);
    173 			continue;
    174 		}
    175 		cf->cf_name = pad_cd.cd_name;
    176 		cf->cf_atname = pad_cd.cd_name;
    177 		cf->cf_unit = i;
    178 		cf->cf_fstate = FSTATE_STAR;
    179 
    180 		(void)config_attach_pseudo(cf);
    181 	}
    182 
    183 	return;
    184 }
    185 
    186 static int
    187 pad_add_block(pad_softc_t *sc, uint8_t *blk, int blksize)
    188 {
    189 	int l;
    190 
    191 	if (sc->sc_open == 0)
    192 		return EIO;
    193 
    194 	KASSERT(mutex_owned(&sc->sc_lock));
    195 
    196 	if (sc->sc_buflen + blksize > PAD_BUFSIZE)
    197 		return ENOBUFS;
    198 
    199 	if (sc->sc_wpos + blksize <= PAD_BUFSIZE)
    200 		memcpy(sc->sc_audiobuf + sc->sc_wpos, blk, blksize);
    201 	else {
    202 		l = PAD_BUFSIZE - sc->sc_wpos;
    203 		memcpy(sc->sc_audiobuf + sc->sc_wpos, blk, l);
    204 		memcpy(sc->sc_audiobuf, blk + l, blksize - l);
    205 	}
    206 
    207 	sc->sc_wpos += blksize;
    208 	if (sc->sc_wpos > PAD_BUFSIZE)
    209 		sc->sc_wpos -= PAD_BUFSIZE;
    210 
    211 	sc->sc_buflen += blksize;
    212 
    213 	return 0;
    214 }
    215 
    216 static int
    217 pad_get_block(pad_softc_t *sc, pad_block_t *pb, int blksize)
    218 {
    219 	int l;
    220 
    221 	KASSERT(mutex_owned(&sc->sc_lock));
    222 	KASSERT(pb != NULL);
    223 
    224 	if (sc->sc_buflen < blksize)
    225 		return ERESTART;
    226 
    227 	pb->pb_ptr = (sc->sc_audiobuf + sc->sc_rpos);
    228 	if (sc->sc_rpos + blksize < PAD_BUFSIZE) {
    229 		pb->pb_len = blksize;
    230 		sc->sc_rpos += blksize;
    231 	} else {
    232 		l = PAD_BUFSIZE - sc->sc_rpos;
    233 		pb->pb_len = l;
    234 		sc->sc_rpos = 0;
    235 	}
    236 	sc->sc_buflen -= pb->pb_len;
    237 
    238 	return 0;
    239 }
    240 
    241 static int
    242 pad_match(device_t parent, cfdata_t data, void *opaque)
    243 {
    244 
    245 	return 1;
    246 }
    247 
    248 static void
    249 pad_childdet(device_t self, device_t child)
    250 {
    251 	pad_softc_t *sc = device_private(self);
    252 
    253 	sc->sc_audiodev = NULL;
    254 }
    255 
    256 static void
    257 pad_attach(device_t parent, device_t self, void *opaque)
    258 {
    259 	pad_softc_t *sc = device_private(self);
    260 
    261 	aprint_normal_dev(self, "outputs: 44100Hz, 16-bit, stereo\n");
    262 
    263 	sc->sc_dev = self;
    264 	sc->sc_open = 0;
    265 	if (auconv_create_encodings(pad_formats, PAD_NFORMATS,
    266 	    &sc->sc_encodings) != 0) {
    267 		aprint_error_dev(self, "couldn't create encodings\n");
    268 		return;
    269 	}
    270 
    271 	cv_init(&sc->sc_condvar, device_xname(self));
    272 	mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
    273 	mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_NONE);
    274 
    275 	sc->sc_swvol = 255;
    276 	sc->sc_buflen = 0;
    277 	sc->sc_rpos = sc->sc_wpos = 0;
    278 	sc->sc_audiodev = (void *)audio_attach_mi(&pad_hw_if, sc, sc->sc_dev);
    279 
    280 	if (!pmf_device_register(self, NULL, NULL))
    281 		aprint_error_dev(self, "couldn't establish power handler\n");
    282 
    283 	return;
    284 }
    285 
    286 static int
    287 pad_detach(device_t self, int flags)
    288 {
    289 	pad_softc_t *sc = device_private(self);
    290 	int cmaj, mn, rc;
    291 
    292 	cmaj = cdevsw_lookup_major(&pad_cdevsw);
    293 	mn = device_unit(self);
    294 	vdevgone(cmaj, mn, mn, VCHR);
    295 
    296 	if ((rc = config_detach_children(self, flags)) != 0)
    297 		return rc;
    298 
    299 	pmf_device_deregister(self);
    300 
    301 	mutex_destroy(&sc->sc_lock);
    302 	mutex_destroy(&sc->sc_intr_lock);
    303 	cv_destroy(&sc->sc_condvar);
    304 
    305 	auconv_delete_encodings(sc->sc_encodings);
    306 
    307 	return 0;
    308 }
    309 
    310 int
    311 pad_open(dev_t dev, int flags, int fmt, struct lwp *l)
    312 {
    313 	pad_softc_t *sc;
    314 
    315 	sc = device_lookup_private(&pad_cd, PADUNIT(dev));
    316 	if (sc == NULL)
    317 		return ENXIO;
    318 
    319 	if (atomic_swap_uint(&sc->sc_open, 1) != 0) {
    320 		return EBUSY;
    321 	}
    322 
    323 	getmicrotime(&sc->sc_last);
    324 	sc->sc_bytes_count = 0;
    325 
    326 	return 0;
    327 }
    328 
    329 int
    330 pad_close(dev_t dev, int flags, int fmt, struct lwp *l)
    331 {
    332 	pad_softc_t *sc;
    333 
    334 	sc = device_lookup_private(&pad_cd, PADUNIT(dev));
    335 	if (sc == NULL)
    336 		return ENXIO;
    337 
    338 	KASSERT(sc->sc_open > 0);
    339 	sc->sc_open = 0;
    340 
    341 	return 0;
    342 }
    343 
    344 #define PAD_BYTES_PER_SEC (44100 * sizeof(int16_t) * 2)
    345 #define TIMENEXTREAD	(20 * 1000)
    346 #define BYTESTOSLEEP ((PAD_BYTES_PER_SEC / (1000000 / TIMENEXTREAD)) + PAD_BLKSIZE)
    347 
    348 int
    349 pad_read(dev_t dev, struct uio *uio, int flags)
    350 {
    351 	struct timeval now;
    352 	uint64_t nowusec, lastusec;
    353 	pad_softc_t *sc;
    354 	pad_block_t pb;
    355 	void (*intr)(void *);
    356 	void *intrarg;
    357 	int err, wait_ticks;
    358 
    359 	sc = device_lookup_private(&pad_cd, PADUNIT(dev));
    360 	if (sc == NULL)
    361 		return ENXIO;
    362 
    363 	err = 0;
    364 
    365 	while (uio->uio_resid > 0 && !err) {
    366 		mutex_enter(&sc->sc_lock);
    367 		intr = sc->sc_intr;
    368 		intrarg = sc->sc_intrarg;
    369 
    370 		getmicrotime(&now);
    371 		nowusec = (now.tv_sec * 1000000) + now.tv_usec;
    372 		lastusec = (sc->sc_last.tv_sec * 1000000) +
    373 		     sc->sc_last.tv_usec;
    374 		if (lastusec + TIMENEXTREAD > nowusec &&
    375 		     sc->sc_bytes_count >= BYTESTOSLEEP) {
    376 			wait_ticks = (hz * ((lastusec + TIMENEXTREAD) -
    377 			     nowusec)) / 1000000;
    378 			if (wait_ticks > 0) {
    379 				kpause("padwait", TRUE, wait_ticks,
    380 				     &sc->sc_lock);
    381 			}
    382 
    383 			sc->sc_bytes_count -= BYTESTOSLEEP;
    384 			getmicrotime(&sc->sc_last);
    385 		} else if (sc->sc_bytes_count >= BYTESTOSLEEP) {
    386 			sc->sc_bytes_count -= BYTESTOSLEEP;
    387 			getmicrotime(&sc->sc_last);
    388 		} else if (lastusec + TIMENEXTREAD <= nowusec)
    389 			getmicrotime(&sc->sc_last);
    390 
    391 		err = pad_get_block(sc, &pb, min(uio->uio_resid, PAD_BLKSIZE));
    392 		if (!err) {
    393 			sc->sc_bytes_count += pb.pb_len;
    394 
    395 			mutex_exit(&sc->sc_lock);
    396 			err = uiomove(pb.pb_ptr, pb.pb_len, uio);
    397 			continue;
    398 		}
    399 
    400 		if (intr) {
    401 			mutex_enter(&sc->sc_intr_lock);
    402 			kpreempt_disable();
    403 			(*intr)(intrarg);
    404 			kpreempt_enable();
    405 			mutex_exit(&sc->sc_intr_lock);
    406 			intr = sc->sc_intr;
    407 			intrarg = sc->sc_intrarg;
    408 			err = 0;
    409 			mutex_exit(&sc->sc_lock);
    410 			continue;
    411 		}
    412 		err = cv_wait_sig(&sc->sc_condvar, &sc->sc_lock);
    413 		if (err != 0) {
    414 			mutex_exit(&sc->sc_lock);
    415 			break;
    416 		}
    417 
    418 		mutex_exit(&sc->sc_lock);
    419 	}
    420 
    421 	return err;
    422 }
    423 
    424 static int
    425 pad_audio_open(void *opaque, int flags)
    426 {
    427 	pad_softc_t *sc;
    428 	sc = opaque;
    429 
    430 	if (sc->sc_open == 0)
    431 		return EIO;
    432 
    433 	getmicrotime(&sc->sc_last);
    434 	return 0;
    435 }
    436 
    437 static int
    438 pad_query_encoding(void *opaque, struct audio_encoding *ae)
    439 {
    440 	pad_softc_t *sc;
    441 
    442 	sc = (pad_softc_t *)opaque;
    443 
    444 	KASSERT(mutex_owned(&sc->sc_lock));
    445 
    446 	return auconv_query_encoding(sc->sc_encodings, ae);
    447 }
    448 
    449 static int
    450 pad_set_params(void *opaque, int setmode, int usemode,
    451     audio_params_t *play, audio_params_t *rec,
    452     stream_filter_list_t *pfil, stream_filter_list_t *rfil)
    453 {
    454 	pad_softc_t *sc __diagused;
    455 
    456 	sc = (pad_softc_t *)opaque;
    457 
    458 	KASSERT(mutex_owned(&sc->sc_lock));
    459 
    460 	if (auconv_set_converter(pad_formats, PAD_NFORMATS, AUMODE_PLAY,
    461 	    play, true, pfil) < 0)
    462 		return EINVAL;
    463 	if (auconv_set_converter(pad_formats, PAD_NFORMATS, AUMODE_RECORD,
    464 	    rec, true, rfil) < 0)
    465 		return EINVAL;
    466 
    467 	if (pfil->req_size > 0)
    468 		play = &pfil->filters[0].param;
    469 	switch (play->encoding) {
    470 	case AUDIO_ENCODING_SLINEAR_LE:
    471 		if (play->precision == 16 && play->validbits == 16)
    472 			pfil->prepend(pfil, pad_swvol_filter_le, play);
    473 		break;
    474 	case AUDIO_ENCODING_SLINEAR_BE:
    475 		if (play->precision == 16 && play->validbits == 16)
    476 			pfil->prepend(pfil, pad_swvol_filter_be, play);
    477 		break;
    478 	default:
    479 		break;
    480 	}
    481 
    482 	return 0;
    483 }
    484 
    485 static int
    486 pad_start_output(void *opaque, void *block, int blksize,
    487     void (*intr)(void *), void *intrarg)
    488 {
    489 	pad_softc_t *sc;
    490 	int err;
    491 
    492 	sc = (pad_softc_t *)opaque;
    493 
    494 	KASSERT(mutex_owned(&sc->sc_lock));
    495 	if (!sc->sc_open)
    496 		return EIO;
    497 
    498 	sc->sc_intr = intr;
    499 	sc->sc_intrarg = intrarg;
    500 	sc->sc_blksize = blksize;
    501 
    502 	err = pad_add_block(sc, block, blksize);
    503 
    504 	cv_broadcast(&sc->sc_condvar);
    505 
    506 	return err;
    507 }
    508 
    509 static int
    510 pad_start_input(void *opaque, void *block, int blksize,
    511     void (*intr)(void *), void *intrarg)
    512 {
    513 	pad_softc_t *sc __diagused;
    514 
    515 	sc = (pad_softc_t *)opaque;
    516 
    517 	KASSERT(mutex_owned(&sc->sc_lock));
    518 
    519 	return EOPNOTSUPP;
    520 }
    521 
    522 static int
    523 pad_halt_output(void *opaque)
    524 {
    525 	pad_softc_t *sc;
    526 
    527 	sc = (pad_softc_t *)opaque;
    528 
    529 	KASSERT(mutex_owned(&sc->sc_lock));
    530 
    531 	sc->sc_intr = NULL;
    532 	sc->sc_intrarg = NULL;
    533 	sc->sc_buflen = 0;
    534 	sc->sc_rpos = sc->sc_wpos = 0;
    535 
    536 	return 0;
    537 }
    538 
    539 static int
    540 pad_halt_input(void *opaque)
    541 {
    542 	pad_softc_t *sc __diagused;
    543 
    544 	sc = (pad_softc_t *)opaque;
    545 
    546 	KASSERT(mutex_owned(&sc->sc_lock));
    547 
    548 	return 0;
    549 }
    550 
    551 static int
    552 pad_getdev(void *opaque, struct audio_device *ret)
    553 {
    554 	strlcpy(ret->name, "Virtual Audio", sizeof(ret->name));
    555 	strlcpy(ret->version, osrelease, sizeof(ret->version));
    556 	strlcpy(ret->config, "pad", sizeof(ret->config));
    557 
    558 	return 0;
    559 }
    560 
    561 static int
    562 pad_set_port(void *opaque, mixer_ctrl_t *mc)
    563 {
    564 	pad_softc_t *sc;
    565 
    566 	sc = (pad_softc_t *)opaque;
    567 
    568 	KASSERT(mutex_owned(&sc->sc_lock));
    569 
    570 	switch (mc->dev) {
    571 	case PAD_OUTPUT_MASTER_VOLUME:
    572 	case PAD_INPUT_DAC_VOLUME:
    573 		sc->sc_swvol = mc->un.value.level[AUDIO_MIXER_LEVEL_MONO];
    574 		return 0;
    575 	}
    576 
    577 	return ENXIO;
    578 }
    579 
    580 static int
    581 pad_get_port(void *opaque, mixer_ctrl_t *mc)
    582 {
    583 	pad_softc_t *sc;
    584 
    585 	sc = (pad_softc_t *)opaque;
    586 
    587 	KASSERT(mutex_owned(&sc->sc_lock));
    588 
    589 	switch (mc->dev) {
    590 	case PAD_OUTPUT_MASTER_VOLUME:
    591 	case PAD_INPUT_DAC_VOLUME:
    592 		mc->un.value.level[AUDIO_MIXER_LEVEL_MONO] = sc->sc_swvol;
    593 		return 0;
    594 	}
    595 
    596 	return ENXIO;
    597 }
    598 
    599 static int
    600 pad_query_devinfo(void *opaque, mixer_devinfo_t *di)
    601 {
    602 	pad_softc_t *sc __diagused;
    603 
    604 	sc = (pad_softc_t *)opaque;
    605 
    606 	KASSERT(mutex_owned(&sc->sc_lock));
    607 
    608 	switch (di->index) {
    609 	case PAD_OUTPUT_CLASS:
    610 		di->mixer_class = PAD_OUTPUT_CLASS;
    611 		strcpy(di->label.name, AudioCoutputs);
    612 		di->type = AUDIO_MIXER_CLASS;
    613 		di->next = di->prev = AUDIO_MIXER_LAST;
    614 		return 0;
    615 	case PAD_INPUT_CLASS:
    616 		di->mixer_class = PAD_INPUT_CLASS;
    617 		strcpy(di->label.name, AudioCinputs);
    618 		di->type = AUDIO_MIXER_CLASS;
    619 		di->next = di->prev = AUDIO_MIXER_LAST;
    620 		return 0;
    621 	case PAD_OUTPUT_MASTER_VOLUME:
    622 		di->mixer_class = PAD_OUTPUT_CLASS;
    623 		strcpy(di->label.name, AudioNmaster);
    624 		di->type = AUDIO_MIXER_VALUE;
    625 		di->next = di->prev = AUDIO_MIXER_LAST;
    626 		di->un.v.num_channels = 1;
    627 		strcpy(di->un.v.units.name, AudioNvolume);
    628 		return 0;
    629 	case PAD_INPUT_DAC_VOLUME:
    630 		di->mixer_class = PAD_INPUT_CLASS;
    631 		strcpy(di->label.name, AudioNdac);
    632 		di->type = AUDIO_MIXER_VALUE;
    633 		di->next = di->prev = AUDIO_MIXER_LAST;
    634 		di->un.v.num_channels = 1;
    635 		strcpy(di->un.v.units.name, AudioNvolume);
    636 		return 0;
    637 	}
    638 
    639 	return ENXIO;
    640 }
    641 
    642 static int
    643 pad_get_props(void *opaque)
    644 {
    645 	pad_softc_t *sc __diagused;
    646 
    647 	sc = (pad_softc_t *)opaque;
    648 
    649 	KASSERT(mutex_owned(&sc->sc_lock));
    650 
    651 	return 0;
    652 }
    653 
    654 static int
    655 pad_round_blocksize(void *opaque, int blksize, int mode,
    656     const audio_params_t *p)
    657 {
    658 	pad_softc_t *sc __diagused;
    659 
    660 	sc = (pad_softc_t *)opaque;
    661 	KASSERT(mutex_owned(&sc->sc_lock));
    662 
    663 	return PAD_BLKSIZE;
    664 }
    665 
    666 static void
    667 pad_get_locks(void *opaque, kmutex_t **intr, kmutex_t **thread)
    668 {
    669 	pad_softc_t *sc;
    670 
    671 	sc = (pad_softc_t *)opaque;
    672 
    673 	*intr = &sc->sc_intr_lock;
    674 	*thread = &sc->sc_lock;
    675 }
    676 
    677 static stream_filter_t *
    678 pad_swvol_filter_le(struct audio_softc *asc,
    679     const audio_params_t *from, const audio_params_t *to)
    680 {
    681 	auvolconv_filter_t *this;
    682 	device_t dev = audio_get_device(asc);
    683 	struct pad_softc *sc = device_private(dev);
    684 
    685 	this = kmem_alloc(sizeof(auvolconv_filter_t), KM_SLEEP);
    686 	this->base.base.fetch_to = auvolconv_slinear16_le_fetch_to;
    687 	this->base.dtor = pad_swvol_dtor;
    688 	this->base.set_fetcher = stream_filter_set_fetcher;
    689 	this->base.set_inputbuffer = stream_filter_set_inputbuffer;
    690 	this->vol = &sc->sc_swvol;
    691 
    692 	return (stream_filter_t *)this;
    693 }
    694 
    695 static stream_filter_t *
    696 pad_swvol_filter_be(struct audio_softc *asc,
    697     const audio_params_t *from, const audio_params_t *to)
    698 {
    699 	auvolconv_filter_t *this;
    700 	device_t dev = audio_get_device(asc);
    701 	struct pad_softc *sc = device_private(dev);
    702 
    703 	this = kmem_alloc(sizeof(auvolconv_filter_t), KM_SLEEP);
    704 	this->base.base.fetch_to = auvolconv_slinear16_be_fetch_to;
    705 	this->base.dtor = pad_swvol_dtor;
    706 	this->base.set_fetcher = stream_filter_set_fetcher;
    707 	this->base.set_inputbuffer = stream_filter_set_inputbuffer;
    708 	this->vol = &sc->sc_swvol;
    709 
    710 	return (stream_filter_t *)this;
    711 }
    712 
    713 static void
    714 pad_swvol_dtor(stream_filter_t *this)
    715 {
    716 	if (this)
    717 		kmem_free(this, sizeof(auvolconv_filter_t));
    718 }
    719 
    720 #ifdef _MODULE
    721 
    722 MODULE(MODULE_CLASS_DRIVER, pad, NULL);
    723 
    724 static const struct cfiattrdata audiobuscf_iattrdata = {
    725 	"audiobus", 0, { { NULL, NULL, 0 }, }
    726 };
    727 static const struct cfiattrdata * const pad_attrs[] = {
    728 	&audiobuscf_iattrdata, NULL
    729 };
    730 
    731 CFDRIVER_DECL(pad, DV_DULL, pad_attrs);
    732 extern struct cfattach pad_ca;
    733 static int padloc[] = { -1, -1 };
    734 
    735 static struct cfdata pad_cfdata[] = {
    736 	{
    737 		.cf_name = "pad",
    738 		.cf_atname = "pad",
    739 		.cf_unit = 0,
    740 		.cf_fstate = FSTATE_STAR,
    741 		.cf_loc = padloc,
    742 		.cf_flags = 0,
    743 		.cf_pspec = NULL,
    744 	},
    745 	{ NULL, NULL, 0, 0, NULL, 0, NULL }
    746 };
    747 
    748 static int
    749 pad_modcmd(modcmd_t cmd, void *arg)
    750 {
    751 	devmajor_t cmajor = NODEVMAJOR, bmajor = NODEVMAJOR;
    752 	int error;
    753 
    754 	switch (cmd) {
    755 	case MODULE_CMD_INIT:
    756 		error = config_cfdriver_attach(&pad_cd);
    757 		if (error) {
    758 			return error;
    759 		}
    760 
    761 		error = config_cfattach_attach(pad_cd.cd_name, &pad_ca);
    762 		if (error) {
    763 			config_cfdriver_detach(&pad_cd);
    764 			aprint_error("%s: unable to register cfattach\n",
    765 				pad_cd.cd_name);
    766 
    767 			return error;
    768 		}
    769 
    770 		error = config_cfdata_attach(pad_cfdata, 1);
    771 		if (error) {
    772 			config_cfattach_detach(pad_cd.cd_name, &pad_ca);
    773 			config_cfdriver_detach(&pad_cd);
    774 			aprint_error("%s: unable to register cfdata\n",
    775 				pad_cd.cd_name);
    776 
    777 			return error;
    778 		}
    779 
    780 		error = devsw_attach(pad_cd.cd_name, NULL, &bmajor,
    781 		    &pad_cdevsw, &cmajor);
    782 		if (error) {
    783 			error = config_cfdata_detach(pad_cfdata);
    784 			if (error) {
    785 				return error;
    786 			}
    787 			config_cfattach_detach(pad_cd.cd_name, &pad_ca);
    788 			config_cfdriver_detach(&pad_cd);
    789 			aprint_error("%s: unable to register devsw\n",
    790 				pad_cd.cd_name);
    791 
    792 			return error;
    793 		}
    794 
    795 		(void)config_attach_pseudo(pad_cfdata);
    796 
    797 		return 0;
    798 	case MODULE_CMD_FINI:
    799 		error = config_cfdata_detach(pad_cfdata);
    800 		if (error) {
    801 			return error;
    802 		}
    803 
    804 		config_cfattach_detach(pad_cd.cd_name, &pad_ca);
    805 		config_cfdriver_detach(&pad_cd);
    806 		devsw_detach(NULL, &pad_cdevsw);
    807 
    808 		return 0;
    809 	default:
    810 		return ENOTTY;
    811 	}
    812 }
    813 
    814 #endif
    815