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