CoCalc -- au88x0

GitHub Repository: torvalds/linux
Path: blob/master/sound/pci/au88x0/au88x0_xtalk.c
²⁶⁴⁵¹ views
1
// SPDX-License-Identifier: GPL-2.0-or-later
2
/***************************************************************************
3
 *            au88x0_cxtalk.c
4
 *
5
 *  Wed Nov 19 16:29:47 2003
6
 *  Copyright  2003  mjander
7
 *  [email protected]
8
 ****************************************************************************/
9

10
/*
11
 */
12

13
#include "au88x0_xtalk.h"
14

15
/* Data (a whole lot of data.... ) */
16

17
static short const sXtalkWideKLeftEq = 0x269C;
18
static short const sXtalkWideKRightEq = 0x269C;
19
static short const sXtalkWideKLeftXt = 0xF25E;
20
static __maybe_unused short const sXtalkWideKRightXt = 0xF25E;
21
static short const sXtalkWideShiftLeftEq = 1;
22
static short const sXtalkWideShiftRightEq = 1;
23
static short const sXtalkWideShiftLeftXt = 0;
24
static __maybe_unused short const sXtalkWideShiftRightXt = 0;
25
static unsigned short const wXtalkWideLeftDelay = 0xd;
26
static unsigned short const wXtalkWideRightDelay = 0xd;
27
static short const sXtalkNarrowKLeftEq = 0x468D;
28
static short const sXtalkNarrowKRightEq = 0x468D;
29
static short const sXtalkNarrowKLeftXt = 0xF82E;
30
static __maybe_unused short const sXtalkNarrowKRightXt = 0xF82E;
31
static short const sXtalkNarrowShiftLeftEq = 0x3;
32
static short const sXtalkNarrowShiftRightEq = 0x3;
33
static short const sXtalkNarrowShiftLeftXt = 0;
34
static __maybe_unused short const sXtalkNarrowShiftRightXt = 0;
35
static unsigned short const wXtalkNarrowLeftDelay = 0x7;
36
static unsigned short const wXtalkNarrowRightDelay = 0x7;
37

38
static __maybe_unused xtalk_gains_t const asXtalkGainsDefault = {
39
	0x4000, 0x4000, 0x4000, 0x4000, 0x4000,
40
	0x4000, 0x4000, 0x4000, 0x4000,	0x4000
41
};
42

43
static __maybe_unused xtalk_gains_t const asXtalkGainsTest = {
44
	0x7fff, 0x8000, 0x0000, 0x0000, 0x0001,
45
	0xffff, 0x4000, 0xc000, 0x0002, 0xfffe
46
};
47

48
static __maybe_unused xtalk_gains_t const asXtalkGains1Chan = {
49
	0x7FFF, 0, 0, 0, 0,
50
	0x7FFF, 0, 0, 0, 0,
51
};
52

53
// Input gain for 4 A3D slices. One possible input pair is left zero.
54
static xtalk_gains_t const asXtalkGainsAllChan = {
55
	0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0,
56
	0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF,	0
57
};
58

59
static xtalk_gains_t const asXtalkGainsZeros = {
60
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0
61
};
62

63
static xtalk_dline_t const alXtalkDlineZeros = {
64
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
65
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
66
};
67
static __maybe_unused xtalk_dline_t const alXtalkDlineTest = {
68
	0x0000fc18, 0xfff03e8, 0x000186a0, 0xfffe7960, 1, 0xffffffff, 0, 0,
69
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
70
	0, 0, 0, 0, 0, 0, 0, 0
71
};
72

73
static xtalk_instate_t const asXtalkInStateZeros = {
74
	0, 0, 0, 0
75
};
76

77
static __maybe_unused xtalk_instate_t const asXtalkInStateTest = {
78
	0x0080, 0xff80, 0x0001, 0xffff
79
};
80

81
static xtalk_state_t const asXtalkOutStateZeros = {
82
	{0, 0, 0, 0},
83
	{0, 0, 0, 0},
84
	{0, 0, 0, 0},
85
	{0, 0, 0, 0},
86
	{0, 0, 0, 0}
87
};
88

89
static short const sDiamondKLeftEq = 0x401d;
90
static short const sDiamondKRightEq = 0x401d;
91
static short const sDiamondKLeftXt = 0xF90E;
92
static __maybe_unused short const sDiamondKRightXt = 0xF90E;
93
static short const sDiamondShiftLeftEq = 1;
94
static short const sDiamondShiftRightEq = 1;
95
static short const sDiamondShiftLeftXt = 0;
96
static __maybe_unused short const sDiamondShiftRightXt = 0;
97
static unsigned short const wDiamondLeftDelay = 0xb;
98
static unsigned short const wDiamondRightDelay = 0xb;
99

100
static xtalk_coefs_t const asXtalkWideCoefsLeftEq = {
101
	{0xEC4C, 0xDCE9, 0xFDC2, 0xFEEC, 0},
102
	{0x5F60, 0xCBCB, 0xFC26, 0x0305, 0},
103
	{0x340B, 0xe8f5, 0x236c, 0xe40d, 0},
104
	{0x76d5, 0xc78d, 0x05ac, 0xfa5b, 0},
105
	{0x7F04, 0xC0FA, 0x0263, 0xFDA2, 0}
106
};
107
static xtalk_coefs_t const asXtalkWideCoefsRightEq = {
108
	{0xEC4C, 0xDCE9, 0xFDC2, 0xFEEC, 0},
109
	{0x5F60, 0xCBCB, 0xFC26, 0x0305, 0},
110
	{0x340B, 0xe8f5, 0x236c, 0xe40d, 0},
111
	{0x76d5, 0xc78d, 0x05ac, 0xfa5b, 0},
112
	{0x7F04, 0xC0FA, 0x0263, 0xFDA2, 0}
113
};
114
static xtalk_coefs_t const asXtalkWideCoefsLeftXt = {
115
	{0x55c6, 0xc97b, 0x005b, 0x0047, 0},
116
	{0x6a60, 0xca20, 0xffc6, 0x0040, 0},
117
	{0x6411, 0xd711, 0xfca1, 0x0190, 0},
118
	{0x77dc, 0xc79e, 0xffb8, 0x000a, 0},
119
	{0, 0, 0, 0, 0}
120
};
121
static __maybe_unused xtalk_coefs_t const asXtalkWideCoefsRightXt = {
122
	{0x55c6, 0xc97b, 0x005b, 0x0047, 0},
123
	{0x6a60, 0xca20, 0xffc6, 0x0040, 0},
124
	{0x6411, 0xd711, 0xfca1, 0x0190, 0},
125
	{0x77dc, 0xc79e, 0xffb8, 0x000a, 0},
126
	{0, 0, 0, 0, 0}
127
};
128
static xtalk_coefs_t const asXtalkNarrowCoefsLeftEq = {
129
	{0x50B5, 0xD07C, 0x026D, 0xFD21, 0},
130
	{0x460F, 0xE44F, 0xF75E, 0xEFA6, 0},
131
	{0x556D, 0xDCAB, 0x2098, 0xF0F2, 0},
132
	{0x7E03, 0xC1F0, 0x007D, 0xFF89, 0},
133
	{0x383E, 0xFD9D, 0xB278, 0x4547, 0}
134
};
135

136
static xtalk_coefs_t const asXtalkNarrowCoefsRightEq = {
137
	{0x50B5, 0xD07C, 0x026D, 0xFD21, 0},
138
	{0x460F, 0xE44F, 0xF75E, 0xEFA6, 0},
139
	{0x556D, 0xDCAB, 0x2098, 0xF0F2, 0},
140
	{0x7E03, 0xC1F0, 0x007D, 0xFF89, 0},
141
	{0x383E, 0xFD9D, 0xB278, 0x4547, 0}
142
};
143

144
static xtalk_coefs_t const asXtalkNarrowCoefsLeftXt = {
145
	{0x3CB2, 0xDF49, 0xF6EA, 0x095B, 0},
146
	{0x6777, 0xC915, 0xFEAF, 0x00B1, 0},
147
	{0x7762, 0xC7D9, 0x025B, 0xFDA6, 0},
148
	{0x6B7A, 0xD2AA, 0xF2FB, 0x0B64, 0},
149
	{0, 0, 0, 0, 0}
150
};
151

152
static __maybe_unused xtalk_coefs_t const asXtalkNarrowCoefsRightXt = {
153
	{0x3CB2, 0xDF49, 0xF6EA, 0x095B, 0},
154
	{0x6777, 0xC915, 0xFEAF, 0x00B1, 0},
155
	{0x7762, 0xC7D9, 0x025B, 0xFDA6, 0},
156
	{0x6B7A, 0xD2AA, 0xF2FB, 0x0B64, 0},
157
	{0, 0, 0, 0, 0}
158
};
159

160
static xtalk_coefs_t const asXtalkCoefsZeros = {
161
	{0, 0, 0, 0, 0},
162
	{0, 0, 0, 0, 0},
163
	{0, 0, 0, 0, 0},
164
	{0, 0, 0, 0, 0},
165
	{0, 0, 0, 0, 0}
166
};
167

168
static xtalk_coefs_t const asXtalkCoefsPipe = {
169
	{0, 0, 0x0FA0, 0, 0},
170
	{0, 0, 0x0FA0, 0, 0},
171
	{0, 0, 0x0FA0, 0, 0},
172
	{0, 0, 0x0FA0, 0, 0},
173
	{0, 0, 0x1180, 0, 0},
174
};
175
static __maybe_unused xtalk_coefs_t const asXtalkCoefsNegPipe = {
176
	{0, 0, 0xF380, 0, 0},
177
	{0, 0, 0xF380, 0, 0},
178
	{0, 0, 0xF380, 0, 0},
179
	{0, 0, 0xF380, 0, 0},
180
	{0, 0, 0xF200, 0, 0}
181
};
182

183
static __maybe_unused xtalk_coefs_t const asXtalkCoefsNumTest = {
184
	{0, 0, 0xF380, 0x8000, 0x6D60},
185
	{0, 0, 0, 0, 0},
186
	{0, 0, 0, 0, 0},
187
	{0, 0, 0, 0, 0},
188
	{0, 0, 0, 0, 0}
189
};
190

191
static __maybe_unused xtalk_coefs_t const asXtalkCoefsDenTest = {
192
	{0xC000, 0x2000, 0x4000, 0, 0},
193
	{0, 0, 0, 0, 0},
194
	{0, 0, 0, 0, 0},
195
	{0, 0, 0, 0, 0},
196
	{0, 0, 0, 0, 0}
197
};
198

199
static __maybe_unused xtalk_state_t const asXtalkOutStateTest = {
200
	{0x7FFF, 0x0004, 0xFFFC, 0},
201
	{0xFE00, 0x0008, 0xFFF8, 0x4000},
202
	{0x0200, 0x0010, 0xFFF0, 0xC000},
203
	{0x8000, 0x0020, 0xFFE0, 0},
204
	{0, 0, 0, 0}
205
};
206

207
static xtalk_coefs_t const asDiamondCoefsLeftEq = {
208
	{0x0F1E, 0x2D05, 0xF8E3, 0x07C8, 0},
209
	{0x45E2, 0xCA51, 0x0448, 0xFCE7, 0},
210
	{0xA93E, 0xDBD5, 0x022C, 0x028A, 0},
211
	{0, 0, 0, 0, 0},
212
	{0, 0, 0, 0, 0}
213
};
214

215
static xtalk_coefs_t const asDiamondCoefsRightEq = {
216
	{0x0F1E, 0x2D05, 0xF8E3, 0x07C8, 0},
217
	{0x45E2, 0xCA51, 0x0448, 0xFCE7, 0},
218
	{0xA93E, 0xDBD5, 0x022C, 0x028A, 0},
219
	{0, 0, 0, 0, 0},
220
	{0, 0, 0, 0, 0}
221
};
222

223
static xtalk_coefs_t const asDiamondCoefsLeftXt = {
224
	{0x3B50, 0xFE08, 0xF959, 0x0060, 0},
225
	{0x9FCB, 0xD8F1, 0x00A2, 0x003A, 0},
226
	{0, 0, 0, 0, 0},
227
	{0, 0, 0, 0, 0},
228
	{0, 0, 0, 0, 0}
229
};
230

231
static __maybe_unused xtalk_coefs_t const asDiamondCoefsRightXt = {
232
	{0x3B50, 0xFE08, 0xF959, 0x0060, 0},
233
	{0x9FCB, 0xD8F1, 0x00A2, 0x003A, 0},
234
	{0, 0, 0, 0, 0},
235
	{0, 0, 0, 0, 0},
236
	{0, 0, 0, 0, 0}
237
};
238

239
 /**/
240
/* XTalk EQ and XT */
241
static void
242
vortex_XtalkHw_SetLeftEQ(vortex_t * vortex, short arg_0, short arg_4,
243
			 xtalk_coefs_t const coefs)
244
{
245
	int i;
246

247
	for (i = 0; i < 5; i++) {
248
		hwwrite(vortex->mmio, 0x24200 + i * 0x24, coefs[i][0]);
249
		hwwrite(vortex->mmio, 0x24204 + i * 0x24, coefs[i][1]);
250
		hwwrite(vortex->mmio, 0x24208 + i * 0x24, coefs[i][2]);
251
		hwwrite(vortex->mmio, 0x2420c + i * 0x24, coefs[i][3]);
252
		hwwrite(vortex->mmio, 0x24210 + i * 0x24, coefs[i][4]);
253
	}
254
	hwwrite(vortex->mmio, 0x24538, arg_0 & 0xffff);
255
	hwwrite(vortex->mmio, 0x2453C, arg_4 & 0xffff);
256
}
257

258
static void
259
vortex_XtalkHw_SetRightEQ(vortex_t * vortex, short arg_0, short arg_4,
260
			  xtalk_coefs_t const coefs)
261
{
262
	int i;
263

264
	for (i = 0; i < 5; i++) {
265
		hwwrite(vortex->mmio, 0x242b4 + i * 0x24, coefs[i][0]);
266
		hwwrite(vortex->mmio, 0x242b8 + i * 0x24, coefs[i][1]);
267
		hwwrite(vortex->mmio, 0x242bc + i * 0x24, coefs[i][2]);
268
		hwwrite(vortex->mmio, 0x242c0 + i * 0x24, coefs[i][3]);
269
		hwwrite(vortex->mmio, 0x242c4 + i * 0x24, coefs[i][4]);
270
	}
271
	hwwrite(vortex->mmio, 0x24540, arg_0 & 0xffff);
272
	hwwrite(vortex->mmio, 0x24544, arg_4 & 0xffff);
273
}
274

275
static void
276
vortex_XtalkHw_SetLeftXT(vortex_t * vortex, short arg_0, short arg_4,
277
			 xtalk_coefs_t const coefs)
278
{
279
	int i;
280

281
	for (i = 0; i < 5; i++) {
282
		hwwrite(vortex->mmio, 0x24368 + i * 0x24, coefs[i][0]);
283
		hwwrite(vortex->mmio, 0x2436c + i * 0x24, coefs[i][1]);
284
		hwwrite(vortex->mmio, 0x24370 + i * 0x24, coefs[i][2]);
285
		hwwrite(vortex->mmio, 0x24374 + i * 0x24, coefs[i][3]);
286
		hwwrite(vortex->mmio, 0x24378 + i * 0x24, coefs[i][4]);
287
	}
288
	hwwrite(vortex->mmio, 0x24548, arg_0 & 0xffff);
289
	hwwrite(vortex->mmio, 0x2454C, arg_4 & 0xffff);
290
}
291

292
static void
293
vortex_XtalkHw_SetRightXT(vortex_t * vortex, short arg_0, short arg_4,
294
			  xtalk_coefs_t const coefs)
295
{
296
	int i;
297

298
	for (i = 0; i < 5; i++) {
299
		hwwrite(vortex->mmio, 0x2441C + i * 0x24, coefs[i][0]);
300
		hwwrite(vortex->mmio, 0x24420 + i * 0x24, coefs[i][1]);
301
		hwwrite(vortex->mmio, 0x24424 + i * 0x24, coefs[i][2]);
302
		hwwrite(vortex->mmio, 0x24428 + i * 0x24, coefs[i][3]);
303
		hwwrite(vortex->mmio, 0x2442C + i * 0x24, coefs[i][4]);
304
	}
305
	hwwrite(vortex->mmio, 0x24550, arg_0 & 0xffff);
306
	hwwrite(vortex->mmio, 0x24554, arg_4 & 0xffff);
307
}
308

309
static void
310
vortex_XtalkHw_SetLeftEQStates(vortex_t * vortex,
311
			       xtalk_instate_t const arg_0,
312
			       xtalk_state_t const coefs)
313
{
314
	int i;
315

316
	for (i = 0; i < 5; i++) {
317
		hwwrite(vortex->mmio, 0x24214 + i * 0x24, coefs[i][0]);
318
		hwwrite(vortex->mmio, 0x24218 + i * 0x24, coefs[i][1]);
319
		hwwrite(vortex->mmio, 0x2421C + i * 0x24, coefs[i][2]);
320
		hwwrite(vortex->mmio, 0x24220 + i * 0x24, coefs[i][3]);
321
	}
322
	hwwrite(vortex->mmio, 0x244F8, arg_0[0]);
323
	hwwrite(vortex->mmio, 0x244FC, arg_0[1]);
324
	hwwrite(vortex->mmio, 0x24500, arg_0[2]);
325
	hwwrite(vortex->mmio, 0x24504, arg_0[3]);
326
}
327

328
static void
329
vortex_XtalkHw_SetRightEQStates(vortex_t * vortex,
330
				xtalk_instate_t const arg_0,
331
				xtalk_state_t const coefs)
332
{
333
	int i;
334

335
	for (i = 0; i < 5; i++) {
336
		hwwrite(vortex->mmio, 0x242C8 + i * 0x24, coefs[i][0]);
337
		hwwrite(vortex->mmio, 0x242CC + i * 0x24, coefs[i][1]);
338
		hwwrite(vortex->mmio, 0x242D0 + i * 0x24, coefs[i][2]);
339
		hwwrite(vortex->mmio, 0x244D4 + i * 0x24, coefs[i][3]);
340
	}
341
	hwwrite(vortex->mmio, 0x24508, arg_0[0]);
342
	hwwrite(vortex->mmio, 0x2450C, arg_0[1]);
343
	hwwrite(vortex->mmio, 0x24510, arg_0[2]);
344
	hwwrite(vortex->mmio, 0x24514, arg_0[3]);
345
}
346

347
static void
348
vortex_XtalkHw_SetLeftXTStates(vortex_t * vortex,
349
			       xtalk_instate_t const arg_0,
350
			       xtalk_state_t const coefs)
351
{
352
	int i;
353

354
	for (i = 0; i < 5; i++) {
355
		hwwrite(vortex->mmio, 0x2437C + i * 0x24, coefs[i][0]);
356
		hwwrite(vortex->mmio, 0x24380 + i * 0x24, coefs[i][1]);
357
		hwwrite(vortex->mmio, 0x24384 + i * 0x24, coefs[i][2]);
358
		hwwrite(vortex->mmio, 0x24388 + i * 0x24, coefs[i][3]);
359
	}
360
	hwwrite(vortex->mmio, 0x24518, arg_0[0]);
361
	hwwrite(vortex->mmio, 0x2451C, arg_0[1]);
362
	hwwrite(vortex->mmio, 0x24520, arg_0[2]);
363
	hwwrite(vortex->mmio, 0x24524, arg_0[3]);
364
}
365

366
static void
367
vortex_XtalkHw_SetRightXTStates(vortex_t * vortex,
368
				xtalk_instate_t const arg_0,
369
				xtalk_state_t const coefs)
370
{
371
	int i;
372

373
	for (i = 0; i < 5; i++) {
374
		hwwrite(vortex->mmio, 0x24430 + i * 0x24, coefs[i][0]);
375
		hwwrite(vortex->mmio, 0x24434 + i * 0x24, coefs[i][1]);
376
		hwwrite(vortex->mmio, 0x24438 + i * 0x24, coefs[i][2]);
377
		hwwrite(vortex->mmio, 0x2443C + i * 0x24, coefs[i][3]);
378
	}
379
	hwwrite(vortex->mmio, 0x24528, arg_0[0]);
380
	hwwrite(vortex->mmio, 0x2452C, arg_0[1]);
381
	hwwrite(vortex->mmio, 0x24530, arg_0[2]);
382
	hwwrite(vortex->mmio, 0x24534, arg_0[3]);
383
}
384

385
#if 0
386
static void
387
vortex_XtalkHw_GetLeftEQ(vortex_t * vortex, short *arg_0, short *arg_4,
388
			 xtalk_coefs_t coefs)
389
{
390
	int i;
391

392
	for (i = 0; i < 5; i++) {
393
		coefs[i][0] = hwread(vortex->mmio, 0x24200 + i * 0x24);
394
		coefs[i][1] = hwread(vortex->mmio, 0x24204 + i * 0x24);
395
		coefs[i][2] = hwread(vortex->mmio, 0x24208 + i * 0x24);
396
		coefs[i][3] = hwread(vortex->mmio, 0x2420c + i * 0x24);
397
		coefs[i][4] = hwread(vortex->mmio, 0x24210 + i * 0x24);
398
	}
399
	*arg_0 = hwread(vortex->mmio, 0x24538) & 0xffff;
400
	*arg_4 = hwread(vortex->mmio, 0x2453c) & 0xffff;
401
}
402

403
static void
404
vortex_XtalkHw_GetRightEQ(vortex_t * vortex, short *arg_0, short *arg_4,
405
			  xtalk_coefs_t coefs)
406
{
407
	int i;
408

409
	for (i = 0; i < 5; i++) {
410
		coefs[i][0] = hwread(vortex->mmio, 0x242b4 + i * 0x24);
411
		coefs[i][1] = hwread(vortex->mmio, 0x242b8 + i * 0x24);
412
		coefs[i][2] = hwread(vortex->mmio, 0x242bc + i * 0x24);
413
		coefs[i][3] = hwread(vortex->mmio, 0x242c0 + i * 0x24);
414
		coefs[i][4] = hwread(vortex->mmio, 0x242c4 + i * 0x24);
415
	}
416
	*arg_0 = hwread(vortex->mmio, 0x24540) & 0xffff;
417
	*arg_4 = hwread(vortex->mmio, 0x24544) & 0xffff;
418
}
419

420
static void
421
vortex_XtalkHw_GetLeftXT(vortex_t * vortex, short *arg_0, short *arg_4,
422
			 xtalk_coefs_t coefs)
423
{
424
	int i;
425

426
	for (i = 0; i < 5; i++) {
427
		coefs[i][0] = hwread(vortex->mmio, 0x24368 + i * 0x24);
428
		coefs[i][1] = hwread(vortex->mmio, 0x2436C + i * 0x24);
429
		coefs[i][2] = hwread(vortex->mmio, 0x24370 + i * 0x24);
430
		coefs[i][3] = hwread(vortex->mmio, 0x24374 + i * 0x24);
431
		coefs[i][4] = hwread(vortex->mmio, 0x24378 + i * 0x24);
432
	}
433
	*arg_0 = hwread(vortex->mmio, 0x24548) & 0xffff;
434
	*arg_4 = hwread(vortex->mmio, 0x2454C) & 0xffff;
435
}
436

437
static void
438
vortex_XtalkHw_GetRightXT(vortex_t * vortex, short *arg_0, short *arg_4,
439
			  xtalk_coefs_t coefs)
440
{
441
	int i;
442

443
	for (i = 0; i < 5; i++) {
444
		coefs[i][0] = hwread(vortex->mmio, 0x2441C + i * 0x24);
445
		coefs[i][1] = hwread(vortex->mmio, 0x24420 + i * 0x24);
446
		coefs[i][2] = hwread(vortex->mmio, 0x24424 + i * 0x24);
447
		coefs[i][3] = hwread(vortex->mmio, 0x24428 + i * 0x24);
448
		coefs[i][4] = hwread(vortex->mmio, 0x2442C + i * 0x24);
449
	}
450
	*arg_0 = hwread(vortex->mmio, 0x24550) & 0xffff;
451
	*arg_4 = hwread(vortex->mmio, 0x24554) & 0xffff;
452
}
453

454
static void
455
vortex_XtalkHw_GetLeftEQStates(vortex_t * vortex, xtalk_instate_t arg_0,
456
			       xtalk_state_t coefs)
457
{
458
	int i;
459

460
	for (i = 0; i < 5; i++) {
461
		coefs[i][0] = hwread(vortex->mmio, 0x24214 + i * 0x24);
462
		coefs[i][1] = hwread(vortex->mmio, 0x24218 + i * 0x24);
463
		coefs[i][2] = hwread(vortex->mmio, 0x2421C + i * 0x24);
464
		coefs[i][3] = hwread(vortex->mmio, 0x24220 + i * 0x24);
465
	}
466
	arg_0[0] = hwread(vortex->mmio, 0x244F8);
467
	arg_0[1] = hwread(vortex->mmio, 0x244FC);
468
	arg_0[2] = hwread(vortex->mmio, 0x24500);
469
	arg_0[3] = hwread(vortex->mmio, 0x24504);
470
}
471

472
static void
473
vortex_XtalkHw_GetRightEQStates(vortex_t * vortex, xtalk_instate_t arg_0,
474
				xtalk_state_t coefs)
475
{
476
	int i;
477

478
	for (i = 0; i < 5; i++) {
479
		coefs[i][0] = hwread(vortex->mmio, 0x242C8 + i * 0x24);
480
		coefs[i][1] = hwread(vortex->mmio, 0x242CC + i * 0x24);
481
		coefs[i][2] = hwread(vortex->mmio, 0x242D0 + i * 0x24);
482
		coefs[i][3] = hwread(vortex->mmio, 0x242D4 + i * 0x24);
483
	}
484
	arg_0[0] = hwread(vortex->mmio, 0x24508);
485
	arg_0[1] = hwread(vortex->mmio, 0x2450C);
486
	arg_0[2] = hwread(vortex->mmio, 0x24510);
487
	arg_0[3] = hwread(vortex->mmio, 0x24514);
488
}
489

490
static void
491
vortex_XtalkHw_GetLeftXTStates(vortex_t * vortex, xtalk_instate_t arg_0,
492
			       xtalk_state_t coefs)
493
{
494
	int i;
495

496
	for (i = 0; i < 5; i++) {
497
		coefs[i][0] = hwread(vortex->mmio, 0x2437C + i * 0x24);
498
		coefs[i][1] = hwread(vortex->mmio, 0x24380 + i * 0x24);
499
		coefs[i][2] = hwread(vortex->mmio, 0x24384 + i * 0x24);
500
		coefs[i][3] = hwread(vortex->mmio, 0x24388 + i * 0x24);
501
	}
502
	arg_0[0] = hwread(vortex->mmio, 0x24518);
503
	arg_0[1] = hwread(vortex->mmio, 0x2451C);
504
	arg_0[2] = hwread(vortex->mmio, 0x24520);
505
	arg_0[3] = hwread(vortex->mmio, 0x24524);
506
}
507

508
static void
509
vortex_XtalkHw_GetRightXTStates(vortex_t * vortex, xtalk_instate_t arg_0,
510
				xtalk_state_t coefs)
511
{
512
	int i;
513

514
	for (i = 0; i < 5; i++) {
515
		coefs[i][0] = hwread(vortex->mmio, 0x24430 + i * 0x24);
516
		coefs[i][1] = hwread(vortex->mmio, 0x24434 + i * 0x24);
517
		coefs[i][2] = hwread(vortex->mmio, 0x24438 + i * 0x24);
518
		coefs[i][3] = hwread(vortex->mmio, 0x2443C + i * 0x24);
519
	}
520
	arg_0[0] = hwread(vortex->mmio, 0x24528);
521
	arg_0[1] = hwread(vortex->mmio, 0x2452C);
522
	arg_0[2] = hwread(vortex->mmio, 0x24530);
523
	arg_0[3] = hwread(vortex->mmio, 0x24534);
524
}
525

526
#endif
527
/* Gains */
528

529
static void
530
vortex_XtalkHw_SetGains(vortex_t * vortex, xtalk_gains_t const gains)
531
{
532
	int i;
533

534
	for (i = 0; i < XTGAINS_SZ; i++) {
535
		hwwrite(vortex->mmio, 0x244D0 + (i * 4), gains[i]);
536
	}
537
}
538

539
static void
540
vortex_XtalkHw_SetGainsAllChan(vortex_t * vortex)
541
{
542
	vortex_XtalkHw_SetGains(vortex, asXtalkGainsAllChan);
543
}
544

545
#if 0
546
static void vortex_XtalkHw_GetGains(vortex_t * vortex, xtalk_gains_t gains)
547
{
548
	int i;
549

550
	for (i = 0; i < XTGAINS_SZ; i++)
551
		gains[i] = hwread(vortex->mmio, 0x244D0 + i * 4);
552
}
553

554
#endif
555
/* Delay parameters */
556

557
static void
558
vortex_XtalkHw_SetDelay(vortex_t * vortex, unsigned short right,
559
			unsigned short left)
560
{
561
	u32 esp0 = 0;
562

563
	esp0 &= 0x1FFFFFFF;
564
	esp0 |= 0xA0000000;
565
	esp0 = (esp0 & 0xffffE0ff) | ((right & 0x1F) << 8);
566
	esp0 = (esp0 & 0xfffc1fff) | ((left & 0x1F) << 0xd);
567

568
	hwwrite(vortex->mmio, 0x24660, esp0);
569
}
570

571
static void
572
vortex_XtalkHw_SetLeftDline(vortex_t * vortex, xtalk_dline_t const dline)
573
{
574
	int i;
575

576
	for (i = 0; i < 0x20; i++) {
577
		hwwrite(vortex->mmio, 0x24000 + (i << 2), dline[i] & 0xffff);
578
		hwwrite(vortex->mmio, 0x24080 + (i << 2), dline[i] >> 0x10);
579
	}
580
}
581

582
static void
583
vortex_XtalkHw_SetRightDline(vortex_t * vortex, xtalk_dline_t const dline)
584
{
585
	int i;
586

587
	for (i = 0; i < 0x20; i++) {
588
		hwwrite(vortex->mmio, 0x24100 + (i << 2), dline[i] & 0xffff);
589
		hwwrite(vortex->mmio, 0x24180 + (i << 2), dline[i] >> 0x10);
590
	}
591
}
592

593
#if 0
594
static void
595
vortex_XtalkHw_GetDelay(vortex_t * vortex, unsigned short *right,
596
			unsigned short *left)
597
{
598
	int esp0;
599

600
	esp0 = hwread(vortex->mmio, 0x24660);
601
	*right = (esp0 >> 8) & 0x1f;
602
	*left = (esp0 >> 0xd) & 0x1f;
603
}
604

605
static void vortex_XtalkHw_GetLeftDline(vortex_t * vortex, xtalk_dline_t dline)
606
{
607
	int i;
608

609
	for (i = 0; i < 0x20; i++) {
610
		dline[i] =
611
		    (hwread(vortex->mmio, 0x24000 + (i << 2)) & 0xffff) |
612
		    (hwread(vortex->mmio, 0x24080 + (i << 2)) << 0x10);
613
	}
614
}
615

616
static void vortex_XtalkHw_GetRightDline(vortex_t * vortex, xtalk_dline_t dline)
617
{
618
	int i;
619

620
	for (i = 0; i < 0x20; i++) {
621
		dline[i] =
622
		    (hwread(vortex->mmio, 0x24100 + (i << 2)) & 0xffff) |
623
		    (hwread(vortex->mmio, 0x24180 + (i << 2)) << 0x10);
624
	}
625
}
626

627
#endif
628
/* Control/Global stuff */
629

630
#if 0
631
static void vortex_XtalkHw_SetControlReg(vortex_t * vortex, u32 ctrl)
632
{
633
	hwwrite(vortex->mmio, 0x24660, ctrl);
634
}
635
static void vortex_XtalkHw_GetControlReg(vortex_t * vortex, u32 *ctrl)
636
{
637
	*ctrl = hwread(vortex->mmio, 0x24660);
638
}
639
#endif
640
static void vortex_XtalkHw_SetSampleRate(vortex_t * vortex, u32 sr)
641
{
642
	u32 temp;
643

644
	temp = (hwread(vortex->mmio, 0x24660) & 0x1FFFFFFF) | 0xC0000000;
645
	temp = (temp & 0xffffff07) | ((sr & 0x1f) << 3);
646
	hwwrite(vortex->mmio, 0x24660, temp);
647
}
648

649
#if 0
650
static void vortex_XtalkHw_GetSampleRate(vortex_t * vortex, u32 *sr)
651
{
652
	*sr = (hwread(vortex->mmio, 0x24660) >> 3) & 0x1f;
653
}
654

655
#endif
656
static void vortex_XtalkHw_Enable(vortex_t * vortex)
657
{
658
	u32 temp;
659

660
	temp = (hwread(vortex->mmio, 0x24660) & 0x1FFFFFFF) | 0xC0000000;
661
	temp |= 1;
662
	hwwrite(vortex->mmio, 0x24660, temp);
663

664
}
665

666
static void vortex_XtalkHw_Disable(vortex_t * vortex)
667
{
668
	u32 temp;
669

670
	temp = (hwread(vortex->mmio, 0x24660) & 0x1FFFFFFF) | 0xC0000000;
671
	temp &= 0xfffffffe;
672
	hwwrite(vortex->mmio, 0x24660, temp);
673

674
}
675

676
static void vortex_XtalkHw_ZeroIO(vortex_t * vortex)
677
{
678
	int i;
679

680
	for (i = 0; i < 20; i++)
681
		hwwrite(vortex->mmio, 0x24600 + (i << 2), 0);
682
	for (i = 0; i < 4; i++)
683
		hwwrite(vortex->mmio, 0x24650 + (i << 2), 0);
684
}
685

686
static void vortex_XtalkHw_ZeroState(vortex_t * vortex)
687
{
688
	vortex_XtalkHw_ZeroIO(vortex);	// inlined
689

690
	vortex_XtalkHw_SetLeftEQ(vortex, 0, 0, asXtalkCoefsZeros);
691
	vortex_XtalkHw_SetRightEQ(vortex, 0, 0, asXtalkCoefsZeros);
692

693
	vortex_XtalkHw_SetLeftXT(vortex, 0, 0, asXtalkCoefsZeros);
694
	vortex_XtalkHw_SetRightXT(vortex, 0, 0, asXtalkCoefsZeros);
695

696
	vortex_XtalkHw_SetGains(vortex, asXtalkGainsZeros);	// inlined
697

698
	vortex_XtalkHw_SetDelay(vortex, 0, 0);	// inlined
699

700
	vortex_XtalkHw_SetLeftDline(vortex, alXtalkDlineZeros);	// inlined
701
	vortex_XtalkHw_SetRightDline(vortex, alXtalkDlineZeros);	// inlined
702
	vortex_XtalkHw_SetLeftDline(vortex, alXtalkDlineZeros);	// inlined
703
	vortex_XtalkHw_SetRightDline(vortex, alXtalkDlineZeros);	// inlined
704

705
	vortex_XtalkHw_SetLeftEQStates(vortex, asXtalkInStateZeros,
706
				       asXtalkOutStateZeros);
707
	vortex_XtalkHw_SetRightEQStates(vortex, asXtalkInStateZeros,
708
					asXtalkOutStateZeros);
709
	vortex_XtalkHw_SetLeftXTStates(vortex, asXtalkInStateZeros,
710
				       asXtalkOutStateZeros);
711
	vortex_XtalkHw_SetRightXTStates(vortex, asXtalkInStateZeros,
712
					asXtalkOutStateZeros);
713
}
714

715
static void vortex_XtalkHw_ProgramPipe(vortex_t * vortex)
716
{
717

718
	vortex_XtalkHw_SetLeftEQ(vortex, 0, 1, asXtalkCoefsPipe);
719
	vortex_XtalkHw_SetRightEQ(vortex, 0, 1, asXtalkCoefsPipe);
720
	vortex_XtalkHw_SetLeftXT(vortex, 0, 0, asXtalkCoefsZeros);
721
	vortex_XtalkHw_SetRightXT(vortex, 0, 0, asXtalkCoefsZeros);
722

723
	vortex_XtalkHw_SetDelay(vortex, 0, 0);	// inlined
724
}
725

726
static void vortex_XtalkHw_ProgramXtalkWide(vortex_t * vortex)
727
{
728

729
	vortex_XtalkHw_SetLeftEQ(vortex, sXtalkWideKLeftEq,
730
				 sXtalkWideShiftLeftEq, asXtalkWideCoefsLeftEq);
731
	vortex_XtalkHw_SetRightEQ(vortex, sXtalkWideKRightEq,
732
				  sXtalkWideShiftRightEq,
733
				  asXtalkWideCoefsRightEq);
734
	vortex_XtalkHw_SetLeftXT(vortex, sXtalkWideKLeftXt,
735
				 sXtalkWideShiftLeftXt, asXtalkWideCoefsLeftXt);
736
	vortex_XtalkHw_SetRightXT(vortex, sXtalkWideKLeftXt,
737
				  sXtalkWideShiftLeftXt,
738
				  asXtalkWideCoefsLeftXt);
739

740
	vortex_XtalkHw_SetDelay(vortex, wXtalkWideRightDelay, wXtalkWideLeftDelay);	// inlined
741
}
742

743
static void vortex_XtalkHw_ProgramXtalkNarrow(vortex_t * vortex)
744
{
745

746
	vortex_XtalkHw_SetLeftEQ(vortex, sXtalkNarrowKLeftEq,
747
				 sXtalkNarrowShiftLeftEq,
748
				 asXtalkNarrowCoefsLeftEq);
749
	vortex_XtalkHw_SetRightEQ(vortex, sXtalkNarrowKRightEq,
750
				  sXtalkNarrowShiftRightEq,
751
				  asXtalkNarrowCoefsRightEq);
752
	vortex_XtalkHw_SetLeftXT(vortex, sXtalkNarrowKLeftXt,
753
				 sXtalkNarrowShiftLeftXt,
754
				 asXtalkNarrowCoefsLeftXt);
755
	vortex_XtalkHw_SetRightXT(vortex, sXtalkNarrowKLeftXt,
756
				  sXtalkNarrowShiftLeftXt,
757
				  asXtalkNarrowCoefsLeftXt);
758

759
	vortex_XtalkHw_SetDelay(vortex, wXtalkNarrowRightDelay, wXtalkNarrowLeftDelay);	// inlined
760
}
761

762
static void vortex_XtalkHw_ProgramDiamondXtalk(vortex_t * vortex)
763
{
764

765
	//sDiamondKLeftEq,sDiamondKRightXt,asDiamondCoefsLeftEq
766
	vortex_XtalkHw_SetLeftEQ(vortex, sDiamondKLeftEq,
767
				 sDiamondShiftLeftEq, asDiamondCoefsLeftEq);
768
	vortex_XtalkHw_SetRightEQ(vortex, sDiamondKRightEq,
769
				  sDiamondShiftRightEq, asDiamondCoefsRightEq);
770
	vortex_XtalkHw_SetLeftXT(vortex, sDiamondKLeftXt,
771
				 sDiamondShiftLeftXt, asDiamondCoefsLeftXt);
772
	vortex_XtalkHw_SetRightXT(vortex, sDiamondKLeftXt,
773
				  sDiamondShiftLeftXt, asDiamondCoefsLeftXt);
774

775
	vortex_XtalkHw_SetDelay(vortex, wDiamondRightDelay, wDiamondLeftDelay);	// inlined
776
}
777

778
static void vortex_XtalkHw_init(vortex_t * vortex)
779
{
780
	vortex_XtalkHw_ZeroState(vortex);
781
}
782

783
/* End of file */
784

785
Product

Resources

Company
