Eric Lee / smarc-ti-linux-kernel

Download as
Browse Code ยป

Commit 3342b9680fbd6535f65148f5e95e581bc75be9cc

Authored by Julia Lawall
Committed by Takashi Iwai
1 parent 335e3b8687
Exists in master and in 20 other branches dlt-processor-sdk-linux-03.00.00.04, newt-ti-linux-3.12.y, processor-sdk-linux-01.00.00, processor-sdk-linux-02.00.01, smarc-ti-linux-3.12.10, smarc-ti-linux-3.12.y, smarc-ti-linux-3.14.y, smarc-ti-linux-3.15.y, smarc-ti-lsk-linux-4.1.y, smarct3x-processor-sdk-04.01.00.06, smarct3x-processor-sdk-linux-02.00.01, smarct3x-processor-sdk-linux-03.00.00.04, smarct4x-800-processor-sdk-linux-02.00.01, smarct4x-processor-sdk-04.01.00.06, smarct4x-processor-sdk-linux-02.00.01, smarct4x-processor-sdk-linux-03.00.00.04, ti-linux-3.12.y, ti-linux-3.14.y, ti-linux-3.15.y, ti-lsk-linux-4.1.y

sound/oss/sb_ess.c: delete double assignment 

Delete successive assignments to the same location.

A simplified version of the semantic match that finds this problem is as
follows: (http://coccinelle.lip6.fr/)

// <smpl>
@@
expression i;
@@

*i = ...;
 i = ...;
// </smpl>

Signed-off-by: Julia Lawall <julia@diku.dk>
Signed-off-by: Takashi Iwai <tiwai@suse.de>

Showing 1 changed file with 0 additions and 1 deletions Inline Diff

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