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