?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
airport: remove useless return in a function returning void
[linux/fpc-iii.git] / sound / pci / au88x0 / au88x0_core.c
blobb070e57145143e6cb0703f338d9bf5db7dd3cffc
1 /*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU Library General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
15 */
16
17 /*
18 Vortex core low level functions.
19
20 Author: Manuel Jander (mjander@users.sourceforge.cl)
21 These functions are mainly the result of translations made
22 from the original disassembly of the au88x0 binary drivers,
23 written by Aureal before they went down.
24 Many thanks to the Jeff Muizelaar, Kester Maddock, and whoever
25 contributed to the OpenVortex project.
26 The author of this file, put the few available pieces together
27 and translated the rest of the riddle (Mix, Src and connection stuff).
28 Some things are still to be discovered, and their meanings are unclear.
29
30 Some of these functions aren't intended to be really used, rather
31 to help to understand how does the AU88X0 chips work. Keep them in, because
32 they could be used somewhere in the future.
33
34 This code hasn't been tested or proof read thoroughly. If you wanna help,
35 take a look at the AU88X0 assembly and check if this matches.
36 Functions tested ok so far are (they show the desired effect
37 at least):
38 vortex_routes(); (1 bug fixed).
39 vortex_adb_addroute();
40 vortex_adb_addroutes();
41 vortex_connect_codecplay();
42 vortex_src_flushbuffers();
43 vortex_adbdma_setmode(); note: still some unknown arguments!
44 vortex_adbdma_startfifo();
45 vortex_adbdma_stopfifo();
46 vortex_fifo_setadbctrl(); note: still some unknown arguments!
47 vortex_mix_setinputvolumebyte();
48 vortex_mix_enableinput();
49 vortex_mixer_addWTD(); (fixed)
50 vortex_connection_adbdma_src_src();
51 vortex_connection_adbdma_src();
52 vortex_src_change_convratio();
53 vortex_src_addWTD(); (fixed)
54
55 History:
56
57 01-03-2003 First revision.
58 01-21-2003 Some bug fixes.
59 17-02-2003 many bugfixes after a big versioning mess.
60 18-02-2003 JAAAAAHHHUUUUUU!!!! The mixer works !! I'm just so happy !
61 (2 hours later...) I cant believe it! Im really lucky today.
62 Now the SRC is working too! Yeah! XMMS works !
63 20-02-2003 First steps into the ALSA world.
64 28-02-2003 As my birthday present, i discovered how the DMA buffer pages really
65 work :-). It was all wrong.
66 12-03-2003 ALSA driver starts working (2 channels).
67 16-03-2003 More srcblock_setupchannel discoveries.
68 12-04-2003 AU8830 playback support. Recording in the works.
69 17-04-2003 vortex_route() and vortex_routes() bug fixes. AU8830 recording
70 works now, but chipn' dale effect is still there.
71 16-05-2003 SrcSetupChannel cleanup. Moved the Src setup stuff entirely
72 into au88x0_pcm.c .
73 06-06-2003 Buffer shifter bugfix. Mixer volume fix.
74 07-12-2003 A3D routing finally fixed. Believed to be OK.
75 25-03-2004 Many thanks to Claudia, for such valuable bug reports.
76
77 */
78
79 #include "au88x0.h"
80 #include "au88x0_a3d.h"
81 #include <linux/delay.h>
82
83 /* MIXER (CAsp4Mix.s and CAsp4Mixer.s) */
84
85 // FIXME: get rid of this.
86 static int mchannels[NR_MIXIN];
87 static int rampchs[NR_MIXIN];
88
89 static void vortex_mixer_en_sr(vortex_t * vortex, int channel)
90 {
91 hwwrite(vortex->mmio, VORTEX_MIXER_SR,
92 hwread(vortex->mmio, VORTEX_MIXER_SR) | (0x1 << channel));
93 }
94 static void vortex_mixer_dis_sr(vortex_t * vortex, int channel)
95 {
96 hwwrite(vortex->mmio, VORTEX_MIXER_SR,
97 hwread(vortex->mmio, VORTEX_MIXER_SR) & ~(0x1 << channel));
98 }
99
100 #if 0
101 static void
102 vortex_mix_muteinputgain(vortex_t * vortex, unsigned char mix,
103 unsigned char channel)
104 {
105 hwwrite(vortex->mmio, VORTEX_MIX_INVOL_A + ((mix << 5) + channel),
106 0x80);
107 hwwrite(vortex->mmio, VORTEX_MIX_INVOL_B + ((mix << 5) + channel),
108 0x80);
109 }
110
111 static int vortex_mix_getvolume(vortex_t * vortex, unsigned char mix)
112 {
113 int a;
114 a = hwread(vortex->mmio, VORTEX_MIX_VOL_A + (mix << 2)) & 0xff;
115 //FP2LinearFrac(a);
116 return (a);
117 }
118
119 static int
120 vortex_mix_getinputvolume(vortex_t * vortex, unsigned char mix,
121 int channel, int *vol)
122 {
123 int a;
124 if (!(mchannels[mix] & (1 << channel)))
125 return 0;
126 a = hwread(vortex->mmio,
127 VORTEX_MIX_INVOL_A + (((mix << 5) + channel) << 2));
128 /*
129 if (rampchs[mix] == 0)
130 a = FP2LinearFrac(a);
131 else
132 a = FP2LinearFracWT(a);
133 */
134 *vol = a;
135 return (0);
136 }
137
138 static unsigned int vortex_mix_boost6db(unsigned char vol)
139 {
140 return (vol + 8); /* WOW! what a complex function! */
141 }
142
143 static void vortex_mix_rampvolume(vortex_t * vortex, int mix)
144 {
145 int ch;
146 char a;
147 // This function is intended for ramping down only (see vortex_disableinput()).
148 for (ch = 0; ch < 0x20; ch++) {
149 if (((1 << ch) & rampchs[mix]) == 0)
150 continue;
151 a = hwread(vortex->mmio,
152 VORTEX_MIX_INVOL_B + (((mix << 5) + ch) << 2));
153 if (a > -126) {
154 a -= 2;
155 hwwrite(vortex->mmio,
156 VORTEX_MIX_INVOL_A +
157 (((mix << 5) + ch) << 2), a);
158 hwwrite(vortex->mmio,
159 VORTEX_MIX_INVOL_B +
160 (((mix << 5) + ch) << 2), a);
161 } else
162 vortex_mix_killinput(vortex, mix, ch);
163 }
164 }
165
166 static int
167 vortex_mix_getenablebit(vortex_t * vortex, unsigned char mix, int mixin)
168 {
169 int addr, temp;
170 if (mixin >= 0)
171 addr = mixin;
172 else
173 addr = mixin + 3;
174 addr = ((mix << 3) + (addr >> 2)) << 2;
175 temp = hwread(vortex->mmio, VORTEX_MIX_ENIN + addr);
176 return ((temp >> (mixin & 3)) & 1);
177 }
178 #endif
179 static void
180 vortex_mix_setvolumebyte(vortex_t * vortex, unsigned char mix,
181 unsigned char vol)
182 {
183 int temp;
184 hwwrite(vortex->mmio, VORTEX_MIX_VOL_A + (mix << 2), vol);
185 if (1) { /*if (this_10) */
186 temp = hwread(vortex->mmio, VORTEX_MIX_VOL_B + (mix << 2));
187 if ((temp != 0x80) || (vol == 0x80))
188 return;
189 }
190 hwwrite(vortex->mmio, VORTEX_MIX_VOL_B + (mix << 2), vol);
191 }
192
193 static void
194 vortex_mix_setinputvolumebyte(vortex_t * vortex, unsigned char mix,
195 int mixin, unsigned char vol)
196 {
197 int temp;
198
199 hwwrite(vortex->mmio,
200 VORTEX_MIX_INVOL_A + (((mix << 5) + mixin) << 2), vol);
201 if (1) { /* this_10, initialized to 1. */
202 temp =
203 hwread(vortex->mmio,
204 VORTEX_MIX_INVOL_B + (((mix << 5) + mixin) << 2));
205 if ((temp != 0x80) || (vol == 0x80))
206 return;
207 }
208 hwwrite(vortex->mmio,
209 VORTEX_MIX_INVOL_B + (((mix << 5) + mixin) << 2), vol);
210 }
211
212 static void
213 vortex_mix_setenablebit(vortex_t * vortex, unsigned char mix, int mixin, int en)
214 {
215 int temp, addr;
216
217 if (mixin < 0)
218 addr = (mixin + 3);
219 else
220 addr = mixin;
221 addr = ((mix << 3) + (addr >> 2)) << 2;
222 temp = hwread(vortex->mmio, VORTEX_MIX_ENIN + addr);
223 if (en)
224 temp |= (1 << (mixin & 3));
225 else
226 temp &= ~(1 << (mixin & 3));
227 /* Mute input. Astatic void crackling? */
228 hwwrite(vortex->mmio,
229 VORTEX_MIX_INVOL_B + (((mix << 5) + mixin) << 2), 0x80);
230 /* Looks like clear buffer. */
231 hwwrite(vortex->mmio, VORTEX_MIX_SMP + (mixin << 2), 0x0);
232 hwwrite(vortex->mmio, VORTEX_MIX_SMP + 4 + (mixin << 2), 0x0);
233 /* Write enable bit. */
234 hwwrite(vortex->mmio, VORTEX_MIX_ENIN + addr, temp);
235 }
236
237 static void
238 vortex_mix_killinput(vortex_t * vortex, unsigned char mix, int mixin)
239 {
240 rampchs[mix] &= ~(1 << mixin);
241 vortex_mix_setinputvolumebyte(vortex, mix, mixin, 0x80);
242 mchannels[mix] &= ~(1 << mixin);
243 vortex_mix_setenablebit(vortex, mix, mixin, 0);
244 }
245
246 static void
247 vortex_mix_enableinput(vortex_t * vortex, unsigned char mix, int mixin)
248 {
249 vortex_mix_killinput(vortex, mix, mixin);
250 if ((mchannels[mix] & (1 << mixin)) == 0) {
251 vortex_mix_setinputvolumebyte(vortex, mix, mixin, 0x80); /*0x80 : mute */
252 mchannels[mix] |= (1 << mixin);
253 }
254 vortex_mix_setenablebit(vortex, mix, mixin, 1);
255 }
256
257 static void
258 vortex_mix_disableinput(vortex_t * vortex, unsigned char mix, int channel,
259 int ramp)
260 {
261 if (ramp) {
262 rampchs[mix] |= (1 << channel);
263 // Register callback.
264 //vortex_mix_startrampvolume(vortex);
265 vortex_mix_killinput(vortex, mix, channel);
266 } else
267 vortex_mix_killinput(vortex, mix, channel);
268 }
269
270 static int
271 vortex_mixer_addWTD(vortex_t * vortex, unsigned char mix, unsigned char ch)
272 {
273 int temp, lifeboat = 0, prev;
274
275 temp = hwread(vortex->mmio, VORTEX_MIXER_SR);
276 if ((temp & (1 << ch)) == 0) {
277 hwwrite(vortex->mmio, VORTEX_MIXER_CHNBASE + (ch << 2), mix);
278 vortex_mixer_en_sr(vortex, ch);
279 return 1;
280 }
281 prev = VORTEX_MIXER_CHNBASE + (ch << 2);
282 temp = hwread(vortex->mmio, prev);
283 while (temp & 0x10) {
284 prev = VORTEX_MIXER_RTBASE + ((temp & 0xf) << 2);
285 temp = hwread(vortex->mmio, prev);
286 //printk(KERN_INFO "vortex: mixAddWTD: while addr=%x, val=%x\n", prev, temp);
287 if ((++lifeboat) > 0xf) {
288 printk(KERN_ERR
289 "vortex_mixer_addWTD: lifeboat overflow\n");
290 return 0;
291 }
292 }
293 hwwrite(vortex->mmio, VORTEX_MIXER_RTBASE + ((temp & 0xf) << 2), mix);
294 hwwrite(vortex->mmio, prev, (temp & 0xf) | 0x10);
295 return 1;
296 }
297
298 static int
299 vortex_mixer_delWTD(vortex_t * vortex, unsigned char mix, unsigned char ch)
300 {
301 int esp14 = -1, esp18, eax, ebx, edx, ebp, esi = 0;
302 //int esp1f=edi(while)=src, esp10=ch;
303
304 eax = hwread(vortex->mmio, VORTEX_MIXER_SR);
305 if (((1 << ch) & eax) == 0) {
306 printk(KERN_ERR "mix ALARM %x\n", eax);
307 return 0;
308 }
309 ebp = VORTEX_MIXER_CHNBASE + (ch << 2);
310 esp18 = hwread(vortex->mmio, ebp);
311 if (esp18 & 0x10) {
312 ebx = (esp18 & 0xf);
313 if (mix == ebx) {
314 ebx = VORTEX_MIXER_RTBASE + (mix << 2);
315 edx = hwread(vortex->mmio, ebx);
316 //7b60
317 hwwrite(vortex->mmio, ebp, edx);
318 hwwrite(vortex->mmio, ebx, 0);
319 } else {
320 //7ad3
321 edx =
322 hwread(vortex->mmio,
323 VORTEX_MIXER_RTBASE + (ebx << 2));
324 //printk(KERN_INFO "vortex: mixdelWTD: 1 addr=%x, val=%x, src=%x\n", ebx, edx, src);
325 while ((edx & 0xf) != mix) {
326 if ((esi) > 0xf) {
327 printk(KERN_ERR
328 "vortex: mixdelWTD: error lifeboat overflow\n");
329 return 0;
330 }
331 esp14 = ebx;
332 ebx = edx & 0xf;
333 ebp = ebx << 2;
334 edx =
335 hwread(vortex->mmio,
336 VORTEX_MIXER_RTBASE + ebp);
337 //printk(KERN_INFO "vortex: mixdelWTD: while addr=%x, val=%x\n", ebp, edx);
338 esi++;
339 }
340 //7b30
341 ebp = ebx << 2;
342 if (edx & 0x10) { /* Delete entry in between others */
343 ebx = VORTEX_MIXER_RTBASE + ((edx & 0xf) << 2);
344 edx = hwread(vortex->mmio, ebx);
345 //7b60
346 hwwrite(vortex->mmio,
347 VORTEX_MIXER_RTBASE + ebp, edx);
348 hwwrite(vortex->mmio, ebx, 0);
349 //printk(KERN_INFO "vortex mixdelWTD between addr= 0x%x, val= 0x%x\n", ebp, edx);
350 } else { /* Delete last entry */
351 //7b83
352 if (esp14 == -1)
353 hwwrite(vortex->mmio,
354 VORTEX_MIXER_CHNBASE +
355 (ch << 2), esp18 & 0xef);
356 else {
357 ebx = (0xffffffe0 & edx) | (0xf & ebx);
358 hwwrite(vortex->mmio,
359 VORTEX_MIXER_RTBASE +
360 (esp14 << 2), ebx);
361 //printk(KERN_INFO "vortex mixdelWTD last addr= 0x%x, val= 0x%x\n", esp14, ebx);
362 }
363 hwwrite(vortex->mmio,
364 VORTEX_MIXER_RTBASE + ebp, 0);
365 return 1;
366 }
367 }
368 } else {
369 //printk(KERN_INFO "removed last mix\n");
370 //7be0
371 vortex_mixer_dis_sr(vortex, ch);
372 hwwrite(vortex->mmio, ebp, 0);
373 }
374 return 1;
375 }
376
377 static void vortex_mixer_init(vortex_t * vortex)
378 {
379 u32 addr;
380 int x;
381
382 // FIXME: get rid of this crap.
383 memset(mchannels, 0, NR_MIXOUT * sizeof(int));
384 memset(rampchs, 0, NR_MIXOUT * sizeof(int));
385
386 addr = VORTEX_MIX_SMP + 0x17c;
387 for (x = 0x5f; x >= 0; x--) {
388 hwwrite(vortex->mmio, addr, 0);
389 addr -= 4;
390 }
391 addr = VORTEX_MIX_ENIN + 0x1fc;
392 for (x = 0x7f; x >= 0; x--) {
393 hwwrite(vortex->mmio, addr, 0);
394 addr -= 4;
395 }
396 addr = VORTEX_MIX_SMP + 0x17c;
397 for (x = 0x5f; x >= 0; x--) {
398 hwwrite(vortex->mmio, addr, 0);
399 addr -= 4;
400 }
401 addr = VORTEX_MIX_INVOL_A + 0x7fc;
402 for (x = 0x1ff; x >= 0; x--) {
403 hwwrite(vortex->mmio, addr, 0x80);
404 addr -= 4;
405 }
406 addr = VORTEX_MIX_VOL_A + 0x3c;
407 for (x = 0xf; x >= 0; x--) {
408 hwwrite(vortex->mmio, addr, 0x80);
409 addr -= 4;
410 }
411 addr = VORTEX_MIX_INVOL_B + 0x7fc;
412 for (x = 0x1ff; x >= 0; x--) {
413 hwwrite(vortex->mmio, addr, 0x80);
414 addr -= 4;
415 }
416 addr = VORTEX_MIX_VOL_B + 0x3c;
417 for (x = 0xf; x >= 0; x--) {
418 hwwrite(vortex->mmio, addr, 0x80);
419 addr -= 4;
420 }
421 addr = VORTEX_MIXER_RTBASE + (MIXER_RTBASE_SIZE - 1) * 4;
422 for (x = (MIXER_RTBASE_SIZE - 1); x >= 0; x--) {
423 hwwrite(vortex->mmio, addr, 0x0);
424 addr -= 4;
425 }
426 hwwrite(vortex->mmio, VORTEX_MIXER_SR, 0);
427
428 /* Set clipping ceiling (this may be all wrong). */
429 /*
430 for (x = 0; x < 0x80; x++) {
431 hwwrite(vortex->mmio, VORTEX_MIXER_CLIP + (x << 2), 0x3ffff);
432 }
433 */
434 /*
435 call CAsp4Mix__Initialize_CAsp4HwIO____CAsp4Mixer____
436 Register ISR callback for volume smooth fade out.
437 Maybe this avoids clicks when press "stop" ?
438 */
439 }
440
441 /* SRC (CAsp4Src.s and CAsp4SrcBlock) */
442
443 static void vortex_src_en_sr(vortex_t * vortex, int channel)
444 {
445 hwwrite(vortex->mmio, VORTEX_SRCBLOCK_SR,
446 hwread(vortex->mmio, VORTEX_SRCBLOCK_SR) | (0x1 << channel));
447 }
448
449 static void vortex_src_dis_sr(vortex_t * vortex, int channel)
450 {
451 hwwrite(vortex->mmio, VORTEX_SRCBLOCK_SR,
452 hwread(vortex->mmio, VORTEX_SRCBLOCK_SR) & ~(0x1 << channel));
453 }
454
455 static void vortex_src_flushbuffers(vortex_t * vortex, unsigned char src)
456 {
457 int i;
458
459 for (i = 0x1f; i >= 0; i--)
460 hwwrite(vortex->mmio,
461 VORTEX_SRC_DATA0 + (src << 7) + (i << 2), 0);
462 hwwrite(vortex->mmio, VORTEX_SRC_DATA + (src << 3), 0);
463 hwwrite(vortex->mmio, VORTEX_SRC_DATA + (src << 3) + 4, 0);
464 }
465
466 static void vortex_src_cleardrift(vortex_t * vortex, unsigned char src)
467 {
468 hwwrite(vortex->mmio, VORTEX_SRC_DRIFT0 + (src << 2), 0);
469 hwwrite(vortex->mmio, VORTEX_SRC_DRIFT1 + (src << 2), 0);
470 hwwrite(vortex->mmio, VORTEX_SRC_DRIFT2 + (src << 2), 1);
471 }
472
473 static void
474 vortex_src_set_throttlesource(vortex_t * vortex, unsigned char src, int en)
475 {
476 int temp;
477
478 temp = hwread(vortex->mmio, VORTEX_SRC_SOURCE);
479 if (en)
480 temp |= 1 << src;
481 else
482 temp &= ~(1 << src);
483 hwwrite(vortex->mmio, VORTEX_SRC_SOURCE, temp);
484 }
485
486 static int
487 vortex_src_persist_convratio(vortex_t * vortex, unsigned char src, int ratio)
488 {
489 int temp, lifeboat = 0;
490
491 do {
492 hwwrite(vortex->mmio, VORTEX_SRC_CONVRATIO + (src << 2), ratio);
493 temp = hwread(vortex->mmio, VORTEX_SRC_CONVRATIO + (src << 2));
494 if ((++lifeboat) > 0x9) {
495 printk(KERN_ERR "Vortex: Src cvr fail\n");
496 break;
497 }
498 }
499 while (temp != ratio);
500 return temp;
501 }
502
503 #if 0
504 static void vortex_src_slowlock(vortex_t * vortex, unsigned char src)
505 {
506 int temp;
507
508 hwwrite(vortex->mmio, VORTEX_SRC_DRIFT2 + (src << 2), 1);
509 hwwrite(vortex->mmio, VORTEX_SRC_DRIFT0 + (src << 2), 0);
510 temp = hwread(vortex->mmio, VORTEX_SRC_U0 + (src << 2));
511 if (temp & 0x200)
512 hwwrite(vortex->mmio, VORTEX_SRC_U0 + (src << 2),
513 temp & ~0x200L);
514 }
515
516 static void
517 vortex_src_change_convratio(vortex_t * vortex, unsigned char src, int ratio)
518 {
519 int temp, a;
520
521 if ((ratio & 0x10000) && (ratio != 0x10000)) {
522 if (ratio & 0x3fff)
523 a = (0x11 - ((ratio >> 0xe) & 0x3)) - 1;
524 else
525 a = (0x11 - ((ratio >> 0xe) & 0x3)) - 2;
526 } else
527 a = 0xc;
528 temp = hwread(vortex->mmio, VORTEX_SRC_U0 + (src << 2));
529 if (((temp >> 4) & 0xf) != a)
530 hwwrite(vortex->mmio, VORTEX_SRC_U0 + (src << 2),
531 (temp & 0xf) | ((a & 0xf) << 4));
532
533 vortex_src_persist_convratio(vortex, src, ratio);
534 }
535
536 static int
537 vortex_src_checkratio(vortex_t * vortex, unsigned char src,
538 unsigned int desired_ratio)
539 {
540 int hw_ratio, lifeboat = 0;
541
542 hw_ratio = hwread(vortex->mmio, VORTEX_SRC_CONVRATIO + (src << 2));
543
544 while (hw_ratio != desired_ratio) {
545 hwwrite(vortex->mmio, VORTEX_SRC_CONVRATIO + (src << 2), desired_ratio);
546
547 if ((lifeboat++) > 15) {
548 printk(KERN_ERR "Vortex: could not set src-%d from %d to %d\n",
549 src, hw_ratio, desired_ratio);
550 break;
551 }
552 }
553
554 return hw_ratio;
555 }
556
557 #endif
558 /*
559 Objective: Set samplerate for given SRC module.
560 Arguments:
561 card: pointer to vortex_t strcut.
562 src: Integer index of the SRC module.
563 cr: Current sample rate conversion factor.
564 b: unknown 16 bit value.
565 sweep: Enable Samplerate fade from cr toward tr flag.
566 dirplay: 1: playback, 0: recording.
567 sl: Slow Lock flag.
568 tr: Target samplerate conversion.
569 thsource: Throttle source flag (no idea what that means).
570 */
571 static void vortex_src_setupchannel(vortex_t * card, unsigned char src,
572 unsigned int cr, unsigned int b, int sweep, int d,
573 int dirplay, int sl, unsigned int tr, int thsource)
574 {
575 // noplayback: d=2,4,7,0xa,0xb when using first 2 src's.
576 // c: enables pitch sweep.
577 // looks like g is c related. Maybe g is a sweep parameter ?
578 // g = cvr
579 // dirplay: 0 = recording, 1 = playback
580 // d = src hw index.
581
582 int esi, ebp = 0, esp10;
583
584 vortex_src_flushbuffers(card, src);
585
586 if (sweep) {
587 if ((tr & 0x10000) && (tr != 0x10000)) {
588 tr = 0;
589 esi = 0x7;
590 } else {
591 if ((((short)tr) < 0) && (tr != 0x8000)) {
592 tr = 0;
593 esi = 0x8;
594 } else {
595 tr = 1;
596 esi = 0xc;
597 }
598 }
599 } else {
600 if ((cr & 0x10000) && (cr != 0x10000)) {
601 tr = 0; /*ebx = 0 */
602 esi = 0x11 - ((cr >> 0xe) & 7);
603 if (cr & 0x3fff)
604 esi -= 1;
605 else
606 esi -= 2;
607 } else {
608 tr = 1;
609 esi = 0xc;
610 }
611 }
612 vortex_src_cleardrift(card, src);
613 vortex_src_set_throttlesource(card, src, thsource);
614
615 if ((dirplay == 0) && (sweep == 0)) {
616 if (tr)
617 esp10 = 0xf;
618 else
619 esp10 = 0xc;
620 ebp = 0;
621 } else {
622 if (tr)
623 ebp = 0xf;
624 else
625 ebp = 0xc;
626 esp10 = 0;
627 }
628 hwwrite(card->mmio, VORTEX_SRC_U0 + (src << 2),
629 (sl << 0x9) | (sweep << 0x8) | ((esi & 0xf) << 4) | d);
630 /* 0xc0 esi=0xc c=f=0 d=0 */
631 vortex_src_persist_convratio(card, src, cr);
632 hwwrite(card->mmio, VORTEX_SRC_U1 + (src << 2), b & 0xffff);
633 /* 0 b=0 */
634 hwwrite(card->mmio, VORTEX_SRC_U2 + (src << 2),
635 (tr << 0x11) | (dirplay << 0x10) | (ebp << 0x8) | esp10);
636 /* 0x30f00 e=g=1 esp10=0 ebp=f */
637 //printk(KERN_INFO "vortex: SRC %d, d=0x%x, esi=0x%x, esp10=0x%x, ebp=0x%x\n", src, d, esi, esp10, ebp);
638 }
639
640 static void vortex_srcblock_init(vortex_t * vortex)
641 {
642 u32 addr;
643 int x;
644 hwwrite(vortex->mmio, VORTEX_SRC_SOURCESIZE, 0x1ff);
645 /*
646 for (x=0; x<0x10; x++) {
647 vortex_src_init(&vortex_src[x], x);
648 }
649 */
650 //addr = 0xcc3c;
651 //addr = 0x26c3c;
652 addr = VORTEX_SRC_RTBASE + 0x3c;
653 for (x = 0xf; x >= 0; x--) {
654 hwwrite(vortex->mmio, addr, 0);
655 addr -= 4;
656 }
657 //addr = 0xcc94;
658 //addr = 0x26c94;
659 addr = VORTEX_SRC_CHNBASE + 0x54;
660 for (x = 0x15; x >= 0; x--) {
661 hwwrite(vortex->mmio, addr, 0);
662 addr -= 4;
663 }
664 }
665
666 static int
667 vortex_src_addWTD(vortex_t * vortex, unsigned char src, unsigned char ch)
668 {
669 int temp, lifeboat = 0, prev;
670 // esp13 = src
671
672 temp = hwread(vortex->mmio, VORTEX_SRCBLOCK_SR);
673 if ((temp & (1 << ch)) == 0) {
674 hwwrite(vortex->mmio, VORTEX_SRC_CHNBASE + (ch << 2), src);
675 vortex_src_en_sr(vortex, ch);
676 return 1;
677 }
678 prev = VORTEX_SRC_CHNBASE + (ch << 2); /*ebp */
679 temp = hwread(vortex->mmio, prev);
680 //while (temp & NR_SRC) {
681 while (temp & 0x10) {
682 prev = VORTEX_SRC_RTBASE + ((temp & 0xf) << 2); /*esp12 */
683 //prev = VORTEX_SRC_RTBASE + ((temp & (NR_SRC-1)) << 2); /*esp12*/
684 temp = hwread(vortex->mmio, prev);
685 //printk(KERN_INFO "vortex: srcAddWTD: while addr=%x, val=%x\n", prev, temp);
686 if ((++lifeboat) > 0xf) {
687 printk(KERN_ERR
688 "vortex_src_addWTD: lifeboat overflow\n");
689 return 0;
690 }
691 }
692 hwwrite(vortex->mmio, VORTEX_SRC_RTBASE + ((temp & 0xf) << 2), src);
693 //hwwrite(vortex->mmio, prev, (temp & (NR_SRC-1)) | NR_SRC);
694 hwwrite(vortex->mmio, prev, (temp & 0xf) | 0x10);
695 return 1;
696 }
697
698 static int
699 vortex_src_delWTD(vortex_t * vortex, unsigned char src, unsigned char ch)
700 {
701 int esp14 = -1, esp18, eax, ebx, edx, ebp, esi = 0;
702 //int esp1f=edi(while)=src, esp10=ch;
703
704 eax = hwread(vortex->mmio, VORTEX_SRCBLOCK_SR);
705 if (((1 << ch) & eax) == 0) {
706 printk(KERN_ERR "src alarm\n");
707 return 0;
708 }
709 ebp = VORTEX_SRC_CHNBASE + (ch << 2);
710 esp18 = hwread(vortex->mmio, ebp);
711 if (esp18 & 0x10) {
712 ebx = (esp18 & 0xf);
713 if (src == ebx) {
714 ebx = VORTEX_SRC_RTBASE + (src << 2);
715 edx = hwread(vortex->mmio, ebx);
716 //7b60
717 hwwrite(vortex->mmio, ebp, edx);
718 hwwrite(vortex->mmio, ebx, 0);
719 } else {
720 //7ad3
721 edx =
722 hwread(vortex->mmio,
723 VORTEX_SRC_RTBASE + (ebx << 2));
724 //printk(KERN_INFO "vortex: srcdelWTD: 1 addr=%x, val=%x, src=%x\n", ebx, edx, src);
725 while ((edx & 0xf) != src) {
726 if ((esi) > 0xf) {
727 printk
728 ("vortex: srcdelWTD: error, lifeboat overflow\n");
729 return 0;
730 }
731 esp14 = ebx;
732 ebx = edx & 0xf;
733 ebp = ebx << 2;
734 edx =
735 hwread(vortex->mmio,
736 VORTEX_SRC_RTBASE + ebp);
737 //printk(KERN_INFO "vortex: srcdelWTD: while addr=%x, val=%x\n", ebp, edx);
738 esi++;
739 }
740 //7b30
741 ebp = ebx << 2;
742 if (edx & 0x10) { /* Delete entry in between others */
743 ebx = VORTEX_SRC_RTBASE + ((edx & 0xf) << 2);
744 edx = hwread(vortex->mmio, ebx);
745 //7b60
746 hwwrite(vortex->mmio,
747 VORTEX_SRC_RTBASE + ebp, edx);
748 hwwrite(vortex->mmio, ebx, 0);
749 //printk(KERN_INFO "vortex srcdelWTD between addr= 0x%x, val= 0x%x\n", ebp, edx);
750 } else { /* Delete last entry */
751 //7b83
752 if (esp14 == -1)
753 hwwrite(vortex->mmio,
754 VORTEX_SRC_CHNBASE +
755 (ch << 2), esp18 & 0xef);
756 else {
757 ebx = (0xffffffe0 & edx) | (0xf & ebx);
758 hwwrite(vortex->mmio,
759 VORTEX_SRC_RTBASE +
760 (esp14 << 2), ebx);
761 //printk(KERN_INFO"vortex srcdelWTD last addr= 0x%x, val= 0x%x\n", esp14, ebx);
762 }
763 hwwrite(vortex->mmio,
764 VORTEX_SRC_RTBASE + ebp, 0);
765 return 1;
766 }
767 }
768 } else {
769 //7be0
770 vortex_src_dis_sr(vortex, ch);
771 hwwrite(vortex->mmio, ebp, 0);
772 }
773 return 1;
774 }
775
776 /*FIFO*/
777
778 static void
779 vortex_fifo_clearadbdata(vortex_t * vortex, int fifo, int x)
780 {
781 for (x--; x >= 0; x--)
782 hwwrite(vortex->mmio,
783 VORTEX_FIFO_ADBDATA +
784 (((fifo << FIFO_SIZE_BITS) + x) << 2), 0);
785 }
786
787 #if 0
788 static void vortex_fifo_adbinitialize(vortex_t * vortex, int fifo, int j)
789 {
790 vortex_fifo_clearadbdata(vortex, fifo, FIFO_SIZE);
791 #ifdef CHIP_AU8820
792 hwwrite(vortex->mmio, VORTEX_FIFO_ADBCTRL + (fifo << 2),
793 (FIFO_U1 | ((j & FIFO_MASK) << 0xb)));
794 #else
795 hwwrite(vortex->mmio, VORTEX_FIFO_ADBCTRL + (fifo << 2),
796 (FIFO_U1 | ((j & FIFO_MASK) << 0xc)));
797 #endif
798 }
799 #endif
800 static void vortex_fifo_setadbvalid(vortex_t * vortex, int fifo, int en)
801 {
802 hwwrite(vortex->mmio, VORTEX_FIFO_ADBCTRL + (fifo << 2),
803 (hwread(vortex->mmio, VORTEX_FIFO_ADBCTRL + (fifo << 2)) &
804 0xffffffef) | ((1 & en) << 4) | FIFO_U1);
805 }
806
807 static void
808 vortex_fifo_setadbctrl(vortex_t * vortex, int fifo, int b, int priority,
809 int empty, int valid, int f)
810 {
811 int temp, lifeboat = 0;
812 //int this_8[NR_ADB] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; /* position */
813 int this_4 = 0x2;
814 /* f seems priority related.
815 * CAsp4AdbDma::SetPriority is the only place that calls SetAdbCtrl with f set to 1
816 * every where else it is set to 0. It seems, however, that CAsp4AdbDma::SetPriority
817 * is never called, thus the f related bits remain a mystery for now.
818 */
819 do {
820 temp = hwread(vortex->mmio, VORTEX_FIFO_ADBCTRL + (fifo << 2));
821 if (lifeboat++ > 0xbb8) {
822 printk(KERN_ERR
823 "Vortex: vortex_fifo_setadbctrl fail\n");
824 break;
825 }
826 }
827 while (temp & FIFO_RDONLY);
828
829 // AU8830 semes to take some special care about fifo content (data).
830 // But i'm just to lazy to translate that :)
831 if (valid) {
832 if ((temp & FIFO_VALID) == 0) {
833 //this_8[fifo] = 0;
834 vortex_fifo_clearadbdata(vortex, fifo, FIFO_SIZE); // this_4
835 #ifdef CHIP_AU8820
836 temp = (this_4 & 0x1f) << 0xb;
837 #else
838 temp = (this_4 & 0x3f) << 0xc;
839 #endif
840 temp = (temp & 0xfffffffd) | ((b & 1) << 1);
841 temp = (temp & 0xfffffff3) | ((priority & 3) << 2);
842 temp = (temp & 0xffffffef) | ((valid & 1) << 4);
843 temp |= FIFO_U1;
844 temp = (temp & 0xffffffdf) | ((empty & 1) << 5);
845 #ifdef CHIP_AU8820
846 temp = (temp & 0xfffbffff) | ((f & 1) << 0x12);
847 #endif
848 #ifdef CHIP_AU8830
849 temp = (temp & 0xf7ffffff) | ((f & 1) << 0x1b);
850 temp = (temp & 0xefffffff) | ((f & 1) << 0x1c);
851 #endif
852 #ifdef CHIP_AU8810
853 temp = (temp & 0xfeffffff) | ((f & 1) << 0x18);
854 temp = (temp & 0xfdffffff) | ((f & 1) << 0x19);
855 #endif
856 }
857 } else {
858 if (temp & FIFO_VALID) {
859 #ifdef CHIP_AU8820
860 temp = ((f & 1) << 0x12) | (temp & 0xfffbffef);
861 #endif
862 #ifdef CHIP_AU8830
863 temp =
864 ((f & 1) << 0x1b) | (temp & 0xe7ffffef) | FIFO_BITS;
865 #endif
866 #ifdef CHIP_AU8810
867 temp =
868 ((f & 1) << 0x18) | (temp & 0xfcffffef) | FIFO_BITS;
869 #endif
870 } else
871 /*if (this_8[fifo]) */
872 vortex_fifo_clearadbdata(vortex, fifo, FIFO_SIZE);
873 }
874 hwwrite(vortex->mmio, VORTEX_FIFO_ADBCTRL + (fifo << 2), temp);
875 hwread(vortex->mmio, VORTEX_FIFO_ADBCTRL + (fifo << 2));
876 }
877
878 #ifndef CHIP_AU8810
879 static void vortex_fifo_clearwtdata(vortex_t * vortex, int fifo, int x)
880 {
881 if (x < 1)
882 return;
883 for (x--; x >= 0; x--)
884 hwwrite(vortex->mmio,
885 VORTEX_FIFO_WTDATA +
886 (((fifo << FIFO_SIZE_BITS) + x) << 2), 0);
887 }
888
889 static void vortex_fifo_wtinitialize(vortex_t * vortex, int fifo, int j)
890 {
891 vortex_fifo_clearwtdata(vortex, fifo, FIFO_SIZE);
892 #ifdef CHIP_AU8820
893 hwwrite(vortex->mmio, VORTEX_FIFO_WTCTRL + (fifo << 2),
894 (FIFO_U1 | ((j & FIFO_MASK) << 0xb)));
895 #else
896 hwwrite(vortex->mmio, VORTEX_FIFO_WTCTRL + (fifo << 2),
897 (FIFO_U1 | ((j & FIFO_MASK) << 0xc)));
898 #endif
899 }
900
901 static void vortex_fifo_setwtvalid(vortex_t * vortex, int fifo, int en)
902 {
903 hwwrite(vortex->mmio, VORTEX_FIFO_WTCTRL + (fifo << 2),
904 (hwread(vortex->mmio, VORTEX_FIFO_WTCTRL + (fifo << 2)) &
905 0xffffffef) | ((en & 1) << 4) | FIFO_U1);
906 }
907
908 static void
909 vortex_fifo_setwtctrl(vortex_t * vortex, int fifo, int ctrl, int priority,
910 int empty, int valid, int f)
911 {
912 int temp = 0, lifeboat = 0;
913 int this_4 = 2;
914
915 do {
916 temp = hwread(vortex->mmio, VORTEX_FIFO_WTCTRL + (fifo << 2));
917 if (lifeboat++ > 0xbb8) {
918 printk(KERN_ERR "Vortex: vortex_fifo_setwtctrl fail\n");
919 break;
920 }
921 }
922 while (temp & FIFO_RDONLY);
923
924 if (valid) {
925 if ((temp & FIFO_VALID) == 0) {
926 vortex_fifo_clearwtdata(vortex, fifo, FIFO_SIZE); // this_4
927 #ifdef CHIP_AU8820
928 temp = (this_4 & 0x1f) << 0xb;
929 #else
930 temp = (this_4 & 0x3f) << 0xc;
931 #endif
932 temp = (temp & 0xfffffffd) | ((ctrl & 1) << 1);
933 temp = (temp & 0xfffffff3) | ((priority & 3) << 2);
934 temp = (temp & 0xffffffef) | ((valid & 1) << 4);
935 temp |= FIFO_U1;
936 temp = (temp & 0xffffffdf) | ((empty & 1) << 5);
937 #ifdef CHIP_AU8820
938 temp = (temp & 0xfffbffff) | ((f & 1) << 0x12);
939 #endif
940 #ifdef CHIP_AU8830
941 temp = (temp & 0xf7ffffff) | ((f & 1) << 0x1b);
942 temp = (temp & 0xefffffff) | ((f & 1) << 0x1c);
943 #endif
944 #ifdef CHIP_AU8810
945 temp = (temp & 0xfeffffff) | ((f & 1) << 0x18);
946 temp = (temp & 0xfdffffff) | ((f & 1) << 0x19);
947 #endif
948 }
949 } else {
950 if (temp & FIFO_VALID) {
951 #ifdef CHIP_AU8820
952 temp = ((f & 1) << 0x12) | (temp & 0xfffbffef);
953 #endif
954 #ifdef CHIP_AU8830
955 temp =
956 ((f & 1) << 0x1b) | (temp & 0xe7ffffef) | FIFO_BITS;
957 #endif
958 #ifdef CHIP_AU8810
959 temp =
960 ((f & 1) << 0x18) | (temp & 0xfcffffef) | FIFO_BITS;
961 #endif
962 } else
963 /*if (this_8[fifo]) */
964 vortex_fifo_clearwtdata(vortex, fifo, FIFO_SIZE);
965 }
966 hwwrite(vortex->mmio, VORTEX_FIFO_WTCTRL + (fifo << 2), temp);
967 hwread(vortex->mmio, VORTEX_FIFO_WTCTRL + (fifo << 2));
968
969 /*
970 do {
971 temp = hwread(vortex->mmio, VORTEX_FIFO_WTCTRL + (fifo << 2));
972 if (lifeboat++ > 0xbb8) {
973 printk(KERN_ERR "Vortex: vortex_fifo_setwtctrl fail (hanging)\n");
974 break;
975 }
976 } while ((temp & FIFO_RDONLY)&&(temp & FIFO_VALID)&&(temp != 0xFFFFFFFF));
977
978
979 if (valid) {
980 if (temp & FIFO_VALID) {
981 temp = 0x40000;
982 //temp |= 0x08000000;
983 //temp |= 0x10000000;
984 //temp |= 0x04000000;
985 //temp |= 0x00400000;
986 temp |= 0x1c400000;
987 temp &= 0xFFFFFFF3;
988 temp &= 0xFFFFFFEF;
989 temp |= (valid & 1) << 4;
990 hwwrite(vortex->mmio, VORTEX_FIFO_WTCTRL + (fifo << 2), temp);
991 return;
992 } else {
993 vortex_fifo_clearwtdata(vortex, fifo, FIFO_SIZE);
994 return;
995 }
996 } else {
997 temp &= 0xffffffef;
998 temp |= 0x08000000;
999 temp |= 0x10000000;
1000 temp |= 0x04000000;
1001 temp |= 0x00400000;
1002 hwwrite(vortex->mmio, VORTEX_FIFO_WTCTRL + (fifo << 2), temp);
1003 temp = hwread(vortex->mmio, VORTEX_FIFO_WTCTRL + (fifo << 2));
1004 //((temp >> 6) & 0x3f)
1005
1006 priority = 0;
1007 if (((temp & 0x0fc0) ^ ((temp >> 6) & 0x0fc0)) & 0FFFFFFC0)
1008 vortex_fifo_clearwtdata(vortex, fifo, FIFO_SIZE);
1009 valid = 0xfb;
1010 temp = (temp & 0xfffffffd) | ((ctrl & 1) << 1);
1011 temp = (temp & 0xfffdffff) | ((f & 1) << 0x11);
1012 temp = (temp & 0xfffffff3) | ((priority & 3) << 2);
1013 temp = (temp & 0xffffffef) | ((valid & 1) << 4);
1014 temp = (temp & 0xffffffdf) | ((empty & 1) << 5);
1015 hwwrite(vortex->mmio, VORTEX_FIFO_WTCTRL + (fifo << 2), temp);
1016 }
1017
1018 */
1019
1020 /*
1021 temp = (temp & 0xfffffffd) | ((ctrl & 1) << 1);
1022 temp = (temp & 0xfffdffff) | ((f & 1) << 0x11);
1023 temp = (temp & 0xfffffff3) | ((priority & 3) << 2);
1024 temp = (temp & 0xffffffef) | ((valid & 1) << 4);
1025 temp = (temp & 0xffffffdf) | ((empty & 1) << 5);
1026 #ifdef FIFO_BITS
1027 temp = temp | FIFO_BITS | 40000;
1028 #endif
1029 // 0x1c440010, 0x1c400000
1030 hwwrite(vortex->mmio, VORTEX_FIFO_WTCTRL + (fifo << 2), temp);
1031 */
1032 }
1033
1034 #endif
1035 static void vortex_fifo_init(vortex_t * vortex)
1036 {
1037 int x;
1038 u32 addr;
1039
1040 /* ADB DMA channels fifos. */
1041 addr = VORTEX_FIFO_ADBCTRL + ((NR_ADB - 1) * 4);
1042 for (x = NR_ADB - 1; x >= 0; x--) {
1043 hwwrite(vortex->mmio, addr, (FIFO_U0 | FIFO_U1));
1044 if (hwread(vortex->mmio, addr) != (FIFO_U0 | FIFO_U1))
1045 printk(KERN_ERR "bad adb fifo reset!");
1046 vortex_fifo_clearadbdata(vortex, x, FIFO_SIZE);
1047 addr -= 4;
1048 }
1049
1050 #ifndef CHIP_AU8810
1051 /* WT DMA channels fifos. */
1052 addr = VORTEX_FIFO_WTCTRL + ((NR_WT - 1) * 4);
1053 for (x = NR_WT - 1; x >= 0; x--) {
1054 hwwrite(vortex->mmio, addr, FIFO_U0);
1055 if (hwread(vortex->mmio, addr) != FIFO_U0)
1056 printk(KERN_ERR
1057 "bad wt fifo reset (0x%08x, 0x%08x)!\n",
1058 addr, hwread(vortex->mmio, addr));
1059 vortex_fifo_clearwtdata(vortex, x, FIFO_SIZE);
1060 addr -= 4;
1061 }
1062 #endif
1063 /* trigger... */
1064 #ifdef CHIP_AU8820
1065 hwwrite(vortex->mmio, 0xf8c0, 0xd03); //0x0843 0xd6b
1066 #else
1067 #ifdef CHIP_AU8830
1068 hwwrite(vortex->mmio, 0x17000, 0x61); /* wt a */
1069 hwwrite(vortex->mmio, 0x17004, 0x61); /* wt b */
1070 #endif
1071 hwwrite(vortex->mmio, 0x17008, 0x61); /* adb */
1072 #endif
1073 }
1074
1075 /* ADBDMA */
1076
1077 static void vortex_adbdma_init(vortex_t * vortex)
1078 {
1079 }
1080
1081 static void vortex_adbdma_setfirstbuffer(vortex_t * vortex, int adbdma)
1082 {
1083 stream_t *dma = &vortex->dma_adb[adbdma];
1084
1085 hwwrite(vortex->mmio, VORTEX_ADBDMA_CTRL + (adbdma << 2),
1086 dma->dma_ctrl);
1087 }
1088
1089 static void vortex_adbdma_setstartbuffer(vortex_t * vortex, int adbdma, int sb)
1090 {
1091 stream_t *dma = &vortex->dma_adb[adbdma];
1092 //hwwrite(vortex->mmio, VORTEX_ADBDMA_START + (adbdma << 2), sb << (((NR_ADB-1)-((adbdma&0xf)*2))));
1093 hwwrite(vortex->mmio, VORTEX_ADBDMA_START + (adbdma << 2),
1094 sb << ((0xf - (adbdma & 0xf)) * 2));
1095 dma->period_real = dma->period_virt = sb;
1096 }
1097
1098 static void
1099 vortex_adbdma_setbuffers(vortex_t * vortex, int adbdma,
1100 int psize, int count)
1101 {
1102 stream_t *dma = &vortex->dma_adb[adbdma];
1103
1104 dma->period_bytes = psize;
1105 dma->nr_periods = count;
1106
1107 dma->cfg0 = 0;
1108 dma->cfg1 = 0;
1109 switch (count) {
1110 /* Four or more pages */
1111 default:
1112 case 4:
1113 dma->cfg1 |= 0x88000000 | 0x44000000 | 0x30000000 | (psize - 1);
1114 hwwrite(vortex->mmio,
1115 VORTEX_ADBDMA_BUFBASE + (adbdma << 4) + 0xc,
1116 snd_pcm_sgbuf_get_addr(dma->substream, psize * 3));
1117 /* 3 pages */
1118 case 3:
1119 dma->cfg0 |= 0x12000000;
1120 dma->cfg1 |= 0x80000000 | 0x40000000 | ((psize - 1) << 0xc);
1121 hwwrite(vortex->mmio,
1122 VORTEX_ADBDMA_BUFBASE + (adbdma << 4) + 0x8,
1123 snd_pcm_sgbuf_get_addr(dma->substream, psize * 2));
1124 /* 2 pages */
1125 case 2:
1126 dma->cfg0 |= 0x88000000 | 0x44000000 | 0x10000000 | (psize - 1);
1127 hwwrite(vortex->mmio,
1128 VORTEX_ADBDMA_BUFBASE + (adbdma << 4) + 0x4,
1129 snd_pcm_sgbuf_get_addr(dma->substream, psize));
1130 /* 1 page */
1131 case 1:
1132 dma->cfg0 |= 0x80000000 | 0x40000000 | ((psize - 1) << 0xc);
1133 hwwrite(vortex->mmio,
1134 VORTEX_ADBDMA_BUFBASE + (adbdma << 4),
1135 snd_pcm_sgbuf_get_addr(dma->substream, 0));
1136 break;
1137 }
1138 //printk("vortex: cfg0 = 0x%x\nvortex: cfg1=0x%x\n", dma->cfg0, dma->cfg1);
1139 hwwrite(vortex->mmio, VORTEX_ADBDMA_BUFCFG0 + (adbdma << 3), dma->cfg0);
1140 hwwrite(vortex->mmio, VORTEX_ADBDMA_BUFCFG1 + (adbdma << 3), dma->cfg1);
1141
1142 vortex_adbdma_setfirstbuffer(vortex, adbdma);
1143 vortex_adbdma_setstartbuffer(vortex, adbdma, 0);
1144 }
1145
1146 static void
1147 vortex_adbdma_setmode(vortex_t * vortex, int adbdma, int ie, int dir,
1148 int fmt, int d, u32 offset)
1149 {
1150 stream_t *dma = &vortex->dma_adb[adbdma];
1151
1152 dma->dma_unknown = d;
1153 dma->dma_ctrl =
1154 ((offset & OFFSET_MASK) | (dma->dma_ctrl & ~OFFSET_MASK));
1155 /* Enable PCMOUT interrupts. */
1156 dma->dma_ctrl =
1157 (dma->dma_ctrl & ~IE_MASK) | ((ie << IE_SHIFT) & IE_MASK);
1158
1159 dma->dma_ctrl =
1160 (dma->dma_ctrl & ~DIR_MASK) | ((dir << DIR_SHIFT) & DIR_MASK);
1161 dma->dma_ctrl =
1162 (dma->dma_ctrl & ~FMT_MASK) | ((fmt << FMT_SHIFT) & FMT_MASK);
1163
1164 hwwrite(vortex->mmio, VORTEX_ADBDMA_CTRL + (adbdma << 2),
1165 dma->dma_ctrl);
1166 hwread(vortex->mmio, VORTEX_ADBDMA_CTRL + (adbdma << 2));
1167 }
1168
1169 static int vortex_adbdma_bufshift(vortex_t * vortex, int adbdma)
1170 {
1171 stream_t *dma = &vortex->dma_adb[adbdma];
1172 int page, p, pp, delta, i;
1173
1174 page =
1175 (hwread(vortex->mmio, VORTEX_ADBDMA_STAT + (adbdma << 2)) &
1176 ADB_SUBBUF_MASK) >> ADB_SUBBUF_SHIFT;
1177 if (dma->nr_periods >= 4)
1178 delta = (page - dma->period_real) & 3;
1179 else {
1180 delta = (page - dma->period_real);
1181 if (delta < 0)
1182 delta += dma->nr_periods;
1183 }
1184 if (delta == 0)
1185 return 0;
1186
1187 /* refresh hw page table */
1188 if (dma->nr_periods > 4) {
1189 for (i = 0; i < delta; i++) {
1190 /* p: audio buffer page index */
1191 p = dma->period_virt + i + 4;
1192 if (p >= dma->nr_periods)
1193 p -= dma->nr_periods;
1194 /* pp: hardware DMA page index. */
1195 pp = dma->period_real + i;
1196 if (pp >= 4)
1197 pp -= 4;
1198 //hwwrite(vortex->mmio, VORTEX_ADBDMA_BUFBASE+(((adbdma << 2)+pp) << 2), dma->table[p].addr);
1199 hwwrite(vortex->mmio,
1200 VORTEX_ADBDMA_BUFBASE + (((adbdma << 2) + pp) << 2),
1201 snd_pcm_sgbuf_get_addr(dma->substream,
1202 dma->period_bytes * p));
1203 /* Force write thru cache. */
1204 hwread(vortex->mmio, VORTEX_ADBDMA_BUFBASE +
1205 (((adbdma << 2) + pp) << 2));
1206 }
1207 }
1208 dma->period_virt += delta;
1209 dma->period_real = page;
1210 if (dma->period_virt >= dma->nr_periods)
1211 dma->period_virt -= dma->nr_periods;
1212 if (delta != 1)
1213 printk(KERN_INFO "vortex: %d virt=%d, real=%d, delta=%d\n",
1214 adbdma, dma->period_virt, dma->period_real, delta);
1215
1216 return delta;
1217 }
1218
1219
1220 static void vortex_adbdma_resetup(vortex_t *vortex, int adbdma) {
1221 stream_t *dma = &vortex->dma_adb[adbdma];
1222 int p, pp, i;
1223
1224 /* refresh hw page table */
1225 for (i=0 ; i < 4 && i < dma->nr_periods; i++) {
1226 /* p: audio buffer page index */
1227 p = dma->period_virt + i;
1228 if (p >= dma->nr_periods)
1229 p -= dma->nr_periods;
1230 /* pp: hardware DMA page index. */
1231 pp = dma->period_real + i;
1232 if (dma->nr_periods < 4) {
1233 if (pp >= dma->nr_periods)
1234 pp -= dma->nr_periods;
1235 }
1236 else {
1237 if (pp >= 4)
1238 pp -= 4;
1239 }
1240 hwwrite(vortex->mmio,
1241 VORTEX_ADBDMA_BUFBASE + (((adbdma << 2) + pp) << 2),
1242 snd_pcm_sgbuf_get_addr(dma->substream,
1243 dma->period_bytes * p));
1244 /* Force write thru cache. */
1245 hwread(vortex->mmio, VORTEX_ADBDMA_BUFBASE + (((adbdma << 2)+pp) << 2));
1246 }
1247 }
1248
1249 static int inline vortex_adbdma_getlinearpos(vortex_t * vortex, int adbdma)
1250 {
1251 stream_t *dma = &vortex->dma_adb[adbdma];
1252 int temp;
1253
1254 temp = hwread(vortex->mmio, VORTEX_ADBDMA_STAT + (adbdma << 2));
1255 temp = (dma->period_virt * dma->period_bytes) + (temp & POS_MASK);
1256 return (temp);
1257 }
1258
1259 static void vortex_adbdma_startfifo(vortex_t * vortex, int adbdma)
1260 {
1261 int this_8 = 0 /*empty */ , this_4 = 0 /*priority */ ;
1262 stream_t *dma = &vortex->dma_adb[adbdma];
1263
1264 switch (dma->fifo_status) {
1265 case FIFO_START:
1266 vortex_fifo_setadbvalid(vortex, adbdma,
1267 dma->fifo_enabled ? 1 : 0);
1268 break;
1269 case FIFO_STOP:
1270 this_8 = 1;
1271 hwwrite(vortex->mmio, VORTEX_ADBDMA_CTRL + (adbdma << 2),
1272 dma->dma_ctrl);
1273 vortex_fifo_setadbctrl(vortex, adbdma, dma->dma_unknown,
1274 this_4, this_8,
1275 dma->fifo_enabled ? 1 : 0, 0);
1276 break;
1277 case FIFO_PAUSE:
1278 vortex_fifo_setadbctrl(vortex, adbdma, dma->dma_unknown,
1279 this_4, this_8,
1280 dma->fifo_enabled ? 1 : 0, 0);
1281 break;
1282 }
1283 dma->fifo_status = FIFO_START;
1284 }
1285
1286 static void vortex_adbdma_resumefifo(vortex_t * vortex, int adbdma)
1287 {
1288 stream_t *dma = &vortex->dma_adb[adbdma];
1289
1290 int this_8 = 1, this_4 = 0;
1291 switch (dma->fifo_status) {
1292 case FIFO_STOP:
1293 hwwrite(vortex->mmio, VORTEX_ADBDMA_CTRL + (adbdma << 2),
1294 dma->dma_ctrl);
1295 vortex_fifo_setadbctrl(vortex, adbdma, dma->dma_unknown,
1296 this_4, this_8,
1297 dma->fifo_enabled ? 1 : 0, 0);
1298 break;
1299 case FIFO_PAUSE:
1300 vortex_fifo_setadbctrl(vortex, adbdma, dma->dma_unknown,
1301 this_4, this_8,
1302 dma->fifo_enabled ? 1 : 0, 0);
1303 break;
1304 }
1305 dma->fifo_status = FIFO_START;
1306 }
1307
1308 static void vortex_adbdma_pausefifo(vortex_t * vortex, int adbdma)
1309 {
1310 stream_t *dma = &vortex->dma_adb[adbdma];
1311
1312 int this_8 = 0, this_4 = 0;
1313 switch (dma->fifo_status) {
1314 case FIFO_START:
1315 vortex_fifo_setadbctrl(vortex, adbdma, dma->dma_unknown,
1316 this_4, this_8, 0, 0);
1317 break;
1318 case FIFO_STOP:
1319 hwwrite(vortex->mmio, VORTEX_ADBDMA_CTRL + (adbdma << 2),
1320 dma->dma_ctrl);
1321 vortex_fifo_setadbctrl(vortex, adbdma, dma->dma_unknown,
1322 this_4, this_8, 0, 0);
1323 break;
1324 }
1325 dma->fifo_status = FIFO_PAUSE;
1326 }
1327
1328 #if 0 // Using pause instead
1329 static void vortex_adbdma_stopfifo(vortex_t * vortex, int adbdma)
1330 {
1331 stream_t *dma = &vortex->dma_adb[adbdma];
1332
1333 int this_4 = 0, this_8 = 0;
1334 if (dma->fifo_status == FIFO_START)
1335 vortex_fifo_setadbctrl(vortex, adbdma, dma->dma_unknown,
1336 this_4, this_8, 0, 0);
1337 else if (dma->fifo_status == FIFO_STOP)
1338 return;
1339 dma->fifo_status = FIFO_STOP;
1340 dma->fifo_enabled = 0;
1341 }
1342
1343 #endif
1344 /* WTDMA */
1345
1346 #ifndef CHIP_AU8810
1347 static void vortex_wtdma_setfirstbuffer(vortex_t * vortex, int wtdma)
1348 {
1349 //int this_7c=dma_ctrl;
1350 stream_t *dma = &vortex->dma_wt[wtdma];
1351
1352 hwwrite(vortex->mmio, VORTEX_WTDMA_CTRL + (wtdma << 2), dma->dma_ctrl);
1353 }
1354
1355 static void vortex_wtdma_setstartbuffer(vortex_t * vortex, int wtdma, int sb)
1356 {
1357 stream_t *dma = &vortex->dma_wt[wtdma];
1358 //hwwrite(vortex->mmio, VORTEX_WTDMA_START + (wtdma << 2), sb << ((0x1f-(wtdma&0xf)*2)));
1359 hwwrite(vortex->mmio, VORTEX_WTDMA_START + (wtdma << 2),
1360 sb << ((0xf - (wtdma & 0xf)) * 2));
1361 dma->period_real = dma->period_virt = sb;
1362 }
1363
1364 static void
1365 vortex_wtdma_setbuffers(vortex_t * vortex, int wtdma,
1366 int psize, int count)
1367 {
1368 stream_t *dma = &vortex->dma_wt[wtdma];
1369
1370 dma->period_bytes = psize;
1371 dma->nr_periods = count;
1372
1373 dma->cfg0 = 0;
1374 dma->cfg1 = 0;
1375 switch (count) {
1376 /* Four or more pages */
1377 default:
1378 case 4:
1379 dma->cfg1 |= 0x88000000 | 0x44000000 | 0x30000000 | (psize-1);
1380 hwwrite(vortex->mmio, VORTEX_WTDMA_BUFBASE + (wtdma << 4) + 0xc,
1381 snd_pcm_sgbuf_get_addr(dma->substream, psize * 3));
1382 /* 3 pages */
1383 case 3:
1384 dma->cfg0 |= 0x12000000;
1385 dma->cfg1 |= 0x80000000 | 0x40000000 | ((psize-1) << 0xc);
1386 hwwrite(vortex->mmio, VORTEX_WTDMA_BUFBASE + (wtdma << 4) + 0x8,
1387 snd_pcm_sgbuf_get_addr(dma->substream, psize * 2));
1388 /* 2 pages */
1389 case 2:
1390 dma->cfg0 |= 0x88000000 | 0x44000000 | 0x10000000 | (psize-1);
1391 hwwrite(vortex->mmio, VORTEX_WTDMA_BUFBASE + (wtdma << 4) + 0x4,
1392 snd_pcm_sgbuf_get_addr(dma->substream, psize));
1393 /* 1 page */
1394 case 1:
1395 dma->cfg0 |= 0x80000000 | 0x40000000 | ((psize-1) << 0xc);
1396 hwwrite(vortex->mmio, VORTEX_WTDMA_BUFBASE + (wtdma << 4),
1397 snd_pcm_sgbuf_get_addr(dma->substream, 0));
1398 break;
1399 }
1400 hwwrite(vortex->mmio, VORTEX_WTDMA_BUFCFG0 + (wtdma << 3), dma->cfg0);
1401 hwwrite(vortex->mmio, VORTEX_WTDMA_BUFCFG1 + (wtdma << 3), dma->cfg1);
1402
1403 vortex_wtdma_setfirstbuffer(vortex, wtdma);
1404 vortex_wtdma_setstartbuffer(vortex, wtdma, 0);
1405 }
1406
1407 static void
1408 vortex_wtdma_setmode(vortex_t * vortex, int wtdma, int ie, int fmt, int d,
1409 /*int e, */ u32 offset)
1410 {
1411 stream_t *dma = &vortex->dma_wt[wtdma];
1412
1413 //dma->this_08 = e;
1414 dma->dma_unknown = d;
1415 dma->dma_ctrl = 0;
1416 dma->dma_ctrl =
1417 ((offset & OFFSET_MASK) | (dma->dma_ctrl & ~OFFSET_MASK));
1418 /* PCMOUT interrupt */
1419 dma->dma_ctrl =
1420 (dma->dma_ctrl & ~IE_MASK) | ((ie << IE_SHIFT) & IE_MASK);
1421 /* Always playback. */
1422 dma->dma_ctrl |= (1 << DIR_SHIFT);
1423 /* Audio Format */
1424 dma->dma_ctrl =
1425 (dma->dma_ctrl & FMT_MASK) | ((fmt << FMT_SHIFT) & FMT_MASK);
1426 /* Write into hardware */
1427 hwwrite(vortex->mmio, VORTEX_WTDMA_CTRL + (wtdma << 2), dma->dma_ctrl);
1428 }
1429
1430 static int vortex_wtdma_bufshift(vortex_t * vortex, int wtdma)
1431 {
1432 stream_t *dma = &vortex->dma_wt[wtdma];
1433 int page, p, pp, delta, i;
1434
1435 page =
1436 (hwread(vortex->mmio, VORTEX_WTDMA_STAT + (wtdma << 2)) &
1437 WT_SUBBUF_MASK)
1438 >> WT_SUBBUF_SHIFT;
1439 if (dma->nr_periods >= 4)
1440 delta = (page - dma->period_real) & 3;
1441 else {
1442 delta = (page - dma->period_real);
1443 if (delta < 0)
1444 delta += dma->nr_periods;
1445 }
1446 if (delta == 0)
1447 return 0;
1448
1449 /* refresh hw page table */
1450 if (dma->nr_periods > 4) {
1451 for (i = 0; i < delta; i++) {
1452 /* p: audio buffer page index */
1453 p = dma->period_virt + i + 4;
1454 if (p >= dma->nr_periods)
1455 p -= dma->nr_periods;
1456 /* pp: hardware DMA page index. */
1457 pp = dma->period_real + i;
1458 if (pp >= 4)
1459 pp -= 4;
1460 hwwrite(vortex->mmio,
1461 VORTEX_WTDMA_BUFBASE +
1462 (((wtdma << 2) + pp) << 2),
1463 snd_pcm_sgbuf_get_addr(dma->substream,
1464 dma->period_bytes * p));
1465 /* Force write thru cache. */
1466 hwread(vortex->mmio, VORTEX_WTDMA_BUFBASE +
1467 (((wtdma << 2) + pp) << 2));
1468 }
1469 }
1470 dma->period_virt += delta;
1471 if (dma->period_virt >= dma->nr_periods)
1472 dma->period_virt -= dma->nr_periods;
1473 dma->period_real = page;
1474
1475 if (delta != 1)
1476 printk(KERN_WARNING "vortex: wt virt = %d, delta = %d\n",
1477 dma->period_virt, delta);
1478
1479 return delta;
1480 }
1481
1482 #if 0
1483 static void
1484 vortex_wtdma_getposition(vortex_t * vortex, int wtdma, int *subbuf, int *pos)
1485 {
1486 int temp;
1487 temp = hwread(vortex->mmio, VORTEX_WTDMA_STAT + (wtdma << 2));
1488 *subbuf = (temp >> WT_SUBBUF_SHIFT) & WT_SUBBUF_MASK;
1489 *pos = temp & POS_MASK;
1490 }
1491
1492 static int vortex_wtdma_getcursubuffer(vortex_t * vortex, int wtdma)
1493 {
1494 return ((hwread(vortex->mmio, VORTEX_WTDMA_STAT + (wtdma << 2)) >>
1495 POS_SHIFT) & POS_MASK);
1496 }
1497 #endif
1498 static int inline vortex_wtdma_getlinearpos(vortex_t * vortex, int wtdma)
1499 {
1500 stream_t *dma = &vortex->dma_wt[wtdma];
1501 int temp;
1502
1503 temp = hwread(vortex->mmio, VORTEX_WTDMA_STAT + (wtdma << 2));
1504 //temp = (temp & POS_MASK) + (((temp>>WT_SUBBUF_SHIFT) & WT_SUBBUF_MASK)*(dma->cfg0&POS_MASK));
1505 temp = (temp & POS_MASK) + ((dma->period_virt) * (dma->period_bytes));
1506 return temp;
1507 }
1508
1509 static void vortex_wtdma_startfifo(vortex_t * vortex, int wtdma)
1510 {
1511 stream_t *dma = &vortex->dma_wt[wtdma];
1512 int this_8 = 0, this_4 = 0;
1513
1514 switch (dma->fifo_status) {
1515 case FIFO_START:
1516 vortex_fifo_setwtvalid(vortex, wtdma,
1517 dma->fifo_enabled ? 1 : 0);
1518 break;
1519 case FIFO_STOP:
1520 this_8 = 1;
1521 hwwrite(vortex->mmio, VORTEX_WTDMA_CTRL + (wtdma << 2),
1522 dma->dma_ctrl);
1523 vortex_fifo_setwtctrl(vortex, wtdma, dma->dma_unknown,
1524 this_4, this_8,
1525 dma->fifo_enabled ? 1 : 0, 0);
1526 break;
1527 case FIFO_PAUSE:
1528 vortex_fifo_setwtctrl(vortex, wtdma, dma->dma_unknown,
1529 this_4, this_8,
1530 dma->fifo_enabled ? 1 : 0, 0);
1531 break;
1532 }
1533 dma->fifo_status = FIFO_START;
1534 }
1535
1536 static void vortex_wtdma_resumefifo(vortex_t * vortex, int wtdma)
1537 {
1538 stream_t *dma = &vortex->dma_wt[wtdma];
1539
1540 int this_8 = 0, this_4 = 0;
1541 switch (dma->fifo_status) {
1542 case FIFO_STOP:
1543 hwwrite(vortex->mmio, VORTEX_WTDMA_CTRL + (wtdma << 2),
1544 dma->dma_ctrl);
1545 vortex_fifo_setwtctrl(vortex, wtdma, dma->dma_unknown,
1546 this_4, this_8,
1547 dma->fifo_enabled ? 1 : 0, 0);
1548 break;
1549 case FIFO_PAUSE:
1550 vortex_fifo_setwtctrl(vortex, wtdma, dma->dma_unknown,
1551 this_4, this_8,
1552 dma->fifo_enabled ? 1 : 0, 0);
1553 break;
1554 }
1555 dma->fifo_status = FIFO_START;
1556 }
1557
1558 static void vortex_wtdma_pausefifo(vortex_t * vortex, int wtdma)
1559 {
1560 stream_t *dma = &vortex->dma_wt[wtdma];
1561
1562 int this_8 = 0, this_4 = 0;
1563 switch (dma->fifo_status) {
1564 case FIFO_START:
1565 vortex_fifo_setwtctrl(vortex, wtdma, dma->dma_unknown,
1566 this_4, this_8, 0, 0);
1567 break;
1568 case FIFO_STOP:
1569 hwwrite(vortex->mmio, VORTEX_WTDMA_CTRL + (wtdma << 2),
1570 dma->dma_ctrl);
1571 vortex_fifo_setwtctrl(vortex, wtdma, dma->dma_unknown,
1572 this_4, this_8, 0, 0);
1573 break;
1574 }
1575 dma->fifo_status = FIFO_PAUSE;
1576 }
1577
1578 static void vortex_wtdma_stopfifo(vortex_t * vortex, int wtdma)
1579 {
1580 stream_t *dma = &vortex->dma_wt[wtdma];
1581
1582 int this_4 = 0, this_8 = 0;
1583 if (dma->fifo_status == FIFO_START)
1584 vortex_fifo_setwtctrl(vortex, wtdma, dma->dma_unknown,
1585 this_4, this_8, 0, 0);
1586 else if (dma->fifo_status == FIFO_STOP)
1587 return;
1588 dma->fifo_status = FIFO_STOP;
1589 dma->fifo_enabled = 0;
1590 }
1591
1592 #endif
1593 /* ADB Routes */
1594
1595 typedef int ADBRamLink;
1596 static void vortex_adb_init(vortex_t * vortex)
1597 {
1598 int i;
1599 /* it looks like we are writing more than we need to...
1600 * if we write what we are supposed to it breaks things... */
1601 hwwrite(vortex->mmio, VORTEX_ADB_SR, 0);
1602 for (i = 0; i < VORTEX_ADB_RTBASE_COUNT; i++)
1603 hwwrite(vortex->mmio, VORTEX_ADB_RTBASE + (i << 2),
1604 hwread(vortex->mmio,
1605 VORTEX_ADB_RTBASE + (i << 2)) | ROUTE_MASK);
1606 for (i = 0; i < VORTEX_ADB_CHNBASE_COUNT; i++) {
1607 hwwrite(vortex->mmio, VORTEX_ADB_CHNBASE + (i << 2),
1608 hwread(vortex->mmio,
1609 VORTEX_ADB_CHNBASE + (i << 2)) | ROUTE_MASK);
1610 }
1611 }
1612
1613 static void vortex_adb_en_sr(vortex_t * vortex, int channel)
1614 {
1615 hwwrite(vortex->mmio, VORTEX_ADB_SR,
1616 hwread(vortex->mmio, VORTEX_ADB_SR) | (0x1 << channel));
1617 }
1618
1619 static void vortex_adb_dis_sr(vortex_t * vortex, int channel)
1620 {
1621 hwwrite(vortex->mmio, VORTEX_ADB_SR,
1622 hwread(vortex->mmio, VORTEX_ADB_SR) & ~(0x1 << channel));
1623 }
1624
1625 static void
1626 vortex_adb_addroutes(vortex_t * vortex, unsigned char channel,
1627 ADBRamLink * route, int rnum)
1628 {
1629 int temp, prev, lifeboat = 0;
1630
1631 if ((rnum <= 0) || (route == NULL))
1632 return;
1633 /* Write last routes. */
1634 rnum--;
1635 hwwrite(vortex->mmio,
1636 VORTEX_ADB_RTBASE + ((route[rnum] & ADB_MASK) << 2),
1637 ROUTE_MASK);
1638 while (rnum > 0) {
1639 hwwrite(vortex->mmio,
1640 VORTEX_ADB_RTBASE +
1641 ((route[rnum - 1] & ADB_MASK) << 2), route[rnum]);
1642 rnum--;
1643 }
1644 /* Write first route. */
1645 temp =
1646 hwread(vortex->mmio,
1647 VORTEX_ADB_CHNBASE + (channel << 2)) & ADB_MASK;
1648 if (temp == ADB_MASK) {
1649 /* First entry on this channel. */
1650 hwwrite(vortex->mmio, VORTEX_ADB_CHNBASE + (channel << 2),
1651 route[0]);
1652 vortex_adb_en_sr(vortex, channel);
1653 return;
1654 }
1655 /* Not first entry on this channel. Need to link. */
1656 do {
1657 prev = temp;
1658 temp =
1659 hwread(vortex->mmio,
1660 VORTEX_ADB_RTBASE + (temp << 2)) & ADB_MASK;
1661 if ((lifeboat++) > ADB_MASK) {
1662 printk(KERN_ERR
1663 "vortex_adb_addroutes: unending route! 0x%x\n",
1664 *route);
1665 return;
1666 }
1667 }
1668 while (temp != ADB_MASK);
1669 hwwrite(vortex->mmio, VORTEX_ADB_RTBASE + (prev << 2), route[0]);
1670 }
1671
1672 static void
1673 vortex_adb_delroutes(vortex_t * vortex, unsigned char channel,
1674 ADBRamLink route0, ADBRamLink route1)
1675 {
1676 int temp, lifeboat = 0, prev;
1677
1678 /* Find route. */
1679 temp =
1680 hwread(vortex->mmio,
1681 VORTEX_ADB_CHNBASE + (channel << 2)) & ADB_MASK;
1682 if (temp == (route0 & ADB_MASK)) {
1683 temp =
1684 hwread(vortex->mmio,
1685 VORTEX_ADB_RTBASE + ((route1 & ADB_MASK) << 2));
1686 if ((temp & ADB_MASK) == ADB_MASK)
1687 vortex_adb_dis_sr(vortex, channel);
1688 hwwrite(vortex->mmio, VORTEX_ADB_CHNBASE + (channel << 2),
1689 temp);
1690 return;
1691 }
1692 do {
1693 prev = temp;
1694 temp =
1695 hwread(vortex->mmio,
1696 VORTEX_ADB_RTBASE + (prev << 2)) & ADB_MASK;
1697 if (((lifeboat++) > ADB_MASK) || (temp == ADB_MASK)) {
1698 printk(KERN_ERR
1699 "vortex_adb_delroutes: route not found! 0x%x\n",
1700 route0);
1701 return;
1702 }
1703 }
1704 while (temp != (route0 & ADB_MASK));
1705 temp = hwread(vortex->mmio, VORTEX_ADB_RTBASE + (temp << 2));
1706 if ((temp & ADB_MASK) == route1)
1707 temp = hwread(vortex->mmio, VORTEX_ADB_RTBASE + (temp << 2));
1708 /* Make bridge over deleted route. */
1709 hwwrite(vortex->mmio, VORTEX_ADB_RTBASE + (prev << 2), temp);
1710 }
1711
1712 static void
1713 vortex_route(vortex_t * vortex, int en, unsigned char channel,
1714 unsigned char source, unsigned char dest)
1715 {
1716 ADBRamLink route;
1717
1718 route = ((source & ADB_MASK) << ADB_SHIFT) | (dest & ADB_MASK);
1719 if (en) {
1720 vortex_adb_addroutes(vortex, channel, &route, 1);
1721 if ((source < (OFFSET_SRCOUT + NR_SRC))
1722 && (source >= OFFSET_SRCOUT))
1723 vortex_src_addWTD(vortex, (source - OFFSET_SRCOUT),
1724 channel);
1725 else if ((source < (OFFSET_MIXOUT + NR_MIXOUT))
1726 && (source >= OFFSET_MIXOUT))
1727 vortex_mixer_addWTD(vortex,
1728 (source - OFFSET_MIXOUT), channel);
1729 } else {
1730 vortex_adb_delroutes(vortex, channel, route, route);
1731 if ((source < (OFFSET_SRCOUT + NR_SRC))
1732 && (source >= OFFSET_SRCOUT))
1733 vortex_src_delWTD(vortex, (source - OFFSET_SRCOUT),
1734 channel);
1735 else if ((source < (OFFSET_MIXOUT + NR_MIXOUT))
1736 && (source >= OFFSET_MIXOUT))
1737 vortex_mixer_delWTD(vortex,
1738 (source - OFFSET_MIXOUT), channel);
1739 }
1740 }
1741
1742 #if 0
1743 static void
1744 vortex_routes(vortex_t * vortex, int en, unsigned char channel,
1745 unsigned char source, unsigned char dest0, unsigned char dest1)
1746 {
1747 ADBRamLink route[2];
1748
1749 route[0] = ((source & ADB_MASK) << ADB_SHIFT) | (dest0 & ADB_MASK);
1750 route[1] = ((source & ADB_MASK) << ADB_SHIFT) | (dest1 & ADB_MASK);
1751
1752 if (en) {
1753 vortex_adb_addroutes(vortex, channel, route, 2);
1754 if ((source < (OFFSET_SRCOUT + NR_SRC))
1755 && (source >= (OFFSET_SRCOUT)))
1756 vortex_src_addWTD(vortex, (source - OFFSET_SRCOUT),
1757 channel);
1758 else if ((source < (OFFSET_MIXOUT + NR_MIXOUT))
1759 && (source >= (OFFSET_MIXOUT)))
1760 vortex_mixer_addWTD(vortex,
1761 (source - OFFSET_MIXOUT), channel);
1762 } else {
1763 vortex_adb_delroutes(vortex, channel, route[0], route[1]);
1764 if ((source < (OFFSET_SRCOUT + NR_SRC))
1765 && (source >= (OFFSET_SRCOUT)))
1766 vortex_src_delWTD(vortex, (source - OFFSET_SRCOUT),
1767 channel);
1768 else if ((source < (OFFSET_MIXOUT + NR_MIXOUT))
1769 && (source >= (OFFSET_MIXOUT)))
1770 vortex_mixer_delWTD(vortex,
1771 (source - OFFSET_MIXOUT), channel);
1772 }
1773 }
1774
1775 #endif
1776 /* Route two sources to same target. Sources must be of same class !!! */
1777 static void
1778 vortex_routeLRT(vortex_t * vortex, int en, unsigned char ch,
1779 unsigned char source0, unsigned char source1,
1780 unsigned char dest)
1781 {
1782 ADBRamLink route[2];
1783
1784 route[0] = ((source0 & ADB_MASK) << ADB_SHIFT) | (dest & ADB_MASK);
1785 route[1] = ((source1 & ADB_MASK) << ADB_SHIFT) | (dest & ADB_MASK);
1786
1787 if (dest < 0x10)
1788 route[1] = (route[1] & ~ADB_MASK) | (dest + 0x20); /* fifo A */
1789
1790 if (en) {
1791 vortex_adb_addroutes(vortex, ch, route, 2);
1792 if ((source0 < (OFFSET_SRCOUT + NR_SRC))
1793 && (source0 >= OFFSET_SRCOUT)) {
1794 vortex_src_addWTD(vortex,
1795 (source0 - OFFSET_SRCOUT), ch);
1796 vortex_src_addWTD(vortex,
1797 (source1 - OFFSET_SRCOUT), ch);
1798 } else if ((source0 < (OFFSET_MIXOUT + NR_MIXOUT))
1799 && (source0 >= OFFSET_MIXOUT)) {
1800 vortex_mixer_addWTD(vortex,
1801 (source0 - OFFSET_MIXOUT), ch);
1802 vortex_mixer_addWTD(vortex,
1803 (source1 - OFFSET_MIXOUT), ch);
1804 }
1805 } else {
1806 vortex_adb_delroutes(vortex, ch, route[0], route[1]);
1807 if ((source0 < (OFFSET_SRCOUT + NR_SRC))
1808 && (source0 >= OFFSET_SRCOUT)) {
1809 vortex_src_delWTD(vortex,
1810 (source0 - OFFSET_SRCOUT), ch);
1811 vortex_src_delWTD(vortex,
1812 (source1 - OFFSET_SRCOUT), ch);
1813 } else if ((source0 < (OFFSET_MIXOUT + NR_MIXOUT))
1814 && (source0 >= OFFSET_MIXOUT)) {
1815 vortex_mixer_delWTD(vortex,
1816 (source0 - OFFSET_MIXOUT), ch);
1817 vortex_mixer_delWTD(vortex,
1818 (source1 - OFFSET_MIXOUT), ch);
1819 }
1820 }
1821 }
1822
1823 /* Connection stuff */
1824
1825 // Connect adbdma to src('s).
1826 static void
1827 vortex_connection_adbdma_src(vortex_t * vortex, int en, unsigned char ch,
1828 unsigned char adbdma, unsigned char src)
1829 {
1830 vortex_route(vortex, en, ch, ADB_DMA(adbdma), ADB_SRCIN(src));
1831 }
1832
1833 // Connect SRC to mixin.
1834 static void
1835 vortex_connection_src_mixin(vortex_t * vortex, int en,
1836 unsigned char channel, unsigned char src,
1837 unsigned char mixin)
1838 {
1839 vortex_route(vortex, en, channel, ADB_SRCOUT(src), ADB_MIXIN(mixin));
1840 }
1841
1842 // Connect mixin with mix output.
1843 static void
1844 vortex_connection_mixin_mix(vortex_t * vortex, int en, unsigned char mixin,
1845 unsigned char mix, int a)
1846 {
1847 if (en) {
1848 vortex_mix_enableinput(vortex, mix, mixin);
1849 vortex_mix_setinputvolumebyte(vortex, mix, mixin, MIX_DEFIGAIN); // added to original code.
1850 } else
1851 vortex_mix_disableinput(vortex, mix, mixin, a);
1852 }
1853
1854 // Connect absolut address to mixin.
1855 static void
1856 vortex_connection_adb_mixin(vortex_t * vortex, int en,
1857 unsigned char channel, unsigned char source,
1858 unsigned char mixin)
1859 {
1860 vortex_route(vortex, en, channel, source, ADB_MIXIN(mixin));
1861 }
1862
1863 static void
1864 vortex_connection_src_adbdma(vortex_t * vortex, int en, unsigned char ch,
1865 unsigned char src, unsigned char adbdma)
1866 {
1867 vortex_route(vortex, en, ch, ADB_SRCOUT(src), ADB_DMA(adbdma));
1868 }
1869
1870 static void
1871 vortex_connection_src_src_adbdma(vortex_t * vortex, int en,
1872 unsigned char ch, unsigned char src0,
1873 unsigned char src1, unsigned char adbdma)
1874 {
1875
1876 vortex_routeLRT(vortex, en, ch, ADB_SRCOUT(src0), ADB_SRCOUT(src1),
1877 ADB_DMA(adbdma));
1878 }
1879
1880 // mix to absolut address.
1881 static void
1882 vortex_connection_mix_adb(vortex_t * vortex, int en, unsigned char ch,
1883 unsigned char mix, unsigned char dest)
1884 {
1885 vortex_route(vortex, en, ch, ADB_MIXOUT(mix), dest);
1886 vortex_mix_setvolumebyte(vortex, mix, MIX_DEFOGAIN); // added to original code.
1887 }
1888
1889 // mixer to src.
1890 static void
1891 vortex_connection_mix_src(vortex_t * vortex, int en, unsigned char ch,
1892 unsigned char mix, unsigned char src)
1893 {
1894 vortex_route(vortex, en, ch, ADB_MIXOUT(mix), ADB_SRCIN(src));
1895 vortex_mix_setvolumebyte(vortex, mix, MIX_DEFOGAIN); // added to original code.
1896 }
1897
1898 #if 0
1899 static void
1900 vortex_connection_adbdma_src_src(vortex_t * vortex, int en,
1901 unsigned char channel,
1902 unsigned char adbdma, unsigned char src0,
1903 unsigned char src1)
1904 {
1905 vortex_routes(vortex, en, channel, ADB_DMA(adbdma),
1906 ADB_SRCIN(src0), ADB_SRCIN(src1));
1907 }
1908
1909 // Connect two mix to AdbDma.
1910 static void
1911 vortex_connection_mix_mix_adbdma(vortex_t * vortex, int en,
1912 unsigned char ch, unsigned char mix0,
1913 unsigned char mix1, unsigned char adbdma)
1914 {
1915
1916 ADBRamLink routes[2];
1917 routes[0] =
1918 (((mix0 +
1919 OFFSET_MIXOUT) & ADB_MASK) << ADB_SHIFT) | (adbdma & ADB_MASK);
1920 routes[1] =
1921 (((mix1 + OFFSET_MIXOUT) & ADB_MASK) << ADB_SHIFT) | ((adbdma +
1922 0x20) &
1923 ADB_MASK);
1924 if (en) {
1925 vortex_adb_addroutes(vortex, ch, routes, 0x2);
1926 vortex_mixer_addWTD(vortex, mix0, ch);
1927 vortex_mixer_addWTD(vortex, mix1, ch);
1928 } else {
1929 vortex_adb_delroutes(vortex, ch, routes[0], routes[1]);
1930 vortex_mixer_delWTD(vortex, mix0, ch);
1931 vortex_mixer_delWTD(vortex, mix1, ch);
1932 }
1933 }
1934 #endif
1935
1936 /* CODEC connect. */
1937
1938 static void
1939 vortex_connect_codecplay(vortex_t * vortex, int en, unsigned char mixers[])
1940 {
1941 #ifdef CHIP_AU8820
1942 vortex_connection_mix_adb(vortex, en, 0x11, mixers[0], ADB_CODECOUT(0));
1943 vortex_connection_mix_adb(vortex, en, 0x11, mixers[1], ADB_CODECOUT(1));
1944 #else
1945 #if 1
1946 // Connect front channels through EQ.
1947 vortex_connection_mix_adb(vortex, en, 0x11, mixers[0], ADB_EQIN(0));
1948 vortex_connection_mix_adb(vortex, en, 0x11, mixers[1], ADB_EQIN(1));
1949 /* Lower volume, since EQ has some gain. */
1950 vortex_mix_setvolumebyte(vortex, mixers[0], 0);
1951 vortex_mix_setvolumebyte(vortex, mixers[1], 0);
1952 vortex_route(vortex, en, 0x11, ADB_EQOUT(0), ADB_CODECOUT(0));
1953 vortex_route(vortex, en, 0x11, ADB_EQOUT(1), ADB_CODECOUT(1));
1954
1955 /* Check if reg 0x28 has SDAC bit set. */
1956 if (VORTEX_IS_QUAD(vortex)) {
1957 /* Rear channel. Note: ADB_CODECOUT(0+2) and (1+2) is for AC97 modem */
1958 vortex_connection_mix_adb(vortex, en, 0x11, mixers[2],
1959 ADB_CODECOUT(0 + 4));
1960 vortex_connection_mix_adb(vortex, en, 0x11, mixers[3],
1961 ADB_CODECOUT(1 + 4));
1962 //printk("SDAC detected ");
1963 }
1964 #else
1965 // Use plain direct output to codec.
1966 vortex_connection_mix_adb(vortex, en, 0x11, mixers[0], ADB_CODECOUT(0));
1967 vortex_connection_mix_adb(vortex, en, 0x11, mixers[1], ADB_CODECOUT(1));
1968 #endif
1969 #endif
1970 }
1971
1972 static void
1973 vortex_connect_codecrec(vortex_t * vortex, int en, unsigned char mixin0,
1974 unsigned char mixin1)
1975 {
1976 /*
1977 Enable: 0x1, 0x1
1978 Channel: 0x11, 0x11
1979 ADB Source address: 0x48, 0x49
1980 Destination Asp4Topology_0x9c,0x98
1981 */
1982 vortex_connection_adb_mixin(vortex, en, 0x11, ADB_CODECIN(0), mixin0);
1983 vortex_connection_adb_mixin(vortex, en, 0x11, ADB_CODECIN(1), mixin1);
1984 }
1985
1986 // Higher level ADB audio path (de)allocator.
1987
1988 /* Resource manager */
1989 static int resnum[VORTEX_RESOURCE_LAST] =
1990 { NR_ADB, NR_SRC, NR_MIXIN, NR_MIXOUT, NR_A3D };
1991 /*
1992 Checkout/Checkin resource of given type.
1993 resmap: resource map to be used. If NULL means that we want to allocate
1994 a DMA resource (root of all other resources of a dma channel).
1995 out: Mean checkout if != 0. Else mean Checkin resource.
1996 restype: Indicates type of resource to be checked in or out.
1997 */
1998 static char
1999 vortex_adb_checkinout(vortex_t * vortex, int resmap[], int out, int restype)
2000 {
2001 int i, qty = resnum[restype], resinuse = 0;
2002
2003 if (out) {
2004 /* Gather used resources by all streams. */
2005 for (i = 0; i < NR_ADB; i++) {
2006 resinuse |= vortex->dma_adb[i].resources[restype];
2007 }
2008 resinuse |= vortex->fixed_res[restype];
2009 /* Find and take free resource. */
2010 for (i = 0; i < qty; i++) {
2011 if ((resinuse & (1 << i)) == 0) {
2012 if (resmap != NULL)
2013 resmap[restype] |= (1 << i);
2014 else
2015 vortex->dma_adb[i].resources[restype] |= (1 << i);
2016 //printk("vortex: ResManager: type %d out %d\n", restype, i);
2017 return i;
2018 }
2019 }
2020 } else {
2021 if (resmap == NULL)
2022 return -EINVAL;
2023 /* Checkin first resource of type restype. */
2024 for (i = 0; i < qty; i++) {
2025 if (resmap[restype] & (1 << i)) {
2026 resmap[restype] &= ~(1 << i);
2027 //printk("vortex: ResManager: type %d in %d\n",restype, i);
2028 return i;
2029 }
2030 }
2031 }
2032 printk(KERN_ERR "vortex: FATAL: ResManager: resource type %d exhausted.\n", restype);
2033 return -ENOMEM;
2034 }
2035
2036 /* Default Connections */
2037 static int
2038 vortex_adb_allocroute(vortex_t * vortex, int dma, int nr_ch, int dir, int type);
2039
2040 static void vortex_connect_default(vortex_t * vortex, int en)
2041 {
2042 // Connect AC97 codec.
2043 vortex->mixplayb[0] = vortex_adb_checkinout(vortex, vortex->fixed_res, en,
2044 VORTEX_RESOURCE_MIXOUT);
2045 vortex->mixplayb[1] = vortex_adb_checkinout(vortex, vortex->fixed_res, en,
2046 VORTEX_RESOURCE_MIXOUT);
2047 if (VORTEX_IS_QUAD(vortex)) {
2048 vortex->mixplayb[2] = vortex_adb_checkinout(vortex, vortex->fixed_res, en,
2049 VORTEX_RESOURCE_MIXOUT);
2050 vortex->mixplayb[3] = vortex_adb_checkinout(vortex, vortex->fixed_res, en,
2051 VORTEX_RESOURCE_MIXOUT);
2052 }
2053 vortex_connect_codecplay(vortex, en, vortex->mixplayb);
2054
2055 vortex->mixcapt[0] = vortex_adb_checkinout(vortex, vortex->fixed_res, en,
2056 VORTEX_RESOURCE_MIXIN);
2057 vortex->mixcapt[1] = vortex_adb_checkinout(vortex, vortex->fixed_res, en,
2058 VORTEX_RESOURCE_MIXIN);
2059 vortex_connect_codecrec(vortex, en, MIX_CAPT(0), MIX_CAPT(1));
2060
2061 // Connect SPDIF
2062 #ifndef CHIP_AU8820
2063 vortex->mixspdif[0] = vortex_adb_checkinout(vortex, vortex->fixed_res, en,
2064 VORTEX_RESOURCE_MIXOUT);
2065 vortex->mixspdif[1] = vortex_adb_checkinout(vortex, vortex->fixed_res, en,
2066 VORTEX_RESOURCE_MIXOUT);
2067 vortex_connection_mix_adb(vortex, en, 0x14, vortex->mixspdif[0],
2068 ADB_SPDIFOUT(0));
2069 vortex_connection_mix_adb(vortex, en, 0x14, vortex->mixspdif[1],
2070 ADB_SPDIFOUT(1));
2071 #endif
2072 // Connect WT
2073 #ifndef CHIP_AU8810
2074 vortex_wt_connect(vortex, en);
2075 #endif
2076 // A3D (crosstalk canceler and A3D slices). AU8810 disabled for now.
2077 #ifndef CHIP_AU8820
2078 vortex_Vort3D_connect(vortex, en);
2079 #endif
2080 // Connect I2S
2081
2082 // Connect DSP interface for SQ3500 turbo (not here i think...)
2083
2084 // Connect AC98 modem codec
2085
2086 }
2087
2088 /*
2089 Allocate nr_ch pcm audio routes if dma < 0. If dma >= 0, existing routes
2090 are deallocated.
2091 dma: DMA engine routes to be deallocated when dma >= 0.
2092 nr_ch: Number of channels to be de/allocated.
2093 dir: direction of stream. Uses same values as substream->stream.
2094 type: Type of audio output/source (codec, spdif, i2s, dsp, etc)
2095 Return: Return allocated DMA or same DMA passed as "dma" when dma >= 0.
2096 */
2097 static int
2098 vortex_adb_allocroute(vortex_t * vortex, int dma, int nr_ch, int dir, int type)
2099 {
2100 stream_t *stream;
2101 int i, en;
2102
2103 if ((nr_ch == 3)
2104 || ((dir == SNDRV_PCM_STREAM_CAPTURE) && (nr_ch > 2)))
2105 return -EBUSY;
2106
2107 if (dma >= 0) {
2108 en = 0;
2109 vortex_adb_checkinout(vortex,
2110 vortex->dma_adb[dma].resources, en,
2111 VORTEX_RESOURCE_DMA);
2112 } else {
2113 en = 1;
2114 if ((dma =
2115 vortex_adb_checkinout(vortex, NULL, en,
2116 VORTEX_RESOURCE_DMA)) < 0)
2117 return -EBUSY;
2118 }
2119
2120 stream = &vortex->dma_adb[dma];
2121 stream->dma = dma;
2122 stream->dir = dir;
2123 stream->type = type;
2124
2125 /* PLAYBACK ROUTES. */
2126 if (dir == SNDRV_PCM_STREAM_PLAYBACK) {
2127 int src[4], mix[4], ch_top;
2128 #ifndef CHIP_AU8820
2129 int a3d = 0;
2130 #endif
2131 /* Get SRC and MIXER hardware resources. */
2132 if (stream->type != VORTEX_PCM_SPDIF) {
2133 for (i = 0; i < nr_ch; i++) {
2134 if ((src[i] = vortex_adb_checkinout(vortex,
2135 stream->resources, en,
2136 VORTEX_RESOURCE_SRC)) < 0) {
2137 memset(stream->resources, 0,
2138 sizeof(unsigned char) *
2139 VORTEX_RESOURCE_LAST);
2140 return -EBUSY;
2141 }
2142 if (stream->type != VORTEX_PCM_A3D) {
2143 if ((mix[i] = vortex_adb_checkinout(vortex,
2144 stream->resources,
2145 en,
2146 VORTEX_RESOURCE_MIXIN)) < 0) {
2147 memset(stream->resources,
2148 0,
2149 sizeof(unsigned char) * VORTEX_RESOURCE_LAST);
2150 return -EBUSY;
2151 }
2152 }
2153 }
2154 }
2155 #ifndef CHIP_AU8820
2156 if (stream->type == VORTEX_PCM_A3D) {
2157 if ((a3d =
2158 vortex_adb_checkinout(vortex,
2159 stream->resources, en,
2160 VORTEX_RESOURCE_A3D)) < 0) {
2161 memset(stream->resources, 0,
2162 sizeof(unsigned char) *
2163 VORTEX_RESOURCE_LAST);
2164 printk(KERN_ERR "vortex: out of A3D sources. Sorry\n");
2165 return -EBUSY;
2166 }
2167 /* (De)Initialize A3D hardware source. */
2168 vortex_Vort3D_InitializeSource(&(vortex->a3d[a3d]), en);
2169 }
2170 /* Make SPDIF out exclusive to "spdif" device when in use. */
2171 if ((stream->type == VORTEX_PCM_SPDIF) && (en)) {
2172 vortex_route(vortex, 0, 0x14,
2173 ADB_MIXOUT(vortex->mixspdif[0]),
2174 ADB_SPDIFOUT(0));
2175 vortex_route(vortex, 0, 0x14,
2176 ADB_MIXOUT(vortex->mixspdif[1]),
2177 ADB_SPDIFOUT(1));
2178 }
2179 #endif
2180 /* Make playback routes. */
2181 for (i = 0; i < nr_ch; i++) {
2182 if (stream->type == VORTEX_PCM_ADB) {
2183 vortex_connection_adbdma_src(vortex, en,
2184 src[nr_ch - 1],
2185 dma,
2186 src[i]);
2187 vortex_connection_src_mixin(vortex, en,
2188 0x11, src[i],
2189 mix[i]);
2190 vortex_connection_mixin_mix(vortex, en,
2191 mix[i],
2192 MIX_PLAYB(i), 0);
2193 #ifndef CHIP_AU8820
2194 vortex_connection_mixin_mix(vortex, en,
2195 mix[i],
2196 MIX_SPDIF(i % 2), 0);
2197 vortex_mix_setinputvolumebyte(vortex,
2198 MIX_SPDIF(i % 2),
2199 mix[i],
2200 MIX_DEFIGAIN);
2201 #endif
2202 }
2203 #ifndef CHIP_AU8820
2204 if (stream->type == VORTEX_PCM_A3D) {
2205 vortex_connection_adbdma_src(vortex, en,
2206 src[nr_ch - 1],
2207 dma,
2208 src[i]);
2209 vortex_route(vortex, en, 0x11, ADB_SRCOUT(src[i]), ADB_A3DIN(a3d));
2210 /* XTalk test. */
2211 //vortex_route(vortex, en, 0x11, dma, ADB_XTALKIN(i?9:4));
2212 //vortex_route(vortex, en, 0x11, ADB_SRCOUT(src[i]), ADB_XTALKIN(i?4:9));
2213 }
2214 if (stream->type == VORTEX_PCM_SPDIF)
2215 vortex_route(vortex, en, 0x14,
2216 ADB_DMA(stream->dma),
2217 ADB_SPDIFOUT(i));
2218 #endif
2219 }
2220 if (stream->type != VORTEX_PCM_SPDIF && stream->type != VORTEX_PCM_A3D) {
2221 ch_top = (VORTEX_IS_QUAD(vortex) ? 4 : 2);
2222 for (i = nr_ch; i < ch_top; i++) {
2223 vortex_connection_mixin_mix(vortex, en,
2224 mix[i % nr_ch],
2225 MIX_PLAYB(i), 0);
2226 #ifndef CHIP_AU8820
2227 vortex_connection_mixin_mix(vortex, en,
2228 mix[i % nr_ch],
2229 MIX_SPDIF(i % 2),
2230 0);
2231 vortex_mix_setinputvolumebyte(vortex,
2232 MIX_SPDIF(i % 2),
2233 mix[i % nr_ch],
2234 MIX_DEFIGAIN);
2235 #endif
2236 }
2237 }
2238 #ifndef CHIP_AU8820
2239 else {
2240 if (nr_ch == 1 && stream->type == VORTEX_PCM_SPDIF)
2241 vortex_route(vortex, en, 0x14,
2242 ADB_DMA(stream->dma),
2243 ADB_SPDIFOUT(1));
2244 }
2245 /* Reconnect SPDIF out when "spdif" device is down. */
2246 if ((stream->type == VORTEX_PCM_SPDIF) && (!en)) {
2247 vortex_route(vortex, 1, 0x14,
2248 ADB_MIXOUT(vortex->mixspdif[0]),
2249 ADB_SPDIFOUT(0));
2250 vortex_route(vortex, 1, 0x14,
2251 ADB_MIXOUT(vortex->mixspdif[1]),
2252 ADB_SPDIFOUT(1));
2253 }
2254 #endif
2255 /* CAPTURE ROUTES. */
2256 } else {
2257 int src[2], mix[2];
2258
2259 /* Get SRC and MIXER hardware resources. */
2260 for (i = 0; i < nr_ch; i++) {
2261 if ((mix[i] =
2262 vortex_adb_checkinout(vortex,
2263 stream->resources, en,
2264 VORTEX_RESOURCE_MIXOUT))
2265 < 0) {
2266 memset(stream->resources, 0,
2267 sizeof(unsigned char) *
2268 VORTEX_RESOURCE_LAST);
2269 return -EBUSY;
2270 }
2271 if ((src[i] =
2272 vortex_adb_checkinout(vortex,
2273 stream->resources, en,
2274 VORTEX_RESOURCE_SRC)) < 0) {
2275 memset(stream->resources, 0,
2276 sizeof(unsigned char) *
2277 VORTEX_RESOURCE_LAST);
2278 return -EBUSY;
2279 }
2280 }
2281
2282 /* Make capture routes. */
2283 vortex_connection_mixin_mix(vortex, en, MIX_CAPT(0), mix[0], 0);
2284 vortex_connection_mix_src(vortex, en, 0x11, mix[0], src[0]);
2285 if (nr_ch == 1) {
2286 vortex_connection_mixin_mix(vortex, en,
2287 MIX_CAPT(1), mix[0], 0);
2288 vortex_connection_src_adbdma(vortex, en,
2289 src[0],
2290 src[0], dma);
2291 } else {
2292 vortex_connection_mixin_mix(vortex, en,
2293 MIX_CAPT(1), mix[1], 0);
2294 vortex_connection_mix_src(vortex, en, 0x11, mix[1],
2295 src[1]);
2296 vortex_connection_src_src_adbdma(vortex, en,
2297 src[1], src[0],
2298 src[1], dma);
2299 }
2300 }
2301 vortex->dma_adb[dma].nr_ch = nr_ch;
2302
2303 #if 0
2304 /* AC97 Codec channel setup. FIXME: this has no effect on some cards !! */
2305 if (nr_ch < 4) {
2306 /* Copy stereo to rear channel (surround) */
2307 snd_ac97_write_cache(vortex->codec,
2308 AC97_SIGMATEL_DAC2INVERT,
2309 snd_ac97_read(vortex->codec,
2310 AC97_SIGMATEL_DAC2INVERT)
2311 | 4);
2312 } else {
2313 /* Allow separate front and rear channels. */
2314 snd_ac97_write_cache(vortex->codec,
2315 AC97_SIGMATEL_DAC2INVERT,
2316 snd_ac97_read(vortex->codec,
2317 AC97_SIGMATEL_DAC2INVERT)
2318 & ~((u32)
2319 4));
2320 }
2321 #endif
2322 return dma;
2323 }
2324
2325 /*
2326 Set the SampleRate of the SRC's attached to the given DMA engine.
2327 */
2328 static void
2329 vortex_adb_setsrc(vortex_t * vortex, int adbdma, unsigned int rate, int dir)
2330 {
2331 stream_t *stream = &(vortex->dma_adb[adbdma]);
2332 int i, cvrt;
2333
2334 /* dir=1:play ; dir=0:rec */
2335 if (dir)
2336 cvrt = SRC_RATIO(rate, 48000);
2337 else
2338 cvrt = SRC_RATIO(48000, rate);
2339
2340 /* Setup SRC's */
2341 for (i = 0; i < NR_SRC; i++) {
2342 if (stream->resources[VORTEX_RESOURCE_SRC] & (1 << i))
2343 vortex_src_setupchannel(vortex, i, cvrt, 0, 0, i, dir, 1, cvrt, dir);
2344 }
2345 }
2346
2347 // Timer and ISR functions.
2348
2349 static void vortex_settimer(vortex_t * vortex, int period)
2350 {
2351 //set the timer period to <period> 48000ths of a second.
2352 hwwrite(vortex->mmio, VORTEX_IRQ_STAT, period);
2353 }
2354
2355 #if 0
2356 static void vortex_enable_timer_int(vortex_t * card)
2357 {
2358 hwwrite(card->mmio, VORTEX_IRQ_CTRL,
2359 hwread(card->mmio, VORTEX_IRQ_CTRL) | IRQ_TIMER | 0x60);
2360 }
2361
2362 static void vortex_disable_timer_int(vortex_t * card)
2363 {
2364 hwwrite(card->mmio, VORTEX_IRQ_CTRL,
2365 hwread(card->mmio, VORTEX_IRQ_CTRL) & ~IRQ_TIMER);
2366 }
2367
2368 #endif
2369 static void vortex_enable_int(vortex_t * card)
2370 {
2371 // CAsp4ISR__EnableVortexInt_void_
2372 hwwrite(card->mmio, VORTEX_CTRL,
2373 hwread(card->mmio, VORTEX_CTRL) | CTRL_IRQ_ENABLE);
2374 hwwrite(card->mmio, VORTEX_IRQ_CTRL,
2375 (hwread(card->mmio, VORTEX_IRQ_CTRL) & 0xffffefc0) | 0x24);
2376 }
2377
2378 static void vortex_disable_int(vortex_t * card)
2379 {
2380 hwwrite(card->mmio, VORTEX_CTRL,
2381 hwread(card->mmio, VORTEX_CTRL) & ~CTRL_IRQ_ENABLE);
2382 }
2383
2384 static irqreturn_t vortex_interrupt(int irq, void *dev_id)
2385 {
2386 vortex_t *vortex = dev_id;
2387 int i, handled;
2388 u32 source;
2389
2390 //check if the interrupt is ours.
2391 if (!(hwread(vortex->mmio, VORTEX_STAT) & 0x1))
2392 return IRQ_NONE;
2393
2394 // This is the Interrupt Enable flag we set before (consistency check).
2395 if (!(hwread(vortex->mmio, VORTEX_CTRL) & CTRL_IRQ_ENABLE))
2396 return IRQ_NONE;
2397
2398 source = hwread(vortex->mmio, VORTEX_IRQ_SOURCE);
2399 // Reset IRQ flags.
2400 hwwrite(vortex->mmio, VORTEX_IRQ_SOURCE, source);
2401 hwread(vortex->mmio, VORTEX_IRQ_SOURCE);
2402 // Is at least one IRQ flag set?
2403 if (source == 0) {
2404 printk(KERN_ERR "vortex: missing irq source\n");
2405 return IRQ_NONE;
2406 }
2407
2408 handled = 0;
2409 // Attend every interrupt source.
2410 if (unlikely(source & IRQ_ERR_MASK)) {
2411 if (source & IRQ_FATAL) {
2412 printk(KERN_ERR "vortex: IRQ fatal error\n");
2413 }
2414 if (source & IRQ_PARITY) {
2415 printk(KERN_ERR "vortex: IRQ parity error\n");
2416 }
2417 if (source & IRQ_REG) {
2418 printk(KERN_ERR "vortex: IRQ reg error\n");
2419 }
2420 if (source & IRQ_FIFO) {
2421 printk(KERN_ERR "vortex: IRQ fifo error\n");
2422 }
2423 if (source & IRQ_DMA) {
2424 printk(KERN_ERR "vortex: IRQ dma error\n");
2425 }
2426 handled = 1;
2427 }
2428 if (source & IRQ_PCMOUT) {
2429 /* ALSA period acknowledge. */
2430 spin_lock(&vortex->lock);
2431 for (i = 0; i < NR_ADB; i++) {
2432 if (vortex->dma_adb[i].fifo_status == FIFO_START) {
2433 if (vortex_adbdma_bufshift(vortex, i)) ;
2434 spin_unlock(&vortex->lock);
2435 snd_pcm_period_elapsed(vortex->dma_adb[i].
2436 substream);
2437 spin_lock(&vortex->lock);
2438 }
2439 }
2440 #ifndef CHIP_AU8810
2441 for (i = 0; i < NR_WT; i++) {
2442 if (vortex->dma_wt[i].fifo_status == FIFO_START) {
2443 if (vortex_wtdma_bufshift(vortex, i)) ;
2444 spin_unlock(&vortex->lock);
2445 snd_pcm_period_elapsed(vortex->dma_wt[i].
2446 substream);
2447 spin_lock(&vortex->lock);
2448 }
2449 }
2450 #endif
2451 spin_unlock(&vortex->lock);
2452 handled = 1;
2453 }
2454 //Acknowledge the Timer interrupt
2455 if (source & IRQ_TIMER) {
2456 hwread(vortex->mmio, VORTEX_IRQ_STAT);
2457 handled = 1;
2458 }
2459 if (source & IRQ_MIDI) {
2460 snd_mpu401_uart_interrupt(vortex->irq,
2461 vortex->rmidi->private_data);
2462 handled = 1;
2463 }
2464
2465 if (!handled) {
2466 printk(KERN_ERR "vortex: unknown irq source %x\n", source);
2467 }
2468 return IRQ_RETVAL(handled);
2469 }
2470
2471 /* Codec */
2472
2473 #define POLL_COUNT 1000
2474 static void vortex_codec_init(vortex_t * vortex)
2475 {
2476 int i;
2477
2478 for (i = 0; i < 32; i++) {
2479 /* the windows driver writes -i, so we write -i */
2480 hwwrite(vortex->mmio, (VORTEX_CODEC_CHN + (i << 2)), -i);
2481 msleep(2);
2482 }
2483 if (0) {
2484 hwwrite(vortex->mmio, VORTEX_CODEC_CTRL, 0x8068);
2485 msleep(1);
2486 hwwrite(vortex->mmio, VORTEX_CODEC_CTRL, 0x00e8);
2487 msleep(1);
2488 } else {
2489 hwwrite(vortex->mmio, VORTEX_CODEC_CTRL, 0x00a8);
2490 msleep(2);
2491 hwwrite(vortex->mmio, VORTEX_CODEC_CTRL, 0x80a8);
2492 msleep(2);
2493 hwwrite(vortex->mmio, VORTEX_CODEC_CTRL, 0x80e8);
2494 msleep(2);
2495 hwwrite(vortex->mmio, VORTEX_CODEC_CTRL, 0x80a8);
2496 msleep(2);
2497 hwwrite(vortex->mmio, VORTEX_CODEC_CTRL, 0x00a8);
2498 msleep(2);
2499 hwwrite(vortex->mmio, VORTEX_CODEC_CTRL, 0x00e8);
2500 }
2501 for (i = 0; i < 32; i++) {
2502 hwwrite(vortex->mmio, (VORTEX_CODEC_CHN + (i << 2)), -i);
2503 msleep(5);
2504 }
2505 hwwrite(vortex->mmio, VORTEX_CODEC_CTRL, 0xe8);
2506 msleep(1);
2507 /* Enable codec channels 0 and 1. */
2508 hwwrite(vortex->mmio, VORTEX_CODEC_EN,
2509 hwread(vortex->mmio, VORTEX_CODEC_EN) | EN_CODEC);
2510 }
2511
2512 static void
2513 vortex_codec_write(struct snd_ac97 * codec, unsigned short addr, unsigned short data)
2514 {
2515
2516 vortex_t *card = (vortex_t *) codec->private_data;
2517 unsigned int lifeboat = 0;
2518
2519 /* wait for transactions to clear */
2520 while (!(hwread(card->mmio, VORTEX_CODEC_CTRL) & 0x100)) {
2521 udelay(100);
2522 if (lifeboat++ > POLL_COUNT) {
2523 printk(KERN_ERR "vortex: ac97 codec stuck busy\n");
2524 return;
2525 }
2526 }
2527 /* write register */
2528 hwwrite(card->mmio, VORTEX_CODEC_IO,
2529 ((addr << VORTEX_CODEC_ADDSHIFT) & VORTEX_CODEC_ADDMASK) |
2530 ((data << VORTEX_CODEC_DATSHIFT) & VORTEX_CODEC_DATMASK) |
2531 VORTEX_CODEC_WRITE |
2532 (codec->num << VORTEX_CODEC_ID_SHIFT) );
2533
2534 /* Flush Caches. */
2535 hwread(card->mmio, VORTEX_CODEC_IO);
2536 }
2537
2538 static unsigned short vortex_codec_read(struct snd_ac97 * codec, unsigned short addr)
2539 {
2540
2541 vortex_t *card = (vortex_t *) codec->private_data;
2542 u32 read_addr, data;
2543 unsigned lifeboat = 0;
2544
2545 /* wait for transactions to clear */
2546 while (!(hwread(card->mmio, VORTEX_CODEC_CTRL) & 0x100)) {
2547 udelay(100);
2548 if (lifeboat++ > POLL_COUNT) {
2549 printk(KERN_ERR "vortex: ac97 codec stuck busy\n");
2550 return 0xffff;
2551 }
2552 }
2553 /* set up read address */
2554 read_addr = ((addr << VORTEX_CODEC_ADDSHIFT) & VORTEX_CODEC_ADDMASK) |
2555 (codec->num << VORTEX_CODEC_ID_SHIFT) ;
2556 hwwrite(card->mmio, VORTEX_CODEC_IO, read_addr);
2557
2558 /* wait for address */
2559 do {
2560 udelay(100);
2561 data = hwread(card->mmio, VORTEX_CODEC_IO);
2562 if (lifeboat++ > POLL_COUNT) {
2563 printk(KERN_ERR "vortex: ac97 address never arrived\n");
2564 return 0xffff;
2565 }
2566 } while ((data & VORTEX_CODEC_ADDMASK) !=
2567 (addr << VORTEX_CODEC_ADDSHIFT));
2568
2569 /* return data. */
2570 return (u16) (data & VORTEX_CODEC_DATMASK);
2571 }
2572
2573 /* SPDIF support */
2574
2575 static void vortex_spdif_init(vortex_t * vortex, int spdif_sr, int spdif_mode)
2576 {
2577 int i, this_38 = 0, this_04 = 0, this_08 = 0, this_0c = 0;
2578
2579 /* CAsp4Spdif::InitializeSpdifHardware(void) */
2580 hwwrite(vortex->mmio, VORTEX_SPDIF_FLAGS,
2581 hwread(vortex->mmio, VORTEX_SPDIF_FLAGS) & 0xfff3fffd);
2582 //for (i=0x291D4; i<0x29200; i+=4)
2583 for (i = 0; i < 11; i++)
2584 hwwrite(vortex->mmio, VORTEX_SPDIF_CFG1 + (i << 2), 0);
2585 //hwwrite(vortex->mmio, 0x29190, hwread(vortex->mmio, 0x29190) | 0xc0000);
2586 hwwrite(vortex->mmio, VORTEX_CODEC_EN,
2587 hwread(vortex->mmio, VORTEX_CODEC_EN) | EN_SPDIF);
2588
2589 /* CAsp4Spdif::ProgramSRCInHardware(enum SPDIF_SR,enum SPDIFMODE) */
2590 if (this_04 && this_08) {
2591 int edi;
2592
2593 i = (((0x5DC00000 / spdif_sr) + 1) >> 1);
2594 if (i > 0x800) {
2595 if (i < 0x1ffff)
2596 edi = (i >> 1);
2597 else
2598 edi = 0x1ffff;
2599 } else {
2600 i = edi = 0x800;
2601 }
2602 /* this_04 and this_08 are the CASp4Src's (samplerate converters) */
2603 vortex_src_setupchannel(vortex, this_04, edi, 0, 1,
2604 this_0c, 1, 0, edi, 1);
2605 vortex_src_setupchannel(vortex, this_08, edi, 0, 1,
2606 this_0c, 1, 0, edi, 1);
2607 }
2608
2609 i = spdif_sr;
2610 spdif_sr |= 0x8c;
2611 switch (i) {
2612 case 32000:
2613 this_38 &= 0xFFFFFFFE;
2614 this_38 &= 0xFFFFFFFD;
2615 this_38 &= 0xF3FFFFFF;
2616 this_38 |= 0x03000000; /* set 32khz samplerate */
2617 this_38 &= 0xFFFFFF3F;
2618 spdif_sr &= 0xFFFFFFFD;
2619 spdif_sr |= 1;
2620 break;
2621 case 44100:
2622 this_38 &= 0xFFFFFFFE;
2623 this_38 &= 0xFFFFFFFD;
2624 this_38 &= 0xF0FFFFFF;
2625 this_38 |= 0x03000000;
2626 this_38 &= 0xFFFFFF3F;
2627 spdif_sr &= 0xFFFFFFFC;
2628 break;
2629 case 48000:
2630 if (spdif_mode == 1) {
2631 this_38 &= 0xFFFFFFFE;
2632 this_38 &= 0xFFFFFFFD;
2633 this_38 &= 0xF2FFFFFF;
2634 this_38 |= 0x02000000; /* set 48khz samplerate */
2635 this_38 &= 0xFFFFFF3F;
2636 } else {
2637 /* J. Gordon Wolfe: I think this stuff is for AC3 */
2638 this_38 |= 0x00000003;
2639 this_38 &= 0xFFFFFFBF;
2640 this_38 |= 0x80;
2641 }
2642 spdif_sr |= 2;
2643 spdif_sr &= 0xFFFFFFFE;
2644 break;
2645
2646 }
2647 /* looks like the next 2 lines transfer a 16-bit value into 2 8-bit
2648 registers. seems to be for the standard IEC/SPDIF initialization
2649 stuff */
2650 hwwrite(vortex->mmio, VORTEX_SPDIF_CFG0, this_38 & 0xffff);
2651 hwwrite(vortex->mmio, VORTEX_SPDIF_CFG1, this_38 >> 0x10);
2652 hwwrite(vortex->mmio, VORTEX_SPDIF_SMPRATE, spdif_sr);
2653 }
2654
2655 /* Initialization */
2656
2657 static int __devinit vortex_core_init(vortex_t * vortex)
2658 {
2659
2660 printk(KERN_INFO "Vortex: init.... ");
2661 /* Hardware Init. */
2662 hwwrite(vortex->mmio, VORTEX_CTRL, 0xffffffff);
2663 msleep(5);
2664 hwwrite(vortex->mmio, VORTEX_CTRL,
2665 hwread(vortex->mmio, VORTEX_CTRL) & 0xffdfffff);
2666 msleep(5);
2667 /* Reset IRQ flags */
2668 hwwrite(vortex->mmio, VORTEX_IRQ_SOURCE, 0xffffffff);
2669 hwread(vortex->mmio, VORTEX_IRQ_STAT);
2670
2671 vortex_codec_init(vortex);
2672
2673 #ifdef CHIP_AU8830
2674 hwwrite(vortex->mmio, VORTEX_CTRL,
2675 hwread(vortex->mmio, VORTEX_CTRL) | 0x1000000);
2676 #endif
2677
2678 /* Init audio engine. */
2679 vortex_adbdma_init(vortex);
2680 hwwrite(vortex->mmio, VORTEX_ENGINE_CTRL, 0x0); //, 0xc83c7e58, 0xc5f93e58
2681 vortex_adb_init(vortex);
2682 /* Init processing blocks. */
2683 vortex_fifo_init(vortex);
2684 vortex_mixer_init(vortex);
2685 vortex_srcblock_init(vortex);
2686 #ifndef CHIP_AU8820
2687 vortex_eq_init(vortex);
2688 vortex_spdif_init(vortex, 48000, 1);
2689 vortex_Vort3D_enable(vortex);
2690 #endif
2691 #ifndef CHIP_AU8810
2692 vortex_wt_init(vortex);
2693 #endif
2694 // Moved to au88x0.c
2695 //vortex_connect_default(vortex, 1);
2696
2697 vortex_settimer(vortex, 0x90);
2698 // Enable Interrupts.
2699 // vortex_enable_int() must be first !!
2700 // hwwrite(vortex->mmio, VORTEX_IRQ_CTRL, 0);
2701 // vortex_enable_int(vortex);
2702 //vortex_enable_timer_int(vortex);
2703 //vortex_disable_timer_int(vortex);
2704
2705 printk(KERN_INFO "done.\n");
2706 spin_lock_init(&vortex->lock);
2707
2708 return 0;
2709 }
2710
2711 static int vortex_core_shutdown(vortex_t * vortex)
2712 {
2713
2714 printk(KERN_INFO "Vortex: shutdown...");
2715 #ifndef CHIP_AU8820
2716 vortex_eq_free(vortex);
2717 vortex_Vort3D_disable(vortex);
2718 #endif
2719 //vortex_disable_timer_int(vortex);
2720 vortex_disable_int(vortex);
2721 vortex_connect_default(vortex, 0);
2722 /* Reset all DMA fifos. */
2723 vortex_fifo_init(vortex);
2724 /* Erase all audio routes. */
2725 vortex_adb_init(vortex);
2726
2727 /* Disable MPU401 */
2728 //hwwrite(vortex->mmio, VORTEX_IRQ_CTRL, hwread(vortex->mmio, VORTEX_IRQ_CTRL) & ~IRQ_MIDI);
2729 //hwwrite(vortex->mmio, VORTEX_CTRL, hwread(vortex->mmio, VORTEX_CTRL) & ~CTRL_MIDI_EN);
2730
2731 hwwrite(vortex->mmio, VORTEX_IRQ_CTRL, 0);
2732 hwwrite(vortex->mmio, VORTEX_CTRL, 0);
2733 msleep(5);
2734 hwwrite(vortex->mmio, VORTEX_IRQ_SOURCE, 0xffff);
2735
2736 printk(KERN_INFO "done.\n");
2737 return 0;
2738 }
2739
2740 /* Alsa support. */
2741
2742 static int vortex_alsafmt_aspfmt(int alsafmt)
2743 {
2744 int fmt;
2745
2746 switch (alsafmt) {
2747 case SNDRV_PCM_FORMAT_U8:
2748 fmt = 0x1;
2749 break;
2750 case SNDRV_PCM_FORMAT_MU_LAW:
2751 fmt = 0x2;
2752 break;
2753 case SNDRV_PCM_FORMAT_A_LAW:
2754 fmt = 0x3;
2755 break;
2756 case SNDRV_PCM_FORMAT_SPECIAL:
2757 fmt = 0x4; /* guess. */
2758 break;
2759 case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE:
2760 fmt = 0x5; /* guess. */
2761 break;
2762 case SNDRV_PCM_FORMAT_S16_LE:
2763 fmt = 0x8;
2764 break;
2765 case SNDRV_PCM_FORMAT_S16_BE:
2766 fmt = 0x9; /* check this... */
2767 break;
2768 default:
2769 fmt = 0x8;
2770 printk(KERN_ERR "vortex: format unsupported %d\n", alsafmt);
2771 break;
2772 }
2773 return fmt;
2774 }
2775
2776 /* Some not yet useful translations. */
2777 #if 0
2778 typedef enum {
2779 ASPFMTLINEAR16 = 0, /* 0x8 */
2780 ASPFMTLINEAR8, /* 0x1 */
2781 ASPFMTULAW, /* 0x2 */
2782 ASPFMTALAW, /* 0x3 */
2783 ASPFMTSPORT, /* ? */
2784 ASPFMTSPDIF, /* ? */
2785 } ASPENCODING;
2786
2787 static int
2788 vortex_translateformat(vortex_t * vortex, char bits, char nch, int encod)
2789 {
2790 int a, this_194;
2791
2792 if ((bits != 8) || (bits != 16))
2793 return -1;
2794
2795 switch (encod) {
2796 case 0:
2797 if (bits == 0x10)
2798 a = 8; // 16 bit
2799 break;
2800 case 1:
2801 if (bits == 8)
2802 a = 1; // 8 bit
2803 break;
2804 case 2:
2805 a = 2; // U_LAW
2806 break;
2807 case 3:
2808 a = 3; // A_LAW
2809 break;
2810 }
2811 switch (nch) {
2812 case 1:
2813 this_194 = 0;
2814 break;
2815 case 2:
2816 this_194 = 1;
2817 break;
2818 case 4:
2819 this_194 = 1;
2820 break;
2821 case 6:
2822 this_194 = 1;
2823 break;
2824 }
2825 return (a);
2826 }
2827
2828 static void vortex_cdmacore_setformat(vortex_t * vortex, int bits, int nch)
2829 {
2830 short int d, this_148;
2831
2832 d = ((bits >> 3) * nch);
2833 this_148 = 0xbb80 / d;
2834 }
2835 #endif
Linux with added FPC-III support