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