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 case FEEDEQ_TREBLE:
323 case FEEDEQ_BASS:
324 if (value < 0 || value > 100)
325 return (EINVAL);
326 if (what == FEEDEQ_TREBLE)
327 info->treble.gain = FEEDEQ_L2GAIN(value);
328 else
329 info->bass.gain = FEEDEQ_L2GAIN(value);
330 break;
331 case FEEDEQ_PREAMP:
332 if (value < FEEDEQ_PREAMP_MIN || value > FEEDEQ_PREAMP_MAX)
333 return (EINVAL);
334 info->preamp = FEEDEQ_PREAMP2IDX(value);
335 break;
336 case FEEDEQ_STATE:
337 if (!(value == FEEDEQ_BYPASS || value == FEEDEQ_ENABLE ||
338 value == FEEDEQ_DISABLE))
339 return (EINVAL);
340 info->state = value;
341 feed_eq_reset(info);
342 break;
343 default:
344 return (EINVAL);
345 }
346
347 return (0);
348 }
349
350 static int
feed_eq_free(struct pcm_feeder * f)351 feed_eq_free(struct pcm_feeder *f)
352 {
353 struct feed_eq_info *info;
354
355 info = f->data;
356 free(info, M_DEVBUF);
357
358 f->data = NULL;
359
360 return (0);
361 }
362
363 static int
feed_eq_feed(struct pcm_feeder * f,struct pcm_channel * c,uint8_t * b,uint32_t count,void * source)364 feed_eq_feed(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b,
365 uint32_t count, void *source)
366 {
367 struct feed_eq_info *info;
368 uint32_t j;
369 uint8_t *dst;
370
371 info = f->data;
372
373 /*
374 * 3 major states:
375 * FEEDEQ_BYPASS - Bypass entirely, nothing happened.
376 * FEEDEQ_ENABLE - Preamp+biquad filtering.
377 * FEEDEQ_DISABLE - Preamp only.
378 */
379 if (info->state == FEEDEQ_BYPASS)
380 return (FEEDER_FEED(f->source, c, b, count, source));
381
382 dst = b;
383 count = SND_FXROUND(count, info->align);
384
385 do {
386 if (count < info->align)
387 break;
388
389 j = SND_FXDIV(FEEDER_FEED(f->source, c, dst, count, source),
390 info->align);
391 if (j == 0)
392 break;
393
394 /* Optimize some common formats. */
395 switch (info->fmt) {
396 case AFMT_S16_NE:
397 feed_eq_biquad(info, dst, j, AFMT_S16_NE);
398 break;
399 case AFMT_S24_NE:
400 feed_eq_biquad(info, dst, j, AFMT_S24_NE);
401 break;
402 case AFMT_S32_NE:
403 feed_eq_biquad(info, dst, j, AFMT_S32_NE);
404 break;
405 default:
406 feed_eq_biquad(info, dst, j, info->fmt);
407 break;
408 }
409
410 j *= info->align;
411 dst += j;
412 count -= j;
413
414 } while (count != 0);
415
416 return (dst - b);
417 }
418
419 static kobj_method_t feeder_eq_methods[] = {
420 KOBJMETHOD(feeder_init, feed_eq_init),
421 KOBJMETHOD(feeder_free, feed_eq_free),
422 KOBJMETHOD(feeder_set, feed_eq_set),
423 KOBJMETHOD(feeder_feed, feed_eq_feed),
424 KOBJMETHOD_END
425 };
426
427 FEEDER_DECLARE(feeder_eq, FEEDER_EQ);
428
429 static int32_t
feed_eq_scan_preamp_arg(const char * s)430 feed_eq_scan_preamp_arg(const char *s)
431 {
432 int r, i, f;
433 size_t len;
434 char buf[32];
435
436 bzero(buf, sizeof(buf));
437
438 /* XXX kind of ugly, but works for now.. */
439
440 r = sscanf(s, "%d.%d", &i, &f);
441
442 if (r == 1 && !(i < FEEDEQ_PREAMP_IMIN || i > FEEDEQ_PREAMP_IMAX)) {
443 snprintf(buf, sizeof(buf), "%c%d",
444 FEEDEQ_PREAMP_SIGNMARK(i), abs(i));
445 f = 0;
446 } else if (r == 2 &&
447 !(i < FEEDEQ_PREAMP_IMIN || i > FEEDEQ_PREAMP_IMAX ||
448 f < FEEDEQ_PREAMP_FMIN || f > FEEDEQ_PREAMP_FMAX))
449 snprintf(buf, sizeof(buf), "%c%d.%d",
450 FEEDEQ_PREAMP_SIGNMARK(i), abs(i), f);
451 else
452 return (FEEDEQ_PREAMP_INVALID);
453
454 len = strlen(s);
455 if (len > 2 && strcasecmp(s + len - 2, "dB") == 0)
456 strlcat(buf, "dB", sizeof(buf));
457
458 if (i == 0 && *s == '-')
459 *buf = '-';
460
461 if (strcasecmp(buf + ((*s >= '0' && *s <= '9') ? 1 : 0), s) != 0)
462 return (FEEDEQ_PREAMP_INVALID);
463
464 while ((f / FEEDEQ_GAIN_DIV) > 0)
465 f /= FEEDEQ_GAIN_DIV;
466
467 return (((i < 0 || *buf == '-') ? -1 : 1) * FEEDEQ_IF2PREAMP(i, f));
468 }
469
470 #ifdef _KERNEL
471 static int
sysctl_dev_pcm_eq(SYSCTL_HANDLER_ARGS)472 sysctl_dev_pcm_eq(SYSCTL_HANDLER_ARGS)
473 {
474 struct snddev_info *d;
475 struct pcm_channel *c;
476 struct pcm_feeder *f;
477 int err, val, oval;
478
479 d = oidp->oid_arg1;
480 if (!PCM_REGISTERED(d))
481 return (ENODEV);
482
483 PCM_LOCK(d);
484 PCM_WAIT(d);
485 if (d->flags & SD_F_EQ_BYPASSED)
486 val = 2;
487 else if (d->flags & SD_F_EQ_ENABLED)
488 val = 1;
489 else
490 val = 0;
491 PCM_ACQUIRE(d);
492 PCM_UNLOCK(d);
493
494 oval = val;
495 err = sysctl_handle_int(oidp, &val, 0, req);
496
497 if (err == 0 && req->newptr != NULL && val != oval) {
498 if (!(val == 0 || val == 1 || val == 2)) {
499 PCM_RELEASE_QUICK(d);
500 return (EINVAL);
501 }
502
503 PCM_LOCK(d);
504
505 d->flags &= ~(SD_F_EQ_ENABLED | SD_F_EQ_BYPASSED);
506 if (val == 2) {
507 val = FEEDEQ_BYPASS;
508 d->flags |= SD_F_EQ_BYPASSED;
509 } else if (val == 1) {
510 val = FEEDEQ_ENABLE;
511 d->flags |= SD_F_EQ_ENABLED;
512 } else
513 val = FEEDEQ_DISABLE;
514
515 CHN_FOREACH(c, d, channels.pcm.busy) {
516 CHN_LOCK(c);
517 f = feeder_find(c, FEEDER_EQ);
518 if (f != NULL)
519 (void)FEEDER_SET(f, FEEDEQ_STATE, val);
520 CHN_UNLOCK(c);
521 }
522
523 PCM_RELEASE(d);
524 PCM_UNLOCK(d);
525 } else
526 PCM_RELEASE_QUICK(d);
527
528 return (err);
529 }
530
531 static int
sysctl_dev_pcm_eq_preamp(SYSCTL_HANDLER_ARGS)532 sysctl_dev_pcm_eq_preamp(SYSCTL_HANDLER_ARGS)
533 {
534 struct snddev_info *d;
535 struct pcm_channel *c;
536 struct pcm_feeder *f;
537 int err, val, oval;
538 char buf[32];
539
540 d = oidp->oid_arg1;
541 if (!PCM_REGISTERED(d))
542 return (ENODEV);
543
544 PCM_LOCK(d);
545 PCM_WAIT(d);
546 val = d->eqpreamp;
547 bzero(buf, sizeof(buf));
548 (void)snprintf(buf, sizeof(buf), "%c%d.%ddB",
549 FEEDEQ_PREAMP_SIGNMARK(val), FEEDEQ_PREAMP_IPART(val),
550 FEEDEQ_PREAMP_FPART(val));
551 PCM_ACQUIRE(d);
552 PCM_UNLOCK(d);
553
554 oval = val;
555 err = sysctl_handle_string(oidp, buf, sizeof(buf), req);
556
557 if (err == 0 && req->newptr != NULL) {
558 val = feed_eq_scan_preamp_arg(buf);
559 if (val == FEEDEQ_PREAMP_INVALID) {
560 PCM_RELEASE_QUICK(d);
561 return (EINVAL);
562 }
563
564 PCM_LOCK(d);
565
566 if (val != oval) {
567 if (val < FEEDEQ_PREAMP_MIN)
568 val = FEEDEQ_PREAMP_MIN;
569 else if (val > FEEDEQ_PREAMP_MAX)
570 val = FEEDEQ_PREAMP_MAX;
571
572 d->eqpreamp = val;
573
574 CHN_FOREACH(c, d, channels.pcm.busy) {
575 CHN_LOCK(c);
576 f = feeder_find(c, FEEDER_EQ);
577 if (f != NULL)
578 (void)FEEDER_SET(f, FEEDEQ_PREAMP, val);
579 CHN_UNLOCK(c);
580 }
581 }
582
583 PCM_RELEASE(d);
584 PCM_UNLOCK(d);
585 } else
586 PCM_RELEASE_QUICK(d);
587
588 return (err);
589 }
590
591 void
feeder_eq_initsys(device_t dev)592 feeder_eq_initsys(device_t dev)
593 {
594 struct snddev_info *d;
595 const char *preamp;
596 char buf[64];
597
598 d = device_get_softc(dev);
599
600 if (!(resource_string_value(device_get_name(dev), device_get_unit(dev),
601 "eq_preamp", &preamp) == 0 &&
602 (d->eqpreamp = feed_eq_scan_preamp_arg(preamp)) !=
603 FEEDEQ_PREAMP_INVALID))
604 d->eqpreamp = FEEDEQ_PREAMP_DEFAULT;
605
606 if (d->eqpreamp < FEEDEQ_PREAMP_MIN)
607 d->eqpreamp = FEEDEQ_PREAMP_MIN;
608 else if (d->eqpreamp > FEEDEQ_PREAMP_MAX)
609 d->eqpreamp = FEEDEQ_PREAMP_MAX;
610
611 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
612 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
613 "eq", CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, d,
614 sizeof(d), sysctl_dev_pcm_eq, "I",
615 "Bass/Treble Equalizer (0=disable, 1=enable, 2=bypass)");
616
617 (void)snprintf(buf, sizeof(buf), "Bass/Treble Equalizer Preamp "
618 "(-/+ %d.0dB , %d.%ddB step)",
619 FEEDEQ_GAIN_MAX, FEEDEQ_GAIN_STEP / FEEDEQ_GAIN_DIV,
620 FEEDEQ_GAIN_STEP - ((FEEDEQ_GAIN_STEP / FEEDEQ_GAIN_DIV) *
621 FEEDEQ_GAIN_DIV));
622
623 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
624 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
625 "eq_preamp", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
626 d, sizeof(d), sysctl_dev_pcm_eq_preamp, "A", buf);
627 }
628 #endif
629