sound/pci/emu10k1/emufx.c

   1 /*
   2  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
   3  *                   Creative Labs, Inc.
   4  *  Routines for effect processor FX8010
   5  *
   6  *  Copyright (c) by James Courtier-Dutton <James@superbug.co.uk>
   7  *      Added EMU 1010 support.
   8  *
   9  *  BUGS:
  10  *    --
  11  *
  12  *  TODO:
  13  *    --
  14  *
  15  *   This program is free software; you can redistribute it and/or modify
  16  *   it under the terms of the GNU General Public License as published by
  17  *   the Free Software Foundation; either version 2 of the License, or
  18  *   (at your option) any later version.
  19  *
  20  *   This program is distributed in the hope that it will be useful,
  21  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  *   GNU General Public License for more details.
  24  *
  25  *   You should have received a copy of the GNU General Public License
  26  *   along with this program; if not, write to the Free Software
  27  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  28  *
  29  */
  30
  31 #include <linux/pci.h>
  32 #include <linux/capability.h>
  33 #include <linux/delay.h>
  34 #include <linux/slab.h>
  35 #include <linux/vmalloc.h>
  36 #include <linux/init.h>
  37 #include <linux/mutex.h>
  38 #include <linux/moduleparam.h>
  39
  40 #include <sound/core.h>
  41 #include <sound/tlv.h>
  42 #include <sound/emu10k1.h>
  43
  44 #if 0           /* for testing purposes - digital out -> capture */
  45 #define EMU10K1_CAPTURE_DIGITAL_OUT
  46 #endif
  47 #if 0           /* for testing purposes - set S/PDIF to AC3 output */
  48 #define EMU10K1_SET_AC3_IEC958
  49 #endif
  50 #if 0           /* for testing purposes - feed the front signal to Center/LFE outputs */
  51 #define EMU10K1_CENTER_LFE_FROM_FRONT
  52 #endif
  53
  54 static bool high_res_gpr_volume;
  55 module_param(high_res_gpr_volume, bool, 0444);
  56 MODULE_PARM_DESC(high_res_gpr_volume, "GPR mixer controls use 31-bit range.");
  57
  58 /*
  59  *  Tables
  60  */
  61
  62 static char *fxbuses[16] = {
  63         /* 0x00 */ "PCM Left",
  64         /* 0x01 */ "PCM Right",
  65         /* 0x02 */ "PCM Surround Left",
  66         /* 0x03 */ "PCM Surround Right",
  67         /* 0x04 */ "MIDI Left",
  68         /* 0x05 */ "MIDI Right",
  69         /* 0x06 */ "Center",
  70         /* 0x07 */ "LFE",
  71         /* 0x08 */ NULL,
  72         /* 0x09 */ NULL,
  73         /* 0x0a */ NULL,
  74         /* 0x0b */ NULL,
  75         /* 0x0c */ "MIDI Reverb",
  76         /* 0x0d */ "MIDI Chorus",
  77         /* 0x0e */ NULL,
  78         /* 0x0f */ NULL
  79 };
  80
  81 static char *creative_ins[16] = {
  82         /* 0x00 */ "AC97 Left",
  83         /* 0x01 */ "AC97 Right",
  84         /* 0x02 */ "TTL IEC958 Left",
  85         /* 0x03 */ "TTL IEC958 Right",
  86         /* 0x04 */ "Zoom Video Left",
  87         /* 0x05 */ "Zoom Video Right",
  88         /* 0x06 */ "Optical IEC958 Left",
  89         /* 0x07 */ "Optical IEC958 Right",
  90         /* 0x08 */ "Line/Mic 1 Left",
  91         /* 0x09 */ "Line/Mic 1 Right",
  92         /* 0x0a */ "Coaxial IEC958 Left",
  93         /* 0x0b */ "Coaxial IEC958 Right",
  94         /* 0x0c */ "Line/Mic 2 Left",
  95         /* 0x0d */ "Line/Mic 2 Right",
  96         /* 0x0e */ NULL,
  97         /* 0x0f */ NULL
  98 };
  99
 100 static char *audigy_ins[16] = {
 101         /* 0x00 */ "AC97 Left",
 102         /* 0x01 */ "AC97 Right",
 103         /* 0x02 */ "Audigy CD Left",
 104         /* 0x03 */ "Audigy CD Right",
 105         /* 0x04 */ "Optical IEC958 Left",
 106         /* 0x05 */ "Optical IEC958 Right",
 107         /* 0x06 */ NULL,
 108         /* 0x07 */ NULL,
 109         /* 0x08 */ "Line/Mic 2 Left",
 110         /* 0x09 */ "Line/Mic 2 Right",
 111         /* 0x0a */ "SPDIF Left",
 112         /* 0x0b */ "SPDIF Right",
 113         /* 0x0c */ "Aux2 Left",
 114         /* 0x0d */ "Aux2 Right",
 115         /* 0x0e */ NULL,
 116         /* 0x0f */ NULL
 117 };
 118
 119 static char *creative_outs[32] = {
 120         /* 0x00 */ "AC97 Left",
 121         /* 0x01 */ "AC97 Right",
 122         /* 0x02 */ "Optical IEC958 Left",
 123         /* 0x03 */ "Optical IEC958 Right",
 124         /* 0x04 */ "Center",
 125         /* 0x05 */ "LFE",
 126         /* 0x06 */ "Headphone Left",
 127         /* 0x07 */ "Headphone Right",
 128         /* 0x08 */ "Surround Left",
 129         /* 0x09 */ "Surround Right",
 130         /* 0x0a */ "PCM Capture Left",
 131         /* 0x0b */ "PCM Capture Right",
 132         /* 0x0c */ "MIC Capture",
 133         /* 0x0d */ "AC97 Surround Left",
 134         /* 0x0e */ "AC97 Surround Right",
 135         /* 0x0f */ NULL,
 136         /* 0x10 */ NULL,
 137         /* 0x11 */ "Analog Center",
 138         /* 0x12 */ "Analog LFE",
 139         /* 0x13 */ NULL,
 140         /* 0x14 */ NULL,
 141         /* 0x15 */ NULL,
 142         /* 0x16 */ NULL,
 143         /* 0x17 */ NULL,
 144         /* 0x18 */ NULL,
 145         /* 0x19 */ NULL,
 146         /* 0x1a */ NULL,
 147         /* 0x1b */ NULL,
 148         /* 0x1c */ NULL,
 149         /* 0x1d */ NULL,
 150         /* 0x1e */ NULL,
 151         /* 0x1f */ NULL,
 152 };
 153
 154 static char *audigy_outs[32] = {
 155         /* 0x00 */ "Digital Front Left",
 156         /* 0x01 */ "Digital Front Right",
 157         /* 0x02 */ "Digital Center",
 158         /* 0x03 */ "Digital LEF",
 159         /* 0x04 */ "Headphone Left",
 160         /* 0x05 */ "Headphone Right",
 161         /* 0x06 */ "Digital Rear Left",
 162         /* 0x07 */ "Digital Rear Right",
 163         /* 0x08 */ "Front Left",
 164         /* 0x09 */ "Front Right",
 165         /* 0x0a */ "Center",
 166         /* 0x0b */ "LFE",
 167         /* 0x0c */ NULL,
 168         /* 0x0d */ NULL,
 169         /* 0x0e */ "Rear Left",
 170         /* 0x0f */ "Rear Right",
 171         /* 0x10 */ "AC97 Front Left",
 172         /* 0x11 */ "AC97 Front Right",
 173         /* 0x12 */ "ADC Caputre Left",
 174         /* 0x13 */ "ADC Capture Right",
 175         /* 0x14 */ NULL,
 176         /* 0x15 */ NULL,
 177         /* 0x16 */ NULL,
 178         /* 0x17 */ NULL,
 179         /* 0x18 */ NULL,
 180         /* 0x19 */ NULL,
 181         /* 0x1a */ NULL,
 182         /* 0x1b */ NULL,
 183         /* 0x1c */ NULL,
 184         /* 0x1d */ NULL,
 185         /* 0x1e */ NULL,
 186         /* 0x1f */ NULL,
 187 };
 188
 189 static const u32 bass_table[41][5] = {
 190         { 0x3e4f844f, 0x84ed4cc3, 0x3cc69927, 0x7b03553a, 0xc4da8486 },
 191         { 0x3e69a17a, 0x84c280fb, 0x3cd77cd4, 0x7b2f2a6f, 0xc4b08d1d },
 192         { 0x3e82ff42, 0x849991d5, 0x3ce7466b, 0x7b5917c6, 0xc48863ee },
 193         { 0x3e9bab3c, 0x847267f0, 0x3cf5ffe8, 0x7b813560, 0xc461f22c },
 194         { 0x3eb3b275, 0x844ced29, 0x3d03b295, 0x7ba79a1c, 0xc43d223b },
 195         { 0x3ecb2174, 0x84290c8b, 0x3d106714, 0x7bcc5ba3, 0xc419dfa5 },
 196         { 0x3ee2044b, 0x8406b244, 0x3d1c2561, 0x7bef8e77, 0xc3f8170f },
 197         { 0x3ef86698, 0x83e5cb96, 0x3d26f4d8, 0x7c114600, 0xc3d7b625 },
 198         { 0x3f0e5390, 0x83c646c9, 0x3d30dc39, 0x7c319498, 0xc3b8ab97 },
 199         { 0x3f23d60b, 0x83a81321, 0x3d39e1af, 0x7c508b9c, 0xc39ae704 },
 200         { 0x3f38f884, 0x838b20d2, 0x3d420ad2, 0x7c6e3b75, 0xc37e58f1 },
 201         { 0x3f4dc52c, 0x836f60ef, 0x3d495cab, 0x7c8ab3a6, 0xc362f2be },
 202         { 0x3f6245e8, 0x8354c565, 0x3d4fdbb8, 0x7ca602d6, 0xc348a69b },
 203         { 0x3f76845f, 0x833b40ec, 0x3d558bf0, 0x7cc036df, 0xc32f677c },
 204         { 0x3f8a8a03, 0x8322c6fb, 0x3d5a70c4, 0x7cd95cd7, 0xc317290b },
 205         { 0x3f9e6014, 0x830b4bc3, 0x3d5e8d25, 0x7cf1811a, 0xc2ffdfa5 },
 206         { 0x3fb20fae, 0x82f4c420, 0x3d61e37f, 0x7d08af56, 0xc2e9804a },
 207         { 0x3fc5a1cc, 0x82df2592, 0x3d6475c3, 0x7d1ef294, 0xc2d40096 },
 208         { 0x3fd91f55, 0x82ca6632, 0x3d664564, 0x7d345541, 0xc2bf56b9 },
 209         { 0x3fec9120, 0x82b67cac, 0x3d675356, 0x7d48e138, 0xc2ab796e },
 210         { 0x40000000, 0x82a36037, 0x3d67a012, 0x7d5c9fc9, 0xc2985fee },
 211         { 0x401374c7, 0x8291088a, 0x3d672b93, 0x7d6f99c3, 0xc28601f2 },
 212         { 0x4026f857, 0x827f6dd7, 0x3d65f559, 0x7d81d77c, 0xc27457a3 },
 213         { 0x403a939f, 0x826e88c5, 0x3d63fc63, 0x7d9360d4, 0xc2635996 },
 214         { 0x404e4faf, 0x825e5266, 0x3d613f32, 0x7da43d42, 0xc25300c6 },
 215         { 0x406235ba, 0x824ec434, 0x3d5dbbc3, 0x7db473d7, 0xc243468e },
 216         { 0x40764f1f, 0x823fd80c, 0x3d596f8f, 0x7dc40b44, 0xc23424a2 },
 217         { 0x408aa576, 0x82318824, 0x3d545787, 0x7dd309e2, 0xc2259509 },
 218         { 0x409f4296, 0x8223cf0b, 0x3d4e7012, 0x7de175b5, 0xc2179218 },
 219         { 0x40b430a0, 0x8216a7a1, 0x3d47b505, 0x7def5475, 0xc20a1670 },
 220         { 0x40c97a0a, 0x820a0d12, 0x3d4021a1, 0x7dfcab8d, 0xc1fd1cf5 },
 221         { 0x40df29a6, 0x81fdfad6, 0x3d37b08d, 0x7e098028, 0xc1f0a0ca },
 222         { 0x40f54ab1, 0x81f26ca9, 0x3d2e5bd1, 0x7e15d72b, 0xc1e49d52 },
 223         { 0x410be8da, 0x81e75e89, 0x3d241cce, 0x7e21b544, 0xc1d90e24 },
 224         { 0x41231051, 0x81dcccb3, 0x3d18ec37, 0x7e2d1ee6, 0xc1cdef10 },
 225         { 0x413acdd0, 0x81d2b39e, 0x3d0cc20a, 0x7e38184e, 0xc1c33c13 },
 226         { 0x41532ea7, 0x81c90ffb, 0x3cff9585, 0x7e42a58b, 0xc1b8f15a },
 227         { 0x416c40cd, 0x81bfdeb2, 0x3cf15d21, 0x7e4cca7c, 0xc1af0b3f },
 228         { 0x418612ea, 0x81b71cdc, 0x3ce20e85, 0x7e568ad3, 0xc1a58640 },
 229         { 0x41a0b465, 0x81aec7c5, 0x3cd19e7c, 0x7e5fea1e, 0xc19c5f03 },
 230         { 0x41bc3573, 0x81a6dcea, 0x3cc000e9, 0x7e68ebc2, 0xc1939250 }
 231 };
 232
 233 static const u32 treble_table[41][5] = {
 234         { 0x0125cba9, 0xfed5debd, 0x00599b6c, 0x0d2506da, 0xfa85b354 },
 235         { 0x0142f67e, 0xfeb03163, 0x0066cd0f, 0x0d14c69d, 0xfa914473 },
 236         { 0x016328bd, 0xfe860158, 0x0075b7f2, 0x0d03eb27, 0xfa9d32d2 },
 237         { 0x0186b438, 0xfe56c982, 0x00869234, 0x0cf27048, 0xfaa97fca },
 238         { 0x01adf358, 0xfe21f5fe, 0x00999842, 0x0ce051c2, 0xfab62ca5 },
 239         { 0x01d949fa, 0xfde6e287, 0x00af0d8d, 0x0ccd8b4a, 0xfac33aa7 },
 240         { 0x02092669, 0xfda4d8bf, 0x00c73d4c, 0x0cba1884, 0xfad0ab07 },
 241         { 0x023e0268, 0xfd5b0e4a, 0x00e27b54, 0x0ca5f509, 0xfade7ef2 },
 242         { 0x0278645c, 0xfd08a2b0, 0x01012509, 0x0c911c63, 0xfaecb788 },
 243         { 0x02b8e091, 0xfcac9d1a, 0x0123a262, 0x0c7b8a14, 0xfafb55df },
 244         { 0x03001a9a, 0xfc45e9ce, 0x014a6709, 0x0c65398f, 0xfb0a5aff },
 245         { 0x034ec6d7, 0xfbd3576b, 0x0175f397, 0x0c4e2643, 0xfb19c7e4 },
 246         { 0x03a5ac15, 0xfb5393ee, 0x01a6d6ed, 0x0c364b94, 0xfb299d7c },
 247         { 0x0405a562, 0xfac52968, 0x01ddafae, 0x0c1da4e2, 0xfb39dca5 },
 248         { 0x046fa3fe, 0xfa267a66, 0x021b2ddd, 0x0c042d8d, 0xfb4a8631 },
 249         { 0x04e4b17f, 0xf975be0f, 0x0260149f, 0x0be9e0f2, 0xfb5b9ae0 },
 250         { 0x0565f220, 0xf8b0fbe5, 0x02ad3c29, 0x0bceba73, 0xfb6d1b60 },
 251         { 0x05f4a745, 0xf7d60722, 0x030393d4, 0x0bb2b578, 0xfb7f084d },
 252         { 0x06923236, 0xf6e279bd, 0x03642465, 0x0b95cd75, 0xfb916233 },
 253         { 0x07401713, 0xf5d3aef9, 0x03d01283, 0x0b77fded, 0xfba42984 },
 254         { 0x08000000, 0xf4a6bd88, 0x0448a161, 0x0b594278, 0xfbb75e9f },
 255         { 0x08d3c097, 0xf3587131, 0x04cf35a4, 0x0b3996c9, 0xfbcb01cb },
 256         { 0x09bd59a2, 0xf1e543f9, 0x05655880, 0x0b18f6b2, 0xfbdf1333 },
 257         { 0x0abefd0f, 0xf04956ca, 0x060cbb12, 0x0af75e2c, 0xfbf392e8 },
 258         { 0x0bdb123e, 0xee806984, 0x06c739fe, 0x0ad4c962, 0xfc0880dd },
 259         { 0x0d143a94, 0xec85d287, 0x0796e150, 0x0ab134b0, 0xfc1ddce5 },
 260         { 0x0e6d5664, 0xea547598, 0x087df0a0, 0x0a8c9cb6, 0xfc33a6ad },
 261         { 0x0fe98a2a, 0xe7e6ba35, 0x097edf83, 0x0a66fe5b, 0xfc49ddc2 },
 262         { 0x118c4421, 0xe536813a, 0x0a9c6248, 0x0a4056d7, 0xfc608185 },
 263         { 0x1359422e, 0xe23d19eb, 0x0bd96efb, 0x0a18a3bf, 0xfc77912c },
 264         { 0x1554982b, 0xdef33645, 0x0d3942bd, 0x09efe312, 0xfc8f0bc1 },
 265         { 0x1782b68a, 0xdb50deb1, 0x0ebf676d, 0x09c6133f, 0xfca6f019 },
 266         { 0x19e8715d, 0xd74d64fd, 0x106fb999, 0x099b3337, 0xfcbf3cd6 },
 267         { 0x1c8b07b8, 0xd2df56ab, 0x124e6ec8, 0x096f4274, 0xfcd7f060 },
 268         { 0x1f702b6d, 0xcdfc6e92, 0x14601c10, 0x0942410b, 0xfcf108e5 },
 269         { 0x229e0933, 0xc89985cd, 0x16a9bcfa, 0x09142fb5, 0xfd0a8451 },
 270         { 0x261b5118, 0xc2aa8409, 0x1930bab6, 0x08e50fdc, 0xfd24604d },
 271         { 0x29ef3f5d, 0xbc224f28, 0x1bfaf396, 0x08b4e3aa, 0xfd3e9a3b },
 272         { 0x2e21a59b, 0xb4f2ba46, 0x1f0ec2d6, 0x0883ae15, 0xfd592f33 },
 273         { 0x32baf44b, 0xad0c7429, 0x227308a3, 0x085172eb, 0xfd741bfd },
 274         { 0x37c4448b, 0xa45ef51d, 0x262f3267, 0x081e36dc, 0xfd8f5d14 }
 275 };
 276
 277 /* dB gain = (float) 20 * log10( float(db_table_value) / 0x8000000 ) */
 278 static const u32 db_table[101] = {
 279         0x00000000, 0x01571f82, 0x01674b41, 0x01783a1b, 0x0189f540,
 280         0x019c8651, 0x01aff763, 0x01c45306, 0x01d9a446, 0x01eff6b8,
 281         0x0207567a, 0x021fd03d, 0x0239714c, 0x02544792, 0x027061a1,
 282         0x028dcebb, 0x02ac9edc, 0x02cce2bf, 0x02eeabe8, 0x03120cb0,
 283         0x0337184e, 0x035de2df, 0x03868173, 0x03b10a18, 0x03dd93e9,
 284         0x040c3713, 0x043d0cea, 0x04702ff3, 0x04a5bbf2, 0x04ddcdfb,
 285         0x0518847f, 0x0555ff62, 0x05966005, 0x05d9c95d, 0x06206005,
 286         0x066a4a52, 0x06b7b067, 0x0708bc4c, 0x075d9a01, 0x07b6779d,
 287         0x08138561, 0x0874f5d5, 0x08dafde1, 0x0945d4ed, 0x09b5b4fd,
 288         0x0a2adad1, 0x0aa58605, 0x0b25f936, 0x0bac7a24, 0x0c3951d8,
 289         0x0ccccccc, 0x0d673b17, 0x0e08f093, 0x0eb24510, 0x0f639481,
 290         0x101d3f2d, 0x10dfa9e6, 0x11ab3e3f, 0x12806ac3, 0x135fa333,
 291         0x144960c5, 0x153e2266, 0x163e6cfe, 0x174acbb7, 0x1863d04d,
 292         0x198a1357, 0x1abe349f, 0x1c00db77, 0x1d52b712, 0x1eb47ee6,
 293         0x2026f30f, 0x21aadcb6, 0x23410e7e, 0x24ea64f9, 0x26a7c71d,
 294         0x287a26c4, 0x2a62812c, 0x2c61df84, 0x2e795779, 0x30aa0bcf,
 295         0x32f52cfe, 0x355bf9d8, 0x37dfc033, 0x3a81dda4, 0x3d43c038,
 296         0x4026e73c, 0x432ce40f, 0x46575af8, 0x49a8040f, 0x4d20ac2a,
 297         0x50c335d3, 0x54919a57, 0x588dead1, 0x5cba514a, 0x611911ea,
 298         0x65ac8c2f, 0x6a773c39, 0x6f7bbc23, 0x74bcc56c, 0x7a3d3272,
 299         0x7fffffff,
 300 };
 301
 302 /* EMU10k1/EMU10k2 DSP control db gain */
 303 static const DECLARE_TLV_DB_SCALE(snd_emu10k1_db_scale1, -4000, 40, 1);
 304 static const DECLARE_TLV_DB_LINEAR(snd_emu10k1_db_linear, TLV_DB_GAIN_MUTE, 0);
 305
 306 /* EMU10K1 bass/treble db gain */
 307 static const DECLARE_TLV_DB_SCALE(snd_emu10k1_bass_treble_db_scale, -1200, 60, 0);
 308
 309 static const u32 onoff_table[2] = {
 310         0x00000000, 0x00000001
 311 };
 312
 313 /*
 314  *   controls
 315  */
 316
 317 static int snd_emu10k1_gpr_ctl_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 318 {
 319         struct snd_emu10k1_fx8010_ctl *ctl =
 320                 (struct snd_emu10k1_fx8010_ctl *) kcontrol->private_value;
 321
 322         if (ctl->min == 0 && ctl->max == 1)
 323                 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
 324         else
 325                 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 326         uinfo->count = ctl->vcount;
 327         uinfo->value.integer.min = ctl->min;
 328         uinfo->value.integer.max = ctl->max;
 329         return 0;
 330 }
 331
 332 static int snd_emu10k1_gpr_ctl_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 333 {
 334         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
 335         struct snd_emu10k1_fx8010_ctl *ctl =
 336                 (struct snd_emu10k1_fx8010_ctl *) kcontrol->private_value;
 337         unsigned long flags;
 338         unsigned int i;
 339
 340         spin_lock_irqsave(&emu->reg_lock, flags);
 341         for (i = 0; i < ctl->vcount; i++)
 342                 ucontrol->value.integer.value[i] = ctl->value[i];
 343         spin_unlock_irqrestore(&emu->reg_lock, flags);
 344         return 0;
 345 }
 346
 347 static int snd_emu10k1_gpr_ctl_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 348 {
 349         struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol);
 350         struct snd_emu10k1_fx8010_ctl *ctl =
 351                 (struct snd_emu10k1_fx8010_ctl *) kcontrol->private_value;
 352         unsigned long flags;
 353         unsigned int nval, val;
 354         unsigned int i, j;
 355         int change = 0;
 356
 357         spin_lock_irqsave(&emu->reg_lock, flags);
 358         for (i = 0; i < ctl->vcount; i++) {
 359                 nval = ucontrol->value.integer.value[i];
 360                 if (nval < ctl->min)
 361                         nval = ctl->min;
 362                 if (nval > ctl->max)
 363                         nval = ctl->max;
 364                 if (nval != ctl->value[i])
 365                         change = 1;
 366                 val = ctl->value[i] = nval;
 367                 switch (ctl->translation) {
 368                 case EMU10K1_GPR_TRANSLATION_NONE:
 369                         snd_emu10k1_ptr_write(emu, emu->gpr_base + ctl->gpr[i], 0, val);
 370                         break;
 371                 case EMU10K1_GPR_TRANSLATION_TABLE100:
 372                         snd_emu10k1_ptr_write(emu, emu->gpr_base + ctl->gpr[i], 0, db_table[val]);
 373                         break;
 374                 case EMU10K1_GPR_TRANSLATION_BASS:
 375                         if ((ctl->count % 5) != 0 || (ctl->count / 5) != ctl->vcount) {
 376                                 change = -EIO;
 377                                 goto __error;
 378                         }
 379                         for (j = 0; j < 5; j++)
 380                                 snd_emu10k1_ptr_write(emu, emu->gpr_base + ctl->gpr[j * ctl->vcount + i], 0, bass_table[val][j]);
 381                         break;
 382                 case EMU10K1_GPR_TRANSLATION_TREBLE:
 383                         if ((ctl->count % 5) != 0 || (ctl->count / 5) != ctl->vcount) {
 384                                 change = -EIO;
 385                                 goto __error;
 386                         }
 387                         for (j = 0; j < 5; j++)
 388                                 snd_emu10k1_ptr_write(emu, emu->gpr_base + ctl->gpr[j * ctl->vcount + i], 0, treble_table[val][j]);
 389                         break;
 390                 case EMU10K1_GPR_TRANSLATION_ONOFF:
 391                         snd_emu10k1_ptr_write(emu, emu->gpr_base + ctl->gpr[i], 0, onoff_table[val]);
 392                         break;
 393                 }
 394         }
 395       __error:
 396         spin_unlock_irqrestore(&emu->reg_lock, flags);
 397         return change;
 398 }
 399
 400 /*
 401  *   Interrupt handler
 402  */
 403
 404 static void snd_emu10k1_fx8010_interrupt(struct snd_emu10k1 *emu)
 405 {
 406         struct snd_emu10k1_fx8010_irq *irq, *nirq;
 407
 408         irq = emu->fx8010.irq_handlers;
 409         while (irq) {
 410                 nirq = irq->next;       /* irq ptr can be removed from list */
 411                 if (snd_emu10k1_ptr_read(emu, emu->gpr_base + irq->gpr_running, 0) & 0xffff0000) {
 412                         if (irq->handler)
 413                                 irq->handler(emu, irq->private_data);
 414                         snd_emu10k1_ptr_write(emu, emu->gpr_base + irq->gpr_running, 0, 1);
 415                 }
 416                 irq = nirq;
 417         }
 418 }
 419
 420 int snd_emu10k1_fx8010_register_irq_handler(struct snd_emu10k1 *emu,
 421                                             snd_fx8010_irq_handler_t *handler,
 422                                             unsigned char gpr_running,
 423                                             void *private_data,
 424                                             struct snd_emu10k1_fx8010_irq **r_irq)
 425 {
 426         struct snd_emu10k1_fx8010_irq *irq;
 427         unsigned long flags;
 428
 429         irq = kmalloc(sizeof(*irq), GFP_ATOMIC);
 430         if (irq == NULL)
 431                 return -ENOMEM;
 432         irq->handler = handler;
 433         irq->gpr_running = gpr_running;
 434         irq->private_data = private_data;
 435         irq->next = NULL;
 436         spin_lock_irqsave(&emu->fx8010.irq_lock, flags);
 437         if (emu->fx8010.irq_handlers == NULL) {
 438                 emu->fx8010.irq_handlers = irq;
 439                 emu->dsp_interrupt = snd_emu10k1_fx8010_interrupt;
 440                 snd_emu10k1_intr_enable(emu, INTE_FXDSPENABLE);
 441         } else {
 442                 irq->next = emu->fx8010.irq_handlers;
 443                 emu->fx8010.irq_handlers = irq;
 444         }
 445         spin_unlock_irqrestore(&emu->fx8010.irq_lock, flags);
 446         if (r_irq)
 447                 *r_irq = irq;
 448         return 0;
 449 }
 450
 451 int snd_emu10k1_fx8010_unregister_irq_handler(struct snd_emu10k1 *emu,
 452                                               struct snd_emu10k1_fx8010_irq *irq)
 453 {
 454         struct snd_emu10k1_fx8010_irq *tmp;
 455         unsigned long flags;
 456
 457         spin_lock_irqsave(&emu->fx8010.irq_lock, flags);
 458         if ((tmp = emu->fx8010.irq_handlers) == irq) {
 459                 emu->fx8010.irq_handlers = tmp->next;
 460                 if (emu->fx8010.irq_handlers == NULL) {
 461                         snd_emu10k1_intr_disable(emu, INTE_FXDSPENABLE);
 462                         emu->dsp_interrupt = NULL;
 463                 }
 464         } else {
 465                 while (tmp && tmp->next != irq)
 466                         tmp = tmp->next;
 467                 if (tmp)
 468                         tmp->next = tmp->next->next;
 469         }
 470         spin_unlock_irqrestore(&emu->fx8010.irq_lock, flags);
 471         kfree(irq);
 472         return 0;
 473 }
 474
 475 /*************************************************************************
 476  * EMU10K1 effect manager
 477  *************************************************************************/
 478
 479 static void snd_emu10k1_write_op(struct snd_emu10k1_fx8010_code *icode,
 480                                  unsigned int *ptr,
 481                                  u32 op, u32 r, u32 a, u32 x, u32 y)
 482 {
 483         u_int32_t *code;
 484         if (snd_BUG_ON(*ptr >= 512))
 485                 return;
 486         code = (u_int32_t __force *)icode->code + (*ptr) * 2;
 487         set_bit(*ptr, icode->code_valid);
 488         code[0] = ((x & 0x3ff) << 10) | (y & 0x3ff);
 489         code[1] = ((op & 0x0f) << 20) | ((r & 0x3ff) << 10) | (a & 0x3ff);
 490         (*ptr)++;
 491 }
 492
 493 #define OP(icode, ptr, op, r, a, x, y) \
 494         snd_emu10k1_write_op(icode, ptr, op, r, a, x, y)
 495
 496 static void snd_emu10k1_audigy_write_op(struct snd_emu10k1_fx8010_code *icode,
 497                                         unsigned int *ptr,
 498                                         u32 op, u32 r, u32 a, u32 x, u32 y)
 499 {
 500         u_int32_t *code;
 501         if (snd_BUG_ON(*ptr >= 1024))
 502                 return;
 503         code = (u_int32_t __force *)icode->code + (*ptr) * 2;
 504         set_bit(*ptr, icode->code_valid);
 505         code[0] = ((x & 0x7ff) << 12) | (y & 0x7ff);
 506         code[1] = ((op & 0x0f) << 24) | ((r & 0x7ff) << 12) | (a & 0x7ff);
 507         (*ptr)++;
 508 }
 509
 510 #define A_OP(icode, ptr, op, r, a, x, y) \
 511         snd_emu10k1_audigy_write_op(icode, ptr, op, r, a, x, y)
 512
 513 static void snd_emu10k1_efx_write(struct snd_emu10k1 *emu, unsigned int pc, unsigned int data)
 514 {
 515         pc += emu->audigy ? A_MICROCODEBASE : MICROCODEBASE;
 516         snd_emu10k1_ptr_write(emu, pc, 0, data);
 517 }
 518
 519 unsigned int snd_emu10k1_efx_read(struct snd_emu10k1 *emu, unsigned int pc)
 520 {
 521         pc += emu->audigy ? A_MICROCODEBASE : MICROCODEBASE;
 522         return snd_emu10k1_ptr_read(emu, pc, 0);
 523 }
 524
 525 static int snd_emu10k1_gpr_poke(struct snd_emu10k1 *emu,
 526                                 struct snd_emu10k1_fx8010_code *icode,
 527                                 bool in_kernel)
 528 {
 529         int gpr;
 530         u32 val;
 531
 532         for (gpr = 0; gpr < (emu->audigy ? 0x200 : 0x100); gpr++) {
 533                 if (!test_bit(gpr, icode->gpr_valid))
 534                         continue;
 535                 if (in_kernel)
 536                         val = *(u32 *)&icode->gpr_map[gpr];
 537                 else if (get_user(val, &icode->gpr_map[gpr]))
 538                         return -EFAULT;
 539                 snd_emu10k1_ptr_write(emu, emu->gpr_base + gpr, 0, val);
 540         }
 541         return 0;
 542 }
 543
 544 static int snd_emu10k1_gpr_peek(struct snd_emu10k1 *emu,
 545                                 struct snd_emu10k1_fx8010_code *icode)
 546 {
 547         int gpr;
 548         u32 val;
 549
 550         for (gpr = 0; gpr < (emu->audigy ? 0x200 : 0x100); gpr++) {
 551                 set_bit(gpr, icode->gpr_valid);
 552                 val = snd_emu10k1_ptr_read(emu, emu->gpr_base + gpr, 0);
 553                 if (put_user(val, &icode->gpr_map[gpr]))
 554                         return -EFAULT;
 555         }
 556         return 0;
 557 }
 558
 559 static int snd_emu10k1_tram_poke(struct snd_emu10k1 *emu,
 560                                  struct snd_emu10k1_fx8010_code *icode,
 561                                  bool in_kernel)
 562 {
 563         int tram;
 564         u32 addr, val;
 565
 566         for (tram = 0; tram < (emu->audigy ? 0x100 : 0xa0); tram++) {
 567                 if (!test_bit(tram, icode->tram_valid))
 568                         continue;
 569                 if (in_kernel) {
 570                         val = *(u32 *)&icode->tram_data_map[tram];
 571                         addr = *(u32 *)&icode->tram_addr_map[tram];
 572                 } else {
 573                         if (get_user(val, &icode->tram_data_map[tram]) ||
 574                             get_user(addr, &icode->tram_addr_map[tram]))
 575                                 return -EFAULT;
 576                 }
 577                 snd_emu10k1_ptr_write(emu, TANKMEMDATAREGBASE + tram, 0, val);
 578                 if (!emu->audigy) {
 579                         snd_emu10k1_ptr_write(emu, TANKMEMADDRREGBASE + tram, 0, addr);
 580                 } else {
 581                         snd_emu10k1_ptr_write(emu, TANKMEMADDRREGBASE + tram, 0, addr << 12);
 582                         snd_emu10k1_ptr_write(emu, A_TANKMEMCTLREGBASE + tram, 0, addr >> 20);
 583                 }
 584         }
 585         return 0;
 586 }
 587
 588 static int snd_emu10k1_tram_peek(struct snd_emu10k1 *emu,
 589                                  struct snd_emu10k1_fx8010_code *icode)
 590 {
 591         int tram;
 592         u32 val, addr;
 593
 594         memset(icode->tram_valid, 0, sizeof(icode->tram_valid));
 595         for (tram = 0; tram < (emu->audigy ? 0x100 : 0xa0); tram++) {
 596                 set_bit(tram, icode->tram_valid);
 597                 val = snd_emu10k1_ptr_read(emu, TANKMEMDATAREGBASE + tram, 0);
 598                 if (!emu->audigy) {
 599                         addr = snd_emu10k1_ptr_read(emu, TANKMEMADDRREGBASE + tram, 0);
 600                 } else {
 601                         addr = snd_emu10k1_ptr_read(emu, TANKMEMADDRREGBASE + tram, 0) >> 12;
 602                         addr |= snd_emu10k1_ptr_read(emu, A_TANKMEMCTLREGBASE + tram, 0) << 20;
 603                 }
 604                 if (put_user(val, &icode->tram_data_map[tram]) ||
 605                     put_user(addr, &icode->tram_addr_map[tram]))
 606                         return -EFAULT;
 607         }
 608         return 0;
 609 }
 610
 611 static int snd_emu10k1_code_poke(struct snd_emu10k1 *emu,
 612                                  struct snd_emu10k1_fx8010_code *icode,
 613                                  bool in_kernel)
 614 {
 615         u32 pc, lo, hi;
 616
 617         for (pc = 0; pc < (emu->audigy ? 2*1024 : 2*512); pc += 2) {
 618                 if (!test_bit(pc / 2, icode->code_valid))
 619                         continue;
 620                 if (in_kernel) {
 621                         lo = *(u32 *)&icode->code[pc + 0];
 622                         hi = *(u32 *)&icode->code[pc + 1];
 623                 } else {
 624                         if (get_user(lo, &icode->code[pc + 0]) ||
 625                             get_user(hi, &icode->code[pc + 1]))
 626                                 return -EFAULT;
 627                 }
 628                 snd_emu10k1_efx_write(emu, pc + 0, lo);
 629                 snd_emu10k1_efx_write(emu, pc + 1, hi);
 630         }
 631         return 0;
 632 }
 633
 634 static int snd_emu10k1_code_peek(struct snd_emu10k1 *emu,
 635                                  struct snd_emu10k1_fx8010_code *icode)
 636 {
 637         u32 pc;
 638
 639         memset(icode->code_valid, 0, sizeof(icode->code_valid));
 640         for (pc = 0; pc < (emu->audigy ? 2*1024 : 2*512); pc += 2) {
 641                 set_bit(pc / 2, icode->code_valid);
 642                 if (put_user(snd_emu10k1_efx_read(emu, pc + 0), &icode->code[pc + 0]))
 643                         return -EFAULT;
 644                 if (put_user(snd_emu10k1_efx_read(emu, pc + 1), &icode->code[pc + 1]))
 645                         return -EFAULT;
 646         }
 647         return 0;
 648 }
 649
 650 static struct snd_emu10k1_fx8010_ctl *
 651 snd_emu10k1_look_for_ctl(struct snd_emu10k1 *emu, struct snd_ctl_elem_id *id)
 652 {
 653         struct snd_emu10k1_fx8010_ctl *ctl;
 654         struct snd_kcontrol *kcontrol;
 655
 656         list_for_each_entry(ctl, &emu->fx8010.gpr_ctl, list) {
 657                 kcontrol = ctl->kcontrol;
 658                 if (kcontrol->id.iface == id->iface &&
 659                     !strcmp(kcontrol->id.name, id->name) &&
 660                     kcontrol->id.index == id->index)
 661                         return ctl;
 662         }
 663         return NULL;
 664 }
 665
 666 #define MAX_TLV_SIZE    256
 667
 668 static unsigned int *copy_tlv(const unsigned int __user *_tlv, bool in_kernel)
 669 {
 670         unsigned int data[2];
 671         unsigned int *tlv;
 672
 673         if (!_tlv)
 674                 return NULL;
 675         if (in_kernel)
 676                 memcpy(data, (void *)_tlv, sizeof(data));
 677         else if (copy_from_user(data, _tlv, sizeof(data)))
 678                 return NULL;
 679         if (data[1] >= MAX_TLV_SIZE)
 680                 return NULL;
 681         tlv = kmalloc(data[1] + sizeof(data), GFP_KERNEL);
 682         if (!tlv)
 683                 return NULL;
 684         memcpy(tlv, data, sizeof(data));
 685         if (in_kernel) {
 686                 memcpy(tlv + 2, (void *)(_tlv + 2),  data[1]);
 687         } else if (copy_from_user(tlv + 2, _tlv + 2, data[1])) {
 688                 kfree(tlv);
 689                 return NULL;
 690         }
 691         return tlv;
 692 }
 693
 694 static int copy_gctl(struct snd_emu10k1 *emu,
 695                      struct snd_emu10k1_fx8010_control_gpr *gctl,
 696                      struct snd_emu10k1_fx8010_control_gpr __user *_gctl,
 697                      int idx, bool in_kernel)
 698 {
 699         struct snd_emu10k1_fx8010_control_old_gpr __user *octl;
 700
 701         if (emu->support_tlv)
 702                 return copy_from_user(gctl, &_gctl[idx], sizeof(*gctl));
 703         octl = (struct snd_emu10k1_fx8010_control_old_gpr __user *)_gctl;
 704         if (copy_from_user(gctl, &octl[idx], sizeof(*octl)))
 705                 return -EFAULT;
 706         gctl->tlv = NULL;
 707         return 0;
 708 }
 709
 710 static int copy_gctl_to_user(struct snd_emu10k1 *emu,
 711                      struct snd_emu10k1_fx8010_control_gpr __user *_gctl,
 712                      struct snd_emu10k1_fx8010_control_gpr *gctl,
 713                      int idx)
 714 {
 715         struct snd_emu10k1_fx8010_control_old_gpr __user *octl;
 716
 717         if (emu->support_tlv)
 718                 return copy_to_user(&_gctl[idx], gctl, sizeof(*gctl));
 719
 720         octl = (struct snd_emu10k1_fx8010_control_old_gpr __user *)_gctl;
 721         return copy_to_user(&octl[idx], gctl, sizeof(*octl));
 722 }
 723
 724 static int snd_emu10k1_verify_controls(struct snd_emu10k1 *emu,
 725                                        struct snd_emu10k1_fx8010_code *icode,
 726                                        bool in_kernel)
 727 {
 728         unsigned int i;
 729         struct snd_ctl_elem_id __user *_id;
 730         struct snd_ctl_elem_id id;
 731         struct snd_emu10k1_fx8010_control_gpr *gctl;
 732         int err;
 733
 734         for (i = 0, _id = icode->gpr_del_controls;
 735              i < icode->gpr_del_control_count; i++, _id++) {
 736                 if (in_kernel)
 737                         id = *(struct snd_ctl_elem_id *)_id;
 738                 else if (copy_from_user(&id, _id, sizeof(id)))
 739                         return -EFAULT;
 740                 if (snd_emu10k1_look_for_ctl(emu, &id) == NULL)
 741                         return -ENOENT;
 742         }
 743         gctl = kmalloc(sizeof(*gctl), GFP_KERNEL);
 744         if (! gctl)
 745                 return -ENOMEM;
 746         err = 0;
 747         for (i = 0; i < icode->gpr_add_control_count; i++) {
 748                 if (copy_gctl(emu, gctl, icode->gpr_add_controls, i,
 749                               in_kernel)) {
 750                         err = -EFAULT;
 751                         goto __error;
 752                 }
 753                 if (snd_emu10k1_look_for_ctl(emu, &gctl->id))
 754                         continue;
 755                 down_read(&emu->card->controls_rwsem);
 756                 if (snd_ctl_find_id(emu->card, &gctl->id) != NULL) {
 757                         up_read(&emu->card->controls_rwsem);
 758                         err = -EEXIST;
 759                         goto __error;
 760                 }
 761                 up_read(&emu->card->controls_rwsem);
 762                 if (gctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER &&
 763                     gctl->id.iface != SNDRV_CTL_ELEM_IFACE_PCM) {
 764                         err = -EINVAL;
 765                         goto __error;
 766                 }
 767         }
 768         for (i = 0; i < icode->gpr_list_control_count; i++) {
 769                 /* FIXME: we need to check the WRITE access */
 770                 if (copy_gctl(emu, gctl, icode->gpr_list_controls, i,
 771                               in_kernel)) {
 772                         err = -EFAULT;
 773                         goto __error;
 774                 }
 775         }
 776  __error:
 777         kfree(gctl);
 778         return err;
 779 }
 780
 781 static void snd_emu10k1_ctl_private_free(struct snd_kcontrol *kctl)
 782 {
 783         struct snd_emu10k1_fx8010_ctl *ctl;
 784
 785         ctl = (struct snd_emu10k1_fx8010_ctl *) kctl->private_value;
 786         kctl->private_value = 0;
 787         list_del(&ctl->list);
 788         kfree(ctl);
 789         kfree(kctl->tlv.p);
 790 }
 791
 792 static int snd_emu10k1_add_controls(struct snd_emu10k1 *emu,
 793                                     struct snd_emu10k1_fx8010_code *icode,
 794                                     bool in_kernel)
 795 {
 796         unsigned int i, j;
 797         struct snd_emu10k1_fx8010_control_gpr *gctl;
 798         struct snd_emu10k1_fx8010_ctl *ctl, *nctl;
 799         struct snd_kcontrol_new knew;
 800         struct snd_kcontrol *kctl;
 801         struct snd_ctl_elem_value *val;
 802         int err = 0;
 803
 804         val = kmalloc(sizeof(*val), GFP_KERNEL);
 805         gctl = kmalloc(sizeof(*gctl), GFP_KERNEL);
 806         nctl = kmalloc(sizeof(*nctl), GFP_KERNEL);
 807         if (!val || !gctl || !nctl) {
 808                 err = -ENOMEM;
 809                 goto __error;
 810         }
 811
 812         for (i = 0; i < icode->gpr_add_control_count; i++) {
 813                 if (copy_gctl(emu, gctl, icode->gpr_add_controls, i,
 814                               in_kernel)) {
 815                         err = -EFAULT;
 816                         goto __error;
 817                 }
 818                 if (gctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER &&
 819                     gctl->id.iface != SNDRV_CTL_ELEM_IFACE_PCM) {
 820                         err = -EINVAL;
 821                         goto __error;
 822                 }
 823                 if (! gctl->id.name[0]) {
 824                         err = -EINVAL;
 825                         goto __error;
 826                 }
 827                 ctl = snd_emu10k1_look_for_ctl(emu, &gctl->id);
 828                 memset(&knew, 0, sizeof(knew));
 829                 knew.iface = gctl->id.iface;
 830                 knew.name = gctl->id.name;
 831                 knew.index = gctl->id.index;
 832                 knew.device = gctl->id.device;
 833                 knew.subdevice = gctl->id.subdevice;
 834                 knew.info = snd_emu10k1_gpr_ctl_info;
 835                 knew.tlv.p = copy_tlv(gctl->tlv, in_kernel);
 836                 if (knew.tlv.p)
 837                         knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
 838                                 SNDRV_CTL_ELEM_ACCESS_TLV_READ;
 839                 knew.get = snd_emu10k1_gpr_ctl_get;
 840                 knew.put = snd_emu10k1_gpr_ctl_put;
 841                 memset(nctl, 0, sizeof(*nctl));
 842                 nctl->vcount = gctl->vcount;
 843                 nctl->count = gctl->count;
 844                 for (j = 0; j < 32; j++) {
 845                         nctl->gpr[j] = gctl->gpr[j];
 846                         nctl->value[j] = ~gctl->value[j];       /* inverted, we want to write new value in gpr_ctl_put() */
 847                         val->value.integer.value[j] = gctl->value[j];
 848                 }
 849                 nctl->min = gctl->min;
 850                 nctl->max = gctl->max;
 851                 nctl->translation = gctl->translation;
 852                 if (ctl == NULL) {
 853                         ctl = kmalloc(sizeof(*ctl), GFP_KERNEL);
 854                         if (ctl == NULL) {
 855                                 err = -ENOMEM;
 856                                 kfree(knew.tlv.p);
 857                                 goto __error;
 858                         }
 859                         knew.private_value = (unsigned long)ctl;
 860                         *ctl = *nctl;
 861                         if ((err = snd_ctl_add(emu->card, kctl = snd_ctl_new1(&knew, emu))) < 0) {
 862                                 kfree(ctl);
 863                                 kfree(knew.tlv.p);
 864                                 goto __error;
 865                         }
 866                         kctl->private_free = snd_emu10k1_ctl_private_free;
 867                         ctl->kcontrol = kctl;
 868                         list_add_tail(&ctl->list, &emu->fx8010.gpr_ctl);
 869                 } else {
 870                         /* overwrite */
 871                         nctl->list = ctl->list;
 872                         nctl->kcontrol = ctl->kcontrol;
 873                         *ctl = *nctl;
 874                         snd_ctl_notify(emu->card, SNDRV_CTL_EVENT_MASK_VALUE |
 875                                                   SNDRV_CTL_EVENT_MASK_INFO, &ctl->kcontrol->id);
 876                 }
 877                 snd_emu10k1_gpr_ctl_put(ctl->kcontrol, val);
 878         }
 879       __error:
 880         kfree(nctl);
 881         kfree(gctl);
 882         kfree(val);
 883         return err;
 884 }
 885
 886 static int snd_emu10k1_del_controls(struct snd_emu10k1 *emu,
 887                                     struct snd_emu10k1_fx8010_code *icode,
 888                                     bool in_kernel)
 889 {
 890         unsigned int i;
 891         struct snd_ctl_elem_id id;
 892         struct snd_ctl_elem_id __user *_id;
 893         struct snd_emu10k1_fx8010_ctl *ctl;
 894         struct snd_card *card = emu->card;
 895
 896         for (i = 0, _id = icode->gpr_del_controls;
 897              i < icode->gpr_del_control_count; i++, _id++) {
 898                 if (in_kernel)
 899                         id = *(struct snd_ctl_elem_id *)_id;
 900                 else if (copy_from_user(&id, _id, sizeof(id)))
 901                         return -EFAULT;
 902                 down_write(&card->controls_rwsem);
 903                 ctl = snd_emu10k1_look_for_ctl(emu, &id);
 904                 if (ctl)
 905                         snd_ctl_remove(card, ctl->kcontrol);
 906                 up_write(&card->controls_rwsem);
 907         }
 908         return 0;
 909 }
 910
 911 static int snd_emu10k1_list_controls(struct snd_emu10k1 *emu,
 912                                      struct snd_emu10k1_fx8010_code *icode)
 913 {
 914         unsigned int i = 0, j;
 915         unsigned int total = 0;
 916         struct snd_emu10k1_fx8010_control_gpr *gctl;
 917         struct snd_emu10k1_fx8010_ctl *ctl;
 918         struct snd_ctl_elem_id *id;
 919
 920         gctl = kmalloc(sizeof(*gctl), GFP_KERNEL);
 921         if (! gctl)
 922                 return -ENOMEM;
 923
 924         list_for_each_entry(ctl, &emu->fx8010.gpr_ctl, list) {
 925                 total++;
 926                 if (icode->gpr_list_controls &&
 927                     i < icode->gpr_list_control_count) {
 928                         memset(gctl, 0, sizeof(*gctl));
 929                         id = &ctl->kcontrol->id;
 930                         gctl->id.iface = id->iface;
 931                         strlcpy(gctl->id.name, id->name, sizeof(gctl->id.name));
 932                         gctl->id.index = id->index;
 933                         gctl->id.device = id->device;
 934                         gctl->id.subdevice = id->subdevice;
 935                         gctl->vcount = ctl->vcount;
 936                         gctl->count = ctl->count;
 937                         for (j = 0; j < 32; j++) {
 938                                 gctl->gpr[j] = ctl->gpr[j];
 939                                 gctl->value[j] = ctl->value[j];
 940                         }
 941                         gctl->min = ctl->min;
 942                         gctl->max = ctl->max;
 943                         gctl->translation = ctl->translation;
 944                         if (copy_gctl_to_user(emu, icode->gpr_list_controls,
 945                                               gctl, i)) {
 946                                 kfree(gctl);
 947                                 return -EFAULT;
 948                         }
 949                         i++;
 950                 }
 951         }
 952         icode->gpr_list_control_total = total;
 953         kfree(gctl);
 954         return 0;
 955 }
 956
 957 static int snd_emu10k1_icode_poke(struct snd_emu10k1 *emu,
 958                                   struct snd_emu10k1_fx8010_code *icode,
 959                                   bool in_kernel)
 960 {
 961         int err = 0;
 962
 963         mutex_lock(&emu->fx8010.lock);
 964         err = snd_emu10k1_verify_controls(emu, icode, in_kernel);
 965         if (err < 0)
 966                 goto __error;
 967         strlcpy(emu->fx8010.name, icode->name, sizeof(emu->fx8010.name));
 968         /* stop FX processor - this may be dangerous, but it's better to miss
 969            some samples than generate wrong ones - [jk] */
 970         if (emu->audigy)
 971                 snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg | A_DBG_SINGLE_STEP);
 972         else
 973                 snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg | EMU10K1_DBG_SINGLE_STEP);
 974         /* ok, do the main job */
 975         err = snd_emu10k1_del_controls(emu, icode, in_kernel);
 976         if (err < 0)
 977                 goto __error;
 978         err = snd_emu10k1_gpr_poke(emu, icode, in_kernel);
 979         if (err < 0)
 980                 goto __error;
 981         err = snd_emu10k1_tram_poke(emu, icode, in_kernel);
 982         if (err < 0)
 983                 goto __error;
 984         err = snd_emu10k1_code_poke(emu, icode, in_kernel);
 985         if (err < 0)
 986                 goto __error;
 987         err = snd_emu10k1_add_controls(emu, icode, in_kernel);
 988         if (err < 0)
 989                 goto __error;
 990         /* start FX processor when the DSP code is updated */
 991         if (emu->audigy)
 992                 snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg);
 993         else
 994                 snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg);
 995       __error:
 996         mutex_unlock(&emu->fx8010.lock);
 997         return err;
 998 }
 999
1000 static int snd_emu10k1_icode_peek(struct snd_emu10k1 *emu,
1001                                   struct snd_emu10k1_fx8010_code *icode)
1002 {
1003         int err;
1004
1005         mutex_lock(&emu->fx8010.lock);
1006         strlcpy(icode->name, emu->fx8010.name, sizeof(icode->name));
1007         /* ok, do the main job */
1008         err = snd_emu10k1_gpr_peek(emu, icode);
1009         if (err >= 0)
1010                 err = snd_emu10k1_tram_peek(emu, icode);
1011         if (err >= 0)
1012                 err = snd_emu10k1_code_peek(emu, icode);
1013         if (err >= 0)
1014                 err = snd_emu10k1_list_controls(emu, icode);
1015         mutex_unlock(&emu->fx8010.lock);
1016         return err;
1017 }
1018
1019 static int snd_emu10k1_ipcm_poke(struct snd_emu10k1 *emu,
1020                                  struct snd_emu10k1_fx8010_pcm_rec *ipcm)
1021 {
1022         unsigned int i;
1023         int err = 0;
1024         struct snd_emu10k1_fx8010_pcm *pcm;
1025
1026         if (ipcm->substream >= EMU10K1_FX8010_PCM_COUNT)
1027                 return -EINVAL;
1028         if (ipcm->channels > 32)
1029                 return -EINVAL;
1030         pcm = &emu->fx8010.pcm[ipcm->substream];
1031         mutex_lock(&emu->fx8010.lock);
1032         spin_lock_irq(&emu->reg_lock);
1033         if (pcm->opened) {
1034                 err = -EBUSY;
1035                 goto __error;
1036         }
1037         if (ipcm->channels == 0) {      /* remove */
1038                 pcm->valid = 0;
1039         } else {
1040                 /* FIXME: we need to add universal code to the PCM transfer routine */
1041                 if (ipcm->channels != 2) {
1042                         err = -EINVAL;
1043                         goto __error;
1044                 }
1045                 pcm->valid = 1;
1046                 pcm->opened = 0;
1047                 pcm->channels = ipcm->channels;
1048                 pcm->tram_start = ipcm->tram_start;
1049                 pcm->buffer_size = ipcm->buffer_size;
1050                 pcm->gpr_size = ipcm->gpr_size;
1051                 pcm->gpr_count = ipcm->gpr_count;
1052                 pcm->gpr_tmpcount = ipcm->gpr_tmpcount;
1053                 pcm->gpr_ptr = ipcm->gpr_ptr;
1054                 pcm->gpr_trigger = ipcm->gpr_trigger;
1055                 pcm->gpr_running = ipcm->gpr_running;
1056                 for (i = 0; i < pcm->channels; i++)
1057                         pcm->etram[i] = ipcm->etram[i];
1058         }
1059       __error:
1060         spin_unlock_irq(&emu->reg_lock);
1061         mutex_unlock(&emu->fx8010.lock);
1062         return err;
1063 }
1064
1065 static int snd_emu10k1_ipcm_peek(struct snd_emu10k1 *emu,
1066                                  struct snd_emu10k1_fx8010_pcm_rec *ipcm)
1067 {
1068         unsigned int i;
1069         int err = 0;
1070         struct snd_emu10k1_fx8010_pcm *pcm;
1071
1072         if (ipcm->substream >= EMU10K1_FX8010_PCM_COUNT)
1073                 return -EINVAL;
1074         pcm = &emu->fx8010.pcm[ipcm->substream];
1075         mutex_lock(&emu->fx8010.lock);
1076         spin_lock_irq(&emu->reg_lock);
1077         ipcm->channels = pcm->channels;
1078         ipcm->tram_start = pcm->tram_start;
1079         ipcm->buffer_size = pcm->buffer_size;
1080         ipcm->gpr_size = pcm->gpr_size;
1081         ipcm->gpr_ptr = pcm->gpr_ptr;
1082         ipcm->gpr_count = pcm->gpr_count;
1083         ipcm->gpr_tmpcount = pcm->gpr_tmpcount;
1084         ipcm->gpr_trigger = pcm->gpr_trigger;
1085         ipcm->gpr_running = pcm->gpr_running;
1086         for (i = 0; i < pcm->channels; i++)
1087                 ipcm->etram[i] = pcm->etram[i];
1088         ipcm->res1 = ipcm->res2 = 0;
1089         ipcm->pad = 0;
1090         spin_unlock_irq(&emu->reg_lock);
1091         mutex_unlock(&emu->fx8010.lock);
1092         return err;
1093 }
1094
1095 #define SND_EMU10K1_GPR_CONTROLS        44
1096 #define SND_EMU10K1_INPUTS              12
1097 #define SND_EMU10K1_PLAYBACK_CHANNELS   8
1098 #define SND_EMU10K1_CAPTURE_CHANNELS    4
1099
1100 static void
1101 snd_emu10k1_init_mono_control(struct snd_emu10k1_fx8010_control_gpr *ctl,
1102                               const char *name, int gpr, int defval)
1103 {
1104         ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1105         strcpy(ctl->id.name, name);
1106         ctl->vcount = ctl->count = 1;
1107         ctl->gpr[0] = gpr + 0; ctl->value[0] = defval;
1108         if (high_res_gpr_volume) {
1109                 ctl->min = 0;
1110                 ctl->max = 0x7fffffff;
1111                 ctl->tlv = snd_emu10k1_db_linear;
1112                 ctl->translation = EMU10K1_GPR_TRANSLATION_NONE;
1113         } else {
1114                 ctl->min = 0;
1115                 ctl->max = 100;
1116                 ctl->tlv = snd_emu10k1_db_scale1;
1117                 ctl->translation = EMU10K1_GPR_TRANSLATION_TABLE100;
1118         }
1119 }
1120
1121 static void
1122 snd_emu10k1_init_stereo_control(struct snd_emu10k1_fx8010_control_gpr *ctl,
1123                                 const char *name, int gpr, int defval)
1124 {
1125         ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1126         strcpy(ctl->id.name, name);
1127         ctl->vcount = ctl->count = 2;
1128         ctl->gpr[0] = gpr + 0; ctl->value[0] = defval;
1129         ctl->gpr[1] = gpr + 1; ctl->value[1] = defval;
1130         if (high_res_gpr_volume) {
1131                 ctl->min = 0;
1132                 ctl->max = 0x7fffffff;
1133                 ctl->tlv = snd_emu10k1_db_linear;
1134                 ctl->translation = EMU10K1_GPR_TRANSLATION_NONE;
1135         } else {
1136                 ctl->min = 0;
1137                 ctl->max = 100;
1138                 ctl->tlv = snd_emu10k1_db_scale1;
1139                 ctl->translation = EMU10K1_GPR_TRANSLATION_TABLE100;
1140         }
1141 }
1142
1143 static void
1144 snd_emu10k1_init_mono_onoff_control(struct snd_emu10k1_fx8010_control_gpr *ctl,
1145                                     const char *name, int gpr, int defval)
1146 {
1147         ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1148         strcpy(ctl->id.name, name);
1149         ctl->vcount = ctl->count = 1;
1150         ctl->gpr[0] = gpr + 0; ctl->value[0] = defval;
1151         ctl->min = 0;
1152         ctl->max = 1;
1153         ctl->translation = EMU10K1_GPR_TRANSLATION_ONOFF;
1154 }
1155
1156 static void
1157 snd_emu10k1_init_stereo_onoff_control(struct snd_emu10k1_fx8010_control_gpr *ctl,
1158                                       const char *name, int gpr, int defval)
1159 {
1160         ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1161         strcpy(ctl->id.name, name);
1162         ctl->vcount = ctl->count = 2;
1163         ctl->gpr[0] = gpr + 0; ctl->value[0] = defval;
1164         ctl->gpr[1] = gpr + 1; ctl->value[1] = defval;
1165         ctl->min = 0;
1166         ctl->max = 1;
1167         ctl->translation = EMU10K1_GPR_TRANSLATION_ONOFF;
1168 }
1169
1170 /*
1171  * Used for emu1010 - conversion from 32-bit capture inputs from HANA
1172  * to 2 x 16-bit registers in audigy - their values are read via DMA.
1173  * Conversion is performed by Audigy DSP instructions of FX8010.
1174  */
1175 static int snd_emu10k1_audigy_dsp_convert_32_to_2x16(
1176                                 struct snd_emu10k1_fx8010_code *icode,
1177                                 u32 *ptr, int tmp, int bit_shifter16,
1178                                 int reg_in, int reg_out)
1179 {
1180         A_OP(icode, ptr, iACC3, A_GPR(tmp + 1), reg_in, A_C_00000000, A_C_00000000);
1181         A_OP(icode, ptr, iANDXOR, A_GPR(tmp), A_GPR(tmp + 1), A_GPR(bit_shifter16 - 1), A_C_00000000);
1182         A_OP(icode, ptr, iTSTNEG, A_GPR(tmp + 2), A_GPR(tmp), A_C_80000000, A_GPR(bit_shifter16 - 2));
1183         A_OP(icode, ptr, iANDXOR, A_GPR(tmp + 2), A_GPR(tmp + 2), A_C_80000000, A_C_00000000);
1184         A_OP(icode, ptr, iANDXOR, A_GPR(tmp), A_GPR(tmp), A_GPR(bit_shifter16 - 3), A_C_00000000);
1185         A_OP(icode, ptr, iMACINT0, A_GPR(tmp), A_C_00000000, A_GPR(tmp), A_C_00010000);
1186         A_OP(icode, ptr, iANDXOR, reg_out, A_GPR(tmp), A_C_ffffffff, A_GPR(tmp + 2));
1187         A_OP(icode, ptr, iACC3, reg_out + 1, A_GPR(tmp + 1), A_C_00000000, A_C_00000000);
1188         return 1;
1189 }
1190
1191 /*
1192  * initial DSP configuration for Audigy
1193  */
1194
1195 static int _snd_emu10k1_audigy_init_efx(struct snd_emu10k1 *emu)
1196 {
1197         int err, i, z, gpr, nctl;
1198         int bit_shifter16;
1199         const int playback = 10;
1200         const int capture = playback + (SND_EMU10K1_PLAYBACK_CHANNELS * 2); /* we reserve 10 voices */
1201         const int stereo_mix = capture + 2;
1202         const int tmp = 0x88;
1203         u32 ptr;
1204         struct snd_emu10k1_fx8010_code *icode = NULL;
1205         struct snd_emu10k1_fx8010_control_gpr *controls = NULL, *ctl;
1206         u32 *gpr_map;
1207
1208         err = -ENOMEM;
1209         icode = kzalloc(sizeof(*icode), GFP_KERNEL);
1210         if (!icode)
1211                 return err;
1212
1213         icode->gpr_map = (u_int32_t __user *) kcalloc(512 + 256 + 256 + 2 * 1024,
1214                                                       sizeof(u_int32_t), GFP_KERNEL);
1215         if (!icode->gpr_map)
1216                 goto __err_gpr;
1217         controls = kcalloc(SND_EMU10K1_GPR_CONTROLS,
1218                            sizeof(*controls), GFP_KERNEL);
1219         if (!controls)
1220                 goto __err_ctrls;
1221
1222         gpr_map = (u32 __force *)icode->gpr_map;
1223
1224         icode->tram_data_map = icode->gpr_map + 512;
1225         icode->tram_addr_map = icode->tram_data_map + 256;
1226         icode->code = icode->tram_addr_map + 256;
1227
1228         /* clear free GPRs */
1229         for (i = 0; i < 512; i++)
1230                 set_bit(i, icode->gpr_valid);
1231
1232         /* clear TRAM data & address lines */
1233         for (i = 0; i < 256; i++)
1234                 set_bit(i, icode->tram_valid);
1235
1236         strcpy(icode->name, "Audigy DSP code for ALSA");
1237         ptr = 0;
1238         nctl = 0;
1239         gpr = stereo_mix + 10;
1240         gpr_map[gpr++] = 0x00007fff;
1241         gpr_map[gpr++] = 0x00008000;
1242         gpr_map[gpr++] = 0x0000ffff;
1243         bit_shifter16 = gpr;
1244
1245         /* stop FX processor */
1246         snd_emu10k1_ptr_write(emu, A_DBG, 0, (emu->fx8010.dbg = 0) | A_DBG_SINGLE_STEP);
1247
1248 #if 1
1249         /* PCM front Playback Volume (independent from stereo mix)
1250          * playback = 0 + ( gpr * FXBUS_PCM_LEFT_FRONT >> 31)
1251          * where gpr contains attenuation from corresponding mixer control
1252          * (snd_emu10k1_init_stereo_control)
1253          */
1254         A_OP(icode, &ptr, iMAC0, A_GPR(playback), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_LEFT_FRONT));
1255         A_OP(icode, &ptr, iMAC0, A_GPR(playback+1), A_C_00000000, A_GPR(gpr+1), A_FXBUS(FXBUS_PCM_RIGHT_FRONT));
1256         snd_emu10k1_init_stereo_control(&controls[nctl++], "PCM Front Playback Volume", gpr, 100);
1257         gpr += 2;
1258
1259         /* PCM Surround Playback (independent from stereo mix) */
1260         A_OP(icode, &ptr, iMAC0, A_GPR(playback+2), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_LEFT_REAR));
1261         A_OP(icode, &ptr, iMAC0, A_GPR(playback+3), A_C_00000000, A_GPR(gpr+1), A_FXBUS(FXBUS_PCM_RIGHT_REAR));
1262         snd_emu10k1_init_stereo_control(&controls[nctl++], "PCM Surround Playback Volume", gpr, 100);
1263         gpr += 2;
1264
1265         /* PCM Side Playback (independent from stereo mix) */
1266         if (emu->card_capabilities->spk71) {
1267                 A_OP(icode, &ptr, iMAC0, A_GPR(playback+6), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_LEFT_SIDE));
1268                 A_OP(icode, &ptr, iMAC0, A_GPR(playback+7), A_C_00000000, A_GPR(gpr+1), A_FXBUS(FXBUS_PCM_RIGHT_SIDE));
1269                 snd_emu10k1_init_stereo_control(&controls[nctl++], "PCM Side Playback Volume", gpr, 100);
1270                 gpr += 2;
1271         }
1272
1273         /* PCM Center Playback (independent from stereo mix) */
1274         A_OP(icode, &ptr, iMAC0, A_GPR(playback+4), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_CENTER));
1275         snd_emu10k1_init_mono_control(&controls[nctl++], "PCM Center Playback Volume", gpr, 100);
1276         gpr++;
1277
1278         /* PCM LFE Playback (independent from stereo mix) */
1279         A_OP(icode, &ptr, iMAC0, A_GPR(playback+5), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_LFE));
1280         snd_emu10k1_init_mono_control(&controls[nctl++], "PCM LFE Playback Volume", gpr, 100);
1281         gpr++;
1282
1283         /*
1284          * Stereo Mix
1285          */
1286         /* Wave (PCM) Playback Volume (will be renamed later) */
1287         A_OP(icode, &ptr, iMAC0, A_GPR(stereo_mix), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_LEFT));
1288         A_OP(icode, &ptr, iMAC0, A_GPR(stereo_mix+1), A_C_00000000, A_GPR(gpr+1), A_FXBUS(FXBUS_PCM_RIGHT));
1289         snd_emu10k1_init_stereo_control(&controls[nctl++], "Wave Playback Volume", gpr, 100);
1290         gpr += 2;
1291
1292         /* Synth Playback */
1293         A_OP(icode, &ptr, iMAC0, A_GPR(stereo_mix+0), A_GPR(stereo_mix+0), A_GPR(gpr), A_FXBUS(FXBUS_MIDI_LEFT));
1294         A_OP(icode, &ptr, iMAC0, A_GPR(stereo_mix+1), A_GPR(stereo_mix+1), A_GPR(gpr+1), A_FXBUS(FXBUS_MIDI_RIGHT));
1295         snd_emu10k1_init_stereo_control(&controls[nctl++], "Synth Playback Volume", gpr, 100);
1296         gpr += 2;
1297
1298         /* Wave (PCM) Capture */
1299         A_OP(icode, &ptr, iMAC0, A_GPR(capture+0), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_LEFT));
1300         A_OP(icode, &ptr, iMAC0, A_GPR(capture+1), A_C_00000000, A_GPR(gpr+1), A_FXBUS(FXBUS_PCM_RIGHT));
1301         snd_emu10k1_init_stereo_control(&controls[nctl++], "PCM Capture Volume", gpr, 0);
1302         gpr += 2;
1303
1304         /* Synth Capture */
1305         A_OP(icode, &ptr, iMAC0, A_GPR(capture+0), A_GPR(capture+0), A_GPR(gpr), A_FXBUS(FXBUS_MIDI_LEFT));
1306         A_OP(icode, &ptr, iMAC0, A_GPR(capture+1), A_GPR(capture+1), A_GPR(gpr+1), A_FXBUS(FXBUS_MIDI_RIGHT));
1307         snd_emu10k1_init_stereo_control(&controls[nctl++], "Synth Capture Volume", gpr, 0);
1308         gpr += 2;
1309
1310         /*
1311          * inputs
1312          */
1313 #define A_ADD_VOLUME_IN(var,vol,input) \
1314 A_OP(icode, &ptr, iMAC0, A_GPR(var), A_GPR(var), A_GPR(vol), A_EXTIN(input))
1315
1316         /* emu1212 DSP 0 and DSP 1 Capture */
1317         if (emu->card_capabilities->emu_model) {
1318                 if (emu->card_capabilities->ca0108_chip) {
1319                         /* Note:JCD:No longer bit shift lower 16bits to upper 16bits of 32bit value. */
1320                         A_OP(icode, &ptr, iMACINT0, A_GPR(tmp), A_C_00000000, A3_EMU32IN(0x0), A_C_00000001);
1321                         A_OP(icode, &ptr, iMAC0, A_GPR(capture+0), A_GPR(capture+0), A_GPR(gpr), A_GPR(tmp));
1322                         A_OP(icode, &ptr, iMACINT0, A_GPR(tmp), A_C_00000000, A3_EMU32IN(0x1), A_C_00000001);
1323                         A_OP(icode, &ptr, iMAC0, A_GPR(capture+1), A_GPR(capture+1), A_GPR(gpr), A_GPR(tmp));
1324                 } else {
1325                         A_OP(icode, &ptr, iMAC0, A_GPR(capture+0), A_GPR(capture+0), A_GPR(gpr), A_P16VIN(0x0));
1326                         A_OP(icode, &ptr, iMAC0, A_GPR(capture+1), A_GPR(capture+1), A_GPR(gpr+1), A_P16VIN(0x1));
1327                 }
1328                 snd_emu10k1_init_stereo_control(&controls[nctl++], "EMU Capture Volume", gpr, 0);
1329                 gpr += 2;
1330         }
1331         /* AC'97 Playback Volume - used only for mic (renamed later) */
1332         A_ADD_VOLUME_IN(stereo_mix, gpr, A_EXTIN_AC97_L);
1333         A_ADD_VOLUME_IN(stereo_mix+1, gpr+1, A_EXTIN_AC97_R);
1334         snd_emu10k1_init_stereo_control(&controls[nctl++], "AMic Playback Volume", gpr, 0);
1335         gpr += 2;
1336         /* AC'97 Capture Volume - used only for mic */
1337         A_ADD_VOLUME_IN(capture, gpr, A_EXTIN_AC97_L);
1338         A_ADD_VOLUME_IN(capture+1, gpr+1, A_EXTIN_AC97_R);
1339         snd_emu10k1_init_stereo_control(&controls[nctl++], "Mic Capture Volume", gpr, 0);
1340         gpr += 2;
1341
1342         /* mic capture buffer */
1343         A_OP(icode, &ptr, iINTERP, A_EXTOUT(A_EXTOUT_MIC_CAP), A_EXTIN(A_EXTIN_AC97_L), 0xcd, A_EXTIN(A_EXTIN_AC97_R));
1344
1345         /* Audigy CD Playback Volume */
1346         A_ADD_VOLUME_IN(stereo_mix, gpr, A_EXTIN_SPDIF_CD_L);
1347         A_ADD_VOLUME_IN(stereo_mix+1, gpr+1, A_EXTIN_SPDIF_CD_R);
1348         snd_emu10k1_init_stereo_control(&controls[nctl++],
1349                                         emu->card_capabilities->ac97_chip ? "Audigy CD Playback Volume" : "CD Playback Volume",
1350                                         gpr, 0);
1351         gpr += 2;
1352         /* Audigy CD Capture Volume */
1353         A_ADD_VOLUME_IN(capture, gpr, A_EXTIN_SPDIF_CD_L);
1354         A_ADD_VOLUME_IN(capture+1, gpr+1, A_EXTIN_SPDIF_CD_R);
1355         snd_emu10k1_init_stereo_control(&controls[nctl++],
1356                                         emu->card_capabilities->ac97_chip ? "Audigy CD Capture Volume" : "CD Capture Volume",
1357                                         gpr, 0);
1358         gpr += 2;
1359
1360         /* Optical SPDIF Playback Volume */
1361         A_ADD_VOLUME_IN(stereo_mix, gpr, A_EXTIN_OPT_SPDIF_L);
1362         A_ADD_VOLUME_IN(stereo_mix+1, gpr+1, A_EXTIN_OPT_SPDIF_R);
1363         snd_emu10k1_init_stereo_control(&controls[nctl++], SNDRV_CTL_NAME_IEC958("Optical ",PLAYBACK,VOLUME), gpr, 0);
1364         gpr += 2;
1365         /* Optical SPDIF Capture Volume */
1366         A_ADD_VOLUME_IN(capture, gpr, A_EXTIN_OPT_SPDIF_L);
1367         A_ADD_VOLUME_IN(capture+1, gpr+1, A_EXTIN_OPT_SPDIF_R);
1368         snd_emu10k1_init_stereo_control(&controls[nctl++], SNDRV_CTL_NAME_IEC958("Optical ",CAPTURE,VOLUME), gpr, 0);
1369         gpr += 2;
1370
1371         /* Line2 Playback Volume */
1372         A_ADD_VOLUME_IN(stereo_mix, gpr, A_EXTIN_LINE2_L);
1373         A_ADD_VOLUME_IN(stereo_mix+1, gpr+1, A_EXTIN_LINE2_R);
1374         snd_emu10k1_init_stereo_control(&controls[nctl++],
1375                                         emu->card_capabilities->ac97_chip ? "Line2 Playback Volume" : "Line Playback Volume",
1376                                         gpr, 0);
1377         gpr += 2;
1378         /* Line2 Capture Volume */
1379         A_ADD_VOLUME_IN(capture, gpr, A_EXTIN_LINE2_L);
1380         A_ADD_VOLUME_IN(capture+1, gpr+1, A_EXTIN_LINE2_R);
1381         snd_emu10k1_init_stereo_control(&controls[nctl++],
1382                                         emu->card_capabilities->ac97_chip ? "Line2 Capture Volume" : "Line Capture Volume",
1383                                         gpr, 0);
1384         gpr += 2;
1385
1386         /* Philips ADC Playback Volume */
1387         A_ADD_VOLUME_IN(stereo_mix, gpr, A_EXTIN_ADC_L);
1388         A_ADD_VOLUME_IN(stereo_mix+1, gpr+1, A_EXTIN_ADC_R);
1389         snd_emu10k1_init_stereo_control(&controls[nctl++], "Analog Mix Playback Volume", gpr, 0);
1390         gpr += 2;
1391         /* Philips ADC Capture Volume */
1392         A_ADD_VOLUME_IN(capture, gpr, A_EXTIN_ADC_L);
1393         A_ADD_VOLUME_IN(capture+1, gpr+1, A_EXTIN_ADC_R);
1394         snd_emu10k1_init_stereo_control(&controls[nctl++], "Analog Mix Capture Volume", gpr, 0);
1395         gpr += 2;
1396
1397         /* Aux2 Playback Volume */
1398         A_ADD_VOLUME_IN(stereo_mix, gpr, A_EXTIN_AUX2_L);
1399         A_ADD_VOLUME_IN(stereo_mix+1, gpr+1, A_EXTIN_AUX2_R);
1400         snd_emu10k1_init_stereo_control(&controls[nctl++],
1401                                         emu->card_capabilities->ac97_chip ? "Aux2 Playback Volume" : "Aux Playback Volume",
1402                                         gpr, 0);
1403         gpr += 2;
1404         /* Aux2 Capture Volume */
1405         A_ADD_VOLUME_IN(capture, gpr, A_EXTIN_AUX2_L);
1406         A_ADD_VOLUME_IN(capture+1, gpr+1, A_EXTIN_AUX2_R);
1407         snd_emu10k1_init_stereo_control(&controls[nctl++],
1408                                         emu->card_capabilities->ac97_chip ? "Aux2 Capture Volume" : "Aux Capture Volume",
1409                                         gpr, 0);
1410         gpr += 2;
1411
1412         /* Stereo Mix Front Playback Volume */
1413         A_OP(icode, &ptr, iMAC0, A_GPR(playback), A_GPR(playback), A_GPR(gpr), A_GPR(stereo_mix));
1414         A_OP(icode, &ptr, iMAC0, A_GPR(playback+1), A_GPR(playback+1), A_GPR(gpr+1), A_GPR(stereo_mix+1));
1415         snd_emu10k1_init_stereo_control(&controls[nctl++], "Front Playback Volume", gpr, 100);
1416         gpr += 2;
1417
1418         /* Stereo Mix Surround Playback */
1419         A_OP(icode, &ptr, iMAC0, A_GPR(playback+2), A_GPR(playback+2), A_GPR(gpr), A_GPR(stereo_mix));
1420         A_OP(icode, &ptr, iMAC0, A_GPR(playback+3), A_GPR(playback+3), A_GPR(gpr+1), A_GPR(stereo_mix+1));
1421         snd_emu10k1_init_stereo_control(&controls[nctl++], "Surround Playback Volume", gpr, 0);
1422         gpr += 2;
1423
1424         /* Stereo Mix Center Playback */
1425         /* Center = sub = Left/2 + Right/2 */
1426         A_OP(icode, &ptr, iINTERP, A_GPR(tmp), A_GPR(stereo_mix), 0xcd, A_GPR(stereo_mix+1));
1427         A_OP(icode, &ptr, iMAC0, A_GPR(playback+4), A_GPR(playback+4), A_GPR(gpr), A_GPR(tmp));
1428         snd_emu10k1_init_mono_control(&controls[nctl++], "Center Playback Volume", gpr, 0);
1429         gpr++;
1430
1431         /* Stereo Mix LFE Playback */
1432         A_OP(icode, &ptr, iMAC0, A_GPR(playback+5), A_GPR(playback+5), A_GPR(gpr), A_GPR(tmp));
1433         snd_emu10k1_init_mono_control(&controls[nctl++], "LFE Playback Volume", gpr, 0);
1434         gpr++;
1435
1436         if (emu->card_capabilities->spk71) {
1437                 /* Stereo Mix Side Playback */
1438                 A_OP(icode, &ptr, iMAC0, A_GPR(playback+6), A_GPR(playback+6), A_GPR(gpr), A_GPR(stereo_mix));
1439                 A_OP(icode, &ptr, iMAC0, A_GPR(playback+7), A_GPR(playback+7), A_GPR(gpr+1), A_GPR(stereo_mix+1));
1440                 snd_emu10k1_init_stereo_control(&controls[nctl++], "Side Playback Volume", gpr, 0);
1441                 gpr += 2;
1442         }
1443
1444         /*
1445          * outputs
1446          */
1447 #define A_PUT_OUTPUT(out,src) A_OP(icode, &ptr, iACC3, A_EXTOUT(out), A_C_00000000, A_C_00000000, A_GPR(src))
1448 #define A_PUT_STEREO_OUTPUT(out1,out2,src) \
1449         {A_PUT_OUTPUT(out1,src); A_PUT_OUTPUT(out2,src+1);}
1450
1451 #define _A_SWITCH(icode, ptr, dst, src, sw) \
1452         A_OP((icode), ptr, iMACINT0, dst, A_C_00000000, src, sw);
1453 #define A_SWITCH(icode, ptr, dst, src, sw) \
1454                 _A_SWITCH(icode, ptr, A_GPR(dst), A_GPR(src), A_GPR(sw))
1455 #define _A_SWITCH_NEG(icode, ptr, dst, src) \
1456         A_OP((icode), ptr, iANDXOR, dst, src, A_C_00000001, A_C_00000001);
1457 #define A_SWITCH_NEG(icode, ptr, dst, src) \
1458                 _A_SWITCH_NEG(icode, ptr, A_GPR(dst), A_GPR(src))
1459
1460
1461         /*
1462          *  Process tone control
1463          */
1464         A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 0), A_GPR(playback + 0), A_C_00000000, A_C_00000000); /* left */
1465         A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 1), A_GPR(playback + 1), A_C_00000000, A_C_00000000); /* right */
1466         A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 2), A_GPR(playback + 2), A_C_00000000, A_C_00000000); /* rear left */
1467         A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 3), A_GPR(playback + 3), A_C_00000000, A_C_00000000); /* rear right */
1468         A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 4), A_GPR(playback + 4), A_C_00000000, A_C_00000000); /* center */
1469         A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 5), A_GPR(playback + 5), A_C_00000000, A_C_00000000); /* LFE */
1470         if (emu->card_capabilities->spk71) {
1471                 A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 6), A_GPR(playback + 6), A_C_00000000, A_C_00000000); /* side left */
1472                 A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 7), A_GPR(playback + 7), A_C_00000000, A_C_00000000); /* side right */
1473         }
1474
1475
1476         ctl = &controls[nctl + 0];
1477         ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1478         strcpy(ctl->id.name, "Tone Control - Bass");
1479         ctl->vcount = 2;
1480         ctl->count = 10;
1481         ctl->min = 0;
1482         ctl->max = 40;
1483         ctl->value[0] = ctl->value[1] = 20;
1484         ctl->translation = EMU10K1_GPR_TRANSLATION_BASS;
1485         ctl = &controls[nctl + 1];
1486         ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1487         strcpy(ctl->id.name, "Tone Control - Treble");
1488         ctl->vcount = 2;
1489         ctl->count = 10;
1490         ctl->min = 0;
1491         ctl->max = 40;
1492         ctl->value[0] = ctl->value[1] = 20;
1493         ctl->translation = EMU10K1_GPR_TRANSLATION_TREBLE;
1494
1495 #define BASS_GPR        0x8c
1496 #define TREBLE_GPR      0x96
1497
1498         for (z = 0; z < 5; z++) {
1499                 int j;
1500                 for (j = 0; j < 2; j++) {
1501                         controls[nctl + 0].gpr[z * 2 + j] = BASS_GPR + z * 2 + j;
1502                         controls[nctl + 1].gpr[z * 2 + j] = TREBLE_GPR + z * 2 + j;
1503                 }
1504         }
1505         for (z = 0; z < 4; z++) {               /* front/rear/center-lfe/side */
1506                 int j, k, l, d;
1507                 for (j = 0; j < 2; j++) {       /* left/right */
1508                         k = 0xb0 + (z * 8) + (j * 4);
1509                         l = 0xe0 + (z * 8) + (j * 4);
1510                         d = playback + SND_EMU10K1_PLAYBACK_CHANNELS + z * 2 + j;
1511
1512                         A_OP(icode, &ptr, iMAC0, A_C_00000000, A_C_00000000, A_GPR(d), A_GPR(BASS_GPR + 0 + j));
1513                         A_OP(icode, &ptr, iMACMV, A_GPR(k+1), A_GPR(k), A_GPR(k+1), A_GPR(BASS_GPR + 4 + j));
1514                         A_OP(icode, &ptr, iMACMV, A_GPR(k), A_GPR(d), A_GPR(k), A_GPR(BASS_GPR + 2 + j));
1515                         A_OP(icode, &ptr, iMACMV, A_GPR(k+3), A_GPR(k+2), A_GPR(k+3), A_GPR(BASS_GPR + 8 + j));
1516                         A_OP(icode, &ptr, iMAC0, A_GPR(k+2), A_GPR_ACCU, A_GPR(k+2), A_GPR(BASS_GPR + 6 + j));
1517                         A_OP(icode, &ptr, iACC3, A_GPR(k+2), A_GPR(k+2), A_GPR(k+2), A_C_00000000);
1518
1519                         A_OP(icode, &ptr, iMAC0, A_C_00000000, A_C_00000000, A_GPR(k+2), A_GPR(TREBLE_GPR + 0 + j));
1520                         A_OP(icode, &ptr, iMACMV, A_GPR(l+1), A_GPR(l), A_GPR(l+1), A_GPR(TREBLE_GPR + 4 + j));
1521                         A_OP(icode, &ptr, iMACMV, A_GPR(l), A_GPR(k+2), A_GPR(l), A_GPR(TREBLE_GPR + 2 + j));
1522                         A_OP(icode, &ptr, iMACMV, A_GPR(l+3), A_GPR(l+2), A_GPR(l+3), A_GPR(TREBLE_GPR + 8 + j));
1523                         A_OP(icode, &ptr, iMAC0, A_GPR(l+2), A_GPR_ACCU, A_GPR(l+2), A_GPR(TREBLE_GPR + 6 + j));
1524                         A_OP(icode, &ptr, iMACINT0, A_GPR(l+2), A_C_00000000, A_GPR(l+2), A_C_00000010);
1525
1526                         A_OP(icode, &ptr, iACC3, A_GPR(d), A_GPR(l+2), A_C_00000000, A_C_00000000);
1527
1528                         if (z == 2)     /* center */
1529                                 break;
1530                 }
1531         }
1532         nctl += 2;
1533
1534 #undef BASS_GPR
1535 #undef TREBLE_GPR
1536
1537         for (z = 0; z < 8; z++) {
1538                 A_SWITCH(icode, &ptr, tmp + 0, playback + SND_EMU10K1_PLAYBACK_CHANNELS + z, gpr + 0);
1539                 A_SWITCH_NEG(icode, &ptr, tmp + 1, gpr + 0);
1540                 A_SWITCH(icode, &ptr, tmp + 1, playback + z, tmp + 1);
1541                 A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + z), A_GPR(tmp + 0), A_GPR(tmp + 1), A_C_00000000);
1542         }
1543         snd_emu10k1_init_stereo_onoff_control(controls + nctl++, "Tone Control - Switch", gpr, 0);
1544         gpr += 2;
1545
1546         /* Master volume (will be renamed later) */
1547         A_OP(icode, &ptr, iMAC0, A_GPR(playback+0+SND_EMU10K1_PLAYBACK_CHANNELS), A_C_00000000, A_GPR(gpr), A_GPR(playback+0+SND_EMU10K1_PLAYBACK_CHANNELS));
1548         A_OP(icode, &ptr, iMAC0, A_GPR(playback+1+SND_EMU10K1_PLAYBACK_CHANNELS), A_C_00000000, A_GPR(gpr), A_GPR(playback+1+SND_EMU10K1_PLAYBACK_CHANNELS));
1549         A_OP(icode, &ptr, iMAC0, A_GPR(playback+2+SND_EMU10K1_PLAYBACK_CHANNELS), A_C_00000000, A_GPR(gpr), A_GPR(playback+2+SND_EMU10K1_PLAYBACK_CHANNELS));
1550         A_OP(icode, &ptr, iMAC0, A_GPR(playback+3+SND_EMU10K1_PLAYBACK_CHANNELS), A_C_00000000, A_GPR(gpr), A_GPR(playback+3+SND_EMU10K1_PLAYBACK_CHANNELS));
1551         A_OP(icode, &ptr, iMAC0, A_GPR(playback+4+SND_EMU10K1_PLAYBACK_CHANNELS), A_C_00000000, A_GPR(gpr), A_GPR(playback+4+SND_EMU10K1_PLAYBACK_CHANNELS));
1552         A_OP(icode, &ptr, iMAC0, A_GPR(playback+5+SND_EMU10K1_PLAYBACK_CHANNELS), A_C_00000000, A_GPR(gpr), A_GPR(playback+5+SND_EMU10K1_PLAYBACK_CHANNELS));
1553         A_OP(icode, &ptr, iMAC0, A_GPR(playback+6+SND_EMU10K1_PLAYBACK_CHANNELS), A_C_00000000, A_GPR(gpr), A_GPR(playback+6+SND_EMU10K1_PLAYBACK_CHANNELS));
1554         A_OP(icode, &ptr, iMAC0, A_GPR(playback+7+SND_EMU10K1_PLAYBACK_CHANNELS), A_C_00000000, A_GPR(gpr), A_GPR(playback+7+SND_EMU10K1_PLAYBACK_CHANNELS));
1555         snd_emu10k1_init_mono_control(&controls[nctl++], "Wave Master Playback Volume", gpr, 0);
1556         gpr += 2;
1557
1558         /* analog speakers */
1559         A_PUT_STEREO_OUTPUT(A_EXTOUT_AFRONT_L, A_EXTOUT_AFRONT_R, playback + SND_EMU10K1_PLAYBACK_CHANNELS);
1560         A_PUT_STEREO_OUTPUT(A_EXTOUT_AREAR_L, A_EXTOUT_AREAR_R, playback+2 + SND_EMU10K1_PLAYBACK_CHANNELS);
1561         A_PUT_OUTPUT(A_EXTOUT_ACENTER, playback+4 + SND_EMU10K1_PLAYBACK_CHANNELS);
1562         A_PUT_OUTPUT(A_EXTOUT_ALFE, playback+5 + SND_EMU10K1_PLAYBACK_CHANNELS);
1563         if (emu->card_capabilities->spk71)
1564                 A_PUT_STEREO_OUTPUT(A_EXTOUT_ASIDE_L, A_EXTOUT_ASIDE_R, playback+6 + SND_EMU10K1_PLAYBACK_CHANNELS);
1565
1566         /* headphone */
1567         A_PUT_STEREO_OUTPUT(A_EXTOUT_HEADPHONE_L, A_EXTOUT_HEADPHONE_R, playback + SND_EMU10K1_PLAYBACK_CHANNELS);
1568
1569         /* digital outputs */
1570         /* A_PUT_STEREO_OUTPUT(A_EXTOUT_FRONT_L, A_EXTOUT_FRONT_R, playback + SND_EMU10K1_PLAYBACK_CHANNELS); */
1571         if (emu->card_capabilities->emu_model) {
1572                 /* EMU1010 Outputs from PCM Front, Rear, Center, LFE, Side */
1573                 dev_info(emu->card->dev, "EMU outputs on\n");
1574                 for (z = 0; z < 8; z++) {
1575                         if (emu->card_capabilities->ca0108_chip) {
1576                                 A_OP(icode, &ptr, iACC3, A3_EMU32OUT(z), A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + z), A_C_00000000, A_C_00000000);
1577                         } else {
1578                                 A_OP(icode, &ptr, iACC3, A_EMU32OUTL(z), A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + z), A_C_00000000, A_C_00000000);
1579                         }
1580                 }
1581         }
1582
1583         /* IEC958 Optical Raw Playback Switch */
1584         gpr_map[gpr++] = 0;
1585         gpr_map[gpr++] = 0x1008;
1586         gpr_map[gpr++] = 0xffff0000;
1587         for (z = 0; z < 2; z++) {
1588                 A_OP(icode, &ptr, iMAC0, A_GPR(tmp + 2), A_FXBUS(FXBUS_PT_LEFT + z), A_C_00000000, A_C_00000000);
1589                 A_OP(icode, &ptr, iSKIP, A_GPR_COND, A_GPR_COND, A_GPR(gpr - 2), A_C_00000001);
1590                 A_OP(icode, &ptr, iACC3, A_GPR(tmp + 2), A_C_00000000, A_C_00010000, A_GPR(tmp + 2));
1591                 A_OP(icode, &ptr, iANDXOR, A_GPR(tmp + 2), A_GPR(tmp + 2), A_GPR(gpr - 1), A_C_00000000);
1592                 A_SWITCH(icode, &ptr, tmp + 0, tmp + 2, gpr + z);
1593                 A_SWITCH_NEG(icode, &ptr, tmp + 1, gpr + z);
1594                 A_SWITCH(icode, &ptr, tmp + 1, playback + SND_EMU10K1_PLAYBACK_CHANNELS + z, tmp + 1);
1595                 if ((z==1) && (emu->card_capabilities->spdif_bug)) {
1596                         /* Due to a SPDIF output bug on some Audigy cards, this code delays the Right channel by 1 sample */
1597                         dev_info(emu->card->dev,
1598                                  "Installing spdif_bug patch: %s\n",
1599                                  emu->card_capabilities->name);
1600                         A_OP(icode, &ptr, iACC3, A_EXTOUT(A_EXTOUT_FRONT_L + z), A_GPR(gpr - 3), A_C_00000000, A_C_00000000);
1601                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 3), A_GPR(tmp + 0), A_GPR(tmp + 1), A_C_00000000);
1602                 } else {
1603                         A_OP(icode, &ptr, iACC3, A_EXTOUT(A_EXTOUT_FRONT_L + z), A_GPR(tmp + 0), A_GPR(tmp + 1), A_C_00000000);
1604                 }
1605         }
1606         snd_emu10k1_init_stereo_onoff_control(controls + nctl++, SNDRV_CTL_NAME_IEC958("Optical Raw ",PLAYBACK,SWITCH), gpr, 0);
1607         gpr += 2;
1608
1609         A_PUT_STEREO_OUTPUT(A_EXTOUT_REAR_L, A_EXTOUT_REAR_R, playback+2 + SND_EMU10K1_PLAYBACK_CHANNELS);
1610         A_PUT_OUTPUT(A_EXTOUT_CENTER, playback+4 + SND_EMU10K1_PLAYBACK_CHANNELS);
1611         A_PUT_OUTPUT(A_EXTOUT_LFE, playback+5 + SND_EMU10K1_PLAYBACK_CHANNELS);
1612
1613         /* ADC buffer */
1614 #ifdef EMU10K1_CAPTURE_DIGITAL_OUT
1615         A_PUT_STEREO_OUTPUT(A_EXTOUT_ADC_CAP_L, A_EXTOUT_ADC_CAP_R, playback + SND_EMU10K1_PLAYBACK_CHANNELS);
1616 #else
1617         A_PUT_OUTPUT(A_EXTOUT_ADC_CAP_L, capture);
1618         A_PUT_OUTPUT(A_EXTOUT_ADC_CAP_R, capture+1);
1619 #endif
1620
1621         if (emu->card_capabilities->emu_model) {
1622                 if (emu->card_capabilities->ca0108_chip) {
1623                         dev_info(emu->card->dev, "EMU2 inputs on\n");
1624                         for (z = 0; z < 0x10; z++) {
1625                                 snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp,
1626                                                                         bit_shifter16,
1627                                                                         A3_EMU32IN(z),
1628                                                                         A_FXBUS2(z*2) );
1629                         }
1630                 } else {
1631                         dev_info(emu->card->dev, "EMU inputs on\n");
1632                         /* Capture 16 (originally 8) channels of S32_LE sound */
1633
1634                         /*
1635                         dev_dbg(emu->card->dev, "emufx.c: gpr=0x%x, tmp=0x%x\n",
1636                                gpr, tmp);
1637                         */
1638                         /* For the EMU1010: How to get 32bit values from the DSP. High 16bits into L, low 16bits into R. */
1639                         /* A_P16VIN(0) is delayed by one sample,
1640                          * so all other A_P16VIN channels will need to also be delayed
1641                          */
1642                         /* Left ADC in. 1 of 2 */
1643                         snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_P16VIN(0x0), A_FXBUS2(0) );
1644                         /* Right ADC in 1 of 2 */
1645                         gpr_map[gpr++] = 0x00000000;
1646                         /* Delaying by one sample: instead of copying the input
1647                          * value A_P16VIN to output A_FXBUS2 as in the first channel,
1648                          * we use an auxiliary register, delaying the value by one
1649                          * sample
1650                          */
1651                         snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(2) );
1652                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x1), A_C_00000000, A_C_00000000);
1653                         gpr_map[gpr++] = 0x00000000;
1654                         snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(4) );
1655                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x2), A_C_00000000, A_C_00000000);
1656                         gpr_map[gpr++] = 0x00000000;
1657                         snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(6) );
1658                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x3), A_C_00000000, A_C_00000000);
1659                         /* For 96kHz mode */
1660                         /* Left ADC in. 2 of 2 */
1661                         gpr_map[gpr++] = 0x00000000;
1662                         snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(0x8) );
1663                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x4), A_C_00000000, A_C_00000000);
1664                         /* Right ADC in 2 of 2 */
1665                         gpr_map[gpr++] = 0x00000000;
1666                         snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(0xa) );
1667                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x5), A_C_00000000, A_C_00000000);
1668                         gpr_map[gpr++] = 0x00000000;
1669                         snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(0xc) );
1670                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x6), A_C_00000000, A_C_00000000);
1671                         gpr_map[gpr++] = 0x00000000;
1672                         snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(0xe) );
1673                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x7), A_C_00000000, A_C_00000000);
1674                         /* Pavel Hofman - we still have voices, A_FXBUS2s, and
1675                          * A_P16VINs available -
1676                          * let's add 8 more capture channels - total of 16
1677                          */
1678                         gpr_map[gpr++] = 0x00000000;
1679                         snd_emu10k1_audigy_dsp_convert_32_to_2x16(icode, &ptr, tmp,
1680                                                                   bit_shifter16,
1681                                                                   A_GPR(gpr - 1),
1682                                                                   A_FXBUS2(0x10));
1683                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x8),
1684                              A_C_00000000, A_C_00000000);
1685                         gpr_map[gpr++] = 0x00000000;
1686                         snd_emu10k1_audigy_dsp_convert_32_to_2x16(icode, &ptr, tmp,
1687                                                                   bit_shifter16,
1688                                                                   A_GPR(gpr - 1),
1689                                                                   A_FXBUS2(0x12));
1690                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x9),
1691                              A_C_00000000, A_C_00000000);
1692                         gpr_map[gpr++] = 0x00000000;
1693                         snd_emu10k1_audigy_dsp_convert_32_to_2x16(icode, &ptr, tmp,
1694                                                                   bit_shifter16,
1695                                                                   A_GPR(gpr - 1),
1696                                                                   A_FXBUS2(0x14));
1697                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0xa),
1698                              A_C_00000000, A_C_00000000);
1699                         gpr_map[gpr++] = 0x00000000;
1700                         snd_emu10k1_audigy_dsp_convert_32_to_2x16(icode, &ptr, tmp,
1701                                                                   bit_shifter16,
1702                                                                   A_GPR(gpr - 1),
1703                                                                   A_FXBUS2(0x16));
1704                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0xb),
1705                              A_C_00000000, A_C_00000000);
1706                         gpr_map[gpr++] = 0x00000000;
1707                         snd_emu10k1_audigy_dsp_convert_32_to_2x16(icode, &ptr, tmp,
1708                                                                   bit_shifter16,
1709                                                                   A_GPR(gpr - 1),
1710                                                                   A_FXBUS2(0x18));
1711                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0xc),
1712                              A_C_00000000, A_C_00000000);
1713                         gpr_map[gpr++] = 0x00000000;
1714                         snd_emu10k1_audigy_dsp_convert_32_to_2x16(icode, &ptr, tmp,
1715                                                                   bit_shifter16,
1716                                                                   A_GPR(gpr - 1),
1717                                                                   A_FXBUS2(0x1a));
1718                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0xd),
1719                              A_C_00000000, A_C_00000000);
1720                         gpr_map[gpr++] = 0x00000000;
1721                         snd_emu10k1_audigy_dsp_convert_32_to_2x16(icode, &ptr, tmp,
1722                                                                   bit_shifter16,
1723                                                                   A_GPR(gpr - 1),
1724                                                                   A_FXBUS2(0x1c));
1725                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0xe),
1726                              A_C_00000000, A_C_00000000);
1727                         gpr_map[gpr++] = 0x00000000;
1728                         snd_emu10k1_audigy_dsp_convert_32_to_2x16(icode, &ptr, tmp,
1729                                                                   bit_shifter16,
1730                                                                   A_GPR(gpr - 1),
1731                                                                   A_FXBUS2(0x1e));
1732                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0xf),
1733                              A_C_00000000, A_C_00000000);
1734                 }
1735
1736 #if 0
1737                 for (z = 4; z < 8; z++) {
1738                         A_OP(icode, &ptr, iACC3, A_FXBUS2(z), A_C_00000000, A_C_00000000, A_C_00000000);
1739                 }
1740                 for (z = 0xc; z < 0x10; z++) {
1741                         A_OP(icode, &ptr, iACC3, A_FXBUS2(z), A_C_00000000, A_C_00000000, A_C_00000000);
1742                 }
1743 #endif
1744         } else {
1745                 /* EFX capture - capture the 16 EXTINs */
1746                 /* Capture 16 channels of S16_LE sound */
1747                 for (z = 0; z < 16; z++) {
1748                         A_OP(icode, &ptr, iACC3, A_FXBUS2(z), A_C_00000000, A_C_00000000, A_EXTIN(z));
1749                 }
1750         }
1751
1752 #endif /* JCD test */
1753         /*
1754          * ok, set up done..
1755          */
1756
1757         if (gpr > tmp) {
1758                 snd_BUG();
1759                 err = -EIO;
1760                 goto __err;
1761         }
1762         /* clear remaining instruction memory */
1763         while (ptr < 0x400)
1764                 A_OP(icode, &ptr, 0x0f, 0xc0, 0xc0, 0xcf, 0xc0);
1765
1766         icode->gpr_add_control_count = nctl;
1767         icode->gpr_add_controls = (struct snd_emu10k1_fx8010_control_gpr __user *)controls;
1768         emu->support_tlv = 1; /* support TLV */
1769         err = snd_emu10k1_icode_poke(emu, icode, true);
1770         emu->support_tlv = 0; /* clear again */
1771
1772 __err:
1773         kfree(controls);
1774 __err_ctrls:
1775         kfree((void __force *)icode->gpr_map);
1776 __err_gpr:
1777         kfree(icode);
1778         return err;
1779 }
1780
1781
1782 /*
1783  * initial DSP configuration for Emu10k1
1784  */
1785
1786 /* when volume = max, then copy only to avoid volume modification */
1787 /* with iMAC0 (negative values) */
1788 static void _volume(struct snd_emu10k1_fx8010_code *icode, u32 *ptr, u32 dst, u32 src, u32 vol)
1789 {
1790         OP(icode, ptr, iMAC0, dst, C_00000000, src, vol);
1791         OP(icode, ptr, iANDXOR, C_00000000, vol, C_ffffffff, C_7fffffff);
1792         OP(icode, ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, C_00000001);
1793         OP(icode, ptr, iACC3, dst, src, C_00000000, C_00000000);
1794 }
1795 static void _volume_add(struct snd_emu10k1_fx8010_code *icode, u32 *ptr, u32 dst, u32 src, u32 vol)
1796 {
1797         OP(icode, ptr, iANDXOR, C_00000000, vol, C_ffffffff, C_7fffffff);
1798         OP(icode, ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, C_00000002);
1799         OP(icode, ptr, iMACINT0, dst, dst, src, C_00000001);
1800         OP(icode, ptr, iSKIP, C_00000000, C_7fffffff, C_7fffffff, C_00000001);
1801         OP(icode, ptr, iMAC0, dst, dst, src, vol);
1802 }
1803 static void _volume_out(struct snd_emu10k1_fx8010_code *icode, u32 *ptr, u32 dst, u32 src, u32 vol)
1804 {
1805         OP(icode, ptr, iANDXOR, C_00000000, vol, C_ffffffff, C_7fffffff);
1806         OP(icode, ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, C_00000002);
1807         OP(icode, ptr, iACC3, dst, src, C_00000000, C_00000000);
1808         OP(icode, ptr, iSKIP, C_00000000, C_7fffffff, C_7fffffff, C_00000001);
1809         OP(icode, ptr, iMAC0, dst, C_00000000, src, vol);
1810 }
1811
1812 #define VOLUME(icode, ptr, dst, src, vol) \
1813                 _volume(icode, ptr, GPR(dst), GPR(src), GPR(vol))
1814 #define VOLUME_IN(icode, ptr, dst, src, vol) \
1815                 _volume(icode, ptr, GPR(dst), EXTIN(src), GPR(vol))
1816 #define VOLUME_ADD(icode, ptr, dst, src, vol) \
1817                 _volume_add(icode, ptr, GPR(dst), GPR(src), GPR(vol))
1818 #define VOLUME_ADDIN(icode, ptr, dst, src, vol) \
1819                 _volume_add(icode, ptr, GPR(dst), EXTIN(src), GPR(vol))
1820 #define VOLUME_OUT(icode, ptr, dst, src, vol) \
1821                 _volume_out(icode, ptr, EXTOUT(dst), GPR(src), GPR(vol))
1822 #define _SWITCH(icode, ptr, dst, src, sw) \
1823         OP((icode), ptr, iMACINT0, dst, C_00000000, src, sw);
1824 #define SWITCH(icode, ptr, dst, src, sw) \
1825                 _SWITCH(icode, ptr, GPR(dst), GPR(src), GPR(sw))
1826 #define SWITCH_IN(icode, ptr, dst, src, sw) \
1827                 _SWITCH(icode, ptr, GPR(dst), EXTIN(src), GPR(sw))
1828 #define _SWITCH_NEG(icode, ptr, dst, src) \
1829         OP((icode), ptr, iANDXOR, dst, src, C_00000001, C_00000001);
1830 #define SWITCH_NEG(icode, ptr, dst, src) \
1831                 _SWITCH_NEG(icode, ptr, GPR(dst), GPR(src))
1832
1833
1834 static int _snd_emu10k1_init_efx(struct snd_emu10k1 *emu)
1835 {
1836         int err, i, z, gpr, tmp, playback, capture;
1837         u32 ptr;
1838         struct snd_emu10k1_fx8010_code *icode;
1839         struct snd_emu10k1_fx8010_pcm_rec *ipcm = NULL;
1840         struct snd_emu10k1_fx8010_control_gpr *controls = NULL, *ctl;
1841         u32 *gpr_map;
1842
1843         err = -ENOMEM;
1844         icode = kzalloc(sizeof(*icode), GFP_KERNEL);
1845         if (!icode)
1846                 return err;
1847
1848         icode->gpr_map = (u_int32_t __user *) kcalloc(256 + 160 + 160 + 2 * 512,
1849                                                       sizeof(u_int32_t), GFP_KERNEL);
1850         if (!icode->gpr_map)
1851                 goto __err_gpr;
1852
1853         controls = kcalloc(SND_EMU10K1_GPR_CONTROLS,
1854                            sizeof(struct snd_emu10k1_fx8010_control_gpr),
1855                            GFP_KERNEL);
1856         if (!controls)
1857                 goto __err_ctrls;
1858
1859         ipcm = kzalloc(sizeof(*ipcm), GFP_KERNEL);
1860         if (!ipcm)
1861                 goto __err_ipcm;
1862
1863         gpr_map = (u32 __force *)icode->gpr_map;
1864
1865         icode->tram_data_map = icode->gpr_map + 256;
1866         icode->tram_addr_map = icode->tram_data_map + 160;
1867         icode->code = icode->tram_addr_map + 160;
1868
1869         /* clear free GPRs */
1870         for (i = 0; i < 256; i++)
1871                 set_bit(i, icode->gpr_valid);
1872
1873         /* clear TRAM data & address lines */
1874         for (i = 0; i < 160; i++)
1875                 set_bit(i, icode->tram_valid);
1876
1877         strcpy(icode->name, "SB Live! FX8010 code for ALSA v1.2 by Jaroslav Kysela");
1878         ptr = 0; i = 0;
1879         /* we have 12 inputs */
1880         playback = SND_EMU10K1_INPUTS;
1881         /* we have 6 playback channels and tone control doubles */
1882         capture = playback + (SND_EMU10K1_PLAYBACK_CHANNELS * 2);
1883         gpr = capture + SND_EMU10K1_CAPTURE_CHANNELS;
1884         tmp = 0x88;     /* we need 4 temporary GPR */
1885         /* from 0x8c to 0xff is the area for tone control */
1886
1887         /* stop FX processor */
1888         snd_emu10k1_ptr_write(emu, DBG, 0, (emu->fx8010.dbg = 0) | EMU10K1_DBG_SINGLE_STEP);
1889
1890         /*
1891          *  Process FX Buses
1892          */
1893         OP(icode, &ptr, iMACINT0, GPR(0), C_00000000, FXBUS(FXBUS_PCM_LEFT), C_00000004);
1894         OP(icode, &ptr, iMACINT0, GPR(1), C_00000000, FXBUS(FXBUS_PCM_RIGHT), C_00000004);
1895         OP(icode, &ptr, iMACINT0, GPR(2), C_00000000, FXBUS(FXBUS_MIDI_LEFT), C_00000004);
1896         OP(icode, &ptr, iMACINT0, GPR(3), C_00000000, FXBUS(FXBUS_MIDI_RIGHT), C_00000004);
1897         OP(icode, &ptr, iMACINT0, GPR(4), C_00000000, FXBUS(FXBUS_PCM_LEFT_REAR), C_00000004);
1898         OP(icode, &ptr, iMACINT0, GPR(5), C_00000000, FXBUS(FXBUS_PCM_RIGHT_REAR), C_00000004);
1899         OP(icode, &ptr, iMACINT0, GPR(6), C_00000000, FXBUS(FXBUS_PCM_CENTER), C_00000004);
1900         OP(icode, &ptr, iMACINT0, GPR(7), C_00000000, FXBUS(FXBUS_PCM_LFE), C_00000004);
1901         OP(icode, &ptr, iMACINT0, GPR(8), C_00000000, C_00000000, C_00000000);  /* S/PDIF left */
1902         OP(icode, &ptr, iMACINT0, GPR(9), C_00000000, C_00000000, C_00000000);  /* S/PDIF right */
1903         OP(icode, &ptr, iMACINT0, GPR(10), C_00000000, FXBUS(FXBUS_PCM_LEFT_FRONT), C_00000004);
1904         OP(icode, &ptr, iMACINT0, GPR(11), C_00000000, FXBUS(FXBUS_PCM_RIGHT_FRONT), C_00000004);
1905
1906         /* Raw S/PDIF PCM */
1907         ipcm->substream = 0;
1908         ipcm->channels = 2;
1909         ipcm->tram_start = 0;
1910         ipcm->buffer_size = (64 * 1024) / 2;
1911         ipcm->gpr_size = gpr++;
1912         ipcm->gpr_ptr = gpr++;
1913         ipcm->gpr_count = gpr++;
1914         ipcm->gpr_tmpcount = gpr++;
1915         ipcm->gpr_trigger = gpr++;
1916         ipcm->gpr_running = gpr++;
1917         ipcm->etram[0] = 0;
1918         ipcm->etram[1] = 1;
1919
1920         gpr_map[gpr + 0] = 0xfffff000;
1921         gpr_map[gpr + 1] = 0xffff0000;
1922         gpr_map[gpr + 2] = 0x70000000;
1923         gpr_map[gpr + 3] = 0x00000007;
1924         gpr_map[gpr + 4] = 0x001f << 11;
1925         gpr_map[gpr + 5] = 0x001c << 11;
1926         gpr_map[gpr + 6] = (0x22  - 0x01) - 1;  /* skip at 01 to 22 */
1927         gpr_map[gpr + 7] = (0x22  - 0x06) - 1;  /* skip at 06 to 22 */
1928         gpr_map[gpr + 8] = 0x2000000 + (2<<11);
1929         gpr_map[gpr + 9] = 0x4000000 + (2<<11);
1930         gpr_map[gpr + 10] = 1<<11;
1931         gpr_map[gpr + 11] = (0x24 - 0x0a) - 1;  /* skip at 0a to 24 */
1932         gpr_map[gpr + 12] = 0;
1933
1934         /* if the trigger flag is not set, skip */
1935         /* 00: */ OP(icode, &ptr, iMAC0, C_00000000, GPR(ipcm->gpr_trigger), C_00000000, C_00000000);
1936         /* 01: */ OP(icode, &ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_ZERO, GPR(gpr + 6));
1937         /* if the running flag is set, we're running */
1938         /* 02: */ OP(icode, &ptr, iMAC0, C_00000000, GPR(ipcm->gpr_running), C_00000000, C_00000000);
1939         /* 03: */ OP(icode, &ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, C_00000004);
1940         /* wait until ((GPR_DBAC>>11) & 0x1f) == 0x1c) */
1941         /* 04: */ OP(icode, &ptr, iANDXOR, GPR(tmp + 0), GPR_DBAC, GPR(gpr + 4), C_00000000);
1942         /* 05: */ OP(icode, &ptr, iMACINT0, C_00000000, GPR(tmp + 0), C_ffffffff, GPR(gpr + 5));
1943         /* 06: */ OP(icode, &ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, GPR(gpr + 7));
1944         /* 07: */ OP(icode, &ptr, iACC3, GPR(gpr + 12), C_00000010, C_00000001, C_00000000);
1945
1946         /* 08: */ OP(icode, &ptr, iANDXOR, GPR(ipcm->gpr_running), GPR(ipcm->gpr_running), C_00000000, C_00000001);
1947         /* 09: */ OP(icode, &ptr, iACC3, GPR(gpr + 12), GPR(gpr + 12), C_ffffffff, C_00000000);
1948         /* 0a: */ OP(icode, &ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, GPR(gpr + 11));
1949         /* 0b: */ OP(icode, &ptr, iACC3, GPR(gpr + 12), C_00000001, C_00000000, C_00000000);
1950
1951         /* 0c: */ OP(icode, &ptr, iANDXOR, GPR(tmp + 0), ETRAM_DATA(ipcm->etram[0]), GPR(gpr + 0), C_00000000);
1952         /* 0d: */ OP(icode, &ptr, iLOG, GPR(tmp + 0), GPR(tmp + 0), GPR(gpr + 3), C_00000000);
1953         /* 0e: */ OP(icode, &ptr, iANDXOR, GPR(8), GPR(tmp + 0), GPR(gpr + 1), GPR(gpr + 2));
1954         /* 0f: */ OP(icode, &ptr, iSKIP, C_00000000, GPR_COND, CC_REG_MINUS, C_00000001);
1955         /* 10: */ OP(icode, &ptr, iANDXOR, GPR(8), GPR(8), GPR(gpr + 1), GPR(gpr + 2));
1956
1957         /* 11: */ OP(icode, &ptr, iANDXOR, GPR(tmp + 0), ETRAM_DATA(ipcm->etram[1]), GPR(gpr + 0), C_00000000);
1958         /* 12: */ OP(icode, &ptr, iLOG, GPR(tmp + 0), GPR(tmp + 0), GPR(gpr + 3), C_00000000);
1959         /* 13: */ OP(icode, &ptr, iANDXOR, GPR(9), GPR(tmp + 0), GPR(gpr + 1), GPR(gpr + 2));
1960         /* 14: */ OP(icode, &ptr, iSKIP, C_00000000, GPR_COND, CC_REG_MINUS, C_00000001);
1961         /* 15: */ OP(icode, &ptr, iANDXOR, GPR(9), GPR(9), GPR(gpr + 1), GPR(gpr + 2));
1962
1963         /* 16: */ OP(icode, &ptr, iACC3, GPR(tmp + 0), GPR(ipcm->gpr_ptr), C_00000001, C_00000000);
1964         /* 17: */ OP(icode, &ptr, iMACINT0, C_00000000, GPR(tmp + 0), C_ffffffff, GPR(ipcm->gpr_size));
1965         /* 18: */ OP(icode, &ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_MINUS, C_00000001);
1966         /* 19: */ OP(icode, &ptr, iACC3, GPR(tmp + 0), C_00000000, C_00000000, C_00000000);
1967         /* 1a: */ OP(icode, &ptr, iACC3, GPR(ipcm->gpr_ptr), GPR(tmp + 0), C_00000000, C_00000000);
1968
1969         /* 1b: */ OP(icode, &ptr, iACC3, GPR(ipcm->gpr_tmpcount), GPR(ipcm->gpr_tmpcount), C_ffffffff, C_00000000);
1970         /* 1c: */ OP(icode, &ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, C_00000002);
1971         /* 1d: */ OP(icode, &ptr, iACC3, GPR(ipcm->gpr_tmpcount), GPR(ipcm->gpr_count), C_00000000, C_00000000);
1972         /* 1e: */ OP(icode, &ptr, iACC3, GPR_IRQ, C_80000000, C_00000000, C_00000000);
1973         /* 1f: */ OP(icode, &ptr, iANDXOR, GPR(ipcm->gpr_running), GPR(ipcm->gpr_running), C_00000001, C_00010000);
1974
1975         /* 20: */ OP(icode, &ptr, iANDXOR, GPR(ipcm->gpr_running), GPR(ipcm->gpr_running), C_00010000, C_00000001);
1976         /* 21: */ OP(icode, &ptr, iSKIP, C_00000000, C_7fffffff, C_7fffffff, C_00000002);
1977
1978         /* 22: */ OP(icode, &ptr, iMACINT1, ETRAM_ADDR(ipcm->etram[0]), GPR(gpr + 8), GPR_DBAC, C_ffffffff);
1979         /* 23: */ OP(icode, &ptr, iMACINT1, ETRAM_ADDR(ipcm->etram[1]), GPR(gpr + 9), GPR_DBAC, C_ffffffff);
1980
1981         /* 24: */
1982         gpr += 13;
1983
1984         /* Wave Playback Volume */
1985         for (z = 0; z < 2; z++)
1986                 VOLUME(icode, &ptr, playback + z, z, gpr + z);
1987         snd_emu10k1_init_stereo_control(controls + i++, "Wave Playback Volume", gpr, 100);
1988         gpr += 2;
1989
1990         /* Wave Surround Playback Volume */
1991         for (z = 0; z < 2; z++)
1992                 VOLUME(icode, &ptr, playback + 2 + z, z, gpr + z);
1993         snd_emu10k1_init_stereo_control(controls + i++, "Wave Surround Playback Volume", gpr, 0);
1994         gpr += 2;
1995
1996         /* Wave Center/LFE Playback Volume */
1997         OP(icode, &ptr, iACC3, GPR(tmp + 0), FXBUS(FXBUS_PCM_LEFT), FXBUS(FXBUS_PCM_RIGHT), C_00000000);
1998         OP(icode, &ptr, iMACINT0, GPR(tmp + 0), C_00000000, GPR(tmp + 0), C_00000002);
1999         VOLUME(icode, &ptr, playback + 4, tmp + 0, gpr);
2000         snd_emu10k1_init_mono_control(controls + i++, "Wave Center Playback Volume", gpr++, 0);
2001         VOLUME(icode, &ptr, playback + 5, tmp + 0, gpr);
2002         snd_emu10k1_init_mono_control(controls + i++, "Wave LFE Playback Volume", gpr++, 0);
2003
2004         /* Wave Capture Volume + Switch */
2005         for (z = 0; z < 2; z++) {
2006                 SWITCH(icode, &ptr, tmp + 0, z, gpr + 2 + z);
2007                 VOLUME(icode, &ptr, capture + z, tmp + 0, gpr + z);
2008         }
2009         snd_emu10k1_init_stereo_control(controls + i++, "Wave Capture Volume", gpr, 0);
2010         snd_emu10k1_init_stereo_onoff_control(controls + i++, "Wave Capture Switch", gpr + 2, 0);
2011         gpr += 4;
2012
2013         /* Synth Playback Volume */
2014         for (z = 0; z < 2; z++)
2015                 VOLUME_ADD(icode, &ptr, playback + z, 2 + z, gpr + z);
2016         snd_emu10k1_init_stereo_control(controls + i++, "Synth Playback Volume", gpr, 100);
2017         gpr += 2;
2018
2019         /* Synth Capture Volume + Switch */
2020         for (z = 0; z < 2; z++) {
2021                 SWITCH(icode, &ptr, tmp + 0, 2 + z, gpr + 2 + z);
2022                 VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z);
2023         }
2024         snd_emu10k1_init_stereo_control(controls + i++, "Synth Capture Volume", gpr, 0);
2025         snd_emu10k1_init_stereo_onoff_control(controls + i++, "Synth Capture Switch", gpr + 2, 0);
2026         gpr += 4;
2027
2028         /* Surround Digital Playback Volume (renamed later without Digital) */
2029         for (z = 0; z < 2; z++)
2030                 VOLUME_ADD(icode, &ptr, playback + 2 + z, 4 + z, gpr + z);
2031         snd_emu10k1_init_stereo_control(controls + i++, "Surround Digital Playback Volume", gpr, 100);
2032         gpr += 2;
2033
2034         /* Surround Capture Volume + Switch */
2035         for (z = 0; z < 2; z++) {
2036                 SWITCH(icode, &ptr, tmp + 0, 4 + z, gpr + 2 + z);
2037                 VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z);
2038         }
2039         snd_emu10k1_init_stereo_control(controls + i++, "Surround Capture Volume", gpr, 0);
2040         snd_emu10k1_init_stereo_onoff_control(controls + i++, "Surround Capture Switch", gpr + 2, 0);
2041         gpr += 4;
2042
2043         /* Center Playback Volume (renamed later without Digital) */
2044         VOLUME_ADD(icode, &ptr, playback + 4, 6, gpr);
2045         snd_emu10k1_init_mono_control(controls + i++, "Center Digital Playback Volume", gpr++, 100);
2046
2047         /* LFE Playback Volume + Switch (renamed later without Digital) */
2048         VOLUME_ADD(icode, &ptr, playback + 5, 7, gpr);
2049         snd_emu10k1_init_mono_control(controls + i++, "LFE Digital Playback Volume", gpr++, 100);
2050
2051         /* Front Playback Volume */
2052         for (z = 0; z < 2; z++)
2053                 VOLUME_ADD(icode, &ptr, playback + z, 10 + z, gpr + z);
2054         snd_emu10k1_init_stereo_control(controls + i++, "Front Playback Volume", gpr, 100);
2055         gpr += 2;
2056
2057         /* Front Capture Volume + Switch */
2058         for (z = 0; z < 2; z++) {
2059                 SWITCH(icode, &ptr, tmp + 0, 10 + z, gpr + 2);
2060                 VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z);
2061         }
2062         snd_emu10k1_init_stereo_control(controls + i++, "Front Capture Volume", gpr, 0);
2063         snd_emu10k1_init_mono_onoff_control(controls + i++, "Front Capture Switch", gpr + 2, 0);
2064         gpr += 3;
2065
2066         /*
2067          *  Process inputs
2068          */
2069
2070         if (emu->fx8010.extin_mask & ((1<<EXTIN_AC97_L)|(1<<EXTIN_AC97_R))) {
2071                 /* AC'97 Playback Volume */
2072                 VOLUME_ADDIN(icode, &ptr, playback + 0, EXTIN_AC97_L, gpr); gpr++;
2073                 VOLUME_ADDIN(icode, &ptr, playback + 1, EXTIN_AC97_R, gpr); gpr++;
2074                 snd_emu10k1_init_stereo_control(controls + i++, "AC97 Playback Volume", gpr-2, 0);
2075                 /* AC'97 Capture Volume */
2076                 VOLUME_ADDIN(icode, &ptr, capture + 0, EXTIN_AC97_L, gpr); gpr++;
2077                 VOLUME_ADDIN(icode, &ptr, capture + 1, EXTIN_AC97_R, gpr); gpr++;
2078                 snd_emu10k1_init_stereo_control(controls + i++, "AC97 Capture Volume", gpr-2, 100);
2079         }
2080
2081         if (emu->fx8010.extin_mask & ((1<<EXTIN_SPDIF_CD_L)|(1<<EXTIN_SPDIF_CD_R))) {
2082                 /* IEC958 TTL Playback Volume */
2083                 for (z = 0; z < 2; z++)
2084                         VOLUME_ADDIN(icode, &ptr, playback + z, EXTIN_SPDIF_CD_L + z, gpr + z);
2085                 snd_emu10k1_init_stereo_control(controls + i++, SNDRV_CTL_NAME_IEC958("TTL ",PLAYBACK,VOLUME), gpr, 0);
2086                 gpr += 2;
2087
2088                 /* IEC958 TTL Capture Volume + Switch */
2089                 for (z = 0; z < 2; z++) {
2090                         SWITCH_IN(icode, &ptr, tmp + 0, EXTIN_SPDIF_CD_L + z, gpr + 2 + z);
2091                         VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z);
2092                 }
2093                 snd_emu10k1_init_stereo_control(controls + i++, SNDRV_CTL_NAME_IEC958("TTL ",CAPTURE,VOLUME), gpr, 0);
2094                 snd_emu10k1_init_stereo_onoff_control(controls + i++, SNDRV_CTL_NAME_IEC958("TTL ",CAPTURE,SWITCH), gpr + 2, 0);
2095                 gpr += 4;
2096         }
2097
2098         if (emu->fx8010.extin_mask & ((1<<EXTIN_ZOOM_L)|(1<<EXTIN_ZOOM_R))) {
2099                 /* Zoom Video Playback Volume */
2100                 for (z = 0; z < 2; z++)
2101                         VOLUME_ADDIN(icode, &ptr, playback + z, EXTIN_ZOOM_L + z, gpr + z);
2102                 snd_emu10k1_init_stereo_control(controls + i++, "Zoom Video Playback Volume", gpr, 0);
2103                 gpr += 2;
2104
2105                 /* Zoom Video Capture Volume + Switch */
2106                 for (z = 0; z < 2; z++) {
2107                         SWITCH_IN(icode, &ptr, tmp + 0, EXTIN_ZOOM_L + z, gpr + 2 + z);
2108                         VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z);
2109                 }
2110                 snd_emu10k1_init_stereo_control(controls + i++, "Zoom Video Capture Volume", gpr, 0);
2111                 snd_emu10k1_init_stereo_onoff_control(controls + i++, "Zoom Video Capture Switch", gpr + 2, 0);
2112                 gpr += 4;
2113         }
2114
2115         if (emu->fx8010.extin_mask & ((1<<EXTIN_TOSLINK_L)|(1<<EXTIN_TOSLINK_R))) {
2116                 /* IEC958 Optical Playback Volume */
2117                 for (z = 0; z < 2; z++)
2118                         VOLUME_ADDIN(icode, &ptr, playback + z, EXTIN_TOSLINK_L + z, gpr + z);
2119                 snd_emu10k1_init_stereo_control(controls + i++, SNDRV_CTL_NAME_IEC958("LiveDrive ",PLAYBACK,VOLUME), gpr, 0);
2120                 gpr += 2;
2121
2122                 /* IEC958 Optical Capture Volume */
2123                 for (z = 0; z < 2; z++) {
2124                         SWITCH_IN(icode, &ptr, tmp + 0, EXTIN_TOSLINK_L + z, gpr + 2 + z);
2125                         VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z);
2126                 }
2127                 snd_emu10k1_init_stereo_control(controls + i++, SNDRV_CTL_NAME_IEC958("LiveDrive ",CAPTURE,VOLUME), gpr, 0);
2128                 snd_emu10k1_init_stereo_onoff_control(controls + i++, SNDRV_CTL_NAME_IEC958("LiveDrive ",CAPTURE,SWITCH), gpr + 2, 0);
2129                 gpr += 4;
2130         }
2131
2132         if (emu->fx8010.extin_mask & ((1<<EXTIN_LINE1_L)|(1<<EXTIN_LINE1_R))) {
2133                 /* Line LiveDrive Playback Volume */
2134                 for (z = 0; z < 2; z++)
2135                         VOLUME_ADDIN(icode, &ptr, playback + z, EXTIN_LINE1_L + z, gpr + z);
2136                 snd_emu10k1_init_stereo_control(controls + i++, "Line LiveDrive Playback Volume", gpr, 0);
2137                 gpr += 2;
2138
2139                 /* Line LiveDrive Capture Volume + Switch */
2140                 for (z = 0; z < 2; z++) {
2141                         SWITCH_IN(icode, &ptr, tmp + 0, EXTIN_LINE1_L + z, gpr + 2 + z);
2142                         VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z);
2143                 }
2144                 snd_emu10k1_init_stereo_control(controls + i++, "Line LiveDrive Capture Volume", gpr, 0);
2145                 snd_emu10k1_init_stereo_onoff_control(controls + i++, "Line LiveDrive Capture Switch", gpr + 2, 0);
2146                 gpr += 4;
2147         }
2148
2149         if (emu->fx8010.extin_mask & ((1<<EXTIN_COAX_SPDIF_L)|(1<<EXTIN_COAX_SPDIF_R))) {
2150                 /* IEC958 Coax Playback Volume */
2151                 for (z = 0; z < 2; z++)
2152                         VOLUME_ADDIN(icode, &ptr, playback + z, EXTIN_COAX_SPDIF_L + z, gpr + z);
2153                 snd_emu10k1_init_stereo_control(controls + i++, SNDRV_CTL_NAME_IEC958("Coaxial ",PLAYBACK,VOLUME), gpr, 0);
2154                 gpr += 2;
2155
2156                 /* IEC958 Coax Capture Volume + Switch */
2157                 for (z = 0; z < 2; z++) {
2158                         SWITCH_IN(icode, &ptr, tmp + 0, EXTIN_COAX_SPDIF_L + z, gpr + 2 + z);
2159                         VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z);
2160                 }
2161                 snd_emu10k1_init_stereo_control(controls + i++, SNDRV_CTL_NAME_IEC958("Coaxial ",CAPTURE,VOLUME), gpr, 0);
2162                 snd_emu10k1_init_stereo_onoff_control(controls + i++, SNDRV_CTL_NAME_IEC958("Coaxial ",CAPTURE,SWITCH), gpr + 2, 0);
2163                 gpr += 4;
2164         }
2165
2166         if (emu->fx8010.extin_mask & ((1<<EXTIN_LINE2_L)|(1<<EXTIN_LINE2_R))) {
2167                 /* Line LiveDrive Playback Volume */
2168                 for (z = 0; z < 2; z++)
2169                         VOLUME_ADDIN(icode, &ptr, playback + z, EXTIN_LINE2_L + z, gpr + z);
2170                 snd_emu10k1_init_stereo_control(controls + i++, "Line2 LiveDrive Playback Volume", gpr, 0);
2171                 controls[i-1].id.index = 1;
2172                 gpr += 2;
2173
2174                 /* Line LiveDrive Capture Volume */
2175                 for (z = 0; z < 2; z++) {
2176                         SWITCH_IN(icode, &ptr, tmp + 0, EXTIN_LINE2_L + z, gpr + 2 + z);
2177                         VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z);
2178                 }
2179                 snd_emu10k1_init_stereo_control(controls + i++, "Line2 LiveDrive Capture Volume", gpr, 0);
2180                 controls[i-1].id.index = 1;
2181                 snd_emu10k1_init_stereo_onoff_control(controls + i++, "Line2 LiveDrive Capture Switch", gpr + 2, 0);
2182                 controls[i-1].id.index = 1;
2183                 gpr += 4;
2184         }
2185
2186         /*
2187          *  Process tone control
2188          */
2189         OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 0), GPR(playback + 0), C_00000000, C_00000000); /* left */
2190         OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 1), GPR(playback + 1), C_00000000, C_00000000); /* right */
2191         OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 2), GPR(playback + 2), C_00000000, C_00000000); /* rear left */
2192         OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 3), GPR(playback + 3), C_00000000, C_00000000); /* rear right */
2193         OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 4), GPR(playback + 4), C_00000000, C_00000000); /* center */
2194         OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 5), GPR(playback + 5), C_00000000, C_00000000); /* LFE */
2195
2196         ctl = &controls[i + 0];
2197         ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2198         strcpy(ctl->id.name, "Tone Control - Bass");
2199         ctl->vcount = 2;
2200         ctl->count = 10;
2201         ctl->min = 0;
2202         ctl->max = 40;
2203         ctl->value[0] = ctl->value[1] = 20;
2204         ctl->tlv = snd_emu10k1_bass_treble_db_scale;
2205         ctl->translation = EMU10K1_GPR_TRANSLATION_BASS;
2206         ctl = &controls[i + 1];
2207         ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2208         strcpy(ctl->id.name, "Tone Control - Treble");
2209         ctl->vcount = 2;
2210         ctl->count = 10;
2211         ctl->min = 0;
2212         ctl->max = 40;
2213         ctl->value[0] = ctl->value[1] = 20;
2214         ctl->tlv = snd_emu10k1_bass_treble_db_scale;
2215         ctl->translation = EMU10K1_GPR_TRANSLATION_TREBLE;
2216
2217 #define BASS_GPR        0x8c
2218 #define TREBLE_GPR      0x96
2219
2220         for (z = 0; z < 5; z++) {
2221                 int j;
2222                 for (j = 0; j < 2; j++) {
2223                         controls[i + 0].gpr[z * 2 + j] = BASS_GPR + z * 2 + j;
2224                         controls[i + 1].gpr[z * 2 + j] = TREBLE_GPR + z * 2 + j;
2225                 }
2226         }
2227         for (z = 0; z < 3; z++) {               /* front/rear/center-lfe */
2228                 int j, k, l, d;
2229                 for (j = 0; j < 2; j++) {       /* left/right */
2230                         k = 0xa0 + (z * 8) + (j * 4);
2231                         l = 0xd0 + (z * 8) + (j * 4);
2232                         d = playback + SND_EMU10K1_PLAYBACK_CHANNELS + z * 2 + j;
2233
2234                         OP(icode, &ptr, iMAC0, C_00000000, C_00000000, GPR(d), GPR(BASS_GPR + 0 + j));
2235                         OP(icode, &ptr, iMACMV, GPR(k+1), GPR(k), GPR(k+1), GPR(BASS_GPR + 4 + j));
2236                         OP(icode, &ptr, iMACMV, GPR(k), GPR(d), GPR(k), GPR(BASS_GPR + 2 + j));
2237                         OP(icode, &ptr, iMACMV, GPR(k+3), GPR(k+2), GPR(k+3), GPR(BASS_GPR + 8 + j));
2238                         OP(icode, &ptr, iMAC0, GPR(k+2), GPR_ACCU, GPR(k+2), GPR(BASS_GPR + 6 + j));
2239                         OP(icode, &ptr, iACC3, GPR(k+2), GPR(k+2), GPR(k+2), C_00000000);
2240
2241                         OP(icode, &ptr, iMAC0, C_00000000, C_00000000, GPR(k+2), GPR(TREBLE_GPR + 0 + j));
2242                         OP(icode, &ptr, iMACMV, GPR(l+1), GPR(l), GPR(l+1), GPR(TREBLE_GPR + 4 + j));
2243                         OP(icode, &ptr, iMACMV, GPR(l), GPR(k+2), GPR(l), GPR(TREBLE_GPR + 2 + j));
2244                         OP(icode, &ptr, iMACMV, GPR(l+3), GPR(l+2), GPR(l+3), GPR(TREBLE_GPR + 8 + j));
2245                         OP(icode, &ptr, iMAC0, GPR(l+2), GPR_ACCU, GPR(l+2), GPR(TREBLE_GPR + 6 + j));
2246                         OP(icode, &ptr, iMACINT0, GPR(l+2), C_00000000, GPR(l+2), C_00000010);
2247
2248                         OP(icode, &ptr, iACC3, GPR(d), GPR(l+2), C_00000000, C_00000000);
2249
2250                         if (z == 2)     /* center */
2251                                 break;
2252                 }
2253         }
2254         i += 2;
2255
2256 #undef BASS_GPR
2257 #undef TREBLE_GPR
2258
2259         for (z = 0; z < 6; z++) {
2260                 SWITCH(icode, &ptr, tmp + 0, playback + SND_EMU10K1_PLAYBACK_CHANNELS + z, gpr + 0);
2261                 SWITCH_NEG(icode, &ptr, tmp + 1, gpr + 0);
2262                 SWITCH(icode, &ptr, tmp + 1, playback + z, tmp + 1);
2263                 OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + z), GPR(tmp + 0), GPR(tmp + 1), C_00000000);
2264         }
2265         snd_emu10k1_init_stereo_onoff_control(controls + i++, "Tone Control - Switch", gpr, 0);
2266         gpr += 2;
2267
2268         /*
2269          *  Process outputs
2270          */
2271         if (emu->fx8010.extout_mask & ((1<<EXTOUT_AC97_L)|(1<<EXTOUT_AC97_R))) {
2272                 /* AC'97 Playback Volume */
2273
2274                 for (z = 0; z < 2; z++)
2275                         OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_AC97_L + z), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + z), C_00000000, C_00000000);
2276         }
2277
2278         if (emu->fx8010.extout_mask & ((1<<EXTOUT_TOSLINK_L)|(1<<EXTOUT_TOSLINK_R))) {
2279                 /* IEC958 Optical Raw Playback Switch */
2280
2281                 for (z = 0; z < 2; z++) {
2282                         SWITCH(icode, &ptr, tmp + 0, 8 + z, gpr + z);
2283                         SWITCH_NEG(icode, &ptr, tmp + 1, gpr + z);
2284                         SWITCH(icode, &ptr, tmp + 1, playback + SND_EMU10K1_PLAYBACK_CHANNELS + z, tmp + 1);
2285                         OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_TOSLINK_L + z), GPR(tmp + 0), GPR(tmp + 1), C_00000000);
2286 #ifdef EMU10K1_CAPTURE_DIGITAL_OUT
2287                         OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_ADC_CAP_L + z), GPR(tmp + 0), GPR(tmp + 1), C_00000000);
2288 #endif
2289                 }
2290
2291                 snd_emu10k1_init_stereo_onoff_control(controls + i++, SNDRV_CTL_NAME_IEC958("Optical Raw ",PLAYBACK,SWITCH), gpr, 0);
2292                 gpr += 2;
2293         }
2294
2295         if (emu->fx8010.extout_mask & ((1<<EXTOUT_HEADPHONE_L)|(1<<EXTOUT_HEADPHONE_R))) {
2296                 /* Headphone Playback Volume */
2297
2298                 for (z = 0; z < 2; z++) {
2299                         SWITCH(icode, &ptr, tmp + 0, playback + SND_EMU10K1_PLAYBACK_CHANNELS + 4 + z, gpr + 2 + z);
2300                         SWITCH_NEG(icode, &ptr, tmp + 1, gpr + 2 + z);
2301                         SWITCH(icode, &ptr, tmp + 1, playback + SND_EMU10K1_PLAYBACK_CHANNELS + z, tmp + 1);
2302                         OP(icode, &ptr, iACC3, GPR(tmp + 0), GPR(tmp + 0), GPR(tmp + 1), C_00000000);
2303                         VOLUME_OUT(icode, &ptr, EXTOUT_HEADPHONE_L + z, tmp + 0, gpr + z);
2304                 }
2305
2306                 snd_emu10k1_init_stereo_control(controls + i++, "Headphone Playback Volume", gpr + 0, 0);
2307                 controls[i-1].id.index = 1;     /* AC'97 can have also Headphone control */
2308                 snd_emu10k1_init_mono_onoff_control(controls + i++, "Headphone Center Playback Switch", gpr + 2, 0);
2309                 controls[i-1].id.index = 1;
2310                 snd_emu10k1_init_mono_onoff_control(controls + i++, "Headphone LFE Playback Switch", gpr + 3, 0);
2311                 controls[i-1].id.index = 1;
2312
2313                 gpr += 4;
2314         }
2315
2316         if (emu->fx8010.extout_mask & ((1<<EXTOUT_REAR_L)|(1<<EXTOUT_REAR_R)))
2317                 for (z = 0; z < 2; z++)
2318                         OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_REAR_L + z), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 2 + z), C_00000000, C_00000000);
2319
2320         if (emu->fx8010.extout_mask & ((1<<EXTOUT_AC97_REAR_L)|(1<<EXTOUT_AC97_REAR_R)))
2321                 for (z = 0; z < 2; z++)
2322                         OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_AC97_REAR_L + z), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 2 + z), C_00000000, C_00000000);
2323
2324         if (emu->fx8010.extout_mask & (1<<EXTOUT_AC97_CENTER)) {
2325 #ifndef EMU10K1_CENTER_LFE_FROM_FRONT
2326                 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_AC97_CENTER), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 4), C_00000000, C_00000000);
2327                 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_ACENTER), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 4), C_00000000, C_00000000);
2328 #else
2329                 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_AC97_CENTER), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 0), C_00000000, C_00000000);
2330                 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_ACENTER), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 0), C_00000000, C_00000000);
2331 #endif
2332         }
2333
2334         if (emu->fx8010.extout_mask & (1<<EXTOUT_AC97_LFE)) {
2335 #ifndef EMU10K1_CENTER_LFE_FROM_FRONT
2336                 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_AC97_LFE), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 5), C_00000000, C_00000000);
2337                 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_ALFE), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 5), C_00000000, C_00000000);
2338 #else
2339                 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_AC97_LFE), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 1), C_00000000, C_00000000);
2340                 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_ALFE), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 1), C_00000000, C_00000000);
2341 #endif
2342         }
2343
2344 #ifndef EMU10K1_CAPTURE_DIGITAL_OUT
2345         for (z = 0; z < 2; z++)
2346                 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_ADC_CAP_L + z), GPR(capture + z), C_00000000, C_00000000);
2347 #endif
2348
2349         if (emu->fx8010.extout_mask & (1<<EXTOUT_MIC_CAP))
2350                 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_MIC_CAP), GPR(capture + 2), C_00000000, C_00000000);
2351
2352         /* EFX capture - capture the 16 EXTINS */
2353         if (emu->card_capabilities->sblive51) {
2354                 /* On the Live! 5.1, FXBUS2(1) and FXBUS(2) are shared with EXTOUT_ACENTER
2355                  * and EXTOUT_ALFE, so we can't connect inputs to them for multitrack recording.
2356                  *
2357                  * Since only 14 of the 16 EXTINs are used, this is not a big problem.
2358                  * We route AC97L and R to FX capture 14 and 15, SPDIF CD in to FX capture
2359                  * 0 and 3, then the rest of the EXTINs to the corresponding FX capture
2360                  * channel.  Multitrack recorders will still see the center/lfe output signal
2361                  * on the second and third channels.
2362                  */
2363                 OP(icode, &ptr, iACC3, FXBUS2(14), C_00000000, C_00000000, EXTIN(0));
2364                 OP(icode, &ptr, iACC3, FXBUS2(15), C_00000000, C_00000000, EXTIN(1));
2365                 OP(icode, &ptr, iACC3, FXBUS2(0), C_00000000, C_00000000, EXTIN(2));
2366                 OP(icode, &ptr, iACC3, FXBUS2(3), C_00000000, C_00000000, EXTIN(3));
2367                 for (z = 4; z < 14; z++)
2368                         OP(icode, &ptr, iACC3, FXBUS2(z), C_00000000, C_00000000, EXTIN(z));
2369         } else {
2370                 for (z = 0; z < 16; z++)
2371                         OP(icode, &ptr, iACC3, FXBUS2(z), C_00000000, C_00000000, EXTIN(z));
2372         }
2373
2374
2375         if (gpr > tmp) {
2376                 snd_BUG();
2377                 err = -EIO;
2378                 goto __err;
2379         }
2380         if (i > SND_EMU10K1_GPR_CONTROLS) {
2381                 snd_BUG();
2382                 err = -EIO;
2383                 goto __err;
2384         }
2385
2386         /* clear remaining instruction memory */
2387         while (ptr < 0x200)
2388                 OP(icode, &ptr, iACC3, C_00000000, C_00000000, C_00000000, C_00000000);
2389
2390         if ((err = snd_emu10k1_fx8010_tram_setup(emu, ipcm->buffer_size)) < 0)
2391                 goto __err;
2392         icode->gpr_add_control_count = i;
2393         icode->gpr_add_controls = (struct snd_emu10k1_fx8010_control_gpr __user *)controls;
2394         emu->support_tlv = 1; /* support TLV */
2395         err = snd_emu10k1_icode_poke(emu, icode, true);
2396         emu->support_tlv = 0; /* clear again */
2397         if (err >= 0)
2398                 err = snd_emu10k1_ipcm_poke(emu, ipcm);
2399 __err:
2400         kfree(ipcm);
2401 __err_ipcm:
2402         kfree(controls);
2403 __err_ctrls:
2404         kfree((void __force *)icode->gpr_map);
2405 __err_gpr:
2406         kfree(icode);
2407         return err;
2408 }
2409
2410 int snd_emu10k1_init_efx(struct snd_emu10k1 *emu)
2411 {
2412         spin_lock_init(&emu->fx8010.irq_lock);
2413         INIT_LIST_HEAD(&emu->fx8010.gpr_ctl);
2414         if (emu->audigy)
2415                 return _snd_emu10k1_audigy_init_efx(emu);
2416         else
2417                 return _snd_emu10k1_init_efx(emu);
2418 }
2419
2420 void snd_emu10k1_free_efx(struct snd_emu10k1 *emu)
2421 {
2422         /* stop processor */
2423         if (emu->audigy)
2424                 snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg = A_DBG_SINGLE_STEP);
2425         else
2426                 snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg = EMU10K1_DBG_SINGLE_STEP);
2427 }
2428
2429 #if 0 /* FIXME: who use them? */
2430 int snd_emu10k1_fx8010_tone_control_activate(struct snd_emu10k1 *emu, int output)
2431 {
2432         if (output < 0 || output >= 6)
2433                 return -EINVAL;
2434         snd_emu10k1_ptr_write(emu, emu->gpr_base + 0x94 + output, 0, 1);
2435         return 0;
2436 }
2437
2438 int snd_emu10k1_fx8010_tone_control_deactivate(struct snd_emu10k1 *emu, int output)
2439 {
2440         if (output < 0 || output >= 6)
2441                 return -EINVAL;
2442         snd_emu10k1_ptr_write(emu, emu->gpr_base + 0x94 + output, 0, 0);
2443         return 0;
2444 }
2445 #endif
2446
2447 int snd_emu10k1_fx8010_tram_setup(struct snd_emu10k1 *emu, u32 size)
2448 {
2449         u8 size_reg = 0;
2450
2451         /* size is in samples */
2452         if (size != 0) {
2453                 size = (size - 1) >> 13;
2454
2455                 while (size) {
2456                         size >>= 1;
2457                         size_reg++;
2458                 }
2459                 size = 0x2000 << size_reg;
2460         }
2461         if ((emu->fx8010.etram_pages.bytes / 2) == size)
2462                 return 0;
2463         spin_lock_irq(&emu->emu_lock);
2464         outl(HCFG_LOCKTANKCACHE_MASK | inl(emu->port + HCFG), emu->port + HCFG);
2465         spin_unlock_irq(&emu->emu_lock);
2466         snd_emu10k1_ptr_write(emu, TCB, 0, 0);
2467         snd_emu10k1_ptr_write(emu, TCBS, 0, 0);
2468         if (emu->fx8010.etram_pages.area != NULL) {
2469                 snd_dma_free_pages(&emu->fx8010.etram_pages);
2470                 emu->fx8010.etram_pages.area = NULL;
2471                 emu->fx8010.etram_pages.bytes = 0;
2472         }
2473
2474         if (size > 0) {
2475                 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(emu->pci),
2476                                         size * 2, &emu->fx8010.etram_pages) < 0)
2477                         return -ENOMEM;
2478                 memset(emu->fx8010.etram_pages.area, 0, size * 2);
2479                 snd_emu10k1_ptr_write(emu, TCB, 0, emu->fx8010.etram_pages.addr);
2480                 snd_emu10k1_ptr_write(emu, TCBS, 0, size_reg);
2481                 spin_lock_irq(&emu->emu_lock);
2482                 outl(inl(emu->port + HCFG) & ~HCFG_LOCKTANKCACHE_MASK, emu->port + HCFG);
2483                 spin_unlock_irq(&emu->emu_lock);
2484         }
2485
2486         return 0;
2487 }
2488
2489 static int snd_emu10k1_fx8010_open(struct snd_hwdep * hw, struct file *file)
2490 {
2491         return 0;
2492 }
2493
2494 static void copy_string(char *dst, char *src, char *null, int idx)
2495 {
2496         if (src == NULL)
2497                 sprintf(dst, "%s %02X", null, idx);
2498         else
2499                 strcpy(dst, src);
2500 }
2501
2502 static void snd_emu10k1_fx8010_info(struct snd_emu10k1 *emu,
2503                                    struct snd_emu10k1_fx8010_info *info)
2504 {
2505         char **fxbus, **extin, **extout;
2506         unsigned short fxbus_mask, extin_mask, extout_mask;
2507         int res;
2508
2509         info->internal_tram_size = emu->fx8010.itram_size;
2510         info->external_tram_size = emu->fx8010.etram_pages.bytes / 2;
2511         fxbus = fxbuses;
2512         extin = emu->audigy ? audigy_ins : creative_ins;
2513         extout = emu->audigy ? audigy_outs : creative_outs;
2514         fxbus_mask = emu->fx8010.fxbus_mask;
2515         extin_mask = emu->fx8010.extin_mask;
2516         extout_mask = emu->fx8010.extout_mask;
2517         for (res = 0; res < 16; res++, fxbus++, extin++, extout++) {
2518                 copy_string(info->fxbus_names[res], fxbus_mask & (1 << res) ? *fxbus : NULL, "FXBUS", res);
2519                 copy_string(info->extin_names[res], extin_mask & (1 << res) ? *extin : NULL, "Unused", res);
2520                 copy_string(info->extout_names[res], extout_mask & (1 << res) ? *extout : NULL, "Unused", res);
2521         }
2522         for (res = 16; res < 32; res++, extout++)
2523                 copy_string(info->extout_names[res], extout_mask & (1 << res) ? *extout : NULL, "Unused", res);
2524         info->gpr_controls = emu->fx8010.gpr_count;
2525 }
2526
2527 static int snd_emu10k1_fx8010_ioctl(struct snd_hwdep * hw, struct file *file, unsigned int cmd, unsigned long arg)
2528 {
2529         struct snd_emu10k1 *emu = hw->private_data;
2530         struct snd_emu10k1_fx8010_info *info;
2531         struct snd_emu10k1_fx8010_code *icode;
2532         struct snd_emu10k1_fx8010_pcm_rec *ipcm;
2533         unsigned int addr;
2534         void __user *argp = (void __user *)arg;
2535         int res;
2536
2537         switch (cmd) {
2538         case SNDRV_EMU10K1_IOCTL_PVERSION:
2539                 emu->support_tlv = 1;
2540                 return put_user(SNDRV_EMU10K1_VERSION, (int __user *)argp);
2541         case SNDRV_EMU10K1_IOCTL_INFO:
2542                 info = kmalloc(sizeof(*info), GFP_KERNEL);
2543                 if (!info)
2544                         return -ENOMEM;
2545                 snd_emu10k1_fx8010_info(emu, info);
2546                 if (copy_to_user(argp, info, sizeof(*info))) {
2547                         kfree(info);
2548                         return -EFAULT;
2549                 }
2550                 kfree(info);
2551                 return 0;
2552         case SNDRV_EMU10K1_IOCTL_CODE_POKE:
2553                 if (!capable(CAP_SYS_ADMIN))
2554                         return -EPERM;
2555
2556                 icode = memdup_user(argp, sizeof(*icode));
2557                 if (IS_ERR(icode))
2558                         return PTR_ERR(icode);
2559                 res = snd_emu10k1_icode_poke(emu, icode, false);
2560                 kfree(icode);
2561                 return res;
2562         case SNDRV_EMU10K1_IOCTL_CODE_PEEK:
2563                 icode = memdup_user(argp, sizeof(*icode));
2564                 if (IS_ERR(icode))
2565                         return PTR_ERR(icode);
2566                 res = snd_emu10k1_icode_peek(emu, icode);
2567                 if (res == 0 && copy_to_user(argp, icode, sizeof(*icode))) {
2568                         kfree(icode);
2569                         return -EFAULT;
2570                 }
2571                 kfree(icode);
2572                 return res;
2573         case SNDRV_EMU10K1_IOCTL_PCM_POKE:
2574                 ipcm = memdup_user(argp, sizeof(*ipcm));
2575                 if (IS_ERR(ipcm))
2576                         return PTR_ERR(ipcm);
2577                 res = snd_emu10k1_ipcm_poke(emu, ipcm);
2578                 kfree(ipcm);
2579                 return res;
2580         case SNDRV_EMU10K1_IOCTL_PCM_PEEK:
2581                 ipcm = memdup_user(argp, sizeof(*ipcm));
2582                 if (IS_ERR(ipcm))
2583                         return PTR_ERR(ipcm);
2584                 res = snd_emu10k1_ipcm_peek(emu, ipcm);
2585                 if (res == 0 && copy_to_user(argp, ipcm, sizeof(*ipcm))) {
2586                         kfree(ipcm);
2587                         return -EFAULT;
2588                 }
2589                 kfree(ipcm);
2590                 return res;
2591         case SNDRV_EMU10K1_IOCTL_TRAM_SETUP:
2592                 if (!capable(CAP_SYS_ADMIN))
2593                         return -EPERM;
2594                 if (get_user(addr, (unsigned int __user *)argp))
2595                         return -EFAULT;
2596                 mutex_lock(&emu->fx8010.lock);
2597                 res = snd_emu10k1_fx8010_tram_setup(emu, addr);
2598                 mutex_unlock(&emu->fx8010.lock);
2599                 return res;
2600         case SNDRV_EMU10K1_IOCTL_STOP:
2601                 if (!capable(CAP_SYS_ADMIN))
2602                         return -EPERM;
2603                 if (emu->audigy)
2604                         snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg |= A_DBG_SINGLE_STEP);
2605                 else
2606                         snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg |= EMU10K1_DBG_SINGLE_STEP);
2607                 return 0;
2608         case SNDRV_EMU10K1_IOCTL_CONTINUE:
2609                 if (!capable(CAP_SYS_ADMIN))
2610                         return -EPERM;
2611                 if (emu->audigy)
2612                         snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg = 0);
2613                 else
2614                         snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg = 0);
2615                 return 0;
2616         case SNDRV_EMU10K1_IOCTL_ZERO_TRAM_COUNTER:
2617                 if (!capable(CAP_SYS_ADMIN))
2618                         return -EPERM;
2619                 if (emu->audigy)
2620                         snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg | A_DBG_ZC);
2621                 else
2622                         snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg | EMU10K1_DBG_ZC);
2623                 udelay(10);
2624                 if (emu->audigy)
2625                         snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg);
2626                 else
2627                         snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg);
2628                 return 0;
2629         case SNDRV_EMU10K1_IOCTL_SINGLE_STEP:
2630                 if (!capable(CAP_SYS_ADMIN))
2631                         return -EPERM;
2632                 if (get_user(addr, (unsigned int __user *)argp))
2633                         return -EFAULT;
2634                 if (addr > 0x1ff)
2635                         return -EINVAL;
2636                 if (emu->audigy)
2637                         snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg |= A_DBG_SINGLE_STEP | addr);
2638                 else
2639                         snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg |= EMU10K1_DBG_SINGLE_STEP | addr);
2640                 udelay(10);
2641                 if (emu->audigy)
2642                         snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg |= A_DBG_SINGLE_STEP | A_DBG_STEP_ADDR | addr);
2643                 else
2644                         snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg |= EMU10K1_DBG_SINGLE_STEP | EMU10K1_DBG_STEP | addr);
2645                 return 0;
2646         case SNDRV_EMU10K1_IOCTL_DBG_READ:
2647                 if (emu->audigy)
2648                         addr = snd_emu10k1_ptr_read(emu, A_DBG, 0);
2649                 else
2650                         addr = snd_emu10k1_ptr_read(emu, DBG, 0);
2651                 if (put_user(addr, (unsigned int __user *)argp))
2652                         return -EFAULT;
2653                 return 0;
2654         }
2655         return -ENOTTY;
2656 }
2657
2658 static int snd_emu10k1_fx8010_release(struct snd_hwdep * hw, struct file *file)
2659 {
2660         return 0;
2661 }
2662
2663 int snd_emu10k1_fx8010_new(struct snd_emu10k1 *emu, int device)
2664 {
2665         struct snd_hwdep *hw;
2666         int err;
2667
2668         if ((err = snd_hwdep_new(emu->card, "FX8010", device, &hw)) < 0)
2669                 return err;
2670         strcpy(hw->name, "EMU10K1 (FX8010)");
2671         hw->iface = SNDRV_HWDEP_IFACE_EMU10K1;
2672         hw->ops.open = snd_emu10k1_fx8010_open;
2673         hw->ops.ioctl = snd_emu10k1_fx8010_ioctl;
2674         hw->ops.release = snd_emu10k1_fx8010_release;
2675         hw->private_data = emu;
2676         return 0;
2677 }
2678
2679 #ifdef CONFIG_PM_SLEEP
2680 int snd_emu10k1_efx_alloc_pm_buffer(struct snd_emu10k1 *emu)
2681 {
2682         int len;
2683
2684         len = emu->audigy ? 0x200 : 0x100;
2685         emu->saved_gpr = kmalloc(len * 4, GFP_KERNEL);
2686         if (! emu->saved_gpr)
2687                 return -ENOMEM;
2688         len = emu->audigy ? 0x100 : 0xa0;
2689         emu->tram_val_saved = kmalloc(len * 4, GFP_KERNEL);
2690         emu->tram_addr_saved = kmalloc(len * 4, GFP_KERNEL);
2691         if (! emu->tram_val_saved || ! emu->tram_addr_saved)
2692                 return -ENOMEM;
2693         len = emu->audigy ? 2 * 1024 : 2 * 512;
2694         emu->saved_icode = vmalloc(len * 4);
2695         if (! emu->saved_icode)
2696                 return -ENOMEM;
2697         return 0;
2698 }
2699
2700 void snd_emu10k1_efx_free_pm_buffer(struct snd_emu10k1 *emu)
2701 {
2702         kfree(emu->saved_gpr);
2703         kfree(emu->tram_val_saved);
2704         kfree(emu->tram_addr_saved);
2705         vfree(emu->saved_icode);
2706 }
2707
2708 /*
2709  * save/restore GPR, TRAM and codes
2710  */
2711 void snd_emu10k1_efx_suspend(struct snd_emu10k1 *emu)
2712 {
2713         int i, len;
2714
2715         len = emu->audigy ? 0x200 : 0x100;
2716         for (i = 0; i < len; i++)
2717                 emu->saved_gpr[i] = snd_emu10k1_ptr_read(emu, emu->gpr_base + i, 0);
2718
2719         len = emu->audigy ? 0x100 : 0xa0;
2720         for (i = 0; i < len; i++) {
2721                 emu->tram_val_saved[i] = snd_emu10k1_ptr_read(emu, TANKMEMDATAREGBASE + i, 0);
2722                 emu->tram_addr_saved[i] = snd_emu10k1_ptr_read(emu, TANKMEMADDRREGBASE + i, 0);
2723                 if (emu->audigy) {
2724                         emu->tram_addr_saved[i] >>= 12;
2725                         emu->tram_addr_saved[i] |=
2726                                 snd_emu10k1_ptr_read(emu, A_TANKMEMCTLREGBASE + i, 0) << 20;
2727                 }
2728         }
2729
2730         len = emu->audigy ? 2 * 1024 : 2 * 512;
2731         for (i = 0; i < len; i++)
2732                 emu->saved_icode[i] = snd_emu10k1_efx_read(emu, i);
2733 }
2734
2735 void snd_emu10k1_efx_resume(struct snd_emu10k1 *emu)
2736 {
2737         int i, len;
2738
2739         /* set up TRAM */
2740         if (emu->fx8010.etram_pages.bytes > 0) {
2741                 unsigned size, size_reg = 0;
2742                 size = emu->fx8010.etram_pages.bytes / 2;
2743                 size = (size - 1) >> 13;
2744                 while (size) {
2745                         size >>= 1;
2746                         size_reg++;
2747                 }
2748                 outl(HCFG_LOCKTANKCACHE_MASK | inl(emu->port + HCFG), emu->port + HCFG);
2749                 snd_emu10k1_ptr_write(emu, TCB, 0, emu->fx8010.etram_pages.addr);
2750                 snd_emu10k1_ptr_write(emu, TCBS, 0, size_reg);
2751                 outl(inl(emu->port + HCFG) & ~HCFG_LOCKTANKCACHE_MASK, emu->port + HCFG);
2752         }
2753
2754         if (emu->audigy)
2755                 snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg | A_DBG_SINGLE_STEP);
2756         else
2757                 snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg | EMU10K1_DBG_SINGLE_STEP);
2758
2759         len = emu->audigy ? 0x200 : 0x100;
2760         for (i = 0; i < len; i++)
2761                 snd_emu10k1_ptr_write(emu, emu->gpr_base + i, 0, emu->saved_gpr[i]);
2762
2763         len = emu->audigy ? 0x100 : 0xa0;
2764         for (i = 0; i < len; i++) {
2765                 snd_emu10k1_ptr_write(emu, TANKMEMDATAREGBASE + i, 0,
2766                                       emu->tram_val_saved[i]);
2767                 if (! emu->audigy)
2768                         snd_emu10k1_ptr_write(emu, TANKMEMADDRREGBASE + i, 0,
2769                                               emu->tram_addr_saved[i]);
2770                 else {
2771                         snd_emu10k1_ptr_write(emu, TANKMEMADDRREGBASE + i, 0,
2772                                               emu->tram_addr_saved[i] << 12);
2773                         snd_emu10k1_ptr_write(emu, TANKMEMADDRREGBASE + i, 0,
2774                                               emu->tram_addr_saved[i] >> 20);
2775                 }
2776         }
2777
2778         len = emu->audigy ? 2 * 1024 : 2 * 512;
2779         for (i = 0; i < len; i++)
2780                 snd_emu10k1_efx_write(emu, i, emu->saved_icode[i]);
2781
2782         /* start FX processor when the DSP code is updated */
2783         if (emu->audigy)
2784                 snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg);
2785         else
2786                 snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg);
2787 }
2788 #endif