Home | History | Annotate | Line # | Download | only in pad
pad.c revision 1.68
      1  1.68  riastrad /* $NetBSD: pad.c,v 1.68 2021/06/14 00:21:09 riastradh Exp $ */
      2   1.1  jmcneill 
      3   1.1  jmcneill /*-
      4   1.1  jmcneill  * Copyright (c) 2007 Jared D. McNeill <jmcneill (at) invisible.ca>
      5   1.1  jmcneill  * All rights reserved.
      6   1.1  jmcneill  *
      7   1.1  jmcneill  * Redistribution and use in source and binary forms, with or without
      8   1.1  jmcneill  * modification, are permitted provided that the following conditions
      9   1.1  jmcneill  * are met:
     10   1.1  jmcneill  * 1. Redistributions of source code must retain the above copyright
     11   1.1  jmcneill  *    notice, this list of conditions and the following disclaimer.
     12   1.1  jmcneill  * 2. Redistributions in binary form must reproduce the above copyright
     13   1.1  jmcneill  *    notice, this list of conditions and the following disclaimer in the
     14   1.1  jmcneill  *    documentation and/or other materials provided with the distribution.
     15   1.1  jmcneill  *
     16   1.1  jmcneill  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     17   1.1  jmcneill  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     18   1.1  jmcneill  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     19   1.1  jmcneill  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     20   1.1  jmcneill  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     21   1.1  jmcneill  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     22   1.1  jmcneill  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     23   1.1  jmcneill  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     24   1.1  jmcneill  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     25   1.1  jmcneill  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     26   1.1  jmcneill  * POSSIBILITY OF SUCH DAMAGE.
     27   1.1  jmcneill  */
     28   1.1  jmcneill 
     29   1.1  jmcneill #include <sys/cdefs.h>
     30  1.68  riastrad __KERNEL_RCSID(0, "$NetBSD: pad.c,v 1.68 2021/06/14 00:21:09 riastradh Exp $");
     31   1.1  jmcneill 
     32   1.1  jmcneill #include <sys/types.h>
     33   1.1  jmcneill #include <sys/param.h>
     34   1.1  jmcneill #include <sys/conf.h>
     35   1.1  jmcneill #include <sys/buf.h>
     36  1.57  nakayama #include <sys/file.h>
     37  1.57  nakayama #include <sys/filedesc.h>
     38  1.57  nakayama #include <sys/vnode.h>
     39  1.57  nakayama #include <sys/kauth.h>
     40   1.1  jmcneill #include <sys/kmem.h>
     41   1.1  jmcneill #include <sys/kernel.h>
     42   1.1  jmcneill #include <sys/device.h>
     43  1.63     isaki #include <sys/poll.h>
     44   1.1  jmcneill #include <sys/proc.h>
     45   1.1  jmcneill #include <sys/condvar.h>
     46   1.1  jmcneill #include <sys/select.h>
     47  1.57  nakayama #include <sys/stat.h>
     48   1.1  jmcneill #include <sys/audioio.h>
     49  1.13     ahoka #include <sys/module.h>
     50   1.1  jmcneill 
     51  1.59     isaki #include <dev/audio/audio_if.h>
     52  1.59     isaki #include <dev/audio/audiovar.h>
     53   1.1  jmcneill 
     54   1.2  jmcneill #include <dev/pad/padvar.h>
     55   1.2  jmcneill 
     56  1.59     isaki /* #define PAD_DEBUG */
     57  1.59     isaki #ifdef PAD_DEBUG
     58  1.59     isaki #define DPRINTF(fmt...)	printf(fmt)
     59  1.59     isaki #else
     60  1.59     isaki #define DPRINTF(fmt...) /**/
     61  1.59     isaki #endif
     62  1.59     isaki 
     63  1.57  nakayama #define MAXDEVS		128
     64  1.57  nakayama #define PADCLONER	254
     65   1.1  jmcneill #define PADUNIT(x)	minor(x)
     66   1.1  jmcneill 
     67  1.57  nakayama #define PADFREQ		44100
     68  1.57  nakayama #define PADCHAN		2
     69  1.57  nakayama #define PADPREC		16
     70  1.57  nakayama 
     71   1.1  jmcneill extern struct cfdriver pad_cd;
     72  1.57  nakayama kmutex_t padconfig;
     73   1.1  jmcneill 
     74   1.1  jmcneill typedef struct pad_block {
     75   1.1  jmcneill 	uint8_t		*pb_ptr;
     76   1.1  jmcneill 	int		pb_len;
     77   1.1  jmcneill } pad_block_t;
     78   1.1  jmcneill 
     79   1.2  jmcneill enum {
     80   1.2  jmcneill 	PAD_OUTPUT_CLASS,
     81   1.2  jmcneill 	PAD_INPUT_CLASS,
     82   1.2  jmcneill 	PAD_OUTPUT_MASTER_VOLUME,
     83   1.2  jmcneill 	PAD_INPUT_DAC_VOLUME,
     84   1.2  jmcneill 	PAD_ENUM_LAST,
     85   1.2  jmcneill };
     86   1.1  jmcneill 
     87  1.10  christos static int	pad_match(device_t, cfdata_t, void *);
     88   1.5    dyoung static void	pad_attach(device_t, device_t, void *);
     89   1.5    dyoung static int	pad_detach(device_t, int);
     90   1.5    dyoung static void	pad_childdet(device_t, device_t);
     91   1.1  jmcneill 
     92  1.59     isaki static int	pad_query_format(void *, audio_format_query_t *);
     93  1.59     isaki static int	pad_set_format(void *, int,
     94  1.59     isaki 		    const audio_params_t *, const audio_params_t *,
     95  1.59     isaki 		    audio_filter_reg_t *, audio_filter_reg_t *);
     96   1.1  jmcneill static int	pad_start_output(void *, void *, int,
     97  1.62     isaki 		    void (*)(void *), void *);
     98   1.1  jmcneill static int	pad_halt_output(void *);
     99   1.1  jmcneill static int	pad_getdev(void *, struct audio_device *);
    100   1.1  jmcneill static int	pad_set_port(void *, mixer_ctrl_t *);
    101   1.1  jmcneill static int	pad_get_port(void *, mixer_ctrl_t *);
    102   1.1  jmcneill static int	pad_query_devinfo(void *, mixer_devinfo_t *);
    103   1.1  jmcneill static int	pad_get_props(void *);
    104  1.17  jmcneill static void	pad_get_locks(void *, kmutex_t **, kmutex_t **);
    105   1.1  jmcneill 
    106  1.59     isaki static void	pad_done_output(void *);
    107  1.59     isaki static void	pad_swvol_codec(audio_filter_arg_t *);
    108  1.22  jmcneill 
    109  1.62     isaki static int	pad_close(struct pad_softc *);
    110  1.62     isaki static int	pad_read(struct pad_softc *, off_t *, struct uio *,
    111  1.62     isaki 		    kauth_cred_t, int);
    112  1.62     isaki 
    113  1.62     isaki static int	fops_pad_close(struct file *);
    114  1.62     isaki static int	fops_pad_read(struct file *, off_t *, struct uio *,
    115  1.62     isaki 		    kauth_cred_t, int);
    116  1.62     isaki static int	fops_pad_write(struct file *, off_t *, struct uio *,
    117  1.62     isaki 		    kauth_cred_t, int);
    118  1.62     isaki static int	fops_pad_ioctl(struct file *, u_long, void *);
    119  1.62     isaki static int	fops_pad_kqfilter(struct file *, struct knote *);
    120  1.62     isaki static int	fops_pad_poll(struct file *, int);
    121  1.62     isaki static int	fops_pad_stat(struct file *, struct stat *);
    122  1.62     isaki static int	fops_pad_mmap(struct file *, off_t *, size_t, int, int *, int *,
    123  1.62     isaki 		    struct uvm_object **, int *);
    124  1.32  pgoyette 
    125   1.1  jmcneill static const struct audio_hw_if pad_hw_if = {
    126  1.62     isaki 	.query_format	= pad_query_format,
    127  1.62     isaki 	.set_format	= pad_set_format,
    128  1.62     isaki 	.start_output	= pad_start_output,
    129  1.62     isaki 	.halt_output	= pad_halt_output,
    130  1.62     isaki 	.getdev		= pad_getdev,
    131  1.62     isaki 	.set_port	= pad_set_port,
    132  1.62     isaki 	.get_port	= pad_get_port,
    133  1.62     isaki 	.query_devinfo	= pad_query_devinfo,
    134  1.62     isaki 	.get_props	= pad_get_props,
    135  1.62     isaki 	.get_locks	= pad_get_locks,
    136   1.1  jmcneill };
    137   1.1  jmcneill 
    138   1.1  jmcneill #define PAD_NFORMATS	1
    139   1.1  jmcneill static const struct audio_format pad_formats[PAD_NFORMATS] = {
    140  1.59     isaki 	{
    141  1.59     isaki 		.mode		= AUMODE_PLAY,
    142  1.60     isaki 		.encoding	= AUDIO_ENCODING_SLINEAR_LE,
    143  1.59     isaki 		.validbits	= PADPREC,
    144  1.59     isaki 		.precision	= PADPREC,
    145  1.59     isaki 		.channels	= PADCHAN,
    146  1.59     isaki 		.channel_mask	= AUFMT_STEREO,
    147  1.59     isaki 		.frequency_type	= 1,
    148  1.59     isaki 		.frequency	= { PADFREQ },
    149  1.59     isaki 	},
    150   1.1  jmcneill };
    151   1.1  jmcneill 
    152   1.1  jmcneill extern void	padattach(int);
    153   1.1  jmcneill 
    154  1.62     isaki static int	pad_add_block(struct pad_softc *, uint8_t *, int);
    155  1.62     isaki static int	pad_get_block(struct pad_softc *, pad_block_t *, int);
    156   1.1  jmcneill 
    157  1.62     isaki dev_type_open(cdev_pad_open);
    158  1.57  nakayama dev_type_close(cdev_pad_close);
    159  1.57  nakayama dev_type_read(cdev_pad_read);
    160   1.1  jmcneill 
    161   1.1  jmcneill const struct cdevsw pad_cdevsw = {
    162  1.62     isaki 	.d_open		= cdev_pad_open,
    163  1.62     isaki 	.d_close	= cdev_pad_close,
    164  1.62     isaki 	.d_read		= cdev_pad_read,
    165  1.62     isaki 	.d_write	= nowrite,
    166  1.62     isaki 	.d_ioctl	= noioctl,
    167  1.62     isaki 	.d_stop		= nostop,
    168  1.62     isaki 	.d_tty		= notty,
    169  1.62     isaki 	.d_poll		= nopoll,
    170  1.62     isaki 	.d_mmap		= nommap,
    171  1.62     isaki 	.d_kqfilter	= nokqfilter,
    172  1.62     isaki 	.d_discard	= nodiscard,
    173  1.62     isaki 	.d_flag		= D_OTHER | D_MPSAFE,
    174   1.1  jmcneill };
    175   1.1  jmcneill 
    176  1.57  nakayama const struct fileops pad_fileops = {
    177  1.62     isaki 	.fo_name	= "pad",
    178  1.62     isaki 	.fo_read	= fops_pad_read,
    179  1.62     isaki 	.fo_write	= fops_pad_write,
    180  1.62     isaki 	.fo_ioctl	= fops_pad_ioctl,
    181  1.62     isaki 	.fo_fcntl	= fnullop_fcntl,
    182  1.62     isaki 	.fo_stat	= fops_pad_stat,
    183  1.62     isaki 	.fo_poll	= fops_pad_poll,
    184  1.62     isaki 	.fo_close	= fops_pad_close,
    185  1.62     isaki 	.fo_mmap	= fops_pad_mmap,
    186  1.62     isaki 	.fo_kqfilter	= fops_pad_kqfilter,
    187  1.62     isaki 	.fo_restart	= fnullop_restart
    188  1.57  nakayama };
    189  1.57  nakayama 
    190  1.62     isaki CFATTACH_DECL2_NEW(pad, sizeof(struct pad_softc),
    191  1.62     isaki     pad_match, pad_attach, pad_detach,
    192   1.5    dyoung     NULL, NULL, pad_childdet);
    193   1.1  jmcneill 
    194   1.1  jmcneill void
    195   1.1  jmcneill padattach(int n)
    196   1.1  jmcneill {
    197  1.57  nakayama 	int error;
    198   1.1  jmcneill 
    199  1.57  nakayama 	error = config_cfattach_attach(pad_cd.cd_name, &pad_ca);
    200  1.57  nakayama 	if (error) {
    201   1.1  jmcneill 		aprint_error("%s: couldn't register cfattach: %d\n",
    202  1.57  nakayama 		    pad_cd.cd_name, error);
    203   1.1  jmcneill 		config_cfdriver_detach(&pad_cd);
    204   1.1  jmcneill 		return;
    205   1.1  jmcneill 	}
    206  1.57  nakayama 	mutex_init(&padconfig, MUTEX_DEFAULT, IPL_NONE);
    207   1.1  jmcneill 
    208   1.1  jmcneill 	return;
    209   1.1  jmcneill }
    210   1.1  jmcneill 
    211   1.1  jmcneill static int
    212  1.62     isaki pad_match(device_t parent, cfdata_t data, void *opaque)
    213  1.62     isaki {
    214  1.62     isaki 
    215  1.62     isaki 	return 1;
    216  1.62     isaki }
    217  1.62     isaki 
    218  1.62     isaki static void
    219  1.62     isaki pad_attach(device_t parent, device_t self, void *opaque)
    220  1.62     isaki {
    221  1.68  riastrad 	struct pad_softc *sc = device_private(self);
    222  1.62     isaki 
    223  1.62     isaki 	aprint_normal_dev(self, "outputs: 44100Hz, 16-bit, stereo\n");
    224  1.68  riastrad 
    225  1.68  riastrad 	sc->sc_dev = self;
    226  1.68  riastrad 	sc->sc_dying = false;
    227  1.68  riastrad 
    228  1.68  riastrad 	cv_init(&sc->sc_condvar, device_xname(sc->sc_dev));
    229  1.68  riastrad 	mutex_init(&sc->sc_cond_lock, MUTEX_DEFAULT, IPL_NONE);
    230  1.68  riastrad 	mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
    231  1.68  riastrad 	mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_NONE);
    232  1.68  riastrad 	callout_init(&sc->sc_pcallout, 0/*XXX?*/);
    233  1.68  riastrad 
    234  1.68  riastrad 	sc->sc_swvol = 255;
    235  1.68  riastrad 	sc->sc_buflen = 0;
    236  1.68  riastrad 	sc->sc_rpos = sc->sc_wpos = 0;
    237  1.68  riastrad 	sc->sc_audiodev = audio_attach_mi(&pad_hw_if, sc, sc->sc_dev);
    238  1.68  riastrad 
    239  1.68  riastrad 	if (!pmf_device_register(sc->sc_dev, NULL, NULL))
    240  1.68  riastrad 		aprint_error_dev(sc->sc_dev,
    241  1.68  riastrad 		    "couldn't establish power handler\n");
    242  1.62     isaki }
    243  1.62     isaki 
    244  1.62     isaki static int
    245  1.62     isaki pad_detach(device_t self, int flags)
    246  1.62     isaki {
    247  1.68  riastrad 	struct pad_softc *sc = device_private(self);
    248  1.62     isaki 	int cmaj, mn;
    249  1.68  riastrad 	int error;
    250  1.68  riastrad 
    251  1.68  riastrad 	error = config_detach_children(self, flags);
    252  1.68  riastrad 	if (error)
    253  1.68  riastrad 		return error;
    254  1.62     isaki 
    255  1.62     isaki 	cmaj = cdevsw_lookup_major(&pad_cdevsw);
    256  1.62     isaki 	mn = device_unit(sc->sc_dev);
    257  1.68  riastrad 	vdevgone(cmaj, mn, mn, VCHR);
    258  1.68  riastrad 
    259  1.68  riastrad 	pmf_device_deregister(sc->sc_dev);
    260  1.68  riastrad 
    261  1.68  riastrad 	mutex_destroy(&sc->sc_cond_lock);
    262  1.68  riastrad 	mutex_destroy(&sc->sc_lock);
    263  1.68  riastrad 	mutex_destroy(&sc->sc_intr_lock);
    264  1.68  riastrad 	cv_destroy(&sc->sc_condvar);
    265  1.62     isaki 
    266  1.62     isaki 	return 0;
    267  1.62     isaki }
    268  1.62     isaki 
    269  1.62     isaki static void
    270  1.62     isaki pad_childdet(device_t self, device_t child)
    271  1.62     isaki {
    272  1.62     isaki 	struct pad_softc *sc = device_private(self);
    273  1.62     isaki 
    274  1.68  riastrad 	if (child == sc->sc_audiodev)
    275  1.68  riastrad 		sc->sc_audiodev = NULL;
    276  1.62     isaki }
    277  1.62     isaki 
    278  1.62     isaki static int
    279  1.62     isaki pad_add_block(struct pad_softc *sc, uint8_t *blk, int blksize)
    280   1.1  jmcneill {
    281   1.1  jmcneill 	int l;
    282   1.1  jmcneill 
    283   1.1  jmcneill 	if (sc->sc_buflen + blksize > PAD_BUFSIZE)
    284   1.1  jmcneill 		return ENOBUFS;
    285   1.1  jmcneill 
    286   1.1  jmcneill 	if (sc->sc_wpos + blksize <= PAD_BUFSIZE)
    287   1.1  jmcneill 		memcpy(sc->sc_audiobuf + sc->sc_wpos, blk, blksize);
    288   1.1  jmcneill 	else {
    289   1.1  jmcneill 		l = PAD_BUFSIZE - sc->sc_wpos;
    290   1.1  jmcneill 		memcpy(sc->sc_audiobuf + sc->sc_wpos, blk, l);
    291   1.1  jmcneill 		memcpy(sc->sc_audiobuf, blk + l, blksize - l);
    292   1.1  jmcneill 	}
    293   1.1  jmcneill 
    294   1.1  jmcneill 	sc->sc_wpos += blksize;
    295  1.59     isaki 	if (sc->sc_wpos >= PAD_BUFSIZE)
    296   1.1  jmcneill 		sc->sc_wpos -= PAD_BUFSIZE;
    297   1.1  jmcneill 
    298   1.1  jmcneill 	sc->sc_buflen += blksize;
    299   1.1  jmcneill 
    300   1.1  jmcneill 	return 0;
    301   1.1  jmcneill }
    302   1.1  jmcneill 
    303   1.1  jmcneill static int
    304  1.62     isaki pad_get_block(struct pad_softc *sc, pad_block_t *pb, int blksize)
    305   1.1  jmcneill {
    306   1.1  jmcneill 	int l;
    307   1.1  jmcneill 
    308   1.1  jmcneill 	KASSERT(pb != NULL);
    309   1.1  jmcneill 
    310   1.1  jmcneill 	pb->pb_ptr = (sc->sc_audiobuf + sc->sc_rpos);
    311   1.1  jmcneill 	if (sc->sc_rpos + blksize < PAD_BUFSIZE) {
    312   1.1  jmcneill 		pb->pb_len = blksize;
    313   1.1  jmcneill 		sc->sc_rpos += blksize;
    314   1.1  jmcneill 	} else {
    315   1.1  jmcneill 		l = PAD_BUFSIZE - sc->sc_rpos;
    316   1.1  jmcneill 		pb->pb_len = l;
    317   1.1  jmcneill 		sc->sc_rpos = 0;
    318   1.1  jmcneill 	}
    319   1.1  jmcneill 	sc->sc_buflen -= pb->pb_len;
    320   1.1  jmcneill 
    321   1.1  jmcneill 	return 0;
    322   1.1  jmcneill }
    323   1.1  jmcneill 
    324  1.57  nakayama int
    325  1.62     isaki cdev_pad_open(dev_t dev, int flags, int fmt, struct lwp *l)
    326  1.57  nakayama {
    327  1.62     isaki 	struct pad_softc *sc;
    328  1.57  nakayama 	struct file *fp;
    329  1.57  nakayama 	device_t paddev;
    330  1.57  nakayama 	cfdata_t cf;
    331  1.57  nakayama 	int error, fd, i;
    332  1.57  nakayama 
    333  1.57  nakayama 	error = 0;
    334  1.57  nakayama 
    335  1.57  nakayama 	mutex_enter(&padconfig);
    336  1.57  nakayama 	if (PADUNIT(dev) == PADCLONER) {
    337  1.57  nakayama 		for (i = 0; i < MAXDEVS; i++) {
    338  1.57  nakayama 			if (device_lookup(&pad_cd, i) == NULL)
    339  1.57  nakayama 				break;
    340  1.57  nakayama 		}
    341  1.57  nakayama 		if (i == MAXDEVS)
    342  1.57  nakayama 			goto bad;
    343  1.57  nakayama 	} else {
    344  1.57  nakayama 		if (PADUNIT(dev) >= MAXDEVS)
    345  1.57  nakayama 			goto bad;
    346  1.57  nakayama 		i = PADUNIT(dev);
    347  1.57  nakayama 	}
    348  1.57  nakayama 
    349  1.57  nakayama 	cf = kmem_alloc(sizeof(struct cfdata), KM_SLEEP);
    350  1.57  nakayama 	cf->cf_name = pad_cd.cd_name;
    351  1.57  nakayama 	cf->cf_atname = pad_cd.cd_name;
    352  1.57  nakayama 	cf->cf_unit = i;
    353  1.57  nakayama 	cf->cf_fstate = FSTATE_STAR;
    354  1.57  nakayama 
    355  1.57  nakayama 	bool existing = false;
    356  1.57  nakayama 	paddev = device_lookup(&pad_cd, minor(dev));
    357  1.57  nakayama 	if (paddev == NULL)
    358  1.57  nakayama 		paddev = config_attach_pseudo(cf);
    359  1.57  nakayama 	else
    360  1.57  nakayama 		existing = true;
    361  1.57  nakayama 	if (paddev == NULL)
    362  1.57  nakayama 		goto bad;
    363  1.57  nakayama 
    364  1.57  nakayama 	sc = device_private(paddev);
    365  1.57  nakayama 	if (sc == NULL)
    366  1.57  nakayama 		goto bad;
    367  1.57  nakayama 
    368  1.57  nakayama 	if (sc->sc_open == 1) {
    369  1.57  nakayama 		mutex_exit(&padconfig);
    370  1.57  nakayama 		return EBUSY;
    371  1.57  nakayama 	}
    372  1.57  nakayama 
    373  1.57  nakayama 	if (PADUNIT(dev) == PADCLONER) {
    374  1.57  nakayama 		error = fd_allocfile(&fp, &fd);
    375  1.57  nakayama 		if (error) {
    376  1.57  nakayama 			if (existing == false)
    377  1.68  riastrad 				config_detach(paddev, 0);
    378  1.57  nakayama 			mutex_exit(&padconfig);
    379  1.57  nakayama 			return error;
    380  1.57  nakayama 		}
    381  1.57  nakayama 		error = fd_clone(fp, fd, flags, &pad_fileops, sc);
    382  1.57  nakayama 		KASSERT(error == EMOVEFD);
    383  1.68  riastrad 	}
    384  1.57  nakayama 	sc->sc_open = 1;
    385  1.57  nakayama 	mutex_exit(&padconfig);
    386  1.57  nakayama 
    387  1.57  nakayama 	return error;
    388  1.57  nakayama bad:
    389  1.57  nakayama 	mutex_exit(&padconfig);
    390  1.57  nakayama 	return ENXIO;
    391   1.1  jmcneill }
    392   1.1  jmcneill 
    393  1.39       nat static int
    394  1.57  nakayama pad_close(struct pad_softc *sc)
    395  1.41       nat {
    396  1.68  riastrad 	int rc __diagused;
    397  1.50       nat 
    398  1.68  riastrad 	/* XXX Defend against concurrent drvctl detach.  */
    399  1.68  riastrad 	rc = config_detach(sc->sc_dev, DETACH_FORCE);
    400  1.68  riastrad 	KASSERT(rc == 0);
    401  1.41       nat 
    402  1.68  riastrad 	return 0;
    403  1.57  nakayama }
    404  1.57  nakayama 
    405  1.57  nakayama static int
    406  1.57  nakayama fops_pad_close(struct file *fp)
    407  1.57  nakayama {
    408  1.68  riastrad 	struct pad_softc *sc = fp->f_pad;
    409  1.57  nakayama 
    410  1.68  riastrad 	pad_close(sc);
    411  1.68  riastrad 	fp->f_pad = NULL;
    412  1.57  nakayama 
    413  1.68  riastrad 	return 0;
    414  1.41       nat }
    415  1.41       nat 
    416  1.54  nakayama int
    417  1.57  nakayama cdev_pad_close(dev_t dev, int flags, int ifmt, struct lwp *l)
    418   1.1  jmcneill {
    419  1.62     isaki 	struct pad_softc *sc;
    420  1.57  nakayama 
    421  1.68  riastrad 	/*
    422  1.68  riastrad 	 * XXX Defend against concurrent drvctl detach.  Simply testing
    423  1.68  riastrad 	 * sc == NULL here is not enough -- it could be detached after
    424  1.68  riastrad 	 * we look it up but before we've issued our own config_detach.
    425  1.68  riastrad 	 */
    426  1.68  riastrad 	sc = device_lookup_private(&pad_cd, PADUNIT(dev));
    427  1.68  riastrad 	if (sc == NULL)
    428  1.68  riastrad 		return 0;
    429  1.68  riastrad 	pad_close(sc);
    430  1.68  riastrad 
    431  1.68  riastrad 	return 0;
    432  1.57  nakayama }
    433   1.1  jmcneill 
    434  1.57  nakayama static int
    435  1.62     isaki fops_pad_poll(struct file *fp, int events)
    436  1.57  nakayama {
    437  1.62     isaki 
    438  1.63     isaki 	return POLLERR;
    439  1.57  nakayama }
    440  1.57  nakayama 
    441  1.57  nakayama static int
    442  1.62     isaki fops_pad_kqfilter(struct file *fp, struct knote *kn)
    443  1.57  nakayama {
    444  1.68  riastrad 	struct pad_softc *sc = fp->f_pad;
    445  1.57  nakayama 	dev_t dev;
    446  1.57  nakayama 
    447  1.62     isaki 	dev = makedev(cdevsw_lookup_major(&pad_cdevsw),
    448  1.62     isaki 	    device_unit(sc->sc_dev));
    449  1.57  nakayama 
    450  1.57  nakayama 	return seltrue_kqfilter(dev, kn);
    451  1.57  nakayama }
    452  1.57  nakayama 
    453  1.57  nakayama static int
    454  1.62     isaki fops_pad_ioctl(struct file *fp, u_long cmd, void *data)
    455  1.57  nakayama {
    456  1.62     isaki 
    457  1.57  nakayama 	return ENODEV;
    458  1.57  nakayama }
    459   1.1  jmcneill 
    460  1.57  nakayama static int
    461  1.62     isaki fops_pad_stat(struct file *fp, struct stat *st)
    462  1.57  nakayama {
    463  1.68  riastrad 	struct pad_softc *sc = fp->f_pad;
    464  1.57  nakayama 
    465  1.57  nakayama 	memset(st, 0, sizeof(*st));
    466  1.57  nakayama 
    467  1.62     isaki 	st->st_dev = makedev(cdevsw_lookup_major(&pad_cdevsw),
    468  1.62     isaki 	    device_unit(sc->sc_dev));
    469  1.57  nakayama 
    470  1.57  nakayama 	st->st_uid = kauth_cred_geteuid(fp->f_cred);
    471  1.57  nakayama 	st->st_gid = kauth_cred_getegid(fp->f_cred);
    472  1.57  nakayama 	st->st_mode = S_IFCHR;
    473  1.57  nakayama 
    474  1.54  nakayama 	return 0;
    475  1.41       nat }
    476  1.39       nat 
    477  1.57  nakayama static int
    478  1.62     isaki fops_pad_mmap(struct file *fp, off_t *offp, size_t len, int prot, int *flagsp,
    479  1.62     isaki     int *advicep, struct uvm_object **uobjp, int *maxprotp)
    480  1.57  nakayama {
    481  1.62     isaki 
    482  1.57  nakayama 	return 1;
    483  1.57  nakayama }
    484  1.57  nakayama 
    485  1.41       nat int
    486  1.57  nakayama cdev_pad_read(dev_t dev, struct uio *uio, int ioflag)
    487  1.41       nat {
    488  1.62     isaki 	struct pad_softc *sc;
    489  1.62     isaki 
    490  1.57  nakayama 	sc = device_private(device_lookup(&pad_cd, PADUNIT(dev)));
    491  1.57  nakayama 	if (sc == NULL)
    492  1.57  nakayama 		return ENXIO;
    493  1.57  nakayama 
    494  1.57  nakayama 	return pad_read(sc, NULL, uio, NULL, ioflag);
    495  1.57  nakayama }
    496  1.39       nat 
    497  1.57  nakayama static int
    498  1.57  nakayama fops_pad_read(struct file *fp, off_t *offp, struct uio *uio, kauth_cred_t cred,
    499  1.62     isaki     int ioflag)
    500  1.57  nakayama {
    501  1.68  riastrad 	struct pad_softc *sc = fp->f_pad;
    502  1.39       nat 
    503  1.57  nakayama 	return pad_read(sc, offp, uio, cred, ioflag);
    504   1.1  jmcneill }
    505   1.1  jmcneill 
    506  1.57  nakayama static int
    507  1.57  nakayama pad_read(struct pad_softc *sc, off_t *offp, struct uio *uio, kauth_cred_t cred,
    508  1.62     isaki     int ioflag)
    509   1.1  jmcneill {
    510   1.1  jmcneill 	pad_block_t pb;
    511  1.59     isaki 	int len;
    512  1.59     isaki 	int err;
    513   1.1  jmcneill 
    514   1.1  jmcneill 	err = 0;
    515  1.59     isaki 	DPRINTF("%s: resid=%zu\n", __func__, uio->uio_resid);
    516  1.27       nat 	while (uio->uio_resid > 0 && !err) {
    517  1.59     isaki 		mutex_enter(&sc->sc_cond_lock);
    518  1.59     isaki 		if (sc->sc_buflen == 0) {
    519  1.59     isaki 			DPRINTF("%s: wait\n", __func__);
    520  1.59     isaki 			err = cv_wait_sig(&sc->sc_condvar, &sc->sc_cond_lock);
    521  1.59     isaki 			DPRINTF("%s: wake up %d\n", __func__, err);
    522  1.59     isaki 			mutex_exit(&sc->sc_cond_lock);
    523  1.59     isaki 			if (err) {
    524  1.59     isaki 				if (err == ERESTART)
    525  1.59     isaki 					err = EINTR;
    526  1.59     isaki 				break;
    527  1.35       nat 			}
    528  1.59     isaki 			if (sc->sc_buflen == 0)
    529  1.59     isaki 				break;
    530  1.17  jmcneill 			continue;
    531  1.17  jmcneill 		}
    532   1.1  jmcneill 
    533  1.59     isaki 		len = uimin(uio->uio_resid, sc->sc_buflen);
    534  1.59     isaki 		err = pad_get_block(sc, &pb, len);
    535  1.59     isaki 		mutex_exit(&sc->sc_cond_lock);
    536  1.59     isaki 		if (err)
    537  1.24       nat 			break;
    538  1.59     isaki 		DPRINTF("%s: move %d\n", __func__, pb.pb_len);
    539  1.59     isaki 		uiomove(pb.pb_ptr, pb.pb_len, uio);
    540   1.1  jmcneill 	}
    541   1.1  jmcneill 
    542   1.1  jmcneill 	return err;
    543   1.1  jmcneill }
    544   1.1  jmcneill 
    545   1.1  jmcneill static int
    546  1.62     isaki fops_pad_write(struct file *fp, off_t *offp, struct uio *uio, kauth_cred_t cred,
    547  1.62     isaki     int ioflag)
    548  1.57  nakayama {
    549  1.62     isaki 
    550  1.57  nakayama 	return EOPNOTSUPP;
    551  1.57  nakayama }
    552  1.57  nakayama 
    553  1.57  nakayama static int
    554  1.59     isaki pad_query_format(void *opaque, audio_format_query_t *afp)
    555  1.26       nat {
    556  1.26       nat 
    557  1.59     isaki 	return audio_query_format(pad_formats, PAD_NFORMATS, afp);
    558  1.26       nat }
    559  1.26       nat 
    560  1.26       nat static int
    561  1.59     isaki pad_set_format(void *opaque, int setmode,
    562  1.59     isaki     const audio_params_t *play, const audio_params_t *rec,
    563  1.59     isaki     audio_filter_reg_t *pfil, audio_filter_reg_t *rfil)
    564   1.1  jmcneill {
    565  1.62     isaki 	struct pad_softc *sc;
    566   1.1  jmcneill 
    567  1.62     isaki 	sc = (struct pad_softc *)opaque;
    568   1.1  jmcneill 
    569  1.17  jmcneill 	KASSERT(mutex_owned(&sc->sc_lock));
    570  1.17  jmcneill 
    571  1.59     isaki 	/* XXX playback only */
    572  1.59     isaki 	pfil->codec = pad_swvol_codec;
    573  1.59     isaki 	pfil->context = sc;
    574   1.2  jmcneill 
    575   1.1  jmcneill 	return 0;
    576   1.1  jmcneill }
    577   1.1  jmcneill 
    578   1.1  jmcneill static int
    579   1.1  jmcneill pad_start_output(void *opaque, void *block, int blksize,
    580   1.1  jmcneill     void (*intr)(void *), void *intrarg)
    581   1.1  jmcneill {
    582  1.62     isaki 	struct pad_softc *sc;
    583   1.1  jmcneill 	int err;
    584  1.59     isaki 	int ms;
    585   1.1  jmcneill 
    586  1.62     isaki 	sc = (struct pad_softc *)opaque;
    587   1.1  jmcneill 
    588  1.59     isaki 	KASSERT(mutex_owned(&sc->sc_intr_lock));
    589   1.1  jmcneill 
    590   1.1  jmcneill 	sc->sc_intr = intr;
    591   1.1  jmcneill 	sc->sc_intrarg = intrarg;
    592   1.1  jmcneill 	sc->sc_blksize = blksize;
    593   1.1  jmcneill 
    594  1.59     isaki 	DPRINTF("%s: blksize=%d\n", __func__, blksize);
    595  1.59     isaki 	mutex_enter(&sc->sc_cond_lock);
    596   1.1  jmcneill 	err = pad_add_block(sc, block, blksize);
    597  1.59     isaki 	mutex_exit(&sc->sc_cond_lock);
    598  1.59     isaki 	cv_broadcast(&sc->sc_condvar);
    599   1.1  jmcneill 
    600  1.59     isaki 	ms = blksize * 1000 / PADCHAN / (PADPREC / NBBY) / PADFREQ;
    601  1.59     isaki 	DPRINTF("%s: callout ms=%d\n", __func__, ms);
    602  1.59     isaki 	callout_reset(&sc->sc_pcallout, mstohz(ms), pad_done_output, sc);
    603   1.1  jmcneill 
    604  1.66       nia 	return err;
    605   1.1  jmcneill }
    606   1.1  jmcneill 
    607   1.1  jmcneill static int
    608   1.1  jmcneill pad_halt_output(void *opaque)
    609   1.1  jmcneill {
    610  1.62     isaki 	struct pad_softc *sc;
    611   1.1  jmcneill 
    612  1.62     isaki 	sc = (struct pad_softc *)opaque;
    613  1.17  jmcneill 
    614  1.59     isaki 	DPRINTF("%s\n", __func__);
    615  1.59     isaki 	KASSERT(mutex_owned(&sc->sc_intr_lock));
    616  1.17  jmcneill 
    617  1.59     isaki 	cv_broadcast(&sc->sc_condvar);
    618  1.59     isaki 	callout_stop(&sc->sc_pcallout);
    619   1.1  jmcneill 	sc->sc_intr = NULL;
    620   1.1  jmcneill 	sc->sc_intrarg = NULL;
    621   1.1  jmcneill 	sc->sc_buflen = 0;
    622   1.1  jmcneill 	sc->sc_rpos = sc->sc_wpos = 0;
    623   1.1  jmcneill 
    624   1.1  jmcneill 	return 0;
    625   1.1  jmcneill }
    626   1.1  jmcneill 
    627  1.59     isaki static void
    628  1.59     isaki pad_done_output(void *arg)
    629  1.59     isaki {
    630  1.62     isaki 	struct pad_softc *sc;
    631  1.59     isaki 
    632  1.59     isaki 	DPRINTF("%s\n", __func__);
    633  1.62     isaki 	sc = (struct pad_softc *)arg;
    634  1.59     isaki 	callout_stop(&sc->sc_pcallout);
    635  1.59     isaki 
    636  1.59     isaki 	mutex_enter(&sc->sc_intr_lock);
    637  1.59     isaki 	(*sc->sc_intr)(sc->sc_intrarg);
    638  1.59     isaki 	mutex_exit(&sc->sc_intr_lock);
    639  1.59     isaki }
    640  1.59     isaki 
    641   1.1  jmcneill static int
    642   1.1  jmcneill pad_getdev(void *opaque, struct audio_device *ret)
    643   1.1  jmcneill {
    644  1.62     isaki 
    645  1.16  jmcneill 	strlcpy(ret->name, "Virtual Audio", sizeof(ret->name));
    646  1.16  jmcneill 	strlcpy(ret->version, osrelease, sizeof(ret->version));
    647  1.16  jmcneill 	strlcpy(ret->config, "pad", sizeof(ret->config));
    648   1.1  jmcneill 
    649   1.1  jmcneill 	return 0;
    650   1.1  jmcneill }
    651   1.1  jmcneill 
    652   1.1  jmcneill static int
    653   1.1  jmcneill pad_set_port(void *opaque, mixer_ctrl_t *mc)
    654   1.1  jmcneill {
    655  1.62     isaki 	struct pad_softc *sc;
    656   1.2  jmcneill 
    657  1.62     isaki 	sc = (struct pad_softc *)opaque;
    658   1.2  jmcneill 
    659  1.17  jmcneill 	KASSERT(mutex_owned(&sc->sc_lock));
    660  1.17  jmcneill 
    661   1.2  jmcneill 	switch (mc->dev) {
    662   1.2  jmcneill 	case PAD_OUTPUT_MASTER_VOLUME:
    663   1.2  jmcneill 	case PAD_INPUT_DAC_VOLUME:
    664  1.58  nakayama 		if (mc->un.value.num_channels != 1)
    665  1.58  nakayama 			return EINVAL;
    666   1.2  jmcneill 		sc->sc_swvol = mc->un.value.level[AUDIO_MIXER_LEVEL_MONO];
    667   1.2  jmcneill 		return 0;
    668   1.2  jmcneill 	}
    669   1.2  jmcneill 
    670   1.1  jmcneill 	return ENXIO;
    671   1.1  jmcneill }
    672   1.1  jmcneill 
    673   1.1  jmcneill static int
    674   1.1  jmcneill pad_get_port(void *opaque, mixer_ctrl_t *mc)
    675   1.1  jmcneill {
    676  1.62     isaki 	struct pad_softc *sc;
    677   1.2  jmcneill 
    678  1.62     isaki 	sc = (struct pad_softc *)opaque;
    679   1.2  jmcneill 
    680  1.17  jmcneill 	KASSERT(mutex_owned(&sc->sc_lock));
    681  1.17  jmcneill 
    682   1.2  jmcneill 	switch (mc->dev) {
    683   1.2  jmcneill 	case PAD_OUTPUT_MASTER_VOLUME:
    684   1.2  jmcneill 	case PAD_INPUT_DAC_VOLUME:
    685  1.58  nakayama 		if (mc->un.value.num_channels != 1)
    686  1.58  nakayama 			return EINVAL;
    687   1.2  jmcneill 		mc->un.value.level[AUDIO_MIXER_LEVEL_MONO] = sc->sc_swvol;
    688   1.2  jmcneill 		return 0;
    689   1.2  jmcneill 	}
    690   1.2  jmcneill 
    691   1.1  jmcneill 	return ENXIO;
    692   1.1  jmcneill }
    693   1.1  jmcneill 
    694   1.1  jmcneill static int
    695   1.1  jmcneill pad_query_devinfo(void *opaque, mixer_devinfo_t *di)
    696   1.1  jmcneill {
    697  1.62     isaki 	struct pad_softc *sc __diagused;
    698   1.2  jmcneill 
    699  1.62     isaki 	sc = (struct pad_softc *)opaque;
    700   1.2  jmcneill 
    701  1.17  jmcneill 	KASSERT(mutex_owned(&sc->sc_lock));
    702  1.17  jmcneill 
    703   1.2  jmcneill 	switch (di->index) {
    704   1.2  jmcneill 	case PAD_OUTPUT_CLASS:
    705   1.2  jmcneill 		di->mixer_class = PAD_OUTPUT_CLASS;
    706   1.2  jmcneill 		strcpy(di->label.name, AudioCoutputs);
    707   1.2  jmcneill 		di->type = AUDIO_MIXER_CLASS;
    708   1.2  jmcneill 		di->next = di->prev = AUDIO_MIXER_LAST;
    709   1.2  jmcneill 		return 0;
    710   1.2  jmcneill 	case PAD_INPUT_CLASS:
    711   1.2  jmcneill 		di->mixer_class = PAD_INPUT_CLASS;
    712   1.2  jmcneill 		strcpy(di->label.name, AudioCinputs);
    713   1.2  jmcneill 		di->type = AUDIO_MIXER_CLASS;
    714   1.2  jmcneill 		di->next = di->prev = AUDIO_MIXER_LAST;
    715   1.2  jmcneill 		return 0;
    716   1.2  jmcneill 	case PAD_OUTPUT_MASTER_VOLUME:
    717   1.2  jmcneill 		di->mixer_class = PAD_OUTPUT_CLASS;
    718   1.2  jmcneill 		strcpy(di->label.name, AudioNmaster);
    719   1.2  jmcneill 		di->type = AUDIO_MIXER_VALUE;
    720   1.2  jmcneill 		di->next = di->prev = AUDIO_MIXER_LAST;
    721   1.2  jmcneill 		di->un.v.num_channels = 1;
    722   1.2  jmcneill 		strcpy(di->un.v.units.name, AudioNvolume);
    723   1.2  jmcneill 		return 0;
    724   1.2  jmcneill 	case PAD_INPUT_DAC_VOLUME:
    725   1.2  jmcneill 		di->mixer_class = PAD_INPUT_CLASS;
    726   1.2  jmcneill 		strcpy(di->label.name, AudioNdac);
    727   1.2  jmcneill 		di->type = AUDIO_MIXER_VALUE;
    728   1.2  jmcneill 		di->next = di->prev = AUDIO_MIXER_LAST;
    729   1.2  jmcneill 		di->un.v.num_channels = 1;
    730   1.2  jmcneill 		strcpy(di->un.v.units.name, AudioNvolume);
    731   1.2  jmcneill 		return 0;
    732   1.2  jmcneill 	}
    733   1.2  jmcneill 
    734   1.1  jmcneill 	return ENXIO;
    735   1.1  jmcneill }
    736   1.1  jmcneill 
    737   1.1  jmcneill static int
    738   1.1  jmcneill pad_get_props(void *opaque)
    739   1.1  jmcneill {
    740  1.17  jmcneill 
    741  1.59     isaki 	return AUDIO_PROP_PLAYBACK;
    742   1.1  jmcneill }
    743  1.13     ahoka 
    744  1.17  jmcneill static void
    745  1.17  jmcneill pad_get_locks(void *opaque, kmutex_t **intr, kmutex_t **thread)
    746  1.17  jmcneill {
    747  1.62     isaki 	struct pad_softc *sc;
    748  1.17  jmcneill 
    749  1.62     isaki 	sc = (struct pad_softc *)opaque;
    750  1.17  jmcneill 
    751  1.17  jmcneill 	*intr = &sc->sc_intr_lock;
    752  1.17  jmcneill 	*thread = &sc->sc_lock;
    753  1.17  jmcneill }
    754  1.17  jmcneill 
    755  1.22  jmcneill static void
    756  1.59     isaki pad_swvol_codec(audio_filter_arg_t *arg)
    757  1.22  jmcneill {
    758  1.59     isaki 	struct pad_softc *sc = arg->context;
    759  1.59     isaki 	const aint_t *src;
    760  1.59     isaki 	aint_t *dst;
    761  1.59     isaki 	u_int sample_count;
    762  1.59     isaki 	u_int i;
    763  1.59     isaki 
    764  1.59     isaki 	src = arg->src;
    765  1.59     isaki 	dst = arg->dst;
    766  1.59     isaki 	sample_count = arg->count * arg->srcfmt->channels;
    767  1.59     isaki 	for (i = 0; i < sample_count; i++) {
    768  1.59     isaki 		aint2_t v = (aint2_t)(*src++);
    769  1.59     isaki 		v = v * sc->sc_swvol / 255;
    770  1.59     isaki 		*dst++ = (aint_t)v;
    771  1.59     isaki 	}
    772  1.22  jmcneill }
    773  1.22  jmcneill 
    774  1.44  pgoyette MODULE(MODULE_CLASS_DRIVER, pad, "audio");
    775  1.44  pgoyette 
    776  1.13     ahoka #ifdef _MODULE
    777  1.13     ahoka 
    778  1.57  nakayama #include "ioconf.c"
    779  1.57  nakayama 
    780  1.57  nakayama devmajor_t cmajor = NODEVMAJOR, bmajor = NODEVMAJOR;
    781  1.57  nakayama 
    782  1.57  nakayama /*
    783  1.57  nakayama  * We need our own version of cfattach since config(1)'s ioconf does not
    784  1.57  nakayama  * generate what we need
    785  1.57  nakayama  */
    786  1.57  nakayama 
    787  1.57  nakayama static struct cfattach *pad_cfattachinit[] = { &pad_ca, NULL };
    788  1.13     ahoka 
    789  1.57  nakayama static struct cfattachinit pad_cfattach[] = {
    790  1.57  nakayama 	{ "pad", pad_cfattachinit },
    791  1.57  nakayama 	{ NULL, NULL }
    792  1.45  pgoyette };
    793  1.47  pgoyette #endif
    794  1.45  pgoyette 
    795  1.13     ahoka static int
    796  1.13     ahoka pad_modcmd(modcmd_t cmd, void *arg)
    797  1.13     ahoka {
    798  1.44  pgoyette 	int error = 0;
    799  1.13     ahoka 
    800  1.13     ahoka 	switch (cmd) {
    801  1.13     ahoka 	case MODULE_CMD_INIT:
    802  1.44  pgoyette #ifdef _MODULE
    803  1.57  nakayama 		pad_cfattach[1] = cfattach_ioconf_pad[0];
    804  1.57  nakayama 		error = config_init_component(cfdriver_ioconf_pad,
    805  1.57  nakayama 		    pad_cfattach, cfdata_ioconf_pad);
    806  1.57  nakayama 		if (error)
    807  1.44  pgoyette 			break;
    808  1.13     ahoka 
    809  1.25   msaitoh 		error = devsw_attach(pad_cd.cd_name, NULL, &bmajor,
    810  1.57  nakayama 			    &pad_cdevsw, &cmajor);
    811  1.13     ahoka 		if (error) {
    812  1.57  nakayama 			config_fini_component(cfdriver_ioconf_pad,
    813  1.57  nakayama 			    pad_cfattach, cfdata_ioconf_pad);
    814  1.44  pgoyette 			break;
    815  1.13     ahoka 		}
    816  1.57  nakayama 		mutex_init(&padconfig, MUTEX_DEFAULT, IPL_NONE);
    817  1.13     ahoka 
    818  1.44  pgoyette #endif
    819  1.57  nakayama 		break;
    820  1.54  nakayama 
    821  1.13     ahoka 	case MODULE_CMD_FINI:
    822  1.44  pgoyette #ifdef _MODULE
    823  1.57  nakayama 		error = devsw_detach(NULL, &pad_cdevsw);
    824  1.57  nakayama 		if (error)
    825  1.57  nakayama 			break;
    826  1.57  nakayama 
    827  1.57  nakayama 		error = config_fini_component(cfdriver_ioconf_pad,
    828  1.57  nakayama 		    pad_cfattach, cfdata_ioconf_pad);
    829  1.13     ahoka 		if (error) {
    830  1.57  nakayama 			devsw_attach(pad_cd.cd_name, NULL, &bmajor,
    831  1.57  nakayama 			    &pad_cdevsw, &cmajor);
    832  1.44  pgoyette 			break;
    833  1.13     ahoka 		}
    834  1.57  nakayama 		mutex_destroy(&padconfig);
    835  1.44  pgoyette #endif
    836  1.57  nakayama 		break;
    837  1.54  nakayama 
    838  1.13     ahoka 	default:
    839  1.44  pgoyette 		error = ENOTTY;
    840  1.13     ahoka 	}
    841  1.44  pgoyette 
    842  1.44  pgoyette 	return error;
    843  1.13     ahoka }
    844