Pileus Git - ~andy/linux/blob - sound/pci/emu10k1/emufx.c

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