1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /*************************************************************************** 3 * au88x0_eq.c 4 * Aureal Vortex Hardware EQ control/access. 5 * 6 * Sun Jun 8 18:19:19 2003 7 * 2003 Manuel Jander (mjander@users.sourceforge.net) 8 * 9 * 02 July 2003: First time something works :) 10 * November 2003: A3D Bypass code completed but untested. 11 * 12 * TODO: 13 * - Debug (testing) 14 * - Test peak visualization support. 15 * 16 ****************************************************************************/ 17 18 /* 19 */ 20 21 /* 22 The Aureal Hardware EQ is found on AU8810 and AU8830 chips only. 23 it has 4 inputs (2 for general mix, 2 for A3D) and 2 outputs (supposed 24 to be routed to the codec). 25 */ 26 27 #include "au88x0.h" 28 #include "au88x0_eq.h" 29 #include "au88x0_eqdata.c" 30 31 #define VORTEX_EQ_BASE 0x2b000 32 #define VORTEX_EQ_DEST (VORTEX_EQ_BASE + 0x410) 33 #define VORTEX_EQ_SOURCE (VORTEX_EQ_BASE + 0x430) 34 #define VORTEX_EQ_CTRL (VORTEX_EQ_BASE + 0x440) 35 36 #define VORTEX_BAND_COEFF_SIZE 0x30 37 38 /* CEqHw.s */ 39 static void vortex_EqHw_SetTimeConsts(vortex_t * vortex, u16 gain, u16 level) 40 { 41 hwwrite(vortex->mmio, 0x2b3c4, gain); 42 hwwrite(vortex->mmio, 0x2b3c8, level); 43 } 44 45 static inline u16 sign_invert(u16 a) 46 { 47 /* -(-32768) -> -32768 so we do -(-32768) -> 32767 to make the result positive */ 48 if (a == (u16)-32768) 49 return 32767; 50 else 51 return -a; 52 } 53 54 static void vortex_EqHw_SetLeftCoefs(vortex_t *vortex, const u16 coefs[]) 55 { 56 eqhw_t *eqhw = &(vortex->eq.this04); 57 int i = 0, n /*esp2c */; 58 59 for (n = 0; n < eqhw->this04; n++) { 60 hwwrite(vortex->mmio, 0x2b000 + n * 0x30, coefs[i + 0]); 61 hwwrite(vortex->mmio, 0x2b004 + n * 0x30, coefs[i + 1]); 62 63 if (eqhw->this08 == 0) { 64 hwwrite(vortex->mmio, 0x2b008 + n * 0x30, coefs[i + 2]); 65 hwwrite(vortex->mmio, 0x2b00c + n * 0x30, coefs[i + 3]); 66 hwwrite(vortex->mmio, 0x2b010 + n * 0x30, coefs[i + 4]); 67 } else { 68 hwwrite(vortex->mmio, 0x2b008 + n * 0x30, sign_invert(coefs[2 + i])); 69 hwwrite(vortex->mmio, 0x2b00c + n * 0x30, sign_invert(coefs[3 + i])); 70 hwwrite(vortex->mmio, 0x2b010 + n * 0x30, sign_invert(coefs[4 + i])); 71 } 72 i += 5; 73 } 74 } 75 76 static void vortex_EqHw_SetRightCoefs(vortex_t *vortex, const u16 coefs[]) 77 { 78 eqhw_t *eqhw = &(vortex->eq.this04); 79 int i = 0, n /*esp2c */; 80 81 for (n = 0; n < eqhw->this04; n++) { 82 hwwrite(vortex->mmio, 0x2b1e0 + n * 0x30, coefs[0 + i]); 83 hwwrite(vortex->mmio, 0x2b1e4 + n * 0x30, coefs[1 + i]); 84 85 if (eqhw->this08 == 0) { 86 hwwrite(vortex->mmio, 0x2b1e8 + n * 0x30, coefs[2 + i]); 87 hwwrite(vortex->mmio, 0x2b1ec + n * 0x30, coefs[3 + i]); 88 hwwrite(vortex->mmio, 0x2b1f0 + n * 0x30, coefs[4 + i]); 89 } else { 90 hwwrite(vortex->mmio, 0x2b1e8 + n * 0x30, sign_invert(coefs[2 + i])); 91 hwwrite(vortex->mmio, 0x2b1ec + n * 0x30, sign_invert(coefs[3 + i])); 92 hwwrite(vortex->mmio, 0x2b1f0 + n * 0x30, sign_invert(coefs[4 + i])); 93 } 94 i += 5; 95 } 96 97 } 98 99 static void vortex_EqHw_SetLeftStates(vortex_t *vortex, const u16 a[], const u16 b[]) 100 { 101 eqhw_t *eqhw = &(vortex->eq.this04); 102 int i = 0, ebx; 103 104 hwwrite(vortex->mmio, 0x2b3fc, a[0]); 105 hwwrite(vortex->mmio, 0x2b400, a[1]); 106 107 for (ebx = 0; ebx < eqhw->this04; ebx++) { 108 hwwrite(vortex->mmio, 0x2b014 + (i * 0xc), b[i]); 109 hwwrite(vortex->mmio, 0x2b018 + (i * 0xc), b[1 + i]); 110 hwwrite(vortex->mmio, 0x2b01c + (i * 0xc), b[2 + i]); 111 hwwrite(vortex->mmio, 0x2b020 + (i * 0xc), b[3 + i]); 112 i += 4; 113 } 114 } 115 116 static void vortex_EqHw_SetRightStates(vortex_t *vortex, const u16 a[], const u16 b[]) 117 { 118 eqhw_t *eqhw = &(vortex->eq.this04); 119 int i = 0, ebx; 120 121 hwwrite(vortex->mmio, 0x2b404, a[0]); 122 hwwrite(vortex->mmio, 0x2b408, a[1]); 123 124 for (ebx = 0; ebx < eqhw->this04; ebx++) { 125 hwwrite(vortex->mmio, 0x2b1f4 + (i * 0xc), b[i]); 126 hwwrite(vortex->mmio, 0x2b1f8 + (i * 0xc), b[1 + i]); 127 hwwrite(vortex->mmio, 0x2b1fc + (i * 0xc), b[2 + i]); 128 hwwrite(vortex->mmio, 0x2b200 + (i * 0xc), b[3 + i]); 129 i += 4; 130 } 131 } 132 133 #if 0 134 static void vortex_EqHw_GetTimeConsts(vortex_t * vortex, u16 * a, u16 * b) 135 { 136 *a = hwread(vortex->mmio, 0x2b3c4); 137 *b = hwread(vortex->mmio, 0x2b3c8); 138 } 139 140 static void vortex_EqHw_GetLeftCoefs(vortex_t * vortex, u16 a[]) 141 { 142 143 } 144 145 static void vortex_EqHw_GetRightCoefs(vortex_t * vortex, u16 a[]) 146 { 147 148 } 149 150 static void vortex_EqHw_GetLeftStates(vortex_t * vortex, u16 * a, u16 b[]) 151 { 152 153 } 154 155 static void vortex_EqHw_GetRightStates(vortex_t * vortex, u16 * a, u16 b[]) 156 { 157 158 } 159 160 #endif 161 /* Mix Gains */ 162 static void vortex_EqHw_SetBypassGain(vortex_t * vortex, u16 a, u16 b) 163 { 164 eqhw_t *eqhw = &(vortex->eq.this04); 165 if (eqhw->this08 == 0) { 166 hwwrite(vortex->mmio, 0x2b3d4, a); 167 hwwrite(vortex->mmio, 0x2b3ec, b); 168 } else { 169 hwwrite(vortex->mmio, 0x2b3d4, sign_invert(a)); 170 hwwrite(vortex->mmio, 0x2b3ec, sign_invert(b)); 171 } 172 } 173 174 static void vortex_EqHw_SetA3DBypassGain(vortex_t * vortex, u16 a, u16 b) 175 { 176 177 hwwrite(vortex->mmio, 0x2b3e0, a); 178 hwwrite(vortex->mmio, 0x2b3f8, b); 179 } 180 181 #if 0 182 static void vortex_EqHw_SetCurrBypassGain(vortex_t * vortex, u16 a, u16 b) 183 { 184 185 hwwrite(vortex->mmio, 0x2b3d0, a); 186 hwwrite(vortex->mmio, 0x2b3e8, b); 187 } 188 189 static void vortex_EqHw_SetCurrA3DBypassGain(vortex_t * vortex, u16 a, u16 b) 190 { 191 192 hwwrite(vortex->mmio, 0x2b3dc, a); 193 hwwrite(vortex->mmio, 0x2b3f4, b); 194 } 195 196 #endif 197 static void 198 vortex_EqHw_SetLeftGainsSingleTarget(vortex_t * vortex, u16 index, u16 b) 199 { 200 hwwrite(vortex->mmio, 0x2b02c + (index * 0x30), b); 201 } 202 203 static void 204 vortex_EqHw_SetRightGainsSingleTarget(vortex_t * vortex, u16 index, u16 b) 205 { 206 hwwrite(vortex->mmio, 0x2b20c + (index * 0x30), b); 207 } 208 209 static void vortex_EqHw_SetLeftGainsTarget(vortex_t *vortex, const u16 a[]) 210 { 211 eqhw_t *eqhw = &(vortex->eq.this04); 212 int ebx; 213 214 for (ebx = 0; ebx < eqhw->this04; ebx++) { 215 hwwrite(vortex->mmio, 0x2b02c + ebx * 0x30, a[ebx]); 216 } 217 } 218 219 static void vortex_EqHw_SetRightGainsTarget(vortex_t *vortex, const u16 a[]) 220 { 221 eqhw_t *eqhw = &(vortex->eq.this04); 222 int ebx; 223 224 for (ebx = 0; ebx < eqhw->this04; ebx++) { 225 hwwrite(vortex->mmio, 0x2b20c + ebx * 0x30, a[ebx]); 226 } 227 } 228 229 static void vortex_EqHw_SetLeftGainsCurrent(vortex_t *vortex, const u16 a[]) 230 { 231 eqhw_t *eqhw = &(vortex->eq.this04); 232 int ebx; 233 234 for (ebx = 0; ebx < eqhw->this04; ebx++) { 235 hwwrite(vortex->mmio, 0x2b028 + ebx * 0x30, a[ebx]); 236 } 237 } 238 239 static void vortex_EqHw_SetRightGainsCurrent(vortex_t *vortex, const u16 a[]) 240 { 241 eqhw_t *eqhw = &(vortex->eq.this04); 242 int ebx; 243 244 for (ebx = 0; ebx < eqhw->this04; ebx++) { 245 hwwrite(vortex->mmio, 0x2b208 + ebx * 0x30, a[ebx]); 246 } 247 } 248 249 #if 0 250 static void vortex_EqHw_GetLeftGainsTarget(vortex_t * vortex, u16 a[]) 251 { 252 eqhw_t *eqhw = &(vortex->eq.this04); 253 int ebx = 0; 254 255 if (eqhw->this04 < 0) 256 return; 257 258 do { 259 a[ebx] = hwread(vortex->mmio, 0x2b02c + ebx * 0x30); 260 ebx++; 261 } 262 while (ebx < eqhw->this04); 263 } 264 265 static void vortex_EqHw_GetRightGainsTarget(vortex_t * vortex, u16 a[]) 266 { 267 eqhw_t *eqhw = &(vortex->eq.this04); 268 int ebx = 0; 269 270 if (eqhw->this04 < 0) 271 return; 272 273 do { 274 a[ebx] = hwread(vortex->mmio, 0x2b20c + ebx * 0x30); 275 ebx++; 276 } 277 while (ebx < eqhw->this04); 278 } 279 280 static void vortex_EqHw_GetLeftGainsCurrent(vortex_t * vortex, u16 a[]) 281 { 282 eqhw_t *eqhw = &(vortex->eq.this04); 283 int ebx = 0; 284 285 if (eqhw->this04 < 0) 286 return; 287 288 do { 289 a[ebx] = hwread(vortex->mmio, 0x2b028 + ebx * 0x30); 290 ebx++; 291 } 292 while (ebx < eqhw->this04); 293 } 294 295 static void vortex_EqHw_GetRightGainsCurrent(vortex_t * vortex, u16 a[]) 296 { 297 eqhw_t *eqhw = &(vortex->eq.this04); 298 int ebx = 0; 299 300 if (eqhw->this04 < 0) 301 return; 302 303 do { 304 a[ebx] = hwread(vortex->mmio, 0x2b208 + ebx * 0x30); 305 ebx++; 306 } 307 while (ebx < eqhw->this04); 308 } 309 310 #endif 311 /* EQ band levels settings */ 312 static void vortex_EqHw_SetLevels(vortex_t *vortex, const u16 peaks[]) 313 { 314 eqhw_t *eqhw = &(vortex->eq.this04); 315 int i; 316 317 /* set left peaks */ 318 for (i = 0; i < eqhw->this04; i++) { 319 hwwrite(vortex->mmio, 0x2b024 + i * VORTEX_BAND_COEFF_SIZE, peaks[i]); 320 } 321 322 hwwrite(vortex->mmio, 0x2b3cc, peaks[eqhw->this04]); 323 hwwrite(vortex->mmio, 0x2b3d8, peaks[eqhw->this04 + 1]); 324 325 /* set right peaks */ 326 for (i = 0; i < eqhw->this04; i++) { 327 hwwrite(vortex->mmio, 0x2b204 + i * VORTEX_BAND_COEFF_SIZE, 328 peaks[i + (eqhw->this04 + 2)]); 329 } 330 331 hwwrite(vortex->mmio, 0x2b3e4, peaks[2 + (eqhw->this04 * 2)]); 332 hwwrite(vortex->mmio, 0x2b3f0, peaks[3 + (eqhw->this04 * 2)]); 333 } 334 335 #if 0 336 static void vortex_EqHw_GetLevels(vortex_t * vortex, u16 a[]) 337 { 338 eqhw_t *eqhw = &(vortex->eq.this04); 339 int ebx; 340 341 if (eqhw->this04 < 0) 342 return; 343 344 ebx = 0; 345 do { 346 a[ebx] = hwread(vortex->mmio, 0x2b024 + ebx * 0x30); 347 ebx++; 348 } 349 while (ebx < eqhw->this04); 350 351 a[eqhw->this04] = hwread(vortex->mmio, 0x2b3cc); 352 a[eqhw->this04 + 1] = hwread(vortex->mmio, 0x2b3d8); 353 354 ebx = 0; 355 do { 356 a[ebx + (eqhw->this04 + 2)] = 357 hwread(vortex->mmio, 0x2b204 + ebx * 0x30); 358 ebx++; 359 } 360 while (ebx < eqhw->this04); 361 362 a[2 + (eqhw->this04 * 2)] = hwread(vortex->mmio, 0x2b3e4); 363 a[3 + (eqhw->this04 * 2)] = hwread(vortex->mmio, 0x2b3f0); 364 } 365 366 #endif 367 /* Global Control */ 368 static void vortex_EqHw_SetControlReg(vortex_t * vortex, u32 reg) 369 { 370 hwwrite(vortex->mmio, 0x2b440, reg); 371 } 372 373 static void vortex_EqHw_SetSampleRate(vortex_t * vortex, u32 sr) 374 { 375 hwwrite(vortex->mmio, 0x2b440, ((sr & 0x1f) << 3) | 0xb800); 376 } 377 378 #if 0 379 static void vortex_EqHw_GetControlReg(vortex_t * vortex, u32 *reg) 380 { 381 *reg = hwread(vortex->mmio, 0x2b440); 382 } 383 384 static void vortex_EqHw_GetSampleRate(vortex_t * vortex, u32 *sr) 385 { 386 *sr = (hwread(vortex->mmio, 0x2b440) >> 3) & 0x1f; 387 } 388 389 #endif 390 static void vortex_EqHw_Enable(vortex_t * vortex) 391 { 392 hwwrite(vortex->mmio, VORTEX_EQ_CTRL, 0xf001); 393 } 394 395 static void vortex_EqHw_Disable(vortex_t * vortex) 396 { 397 hwwrite(vortex->mmio, VORTEX_EQ_CTRL, 0xf000); 398 } 399 400 /* Reset (zero) buffers */ 401 static void vortex_EqHw_ZeroIO(vortex_t * vortex) 402 { 403 int i; 404 for (i = 0; i < 0x8; i++) 405 hwwrite(vortex->mmio, VORTEX_EQ_DEST + (i << 2), 0x0); 406 for (i = 0; i < 0x4; i++) 407 hwwrite(vortex->mmio, VORTEX_EQ_SOURCE + (i << 2), 0x0); 408 } 409 410 static void vortex_EqHw_ZeroA3DIO(vortex_t * vortex) 411 { 412 int i; 413 for (i = 0; i < 0x4; i++) 414 hwwrite(vortex->mmio, VORTEX_EQ_DEST + (i << 2), 0x0); 415 } 416 417 static void vortex_EqHw_ZeroState(vortex_t * vortex) 418 { 419 420 vortex_EqHw_SetControlReg(vortex, 0); 421 vortex_EqHw_ZeroIO(vortex); 422 hwwrite(vortex->mmio, 0x2b3c0, 0); 423 424 vortex_EqHw_SetTimeConsts(vortex, 0, 0); 425 426 vortex_EqHw_SetLeftCoefs(vortex, asEqCoefsZeros); 427 vortex_EqHw_SetRightCoefs(vortex, asEqCoefsZeros); 428 429 vortex_EqHw_SetLeftGainsCurrent(vortex, eq_gains_zero); 430 vortex_EqHw_SetRightGainsCurrent(vortex, eq_gains_zero); 431 vortex_EqHw_SetLeftGainsTarget(vortex, eq_gains_zero); 432 vortex_EqHw_SetRightGainsTarget(vortex, eq_gains_zero); 433 434 vortex_EqHw_SetBypassGain(vortex, 0, 0); 435 //vortex_EqHw_SetCurrBypassGain(vortex, 0, 0); 436 vortex_EqHw_SetA3DBypassGain(vortex, 0, 0); 437 //vortex_EqHw_SetCurrA3DBypassGain(vortex, 0, 0); 438 vortex_EqHw_SetLeftStates(vortex, eq_states_zero, asEqOutStateZeros); 439 vortex_EqHw_SetRightStates(vortex, eq_states_zero, asEqOutStateZeros); 440 vortex_EqHw_SetLevels(vortex, (u16 *) eq_levels); 441 } 442 443 /* Program coeficients as pass through */ 444 static void vortex_EqHw_ProgramPipe(vortex_t * vortex) 445 { 446 vortex_EqHw_SetTimeConsts(vortex, 0, 0); 447 448 vortex_EqHw_SetLeftCoefs(vortex, asEqCoefsPipes); 449 vortex_EqHw_SetRightCoefs(vortex, asEqCoefsPipes); 450 451 vortex_EqHw_SetLeftGainsCurrent(vortex, eq_gains_current); 452 vortex_EqHw_SetRightGainsCurrent(vortex, eq_gains_current); 453 vortex_EqHw_SetLeftGainsTarget(vortex, eq_gains_current); 454 vortex_EqHw_SetRightGainsTarget(vortex, eq_gains_current); 455 } 456 457 /* Program EQ block as 10 band Equalizer */ 458 static void 459 vortex_EqHw_Program10Band(vortex_t * vortex, auxxEqCoeffSet_t * coefset) 460 { 461 462 vortex_EqHw_SetTimeConsts(vortex, 0xc, 0x7fe0); 463 464 vortex_EqHw_SetLeftCoefs(vortex, coefset->LeftCoefs); 465 vortex_EqHw_SetRightCoefs(vortex, coefset->RightCoefs); 466 467 vortex_EqHw_SetLeftGainsCurrent(vortex, coefset->LeftGains); 468 469 vortex_EqHw_SetRightGainsTarget(vortex, coefset->RightGains); 470 vortex_EqHw_SetLeftGainsTarget(vortex, coefset->LeftGains); 471 472 vortex_EqHw_SetRightGainsCurrent(vortex, coefset->RightGains); 473 } 474 475 /* Read all EQ peaks. (think VU meter) */ 476 static void vortex_EqHw_GetTenBandLevels(vortex_t * vortex, u16 peaks[]) 477 { 478 eqhw_t *eqhw = &(vortex->eq.this04); 479 int i; 480 481 if (eqhw->this04 <= 0) 482 return; 483 484 for (i = 0; i < eqhw->this04; i++) 485 peaks[i] = hwread(vortex->mmio, 0x2B024 + i * 0x30); 486 for (i = 0; i < eqhw->this04; i++) 487 peaks[i + eqhw->this04] = 488 hwread(vortex->mmio, 0x2B204 + i * 0x30); 489 } 490 491 /* CEqlzr.s */ 492 493 static int vortex_Eqlzr_GetLeftGain(vortex_t * vortex, u16 index, u16 * gain) 494 { 495 eqlzr_t *eq = &(vortex->eq); 496 497 if (eq->this28) { 498 *gain = eq->this130[index]; 499 return 0; 500 } 501 return 1; 502 } 503 504 static void vortex_Eqlzr_SetLeftGain(vortex_t * vortex, u16 index, u16 gain) 505 { 506 eqlzr_t *eq = &(vortex->eq); 507 508 if (eq->this28 == 0) 509 return; 510 511 eq->this130[index] = gain; 512 if (eq->this54) 513 return; 514 515 vortex_EqHw_SetLeftGainsSingleTarget(vortex, index, gain); 516 } 517 518 static int vortex_Eqlzr_GetRightGain(vortex_t * vortex, u16 index, u16 * gain) 519 { 520 eqlzr_t *eq = &(vortex->eq); 521 522 if (eq->this28) { 523 *gain = eq->this130[index + eq->this10]; 524 return 0; 525 } 526 return 1; 527 } 528 529 static void vortex_Eqlzr_SetRightGain(vortex_t * vortex, u16 index, u16 gain) 530 { 531 eqlzr_t *eq = &(vortex->eq); 532 533 if (eq->this28 == 0) 534 return; 535 536 eq->this130[index + eq->this10] = gain; 537 if (eq->this54) 538 return; 539 540 vortex_EqHw_SetRightGainsSingleTarget(vortex, index, gain); 541 } 542 543 #if 0 544 static int 545 vortex_Eqlzr_GetAllBands(vortex_t * vortex, u16 * gains, s32 *cnt) 546 { 547 eqlzr_t *eq = &(vortex->eq); 548 int si = 0; 549 550 if (eq->this10 == 0) 551 return 1; 552 553 { 554 if (vortex_Eqlzr_GetLeftGain(vortex, si, &gains[si])) 555 return 1; 556 if (vortex_Eqlzr_GetRightGain 557 (vortex, si, &gains[si + eq->this10])) 558 return 1; 559 si++; 560 } 561 while (eq->this10 > si) ; 562 *cnt = si * 2; 563 return 0; 564 } 565 #endif 566 static int vortex_Eqlzr_SetAllBandsFromActiveCoeffSet(vortex_t * vortex) 567 { 568 eqlzr_t *eq = &(vortex->eq); 569 570 vortex_EqHw_SetLeftGainsTarget(vortex, eq->this130); 571 vortex_EqHw_SetRightGainsTarget(vortex, &(eq->this130[eq->this10])); 572 573 return 0; 574 } 575 576 static int 577 vortex_Eqlzr_SetAllBands(vortex_t *vortex, const u16 gains[], s32 count) 578 { 579 eqlzr_t *eq = &(vortex->eq); 580 int i; 581 582 if (((eq->this10) * 2 != count) || (eq->this28 == 0)) 583 return 1; 584 585 for (i = 0; i < count; i++) { 586 eq->this130[i] = gains[i]; 587 } 588 589 if (eq->this54) 590 return 0; 591 return vortex_Eqlzr_SetAllBandsFromActiveCoeffSet(vortex); 592 } 593 594 static void 595 vortex_Eqlzr_SetA3dBypassGain(vortex_t * vortex, u32 a, u32 b) 596 { 597 eqlzr_t *eq = &(vortex->eq); 598 u32 eax, ebx; 599 600 eq->this58 = a; 601 eq->this5c = b; 602 if (eq->this54) 603 eax = eq->this0e; 604 else 605 eax = eq->this0a; 606 ebx = (eax * eq->this58) >> 0x10; 607 eax = (eax * eq->this5c) >> 0x10; 608 vortex_EqHw_SetA3DBypassGain(vortex, ebx, eax); 609 } 610 611 static void vortex_Eqlzr_ProgramA3dBypassGain(vortex_t * vortex) 612 { 613 eqlzr_t *eq = &(vortex->eq); 614 u32 eax, ebx; 615 616 if (eq->this54) 617 eax = eq->this0e; 618 else 619 eax = eq->this0a; 620 ebx = (eax * eq->this58) >> 0x10; 621 eax = (eax * eq->this5c) >> 0x10; 622 vortex_EqHw_SetA3DBypassGain(vortex, ebx, eax); 623 } 624 625 static void vortex_Eqlzr_ShutDownA3d(vortex_t * vortex) 626 { 627 if (vortex != NULL) 628 vortex_EqHw_ZeroA3DIO(vortex); 629 } 630 631 static void vortex_Eqlzr_SetBypass(vortex_t * vortex, u32 bp) 632 { 633 eqlzr_t *eq = &(vortex->eq); 634 635 if ((eq->this28) && (bp == 0)) { 636 /* EQ enabled */ 637 vortex_Eqlzr_SetAllBandsFromActiveCoeffSet(vortex); 638 vortex_EqHw_SetBypassGain(vortex, eq->this08, eq->this08); 639 } else { 640 /* EQ disabled. */ 641 vortex_EqHw_SetLeftGainsTarget(vortex, eq->this14_array); 642 vortex_EqHw_SetRightGainsTarget(vortex, eq->this14_array); 643 vortex_EqHw_SetBypassGain(vortex, eq->this0c, eq->this0c); 644 } 645 vortex_Eqlzr_ProgramA3dBypassGain(vortex); 646 } 647 648 static void vortex_Eqlzr_ReadAndSetActiveCoefSet(vortex_t * vortex) 649 { 650 eqlzr_t *eq = &(vortex->eq); 651 652 /* Set EQ BiQuad filter coeficients */ 653 memcpy(&(eq->coefset), &asEqCoefsNormal, sizeof(auxxEqCoeffSet_t)); 654 /* Set EQ Band gain levels and dump into hardware registers. */ 655 vortex_Eqlzr_SetAllBands(vortex, eq_gains_normal, eq->this10 * 2); 656 } 657 658 static int vortex_Eqlzr_GetAllPeaks(vortex_t * vortex, u16 * peaks, int *count) 659 { 660 eqlzr_t *eq = &(vortex->eq); 661 662 if (eq->this10 == 0) 663 return 1; 664 *count = eq->this10 * 2; 665 vortex_EqHw_GetTenBandLevels(vortex, peaks); 666 return 0; 667 } 668 669 #if 0 670 static auxxEqCoeffSet_t *vortex_Eqlzr_GetActiveCoefSet(vortex_t * vortex) 671 { 672 eqlzr_t *eq = &(vortex->eq); 673 674 return (&(eq->coefset)); 675 } 676 #endif 677 static void vortex_Eqlzr_init(vortex_t * vortex) 678 { 679 eqlzr_t *eq = &(vortex->eq); 680 681 /* Object constructor */ 682 //eq->this04 = 0; 683 eq->this08 = 0; /* Bypass gain with EQ in use. */ 684 eq->this0a = 0x5999; 685 eq->this0c = 0x5999; /* Bypass gain with EQ disabled. */ 686 eq->this0e = 0x5999; 687 688 eq->this10 = 0xa; /* 10 eq frequency bands. */ 689 eq->this04.this04 = eq->this10; 690 eq->this28 = 0x1; /* if 1 => Allow read access to this130 (gains) */ 691 eq->this54 = 0x0; /* if 1 => Dont Allow access to hardware (gains) */ 692 eq->this58 = 0xffff; 693 eq->this5c = 0xffff; 694 695 /* Set gains. */ 696 memset(eq->this14_array, 0, sizeof(eq->this14_array)); 697 698 /* Actual init. */ 699 vortex_EqHw_ZeroState(vortex); 700 vortex_EqHw_SetSampleRate(vortex, 0x11); 701 vortex_Eqlzr_ReadAndSetActiveCoefSet(vortex); 702 703 vortex_EqHw_Program10Band(vortex, &(eq->coefset)); 704 vortex_Eqlzr_SetBypass(vortex, eq->this54); 705 vortex_Eqlzr_SetA3dBypassGain(vortex, 0, 0); 706 vortex_EqHw_Enable(vortex); 707 } 708 709 static void vortex_Eqlzr_shutdown(vortex_t * vortex) 710 { 711 vortex_Eqlzr_ShutDownA3d(vortex); 712 vortex_EqHw_ProgramPipe(vortex); 713 vortex_EqHw_Disable(vortex); 714 } 715 716 /* ALSA interface */ 717 718 /* Control interface */ 719 #define snd_vortex_eqtoggle_info snd_ctl_boolean_mono_info 720 721 static int 722 snd_vortex_eqtoggle_get(struct snd_kcontrol *kcontrol, 723 struct snd_ctl_elem_value *ucontrol) 724 { 725 vortex_t *vortex = snd_kcontrol_chip(kcontrol); 726 eqlzr_t *eq = &(vortex->eq); 727 //int i = kcontrol->private_value; 728 729 ucontrol->value.integer.value[0] = eq->this54 ? 0 : 1; 730 731 return 0; 732 } 733 734 static int 735 snd_vortex_eqtoggle_put(struct snd_kcontrol *kcontrol, 736 struct snd_ctl_elem_value *ucontrol) 737 { 738 vortex_t *vortex = snd_kcontrol_chip(kcontrol); 739 eqlzr_t *eq = &(vortex->eq); 740 //int i = kcontrol->private_value; 741 742 eq->this54 = ucontrol->value.integer.value[0] ? 0 : 1; 743 vortex_Eqlzr_SetBypass(vortex, eq->this54); 744 745 return 1; /* Allways changes */ 746 } 747 748 static const struct snd_kcontrol_new vortex_eqtoggle_kcontrol = { 749 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 750 .name = "EQ Enable", 751 .index = 0, 752 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 753 .private_value = 0, 754 .info = snd_vortex_eqtoggle_info, 755 .get = snd_vortex_eqtoggle_get, 756 .put = snd_vortex_eqtoggle_put 757 }; 758 759 static int 760 snd_vortex_eq_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 761 { 762 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 763 uinfo->count = 2; 764 uinfo->value.integer.min = 0x0000; 765 uinfo->value.integer.max = 0x7fff; 766 return 0; 767 } 768 769 static int 770 snd_vortex_eq_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 771 { 772 vortex_t *vortex = snd_kcontrol_chip(kcontrol); 773 int i = kcontrol->private_value; 774 u16 gainL = 0, gainR = 0; 775 776 vortex_Eqlzr_GetLeftGain(vortex, i, &gainL); 777 vortex_Eqlzr_GetRightGain(vortex, i, &gainR); 778 ucontrol->value.integer.value[0] = gainL; 779 ucontrol->value.integer.value[1] = gainR; 780 return 0; 781 } 782 783 static int 784 snd_vortex_eq_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 785 { 786 vortex_t *vortex = snd_kcontrol_chip(kcontrol); 787 int changed = 0, i = kcontrol->private_value; 788 u16 gainL = 0, gainR = 0; 789 790 vortex_Eqlzr_GetLeftGain(vortex, i, &gainL); 791 vortex_Eqlzr_GetRightGain(vortex, i, &gainR); 792 793 if (gainL != ucontrol->value.integer.value[0]) { 794 vortex_Eqlzr_SetLeftGain(vortex, i, 795 ucontrol->value.integer.value[0]); 796 changed = 1; 797 } 798 if (gainR != ucontrol->value.integer.value[1]) { 799 vortex_Eqlzr_SetRightGain(vortex, i, 800 ucontrol->value.integer.value[1]); 801 changed = 1; 802 } 803 return changed; 804 } 805 806 static const struct snd_kcontrol_new vortex_eq_kcontrol = { 807 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 808 .name = " .", 809 .index = 0, 810 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, 811 .private_value = 0, 812 .info = snd_vortex_eq_info, 813 .get = snd_vortex_eq_get, 814 .put = snd_vortex_eq_put 815 }; 816 817 static int 818 snd_vortex_peaks_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 819 { 820 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 821 uinfo->count = 20; 822 uinfo->value.integer.min = 0x0000; 823 uinfo->value.integer.max = 0x7fff; 824 return 0; 825 } 826 827 static int 828 snd_vortex_peaks_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 829 { 830 vortex_t *vortex = snd_kcontrol_chip(kcontrol); 831 int i, count = 0; 832 u16 peaks[20]; 833 834 vortex_Eqlzr_GetAllPeaks(vortex, peaks, &count); 835 if (count != 20) { 836 dev_err(vortex->card->dev, 837 "peak count error 20 != %d\n", count); 838 return -1; 839 } 840 for (i = 0; i < 20; i++) 841 ucontrol->value.integer.value[i] = peaks[i]; 842 843 return 0; 844 } 845 846 static const struct snd_kcontrol_new vortex_levels_kcontrol = { 847 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 848 .name = "EQ Peaks", 849 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 850 .info = snd_vortex_peaks_info, 851 .get = snd_vortex_peaks_get, 852 }; 853 854 /* EQ band gain labels. */ 855 static const char * const EqBandLabels[10] = { 856 "EQ0 31Hz\0", 857 "EQ1 63Hz\0", 858 "EQ2 125Hz\0", 859 "EQ3 250Hz\0", 860 "EQ4 500Hz\0", 861 "EQ5 1KHz\0", 862 "EQ6 2KHz\0", 863 "EQ7 4KHz\0", 864 "EQ8 8KHz\0", 865 "EQ9 16KHz\0", 866 }; 867 868 /* ALSA driver entry points. Init and exit. */ 869 static int vortex_eq_init(vortex_t *vortex) 870 { 871 struct snd_kcontrol *kcontrol; 872 int err, i; 873 874 vortex_Eqlzr_init(vortex); 875 876 kcontrol = snd_ctl_new1(&vortex_eqtoggle_kcontrol, vortex); 877 if (!kcontrol) 878 return -ENOMEM; 879 kcontrol->private_value = 0; 880 err = snd_ctl_add(vortex->card, kcontrol); 881 if (err < 0) 882 return err; 883 884 /* EQ gain controls */ 885 for (i = 0; i < 10; i++) { 886 kcontrol = snd_ctl_new1(&vortex_eq_kcontrol, vortex); 887 if (!kcontrol) 888 return -ENOMEM; 889 snprintf(kcontrol->id.name, sizeof(kcontrol->id.name), 890 "%s Playback Volume", EqBandLabels[i]); 891 kcontrol->private_value = i; 892 err = snd_ctl_add(vortex->card, kcontrol); 893 if (err < 0) 894 return err; 895 //vortex->eqctrl[i] = kcontrol; 896 } 897 /* EQ band levels */ 898 kcontrol = snd_ctl_new1(&vortex_levels_kcontrol, vortex); 899 if (!kcontrol) 900 return -ENOMEM; 901 err = snd_ctl_add(vortex->card, kcontrol); 902 if (err < 0) 903 return err; 904 905 return 0; 906 } 907 908 static int vortex_eq_free(vortex_t * vortex) 909 { 910 /* 911 //FIXME: segfault because vortex->eqctrl[i] == 4 912 int i; 913 for (i=0; i<10; i++) { 914 if (vortex->eqctrl[i]) 915 snd_ctl_remove(vortex->card, vortex->eqctrl[i]); 916 } 917 */ 918 vortex_Eqlzr_shutdown(vortex); 919 return 0; 920 } 921 922 /* End */ 923