1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2008-2009 Ariff Abdullah <ariff@FreeBSD.org>
5 * All rights reserved.
6 * Copyright (c) 2024-2025 The FreeBSD Foundation
7 *
8 * Portions of this software were developed by Christos Margiolis
9 * <christos@FreeBSD.org> under sponsorship from the FreeBSD Foundation.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 */
32
33 /*
34 * feeder_eq: Parametric (compile time) Software Equalizer. Though accidental,
35 * it proves good enough for educational and general consumption.
36 *
37 * "Cookbook formulae for audio EQ biquad filter coefficients"
38 * by Robert Bristow-Johnson <rbj@audioimagination.com>
39 * - http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt
40 */
41
42 #ifdef _KERNEL
43 #ifdef HAVE_KERNEL_OPTION_HEADERS
44 #include "opt_snd.h"
45 #endif
46 #include <dev/sound/pcm/sound.h>
47 #include <dev/sound/pcm/pcm.h>
48 #include "feeder_if.h"
49
50 #define SND_USE_FXDIV
51 #include "snd_fxdiv_gen.h"
52 #endif
53
54 #include "feeder_eq_gen.h"
55
56 #define FEEDEQ_LEVELS \
57 (((FEEDEQ_GAIN_MAX - FEEDEQ_GAIN_MIN) * \
58 (FEEDEQ_GAIN_DIV / FEEDEQ_GAIN_STEP)) + 1)
59
60 #define FEEDEQ_L2GAIN(v) \
61 ((int)min(((v) * FEEDEQ_LEVELS) / 100, FEEDEQ_LEVELS - 1))
62
63 #define FEEDEQ_PREAMP_IPART(x) (abs(x) >> FEEDEQ_GAIN_SHIFT)
64 #define FEEDEQ_PREAMP_FPART(x) (abs(x) & FEEDEQ_GAIN_FMASK)
65 #define FEEDEQ_PREAMP_SIGNVAL(x) ((x) < 0 ? -1 : 1)
66 #define FEEDEQ_PREAMP_SIGNMARK(x) (((x) < 0) ? '-' : '+')
67
68 #define FEEDEQ_PREAMP_IMIN -192
69 #define FEEDEQ_PREAMP_IMAX 192
70 #define FEEDEQ_PREAMP_FMIN 0
71 #define FEEDEQ_PREAMP_FMAX 9
72
73 #define FEEDEQ_PREAMP_INVALID INT_MAX
74
75 #define FEEDEQ_IF2PREAMP(i, f) \
76 ((abs(i) << FEEDEQ_GAIN_SHIFT) | \
77 (((abs(f) / FEEDEQ_GAIN_STEP) * FEEDEQ_GAIN_STEP) & \
78 FEEDEQ_GAIN_FMASK))
79
80 #define FEEDEQ_PREAMP_MIN \
81 (FEEDEQ_PREAMP_SIGNVAL(FEEDEQ_GAIN_MIN) * \
82 FEEDEQ_IF2PREAMP(FEEDEQ_GAIN_MIN, 0))
83
84 #define FEEDEQ_PREAMP_MAX \
85 (FEEDEQ_PREAMP_SIGNVAL(FEEDEQ_GAIN_MAX) * \
86 FEEDEQ_IF2PREAMP(FEEDEQ_GAIN_MAX, 0))
87
88 #define FEEDEQ_PREAMP_DEFAULT FEEDEQ_IF2PREAMP(0, 0)
89
90 #define FEEDEQ_PREAMP2IDX(v) \
91 ((int32_t)((FEEDEQ_GAIN_MAX * (FEEDEQ_GAIN_DIV / \
92 FEEDEQ_GAIN_STEP)) + (FEEDEQ_PREAMP_SIGNVAL(v) * \
93 FEEDEQ_PREAMP_IPART(v) * (FEEDEQ_GAIN_DIV / \
94 FEEDEQ_GAIN_STEP)) + (FEEDEQ_PREAMP_SIGNVAL(v) * \
95 (FEEDEQ_PREAMP_FPART(v) / FEEDEQ_GAIN_STEP))))
96
97 static int feeder_eq_exact_rate = 0;
98
99 #ifdef _KERNEL
100 static char feeder_eq_presets[] = FEEDER_EQ_PRESETS;
101 SYSCTL_STRING(_hw_snd, OID_AUTO, feeder_eq_presets, CTLFLAG_RD,
102 &feeder_eq_presets, 0, "compile-time eq presets");
103
104 SYSCTL_INT(_hw_snd, OID_AUTO, feeder_eq_exact_rate, CTLFLAG_RWTUN,
105 &feeder_eq_exact_rate, 0, "force exact rate validation");
106 #endif
107
108 struct feed_eq_tone {
109 intpcm_t o1[SND_CHN_MAX];
110 intpcm_t o2[SND_CHN_MAX];
111 intpcm_t i1[SND_CHN_MAX];
112 intpcm_t i2[SND_CHN_MAX];
113 int gain;
114 };
115
116 struct feed_eq_info {
117 struct feed_eq_tone treble;
118 struct feed_eq_tone bass;
119 struct feed_eq_coeff *coeff;
120 uint32_t fmt;
121 uint32_t channels;
122 uint32_t rate;
123 uint32_t align;
124 int32_t preamp;
125 int state;
126 };
127
128 #if !defined(_KERNEL) && defined(FEEDEQ_ERR_CLIP)
129 #define FEEDEQ_ERR_CLIP_CHECK(t, v) do { \
130 if ((v) < PCM_S32_MIN || (v) > PCM_S32_MAX) \
131 errx(1, "\n\n%s(): ["#t"] Sample clipping: %jd\n", \
132 __func__, (intmax_t)(v)); \
133 } while (0)
134 #else
135 #define FEEDEQ_ERR_CLIP_CHECK(...)
136 #endif
137
138 __always_inline static void
feed_eq_biquad(struct feed_eq_info * info,uint8_t * dst,uint32_t count,const uint32_t fmt)139 feed_eq_biquad(struct feed_eq_info *info, uint8_t *dst, uint32_t count,
140 const uint32_t fmt)
141 {
142 struct feed_eq_coeff_tone *treble, *bass;
143 intpcm64_t w;
144 intpcm_t v;
145 uint32_t i, j;
146 int32_t pmul, pshift;
147
148 pmul = feed_eq_preamp[info->preamp].mul;
149 pshift = feed_eq_preamp[info->preamp].shift;
150
151 if (info->state == FEEDEQ_DISABLE) {
152 j = count * info->channels;
153 dst += j * AFMT_BPS(fmt);
154 do {
155 dst -= AFMT_BPS(fmt);
156 v = pcm_sample_read(dst, fmt);
157 v = ((intpcm64_t)pmul * v) >> pshift;
158 pcm_sample_write(dst, v, fmt);
159 } while (--j != 0);
160
161 return;
162 }
163
164 treble = &(info->coeff[info->treble.gain].treble);
165 bass = &(info->coeff[info->bass.gain].bass);
166
167 do {
168 i = 0;
169 j = info->channels;
170 do {
171 v = pcm_sample_read_norm(dst, fmt);
172 v = ((intpcm64_t)pmul * v) >> pshift;
173
174 w = (intpcm64_t)v * treble->b0;
175 w += (intpcm64_t)info->treble.i1[i] * treble->b1;
176 w += (intpcm64_t)info->treble.i2[i] * treble->b2;
177 w -= (intpcm64_t)info->treble.o1[i] * treble->a1;
178 w -= (intpcm64_t)info->treble.o2[i] * treble->a2;
179 info->treble.i2[i] = info->treble.i1[i];
180 info->treble.i1[i] = v;
181 info->treble.o2[i] = info->treble.o1[i];
182 w >>= FEEDEQ_COEFF_SHIFT;
183 FEEDEQ_ERR_CLIP_CHECK(treble, w);
184 v = pcm_clamp(w, AFMT_S32_NE);
185 info->treble.o1[i] = v;
186
187 w = (intpcm64_t)v * bass->b0;
188 w += (intpcm64_t)info->bass.i1[i] * bass->b1;
189 w += (intpcm64_t)info->bass.i2[i] * bass->b2;
190 w -= (intpcm64_t)info->bass.o1[i] * bass->a1;
191 w -= (intpcm64_t)info->bass.o2[i] * bass->a2;
192 info->bass.i2[i] = info->bass.i1[i];
193 info->bass.i1[i] = v;
194 info->bass.o2[i] = info->bass.o1[i];
195 w >>= FEEDEQ_COEFF_SHIFT;
196 FEEDEQ_ERR_CLIP_CHECK(bass, w);
197 v = pcm_clamp(w, AFMT_S32_NE);
198 info->bass.o1[i] = v;
199
200 pcm_sample_write_norm(dst, v, fmt);
201 dst += AFMT_BPS(fmt);
202 i++;
203 } while (--j != 0);
204 } while (--count != 0);
205 }
206
207 static struct feed_eq_coeff *
feed_eq_coeff_rate(uint32_t rate)208 feed_eq_coeff_rate(uint32_t rate)
209 {
210 uint32_t spd, threshold;
211 int i;
212
213 if (rate < FEEDEQ_RATE_MIN || rate > FEEDEQ_RATE_MAX)
214 return (NULL);
215
216 /*
217 * Not all rates are supported. Choose the best rate that we can to
218 * allow 'sloppy' conversion. Good enough for naive listeners.
219 */
220 for (i = 0; i < FEEDEQ_TAB_SIZE; i++) {
221 spd = feed_eq_tab[i].rate;
222 threshold = spd + ((i < (FEEDEQ_TAB_SIZE - 1) &&
223 feed_eq_tab[i + 1].rate > spd) ?
224 ((feed_eq_tab[i + 1].rate - spd) >> 1) : 0);
225 if (rate == spd ||
226 (feeder_eq_exact_rate == 0 && rate <= threshold))
227 return (feed_eq_tab[i].coeff);
228 }
229
230 return (NULL);
231 }
232
233 int
feeder_eq_validrate(uint32_t rate)234 feeder_eq_validrate(uint32_t rate)
235 {
236
237 if (feed_eq_coeff_rate(rate) != NULL)
238 return (1);
239
240 return (0);
241 }
242
243 static void
feed_eq_reset(struct feed_eq_info * info)244 feed_eq_reset(struct feed_eq_info *info)
245 {
246 uint32_t i;
247
248 for (i = 0; i < info->channels; i++) {
249 info->treble.i1[i] = 0;
250 info->treble.i2[i] = 0;
251 info->treble.o1[i] = 0;
252 info->treble.o2[i] = 0;
253 info->bass.i1[i] = 0;
254 info->bass.i2[i] = 0;
255 info->bass.o1[i] = 0;
256 info->bass.o2[i] = 0;
257 }
258 }
259
260 static int
feed_eq_setup(struct feed_eq_info * info)261 feed_eq_setup(struct feed_eq_info *info)
262 {
263
264 info->coeff = feed_eq_coeff_rate(info->rate);
265 if (info->coeff == NULL)
266 return (EINVAL);
267
268 feed_eq_reset(info);
269
270 return (0);
271 }
272
273 static int
feed_eq_init(struct pcm_feeder * f)274 feed_eq_init(struct pcm_feeder *f)
275 {
276 struct feed_eq_info *info;
277
278 if (f->desc->in != f->desc->out)
279 return (EINVAL);
280
281 info = malloc(sizeof(*info), M_DEVBUF, M_NOWAIT | M_ZERO);
282 if (info == NULL)
283 return (ENOMEM);
284
285 info->fmt = AFMT_ENCODING(f->desc->in);
286 info->channels = AFMT_CHANNEL(f->desc->in);
287 info->align = info->channels * AFMT_BPS(f->desc->in);
288
289 info->rate = FEEDEQ_RATE_MIN;
290 info->treble.gain = FEEDEQ_L2GAIN(50);
291 info->bass.gain = FEEDEQ_L2GAIN(50);
292 info->preamp = FEEDEQ_PREAMP2IDX(FEEDEQ_PREAMP_DEFAULT);
293 info->state = FEEDEQ_UNKNOWN;
294
295 f->data = info;
296
297 return (feed_eq_setup(info));
298 }
299
300 static int
feed_eq_set(struct pcm_feeder * f,int what,int value)301 feed_eq_set(struct pcm_feeder *f, int what, int value)
302 {
303 struct feed_eq_info *info;
304
305 info = f->data;
306
307 switch (what) {
308 case FEEDEQ_CHANNELS:
309 if (value < SND_CHN_MIN || value > SND_CHN_MAX)
310 return (EINVAL);
311 info->channels = (uint32_t)value;
312 info->align = info->channels * AFMT_BPS(f->desc->in);
313 feed_eq_reset(info);
314 break;
315 case FEEDEQ_RATE:
316 if (feeder_eq_validrate(value) == 0)
317 return (EINVAL);
318 info->rate = (uint32_t)value;
319 if (info->state == FEEDEQ_UNKNOWN)
320 info->state = FEEDEQ_ENABLE;
321 return (feed_eq_setup(info));
322 break;
323 case FEEDEQ_TREBLE:
324 case FEEDEQ_BASS:
325 if (value < 0 || value > 100)
326 return (EINVAL);
327 if (what == FEEDEQ_TREBLE)
328 info->treble.gain = FEEDEQ_L2GAIN(value);
329 else
330 info->bass.gain = FEEDEQ_L2GAIN(value);
331 break;
332 case FEEDEQ_PREAMP:
333 if (value < FEEDEQ_PREAMP_MIN || value > FEEDEQ_PREAMP_MAX)
334 return (EINVAL);
335 info->preamp = FEEDEQ_PREAMP2IDX(value);
336 break;
337 case FEEDEQ_STATE:
338 if (!(value == FEEDEQ_BYPASS || value == FEEDEQ_ENABLE ||
339 value == FEEDEQ_DISABLE))
340 return (EINVAL);
341 info->state = value;
342 feed_eq_reset(info);
343 break;
344 default:
345 return (EINVAL);
346 break;
347 }
348
349 return (0);
350 }
351
352 static int
feed_eq_free(struct pcm_feeder * f)353 feed_eq_free(struct pcm_feeder *f)
354 {
355 struct feed_eq_info *info;
356
357 info = f->data;
358 if (info != NULL)
359 free(info, M_DEVBUF);
360
361 f->data = NULL;
362
363 return (0);
364 }
365
366 static int
feed_eq_feed(struct pcm_feeder * f,struct pcm_channel * c,uint8_t * b,uint32_t count,void * source)367 feed_eq_feed(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b,
368 uint32_t count, void *source)
369 {
370 struct feed_eq_info *info;
371 uint32_t j;
372 uint8_t *dst;
373
374 info = f->data;
375
376 /*
377 * 3 major states:
378 * FEEDEQ_BYPASS - Bypass entirely, nothing happened.
379 * FEEDEQ_ENABLE - Preamp+biquad filtering.
380 * FEEDEQ_DISABLE - Preamp only.
381 */
382 if (info->state == FEEDEQ_BYPASS)
383 return (FEEDER_FEED(f->source, c, b, count, source));
384
385 dst = b;
386 count = SND_FXROUND(count, info->align);
387
388 do {
389 if (count < info->align)
390 break;
391
392 j = SND_FXDIV(FEEDER_FEED(f->source, c, dst, count, source),
393 info->align);
394 if (j == 0)
395 break;
396
397 /* Optimize some common formats. */
398 switch (info->fmt) {
399 case AFMT_S16_NE:
400 feed_eq_biquad(info, dst, j, AFMT_S16_NE);
401 break;
402 case AFMT_S24_NE:
403 feed_eq_biquad(info, dst, j, AFMT_S24_NE);
404 break;
405 case AFMT_S32_NE:
406 feed_eq_biquad(info, dst, j, AFMT_S32_NE);
407 break;
408 default:
409 feed_eq_biquad(info, dst, j, info->fmt);
410 break;
411 }
412
413 j *= info->align;
414 dst += j;
415 count -= j;
416
417 } while (count != 0);
418
419 return (dst - b);
420 }
421
422 static kobj_method_t feeder_eq_methods[] = {
423 KOBJMETHOD(feeder_init, feed_eq_init),
424 KOBJMETHOD(feeder_free, feed_eq_free),
425 KOBJMETHOD(feeder_set, feed_eq_set),
426 KOBJMETHOD(feeder_feed, feed_eq_feed),
427 KOBJMETHOD_END
428 };
429
430 FEEDER_DECLARE(feeder_eq, FEEDER_EQ);
431
432 static int32_t
feed_eq_scan_preamp_arg(const char * s)433 feed_eq_scan_preamp_arg(const char *s)
434 {
435 int r, i, f;
436 size_t len;
437 char buf[32];
438
439 bzero(buf, sizeof(buf));
440
441 /* XXX kind of ugly, but works for now.. */
442
443 r = sscanf(s, "%d.%d", &i, &f);
444
445 if (r == 1 && !(i < FEEDEQ_PREAMP_IMIN || i > FEEDEQ_PREAMP_IMAX)) {
446 snprintf(buf, sizeof(buf), "%c%d",
447 FEEDEQ_PREAMP_SIGNMARK(i), abs(i));
448 f = 0;
449 } else if (r == 2 &&
450 !(i < FEEDEQ_PREAMP_IMIN || i > FEEDEQ_PREAMP_IMAX ||
451 f < FEEDEQ_PREAMP_FMIN || f > FEEDEQ_PREAMP_FMAX))
452 snprintf(buf, sizeof(buf), "%c%d.%d",
453 FEEDEQ_PREAMP_SIGNMARK(i), abs(i), f);
454 else
455 return (FEEDEQ_PREAMP_INVALID);
456
457 len = strlen(s);
458 if (len > 2 && strcasecmp(s + len - 2, "dB") == 0)
459 strlcat(buf, "dB", sizeof(buf));
460
461 if (i == 0 && *s == '-')
462 *buf = '-';
463
464 if (strcasecmp(buf + ((*s >= '0' && *s <= '9') ? 1 : 0), s) != 0)
465 return (FEEDEQ_PREAMP_INVALID);
466
467 while ((f / FEEDEQ_GAIN_DIV) > 0)
468 f /= FEEDEQ_GAIN_DIV;
469
470 return (((i < 0 || *buf == '-') ? -1 : 1) * FEEDEQ_IF2PREAMP(i, f));
471 }
472
473 #ifdef _KERNEL
474 static int
sysctl_dev_pcm_eq(SYSCTL_HANDLER_ARGS)475 sysctl_dev_pcm_eq(SYSCTL_HANDLER_ARGS)
476 {
477 struct snddev_info *d;
478 struct pcm_channel *c;
479 struct pcm_feeder *f;
480 int err, val, oval;
481
482 d = oidp->oid_arg1;
483 if (!PCM_REGISTERED(d))
484 return (ENODEV);
485
486 PCM_LOCK(d);
487 PCM_WAIT(d);
488 if (d->flags & SD_F_EQ_BYPASSED)
489 val = 2;
490 else if (d->flags & SD_F_EQ_ENABLED)
491 val = 1;
492 else
493 val = 0;
494 PCM_ACQUIRE(d);
495 PCM_UNLOCK(d);
496
497 oval = val;
498 err = sysctl_handle_int(oidp, &val, 0, req);
499
500 if (err == 0 && req->newptr != NULL && val != oval) {
501 if (!(val == 0 || val == 1 || val == 2)) {
502 PCM_RELEASE_QUICK(d);
503 return (EINVAL);
504 }
505
506 PCM_LOCK(d);
507
508 d->flags &= ~(SD_F_EQ_ENABLED | SD_F_EQ_BYPASSED);
509 if (val == 2) {
510 val = FEEDEQ_BYPASS;
511 d->flags |= SD_F_EQ_BYPASSED;
512 } else if (val == 1) {
513 val = FEEDEQ_ENABLE;
514 d->flags |= SD_F_EQ_ENABLED;
515 } else
516 val = FEEDEQ_DISABLE;
517
518 CHN_FOREACH(c, d, channels.pcm.busy) {
519 CHN_LOCK(c);
520 f = feeder_find(c, FEEDER_EQ);
521 if (f != NULL)
522 (void)FEEDER_SET(f, FEEDEQ_STATE, val);
523 CHN_UNLOCK(c);
524 }
525
526 PCM_RELEASE(d);
527 PCM_UNLOCK(d);
528 } else
529 PCM_RELEASE_QUICK(d);
530
531 return (err);
532 }
533
534 static int
sysctl_dev_pcm_eq_preamp(SYSCTL_HANDLER_ARGS)535 sysctl_dev_pcm_eq_preamp(SYSCTL_HANDLER_ARGS)
536 {
537 struct snddev_info *d;
538 struct pcm_channel *c;
539 struct pcm_feeder *f;
540 int err, val, oval;
541 char buf[32];
542
543 d = oidp->oid_arg1;
544 if (!PCM_REGISTERED(d))
545 return (ENODEV);
546
547 PCM_LOCK(d);
548 PCM_WAIT(d);
549 val = d->eqpreamp;
550 bzero(buf, sizeof(buf));
551 (void)snprintf(buf, sizeof(buf), "%c%d.%ddB",
552 FEEDEQ_PREAMP_SIGNMARK(val), FEEDEQ_PREAMP_IPART(val),
553 FEEDEQ_PREAMP_FPART(val));
554 PCM_ACQUIRE(d);
555 PCM_UNLOCK(d);
556
557 oval = val;
558 err = sysctl_handle_string(oidp, buf, sizeof(buf), req);
559
560 if (err == 0 && req->newptr != NULL) {
561 val = feed_eq_scan_preamp_arg(buf);
562 if (val == FEEDEQ_PREAMP_INVALID) {
563 PCM_RELEASE_QUICK(d);
564 return (EINVAL);
565 }
566
567 PCM_LOCK(d);
568
569 if (val != oval) {
570 if (val < FEEDEQ_PREAMP_MIN)
571 val = FEEDEQ_PREAMP_MIN;
572 else if (val > FEEDEQ_PREAMP_MAX)
573 val = FEEDEQ_PREAMP_MAX;
574
575 d->eqpreamp = val;
576
577 CHN_FOREACH(c, d, channels.pcm.busy) {
578 CHN_LOCK(c);
579 f = feeder_find(c, FEEDER_EQ);
580 if (f != NULL)
581 (void)FEEDER_SET(f, FEEDEQ_PREAMP, val);
582 CHN_UNLOCK(c);
583 }
584 }
585
586 PCM_RELEASE(d);
587 PCM_UNLOCK(d);
588 } else
589 PCM_RELEASE_QUICK(d);
590
591 return (err);
592 }
593
594 void
feeder_eq_initsys(device_t dev)595 feeder_eq_initsys(device_t dev)
596 {
597 struct snddev_info *d;
598 const char *preamp;
599 char buf[64];
600
601 d = device_get_softc(dev);
602
603 if (!(resource_string_value(device_get_name(dev), device_get_unit(dev),
604 "eq_preamp", &preamp) == 0 &&
605 (d->eqpreamp = feed_eq_scan_preamp_arg(preamp)) !=
606 FEEDEQ_PREAMP_INVALID))
607 d->eqpreamp = FEEDEQ_PREAMP_DEFAULT;
608
609 if (d->eqpreamp < FEEDEQ_PREAMP_MIN)
610 d->eqpreamp = FEEDEQ_PREAMP_MIN;
611 else if (d->eqpreamp > FEEDEQ_PREAMP_MAX)
612 d->eqpreamp = FEEDEQ_PREAMP_MAX;
613
614 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
615 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
616 "eq", CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, d,
617 sizeof(d), sysctl_dev_pcm_eq, "I",
618 "Bass/Treble Equalizer (0=disable, 1=enable, 2=bypass)");
619
620 (void)snprintf(buf, sizeof(buf), "Bass/Treble Equalizer Preamp "
621 "(-/+ %d.0dB , %d.%ddB step)",
622 FEEDEQ_GAIN_MAX, FEEDEQ_GAIN_STEP / FEEDEQ_GAIN_DIV,
623 FEEDEQ_GAIN_STEP - ((FEEDEQ_GAIN_STEP / FEEDEQ_GAIN_DIV) *
624 FEEDEQ_GAIN_DIV));
625
626 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
627 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
628 "eq_preamp", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
629 d, sizeof(d), sysctl_dev_pcm_eq_preamp, "A", buf);
630 }
631 #endif
632