sound/pci/emu10k1/emufx.c

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