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                 if (in_kernel)
 703                         memcpy(gctl, (void *)&_gctl[idx], sizeof(*gctl));
 704                 else if (copy_from_user(gctl, &_gctl[idx], sizeof(*gctl)))
 705                         return -EFAULT;
 706                 return 0;
 707         }
 708
 709         octl = (struct snd_emu10k1_fx8010_control_old_gpr __user *)_gctl;
 710         if (in_kernel)
 711                 memcpy(gctl, (void *)&octl[idx], sizeof(*octl));
 712         else if (copy_from_user(gctl, &octl[idx], sizeof(*octl)))
 713                 return -EFAULT;
 714         gctl->tlv = NULL;
 715         return 0;
 716 }
 717
 718 static int copy_gctl_to_user(struct snd_emu10k1 *emu,
 719                      struct snd_emu10k1_fx8010_control_gpr __user *_gctl,
 720                      struct snd_emu10k1_fx8010_control_gpr *gctl,
 721                      int idx)
 722 {
 723         struct snd_emu10k1_fx8010_control_old_gpr __user *octl;
 724
 725         if (emu->support_tlv)
 726                 return copy_to_user(&_gctl[idx], gctl, sizeof(*gctl));
 727
 728         octl = (struct snd_emu10k1_fx8010_control_old_gpr __user *)_gctl;
 729         return copy_to_user(&octl[idx], gctl, sizeof(*octl));
 730 }
 731
 732 static int snd_emu10k1_verify_controls(struct snd_emu10k1 *emu,
 733                                        struct snd_emu10k1_fx8010_code *icode,
 734                                        bool in_kernel)
 735 {
 736         unsigned int i;
 737         struct snd_ctl_elem_id __user *_id;
 738         struct snd_ctl_elem_id id;
 739         struct snd_emu10k1_fx8010_control_gpr *gctl;
 740         int err;
 741
 742         for (i = 0, _id = icode->gpr_del_controls;
 743              i < icode->gpr_del_control_count; i++, _id++) {
 744                 if (in_kernel)
 745                         id = *(struct snd_ctl_elem_id *)_id;
 746                 else if (copy_from_user(&id, _id, sizeof(id)))
 747                         return -EFAULT;
 748                 if (snd_emu10k1_look_for_ctl(emu, &id) == NULL)
 749                         return -ENOENT;
 750         }
 751         gctl = kmalloc(sizeof(*gctl), GFP_KERNEL);
 752         if (! gctl)
 753                 return -ENOMEM;
 754         err = 0;
 755         for (i = 0; i < icode->gpr_add_control_count; i++) {
 756                 if (copy_gctl(emu, gctl, icode->gpr_add_controls, i,
 757                               in_kernel)) {
 758                         err = -EFAULT;
 759                         goto __error;
 760                 }
 761                 if (snd_emu10k1_look_for_ctl(emu, &gctl->id))
 762                         continue;
 763                 down_read(&emu->card->controls_rwsem);
 764                 if (snd_ctl_find_id(emu->card, &gctl->id) != NULL) {
 765                         up_read(&emu->card->controls_rwsem);
 766                         err = -EEXIST;
 767                         goto __error;
 768                 }
 769                 up_read(&emu->card->controls_rwsem);
 770                 if (gctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER &&
 771                     gctl->id.iface != SNDRV_CTL_ELEM_IFACE_PCM) {
 772                         err = -EINVAL;
 773                         goto __error;
 774                 }
 775         }
 776         for (i = 0; i < icode->gpr_list_control_count; i++) {
 777                 /* FIXME: we need to check the WRITE access */
 778                 if (copy_gctl(emu, gctl, icode->gpr_list_controls, i,
 779                               in_kernel)) {
 780                         err = -EFAULT;
 781                         goto __error;
 782                 }
 783         }
 784  __error:
 785         kfree(gctl);
 786         return err;
 787 }
 788
 789 static void snd_emu10k1_ctl_private_free(struct snd_kcontrol *kctl)
 790 {
 791         struct snd_emu10k1_fx8010_ctl *ctl;
 792
 793         ctl = (struct snd_emu10k1_fx8010_ctl *) kctl->private_value;
 794         kctl->private_value = 0;
 795         list_del(&ctl->list);
 796         kfree(ctl);
 797         kfree(kctl->tlv.p);
 798 }
 799
 800 static int snd_emu10k1_add_controls(struct snd_emu10k1 *emu,
 801                                     struct snd_emu10k1_fx8010_code *icode,
 802                                     bool in_kernel)
 803 {
 804         unsigned int i, j;
 805         struct snd_emu10k1_fx8010_control_gpr *gctl;
 806         struct snd_emu10k1_fx8010_ctl *ctl, *nctl;
 807         struct snd_kcontrol_new knew;
 808         struct snd_kcontrol *kctl;
 809         struct snd_ctl_elem_value *val;
 810         int err = 0;
 811
 812         val = kmalloc(sizeof(*val), GFP_KERNEL);
 813         gctl = kmalloc(sizeof(*gctl), GFP_KERNEL);
 814         nctl = kmalloc(sizeof(*nctl), GFP_KERNEL);
 815         if (!val || !gctl || !nctl) {
 816                 err = -ENOMEM;
 817                 goto __error;
 818         }
 819
 820         for (i = 0; i < icode->gpr_add_control_count; i++) {
 821                 if (copy_gctl(emu, gctl, icode->gpr_add_controls, i,
 822                               in_kernel)) {
 823                         err = -EFAULT;
 824                         goto __error;
 825                 }
 826                 if (gctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER &&
 827                     gctl->id.iface != SNDRV_CTL_ELEM_IFACE_PCM) {
 828                         err = -EINVAL;
 829                         goto __error;
 830                 }
 831                 if (! gctl->id.name[0]) {
 832                         err = -EINVAL;
 833                         goto __error;
 834                 }
 835                 ctl = snd_emu10k1_look_for_ctl(emu, &gctl->id);
 836                 memset(&knew, 0, sizeof(knew));
 837                 knew.iface = gctl->id.iface;
 838                 knew.name = gctl->id.name;
 839                 knew.index = gctl->id.index;
 840                 knew.device = gctl->id.device;
 841                 knew.subdevice = gctl->id.subdevice;
 842                 knew.info = snd_emu10k1_gpr_ctl_info;
 843                 knew.tlv.p = copy_tlv(gctl->tlv, in_kernel);
 844                 if (knew.tlv.p)
 845                         knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
 846                                 SNDRV_CTL_ELEM_ACCESS_TLV_READ;
 847                 knew.get = snd_emu10k1_gpr_ctl_get;
 848                 knew.put = snd_emu10k1_gpr_ctl_put;
 849                 memset(nctl, 0, sizeof(*nctl));
 850                 nctl->vcount = gctl->vcount;
 851                 nctl->count = gctl->count;
 852                 for (j = 0; j < 32; j++) {
 853                         nctl->gpr[j] = gctl->gpr[j];
 854                         nctl->value[j] = ~gctl->value[j];       /* inverted, we want to write new value in gpr_ctl_put() */
 855                         val->value.integer.value[j] = gctl->value[j];
 856                 }
 857                 nctl->min = gctl->min;
 858                 nctl->max = gctl->max;
 859                 nctl->translation = gctl->translation;
 860                 if (ctl == NULL) {
 861                         ctl = kmalloc(sizeof(*ctl), GFP_KERNEL);
 862                         if (ctl == NULL) {
 863                                 err = -ENOMEM;
 864                                 kfree(knew.tlv.p);
 865                                 goto __error;
 866                         }
 867                         knew.private_value = (unsigned long)ctl;
 868                         *ctl = *nctl;
 869                         if ((err = snd_ctl_add(emu->card, kctl = snd_ctl_new1(&knew, emu))) < 0) {
 870                                 kfree(ctl);
 871                                 kfree(knew.tlv.p);
 872                                 goto __error;
 873                         }
 874                         kctl->private_free = snd_emu10k1_ctl_private_free;
 875                         ctl->kcontrol = kctl;
 876                         list_add_tail(&ctl->list, &emu->fx8010.gpr_ctl);
 877                 } else {
 878                         /* overwrite */
 879                         nctl->list = ctl->list;
 880                         nctl->kcontrol = ctl->kcontrol;
 881                         *ctl = *nctl;
 882                         snd_ctl_notify(emu->card, SNDRV_CTL_EVENT_MASK_VALUE |
 883                                                   SNDRV_CTL_EVENT_MASK_INFO, &ctl->kcontrol->id);
 884                 }
 885                 snd_emu10k1_gpr_ctl_put(ctl->kcontrol, val);
 886         }
 887       __error:
 888         kfree(nctl);
 889         kfree(gctl);
 890         kfree(val);
 891         return err;
 892 }
 893
 894 static int snd_emu10k1_del_controls(struct snd_emu10k1 *emu,
 895                                     struct snd_emu10k1_fx8010_code *icode,
 896                                     bool in_kernel)
 897 {
 898         unsigned int i;
 899         struct snd_ctl_elem_id id;
 900         struct snd_ctl_elem_id __user *_id;
 901         struct snd_emu10k1_fx8010_ctl *ctl;
 902         struct snd_card *card = emu->card;
 903
 904         for (i = 0, _id = icode->gpr_del_controls;
 905              i < icode->gpr_del_control_count; i++, _id++) {
 906                 if (in_kernel)
 907                         id = *(struct snd_ctl_elem_id *)_id;
 908                 else if (copy_from_user(&id, _id, sizeof(id)))
 909                         return -EFAULT;
 910                 down_write(&card->controls_rwsem);
 911                 ctl = snd_emu10k1_look_for_ctl(emu, &id);
 912                 if (ctl)
 913                         snd_ctl_remove(card, ctl->kcontrol);
 914                 up_write(&card->controls_rwsem);
 915         }
 916         return 0;
 917 }
 918
 919 static int snd_emu10k1_list_controls(struct snd_emu10k1 *emu,
 920                                      struct snd_emu10k1_fx8010_code *icode)
 921 {
 922         unsigned int i = 0, j;
 923         unsigned int total = 0;
 924         struct snd_emu10k1_fx8010_control_gpr *gctl;
 925         struct snd_emu10k1_fx8010_ctl *ctl;
 926         struct snd_ctl_elem_id *id;
 927
 928         gctl = kmalloc(sizeof(*gctl), GFP_KERNEL);
 929         if (! gctl)
 930                 return -ENOMEM;
 931
 932         list_for_each_entry(ctl, &emu->fx8010.gpr_ctl, list) {
 933                 total++;
 934                 if (icode->gpr_list_controls &&
 935                     i < icode->gpr_list_control_count) {
 936                         memset(gctl, 0, sizeof(*gctl));
 937                         id = &ctl->kcontrol->id;
 938                         gctl->id.iface = id->iface;
 939                         strlcpy(gctl->id.name, id->name, sizeof(gctl->id.name));
 940                         gctl->id.index = id->index;
 941                         gctl->id.device = id->device;
 942                         gctl->id.subdevice = id->subdevice;
 943                         gctl->vcount = ctl->vcount;
 944                         gctl->count = ctl->count;
 945                         for (j = 0; j < 32; j++) {
 946                                 gctl->gpr[j] = ctl->gpr[j];
 947                                 gctl->value[j] = ctl->value[j];
 948                         }
 949                         gctl->min = ctl->min;
 950                         gctl->max = ctl->max;
 951                         gctl->translation = ctl->translation;
 952                         if (copy_gctl_to_user(emu, icode->gpr_list_controls,
 953                                               gctl, i)) {
 954                                 kfree(gctl);
 955                                 return -EFAULT;
 956                         }
 957                         i++;
 958                 }
 959         }
 960         icode->gpr_list_control_total = total;
 961         kfree(gctl);
 962         return 0;
 963 }
 964
 965 static int snd_emu10k1_icode_poke(struct snd_emu10k1 *emu,
 966                                   struct snd_emu10k1_fx8010_code *icode,
 967                                   bool in_kernel)
 968 {
 969         int err = 0;
 970
 971         mutex_lock(&emu->fx8010.lock);
 972         err = snd_emu10k1_verify_controls(emu, icode, in_kernel);
 973         if (err < 0)
 974                 goto __error;
 975         strlcpy(emu->fx8010.name, icode->name, sizeof(emu->fx8010.name));
 976         /* stop FX processor - this may be dangerous, but it's better to miss
 977            some samples than generate wrong ones - [jk] */
 978         if (emu->audigy)
 979                 snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg | A_DBG_SINGLE_STEP);
 980         else
 981                 snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg | EMU10K1_DBG_SINGLE_STEP);
 982         /* ok, do the main job */
 983         err = snd_emu10k1_del_controls(emu, icode, in_kernel);
 984         if (err < 0)
 985                 goto __error;
 986         err = snd_emu10k1_gpr_poke(emu, icode, in_kernel);
 987         if (err < 0)
 988                 goto __error;
 989         err = snd_emu10k1_tram_poke(emu, icode, in_kernel);
 990         if (err < 0)
 991                 goto __error;
 992         err = snd_emu10k1_code_poke(emu, icode, in_kernel);
 993         if (err < 0)
 994                 goto __error;
 995         err = snd_emu10k1_add_controls(emu, icode, in_kernel);
 996         if (err < 0)
 997                 goto __error;
 998         /* start FX processor when the DSP code is updated */
 999         if (emu->audigy)
1000                 snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg);
1001         else
1002                 snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg);
1003       __error:
1004         mutex_unlock(&emu->fx8010.lock);
1005         return err;
1006 }
1007
1008 static int snd_emu10k1_icode_peek(struct snd_emu10k1 *emu,
1009                                   struct snd_emu10k1_fx8010_code *icode)
1010 {
1011         int err;
1012
1013         mutex_lock(&emu->fx8010.lock);
1014         strlcpy(icode->name, emu->fx8010.name, sizeof(icode->name));
1015         /* ok, do the main job */
1016         err = snd_emu10k1_gpr_peek(emu, icode);
1017         if (err >= 0)
1018                 err = snd_emu10k1_tram_peek(emu, icode);
1019         if (err >= 0)
1020                 err = snd_emu10k1_code_peek(emu, icode);
1021         if (err >= 0)
1022                 err = snd_emu10k1_list_controls(emu, icode);
1023         mutex_unlock(&emu->fx8010.lock);
1024         return err;
1025 }
1026
1027 static int snd_emu10k1_ipcm_poke(struct snd_emu10k1 *emu,
1028                                  struct snd_emu10k1_fx8010_pcm_rec *ipcm)
1029 {
1030         unsigned int i;
1031         int err = 0;
1032         struct snd_emu10k1_fx8010_pcm *pcm;
1033
1034         if (ipcm->substream >= EMU10K1_FX8010_PCM_COUNT)
1035                 return -EINVAL;
1036         if (ipcm->channels > 32)
1037                 return -EINVAL;
1038         pcm = &emu->fx8010.pcm[ipcm->substream];
1039         mutex_lock(&emu->fx8010.lock);
1040         spin_lock_irq(&emu->reg_lock);
1041         if (pcm->opened) {
1042                 err = -EBUSY;
1043                 goto __error;
1044         }
1045         if (ipcm->channels == 0) {      /* remove */
1046                 pcm->valid = 0;
1047         } else {
1048                 /* FIXME: we need to add universal code to the PCM transfer routine */
1049                 if (ipcm->channels != 2) {
1050                         err = -EINVAL;
1051                         goto __error;
1052                 }
1053                 pcm->valid = 1;
1054                 pcm->opened = 0;
1055                 pcm->channels = ipcm->channels;
1056                 pcm->tram_start = ipcm->tram_start;
1057                 pcm->buffer_size = ipcm->buffer_size;
1058                 pcm->gpr_size = ipcm->gpr_size;
1059                 pcm->gpr_count = ipcm->gpr_count;
1060                 pcm->gpr_tmpcount = ipcm->gpr_tmpcount;
1061                 pcm->gpr_ptr = ipcm->gpr_ptr;
1062                 pcm->gpr_trigger = ipcm->gpr_trigger;
1063                 pcm->gpr_running = ipcm->gpr_running;
1064                 for (i = 0; i < pcm->channels; i++)
1065                         pcm->etram[i] = ipcm->etram[i];
1066         }
1067       __error:
1068         spin_unlock_irq(&emu->reg_lock);
1069         mutex_unlock(&emu->fx8010.lock);
1070         return err;
1071 }
1072
1073 static int snd_emu10k1_ipcm_peek(struct snd_emu10k1 *emu,
1074                                  struct snd_emu10k1_fx8010_pcm_rec *ipcm)
1075 {
1076         unsigned int i;
1077         int err = 0;
1078         struct snd_emu10k1_fx8010_pcm *pcm;
1079
1080         if (ipcm->substream >= EMU10K1_FX8010_PCM_COUNT)
1081                 return -EINVAL;
1082         pcm = &emu->fx8010.pcm[ipcm->substream];
1083         mutex_lock(&emu->fx8010.lock);
1084         spin_lock_irq(&emu->reg_lock);
1085         ipcm->channels = pcm->channels;
1086         ipcm->tram_start = pcm->tram_start;
1087         ipcm->buffer_size = pcm->buffer_size;
1088         ipcm->gpr_size = pcm->gpr_size;
1089         ipcm->gpr_ptr = pcm->gpr_ptr;
1090         ipcm->gpr_count = pcm->gpr_count;
1091         ipcm->gpr_tmpcount = pcm->gpr_tmpcount;
1092         ipcm->gpr_trigger = pcm->gpr_trigger;
1093         ipcm->gpr_running = pcm->gpr_running;
1094         for (i = 0; i < pcm->channels; i++)
1095                 ipcm->etram[i] = pcm->etram[i];
1096         ipcm->res1 = ipcm->res2 = 0;
1097         ipcm->pad = 0;
1098         spin_unlock_irq(&emu->reg_lock);
1099         mutex_unlock(&emu->fx8010.lock);
1100         return err;
1101 }
1102
1103 #define SND_EMU10K1_GPR_CONTROLS        44
1104 #define SND_EMU10K1_INPUTS              12
1105 #define SND_EMU10K1_PLAYBACK_CHANNELS   8
1106 #define SND_EMU10K1_CAPTURE_CHANNELS    4
1107
1108 static void
1109 snd_emu10k1_init_mono_control(struct snd_emu10k1_fx8010_control_gpr *ctl,
1110                               const char *name, int gpr, int defval)
1111 {
1112         ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1113         strcpy(ctl->id.name, name);
1114         ctl->vcount = ctl->count = 1;
1115         ctl->gpr[0] = gpr + 0; ctl->value[0] = defval;
1116         if (high_res_gpr_volume) {
1117                 ctl->min = 0;
1118                 ctl->max = 0x7fffffff;
1119                 ctl->tlv = snd_emu10k1_db_linear;
1120                 ctl->translation = EMU10K1_GPR_TRANSLATION_NONE;
1121         } else {
1122                 ctl->min = 0;
1123                 ctl->max = 100;
1124                 ctl->tlv = snd_emu10k1_db_scale1;
1125                 ctl->translation = EMU10K1_GPR_TRANSLATION_TABLE100;
1126         }
1127 }
1128
1129 static void
1130 snd_emu10k1_init_stereo_control(struct snd_emu10k1_fx8010_control_gpr *ctl,
1131                                 const char *name, int gpr, int defval)
1132 {
1133         ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1134         strcpy(ctl->id.name, name);
1135         ctl->vcount = ctl->count = 2;
1136         ctl->gpr[0] = gpr + 0; ctl->value[0] = defval;
1137         ctl->gpr[1] = gpr + 1; ctl->value[1] = defval;
1138         if (high_res_gpr_volume) {
1139                 ctl->min = 0;
1140                 ctl->max = 0x7fffffff;
1141                 ctl->tlv = snd_emu10k1_db_linear;
1142                 ctl->translation = EMU10K1_GPR_TRANSLATION_NONE;
1143         } else {
1144                 ctl->min = 0;
1145                 ctl->max = 100;
1146                 ctl->tlv = snd_emu10k1_db_scale1;
1147                 ctl->translation = EMU10K1_GPR_TRANSLATION_TABLE100;
1148         }
1149 }
1150
1151 static void
1152 snd_emu10k1_init_mono_onoff_control(struct snd_emu10k1_fx8010_control_gpr *ctl,
1153                                     const char *name, int gpr, int defval)
1154 {
1155         ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1156         strcpy(ctl->id.name, name);
1157         ctl->vcount = ctl->count = 1;
1158         ctl->gpr[0] = gpr + 0; ctl->value[0] = defval;
1159         ctl->min = 0;
1160         ctl->max = 1;
1161         ctl->translation = EMU10K1_GPR_TRANSLATION_ONOFF;
1162 }
1163
1164 static void
1165 snd_emu10k1_init_stereo_onoff_control(struct snd_emu10k1_fx8010_control_gpr *ctl,
1166                                       const char *name, int gpr, int defval)
1167 {
1168         ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1169         strcpy(ctl->id.name, name);
1170         ctl->vcount = ctl->count = 2;
1171         ctl->gpr[0] = gpr + 0; ctl->value[0] = defval;
1172         ctl->gpr[1] = gpr + 1; ctl->value[1] = defval;
1173         ctl->min = 0;
1174         ctl->max = 1;
1175         ctl->translation = EMU10K1_GPR_TRANSLATION_ONOFF;
1176 }
1177
1178 /*
1179  * Used for emu1010 - conversion from 32-bit capture inputs from HANA
1180  * to 2 x 16-bit registers in audigy - their values are read via DMA.
1181  * Conversion is performed by Audigy DSP instructions of FX8010.
1182  */
1183 static int snd_emu10k1_audigy_dsp_convert_32_to_2x16(
1184                                 struct snd_emu10k1_fx8010_code *icode,
1185                                 u32 *ptr, int tmp, int bit_shifter16,
1186                                 int reg_in, int reg_out)
1187 {
1188         A_OP(icode, ptr, iACC3, A_GPR(tmp + 1), reg_in, A_C_00000000, A_C_00000000);
1189         A_OP(icode, ptr, iANDXOR, A_GPR(tmp), A_GPR(tmp + 1), A_GPR(bit_shifter16 - 1), A_C_00000000);
1190         A_OP(icode, ptr, iTSTNEG, A_GPR(tmp + 2), A_GPR(tmp), A_C_80000000, A_GPR(bit_shifter16 - 2));
1191         A_OP(icode, ptr, iANDXOR, A_GPR(tmp + 2), A_GPR(tmp + 2), A_C_80000000, A_C_00000000);
1192         A_OP(icode, ptr, iANDXOR, A_GPR(tmp), A_GPR(tmp), A_GPR(bit_shifter16 - 3), A_C_00000000);
1193         A_OP(icode, ptr, iMACINT0, A_GPR(tmp), A_C_00000000, A_GPR(tmp), A_C_00010000);
1194         A_OP(icode, ptr, iANDXOR, reg_out, A_GPR(tmp), A_C_ffffffff, A_GPR(tmp + 2));
1195         A_OP(icode, ptr, iACC3, reg_out + 1, A_GPR(tmp + 1), A_C_00000000, A_C_00000000);
1196         return 1;
1197 }
1198
1199 /*
1200  * initial DSP configuration for Audigy
1201  */
1202
1203 static int _snd_emu10k1_audigy_init_efx(struct snd_emu10k1 *emu)
1204 {
1205         int err, i, z, gpr, nctl;
1206         int bit_shifter16;
1207         const int playback = 10;
1208         const int capture = playback + (SND_EMU10K1_PLAYBACK_CHANNELS * 2); /* we reserve 10 voices */
1209         const int stereo_mix = capture + 2;
1210         const int tmp = 0x88;
1211         u32 ptr;
1212         struct snd_emu10k1_fx8010_code *icode = NULL;
1213         struct snd_emu10k1_fx8010_control_gpr *controls = NULL, *ctl;
1214         u32 *gpr_map;
1215
1216         err = -ENOMEM;
1217         icode = kzalloc(sizeof(*icode), GFP_KERNEL);
1218         if (!icode)
1219                 return err;
1220
1221         icode->gpr_map = (u_int32_t __user *) kcalloc(512 + 256 + 256 + 2 * 1024,
1222                                                       sizeof(u_int32_t), GFP_KERNEL);
1223         if (!icode->gpr_map)
1224                 goto __err_gpr;
1225         controls = kcalloc(SND_EMU10K1_GPR_CONTROLS,
1226                            sizeof(*controls), GFP_KERNEL);
1227         if (!controls)
1228                 goto __err_ctrls;
1229
1230         gpr_map = (u32 __force *)icode->gpr_map;
1231
1232         icode->tram_data_map = icode->gpr_map + 512;
1233         icode->tram_addr_map = icode->tram_data_map + 256;
1234         icode->code = icode->tram_addr_map + 256;
1235
1236         /* clear free GPRs */
1237         for (i = 0; i < 512; i++)
1238                 set_bit(i, icode->gpr_valid);
1239
1240         /* clear TRAM data & address lines */
1241         for (i = 0; i < 256; i++)
1242                 set_bit(i, icode->tram_valid);
1243
1244         strcpy(icode->name, "Audigy DSP code for ALSA");
1245         ptr = 0;
1246         nctl = 0;
1247         gpr = stereo_mix + 10;
1248         gpr_map[gpr++] = 0x00007fff;
1249         gpr_map[gpr++] = 0x00008000;
1250         gpr_map[gpr++] = 0x0000ffff;
1251         bit_shifter16 = gpr;
1252
1253         /* stop FX processor */
1254         snd_emu10k1_ptr_write(emu, A_DBG, 0, (emu->fx8010.dbg = 0) | A_DBG_SINGLE_STEP);
1255
1256 #if 1
1257         /* PCM front Playback Volume (independent from stereo mix)
1258          * playback = 0 + ( gpr * FXBUS_PCM_LEFT_FRONT >> 31)
1259          * where gpr contains attenuation from corresponding mixer control
1260          * (snd_emu10k1_init_stereo_control)
1261          */
1262         A_OP(icode, &ptr, iMAC0, A_GPR(playback), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_LEFT_FRONT));
1263         A_OP(icode, &ptr, iMAC0, A_GPR(playback+1), A_C_00000000, A_GPR(gpr+1), A_FXBUS(FXBUS_PCM_RIGHT_FRONT));
1264         snd_emu10k1_init_stereo_control(&controls[nctl++], "PCM Front Playback Volume", gpr, 100);
1265         gpr += 2;
1266
1267         /* PCM Surround Playback (independent from stereo mix) */
1268         A_OP(icode, &ptr, iMAC0, A_GPR(playback+2), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_LEFT_REAR));
1269         A_OP(icode, &ptr, iMAC0, A_GPR(playback+3), A_C_00000000, A_GPR(gpr+1), A_FXBUS(FXBUS_PCM_RIGHT_REAR));
1270         snd_emu10k1_init_stereo_control(&controls[nctl++], "PCM Surround Playback Volume", gpr, 100);
1271         gpr += 2;
1272
1273         /* PCM Side Playback (independent from stereo mix) */
1274         if (emu->card_capabilities->spk71) {
1275                 A_OP(icode, &ptr, iMAC0, A_GPR(playback+6), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_LEFT_SIDE));
1276                 A_OP(icode, &ptr, iMAC0, A_GPR(playback+7), A_C_00000000, A_GPR(gpr+1), A_FXBUS(FXBUS_PCM_RIGHT_SIDE));
1277                 snd_emu10k1_init_stereo_control(&controls[nctl++], "PCM Side Playback Volume", gpr, 100);
1278                 gpr += 2;
1279         }
1280
1281         /* PCM Center Playback (independent from stereo mix) */
1282         A_OP(icode, &ptr, iMAC0, A_GPR(playback+4), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_CENTER));
1283         snd_emu10k1_init_mono_control(&controls[nctl++], "PCM Center Playback Volume", gpr, 100);
1284         gpr++;
1285
1286         /* PCM LFE Playback (independent from stereo mix) */
1287         A_OP(icode, &ptr, iMAC0, A_GPR(playback+5), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_LFE));
1288         snd_emu10k1_init_mono_control(&controls[nctl++], "PCM LFE Playback Volume", gpr, 100);
1289         gpr++;
1290
1291         /*
1292          * Stereo Mix
1293          */
1294         /* Wave (PCM) Playback Volume (will be renamed later) */
1295         A_OP(icode, &ptr, iMAC0, A_GPR(stereo_mix), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_LEFT));
1296         A_OP(icode, &ptr, iMAC0, A_GPR(stereo_mix+1), A_C_00000000, A_GPR(gpr+1), A_FXBUS(FXBUS_PCM_RIGHT));
1297         snd_emu10k1_init_stereo_control(&controls[nctl++], "Wave Playback Volume", gpr, 100);
1298         gpr += 2;
1299
1300         /* Synth Playback */
1301         A_OP(icode, &ptr, iMAC0, A_GPR(stereo_mix+0), A_GPR(stereo_mix+0), A_GPR(gpr), A_FXBUS(FXBUS_MIDI_LEFT));
1302         A_OP(icode, &ptr, iMAC0, A_GPR(stereo_mix+1), A_GPR(stereo_mix+1), A_GPR(gpr+1), A_FXBUS(FXBUS_MIDI_RIGHT));
1303         snd_emu10k1_init_stereo_control(&controls[nctl++], "Synth Playback Volume", gpr, 100);
1304         gpr += 2;
1305
1306         /* Wave (PCM) Capture */
1307         A_OP(icode, &ptr, iMAC0, A_GPR(capture+0), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_LEFT));
1308         A_OP(icode, &ptr, iMAC0, A_GPR(capture+1), A_C_00000000, A_GPR(gpr+1), A_FXBUS(FXBUS_PCM_RIGHT));
1309         snd_emu10k1_init_stereo_control(&controls[nctl++], "PCM Capture Volume", gpr, 0);
1310         gpr += 2;
1311
1312         /* Synth Capture */
1313         A_OP(icode, &ptr, iMAC0, A_GPR(capture+0), A_GPR(capture+0), A_GPR(gpr), A_FXBUS(FXBUS_MIDI_LEFT));
1314         A_OP(icode, &ptr, iMAC0, A_GPR(capture+1), A_GPR(capture+1), A_GPR(gpr+1), A_FXBUS(FXBUS_MIDI_RIGHT));
1315         snd_emu10k1_init_stereo_control(&controls[nctl++], "Synth Capture Volume", gpr, 0);
1316         gpr += 2;
1317
1318         /*
1319          * inputs
1320          */
1321 #define A_ADD_VOLUME_IN(var,vol,input) \
1322 A_OP(icode, &ptr, iMAC0, A_GPR(var), A_GPR(var), A_GPR(vol), A_EXTIN(input))
1323
1324         /* emu1212 DSP 0 and DSP 1 Capture */
1325         if (emu->card_capabilities->emu_model) {
1326                 if (emu->card_capabilities->ca0108_chip) {
1327                         /* Note:JCD:No longer bit shift lower 16bits to upper 16bits of 32bit value. */
1328                         A_OP(icode, &ptr, iMACINT0, A_GPR(tmp), A_C_00000000, A3_EMU32IN(0x0), A_C_00000001);
1329                         A_OP(icode, &ptr, iMAC0, A_GPR(capture+0), A_GPR(capture+0), A_GPR(gpr), A_GPR(tmp));
1330                         A_OP(icode, &ptr, iMACINT0, A_GPR(tmp), A_C_00000000, A3_EMU32IN(0x1), A_C_00000001);
1331                         A_OP(icode, &ptr, iMAC0, A_GPR(capture+1), A_GPR(capture+1), A_GPR(gpr), A_GPR(tmp));
1332                 } else {
1333                         A_OP(icode, &ptr, iMAC0, A_GPR(capture+0), A_GPR(capture+0), A_GPR(gpr), A_P16VIN(0x0));
1334                         A_OP(icode, &ptr, iMAC0, A_GPR(capture+1), A_GPR(capture+1), A_GPR(gpr+1), A_P16VIN(0x1));
1335                 }
1336                 snd_emu10k1_init_stereo_control(&controls[nctl++], "EMU Capture Volume", gpr, 0);
1337                 gpr += 2;
1338         }
1339         /* AC'97 Playback Volume - used only for mic (renamed later) */
1340         A_ADD_VOLUME_IN(stereo_mix, gpr, A_EXTIN_AC97_L);
1341         A_ADD_VOLUME_IN(stereo_mix+1, gpr+1, A_EXTIN_AC97_R);
1342         snd_emu10k1_init_stereo_control(&controls[nctl++], "AMic Playback Volume", gpr, 0);
1343         gpr += 2;
1344         /* AC'97 Capture Volume - used only for mic */
1345         A_ADD_VOLUME_IN(capture, gpr, A_EXTIN_AC97_L);
1346         A_ADD_VOLUME_IN(capture+1, gpr+1, A_EXTIN_AC97_R);
1347         snd_emu10k1_init_stereo_control(&controls[nctl++], "Mic Capture Volume", gpr, 0);
1348         gpr += 2;
1349
1350         /* mic capture buffer */
1351         A_OP(icode, &ptr, iINTERP, A_EXTOUT(A_EXTOUT_MIC_CAP), A_EXTIN(A_EXTIN_AC97_L), 0xcd, A_EXTIN(A_EXTIN_AC97_R));
1352
1353         /* Audigy CD Playback Volume */
1354         A_ADD_VOLUME_IN(stereo_mix, gpr, A_EXTIN_SPDIF_CD_L);
1355         A_ADD_VOLUME_IN(stereo_mix+1, gpr+1, A_EXTIN_SPDIF_CD_R);
1356         snd_emu10k1_init_stereo_control(&controls[nctl++],
1357                                         emu->card_capabilities->ac97_chip ? "Audigy CD Playback Volume" : "CD Playback Volume",
1358                                         gpr, 0);
1359         gpr += 2;
1360         /* Audigy CD Capture Volume */
1361         A_ADD_VOLUME_IN(capture, gpr, A_EXTIN_SPDIF_CD_L);
1362         A_ADD_VOLUME_IN(capture+1, gpr+1, A_EXTIN_SPDIF_CD_R);
1363         snd_emu10k1_init_stereo_control(&controls[nctl++],
1364                                         emu->card_capabilities->ac97_chip ? "Audigy CD Capture Volume" : "CD Capture Volume",
1365                                         gpr, 0);
1366         gpr += 2;
1367
1368         /* Optical SPDIF Playback Volume */
1369         A_ADD_VOLUME_IN(stereo_mix, gpr, A_EXTIN_OPT_SPDIF_L);
1370         A_ADD_VOLUME_IN(stereo_mix+1, gpr+1, A_EXTIN_OPT_SPDIF_R);
1371         snd_emu10k1_init_stereo_control(&controls[nctl++], SNDRV_CTL_NAME_IEC958("Optical ",PLAYBACK,VOLUME), gpr, 0);
1372         gpr += 2;
1373         /* Optical SPDIF Capture Volume */
1374         A_ADD_VOLUME_IN(capture, gpr, A_EXTIN_OPT_SPDIF_L);
1375         A_ADD_VOLUME_IN(capture+1, gpr+1, A_EXTIN_OPT_SPDIF_R);
1376         snd_emu10k1_init_stereo_control(&controls[nctl++], SNDRV_CTL_NAME_IEC958("Optical ",CAPTURE,VOLUME), gpr, 0);
1377         gpr += 2;
1378
1379         /* Line2 Playback Volume */
1380         A_ADD_VOLUME_IN(stereo_mix, gpr, A_EXTIN_LINE2_L);
1381         A_ADD_VOLUME_IN(stereo_mix+1, gpr+1, A_EXTIN_LINE2_R);
1382         snd_emu10k1_init_stereo_control(&controls[nctl++],
1383                                         emu->card_capabilities->ac97_chip ? "Line2 Playback Volume" : "Line Playback Volume",
1384                                         gpr, 0);
1385         gpr += 2;
1386         /* Line2 Capture Volume */
1387         A_ADD_VOLUME_IN(capture, gpr, A_EXTIN_LINE2_L);
1388         A_ADD_VOLUME_IN(capture+1, gpr+1, A_EXTIN_LINE2_R);
1389         snd_emu10k1_init_stereo_control(&controls[nctl++],
1390                                         emu->card_capabilities->ac97_chip ? "Line2 Capture Volume" : "Line Capture Volume",
1391                                         gpr, 0);
1392         gpr += 2;
1393
1394         /* Philips ADC Playback Volume */
1395         A_ADD_VOLUME_IN(stereo_mix, gpr, A_EXTIN_ADC_L);
1396         A_ADD_VOLUME_IN(stereo_mix+1, gpr+1, A_EXTIN_ADC_R);
1397         snd_emu10k1_init_stereo_control(&controls[nctl++], "Analog Mix Playback Volume", gpr, 0);
1398         gpr += 2;
1399         /* Philips ADC Capture Volume */
1400         A_ADD_VOLUME_IN(capture, gpr, A_EXTIN_ADC_L);
1401         A_ADD_VOLUME_IN(capture+1, gpr+1, A_EXTIN_ADC_R);
1402         snd_emu10k1_init_stereo_control(&controls[nctl++], "Analog Mix Capture Volume", gpr, 0);
1403         gpr += 2;
1404
1405         /* Aux2 Playback Volume */
1406         A_ADD_VOLUME_IN(stereo_mix, gpr, A_EXTIN_AUX2_L);
1407         A_ADD_VOLUME_IN(stereo_mix+1, gpr+1, A_EXTIN_AUX2_R);
1408         snd_emu10k1_init_stereo_control(&controls[nctl++],
1409                                         emu->card_capabilities->ac97_chip ? "Aux2 Playback Volume" : "Aux Playback Volume",
1410                                         gpr, 0);
1411         gpr += 2;
1412         /* Aux2 Capture Volume */
1413         A_ADD_VOLUME_IN(capture, gpr, A_EXTIN_AUX2_L);
1414         A_ADD_VOLUME_IN(capture+1, gpr+1, A_EXTIN_AUX2_R);
1415         snd_emu10k1_init_stereo_control(&controls[nctl++],
1416                                         emu->card_capabilities->ac97_chip ? "Aux2 Capture Volume" : "Aux Capture Volume",
1417                                         gpr, 0);
1418         gpr += 2;
1419
1420         /* Stereo Mix Front Playback Volume */
1421         A_OP(icode, &ptr, iMAC0, A_GPR(playback), A_GPR(playback), A_GPR(gpr), A_GPR(stereo_mix));
1422         A_OP(icode, &ptr, iMAC0, A_GPR(playback+1), A_GPR(playback+1), A_GPR(gpr+1), A_GPR(stereo_mix+1));
1423         snd_emu10k1_init_stereo_control(&controls[nctl++], "Front Playback Volume", gpr, 100);
1424         gpr += 2;
1425
1426         /* Stereo Mix Surround Playback */
1427         A_OP(icode, &ptr, iMAC0, A_GPR(playback+2), A_GPR(playback+2), A_GPR(gpr), A_GPR(stereo_mix));
1428         A_OP(icode, &ptr, iMAC0, A_GPR(playback+3), A_GPR(playback+3), A_GPR(gpr+1), A_GPR(stereo_mix+1));
1429         snd_emu10k1_init_stereo_control(&controls[nctl++], "Surround Playback Volume", gpr, 0);
1430         gpr += 2;
1431
1432         /* Stereo Mix Center Playback */
1433         /* Center = sub = Left/2 + Right/2 */
1434         A_OP(icode, &ptr, iINTERP, A_GPR(tmp), A_GPR(stereo_mix), 0xcd, A_GPR(stereo_mix+1));
1435         A_OP(icode, &ptr, iMAC0, A_GPR(playback+4), A_GPR(playback+4), A_GPR(gpr), A_GPR(tmp));
1436         snd_emu10k1_init_mono_control(&controls[nctl++], "Center Playback Volume", gpr, 0);
1437         gpr++;
1438
1439         /* Stereo Mix LFE Playback */
1440         A_OP(icode, &ptr, iMAC0, A_GPR(playback+5), A_GPR(playback+5), A_GPR(gpr), A_GPR(tmp));
1441         snd_emu10k1_init_mono_control(&controls[nctl++], "LFE Playback Volume", gpr, 0);
1442         gpr++;
1443
1444         if (emu->card_capabilities->spk71) {
1445                 /* Stereo Mix Side Playback */
1446                 A_OP(icode, &ptr, iMAC0, A_GPR(playback+6), A_GPR(playback+6), A_GPR(gpr), A_GPR(stereo_mix));
1447                 A_OP(icode, &ptr, iMAC0, A_GPR(playback+7), A_GPR(playback+7), A_GPR(gpr+1), A_GPR(stereo_mix+1));
1448                 snd_emu10k1_init_stereo_control(&controls[nctl++], "Side Playback Volume", gpr, 0);
1449                 gpr += 2;
1450         }
1451
1452         /*
1453          * outputs
1454          */
1455 #define A_PUT_OUTPUT(out,src) A_OP(icode, &ptr, iACC3, A_EXTOUT(out), A_C_00000000, A_C_00000000, A_GPR(src))
1456 #define A_PUT_STEREO_OUTPUT(out1,out2,src) \
1457         {A_PUT_OUTPUT(out1,src); A_PUT_OUTPUT(out2,src+1);}
1458
1459 #define _A_SWITCH(icode, ptr, dst, src, sw) \
1460         A_OP((icode), ptr, iMACINT0, dst, A_C_00000000, src, sw);
1461 #define A_SWITCH(icode, ptr, dst, src, sw) \
1462                 _A_SWITCH(icode, ptr, A_GPR(dst), A_GPR(src), A_GPR(sw))
1463 #define _A_SWITCH_NEG(icode, ptr, dst, src) \
1464         A_OP((icode), ptr, iANDXOR, dst, src, A_C_00000001, A_C_00000001);
1465 #define A_SWITCH_NEG(icode, ptr, dst, src) \
1466                 _A_SWITCH_NEG(icode, ptr, A_GPR(dst), A_GPR(src))
1467
1468
1469         /*
1470          *  Process tone control
1471          */
1472         A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 0), A_GPR(playback + 0), A_C_00000000, A_C_00000000); /* left */
1473         A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 1), A_GPR(playback + 1), A_C_00000000, A_C_00000000); /* right */
1474         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 */
1475         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 */
1476         A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 4), A_GPR(playback + 4), A_C_00000000, A_C_00000000); /* center */
1477         A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 5), A_GPR(playback + 5), A_C_00000000, A_C_00000000); /* LFE */
1478         if (emu->card_capabilities->spk71) {
1479                 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 */
1480                 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 */
1481         }
1482
1483
1484         ctl = &controls[nctl + 0];
1485         ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1486         strcpy(ctl->id.name, "Tone Control - Bass");
1487         ctl->vcount = 2;
1488         ctl->count = 10;
1489         ctl->min = 0;
1490         ctl->max = 40;
1491         ctl->value[0] = ctl->value[1] = 20;
1492         ctl->translation = EMU10K1_GPR_TRANSLATION_BASS;
1493         ctl = &controls[nctl + 1];
1494         ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1495         strcpy(ctl->id.name, "Tone Control - Treble");
1496         ctl->vcount = 2;
1497         ctl->count = 10;
1498         ctl->min = 0;
1499         ctl->max = 40;
1500         ctl->value[0] = ctl->value[1] = 20;
1501         ctl->translation = EMU10K1_GPR_TRANSLATION_TREBLE;
1502
1503 #define BASS_GPR        0x8c
1504 #define TREBLE_GPR      0x96
1505
1506         for (z = 0; z < 5; z++) {
1507                 int j;
1508                 for (j = 0; j < 2; j++) {
1509                         controls[nctl + 0].gpr[z * 2 + j] = BASS_GPR + z * 2 + j;
1510                         controls[nctl + 1].gpr[z * 2 + j] = TREBLE_GPR + z * 2 + j;
1511                 }
1512         }
1513         for (z = 0; z < 4; z++) {               /* front/rear/center-lfe/side */
1514                 int j, k, l, d;
1515                 for (j = 0; j < 2; j++) {       /* left/right */
1516                         k = 0xb0 + (z * 8) + (j * 4);
1517                         l = 0xe0 + (z * 8) + (j * 4);
1518                         d = playback + SND_EMU10K1_PLAYBACK_CHANNELS + z * 2 + j;
1519
1520                         A_OP(icode, &ptr, iMAC0, A_C_00000000, A_C_00000000, A_GPR(d), A_GPR(BASS_GPR + 0 + j));
1521                         A_OP(icode, &ptr, iMACMV, A_GPR(k+1), A_GPR(k), A_GPR(k+1), A_GPR(BASS_GPR + 4 + j));
1522                         A_OP(icode, &ptr, iMACMV, A_GPR(k), A_GPR(d), A_GPR(k), A_GPR(BASS_GPR + 2 + j));
1523                         A_OP(icode, &ptr, iMACMV, A_GPR(k+3), A_GPR(k+2), A_GPR(k+3), A_GPR(BASS_GPR + 8 + j));
1524                         A_OP(icode, &ptr, iMAC0, A_GPR(k+2), A_GPR_ACCU, A_GPR(k+2), A_GPR(BASS_GPR + 6 + j));
1525                         A_OP(icode, &ptr, iACC3, A_GPR(k+2), A_GPR(k+2), A_GPR(k+2), A_C_00000000);
1526
1527                         A_OP(icode, &ptr, iMAC0, A_C_00000000, A_C_00000000, A_GPR(k+2), A_GPR(TREBLE_GPR + 0 + j));
1528                         A_OP(icode, &ptr, iMACMV, A_GPR(l+1), A_GPR(l), A_GPR(l+1), A_GPR(TREBLE_GPR + 4 + j));
1529                         A_OP(icode, &ptr, iMACMV, A_GPR(l), A_GPR(k+2), A_GPR(l), A_GPR(TREBLE_GPR + 2 + j));
1530                         A_OP(icode, &ptr, iMACMV, A_GPR(l+3), A_GPR(l+2), A_GPR(l+3), A_GPR(TREBLE_GPR + 8 + j));
1531                         A_OP(icode, &ptr, iMAC0, A_GPR(l+2), A_GPR_ACCU, A_GPR(l+2), A_GPR(TREBLE_GPR + 6 + j));
1532                         A_OP(icode, &ptr, iMACINT0, A_GPR(l+2), A_C_00000000, A_GPR(l+2), A_C_00000010);
1533
1534                         A_OP(icode, &ptr, iACC3, A_GPR(d), A_GPR(l+2), A_C_00000000, A_C_00000000);
1535
1536                         if (z == 2)     /* center */
1537                                 break;
1538                 }
1539         }
1540         nctl += 2;
1541
1542 #undef BASS_GPR
1543 #undef TREBLE_GPR
1544
1545         for (z = 0; z < 8; z++) {
1546                 A_SWITCH(icode, &ptr, tmp + 0, playback + SND_EMU10K1_PLAYBACK_CHANNELS + z, gpr + 0);
1547                 A_SWITCH_NEG(icode, &ptr, tmp + 1, gpr + 0);
1548                 A_SWITCH(icode, &ptr, tmp + 1, playback + z, tmp + 1);
1549                 A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + z), A_GPR(tmp + 0), A_GPR(tmp + 1), A_C_00000000);
1550         }
1551         snd_emu10k1_init_stereo_onoff_control(controls + nctl++, "Tone Control - Switch", gpr, 0);
1552         gpr += 2;
1553
1554         /* Master volume (will be renamed later) */
1555         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));
1556         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));
1557         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));
1558         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));
1559         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));
1560         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));
1561         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));
1562         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));
1563         snd_emu10k1_init_mono_control(&controls[nctl++], "Wave Master Playback Volume", gpr, 0);
1564         gpr += 2;
1565
1566         /* analog speakers */
1567         A_PUT_STEREO_OUTPUT(A_EXTOUT_AFRONT_L, A_EXTOUT_AFRONT_R, playback + SND_EMU10K1_PLAYBACK_CHANNELS);
1568         A_PUT_STEREO_OUTPUT(A_EXTOUT_AREAR_L, A_EXTOUT_AREAR_R, playback+2 + SND_EMU10K1_PLAYBACK_CHANNELS);
1569         A_PUT_OUTPUT(A_EXTOUT_ACENTER, playback+4 + SND_EMU10K1_PLAYBACK_CHANNELS);
1570         A_PUT_OUTPUT(A_EXTOUT_ALFE, playback+5 + SND_EMU10K1_PLAYBACK_CHANNELS);
1571         if (emu->card_capabilities->spk71)
1572                 A_PUT_STEREO_OUTPUT(A_EXTOUT_ASIDE_L, A_EXTOUT_ASIDE_R, playback+6 + SND_EMU10K1_PLAYBACK_CHANNELS);
1573
1574         /* headphone */
1575         A_PUT_STEREO_OUTPUT(A_EXTOUT_HEADPHONE_L, A_EXTOUT_HEADPHONE_R, playback + SND_EMU10K1_PLAYBACK_CHANNELS);
1576
1577         /* digital outputs */
1578         /* A_PUT_STEREO_OUTPUT(A_EXTOUT_FRONT_L, A_EXTOUT_FRONT_R, playback + SND_EMU10K1_PLAYBACK_CHANNELS); */
1579         if (emu->card_capabilities->emu_model) {
1580                 /* EMU1010 Outputs from PCM Front, Rear, Center, LFE, Side */
1581                 dev_info(emu->card->dev, "EMU outputs on\n");
1582                 for (z = 0; z < 8; z++) {
1583                         if (emu->card_capabilities->ca0108_chip) {
1584                                 A_OP(icode, &ptr, iACC3, A3_EMU32OUT(z), A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + z), A_C_00000000, A_C_00000000);
1585                         } else {
1586                                 A_OP(icode, &ptr, iACC3, A_EMU32OUTL(z), A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + z), A_C_00000000, A_C_00000000);
1587                         }
1588                 }
1589         }
1590
1591         /* IEC958 Optical Raw Playback Switch */
1592         gpr_map[gpr++] = 0;
1593         gpr_map[gpr++] = 0x1008;
1594         gpr_map[gpr++] = 0xffff0000;
1595         for (z = 0; z < 2; z++) {
1596                 A_OP(icode, &ptr, iMAC0, A_GPR(tmp + 2), A_FXBUS(FXBUS_PT_LEFT + z), A_C_00000000, A_C_00000000);
1597                 A_OP(icode, &ptr, iSKIP, A_GPR_COND, A_GPR_COND, A_GPR(gpr - 2), A_C_00000001);
1598                 A_OP(icode, &ptr, iACC3, A_GPR(tmp + 2), A_C_00000000, A_C_00010000, A_GPR(tmp + 2));
1599                 A_OP(icode, &ptr, iANDXOR, A_GPR(tmp + 2), A_GPR(tmp + 2), A_GPR(gpr - 1), A_C_00000000);
1600                 A_SWITCH(icode, &ptr, tmp + 0, tmp + 2, gpr + z);
1601                 A_SWITCH_NEG(icode, &ptr, tmp + 1, gpr + z);
1602                 A_SWITCH(icode, &ptr, tmp + 1, playback + SND_EMU10K1_PLAYBACK_CHANNELS + z, tmp + 1);
1603                 if ((z==1) && (emu->card_capabilities->spdif_bug)) {
1604                         /* Due to a SPDIF output bug on some Audigy cards, this code delays the Right channel by 1 sample */
1605                         dev_info(emu->card->dev,
1606                                  "Installing spdif_bug patch: %s\n",
1607                                  emu->card_capabilities->name);
1608                         A_OP(icode, &ptr, iACC3, A_EXTOUT(A_EXTOUT_FRONT_L + z), A_GPR(gpr - 3), A_C_00000000, A_C_00000000);
1609                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 3), A_GPR(tmp + 0), A_GPR(tmp + 1), A_C_00000000);
1610                 } else {
1611                         A_OP(icode, &ptr, iACC3, A_EXTOUT(A_EXTOUT_FRONT_L + z), A_GPR(tmp + 0), A_GPR(tmp + 1), A_C_00000000);
1612                 }
1613         }
1614         snd_emu10k1_init_stereo_onoff_control(controls + nctl++, SNDRV_CTL_NAME_IEC958("Optical Raw ",PLAYBACK,SWITCH), gpr, 0);
1615         gpr += 2;
1616
1617         A_PUT_STEREO_OUTPUT(A_EXTOUT_REAR_L, A_EXTOUT_REAR_R, playback+2 + SND_EMU10K1_PLAYBACK_CHANNELS);
1618         A_PUT_OUTPUT(A_EXTOUT_CENTER, playback+4 + SND_EMU10K1_PLAYBACK_CHANNELS);
1619         A_PUT_OUTPUT(A_EXTOUT_LFE, playback+5 + SND_EMU10K1_PLAYBACK_CHANNELS);
1620
1621         /* ADC buffer */
1622 #ifdef EMU10K1_CAPTURE_DIGITAL_OUT
1623         A_PUT_STEREO_OUTPUT(A_EXTOUT_ADC_CAP_L, A_EXTOUT_ADC_CAP_R, playback + SND_EMU10K1_PLAYBACK_CHANNELS);
1624 #else
1625         A_PUT_OUTPUT(A_EXTOUT_ADC_CAP_L, capture);
1626         A_PUT_OUTPUT(A_EXTOUT_ADC_CAP_R, capture+1);
1627 #endif
1628
1629         if (emu->card_capabilities->emu_model) {
1630                 if (emu->card_capabilities->ca0108_chip) {
1631                         dev_info(emu->card->dev, "EMU2 inputs on\n");
1632                         for (z = 0; z < 0x10; z++) {
1633                                 snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp,
1634                                                                         bit_shifter16,
1635                                                                         A3_EMU32IN(z),
1636                                                                         A_FXBUS2(z*2) );
1637                         }
1638                 } else {
1639                         dev_info(emu->card->dev, "EMU inputs on\n");
1640                         /* Capture 16 (originally 8) channels of S32_LE sound */
1641
1642                         /*
1643                         dev_dbg(emu->card->dev, "emufx.c: gpr=0x%x, tmp=0x%x\n",
1644                                gpr, tmp);
1645                         */
1646                         /* For the EMU1010: How to get 32bit values from the DSP. High 16bits into L, low 16bits into R. */
1647                         /* A_P16VIN(0) is delayed by one sample,
1648                          * so all other A_P16VIN channels will need to also be delayed
1649                          */
1650                         /* Left ADC in. 1 of 2 */
1651                         snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_P16VIN(0x0), A_FXBUS2(0) );
1652                         /* Right ADC in 1 of 2 */
1653                         gpr_map[gpr++] = 0x00000000;
1654                         /* Delaying by one sample: instead of copying the input
1655                          * value A_P16VIN to output A_FXBUS2 as in the first channel,
1656                          * we use an auxiliary register, delaying the value by one
1657                          * sample
1658                          */
1659                         snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(2) );
1660                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x1), A_C_00000000, A_C_00000000);
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(4) );
1663                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x2), A_C_00000000, A_C_00000000);
1664                         gpr_map[gpr++] = 0x00000000;
1665                         snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(6) );
1666                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x3), A_C_00000000, A_C_00000000);
1667                         /* For 96kHz mode */
1668                         /* Left ADC in. 2 of 2 */
1669                         gpr_map[gpr++] = 0x00000000;
1670                         snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(0x8) );
1671                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x4), A_C_00000000, A_C_00000000);
1672                         /* Right ADC in 2 of 2 */
1673                         gpr_map[gpr++] = 0x00000000;
1674                         snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(0xa) );
1675                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x5), A_C_00000000, A_C_00000000);
1676                         gpr_map[gpr++] = 0x00000000;
1677                         snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(0xc) );
1678                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x6), A_C_00000000, A_C_00000000);
1679                         gpr_map[gpr++] = 0x00000000;
1680                         snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(0xe) );
1681                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x7), A_C_00000000, A_C_00000000);
1682                         /* Pavel Hofman - we still have voices, A_FXBUS2s, and
1683                          * A_P16VINs available -
1684                          * let's add 8 more capture channels - total of 16
1685                          */
1686                         gpr_map[gpr++] = 0x00000000;
1687                         snd_emu10k1_audigy_dsp_convert_32_to_2x16(icode, &ptr, tmp,
1688                                                                   bit_shifter16,
1689                                                                   A_GPR(gpr - 1),
1690                                                                   A_FXBUS2(0x10));
1691                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x8),
1692                              A_C_00000000, A_C_00000000);
1693                         gpr_map[gpr++] = 0x00000000;
1694                         snd_emu10k1_audigy_dsp_convert_32_to_2x16(icode, &ptr, tmp,
1695                                                                   bit_shifter16,
1696                                                                   A_GPR(gpr - 1),
1697                                                                   A_FXBUS2(0x12));
1698                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x9),
1699                              A_C_00000000, A_C_00000000);
1700                         gpr_map[gpr++] = 0x00000000;
1701                         snd_emu10k1_audigy_dsp_convert_32_to_2x16(icode, &ptr, tmp,
1702                                                                   bit_shifter16,
1703                                                                   A_GPR(gpr - 1),
1704                                                                   A_FXBUS2(0x14));
1705                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0xa),
1706                              A_C_00000000, A_C_00000000);
1707                         gpr_map[gpr++] = 0x00000000;
1708                         snd_emu10k1_audigy_dsp_convert_32_to_2x16(icode, &ptr, tmp,
1709                                                                   bit_shifter16,
1710                                                                   A_GPR(gpr - 1),
1711                                                                   A_FXBUS2(0x16));
1712                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0xb),
1713                              A_C_00000000, A_C_00000000);
1714                         gpr_map[gpr++] = 0x00000000;
1715                         snd_emu10k1_audigy_dsp_convert_32_to_2x16(icode, &ptr, tmp,
1716                                                                   bit_shifter16,
1717                                                                   A_GPR(gpr - 1),
1718                                                                   A_FXBUS2(0x18));
1719                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0xc),
1720                              A_C_00000000, A_C_00000000);
1721                         gpr_map[gpr++] = 0x00000000;
1722                         snd_emu10k1_audigy_dsp_convert_32_to_2x16(icode, &ptr, tmp,
1723                                                                   bit_shifter16,
1724                                                                   A_GPR(gpr - 1),
1725                                                                   A_FXBUS2(0x1a));
1726                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0xd),
1727                              A_C_00000000, A_C_00000000);
1728                         gpr_map[gpr++] = 0x00000000;
1729                         snd_emu10k1_audigy_dsp_convert_32_to_2x16(icode, &ptr, tmp,
1730                                                                   bit_shifter16,
1731                                                                   A_GPR(gpr - 1),
1732                                                                   A_FXBUS2(0x1c));
1733                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0xe),
1734                              A_C_00000000, A_C_00000000);
1735                         gpr_map[gpr++] = 0x00000000;
1736                         snd_emu10k1_audigy_dsp_convert_32_to_2x16(icode, &ptr, tmp,
1737                                                                   bit_shifter16,
1738                                                                   A_GPR(gpr - 1),
1739                                                                   A_FXBUS2(0x1e));
1740                         A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0xf),
1741                              A_C_00000000, A_C_00000000);
1742                 }
1743
1744 #if 0
1745                 for (z = 4; z < 8; z++) {
1746                         A_OP(icode, &ptr, iACC3, A_FXBUS2(z), A_C_00000000, A_C_00000000, A_C_00000000);
1747                 }
1748                 for (z = 0xc; z < 0x10; z++) {
1749                         A_OP(icode, &ptr, iACC3, A_FXBUS2(z), A_C_00000000, A_C_00000000, A_C_00000000);
1750                 }
1751 #endif
1752         } else {
1753                 /* EFX capture - capture the 16 EXTINs */
1754                 /* Capture 16 channels of S16_LE sound */
1755                 for (z = 0; z < 16; z++) {
1756                         A_OP(icode, &ptr, iACC3, A_FXBUS2(z), A_C_00000000, A_C_00000000, A_EXTIN(z));
1757                 }
1758         }
1759
1760 #endif /* JCD test */
1761         /*
1762          * ok, set up done..
1763          */
1764
1765         if (gpr > tmp) {
1766                 snd_BUG();
1767                 err = -EIO;
1768                 goto __err;
1769         }
1770         /* clear remaining instruction memory */
1771         while (ptr < 0x400)
1772                 A_OP(icode, &ptr, 0x0f, 0xc0, 0xc0, 0xcf, 0xc0);
1773
1774         icode->gpr_add_control_count = nctl;
1775         icode->gpr_add_controls = (struct snd_emu10k1_fx8010_control_gpr __user *)controls;
1776         emu->support_tlv = 1; /* support TLV */
1777         err = snd_emu10k1_icode_poke(emu, icode, true);
1778         emu->support_tlv = 0; /* clear again */
1779
1780 __err:
1781         kfree(controls);
1782 __err_ctrls:
1783         kfree((void __force *)icode->gpr_map);
1784 __err_gpr:
1785         kfree(icode);
1786         return err;
1787 }
1788
1789
1790 /*
1791  * initial DSP configuration for Emu10k1
1792  */
1793
1794 /* when volume = max, then copy only to avoid volume modification */
1795 /* with iMAC0 (negative values) */
1796 static void _volume(struct snd_emu10k1_fx8010_code *icode, u32 *ptr, u32 dst, u32 src, u32 vol)
1797 {
1798         OP(icode, ptr, iMAC0, dst, C_00000000, src, vol);
1799         OP(icode, ptr, iANDXOR, C_00000000, vol, C_ffffffff, C_7fffffff);
1800         OP(icode, ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, C_00000001);
1801         OP(icode, ptr, iACC3, dst, src, C_00000000, C_00000000);
1802 }
1803 static void _volume_add(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, iMACINT0, dst, dst, src, C_00000001);
1808         OP(icode, ptr, iSKIP, C_00000000, C_7fffffff, C_7fffffff, C_00000001);
1809         OP(icode, ptr, iMAC0, dst, dst, src, vol);
1810 }
1811 static void _volume_out(struct snd_emu10k1_fx8010_code *icode, u32 *ptr, u32 dst, u32 src, u32 vol)
1812 {
1813         OP(icode, ptr, iANDXOR, C_00000000, vol, C_ffffffff, C_7fffffff);
1814         OP(icode, ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, C_00000002);
1815         OP(icode, ptr, iACC3, dst, src, C_00000000, C_00000000);
1816         OP(icode, ptr, iSKIP, C_00000000, C_7fffffff, C_7fffffff, C_00000001);
1817         OP(icode, ptr, iMAC0, dst, C_00000000, src, vol);
1818 }
1819
1820 #define VOLUME(icode, ptr, dst, src, vol) \
1821                 _volume(icode, ptr, GPR(dst), GPR(src), GPR(vol))
1822 #define VOLUME_IN(icode, ptr, dst, src, vol) \
1823                 _volume(icode, ptr, GPR(dst), EXTIN(src), GPR(vol))
1824 #define VOLUME_ADD(icode, ptr, dst, src, vol) \
1825                 _volume_add(icode, ptr, GPR(dst), GPR(src), GPR(vol))
1826 #define VOLUME_ADDIN(icode, ptr, dst, src, vol) \
1827                 _volume_add(icode, ptr, GPR(dst), EXTIN(src), GPR(vol))
1828 #define VOLUME_OUT(icode, ptr, dst, src, vol) \
1829                 _volume_out(icode, ptr, EXTOUT(dst), GPR(src), GPR(vol))
1830 #define _SWITCH(icode, ptr, dst, src, sw) \
1831         OP((icode), ptr, iMACINT0, dst, C_00000000, src, sw);
1832 #define SWITCH(icode, ptr, dst, src, sw) \
1833                 _SWITCH(icode, ptr, GPR(dst), GPR(src), GPR(sw))
1834 #define SWITCH_IN(icode, ptr, dst, src, sw) \
1835                 _SWITCH(icode, ptr, GPR(dst), EXTIN(src), GPR(sw))
1836 #define _SWITCH_NEG(icode, ptr, dst, src) \
1837         OP((icode), ptr, iANDXOR, dst, src, C_00000001, C_00000001);
1838 #define SWITCH_NEG(icode, ptr, dst, src) \
1839                 _SWITCH_NEG(icode, ptr, GPR(dst), GPR(src))
1840
1841
1842 static int _snd_emu10k1_init_efx(struct snd_emu10k1 *emu)
1843 {
1844         int err, i, z, gpr, tmp, playback, capture;
1845         u32 ptr;
1846         struct snd_emu10k1_fx8010_code *icode;
1847         struct snd_emu10k1_fx8010_pcm_rec *ipcm = NULL;
1848         struct snd_emu10k1_fx8010_control_gpr *controls = NULL, *ctl;
1849         u32 *gpr_map;
1850
1851         err = -ENOMEM;
1852         icode = kzalloc(sizeof(*icode), GFP_KERNEL);
1853         if (!icode)
1854                 return err;
1855
1856         icode->gpr_map = (u_int32_t __user *) kcalloc(256 + 160 + 160 + 2 * 512,
1857                                                       sizeof(u_int32_t), GFP_KERNEL);
1858         if (!icode->gpr_map)
1859                 goto __err_gpr;
1860
1861         controls = kcalloc(SND_EMU10K1_GPR_CONTROLS,
1862                            sizeof(struct snd_emu10k1_fx8010_control_gpr),
1863                            GFP_KERNEL);
1864         if (!controls)
1865                 goto __err_ctrls;
1866
1867         ipcm = kzalloc(sizeof(*ipcm), GFP_KERNEL);
1868         if (!ipcm)
1869                 goto __err_ipcm;
1870
1871         gpr_map = (u32 __force *)icode->gpr_map;
1872
1873         icode->tram_data_map = icode->gpr_map + 256;
1874         icode->tram_addr_map = icode->tram_data_map + 160;
1875         icode->code = icode->tram_addr_map + 160;
1876
1877         /* clear free GPRs */
1878         for (i = 0; i < 256; i++)
1879                 set_bit(i, icode->gpr_valid);
1880
1881         /* clear TRAM data & address lines */
1882         for (i = 0; i < 160; i++)
1883                 set_bit(i, icode->tram_valid);
1884
1885         strcpy(icode->name, "SB Live! FX8010 code for ALSA v1.2 by Jaroslav Kysela");
1886         ptr = 0; i = 0;
1887         /* we have 12 inputs */
1888         playback = SND_EMU10K1_INPUTS;
1889         /* we have 6 playback channels and tone control doubles */
1890         capture = playback + (SND_EMU10K1_PLAYBACK_CHANNELS * 2);
1891         gpr = capture + SND_EMU10K1_CAPTURE_CHANNELS;
1892         tmp = 0x88;     /* we need 4 temporary GPR */
1893         /* from 0x8c to 0xff is the area for tone control */
1894
1895         /* stop FX processor */
1896         snd_emu10k1_ptr_write(emu, DBG, 0, (emu->fx8010.dbg = 0) | EMU10K1_DBG_SINGLE_STEP);
1897
1898         /*
1899          *  Process FX Buses
1900          */
1901         OP(icode, &ptr, iMACINT0, GPR(0), C_00000000, FXBUS(FXBUS_PCM_LEFT), C_00000004);
1902         OP(icode, &ptr, iMACINT0, GPR(1), C_00000000, FXBUS(FXBUS_PCM_RIGHT), C_00000004);
1903         OP(icode, &ptr, iMACINT0, GPR(2), C_00000000, FXBUS(FXBUS_MIDI_LEFT), C_00000004);
1904         OP(icode, &ptr, iMACINT0, GPR(3), C_00000000, FXBUS(FXBUS_MIDI_RIGHT), C_00000004);
1905         OP(icode, &ptr, iMACINT0, GPR(4), C_00000000, FXBUS(FXBUS_PCM_LEFT_REAR), C_00000004);
1906         OP(icode, &ptr, iMACINT0, GPR(5), C_00000000, FXBUS(FXBUS_PCM_RIGHT_REAR), C_00000004);
1907         OP(icode, &ptr, iMACINT0, GPR(6), C_00000000, FXBUS(FXBUS_PCM_CENTER), C_00000004);
1908         OP(icode, &ptr, iMACINT0, GPR(7), C_00000000, FXBUS(FXBUS_PCM_LFE), C_00000004);
1909         OP(icode, &ptr, iMACINT0, GPR(8), C_00000000, C_00000000, C_00000000);  /* S/PDIF left */
1910         OP(icode, &ptr, iMACINT0, GPR(9), C_00000000, C_00000000, C_00000000);  /* S/PDIF right */
1911         OP(icode, &ptr, iMACINT0, GPR(10), C_00000000, FXBUS(FXBUS_PCM_LEFT_FRONT), C_00000004);
1912         OP(icode, &ptr, iMACINT0, GPR(11), C_00000000, FXBUS(FXBUS_PCM_RIGHT_FRONT), C_00000004);
1913
1914         /* Raw S/PDIF PCM */
1915         ipcm->substream = 0;
1916         ipcm->channels = 2;
1917         ipcm->tram_start = 0;
1918         ipcm->buffer_size = (64 * 1024) / 2;
1919         ipcm->gpr_size = gpr++;
1920         ipcm->gpr_ptr = gpr++;
1921         ipcm->gpr_count = gpr++;
1922         ipcm->gpr_tmpcount = gpr++;
1923         ipcm->gpr_trigger = gpr++;
1924         ipcm->gpr_running = gpr++;
1925         ipcm->etram[0] = 0;
1926         ipcm->etram[1] = 1;
1927
1928         gpr_map[gpr + 0] = 0xfffff000;
1929         gpr_map[gpr + 1] = 0xffff0000;
1930         gpr_map[gpr + 2] = 0x70000000;
1931         gpr_map[gpr + 3] = 0x00000007;
1932         gpr_map[gpr + 4] = 0x001f << 11;
1933         gpr_map[gpr + 5] = 0x001c << 11;
1934         gpr_map[gpr + 6] = (0x22  - 0x01) - 1;  /* skip at 01 to 22 */
1935         gpr_map[gpr + 7] = (0x22  - 0x06) - 1;  /* skip at 06 to 22 */
1936         gpr_map[gpr + 8] = 0x2000000 + (2<<11);
1937         gpr_map[gpr + 9] = 0x4000000 + (2<<11);
1938         gpr_map[gpr + 10] = 1<<11;
1939         gpr_map[gpr + 11] = (0x24 - 0x0a) - 1;  /* skip at 0a to 24 */
1940         gpr_map[gpr + 12] = 0;
1941
1942         /* if the trigger flag is not set, skip */
1943         /* 00: */ OP(icode, &ptr, iMAC0, C_00000000, GPR(ipcm->gpr_trigger), C_00000000, C_00000000);
1944         /* 01: */ OP(icode, &ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_ZERO, GPR(gpr + 6));
1945         /* if the running flag is set, we're running */
1946         /* 02: */ OP(icode, &ptr, iMAC0, C_00000000, GPR(ipcm->gpr_running), C_00000000, C_00000000);
1947         /* 03: */ OP(icode, &ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, C_00000004);
1948         /* wait until ((GPR_DBAC>>11) & 0x1f) == 0x1c) */
1949         /* 04: */ OP(icode, &ptr, iANDXOR, GPR(tmp + 0), GPR_DBAC, GPR(gpr + 4), C_00000000);
1950         /* 05: */ OP(icode, &ptr, iMACINT0, C_00000000, GPR(tmp + 0), C_ffffffff, GPR(gpr + 5));
1951         /* 06: */ OP(icode, &ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, GPR(gpr + 7));
1952         /* 07: */ OP(icode, &ptr, iACC3, GPR(gpr + 12), C_00000010, C_00000001, C_00000000);
1953
1954         /* 08: */ OP(icode, &ptr, iANDXOR, GPR(ipcm->gpr_running), GPR(ipcm->gpr_running), C_00000000, C_00000001);
1955         /* 09: */ OP(icode, &ptr, iACC3, GPR(gpr + 12), GPR(gpr + 12), C_ffffffff, C_00000000);
1956         /* 0a: */ OP(icode, &ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, GPR(gpr + 11));
1957         /* 0b: */ OP(icode, &ptr, iACC3, GPR(gpr + 12), C_00000001, C_00000000, C_00000000);
1958
1959         /* 0c: */ OP(icode, &ptr, iANDXOR, GPR(tmp + 0), ETRAM_DATA(ipcm->etram[0]), GPR(gpr + 0), C_00000000);
1960         /* 0d: */ OP(icode, &ptr, iLOG, GPR(tmp + 0), GPR(tmp + 0), GPR(gpr + 3), C_00000000);
1961         /* 0e: */ OP(icode, &ptr, iANDXOR, GPR(8), GPR(tmp + 0), GPR(gpr + 1), GPR(gpr + 2));
1962         /* 0f: */ OP(icode, &ptr, iSKIP, C_00000000, GPR_COND, CC_REG_MINUS, C_00000001);
1963         /* 10: */ OP(icode, &ptr, iANDXOR, GPR(8), GPR(8), GPR(gpr + 1), GPR(gpr + 2));
1964
1965         /* 11: */ OP(icode, &ptr, iANDXOR, GPR(tmp + 0), ETRAM_DATA(ipcm->etram[1]), GPR(gpr + 0), C_00000000);
1966         /* 12: */ OP(icode, &ptr, iLOG, GPR(tmp + 0), GPR(tmp + 0), GPR(gpr + 3), C_00000000);
1967         /* 13: */ OP(icode, &ptr, iANDXOR, GPR(9), GPR(tmp + 0), GPR(gpr + 1), GPR(gpr + 2));
1968         /* 14: */ OP(icode, &ptr, iSKIP, C_00000000, GPR_COND, CC_REG_MINUS, C_00000001);
1969         /* 15: */ OP(icode, &ptr, iANDXOR, GPR(9), GPR(9), GPR(gpr + 1), GPR(gpr + 2));
1970
1971         /* 16: */ OP(icode, &ptr, iACC3, GPR(tmp + 0), GPR(ipcm->gpr_ptr), C_00000001, C_00000000);
1972         /* 17: */ OP(icode, &ptr, iMACINT0, C_00000000, GPR(tmp + 0), C_ffffffff, GPR(ipcm->gpr_size));
1973         /* 18: */ OP(icode, &ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_MINUS, C_00000001);
1974         /* 19: */ OP(icode, &ptr, iACC3, GPR(tmp + 0), C_00000000, C_00000000, C_00000000);
1975         /* 1a: */ OP(icode, &ptr, iACC3, GPR(ipcm->gpr_ptr), GPR(tmp + 0), C_00000000, C_00000000);
1976
1977         /* 1b: */ OP(icode, &ptr, iACC3, GPR(ipcm->gpr_tmpcount), GPR(ipcm->gpr_tmpcount), C_ffffffff, C_00000000);
1978         /* 1c: */ OP(icode, &ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, C_00000002);
1979         /* 1d: */ OP(icode, &ptr, iACC3, GPR(ipcm->gpr_tmpcount), GPR(ipcm->gpr_count), C_00000000, C_00000000);
1980         /* 1e: */ OP(icode, &ptr, iACC3, GPR_IRQ, C_80000000, C_00000000, C_00000000);
1981         /* 1f: */ OP(icode, &ptr, iANDXOR, GPR(ipcm->gpr_running), GPR(ipcm->gpr_running), C_00000001, C_00010000);
1982
1983         /* 20: */ OP(icode, &ptr, iANDXOR, GPR(ipcm->gpr_running), GPR(ipcm->gpr_running), C_00010000, C_00000001);
1984         /* 21: */ OP(icode, &ptr, iSKIP, C_00000000, C_7fffffff, C_7fffffff, C_00000002);
1985
1986         /* 22: */ OP(icode, &ptr, iMACINT1, ETRAM_ADDR(ipcm->etram[0]), GPR(gpr + 8), GPR_DBAC, C_ffffffff);
1987         /* 23: */ OP(icode, &ptr, iMACINT1, ETRAM_ADDR(ipcm->etram[1]), GPR(gpr + 9), GPR_DBAC, C_ffffffff);
1988
1989         /* 24: */
1990         gpr += 13;
1991
1992         /* Wave Playback Volume */
1993         for (z = 0; z < 2; z++)
1994                 VOLUME(icode, &ptr, playback + z, z, gpr + z);
1995         snd_emu10k1_init_stereo_control(controls + i++, "Wave Playback Volume", gpr, 100);
1996         gpr += 2;
1997
1998         /* Wave Surround Playback Volume */
1999         for (z = 0; z < 2; z++)
2000                 VOLUME(icode, &ptr, playback + 2 + z, z, gpr + z);
2001         snd_emu10k1_init_stereo_control(controls + i++, "Wave Surround Playback Volume", gpr, 0);
2002         gpr += 2;
2003
2004         /* Wave Center/LFE Playback Volume */
2005         OP(icode, &ptr, iACC3, GPR(tmp + 0), FXBUS(FXBUS_PCM_LEFT), FXBUS(FXBUS_PCM_RIGHT), C_00000000);
2006         OP(icode, &ptr, iMACINT0, GPR(tmp + 0), C_00000000, GPR(tmp + 0), C_00000002);
2007         VOLUME(icode, &ptr, playback + 4, tmp + 0, gpr);
2008         snd_emu10k1_init_mono_control(controls + i++, "Wave Center Playback Volume", gpr++, 0);
2009         VOLUME(icode, &ptr, playback + 5, tmp + 0, gpr);
2010         snd_emu10k1_init_mono_control(controls + i++, "Wave LFE Playback Volume", gpr++, 0);
2011
2012         /* Wave Capture Volume + Switch */
2013         for (z = 0; z < 2; z++) {
2014                 SWITCH(icode, &ptr, tmp + 0, z, gpr + 2 + z);
2015                 VOLUME(icode, &ptr, capture + z, tmp + 0, gpr + z);
2016         }
2017         snd_emu10k1_init_stereo_control(controls + i++, "Wave Capture Volume", gpr, 0);
2018         snd_emu10k1_init_stereo_onoff_control(controls + i++, "Wave Capture Switch", gpr + 2, 0);
2019         gpr += 4;
2020
2021         /* Synth Playback Volume */
2022         for (z = 0; z < 2; z++)
2023                 VOLUME_ADD(icode, &ptr, playback + z, 2 + z, gpr + z);
2024         snd_emu10k1_init_stereo_control(controls + i++, "Synth Playback Volume", gpr, 100);
2025         gpr += 2;
2026
2027         /* Synth Capture Volume + Switch */
2028         for (z = 0; z < 2; z++) {
2029                 SWITCH(icode, &ptr, tmp + 0, 2 + z, gpr + 2 + z);
2030                 VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z);
2031         }
2032         snd_emu10k1_init_stereo_control(controls + i++, "Synth Capture Volume", gpr, 0);
2033         snd_emu10k1_init_stereo_onoff_control(controls + i++, "Synth Capture Switch", gpr + 2, 0);
2034         gpr += 4;
2035
2036         /* Surround Digital Playback Volume (renamed later without Digital) */
2037         for (z = 0; z < 2; z++)
2038                 VOLUME_ADD(icode, &ptr, playback + 2 + z, 4 + z, gpr + z);
2039         snd_emu10k1_init_stereo_control(controls + i++, "Surround Digital Playback Volume", gpr, 100);
2040         gpr += 2;
2041
2042         /* Surround Capture Volume + Switch */
2043         for (z = 0; z < 2; z++) {
2044                 SWITCH(icode, &ptr, tmp + 0, 4 + z, gpr + 2 + z);
2045                 VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z);
2046         }
2047         snd_emu10k1_init_stereo_control(controls + i++, "Surround Capture Volume", gpr, 0);
2048         snd_emu10k1_init_stereo_onoff_control(controls + i++, "Surround Capture Switch", gpr + 2, 0);
2049         gpr += 4;
2050
2051         /* Center Playback Volume (renamed later without Digital) */
2052         VOLUME_ADD(icode, &ptr, playback + 4, 6, gpr);
2053         snd_emu10k1_init_mono_control(controls + i++, "Center Digital Playback Volume", gpr++, 100);
2054
2055         /* LFE Playback Volume + Switch (renamed later without Digital) */
2056         VOLUME_ADD(icode, &ptr, playback + 5, 7, gpr);
2057         snd_emu10k1_init_mono_control(controls + i++, "LFE Digital Playback Volume", gpr++, 100);
2058
2059         /* Front Playback Volume */
2060         for (z = 0; z < 2; z++)
2061                 VOLUME_ADD(icode, &ptr, playback + z, 10 + z, gpr + z);
2062         snd_emu10k1_init_stereo_control(controls + i++, "Front Playback Volume", gpr, 100);
2063         gpr += 2;
2064
2065         /* Front Capture Volume + Switch */
2066         for (z = 0; z < 2; z++) {
2067                 SWITCH(icode, &ptr, tmp + 0, 10 + z, gpr + 2);
2068                 VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z);
2069         }
2070         snd_emu10k1_init_stereo_control(controls + i++, "Front Capture Volume", gpr, 0);
2071         snd_emu10k1_init_mono_onoff_control(controls + i++, "Front Capture Switch", gpr + 2, 0);
2072         gpr += 3;
2073
2074         /*
2075          *  Process inputs
2076          */
2077
2078         if (emu->fx8010.extin_mask & ((1<<EXTIN_AC97_L)|(1<<EXTIN_AC97_R))) {
2079                 /* AC'97 Playback Volume */
2080                 VOLUME_ADDIN(icode, &ptr, playback + 0, EXTIN_AC97_L, gpr); gpr++;
2081                 VOLUME_ADDIN(icode, &ptr, playback + 1, EXTIN_AC97_R, gpr); gpr++;
2082                 snd_emu10k1_init_stereo_control(controls + i++, "AC97 Playback Volume", gpr-2, 0);
2083                 /* AC'97 Capture Volume */
2084                 VOLUME_ADDIN(icode, &ptr, capture + 0, EXTIN_AC97_L, gpr); gpr++;
2085                 VOLUME_ADDIN(icode, &ptr, capture + 1, EXTIN_AC97_R, gpr); gpr++;
2086                 snd_emu10k1_init_stereo_control(controls + i++, "AC97 Capture Volume", gpr-2, 100);
2087         }
2088
2089         if (emu->fx8010.extin_mask & ((1<<EXTIN_SPDIF_CD_L)|(1<<EXTIN_SPDIF_CD_R))) {
2090                 /* IEC958 TTL Playback Volume */
2091                 for (z = 0; z < 2; z++)
2092                         VOLUME_ADDIN(icode, &ptr, playback + z, EXTIN_SPDIF_CD_L + z, gpr + z);
2093                 snd_emu10k1_init_stereo_control(controls + i++, SNDRV_CTL_NAME_IEC958("TTL ",PLAYBACK,VOLUME), gpr, 0);
2094                 gpr += 2;
2095
2096                 /* IEC958 TTL Capture Volume + Switch */
2097                 for (z = 0; z < 2; z++) {
2098                         SWITCH_IN(icode, &ptr, tmp + 0, EXTIN_SPDIF_CD_L + z, gpr + 2 + z);
2099                         VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z);
2100                 }
2101                 snd_emu10k1_init_stereo_control(controls + i++, SNDRV_CTL_NAME_IEC958("TTL ",CAPTURE,VOLUME), gpr, 0);
2102                 snd_emu10k1_init_stereo_onoff_control(controls + i++, SNDRV_CTL_NAME_IEC958("TTL ",CAPTURE,SWITCH), gpr + 2, 0);
2103                 gpr += 4;
2104         }
2105
2106         if (emu->fx8010.extin_mask & ((1<<EXTIN_ZOOM_L)|(1<<EXTIN_ZOOM_R))) {
2107                 /* Zoom Video Playback Volume */
2108                 for (z = 0; z < 2; z++)
2109                         VOLUME_ADDIN(icode, &ptr, playback + z, EXTIN_ZOOM_L + z, gpr + z);
2110                 snd_emu10k1_init_stereo_control(controls + i++, "Zoom Video Playback Volume", gpr, 0);
2111                 gpr += 2;
2112
2113                 /* Zoom Video Capture Volume + Switch */
2114                 for (z = 0; z < 2; z++) {
2115                         SWITCH_IN(icode, &ptr, tmp + 0, EXTIN_ZOOM_L + z, gpr + 2 + z);
2116                         VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z);
2117                 }
2118                 snd_emu10k1_init_stereo_control(controls + i++, "Zoom Video Capture Volume", gpr, 0);
2119                 snd_emu10k1_init_stereo_onoff_control(controls + i++, "Zoom Video Capture Switch", gpr + 2, 0);
2120                 gpr += 4;
2121         }
2122
2123         if (emu->fx8010.extin_mask & ((1<<EXTIN_TOSLINK_L)|(1<<EXTIN_TOSLINK_R))) {
2124                 /* IEC958 Optical Playback Volume */
2125                 for (z = 0; z < 2; z++)
2126                         VOLUME_ADDIN(icode, &ptr, playback + z, EXTIN_TOSLINK_L + z, gpr + z);
2127                 snd_emu10k1_init_stereo_control(controls + i++, SNDRV_CTL_NAME_IEC958("LiveDrive ",PLAYBACK,VOLUME), gpr, 0);
2128                 gpr += 2;
2129
2130                 /* IEC958 Optical Capture Volume */
2131                 for (z = 0; z < 2; z++) {
2132                         SWITCH_IN(icode, &ptr, tmp + 0, EXTIN_TOSLINK_L + z, gpr + 2 + z);
2133                         VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z);
2134                 }
2135                 snd_emu10k1_init_stereo_control(controls + i++, SNDRV_CTL_NAME_IEC958("LiveDrive ",CAPTURE,VOLUME), gpr, 0);
2136                 snd_emu10k1_init_stereo_onoff_control(controls + i++, SNDRV_CTL_NAME_IEC958("LiveDrive ",CAPTURE,SWITCH), gpr + 2, 0);
2137                 gpr += 4;
2138         }
2139
2140         if (emu->fx8010.extin_mask & ((1<<EXTIN_LINE1_L)|(1<<EXTIN_LINE1_R))) {
2141                 /* Line LiveDrive Playback Volume */
2142                 for (z = 0; z < 2; z++)
2143                         VOLUME_ADDIN(icode, &ptr, playback + z, EXTIN_LINE1_L + z, gpr + z);
2144                 snd_emu10k1_init_stereo_control(controls + i++, "Line LiveDrive Playback Volume", gpr, 0);
2145                 gpr += 2;
2146
2147                 /* Line LiveDrive Capture Volume + Switch */
2148                 for (z = 0; z < 2; z++) {
2149                         SWITCH_IN(icode, &ptr, tmp + 0, EXTIN_LINE1_L + z, gpr + 2 + z);
2150                         VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z);
2151                 }
2152                 snd_emu10k1_init_stereo_control(controls + i++, "Line LiveDrive Capture Volume", gpr, 0);
2153                 snd_emu10k1_init_stereo_onoff_control(controls + i++, "Line LiveDrive Capture Switch", gpr + 2, 0);
2154                 gpr += 4;
2155         }
2156
2157         if (emu->fx8010.extin_mask & ((1<<EXTIN_COAX_SPDIF_L)|(1<<EXTIN_COAX_SPDIF_R))) {
2158                 /* IEC958 Coax Playback Volume */
2159                 for (z = 0; z < 2; z++)
2160                         VOLUME_ADDIN(icode, &ptr, playback + z, EXTIN_COAX_SPDIF_L + z, gpr + z);
2161                 snd_emu10k1_init_stereo_control(controls + i++, SNDRV_CTL_NAME_IEC958("Coaxial ",PLAYBACK,VOLUME), gpr, 0);
2162                 gpr += 2;
2163
2164                 /* IEC958 Coax Capture Volume + Switch */
2165                 for (z = 0; z < 2; z++) {
2166                         SWITCH_IN(icode, &ptr, tmp + 0, EXTIN_COAX_SPDIF_L + z, gpr + 2 + z);
2167                         VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z);
2168                 }
2169                 snd_emu10k1_init_stereo_control(controls + i++, SNDRV_CTL_NAME_IEC958("Coaxial ",CAPTURE,VOLUME), gpr, 0);
2170                 snd_emu10k1_init_stereo_onoff_control(controls + i++, SNDRV_CTL_NAME_IEC958("Coaxial ",CAPTURE,SWITCH), gpr + 2, 0);
2171                 gpr += 4;
2172         }
2173
2174         if (emu->fx8010.extin_mask & ((1<<EXTIN_LINE2_L)|(1<<EXTIN_LINE2_R))) {
2175                 /* Line LiveDrive Playback Volume */
2176                 for (z = 0; z < 2; z++)
2177                         VOLUME_ADDIN(icode, &ptr, playback + z, EXTIN_LINE2_L + z, gpr + z);
2178                 snd_emu10k1_init_stereo_control(controls + i++, "Line2 LiveDrive Playback Volume", gpr, 0);
2179                 controls[i-1].id.index = 1;
2180                 gpr += 2;
2181
2182                 /* Line LiveDrive Capture Volume */
2183                 for (z = 0; z < 2; z++) {
2184                         SWITCH_IN(icode, &ptr, tmp + 0, EXTIN_LINE2_L + z, gpr + 2 + z);
2185                         VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z);
2186                 }
2187                 snd_emu10k1_init_stereo_control(controls + i++, "Line2 LiveDrive Capture Volume", gpr, 0);
2188                 controls[i-1].id.index = 1;
2189                 snd_emu10k1_init_stereo_onoff_control(controls + i++, "Line2 LiveDrive Capture Switch", gpr + 2, 0);
2190                 controls[i-1].id.index = 1;
2191                 gpr += 4;
2192         }
2193
2194         /*
2195          *  Process tone control
2196          */
2197         OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 0), GPR(playback + 0), C_00000000, C_00000000); /* left */
2198         OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 1), GPR(playback + 1), C_00000000, C_00000000); /* right */
2199         OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 2), GPR(playback + 2), C_00000000, C_00000000); /* rear left */
2200         OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 3), GPR(playback + 3), C_00000000, C_00000000); /* rear right */
2201         OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 4), GPR(playback + 4), C_00000000, C_00000000); /* center */
2202         OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 5), GPR(playback + 5), C_00000000, C_00000000); /* LFE */
2203
2204         ctl = &controls[i + 0];
2205         ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2206         strcpy(ctl->id.name, "Tone Control - Bass");
2207         ctl->vcount = 2;
2208         ctl->count = 10;
2209         ctl->min = 0;
2210         ctl->max = 40;
2211         ctl->value[0] = ctl->value[1] = 20;
2212         ctl->tlv = snd_emu10k1_bass_treble_db_scale;
2213         ctl->translation = EMU10K1_GPR_TRANSLATION_BASS;
2214         ctl = &controls[i + 1];
2215         ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2216         strcpy(ctl->id.name, "Tone Control - Treble");
2217         ctl->vcount = 2;
2218         ctl->count = 10;
2219         ctl->min = 0;
2220         ctl->max = 40;
2221         ctl->value[0] = ctl->value[1] = 20;
2222         ctl->tlv = snd_emu10k1_bass_treble_db_scale;
2223         ctl->translation = EMU10K1_GPR_TRANSLATION_TREBLE;
2224
2225 #define BASS_GPR        0x8c
2226 #define TREBLE_GPR      0x96
2227
2228         for (z = 0; z < 5; z++) {
2229                 int j;
2230                 for (j = 0; j < 2; j++) {
2231                         controls[i + 0].gpr[z * 2 + j] = BASS_GPR + z * 2 + j;
2232                         controls[i + 1].gpr[z * 2 + j] = TREBLE_GPR + z * 2 + j;
2233                 }
2234         }
2235         for (z = 0; z < 3; z++) {               /* front/rear/center-lfe */
2236                 int j, k, l, d;
2237                 for (j = 0; j < 2; j++) {       /* left/right */
2238                         k = 0xa0 + (z * 8) + (j * 4);
2239                         l = 0xd0 + (z * 8) + (j * 4);
2240                         d = playback + SND_EMU10K1_PLAYBACK_CHANNELS + z * 2 + j;
2241
2242                         OP(icode, &ptr, iMAC0, C_00000000, C_00000000, GPR(d), GPR(BASS_GPR + 0 + j));
2243                         OP(icode, &ptr, iMACMV, GPR(k+1), GPR(k), GPR(k+1), GPR(BASS_GPR + 4 + j));
2244                         OP(icode, &ptr, iMACMV, GPR(k), GPR(d), GPR(k), GPR(BASS_GPR + 2 + j));
2245                         OP(icode, &ptr, iMACMV, GPR(k+3), GPR(k+2), GPR(k+3), GPR(BASS_GPR + 8 + j));
2246                         OP(icode, &ptr, iMAC0, GPR(k+2), GPR_ACCU, GPR(k+2), GPR(BASS_GPR + 6 + j));
2247                         OP(icode, &ptr, iACC3, GPR(k+2), GPR(k+2), GPR(k+2), C_00000000);
2248
2249                         OP(icode, &ptr, iMAC0, C_00000000, C_00000000, GPR(k+2), GPR(TREBLE_GPR + 0 + j));
2250                         OP(icode, &ptr, iMACMV, GPR(l+1), GPR(l), GPR(l+1), GPR(TREBLE_GPR + 4 + j));
2251                         OP(icode, &ptr, iMACMV, GPR(l), GPR(k+2), GPR(l), GPR(TREBLE_GPR + 2 + j));
2252                         OP(icode, &ptr, iMACMV, GPR(l+3), GPR(l+2), GPR(l+3), GPR(TREBLE_GPR + 8 + j));
2253                         OP(icode, &ptr, iMAC0, GPR(l+2), GPR_ACCU, GPR(l+2), GPR(TREBLE_GPR + 6 + j));
2254                         OP(icode, &ptr, iMACINT0, GPR(l+2), C_00000000, GPR(l+2), C_00000010);
2255
2256                         OP(icode, &ptr, iACC3, GPR(d), GPR(l+2), C_00000000, C_00000000);
2257
2258                         if (z == 2)     /* center */
2259                                 break;
2260                 }
2261         }
2262         i += 2;
2263
2264 #undef BASS_GPR
2265 #undef TREBLE_GPR
2266
2267         for (z = 0; z < 6; z++) {
2268                 SWITCH(icode, &ptr, tmp + 0, playback + SND_EMU10K1_PLAYBACK_CHANNELS + z, gpr + 0);
2269                 SWITCH_NEG(icode, &ptr, tmp + 1, gpr + 0);
2270                 SWITCH(icode, &ptr, tmp + 1, playback + z, tmp + 1);
2271                 OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + z), GPR(tmp + 0), GPR(tmp + 1), C_00000000);
2272         }
2273         snd_emu10k1_init_stereo_onoff_control(controls + i++, "Tone Control - Switch", gpr, 0);
2274         gpr += 2;
2275
2276         /*
2277          *  Process outputs
2278          */
2279         if (emu->fx8010.extout_mask & ((1<<EXTOUT_AC97_L)|(1<<EXTOUT_AC97_R))) {
2280                 /* AC'97 Playback Volume */
2281
2282                 for (z = 0; z < 2; z++)
2283                         OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_AC97_L + z), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + z), C_00000000, C_00000000);
2284         }
2285
2286         if (emu->fx8010.extout_mask & ((1<<EXTOUT_TOSLINK_L)|(1<<EXTOUT_TOSLINK_R))) {
2287                 /* IEC958 Optical Raw Playback Switch */
2288
2289                 for (z = 0; z < 2; z++) {
2290                         SWITCH(icode, &ptr, tmp + 0, 8 + z, gpr + z);
2291                         SWITCH_NEG(icode, &ptr, tmp + 1, gpr + z);
2292                         SWITCH(icode, &ptr, tmp + 1, playback + SND_EMU10K1_PLAYBACK_CHANNELS + z, tmp + 1);
2293                         OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_TOSLINK_L + z), GPR(tmp + 0), GPR(tmp + 1), C_00000000);
2294 #ifdef EMU10K1_CAPTURE_DIGITAL_OUT
2295                         OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_ADC_CAP_L + z), GPR(tmp + 0), GPR(tmp + 1), C_00000000);
2296 #endif
2297                 }
2298
2299                 snd_emu10k1_init_stereo_onoff_control(controls + i++, SNDRV_CTL_NAME_IEC958("Optical Raw ",PLAYBACK,SWITCH), gpr, 0);
2300                 gpr += 2;
2301         }
2302
2303         if (emu->fx8010.extout_mask & ((1<<EXTOUT_HEADPHONE_L)|(1<<EXTOUT_HEADPHONE_R))) {
2304                 /* Headphone Playback Volume */
2305
2306                 for (z = 0; z < 2; z++) {
2307                         SWITCH(icode, &ptr, tmp + 0, playback + SND_EMU10K1_PLAYBACK_CHANNELS + 4 + z, gpr + 2 + z);
2308                         SWITCH_NEG(icode, &ptr, tmp + 1, gpr + 2 + z);
2309                         SWITCH(icode, &ptr, tmp + 1, playback + SND_EMU10K1_PLAYBACK_CHANNELS + z, tmp + 1);
2310                         OP(icode, &ptr, iACC3, GPR(tmp + 0), GPR(tmp + 0), GPR(tmp + 1), C_00000000);
2311                         VOLUME_OUT(icode, &ptr, EXTOUT_HEADPHONE_L + z, tmp + 0, gpr + z);
2312                 }
2313
2314                 snd_emu10k1_init_stereo_control(controls + i++, "Headphone Playback Volume", gpr + 0, 0);
2315                 controls[i-1].id.index = 1;     /* AC'97 can have also Headphone control */
2316                 snd_emu10k1_init_mono_onoff_control(controls + i++, "Headphone Center Playback Switch", gpr + 2, 0);
2317                 controls[i-1].id.index = 1;
2318                 snd_emu10k1_init_mono_onoff_control(controls + i++, "Headphone LFE Playback Switch", gpr + 3, 0);
2319                 controls[i-1].id.index = 1;
2320
2321                 gpr += 4;
2322         }
2323
2324         if (emu->fx8010.extout_mask & ((1<<EXTOUT_REAR_L)|(1<<EXTOUT_REAR_R)))
2325                 for (z = 0; z < 2; z++)
2326                         OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_REAR_L + z), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 2 + z), C_00000000, C_00000000);
2327
2328         if (emu->fx8010.extout_mask & ((1<<EXTOUT_AC97_REAR_L)|(1<<EXTOUT_AC97_REAR_R)))
2329                 for (z = 0; z < 2; z++)
2330                         OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_AC97_REAR_L + z), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 2 + z), C_00000000, C_00000000);
2331
2332         if (emu->fx8010.extout_mask & (1<<EXTOUT_AC97_CENTER)) {
2333 #ifndef EMU10K1_CENTER_LFE_FROM_FRONT
2334                 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_AC97_CENTER), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 4), C_00000000, C_00000000);
2335                 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_ACENTER), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 4), C_00000000, C_00000000);
2336 #else
2337                 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_AC97_CENTER), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 0), C_00000000, C_00000000);
2338                 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_ACENTER), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 0), C_00000000, C_00000000);
2339 #endif
2340         }
2341
2342         if (emu->fx8010.extout_mask & (1<<EXTOUT_AC97_LFE)) {
2343 #ifndef EMU10K1_CENTER_LFE_FROM_FRONT
2344                 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_AC97_LFE), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 5), C_00000000, C_00000000);
2345                 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_ALFE), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 5), C_00000000, C_00000000);
2346 #else
2347                 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_AC97_LFE), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 1), C_00000000, C_00000000);
2348                 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_ALFE), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 1), C_00000000, C_00000000);
2349 #endif
2350         }
2351
2352 #ifndef EMU10K1_CAPTURE_DIGITAL_OUT
2353         for (z = 0; z < 2; z++)
2354                 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_ADC_CAP_L + z), GPR(capture + z), C_00000000, C_00000000);
2355 #endif
2356
2357         if (emu->fx8010.extout_mask & (1<<EXTOUT_MIC_CAP))
2358                 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_MIC_CAP), GPR(capture + 2), C_00000000, C_00000000);
2359
2360         /* EFX capture - capture the 16 EXTINS */
2361         if (emu->card_capabilities->sblive51) {
2362                 /* On the Live! 5.1, FXBUS2(1) and FXBUS(2) are shared with EXTOUT_ACENTER
2363                  * and EXTOUT_ALFE, so we can't connect inputs to them for multitrack recording.
2364                  *
2365                  * Since only 14 of the 16 EXTINs are used, this is not a big problem.
2366                  * We route AC97L and R to FX capture 14 and 15, SPDIF CD in to FX capture
2367                  * 0 and 3, then the rest of the EXTINs to the corresponding FX capture
2368                  * channel.  Multitrack recorders will still see the center/lfe output signal
2369                  * on the second and third channels.
2370                  */
2371                 OP(icode, &ptr, iACC3, FXBUS2(14), C_00000000, C_00000000, EXTIN(0));
2372                 OP(icode, &ptr, iACC3, FXBUS2(15), C_00000000, C_00000000, EXTIN(1));
2373                 OP(icode, &ptr, iACC3, FXBUS2(0), C_00000000, C_00000000, EXTIN(2));
2374                 OP(icode, &ptr, iACC3, FXBUS2(3), C_00000000, C_00000000, EXTIN(3));
2375                 for (z = 4; z < 14; z++)
2376                         OP(icode, &ptr, iACC3, FXBUS2(z), C_00000000, C_00000000, EXTIN(z));
2377         } else {
2378                 for (z = 0; z < 16; z++)
2379                         OP(icode, &ptr, iACC3, FXBUS2(z), C_00000000, C_00000000, EXTIN(z));
2380         }
2381
2382
2383         if (gpr > tmp) {
2384                 snd_BUG();
2385                 err = -EIO;
2386                 goto __err;
2387         }
2388         if (i > SND_EMU10K1_GPR_CONTROLS) {
2389                 snd_BUG();
2390                 err = -EIO;
2391                 goto __err;
2392         }
2393
2394         /* clear remaining instruction memory */
2395         while (ptr < 0x200)
2396                 OP(icode, &ptr, iACC3, C_00000000, C_00000000, C_00000000, C_00000000);
2397
2398         if ((err = snd_emu10k1_fx8010_tram_setup(emu, ipcm->buffer_size)) < 0)
2399                 goto __err;
2400         icode->gpr_add_control_count = i;
2401         icode->gpr_add_controls = (struct snd_emu10k1_fx8010_control_gpr __user *)controls;
2402         emu->support_tlv = 1; /* support TLV */
2403         err = snd_emu10k1_icode_poke(emu, icode, true);
2404         emu->support_tlv = 0; /* clear again */
2405         if (err >= 0)
2406                 err = snd_emu10k1_ipcm_poke(emu, ipcm);
2407 __err:
2408         kfree(ipcm);
2409 __err_ipcm:
2410         kfree(controls);
2411 __err_ctrls:
2412         kfree((void __force *)icode->gpr_map);
2413 __err_gpr:
2414         kfree(icode);
2415         return err;
2416 }
2417
2418 int snd_emu10k1_init_efx(struct snd_emu10k1 *emu)
2419 {
2420         spin_lock_init(&emu->fx8010.irq_lock);
2421         INIT_LIST_HEAD(&emu->fx8010.gpr_ctl);
2422         if (emu->audigy)
2423                 return _snd_emu10k1_audigy_init_efx(emu);
2424         else
2425                 return _snd_emu10k1_init_efx(emu);
2426 }
2427
2428 void snd_emu10k1_free_efx(struct snd_emu10k1 *emu)
2429 {
2430         /* stop processor */
2431         if (emu->audigy)
2432                 snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg = A_DBG_SINGLE_STEP);
2433         else
2434                 snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg = EMU10K1_DBG_SINGLE_STEP);
2435 }
2436
2437 #if 0 /* FIXME: who use them? */
2438 int snd_emu10k1_fx8010_tone_control_activate(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, 1);
2443         return 0;
2444 }
2445
2446 int snd_emu10k1_fx8010_tone_control_deactivate(struct snd_emu10k1 *emu, int output)
2447 {
2448         if (output < 0 || output >= 6)
2449                 return -EINVAL;
2450         snd_emu10k1_ptr_write(emu, emu->gpr_base + 0x94 + output, 0, 0);
2451         return 0;
2452 }
2453 #endif
2454
2455 int snd_emu10k1_fx8010_tram_setup(struct snd_emu10k1 *emu, u32 size)
2456 {
2457         u8 size_reg = 0;
2458
2459         /* size is in samples */
2460         if (size != 0) {
2461                 size = (size - 1) >> 13;
2462
2463                 while (size) {
2464                         size >>= 1;
2465                         size_reg++;
2466                 }
2467                 size = 0x2000 << size_reg;
2468         }
2469         if ((emu->fx8010.etram_pages.bytes / 2) == size)
2470                 return 0;
2471         spin_lock_irq(&emu->emu_lock);
2472         outl(HCFG_LOCKTANKCACHE_MASK | inl(emu->port + HCFG), emu->port + HCFG);
2473         spin_unlock_irq(&emu->emu_lock);
2474         snd_emu10k1_ptr_write(emu, TCB, 0, 0);
2475         snd_emu10k1_ptr_write(emu, TCBS, 0, 0);
2476         if (emu->fx8010.etram_pages.area != NULL) {
2477                 snd_dma_free_pages(&emu->fx8010.etram_pages);
2478                 emu->fx8010.etram_pages.area = NULL;
2479                 emu->fx8010.etram_pages.bytes = 0;
2480         }
2481
2482         if (size > 0) {
2483                 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(emu->pci),
2484                                         size * 2, &emu->fx8010.etram_pages) < 0)
2485                         return -ENOMEM;
2486                 memset(emu->fx8010.etram_pages.area, 0, size * 2);
2487                 snd_emu10k1_ptr_write(emu, TCB, 0, emu->fx8010.etram_pages.addr);
2488                 snd_emu10k1_ptr_write(emu, TCBS, 0, size_reg);
2489                 spin_lock_irq(&emu->emu_lock);
2490                 outl(inl(emu->port + HCFG) & ~HCFG_LOCKTANKCACHE_MASK, emu->port + HCFG);
2491                 spin_unlock_irq(&emu->emu_lock);
2492         }
2493
2494         return 0;
2495 }
2496
2497 static int snd_emu10k1_fx8010_open(struct snd_hwdep * hw, struct file *file)
2498 {
2499         return 0;
2500 }
2501
2502 static void copy_string(char *dst, char *src, char *null, int idx)
2503 {
2504         if (src == NULL)
2505                 sprintf(dst, "%s %02X", null, idx);
2506         else
2507                 strcpy(dst, src);
2508 }
2509
2510 static void snd_emu10k1_fx8010_info(struct snd_emu10k1 *emu,
2511                                    struct snd_emu10k1_fx8010_info *info)
2512 {
2513         char **fxbus, **extin, **extout;
2514         unsigned short fxbus_mask, extin_mask, extout_mask;
2515         int res;
2516
2517         info->internal_tram_size = emu->fx8010.itram_size;
2518         info->external_tram_size = emu->fx8010.etram_pages.bytes / 2;
2519         fxbus = fxbuses;
2520         extin = emu->audigy ? audigy_ins : creative_ins;
2521         extout = emu->audigy ? audigy_outs : creative_outs;
2522         fxbus_mask = emu->fx8010.fxbus_mask;
2523         extin_mask = emu->fx8010.extin_mask;
2524         extout_mask = emu->fx8010.extout_mask;
2525         for (res = 0; res < 16; res++, fxbus++, extin++, extout++) {
2526                 copy_string(info->fxbus_names[res], fxbus_mask & (1 << res) ? *fxbus : NULL, "FXBUS", res);
2527                 copy_string(info->extin_names[res], extin_mask & (1 << res) ? *extin : NULL, "Unused", res);
2528                 copy_string(info->extout_names[res], extout_mask & (1 << res) ? *extout : NULL, "Unused", res);
2529         }
2530         for (res = 16; res < 32; res++, extout++)
2531                 copy_string(info->extout_names[res], extout_mask & (1 << res) ? *extout : NULL, "Unused", res);
2532         info->gpr_controls = emu->fx8010.gpr_count;
2533 }
2534
2535 static int snd_emu10k1_fx8010_ioctl(struct snd_hwdep * hw, struct file *file, unsigned int cmd, unsigned long arg)
2536 {
2537         struct snd_emu10k1 *emu = hw->private_data;
2538         struct snd_emu10k1_fx8010_info *info;
2539         struct snd_emu10k1_fx8010_code *icode;
2540         struct snd_emu10k1_fx8010_pcm_rec *ipcm;
2541         unsigned int addr;
2542         void __user *argp = (void __user *)arg;
2543         int res;
2544
2545         switch (cmd) {
2546         case SNDRV_EMU10K1_IOCTL_PVERSION:
2547                 emu->support_tlv = 1;
2548                 return put_user(SNDRV_EMU10K1_VERSION, (int __user *)argp);
2549         case SNDRV_EMU10K1_IOCTL_INFO:
2550                 info = kmalloc(sizeof(*info), GFP_KERNEL);
2551                 if (!info)
2552                         return -ENOMEM;
2553                 snd_emu10k1_fx8010_info(emu, info);
2554                 if (copy_to_user(argp, info, sizeof(*info))) {
2555                         kfree(info);
2556                         return -EFAULT;
2557                 }
2558                 kfree(info);
2559                 return 0;
2560         case SNDRV_EMU10K1_IOCTL_CODE_POKE:
2561                 if (!capable(CAP_SYS_ADMIN))
2562                         return -EPERM;
2563
2564                 icode = memdup_user(argp, sizeof(*icode));
2565                 if (IS_ERR(icode))
2566                         return PTR_ERR(icode);
2567                 res = snd_emu10k1_icode_poke(emu, icode, false);
2568                 kfree(icode);
2569                 return res;
2570         case SNDRV_EMU10K1_IOCTL_CODE_PEEK:
2571                 icode = memdup_user(argp, sizeof(*icode));
2572                 if (IS_ERR(icode))
2573                         return PTR_ERR(icode);
2574                 res = snd_emu10k1_icode_peek(emu, icode);
2575                 if (res == 0 && copy_to_user(argp, icode, sizeof(*icode))) {
2576                         kfree(icode);
2577                         return -EFAULT;
2578                 }
2579                 kfree(icode);
2580                 return res;
2581         case SNDRV_EMU10K1_IOCTL_PCM_POKE:
2582                 ipcm = memdup_user(argp, sizeof(*ipcm));
2583                 if (IS_ERR(ipcm))
2584                         return PTR_ERR(ipcm);
2585                 res = snd_emu10k1_ipcm_poke(emu, ipcm);
2586                 kfree(ipcm);
2587                 return res;
2588         case SNDRV_EMU10K1_IOCTL_PCM_PEEK:
2589                 ipcm = memdup_user(argp, sizeof(*ipcm));
2590                 if (IS_ERR(ipcm))
2591                         return PTR_ERR(ipcm);
2592                 res = snd_emu10k1_ipcm_peek(emu, ipcm);
2593                 if (res == 0 && copy_to_user(argp, ipcm, sizeof(*ipcm))) {
2594                         kfree(ipcm);
2595                         return -EFAULT;
2596                 }
2597                 kfree(ipcm);
2598                 return res;
2599         case SNDRV_EMU10K1_IOCTL_TRAM_SETUP:
2600                 if (!capable(CAP_SYS_ADMIN))
2601                         return -EPERM;
2602                 if (get_user(addr, (unsigned int __user *)argp))
2603                         return -EFAULT;
2604                 mutex_lock(&emu->fx8010.lock);
2605                 res = snd_emu10k1_fx8010_tram_setup(emu, addr);
2606                 mutex_unlock(&emu->fx8010.lock);
2607                 return res;
2608         case SNDRV_EMU10K1_IOCTL_STOP:
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 |= A_DBG_SINGLE_STEP);
2613                 else
2614                         snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg |= EMU10K1_DBG_SINGLE_STEP);
2615                 return 0;
2616         case SNDRV_EMU10K1_IOCTL_CONTINUE:
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 = 0);
2621                 else
2622                         snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg = 0);
2623                 return 0;
2624         case SNDRV_EMU10K1_IOCTL_ZERO_TRAM_COUNTER:
2625                 if (!capable(CAP_SYS_ADMIN))
2626                         return -EPERM;
2627                 if (emu->audigy)
2628                         snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg | A_DBG_ZC);
2629                 else
2630                         snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg | EMU10K1_DBG_ZC);
2631                 udelay(10);
2632                 if (emu->audigy)
2633                         snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg);
2634                 else
2635                         snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg);
2636                 return 0;
2637         case SNDRV_EMU10K1_IOCTL_SINGLE_STEP:
2638                 if (!capable(CAP_SYS_ADMIN))
2639                         return -EPERM;
2640                 if (get_user(addr, (unsigned int __user *)argp))
2641                         return -EFAULT;
2642                 if (addr > 0x1ff)
2643                         return -EINVAL;
2644                 if (emu->audigy)
2645                         snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg |= A_DBG_SINGLE_STEP | addr);
2646                 else
2647                         snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg |= EMU10K1_DBG_SINGLE_STEP | addr);
2648                 udelay(10);
2649                 if (emu->audigy)
2650                         snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg |= A_DBG_SINGLE_STEP | A_DBG_STEP_ADDR | addr);
2651                 else
2652                         snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg |= EMU10K1_DBG_SINGLE_STEP | EMU10K1_DBG_STEP | addr);
2653                 return 0;
2654         case SNDRV_EMU10K1_IOCTL_DBG_READ:
2655                 if (emu->audigy)
2656                         addr = snd_emu10k1_ptr_read(emu, A_DBG, 0);
2657                 else
2658                         addr = snd_emu10k1_ptr_read(emu, DBG, 0);
2659                 if (put_user(addr, (unsigned int __user *)argp))
2660                         return -EFAULT;
2661                 return 0;
2662         }
2663         return -ENOTTY;
2664 }
2665
2666 static int snd_emu10k1_fx8010_release(struct snd_hwdep * hw, struct file *file)
2667 {
2668         return 0;
2669 }
2670
2671 int snd_emu10k1_fx8010_new(struct snd_emu10k1 *emu, int device)
2672 {
2673         struct snd_hwdep *hw;
2674         int err;
2675
2676         if ((err = snd_hwdep_new(emu->card, "FX8010", device, &hw)) < 0)
2677                 return err;
2678         strcpy(hw->name, "EMU10K1 (FX8010)");
2679         hw->iface = SNDRV_HWDEP_IFACE_EMU10K1;
2680         hw->ops.open = snd_emu10k1_fx8010_open;
2681         hw->ops.ioctl = snd_emu10k1_fx8010_ioctl;
2682         hw->ops.release = snd_emu10k1_fx8010_release;
2683         hw->private_data = emu;
2684         return 0;
2685 }
2686
2687 #ifdef CONFIG_PM_SLEEP
2688 int snd_emu10k1_efx_alloc_pm_buffer(struct snd_emu10k1 *emu)
2689 {
2690         int len;
2691
2692         len = emu->audigy ? 0x200 : 0x100;
2693         emu->saved_gpr = kmalloc(len * 4, GFP_KERNEL);
2694         if (! emu->saved_gpr)
2695                 return -ENOMEM;
2696         len = emu->audigy ? 0x100 : 0xa0;
2697         emu->tram_val_saved = kmalloc(len * 4, GFP_KERNEL);
2698         emu->tram_addr_saved = kmalloc(len * 4, GFP_KERNEL);
2699         if (! emu->tram_val_saved || ! emu->tram_addr_saved)
2700                 return -ENOMEM;
2701         len = emu->audigy ? 2 * 1024 : 2 * 512;
2702         emu->saved_icode = vmalloc(len * 4);
2703         if (! emu->saved_icode)
2704                 return -ENOMEM;
2705         return 0;
2706 }
2707
2708 void snd_emu10k1_efx_free_pm_buffer(struct snd_emu10k1 *emu)
2709 {
2710         kfree(emu->saved_gpr);
2711         kfree(emu->tram_val_saved);
2712         kfree(emu->tram_addr_saved);
2713         vfree(emu->saved_icode);
2714 }
2715
2716 /*
2717  * save/restore GPR, TRAM and codes
2718  */
2719 void snd_emu10k1_efx_suspend(struct snd_emu10k1 *emu)
2720 {
2721         int i, len;
2722
2723         len = emu->audigy ? 0x200 : 0x100;
2724         for (i = 0; i < len; i++)
2725                 emu->saved_gpr[i] = snd_emu10k1_ptr_read(emu, emu->gpr_base + i, 0);
2726
2727         len = emu->audigy ? 0x100 : 0xa0;
2728         for (i = 0; i < len; i++) {
2729                 emu->tram_val_saved[i] = snd_emu10k1_ptr_read(emu, TANKMEMDATAREGBASE + i, 0);
2730                 emu->tram_addr_saved[i] = snd_emu10k1_ptr_read(emu, TANKMEMADDRREGBASE + i, 0);
2731                 if (emu->audigy) {
2732                         emu->tram_addr_saved[i] >>= 12;
2733                         emu->tram_addr_saved[i] |=
2734                                 snd_emu10k1_ptr_read(emu, A_TANKMEMCTLREGBASE + i, 0) << 20;
2735                 }
2736         }
2737
2738         len = emu->audigy ? 2 * 1024 : 2 * 512;
2739         for (i = 0; i < len; i++)
2740                 emu->saved_icode[i] = snd_emu10k1_efx_read(emu, i);
2741 }
2742
2743 void snd_emu10k1_efx_resume(struct snd_emu10k1 *emu)
2744 {
2745         int i, len;
2746
2747         /* set up TRAM */
2748         if (emu->fx8010.etram_pages.bytes > 0) {
2749                 unsigned size, size_reg = 0;
2750                 size = emu->fx8010.etram_pages.bytes / 2;
2751                 size = (size - 1) >> 13;
2752                 while (size) {
2753                         size >>= 1;
2754                         size_reg++;
2755                 }
2756                 outl(HCFG_LOCKTANKCACHE_MASK | inl(emu->port + HCFG), emu->port + HCFG);
2757                 snd_emu10k1_ptr_write(emu, TCB, 0, emu->fx8010.etram_pages.addr);
2758                 snd_emu10k1_ptr_write(emu, TCBS, 0, size_reg);
2759                 outl(inl(emu->port + HCFG) & ~HCFG_LOCKTANKCACHE_MASK, emu->port + HCFG);
2760         }
2761
2762         if (emu->audigy)
2763                 snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg | A_DBG_SINGLE_STEP);
2764         else
2765                 snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg | EMU10K1_DBG_SINGLE_STEP);
2766
2767         len = emu->audigy ? 0x200 : 0x100;
2768         for (i = 0; i < len; i++)
2769                 snd_emu10k1_ptr_write(emu, emu->gpr_base + i, 0, emu->saved_gpr[i]);
2770
2771         len = emu->audigy ? 0x100 : 0xa0;
2772         for (i = 0; i < len; i++) {
2773                 snd_emu10k1_ptr_write(emu, TANKMEMDATAREGBASE + i, 0,
2774                                       emu->tram_val_saved[i]);
2775                 if (! emu->audigy)
2776                         snd_emu10k1_ptr_write(emu, TANKMEMADDRREGBASE + i, 0,
2777                                               emu->tram_addr_saved[i]);
2778                 else {
2779                         snd_emu10k1_ptr_write(emu, TANKMEMADDRREGBASE + i, 0,
2780                                               emu->tram_addr_saved[i] << 12);
2781                         snd_emu10k1_ptr_write(emu, TANKMEMADDRREGBASE + i, 0,
2782                                               emu->tram_addr_saved[i] >> 20);
2783                 }
2784         }
2785
2786         len = emu->audigy ? 2 * 1024 : 2 * 512;
2787         for (i = 0; i < len; i++)
2788                 snd_emu10k1_efx_write(emu, i, emu->saved_icode[i]);
2789
2790         /* start FX processor when the DSP code is updated */
2791         if (emu->audigy)
2792                 snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg);
2793         else
2794                 snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg);
2795 }
2796 #endif