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