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