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