linux/sound/pci/au88x0/au88x0_a3d.c
<<
>>
Prefs
   1/***************************************************************************
   2 *            au88x0_a3d.c
   3 *
   4 *  Fri Jul 18 14:16:22 2003
   5 *  Copyright  2003  mjander
   6 *  mjander@users.sourceforge.net
   7 *
   8 * A3D. You may think i'm crazy, but this may work someday. Who knows...
   9 ****************************************************************************/
  10
  11/*
  12 *  This program is free software; you can redistribute it and/or modify
  13 *  it under the terms of the GNU General Public License as published by
  14 *  the Free Software Foundation; either version 2 of the License, or
  15 *  (at your option) any later version.
  16 *
  17 *  This program is distributed in the hope that it will be useful,
  18 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 *  GNU Library General Public License for more details.
  21 *
  22 *  You should have received a copy of the GNU General Public License
  23 *  along with this program; if not, write to the Free Software
  24 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  25 */
  26
  27#include "au88x0_a3d.h"
  28#include "au88x0_a3ddata.c"
  29#include "au88x0_xtalk.h"
  30#include "au88x0.h"
  31
  32static void
  33a3dsrc_SetTimeConsts(a3dsrc_t * a, short HrtfTrack, short ItdTrack,
  34                     short GTrack, short CTrack)
  35{
  36        vortex_t *vortex = (vortex_t *) (a->vortex);
  37        hwwrite(vortex->mmio,
  38                a3d_addrA(a->slice, a->source, A3D_A_HrtfTrackTC), HrtfTrack);
  39        hwwrite(vortex->mmio,
  40                a3d_addrA(a->slice, a->source, A3D_A_ITDTrackTC), ItdTrack);
  41        hwwrite(vortex->mmio,
  42                a3d_addrA(a->slice, a->source, A3D_A_GainTrackTC), GTrack);
  43        hwwrite(vortex->mmio,
  44                a3d_addrA(a->slice, a->source, A3D_A_CoeffTrackTC), CTrack);
  45}
  46
  47#if 0
  48static void
  49a3dsrc_GetTimeConsts(a3dsrc_t * a, short *HrtfTrack, short *ItdTrack,
  50                     short *GTrack, short *CTrack)
  51{
  52        // stub!
  53}
  54
  55#endif
  56/* Atmospheric absorption. */
  57
  58static void
  59a3dsrc_SetAtmosTarget(a3dsrc_t * a, short aa, short b, short c, short d,
  60                      short e)
  61{
  62        vortex_t *vortex = (vortex_t *) (a->vortex);
  63        hwwrite(vortex->mmio,
  64                a3d_addrB(a->slice, a->source, A3D_B_A21Target),
  65                (e << 0x10) | d);
  66        hwwrite(vortex->mmio,
  67                a3d_addrB(a->slice, a->source, A3D_B_B10Target),
  68                (b << 0x10) | aa);
  69        hwwrite(vortex->mmio,
  70                a3d_addrB(a->slice, a->source, A3D_B_B2Target), c);
  71}
  72
  73static void
  74a3dsrc_SetAtmosCurrent(a3dsrc_t * a, short aa, short b, short c, short d,
  75                       short e)
  76{
  77        vortex_t *vortex = (vortex_t *) (a->vortex);
  78        hwwrite(vortex->mmio,
  79                a3d_addrB(a->slice, a->source, A3D_B_A12Current),
  80                (e << 0x10) | d);
  81        hwwrite(vortex->mmio,
  82                a3d_addrB(a->slice, a->source, A3D_B_B01Current),
  83                (b << 0x10) | aa);
  84        hwwrite(vortex->mmio,
  85                a3d_addrB(a->slice, a->source, A3D_B_B2Current), c);
  86}
  87
  88static void
  89a3dsrc_SetAtmosState(a3dsrc_t * a, short x1, short x2, short y1, short y2)
  90{
  91        vortex_t *vortex = (vortex_t *) (a->vortex);
  92        hwwrite(vortex->mmio, a3d_addrA(a->slice, a->source, A3D_A_x1), x1);
  93        hwwrite(vortex->mmio, a3d_addrA(a->slice, a->source, A3D_A_x2), x2);
  94        hwwrite(vortex->mmio, a3d_addrA(a->slice, a->source, A3D_A_y1), y1);
  95        hwwrite(vortex->mmio, a3d_addrA(a->slice, a->source, A3D_A_y2), y2);
  96}
  97
  98#if 0
  99static void
 100a3dsrc_GetAtmosTarget(a3dsrc_t * a, short *aa, short *b, short *c,
 101                      short *d, short *e)
 102{
 103}
 104static void
 105a3dsrc_GetAtmosCurrent(a3dsrc_t * a, short *bb01, short *ab01, short *b2,
 106                       short *aa12, short *ba12)
 107{
 108        vortex_t *vortex = (vortex_t *) (a->vortex);
 109        *aa12 =
 110            hwread(vortex->mmio,
 111                   a3d_addrA(a->slice, a->source, A3D_A_A12Current));
 112        *ba12 =
 113            hwread(vortex->mmio,
 114                   a3d_addrB(a->slice, a->source, A3D_B_A12Current));
 115        *ab01 =
 116            hwread(vortex->mmio,
 117                   a3d_addrA(a->slice, a->source, A3D_A_B01Current));
 118        *bb01 =
 119            hwread(vortex->mmio,
 120                   a3d_addrB(a->slice, a->source, A3D_B_B01Current));
 121        *b2 =
 122            hwread(vortex->mmio,
 123                   a3d_addrA(a->slice, a->source, A3D_A_B2Current));
 124}
 125
 126static void
 127a3dsrc_GetAtmosState(a3dsrc_t * a, short *x1, short *x2, short *y1, short *y2)
 128{
 129
 130}
 131
 132#endif
 133/* HRTF */
 134
 135static void
 136a3dsrc_SetHrtfTarget(a3dsrc_t * a, a3d_Hrtf_t const aa, a3d_Hrtf_t const b)
 137{
 138        vortex_t *vortex = (vortex_t *) (a->vortex);
 139        int i;
 140
 141        for (i = 0; i < HRTF_SZ; i++)
 142                hwwrite(vortex->mmio,
 143                        a3d_addrB(a->slice, a->source,
 144                                  A3D_B_HrtfTarget) + (i << 2),
 145                        (b[i] << 0x10) | aa[i]);
 146}
 147
 148static void
 149a3dsrc_SetHrtfCurrent(a3dsrc_t * a, a3d_Hrtf_t const aa, a3d_Hrtf_t const b)
 150{
 151        vortex_t *vortex = (vortex_t *) (a->vortex);
 152        int i;
 153
 154        for (i = 0; i < HRTF_SZ; i++)
 155                hwwrite(vortex->mmio,
 156                        a3d_addrB(a->slice, a->source,
 157                                  A3D_B_HrtfCurrent) + (i << 2),
 158                        (b[i] << 0x10) | aa[i]);
 159}
 160
 161static void
 162a3dsrc_SetHrtfState(a3dsrc_t * a, a3d_Hrtf_t const aa, a3d_Hrtf_t const b)
 163{
 164        vortex_t *vortex = (vortex_t *) (a->vortex);
 165        int i;
 166
 167        for (i = 0; i < HRTF_SZ; i++)
 168                hwwrite(vortex->mmio,
 169                        a3d_addrB(a->slice, a->source,
 170                                  A3D_B_HrtfDelayLine) + (i << 2),
 171                        (b[i] << 0x10) | aa[i]);
 172}
 173
 174static void a3dsrc_SetHrtfOutput(a3dsrc_t * a, short left, short right)
 175{
 176        vortex_t *vortex = (vortex_t *) (a->vortex);
 177        hwwrite(vortex->mmio,
 178                a3d_addrA(a->slice, a->source, A3D_A_HrtfOutL), left);
 179        hwwrite(vortex->mmio,
 180                a3d_addrA(a->slice, a->source, A3D_A_HrtfOutR), right);
 181}
 182
 183#if 0
 184static void a3dsrc_GetHrtfTarget(a3dsrc_t * a, a3d_Hrtf_t aa, a3d_Hrtf_t b)
 185{
 186        vortex_t *vortex = (vortex_t *) (a->vortex);
 187        int i;
 188
 189        for (i = 0; i < HRTF_SZ; i++)
 190                aa[i] =
 191                    hwread(vortex->mmio,
 192                           a3d_addrA(a->slice, a->source,
 193                                     A3D_A_HrtfTarget + (i << 2)));
 194        for (i = 0; i < HRTF_SZ; i++)
 195                b[i] =
 196                    hwread(vortex->mmio,
 197                           a3d_addrB(a->slice, a->source,
 198                                     A3D_B_HrtfTarget + (i << 2)));
 199}
 200
 201static void a3dsrc_GetHrtfCurrent(a3dsrc_t * a, a3d_Hrtf_t aa, a3d_Hrtf_t b)
 202{
 203        vortex_t *vortex = (vortex_t *) (a->vortex);
 204        int i;
 205
 206        for (i = 0; i < HRTF_SZ; i++)
 207                aa[i] =
 208                    hwread(vortex->mmio,
 209                           a3d_addrA(a->slice, a->source,
 210                                     A3D_A_HrtfCurrent + (i << 2)));
 211        for (i = 0; i < HRTF_SZ; i++)
 212                b[i] =
 213                    hwread(vortex->mmio,
 214                           a3d_addrB(a->slice, a->source,
 215                                     A3D_B_HrtfCurrent + (i << 2)));
 216}
 217
 218static void a3dsrc_GetHrtfState(a3dsrc_t * a, a3d_Hrtf_t aa, a3d_Hrtf_t b)
 219{
 220        vortex_t *vortex = (vortex_t *) (a->vortex);
 221        int i;
 222        // FIXME: verify this!
 223        for (i = 0; i < HRTF_SZ; i++)
 224                aa[i] =
 225                    hwread(vortex->mmio,
 226                           a3d_addrA(a->slice, a->source,
 227                                     A3D_A_HrtfDelayLine + (i << 2)));
 228        for (i = 0; i < HRTF_SZ; i++)
 229                b[i] =
 230                    hwread(vortex->mmio,
 231                           a3d_addrB(a->slice, a->source,
 232                                     A3D_B_HrtfDelayLine + (i << 2)));
 233}
 234
 235static void a3dsrc_GetHrtfOutput(a3dsrc_t * a, short *left, short *right)
 236{
 237        vortex_t *vortex = (vortex_t *) (a->vortex);
 238        *left =
 239            hwread(vortex->mmio,
 240                   a3d_addrA(a->slice, a->source, A3D_A_HrtfOutL));
 241        *right =
 242            hwread(vortex->mmio,
 243                   a3d_addrA(a->slice, a->source, A3D_A_HrtfOutR));
 244}
 245
 246#endif
 247
 248/* Interaural Time Difference. 
 249 * "The other main clue that humans use to locate sounds, is called 
 250 * Interaural Time Difference (ITD). The differences in distance from 
 251 * the sound source to a listeners ears means  that the sound will 
 252 * reach one ear slightly before the other....", found somewhere with google.*/
 253static void a3dsrc_SetItdTarget(a3dsrc_t * a, short litd, short ritd)
 254{
 255        vortex_t *vortex = (vortex_t *) (a->vortex);
 256
 257        if (litd < 0)
 258                litd = 0;
 259        if (litd > 0x57FF)
 260                litd = 0x57FF;
 261        if (ritd < 0)
 262                ritd = 0;
 263        if (ritd > 0x57FF)
 264                ritd = 0x57FF;
 265        hwwrite(vortex->mmio,
 266                a3d_addrB(a->slice, a->source, A3D_B_ITDTarget),
 267                (ritd << 0x10) | litd);
 268        //hwwrite(vortex->mmio, addr(0x191DF+5, this04, this08), (ritd<<0x10)|litd);
 269}
 270
 271static void a3dsrc_SetItdCurrent(a3dsrc_t * a, short litd, short ritd)
 272{
 273        vortex_t *vortex = (vortex_t *) (a->vortex);
 274
 275        if (litd < 0)
 276                litd = 0;
 277        if (litd > 0x57FF)
 278                litd = 0x57FF;
 279        if (ritd < 0)
 280                ritd = 0;
 281        if (ritd > 0x57FF)
 282                ritd = 0x57FF;
 283        hwwrite(vortex->mmio,
 284                a3d_addrB(a->slice, a->source, A3D_B_ITDCurrent),
 285                (ritd << 0x10) | litd);
 286        //hwwrite(vortex->mmio, addr(0x191DF+1, this04, this08), (ritd<<0x10)|litd);
 287}
 288
 289static void a3dsrc_SetItdDline(a3dsrc_t * a, a3d_ItdDline_t const dline)
 290{
 291        vortex_t *vortex = (vortex_t *) (a->vortex);
 292        int i;
 293        /* 45 != 40 -> Check this ! */
 294        for (i = 0; i < DLINE_SZ; i++)
 295                hwwrite(vortex->mmio,
 296                        a3d_addrA(a->slice, a->source,
 297                                  A3D_A_ITDDelayLine) + (i << 2), dline[i]);
 298}
 299
 300#if 0
 301static void a3dsrc_GetItdTarget(a3dsrc_t * a, short *litd, short *ritd)
 302{
 303        vortex_t *vortex = (vortex_t *) (a->vortex);
 304        *ritd =
 305            hwread(vortex->mmio,
 306                   a3d_addrA(a->slice, a->source, A3D_A_ITDTarget));
 307        *litd =
 308            hwread(vortex->mmio,
 309                   a3d_addrB(a->slice, a->source, A3D_B_ITDTarget));
 310}
 311
 312static void a3dsrc_GetItdCurrent(a3dsrc_t * a, short *litd, short *ritd)
 313{
 314        vortex_t *vortex = (vortex_t *) (a->vortex);
 315
 316        *ritd =
 317            hwread(vortex->mmio,
 318                   a3d_addrA(a->slice, a->source, A3D_A_ITDCurrent));
 319        *litd =
 320            hwread(vortex->mmio,
 321                   a3d_addrB(a->slice, a->source, A3D_B_ITDCurrent));
 322}
 323
 324static void a3dsrc_GetItdDline(a3dsrc_t * a, a3d_ItdDline_t dline)
 325{
 326        vortex_t *vortex = (vortex_t *) (a->vortex);
 327        int i;
 328
 329        for (i = 0; i < DLINE_SZ; i++)
 330                dline[i] =
 331                    hwread(vortex->mmio,
 332                           a3d_addrA(a->slice, a->source,
 333                                     A3D_A_ITDDelayLine + (i << 2)));
 334}
 335
 336#endif
 337/* This is may be used for ILD Interaural Level Difference. */
 338
 339static void a3dsrc_SetGainTarget(a3dsrc_t * a, short left, short right)
 340{
 341        vortex_t *vortex = (vortex_t *) (a->vortex);
 342        hwwrite(vortex->mmio,
 343                a3d_addrB(a->slice, a->source, A3D_B_GainTarget),
 344                (right << 0x10) | left);
 345}
 346
 347static void a3dsrc_SetGainCurrent(a3dsrc_t * a, short left, short right)
 348{
 349        vortex_t *vortex = (vortex_t *) (a->vortex);
 350        hwwrite(vortex->mmio,
 351                a3d_addrB(a->slice, a->source, A3D_B_GainCurrent),
 352                (right << 0x10) | left);
 353}
 354
 355#if 0
 356static void a3dsrc_GetGainTarget(a3dsrc_t * a, short *left, short *right)
 357{
 358        vortex_t *vortex = (vortex_t *) (a->vortex);
 359        *right =
 360            hwread(vortex->mmio,
 361                   a3d_addrA(a->slice, a->source, A3D_A_GainTarget));
 362        *left =
 363            hwread(vortex->mmio,
 364                   a3d_addrB(a->slice, a->source, A3D_B_GainTarget));
 365}
 366
 367static void a3dsrc_GetGainCurrent(a3dsrc_t * a, short *left, short *right)
 368{
 369        vortex_t *vortex = (vortex_t *) (a->vortex);
 370        *right =
 371            hwread(vortex->mmio,
 372                   a3d_addrA(a->slice, a->source, A3D_A_GainCurrent));
 373        *left =
 374            hwread(vortex->mmio,
 375                   a3d_addrB(a->slice, a->source, A3D_B_GainCurrent));
 376}
 377
 378/* CA3dIO this func seems to be inlined all over this place. */
 379static void CA3dIO_WriteReg(a3dsrc_t * a, unsigned long addr, short aa, short b)
 380{
 381        vortex_t *vortex = (vortex_t *) (a->vortex);
 382        hwwrite(vortex->mmio, addr, (aa << 0x10) | b);
 383}
 384
 385#endif
 386/* Generic A3D stuff */
 387
 388static void a3dsrc_SetA3DSampleRate(a3dsrc_t * a, int sr)
 389{
 390        vortex_t *vortex = (vortex_t *) (a->vortex);
 391        int esp0 = 0;
 392
 393        esp0 = (((esp0 & 0x7fffffff) | 0xB8000000) & 0x7) | ((sr & 0x1f) << 3);
 394        hwwrite(vortex->mmio, A3D_SLICE_Control + ((a->slice) << 0xd), esp0);
 395        //hwwrite(vortex->mmio, 0x19C38 + (this08<<0xd), esp0);
 396}
 397
 398static void a3dsrc_EnableA3D(a3dsrc_t * a)
 399{
 400        vortex_t *vortex = (vortex_t *) (a->vortex);
 401        hwwrite(vortex->mmio, A3D_SLICE_Control + ((a->slice) << 0xd),
 402                0xF0000001);
 403        //hwwrite(vortex->mmio, 0x19C38 + (this08<<0xd), 0xF0000001);
 404}
 405
 406static void a3dsrc_DisableA3D(a3dsrc_t * a)
 407{
 408        vortex_t *vortex = (vortex_t *) (a->vortex);
 409        hwwrite(vortex->mmio, A3D_SLICE_Control + ((a->slice) << 0xd),
 410                0xF0000000);
 411}
 412
 413static void a3dsrc_SetA3DControlReg(a3dsrc_t * a, unsigned long ctrl)
 414{
 415        vortex_t *vortex = (vortex_t *) (a->vortex);
 416        hwwrite(vortex->mmio, A3D_SLICE_Control + ((a->slice) << 0xd), ctrl);
 417}
 418
 419static void a3dsrc_SetA3DPointerReg(a3dsrc_t * a, unsigned long ptr)
 420{
 421        vortex_t *vortex = (vortex_t *) (a->vortex);
 422        hwwrite(vortex->mmio, A3D_SLICE_Pointers + ((a->slice) << 0xd), ptr);
 423}
 424
 425#if 0
 426static void a3dsrc_GetA3DSampleRate(a3dsrc_t * a, int *sr)
 427{
 428        vortex_t *vortex = (vortex_t *) (a->vortex);
 429        *sr = ((hwread(vortex->mmio, A3D_SLICE_Control + (a->slice << 0xd))
 430                >> 3) & 0x1f);
 431        //*sr = ((hwread(vortex->mmio, 0x19C38 + (this08<<0xd))>>3)&0x1f);
 432}
 433
 434static void a3dsrc_GetA3DControlReg(a3dsrc_t * a, unsigned long *ctrl)
 435{
 436        vortex_t *vortex = (vortex_t *) (a->vortex);
 437        *ctrl = hwread(vortex->mmio, A3D_SLICE_Control + ((a->slice) << 0xd));
 438}
 439
 440static void a3dsrc_GetA3DPointerReg(a3dsrc_t * a, unsigned long *ptr)
 441{
 442        vortex_t *vortex = (vortex_t *) (a->vortex);
 443        *ptr = hwread(vortex->mmio, A3D_SLICE_Pointers + ((a->slice) << 0xd));
 444}
 445
 446#endif
 447static void a3dsrc_ZeroSliceIO(a3dsrc_t * a)
 448{
 449        vortex_t *vortex = (vortex_t *) (a->vortex);
 450        int i;
 451
 452        for (i = 0; i < 8; i++)
 453                hwwrite(vortex->mmio,
 454                        A3D_SLICE_VDBDest +
 455                        ((((a->slice) << 0xb) + i) << 2), 0);
 456        for (i = 0; i < 4; i++)
 457                hwwrite(vortex->mmio,
 458                        A3D_SLICE_VDBSource +
 459                        ((((a->slice) << 0xb) + i) << 2), 0);
 460}
 461
 462/* Reset Single A3D source. */
 463static void a3dsrc_ZeroState(a3dsrc_t * a)
 464{
 465        /*
 466        pr_debug( "vortex: ZeroState slice: %d, source %d\n",
 467               a->slice, a->source);
 468        */
 469        a3dsrc_SetAtmosState(a, 0, 0, 0, 0);
 470        a3dsrc_SetHrtfState(a, A3dHrirZeros, A3dHrirZeros);
 471        a3dsrc_SetItdDline(a, A3dItdDlineZeros);
 472        a3dsrc_SetHrtfOutput(a, 0, 0);
 473        a3dsrc_SetTimeConsts(a, 0, 0, 0, 0);
 474
 475        a3dsrc_SetAtmosCurrent(a, 0, 0, 0, 0, 0);
 476        a3dsrc_SetAtmosTarget(a, 0, 0, 0, 0, 0);
 477        a3dsrc_SetItdCurrent(a, 0, 0);
 478        a3dsrc_SetItdTarget(a, 0, 0);
 479        a3dsrc_SetGainCurrent(a, 0, 0);
 480        a3dsrc_SetGainTarget(a, 0, 0);
 481
 482        a3dsrc_SetHrtfCurrent(a, A3dHrirZeros, A3dHrirZeros);
 483        a3dsrc_SetHrtfTarget(a, A3dHrirZeros, A3dHrirZeros);
 484}
 485
 486/* Reset entire A3D engine */
 487static void a3dsrc_ZeroStateA3D(a3dsrc_t *a, vortex_t *v)
 488{
 489        int i, var, var2;
 490
 491        if ((a->vortex) == NULL) {
 492                dev_err(v->card->dev,
 493                        "ZeroStateA3D: ERROR: a->vortex is NULL\n");
 494                return;
 495        }
 496
 497        a3dsrc_SetA3DControlReg(a, 0);
 498        a3dsrc_SetA3DPointerReg(a, 0);
 499
 500        var = a->slice;
 501        var2 = a->source;
 502        for (i = 0; i < 4; i++) {
 503                a->slice = i;
 504                a3dsrc_ZeroSliceIO(a);
 505                //a3dsrc_ZeroState(a);
 506        }
 507        a->source = var2;
 508        a->slice = var;
 509}
 510
 511/* Program A3D block as pass through */
 512static void a3dsrc_ProgramPipe(a3dsrc_t * a)
 513{
 514        a3dsrc_SetTimeConsts(a, 0, 0, 0, 0);
 515        a3dsrc_SetAtmosCurrent(a, 0, 0x4000, 0, 0, 0);
 516        a3dsrc_SetAtmosTarget(a, 0x4000, 0, 0, 0, 0);
 517        a3dsrc_SetItdCurrent(a, 0, 0);
 518        a3dsrc_SetItdTarget(a, 0, 0);
 519        a3dsrc_SetGainCurrent(a, 0x7fff, 0x7fff);
 520        a3dsrc_SetGainTarget(a, 0x7fff, 0x7fff);
 521
 522        /* SET HRTF HERE */
 523
 524        /* Single spike leads to identity transfer function. */
 525        a3dsrc_SetHrtfCurrent(a, A3dHrirImpulse, A3dHrirImpulse);
 526        a3dsrc_SetHrtfTarget(a, A3dHrirImpulse, A3dHrirImpulse);
 527
 528        /* Test: Sounds saturated. */
 529        //a3dsrc_SetHrtfCurrent(a, A3dHrirSatTest, A3dHrirSatTest);
 530        //a3dsrc_SetHrtfTarget(a, A3dHrirSatTest, A3dHrirSatTest);      
 531}
 532
 533/* VDB = Vortex audio Dataflow Bus */
 534#if 0
 535static void a3dsrc_ClearVDBData(a3dsrc_t * a, unsigned long aa)
 536{
 537        vortex_t *vortex = (vortex_t *) (a->vortex);
 538
 539        // ((aa >> 2) << 8) - (aa >> 2)
 540        hwwrite(vortex->mmio,
 541                a3d_addrS(a->slice, A3D_SLICE_VDBDest) + (a->source << 2), 0);
 542        hwwrite(vortex->mmio,
 543                a3d_addrS(a->slice,
 544                          A3D_SLICE_VDBDest + 4) + (a->source << 2), 0);
 545        /*
 546           hwwrite(vortex->mmio, 0x19c00 + (((aa>>2)*255*4)+aa)*8, 0);
 547           hwwrite(vortex->mmio, 0x19c04 + (((aa>>2)*255*4)+aa)*8, 0);
 548         */
 549}
 550#endif
 551
 552/* A3D HwSource stuff. */
 553
 554static void vortex_A3dSourceHw_Initialize(vortex_t * v, int source, int slice)
 555{
 556        a3dsrc_t *a3dsrc = &(v->a3d[source + (slice * 4)]);
 557        //a3dsrc_t *a3dsrc = &(v->a3d[source + (slice*4)]);
 558
 559        a3dsrc->vortex = (void *)v;
 560        a3dsrc->source = source;        /* source */
 561        a3dsrc->slice = slice;  /* slice */
 562        a3dsrc_ZeroState(a3dsrc);
 563        /* Added by me. */
 564        a3dsrc_SetA3DSampleRate(a3dsrc, 0x11);
 565}
 566
 567static int Vort3DRend_Initialize(vortex_t * v, unsigned short mode)
 568{
 569        v->xt_mode = mode;      /* this_14 */
 570
 571        vortex_XtalkHw_init(v);
 572        vortex_XtalkHw_SetGainsAllChan(v);
 573        switch (v->xt_mode) {
 574        case XT_SPEAKER0:
 575                vortex_XtalkHw_ProgramXtalkNarrow(v);
 576                break;
 577        case XT_SPEAKER1:
 578                vortex_XtalkHw_ProgramXtalkWide(v);
 579                break;
 580        default:
 581        case XT_HEADPHONE:
 582                vortex_XtalkHw_ProgramPipe(v);
 583                break;
 584        case XT_DIAMOND:
 585                vortex_XtalkHw_ProgramDiamondXtalk(v);
 586                break;
 587        }
 588        vortex_XtalkHw_SetSampleRate(v, 0x11);
 589        vortex_XtalkHw_Enable(v);
 590        return 0;
 591}
 592
 593/* 3D Sound entry points. */
 594
 595static int vortex_a3d_register_controls(vortex_t * vortex);
 596static void vortex_a3d_unregister_controls(vortex_t * vortex);
 597/* A3D base support init/shudown */
 598static void vortex_Vort3D_enable(vortex_t *v)
 599{
 600        int i;
 601
 602        Vort3DRend_Initialize(v, XT_HEADPHONE);
 603        for (i = 0; i < NR_A3D; i++) {
 604                vortex_A3dSourceHw_Initialize(v, i % 4, i >> 2);
 605                a3dsrc_ZeroStateA3D(&v->a3d[0], v);
 606        }
 607        /* Register ALSA controls */
 608        vortex_a3d_register_controls(v);
 609}
 610
 611static void vortex_Vort3D_disable(vortex_t * v)
 612{
 613        vortex_XtalkHw_Disable(v);
 614        vortex_a3d_unregister_controls(v);
 615}
 616
 617/* Make A3D subsystem connections. */
 618static void vortex_Vort3D_connect(vortex_t * v, int en)
 619{
 620        int i;
 621        
 622// Disable AU8810 routes, since they seem to be wrong (in au8810.h).
 623#ifdef CHIP_AU8810
 624        return;
 625#endif
 626        
 627#if 1
 628        /* Alloc Xtalk mixin resources */
 629        v->mixxtlk[0] =
 630            vortex_adb_checkinout(v, v->fixed_res, en, VORTEX_RESOURCE_MIXIN);
 631        if (v->mixxtlk[0] < 0) {
 632                dev_warn(v->card->dev,
 633                         "vortex_Vort3D: ERROR: not enough free mixer resources.\n");
 634                return;
 635        }
 636        v->mixxtlk[1] =
 637            vortex_adb_checkinout(v, v->fixed_res, en, VORTEX_RESOURCE_MIXIN);
 638        if (v->mixxtlk[1] < 0) {
 639                dev_warn(v->card->dev,
 640                         "vortex_Vort3D: ERROR: not enough free mixer resources.\n");
 641                return;
 642        }
 643#endif
 644
 645        /* Connect A3D -> XTALK */
 646        for (i = 0; i < 4; i++) {
 647                // 2 outputs per each A3D slice. 
 648                vortex_route(v, en, 0x11, ADB_A3DOUT(i * 2), ADB_XTALKIN(i));
 649                vortex_route(v, en, 0x11, ADB_A3DOUT(i * 2) + 1, ADB_XTALKIN(5 + i));
 650        }
 651#if 0
 652        vortex_route(v, en, 0x11, ADB_XTALKOUT(0), ADB_EQIN(2));
 653        vortex_route(v, en, 0x11, ADB_XTALKOUT(1), ADB_EQIN(3));
 654#else
 655        /* Connect XTalk -> mixer */
 656        vortex_route(v, en, 0x11, ADB_XTALKOUT(0), ADB_MIXIN(v->mixxtlk[0]));
 657        vortex_route(v, en, 0x11, ADB_XTALKOUT(1), ADB_MIXIN(v->mixxtlk[1]));
 658        vortex_connection_mixin_mix(v, en, v->mixxtlk[0], v->mixplayb[0], 0);
 659        vortex_connection_mixin_mix(v, en, v->mixxtlk[1], v->mixplayb[1], 0);
 660        vortex_mix_setinputvolumebyte(v, v->mixplayb[0], v->mixxtlk[0],
 661                                      en ? MIX_DEFIGAIN : VOL_MIN);
 662        vortex_mix_setinputvolumebyte(v, v->mixplayb[1], v->mixxtlk[1],
 663                                      en ? MIX_DEFIGAIN : VOL_MIN);
 664        if (VORTEX_IS_QUAD(v)) {
 665                vortex_connection_mixin_mix(v, en, v->mixxtlk[0],
 666                                            v->mixplayb[2], 0);
 667                vortex_connection_mixin_mix(v, en, v->mixxtlk[1],
 668                                            v->mixplayb[3], 0);
 669                vortex_mix_setinputvolumebyte(v, v->mixplayb[2],
 670                                              v->mixxtlk[0],
 671                                              en ? MIX_DEFIGAIN : VOL_MIN);
 672                vortex_mix_setinputvolumebyte(v, v->mixplayb[3],
 673                                              v->mixxtlk[1],
 674                                              en ? MIX_DEFIGAIN : VOL_MIN);
 675        }
 676#endif
 677}
 678
 679/* Initialize one single A3D source. */
 680static void vortex_Vort3D_InitializeSource(a3dsrc_t *a, int en, vortex_t *v)
 681{
 682        if (a->vortex == NULL) {
 683                dev_warn(v->card->dev,
 684                         "Vort3D_InitializeSource: A3D source not initialized\n");
 685                return;
 686        }
 687        if (en) {
 688                a3dsrc_ProgramPipe(a);
 689                a3dsrc_SetA3DSampleRate(a, 0x11);
 690                a3dsrc_SetTimeConsts(a, HrtfTCDefault,
 691                                     ItdTCDefault, GainTCDefault,
 692                                     CoefTCDefault);
 693                /* Remark: zero gain is muted. */
 694                //a3dsrc_SetGainTarget(a,0,0);
 695                //a3dsrc_SetGainCurrent(a,0,0);
 696                a3dsrc_EnableA3D(a);
 697        } else {
 698                a3dsrc_DisableA3D(a);
 699                a3dsrc_ZeroState(a);
 700        }
 701}
 702
 703/* Conversion of coordinates into 3D parameters. */
 704
 705static void vortex_a3d_coord2hrtf(a3d_Hrtf_t hrtf, int *coord)
 706{
 707        /* FIXME: implement this. */
 708
 709}
 710static void vortex_a3d_coord2itd(a3d_Itd_t itd, int *coord)
 711{
 712        /* FIXME: implement this. */
 713
 714}
 715static void vortex_a3d_coord2ild(a3d_LRGains_t ild, int left, int right)
 716{
 717        /* FIXME: implement this. */
 718
 719}
 720static void vortex_a3d_translate_filter(a3d_atmos_t filter, int *params)
 721{
 722        /* FIXME: implement this. */
 723
 724}
 725
 726/* ALSA control interface.  */
 727
 728static int
 729snd_vortex_a3d_hrtf_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 730{
 731        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 732        uinfo->count = 6;
 733        uinfo->value.integer.min = 0x00000000;
 734        uinfo->value.integer.max = 0xffffffff;
 735        return 0;
 736}
 737static int
 738snd_vortex_a3d_itd_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 739{
 740        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 741        uinfo->count = 2;
 742        uinfo->value.integer.min = 0x00000000;
 743        uinfo->value.integer.max = 0xffffffff;
 744        return 0;
 745}
 746static int
 747snd_vortex_a3d_ild_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 748{
 749        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 750        uinfo->count = 2;
 751        uinfo->value.integer.min = 0x00000000;
 752        uinfo->value.integer.max = 0xffffffff;
 753        return 0;
 754}
 755static int
 756snd_vortex_a3d_filter_info(struct snd_kcontrol *kcontrol,
 757                           struct snd_ctl_elem_info *uinfo)
 758{
 759        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 760        uinfo->count = 4;
 761        uinfo->value.integer.min = 0x00000000;
 762        uinfo->value.integer.max = 0xffffffff;
 763        return 0;
 764}
 765
 766static int
 767snd_vortex_a3d_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 768{
 769        //a3dsrc_t *a = kcontrol->private_data;
 770        /* No read yet. Would this be really useable/needed ? */
 771
 772        return 0;
 773}
 774
 775static int
 776snd_vortex_a3d_hrtf_put(struct snd_kcontrol *kcontrol,
 777                        struct snd_ctl_elem_value *ucontrol)
 778{
 779        a3dsrc_t *a = kcontrol->private_data;
 780        int changed = 1, i;
 781        int coord[6];
 782        for (i = 0; i < 6; i++)
 783                coord[i] = ucontrol->value.integer.value[i];
 784        /* Translate orientation coordinates to a3d params. */
 785        vortex_a3d_coord2hrtf(a->hrtf[0], coord);
 786        vortex_a3d_coord2hrtf(a->hrtf[1], coord);
 787        a3dsrc_SetHrtfTarget(a, a->hrtf[0], a->hrtf[1]);
 788        a3dsrc_SetHrtfCurrent(a, a->hrtf[0], a->hrtf[1]);
 789        return changed;
 790}
 791
 792static int
 793snd_vortex_a3d_itd_put(struct snd_kcontrol *kcontrol,
 794                       struct snd_ctl_elem_value *ucontrol)
 795{
 796        a3dsrc_t *a = kcontrol->private_data;
 797        int coord[6];
 798        int i, changed = 1;
 799        for (i = 0; i < 6; i++)
 800                coord[i] = ucontrol->value.integer.value[i];
 801        /* Translate orientation coordinates to a3d params. */
 802        vortex_a3d_coord2itd(a->hrtf[0], coord);
 803        vortex_a3d_coord2itd(a->hrtf[1], coord);
 804        /* Inter aural time difference. */
 805        a3dsrc_SetItdTarget(a, a->itd[0], a->itd[1]);
 806        a3dsrc_SetItdCurrent(a, a->itd[0], a->itd[1]);
 807        a3dsrc_SetItdDline(a, a->dline);
 808        return changed;
 809}
 810
 811static int
 812snd_vortex_a3d_ild_put(struct snd_kcontrol *kcontrol,
 813                       struct snd_ctl_elem_value *ucontrol)
 814{
 815        a3dsrc_t *a = kcontrol->private_data;
 816        int changed = 1;
 817        int l, r;
 818        /* There may be some scale tranlation needed here. */
 819        l = ucontrol->value.integer.value[0];
 820        r = ucontrol->value.integer.value[1];
 821        vortex_a3d_coord2ild(a->ild, l, r);
 822        /* Left Right panning. */
 823        a3dsrc_SetGainTarget(a, l, r);
 824        a3dsrc_SetGainCurrent(a, l, r);
 825        return changed;
 826}
 827
 828static int
 829snd_vortex_a3d_filter_put(struct snd_kcontrol *kcontrol,
 830                          struct snd_ctl_elem_value *ucontrol)
 831{
 832        a3dsrc_t *a = kcontrol->private_data;
 833        int i, changed = 1;
 834        int params[6];
 835        for (i = 0; i < 6; i++)
 836                params[i] = ucontrol->value.integer.value[i];
 837        /* Translate generic filter params to a3d filter params. */
 838        vortex_a3d_translate_filter(a->filter, params);
 839        /* Atmospheric absorption and filtering. */
 840        a3dsrc_SetAtmosTarget(a, a->filter[0],
 841                              a->filter[1], a->filter[2],
 842                              a->filter[3], a->filter[4]);
 843        a3dsrc_SetAtmosCurrent(a, a->filter[0],
 844                               a->filter[1], a->filter[2],
 845                               a->filter[3], a->filter[4]);
 846        return changed;
 847}
 848
 849static const struct snd_kcontrol_new vortex_a3d_kcontrol = {
 850        .iface = SNDRV_CTL_ELEM_IFACE_PCM,
 851        .name = "Playback PCM advanced processing",
 852        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 853        .info = snd_vortex_a3d_hrtf_info,
 854        .get = snd_vortex_a3d_get,
 855        .put = snd_vortex_a3d_hrtf_put,
 856};
 857
 858/* Control (un)registration. */
 859static int vortex_a3d_register_controls(vortex_t *vortex)
 860{
 861        struct snd_kcontrol *kcontrol;
 862        int err, i;
 863        /* HRTF controls. */
 864        for (i = 0; i < NR_A3D; i++) {
 865                if ((kcontrol =
 866                     snd_ctl_new1(&vortex_a3d_kcontrol, &vortex->a3d[i])) == NULL)
 867                        return -ENOMEM;
 868                kcontrol->id.numid = CTRLID_HRTF;
 869                kcontrol->info = snd_vortex_a3d_hrtf_info;
 870                kcontrol->put = snd_vortex_a3d_hrtf_put;
 871                if ((err = snd_ctl_add(vortex->card, kcontrol)) < 0)
 872                        return err;
 873        }
 874        /* ITD controls. */
 875        for (i = 0; i < NR_A3D; i++) {
 876                if ((kcontrol =
 877                     snd_ctl_new1(&vortex_a3d_kcontrol, &vortex->a3d[i])) == NULL)
 878                        return -ENOMEM;
 879                kcontrol->id.numid = CTRLID_ITD;
 880                kcontrol->info = snd_vortex_a3d_itd_info;
 881                kcontrol->put = snd_vortex_a3d_itd_put;
 882                if ((err = snd_ctl_add(vortex->card, kcontrol)) < 0)
 883                        return err;
 884        }
 885        /* ILD (gains) controls. */
 886        for (i = 0; i < NR_A3D; i++) {
 887                if ((kcontrol =
 888                     snd_ctl_new1(&vortex_a3d_kcontrol, &vortex->a3d[i])) == NULL)
 889                        return -ENOMEM;
 890                kcontrol->id.numid = CTRLID_GAINS;
 891                kcontrol->info = snd_vortex_a3d_ild_info;
 892                kcontrol->put = snd_vortex_a3d_ild_put;
 893                if ((err = snd_ctl_add(vortex->card, kcontrol)) < 0)
 894                        return err;
 895        }
 896        /* Filter controls. */
 897        for (i = 0; i < NR_A3D; i++) {
 898                if ((kcontrol =
 899                     snd_ctl_new1(&vortex_a3d_kcontrol, &vortex->a3d[i])) == NULL)
 900                        return -ENOMEM;
 901                kcontrol->id.numid = CTRLID_FILTER;
 902                kcontrol->info = snd_vortex_a3d_filter_info;
 903                kcontrol->put = snd_vortex_a3d_filter_put;
 904                if ((err = snd_ctl_add(vortex->card, kcontrol)) < 0)
 905                        return err;
 906        }
 907        return 0;
 908}
 909
 910static void vortex_a3d_unregister_controls(vortex_t * vortex)
 911{
 912
 913}
 914
 915/* End of File*/
 916