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 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 * 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 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 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 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 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 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 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 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 struct pcm_feederdesc feeder_eq_desc[] = { 423 { FEEDER_EQ, 0, 0, 0, 0 }, 424 { 0, 0, 0, 0, 0 } 425 }; 426 427 static kobj_method_t feeder_eq_methods[] = { 428 KOBJMETHOD(feeder_init, feed_eq_init), 429 KOBJMETHOD(feeder_free, feed_eq_free), 430 KOBJMETHOD(feeder_set, feed_eq_set), 431 KOBJMETHOD(feeder_feed, feed_eq_feed), 432 KOBJMETHOD_END 433 }; 434 435 FEEDER_DECLARE(feeder_eq, NULL); 436 437 static int32_t 438 feed_eq_scan_preamp_arg(const char *s) 439 { 440 int r, i, f; 441 size_t len; 442 char buf[32]; 443 444 bzero(buf, sizeof(buf)); 445 446 /* XXX kind of ugly, but works for now.. */ 447 448 r = sscanf(s, "%d.%d", &i, &f); 449 450 if (r == 1 && !(i < FEEDEQ_PREAMP_IMIN || i > FEEDEQ_PREAMP_IMAX)) { 451 snprintf(buf, sizeof(buf), "%c%d", 452 FEEDEQ_PREAMP_SIGNMARK(i), abs(i)); 453 f = 0; 454 } else if (r == 2 && 455 !(i < FEEDEQ_PREAMP_IMIN || i > FEEDEQ_PREAMP_IMAX || 456 f < FEEDEQ_PREAMP_FMIN || f > FEEDEQ_PREAMP_FMAX)) 457 snprintf(buf, sizeof(buf), "%c%d.%d", 458 FEEDEQ_PREAMP_SIGNMARK(i), abs(i), f); 459 else 460 return (FEEDEQ_PREAMP_INVALID); 461 462 len = strlen(s); 463 if (len > 2 && strcasecmp(s + len - 2, "dB") == 0) 464 strlcat(buf, "dB", sizeof(buf)); 465 466 if (i == 0 && *s == '-') 467 *buf = '-'; 468 469 if (strcasecmp(buf + ((*s >= '0' && *s <= '9') ? 1 : 0), s) != 0) 470 return (FEEDEQ_PREAMP_INVALID); 471 472 while ((f / FEEDEQ_GAIN_DIV) > 0) 473 f /= FEEDEQ_GAIN_DIV; 474 475 return (((i < 0 || *buf == '-') ? -1 : 1) * FEEDEQ_IF2PREAMP(i, f)); 476 } 477 478 #ifdef _KERNEL 479 static int 480 sysctl_dev_pcm_eq(SYSCTL_HANDLER_ARGS) 481 { 482 struct snddev_info *d; 483 struct pcm_channel *c; 484 struct pcm_feeder *f; 485 int err, val, oval; 486 487 d = oidp->oid_arg1; 488 if (!PCM_REGISTERED(d)) 489 return (ENODEV); 490 491 PCM_LOCK(d); 492 PCM_WAIT(d); 493 if (d->flags & SD_F_EQ_BYPASSED) 494 val = 2; 495 else if (d->flags & SD_F_EQ_ENABLED) 496 val = 1; 497 else 498 val = 0; 499 PCM_ACQUIRE(d); 500 PCM_UNLOCK(d); 501 502 oval = val; 503 err = sysctl_handle_int(oidp, &val, 0, req); 504 505 if (err == 0 && req->newptr != NULL && val != oval) { 506 if (!(val == 0 || val == 1 || val == 2)) { 507 PCM_RELEASE_QUICK(d); 508 return (EINVAL); 509 } 510 511 PCM_LOCK(d); 512 513 d->flags &= ~(SD_F_EQ_ENABLED | SD_F_EQ_BYPASSED); 514 if (val == 2) { 515 val = FEEDEQ_BYPASS; 516 d->flags |= SD_F_EQ_BYPASSED; 517 } else if (val == 1) { 518 val = FEEDEQ_ENABLE; 519 d->flags |= SD_F_EQ_ENABLED; 520 } else 521 val = FEEDEQ_DISABLE; 522 523 CHN_FOREACH(c, d, channels.pcm.busy) { 524 CHN_LOCK(c); 525 f = feeder_find(c, FEEDER_EQ); 526 if (f != NULL) 527 (void)FEEDER_SET(f, FEEDEQ_STATE, val); 528 CHN_UNLOCK(c); 529 } 530 531 PCM_RELEASE(d); 532 PCM_UNLOCK(d); 533 } else 534 PCM_RELEASE_QUICK(d); 535 536 return (err); 537 } 538 539 static int 540 sysctl_dev_pcm_eq_preamp(SYSCTL_HANDLER_ARGS) 541 { 542 struct snddev_info *d; 543 struct pcm_channel *c; 544 struct pcm_feeder *f; 545 int err, val, oval; 546 char buf[32]; 547 548 d = oidp->oid_arg1; 549 if (!PCM_REGISTERED(d)) 550 return (ENODEV); 551 552 PCM_LOCK(d); 553 PCM_WAIT(d); 554 val = d->eqpreamp; 555 bzero(buf, sizeof(buf)); 556 (void)snprintf(buf, sizeof(buf), "%c%d.%ddB", 557 FEEDEQ_PREAMP_SIGNMARK(val), FEEDEQ_PREAMP_IPART(val), 558 FEEDEQ_PREAMP_FPART(val)); 559 PCM_ACQUIRE(d); 560 PCM_UNLOCK(d); 561 562 oval = val; 563 err = sysctl_handle_string(oidp, buf, sizeof(buf), req); 564 565 if (err == 0 && req->newptr != NULL) { 566 val = feed_eq_scan_preamp_arg(buf); 567 if (val == FEEDEQ_PREAMP_INVALID) { 568 PCM_RELEASE_QUICK(d); 569 return (EINVAL); 570 } 571 572 PCM_LOCK(d); 573 574 if (val != oval) { 575 if (val < FEEDEQ_PREAMP_MIN) 576 val = FEEDEQ_PREAMP_MIN; 577 else if (val > FEEDEQ_PREAMP_MAX) 578 val = FEEDEQ_PREAMP_MAX; 579 580 d->eqpreamp = val; 581 582 CHN_FOREACH(c, d, channels.pcm.busy) { 583 CHN_LOCK(c); 584 f = feeder_find(c, FEEDER_EQ); 585 if (f != NULL) 586 (void)FEEDER_SET(f, FEEDEQ_PREAMP, val); 587 CHN_UNLOCK(c); 588 } 589 } 590 591 PCM_RELEASE(d); 592 PCM_UNLOCK(d); 593 } else 594 PCM_RELEASE_QUICK(d); 595 596 return (err); 597 } 598 599 void 600 feeder_eq_initsys(device_t dev) 601 { 602 struct snddev_info *d; 603 const char *preamp; 604 char buf[64]; 605 606 d = device_get_softc(dev); 607 608 if (!(resource_string_value(device_get_name(dev), device_get_unit(dev), 609 "eq_preamp", &preamp) == 0 && 610 (d->eqpreamp = feed_eq_scan_preamp_arg(preamp)) != 611 FEEDEQ_PREAMP_INVALID)) 612 d->eqpreamp = FEEDEQ_PREAMP_DEFAULT; 613 614 if (d->eqpreamp < FEEDEQ_PREAMP_MIN) 615 d->eqpreamp = FEEDEQ_PREAMP_MIN; 616 else if (d->eqpreamp > FEEDEQ_PREAMP_MAX) 617 d->eqpreamp = FEEDEQ_PREAMP_MAX; 618 619 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), 620 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, 621 "eq", CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, d, 622 sizeof(d), sysctl_dev_pcm_eq, "I", 623 "Bass/Treble Equalizer (0=disable, 1=enable, 2=bypass)"); 624 625 (void)snprintf(buf, sizeof(buf), "Bass/Treble Equalizer Preamp " 626 "(-/+ %d.0dB , %d.%ddB step)", 627 FEEDEQ_GAIN_MAX, FEEDEQ_GAIN_STEP / FEEDEQ_GAIN_DIV, 628 FEEDEQ_GAIN_STEP - ((FEEDEQ_GAIN_STEP / FEEDEQ_GAIN_DIV) * 629 FEEDEQ_GAIN_DIV)); 630 631 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), 632 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, 633 "eq_preamp", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, 634 d, sizeof(d), sysctl_dev_pcm_eq_preamp, "A", buf); 635 } 636 #endif 637