1 /* 2 * Copyright (c) by Jaroslav Kysela <perex@suse.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 struct list_head *list; 646 647 list_for_each(list, &emu->fx8010.gpr_ctl) { 648 ctl = emu10k1_gpr_ctl(list); 649 kcontrol = ctl->kcontrol; 650 if (kcontrol->id.iface == id->iface && 651 !strcmp(kcontrol->id.name, id->name) && 652 kcontrol->id.index == id->index) 653 return ctl; 654 } 655 return NULL; 656 } 657 658 #define MAX_TLV_SIZE 256 659 660 static unsigned int *copy_tlv(const unsigned int __user *_tlv) 661 { 662 unsigned int data[2]; 663 unsigned int *tlv; 664 665 if (!_tlv) 666 return NULL; 667 if (copy_from_user(data, _tlv, sizeof(data))) 668 return NULL; 669 if (data[1] >= MAX_TLV_SIZE) 670 return NULL; 671 tlv = kmalloc(data[1] * 4 + sizeof(data), GFP_KERNEL); 672 if (!tlv) 673 return NULL; 674 memcpy(tlv, data, sizeof(data)); 675 if (copy_from_user(tlv + 2, _tlv + 2, data[1])) { 676 kfree(tlv); 677 return NULL; 678 } 679 return tlv; 680 } 681 682 static int copy_gctl(struct snd_emu10k1 *emu, 683 struct snd_emu10k1_fx8010_control_gpr *gctl, 684 struct snd_emu10k1_fx8010_control_gpr __user *_gctl, 685 int idx) 686 { 687 struct snd_emu10k1_fx8010_control_old_gpr __user *octl; 688 689 if (emu->support_tlv) 690 return copy_from_user(gctl, &_gctl[idx], sizeof(*gctl)); 691 octl = (struct snd_emu10k1_fx8010_control_old_gpr __user *)_gctl; 692 if (copy_from_user(gctl, &octl[idx], sizeof(*octl))) 693 return -EFAULT; 694 gctl->tlv = NULL; 695 return 0; 696 } 697 698 static int copy_gctl_to_user(struct snd_emu10k1 *emu, 699 struct snd_emu10k1_fx8010_control_gpr __user *_gctl, 700 struct snd_emu10k1_fx8010_control_gpr *gctl, 701 int idx) 702 { 703 struct snd_emu10k1_fx8010_control_old_gpr __user *octl; 704 705 if (emu->support_tlv) 706 return copy_to_user(&_gctl[idx], gctl, sizeof(*gctl)); 707 708 octl = (struct snd_emu10k1_fx8010_control_old_gpr __user *)_gctl; 709 return copy_to_user(&octl[idx], gctl, sizeof(*octl)); 710 } 711 712 static int snd_emu10k1_verify_controls(struct snd_emu10k1 *emu, 713 struct snd_emu10k1_fx8010_code *icode) 714 { 715 unsigned int i; 716 struct snd_ctl_elem_id __user *_id; 717 struct snd_ctl_elem_id id; 718 struct snd_emu10k1_fx8010_control_gpr *gctl; 719 int err; 720 721 for (i = 0, _id = icode->gpr_del_controls; 722 i < icode->gpr_del_control_count; i++, _id++) { 723 if (copy_from_user(&id, _id, sizeof(id))) 724 return -EFAULT; 725 if (snd_emu10k1_look_for_ctl(emu, &id) == NULL) 726 return -ENOENT; 727 } 728 gctl = kmalloc(sizeof(*gctl), GFP_KERNEL); 729 if (! gctl) 730 return -ENOMEM; 731 err = 0; 732 for (i = 0; i < icode->gpr_add_control_count; i++) { 733 if (copy_gctl(emu, gctl, icode->gpr_add_controls, i)) { 734 err = -EFAULT; 735 goto __error; 736 } 737 if (snd_emu10k1_look_for_ctl(emu, &gctl->id)) 738 continue; 739 down_read(&emu->card->controls_rwsem); 740 if (snd_ctl_find_id(emu->card, &gctl->id) != NULL) { 741 up_read(&emu->card->controls_rwsem); 742 err = -EEXIST; 743 goto __error; 744 } 745 up_read(&emu->card->controls_rwsem); 746 if (gctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER && 747 gctl->id.iface != SNDRV_CTL_ELEM_IFACE_PCM) { 748 err = -EINVAL; 749 goto __error; 750 } 751 } 752 for (i = 0; i < icode->gpr_list_control_count; i++) { 753 /* FIXME: we need to check the WRITE access */ 754 if (copy_gctl(emu, gctl, icode->gpr_list_controls, i)) { 755 err = -EFAULT; 756 goto __error; 757 } 758 } 759 __error: 760 kfree(gctl); 761 return err; 762 } 763 764 static void snd_emu10k1_ctl_private_free(struct snd_kcontrol *kctl) 765 { 766 struct snd_emu10k1_fx8010_ctl *ctl; 767 768 ctl = (struct snd_emu10k1_fx8010_ctl *) kctl->private_value; 769 kctl->private_value = 0; 770 list_del(&ctl->list); 771 kfree(ctl); 772 if (kctl->tlv.p) 773 kfree(kctl->tlv.p); 774 } 775 776 static int snd_emu10k1_add_controls(struct snd_emu10k1 *emu, 777 struct snd_emu10k1_fx8010_code *icode) 778 { 779 unsigned int i, j; 780 struct snd_emu10k1_fx8010_control_gpr *gctl; 781 struct snd_emu10k1_fx8010_ctl *ctl, *nctl; 782 struct snd_kcontrol_new knew; 783 struct snd_kcontrol *kctl; 784 struct snd_ctl_elem_value *val; 785 int err = 0; 786 787 val = kmalloc(sizeof(*val), GFP_KERNEL); 788 gctl = kmalloc(sizeof(*gctl), GFP_KERNEL); 789 nctl = kmalloc(sizeof(*nctl), GFP_KERNEL); 790 if (!val || !gctl || !nctl) { 791 err = -ENOMEM; 792 goto __error; 793 } 794 795 for (i = 0; i < icode->gpr_add_control_count; i++) { 796 if (copy_gctl(emu, gctl, icode->gpr_add_controls, i)) { 797 err = -EFAULT; 798 goto __error; 799 } 800 if (gctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER && 801 gctl->id.iface != SNDRV_CTL_ELEM_IFACE_PCM) { 802 err = -EINVAL; 803 goto __error; 804 } 805 if (! gctl->id.name[0]) { 806 err = -EINVAL; 807 goto __error; 808 } 809 ctl = snd_emu10k1_look_for_ctl(emu, &gctl->id); 810 memset(&knew, 0, sizeof(knew)); 811 knew.iface = gctl->id.iface; 812 knew.name = gctl->id.name; 813 knew.index = gctl->id.index; 814 knew.device = gctl->id.device; 815 knew.subdevice = gctl->id.subdevice; 816 knew.info = snd_emu10k1_gpr_ctl_info; 817 knew.tlv.p = copy_tlv(gctl->tlv); 818 if (knew.tlv.p) 819 knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE | 820 SNDRV_CTL_ELEM_ACCESS_TLV_READ; 821 knew.get = snd_emu10k1_gpr_ctl_get; 822 knew.put = snd_emu10k1_gpr_ctl_put; 823 memset(nctl, 0, sizeof(*nctl)); 824 nctl->vcount = gctl->vcount; 825 nctl->count = gctl->count; 826 for (j = 0; j < 32; j++) { 827 nctl->gpr[j] = gctl->gpr[j]; 828 nctl->value[j] = ~gctl->value[j]; /* inverted, we want to write new value in gpr_ctl_put() */ 829 val->value.integer.value[j] = gctl->value[j]; 830 } 831 nctl->min = gctl->min; 832 nctl->max = gctl->max; 833 nctl->translation = gctl->translation; 834 if (ctl == NULL) { 835 ctl = kmalloc(sizeof(*ctl), GFP_KERNEL); 836 if (ctl == NULL) { 837 err = -ENOMEM; 838 kfree(knew.tlv.p); 839 goto __error; 840 } 841 knew.private_value = (unsigned long)ctl; 842 *ctl = *nctl; 843 if ((err = snd_ctl_add(emu->card, kctl = snd_ctl_new1(&knew, emu))) < 0) { 844 kfree(ctl); 845 kfree(knew.tlv.p); 846 goto __error; 847 } 848 kctl->private_free = snd_emu10k1_ctl_private_free; 849 ctl->kcontrol = kctl; 850 list_add_tail(&ctl->list, &emu->fx8010.gpr_ctl); 851 } else { 852 /* overwrite */ 853 nctl->list = ctl->list; 854 nctl->kcontrol = ctl->kcontrol; 855 *ctl = *nctl; 856 snd_ctl_notify(emu->card, SNDRV_CTL_EVENT_MASK_VALUE | 857 SNDRV_CTL_EVENT_MASK_INFO, &ctl->kcontrol->id); 858 } 859 snd_emu10k1_gpr_ctl_put(ctl->kcontrol, val); 860 } 861 __error: 862 kfree(nctl); 863 kfree(gctl); 864 kfree(val); 865 return err; 866 } 867 868 static int snd_emu10k1_del_controls(struct snd_emu10k1 *emu, 869 struct snd_emu10k1_fx8010_code *icode) 870 { 871 unsigned int i; 872 struct snd_ctl_elem_id id; 873 struct snd_ctl_elem_id __user *_id; 874 struct snd_emu10k1_fx8010_ctl *ctl; 875 struct snd_card *card = emu->card; 876 877 for (i = 0, _id = icode->gpr_del_controls; 878 i < icode->gpr_del_control_count; i++, _id++) { 879 if (copy_from_user(&id, _id, sizeof(id))) 880 return -EFAULT; 881 down_write(&card->controls_rwsem); 882 ctl = snd_emu10k1_look_for_ctl(emu, &id); 883 if (ctl) 884 snd_ctl_remove(card, ctl->kcontrol); 885 up_write(&card->controls_rwsem); 886 } 887 return 0; 888 } 889 890 static int snd_emu10k1_list_controls(struct snd_emu10k1 *emu, 891 struct snd_emu10k1_fx8010_code *icode) 892 { 893 unsigned int i = 0, j; 894 unsigned int total = 0; 895 struct snd_emu10k1_fx8010_control_gpr *gctl; 896 struct snd_emu10k1_fx8010_ctl *ctl; 897 struct snd_ctl_elem_id *id; 898 struct list_head *list; 899 900 gctl = kmalloc(sizeof(*gctl), GFP_KERNEL); 901 if (! gctl) 902 return -ENOMEM; 903 904 list_for_each(list, &emu->fx8010.gpr_ctl) { 905 ctl = emu10k1_gpr_ctl(list); 906 total++; 907 if (icode->gpr_list_controls && 908 i < icode->gpr_list_control_count) { 909 memset(gctl, 0, sizeof(*gctl)); 910 id = &ctl->kcontrol->id; 911 gctl->id.iface = id->iface; 912 strlcpy(gctl->id.name, id->name, sizeof(gctl->id.name)); 913 gctl->id.index = id->index; 914 gctl->id.device = id->device; 915 gctl->id.subdevice = id->subdevice; 916 gctl->vcount = ctl->vcount; 917 gctl->count = ctl->count; 918 for (j = 0; j < 32; j++) { 919 gctl->gpr[j] = ctl->gpr[j]; 920 gctl->value[j] = ctl->value[j]; 921 } 922 gctl->min = ctl->min; 923 gctl->max = ctl->max; 924 gctl->translation = ctl->translation; 925 if (copy_gctl_to_user(emu, icode->gpr_list_controls, 926 gctl, i)) { 927 kfree(gctl); 928 return -EFAULT; 929 } 930 i++; 931 } 932 } 933 icode->gpr_list_control_total = total; 934 kfree(gctl); 935 return 0; 936 } 937 938 static int snd_emu10k1_icode_poke(struct snd_emu10k1 *emu, 939 struct snd_emu10k1_fx8010_code *icode) 940 { 941 int err = 0; 942 943 mutex_lock(&emu->fx8010.lock); 944 if ((err = snd_emu10k1_verify_controls(emu, icode)) < 0) 945 goto __error; 946 strlcpy(emu->fx8010.name, icode->name, sizeof(emu->fx8010.name)); 947 /* stop FX processor - this may be dangerous, but it's better to miss 948 some samples than generate wrong ones - [jk] */ 949 if (emu->audigy) 950 snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg | A_DBG_SINGLE_STEP); 951 else 952 snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg | EMU10K1_DBG_SINGLE_STEP); 953 /* ok, do the main job */ 954 if ((err = snd_emu10k1_del_controls(emu, icode)) < 0 || 955 (err = snd_emu10k1_gpr_poke(emu, icode)) < 0 || 956 (err = snd_emu10k1_tram_poke(emu, icode)) < 0 || 957 (err = snd_emu10k1_code_poke(emu, icode)) < 0 || 958 (err = snd_emu10k1_add_controls(emu, icode)) < 0) 959 goto __error; 960 /* start FX processor when the DSP code is updated */ 961 if (emu->audigy) 962 snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg); 963 else 964 snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg); 965 __error: 966 mutex_unlock(&emu->fx8010.lock); 967 return err; 968 } 969 970 static int snd_emu10k1_icode_peek(struct snd_emu10k1 *emu, 971 struct snd_emu10k1_fx8010_code *icode) 972 { 973 int err; 974 975 mutex_lock(&emu->fx8010.lock); 976 strlcpy(icode->name, emu->fx8010.name, sizeof(icode->name)); 977 /* ok, do the main job */ 978 err = snd_emu10k1_gpr_peek(emu, icode); 979 if (err >= 0) 980 err = snd_emu10k1_tram_peek(emu, icode); 981 if (err >= 0) 982 err = snd_emu10k1_code_peek(emu, icode); 983 if (err >= 0) 984 err = snd_emu10k1_list_controls(emu, icode); 985 mutex_unlock(&emu->fx8010.lock); 986 return err; 987 } 988 989 static int snd_emu10k1_ipcm_poke(struct snd_emu10k1 *emu, 990 struct snd_emu10k1_fx8010_pcm_rec *ipcm) 991 { 992 unsigned int i; 993 int err = 0; 994 struct snd_emu10k1_fx8010_pcm *pcm; 995 996 if (ipcm->substream >= EMU10K1_FX8010_PCM_COUNT) 997 return -EINVAL; 998 if (ipcm->channels > 32) 999 return -EINVAL; 1000 pcm = &emu->fx8010.pcm[ipcm->substream]; 1001 mutex_lock(&emu->fx8010.lock); 1002 spin_lock_irq(&emu->reg_lock); 1003 if (pcm->opened) { 1004 err = -EBUSY; 1005 goto __error; 1006 } 1007 if (ipcm->channels == 0) { /* remove */ 1008 pcm->valid = 0; 1009 } else { 1010 /* FIXME: we need to add universal code to the PCM transfer routine */ 1011 if (ipcm->channels != 2) { 1012 err = -EINVAL; 1013 goto __error; 1014 } 1015 pcm->valid = 1; 1016 pcm->opened = 0; 1017 pcm->channels = ipcm->channels; 1018 pcm->tram_start = ipcm->tram_start; 1019 pcm->buffer_size = ipcm->buffer_size; 1020 pcm->gpr_size = ipcm->gpr_size; 1021 pcm->gpr_count = ipcm->gpr_count; 1022 pcm->gpr_tmpcount = ipcm->gpr_tmpcount; 1023 pcm->gpr_ptr = ipcm->gpr_ptr; 1024 pcm->gpr_trigger = ipcm->gpr_trigger; 1025 pcm->gpr_running = ipcm->gpr_running; 1026 for (i = 0; i < pcm->channels; i++) 1027 pcm->etram[i] = ipcm->etram[i]; 1028 } 1029 __error: 1030 spin_unlock_irq(&emu->reg_lock); 1031 mutex_unlock(&emu->fx8010.lock); 1032 return err; 1033 } 1034 1035 static int snd_emu10k1_ipcm_peek(struct snd_emu10k1 *emu, 1036 struct snd_emu10k1_fx8010_pcm_rec *ipcm) 1037 { 1038 unsigned int i; 1039 int err = 0; 1040 struct snd_emu10k1_fx8010_pcm *pcm; 1041 1042 if (ipcm->substream >= EMU10K1_FX8010_PCM_COUNT) 1043 return -EINVAL; 1044 pcm = &emu->fx8010.pcm[ipcm->substream]; 1045 mutex_lock(&emu->fx8010.lock); 1046 spin_lock_irq(&emu->reg_lock); 1047 ipcm->channels = pcm->channels; 1048 ipcm->tram_start = pcm->tram_start; 1049 ipcm->buffer_size = pcm->buffer_size; 1050 ipcm->gpr_size = pcm->gpr_size; 1051 ipcm->gpr_ptr = pcm->gpr_ptr; 1052 ipcm->gpr_count = pcm->gpr_count; 1053 ipcm->gpr_tmpcount = pcm->gpr_tmpcount; 1054 ipcm->gpr_trigger = pcm->gpr_trigger; 1055 ipcm->gpr_running = pcm->gpr_running; 1056 for (i = 0; i < pcm->channels; i++) 1057 ipcm->etram[i] = pcm->etram[i]; 1058 ipcm->res1 = ipcm->res2 = 0; 1059 ipcm->pad = 0; 1060 spin_unlock_irq(&emu->reg_lock); 1061 mutex_unlock(&emu->fx8010.lock); 1062 return err; 1063 } 1064 1065 #define SND_EMU10K1_GPR_CONTROLS 44 1066 #define SND_EMU10K1_INPUTS 12 1067 #define SND_EMU10K1_PLAYBACK_CHANNELS 8 1068 #define SND_EMU10K1_CAPTURE_CHANNELS 4 1069 1070 static void __devinit 1071 snd_emu10k1_init_mono_control(struct snd_emu10k1_fx8010_control_gpr *ctl, 1072 const char *name, int gpr, int defval) 1073 { 1074 ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 1075 strcpy(ctl->id.name, name); 1076 ctl->vcount = ctl->count = 1; 1077 ctl->gpr[0] = gpr + 0; ctl->value[0] = defval; 1078 ctl->min = 0; 1079 ctl->max = 100; 1080 ctl->tlv = snd_emu10k1_db_scale1; 1081 ctl->translation = EMU10K1_GPR_TRANSLATION_TABLE100; 1082 } 1083 1084 static void __devinit 1085 snd_emu10k1_init_stereo_control(struct snd_emu10k1_fx8010_control_gpr *ctl, 1086 const char *name, int gpr, int defval) 1087 { 1088 ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 1089 strcpy(ctl->id.name, name); 1090 ctl->vcount = ctl->count = 2; 1091 ctl->gpr[0] = gpr + 0; ctl->value[0] = defval; 1092 ctl->gpr[1] = gpr + 1; ctl->value[1] = defval; 1093 ctl->min = 0; 1094 ctl->max = 100; 1095 ctl->tlv = snd_emu10k1_db_scale1; 1096 ctl->translation = EMU10K1_GPR_TRANSLATION_TABLE100; 1097 } 1098 1099 static void __devinit 1100 snd_emu10k1_init_mono_onoff_control(struct snd_emu10k1_fx8010_control_gpr *ctl, 1101 const char *name, int gpr, int defval) 1102 { 1103 ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 1104 strcpy(ctl->id.name, name); 1105 ctl->vcount = ctl->count = 1; 1106 ctl->gpr[0] = gpr + 0; ctl->value[0] = defval; 1107 ctl->min = 0; 1108 ctl->max = 1; 1109 ctl->translation = EMU10K1_GPR_TRANSLATION_ONOFF; 1110 } 1111 1112 static void __devinit 1113 snd_emu10k1_init_stereo_onoff_control(struct snd_emu10k1_fx8010_control_gpr *ctl, 1114 const char *name, int gpr, int defval) 1115 { 1116 ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 1117 strcpy(ctl->id.name, name); 1118 ctl->vcount = ctl->count = 2; 1119 ctl->gpr[0] = gpr + 0; ctl->value[0] = defval; 1120 ctl->gpr[1] = gpr + 1; ctl->value[1] = defval; 1121 ctl->min = 0; 1122 ctl->max = 1; 1123 ctl->translation = EMU10K1_GPR_TRANSLATION_ONOFF; 1124 } 1125 1126 static int snd_emu10k1_audigy_dsp_convert_32_to_2x16( 1127 struct snd_emu10k1_fx8010_code *icode, 1128 u32 *ptr, int tmp, int bit_shifter16, 1129 int reg_in, int reg_out) 1130 { 1131 A_OP(icode, ptr, iACC3, A_GPR(tmp + 1), reg_in, A_C_00000000, A_C_00000000); 1132 A_OP(icode, ptr, iANDXOR, A_GPR(tmp), A_GPR(tmp + 1), A_GPR(bit_shifter16 - 1), A_C_00000000); 1133 A_OP(icode, ptr, iTSTNEG, A_GPR(tmp + 2), A_GPR(tmp), A_C_80000000, A_GPR(bit_shifter16 - 2)); 1134 A_OP(icode, ptr, iANDXOR, A_GPR(tmp + 2), A_GPR(tmp + 2), A_C_80000000, A_C_00000000); 1135 A_OP(icode, ptr, iANDXOR, A_GPR(tmp), A_GPR(tmp), A_GPR(bit_shifter16 - 3), A_C_00000000); 1136 A_OP(icode, ptr, iMACINT0, A_GPR(tmp), A_C_00000000, A_GPR(tmp), A_C_00010000); 1137 A_OP(icode, ptr, iANDXOR, reg_out, A_GPR(tmp), A_C_ffffffff, A_GPR(tmp + 2)); 1138 A_OP(icode, ptr, iACC3, reg_out + 1, A_GPR(tmp + 1), A_C_00000000, A_C_00000000); 1139 return 1; 1140 } 1141 1142 /* 1143 * initial DSP configuration for Audigy 1144 */ 1145 1146 static int __devinit _snd_emu10k1_audigy_init_efx(struct snd_emu10k1 *emu) 1147 { 1148 int err, i, z, gpr, nctl; 1149 int bit_shifter16; 1150 const int playback = 10; 1151 const int capture = playback + (SND_EMU10K1_PLAYBACK_CHANNELS * 2); /* we reserve 10 voices */ 1152 const int stereo_mix = capture + 2; 1153 const int tmp = 0x88; 1154 u32 ptr; 1155 struct snd_emu10k1_fx8010_code *icode = NULL; 1156 struct snd_emu10k1_fx8010_control_gpr *controls = NULL, *ctl; 1157 u32 *gpr_map; 1158 mm_segment_t seg; 1159 1160 if ((icode = kzalloc(sizeof(*icode), GFP_KERNEL)) == NULL || 1161 (icode->gpr_map = (u_int32_t __user *) 1162 kcalloc(512 + 256 + 256 + 2 * 1024, sizeof(u_int32_t), 1163 GFP_KERNEL)) == NULL || 1164 (controls = kcalloc(SND_EMU10K1_GPR_CONTROLS, 1165 sizeof(*controls), GFP_KERNEL)) == NULL) { 1166 err = -ENOMEM; 1167 goto __err; 1168 } 1169 gpr_map = (u32 __force *)icode->gpr_map; 1170 1171 icode->tram_data_map = icode->gpr_map + 512; 1172 icode->tram_addr_map = icode->tram_data_map + 256; 1173 icode->code = icode->tram_addr_map + 256; 1174 1175 /* clear free GPRs */ 1176 for (i = 0; i < 512; i++) 1177 set_bit(i, icode->gpr_valid); 1178 1179 /* clear TRAM data & address lines */ 1180 for (i = 0; i < 256; i++) 1181 set_bit(i, icode->tram_valid); 1182 1183 strcpy(icode->name, "Audigy DSP code for ALSA"); 1184 ptr = 0; 1185 nctl = 0; 1186 gpr = stereo_mix + 10; 1187 gpr_map[gpr++] = 0x00007fff; 1188 gpr_map[gpr++] = 0x00008000; 1189 gpr_map[gpr++] = 0x0000ffff; 1190 bit_shifter16 = gpr; 1191 1192 /* stop FX processor */ 1193 snd_emu10k1_ptr_write(emu, A_DBG, 0, (emu->fx8010.dbg = 0) | A_DBG_SINGLE_STEP); 1194 1195 #if 1 1196 /* PCM front Playback Volume (independent from stereo mix) */ 1197 A_OP(icode, &ptr, iMAC0, A_GPR(playback), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_LEFT_FRONT)); 1198 A_OP(icode, &ptr, iMAC0, A_GPR(playback+1), A_C_00000000, A_GPR(gpr+1), A_FXBUS(FXBUS_PCM_RIGHT_FRONT)); 1199 snd_emu10k1_init_stereo_control(&controls[nctl++], "PCM Front Playback Volume", gpr, 100); 1200 gpr += 2; 1201 1202 /* PCM Surround Playback (independent from stereo mix) */ 1203 A_OP(icode, &ptr, iMAC0, A_GPR(playback+2), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_LEFT_REAR)); 1204 A_OP(icode, &ptr, iMAC0, A_GPR(playback+3), A_C_00000000, A_GPR(gpr+1), A_FXBUS(FXBUS_PCM_RIGHT_REAR)); 1205 snd_emu10k1_init_stereo_control(&controls[nctl++], "PCM Surround Playback Volume", gpr, 100); 1206 gpr += 2; 1207 1208 /* PCM Side Playback (independent from stereo mix) */ 1209 if (emu->card_capabilities->spk71) { 1210 A_OP(icode, &ptr, iMAC0, A_GPR(playback+6), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_LEFT_SIDE)); 1211 A_OP(icode, &ptr, iMAC0, A_GPR(playback+7), A_C_00000000, A_GPR(gpr+1), A_FXBUS(FXBUS_PCM_RIGHT_SIDE)); 1212 snd_emu10k1_init_stereo_control(&controls[nctl++], "PCM Side Playback Volume", gpr, 100); 1213 gpr += 2; 1214 } 1215 1216 /* PCM Center Playback (independent from stereo mix) */ 1217 A_OP(icode, &ptr, iMAC0, A_GPR(playback+4), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_CENTER)); 1218 snd_emu10k1_init_mono_control(&controls[nctl++], "PCM Center Playback Volume", gpr, 100); 1219 gpr++; 1220 1221 /* PCM LFE Playback (independent from stereo mix) */ 1222 A_OP(icode, &ptr, iMAC0, A_GPR(playback+5), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_LFE)); 1223 snd_emu10k1_init_mono_control(&controls[nctl++], "PCM LFE Playback Volume", gpr, 100); 1224 gpr++; 1225 1226 /* 1227 * Stereo Mix 1228 */ 1229 /* Wave (PCM) Playback Volume (will be renamed later) */ 1230 A_OP(icode, &ptr, iMAC0, A_GPR(stereo_mix), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_LEFT)); 1231 A_OP(icode, &ptr, iMAC0, A_GPR(stereo_mix+1), A_C_00000000, A_GPR(gpr+1), A_FXBUS(FXBUS_PCM_RIGHT)); 1232 snd_emu10k1_init_stereo_control(&controls[nctl++], "Wave Playback Volume", gpr, 100); 1233 gpr += 2; 1234 1235 /* Synth Playback */ 1236 A_OP(icode, &ptr, iMAC0, A_GPR(stereo_mix+0), A_GPR(stereo_mix+0), A_GPR(gpr), A_FXBUS(FXBUS_MIDI_LEFT)); 1237 A_OP(icode, &ptr, iMAC0, A_GPR(stereo_mix+1), A_GPR(stereo_mix+1), A_GPR(gpr+1), A_FXBUS(FXBUS_MIDI_RIGHT)); 1238 snd_emu10k1_init_stereo_control(&controls[nctl++], "Synth Playback Volume", gpr, 100); 1239 gpr += 2; 1240 1241 /* Wave (PCM) Capture */ 1242 A_OP(icode, &ptr, iMAC0, A_GPR(capture+0), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_LEFT)); 1243 A_OP(icode, &ptr, iMAC0, A_GPR(capture+1), A_C_00000000, A_GPR(gpr+1), A_FXBUS(FXBUS_PCM_RIGHT)); 1244 snd_emu10k1_init_stereo_control(&controls[nctl++], "PCM Capture Volume", gpr, 0); 1245 gpr += 2; 1246 1247 /* Synth Capture */ 1248 A_OP(icode, &ptr, iMAC0, A_GPR(capture+0), A_GPR(capture+0), A_GPR(gpr), A_FXBUS(FXBUS_MIDI_LEFT)); 1249 A_OP(icode, &ptr, iMAC0, A_GPR(capture+1), A_GPR(capture+1), A_GPR(gpr+1), A_FXBUS(FXBUS_MIDI_RIGHT)); 1250 snd_emu10k1_init_stereo_control(&controls[nctl++], "Synth Capture Volume", gpr, 0); 1251 gpr += 2; 1252 1253 /* 1254 * inputs 1255 */ 1256 #define A_ADD_VOLUME_IN(var,vol,input) \ 1257 A_OP(icode, &ptr, iMAC0, A_GPR(var), A_GPR(var), A_GPR(vol), A_EXTIN(input)) 1258 1259 /* emu1212 DSP 0 and DSP 1 Capture */ 1260 if (emu->card_capabilities->emu1010) { 1261 A_OP(icode, &ptr, iMAC0, A_GPR(capture+0), A_GPR(capture+0), A_GPR(gpr), A_P16VIN(0x0)); 1262 A_OP(icode, &ptr, iMAC0, A_GPR(capture+1), A_GPR(capture+1), A_GPR(gpr+1), A_P16VIN(0x1)); 1263 snd_emu10k1_init_stereo_control(&controls[nctl++], "EMU Capture Volume", gpr, 0); 1264 gpr += 2; 1265 } 1266 /* AC'97 Playback Volume - used only for mic (renamed later) */ 1267 A_ADD_VOLUME_IN(stereo_mix, gpr, A_EXTIN_AC97_L); 1268 A_ADD_VOLUME_IN(stereo_mix+1, gpr+1, A_EXTIN_AC97_R); 1269 snd_emu10k1_init_stereo_control(&controls[nctl++], "AMic Playback Volume", gpr, 0); 1270 gpr += 2; 1271 /* AC'97 Capture Volume - used only for mic */ 1272 A_ADD_VOLUME_IN(capture, gpr, A_EXTIN_AC97_L); 1273 A_ADD_VOLUME_IN(capture+1, gpr+1, A_EXTIN_AC97_R); 1274 snd_emu10k1_init_stereo_control(&controls[nctl++], "Mic Capture Volume", gpr, 0); 1275 gpr += 2; 1276 1277 /* mic capture buffer */ 1278 A_OP(icode, &ptr, iINTERP, A_EXTOUT(A_EXTOUT_MIC_CAP), A_EXTIN(A_EXTIN_AC97_L), 0xcd, A_EXTIN(A_EXTIN_AC97_R)); 1279 1280 /* Audigy CD Playback Volume */ 1281 A_ADD_VOLUME_IN(stereo_mix, gpr, A_EXTIN_SPDIF_CD_L); 1282 A_ADD_VOLUME_IN(stereo_mix+1, gpr+1, A_EXTIN_SPDIF_CD_R); 1283 snd_emu10k1_init_stereo_control(&controls[nctl++], 1284 emu->card_capabilities->ac97_chip ? "Audigy CD Playback Volume" : "CD Playback Volume", 1285 gpr, 0); 1286 gpr += 2; 1287 /* Audigy CD Capture Volume */ 1288 A_ADD_VOLUME_IN(capture, gpr, A_EXTIN_SPDIF_CD_L); 1289 A_ADD_VOLUME_IN(capture+1, gpr+1, A_EXTIN_SPDIF_CD_R); 1290 snd_emu10k1_init_stereo_control(&controls[nctl++], 1291 emu->card_capabilities->ac97_chip ? "Audigy CD Capture Volume" : "CD Capture Volume", 1292 gpr, 0); 1293 gpr += 2; 1294 1295 /* Optical SPDIF Playback Volume */ 1296 A_ADD_VOLUME_IN(stereo_mix, gpr, A_EXTIN_OPT_SPDIF_L); 1297 A_ADD_VOLUME_IN(stereo_mix+1, gpr+1, A_EXTIN_OPT_SPDIF_R); 1298 snd_emu10k1_init_stereo_control(&controls[nctl++], SNDRV_CTL_NAME_IEC958("Optical ",PLAYBACK,VOLUME), gpr, 0); 1299 gpr += 2; 1300 /* Optical SPDIF Capture Volume */ 1301 A_ADD_VOLUME_IN(capture, gpr, A_EXTIN_OPT_SPDIF_L); 1302 A_ADD_VOLUME_IN(capture+1, gpr+1, A_EXTIN_OPT_SPDIF_R); 1303 snd_emu10k1_init_stereo_control(&controls[nctl++], SNDRV_CTL_NAME_IEC958("Optical ",CAPTURE,VOLUME), gpr, 0); 1304 gpr += 2; 1305 1306 /* Line2 Playback Volume */ 1307 A_ADD_VOLUME_IN(stereo_mix, gpr, A_EXTIN_LINE2_L); 1308 A_ADD_VOLUME_IN(stereo_mix+1, gpr+1, A_EXTIN_LINE2_R); 1309 snd_emu10k1_init_stereo_control(&controls[nctl++], 1310 emu->card_capabilities->ac97_chip ? "Line2 Playback Volume" : "Line Playback Volume", 1311 gpr, 0); 1312 gpr += 2; 1313 /* Line2 Capture Volume */ 1314 A_ADD_VOLUME_IN(capture, gpr, A_EXTIN_LINE2_L); 1315 A_ADD_VOLUME_IN(capture+1, gpr+1, A_EXTIN_LINE2_R); 1316 snd_emu10k1_init_stereo_control(&controls[nctl++], 1317 emu->card_capabilities->ac97_chip ? "Line2 Capture Volume" : "Line Capture Volume", 1318 gpr, 0); 1319 gpr += 2; 1320 1321 /* Philips ADC Playback Volume */ 1322 A_ADD_VOLUME_IN(stereo_mix, gpr, A_EXTIN_ADC_L); 1323 A_ADD_VOLUME_IN(stereo_mix+1, gpr+1, A_EXTIN_ADC_R); 1324 snd_emu10k1_init_stereo_control(&controls[nctl++], "Analog Mix Playback Volume", gpr, 0); 1325 gpr += 2; 1326 /* Philips ADC Capture Volume */ 1327 A_ADD_VOLUME_IN(capture, gpr, A_EXTIN_ADC_L); 1328 A_ADD_VOLUME_IN(capture+1, gpr+1, A_EXTIN_ADC_R); 1329 snd_emu10k1_init_stereo_control(&controls[nctl++], "Analog Mix Capture Volume", gpr, 0); 1330 gpr += 2; 1331 1332 /* Aux2 Playback Volume */ 1333 A_ADD_VOLUME_IN(stereo_mix, gpr, A_EXTIN_AUX2_L); 1334 A_ADD_VOLUME_IN(stereo_mix+1, gpr+1, A_EXTIN_AUX2_R); 1335 snd_emu10k1_init_stereo_control(&controls[nctl++], 1336 emu->card_capabilities->ac97_chip ? "Aux2 Playback Volume" : "Aux Playback Volume", 1337 gpr, 0); 1338 gpr += 2; 1339 /* Aux2 Capture Volume */ 1340 A_ADD_VOLUME_IN(capture, gpr, A_EXTIN_AUX2_L); 1341 A_ADD_VOLUME_IN(capture+1, gpr+1, A_EXTIN_AUX2_R); 1342 snd_emu10k1_init_stereo_control(&controls[nctl++], 1343 emu->card_capabilities->ac97_chip ? "Aux2 Capture Volume" : "Aux Capture Volume", 1344 gpr, 0); 1345 gpr += 2; 1346 1347 /* Stereo Mix Front Playback Volume */ 1348 A_OP(icode, &ptr, iMAC0, A_GPR(playback), A_GPR(playback), A_GPR(gpr), A_GPR(stereo_mix)); 1349 A_OP(icode, &ptr, iMAC0, A_GPR(playback+1), A_GPR(playback+1), A_GPR(gpr+1), A_GPR(stereo_mix+1)); 1350 snd_emu10k1_init_stereo_control(&controls[nctl++], "Front Playback Volume", gpr, 100); 1351 gpr += 2; 1352 1353 /* Stereo Mix Surround Playback */ 1354 A_OP(icode, &ptr, iMAC0, A_GPR(playback+2), A_GPR(playback+2), A_GPR(gpr), A_GPR(stereo_mix)); 1355 A_OP(icode, &ptr, iMAC0, A_GPR(playback+3), A_GPR(playback+3), A_GPR(gpr+1), A_GPR(stereo_mix+1)); 1356 snd_emu10k1_init_stereo_control(&controls[nctl++], "Surround Playback Volume", gpr, 0); 1357 gpr += 2; 1358 1359 /* Stereo Mix Center Playback */ 1360 /* Center = sub = Left/2 + Right/2 */ 1361 A_OP(icode, &ptr, iINTERP, A_GPR(tmp), A_GPR(stereo_mix), 0xcd, A_GPR(stereo_mix+1)); 1362 A_OP(icode, &ptr, iMAC0, A_GPR(playback+4), A_GPR(playback+4), A_GPR(gpr), A_GPR(tmp)); 1363 snd_emu10k1_init_mono_control(&controls[nctl++], "Center Playback Volume", gpr, 0); 1364 gpr++; 1365 1366 /* Stereo Mix LFE Playback */ 1367 A_OP(icode, &ptr, iMAC0, A_GPR(playback+5), A_GPR(playback+5), A_GPR(gpr), A_GPR(tmp)); 1368 snd_emu10k1_init_mono_control(&controls[nctl++], "LFE Playback Volume", gpr, 0); 1369 gpr++; 1370 1371 if (emu->card_capabilities->spk71) { 1372 /* Stereo Mix Side Playback */ 1373 A_OP(icode, &ptr, iMAC0, A_GPR(playback+6), A_GPR(playback+6), A_GPR(gpr), A_GPR(stereo_mix)); 1374 A_OP(icode, &ptr, iMAC0, A_GPR(playback+7), A_GPR(playback+7), A_GPR(gpr+1), A_GPR(stereo_mix+1)); 1375 snd_emu10k1_init_stereo_control(&controls[nctl++], "Side Playback Volume", gpr, 0); 1376 gpr += 2; 1377 } 1378 1379 /* 1380 * outputs 1381 */ 1382 #define A_PUT_OUTPUT(out,src) A_OP(icode, &ptr, iACC3, A_EXTOUT(out), A_C_00000000, A_C_00000000, A_GPR(src)) 1383 #define A_PUT_STEREO_OUTPUT(out1,out2,src) \ 1384 {A_PUT_OUTPUT(out1,src); A_PUT_OUTPUT(out2,src+1);} 1385 1386 #define _A_SWITCH(icode, ptr, dst, src, sw) \ 1387 A_OP((icode), ptr, iMACINT0, dst, A_C_00000000, src, sw); 1388 #define A_SWITCH(icode, ptr, dst, src, sw) \ 1389 _A_SWITCH(icode, ptr, A_GPR(dst), A_GPR(src), A_GPR(sw)) 1390 #define _A_SWITCH_NEG(icode, ptr, dst, src) \ 1391 A_OP((icode), ptr, iANDXOR, dst, src, A_C_00000001, A_C_00000001); 1392 #define A_SWITCH_NEG(icode, ptr, dst, src) \ 1393 _A_SWITCH_NEG(icode, ptr, A_GPR(dst), A_GPR(src)) 1394 1395 1396 /* 1397 * Process tone control 1398 */ 1399 A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 0), A_GPR(playback + 0), A_C_00000000, A_C_00000000); /* left */ 1400 A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 1), A_GPR(playback + 1), A_C_00000000, A_C_00000000); /* right */ 1401 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 */ 1402 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 */ 1403 A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 4), A_GPR(playback + 4), A_C_00000000, A_C_00000000); /* center */ 1404 A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 5), A_GPR(playback + 5), A_C_00000000, A_C_00000000); /* LFE */ 1405 if (emu->card_capabilities->spk71) { 1406 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 */ 1407 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 */ 1408 } 1409 1410 1411 ctl = &controls[nctl + 0]; 1412 ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 1413 strcpy(ctl->id.name, "Tone Control - Bass"); 1414 ctl->vcount = 2; 1415 ctl->count = 10; 1416 ctl->min = 0; 1417 ctl->max = 40; 1418 ctl->value[0] = ctl->value[1] = 20; 1419 ctl->translation = EMU10K1_GPR_TRANSLATION_BASS; 1420 ctl = &controls[nctl + 1]; 1421 ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 1422 strcpy(ctl->id.name, "Tone Control - Treble"); 1423 ctl->vcount = 2; 1424 ctl->count = 10; 1425 ctl->min = 0; 1426 ctl->max = 40; 1427 ctl->value[0] = ctl->value[1] = 20; 1428 ctl->translation = EMU10K1_GPR_TRANSLATION_TREBLE; 1429 1430 #define BASS_GPR 0x8c 1431 #define TREBLE_GPR 0x96 1432 1433 for (z = 0; z < 5; z++) { 1434 int j; 1435 for (j = 0; j < 2; j++) { 1436 controls[nctl + 0].gpr[z * 2 + j] = BASS_GPR + z * 2 + j; 1437 controls[nctl + 1].gpr[z * 2 + j] = TREBLE_GPR + z * 2 + j; 1438 } 1439 } 1440 for (z = 0; z < 4; z++) { /* front/rear/center-lfe/side */ 1441 int j, k, l, d; 1442 for (j = 0; j < 2; j++) { /* left/right */ 1443 k = 0xb0 + (z * 8) + (j * 4); 1444 l = 0xe0 + (z * 8) + (j * 4); 1445 d = playback + SND_EMU10K1_PLAYBACK_CHANNELS + z * 2 + j; 1446 1447 A_OP(icode, &ptr, iMAC0, A_C_00000000, A_C_00000000, A_GPR(d), A_GPR(BASS_GPR + 0 + j)); 1448 A_OP(icode, &ptr, iMACMV, A_GPR(k+1), A_GPR(k), A_GPR(k+1), A_GPR(BASS_GPR + 4 + j)); 1449 A_OP(icode, &ptr, iMACMV, A_GPR(k), A_GPR(d), A_GPR(k), A_GPR(BASS_GPR + 2 + j)); 1450 A_OP(icode, &ptr, iMACMV, A_GPR(k+3), A_GPR(k+2), A_GPR(k+3), A_GPR(BASS_GPR + 8 + j)); 1451 A_OP(icode, &ptr, iMAC0, A_GPR(k+2), A_GPR_ACCU, A_GPR(k+2), A_GPR(BASS_GPR + 6 + j)); 1452 A_OP(icode, &ptr, iACC3, A_GPR(k+2), A_GPR(k+2), A_GPR(k+2), A_C_00000000); 1453 1454 A_OP(icode, &ptr, iMAC0, A_C_00000000, A_C_00000000, A_GPR(k+2), A_GPR(TREBLE_GPR + 0 + j)); 1455 A_OP(icode, &ptr, iMACMV, A_GPR(l+1), A_GPR(l), A_GPR(l+1), A_GPR(TREBLE_GPR + 4 + j)); 1456 A_OP(icode, &ptr, iMACMV, A_GPR(l), A_GPR(k+2), A_GPR(l), A_GPR(TREBLE_GPR + 2 + j)); 1457 A_OP(icode, &ptr, iMACMV, A_GPR(l+3), A_GPR(l+2), A_GPR(l+3), A_GPR(TREBLE_GPR + 8 + j)); 1458 A_OP(icode, &ptr, iMAC0, A_GPR(l+2), A_GPR_ACCU, A_GPR(l+2), A_GPR(TREBLE_GPR + 6 + j)); 1459 A_OP(icode, &ptr, iMACINT0, A_GPR(l+2), A_C_00000000, A_GPR(l+2), A_C_00000010); 1460 1461 A_OP(icode, &ptr, iACC3, A_GPR(d), A_GPR(l+2), A_C_00000000, A_C_00000000); 1462 1463 if (z == 2) /* center */ 1464 break; 1465 } 1466 } 1467 nctl += 2; 1468 1469 #undef BASS_GPR 1470 #undef TREBLE_GPR 1471 1472 for (z = 0; z < 8; z++) { 1473 A_SWITCH(icode, &ptr, tmp + 0, playback + SND_EMU10K1_PLAYBACK_CHANNELS + z, gpr + 0); 1474 A_SWITCH_NEG(icode, &ptr, tmp + 1, gpr + 0); 1475 A_SWITCH(icode, &ptr, tmp + 1, playback + z, tmp + 1); 1476 A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + z), A_GPR(tmp + 0), A_GPR(tmp + 1), A_C_00000000); 1477 } 1478 snd_emu10k1_init_stereo_onoff_control(controls + nctl++, "Tone Control - Switch", gpr, 0); 1479 gpr += 2; 1480 1481 /* Master volume (will be renamed later) */ 1482 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)); 1483 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)); 1484 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)); 1485 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)); 1486 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)); 1487 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)); 1488 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)); 1489 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)); 1490 snd_emu10k1_init_mono_control(&controls[nctl++], "Wave Master Playback Volume", gpr, 0); 1491 gpr += 2; 1492 1493 /* analog speakers */ 1494 A_PUT_STEREO_OUTPUT(A_EXTOUT_AFRONT_L, A_EXTOUT_AFRONT_R, playback + SND_EMU10K1_PLAYBACK_CHANNELS); 1495 A_PUT_STEREO_OUTPUT(A_EXTOUT_AREAR_L, A_EXTOUT_AREAR_R, playback+2 + SND_EMU10K1_PLAYBACK_CHANNELS); 1496 A_PUT_OUTPUT(A_EXTOUT_ACENTER, playback+4 + SND_EMU10K1_PLAYBACK_CHANNELS); 1497 A_PUT_OUTPUT(A_EXTOUT_ALFE, playback+5 + SND_EMU10K1_PLAYBACK_CHANNELS); 1498 if (emu->card_capabilities->spk71) 1499 A_PUT_STEREO_OUTPUT(A_EXTOUT_ASIDE_L, A_EXTOUT_ASIDE_R, playback+6 + SND_EMU10K1_PLAYBACK_CHANNELS); 1500 1501 /* headphone */ 1502 A_PUT_STEREO_OUTPUT(A_EXTOUT_HEADPHONE_L, A_EXTOUT_HEADPHONE_R, playback + SND_EMU10K1_PLAYBACK_CHANNELS); 1503 1504 /* digital outputs */ 1505 /* A_PUT_STEREO_OUTPUT(A_EXTOUT_FRONT_L, A_EXTOUT_FRONT_R, playback + SND_EMU10K1_PLAYBACK_CHANNELS); */ 1506 if (emu->card_capabilities->emu1010) { 1507 /* EMU1010 Outputs from PCM Front, Rear, Center, LFE, Side */ 1508 snd_printk("EMU outputs on\n"); 1509 for (z = 0; z < 8; z++) { 1510 A_OP(icode, &ptr, iACC3, A_EMU32OUTL(z), A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + z), A_C_00000000, A_C_00000000); 1511 } 1512 } 1513 1514 /* IEC958 Optical Raw Playback Switch */ 1515 gpr_map[gpr++] = 0; 1516 gpr_map[gpr++] = 0x1008; 1517 gpr_map[gpr++] = 0xffff0000; 1518 for (z = 0; z < 2; z++) { 1519 A_OP(icode, &ptr, iMAC0, A_GPR(tmp + 2), A_FXBUS(FXBUS_PT_LEFT + z), A_C_00000000, A_C_00000000); 1520 A_OP(icode, &ptr, iSKIP, A_GPR_COND, A_GPR_COND, A_GPR(gpr - 2), A_C_00000001); 1521 A_OP(icode, &ptr, iACC3, A_GPR(tmp + 2), A_C_00000000, A_C_00010000, A_GPR(tmp + 2)); 1522 A_OP(icode, &ptr, iANDXOR, A_GPR(tmp + 2), A_GPR(tmp + 2), A_GPR(gpr - 1), A_C_00000000); 1523 A_SWITCH(icode, &ptr, tmp + 0, tmp + 2, gpr + z); 1524 A_SWITCH_NEG(icode, &ptr, tmp + 1, gpr + z); 1525 A_SWITCH(icode, &ptr, tmp + 1, playback + SND_EMU10K1_PLAYBACK_CHANNELS + z, tmp + 1); 1526 if ((z==1) && (emu->card_capabilities->spdif_bug)) { 1527 /* Due to a SPDIF output bug on some Audigy cards, this code delays the Right channel by 1 sample */ 1528 snd_printk(KERN_INFO "Installing spdif_bug patch: %s\n", emu->card_capabilities->name); 1529 A_OP(icode, &ptr, iACC3, A_EXTOUT(A_EXTOUT_FRONT_L + z), A_GPR(gpr - 3), A_C_00000000, A_C_00000000); 1530 A_OP(icode, &ptr, iACC3, A_GPR(gpr - 3), A_GPR(tmp + 0), A_GPR(tmp + 1), A_C_00000000); 1531 } else { 1532 A_OP(icode, &ptr, iACC3, A_EXTOUT(A_EXTOUT_FRONT_L + z), A_GPR(tmp + 0), A_GPR(tmp + 1), A_C_00000000); 1533 } 1534 } 1535 snd_emu10k1_init_stereo_onoff_control(controls + nctl++, SNDRV_CTL_NAME_IEC958("Optical Raw ",PLAYBACK,SWITCH), gpr, 0); 1536 gpr += 2; 1537 1538 A_PUT_STEREO_OUTPUT(A_EXTOUT_REAR_L, A_EXTOUT_REAR_R, playback+2 + SND_EMU10K1_PLAYBACK_CHANNELS); 1539 A_PUT_OUTPUT(A_EXTOUT_CENTER, playback+4 + SND_EMU10K1_PLAYBACK_CHANNELS); 1540 A_PUT_OUTPUT(A_EXTOUT_LFE, playback+5 + SND_EMU10K1_PLAYBACK_CHANNELS); 1541 1542 /* ADC buffer */ 1543 #ifdef EMU10K1_CAPTURE_DIGITAL_OUT 1544 A_PUT_STEREO_OUTPUT(A_EXTOUT_ADC_CAP_L, A_EXTOUT_ADC_CAP_R, playback + SND_EMU10K1_PLAYBACK_CHANNELS); 1545 #else 1546 A_PUT_OUTPUT(A_EXTOUT_ADC_CAP_L, capture); 1547 A_PUT_OUTPUT(A_EXTOUT_ADC_CAP_R, capture+1); 1548 #endif 1549 1550 if (emu->card_capabilities->emu1010) { 1551 snd_printk("EMU inputs on\n"); 1552 /* Capture 8 channels of S32_LE sound */ 1553 1554 /* printk("emufx.c: gpr=0x%x, tmp=0x%x\n",gpr, tmp); */ 1555 /* For the EMU1010: How to get 32bit values from the DSP. High 16bits into L, low 16bits into R. */ 1556 /* A_P16VIN(0) is delayed by one sample, 1557 * so all other A_P16VIN channels will need to also be delayed 1558 */ 1559 /* Left ADC in. 1 of 2 */ 1560 snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_P16VIN(0x0), A_FXBUS2(0) ); 1561 /* Right ADC in 1 of 2 */ 1562 gpr_map[gpr++] = 0x00000000; 1563 snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(2) ); 1564 A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x1), A_C_00000000, A_C_00000000); 1565 gpr_map[gpr++] = 0x00000000; 1566 snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(4) ); 1567 A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x2), A_C_00000000, A_C_00000000); 1568 gpr_map[gpr++] = 0x00000000; 1569 snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(6) ); 1570 A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x3), A_C_00000000, A_C_00000000); 1571 /* For 96kHz mode */ 1572 /* Left ADC in. 2 of 2 */ 1573 gpr_map[gpr++] = 0x00000000; 1574 snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(0x8) ); 1575 A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x4), A_C_00000000, A_C_00000000); 1576 /* Right ADC in 2 of 2 */ 1577 gpr_map[gpr++] = 0x00000000; 1578 snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(0xa) ); 1579 A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x5), A_C_00000000, A_C_00000000); 1580 gpr_map[gpr++] = 0x00000000; 1581 snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(0xc) ); 1582 A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x6), A_C_00000000, A_C_00000000); 1583 gpr_map[gpr++] = 0x00000000; 1584 snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(0xe) ); 1585 A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x7), A_C_00000000, A_C_00000000); 1586 1587 #if 0 1588 for (z = 4; z < 8; z++) { 1589 A_OP(icode, &ptr, iACC3, A_FXBUS2(z), A_C_00000000, A_C_00000000, A_C_00000000); 1590 } 1591 for (z = 0xc; z < 0x10; z++) { 1592 A_OP(icode, &ptr, iACC3, A_FXBUS2(z), A_C_00000000, A_C_00000000, A_C_00000000); 1593 } 1594 #endif 1595 } else { 1596 /* EFX capture - capture the 16 EXTINs */ 1597 /* Capture 16 channels of S16_LE sound */ 1598 for (z = 0; z < 16; z++) { 1599 A_OP(icode, &ptr, iACC3, A_FXBUS2(z), A_C_00000000, A_C_00000000, A_EXTIN(z)); 1600 } 1601 } 1602 1603 #endif /* JCD test */ 1604 /* 1605 * ok, set up done.. 1606 */ 1607 1608 if (gpr > tmp) { 1609 snd_BUG(); 1610 err = -EIO; 1611 goto __err; 1612 } 1613 /* clear remaining instruction memory */ 1614 while (ptr < 0x400) 1615 A_OP(icode, &ptr, 0x0f, 0xc0, 0xc0, 0xcf, 0xc0); 1616 1617 seg = snd_enter_user(); 1618 icode->gpr_add_control_count = nctl; 1619 icode->gpr_add_controls = (struct snd_emu10k1_fx8010_control_gpr __user *)controls; 1620 emu->support_tlv = 1; /* support TLV */ 1621 err = snd_emu10k1_icode_poke(emu, icode); 1622 emu->support_tlv = 0; /* clear again */ 1623 snd_leave_user(seg); 1624 1625 __err: 1626 kfree(controls); 1627 if (icode != NULL) { 1628 kfree((void __force *)icode->gpr_map); 1629 kfree(icode); 1630 } 1631 return err; 1632 } 1633 1634 1635 /* 1636 * initial DSP configuration for Emu10k1 1637 */ 1638 1639 /* when volume = max, then copy only to avoid volume modification */ 1640 /* with iMAC0 (negative values) */ 1641 static void __devinit _volume(struct snd_emu10k1_fx8010_code *icode, u32 *ptr, u32 dst, u32 src, u32 vol) 1642 { 1643 OP(icode, ptr, iMAC0, dst, C_00000000, src, vol); 1644 OP(icode, ptr, iANDXOR, C_00000000, vol, C_ffffffff, C_7fffffff); 1645 OP(icode, ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, C_00000001); 1646 OP(icode, ptr, iACC3, dst, src, C_00000000, C_00000000); 1647 } 1648 static void __devinit _volume_add(struct snd_emu10k1_fx8010_code *icode, u32 *ptr, u32 dst, u32 src, u32 vol) 1649 { 1650 OP(icode, ptr, iANDXOR, C_00000000, vol, C_ffffffff, C_7fffffff); 1651 OP(icode, ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, C_00000002); 1652 OP(icode, ptr, iMACINT0, dst, dst, src, C_00000001); 1653 OP(icode, ptr, iSKIP, C_00000000, C_7fffffff, C_7fffffff, C_00000001); 1654 OP(icode, ptr, iMAC0, dst, dst, src, vol); 1655 } 1656 static void __devinit _volume_out(struct snd_emu10k1_fx8010_code *icode, u32 *ptr, u32 dst, u32 src, u32 vol) 1657 { 1658 OP(icode, ptr, iANDXOR, C_00000000, vol, C_ffffffff, C_7fffffff); 1659 OP(icode, ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, C_00000002); 1660 OP(icode, ptr, iACC3, dst, src, C_00000000, C_00000000); 1661 OP(icode, ptr, iSKIP, C_00000000, C_7fffffff, C_7fffffff, C_00000001); 1662 OP(icode, ptr, iMAC0, dst, C_00000000, src, vol); 1663 } 1664 1665 #define VOLUME(icode, ptr, dst, src, vol) \ 1666 _volume(icode, ptr, GPR(dst), GPR(src), GPR(vol)) 1667 #define VOLUME_IN(icode, ptr, dst, src, vol) \ 1668 _volume(icode, ptr, GPR(dst), EXTIN(src), GPR(vol)) 1669 #define VOLUME_ADD(icode, ptr, dst, src, vol) \ 1670 _volume_add(icode, ptr, GPR(dst), GPR(src), GPR(vol)) 1671 #define VOLUME_ADDIN(icode, ptr, dst, src, vol) \ 1672 _volume_add(icode, ptr, GPR(dst), EXTIN(src), GPR(vol)) 1673 #define VOLUME_OUT(icode, ptr, dst, src, vol) \ 1674 _volume_out(icode, ptr, EXTOUT(dst), GPR(src), GPR(vol)) 1675 #define _SWITCH(icode, ptr, dst, src, sw) \ 1676 OP((icode), ptr, iMACINT0, dst, C_00000000, src, sw); 1677 #define SWITCH(icode, ptr, dst, src, sw) \ 1678 _SWITCH(icode, ptr, GPR(dst), GPR(src), GPR(sw)) 1679 #define SWITCH_IN(icode, ptr, dst, src, sw) \ 1680 _SWITCH(icode, ptr, GPR(dst), EXTIN(src), GPR(sw)) 1681 #define _SWITCH_NEG(icode, ptr, dst, src) \ 1682 OP((icode), ptr, iANDXOR, dst, src, C_00000001, C_00000001); 1683 #define SWITCH_NEG(icode, ptr, dst, src) \ 1684 _SWITCH_NEG(icode, ptr, GPR(dst), GPR(src)) 1685 1686 1687 static int __devinit _snd_emu10k1_init_efx(struct snd_emu10k1 *emu) 1688 { 1689 int err, i, z, gpr, tmp, playback, capture; 1690 u32 ptr; 1691 struct snd_emu10k1_fx8010_code *icode; 1692 struct snd_emu10k1_fx8010_pcm_rec *ipcm = NULL; 1693 struct snd_emu10k1_fx8010_control_gpr *controls = NULL, *ctl; 1694 u32 *gpr_map; 1695 mm_segment_t seg; 1696 1697 if ((icode = kzalloc(sizeof(*icode), GFP_KERNEL)) == NULL) 1698 return -ENOMEM; 1699 if ((icode->gpr_map = (u_int32_t __user *) 1700 kcalloc(256 + 160 + 160 + 2 * 512, sizeof(u_int32_t), 1701 GFP_KERNEL)) == NULL || 1702 (controls = kcalloc(SND_EMU10K1_GPR_CONTROLS, 1703 sizeof(struct snd_emu10k1_fx8010_control_gpr), 1704 GFP_KERNEL)) == NULL || 1705 (ipcm = kzalloc(sizeof(*ipcm), GFP_KERNEL)) == NULL) { 1706 err = -ENOMEM; 1707 goto __err; 1708 } 1709 gpr_map = (u32 __force *)icode->gpr_map; 1710 1711 icode->tram_data_map = icode->gpr_map + 256; 1712 icode->tram_addr_map = icode->tram_data_map + 160; 1713 icode->code = icode->tram_addr_map + 160; 1714 1715 /* clear free GPRs */ 1716 for (i = 0; i < 256; i++) 1717 set_bit(i, icode->gpr_valid); 1718 1719 /* clear TRAM data & address lines */ 1720 for (i = 0; i < 160; i++) 1721 set_bit(i, icode->tram_valid); 1722 1723 strcpy(icode->name, "SB Live! FX8010 code for ALSA v1.2 by Jaroslav Kysela"); 1724 ptr = 0; i = 0; 1725 /* we have 12 inputs */ 1726 playback = SND_EMU10K1_INPUTS; 1727 /* we have 6 playback channels and tone control doubles */ 1728 capture = playback + (SND_EMU10K1_PLAYBACK_CHANNELS * 2); 1729 gpr = capture + SND_EMU10K1_CAPTURE_CHANNELS; 1730 tmp = 0x88; /* we need 4 temporary GPR */ 1731 /* from 0x8c to 0xff is the area for tone control */ 1732 1733 /* stop FX processor */ 1734 snd_emu10k1_ptr_write(emu, DBG, 0, (emu->fx8010.dbg = 0) | EMU10K1_DBG_SINGLE_STEP); 1735 1736 /* 1737 * Process FX Buses 1738 */ 1739 OP(icode, &ptr, iMACINT0, GPR(0), C_00000000, FXBUS(FXBUS_PCM_LEFT), C_00000004); 1740 OP(icode, &ptr, iMACINT0, GPR(1), C_00000000, FXBUS(FXBUS_PCM_RIGHT), C_00000004); 1741 OP(icode, &ptr, iMACINT0, GPR(2), C_00000000, FXBUS(FXBUS_MIDI_LEFT), C_00000004); 1742 OP(icode, &ptr, iMACINT0, GPR(3), C_00000000, FXBUS(FXBUS_MIDI_RIGHT), C_00000004); 1743 OP(icode, &ptr, iMACINT0, GPR(4), C_00000000, FXBUS(FXBUS_PCM_LEFT_REAR), C_00000004); 1744 OP(icode, &ptr, iMACINT0, GPR(5), C_00000000, FXBUS(FXBUS_PCM_RIGHT_REAR), C_00000004); 1745 OP(icode, &ptr, iMACINT0, GPR(6), C_00000000, FXBUS(FXBUS_PCM_CENTER), C_00000004); 1746 OP(icode, &ptr, iMACINT0, GPR(7), C_00000000, FXBUS(FXBUS_PCM_LFE), C_00000004); 1747 OP(icode, &ptr, iMACINT0, GPR(8), C_00000000, C_00000000, C_00000000); /* S/PDIF left */ 1748 OP(icode, &ptr, iMACINT0, GPR(9), C_00000000, C_00000000, C_00000000); /* S/PDIF right */ 1749 OP(icode, &ptr, iMACINT0, GPR(10), C_00000000, FXBUS(FXBUS_PCM_LEFT_FRONT), C_00000004); 1750 OP(icode, &ptr, iMACINT0, GPR(11), C_00000000, FXBUS(FXBUS_PCM_RIGHT_FRONT), C_00000004); 1751 1752 /* Raw S/PDIF PCM */ 1753 ipcm->substream = 0; 1754 ipcm->channels = 2; 1755 ipcm->tram_start = 0; 1756 ipcm->buffer_size = (64 * 1024) / 2; 1757 ipcm->gpr_size = gpr++; 1758 ipcm->gpr_ptr = gpr++; 1759 ipcm->gpr_count = gpr++; 1760 ipcm->gpr_tmpcount = gpr++; 1761 ipcm->gpr_trigger = gpr++; 1762 ipcm->gpr_running = gpr++; 1763 ipcm->etram[0] = 0; 1764 ipcm->etram[1] = 1; 1765 1766 gpr_map[gpr + 0] = 0xfffff000; 1767 gpr_map[gpr + 1] = 0xffff0000; 1768 gpr_map[gpr + 2] = 0x70000000; 1769 gpr_map[gpr + 3] = 0x00000007; 1770 gpr_map[gpr + 4] = 0x001f << 11; 1771 gpr_map[gpr + 5] = 0x001c << 11; 1772 gpr_map[gpr + 6] = (0x22 - 0x01) - 1; /* skip at 01 to 22 */ 1773 gpr_map[gpr + 7] = (0x22 - 0x06) - 1; /* skip at 06 to 22 */ 1774 gpr_map[gpr + 8] = 0x2000000 + (2<<11); 1775 gpr_map[gpr + 9] = 0x4000000 + (2<<11); 1776 gpr_map[gpr + 10] = 1<<11; 1777 gpr_map[gpr + 11] = (0x24 - 0x0a) - 1; /* skip at 0a to 24 */ 1778 gpr_map[gpr + 12] = 0; 1779 1780 /* if the trigger flag is not set, skip */ 1781 /* 00: */ OP(icode, &ptr, iMAC0, C_00000000, GPR(ipcm->gpr_trigger), C_00000000, C_00000000); 1782 /* 01: */ OP(icode, &ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_ZERO, GPR(gpr + 6)); 1783 /* if the running flag is set, we're running */ 1784 /* 02: */ OP(icode, &ptr, iMAC0, C_00000000, GPR(ipcm->gpr_running), C_00000000, C_00000000); 1785 /* 03: */ OP(icode, &ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, C_00000004); 1786 /* wait until ((GPR_DBAC>>11) & 0x1f) == 0x1c) */ 1787 /* 04: */ OP(icode, &ptr, iANDXOR, GPR(tmp + 0), GPR_DBAC, GPR(gpr + 4), C_00000000); 1788 /* 05: */ OP(icode, &ptr, iMACINT0, C_00000000, GPR(tmp + 0), C_ffffffff, GPR(gpr + 5)); 1789 /* 06: */ OP(icode, &ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, GPR(gpr + 7)); 1790 /* 07: */ OP(icode, &ptr, iACC3, GPR(gpr + 12), C_00000010, C_00000001, C_00000000); 1791 1792 /* 08: */ OP(icode, &ptr, iANDXOR, GPR(ipcm->gpr_running), GPR(ipcm->gpr_running), C_00000000, C_00000001); 1793 /* 09: */ OP(icode, &ptr, iACC3, GPR(gpr + 12), GPR(gpr + 12), C_ffffffff, C_00000000); 1794 /* 0a: */ OP(icode, &ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, GPR(gpr + 11)); 1795 /* 0b: */ OP(icode, &ptr, iACC3, GPR(gpr + 12), C_00000001, C_00000000, C_00000000); 1796 1797 /* 0c: */ OP(icode, &ptr, iANDXOR, GPR(tmp + 0), ETRAM_DATA(ipcm->etram[0]), GPR(gpr + 0), C_00000000); 1798 /* 0d: */ OP(icode, &ptr, iLOG, GPR(tmp + 0), GPR(tmp + 0), GPR(gpr + 3), C_00000000); 1799 /* 0e: */ OP(icode, &ptr, iANDXOR, GPR(8), GPR(tmp + 0), GPR(gpr + 1), GPR(gpr + 2)); 1800 /* 0f: */ OP(icode, &ptr, iSKIP, C_00000000, GPR_COND, CC_REG_MINUS, C_00000001); 1801 /* 10: */ OP(icode, &ptr, iANDXOR, GPR(8), GPR(8), GPR(gpr + 1), GPR(gpr + 2)); 1802 1803 /* 11: */ OP(icode, &ptr, iANDXOR, GPR(tmp + 0), ETRAM_DATA(ipcm->etram[1]), GPR(gpr + 0), C_00000000); 1804 /* 12: */ OP(icode, &ptr, iLOG, GPR(tmp + 0), GPR(tmp + 0), GPR(gpr + 3), C_00000000); 1805 /* 13: */ OP(icode, &ptr, iANDXOR, GPR(9), GPR(tmp + 0), GPR(gpr + 1), GPR(gpr + 2)); 1806 /* 14: */ OP(icode, &ptr, iSKIP, C_00000000, GPR_COND, CC_REG_MINUS, C_00000001); 1807 /* 15: */ OP(icode, &ptr, iANDXOR, GPR(9), GPR(9), GPR(gpr + 1), GPR(gpr + 2)); 1808 1809 /* 16: */ OP(icode, &ptr, iACC3, GPR(tmp + 0), GPR(ipcm->gpr_ptr), C_00000001, C_00000000); 1810 /* 17: */ OP(icode, &ptr, iMACINT0, C_00000000, GPR(tmp + 0), C_ffffffff, GPR(ipcm->gpr_size)); 1811 /* 18: */ OP(icode, &ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_MINUS, C_00000001); 1812 /* 19: */ OP(icode, &ptr, iACC3, GPR(tmp + 0), C_00000000, C_00000000, C_00000000); 1813 /* 1a: */ OP(icode, &ptr, iACC3, GPR(ipcm->gpr_ptr), GPR(tmp + 0), C_00000000, C_00000000); 1814 1815 /* 1b: */ OP(icode, &ptr, iACC3, GPR(ipcm->gpr_tmpcount), GPR(ipcm->gpr_tmpcount), C_ffffffff, C_00000000); 1816 /* 1c: */ OP(icode, &ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, C_00000002); 1817 /* 1d: */ OP(icode, &ptr, iACC3, GPR(ipcm->gpr_tmpcount), GPR(ipcm->gpr_count), C_00000000, C_00000000); 1818 /* 1e: */ OP(icode, &ptr, iACC3, GPR_IRQ, C_80000000, C_00000000, C_00000000); 1819 /* 1f: */ OP(icode, &ptr, iANDXOR, GPR(ipcm->gpr_running), GPR(ipcm->gpr_running), C_00000001, C_00010000); 1820 1821 /* 20: */ OP(icode, &ptr, iANDXOR, GPR(ipcm->gpr_running), GPR(ipcm->gpr_running), C_00010000, C_00000001); 1822 /* 21: */ OP(icode, &ptr, iSKIP, C_00000000, C_7fffffff, C_7fffffff, C_00000002); 1823 1824 /* 22: */ OP(icode, &ptr, iMACINT1, ETRAM_ADDR(ipcm->etram[0]), GPR(gpr + 8), GPR_DBAC, C_ffffffff); 1825 /* 23: */ OP(icode, &ptr, iMACINT1, ETRAM_ADDR(ipcm->etram[1]), GPR(gpr + 9), GPR_DBAC, C_ffffffff); 1826 1827 /* 24: */ 1828 gpr += 13; 1829 1830 /* Wave Playback Volume */ 1831 for (z = 0; z < 2; z++) 1832 VOLUME(icode, &ptr, playback + z, z, gpr + z); 1833 snd_emu10k1_init_stereo_control(controls + i++, "Wave Playback Volume", gpr, 100); 1834 gpr += 2; 1835 1836 /* Wave Surround Playback Volume */ 1837 for (z = 0; z < 2; z++) 1838 VOLUME(icode, &ptr, playback + 2 + z, z, gpr + z); 1839 snd_emu10k1_init_stereo_control(controls + i++, "Wave Surround Playback Volume", gpr, 0); 1840 gpr += 2; 1841 1842 /* Wave Center/LFE Playback Volume */ 1843 OP(icode, &ptr, iACC3, GPR(tmp + 0), FXBUS(FXBUS_PCM_LEFT), FXBUS(FXBUS_PCM_RIGHT), C_00000000); 1844 OP(icode, &ptr, iMACINT0, GPR(tmp + 0), C_00000000, GPR(tmp + 0), C_00000002); 1845 VOLUME(icode, &ptr, playback + 4, tmp + 0, gpr); 1846 snd_emu10k1_init_mono_control(controls + i++, "Wave Center Playback Volume", gpr++, 0); 1847 VOLUME(icode, &ptr, playback + 5, tmp + 0, gpr); 1848 snd_emu10k1_init_mono_control(controls + i++, "Wave LFE Playback Volume", gpr++, 0); 1849 1850 /* Wave Capture Volume + Switch */ 1851 for (z = 0; z < 2; z++) { 1852 SWITCH(icode, &ptr, tmp + 0, z, gpr + 2 + z); 1853 VOLUME(icode, &ptr, capture + z, tmp + 0, gpr + z); 1854 } 1855 snd_emu10k1_init_stereo_control(controls + i++, "Wave Capture Volume", gpr, 0); 1856 snd_emu10k1_init_stereo_onoff_control(controls + i++, "Wave Capture Switch", gpr + 2, 0); 1857 gpr += 4; 1858 1859 /* Synth Playback Volume */ 1860 for (z = 0; z < 2; z++) 1861 VOLUME_ADD(icode, &ptr, playback + z, 2 + z, gpr + z); 1862 snd_emu10k1_init_stereo_control(controls + i++, "Synth Playback Volume", gpr, 100); 1863 gpr += 2; 1864 1865 /* Synth Capture Volume + Switch */ 1866 for (z = 0; z < 2; z++) { 1867 SWITCH(icode, &ptr, tmp + 0, 2 + z, gpr + 2 + z); 1868 VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z); 1869 } 1870 snd_emu10k1_init_stereo_control(controls + i++, "Synth Capture Volume", gpr, 0); 1871 snd_emu10k1_init_stereo_onoff_control(controls + i++, "Synth Capture Switch", gpr + 2, 0); 1872 gpr += 4; 1873 1874 /* Surround Digital Playback Volume (renamed later without Digital) */ 1875 for (z = 0; z < 2; z++) 1876 VOLUME_ADD(icode, &ptr, playback + 2 + z, 4 + z, gpr + z); 1877 snd_emu10k1_init_stereo_control(controls + i++, "Surround Digital Playback Volume", gpr, 100); 1878 gpr += 2; 1879 1880 /* Surround Capture Volume + Switch */ 1881 for (z = 0; z < 2; z++) { 1882 SWITCH(icode, &ptr, tmp + 0, 4 + z, gpr + 2 + z); 1883 VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z); 1884 } 1885 snd_emu10k1_init_stereo_control(controls + i++, "Surround Capture Volume", gpr, 0); 1886 snd_emu10k1_init_stereo_onoff_control(controls + i++, "Surround Capture Switch", gpr + 2, 0); 1887 gpr += 4; 1888 1889 /* Center Playback Volume (renamed later without Digital) */ 1890 VOLUME_ADD(icode, &ptr, playback + 4, 6, gpr); 1891 snd_emu10k1_init_mono_control(controls + i++, "Center Digital Playback Volume", gpr++, 100); 1892 1893 /* LFE Playback Volume + Switch (renamed later without Digital) */ 1894 VOLUME_ADD(icode, &ptr, playback + 5, 7, gpr); 1895 snd_emu10k1_init_mono_control(controls + i++, "LFE Digital Playback Volume", gpr++, 100); 1896 1897 /* Front Playback Volume */ 1898 for (z = 0; z < 2; z++) 1899 VOLUME_ADD(icode, &ptr, playback + z, 10 + z, gpr + z); 1900 snd_emu10k1_init_stereo_control(controls + i++, "Front Playback Volume", gpr, 100); 1901 gpr += 2; 1902 1903 /* Front Capture Volume + Switch */ 1904 for (z = 0; z < 2; z++) { 1905 SWITCH(icode, &ptr, tmp + 0, 10 + z, gpr + 2); 1906 VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z); 1907 } 1908 snd_emu10k1_init_stereo_control(controls + i++, "Front Capture Volume", gpr, 0); 1909 snd_emu10k1_init_mono_onoff_control(controls + i++, "Front Capture Switch", gpr + 2, 0); 1910 gpr += 3; 1911 1912 /* 1913 * Process inputs 1914 */ 1915 1916 if (emu->fx8010.extin_mask & ((1<<EXTIN_AC97_L)|(1<<EXTIN_AC97_R))) { 1917 /* AC'97 Playback Volume */ 1918 VOLUME_ADDIN(icode, &ptr, playback + 0, EXTIN_AC97_L, gpr); gpr++; 1919 VOLUME_ADDIN(icode, &ptr, playback + 1, EXTIN_AC97_R, gpr); gpr++; 1920 snd_emu10k1_init_stereo_control(controls + i++, "AC97 Playback Volume", gpr-2, 0); 1921 /* AC'97 Capture Volume */ 1922 VOLUME_ADDIN(icode, &ptr, capture + 0, EXTIN_AC97_L, gpr); gpr++; 1923 VOLUME_ADDIN(icode, &ptr, capture + 1, EXTIN_AC97_R, gpr); gpr++; 1924 snd_emu10k1_init_stereo_control(controls + i++, "AC97 Capture Volume", gpr-2, 100); 1925 } 1926 1927 if (emu->fx8010.extin_mask & ((1<<EXTIN_SPDIF_CD_L)|(1<<EXTIN_SPDIF_CD_R))) { 1928 /* IEC958 TTL Playback Volume */ 1929 for (z = 0; z < 2; z++) 1930 VOLUME_ADDIN(icode, &ptr, playback + z, EXTIN_SPDIF_CD_L + z, gpr + z); 1931 snd_emu10k1_init_stereo_control(controls + i++, SNDRV_CTL_NAME_IEC958("TTL ",PLAYBACK,VOLUME), gpr, 0); 1932 gpr += 2; 1933 1934 /* IEC958 TTL Capture Volume + Switch */ 1935 for (z = 0; z < 2; z++) { 1936 SWITCH_IN(icode, &ptr, tmp + 0, EXTIN_SPDIF_CD_L + z, gpr + 2 + z); 1937 VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z); 1938 } 1939 snd_emu10k1_init_stereo_control(controls + i++, SNDRV_CTL_NAME_IEC958("TTL ",CAPTURE,VOLUME), gpr, 0); 1940 snd_emu10k1_init_stereo_onoff_control(controls + i++, SNDRV_CTL_NAME_IEC958("TTL ",CAPTURE,SWITCH), gpr + 2, 0); 1941 gpr += 4; 1942 } 1943 1944 if (emu->fx8010.extin_mask & ((1<<EXTIN_ZOOM_L)|(1<<EXTIN_ZOOM_R))) { 1945 /* Zoom Video Playback Volume */ 1946 for (z = 0; z < 2; z++) 1947 VOLUME_ADDIN(icode, &ptr, playback + z, EXTIN_ZOOM_L + z, gpr + z); 1948 snd_emu10k1_init_stereo_control(controls + i++, "Zoom Video Playback Volume", gpr, 0); 1949 gpr += 2; 1950 1951 /* Zoom Video Capture Volume + Switch */ 1952 for (z = 0; z < 2; z++) { 1953 SWITCH_IN(icode, &ptr, tmp + 0, EXTIN_ZOOM_L + z, gpr + 2 + z); 1954 VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z); 1955 } 1956 snd_emu10k1_init_stereo_control(controls + i++, "Zoom Video Capture Volume", gpr, 0); 1957 snd_emu10k1_init_stereo_onoff_control(controls + i++, "Zoom Video Capture Switch", gpr + 2, 0); 1958 gpr += 4; 1959 } 1960 1961 if (emu->fx8010.extin_mask & ((1<<EXTIN_TOSLINK_L)|(1<<EXTIN_TOSLINK_R))) { 1962 /* IEC958 Optical Playback Volume */ 1963 for (z = 0; z < 2; z++) 1964 VOLUME_ADDIN(icode, &ptr, playback + z, EXTIN_TOSLINK_L + z, gpr + z); 1965 snd_emu10k1_init_stereo_control(controls + i++, SNDRV_CTL_NAME_IEC958("LiveDrive ",PLAYBACK,VOLUME), gpr, 0); 1966 gpr += 2; 1967 1968 /* IEC958 Optical Capture Volume */ 1969 for (z = 0; z < 2; z++) { 1970 SWITCH_IN(icode, &ptr, tmp + 0, EXTIN_TOSLINK_L + z, gpr + 2 + z); 1971 VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z); 1972 } 1973 snd_emu10k1_init_stereo_control(controls + i++, SNDRV_CTL_NAME_IEC958("LiveDrive ",CAPTURE,VOLUME), gpr, 0); 1974 snd_emu10k1_init_stereo_onoff_control(controls + i++, SNDRV_CTL_NAME_IEC958("LiveDrive ",CAPTURE,SWITCH), gpr + 2, 0); 1975 gpr += 4; 1976 } 1977 1978 if (emu->fx8010.extin_mask & ((1<<EXTIN_LINE1_L)|(1<<EXTIN_LINE1_R))) { 1979 /* Line LiveDrive Playback Volume */ 1980 for (z = 0; z < 2; z++) 1981 VOLUME_ADDIN(icode, &ptr, playback + z, EXTIN_LINE1_L + z, gpr + z); 1982 snd_emu10k1_init_stereo_control(controls + i++, "Line LiveDrive Playback Volume", gpr, 0); 1983 gpr += 2; 1984 1985 /* Line LiveDrive Capture Volume + Switch */ 1986 for (z = 0; z < 2; z++) { 1987 SWITCH_IN(icode, &ptr, tmp + 0, EXTIN_LINE1_L + z, gpr + 2 + z); 1988 VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z); 1989 } 1990 snd_emu10k1_init_stereo_control(controls + i++, "Line LiveDrive Capture Volume", gpr, 0); 1991 snd_emu10k1_init_stereo_onoff_control(controls + i++, "Line LiveDrive Capture Switch", gpr + 2, 0); 1992 gpr += 4; 1993 } 1994 1995 if (emu->fx8010.extin_mask & ((1<<EXTIN_COAX_SPDIF_L)|(1<<EXTIN_COAX_SPDIF_R))) { 1996 /* IEC958 Coax Playback Volume */ 1997 for (z = 0; z < 2; z++) 1998 VOLUME_ADDIN(icode, &ptr, playback + z, EXTIN_COAX_SPDIF_L + z, gpr + z); 1999 snd_emu10k1_init_stereo_control(controls + i++, SNDRV_CTL_NAME_IEC958("Coaxial ",PLAYBACK,VOLUME), gpr, 0); 2000 gpr += 2; 2001 2002 /* IEC958 Coax Capture Volume + Switch */ 2003 for (z = 0; z < 2; z++) { 2004 SWITCH_IN(icode, &ptr, tmp + 0, EXTIN_COAX_SPDIF_L + z, gpr + 2 + z); 2005 VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z); 2006 } 2007 snd_emu10k1_init_stereo_control(controls + i++, SNDRV_CTL_NAME_IEC958("Coaxial ",CAPTURE,VOLUME), gpr, 0); 2008 snd_emu10k1_init_stereo_onoff_control(controls + i++, SNDRV_CTL_NAME_IEC958("Coaxial ",CAPTURE,SWITCH), gpr + 2, 0); 2009 gpr += 4; 2010 } 2011 2012 if (emu->fx8010.extin_mask & ((1<<EXTIN_LINE2_L)|(1<<EXTIN_LINE2_R))) { 2013 /* Line LiveDrive Playback Volume */ 2014 for (z = 0; z < 2; z++) 2015 VOLUME_ADDIN(icode, &ptr, playback + z, EXTIN_LINE2_L + z, gpr + z); 2016 snd_emu10k1_init_stereo_control(controls + i++, "Line2 LiveDrive Playback Volume", gpr, 0); 2017 controls[i-1].id.index = 1; 2018 gpr += 2; 2019 2020 /* Line LiveDrive Capture Volume */ 2021 for (z = 0; z < 2; z++) { 2022 SWITCH_IN(icode, &ptr, tmp + 0, EXTIN_LINE2_L + z, gpr + 2 + z); 2023 VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z); 2024 } 2025 snd_emu10k1_init_stereo_control(controls + i++, "Line2 LiveDrive Capture Volume", gpr, 0); 2026 controls[i-1].id.index = 1; 2027 snd_emu10k1_init_stereo_onoff_control(controls + i++, "Line2 LiveDrive Capture Switch", gpr + 2, 0); 2028 controls[i-1].id.index = 1; 2029 gpr += 4; 2030 } 2031 2032 /* 2033 * Process tone control 2034 */ 2035 OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 0), GPR(playback + 0), C_00000000, C_00000000); /* left */ 2036 OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 1), GPR(playback + 1), C_00000000, C_00000000); /* right */ 2037 OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 2), GPR(playback + 2), C_00000000, C_00000000); /* rear left */ 2038 OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 3), GPR(playback + 3), C_00000000, C_00000000); /* rear right */ 2039 OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 4), GPR(playback + 4), C_00000000, C_00000000); /* center */ 2040 OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 5), GPR(playback + 5), C_00000000, C_00000000); /* LFE */ 2041 2042 ctl = &controls[i + 0]; 2043 ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 2044 strcpy(ctl->id.name, "Tone Control - Bass"); 2045 ctl->vcount = 2; 2046 ctl->count = 10; 2047 ctl->min = 0; 2048 ctl->max = 40; 2049 ctl->value[0] = ctl->value[1] = 20; 2050 ctl->translation = EMU10K1_GPR_TRANSLATION_BASS; 2051 ctl = &controls[i + 1]; 2052 ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 2053 strcpy(ctl->id.name, "Tone Control - Treble"); 2054 ctl->vcount = 2; 2055 ctl->count = 10; 2056 ctl->min = 0; 2057 ctl->max = 40; 2058 ctl->value[0] = ctl->value[1] = 20; 2059 ctl->translation = EMU10K1_GPR_TRANSLATION_TREBLE; 2060 2061 #define BASS_GPR 0x8c 2062 #define TREBLE_GPR 0x96 2063 2064 for (z = 0; z < 5; z++) { 2065 int j; 2066 for (j = 0; j < 2; j++) { 2067 controls[i + 0].gpr[z * 2 + j] = BASS_GPR + z * 2 + j; 2068 controls[i + 1].gpr[z * 2 + j] = TREBLE_GPR + z * 2 + j; 2069 } 2070 } 2071 for (z = 0; z < 3; z++) { /* front/rear/center-lfe */ 2072 int j, k, l, d; 2073 for (j = 0; j < 2; j++) { /* left/right */ 2074 k = 0xa0 + (z * 8) + (j * 4); 2075 l = 0xd0 + (z * 8) + (j * 4); 2076 d = playback + SND_EMU10K1_PLAYBACK_CHANNELS + z * 2 + j; 2077 2078 OP(icode, &ptr, iMAC0, C_00000000, C_00000000, GPR(d), GPR(BASS_GPR + 0 + j)); 2079 OP(icode, &ptr, iMACMV, GPR(k+1), GPR(k), GPR(k+1), GPR(BASS_GPR + 4 + j)); 2080 OP(icode, &ptr, iMACMV, GPR(k), GPR(d), GPR(k), GPR(BASS_GPR + 2 + j)); 2081 OP(icode, &ptr, iMACMV, GPR(k+3), GPR(k+2), GPR(k+3), GPR(BASS_GPR + 8 + j)); 2082 OP(icode, &ptr, iMAC0, GPR(k+2), GPR_ACCU, GPR(k+2), GPR(BASS_GPR + 6 + j)); 2083 OP(icode, &ptr, iACC3, GPR(k+2), GPR(k+2), GPR(k+2), C_00000000); 2084 2085 OP(icode, &ptr, iMAC0, C_00000000, C_00000000, GPR(k+2), GPR(TREBLE_GPR + 0 + j)); 2086 OP(icode, &ptr, iMACMV, GPR(l+1), GPR(l), GPR(l+1), GPR(TREBLE_GPR + 4 + j)); 2087 OP(icode, &ptr, iMACMV, GPR(l), GPR(k+2), GPR(l), GPR(TREBLE_GPR + 2 + j)); 2088 OP(icode, &ptr, iMACMV, GPR(l+3), GPR(l+2), GPR(l+3), GPR(TREBLE_GPR + 8 + j)); 2089 OP(icode, &ptr, iMAC0, GPR(l+2), GPR_ACCU, GPR(l+2), GPR(TREBLE_GPR + 6 + j)); 2090 OP(icode, &ptr, iMACINT0, GPR(l+2), C_00000000, GPR(l+2), C_00000010); 2091 2092 OP(icode, &ptr, iACC3, GPR(d), GPR(l+2), C_00000000, C_00000000); 2093 2094 if (z == 2) /* center */ 2095 break; 2096 } 2097 } 2098 i += 2; 2099 2100 #undef BASS_GPR 2101 #undef TREBLE_GPR 2102 2103 for (z = 0; z < 6; z++) { 2104 SWITCH(icode, &ptr, tmp + 0, playback + SND_EMU10K1_PLAYBACK_CHANNELS + z, gpr + 0); 2105 SWITCH_NEG(icode, &ptr, tmp + 1, gpr + 0); 2106 SWITCH(icode, &ptr, tmp + 1, playback + z, tmp + 1); 2107 OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + z), GPR(tmp + 0), GPR(tmp + 1), C_00000000); 2108 } 2109 snd_emu10k1_init_stereo_onoff_control(controls + i++, "Tone Control - Switch", gpr, 0); 2110 gpr += 2; 2111 2112 /* 2113 * Process outputs 2114 */ 2115 if (emu->fx8010.extout_mask & ((1<<EXTOUT_AC97_L)|(1<<EXTOUT_AC97_R))) { 2116 /* AC'97 Playback Volume */ 2117 2118 for (z = 0; z < 2; z++) 2119 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_AC97_L + z), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + z), C_00000000, C_00000000); 2120 } 2121 2122 if (emu->fx8010.extout_mask & ((1<<EXTOUT_TOSLINK_L)|(1<<EXTOUT_TOSLINK_R))) { 2123 /* IEC958 Optical Raw Playback Switch */ 2124 2125 for (z = 0; z < 2; z++) { 2126 SWITCH(icode, &ptr, tmp + 0, 8 + z, gpr + z); 2127 SWITCH_NEG(icode, &ptr, tmp + 1, gpr + z); 2128 SWITCH(icode, &ptr, tmp + 1, playback + SND_EMU10K1_PLAYBACK_CHANNELS + z, tmp + 1); 2129 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_TOSLINK_L + z), GPR(tmp + 0), GPR(tmp + 1), C_00000000); 2130 #ifdef EMU10K1_CAPTURE_DIGITAL_OUT 2131 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_ADC_CAP_L + z), GPR(tmp + 0), GPR(tmp + 1), C_00000000); 2132 #endif 2133 } 2134 2135 snd_emu10k1_init_stereo_onoff_control(controls + i++, SNDRV_CTL_NAME_IEC958("Optical Raw ",PLAYBACK,SWITCH), gpr, 0); 2136 gpr += 2; 2137 } 2138 2139 if (emu->fx8010.extout_mask & ((1<<EXTOUT_HEADPHONE_L)|(1<<EXTOUT_HEADPHONE_R))) { 2140 /* Headphone Playback Volume */ 2141 2142 for (z = 0; z < 2; z++) { 2143 SWITCH(icode, &ptr, tmp + 0, playback + SND_EMU10K1_PLAYBACK_CHANNELS + 4 + z, gpr + 2 + z); 2144 SWITCH_NEG(icode, &ptr, tmp + 1, gpr + 2 + z); 2145 SWITCH(icode, &ptr, tmp + 1, playback + SND_EMU10K1_PLAYBACK_CHANNELS + z, tmp + 1); 2146 OP(icode, &ptr, iACC3, GPR(tmp + 0), GPR(tmp + 0), GPR(tmp + 1), C_00000000); 2147 VOLUME_OUT(icode, &ptr, EXTOUT_HEADPHONE_L + z, tmp + 0, gpr + z); 2148 } 2149 2150 snd_emu10k1_init_stereo_control(controls + i++, "Headphone Playback Volume", gpr + 0, 0); 2151 controls[i-1].id.index = 1; /* AC'97 can have also Headphone control */ 2152 snd_emu10k1_init_mono_onoff_control(controls + i++, "Headphone Center Playback Switch", gpr + 2, 0); 2153 controls[i-1].id.index = 1; 2154 snd_emu10k1_init_mono_onoff_control(controls + i++, "Headphone LFE Playback Switch", gpr + 3, 0); 2155 controls[i-1].id.index = 1; 2156 2157 gpr += 4; 2158 } 2159 2160 if (emu->fx8010.extout_mask & ((1<<EXTOUT_REAR_L)|(1<<EXTOUT_REAR_R))) 2161 for (z = 0; z < 2; z++) 2162 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_REAR_L + z), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 2 + z), C_00000000, C_00000000); 2163 2164 if (emu->fx8010.extout_mask & ((1<<EXTOUT_AC97_REAR_L)|(1<<EXTOUT_AC97_REAR_R))) 2165 for (z = 0; z < 2; z++) 2166 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_AC97_REAR_L + z), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 2 + z), C_00000000, C_00000000); 2167 2168 if (emu->fx8010.extout_mask & (1<<EXTOUT_AC97_CENTER)) { 2169 #ifndef EMU10K1_CENTER_LFE_FROM_FRONT 2170 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_AC97_CENTER), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 4), C_00000000, C_00000000); 2171 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_ACENTER), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 4), C_00000000, C_00000000); 2172 #else 2173 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_AC97_CENTER), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 0), C_00000000, C_00000000); 2174 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_ACENTER), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 0), C_00000000, C_00000000); 2175 #endif 2176 } 2177 2178 if (emu->fx8010.extout_mask & (1<<EXTOUT_AC97_LFE)) { 2179 #ifndef EMU10K1_CENTER_LFE_FROM_FRONT 2180 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_AC97_LFE), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 5), C_00000000, C_00000000); 2181 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_ALFE), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 5), C_00000000, C_00000000); 2182 #else 2183 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_AC97_LFE), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 1), C_00000000, C_00000000); 2184 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_ALFE), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 1), C_00000000, C_00000000); 2185 #endif 2186 } 2187 2188 #ifndef EMU10K1_CAPTURE_DIGITAL_OUT 2189 for (z = 0; z < 2; z++) 2190 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_ADC_CAP_L + z), GPR(capture + z), C_00000000, C_00000000); 2191 #endif 2192 2193 if (emu->fx8010.extout_mask & (1<<EXTOUT_MIC_CAP)) 2194 OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_MIC_CAP), GPR(capture + 2), C_00000000, C_00000000); 2195 2196 /* EFX capture - capture the 16 EXTINS */ 2197 if (emu->card_capabilities->sblive51) { 2198 /* On the Live! 5.1, FXBUS2(1) and FXBUS(2) are shared with EXTOUT_ACENTER 2199 * and EXTOUT_ALFE, so we can't connect inputs to them for multitrack recording. 2200 * 2201 * Since only 14 of the 16 EXTINs are used, this is not a big problem. 2202 * We route AC97L and R to FX capture 14 and 15, SPDIF CD in to FX capture 2203 * 0 and 3, then the rest of the EXTINs to the corresponding FX capture 2204 * channel. Multitrack recorders will still see the center/lfe output signal 2205 * on the second and third channels. 2206 */ 2207 OP(icode, &ptr, iACC3, FXBUS2(14), C_00000000, C_00000000, EXTIN(0)); 2208 OP(icode, &ptr, iACC3, FXBUS2(15), C_00000000, C_00000000, EXTIN(1)); 2209 OP(icode, &ptr, iACC3, FXBUS2(0), C_00000000, C_00000000, EXTIN(2)); 2210 OP(icode, &ptr, iACC3, FXBUS2(3), C_00000000, C_00000000, EXTIN(3)); 2211 for (z = 4; z < 14; z++) 2212 OP(icode, &ptr, iACC3, FXBUS2(z), C_00000000, C_00000000, EXTIN(z)); 2213 } else { 2214 for (z = 0; z < 16; z++) 2215 OP(icode, &ptr, iACC3, FXBUS2(z), C_00000000, C_00000000, EXTIN(z)); 2216 } 2217 2218 2219 if (gpr > tmp) { 2220 snd_BUG(); 2221 err = -EIO; 2222 goto __err; 2223 } 2224 if (i > SND_EMU10K1_GPR_CONTROLS) { 2225 snd_BUG(); 2226 err = -EIO; 2227 goto __err; 2228 } 2229 2230 /* clear remaining instruction memory */ 2231 while (ptr < 0x200) 2232 OP(icode, &ptr, iACC3, C_00000000, C_00000000, C_00000000, C_00000000); 2233 2234 if ((err = snd_emu10k1_fx8010_tram_setup(emu, ipcm->buffer_size)) < 0) 2235 goto __err; 2236 seg = snd_enter_user(); 2237 icode->gpr_add_control_count = i; 2238 icode->gpr_add_controls = (struct snd_emu10k1_fx8010_control_gpr __user *)controls; 2239 emu->support_tlv = 1; /* support TLV */ 2240 err = snd_emu10k1_icode_poke(emu, icode); 2241 emu->support_tlv = 0; /* clear again */ 2242 snd_leave_user(seg); 2243 if (err >= 0) 2244 err = snd_emu10k1_ipcm_poke(emu, ipcm); 2245 __err: 2246 kfree(ipcm); 2247 kfree(controls); 2248 if (icode != NULL) { 2249 kfree((void __force *)icode->gpr_map); 2250 kfree(icode); 2251 } 2252 return err; 2253 } 2254 2255 int __devinit snd_emu10k1_init_efx(struct snd_emu10k1 *emu) 2256 { 2257 spin_lock_init(&emu->fx8010.irq_lock); 2258 INIT_LIST_HEAD(&emu->fx8010.gpr_ctl); 2259 if (emu->audigy) 2260 return _snd_emu10k1_audigy_init_efx(emu); 2261 else 2262 return _snd_emu10k1_init_efx(emu); 2263 } 2264 2265 void snd_emu10k1_free_efx(struct snd_emu10k1 *emu) 2266 { 2267 /* stop processor */ 2268 if (emu->audigy) 2269 snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg = A_DBG_SINGLE_STEP); 2270 else 2271 snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg = EMU10K1_DBG_SINGLE_STEP); 2272 } 2273 2274 #if 0 /* FIXME: who use them? */ 2275 int snd_emu10k1_fx8010_tone_control_activate(struct snd_emu10k1 *emu, int output) 2276 { 2277 if (output < 0 || output >= 6) 2278 return -EINVAL; 2279 snd_emu10k1_ptr_write(emu, emu->gpr_base + 0x94 + output, 0, 1); 2280 return 0; 2281 } 2282 2283 int snd_emu10k1_fx8010_tone_control_deactivate(struct snd_emu10k1 *emu, int output) 2284 { 2285 if (output < 0 || output >= 6) 2286 return -EINVAL; 2287 snd_emu10k1_ptr_write(emu, emu->gpr_base + 0x94 + output, 0, 0); 2288 return 0; 2289 } 2290 #endif 2291 2292 int snd_emu10k1_fx8010_tram_setup(struct snd_emu10k1 *emu, u32 size) 2293 { 2294 u8 size_reg = 0; 2295 2296 /* size is in samples */ 2297 if (size != 0) { 2298 size = (size - 1) >> 13; 2299 2300 while (size) { 2301 size >>= 1; 2302 size_reg++; 2303 } 2304 size = 0x2000 << size_reg; 2305 } 2306 if ((emu->fx8010.etram_pages.bytes / 2) == size) 2307 return 0; 2308 spin_lock_irq(&emu->emu_lock); 2309 outl(HCFG_LOCKTANKCACHE_MASK | inl(emu->port + HCFG), emu->port + HCFG); 2310 spin_unlock_irq(&emu->emu_lock); 2311 snd_emu10k1_ptr_write(emu, TCB, 0, 0); 2312 snd_emu10k1_ptr_write(emu, TCBS, 0, 0); 2313 if (emu->fx8010.etram_pages.area != NULL) { 2314 snd_dma_free_pages(&emu->fx8010.etram_pages); 2315 emu->fx8010.etram_pages.area = NULL; 2316 emu->fx8010.etram_pages.bytes = 0; 2317 } 2318 2319 if (size > 0) { 2320 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(emu->pci), 2321 size * 2, &emu->fx8010.etram_pages) < 0) 2322 return -ENOMEM; 2323 memset(emu->fx8010.etram_pages.area, 0, size * 2); 2324 snd_emu10k1_ptr_write(emu, TCB, 0, emu->fx8010.etram_pages.addr); 2325 snd_emu10k1_ptr_write(emu, TCBS, 0, size_reg); 2326 spin_lock_irq(&emu->emu_lock); 2327 outl(inl(emu->port + HCFG) & ~HCFG_LOCKTANKCACHE_MASK, emu->port + HCFG); 2328 spin_unlock_irq(&emu->emu_lock); 2329 } 2330 2331 return 0; 2332 } 2333 2334 static int snd_emu10k1_fx8010_open(struct snd_hwdep * hw, struct file *file) 2335 { 2336 return 0; 2337 } 2338 2339 static void copy_string(char *dst, char *src, char *null, int idx) 2340 { 2341 if (src == NULL) 2342 sprintf(dst, "%s %02X", null, idx); 2343 else 2344 strcpy(dst, src); 2345 } 2346 2347 static int snd_emu10k1_fx8010_info(struct snd_emu10k1 *emu, 2348 struct snd_emu10k1_fx8010_info *info) 2349 { 2350 char **fxbus, **extin, **extout; 2351 unsigned short fxbus_mask, extin_mask, extout_mask; 2352 int res; 2353 2354 memset(info, 0, sizeof(info)); 2355 info->internal_tram_size = emu->fx8010.itram_size; 2356 info->external_tram_size = emu->fx8010.etram_pages.bytes / 2; 2357 fxbus = fxbuses; 2358 extin = emu->audigy ? audigy_ins : creative_ins; 2359 extout = emu->audigy ? audigy_outs : creative_outs; 2360 fxbus_mask = emu->fx8010.fxbus_mask; 2361 extin_mask = emu->fx8010.extin_mask; 2362 extout_mask = emu->fx8010.extout_mask; 2363 for (res = 0; res < 16; res++, fxbus++, extin++, extout++) { 2364 copy_string(info->fxbus_names[res], fxbus_mask & (1 << res) ? *fxbus : NULL, "FXBUS", res); 2365 copy_string(info->extin_names[res], extin_mask & (1 << res) ? *extin : NULL, "Unused", res); 2366 copy_string(info->extout_names[res], extout_mask & (1 << res) ? *extout : NULL, "Unused", res); 2367 } 2368 for (res = 16; res < 32; res++, extout++) 2369 copy_string(info->extout_names[res], extout_mask & (1 << res) ? *extout : NULL, "Unused", res); 2370 info->gpr_controls = emu->fx8010.gpr_count; 2371 return 0; 2372 } 2373 2374 static int snd_emu10k1_fx8010_ioctl(struct snd_hwdep * hw, struct file *file, unsigned int cmd, unsigned long arg) 2375 { 2376 struct snd_emu10k1 *emu = hw->private_data; 2377 struct snd_emu10k1_fx8010_info *info; 2378 struct snd_emu10k1_fx8010_code *icode; 2379 struct snd_emu10k1_fx8010_pcm_rec *ipcm; 2380 unsigned int addr; 2381 void __user *argp = (void __user *)arg; 2382 int res; 2383 2384 switch (cmd) { 2385 case SNDRV_EMU10K1_IOCTL_PVERSION: 2386 emu->support_tlv = 1; 2387 return put_user(SNDRV_EMU10K1_VERSION, (int __user *)argp); 2388 case SNDRV_EMU10K1_IOCTL_INFO: 2389 info = kmalloc(sizeof(*info), GFP_KERNEL); 2390 if (!info) 2391 return -ENOMEM; 2392 if ((res = snd_emu10k1_fx8010_info(emu, info)) < 0) { 2393 kfree(info); 2394 return res; 2395 } 2396 if (copy_to_user(argp, info, sizeof(*info))) { 2397 kfree(info); 2398 return -EFAULT; 2399 } 2400 kfree(info); 2401 return 0; 2402 case SNDRV_EMU10K1_IOCTL_CODE_POKE: 2403 if (!capable(CAP_SYS_ADMIN)) 2404 return -EPERM; 2405 icode = kmalloc(sizeof(*icode), GFP_KERNEL); 2406 if (icode == NULL) 2407 return -ENOMEM; 2408 if (copy_from_user(icode, argp, sizeof(*icode))) { 2409 kfree(icode); 2410 return -EFAULT; 2411 } 2412 res = snd_emu10k1_icode_poke(emu, icode); 2413 kfree(icode); 2414 return res; 2415 case SNDRV_EMU10K1_IOCTL_CODE_PEEK: 2416 icode = kmalloc(sizeof(*icode), GFP_KERNEL); 2417 if (icode == NULL) 2418 return -ENOMEM; 2419 if (copy_from_user(icode, argp, sizeof(*icode))) { 2420 kfree(icode); 2421 return -EFAULT; 2422 } 2423 res = snd_emu10k1_icode_peek(emu, icode); 2424 if (res == 0 && copy_to_user(argp, icode, sizeof(*icode))) { 2425 kfree(icode); 2426 return -EFAULT; 2427 } 2428 kfree(icode); 2429 return res; 2430 case SNDRV_EMU10K1_IOCTL_PCM_POKE: 2431 ipcm = kmalloc(sizeof(*ipcm), GFP_KERNEL); 2432 if (ipcm == NULL) 2433 return -ENOMEM; 2434 if (copy_from_user(ipcm, argp, sizeof(*ipcm))) { 2435 kfree(ipcm); 2436 return -EFAULT; 2437 } 2438 res = snd_emu10k1_ipcm_poke(emu, ipcm); 2439 kfree(ipcm); 2440 return res; 2441 case SNDRV_EMU10K1_IOCTL_PCM_PEEK: 2442 ipcm = kzalloc(sizeof(*ipcm), GFP_KERNEL); 2443 if (ipcm == NULL) 2444 return -ENOMEM; 2445 if (copy_from_user(ipcm, argp, sizeof(*ipcm))) { 2446 kfree(ipcm); 2447 return -EFAULT; 2448 } 2449 res = snd_emu10k1_ipcm_peek(emu, ipcm); 2450 if (res == 0 && copy_to_user(argp, ipcm, sizeof(*ipcm))) { 2451 kfree(ipcm); 2452 return -EFAULT; 2453 } 2454 kfree(ipcm); 2455 return res; 2456 case SNDRV_EMU10K1_IOCTL_TRAM_SETUP: 2457 if (!capable(CAP_SYS_ADMIN)) 2458 return -EPERM; 2459 if (get_user(addr, (unsigned int __user *)argp)) 2460 return -EFAULT; 2461 mutex_lock(&emu->fx8010.lock); 2462 res = snd_emu10k1_fx8010_tram_setup(emu, addr); 2463 mutex_unlock(&emu->fx8010.lock); 2464 return res; 2465 case SNDRV_EMU10K1_IOCTL_STOP: 2466 if (!capable(CAP_SYS_ADMIN)) 2467 return -EPERM; 2468 if (emu->audigy) 2469 snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg |= A_DBG_SINGLE_STEP); 2470 else 2471 snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg |= EMU10K1_DBG_SINGLE_STEP); 2472 return 0; 2473 case SNDRV_EMU10K1_IOCTL_CONTINUE: 2474 if (!capable(CAP_SYS_ADMIN)) 2475 return -EPERM; 2476 if (emu->audigy) 2477 snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg = 0); 2478 else 2479 snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg = 0); 2480 return 0; 2481 case SNDRV_EMU10K1_IOCTL_ZERO_TRAM_COUNTER: 2482 if (!capable(CAP_SYS_ADMIN)) 2483 return -EPERM; 2484 if (emu->audigy) 2485 snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg | A_DBG_ZC); 2486 else 2487 snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg | EMU10K1_DBG_ZC); 2488 udelay(10); 2489 if (emu->audigy) 2490 snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg); 2491 else 2492 snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg); 2493 return 0; 2494 case SNDRV_EMU10K1_IOCTL_SINGLE_STEP: 2495 if (!capable(CAP_SYS_ADMIN)) 2496 return -EPERM; 2497 if (get_user(addr, (unsigned int __user *)argp)) 2498 return -EFAULT; 2499 if (addr > 0x1ff) 2500 return -EINVAL; 2501 if (emu->audigy) 2502 snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg |= A_DBG_SINGLE_STEP | addr); 2503 else 2504 snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg |= EMU10K1_DBG_SINGLE_STEP | addr); 2505 udelay(10); 2506 if (emu->audigy) 2507 snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg |= A_DBG_SINGLE_STEP | A_DBG_STEP_ADDR | addr); 2508 else 2509 snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg |= EMU10K1_DBG_SINGLE_STEP | EMU10K1_DBG_STEP | addr); 2510 return 0; 2511 case SNDRV_EMU10K1_IOCTL_DBG_READ: 2512 if (emu->audigy) 2513 addr = snd_emu10k1_ptr_read(emu, A_DBG, 0); 2514 else 2515 addr = snd_emu10k1_ptr_read(emu, DBG, 0); 2516 if (put_user(addr, (unsigned int __user *)argp)) 2517 return -EFAULT; 2518 return 0; 2519 } 2520 return -ENOTTY; 2521 } 2522 2523 static int snd_emu10k1_fx8010_release(struct snd_hwdep * hw, struct file *file) 2524 { 2525 return 0; 2526 } 2527 2528 int __devinit snd_emu10k1_fx8010_new(struct snd_emu10k1 *emu, int device, struct snd_hwdep ** rhwdep) 2529 { 2530 struct snd_hwdep *hw; 2531 int err; 2532 2533 if (rhwdep) 2534 *rhwdep = NULL; 2535 if ((err = snd_hwdep_new(emu->card, "FX8010", device, &hw)) < 0) 2536 return err; 2537 strcpy(hw->name, "EMU10K1 (FX8010)"); 2538 hw->iface = SNDRV_HWDEP_IFACE_EMU10K1; 2539 hw->ops.open = snd_emu10k1_fx8010_open; 2540 hw->ops.ioctl = snd_emu10k1_fx8010_ioctl; 2541 hw->ops.release = snd_emu10k1_fx8010_release; 2542 hw->private_data = emu; 2543 if (rhwdep) 2544 *rhwdep = hw; 2545 return 0; 2546 } 2547 2548 #ifdef CONFIG_PM 2549 int __devinit snd_emu10k1_efx_alloc_pm_buffer(struct snd_emu10k1 *emu) 2550 { 2551 int len; 2552 2553 len = emu->audigy ? 0x200 : 0x100; 2554 emu->saved_gpr = kmalloc(len * 4, GFP_KERNEL); 2555 if (! emu->saved_gpr) 2556 return -ENOMEM; 2557 len = emu->audigy ? 0x100 : 0xa0; 2558 emu->tram_val_saved = kmalloc(len * 4, GFP_KERNEL); 2559 emu->tram_addr_saved = kmalloc(len * 4, GFP_KERNEL); 2560 if (! emu->tram_val_saved || ! emu->tram_addr_saved) 2561 return -ENOMEM; 2562 len = emu->audigy ? 2 * 1024 : 2 * 512; 2563 emu->saved_icode = vmalloc(len * 4); 2564 if (! emu->saved_icode) 2565 return -ENOMEM; 2566 return 0; 2567 } 2568 2569 void snd_emu10k1_efx_free_pm_buffer(struct snd_emu10k1 *emu) 2570 { 2571 kfree(emu->saved_gpr); 2572 kfree(emu->tram_val_saved); 2573 kfree(emu->tram_addr_saved); 2574 vfree(emu->saved_icode); 2575 } 2576 2577 /* 2578 * save/restore GPR, TRAM and codes 2579 */ 2580 void snd_emu10k1_efx_suspend(struct snd_emu10k1 *emu) 2581 { 2582 int i, len; 2583 2584 len = emu->audigy ? 0x200 : 0x100; 2585 for (i = 0; i < len; i++) 2586 emu->saved_gpr[i] = snd_emu10k1_ptr_read(emu, emu->gpr_base + i, 0); 2587 2588 len = emu->audigy ? 0x100 : 0xa0; 2589 for (i = 0; i < len; i++) { 2590 emu->tram_val_saved[i] = snd_emu10k1_ptr_read(emu, TANKMEMDATAREGBASE + i, 0); 2591 emu->tram_addr_saved[i] = snd_emu10k1_ptr_read(emu, TANKMEMADDRREGBASE + i, 0); 2592 if (emu->audigy) { 2593 emu->tram_addr_saved[i] >>= 12; 2594 emu->tram_addr_saved[i] |= 2595 snd_emu10k1_ptr_read(emu, A_TANKMEMCTLREGBASE + i, 0) << 20; 2596 } 2597 } 2598 2599 len = emu->audigy ? 2 * 1024 : 2 * 512; 2600 for (i = 0; i < len; i++) 2601 emu->saved_icode[i] = snd_emu10k1_efx_read(emu, i); 2602 } 2603 2604 void snd_emu10k1_efx_resume(struct snd_emu10k1 *emu) 2605 { 2606 int i, len; 2607 2608 /* set up TRAM */ 2609 if (emu->fx8010.etram_pages.bytes > 0) { 2610 unsigned size, size_reg = 0; 2611 size = emu->fx8010.etram_pages.bytes / 2; 2612 size = (size - 1) >> 13; 2613 while (size) { 2614 size >>= 1; 2615 size_reg++; 2616 } 2617 outl(HCFG_LOCKTANKCACHE_MASK | inl(emu->port + HCFG), emu->port + HCFG); 2618 snd_emu10k1_ptr_write(emu, TCB, 0, emu->fx8010.etram_pages.addr); 2619 snd_emu10k1_ptr_write(emu, TCBS, 0, size_reg); 2620 outl(inl(emu->port + HCFG) & ~HCFG_LOCKTANKCACHE_MASK, emu->port + HCFG); 2621 } 2622 2623 if (emu->audigy) 2624 snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg | A_DBG_SINGLE_STEP); 2625 else 2626 snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg | EMU10K1_DBG_SINGLE_STEP); 2627 2628 len = emu->audigy ? 0x200 : 0x100; 2629 for (i = 0; i < len; i++) 2630 snd_emu10k1_ptr_write(emu, emu->gpr_base + i, 0, emu->saved_gpr[i]); 2631 2632 len = emu->audigy ? 0x100 : 0xa0; 2633 for (i = 0; i < len; i++) { 2634 snd_emu10k1_ptr_write(emu, TANKMEMDATAREGBASE + i, 0, 2635 emu->tram_val_saved[i]); 2636 if (! emu->audigy) 2637 snd_emu10k1_ptr_write(emu, TANKMEMADDRREGBASE + i, 0, 2638 emu->tram_addr_saved[i]); 2639 else { 2640 snd_emu10k1_ptr_write(emu, TANKMEMADDRREGBASE + i, 0, 2641 emu->tram_addr_saved[i] << 12); 2642 snd_emu10k1_ptr_write(emu, TANKMEMADDRREGBASE + i, 0, 2643 emu->tram_addr_saved[i] >> 20); 2644 } 2645 } 2646 2647 len = emu->audigy ? 2 * 1024 : 2 * 512; 2648 for (i = 0; i < len; i++) 2649 snd_emu10k1_efx_write(emu, i, emu->saved_icode[i]); 2650 2651 /* start FX processor when the DSP code is updated */ 2652 if (emu->audigy) 2653 snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg); 2654 else 2655 snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg); 2656 } 2657 #endif 2658