1 /***************************************************************************
3 * Aureal Vortex Hardware EQ control/access.
5 * Sun Jun 8 18:19:19 2003
6 * 2003 Manuel Jander (mjander@users.sourceforge.net)
8 * 02 July 2003: First time something works :)
9 * November 2003: A3D Bypass code completed but untested.
13 * - Test peak visualization support.
15 ****************************************************************************/
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.
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.
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.
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).
40 #include "au88x0_eq.h"
41 #include "au88x0_eqdata.c"
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)
48 #define VORTEX_BAND_COEFF_SIZE 0x30
51 static void vortex_EqHw_SetTimeConsts(vortex_t
* vortex
, u16 gain
, u16 level
)
53 hwwrite(vortex
->mmio
, 0x2b3c4, gain
);
54 hwwrite(vortex
->mmio
, 0x2b3c8, level
);
57 static inline u16
sign_invert(u16 a
)
59 /* -(-32768) -> -32768 so we do -(-32768) -> 32767 to make the result positive */
66 static void vortex_EqHw_SetLeftCoefs(vortex_t
* vortex
, u16 coefs
[])
68 eqhw_t
*eqhw
= &(vortex
->eq
.this04
);
69 int i
= 0, n
/*esp2c */;
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]);
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]);
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
]));
88 static void vortex_EqHw_SetRightCoefs(vortex_t
* vortex
, u16 coefs
[])
90 eqhw_t
*eqhw
= &(vortex
->eq
.this04
);
91 int i
= 0, n
/*esp2c */;
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
]);
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
]);
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
]));
111 static void vortex_EqHw_SetLeftStates(vortex_t
* vortex
, u16 a
[], u16 b
[])
113 eqhw_t
*eqhw
= &(vortex
->eq
.this04
);
116 hwwrite(vortex
->mmio
, 0x2b3fc, a
[0]);
117 hwwrite(vortex
->mmio
, 0x2b400, a
[1]);
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
]);
128 static void vortex_EqHw_SetRightStates(vortex_t
* vortex
, u16 a
[], u16 b
[])
130 eqhw_t
*eqhw
= &(vortex
->eq
.this04
);
133 hwwrite(vortex
->mmio
, 0x2b404, a
[0]);
134 hwwrite(vortex
->mmio
, 0x2b408, a
[1]);
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
]);
146 static void vortex_EqHw_GetTimeConsts(vortex_t
* vortex
, u16
* a
, u16
* b
)
148 *a
= hwread(vortex
->mmio
, 0x2b3c4);
149 *b
= hwread(vortex
->mmio
, 0x2b3c8);
152 static void vortex_EqHw_GetLeftCoefs(vortex_t
* vortex
, u16 a
[])
157 static void vortex_EqHw_GetRightCoefs(vortex_t
* vortex
, u16 a
[])
162 static void vortex_EqHw_GetLeftStates(vortex_t
* vortex
, u16
* a
, u16 b
[])
167 static void vortex_EqHw_GetRightStates(vortex_t
* vortex
, u16
* a
, u16 b
[])
174 static void vortex_EqHw_SetBypassGain(vortex_t
* vortex
, u16 a
, u16 b
)
176 eqhw_t
*eqhw
= &(vortex
->eq
.this04
);
177 if (eqhw
->this08
== 0) {
178 hwwrite(vortex
->mmio
, 0x2b3d4, a
);
179 hwwrite(vortex
->mmio
, 0x2b3ec, b
);
181 hwwrite(vortex
->mmio
, 0x2b3d4, sign_invert(a
));
182 hwwrite(vortex
->mmio
, 0x2b3ec, sign_invert(b
));
186 static void vortex_EqHw_SetA3DBypassGain(vortex_t
* vortex
, u16 a
, u16 b
)
189 hwwrite(vortex
->mmio
, 0x2b3e0, a
);
190 hwwrite(vortex
->mmio
, 0x2b3f8, b
);
194 static void vortex_EqHw_SetCurrBypassGain(vortex_t
* vortex
, u16 a
, u16 b
)
197 hwwrite(vortex
->mmio
, 0x2b3d0, a
);
198 hwwrite(vortex
->mmio
, 0x2b3e8, b
);
201 static void vortex_EqHw_SetCurrA3DBypassGain(vortex_t
* vortex
, u16 a
, u16 b
)
204 hwwrite(vortex
->mmio
, 0x2b3dc, a
);
205 hwwrite(vortex
->mmio
, 0x2b3f4, b
);
210 vortex_EqHw_SetLeftGainsSingleTarget(vortex_t
* vortex
, u16 index
, u16 b
)
212 hwwrite(vortex
->mmio
, 0x2b02c + (index
* 0x30), b
);
216 vortex_EqHw_SetRightGainsSingleTarget(vortex_t
* vortex
, u16 index
, u16 b
)
218 hwwrite(vortex
->mmio
, 0x2b20c + (index
* 0x30), b
);
221 static void vortex_EqHw_SetLeftGainsTarget(vortex_t
* vortex
, u16 a
[])
223 eqhw_t
*eqhw
= &(vortex
->eq
.this04
);
226 for (ebx
= 0; ebx
< eqhw
->this04
; ebx
++) {
227 hwwrite(vortex
->mmio
, 0x2b02c + ebx
* 0x30, a
[ebx
]);
231 static void vortex_EqHw_SetRightGainsTarget(vortex_t
* vortex
, u16 a
[])
233 eqhw_t
*eqhw
= &(vortex
->eq
.this04
);
236 for (ebx
= 0; ebx
< eqhw
->this04
; ebx
++) {
237 hwwrite(vortex
->mmio
, 0x2b20c + ebx
* 0x30, a
[ebx
]);
241 static void vortex_EqHw_SetLeftGainsCurrent(vortex_t
* vortex
, u16 a
[])
243 eqhw_t
*eqhw
= &(vortex
->eq
.this04
);
246 for (ebx
= 0; ebx
< eqhw
->this04
; ebx
++) {
247 hwwrite(vortex
->mmio
, 0x2b028 + ebx
* 0x30, a
[ebx
]);
251 static void vortex_EqHw_SetRightGainsCurrent(vortex_t
* vortex
, u16 a
[])
253 eqhw_t
*eqhw
= &(vortex
->eq
.this04
);
256 for (ebx
= 0; ebx
< eqhw
->this04
; ebx
++) {
257 hwwrite(vortex
->mmio
, 0x2b208 + ebx
* 0x30, a
[ebx
]);
262 static void vortex_EqHw_GetLeftGainsTarget(vortex_t
* vortex
, u16 a
[])
264 eqhw_t
*eqhw
= &(vortex
->eq
.this04
);
267 if (eqhw
->this04
< 0)
271 a
[ebx
] = hwread(vortex
->mmio
, 0x2b02c + ebx
* 0x30);
274 while (ebx
< eqhw
->this04
);
277 static void vortex_EqHw_GetRightGainsTarget(vortex_t
* vortex
, u16 a
[])
279 eqhw_t
*eqhw
= &(vortex
->eq
.this04
);
282 if (eqhw
->this04
< 0)
286 a
[ebx
] = hwread(vortex
->mmio
, 0x2b20c + ebx
* 0x30);
289 while (ebx
< eqhw
->this04
);
292 static void vortex_EqHw_GetLeftGainsCurrent(vortex_t
* vortex
, u16 a
[])
294 eqhw_t
*eqhw
= &(vortex
->eq
.this04
);
297 if (eqhw
->this04
< 0)
301 a
[ebx
] = hwread(vortex
->mmio
, 0x2b028 + ebx
* 0x30);
304 while (ebx
< eqhw
->this04
);
307 static void vortex_EqHw_GetRightGainsCurrent(vortex_t
* vortex
, u16 a
[])
309 eqhw_t
*eqhw
= &(vortex
->eq
.this04
);
312 if (eqhw
->this04
< 0)
316 a
[ebx
] = hwread(vortex
->mmio
, 0x2b208 + ebx
* 0x30);
319 while (ebx
< eqhw
->this04
);
323 /* EQ band levels settings */
324 static void vortex_EqHw_SetLevels(vortex_t
* vortex
, u16 peaks
[])
326 eqhw_t
*eqhw
= &(vortex
->eq
.this04
);
330 for (i
= 0; i
< eqhw
->this04
; i
++) {
331 hwwrite(vortex
->mmio
, 0x2b024 + i
* VORTEX_BAND_COEFF_SIZE
, peaks
[i
]);
334 hwwrite(vortex
->mmio
, 0x2b3cc, peaks
[eqhw
->this04
]);
335 hwwrite(vortex
->mmio
, 0x2b3d8, peaks
[eqhw
->this04
+ 1]);
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)]);
343 hwwrite(vortex
->mmio
, 0x2b3e4, peaks
[2 + (eqhw
->this04
* 2)]);
344 hwwrite(vortex
->mmio
, 0x2b3f0, peaks
[3 + (eqhw
->this04
* 2)]);
348 static void vortex_EqHw_GetLevels(vortex_t
* vortex
, u16 a
[])
350 eqhw_t
*eqhw
= &(vortex
->eq
.this04
);
353 if (eqhw
->this04
< 0)
358 a
[ebx
] = hwread(vortex
->mmio
, 0x2b024 + ebx
* 0x30);
361 while (ebx
< eqhw
->this04
);
363 a
[eqhw
->this04
] = hwread(vortex
->mmio
, 0x2b3cc);
364 a
[eqhw
->this04
+ 1] = hwread(vortex
->mmio
, 0x2b3d8);
368 a
[ebx
+ (eqhw
->this04
+ 2)] =
369 hwread(vortex
->mmio
, 0x2b204 + ebx
* 0x30);
372 while (ebx
< eqhw
->this04
);
374 a
[2 + (eqhw
->this04
* 2)] = hwread(vortex
->mmio
, 0x2b3e4);
375 a
[3 + (eqhw
->this04
* 2)] = hwread(vortex
->mmio
, 0x2b3f0);
380 static void vortex_EqHw_SetControlReg(vortex_t
* vortex
, u32 reg
)
382 hwwrite(vortex
->mmio
, 0x2b440, reg
);
385 static void vortex_EqHw_SetSampleRate(vortex_t
* vortex
, u32 sr
)
387 hwwrite(vortex
->mmio
, 0x2b440, ((sr
& 0x1f) << 3) | 0xb800);
391 static void vortex_EqHw_GetControlReg(vortex_t
* vortex
, u32
*reg
)
393 *reg
= hwread(vortex
->mmio
, 0x2b440);
396 static void vortex_EqHw_GetSampleRate(vortex_t
* vortex
, u32
*sr
)
398 *sr
= (hwread(vortex
->mmio
, 0x2b440) >> 3) & 0x1f;
402 static void vortex_EqHw_Enable(vortex_t
* vortex
)
404 hwwrite(vortex
->mmio
, VORTEX_EQ_CTRL
, 0xf001);
407 static void vortex_EqHw_Disable(vortex_t
* vortex
)
409 hwwrite(vortex
->mmio
, VORTEX_EQ_CTRL
, 0xf000);
412 /* Reset (zero) buffers */
413 static void vortex_EqHw_ZeroIO(vortex_t
* vortex
)
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);
422 static void vortex_EqHw_ZeroA3DIO(vortex_t
* vortex
)
425 for (i
= 0; i
< 0x4; i
++)
426 hwwrite(vortex
->mmio
, VORTEX_EQ_DEST
+ (i
<< 2), 0x0);
429 static void vortex_EqHw_ZeroState(vortex_t
* vortex
)
432 vortex_EqHw_SetControlReg(vortex
, 0);
433 vortex_EqHw_ZeroIO(vortex
);
434 hwwrite(vortex
->mmio
, 0x2b3c0, 0);
436 vortex_EqHw_SetTimeConsts(vortex
, 0, 0);
438 vortex_EqHw_SetLeftCoefs(vortex
, asEqCoefsZeros
);
439 vortex_EqHw_SetRightCoefs(vortex
, asEqCoefsZeros
);
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
);
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
);
455 /* Program coeficients as pass through */
456 static void vortex_EqHw_ProgramPipe(vortex_t
* vortex
)
458 vortex_EqHw_SetTimeConsts(vortex
, 0, 0);
460 vortex_EqHw_SetLeftCoefs(vortex
, asEqCoefsPipes
);
461 vortex_EqHw_SetRightCoefs(vortex
, asEqCoefsPipes
);
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
);
469 /* Program EQ block as 10 band Equalizer */
471 vortex_EqHw_Program10Band(vortex_t
* vortex
, auxxEqCoeffSet_t
* coefset
)
474 vortex_EqHw_SetTimeConsts(vortex
, 0xc, 0x7fe0);
476 vortex_EqHw_SetLeftCoefs(vortex
, coefset
->LeftCoefs
);
477 vortex_EqHw_SetRightCoefs(vortex
, coefset
->RightCoefs
);
479 vortex_EqHw_SetLeftGainsCurrent(vortex
, coefset
->LeftGains
);
481 vortex_EqHw_SetRightGainsTarget(vortex
, coefset
->RightGains
);
482 vortex_EqHw_SetLeftGainsTarget(vortex
, coefset
->LeftGains
);
484 vortex_EqHw_SetRightGainsCurrent(vortex
, coefset
->RightGains
);
487 /* Read all EQ peaks. (think VU meter) */
488 static void vortex_EqHw_GetTenBandLevels(vortex_t
* vortex
, u16 peaks
[])
490 eqhw_t
*eqhw
= &(vortex
->eq
.this04
);
493 if (eqhw
->this04
<= 0)
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);
505 static int vortex_Eqlzr_GetLeftGain(vortex_t
* vortex
, u16 index
, u16
* gain
)
507 eqlzr_t
*eq
= &(vortex
->eq
);
510 *gain
= eq
->this130
[index
];
516 static void vortex_Eqlzr_SetLeftGain(vortex_t
* vortex
, u16 index
, u16 gain
)
518 eqlzr_t
*eq
= &(vortex
->eq
);
523 eq
->this130
[index
] = gain
;
527 vortex_EqHw_SetLeftGainsSingleTarget(vortex
, index
, gain
);
530 static int vortex_Eqlzr_GetRightGain(vortex_t
* vortex
, u16 index
, u16
* gain
)
532 eqlzr_t
*eq
= &(vortex
->eq
);
535 *gain
= eq
->this130
[index
+ eq
->this10
];
541 static void vortex_Eqlzr_SetRightGain(vortex_t
* vortex
, u16 index
, u16 gain
)
543 eqlzr_t
*eq
= &(vortex
->eq
);
548 eq
->this130
[index
+ eq
->this10
] = gain
;
552 vortex_EqHw_SetRightGainsSingleTarget(vortex
, index
, gain
);
557 vortex_Eqlzr_GetAllBands(vortex_t
* vortex
, u16
* gains
, s32
*cnt
)
559 eqlzr_t
*eq
= &(vortex
->eq
);
566 if (vortex_Eqlzr_GetLeftGain(vortex
, si
, &gains
[si
]))
568 if (vortex_Eqlzr_GetRightGain
569 (vortex
, si
, &gains
[si
+ eq
->this10
]))
573 while (eq
->this10
> si
) ;
578 static int vortex_Eqlzr_SetAllBandsFromActiveCoeffSet(vortex_t
* vortex
)
580 eqlzr_t
*eq
= &(vortex
->eq
);
582 vortex_EqHw_SetLeftGainsTarget(vortex
, eq
->this130
);
583 vortex_EqHw_SetRightGainsTarget(vortex
, &(eq
->this130
[eq
->this10
]));
589 vortex_Eqlzr_SetAllBands(vortex_t
* vortex
, u16 gains
[], s32 count
)
591 eqlzr_t
*eq
= &(vortex
->eq
);
594 if (((eq
->this10
) * 2 != count
) || (eq
->this28
== 0))
597 for (i
= 0; i
< count
; i
++) {
598 eq
->this130
[i
] = gains
[i
];
603 return vortex_Eqlzr_SetAllBandsFromActiveCoeffSet(vortex
);
607 vortex_Eqlzr_SetA3dBypassGain(vortex_t
* vortex
, u32 a
, u32 b
)
609 eqlzr_t
*eq
= &(vortex
->eq
);
618 ebx
= (eax
* eq
->this58
) >> 0x10;
619 eax
= (eax
* eq
->this5c
) >> 0x10;
620 vortex_EqHw_SetA3DBypassGain(vortex
, ebx
, eax
);
623 static void vortex_Eqlzr_ProgramA3dBypassGain(vortex_t
* vortex
)
625 eqlzr_t
*eq
= &(vortex
->eq
);
632 ebx
= (eax
* eq
->this58
) >> 0x10;
633 eax
= (eax
* eq
->this5c
) >> 0x10;
634 vortex_EqHw_SetA3DBypassGain(vortex
, ebx
, eax
);
637 static void vortex_Eqlzr_ShutDownA3d(vortex_t
* vortex
)
640 vortex_EqHw_ZeroA3DIO(vortex
);
643 static void vortex_Eqlzr_SetBypass(vortex_t
* vortex
, u32 bp
)
645 eqlzr_t
*eq
= &(vortex
->eq
);
647 if ((eq
->this28
) && (bp
== 0)) {
649 vortex_Eqlzr_SetAllBandsFromActiveCoeffSet(vortex
);
650 vortex_EqHw_SetBypassGain(vortex
, eq
->this08
, eq
->this08
);
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
);
657 vortex_Eqlzr_ProgramA3dBypassGain(vortex
);
660 static void vortex_Eqlzr_ReadAndSetActiveCoefSet(vortex_t
* vortex
)
662 eqlzr_t
*eq
= &(vortex
->eq
);
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);
670 static int vortex_Eqlzr_GetAllPeaks(vortex_t
* vortex
, u16
* peaks
, int *count
)
672 eqlzr_t
*eq
= &(vortex
->eq
);
676 *count
= eq
->this10
* 2;
677 vortex_EqHw_GetTenBandLevels(vortex
, peaks
);
682 static auxxEqCoeffSet_t
*vortex_Eqlzr_GetActiveCoefSet(vortex_t
* vortex
)
684 eqlzr_t
*eq
= &(vortex
->eq
);
686 return (&(eq
->coefset
));
689 static void vortex_Eqlzr_init(vortex_t
* vortex
)
691 eqlzr_t
*eq
= &(vortex
->eq
);
693 /* Object constructor */
695 eq
->this08
= 0; /* Bypass gain with EQ in use. */
697 eq
->this0c
= 0x5999; /* Bypass gain with EQ disabled. */
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) */
708 memset(eq
->this14_array
, 0, sizeof(eq
->this14_array
));
711 vortex_EqHw_ZeroState(vortex
);
712 vortex_EqHw_SetSampleRate(vortex
, 0x11);
713 vortex_Eqlzr_ReadAndSetActiveCoefSet(vortex
);
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
);
721 static void vortex_Eqlzr_shutdown(vortex_t
* vortex
)
723 vortex_Eqlzr_ShutDownA3d(vortex
);
724 vortex_EqHw_ProgramPipe(vortex
);
725 vortex_EqHw_Disable(vortex
);
730 /* Control interface */
731 #define snd_vortex_eqtoggle_info snd_ctl_boolean_mono_info
734 snd_vortex_eqtoggle_get(struct snd_kcontrol
*kcontrol
,
735 struct snd_ctl_elem_value
*ucontrol
)
737 vortex_t
*vortex
= snd_kcontrol_chip(kcontrol
);
738 eqlzr_t
*eq
= &(vortex
->eq
);
739 //int i = kcontrol->private_value;
741 ucontrol
->value
.integer
.value
[0] = eq
->this54
? 0 : 1;
747 snd_vortex_eqtoggle_put(struct snd_kcontrol
*kcontrol
,
748 struct snd_ctl_elem_value
*ucontrol
)
750 vortex_t
*vortex
= snd_kcontrol_chip(kcontrol
);
751 eqlzr_t
*eq
= &(vortex
->eq
);
752 //int i = kcontrol->private_value;
754 eq
->this54
= ucontrol
->value
.integer
.value
[0] ? 0 : 1;
755 vortex_Eqlzr_SetBypass(vortex
, eq
->this54
);
757 return 1; /* Allways changes */
760 static const struct snd_kcontrol_new vortex_eqtoggle_kcontrol
= {
761 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
764 .access
= SNDRV_CTL_ELEM_ACCESS_READWRITE
,
766 .info
= snd_vortex_eqtoggle_info
,
767 .get
= snd_vortex_eqtoggle_get
,
768 .put
= snd_vortex_eqtoggle_put
772 snd_vortex_eq_info(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
774 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
776 uinfo
->value
.integer
.min
= 0x0000;
777 uinfo
->value
.integer
.max
= 0x7fff;
782 snd_vortex_eq_get(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
784 vortex_t
*vortex
= snd_kcontrol_chip(kcontrol
);
785 int i
= kcontrol
->private_value
;
786 u16 gainL
= 0, gainR
= 0;
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
;
796 snd_vortex_eq_put(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
798 vortex_t
*vortex
= snd_kcontrol_chip(kcontrol
);
799 int changed
= 0, i
= kcontrol
->private_value
;
800 u16 gainL
= 0, gainR
= 0;
802 vortex_Eqlzr_GetLeftGain(vortex
, i
, &gainL
);
803 vortex_Eqlzr_GetRightGain(vortex
, i
, &gainR
);
805 if (gainL
!= ucontrol
->value
.integer
.value
[0]) {
806 vortex_Eqlzr_SetLeftGain(vortex
, i
,
807 ucontrol
->value
.integer
.value
[0]);
810 if (gainR
!= ucontrol
->value
.integer
.value
[1]) {
811 vortex_Eqlzr_SetRightGain(vortex
, i
,
812 ucontrol
->value
.integer
.value
[1]);
818 static const struct snd_kcontrol_new vortex_eq_kcontrol
= {
819 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
822 .access
= SNDRV_CTL_ELEM_ACCESS_READWRITE
,
824 .info
= snd_vortex_eq_info
,
825 .get
= snd_vortex_eq_get
,
826 .put
= snd_vortex_eq_put
830 snd_vortex_peaks_info(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
832 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
834 uinfo
->value
.integer
.min
= 0x0000;
835 uinfo
->value
.integer
.max
= 0x7fff;
840 snd_vortex_peaks_get(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
842 vortex_t
*vortex
= snd_kcontrol_chip(kcontrol
);
846 vortex_Eqlzr_GetAllPeaks(vortex
, peaks
, &count
);
848 dev_err(vortex
->card
->dev
,
849 "peak count error 20 != %d\n", count
);
852 for (i
= 0; i
< 20; i
++)
853 ucontrol
->value
.integer
.value
[i
] = peaks
[i
];
858 static const struct snd_kcontrol_new vortex_levels_kcontrol
= {
859 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
861 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
862 .info
= snd_vortex_peaks_info
,
863 .get
= snd_vortex_peaks_get
,
866 /* EQ band gain labels. */
867 static char *EqBandLabels
[10] = {
880 /* ALSA driver entry points. Init and exit. */
881 static int vortex_eq_init(vortex_t
*vortex
)
883 struct snd_kcontrol
*kcontrol
;
886 vortex_Eqlzr_init(vortex
);
889 snd_ctl_new1(&vortex_eqtoggle_kcontrol
, vortex
)) == NULL
)
891 kcontrol
->private_value
= 0;
892 if ((err
= snd_ctl_add(vortex
->card
, kcontrol
)) < 0)
895 /* EQ gain controls */
896 for (i
= 0; i
< 10; i
++) {
898 snd_ctl_new1(&vortex_eq_kcontrol
, vortex
)) == NULL
)
900 snprintf(kcontrol
->id
.name
, sizeof(kcontrol
->id
.name
),
901 "%s Playback Volume", EqBandLabels
[i
]);
902 kcontrol
->private_value
= i
;
903 if ((err
= snd_ctl_add(vortex
->card
, kcontrol
)) < 0)
905 //vortex->eqctrl[i] = kcontrol;
908 if ((kcontrol
= snd_ctl_new1(&vortex_levels_kcontrol
, vortex
)) == NULL
)
910 if ((err
= snd_ctl_add(vortex
->card
, kcontrol
)) < 0)
916 static int vortex_eq_free(vortex_t
* vortex
)
919 //FIXME: segfault because vortex->eqctrl[i] == 4
921 for (i=0; i<10; i++) {
922 if (vortex->eqctrl[i])
923 snd_ctl_remove(vortex->card, vortex->eqctrl[i]);
926 vortex_Eqlzr_shutdown(vortex
);