sound/pci/au88x0/au88x0_eq.c

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