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