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