?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.14.171
[linux/fpc-iii.git] / sound / oss / sb_ess.c
blob17e3f14318cda985c5e934e73744804e23dac7f6
1 // SPDX-License-Identifier: GPL-2.0
2 #undef FKS_LOGGING
3 #undef FKS_TEST
4
5 /*
6 * tabs should be 4 spaces, in vi(m): set tabstop=4
7 *
8 * TODO: consistency speed calculations!!
9 * cleanup!
10 * ????: Did I break MIDI support?
11 *
12 * History:
13 *
14 * Rolf Fokkens (Dec 20 1998): ES188x recording level support on a per
15 * fokkensr@vertis.nl input basis.
16 * (Dec 24 1998): Recognition of ES1788, ES1887, ES1888,
17 * ES1868, ES1869 and ES1878. Could be used for
18 * specific handling in the future. All except
19 * ES1887 and ES1888 and ES688 are handled like
20 * ES1688.
21 * (Dec 27 1998): RECLEV for all (?) ES1688+ chips. ES188x now
22 * have the "Dec 20" support + RECLEV
23 * (Jan 2 1999): Preparation for Full Duplex. This means
24 * Audio 2 is now used for playback when dma16
25 * is specified. The next step would be to use
26 * Audio 1 and Audio 2 at the same time.
27 * (Jan 9 1999): Put all ESS stuff into sb_ess.[ch], this
28 * includes both the ESS stuff that has been in
29 * sb_*[ch] before I touched it and the ESS support
30 * I added later
31 * (Jan 23 1999): Full Duplex seems to work. I wrote a small
32 * test proggy which works OK. Haven't found
33 * any applications to test it though. So why did
34 * I bother to create it anyway?? :) Just for
35 * fun.
36 * (May 2 1999): I tried to be too smart by "introducing"
37 * ess_calc_best_speed (). The idea was that two
38 * dividers could be used to setup a samplerate,
39 * ess_calc_best_speed () would choose the best.
40 * This works for playback, but results in
41 * recording problems for high samplerates. I
42 * fixed this by removing ess_calc_best_speed ()
43 * and just doing what the documentation says.
44 * Andy Sloane (Jun 4 1999): Stole some code from ALSA to fix the playback
45 * andy@guildsoftware.com speed on ES1869, ES1879, ES1887, and ES1888.
46 * 1879's were previously ignored by this driver;
47 * added (untested) support for those.
48 * Cvetan Ivanov (Oct 27 1999): Fixed ess_dsp_init to call ess_set_dma_hw for
49 * zezo@inet.bg _ALL_ ESS models, not only ES1887
50 *
51 * This files contains ESS chip specifics. It's based on the existing ESS
52 * handling as it resided in sb_common.c, sb_mixer.c and sb_audio.c. This
53 * file adds features like:
54 * - Chip Identification (as shown in /proc/sound)
55 * - RECLEV support for ES1688 and later
56 * - 6 bits playback level support chips later than ES1688
57 * - Recording level support on a per-device basis for ES1887
58 * - Full-Duplex for ES1887
59 *
60 * Full duplex is enabled by specifying dma16. While the normal dma must
61 * be one of 0, 1 or 3, dma16 can be one of 0, 1, 3 or 5. DMA 5 is a 16 bit
62 * DMA channel, while the others are 8 bit..
63 *
64 * ESS detection isn't full proof (yet). If it fails an additional module
65 * parameter esstype can be specified to be one of the following:
66 * -1, 0, 688, 1688, 1868, 1869, 1788, 1887, 1888
67 * -1 means: mimic 2.0 behaviour,
68 * 0 means: auto detect.
69 * others: explicitly specify chip
70 * -1 is default, cause auto detect still doesn't work.
71 */
72
73 /*
74 * About the documentation
75 *
76 * I don't know if the chips all are OK, but the documentation is buggy. 'cause
77 * I don't have all the cips myself, there's a lot I cannot verify. I'll try to
78 * keep track of my latest insights about his here. If you have additional info,
79 * please enlighten me (fokkensr@vertis.nl)!
80 *
81 * I had the impression that ES1688 also has 6 bit master volume control. The
82 * documentation about ES1888 (rev C, october '95) claims that ES1888 has
83 * the following features ES1688 doesn't have:
84 * - 6 bit master volume
85 * - Full Duplex
86 * So ES1688 apparently doesn't have 6 bit master volume control, but the
87 * ES1688 does have RECLEV control. Makes me wonder: does ES688 have it too?
88 * Without RECLEV ES688 won't be much fun I guess.
89 *
90 * From the ES1888 (rev C, october '95) documentation I got the impression
91 * that registers 0x68 to 0x6e don't exist which means: no recording volume
92 * controls. To my surprise the ES888 documentation (1/14/96) claims that
93 * ES888 does have these record mixer registers, but that ES1888 doesn't have
94 * 0x69 and 0x6b. So the rest should be there.
95 *
96 * I'm trying to get ES1887 Full Duplex. Audio 2 is playback only, while Audio 2
97 * is both record and playback. I think I should use Audio 2 for all playback.
98 *
99 * The documentation is an adventure: it's close but not fully accurate. I
100 * found out that after a reset some registers are *NOT* reset, though the
101 * docs say the would be. Interesting ones are 0x7f, 0x7d and 0x7a. They are
102 * related to the Audio 2 channel. I also was surprised about the consequences
103 * of writing 0x00 to 0x7f (which should be done by reset): The ES1887 moves
104 * into ES1888 mode. This means that it claims IRQ 11, which happens to be my
105 * ISDN adapter. Needless to say it no longer worked. I now understand why
106 * after rebooting 0x7f already was 0x05, the value of my choice: the BIOS
107 * did it.
108 *
109 * Oh, and this is another trap: in ES1887 docs mixer register 0x70 is
110 * described as if it's exactly the same as register 0xa1. This is *NOT* true.
111 * The description of 0x70 in ES1869 docs is accurate however.
112 * Well, the assumption about ES1869 was wrong: register 0x70 is very much
113 * like register 0xa1, except that bit 7 is always 1, whatever you want
114 * it to be.
115 *
116 * When using audio 2 mixer register 0x72 seems te be meaningless. Only 0xa2
117 * has effect.
118 *
119 * Software reset not being able to reset all registers is great! Especially
120 * the fact that register 0x78 isn't reset is great when you wanna change back
121 * to single dma operation (simplex): audio 2 is still operational, and uses
122 * the same dma as audio 1: your ess changes into a funny echo machine.
123 *
124 * Received the news that ES1688 is detected as a ES1788. Did some thinking:
125 * the ES1887 detection scheme suggests in step 2 to try if bit 3 of register
126 * 0x64 can be changed. This is inaccurate, first I inverted the * check: "If
127 * can be modified, it's a 1688", which lead to a correct detection
128 * of my ES1887. It resulted however in bad detection of 1688 (reported by mail)
129 * and 1868 (if no PnP detection first): they result in a 1788 being detected.
130 * I don't have docs on 1688, but I do have docs on 1868: The documentation is
131 * probably inaccurate in the fact that I should check bit 2, not bit 3. This
132 * is what I do now.
133 */
134
135 /*
136 * About recognition of ESS chips
137 *
138 * The distinction of ES688, ES1688, ES1788, ES1887 and ES1888 is described in
139 * a (preliminary ??) datasheet on ES1887. Its aim is to identify ES1887, but
140 * during detection the text claims that "this chip may be ..." when a step
141 * fails. This scheme is used to distinct between the above chips.
142 * It appears however that some PnP chips like ES1868 are recognized as ES1788
143 * by the ES1887 detection scheme. These PnP chips can be detected in another
144 * way however: ES1868, ES1869 and ES1878 can be recognized (full proof I think)
145 * by repeatedly reading mixer register 0x40. This is done by ess_identify in
146 * sb_common.c.
147 * This results in the following detection steps:
148 * - distinct between ES688 and ES1688+ (as always done in this driver)
149 * if ES688 we're ready
150 * - try to detect ES1868, ES1869 or ES1878
151 * if successful we're ready
152 * - try to detect ES1888, ES1887 or ES1788
153 * if successful we're ready
154 * - Dunno. Must be 1688. Will do in general
155 *
156 * About RECLEV support:
157 *
158 * The existing ES1688 support didn't take care of the ES1688+ recording
159 * levels very well. Whenever a device was selected (recmask) for recording
160 * its recording level was loud, and it couldn't be changed. The fact that
161 * internal register 0xb4 could take care of RECLEV, didn't work meaning until
162 * its value was restored every time the chip was reset; this reset the
163 * value of 0xb4 too. I guess that's what 4front also had (have?) trouble with.
164 *
165 * About ES1887 support:
166 *
167 * The ES1887 has separate registers to control the recording levels, for all
168 * inputs. The ES1887 specific software makes these levels the same as their
169 * corresponding playback levels, unless recmask says they aren't recorded. In
170 * the latter case the recording volumes are 0.
171 * Now recording levels of inputs can be controlled, by changing the playback
172 * levels. Furthermore several devices can be recorded together (which is not
173 * possible with the ES1688).
174 * Besides the separate recording level control for each input, the common
175 * recording level can also be controlled by RECLEV as described above.
176 *
177 * Not only ES1887 have this recording mixer. I know the following from the
178 * documentation:
179 * ES688 no
180 * ES1688 no
181 * ES1868 no
182 * ES1869 yes
183 * ES1878 no
184 * ES1879 yes
185 * ES1888 no/yes Contradicting documentation; most recent: yes
186 * ES1946 yes This is a PCI chip; not handled by this driver
187 */
188
189 #include <linux/delay.h>
190 #include <linux/interrupt.h>
191 #include <linux/spinlock.h>
192
193 #include "sound_config.h"
194 #include "sb_mixer.h"
195 #include "sb.h"
196
197 #include "sb_ess.h"
198
199 #define ESSTYPE_LIKE20 -1 /* Mimic 2.0 behaviour */
200 #define ESSTYPE_DETECT 0 /* Mimic 2.0 behaviour */
201
202 #define SUBMDL_ES1788 0x10 /* Subtype ES1788 for specific handling */
203 #define SUBMDL_ES1868 0x11 /* Subtype ES1868 for specific handling */
204 #define SUBMDL_ES1869 0x12 /* Subtype ES1869 for specific handling */
205 #define SUBMDL_ES1878 0x13 /* Subtype ES1878 for specific handling */
206 #define SUBMDL_ES1879 0x16 /* ES1879 was initially forgotten */
207 #define SUBMDL_ES1887 0x14 /* Subtype ES1887 for specific handling */
208 #define SUBMDL_ES1888 0x15 /* Subtype ES1888 for specific handling */
209
210 #define SB_CAP_ES18XX_RATE 0x100
211
212 #define ES1688_CLOCK1 795444 /* 128 - div */
213 #define ES1688_CLOCK2 397722 /* 256 - div */
214 #define ES18XX_CLOCK1 793800 /* 128 - div */
215 #define ES18XX_CLOCK2 768000 /* 256 - div */
216
217 #ifdef FKS_LOGGING
218 static void ess_show_mixerregs (sb_devc *devc);
219 #endif
220 static int ess_read (sb_devc * devc, unsigned char reg);
221 static int ess_write (sb_devc * devc, unsigned char reg, unsigned char data);
222 static void ess_chgmixer
223 (sb_devc * devc, unsigned int reg, unsigned int mask, unsigned int val);
224
225 /****************************************************************************
226 * *
227 * ESS audio *
228 * *
229 ****************************************************************************/
230
231 struct ess_command {short cmd; short data;};
232
233 /*
234 * Commands for initializing Audio 1 for input (record)
235 */
236 static struct ess_command ess_i08m[] = /* input 8 bit mono */
237 { {0xb7, 0x51}, {0xb7, 0xd0}, {-1, 0} };
238 static struct ess_command ess_i16m[] = /* input 16 bit mono */
239 { {0xb7, 0x71}, {0xb7, 0xf4}, {-1, 0} };
240 static struct ess_command ess_i08s[] = /* input 8 bit stereo */
241 { {0xb7, 0x51}, {0xb7, 0x98}, {-1, 0} };
242 static struct ess_command ess_i16s[] = /* input 16 bit stereo */
243 { {0xb7, 0x71}, {0xb7, 0xbc}, {-1, 0} };
244
245 static struct ess_command *ess_inp_cmds[] =
246 { ess_i08m, ess_i16m, ess_i08s, ess_i16s };
247
248
249 /*
250 * Commands for initializing Audio 1 for output (playback)
251 */
252 static struct ess_command ess_o08m[] = /* output 8 bit mono */
253 { {0xb6, 0x80}, {0xb7, 0x51}, {0xb7, 0xd0}, {-1, 0} };
254 static struct ess_command ess_o16m[] = /* output 16 bit mono */
255 { {0xb6, 0x00}, {0xb7, 0x71}, {0xb7, 0xf4}, {-1, 0} };
256 static struct ess_command ess_o08s[] = /* output 8 bit stereo */
257 { {0xb6, 0x80}, {0xb7, 0x51}, {0xb7, 0x98}, {-1, 0} };
258 static struct ess_command ess_o16s[] = /* output 16 bit stereo */
259 { {0xb6, 0x00}, {0xb7, 0x71}, {0xb7, 0xbc}, {-1, 0} };
260
261 static struct ess_command *ess_out_cmds[] =
262 { ess_o08m, ess_o16m, ess_o08s, ess_o16s };
263
264 static void ess_exec_commands
265 (sb_devc *devc, struct ess_command *cmdtab[])
266 {
267 struct ess_command *cmd;
268
269 cmd = cmdtab [ ((devc->channels != 1) << 1) + (devc->bits != AFMT_U8) ];
270
271 while (cmd->cmd != -1) {
272 ess_write (devc, cmd->cmd, cmd->data);
273 cmd++;
274 }
275 }
276
277 static void ess_change
278 (sb_devc *devc, unsigned int reg, unsigned int mask, unsigned int val)
279 {
280 int value;
281
282 value = ess_read (devc, reg);
283 value = (value & ~mask) | (val & mask);
284 ess_write (devc, reg, value);
285 }
286
287 static void ess_set_output_parms
288 (int dev, unsigned long buf, int nr_bytes, int intrflag)
289 {
290 sb_devc *devc = audio_devs[dev]->devc;
291
292 if (devc->duplex) {
293 devc->trg_buf_16 = buf;
294 devc->trg_bytes_16 = nr_bytes;
295 devc->trg_intrflag_16 = intrflag;
296 devc->irq_mode_16 = IMODE_OUTPUT;
297 } else {
298 devc->trg_buf = buf;
299 devc->trg_bytes = nr_bytes;
300 devc->trg_intrflag = intrflag;
301 devc->irq_mode = IMODE_OUTPUT;
302 }
303 }
304
305 static void ess_set_input_parms
306 (int dev, unsigned long buf, int count, int intrflag)
307 {
308 sb_devc *devc = audio_devs[dev]->devc;
309
310 devc->trg_buf = buf;
311 devc->trg_bytes = count;
312 devc->trg_intrflag = intrflag;
313 devc->irq_mode = IMODE_INPUT;
314 }
315
316 static int ess_calc_div (int clock, int revert, int *speedp, int *diffp)
317 {
318 int divider;
319 int speed, diff;
320 int retval;
321
322 speed = *speedp;
323 divider = (clock + speed / 2) / speed;
324 retval = revert - divider;
325 if (retval > revert - 1) {
326 retval = revert - 1;
327 divider = revert - retval;
328 }
329 /* This line is suggested. Must be wrong I think
330 *speedp = (clock + divider / 2) / divider;
331 So I chose the next one */
332
333 *speedp = clock / divider;
334 diff = speed - *speedp;
335 if (diff < 0) diff =-diff;
336 *diffp = diff;
337
338 return retval;
339 }
340
341 static int ess_calc_best_speed
342 (int clock1, int rev1, int clock2, int rev2, int *divp, int *speedp)
343 {
344 int speed1 = *speedp, speed2 = *speedp;
345 int div1, div2;
346 int diff1, diff2;
347 int retval;
348
349 div1 = ess_calc_div (clock1, rev1, &speed1, &diff1);
350 div2 = ess_calc_div (clock2, rev2, &speed2, &diff2);
351
352 if (diff1 < diff2) {
353 *divp = div1;
354 *speedp = speed1;
355 retval = 1;
356 } else {
357 /* *divp = div2; */
358 *divp = 0x80 | div2;
359 *speedp = speed2;
360 retval = 2;
361 }
362
363 return retval;
364 }
365
366 /*
367 * Depending on the audiochannel ESS devices can
368 * have different clock settings. These are made consistent for duplex
369 * however.
370 * callers of ess_speed only do an audionum suggestion, which means
371 * input suggests 1, output suggests 2. This suggestion is only true
372 * however when doing duplex.
373 */
374 static void ess_common_speed (sb_devc *devc, int *speedp, int *divp)
375 {
376 int diff = 0, div;
377
378 if (devc->duplex) {
379 /*
380 * The 0x80 is important for the first audio channel
381 */
382 if (devc->submodel == SUBMDL_ES1888) {
383 div = 0x80 | ess_calc_div (795500, 256, speedp, &diff);
384 } else {
385 div = 0x80 | ess_calc_div (795500, 128, speedp, &diff);
386 }
387 } else if(devc->caps & SB_CAP_ES18XX_RATE) {
388 if (devc->submodel == SUBMDL_ES1888) {
389 ess_calc_best_speed(397700, 128, 795500, 256,
390 &div, speedp);
391 } else {
392 ess_calc_best_speed(ES18XX_CLOCK1, 128, ES18XX_CLOCK2, 256,
393 &div, speedp);
394 }
395 } else {
396 if (*speedp > 22000) {
397 div = 0x80 | ess_calc_div (ES1688_CLOCK1, 256, speedp, &diff);
398 } else {
399 div = 0x00 | ess_calc_div (ES1688_CLOCK2, 128, speedp, &diff);
400 }
401 }
402 *divp = div;
403 }
404
405 static void ess_speed (sb_devc *devc, int audionum)
406 {
407 int speed;
408 int div, div2;
409
410 ess_common_speed (devc, &(devc->speed), &div);
411
412 #ifdef FKS_REG_LOGGING
413 printk (KERN_INFO "FKS: ess_speed (%d) b speed = %d, div=%x\n", audionum, devc->speed, div);
414 #endif
415
416 /* Set filter roll-off to 90% of speed/2 */
417 speed = (devc->speed * 9) / 20;
418
419 div2 = 256 - 7160000 / (speed * 82);
420
421 if (!devc->duplex) audionum = 1;
422
423 if (audionum == 1) {
424 /* Change behaviour of register A1 *
425 sb_chg_mixer(devc, 0x71, 0x20, 0x20)
426 * For ES1869 only??? */
427 ess_write (devc, 0xa1, div);
428 ess_write (devc, 0xa2, div2);
429 } else {
430 ess_setmixer (devc, 0x70, div);
431 /*
432 * FKS: fascinating: 0x72 doesn't seem to work.
433 */
434 ess_write (devc, 0xa2, div2);
435 ess_setmixer (devc, 0x72, div2);
436 }
437 }
438
439 static int ess_audio_prepare_for_input(int dev, int bsize, int bcount)
440 {
441 sb_devc *devc = audio_devs[dev]->devc;
442
443 ess_speed(devc, 1);
444
445 sb_dsp_command(devc, DSP_CMD_SPKOFF);
446
447 ess_write (devc, 0xb8, 0x0e); /* Auto init DMA mode */
448 ess_change (devc, 0xa8, 0x03, 3 - devc->channels); /* Mono/stereo */
449 ess_write (devc, 0xb9, 2); /* Demand mode (4 bytes/DMA request) */
450
451 ess_exec_commands (devc, ess_inp_cmds);
452
453 ess_change (devc, 0xb1, 0xf0, 0x50);
454 ess_change (devc, 0xb2, 0xf0, 0x50);
455
456 devc->trigger_bits = 0;
457 return 0;
458 }
459
460 static int ess_audio_prepare_for_output_audio1 (int dev, int bsize, int bcount)
461 {
462 sb_devc *devc = audio_devs[dev]->devc;
463
464 sb_dsp_reset(devc);
465 ess_speed(devc, 1);
466 ess_write (devc, 0xb8, 4); /* Auto init DMA mode */
467 ess_change (devc, 0xa8, 0x03, 3 - devc->channels); /* Mono/stereo */
468 ess_write (devc, 0xb9, 2); /* Demand mode (4 bytes/request) */
469
470 ess_exec_commands (devc, ess_out_cmds);
471
472 ess_change (devc, 0xb1, 0xf0, 0x50); /* Enable DMA */
473 ess_change (devc, 0xb2, 0xf0, 0x50); /* Enable IRQ */
474
475 sb_dsp_command(devc, DSP_CMD_SPKON); /* There be sound! */
476
477 devc->trigger_bits = 0;
478 return 0;
479 }
480
481 static int ess_audio_prepare_for_output_audio2 (int dev, int bsize, int bcount)
482 {
483 sb_devc *devc = audio_devs[dev]->devc;
484 unsigned char bits;
485
486 /* FKS: qqq
487 sb_dsp_reset(devc);
488 */
489
490 /*
491 * Auto-Initialize:
492 * DMA mode + demand mode (8 bytes/request, yes I want it all!)
493 * But leave 16-bit DMA bit untouched!
494 */
495 ess_chgmixer (devc, 0x78, 0xd0, 0xd0);
496
497 ess_speed(devc, 2);
498
499 /* bits 4:3 on ES1887 represent recording source. Keep them! */
500 bits = ess_getmixer (devc, 0x7a) & 0x18;
501
502 /* Set stereo/mono */
503 if (devc->channels != 1) bits |= 0x02;
504
505 /* Init DACs; UNSIGNED mode for 8 bit; SIGNED mode for 16 bit */
506 if (devc->bits != AFMT_U8) bits |= 0x05; /* 16 bit */
507
508 /* Enable DMA, IRQ will be shared (hopefully)*/
509 bits |= 0x60;
510
511 ess_setmixer (devc, 0x7a, bits);
512
513 ess_mixer_reload (devc, SOUND_MIXER_PCM); /* There be sound! */
514
515 devc->trigger_bits = 0;
516 return 0;
517 }
518
519 static int ess_audio_prepare_for_output(int dev, int bsize, int bcount)
520 {
521 sb_devc *devc = audio_devs[dev]->devc;
522
523 #ifdef FKS_REG_LOGGING
524 printk(KERN_INFO "ess_audio_prepare_for_output: dma_out=%d,dma_in=%d\n"
525 , audio_devs[dev]->dmap_out->dma, audio_devs[dev]->dmap_in->dma);
526 #endif
527
528 if (devc->duplex) {
529 return ess_audio_prepare_for_output_audio2 (dev, bsize, bcount);
530 } else {
531 return ess_audio_prepare_for_output_audio1 (dev, bsize, bcount);
532 }
533 }
534
535 static void ess_audio_halt_xfer(int dev)
536 {
537 unsigned long flags;
538 sb_devc *devc = audio_devs[dev]->devc;
539
540 spin_lock_irqsave(&devc->lock, flags);
541 sb_dsp_reset(devc);
542 spin_unlock_irqrestore(&devc->lock, flags);
543
544 /*
545 * Audio 2 may still be operational! Creates awful sounds!
546 */
547 if (devc->duplex) ess_chgmixer(devc, 0x78, 0x03, 0x00);
548 }
549
550 static void ess_audio_start_input
551 (int dev, unsigned long buf, int nr_bytes, int intrflag)
552 {
553 int count = nr_bytes;
554 sb_devc *devc = audio_devs[dev]->devc;
555 short c = -nr_bytes;
556
557 /*
558 * Start a DMA input to the buffer pointed by dmaqtail
559 */
560
561 if (audio_devs[dev]->dmap_in->dma > 3) count >>= 1;
562 count--;
563
564 devc->irq_mode = IMODE_INPUT;
565
566 ess_write (devc, 0xa4, (unsigned char) ((unsigned short) c & 0xff));
567 ess_write (devc, 0xa5, (unsigned char) (((unsigned short) c >> 8) & 0xff));
568
569 ess_change (devc, 0xb8, 0x0f, 0x0f); /* Go */
570 devc->intr_active = 1;
571 }
572
573 static void ess_audio_output_block_audio1
574 (int dev, unsigned long buf, int nr_bytes, int intrflag)
575 {
576 int count = nr_bytes;
577 sb_devc *devc = audio_devs[dev]->devc;
578 short c = -nr_bytes;
579
580 if (audio_devs[dev]->dmap_out->dma > 3)
581 count >>= 1;
582 count--;
583
584 devc->irq_mode = IMODE_OUTPUT;
585
586 ess_write (devc, 0xa4, (unsigned char) ((unsigned short) c & 0xff));
587 ess_write (devc, 0xa5, (unsigned char) (((unsigned short) c >> 8) & 0xff));
588
589 ess_change (devc, 0xb8, 0x05, 0x05); /* Go */
590 devc->intr_active = 1;
591 }
592
593 static void ess_audio_output_block_audio2
594 (int dev, unsigned long buf, int nr_bytes, int intrflag)
595 {
596 int count = nr_bytes;
597 sb_devc *devc = audio_devs[dev]->devc;
598 short c = -nr_bytes;
599
600 if (audio_devs[dev]->dmap_out->dma > 3) count >>= 1;
601 count--;
602
603 ess_setmixer (devc, 0x74, (unsigned char) ((unsigned short) c & 0xff));
604 ess_setmixer (devc, 0x76, (unsigned char) (((unsigned short) c >> 8) & 0xff));
605 ess_chgmixer (devc, 0x78, 0x03, 0x03); /* Go */
606
607 devc->irq_mode_16 = IMODE_OUTPUT;
608 devc->intr_active_16 = 1;
609 }
610
611 static void ess_audio_output_block
612 (int dev, unsigned long buf, int nr_bytes, int intrflag)
613 {
614 sb_devc *devc = audio_devs[dev]->devc;
615
616 if (devc->duplex) {
617 ess_audio_output_block_audio2 (dev, buf, nr_bytes, intrflag);
618 } else {
619 ess_audio_output_block_audio1 (dev, buf, nr_bytes, intrflag);
620 }
621 }
622
623 /*
624 * FKS: the if-statements for both bits and bits_16 are quite alike.
625 * Combine this...
626 */
627 static void ess_audio_trigger(int dev, int bits)
628 {
629 sb_devc *devc = audio_devs[dev]->devc;
630
631 int bits_16 = bits & devc->irq_mode_16;
632 bits &= devc->irq_mode;
633
634 if (!bits && !bits_16) {
635 /* FKS oh oh.... wrong?? for dma 16? */
636 sb_dsp_command(devc, 0xd0); /* Halt DMA */
637 }
638
639 if (bits) {
640 switch (devc->irq_mode)
641 {
642 case IMODE_INPUT:
643 ess_audio_start_input(dev, devc->trg_buf, devc->trg_bytes,
644 devc->trg_intrflag);
645 break;
646
647 case IMODE_OUTPUT:
648 ess_audio_output_block(dev, devc->trg_buf, devc->trg_bytes,
649 devc->trg_intrflag);
650 break;
651 }
652 }
653
654 if (bits_16) {
655 switch (devc->irq_mode_16) {
656 case IMODE_INPUT:
657 ess_audio_start_input(dev, devc->trg_buf_16, devc->trg_bytes_16,
658 devc->trg_intrflag_16);
659 break;
660
661 case IMODE_OUTPUT:
662 ess_audio_output_block(dev, devc->trg_buf_16, devc->trg_bytes_16,
663 devc->trg_intrflag_16);
664 break;
665 }
666 }
667
668 devc->trigger_bits = bits | bits_16;
669 }
670
671 static int ess_audio_set_speed(int dev, int speed)
672 {
673 sb_devc *devc = audio_devs[dev]->devc;
674 int minspeed, maxspeed, dummydiv;
675
676 if (speed > 0) {
677 minspeed = (devc->duplex ? 6215 : 5000 );
678 maxspeed = (devc->duplex ? 44100 : 48000);
679 if (speed < minspeed) speed = minspeed;
680 if (speed > maxspeed) speed = maxspeed;
681
682 ess_common_speed (devc, &speed, &dummydiv);
683
684 devc->speed = speed;
685 }
686 return devc->speed;
687 }
688
689 /*
690 * FKS: This is a one-on-one copy of sb1_audio_set_bits
691 */
692 static unsigned int ess_audio_set_bits(int dev, unsigned int bits)
693 {
694 sb_devc *devc = audio_devs[dev]->devc;
695
696 if (bits != 0) {
697 if (bits == AFMT_U8 || bits == AFMT_S16_LE) {
698 devc->bits = bits;
699 } else {
700 devc->bits = AFMT_U8;
701 }
702 }
703
704 return devc->bits;
705 }
706
707 /*
708 * FKS: This is a one-on-one copy of sbpro_audio_set_channels
709 * (*) Modified it!!
710 */
711 static short ess_audio_set_channels(int dev, short channels)
712 {
713 sb_devc *devc = audio_devs[dev]->devc;
714
715 if (channels == 1 || channels == 2) devc->channels = channels;
716
717 return devc->channels;
718 }
719
720 static struct audio_driver ess_audio_driver = /* ESS ES688/1688 */
721 {
722 .owner = THIS_MODULE,
723 .open = sb_audio_open,
724 .close = sb_audio_close,
725 .output_block = ess_set_output_parms,
726 .start_input = ess_set_input_parms,
727 .prepare_for_input = ess_audio_prepare_for_input,
728 .prepare_for_output = ess_audio_prepare_for_output,
729 .halt_io = ess_audio_halt_xfer,
730 .trigger = ess_audio_trigger,
731 .set_speed = ess_audio_set_speed,
732 .set_bits = ess_audio_set_bits,
733 .set_channels = ess_audio_set_channels
734 };
735
736 /*
737 * ess_audio_init must be called from sb_audio_init
738 */
739 struct audio_driver *ess_audio_init
740 (sb_devc *devc, int *audio_flags, int *format_mask)
741 {
742 *audio_flags = DMA_AUTOMODE;
743 *format_mask |= AFMT_S16_LE;
744
745 if (devc->duplex) {
746 int tmp_dma;
747 /*
748 * sb_audio_init thinks dma8 is for playback and
749 * dma16 is for record. Not now! So swap them.
750 */
751 tmp_dma = devc->dma16;
752 devc->dma16 = devc->dma8;
753 devc->dma8 = tmp_dma;
754
755 *audio_flags |= DMA_DUPLEX;
756 }
757
758 return &ess_audio_driver;
759 }
760
761 /****************************************************************************
762 * *
763 * ESS common *
764 * *
765 ****************************************************************************/
766 static void ess_handle_channel
767 (char *channel, int dev, int intr_active, unsigned char flag, int irq_mode)
768 {
769 if (!intr_active || !flag) return;
770 #ifdef FKS_REG_LOGGING
771 printk(KERN_INFO "FKS: ess_handle_channel %s irq_mode=%d\n", channel, irq_mode);
772 #endif
773 switch (irq_mode) {
774 case IMODE_OUTPUT:
775 DMAbuf_outputintr (dev, 1);
776 break;
777
778 case IMODE_INPUT:
779 DMAbuf_inputintr (dev);
780 break;
781
782 case IMODE_INIT:
783 break;
784
785 default:;
786 /* printk(KERN_WARNING "ESS: Unexpected interrupt\n"); */
787 }
788 }
789
790 /*
791 * FKS: TODO!!! Finish this!
792 *
793 * I think midi stuff uses uart401, without interrupts.
794 * So IMODE_MIDI isn't a value for devc->irq_mode.
795 */
796 void ess_intr (sb_devc *devc)
797 {
798 int status;
799 unsigned char src;
800
801 if (devc->submodel == SUBMDL_ES1887) {
802 src = ess_getmixer (devc, 0x7f) >> 4;
803 } else {
804 src = 0xff;
805 }
806
807 #ifdef FKS_REG_LOGGING
808 printk(KERN_INFO "FKS: sbintr src=%x\n",(int)src);
809 #endif
810 ess_handle_channel
811 ( "Audio 1"
812 , devc->dev, devc->intr_active , src & 0x01, devc->irq_mode );
813 ess_handle_channel
814 ( "Audio 2"
815 , devc->dev, devc->intr_active_16, src & 0x02, devc->irq_mode_16);
816 /*
817 * Acknowledge interrupts
818 */
819 if (devc->submodel == SUBMDL_ES1887 && (src & 0x02)) {
820 ess_chgmixer (devc, 0x7a, 0x80, 0x00);
821 }
822
823 if (src & 0x01) {
824 status = inb(DSP_DATA_AVAIL);
825 }
826 }
827
828 static void ess_extended (sb_devc * devc)
829 {
830 /* Enable extended mode */
831
832 sb_dsp_command(devc, 0xc6);
833 }
834
835 static int ess_write (sb_devc * devc, unsigned char reg, unsigned char data)
836 {
837 #ifdef FKS_REG_LOGGING
838 printk(KERN_INFO "FKS: write reg %x: %x\n", reg, data);
839 #endif
840 /* Write a byte to an extended mode register of ES1688 */
841
842 if (!sb_dsp_command(devc, reg))
843 return 0;
844
845 return sb_dsp_command(devc, data);
846 }
847
848 static int ess_read (sb_devc * devc, unsigned char reg)
849 {
850 /* Read a byte from an extended mode register of ES1688 */
851
852 /* Read register command */
853 if (!sb_dsp_command(devc, 0xc0)) return -1;
854
855 if (!sb_dsp_command(devc, reg )) return -1;
856
857 return sb_dsp_get_byte(devc);
858 }
859
860 int ess_dsp_reset(sb_devc * devc)
861 {
862 int loopc;
863
864 #ifdef FKS_REG_LOGGING
865 printk(KERN_INFO "FKS: ess_dsp_reset 1\n");
866 ess_show_mixerregs (devc);
867 #endif
868
869 outb(3, DSP_RESET); /* Reset FIFO too */
870
871 udelay(10);
872 outb(0, DSP_RESET);
873 udelay(30);
874
875 for (loopc = 0; loopc < 1000 && !(inb(DSP_DATA_AVAIL) & 0x80); loopc++);
876
877 if (inb(DSP_READ) != 0xAA) {
878 DDB(printk("sb: No response to RESET\n"));
879 return 0; /* Sorry */
880 }
881 ess_extended (devc);
882
883 #ifdef FKS_LOGGING
884 printk(KERN_INFO "FKS: dsp_reset 2\n");
885 ess_show_mixerregs (devc);
886 #endif
887
888 return 1;
889 }
890
891 static int ess_irq_bits (int irq)
892 {
893 switch (irq) {
894 case 2:
895 case 9:
896 return 0;
897
898 case 5:
899 return 1;
900
901 case 7:
902 return 2;
903
904 case 10:
905 return 3;
906
907 default:
908 printk(KERN_ERR "ESS1688: Invalid IRQ %d\n", irq);
909 return -1;
910 }
911 }
912
913 /*
914 * Set IRQ configuration register for all ESS models
915 */
916 static int ess_common_set_irq_hw (sb_devc * devc)
917 {
918 int irq_bits;
919
920 if ((irq_bits = ess_irq_bits (devc->irq)) == -1) return 0;
921
922 if (!ess_write (devc, 0xb1, 0x50 | (irq_bits << 2))) {
923 printk(KERN_ERR "ES1688: Failed to write to IRQ config register\n");
924 return 0;
925 }
926 return 1;
927 }
928
929 /*
930 * I wanna use modern ES1887 mixer irq handling. Funny is the
931 * fact that my BIOS wants the same. But suppose someone's BIOS
932 * doesn't do this!
933 * This is independent of duplex. If there's a 1887 this will
934 * prevent it from going into 1888 mode.
935 */
936 static void ess_es1887_set_irq_hw (sb_devc * devc)
937 {
938 int irq_bits;
939
940 if ((irq_bits = ess_irq_bits (devc->irq)) == -1) return;
941
942 ess_chgmixer (devc, 0x7f, 0x0f, 0x01 | ((irq_bits + 1) << 1));
943 }
944
945 static int ess_set_irq_hw (sb_devc * devc)
946 {
947 if (devc->submodel == SUBMDL_ES1887) ess_es1887_set_irq_hw (devc);
948
949 return ess_common_set_irq_hw (devc);
950 }
951
952 #ifdef FKS_TEST
953
954 /*
955 * FKS_test:
956 * for ES1887: 00, 18, non wr bits: 0001 1000
957 * for ES1868: 00, b8, non wr bits: 1011 1000
958 * for ES1888: 00, f8, non wr bits: 1111 1000
959 * for ES1688: 00, f8, non wr bits: 1111 1000
960 * + ES968
961 */
962
963 static void FKS_test (sb_devc * devc)
964 {
965 int val1, val2;
966 val1 = ess_getmixer (devc, 0x64);
967 ess_setmixer (devc, 0x64, ~val1);
968 val2 = ess_getmixer (devc, 0x64) ^ ~val1;
969 ess_setmixer (devc, 0x64, val1);
970 val1 ^= ess_getmixer (devc, 0x64);
971 printk (KERN_INFO "FKS: FKS_test %02x, %02x\n", (val1 & 0x0ff), (val2 & 0x0ff));
972 };
973 #endif
974
975 static unsigned int ess_identify (sb_devc * devc)
976 {
977 unsigned int val;
978 unsigned long flags;
979
980 spin_lock_irqsave(&devc->lock, flags);
981 outb(((unsigned char) (0x40 & 0xff)), MIXER_ADDR);
982
983 udelay(20);
984 val = inb(MIXER_DATA) << 8;
985 udelay(20);
986 val |= inb(MIXER_DATA);
987 udelay(20);
988 spin_unlock_irqrestore(&devc->lock, flags);
989
990 return val;
991 }
992
993 /*
994 * ESS technology describes a detection scheme in their docs. It involves
995 * fiddling with the bits in certain mixer registers. ess_probe is supposed
996 * to help.
997 *
998 * FKS: tracing shows ess_probe writes wrong value to 0x64. Bit 3 reads 1, but
999 * should be written 0 only. Check this.
1000 */
1001 static int ess_probe (sb_devc * devc, int reg, int xorval)
1002 {
1003 int val1, val2, val3;
1004
1005 val1 = ess_getmixer (devc, reg);
1006 val2 = val1 ^ xorval;
1007 ess_setmixer (devc, reg, val2);
1008 val3 = ess_getmixer (devc, reg);
1009 ess_setmixer (devc, reg, val1);
1010
1011 return (val2 == val3);
1012 }
1013
1014 int ess_init(sb_devc * devc, struct address_info *hw_config)
1015 {
1016 unsigned char cfg;
1017 int ess_major = 0, ess_minor = 0;
1018 int i;
1019 static char name[100], modelname[10];
1020
1021 /*
1022 * Try to detect ESS chips.
1023 */
1024
1025 sb_dsp_command(devc, 0xe7); /* Return identification */
1026
1027 for (i = 1000; i; i--) {
1028 if (inb(DSP_DATA_AVAIL) & 0x80) {
1029 if (ess_major == 0) {
1030 ess_major = inb(DSP_READ);
1031 } else {
1032 ess_minor = inb(DSP_READ);
1033 break;
1034 }
1035 }
1036 }
1037
1038 if (ess_major == 0) return 0;
1039
1040 if (ess_major == 0x48 && (ess_minor & 0xf0) == 0x80) {
1041 sprintf(name, "ESS ES488 AudioDrive (rev %d)",
1042 ess_minor & 0x0f);
1043 hw_config->name = name;
1044 devc->model = MDL_SBPRO;
1045 return 1;
1046 }
1047
1048 /*
1049 * This the detection heuristic of ESS technology, though somewhat
1050 * changed to actually make it work.
1051 * This results in the following detection steps:
1052 * - distinct between ES688 and ES1688+ (as always done in this driver)
1053 * if ES688 we're ready
1054 * - try to detect ES1868, ES1869 or ES1878 (ess_identify)
1055 * if successful we're ready
1056 * - try to detect ES1888, ES1887 or ES1788 (aim: detect ES1887)
1057 * if successful we're ready
1058 * - Dunno. Must be 1688. Will do in general
1059 *
1060 * This is the most BETA part of the software: Will the detection
1061 * always work?
1062 */
1063 devc->model = MDL_ESS;
1064 devc->submodel = ess_minor & 0x0f;
1065
1066 if (ess_major == 0x68 && (ess_minor & 0xf0) == 0x80) {
1067 char *chip = NULL;
1068 int submodel = -1;
1069
1070 switch (devc->sbmo.esstype) {
1071 case ESSTYPE_DETECT:
1072 case ESSTYPE_LIKE20:
1073 break;
1074 case 688:
1075 submodel = 0x00;
1076 break;
1077 case 1688:
1078 submodel = 0x08;
1079 break;
1080 case 1868:
1081 submodel = SUBMDL_ES1868;
1082 break;
1083 case 1869:
1084 submodel = SUBMDL_ES1869;
1085 break;
1086 case 1788:
1087 submodel = SUBMDL_ES1788;
1088 break;
1089 case 1878:
1090 submodel = SUBMDL_ES1878;
1091 break;
1092 case 1879:
1093 submodel = SUBMDL_ES1879;
1094 break;
1095 case 1887:
1096 submodel = SUBMDL_ES1887;
1097 break;
1098 case 1888:
1099 submodel = SUBMDL_ES1888;
1100 break;
1101 default:
1102 printk (KERN_ERR "Invalid esstype=%d specified\n", devc->sbmo.esstype);
1103 return 0;
1104 }
1105 if (submodel != -1) {
1106 devc->submodel = submodel;
1107 sprintf (modelname, "ES%d", devc->sbmo.esstype);
1108 chip = modelname;
1109 }
1110 if (chip == NULL && (ess_minor & 0x0f) < 8) {
1111 chip = "ES688";
1112 }
1113 #ifdef FKS_TEST
1114 FKS_test (devc);
1115 #endif
1116 /*
1117 * If Nothing detected yet, and we want 2.0 behaviour...
1118 * Then let's assume it's ES1688.
1119 */
1120 if (chip == NULL && devc->sbmo.esstype == ESSTYPE_LIKE20) {
1121 chip = "ES1688";
1122 }
1123
1124 if (chip == NULL) {
1125 int type;
1126
1127 type = ess_identify (devc);
1128
1129 switch (type) {
1130 case 0x1868:
1131 chip = "ES1868";
1132 devc->submodel = SUBMDL_ES1868;
1133 break;
1134 case 0x1869:
1135 chip = "ES1869";
1136 devc->submodel = SUBMDL_ES1869;
1137 break;
1138 case 0x1878:
1139 chip = "ES1878";
1140 devc->submodel = SUBMDL_ES1878;
1141 break;
1142 case 0x1879:
1143 chip = "ES1879";
1144 devc->submodel = SUBMDL_ES1879;
1145 break;
1146 default:
1147 if ((type & 0x00ff) != ((type >> 8) & 0x00ff)) {
1148 printk ("ess_init: Unrecognized %04x\n", type);
1149 }
1150 }
1151 }
1152 #if 0
1153 /*
1154 * this one failed:
1155 * the probing of bit 4 is another thought: from ES1788 and up, all
1156 * chips seem to have hardware volume control. Bit 4 is readonly to
1157 * check if a hardware volume interrupt has fired.
1158 * Cause ES688/ES1688 don't have this feature, bit 4 might be writeable
1159 * for these chips.
1160 */
1161 if (chip == NULL && !ess_probe(devc, 0x64, (1 << 4))) {
1162 #endif
1163 /*
1164 * the probing of bit 2 is my idea. The ES1887 docs want me to probe
1165 * bit 3. This results in ES1688 being detected as ES1788.
1166 * Bit 2 is for "Enable HWV IRQE", but as ES(1)688 chips don't have
1167 * HardWare Volume, I think they don't have this IRQE.
1168 */
1169 if (chip == NULL && ess_probe(devc, 0x64, (1 << 2))) {
1170 if (ess_probe (devc, 0x70, 0x7f)) {
1171 if (ess_probe (devc, 0x64, (1 << 5))) {
1172 chip = "ES1887";
1173 devc->submodel = SUBMDL_ES1887;
1174 } else {
1175 chip = "ES1888";
1176 devc->submodel = SUBMDL_ES1888;
1177 }
1178 } else {
1179 chip = "ES1788";
1180 devc->submodel = SUBMDL_ES1788;
1181 }
1182 }
1183 if (chip == NULL) {
1184 chip = "ES1688";
1185 }
1186
1187 printk(KERN_INFO "ESS chip %s %s%s\n", chip,
1188 (devc->sbmo.esstype == ESSTYPE_DETECT ||
1189 devc->sbmo.esstype == ESSTYPE_LIKE20) ?
1190 "detected" : "specified",
1191 devc->sbmo.esstype == ESSTYPE_LIKE20 ?
1192 " (kernel 2.0 compatible)" : "");
1193
1194 sprintf(name,"ESS %s AudioDrive (rev %d)", chip, ess_minor & 0x0f);
1195 } else {
1196 strcpy(name, "Jazz16");
1197 }
1198
1199 /* AAS: info stolen from ALSA: these boards have different clocks */
1200 switch(devc->submodel) {
1201 /* APPARENTLY NOT 1869 AND 1887
1202 case SUBMDL_ES1869:
1203 case SUBMDL_ES1887:
1204 */
1205 case SUBMDL_ES1888:
1206 devc->caps |= SB_CAP_ES18XX_RATE;
1207 break;
1208 }
1209
1210 hw_config->name = name;
1211 /* FKS: sb_dsp_reset to enable extended mode???? */
1212 sb_dsp_reset(devc); /* Turn on extended mode */
1213
1214 /*
1215 * Enable joystick and OPL3
1216 */
1217 cfg = ess_getmixer (devc, 0x40);
1218 ess_setmixer (devc, 0x40, cfg | 0x03);
1219 if (devc->submodel >= 8) { /* ES1688 */
1220 devc->caps |= SB_NO_MIDI; /* ES1688 uses MPU401 MIDI mode */
1221 }
1222 sb_dsp_reset (devc);
1223
1224 /*
1225 * This is important! If it's not done, the IRQ probe in sb_dsp_init
1226 * may fail.
1227 */
1228 return ess_set_irq_hw (devc);
1229 }
1230
1231 static int ess_set_dma_hw(sb_devc * devc)
1232 {
1233 unsigned char cfg, dma_bits = 0, dma16_bits;
1234 int dma;
1235
1236 #ifdef FKS_LOGGING
1237 printk(KERN_INFO "ess_set_dma_hw: dma8=%d,dma16=%d,dup=%d\n"
1238 , devc->dma8, devc->dma16, devc->duplex);
1239 #endif
1240
1241 /*
1242 * FKS: It seems as if this duplex flag isn't set yet. Check it.
1243 */
1244 dma = devc->dma8;
1245
1246 if (dma > 3 || dma < 0 || dma == 2) {
1247 dma_bits = 0;
1248 printk(KERN_ERR "ESS1688: Invalid DMA8 %d\n", dma);
1249 return 0;
1250 } else {
1251 /* Extended mode DMA enable */
1252 cfg = 0x50;
1253
1254 if (dma == 3) {
1255 dma_bits = 3;
1256 } else {
1257 dma_bits = dma + 1;
1258 }
1259 }
1260
1261 if (!ess_write (devc, 0xb2, cfg | (dma_bits << 2))) {
1262 printk(KERN_ERR "ESS1688: Failed to write to DMA config register\n");
1263 return 0;
1264 }
1265
1266 if (devc->duplex) {
1267 dma = devc->dma16;
1268 dma16_bits = 0;
1269
1270 if (dma >= 0) {
1271 switch (dma) {
1272 case 0:
1273 dma_bits = 0x04;
1274 break;
1275 case 1:
1276 dma_bits = 0x05;
1277 break;
1278 case 3:
1279 dma_bits = 0x06;
1280 break;
1281 case 5:
1282 dma_bits = 0x07;
1283 dma16_bits = 0x20;
1284 break;
1285 default:
1286 printk(KERN_ERR "ESS1887: Invalid DMA16 %d\n", dma);
1287 return 0;
1288 }
1289 ess_chgmixer (devc, 0x78, 0x20, dma16_bits);
1290 ess_chgmixer (devc, 0x7d, 0x07, dma_bits);
1291 }
1292 }
1293 return 1;
1294 }
1295
1296 /*
1297 * This one is called from sb_dsp_init.
1298 *
1299 * Return values:
1300 * 0: Failed
1301 * 1: Succeeded or doesn't apply (not SUBMDL_ES1887)
1302 */
1303 int ess_dsp_init (sb_devc *devc, struct address_info *hw_config)
1304 {
1305 /*
1306 * Caller also checks this, but anyway
1307 */
1308 if (devc->model != MDL_ESS) {
1309 printk (KERN_INFO "ess_dsp_init for non ESS chip\n");
1310 return 1;
1311 }
1312 /*
1313 * This for ES1887 to run Full Duplex. Actually ES1888
1314 * is allowed to do so too. I have no idea yet if this
1315 * will work for ES1888 however.
1316 *
1317 * For SB16 having both dma8 and dma16 means enable
1318 * Full Duplex. Let's try this for ES1887 too
1319 *
1320 */
1321 if (devc->submodel == SUBMDL_ES1887) {
1322 if (hw_config->dma2 != -1) {
1323 devc->dma16 = hw_config->dma2;
1324 }
1325 /*
1326 * devc->duplex initialization is put here, cause
1327 * ess_set_dma_hw needs it.
1328 */
1329 if (devc->dma8 != devc->dma16 && devc->dma16 != -1) {
1330 devc->duplex = 1;
1331 }
1332 }
1333 if (!ess_set_dma_hw (devc)) {
1334 free_irq(devc->irq, devc);
1335 return 0;
1336 }
1337 return 1;
1338 }
1339
1340 /****************************************************************************
1341 * *
1342 * ESS mixer *
1343 * *
1344 ****************************************************************************/
1345
1346 #define ES688_RECORDING_DEVICES \
1347 ( SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD )
1348 #define ES688_MIXER_DEVICES \
1349 ( SOUND_MASK_SYNTH | SOUND_MASK_PCM | SOUND_MASK_LINE \
1350 | SOUND_MASK_MIC | SOUND_MASK_CD | SOUND_MASK_VOLUME \
1351 | SOUND_MASK_LINE2 | SOUND_MASK_SPEAKER )
1352
1353 #define ES1688_RECORDING_DEVICES \
1354 ( ES688_RECORDING_DEVICES )
1355 #define ES1688_MIXER_DEVICES \
1356 ( ES688_MIXER_DEVICES | SOUND_MASK_RECLEV )
1357
1358 #define ES1887_RECORDING_DEVICES \
1359 ( ES1688_RECORDING_DEVICES | SOUND_MASK_LINE2 | SOUND_MASK_SYNTH)
1360 #define ES1887_MIXER_DEVICES \
1361 ( ES1688_MIXER_DEVICES )
1362
1363 /*
1364 * Mixer registers of ES1887
1365 *
1366 * These registers specifically take care of recording levels. To make the
1367 * mapping from playback devices to recording devices every recording
1368 * devices = playback device + ES_REC_MIXER_RECDIFF
1369 */
1370 #define ES_REC_MIXER_RECBASE (SOUND_MIXER_LINE3 + 1)
1371 #define ES_REC_MIXER_RECDIFF (ES_REC_MIXER_RECBASE - SOUND_MIXER_SYNTH)
1372
1373 #define ES_REC_MIXER_RECSYNTH (SOUND_MIXER_SYNTH + ES_REC_MIXER_RECDIFF)
1374 #define ES_REC_MIXER_RECPCM (SOUND_MIXER_PCM + ES_REC_MIXER_RECDIFF)
1375 #define ES_REC_MIXER_RECSPEAKER (SOUND_MIXER_SPEAKER + ES_REC_MIXER_RECDIFF)
1376 #define ES_REC_MIXER_RECLINE (SOUND_MIXER_LINE + ES_REC_MIXER_RECDIFF)
1377 #define ES_REC_MIXER_RECMIC (SOUND_MIXER_MIC + ES_REC_MIXER_RECDIFF)
1378 #define ES_REC_MIXER_RECCD (SOUND_MIXER_CD + ES_REC_MIXER_RECDIFF)
1379 #define ES_REC_MIXER_RECIMIX (SOUND_MIXER_IMIX + ES_REC_MIXER_RECDIFF)
1380 #define ES_REC_MIXER_RECALTPCM (SOUND_MIXER_ALTPCM + ES_REC_MIXER_RECDIFF)
1381 #define ES_REC_MIXER_RECRECLEV (SOUND_MIXER_RECLEV + ES_REC_MIXER_RECDIFF)
1382 #define ES_REC_MIXER_RECIGAIN (SOUND_MIXER_IGAIN + ES_REC_MIXER_RECDIFF)
1383 #define ES_REC_MIXER_RECOGAIN (SOUND_MIXER_OGAIN + ES_REC_MIXER_RECDIFF)
1384 #define ES_REC_MIXER_RECLINE1 (SOUND_MIXER_LINE1 + ES_REC_MIXER_RECDIFF)
1385 #define ES_REC_MIXER_RECLINE2 (SOUND_MIXER_LINE2 + ES_REC_MIXER_RECDIFF)
1386 #define ES_REC_MIXER_RECLINE3 (SOUND_MIXER_LINE3 + ES_REC_MIXER_RECDIFF)
1387
1388 static mixer_tab es688_mix = {
1389 MIX_ENT(SOUND_MIXER_VOLUME, 0x32, 7, 4, 0x32, 3, 4),
1390 MIX_ENT(SOUND_MIXER_BASS, 0x00, 0, 0, 0x00, 0, 0),
1391 MIX_ENT(SOUND_MIXER_TREBLE, 0x00, 0, 0, 0x00, 0, 0),
1392 MIX_ENT(SOUND_MIXER_SYNTH, 0x36, 7, 4, 0x36, 3, 4),
1393 MIX_ENT(SOUND_MIXER_PCM, 0x14, 7, 4, 0x14, 3, 4),
1394 MIX_ENT(SOUND_MIXER_SPEAKER, 0x3c, 2, 3, 0x00, 0, 0),
1395 MIX_ENT(SOUND_MIXER_LINE, 0x3e, 7, 4, 0x3e, 3, 4),
1396 MIX_ENT(SOUND_MIXER_MIC, 0x1a, 7, 4, 0x1a, 3, 4),
1397 MIX_ENT(SOUND_MIXER_CD, 0x38, 7, 4, 0x38, 3, 4),
1398 MIX_ENT(SOUND_MIXER_IMIX, 0x00, 0, 0, 0x00, 0, 0),
1399 MIX_ENT(SOUND_MIXER_ALTPCM, 0x00, 0, 0, 0x00, 0, 0),
1400 MIX_ENT(SOUND_MIXER_RECLEV, 0x00, 0, 0, 0x00, 0, 0),
1401 MIX_ENT(SOUND_MIXER_IGAIN, 0x00, 0, 0, 0x00, 0, 0),
1402 MIX_ENT(SOUND_MIXER_OGAIN, 0x00, 0, 0, 0x00, 0, 0),
1403 MIX_ENT(SOUND_MIXER_LINE1, 0x00, 0, 0, 0x00, 0, 0),
1404 MIX_ENT(SOUND_MIXER_LINE2, 0x3a, 7, 4, 0x3a, 3, 4),
1405 MIX_ENT(SOUND_MIXER_LINE3, 0x00, 0, 0, 0x00, 0, 0)
1406 };
1407
1408 /*
1409 * The ES1688 specifics... hopefully correct...
1410 * - 6 bit master volume
1411 * I was wrong, ES1888 docs say ES1688 didn't have it.
1412 * - RECLEV control
1413 * These may apply to ES688 too. I have no idea.
1414 */
1415 static mixer_tab es1688_mix = {
1416 MIX_ENT(SOUND_MIXER_VOLUME, 0x32, 7, 4, 0x32, 3, 4),
1417 MIX_ENT(SOUND_MIXER_BASS, 0x00, 0, 0, 0x00, 0, 0),
1418 MIX_ENT(SOUND_MIXER_TREBLE, 0x00, 0, 0, 0x00, 0, 0),
1419 MIX_ENT(SOUND_MIXER_SYNTH, 0x36, 7, 4, 0x36, 3, 4),
1420 MIX_ENT(SOUND_MIXER_PCM, 0x14, 7, 4, 0x14, 3, 4),
1421 MIX_ENT(SOUND_MIXER_SPEAKER, 0x3c, 2, 3, 0x00, 0, 0),
1422 MIX_ENT(SOUND_MIXER_LINE, 0x3e, 7, 4, 0x3e, 3, 4),
1423 MIX_ENT(SOUND_MIXER_MIC, 0x1a, 7, 4, 0x1a, 3, 4),
1424 MIX_ENT(SOUND_MIXER_CD, 0x38, 7, 4, 0x38, 3, 4),
1425 MIX_ENT(SOUND_MIXER_IMIX, 0x00, 0, 0, 0x00, 0, 0),
1426 MIX_ENT(SOUND_MIXER_ALTPCM, 0x00, 0, 0, 0x00, 0, 0),
1427 MIX_ENT(SOUND_MIXER_RECLEV, 0xb4, 7, 4, 0xb4, 3, 4),
1428 MIX_ENT(SOUND_MIXER_IGAIN, 0x00, 0, 0, 0x00, 0, 0),
1429 MIX_ENT(SOUND_MIXER_OGAIN, 0x00, 0, 0, 0x00, 0, 0),
1430 MIX_ENT(SOUND_MIXER_LINE1, 0x00, 0, 0, 0x00, 0, 0),
1431 MIX_ENT(SOUND_MIXER_LINE2, 0x3a, 7, 4, 0x3a, 3, 4),
1432 MIX_ENT(SOUND_MIXER_LINE3, 0x00, 0, 0, 0x00, 0, 0)
1433 };
1434
1435 static mixer_tab es1688later_mix = {
1436 MIX_ENT(SOUND_MIXER_VOLUME, 0x60, 5, 6, 0x62, 5, 6),
1437 MIX_ENT(SOUND_MIXER_BASS, 0x00, 0, 0, 0x00, 0, 0),
1438 MIX_ENT(SOUND_MIXER_TREBLE, 0x00, 0, 0, 0x00, 0, 0),
1439 MIX_ENT(SOUND_MIXER_SYNTH, 0x36, 7, 4, 0x36, 3, 4),
1440 MIX_ENT(SOUND_MIXER_PCM, 0x14, 7, 4, 0x14, 3, 4),
1441 MIX_ENT(SOUND_MIXER_SPEAKER, 0x3c, 2, 3, 0x00, 0, 0),
1442 MIX_ENT(SOUND_MIXER_LINE, 0x3e, 7, 4, 0x3e, 3, 4),
1443 MIX_ENT(SOUND_MIXER_MIC, 0x1a, 7, 4, 0x1a, 3, 4),
1444 MIX_ENT(SOUND_MIXER_CD, 0x38, 7, 4, 0x38, 3, 4),
1445 MIX_ENT(SOUND_MIXER_IMIX, 0x00, 0, 0, 0x00, 0, 0),
1446 MIX_ENT(SOUND_MIXER_ALTPCM, 0x00, 0, 0, 0x00, 0, 0),
1447 MIX_ENT(SOUND_MIXER_RECLEV, 0xb4, 7, 4, 0xb4, 3, 4),
1448 MIX_ENT(SOUND_MIXER_IGAIN, 0x00, 0, 0, 0x00, 0, 0),
1449 MIX_ENT(SOUND_MIXER_OGAIN, 0x00, 0, 0, 0x00, 0, 0),
1450 MIX_ENT(SOUND_MIXER_LINE1, 0x00, 0, 0, 0x00, 0, 0),
1451 MIX_ENT(SOUND_MIXER_LINE2, 0x3a, 7, 4, 0x3a, 3, 4),
1452 MIX_ENT(SOUND_MIXER_LINE3, 0x00, 0, 0, 0x00, 0, 0)
1453 };
1454
1455 /*
1456 * This one is for all ESS chips with a record mixer.
1457 * It's not used (yet) however
1458 */
1459 static mixer_tab es_rec_mix = {
1460 MIX_ENT(SOUND_MIXER_VOLUME, 0x60, 5, 6, 0x62, 5, 6),
1461 MIX_ENT(SOUND_MIXER_BASS, 0x00, 0, 0, 0x00, 0, 0),
1462 MIX_ENT(SOUND_MIXER_TREBLE, 0x00, 0, 0, 0x00, 0, 0),
1463 MIX_ENT(SOUND_MIXER_SYNTH, 0x36, 7, 4, 0x36, 3, 4),
1464 MIX_ENT(SOUND_MIXER_PCM, 0x14, 7, 4, 0x14, 3, 4),
1465 MIX_ENT(SOUND_MIXER_SPEAKER, 0x3c, 2, 3, 0x00, 0, 0),
1466 MIX_ENT(SOUND_MIXER_LINE, 0x3e, 7, 4, 0x3e, 3, 4),
1467 MIX_ENT(SOUND_MIXER_MIC, 0x1a, 7, 4, 0x1a, 3, 4),
1468 MIX_ENT(SOUND_MIXER_CD, 0x38, 7, 4, 0x38, 3, 4),
1469 MIX_ENT(SOUND_MIXER_IMIX, 0x00, 0, 0, 0x00, 0, 0),
1470 MIX_ENT(SOUND_MIXER_ALTPCM, 0x00, 0, 0, 0x00, 0, 0),
1471 MIX_ENT(SOUND_MIXER_RECLEV, 0xb4, 7, 4, 0xb4, 3, 4),
1472 MIX_ENT(SOUND_MIXER_IGAIN, 0x00, 0, 0, 0x00, 0, 0),
1473 MIX_ENT(SOUND_MIXER_OGAIN, 0x00, 0, 0, 0x00, 0, 0),
1474 MIX_ENT(SOUND_MIXER_LINE1, 0x00, 0, 0, 0x00, 0, 0),
1475 MIX_ENT(SOUND_MIXER_LINE2, 0x3a, 7, 4, 0x3a, 3, 4),
1476 MIX_ENT(SOUND_MIXER_LINE3, 0x00, 0, 0, 0x00, 0, 0),
1477 MIX_ENT(ES_REC_MIXER_RECSYNTH, 0x6b, 7, 4, 0x6b, 3, 4),
1478 MIX_ENT(ES_REC_MIXER_RECPCM, 0x00, 0, 0, 0x00, 0, 0),
1479 MIX_ENT(ES_REC_MIXER_RECSPEAKER, 0x00, 0, 0, 0x00, 0, 0),
1480 MIX_ENT(ES_REC_MIXER_RECLINE, 0x6e, 7, 4, 0x6e, 3, 4),
1481 MIX_ENT(ES_REC_MIXER_RECMIC, 0x68, 7, 4, 0x68, 3, 4),
1482 MIX_ENT(ES_REC_MIXER_RECCD, 0x6a, 7, 4, 0x6a, 3, 4),
1483 MIX_ENT(ES_REC_MIXER_RECIMIX, 0x00, 0, 0, 0x00, 0, 0),
1484 MIX_ENT(ES_REC_MIXER_RECALTPCM, 0x00, 0, 0, 0x00, 0, 0),
1485 MIX_ENT(ES_REC_MIXER_RECRECLEV, 0x00, 0, 0, 0x00, 0, 0),
1486 MIX_ENT(ES_REC_MIXER_RECIGAIN, 0x00, 0, 0, 0x00, 0, 0),
1487 MIX_ENT(ES_REC_MIXER_RECOGAIN, 0x00, 0, 0, 0x00, 0, 0),
1488 MIX_ENT(ES_REC_MIXER_RECLINE1, 0x00, 0, 0, 0x00, 0, 0),
1489 MIX_ENT(ES_REC_MIXER_RECLINE2, 0x6c, 7, 4, 0x6c, 3, 4),
1490 MIX_ENT(ES_REC_MIXER_RECLINE3, 0x00, 0, 0, 0x00, 0, 0)
1491 };
1492
1493 /*
1494 * This one is for ES1887. It's little different from es_rec_mix: it
1495 * has 0x7c for PCM playback level. This is because ES1887 uses
1496 * Audio 2 for playback.
1497 */
1498 static mixer_tab es1887_mix = {
1499 MIX_ENT(SOUND_MIXER_VOLUME, 0x60, 5, 6, 0x62, 5, 6),
1500 MIX_ENT(SOUND_MIXER_BASS, 0x00, 0, 0, 0x00, 0, 0),
1501 MIX_ENT(SOUND_MIXER_TREBLE, 0x00, 0, 0, 0x00, 0, 0),
1502 MIX_ENT(SOUND_MIXER_SYNTH, 0x36, 7, 4, 0x36, 3, 4),
1503 MIX_ENT(SOUND_MIXER_PCM, 0x7c, 7, 4, 0x7c, 3, 4),
1504 MIX_ENT(SOUND_MIXER_SPEAKER, 0x3c, 2, 3, 0x00, 0, 0),
1505 MIX_ENT(SOUND_MIXER_LINE, 0x3e, 7, 4, 0x3e, 3, 4),
1506 MIX_ENT(SOUND_MIXER_MIC, 0x1a, 7, 4, 0x1a, 3, 4),
1507 MIX_ENT(SOUND_MIXER_CD, 0x38, 7, 4, 0x38, 3, 4),
1508 MIX_ENT(SOUND_MIXER_IMIX, 0x00, 0, 0, 0x00, 0, 0),
1509 MIX_ENT(SOUND_MIXER_ALTPCM, 0x00, 0, 0, 0x00, 0, 0),
1510 MIX_ENT(SOUND_MIXER_RECLEV, 0xb4, 7, 4, 0xb4, 3, 4),
1511 MIX_ENT(SOUND_MIXER_IGAIN, 0x00, 0, 0, 0x00, 0, 0),
1512 MIX_ENT(SOUND_MIXER_OGAIN, 0x00, 0, 0, 0x00, 0, 0),
1513 MIX_ENT(SOUND_MIXER_LINE1, 0x00, 0, 0, 0x00, 0, 0),
1514 MIX_ENT(SOUND_MIXER_LINE2, 0x3a, 7, 4, 0x3a, 3, 4),
1515 MIX_ENT(SOUND_MIXER_LINE3, 0x00, 0, 0, 0x00, 0, 0),
1516 MIX_ENT(ES_REC_MIXER_RECSYNTH, 0x6b, 7, 4, 0x6b, 3, 4),
1517 MIX_ENT(ES_REC_MIXER_RECPCM, 0x00, 0, 0, 0x00, 0, 0),
1518 MIX_ENT(ES_REC_MIXER_RECSPEAKER, 0x00, 0, 0, 0x00, 0, 0),
1519 MIX_ENT(ES_REC_MIXER_RECLINE, 0x6e, 7, 4, 0x6e, 3, 4),
1520 MIX_ENT(ES_REC_MIXER_RECMIC, 0x68, 7, 4, 0x68, 3, 4),
1521 MIX_ENT(ES_REC_MIXER_RECCD, 0x6a, 7, 4, 0x6a, 3, 4),
1522 MIX_ENT(ES_REC_MIXER_RECIMIX, 0x00, 0, 0, 0x00, 0, 0),
1523 MIX_ENT(ES_REC_MIXER_RECALTPCM, 0x00, 0, 0, 0x00, 0, 0),
1524 MIX_ENT(ES_REC_MIXER_RECRECLEV, 0x00, 0, 0, 0x00, 0, 0),
1525 MIX_ENT(ES_REC_MIXER_RECIGAIN, 0x00, 0, 0, 0x00, 0, 0),
1526 MIX_ENT(ES_REC_MIXER_RECOGAIN, 0x00, 0, 0, 0x00, 0, 0),
1527 MIX_ENT(ES_REC_MIXER_RECLINE1, 0x00, 0, 0, 0x00, 0, 0),
1528 MIX_ENT(ES_REC_MIXER_RECLINE2, 0x6c, 7, 4, 0x6c, 3, 4),
1529 MIX_ENT(ES_REC_MIXER_RECLINE3, 0x00, 0, 0, 0x00, 0, 0)
1530 };
1531
1532 static int ess_has_rec_mixer (int submodel)
1533 {
1534 switch (submodel) {
1535 case SUBMDL_ES1887:
1536 return 1;
1537 default:
1538 return 0;
1539 }
1540 };
1541
1542 #ifdef FKS_LOGGING
1543 static int ess_mixer_mon_regs[]
1544 = { 0x70, 0x71, 0x72, 0x74, 0x76, 0x78, 0x7a, 0x7c, 0x7d, 0x7f
1545 , 0xa1, 0xa2, 0xa4, 0xa5, 0xa8, 0xa9
1546 , 0xb1, 0xb2, 0xb4, 0xb5, 0xb6, 0xb7, 0xb9
1547 , 0x00};
1548
1549 static void ess_show_mixerregs (sb_devc *devc)
1550 {
1551 int *mp = ess_mixer_mon_regs;
1552
1553 return;
1554
1555 while (*mp != 0) {
1556 printk (KERN_INFO "res (%x)=%x\n", *mp, (int)(ess_getmixer (devc, *mp)));
1557 mp++;
1558 }
1559 }
1560 #endif
1561
1562 void ess_setmixer (sb_devc * devc, unsigned int port, unsigned int value)
1563 {
1564 unsigned long flags;
1565
1566 #ifdef FKS_LOGGING
1567 printk(KERN_INFO "FKS: write mixer %x: %x\n", port, value);
1568 #endif
1569
1570 spin_lock_irqsave(&devc->lock, flags);
1571 if (port >= 0xa0) {
1572 ess_write (devc, port, value);
1573 } else {
1574 outb(((unsigned char) (port & 0xff)), MIXER_ADDR);
1575
1576 udelay(20);
1577 outb(((unsigned char) (value & 0xff)), MIXER_DATA);
1578 udelay(20);
1579 }
1580 spin_unlock_irqrestore(&devc->lock, flags);
1581 }
1582
1583 unsigned int ess_getmixer (sb_devc * devc, unsigned int port)
1584 {
1585 unsigned int val;
1586 unsigned long flags;
1587
1588 spin_lock_irqsave(&devc->lock, flags);
1589
1590 if (port >= 0xa0) {
1591 val = ess_read (devc, port);
1592 } else {
1593 outb(((unsigned char) (port & 0xff)), MIXER_ADDR);
1594
1595 udelay(20);
1596 val = inb(MIXER_DATA);
1597 udelay(20);
1598 }
1599 spin_unlock_irqrestore(&devc->lock, flags);
1600
1601 return val;
1602 }
1603
1604 static void ess_chgmixer
1605 (sb_devc * devc, unsigned int reg, unsigned int mask, unsigned int val)
1606 {
1607 int value;
1608
1609 value = ess_getmixer (devc, reg);
1610 value = (value & ~mask) | (val & mask);
1611 ess_setmixer (devc, reg, value);
1612 }
1613
1614 /*
1615 * ess_mixer_init must be called from sb_mixer_init
1616 */
1617 void ess_mixer_init (sb_devc * devc)
1618 {
1619 devc->mixer_caps = SOUND_CAP_EXCL_INPUT;
1620
1621 /*
1622 * Take care of ES1887 specifics...
1623 */
1624 switch (devc->submodel) {
1625 case SUBMDL_ES1887:
1626 devc->supported_devices = ES1887_MIXER_DEVICES;
1627 devc->supported_rec_devices = ES1887_RECORDING_DEVICES;
1628 #ifdef FKS_LOGGING
1629 printk (KERN_INFO "FKS: ess_mixer_init dup = %d\n", devc->duplex);
1630 #endif
1631 if (devc->duplex) {
1632 devc->iomap = &es1887_mix;
1633 devc->iomap_sz = ARRAY_SIZE(es1887_mix);
1634 } else {
1635 devc->iomap = &es_rec_mix;
1636 devc->iomap_sz = ARRAY_SIZE(es_rec_mix);
1637 }
1638 break;
1639 default:
1640 if (devc->submodel < 8) {
1641 devc->supported_devices = ES688_MIXER_DEVICES;
1642 devc->supported_rec_devices = ES688_RECORDING_DEVICES;
1643 devc->iomap = &es688_mix;
1644 devc->iomap_sz = ARRAY_SIZE(es688_mix);
1645 } else {
1646 /*
1647 * es1688 has 4 bits master vol.
1648 * later chips have 6 bits (?)
1649 */
1650 devc->supported_devices = ES1688_MIXER_DEVICES;
1651 devc->supported_rec_devices = ES1688_RECORDING_DEVICES;
1652 if (devc->submodel < 0x10) {
1653 devc->iomap = &es1688_mix;
1654 devc->iomap_sz = ARRAY_SIZE(es688_mix);
1655 } else {
1656 devc->iomap = &es1688later_mix;
1657 devc->iomap_sz = ARRAY_SIZE(es1688later_mix);
1658 }
1659 }
1660 }
1661 }
1662
1663 /*
1664 * Changing playback levels at an ESS chip with record mixer means having to
1665 * take care of recording levels of recorded inputs (devc->recmask) too!
1666 */
1667 int ess_mixer_set(sb_devc *devc, int dev, int left, int right)
1668 {
1669 if (ess_has_rec_mixer (devc->submodel) && (devc->recmask & (1 << dev))) {
1670 sb_common_mixer_set (devc, dev + ES_REC_MIXER_RECDIFF, left, right);
1671 }
1672 return sb_common_mixer_set (devc, dev, left, right);
1673 }
1674
1675 /*
1676 * After a sb_dsp_reset extended register 0xb4 (RECLEV) is reset too. After
1677 * sb_dsp_reset RECLEV has to be restored. This is where ess_mixer_reload
1678 * helps.
1679 */
1680 void ess_mixer_reload (sb_devc *devc, int dev)
1681 {
1682 int left, right, value;
1683
1684 value = devc->levels[dev];
1685 left = value & 0x000000ff;
1686 right = (value & 0x0000ff00) >> 8;
1687
1688 sb_common_mixer_set(devc, dev, left, right);
1689 }
1690
1691 static int es_rec_set_recmask(sb_devc * devc, int mask)
1692 {
1693 int i, i_mask, cur_mask, diff_mask;
1694 int value, left, right;
1695
1696 #ifdef FKS_LOGGING
1697 printk (KERN_INFO "FKS: es_rec_set_recmask mask = %x\n", mask);
1698 #endif
1699 /*
1700 * Changing the recmask on an ESS chip with recording mixer means:
1701 * (1) Find the differences
1702 * (2) For "turned-on" inputs: make the recording level the playback level
1703 * (3) For "turned-off" inputs: make the recording level zero
1704 */
1705 cur_mask = devc->recmask;
1706 diff_mask = (cur_mask ^ mask);
1707
1708 for (i = 0; i < 32; i++) {
1709 i_mask = (1 << i);
1710 if (diff_mask & i_mask) { /* Difference? (1) */
1711 if (mask & i_mask) { /* Turn it on (2) */
1712 value = devc->levels[i];
1713 left = value & 0x000000ff;
1714 right = (value & 0x0000ff00) >> 8;
1715 } else { /* Turn it off (3) */
1716 left = 0;
1717 right = 0;
1718 }
1719 sb_common_mixer_set(devc, i + ES_REC_MIXER_RECDIFF, left, right);
1720 }
1721 }
1722 return mask;
1723 }
1724
1725 int ess_set_recmask(sb_devc * devc, int *mask)
1726 {
1727 /* This applies to ESS chips with record mixers only! */
1728
1729 if (ess_has_rec_mixer (devc->submodel)) {
1730 *mask = es_rec_set_recmask (devc, *mask);
1731 return 1; /* Applied */
1732 } else {
1733 return 0; /* Not applied */
1734 }
1735 }
1736
1737 /*
1738 * ess_mixer_reset must be called from sb_mixer_reset
1739 */
1740 int ess_mixer_reset (sb_devc * devc)
1741 {
1742 /*
1743 * Separate actions for ESS chips with a record mixer:
1744 */
1745 if (ess_has_rec_mixer (devc->submodel)) {
1746 switch (devc->submodel) {
1747 case SUBMDL_ES1887:
1748 /*
1749 * Separate actions for ES1887:
1750 * Change registers 7a and 1c to make the record mixer the
1751 * actual recording source.
1752 */
1753 ess_chgmixer(devc, 0x7a, 0x18, 0x08);
1754 ess_chgmixer(devc, 0x1c, 0x07, 0x07);
1755 break;
1756 }
1757 /*
1758 * Call set_recmask for proper initialization
1759 */
1760 devc->recmask = devc->supported_rec_devices;
1761 es_rec_set_recmask(devc, 0);
1762 devc->recmask = 0;
1763
1764 return 1; /* We took care of recmask. */
1765 } else {
1766 return 0; /* We didn't take care; caller do it */
1767 }
1768 }
1769
1770 /****************************************************************************
1771 * *
1772 * ESS midi *
1773 * *
1774 ****************************************************************************/
1775
1776 /*
1777 * FKS: IRQ may be shared. Hm. And if so? Then What?
1778 */
1779 int ess_midi_init(sb_devc * devc, struct address_info *hw_config)
1780 {
1781 unsigned char cfg, tmp;
1782
1783 cfg = ess_getmixer (devc, 0x40) & 0x03;
1784
1785 if (devc->submodel < 8) {
1786 ess_setmixer (devc, 0x40, cfg | 0x03); /* Enable OPL3 & joystick */
1787 return 0; /* ES688 doesn't support MPU401 mode */
1788 }
1789 tmp = (hw_config->io_base & 0x0f0) >> 4;
1790
1791 if (tmp > 3) {
1792 ess_setmixer (devc, 0x40, cfg);
1793 return 0;
1794 }
1795 cfg |= tmp << 3;
1796
1797 tmp = 1; /* MPU enabled without interrupts */
1798
1799 /* May be shared: if so the value is -ve */
1800
1801 switch (abs(hw_config->irq)) {
1802 case 9:
1803 tmp = 0x4;
1804 break;
1805 case 5:
1806 tmp = 0x5;
1807 break;
1808 case 7:
1809 tmp = 0x6;
1810 break;
1811 case 10:
1812 tmp = 0x7;
1813 break;
1814 default:
1815 return 0;
1816 }
1817
1818 cfg |= tmp << 5;
1819 ess_setmixer (devc, 0x40, cfg | 0x03);
1820
1821 return 1;
1822 }
1823
Linux with added FPC-III support