sound/pci/au88x0/au88x0_xtalk.c

   1 /***************************************************************************
   2  *            au88x0_cxtalk.c
   3  *
   4  *  Wed Nov 19 16:29:47 2003
   5  *  Copyright  2003  mjander
   6  *  mjander@users.sourceforge.org
   7  ****************************************************************************/
   8
   9 /*
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU Library General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23  */
  24
  25 #include "au88x0_xtalk.h"
  26
  27 /* Data (a whole lot of data.... ) */
  28
  29 static short const sXtalkWideKLeftEq = 0x269C;
  30 static short const sXtalkWideKRightEq = 0x269C;
  31 static short const sXtalkWideKLeftXt = 0xF25E;
  32 static short const sXtalkWideKRightXt = 0xF25E;
  33 static short const sXtalkWideShiftLeftEq = 1;
  34 static short const sXtalkWideShiftRightEq = 1;
  35 static short const sXtalkWideShiftLeftXt = 0;
  36 static short const sXtalkWideShiftRightXt = 0;
  37 static unsigned short const wXtalkWideLeftDelay = 0xd;
  38 static unsigned short const wXtalkWideRightDelay = 0xd;
  39 static short const sXtalkNarrowKLeftEq = 0x468D;
  40 static short const sXtalkNarrowKRightEq = 0x468D;
  41 static short const sXtalkNarrowKLeftXt = 0xF82E;
  42 static short const sXtalkNarrowKRightXt = 0xF82E;
  43 static short const sXtalkNarrowShiftLeftEq = 0x3;
  44 static short const sXtalkNarrowShiftRightEq = 0x3;
  45 static short const sXtalkNarrowShiftLeftXt = 0;
  46 static short const sXtalkNarrowShiftRightXt = 0;
  47 static unsigned short const wXtalkNarrowLeftDelay = 0x7;
  48 static unsigned short const wXtalkNarrowRightDelay = 0x7;
  49
  50 static xtalk_gains_t const asXtalkGainsDefault = {
  51         0x4000, 0x4000, 4000, 0x4000, 4000, 0x4000, 4000, 0x4000, 4000,
  52         0x4000
  53 };
  54
  55 static xtalk_gains_t const asXtalkGainsTest = {
  56         0x8000, 0x7FFF, 0, 0xFFFF, 0x0001, 0xC000, 0x4000, 0xFFFE, 0x0002,
  57         0
  58 };
  59 static xtalk_gains_t const asXtalkGains1Chan = {
  60         0x7FFF, 0, 0, 0, 0x7FFF, 0, 0, 0, 0, 0
  61 };
  62
  63 // Input gain for 4 A3D slices. One possible input pair is left zero.
  64 static xtalk_gains_t const asXtalkGainsAllChan = {
  65         0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF,
  66         0
  67             //0x7FFF,0x7FFF,0x7FFF,0x7FFF,0x7fff,0x7FFF,0x7FFF,0x7FFF,0x7FFF,0x7fff
  68 };
  69 static xtalk_gains_t const asXtalkGainsZeros = {
  70         0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  71 };
  72
  73 static xtalk_dline_t const alXtalkDlineZeros = {
  74         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  75         0, 0, 0,
  76         0, 0, 0, 0, 0, 0, 0
  77 };
  78 static xtalk_dline_t const alXtalkDlineTest = {
  79         0xFC18, 0x03E8FFFF, 0x186A0, 0x7960FFFE, 1, 0xFFFFFFFF,
  80         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  81         0, 0, 0, 0
  82 };
  83
  84 static xtalk_instate_t const asXtalkInStateZeros = { 0, 0, 0, 0 };
  85 static xtalk_instate_t const asXtalkInStateTest =
  86     { 0xFF80, 0x0080, 0xFFFF, 0x0001 };
  87 static xtalk_state_t const asXtalkOutStateZeros = {
  88         {0, 0, 0, 0},
  89         {0, 0, 0, 0},
  90         {0, 0, 0, 0},
  91         {0, 0, 0, 0},
  92         {0, 0, 0, 0}
  93 };
  94 static short const sDiamondKLeftEq = 0x401d;
  95 static short const sDiamondKRightEq = 0x401d;
  96 static short const sDiamondKLeftXt = 0xF90E;
  97 static short const sDiamondKRightXt = 0xF90E;
  98 static short const sDiamondShiftLeftEq = 1;     /* 0xF90E Is this a bug ??? */
  99 static short const sDiamondShiftRightEq = 1;
 100 static short const sDiamondShiftLeftXt = 0;
 101 static short const sDiamondShiftRightXt = 0;
 102 static unsigned short const wDiamondLeftDelay = 0xb;
 103 static unsigned short const wDiamondRightDelay = 0xb;
 104
 105 static xtalk_coefs_t const asXtalkWideCoefsLeftEq = {
 106         {0xEC4C, 0xDCE9, 0xFDC2, 0xFEEC, 0},
 107         {0x5F60, 0xCBCB, 0xFC26, 0x0305, 0},
 108         {0x340B, 0xf504, 0x6CE8, 0x0D23, 0x00E4},
 109         {0xD500, 0x8D76, 0xACC7, 0x5B05, 0x00FA},
 110         {0x7F04, 0xC0FA, 0x0263, 0xFDA2, 0}
 111 };
 112 static xtalk_coefs_t const asXtalkWideCoefsRightEq = {
 113         {0xEC4C, 0xDCE9, 0xFDC2, 0xFEEC, 0},
 114         {0x5F60, 0xCBCB, 0xFC26, 0x0305, 0},
 115         {0x340B, 0xF504, 0x6CE8, 0x0D23, 0x00E4},
 116         {0xD500, 0x8D76, 0xACC7, 0x5B05, 0x00FA},
 117         {0x7F04, 0xC0FA, 0x0263, 0xFDA2, 0}
 118 };
 119 static xtalk_coefs_t const asXtalkWideCoefsLeftXt = {
 120         {0x86C3, 0x7B55, 0x89C3, 0x005B, 0x0047},
 121         {0x6000, 0x206A, 0xC6CA, 0x40FF, 0},
 122         {0x1100, 0x1164, 0xA1D7, 0x90FC, 0x0001},
 123         {0xDC00, 0x9E77, 0xB8C7, 0x0AFF, 0},
 124         {0, 0, 0, 0, 0}
 125 };
 126 static xtalk_coefs_t const asXtalkWideCoefsRightXt = {
 127         {0x86C3, 0x7B55, 0x89C3, 0x005B, 0x0047},
 128         {0x6000, 0x206A, 0xC6CA, 0x40FF, 0},
 129         {0x1100, 0x1164, 0xA1D7, 0x90FC, 0x0001},
 130         {0xDC00, 0x9E77, 0xB8C7, 0x0AFF, 0},
 131         {0, 0, 0, 0, 0}
 132 };
 133 static xtalk_coefs_t const asXtalkNarrowCoefsLeftEq = {
 134         {0x50B5, 0xD07C, 0x026D, 0xFD21, 0},
 135         {0x460F, 0xE44F, 0xF75E, 0xEFA6, 0},
 136         {0x556D, 0xDCAB, 0x2098, 0xF0F2, 0},
 137         {0x7E03, 0xC1F0, 0x007D, 0xFF89, 0},
 138         {0x383E, 0xFD9D, 0xB278, 0x4547, 0}
 139 };
 140
 141 static xtalk_coefs_t const asXtalkNarrowCoefsRightEq = {
 142         {0x50B5, 0xD07C, 0x026D, 0xFD21, 0},
 143         {0x460F, 0xE44F, 0xF75E, 0xEFA6, 0},
 144         {0x556D, 0xDCAB, 0x2098, 0xF0F2, 0},
 145         {0x7E03, 0xC1F0, 0x007D, 0xFF89, 0},
 146         {0x383E, 0xFD9D, 0xB278, 0x4547, 0}
 147 };
 148
 149 static xtalk_coefs_t const asXtalkNarrowCoefsLeftXt = {
 150         {0x3CB2, 0xDF49, 0xF6EA, 0x095B, 0},
 151         {0x6777, 0xC915, 0xFEAF, 0x00B1, 0},
 152         {0x7762, 0xC7D9, 0x025B, 0xFDA6, 0},
 153         {0x6B7A, 0xD2AA, 0xF2FB, 0x0B64, 0},
 154         {0, 0, 0, 0, 0}
 155 };
 156
 157 static xtalk_coefs_t const asXtalkNarrowCoefsRightXt = {
 158         {0x3CB2, 0xDF49, 0xF6EA, 0x095B, 0},
 159         {0x6777, 0xC915, 0xFEAF, 0x00B1, 0},
 160         {0x7762, 0xC7D9, 0x025B, 0xFDA6, 0},
 161         {0x6B7A, 0xD2AA, 0xF2FB, 0x0B64, 0},
 162         {0, 0, 0, 0, 0}
 163 };
 164
 165 static xtalk_coefs_t const asXtalkCoefsZeros = {
 166         {0, 0, 0, 0, 0},
 167         {0, 0, 0, 0, 0},
 168         {0, 0, 0, 0, 0},
 169         {0, 0, 0, 0, 0},
 170         {0, 0, 0, 0, 0}
 171 };
 172 static xtalk_coefs_t const asXtalkCoefsPipe = {
 173         {0, 0, 0x0FA0, 0, 0},
 174         {0, 0, 0x0FA0, 0, 0},
 175         {0, 0, 0x0FA0, 0, 0},
 176         {0, 0, 0x0FA0, 0, 0},
 177         {0, 0, 0x1180, 0, 0},
 178 };
 179 static xtalk_coefs_t const asXtalkCoefsNegPipe = {
 180         {0, 0, 0xF380, 0, 0},
 181         {0, 0, 0xF380, 0, 0},
 182         {0, 0, 0xF380, 0, 0},
 183         {0, 0, 0xF380, 0, 0},
 184         {0, 0, 0xF200, 0, 0}
 185 };
 186
 187 static xtalk_coefs_t const asXtalkCoefsNumTest = {
 188         {0, 0, 0xF380, 0x8000, 0x6D60},
 189         {0, 0, 0, 0, 0},
 190         {0, 0, 0, 0, 0},
 191         {0, 0, 0, 0, 0},
 192         {0, 0, 0, 0, 0}
 193 };
 194
 195 static xtalk_coefs_t const asXtalkCoefsDenTest = {
 196         {0xC000, 0x2000, 0x4000, 0, 0},
 197         {0, 0, 0, 0, 0},
 198         {0, 0, 0, 0, 0},
 199         {0, 0, 0, 0, 0},
 200         {0, 0, 0, 0, 0}
 201 };
 202
 203 static xtalk_state_t const asXtalkOutStateTest = {
 204         {0x7FFF, 0x0004, 0xFFFC, 0},
 205         {0xFE00, 0x0008, 0xFFF8, 0x4000},
 206         {0x200, 0x0010, 0xFFF0, 0xC000},
 207         {0x8000, 0x0020, 0xFFE0, 0},
 208         {0, 0, 0, 0}
 209 };
 210
 211 static xtalk_coefs_t const asDiamondCoefsLeftEq = {
 212         {0x0F1E, 0x2D05, 0xF8E3, 0x07C8, 0},
 213         {0x45E2, 0xCA51, 0x0448, 0xFCE7, 0},
 214         {0xA93E, 0xDBD5, 0x022C, 0x028A, 0},
 215         {0, 0, 0, 0, 0},
 216         {0, 0, 0, 0, 0}
 217 };
 218
 219 static xtalk_coefs_t const asDiamondCoefsRightEq = {
 220         {0x0F1E, 0x2D05, 0xF8E3, 0x07C8, 0},
 221         {0x45E2, 0xCA51, 0x0448, 0xFCE7, 0},
 222         {0xA93E, 0xDBD5, 0x022C, 0x028A, 0},
 223         {0, 0, 0, 0, 0},
 224         {0, 0, 0, 0, 0}
 225 };
 226
 227 static xtalk_coefs_t const asDiamondCoefsLeftXt = {
 228         {0x3B50, 0xFE08, 0xF959, 0x0060, 0},
 229         {0x9FCB, 0xD8F1, 0x00A2, 0x003A, 0},
 230         {0, 0, 0, 0, 0},
 231         {0, 0, 0, 0, 0},
 232         {0, 0, 0, 0, 0}
 233 };
 234
 235 static xtalk_coefs_t const asDiamondCoefsRightXt = {
 236         {0x3B50, 0xFE08, 0xF959, 0x0060, 0},
 237         {0x9FCB, 0xD8F1, 0x00A2, 0x003A, 0},
 238         {0, 0, 0, 0, 0},
 239         {0, 0, 0, 0, 0},
 240         {0, 0, 0, 0, 0}
 241 };
 242
 243  /**/
 244 /* XTalk EQ and XT */
 245 static void
 246 vortex_XtalkHw_SetLeftEQ(vortex_t * vortex, short arg_0, short arg_4,
 247                          xtalk_coefs_t const coefs)
 248 {
 249         int i;
 250
 251         for (i = 0; i < 5; i++) {
 252                 hwwrite(vortex->mmio, 0x24200 + i * 0x24, coefs[i][0]);
 253                 hwwrite(vortex->mmio, 0x24204 + i * 0x24, coefs[i][1]);
 254                 hwwrite(vortex->mmio, 0x24208 + i * 0x24, coefs[i][2]);
 255                 hwwrite(vortex->mmio, 0x2420c + i * 0x24, coefs[i][3]);
 256                 hwwrite(vortex->mmio, 0x24210 + i * 0x24, coefs[i][4]);
 257         }
 258         hwwrite(vortex->mmio, 0x24538, arg_0 & 0xffff);
 259         hwwrite(vortex->mmio, 0x2453C, arg_4 & 0xffff);
 260 }
 261
 262 static void
 263 vortex_XtalkHw_SetRightEQ(vortex_t * vortex, short arg_0, short arg_4,
 264                           xtalk_coefs_t const coefs)
 265 {
 266         int i;
 267
 268         for (i = 0; i < 5; i++) {
 269                 hwwrite(vortex->mmio, 0x242b4 + i * 0x24, coefs[i][0]);
 270                 hwwrite(vortex->mmio, 0x242b8 + i * 0x24, coefs[i][1]);
 271                 hwwrite(vortex->mmio, 0x242bc + i * 0x24, coefs[i][2]);
 272                 hwwrite(vortex->mmio, 0x242c0 + i * 0x24, coefs[i][3]);
 273                 hwwrite(vortex->mmio, 0x242c4 + i * 0x24, coefs[i][4]);
 274         }
 275         hwwrite(vortex->mmio, 0x24540, arg_0 & 0xffff);
 276         hwwrite(vortex->mmio, 0x24544, arg_4 & 0xffff);
 277 }
 278
 279 static void
 280 vortex_XtalkHw_SetLeftXT(vortex_t * vortex, short arg_0, short arg_4,
 281                          xtalk_coefs_t const coefs)
 282 {
 283         int i;
 284
 285         for (i = 0; i < 5; i++) {
 286                 hwwrite(vortex->mmio, 0x24368 + i * 0x24, coefs[i][0]);
 287                 hwwrite(vortex->mmio, 0x2436c + i * 0x24, coefs[i][1]);
 288                 hwwrite(vortex->mmio, 0x24370 + i * 0x24, coefs[i][2]);
 289                 hwwrite(vortex->mmio, 0x24374 + i * 0x24, coefs[i][3]);
 290                 hwwrite(vortex->mmio, 0x24378 + i * 0x24, coefs[i][4]);
 291         }
 292         hwwrite(vortex->mmio, 0x24548, arg_0 & 0xffff);
 293         hwwrite(vortex->mmio, 0x2454C, arg_4 & 0xffff);
 294 }
 295
 296 static void
 297 vortex_XtalkHw_SetRightXT(vortex_t * vortex, short arg_0, short arg_4,
 298                           xtalk_coefs_t const coefs)
 299 {
 300         int i;
 301
 302         for (i = 0; i < 5; i++) {
 303                 hwwrite(vortex->mmio, 0x2441C + i * 0x24, coefs[i][0]);
 304                 hwwrite(vortex->mmio, 0x24420 + i * 0x24, coefs[i][1]);
 305                 hwwrite(vortex->mmio, 0x24424 + i * 0x24, coefs[i][2]);
 306                 hwwrite(vortex->mmio, 0x24428 + i * 0x24, coefs[i][3]);
 307                 hwwrite(vortex->mmio, 0x2442C + i * 0x24, coefs[i][4]);
 308         }
 309         hwwrite(vortex->mmio, 0x24550, arg_0 & 0xffff);
 310         hwwrite(vortex->mmio, 0x24554, arg_4 & 0xffff);
 311 }
 312
 313 static void
 314 vortex_XtalkHw_SetLeftEQStates(vortex_t * vortex,
 315                                xtalk_instate_t const arg_0,
 316                                xtalk_state_t const coefs)
 317 {
 318         int i;
 319
 320         for (i = 0; i < 5; i++) {
 321                 hwwrite(vortex->mmio, 0x24214 + i * 0x24, coefs[i][0]);
 322                 hwwrite(vortex->mmio, 0x24218 + i * 0x24, coefs[i][1]);
 323                 hwwrite(vortex->mmio, 0x2421C + i * 0x24, coefs[i][2]);
 324                 hwwrite(vortex->mmio, 0x24220 + i * 0x24, coefs[i][3]);
 325         }
 326         hwwrite(vortex->mmio, 0x244F8 + i * 0x24, arg_0[0]);
 327         hwwrite(vortex->mmio, 0x244FC + i * 0x24, arg_0[1]);
 328         hwwrite(vortex->mmio, 0x24500 + i * 0x24, arg_0[2]);
 329         hwwrite(vortex->mmio, 0x24504 + i * 0x24, arg_0[3]);
 330 }
 331
 332 static void
 333 vortex_XtalkHw_SetRightEQStates(vortex_t * vortex,
 334                                 xtalk_instate_t const arg_0,
 335                                 xtalk_state_t const coefs)
 336 {
 337         int i;
 338
 339         for (i = 0; i < 5; i++) {
 340                 hwwrite(vortex->mmio, 0x242C8 + i * 0x24, coefs[i][0]);
 341                 hwwrite(vortex->mmio, 0x242CC + i * 0x24, coefs[i][1]);
 342                 hwwrite(vortex->mmio, 0x242D0 + i * 0x24, coefs[i][2]);
 343                 hwwrite(vortex->mmio, 0x244D4 + i * 0x24, coefs[i][3]);
 344         }
 345         hwwrite(vortex->mmio, 0x24508 + i * 0x24, arg_0[0]);
 346         hwwrite(vortex->mmio, 0x2450C + i * 0x24, arg_0[1]);
 347         hwwrite(vortex->mmio, 0x24510 + i * 0x24, arg_0[2]);
 348         hwwrite(vortex->mmio, 0x24514 + i * 0x24, arg_0[3]);
 349 }
 350
 351 static void
 352 vortex_XtalkHw_SetLeftXTStates(vortex_t * vortex,
 353                                xtalk_instate_t const arg_0,
 354                                xtalk_state_t const coefs)
 355 {
 356         int i;
 357
 358         for (i = 0; i < 5; i++) {
 359                 hwwrite(vortex->mmio, 0x2437C + i * 0x24, coefs[i][0]);
 360                 hwwrite(vortex->mmio, 0x24380 + i * 0x24, coefs[i][1]);
 361                 hwwrite(vortex->mmio, 0x24384 + i * 0x24, coefs[i][2]);
 362                 hwwrite(vortex->mmio, 0x24388 + i * 0x24, coefs[i][3]);
 363         }
 364         hwwrite(vortex->mmio, 0x24518 + i * 0x24, arg_0[0]);
 365         hwwrite(vortex->mmio, 0x2451C + i * 0x24, arg_0[1]);
 366         hwwrite(vortex->mmio, 0x24520 + i * 0x24, arg_0[2]);
 367         hwwrite(vortex->mmio, 0x24524 + i * 0x24, arg_0[3]);
 368 }
 369
 370 static void
 371 vortex_XtalkHw_SetRightXTStates(vortex_t * vortex,
 372                                 xtalk_instate_t const arg_0,
 373                                 xtalk_state_t const coefs)
 374 {
 375         int i;
 376
 377         for (i = 0; i < 5; i++) {
 378                 hwwrite(vortex->mmio, 0x24430 + i * 0x24, coefs[i][0]);
 379                 hwwrite(vortex->mmio, 0x24434 + i * 0x24, coefs[i][1]);
 380                 hwwrite(vortex->mmio, 0x24438 + i * 0x24, coefs[i][2]);
 381                 hwwrite(vortex->mmio, 0x2443C + i * 0x24, coefs[i][3]);
 382         }
 383         hwwrite(vortex->mmio, 0x24528 + i * 0x24, arg_0[0]);
 384         hwwrite(vortex->mmio, 0x2452C + i * 0x24, arg_0[1]);
 385         hwwrite(vortex->mmio, 0x24530 + i * 0x24, arg_0[2]);
 386         hwwrite(vortex->mmio, 0x24534 + i * 0x24, arg_0[3]);
 387 }
 388
 389 #if 0
 390 static void
 391 vortex_XtalkHw_GetLeftEQ(vortex_t * vortex, short *arg_0, short *arg_4,
 392                          xtalk_coefs_t coefs)
 393 {
 394         int i;
 395
 396         for (i = 0; i < 5; i++) {
 397                 coefs[i][0] = hwread(vortex->mmio, 0x24200 + i * 0x24);
 398                 coefs[i][1] = hwread(vortex->mmio, 0x24204 + i * 0x24);
 399                 coefs[i][2] = hwread(vortex->mmio, 0x24208 + i * 0x24);
 400                 coefs[i][3] = hwread(vortex->mmio, 0x2420c + i * 0x24);
 401                 coefs[i][4] = hwread(vortex->mmio, 0x24210 + i * 0x24);
 402         }
 403         *arg_0 = hwread(vortex->mmio, 0x24538) & 0xffff;
 404         *arg_4 = hwread(vortex->mmio, 0x2453c) & 0xffff;
 405 }
 406
 407 static void
 408 vortex_XtalkHw_GetRightEQ(vortex_t * vortex, short *arg_0, short *arg_4,
 409                           xtalk_coefs_t coefs)
 410 {
 411         int i;
 412
 413         for (i = 0; i < 5; i++) {
 414                 coefs[i][0] = hwread(vortex->mmio, 0x242b4 + i * 0x24);
 415                 coefs[i][1] = hwread(vortex->mmio, 0x242b8 + i * 0x24);
 416                 coefs[i][2] = hwread(vortex->mmio, 0x242bc + i * 0x24);
 417                 coefs[i][3] = hwread(vortex->mmio, 0x242c0 + i * 0x24);
 418                 coefs[i][4] = hwread(vortex->mmio, 0x242c4 + i * 0x24);
 419         }
 420         *arg_0 = hwread(vortex->mmio, 0x24540) & 0xffff;
 421         *arg_4 = hwread(vortex->mmio, 0x24544) & 0xffff;
 422 }
 423
 424 static void
 425 vortex_XtalkHw_GetLeftXT(vortex_t * vortex, short *arg_0, short *arg_4,
 426                          xtalk_coefs_t coefs)
 427 {
 428         int i;
 429
 430         for (i = 0; i < 5; i++) {
 431                 coefs[i][0] = hwread(vortex->mmio, 0x24368 + i * 0x24);
 432                 coefs[i][1] = hwread(vortex->mmio, 0x2436C + i * 0x24);
 433                 coefs[i][2] = hwread(vortex->mmio, 0x24370 + i * 0x24);
 434                 coefs[i][3] = hwread(vortex->mmio, 0x24374 + i * 0x24);
 435                 coefs[i][4] = hwread(vortex->mmio, 0x24378 + i * 0x24);
 436         }
 437         *arg_0 = hwread(vortex->mmio, 0x24548) & 0xffff;
 438         *arg_4 = hwread(vortex->mmio, 0x2454C) & 0xffff;
 439 }
 440
 441 static void
 442 vortex_XtalkHw_GetRightXT(vortex_t * vortex, short *arg_0, short *arg_4,
 443                           xtalk_coefs_t coefs)
 444 {
 445         int i;
 446
 447         for (i = 0; i < 5; i++) {
 448                 coefs[i][0] = hwread(vortex->mmio, 0x2441C + i * 0x24);
 449                 coefs[i][1] = hwread(vortex->mmio, 0x24420 + i * 0x24);
 450                 coefs[i][2] = hwread(vortex->mmio, 0x24424 + i * 0x24);
 451                 coefs[i][3] = hwread(vortex->mmio, 0x24428 + i * 0x24);
 452                 coefs[i][4] = hwread(vortex->mmio, 0x2442C + i * 0x24);
 453         }
 454         *arg_0 = hwread(vortex->mmio, 0x24550) & 0xffff;
 455         *arg_4 = hwread(vortex->mmio, 0x24554) & 0xffff;
 456 }
 457
 458 static void
 459 vortex_XtalkHw_GetLeftEQStates(vortex_t * vortex, xtalk_instate_t arg_0,
 460                                xtalk_state_t coefs)
 461 {
 462         int i;
 463
 464         for (i = 0; i < 5; i++) {
 465                 coefs[i][0] = hwread(vortex->mmio, 0x24214 + i * 0x24);
 466                 coefs[i][1] = hwread(vortex->mmio, 0x24218 + i * 0x24);
 467                 coefs[i][2] = hwread(vortex->mmio, 0x2421C + i * 0x24);
 468                 coefs[i][3] = hwread(vortex->mmio, 0x24220 + i * 0x24);
 469         }
 470         arg_0[0] = hwread(vortex->mmio, 0x244F8 + i * 0x24);
 471         arg_0[1] = hwread(vortex->mmio, 0x244FC + i * 0x24);
 472         arg_0[2] = hwread(vortex->mmio, 0x24500 + i * 0x24);
 473         arg_0[3] = hwread(vortex->mmio, 0x24504 + i * 0x24);
 474 }
 475
 476 static void
 477 vortex_XtalkHw_GetRightEQStates(vortex_t * vortex, xtalk_instate_t arg_0,
 478                                 xtalk_state_t coefs)
 479 {
 480         int i;
 481
 482         for (i = 0; i < 5; i++) {
 483                 coefs[i][0] = hwread(vortex->mmio, 0x242C8 + i * 0x24);
 484                 coefs[i][1] = hwread(vortex->mmio, 0x242CC + i * 0x24);
 485                 coefs[i][2] = hwread(vortex->mmio, 0x242D0 + i * 0x24);
 486                 coefs[i][3] = hwread(vortex->mmio, 0x242D4 + i * 0x24);
 487         }
 488         arg_0[0] = hwread(vortex->mmio, 0x24508 + i * 0x24);
 489         arg_0[1] = hwread(vortex->mmio, 0x2450C + i * 0x24);
 490         arg_0[2] = hwread(vortex->mmio, 0x24510 + i * 0x24);
 491         arg_0[3] = hwread(vortex->mmio, 0x24514 + i * 0x24);
 492 }
 493
 494 static void
 495 vortex_XtalkHw_GetLeftXTStates(vortex_t * vortex, xtalk_instate_t arg_0,
 496                                xtalk_state_t coefs)
 497 {
 498         int i;
 499
 500         for (i = 0; i < 5; i++) {
 501                 coefs[i][0] = hwread(vortex->mmio, 0x2437C + i * 0x24);
 502                 coefs[i][1] = hwread(vortex->mmio, 0x24380 + i * 0x24);
 503                 coefs[i][2] = hwread(vortex->mmio, 0x24384 + i * 0x24);
 504                 coefs[i][3] = hwread(vortex->mmio, 0x24388 + i * 0x24);
 505         }
 506         arg_0[0] = hwread(vortex->mmio, 0x24518 + i * 0x24);
 507         arg_0[1] = hwread(vortex->mmio, 0x2451C + i * 0x24);
 508         arg_0[2] = hwread(vortex->mmio, 0x24520 + i * 0x24);
 509         arg_0[3] = hwread(vortex->mmio, 0x24524 + i * 0x24);
 510 }
 511
 512 static void
 513 vortex_XtalkHw_GetRightXTStates(vortex_t * vortex, xtalk_instate_t arg_0,
 514                                 xtalk_state_t coefs)
 515 {
 516         int i;
 517
 518         for (i = 0; i < 5; i++) {
 519                 coefs[i][0] = hwread(vortex->mmio, 0x24430 + i * 0x24);
 520                 coefs[i][1] = hwread(vortex->mmio, 0x24434 + i * 0x24);
 521                 coefs[i][2] = hwread(vortex->mmio, 0x24438 + i * 0x24);
 522                 coefs[i][3] = hwread(vortex->mmio, 0x2443C + i * 0x24);
 523         }
 524         arg_0[0] = hwread(vortex->mmio, 0x24528 + i * 0x24);
 525         arg_0[1] = hwread(vortex->mmio, 0x2452C + i * 0x24);
 526         arg_0[2] = hwread(vortex->mmio, 0x24530 + i * 0x24);
 527         arg_0[3] = hwread(vortex->mmio, 0x24534 + i * 0x24);
 528 }
 529
 530 #endif
 531 /* Gains */
 532
 533 static void
 534 vortex_XtalkHw_SetGains(vortex_t * vortex, xtalk_gains_t const gains)
 535 {
 536         int i;
 537
 538         for (i = 0; i < XTGAINS_SZ; i++) {
 539                 hwwrite(vortex->mmio, 0x244D0 + (i * 4), gains[i]);
 540         }
 541 }
 542
 543 static void
 544 vortex_XtalkHw_SetGainsAllChan(vortex_t * vortex)
 545 {
 546         vortex_XtalkHw_SetGains(vortex, asXtalkGainsAllChan);
 547 }
 548
 549 #if 0
 550 static void vortex_XtalkHw_GetGains(vortex_t * vortex, xtalk_gains_t gains)
 551 {
 552         int i;
 553
 554         for (i = 0; i < XTGAINS_SZ; i++)
 555                 gains[i] = hwread(vortex->mmio, 0x244D0 + i * 4);
 556 }
 557
 558 #endif
 559 /* Delay parameters */
 560
 561 static void
 562 vortex_XtalkHw_SetDelay(vortex_t * vortex, unsigned short right,
 563                         unsigned short left)
 564 {
 565         int esp0 = 0;
 566
 567         esp0 &= 0x1FFFFFFF;
 568         esp0 |= 0xA0000000;
 569         esp0 = (esp0 & 0xffffE0ff) | ((right & 0x1F) << 8);
 570         esp0 = (esp0 & 0xfffc1fff) | ((left & 0x1F) << 0xd);
 571
 572         hwwrite(vortex->mmio, 0x24660, esp0);
 573 }
 574
 575 static void
 576 vortex_XtalkHw_SetLeftDline(vortex_t * vortex, xtalk_dline_t const dline)
 577 {
 578         int i;
 579
 580         for (i = 0; i < 0x20; i++) {
 581                 hwwrite(vortex->mmio, 0x24000 + (i << 2), dline[i] & 0xffff);
 582                 hwwrite(vortex->mmio, 0x24080 + (i << 2), dline[i] >> 0x10);
 583         }
 584 }
 585
 586 static void
 587 vortex_XtalkHw_SetRightDline(vortex_t * vortex, xtalk_dline_t const dline)
 588 {
 589         int i;
 590
 591         for (i = 0; i < 0x20; i++) {
 592                 hwwrite(vortex->mmio, 0x24100 + (i << 2), dline[i] & 0xffff);
 593                 hwwrite(vortex->mmio, 0x24180 + (i << 2), dline[i] >> 0x10);
 594         }
 595 }
 596
 597 #if 0
 598 static void
 599 vortex_XtalkHw_GetDelay(vortex_t * vortex, unsigned short *right,
 600                         unsigned short *left)
 601 {
 602         int esp0;
 603
 604         esp0 = hwread(vortex->mmio, 0x24660);
 605         *right = (esp0 >> 8) & 0x1f;
 606         *left = (esp0 >> 0xd) & 0x1f;
 607 }
 608
 609 static void vortex_XtalkHw_GetLeftDline(vortex_t * vortex, xtalk_dline_t dline)
 610 {
 611         int i;
 612
 613         for (i = 0; i < 0x20; i++) {
 614                 dline[i] =
 615                     (hwread(vortex->mmio, 0x24000 + (i << 2)) & 0xffff) |
 616                     (hwread(vortex->mmio, 0x24080 + (i << 2)) << 0x10);
 617         }
 618 }
 619
 620 static void vortex_XtalkHw_GetRightDline(vortex_t * vortex, xtalk_dline_t dline)
 621 {
 622         int i;
 623
 624         for (i = 0; i < 0x20; i++) {
 625                 dline[i] =
 626                     (hwread(vortex->mmio, 0x24100 + (i << 2)) & 0xffff) |
 627                     (hwread(vortex->mmio, 0x24180 + (i << 2)) << 0x10);
 628         }
 629 }
 630
 631 #endif
 632 /* Control/Global stuff */
 633
 634 #if 0
 635 static void vortex_XtalkHw_SetControlReg(vortex_t * vortex, unsigned long ctrl)
 636 {
 637         hwwrite(vortex->mmio, 0x24660, ctrl);
 638 }
 639 static void vortex_XtalkHw_GetControlReg(vortex_t * vortex, unsigned long *ctrl)
 640 {
 641         *ctrl = hwread(vortex->mmio, 0x24660);
 642 }
 643 #endif
 644 static void vortex_XtalkHw_SetSampleRate(vortex_t * vortex, int sr)
 645 {
 646         int temp;
 647
 648         temp = (hwread(vortex->mmio, 0x24660) & 0x1FFFFFFF) | 0xC0000000;
 649         temp = (temp & 0xffffff07) | ((sr & 0x1f) << 3);
 650         hwwrite(vortex->mmio, 0x24660, temp);
 651 }
 652
 653 #if 0
 654 static void vortex_XtalkHw_GetSampleRate(vortex_t * vortex, int *sr)
 655 {
 656         *sr = (hwread(vortex->mmio, 0x24660) >> 3) & 0x1f;
 657 }
 658
 659 #endif
 660 static void vortex_XtalkHw_Enable(vortex_t * vortex)
 661 {
 662         int temp;
 663
 664         temp = (hwread(vortex->mmio, 0x24660) & 0x1FFFFFFF) | 0xC0000000;
 665         temp |= 1;
 666         hwwrite(vortex->mmio, 0x24660, temp);
 667
 668 }
 669
 670 static void vortex_XtalkHw_Disable(vortex_t * vortex)
 671 {
 672         int temp;
 673
 674         temp = (hwread(vortex->mmio, 0x24660) & 0x1FFFFFFF) | 0xC0000000;
 675         temp &= 0xfffffffe;
 676         hwwrite(vortex->mmio, 0x24660, temp);
 677
 678 }
 679
 680 static void vortex_XtalkHw_ZeroIO(vortex_t * vortex)
 681 {
 682         int i;
 683
 684         for (i = 0; i < 20; i++)
 685                 hwwrite(vortex->mmio, 0x24600 + (i << 2), 0);
 686         for (i = 0; i < 4; i++)
 687                 hwwrite(vortex->mmio, 0x24650 + (i << 2), 0);
 688 }
 689
 690 static void vortex_XtalkHw_ZeroState(vortex_t * vortex)
 691 {
 692         vortex_XtalkHw_ZeroIO(vortex);  // inlined
 693
 694         vortex_XtalkHw_SetLeftEQ(vortex, 0, 0, asXtalkCoefsZeros);
 695         vortex_XtalkHw_SetRightEQ(vortex, 0, 0, asXtalkCoefsZeros);
 696
 697         vortex_XtalkHw_SetLeftXT(vortex, 0, 0, asXtalkCoefsZeros);
 698         vortex_XtalkHw_SetRightXT(vortex, 0, 0, asXtalkCoefsZeros);
 699
 700         vortex_XtalkHw_SetGains(vortex, asXtalkGainsZeros);     // inlined
 701
 702         vortex_XtalkHw_SetDelay(vortex, 0, 0);  // inlined
 703
 704         vortex_XtalkHw_SetLeftDline(vortex, alXtalkDlineZeros); // inlined
 705         vortex_XtalkHw_SetRightDline(vortex, alXtalkDlineZeros);        // inlined
 706         vortex_XtalkHw_SetLeftDline(vortex, alXtalkDlineZeros); // inlined
 707         vortex_XtalkHw_SetRightDline(vortex, alXtalkDlineZeros);        // inlined
 708
 709         vortex_XtalkHw_SetLeftEQStates(vortex, asXtalkInStateZeros,
 710                                        asXtalkOutStateZeros);
 711         vortex_XtalkHw_SetRightEQStates(vortex, asXtalkInStateZeros,
 712                                         asXtalkOutStateZeros);
 713         vortex_XtalkHw_SetLeftXTStates(vortex, asXtalkInStateZeros,
 714                                        asXtalkOutStateZeros);
 715         vortex_XtalkHw_SetRightXTStates(vortex, asXtalkInStateZeros,
 716                                         asXtalkOutStateZeros);
 717 }
 718
 719 static void vortex_XtalkHw_ProgramPipe(vortex_t * vortex)
 720 {
 721
 722         vortex_XtalkHw_SetLeftEQ(vortex, 0, 1, asXtalkCoefsPipe);
 723         vortex_XtalkHw_SetRightEQ(vortex, 0, 1, asXtalkCoefsPipe);
 724         vortex_XtalkHw_SetLeftXT(vortex, 0, 0, asXtalkCoefsZeros);
 725         vortex_XtalkHw_SetRightXT(vortex, 0, 0, asXtalkCoefsZeros);
 726
 727         vortex_XtalkHw_SetDelay(vortex, 0, 0);  // inlined
 728 }
 729
 730 static void vortex_XtalkHw_ProgramXtalkWide(vortex_t * vortex)
 731 {
 732
 733         vortex_XtalkHw_SetLeftEQ(vortex, sXtalkWideKLeftEq,
 734                                  sXtalkWideShiftLeftEq, asXtalkWideCoefsLeftEq);
 735         vortex_XtalkHw_SetRightEQ(vortex, sXtalkWideKRightEq,
 736                                   sXtalkWideShiftRightEq,
 737                                   asXtalkWideCoefsRightEq);
 738         vortex_XtalkHw_SetLeftXT(vortex, sXtalkWideKLeftXt,
 739                                  sXtalkWideShiftLeftXt, asXtalkWideCoefsLeftXt);
 740         vortex_XtalkHw_SetRightXT(vortex, sXtalkWideKLeftXt,
 741                                   sXtalkWideShiftLeftXt,
 742                                   asXtalkWideCoefsLeftXt);
 743
 744         vortex_XtalkHw_SetDelay(vortex, wXtalkWideRightDelay, wXtalkWideLeftDelay);     // inlined
 745 }
 746
 747 static void vortex_XtalkHw_ProgramXtalkNarrow(vortex_t * vortex)
 748 {
 749
 750         vortex_XtalkHw_SetLeftEQ(vortex, sXtalkNarrowKLeftEq,
 751                                  sXtalkNarrowShiftLeftEq,
 752                                  asXtalkNarrowCoefsLeftEq);
 753         vortex_XtalkHw_SetRightEQ(vortex, sXtalkNarrowKRightEq,
 754                                   sXtalkNarrowShiftRightEq,
 755                                   asXtalkNarrowCoefsRightEq);
 756         vortex_XtalkHw_SetLeftXT(vortex, sXtalkNarrowKLeftXt,
 757                                  sXtalkNarrowShiftLeftXt,
 758                                  asXtalkNarrowCoefsLeftXt);
 759         vortex_XtalkHw_SetRightXT(vortex, sXtalkNarrowKLeftXt,
 760                                   sXtalkNarrowShiftLeftXt,
 761                                   asXtalkNarrowCoefsLeftXt);
 762
 763         vortex_XtalkHw_SetDelay(vortex, wXtalkNarrowRightDelay, wXtalkNarrowLeftDelay); // inlined
 764 }
 765
 766 static void vortex_XtalkHw_ProgramDiamondXtalk(vortex_t * vortex)
 767 {
 768
 769         //sDiamondKLeftEq,sDiamondKRightXt,asDiamondCoefsLeftEq
 770         vortex_XtalkHw_SetLeftEQ(vortex, sDiamondKLeftEq,
 771                                  sDiamondShiftLeftEq, asDiamondCoefsLeftEq);
 772         vortex_XtalkHw_SetRightEQ(vortex, sDiamondKRightEq,
 773                                   sDiamondShiftRightEq, asDiamondCoefsRightEq);
 774         vortex_XtalkHw_SetLeftXT(vortex, sDiamondKLeftXt,
 775                                  sDiamondShiftLeftXt, asDiamondCoefsLeftXt);
 776         vortex_XtalkHw_SetRightXT(vortex, sDiamondKLeftXt,
 777                                   sDiamondShiftLeftXt, asDiamondCoefsLeftXt);
 778
 779         vortex_XtalkHw_SetDelay(vortex, wDiamondRightDelay, wDiamondLeftDelay); // inlined
 780 }
 781
 782 static void vortex_XtalkHw_init(vortex_t * vortex)
 783 {
 784         vortex_XtalkHw_ZeroState(vortex);
 785 }
 786
 787 /* End of file */