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