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