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