sound/pci/au88x0/au88x0_eq.c

   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 */