Home | History | Annotate | Line # | Download | only in pad
pad.c revision 1.58.2.3
      1 /* $NetBSD: pad.c,v 1.58.2.3 2019/05/05 02:01:34 isaki 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.58.2.3 2019/05/05 02:01:34 isaki 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/audio_if.h>
     49 #include <dev/audio/audiovar.h>
     50 
     51 #include <dev/pad/padvar.h>
     52 
     53 /* #define PAD_DEBUG */
     54 #ifdef PAD_DEBUG
     55 #define DPRINTF(fmt...)	printf(fmt)
     56 #else
     57 #define DPRINTF(fmt...) /**/
     58 #endif
     59 
     60 #define PADUNIT(x)	minor(x)
     61 
     62 #define PADFREQ		44100
     63 #define PADCHAN		2
     64 #define PADPREC		16
     65 
     66 extern struct cfdriver pad_cd;
     67 
     68 typedef struct pad_block {
     69 	uint8_t		*pb_ptr;
     70 	int		pb_len;
     71 } pad_block_t;
     72 
     73 enum {
     74 	PAD_OUTPUT_CLASS,
     75 	PAD_INPUT_CLASS,
     76 	PAD_OUTPUT_MASTER_VOLUME,
     77 	PAD_INPUT_DAC_VOLUME,
     78 	PAD_ENUM_LAST,
     79 };
     80 
     81 static int	pad_match(device_t, cfdata_t, void *);
     82 static void	pad_attach(device_t, device_t, void *);
     83 static int	pad_detach(device_t, int);
     84 static void	pad_childdet(device_t, device_t);
     85 
     86 static int	pad_query_format(void *, audio_format_query_t *);
     87 static int	pad_set_format(void *, int,
     88 				const audio_params_t *, const audio_params_t *,
     89 			    audio_filter_reg_t *, audio_filter_reg_t *);
     90 static int	pad_start_output(void *, void *, int,
     91 				    void (*)(void *), void *);
     92 static int	pad_start_input(void *, void *, int,
     93 				   void (*)(void *), void *);
     94 static int	pad_halt_output(void *);
     95 static int	pad_halt_input(void *);
     96 static int	pad_getdev(void *, struct audio_device *);
     97 static int	pad_set_port(void *, mixer_ctrl_t *);
     98 static int	pad_get_port(void *, mixer_ctrl_t *);
     99 static int	pad_query_devinfo(void *, mixer_devinfo_t *);
    100 static int	pad_get_props(void *);
    101 static void	pad_get_locks(void *, kmutex_t **, kmutex_t **);
    102 
    103 static void	pad_done_output(void *);
    104 static void	pad_swvol_codec(audio_filter_arg_t *);
    105 
    106 static bool	pad_is_attached;	/* Do we have an audio* child? */
    107 
    108 static const struct audio_hw_if pad_hw_if = {
    109 	.query_format = pad_query_format,
    110 	.set_format = pad_set_format,
    111 	.start_output = pad_start_output,
    112 	.start_input = pad_start_input,
    113 	.halt_output = pad_halt_output,
    114 	.halt_input = pad_halt_input,
    115 	.getdev = pad_getdev,
    116 	.set_port = pad_set_port,
    117 	.get_port = pad_get_port,
    118 	.query_devinfo = pad_query_devinfo,
    119 	.get_props = pad_get_props,
    120 	.get_locks = pad_get_locks,
    121 };
    122 
    123 #define PAD_NFORMATS	1
    124 #if defined(PAD_SUPPORT_RECORD)
    125 #define PADMODE	(AUMODE_PLAY | AUMODE_RECORD)
    126 #else
    127 #define PADMODE	AUMODE_PLAY
    128 #endif
    129 static const struct audio_format pad_formats[PAD_NFORMATS] = {
    130 	{
    131 		.mode		= PADMODE,
    132 		.encoding	= AUDIO_ENCODING_SLINEAR_NE,
    133 		.validbits	= PADPREC,
    134 		.precision	= PADPREC,
    135 		.channels	= PADCHAN,
    136 		.channel_mask	= AUFMT_STEREO,
    137 		.frequency_type	= 1,
    138 		.frequency	= { PADFREQ },
    139 	},
    140 };
    141 
    142 extern void	padattach(int);
    143 
    144 static int	pad_add_block(pad_softc_t *, uint8_t *, int);
    145 static int	pad_get_block(pad_softc_t *, pad_block_t *, int);
    146 
    147 dev_type_open(pad_dev_open);
    148 dev_type_close(pad_dev_close);
    149 dev_type_read(pad_dev_read);
    150 
    151 const struct cdevsw pad_cdevsw = {
    152 	.d_open = pad_dev_open,
    153 	.d_close = pad_dev_close,
    154 	.d_read = pad_dev_read,
    155 	.d_write = nowrite,
    156 	.d_ioctl = noioctl,
    157 	.d_stop = nostop,
    158 	.d_tty = notty,
    159 	.d_poll = nopoll,
    160 	.d_mmap = nommap,
    161 	.d_kqfilter = nokqfilter,
    162 	.d_discard = nodiscard,
    163 	.d_flag = D_OTHER | D_MPSAFE,
    164 };
    165 
    166 CFATTACH_DECL2_NEW(pad, sizeof(pad_softc_t), pad_match, pad_attach, pad_detach,
    167     NULL, NULL, pad_childdet);
    168 
    169 void
    170 padattach(int n)
    171 {
    172 	int i, err;
    173 	cfdata_t cf;
    174 
    175 	aprint_debug("pad: requested %d units\n", n);
    176 	DPRINTF("%s: requested %d units\n", __func__, n);
    177 
    178 	err = config_cfattach_attach(pad_cd.cd_name, &pad_ca);
    179 	if (err) {
    180 		aprint_error("%s: couldn't register cfattach: %d\n",
    181 		    pad_cd.cd_name, err);
    182 		config_cfdriver_detach(&pad_cd);
    183 		return;
    184 	}
    185 
    186 	for (i = 0; i < n; i++) {
    187 		cf = kmem_alloc(sizeof(struct cfdata), KM_SLEEP);
    188 		cf->cf_name = pad_cd.cd_name;
    189 		cf->cf_atname = pad_cd.cd_name;
    190 		cf->cf_unit = i;
    191 		cf->cf_fstate = FSTATE_STAR;
    192 
    193 		(void)config_attach_pseudo(cf);
    194 	}
    195 
    196 	return;
    197 }
    198 
    199 static int
    200 pad_add_block(pad_softc_t *sc, uint8_t *blk, int blksize)
    201 {
    202 	int l;
    203 
    204 	if (sc->sc_buflen + blksize > PAD_BUFSIZE)
    205 		return ENOBUFS;
    206 
    207 	if (sc->sc_wpos + blksize <= PAD_BUFSIZE)
    208 		memcpy(sc->sc_audiobuf + sc->sc_wpos, blk, blksize);
    209 	else {
    210 		l = PAD_BUFSIZE - sc->sc_wpos;
    211 		memcpy(sc->sc_audiobuf + sc->sc_wpos, blk, l);
    212 		memcpy(sc->sc_audiobuf, blk + l, blksize - l);
    213 	}
    214 
    215 	sc->sc_wpos += blksize;
    216 	if (sc->sc_wpos >= PAD_BUFSIZE)
    217 		sc->sc_wpos -= PAD_BUFSIZE;
    218 
    219 	sc->sc_buflen += blksize;
    220 
    221 	return 0;
    222 }
    223 
    224 static int
    225 pad_get_block(pad_softc_t *sc, pad_block_t *pb, int blksize)
    226 {
    227 	int l;
    228 
    229 	KASSERT(pb != NULL);
    230 
    231 	pb->pb_ptr = (sc->sc_audiobuf + sc->sc_rpos);
    232 	if (sc->sc_rpos + blksize < PAD_BUFSIZE) {
    233 		pb->pb_len = blksize;
    234 		sc->sc_rpos += blksize;
    235 	} else {
    236 		l = PAD_BUFSIZE - sc->sc_rpos;
    237 		pb->pb_len = l;
    238 		sc->sc_rpos = 0;
    239 	}
    240 	sc->sc_buflen -= pb->pb_len;
    241 
    242 	return 0;
    243 }
    244 
    245 static int
    246 pad_match(device_t parent, cfdata_t data, void *opaque)
    247 {
    248 
    249 	return 1;
    250 }
    251 
    252 static void
    253 pad_childdet(device_t self, device_t child)
    254 {
    255 	pad_softc_t *sc = device_private(self);
    256 
    257 	sc->sc_audiodev = NULL;
    258 }
    259 
    260 static void
    261 pad_attach(device_t parent, device_t self, void *opaque)
    262 {
    263 	pad_softc_t *sc = device_private(self);
    264 
    265 	aprint_normal_dev(self, "outputs: 44100Hz, 16-bit, stereo\n");
    266 
    267 	sc->sc_dev = self;
    268 	sc->sc_open = 0;
    269 
    270 	cv_init(&sc->sc_condvar, device_xname(self));
    271 	mutex_init(&sc->sc_cond_lock, MUTEX_DEFAULT, IPL_NONE);
    272 	mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
    273 	mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_NONE);
    274 	callout_init(&sc->sc_pcallout, 0/*XXX?*/);
    275 
    276 	sc->sc_swvol = 255;
    277 	sc->sc_buflen = 0;
    278 	sc->sc_rpos = sc->sc_wpos = 0;
    279 	sc->sc_audiodev = audio_attach_mi(&pad_hw_if, sc, sc->sc_dev);
    280 
    281 	if (!pmf_device_register(self, NULL, NULL))
    282 		aprint_error_dev(self, "couldn't establish power handler\n");
    283 
    284 	pad_is_attached = true;
    285 	return;
    286 }
    287 
    288 static int
    289 pad_detach(device_t self, int flags)
    290 {
    291 	pad_softc_t *sc = device_private(self);
    292 	int cmaj, mn, rc;
    293 
    294 	if (!pad_is_attached)
    295 		return ENXIO;
    296 
    297 	cmaj = cdevsw_lookup_major(&pad_cdevsw);
    298 	mn = device_unit(self);
    299 	vdevgone(cmaj, mn, mn, VCHR);
    300 
    301 	if ((rc = config_detach_children(self, flags)) != 0)
    302 		return rc;
    303 
    304 	pmf_device_deregister(self);
    305 
    306 	mutex_destroy(&sc->sc_lock);
    307 	mutex_destroy(&sc->sc_intr_lock);
    308 	cv_destroy(&sc->sc_condvar);
    309 	callout_destroy(&sc->sc_pcallout);
    310 
    311 	pad_is_attached = false;
    312 	return 0;
    313 }
    314 
    315 int
    316 pad_dev_open(dev_t dev, int flags, int fmt, struct lwp *l)
    317 {
    318 	pad_softc_t *sc;
    319 
    320 	sc = device_lookup_private(&pad_cd, PADUNIT(dev));
    321 	if (sc == NULL)
    322 		return ENXIO;
    323 
    324 	if (atomic_swap_uint(&sc->sc_open, 1) != 0)
    325 		return EBUSY;
    326 
    327 	DPRINTF("%s -> %d\n", __func__, sc->sc_open);
    328 
    329 	return 0;
    330 }
    331 
    332 int
    333 pad_dev_close(dev_t dev, int flags, int fmt, struct lwp *l)
    334 {
    335 	pad_softc_t *sc;
    336 
    337 	sc = device_lookup_private(&pad_cd, PADUNIT(dev));
    338 	if (sc == NULL)
    339 		return ENXIO;
    340 
    341 	KASSERT(sc->sc_open > 0);
    342 	/* XXX should this be atomic too? */
    343 	sc->sc_open = 0;
    344 	DPRINTF("%s -> %d\n", __func__, sc->sc_open);
    345 
    346 	return 0;
    347 }
    348 
    349 int
    350 pad_dev_read(dev_t dev, struct uio *uio, int flags)
    351 {
    352 	pad_softc_t *sc;
    353 	pad_block_t pb;
    354 	int len;
    355 	int err;
    356 
    357 	sc = device_lookup_private(&pad_cd, PADUNIT(dev));
    358 	if (sc == NULL)
    359 		return ENXIO;
    360 
    361 	err = 0;
    362 	DPRINTF("%s: resid=%zu\n", __func__, uio->uio_resid);
    363 	while (uio->uio_resid > 0 && !err) {
    364 		mutex_enter(&sc->sc_cond_lock);
    365 		if (sc->sc_buflen == 0) {
    366 			DPRINTF("%s: wait\n", __func__);
    367 			err = cv_wait_sig(&sc->sc_condvar, &sc->sc_cond_lock);
    368 			DPRINTF("%s: wake up %d\n", __func__, err);
    369 			mutex_exit(&sc->sc_cond_lock);
    370 			if (err) {
    371 				if (err == ERESTART)
    372 					err = EINTR;
    373 				break;
    374 			}
    375 			if (sc->sc_buflen == 0)
    376 				break;
    377 			continue;
    378 		}
    379 
    380 		len = uimin(uio->uio_resid, sc->sc_buflen);
    381 		err = pad_get_block(sc, &pb, len);
    382 		mutex_exit(&sc->sc_cond_lock);
    383 		if (err)
    384 			break;
    385 		DPRINTF("%s: move %d\n", __func__, pb.pb_len);
    386 		uiomove(pb.pb_ptr, pb.pb_len, uio);
    387 	}
    388 
    389 	return err;
    390 }
    391 
    392 static int
    393 pad_query_format(void *opaque, audio_format_query_t *afp)
    394 {
    395 
    396 	return audio_query_format(pad_formats, PAD_NFORMATS, afp);
    397 }
    398 
    399 static int
    400 pad_set_format(void *opaque, int setmode,
    401     const audio_params_t *play, const audio_params_t *rec,
    402 	audio_filter_reg_t *pfil, audio_filter_reg_t *rfil)
    403 {
    404 	pad_softc_t *sc;
    405 
    406 	sc = (pad_softc_t *)opaque;
    407 
    408 	KASSERT(mutex_owned(&sc->sc_lock));
    409 
    410 	/* XXX playback only */
    411 	pfil->codec = pad_swvol_codec;
    412 	pfil->context = sc;
    413 
    414 	return 0;
    415 }
    416 
    417 static int
    418 pad_start_output(void *opaque, void *block, int blksize,
    419     void (*intr)(void *), void *intrarg)
    420 {
    421 	pad_softc_t *sc;
    422 	int err;
    423 	int ms;
    424 
    425 	sc = (pad_softc_t *)opaque;
    426 
    427 	KASSERT(mutex_owned(&sc->sc_intr_lock));
    428 
    429 	sc->sc_intr = intr;
    430 	sc->sc_intrarg = intrarg;
    431 	sc->sc_blksize = blksize;
    432 
    433 	DPRINTF("%s: blksize=%d\n", __func__, blksize);
    434 	mutex_enter(&sc->sc_cond_lock);
    435 	err = pad_add_block(sc, block, blksize);
    436 	mutex_exit(&sc->sc_cond_lock);
    437 	cv_broadcast(&sc->sc_condvar);
    438 
    439 	ms = blksize * 1000 / PADCHAN / (PADPREC / NBBY) / PADFREQ;
    440 	DPRINTF("%s: callout ms=%d\n", __func__, ms);
    441 	callout_reset(&sc->sc_pcallout, mstohz(ms), pad_done_output, sc);
    442 
    443 	return err;
    444 }
    445 
    446 static int
    447 pad_start_input(void *opaque, void *block, int blksize,
    448     void (*intr)(void *), void *intrarg)
    449 {
    450 	pad_softc_t *sc __diagused;
    451 
    452 	sc = (pad_softc_t *)opaque;
    453 
    454 	KASSERT(mutex_owned(&sc->sc_intr_lock));
    455 
    456 	return EOPNOTSUPP;
    457 }
    458 
    459 static int
    460 pad_halt_output(void *opaque)
    461 {
    462 	pad_softc_t *sc;
    463 
    464 	sc = (pad_softc_t *)opaque;
    465 
    466 	DPRINTF("%s\n", __func__);
    467 	KASSERT(mutex_owned(&sc->sc_intr_lock));
    468 
    469 	cv_broadcast(&sc->sc_condvar);
    470 	callout_stop(&sc->sc_pcallout);
    471 	sc->sc_intr = NULL;
    472 	sc->sc_intrarg = NULL;
    473 	sc->sc_buflen = 0;
    474 	sc->sc_rpos = sc->sc_wpos = 0;
    475 
    476 	return 0;
    477 }
    478 
    479 static int
    480 pad_halt_input(void *opaque)
    481 {
    482 	pad_softc_t *sc __diagused;
    483 
    484 	sc = (pad_softc_t *)opaque;
    485 
    486 	KASSERT(mutex_owned(&sc->sc_intr_lock));
    487 
    488 	return 0;
    489 }
    490 
    491 static void
    492 pad_done_output(void *arg)
    493 {
    494 	pad_softc_t *sc;
    495 
    496 	DPRINTF("%s\n", __func__);
    497 	sc = (pad_softc_t *)arg;
    498 	callout_stop(&sc->sc_pcallout);
    499 
    500 	mutex_enter(&sc->sc_intr_lock);
    501 	(*sc->sc_intr)(sc->sc_intrarg);
    502 	mutex_exit(&sc->sc_intr_lock);
    503 }
    504 
    505 static int
    506 pad_getdev(void *opaque, struct audio_device *ret)
    507 {
    508 	strlcpy(ret->name, "Virtual Audio", sizeof(ret->name));
    509 	strlcpy(ret->version, osrelease, sizeof(ret->version));
    510 	strlcpy(ret->config, "pad", sizeof(ret->config));
    511 
    512 	return 0;
    513 }
    514 
    515 static int
    516 pad_set_port(void *opaque, mixer_ctrl_t *mc)
    517 {
    518 	pad_softc_t *sc;
    519 
    520 	sc = (pad_softc_t *)opaque;
    521 
    522 	KASSERT(mutex_owned(&sc->sc_lock));
    523 
    524 	switch (mc->dev) {
    525 	case PAD_OUTPUT_MASTER_VOLUME:
    526 	case PAD_INPUT_DAC_VOLUME:
    527 		if (mc->un.value.num_channels != 1)
    528 			return EINVAL;
    529 		sc->sc_swvol = mc->un.value.level[AUDIO_MIXER_LEVEL_MONO];
    530 		return 0;
    531 	}
    532 
    533 	return ENXIO;
    534 }
    535 
    536 static int
    537 pad_get_port(void *opaque, mixer_ctrl_t *mc)
    538 {
    539 	pad_softc_t *sc;
    540 
    541 	sc = (pad_softc_t *)opaque;
    542 
    543 	KASSERT(mutex_owned(&sc->sc_lock));
    544 
    545 	switch (mc->dev) {
    546 	case PAD_OUTPUT_MASTER_VOLUME:
    547 	case PAD_INPUT_DAC_VOLUME:
    548 		if (mc->un.value.num_channels != 1)
    549 			return EINVAL;
    550 		mc->un.value.level[AUDIO_MIXER_LEVEL_MONO] = sc->sc_swvol;
    551 		return 0;
    552 	}
    553 
    554 	return ENXIO;
    555 }
    556 
    557 static int
    558 pad_query_devinfo(void *opaque, mixer_devinfo_t *di)
    559 {
    560 	pad_softc_t *sc __diagused;
    561 
    562 	sc = (pad_softc_t *)opaque;
    563 
    564 	KASSERT(mutex_owned(&sc->sc_lock));
    565 
    566 	switch (di->index) {
    567 	case PAD_OUTPUT_CLASS:
    568 		di->mixer_class = PAD_OUTPUT_CLASS;
    569 		strcpy(di->label.name, AudioCoutputs);
    570 		di->type = AUDIO_MIXER_CLASS;
    571 		di->next = di->prev = AUDIO_MIXER_LAST;
    572 		return 0;
    573 	case PAD_INPUT_CLASS:
    574 		di->mixer_class = PAD_INPUT_CLASS;
    575 		strcpy(di->label.name, AudioCinputs);
    576 		di->type = AUDIO_MIXER_CLASS;
    577 		di->next = di->prev = AUDIO_MIXER_LAST;
    578 		return 0;
    579 	case PAD_OUTPUT_MASTER_VOLUME:
    580 		di->mixer_class = PAD_OUTPUT_CLASS;
    581 		strcpy(di->label.name, AudioNmaster);
    582 		di->type = AUDIO_MIXER_VALUE;
    583 		di->next = di->prev = AUDIO_MIXER_LAST;
    584 		di->un.v.num_channels = 1;
    585 		strcpy(di->un.v.units.name, AudioNvolume);
    586 		return 0;
    587 	case PAD_INPUT_DAC_VOLUME:
    588 		di->mixer_class = PAD_INPUT_CLASS;
    589 		strcpy(di->label.name, AudioNdac);
    590 		di->type = AUDIO_MIXER_VALUE;
    591 		di->next = di->prev = AUDIO_MIXER_LAST;
    592 		di->un.v.num_channels = 1;
    593 		strcpy(di->un.v.units.name, AudioNvolume);
    594 		return 0;
    595 	}
    596 
    597 	return ENXIO;
    598 }
    599 
    600 static int
    601 pad_get_props(void *opaque)
    602 {
    603 	pad_softc_t *sc __diagused;
    604 
    605 	sc = (pad_softc_t *)opaque;
    606 
    607 	KASSERT(mutex_owned(&sc->sc_lock));
    608 
    609 #if defined(PAD_SUPPORT_RECORD)
    610 	return 0;
    611 #else
    612 	return AUDIO_PROP_PLAYBACK;
    613 #endif
    614 }
    615 
    616 static void
    617 pad_get_locks(void *opaque, kmutex_t **intr, kmutex_t **thread)
    618 {
    619 	pad_softc_t *sc;
    620 
    621 	sc = (pad_softc_t *)opaque;
    622 
    623 	*intr = &sc->sc_intr_lock;
    624 	*thread = &sc->sc_lock;
    625 }
    626 
    627 static void
    628 pad_swvol_codec(audio_filter_arg_t *arg)
    629 {
    630 	struct pad_softc *sc = arg->context;
    631 	const aint_t *src;
    632 	aint_t *dst;
    633 	u_int sample_count;
    634 	u_int i;
    635 
    636 	src = arg->src;
    637 	dst = arg->dst;
    638 	sample_count = arg->count * arg->srcfmt->channels;
    639 	for (i = 0; i < sample_count; i++) {
    640 		aint2_t v = (aint2_t)(*src++);
    641 		v = v * sc->sc_swvol / 255;
    642 		*dst++ = (aint_t)v;
    643 	}
    644 }
    645 
    646 MODULE(MODULE_CLASS_DRIVER, pad, "audio");
    647 
    648 #ifdef _MODULE
    649 
    650 static const struct cfiattrdata audiobuscf_iattrdata = {
    651 	"audiobus", 0, { { NULL, NULL, 0 }, }
    652 };
    653 static const struct cfiattrdata * const pad_attrs[] = {
    654 	&audiobuscf_iattrdata, NULL
    655 };
    656 
    657 CFDRIVER_DECL(pad, DV_DULL, pad_attrs);
    658 extern struct cfattach pad_ca;
    659 static int padloc[] = { -1, -1 };
    660 
    661 static struct cfdata pad_cfdata[] = {
    662 	{
    663 		.cf_name = "pad",
    664 		.cf_atname = "pad",
    665 		.cf_unit = 0,
    666 		.cf_fstate = FSTATE_STAR,
    667 		.cf_loc = padloc,
    668 		.cf_flags = 0,
    669 		.cf_pspec = NULL,
    670 	},
    671 	{ NULL, NULL, 0, 0, NULL, 0, NULL }
    672 };
    673 #endif
    674 
    675 static int
    676 pad_modcmd(modcmd_t cmd, void *arg)
    677 {
    678 #ifdef _MODULE
    679 	devmajor_t cmajor = NODEVMAJOR, bmajor = NODEVMAJOR;
    680 #endif
    681 	int error = 0;
    682 
    683 	switch (cmd) {
    684 	case MODULE_CMD_INIT:
    685 #ifdef _MODULE
    686 		error = config_cfdriver_attach(&pad_cd);
    687 		if (error) {
    688 			break;
    689 		}
    690 
    691 		error = config_cfattach_attach(pad_cd.cd_name, &pad_ca);
    692 		if (error) {
    693 			config_cfdriver_detach(&pad_cd);
    694 			aprint_error("%s: unable to register cfattach\n",
    695 				pad_cd.cd_name);
    696 
    697 			break;
    698 		}
    699 
    700 		error = config_cfdata_attach(pad_cfdata, 1);
    701 		if (error) {
    702 			config_cfattach_detach(pad_cd.cd_name, &pad_ca);
    703 			config_cfdriver_detach(&pad_cd);
    704 			aprint_error("%s: unable to register cfdata\n",
    705 				pad_cd.cd_name);
    706 
    707 			break;
    708 		}
    709 
    710 		error = devsw_attach(pad_cd.cd_name, NULL, &bmajor,
    711 		    &pad_cdevsw, &cmajor);
    712 		if (error) {
    713 			config_cfdata_detach(pad_cfdata);
    714 			config_cfattach_detach(pad_cd.cd_name, &pad_ca);
    715 			config_cfdriver_detach(&pad_cd);
    716 			aprint_error("%s: unable to register devsw\n",
    717 				pad_cd.cd_name);
    718 
    719 			break;
    720 		}
    721 
    722 		(void)config_attach_pseudo(pad_cfdata);
    723 #endif
    724 
    725 		break;
    726 	case MODULE_CMD_FINI:
    727 #ifdef _MODULE
    728 		error = config_cfdata_detach(pad_cfdata);
    729 		if (error) {
    730 			break;
    731 		}
    732 
    733 		config_cfattach_detach(pad_cd.cd_name, &pad_ca);
    734 		config_cfdriver_detach(&pad_cd);
    735 		devsw_detach(NULL, &pad_cdevsw);
    736 #endif
    737 
    738 		break;
    739 	default:
    740 		error = ENOTTY;
    741 	}
    742 
    743 	return error;
    744 }
    745