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