Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
1da177e4 LT |
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 | |
d6e05edc AM |
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 | |
1da177e4 LT |
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 | * | |
d6e05edc AM |
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. | |
1da177e4 | 112 | * Well, the assumption about ES1869 was wrong: register 0x70 is very much |
d6e05edc | 113 | * like register 0xa1, except that bit 7 is always 1, whatever you want |
1da177e4 LT |
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 | |
d6e05edc AM |
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. | |
1da177e4 | 123 | * |
d6e05edc | 124 | * Received the news that ES1688 is detected as a ES1788. Did some thinking: |
1da177e4 LT |
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 | |
d6e05edc | 139 | * a (preliminary ??) datasheet on ES1887. Its aim is to identify ES1887, but |
1da177e4 LT |
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 | |
d6e05edc | 160 | * its recording level was loud, and it couldn't be changed. The fact that |
1da177e4 | 161 | * internal register 0xb4 could take care of RECLEV, didn't work meaning until |
d6e05edc | 162 | * its value was restored every time the chip was reset; this reset the |
1da177e4 LT |
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 | |
25985edc | 172 | * levels. Furthermore several devices can be recorded together (which is not |
d6e05edc | 173 | * possible with the ES1688). |
1da177e4 | 174 | * Besides the separate recording level control for each input, the common |
d6e05edc | 175 | * recording level can also be controlled by RECLEV as described above. |
1da177e4 LT |
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; | |
e214e518 | 608 | devc->intr_active_16 = 1; |
1da177e4 LT |
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:; | |
f702cf46 | 786 | /* printk(KERN_WARNING "ESS: Unexpected interrupt\n"); */ |
1da177e4 LT |
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 | ||
1da177e4 LT |
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 | ||
1da177e4 LT |
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; | |
395d9dd5 | 1104 | } |
1da177e4 LT |
1105 | if (submodel != -1) { |
1106 | devc->submodel = submodel; | |
1107 | sprintf (modelname, "ES%d", devc->sbmo.esstype); | |
1108 | chip = modelname; | |
395d9dd5 | 1109 | } |
1da177e4 LT |
1110 | if (chip == NULL && (ess_minor & 0x0f) < 8) { |
1111 | chip = "ES688"; | |
395d9dd5 | 1112 | } |
1da177e4 LT |
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"; | |
395d9dd5 | 1122 | } |
1da177e4 LT |
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 | } | |
395d9dd5 PST |
1150 | } |
1151 | } | |
1da177e4 LT |
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 | } | |
395d9dd5 | 1182 | } |
1da177e4 LT |
1183 | if (chip == NULL) { |
1184 | chip = "ES1688"; | |
395d9dd5 | 1185 | } |
1da177e4 | 1186 | |
e214e518 DC |
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)" : ""); | |
1da177e4 LT |
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; | |
395d9dd5 | 1288 | } |
1da177e4 LT |
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; | |
1d198f26 | 1539 | } |
1da177e4 LT |
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); | |
395d9dd5 | 1579 | } |
1da177e4 LT |
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) */ | |
1da177e4 LT |
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; | |
395d9dd5 | 1756 | } |
1da177e4 LT |
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 |