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