diff options
48 files changed, 9544 insertions, 2215 deletions
diff --git a/Documentation/sound/alsa/ALSA-Configuration.txt b/Documentation/sound/alsa/ALSA-Configuration.txt index 50a59860ceed..8923597bd2bd 100644 --- a/Documentation/sound/alsa/ALSA-Configuration.txt +++ b/Documentation/sound/alsa/ALSA-Configuration.txt | |||
@@ -798,6 +798,9 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. | |||
798 | setup before initializing the codecs. This option is | 798 | setup before initializing the codecs. This option is |
799 | available only when CONFIG_SND_HDA_PATCH_LOADER=y is set. | 799 | available only when CONFIG_SND_HDA_PATCH_LOADER=y is set. |
800 | See HD-Audio.txt for details. | 800 | See HD-Audio.txt for details. |
801 | beep_mode - Selects the beep registration mode (0=off, 1=on, 2= | ||
802 | dynamic registration via mute switch on/off); the default | ||
803 | value is set via CONFIG_SND_HDA_INPUT_BEEP_MODE kconfig. | ||
801 | 804 | ||
802 | [Single (global) options] | 805 | [Single (global) options] |
803 | single_cmd - Use single immediate commands to communicate with | 806 | single_cmd - Use single immediate commands to communicate with |
diff --git a/Documentation/sound/alsa/HD-Audio-Models.txt b/Documentation/sound/alsa/HD-Audio-Models.txt index 4c7f9aee5c4e..9000cd84d076 100644 --- a/Documentation/sound/alsa/HD-Audio-Models.txt +++ b/Documentation/sound/alsa/HD-Audio-Models.txt | |||
@@ -391,6 +391,7 @@ STAC92HD83* | |||
391 | ref Reference board | 391 | ref Reference board |
392 | mic-ref Reference board with power management for ports | 392 | mic-ref Reference board with power management for ports |
393 | dell-s14 Dell laptop | 393 | dell-s14 Dell laptop |
394 | hp HP laptops with (inverted) mute-LED | ||
394 | auto BIOS setup (default) | 395 | auto BIOS setup (default) |
395 | 396 | ||
396 | STAC9872 | 397 | STAC9872 |
diff --git a/include/sound/ak4113.h b/include/sound/ak4113.h new file mode 100644 index 000000000000..8988edae1609 --- /dev/null +++ b/include/sound/ak4113.h | |||
@@ -0,0 +1,321 @@ | |||
1 | #ifndef __SOUND_AK4113_H | ||
2 | #define __SOUND_AK4113_H | ||
3 | |||
4 | /* | ||
5 | * Routines for Asahi Kasei AK4113 | ||
6 | * Copyright (c) by Jaroslav Kysela <perex@perex.cz>, | ||
7 | * Copyright (c) by Pavel Hofman <pavel.hofman@ivitera.com>, | ||
8 | * | ||
9 | * | ||
10 | * This program is free software; you can redistribute it and/or modify | ||
11 | * it under the terms of the GNU General Public License as published by | ||
12 | * the Free Software Foundation; either version 2 of the License, or | ||
13 | * (at your option) any later version. | ||
14 | * | ||
15 | * This program is distributed in the hope that it will be useful, | ||
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
18 | * GNU General Public License for more details. | ||
19 | * | ||
20 | * You should have received a copy of the GNU General Public License | ||
21 | * along with this program; if not, write to the Free Software | ||
22 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
23 | * | ||
24 | */ | ||
25 | |||
26 | /* AK4113 registers */ | ||
27 | /* power down */ | ||
28 | #define AK4113_REG_PWRDN 0x00 | ||
29 | /* format control */ | ||
30 | #define AK4113_REG_FORMAT 0x01 | ||
31 | /* input/output control */ | ||
32 | #define AK4113_REG_IO0 0x02 | ||
33 | /* input/output control */ | ||
34 | #define AK4113_REG_IO1 0x03 | ||
35 | /* interrupt0 mask */ | ||
36 | #define AK4113_REG_INT0_MASK 0x04 | ||
37 | /* interrupt1 mask */ | ||
38 | #define AK4113_REG_INT1_MASK 0x05 | ||
39 | /* DAT mask & DTS select */ | ||
40 | #define AK4113_REG_DATDTS 0x06 | ||
41 | /* receiver status 0 */ | ||
42 | #define AK4113_REG_RCS0 0x07 | ||
43 | /* receiver status 1 */ | ||
44 | #define AK4113_REG_RCS1 0x08 | ||
45 | /* receiver status 2 */ | ||
46 | #define AK4113_REG_RCS2 0x09 | ||
47 | /* RX channel status byte 0 */ | ||
48 | #define AK4113_REG_RXCSB0 0x0a | ||
49 | /* RX channel status byte 1 */ | ||
50 | #define AK4113_REG_RXCSB1 0x0b | ||
51 | /* RX channel status byte 2 */ | ||
52 | #define AK4113_REG_RXCSB2 0x0c | ||
53 | /* RX channel status byte 3 */ | ||
54 | #define AK4113_REG_RXCSB3 0x0d | ||
55 | /* RX channel status byte 4 */ | ||
56 | #define AK4113_REG_RXCSB4 0x0e | ||
57 | /* burst preamble Pc byte 0 */ | ||
58 | #define AK4113_REG_Pc0 0x0f | ||
59 | /* burst preamble Pc byte 1 */ | ||
60 | #define AK4113_REG_Pc1 0x10 | ||
61 | /* burst preamble Pd byte 0 */ | ||
62 | #define AK4113_REG_Pd0 0x11 | ||
63 | /* burst preamble Pd byte 1 */ | ||
64 | #define AK4113_REG_Pd1 0x12 | ||
65 | /* Q-subcode address + control */ | ||
66 | #define AK4113_REG_QSUB_ADDR 0x13 | ||
67 | /* Q-subcode track */ | ||
68 | #define AK4113_REG_QSUB_TRACK 0x14 | ||
69 | /* Q-subcode index */ | ||
70 | #define AK4113_REG_QSUB_INDEX 0x15 | ||
71 | /* Q-subcode minute */ | ||
72 | #define AK4113_REG_QSUB_MINUTE 0x16 | ||
73 | /* Q-subcode second */ | ||
74 | #define AK4113_REG_QSUB_SECOND 0x17 | ||
75 | /* Q-subcode frame */ | ||
76 | #define AK4113_REG_QSUB_FRAME 0x18 | ||
77 | /* Q-subcode zero */ | ||
78 | #define AK4113_REG_QSUB_ZERO 0x19 | ||
79 | /* Q-subcode absolute minute */ | ||
80 | #define AK4113_REG_QSUB_ABSMIN 0x1a | ||
81 | /* Q-subcode absolute second */ | ||
82 | #define AK4113_REG_QSUB_ABSSEC 0x1b | ||
83 | /* Q-subcode absolute frame */ | ||
84 | #define AK4113_REG_QSUB_ABSFRM 0x1c | ||
85 | |||
86 | /* sizes */ | ||
87 | #define AK4113_REG_RXCSB_SIZE ((AK4113_REG_RXCSB4-AK4113_REG_RXCSB0)+1) | ||
88 | #define AK4113_REG_QSUB_SIZE ((AK4113_REG_QSUB_ABSFRM-AK4113_REG_QSUB_ADDR)\ | ||
89 | +1) | ||
90 | |||
91 | #define AK4113_WRITABLE_REGS (AK4113_REG_DATDTS + 1) | ||
92 | |||
93 | /* AK4113_REG_PWRDN bits */ | ||
94 | /* Channel Status Select */ | ||
95 | #define AK4113_CS12 (1<<7) | ||
96 | /* Block Start & C/U Output Mode */ | ||
97 | #define AK4113_BCU (1<<6) | ||
98 | /* Master Clock Operation Select */ | ||
99 | #define AK4113_CM1 (1<<5) | ||
100 | /* Master Clock Operation Select */ | ||
101 | #define AK4113_CM0 (1<<4) | ||
102 | /* Master Clock Frequency Select */ | ||
103 | #define AK4113_OCKS1 (1<<3) | ||
104 | /* Master Clock Frequency Select */ | ||
105 | #define AK4113_OCKS0 (1<<2) | ||
106 | /* 0 = power down, 1 = normal operation */ | ||
107 | #define AK4113_PWN (1<<1) | ||
108 | /* 0 = reset & initialize (except thisregister), 1 = normal operation */ | ||
109 | #define AK4113_RST (1<<0) | ||
110 | |||
111 | /* AK4113_REQ_FORMAT bits */ | ||
112 | /* V/TX Output select: 0 = Validity Flag Output, 1 = TX */ | ||
113 | #define AK4113_VTX (1<<7) | ||
114 | /* Audio Data Control */ | ||
115 | #define AK4113_DIF2 (1<<6) | ||
116 | /* Audio Data Control */ | ||
117 | #define AK4113_DIF1 (1<<5) | ||
118 | /* Audio Data Control */ | ||
119 | #define AK4113_DIF0 (1<<4) | ||
120 | /* Deemphasis Autodetect Enable (1 = enable) */ | ||
121 | #define AK4113_DEAU (1<<3) | ||
122 | /* 32kHz-48kHz Deemphasis Control */ | ||
123 | #define AK4113_DEM1 (1<<2) | ||
124 | /* 32kHz-48kHz Deemphasis Control */ | ||
125 | #define AK4113_DEM0 (1<<1) | ||
126 | #define AK4113_DEM_OFF (AK4113_DEM0) | ||
127 | #define AK4113_DEM_44KHZ (0) | ||
128 | #define AK4113_DEM_48KHZ (AK4113_DEM1) | ||
129 | #define AK4113_DEM_32KHZ (AK4113_DEM0|AK4113_DEM1) | ||
130 | /* STDO: 16-bit, right justified */ | ||
131 | #define AK4113_DIF_16R (0) | ||
132 | /* STDO: 18-bit, right justified */ | ||
133 | #define AK4113_DIF_18R (AK4113_DIF0) | ||
134 | /* STDO: 20-bit, right justified */ | ||
135 | #define AK4113_DIF_20R (AK4113_DIF1) | ||
136 | /* STDO: 24-bit, right justified */ | ||
137 | #define AK4113_DIF_24R (AK4113_DIF1|AK4113_DIF0) | ||
138 | /* STDO: 24-bit, left justified */ | ||
139 | #define AK4113_DIF_24L (AK4113_DIF2) | ||
140 | /* STDO: I2S */ | ||
141 | #define AK4113_DIF_24I2S (AK4113_DIF2|AK4113_DIF0) | ||
142 | /* STDO: 24-bit, left justified; LRCLK, BICK = Input */ | ||
143 | #define AK4113_DIF_I24L (AK4113_DIF2|AK4113_DIF1) | ||
144 | /* STDO: I2S; LRCLK, BICK = Input */ | ||
145 | #define AK4113_DIF_I24I2S (AK4113_DIF2|AK4113_DIF1|AK4113_DIF0) | ||
146 | |||
147 | /* AK4113_REG_IO0 */ | ||
148 | /* XTL1=0,XTL0=0 -> 11.2896Mhz; XTL1=0,XTL0=1 -> 12.288Mhz */ | ||
149 | #define AK4113_XTL1 (1<<6) | ||
150 | /* XTL1=1,XTL0=0 -> 24.576Mhz; XTL1=1,XTL0=1 -> use channel status */ | ||
151 | #define AK4113_XTL0 (1<<5) | ||
152 | /* Block Start Signal Output: 0 = U-bit, 1 = C-bit (req. BCU = 1) */ | ||
153 | #define AK4113_UCE (1<<4) | ||
154 | /* TX Output Enable (1 = enable) */ | ||
155 | #define AK4113_TXE (1<<3) | ||
156 | /* Output Through Data Selector for TX pin */ | ||
157 | #define AK4113_OPS2 (1<<2) | ||
158 | /* Output Through Data Selector for TX pin */ | ||
159 | #define AK4113_OPS1 (1<<1) | ||
160 | /* Output Through Data Selector for TX pin */ | ||
161 | #define AK4113_OPS0 (1<<0) | ||
162 | /* 11.2896 MHz ref. Xtal freq. */ | ||
163 | #define AK4113_XTL_11_2896M (0) | ||
164 | /* 12.288 MHz ref. Xtal freq. */ | ||
165 | #define AK4113_XTL_12_288M (AK4113_XTL0) | ||
166 | /* 24.576 MHz ref. Xtal freq. */ | ||
167 | #define AK4113_XTL_24_576M (AK4113_XTL1) | ||
168 | |||
169 | /* AK4113_REG_IO1 */ | ||
170 | /* Interrupt 0 pin Hold */ | ||
171 | #define AK4113_EFH1 (1<<7) | ||
172 | /* Interrupt 0 pin Hold */ | ||
173 | #define AK4113_EFH0 (1<<6) | ||
174 | #define AK4113_EFH_512LRCLK (0) | ||
175 | #define AK4113_EFH_1024LRCLK (AK4113_EFH0) | ||
176 | #define AK4113_EFH_2048LRCLK (AK4113_EFH1) | ||
177 | #define AK4113_EFH_4096LRCLK (AK4113_EFH1|AK4113_EFH0) | ||
178 | /* PLL Lock Time: 0 = 384/fs, 1 = 1/fs */ | ||
179 | #define AK4113_FAST (1<<5) | ||
180 | /* MCKO2 Output Select: 0 = CMx/OCKSx, 1 = Xtal */ | ||
181 | #define AK4113_XMCK (1<<4) | ||
182 | /* MCKO2 Output Freq. Select: 0 = x1, 1 = x0.5 (req. XMCK = 1) */ | ||
183 | #define AK4113_DIV (1<<3) | ||
184 | /* Input Recovery Data Select */ | ||
185 | #define AK4113_IPS2 (1<<2) | ||
186 | /* Input Recovery Data Select */ | ||
187 | #define AK4113_IPS1 (1<<1) | ||
188 | /* Input Recovery Data Select */ | ||
189 | #define AK4113_IPS0 (1<<0) | ||
190 | #define AK4113_IPS(x) ((x)&7) | ||
191 | |||
192 | /* AK4113_REG_INT0_MASK && AK4113_REG_INT1_MASK*/ | ||
193 | /* mask enable for QINT bit */ | ||
194 | #define AK4113_MQI (1<<7) | ||
195 | /* mask enable for AUTO bit */ | ||
196 | #define AK4113_MAUT (1<<6) | ||
197 | /* mask enable for CINT bit */ | ||
198 | #define AK4113_MCIT (1<<5) | ||
199 | /* mask enable for UNLOCK bit */ | ||
200 | #define AK4113_MULK (1<<4) | ||
201 | /* mask enable for V bit */ | ||
202 | #define AK4113_V (1<<3) | ||
203 | /* mask enable for STC bit */ | ||
204 | #define AK4113_STC (1<<2) | ||
205 | /* mask enable for AUDN bit */ | ||
206 | #define AK4113_MAN (1<<1) | ||
207 | /* mask enable for PAR bit */ | ||
208 | #define AK4113_MPR (1<<0) | ||
209 | |||
210 | /* AK4113_REG_DATDTS */ | ||
211 | /* DAT Start ID Counter */ | ||
212 | #define AK4113_DCNT (1<<4) | ||
213 | /* DTS-CD 16-bit Sync Word Detect */ | ||
214 | #define AK4113_DTS16 (1<<3) | ||
215 | /* DTS-CD 14-bit Sync Word Detect */ | ||
216 | #define AK4113_DTS14 (1<<2) | ||
217 | /* mask enable for DAT bit (if 1, no INT1 effect */ | ||
218 | #define AK4113_MDAT1 (1<<1) | ||
219 | /* mask enable for DAT bit (if 1, no INT0 effect */ | ||
220 | #define AK4113_MDAT0 (1<<0) | ||
221 | |||
222 | /* AK4113_REG_RCS0 */ | ||
223 | /* Q-subcode buffer interrupt, 0 = no change, 1 = changed */ | ||
224 | #define AK4113_QINT (1<<7) | ||
225 | /* Non-PCM or DTS stream auto detection, 0 = no detect, 1 = detect */ | ||
226 | #define AK4113_AUTO (1<<6) | ||
227 | /* channel status buffer interrupt, 0 = no change, 1 = change */ | ||
228 | #define AK4113_CINT (1<<5) | ||
229 | /* PLL lock status, 0 = lock, 1 = unlock */ | ||
230 | #define AK4113_UNLCK (1<<4) | ||
231 | /* Validity bit, 0 = valid, 1 = invalid */ | ||
232 | #define AK4113_V (1<<3) | ||
233 | /* sampling frequency or Pre-emphasis change, 0 = no detect, 1 = detect */ | ||
234 | #define AK4113_STC (1<<2) | ||
235 | /* audio bit output, 0 = audio, 1 = non-audio */ | ||
236 | #define AK4113_AUDION (1<<1) | ||
237 | /* parity error or biphase error status, 0 = no error, 1 = error */ | ||
238 | #define AK4113_PAR (1<<0) | ||
239 | |||
240 | /* AK4113_REG_RCS1 */ | ||
241 | /* sampling frequency detection */ | ||
242 | #define AK4113_FS3 (1<<7) | ||
243 | #define AK4113_FS2 (1<<6) | ||
244 | #define AK4113_FS1 (1<<5) | ||
245 | #define AK4113_FS0 (1<<4) | ||
246 | /* Pre-emphasis detect, 0 = OFF, 1 = ON */ | ||
247 | #define AK4113_PEM (1<<3) | ||
248 | /* DAT Start ID Detect, 0 = no detect, 1 = detect */ | ||
249 | #define AK4113_DAT (1<<2) | ||
250 | /* DTS-CD bit audio stream detect, 0 = no detect, 1 = detect */ | ||
251 | #define AK4113_DTSCD (1<<1) | ||
252 | /* Non-PCM bit stream detection, 0 = no detect, 1 = detect */ | ||
253 | #define AK4113_NPCM (1<<0) | ||
254 | #define AK4113_FS_8000HZ (AK4113_FS3|AK4113_FS0) | ||
255 | #define AK4113_FS_11025HZ (AK4113_FS2|AK4113_FS0) | ||
256 | #define AK4113_FS_16000HZ (AK4113_FS2|AK4113_FS1|AK4113_FS0) | ||
257 | #define AK4113_FS_22050HZ (AK4113_FS2) | ||
258 | #define AK4113_FS_24000HZ (AK4113_FS2|AK4113_FS1) | ||
259 | #define AK4113_FS_32000HZ (AK4113_FS1|AK4113_FS0) | ||
260 | #define AK4113_FS_44100HZ (0) | ||
261 | #define AK4113_FS_48000HZ (AK4113_FS1) | ||
262 | #define AK4113_FS_64000HZ (AK4113_FS3|AK4113_FS1|AK4113_FS0) | ||
263 | #define AK4113_FS_88200HZ (AK4113_FS3) | ||
264 | #define AK4113_FS_96000HZ (AK4113_FS3|AK4113_FS1) | ||
265 | #define AK4113_FS_176400HZ (AK4113_FS3|AK4113_FS2) | ||
266 | #define AK4113_FS_192000HZ (AK4113_FS3|AK4113_FS2|AK4113_FS1) | ||
267 | |||
268 | /* AK4113_REG_RCS2 */ | ||
269 | /* CRC for Q-subcode, 0 = no error, 1 = error */ | ||
270 | #define AK4113_QCRC (1<<1) | ||
271 | /* CRC for channel status, 0 = no error, 1 = error */ | ||
272 | #define AK4113_CCRC (1<<0) | ||
273 | |||
274 | /* flags for snd_ak4113_check_rate_and_errors() */ | ||
275 | #define AK4113_CHECK_NO_STAT (1<<0) /* no statistics */ | ||
276 | #define AK4113_CHECK_NO_RATE (1<<1) /* no rate check */ | ||
277 | |||
278 | #define AK4113_CONTROLS 13 | ||
279 | |||
280 | typedef void (ak4113_write_t)(void *private_data, unsigned char addr, | ||
281 | unsigned char data); | ||
282 | typedef unsigned char (ak4113_read_t)(void *private_data, unsigned char addr); | ||
283 | |||
284 | struct ak4113 { | ||
285 | struct snd_card *card; | ||
286 | ak4113_write_t *write; | ||
287 | ak4113_read_t *read; | ||
288 | void *private_data; | ||
289 | unsigned int init:1; | ||
290 | spinlock_t lock; | ||
291 | unsigned char regmap[AK4113_WRITABLE_REGS]; | ||
292 | struct snd_kcontrol *kctls[AK4113_CONTROLS]; | ||
293 | struct snd_pcm_substream *substream; | ||
294 | unsigned long parity_errors; | ||
295 | unsigned long v_bit_errors; | ||
296 | unsigned long qcrc_errors; | ||
297 | unsigned long ccrc_errors; | ||
298 | unsigned char rcs0; | ||
299 | unsigned char rcs1; | ||
300 | unsigned char rcs2; | ||
301 | struct delayed_work work; | ||
302 | unsigned int check_flags; | ||
303 | void *change_callback_private; | ||
304 | void (*change_callback)(struct ak4113 *ak4113, unsigned char c0, | ||
305 | unsigned char c1); | ||
306 | }; | ||
307 | |||
308 | int snd_ak4113_create(struct snd_card *card, ak4113_read_t *read, | ||
309 | ak4113_write_t *write, | ||
310 | const unsigned char pgm[AK4113_WRITABLE_REGS], | ||
311 | void *private_data, struct ak4113 **r_ak4113); | ||
312 | void snd_ak4113_reg_write(struct ak4113 *ak4113, unsigned char reg, | ||
313 | unsigned char mask, unsigned char val); | ||
314 | void snd_ak4113_reinit(struct ak4113 *ak4113); | ||
315 | int snd_ak4113_build(struct ak4113 *ak4113, | ||
316 | struct snd_pcm_substream *capture_substream); | ||
317 | int snd_ak4113_external_rate(struct ak4113 *ak4113); | ||
318 | int snd_ak4113_check_rate_and_errors(struct ak4113 *ak4113, unsigned int flags); | ||
319 | |||
320 | #endif /* __SOUND_AK4113_H */ | ||
321 | |||
diff --git a/include/sound/ak4114.h b/include/sound/ak4114.h index d293d36a66b8..3ce69fd92523 100644 --- a/include/sound/ak4114.h +++ b/include/sound/ak4114.h | |||
@@ -95,13 +95,13 @@ | |||
95 | 95 | ||
96 | /* AK4114_REG_IO0 */ | 96 | /* AK4114_REG_IO0 */ |
97 | #define AK4114_TX1E (1<<7) /* TX1 Output Enable (1 = enable) */ | 97 | #define AK4114_TX1E (1<<7) /* TX1 Output Enable (1 = enable) */ |
98 | #define AK4114_OPS12 (1<<2) /* Output Though Data Selector for TX1 pin */ | 98 | #define AK4114_OPS12 (1<<6) /* Output Data Selector for TX1 pin */ |
99 | #define AK4114_OPS11 (1<<1) /* Output Though Data Selector for TX1 pin */ | 99 | #define AK4114_OPS11 (1<<5) /* Output Data Selector for TX1 pin */ |
100 | #define AK4114_OPS10 (1<<0) /* Output Though Data Selector for TX1 pin */ | 100 | #define AK4114_OPS10 (1<<4) /* Output Data Selector for TX1 pin */ |
101 | #define AK4114_TX0E (1<<3) /* TX0 Output Enable (1 = enable) */ | 101 | #define AK4114_TX0E (1<<3) /* TX0 Output Enable (1 = enable) */ |
102 | #define AK4114_OPS02 (1<<2) /* Output Though Data Selector for TX0 pin */ | 102 | #define AK4114_OPS02 (1<<2) /* Output Data Selector for TX0 pin */ |
103 | #define AK4114_OPS01 (1<<1) /* Output Though Data Selector for TX0 pin */ | 103 | #define AK4114_OPS01 (1<<1) /* Output Data Selector for TX0 pin */ |
104 | #define AK4114_OPS00 (1<<0) /* Output Though Data Selector for TX0 pin */ | 104 | #define AK4114_OPS00 (1<<0) /* Output Data Selector for TX0 pin */ |
105 | 105 | ||
106 | /* AK4114_REG_IO1 */ | 106 | /* AK4114_REG_IO1 */ |
107 | #define AK4114_EFH1 (1<<7) /* Interrupt 0 pin Hold */ | 107 | #define AK4114_EFH1 (1<<7) /* Interrupt 0 pin Hold */ |
diff --git a/include/sound/ak4xxx-adda.h b/include/sound/ak4xxx-adda.h index 891cf1aea8b1..030b87c2f6d4 100644 --- a/include/sound/ak4xxx-adda.h +++ b/include/sound/ak4xxx-adda.h | |||
@@ -68,7 +68,7 @@ struct snd_akm4xxx { | |||
68 | enum { | 68 | enum { |
69 | SND_AK4524, SND_AK4528, SND_AK4529, | 69 | SND_AK4524, SND_AK4528, SND_AK4529, |
70 | SND_AK4355, SND_AK4358, SND_AK4381, | 70 | SND_AK4355, SND_AK4358, SND_AK4381, |
71 | SND_AK5365 | 71 | SND_AK5365, SND_AK4620, |
72 | } type; | 72 | } type; |
73 | 73 | ||
74 | /* (array) information of combined codecs */ | 74 | /* (array) information of combined codecs */ |
@@ -76,6 +76,9 @@ struct snd_akm4xxx { | |||
76 | const struct snd_akm4xxx_adc_channel *adc_info; | 76 | const struct snd_akm4xxx_adc_channel *adc_info; |
77 | 77 | ||
78 | struct snd_ak4xxx_ops ops; | 78 | struct snd_ak4xxx_ops ops; |
79 | unsigned int num_chips; | ||
80 | unsigned int total_regs; | ||
81 | const char *name; | ||
79 | }; | 82 | }; |
80 | 83 | ||
81 | void snd_akm4xxx_write(struct snd_akm4xxx *ak, int chip, unsigned char reg, | 84 | void snd_akm4xxx_write(struct snd_akm4xxx *ak, int chip, unsigned char reg, |
diff --git a/sound/i2c/other/Makefile b/sound/i2c/other/Makefile index 703d954238f4..2dad40f3f622 100644 --- a/sound/i2c/other/Makefile +++ b/sound/i2c/other/Makefile | |||
@@ -5,6 +5,7 @@ | |||
5 | 5 | ||
6 | snd-ak4114-objs := ak4114.o | 6 | snd-ak4114-objs := ak4114.o |
7 | snd-ak4117-objs := ak4117.o | 7 | snd-ak4117-objs := ak4117.o |
8 | snd-ak4113-objs := ak4113.o | ||
8 | snd-ak4xxx-adda-objs := ak4xxx-adda.o | 9 | snd-ak4xxx-adda-objs := ak4xxx-adda.o |
9 | snd-pt2258-objs := pt2258.o | 10 | snd-pt2258-objs := pt2258.o |
10 | snd-tea575x-tuner-objs := tea575x-tuner.o | 11 | snd-tea575x-tuner-objs := tea575x-tuner.o |
@@ -12,5 +13,5 @@ snd-tea575x-tuner-objs := tea575x-tuner.o | |||
12 | # Module Dependency | 13 | # Module Dependency |
13 | obj-$(CONFIG_SND_PDAUDIOCF) += snd-ak4117.o | 14 | obj-$(CONFIG_SND_PDAUDIOCF) += snd-ak4117.o |
14 | obj-$(CONFIG_SND_ICE1712) += snd-ak4xxx-adda.o | 15 | obj-$(CONFIG_SND_ICE1712) += snd-ak4xxx-adda.o |
15 | obj-$(CONFIG_SND_ICE1724) += snd-ak4114.o snd-ak4xxx-adda.o snd-pt2258.o | 16 | obj-$(CONFIG_SND_ICE1724) += snd-ak4114.o snd-ak4113.o snd-ak4xxx-adda.o snd-pt2258.o |
16 | obj-$(CONFIG_SND_FM801_TEA575X) += snd-tea575x-tuner.o | 17 | obj-$(CONFIG_SND_FM801_TEA575X) += snd-tea575x-tuner.o |
diff --git a/sound/i2c/other/ak4113.c b/sound/i2c/other/ak4113.c new file mode 100644 index 000000000000..fff62cc8607c --- /dev/null +++ b/sound/i2c/other/ak4113.c | |||
@@ -0,0 +1,639 @@ | |||
1 | /* | ||
2 | * Routines for control of the AK4113 via I2C/4-wire serial interface | ||
3 | * IEC958 (S/PDIF) receiver by Asahi Kasei | ||
4 | * Copyright (c) by Jaroslav Kysela <perex@perex.cz> | ||
5 | * Copyright (c) by Pavel Hofman <pavel.hofman@ivitera.com> | ||
6 | * | ||
7 | * | ||
8 | * This program is free software; you can redistribute it and/or modify | ||
9 | * it under the terms of the GNU General Public License as published by | ||
10 | * the Free Software Foundation; either version 2 of the License, or | ||
11 | * (at your option) any later version. | ||
12 | * | ||
13 | * This program is distributed in the hope that it will be useful, | ||
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
16 | * GNU General Public License for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU General Public License | ||
19 | * along with this program; if not, write to the Free Software | ||
20 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
21 | * | ||
22 | */ | ||
23 | |||
24 | #include <linux/slab.h> | ||
25 | #include <linux/delay.h> | ||
26 | #include <sound/core.h> | ||
27 | #include <sound/control.h> | ||
28 | #include <sound/pcm.h> | ||
29 | #include <sound/ak4113.h> | ||
30 | #include <sound/asoundef.h> | ||
31 | #include <sound/info.h> | ||
32 | |||
33 | MODULE_AUTHOR("Pavel Hofman <pavel.hofman@ivitera.com>"); | ||
34 | MODULE_DESCRIPTION("AK4113 IEC958 (S/PDIF) receiver by Asahi Kasei"); | ||
35 | MODULE_LICENSE("GPL"); | ||
36 | |||
37 | #define AK4113_ADDR 0x00 /* fixed address */ | ||
38 | |||
39 | static void ak4113_stats(struct work_struct *work); | ||
40 | static void ak4113_init_regs(struct ak4113 *chip); | ||
41 | |||
42 | |||
43 | static void reg_write(struct ak4113 *ak4113, unsigned char reg, | ||
44 | unsigned char val) | ||
45 | { | ||
46 | ak4113->write(ak4113->private_data, reg, val); | ||
47 | if (reg < sizeof(ak4113->regmap)) | ||
48 | ak4113->regmap[reg] = val; | ||
49 | } | ||
50 | |||
51 | static inline unsigned char reg_read(struct ak4113 *ak4113, unsigned char reg) | ||
52 | { | ||
53 | return ak4113->read(ak4113->private_data, reg); | ||
54 | } | ||
55 | |||
56 | static void snd_ak4113_free(struct ak4113 *chip) | ||
57 | { | ||
58 | chip->init = 1; /* don't schedule new work */ | ||
59 | mb(); | ||
60 | cancel_delayed_work(&chip->work); | ||
61 | flush_scheduled_work(); | ||
62 | kfree(chip); | ||
63 | } | ||
64 | |||
65 | static int snd_ak4113_dev_free(struct snd_device *device) | ||
66 | { | ||
67 | struct ak4113 *chip = device->device_data; | ||
68 | snd_ak4113_free(chip); | ||
69 | return 0; | ||
70 | } | ||
71 | |||
72 | int snd_ak4113_create(struct snd_card *card, ak4113_read_t *read, | ||
73 | ak4113_write_t *write, const unsigned char pgm[5], | ||
74 | void *private_data, struct ak4113 **r_ak4113) | ||
75 | { | ||
76 | struct ak4113 *chip; | ||
77 | int err = 0; | ||
78 | unsigned char reg; | ||
79 | static struct snd_device_ops ops = { | ||
80 | .dev_free = snd_ak4113_dev_free, | ||
81 | }; | ||
82 | |||
83 | chip = kzalloc(sizeof(*chip), GFP_KERNEL); | ||
84 | if (chip == NULL) | ||
85 | return -ENOMEM; | ||
86 | spin_lock_init(&chip->lock); | ||
87 | chip->card = card; | ||
88 | chip->read = read; | ||
89 | chip->write = write; | ||
90 | chip->private_data = private_data; | ||
91 | INIT_DELAYED_WORK(&chip->work, ak4113_stats); | ||
92 | |||
93 | for (reg = 0; reg < AK4113_WRITABLE_REGS ; reg++) | ||
94 | chip->regmap[reg] = pgm[reg]; | ||
95 | ak4113_init_regs(chip); | ||
96 | |||
97 | chip->rcs0 = reg_read(chip, AK4113_REG_RCS0) & ~(AK4113_QINT | | ||
98 | AK4113_CINT | AK4113_STC); | ||
99 | chip->rcs1 = reg_read(chip, AK4113_REG_RCS1); | ||
100 | chip->rcs2 = reg_read(chip, AK4113_REG_RCS2); | ||
101 | err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops); | ||
102 | if (err < 0) | ||
103 | goto __fail; | ||
104 | |||
105 | if (r_ak4113) | ||
106 | *r_ak4113 = chip; | ||
107 | return 0; | ||
108 | |||
109 | __fail: | ||
110 | snd_ak4113_free(chip); | ||
111 | return err < 0 ? err : -EIO; | ||
112 | } | ||
113 | EXPORT_SYMBOL_GPL(snd_ak4113_create); | ||
114 | |||
115 | void snd_ak4113_reg_write(struct ak4113 *chip, unsigned char reg, | ||
116 | unsigned char mask, unsigned char val) | ||
117 | { | ||
118 | if (reg >= AK4113_WRITABLE_REGS) | ||
119 | return; | ||
120 | reg_write(chip, reg, (chip->regmap[reg] & ~mask) | val); | ||
121 | } | ||
122 | EXPORT_SYMBOL_GPL(snd_ak4113_reg_write); | ||
123 | |||
124 | static void ak4113_init_regs(struct ak4113 *chip) | ||
125 | { | ||
126 | unsigned char old = chip->regmap[AK4113_REG_PWRDN], reg; | ||
127 | |||
128 | /* bring the chip to reset state and powerdown state */ | ||
129 | reg_write(chip, AK4113_REG_PWRDN, old & ~(AK4113_RST|AK4113_PWN)); | ||
130 | udelay(200); | ||
131 | /* release reset, but leave powerdown */ | ||
132 | reg_write(chip, AK4113_REG_PWRDN, (old | AK4113_RST) & ~AK4113_PWN); | ||
133 | udelay(200); | ||
134 | for (reg = 1; reg < AK4113_WRITABLE_REGS; reg++) | ||
135 | reg_write(chip, reg, chip->regmap[reg]); | ||
136 | /* release powerdown, everything is initialized now */ | ||
137 | reg_write(chip, AK4113_REG_PWRDN, old | AK4113_RST | AK4113_PWN); | ||
138 | } | ||
139 | |||
140 | void snd_ak4113_reinit(struct ak4113 *chip) | ||
141 | { | ||
142 | chip->init = 1; | ||
143 | mb(); | ||
144 | flush_scheduled_work(); | ||
145 | ak4113_init_regs(chip); | ||
146 | /* bring up statistics / event queing */ | ||
147 | chip->init = 0; | ||
148 | if (chip->kctls[0]) | ||
149 | schedule_delayed_work(&chip->work, HZ / 10); | ||
150 | } | ||
151 | EXPORT_SYMBOL_GPL(snd_ak4113_reinit); | ||
152 | |||
153 | static unsigned int external_rate(unsigned char rcs1) | ||
154 | { | ||
155 | switch (rcs1 & (AK4113_FS0|AK4113_FS1|AK4113_FS2|AK4113_FS3)) { | ||
156 | case AK4113_FS_8000HZ: | ||
157 | return 8000; | ||
158 | case AK4113_FS_11025HZ: | ||
159 | return 11025; | ||
160 | case AK4113_FS_16000HZ: | ||
161 | return 16000; | ||
162 | case AK4113_FS_22050HZ: | ||
163 | return 22050; | ||
164 | case AK4113_FS_24000HZ: | ||
165 | return 24000; | ||
166 | case AK4113_FS_32000HZ: | ||
167 | return 32000; | ||
168 | case AK4113_FS_44100HZ: | ||
169 | return 44100; | ||
170 | case AK4113_FS_48000HZ: | ||
171 | return 48000; | ||
172 | case AK4113_FS_64000HZ: | ||
173 | return 64000; | ||
174 | case AK4113_FS_88200HZ: | ||
175 | return 88200; | ||
176 | case AK4113_FS_96000HZ: | ||
177 | return 96000; | ||
178 | case AK4113_FS_176400HZ: | ||
179 | return 176400; | ||
180 | case AK4113_FS_192000HZ: | ||
181 | return 192000; | ||
182 | default: | ||
183 | return 0; | ||
184 | } | ||
185 | } | ||
186 | |||
187 | static int snd_ak4113_in_error_info(struct snd_kcontrol *kcontrol, | ||
188 | struct snd_ctl_elem_info *uinfo) | ||
189 | { | ||
190 | uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; | ||
191 | uinfo->count = 1; | ||
192 | uinfo->value.integer.min = 0; | ||
193 | uinfo->value.integer.max = LONG_MAX; | ||
194 | return 0; | ||
195 | } | ||
196 | |||
197 | static int snd_ak4113_in_error_get(struct snd_kcontrol *kcontrol, | ||
198 | struct snd_ctl_elem_value *ucontrol) | ||
199 | { | ||
200 | struct ak4113 *chip = snd_kcontrol_chip(kcontrol); | ||
201 | long *ptr; | ||
202 | |||
203 | spin_lock_irq(&chip->lock); | ||
204 | ptr = (long *)(((char *)chip) + kcontrol->private_value); | ||
205 | ucontrol->value.integer.value[0] = *ptr; | ||
206 | *ptr = 0; | ||
207 | spin_unlock_irq(&chip->lock); | ||
208 | return 0; | ||
209 | } | ||
210 | |||
211 | #define snd_ak4113_in_bit_info snd_ctl_boolean_mono_info | ||
212 | |||
213 | static int snd_ak4113_in_bit_get(struct snd_kcontrol *kcontrol, | ||
214 | struct snd_ctl_elem_value *ucontrol) | ||
215 | { | ||
216 | struct ak4113 *chip = snd_kcontrol_chip(kcontrol); | ||
217 | unsigned char reg = kcontrol->private_value & 0xff; | ||
218 | unsigned char bit = (kcontrol->private_value >> 8) & 0xff; | ||
219 | unsigned char inv = (kcontrol->private_value >> 31) & 1; | ||
220 | |||
221 | ucontrol->value.integer.value[0] = | ||
222 | ((reg_read(chip, reg) & (1 << bit)) ? 1 : 0) ^ inv; | ||
223 | return 0; | ||
224 | } | ||
225 | |||
226 | static int snd_ak4113_rx_info(struct snd_kcontrol *kcontrol, | ||
227 | struct snd_ctl_elem_info *uinfo) | ||
228 | { | ||
229 | uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; | ||
230 | uinfo->count = 1; | ||
231 | uinfo->value.integer.min = 0; | ||
232 | uinfo->value.integer.max = 5; | ||
233 | return 0; | ||
234 | } | ||
235 | |||
236 | static int snd_ak4113_rx_get(struct snd_kcontrol *kcontrol, | ||
237 | struct snd_ctl_elem_value *ucontrol) | ||
238 | { | ||
239 | struct ak4113 *chip = snd_kcontrol_chip(kcontrol); | ||
240 | |||
241 | ucontrol->value.integer.value[0] = | ||
242 | (AK4113_IPS(chip->regmap[AK4113_REG_IO1])); | ||
243 | return 0; | ||
244 | } | ||
245 | |||
246 | static int snd_ak4113_rx_put(struct snd_kcontrol *kcontrol, | ||
247 | struct snd_ctl_elem_value *ucontrol) | ||
248 | { | ||
249 | struct ak4113 *chip = snd_kcontrol_chip(kcontrol); | ||
250 | int change; | ||
251 | u8 old_val; | ||
252 | |||
253 | spin_lock_irq(&chip->lock); | ||
254 | old_val = chip->regmap[AK4113_REG_IO1]; | ||
255 | change = ucontrol->value.integer.value[0] != AK4113_IPS(old_val); | ||
256 | if (change) | ||
257 | reg_write(chip, AK4113_REG_IO1, | ||
258 | (old_val & (~AK4113_IPS(0xff))) | | ||
259 | (AK4113_IPS(ucontrol->value.integer.value[0]))); | ||
260 | spin_unlock_irq(&chip->lock); | ||
261 | return change; | ||
262 | } | ||
263 | |||
264 | static int snd_ak4113_rate_info(struct snd_kcontrol *kcontrol, | ||
265 | struct snd_ctl_elem_info *uinfo) | ||
266 | { | ||
267 | uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; | ||
268 | uinfo->count = 1; | ||
269 | uinfo->value.integer.min = 0; | ||
270 | uinfo->value.integer.max = 192000; | ||
271 | return 0; | ||
272 | } | ||
273 | |||
274 | static int snd_ak4113_rate_get(struct snd_kcontrol *kcontrol, | ||
275 | struct snd_ctl_elem_value *ucontrol) | ||
276 | { | ||
277 | struct ak4113 *chip = snd_kcontrol_chip(kcontrol); | ||
278 | |||
279 | ucontrol->value.integer.value[0] = external_rate(reg_read(chip, | ||
280 | AK4113_REG_RCS1)); | ||
281 | return 0; | ||
282 | } | ||
283 | |||
284 | static int snd_ak4113_spdif_info(struct snd_kcontrol *kcontrol, | ||
285 | struct snd_ctl_elem_info *uinfo) | ||
286 | { | ||
287 | uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; | ||
288 | uinfo->count = 1; | ||
289 | return 0; | ||
290 | } | ||
291 | |||
292 | static int snd_ak4113_spdif_get(struct snd_kcontrol *kcontrol, | ||
293 | struct snd_ctl_elem_value *ucontrol) | ||
294 | { | ||
295 | struct ak4113 *chip = snd_kcontrol_chip(kcontrol); | ||
296 | unsigned i; | ||
297 | |||
298 | for (i = 0; i < AK4113_REG_RXCSB_SIZE; i++) | ||
299 | ucontrol->value.iec958.status[i] = reg_read(chip, | ||
300 | AK4113_REG_RXCSB0 + i); | ||
301 | return 0; | ||
302 | } | ||
303 | |||
304 | static int snd_ak4113_spdif_mask_info(struct snd_kcontrol *kcontrol, | ||
305 | struct snd_ctl_elem_info *uinfo) | ||
306 | { | ||
307 | uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; | ||
308 | uinfo->count = 1; | ||
309 | return 0; | ||
310 | } | ||
311 | |||
312 | static int snd_ak4113_spdif_mask_get(struct snd_kcontrol *kcontrol, | ||
313 | struct snd_ctl_elem_value *ucontrol) | ||
314 | { | ||
315 | memset(ucontrol->value.iec958.status, 0xff, AK4113_REG_RXCSB_SIZE); | ||
316 | return 0; | ||
317 | } | ||
318 | |||
319 | static int snd_ak4113_spdif_pinfo(struct snd_kcontrol *kcontrol, | ||
320 | struct snd_ctl_elem_info *uinfo) | ||
321 | { | ||
322 | uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; | ||
323 | uinfo->value.integer.min = 0; | ||
324 | uinfo->value.integer.max = 0xffff; | ||
325 | uinfo->count = 4; | ||
326 | return 0; | ||
327 | } | ||
328 | |||
329 | static int snd_ak4113_spdif_pget(struct snd_kcontrol *kcontrol, | ||
330 | struct snd_ctl_elem_value *ucontrol) | ||
331 | { | ||
332 | struct ak4113 *chip = snd_kcontrol_chip(kcontrol); | ||
333 | unsigned short tmp; | ||
334 | |||
335 | ucontrol->value.integer.value[0] = 0xf8f2; | ||
336 | ucontrol->value.integer.value[1] = 0x4e1f; | ||
337 | tmp = reg_read(chip, AK4113_REG_Pc0) | | ||
338 | (reg_read(chip, AK4113_REG_Pc1) << 8); | ||
339 | ucontrol->value.integer.value[2] = tmp; | ||
340 | tmp = reg_read(chip, AK4113_REG_Pd0) | | ||
341 | (reg_read(chip, AK4113_REG_Pd1) << 8); | ||
342 | ucontrol->value.integer.value[3] = tmp; | ||
343 | return 0; | ||
344 | } | ||
345 | |||
346 | static int snd_ak4113_spdif_qinfo(struct snd_kcontrol *kcontrol, | ||
347 | struct snd_ctl_elem_info *uinfo) | ||
348 | { | ||
349 | uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES; | ||
350 | uinfo->count = AK4113_REG_QSUB_SIZE; | ||
351 | return 0; | ||
352 | } | ||
353 | |||
354 | static int snd_ak4113_spdif_qget(struct snd_kcontrol *kcontrol, | ||
355 | struct snd_ctl_elem_value *ucontrol) | ||
356 | { | ||
357 | struct ak4113 *chip = snd_kcontrol_chip(kcontrol); | ||
358 | unsigned i; | ||
359 | |||
360 | for (i = 0; i < AK4113_REG_QSUB_SIZE; i++) | ||
361 | ucontrol->value.bytes.data[i] = reg_read(chip, | ||
362 | AK4113_REG_QSUB_ADDR + i); | ||
363 | return 0; | ||
364 | } | ||
365 | |||
366 | /* Don't forget to change AK4113_CONTROLS define!!! */ | ||
367 | static struct snd_kcontrol_new snd_ak4113_iec958_controls[] = { | ||
368 | { | ||
369 | .iface = SNDRV_CTL_ELEM_IFACE_PCM, | ||
370 | .name = "IEC958 Parity Errors", | ||
371 | .access = SNDRV_CTL_ELEM_ACCESS_READ | | ||
372 | SNDRV_CTL_ELEM_ACCESS_VOLATILE, | ||
373 | .info = snd_ak4113_in_error_info, | ||
374 | .get = snd_ak4113_in_error_get, | ||
375 | .private_value = offsetof(struct ak4113, parity_errors), | ||
376 | }, | ||
377 | { | ||
378 | .iface = SNDRV_CTL_ELEM_IFACE_PCM, | ||
379 | .name = "IEC958 V-Bit Errors", | ||
380 | .access = SNDRV_CTL_ELEM_ACCESS_READ | | ||
381 | SNDRV_CTL_ELEM_ACCESS_VOLATILE, | ||
382 | .info = snd_ak4113_in_error_info, | ||
383 | .get = snd_ak4113_in_error_get, | ||
384 | .private_value = offsetof(struct ak4113, v_bit_errors), | ||
385 | }, | ||
386 | { | ||
387 | .iface = SNDRV_CTL_ELEM_IFACE_PCM, | ||
388 | .name = "IEC958 C-CRC Errors", | ||
389 | .access = SNDRV_CTL_ELEM_ACCESS_READ | | ||
390 | SNDRV_CTL_ELEM_ACCESS_VOLATILE, | ||
391 | .info = snd_ak4113_in_error_info, | ||
392 | .get = snd_ak4113_in_error_get, | ||
393 | .private_value = offsetof(struct ak4113, ccrc_errors), | ||
394 | }, | ||
395 | { | ||
396 | .iface = SNDRV_CTL_ELEM_IFACE_PCM, | ||
397 | .name = "IEC958 Q-CRC Errors", | ||
398 | .access = SNDRV_CTL_ELEM_ACCESS_READ | | ||
399 | SNDRV_CTL_ELEM_ACCESS_VOLATILE, | ||
400 | .info = snd_ak4113_in_error_info, | ||
401 | .get = snd_ak4113_in_error_get, | ||
402 | .private_value = offsetof(struct ak4113, qcrc_errors), | ||
403 | }, | ||
404 | { | ||
405 | .iface = SNDRV_CTL_ELEM_IFACE_PCM, | ||
406 | .name = "IEC958 External Rate", | ||
407 | .access = SNDRV_CTL_ELEM_ACCESS_READ | | ||
408 | SNDRV_CTL_ELEM_ACCESS_VOLATILE, | ||
409 | .info = snd_ak4113_rate_info, | ||
410 | .get = snd_ak4113_rate_get, | ||
411 | }, | ||
412 | { | ||
413 | .iface = SNDRV_CTL_ELEM_IFACE_PCM, | ||
414 | .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, MASK), | ||
415 | .access = SNDRV_CTL_ELEM_ACCESS_READ, | ||
416 | .info = snd_ak4113_spdif_mask_info, | ||
417 | .get = snd_ak4113_spdif_mask_get, | ||
418 | }, | ||
419 | { | ||
420 | .iface = SNDRV_CTL_ELEM_IFACE_PCM, | ||
421 | .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT), | ||
422 | .access = SNDRV_CTL_ELEM_ACCESS_READ | | ||
423 | SNDRV_CTL_ELEM_ACCESS_VOLATILE, | ||
424 | .info = snd_ak4113_spdif_info, | ||
425 | .get = snd_ak4113_spdif_get, | ||
426 | }, | ||
427 | { | ||
428 | .iface = SNDRV_CTL_ELEM_IFACE_PCM, | ||
429 | .name = "IEC958 Preample Capture Default", | ||
430 | .access = SNDRV_CTL_ELEM_ACCESS_READ | | ||
431 | SNDRV_CTL_ELEM_ACCESS_VOLATILE, | ||
432 | .info = snd_ak4113_spdif_pinfo, | ||
433 | .get = snd_ak4113_spdif_pget, | ||
434 | }, | ||
435 | { | ||
436 | .iface = SNDRV_CTL_ELEM_IFACE_PCM, | ||
437 | .name = "IEC958 Q-subcode Capture Default", | ||
438 | .access = SNDRV_CTL_ELEM_ACCESS_READ | | ||
439 | SNDRV_CTL_ELEM_ACCESS_VOLATILE, | ||
440 | .info = snd_ak4113_spdif_qinfo, | ||
441 | .get = snd_ak4113_spdif_qget, | ||
442 | }, | ||
443 | { | ||
444 | .iface = SNDRV_CTL_ELEM_IFACE_PCM, | ||
445 | .name = "IEC958 Audio", | ||
446 | .access = SNDRV_CTL_ELEM_ACCESS_READ | | ||
447 | SNDRV_CTL_ELEM_ACCESS_VOLATILE, | ||
448 | .info = snd_ak4113_in_bit_info, | ||
449 | .get = snd_ak4113_in_bit_get, | ||
450 | .private_value = (1<<31) | (1<<8) | AK4113_REG_RCS0, | ||
451 | }, | ||
452 | { | ||
453 | .iface = SNDRV_CTL_ELEM_IFACE_PCM, | ||
454 | .name = "IEC958 Non-PCM Bitstream", | ||
455 | .access = SNDRV_CTL_ELEM_ACCESS_READ | | ||
456 | SNDRV_CTL_ELEM_ACCESS_VOLATILE, | ||
457 | .info = snd_ak4113_in_bit_info, | ||
458 | .get = snd_ak4113_in_bit_get, | ||
459 | .private_value = (0<<8) | AK4113_REG_RCS1, | ||
460 | }, | ||
461 | { | ||
462 | .iface = SNDRV_CTL_ELEM_IFACE_PCM, | ||
463 | .name = "IEC958 DTS Bitstream", | ||
464 | .access = SNDRV_CTL_ELEM_ACCESS_READ | | ||
465 | SNDRV_CTL_ELEM_ACCESS_VOLATILE, | ||
466 | .info = snd_ak4113_in_bit_info, | ||
467 | .get = snd_ak4113_in_bit_get, | ||
468 | .private_value = (1<<8) | AK4113_REG_RCS1, | ||
469 | }, | ||
470 | { | ||
471 | .iface = SNDRV_CTL_ELEM_IFACE_PCM, | ||
472 | .name = "AK4113 Input Select", | ||
473 | .access = SNDRV_CTL_ELEM_ACCESS_READ | | ||
474 | SNDRV_CTL_ELEM_ACCESS_WRITE, | ||
475 | .info = snd_ak4113_rx_info, | ||
476 | .get = snd_ak4113_rx_get, | ||
477 | .put = snd_ak4113_rx_put, | ||
478 | } | ||
479 | }; | ||
480 | |||
481 | static void snd_ak4113_proc_regs_read(struct snd_info_entry *entry, | ||
482 | struct snd_info_buffer *buffer) | ||
483 | { | ||
484 | struct ak4113 *ak4113 = entry->private_data; | ||
485 | int reg, val; | ||
486 | /* all ak4113 registers 0x00 - 0x1c */ | ||
487 | for (reg = 0; reg < 0x1d; reg++) { | ||
488 | val = reg_read(ak4113, reg); | ||
489 | snd_iprintf(buffer, "0x%02x = 0x%02x\n", reg, val); | ||
490 | } | ||
491 | } | ||
492 | |||
493 | static void snd_ak4113_proc_init(struct ak4113 *ak4113) | ||
494 | { | ||
495 | struct snd_info_entry *entry; | ||
496 | if (!snd_card_proc_new(ak4113->card, "ak4113", &entry)) | ||
497 | snd_info_set_text_ops(entry, ak4113, snd_ak4113_proc_regs_read); | ||
498 | } | ||
499 | |||
500 | int snd_ak4113_build(struct ak4113 *ak4113, | ||
501 | struct snd_pcm_substream *cap_substream) | ||
502 | { | ||
503 | struct snd_kcontrol *kctl; | ||
504 | unsigned int idx; | ||
505 | int err; | ||
506 | |||
507 | if (snd_BUG_ON(!cap_substream)) | ||
508 | return -EINVAL; | ||
509 | ak4113->substream = cap_substream; | ||
510 | for (idx = 0; idx < AK4113_CONTROLS; idx++) { | ||
511 | kctl = snd_ctl_new1(&snd_ak4113_iec958_controls[idx], ak4113); | ||
512 | if (kctl == NULL) | ||
513 | return -ENOMEM; | ||
514 | kctl->id.device = cap_substream->pcm->device; | ||
515 | kctl->id.subdevice = cap_substream->number; | ||
516 | err = snd_ctl_add(ak4113->card, kctl); | ||
517 | if (err < 0) | ||
518 | return err; | ||
519 | ak4113->kctls[idx] = kctl; | ||
520 | } | ||
521 | snd_ak4113_proc_init(ak4113); | ||
522 | /* trigger workq */ | ||
523 | schedule_delayed_work(&ak4113->work, HZ / 10); | ||
524 | return 0; | ||
525 | } | ||
526 | EXPORT_SYMBOL_GPL(snd_ak4113_build); | ||
527 | |||
528 | int snd_ak4113_external_rate(struct ak4113 *ak4113) | ||
529 | { | ||
530 | unsigned char rcs1; | ||
531 | |||
532 | rcs1 = reg_read(ak4113, AK4113_REG_RCS1); | ||
533 | return external_rate(rcs1); | ||
534 | } | ||
535 | EXPORT_SYMBOL_GPL(snd_ak4113_external_rate); | ||
536 | |||
537 | int snd_ak4113_check_rate_and_errors(struct ak4113 *ak4113, unsigned int flags) | ||
538 | { | ||
539 | struct snd_pcm_runtime *runtime = | ||
540 | ak4113->substream ? ak4113->substream->runtime : NULL; | ||
541 | unsigned long _flags; | ||
542 | int res = 0; | ||
543 | unsigned char rcs0, rcs1, rcs2; | ||
544 | unsigned char c0, c1; | ||
545 | |||
546 | rcs1 = reg_read(ak4113, AK4113_REG_RCS1); | ||
547 | if (flags & AK4113_CHECK_NO_STAT) | ||
548 | goto __rate; | ||
549 | rcs0 = reg_read(ak4113, AK4113_REG_RCS0); | ||
550 | rcs2 = reg_read(ak4113, AK4113_REG_RCS2); | ||
551 | spin_lock_irqsave(&ak4113->lock, _flags); | ||
552 | if (rcs0 & AK4113_PAR) | ||
553 | ak4113->parity_errors++; | ||
554 | if (rcs0 & AK4113_V) | ||
555 | ak4113->v_bit_errors++; | ||
556 | if (rcs2 & AK4113_CCRC) | ||
557 | ak4113->ccrc_errors++; | ||
558 | if (rcs2 & AK4113_QCRC) | ||
559 | ak4113->qcrc_errors++; | ||
560 | c0 = (ak4113->rcs0 & (AK4113_QINT | AK4113_CINT | AK4113_STC | | ||
561 | AK4113_AUDION | AK4113_AUTO | AK4113_UNLCK)) ^ | ||
562 | (rcs0 & (AK4113_QINT | AK4113_CINT | AK4113_STC | | ||
563 | AK4113_AUDION | AK4113_AUTO | AK4113_UNLCK)); | ||
564 | c1 = (ak4113->rcs1 & (AK4113_DTSCD | AK4113_NPCM | AK4113_PEM | | ||
565 | AK4113_DAT | 0xf0)) ^ | ||
566 | (rcs1 & (AK4113_DTSCD | AK4113_NPCM | AK4113_PEM | | ||
567 | AK4113_DAT | 0xf0)); | ||
568 | ak4113->rcs0 = rcs0 & ~(AK4113_QINT | AK4113_CINT | AK4113_STC); | ||
569 | ak4113->rcs1 = rcs1; | ||
570 | ak4113->rcs2 = rcs2; | ||
571 | spin_unlock_irqrestore(&ak4113->lock, _flags); | ||
572 | |||
573 | if (rcs0 & AK4113_PAR) | ||
574 | snd_ctl_notify(ak4113->card, SNDRV_CTL_EVENT_MASK_VALUE, | ||
575 | &ak4113->kctls[0]->id); | ||
576 | if (rcs0 & AK4113_V) | ||
577 | snd_ctl_notify(ak4113->card, SNDRV_CTL_EVENT_MASK_VALUE, | ||
578 | &ak4113->kctls[1]->id); | ||
579 | if (rcs2 & AK4113_CCRC) | ||
580 | snd_ctl_notify(ak4113->card, SNDRV_CTL_EVENT_MASK_VALUE, | ||
581 | &ak4113->kctls[2]->id); | ||
582 | if (rcs2 & AK4113_QCRC) | ||
583 | snd_ctl_notify(ak4113->card, SNDRV_CTL_EVENT_MASK_VALUE, | ||
584 | &ak4113->kctls[3]->id); | ||
585 | |||
586 | /* rate change */ | ||
587 | if (c1 & 0xf0) | ||
588 | snd_ctl_notify(ak4113->card, SNDRV_CTL_EVENT_MASK_VALUE, | ||
589 | &ak4113->kctls[4]->id); | ||
590 | |||
591 | if ((c1 & AK4113_PEM) | (c0 & AK4113_CINT)) | ||
592 | snd_ctl_notify(ak4113->card, SNDRV_CTL_EVENT_MASK_VALUE, | ||
593 | &ak4113->kctls[6]->id); | ||
594 | if (c0 & AK4113_QINT) | ||
595 | snd_ctl_notify(ak4113->card, SNDRV_CTL_EVENT_MASK_VALUE, | ||
596 | &ak4113->kctls[8]->id); | ||
597 | |||
598 | if (c0 & AK4113_AUDION) | ||
599 | snd_ctl_notify(ak4113->card, SNDRV_CTL_EVENT_MASK_VALUE, | ||
600 | &ak4113->kctls[9]->id); | ||
601 | if (c1 & AK4113_NPCM) | ||
602 | snd_ctl_notify(ak4113->card, SNDRV_CTL_EVENT_MASK_VALUE, | ||
603 | &ak4113->kctls[10]->id); | ||
604 | if (c1 & AK4113_DTSCD) | ||
605 | snd_ctl_notify(ak4113->card, SNDRV_CTL_EVENT_MASK_VALUE, | ||
606 | &ak4113->kctls[11]->id); | ||
607 | |||
608 | if (ak4113->change_callback && (c0 | c1) != 0) | ||
609 | ak4113->change_callback(ak4113, c0, c1); | ||
610 | |||
611 | __rate: | ||
612 | /* compare rate */ | ||
613 | res = external_rate(rcs1); | ||
614 | if (!(flags & AK4113_CHECK_NO_RATE) && runtime && | ||
615 | (runtime->rate != res)) { | ||
616 | snd_pcm_stream_lock_irqsave(ak4113->substream, _flags); | ||
617 | if (snd_pcm_running(ak4113->substream)) { | ||
618 | /*printk(KERN_DEBUG "rate changed (%i <- %i)\n", | ||
619 | * runtime->rate, res); */ | ||
620 | snd_pcm_stop(ak4113->substream, | ||
621 | SNDRV_PCM_STATE_DRAINING); | ||
622 | wake_up(&runtime->sleep); | ||
623 | res = 1; | ||
624 | } | ||
625 | snd_pcm_stream_unlock_irqrestore(ak4113->substream, _flags); | ||
626 | } | ||
627 | return res; | ||
628 | } | ||
629 | EXPORT_SYMBOL_GPL(snd_ak4113_check_rate_and_errors); | ||
630 | |||
631 | static void ak4113_stats(struct work_struct *work) | ||
632 | { | ||
633 | struct ak4113 *chip = container_of(work, struct ak4113, work.work); | ||
634 | |||
635 | if (!chip->init) | ||
636 | snd_ak4113_check_rate_and_errors(chip, chip->check_flags); | ||
637 | |||
638 | schedule_delayed_work(&chip->work, HZ / 10); | ||
639 | } | ||
diff --git a/sound/i2c/other/ak4xxx-adda.c b/sound/i2c/other/ak4xxx-adda.c index ee47abab764e..1adb8a3c2b62 100644 --- a/sound/i2c/other/ak4xxx-adda.c +++ b/sound/i2c/other/ak4xxx-adda.c | |||
@@ -19,7 +19,7 @@ | |||
19 | * along with this program; if not, write to the Free Software | 19 | * along with this program; if not, write to the Free Software |
20 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | 20 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
21 | * | 21 | * |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <asm/io.h> | 24 | #include <asm/io.h> |
25 | #include <linux/delay.h> | 25 | #include <linux/delay.h> |
@@ -29,6 +29,7 @@ | |||
29 | #include <sound/control.h> | 29 | #include <sound/control.h> |
30 | #include <sound/tlv.h> | 30 | #include <sound/tlv.h> |
31 | #include <sound/ak4xxx-adda.h> | 31 | #include <sound/ak4xxx-adda.h> |
32 | #include <sound/info.h> | ||
32 | 33 | ||
33 | MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Takashi Iwai <tiwai@suse.de>"); | 34 | MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Takashi Iwai <tiwai@suse.de>"); |
34 | MODULE_DESCRIPTION("Routines for control of AK452x / AK43xx AD/DA converters"); | 35 | MODULE_DESCRIPTION("Routines for control of AK452x / AK43xx AD/DA converters"); |
@@ -52,26 +53,21 @@ EXPORT_SYMBOL(snd_akm4xxx_write); | |||
52 | static void ak4524_reset(struct snd_akm4xxx *ak, int state) | 53 | static void ak4524_reset(struct snd_akm4xxx *ak, int state) |
53 | { | 54 | { |
54 | unsigned int chip; | 55 | unsigned int chip; |
55 | unsigned char reg, maxreg; | 56 | unsigned char reg; |
56 | 57 | ||
57 | if (ak->type == SND_AK4528) | ||
58 | maxreg = 0x06; | ||
59 | else | ||
60 | maxreg = 0x08; | ||
61 | for (chip = 0; chip < ak->num_dacs/2; chip++) { | 58 | for (chip = 0; chip < ak->num_dacs/2; chip++) { |
62 | snd_akm4xxx_write(ak, chip, 0x01, state ? 0x00 : 0x03); | 59 | snd_akm4xxx_write(ak, chip, 0x01, state ? 0x00 : 0x03); |
63 | if (state) | 60 | if (state) |
64 | continue; | 61 | continue; |
65 | /* DAC volumes */ | 62 | /* DAC volumes */ |
66 | for (reg = 0x04; reg < maxreg; reg++) | 63 | for (reg = 0x04; reg < ak->total_regs; reg++) |
67 | snd_akm4xxx_write(ak, chip, reg, | 64 | snd_akm4xxx_write(ak, chip, reg, |
68 | snd_akm4xxx_get(ak, chip, reg)); | 65 | snd_akm4xxx_get(ak, chip, reg)); |
69 | } | 66 | } |
70 | } | 67 | } |
71 | 68 | ||
72 | /* reset procedure for AK4355 and AK4358 */ | 69 | /* reset procedure for AK4355 and AK4358 */ |
73 | static void ak435X_reset(struct snd_akm4xxx *ak, int state, | 70 | static void ak435X_reset(struct snd_akm4xxx *ak, int state) |
74 | unsigned char total_regs) | ||
75 | { | 71 | { |
76 | unsigned char reg; | 72 | unsigned char reg; |
77 | 73 | ||
@@ -79,7 +75,7 @@ static void ak435X_reset(struct snd_akm4xxx *ak, int state, | |||
79 | snd_akm4xxx_write(ak, 0, 0x01, 0x02); /* reset and soft-mute */ | 75 | snd_akm4xxx_write(ak, 0, 0x01, 0x02); /* reset and soft-mute */ |
80 | return; | 76 | return; |
81 | } | 77 | } |
82 | for (reg = 0x00; reg < total_regs; reg++) | 78 | for (reg = 0x00; reg < ak->total_regs; reg++) |
83 | if (reg != 0x01) | 79 | if (reg != 0x01) |
84 | snd_akm4xxx_write(ak, 0, reg, | 80 | snd_akm4xxx_write(ak, 0, reg, |
85 | snd_akm4xxx_get(ak, 0, reg)); | 81 | snd_akm4xxx_get(ak, 0, reg)); |
@@ -91,12 +87,11 @@ static void ak4381_reset(struct snd_akm4xxx *ak, int state) | |||
91 | { | 87 | { |
92 | unsigned int chip; | 88 | unsigned int chip; |
93 | unsigned char reg; | 89 | unsigned char reg; |
94 | |||
95 | for (chip = 0; chip < ak->num_dacs/2; chip++) { | 90 | for (chip = 0; chip < ak->num_dacs/2; chip++) { |
96 | snd_akm4xxx_write(ak, chip, 0x00, state ? 0x0c : 0x0f); | 91 | snd_akm4xxx_write(ak, chip, 0x00, state ? 0x0c : 0x0f); |
97 | if (state) | 92 | if (state) |
98 | continue; | 93 | continue; |
99 | for (reg = 0x01; reg < 0x05; reg++) | 94 | for (reg = 0x01; reg < ak->total_regs; reg++) |
100 | snd_akm4xxx_write(ak, chip, reg, | 95 | snd_akm4xxx_write(ak, chip, reg, |
101 | snd_akm4xxx_get(ak, chip, reg)); | 96 | snd_akm4xxx_get(ak, chip, reg)); |
102 | } | 97 | } |
@@ -113,16 +108,17 @@ void snd_akm4xxx_reset(struct snd_akm4xxx *ak, int state) | |||
113 | switch (ak->type) { | 108 | switch (ak->type) { |
114 | case SND_AK4524: | 109 | case SND_AK4524: |
115 | case SND_AK4528: | 110 | case SND_AK4528: |
111 | case SND_AK4620: | ||
116 | ak4524_reset(ak, state); | 112 | ak4524_reset(ak, state); |
117 | break; | 113 | break; |
118 | case SND_AK4529: | 114 | case SND_AK4529: |
119 | /* FIXME: needed for ak4529? */ | 115 | /* FIXME: needed for ak4529? */ |
120 | break; | 116 | break; |
121 | case SND_AK4355: | 117 | case SND_AK4355: |
122 | ak435X_reset(ak, state, 0x0b); | 118 | ak435X_reset(ak, state); |
123 | break; | 119 | break; |
124 | case SND_AK4358: | 120 | case SND_AK4358: |
125 | ak435X_reset(ak, state, 0x10); | 121 | ak435X_reset(ak, state); |
126 | break; | 122 | break; |
127 | case SND_AK4381: | 123 | case SND_AK4381: |
128 | ak4381_reset(ak, state); | 124 | ak4381_reset(ak, state); |
@@ -139,7 +135,7 @@ EXPORT_SYMBOL(snd_akm4xxx_reset); | |||
139 | * Volume conversion table for non-linear volumes | 135 | * Volume conversion table for non-linear volumes |
140 | * from -63.5dB (mute) to 0dB step 0.5dB | 136 | * from -63.5dB (mute) to 0dB step 0.5dB |
141 | * | 137 | * |
142 | * Used for AK4524 input/ouput attenuation, AK4528, and | 138 | * Used for AK4524/AK4620 input/ouput attenuation, AK4528, and |
143 | * AK5365 input attenuation | 139 | * AK5365 input attenuation |
144 | */ | 140 | */ |
145 | static const unsigned char vol_cvt_datt[128] = { | 141 | static const unsigned char vol_cvt_datt[128] = { |
@@ -259,8 +255,22 @@ void snd_akm4xxx_init(struct snd_akm4xxx *ak) | |||
259 | 0x00, 0x0f, /* 0: power-up, un-reset */ | 255 | 0x00, 0x0f, /* 0: power-up, un-reset */ |
260 | 0xff, 0xff | 256 | 0xff, 0xff |
261 | }; | 257 | }; |
258 | static const unsigned char inits_ak4620[] = { | ||
259 | 0x00, 0x07, /* 0: normal */ | ||
260 | 0x01, 0x00, /* 0: reset */ | ||
261 | 0x01, 0x02, /* 1: RSTAD */ | ||
262 | 0x01, 0x03, /* 1: RSTDA */ | ||
263 | 0x01, 0x0f, /* 1: normal */ | ||
264 | 0x02, 0x60, /* 2: 24bit I2S */ | ||
265 | 0x03, 0x01, /* 3: deemphasis off */ | ||
266 | 0x04, 0x00, /* 4: LIN muted */ | ||
267 | 0x05, 0x00, /* 5: RIN muted */ | ||
268 | 0x06, 0x00, /* 6: LOUT muted */ | ||
269 | 0x07, 0x00, /* 7: ROUT muted */ | ||
270 | 0xff, 0xff | ||
271 | }; | ||
262 | 272 | ||
263 | int chip, num_chips; | 273 | int chip; |
264 | const unsigned char *ptr, *inits; | 274 | const unsigned char *ptr, *inits; |
265 | unsigned char reg, data; | 275 | unsigned char reg, data; |
266 | 276 | ||
@@ -270,42 +280,64 @@ void snd_akm4xxx_init(struct snd_akm4xxx *ak) | |||
270 | switch (ak->type) { | 280 | switch (ak->type) { |
271 | case SND_AK4524: | 281 | case SND_AK4524: |
272 | inits = inits_ak4524; | 282 | inits = inits_ak4524; |
273 | num_chips = ak->num_dacs / 2; | 283 | ak->num_chips = ak->num_dacs / 2; |
284 | ak->name = "ak4524"; | ||
285 | ak->total_regs = 0x08; | ||
274 | break; | 286 | break; |
275 | case SND_AK4528: | 287 | case SND_AK4528: |
276 | inits = inits_ak4528; | 288 | inits = inits_ak4528; |
277 | num_chips = ak->num_dacs / 2; | 289 | ak->num_chips = ak->num_dacs / 2; |
290 | ak->name = "ak4528"; | ||
291 | ak->total_regs = 0x06; | ||
278 | break; | 292 | break; |
279 | case SND_AK4529: | 293 | case SND_AK4529: |
280 | inits = inits_ak4529; | 294 | inits = inits_ak4529; |
281 | num_chips = 1; | 295 | ak->num_chips = 1; |
296 | ak->name = "ak4529"; | ||
297 | ak->total_regs = 0x0d; | ||
282 | break; | 298 | break; |
283 | case SND_AK4355: | 299 | case SND_AK4355: |
284 | inits = inits_ak4355; | 300 | inits = inits_ak4355; |
285 | num_chips = 1; | 301 | ak->num_chips = 1; |
302 | ak->name = "ak4355"; | ||
303 | ak->total_regs = 0x0b; | ||
286 | break; | 304 | break; |
287 | case SND_AK4358: | 305 | case SND_AK4358: |
288 | inits = inits_ak4358; | 306 | inits = inits_ak4358; |
289 | num_chips = 1; | 307 | ak->num_chips = 1; |
308 | ak->name = "ak4358"; | ||
309 | ak->total_regs = 0x10; | ||
290 | break; | 310 | break; |
291 | case SND_AK4381: | 311 | case SND_AK4381: |
292 | inits = inits_ak4381; | 312 | inits = inits_ak4381; |
293 | num_chips = ak->num_dacs / 2; | 313 | ak->num_chips = ak->num_dacs / 2; |
314 | ak->name = "ak4381"; | ||
315 | ak->total_regs = 0x05; | ||
294 | break; | 316 | break; |
295 | case SND_AK5365: | 317 | case SND_AK5365: |
296 | /* FIXME: any init sequence? */ | 318 | /* FIXME: any init sequence? */ |
319 | ak->num_chips = 1; | ||
320 | ak->name = "ak5365"; | ||
321 | ak->total_regs = 0x08; | ||
297 | return; | 322 | return; |
323 | case SND_AK4620: | ||
324 | inits = inits_ak4620; | ||
325 | ak->num_chips = ak->num_dacs / 2; | ||
326 | ak->name = "ak4620"; | ||
327 | ak->total_regs = 0x08; | ||
328 | break; | ||
298 | default: | 329 | default: |
299 | snd_BUG(); | 330 | snd_BUG(); |
300 | return; | 331 | return; |
301 | } | 332 | } |
302 | 333 | ||
303 | for (chip = 0; chip < num_chips; chip++) { | 334 | for (chip = 0; chip < ak->num_chips; chip++) { |
304 | ptr = inits; | 335 | ptr = inits; |
305 | while (*ptr != 0xff) { | 336 | while (*ptr != 0xff) { |
306 | reg = *ptr++; | 337 | reg = *ptr++; |
307 | data = *ptr++; | 338 | data = *ptr++; |
308 | snd_akm4xxx_write(ak, chip, reg, data); | 339 | snd_akm4xxx_write(ak, chip, reg, data); |
340 | udelay(10); | ||
309 | } | 341 | } |
310 | } | 342 | } |
311 | } | 343 | } |
@@ -688,6 +720,12 @@ static int build_dac_controls(struct snd_akm4xxx *ak) | |||
688 | AK_COMPOSE(idx/2, (idx%2) + 3, 0, 255); | 720 | AK_COMPOSE(idx/2, (idx%2) + 3, 0, 255); |
689 | knew.tlv.p = db_scale_linear; | 721 | knew.tlv.p = db_scale_linear; |
690 | break; | 722 | break; |
723 | case SND_AK4620: | ||
724 | /* register 6 & 7 */ | ||
725 | knew.private_value = | ||
726 | AK_COMPOSE(idx/2, (idx%2) + 6, 0, 255); | ||
727 | knew.tlv.p = db_scale_linear; | ||
728 | break; | ||
691 | default: | 729 | default: |
692 | return -EINVAL; | 730 | return -EINVAL; |
693 | } | 731 | } |
@@ -704,10 +742,12 @@ static int build_dac_controls(struct snd_akm4xxx *ak) | |||
704 | 742 | ||
705 | static int build_adc_controls(struct snd_akm4xxx *ak) | 743 | static int build_adc_controls(struct snd_akm4xxx *ak) |
706 | { | 744 | { |
707 | int idx, err, mixer_ch, num_stereo; | 745 | int idx, err, mixer_ch, num_stereo, max_steps; |
708 | struct snd_kcontrol_new knew; | 746 | struct snd_kcontrol_new knew; |
709 | 747 | ||
710 | mixer_ch = 0; | 748 | mixer_ch = 0; |
749 | if (ak->type == SND_AK4528) | ||
750 | return 0; /* no controls */ | ||
711 | for (idx = 0; idx < ak->num_adcs;) { | 751 | for (idx = 0; idx < ak->num_adcs;) { |
712 | memset(&knew, 0, sizeof(knew)); | 752 | memset(&knew, 0, sizeof(knew)); |
713 | if (! ak->adc_info || ! ak->adc_info[mixer_ch].name) { | 753 | if (! ak->adc_info || ! ak->adc_info[mixer_ch].name) { |
@@ -733,13 +773,12 @@ static int build_adc_controls(struct snd_akm4xxx *ak) | |||
733 | } | 773 | } |
734 | /* register 4 & 5 */ | 774 | /* register 4 & 5 */ |
735 | if (ak->type == SND_AK5365) | 775 | if (ak->type == SND_AK5365) |
736 | knew.private_value = | 776 | max_steps = 152; |
737 | AK_COMPOSE(idx/2, (idx%2) + 4, 0, 151) | | ||
738 | AK_VOL_CVT | AK_IPGA; | ||
739 | else | 777 | else |
740 | knew.private_value = | 778 | max_steps = 164; |
741 | AK_COMPOSE(idx/2, (idx%2) + 4, 0, 163) | | 779 | knew.private_value = |
742 | AK_VOL_CVT | AK_IPGA; | 780 | AK_COMPOSE(idx/2, (idx%2) + 4, 0, max_steps) | |
781 | AK_VOL_CVT | AK_IPGA; | ||
743 | knew.tlv.p = db_scale_vol_datt; | 782 | knew.tlv.p = db_scale_vol_datt; |
744 | err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak)); | 783 | err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak)); |
745 | if (err < 0) | 784 | if (err < 0) |
@@ -808,6 +847,7 @@ static int build_deemphasis(struct snd_akm4xxx *ak, int num_emphs) | |||
808 | switch (ak->type) { | 847 | switch (ak->type) { |
809 | case SND_AK4524: | 848 | case SND_AK4524: |
810 | case SND_AK4528: | 849 | case SND_AK4528: |
850 | case SND_AK4620: | ||
811 | /* register 3 */ | 851 | /* register 3 */ |
812 | knew.private_value = AK_COMPOSE(idx, 3, 0, 0); | 852 | knew.private_value = AK_COMPOSE(idx, 3, 0, 0); |
813 | break; | 853 | break; |
@@ -834,6 +874,35 @@ static int build_deemphasis(struct snd_akm4xxx *ak, int num_emphs) | |||
834 | return 0; | 874 | return 0; |
835 | } | 875 | } |
836 | 876 | ||
877 | #ifdef CONFIG_PROC_FS | ||
878 | static void proc_regs_read(struct snd_info_entry *entry, | ||
879 | struct snd_info_buffer *buffer) | ||
880 | { | ||
881 | struct snd_akm4xxx *ak = (struct snd_akm4xxx *)entry->private_data; | ||
882 | int reg, val, chip; | ||
883 | for (chip = 0; chip < ak->num_chips; chip++) { | ||
884 | for (reg = 0; reg < ak->total_regs; reg++) { | ||
885 | val = snd_akm4xxx_get(ak, chip, reg); | ||
886 | snd_iprintf(buffer, "chip %d: 0x%02x = 0x%02x\n", chip, | ||
887 | reg, val); | ||
888 | } | ||
889 | } | ||
890 | } | ||
891 | |||
892 | static int proc_init(struct snd_akm4xxx *ak) | ||
893 | { | ||
894 | struct snd_info_entry *entry; | ||
895 | int err; | ||
896 | err = snd_card_proc_new(ak->card, ak->name, &entry); | ||
897 | if (err < 0) | ||
898 | return err; | ||
899 | snd_info_set_text_ops(entry, ak, proc_regs_read); | ||
900 | return 0; | ||
901 | } | ||
902 | #else /* !CONFIG_PROC_FS */ | ||
903 | static int proc_init(struct snd_akm4xxx *ak) {} | ||
904 | #endif | ||
905 | |||
837 | int snd_akm4xxx_build_controls(struct snd_akm4xxx *ak) | 906 | int snd_akm4xxx_build_controls(struct snd_akm4xxx *ak) |
838 | { | 907 | { |
839 | int err, num_emphs; | 908 | int err, num_emphs; |
@@ -845,18 +914,21 @@ int snd_akm4xxx_build_controls(struct snd_akm4xxx *ak) | |||
845 | err = build_adc_controls(ak); | 914 | err = build_adc_controls(ak); |
846 | if (err < 0) | 915 | if (err < 0) |
847 | return err; | 916 | return err; |
848 | |||
849 | if (ak->type == SND_AK4355 || ak->type == SND_AK4358) | 917 | if (ak->type == SND_AK4355 || ak->type == SND_AK4358) |
850 | num_emphs = 1; | 918 | num_emphs = 1; |
919 | else if (ak->type == SND_AK4620) | ||
920 | num_emphs = 0; | ||
851 | else | 921 | else |
852 | num_emphs = ak->num_dacs / 2; | 922 | num_emphs = ak->num_dacs / 2; |
853 | err = build_deemphasis(ak, num_emphs); | 923 | err = build_deemphasis(ak, num_emphs); |
854 | if (err < 0) | 924 | if (err < 0) |
855 | return err; | 925 | return err; |
926 | err = proc_init(ak); | ||
927 | if (err < 0) | ||
928 | return err; | ||
856 | 929 | ||
857 | return 0; | 930 | return 0; |
858 | } | 931 | } |
859 | |||
860 | EXPORT_SYMBOL(snd_akm4xxx_build_controls); | 932 | EXPORT_SYMBOL(snd_akm4xxx_build_controls); |
861 | 933 | ||
862 | static int __init alsa_akm4xxx_module_init(void) | 934 | static int __init alsa_akm4xxx_module_init(void) |
diff --git a/sound/pci/hda/Kconfig b/sound/pci/hda/Kconfig index 55545e0818b5..556cff937be7 100644 --- a/sound/pci/hda/Kconfig +++ b/sound/pci/hda/Kconfig | |||
@@ -38,9 +38,20 @@ config SND_HDA_INPUT_BEEP | |||
38 | Say Y here to build a digital beep interface for HD-audio | 38 | Say Y here to build a digital beep interface for HD-audio |
39 | driver. This interface is used to generate digital beeps. | 39 | driver. This interface is used to generate digital beeps. |
40 | 40 | ||
41 | config SND_HDA_INPUT_BEEP_MODE | ||
42 | int "Digital beep registration mode (0=off, 1=on, 2=mute sw on/off)" | ||
43 | depends on SND_HDA_INPUT_BEEP=y | ||
44 | default "1" | ||
45 | range 0 2 | ||
46 | help | ||
47 | Set 0 to disable the digital beep interface for HD-audio by default. | ||
48 | Set 1 to always enable the digital beep interface for HD-audio by | ||
49 | default. Set 2 to control the beep device registration to input | ||
50 | layer using a "Beep Switch" in mixer applications. | ||
51 | |||
41 | config SND_HDA_INPUT_JACK | 52 | config SND_HDA_INPUT_JACK |
42 | bool "Support jack plugging notification via input layer" | 53 | bool "Support jack plugging notification via input layer" |
43 | depends on INPUT=y || INPUT=SND_HDA_INTEL | 54 | depends on INPUT=y || INPUT=SND |
44 | select SND_JACK | 55 | select SND_JACK |
45 | help | 56 | help |
46 | Say Y here to enable the jack plugging notification via | 57 | Say Y here to enable the jack plugging notification via |
diff --git a/sound/pci/hda/hda_beep.c b/sound/pci/hda/hda_beep.c index 3f51a981e604..5fe34a8d8c81 100644 --- a/sound/pci/hda/hda_beep.c +++ b/sound/pci/hda/hda_beep.c | |||
@@ -113,23 +113,25 @@ static int snd_hda_beep_event(struct input_dev *dev, unsigned int type, | |||
113 | return 0; | 113 | return 0; |
114 | } | 114 | } |
115 | 115 | ||
116 | int snd_hda_attach_beep_device(struct hda_codec *codec, int nid) | 116 | static void snd_hda_do_detach(struct hda_beep *beep) |
117 | { | ||
118 | input_unregister_device(beep->dev); | ||
119 | beep->dev = NULL; | ||
120 | cancel_work_sync(&beep->beep_work); | ||
121 | /* turn off beep for sure */ | ||
122 | snd_hda_codec_write_cache(beep->codec, beep->nid, 0, | ||
123 | AC_VERB_SET_BEEP_CONTROL, 0); | ||
124 | } | ||
125 | |||
126 | static int snd_hda_do_attach(struct hda_beep *beep) | ||
117 | { | 127 | { |
118 | struct input_dev *input_dev; | 128 | struct input_dev *input_dev; |
119 | struct hda_beep *beep; | 129 | struct hda_codec *codec = beep->codec; |
120 | int err; | 130 | int err; |
121 | 131 | ||
122 | if (!snd_hda_get_bool_hint(codec, "beep")) | ||
123 | return 0; /* disabled explicitly */ | ||
124 | |||
125 | beep = kzalloc(sizeof(*beep), GFP_KERNEL); | ||
126 | if (beep == NULL) | ||
127 | return -ENOMEM; | ||
128 | snprintf(beep->phys, sizeof(beep->phys), | ||
129 | "card%d/codec#%d/beep0", codec->bus->card->number, codec->addr); | ||
130 | input_dev = input_allocate_device(); | 132 | input_dev = input_allocate_device(); |
131 | if (!input_dev) { | 133 | if (!input_dev) { |
132 | kfree(beep); | 134 | printk(KERN_INFO "hda_beep: unable to allocate input device\n"); |
133 | return -ENOMEM; | 135 | return -ENOMEM; |
134 | } | 136 | } |
135 | 137 | ||
@@ -151,21 +153,96 @@ int snd_hda_attach_beep_device(struct hda_codec *codec, int nid) | |||
151 | err = input_register_device(input_dev); | 153 | err = input_register_device(input_dev); |
152 | if (err < 0) { | 154 | if (err < 0) { |
153 | input_free_device(input_dev); | 155 | input_free_device(input_dev); |
154 | kfree(beep); | 156 | printk(KERN_INFO "hda_beep: unable to register input device\n"); |
155 | return err; | 157 | return err; |
156 | } | 158 | } |
159 | beep->dev = input_dev; | ||
160 | return 0; | ||
161 | } | ||
162 | |||
163 | static void snd_hda_do_register(struct work_struct *work) | ||
164 | { | ||
165 | struct hda_beep *beep = | ||
166 | container_of(work, struct hda_beep, register_work); | ||
167 | |||
168 | mutex_lock(&beep->mutex); | ||
169 | if (beep->enabled && !beep->dev) | ||
170 | snd_hda_do_attach(beep); | ||
171 | mutex_unlock(&beep->mutex); | ||
172 | } | ||
173 | |||
174 | static void snd_hda_do_unregister(struct work_struct *work) | ||
175 | { | ||
176 | struct hda_beep *beep = | ||
177 | container_of(work, struct hda_beep, unregister_work.work); | ||
178 | |||
179 | mutex_lock(&beep->mutex); | ||
180 | if (!beep->enabled && beep->dev) | ||
181 | snd_hda_do_detach(beep); | ||
182 | mutex_unlock(&beep->mutex); | ||
183 | } | ||
157 | 184 | ||
185 | int snd_hda_enable_beep_device(struct hda_codec *codec, int enable) | ||
186 | { | ||
187 | struct hda_beep *beep = codec->beep; | ||
188 | enable = !!enable; | ||
189 | if (beep == NULL) | ||
190 | return 0; | ||
191 | if (beep->enabled != enable) { | ||
192 | beep->enabled = enable; | ||
193 | if (!enable) { | ||
194 | /* turn off beep */ | ||
195 | snd_hda_codec_write_cache(beep->codec, beep->nid, 0, | ||
196 | AC_VERB_SET_BEEP_CONTROL, 0); | ||
197 | } | ||
198 | if (beep->mode == HDA_BEEP_MODE_SWREG) { | ||
199 | if (enable) { | ||
200 | cancel_delayed_work(&beep->unregister_work); | ||
201 | schedule_work(&beep->register_work); | ||
202 | } else { | ||
203 | schedule_delayed_work(&beep->unregister_work, | ||
204 | HZ); | ||
205 | } | ||
206 | } | ||
207 | return 1; | ||
208 | } | ||
209 | return 0; | ||
210 | } | ||
211 | EXPORT_SYMBOL_HDA(snd_hda_enable_beep_device); | ||
212 | |||
213 | int snd_hda_attach_beep_device(struct hda_codec *codec, int nid) | ||
214 | { | ||
215 | struct hda_beep *beep; | ||
216 | |||
217 | if (!snd_hda_get_bool_hint(codec, "beep")) | ||
218 | return 0; /* disabled explicitly by hints */ | ||
219 | if (codec->beep_mode == HDA_BEEP_MODE_OFF) | ||
220 | return 0; /* disabled by module option */ | ||
221 | |||
222 | beep = kzalloc(sizeof(*beep), GFP_KERNEL); | ||
223 | if (beep == NULL) | ||
224 | return -ENOMEM; | ||
225 | snprintf(beep->phys, sizeof(beep->phys), | ||
226 | "card%d/codec#%d/beep0", codec->bus->card->number, codec->addr); | ||
158 | /* enable linear scale */ | 227 | /* enable linear scale */ |
159 | snd_hda_codec_write(codec, nid, 0, | 228 | snd_hda_codec_write(codec, nid, 0, |
160 | AC_VERB_SET_DIGI_CONVERT_2, 0x01); | 229 | AC_VERB_SET_DIGI_CONVERT_2, 0x01); |
161 | 230 | ||
162 | beep->nid = nid; | 231 | beep->nid = nid; |
163 | beep->dev = input_dev; | ||
164 | beep->codec = codec; | 232 | beep->codec = codec; |
165 | beep->enabled = 1; | 233 | beep->mode = codec->beep_mode; |
166 | codec->beep = beep; | 234 | codec->beep = beep; |
167 | 235 | ||
236 | INIT_WORK(&beep->register_work, &snd_hda_do_register); | ||
237 | INIT_DELAYED_WORK(&beep->unregister_work, &snd_hda_do_unregister); | ||
168 | INIT_WORK(&beep->beep_work, &snd_hda_generate_beep); | 238 | INIT_WORK(&beep->beep_work, &snd_hda_generate_beep); |
239 | mutex_init(&beep->mutex); | ||
240 | |||
241 | if (beep->mode == HDA_BEEP_MODE_ON) { | ||
242 | beep->enabled = 1; | ||
243 | snd_hda_do_register(&beep->register_work); | ||
244 | } | ||
245 | |||
169 | return 0; | 246 | return 0; |
170 | } | 247 | } |
171 | EXPORT_SYMBOL_HDA(snd_hda_attach_beep_device); | 248 | EXPORT_SYMBOL_HDA(snd_hda_attach_beep_device); |
@@ -174,11 +251,12 @@ void snd_hda_detach_beep_device(struct hda_codec *codec) | |||
174 | { | 251 | { |
175 | struct hda_beep *beep = codec->beep; | 252 | struct hda_beep *beep = codec->beep; |
176 | if (beep) { | 253 | if (beep) { |
177 | cancel_work_sync(&beep->beep_work); | 254 | cancel_work_sync(&beep->register_work); |
178 | 255 | cancel_delayed_work(&beep->unregister_work); | |
179 | input_unregister_device(beep->dev); | 256 | if (beep->enabled) |
180 | kfree(beep); | 257 | snd_hda_do_detach(beep); |
181 | codec->beep = NULL; | 258 | codec->beep = NULL; |
259 | kfree(beep); | ||
182 | } | 260 | } |
183 | } | 261 | } |
184 | EXPORT_SYMBOL_HDA(snd_hda_detach_beep_device); | 262 | EXPORT_SYMBOL_HDA(snd_hda_detach_beep_device); |
diff --git a/sound/pci/hda/hda_beep.h b/sound/pci/hda/hda_beep.h index 0c3de787c717..f1de1bac042c 100644 --- a/sound/pci/hda/hda_beep.h +++ b/sound/pci/hda/hda_beep.h | |||
@@ -24,19 +24,29 @@ | |||
24 | 24 | ||
25 | #include "hda_codec.h" | 25 | #include "hda_codec.h" |
26 | 26 | ||
27 | #define HDA_BEEP_MODE_OFF 0 | ||
28 | #define HDA_BEEP_MODE_ON 1 | ||
29 | #define HDA_BEEP_MODE_SWREG 2 | ||
30 | |||
27 | /* beep information */ | 31 | /* beep information */ |
28 | struct hda_beep { | 32 | struct hda_beep { |
29 | struct input_dev *dev; | 33 | struct input_dev *dev; |
30 | struct hda_codec *codec; | 34 | struct hda_codec *codec; |
35 | unsigned int mode; | ||
31 | char phys[32]; | 36 | char phys[32]; |
32 | int tone; | 37 | int tone; |
33 | hda_nid_t nid; | 38 | hda_nid_t nid; |
34 | unsigned int enabled:1; | 39 | unsigned int enabled:1; |
40 | unsigned int request_enable:1; | ||
35 | unsigned int linear_tone:1; /* linear tone for IDT/STAC codec */ | 41 | unsigned int linear_tone:1; /* linear tone for IDT/STAC codec */ |
42 | struct work_struct register_work; /* registration work */ | ||
43 | struct delayed_work unregister_work; /* unregistration work */ | ||
36 | struct work_struct beep_work; /* scheduled task for beep event */ | 44 | struct work_struct beep_work; /* scheduled task for beep event */ |
45 | struct mutex mutex; | ||
37 | }; | 46 | }; |
38 | 47 | ||
39 | #ifdef CONFIG_SND_HDA_INPUT_BEEP | 48 | #ifdef CONFIG_SND_HDA_INPUT_BEEP |
49 | int snd_hda_enable_beep_device(struct hda_codec *codec, int enable); | ||
40 | int snd_hda_attach_beep_device(struct hda_codec *codec, int nid); | 50 | int snd_hda_attach_beep_device(struct hda_codec *codec, int nid); |
41 | void snd_hda_detach_beep_device(struct hda_codec *codec); | 51 | void snd_hda_detach_beep_device(struct hda_codec *codec); |
42 | #else | 52 | #else |
diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c index af989f660cca..9cfdb771928c 100644 --- a/sound/pci/hda/hda_codec.c +++ b/sound/pci/hda/hda_codec.c | |||
@@ -30,6 +30,7 @@ | |||
30 | #include <sound/tlv.h> | 30 | #include <sound/tlv.h> |
31 | #include <sound/initval.h> | 31 | #include <sound/initval.h> |
32 | #include "hda_local.h" | 32 | #include "hda_local.h" |
33 | #include "hda_beep.h" | ||
33 | #include <sound/hda_hwdep.h> | 34 | #include <sound/hda_hwdep.h> |
34 | 35 | ||
35 | /* | 36 | /* |
@@ -93,6 +94,13 @@ static void hda_keep_power_on(struct hda_codec *codec); | |||
93 | static inline void hda_keep_power_on(struct hda_codec *codec) {} | 94 | static inline void hda_keep_power_on(struct hda_codec *codec) {} |
94 | #endif | 95 | #endif |
95 | 96 | ||
97 | /** | ||
98 | * snd_hda_get_jack_location - Give a location string of the jack | ||
99 | * @cfg: pin default config value | ||
100 | * | ||
101 | * Parse the pin default config value and returns the string of the | ||
102 | * jack location, e.g. "Rear", "Front", etc. | ||
103 | */ | ||
96 | const char *snd_hda_get_jack_location(u32 cfg) | 104 | const char *snd_hda_get_jack_location(u32 cfg) |
97 | { | 105 | { |
98 | static char *bases[7] = { | 106 | static char *bases[7] = { |
@@ -120,6 +128,13 @@ const char *snd_hda_get_jack_location(u32 cfg) | |||
120 | } | 128 | } |
121 | EXPORT_SYMBOL_HDA(snd_hda_get_jack_location); | 129 | EXPORT_SYMBOL_HDA(snd_hda_get_jack_location); |
122 | 130 | ||
131 | /** | ||
132 | * snd_hda_get_jack_connectivity - Give a connectivity string of the jack | ||
133 | * @cfg: pin default config value | ||
134 | * | ||
135 | * Parse the pin default config value and returns the string of the | ||
136 | * jack connectivity, i.e. external or internal connection. | ||
137 | */ | ||
123 | const char *snd_hda_get_jack_connectivity(u32 cfg) | 138 | const char *snd_hda_get_jack_connectivity(u32 cfg) |
124 | { | 139 | { |
125 | static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" }; | 140 | static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" }; |
@@ -128,6 +143,13 @@ const char *snd_hda_get_jack_connectivity(u32 cfg) | |||
128 | } | 143 | } |
129 | EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity); | 144 | EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity); |
130 | 145 | ||
146 | /** | ||
147 | * snd_hda_get_jack_type - Give a type string of the jack | ||
148 | * @cfg: pin default config value | ||
149 | * | ||
150 | * Parse the pin default config value and returns the string of the | ||
151 | * jack type, i.e. the purpose of the jack, such as Line-Out or CD. | ||
152 | */ | ||
131 | const char *snd_hda_get_jack_type(u32 cfg) | 153 | const char *snd_hda_get_jack_type(u32 cfg) |
132 | { | 154 | { |
133 | static char *jack_types[16] = { | 155 | static char *jack_types[16] = { |
@@ -515,6 +537,7 @@ static int snd_hda_bus_dev_register(struct snd_device *device) | |||
515 | struct hda_codec *codec; | 537 | struct hda_codec *codec; |
516 | list_for_each_entry(codec, &bus->codec_list, list) { | 538 | list_for_each_entry(codec, &bus->codec_list, list) { |
517 | snd_hda_hwdep_add_sysfs(codec); | 539 | snd_hda_hwdep_add_sysfs(codec); |
540 | snd_hda_hwdep_add_power_sysfs(codec); | ||
518 | } | 541 | } |
519 | return 0; | 542 | return 0; |
520 | } | 543 | } |
@@ -820,6 +843,16 @@ int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list, | |||
820 | return 0; | 843 | return 0; |
821 | } | 844 | } |
822 | 845 | ||
846 | /** | ||
847 | * snd_hda_codec_set_pincfg - Override a pin default configuration | ||
848 | * @codec: the HDA codec | ||
849 | * @nid: NID to set the pin config | ||
850 | * @cfg: the pin default config value | ||
851 | * | ||
852 | * Override a pin default configuration value in the cache. | ||
853 | * This value can be read by snd_hda_codec_get_pincfg() in a higher | ||
854 | * priority than the real hardware value. | ||
855 | */ | ||
823 | int snd_hda_codec_set_pincfg(struct hda_codec *codec, | 856 | int snd_hda_codec_set_pincfg(struct hda_codec *codec, |
824 | hda_nid_t nid, unsigned int cfg) | 857 | hda_nid_t nid, unsigned int cfg) |
825 | { | 858 | { |
@@ -827,7 +860,15 @@ int snd_hda_codec_set_pincfg(struct hda_codec *codec, | |||
827 | } | 860 | } |
828 | EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg); | 861 | EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg); |
829 | 862 | ||
830 | /* get the current pin config value of the given pin NID */ | 863 | /** |
864 | * snd_hda_codec_get_pincfg - Obtain a pin-default configuration | ||
865 | * @codec: the HDA codec | ||
866 | * @nid: NID to get the pin config | ||
867 | * | ||
868 | * Get the current pin config value of the given pin NID. | ||
869 | * If the pincfg value is cached or overridden via sysfs or driver, | ||
870 | * returns the cached value. | ||
871 | */ | ||
831 | unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid) | 872 | unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid) |
832 | { | 873 | { |
833 | struct hda_pincfg *pin; | 874 | struct hda_pincfg *pin; |
@@ -944,7 +985,7 @@ int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr | |||
944 | mutex_init(&codec->control_mutex); | 985 | mutex_init(&codec->control_mutex); |
945 | init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info)); | 986 | init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info)); |
946 | init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head)); | 987 | init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head)); |
947 | snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32); | 988 | snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 60); |
948 | snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16); | 989 | snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16); |
949 | snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16); | 990 | snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16); |
950 | if (codec->bus->modelname) { | 991 | if (codec->bus->modelname) { |
@@ -1026,6 +1067,15 @@ int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr | |||
1026 | } | 1067 | } |
1027 | EXPORT_SYMBOL_HDA(snd_hda_codec_new); | 1068 | EXPORT_SYMBOL_HDA(snd_hda_codec_new); |
1028 | 1069 | ||
1070 | /** | ||
1071 | * snd_hda_codec_configure - (Re-)configure the HD-audio codec | ||
1072 | * @codec: the HDA codec | ||
1073 | * | ||
1074 | * Start parsing of the given codec tree and (re-)initialize the whole | ||
1075 | * patch instance. | ||
1076 | * | ||
1077 | * Returns 0 if successful or a negative error code. | ||
1078 | */ | ||
1029 | int snd_hda_codec_configure(struct hda_codec *codec) | 1079 | int snd_hda_codec_configure(struct hda_codec *codec) |
1030 | { | 1080 | { |
1031 | int err; | 1081 | int err; |
@@ -1088,6 +1138,11 @@ void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid, | |||
1088 | } | 1138 | } |
1089 | EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream); | 1139 | EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream); |
1090 | 1140 | ||
1141 | /** | ||
1142 | * snd_hda_codec_cleanup_stream - clean up the codec for closing | ||
1143 | * @codec: the CODEC to clean up | ||
1144 | * @nid: the NID to clean up | ||
1145 | */ | ||
1091 | void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid) | 1146 | void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid) |
1092 | { | 1147 | { |
1093 | if (!nid) | 1148 | if (!nid) |
@@ -1163,8 +1218,17 @@ get_alloc_amp_hash(struct hda_codec *codec, u32 key) | |||
1163 | return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key); | 1218 | return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key); |
1164 | } | 1219 | } |
1165 | 1220 | ||
1166 | /* | 1221 | /** |
1167 | * query AMP capabilities for the given widget and direction | 1222 | * query_amp_caps - query AMP capabilities |
1223 | * @codec: the HD-auio codec | ||
1224 | * @nid: the NID to query | ||
1225 | * @direction: either #HDA_INPUT or #HDA_OUTPUT | ||
1226 | * | ||
1227 | * Query AMP capabilities for the given widget and direction. | ||
1228 | * Returns the obtained capability bits. | ||
1229 | * | ||
1230 | * When cap bits have been already read, this doesn't read again but | ||
1231 | * returns the cached value. | ||
1168 | */ | 1232 | */ |
1169 | u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction) | 1233 | u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction) |
1170 | { | 1234 | { |
@@ -1187,6 +1251,19 @@ u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction) | |||
1187 | } | 1251 | } |
1188 | EXPORT_SYMBOL_HDA(query_amp_caps); | 1252 | EXPORT_SYMBOL_HDA(query_amp_caps); |
1189 | 1253 | ||
1254 | /** | ||
1255 | * snd_hda_override_amp_caps - Override the AMP capabilities | ||
1256 | * @codec: the CODEC to clean up | ||
1257 | * @nid: the NID to clean up | ||
1258 | * @direction: either #HDA_INPUT or #HDA_OUTPUT | ||
1259 | * @caps: the capability bits to set | ||
1260 | * | ||
1261 | * Override the cached AMP caps bits value by the given one. | ||
1262 | * This function is useful if the driver needs to adjust the AMP ranges, | ||
1263 | * e.g. limit to 0dB, etc. | ||
1264 | * | ||
1265 | * Returns zero if successful or a negative error code. | ||
1266 | */ | ||
1190 | int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir, | 1267 | int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir, |
1191 | unsigned int caps) | 1268 | unsigned int caps) |
1192 | { | 1269 | { |
@@ -1222,6 +1299,17 @@ static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid) | |||
1222 | return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP); | 1299 | return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP); |
1223 | } | 1300 | } |
1224 | 1301 | ||
1302 | /** | ||
1303 | * snd_hda_query_pin_caps - Query PIN capabilities | ||
1304 | * @codec: the HD-auio codec | ||
1305 | * @nid: the NID to query | ||
1306 | * | ||
1307 | * Query PIN capabilities for the given widget. | ||
1308 | * Returns the obtained capability bits. | ||
1309 | * | ||
1310 | * When cap bits have been already read, this doesn't read again but | ||
1311 | * returns the cached value. | ||
1312 | */ | ||
1225 | u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid) | 1313 | u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid) |
1226 | { | 1314 | { |
1227 | return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid), | 1315 | return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid), |
@@ -1229,6 +1317,40 @@ u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid) | |||
1229 | } | 1317 | } |
1230 | EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps); | 1318 | EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps); |
1231 | 1319 | ||
1320 | /** | ||
1321 | * snd_hda_pin_sense - execute pin sense measurement | ||
1322 | * @codec: the CODEC to sense | ||
1323 | * @nid: the pin NID to sense | ||
1324 | * | ||
1325 | * Execute necessary pin sense measurement and return its Presence Detect, | ||
1326 | * Impedance, ELD Valid etc. status bits. | ||
1327 | */ | ||
1328 | u32 snd_hda_pin_sense(struct hda_codec *codec, hda_nid_t nid) | ||
1329 | { | ||
1330 | u32 pincap = snd_hda_query_pin_caps(codec, nid); | ||
1331 | |||
1332 | if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */ | ||
1333 | snd_hda_codec_read(codec, nid, 0, AC_VERB_SET_PIN_SENSE, 0); | ||
1334 | |||
1335 | return snd_hda_codec_read(codec, nid, 0, | ||
1336 | AC_VERB_GET_PIN_SENSE, 0); | ||
1337 | } | ||
1338 | EXPORT_SYMBOL_HDA(snd_hda_pin_sense); | ||
1339 | |||
1340 | /** | ||
1341 | * snd_hda_jack_detect - query pin Presence Detect status | ||
1342 | * @codec: the CODEC to sense | ||
1343 | * @nid: the pin NID to sense | ||
1344 | * | ||
1345 | * Query and return the pin's Presence Detect status. | ||
1346 | */ | ||
1347 | int snd_hda_jack_detect(struct hda_codec *codec, hda_nid_t nid) | ||
1348 | { | ||
1349 | u32 sense = snd_hda_pin_sense(codec, nid); | ||
1350 | return !!(sense & AC_PINSENSE_PRESENCE); | ||
1351 | } | ||
1352 | EXPORT_SYMBOL_HDA(snd_hda_jack_detect); | ||
1353 | |||
1232 | /* | 1354 | /* |
1233 | * read the current volume to info | 1355 | * read the current volume to info |
1234 | * if the cache exists, read the cache value. | 1356 | * if the cache exists, read the cache value. |
@@ -1269,8 +1391,15 @@ static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info, | |||
1269 | info->vol[ch] = val; | 1391 | info->vol[ch] = val; |
1270 | } | 1392 | } |
1271 | 1393 | ||
1272 | /* | 1394 | /** |
1273 | * read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit. | 1395 | * snd_hda_codec_amp_read - Read AMP value |
1396 | * @codec: HD-audio codec | ||
1397 | * @nid: NID to read the AMP value | ||
1398 | * @ch: channel (left=0 or right=1) | ||
1399 | * @direction: #HDA_INPUT or #HDA_OUTPUT | ||
1400 | * @index: the index value (only for input direction) | ||
1401 | * | ||
1402 | * Read AMP value. The volume is between 0 to 0x7f, 0x80 = mute bit. | ||
1274 | */ | 1403 | */ |
1275 | int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch, | 1404 | int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch, |
1276 | int direction, int index) | 1405 | int direction, int index) |
@@ -1283,8 +1412,18 @@ int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch, | |||
1283 | } | 1412 | } |
1284 | EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read); | 1413 | EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read); |
1285 | 1414 | ||
1286 | /* | 1415 | /** |
1287 | * update the AMP value, mask = bit mask to set, val = the value | 1416 | * snd_hda_codec_amp_update - update the AMP value |
1417 | * @codec: HD-audio codec | ||
1418 | * @nid: NID to read the AMP value | ||
1419 | * @ch: channel (left=0 or right=1) | ||
1420 | * @direction: #HDA_INPUT or #HDA_OUTPUT | ||
1421 | * @idx: the index value (only for input direction) | ||
1422 | * @mask: bit mask to set | ||
1423 | * @val: the bits value to set | ||
1424 | * | ||
1425 | * Update the AMP value with a bit mask. | ||
1426 | * Returns 0 if the value is unchanged, 1 if changed. | ||
1288 | */ | 1427 | */ |
1289 | int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch, | 1428 | int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch, |
1290 | int direction, int idx, int mask, int val) | 1429 | int direction, int idx, int mask, int val) |
@@ -1303,8 +1442,17 @@ int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch, | |||
1303 | } | 1442 | } |
1304 | EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update); | 1443 | EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update); |
1305 | 1444 | ||
1306 | /* | 1445 | /** |
1307 | * update the AMP stereo with the same mask and value | 1446 | * snd_hda_codec_amp_stereo - update the AMP stereo values |
1447 | * @codec: HD-audio codec | ||
1448 | * @nid: NID to read the AMP value | ||
1449 | * @direction: #HDA_INPUT or #HDA_OUTPUT | ||
1450 | * @idx: the index value (only for input direction) | ||
1451 | * @mask: bit mask to set | ||
1452 | * @val: the bits value to set | ||
1453 | * | ||
1454 | * Update the AMP values like snd_hda_codec_amp_update(), but for a | ||
1455 | * stereo widget with the same mask and value. | ||
1308 | */ | 1456 | */ |
1309 | int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid, | 1457 | int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid, |
1310 | int direction, int idx, int mask, int val) | 1458 | int direction, int idx, int mask, int val) |
@@ -1318,7 +1466,12 @@ int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid, | |||
1318 | EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo); | 1466 | EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo); |
1319 | 1467 | ||
1320 | #ifdef SND_HDA_NEEDS_RESUME | 1468 | #ifdef SND_HDA_NEEDS_RESUME |
1321 | /* resume the all amp commands from the cache */ | 1469 | /** |
1470 | * snd_hda_codec_resume_amp - Resume all AMP commands from the cache | ||
1471 | * @codec: HD-audio codec | ||
1472 | * | ||
1473 | * Resume the all amp commands from the cache. | ||
1474 | */ | ||
1322 | void snd_hda_codec_resume_amp(struct hda_codec *codec) | 1475 | void snd_hda_codec_resume_amp(struct hda_codec *codec) |
1323 | { | 1476 | { |
1324 | struct hda_amp_info *buffer = codec->amp_cache.buf.list; | 1477 | struct hda_amp_info *buffer = codec->amp_cache.buf.list; |
@@ -1344,7 +1497,12 @@ void snd_hda_codec_resume_amp(struct hda_codec *codec) | |||
1344 | EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp); | 1497 | EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp); |
1345 | #endif /* SND_HDA_NEEDS_RESUME */ | 1498 | #endif /* SND_HDA_NEEDS_RESUME */ |
1346 | 1499 | ||
1347 | /* volume */ | 1500 | /** |
1501 | * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer | ||
1502 | * | ||
1503 | * The control element is supposed to have the private_value field | ||
1504 | * set up via HDA_COMPOSE_AMP_VAL*() or related macros. | ||
1505 | */ | ||
1348 | int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol, | 1506 | int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol, |
1349 | struct snd_ctl_elem_info *uinfo) | 1507 | struct snd_ctl_elem_info *uinfo) |
1350 | { | 1508 | { |
@@ -1400,6 +1558,12 @@ update_amp_value(struct hda_codec *codec, hda_nid_t nid, | |||
1400 | HDA_AMP_VOLMASK, val); | 1558 | HDA_AMP_VOLMASK, val); |
1401 | } | 1559 | } |
1402 | 1560 | ||
1561 | /** | ||
1562 | * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume | ||
1563 | * | ||
1564 | * The control element is supposed to have the private_value field | ||
1565 | * set up via HDA_COMPOSE_AMP_VAL*() or related macros. | ||
1566 | */ | ||
1403 | int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol, | 1567 | int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol, |
1404 | struct snd_ctl_elem_value *ucontrol) | 1568 | struct snd_ctl_elem_value *ucontrol) |
1405 | { | 1569 | { |
@@ -1419,6 +1583,12 @@ int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol, | |||
1419 | } | 1583 | } |
1420 | EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get); | 1584 | EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get); |
1421 | 1585 | ||
1586 | /** | ||
1587 | * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume | ||
1588 | * | ||
1589 | * The control element is supposed to have the private_value field | ||
1590 | * set up via HDA_COMPOSE_AMP_VAL*() or related macros. | ||
1591 | */ | ||
1422 | int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol, | 1592 | int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol, |
1423 | struct snd_ctl_elem_value *ucontrol) | 1593 | struct snd_ctl_elem_value *ucontrol) |
1424 | { | 1594 | { |
@@ -1443,6 +1613,12 @@ int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol, | |||
1443 | } | 1613 | } |
1444 | EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put); | 1614 | EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put); |
1445 | 1615 | ||
1616 | /** | ||
1617 | * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume | ||
1618 | * | ||
1619 | * The control element is supposed to have the private_value field | ||
1620 | * set up via HDA_COMPOSE_AMP_VAL*() or related macros. | ||
1621 | */ | ||
1446 | int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag, | 1622 | int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag, |
1447 | unsigned int size, unsigned int __user *_tlv) | 1623 | unsigned int size, unsigned int __user *_tlv) |
1448 | { | 1624 | { |
@@ -1472,8 +1648,16 @@ int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag, | |||
1472 | } | 1648 | } |
1473 | EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv); | 1649 | EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv); |
1474 | 1650 | ||
1475 | /* | 1651 | /** |
1476 | * set (static) TLV for virtual master volume; recalculated as max 0dB | 1652 | * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control |
1653 | * @codec: HD-audio codec | ||
1654 | * @nid: NID of a reference widget | ||
1655 | * @dir: #HDA_INPUT or #HDA_OUTPUT | ||
1656 | * @tlv: TLV data to be stored, at least 4 elements | ||
1657 | * | ||
1658 | * Set (static) TLV data for a virtual master volume using the AMP caps | ||
1659 | * obtained from the reference NID. | ||
1660 | * The volume range is recalculated as if the max volume is 0dB. | ||
1477 | */ | 1661 | */ |
1478 | void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir, | 1662 | void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir, |
1479 | unsigned int *tlv) | 1663 | unsigned int *tlv) |
@@ -1507,6 +1691,13 @@ _snd_hda_find_mixer_ctl(struct hda_codec *codec, | |||
1507 | return snd_ctl_find_id(codec->bus->card, &id); | 1691 | return snd_ctl_find_id(codec->bus->card, &id); |
1508 | } | 1692 | } |
1509 | 1693 | ||
1694 | /** | ||
1695 | * snd_hda_find_mixer_ctl - Find a mixer control element with the given name | ||
1696 | * @codec: HD-audio codec | ||
1697 | * @name: ctl id name string | ||
1698 | * | ||
1699 | * Get the control element with the given id string and IFACE_MIXER. | ||
1700 | */ | ||
1510 | struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec, | 1701 | struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec, |
1511 | const char *name) | 1702 | const char *name) |
1512 | { | 1703 | { |
@@ -1514,30 +1705,57 @@ struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec, | |||
1514 | } | 1705 | } |
1515 | EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl); | 1706 | EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl); |
1516 | 1707 | ||
1517 | /* Add a control element and assign to the codec */ | 1708 | /** |
1518 | int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl) | 1709 | * snd_hda_ctl-add - Add a control element and assign to the codec |
1710 | * @codec: HD-audio codec | ||
1711 | * @nid: corresponding NID (optional) | ||
1712 | * @kctl: the control element to assign | ||
1713 | * | ||
1714 | * Add the given control element to an array inside the codec instance. | ||
1715 | * All control elements belonging to a codec are supposed to be added | ||
1716 | * by this function so that a proper clean-up works at the free or | ||
1717 | * reconfiguration time. | ||
1718 | * | ||
1719 | * If non-zero @nid is passed, the NID is assigned to the control element. | ||
1720 | * The assignment is shown in the codec proc file. | ||
1721 | * | ||
1722 | * snd_hda_ctl_add() checks the control subdev id field whether | ||
1723 | * #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower | ||
1724 | * bits value is taken as the NID to assign. | ||
1725 | */ | ||
1726 | int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid, | ||
1727 | struct snd_kcontrol *kctl) | ||
1519 | { | 1728 | { |
1520 | int err; | 1729 | int err; |
1521 | struct snd_kcontrol **knewp; | 1730 | struct hda_nid_item *item; |
1522 | 1731 | ||
1732 | if (kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) { | ||
1733 | if (nid == 0) | ||
1734 | nid = kctl->id.subdevice & 0xffff; | ||
1735 | kctl->id.subdevice = 0; | ||
1736 | } | ||
1523 | err = snd_ctl_add(codec->bus->card, kctl); | 1737 | err = snd_ctl_add(codec->bus->card, kctl); |
1524 | if (err < 0) | 1738 | if (err < 0) |
1525 | return err; | 1739 | return err; |
1526 | knewp = snd_array_new(&codec->mixers); | 1740 | item = snd_array_new(&codec->mixers); |
1527 | if (!knewp) | 1741 | if (!item) |
1528 | return -ENOMEM; | 1742 | return -ENOMEM; |
1529 | *knewp = kctl; | 1743 | item->kctl = kctl; |
1744 | item->nid = nid; | ||
1530 | return 0; | 1745 | return 0; |
1531 | } | 1746 | } |
1532 | EXPORT_SYMBOL_HDA(snd_hda_ctl_add); | 1747 | EXPORT_SYMBOL_HDA(snd_hda_ctl_add); |
1533 | 1748 | ||
1534 | /* Clear all controls assigned to the given codec */ | 1749 | /** |
1750 | * snd_hda_ctls_clear - Clear all controls assigned to the given codec | ||
1751 | * @codec: HD-audio codec | ||
1752 | */ | ||
1535 | void snd_hda_ctls_clear(struct hda_codec *codec) | 1753 | void snd_hda_ctls_clear(struct hda_codec *codec) |
1536 | { | 1754 | { |
1537 | int i; | 1755 | int i; |
1538 | struct snd_kcontrol **kctls = codec->mixers.list; | 1756 | struct hda_nid_item *items = codec->mixers.list; |
1539 | for (i = 0; i < codec->mixers.used; i++) | 1757 | for (i = 0; i < codec->mixers.used; i++) |
1540 | snd_ctl_remove(codec->bus->card, kctls[i]); | 1758 | snd_ctl_remove(codec->bus->card, items[i].kctl); |
1541 | snd_array_free(&codec->mixers); | 1759 | snd_array_free(&codec->mixers); |
1542 | } | 1760 | } |
1543 | 1761 | ||
@@ -1563,6 +1781,16 @@ static void hda_unlock_devices(struct snd_card *card) | |||
1563 | spin_unlock(&card->files_lock); | 1781 | spin_unlock(&card->files_lock); |
1564 | } | 1782 | } |
1565 | 1783 | ||
1784 | /** | ||
1785 | * snd_hda_codec_reset - Clear all objects assigned to the codec | ||
1786 | * @codec: HD-audio codec | ||
1787 | * | ||
1788 | * This frees the all PCM and control elements assigned to the codec, and | ||
1789 | * clears the caches and restores the pin default configurations. | ||
1790 | * | ||
1791 | * When a device is being used, it returns -EBSY. If successfully freed, | ||
1792 | * returns zero. | ||
1793 | */ | ||
1566 | int snd_hda_codec_reset(struct hda_codec *codec) | 1794 | int snd_hda_codec_reset(struct hda_codec *codec) |
1567 | { | 1795 | { |
1568 | struct snd_card *card = codec->bus->card; | 1796 | struct snd_card *card = codec->bus->card; |
@@ -1626,7 +1854,22 @@ int snd_hda_codec_reset(struct hda_codec *codec) | |||
1626 | return 0; | 1854 | return 0; |
1627 | } | 1855 | } |
1628 | 1856 | ||
1629 | /* create a virtual master control and add slaves */ | 1857 | /** |
1858 | * snd_hda_add_vmaster - create a virtual master control and add slaves | ||
1859 | * @codec: HD-audio codec | ||
1860 | * @name: vmaster control name | ||
1861 | * @tlv: TLV data (optional) | ||
1862 | * @slaves: slave control names (optional) | ||
1863 | * | ||
1864 | * Create a virtual master control with the given name. The TLV data | ||
1865 | * must be either NULL or a valid data. | ||
1866 | * | ||
1867 | * @slaves is a NULL-terminated array of strings, each of which is a | ||
1868 | * slave control name. All controls with these names are assigned to | ||
1869 | * the new virtual master control. | ||
1870 | * | ||
1871 | * This function returns zero if successful or a negative error code. | ||
1872 | */ | ||
1630 | int snd_hda_add_vmaster(struct hda_codec *codec, char *name, | 1873 | int snd_hda_add_vmaster(struct hda_codec *codec, char *name, |
1631 | unsigned int *tlv, const char **slaves) | 1874 | unsigned int *tlv, const char **slaves) |
1632 | { | 1875 | { |
@@ -1643,7 +1886,7 @@ int snd_hda_add_vmaster(struct hda_codec *codec, char *name, | |||
1643 | kctl = snd_ctl_make_virtual_master(name, tlv); | 1886 | kctl = snd_ctl_make_virtual_master(name, tlv); |
1644 | if (!kctl) | 1887 | if (!kctl) |
1645 | return -ENOMEM; | 1888 | return -ENOMEM; |
1646 | err = snd_hda_ctl_add(codec, kctl); | 1889 | err = snd_hda_ctl_add(codec, 0, kctl); |
1647 | if (err < 0) | 1890 | if (err < 0) |
1648 | return err; | 1891 | return err; |
1649 | 1892 | ||
@@ -1668,7 +1911,12 @@ int snd_hda_add_vmaster(struct hda_codec *codec, char *name, | |||
1668 | } | 1911 | } |
1669 | EXPORT_SYMBOL_HDA(snd_hda_add_vmaster); | 1912 | EXPORT_SYMBOL_HDA(snd_hda_add_vmaster); |
1670 | 1913 | ||
1671 | /* switch */ | 1914 | /** |
1915 | * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch | ||
1916 | * | ||
1917 | * The control element is supposed to have the private_value field | ||
1918 | * set up via HDA_COMPOSE_AMP_VAL*() or related macros. | ||
1919 | */ | ||
1672 | int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol, | 1920 | int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol, |
1673 | struct snd_ctl_elem_info *uinfo) | 1921 | struct snd_ctl_elem_info *uinfo) |
1674 | { | 1922 | { |
@@ -1682,6 +1930,12 @@ int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol, | |||
1682 | } | 1930 | } |
1683 | EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info); | 1931 | EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info); |
1684 | 1932 | ||
1933 | /** | ||
1934 | * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch | ||
1935 | * | ||
1936 | * The control element is supposed to have the private_value field | ||
1937 | * set up via HDA_COMPOSE_AMP_VAL*() or related macros. | ||
1938 | */ | ||
1685 | int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol, | 1939 | int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol, |
1686 | struct snd_ctl_elem_value *ucontrol) | 1940 | struct snd_ctl_elem_value *ucontrol) |
1687 | { | 1941 | { |
@@ -1702,6 +1956,12 @@ int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol, | |||
1702 | } | 1956 | } |
1703 | EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get); | 1957 | EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get); |
1704 | 1958 | ||
1959 | /** | ||
1960 | * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch | ||
1961 | * | ||
1962 | * The control element is supposed to have the private_value field | ||
1963 | * set up via HDA_COMPOSE_AMP_VAL*() or related macros. | ||
1964 | */ | ||
1705 | int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol, | 1965 | int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol, |
1706 | struct snd_ctl_elem_value *ucontrol) | 1966 | struct snd_ctl_elem_value *ucontrol) |
1707 | { | 1967 | { |
@@ -1733,6 +1993,25 @@ int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol, | |||
1733 | } | 1993 | } |
1734 | EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put); | 1994 | EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put); |
1735 | 1995 | ||
1996 | #ifdef CONFIG_SND_HDA_INPUT_BEEP | ||
1997 | /** | ||
1998 | * snd_hda_mixer_amp_switch_put_beep - Put callback for a beep AMP switch | ||
1999 | * | ||
2000 | * This function calls snd_hda_enable_beep_device(), which behaves differently | ||
2001 | * depending on beep_mode option. | ||
2002 | */ | ||
2003 | int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol, | ||
2004 | struct snd_ctl_elem_value *ucontrol) | ||
2005 | { | ||
2006 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | ||
2007 | long *valp = ucontrol->value.integer.value; | ||
2008 | |||
2009 | snd_hda_enable_beep_device(codec, *valp); | ||
2010 | return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol); | ||
2011 | } | ||
2012 | EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep); | ||
2013 | #endif /* CONFIG_SND_HDA_INPUT_BEEP */ | ||
2014 | |||
1736 | /* | 2015 | /* |
1737 | * bound volume controls | 2016 | * bound volume controls |
1738 | * | 2017 | * |
@@ -1742,6 +2021,12 @@ EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put); | |||
1742 | #define AMP_VAL_IDX_SHIFT 19 | 2021 | #define AMP_VAL_IDX_SHIFT 19 |
1743 | #define AMP_VAL_IDX_MASK (0x0f<<19) | 2022 | #define AMP_VAL_IDX_MASK (0x0f<<19) |
1744 | 2023 | ||
2024 | /** | ||
2025 | * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control | ||
2026 | * | ||
2027 | * The control element is supposed to have the private_value field | ||
2028 | * set up via HDA_BIND_MUTE*() macros. | ||
2029 | */ | ||
1745 | int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol, | 2030 | int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol, |
1746 | struct snd_ctl_elem_value *ucontrol) | 2031 | struct snd_ctl_elem_value *ucontrol) |
1747 | { | 2032 | { |
@@ -1759,6 +2044,12 @@ int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol, | |||
1759 | } | 2044 | } |
1760 | EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get); | 2045 | EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get); |
1761 | 2046 | ||
2047 | /** | ||
2048 | * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control | ||
2049 | * | ||
2050 | * The control element is supposed to have the private_value field | ||
2051 | * set up via HDA_BIND_MUTE*() macros. | ||
2052 | */ | ||
1762 | int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol, | 2053 | int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol, |
1763 | struct snd_ctl_elem_value *ucontrol) | 2054 | struct snd_ctl_elem_value *ucontrol) |
1764 | { | 2055 | { |
@@ -1783,8 +2074,11 @@ int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol, | |||
1783 | } | 2074 | } |
1784 | EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put); | 2075 | EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put); |
1785 | 2076 | ||
1786 | /* | 2077 | /** |
1787 | * generic bound volume/swtich controls | 2078 | * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control |
2079 | * | ||
2080 | * The control element is supposed to have the private_value field | ||
2081 | * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros. | ||
1788 | */ | 2082 | */ |
1789 | int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol, | 2083 | int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol, |
1790 | struct snd_ctl_elem_info *uinfo) | 2084 | struct snd_ctl_elem_info *uinfo) |
@@ -1803,6 +2097,12 @@ int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol, | |||
1803 | } | 2097 | } |
1804 | EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info); | 2098 | EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info); |
1805 | 2099 | ||
2100 | /** | ||
2101 | * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control | ||
2102 | * | ||
2103 | * The control element is supposed to have the private_value field | ||
2104 | * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros. | ||
2105 | */ | ||
1806 | int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol, | 2106 | int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol, |
1807 | struct snd_ctl_elem_value *ucontrol) | 2107 | struct snd_ctl_elem_value *ucontrol) |
1808 | { | 2108 | { |
@@ -1820,6 +2120,12 @@ int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol, | |||
1820 | } | 2120 | } |
1821 | EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get); | 2121 | EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get); |
1822 | 2122 | ||
2123 | /** | ||
2124 | * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control | ||
2125 | * | ||
2126 | * The control element is supposed to have the private_value field | ||
2127 | * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros. | ||
2128 | */ | ||
1823 | int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol, | 2129 | int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol, |
1824 | struct snd_ctl_elem_value *ucontrol) | 2130 | struct snd_ctl_elem_value *ucontrol) |
1825 | { | 2131 | { |
@@ -1843,6 +2149,12 @@ int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol, | |||
1843 | } | 2149 | } |
1844 | EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put); | 2150 | EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put); |
1845 | 2151 | ||
2152 | /** | ||
2153 | * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control | ||
2154 | * | ||
2155 | * The control element is supposed to have the private_value field | ||
2156 | * set up via HDA_BIND_VOL() macro. | ||
2157 | */ | ||
1846 | int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag, | 2158 | int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag, |
1847 | unsigned int size, unsigned int __user *tlv) | 2159 | unsigned int size, unsigned int __user *tlv) |
1848 | { | 2160 | { |
@@ -2126,7 +2438,7 @@ int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid) | |||
2126 | return -ENOMEM; | 2438 | return -ENOMEM; |
2127 | kctl->id.index = idx; | 2439 | kctl->id.index = idx; |
2128 | kctl->private_value = nid; | 2440 | kctl->private_value = nid; |
2129 | err = snd_hda_ctl_add(codec, kctl); | 2441 | err = snd_hda_ctl_add(codec, nid, kctl); |
2130 | if (err < 0) | 2442 | if (err < 0) |
2131 | return err; | 2443 | return err; |
2132 | } | 2444 | } |
@@ -2165,14 +2477,19 @@ static struct snd_kcontrol_new spdif_share_sw = { | |||
2165 | .put = spdif_share_sw_put, | 2477 | .put = spdif_share_sw_put, |
2166 | }; | 2478 | }; |
2167 | 2479 | ||
2480 | /** | ||
2481 | * snd_hda_create_spdif_share_sw - create Default PCM switch | ||
2482 | * @codec: the HDA codec | ||
2483 | * @mout: multi-out instance | ||
2484 | */ | ||
2168 | int snd_hda_create_spdif_share_sw(struct hda_codec *codec, | 2485 | int snd_hda_create_spdif_share_sw(struct hda_codec *codec, |
2169 | struct hda_multi_out *mout) | 2486 | struct hda_multi_out *mout) |
2170 | { | 2487 | { |
2171 | if (!mout->dig_out_nid) | 2488 | if (!mout->dig_out_nid) |
2172 | return 0; | 2489 | return 0; |
2173 | /* ATTENTION: here mout is passed as private_data, instead of codec */ | 2490 | /* ATTENTION: here mout is passed as private_data, instead of codec */ |
2174 | return snd_hda_ctl_add(codec, | 2491 | return snd_hda_ctl_add(codec, mout->dig_out_nid, |
2175 | snd_ctl_new1(&spdif_share_sw, mout)); | 2492 | snd_ctl_new1(&spdif_share_sw, mout)); |
2176 | } | 2493 | } |
2177 | EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw); | 2494 | EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw); |
2178 | 2495 | ||
@@ -2276,7 +2593,7 @@ int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid) | |||
2276 | if (!kctl) | 2593 | if (!kctl) |
2277 | return -ENOMEM; | 2594 | return -ENOMEM; |
2278 | kctl->private_value = nid; | 2595 | kctl->private_value = nid; |
2279 | err = snd_hda_ctl_add(codec, kctl); | 2596 | err = snd_hda_ctl_add(codec, nid, kctl); |
2280 | if (err < 0) | 2597 | if (err < 0) |
2281 | return err; | 2598 | return err; |
2282 | } | 2599 | } |
@@ -2332,7 +2649,12 @@ int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid, | |||
2332 | } | 2649 | } |
2333 | EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache); | 2650 | EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache); |
2334 | 2651 | ||
2335 | /* resume the all commands from the cache */ | 2652 | /** |
2653 | * snd_hda_codec_resume_cache - Resume the all commands from the cache | ||
2654 | * @codec: HD-audio codec | ||
2655 | * | ||
2656 | * Execute all verbs recorded in the command caches to resume. | ||
2657 | */ | ||
2336 | void snd_hda_codec_resume_cache(struct hda_codec *codec) | 2658 | void snd_hda_codec_resume_cache(struct hda_codec *codec) |
2337 | { | 2659 | { |
2338 | struct hda_cache_head *buffer = codec->cmd_cache.buf.list; | 2660 | struct hda_cache_head *buffer = codec->cmd_cache.buf.list; |
@@ -2452,9 +2774,11 @@ static void hda_call_codec_suspend(struct hda_codec *codec) | |||
2452 | codec->afg ? codec->afg : codec->mfg, | 2774 | codec->afg ? codec->afg : codec->mfg, |
2453 | AC_PWRST_D3); | 2775 | AC_PWRST_D3); |
2454 | #ifdef CONFIG_SND_HDA_POWER_SAVE | 2776 | #ifdef CONFIG_SND_HDA_POWER_SAVE |
2777 | snd_hda_update_power_acct(codec); | ||
2455 | cancel_delayed_work(&codec->power_work); | 2778 | cancel_delayed_work(&codec->power_work); |
2456 | codec->power_on = 0; | 2779 | codec->power_on = 0; |
2457 | codec->power_transition = 0; | 2780 | codec->power_transition = 0; |
2781 | codec->power_jiffies = jiffies; | ||
2458 | #endif | 2782 | #endif |
2459 | } | 2783 | } |
2460 | 2784 | ||
@@ -2756,8 +3080,12 @@ static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid, | |||
2756 | } | 3080 | } |
2757 | 3081 | ||
2758 | /** | 3082 | /** |
2759 | * snd_hda_is_supported_format - check whether the given node supports | 3083 | * snd_hda_is_supported_format - Check the validity of the format |
2760 | * the format val | 3084 | * @codec: HD-audio codec |
3085 | * @nid: NID to check | ||
3086 | * @format: the HD-audio format value to check | ||
3087 | * | ||
3088 | * Check whether the given node supports the format value. | ||
2761 | * | 3089 | * |
2762 | * Returns 1 if supported, 0 if not. | 3090 | * Returns 1 if supported, 0 if not. |
2763 | */ | 3091 | */ |
@@ -2877,51 +3205,36 @@ static int set_pcm_default_values(struct hda_codec *codec, | |||
2877 | return 0; | 3205 | return 0; |
2878 | } | 3206 | } |
2879 | 3207 | ||
3208 | /* global */ | ||
3209 | const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = { | ||
3210 | "Audio", "SPDIF", "HDMI", "Modem" | ||
3211 | }; | ||
3212 | |||
2880 | /* | 3213 | /* |
2881 | * get the empty PCM device number to assign | 3214 | * get the empty PCM device number to assign |
2882 | */ | 3215 | */ |
2883 | static int get_empty_pcm_device(struct hda_bus *bus, int type) | 3216 | static int get_empty_pcm_device(struct hda_bus *bus, int type) |
2884 | { | 3217 | { |
2885 | static const char *dev_name[HDA_PCM_NTYPES] = { | 3218 | /* audio device indices; not linear to keep compatibility */ |
2886 | "Audio", "SPDIF", "HDMI", "Modem" | 3219 | static int audio_idx[HDA_PCM_NTYPES][5] = { |
2887 | }; | 3220 | [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 }, |
2888 | /* starting device index for each PCM type */ | 3221 | [HDA_PCM_TYPE_SPDIF] = { 1, -1 }, |
2889 | static int dev_idx[HDA_PCM_NTYPES] = { | 3222 | [HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 }, |
2890 | [HDA_PCM_TYPE_AUDIO] = 0, | 3223 | [HDA_PCM_TYPE_MODEM] = { 6, -1 }, |
2891 | [HDA_PCM_TYPE_SPDIF] = 1, | ||
2892 | [HDA_PCM_TYPE_HDMI] = 3, | ||
2893 | [HDA_PCM_TYPE_MODEM] = 6 | ||
2894 | }; | 3224 | }; |
2895 | /* normal audio device indices; not linear to keep compatibility */ | 3225 | int i; |
2896 | static int audio_idx[4] = { 0, 2, 4, 5 }; | 3226 | |
2897 | int i, dev; | 3227 | if (type >= HDA_PCM_NTYPES) { |
2898 | |||
2899 | switch (type) { | ||
2900 | case HDA_PCM_TYPE_AUDIO: | ||
2901 | for (i = 0; i < ARRAY_SIZE(audio_idx); i++) { | ||
2902 | dev = audio_idx[i]; | ||
2903 | if (!test_bit(dev, bus->pcm_dev_bits)) | ||
2904 | goto ok; | ||
2905 | } | ||
2906 | snd_printk(KERN_WARNING "Too many audio devices\n"); | ||
2907 | return -EAGAIN; | ||
2908 | case HDA_PCM_TYPE_SPDIF: | ||
2909 | case HDA_PCM_TYPE_HDMI: | ||
2910 | case HDA_PCM_TYPE_MODEM: | ||
2911 | dev = dev_idx[type]; | ||
2912 | if (test_bit(dev, bus->pcm_dev_bits)) { | ||
2913 | snd_printk(KERN_WARNING "%s already defined\n", | ||
2914 | dev_name[type]); | ||
2915 | return -EAGAIN; | ||
2916 | } | ||
2917 | break; | ||
2918 | default: | ||
2919 | snd_printk(KERN_WARNING "Invalid PCM type %d\n", type); | 3228 | snd_printk(KERN_WARNING "Invalid PCM type %d\n", type); |
2920 | return -EINVAL; | 3229 | return -EINVAL; |
2921 | } | 3230 | } |
2922 | ok: | 3231 | |
2923 | set_bit(dev, bus->pcm_dev_bits); | 3232 | for (i = 0; audio_idx[type][i] >= 0 ; i++) |
2924 | return dev; | 3233 | if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits)) |
3234 | return audio_idx[type][i]; | ||
3235 | |||
3236 | snd_printk(KERN_WARNING "Too many %s devices\n", snd_hda_pcm_type_name[type]); | ||
3237 | return -EAGAIN; | ||
2925 | } | 3238 | } |
2926 | 3239 | ||
2927 | /* | 3240 | /* |
@@ -3159,14 +3472,14 @@ EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config); | |||
3159 | */ | 3472 | */ |
3160 | int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew) | 3473 | int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew) |
3161 | { | 3474 | { |
3162 | int err; | 3475 | int err; |
3163 | 3476 | ||
3164 | for (; knew->name; knew++) { | 3477 | for (; knew->name; knew++) { |
3165 | struct snd_kcontrol *kctl; | 3478 | struct snd_kcontrol *kctl; |
3166 | kctl = snd_ctl_new1(knew, codec); | 3479 | kctl = snd_ctl_new1(knew, codec); |
3167 | if (!kctl) | 3480 | if (!kctl) |
3168 | return -ENOMEM; | 3481 | return -ENOMEM; |
3169 | err = snd_hda_ctl_add(codec, kctl); | 3482 | err = snd_hda_ctl_add(codec, 0, kctl); |
3170 | if (err < 0) { | 3483 | if (err < 0) { |
3171 | if (!codec->addr) | 3484 | if (!codec->addr) |
3172 | return err; | 3485 | return err; |
@@ -3174,7 +3487,7 @@ int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew) | |||
3174 | if (!kctl) | 3487 | if (!kctl) |
3175 | return -ENOMEM; | 3488 | return -ENOMEM; |
3176 | kctl->id.device = codec->addr; | 3489 | kctl->id.device = codec->addr; |
3177 | err = snd_hda_ctl_add(codec, kctl); | 3490 | err = snd_hda_ctl_add(codec, 0, kctl); |
3178 | if (err < 0) | 3491 | if (err < 0) |
3179 | return err; | 3492 | return err; |
3180 | } | 3493 | } |
@@ -3207,8 +3520,27 @@ static void hda_keep_power_on(struct hda_codec *codec) | |||
3207 | { | 3520 | { |
3208 | codec->power_count++; | 3521 | codec->power_count++; |
3209 | codec->power_on = 1; | 3522 | codec->power_on = 1; |
3523 | codec->power_jiffies = jiffies; | ||
3210 | } | 3524 | } |
3211 | 3525 | ||
3526 | /* update the power on/off account with the current jiffies */ | ||
3527 | void snd_hda_update_power_acct(struct hda_codec *codec) | ||
3528 | { | ||
3529 | unsigned long delta = jiffies - codec->power_jiffies; | ||
3530 | if (codec->power_on) | ||
3531 | codec->power_on_acct += delta; | ||
3532 | else | ||
3533 | codec->power_off_acct += delta; | ||
3534 | codec->power_jiffies += delta; | ||
3535 | } | ||
3536 | |||
3537 | /** | ||
3538 | * snd_hda_power_up - Power-up the codec | ||
3539 | * @codec: HD-audio codec | ||
3540 | * | ||
3541 | * Increment the power-up counter and power up the hardware really when | ||
3542 | * not turned on yet. | ||
3543 | */ | ||
3212 | void snd_hda_power_up(struct hda_codec *codec) | 3544 | void snd_hda_power_up(struct hda_codec *codec) |
3213 | { | 3545 | { |
3214 | struct hda_bus *bus = codec->bus; | 3546 | struct hda_bus *bus = codec->bus; |
@@ -3217,7 +3549,9 @@ void snd_hda_power_up(struct hda_codec *codec) | |||
3217 | if (codec->power_on || codec->power_transition) | 3549 | if (codec->power_on || codec->power_transition) |
3218 | return; | 3550 | return; |
3219 | 3551 | ||
3552 | snd_hda_update_power_acct(codec); | ||
3220 | codec->power_on = 1; | 3553 | codec->power_on = 1; |
3554 | codec->power_jiffies = jiffies; | ||
3221 | if (bus->ops.pm_notify) | 3555 | if (bus->ops.pm_notify) |
3222 | bus->ops.pm_notify(bus); | 3556 | bus->ops.pm_notify(bus); |
3223 | hda_call_codec_resume(codec); | 3557 | hda_call_codec_resume(codec); |
@@ -3229,9 +3563,13 @@ EXPORT_SYMBOL_HDA(snd_hda_power_up); | |||
3229 | #define power_save(codec) \ | 3563 | #define power_save(codec) \ |
3230 | ((codec)->bus->power_save ? *(codec)->bus->power_save : 0) | 3564 | ((codec)->bus->power_save ? *(codec)->bus->power_save : 0) |
3231 | 3565 | ||
3232 | #define power_save(codec) \ | 3566 | /** |
3233 | ((codec)->bus->power_save ? *(codec)->bus->power_save : 0) | 3567 | * snd_hda_power_down - Power-down the codec |
3234 | 3568 | * @codec: HD-audio codec | |
3569 | * | ||
3570 | * Decrement the power-up counter and schedules the power-off work if | ||
3571 | * the counter rearches to zero. | ||
3572 | */ | ||
3235 | void snd_hda_power_down(struct hda_codec *codec) | 3573 | void snd_hda_power_down(struct hda_codec *codec) |
3236 | { | 3574 | { |
3237 | --codec->power_count; | 3575 | --codec->power_count; |
@@ -3245,6 +3583,19 @@ void snd_hda_power_down(struct hda_codec *codec) | |||
3245 | } | 3583 | } |
3246 | EXPORT_SYMBOL_HDA(snd_hda_power_down); | 3584 | EXPORT_SYMBOL_HDA(snd_hda_power_down); |
3247 | 3585 | ||
3586 | /** | ||
3587 | * snd_hda_check_amp_list_power - Check the amp list and update the power | ||
3588 | * @codec: HD-audio codec | ||
3589 | * @check: the object containing an AMP list and the status | ||
3590 | * @nid: NID to check / update | ||
3591 | * | ||
3592 | * Check whether the given NID is in the amp list. If it's in the list, | ||
3593 | * check the current AMP status, and update the the power-status according | ||
3594 | * to the mute status. | ||
3595 | * | ||
3596 | * This function is supposed to be set or called from the check_power_status | ||
3597 | * patch ops. | ||
3598 | */ | ||
3248 | int snd_hda_check_amp_list_power(struct hda_codec *codec, | 3599 | int snd_hda_check_amp_list_power(struct hda_codec *codec, |
3249 | struct hda_loopback_check *check, | 3600 | struct hda_loopback_check *check, |
3250 | hda_nid_t nid) | 3601 | hda_nid_t nid) |
@@ -3286,6 +3637,10 @@ EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power); | |||
3286 | /* | 3637 | /* |
3287 | * Channel mode helper | 3638 | * Channel mode helper |
3288 | */ | 3639 | */ |
3640 | |||
3641 | /** | ||
3642 | * snd_hda_ch_mode_info - Info callback helper for the channel mode enum | ||
3643 | */ | ||
3289 | int snd_hda_ch_mode_info(struct hda_codec *codec, | 3644 | int snd_hda_ch_mode_info(struct hda_codec *codec, |
3290 | struct snd_ctl_elem_info *uinfo, | 3645 | struct snd_ctl_elem_info *uinfo, |
3291 | const struct hda_channel_mode *chmode, | 3646 | const struct hda_channel_mode *chmode, |
@@ -3302,6 +3657,9 @@ int snd_hda_ch_mode_info(struct hda_codec *codec, | |||
3302 | } | 3657 | } |
3303 | EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info); | 3658 | EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info); |
3304 | 3659 | ||
3660 | /** | ||
3661 | * snd_hda_ch_mode_get - Get callback helper for the channel mode enum | ||
3662 | */ | ||
3305 | int snd_hda_ch_mode_get(struct hda_codec *codec, | 3663 | int snd_hda_ch_mode_get(struct hda_codec *codec, |
3306 | struct snd_ctl_elem_value *ucontrol, | 3664 | struct snd_ctl_elem_value *ucontrol, |
3307 | const struct hda_channel_mode *chmode, | 3665 | const struct hda_channel_mode *chmode, |
@@ -3320,6 +3678,9 @@ int snd_hda_ch_mode_get(struct hda_codec *codec, | |||
3320 | } | 3678 | } |
3321 | EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get); | 3679 | EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get); |
3322 | 3680 | ||
3681 | /** | ||
3682 | * snd_hda_ch_mode_put - Put callback helper for the channel mode enum | ||
3683 | */ | ||
3323 | int snd_hda_ch_mode_put(struct hda_codec *codec, | 3684 | int snd_hda_ch_mode_put(struct hda_codec *codec, |
3324 | struct snd_ctl_elem_value *ucontrol, | 3685 | struct snd_ctl_elem_value *ucontrol, |
3325 | const struct hda_channel_mode *chmode, | 3686 | const struct hda_channel_mode *chmode, |
@@ -3344,6 +3705,10 @@ EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put); | |||
3344 | /* | 3705 | /* |
3345 | * input MUX helper | 3706 | * input MUX helper |
3346 | */ | 3707 | */ |
3708 | |||
3709 | /** | ||
3710 | * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum | ||
3711 | */ | ||
3347 | int snd_hda_input_mux_info(const struct hda_input_mux *imux, | 3712 | int snd_hda_input_mux_info(const struct hda_input_mux *imux, |
3348 | struct snd_ctl_elem_info *uinfo) | 3713 | struct snd_ctl_elem_info *uinfo) |
3349 | { | 3714 | { |
@@ -3362,6 +3727,9 @@ int snd_hda_input_mux_info(const struct hda_input_mux *imux, | |||
3362 | } | 3727 | } |
3363 | EXPORT_SYMBOL_HDA(snd_hda_input_mux_info); | 3728 | EXPORT_SYMBOL_HDA(snd_hda_input_mux_info); |
3364 | 3729 | ||
3730 | /** | ||
3731 | * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum | ||
3732 | */ | ||
3365 | int snd_hda_input_mux_put(struct hda_codec *codec, | 3733 | int snd_hda_input_mux_put(struct hda_codec *codec, |
3366 | const struct hda_input_mux *imux, | 3734 | const struct hda_input_mux *imux, |
3367 | struct snd_ctl_elem_value *ucontrol, | 3735 | struct snd_ctl_elem_value *ucontrol, |
@@ -3421,8 +3789,29 @@ static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid) | |||
3421 | } | 3789 | } |
3422 | } | 3790 | } |
3423 | 3791 | ||
3424 | /* | 3792 | /** |
3425 | * open the digital out in the exclusive mode | 3793 | * snd_hda_bus_reboot_notify - call the reboot notifier of each codec |
3794 | * @bus: HD-audio bus | ||
3795 | */ | ||
3796 | void snd_hda_bus_reboot_notify(struct hda_bus *bus) | ||
3797 | { | ||
3798 | struct hda_codec *codec; | ||
3799 | |||
3800 | if (!bus) | ||
3801 | return; | ||
3802 | list_for_each_entry(codec, &bus->codec_list, list) { | ||
3803 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
3804 | if (!codec->power_on) | ||
3805 | continue; | ||
3806 | #endif | ||
3807 | if (codec->patch_ops.reboot_notify) | ||
3808 | codec->patch_ops.reboot_notify(codec); | ||
3809 | } | ||
3810 | } | ||
3811 | EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify); | ||
3812 | |||
3813 | /** | ||
3814 | * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode | ||
3426 | */ | 3815 | */ |
3427 | int snd_hda_multi_out_dig_open(struct hda_codec *codec, | 3816 | int snd_hda_multi_out_dig_open(struct hda_codec *codec, |
3428 | struct hda_multi_out *mout) | 3817 | struct hda_multi_out *mout) |
@@ -3437,6 +3826,9 @@ int snd_hda_multi_out_dig_open(struct hda_codec *codec, | |||
3437 | } | 3826 | } |
3438 | EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open); | 3827 | EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open); |
3439 | 3828 | ||
3829 | /** | ||
3830 | * snd_hda_multi_out_dig_prepare - prepare the digital out stream | ||
3831 | */ | ||
3440 | int snd_hda_multi_out_dig_prepare(struct hda_codec *codec, | 3832 | int snd_hda_multi_out_dig_prepare(struct hda_codec *codec, |
3441 | struct hda_multi_out *mout, | 3833 | struct hda_multi_out *mout, |
3442 | unsigned int stream_tag, | 3834 | unsigned int stream_tag, |
@@ -3450,6 +3842,9 @@ int snd_hda_multi_out_dig_prepare(struct hda_codec *codec, | |||
3450 | } | 3842 | } |
3451 | EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare); | 3843 | EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare); |
3452 | 3844 | ||
3845 | /** | ||
3846 | * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream | ||
3847 | */ | ||
3453 | int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec, | 3848 | int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec, |
3454 | struct hda_multi_out *mout) | 3849 | struct hda_multi_out *mout) |
3455 | { | 3850 | { |
@@ -3460,8 +3855,8 @@ int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec, | |||
3460 | } | 3855 | } |
3461 | EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup); | 3856 | EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup); |
3462 | 3857 | ||
3463 | /* | 3858 | /** |
3464 | * release the digital out | 3859 | * snd_hda_multi_out_dig_close - release the digital out stream |
3465 | */ | 3860 | */ |
3466 | int snd_hda_multi_out_dig_close(struct hda_codec *codec, | 3861 | int snd_hda_multi_out_dig_close(struct hda_codec *codec, |
3467 | struct hda_multi_out *mout) | 3862 | struct hda_multi_out *mout) |
@@ -3473,8 +3868,12 @@ int snd_hda_multi_out_dig_close(struct hda_codec *codec, | |||
3473 | } | 3868 | } |
3474 | EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close); | 3869 | EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close); |
3475 | 3870 | ||
3476 | /* | 3871 | /** |
3477 | * set up more restrictions for analog out | 3872 | * snd_hda_multi_out_analog_open - open analog outputs |
3873 | * | ||
3874 | * Open analog outputs and set up the hw-constraints. | ||
3875 | * If the digital outputs can be opened as slave, open the digital | ||
3876 | * outputs, too. | ||
3478 | */ | 3877 | */ |
3479 | int snd_hda_multi_out_analog_open(struct hda_codec *codec, | 3878 | int snd_hda_multi_out_analog_open(struct hda_codec *codec, |
3480 | struct hda_multi_out *mout, | 3879 | struct hda_multi_out *mout, |
@@ -3519,9 +3918,11 @@ int snd_hda_multi_out_analog_open(struct hda_codec *codec, | |||
3519 | } | 3918 | } |
3520 | EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open); | 3919 | EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open); |
3521 | 3920 | ||
3522 | /* | 3921 | /** |
3523 | * set up the i/o for analog out | 3922 | * snd_hda_multi_out_analog_prepare - Preapre the analog outputs. |
3524 | * when the digital out is available, copy the front out to digital out, too. | 3923 | * |
3924 | * Set up the i/o for analog out. | ||
3925 | * When the digital out is available, copy the front out to digital out, too. | ||
3525 | */ | 3926 | */ |
3526 | int snd_hda_multi_out_analog_prepare(struct hda_codec *codec, | 3927 | int snd_hda_multi_out_analog_prepare(struct hda_codec *codec, |
3527 | struct hda_multi_out *mout, | 3928 | struct hda_multi_out *mout, |
@@ -3578,8 +3979,8 @@ int snd_hda_multi_out_analog_prepare(struct hda_codec *codec, | |||
3578 | } | 3979 | } |
3579 | EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare); | 3980 | EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare); |
3580 | 3981 | ||
3581 | /* | 3982 | /** |
3582 | * clean up the setting for analog out | 3983 | * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out |
3583 | */ | 3984 | */ |
3584 | int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec, | 3985 | int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec, |
3585 | struct hda_multi_out *mout) | 3986 | struct hda_multi_out *mout) |
@@ -3965,8 +4366,14 @@ EXPORT_SYMBOL_HDA(snd_hda_resume); | |||
3965 | * generic arrays | 4366 | * generic arrays |
3966 | */ | 4367 | */ |
3967 | 4368 | ||
3968 | /* get a new element from the given array | 4369 | /** |
3969 | * if it exceeds the pre-allocated array size, re-allocate the array | 4370 | * snd_array_new - get a new element from the given array |
4371 | * @array: the array object | ||
4372 | * | ||
4373 | * Get a new element from the given array. If it exceeds the | ||
4374 | * pre-allocated array size, re-allocate the array. | ||
4375 | * | ||
4376 | * Returns NULL if allocation failed. | ||
3970 | */ | 4377 | */ |
3971 | void *snd_array_new(struct snd_array *array) | 4378 | void *snd_array_new(struct snd_array *array) |
3972 | { | 4379 | { |
@@ -3990,7 +4397,10 @@ void *snd_array_new(struct snd_array *array) | |||
3990 | } | 4397 | } |
3991 | EXPORT_SYMBOL_HDA(snd_array_new); | 4398 | EXPORT_SYMBOL_HDA(snd_array_new); |
3992 | 4399 | ||
3993 | /* free the given array elements */ | 4400 | /** |
4401 | * snd_array_free - free the given array elements | ||
4402 | * @array: the array object | ||
4403 | */ | ||
3994 | void snd_array_free(struct snd_array *array) | 4404 | void snd_array_free(struct snd_array *array) |
3995 | { | 4405 | { |
3996 | kfree(array->list); | 4406 | kfree(array->list); |
@@ -4000,7 +4410,12 @@ void snd_array_free(struct snd_array *array) | |||
4000 | } | 4410 | } |
4001 | EXPORT_SYMBOL_HDA(snd_array_free); | 4411 | EXPORT_SYMBOL_HDA(snd_array_free); |
4002 | 4412 | ||
4003 | /* | 4413 | /** |
4414 | * snd_print_pcm_rates - Print the supported PCM rates to the string buffer | ||
4415 | * @pcm: PCM caps bits | ||
4416 | * @buf: the string buffer to write | ||
4417 | * @buflen: the max buffer length | ||
4418 | * | ||
4004 | * used by hda_proc.c and hda_eld.c | 4419 | * used by hda_proc.c and hda_eld.c |
4005 | */ | 4420 | */ |
4006 | void snd_print_pcm_rates(int pcm, char *buf, int buflen) | 4421 | void snd_print_pcm_rates(int pcm, char *buf, int buflen) |
@@ -4019,6 +4434,14 @@ void snd_print_pcm_rates(int pcm, char *buf, int buflen) | |||
4019 | } | 4434 | } |
4020 | EXPORT_SYMBOL_HDA(snd_print_pcm_rates); | 4435 | EXPORT_SYMBOL_HDA(snd_print_pcm_rates); |
4021 | 4436 | ||
4437 | /** | ||
4438 | * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer | ||
4439 | * @pcm: PCM caps bits | ||
4440 | * @buf: the string buffer to write | ||
4441 | * @buflen: the max buffer length | ||
4442 | * | ||
4443 | * used by hda_proc.c and hda_eld.c | ||
4444 | */ | ||
4022 | void snd_print_pcm_bits(int pcm, char *buf, int buflen) | 4445 | void snd_print_pcm_bits(int pcm, char *buf, int buflen) |
4023 | { | 4446 | { |
4024 | static unsigned int bits[] = { 8, 16, 20, 24, 32 }; | 4447 | static unsigned int bits[] = { 8, 16, 20, 24, 32 }; |
diff --git a/sound/pci/hda/hda_codec.h b/sound/pci/hda/hda_codec.h index 99552fb5f756..2d627613aea3 100644 --- a/sound/pci/hda/hda_codec.h +++ b/sound/pci/hda/hda_codec.h | |||
@@ -286,6 +286,10 @@ enum { | |||
286 | #define AC_PWRST_D1SUP (1<<1) | 286 | #define AC_PWRST_D1SUP (1<<1) |
287 | #define AC_PWRST_D2SUP (1<<2) | 287 | #define AC_PWRST_D2SUP (1<<2) |
288 | #define AC_PWRST_D3SUP (1<<3) | 288 | #define AC_PWRST_D3SUP (1<<3) |
289 | #define AC_PWRST_D3COLDSUP (1<<4) | ||
290 | #define AC_PWRST_S3D3COLDSUP (1<<29) | ||
291 | #define AC_PWRST_CLKSTOP (1<<30) | ||
292 | #define AC_PWRST_EPSS (1U<<31) | ||
289 | 293 | ||
290 | /* Power state values */ | 294 | /* Power state values */ |
291 | #define AC_PWRST_SETTING (0xf<<0) | 295 | #define AC_PWRST_SETTING (0xf<<0) |
@@ -674,6 +678,7 @@ struct hda_codec_ops { | |||
674 | #ifdef CONFIG_SND_HDA_POWER_SAVE | 678 | #ifdef CONFIG_SND_HDA_POWER_SAVE |
675 | int (*check_power_status)(struct hda_codec *codec, hda_nid_t nid); | 679 | int (*check_power_status)(struct hda_codec *codec, hda_nid_t nid); |
676 | #endif | 680 | #endif |
681 | void (*reboot_notify)(struct hda_codec *codec); | ||
677 | }; | 682 | }; |
678 | 683 | ||
679 | /* record for amp information cache */ | 684 | /* record for amp information cache */ |
@@ -771,6 +776,7 @@ struct hda_codec { | |||
771 | 776 | ||
772 | /* beep device */ | 777 | /* beep device */ |
773 | struct hda_beep *beep; | 778 | struct hda_beep *beep; |
779 | unsigned int beep_mode; | ||
774 | 780 | ||
775 | /* widget capabilities cache */ | 781 | /* widget capabilities cache */ |
776 | unsigned int num_nodes; | 782 | unsigned int num_nodes; |
@@ -811,6 +817,9 @@ struct hda_codec { | |||
811 | unsigned int power_transition :1; /* power-state in transition */ | 817 | unsigned int power_transition :1; /* power-state in transition */ |
812 | int power_count; /* current (global) power refcount */ | 818 | int power_count; /* current (global) power refcount */ |
813 | struct delayed_work power_work; /* delayed task for powerdown */ | 819 | struct delayed_work power_work; /* delayed task for powerdown */ |
820 | unsigned long power_on_acct; | ||
821 | unsigned long power_off_acct; | ||
822 | unsigned long power_jiffies; | ||
814 | #endif | 823 | #endif |
815 | 824 | ||
816 | /* codec-specific additional proc output */ | 825 | /* codec-specific additional proc output */ |
@@ -910,6 +919,7 @@ int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid, | |||
910 | * Misc | 919 | * Misc |
911 | */ | 920 | */ |
912 | void snd_hda_get_codec_name(struct hda_codec *codec, char *name, int namelen); | 921 | void snd_hda_get_codec_name(struct hda_codec *codec, char *name, int namelen); |
922 | void snd_hda_bus_reboot_notify(struct hda_bus *bus); | ||
913 | 923 | ||
914 | /* | 924 | /* |
915 | * power management | 925 | * power management |
@@ -933,6 +943,7 @@ const char *snd_hda_get_jack_location(u32 cfg); | |||
933 | void snd_hda_power_up(struct hda_codec *codec); | 943 | void snd_hda_power_up(struct hda_codec *codec); |
934 | void snd_hda_power_down(struct hda_codec *codec); | 944 | void snd_hda_power_down(struct hda_codec *codec); |
935 | #define snd_hda_codec_needs_resume(codec) codec->power_count | 945 | #define snd_hda_codec_needs_resume(codec) codec->power_count |
946 | void snd_hda_update_power_acct(struct hda_codec *codec); | ||
936 | #else | 947 | #else |
937 | static inline void snd_hda_power_up(struct hda_codec *codec) {} | 948 | static inline void snd_hda_power_up(struct hda_codec *codec) {} |
938 | static inline void snd_hda_power_down(struct hda_codec *codec) {} | 949 | static inline void snd_hda_power_down(struct hda_codec *codec) {} |
diff --git a/sound/pci/hda/hda_eld.c b/sound/pci/hda/hda_eld.c index 9446a5abea13..4228f2fe5956 100644 --- a/sound/pci/hda/hda_eld.c +++ b/sound/pci/hda/hda_eld.c | |||
@@ -309,17 +309,12 @@ out_fail: | |||
309 | return -EINVAL; | 309 | return -EINVAL; |
310 | } | 310 | } |
311 | 311 | ||
312 | static int hdmi_present_sense(struct hda_codec *codec, hda_nid_t nid) | ||
313 | { | ||
314 | return snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0); | ||
315 | } | ||
316 | |||
317 | static int hdmi_eld_valid(struct hda_codec *codec, hda_nid_t nid) | 312 | static int hdmi_eld_valid(struct hda_codec *codec, hda_nid_t nid) |
318 | { | 313 | { |
319 | int eldv; | 314 | int eldv; |
320 | int present; | 315 | int present; |
321 | 316 | ||
322 | present = hdmi_present_sense(codec, nid); | 317 | present = snd_hda_pin_sense(codec, nid); |
323 | eldv = (present & AC_PINSENSE_ELDV); | 318 | eldv = (present & AC_PINSENSE_ELDV); |
324 | present = (present & AC_PINSENSE_PRESENCE); | 319 | present = (present & AC_PINSENSE_PRESENCE); |
325 | 320 | ||
@@ -477,6 +472,8 @@ static void hdmi_print_eld_info(struct snd_info_entry *entry, | |||
477 | [4 ... 7] = "reserved" | 472 | [4 ... 7] = "reserved" |
478 | }; | 473 | }; |
479 | 474 | ||
475 | snd_iprintf(buffer, "monitor_present\t\t%d\n", e->monitor_present); | ||
476 | snd_iprintf(buffer, "eld_valid\t\t%d\n", e->eld_valid); | ||
480 | snd_iprintf(buffer, "monitor_name\t\t%s\n", e->monitor_name); | 477 | snd_iprintf(buffer, "monitor_name\t\t%s\n", e->monitor_name); |
481 | snd_iprintf(buffer, "connection_type\t\t%s\n", | 478 | snd_iprintf(buffer, "connection_type\t\t%s\n", |
482 | eld_connection_type_names[e->conn_type]); | 479 | eld_connection_type_names[e->conn_type]); |
@@ -518,7 +515,11 @@ static void hdmi_write_eld_info(struct snd_info_entry *entry, | |||
518 | * monitor_name manufacture_id product_id | 515 | * monitor_name manufacture_id product_id |
519 | * eld_version edid_version | 516 | * eld_version edid_version |
520 | */ | 517 | */ |
521 | if (!strcmp(name, "connection_type")) | 518 | if (!strcmp(name, "monitor_present")) |
519 | e->monitor_present = val; | ||
520 | else if (!strcmp(name, "eld_valid")) | ||
521 | e->eld_valid = val; | ||
522 | else if (!strcmp(name, "connection_type")) | ||
522 | e->conn_type = val; | 523 | e->conn_type = val; |
523 | else if (!strcmp(name, "port_id")) | 524 | else if (!strcmp(name, "port_id")) |
524 | e->port_id = val; | 525 | e->port_id = val; |
@@ -560,13 +561,14 @@ static void hdmi_write_eld_info(struct snd_info_entry *entry, | |||
560 | } | 561 | } |
561 | 562 | ||
562 | 563 | ||
563 | int snd_hda_eld_proc_new(struct hda_codec *codec, struct hdmi_eld *eld) | 564 | int snd_hda_eld_proc_new(struct hda_codec *codec, struct hdmi_eld *eld, |
565 | int index) | ||
564 | { | 566 | { |
565 | char name[32]; | 567 | char name[32]; |
566 | struct snd_info_entry *entry; | 568 | struct snd_info_entry *entry; |
567 | int err; | 569 | int err; |
568 | 570 | ||
569 | snprintf(name, sizeof(name), "eld#%d", codec->addr); | 571 | snprintf(name, sizeof(name), "eld#%d.%d", codec->addr, index); |
570 | err = snd_card_proc_new(codec->bus->card, name, &entry); | 572 | err = snd_card_proc_new(codec->bus->card, name, &entry); |
571 | if (err < 0) | 573 | if (err < 0) |
572 | return err; | 574 | return err; |
diff --git a/sound/pci/hda/hda_generic.c b/sound/pci/hda/hda_generic.c index b36f6c5a92df..092c6a7c2ff3 100644 --- a/sound/pci/hda/hda_generic.c +++ b/sound/pci/hda/hda_generic.c | |||
@@ -727,7 +727,8 @@ static int create_mixer(struct hda_codec *codec, struct hda_gnode *node, | |||
727 | if (is_loopback) | 727 | if (is_loopback) |
728 | add_input_loopback(codec, node->nid, HDA_INPUT, index); | 728 | add_input_loopback(codec, node->nid, HDA_INPUT, index); |
729 | snd_printdd("[%s] NID=0x%x, DIR=IN, IDX=0x%x\n", name, node->nid, index); | 729 | snd_printdd("[%s] NID=0x%x, DIR=IN, IDX=0x%x\n", name, node->nid, index); |
730 | err = snd_hda_ctl_add(codec, snd_ctl_new1(&knew, codec)); | 730 | err = snd_hda_ctl_add(codec, node->nid, |
731 | snd_ctl_new1(&knew, codec)); | ||
731 | if (err < 0) | 732 | if (err < 0) |
732 | return err; | 733 | return err; |
733 | created = 1; | 734 | created = 1; |
@@ -737,7 +738,8 @@ static int create_mixer(struct hda_codec *codec, struct hda_gnode *node, | |||
737 | if (is_loopback) | 738 | if (is_loopback) |
738 | add_input_loopback(codec, node->nid, HDA_OUTPUT, 0); | 739 | add_input_loopback(codec, node->nid, HDA_OUTPUT, 0); |
739 | snd_printdd("[%s] NID=0x%x, DIR=OUT\n", name, node->nid); | 740 | snd_printdd("[%s] NID=0x%x, DIR=OUT\n", name, node->nid); |
740 | err = snd_hda_ctl_add(codec, snd_ctl_new1(&knew, codec)); | 741 | err = snd_hda_ctl_add(codec, node->nid, |
742 | snd_ctl_new1(&knew, codec)); | ||
741 | if (err < 0) | 743 | if (err < 0) |
742 | return err; | 744 | return err; |
743 | created = 1; | 745 | created = 1; |
@@ -751,7 +753,8 @@ static int create_mixer(struct hda_codec *codec, struct hda_gnode *node, | |||
751 | (node->amp_in_caps & AC_AMPCAP_NUM_STEPS)) { | 753 | (node->amp_in_caps & AC_AMPCAP_NUM_STEPS)) { |
752 | knew = (struct snd_kcontrol_new)HDA_CODEC_VOLUME(name, node->nid, index, HDA_INPUT); | 754 | knew = (struct snd_kcontrol_new)HDA_CODEC_VOLUME(name, node->nid, index, HDA_INPUT); |
753 | snd_printdd("[%s] NID=0x%x, DIR=IN, IDX=0x%x\n", name, node->nid, index); | 755 | snd_printdd("[%s] NID=0x%x, DIR=IN, IDX=0x%x\n", name, node->nid, index); |
754 | err = snd_hda_ctl_add(codec, snd_ctl_new1(&knew, codec)); | 756 | err = snd_hda_ctl_add(codec, node->nid, |
757 | snd_ctl_new1(&knew, codec)); | ||
755 | if (err < 0) | 758 | if (err < 0) |
756 | return err; | 759 | return err; |
757 | created = 1; | 760 | created = 1; |
@@ -759,7 +762,8 @@ static int create_mixer(struct hda_codec *codec, struct hda_gnode *node, | |||
759 | (node->amp_out_caps & AC_AMPCAP_NUM_STEPS)) { | 762 | (node->amp_out_caps & AC_AMPCAP_NUM_STEPS)) { |
760 | knew = (struct snd_kcontrol_new)HDA_CODEC_VOLUME(name, node->nid, 0, HDA_OUTPUT); | 763 | knew = (struct snd_kcontrol_new)HDA_CODEC_VOLUME(name, node->nid, 0, HDA_OUTPUT); |
761 | snd_printdd("[%s] NID=0x%x, DIR=OUT\n", name, node->nid); | 764 | snd_printdd("[%s] NID=0x%x, DIR=OUT\n", name, node->nid); |
762 | err = snd_hda_ctl_add(codec, snd_ctl_new1(&knew, codec)); | 765 | err = snd_hda_ctl_add(codec, node->nid, |
766 | snd_ctl_new1(&knew, codec)); | ||
763 | if (err < 0) | 767 | if (err < 0) |
764 | return err; | 768 | return err; |
765 | created = 1; | 769 | created = 1; |
@@ -857,7 +861,7 @@ static int build_input_controls(struct hda_codec *codec) | |||
857 | } | 861 | } |
858 | 862 | ||
859 | /* create input MUX if multiple sources are available */ | 863 | /* create input MUX if multiple sources are available */ |
860 | err = snd_hda_ctl_add(codec, snd_ctl_new1(&cap_sel, codec)); | 864 | err = snd_hda_ctl_add(codec, 0, snd_ctl_new1(&cap_sel, codec)); |
861 | if (err < 0) | 865 | if (err < 0) |
862 | return err; | 866 | return err; |
863 | 867 | ||
@@ -875,7 +879,8 @@ static int build_input_controls(struct hda_codec *codec) | |||
875 | HDA_CODEC_VOLUME(name, adc_node->nid, | 879 | HDA_CODEC_VOLUME(name, adc_node->nid, |
876 | spec->input_mux.items[i].index, | 880 | spec->input_mux.items[i].index, |
877 | HDA_INPUT); | 881 | HDA_INPUT); |
878 | err = snd_hda_ctl_add(codec, snd_ctl_new1(&knew, codec)); | 882 | err = snd_hda_ctl_add(codec, adc_node->nid, |
883 | snd_ctl_new1(&knew, codec)); | ||
879 | if (err < 0) | 884 | if (err < 0) |
880 | return err; | 885 | return err; |
881 | } | 886 | } |
diff --git a/sound/pci/hda/hda_hwdep.c b/sound/pci/hda/hda_hwdep.c index cc24e6721d74..d24328661c6a 100644 --- a/sound/pci/hda/hda_hwdep.c +++ b/sound/pci/hda/hda_hwdep.c | |||
@@ -154,6 +154,44 @@ int /*__devinit*/ snd_hda_create_hwdep(struct hda_codec *codec) | |||
154 | return 0; | 154 | return 0; |
155 | } | 155 | } |
156 | 156 | ||
157 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
158 | static ssize_t power_on_acct_show(struct device *dev, | ||
159 | struct device_attribute *attr, | ||
160 | char *buf) | ||
161 | { | ||
162 | struct snd_hwdep *hwdep = dev_get_drvdata(dev); | ||
163 | struct hda_codec *codec = hwdep->private_data; | ||
164 | snd_hda_update_power_acct(codec); | ||
165 | return sprintf(buf, "%u\n", jiffies_to_msecs(codec->power_on_acct)); | ||
166 | } | ||
167 | |||
168 | static ssize_t power_off_acct_show(struct device *dev, | ||
169 | struct device_attribute *attr, | ||
170 | char *buf) | ||
171 | { | ||
172 | struct snd_hwdep *hwdep = dev_get_drvdata(dev); | ||
173 | struct hda_codec *codec = hwdep->private_data; | ||
174 | snd_hda_update_power_acct(codec); | ||
175 | return sprintf(buf, "%u\n", jiffies_to_msecs(codec->power_off_acct)); | ||
176 | } | ||
177 | |||
178 | static struct device_attribute power_attrs[] = { | ||
179 | __ATTR_RO(power_on_acct), | ||
180 | __ATTR_RO(power_off_acct), | ||
181 | }; | ||
182 | |||
183 | int snd_hda_hwdep_add_power_sysfs(struct hda_codec *codec) | ||
184 | { | ||
185 | struct snd_hwdep *hwdep = codec->hwdep; | ||
186 | int i; | ||
187 | |||
188 | for (i = 0; i < ARRAY_SIZE(power_attrs); i++) | ||
189 | snd_add_device_sysfs_file(SNDRV_DEVICE_TYPE_HWDEP, hwdep->card, | ||
190 | hwdep->device, &power_attrs[i]); | ||
191 | return 0; | ||
192 | } | ||
193 | #endif /* CONFIG_SND_HDA_POWER_SAVE */ | ||
194 | |||
157 | #ifdef CONFIG_SND_HDA_RECONFIG | 195 | #ifdef CONFIG_SND_HDA_RECONFIG |
158 | 196 | ||
159 | /* | 197 | /* |
diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c index 6517f589d01d..d822bfc6cad6 100644 --- a/sound/pci/hda/hda_intel.c +++ b/sound/pci/hda/hda_intel.c | |||
@@ -60,10 +60,14 @@ static int bdl_pos_adj[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = -1}; | |||
60 | static int probe_mask[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = -1}; | 60 | static int probe_mask[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = -1}; |
61 | static int probe_only[SNDRV_CARDS]; | 61 | static int probe_only[SNDRV_CARDS]; |
62 | static int single_cmd; | 62 | static int single_cmd; |
63 | static int enable_msi; | 63 | static int enable_msi = -1; |
64 | #ifdef CONFIG_SND_HDA_PATCH_LOADER | 64 | #ifdef CONFIG_SND_HDA_PATCH_LOADER |
65 | static char *patch[SNDRV_CARDS]; | 65 | static char *patch[SNDRV_CARDS]; |
66 | #endif | 66 | #endif |
67 | #ifdef CONFIG_SND_HDA_INPUT_BEEP | ||
68 | static int beep_mode[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = | ||
69 | CONFIG_SND_HDA_INPUT_BEEP_MODE}; | ||
70 | #endif | ||
67 | 71 | ||
68 | module_param_array(index, int, NULL, 0444); | 72 | module_param_array(index, int, NULL, 0444); |
69 | MODULE_PARM_DESC(index, "Index value for Intel HD audio interface."); | 73 | MODULE_PARM_DESC(index, "Index value for Intel HD audio interface."); |
@@ -91,6 +95,11 @@ MODULE_PARM_DESC(enable_msi, "Enable Message Signaled Interrupt (MSI)"); | |||
91 | module_param_array(patch, charp, NULL, 0444); | 95 | module_param_array(patch, charp, NULL, 0444); |
92 | MODULE_PARM_DESC(patch, "Patch file for Intel HD audio interface."); | 96 | MODULE_PARM_DESC(patch, "Patch file for Intel HD audio interface."); |
93 | #endif | 97 | #endif |
98 | #ifdef CONFIG_SND_HDA_INPUT_BEEP | ||
99 | module_param_array(beep_mode, int, NULL, 0444); | ||
100 | MODULE_PARM_DESC(beep_mode, "Select HDA Beep registration mode " | ||
101 | "(0=off, 1=on, 2=mute switch on/off) (default=1)."); | ||
102 | #endif | ||
94 | 103 | ||
95 | #ifdef CONFIG_SND_HDA_POWER_SAVE | 104 | #ifdef CONFIG_SND_HDA_POWER_SAVE |
96 | static int power_save = CONFIG_SND_HDA_POWER_SAVE_DEFAULT; | 105 | static int power_save = CONFIG_SND_HDA_POWER_SAVE_DEFAULT; |
@@ -404,6 +413,7 @@ struct azx { | |||
404 | unsigned short codec_mask; | 413 | unsigned short codec_mask; |
405 | int codec_probe_mask; /* copied from probe_mask option */ | 414 | int codec_probe_mask; /* copied from probe_mask option */ |
406 | struct hda_bus *bus; | 415 | struct hda_bus *bus; |
416 | unsigned int beep_mode; | ||
407 | 417 | ||
408 | /* CORB/RIRB */ | 418 | /* CORB/RIRB */ |
409 | struct azx_rb corb; | 419 | struct azx_rb corb; |
@@ -677,6 +687,14 @@ static unsigned int azx_rirb_get_response(struct hda_bus *bus, | |||
677 | } | 687 | } |
678 | } | 688 | } |
679 | 689 | ||
690 | if (!chip->polling_mode) { | ||
691 | snd_printk(KERN_WARNING SFX "azx_get_response timeout, " | ||
692 | "switching to polling mode: last cmd=0x%08x\n", | ||
693 | chip->last_cmd[addr]); | ||
694 | chip->polling_mode = 1; | ||
695 | goto again; | ||
696 | } | ||
697 | |||
680 | if (chip->msi) { | 698 | if (chip->msi) { |
681 | snd_printk(KERN_WARNING SFX "No response from codec, " | 699 | snd_printk(KERN_WARNING SFX "No response from codec, " |
682 | "disabling MSI: last cmd=0x%08x\n", | 700 | "disabling MSI: last cmd=0x%08x\n", |
@@ -692,14 +710,6 @@ static unsigned int azx_rirb_get_response(struct hda_bus *bus, | |||
692 | goto again; | 710 | goto again; |
693 | } | 711 | } |
694 | 712 | ||
695 | if (!chip->polling_mode) { | ||
696 | snd_printk(KERN_WARNING SFX "azx_get_response timeout, " | ||
697 | "switching to polling mode: last cmd=0x%08x\n", | ||
698 | chip->last_cmd[addr]); | ||
699 | chip->polling_mode = 1; | ||
700 | goto again; | ||
701 | } | ||
702 | |||
703 | if (chip->probing) { | 713 | if (chip->probing) { |
704 | /* If this critical timeout happens during the codec probing | 714 | /* If this critical timeout happens during the codec probing |
705 | * phase, this is likely an access to a non-existing codec | 715 | * phase, this is likely an access to a non-existing codec |
@@ -1404,6 +1414,7 @@ static int __devinit azx_codec_create(struct azx *chip, const char *model) | |||
1404 | err = snd_hda_codec_new(chip->bus, c, &codec); | 1414 | err = snd_hda_codec_new(chip->bus, c, &codec); |
1405 | if (err < 0) | 1415 | if (err < 0) |
1406 | continue; | 1416 | continue; |
1417 | codec->beep_mode = chip->beep_mode; | ||
1407 | codecs++; | 1418 | codecs++; |
1408 | } | 1419 | } |
1409 | } | 1420 | } |
@@ -2154,6 +2165,7 @@ static int azx_resume(struct pci_dev *pci) | |||
2154 | static int azx_halt(struct notifier_block *nb, unsigned long event, void *buf) | 2165 | static int azx_halt(struct notifier_block *nb, unsigned long event, void *buf) |
2155 | { | 2166 | { |
2156 | struct azx *chip = container_of(nb, struct azx, reboot_notifier); | 2167 | struct azx *chip = container_of(nb, struct azx, reboot_notifier); |
2168 | snd_hda_bus_reboot_notify(chip->bus); | ||
2157 | azx_stop_chip(chip); | 2169 | azx_stop_chip(chip); |
2158 | return NOTIFY_OK; | 2170 | return NOTIFY_OK; |
2159 | } | 2171 | } |
@@ -2221,7 +2233,9 @@ static int azx_dev_free(struct snd_device *device) | |||
2221 | static struct snd_pci_quirk position_fix_list[] __devinitdata = { | 2233 | static struct snd_pci_quirk position_fix_list[] __devinitdata = { |
2222 | SND_PCI_QUIRK(0x1028, 0x01cc, "Dell D820", POS_FIX_LPIB), | 2234 | SND_PCI_QUIRK(0x1028, 0x01cc, "Dell D820", POS_FIX_LPIB), |
2223 | SND_PCI_QUIRK(0x1028, 0x01de, "Dell Precision 390", POS_FIX_LPIB), | 2235 | SND_PCI_QUIRK(0x1028, 0x01de, "Dell Precision 390", POS_FIX_LPIB), |
2236 | SND_PCI_QUIRK(0x103c, 0x306d, "HP dv3", POS_FIX_LPIB), | ||
2224 | SND_PCI_QUIRK(0x1043, 0x813d, "ASUS P5AD2", POS_FIX_LPIB), | 2237 | SND_PCI_QUIRK(0x1043, 0x813d, "ASUS P5AD2", POS_FIX_LPIB), |
2238 | SND_PCI_QUIRK(0x1462, 0x1002, "MSI Wind U115", POS_FIX_LPIB), | ||
2225 | {} | 2239 | {} |
2226 | }; | 2240 | }; |
2227 | 2241 | ||
@@ -2304,11 +2318,9 @@ static void __devinit check_probe_mask(struct azx *chip, int dev) | |||
2304 | } | 2318 | } |
2305 | 2319 | ||
2306 | /* | 2320 | /* |
2307 | * white-list for enable_msi | 2321 | * white/black-list for enable_msi |
2308 | */ | 2322 | */ |
2309 | static struct snd_pci_quirk msi_white_list[] __devinitdata = { | 2323 | static struct snd_pci_quirk msi_black_list[] __devinitdata = { |
2310 | SND_PCI_QUIRK(0x103c, 0x30f7, "HP Pavilion dv4t-1300", 1), | ||
2311 | SND_PCI_QUIRK(0x103c, 0x3607, "HP Compa CQ40", 1), | ||
2312 | {} | 2324 | {} |
2313 | }; | 2325 | }; |
2314 | 2326 | ||
@@ -2316,10 +2328,12 @@ static void __devinit check_msi(struct azx *chip) | |||
2316 | { | 2328 | { |
2317 | const struct snd_pci_quirk *q; | 2329 | const struct snd_pci_quirk *q; |
2318 | 2330 | ||
2319 | chip->msi = enable_msi; | 2331 | if (enable_msi >= 0) { |
2320 | if (chip->msi) | 2332 | chip->msi = !!enable_msi; |
2321 | return; | 2333 | return; |
2322 | q = snd_pci_quirk_lookup(chip->pci, msi_white_list); | 2334 | } |
2335 | chip->msi = 1; /* enable MSI as default */ | ||
2336 | q = snd_pci_quirk_lookup(chip->pci, msi_black_list); | ||
2323 | if (q) { | 2337 | if (q) { |
2324 | printk(KERN_INFO | 2338 | printk(KERN_INFO |
2325 | "hda_intel: msi for device %04x:%04x set to %d\n", | 2339 | "hda_intel: msi for device %04x:%04x set to %d\n", |
@@ -2578,6 +2592,10 @@ static int __devinit azx_probe(struct pci_dev *pci, | |||
2578 | goto out_free; | 2592 | goto out_free; |
2579 | card->private_data = chip; | 2593 | card->private_data = chip; |
2580 | 2594 | ||
2595 | #ifdef CONFIG_SND_HDA_INPUT_BEEP | ||
2596 | chip->beep_mode = beep_mode[dev]; | ||
2597 | #endif | ||
2598 | |||
2581 | /* create codec instances */ | 2599 | /* create codec instances */ |
2582 | err = azx_codec_create(chip, model[dev]); | 2600 | err = azx_codec_create(chip, model[dev]); |
2583 | if (err < 0) | 2601 | if (err < 0) |
diff --git a/sound/pci/hda/hda_local.h b/sound/pci/hda/hda_local.h index 5f1dcc59002b..5778ae882b83 100644 --- a/sound/pci/hda/hda_local.h +++ b/sound/pci/hda/hda_local.h | |||
@@ -23,6 +23,15 @@ | |||
23 | #ifndef __SOUND_HDA_LOCAL_H | 23 | #ifndef __SOUND_HDA_LOCAL_H |
24 | #define __SOUND_HDA_LOCAL_H | 24 | #define __SOUND_HDA_LOCAL_H |
25 | 25 | ||
26 | /* We abuse kcontrol_new.subdev field to pass the NID corresponding to | ||
27 | * the given new control. If id.subdev has a bit flag HDA_SUBDEV_NID_FLAG, | ||
28 | * snd_hda_ctl_add() takes the lower-bit subdev value as a valid NID. | ||
29 | * | ||
30 | * Note that the subdevice field is cleared again before the real registration | ||
31 | * in snd_hda_ctl_add(), so that this value won't appear in the outside. | ||
32 | */ | ||
33 | #define HDA_SUBDEV_NID_FLAG (1U << 31) | ||
34 | |||
26 | /* | 35 | /* |
27 | * for mixer controls | 36 | * for mixer controls |
28 | */ | 37 | */ |
@@ -33,6 +42,7 @@ | |||
33 | /* mono volume with index (index=0,1,...) (channel=1,2) */ | 42 | /* mono volume with index (index=0,1,...) (channel=1,2) */ |
34 | #define HDA_CODEC_VOLUME_MONO_IDX(xname, xcidx, nid, channel, xindex, direction) \ | 43 | #define HDA_CODEC_VOLUME_MONO_IDX(xname, xcidx, nid, channel, xindex, direction) \ |
35 | { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xcidx, \ | 44 | { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xcidx, \ |
45 | .subdevice = HDA_SUBDEV_NID_FLAG | (nid), \ | ||
36 | .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \ | 46 | .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \ |
37 | SNDRV_CTL_ELEM_ACCESS_TLV_READ | \ | 47 | SNDRV_CTL_ELEM_ACCESS_TLV_READ | \ |
38 | SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \ | 48 | SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \ |
@@ -53,6 +63,7 @@ | |||
53 | /* mono mute switch with index (index=0,1,...) (channel=1,2) */ | 63 | /* mono mute switch with index (index=0,1,...) (channel=1,2) */ |
54 | #define HDA_CODEC_MUTE_MONO_IDX(xname, xcidx, nid, channel, xindex, direction) \ | 64 | #define HDA_CODEC_MUTE_MONO_IDX(xname, xcidx, nid, channel, xindex, direction) \ |
55 | { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xcidx, \ | 65 | { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xcidx, \ |
66 | .subdevice = HDA_SUBDEV_NID_FLAG | (nid), \ | ||
56 | .info = snd_hda_mixer_amp_switch_info, \ | 67 | .info = snd_hda_mixer_amp_switch_info, \ |
57 | .get = snd_hda_mixer_amp_switch_get, \ | 68 | .get = snd_hda_mixer_amp_switch_get, \ |
58 | .put = snd_hda_mixer_amp_switch_put, \ | 69 | .put = snd_hda_mixer_amp_switch_put, \ |
@@ -66,6 +77,28 @@ | |||
66 | /* stereo mute switch */ | 77 | /* stereo mute switch */ |
67 | #define HDA_CODEC_MUTE(xname, nid, xindex, direction) \ | 78 | #define HDA_CODEC_MUTE(xname, nid, xindex, direction) \ |
68 | HDA_CODEC_MUTE_MONO(xname, nid, 3, xindex, direction) | 79 | HDA_CODEC_MUTE_MONO(xname, nid, 3, xindex, direction) |
80 | #ifdef CONFIG_SND_HDA_INPUT_BEEP | ||
81 | /* special beep mono mute switch with index (index=0,1,...) (channel=1,2) */ | ||
82 | #define HDA_CODEC_MUTE_BEEP_MONO_IDX(xname, xcidx, nid, channel, xindex, direction) \ | ||
83 | { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xcidx, \ | ||
84 | .subdevice = HDA_SUBDEV_NID_FLAG | (nid), \ | ||
85 | .info = snd_hda_mixer_amp_switch_info, \ | ||
86 | .get = snd_hda_mixer_amp_switch_get, \ | ||
87 | .put = snd_hda_mixer_amp_switch_put_beep, \ | ||
88 | .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, xindex, direction) } | ||
89 | #else | ||
90 | /* no digital beep - just the standard one */ | ||
91 | #define HDA_CODEC_MUTE_BEEP_MONO_IDX(xname, xcidx, nid, ch, xidx, dir) \ | ||
92 | HDA_CODEC_MUTE_MONO_IDX(xname, xcidx, nid, ch, xidx, dir) | ||
93 | #endif /* CONFIG_SND_HDA_INPUT_BEEP */ | ||
94 | /* special beep mono mute switch */ | ||
95 | #define HDA_CODEC_MUTE_BEEP_MONO(xname, nid, channel, xindex, direction) \ | ||
96 | HDA_CODEC_MUTE_BEEP_MONO_IDX(xname, 0, nid, channel, xindex, direction) | ||
97 | /* special beep stereo mute switch */ | ||
98 | #define HDA_CODEC_MUTE_BEEP(xname, nid, xindex, direction) \ | ||
99 | HDA_CODEC_MUTE_BEEP_MONO(xname, nid, 3, xindex, direction) | ||
100 | |||
101 | extern const char *snd_hda_pcm_type_name[]; | ||
69 | 102 | ||
70 | int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol, | 103 | int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol, |
71 | struct snd_ctl_elem_info *uinfo); | 104 | struct snd_ctl_elem_info *uinfo); |
@@ -81,6 +114,10 @@ int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol, | |||
81 | struct snd_ctl_elem_value *ucontrol); | 114 | struct snd_ctl_elem_value *ucontrol); |
82 | int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol, | 115 | int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol, |
83 | struct snd_ctl_elem_value *ucontrol); | 116 | struct snd_ctl_elem_value *ucontrol); |
117 | #ifdef CONFIG_SND_HDA_INPUT_BEEP | ||
118 | int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol, | ||
119 | struct snd_ctl_elem_value *ucontrol); | ||
120 | #endif | ||
84 | /* lowlevel accessor with caching; use carefully */ | 121 | /* lowlevel accessor with caching; use carefully */ |
85 | int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch, | 122 | int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch, |
86 | int direction, int index); | 123 | int direction, int index); |
@@ -424,8 +461,16 @@ u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction); | |||
424 | int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir, | 461 | int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir, |
425 | unsigned int caps); | 462 | unsigned int caps); |
426 | u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid); | 463 | u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid); |
464 | u32 snd_hda_pin_sense(struct hda_codec *codec, hda_nid_t nid); | ||
465 | int snd_hda_jack_detect(struct hda_codec *codec, hda_nid_t nid); | ||
427 | 466 | ||
428 | int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl); | 467 | struct hda_nid_item { |
468 | struct snd_kcontrol *kctl; | ||
469 | hda_nid_t nid; | ||
470 | }; | ||
471 | |||
472 | int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid, | ||
473 | struct snd_kcontrol *kctl); | ||
429 | void snd_hda_ctls_clear(struct hda_codec *codec); | 474 | void snd_hda_ctls_clear(struct hda_codec *codec); |
430 | 475 | ||
431 | /* | 476 | /* |
@@ -437,6 +482,15 @@ int snd_hda_create_hwdep(struct hda_codec *codec); | |||
437 | static inline int snd_hda_create_hwdep(struct hda_codec *codec) { return 0; } | 482 | static inline int snd_hda_create_hwdep(struct hda_codec *codec) { return 0; } |
438 | #endif | 483 | #endif |
439 | 484 | ||
485 | #if defined(CONFIG_SND_HDA_POWER_SAVE) && defined(CONFIG_SND_HDA_HWDEP) | ||
486 | int snd_hda_hwdep_add_power_sysfs(struct hda_codec *codec); | ||
487 | #else | ||
488 | static inline int snd_hda_hwdep_add_power_sysfs(struct hda_codec *codec) | ||
489 | { | ||
490 | return 0; | ||
491 | } | ||
492 | #endif | ||
493 | |||
440 | #ifdef CONFIG_SND_HDA_RECONFIG | 494 | #ifdef CONFIG_SND_HDA_RECONFIG |
441 | int snd_hda_hwdep_add_sysfs(struct hda_codec *codec); | 495 | int snd_hda_hwdep_add_sysfs(struct hda_codec *codec); |
442 | #else | 496 | #else |
@@ -490,7 +544,8 @@ int snd_hda_check_amp_list_power(struct hda_codec *codec, | |||
490 | * AMP control callbacks | 544 | * AMP control callbacks |
491 | */ | 545 | */ |
492 | /* retrieve parameters from private_value */ | 546 | /* retrieve parameters from private_value */ |
493 | #define get_amp_nid(kc) ((kc)->private_value & 0xffff) | 547 | #define get_amp_nid_(pv) ((pv) & 0xffff) |
548 | #define get_amp_nid(kc) get_amp_nid_((kc)->private_value) | ||
494 | #define get_amp_channels(kc) (((kc)->private_value >> 16) & 0x3) | 549 | #define get_amp_channels(kc) (((kc)->private_value >> 16) & 0x3) |
495 | #define get_amp_direction(kc) (((kc)->private_value >> 18) & 0x1) | 550 | #define get_amp_direction(kc) (((kc)->private_value >> 18) & 0x1) |
496 | #define get_amp_index(kc) (((kc)->private_value >> 19) & 0xf) | 551 | #define get_amp_index(kc) (((kc)->private_value >> 19) & 0xf) |
@@ -516,9 +571,11 @@ struct cea_sad { | |||
516 | * ELD: EDID Like Data | 571 | * ELD: EDID Like Data |
517 | */ | 572 | */ |
518 | struct hdmi_eld { | 573 | struct hdmi_eld { |
574 | bool monitor_present; | ||
575 | bool eld_valid; | ||
519 | int eld_size; | 576 | int eld_size; |
520 | int baseline_len; | 577 | int baseline_len; |
521 | int eld_ver; /* (eld_ver == 0) indicates invalid ELD */ | 578 | int eld_ver; |
522 | int cea_edid_ver; | 579 | int cea_edid_ver; |
523 | char monitor_name[ELD_MAX_MNL + 1]; | 580 | char monitor_name[ELD_MAX_MNL + 1]; |
524 | int manufacture_id; | 581 | int manufacture_id; |
@@ -541,11 +598,13 @@ int snd_hdmi_get_eld(struct hdmi_eld *, struct hda_codec *, hda_nid_t); | |||
541 | void snd_hdmi_show_eld(struct hdmi_eld *eld); | 598 | void snd_hdmi_show_eld(struct hdmi_eld *eld); |
542 | 599 | ||
543 | #ifdef CONFIG_PROC_FS | 600 | #ifdef CONFIG_PROC_FS |
544 | int snd_hda_eld_proc_new(struct hda_codec *codec, struct hdmi_eld *eld); | 601 | int snd_hda_eld_proc_new(struct hda_codec *codec, struct hdmi_eld *eld, |
602 | int index); | ||
545 | void snd_hda_eld_proc_free(struct hda_codec *codec, struct hdmi_eld *eld); | 603 | void snd_hda_eld_proc_free(struct hda_codec *codec, struct hdmi_eld *eld); |
546 | #else | 604 | #else |
547 | static inline int snd_hda_eld_proc_new(struct hda_codec *codec, | 605 | static inline int snd_hda_eld_proc_new(struct hda_codec *codec, |
548 | struct hdmi_eld *eld) | 606 | struct hdmi_eld *eld, |
607 | int index) | ||
549 | { | 608 | { |
550 | return 0; | 609 | return 0; |
551 | } | 610 | } |
diff --git a/sound/pci/hda/hda_proc.c b/sound/pci/hda/hda_proc.c index 95f24e4729f8..09476fc1ab64 100644 --- a/sound/pci/hda/hda_proc.c +++ b/sound/pci/hda/hda_proc.c | |||
@@ -26,6 +26,21 @@ | |||
26 | #include "hda_codec.h" | 26 | #include "hda_codec.h" |
27 | #include "hda_local.h" | 27 | #include "hda_local.h" |
28 | 28 | ||
29 | static char *bits_names(unsigned int bits, char *names[], int size) | ||
30 | { | ||
31 | int i, n; | ||
32 | static char buf[128]; | ||
33 | |||
34 | for (i = 0, n = 0; i < size; i++) { | ||
35 | if (bits & (1U<<i) && names[i]) | ||
36 | n += snprintf(buf + n, sizeof(buf) - n, " %s", | ||
37 | names[i]); | ||
38 | } | ||
39 | buf[n] = '\0'; | ||
40 | |||
41 | return buf; | ||
42 | } | ||
43 | |||
29 | static const char *get_wid_type_name(unsigned int wid_value) | 44 | static const char *get_wid_type_name(unsigned int wid_value) |
30 | { | 45 | { |
31 | static char *names[16] = { | 46 | static char *names[16] = { |
@@ -46,6 +61,41 @@ static const char *get_wid_type_name(unsigned int wid_value) | |||
46 | return "UNKNOWN Widget"; | 61 | return "UNKNOWN Widget"; |
47 | } | 62 | } |
48 | 63 | ||
64 | static void print_nid_mixers(struct snd_info_buffer *buffer, | ||
65 | struct hda_codec *codec, hda_nid_t nid) | ||
66 | { | ||
67 | int i; | ||
68 | struct hda_nid_item *items = codec->mixers.list; | ||
69 | struct snd_kcontrol *kctl; | ||
70 | for (i = 0; i < codec->mixers.used; i++) { | ||
71 | if (items[i].nid == nid) { | ||
72 | kctl = items[i].kctl; | ||
73 | snd_iprintf(buffer, | ||
74 | " Control: name=\"%s\", index=%i, device=%i\n", | ||
75 | kctl->id.name, kctl->id.index, kctl->id.device); | ||
76 | } | ||
77 | } | ||
78 | } | ||
79 | |||
80 | static void print_nid_pcms(struct snd_info_buffer *buffer, | ||
81 | struct hda_codec *codec, hda_nid_t nid) | ||
82 | { | ||
83 | int pcm, type; | ||
84 | struct hda_pcm *cpcm; | ||
85 | for (pcm = 0; pcm < codec->num_pcms; pcm++) { | ||
86 | cpcm = &codec->pcm_info[pcm]; | ||
87 | for (type = 0; type < 2; type++) { | ||
88 | if (cpcm->stream[type].nid != nid || cpcm->pcm == NULL) | ||
89 | continue; | ||
90 | snd_iprintf(buffer, " Device: name=\"%s\", " | ||
91 | "type=\"%s\", device=%i\n", | ||
92 | cpcm->name, | ||
93 | snd_hda_pcm_type_name[cpcm->pcm_type], | ||
94 | cpcm->pcm->device); | ||
95 | } | ||
96 | } | ||
97 | } | ||
98 | |||
49 | static void print_amp_caps(struct snd_info_buffer *buffer, | 99 | static void print_amp_caps(struct snd_info_buffer *buffer, |
50 | struct hda_codec *codec, hda_nid_t nid, int dir) | 100 | struct hda_codec *codec, hda_nid_t nid, int dir) |
51 | { | 101 | { |
@@ -363,8 +413,24 @@ static const char *get_pwr_state(u32 state) | |||
363 | static void print_power_state(struct snd_info_buffer *buffer, | 413 | static void print_power_state(struct snd_info_buffer *buffer, |
364 | struct hda_codec *codec, hda_nid_t nid) | 414 | struct hda_codec *codec, hda_nid_t nid) |
365 | { | 415 | { |
416 | static char *names[] = { | ||
417 | [ilog2(AC_PWRST_D0SUP)] = "D0", | ||
418 | [ilog2(AC_PWRST_D1SUP)] = "D1", | ||
419 | [ilog2(AC_PWRST_D2SUP)] = "D2", | ||
420 | [ilog2(AC_PWRST_D3SUP)] = "D3", | ||
421 | [ilog2(AC_PWRST_D3COLDSUP)] = "D3cold", | ||
422 | [ilog2(AC_PWRST_S3D3COLDSUP)] = "S3D3cold", | ||
423 | [ilog2(AC_PWRST_CLKSTOP)] = "CLKSTOP", | ||
424 | [ilog2(AC_PWRST_EPSS)] = "EPSS", | ||
425 | }; | ||
426 | |||
427 | int sup = snd_hda_param_read(codec, nid, AC_PAR_POWER_STATE); | ||
366 | int pwr = snd_hda_codec_read(codec, nid, 0, | 428 | int pwr = snd_hda_codec_read(codec, nid, 0, |
367 | AC_VERB_GET_POWER_STATE, 0); | 429 | AC_VERB_GET_POWER_STATE, 0); |
430 | if (sup) | ||
431 | snd_iprintf(buffer, " Power states: %s\n", | ||
432 | bits_names(sup, names, ARRAY_SIZE(names))); | ||
433 | |||
368 | snd_iprintf(buffer, " Power: setting=%s, actual=%s\n", | 434 | snd_iprintf(buffer, " Power: setting=%s, actual=%s\n", |
369 | get_pwr_state(pwr & AC_PWRST_SETTING), | 435 | get_pwr_state(pwr & AC_PWRST_SETTING), |
370 | get_pwr_state((pwr & AC_PWRST_ACTUAL) >> | 436 | get_pwr_state((pwr & AC_PWRST_ACTUAL) >> |
@@ -457,6 +523,7 @@ static void print_gpio(struct snd_info_buffer *buffer, | |||
457 | (data & (1<<i)) ? 1 : 0, | 523 | (data & (1<<i)) ? 1 : 0, |
458 | (unsol & (1<<i)) ? 1 : 0); | 524 | (unsol & (1<<i)) ? 1 : 0); |
459 | /* FIXME: add GPO and GPI pin information */ | 525 | /* FIXME: add GPO and GPI pin information */ |
526 | print_nid_mixers(buffer, codec, nid); | ||
460 | } | 527 | } |
461 | 528 | ||
462 | static void print_codec_info(struct snd_info_entry *entry, | 529 | static void print_codec_info(struct snd_info_entry *entry, |
@@ -536,6 +603,9 @@ static void print_codec_info(struct snd_info_entry *entry, | |||
536 | snd_iprintf(buffer, " CP"); | 603 | snd_iprintf(buffer, " CP"); |
537 | snd_iprintf(buffer, "\n"); | 604 | snd_iprintf(buffer, "\n"); |
538 | 605 | ||
606 | print_nid_mixers(buffer, codec, nid); | ||
607 | print_nid_pcms(buffer, codec, nid); | ||
608 | |||
539 | /* volume knob is a special widget that always have connection | 609 | /* volume knob is a special widget that always have connection |
540 | * list | 610 | * list |
541 | */ | 611 | */ |
diff --git a/sound/pci/hda/patch_analog.c b/sound/pci/hda/patch_analog.c index 2d603f6aba63..455a0494f907 100644 --- a/sound/pci/hda/patch_analog.c +++ b/sound/pci/hda/patch_analog.c | |||
@@ -156,15 +156,19 @@ static const char *ad_slave_sws[] = { | |||
156 | 156 | ||
157 | static void ad198x_free_kctls(struct hda_codec *codec); | 157 | static void ad198x_free_kctls(struct hda_codec *codec); |
158 | 158 | ||
159 | #ifdef CONFIG_SND_HDA_INPUT_BEEP | ||
159 | /* additional beep mixers; the actual parameters are overwritten at build */ | 160 | /* additional beep mixers; the actual parameters are overwritten at build */ |
160 | static struct snd_kcontrol_new ad_beep_mixer[] = { | 161 | static struct snd_kcontrol_new ad_beep_mixer[] = { |
161 | HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_OUTPUT), | 162 | HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_OUTPUT), |
162 | HDA_CODEC_MUTE("Beep Playback Switch", 0, 0, HDA_OUTPUT), | 163 | HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_OUTPUT), |
163 | { } /* end */ | 164 | { } /* end */ |
164 | }; | 165 | }; |
165 | 166 | ||
166 | #define set_beep_amp(spec, nid, idx, dir) \ | 167 | #define set_beep_amp(spec, nid, idx, dir) \ |
167 | ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 1, idx, dir)) /* mono */ | 168 | ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 1, idx, dir)) /* mono */ |
169 | #else | ||
170 | #define set_beep_amp(spec, nid, idx, dir) /* NOP */ | ||
171 | #endif | ||
168 | 172 | ||
169 | static int ad198x_build_controls(struct hda_codec *codec) | 173 | static int ad198x_build_controls(struct hda_codec *codec) |
170 | { | 174 | { |
@@ -194,6 +198,7 @@ static int ad198x_build_controls(struct hda_codec *codec) | |||
194 | } | 198 | } |
195 | 199 | ||
196 | /* create beep controls if needed */ | 200 | /* create beep controls if needed */ |
201 | #ifdef CONFIG_SND_HDA_INPUT_BEEP | ||
197 | if (spec->beep_amp) { | 202 | if (spec->beep_amp) { |
198 | struct snd_kcontrol_new *knew; | 203 | struct snd_kcontrol_new *knew; |
199 | for (knew = ad_beep_mixer; knew->name; knew++) { | 204 | for (knew = ad_beep_mixer; knew->name; knew++) { |
@@ -202,11 +207,14 @@ static int ad198x_build_controls(struct hda_codec *codec) | |||
202 | if (!kctl) | 207 | if (!kctl) |
203 | return -ENOMEM; | 208 | return -ENOMEM; |
204 | kctl->private_value = spec->beep_amp; | 209 | kctl->private_value = spec->beep_amp; |
205 | err = snd_hda_ctl_add(codec, kctl); | 210 | err = snd_hda_ctl_add(codec, |
211 | get_amp_nid_(spec->beep_amp), | ||
212 | kctl); | ||
206 | if (err < 0) | 213 | if (err < 0) |
207 | return err; | 214 | return err; |
208 | } | 215 | } |
209 | } | 216 | } |
217 | #endif | ||
210 | 218 | ||
211 | /* if we have no master control, let's create it */ | 219 | /* if we have no master control, let's create it */ |
212 | if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) { | 220 | if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) { |
@@ -712,10 +720,10 @@ static struct snd_kcontrol_new ad1986a_laptop_intmic_mixers[] = { | |||
712 | static void ad1986a_automic(struct hda_codec *codec) | 720 | static void ad1986a_automic(struct hda_codec *codec) |
713 | { | 721 | { |
714 | unsigned int present; | 722 | unsigned int present; |
715 | present = snd_hda_codec_read(codec, 0x1f, 0, AC_VERB_GET_PIN_SENSE, 0); | 723 | present = snd_hda_jack_detect(codec, 0x1f); |
716 | /* 0 = 0x1f, 2 = 0x1d, 4 = mixed */ | 724 | /* 0 = 0x1f, 2 = 0x1d, 4 = mixed */ |
717 | snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_CONNECT_SEL, | 725 | snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_CONNECT_SEL, |
718 | (present & AC_PINSENSE_PRESENCE) ? 0 : 2); | 726 | present ? 0 : 2); |
719 | } | 727 | } |
720 | 728 | ||
721 | #define AD1986A_MIC_EVENT 0x36 | 729 | #define AD1986A_MIC_EVENT 0x36 |
@@ -754,10 +762,8 @@ static void ad1986a_update_hp(struct hda_codec *codec) | |||
754 | static void ad1986a_hp_automute(struct hda_codec *codec) | 762 | static void ad1986a_hp_automute(struct hda_codec *codec) |
755 | { | 763 | { |
756 | struct ad198x_spec *spec = codec->spec; | 764 | struct ad198x_spec *spec = codec->spec; |
757 | unsigned int present; | ||
758 | 765 | ||
759 | present = snd_hda_codec_read(codec, 0x1a, 0, AC_VERB_GET_PIN_SENSE, 0); | 766 | spec->jack_present = snd_hda_jack_detect(codec, 0x1a); |
760 | spec->jack_present = !!(present & 0x80000000); | ||
761 | if (spec->inv_jack_detect) | 767 | if (spec->inv_jack_detect) |
762 | spec->jack_present = !spec->jack_present; | 768 | spec->jack_present = !spec->jack_present; |
763 | ad1986a_update_hp(codec); | 769 | ad1986a_update_hp(codec); |
@@ -1547,8 +1553,7 @@ static void ad1981_hp_automute(struct hda_codec *codec) | |||
1547 | { | 1553 | { |
1548 | unsigned int present; | 1554 | unsigned int present; |
1549 | 1555 | ||
1550 | present = snd_hda_codec_read(codec, 0x06, 0, | 1556 | present = snd_hda_jack_detect(codec, 0x06); |
1551 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | ||
1552 | snd_hda_codec_amp_stereo(codec, 0x05, HDA_OUTPUT, 0, | 1557 | snd_hda_codec_amp_stereo(codec, 0x05, HDA_OUTPUT, 0, |
1553 | HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); | 1558 | HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); |
1554 | } | 1559 | } |
@@ -1568,8 +1573,7 @@ static void ad1981_hp_automic(struct hda_codec *codec) | |||
1568 | }; | 1573 | }; |
1569 | unsigned int present; | 1574 | unsigned int present; |
1570 | 1575 | ||
1571 | present = snd_hda_codec_read(codec, 0x08, 0, | 1576 | present = snd_hda_jack_detect(codec, 0x08); |
1572 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | ||
1573 | if (present) | 1577 | if (present) |
1574 | snd_hda_sequence_write(codec, mic_jack_on); | 1578 | snd_hda_sequence_write(codec, mic_jack_on); |
1575 | else | 1579 | else |
@@ -2524,7 +2528,7 @@ static void ad1988_laptop_unsol_event(struct hda_codec *codec, unsigned int res) | |||
2524 | { | 2528 | { |
2525 | if ((res >> 26) != AD1988_HP_EVENT) | 2529 | if ((res >> 26) != AD1988_HP_EVENT) |
2526 | return; | 2530 | return; |
2527 | if (snd_hda_codec_read(codec, 0x11, 0, AC_VERB_GET_PIN_SENSE, 0) & (1 << 31)) | 2531 | if (snd_hda_jack_detect(codec, 0x11)) |
2528 | snd_hda_sequence_write(codec, ad1988_laptop_hp_on); | 2532 | snd_hda_sequence_write(codec, ad1988_laptop_hp_on); |
2529 | else | 2533 | else |
2530 | snd_hda_sequence_write(codec, ad1988_laptop_hp_off); | 2534 | snd_hda_sequence_write(codec, ad1988_laptop_hp_off); |
@@ -2569,6 +2573,8 @@ static int add_control(struct ad198x_spec *spec, int type, const char *name, | |||
2569 | knew->name = kstrdup(name, GFP_KERNEL); | 2573 | knew->name = kstrdup(name, GFP_KERNEL); |
2570 | if (! knew->name) | 2574 | if (! knew->name) |
2571 | return -ENOMEM; | 2575 | return -ENOMEM; |
2576 | if (get_amp_nid_(val)) | ||
2577 | knew->subdevice = HDA_SUBDEV_NID_FLAG | get_amp_nid_(val); | ||
2572 | knew->private_value = val; | 2578 | knew->private_value = val; |
2573 | return 0; | 2579 | return 0; |
2574 | } | 2580 | } |
@@ -3768,8 +3774,7 @@ static void ad1884a_hp_automute(struct hda_codec *codec) | |||
3768 | { | 3774 | { |
3769 | unsigned int present; | 3775 | unsigned int present; |
3770 | 3776 | ||
3771 | present = snd_hda_codec_read(codec, 0x11, 0, | 3777 | present = snd_hda_jack_detect(codec, 0x11); |
3772 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | ||
3773 | snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, | 3778 | snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, |
3774 | HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); | 3779 | HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); |
3775 | snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_EAPD_BTLENABLE, | 3780 | snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_EAPD_BTLENABLE, |
@@ -3781,8 +3786,7 @@ static void ad1884a_hp_automic(struct hda_codec *codec) | |||
3781 | { | 3786 | { |
3782 | unsigned int present; | 3787 | unsigned int present; |
3783 | 3788 | ||
3784 | present = snd_hda_codec_read(codec, 0x14, 0, | 3789 | present = snd_hda_jack_detect(codec, 0x14); |
3785 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | ||
3786 | snd_hda_codec_write(codec, 0x0c, 0, AC_VERB_SET_CONNECT_SEL, | 3790 | snd_hda_codec_write(codec, 0x0c, 0, AC_VERB_SET_CONNECT_SEL, |
3787 | present ? 0 : 1); | 3791 | present ? 0 : 1); |
3788 | } | 3792 | } |
@@ -3817,13 +3821,9 @@ static void ad1884a_laptop_automute(struct hda_codec *codec) | |||
3817 | { | 3821 | { |
3818 | unsigned int present; | 3822 | unsigned int present; |
3819 | 3823 | ||
3820 | present = snd_hda_codec_read(codec, 0x11, 0, AC_VERB_GET_PIN_SENSE, 0); | 3824 | present = snd_hda_jack_detect(codec, 0x11); |
3821 | present &= AC_PINSENSE_PRESENCE; | 3825 | if (!present) |
3822 | if (!present) { | 3826 | present = snd_hda_jack_detect(codec, 0x12); |
3823 | present = snd_hda_codec_read(codec, 0x12, 0, | ||
3824 | AC_VERB_GET_PIN_SENSE, 0); | ||
3825 | present &= AC_PINSENSE_PRESENCE; | ||
3826 | } | ||
3827 | snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, | 3827 | snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, |
3828 | HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); | 3828 | HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); |
3829 | snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_EAPD_BTLENABLE, | 3829 | snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_EAPD_BTLENABLE, |
@@ -3835,11 +3835,9 @@ static void ad1884a_laptop_automic(struct hda_codec *codec) | |||
3835 | { | 3835 | { |
3836 | unsigned int idx; | 3836 | unsigned int idx; |
3837 | 3837 | ||
3838 | if (snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0) & | 3838 | if (snd_hda_jack_detect(codec, 0x14)) |
3839 | AC_PINSENSE_PRESENCE) | ||
3840 | idx = 0; | 3839 | idx = 0; |
3841 | else if (snd_hda_codec_read(codec, 0x1c, 0, AC_VERB_GET_PIN_SENSE, 0) & | 3840 | else if (snd_hda_jack_detect(codec, 0x1c)) |
3842 | AC_PINSENSE_PRESENCE) | ||
3843 | idx = 4; | 3841 | idx = 4; |
3844 | else | 3842 | else |
3845 | idx = 1; | 3843 | idx = 1; |
@@ -4008,8 +4006,7 @@ static void ad1984a_thinkpad_automute(struct hda_codec *codec) | |||
4008 | { | 4006 | { |
4009 | unsigned int present; | 4007 | unsigned int present; |
4010 | 4008 | ||
4011 | present = snd_hda_codec_read(codec, 0x11, 0, AC_VERB_GET_PIN_SENSE, 0) | 4009 | present = snd_hda_jack_detect(codec, 0x11); |
4012 | & AC_PINSENSE_PRESENCE; | ||
4013 | snd_hda_codec_amp_stereo(codec, 0x12, HDA_OUTPUT, 0, | 4010 | snd_hda_codec_amp_stereo(codec, 0x12, HDA_OUTPUT, 0, |
4014 | HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); | 4011 | HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); |
4015 | } | 4012 | } |
@@ -4117,14 +4114,12 @@ static struct snd_kcontrol_new ad1984a_touchsmart_mixers[] = { | |||
4117 | /* switch to external mic if plugged */ | 4114 | /* switch to external mic if plugged */ |
4118 | static void ad1984a_touchsmart_automic(struct hda_codec *codec) | 4115 | static void ad1984a_touchsmart_automic(struct hda_codec *codec) |
4119 | { | 4116 | { |
4120 | if (snd_hda_codec_read(codec, 0x1c, 0, | 4117 | if (snd_hda_jack_detect(codec, 0x1c)) |
4121 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000) { | ||
4122 | snd_hda_codec_write(codec, 0x0c, 0, | 4118 | snd_hda_codec_write(codec, 0x0c, 0, |
4123 | AC_VERB_SET_CONNECT_SEL, 0x4); | 4119 | AC_VERB_SET_CONNECT_SEL, 0x4); |
4124 | } else { | 4120 | else |
4125 | snd_hda_codec_write(codec, 0x0c, 0, | 4121 | snd_hda_codec_write(codec, 0x0c, 0, |
4126 | AC_VERB_SET_CONNECT_SEL, 0x5); | 4122 | AC_VERB_SET_CONNECT_SEL, 0x5); |
4127 | } | ||
4128 | } | 4123 | } |
4129 | 4124 | ||
4130 | 4125 | ||
diff --git a/sound/pci/hda/patch_ca0110.c b/sound/pci/hda/patch_ca0110.c index d08353d3bb7f..af478019088e 100644 --- a/sound/pci/hda/patch_ca0110.c +++ b/sound/pci/hda/patch_ca0110.c | |||
@@ -144,7 +144,7 @@ static int _add_switch(struct hda_codec *codec, hda_nid_t nid, const char *pfx, | |||
144 | struct snd_kcontrol_new knew = | 144 | struct snd_kcontrol_new knew = |
145 | HDA_CODEC_MUTE_MONO(namestr, nid, chan, 0, type); | 145 | HDA_CODEC_MUTE_MONO(namestr, nid, chan, 0, type); |
146 | sprintf(namestr, "%s %s Switch", pfx, dirstr[dir]); | 146 | sprintf(namestr, "%s %s Switch", pfx, dirstr[dir]); |
147 | return snd_hda_ctl_add(codec, snd_ctl_new1(&knew, codec)); | 147 | return snd_hda_ctl_add(codec, nid, snd_ctl_new1(&knew, codec)); |
148 | } | 148 | } |
149 | 149 | ||
150 | static int _add_volume(struct hda_codec *codec, hda_nid_t nid, const char *pfx, | 150 | static int _add_volume(struct hda_codec *codec, hda_nid_t nid, const char *pfx, |
@@ -155,7 +155,7 @@ static int _add_volume(struct hda_codec *codec, hda_nid_t nid, const char *pfx, | |||
155 | struct snd_kcontrol_new knew = | 155 | struct snd_kcontrol_new knew = |
156 | HDA_CODEC_VOLUME_MONO(namestr, nid, chan, 0, type); | 156 | HDA_CODEC_VOLUME_MONO(namestr, nid, chan, 0, type); |
157 | sprintf(namestr, "%s %s Volume", pfx, dirstr[dir]); | 157 | sprintf(namestr, "%s %s Volume", pfx, dirstr[dir]); |
158 | return snd_hda_ctl_add(codec, snd_ctl_new1(&knew, codec)); | 158 | return snd_hda_ctl_add(codec, nid, snd_ctl_new1(&knew, codec)); |
159 | } | 159 | } |
160 | 160 | ||
161 | #define add_out_switch(codec, nid, pfx) _add_switch(codec, nid, pfx, 3, 0) | 161 | #define add_out_switch(codec, nid, pfx) _add_switch(codec, nid, pfx, 3, 0) |
diff --git a/sound/pci/hda/patch_cirrus.c b/sound/pci/hda/patch_cirrus.c index 8ba306856d38..2439e84dcb21 100644 --- a/sound/pci/hda/patch_cirrus.c +++ b/sound/pci/hda/patch_cirrus.c | |||
@@ -500,7 +500,7 @@ static int add_mute(struct hda_codec *codec, const char *name, int index, | |||
500 | knew.private_value = pval; | 500 | knew.private_value = pval; |
501 | snprintf(tmp, sizeof(tmp), "%s %s Switch", name, dir_sfx[dir]); | 501 | snprintf(tmp, sizeof(tmp), "%s %s Switch", name, dir_sfx[dir]); |
502 | *kctlp = snd_ctl_new1(&knew, codec); | 502 | *kctlp = snd_ctl_new1(&knew, codec); |
503 | return snd_hda_ctl_add(codec, *kctlp); | 503 | return snd_hda_ctl_add(codec, get_amp_nid_(pval), *kctlp); |
504 | } | 504 | } |
505 | 505 | ||
506 | static int add_volume(struct hda_codec *codec, const char *name, | 506 | static int add_volume(struct hda_codec *codec, const char *name, |
@@ -513,7 +513,7 @@ static int add_volume(struct hda_codec *codec, const char *name, | |||
513 | knew.private_value = pval; | 513 | knew.private_value = pval; |
514 | snprintf(tmp, sizeof(tmp), "%s %s Volume", name, dir_sfx[dir]); | 514 | snprintf(tmp, sizeof(tmp), "%s %s Volume", name, dir_sfx[dir]); |
515 | *kctlp = snd_ctl_new1(&knew, codec); | 515 | *kctlp = snd_ctl_new1(&knew, codec); |
516 | return snd_hda_ctl_add(codec, *kctlp); | 516 | return snd_hda_ctl_add(codec, get_amp_nid_(pval), *kctlp); |
517 | } | 517 | } |
518 | 518 | ||
519 | static void fix_volume_caps(struct hda_codec *codec, hda_nid_t dac) | 519 | static void fix_volume_caps(struct hda_codec *codec, hda_nid_t dac) |
@@ -536,14 +536,14 @@ static int add_vmaster(struct hda_codec *codec, hda_nid_t dac) | |||
536 | 536 | ||
537 | spec->vmaster_sw = | 537 | spec->vmaster_sw = |
538 | snd_ctl_make_virtual_master("Master Playback Switch", NULL); | 538 | snd_ctl_make_virtual_master("Master Playback Switch", NULL); |
539 | err = snd_hda_ctl_add(codec, spec->vmaster_sw); | 539 | err = snd_hda_ctl_add(codec, dac, spec->vmaster_sw); |
540 | if (err < 0) | 540 | if (err < 0) |
541 | return err; | 541 | return err; |
542 | 542 | ||
543 | snd_hda_set_vmaster_tlv(codec, dac, HDA_OUTPUT, tlv); | 543 | snd_hda_set_vmaster_tlv(codec, dac, HDA_OUTPUT, tlv); |
544 | spec->vmaster_vol = | 544 | spec->vmaster_vol = |
545 | snd_ctl_make_virtual_master("Master Playback Volume", tlv); | 545 | snd_ctl_make_virtual_master("Master Playback Volume", tlv); |
546 | err = snd_hda_ctl_add(codec, spec->vmaster_vol); | 546 | err = snd_hda_ctl_add(codec, dac, spec->vmaster_vol); |
547 | if (err < 0) | 547 | if (err < 0) |
548 | return err; | 548 | return err; |
549 | return 0; | 549 | return 0; |
@@ -756,13 +756,13 @@ static int build_input(struct hda_codec *codec) | |||
756 | if (!kctl) | 756 | if (!kctl) |
757 | return -ENOMEM; | 757 | return -ENOMEM; |
758 | kctl->private_value = (long)spec->capture_bind[i]; | 758 | kctl->private_value = (long)spec->capture_bind[i]; |
759 | err = snd_hda_ctl_add(codec, kctl); | 759 | err = snd_hda_ctl_add(codec, 0, kctl); |
760 | if (err < 0) | 760 | if (err < 0) |
761 | return err; | 761 | return err; |
762 | } | 762 | } |
763 | 763 | ||
764 | if (spec->num_inputs > 1 && !spec->mic_detect) { | 764 | if (spec->num_inputs > 1 && !spec->mic_detect) { |
765 | err = snd_hda_ctl_add(codec, | 765 | err = snd_hda_ctl_add(codec, 0, |
766 | snd_ctl_new1(&cs_capture_source, codec)); | 766 | snd_ctl_new1(&cs_capture_source, codec)); |
767 | if (err < 0) | 767 | if (err < 0) |
768 | return err; | 768 | return err; |
@@ -807,7 +807,7 @@ static void cs_automute(struct hda_codec *codec) | |||
807 | { | 807 | { |
808 | struct cs_spec *spec = codec->spec; | 808 | struct cs_spec *spec = codec->spec; |
809 | struct auto_pin_cfg *cfg = &spec->autocfg; | 809 | struct auto_pin_cfg *cfg = &spec->autocfg; |
810 | unsigned int caps, present, hp_present; | 810 | unsigned int caps, hp_present; |
811 | hda_nid_t nid; | 811 | hda_nid_t nid; |
812 | int i; | 812 | int i; |
813 | 813 | ||
@@ -817,12 +817,7 @@ static void cs_automute(struct hda_codec *codec) | |||
817 | caps = snd_hda_query_pin_caps(codec, nid); | 817 | caps = snd_hda_query_pin_caps(codec, nid); |
818 | if (!(caps & AC_PINCAP_PRES_DETECT)) | 818 | if (!(caps & AC_PINCAP_PRES_DETECT)) |
819 | continue; | 819 | continue; |
820 | if (caps & AC_PINCAP_TRIG_REQ) | 820 | hp_present = snd_hda_jack_detect(codec, nid); |
821 | snd_hda_codec_read(codec, nid, 0, | ||
822 | AC_VERB_SET_PIN_SENSE, 0); | ||
823 | present = snd_hda_codec_read(codec, nid, 0, | ||
824 | AC_VERB_GET_PIN_SENSE, 0); | ||
825 | hp_present |= (present & AC_PINSENSE_PRESENCE) != 0; | ||
826 | if (hp_present) | 821 | if (hp_present) |
827 | break; | 822 | break; |
828 | } | 823 | } |
@@ -844,15 +839,11 @@ static void cs_automic(struct hda_codec *codec) | |||
844 | struct cs_spec *spec = codec->spec; | 839 | struct cs_spec *spec = codec->spec; |
845 | struct auto_pin_cfg *cfg = &spec->autocfg; | 840 | struct auto_pin_cfg *cfg = &spec->autocfg; |
846 | hda_nid_t nid; | 841 | hda_nid_t nid; |
847 | unsigned int caps, present; | 842 | unsigned int present; |
848 | 843 | ||
849 | nid = cfg->input_pins[spec->automic_idx]; | 844 | nid = cfg->input_pins[spec->automic_idx]; |
850 | caps = snd_hda_query_pin_caps(codec, nid); | 845 | present = snd_hda_jack_detect(codec, nid); |
851 | if (caps & AC_PINCAP_TRIG_REQ) | 846 | if (present) |
852 | snd_hda_codec_read(codec, nid, 0, AC_VERB_SET_PIN_SENSE, 0); | ||
853 | present = snd_hda_codec_read(codec, nid, 0, | ||
854 | AC_VERB_GET_PIN_SENSE, 0); | ||
855 | if (present & AC_PINSENSE_PRESENCE) | ||
856 | change_cur_input(codec, spec->automic_idx, 0); | 847 | change_cur_input(codec, spec->automic_idx, 0); |
857 | else { | 848 | else { |
858 | unsigned int imic = (spec->automic_idx == AUTO_PIN_MIC) ? | 849 | unsigned int imic = (spec->automic_idx == AUTO_PIN_MIC) ? |
diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c index 905859d4f4df..a09c03c3f62b 100644 --- a/sound/pci/hda/patch_conexant.c +++ b/sound/pci/hda/patch_conexant.c | |||
@@ -397,9 +397,7 @@ static void conexant_report_jack(struct hda_codec *codec, hda_nid_t nid) | |||
397 | for (i = 0; i < spec->jacks.used; i++) { | 397 | for (i = 0; i < spec->jacks.used; i++) { |
398 | if (jacks->nid == nid) { | 398 | if (jacks->nid == nid) { |
399 | unsigned int present; | 399 | unsigned int present; |
400 | present = snd_hda_codec_read(codec, nid, 0, | 400 | present = snd_hda_jack_detect(codec, nid); |
401 | AC_VERB_GET_PIN_SENSE, 0) & | ||
402 | AC_PINSENSE_PRESENCE; | ||
403 | 401 | ||
404 | present = (present) ? jacks->type : 0 ; | 402 | present = (present) ? jacks->type : 0 ; |
405 | 403 | ||
@@ -750,8 +748,7 @@ static void cxt5045_hp_automic(struct hda_codec *codec) | |||
750 | }; | 748 | }; |
751 | unsigned int present; | 749 | unsigned int present; |
752 | 750 | ||
753 | present = snd_hda_codec_read(codec, 0x12, 0, | 751 | present = snd_hda_jack_detect(codec, 0x12); |
754 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | ||
755 | if (present) | 752 | if (present) |
756 | snd_hda_sequence_write(codec, mic_jack_on); | 753 | snd_hda_sequence_write(codec, mic_jack_on); |
757 | else | 754 | else |
@@ -765,8 +762,7 @@ static void cxt5045_hp_automute(struct hda_codec *codec) | |||
765 | struct conexant_spec *spec = codec->spec; | 762 | struct conexant_spec *spec = codec->spec; |
766 | unsigned int bits; | 763 | unsigned int bits; |
767 | 764 | ||
768 | spec->hp_present = snd_hda_codec_read(codec, 0x11, 0, | 765 | spec->hp_present = snd_hda_jack_detect(codec, 0x11); |
769 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | ||
770 | 766 | ||
771 | bits = (spec->hp_present || !spec->cur_eapd) ? HDA_AMP_MUTE : 0; | 767 | bits = (spec->hp_present || !spec->cur_eapd) ? HDA_AMP_MUTE : 0; |
772 | snd_hda_codec_amp_stereo(codec, 0x10, HDA_OUTPUT, 0, | 768 | snd_hda_codec_amp_stereo(codec, 0x10, HDA_OUTPUT, 0, |
@@ -1175,9 +1171,10 @@ static int patch_cxt5045(struct hda_codec *codec) | |||
1175 | 1171 | ||
1176 | switch (codec->subsystem_id >> 16) { | 1172 | switch (codec->subsystem_id >> 16) { |
1177 | case 0x103c: | 1173 | case 0x103c: |
1178 | /* HP laptop has a really bad sound over 0dB on NID 0x17. | 1174 | case 0x1734: |
1179 | * Fix max PCM level to 0 dB | 1175 | /* HP & Fujitsu-Siemens laptops have really bad sound over 0dB |
1180 | * (originall it has 0x2b steps with 0dB offset 0x14) | 1176 | * on NID 0x17. Fix max PCM level to 0 dB |
1177 | * (originally it has 0x2b steps with 0dB offset 0x14) | ||
1181 | */ | 1178 | */ |
1182 | snd_hda_override_amp_caps(codec, 0x17, HDA_INPUT, | 1179 | snd_hda_override_amp_caps(codec, 0x17, HDA_INPUT, |
1183 | (0x14 << AC_AMPCAP_OFFSET_SHIFT) | | 1180 | (0x14 << AC_AMPCAP_OFFSET_SHIFT) | |
@@ -1243,8 +1240,7 @@ static void cxt5047_hp_automute(struct hda_codec *codec) | |||
1243 | struct conexant_spec *spec = codec->spec; | 1240 | struct conexant_spec *spec = codec->spec; |
1244 | unsigned int bits; | 1241 | unsigned int bits; |
1245 | 1242 | ||
1246 | spec->hp_present = snd_hda_codec_read(codec, 0x13, 0, | 1243 | spec->hp_present = snd_hda_jack_detect(codec, 0x13); |
1247 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | ||
1248 | 1244 | ||
1249 | bits = (spec->hp_present || !spec->cur_eapd) ? HDA_AMP_MUTE : 0; | 1245 | bits = (spec->hp_present || !spec->cur_eapd) ? HDA_AMP_MUTE : 0; |
1250 | /* See the note in cxt5047_hp_master_sw_put */ | 1246 | /* See the note in cxt5047_hp_master_sw_put */ |
@@ -1267,8 +1263,7 @@ static void cxt5047_hp_automic(struct hda_codec *codec) | |||
1267 | }; | 1263 | }; |
1268 | unsigned int present; | 1264 | unsigned int present; |
1269 | 1265 | ||
1270 | present = snd_hda_codec_read(codec, 0x15, 0, | 1266 | present = snd_hda_jack_detect(codec, 0x15); |
1271 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | ||
1272 | if (present) | 1267 | if (present) |
1273 | snd_hda_sequence_write(codec, mic_jack_on); | 1268 | snd_hda_sequence_write(codec, mic_jack_on); |
1274 | else | 1269 | else |
@@ -1415,16 +1410,7 @@ static struct snd_kcontrol_new cxt5047_test_mixer[] = { | |||
1415 | .get = conexant_mux_enum_get, | 1410 | .get = conexant_mux_enum_get, |
1416 | .put = conexant_mux_enum_put, | 1411 | .put = conexant_mux_enum_put, |
1417 | }, | 1412 | }, |
1418 | HDA_CODEC_VOLUME("Input-1 Volume", 0x1a, 0x0, HDA_INPUT), | 1413 | HDA_CODEC_VOLUME("Mic Boost Volume", 0x1a, 0x0, HDA_OUTPUT), |
1419 | HDA_CODEC_MUTE("Input-1 Switch", 0x1a, 0x0, HDA_INPUT), | ||
1420 | HDA_CODEC_VOLUME("Input-2 Volume", 0x1a, 0x1, HDA_INPUT), | ||
1421 | HDA_CODEC_MUTE("Input-2 Switch", 0x1a, 0x1, HDA_INPUT), | ||
1422 | HDA_CODEC_VOLUME("Input-3 Volume", 0x1a, 0x2, HDA_INPUT), | ||
1423 | HDA_CODEC_MUTE("Input-3 Switch", 0x1a, 0x2, HDA_INPUT), | ||
1424 | HDA_CODEC_VOLUME("Input-4 Volume", 0x1a, 0x3, HDA_INPUT), | ||
1425 | HDA_CODEC_MUTE("Input-4 Switch", 0x1a, 0x3, HDA_INPUT), | ||
1426 | HDA_CODEC_VOLUME("Input-5 Volume", 0x1a, 0x4, HDA_INPUT), | ||
1427 | HDA_CODEC_MUTE("Input-5 Switch", 0x1a, 0x4, HDA_INPUT), | ||
1428 | 1414 | ||
1429 | { } /* end */ | 1415 | { } /* end */ |
1430 | }; | 1416 | }; |
@@ -1621,9 +1607,7 @@ static void cxt5051_portb_automic(struct hda_codec *codec) | |||
1621 | 1607 | ||
1622 | if (spec->no_auto_mic) | 1608 | if (spec->no_auto_mic) |
1623 | return; | 1609 | return; |
1624 | present = snd_hda_codec_read(codec, 0x17, 0, | 1610 | present = snd_hda_jack_detect(codec, 0x17); |
1625 | AC_VERB_GET_PIN_SENSE, 0) & | ||
1626 | AC_PINSENSE_PRESENCE; | ||
1627 | snd_hda_codec_write(codec, 0x14, 0, | 1611 | snd_hda_codec_write(codec, 0x14, 0, |
1628 | AC_VERB_SET_CONNECT_SEL, | 1612 | AC_VERB_SET_CONNECT_SEL, |
1629 | present ? 0x01 : 0x00); | 1613 | present ? 0x01 : 0x00); |
@@ -1638,9 +1622,7 @@ static void cxt5051_portc_automic(struct hda_codec *codec) | |||
1638 | 1622 | ||
1639 | if (spec->no_auto_mic) | 1623 | if (spec->no_auto_mic) |
1640 | return; | 1624 | return; |
1641 | present = snd_hda_codec_read(codec, 0x18, 0, | 1625 | present = snd_hda_jack_detect(codec, 0x18); |
1642 | AC_VERB_GET_PIN_SENSE, 0) & | ||
1643 | AC_PINSENSE_PRESENCE; | ||
1644 | if (present) | 1626 | if (present) |
1645 | spec->cur_adc_idx = 1; | 1627 | spec->cur_adc_idx = 1; |
1646 | else | 1628 | else |
@@ -1661,9 +1643,7 @@ static void cxt5051_hp_automute(struct hda_codec *codec) | |||
1661 | { | 1643 | { |
1662 | struct conexant_spec *spec = codec->spec; | 1644 | struct conexant_spec *spec = codec->spec; |
1663 | 1645 | ||
1664 | spec->hp_present = snd_hda_codec_read(codec, 0x16, 0, | 1646 | spec->hp_present = snd_hda_jack_detect(codec, 0x16); |
1665 | AC_VERB_GET_PIN_SENSE, 0) & | ||
1666 | AC_PINSENSE_PRESENCE; | ||
1667 | cxt5051_update_speaker(codec); | 1647 | cxt5051_update_speaker(codec); |
1668 | } | 1648 | } |
1669 | 1649 | ||
@@ -2011,8 +1991,47 @@ static void cxt5066_automic(struct hda_codec *codec) | |||
2011 | }; | 1991 | }; |
2012 | unsigned int present; | 1992 | unsigned int present; |
2013 | 1993 | ||
2014 | present = snd_hda_codec_read(codec, 0x1a, 0, | 1994 | present = snd_hda_jack_detect(codec, 0x1a); |
2015 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | 1995 | if (present) { |
1996 | snd_printdd("CXT5066: external microphone detected\n"); | ||
1997 | snd_hda_sequence_write(codec, ext_mic_present); | ||
1998 | } else { | ||
1999 | snd_printdd("CXT5066: external microphone absent\n"); | ||
2000 | snd_hda_sequence_write(codec, ext_mic_absent); | ||
2001 | } | ||
2002 | } | ||
2003 | |||
2004 | /* toggle input of built-in digital mic and mic jack appropriately */ | ||
2005 | static void cxt5066_vostro_automic(struct hda_codec *codec) | ||
2006 | { | ||
2007 | struct conexant_spec *spec = codec->spec; | ||
2008 | unsigned int present; | ||
2009 | |||
2010 | struct hda_verb ext_mic_present[] = { | ||
2011 | /* enable external mic, port B */ | ||
2012 | {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, spec->ext_mic_bias}, | ||
2013 | |||
2014 | /* switch to external mic input */ | ||
2015 | {0x17, AC_VERB_SET_CONNECT_SEL, 0}, | ||
2016 | {0x14, AC_VERB_SET_CONNECT_SEL, 0}, | ||
2017 | |||
2018 | /* disable internal digital mic */ | ||
2019 | {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, | ||
2020 | {} | ||
2021 | }; | ||
2022 | static struct hda_verb ext_mic_absent[] = { | ||
2023 | /* enable internal mic, port C */ | ||
2024 | {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, | ||
2025 | |||
2026 | /* switch to internal mic input */ | ||
2027 | {0x14, AC_VERB_SET_CONNECT_SEL, 2}, | ||
2028 | |||
2029 | /* disable external mic, port B */ | ||
2030 | {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, | ||
2031 | {} | ||
2032 | }; | ||
2033 | |||
2034 | present = snd_hda_jack_detect(codec, 0x1a); | ||
2016 | if (present) { | 2035 | if (present) { |
2017 | snd_printdd("CXT5066: external microphone detected\n"); | 2036 | snd_printdd("CXT5066: external microphone detected\n"); |
2018 | snd_hda_sequence_write(codec, ext_mic_present); | 2037 | snd_hda_sequence_write(codec, ext_mic_present); |
@@ -2029,12 +2048,10 @@ static void cxt5066_hp_automute(struct hda_codec *codec) | |||
2029 | unsigned int portA, portD; | 2048 | unsigned int portA, portD; |
2030 | 2049 | ||
2031 | /* Port A */ | 2050 | /* Port A */ |
2032 | portA = snd_hda_codec_read(codec, 0x19, 0, AC_VERB_GET_PIN_SENSE, 0) | 2051 | portA = snd_hda_jack_detect(codec, 0x19); |
2033 | & AC_PINSENSE_PRESENCE; | ||
2034 | 2052 | ||
2035 | /* Port D */ | 2053 | /* Port D */ |
2036 | portD = (snd_hda_codec_read(codec, 0x1c, 0, AC_VERB_GET_PIN_SENSE, 0) | 2054 | portD = snd_hda_jack_detect(codec, 0x1c); |
2037 | & AC_PINSENSE_PRESENCE) << 1; | ||
2038 | 2055 | ||
2039 | spec->hp_present = !!(portA | portD); | 2056 | spec->hp_present = !!(portA | portD); |
2040 | snd_printdd("CXT5066: hp automute portA=%x portD=%x present=%d\n", | 2057 | snd_printdd("CXT5066: hp automute portA=%x portD=%x present=%d\n", |
@@ -2056,6 +2073,20 @@ static void cxt5066_unsol_event(struct hda_codec *codec, unsigned int res) | |||
2056 | } | 2073 | } |
2057 | } | 2074 | } |
2058 | 2075 | ||
2076 | /* unsolicited event for jack sensing */ | ||
2077 | static void cxt5066_vostro_event(struct hda_codec *codec, unsigned int res) | ||
2078 | { | ||
2079 | snd_printdd("CXT5066_vostro: unsol event %x (%x)\n", res, res >> 26); | ||
2080 | switch (res >> 26) { | ||
2081 | case CONEXANT_HP_EVENT: | ||
2082 | cxt5066_hp_automute(codec); | ||
2083 | break; | ||
2084 | case CONEXANT_MIC_EVENT: | ||
2085 | cxt5066_vostro_automic(codec); | ||
2086 | break; | ||
2087 | } | ||
2088 | } | ||
2089 | |||
2059 | static const struct hda_input_mux cxt5066_analog_mic_boost = { | 2090 | static const struct hda_input_mux cxt5066_analog_mic_boost = { |
2060 | .num_items = 5, | 2091 | .num_items = 5, |
2061 | .items = { | 2092 | .items = { |
@@ -2297,6 +2328,67 @@ static struct hda_verb cxt5066_init_verbs_olpc[] = { | |||
2297 | { } /* end */ | 2328 | { } /* end */ |
2298 | }; | 2329 | }; |
2299 | 2330 | ||
2331 | static struct hda_verb cxt5066_init_verbs_vostro[] = { | ||
2332 | /* Port A: headphones */ | ||
2333 | {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, | ||
2334 | {0x19, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */ | ||
2335 | |||
2336 | /* Port B: external microphone */ | ||
2337 | {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, | ||
2338 | |||
2339 | /* Port C: unused */ | ||
2340 | {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, | ||
2341 | |||
2342 | /* Port D: unused */ | ||
2343 | {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, | ||
2344 | |||
2345 | /* Port E: unused, but has primary EAPD */ | ||
2346 | {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, | ||
2347 | {0x1d, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */ | ||
2348 | |||
2349 | /* Port F: unused */ | ||
2350 | {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, | ||
2351 | |||
2352 | /* Port G: internal speakers */ | ||
2353 | {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, | ||
2354 | {0x1f, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */ | ||
2355 | |||
2356 | /* DAC1 */ | ||
2357 | {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, | ||
2358 | |||
2359 | /* DAC2: unused */ | ||
2360 | {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, | ||
2361 | |||
2362 | {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, | ||
2363 | {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, | ||
2364 | {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, | ||
2365 | {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, | ||
2366 | {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, | ||
2367 | {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, | ||
2368 | {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, | ||
2369 | {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, | ||
2370 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, | ||
2371 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, | ||
2372 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, | ||
2373 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, | ||
2374 | |||
2375 | /* Digital microphone port */ | ||
2376 | {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, | ||
2377 | |||
2378 | /* Audio input selectors */ | ||
2379 | {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x3}, | ||
2380 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, | ||
2381 | |||
2382 | /* Disable SPDIF */ | ||
2383 | {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, | ||
2384 | {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, | ||
2385 | |||
2386 | /* enable unsolicited events for Port A and B */ | ||
2387 | {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT}, | ||
2388 | {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT}, | ||
2389 | { } /* end */ | ||
2390 | }; | ||
2391 | |||
2300 | static struct hda_verb cxt5066_init_verbs_portd_lo[] = { | 2392 | static struct hda_verb cxt5066_init_verbs_portd_lo[] = { |
2301 | {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, | 2393 | {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, |
2302 | { } /* end */ | 2394 | { } /* end */ |
@@ -2318,6 +2410,7 @@ enum { | |||
2318 | CXT5066_LAPTOP, /* Laptops w/ EAPD support */ | 2410 | CXT5066_LAPTOP, /* Laptops w/ EAPD support */ |
2319 | CXT5066_DELL_LAPTOP, /* Dell Laptop */ | 2411 | CXT5066_DELL_LAPTOP, /* Dell Laptop */ |
2320 | CXT5066_OLPC_XO_1_5, /* OLPC XO 1.5 */ | 2412 | CXT5066_OLPC_XO_1_5, /* OLPC XO 1.5 */ |
2413 | CXT5066_DELL_VOSTO, /* Dell Vostro 1015i */ | ||
2321 | CXT5066_MODELS | 2414 | CXT5066_MODELS |
2322 | }; | 2415 | }; |
2323 | 2416 | ||
@@ -2325,6 +2418,7 @@ static const char *cxt5066_models[CXT5066_MODELS] = { | |||
2325 | [CXT5066_LAPTOP] = "laptop", | 2418 | [CXT5066_LAPTOP] = "laptop", |
2326 | [CXT5066_DELL_LAPTOP] = "dell-laptop", | 2419 | [CXT5066_DELL_LAPTOP] = "dell-laptop", |
2327 | [CXT5066_OLPC_XO_1_5] = "olpc-xo-1_5", | 2420 | [CXT5066_OLPC_XO_1_5] = "olpc-xo-1_5", |
2421 | [CXT5066_DELL_VOSTO] = "dell-vostro" | ||
2328 | }; | 2422 | }; |
2329 | 2423 | ||
2330 | static struct snd_pci_quirk cxt5066_cfg_tbl[] = { | 2424 | static struct snd_pci_quirk cxt5066_cfg_tbl[] = { |
@@ -2333,6 +2427,7 @@ static struct snd_pci_quirk cxt5066_cfg_tbl[] = { | |||
2333 | SND_PCI_QUIRK(0x1028, 0x02f5, "Dell", | 2427 | SND_PCI_QUIRK(0x1028, 0x02f5, "Dell", |
2334 | CXT5066_DELL_LAPTOP), | 2428 | CXT5066_DELL_LAPTOP), |
2335 | SND_PCI_QUIRK(0x152d, 0x0833, "OLPC XO-1.5", CXT5066_OLPC_XO_1_5), | 2429 | SND_PCI_QUIRK(0x152d, 0x0833, "OLPC XO-1.5", CXT5066_OLPC_XO_1_5), |
2430 | SND_PCI_QUIRK(0x1028, 0x0402, "Dell Vostro", CXT5066_DELL_VOSTO), | ||
2336 | {} | 2431 | {} |
2337 | }; | 2432 | }; |
2338 | 2433 | ||
@@ -2400,6 +2495,19 @@ static int patch_cxt5066(struct hda_codec *codec) | |||
2400 | /* input source automatically selected */ | 2495 | /* input source automatically selected */ |
2401 | spec->input_mux = NULL; | 2496 | spec->input_mux = NULL; |
2402 | break; | 2497 | break; |
2498 | case CXT5066_DELL_VOSTO: | ||
2499 | codec->patch_ops.unsol_event = cxt5066_vostro_event; | ||
2500 | spec->init_verbs[0] = cxt5066_init_verbs_vostro; | ||
2501 | spec->mixers[spec->num_mixers++] = cxt5066_mixer_master_olpc; | ||
2502 | spec->mixers[spec->num_mixers++] = cxt5066_mixers; | ||
2503 | spec->port_d_mode = 0; | ||
2504 | |||
2505 | /* no S/PDIF out */ | ||
2506 | spec->multiout.dig_out_nid = 0; | ||
2507 | |||
2508 | /* input source automatically selected */ | ||
2509 | spec->input_mux = NULL; | ||
2510 | break; | ||
2403 | } | 2511 | } |
2404 | 2512 | ||
2405 | return 0; | 2513 | return 0; |
@@ -2417,6 +2525,8 @@ static struct hda_codec_preset snd_hda_preset_conexant[] = { | |||
2417 | .patch = patch_cxt5051 }, | 2525 | .patch = patch_cxt5051 }, |
2418 | { .id = 0x14f15066, .name = "CX20582 (Pebble)", | 2526 | { .id = 0x14f15066, .name = "CX20582 (Pebble)", |
2419 | .patch = patch_cxt5066 }, | 2527 | .patch = patch_cxt5066 }, |
2528 | { .id = 0x14f15067, .name = "CX20583 (Pebble HSF)", | ||
2529 | .patch = patch_cxt5066 }, | ||
2420 | {} /* terminator */ | 2530 | {} /* terminator */ |
2421 | }; | 2531 | }; |
2422 | 2532 | ||
@@ -2424,6 +2534,7 @@ MODULE_ALIAS("snd-hda-codec-id:14f15045"); | |||
2424 | MODULE_ALIAS("snd-hda-codec-id:14f15047"); | 2534 | MODULE_ALIAS("snd-hda-codec-id:14f15047"); |
2425 | MODULE_ALIAS("snd-hda-codec-id:14f15051"); | 2535 | MODULE_ALIAS("snd-hda-codec-id:14f15051"); |
2426 | MODULE_ALIAS("snd-hda-codec-id:14f15066"); | 2536 | MODULE_ALIAS("snd-hda-codec-id:14f15066"); |
2537 | MODULE_ALIAS("snd-hda-codec-id:14f15067"); | ||
2427 | 2538 | ||
2428 | MODULE_LICENSE("GPL"); | 2539 | MODULE_LICENSE("GPL"); |
2429 | MODULE_DESCRIPTION("Conexant HD-audio codec"); | 2540 | MODULE_DESCRIPTION("Conexant HD-audio codec"); |
diff --git a/sound/pci/hda/patch_intelhdmi.c b/sound/pci/hda/patch_intelhdmi.c index 01a18ed475ac..928df59be5d8 100644 --- a/sound/pci/hda/patch_intelhdmi.c +++ b/sound/pci/hda/patch_intelhdmi.c | |||
@@ -33,15 +33,41 @@ | |||
33 | #include "hda_codec.h" | 33 | #include "hda_codec.h" |
34 | #include "hda_local.h" | 34 | #include "hda_local.h" |
35 | 35 | ||
36 | static hda_nid_t cvt_nid; /* audio converter */ | 36 | /* |
37 | static hda_nid_t pin_nid; /* HDMI output pin */ | 37 | * The HDMI/DisplayPort configuration can be highly dynamic. A graphics device |
38 | * could support two independent pipes, each of them can be connected to one or | ||
39 | * more ports (DVI, HDMI or DisplayPort). | ||
40 | * | ||
41 | * The HDA correspondence of pipes/ports are converter/pin nodes. | ||
42 | */ | ||
43 | #define INTEL_HDMI_CVTS 2 | ||
44 | #define INTEL_HDMI_PINS 3 | ||
38 | 45 | ||
39 | #define INTEL_HDMI_EVENT_TAG 0x08 | 46 | static char *intel_hdmi_pcm_names[INTEL_HDMI_CVTS] = { |
47 | "INTEL HDMI 0", | ||
48 | "INTEL HDMI 1", | ||
49 | }; | ||
40 | 50 | ||
41 | struct intel_hdmi_spec { | 51 | struct intel_hdmi_spec { |
42 | struct hda_multi_out multiout; | 52 | int num_cvts; |
43 | struct hda_pcm pcm_rec; | 53 | int num_pins; |
44 | struct hdmi_eld sink_eld; | 54 | hda_nid_t cvt[INTEL_HDMI_CVTS+1]; /* audio sources */ |
55 | hda_nid_t pin[INTEL_HDMI_PINS+1]; /* audio sinks */ | ||
56 | |||
57 | /* | ||
58 | * source connection for each pin | ||
59 | */ | ||
60 | hda_nid_t pin_cvt[INTEL_HDMI_PINS+1]; | ||
61 | |||
62 | /* | ||
63 | * HDMI sink attached to each pin | ||
64 | */ | ||
65 | struct hdmi_eld sink_eld[INTEL_HDMI_PINS]; | ||
66 | |||
67 | /* | ||
68 | * export one pcm per pipe | ||
69 | */ | ||
70 | struct hda_pcm pcm_rec[INTEL_HDMI_CVTS]; | ||
45 | }; | 71 | }; |
46 | 72 | ||
47 | struct hdmi_audio_infoframe { | 73 | struct hdmi_audio_infoframe { |
@@ -184,40 +210,186 @@ static struct cea_channel_speaker_allocation channel_allocations[] = { | |||
184 | { .ca_index = 0x31, .speakers = { FRW, FLW, RR, RL, FC, LFE, FR, FL } }, | 210 | { .ca_index = 0x31, .speakers = { FRW, FLW, RR, RL, FC, LFE, FR, FL } }, |
185 | }; | 211 | }; |
186 | 212 | ||
213 | |||
214 | /* | ||
215 | * HDA/HDMI auto parsing | ||
216 | */ | ||
217 | |||
218 | static int hda_node_index(hda_nid_t *nids, hda_nid_t nid) | ||
219 | { | ||
220 | int i; | ||
221 | |||
222 | for (i = 0; nids[i]; i++) | ||
223 | if (nids[i] == nid) | ||
224 | return i; | ||
225 | |||
226 | snd_printk(KERN_WARNING "HDMI: nid %d not registered\n", nid); | ||
227 | return -EINVAL; | ||
228 | } | ||
229 | |||
230 | static int intel_hdmi_read_pin_conn(struct hda_codec *codec, hda_nid_t pin_nid) | ||
231 | { | ||
232 | struct intel_hdmi_spec *spec = codec->spec; | ||
233 | hda_nid_t conn_list[HDA_MAX_CONNECTIONS]; | ||
234 | int conn_len, curr; | ||
235 | int index; | ||
236 | |||
237 | if (!(get_wcaps(codec, pin_nid) & AC_WCAP_CONN_LIST)) { | ||
238 | snd_printk(KERN_WARNING | ||
239 | "HDMI: pin %d wcaps %#x " | ||
240 | "does not support connection list\n", | ||
241 | pin_nid, get_wcaps(codec, pin_nid)); | ||
242 | return -EINVAL; | ||
243 | } | ||
244 | |||
245 | conn_len = snd_hda_get_connections(codec, pin_nid, conn_list, | ||
246 | HDA_MAX_CONNECTIONS); | ||
247 | if (conn_len > 1) | ||
248 | curr = snd_hda_codec_read(codec, pin_nid, 0, | ||
249 | AC_VERB_GET_CONNECT_SEL, 0); | ||
250 | else | ||
251 | curr = 0; | ||
252 | |||
253 | index = hda_node_index(spec->pin, pin_nid); | ||
254 | if (index < 0) | ||
255 | return -EINVAL; | ||
256 | |||
257 | spec->pin_cvt[index] = conn_list[curr]; | ||
258 | |||
259 | return 0; | ||
260 | } | ||
261 | |||
262 | static void hdmi_get_show_eld(struct hda_codec *codec, hda_nid_t pin_nid, | ||
263 | struct hdmi_eld *eld) | ||
264 | { | ||
265 | if (!snd_hdmi_get_eld(eld, codec, pin_nid)) | ||
266 | snd_hdmi_show_eld(eld); | ||
267 | } | ||
268 | |||
269 | static void hdmi_present_sense(struct hda_codec *codec, hda_nid_t pin_nid, | ||
270 | struct hdmi_eld *eld) | ||
271 | { | ||
272 | int present = snd_hda_pin_sense(codec, pin_nid); | ||
273 | |||
274 | eld->monitor_present = !!(present & AC_PINSENSE_PRESENCE); | ||
275 | eld->eld_valid = !!(present & AC_PINSENSE_ELDV); | ||
276 | |||
277 | if (present & AC_PINSENSE_ELDV) | ||
278 | hdmi_get_show_eld(codec, pin_nid, eld); | ||
279 | } | ||
280 | |||
281 | static int intel_hdmi_add_pin(struct hda_codec *codec, hda_nid_t pin_nid) | ||
282 | { | ||
283 | struct intel_hdmi_spec *spec = codec->spec; | ||
284 | |||
285 | if (spec->num_pins >= INTEL_HDMI_PINS) { | ||
286 | snd_printk(KERN_WARNING | ||
287 | "HDMI: no space for pin %d \n", pin_nid); | ||
288 | return -EINVAL; | ||
289 | } | ||
290 | |||
291 | hdmi_present_sense(codec, pin_nid, &spec->sink_eld[spec->num_pins]); | ||
292 | |||
293 | spec->pin[spec->num_pins] = pin_nid; | ||
294 | spec->num_pins++; | ||
295 | |||
296 | /* | ||
297 | * It is assumed that converter nodes come first in the node list and | ||
298 | * hence have been registered and usable now. | ||
299 | */ | ||
300 | return intel_hdmi_read_pin_conn(codec, pin_nid); | ||
301 | } | ||
302 | |||
303 | static int intel_hdmi_add_cvt(struct hda_codec *codec, hda_nid_t nid) | ||
304 | { | ||
305 | struct intel_hdmi_spec *spec = codec->spec; | ||
306 | |||
307 | if (spec->num_cvts >= INTEL_HDMI_CVTS) { | ||
308 | snd_printk(KERN_WARNING | ||
309 | "HDMI: no space for converter %d \n", nid); | ||
310 | return -EINVAL; | ||
311 | } | ||
312 | |||
313 | spec->cvt[spec->num_cvts] = nid; | ||
314 | spec->num_cvts++; | ||
315 | |||
316 | return 0; | ||
317 | } | ||
318 | |||
319 | static int intel_hdmi_parse_codec(struct hda_codec *codec) | ||
320 | { | ||
321 | hda_nid_t nid; | ||
322 | int i, nodes; | ||
323 | |||
324 | nodes = snd_hda_get_sub_nodes(codec, codec->afg, &nid); | ||
325 | if (!nid || nodes < 0) { | ||
326 | snd_printk(KERN_WARNING "HDMI: failed to get afg sub nodes\n"); | ||
327 | return -EINVAL; | ||
328 | } | ||
329 | |||
330 | for (i = 0; i < nodes; i++, nid++) { | ||
331 | unsigned int caps; | ||
332 | unsigned int type; | ||
333 | |||
334 | caps = snd_hda_param_read(codec, nid, AC_PAR_AUDIO_WIDGET_CAP); | ||
335 | type = get_wcaps_type(caps); | ||
336 | |||
337 | if (!(caps & AC_WCAP_DIGITAL)) | ||
338 | continue; | ||
339 | |||
340 | switch (type) { | ||
341 | case AC_WID_AUD_OUT: | ||
342 | if (intel_hdmi_add_cvt(codec, nid) < 0) | ||
343 | return -EINVAL; | ||
344 | break; | ||
345 | case AC_WID_PIN: | ||
346 | caps = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP); | ||
347 | if (!(caps & AC_PINCAP_HDMI)) | ||
348 | continue; | ||
349 | if (intel_hdmi_add_pin(codec, nid) < 0) | ||
350 | return -EINVAL; | ||
351 | break; | ||
352 | } | ||
353 | } | ||
354 | |||
355 | return 0; | ||
356 | } | ||
357 | |||
187 | /* | 358 | /* |
188 | * HDMI routines | 359 | * HDMI routines |
189 | */ | 360 | */ |
190 | 361 | ||
191 | #ifdef BE_PARANOID | 362 | #ifdef BE_PARANOID |
192 | static void hdmi_get_dip_index(struct hda_codec *codec, hda_nid_t nid, | 363 | static void hdmi_get_dip_index(struct hda_codec *codec, hda_nid_t pin_nid, |
193 | int *packet_index, int *byte_index) | 364 | int *packet_index, int *byte_index) |
194 | { | 365 | { |
195 | int val; | 366 | int val; |
196 | 367 | ||
197 | val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_HDMI_DIP_INDEX, 0); | 368 | val = snd_hda_codec_read(codec, pin_nid, 0, |
369 | AC_VERB_GET_HDMI_DIP_INDEX, 0); | ||
198 | 370 | ||
199 | *packet_index = val >> 5; | 371 | *packet_index = val >> 5; |
200 | *byte_index = val & 0x1f; | 372 | *byte_index = val & 0x1f; |
201 | } | 373 | } |
202 | #endif | 374 | #endif |
203 | 375 | ||
204 | static void hdmi_set_dip_index(struct hda_codec *codec, hda_nid_t nid, | 376 | static void hdmi_set_dip_index(struct hda_codec *codec, hda_nid_t pin_nid, |
205 | int packet_index, int byte_index) | 377 | int packet_index, int byte_index) |
206 | { | 378 | { |
207 | int val; | 379 | int val; |
208 | 380 | ||
209 | val = (packet_index << 5) | (byte_index & 0x1f); | 381 | val = (packet_index << 5) | (byte_index & 0x1f); |
210 | 382 | ||
211 | snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_HDMI_DIP_INDEX, val); | 383 | snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_INDEX, val); |
212 | } | 384 | } |
213 | 385 | ||
214 | static void hdmi_write_dip_byte(struct hda_codec *codec, hda_nid_t nid, | 386 | static void hdmi_write_dip_byte(struct hda_codec *codec, hda_nid_t pin_nid, |
215 | unsigned char val) | 387 | unsigned char val) |
216 | { | 388 | { |
217 | snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_HDMI_DIP_DATA, val); | 389 | snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_DATA, val); |
218 | } | 390 | } |
219 | 391 | ||
220 | static void hdmi_enable_output(struct hda_codec *codec) | 392 | static void hdmi_enable_output(struct hda_codec *codec, hda_nid_t pin_nid) |
221 | { | 393 | { |
222 | /* Unmute */ | 394 | /* Unmute */ |
223 | if (get_wcaps(codec, pin_nid) & AC_WCAP_OUT_AMP) | 395 | if (get_wcaps(codec, pin_nid) & AC_WCAP_OUT_AMP) |
@@ -231,7 +403,8 @@ static void hdmi_enable_output(struct hda_codec *codec) | |||
231 | /* | 403 | /* |
232 | * Enable Audio InfoFrame Transmission | 404 | * Enable Audio InfoFrame Transmission |
233 | */ | 405 | */ |
234 | static void hdmi_start_infoframe_trans(struct hda_codec *codec) | 406 | static void hdmi_start_infoframe_trans(struct hda_codec *codec, |
407 | hda_nid_t pin_nid) | ||
235 | { | 408 | { |
236 | hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0); | 409 | hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0); |
237 | snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_XMIT, | 410 | snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_XMIT, |
@@ -241,59 +414,49 @@ static void hdmi_start_infoframe_trans(struct hda_codec *codec) | |||
241 | /* | 414 | /* |
242 | * Disable Audio InfoFrame Transmission | 415 | * Disable Audio InfoFrame Transmission |
243 | */ | 416 | */ |
244 | static void hdmi_stop_infoframe_trans(struct hda_codec *codec) | 417 | static void hdmi_stop_infoframe_trans(struct hda_codec *codec, |
418 | hda_nid_t pin_nid) | ||
245 | { | 419 | { |
246 | hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0); | 420 | hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0); |
247 | snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_XMIT, | 421 | snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_XMIT, |
248 | AC_DIPXMIT_DISABLE); | 422 | AC_DIPXMIT_DISABLE); |
249 | } | 423 | } |
250 | 424 | ||
251 | static int hdmi_get_channel_count(struct hda_codec *codec) | 425 | static int hdmi_get_channel_count(struct hda_codec *codec, hda_nid_t nid) |
252 | { | 426 | { |
253 | return 1 + snd_hda_codec_read(codec, cvt_nid, 0, | 427 | return 1 + snd_hda_codec_read(codec, nid, 0, |
254 | AC_VERB_GET_CVT_CHAN_COUNT, 0); | 428 | AC_VERB_GET_CVT_CHAN_COUNT, 0); |
255 | } | 429 | } |
256 | 430 | ||
257 | static void hdmi_set_channel_count(struct hda_codec *codec, int chs) | 431 | static void hdmi_set_channel_count(struct hda_codec *codec, |
432 | hda_nid_t nid, int chs) | ||
258 | { | 433 | { |
259 | snd_hda_codec_write(codec, cvt_nid, 0, | 434 | if (chs != hdmi_get_channel_count(codec, nid)) |
260 | AC_VERB_SET_CVT_CHAN_COUNT, chs - 1); | 435 | snd_hda_codec_write(codec, nid, 0, |
261 | 436 | AC_VERB_SET_CVT_CHAN_COUNT, chs - 1); | |
262 | if (chs != hdmi_get_channel_count(codec)) | ||
263 | snd_printd(KERN_INFO "HDMI channel count: expect %d, get %d\n", | ||
264 | chs, hdmi_get_channel_count(codec)); | ||
265 | } | 437 | } |
266 | 438 | ||
267 | static void hdmi_debug_channel_mapping(struct hda_codec *codec) | 439 | static void hdmi_debug_channel_mapping(struct hda_codec *codec, hda_nid_t nid) |
268 | { | 440 | { |
269 | #ifdef CONFIG_SND_DEBUG_VERBOSE | 441 | #ifdef CONFIG_SND_DEBUG_VERBOSE |
270 | int i; | 442 | int i; |
271 | int slot; | 443 | int slot; |
272 | 444 | ||
273 | for (i = 0; i < 8; i++) { | 445 | for (i = 0; i < 8; i++) { |
274 | slot = snd_hda_codec_read(codec, cvt_nid, 0, | 446 | slot = snd_hda_codec_read(codec, nid, 0, |
275 | AC_VERB_GET_HDMI_CHAN_SLOT, i); | 447 | AC_VERB_GET_HDMI_CHAN_SLOT, i); |
276 | printk(KERN_DEBUG "HDMI: ASP channel %d => slot %d\n", | 448 | printk(KERN_DEBUG "HDMI: ASP channel %d => slot %d\n", |
277 | slot >> 4, slot & 0x7); | 449 | slot >> 4, slot & 0xf); |
278 | } | 450 | } |
279 | #endif | 451 | #endif |
280 | } | 452 | } |
281 | 453 | ||
282 | static void hdmi_parse_eld(struct hda_codec *codec) | ||
283 | { | ||
284 | struct intel_hdmi_spec *spec = codec->spec; | ||
285 | struct hdmi_eld *eld = &spec->sink_eld; | ||
286 | |||
287 | if (!snd_hdmi_get_eld(eld, codec, pin_nid)) | ||
288 | snd_hdmi_show_eld(eld); | ||
289 | } | ||
290 | |||
291 | 454 | ||
292 | /* | 455 | /* |
293 | * Audio InfoFrame routines | 456 | * Audio InfoFrame routines |
294 | */ | 457 | */ |
295 | 458 | ||
296 | static void hdmi_debug_dip_size(struct hda_codec *codec) | 459 | static void hdmi_debug_dip_size(struct hda_codec *codec, hda_nid_t pin_nid) |
297 | { | 460 | { |
298 | #ifdef CONFIG_SND_DEBUG_VERBOSE | 461 | #ifdef CONFIG_SND_DEBUG_VERBOSE |
299 | int i; | 462 | int i; |
@@ -310,7 +473,7 @@ static void hdmi_debug_dip_size(struct hda_codec *codec) | |||
310 | #endif | 473 | #endif |
311 | } | 474 | } |
312 | 475 | ||
313 | static void hdmi_clear_dip_buffers(struct hda_codec *codec) | 476 | static void hdmi_clear_dip_buffers(struct hda_codec *codec, hda_nid_t pin_nid) |
314 | { | 477 | { |
315 | #ifdef BE_PARANOID | 478 | #ifdef BE_PARANOID |
316 | int i, j; | 479 | int i, j; |
@@ -339,23 +502,35 @@ static void hdmi_clear_dip_buffers(struct hda_codec *codec) | |||
339 | #endif | 502 | #endif |
340 | } | 503 | } |
341 | 504 | ||
342 | static void hdmi_fill_audio_infoframe(struct hda_codec *codec, | 505 | static void hdmi_checksum_audio_infoframe(struct hdmi_audio_infoframe *ai) |
343 | struct hdmi_audio_infoframe *ai) | ||
344 | { | 506 | { |
345 | u8 *params = (u8 *)ai; | 507 | u8 *bytes = (u8 *)ai; |
346 | u8 sum = 0; | 508 | u8 sum = 0; |
347 | int i; | 509 | int i; |
348 | 510 | ||
349 | hdmi_debug_dip_size(codec); | 511 | ai->checksum = 0; |
350 | hdmi_clear_dip_buffers(codec); /* be paranoid */ | 512 | |
513 | for (i = 0; i < sizeof(*ai); i++) | ||
514 | sum += bytes[i]; | ||
351 | 515 | ||
352 | for (i = 0; i < sizeof(ai); i++) | ||
353 | sum += params[i]; | ||
354 | ai->checksum = - sum; | 516 | ai->checksum = - sum; |
517 | } | ||
518 | |||
519 | static void hdmi_fill_audio_infoframe(struct hda_codec *codec, | ||
520 | hda_nid_t pin_nid, | ||
521 | struct hdmi_audio_infoframe *ai) | ||
522 | { | ||
523 | u8 *bytes = (u8 *)ai; | ||
524 | int i; | ||
525 | |||
526 | hdmi_debug_dip_size(codec, pin_nid); | ||
527 | hdmi_clear_dip_buffers(codec, pin_nid); /* be paranoid */ | ||
528 | |||
529 | hdmi_checksum_audio_infoframe(ai); | ||
355 | 530 | ||
356 | hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0); | 531 | hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0); |
357 | for (i = 0; i < sizeof(ai); i++) | 532 | for (i = 0; i < sizeof(*ai); i++) |
358 | hdmi_write_dip_byte(codec, pin_nid, params[i]); | 533 | hdmi_write_dip_byte(codec, pin_nid, bytes[i]); |
359 | } | 534 | } |
360 | 535 | ||
361 | /* | 536 | /* |
@@ -386,11 +561,11 @@ static void init_channel_allocations(void) | |||
386 | * | 561 | * |
387 | * TODO: it could select the wrong CA from multiple candidates. | 562 | * TODO: it could select the wrong CA from multiple candidates. |
388 | */ | 563 | */ |
389 | static int hdmi_setup_channel_allocation(struct hda_codec *codec, | 564 | static int hdmi_setup_channel_allocation(struct hda_codec *codec, hda_nid_t nid, |
390 | struct hdmi_audio_infoframe *ai) | 565 | struct hdmi_audio_infoframe *ai) |
391 | { | 566 | { |
392 | struct intel_hdmi_spec *spec = codec->spec; | 567 | struct intel_hdmi_spec *spec = codec->spec; |
393 | struct hdmi_eld *eld = &spec->sink_eld; | 568 | struct hdmi_eld *eld; |
394 | int i; | 569 | int i; |
395 | int spk_mask = 0; | 570 | int spk_mask = 0; |
396 | int channels = 1 + (ai->CC02_CT47 & 0x7); | 571 | int channels = 1 + (ai->CC02_CT47 & 0x7); |
@@ -402,6 +577,11 @@ static int hdmi_setup_channel_allocation(struct hda_codec *codec, | |||
402 | if (channels <= 2) | 577 | if (channels <= 2) |
403 | return 0; | 578 | return 0; |
404 | 579 | ||
580 | i = hda_node_index(spec->pin_cvt, nid); | ||
581 | if (i < 0) | ||
582 | return 0; | ||
583 | eld = &spec->sink_eld[i]; | ||
584 | |||
405 | /* | 585 | /* |
406 | * HDMI sink's ELD info cannot always be retrieved for now, e.g. | 586 | * HDMI sink's ELD info cannot always be retrieved for now, e.g. |
407 | * in console or for audio devices. Assume the highest speakers | 587 | * in console or for audio devices. Assume the highest speakers |
@@ -439,8 +619,8 @@ static int hdmi_setup_channel_allocation(struct hda_codec *codec, | |||
439 | return ai->CA; | 619 | return ai->CA; |
440 | } | 620 | } |
441 | 621 | ||
442 | static void hdmi_setup_channel_mapping(struct hda_codec *codec, | 622 | static void hdmi_setup_channel_mapping(struct hda_codec *codec, hda_nid_t nid, |
443 | struct hdmi_audio_infoframe *ai) | 623 | struct hdmi_audio_infoframe *ai) |
444 | { | 624 | { |
445 | int i; | 625 | int i; |
446 | 626 | ||
@@ -453,17 +633,41 @@ static void hdmi_setup_channel_mapping(struct hda_codec *codec, | |||
453 | */ | 633 | */ |
454 | 634 | ||
455 | for (i = 0; i < 8; i++) | 635 | for (i = 0; i < 8; i++) |
456 | snd_hda_codec_write(codec, cvt_nid, 0, | 636 | snd_hda_codec_write(codec, nid, 0, |
457 | AC_VERB_SET_HDMI_CHAN_SLOT, | 637 | AC_VERB_SET_HDMI_CHAN_SLOT, |
458 | (i << 4) | i); | 638 | (i << 4) | i); |
459 | 639 | ||
460 | hdmi_debug_channel_mapping(codec); | 640 | hdmi_debug_channel_mapping(codec, nid); |
461 | } | 641 | } |
462 | 642 | ||
643 | static bool hdmi_infoframe_uptodate(struct hda_codec *codec, hda_nid_t pin_nid, | ||
644 | struct hdmi_audio_infoframe *ai) | ||
645 | { | ||
646 | u8 *bytes = (u8 *)ai; | ||
647 | u8 val; | ||
648 | int i; | ||
649 | |||
650 | if (snd_hda_codec_read(codec, pin_nid, 0, AC_VERB_GET_HDMI_DIP_XMIT, 0) | ||
651 | != AC_DIPXMIT_BEST) | ||
652 | return false; | ||
653 | |||
654 | hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0); | ||
655 | for (i = 0; i < sizeof(*ai); i++) { | ||
656 | val = snd_hda_codec_read(codec, pin_nid, 0, | ||
657 | AC_VERB_GET_HDMI_DIP_DATA, 0); | ||
658 | if (val != bytes[i]) | ||
659 | return false; | ||
660 | } | ||
463 | 661 | ||
464 | static void hdmi_setup_audio_infoframe(struct hda_codec *codec, | 662 | return true; |
663 | } | ||
664 | |||
665 | static void hdmi_setup_audio_infoframe(struct hda_codec *codec, hda_nid_t nid, | ||
465 | struct snd_pcm_substream *substream) | 666 | struct snd_pcm_substream *substream) |
466 | { | 667 | { |
668 | struct intel_hdmi_spec *spec = codec->spec; | ||
669 | hda_nid_t pin_nid; | ||
670 | int i; | ||
467 | struct hdmi_audio_infoframe ai = { | 671 | struct hdmi_audio_infoframe ai = { |
468 | .type = 0x84, | 672 | .type = 0x84, |
469 | .ver = 0x01, | 673 | .ver = 0x01, |
@@ -471,11 +675,22 @@ static void hdmi_setup_audio_infoframe(struct hda_codec *codec, | |||
471 | .CC02_CT47 = substream->runtime->channels - 1, | 675 | .CC02_CT47 = substream->runtime->channels - 1, |
472 | }; | 676 | }; |
473 | 677 | ||
474 | hdmi_setup_channel_allocation(codec, &ai); | 678 | hdmi_setup_channel_allocation(codec, nid, &ai); |
475 | hdmi_setup_channel_mapping(codec, &ai); | 679 | hdmi_setup_channel_mapping(codec, nid, &ai); |
476 | 680 | ||
477 | hdmi_fill_audio_infoframe(codec, &ai); | 681 | for (i = 0; i < spec->num_pins; i++) { |
478 | hdmi_start_infoframe_trans(codec); | 682 | if (spec->pin_cvt[i] != nid) |
683 | continue; | ||
684 | if (!spec->sink_eld[i].monitor_present) | ||
685 | continue; | ||
686 | |||
687 | pin_nid = spec->pin[i]; | ||
688 | if (!hdmi_infoframe_uptodate(codec, pin_nid, &ai)) { | ||
689 | hdmi_stop_infoframe_trans(codec, pin_nid); | ||
690 | hdmi_fill_audio_infoframe(codec, pin_nid, &ai); | ||
691 | hdmi_start_infoframe_trans(codec, pin_nid); | ||
692 | } | ||
693 | } | ||
479 | } | 694 | } |
480 | 695 | ||
481 | 696 | ||
@@ -485,27 +700,39 @@ static void hdmi_setup_audio_infoframe(struct hda_codec *codec, | |||
485 | 700 | ||
486 | static void hdmi_intrinsic_event(struct hda_codec *codec, unsigned int res) | 701 | static void hdmi_intrinsic_event(struct hda_codec *codec, unsigned int res) |
487 | { | 702 | { |
703 | struct intel_hdmi_spec *spec = codec->spec; | ||
704 | int tag = res >> AC_UNSOL_RES_TAG_SHIFT; | ||
488 | int pind = !!(res & AC_UNSOL_RES_PD); | 705 | int pind = !!(res & AC_UNSOL_RES_PD); |
489 | int eldv = !!(res & AC_UNSOL_RES_ELDV); | 706 | int eldv = !!(res & AC_UNSOL_RES_ELDV); |
707 | int index; | ||
490 | 708 | ||
491 | printk(KERN_INFO | 709 | printk(KERN_INFO |
492 | "HDMI hot plug event: Presence_Detect=%d ELD_Valid=%d\n", | 710 | "HDMI hot plug event: Pin=%d Presence_Detect=%d ELD_Valid=%d\n", |
493 | pind, eldv); | 711 | tag, pind, eldv); |
712 | |||
713 | index = hda_node_index(spec->pin, tag); | ||
714 | if (index < 0) | ||
715 | return; | ||
716 | |||
717 | spec->sink_eld[index].monitor_present = pind; | ||
718 | spec->sink_eld[index].eld_valid = eldv; | ||
494 | 719 | ||
495 | if (pind && eldv) { | 720 | if (pind && eldv) { |
496 | hdmi_parse_eld(codec); | 721 | hdmi_get_show_eld(codec, spec->pin[index], &spec->sink_eld[index]); |
497 | /* TODO: do real things about ELD */ | 722 | /* TODO: do real things about ELD */ |
498 | } | 723 | } |
499 | } | 724 | } |
500 | 725 | ||
501 | static void hdmi_non_intrinsic_event(struct hda_codec *codec, unsigned int res) | 726 | static void hdmi_non_intrinsic_event(struct hda_codec *codec, unsigned int res) |
502 | { | 727 | { |
728 | int tag = res >> AC_UNSOL_RES_TAG_SHIFT; | ||
503 | int subtag = (res & AC_UNSOL_RES_SUBTAG) >> AC_UNSOL_RES_SUBTAG_SHIFT; | 729 | int subtag = (res & AC_UNSOL_RES_SUBTAG) >> AC_UNSOL_RES_SUBTAG_SHIFT; |
504 | int cp_state = !!(res & AC_UNSOL_RES_CP_STATE); | 730 | int cp_state = !!(res & AC_UNSOL_RES_CP_STATE); |
505 | int cp_ready = !!(res & AC_UNSOL_RES_CP_READY); | 731 | int cp_ready = !!(res & AC_UNSOL_RES_CP_READY); |
506 | 732 | ||
507 | printk(KERN_INFO | 733 | printk(KERN_INFO |
508 | "HDMI content protection event: SUBTAG=0x%x CP_STATE=%d CP_READY=%d\n", | 734 | "HDMI CP event: PIN=%d SUBTAG=0x%x CP_STATE=%d CP_READY=%d\n", |
735 | tag, | ||
509 | subtag, | 736 | subtag, |
510 | cp_state, | 737 | cp_state, |
511 | cp_ready); | 738 | cp_ready); |
@@ -520,10 +747,11 @@ static void hdmi_non_intrinsic_event(struct hda_codec *codec, unsigned int res) | |||
520 | 747 | ||
521 | static void intel_hdmi_unsol_event(struct hda_codec *codec, unsigned int res) | 748 | static void intel_hdmi_unsol_event(struct hda_codec *codec, unsigned int res) |
522 | { | 749 | { |
750 | struct intel_hdmi_spec *spec = codec->spec; | ||
523 | int tag = res >> AC_UNSOL_RES_TAG_SHIFT; | 751 | int tag = res >> AC_UNSOL_RES_TAG_SHIFT; |
524 | int subtag = (res & AC_UNSOL_RES_SUBTAG) >> AC_UNSOL_RES_SUBTAG_SHIFT; | 752 | int subtag = (res & AC_UNSOL_RES_SUBTAG) >> AC_UNSOL_RES_SUBTAG_SHIFT; |
525 | 753 | ||
526 | if (tag != INTEL_HDMI_EVENT_TAG) { | 754 | if (hda_node_index(spec->pin, tag) < 0) { |
527 | snd_printd(KERN_INFO "Unexpected HDMI event tag 0x%x\n", tag); | 755 | snd_printd(KERN_INFO "Unexpected HDMI event tag 0x%x\n", tag); |
528 | return; | 756 | return; |
529 | } | 757 | } |
@@ -538,24 +766,29 @@ static void intel_hdmi_unsol_event(struct hda_codec *codec, unsigned int res) | |||
538 | * Callbacks | 766 | * Callbacks |
539 | */ | 767 | */ |
540 | 768 | ||
541 | static int intel_hdmi_playback_pcm_open(struct hda_pcm_stream *hinfo, | 769 | static void hdmi_setup_stream(struct hda_codec *codec, hda_nid_t nid, |
542 | struct hda_codec *codec, | 770 | u32 stream_tag, int format) |
543 | struct snd_pcm_substream *substream) | ||
544 | { | 771 | { |
545 | struct intel_hdmi_spec *spec = codec->spec; | 772 | int tag; |
546 | 773 | int fmt; | |
547 | return snd_hda_multi_out_dig_open(codec, &spec->multiout); | ||
548 | } | ||
549 | 774 | ||
550 | static int intel_hdmi_playback_pcm_close(struct hda_pcm_stream *hinfo, | 775 | tag = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0) >> 4; |
551 | struct hda_codec *codec, | 776 | fmt = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_STREAM_FORMAT, 0); |
552 | struct snd_pcm_substream *substream) | ||
553 | { | ||
554 | struct intel_hdmi_spec *spec = codec->spec; | ||
555 | 777 | ||
556 | hdmi_stop_infoframe_trans(codec); | 778 | snd_printdd("hdmi_setup_stream: " |
779 | "NID=0x%x, %sstream=0x%x, %sformat=0x%x\n", | ||
780 | nid, | ||
781 | tag == stream_tag ? "" : "new-", | ||
782 | stream_tag, | ||
783 | fmt == format ? "" : "new-", | ||
784 | format); | ||
557 | 785 | ||
558 | return snd_hda_multi_out_dig_close(codec, &spec->multiout); | 786 | if (tag != stream_tag) |
787 | snd_hda_codec_write(codec, nid, 0, | ||
788 | AC_VERB_SET_CHANNEL_STREAMID, stream_tag << 4); | ||
789 | if (fmt != format) | ||
790 | snd_hda_codec_write(codec, nid, 0, | ||
791 | AC_VERB_SET_STREAM_FORMAT, format); | ||
559 | } | 792 | } |
560 | 793 | ||
561 | static int intel_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo, | 794 | static int intel_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo, |
@@ -564,43 +797,53 @@ static int intel_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo, | |||
564 | unsigned int format, | 797 | unsigned int format, |
565 | struct snd_pcm_substream *substream) | 798 | struct snd_pcm_substream *substream) |
566 | { | 799 | { |
567 | struct intel_hdmi_spec *spec = codec->spec; | 800 | hdmi_set_channel_count(codec, hinfo->nid, |
568 | 801 | substream->runtime->channels); | |
569 | snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag, | ||
570 | format, substream); | ||
571 | 802 | ||
572 | hdmi_set_channel_count(codec, substream->runtime->channels); | 803 | hdmi_setup_audio_infoframe(codec, hinfo->nid, substream); |
573 | 804 | ||
574 | hdmi_setup_audio_infoframe(codec, substream); | 805 | hdmi_setup_stream(codec, hinfo->nid, stream_tag, format); |
806 | return 0; | ||
807 | } | ||
575 | 808 | ||
809 | static int intel_hdmi_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, | ||
810 | struct hda_codec *codec, | ||
811 | struct snd_pcm_substream *substream) | ||
812 | { | ||
576 | return 0; | 813 | return 0; |
577 | } | 814 | } |
578 | 815 | ||
579 | static struct hda_pcm_stream intel_hdmi_pcm_playback = { | 816 | static struct hda_pcm_stream intel_hdmi_pcm_playback = { |
580 | .substreams = 1, | 817 | .substreams = 1, |
581 | .channels_min = 2, | 818 | .channels_min = 2, |
582 | .channels_max = 8, | ||
583 | .ops = { | 819 | .ops = { |
584 | .open = intel_hdmi_playback_pcm_open, | 820 | .prepare = intel_hdmi_playback_pcm_prepare, |
585 | .close = intel_hdmi_playback_pcm_close, | 821 | .cleanup = intel_hdmi_playback_pcm_cleanup, |
586 | .prepare = intel_hdmi_playback_pcm_prepare | ||
587 | }, | 822 | }, |
588 | }; | 823 | }; |
589 | 824 | ||
590 | static int intel_hdmi_build_pcms(struct hda_codec *codec) | 825 | static int intel_hdmi_build_pcms(struct hda_codec *codec) |
591 | { | 826 | { |
592 | struct intel_hdmi_spec *spec = codec->spec; | 827 | struct intel_hdmi_spec *spec = codec->spec; |
593 | struct hda_pcm *info = &spec->pcm_rec; | 828 | struct hda_pcm *info = spec->pcm_rec; |
829 | int i; | ||
594 | 830 | ||
595 | codec->num_pcms = 1; | 831 | codec->num_pcms = spec->num_cvts; |
596 | codec->pcm_info = info; | 832 | codec->pcm_info = info; |
597 | 833 | ||
598 | /* NID to query formats and rates and setup streams */ | 834 | for (i = 0; i < codec->num_pcms; i++, info++) { |
599 | intel_hdmi_pcm_playback.nid = cvt_nid; | 835 | unsigned int chans; |
600 | 836 | ||
601 | info->name = "INTEL HDMI"; | 837 | chans = get_wcaps(codec, spec->cvt[i]); |
602 | info->pcm_type = HDA_PCM_TYPE_HDMI; | 838 | chans = get_wcaps_channels(chans); |
603 | info->stream[SNDRV_PCM_STREAM_PLAYBACK] = intel_hdmi_pcm_playback; | 839 | |
840 | info->name = intel_hdmi_pcm_names[i]; | ||
841 | info->pcm_type = HDA_PCM_TYPE_HDMI; | ||
842 | info->stream[SNDRV_PCM_STREAM_PLAYBACK] = | ||
843 | intel_hdmi_pcm_playback; | ||
844 | info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->cvt[i]; | ||
845 | info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = chans; | ||
846 | } | ||
604 | 847 | ||
605 | return 0; | 848 | return 0; |
606 | } | 849 | } |
@@ -609,29 +852,39 @@ static int intel_hdmi_build_controls(struct hda_codec *codec) | |||
609 | { | 852 | { |
610 | struct intel_hdmi_spec *spec = codec->spec; | 853 | struct intel_hdmi_spec *spec = codec->spec; |
611 | int err; | 854 | int err; |
855 | int i; | ||
612 | 856 | ||
613 | err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid); | 857 | for (i = 0; i < codec->num_pcms; i++) { |
614 | if (err < 0) | 858 | err = snd_hda_create_spdif_out_ctls(codec, spec->cvt[i]); |
615 | return err; | 859 | if (err < 0) |
860 | return err; | ||
861 | } | ||
616 | 862 | ||
617 | return 0; | 863 | return 0; |
618 | } | 864 | } |
619 | 865 | ||
620 | static int intel_hdmi_init(struct hda_codec *codec) | 866 | static int intel_hdmi_init(struct hda_codec *codec) |
621 | { | 867 | { |
622 | hdmi_enable_output(codec); | 868 | struct intel_hdmi_spec *spec = codec->spec; |
869 | int i; | ||
623 | 870 | ||
624 | snd_hda_codec_write(codec, pin_nid, 0, | 871 | for (i = 0; spec->pin[i]; i++) { |
625 | AC_VERB_SET_UNSOLICITED_ENABLE, | 872 | hdmi_enable_output(codec, spec->pin[i]); |
626 | AC_USRSP_EN | INTEL_HDMI_EVENT_TAG); | 873 | snd_hda_codec_write(codec, spec->pin[i], 0, |
874 | AC_VERB_SET_UNSOLICITED_ENABLE, | ||
875 | AC_USRSP_EN | spec->pin[i]); | ||
876 | } | ||
627 | return 0; | 877 | return 0; |
628 | } | 878 | } |
629 | 879 | ||
630 | static void intel_hdmi_free(struct hda_codec *codec) | 880 | static void intel_hdmi_free(struct hda_codec *codec) |
631 | { | 881 | { |
632 | struct intel_hdmi_spec *spec = codec->spec; | 882 | struct intel_hdmi_spec *spec = codec->spec; |
883 | int i; | ||
884 | |||
885 | for (i = 0; i < spec->num_pins; i++) | ||
886 | snd_hda_eld_proc_free(codec, &spec->sink_eld[i]); | ||
633 | 887 | ||
634 | snd_hda_eld_proc_free(codec, &spec->sink_eld); | ||
635 | kfree(spec); | 888 | kfree(spec); |
636 | } | 889 | } |
637 | 890 | ||
@@ -643,49 +896,38 @@ static struct hda_codec_ops intel_hdmi_patch_ops = { | |||
643 | .unsol_event = intel_hdmi_unsol_event, | 896 | .unsol_event = intel_hdmi_unsol_event, |
644 | }; | 897 | }; |
645 | 898 | ||
646 | static int do_patch_intel_hdmi(struct hda_codec *codec) | 899 | static int patch_intel_hdmi(struct hda_codec *codec) |
647 | { | 900 | { |
648 | struct intel_hdmi_spec *spec; | 901 | struct intel_hdmi_spec *spec; |
902 | int i; | ||
649 | 903 | ||
650 | spec = kzalloc(sizeof(*spec), GFP_KERNEL); | 904 | spec = kzalloc(sizeof(*spec), GFP_KERNEL); |
651 | if (spec == NULL) | 905 | if (spec == NULL) |
652 | return -ENOMEM; | 906 | return -ENOMEM; |
653 | 907 | ||
654 | spec->multiout.num_dacs = 0; /* no analog */ | ||
655 | spec->multiout.max_channels = 8; | ||
656 | spec->multiout.dig_out_nid = cvt_nid; | ||
657 | |||
658 | codec->spec = spec; | 908 | codec->spec = spec; |
909 | if (intel_hdmi_parse_codec(codec) < 0) { | ||
910 | codec->spec = NULL; | ||
911 | kfree(spec); | ||
912 | return -EINVAL; | ||
913 | } | ||
659 | codec->patch_ops = intel_hdmi_patch_ops; | 914 | codec->patch_ops = intel_hdmi_patch_ops; |
660 | 915 | ||
661 | snd_hda_eld_proc_new(codec, &spec->sink_eld); | 916 | for (i = 0; i < spec->num_pins; i++) |
917 | snd_hda_eld_proc_new(codec, &spec->sink_eld[i], i); | ||
662 | 918 | ||
663 | init_channel_allocations(); | 919 | init_channel_allocations(); |
664 | 920 | ||
665 | return 0; | 921 | return 0; |
666 | } | 922 | } |
667 | 923 | ||
668 | static int patch_intel_hdmi(struct hda_codec *codec) | ||
669 | { | ||
670 | cvt_nid = 0x02; | ||
671 | pin_nid = 0x03; | ||
672 | return do_patch_intel_hdmi(codec); | ||
673 | } | ||
674 | |||
675 | static int patch_intel_hdmi_ibexpeak(struct hda_codec *codec) | ||
676 | { | ||
677 | cvt_nid = 0x02; | ||
678 | pin_nid = 0x04; | ||
679 | return do_patch_intel_hdmi(codec); | ||
680 | } | ||
681 | |||
682 | static struct hda_codec_preset snd_hda_preset_intelhdmi[] = { | 924 | static struct hda_codec_preset snd_hda_preset_intelhdmi[] = { |
683 | { .id = 0x808629fb, .name = "G45 DEVCL", .patch = patch_intel_hdmi }, | 925 | { .id = 0x808629fb, .name = "G45 DEVCL", .patch = patch_intel_hdmi }, |
684 | { .id = 0x80862801, .name = "G45 DEVBLC", .patch = patch_intel_hdmi }, | 926 | { .id = 0x80862801, .name = "G45 DEVBLC", .patch = patch_intel_hdmi }, |
685 | { .id = 0x80862802, .name = "G45 DEVCTG", .patch = patch_intel_hdmi }, | 927 | { .id = 0x80862802, .name = "G45 DEVCTG", .patch = patch_intel_hdmi }, |
686 | { .id = 0x80862803, .name = "G45 DEVELK", .patch = patch_intel_hdmi }, | 928 | { .id = 0x80862803, .name = "G45 DEVELK", .patch = patch_intel_hdmi }, |
687 | { .id = 0x80862804, .name = "G45 DEVIBX", .patch = patch_intel_hdmi }, | 929 | { .id = 0x80862804, .name = "G45 DEVIBX", .patch = patch_intel_hdmi }, |
688 | { .id = 0x80860054, .name = "Q57 DEVIBX", .patch = patch_intel_hdmi_ibexpeak }, | 930 | { .id = 0x80860054, .name = "Q57 DEVIBX", .patch = patch_intel_hdmi }, |
689 | { .id = 0x10951392, .name = "SiI1392 HDMI", .patch = patch_intel_hdmi }, | 931 | { .id = 0x10951392, .name = "SiI1392 HDMI", .patch = patch_intel_hdmi }, |
690 | {} /* terminator */ | 932 | {} /* terminator */ |
691 | }; | 933 | }; |
diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index 24b07c9b6a8e..d967836f36bb 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c | |||
@@ -961,18 +961,12 @@ static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid, | |||
961 | static void alc_automute_pin(struct hda_codec *codec) | 961 | static void alc_automute_pin(struct hda_codec *codec) |
962 | { | 962 | { |
963 | struct alc_spec *spec = codec->spec; | 963 | struct alc_spec *spec = codec->spec; |
964 | unsigned int present, pincap; | ||
965 | unsigned int nid = spec->autocfg.hp_pins[0]; | 964 | unsigned int nid = spec->autocfg.hp_pins[0]; |
966 | int i; | 965 | int i; |
967 | 966 | ||
968 | if (!nid) | 967 | if (!nid) |
969 | return; | 968 | return; |
970 | pincap = snd_hda_query_pin_caps(codec, nid); | 969 | spec->jack_present = snd_hda_jack_detect(codec, nid); |
971 | if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */ | ||
972 | snd_hda_codec_read(codec, nid, 0, AC_VERB_SET_PIN_SENSE, 0); | ||
973 | present = snd_hda_codec_read(codec, nid, 0, | ||
974 | AC_VERB_GET_PIN_SENSE, 0); | ||
975 | spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0; | ||
976 | for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) { | 970 | for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) { |
977 | nid = spec->autocfg.speaker_pins[i]; | 971 | nid = spec->autocfg.speaker_pins[i]; |
978 | if (!nid) | 972 | if (!nid) |
@@ -1012,9 +1006,7 @@ static void alc_mic_automute(struct hda_codec *codec) | |||
1012 | 1006 | ||
1013 | cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0]; | 1007 | cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0]; |
1014 | 1008 | ||
1015 | present = snd_hda_codec_read(codec, spec->ext_mic.pin, 0, | 1009 | present = snd_hda_jack_detect(codec, spec->ext_mic.pin); |
1016 | AC_VERB_GET_PIN_SENSE, 0); | ||
1017 | present &= AC_PINSENSE_PRESENCE; | ||
1018 | if (present) { | 1010 | if (present) { |
1019 | alive = &spec->ext_mic; | 1011 | alive = &spec->ext_mic; |
1020 | dead = &spec->int_mic; | 1012 | dead = &spec->int_mic; |
@@ -1402,6 +1394,17 @@ static void alc_pick_fixup(struct hda_codec *codec, | |||
1402 | add_verb(codec->spec, fix->verbs); | 1394 | add_verb(codec->spec, fix->verbs); |
1403 | } | 1395 | } |
1404 | 1396 | ||
1397 | static int alc_read_coef_idx(struct hda_codec *codec, | ||
1398 | unsigned int coef_idx) | ||
1399 | { | ||
1400 | unsigned int val; | ||
1401 | snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, | ||
1402 | coef_idx); | ||
1403 | val = snd_hda_codec_read(codec, 0x20, 0, | ||
1404 | AC_VERB_GET_PROC_COEF, 0); | ||
1405 | return val; | ||
1406 | } | ||
1407 | |||
1405 | /* | 1408 | /* |
1406 | * ALC888 | 1409 | * ALC888 |
1407 | */ | 1410 | */ |
@@ -1513,7 +1516,7 @@ static struct hda_verb alc888_fujitsu_xa3530_verbs[] = { | |||
1513 | static void alc_automute_amp(struct hda_codec *codec) | 1516 | static void alc_automute_amp(struct hda_codec *codec) |
1514 | { | 1517 | { |
1515 | struct alc_spec *spec = codec->spec; | 1518 | struct alc_spec *spec = codec->spec; |
1516 | unsigned int val, mute, pincap; | 1519 | unsigned int mute; |
1517 | hda_nid_t nid; | 1520 | hda_nid_t nid; |
1518 | int i; | 1521 | int i; |
1519 | 1522 | ||
@@ -1522,13 +1525,7 @@ static void alc_automute_amp(struct hda_codec *codec) | |||
1522 | nid = spec->autocfg.hp_pins[i]; | 1525 | nid = spec->autocfg.hp_pins[i]; |
1523 | if (!nid) | 1526 | if (!nid) |
1524 | break; | 1527 | break; |
1525 | pincap = snd_hda_query_pin_caps(codec, nid); | 1528 | if (snd_hda_jack_detect(codec, nid)) { |
1526 | if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */ | ||
1527 | snd_hda_codec_read(codec, nid, 0, | ||
1528 | AC_VERB_SET_PIN_SENSE, 0); | ||
1529 | val = snd_hda_codec_read(codec, nid, 0, | ||
1530 | AC_VERB_GET_PIN_SENSE, 0); | ||
1531 | if (val & AC_PINSENSE_PRESENCE) { | ||
1532 | spec->jack_present = 1; | 1529 | spec->jack_present = 1; |
1533 | break; | 1530 | break; |
1534 | } | 1531 | } |
@@ -1786,6 +1783,8 @@ static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec) | |||
1786 | 1783 | ||
1787 | spec->autocfg.hp_pins[0] = 0x15; | 1784 | spec->autocfg.hp_pins[0] = 0x15; |
1788 | spec->autocfg.speaker_pins[0] = 0x14; | 1785 | spec->autocfg.speaker_pins[0] = 0x14; |
1786 | spec->autocfg.speaker_pins[1] = 0x16; | ||
1787 | spec->autocfg.speaker_pins[2] = 0x17; | ||
1789 | } | 1788 | } |
1790 | 1789 | ||
1791 | static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec) | 1790 | static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec) |
@@ -2410,12 +2409,14 @@ static const char *alc_slave_sws[] = { | |||
2410 | 2409 | ||
2411 | static void alc_free_kctls(struct hda_codec *codec); | 2410 | static void alc_free_kctls(struct hda_codec *codec); |
2412 | 2411 | ||
2412 | #ifdef CONFIG_SND_HDA_INPUT_BEEP | ||
2413 | /* additional beep mixers; the actual parameters are overwritten at build */ | 2413 | /* additional beep mixers; the actual parameters are overwritten at build */ |
2414 | static struct snd_kcontrol_new alc_beep_mixer[] = { | 2414 | static struct snd_kcontrol_new alc_beep_mixer[] = { |
2415 | HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT), | 2415 | HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT), |
2416 | HDA_CODEC_MUTE("Beep Playback Switch", 0, 0, HDA_INPUT), | 2416 | HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT), |
2417 | { } /* end */ | 2417 | { } /* end */ |
2418 | }; | 2418 | }; |
2419 | #endif | ||
2419 | 2420 | ||
2420 | static int alc_build_controls(struct hda_codec *codec) | 2421 | static int alc_build_controls(struct hda_codec *codec) |
2421 | { | 2422 | { |
@@ -2452,6 +2453,7 @@ static int alc_build_controls(struct hda_codec *codec) | |||
2452 | return err; | 2453 | return err; |
2453 | } | 2454 | } |
2454 | 2455 | ||
2456 | #ifdef CONFIG_SND_HDA_INPUT_BEEP | ||
2455 | /* create beep controls if needed */ | 2457 | /* create beep controls if needed */ |
2456 | if (spec->beep_amp) { | 2458 | if (spec->beep_amp) { |
2457 | struct snd_kcontrol_new *knew; | 2459 | struct snd_kcontrol_new *knew; |
@@ -2461,11 +2463,13 @@ static int alc_build_controls(struct hda_codec *codec) | |||
2461 | if (!kctl) | 2463 | if (!kctl) |
2462 | return -ENOMEM; | 2464 | return -ENOMEM; |
2463 | kctl->private_value = spec->beep_amp; | 2465 | kctl->private_value = spec->beep_amp; |
2464 | err = snd_hda_ctl_add(codec, kctl); | 2466 | err = snd_hda_ctl_add(codec, |
2467 | get_amp_nid_(spec->beep_amp), kctl); | ||
2465 | if (err < 0) | 2468 | if (err < 0) |
2466 | return err; | 2469 | return err; |
2467 | } | 2470 | } |
2468 | } | 2471 | } |
2472 | #endif | ||
2469 | 2473 | ||
2470 | /* if we have no master control, let's create it */ | 2474 | /* if we have no master control, let's create it */ |
2471 | if (!spec->no_analog && | 2475 | if (!spec->no_analog && |
@@ -2779,8 +2783,7 @@ static void alc880_uniwill_mic_automute(struct hda_codec *codec) | |||
2779 | unsigned int present; | 2783 | unsigned int present; |
2780 | unsigned char bits; | 2784 | unsigned char bits; |
2781 | 2785 | ||
2782 | present = snd_hda_codec_read(codec, 0x18, 0, | 2786 | present = snd_hda_jack_detect(codec, 0x18); |
2783 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | ||
2784 | bits = present ? HDA_AMP_MUTE : 0; | 2787 | bits = present ? HDA_AMP_MUTE : 0; |
2785 | snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits); | 2788 | snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits); |
2786 | } | 2789 | } |
@@ -3480,7 +3483,7 @@ static int alc_build_pcms(struct hda_codec *codec) | |||
3480 | snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog), | 3483 | snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog), |
3481 | "%s Analog", codec->chip_name); | 3484 | "%s Analog", codec->chip_name); |
3482 | info->name = spec->stream_name_analog; | 3485 | info->name = spec->stream_name_analog; |
3483 | 3486 | ||
3484 | if (spec->stream_analog_playback) { | 3487 | if (spec->stream_analog_playback) { |
3485 | if (snd_BUG_ON(!spec->multiout.dac_nids)) | 3488 | if (snd_BUG_ON(!spec->multiout.dac_nids)) |
3486 | return -EINVAL; | 3489 | return -EINVAL; |
@@ -4322,10 +4325,26 @@ static int add_control(struct alc_spec *spec, int type, const char *name, | |||
4322 | knew->name = kstrdup(name, GFP_KERNEL); | 4325 | knew->name = kstrdup(name, GFP_KERNEL); |
4323 | if (!knew->name) | 4326 | if (!knew->name) |
4324 | return -ENOMEM; | 4327 | return -ENOMEM; |
4328 | if (get_amp_nid_(val)) | ||
4329 | knew->subdevice = HDA_SUBDEV_NID_FLAG | get_amp_nid_(val); | ||
4325 | knew->private_value = val; | 4330 | knew->private_value = val; |
4326 | return 0; | 4331 | return 0; |
4327 | } | 4332 | } |
4328 | 4333 | ||
4334 | static int add_control_with_pfx(struct alc_spec *spec, int type, | ||
4335 | const char *pfx, const char *dir, | ||
4336 | const char *sfx, unsigned long val) | ||
4337 | { | ||
4338 | char name[32]; | ||
4339 | snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx); | ||
4340 | return add_control(spec, type, name, val); | ||
4341 | } | ||
4342 | |||
4343 | #define add_pb_vol_ctrl(spec, type, pfx, val) \ | ||
4344 | add_control_with_pfx(spec, type, pfx, "Playback", "Volume", val) | ||
4345 | #define add_pb_sw_ctrl(spec, type, pfx, val) \ | ||
4346 | add_control_with_pfx(spec, type, pfx, "Playback", "Switch", val) | ||
4347 | |||
4329 | #define alc880_is_fixed_pin(nid) ((nid) >= 0x14 && (nid) <= 0x17) | 4348 | #define alc880_is_fixed_pin(nid) ((nid) >= 0x14 && (nid) <= 0x17) |
4330 | #define alc880_fixed_pin_idx(nid) ((nid) - 0x14) | 4349 | #define alc880_fixed_pin_idx(nid) ((nid) - 0x14) |
4331 | #define alc880_is_multi_pin(nid) ((nid) >= 0x18) | 4350 | #define alc880_is_multi_pin(nid) ((nid) >= 0x18) |
@@ -4379,7 +4398,6 @@ static int alc880_auto_fill_dac_nids(struct alc_spec *spec, | |||
4379 | static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec, | 4398 | static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec, |
4380 | const struct auto_pin_cfg *cfg) | 4399 | const struct auto_pin_cfg *cfg) |
4381 | { | 4400 | { |
4382 | char name[32]; | ||
4383 | static const char *chname[4] = { | 4401 | static const char *chname[4] = { |
4384 | "Front", "Surround", NULL /*CLFE*/, "Side" | 4402 | "Front", "Surround", NULL /*CLFE*/, "Side" |
4385 | }; | 4403 | }; |
@@ -4392,26 +4410,26 @@ static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec, | |||
4392 | nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i])); | 4410 | nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i])); |
4393 | if (i == 2) { | 4411 | if (i == 2) { |
4394 | /* Center/LFE */ | 4412 | /* Center/LFE */ |
4395 | err = add_control(spec, ALC_CTL_WIDGET_VOL, | 4413 | err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, |
4396 | "Center Playback Volume", | 4414 | "Center", |
4397 | HDA_COMPOSE_AMP_VAL(nid, 1, 0, | 4415 | HDA_COMPOSE_AMP_VAL(nid, 1, 0, |
4398 | HDA_OUTPUT)); | 4416 | HDA_OUTPUT)); |
4399 | if (err < 0) | 4417 | if (err < 0) |
4400 | return err; | 4418 | return err; |
4401 | err = add_control(spec, ALC_CTL_WIDGET_VOL, | 4419 | err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, |
4402 | "LFE Playback Volume", | 4420 | "LFE", |
4403 | HDA_COMPOSE_AMP_VAL(nid, 2, 0, | 4421 | HDA_COMPOSE_AMP_VAL(nid, 2, 0, |
4404 | HDA_OUTPUT)); | 4422 | HDA_OUTPUT)); |
4405 | if (err < 0) | 4423 | if (err < 0) |
4406 | return err; | 4424 | return err; |
4407 | err = add_control(spec, ALC_CTL_BIND_MUTE, | 4425 | err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, |
4408 | "Center Playback Switch", | 4426 | "Center", |
4409 | HDA_COMPOSE_AMP_VAL(nid, 1, 2, | 4427 | HDA_COMPOSE_AMP_VAL(nid, 1, 2, |
4410 | HDA_INPUT)); | 4428 | HDA_INPUT)); |
4411 | if (err < 0) | 4429 | if (err < 0) |
4412 | return err; | 4430 | return err; |
4413 | err = add_control(spec, ALC_CTL_BIND_MUTE, | 4431 | err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, |
4414 | "LFE Playback Switch", | 4432 | "LFE", |
4415 | HDA_COMPOSE_AMP_VAL(nid, 2, 2, | 4433 | HDA_COMPOSE_AMP_VAL(nid, 2, 2, |
4416 | HDA_INPUT)); | 4434 | HDA_INPUT)); |
4417 | if (err < 0) | 4435 | if (err < 0) |
@@ -4423,14 +4441,12 @@ static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec, | |||
4423 | pfx = "Speaker"; | 4441 | pfx = "Speaker"; |
4424 | else | 4442 | else |
4425 | pfx = chname[i]; | 4443 | pfx = chname[i]; |
4426 | sprintf(name, "%s Playback Volume", pfx); | 4444 | err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, |
4427 | err = add_control(spec, ALC_CTL_WIDGET_VOL, name, | ||
4428 | HDA_COMPOSE_AMP_VAL(nid, 3, 0, | 4445 | HDA_COMPOSE_AMP_VAL(nid, 3, 0, |
4429 | HDA_OUTPUT)); | 4446 | HDA_OUTPUT)); |
4430 | if (err < 0) | 4447 | if (err < 0) |
4431 | return err; | 4448 | return err; |
4432 | sprintf(name, "%s Playback Switch", pfx); | 4449 | err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx, |
4433 | err = add_control(spec, ALC_CTL_BIND_MUTE, name, | ||
4434 | HDA_COMPOSE_AMP_VAL(nid, 3, 2, | 4450 | HDA_COMPOSE_AMP_VAL(nid, 3, 2, |
4435 | HDA_INPUT)); | 4451 | HDA_INPUT)); |
4436 | if (err < 0) | 4452 | if (err < 0) |
@@ -4446,7 +4462,6 @@ static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin, | |||
4446 | { | 4462 | { |
4447 | hda_nid_t nid; | 4463 | hda_nid_t nid; |
4448 | int err; | 4464 | int err; |
4449 | char name[32]; | ||
4450 | 4465 | ||
4451 | if (!pin) | 4466 | if (!pin) |
4452 | return 0; | 4467 | return 0; |
@@ -4460,21 +4475,18 @@ static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin, | |||
4460 | spec->multiout.extra_out_nid[0] = nid; | 4475 | spec->multiout.extra_out_nid[0] = nid; |
4461 | /* control HP volume/switch on the output mixer amp */ | 4476 | /* control HP volume/switch on the output mixer amp */ |
4462 | nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin)); | 4477 | nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin)); |
4463 | sprintf(name, "%s Playback Volume", pfx); | 4478 | err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, |
4464 | err = add_control(spec, ALC_CTL_WIDGET_VOL, name, | ||
4465 | HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT)); | 4479 | HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT)); |
4466 | if (err < 0) | 4480 | if (err < 0) |
4467 | return err; | 4481 | return err; |
4468 | sprintf(name, "%s Playback Switch", pfx); | 4482 | err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx, |
4469 | err = add_control(spec, ALC_CTL_BIND_MUTE, name, | ||
4470 | HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT)); | 4483 | HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT)); |
4471 | if (err < 0) | 4484 | if (err < 0) |
4472 | return err; | 4485 | return err; |
4473 | } else if (alc880_is_multi_pin(pin)) { | 4486 | } else if (alc880_is_multi_pin(pin)) { |
4474 | /* set manual connection */ | 4487 | /* set manual connection */ |
4475 | /* we have only a switch on HP-out PIN */ | 4488 | /* we have only a switch on HP-out PIN */ |
4476 | sprintf(name, "%s Playback Switch", pfx); | 4489 | err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, |
4477 | err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, | ||
4478 | HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); | 4490 | HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); |
4479 | if (err < 0) | 4491 | if (err < 0) |
4480 | return err; | 4492 | return err; |
@@ -4487,16 +4499,13 @@ static int new_analog_input(struct alc_spec *spec, hda_nid_t pin, | |||
4487 | const char *ctlname, | 4499 | const char *ctlname, |
4488 | int idx, hda_nid_t mix_nid) | 4500 | int idx, hda_nid_t mix_nid) |
4489 | { | 4501 | { |
4490 | char name[32]; | ||
4491 | int err; | 4502 | int err; |
4492 | 4503 | ||
4493 | sprintf(name, "%s Playback Volume", ctlname); | 4504 | err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, |
4494 | err = add_control(spec, ALC_CTL_WIDGET_VOL, name, | ||
4495 | HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); | 4505 | HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); |
4496 | if (err < 0) | 4506 | if (err < 0) |
4497 | return err; | 4507 | return err; |
4498 | sprintf(name, "%s Playback Switch", ctlname); | 4508 | err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, |
4499 | err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, | ||
4500 | HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); | 4509 | HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); |
4501 | if (err < 0) | 4510 | if (err < 0) |
4502 | return err; | 4511 | return err; |
@@ -4773,8 +4782,12 @@ static void set_capture_mixer(struct hda_codec *codec) | |||
4773 | } | 4782 | } |
4774 | } | 4783 | } |
4775 | 4784 | ||
4785 | #ifdef CONFIG_SND_HDA_INPUT_BEEP | ||
4776 | #define set_beep_amp(spec, nid, idx, dir) \ | 4786 | #define set_beep_amp(spec, nid, idx, dir) \ |
4777 | ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir)) | 4787 | ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir)) |
4788 | #else | ||
4789 | #define set_beep_amp(spec, nid, idx, dir) /* NOP */ | ||
4790 | #endif | ||
4778 | 4791 | ||
4779 | /* | 4792 | /* |
4780 | * OK, here we have finally the patch for ALC880 | 4793 | * OK, here we have finally the patch for ALC880 |
@@ -5087,11 +5100,8 @@ static struct hda_verb alc260_hp_unsol_verbs[] = { | |||
5087 | static void alc260_hp_automute(struct hda_codec *codec) | 5100 | static void alc260_hp_automute(struct hda_codec *codec) |
5088 | { | 5101 | { |
5089 | struct alc_spec *spec = codec->spec; | 5102 | struct alc_spec *spec = codec->spec; |
5090 | unsigned int present; | ||
5091 | 5103 | ||
5092 | present = snd_hda_codec_read(codec, 0x10, 0, | 5104 | spec->jack_present = snd_hda_jack_detect(codec, 0x10); |
5093 | AC_VERB_GET_PIN_SENSE, 0); | ||
5094 | spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0; | ||
5095 | alc260_hp_master_update(codec, 0x0f, 0x10, 0x11); | 5105 | alc260_hp_master_update(codec, 0x0f, 0x10, 0x11); |
5096 | } | 5106 | } |
5097 | 5107 | ||
@@ -5156,11 +5166,8 @@ static struct hda_verb alc260_hp_3013_unsol_verbs[] = { | |||
5156 | static void alc260_hp_3013_automute(struct hda_codec *codec) | 5166 | static void alc260_hp_3013_automute(struct hda_codec *codec) |
5157 | { | 5167 | { |
5158 | struct alc_spec *spec = codec->spec; | 5168 | struct alc_spec *spec = codec->spec; |
5159 | unsigned int present; | ||
5160 | 5169 | ||
5161 | present = snd_hda_codec_read(codec, 0x15, 0, | 5170 | spec->jack_present = snd_hda_jack_detect(codec, 0x15); |
5162 | AC_VERB_GET_PIN_SENSE, 0); | ||
5163 | spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0; | ||
5164 | alc260_hp_master_update(codec, 0x15, 0x10, 0x11); | 5171 | alc260_hp_master_update(codec, 0x15, 0x10, 0x11); |
5165 | } | 5172 | } |
5166 | 5173 | ||
@@ -5173,12 +5180,8 @@ static void alc260_hp_3013_unsol_event(struct hda_codec *codec, | |||
5173 | 5180 | ||
5174 | static void alc260_hp_3012_automute(struct hda_codec *codec) | 5181 | static void alc260_hp_3012_automute(struct hda_codec *codec) |
5175 | { | 5182 | { |
5176 | unsigned int present, bits; | 5183 | unsigned int bits = snd_hda_jack_detect(codec, 0x10) ? 0 : PIN_OUT; |
5177 | |||
5178 | present = snd_hda_codec_read(codec, 0x10, 0, | ||
5179 | AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE; | ||
5180 | 5184 | ||
5181 | bits = present ? 0 : PIN_OUT; | ||
5182 | snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, | 5185 | snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, |
5183 | bits); | 5186 | bits); |
5184 | snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, | 5187 | snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, |
@@ -5748,8 +5751,7 @@ static void alc260_replacer_672v_automute(struct hda_codec *codec) | |||
5748 | unsigned int present; | 5751 | unsigned int present; |
5749 | 5752 | ||
5750 | /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */ | 5753 | /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */ |
5751 | present = snd_hda_codec_read(codec, 0x0f, 0, | 5754 | present = snd_hda_jack_detect(codec, 0x0f); |
5752 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | ||
5753 | if (present) { | 5755 | if (present) { |
5754 | snd_hda_codec_write_cache(codec, 0x01, 0, | 5756 | snd_hda_codec_write_cache(codec, 0x01, 0, |
5755 | AC_VERB_SET_GPIO_DATA, 1); | 5757 | AC_VERB_SET_GPIO_DATA, 1); |
@@ -5989,7 +5991,6 @@ static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid, | |||
5989 | { | 5991 | { |
5990 | hda_nid_t nid_vol; | 5992 | hda_nid_t nid_vol; |
5991 | unsigned long vol_val, sw_val; | 5993 | unsigned long vol_val, sw_val; |
5992 | char name[32]; | ||
5993 | int err; | 5994 | int err; |
5994 | 5995 | ||
5995 | if (nid >= 0x0f && nid < 0x11) { | 5996 | if (nid >= 0x0f && nid < 0x11) { |
@@ -6009,14 +6010,12 @@ static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid, | |||
6009 | 6010 | ||
6010 | if (!(*vol_bits & (1 << nid_vol))) { | 6011 | if (!(*vol_bits & (1 << nid_vol))) { |
6011 | /* first control for the volume widget */ | 6012 | /* first control for the volume widget */ |
6012 | snprintf(name, sizeof(name), "%s Playback Volume", pfx); | 6013 | err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, vol_val); |
6013 | err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val); | ||
6014 | if (err < 0) | 6014 | if (err < 0) |
6015 | return err; | 6015 | return err; |
6016 | *vol_bits |= (1 << nid_vol); | 6016 | *vol_bits |= (1 << nid_vol); |
6017 | } | 6017 | } |
6018 | snprintf(name, sizeof(name), "%s Playback Switch", pfx); | 6018 | err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, sw_val); |
6019 | err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val); | ||
6020 | if (err < 0) | 6019 | if (err < 0) |
6021 | return err; | 6020 | return err; |
6022 | return 1; | 6021 | return 1; |
@@ -8184,12 +8183,8 @@ static void alc883_mitac_setup(struct hda_codec *codec) | |||
8184 | /* | 8183 | /* |
8185 | static void alc883_mitac_mic_automute(struct hda_codec *codec) | 8184 | static void alc883_mitac_mic_automute(struct hda_codec *codec) |
8186 | { | 8185 | { |
8187 | unsigned int present; | 8186 | unsigned char bits = snd_hda_jack_detect(codec, 0x18) ? HDA_AMP_MUTE : 0; |
8188 | unsigned char bits; | ||
8189 | 8187 | ||
8190 | present = snd_hda_codec_read(codec, 0x18, 0, | ||
8191 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | ||
8192 | bits = present ? HDA_AMP_MUTE : 0; | ||
8193 | snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits); | 8188 | snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits); |
8194 | } | 8189 | } |
8195 | */ | 8190 | */ |
@@ -8411,10 +8406,8 @@ static struct hda_channel_mode alc888_3st_hp_modes[3] = { | |||
8411 | /* toggle front-jack and RCA according to the hp-jack state */ | 8406 | /* toggle front-jack and RCA according to the hp-jack state */ |
8412 | static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec) | 8407 | static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec) |
8413 | { | 8408 | { |
8414 | unsigned int present; | 8409 | unsigned int present = snd_hda_jack_detect(codec, 0x1b); |
8415 | 8410 | ||
8416 | present = snd_hda_codec_read(codec, 0x1b, 0, | ||
8417 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | ||
8418 | snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, | 8411 | snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, |
8419 | HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); | 8412 | HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); |
8420 | snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, | 8413 | snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, |
@@ -8424,10 +8417,8 @@ static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec) | |||
8424 | /* toggle RCA according to the front-jack state */ | 8417 | /* toggle RCA according to the front-jack state */ |
8425 | static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec) | 8418 | static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec) |
8426 | { | 8419 | { |
8427 | unsigned int present; | 8420 | unsigned int present = snd_hda_jack_detect(codec, 0x14); |
8428 | 8421 | ||
8429 | present = snd_hda_codec_read(codec, 0x14, 0, | ||
8430 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | ||
8431 | snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, | 8422 | snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, |
8432 | HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); | 8423 | HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); |
8433 | } | 8424 | } |
@@ -8468,8 +8459,7 @@ static void alc883_clevo_m720_mic_automute(struct hda_codec *codec) | |||
8468 | { | 8459 | { |
8469 | unsigned int present; | 8460 | unsigned int present; |
8470 | 8461 | ||
8471 | present = snd_hda_codec_read(codec, 0x18, 0, | 8462 | present = snd_hda_jack_detect(codec, 0x18); |
8472 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | ||
8473 | snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, | 8463 | snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, |
8474 | HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); | 8464 | HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); |
8475 | } | 8465 | } |
@@ -8520,24 +8510,16 @@ static void alc883_haier_w66_setup(struct hda_codec *codec) | |||
8520 | 8510 | ||
8521 | static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec) | 8511 | static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec) |
8522 | { | 8512 | { |
8523 | unsigned int present; | 8513 | int bits = snd_hda_jack_detect(codec, 0x14) ? HDA_AMP_MUTE : 0; |
8524 | unsigned char bits; | ||
8525 | 8514 | ||
8526 | present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0) | ||
8527 | & AC_PINSENSE_PRESENCE; | ||
8528 | bits = present ? HDA_AMP_MUTE : 0; | ||
8529 | snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, | 8515 | snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, |
8530 | HDA_AMP_MUTE, bits); | 8516 | HDA_AMP_MUTE, bits); |
8531 | } | 8517 | } |
8532 | 8518 | ||
8533 | static void alc883_lenovo_101e_all_automute(struct hda_codec *codec) | 8519 | static void alc883_lenovo_101e_all_automute(struct hda_codec *codec) |
8534 | { | 8520 | { |
8535 | unsigned int present; | 8521 | int bits = snd_hda_jack_detect(codec, 0x1b) ? HDA_AMP_MUTE : 0; |
8536 | unsigned char bits; | ||
8537 | 8522 | ||
8538 | present = snd_hda_codec_read(codec, 0x1b, 0, | ||
8539 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | ||
8540 | bits = present ? HDA_AMP_MUTE : 0; | ||
8541 | snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, | 8523 | snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, |
8542 | HDA_AMP_MUTE, bits); | 8524 | HDA_AMP_MUTE, bits); |
8543 | snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, | 8525 | snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, |
@@ -8688,8 +8670,7 @@ static void alc889A_mb31_automute(struct hda_codec *codec) | |||
8688 | /* Mute only in 2ch or 4ch mode */ | 8670 | /* Mute only in 2ch or 4ch mode */ |
8689 | if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0) | 8671 | if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0) |
8690 | == 0x00) { | 8672 | == 0x00) { |
8691 | present = snd_hda_codec_read(codec, 0x15, 0, | 8673 | present = snd_hda_jack_detect(codec, 0x15); |
8692 | AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE; | ||
8693 | snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, | 8674 | snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, |
8694 | HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); | 8675 | HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); |
8695 | snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, | 8676 | snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, |
@@ -10032,10 +10013,8 @@ static void alc262_hp_master_update(struct hda_codec *codec) | |||
10032 | static void alc262_hp_bpc_automute(struct hda_codec *codec) | 10013 | static void alc262_hp_bpc_automute(struct hda_codec *codec) |
10033 | { | 10014 | { |
10034 | struct alc_spec *spec = codec->spec; | 10015 | struct alc_spec *spec = codec->spec; |
10035 | unsigned int presence; | 10016 | |
10036 | presence = snd_hda_codec_read(codec, 0x1b, 0, | 10017 | spec->jack_present = snd_hda_jack_detect(codec, 0x1b); |
10037 | AC_VERB_GET_PIN_SENSE, 0); | ||
10038 | spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE); | ||
10039 | alc262_hp_master_update(codec); | 10018 | alc262_hp_master_update(codec); |
10040 | } | 10019 | } |
10041 | 10020 | ||
@@ -10049,10 +10028,8 @@ static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res) | |||
10049 | static void alc262_hp_wildwest_automute(struct hda_codec *codec) | 10028 | static void alc262_hp_wildwest_automute(struct hda_codec *codec) |
10050 | { | 10029 | { |
10051 | struct alc_spec *spec = codec->spec; | 10030 | struct alc_spec *spec = codec->spec; |
10052 | unsigned int presence; | 10031 | |
10053 | presence = snd_hda_codec_read(codec, 0x15, 0, | 10032 | spec->jack_present = snd_hda_jack_detect(codec, 0x15); |
10054 | AC_VERB_GET_PIN_SENSE, 0); | ||
10055 | spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE); | ||
10056 | alc262_hp_master_update(codec); | 10033 | alc262_hp_master_update(codec); |
10057 | } | 10034 | } |
10058 | 10035 | ||
@@ -10286,13 +10263,8 @@ static void alc262_hippo_automute(struct hda_codec *codec) | |||
10286 | { | 10263 | { |
10287 | struct alc_spec *spec = codec->spec; | 10264 | struct alc_spec *spec = codec->spec; |
10288 | hda_nid_t hp_nid = spec->autocfg.hp_pins[0]; | 10265 | hda_nid_t hp_nid = spec->autocfg.hp_pins[0]; |
10289 | unsigned int present; | ||
10290 | 10266 | ||
10291 | /* need to execute and sync at first */ | 10267 | spec->jack_present = snd_hda_jack_detect(codec, hp_nid); |
10292 | snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0); | ||
10293 | present = snd_hda_codec_read(codec, hp_nid, 0, | ||
10294 | AC_VERB_GET_PIN_SENSE, 0); | ||
10295 | spec->jack_present = (present & 0x80000000) != 0; | ||
10296 | alc262_hippo_master_update(codec); | 10268 | alc262_hippo_master_update(codec); |
10297 | } | 10269 | } |
10298 | 10270 | ||
@@ -10618,21 +10590,8 @@ static void alc262_fujitsu_automute(struct hda_codec *codec, int force) | |||
10618 | unsigned int mute; | 10590 | unsigned int mute; |
10619 | 10591 | ||
10620 | if (force || !spec->sense_updated) { | 10592 | if (force || !spec->sense_updated) { |
10621 | unsigned int present; | 10593 | spec->jack_present = snd_hda_jack_detect(codec, 0x14) || |
10622 | /* need to execute and sync at first */ | 10594 | snd_hda_jack_detect(codec, 0x1b); |
10623 | snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0); | ||
10624 | /* check laptop HP jack */ | ||
10625 | present = snd_hda_codec_read(codec, 0x14, 0, | ||
10626 | AC_VERB_GET_PIN_SENSE, 0); | ||
10627 | /* need to execute and sync at first */ | ||
10628 | snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0); | ||
10629 | /* check docking HP jack */ | ||
10630 | present |= snd_hda_codec_read(codec, 0x1b, 0, | ||
10631 | AC_VERB_GET_PIN_SENSE, 0); | ||
10632 | if (present & AC_PINSENSE_PRESENCE) | ||
10633 | spec->jack_present = 1; | ||
10634 | else | ||
10635 | spec->jack_present = 0; | ||
10636 | spec->sense_updated = 1; | 10595 | spec->sense_updated = 1; |
10637 | } | 10596 | } |
10638 | /* unmute internal speaker only if both HPs are unplugged and | 10597 | /* unmute internal speaker only if both HPs are unplugged and |
@@ -10677,12 +10636,7 @@ static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force) | |||
10677 | unsigned int mute; | 10636 | unsigned int mute; |
10678 | 10637 | ||
10679 | if (force || !spec->sense_updated) { | 10638 | if (force || !spec->sense_updated) { |
10680 | unsigned int present_int_hp; | 10639 | spec->jack_present = snd_hda_jack_detect(codec, 0x1b); |
10681 | /* need to execute and sync at first */ | ||
10682 | snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0); | ||
10683 | present_int_hp = snd_hda_codec_read(codec, 0x1b, 0, | ||
10684 | AC_VERB_GET_PIN_SENSE, 0); | ||
10685 | spec->jack_present = (present_int_hp & 0x80000000) != 0; | ||
10686 | spec->sense_updated = 1; | 10640 | spec->sense_updated = 1; |
10687 | } | 10641 | } |
10688 | if (spec->jack_present) { | 10642 | if (spec->jack_present) { |
@@ -10874,12 +10828,7 @@ static void alc262_ultra_automute(struct hda_codec *codec) | |||
10874 | mute = 0; | 10828 | mute = 0; |
10875 | /* auto-mute only when HP is used as HP */ | 10829 | /* auto-mute only when HP is used as HP */ |
10876 | if (!spec->cur_mux[0]) { | 10830 | if (!spec->cur_mux[0]) { |
10877 | unsigned int present; | 10831 | spec->jack_present = snd_hda_jack_detect(codec, 0x15); |
10878 | /* need to execute and sync at first */ | ||
10879 | snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0); | ||
10880 | present = snd_hda_codec_read(codec, 0x15, 0, | ||
10881 | AC_VERB_GET_PIN_SENSE, 0); | ||
10882 | spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0; | ||
10883 | if (spec->jack_present) | 10832 | if (spec->jack_present) |
10884 | mute = HDA_AMP_MUTE; | 10833 | mute = HDA_AMP_MUTE; |
10885 | } | 10834 | } |
@@ -10956,7 +10905,6 @@ static int alc262_check_volbit(hda_nid_t nid) | |||
10956 | static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid, | 10905 | static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid, |
10957 | const char *pfx, int *vbits) | 10906 | const char *pfx, int *vbits) |
10958 | { | 10907 | { |
10959 | char name[32]; | ||
10960 | unsigned long val; | 10908 | unsigned long val; |
10961 | int vbit; | 10909 | int vbit; |
10962 | 10910 | ||
@@ -10966,28 +10914,25 @@ static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid, | |||
10966 | if (*vbits & vbit) /* a volume control for this mixer already there */ | 10914 | if (*vbits & vbit) /* a volume control for this mixer already there */ |
10967 | return 0; | 10915 | return 0; |
10968 | *vbits |= vbit; | 10916 | *vbits |= vbit; |
10969 | snprintf(name, sizeof(name), "%s Playback Volume", pfx); | ||
10970 | if (vbit == 2) | 10917 | if (vbit == 2) |
10971 | val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT); | 10918 | val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT); |
10972 | else | 10919 | else |
10973 | val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT); | 10920 | val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT); |
10974 | return add_control(spec, ALC_CTL_WIDGET_VOL, name, val); | 10921 | return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, val); |
10975 | } | 10922 | } |
10976 | 10923 | ||
10977 | static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid, | 10924 | static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid, |
10978 | const char *pfx) | 10925 | const char *pfx) |
10979 | { | 10926 | { |
10980 | char name[32]; | ||
10981 | unsigned long val; | 10927 | unsigned long val; |
10982 | 10928 | ||
10983 | if (!nid) | 10929 | if (!nid) |
10984 | return 0; | 10930 | return 0; |
10985 | snprintf(name, sizeof(name), "%s Playback Switch", pfx); | ||
10986 | if (nid == 0x16) | 10931 | if (nid == 0x16) |
10987 | val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT); | 10932 | val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT); |
10988 | else | 10933 | else |
10989 | val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); | 10934 | val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); |
10990 | return add_control(spec, ALC_CTL_WIDGET_MUTE, name, val); | 10935 | return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, val); |
10991 | } | 10936 | } |
10992 | 10937 | ||
10993 | /* add playback controls from the parsed DAC table */ | 10938 | /* add playback controls from the parsed DAC table */ |
@@ -11463,8 +11408,10 @@ static struct snd_pci_quirk alc262_cfg_tbl[] = { | |||
11463 | SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06), | 11408 | SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06), |
11464 | SND_PCI_QUIRK(0x104d, 0x9035, "Sony VAIO VGN-FW170J", ALC262_AUTO), | 11409 | SND_PCI_QUIRK(0x104d, 0x9035, "Sony VAIO VGN-FW170J", ALC262_AUTO), |
11465 | SND_PCI_QUIRK(0x104d, 0x9047, "Sony VAIO Type G", ALC262_AUTO), | 11410 | SND_PCI_QUIRK(0x104d, 0x9047, "Sony VAIO Type G", ALC262_AUTO), |
11411 | #if 0 /* disable the quirk since model=auto works better in recent versions */ | ||
11466 | SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO", | 11412 | SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO", |
11467 | ALC262_SONY_ASSAMD), | 11413 | ALC262_SONY_ASSAMD), |
11414 | #endif | ||
11468 | SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1", | 11415 | SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1", |
11469 | ALC262_TOSHIBA_RX1), | 11416 | ALC262_TOSHIBA_RX1), |
11470 | SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06), | 11417 | SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06), |
@@ -11923,10 +11870,7 @@ static void alc268_acer_automute(struct hda_codec *codec, int force) | |||
11923 | unsigned int mute; | 11870 | unsigned int mute; |
11924 | 11871 | ||
11925 | if (force || !spec->sense_updated) { | 11872 | if (force || !spec->sense_updated) { |
11926 | unsigned int present; | 11873 | spec->jack_present = snd_hda_jack_detect(codec, 0x14); |
11927 | present = snd_hda_codec_read(codec, 0x14, 0, | ||
11928 | AC_VERB_GET_PIN_SENSE, 0); | ||
11929 | spec->jack_present = (present & 0x80000000) != 0; | ||
11930 | spec->sense_updated = 1; | 11874 | spec->sense_updated = 1; |
11931 | } | 11875 | } |
11932 | if (spec->jack_present) | 11876 | if (spec->jack_present) |
@@ -12045,8 +11989,7 @@ static void alc268_aspire_one_speaker_automute(struct hda_codec *codec) | |||
12045 | unsigned int present; | 11989 | unsigned int present; |
12046 | unsigned char bits; | 11990 | unsigned char bits; |
12047 | 11991 | ||
12048 | present = snd_hda_codec_read(codec, 0x15, 0, | 11992 | present = snd_hda_jack_detect(codec, 0x15); |
12049 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | ||
12050 | bits = present ? AMP_IN_MUTE(0) : 0; | 11993 | bits = present ? AMP_IN_MUTE(0) : 0; |
12051 | snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0, | 11994 | snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0, |
12052 | AMP_IN_MUTE(0), bits); | 11995 | AMP_IN_MUTE(0), bits); |
@@ -12327,11 +12270,9 @@ static struct snd_kcontrol_new alc268_test_mixer[] = { | |||
12327 | static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid, | 12270 | static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid, |
12328 | const char *ctlname, int idx) | 12271 | const char *ctlname, int idx) |
12329 | { | 12272 | { |
12330 | char name[32]; | ||
12331 | hda_nid_t dac; | 12273 | hda_nid_t dac; |
12332 | int err; | 12274 | int err; |
12333 | 12275 | ||
12334 | sprintf(name, "%s Playback Volume", ctlname); | ||
12335 | switch (nid) { | 12276 | switch (nid) { |
12336 | case 0x14: | 12277 | case 0x14: |
12337 | case 0x16: | 12278 | case 0x16: |
@@ -12345,7 +12286,7 @@ static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid, | |||
12345 | } | 12286 | } |
12346 | if (spec->multiout.dac_nids[0] != dac && | 12287 | if (spec->multiout.dac_nids[0] != dac && |
12347 | spec->multiout.dac_nids[1] != dac) { | 12288 | spec->multiout.dac_nids[1] != dac) { |
12348 | err = add_control(spec, ALC_CTL_WIDGET_VOL, name, | 12289 | err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, |
12349 | HDA_COMPOSE_AMP_VAL(dac, 3, idx, | 12290 | HDA_COMPOSE_AMP_VAL(dac, 3, idx, |
12350 | HDA_OUTPUT)); | 12291 | HDA_OUTPUT)); |
12351 | if (err < 0) | 12292 | if (err < 0) |
@@ -12353,12 +12294,11 @@ static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid, | |||
12353 | spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac; | 12294 | spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac; |
12354 | } | 12295 | } |
12355 | 12296 | ||
12356 | sprintf(name, "%s Playback Switch", ctlname); | ||
12357 | if (nid != 0x16) | 12297 | if (nid != 0x16) |
12358 | err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, | 12298 | err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, |
12359 | HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT)); | 12299 | HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT)); |
12360 | else /* mono */ | 12300 | else /* mono */ |
12361 | err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, | 12301 | err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, |
12362 | HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT)); | 12302 | HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT)); |
12363 | if (err < 0) | 12303 | if (err < 0) |
12364 | return err; | 12304 | return err; |
@@ -12388,8 +12328,7 @@ static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec, | |||
12388 | 12328 | ||
12389 | nid = cfg->speaker_pins[0]; | 12329 | nid = cfg->speaker_pins[0]; |
12390 | if (nid == 0x1d) { | 12330 | if (nid == 0x1d) { |
12391 | err = add_control(spec, ALC_CTL_WIDGET_VOL, | 12331 | err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, "Speaker", |
12392 | "Speaker Playback Volume", | ||
12393 | HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT)); | 12332 | HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT)); |
12394 | if (err < 0) | 12333 | if (err < 0) |
12395 | return err; | 12334 | return err; |
@@ -12407,8 +12346,7 @@ static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec, | |||
12407 | 12346 | ||
12408 | nid = cfg->line_out_pins[1] | cfg->line_out_pins[2]; | 12347 | nid = cfg->line_out_pins[1] | cfg->line_out_pins[2]; |
12409 | if (nid == 0x16) { | 12348 | if (nid == 0x16) { |
12410 | err = add_control(spec, ALC_CTL_WIDGET_MUTE, | 12349 | err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, "Mono", |
12411 | "Mono Playback Switch", | ||
12412 | HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT)); | 12350 | HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT)); |
12413 | if (err < 0) | 12351 | if (err < 0) |
12414 | return err; | 12352 | return err; |
@@ -13034,8 +12972,7 @@ static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec) | |||
13034 | unsigned int present; | 12972 | unsigned int present; |
13035 | unsigned char bits; | 12973 | unsigned char bits; |
13036 | 12974 | ||
13037 | present = snd_hda_codec_read(codec, 0x15, 0, | 12975 | present = snd_hda_jack_detect(codec, 0x15); |
13038 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | ||
13039 | bits = present ? AMP_IN_MUTE(0) : 0; | 12976 | bits = present ? AMP_IN_MUTE(0) : 0; |
13040 | snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, | 12977 | snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, |
13041 | AMP_IN_MUTE(0), bits); | 12978 | AMP_IN_MUTE(0), bits); |
@@ -13060,12 +12997,10 @@ static void alc269_lifebook_speaker_automute(struct hda_codec *codec) | |||
13060 | unsigned char bits; | 12997 | unsigned char bits; |
13061 | 12998 | ||
13062 | /* Check laptop headphone socket */ | 12999 | /* Check laptop headphone socket */ |
13063 | present = snd_hda_codec_read(codec, 0x15, 0, | 13000 | present = snd_hda_jack_detect(codec, 0x15); |
13064 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | ||
13065 | 13001 | ||
13066 | /* Check port replicator headphone socket */ | 13002 | /* Check port replicator headphone socket */ |
13067 | present |= snd_hda_codec_read(codec, 0x1a, 0, | 13003 | present |= snd_hda_jack_detect(codec, 0x1a); |
13068 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | ||
13069 | 13004 | ||
13070 | bits = present ? AMP_IN_MUTE(0) : 0; | 13005 | bits = present ? AMP_IN_MUTE(0) : 0; |
13071 | snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, | 13006 | snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, |
@@ -13089,11 +13024,8 @@ static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec) | |||
13089 | unsigned int present_laptop; | 13024 | unsigned int present_laptop; |
13090 | unsigned int present_dock; | 13025 | unsigned int present_dock; |
13091 | 13026 | ||
13092 | present_laptop = snd_hda_codec_read(codec, 0x18, 0, | 13027 | present_laptop = snd_hda_jack_detect(codec, 0x18); |
13093 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | 13028 | present_dock = snd_hda_jack_detect(codec, 0x1b); |
13094 | |||
13095 | present_dock = snd_hda_codec_read(codec, 0x1b, 0, | ||
13096 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | ||
13097 | 13029 | ||
13098 | /* Laptop mic port overrides dock mic port, design decision */ | 13030 | /* Laptop mic port overrides dock mic port, design decision */ |
13099 | if (present_dock) | 13031 | if (present_dock) |
@@ -13178,8 +13110,7 @@ static void alc269_speaker_automute(struct hda_codec *codec) | |||
13178 | unsigned int present; | 13110 | unsigned int present; |
13179 | unsigned char bits; | 13111 | unsigned char bits; |
13180 | 13112 | ||
13181 | present = snd_hda_codec_read(codec, 0x15, 0, | 13113 | present = snd_hda_jack_detect(codec, 0x15); |
13182 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | ||
13183 | bits = present ? AMP_IN_MUTE(0) : 0; | 13114 | bits = present ? AMP_IN_MUTE(0) : 0; |
13184 | snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, | 13115 | snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, |
13185 | AMP_IN_MUTE(0), bits); | 13116 | AMP_IN_MUTE(0), bits); |
@@ -13525,6 +13456,15 @@ static int patch_alc269(struct hda_codec *codec) | |||
13525 | 13456 | ||
13526 | alc_fix_pll_init(codec, 0x20, 0x04, 15); | 13457 | alc_fix_pll_init(codec, 0x20, 0x04, 15); |
13527 | 13458 | ||
13459 | if ((alc_read_coef_idx(codec, 0) & 0x00f0) == 0x0010){ | ||
13460 | kfree(codec->chip_name); | ||
13461 | codec->chip_name = kstrdup("ALC259", GFP_KERNEL); | ||
13462 | if (!codec->chip_name) { | ||
13463 | alc_free(codec); | ||
13464 | return -ENOMEM; | ||
13465 | } | ||
13466 | } | ||
13467 | |||
13528 | board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST, | 13468 | board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST, |
13529 | alc269_models, | 13469 | alc269_models, |
13530 | alc269_cfg_tbl); | 13470 | alc269_cfg_tbl); |
@@ -14157,10 +14097,8 @@ static struct hda_verb alc861_toshiba_init_verbs[] = { | |||
14157 | /* toggle speaker-output according to the hp-jack state */ | 14097 | /* toggle speaker-output according to the hp-jack state */ |
14158 | static void alc861_toshiba_automute(struct hda_codec *codec) | 14098 | static void alc861_toshiba_automute(struct hda_codec *codec) |
14159 | { | 14099 | { |
14160 | unsigned int present; | 14100 | unsigned int present = snd_hda_jack_detect(codec, 0x0f); |
14161 | 14101 | ||
14162 | present = snd_hda_codec_read(codec, 0x0f, 0, | ||
14163 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | ||
14164 | snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0, | 14102 | snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0, |
14165 | HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); | 14103 | HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); |
14166 | snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3, | 14104 | snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3, |
@@ -14260,9 +14198,7 @@ static int alc861_auto_fill_dac_nids(struct hda_codec *codec, | |||
14260 | static int alc861_create_out_sw(struct hda_codec *codec, const char *pfx, | 14198 | static int alc861_create_out_sw(struct hda_codec *codec, const char *pfx, |
14261 | hda_nid_t nid, unsigned int chs) | 14199 | hda_nid_t nid, unsigned int chs) |
14262 | { | 14200 | { |
14263 | char name[32]; | 14201 | return add_pb_sw_ctrl(codec->spec, ALC_CTL_WIDGET_MUTE, pfx, |
14264 | snprintf(name, sizeof(name), "%s Playback Switch", pfx); | ||
14265 | return add_control(codec->spec, ALC_CTL_WIDGET_MUTE, name, | ||
14266 | HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT)); | 14202 | HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT)); |
14267 | } | 14203 | } |
14268 | 14204 | ||
@@ -14627,6 +14563,27 @@ static struct alc_config_preset alc861_presets[] = { | |||
14627 | }, | 14563 | }, |
14628 | }; | 14564 | }; |
14629 | 14565 | ||
14566 | /* Pin config fixes */ | ||
14567 | enum { | ||
14568 | PINFIX_FSC_AMILO_PI1505, | ||
14569 | }; | ||
14570 | |||
14571 | static struct alc_pincfg alc861_fsc_amilo_pi1505_pinfix[] = { | ||
14572 | { 0x0b, 0x0221101f }, /* HP */ | ||
14573 | { 0x0f, 0x90170310 }, /* speaker */ | ||
14574 | { } | ||
14575 | }; | ||
14576 | |||
14577 | static const struct alc_fixup alc861_fixups[] = { | ||
14578 | [PINFIX_FSC_AMILO_PI1505] = { | ||
14579 | .pins = alc861_fsc_amilo_pi1505_pinfix | ||
14580 | }, | ||
14581 | }; | ||
14582 | |||
14583 | static struct snd_pci_quirk alc861_fixup_tbl[] = { | ||
14584 | SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505), | ||
14585 | {} | ||
14586 | }; | ||
14630 | 14587 | ||
14631 | static int patch_alc861(struct hda_codec *codec) | 14588 | static int patch_alc861(struct hda_codec *codec) |
14632 | { | 14589 | { |
@@ -14650,6 +14607,8 @@ static int patch_alc861(struct hda_codec *codec) | |||
14650 | board_config = ALC861_AUTO; | 14607 | board_config = ALC861_AUTO; |
14651 | } | 14608 | } |
14652 | 14609 | ||
14610 | alc_pick_fixup(codec, alc861_fixup_tbl, alc861_fixups); | ||
14611 | |||
14653 | if (board_config == ALC861_AUTO) { | 14612 | if (board_config == ALC861_AUTO) { |
14654 | /* automatic parse from the BIOS config */ | 14613 | /* automatic parse from the BIOS config */ |
14655 | err = alc861_parse_auto_config(codec); | 14614 | err = alc861_parse_auto_config(codec); |
@@ -15067,9 +15026,9 @@ static void alc861vd_lenovo_mic_automute(struct hda_codec *codec) | |||
15067 | unsigned int present; | 15026 | unsigned int present; |
15068 | unsigned char bits; | 15027 | unsigned char bits; |
15069 | 15028 | ||
15070 | present = snd_hda_codec_read(codec, 0x18, 0, | 15029 | present = snd_hda_jack_detect(codec, 0x18); |
15071 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | ||
15072 | bits = present ? HDA_AMP_MUTE : 0; | 15030 | bits = present ? HDA_AMP_MUTE : 0; |
15031 | |||
15073 | snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, | 15032 | snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, |
15074 | HDA_AMP_MUTE, bits); | 15033 | HDA_AMP_MUTE, bits); |
15075 | } | 15034 | } |
@@ -15386,7 +15345,6 @@ static void alc861vd_auto_init_analog_input(struct hda_codec *codec) | |||
15386 | static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec, | 15345 | static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec, |
15387 | const struct auto_pin_cfg *cfg) | 15346 | const struct auto_pin_cfg *cfg) |
15388 | { | 15347 | { |
15389 | char name[32]; | ||
15390 | static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"}; | 15348 | static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"}; |
15391 | hda_nid_t nid_v, nid_s; | 15349 | hda_nid_t nid_v, nid_s; |
15392 | int i, err; | 15350 | int i, err; |
@@ -15403,26 +15361,26 @@ static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec, | |||
15403 | 15361 | ||
15404 | if (i == 2) { | 15362 | if (i == 2) { |
15405 | /* Center/LFE */ | 15363 | /* Center/LFE */ |
15406 | err = add_control(spec, ALC_CTL_WIDGET_VOL, | 15364 | err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, |
15407 | "Center Playback Volume", | 15365 | "Center", |
15408 | HDA_COMPOSE_AMP_VAL(nid_v, 1, 0, | 15366 | HDA_COMPOSE_AMP_VAL(nid_v, 1, 0, |
15409 | HDA_OUTPUT)); | 15367 | HDA_OUTPUT)); |
15410 | if (err < 0) | 15368 | if (err < 0) |
15411 | return err; | 15369 | return err; |
15412 | err = add_control(spec, ALC_CTL_WIDGET_VOL, | 15370 | err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, |
15413 | "LFE Playback Volume", | 15371 | "LFE", |
15414 | HDA_COMPOSE_AMP_VAL(nid_v, 2, 0, | 15372 | HDA_COMPOSE_AMP_VAL(nid_v, 2, 0, |
15415 | HDA_OUTPUT)); | 15373 | HDA_OUTPUT)); |
15416 | if (err < 0) | 15374 | if (err < 0) |
15417 | return err; | 15375 | return err; |
15418 | err = add_control(spec, ALC_CTL_BIND_MUTE, | 15376 | err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, |
15419 | "Center Playback Switch", | 15377 | "Center", |
15420 | HDA_COMPOSE_AMP_VAL(nid_s, 1, 2, | 15378 | HDA_COMPOSE_AMP_VAL(nid_s, 1, 2, |
15421 | HDA_INPUT)); | 15379 | HDA_INPUT)); |
15422 | if (err < 0) | 15380 | if (err < 0) |
15423 | return err; | 15381 | return err; |
15424 | err = add_control(spec, ALC_CTL_BIND_MUTE, | 15382 | err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, |
15425 | "LFE Playback Switch", | 15383 | "LFE", |
15426 | HDA_COMPOSE_AMP_VAL(nid_s, 2, 2, | 15384 | HDA_COMPOSE_AMP_VAL(nid_s, 2, 2, |
15427 | HDA_INPUT)); | 15385 | HDA_INPUT)); |
15428 | if (err < 0) | 15386 | if (err < 0) |
@@ -15437,8 +15395,7 @@ static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec, | |||
15437 | pfx = "PCM"; | 15395 | pfx = "PCM"; |
15438 | } else | 15396 | } else |
15439 | pfx = chname[i]; | 15397 | pfx = chname[i]; |
15440 | sprintf(name, "%s Playback Volume", pfx); | 15398 | err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, |
15441 | err = add_control(spec, ALC_CTL_WIDGET_VOL, name, | ||
15442 | HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, | 15399 | HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, |
15443 | HDA_OUTPUT)); | 15400 | HDA_OUTPUT)); |
15444 | if (err < 0) | 15401 | if (err < 0) |
@@ -15446,8 +15403,7 @@ static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec, | |||
15446 | if (cfg->line_outs == 1 && | 15403 | if (cfg->line_outs == 1 && |
15447 | cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) | 15404 | cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) |
15448 | pfx = "Speaker"; | 15405 | pfx = "Speaker"; |
15449 | sprintf(name, "%s Playback Switch", pfx); | 15406 | err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx, |
15450 | err = add_control(spec, ALC_CTL_BIND_MUTE, name, | ||
15451 | HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, | 15407 | HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, |
15452 | HDA_INPUT)); | 15408 | HDA_INPUT)); |
15453 | if (err < 0) | 15409 | if (err < 0) |
@@ -15465,7 +15421,6 @@ static int alc861vd_auto_create_extra_out(struct alc_spec *spec, | |||
15465 | { | 15421 | { |
15466 | hda_nid_t nid_v, nid_s; | 15422 | hda_nid_t nid_v, nid_s; |
15467 | int err; | 15423 | int err; |
15468 | char name[32]; | ||
15469 | 15424 | ||
15470 | if (!pin) | 15425 | if (!pin) |
15471 | return 0; | 15426 | return 0; |
@@ -15483,21 +15438,18 @@ static int alc861vd_auto_create_extra_out(struct alc_spec *spec, | |||
15483 | nid_s = alc861vd_idx_to_mixer_switch( | 15438 | nid_s = alc861vd_idx_to_mixer_switch( |
15484 | alc880_fixed_pin_idx(pin)); | 15439 | alc880_fixed_pin_idx(pin)); |
15485 | 15440 | ||
15486 | sprintf(name, "%s Playback Volume", pfx); | 15441 | err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, |
15487 | err = add_control(spec, ALC_CTL_WIDGET_VOL, name, | ||
15488 | HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT)); | 15442 | HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT)); |
15489 | if (err < 0) | 15443 | if (err < 0) |
15490 | return err; | 15444 | return err; |
15491 | sprintf(name, "%s Playback Switch", pfx); | 15445 | err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx, |
15492 | err = add_control(spec, ALC_CTL_BIND_MUTE, name, | ||
15493 | HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT)); | 15446 | HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT)); |
15494 | if (err < 0) | 15447 | if (err < 0) |
15495 | return err; | 15448 | return err; |
15496 | } else if (alc880_is_multi_pin(pin)) { | 15449 | } else if (alc880_is_multi_pin(pin)) { |
15497 | /* set manual connection */ | 15450 | /* set manual connection */ |
15498 | /* we have only a switch on HP-out PIN */ | 15451 | /* we have only a switch on HP-out PIN */ |
15499 | sprintf(name, "%s Playback Switch", pfx); | 15452 | err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, |
15500 | err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, | ||
15501 | HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); | 15453 | HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); |
15502 | if (err < 0) | 15454 | if (err < 0) |
15503 | return err; | 15455 | return err; |
@@ -16387,9 +16339,9 @@ static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec) | |||
16387 | unsigned int present; | 16339 | unsigned int present; |
16388 | unsigned char bits; | 16340 | unsigned char bits; |
16389 | 16341 | ||
16390 | present = snd_hda_codec_read(codec, 0x14, 0, | 16342 | present = snd_hda_jack_detect(codec, 0x14); |
16391 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | ||
16392 | bits = present ? HDA_AMP_MUTE : 0; | 16343 | bits = present ? HDA_AMP_MUTE : 0; |
16344 | |||
16393 | snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, | 16345 | snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, |
16394 | HDA_AMP_MUTE, bits); | 16346 | HDA_AMP_MUTE, bits); |
16395 | } | 16347 | } |
@@ -16399,9 +16351,9 @@ static void alc662_lenovo_101e_all_automute(struct hda_codec *codec) | |||
16399 | unsigned int present; | 16351 | unsigned int present; |
16400 | unsigned char bits; | 16352 | unsigned char bits; |
16401 | 16353 | ||
16402 | present = snd_hda_codec_read(codec, 0x1b, 0, | 16354 | present = snd_hda_jack_detect(codec, 0x1b); |
16403 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | ||
16404 | bits = present ? HDA_AMP_MUTE : 0; | 16355 | bits = present ? HDA_AMP_MUTE : 0; |
16356 | |||
16405 | snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, | 16357 | snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, |
16406 | HDA_AMP_MUTE, bits); | 16358 | HDA_AMP_MUTE, bits); |
16407 | snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, | 16359 | snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, |
@@ -16460,9 +16412,7 @@ static void alc663_m51va_speaker_automute(struct hda_codec *codec) | |||
16460 | unsigned int present; | 16412 | unsigned int present; |
16461 | unsigned char bits; | 16413 | unsigned char bits; |
16462 | 16414 | ||
16463 | present = snd_hda_codec_read(codec, 0x21, 0, | 16415 | present = snd_hda_jack_detect(codec, 0x21); |
16464 | AC_VERB_GET_PIN_SENSE, 0) | ||
16465 | & AC_PINSENSE_PRESENCE; | ||
16466 | bits = present ? HDA_AMP_MUTE : 0; | 16416 | bits = present ? HDA_AMP_MUTE : 0; |
16467 | snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, | 16417 | snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, |
16468 | AMP_IN_MUTE(0), bits); | 16418 | AMP_IN_MUTE(0), bits); |
@@ -16475,9 +16425,7 @@ static void alc663_21jd_two_speaker_automute(struct hda_codec *codec) | |||
16475 | unsigned int present; | 16425 | unsigned int present; |
16476 | unsigned char bits; | 16426 | unsigned char bits; |
16477 | 16427 | ||
16478 | present = snd_hda_codec_read(codec, 0x21, 0, | 16428 | present = snd_hda_jack_detect(codec, 0x21); |
16479 | AC_VERB_GET_PIN_SENSE, 0) | ||
16480 | & AC_PINSENSE_PRESENCE; | ||
16481 | bits = present ? HDA_AMP_MUTE : 0; | 16429 | bits = present ? HDA_AMP_MUTE : 0; |
16482 | snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, | 16430 | snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, |
16483 | AMP_IN_MUTE(0), bits); | 16431 | AMP_IN_MUTE(0), bits); |
@@ -16494,9 +16442,7 @@ static void alc663_15jd_two_speaker_automute(struct hda_codec *codec) | |||
16494 | unsigned int present; | 16442 | unsigned int present; |
16495 | unsigned char bits; | 16443 | unsigned char bits; |
16496 | 16444 | ||
16497 | present = snd_hda_codec_read(codec, 0x15, 0, | 16445 | present = snd_hda_jack_detect(codec, 0x15); |
16498 | AC_VERB_GET_PIN_SENSE, 0) | ||
16499 | & AC_PINSENSE_PRESENCE; | ||
16500 | bits = present ? HDA_AMP_MUTE : 0; | 16446 | bits = present ? HDA_AMP_MUTE : 0; |
16501 | snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, | 16447 | snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, |
16502 | AMP_IN_MUTE(0), bits); | 16448 | AMP_IN_MUTE(0), bits); |
@@ -16513,9 +16459,7 @@ static void alc662_f5z_speaker_automute(struct hda_codec *codec) | |||
16513 | unsigned int present; | 16459 | unsigned int present; |
16514 | unsigned char bits; | 16460 | unsigned char bits; |
16515 | 16461 | ||
16516 | present = snd_hda_codec_read(codec, 0x1b, 0, | 16462 | present = snd_hda_jack_detect(codec, 0x1b); |
16517 | AC_VERB_GET_PIN_SENSE, 0) | ||
16518 | & AC_PINSENSE_PRESENCE; | ||
16519 | bits = present ? 0 : PIN_OUT; | 16463 | bits = present ? 0 : PIN_OUT; |
16520 | snd_hda_codec_write(codec, 0x14, 0, | 16464 | snd_hda_codec_write(codec, 0x14, 0, |
16521 | AC_VERB_SET_PIN_WIDGET_CONTROL, bits); | 16465 | AC_VERB_SET_PIN_WIDGET_CONTROL, bits); |
@@ -16525,12 +16469,8 @@ static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec) | |||
16525 | { | 16469 | { |
16526 | unsigned int present1, present2; | 16470 | unsigned int present1, present2; |
16527 | 16471 | ||
16528 | present1 = snd_hda_codec_read(codec, 0x21, 0, | 16472 | present1 = snd_hda_jack_detect(codec, 0x21); |
16529 | AC_VERB_GET_PIN_SENSE, 0) | 16473 | present2 = snd_hda_jack_detect(codec, 0x15); |
16530 | & AC_PINSENSE_PRESENCE; | ||
16531 | present2 = snd_hda_codec_read(codec, 0x15, 0, | ||
16532 | AC_VERB_GET_PIN_SENSE, 0) | ||
16533 | & AC_PINSENSE_PRESENCE; | ||
16534 | 16474 | ||
16535 | if (present1 || present2) { | 16475 | if (present1 || present2) { |
16536 | snd_hda_codec_write_cache(codec, 0x14, 0, | 16476 | snd_hda_codec_write_cache(codec, 0x14, 0, |
@@ -16545,12 +16485,8 @@ static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec) | |||
16545 | { | 16485 | { |
16546 | unsigned int present1, present2; | 16486 | unsigned int present1, present2; |
16547 | 16487 | ||
16548 | present1 = snd_hda_codec_read(codec, 0x1b, 0, | 16488 | present1 = snd_hda_jack_detect(codec, 0x1b); |
16549 | AC_VERB_GET_PIN_SENSE, 0) | 16489 | present2 = snd_hda_jack_detect(codec, 0x15); |
16550 | & AC_PINSENSE_PRESENCE; | ||
16551 | present2 = snd_hda_codec_read(codec, 0x15, 0, | ||
16552 | AC_VERB_GET_PIN_SENSE, 0) | ||
16553 | & AC_PINSENSE_PRESENCE; | ||
16554 | 16490 | ||
16555 | if (present1 || present2) { | 16491 | if (present1 || present2) { |
16556 | snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, | 16492 | snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, |
@@ -16710,9 +16646,7 @@ static void alc663_g71v_hp_automute(struct hda_codec *codec) | |||
16710 | unsigned int present; | 16646 | unsigned int present; |
16711 | unsigned char bits; | 16647 | unsigned char bits; |
16712 | 16648 | ||
16713 | present = snd_hda_codec_read(codec, 0x21, 0, | 16649 | present = snd_hda_jack_detect(codec, 0x21); |
16714 | AC_VERB_GET_PIN_SENSE, 0) | ||
16715 | & AC_PINSENSE_PRESENCE; | ||
16716 | bits = present ? HDA_AMP_MUTE : 0; | 16650 | bits = present ? HDA_AMP_MUTE : 0; |
16717 | snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, | 16651 | snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, |
16718 | HDA_AMP_MUTE, bits); | 16652 | HDA_AMP_MUTE, bits); |
@@ -16725,9 +16659,7 @@ static void alc663_g71v_front_automute(struct hda_codec *codec) | |||
16725 | unsigned int present; | 16659 | unsigned int present; |
16726 | unsigned char bits; | 16660 | unsigned char bits; |
16727 | 16661 | ||
16728 | present = snd_hda_codec_read(codec, 0x15, 0, | 16662 | present = snd_hda_jack_detect(codec, 0x15); |
16729 | AC_VERB_GET_PIN_SENSE, 0) | ||
16730 | & AC_PINSENSE_PRESENCE; | ||
16731 | bits = present ? HDA_AMP_MUTE : 0; | 16663 | bits = present ? HDA_AMP_MUTE : 0; |
16732 | snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, | 16664 | snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, |
16733 | HDA_AMP_MUTE, bits); | 16665 | HDA_AMP_MUTE, bits); |
@@ -17264,21 +17196,17 @@ static int alc662_auto_fill_dac_nids(struct hda_codec *codec, | |||
17264 | return 0; | 17196 | return 0; |
17265 | } | 17197 | } |
17266 | 17198 | ||
17267 | static int alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx, | 17199 | static inline int alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx, |
17268 | hda_nid_t nid, unsigned int chs) | 17200 | hda_nid_t nid, unsigned int chs) |
17269 | { | 17201 | { |
17270 | char name[32]; | 17202 | return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, |
17271 | sprintf(name, "%s Playback Volume", pfx); | ||
17272 | return add_control(spec, ALC_CTL_WIDGET_VOL, name, | ||
17273 | HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT)); | 17203 | HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT)); |
17274 | } | 17204 | } |
17275 | 17205 | ||
17276 | static int alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx, | 17206 | static inline int alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx, |
17277 | hda_nid_t nid, unsigned int chs) | 17207 | hda_nid_t nid, unsigned int chs) |
17278 | { | 17208 | { |
17279 | char name[32]; | 17209 | return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, |
17280 | sprintf(name, "%s Playback Switch", pfx); | ||
17281 | return add_control(spec, ALC_CTL_WIDGET_MUTE, name, | ||
17282 | HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT)); | 17210 | HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT)); |
17283 | } | 17211 | } |
17284 | 17212 | ||
@@ -17356,13 +17284,11 @@ static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin, | |||
17356 | return 0; | 17284 | return 0; |
17357 | nid = alc662_look_for_dac(codec, pin); | 17285 | nid = alc662_look_for_dac(codec, pin); |
17358 | if (!nid) { | 17286 | if (!nid) { |
17359 | char name[32]; | ||
17360 | /* the corresponding DAC is already occupied */ | 17287 | /* the corresponding DAC is already occupied */ |
17361 | if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP)) | 17288 | if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP)) |
17362 | return 0; /* no way */ | 17289 | return 0; /* no way */ |
17363 | /* create a switch only */ | 17290 | /* create a switch only */ |
17364 | sprintf(name, "%s Playback Switch", pfx); | 17291 | return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, |
17365 | return add_control(spec, ALC_CTL_WIDGET_MUTE, name, | ||
17366 | HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); | 17292 | HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); |
17367 | } | 17293 | } |
17368 | 17294 | ||
@@ -17538,6 +17464,15 @@ static int patch_alc662(struct hda_codec *codec) | |||
17538 | 17464 | ||
17539 | alc_fix_pll_init(codec, 0x20, 0x04, 15); | 17465 | alc_fix_pll_init(codec, 0x20, 0x04, 15); |
17540 | 17466 | ||
17467 | if (alc_read_coef_idx(codec, 0)==0x8020){ | ||
17468 | kfree(codec->chip_name); | ||
17469 | codec->chip_name = kstrdup("ALC661", GFP_KERNEL); | ||
17470 | if (!codec->chip_name) { | ||
17471 | alc_free(codec); | ||
17472 | return -ENOMEM; | ||
17473 | } | ||
17474 | } | ||
17475 | |||
17541 | board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST, | 17476 | board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST, |
17542 | alc662_models, | 17477 | alc662_models, |
17543 | alc662_cfg_tbl); | 17478 | alc662_cfg_tbl); |
@@ -17604,6 +17539,20 @@ static int patch_alc662(struct hda_codec *codec) | |||
17604 | return 0; | 17539 | return 0; |
17605 | } | 17540 | } |
17606 | 17541 | ||
17542 | static int patch_alc888(struct hda_codec *codec) | ||
17543 | { | ||
17544 | if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){ | ||
17545 | kfree(codec->chip_name); | ||
17546 | codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL); | ||
17547 | if (!codec->chip_name) { | ||
17548 | alc_free(codec); | ||
17549 | return -ENOMEM; | ||
17550 | } | ||
17551 | return patch_alc662(codec); | ||
17552 | } | ||
17553 | return patch_alc882(codec); | ||
17554 | } | ||
17555 | |||
17607 | /* | 17556 | /* |
17608 | * patch entries | 17557 | * patch entries |
17609 | */ | 17558 | */ |
@@ -17635,8 +17584,9 @@ static struct hda_codec_preset snd_hda_preset_realtek[] = { | |||
17635 | { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 }, | 17584 | { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 }, |
17636 | { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200", | 17585 | { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200", |
17637 | .patch = patch_alc882 }, | 17586 | .patch = patch_alc882 }, |
17638 | { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc882 }, | 17587 | { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 }, |
17639 | { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 }, | 17588 | { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 }, |
17589 | { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 }, | ||
17640 | {} /* terminator */ | 17590 | {} /* terminator */ |
17641 | }; | 17591 | }; |
17642 | 17592 | ||
diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c index ec25262e59e7..6b0bc040c3b1 100644 --- a/sound/pci/hda/patch_sigmatel.c +++ b/sound/pci/hda/patch_sigmatel.c | |||
@@ -93,6 +93,7 @@ enum { | |||
93 | STAC_92HD83XXX_REF, | 93 | STAC_92HD83XXX_REF, |
94 | STAC_92HD83XXX_PWR_REF, | 94 | STAC_92HD83XXX_PWR_REF, |
95 | STAC_DELL_S14, | 95 | STAC_DELL_S14, |
96 | STAC_92HD83XXX_HP, | ||
96 | STAC_92HD83XXX_MODELS | 97 | STAC_92HD83XXX_MODELS |
97 | }; | 98 | }; |
98 | 99 | ||
@@ -1085,7 +1086,7 @@ static int stac92xx_build_controls(struct hda_codec *codec) | |||
1085 | if (!spec->auto_mic && spec->num_dmuxes > 0 && | 1086 | if (!spec->auto_mic && spec->num_dmuxes > 0 && |
1086 | snd_hda_get_bool_hint(codec, "separate_dmux") == 1) { | 1087 | snd_hda_get_bool_hint(codec, "separate_dmux") == 1) { |
1087 | stac_dmux_mixer.count = spec->num_dmuxes; | 1088 | stac_dmux_mixer.count = spec->num_dmuxes; |
1088 | err = snd_hda_ctl_add(codec, | 1089 | err = snd_hda_ctl_add(codec, 0, |
1089 | snd_ctl_new1(&stac_dmux_mixer, codec)); | 1090 | snd_ctl_new1(&stac_dmux_mixer, codec)); |
1090 | if (err < 0) | 1091 | if (err < 0) |
1091 | return err; | 1092 | return err; |
@@ -1101,7 +1102,7 @@ static int stac92xx_build_controls(struct hda_codec *codec) | |||
1101 | spec->spdif_mute = 1; | 1102 | spec->spdif_mute = 1; |
1102 | } | 1103 | } |
1103 | stac_smux_mixer.count = spec->num_smuxes; | 1104 | stac_smux_mixer.count = spec->num_smuxes; |
1104 | err = snd_hda_ctl_add(codec, | 1105 | err = snd_hda_ctl_add(codec, 0, |
1105 | snd_ctl_new1(&stac_smux_mixer, codec)); | 1106 | snd_ctl_new1(&stac_smux_mixer, codec)); |
1106 | if (err < 0) | 1107 | if (err < 0) |
1107 | return err; | 1108 | return err; |
@@ -1624,6 +1625,7 @@ static const char *stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = { | |||
1624 | [STAC_92HD83XXX_REF] = "ref", | 1625 | [STAC_92HD83XXX_REF] = "ref", |
1625 | [STAC_92HD83XXX_PWR_REF] = "mic-ref", | 1626 | [STAC_92HD83XXX_PWR_REF] = "mic-ref", |
1626 | [STAC_DELL_S14] = "dell-s14", | 1627 | [STAC_DELL_S14] = "dell-s14", |
1628 | [STAC_92HD83XXX_HP] = "hp", | ||
1627 | }; | 1629 | }; |
1628 | 1630 | ||
1629 | static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = { | 1631 | static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = { |
@@ -1634,6 +1636,8 @@ static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = { | |||
1634 | "DFI LanParty", STAC_92HD83XXX_REF), | 1636 | "DFI LanParty", STAC_92HD83XXX_REF), |
1635 | SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ba, | 1637 | SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ba, |
1636 | "unknown Dell", STAC_DELL_S14), | 1638 | "unknown Dell", STAC_DELL_S14), |
1639 | SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xff00, 0x3600, | ||
1640 | "HP", STAC_92HD83XXX_HP), | ||
1637 | {} /* terminator */ | 1641 | {} /* terminator */ |
1638 | }; | 1642 | }; |
1639 | 1643 | ||
@@ -2648,6 +2652,7 @@ static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol, | |||
2648 | enum { | 2652 | enum { |
2649 | STAC_CTL_WIDGET_VOL, | 2653 | STAC_CTL_WIDGET_VOL, |
2650 | STAC_CTL_WIDGET_MUTE, | 2654 | STAC_CTL_WIDGET_MUTE, |
2655 | STAC_CTL_WIDGET_MUTE_BEEP, | ||
2651 | STAC_CTL_WIDGET_MONO_MUX, | 2656 | STAC_CTL_WIDGET_MONO_MUX, |
2652 | STAC_CTL_WIDGET_HP_SWITCH, | 2657 | STAC_CTL_WIDGET_HP_SWITCH, |
2653 | STAC_CTL_WIDGET_IO_SWITCH, | 2658 | STAC_CTL_WIDGET_IO_SWITCH, |
@@ -2658,6 +2663,7 @@ enum { | |||
2658 | static struct snd_kcontrol_new stac92xx_control_templates[] = { | 2663 | static struct snd_kcontrol_new stac92xx_control_templates[] = { |
2659 | HDA_CODEC_VOLUME(NULL, 0, 0, 0), | 2664 | HDA_CODEC_VOLUME(NULL, 0, 0, 0), |
2660 | HDA_CODEC_MUTE(NULL, 0, 0, 0), | 2665 | HDA_CODEC_MUTE(NULL, 0, 0, 0), |
2666 | HDA_CODEC_MUTE_BEEP(NULL, 0, 0, 0), | ||
2661 | STAC_MONO_MUX, | 2667 | STAC_MONO_MUX, |
2662 | STAC_CODEC_HP_SWITCH(NULL), | 2668 | STAC_CODEC_HP_SWITCH(NULL), |
2663 | STAC_CODEC_IO_SWITCH(NULL, 0), | 2669 | STAC_CODEC_IO_SWITCH(NULL, 0), |
@@ -2669,7 +2675,8 @@ static struct snd_kcontrol_new stac92xx_control_templates[] = { | |||
2669 | static struct snd_kcontrol_new * | 2675 | static struct snd_kcontrol_new * |
2670 | stac_control_new(struct sigmatel_spec *spec, | 2676 | stac_control_new(struct sigmatel_spec *spec, |
2671 | struct snd_kcontrol_new *ktemp, | 2677 | struct snd_kcontrol_new *ktemp, |
2672 | const char *name) | 2678 | const char *name, |
2679 | hda_nid_t nid) | ||
2673 | { | 2680 | { |
2674 | struct snd_kcontrol_new *knew; | 2681 | struct snd_kcontrol_new *knew; |
2675 | 2682 | ||
@@ -2685,6 +2692,8 @@ stac_control_new(struct sigmatel_spec *spec, | |||
2685 | spec->kctls.alloced--; | 2692 | spec->kctls.alloced--; |
2686 | return NULL; | 2693 | return NULL; |
2687 | } | 2694 | } |
2695 | if (nid) | ||
2696 | knew->subdevice = HDA_SUBDEV_NID_FLAG | nid; | ||
2688 | return knew; | 2697 | return knew; |
2689 | } | 2698 | } |
2690 | 2699 | ||
@@ -2693,7 +2702,8 @@ static int stac92xx_add_control_temp(struct sigmatel_spec *spec, | |||
2693 | int idx, const char *name, | 2702 | int idx, const char *name, |
2694 | unsigned long val) | 2703 | unsigned long val) |
2695 | { | 2704 | { |
2696 | struct snd_kcontrol_new *knew = stac_control_new(spec, ktemp, name); | 2705 | struct snd_kcontrol_new *knew = stac_control_new(spec, ktemp, name, |
2706 | get_amp_nid_(val)); | ||
2697 | if (!knew) | 2707 | if (!knew) |
2698 | return -ENOMEM; | 2708 | return -ENOMEM; |
2699 | knew->index = idx; | 2709 | knew->index = idx; |
@@ -2764,7 +2774,7 @@ static int stac92xx_add_input_source(struct sigmatel_spec *spec) | |||
2764 | if (!spec->num_adcs || imux->num_items <= 1) | 2774 | if (!spec->num_adcs || imux->num_items <= 1) |
2765 | return 0; /* no need for input source control */ | 2775 | return 0; /* no need for input source control */ |
2766 | knew = stac_control_new(spec, &stac_input_src_temp, | 2776 | knew = stac_control_new(spec, &stac_input_src_temp, |
2767 | stac_input_src_temp.name); | 2777 | stac_input_src_temp.name, 0); |
2768 | if (!knew) | 2778 | if (!knew) |
2769 | return -ENOMEM; | 2779 | return -ENOMEM; |
2770 | knew->count = spec->num_adcs; | 2780 | knew->count = spec->num_adcs; |
@@ -3221,11 +3231,14 @@ static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec, | |||
3221 | { | 3231 | { |
3222 | struct sigmatel_spec *spec = codec->spec; | 3232 | struct sigmatel_spec *spec = codec->spec; |
3223 | u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT); | 3233 | u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT); |
3224 | int err; | 3234 | int err, type = STAC_CTL_WIDGET_MUTE_BEEP; |
3235 | |||
3236 | if (spec->anabeep_nid == nid) | ||
3237 | type = STAC_CTL_WIDGET_MUTE; | ||
3225 | 3238 | ||
3226 | /* check for mute support for the the amp */ | 3239 | /* check for mute support for the the amp */ |
3227 | if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) { | 3240 | if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) { |
3228 | err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, | 3241 | err = stac92xx_add_control(spec, type, |
3229 | "Beep Playback Switch", | 3242 | "Beep Playback Switch", |
3230 | HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT)); | 3243 | HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT)); |
3231 | if (err < 0) | 3244 | if (err < 0) |
@@ -3258,12 +3271,7 @@ static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol, | |||
3258 | struct snd_ctl_elem_value *ucontrol) | 3271 | struct snd_ctl_elem_value *ucontrol) |
3259 | { | 3272 | { |
3260 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | 3273 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); |
3261 | int enabled = !!ucontrol->value.integer.value[0]; | 3274 | return snd_hda_enable_beep_device(codec, ucontrol->value.integer.value[0]); |
3262 | if (codec->beep->enabled != enabled) { | ||
3263 | codec->beep->enabled = enabled; | ||
3264 | return 1; | ||
3265 | } | ||
3266 | return 0; | ||
3267 | } | 3275 | } |
3268 | 3276 | ||
3269 | static struct snd_kcontrol_new stac92xx_dig_beep_ctrl = { | 3277 | static struct snd_kcontrol_new stac92xx_dig_beep_ctrl = { |
@@ -3631,6 +3639,26 @@ static void stac92xx_auto_init_hp_out(struct hda_codec *codec) | |||
3631 | } | 3639 | } |
3632 | } | 3640 | } |
3633 | 3641 | ||
3642 | static int is_dual_headphones(struct hda_codec *codec) | ||
3643 | { | ||
3644 | struct sigmatel_spec *spec = codec->spec; | ||
3645 | int i, valid_hps; | ||
3646 | |||
3647 | if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT || | ||
3648 | spec->autocfg.hp_outs <= 1) | ||
3649 | return 0; | ||
3650 | valid_hps = 0; | ||
3651 | for (i = 0; i < spec->autocfg.hp_outs; i++) { | ||
3652 | hda_nid_t nid = spec->autocfg.hp_pins[i]; | ||
3653 | unsigned int cfg = snd_hda_codec_get_pincfg(codec, nid); | ||
3654 | if (get_defcfg_location(cfg) & AC_JACK_LOC_SEPARATE) | ||
3655 | continue; | ||
3656 | valid_hps++; | ||
3657 | } | ||
3658 | return (valid_hps > 1); | ||
3659 | } | ||
3660 | |||
3661 | |||
3634 | static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in) | 3662 | static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in) |
3635 | { | 3663 | { |
3636 | struct sigmatel_spec *spec = codec->spec; | 3664 | struct sigmatel_spec *spec = codec->spec; |
@@ -3647,8 +3675,7 @@ static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out | |||
3647 | /* If we have no real line-out pin and multiple hp-outs, HPs should | 3675 | /* If we have no real line-out pin and multiple hp-outs, HPs should |
3648 | * be set up as multi-channel outputs. | 3676 | * be set up as multi-channel outputs. |
3649 | */ | 3677 | */ |
3650 | if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT && | 3678 | if (is_dual_headphones(codec)) { |
3651 | spec->autocfg.hp_outs > 1) { | ||
3652 | /* Copy hp_outs to line_outs, backup line_outs in | 3679 | /* Copy hp_outs to line_outs, backup line_outs in |
3653 | * speaker_outs so that the following routines can handle | 3680 | * speaker_outs so that the following routines can handle |
3654 | * HP pins as primary outputs. | 3681 | * HP pins as primary outputs. |
@@ -4329,6 +4356,28 @@ static void stac92xx_free_kctls(struct hda_codec *codec) | |||
4329 | snd_array_free(&spec->kctls); | 4356 | snd_array_free(&spec->kctls); |
4330 | } | 4357 | } |
4331 | 4358 | ||
4359 | static void stac92xx_shutup(struct hda_codec *codec) | ||
4360 | { | ||
4361 | struct sigmatel_spec *spec = codec->spec; | ||
4362 | int i; | ||
4363 | hda_nid_t nid; | ||
4364 | |||
4365 | /* reset each pin before powering down DAC/ADC to avoid click noise */ | ||
4366 | nid = codec->start_nid; | ||
4367 | for (i = 0; i < codec->num_nodes; i++, nid++) { | ||
4368 | unsigned int wcaps = get_wcaps(codec, nid); | ||
4369 | unsigned int wid_type = get_wcaps_type(wcaps); | ||
4370 | if (wid_type == AC_WID_PIN) | ||
4371 | snd_hda_codec_read(codec, nid, 0, | ||
4372 | AC_VERB_SET_PIN_WIDGET_CONTROL, 0); | ||
4373 | } | ||
4374 | |||
4375 | if (spec->eapd_mask) | ||
4376 | stac_gpio_set(codec, spec->gpio_mask, | ||
4377 | spec->gpio_dir, spec->gpio_data & | ||
4378 | ~spec->eapd_mask); | ||
4379 | } | ||
4380 | |||
4332 | static void stac92xx_free(struct hda_codec *codec) | 4381 | static void stac92xx_free(struct hda_codec *codec) |
4333 | { | 4382 | { |
4334 | struct sigmatel_spec *spec = codec->spec; | 4383 | struct sigmatel_spec *spec = codec->spec; |
@@ -4336,6 +4385,7 @@ static void stac92xx_free(struct hda_codec *codec) | |||
4336 | if (! spec) | 4385 | if (! spec) |
4337 | return; | 4386 | return; |
4338 | 4387 | ||
4388 | stac92xx_shutup(codec); | ||
4339 | stac92xx_free_jacks(codec); | 4389 | stac92xx_free_jacks(codec); |
4340 | snd_array_free(&spec->events); | 4390 | snd_array_free(&spec->events); |
4341 | 4391 | ||
@@ -4386,12 +4436,16 @@ static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid, | |||
4386 | pin_ctl & ~flag); | 4436 | pin_ctl & ~flag); |
4387 | } | 4437 | } |
4388 | 4438 | ||
4389 | static int get_pin_presence(struct hda_codec *codec, hda_nid_t nid) | 4439 | static inline int get_pin_presence(struct hda_codec *codec, hda_nid_t nid) |
4390 | { | 4440 | { |
4391 | if (!nid) | 4441 | if (!nid) |
4392 | return 0; | 4442 | return 0; |
4393 | if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00) | 4443 | /* NOTE: we can't use snd_hda_jack_detect() here because STAC/IDT |
4394 | & (1 << 31)) | 4444 | * codecs behave wrongly when SET_PIN_SENSE is triggered, although |
4445 | * the pincap gives TRIG_REQ bit. | ||
4446 | */ | ||
4447 | if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0) & | ||
4448 | AC_PINSENSE_PRESENCE) | ||
4395 | return 1; | 4449 | return 1; |
4396 | return 0; | 4450 | return 0; |
4397 | } | 4451 | } |
@@ -4791,28 +4845,28 @@ static int stac92xx_hp_check_power_status(struct hda_codec *codec, | |||
4791 | 4845 | ||
4792 | return 0; | 4846 | return 0; |
4793 | } | 4847 | } |
4794 | #endif | ||
4795 | 4848 | ||
4796 | static int stac92xx_suspend(struct hda_codec *codec, pm_message_t state) | 4849 | static int idt92hd83xxx_hp_check_power_status(struct hda_codec *codec, |
4850 | hda_nid_t nid) | ||
4797 | { | 4851 | { |
4798 | struct sigmatel_spec *spec = codec->spec; | 4852 | struct sigmatel_spec *spec = codec->spec; |
4799 | int i; | ||
4800 | hda_nid_t nid; | ||
4801 | 4853 | ||
4802 | /* reset each pin before powering down DAC/ADC to avoid click noise */ | 4854 | if (nid != 0x13) |
4803 | nid = codec->start_nid; | 4855 | return 0; |
4804 | for (i = 0; i < codec->num_nodes; i++, nid++) { | 4856 | if (snd_hda_codec_amp_read(codec, nid, 0, HDA_OUTPUT, 0) & HDA_AMP_MUTE) |
4805 | unsigned int wcaps = get_wcaps(codec, nid); | 4857 | spec->gpio_data |= spec->gpio_led; /* mute LED on */ |
4806 | unsigned int wid_type = get_wcaps_type(wcaps); | 4858 | else |
4807 | if (wid_type == AC_WID_PIN) | 4859 | spec->gpio_data &= ~spec->gpio_led; /* mute LED off */ |
4808 | snd_hda_codec_read(codec, nid, 0, | 4860 | stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, spec->gpio_data); |
4809 | AC_VERB_SET_PIN_WIDGET_CONTROL, 0); | ||
4810 | } | ||
4811 | 4861 | ||
4812 | if (spec->eapd_mask) | 4862 | return 0; |
4813 | stac_gpio_set(codec, spec->gpio_mask, | 4863 | } |
4814 | spec->gpio_dir, spec->gpio_data & | 4864 | |
4815 | ~spec->eapd_mask); | 4865 | #endif |
4866 | |||
4867 | static int stac92xx_suspend(struct hda_codec *codec, pm_message_t state) | ||
4868 | { | ||
4869 | stac92xx_shutup(codec); | ||
4816 | return 0; | 4870 | return 0; |
4817 | } | 4871 | } |
4818 | #endif | 4872 | #endif |
@@ -4827,6 +4881,7 @@ static struct hda_codec_ops stac92xx_patch_ops = { | |||
4827 | .suspend = stac92xx_suspend, | 4881 | .suspend = stac92xx_suspend, |
4828 | .resume = stac92xx_resume, | 4882 | .resume = stac92xx_resume, |
4829 | #endif | 4883 | #endif |
4884 | .reboot_notify = stac92xx_shutup, | ||
4830 | }; | 4885 | }; |
4831 | 4886 | ||
4832 | static int patch_stac9200(struct hda_codec *codec) | 4887 | static int patch_stac9200(struct hda_codec *codec) |
@@ -5172,6 +5227,22 @@ again: | |||
5172 | break; | 5227 | break; |
5173 | } | 5228 | } |
5174 | 5229 | ||
5230 | codec->patch_ops = stac92xx_patch_ops; | ||
5231 | |||
5232 | if (spec->board_config == STAC_92HD83XXX_HP) | ||
5233 | spec->gpio_led = 0x01; | ||
5234 | |||
5235 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
5236 | if (spec->gpio_led) { | ||
5237 | spec->gpio_mask |= spec->gpio_led; | ||
5238 | spec->gpio_dir |= spec->gpio_led; | ||
5239 | spec->gpio_data |= spec->gpio_led; | ||
5240 | /* register check_power_status callback. */ | ||
5241 | codec->patch_ops.check_power_status = | ||
5242 | idt92hd83xxx_hp_check_power_status; | ||
5243 | } | ||
5244 | #endif | ||
5245 | |||
5175 | err = stac92xx_parse_auto_config(codec, 0x1d, 0); | 5246 | err = stac92xx_parse_auto_config(codec, 0x1d, 0); |
5176 | if (!err) { | 5247 | if (!err) { |
5177 | if (spec->board_config < 0) { | 5248 | if (spec->board_config < 0) { |
@@ -5207,8 +5278,6 @@ again: | |||
5207 | snd_hda_codec_write_cache(codec, nid, 0, | 5278 | snd_hda_codec_write_cache(codec, nid, 0, |
5208 | AC_VERB_SET_CONNECT_SEL, num_dacs); | 5279 | AC_VERB_SET_CONNECT_SEL, num_dacs); |
5209 | 5280 | ||
5210 | codec->patch_ops = stac92xx_patch_ops; | ||
5211 | |||
5212 | codec->proc_widget_hook = stac92hd_proc_hook; | 5281 | codec->proc_widget_hook = stac92hd_proc_hook; |
5213 | 5282 | ||
5214 | return 0; | 5283 | return 0; |
diff --git a/sound/pci/hda/patch_via.c b/sound/pci/hda/patch_via.c index ee89db90c9b6..b70e26ad263f 100644 --- a/sound/pci/hda/patch_via.c +++ b/sound/pci/hda/patch_via.c | |||
@@ -1,10 +1,10 @@ | |||
1 | /* | 1 | /* |
2 | * Universal Interface for Intel High Definition Audio Codec | 2 | * Universal Interface for Intel High Definition Audio Codec |
3 | * | 3 | * |
4 | * HD audio interface patch for VIA VT1702/VT1708/VT1709 codec | 4 | * HD audio interface patch for VIA VT17xx/VT18xx/VT20xx codec |
5 | * | 5 | * |
6 | * Copyright (c) 2006-2008 Lydia Wang <lydiawang@viatech.com> | 6 | * (C) 2006-2009 VIA Technology, Inc. |
7 | * Takashi Iwai <tiwai@suse.de> | 7 | * (C) 2006-2008 Takashi Iwai <tiwai@suse.de> |
8 | * | 8 | * |
9 | * This driver is free software; you can redistribute it and/or modify | 9 | * This driver is free software; you can redistribute it and/or modify |
10 | * it under the terms of the GNU General Public License as published by | 10 | * it under the terms of the GNU General Public License as published by |
@@ -22,21 +22,27 @@ | |||
22 | */ | 22 | */ |
23 | 23 | ||
24 | /* * * * * * * * * * * * * * Release History * * * * * * * * * * * * * * * * */ | 24 | /* * * * * * * * * * * * * * Release History * * * * * * * * * * * * * * * * */ |
25 | /* */ | 25 | /* */ |
26 | /* 2006-03-03 Lydia Wang Create the basic patch to support VT1708 codec */ | 26 | /* 2006-03-03 Lydia Wang Create the basic patch to support VT1708 codec */ |
27 | /* 2006-03-14 Lydia Wang Modify hard code for some pin widget nid */ | 27 | /* 2006-03-14 Lydia Wang Modify hard code for some pin widget nid */ |
28 | /* 2006-08-02 Lydia Wang Add support to VT1709 codec */ | 28 | /* 2006-08-02 Lydia Wang Add support to VT1709 codec */ |
29 | /* 2006-09-08 Lydia Wang Fix internal loopback recording source select bug */ | 29 | /* 2006-09-08 Lydia Wang Fix internal loopback recording source select bug */ |
30 | /* 2007-09-12 Lydia Wang Add EAPD enable during driver initialization */ | 30 | /* 2007-09-12 Lydia Wang Add EAPD enable during driver initialization */ |
31 | /* 2007-09-17 Lydia Wang Add VT1708B codec support */ | 31 | /* 2007-09-17 Lydia Wang Add VT1708B codec support */ |
32 | /* 2007-11-14 Lydia Wang Add VT1708A codec HP and CD pin connect config */ | 32 | /* 2007-11-14 Lydia Wang Add VT1708A codec HP and CD pin connect config */ |
33 | /* 2008-02-03 Lydia Wang Fix Rear channels and Back channels inverse issue */ | 33 | /* 2008-02-03 Lydia Wang Fix Rear channels and Back channels inverse issue */ |
34 | /* 2008-03-06 Lydia Wang Add VT1702 codec and VT1708S codec support */ | 34 | /* 2008-03-06 Lydia Wang Add VT1702 codec and VT1708S codec support */ |
35 | /* 2008-04-09 Lydia Wang Add mute front speaker when HP plugin */ | 35 | /* 2008-04-09 Lydia Wang Add mute front speaker when HP plugin */ |
36 | /* 2008-04-09 Lydia Wang Add Independent HP feature */ | 36 | /* 2008-04-09 Lydia Wang Add Independent HP feature */ |
37 | /* 2008-05-28 Lydia Wang Add second S/PDIF Out support for VT1702 */ | 37 | /* 2008-05-28 Lydia Wang Add second S/PDIF Out support for VT1702 */ |
38 | /* 2008-09-15 Logan Li Add VT1708S Mic Boost workaround/backdoor */ | 38 | /* 2008-09-15 Logan Li Add VT1708S Mic Boost workaround/backdoor */ |
39 | /* */ | 39 | /* 2009-02-16 Logan Li Add support for VT1718S */ |
40 | /* 2009-03-13 Logan Li Add support for VT1716S */ | ||
41 | /* 2009-04-14 Lydai Wang Add support for VT1828S and VT2020 */ | ||
42 | /* 2009-07-08 Lydia Wang Add support for VT2002P */ | ||
43 | /* 2009-07-21 Lydia Wang Add support for VT1812 */ | ||
44 | /* 2009-09-19 Lydia Wang Add support for VT1818S */ | ||
45 | /* */ | ||
40 | /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ | 46 | /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ |
41 | 47 | ||
42 | 48 | ||
@@ -76,14 +82,6 @@ | |||
76 | #define VT1702_HP_NID 0x17 | 82 | #define VT1702_HP_NID 0x17 |
77 | #define VT1702_DIGOUT_NID 0x11 | 83 | #define VT1702_DIGOUT_NID 0x11 |
78 | 84 | ||
79 | #define IS_VT1708_VENDORID(x) ((x) >= 0x11061708 && (x) <= 0x1106170b) | ||
80 | #define IS_VT1709_10CH_VENDORID(x) ((x) >= 0x1106e710 && (x) <= 0x1106e713) | ||
81 | #define IS_VT1709_6CH_VENDORID(x) ((x) >= 0x1106e714 && (x) <= 0x1106e717) | ||
82 | #define IS_VT1708B_8CH_VENDORID(x) ((x) >= 0x1106e720 && (x) <= 0x1106e723) | ||
83 | #define IS_VT1708B_4CH_VENDORID(x) ((x) >= 0x1106e724 && (x) <= 0x1106e727) | ||
84 | #define IS_VT1708S_VENDORID(x) ((x) >= 0x11060397 && (x) <= 0x11067397) | ||
85 | #define IS_VT1702_VENDORID(x) ((x) >= 0x11060398 && (x) <= 0x11067398) | ||
86 | |||
87 | enum VIA_HDA_CODEC { | 85 | enum VIA_HDA_CODEC { |
88 | UNKNOWN = -1, | 86 | UNKNOWN = -1, |
89 | VT1708, | 87 | VT1708, |
@@ -92,12 +90,76 @@ enum VIA_HDA_CODEC { | |||
92 | VT1708B_8CH, | 90 | VT1708B_8CH, |
93 | VT1708B_4CH, | 91 | VT1708B_4CH, |
94 | VT1708S, | 92 | VT1708S, |
93 | VT1708BCE, | ||
95 | VT1702, | 94 | VT1702, |
95 | VT1718S, | ||
96 | VT1716S, | ||
97 | VT2002P, | ||
98 | VT1812, | ||
96 | CODEC_TYPES, | 99 | CODEC_TYPES, |
97 | }; | 100 | }; |
98 | 101 | ||
99 | static enum VIA_HDA_CODEC get_codec_type(u32 vendor_id) | 102 | struct via_spec { |
103 | /* codec parameterization */ | ||
104 | struct snd_kcontrol_new *mixers[6]; | ||
105 | unsigned int num_mixers; | ||
106 | |||
107 | struct hda_verb *init_verbs[5]; | ||
108 | unsigned int num_iverbs; | ||
109 | |||
110 | char *stream_name_analog; | ||
111 | struct hda_pcm_stream *stream_analog_playback; | ||
112 | struct hda_pcm_stream *stream_analog_capture; | ||
113 | |||
114 | char *stream_name_digital; | ||
115 | struct hda_pcm_stream *stream_digital_playback; | ||
116 | struct hda_pcm_stream *stream_digital_capture; | ||
117 | |||
118 | /* playback */ | ||
119 | struct hda_multi_out multiout; | ||
120 | hda_nid_t slave_dig_outs[2]; | ||
121 | |||
122 | /* capture */ | ||
123 | unsigned int num_adc_nids; | ||
124 | hda_nid_t *adc_nids; | ||
125 | hda_nid_t mux_nids[3]; | ||
126 | hda_nid_t dig_in_nid; | ||
127 | hda_nid_t dig_in_pin; | ||
128 | |||
129 | /* capture source */ | ||
130 | const struct hda_input_mux *input_mux; | ||
131 | unsigned int cur_mux[3]; | ||
132 | |||
133 | /* PCM information */ | ||
134 | struct hda_pcm pcm_rec[3]; | ||
135 | |||
136 | /* dynamic controls, init_verbs and input_mux */ | ||
137 | struct auto_pin_cfg autocfg; | ||
138 | struct snd_array kctls; | ||
139 | struct hda_input_mux private_imux[2]; | ||
140 | hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS]; | ||
141 | |||
142 | /* HP mode source */ | ||
143 | const struct hda_input_mux *hp_mux; | ||
144 | unsigned int hp_independent_mode; | ||
145 | unsigned int hp_independent_mode_index; | ||
146 | unsigned int smart51_enabled; | ||
147 | unsigned int dmic_enabled; | ||
148 | enum VIA_HDA_CODEC codec_type; | ||
149 | |||
150 | /* work to check hp jack state */ | ||
151 | struct hda_codec *codec; | ||
152 | struct delayed_work vt1708_hp_work; | ||
153 | int vt1708_jack_detectect; | ||
154 | int vt1708_hp_present; | ||
155 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
156 | struct hda_loopback_check loopback; | ||
157 | #endif | ||
158 | }; | ||
159 | |||
160 | static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec) | ||
100 | { | 161 | { |
162 | u32 vendor_id = codec->vendor_id; | ||
101 | u16 ven_id = vendor_id >> 16; | 163 | u16 ven_id = vendor_id >> 16; |
102 | u16 dev_id = vendor_id & 0xffff; | 164 | u16 dev_id = vendor_id & 0xffff; |
103 | enum VIA_HDA_CODEC codec_type; | 165 | enum VIA_HDA_CODEC codec_type; |
@@ -111,9 +173,11 @@ static enum VIA_HDA_CODEC get_codec_type(u32 vendor_id) | |||
111 | codec_type = VT1709_10CH; | 173 | codec_type = VT1709_10CH; |
112 | else if (dev_id >= 0xe714 && dev_id <= 0xe717) | 174 | else if (dev_id >= 0xe714 && dev_id <= 0xe717) |
113 | codec_type = VT1709_6CH; | 175 | codec_type = VT1709_6CH; |
114 | else if (dev_id >= 0xe720 && dev_id <= 0xe723) | 176 | else if (dev_id >= 0xe720 && dev_id <= 0xe723) { |
115 | codec_type = VT1708B_8CH; | 177 | codec_type = VT1708B_8CH; |
116 | else if (dev_id >= 0xe724 && dev_id <= 0xe727) | 178 | if (snd_hda_param_read(codec, 0x16, AC_PAR_CONNLIST_LEN) == 0x7) |
179 | codec_type = VT1708BCE; | ||
180 | } else if (dev_id >= 0xe724 && dev_id <= 0xe727) | ||
117 | codec_type = VT1708B_4CH; | 181 | codec_type = VT1708B_4CH; |
118 | else if ((dev_id & 0xfff) == 0x397 | 182 | else if ((dev_id & 0xfff) == 0x397 |
119 | && (dev_id >> 12) < 8) | 183 | && (dev_id >> 12) < 8) |
@@ -121,6 +185,19 @@ static enum VIA_HDA_CODEC get_codec_type(u32 vendor_id) | |||
121 | else if ((dev_id & 0xfff) == 0x398 | 185 | else if ((dev_id & 0xfff) == 0x398 |
122 | && (dev_id >> 12) < 8) | 186 | && (dev_id >> 12) < 8) |
123 | codec_type = VT1702; | 187 | codec_type = VT1702; |
188 | else if ((dev_id & 0xfff) == 0x428 | ||
189 | && (dev_id >> 12) < 8) | ||
190 | codec_type = VT1718S; | ||
191 | else if (dev_id == 0x0433 || dev_id == 0xa721) | ||
192 | codec_type = VT1716S; | ||
193 | else if (dev_id == 0x0441 || dev_id == 0x4441) | ||
194 | codec_type = VT1718S; | ||
195 | else if (dev_id == 0x0438 || dev_id == 0x4438) | ||
196 | codec_type = VT2002P; | ||
197 | else if (dev_id == 0x0448) | ||
198 | codec_type = VT1812; | ||
199 | else if (dev_id == 0x0440) | ||
200 | codec_type = VT1708S; | ||
124 | else | 201 | else |
125 | codec_type = UNKNOWN; | 202 | codec_type = UNKNOWN; |
126 | return codec_type; | 203 | return codec_type; |
@@ -128,10 +205,16 @@ static enum VIA_HDA_CODEC get_codec_type(u32 vendor_id) | |||
128 | 205 | ||
129 | #define VIA_HP_EVENT 0x01 | 206 | #define VIA_HP_EVENT 0x01 |
130 | #define VIA_GPIO_EVENT 0x02 | 207 | #define VIA_GPIO_EVENT 0x02 |
208 | #define VIA_JACK_EVENT 0x04 | ||
209 | #define VIA_MONO_EVENT 0x08 | ||
210 | #define VIA_SPEAKER_EVENT 0x10 | ||
211 | #define VIA_BIND_HP_EVENT 0x20 | ||
131 | 212 | ||
132 | enum { | 213 | enum { |
133 | VIA_CTL_WIDGET_VOL, | 214 | VIA_CTL_WIDGET_VOL, |
134 | VIA_CTL_WIDGET_MUTE, | 215 | VIA_CTL_WIDGET_MUTE, |
216 | VIA_CTL_WIDGET_ANALOG_MUTE, | ||
217 | VIA_CTL_WIDGET_BIND_PIN_MUTE, | ||
135 | }; | 218 | }; |
136 | 219 | ||
137 | enum { | 220 | enum { |
@@ -141,99 +224,162 @@ enum { | |||
141 | AUTO_SEQ_SIDE | 224 | AUTO_SEQ_SIDE |
142 | }; | 225 | }; |
143 | 226 | ||
144 | /* Some VT1708S based boards gets the micboost setting wrong, so we have | 227 | static void analog_low_current_mode(struct hda_codec *codec, int stream_idle); |
145 | * to apply some brute-force and re-write the TLV's by software. */ | 228 | static void set_jack_power_state(struct hda_codec *codec); |
146 | static int mic_boost_tlv(struct snd_kcontrol *kcontrol, int op_flag, | 229 | static int is_aa_path_mute(struct hda_codec *codec); |
147 | unsigned int size, unsigned int __user *_tlv) | 230 | |
231 | static void vt1708_start_hp_work(struct via_spec *spec) | ||
148 | { | 232 | { |
149 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | 233 | if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0) |
150 | hda_nid_t nid = get_amp_nid(kcontrol); | 234 | return; |
235 | snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81, | ||
236 | !spec->vt1708_jack_detectect); | ||
237 | if (!delayed_work_pending(&spec->vt1708_hp_work)) | ||
238 | schedule_delayed_work(&spec->vt1708_hp_work, | ||
239 | msecs_to_jiffies(100)); | ||
240 | } | ||
151 | 241 | ||
152 | if (get_codec_type(codec->vendor_id) == VT1708S | 242 | static void vt1708_stop_hp_work(struct via_spec *spec) |
153 | && (nid == 0x1a || nid == 0x1e)) { | 243 | { |
154 | if (size < 4 * sizeof(unsigned int)) | 244 | if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0) |
155 | return -ENOMEM; | 245 | return; |
156 | if (put_user(1, _tlv)) /* SNDRV_CTL_TLVT_DB_SCALE */ | 246 | if (snd_hda_get_bool_hint(spec->codec, "analog_loopback_hp_detect") == 1 |
157 | return -EFAULT; | 247 | && !is_aa_path_mute(spec->codec)) |
158 | if (put_user(2 * sizeof(unsigned int), _tlv + 1)) | 248 | return; |
159 | return -EFAULT; | 249 | snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81, |
160 | if (put_user(0, _tlv + 2)) /* offset = 0 */ | 250 | !spec->vt1708_jack_detectect); |
161 | return -EFAULT; | 251 | cancel_delayed_work(&spec->vt1708_hp_work); |
162 | if (put_user(1000, _tlv + 3)) /* step size = 10 dB */ | 252 | flush_scheduled_work(); |
163 | return -EFAULT; | ||
164 | } | ||
165 | return 0; | ||
166 | } | 253 | } |
167 | 254 | ||
168 | static int mic_boost_volume_info(struct snd_kcontrol *kcontrol, | 255 | |
169 | struct snd_ctl_elem_info *uinfo) | 256 | static int analog_input_switch_put(struct snd_kcontrol *kcontrol, |
257 | struct snd_ctl_elem_value *ucontrol) | ||
170 | { | 258 | { |
259 | int change = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol); | ||
171 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | 260 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); |
172 | hda_nid_t nid = get_amp_nid(kcontrol); | ||
173 | 261 | ||
174 | if (get_codec_type(codec->vendor_id) == VT1708S | 262 | set_jack_power_state(codec); |
175 | && (nid == 0x1a || nid == 0x1e)) { | 263 | analog_low_current_mode(snd_kcontrol_chip(kcontrol), -1); |
176 | uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; | 264 | if (snd_hda_get_bool_hint(codec, "analog_loopback_hp_detect") == 1) { |
177 | uinfo->count = 2; | 265 | if (is_aa_path_mute(codec)) |
178 | uinfo->value.integer.min = 0; | 266 | vt1708_start_hp_work(codec->spec); |
179 | uinfo->value.integer.max = 3; | 267 | else |
268 | vt1708_stop_hp_work(codec->spec); | ||
180 | } | 269 | } |
181 | return 0; | 270 | return change; |
182 | } | 271 | } |
183 | 272 | ||
184 | static struct snd_kcontrol_new vt1708_control_templates[] = { | 273 | /* modify .put = snd_hda_mixer_amp_switch_put */ |
185 | HDA_CODEC_VOLUME(NULL, 0, 0, 0), | 274 | #define ANALOG_INPUT_MUTE \ |
186 | HDA_CODEC_MUTE(NULL, 0, 0, 0), | 275 | { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ |
187 | }; | 276 | .name = NULL, \ |
188 | 277 | .index = 0, \ | |
189 | 278 | .info = snd_hda_mixer_amp_switch_info, \ | |
190 | struct via_spec { | 279 | .get = snd_hda_mixer_amp_switch_get, \ |
191 | /* codec parameterization */ | 280 | .put = analog_input_switch_put, \ |
192 | struct snd_kcontrol_new *mixers[3]; | 281 | .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0) } |
193 | unsigned int num_mixers; | ||
194 | 282 | ||
195 | struct hda_verb *init_verbs[5]; | 283 | static void via_hp_bind_automute(struct hda_codec *codec); |
196 | unsigned int num_iverbs; | ||
197 | 284 | ||
198 | char *stream_name_analog; | 285 | static int bind_pin_switch_put(struct snd_kcontrol *kcontrol, |
199 | struct hda_pcm_stream *stream_analog_playback; | 286 | struct snd_ctl_elem_value *ucontrol) |
200 | struct hda_pcm_stream *stream_analog_capture; | 287 | { |
201 | 288 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | |
202 | char *stream_name_digital; | 289 | struct via_spec *spec = codec->spec; |
203 | struct hda_pcm_stream *stream_digital_playback; | 290 | int i; |
204 | struct hda_pcm_stream *stream_digital_capture; | 291 | int change = 0; |
205 | |||
206 | /* playback */ | ||
207 | struct hda_multi_out multiout; | ||
208 | hda_nid_t slave_dig_outs[2]; | ||
209 | |||
210 | /* capture */ | ||
211 | unsigned int num_adc_nids; | ||
212 | hda_nid_t *adc_nids; | ||
213 | hda_nid_t mux_nids[3]; | ||
214 | hda_nid_t dig_in_nid; | ||
215 | hda_nid_t dig_in_pin; | ||
216 | 292 | ||
217 | /* capture source */ | 293 | long *valp = ucontrol->value.integer.value; |
218 | const struct hda_input_mux *input_mux; | 294 | int lmute, rmute; |
219 | unsigned int cur_mux[3]; | 295 | if (strstr(kcontrol->id.name, "Switch") == NULL) { |
296 | snd_printd("Invalid control!\n"); | ||
297 | return change; | ||
298 | } | ||
299 | change = snd_hda_mixer_amp_switch_put(kcontrol, | ||
300 | ucontrol); | ||
301 | /* Get mute value */ | ||
302 | lmute = *valp ? 0 : HDA_AMP_MUTE; | ||
303 | valp++; | ||
304 | rmute = *valp ? 0 : HDA_AMP_MUTE; | ||
305 | |||
306 | /* Set hp pins */ | ||
307 | if (!spec->hp_independent_mode) { | ||
308 | for (i = 0; i < spec->autocfg.hp_outs; i++) { | ||
309 | snd_hda_codec_amp_update( | ||
310 | codec, spec->autocfg.hp_pins[i], | ||
311 | 0, HDA_OUTPUT, 0, HDA_AMP_MUTE, | ||
312 | lmute); | ||
313 | snd_hda_codec_amp_update( | ||
314 | codec, spec->autocfg.hp_pins[i], | ||
315 | 1, HDA_OUTPUT, 0, HDA_AMP_MUTE, | ||
316 | rmute); | ||
317 | } | ||
318 | } | ||
220 | 319 | ||
221 | /* PCM information */ | 320 | if (!lmute && !rmute) { |
222 | struct hda_pcm pcm_rec[3]; | 321 | /* Line Outs */ |
322 | for (i = 0; i < spec->autocfg.line_outs; i++) | ||
323 | snd_hda_codec_amp_stereo( | ||
324 | codec, spec->autocfg.line_out_pins[i], | ||
325 | HDA_OUTPUT, 0, HDA_AMP_MUTE, 0); | ||
326 | /* Speakers */ | ||
327 | for (i = 0; i < spec->autocfg.speaker_outs; i++) | ||
328 | snd_hda_codec_amp_stereo( | ||
329 | codec, spec->autocfg.speaker_pins[i], | ||
330 | HDA_OUTPUT, 0, HDA_AMP_MUTE, 0); | ||
331 | /* unmute */ | ||
332 | via_hp_bind_automute(codec); | ||
223 | 333 | ||
224 | /* dynamic controls, init_verbs and input_mux */ | 334 | } else { |
225 | struct auto_pin_cfg autocfg; | 335 | if (lmute) { |
226 | struct snd_array kctls; | 336 | /* Mute all left channels */ |
227 | struct hda_input_mux private_imux[2]; | 337 | for (i = 1; i < spec->autocfg.line_outs; i++) |
228 | hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS]; | 338 | snd_hda_codec_amp_update( |
339 | codec, | ||
340 | spec->autocfg.line_out_pins[i], | ||
341 | 0, HDA_OUTPUT, 0, HDA_AMP_MUTE, | ||
342 | lmute); | ||
343 | for (i = 0; i < spec->autocfg.speaker_outs; i++) | ||
344 | snd_hda_codec_amp_update( | ||
345 | codec, | ||
346 | spec->autocfg.speaker_pins[i], | ||
347 | 0, HDA_OUTPUT, 0, HDA_AMP_MUTE, | ||
348 | lmute); | ||
349 | } | ||
350 | if (rmute) { | ||
351 | /* mute all right channels */ | ||
352 | for (i = 1; i < spec->autocfg.line_outs; i++) | ||
353 | snd_hda_codec_amp_update( | ||
354 | codec, | ||
355 | spec->autocfg.line_out_pins[i], | ||
356 | 1, HDA_OUTPUT, 0, HDA_AMP_MUTE, | ||
357 | rmute); | ||
358 | for (i = 0; i < spec->autocfg.speaker_outs; i++) | ||
359 | snd_hda_codec_amp_update( | ||
360 | codec, | ||
361 | spec->autocfg.speaker_pins[i], | ||
362 | 1, HDA_OUTPUT, 0, HDA_AMP_MUTE, | ||
363 | rmute); | ||
364 | } | ||
365 | } | ||
366 | return change; | ||
367 | } | ||
229 | 368 | ||
230 | /* HP mode source */ | 369 | #define BIND_PIN_MUTE \ |
231 | const struct hda_input_mux *hp_mux; | 370 | { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ |
232 | unsigned int hp_independent_mode; | 371 | .name = NULL, \ |
372 | .index = 0, \ | ||
373 | .info = snd_hda_mixer_amp_switch_info, \ | ||
374 | .get = snd_hda_mixer_amp_switch_get, \ | ||
375 | .put = bind_pin_switch_put, \ | ||
376 | .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0) } | ||
233 | 377 | ||
234 | #ifdef CONFIG_SND_HDA_POWER_SAVE | 378 | static struct snd_kcontrol_new via_control_templates[] = { |
235 | struct hda_loopback_check loopback; | 379 | HDA_CODEC_VOLUME(NULL, 0, 0, 0), |
236 | #endif | 380 | HDA_CODEC_MUTE(NULL, 0, 0, 0), |
381 | ANALOG_INPUT_MUTE, | ||
382 | BIND_PIN_MUTE, | ||
237 | }; | 383 | }; |
238 | 384 | ||
239 | static hda_nid_t vt1708_adc_nids[2] = { | 385 | static hda_nid_t vt1708_adc_nids[2] = { |
@@ -261,6 +407,27 @@ static hda_nid_t vt1702_adc_nids[3] = { | |||
261 | 0x12, 0x20, 0x1F | 407 | 0x12, 0x20, 0x1F |
262 | }; | 408 | }; |
263 | 409 | ||
410 | static hda_nid_t vt1718S_adc_nids[2] = { | ||
411 | /* ADC1-2 */ | ||
412 | 0x10, 0x11 | ||
413 | }; | ||
414 | |||
415 | static hda_nid_t vt1716S_adc_nids[2] = { | ||
416 | /* ADC1-2 */ | ||
417 | 0x13, 0x14 | ||
418 | }; | ||
419 | |||
420 | static hda_nid_t vt2002P_adc_nids[2] = { | ||
421 | /* ADC1-2 */ | ||
422 | 0x10, 0x11 | ||
423 | }; | ||
424 | |||
425 | static hda_nid_t vt1812_adc_nids[2] = { | ||
426 | /* ADC1-2 */ | ||
427 | 0x10, 0x11 | ||
428 | }; | ||
429 | |||
430 | |||
264 | /* add dynamic controls */ | 431 | /* add dynamic controls */ |
265 | static int via_add_control(struct via_spec *spec, int type, const char *name, | 432 | static int via_add_control(struct via_spec *spec, int type, const char *name, |
266 | unsigned long val) | 433 | unsigned long val) |
@@ -271,10 +438,12 @@ static int via_add_control(struct via_spec *spec, int type, const char *name, | |||
271 | knew = snd_array_new(&spec->kctls); | 438 | knew = snd_array_new(&spec->kctls); |
272 | if (!knew) | 439 | if (!knew) |
273 | return -ENOMEM; | 440 | return -ENOMEM; |
274 | *knew = vt1708_control_templates[type]; | 441 | *knew = via_control_templates[type]; |
275 | knew->name = kstrdup(name, GFP_KERNEL); | 442 | knew->name = kstrdup(name, GFP_KERNEL); |
276 | if (!knew->name) | 443 | if (!knew->name) |
277 | return -ENOMEM; | 444 | return -ENOMEM; |
445 | if (get_amp_nid_(val)) | ||
446 | knew->subdevice = HDA_SUBDEV_NID_FLAG | get_amp_nid_(val); | ||
278 | knew->private_value = val; | 447 | knew->private_value = val; |
279 | return 0; | 448 | return 0; |
280 | } | 449 | } |
@@ -293,8 +462,8 @@ static void via_free_kctls(struct hda_codec *codec) | |||
293 | } | 462 | } |
294 | 463 | ||
295 | /* create input playback/capture controls for the given pin */ | 464 | /* create input playback/capture controls for the given pin */ |
296 | static int via_new_analog_input(struct via_spec *spec, hda_nid_t pin, | 465 | static int via_new_analog_input(struct via_spec *spec, const char *ctlname, |
297 | const char *ctlname, int idx, int mix_nid) | 466 | int idx, int mix_nid) |
298 | { | 467 | { |
299 | char name[32]; | 468 | char name[32]; |
300 | int err; | 469 | int err; |
@@ -305,7 +474,7 @@ static int via_new_analog_input(struct via_spec *spec, hda_nid_t pin, | |||
305 | if (err < 0) | 474 | if (err < 0) |
306 | return err; | 475 | return err; |
307 | sprintf(name, "%s Playback Switch", ctlname); | 476 | sprintf(name, "%s Playback Switch", ctlname); |
308 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, | 477 | err = via_add_control(spec, VIA_CTL_WIDGET_ANALOG_MUTE, name, |
309 | HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); | 478 | HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); |
310 | if (err < 0) | 479 | if (err < 0) |
311 | return err; | 480 | return err; |
@@ -322,7 +491,7 @@ static void via_auto_set_output_and_unmute(struct hda_codec *codec, | |||
322 | snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, | 491 | snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, |
323 | AMP_OUT_UNMUTE); | 492 | AMP_OUT_UNMUTE); |
324 | if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD) | 493 | if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD) |
325 | snd_hda_codec_write(codec, nid, 0, | 494 | snd_hda_codec_write(codec, nid, 0, |
326 | AC_VERB_SET_EAPD_BTLENABLE, 0x02); | 495 | AC_VERB_SET_EAPD_BTLENABLE, 0x02); |
327 | } | 496 | } |
328 | 497 | ||
@@ -343,10 +512,13 @@ static void via_auto_init_hp_out(struct hda_codec *codec) | |||
343 | { | 512 | { |
344 | struct via_spec *spec = codec->spec; | 513 | struct via_spec *spec = codec->spec; |
345 | hda_nid_t pin; | 514 | hda_nid_t pin; |
515 | int i; | ||
346 | 516 | ||
347 | pin = spec->autocfg.hp_pins[0]; | 517 | for (i = 0; i < spec->autocfg.hp_outs; i++) { |
348 | if (pin) /* connect to front */ | 518 | pin = spec->autocfg.hp_pins[i]; |
349 | via_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); | 519 | if (pin) /* connect to front */ |
520 | via_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); | ||
521 | } | ||
350 | } | 522 | } |
351 | 523 | ||
352 | static void via_auto_init_analog_input(struct hda_codec *codec) | 524 | static void via_auto_init_analog_input(struct hda_codec *codec) |
@@ -364,6 +536,502 @@ static void via_auto_init_analog_input(struct hda_codec *codec) | |||
364 | 536 | ||
365 | } | 537 | } |
366 | } | 538 | } |
539 | |||
540 | static int is_smart51_pins(struct via_spec *spec, hda_nid_t pin); | ||
541 | |||
542 | static void set_pin_power_state(struct hda_codec *codec, hda_nid_t nid, | ||
543 | unsigned int *affected_parm) | ||
544 | { | ||
545 | unsigned parm; | ||
546 | unsigned def_conf = snd_hda_codec_get_pincfg(codec, nid); | ||
547 | unsigned no_presence = (def_conf & AC_DEFCFG_MISC) | ||
548 | >> AC_DEFCFG_MISC_SHIFT | ||
549 | & AC_DEFCFG_MISC_NO_PRESENCE; /* do not support pin sense */ | ||
550 | unsigned present = snd_hda_jack_detect(codec, nid); | ||
551 | struct via_spec *spec = codec->spec; | ||
552 | if ((spec->smart51_enabled && is_smart51_pins(spec, nid)) | ||
553 | || ((no_presence || present) | ||
554 | && get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE)) { | ||
555 | *affected_parm = AC_PWRST_D0; /* if it's connected */ | ||
556 | parm = AC_PWRST_D0; | ||
557 | } else | ||
558 | parm = AC_PWRST_D3; | ||
559 | |||
560 | snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE, parm); | ||
561 | } | ||
562 | |||
563 | static void set_jack_power_state(struct hda_codec *codec) | ||
564 | { | ||
565 | struct via_spec *spec = codec->spec; | ||
566 | int imux_is_smixer; | ||
567 | unsigned int parm; | ||
568 | |||
569 | if (spec->codec_type == VT1702) { | ||
570 | imux_is_smixer = snd_hda_codec_read( | ||
571 | codec, 0x13, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3; | ||
572 | /* inputs */ | ||
573 | /* PW 1/2/5 (14h/15h/18h) */ | ||
574 | parm = AC_PWRST_D3; | ||
575 | set_pin_power_state(codec, 0x14, &parm); | ||
576 | set_pin_power_state(codec, 0x15, &parm); | ||
577 | set_pin_power_state(codec, 0x18, &parm); | ||
578 | if (imux_is_smixer) | ||
579 | parm = AC_PWRST_D0; /* SW0 = stereo mixer (idx 3) */ | ||
580 | /* SW0 (13h), AIW 0/1/2 (12h/1fh/20h) */ | ||
581 | snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE, | ||
582 | parm); | ||
583 | snd_hda_codec_write(codec, 0x12, 0, AC_VERB_SET_POWER_STATE, | ||
584 | parm); | ||
585 | snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, | ||
586 | parm); | ||
587 | snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_POWER_STATE, | ||
588 | parm); | ||
589 | |||
590 | /* outputs */ | ||
591 | /* PW 3/4 (16h/17h) */ | ||
592 | parm = AC_PWRST_D3; | ||
593 | set_pin_power_state(codec, 0x16, &parm); | ||
594 | set_pin_power_state(codec, 0x17, &parm); | ||
595 | /* MW0 (1ah), AOW 0/1 (10h/1dh) */ | ||
596 | snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_POWER_STATE, | ||
597 | imux_is_smixer ? AC_PWRST_D0 : parm); | ||
598 | snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, | ||
599 | parm); | ||
600 | snd_hda_codec_write(codec, 0x1d, 0, AC_VERB_SET_POWER_STATE, | ||
601 | parm); | ||
602 | } else if (spec->codec_type == VT1708B_8CH | ||
603 | || spec->codec_type == VT1708B_4CH | ||
604 | || spec->codec_type == VT1708S) { | ||
605 | /* SW0 (17h) = stereo mixer */ | ||
606 | int is_8ch = spec->codec_type != VT1708B_4CH; | ||
607 | imux_is_smixer = snd_hda_codec_read( | ||
608 | codec, 0x17, 0, AC_VERB_GET_CONNECT_SEL, 0x00) | ||
609 | == ((spec->codec_type == VT1708S) ? 5 : 0); | ||
610 | /* inputs */ | ||
611 | /* PW 1/2/5 (1ah/1bh/1eh) */ | ||
612 | parm = AC_PWRST_D3; | ||
613 | set_pin_power_state(codec, 0x1a, &parm); | ||
614 | set_pin_power_state(codec, 0x1b, &parm); | ||
615 | set_pin_power_state(codec, 0x1e, &parm); | ||
616 | if (imux_is_smixer) | ||
617 | parm = AC_PWRST_D0; | ||
618 | /* SW0 (17h), AIW 0/1 (13h/14h) */ | ||
619 | snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_POWER_STATE, | ||
620 | parm); | ||
621 | snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE, | ||
622 | parm); | ||
623 | snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_POWER_STATE, | ||
624 | parm); | ||
625 | |||
626 | /* outputs */ | ||
627 | /* PW0 (19h), SW1 (18h), AOW1 (11h) */ | ||
628 | parm = AC_PWRST_D3; | ||
629 | set_pin_power_state(codec, 0x19, &parm); | ||
630 | snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE, | ||
631 | parm); | ||
632 | snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, | ||
633 | parm); | ||
634 | |||
635 | /* PW6 (22h), SW2 (26h), AOW2 (24h) */ | ||
636 | if (is_8ch) { | ||
637 | parm = AC_PWRST_D3; | ||
638 | set_pin_power_state(codec, 0x22, &parm); | ||
639 | snd_hda_codec_write(codec, 0x26, 0, | ||
640 | AC_VERB_SET_POWER_STATE, parm); | ||
641 | snd_hda_codec_write(codec, 0x24, 0, | ||
642 | AC_VERB_SET_POWER_STATE, parm); | ||
643 | } | ||
644 | |||
645 | /* PW 3/4/7 (1ch/1dh/23h) */ | ||
646 | parm = AC_PWRST_D3; | ||
647 | /* force to D0 for internal Speaker */ | ||
648 | set_pin_power_state(codec, 0x1c, &parm); | ||
649 | set_pin_power_state(codec, 0x1d, &parm); | ||
650 | if (is_8ch) | ||
651 | set_pin_power_state(codec, 0x23, &parm); | ||
652 | /* MW0 (16h), Sw3 (27h), AOW 0/3 (10h/25h) */ | ||
653 | snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_POWER_STATE, | ||
654 | imux_is_smixer ? AC_PWRST_D0 : parm); | ||
655 | snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, | ||
656 | parm); | ||
657 | if (is_8ch) { | ||
658 | snd_hda_codec_write(codec, 0x25, 0, | ||
659 | AC_VERB_SET_POWER_STATE, parm); | ||
660 | snd_hda_codec_write(codec, 0x27, 0, | ||
661 | AC_VERB_SET_POWER_STATE, parm); | ||
662 | } | ||
663 | } else if (spec->codec_type == VT1718S) { | ||
664 | /* MUX6 (1eh) = stereo mixer */ | ||
665 | imux_is_smixer = snd_hda_codec_read( | ||
666 | codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 5; | ||
667 | /* inputs */ | ||
668 | /* PW 5/6/7 (29h/2ah/2bh) */ | ||
669 | parm = AC_PWRST_D3; | ||
670 | set_pin_power_state(codec, 0x29, &parm); | ||
671 | set_pin_power_state(codec, 0x2a, &parm); | ||
672 | set_pin_power_state(codec, 0x2b, &parm); | ||
673 | if (imux_is_smixer) | ||
674 | parm = AC_PWRST_D0; | ||
675 | /* MUX6/7 (1eh/1fh), AIW 0/1 (10h/11h) */ | ||
676 | snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_POWER_STATE, | ||
677 | parm); | ||
678 | snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, | ||
679 | parm); | ||
680 | snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, | ||
681 | parm); | ||
682 | snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, | ||
683 | parm); | ||
684 | |||
685 | /* outputs */ | ||
686 | /* PW3 (27h), MW2 (1ah), AOW3 (bh) */ | ||
687 | parm = AC_PWRST_D3; | ||
688 | set_pin_power_state(codec, 0x27, &parm); | ||
689 | snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_POWER_STATE, | ||
690 | parm); | ||
691 | snd_hda_codec_write(codec, 0xb, 0, AC_VERB_SET_POWER_STATE, | ||
692 | parm); | ||
693 | |||
694 | /* PW2 (26h), AOW2 (ah) */ | ||
695 | parm = AC_PWRST_D3; | ||
696 | set_pin_power_state(codec, 0x26, &parm); | ||
697 | snd_hda_codec_write(codec, 0xa, 0, AC_VERB_SET_POWER_STATE, | ||
698 | parm); | ||
699 | |||
700 | /* PW0/1 (24h/25h) */ | ||
701 | parm = AC_PWRST_D3; | ||
702 | set_pin_power_state(codec, 0x24, &parm); | ||
703 | set_pin_power_state(codec, 0x25, &parm); | ||
704 | if (!spec->hp_independent_mode) /* check for redirected HP */ | ||
705 | set_pin_power_state(codec, 0x28, &parm); | ||
706 | snd_hda_codec_write(codec, 0x8, 0, AC_VERB_SET_POWER_STATE, | ||
707 | parm); | ||
708 | snd_hda_codec_write(codec, 0x9, 0, AC_VERB_SET_POWER_STATE, | ||
709 | parm); | ||
710 | /* MW9 (21h), Mw2 (1ah), AOW0 (8h) */ | ||
711 | snd_hda_codec_write(codec, 0x21, 0, AC_VERB_SET_POWER_STATE, | ||
712 | imux_is_smixer ? AC_PWRST_D0 : parm); | ||
713 | if (spec->hp_independent_mode) { | ||
714 | /* PW4 (28h), MW3 (1bh), MUX1(34h), AOW4 (ch) */ | ||
715 | parm = AC_PWRST_D3; | ||
716 | set_pin_power_state(codec, 0x28, &parm); | ||
717 | snd_hda_codec_write(codec, 0x1b, 0, | ||
718 | AC_VERB_SET_POWER_STATE, parm); | ||
719 | snd_hda_codec_write(codec, 0x34, 0, | ||
720 | AC_VERB_SET_POWER_STATE, parm); | ||
721 | snd_hda_codec_write(codec, 0xc, 0, | ||
722 | AC_VERB_SET_POWER_STATE, parm); | ||
723 | } | ||
724 | } else if (spec->codec_type == VT1716S) { | ||
725 | unsigned int mono_out, present; | ||
726 | /* SW0 (17h) = stereo mixer */ | ||
727 | imux_is_smixer = snd_hda_codec_read( | ||
728 | codec, 0x17, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 5; | ||
729 | /* inputs */ | ||
730 | /* PW 1/2/5 (1ah/1bh/1eh) */ | ||
731 | parm = AC_PWRST_D3; | ||
732 | set_pin_power_state(codec, 0x1a, &parm); | ||
733 | set_pin_power_state(codec, 0x1b, &parm); | ||
734 | set_pin_power_state(codec, 0x1e, &parm); | ||
735 | if (imux_is_smixer) | ||
736 | parm = AC_PWRST_D0; | ||
737 | /* SW0 (17h), AIW0(13h) */ | ||
738 | snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_POWER_STATE, | ||
739 | parm); | ||
740 | snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE, | ||
741 | parm); | ||
742 | |||
743 | parm = AC_PWRST_D3; | ||
744 | set_pin_power_state(codec, 0x1e, &parm); | ||
745 | /* PW11 (22h) */ | ||
746 | if (spec->dmic_enabled) | ||
747 | set_pin_power_state(codec, 0x22, &parm); | ||
748 | else | ||
749 | snd_hda_codec_write( | ||
750 | codec, 0x22, 0, | ||
751 | AC_VERB_SET_POWER_STATE, AC_PWRST_D3); | ||
752 | |||
753 | /* SW2(26h), AIW1(14h) */ | ||
754 | snd_hda_codec_write(codec, 0x26, 0, AC_VERB_SET_POWER_STATE, | ||
755 | parm); | ||
756 | snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_POWER_STATE, | ||
757 | parm); | ||
758 | |||
759 | /* outputs */ | ||
760 | /* PW0 (19h), SW1 (18h), AOW1 (11h) */ | ||
761 | parm = AC_PWRST_D3; | ||
762 | set_pin_power_state(codec, 0x19, &parm); | ||
763 | /* Smart 5.1 PW2(1bh) */ | ||
764 | if (spec->smart51_enabled) | ||
765 | set_pin_power_state(codec, 0x1b, &parm); | ||
766 | snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE, | ||
767 | parm); | ||
768 | snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, | ||
769 | parm); | ||
770 | |||
771 | /* PW7 (23h), SW3 (27h), AOW3 (25h) */ | ||
772 | parm = AC_PWRST_D3; | ||
773 | set_pin_power_state(codec, 0x23, &parm); | ||
774 | /* Smart 5.1 PW1(1ah) */ | ||
775 | if (spec->smart51_enabled) | ||
776 | set_pin_power_state(codec, 0x1a, &parm); | ||
777 | snd_hda_codec_write(codec, 0x27, 0, AC_VERB_SET_POWER_STATE, | ||
778 | parm); | ||
779 | |||
780 | /* Smart 5.1 PW5(1eh) */ | ||
781 | if (spec->smart51_enabled) | ||
782 | set_pin_power_state(codec, 0x1e, &parm); | ||
783 | snd_hda_codec_write(codec, 0x25, 0, AC_VERB_SET_POWER_STATE, | ||
784 | parm); | ||
785 | |||
786 | /* Mono out */ | ||
787 | /* SW4(28h)->MW1(29h)-> PW12 (2ah)*/ | ||
788 | present = snd_hda_jack_detect(codec, 0x1c); | ||
789 | if (present) | ||
790 | mono_out = 0; | ||
791 | else { | ||
792 | present = snd_hda_jack_detect(codec, 0x1d); | ||
793 | if (!spec->hp_independent_mode && present) | ||
794 | mono_out = 0; | ||
795 | else | ||
796 | mono_out = 1; | ||
797 | } | ||
798 | parm = mono_out ? AC_PWRST_D0 : AC_PWRST_D3; | ||
799 | snd_hda_codec_write(codec, 0x28, 0, AC_VERB_SET_POWER_STATE, | ||
800 | parm); | ||
801 | snd_hda_codec_write(codec, 0x29, 0, AC_VERB_SET_POWER_STATE, | ||
802 | parm); | ||
803 | snd_hda_codec_write(codec, 0x2a, 0, AC_VERB_SET_POWER_STATE, | ||
804 | parm); | ||
805 | |||
806 | /* PW 3/4 (1ch/1dh) */ | ||
807 | parm = AC_PWRST_D3; | ||
808 | set_pin_power_state(codec, 0x1c, &parm); | ||
809 | set_pin_power_state(codec, 0x1d, &parm); | ||
810 | /* HP Independent Mode, power on AOW3 */ | ||
811 | if (spec->hp_independent_mode) | ||
812 | snd_hda_codec_write(codec, 0x25, 0, | ||
813 | AC_VERB_SET_POWER_STATE, parm); | ||
814 | |||
815 | /* force to D0 for internal Speaker */ | ||
816 | /* MW0 (16h), AOW0 (10h) */ | ||
817 | snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_POWER_STATE, | ||
818 | imux_is_smixer ? AC_PWRST_D0 : parm); | ||
819 | snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, | ||
820 | mono_out ? AC_PWRST_D0 : parm); | ||
821 | } else if (spec->codec_type == VT2002P) { | ||
822 | unsigned int present; | ||
823 | /* MUX9 (1eh) = stereo mixer */ | ||
824 | imux_is_smixer = snd_hda_codec_read( | ||
825 | codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3; | ||
826 | /* inputs */ | ||
827 | /* PW 5/6/7 (29h/2ah/2bh) */ | ||
828 | parm = AC_PWRST_D3; | ||
829 | set_pin_power_state(codec, 0x29, &parm); | ||
830 | set_pin_power_state(codec, 0x2a, &parm); | ||
831 | set_pin_power_state(codec, 0x2b, &parm); | ||
832 | if (imux_is_smixer) | ||
833 | parm = AC_PWRST_D0; | ||
834 | /* MUX9/10 (1eh/1fh), AIW 0/1 (10h/11h) */ | ||
835 | snd_hda_codec_write(codec, 0x1e, 0, | ||
836 | AC_VERB_SET_POWER_STATE, parm); | ||
837 | snd_hda_codec_write(codec, 0x1f, 0, | ||
838 | AC_VERB_SET_POWER_STATE, parm); | ||
839 | snd_hda_codec_write(codec, 0x10, 0, | ||
840 | AC_VERB_SET_POWER_STATE, parm); | ||
841 | snd_hda_codec_write(codec, 0x11, 0, | ||
842 | AC_VERB_SET_POWER_STATE, parm); | ||
843 | |||
844 | /* outputs */ | ||
845 | /* AOW0 (8h)*/ | ||
846 | snd_hda_codec_write(codec, 0x8, 0, | ||
847 | AC_VERB_SET_POWER_STATE, AC_PWRST_D0); | ||
848 | |||
849 | /* PW4 (26h), MW4 (1ch), MUX4(37h) */ | ||
850 | parm = AC_PWRST_D3; | ||
851 | set_pin_power_state(codec, 0x26, &parm); | ||
852 | snd_hda_codec_write(codec, 0x1c, 0, | ||
853 | AC_VERB_SET_POWER_STATE, parm); | ||
854 | snd_hda_codec_write(codec, 0x37, | ||
855 | 0, AC_VERB_SET_POWER_STATE, parm); | ||
856 | |||
857 | /* PW1 (25h), MW1 (19h), MUX1(35h), AOW1 (9h) */ | ||
858 | parm = AC_PWRST_D3; | ||
859 | set_pin_power_state(codec, 0x25, &parm); | ||
860 | snd_hda_codec_write(codec, 0x19, 0, | ||
861 | AC_VERB_SET_POWER_STATE, parm); | ||
862 | snd_hda_codec_write(codec, 0x35, 0, | ||
863 | AC_VERB_SET_POWER_STATE, parm); | ||
864 | if (spec->hp_independent_mode) { | ||
865 | snd_hda_codec_write(codec, 0x9, 0, | ||
866 | AC_VERB_SET_POWER_STATE, parm); | ||
867 | } | ||
868 | |||
869 | /* Class-D */ | ||
870 | /* PW0 (24h), MW0(18h), MUX0(34h) */ | ||
871 | present = snd_hda_jack_detect(codec, 0x25); | ||
872 | parm = AC_PWRST_D3; | ||
873 | set_pin_power_state(codec, 0x24, &parm); | ||
874 | if (present) { | ||
875 | snd_hda_codec_write( | ||
876 | codec, 0x18, 0, | ||
877 | AC_VERB_SET_POWER_STATE, AC_PWRST_D3); | ||
878 | snd_hda_codec_write( | ||
879 | codec, 0x34, 0, | ||
880 | AC_VERB_SET_POWER_STATE, AC_PWRST_D3); | ||
881 | } else { | ||
882 | snd_hda_codec_write( | ||
883 | codec, 0x18, 0, | ||
884 | AC_VERB_SET_POWER_STATE, AC_PWRST_D0); | ||
885 | snd_hda_codec_write( | ||
886 | codec, 0x34, 0, | ||
887 | AC_VERB_SET_POWER_STATE, AC_PWRST_D0); | ||
888 | } | ||
889 | |||
890 | /* Mono Out */ | ||
891 | /* PW15 (31h), MW8(17h), MUX8(3bh) */ | ||
892 | present = snd_hda_jack_detect(codec, 0x26); | ||
893 | parm = AC_PWRST_D3; | ||
894 | set_pin_power_state(codec, 0x31, &parm); | ||
895 | if (present) { | ||
896 | snd_hda_codec_write( | ||
897 | codec, 0x17, 0, | ||
898 | AC_VERB_SET_POWER_STATE, AC_PWRST_D3); | ||
899 | snd_hda_codec_write( | ||
900 | codec, 0x3b, 0, | ||
901 | AC_VERB_SET_POWER_STATE, AC_PWRST_D3); | ||
902 | } else { | ||
903 | snd_hda_codec_write( | ||
904 | codec, 0x17, 0, | ||
905 | AC_VERB_SET_POWER_STATE, AC_PWRST_D0); | ||
906 | snd_hda_codec_write( | ||
907 | codec, 0x3b, 0, | ||
908 | AC_VERB_SET_POWER_STATE, AC_PWRST_D0); | ||
909 | } | ||
910 | |||
911 | /* MW9 (21h) */ | ||
912 | if (imux_is_smixer || !is_aa_path_mute(codec)) | ||
913 | snd_hda_codec_write( | ||
914 | codec, 0x21, 0, | ||
915 | AC_VERB_SET_POWER_STATE, AC_PWRST_D0); | ||
916 | else | ||
917 | snd_hda_codec_write( | ||
918 | codec, 0x21, 0, | ||
919 | AC_VERB_SET_POWER_STATE, AC_PWRST_D3); | ||
920 | } else if (spec->codec_type == VT1812) { | ||
921 | unsigned int present; | ||
922 | /* MUX10 (1eh) = stereo mixer */ | ||
923 | imux_is_smixer = snd_hda_codec_read( | ||
924 | codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 5; | ||
925 | /* inputs */ | ||
926 | /* PW 5/6/7 (29h/2ah/2bh) */ | ||
927 | parm = AC_PWRST_D3; | ||
928 | set_pin_power_state(codec, 0x29, &parm); | ||
929 | set_pin_power_state(codec, 0x2a, &parm); | ||
930 | set_pin_power_state(codec, 0x2b, &parm); | ||
931 | if (imux_is_smixer) | ||
932 | parm = AC_PWRST_D0; | ||
933 | /* MUX10/11 (1eh/1fh), AIW 0/1 (10h/11h) */ | ||
934 | snd_hda_codec_write(codec, 0x1e, 0, | ||
935 | AC_VERB_SET_POWER_STATE, parm); | ||
936 | snd_hda_codec_write(codec, 0x1f, 0, | ||
937 | AC_VERB_SET_POWER_STATE, parm); | ||
938 | snd_hda_codec_write(codec, 0x10, 0, | ||
939 | AC_VERB_SET_POWER_STATE, parm); | ||
940 | snd_hda_codec_write(codec, 0x11, 0, | ||
941 | AC_VERB_SET_POWER_STATE, parm); | ||
942 | |||
943 | /* outputs */ | ||
944 | /* AOW0 (8h)*/ | ||
945 | snd_hda_codec_write(codec, 0x8, 0, | ||
946 | AC_VERB_SET_POWER_STATE, AC_PWRST_D0); | ||
947 | |||
948 | /* PW4 (28h), MW4 (18h), MUX4(38h) */ | ||
949 | parm = AC_PWRST_D3; | ||
950 | set_pin_power_state(codec, 0x28, &parm); | ||
951 | snd_hda_codec_write(codec, 0x18, 0, | ||
952 | AC_VERB_SET_POWER_STATE, parm); | ||
953 | snd_hda_codec_write(codec, 0x38, 0, | ||
954 | AC_VERB_SET_POWER_STATE, parm); | ||
955 | |||
956 | /* PW1 (25h), MW1 (15h), MUX1(35h), AOW1 (9h) */ | ||
957 | parm = AC_PWRST_D3; | ||
958 | set_pin_power_state(codec, 0x25, &parm); | ||
959 | snd_hda_codec_write(codec, 0x15, 0, | ||
960 | AC_VERB_SET_POWER_STATE, parm); | ||
961 | snd_hda_codec_write(codec, 0x35, 0, | ||
962 | AC_VERB_SET_POWER_STATE, parm); | ||
963 | if (spec->hp_independent_mode) { | ||
964 | snd_hda_codec_write(codec, 0x9, 0, | ||
965 | AC_VERB_SET_POWER_STATE, parm); | ||
966 | } | ||
967 | |||
968 | /* Internal Speaker */ | ||
969 | /* PW0 (24h), MW0(14h), MUX0(34h) */ | ||
970 | present = snd_hda_jack_detect(codec, 0x25); | ||
971 | parm = AC_PWRST_D3; | ||
972 | set_pin_power_state(codec, 0x24, &parm); | ||
973 | if (present) { | ||
974 | snd_hda_codec_write(codec, 0x14, 0, | ||
975 | AC_VERB_SET_POWER_STATE, | ||
976 | AC_PWRST_D3); | ||
977 | snd_hda_codec_write(codec, 0x34, 0, | ||
978 | AC_VERB_SET_POWER_STATE, | ||
979 | AC_PWRST_D3); | ||
980 | } else { | ||
981 | snd_hda_codec_write(codec, 0x14, 0, | ||
982 | AC_VERB_SET_POWER_STATE, | ||
983 | AC_PWRST_D0); | ||
984 | snd_hda_codec_write(codec, 0x34, 0, | ||
985 | AC_VERB_SET_POWER_STATE, | ||
986 | AC_PWRST_D0); | ||
987 | } | ||
988 | /* Mono Out */ | ||
989 | /* PW13 (31h), MW13(1ch), MUX13(3ch), MW14(3eh) */ | ||
990 | present = snd_hda_jack_detect(codec, 0x28); | ||
991 | parm = AC_PWRST_D3; | ||
992 | set_pin_power_state(codec, 0x31, &parm); | ||
993 | if (present) { | ||
994 | snd_hda_codec_write(codec, 0x1c, 0, | ||
995 | AC_VERB_SET_POWER_STATE, | ||
996 | AC_PWRST_D3); | ||
997 | snd_hda_codec_write(codec, 0x3c, 0, | ||
998 | AC_VERB_SET_POWER_STATE, | ||
999 | AC_PWRST_D3); | ||
1000 | snd_hda_codec_write(codec, 0x3e, 0, | ||
1001 | AC_VERB_SET_POWER_STATE, | ||
1002 | AC_PWRST_D3); | ||
1003 | } else { | ||
1004 | snd_hda_codec_write(codec, 0x1c, 0, | ||
1005 | AC_VERB_SET_POWER_STATE, | ||
1006 | AC_PWRST_D0); | ||
1007 | snd_hda_codec_write(codec, 0x3c, 0, | ||
1008 | AC_VERB_SET_POWER_STATE, | ||
1009 | AC_PWRST_D0); | ||
1010 | snd_hda_codec_write(codec, 0x3e, 0, | ||
1011 | AC_VERB_SET_POWER_STATE, | ||
1012 | AC_PWRST_D0); | ||
1013 | } | ||
1014 | |||
1015 | /* PW15 (33h), MW15 (1dh), MUX15(3dh) */ | ||
1016 | parm = AC_PWRST_D3; | ||
1017 | set_pin_power_state(codec, 0x33, &parm); | ||
1018 | snd_hda_codec_write(codec, 0x1d, 0, | ||
1019 | AC_VERB_SET_POWER_STATE, parm); | ||
1020 | snd_hda_codec_write(codec, 0x3d, 0, | ||
1021 | AC_VERB_SET_POWER_STATE, parm); | ||
1022 | |||
1023 | /* MW9 (21h) */ | ||
1024 | if (imux_is_smixer || !is_aa_path_mute(codec)) | ||
1025 | snd_hda_codec_write( | ||
1026 | codec, 0x21, 0, | ||
1027 | AC_VERB_SET_POWER_STATE, AC_PWRST_D0); | ||
1028 | else | ||
1029 | snd_hda_codec_write( | ||
1030 | codec, 0x21, 0, | ||
1031 | AC_VERB_SET_POWER_STATE, AC_PWRST_D3); | ||
1032 | } | ||
1033 | } | ||
1034 | |||
367 | /* | 1035 | /* |
368 | * input MUX handling | 1036 | * input MUX handling |
369 | */ | 1037 | */ |
@@ -395,6 +1063,14 @@ static int via_mux_enum_put(struct snd_kcontrol *kcontrol, | |||
395 | 1063 | ||
396 | if (!spec->mux_nids[adc_idx]) | 1064 | if (!spec->mux_nids[adc_idx]) |
397 | return -EINVAL; | 1065 | return -EINVAL; |
1066 | /* switch to D0 beofre change index */ | ||
1067 | if (snd_hda_codec_read(codec, spec->mux_nids[adc_idx], 0, | ||
1068 | AC_VERB_GET_POWER_STATE, 0x00) != AC_PWRST_D0) | ||
1069 | snd_hda_codec_write(codec, spec->mux_nids[adc_idx], 0, | ||
1070 | AC_VERB_SET_POWER_STATE, AC_PWRST_D0); | ||
1071 | /* update jack power state */ | ||
1072 | set_jack_power_state(codec); | ||
1073 | |||
398 | return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol, | 1074 | return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol, |
399 | spec->mux_nids[adc_idx], | 1075 | spec->mux_nids[adc_idx], |
400 | &spec->cur_mux[adc_idx]); | 1076 | &spec->cur_mux[adc_idx]); |
@@ -413,16 +1089,74 @@ static int via_independent_hp_get(struct snd_kcontrol *kcontrol, | |||
413 | { | 1089 | { |
414 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | 1090 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); |
415 | struct via_spec *spec = codec->spec; | 1091 | struct via_spec *spec = codec->spec; |
416 | hda_nid_t nid = spec->autocfg.hp_pins[0]; | 1092 | hda_nid_t nid; |
417 | unsigned int pinsel = snd_hda_codec_read(codec, nid, 0, | 1093 | unsigned int pinsel; |
418 | AC_VERB_GET_CONNECT_SEL, | 1094 | |
419 | 0x00); | 1095 | switch (spec->codec_type) { |
420 | 1096 | case VT1718S: | |
1097 | nid = 0x34; | ||
1098 | break; | ||
1099 | case VT2002P: | ||
1100 | nid = 0x35; | ||
1101 | break; | ||
1102 | case VT1812: | ||
1103 | nid = 0x3d; | ||
1104 | break; | ||
1105 | default: | ||
1106 | nid = spec->autocfg.hp_pins[0]; | ||
1107 | break; | ||
1108 | } | ||
1109 | /* use !! to translate conn sel 2 for VT1718S */ | ||
1110 | pinsel = !!snd_hda_codec_read(codec, nid, 0, | ||
1111 | AC_VERB_GET_CONNECT_SEL, | ||
1112 | 0x00); | ||
421 | ucontrol->value.enumerated.item[0] = pinsel; | 1113 | ucontrol->value.enumerated.item[0] = pinsel; |
422 | 1114 | ||
423 | return 0; | 1115 | return 0; |
424 | } | 1116 | } |
425 | 1117 | ||
1118 | static void activate_ctl(struct hda_codec *codec, const char *name, int active) | ||
1119 | { | ||
1120 | struct snd_kcontrol *ctl = snd_hda_find_mixer_ctl(codec, name); | ||
1121 | if (ctl) { | ||
1122 | ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE; | ||
1123 | ctl->vd[0].access |= active | ||
1124 | ? 0 : SNDRV_CTL_ELEM_ACCESS_INACTIVE; | ||
1125 | snd_ctl_notify(codec->bus->card, | ||
1126 | SNDRV_CTL_EVENT_MASK_VALUE, &ctl->id); | ||
1127 | } | ||
1128 | } | ||
1129 | |||
1130 | static int update_side_mute_status(struct hda_codec *codec) | ||
1131 | { | ||
1132 | /* mute side channel */ | ||
1133 | struct via_spec *spec = codec->spec; | ||
1134 | unsigned int parm = spec->hp_independent_mode | ||
1135 | ? AMP_OUT_MUTE : AMP_OUT_UNMUTE; | ||
1136 | hda_nid_t sw3; | ||
1137 | |||
1138 | switch (spec->codec_type) { | ||
1139 | case VT1708: | ||
1140 | sw3 = 0x1b; | ||
1141 | break; | ||
1142 | case VT1709_10CH: | ||
1143 | sw3 = 0x29; | ||
1144 | break; | ||
1145 | case VT1708B_8CH: | ||
1146 | case VT1708S: | ||
1147 | sw3 = 0x27; | ||
1148 | break; | ||
1149 | default: | ||
1150 | sw3 = 0; | ||
1151 | break; | ||
1152 | } | ||
1153 | |||
1154 | if (sw3) | ||
1155 | snd_hda_codec_write(codec, sw3, 0, AC_VERB_SET_AMP_GAIN_MUTE, | ||
1156 | parm); | ||
1157 | return 0; | ||
1158 | } | ||
1159 | |||
426 | static int via_independent_hp_put(struct snd_kcontrol *kcontrol, | 1160 | static int via_independent_hp_put(struct snd_kcontrol *kcontrol, |
427 | struct snd_ctl_elem_value *ucontrol) | 1161 | struct snd_ctl_elem_value *ucontrol) |
428 | { | 1162 | { |
@@ -430,47 +1164,46 @@ static int via_independent_hp_put(struct snd_kcontrol *kcontrol, | |||
430 | struct via_spec *spec = codec->spec; | 1164 | struct via_spec *spec = codec->spec; |
431 | hda_nid_t nid = spec->autocfg.hp_pins[0]; | 1165 | hda_nid_t nid = spec->autocfg.hp_pins[0]; |
432 | unsigned int pinsel = ucontrol->value.enumerated.item[0]; | 1166 | unsigned int pinsel = ucontrol->value.enumerated.item[0]; |
433 | unsigned int con_nid = snd_hda_codec_read(codec, nid, 0, | 1167 | /* Get Independent Mode index of headphone pin widget */ |
434 | AC_VERB_GET_CONNECT_LIST, 0) & 0xff; | 1168 | spec->hp_independent_mode = spec->hp_independent_mode_index == pinsel |
435 | 1169 | ? 1 : 0; | |
436 | if (con_nid == spec->multiout.hp_nid) { | 1170 | |
437 | if (pinsel == 0) { | 1171 | switch (spec->codec_type) { |
438 | if (!spec->hp_independent_mode) { | 1172 | case VT1718S: |
439 | if (spec->multiout.num_dacs > 1) | 1173 | nid = 0x34; |
440 | spec->multiout.num_dacs -= 1; | 1174 | pinsel = pinsel ? 2 : 0; /* indep HP use AOW4 (index 2) */ |
441 | spec->hp_independent_mode = 1; | 1175 | spec->multiout.num_dacs = 4; |
442 | } | 1176 | break; |
443 | } else if (pinsel == 1) { | 1177 | case VT2002P: |
444 | if (spec->hp_independent_mode) { | 1178 | nid = 0x35; |
445 | if (spec->multiout.num_dacs > 1) | 1179 | break; |
446 | spec->multiout.num_dacs += 1; | 1180 | case VT1812: |
447 | spec->hp_independent_mode = 0; | 1181 | nid = 0x3d; |
448 | } | 1182 | break; |
449 | } | 1183 | default: |
450 | } else { | 1184 | nid = spec->autocfg.hp_pins[0]; |
451 | if (pinsel == 0) { | 1185 | break; |
452 | if (spec->hp_independent_mode) { | 1186 | } |
453 | if (spec->multiout.num_dacs > 1) | 1187 | snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, pinsel); |
454 | spec->multiout.num_dacs += 1; | 1188 | |
455 | spec->hp_independent_mode = 0; | 1189 | if (spec->multiout.hp_nid && spec->multiout.hp_nid |
456 | } | 1190 | != spec->multiout.dac_nids[HDA_FRONT]) |
457 | } else if (pinsel == 1) { | 1191 | snd_hda_codec_setup_stream(codec, spec->multiout.hp_nid, |
458 | if (!spec->hp_independent_mode) { | 1192 | 0, 0, 0); |
459 | if (spec->multiout.num_dacs > 1) | 1193 | |
460 | spec->multiout.num_dacs -= 1; | 1194 | update_side_mute_status(codec); |
461 | spec->hp_independent_mode = 1; | 1195 | /* update HP volume/swtich active state */ |
462 | } | 1196 | if (spec->codec_type == VT1708S |
463 | } | 1197 | || spec->codec_type == VT1702 |
1198 | || spec->codec_type == VT1718S | ||
1199 | || spec->codec_type == VT1716S | ||
1200 | || spec->codec_type == VT2002P | ||
1201 | || spec->codec_type == VT1812) { | ||
1202 | activate_ctl(codec, "Headphone Playback Volume", | ||
1203 | spec->hp_independent_mode); | ||
1204 | activate_ctl(codec, "Headphone Playback Switch", | ||
1205 | spec->hp_independent_mode); | ||
464 | } | 1206 | } |
465 | snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, | ||
466 | pinsel); | ||
467 | |||
468 | if (spec->multiout.hp_nid && | ||
469 | spec->multiout.hp_nid != spec->multiout.dac_nids[HDA_FRONT]) | ||
470 | snd_hda_codec_setup_stream(codec, | ||
471 | spec->multiout.hp_nid, | ||
472 | 0, 0, 0); | ||
473 | |||
474 | return 0; | 1207 | return 0; |
475 | } | 1208 | } |
476 | 1209 | ||
@@ -486,6 +1219,175 @@ static struct snd_kcontrol_new via_hp_mixer[] = { | |||
486 | { } /* end */ | 1219 | { } /* end */ |
487 | }; | 1220 | }; |
488 | 1221 | ||
1222 | static void notify_aa_path_ctls(struct hda_codec *codec) | ||
1223 | { | ||
1224 | int i; | ||
1225 | struct snd_ctl_elem_id id; | ||
1226 | const char *labels[] = {"Mic", "Front Mic", "Line"}; | ||
1227 | |||
1228 | memset(&id, 0, sizeof(id)); | ||
1229 | id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; | ||
1230 | for (i = 0; i < ARRAY_SIZE(labels); i++) { | ||
1231 | sprintf(id.name, "%s Playback Volume", labels[i]); | ||
1232 | snd_ctl_notify(codec->bus->card, SNDRV_CTL_EVENT_MASK_VALUE, | ||
1233 | &id); | ||
1234 | } | ||
1235 | } | ||
1236 | |||
1237 | static void mute_aa_path(struct hda_codec *codec, int mute) | ||
1238 | { | ||
1239 | struct via_spec *spec = codec->spec; | ||
1240 | hda_nid_t nid_mixer; | ||
1241 | int start_idx; | ||
1242 | int end_idx; | ||
1243 | int i; | ||
1244 | /* get nid of MW0 and start & end index */ | ||
1245 | switch (spec->codec_type) { | ||
1246 | case VT1708: | ||
1247 | nid_mixer = 0x17; | ||
1248 | start_idx = 2; | ||
1249 | end_idx = 4; | ||
1250 | break; | ||
1251 | case VT1709_10CH: | ||
1252 | case VT1709_6CH: | ||
1253 | nid_mixer = 0x18; | ||
1254 | start_idx = 2; | ||
1255 | end_idx = 4; | ||
1256 | break; | ||
1257 | case VT1708B_8CH: | ||
1258 | case VT1708B_4CH: | ||
1259 | case VT1708S: | ||
1260 | case VT1716S: | ||
1261 | nid_mixer = 0x16; | ||
1262 | start_idx = 2; | ||
1263 | end_idx = 4; | ||
1264 | break; | ||
1265 | default: | ||
1266 | return; | ||
1267 | } | ||
1268 | /* check AA path's mute status */ | ||
1269 | for (i = start_idx; i <= end_idx; i++) { | ||
1270 | int val = mute ? HDA_AMP_MUTE : HDA_AMP_UNMUTE; | ||
1271 | snd_hda_codec_amp_stereo(codec, nid_mixer, HDA_INPUT, i, | ||
1272 | HDA_AMP_MUTE, val); | ||
1273 | } | ||
1274 | } | ||
1275 | static int is_smart51_pins(struct via_spec *spec, hda_nid_t pin) | ||
1276 | { | ||
1277 | int res = 0; | ||
1278 | int index; | ||
1279 | for (index = AUTO_PIN_MIC; index < AUTO_PIN_FRONT_LINE; index++) { | ||
1280 | if (pin == spec->autocfg.input_pins[index]) { | ||
1281 | res = 1; | ||
1282 | break; | ||
1283 | } | ||
1284 | } | ||
1285 | return res; | ||
1286 | } | ||
1287 | |||
1288 | static int via_smart51_info(struct snd_kcontrol *kcontrol, | ||
1289 | struct snd_ctl_elem_info *uinfo) | ||
1290 | { | ||
1291 | uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; | ||
1292 | uinfo->count = 1; | ||
1293 | uinfo->value.integer.min = 0; | ||
1294 | uinfo->value.integer.max = 1; | ||
1295 | return 0; | ||
1296 | } | ||
1297 | |||
1298 | static int via_smart51_get(struct snd_kcontrol *kcontrol, | ||
1299 | struct snd_ctl_elem_value *ucontrol) | ||
1300 | { | ||
1301 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | ||
1302 | struct via_spec *spec = codec->spec; | ||
1303 | int index[] = { AUTO_PIN_MIC, AUTO_PIN_FRONT_MIC, AUTO_PIN_LINE }; | ||
1304 | int on = 1; | ||
1305 | int i; | ||
1306 | |||
1307 | for (i = 0; i < ARRAY_SIZE(index); i++) { | ||
1308 | hda_nid_t nid = spec->autocfg.input_pins[index[i]]; | ||
1309 | if (nid) { | ||
1310 | int ctl = | ||
1311 | snd_hda_codec_read(codec, nid, 0, | ||
1312 | AC_VERB_GET_PIN_WIDGET_CONTROL, | ||
1313 | 0); | ||
1314 | if (i == AUTO_PIN_FRONT_MIC | ||
1315 | && spec->hp_independent_mode | ||
1316 | && spec->codec_type != VT1718S) | ||
1317 | continue; /* ignore FMic for independent HP */ | ||
1318 | if (ctl & AC_PINCTL_IN_EN | ||
1319 | && !(ctl & AC_PINCTL_OUT_EN)) | ||
1320 | on = 0; | ||
1321 | } | ||
1322 | } | ||
1323 | *ucontrol->value.integer.value = on; | ||
1324 | return 0; | ||
1325 | } | ||
1326 | |||
1327 | static int via_smart51_put(struct snd_kcontrol *kcontrol, | ||
1328 | struct snd_ctl_elem_value *ucontrol) | ||
1329 | { | ||
1330 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | ||
1331 | struct via_spec *spec = codec->spec; | ||
1332 | int out_in = *ucontrol->value.integer.value | ||
1333 | ? AC_PINCTL_OUT_EN : AC_PINCTL_IN_EN; | ||
1334 | int index[] = { AUTO_PIN_MIC, AUTO_PIN_FRONT_MIC, AUTO_PIN_LINE }; | ||
1335 | int i; | ||
1336 | |||
1337 | for (i = 0; i < ARRAY_SIZE(index); i++) { | ||
1338 | hda_nid_t nid = spec->autocfg.input_pins[index[i]]; | ||
1339 | if (i == AUTO_PIN_FRONT_MIC | ||
1340 | && spec->hp_independent_mode | ||
1341 | && spec->codec_type != VT1718S) | ||
1342 | continue; /* don't retask FMic for independent HP */ | ||
1343 | if (nid) { | ||
1344 | unsigned int parm = snd_hda_codec_read( | ||
1345 | codec, nid, 0, | ||
1346 | AC_VERB_GET_PIN_WIDGET_CONTROL, 0); | ||
1347 | parm &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN); | ||
1348 | parm |= out_in; | ||
1349 | snd_hda_codec_write(codec, nid, 0, | ||
1350 | AC_VERB_SET_PIN_WIDGET_CONTROL, | ||
1351 | parm); | ||
1352 | if (out_in == AC_PINCTL_OUT_EN) { | ||
1353 | mute_aa_path(codec, 1); | ||
1354 | notify_aa_path_ctls(codec); | ||
1355 | } | ||
1356 | if (spec->codec_type == VT1718S) | ||
1357 | snd_hda_codec_amp_stereo( | ||
1358 | codec, nid, HDA_OUTPUT, 0, HDA_AMP_MUTE, | ||
1359 | HDA_AMP_UNMUTE); | ||
1360 | } | ||
1361 | if (i == AUTO_PIN_FRONT_MIC) { | ||
1362 | if (spec->codec_type == VT1708S | ||
1363 | || spec->codec_type == VT1716S) { | ||
1364 | /* input = index 1 (AOW3) */ | ||
1365 | snd_hda_codec_write( | ||
1366 | codec, nid, 0, | ||
1367 | AC_VERB_SET_CONNECT_SEL, 1); | ||
1368 | snd_hda_codec_amp_stereo( | ||
1369 | codec, nid, HDA_OUTPUT, | ||
1370 | 0, HDA_AMP_MUTE, HDA_AMP_UNMUTE); | ||
1371 | } | ||
1372 | } | ||
1373 | } | ||
1374 | spec->smart51_enabled = *ucontrol->value.integer.value; | ||
1375 | set_jack_power_state(codec); | ||
1376 | return 1; | ||
1377 | } | ||
1378 | |||
1379 | static struct snd_kcontrol_new via_smart51_mixer[] = { | ||
1380 | { | ||
1381 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
1382 | .name = "Smart 5.1", | ||
1383 | .count = 1, | ||
1384 | .info = via_smart51_info, | ||
1385 | .get = via_smart51_get, | ||
1386 | .put = via_smart51_put, | ||
1387 | }, | ||
1388 | {} /* end */ | ||
1389 | }; | ||
1390 | |||
489 | /* capture mixer elements */ | 1391 | /* capture mixer elements */ |
490 | static struct snd_kcontrol_new vt1708_capture_mixer[] = { | 1392 | static struct snd_kcontrol_new vt1708_capture_mixer[] = { |
491 | HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_INPUT), | 1393 | HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_INPUT), |
@@ -506,6 +1408,112 @@ static struct snd_kcontrol_new vt1708_capture_mixer[] = { | |||
506 | }, | 1408 | }, |
507 | { } /* end */ | 1409 | { } /* end */ |
508 | }; | 1410 | }; |
1411 | |||
1412 | /* check AA path's mute statue */ | ||
1413 | static int is_aa_path_mute(struct hda_codec *codec) | ||
1414 | { | ||
1415 | int mute = 1; | ||
1416 | hda_nid_t nid_mixer; | ||
1417 | int start_idx; | ||
1418 | int end_idx; | ||
1419 | int i; | ||
1420 | struct via_spec *spec = codec->spec; | ||
1421 | /* get nid of MW0 and start & end index */ | ||
1422 | switch (spec->codec_type) { | ||
1423 | case VT1708B_8CH: | ||
1424 | case VT1708B_4CH: | ||
1425 | case VT1708S: | ||
1426 | case VT1716S: | ||
1427 | nid_mixer = 0x16; | ||
1428 | start_idx = 2; | ||
1429 | end_idx = 4; | ||
1430 | break; | ||
1431 | case VT1702: | ||
1432 | nid_mixer = 0x1a; | ||
1433 | start_idx = 1; | ||
1434 | end_idx = 3; | ||
1435 | break; | ||
1436 | case VT1718S: | ||
1437 | nid_mixer = 0x21; | ||
1438 | start_idx = 1; | ||
1439 | end_idx = 3; | ||
1440 | break; | ||
1441 | case VT2002P: | ||
1442 | case VT1812: | ||
1443 | nid_mixer = 0x21; | ||
1444 | start_idx = 0; | ||
1445 | end_idx = 2; | ||
1446 | break; | ||
1447 | default: | ||
1448 | return 0; | ||
1449 | } | ||
1450 | /* check AA path's mute status */ | ||
1451 | for (i = start_idx; i <= end_idx; i++) { | ||
1452 | unsigned int con_list = snd_hda_codec_read( | ||
1453 | codec, nid_mixer, 0, AC_VERB_GET_CONNECT_LIST, i/4*4); | ||
1454 | int shift = 8 * (i % 4); | ||
1455 | hda_nid_t nid_pin = (con_list & (0xff << shift)) >> shift; | ||
1456 | unsigned int defconf = snd_hda_codec_get_pincfg(codec, nid_pin); | ||
1457 | if (get_defcfg_connect(defconf) == AC_JACK_PORT_COMPLEX) { | ||
1458 | /* check mute status while the pin is connected */ | ||
1459 | int mute_l = snd_hda_codec_amp_read(codec, nid_mixer, 0, | ||
1460 | HDA_INPUT, i) >> 7; | ||
1461 | int mute_r = snd_hda_codec_amp_read(codec, nid_mixer, 1, | ||
1462 | HDA_INPUT, i) >> 7; | ||
1463 | if (!mute_l || !mute_r) { | ||
1464 | mute = 0; | ||
1465 | break; | ||
1466 | } | ||
1467 | } | ||
1468 | } | ||
1469 | return mute; | ||
1470 | } | ||
1471 | |||
1472 | /* enter/exit analog low-current mode */ | ||
1473 | static void analog_low_current_mode(struct hda_codec *codec, int stream_idle) | ||
1474 | { | ||
1475 | struct via_spec *spec = codec->spec; | ||
1476 | static int saved_stream_idle = 1; /* saved stream idle status */ | ||
1477 | int enable = is_aa_path_mute(codec); | ||
1478 | unsigned int verb = 0; | ||
1479 | unsigned int parm = 0; | ||
1480 | |||
1481 | if (stream_idle == -1) /* stream status did not change */ | ||
1482 | enable = enable && saved_stream_idle; | ||
1483 | else { | ||
1484 | enable = enable && stream_idle; | ||
1485 | saved_stream_idle = stream_idle; | ||
1486 | } | ||
1487 | |||
1488 | /* decide low current mode's verb & parameter */ | ||
1489 | switch (spec->codec_type) { | ||
1490 | case VT1708B_8CH: | ||
1491 | case VT1708B_4CH: | ||
1492 | verb = 0xf70; | ||
1493 | parm = enable ? 0x02 : 0x00; /* 0x02: 2/3x, 0x00: 1x */ | ||
1494 | break; | ||
1495 | case VT1708S: | ||
1496 | case VT1718S: | ||
1497 | case VT1716S: | ||
1498 | verb = 0xf73; | ||
1499 | parm = enable ? 0x51 : 0xe1; /* 0x51: 4/28x, 0xe1: 1x */ | ||
1500 | break; | ||
1501 | case VT1702: | ||
1502 | verb = 0xf73; | ||
1503 | parm = enable ? 0x01 : 0x1d; /* 0x01: 4/40x, 0x1d: 1x */ | ||
1504 | break; | ||
1505 | case VT2002P: | ||
1506 | case VT1812: | ||
1507 | verb = 0xf93; | ||
1508 | parm = enable ? 0x00 : 0xe0; /* 0x00: 4/40x, 0xe0: 1x */ | ||
1509 | break; | ||
1510 | default: | ||
1511 | return; /* other codecs are not supported */ | ||
1512 | } | ||
1513 | /* send verb */ | ||
1514 | snd_hda_codec_write(codec, codec->afg, 0, verb, parm); | ||
1515 | } | ||
1516 | |||
509 | /* | 1517 | /* |
510 | * generic initialization of ADC, input mixers and output mixers | 1518 | * generic initialization of ADC, input mixers and output mixers |
511 | */ | 1519 | */ |
@@ -534,9 +1542,9 @@ static struct hda_verb vt1708_volume_init_verbs[] = { | |||
534 | {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, | 1542 | {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, |
535 | {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, | 1543 | {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, |
536 | {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, | 1544 | {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, |
537 | 1545 | ||
538 | /* Setup default input to PW4 */ | 1546 | /* Setup default input MW0 to PW4 */ |
539 | {0x20, AC_VERB_SET_CONNECT_SEL, 0x1}, | 1547 | {0x20, AC_VERB_SET_CONNECT_SEL, 0}, |
540 | /* PW9 Output enable */ | 1548 | /* PW9 Output enable */ |
541 | {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, | 1549 | {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, |
542 | { } | 1550 | { } |
@@ -547,30 +1555,13 @@ static int via_playback_pcm_open(struct hda_pcm_stream *hinfo, | |||
547 | struct snd_pcm_substream *substream) | 1555 | struct snd_pcm_substream *substream) |
548 | { | 1556 | { |
549 | struct via_spec *spec = codec->spec; | 1557 | struct via_spec *spec = codec->spec; |
1558 | int idle = substream->pstr->substream_opened == 1 | ||
1559 | && substream->ref_count == 0; | ||
1560 | analog_low_current_mode(codec, idle); | ||
550 | return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream, | 1561 | return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream, |
551 | hinfo); | 1562 | hinfo); |
552 | } | 1563 | } |
553 | 1564 | ||
554 | static int via_playback_pcm_prepare(struct hda_pcm_stream *hinfo, | ||
555 | struct hda_codec *codec, | ||
556 | unsigned int stream_tag, | ||
557 | unsigned int format, | ||
558 | struct snd_pcm_substream *substream) | ||
559 | { | ||
560 | struct via_spec *spec = codec->spec; | ||
561 | return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, | ||
562 | stream_tag, format, substream); | ||
563 | } | ||
564 | |||
565 | static int via_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, | ||
566 | struct hda_codec *codec, | ||
567 | struct snd_pcm_substream *substream) | ||
568 | { | ||
569 | struct via_spec *spec = codec->spec; | ||
570 | return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); | ||
571 | } | ||
572 | |||
573 | |||
574 | static void playback_multi_pcm_prep_0(struct hda_codec *codec, | 1565 | static void playback_multi_pcm_prep_0(struct hda_codec *codec, |
575 | unsigned int stream_tag, | 1566 | unsigned int stream_tag, |
576 | unsigned int format, | 1567 | unsigned int format, |
@@ -615,8 +1606,8 @@ static void playback_multi_pcm_prep_0(struct hda_codec *codec, | |||
615 | snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag, | 1606 | snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag, |
616 | 0, format); | 1607 | 0, format); |
617 | 1608 | ||
618 | if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] && | 1609 | if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] |
619 | !spec->hp_independent_mode) | 1610 | && !spec->hp_independent_mode) |
620 | /* headphone out will just decode front left/right (stereo) */ | 1611 | /* headphone out will just decode front left/right (stereo) */ |
621 | snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag, | 1612 | snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag, |
622 | 0, format); | 1613 | 0, format); |
@@ -658,7 +1649,7 @@ static int via_playback_multi_pcm_prepare(struct hda_pcm_stream *hinfo, | |||
658 | snd_hda_codec_setup_stream(codec, mout->hp_nid, | 1649 | snd_hda_codec_setup_stream(codec, mout->hp_nid, |
659 | stream_tag, 0, format); | 1650 | stream_tag, 0, format); |
660 | } | 1651 | } |
661 | 1652 | vt1708_start_hp_work(spec); | |
662 | return 0; | 1653 | return 0; |
663 | } | 1654 | } |
664 | 1655 | ||
@@ -698,7 +1689,7 @@ static int via_playback_multi_pcm_cleanup(struct hda_pcm_stream *hinfo, | |||
698 | snd_hda_codec_setup_stream(codec, mout->hp_nid, | 1689 | snd_hda_codec_setup_stream(codec, mout->hp_nid, |
699 | 0, 0, 0); | 1690 | 0, 0, 0); |
700 | } | 1691 | } |
701 | 1692 | vt1708_stop_hp_work(spec); | |
702 | return 0; | 1693 | return 0; |
703 | } | 1694 | } |
704 | 1695 | ||
@@ -779,7 +1770,7 @@ static struct hda_pcm_stream vt1708_pcm_analog_playback = { | |||
779 | }; | 1770 | }; |
780 | 1771 | ||
781 | static struct hda_pcm_stream vt1708_pcm_analog_s16_playback = { | 1772 | static struct hda_pcm_stream vt1708_pcm_analog_s16_playback = { |
782 | .substreams = 1, | 1773 | .substreams = 2, |
783 | .channels_min = 2, | 1774 | .channels_min = 2, |
784 | .channels_max = 8, | 1775 | .channels_max = 8, |
785 | .nid = 0x10, /* NID to query formats and rates */ | 1776 | .nid = 0x10, /* NID to query formats and rates */ |
@@ -790,8 +1781,8 @@ static struct hda_pcm_stream vt1708_pcm_analog_s16_playback = { | |||
790 | .formats = SNDRV_PCM_FMTBIT_S16_LE, | 1781 | .formats = SNDRV_PCM_FMTBIT_S16_LE, |
791 | .ops = { | 1782 | .ops = { |
792 | .open = via_playback_pcm_open, | 1783 | .open = via_playback_pcm_open, |
793 | .prepare = via_playback_pcm_prepare, | 1784 | .prepare = via_playback_multi_pcm_prepare, |
794 | .cleanup = via_playback_pcm_cleanup | 1785 | .cleanup = via_playback_multi_pcm_cleanup |
795 | }, | 1786 | }, |
796 | }; | 1787 | }; |
797 | 1788 | ||
@@ -853,6 +1844,11 @@ static int via_build_controls(struct hda_codec *codec) | |||
853 | if (err < 0) | 1844 | if (err < 0) |
854 | return err; | 1845 | return err; |
855 | } | 1846 | } |
1847 | |||
1848 | /* init power states */ | ||
1849 | set_jack_power_state(codec); | ||
1850 | analog_low_current_mode(codec, 1); | ||
1851 | |||
856 | via_free_kctls(codec); /* no longer needed */ | 1852 | via_free_kctls(codec); /* no longer needed */ |
857 | return 0; | 1853 | return 0; |
858 | } | 1854 | } |
@@ -866,8 +1862,10 @@ static int via_build_pcms(struct hda_codec *codec) | |||
866 | codec->pcm_info = info; | 1862 | codec->pcm_info = info; |
867 | 1863 | ||
868 | info->name = spec->stream_name_analog; | 1864 | info->name = spec->stream_name_analog; |
869 | info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback); | 1865 | info->stream[SNDRV_PCM_STREAM_PLAYBACK] = |
870 | info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0]; | 1866 | *(spec->stream_analog_playback); |
1867 | info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = | ||
1868 | spec->multiout.dac_nids[0]; | ||
871 | info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture); | 1869 | info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture); |
872 | info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0]; | 1870 | info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0]; |
873 | 1871 | ||
@@ -904,20 +1902,58 @@ static void via_free(struct hda_codec *codec) | |||
904 | return; | 1902 | return; |
905 | 1903 | ||
906 | via_free_kctls(codec); | 1904 | via_free_kctls(codec); |
1905 | vt1708_stop_hp_work(spec); | ||
907 | kfree(codec->spec); | 1906 | kfree(codec->spec); |
908 | } | 1907 | } |
909 | 1908 | ||
910 | /* mute internal speaker if HP is plugged */ | 1909 | /* mute internal speaker if HP is plugged */ |
911 | static void via_hp_automute(struct hda_codec *codec) | 1910 | static void via_hp_automute(struct hda_codec *codec) |
912 | { | 1911 | { |
913 | unsigned int present; | 1912 | unsigned int present = 0; |
914 | struct via_spec *spec = codec->spec; | 1913 | struct via_spec *spec = codec->spec; |
915 | 1914 | ||
916 | present = snd_hda_codec_read(codec, spec->autocfg.hp_pins[0], 0, | 1915 | present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]); |
917 | AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; | 1916 | |
918 | snd_hda_codec_amp_stereo(codec, spec->autocfg.line_out_pins[0], | 1917 | if (!spec->hp_independent_mode) { |
919 | HDA_OUTPUT, 0, HDA_AMP_MUTE, | 1918 | struct snd_ctl_elem_id id; |
920 | present ? HDA_AMP_MUTE : 0); | 1919 | /* auto mute */ |
1920 | snd_hda_codec_amp_stereo( | ||
1921 | codec, spec->autocfg.line_out_pins[0], HDA_OUTPUT, 0, | ||
1922 | HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); | ||
1923 | /* notify change */ | ||
1924 | memset(&id, 0, sizeof(id)); | ||
1925 | id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; | ||
1926 | strcpy(id.name, "Front Playback Switch"); | ||
1927 | snd_ctl_notify(codec->bus->card, SNDRV_CTL_EVENT_MASK_VALUE, | ||
1928 | &id); | ||
1929 | } | ||
1930 | } | ||
1931 | |||
1932 | /* mute mono out if HP or Line out is plugged */ | ||
1933 | static void via_mono_automute(struct hda_codec *codec) | ||
1934 | { | ||
1935 | unsigned int hp_present, lineout_present; | ||
1936 | struct via_spec *spec = codec->spec; | ||
1937 | |||
1938 | if (spec->codec_type != VT1716S) | ||
1939 | return; | ||
1940 | |||
1941 | lineout_present = snd_hda_jack_detect(codec, | ||
1942 | spec->autocfg.line_out_pins[0]); | ||
1943 | |||
1944 | /* Mute Mono Out if Line Out is plugged */ | ||
1945 | if (lineout_present) { | ||
1946 | snd_hda_codec_amp_stereo( | ||
1947 | codec, 0x2A, HDA_OUTPUT, 0, HDA_AMP_MUTE, HDA_AMP_MUTE); | ||
1948 | return; | ||
1949 | } | ||
1950 | |||
1951 | hp_present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]); | ||
1952 | |||
1953 | if (!spec->hp_independent_mode) | ||
1954 | snd_hda_codec_amp_stereo( | ||
1955 | codec, 0x2A, HDA_OUTPUT, 0, HDA_AMP_MUTE, | ||
1956 | hp_present ? HDA_AMP_MUTE : 0); | ||
921 | } | 1957 | } |
922 | 1958 | ||
923 | static void via_gpio_control(struct hda_codec *codec) | 1959 | static void via_gpio_control(struct hda_codec *codec) |
@@ -968,15 +2004,83 @@ static void via_gpio_control(struct hda_codec *codec) | |||
968 | } | 2004 | } |
969 | } | 2005 | } |
970 | 2006 | ||
2007 | /* mute Internal-Speaker if HP is plugged */ | ||
2008 | static void via_speaker_automute(struct hda_codec *codec) | ||
2009 | { | ||
2010 | unsigned int hp_present; | ||
2011 | struct via_spec *spec = codec->spec; | ||
2012 | |||
2013 | if (spec->codec_type != VT2002P && spec->codec_type != VT1812) | ||
2014 | return; | ||
2015 | |||
2016 | hp_present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]); | ||
2017 | |||
2018 | if (!spec->hp_independent_mode) { | ||
2019 | struct snd_ctl_elem_id id; | ||
2020 | snd_hda_codec_amp_stereo( | ||
2021 | codec, spec->autocfg.speaker_pins[0], HDA_OUTPUT, 0, | ||
2022 | HDA_AMP_MUTE, hp_present ? HDA_AMP_MUTE : 0); | ||
2023 | /* notify change */ | ||
2024 | memset(&id, 0, sizeof(id)); | ||
2025 | id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; | ||
2026 | strcpy(id.name, "Speaker Playback Switch"); | ||
2027 | snd_ctl_notify(codec->bus->card, SNDRV_CTL_EVENT_MASK_VALUE, | ||
2028 | &id); | ||
2029 | } | ||
2030 | } | ||
2031 | |||
2032 | /* mute line-out and internal speaker if HP is plugged */ | ||
2033 | static void via_hp_bind_automute(struct hda_codec *codec) | ||
2034 | { | ||
2035 | /* use long instead of int below just to avoid an internal compiler | ||
2036 | * error with gcc 4.0.x | ||
2037 | */ | ||
2038 | unsigned long hp_present, present = 0; | ||
2039 | struct via_spec *spec = codec->spec; | ||
2040 | int i; | ||
2041 | |||
2042 | if (!spec->autocfg.hp_pins[0] || !spec->autocfg.line_out_pins[0]) | ||
2043 | return; | ||
2044 | |||
2045 | hp_present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]); | ||
2046 | |||
2047 | present = snd_hda_jack_detect(codec, spec->autocfg.line_out_pins[0]); | ||
2048 | |||
2049 | if (!spec->hp_independent_mode) { | ||
2050 | /* Mute Line-Outs */ | ||
2051 | for (i = 0; i < spec->autocfg.line_outs; i++) | ||
2052 | snd_hda_codec_amp_stereo( | ||
2053 | codec, spec->autocfg.line_out_pins[i], | ||
2054 | HDA_OUTPUT, 0, | ||
2055 | HDA_AMP_MUTE, hp_present ? HDA_AMP_MUTE : 0); | ||
2056 | if (hp_present) | ||
2057 | present = hp_present; | ||
2058 | } | ||
2059 | /* Speakers */ | ||
2060 | for (i = 0; i < spec->autocfg.speaker_outs; i++) | ||
2061 | snd_hda_codec_amp_stereo( | ||
2062 | codec, spec->autocfg.speaker_pins[i], HDA_OUTPUT, 0, | ||
2063 | HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); | ||
2064 | } | ||
2065 | |||
2066 | |||
971 | /* unsolicited event for jack sensing */ | 2067 | /* unsolicited event for jack sensing */ |
972 | static void via_unsol_event(struct hda_codec *codec, | 2068 | static void via_unsol_event(struct hda_codec *codec, |
973 | unsigned int res) | 2069 | unsigned int res) |
974 | { | 2070 | { |
975 | res >>= 26; | 2071 | res >>= 26; |
976 | if (res == VIA_HP_EVENT) | 2072 | if (res & VIA_HP_EVENT) |
977 | via_hp_automute(codec); | 2073 | via_hp_automute(codec); |
978 | else if (res == VIA_GPIO_EVENT) | 2074 | if (res & VIA_GPIO_EVENT) |
979 | via_gpio_control(codec); | 2075 | via_gpio_control(codec); |
2076 | if (res & VIA_JACK_EVENT) | ||
2077 | set_jack_power_state(codec); | ||
2078 | if (res & VIA_MONO_EVENT) | ||
2079 | via_mono_automute(codec); | ||
2080 | if (res & VIA_SPEAKER_EVENT) | ||
2081 | via_speaker_automute(codec); | ||
2082 | if (res & VIA_BIND_HP_EVENT) | ||
2083 | via_hp_bind_automute(codec); | ||
980 | } | 2084 | } |
981 | 2085 | ||
982 | static int via_init(struct hda_codec *codec) | 2086 | static int via_init(struct hda_codec *codec) |
@@ -986,6 +2090,10 @@ static int via_init(struct hda_codec *codec) | |||
986 | for (i = 0; i < spec->num_iverbs; i++) | 2090 | for (i = 0; i < spec->num_iverbs; i++) |
987 | snd_hda_sequence_write(codec, spec->init_verbs[i]); | 2091 | snd_hda_sequence_write(codec, spec->init_verbs[i]); |
988 | 2092 | ||
2093 | spec->codec_type = get_codec_type(codec); | ||
2094 | if (spec->codec_type == VT1708BCE) | ||
2095 | spec->codec_type = VT1708S; /* VT1708BCE & VT1708S are almost | ||
2096 | same */ | ||
989 | /* Lydia Add for EAPD enable */ | 2097 | /* Lydia Add for EAPD enable */ |
990 | if (!spec->dig_in_nid) { /* No Digital In connection */ | 2098 | if (!spec->dig_in_nid) { /* No Digital In connection */ |
991 | if (spec->dig_in_pin) { | 2099 | if (spec->dig_in_pin) { |
@@ -1003,8 +2111,17 @@ static int via_init(struct hda_codec *codec) | |||
1003 | if (spec->slave_dig_outs[0]) | 2111 | if (spec->slave_dig_outs[0]) |
1004 | codec->slave_dig_outs = spec->slave_dig_outs; | 2112 | codec->slave_dig_outs = spec->slave_dig_outs; |
1005 | 2113 | ||
1006 | return 0; | 2114 | return 0; |
2115 | } | ||
2116 | |||
2117 | #ifdef SND_HDA_NEEDS_RESUME | ||
2118 | static int via_suspend(struct hda_codec *codec, pm_message_t state) | ||
2119 | { | ||
2120 | struct via_spec *spec = codec->spec; | ||
2121 | vt1708_stop_hp_work(spec); | ||
2122 | return 0; | ||
1007 | } | 2123 | } |
2124 | #endif | ||
1008 | 2125 | ||
1009 | #ifdef CONFIG_SND_HDA_POWER_SAVE | 2126 | #ifdef CONFIG_SND_HDA_POWER_SAVE |
1010 | static int via_check_power_status(struct hda_codec *codec, hda_nid_t nid) | 2127 | static int via_check_power_status(struct hda_codec *codec, hda_nid_t nid) |
@@ -1021,6 +2138,9 @@ static struct hda_codec_ops via_patch_ops = { | |||
1021 | .build_pcms = via_build_pcms, | 2138 | .build_pcms = via_build_pcms, |
1022 | .init = via_init, | 2139 | .init = via_init, |
1023 | .free = via_free, | 2140 | .free = via_free, |
2141 | #ifdef SND_HDA_NEEDS_RESUME | ||
2142 | .suspend = via_suspend, | ||
2143 | #endif | ||
1024 | #ifdef CONFIG_SND_HDA_POWER_SAVE | 2144 | #ifdef CONFIG_SND_HDA_POWER_SAVE |
1025 | .check_power_status = via_check_power_status, | 2145 | .check_power_status = via_check_power_status, |
1026 | #endif | 2146 | #endif |
@@ -1036,8 +2156,8 @@ static int vt1708_auto_fill_dac_nids(struct via_spec *spec, | |||
1036 | spec->multiout.num_dacs = cfg->line_outs; | 2156 | spec->multiout.num_dacs = cfg->line_outs; |
1037 | 2157 | ||
1038 | spec->multiout.dac_nids = spec->private_dac_nids; | 2158 | spec->multiout.dac_nids = spec->private_dac_nids; |
1039 | 2159 | ||
1040 | for(i = 0; i < 4; i++) { | 2160 | for (i = 0; i < 4; i++) { |
1041 | nid = cfg->line_out_pins[i]; | 2161 | nid = cfg->line_out_pins[i]; |
1042 | if (nid) { | 2162 | if (nid) { |
1043 | /* config dac list */ | 2163 | /* config dac list */ |
@@ -1067,7 +2187,7 @@ static int vt1708_auto_create_multi_out_ctls(struct via_spec *spec, | |||
1067 | { | 2187 | { |
1068 | char name[32]; | 2188 | char name[32]; |
1069 | static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" }; | 2189 | static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" }; |
1070 | hda_nid_t nid, nid_vol = 0; | 2190 | hda_nid_t nid, nid_vol, nid_vols[] = {0x17, 0x19, 0x1a, 0x1b}; |
1071 | int i, err; | 2191 | int i, err; |
1072 | 2192 | ||
1073 | for (i = 0; i <= AUTO_SEQ_SIDE; i++) { | 2193 | for (i = 0; i <= AUTO_SEQ_SIDE; i++) { |
@@ -1075,9 +2195,8 @@ static int vt1708_auto_create_multi_out_ctls(struct via_spec *spec, | |||
1075 | 2195 | ||
1076 | if (!nid) | 2196 | if (!nid) |
1077 | continue; | 2197 | continue; |
1078 | 2198 | ||
1079 | if (i != AUTO_SEQ_FRONT) | 2199 | nid_vol = nid_vols[i]; |
1080 | nid_vol = 0x18 + i; | ||
1081 | 2200 | ||
1082 | if (i == AUTO_SEQ_CENLFE) { | 2201 | if (i == AUTO_SEQ_CENLFE) { |
1083 | /* Center/LFE */ | 2202 | /* Center/LFE */ |
@@ -1105,21 +2224,21 @@ static int vt1708_auto_create_multi_out_ctls(struct via_spec *spec, | |||
1105 | HDA_OUTPUT)); | 2224 | HDA_OUTPUT)); |
1106 | if (err < 0) | 2225 | if (err < 0) |
1107 | return err; | 2226 | return err; |
1108 | } else if (i == AUTO_SEQ_FRONT){ | 2227 | } else if (i == AUTO_SEQ_FRONT) { |
1109 | /* add control to mixer index 0 */ | 2228 | /* add control to mixer index 0 */ |
1110 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | 2229 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, |
1111 | "Master Front Playback Volume", | 2230 | "Master Front Playback Volume", |
1112 | HDA_COMPOSE_AMP_VAL(0x17, 3, 0, | 2231 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, |
1113 | HDA_INPUT)); | 2232 | HDA_INPUT)); |
1114 | if (err < 0) | 2233 | if (err < 0) |
1115 | return err; | 2234 | return err; |
1116 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | 2235 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, |
1117 | "Master Front Playback Switch", | 2236 | "Master Front Playback Switch", |
1118 | HDA_COMPOSE_AMP_VAL(0x17, 3, 0, | 2237 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, |
1119 | HDA_INPUT)); | 2238 | HDA_INPUT)); |
1120 | if (err < 0) | 2239 | if (err < 0) |
1121 | return err; | 2240 | return err; |
1122 | 2241 | ||
1123 | /* add control to PW3 */ | 2242 | /* add control to PW3 */ |
1124 | sprintf(name, "%s Playback Volume", chname[i]); | 2243 | sprintf(name, "%s Playback Volume", chname[i]); |
1125 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, | 2244 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, |
@@ -1178,6 +2297,7 @@ static int vt1708_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) | |||
1178 | return 0; | 2297 | return 0; |
1179 | 2298 | ||
1180 | spec->multiout.hp_nid = VT1708_HP_NID; /* AOW3 */ | 2299 | spec->multiout.hp_nid = VT1708_HP_NID; /* AOW3 */ |
2300 | spec->hp_independent_mode_index = 1; | ||
1181 | 2301 | ||
1182 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | 2302 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, |
1183 | "Headphone Playback Volume", | 2303 | "Headphone Playback Volume", |
@@ -1218,7 +2338,7 @@ static int vt1708_auto_create_analog_input_ctls(struct via_spec *spec, | |||
1218 | case 0x1d: /* Mic */ | 2338 | case 0x1d: /* Mic */ |
1219 | idx = 2; | 2339 | idx = 2; |
1220 | break; | 2340 | break; |
1221 | 2341 | ||
1222 | case 0x1e: /* Line In */ | 2342 | case 0x1e: /* Line In */ |
1223 | idx = 3; | 2343 | idx = 3; |
1224 | break; | 2344 | break; |
@@ -1231,8 +2351,7 @@ static int vt1708_auto_create_analog_input_ctls(struct via_spec *spec, | |||
1231 | idx = 1; | 2351 | idx = 1; |
1232 | break; | 2352 | break; |
1233 | } | 2353 | } |
1234 | err = via_new_analog_input(spec, cfg->input_pins[i], labels[i], | 2354 | err = via_new_analog_input(spec, labels[i], idx, 0x17); |
1235 | idx, 0x17); | ||
1236 | if (err < 0) | 2355 | if (err < 0) |
1237 | return err; | 2356 | return err; |
1238 | imux->items[imux->num_items].label = labels[i]; | 2357 | imux->items[imux->num_items].label = labels[i]; |
@@ -1260,16 +2379,60 @@ static void vt1708_set_pinconfig_connect(struct hda_codec *codec, hda_nid_t nid) | |||
1260 | def_conf = snd_hda_codec_get_pincfg(codec, nid); | 2379 | def_conf = snd_hda_codec_get_pincfg(codec, nid); |
1261 | seqassoc = (unsigned char) get_defcfg_association(def_conf); | 2380 | seqassoc = (unsigned char) get_defcfg_association(def_conf); |
1262 | seqassoc = (seqassoc << 4) | get_defcfg_sequence(def_conf); | 2381 | seqassoc = (seqassoc << 4) | get_defcfg_sequence(def_conf); |
1263 | if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE) { | 2382 | if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE |
1264 | if (seqassoc == 0xff) { | 2383 | && (seqassoc == 0xf0 || seqassoc == 0xff)) { |
1265 | def_conf = def_conf & (~(AC_JACK_PORT_BOTH << 30)); | 2384 | def_conf = def_conf & (~(AC_JACK_PORT_BOTH << 30)); |
1266 | snd_hda_codec_set_pincfg(codec, nid, def_conf); | 2385 | snd_hda_codec_set_pincfg(codec, nid, def_conf); |
1267 | } | ||
1268 | } | 2386 | } |
1269 | 2387 | ||
1270 | return; | 2388 | return; |
1271 | } | 2389 | } |
1272 | 2390 | ||
2391 | static int vt1708_jack_detectect_get(struct snd_kcontrol *kcontrol, | ||
2392 | struct snd_ctl_elem_value *ucontrol) | ||
2393 | { | ||
2394 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | ||
2395 | struct via_spec *spec = codec->spec; | ||
2396 | |||
2397 | if (spec->codec_type != VT1708) | ||
2398 | return 0; | ||
2399 | spec->vt1708_jack_detectect = | ||
2400 | !((snd_hda_codec_read(codec, 0x1, 0, 0xf84, 0) >> 8) & 0x1); | ||
2401 | ucontrol->value.integer.value[0] = spec->vt1708_jack_detectect; | ||
2402 | return 0; | ||
2403 | } | ||
2404 | |||
2405 | static int vt1708_jack_detectect_put(struct snd_kcontrol *kcontrol, | ||
2406 | struct snd_ctl_elem_value *ucontrol) | ||
2407 | { | ||
2408 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | ||
2409 | struct via_spec *spec = codec->spec; | ||
2410 | int change; | ||
2411 | |||
2412 | if (spec->codec_type != VT1708) | ||
2413 | return 0; | ||
2414 | spec->vt1708_jack_detectect = ucontrol->value.integer.value[0]; | ||
2415 | change = (0x1 & (snd_hda_codec_read(codec, 0x1, 0, 0xf84, 0) >> 8)) | ||
2416 | == !spec->vt1708_jack_detectect; | ||
2417 | if (spec->vt1708_jack_detectect) { | ||
2418 | mute_aa_path(codec, 1); | ||
2419 | notify_aa_path_ctls(codec); | ||
2420 | } | ||
2421 | return change; | ||
2422 | } | ||
2423 | |||
2424 | static struct snd_kcontrol_new vt1708_jack_detectect[] = { | ||
2425 | { | ||
2426 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
2427 | .name = "Jack Detect", | ||
2428 | .count = 1, | ||
2429 | .info = snd_ctl_boolean_mono_info, | ||
2430 | .get = vt1708_jack_detectect_get, | ||
2431 | .put = vt1708_jack_detectect_put, | ||
2432 | }, | ||
2433 | {} /* end */ | ||
2434 | }; | ||
2435 | |||
1273 | static int vt1708_parse_auto_config(struct hda_codec *codec) | 2436 | static int vt1708_parse_auto_config(struct hda_codec *codec) |
1274 | { | 2437 | { |
1275 | struct via_spec *spec = codec->spec; | 2438 | struct via_spec *spec = codec->spec; |
@@ -1297,6 +2460,10 @@ static int vt1708_parse_auto_config(struct hda_codec *codec) | |||
1297 | err = vt1708_auto_create_analog_input_ctls(spec, &spec->autocfg); | 2460 | err = vt1708_auto_create_analog_input_ctls(spec, &spec->autocfg); |
1298 | if (err < 0) | 2461 | if (err < 0) |
1299 | return err; | 2462 | return err; |
2463 | /* add jack detect on/off control */ | ||
2464 | err = snd_hda_add_new_ctls(codec, vt1708_jack_detectect); | ||
2465 | if (err < 0) | ||
2466 | return err; | ||
1300 | 2467 | ||
1301 | spec->multiout.max_channels = spec->multiout.num_dacs * 2; | 2468 | spec->multiout.max_channels = spec->multiout.num_dacs * 2; |
1302 | 2469 | ||
@@ -1316,19 +2483,44 @@ static int vt1708_parse_auto_config(struct hda_codec *codec) | |||
1316 | if (spec->hp_mux) | 2483 | if (spec->hp_mux) |
1317 | spec->mixers[spec->num_mixers++] = via_hp_mixer; | 2484 | spec->mixers[spec->num_mixers++] = via_hp_mixer; |
1318 | 2485 | ||
2486 | spec->mixers[spec->num_mixers++] = via_smart51_mixer; | ||
1319 | return 1; | 2487 | return 1; |
1320 | } | 2488 | } |
1321 | 2489 | ||
1322 | /* init callback for auto-configuration model -- overriding the default init */ | 2490 | /* init callback for auto-configuration model -- overriding the default init */ |
1323 | static int via_auto_init(struct hda_codec *codec) | 2491 | static int via_auto_init(struct hda_codec *codec) |
1324 | { | 2492 | { |
2493 | struct via_spec *spec = codec->spec; | ||
2494 | |||
1325 | via_init(codec); | 2495 | via_init(codec); |
1326 | via_auto_init_multi_out(codec); | 2496 | via_auto_init_multi_out(codec); |
1327 | via_auto_init_hp_out(codec); | 2497 | via_auto_init_hp_out(codec); |
1328 | via_auto_init_analog_input(codec); | 2498 | via_auto_init_analog_input(codec); |
2499 | if (spec->codec_type == VT2002P || spec->codec_type == VT1812) { | ||
2500 | via_hp_bind_automute(codec); | ||
2501 | } else { | ||
2502 | via_hp_automute(codec); | ||
2503 | via_speaker_automute(codec); | ||
2504 | } | ||
2505 | |||
1329 | return 0; | 2506 | return 0; |
1330 | } | 2507 | } |
1331 | 2508 | ||
2509 | static void vt1708_update_hp_jack_state(struct work_struct *work) | ||
2510 | { | ||
2511 | struct via_spec *spec = container_of(work, struct via_spec, | ||
2512 | vt1708_hp_work.work); | ||
2513 | if (spec->codec_type != VT1708) | ||
2514 | return; | ||
2515 | /* if jack state toggled */ | ||
2516 | if (spec->vt1708_hp_present | ||
2517 | != snd_hda_jack_detect(spec->codec, spec->autocfg.hp_pins[0])) { | ||
2518 | spec->vt1708_hp_present ^= 1; | ||
2519 | via_hp_automute(spec->codec); | ||
2520 | } | ||
2521 | vt1708_start_hp_work(spec); | ||
2522 | } | ||
2523 | |||
1332 | static int get_mux_nids(struct hda_codec *codec) | 2524 | static int get_mux_nids(struct hda_codec *codec) |
1333 | { | 2525 | { |
1334 | struct via_spec *spec = codec->spec; | 2526 | struct via_spec *spec = codec->spec; |
@@ -1378,7 +2570,7 @@ static int patch_vt1708(struct hda_codec *codec) | |||
1378 | "from BIOS. Using genenic mode...\n"); | 2570 | "from BIOS. Using genenic mode...\n"); |
1379 | } | 2571 | } |
1380 | 2572 | ||
1381 | 2573 | ||
1382 | spec->stream_name_analog = "VT1708 Analog"; | 2574 | spec->stream_name_analog = "VT1708 Analog"; |
1383 | spec->stream_analog_playback = &vt1708_pcm_analog_playback; | 2575 | spec->stream_analog_playback = &vt1708_pcm_analog_playback; |
1384 | /* disable 32bit format on VT1708 */ | 2576 | /* disable 32bit format on VT1708 */ |
@@ -1390,7 +2582,7 @@ static int patch_vt1708(struct hda_codec *codec) | |||
1390 | spec->stream_digital_playback = &vt1708_pcm_digital_playback; | 2582 | spec->stream_digital_playback = &vt1708_pcm_digital_playback; |
1391 | spec->stream_digital_capture = &vt1708_pcm_digital_capture; | 2583 | spec->stream_digital_capture = &vt1708_pcm_digital_capture; |
1392 | 2584 | ||
1393 | 2585 | ||
1394 | if (!spec->adc_nids && spec->input_mux) { | 2586 | if (!spec->adc_nids && spec->input_mux) { |
1395 | spec->adc_nids = vt1708_adc_nids; | 2587 | spec->adc_nids = vt1708_adc_nids; |
1396 | spec->num_adc_nids = ARRAY_SIZE(vt1708_adc_nids); | 2588 | spec->num_adc_nids = ARRAY_SIZE(vt1708_adc_nids); |
@@ -1405,7 +2597,8 @@ static int patch_vt1708(struct hda_codec *codec) | |||
1405 | #ifdef CONFIG_SND_HDA_POWER_SAVE | 2597 | #ifdef CONFIG_SND_HDA_POWER_SAVE |
1406 | spec->loopback.amplist = vt1708_loopbacks; | 2598 | spec->loopback.amplist = vt1708_loopbacks; |
1407 | #endif | 2599 | #endif |
1408 | 2600 | spec->codec = codec; | |
2601 | INIT_DELAYED_WORK(&spec->vt1708_hp_work, vt1708_update_hp_jack_state); | ||
1409 | return 0; | 2602 | return 0; |
1410 | } | 2603 | } |
1411 | 2604 | ||
@@ -1433,7 +2626,8 @@ static struct snd_kcontrol_new vt1709_capture_mixer[] = { | |||
1433 | }; | 2626 | }; |
1434 | 2627 | ||
1435 | static struct hda_verb vt1709_uniwill_init_verbs[] = { | 2628 | static struct hda_verb vt1709_uniwill_init_verbs[] = { |
1436 | {0x20, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT}, | 2629 | {0x20, AC_VERB_SET_UNSOLICITED_ENABLE, |
2630 | AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT}, | ||
1437 | { } | 2631 | { } |
1438 | }; | 2632 | }; |
1439 | 2633 | ||
@@ -1473,8 +2667,8 @@ static struct hda_verb vt1709_10ch_volume_init_verbs[] = { | |||
1473 | {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, | 2667 | {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, |
1474 | {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, | 2668 | {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, |
1475 | 2669 | ||
1476 | /* Set input of PW4 as AOW4 */ | 2670 | /* Set input of PW4 as MW0 */ |
1477 | {0x20, AC_VERB_SET_CONNECT_SEL, 0x1}, | 2671 | {0x20, AC_VERB_SET_CONNECT_SEL, 0}, |
1478 | /* PW9 Output enable */ | 2672 | /* PW9 Output enable */ |
1479 | {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, | 2673 | {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, |
1480 | { } | 2674 | { } |
@@ -1487,8 +2681,8 @@ static struct hda_pcm_stream vt1709_10ch_pcm_analog_playback = { | |||
1487 | .nid = 0x10, /* NID to query formats and rates */ | 2681 | .nid = 0x10, /* NID to query formats and rates */ |
1488 | .ops = { | 2682 | .ops = { |
1489 | .open = via_playback_pcm_open, | 2683 | .open = via_playback_pcm_open, |
1490 | .prepare = via_playback_pcm_prepare, | 2684 | .prepare = via_playback_multi_pcm_prepare, |
1491 | .cleanup = via_playback_pcm_cleanup | 2685 | .cleanup = via_playback_multi_pcm_cleanup, |
1492 | }, | 2686 | }, |
1493 | }; | 2687 | }; |
1494 | 2688 | ||
@@ -1499,8 +2693,8 @@ static struct hda_pcm_stream vt1709_6ch_pcm_analog_playback = { | |||
1499 | .nid = 0x10, /* NID to query formats and rates */ | 2693 | .nid = 0x10, /* NID to query formats and rates */ |
1500 | .ops = { | 2694 | .ops = { |
1501 | .open = via_playback_pcm_open, | 2695 | .open = via_playback_pcm_open, |
1502 | .prepare = via_playback_pcm_prepare, | 2696 | .prepare = via_playback_multi_pcm_prepare, |
1503 | .cleanup = via_playback_pcm_cleanup | 2697 | .cleanup = via_playback_multi_pcm_cleanup, |
1504 | }, | 2698 | }, |
1505 | }; | 2699 | }; |
1506 | 2700 | ||
@@ -1575,11 +2769,11 @@ static int vt1709_auto_fill_dac_nids(struct via_spec *spec, | |||
1575 | spec->multiout.dac_nids[cfg->line_outs] = 0x28; /* AOW4 */ | 2769 | spec->multiout.dac_nids[cfg->line_outs] = 0x28; /* AOW4 */ |
1576 | 2770 | ||
1577 | } else if (cfg->line_outs == 3) { /* 6 channels */ | 2771 | } else if (cfg->line_outs == 3) { /* 6 channels */ |
1578 | for(i = 0; i < cfg->line_outs; i++) { | 2772 | for (i = 0; i < cfg->line_outs; i++) { |
1579 | nid = cfg->line_out_pins[i]; | 2773 | nid = cfg->line_out_pins[i]; |
1580 | if (nid) { | 2774 | if (nid) { |
1581 | /* config dac list */ | 2775 | /* config dac list */ |
1582 | switch(i) { | 2776 | switch (i) { |
1583 | case AUTO_SEQ_FRONT: | 2777 | case AUTO_SEQ_FRONT: |
1584 | /* AOW0 */ | 2778 | /* AOW0 */ |
1585 | spec->multiout.dac_nids[i] = 0x10; | 2779 | spec->multiout.dac_nids[i] = 0x10; |
@@ -1608,56 +2802,58 @@ static int vt1709_auto_create_multi_out_ctls(struct via_spec *spec, | |||
1608 | { | 2802 | { |
1609 | char name[32]; | 2803 | char name[32]; |
1610 | static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" }; | 2804 | static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" }; |
1611 | hda_nid_t nid = 0; | 2805 | hda_nid_t nid, nid_vol, nid_vols[] = {0x18, 0x1a, 0x1b, 0x29}; |
1612 | int i, err; | 2806 | int i, err; |
1613 | 2807 | ||
1614 | for (i = 0; i <= AUTO_SEQ_SIDE; i++) { | 2808 | for (i = 0; i <= AUTO_SEQ_SIDE; i++) { |
1615 | nid = cfg->line_out_pins[i]; | 2809 | nid = cfg->line_out_pins[i]; |
1616 | 2810 | ||
1617 | if (!nid) | 2811 | if (!nid) |
1618 | continue; | 2812 | continue; |
1619 | 2813 | ||
2814 | nid_vol = nid_vols[i]; | ||
2815 | |||
1620 | if (i == AUTO_SEQ_CENLFE) { | 2816 | if (i == AUTO_SEQ_CENLFE) { |
1621 | /* Center/LFE */ | 2817 | /* Center/LFE */ |
1622 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | 2818 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, |
1623 | "Center Playback Volume", | 2819 | "Center Playback Volume", |
1624 | HDA_COMPOSE_AMP_VAL(0x1b, 1, 0, | 2820 | HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, |
1625 | HDA_OUTPUT)); | 2821 | HDA_OUTPUT)); |
1626 | if (err < 0) | 2822 | if (err < 0) |
1627 | return err; | 2823 | return err; |
1628 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | 2824 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, |
1629 | "LFE Playback Volume", | 2825 | "LFE Playback Volume", |
1630 | HDA_COMPOSE_AMP_VAL(0x1b, 2, 0, | 2826 | HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, |
1631 | HDA_OUTPUT)); | 2827 | HDA_OUTPUT)); |
1632 | if (err < 0) | 2828 | if (err < 0) |
1633 | return err; | 2829 | return err; |
1634 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | 2830 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, |
1635 | "Center Playback Switch", | 2831 | "Center Playback Switch", |
1636 | HDA_COMPOSE_AMP_VAL(0x1b, 1, 0, | 2832 | HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, |
1637 | HDA_OUTPUT)); | 2833 | HDA_OUTPUT)); |
1638 | if (err < 0) | 2834 | if (err < 0) |
1639 | return err; | 2835 | return err; |
1640 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | 2836 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, |
1641 | "LFE Playback Switch", | 2837 | "LFE Playback Switch", |
1642 | HDA_COMPOSE_AMP_VAL(0x1b, 2, 0, | 2838 | HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, |
1643 | HDA_OUTPUT)); | 2839 | HDA_OUTPUT)); |
1644 | if (err < 0) | 2840 | if (err < 0) |
1645 | return err; | 2841 | return err; |
1646 | } else if (i == AUTO_SEQ_FRONT){ | 2842 | } else if (i == AUTO_SEQ_FRONT) { |
1647 | /* add control to mixer index 0 */ | 2843 | /* ADD control to mixer index 0 */ |
1648 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | 2844 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, |
1649 | "Master Front Playback Volume", | 2845 | "Master Front Playback Volume", |
1650 | HDA_COMPOSE_AMP_VAL(0x18, 3, 0, | 2846 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, |
1651 | HDA_INPUT)); | 2847 | HDA_INPUT)); |
1652 | if (err < 0) | 2848 | if (err < 0) |
1653 | return err; | 2849 | return err; |
1654 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | 2850 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, |
1655 | "Master Front Playback Switch", | 2851 | "Master Front Playback Switch", |
1656 | HDA_COMPOSE_AMP_VAL(0x18, 3, 0, | 2852 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, |
1657 | HDA_INPUT)); | 2853 | HDA_INPUT)); |
1658 | if (err < 0) | 2854 | if (err < 0) |
1659 | return err; | 2855 | return err; |
1660 | 2856 | ||
1661 | /* add control to PW3 */ | 2857 | /* add control to PW3 */ |
1662 | sprintf(name, "%s Playback Volume", chname[i]); | 2858 | sprintf(name, "%s Playback Volume", chname[i]); |
1663 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, | 2859 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, |
@@ -1674,26 +2870,26 @@ static int vt1709_auto_create_multi_out_ctls(struct via_spec *spec, | |||
1674 | } else if (i == AUTO_SEQ_SURROUND) { | 2870 | } else if (i == AUTO_SEQ_SURROUND) { |
1675 | sprintf(name, "%s Playback Volume", chname[i]); | 2871 | sprintf(name, "%s Playback Volume", chname[i]); |
1676 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, | 2872 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, |
1677 | HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, | 2873 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, |
1678 | HDA_OUTPUT)); | 2874 | HDA_OUTPUT)); |
1679 | if (err < 0) | 2875 | if (err < 0) |
1680 | return err; | 2876 | return err; |
1681 | sprintf(name, "%s Playback Switch", chname[i]); | 2877 | sprintf(name, "%s Playback Switch", chname[i]); |
1682 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, | 2878 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, |
1683 | HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, | 2879 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, |
1684 | HDA_OUTPUT)); | 2880 | HDA_OUTPUT)); |
1685 | if (err < 0) | 2881 | if (err < 0) |
1686 | return err; | 2882 | return err; |
1687 | } else if (i == AUTO_SEQ_SIDE) { | 2883 | } else if (i == AUTO_SEQ_SIDE) { |
1688 | sprintf(name, "%s Playback Volume", chname[i]); | 2884 | sprintf(name, "%s Playback Volume", chname[i]); |
1689 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, | 2885 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, |
1690 | HDA_COMPOSE_AMP_VAL(0x29, 3, 0, | 2886 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, |
1691 | HDA_OUTPUT)); | 2887 | HDA_OUTPUT)); |
1692 | if (err < 0) | 2888 | if (err < 0) |
1693 | return err; | 2889 | return err; |
1694 | sprintf(name, "%s Playback Switch", chname[i]); | 2890 | sprintf(name, "%s Playback Switch", chname[i]); |
1695 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, | 2891 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, |
1696 | HDA_COMPOSE_AMP_VAL(0x29, 3, 0, | 2892 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, |
1697 | HDA_OUTPUT)); | 2893 | HDA_OUTPUT)); |
1698 | if (err < 0) | 2894 | if (err < 0) |
1699 | return err; | 2895 | return err; |
@@ -1714,6 +2910,7 @@ static int vt1709_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) | |||
1714 | spec->multiout.hp_nid = VT1709_HP_DAC_NID; | 2910 | spec->multiout.hp_nid = VT1709_HP_DAC_NID; |
1715 | else if (spec->multiout.num_dacs == 3) /* 6 channels */ | 2911 | else if (spec->multiout.num_dacs == 3) /* 6 channels */ |
1716 | spec->multiout.hp_nid = 0; | 2912 | spec->multiout.hp_nid = 0; |
2913 | spec->hp_independent_mode_index = 1; | ||
1717 | 2914 | ||
1718 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | 2915 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, |
1719 | "Headphone Playback Volume", | 2916 | "Headphone Playback Volume", |
@@ -1752,7 +2949,7 @@ static int vt1709_auto_create_analog_input_ctls(struct via_spec *spec, | |||
1752 | case 0x1d: /* Mic */ | 2949 | case 0x1d: /* Mic */ |
1753 | idx = 2; | 2950 | idx = 2; |
1754 | break; | 2951 | break; |
1755 | 2952 | ||
1756 | case 0x1e: /* Line In */ | 2953 | case 0x1e: /* Line In */ |
1757 | idx = 3; | 2954 | idx = 3; |
1758 | break; | 2955 | break; |
@@ -1765,8 +2962,7 @@ static int vt1709_auto_create_analog_input_ctls(struct via_spec *spec, | |||
1765 | idx = 1; | 2962 | idx = 1; |
1766 | break; | 2963 | break; |
1767 | } | 2964 | } |
1768 | err = via_new_analog_input(spec, cfg->input_pins[i], labels[i], | 2965 | err = via_new_analog_input(spec, labels[i], idx, 0x18); |
1769 | idx, 0x18); | ||
1770 | if (err < 0) | 2966 | if (err < 0) |
1771 | return err; | 2967 | return err; |
1772 | imux->items[imux->num_items].label = labels[i]; | 2968 | imux->items[imux->num_items].label = labels[i]; |
@@ -1816,6 +3012,7 @@ static int vt1709_parse_auto_config(struct hda_codec *codec) | |||
1816 | if (spec->hp_mux) | 3012 | if (spec->hp_mux) |
1817 | spec->mixers[spec->num_mixers++] = via_hp_mixer; | 3013 | spec->mixers[spec->num_mixers++] = via_hp_mixer; |
1818 | 3014 | ||
3015 | spec->mixers[spec->num_mixers++] = via_smart51_mixer; | ||
1819 | return 1; | 3016 | return 1; |
1820 | } | 3017 | } |
1821 | 3018 | ||
@@ -1861,7 +3058,7 @@ static int patch_vt1709_10ch(struct hda_codec *codec) | |||
1861 | spec->stream_digital_playback = &vt1709_pcm_digital_playback; | 3058 | spec->stream_digital_playback = &vt1709_pcm_digital_playback; |
1862 | spec->stream_digital_capture = &vt1709_pcm_digital_capture; | 3059 | spec->stream_digital_capture = &vt1709_pcm_digital_capture; |
1863 | 3060 | ||
1864 | 3061 | ||
1865 | if (!spec->adc_nids && spec->input_mux) { | 3062 | if (!spec->adc_nids && spec->input_mux) { |
1866 | spec->adc_nids = vt1709_adc_nids; | 3063 | spec->adc_nids = vt1709_adc_nids; |
1867 | spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids); | 3064 | spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids); |
@@ -1955,7 +3152,7 @@ static int patch_vt1709_6ch(struct hda_codec *codec) | |||
1955 | spec->stream_digital_playback = &vt1709_pcm_digital_playback; | 3152 | spec->stream_digital_playback = &vt1709_pcm_digital_playback; |
1956 | spec->stream_digital_capture = &vt1709_pcm_digital_capture; | 3153 | spec->stream_digital_capture = &vt1709_pcm_digital_capture; |
1957 | 3154 | ||
1958 | 3155 | ||
1959 | if (!spec->adc_nids && spec->input_mux) { | 3156 | if (!spec->adc_nids && spec->input_mux) { |
1960 | spec->adc_nids = vt1709_adc_nids; | 3157 | spec->adc_nids = vt1709_adc_nids; |
1961 | spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids); | 3158 | spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids); |
@@ -2024,7 +3221,7 @@ static struct hda_verb vt1708B_8ch_volume_init_verbs[] = { | |||
2024 | {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, | 3221 | {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, |
2025 | 3222 | ||
2026 | /* Setup default input to PW4 */ | 3223 | /* Setup default input to PW4 */ |
2027 | {0x1d, AC_VERB_SET_CONNECT_SEL, 0x1}, | 3224 | {0x1d, AC_VERB_SET_CONNECT_SEL, 0}, |
2028 | /* PW9 Output enable */ | 3225 | /* PW9 Output enable */ |
2029 | {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, | 3226 | {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, |
2030 | /* PW10 Input enable */ | 3227 | /* PW10 Input enable */ |
@@ -2068,10 +3265,29 @@ static struct hda_verb vt1708B_4ch_volume_init_verbs[] = { | |||
2068 | }; | 3265 | }; |
2069 | 3266 | ||
2070 | static struct hda_verb vt1708B_uniwill_init_verbs[] = { | 3267 | static struct hda_verb vt1708B_uniwill_init_verbs[] = { |
2071 | {0x1D, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT}, | 3268 | {0x1d, AC_VERB_SET_UNSOLICITED_ENABLE, |
3269 | AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT}, | ||
3270 | {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3271 | {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3272 | {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3273 | {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3274 | {0x1e, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3275 | {0x22, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3276 | {0x23, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
2072 | { } | 3277 | { } |
2073 | }; | 3278 | }; |
2074 | 3279 | ||
3280 | static int via_pcm_open_close(struct hda_pcm_stream *hinfo, | ||
3281 | struct hda_codec *codec, | ||
3282 | struct snd_pcm_substream *substream) | ||
3283 | { | ||
3284 | int idle = substream->pstr->substream_opened == 1 | ||
3285 | && substream->ref_count == 0; | ||
3286 | |||
3287 | analog_low_current_mode(codec, idle); | ||
3288 | return 0; | ||
3289 | } | ||
3290 | |||
2075 | static struct hda_pcm_stream vt1708B_8ch_pcm_analog_playback = { | 3291 | static struct hda_pcm_stream vt1708B_8ch_pcm_analog_playback = { |
2076 | .substreams = 2, | 3292 | .substreams = 2, |
2077 | .channels_min = 2, | 3293 | .channels_min = 2, |
@@ -2080,7 +3296,8 @@ static struct hda_pcm_stream vt1708B_8ch_pcm_analog_playback = { | |||
2080 | .ops = { | 3296 | .ops = { |
2081 | .open = via_playback_pcm_open, | 3297 | .open = via_playback_pcm_open, |
2082 | .prepare = via_playback_multi_pcm_prepare, | 3298 | .prepare = via_playback_multi_pcm_prepare, |
2083 | .cleanup = via_playback_multi_pcm_cleanup | 3299 | .cleanup = via_playback_multi_pcm_cleanup, |
3300 | .close = via_pcm_open_close | ||
2084 | }, | 3301 | }, |
2085 | }; | 3302 | }; |
2086 | 3303 | ||
@@ -2102,8 +3319,10 @@ static struct hda_pcm_stream vt1708B_pcm_analog_capture = { | |||
2102 | .channels_max = 2, | 3319 | .channels_max = 2, |
2103 | .nid = 0x13, /* NID to query formats and rates */ | 3320 | .nid = 0x13, /* NID to query formats and rates */ |
2104 | .ops = { | 3321 | .ops = { |
3322 | .open = via_pcm_open_close, | ||
2105 | .prepare = via_capture_pcm_prepare, | 3323 | .prepare = via_capture_pcm_prepare, |
2106 | .cleanup = via_capture_pcm_cleanup | 3324 | .cleanup = via_capture_pcm_cleanup, |
3325 | .close = via_pcm_open_close | ||
2107 | }, | 3326 | }, |
2108 | }; | 3327 | }; |
2109 | 3328 | ||
@@ -2260,6 +3479,7 @@ static int vt1708B_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) | |||
2260 | return 0; | 3479 | return 0; |
2261 | 3480 | ||
2262 | spec->multiout.hp_nid = VT1708B_HP_NID; /* AOW3 */ | 3481 | spec->multiout.hp_nid = VT1708B_HP_NID; /* AOW3 */ |
3482 | spec->hp_independent_mode_index = 1; | ||
2263 | 3483 | ||
2264 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | 3484 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, |
2265 | "Headphone Playback Volume", | 3485 | "Headphone Playback Volume", |
@@ -2313,8 +3533,7 @@ static int vt1708B_auto_create_analog_input_ctls(struct via_spec *spec, | |||
2313 | idx = 1; | 3533 | idx = 1; |
2314 | break; | 3534 | break; |
2315 | } | 3535 | } |
2316 | err = via_new_analog_input(spec, cfg->input_pins[i], labels[i], | 3536 | err = via_new_analog_input(spec, labels[i], idx, 0x16); |
2317 | idx, 0x16); | ||
2318 | if (err < 0) | 3537 | if (err < 0) |
2319 | return err; | 3538 | return err; |
2320 | imux->items[imux->num_items].label = labels[i]; | 3539 | imux->items[imux->num_items].label = labels[i]; |
@@ -2364,6 +3583,7 @@ static int vt1708B_parse_auto_config(struct hda_codec *codec) | |||
2364 | if (spec->hp_mux) | 3583 | if (spec->hp_mux) |
2365 | spec->mixers[spec->num_mixers++] = via_hp_mixer; | 3584 | spec->mixers[spec->num_mixers++] = via_hp_mixer; |
2366 | 3585 | ||
3586 | spec->mixers[spec->num_mixers++] = via_smart51_mixer; | ||
2367 | return 1; | 3587 | return 1; |
2368 | } | 3588 | } |
2369 | 3589 | ||
@@ -2376,12 +3596,14 @@ static struct hda_amp_list vt1708B_loopbacks[] = { | |||
2376 | { } /* end */ | 3596 | { } /* end */ |
2377 | }; | 3597 | }; |
2378 | #endif | 3598 | #endif |
2379 | 3599 | static int patch_vt1708S(struct hda_codec *codec); | |
2380 | static int patch_vt1708B_8ch(struct hda_codec *codec) | 3600 | static int patch_vt1708B_8ch(struct hda_codec *codec) |
2381 | { | 3601 | { |
2382 | struct via_spec *spec; | 3602 | struct via_spec *spec; |
2383 | int err; | 3603 | int err; |
2384 | 3604 | ||
3605 | if (get_codec_type(codec) == VT1708BCE) | ||
3606 | return patch_vt1708S(codec); | ||
2385 | /* create a codec specific record */ | 3607 | /* create a codec specific record */ |
2386 | spec = kzalloc(sizeof(*spec), GFP_KERNEL); | 3608 | spec = kzalloc(sizeof(*spec), GFP_KERNEL); |
2387 | if (spec == NULL) | 3609 | if (spec == NULL) |
@@ -2483,29 +3705,15 @@ static int patch_vt1708B_4ch(struct hda_codec *codec) | |||
2483 | 3705 | ||
2484 | /* Patch for VT1708S */ | 3706 | /* Patch for VT1708S */ |
2485 | 3707 | ||
2486 | /* VT1708S software backdoor based override for buggy hardware micboost | ||
2487 | * setting */ | ||
2488 | #define MIC_BOOST_VOLUME(xname, nid) { \ | ||
2489 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ | ||
2490 | .name = xname, \ | ||
2491 | .index = 0, \ | ||
2492 | .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \ | ||
2493 | SNDRV_CTL_ELEM_ACCESS_TLV_READ | \ | ||
2494 | SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \ | ||
2495 | .info = mic_boost_volume_info, \ | ||
2496 | .get = snd_hda_mixer_amp_volume_get, \ | ||
2497 | .put = snd_hda_mixer_amp_volume_put, \ | ||
2498 | .tlv = { .c = mic_boost_tlv }, \ | ||
2499 | .private_value = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT) } | ||
2500 | |||
2501 | /* capture mixer elements */ | 3708 | /* capture mixer elements */ |
2502 | static struct snd_kcontrol_new vt1708S_capture_mixer[] = { | 3709 | static struct snd_kcontrol_new vt1708S_capture_mixer[] = { |
2503 | HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT), | 3710 | HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT), |
2504 | HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT), | 3711 | HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT), |
2505 | HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT), | 3712 | HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT), |
2506 | HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT), | 3713 | HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT), |
2507 | MIC_BOOST_VOLUME("Mic Boost Capture Volume", 0x1A), | 3714 | HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x1A, 0x0, HDA_INPUT), |
2508 | MIC_BOOST_VOLUME("Front Mic Boost Capture Volume", 0x1E), | 3715 | HDA_CODEC_VOLUME("Front Mic Boost Capture Volume", 0x1E, 0x0, |
3716 | HDA_INPUT), | ||
2509 | { | 3717 | { |
2510 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | 3718 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
2511 | /* The multiple "Capture Source" controls confuse alsamixer | 3719 | /* The multiple "Capture Source" controls confuse alsamixer |
@@ -2542,11 +3750,21 @@ static struct hda_verb vt1708S_volume_init_verbs[] = { | |||
2542 | {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, | 3750 | {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, |
2543 | /* Enable Mic Boost Volume backdoor */ | 3751 | /* Enable Mic Boost Volume backdoor */ |
2544 | {0x1, 0xf98, 0x1}, | 3752 | {0x1, 0xf98, 0x1}, |
3753 | /* don't bybass mixer */ | ||
3754 | {0x1, 0xf88, 0xc0}, | ||
2545 | { } | 3755 | { } |
2546 | }; | 3756 | }; |
2547 | 3757 | ||
2548 | static struct hda_verb vt1708S_uniwill_init_verbs[] = { | 3758 | static struct hda_verb vt1708S_uniwill_init_verbs[] = { |
2549 | {0x1D, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT}, | 3759 | {0x1d, AC_VERB_SET_UNSOLICITED_ENABLE, |
3760 | AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT}, | ||
3761 | {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3762 | {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3763 | {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3764 | {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3765 | {0x1e, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3766 | {0x22, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3767 | {0x23, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
2550 | { } | 3768 | { } |
2551 | }; | 3769 | }; |
2552 | 3770 | ||
@@ -2557,8 +3775,9 @@ static struct hda_pcm_stream vt1708S_pcm_analog_playback = { | |||
2557 | .nid = 0x10, /* NID to query formats and rates */ | 3775 | .nid = 0x10, /* NID to query formats and rates */ |
2558 | .ops = { | 3776 | .ops = { |
2559 | .open = via_playback_pcm_open, | 3777 | .open = via_playback_pcm_open, |
2560 | .prepare = via_playback_pcm_prepare, | 3778 | .prepare = via_playback_multi_pcm_prepare, |
2561 | .cleanup = via_playback_pcm_cleanup | 3779 | .cleanup = via_playback_multi_pcm_cleanup, |
3780 | .close = via_pcm_open_close | ||
2562 | }, | 3781 | }, |
2563 | }; | 3782 | }; |
2564 | 3783 | ||
@@ -2568,8 +3787,10 @@ static struct hda_pcm_stream vt1708S_pcm_analog_capture = { | |||
2568 | .channels_max = 2, | 3787 | .channels_max = 2, |
2569 | .nid = 0x13, /* NID to query formats and rates */ | 3788 | .nid = 0x13, /* NID to query formats and rates */ |
2570 | .ops = { | 3789 | .ops = { |
3790 | .open = via_pcm_open_close, | ||
2571 | .prepare = via_capture_pcm_prepare, | 3791 | .prepare = via_capture_pcm_prepare, |
2572 | .cleanup = via_capture_pcm_cleanup | 3792 | .cleanup = via_capture_pcm_cleanup, |
3793 | .close = via_pcm_open_close | ||
2573 | }, | 3794 | }, |
2574 | }; | 3795 | }; |
2575 | 3796 | ||
@@ -2726,6 +3947,7 @@ static int vt1708S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) | |||
2726 | return 0; | 3947 | return 0; |
2727 | 3948 | ||
2728 | spec->multiout.hp_nid = VT1708S_HP_NID; /* AOW3 */ | 3949 | spec->multiout.hp_nid = VT1708S_HP_NID; /* AOW3 */ |
3950 | spec->hp_independent_mode_index = 1; | ||
2729 | 3951 | ||
2730 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | 3952 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, |
2731 | "Headphone Playback Volume", | 3953 | "Headphone Playback Volume", |
@@ -2780,8 +4002,7 @@ static int vt1708S_auto_create_analog_input_ctls(struct via_spec *spec, | |||
2780 | idx = 1; | 4002 | idx = 1; |
2781 | break; | 4003 | break; |
2782 | } | 4004 | } |
2783 | err = via_new_analog_input(spec, cfg->input_pins[i], labels[i], | 4005 | err = via_new_analog_input(spec, labels[i], idx, 0x16); |
2784 | idx, 0x16); | ||
2785 | if (err < 0) | 4006 | if (err < 0) |
2786 | return err; | 4007 | return err; |
2787 | imux->items[imux->num_items].label = labels[i]; | 4008 | imux->items[imux->num_items].label = labels[i]; |
@@ -2852,6 +4073,7 @@ static int vt1708S_parse_auto_config(struct hda_codec *codec) | |||
2852 | if (spec->hp_mux) | 4073 | if (spec->hp_mux) |
2853 | spec->mixers[spec->num_mixers++] = via_hp_mixer; | 4074 | spec->mixers[spec->num_mixers++] = via_hp_mixer; |
2854 | 4075 | ||
4076 | spec->mixers[spec->num_mixers++] = via_smart51_mixer; | ||
2855 | return 1; | 4077 | return 1; |
2856 | } | 4078 | } |
2857 | 4079 | ||
@@ -2865,6 +4087,16 @@ static struct hda_amp_list vt1708S_loopbacks[] = { | |||
2865 | }; | 4087 | }; |
2866 | #endif | 4088 | #endif |
2867 | 4089 | ||
4090 | static void override_mic_boost(struct hda_codec *codec, hda_nid_t pin, | ||
4091 | int offset, int num_steps, int step_size) | ||
4092 | { | ||
4093 | snd_hda_override_amp_caps(codec, pin, HDA_INPUT, | ||
4094 | (offset << AC_AMPCAP_OFFSET_SHIFT) | | ||
4095 | (num_steps << AC_AMPCAP_NUM_STEPS_SHIFT) | | ||
4096 | (step_size << AC_AMPCAP_STEP_SIZE_SHIFT) | | ||
4097 | (0 << AC_AMPCAP_MUTE_SHIFT)); | ||
4098 | } | ||
4099 | |||
2868 | static int patch_vt1708S(struct hda_codec *codec) | 4100 | static int patch_vt1708S(struct hda_codec *codec) |
2869 | { | 4101 | { |
2870 | struct via_spec *spec; | 4102 | struct via_spec *spec; |
@@ -2890,17 +4122,25 @@ static int patch_vt1708S(struct hda_codec *codec) | |||
2890 | spec->init_verbs[spec->num_iverbs++] = vt1708S_volume_init_verbs; | 4122 | spec->init_verbs[spec->num_iverbs++] = vt1708S_volume_init_verbs; |
2891 | spec->init_verbs[spec->num_iverbs++] = vt1708S_uniwill_init_verbs; | 4123 | spec->init_verbs[spec->num_iverbs++] = vt1708S_uniwill_init_verbs; |
2892 | 4124 | ||
2893 | spec->stream_name_analog = "VT1708S Analog"; | 4125 | if (codec->vendor_id == 0x11060440) |
4126 | spec->stream_name_analog = "VT1818S Analog"; | ||
4127 | else | ||
4128 | spec->stream_name_analog = "VT1708S Analog"; | ||
2894 | spec->stream_analog_playback = &vt1708S_pcm_analog_playback; | 4129 | spec->stream_analog_playback = &vt1708S_pcm_analog_playback; |
2895 | spec->stream_analog_capture = &vt1708S_pcm_analog_capture; | 4130 | spec->stream_analog_capture = &vt1708S_pcm_analog_capture; |
2896 | 4131 | ||
2897 | spec->stream_name_digital = "VT1708S Digital"; | 4132 | if (codec->vendor_id == 0x11060440) |
4133 | spec->stream_name_digital = "VT1818S Digital"; | ||
4134 | else | ||
4135 | spec->stream_name_digital = "VT1708S Digital"; | ||
2898 | spec->stream_digital_playback = &vt1708S_pcm_digital_playback; | 4136 | spec->stream_digital_playback = &vt1708S_pcm_digital_playback; |
2899 | 4137 | ||
2900 | if (!spec->adc_nids && spec->input_mux) { | 4138 | if (!spec->adc_nids && spec->input_mux) { |
2901 | spec->adc_nids = vt1708S_adc_nids; | 4139 | spec->adc_nids = vt1708S_adc_nids; |
2902 | spec->num_adc_nids = ARRAY_SIZE(vt1708S_adc_nids); | 4140 | spec->num_adc_nids = ARRAY_SIZE(vt1708S_adc_nids); |
2903 | get_mux_nids(codec); | 4141 | get_mux_nids(codec); |
4142 | override_mic_boost(codec, 0x1a, 0, 3, 40); | ||
4143 | override_mic_boost(codec, 0x1e, 0, 3, 40); | ||
2904 | spec->mixers[spec->num_mixers] = vt1708S_capture_mixer; | 4144 | spec->mixers[spec->num_mixers] = vt1708S_capture_mixer; |
2905 | spec->num_mixers++; | 4145 | spec->num_mixers++; |
2906 | } | 4146 | } |
@@ -2913,6 +4153,16 @@ static int patch_vt1708S(struct hda_codec *codec) | |||
2913 | spec->loopback.amplist = vt1708S_loopbacks; | 4153 | spec->loopback.amplist = vt1708S_loopbacks; |
2914 | #endif | 4154 | #endif |
2915 | 4155 | ||
4156 | /* correct names for VT1708BCE */ | ||
4157 | if (get_codec_type(codec) == VT1708BCE) { | ||
4158 | kfree(codec->chip_name); | ||
4159 | codec->chip_name = kstrdup("VT1708BCE", GFP_KERNEL); | ||
4160 | snprintf(codec->bus->card->mixername, | ||
4161 | sizeof(codec->bus->card->mixername), | ||
4162 | "%s %s", codec->vendor_name, codec->chip_name); | ||
4163 | spec->stream_name_analog = "VT1708BCE Analog"; | ||
4164 | spec->stream_name_digital = "VT1708BCE Digital"; | ||
4165 | } | ||
2916 | return 0; | 4166 | return 0; |
2917 | } | 4167 | } |
2918 | 4168 | ||
@@ -2967,12 +4217,20 @@ static struct hda_verb vt1702_volume_init_verbs[] = { | |||
2967 | /* PW6 PW7 Output enable */ | 4217 | /* PW6 PW7 Output enable */ |
2968 | {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, | 4218 | {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, |
2969 | {0x1C, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, | 4219 | {0x1C, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, |
4220 | /* mixer enable */ | ||
4221 | {0x1, 0xF88, 0x3}, | ||
4222 | /* GPIO 0~2 */ | ||
4223 | {0x1, 0xF82, 0x3F}, | ||
2970 | { } | 4224 | { } |
2971 | }; | 4225 | }; |
2972 | 4226 | ||
2973 | static struct hda_verb vt1702_uniwill_init_verbs[] = { | 4227 | static struct hda_verb vt1702_uniwill_init_verbs[] = { |
2974 | {0x01, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_GPIO_EVENT}, | 4228 | {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, |
2975 | {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT}, | 4229 | AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT}, |
4230 | {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
4231 | {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
4232 | {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
4233 | {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
2976 | { } | 4234 | { } |
2977 | }; | 4235 | }; |
2978 | 4236 | ||
@@ -2984,7 +4242,8 @@ static struct hda_pcm_stream vt1702_pcm_analog_playback = { | |||
2984 | .ops = { | 4242 | .ops = { |
2985 | .open = via_playback_pcm_open, | 4243 | .open = via_playback_pcm_open, |
2986 | .prepare = via_playback_multi_pcm_prepare, | 4244 | .prepare = via_playback_multi_pcm_prepare, |
2987 | .cleanup = via_playback_multi_pcm_cleanup | 4245 | .cleanup = via_playback_multi_pcm_cleanup, |
4246 | .close = via_pcm_open_close | ||
2988 | }, | 4247 | }, |
2989 | }; | 4248 | }; |
2990 | 4249 | ||
@@ -2994,8 +4253,10 @@ static struct hda_pcm_stream vt1702_pcm_analog_capture = { | |||
2994 | .channels_max = 2, | 4253 | .channels_max = 2, |
2995 | .nid = 0x12, /* NID to query formats and rates */ | 4254 | .nid = 0x12, /* NID to query formats and rates */ |
2996 | .ops = { | 4255 | .ops = { |
4256 | .open = via_pcm_open_close, | ||
2997 | .prepare = via_capture_pcm_prepare, | 4257 | .prepare = via_capture_pcm_prepare, |
2998 | .cleanup = via_capture_pcm_cleanup | 4258 | .cleanup = via_capture_pcm_cleanup, |
4259 | .close = via_pcm_open_close | ||
2999 | }, | 4260 | }, |
3000 | }; | 4261 | }; |
3001 | 4262 | ||
@@ -3065,12 +4326,13 @@ static int vt1702_auto_create_line_out_ctls(struct via_spec *spec, | |||
3065 | 4326 | ||
3066 | static int vt1702_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) | 4327 | static int vt1702_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) |
3067 | { | 4328 | { |
3068 | int err; | 4329 | int err, i; |
3069 | 4330 | struct hda_input_mux *imux; | |
4331 | static const char *texts[] = { "ON", "OFF", NULL}; | ||
3070 | if (!pin) | 4332 | if (!pin) |
3071 | return 0; | 4333 | return 0; |
3072 | |||
3073 | spec->multiout.hp_nid = 0x1D; | 4334 | spec->multiout.hp_nid = 0x1D; |
4335 | spec->hp_independent_mode_index = 0; | ||
3074 | 4336 | ||
3075 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | 4337 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, |
3076 | "Headphone Playback Volume", | 4338 | "Headphone Playback Volume", |
@@ -3084,8 +4346,18 @@ static int vt1702_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) | |||
3084 | if (err < 0) | 4346 | if (err < 0) |
3085 | return err; | 4347 | return err; |
3086 | 4348 | ||
3087 | create_hp_imux(spec); | 4349 | imux = &spec->private_imux[1]; |
3088 | 4350 | ||
4351 | /* for hp mode select */ | ||
4352 | i = 0; | ||
4353 | while (texts[i] != NULL) { | ||
4354 | imux->items[imux->num_items].label = texts[i]; | ||
4355 | imux->items[imux->num_items].index = i; | ||
4356 | imux->num_items++; | ||
4357 | i++; | ||
4358 | } | ||
4359 | |||
4360 | spec->hp_mux = &spec->private_imux[1]; | ||
3089 | return 0; | 4361 | return 0; |
3090 | } | 4362 | } |
3091 | 4363 | ||
@@ -3121,8 +4393,7 @@ static int vt1702_auto_create_analog_input_ctls(struct via_spec *spec, | |||
3121 | idx = 3; | 4393 | idx = 3; |
3122 | break; | 4394 | break; |
3123 | } | 4395 | } |
3124 | err = via_new_analog_input(spec, cfg->input_pins[i], | 4396 | err = via_new_analog_input(spec, labels[i], idx, 0x1A); |
3125 | labels[i], idx, 0x1A); | ||
3126 | if (err < 0) | 4397 | if (err < 0) |
3127 | return err; | 4398 | return err; |
3128 | imux->items[imux->num_items].label = labels[i]; | 4399 | imux->items[imux->num_items].label = labels[i]; |
@@ -3152,6 +4423,12 @@ static int vt1702_parse_auto_config(struct hda_codec *codec) | |||
3152 | err = vt1702_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); | 4423 | err = vt1702_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); |
3153 | if (err < 0) | 4424 | if (err < 0) |
3154 | return err; | 4425 | return err; |
4426 | /* limit AA path volume to 0 dB */ | ||
4427 | snd_hda_override_amp_caps(codec, 0x1A, HDA_INPUT, | ||
4428 | (0x17 << AC_AMPCAP_OFFSET_SHIFT) | | ||
4429 | (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) | | ||
4430 | (0x5 << AC_AMPCAP_STEP_SIZE_SHIFT) | | ||
4431 | (1 << AC_AMPCAP_MUTE_SHIFT)); | ||
3155 | err = vt1702_auto_create_analog_input_ctls(spec, &spec->autocfg); | 4432 | err = vt1702_auto_create_analog_input_ctls(spec, &spec->autocfg); |
3156 | if (err < 0) | 4433 | if (err < 0) |
3157 | return err; | 4434 | return err; |
@@ -3185,8 +4462,6 @@ static int patch_vt1702(struct hda_codec *codec) | |||
3185 | { | 4462 | { |
3186 | struct via_spec *spec; | 4463 | struct via_spec *spec; |
3187 | int err; | 4464 | int err; |
3188 | unsigned int response; | ||
3189 | unsigned char control; | ||
3190 | 4465 | ||
3191 | /* create a codec specific record */ | 4466 | /* create a codec specific record */ |
3192 | spec = kzalloc(sizeof(*spec), GFP_KERNEL); | 4467 | spec = kzalloc(sizeof(*spec), GFP_KERNEL); |
@@ -3231,17 +4506,1638 @@ static int patch_vt1702(struct hda_codec *codec) | |||
3231 | spec->loopback.amplist = vt1702_loopbacks; | 4506 | spec->loopback.amplist = vt1702_loopbacks; |
3232 | #endif | 4507 | #endif |
3233 | 4508 | ||
3234 | /* Open backdoor */ | 4509 | return 0; |
3235 | response = snd_hda_codec_read(codec, codec->afg, 0, 0xF8C, 0); | 4510 | } |
3236 | control = (unsigned char)(response & 0xff); | 4511 | |
3237 | control |= 0x3; | 4512 | /* Patch for VT1718S */ |
3238 | snd_hda_codec_write(codec, codec->afg, 0, 0xF88, control); | 4513 | |
4514 | /* capture mixer elements */ | ||
4515 | static struct snd_kcontrol_new vt1718S_capture_mixer[] = { | ||
4516 | HDA_CODEC_VOLUME("Capture Volume", 0x10, 0x0, HDA_INPUT), | ||
4517 | HDA_CODEC_MUTE("Capture Switch", 0x10, 0x0, HDA_INPUT), | ||
4518 | HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x11, 0x0, HDA_INPUT), | ||
4519 | HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x11, 0x0, HDA_INPUT), | ||
4520 | HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x2b, 0x0, HDA_INPUT), | ||
4521 | HDA_CODEC_VOLUME("Front Mic Boost Capture Volume", 0x29, 0x0, | ||
4522 | HDA_INPUT), | ||
4523 | { | ||
4524 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
4525 | /* The multiple "Capture Source" controls confuse alsamixer | ||
4526 | * So call somewhat different.. | ||
4527 | */ | ||
4528 | .name = "Input Source", | ||
4529 | .count = 2, | ||
4530 | .info = via_mux_enum_info, | ||
4531 | .get = via_mux_enum_get, | ||
4532 | .put = via_mux_enum_put, | ||
4533 | }, | ||
4534 | { } /* end */ | ||
4535 | }; | ||
4536 | |||
4537 | static struct hda_verb vt1718S_volume_init_verbs[] = { | ||
4538 | /* | ||
4539 | * Unmute ADC0-1 and set the default input to mic-in | ||
4540 | */ | ||
4541 | {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
4542 | {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
4543 | |||
4544 | |||
4545 | /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback | ||
4546 | * mixer widget | ||
4547 | */ | ||
4548 | /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ | ||
4549 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, | ||
4550 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, | ||
4551 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, | ||
4552 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, | ||
4553 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, | ||
4554 | |||
4555 | /* Setup default input of Front HP to MW9 */ | ||
4556 | {0x28, AC_VERB_SET_CONNECT_SEL, 0x1}, | ||
4557 | /* PW9 PW10 Output enable */ | ||
4558 | {0x2d, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_OUT_EN}, | ||
4559 | {0x2e, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_OUT_EN}, | ||
4560 | /* PW11 Input enable */ | ||
4561 | {0x2f, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_IN_EN}, | ||
4562 | /* Enable Boost Volume backdoor */ | ||
4563 | {0x1, 0xf88, 0x8}, | ||
4564 | /* MW0/1/2/3/4: un-mute index 0 (AOWx), mute index 1 (MW9) */ | ||
4565 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
4566 | {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
4567 | {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
4568 | {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
4569 | {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
4570 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
4571 | {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, | ||
4572 | {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, | ||
4573 | {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
4574 | {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, | ||
4575 | /* set MUX1 = 2 (AOW4), MUX2 = 1 (AOW3) */ | ||
4576 | {0x34, AC_VERB_SET_CONNECT_SEL, 0x2}, | ||
4577 | {0x35, AC_VERB_SET_CONNECT_SEL, 0x1}, | ||
4578 | /* Unmute MW4's index 0 */ | ||
4579 | {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
4580 | { } | ||
4581 | }; | ||
4582 | |||
4583 | |||
4584 | static struct hda_verb vt1718S_uniwill_init_verbs[] = { | ||
4585 | {0x28, AC_VERB_SET_UNSOLICITED_ENABLE, | ||
4586 | AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT}, | ||
4587 | {0x24, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
4588 | {0x25, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
4589 | {0x26, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
4590 | {0x27, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
4591 | {0x29, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
4592 | {0x2a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
4593 | {0x2b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
4594 | { } | ||
4595 | }; | ||
4596 | |||
4597 | static struct hda_pcm_stream vt1718S_pcm_analog_playback = { | ||
4598 | .substreams = 2, | ||
4599 | .channels_min = 2, | ||
4600 | .channels_max = 10, | ||
4601 | .nid = 0x8, /* NID to query formats and rates */ | ||
4602 | .ops = { | ||
4603 | .open = via_playback_pcm_open, | ||
4604 | .prepare = via_playback_multi_pcm_prepare, | ||
4605 | .cleanup = via_playback_multi_pcm_cleanup, | ||
4606 | .close = via_pcm_open_close, | ||
4607 | }, | ||
4608 | }; | ||
4609 | |||
4610 | static struct hda_pcm_stream vt1718S_pcm_analog_capture = { | ||
4611 | .substreams = 2, | ||
4612 | .channels_min = 2, | ||
4613 | .channels_max = 2, | ||
4614 | .nid = 0x10, /* NID to query formats and rates */ | ||
4615 | .ops = { | ||
4616 | .open = via_pcm_open_close, | ||
4617 | .prepare = via_capture_pcm_prepare, | ||
4618 | .cleanup = via_capture_pcm_cleanup, | ||
4619 | .close = via_pcm_open_close, | ||
4620 | }, | ||
4621 | }; | ||
4622 | |||
4623 | static struct hda_pcm_stream vt1718S_pcm_digital_playback = { | ||
4624 | .substreams = 2, | ||
4625 | .channels_min = 2, | ||
4626 | .channels_max = 2, | ||
4627 | /* NID is set in via_build_pcms */ | ||
4628 | .ops = { | ||
4629 | .open = via_dig_playback_pcm_open, | ||
4630 | .close = via_dig_playback_pcm_close, | ||
4631 | .prepare = via_dig_playback_pcm_prepare, | ||
4632 | .cleanup = via_dig_playback_pcm_cleanup | ||
4633 | }, | ||
4634 | }; | ||
4635 | |||
4636 | static struct hda_pcm_stream vt1718S_pcm_digital_capture = { | ||
4637 | .substreams = 1, | ||
4638 | .channels_min = 2, | ||
4639 | .channels_max = 2, | ||
4640 | }; | ||
4641 | |||
4642 | /* fill in the dac_nids table from the parsed pin configuration */ | ||
4643 | static int vt1718S_auto_fill_dac_nids(struct via_spec *spec, | ||
4644 | const struct auto_pin_cfg *cfg) | ||
4645 | { | ||
4646 | int i; | ||
4647 | hda_nid_t nid; | ||
4648 | |||
4649 | spec->multiout.num_dacs = cfg->line_outs; | ||
4650 | |||
4651 | spec->multiout.dac_nids = spec->private_dac_nids; | ||
4652 | |||
4653 | for (i = 0; i < 4; i++) { | ||
4654 | nid = cfg->line_out_pins[i]; | ||
4655 | if (nid) { | ||
4656 | /* config dac list */ | ||
4657 | switch (i) { | ||
4658 | case AUTO_SEQ_FRONT: | ||
4659 | spec->multiout.dac_nids[i] = 0x8; | ||
4660 | break; | ||
4661 | case AUTO_SEQ_CENLFE: | ||
4662 | spec->multiout.dac_nids[i] = 0xa; | ||
4663 | break; | ||
4664 | case AUTO_SEQ_SURROUND: | ||
4665 | spec->multiout.dac_nids[i] = 0x9; | ||
4666 | break; | ||
4667 | case AUTO_SEQ_SIDE: | ||
4668 | spec->multiout.dac_nids[i] = 0xb; | ||
4669 | break; | ||
4670 | } | ||
4671 | } | ||
4672 | } | ||
4673 | |||
4674 | return 0; | ||
4675 | } | ||
4676 | |||
4677 | /* add playback controls from the parsed DAC table */ | ||
4678 | static int vt1718S_auto_create_multi_out_ctls(struct via_spec *spec, | ||
4679 | const struct auto_pin_cfg *cfg) | ||
4680 | { | ||
4681 | char name[32]; | ||
4682 | static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" }; | ||
4683 | hda_nid_t nid_vols[] = {0x8, 0x9, 0xa, 0xb}; | ||
4684 | hda_nid_t nid_mutes[] = {0x24, 0x25, 0x26, 0x27}; | ||
4685 | hda_nid_t nid, nid_vol, nid_mute = 0; | ||
4686 | int i, err; | ||
4687 | |||
4688 | for (i = 0; i <= AUTO_SEQ_SIDE; i++) { | ||
4689 | nid = cfg->line_out_pins[i]; | ||
4690 | |||
4691 | if (!nid) | ||
4692 | continue; | ||
4693 | nid_vol = nid_vols[i]; | ||
4694 | nid_mute = nid_mutes[i]; | ||
4695 | |||
4696 | if (i == AUTO_SEQ_CENLFE) { | ||
4697 | /* Center/LFE */ | ||
4698 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
4699 | "Center Playback Volume", | ||
4700 | HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, | ||
4701 | HDA_OUTPUT)); | ||
4702 | if (err < 0) | ||
4703 | return err; | ||
4704 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
4705 | "LFE Playback Volume", | ||
4706 | HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, | ||
4707 | HDA_OUTPUT)); | ||
4708 | if (err < 0) | ||
4709 | return err; | ||
4710 | err = via_add_control( | ||
4711 | spec, VIA_CTL_WIDGET_MUTE, | ||
4712 | "Center Playback Switch", | ||
4713 | HDA_COMPOSE_AMP_VAL(nid_mute, 1, 0, | ||
4714 | HDA_OUTPUT)); | ||
4715 | if (err < 0) | ||
4716 | return err; | ||
4717 | err = via_add_control( | ||
4718 | spec, VIA_CTL_WIDGET_MUTE, | ||
4719 | "LFE Playback Switch", | ||
4720 | HDA_COMPOSE_AMP_VAL(nid_mute, 2, 0, | ||
4721 | HDA_OUTPUT)); | ||
4722 | if (err < 0) | ||
4723 | return err; | ||
4724 | } else if (i == AUTO_SEQ_FRONT) { | ||
4725 | /* Front */ | ||
4726 | sprintf(name, "%s Playback Volume", chname[i]); | ||
4727 | err = via_add_control( | ||
4728 | spec, VIA_CTL_WIDGET_VOL, name, | ||
4729 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT)); | ||
4730 | if (err < 0) | ||
4731 | return err; | ||
4732 | sprintf(name, "%s Playback Switch", chname[i]); | ||
4733 | err = via_add_control( | ||
4734 | spec, VIA_CTL_WIDGET_MUTE, name, | ||
4735 | HDA_COMPOSE_AMP_VAL(nid_mute, 3, 0, | ||
4736 | HDA_OUTPUT)); | ||
4737 | if (err < 0) | ||
4738 | return err; | ||
4739 | } else { | ||
4740 | sprintf(name, "%s Playback Volume", chname[i]); | ||
4741 | err = via_add_control( | ||
4742 | spec, VIA_CTL_WIDGET_VOL, name, | ||
4743 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT)); | ||
4744 | if (err < 0) | ||
4745 | return err; | ||
4746 | sprintf(name, "%s Playback Switch", chname[i]); | ||
4747 | err = via_add_control( | ||
4748 | spec, VIA_CTL_WIDGET_MUTE, name, | ||
4749 | HDA_COMPOSE_AMP_VAL(nid_mute, 3, 0, | ||
4750 | HDA_OUTPUT)); | ||
4751 | if (err < 0) | ||
4752 | return err; | ||
4753 | } | ||
4754 | } | ||
4755 | return 0; | ||
4756 | } | ||
4757 | |||
4758 | static int vt1718S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) | ||
4759 | { | ||
4760 | int err; | ||
4761 | |||
4762 | if (!pin) | ||
4763 | return 0; | ||
4764 | |||
4765 | spec->multiout.hp_nid = 0xc; /* AOW4 */ | ||
4766 | spec->hp_independent_mode_index = 1; | ||
4767 | |||
4768 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
4769 | "Headphone Playback Volume", | ||
4770 | HDA_COMPOSE_AMP_VAL(0xc, 3, 0, HDA_OUTPUT)); | ||
4771 | if (err < 0) | ||
4772 | return err; | ||
4773 | |||
4774 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
4775 | "Headphone Playback Switch", | ||
4776 | HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); | ||
4777 | if (err < 0) | ||
4778 | return err; | ||
4779 | |||
4780 | create_hp_imux(spec); | ||
4781 | return 0; | ||
4782 | } | ||
4783 | |||
4784 | /* create playback/capture controls for input pins */ | ||
4785 | static int vt1718S_auto_create_analog_input_ctls(struct via_spec *spec, | ||
4786 | const struct auto_pin_cfg *cfg) | ||
4787 | { | ||
4788 | static char *labels[] = { | ||
4789 | "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL | ||
4790 | }; | ||
4791 | struct hda_input_mux *imux = &spec->private_imux[0]; | ||
4792 | int i, err, idx = 0; | ||
4793 | |||
4794 | /* for internal loopback recording select */ | ||
4795 | imux->items[imux->num_items].label = "Stereo Mixer"; | ||
4796 | imux->items[imux->num_items].index = 5; | ||
4797 | imux->num_items++; | ||
4798 | |||
4799 | for (i = 0; i < AUTO_PIN_LAST; i++) { | ||
4800 | if (!cfg->input_pins[i]) | ||
4801 | continue; | ||
4802 | |||
4803 | switch (cfg->input_pins[i]) { | ||
4804 | case 0x2b: /* Mic */ | ||
4805 | idx = 1; | ||
4806 | break; | ||
4807 | |||
4808 | case 0x2a: /* Line In */ | ||
4809 | idx = 2; | ||
4810 | break; | ||
4811 | |||
4812 | case 0x29: /* Front Mic */ | ||
4813 | idx = 3; | ||
4814 | break; | ||
4815 | |||
4816 | case 0x2c: /* CD */ | ||
4817 | idx = 0; | ||
4818 | break; | ||
4819 | } | ||
4820 | err = via_new_analog_input(spec, labels[i], idx, 0x21); | ||
4821 | if (err < 0) | ||
4822 | return err; | ||
4823 | imux->items[imux->num_items].label = labels[i]; | ||
4824 | imux->items[imux->num_items].index = idx; | ||
4825 | imux->num_items++; | ||
4826 | } | ||
4827 | return 0; | ||
4828 | } | ||
4829 | |||
4830 | static int vt1718S_parse_auto_config(struct hda_codec *codec) | ||
4831 | { | ||
4832 | struct via_spec *spec = codec->spec; | ||
4833 | int err; | ||
4834 | |||
4835 | err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); | ||
4836 | |||
4837 | if (err < 0) | ||
4838 | return err; | ||
4839 | err = vt1718S_auto_fill_dac_nids(spec, &spec->autocfg); | ||
4840 | if (err < 0) | ||
4841 | return err; | ||
4842 | if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) | ||
4843 | return 0; /* can't find valid BIOS pin config */ | ||
4844 | |||
4845 | err = vt1718S_auto_create_multi_out_ctls(spec, &spec->autocfg); | ||
4846 | if (err < 0) | ||
4847 | return err; | ||
4848 | err = vt1718S_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); | ||
4849 | if (err < 0) | ||
4850 | return err; | ||
4851 | err = vt1718S_auto_create_analog_input_ctls(spec, &spec->autocfg); | ||
4852 | if (err < 0) | ||
4853 | return err; | ||
4854 | |||
4855 | spec->multiout.max_channels = spec->multiout.num_dacs * 2; | ||
4856 | |||
4857 | fill_dig_outs(codec); | ||
4858 | |||
4859 | if (spec->autocfg.dig_in_pin && codec->vendor_id == 0x11060428) | ||
4860 | spec->dig_in_nid = 0x13; | ||
4861 | |||
4862 | if (spec->kctls.list) | ||
4863 | spec->mixers[spec->num_mixers++] = spec->kctls.list; | ||
4864 | |||
4865 | spec->input_mux = &spec->private_imux[0]; | ||
4866 | |||
4867 | if (spec->hp_mux) | ||
4868 | spec->mixers[spec->num_mixers++] = via_hp_mixer; | ||
4869 | |||
4870 | spec->mixers[spec->num_mixers++] = via_smart51_mixer; | ||
4871 | |||
4872 | return 1; | ||
4873 | } | ||
4874 | |||
4875 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
4876 | static struct hda_amp_list vt1718S_loopbacks[] = { | ||
4877 | { 0x21, HDA_INPUT, 1 }, | ||
4878 | { 0x21, HDA_INPUT, 2 }, | ||
4879 | { 0x21, HDA_INPUT, 3 }, | ||
4880 | { 0x21, HDA_INPUT, 4 }, | ||
4881 | { } /* end */ | ||
4882 | }; | ||
4883 | #endif | ||
4884 | |||
4885 | static int patch_vt1718S(struct hda_codec *codec) | ||
4886 | { | ||
4887 | struct via_spec *spec; | ||
4888 | int err; | ||
3239 | 4889 | ||
3240 | /* Enable GPIO 0&1 for volume&mute control */ | 4890 | /* create a codec specific record */ |
3241 | /* Enable GPIO 2 for DMIC-DATA */ | 4891 | spec = kzalloc(sizeof(*spec), GFP_KERNEL); |
3242 | response = snd_hda_codec_read(codec, codec->afg, 0, 0xF84, 0); | 4892 | if (spec == NULL) |
3243 | control = (unsigned char)((response >> 16) & 0x3f); | 4893 | return -ENOMEM; |
3244 | snd_hda_codec_write(codec, codec->afg, 0, 0xF82, control); | 4894 | |
4895 | codec->spec = spec; | ||
4896 | |||
4897 | /* automatic parse from the BIOS config */ | ||
4898 | err = vt1718S_parse_auto_config(codec); | ||
4899 | if (err < 0) { | ||
4900 | via_free(codec); | ||
4901 | return err; | ||
4902 | } else if (!err) { | ||
4903 | printk(KERN_INFO "hda_codec: Cannot set up configuration " | ||
4904 | "from BIOS. Using genenic mode...\n"); | ||
4905 | } | ||
4906 | |||
4907 | spec->init_verbs[spec->num_iverbs++] = vt1718S_volume_init_verbs; | ||
4908 | spec->init_verbs[spec->num_iverbs++] = vt1718S_uniwill_init_verbs; | ||
4909 | |||
4910 | if (codec->vendor_id == 0x11060441) | ||
4911 | spec->stream_name_analog = "VT2020 Analog"; | ||
4912 | else if (codec->vendor_id == 0x11064441) | ||
4913 | spec->stream_name_analog = "VT1828S Analog"; | ||
4914 | else | ||
4915 | spec->stream_name_analog = "VT1718S Analog"; | ||
4916 | spec->stream_analog_playback = &vt1718S_pcm_analog_playback; | ||
4917 | spec->stream_analog_capture = &vt1718S_pcm_analog_capture; | ||
4918 | |||
4919 | if (codec->vendor_id == 0x11060441) | ||
4920 | spec->stream_name_digital = "VT2020 Digital"; | ||
4921 | else if (codec->vendor_id == 0x11064441) | ||
4922 | spec->stream_name_digital = "VT1828S Digital"; | ||
4923 | else | ||
4924 | spec->stream_name_digital = "VT1718S Digital"; | ||
4925 | spec->stream_digital_playback = &vt1718S_pcm_digital_playback; | ||
4926 | if (codec->vendor_id == 0x11060428 || codec->vendor_id == 0x11060441) | ||
4927 | spec->stream_digital_capture = &vt1718S_pcm_digital_capture; | ||
4928 | |||
4929 | if (!spec->adc_nids && spec->input_mux) { | ||
4930 | spec->adc_nids = vt1718S_adc_nids; | ||
4931 | spec->num_adc_nids = ARRAY_SIZE(vt1718S_adc_nids); | ||
4932 | get_mux_nids(codec); | ||
4933 | override_mic_boost(codec, 0x2b, 0, 3, 40); | ||
4934 | override_mic_boost(codec, 0x29, 0, 3, 40); | ||
4935 | spec->mixers[spec->num_mixers] = vt1718S_capture_mixer; | ||
4936 | spec->num_mixers++; | ||
4937 | } | ||
4938 | |||
4939 | codec->patch_ops = via_patch_ops; | ||
4940 | |||
4941 | codec->patch_ops.init = via_auto_init; | ||
4942 | codec->patch_ops.unsol_event = via_unsol_event; | ||
4943 | |||
4944 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
4945 | spec->loopback.amplist = vt1718S_loopbacks; | ||
4946 | #endif | ||
4947 | |||
4948 | return 0; | ||
4949 | } | ||
4950 | |||
4951 | /* Patch for VT1716S */ | ||
4952 | |||
4953 | static int vt1716s_dmic_info(struct snd_kcontrol *kcontrol, | ||
4954 | struct snd_ctl_elem_info *uinfo) | ||
4955 | { | ||
4956 | uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; | ||
4957 | uinfo->count = 1; | ||
4958 | uinfo->value.integer.min = 0; | ||
4959 | uinfo->value.integer.max = 1; | ||
4960 | return 0; | ||
4961 | } | ||
4962 | |||
4963 | static int vt1716s_dmic_get(struct snd_kcontrol *kcontrol, | ||
4964 | struct snd_ctl_elem_value *ucontrol) | ||
4965 | { | ||
4966 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | ||
4967 | int index = 0; | ||
4968 | |||
4969 | index = snd_hda_codec_read(codec, 0x26, 0, | ||
4970 | AC_VERB_GET_CONNECT_SEL, 0); | ||
4971 | if (index != -1) | ||
4972 | *ucontrol->value.integer.value = index; | ||
4973 | |||
4974 | return 0; | ||
4975 | } | ||
4976 | |||
4977 | static int vt1716s_dmic_put(struct snd_kcontrol *kcontrol, | ||
4978 | struct snd_ctl_elem_value *ucontrol) | ||
4979 | { | ||
4980 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | ||
4981 | struct via_spec *spec = codec->spec; | ||
4982 | int index = *ucontrol->value.integer.value; | ||
4983 | |||
4984 | snd_hda_codec_write(codec, 0x26, 0, | ||
4985 | AC_VERB_SET_CONNECT_SEL, index); | ||
4986 | spec->dmic_enabled = index; | ||
4987 | set_jack_power_state(codec); | ||
4988 | |||
4989 | return 1; | ||
4990 | } | ||
4991 | |||
4992 | /* capture mixer elements */ | ||
4993 | static struct snd_kcontrol_new vt1716S_capture_mixer[] = { | ||
4994 | HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT), | ||
4995 | HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT), | ||
4996 | HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT), | ||
4997 | HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT), | ||
4998 | HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x1A, 0x0, HDA_INPUT), | ||
4999 | HDA_CODEC_VOLUME("Front Mic Boost Capture Volume", 0x1E, 0x0, | ||
5000 | HDA_INPUT), | ||
5001 | { | ||
5002 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
5003 | .name = "Input Source", | ||
5004 | .count = 1, | ||
5005 | .info = via_mux_enum_info, | ||
5006 | .get = via_mux_enum_get, | ||
5007 | .put = via_mux_enum_put, | ||
5008 | }, | ||
5009 | { } /* end */ | ||
5010 | }; | ||
5011 | |||
5012 | static struct snd_kcontrol_new vt1716s_dmic_mixer[] = { | ||
5013 | HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x22, 0x0, HDA_INPUT), | ||
5014 | { | ||
5015 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
5016 | .name = "Digital Mic Capture Switch", | ||
5017 | .count = 1, | ||
5018 | .info = vt1716s_dmic_info, | ||
5019 | .get = vt1716s_dmic_get, | ||
5020 | .put = vt1716s_dmic_put, | ||
5021 | }, | ||
5022 | {} /* end */ | ||
5023 | }; | ||
5024 | |||
5025 | |||
5026 | /* mono-out mixer elements */ | ||
5027 | static struct snd_kcontrol_new vt1716S_mono_out_mixer[] = { | ||
5028 | HDA_CODEC_MUTE("Mono Playback Switch", 0x2a, 0x0, HDA_OUTPUT), | ||
5029 | { } /* end */ | ||
5030 | }; | ||
5031 | |||
5032 | static struct hda_verb vt1716S_volume_init_verbs[] = { | ||
5033 | /* | ||
5034 | * Unmute ADC0-1 and set the default input to mic-in | ||
5035 | */ | ||
5036 | {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5037 | {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5038 | |||
5039 | |||
5040 | /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback | ||
5041 | * mixer widget | ||
5042 | */ | ||
5043 | /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ | ||
5044 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, | ||
5045 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, | ||
5046 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, | ||
5047 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, | ||
5048 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, | ||
5049 | |||
5050 | /* MUX Indices: Stereo Mixer = 5 */ | ||
5051 | {0x17, AC_VERB_SET_CONNECT_SEL, 0x5}, | ||
5052 | |||
5053 | /* Setup default input of PW4 to MW0 */ | ||
5054 | {0x1d, AC_VERB_SET_CONNECT_SEL, 0x0}, | ||
5055 | |||
5056 | /* Setup default input of SW1 as MW0 */ | ||
5057 | {0x18, AC_VERB_SET_CONNECT_SEL, 0x1}, | ||
5058 | |||
5059 | /* Setup default input of SW4 as AOW0 */ | ||
5060 | {0x28, AC_VERB_SET_CONNECT_SEL, 0x1}, | ||
5061 | |||
5062 | /* PW9 PW10 Output enable */ | ||
5063 | {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, | ||
5064 | {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, | ||
5065 | |||
5066 | /* Unmute SW1, PW12 */ | ||
5067 | {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5068 | {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, | ||
5069 | /* PW12 Output enable */ | ||
5070 | {0x2a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, | ||
5071 | /* Enable Boost Volume backdoor */ | ||
5072 | {0x1, 0xf8a, 0x80}, | ||
5073 | /* don't bybass mixer */ | ||
5074 | {0x1, 0xf88, 0xc0}, | ||
5075 | /* Enable mono output */ | ||
5076 | {0x1, 0xf90, 0x08}, | ||
5077 | { } | ||
5078 | }; | ||
5079 | |||
5080 | |||
5081 | static struct hda_verb vt1716S_uniwill_init_verbs[] = { | ||
5082 | {0x1d, AC_VERB_SET_UNSOLICITED_ENABLE, | ||
5083 | AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT}, | ||
5084 | {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
5085 | {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
5086 | {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
5087 | {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, | ||
5088 | AC_USRSP_EN | VIA_MONO_EVENT | VIA_JACK_EVENT}, | ||
5089 | {0x1e, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
5090 | {0x23, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
5091 | { } | ||
5092 | }; | ||
5093 | |||
5094 | static struct hda_pcm_stream vt1716S_pcm_analog_playback = { | ||
5095 | .substreams = 2, | ||
5096 | .channels_min = 2, | ||
5097 | .channels_max = 6, | ||
5098 | .nid = 0x10, /* NID to query formats and rates */ | ||
5099 | .ops = { | ||
5100 | .open = via_playback_pcm_open, | ||
5101 | .prepare = via_playback_multi_pcm_prepare, | ||
5102 | .cleanup = via_playback_multi_pcm_cleanup, | ||
5103 | .close = via_pcm_open_close, | ||
5104 | }, | ||
5105 | }; | ||
5106 | |||
5107 | static struct hda_pcm_stream vt1716S_pcm_analog_capture = { | ||
5108 | .substreams = 2, | ||
5109 | .channels_min = 2, | ||
5110 | .channels_max = 2, | ||
5111 | .nid = 0x13, /* NID to query formats and rates */ | ||
5112 | .ops = { | ||
5113 | .open = via_pcm_open_close, | ||
5114 | .prepare = via_capture_pcm_prepare, | ||
5115 | .cleanup = via_capture_pcm_cleanup, | ||
5116 | .close = via_pcm_open_close, | ||
5117 | }, | ||
5118 | }; | ||
5119 | |||
5120 | static struct hda_pcm_stream vt1716S_pcm_digital_playback = { | ||
5121 | .substreams = 2, | ||
5122 | .channels_min = 2, | ||
5123 | .channels_max = 2, | ||
5124 | /* NID is set in via_build_pcms */ | ||
5125 | .ops = { | ||
5126 | .open = via_dig_playback_pcm_open, | ||
5127 | .close = via_dig_playback_pcm_close, | ||
5128 | .prepare = via_dig_playback_pcm_prepare, | ||
5129 | .cleanup = via_dig_playback_pcm_cleanup | ||
5130 | }, | ||
5131 | }; | ||
5132 | |||
5133 | /* fill in the dac_nids table from the parsed pin configuration */ | ||
5134 | static int vt1716S_auto_fill_dac_nids(struct via_spec *spec, | ||
5135 | const struct auto_pin_cfg *cfg) | ||
5136 | { int i; | ||
5137 | hda_nid_t nid; | ||
5138 | |||
5139 | spec->multiout.num_dacs = cfg->line_outs; | ||
5140 | |||
5141 | spec->multiout.dac_nids = spec->private_dac_nids; | ||
5142 | |||
5143 | for (i = 0; i < 3; i++) { | ||
5144 | nid = cfg->line_out_pins[i]; | ||
5145 | if (nid) { | ||
5146 | /* config dac list */ | ||
5147 | switch (i) { | ||
5148 | case AUTO_SEQ_FRONT: | ||
5149 | spec->multiout.dac_nids[i] = 0x10; | ||
5150 | break; | ||
5151 | case AUTO_SEQ_CENLFE: | ||
5152 | spec->multiout.dac_nids[i] = 0x25; | ||
5153 | break; | ||
5154 | case AUTO_SEQ_SURROUND: | ||
5155 | spec->multiout.dac_nids[i] = 0x11; | ||
5156 | break; | ||
5157 | } | ||
5158 | } | ||
5159 | } | ||
5160 | |||
5161 | return 0; | ||
5162 | } | ||
5163 | |||
5164 | /* add playback controls from the parsed DAC table */ | ||
5165 | static int vt1716S_auto_create_multi_out_ctls(struct via_spec *spec, | ||
5166 | const struct auto_pin_cfg *cfg) | ||
5167 | { | ||
5168 | char name[32]; | ||
5169 | static const char *chname[3] = { "Front", "Surround", "C/LFE" }; | ||
5170 | hda_nid_t nid_vols[] = {0x10, 0x11, 0x25}; | ||
5171 | hda_nid_t nid_mutes[] = {0x1C, 0x18, 0x27}; | ||
5172 | hda_nid_t nid, nid_vol, nid_mute; | ||
5173 | int i, err; | ||
5174 | |||
5175 | for (i = 0; i <= AUTO_SEQ_CENLFE; i++) { | ||
5176 | nid = cfg->line_out_pins[i]; | ||
5177 | |||
5178 | if (!nid) | ||
5179 | continue; | ||
5180 | |||
5181 | nid_vol = nid_vols[i]; | ||
5182 | nid_mute = nid_mutes[i]; | ||
5183 | |||
5184 | if (i == AUTO_SEQ_CENLFE) { | ||
5185 | err = via_add_control( | ||
5186 | spec, VIA_CTL_WIDGET_VOL, | ||
5187 | "Center Playback Volume", | ||
5188 | HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, HDA_OUTPUT)); | ||
5189 | if (err < 0) | ||
5190 | return err; | ||
5191 | err = via_add_control( | ||
5192 | spec, VIA_CTL_WIDGET_VOL, | ||
5193 | "LFE Playback Volume", | ||
5194 | HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT)); | ||
5195 | if (err < 0) | ||
5196 | return err; | ||
5197 | err = via_add_control( | ||
5198 | spec, VIA_CTL_WIDGET_MUTE, | ||
5199 | "Center Playback Switch", | ||
5200 | HDA_COMPOSE_AMP_VAL(nid_mute, 1, 0, | ||
5201 | HDA_OUTPUT)); | ||
5202 | if (err < 0) | ||
5203 | return err; | ||
5204 | err = via_add_control( | ||
5205 | spec, VIA_CTL_WIDGET_MUTE, | ||
5206 | "LFE Playback Switch", | ||
5207 | HDA_COMPOSE_AMP_VAL(nid_mute, 2, 0, | ||
5208 | HDA_OUTPUT)); | ||
5209 | if (err < 0) | ||
5210 | return err; | ||
5211 | } else if (i == AUTO_SEQ_FRONT) { | ||
5212 | |||
5213 | err = via_add_control( | ||
5214 | spec, VIA_CTL_WIDGET_VOL, | ||
5215 | "Master Front Playback Volume", | ||
5216 | HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_INPUT)); | ||
5217 | if (err < 0) | ||
5218 | return err; | ||
5219 | err = via_add_control( | ||
5220 | spec, VIA_CTL_WIDGET_MUTE, | ||
5221 | "Master Front Playback Switch", | ||
5222 | HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_INPUT)); | ||
5223 | if (err < 0) | ||
5224 | return err; | ||
5225 | |||
5226 | sprintf(name, "%s Playback Volume", chname[i]); | ||
5227 | err = via_add_control( | ||
5228 | spec, VIA_CTL_WIDGET_VOL, name, | ||
5229 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT)); | ||
5230 | if (err < 0) | ||
5231 | return err; | ||
5232 | sprintf(name, "%s Playback Switch", chname[i]); | ||
5233 | err = via_add_control( | ||
5234 | spec, VIA_CTL_WIDGET_MUTE, name, | ||
5235 | HDA_COMPOSE_AMP_VAL(nid_mute, 3, 0, | ||
5236 | HDA_OUTPUT)); | ||
5237 | if (err < 0) | ||
5238 | return err; | ||
5239 | } else { | ||
5240 | sprintf(name, "%s Playback Volume", chname[i]); | ||
5241 | err = via_add_control( | ||
5242 | spec, VIA_CTL_WIDGET_VOL, name, | ||
5243 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT)); | ||
5244 | if (err < 0) | ||
5245 | return err; | ||
5246 | sprintf(name, "%s Playback Switch", chname[i]); | ||
5247 | err = via_add_control( | ||
5248 | spec, VIA_CTL_WIDGET_MUTE, name, | ||
5249 | HDA_COMPOSE_AMP_VAL(nid_mute, 3, 0, | ||
5250 | HDA_OUTPUT)); | ||
5251 | if (err < 0) | ||
5252 | return err; | ||
5253 | } | ||
5254 | } | ||
5255 | return 0; | ||
5256 | } | ||
5257 | |||
5258 | static int vt1716S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) | ||
5259 | { | ||
5260 | int err; | ||
5261 | |||
5262 | if (!pin) | ||
5263 | return 0; | ||
5264 | |||
5265 | spec->multiout.hp_nid = 0x25; /* AOW3 */ | ||
5266 | spec->hp_independent_mode_index = 1; | ||
5267 | |||
5268 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
5269 | "Headphone Playback Volume", | ||
5270 | HDA_COMPOSE_AMP_VAL(0x25, 3, 0, HDA_OUTPUT)); | ||
5271 | if (err < 0) | ||
5272 | return err; | ||
5273 | |||
5274 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
5275 | "Headphone Playback Switch", | ||
5276 | HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); | ||
5277 | if (err < 0) | ||
5278 | return err; | ||
5279 | |||
5280 | create_hp_imux(spec); | ||
5281 | return 0; | ||
5282 | } | ||
5283 | |||
5284 | /* create playback/capture controls for input pins */ | ||
5285 | static int vt1716S_auto_create_analog_input_ctls(struct via_spec *spec, | ||
5286 | const struct auto_pin_cfg *cfg) | ||
5287 | { | ||
5288 | static char *labels[] = { | ||
5289 | "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL | ||
5290 | }; | ||
5291 | struct hda_input_mux *imux = &spec->private_imux[0]; | ||
5292 | int i, err, idx = 0; | ||
5293 | |||
5294 | /* for internal loopback recording select */ | ||
5295 | imux->items[imux->num_items].label = "Stereo Mixer"; | ||
5296 | imux->items[imux->num_items].index = 5; | ||
5297 | imux->num_items++; | ||
5298 | |||
5299 | for (i = 0; i < AUTO_PIN_LAST; i++) { | ||
5300 | if (!cfg->input_pins[i]) | ||
5301 | continue; | ||
5302 | |||
5303 | switch (cfg->input_pins[i]) { | ||
5304 | case 0x1a: /* Mic */ | ||
5305 | idx = 2; | ||
5306 | break; | ||
5307 | |||
5308 | case 0x1b: /* Line In */ | ||
5309 | idx = 3; | ||
5310 | break; | ||
5311 | |||
5312 | case 0x1e: /* Front Mic */ | ||
5313 | idx = 4; | ||
5314 | break; | ||
5315 | |||
5316 | case 0x1f: /* CD */ | ||
5317 | idx = 1; | ||
5318 | break; | ||
5319 | } | ||
5320 | err = via_new_analog_input(spec, labels[i], idx, 0x16); | ||
5321 | if (err < 0) | ||
5322 | return err; | ||
5323 | imux->items[imux->num_items].label = labels[i]; | ||
5324 | imux->items[imux->num_items].index = idx-1; | ||
5325 | imux->num_items++; | ||
5326 | } | ||
5327 | return 0; | ||
5328 | } | ||
5329 | |||
5330 | static int vt1716S_parse_auto_config(struct hda_codec *codec) | ||
5331 | { | ||
5332 | struct via_spec *spec = codec->spec; | ||
5333 | int err; | ||
5334 | |||
5335 | err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); | ||
5336 | if (err < 0) | ||
5337 | return err; | ||
5338 | err = vt1716S_auto_fill_dac_nids(spec, &spec->autocfg); | ||
5339 | if (err < 0) | ||
5340 | return err; | ||
5341 | if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) | ||
5342 | return 0; /* can't find valid BIOS pin config */ | ||
5343 | |||
5344 | err = vt1716S_auto_create_multi_out_ctls(spec, &spec->autocfg); | ||
5345 | if (err < 0) | ||
5346 | return err; | ||
5347 | err = vt1716S_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); | ||
5348 | if (err < 0) | ||
5349 | return err; | ||
5350 | err = vt1716S_auto_create_analog_input_ctls(spec, &spec->autocfg); | ||
5351 | if (err < 0) | ||
5352 | return err; | ||
5353 | |||
5354 | spec->multiout.max_channels = spec->multiout.num_dacs * 2; | ||
5355 | |||
5356 | fill_dig_outs(codec); | ||
5357 | |||
5358 | if (spec->kctls.list) | ||
5359 | spec->mixers[spec->num_mixers++] = spec->kctls.list; | ||
5360 | |||
5361 | spec->input_mux = &spec->private_imux[0]; | ||
5362 | |||
5363 | if (spec->hp_mux) | ||
5364 | spec->mixers[spec->num_mixers++] = via_hp_mixer; | ||
5365 | |||
5366 | spec->mixers[spec->num_mixers++] = via_smart51_mixer; | ||
5367 | |||
5368 | return 1; | ||
5369 | } | ||
5370 | |||
5371 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
5372 | static struct hda_amp_list vt1716S_loopbacks[] = { | ||
5373 | { 0x16, HDA_INPUT, 1 }, | ||
5374 | { 0x16, HDA_INPUT, 2 }, | ||
5375 | { 0x16, HDA_INPUT, 3 }, | ||
5376 | { 0x16, HDA_INPUT, 4 }, | ||
5377 | { } /* end */ | ||
5378 | }; | ||
5379 | #endif | ||
5380 | |||
5381 | static int patch_vt1716S(struct hda_codec *codec) | ||
5382 | { | ||
5383 | struct via_spec *spec; | ||
5384 | int err; | ||
5385 | |||
5386 | /* create a codec specific record */ | ||
5387 | spec = kzalloc(sizeof(*spec), GFP_KERNEL); | ||
5388 | if (spec == NULL) | ||
5389 | return -ENOMEM; | ||
5390 | |||
5391 | codec->spec = spec; | ||
5392 | |||
5393 | /* automatic parse from the BIOS config */ | ||
5394 | err = vt1716S_parse_auto_config(codec); | ||
5395 | if (err < 0) { | ||
5396 | via_free(codec); | ||
5397 | return err; | ||
5398 | } else if (!err) { | ||
5399 | printk(KERN_INFO "hda_codec: Cannot set up configuration " | ||
5400 | "from BIOS. Using genenic mode...\n"); | ||
5401 | } | ||
5402 | |||
5403 | spec->init_verbs[spec->num_iverbs++] = vt1716S_volume_init_verbs; | ||
5404 | spec->init_verbs[spec->num_iverbs++] = vt1716S_uniwill_init_verbs; | ||
5405 | |||
5406 | spec->stream_name_analog = "VT1716S Analog"; | ||
5407 | spec->stream_analog_playback = &vt1716S_pcm_analog_playback; | ||
5408 | spec->stream_analog_capture = &vt1716S_pcm_analog_capture; | ||
5409 | |||
5410 | spec->stream_name_digital = "VT1716S Digital"; | ||
5411 | spec->stream_digital_playback = &vt1716S_pcm_digital_playback; | ||
5412 | |||
5413 | if (!spec->adc_nids && spec->input_mux) { | ||
5414 | spec->adc_nids = vt1716S_adc_nids; | ||
5415 | spec->num_adc_nids = ARRAY_SIZE(vt1716S_adc_nids); | ||
5416 | get_mux_nids(codec); | ||
5417 | override_mic_boost(codec, 0x1a, 0, 3, 40); | ||
5418 | override_mic_boost(codec, 0x1e, 0, 3, 40); | ||
5419 | spec->mixers[spec->num_mixers] = vt1716S_capture_mixer; | ||
5420 | spec->num_mixers++; | ||
5421 | } | ||
5422 | |||
5423 | spec->mixers[spec->num_mixers] = vt1716s_dmic_mixer; | ||
5424 | spec->num_mixers++; | ||
5425 | |||
5426 | spec->mixers[spec->num_mixers++] = vt1716S_mono_out_mixer; | ||
5427 | |||
5428 | codec->patch_ops = via_patch_ops; | ||
5429 | |||
5430 | codec->patch_ops.init = via_auto_init; | ||
5431 | codec->patch_ops.unsol_event = via_unsol_event; | ||
5432 | |||
5433 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
5434 | spec->loopback.amplist = vt1716S_loopbacks; | ||
5435 | #endif | ||
5436 | |||
5437 | return 0; | ||
5438 | } | ||
5439 | |||
5440 | /* for vt2002P */ | ||
5441 | |||
5442 | /* capture mixer elements */ | ||
5443 | static struct snd_kcontrol_new vt2002P_capture_mixer[] = { | ||
5444 | HDA_CODEC_VOLUME("Capture Volume", 0x10, 0x0, HDA_INPUT), | ||
5445 | HDA_CODEC_MUTE("Capture Switch", 0x10, 0x0, HDA_INPUT), | ||
5446 | HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x11, 0x0, HDA_INPUT), | ||
5447 | HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x11, 0x0, HDA_INPUT), | ||
5448 | HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x2b, 0x0, HDA_INPUT), | ||
5449 | HDA_CODEC_VOLUME("Front Mic Boost Capture Volume", 0x29, 0x0, | ||
5450 | HDA_INPUT), | ||
5451 | { | ||
5452 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
5453 | /* The multiple "Capture Source" controls confuse alsamixer | ||
5454 | * So call somewhat different.. | ||
5455 | */ | ||
5456 | /* .name = "Capture Source", */ | ||
5457 | .name = "Input Source", | ||
5458 | .count = 2, | ||
5459 | .info = via_mux_enum_info, | ||
5460 | .get = via_mux_enum_get, | ||
5461 | .put = via_mux_enum_put, | ||
5462 | }, | ||
5463 | { } /* end */ | ||
5464 | }; | ||
5465 | |||
5466 | static struct hda_verb vt2002P_volume_init_verbs[] = { | ||
5467 | /* | ||
5468 | * Unmute ADC0-1 and set the default input to mic-in | ||
5469 | */ | ||
5470 | {0x8, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5471 | {0x9, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5472 | |||
5473 | |||
5474 | /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback | ||
5475 | * mixer widget | ||
5476 | */ | ||
5477 | /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ | ||
5478 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, | ||
5479 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, | ||
5480 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, | ||
5481 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, | ||
5482 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, | ||
5483 | |||
5484 | /* MUX Indices: Mic = 0 */ | ||
5485 | {0x1e, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5486 | {0x1f, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5487 | |||
5488 | /* PW9 Output enable */ | ||
5489 | {0x2d, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_OUT_EN}, | ||
5490 | |||
5491 | /* Enable Boost Volume backdoor */ | ||
5492 | {0x1, 0xfb9, 0x24}, | ||
5493 | |||
5494 | /* MW0/1/4/8: un-mute index 0 (MUXx), un-mute index 1 (MW9) */ | ||
5495 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5496 | {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5497 | {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5498 | {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5499 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
5500 | {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
5501 | {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
5502 | {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
5503 | |||
5504 | /* set MUX0/1/4/8 = 0 (AOW0) */ | ||
5505 | {0x34, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5506 | {0x35, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5507 | {0x37, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5508 | {0x3b, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5509 | |||
5510 | /* set PW0 index=0 (MW0) */ | ||
5511 | {0x24, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5512 | |||
5513 | /* Enable AOW0 to MW9 */ | ||
5514 | {0x1, 0xfb8, 0x88}, | ||
5515 | { } | ||
5516 | }; | ||
5517 | |||
5518 | |||
5519 | static struct hda_verb vt2002P_uniwill_init_verbs[] = { | ||
5520 | {0x25, AC_VERB_SET_UNSOLICITED_ENABLE, | ||
5521 | AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT}, | ||
5522 | {0x26, AC_VERB_SET_UNSOLICITED_ENABLE, | ||
5523 | AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT}, | ||
5524 | {0x29, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
5525 | {0x2a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
5526 | {0x2b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
5527 | { } | ||
5528 | }; | ||
5529 | |||
5530 | static struct hda_pcm_stream vt2002P_pcm_analog_playback = { | ||
5531 | .substreams = 2, | ||
5532 | .channels_min = 2, | ||
5533 | .channels_max = 2, | ||
5534 | .nid = 0x8, /* NID to query formats and rates */ | ||
5535 | .ops = { | ||
5536 | .open = via_playback_pcm_open, | ||
5537 | .prepare = via_playback_multi_pcm_prepare, | ||
5538 | .cleanup = via_playback_multi_pcm_cleanup, | ||
5539 | .close = via_pcm_open_close, | ||
5540 | }, | ||
5541 | }; | ||
5542 | |||
5543 | static struct hda_pcm_stream vt2002P_pcm_analog_capture = { | ||
5544 | .substreams = 2, | ||
5545 | .channels_min = 2, | ||
5546 | .channels_max = 2, | ||
5547 | .nid = 0x10, /* NID to query formats and rates */ | ||
5548 | .ops = { | ||
5549 | .open = via_pcm_open_close, | ||
5550 | .prepare = via_capture_pcm_prepare, | ||
5551 | .cleanup = via_capture_pcm_cleanup, | ||
5552 | .close = via_pcm_open_close, | ||
5553 | }, | ||
5554 | }; | ||
5555 | |||
5556 | static struct hda_pcm_stream vt2002P_pcm_digital_playback = { | ||
5557 | .substreams = 1, | ||
5558 | .channels_min = 2, | ||
5559 | .channels_max = 2, | ||
5560 | /* NID is set in via_build_pcms */ | ||
5561 | .ops = { | ||
5562 | .open = via_dig_playback_pcm_open, | ||
5563 | .close = via_dig_playback_pcm_close, | ||
5564 | .prepare = via_dig_playback_pcm_prepare, | ||
5565 | .cleanup = via_dig_playback_pcm_cleanup | ||
5566 | }, | ||
5567 | }; | ||
5568 | |||
5569 | /* fill in the dac_nids table from the parsed pin configuration */ | ||
5570 | static int vt2002P_auto_fill_dac_nids(struct via_spec *spec, | ||
5571 | const struct auto_pin_cfg *cfg) | ||
5572 | { | ||
5573 | spec->multiout.num_dacs = 1; | ||
5574 | spec->multiout.dac_nids = spec->private_dac_nids; | ||
5575 | if (cfg->line_out_pins[0]) | ||
5576 | spec->multiout.dac_nids[0] = 0x8; | ||
5577 | return 0; | ||
5578 | } | ||
5579 | |||
5580 | /* add playback controls from the parsed DAC table */ | ||
5581 | static int vt2002P_auto_create_multi_out_ctls(struct via_spec *spec, | ||
5582 | const struct auto_pin_cfg *cfg) | ||
5583 | { | ||
5584 | int err; | ||
5585 | |||
5586 | if (!cfg->line_out_pins[0]) | ||
5587 | return -1; | ||
5588 | |||
5589 | |||
5590 | /* Line-Out: PortE */ | ||
5591 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
5592 | "Master Front Playback Volume", | ||
5593 | HDA_COMPOSE_AMP_VAL(0x8, 3, 0, HDA_OUTPUT)); | ||
5594 | if (err < 0) | ||
5595 | return err; | ||
5596 | err = via_add_control(spec, VIA_CTL_WIDGET_BIND_PIN_MUTE, | ||
5597 | "Master Front Playback Switch", | ||
5598 | HDA_COMPOSE_AMP_VAL(0x26, 3, 0, HDA_OUTPUT)); | ||
5599 | if (err < 0) | ||
5600 | return err; | ||
5601 | |||
5602 | return 0; | ||
5603 | } | ||
5604 | |||
5605 | static int vt2002P_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) | ||
5606 | { | ||
5607 | int err; | ||
5608 | |||
5609 | if (!pin) | ||
5610 | return 0; | ||
5611 | |||
5612 | spec->multiout.hp_nid = 0x9; | ||
5613 | spec->hp_independent_mode_index = 1; | ||
5614 | |||
5615 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
5616 | "Headphone Playback Volume", | ||
5617 | HDA_COMPOSE_AMP_VAL( | ||
5618 | spec->multiout.hp_nid, 3, 0, HDA_OUTPUT)); | ||
5619 | if (err < 0) | ||
5620 | return err; | ||
5621 | |||
5622 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
5623 | "Headphone Playback Switch", | ||
5624 | HDA_COMPOSE_AMP_VAL(0x25, 3, 0, HDA_OUTPUT)); | ||
5625 | if (err < 0) | ||
5626 | return err; | ||
5627 | |||
5628 | create_hp_imux(spec); | ||
5629 | return 0; | ||
5630 | } | ||
5631 | |||
5632 | /* create playback/capture controls for input pins */ | ||
5633 | static int vt2002P_auto_create_analog_input_ctls(struct via_spec *spec, | ||
5634 | const struct auto_pin_cfg *cfg) | ||
5635 | { | ||
5636 | static char *labels[] = { | ||
5637 | "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL | ||
5638 | }; | ||
5639 | struct hda_input_mux *imux = &spec->private_imux[0]; | ||
5640 | int i, err, idx = 0; | ||
5641 | |||
5642 | for (i = 0; i < AUTO_PIN_LAST; i++) { | ||
5643 | if (!cfg->input_pins[i]) | ||
5644 | continue; | ||
5645 | |||
5646 | switch (cfg->input_pins[i]) { | ||
5647 | case 0x2b: /* Mic */ | ||
5648 | idx = 0; | ||
5649 | break; | ||
5650 | |||
5651 | case 0x2a: /* Line In */ | ||
5652 | idx = 1; | ||
5653 | break; | ||
5654 | |||
5655 | case 0x29: /* Front Mic */ | ||
5656 | idx = 2; | ||
5657 | break; | ||
5658 | } | ||
5659 | err = via_new_analog_input(spec, labels[i], idx, 0x21); | ||
5660 | if (err < 0) | ||
5661 | return err; | ||
5662 | imux->items[imux->num_items].label = labels[i]; | ||
5663 | imux->items[imux->num_items].index = idx; | ||
5664 | imux->num_items++; | ||
5665 | } | ||
5666 | |||
5667 | /* build volume/mute control of loopback */ | ||
5668 | err = via_new_analog_input(spec, "Stereo Mixer", 3, 0x21); | ||
5669 | if (err < 0) | ||
5670 | return err; | ||
5671 | |||
5672 | /* for internal loopback recording select */ | ||
5673 | imux->items[imux->num_items].label = "Stereo Mixer"; | ||
5674 | imux->items[imux->num_items].index = 3; | ||
5675 | imux->num_items++; | ||
5676 | |||
5677 | /* for digital mic select */ | ||
5678 | imux->items[imux->num_items].label = "Digital Mic"; | ||
5679 | imux->items[imux->num_items].index = 4; | ||
5680 | imux->num_items++; | ||
5681 | |||
5682 | return 0; | ||
5683 | } | ||
5684 | |||
5685 | static int vt2002P_parse_auto_config(struct hda_codec *codec) | ||
5686 | { | ||
5687 | struct via_spec *spec = codec->spec; | ||
5688 | int err; | ||
5689 | |||
5690 | |||
5691 | err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); | ||
5692 | if (err < 0) | ||
5693 | return err; | ||
5694 | |||
5695 | err = vt2002P_auto_fill_dac_nids(spec, &spec->autocfg); | ||
5696 | if (err < 0) | ||
5697 | return err; | ||
5698 | |||
5699 | if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) | ||
5700 | return 0; /* can't find valid BIOS pin config */ | ||
5701 | |||
5702 | err = vt2002P_auto_create_multi_out_ctls(spec, &spec->autocfg); | ||
5703 | if (err < 0) | ||
5704 | return err; | ||
5705 | err = vt2002P_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); | ||
5706 | if (err < 0) | ||
5707 | return err; | ||
5708 | err = vt2002P_auto_create_analog_input_ctls(spec, &spec->autocfg); | ||
5709 | if (err < 0) | ||
5710 | return err; | ||
5711 | |||
5712 | spec->multiout.max_channels = spec->multiout.num_dacs * 2; | ||
5713 | |||
5714 | fill_dig_outs(codec); | ||
5715 | |||
5716 | if (spec->kctls.list) | ||
5717 | spec->mixers[spec->num_mixers++] = spec->kctls.list; | ||
5718 | |||
5719 | spec->input_mux = &spec->private_imux[0]; | ||
5720 | |||
5721 | if (spec->hp_mux) | ||
5722 | spec->mixers[spec->num_mixers++] = via_hp_mixer; | ||
5723 | |||
5724 | return 1; | ||
5725 | } | ||
5726 | |||
5727 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
5728 | static struct hda_amp_list vt2002P_loopbacks[] = { | ||
5729 | { 0x21, HDA_INPUT, 0 }, | ||
5730 | { 0x21, HDA_INPUT, 1 }, | ||
5731 | { 0x21, HDA_INPUT, 2 }, | ||
5732 | { } /* end */ | ||
5733 | }; | ||
5734 | #endif | ||
5735 | |||
5736 | |||
5737 | /* patch for vt2002P */ | ||
5738 | static int patch_vt2002P(struct hda_codec *codec) | ||
5739 | { | ||
5740 | struct via_spec *spec; | ||
5741 | int err; | ||
5742 | |||
5743 | /* create a codec specific record */ | ||
5744 | spec = kzalloc(sizeof(*spec), GFP_KERNEL); | ||
5745 | if (spec == NULL) | ||
5746 | return -ENOMEM; | ||
5747 | |||
5748 | codec->spec = spec; | ||
5749 | |||
5750 | /* automatic parse from the BIOS config */ | ||
5751 | err = vt2002P_parse_auto_config(codec); | ||
5752 | if (err < 0) { | ||
5753 | via_free(codec); | ||
5754 | return err; | ||
5755 | } else if (!err) { | ||
5756 | printk(KERN_INFO "hda_codec: Cannot set up configuration " | ||
5757 | "from BIOS. Using genenic mode...\n"); | ||
5758 | } | ||
5759 | |||
5760 | spec->init_verbs[spec->num_iverbs++] = vt2002P_volume_init_verbs; | ||
5761 | spec->init_verbs[spec->num_iverbs++] = vt2002P_uniwill_init_verbs; | ||
5762 | |||
5763 | spec->stream_name_analog = "VT2002P Analog"; | ||
5764 | spec->stream_analog_playback = &vt2002P_pcm_analog_playback; | ||
5765 | spec->stream_analog_capture = &vt2002P_pcm_analog_capture; | ||
5766 | |||
5767 | spec->stream_name_digital = "VT2002P Digital"; | ||
5768 | spec->stream_digital_playback = &vt2002P_pcm_digital_playback; | ||
5769 | |||
5770 | if (!spec->adc_nids && spec->input_mux) { | ||
5771 | spec->adc_nids = vt2002P_adc_nids; | ||
5772 | spec->num_adc_nids = ARRAY_SIZE(vt2002P_adc_nids); | ||
5773 | get_mux_nids(codec); | ||
5774 | override_mic_boost(codec, 0x2b, 0, 3, 40); | ||
5775 | override_mic_boost(codec, 0x29, 0, 3, 40); | ||
5776 | spec->mixers[spec->num_mixers] = vt2002P_capture_mixer; | ||
5777 | spec->num_mixers++; | ||
5778 | } | ||
5779 | |||
5780 | codec->patch_ops = via_patch_ops; | ||
5781 | |||
5782 | codec->patch_ops.init = via_auto_init; | ||
5783 | codec->patch_ops.unsol_event = via_unsol_event; | ||
5784 | |||
5785 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
5786 | spec->loopback.amplist = vt2002P_loopbacks; | ||
5787 | #endif | ||
5788 | |||
5789 | return 0; | ||
5790 | } | ||
5791 | |||
5792 | /* for vt1812 */ | ||
5793 | |||
5794 | /* capture mixer elements */ | ||
5795 | static struct snd_kcontrol_new vt1812_capture_mixer[] = { | ||
5796 | HDA_CODEC_VOLUME("Capture Volume", 0x10, 0x0, HDA_INPUT), | ||
5797 | HDA_CODEC_MUTE("Capture Switch", 0x10, 0x0, HDA_INPUT), | ||
5798 | HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x11, 0x0, HDA_INPUT), | ||
5799 | HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x11, 0x0, HDA_INPUT), | ||
5800 | HDA_CODEC_MUTE("Mic Boost Capture Volume", 0x2b, 0x0, HDA_INPUT), | ||
5801 | HDA_CODEC_MUTE("Front Mic Boost Capture Volume", 0x29, 0x0, | ||
5802 | HDA_INPUT), | ||
5803 | { | ||
5804 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
5805 | /* The multiple "Capture Source" controls confuse alsamixer | ||
5806 | * So call somewhat different.. | ||
5807 | */ | ||
5808 | .name = "Input Source", | ||
5809 | .count = 2, | ||
5810 | .info = via_mux_enum_info, | ||
5811 | .get = via_mux_enum_get, | ||
5812 | .put = via_mux_enum_put, | ||
5813 | }, | ||
5814 | { } /* end */ | ||
5815 | }; | ||
5816 | |||
5817 | static struct hda_verb vt1812_volume_init_verbs[] = { | ||
5818 | /* | ||
5819 | * Unmute ADC0-1 and set the default input to mic-in | ||
5820 | */ | ||
5821 | {0x8, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5822 | {0x9, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5823 | |||
5824 | |||
5825 | /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback | ||
5826 | * mixer widget | ||
5827 | */ | ||
5828 | /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ | ||
5829 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, | ||
5830 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, | ||
5831 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, | ||
5832 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, | ||
5833 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, | ||
5834 | |||
5835 | /* MUX Indices: Mic = 0 */ | ||
5836 | {0x1e, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5837 | {0x1f, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5838 | |||
5839 | /* PW9 Output enable */ | ||
5840 | {0x2d, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_OUT_EN}, | ||
5841 | |||
5842 | /* Enable Boost Volume backdoor */ | ||
5843 | {0x1, 0xfb9, 0x24}, | ||
5844 | |||
5845 | /* MW0/1/4/13/15: un-mute index 0 (MUXx), un-mute index 1 (MW9) */ | ||
5846 | {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5847 | {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5848 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5849 | {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5850 | {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5851 | {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
5852 | {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
5853 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
5854 | {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
5855 | {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
5856 | |||
5857 | /* set MUX0/1/4/13/15 = 0 (AOW0) */ | ||
5858 | {0x34, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5859 | {0x35, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5860 | {0x38, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5861 | {0x3c, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5862 | {0x3d, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5863 | |||
5864 | /* Enable AOW0 to MW9 */ | ||
5865 | {0x1, 0xfb8, 0xa8}, | ||
5866 | { } | ||
5867 | }; | ||
5868 | |||
5869 | |||
5870 | static struct hda_verb vt1812_uniwill_init_verbs[] = { | ||
5871 | {0x33, AC_VERB_SET_UNSOLICITED_ENABLE, | ||
5872 | AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT}, | ||
5873 | {0x25, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT }, | ||
5874 | {0x28, AC_VERB_SET_UNSOLICITED_ENABLE, | ||
5875 | AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT}, | ||
5876 | {0x29, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
5877 | {0x2a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
5878 | {0x2b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
5879 | { } | ||
5880 | }; | ||
5881 | |||
5882 | static struct hda_pcm_stream vt1812_pcm_analog_playback = { | ||
5883 | .substreams = 2, | ||
5884 | .channels_min = 2, | ||
5885 | .channels_max = 2, | ||
5886 | .nid = 0x8, /* NID to query formats and rates */ | ||
5887 | .ops = { | ||
5888 | .open = via_playback_pcm_open, | ||
5889 | .prepare = via_playback_multi_pcm_prepare, | ||
5890 | .cleanup = via_playback_multi_pcm_cleanup, | ||
5891 | .close = via_pcm_open_close, | ||
5892 | }, | ||
5893 | }; | ||
5894 | |||
5895 | static struct hda_pcm_stream vt1812_pcm_analog_capture = { | ||
5896 | .substreams = 2, | ||
5897 | .channels_min = 2, | ||
5898 | .channels_max = 2, | ||
5899 | .nid = 0x10, /* NID to query formats and rates */ | ||
5900 | .ops = { | ||
5901 | .open = via_pcm_open_close, | ||
5902 | .prepare = via_capture_pcm_prepare, | ||
5903 | .cleanup = via_capture_pcm_cleanup, | ||
5904 | .close = via_pcm_open_close, | ||
5905 | }, | ||
5906 | }; | ||
5907 | |||
5908 | static struct hda_pcm_stream vt1812_pcm_digital_playback = { | ||
5909 | .substreams = 1, | ||
5910 | .channels_min = 2, | ||
5911 | .channels_max = 2, | ||
5912 | /* NID is set in via_build_pcms */ | ||
5913 | .ops = { | ||
5914 | .open = via_dig_playback_pcm_open, | ||
5915 | .close = via_dig_playback_pcm_close, | ||
5916 | .prepare = via_dig_playback_pcm_prepare, | ||
5917 | .cleanup = via_dig_playback_pcm_cleanup | ||
5918 | }, | ||
5919 | }; | ||
5920 | /* fill in the dac_nids table from the parsed pin configuration */ | ||
5921 | static int vt1812_auto_fill_dac_nids(struct via_spec *spec, | ||
5922 | const struct auto_pin_cfg *cfg) | ||
5923 | { | ||
5924 | spec->multiout.num_dacs = 1; | ||
5925 | spec->multiout.dac_nids = spec->private_dac_nids; | ||
5926 | if (cfg->line_out_pins[0]) | ||
5927 | spec->multiout.dac_nids[0] = 0x8; | ||
5928 | return 0; | ||
5929 | } | ||
5930 | |||
5931 | |||
5932 | /* add playback controls from the parsed DAC table */ | ||
5933 | static int vt1812_auto_create_multi_out_ctls(struct via_spec *spec, | ||
5934 | const struct auto_pin_cfg *cfg) | ||
5935 | { | ||
5936 | int err; | ||
5937 | |||
5938 | if (!cfg->line_out_pins[0]) | ||
5939 | return -1; | ||
5940 | |||
5941 | /* Line-Out: PortE */ | ||
5942 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
5943 | "Master Front Playback Volume", | ||
5944 | HDA_COMPOSE_AMP_VAL(0x8, 3, 0, HDA_OUTPUT)); | ||
5945 | if (err < 0) | ||
5946 | return err; | ||
5947 | err = via_add_control(spec, VIA_CTL_WIDGET_BIND_PIN_MUTE, | ||
5948 | "Master Front Playback Switch", | ||
5949 | HDA_COMPOSE_AMP_VAL(0x28, 3, 0, HDA_OUTPUT)); | ||
5950 | if (err < 0) | ||
5951 | return err; | ||
5952 | |||
5953 | return 0; | ||
5954 | } | ||
5955 | |||
5956 | static int vt1812_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) | ||
5957 | { | ||
5958 | int err; | ||
5959 | |||
5960 | if (!pin) | ||
5961 | return 0; | ||
5962 | |||
5963 | spec->multiout.hp_nid = 0x9; | ||
5964 | spec->hp_independent_mode_index = 1; | ||
5965 | |||
5966 | |||
5967 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
5968 | "Headphone Playback Volume", | ||
5969 | HDA_COMPOSE_AMP_VAL( | ||
5970 | spec->multiout.hp_nid, 3, 0, HDA_OUTPUT)); | ||
5971 | if (err < 0) | ||
5972 | return err; | ||
5973 | |||
5974 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
5975 | "Headphone Playback Switch", | ||
5976 | HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); | ||
5977 | if (err < 0) | ||
5978 | return err; | ||
5979 | |||
5980 | create_hp_imux(spec); | ||
5981 | return 0; | ||
5982 | } | ||
5983 | |||
5984 | /* create playback/capture controls for input pins */ | ||
5985 | static int vt1812_auto_create_analog_input_ctls(struct via_spec *spec, | ||
5986 | const struct auto_pin_cfg *cfg) | ||
5987 | { | ||
5988 | static char *labels[] = { | ||
5989 | "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL | ||
5990 | }; | ||
5991 | struct hda_input_mux *imux = &spec->private_imux[0]; | ||
5992 | int i, err, idx = 0; | ||
5993 | |||
5994 | for (i = 0; i < AUTO_PIN_LAST; i++) { | ||
5995 | if (!cfg->input_pins[i]) | ||
5996 | continue; | ||
5997 | |||
5998 | switch (cfg->input_pins[i]) { | ||
5999 | case 0x2b: /* Mic */ | ||
6000 | idx = 0; | ||
6001 | break; | ||
6002 | |||
6003 | case 0x2a: /* Line In */ | ||
6004 | idx = 1; | ||
6005 | break; | ||
6006 | |||
6007 | case 0x29: /* Front Mic */ | ||
6008 | idx = 2; | ||
6009 | break; | ||
6010 | } | ||
6011 | err = via_new_analog_input(spec, labels[i], idx, 0x21); | ||
6012 | if (err < 0) | ||
6013 | return err; | ||
6014 | imux->items[imux->num_items].label = labels[i]; | ||
6015 | imux->items[imux->num_items].index = idx; | ||
6016 | imux->num_items++; | ||
6017 | } | ||
6018 | /* build volume/mute control of loopback */ | ||
6019 | err = via_new_analog_input(spec, "Stereo Mixer", 5, 0x21); | ||
6020 | if (err < 0) | ||
6021 | return err; | ||
6022 | |||
6023 | /* for internal loopback recording select */ | ||
6024 | imux->items[imux->num_items].label = "Stereo Mixer"; | ||
6025 | imux->items[imux->num_items].index = 5; | ||
6026 | imux->num_items++; | ||
6027 | |||
6028 | /* for digital mic select */ | ||
6029 | imux->items[imux->num_items].label = "Digital Mic"; | ||
6030 | imux->items[imux->num_items].index = 6; | ||
6031 | imux->num_items++; | ||
6032 | |||
6033 | return 0; | ||
6034 | } | ||
6035 | |||
6036 | static int vt1812_parse_auto_config(struct hda_codec *codec) | ||
6037 | { | ||
6038 | struct via_spec *spec = codec->spec; | ||
6039 | int err; | ||
6040 | |||
6041 | |||
6042 | err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); | ||
6043 | if (err < 0) | ||
6044 | return err; | ||
6045 | fill_dig_outs(codec); | ||
6046 | err = vt1812_auto_fill_dac_nids(spec, &spec->autocfg); | ||
6047 | if (err < 0) | ||
6048 | return err; | ||
6049 | |||
6050 | if (!spec->autocfg.line_outs && !spec->autocfg.hp_outs) | ||
6051 | return 0; /* can't find valid BIOS pin config */ | ||
6052 | |||
6053 | err = vt1812_auto_create_multi_out_ctls(spec, &spec->autocfg); | ||
6054 | if (err < 0) | ||
6055 | return err; | ||
6056 | err = vt1812_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); | ||
6057 | if (err < 0) | ||
6058 | return err; | ||
6059 | err = vt1812_auto_create_analog_input_ctls(spec, &spec->autocfg); | ||
6060 | if (err < 0) | ||
6061 | return err; | ||
6062 | |||
6063 | spec->multiout.max_channels = spec->multiout.num_dacs * 2; | ||
6064 | |||
6065 | fill_dig_outs(codec); | ||
6066 | |||
6067 | if (spec->kctls.list) | ||
6068 | spec->mixers[spec->num_mixers++] = spec->kctls.list; | ||
6069 | |||
6070 | spec->input_mux = &spec->private_imux[0]; | ||
6071 | |||
6072 | if (spec->hp_mux) | ||
6073 | spec->mixers[spec->num_mixers++] = via_hp_mixer; | ||
6074 | |||
6075 | return 1; | ||
6076 | } | ||
6077 | |||
6078 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
6079 | static struct hda_amp_list vt1812_loopbacks[] = { | ||
6080 | { 0x21, HDA_INPUT, 0 }, | ||
6081 | { 0x21, HDA_INPUT, 1 }, | ||
6082 | { 0x21, HDA_INPUT, 2 }, | ||
6083 | { } /* end */ | ||
6084 | }; | ||
6085 | #endif | ||
6086 | |||
6087 | |||
6088 | /* patch for vt1812 */ | ||
6089 | static int patch_vt1812(struct hda_codec *codec) | ||
6090 | { | ||
6091 | struct via_spec *spec; | ||
6092 | int err; | ||
6093 | |||
6094 | /* create a codec specific record */ | ||
6095 | spec = kzalloc(sizeof(*spec), GFP_KERNEL); | ||
6096 | if (spec == NULL) | ||
6097 | return -ENOMEM; | ||
6098 | |||
6099 | codec->spec = spec; | ||
6100 | |||
6101 | /* automatic parse from the BIOS config */ | ||
6102 | err = vt1812_parse_auto_config(codec); | ||
6103 | if (err < 0) { | ||
6104 | via_free(codec); | ||
6105 | return err; | ||
6106 | } else if (!err) { | ||
6107 | printk(KERN_INFO "hda_codec: Cannot set up configuration " | ||
6108 | "from BIOS. Using genenic mode...\n"); | ||
6109 | } | ||
6110 | |||
6111 | |||
6112 | spec->init_verbs[spec->num_iverbs++] = vt1812_volume_init_verbs; | ||
6113 | spec->init_verbs[spec->num_iverbs++] = vt1812_uniwill_init_verbs; | ||
6114 | |||
6115 | spec->stream_name_analog = "VT1812 Analog"; | ||
6116 | spec->stream_analog_playback = &vt1812_pcm_analog_playback; | ||
6117 | spec->stream_analog_capture = &vt1812_pcm_analog_capture; | ||
6118 | |||
6119 | spec->stream_name_digital = "VT1812 Digital"; | ||
6120 | spec->stream_digital_playback = &vt1812_pcm_digital_playback; | ||
6121 | |||
6122 | |||
6123 | if (!spec->adc_nids && spec->input_mux) { | ||
6124 | spec->adc_nids = vt1812_adc_nids; | ||
6125 | spec->num_adc_nids = ARRAY_SIZE(vt1812_adc_nids); | ||
6126 | get_mux_nids(codec); | ||
6127 | override_mic_boost(codec, 0x2b, 0, 3, 40); | ||
6128 | override_mic_boost(codec, 0x29, 0, 3, 40); | ||
6129 | spec->mixers[spec->num_mixers] = vt1812_capture_mixer; | ||
6130 | spec->num_mixers++; | ||
6131 | } | ||
6132 | |||
6133 | codec->patch_ops = via_patch_ops; | ||
6134 | |||
6135 | codec->patch_ops.init = via_auto_init; | ||
6136 | codec->patch_ops.unsol_event = via_unsol_event; | ||
6137 | |||
6138 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
6139 | spec->loopback.amplist = vt1812_loopbacks; | ||
6140 | #endif | ||
3245 | 6141 | ||
3246 | return 0; | 6142 | return 0; |
3247 | } | 6143 | } |
@@ -3318,6 +6214,23 @@ static struct hda_codec_preset snd_hda_preset_via[] = { | |||
3318 | .patch = patch_vt1702}, | 6214 | .patch = patch_vt1702}, |
3319 | { .id = 0x11067398, .name = "VT1702", | 6215 | { .id = 0x11067398, .name = "VT1702", |
3320 | .patch = patch_vt1702}, | 6216 | .patch = patch_vt1702}, |
6217 | { .id = 0x11060428, .name = "VT1718S", | ||
6218 | .patch = patch_vt1718S}, | ||
6219 | { .id = 0x11064428, .name = "VT1718S", | ||
6220 | .patch = patch_vt1718S}, | ||
6221 | { .id = 0x11060441, .name = "VT2020", | ||
6222 | .patch = patch_vt1718S}, | ||
6223 | { .id = 0x11064441, .name = "VT1828S", | ||
6224 | .patch = patch_vt1718S}, | ||
6225 | { .id = 0x11060433, .name = "VT1716S", | ||
6226 | .patch = patch_vt1716S}, | ||
6227 | { .id = 0x1106a721, .name = "VT1716S", | ||
6228 | .patch = patch_vt1716S}, | ||
6229 | { .id = 0x11060438, .name = "VT2002P", .patch = patch_vt2002P}, | ||
6230 | { .id = 0x11064438, .name = "VT2002P", .patch = patch_vt2002P}, | ||
6231 | { .id = 0x11060448, .name = "VT1812", .patch = patch_vt1812}, | ||
6232 | { .id = 0x11060440, .name = "VT1818S", | ||
6233 | .patch = patch_vt1708S}, | ||
3321 | {} /* terminator */ | 6234 | {} /* terminator */ |
3322 | }; | 6235 | }; |
3323 | 6236 | ||
diff --git a/sound/pci/ice1712/Makefile b/sound/pci/ice1712/Makefile index 536eae2ccf94..f7ce33f00ea5 100644 --- a/sound/pci/ice1712/Makefile +++ b/sound/pci/ice1712/Makefile | |||
@@ -5,7 +5,7 @@ | |||
5 | 5 | ||
6 | snd-ice17xx-ak4xxx-objs := ak4xxx.o | 6 | snd-ice17xx-ak4xxx-objs := ak4xxx.o |
7 | snd-ice1712-objs := ice1712.o delta.o hoontech.o ews.o | 7 | snd-ice1712-objs := ice1712.o delta.o hoontech.o ews.o |
8 | snd-ice1724-objs := ice1724.o amp.o revo.o aureon.o vt1720_mobo.o pontis.o prodigy192.o prodigy_hifi.o juli.o phase.o wtm.o se.o maya44.o | 8 | snd-ice1724-objs := ice1724.o amp.o revo.o aureon.o vt1720_mobo.o pontis.o prodigy192.o prodigy_hifi.o juli.o phase.o wtm.o se.o maya44.o quartet.o |
9 | 9 | ||
10 | # Toplevel Module Dependency | 10 | # Toplevel Module Dependency |
11 | obj-$(CONFIG_SND_ICE1712) += snd-ice1712.o snd-ice17xx-ak4xxx.o | 11 | obj-$(CONFIG_SND_ICE1712) += snd-ice1712.o snd-ice17xx-ak4xxx.o |
diff --git a/sound/pci/ice1712/ice1712.c b/sound/pci/ice1712/ice1712.c index d74033a2cfbe..c7cff6f8168a 100644 --- a/sound/pci/ice1712/ice1712.c +++ b/sound/pci/ice1712/ice1712.c | |||
@@ -298,6 +298,16 @@ static void snd_ice1712_set_gpio_dir(struct snd_ice1712 *ice, unsigned int data) | |||
298 | inb(ICEREG(ice, DATA)); /* dummy read for pci-posting */ | 298 | inb(ICEREG(ice, DATA)); /* dummy read for pci-posting */ |
299 | } | 299 | } |
300 | 300 | ||
301 | static unsigned int snd_ice1712_get_gpio_dir(struct snd_ice1712 *ice) | ||
302 | { | ||
303 | return snd_ice1712_read(ice, ICE1712_IREG_GPIO_DIRECTION); | ||
304 | } | ||
305 | |||
306 | static unsigned int snd_ice1712_get_gpio_mask(struct snd_ice1712 *ice) | ||
307 | { | ||
308 | return snd_ice1712_read(ice, ICE1712_IREG_GPIO_WRITE_MASK); | ||
309 | } | ||
310 | |||
301 | static void snd_ice1712_set_gpio_mask(struct snd_ice1712 *ice, unsigned int data) | 311 | static void snd_ice1712_set_gpio_mask(struct snd_ice1712 *ice, unsigned int data) |
302 | { | 312 | { |
303 | snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, data); | 313 | snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, data); |
@@ -2557,7 +2567,9 @@ static int __devinit snd_ice1712_create(struct snd_card *card, | |||
2557 | mutex_init(&ice->i2c_mutex); | 2567 | mutex_init(&ice->i2c_mutex); |
2558 | mutex_init(&ice->open_mutex); | 2568 | mutex_init(&ice->open_mutex); |
2559 | ice->gpio.set_mask = snd_ice1712_set_gpio_mask; | 2569 | ice->gpio.set_mask = snd_ice1712_set_gpio_mask; |
2570 | ice->gpio.get_mask = snd_ice1712_get_gpio_mask; | ||
2560 | ice->gpio.set_dir = snd_ice1712_set_gpio_dir; | 2571 | ice->gpio.set_dir = snd_ice1712_set_gpio_dir; |
2572 | ice->gpio.get_dir = snd_ice1712_get_gpio_dir; | ||
2561 | ice->gpio.set_data = snd_ice1712_set_gpio_data; | 2573 | ice->gpio.set_data = snd_ice1712_set_gpio_data; |
2562 | ice->gpio.get_data = snd_ice1712_get_gpio_data; | 2574 | ice->gpio.get_data = snd_ice1712_get_gpio_data; |
2563 | 2575 | ||
diff --git a/sound/pci/ice1712/ice1712.h b/sound/pci/ice1712/ice1712.h index d063149e7047..0da778a69ef8 100644 --- a/sound/pci/ice1712/ice1712.h +++ b/sound/pci/ice1712/ice1712.h | |||
@@ -359,7 +359,9 @@ struct snd_ice1712 { | |||
359 | unsigned int saved[2]; /* for ewx_i2c */ | 359 | unsigned int saved[2]; /* for ewx_i2c */ |
360 | /* operators */ | 360 | /* operators */ |
361 | void (*set_mask)(struct snd_ice1712 *ice, unsigned int data); | 361 | void (*set_mask)(struct snd_ice1712 *ice, unsigned int data); |
362 | unsigned int (*get_mask)(struct snd_ice1712 *ice); | ||
362 | void (*set_dir)(struct snd_ice1712 *ice, unsigned int data); | 363 | void (*set_dir)(struct snd_ice1712 *ice, unsigned int data); |
364 | unsigned int (*get_dir)(struct snd_ice1712 *ice); | ||
363 | void (*set_data)(struct snd_ice1712 *ice, unsigned int data); | 365 | void (*set_data)(struct snd_ice1712 *ice, unsigned int data); |
364 | unsigned int (*get_data)(struct snd_ice1712 *ice); | 366 | unsigned int (*get_data)(struct snd_ice1712 *ice); |
365 | /* misc operators - move to another place? */ | 367 | /* misc operators - move to another place? */ |
@@ -377,8 +379,11 @@ struct snd_ice1712 { | |||
377 | unsigned int (*get_rate)(struct snd_ice1712 *ice); | 379 | unsigned int (*get_rate)(struct snd_ice1712 *ice); |
378 | void (*set_rate)(struct snd_ice1712 *ice, unsigned int rate); | 380 | void (*set_rate)(struct snd_ice1712 *ice, unsigned int rate); |
379 | unsigned char (*set_mclk)(struct snd_ice1712 *ice, unsigned int rate); | 381 | unsigned char (*set_mclk)(struct snd_ice1712 *ice, unsigned int rate); |
380 | void (*set_spdif_clock)(struct snd_ice1712 *ice); | 382 | int (*set_spdif_clock)(struct snd_ice1712 *ice, int type); |
381 | 383 | int (*get_spdif_master_type)(struct snd_ice1712 *ice); | |
384 | char **ext_clock_names; | ||
385 | int ext_clock_count; | ||
386 | void (*pro_open)(struct snd_ice1712 *, struct snd_pcm_substream *); | ||
382 | #ifdef CONFIG_PM | 387 | #ifdef CONFIG_PM |
383 | int (*pm_suspend)(struct snd_ice1712 *); | 388 | int (*pm_suspend)(struct snd_ice1712 *); |
384 | int (*pm_resume)(struct snd_ice1712 *); | 389 | int (*pm_resume)(struct snd_ice1712 *); |
@@ -399,6 +404,11 @@ static inline void snd_ice1712_gpio_set_dir(struct snd_ice1712 *ice, unsigned in | |||
399 | ice->gpio.set_dir(ice, bits); | 404 | ice->gpio.set_dir(ice, bits); |
400 | } | 405 | } |
401 | 406 | ||
407 | static inline unsigned int snd_ice1712_gpio_get_dir(struct snd_ice1712 *ice) | ||
408 | { | ||
409 | return ice->gpio.get_dir(ice); | ||
410 | } | ||
411 | |||
402 | static inline void snd_ice1712_gpio_set_mask(struct snd_ice1712 *ice, unsigned int bits) | 412 | static inline void snd_ice1712_gpio_set_mask(struct snd_ice1712 *ice, unsigned int bits) |
403 | { | 413 | { |
404 | ice->gpio.set_mask(ice, bits); | 414 | ice->gpio.set_mask(ice, bits); |
diff --git a/sound/pci/ice1712/ice1724.c b/sound/pci/ice1712/ice1724.c index 10fc92c05574..ae29073eea93 100644 --- a/sound/pci/ice1712/ice1724.c +++ b/sound/pci/ice1712/ice1724.c | |||
@@ -53,6 +53,7 @@ | |||
53 | #include "phase.h" | 53 | #include "phase.h" |
54 | #include "wtm.h" | 54 | #include "wtm.h" |
55 | #include "se.h" | 55 | #include "se.h" |
56 | #include "quartet.h" | ||
56 | 57 | ||
57 | MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>"); | 58 | MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>"); |
58 | MODULE_DESCRIPTION("VIA ICEnsemble ICE1724/1720 (Envy24HT/PT)"); | 59 | MODULE_DESCRIPTION("VIA ICEnsemble ICE1724/1720 (Envy24HT/PT)"); |
@@ -70,6 +71,7 @@ MODULE_SUPPORTED_DEVICE("{" | |||
70 | PHASE_DEVICE_DESC | 71 | PHASE_DEVICE_DESC |
71 | WTM_DEVICE_DESC | 72 | WTM_DEVICE_DESC |
72 | SE_DEVICE_DESC | 73 | SE_DEVICE_DESC |
74 | QTET_DEVICE_DESC | ||
73 | "{VIA,VT1720}," | 75 | "{VIA,VT1720}," |
74 | "{VIA,VT1724}," | 76 | "{VIA,VT1724}," |
75 | "{ICEnsemble,Generic ICE1724}," | 77 | "{ICEnsemble,Generic ICE1724}," |
@@ -104,6 +106,8 @@ static int PRO_RATE_LOCKED; | |||
104 | static int PRO_RATE_RESET = 1; | 106 | static int PRO_RATE_RESET = 1; |
105 | static unsigned int PRO_RATE_DEFAULT = 44100; | 107 | static unsigned int PRO_RATE_DEFAULT = 44100; |
106 | 108 | ||
109 | static char *ext_clock_names[1] = { "IEC958 In" }; | ||
110 | |||
107 | /* | 111 | /* |
108 | * Basic I/O | 112 | * Basic I/O |
109 | */ | 113 | */ |
@@ -118,9 +122,12 @@ static inline int stdclock_is_spdif_master(struct snd_ice1712 *ice) | |||
118 | return (inb(ICEMT1724(ice, RATE)) & VT1724_SPDIF_MASTER) ? 1 : 0; | 122 | return (inb(ICEMT1724(ice, RATE)) & VT1724_SPDIF_MASTER) ? 1 : 0; |
119 | } | 123 | } |
120 | 124 | ||
125 | /* | ||
126 | * locking rate makes sense only for internal clock mode | ||
127 | */ | ||
121 | static inline int is_pro_rate_locked(struct snd_ice1712 *ice) | 128 | static inline int is_pro_rate_locked(struct snd_ice1712 *ice) |
122 | { | 129 | { |
123 | return ice->is_spdif_master(ice) || PRO_RATE_LOCKED; | 130 | return (!ice->is_spdif_master(ice)) && PRO_RATE_LOCKED; |
124 | } | 131 | } |
125 | 132 | ||
126 | /* | 133 | /* |
@@ -196,6 +203,12 @@ static void snd_vt1724_set_gpio_dir(struct snd_ice1712 *ice, unsigned int data) | |||
196 | inw(ICEREG1724(ice, GPIO_DIRECTION)); /* dummy read for pci-posting */ | 203 | inw(ICEREG1724(ice, GPIO_DIRECTION)); /* dummy read for pci-posting */ |
197 | } | 204 | } |
198 | 205 | ||
206 | /* get gpio direction 0 = read, 1 = write */ | ||
207 | static unsigned int snd_vt1724_get_gpio_dir(struct snd_ice1712 *ice) | ||
208 | { | ||
209 | return inl(ICEREG1724(ice, GPIO_DIRECTION)); | ||
210 | } | ||
211 | |||
199 | /* set the gpio mask (0 = writable) */ | 212 | /* set the gpio mask (0 = writable) */ |
200 | static void snd_vt1724_set_gpio_mask(struct snd_ice1712 *ice, unsigned int data) | 213 | static void snd_vt1724_set_gpio_mask(struct snd_ice1712 *ice, unsigned int data) |
201 | { | 214 | { |
@@ -205,6 +218,17 @@ static void snd_vt1724_set_gpio_mask(struct snd_ice1712 *ice, unsigned int data) | |||
205 | inw(ICEREG1724(ice, GPIO_WRITE_MASK)); /* dummy read for pci-posting */ | 218 | inw(ICEREG1724(ice, GPIO_WRITE_MASK)); /* dummy read for pci-posting */ |
206 | } | 219 | } |
207 | 220 | ||
221 | static unsigned int snd_vt1724_get_gpio_mask(struct snd_ice1712 *ice) | ||
222 | { | ||
223 | unsigned int mask; | ||
224 | if (!ice->vt1720) | ||
225 | mask = (unsigned int)inb(ICEREG1724(ice, GPIO_WRITE_MASK_22)); | ||
226 | else | ||
227 | mask = 0; | ||
228 | mask = (mask << 16) | inw(ICEREG1724(ice, GPIO_WRITE_MASK)); | ||
229 | return mask; | ||
230 | } | ||
231 | |||
208 | static void snd_vt1724_set_gpio_data(struct snd_ice1712 *ice, unsigned int data) | 232 | static void snd_vt1724_set_gpio_data(struct snd_ice1712 *ice, unsigned int data) |
209 | { | 233 | { |
210 | outw(data, ICEREG1724(ice, GPIO_DATA)); | 234 | outw(data, ICEREG1724(ice, GPIO_DATA)); |
@@ -651,16 +675,22 @@ static int snd_vt1724_set_pro_rate(struct snd_ice1712 *ice, unsigned int rate, | |||
651 | return ((rate == ice->cur_rate) && !force) ? 0 : -EBUSY; | 675 | return ((rate == ice->cur_rate) && !force) ? 0 : -EBUSY; |
652 | } | 676 | } |
653 | if (!force && is_pro_rate_locked(ice)) { | 677 | if (!force && is_pro_rate_locked(ice)) { |
678 | /* comparing required and current rate - makes sense for | ||
679 | * internal clock only */ | ||
654 | spin_unlock_irqrestore(&ice->reg_lock, flags); | 680 | spin_unlock_irqrestore(&ice->reg_lock, flags); |
655 | return (rate == ice->cur_rate) ? 0 : -EBUSY; | 681 | return (rate == ice->cur_rate) ? 0 : -EBUSY; |
656 | } | 682 | } |
657 | 683 | ||
658 | old_rate = ice->get_rate(ice); | 684 | if (force || !ice->is_spdif_master(ice)) { |
659 | if (force || (old_rate != rate)) | 685 | /* force means the rate was switched by ucontrol, otherwise |
660 | ice->set_rate(ice, rate); | 686 | * setting clock rate for internal clock mode */ |
661 | else if (rate == ice->cur_rate) { | 687 | old_rate = ice->get_rate(ice); |
662 | spin_unlock_irqrestore(&ice->reg_lock, flags); | 688 | if (force || (old_rate != rate)) |
663 | return 0; | 689 | ice->set_rate(ice, rate); |
690 | else if (rate == ice->cur_rate) { | ||
691 | spin_unlock_irqrestore(&ice->reg_lock, flags); | ||
692 | return 0; | ||
693 | } | ||
664 | } | 694 | } |
665 | 695 | ||
666 | ice->cur_rate = rate; | 696 | ice->cur_rate = rate; |
@@ -1016,6 +1046,8 @@ static int snd_vt1724_playback_pro_open(struct snd_pcm_substream *substream) | |||
1016 | VT1724_BUFFER_ALIGN); | 1046 | VT1724_BUFFER_ALIGN); |
1017 | snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, | 1047 | snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, |
1018 | VT1724_BUFFER_ALIGN); | 1048 | VT1724_BUFFER_ALIGN); |
1049 | if (ice->pro_open) | ||
1050 | ice->pro_open(ice, substream); | ||
1019 | return 0; | 1051 | return 0; |
1020 | } | 1052 | } |
1021 | 1053 | ||
@@ -1034,6 +1066,8 @@ static int snd_vt1724_capture_pro_open(struct snd_pcm_substream *substream) | |||
1034 | VT1724_BUFFER_ALIGN); | 1066 | VT1724_BUFFER_ALIGN); |
1035 | snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, | 1067 | snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, |
1036 | VT1724_BUFFER_ALIGN); | 1068 | VT1724_BUFFER_ALIGN); |
1069 | if (ice->pro_open) | ||
1070 | ice->pro_open(ice, substream); | ||
1037 | return 0; | 1071 | return 0; |
1038 | } | 1072 | } |
1039 | 1073 | ||
@@ -1787,15 +1821,21 @@ static int snd_vt1724_pro_internal_clock_info(struct snd_kcontrol *kcontrol, | |||
1787 | struct snd_ctl_elem_info *uinfo) | 1821 | struct snd_ctl_elem_info *uinfo) |
1788 | { | 1822 | { |
1789 | struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); | 1823 | struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); |
1790 | 1824 | int hw_rates_count = ice->hw_rates->count; | |
1791 | uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; | 1825 | uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; |
1792 | uinfo->count = 1; | 1826 | uinfo->count = 1; |
1793 | uinfo->value.enumerated.items = ice->hw_rates->count + 1; | 1827 | |
1828 | uinfo->value.enumerated.items = hw_rates_count + ice->ext_clock_count; | ||
1829 | /* upper limit - keep at top */ | ||
1794 | if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items) | 1830 | if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items) |
1795 | uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1; | 1831 | uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1; |
1796 | if (uinfo->value.enumerated.item == uinfo->value.enumerated.items - 1) | 1832 | if (uinfo->value.enumerated.item >= hw_rates_count) |
1797 | strcpy(uinfo->value.enumerated.name, "IEC958 Input"); | 1833 | /* ext_clock items */ |
1834 | strcpy(uinfo->value.enumerated.name, | ||
1835 | ice->ext_clock_names[ | ||
1836 | uinfo->value.enumerated.item - hw_rates_count]); | ||
1798 | else | 1837 | else |
1838 | /* int clock items */ | ||
1799 | sprintf(uinfo->value.enumerated.name, "%d", | 1839 | sprintf(uinfo->value.enumerated.name, "%d", |
1800 | ice->hw_rates->list[uinfo->value.enumerated.item]); | 1840 | ice->hw_rates->list[uinfo->value.enumerated.item]); |
1801 | return 0; | 1841 | return 0; |
@@ -1809,7 +1849,8 @@ static int snd_vt1724_pro_internal_clock_get(struct snd_kcontrol *kcontrol, | |||
1809 | 1849 | ||
1810 | spin_lock_irq(&ice->reg_lock); | 1850 | spin_lock_irq(&ice->reg_lock); |
1811 | if (ice->is_spdif_master(ice)) { | 1851 | if (ice->is_spdif_master(ice)) { |
1812 | ucontrol->value.enumerated.item[0] = ice->hw_rates->count; | 1852 | ucontrol->value.enumerated.item[0] = ice->hw_rates->count + |
1853 | ice->get_spdif_master_type(ice); | ||
1813 | } else { | 1854 | } else { |
1814 | rate = ice->get_rate(ice); | 1855 | rate = ice->get_rate(ice); |
1815 | ucontrol->value.enumerated.item[0] = 0; | 1856 | ucontrol->value.enumerated.item[0] = 0; |
@@ -1824,8 +1865,14 @@ static int snd_vt1724_pro_internal_clock_get(struct snd_kcontrol *kcontrol, | |||
1824 | return 0; | 1865 | return 0; |
1825 | } | 1866 | } |
1826 | 1867 | ||
1868 | static int stdclock_get_spdif_master_type(struct snd_ice1712 *ice) | ||
1869 | { | ||
1870 | /* standard external clock - only single type - SPDIF IN */ | ||
1871 | return 0; | ||
1872 | } | ||
1873 | |||
1827 | /* setting clock to external - SPDIF */ | 1874 | /* setting clock to external - SPDIF */ |
1828 | static void stdclock_set_spdif_clock(struct snd_ice1712 *ice) | 1875 | static int stdclock_set_spdif_clock(struct snd_ice1712 *ice, int type) |
1829 | { | 1876 | { |
1830 | unsigned char oval; | 1877 | unsigned char oval; |
1831 | unsigned char i2s_oval; | 1878 | unsigned char i2s_oval; |
@@ -1834,27 +1881,30 @@ static void stdclock_set_spdif_clock(struct snd_ice1712 *ice) | |||
1834 | /* setting 256fs */ | 1881 | /* setting 256fs */ |
1835 | i2s_oval = inb(ICEMT1724(ice, I2S_FORMAT)); | 1882 | i2s_oval = inb(ICEMT1724(ice, I2S_FORMAT)); |
1836 | outb(i2s_oval & ~VT1724_MT_I2S_MCLK_128X, ICEMT1724(ice, I2S_FORMAT)); | 1883 | outb(i2s_oval & ~VT1724_MT_I2S_MCLK_128X, ICEMT1724(ice, I2S_FORMAT)); |
1884 | return 0; | ||
1837 | } | 1885 | } |
1838 | 1886 | ||
1887 | |||
1839 | static int snd_vt1724_pro_internal_clock_put(struct snd_kcontrol *kcontrol, | 1888 | static int snd_vt1724_pro_internal_clock_put(struct snd_kcontrol *kcontrol, |
1840 | struct snd_ctl_elem_value *ucontrol) | 1889 | struct snd_ctl_elem_value *ucontrol) |
1841 | { | 1890 | { |
1842 | struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); | 1891 | struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); |
1843 | unsigned int old_rate, new_rate; | 1892 | unsigned int old_rate, new_rate; |
1844 | unsigned int item = ucontrol->value.enumerated.item[0]; | 1893 | unsigned int item = ucontrol->value.enumerated.item[0]; |
1845 | unsigned int spdif = ice->hw_rates->count; | 1894 | unsigned int first_ext_clock = ice->hw_rates->count; |
1846 | 1895 | ||
1847 | if (item > spdif) | 1896 | if (item > first_ext_clock + ice->ext_clock_count - 1) |
1848 | return -EINVAL; | 1897 | return -EINVAL; |
1849 | 1898 | ||
1899 | /* if rate = 0 => external clock */ | ||
1850 | spin_lock_irq(&ice->reg_lock); | 1900 | spin_lock_irq(&ice->reg_lock); |
1851 | if (ice->is_spdif_master(ice)) | 1901 | if (ice->is_spdif_master(ice)) |
1852 | old_rate = 0; | 1902 | old_rate = 0; |
1853 | else | 1903 | else |
1854 | old_rate = ice->get_rate(ice); | 1904 | old_rate = ice->get_rate(ice); |
1855 | if (item == spdif) { | 1905 | if (item >= first_ext_clock) { |
1856 | /* switching to external clock via SPDIF */ | 1906 | /* switching to external clock */ |
1857 | ice->set_spdif_clock(ice); | 1907 | ice->set_spdif_clock(ice, item - first_ext_clock); |
1858 | new_rate = 0; | 1908 | new_rate = 0; |
1859 | } else { | 1909 | } else { |
1860 | /* internal on-card clock */ | 1910 | /* internal on-card clock */ |
@@ -1866,7 +1916,7 @@ static int snd_vt1724_pro_internal_clock_put(struct snd_kcontrol *kcontrol, | |||
1866 | } | 1916 | } |
1867 | spin_unlock_irq(&ice->reg_lock); | 1917 | spin_unlock_irq(&ice->reg_lock); |
1868 | 1918 | ||
1869 | /* the first reset to the SPDIF master mode? */ | 1919 | /* the first switch to the ext. clock mode? */ |
1870 | if (old_rate != new_rate && !new_rate) { | 1920 | if (old_rate != new_rate && !new_rate) { |
1871 | /* notify akm chips as well */ | 1921 | /* notify akm chips as well */ |
1872 | unsigned int i; | 1922 | unsigned int i; |
@@ -2136,6 +2186,7 @@ static struct snd_ice1712_card_info *card_tables[] __devinitdata = { | |||
2136 | snd_vt1724_phase_cards, | 2186 | snd_vt1724_phase_cards, |
2137 | snd_vt1724_wtm_cards, | 2187 | snd_vt1724_wtm_cards, |
2138 | snd_vt1724_se_cards, | 2188 | snd_vt1724_se_cards, |
2189 | snd_vt1724_qtet_cards, | ||
2139 | NULL, | 2190 | NULL, |
2140 | }; | 2191 | }; |
2141 | 2192 | ||
@@ -2434,7 +2485,9 @@ static int __devinit snd_vt1724_create(struct snd_card *card, | |||
2434 | mutex_init(&ice->open_mutex); | 2485 | mutex_init(&ice->open_mutex); |
2435 | mutex_init(&ice->i2c_mutex); | 2486 | mutex_init(&ice->i2c_mutex); |
2436 | ice->gpio.set_mask = snd_vt1724_set_gpio_mask; | 2487 | ice->gpio.set_mask = snd_vt1724_set_gpio_mask; |
2488 | ice->gpio.get_mask = snd_vt1724_get_gpio_mask; | ||
2437 | ice->gpio.set_dir = snd_vt1724_set_gpio_dir; | 2489 | ice->gpio.set_dir = snd_vt1724_set_gpio_dir; |
2490 | ice->gpio.get_dir = snd_vt1724_get_gpio_dir; | ||
2438 | ice->gpio.set_data = snd_vt1724_set_gpio_data; | 2491 | ice->gpio.set_data = snd_vt1724_set_gpio_data; |
2439 | ice->gpio.get_data = snd_vt1724_get_gpio_data; | 2492 | ice->gpio.get_data = snd_vt1724_get_gpio_data; |
2440 | ice->card = card; | 2493 | ice->card = card; |
@@ -2522,6 +2575,9 @@ static int __devinit snd_vt1724_probe(struct pci_dev *pci, | |||
2522 | return err; | 2575 | return err; |
2523 | } | 2576 | } |
2524 | 2577 | ||
2578 | /* field init before calling chip_init */ | ||
2579 | ice->ext_clock_count = 0; | ||
2580 | |||
2525 | for (tbl = card_tables; *tbl; tbl++) { | 2581 | for (tbl = card_tables; *tbl; tbl++) { |
2526 | for (c = *tbl; c->subvendor; c++) { | 2582 | for (c = *tbl; c->subvendor; c++) { |
2527 | if (c->subvendor == ice->eeprom.subvendor) { | 2583 | if (c->subvendor == ice->eeprom.subvendor) { |
@@ -2560,6 +2616,13 @@ __found: | |||
2560 | ice->set_mclk = stdclock_set_mclk; | 2616 | ice->set_mclk = stdclock_set_mclk; |
2561 | if (!ice->set_spdif_clock) | 2617 | if (!ice->set_spdif_clock) |
2562 | ice->set_spdif_clock = stdclock_set_spdif_clock; | 2618 | ice->set_spdif_clock = stdclock_set_spdif_clock; |
2619 | if (!ice->get_spdif_master_type) | ||
2620 | ice->get_spdif_master_type = stdclock_get_spdif_master_type; | ||
2621 | if (!ice->ext_clock_names) | ||
2622 | ice->ext_clock_names = ext_clock_names; | ||
2623 | if (!ice->ext_clock_count) | ||
2624 | ice->ext_clock_count = ARRAY_SIZE(ext_clock_names); | ||
2625 | |||
2563 | if (!ice->hw_rates) | 2626 | if (!ice->hw_rates) |
2564 | set_std_hw_rates(ice); | 2627 | set_std_hw_rates(ice); |
2565 | 2628 | ||
@@ -2719,7 +2782,7 @@ static int snd_vt1724_resume(struct pci_dev *pci) | |||
2719 | 2782 | ||
2720 | if (ice->pm_saved_is_spdif_master) { | 2783 | if (ice->pm_saved_is_spdif_master) { |
2721 | /* switching to external clock via SPDIF */ | 2784 | /* switching to external clock via SPDIF */ |
2722 | ice->set_spdif_clock(ice); | 2785 | ice->set_spdif_clock(ice, 0); |
2723 | } else { | 2786 | } else { |
2724 | /* internal on-card clock */ | 2787 | /* internal on-card clock */ |
2725 | snd_vt1724_set_pro_rate(ice, ice->pro_rate_default, 1); | 2788 | snd_vt1724_set_pro_rate(ice, ice->pro_rate_default, 1); |
diff --git a/sound/pci/ice1712/juli.c b/sound/pci/ice1712/juli.c index f5020ad99a10..0c9413d5341b 100644 --- a/sound/pci/ice1712/juli.c +++ b/sound/pci/ice1712/juli.c | |||
@@ -412,25 +412,6 @@ static struct snd_kcontrol_new juli_mute_controls[] __devinitdata = { | |||
412 | }, | 412 | }, |
413 | }; | 413 | }; |
414 | 414 | ||
415 | |||
416 | static void ak4358_proc_regs_read(struct snd_info_entry *entry, | ||
417 | struct snd_info_buffer *buffer) | ||
418 | { | ||
419 | struct snd_ice1712 *ice = (struct snd_ice1712 *)entry->private_data; | ||
420 | int reg, val; | ||
421 | for (reg = 0; reg <= 0xf; reg++) { | ||
422 | val = snd_akm4xxx_get(ice->akm, 0, reg); | ||
423 | snd_iprintf(buffer, "0x%02x = 0x%02x\n", reg, val); | ||
424 | } | ||
425 | } | ||
426 | |||
427 | static void ak4358_proc_init(struct snd_ice1712 *ice) | ||
428 | { | ||
429 | struct snd_info_entry *entry; | ||
430 | if (!snd_card_proc_new(ice->card, "ak4358_codec", &entry)) | ||
431 | snd_info_set_text_ops(entry, ice, ak4358_proc_regs_read); | ||
432 | } | ||
433 | |||
434 | static char *slave_vols[] __devinitdata = { | 415 | static char *slave_vols[] __devinitdata = { |
435 | PCM_VOLUME, | 416 | PCM_VOLUME, |
436 | MONITOR_AN_IN_VOLUME, | 417 | MONITOR_AN_IN_VOLUME, |
@@ -496,8 +477,6 @@ static int __devinit juli_add_controls(struct snd_ice1712 *ice) | |||
496 | /* only capture SPDIF over AK4114 */ | 477 | /* only capture SPDIF over AK4114 */ |
497 | err = snd_ak4114_build(spec->ak4114, NULL, | 478 | err = snd_ak4114_build(spec->ak4114, NULL, |
498 | ice->pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream); | 479 | ice->pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream); |
499 | |||
500 | ak4358_proc_init(ice); | ||
501 | if (err < 0) | 480 | if (err < 0) |
502 | return err; | 481 | return err; |
503 | return 0; | 482 | return 0; |
@@ -575,13 +554,14 @@ static inline unsigned char juli_set_mclk(struct snd_ice1712 *ice, | |||
575 | } | 554 | } |
576 | 555 | ||
577 | /* setting clock to external - SPDIF */ | 556 | /* setting clock to external - SPDIF */ |
578 | static void juli_set_spdif_clock(struct snd_ice1712 *ice) | 557 | static int juli_set_spdif_clock(struct snd_ice1712 *ice, int type) |
579 | { | 558 | { |
580 | unsigned int old; | 559 | unsigned int old; |
581 | old = ice->gpio.get_data(ice); | 560 | old = ice->gpio.get_data(ice); |
582 | /* external clock (= 0), multiply 1x, 48kHz */ | 561 | /* external clock (= 0), multiply 1x, 48kHz */ |
583 | ice->gpio.set_data(ice, (old & ~GPIO_RATE_MASK) | GPIO_MULTI_1X | | 562 | ice->gpio.set_data(ice, (old & ~GPIO_RATE_MASK) | GPIO_MULTI_1X | |
584 | GPIO_FREQ_48KHZ); | 563 | GPIO_FREQ_48KHZ); |
564 | return 0; | ||
585 | } | 565 | } |
586 | 566 | ||
587 | /* Called when ak4114 detects change in the input SPDIF stream */ | 567 | /* Called when ak4114 detects change in the input SPDIF stream */ |
diff --git a/sound/pci/ice1712/quartet.c b/sound/pci/ice1712/quartet.c new file mode 100644 index 000000000000..1948632787e6 --- /dev/null +++ b/sound/pci/ice1712/quartet.c | |||
@@ -0,0 +1,1130 @@ | |||
1 | /* | ||
2 | * ALSA driver for ICEnsemble VT1724 (Envy24HT) | ||
3 | * | ||
4 | * Lowlevel functions for Infrasonic Quartet | ||
5 | * | ||
6 | * Copyright (c) 2009 Pavel Hofman <pavel.hofman@ivitera.com> | ||
7 | * | ||
8 | * | ||
9 | * This program is free software; you can redistribute it and/or modify | ||
10 | * it under the terms of the GNU General Public License as published by | ||
11 | * the Free Software Foundation; either version 2 of the License, or | ||
12 | * (at your option) any later version. | ||
13 | * | ||
14 | * This program is distributed in the hope that it will be useful, | ||
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
17 | * GNU General Public License for more details. | ||
18 | * | ||
19 | * You should have received a copy of the GNU General Public License | ||
20 | * along with this program; if not, write to the Free Software | ||
21 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
22 | * | ||
23 | */ | ||
24 | |||
25 | #include <asm/io.h> | ||
26 | #include <linux/delay.h> | ||
27 | #include <linux/interrupt.h> | ||
28 | #include <linux/init.h> | ||
29 | #include <linux/slab.h> | ||
30 | #include <sound/core.h> | ||
31 | #include <sound/tlv.h> | ||
32 | #include <sound/info.h> | ||
33 | |||
34 | #include "ice1712.h" | ||
35 | #include "envy24ht.h" | ||
36 | #include <sound/ak4113.h> | ||
37 | #include "quartet.h" | ||
38 | |||
39 | struct qtet_spec { | ||
40 | struct ak4113 *ak4113; | ||
41 | unsigned int scr; /* system control register */ | ||
42 | unsigned int mcr; /* monitoring control register */ | ||
43 | unsigned int cpld; /* cpld register */ | ||
44 | }; | ||
45 | |||
46 | struct qtet_kcontrol_private { | ||
47 | unsigned int bit; | ||
48 | void (*set_register)(struct snd_ice1712 *ice, unsigned int val); | ||
49 | unsigned int (*get_register)(struct snd_ice1712 *ice); | ||
50 | unsigned char *texts[2]; | ||
51 | }; | ||
52 | |||
53 | enum { | ||
54 | IN12_SEL = 0, | ||
55 | IN34_SEL, | ||
56 | AIN34_SEL, | ||
57 | COAX_OUT, | ||
58 | IN12_MON12, | ||
59 | IN12_MON34, | ||
60 | IN34_MON12, | ||
61 | IN34_MON34, | ||
62 | OUT12_MON34, | ||
63 | OUT34_MON12, | ||
64 | }; | ||
65 | |||
66 | static char *ext_clock_names[3] = {"IEC958 In", "Word Clock 1xFS", | ||
67 | "Word Clock 256xFS"}; | ||
68 | |||
69 | /* chip address on I2C bus */ | ||
70 | #define AK4113_ADDR 0x26 /* S/PDIF receiver */ | ||
71 | |||
72 | /* chip address on SPI bus */ | ||
73 | #define AK4620_ADDR 0x02 /* ADC/DAC */ | ||
74 | |||
75 | |||
76 | /* | ||
77 | * GPIO pins | ||
78 | */ | ||
79 | |||
80 | /* GPIO0 - O - DATA0, def. 0 */ | ||
81 | #define GPIO_D0 (1<<0) | ||
82 | /* GPIO1 - I/O - DATA1, Jack Detect Input0 (0:present, 1:missing), def. 1 */ | ||
83 | #define GPIO_D1_JACKDTC0 (1<<1) | ||
84 | /* GPIO2 - I/O - DATA2, Jack Detect Input1 (0:present, 1:missing), def. 1 */ | ||
85 | #define GPIO_D2_JACKDTC1 (1<<2) | ||
86 | /* GPIO3 - I/O - DATA3, def. 1 */ | ||
87 | #define GPIO_D3 (1<<3) | ||
88 | /* GPIO4 - I/O - DATA4, SPI CDTO, def. 1 */ | ||
89 | #define GPIO_D4_SPI_CDTO (1<<4) | ||
90 | /* GPIO5 - I/O - DATA5, SPI CCLK, def. 1 */ | ||
91 | #define GPIO_D5_SPI_CCLK (1<<5) | ||
92 | /* GPIO6 - I/O - DATA6, Cable Detect Input (0:detected, 1:not detected */ | ||
93 | #define GPIO_D6_CD (1<<6) | ||
94 | /* GPIO7 - I/O - DATA7, Device Detect Input (0:detected, 1:not detected */ | ||
95 | #define GPIO_D7_DD (1<<7) | ||
96 | /* GPIO8 - O - CPLD Chip Select, def. 1 */ | ||
97 | #define GPIO_CPLD_CSN (1<<8) | ||
98 | /* GPIO9 - O - CPLD register read/write (0:write, 1:read), def. 0 */ | ||
99 | #define GPIO_CPLD_RW (1<<9) | ||
100 | /* GPIO10 - O - SPI Chip Select for CODEC#0, def. 1 */ | ||
101 | #define GPIO_SPI_CSN0 (1<<10) | ||
102 | /* GPIO11 - O - SPI Chip Select for CODEC#1, def. 1 */ | ||
103 | #define GPIO_SPI_CSN1 (1<<11) | ||
104 | /* GPIO12 - O - Ex. Register Output Enable (0:enable, 1:disable), def. 1, | ||
105 | * init 0 */ | ||
106 | #define GPIO_EX_GPIOE (1<<12) | ||
107 | /* GPIO13 - O - Ex. Register0 Chip Select for System Control Register, | ||
108 | * def. 1 */ | ||
109 | #define GPIO_SCR (1<<13) | ||
110 | /* GPIO14 - O - Ex. Register1 Chip Select for Monitor Control Register, | ||
111 | * def. 1 */ | ||
112 | #define GPIO_MCR (1<<14) | ||
113 | |||
114 | #define GPIO_SPI_ALL (GPIO_D4_SPI_CDTO | GPIO_D5_SPI_CCLK |\ | ||
115 | GPIO_SPI_CSN0 | GPIO_SPI_CSN1) | ||
116 | |||
117 | #define GPIO_DATA_MASK (GPIO_D0 | GPIO_D1_JACKDTC0 | \ | ||
118 | GPIO_D2_JACKDTC1 | GPIO_D3 | \ | ||
119 | GPIO_D4_SPI_CDTO | GPIO_D5_SPI_CCLK | \ | ||
120 | GPIO_D6_CD | GPIO_D7_DD) | ||
121 | |||
122 | /* System Control Register GPIO_SCR data bits */ | ||
123 | /* Mic/Line select relay (0:line, 1:mic) */ | ||
124 | #define SCR_RELAY GPIO_D0 | ||
125 | /* Phantom power drive control (0:5V, 1:48V) */ | ||
126 | #define SCR_PHP_V GPIO_D1_JACKDTC0 | ||
127 | /* H/W mute control (0:Normal, 1:Mute) */ | ||
128 | #define SCR_MUTE GPIO_D2_JACKDTC1 | ||
129 | /* Phantom power control (0:Phantom on, 1:off) */ | ||
130 | #define SCR_PHP GPIO_D3 | ||
131 | /* Analog input 1/2 Source Select */ | ||
132 | #define SCR_AIN12_SEL0 GPIO_D4_SPI_CDTO | ||
133 | #define SCR_AIN12_SEL1 GPIO_D5_SPI_CCLK | ||
134 | /* Analog input 3/4 Source Select (0:line, 1:hi-z) */ | ||
135 | #define SCR_AIN34_SEL GPIO_D6_CD | ||
136 | /* Codec Power Down (0:power down, 1:normal) */ | ||
137 | #define SCR_CODEC_PDN GPIO_D7_DD | ||
138 | |||
139 | #define SCR_AIN12_LINE (0) | ||
140 | #define SCR_AIN12_MIC (SCR_AIN12_SEL0) | ||
141 | #define SCR_AIN12_LOWCUT (SCR_AIN12_SEL1 | SCR_AIN12_SEL0) | ||
142 | |||
143 | /* Monitor Control Register GPIO_MCR data bits */ | ||
144 | /* Input 1/2 to Monitor 1/2 (0:off, 1:on) */ | ||
145 | #define MCR_IN12_MON12 GPIO_D0 | ||
146 | /* Input 1/2 to Monitor 3/4 (0:off, 1:on) */ | ||
147 | #define MCR_IN12_MON34 GPIO_D1_JACKDTC0 | ||
148 | /* Input 3/4 to Monitor 1/2 (0:off, 1:on) */ | ||
149 | #define MCR_IN34_MON12 GPIO_D2_JACKDTC1 | ||
150 | /* Input 3/4 to Monitor 3/4 (0:off, 1:on) */ | ||
151 | #define MCR_IN34_MON34 GPIO_D3 | ||
152 | /* Output to Monitor 1/2 (0:off, 1:on) */ | ||
153 | #define MCR_OUT34_MON12 GPIO_D4_SPI_CDTO | ||
154 | /* Output to Monitor 3/4 (0:off, 1:on) */ | ||
155 | #define MCR_OUT12_MON34 GPIO_D5_SPI_CCLK | ||
156 | |||
157 | /* CPLD Register DATA bits */ | ||
158 | /* Clock Rate Select */ | ||
159 | #define CPLD_CKS0 GPIO_D0 | ||
160 | #define CPLD_CKS1 GPIO_D1_JACKDTC0 | ||
161 | #define CPLD_CKS2 GPIO_D2_JACKDTC1 | ||
162 | /* Sync Source Select (0:Internal, 1:External) */ | ||
163 | #define CPLD_SYNC_SEL GPIO_D3 | ||
164 | /* Word Clock FS Select (0:FS, 1:256FS) */ | ||
165 | #define CPLD_WORD_SEL GPIO_D4_SPI_CDTO | ||
166 | /* Coaxial Output Source (IS-Link) (0:SPDIF, 1:I2S) */ | ||
167 | #define CPLD_COAX_OUT GPIO_D5_SPI_CCLK | ||
168 | /* Input 1/2 Source Select (0:Analog12, 1:An34) */ | ||
169 | #define CPLD_IN12_SEL GPIO_D6_CD | ||
170 | /* Input 3/4 Source Select (0:Analog34, 1:Digital In) */ | ||
171 | #define CPLD_IN34_SEL GPIO_D7_DD | ||
172 | |||
173 | /* internal clock (CPLD_SYNC_SEL = 0) options */ | ||
174 | #define CPLD_CKS_44100HZ (0) | ||
175 | #define CPLD_CKS_48000HZ (CPLD_CKS0) | ||
176 | #define CPLD_CKS_88200HZ (CPLD_CKS1) | ||
177 | #define CPLD_CKS_96000HZ (CPLD_CKS1 | CPLD_CKS0) | ||
178 | #define CPLD_CKS_176400HZ (CPLD_CKS2) | ||
179 | #define CPLD_CKS_192000HZ (CPLD_CKS2 | CPLD_CKS0) | ||
180 | |||
181 | #define CPLD_CKS_MASK (CPLD_CKS0 | CPLD_CKS1 | CPLD_CKS2) | ||
182 | |||
183 | /* external clock (CPLD_SYNC_SEL = 1) options */ | ||
184 | /* external clock - SPDIF */ | ||
185 | #define CPLD_EXT_SPDIF (0 | CPLD_SYNC_SEL) | ||
186 | /* external clock - WordClock 1xfs */ | ||
187 | #define CPLD_EXT_WORDCLOCK_1FS (CPLD_CKS1 | CPLD_SYNC_SEL) | ||
188 | /* external clock - WordClock 256xfs */ | ||
189 | #define CPLD_EXT_WORDCLOCK_256FS (CPLD_CKS1 | CPLD_WORD_SEL |\ | ||
190 | CPLD_SYNC_SEL) | ||
191 | |||
192 | #define EXT_SPDIF_TYPE 0 | ||
193 | #define EXT_WORDCLOCK_1FS_TYPE 1 | ||
194 | #define EXT_WORDCLOCK_256FS_TYPE 2 | ||
195 | |||
196 | #define AK4620_DFS0 (1<<0) | ||
197 | #define AK4620_DFS1 (1<<1) | ||
198 | #define AK4620_CKS0 (1<<2) | ||
199 | #define AK4620_CKS1 (1<<3) | ||
200 | /* Clock and Format Control register */ | ||
201 | #define AK4620_DFS_REG 0x02 | ||
202 | |||
203 | /* Deem and Volume Control register */ | ||
204 | #define AK4620_DEEMVOL_REG 0x03 | ||
205 | #define AK4620_SMUTE (1<<7) | ||
206 | |||
207 | /* | ||
208 | * Conversion from int value to its binary form. Used for debugging. | ||
209 | * The output buffer must be allocated prior to calling the function. | ||
210 | */ | ||
211 | static char *get_binary(char *buffer, int value) | ||
212 | { | ||
213 | int i, j, pos; | ||
214 | pos = 0; | ||
215 | for (i = 0; i < 4; ++i) { | ||
216 | for (j = 0; j < 8; ++j) { | ||
217 | if (value & (1 << (31-(i*8 + j)))) | ||
218 | buffer[pos] = '1'; | ||
219 | else | ||
220 | buffer[pos] = '0'; | ||
221 | pos++; | ||
222 | } | ||
223 | if (i < 3) { | ||
224 | buffer[pos] = ' '; | ||
225 | pos++; | ||
226 | } | ||
227 | } | ||
228 | buffer[pos] = '\0'; | ||
229 | return buffer; | ||
230 | } | ||
231 | |||
232 | /* | ||
233 | * Initial setup of the conversion array GPIO <-> rate | ||
234 | */ | ||
235 | static unsigned int qtet_rates[] = { | ||
236 | 44100, 48000, 88200, | ||
237 | 96000, 176400, 192000, | ||
238 | }; | ||
239 | |||
240 | static unsigned int cks_vals[] = { | ||
241 | CPLD_CKS_44100HZ, CPLD_CKS_48000HZ, CPLD_CKS_88200HZ, | ||
242 | CPLD_CKS_96000HZ, CPLD_CKS_176400HZ, CPLD_CKS_192000HZ, | ||
243 | }; | ||
244 | |||
245 | static struct snd_pcm_hw_constraint_list qtet_rates_info = { | ||
246 | .count = ARRAY_SIZE(qtet_rates), | ||
247 | .list = qtet_rates, | ||
248 | .mask = 0, | ||
249 | }; | ||
250 | |||
251 | static void qtet_ak4113_write(void *private_data, unsigned char reg, | ||
252 | unsigned char val) | ||
253 | { | ||
254 | snd_vt1724_write_i2c((struct snd_ice1712 *)private_data, AK4113_ADDR, | ||
255 | reg, val); | ||
256 | } | ||
257 | |||
258 | static unsigned char qtet_ak4113_read(void *private_data, unsigned char reg) | ||
259 | { | ||
260 | return snd_vt1724_read_i2c((struct snd_ice1712 *)private_data, | ||
261 | AK4113_ADDR, reg); | ||
262 | } | ||
263 | |||
264 | |||
265 | /* | ||
266 | * AK4620 section | ||
267 | */ | ||
268 | |||
269 | /* | ||
270 | * Write data to addr register of ak4620 | ||
271 | */ | ||
272 | static void qtet_akm_write(struct snd_akm4xxx *ak, int chip, | ||
273 | unsigned char addr, unsigned char data) | ||
274 | { | ||
275 | unsigned int tmp, orig_dir; | ||
276 | int idx; | ||
277 | unsigned int addrdata; | ||
278 | struct snd_ice1712 *ice = ak->private_data[0]; | ||
279 | |||
280 | if (snd_BUG_ON(chip < 0 || chip >= 4)) | ||
281 | return; | ||
282 | /*printk(KERN_DEBUG "Writing to AK4620: chip=%d, addr=0x%x, | ||
283 | data=0x%x\n", chip, addr, data);*/ | ||
284 | orig_dir = ice->gpio.get_dir(ice); | ||
285 | ice->gpio.set_dir(ice, orig_dir | GPIO_SPI_ALL); | ||
286 | /* set mask - only SPI bits */ | ||
287 | ice->gpio.set_mask(ice, ~GPIO_SPI_ALL); | ||
288 | |||
289 | tmp = ice->gpio.get_data(ice); | ||
290 | /* high all */ | ||
291 | tmp |= GPIO_SPI_ALL; | ||
292 | ice->gpio.set_data(ice, tmp); | ||
293 | udelay(100); | ||
294 | /* drop chip select */ | ||
295 | if (chip) | ||
296 | /* CODEC 1 */ | ||
297 | tmp &= ~GPIO_SPI_CSN1; | ||
298 | else | ||
299 | tmp &= ~GPIO_SPI_CSN0; | ||
300 | ice->gpio.set_data(ice, tmp); | ||
301 | udelay(100); | ||
302 | |||
303 | /* build I2C address + data byte */ | ||
304 | addrdata = (AK4620_ADDR << 6) | 0x20 | (addr & 0x1f); | ||
305 | addrdata = (addrdata << 8) | data; | ||
306 | for (idx = 15; idx >= 0; idx--) { | ||
307 | /* drop clock */ | ||
308 | tmp &= ~GPIO_D5_SPI_CCLK; | ||
309 | ice->gpio.set_data(ice, tmp); | ||
310 | udelay(100); | ||
311 | /* set data */ | ||
312 | if (addrdata & (1 << idx)) | ||
313 | tmp |= GPIO_D4_SPI_CDTO; | ||
314 | else | ||
315 | tmp &= ~GPIO_D4_SPI_CDTO; | ||
316 | ice->gpio.set_data(ice, tmp); | ||
317 | udelay(100); | ||
318 | /* raise clock */ | ||
319 | tmp |= GPIO_D5_SPI_CCLK; | ||
320 | ice->gpio.set_data(ice, tmp); | ||
321 | udelay(100); | ||
322 | } | ||
323 | /* all back to 1 */ | ||
324 | tmp |= GPIO_SPI_ALL; | ||
325 | ice->gpio.set_data(ice, tmp); | ||
326 | udelay(100); | ||
327 | |||
328 | /* return all gpios to non-writable */ | ||
329 | ice->gpio.set_mask(ice, 0xffffff); | ||
330 | /* restore GPIOs direction */ | ||
331 | ice->gpio.set_dir(ice, orig_dir); | ||
332 | } | ||
333 | |||
334 | static void qtet_akm_set_regs(struct snd_akm4xxx *ak, unsigned char addr, | ||
335 | unsigned char mask, unsigned char value) | ||
336 | { | ||
337 | unsigned char tmp; | ||
338 | int chip; | ||
339 | for (chip = 0; chip < ak->num_chips; chip++) { | ||
340 | tmp = snd_akm4xxx_get(ak, chip, addr); | ||
341 | /* clear the bits */ | ||
342 | tmp &= ~mask; | ||
343 | /* set the new bits */ | ||
344 | tmp |= value; | ||
345 | snd_akm4xxx_write(ak, chip, addr, tmp); | ||
346 | } | ||
347 | } | ||
348 | |||
349 | /* | ||
350 | * change the rate of AK4620 | ||
351 | */ | ||
352 | static void qtet_akm_set_rate_val(struct snd_akm4xxx *ak, unsigned int rate) | ||
353 | { | ||
354 | unsigned char ak4620_dfs; | ||
355 | |||
356 | if (rate == 0) /* no hint - S/PDIF input is master or the new spdif | ||
357 | input rate undetected, simply return */ | ||
358 | return; | ||
359 | |||
360 | /* adjust DFS on codecs - see datasheet */ | ||
361 | if (rate > 108000) | ||
362 | ak4620_dfs = AK4620_DFS1 | AK4620_CKS1; | ||
363 | else if (rate > 54000) | ||
364 | ak4620_dfs = AK4620_DFS0 | AK4620_CKS0; | ||
365 | else | ||
366 | ak4620_dfs = 0; | ||
367 | |||
368 | /* set new value */ | ||
369 | qtet_akm_set_regs(ak, AK4620_DFS_REG, AK4620_DFS0 | AK4620_DFS1 | | ||
370 | AK4620_CKS0 | AK4620_CKS1, ak4620_dfs); | ||
371 | } | ||
372 | |||
373 | #define AK_CONTROL(xname, xch) { .name = xname, .num_channels = xch } | ||
374 | |||
375 | #define PCM_12_PLAYBACK_VOLUME "PCM 1/2 Playback Volume" | ||
376 | #define PCM_34_PLAYBACK_VOLUME "PCM 3/4 Playback Volume" | ||
377 | #define PCM_12_CAPTURE_VOLUME "PCM 1/2 Capture Volume" | ||
378 | #define PCM_34_CAPTURE_VOLUME "PCM 3/4 Capture Volume" | ||
379 | |||
380 | static const struct snd_akm4xxx_dac_channel qtet_dac[] = { | ||
381 | AK_CONTROL(PCM_12_PLAYBACK_VOLUME, 2), | ||
382 | AK_CONTROL(PCM_34_PLAYBACK_VOLUME, 2), | ||
383 | }; | ||
384 | |||
385 | static const struct snd_akm4xxx_adc_channel qtet_adc[] = { | ||
386 | AK_CONTROL(PCM_12_CAPTURE_VOLUME, 2), | ||
387 | AK_CONTROL(PCM_34_CAPTURE_VOLUME, 2), | ||
388 | }; | ||
389 | |||
390 | static struct snd_akm4xxx akm_qtet_dac __devinitdata = { | ||
391 | .type = SND_AK4620, | ||
392 | .num_dacs = 4, /* DAC1 - Output 12 | ||
393 | */ | ||
394 | .num_adcs = 4, /* ADC1 - Input 12 | ||
395 | */ | ||
396 | .ops = { | ||
397 | .write = qtet_akm_write, | ||
398 | .set_rate_val = qtet_akm_set_rate_val, | ||
399 | }, | ||
400 | .dac_info = qtet_dac, | ||
401 | .adc_info = qtet_adc, | ||
402 | }; | ||
403 | |||
404 | /* Communication routines with the CPLD */ | ||
405 | |||
406 | |||
407 | /* Writes data to external register reg, both reg and data are | ||
408 | * GPIO representations */ | ||
409 | static void reg_write(struct snd_ice1712 *ice, unsigned int reg, | ||
410 | unsigned int data) | ||
411 | { | ||
412 | unsigned int tmp; | ||
413 | |||
414 | mutex_lock(&ice->gpio_mutex); | ||
415 | /* set direction of used GPIOs*/ | ||
416 | /* all outputs */ | ||
417 | tmp = 0x00ffff; | ||
418 | ice->gpio.set_dir(ice, tmp); | ||
419 | /* mask - writable bits */ | ||
420 | ice->gpio.set_mask(ice, ~(tmp)); | ||
421 | /* write the data */ | ||
422 | tmp = ice->gpio.get_data(ice); | ||
423 | tmp &= ~GPIO_DATA_MASK; | ||
424 | tmp |= data; | ||
425 | ice->gpio.set_data(ice, tmp); | ||
426 | udelay(100); | ||
427 | /* drop output enable */ | ||
428 | tmp &= ~GPIO_EX_GPIOE; | ||
429 | ice->gpio.set_data(ice, tmp); | ||
430 | udelay(100); | ||
431 | /* drop the register gpio */ | ||
432 | tmp &= ~reg; | ||
433 | ice->gpio.set_data(ice, tmp); | ||
434 | udelay(100); | ||
435 | /* raise the register GPIO */ | ||
436 | tmp |= reg; | ||
437 | ice->gpio.set_data(ice, tmp); | ||
438 | udelay(100); | ||
439 | |||
440 | /* raise all data gpios */ | ||
441 | tmp |= GPIO_DATA_MASK; | ||
442 | ice->gpio.set_data(ice, tmp); | ||
443 | /* mask - immutable bits */ | ||
444 | ice->gpio.set_mask(ice, 0xffffff); | ||
445 | /* outputs only 8-15 */ | ||
446 | ice->gpio.set_dir(ice, 0x00ff00); | ||
447 | mutex_unlock(&ice->gpio_mutex); | ||
448 | } | ||
449 | |||
450 | static unsigned int get_scr(struct snd_ice1712 *ice) | ||
451 | { | ||
452 | struct qtet_spec *spec = ice->spec; | ||
453 | return spec->scr; | ||
454 | } | ||
455 | |||
456 | static unsigned int get_mcr(struct snd_ice1712 *ice) | ||
457 | { | ||
458 | struct qtet_spec *spec = ice->spec; | ||
459 | return spec->mcr; | ||
460 | } | ||
461 | |||
462 | static unsigned int get_cpld(struct snd_ice1712 *ice) | ||
463 | { | ||
464 | struct qtet_spec *spec = ice->spec; | ||
465 | return spec->cpld; | ||
466 | } | ||
467 | |||
468 | static void set_scr(struct snd_ice1712 *ice, unsigned int val) | ||
469 | { | ||
470 | struct qtet_spec *spec = ice->spec; | ||
471 | reg_write(ice, GPIO_SCR, val); | ||
472 | spec->scr = val; | ||
473 | } | ||
474 | |||
475 | static void set_mcr(struct snd_ice1712 *ice, unsigned int val) | ||
476 | { | ||
477 | struct qtet_spec *spec = ice->spec; | ||
478 | reg_write(ice, GPIO_MCR, val); | ||
479 | spec->mcr = val; | ||
480 | } | ||
481 | |||
482 | static void set_cpld(struct snd_ice1712 *ice, unsigned int val) | ||
483 | { | ||
484 | struct qtet_spec *spec = ice->spec; | ||
485 | reg_write(ice, GPIO_CPLD_CSN, val); | ||
486 | spec->cpld = val; | ||
487 | } | ||
488 | #ifdef CONFIG_PROC_FS | ||
489 | static void proc_regs_read(struct snd_info_entry *entry, | ||
490 | struct snd_info_buffer *buffer) | ||
491 | { | ||
492 | struct snd_ice1712 *ice = entry->private_data; | ||
493 | char bin_buffer[36]; | ||
494 | |||
495 | snd_iprintf(buffer, "SCR: %s\n", get_binary(bin_buffer, | ||
496 | get_scr(ice))); | ||
497 | snd_iprintf(buffer, "MCR: %s\n", get_binary(bin_buffer, | ||
498 | get_mcr(ice))); | ||
499 | snd_iprintf(buffer, "CPLD: %s\n", get_binary(bin_buffer, | ||
500 | get_cpld(ice))); | ||
501 | } | ||
502 | |||
503 | static void proc_init(struct snd_ice1712 *ice) | ||
504 | { | ||
505 | struct snd_info_entry *entry; | ||
506 | if (!snd_card_proc_new(ice->card, "quartet", &entry)) | ||
507 | snd_info_set_text_ops(entry, ice, proc_regs_read); | ||
508 | } | ||
509 | #else /* !CONFIG_PROC_FS */ | ||
510 | static void proc_init(struct snd_ice1712 *ice) {} | ||
511 | #endif | ||
512 | |||
513 | static int qtet_mute_get(struct snd_kcontrol *kcontrol, | ||
514 | struct snd_ctl_elem_value *ucontrol) | ||
515 | { | ||
516 | struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); | ||
517 | unsigned int val; | ||
518 | val = get_scr(ice) & SCR_MUTE; | ||
519 | ucontrol->value.integer.value[0] = (val) ? 0 : 1; | ||
520 | return 0; | ||
521 | } | ||
522 | |||
523 | static int qtet_mute_put(struct snd_kcontrol *kcontrol, | ||
524 | struct snd_ctl_elem_value *ucontrol) | ||
525 | { | ||
526 | struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); | ||
527 | unsigned int old, new, smute; | ||
528 | old = get_scr(ice) & SCR_MUTE; | ||
529 | if (ucontrol->value.integer.value[0]) { | ||
530 | /* unmute */ | ||
531 | new = 0; | ||
532 | /* un-smuting DAC */ | ||
533 | smute = 0; | ||
534 | } else { | ||
535 | /* mute */ | ||
536 | new = SCR_MUTE; | ||
537 | /* smuting DAC */ | ||
538 | smute = AK4620_SMUTE; | ||
539 | } | ||
540 | if (old != new) { | ||
541 | struct snd_akm4xxx *ak = ice->akm; | ||
542 | set_scr(ice, (get_scr(ice) & ~SCR_MUTE) | new); | ||
543 | /* set smute */ | ||
544 | qtet_akm_set_regs(ak, AK4620_DEEMVOL_REG, AK4620_SMUTE, smute); | ||
545 | return 1; | ||
546 | } | ||
547 | /* no change */ | ||
548 | return 0; | ||
549 | } | ||
550 | |||
551 | static int qtet_ain12_enum_info(struct snd_kcontrol *kcontrol, | ||
552 | struct snd_ctl_elem_info *uinfo) | ||
553 | { | ||
554 | static char *texts[3] = {"Line In 1/2", "Mic", "Mic + Low-cut"}; | ||
555 | uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; | ||
556 | uinfo->count = 1; | ||
557 | uinfo->value.enumerated.items = ARRAY_SIZE(texts); | ||
558 | |||
559 | if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items) | ||
560 | uinfo->value.enumerated.item = | ||
561 | uinfo->value.enumerated.items - 1; | ||
562 | strcpy(uinfo->value.enumerated.name, | ||
563 | texts[uinfo->value.enumerated.item]); | ||
564 | |||
565 | return 0; | ||
566 | } | ||
567 | |||
568 | static int qtet_ain12_sw_get(struct snd_kcontrol *kcontrol, | ||
569 | struct snd_ctl_elem_value *ucontrol) | ||
570 | { | ||
571 | struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); | ||
572 | unsigned int val, result; | ||
573 | val = get_scr(ice) & (SCR_AIN12_SEL1 | SCR_AIN12_SEL0); | ||
574 | switch (val) { | ||
575 | case SCR_AIN12_LINE: | ||
576 | result = 0; | ||
577 | break; | ||
578 | case SCR_AIN12_MIC: | ||
579 | result = 1; | ||
580 | break; | ||
581 | case SCR_AIN12_LOWCUT: | ||
582 | result = 2; | ||
583 | break; | ||
584 | default: | ||
585 | /* BUG - no other combinations allowed */ | ||
586 | snd_BUG(); | ||
587 | result = 0; | ||
588 | } | ||
589 | ucontrol->value.integer.value[0] = result; | ||
590 | return 0; | ||
591 | } | ||
592 | |||
593 | static int qtet_ain12_sw_put(struct snd_kcontrol *kcontrol, | ||
594 | struct snd_ctl_elem_value *ucontrol) | ||
595 | { | ||
596 | struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); | ||
597 | unsigned int old, new, tmp, masked_old; | ||
598 | old = new = get_scr(ice); | ||
599 | masked_old = old & (SCR_AIN12_SEL1 | SCR_AIN12_SEL0); | ||
600 | tmp = ucontrol->value.integer.value[0]; | ||
601 | if (tmp == 2) | ||
602 | tmp = 3; /* binary 10 is not supported */ | ||
603 | tmp <<= 4; /* shifting to SCR_AIN12_SEL0 */ | ||
604 | if (tmp != masked_old) { | ||
605 | /* change requested */ | ||
606 | switch (tmp) { | ||
607 | case SCR_AIN12_LINE: | ||
608 | new = old & ~(SCR_AIN12_SEL1 | SCR_AIN12_SEL0); | ||
609 | set_scr(ice, new); | ||
610 | /* turn off relay */ | ||
611 | new &= ~SCR_RELAY; | ||
612 | set_scr(ice, new); | ||
613 | break; | ||
614 | case SCR_AIN12_MIC: | ||
615 | /* turn on relay */ | ||
616 | new = old | SCR_RELAY; | ||
617 | set_scr(ice, new); | ||
618 | new = (new & ~SCR_AIN12_SEL1) | SCR_AIN12_SEL0; | ||
619 | set_scr(ice, new); | ||
620 | break; | ||
621 | case SCR_AIN12_LOWCUT: | ||
622 | /* turn on relay */ | ||
623 | new = old | SCR_RELAY; | ||
624 | set_scr(ice, new); | ||
625 | new |= SCR_AIN12_SEL1 | SCR_AIN12_SEL0; | ||
626 | set_scr(ice, new); | ||
627 | break; | ||
628 | default: | ||
629 | snd_BUG(); | ||
630 | } | ||
631 | return 1; | ||
632 | } | ||
633 | /* no change */ | ||
634 | return 0; | ||
635 | } | ||
636 | |||
637 | static int qtet_php_get(struct snd_kcontrol *kcontrol, | ||
638 | struct snd_ctl_elem_value *ucontrol) | ||
639 | { | ||
640 | struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); | ||
641 | unsigned int val; | ||
642 | /* if phantom voltage =48V, phantom on */ | ||
643 | val = get_scr(ice) & SCR_PHP_V; | ||
644 | ucontrol->value.integer.value[0] = val ? 1 : 0; | ||
645 | return 0; | ||
646 | } | ||
647 | |||
648 | static int qtet_php_put(struct snd_kcontrol *kcontrol, | ||
649 | struct snd_ctl_elem_value *ucontrol) | ||
650 | { | ||
651 | struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); | ||
652 | unsigned int old, new; | ||
653 | old = new = get_scr(ice); | ||
654 | if (ucontrol->value.integer.value[0] /* phantom on requested */ | ||
655 | && (~old & SCR_PHP_V)) /* 0 = voltage 5V */ { | ||
656 | /* is off, turn on */ | ||
657 | /* turn voltage on first, = 1 */ | ||
658 | new = old | SCR_PHP_V; | ||
659 | set_scr(ice, new); | ||
660 | /* turn phantom on, = 0 */ | ||
661 | new &= ~SCR_PHP; | ||
662 | set_scr(ice, new); | ||
663 | } else if (!ucontrol->value.integer.value[0] && (old & SCR_PHP_V)) { | ||
664 | /* phantom off requested and 1 = voltage 48V */ | ||
665 | /* is on, turn off */ | ||
666 | /* turn voltage off first, = 0 */ | ||
667 | new = old & ~SCR_PHP_V; | ||
668 | set_scr(ice, new); | ||
669 | /* turn phantom off, = 1 */ | ||
670 | new |= SCR_PHP; | ||
671 | set_scr(ice, new); | ||
672 | } | ||
673 | if (old != new) | ||
674 | return 1; | ||
675 | /* no change */ | ||
676 | return 0; | ||
677 | } | ||
678 | |||
679 | #define PRIV_SW(xid, xbit, xreg) [xid] = {.bit = xbit,\ | ||
680 | .set_register = set_##xreg,\ | ||
681 | .get_register = get_##xreg, } | ||
682 | |||
683 | |||
684 | #define PRIV_ENUM2(xid, xbit, xreg, xtext1, xtext2) [xid] = {.bit = xbit,\ | ||
685 | .set_register = set_##xreg,\ | ||
686 | .get_register = get_##xreg,\ | ||
687 | .texts = {xtext1, xtext2} } | ||
688 | |||
689 | static struct qtet_kcontrol_private qtet_privates[] = { | ||
690 | PRIV_ENUM2(IN12_SEL, CPLD_IN12_SEL, cpld, "An In 1/2", "An In 3/4"), | ||
691 | PRIV_ENUM2(IN34_SEL, CPLD_IN34_SEL, cpld, "An In 3/4", "IEC958 In"), | ||
692 | PRIV_ENUM2(AIN34_SEL, SCR_AIN34_SEL, scr, "Line In 3/4", "Hi-Z"), | ||
693 | PRIV_ENUM2(COAX_OUT, CPLD_COAX_OUT, cpld, "IEC958", "I2S"), | ||
694 | PRIV_SW(IN12_MON12, MCR_IN12_MON12, mcr), | ||
695 | PRIV_SW(IN12_MON34, MCR_IN12_MON34, mcr), | ||
696 | PRIV_SW(IN34_MON12, MCR_IN34_MON12, mcr), | ||
697 | PRIV_SW(IN34_MON34, MCR_IN34_MON34, mcr), | ||
698 | PRIV_SW(OUT12_MON34, MCR_OUT12_MON34, mcr), | ||
699 | PRIV_SW(OUT34_MON12, MCR_OUT34_MON12, mcr), | ||
700 | }; | ||
701 | |||
702 | static int qtet_enum_info(struct snd_kcontrol *kcontrol, | ||
703 | struct snd_ctl_elem_info *uinfo) | ||
704 | { | ||
705 | struct qtet_kcontrol_private private = | ||
706 | qtet_privates[kcontrol->private_value]; | ||
707 | uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; | ||
708 | uinfo->count = 1; | ||
709 | uinfo->value.enumerated.items = ARRAY_SIZE(private.texts); | ||
710 | |||
711 | if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items) | ||
712 | uinfo->value.enumerated.item = | ||
713 | uinfo->value.enumerated.items - 1; | ||
714 | strcpy(uinfo->value.enumerated.name, | ||
715 | private.texts[uinfo->value.enumerated.item]); | ||
716 | |||
717 | return 0; | ||
718 | } | ||
719 | |||
720 | static int qtet_sw_get(struct snd_kcontrol *kcontrol, | ||
721 | struct snd_ctl_elem_value *ucontrol) | ||
722 | { | ||
723 | struct qtet_kcontrol_private private = | ||
724 | qtet_privates[kcontrol->private_value]; | ||
725 | struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); | ||
726 | ucontrol->value.integer.value[0] = | ||
727 | (private.get_register(ice) & private.bit) ? 1 : 0; | ||
728 | return 0; | ||
729 | } | ||
730 | |||
731 | static int qtet_sw_put(struct snd_kcontrol *kcontrol, | ||
732 | struct snd_ctl_elem_value *ucontrol) | ||
733 | { | ||
734 | struct qtet_kcontrol_private private = | ||
735 | qtet_privates[kcontrol->private_value]; | ||
736 | struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); | ||
737 | unsigned int old, new; | ||
738 | old = private.get_register(ice); | ||
739 | if (ucontrol->value.integer.value[0]) | ||
740 | new = old | private.bit; | ||
741 | else | ||
742 | new = old & ~private.bit; | ||
743 | if (old != new) { | ||
744 | private.set_register(ice, new); | ||
745 | return 1; | ||
746 | } | ||
747 | /* no change */ | ||
748 | return 0; | ||
749 | } | ||
750 | |||
751 | #define qtet_sw_info snd_ctl_boolean_mono_info | ||
752 | |||
753 | #define QTET_CONTROL(xname, xtype, xpriv) \ | ||
754 | {.iface = SNDRV_CTL_ELEM_IFACE_MIXER,\ | ||
755 | .name = xname,\ | ||
756 | .info = qtet_##xtype##_info,\ | ||
757 | .get = qtet_sw_get,\ | ||
758 | .put = qtet_sw_put,\ | ||
759 | .private_value = xpriv } | ||
760 | |||
761 | static struct snd_kcontrol_new qtet_controls[] __devinitdata = { | ||
762 | { | ||
763 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
764 | .name = "Master Playback Switch", | ||
765 | .info = qtet_sw_info, | ||
766 | .get = qtet_mute_get, | ||
767 | .put = qtet_mute_put, | ||
768 | .private_value = 0 | ||
769 | }, | ||
770 | { | ||
771 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
772 | .name = "Phantom Power", | ||
773 | .info = qtet_sw_info, | ||
774 | .get = qtet_php_get, | ||
775 | .put = qtet_php_put, | ||
776 | .private_value = 0 | ||
777 | }, | ||
778 | { | ||
779 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
780 | .name = "Analog In 1/2 Capture Switch", | ||
781 | .info = qtet_ain12_enum_info, | ||
782 | .get = qtet_ain12_sw_get, | ||
783 | .put = qtet_ain12_sw_put, | ||
784 | .private_value = 0 | ||
785 | }, | ||
786 | QTET_CONTROL("Analog In 3/4 Capture Switch", enum, AIN34_SEL), | ||
787 | QTET_CONTROL("PCM In 1/2 Capture Switch", enum, IN12_SEL), | ||
788 | QTET_CONTROL("PCM In 3/4 Capture Switch", enum, IN34_SEL), | ||
789 | QTET_CONTROL("Coax Output Source", enum, COAX_OUT), | ||
790 | QTET_CONTROL("Analog In 1/2 to Monitor 1/2", sw, IN12_MON12), | ||
791 | QTET_CONTROL("Analog In 1/2 to Monitor 3/4", sw, IN12_MON34), | ||
792 | QTET_CONTROL("Analog In 3/4 to Monitor 1/2", sw, IN34_MON12), | ||
793 | QTET_CONTROL("Analog In 3/4 to Monitor 3/4", sw, IN34_MON34), | ||
794 | QTET_CONTROL("Output 1/2 to Monitor 3/4", sw, OUT12_MON34), | ||
795 | QTET_CONTROL("Output 3/4 to Monitor 1/2", sw, OUT34_MON12), | ||
796 | }; | ||
797 | |||
798 | static char *slave_vols[] __devinitdata = { | ||
799 | PCM_12_PLAYBACK_VOLUME, | ||
800 | PCM_34_PLAYBACK_VOLUME, | ||
801 | NULL | ||
802 | }; | ||
803 | |||
804 | static __devinitdata | ||
805 | DECLARE_TLV_DB_SCALE(qtet_master_db_scale, -6350, 50, 1); | ||
806 | |||
807 | static struct snd_kcontrol __devinit *ctl_find(struct snd_card *card, | ||
808 | const char *name) | ||
809 | { | ||
810 | struct snd_ctl_elem_id sid; | ||
811 | memset(&sid, 0, sizeof(sid)); | ||
812 | /* FIXME: strcpy is bad. */ | ||
813 | strcpy(sid.name, name); | ||
814 | sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER; | ||
815 | return snd_ctl_find_id(card, &sid); | ||
816 | } | ||
817 | |||
818 | static void __devinit add_slaves(struct snd_card *card, | ||
819 | struct snd_kcontrol *master, char **list) | ||
820 | { | ||
821 | for (; *list; list++) { | ||
822 | struct snd_kcontrol *slave = ctl_find(card, *list); | ||
823 | if (slave) | ||
824 | snd_ctl_add_slave(master, slave); | ||
825 | } | ||
826 | } | ||
827 | |||
828 | static int __devinit qtet_add_controls(struct snd_ice1712 *ice) | ||
829 | { | ||
830 | struct qtet_spec *spec = ice->spec; | ||
831 | int err, i; | ||
832 | struct snd_kcontrol *vmaster; | ||
833 | err = snd_ice1712_akm4xxx_build_controls(ice); | ||
834 | if (err < 0) | ||
835 | return err; | ||
836 | for (i = 0; i < ARRAY_SIZE(qtet_controls); i++) { | ||
837 | err = snd_ctl_add(ice->card, | ||
838 | snd_ctl_new1(&qtet_controls[i], ice)); | ||
839 | if (err < 0) | ||
840 | return err; | ||
841 | } | ||
842 | |||
843 | /* Create virtual master control */ | ||
844 | vmaster = snd_ctl_make_virtual_master("Master Playback Volume", | ||
845 | qtet_master_db_scale); | ||
846 | if (!vmaster) | ||
847 | return -ENOMEM; | ||
848 | add_slaves(ice->card, vmaster, slave_vols); | ||
849 | err = snd_ctl_add(ice->card, vmaster); | ||
850 | if (err < 0) | ||
851 | return err; | ||
852 | /* only capture SPDIF over AK4113 */ | ||
853 | err = snd_ak4113_build(spec->ak4113, | ||
854 | ice->pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream); | ||
855 | if (err < 0) | ||
856 | return err; | ||
857 | return 0; | ||
858 | } | ||
859 | |||
860 | static inline int qtet_is_spdif_master(struct snd_ice1712 *ice) | ||
861 | { | ||
862 | /* CPLD_SYNC_SEL: 0 = internal, 1 = external (i.e. spdif master) */ | ||
863 | return (get_cpld(ice) & CPLD_SYNC_SEL) ? 1 : 0; | ||
864 | } | ||
865 | |||
866 | static unsigned int qtet_get_rate(struct snd_ice1712 *ice) | ||
867 | { | ||
868 | int i; | ||
869 | unsigned char result; | ||
870 | |||
871 | result = get_cpld(ice) & CPLD_CKS_MASK; | ||
872 | for (i = 0; i < ARRAY_SIZE(cks_vals); i++) | ||
873 | if (cks_vals[i] == result) | ||
874 | return qtet_rates[i]; | ||
875 | return 0; | ||
876 | } | ||
877 | |||
878 | static int get_cks_val(int rate) | ||
879 | { | ||
880 | int i; | ||
881 | for (i = 0; i < ARRAY_SIZE(qtet_rates); i++) | ||
882 | if (qtet_rates[i] == rate) | ||
883 | return cks_vals[i]; | ||
884 | return 0; | ||
885 | } | ||
886 | |||
887 | /* setting new rate */ | ||
888 | static void qtet_set_rate(struct snd_ice1712 *ice, unsigned int rate) | ||
889 | { | ||
890 | unsigned int new; | ||
891 | unsigned char val; | ||
892 | /* switching ice1724 to external clock - supplied by ext. circuits */ | ||
893 | val = inb(ICEMT1724(ice, RATE)); | ||
894 | outb(val | VT1724_SPDIF_MASTER, ICEMT1724(ice, RATE)); | ||
895 | |||
896 | new = (get_cpld(ice) & ~CPLD_CKS_MASK) | get_cks_val(rate); | ||
897 | /* switch to internal clock, drop CPLD_SYNC_SEL */ | ||
898 | new &= ~CPLD_SYNC_SEL; | ||
899 | /* printk(KERN_DEBUG "QT - set_rate: old %x, new %x\n", | ||
900 | get_cpld(ice), new); */ | ||
901 | set_cpld(ice, new); | ||
902 | } | ||
903 | |||
904 | static inline unsigned char qtet_set_mclk(struct snd_ice1712 *ice, | ||
905 | unsigned int rate) | ||
906 | { | ||
907 | /* no change in master clock */ | ||
908 | return 0; | ||
909 | } | ||
910 | |||
911 | /* setting clock to external - SPDIF */ | ||
912 | static int qtet_set_spdif_clock(struct snd_ice1712 *ice, int type) | ||
913 | { | ||
914 | unsigned int old, new; | ||
915 | |||
916 | old = new = get_cpld(ice); | ||
917 | new &= ~(CPLD_CKS_MASK | CPLD_WORD_SEL); | ||
918 | switch (type) { | ||
919 | case EXT_SPDIF_TYPE: | ||
920 | new |= CPLD_EXT_SPDIF; | ||
921 | break; | ||
922 | case EXT_WORDCLOCK_1FS_TYPE: | ||
923 | new |= CPLD_EXT_WORDCLOCK_1FS; | ||
924 | break; | ||
925 | case EXT_WORDCLOCK_256FS_TYPE: | ||
926 | new |= CPLD_EXT_WORDCLOCK_256FS; | ||
927 | break; | ||
928 | default: | ||
929 | snd_BUG(); | ||
930 | } | ||
931 | if (old != new) { | ||
932 | set_cpld(ice, new); | ||
933 | /* changed */ | ||
934 | return 1; | ||
935 | } | ||
936 | return 0; | ||
937 | } | ||
938 | |||
939 | static int qtet_get_spdif_master_type(struct snd_ice1712 *ice) | ||
940 | { | ||
941 | unsigned int val; | ||
942 | int result; | ||
943 | val = get_cpld(ice); | ||
944 | /* checking only rate/clock-related bits */ | ||
945 | val &= (CPLD_CKS_MASK | CPLD_WORD_SEL | CPLD_SYNC_SEL); | ||
946 | if (!(val & CPLD_SYNC_SEL)) { | ||
947 | /* switched to internal clock, is not any external type */ | ||
948 | result = -1; | ||
949 | } else { | ||
950 | switch (val) { | ||
951 | case (CPLD_EXT_SPDIF): | ||
952 | result = EXT_SPDIF_TYPE; | ||
953 | break; | ||
954 | case (CPLD_EXT_WORDCLOCK_1FS): | ||
955 | result = EXT_WORDCLOCK_1FS_TYPE; | ||
956 | break; | ||
957 | case (CPLD_EXT_WORDCLOCK_256FS): | ||
958 | result = EXT_WORDCLOCK_256FS_TYPE; | ||
959 | break; | ||
960 | default: | ||
961 | /* undefined combination of external clock setup */ | ||
962 | snd_BUG(); | ||
963 | result = 0; | ||
964 | } | ||
965 | } | ||
966 | return result; | ||
967 | } | ||
968 | |||
969 | /* Called when ak4113 detects change in the input SPDIF stream */ | ||
970 | static void qtet_ak4113_change(struct ak4113 *ak4113, unsigned char c0, | ||
971 | unsigned char c1) | ||
972 | { | ||
973 | struct snd_ice1712 *ice = ak4113->change_callback_private; | ||
974 | int rate; | ||
975 | if ((qtet_get_spdif_master_type(ice) == EXT_SPDIF_TYPE) && | ||
976 | c1) { | ||
977 | /* only for SPDIF master mode, rate was changed */ | ||
978 | rate = snd_ak4113_external_rate(ak4113); | ||
979 | /* printk(KERN_DEBUG "ak4113 - input rate changed to %d\n", | ||
980 | rate); */ | ||
981 | qtet_akm_set_rate_val(ice->akm, rate); | ||
982 | } | ||
983 | } | ||
984 | |||
985 | /* | ||
986 | * If clock slaved to SPDIF-IN, setting runtime rate | ||
987 | * to the detected external rate | ||
988 | */ | ||
989 | static void qtet_spdif_in_open(struct snd_ice1712 *ice, | ||
990 | struct snd_pcm_substream *substream) | ||
991 | { | ||
992 | struct qtet_spec *spec = ice->spec; | ||
993 | struct snd_pcm_runtime *runtime = substream->runtime; | ||
994 | int rate; | ||
995 | |||
996 | if (qtet_get_spdif_master_type(ice) != EXT_SPDIF_TYPE) | ||
997 | /* not external SPDIF, no rate limitation */ | ||
998 | return; | ||
999 | /* only external SPDIF can detect incoming sample rate */ | ||
1000 | rate = snd_ak4113_external_rate(spec->ak4113); | ||
1001 | if (rate >= runtime->hw.rate_min && rate <= runtime->hw.rate_max) { | ||
1002 | runtime->hw.rate_min = rate; | ||
1003 | runtime->hw.rate_max = rate; | ||
1004 | } | ||
1005 | } | ||
1006 | |||
1007 | /* | ||
1008 | * initialize the chip | ||
1009 | */ | ||
1010 | static int __devinit qtet_init(struct snd_ice1712 *ice) | ||
1011 | { | ||
1012 | static const unsigned char ak4113_init_vals[] = { | ||
1013 | /* AK4113_REG_PWRDN */ AK4113_RST | AK4113_PWN | | ||
1014 | AK4113_OCKS0 | AK4113_OCKS1, | ||
1015 | /* AK4113_REQ_FORMAT */ AK4113_DIF_I24I2S | AK4113_VTX | | ||
1016 | AK4113_DEM_OFF | AK4113_DEAU, | ||
1017 | /* AK4113_REG_IO0 */ AK4113_OPS2 | AK4113_TXE | | ||
1018 | AK4113_XTL_24_576M, | ||
1019 | /* AK4113_REG_IO1 */ AK4113_EFH_1024LRCLK | AK4113_IPS(0), | ||
1020 | /* AK4113_REG_INT0_MASK */ 0, | ||
1021 | /* AK4113_REG_INT1_MASK */ 0, | ||
1022 | /* AK4113_REG_DATDTS */ 0, | ||
1023 | }; | ||
1024 | int err; | ||
1025 | struct qtet_spec *spec; | ||
1026 | struct snd_akm4xxx *ak; | ||
1027 | unsigned char val; | ||
1028 | |||
1029 | /* switching ice1724 to external clock - supplied by ext. circuits */ | ||
1030 | val = inb(ICEMT1724(ice, RATE)); | ||
1031 | outb(val | VT1724_SPDIF_MASTER, ICEMT1724(ice, RATE)); | ||
1032 | |||
1033 | spec = kzalloc(sizeof(*spec), GFP_KERNEL); | ||
1034 | if (!spec) | ||
1035 | return -ENOMEM; | ||
1036 | /* qtet is clocked by Xilinx array */ | ||
1037 | ice->hw_rates = &qtet_rates_info; | ||
1038 | ice->is_spdif_master = qtet_is_spdif_master; | ||
1039 | ice->get_rate = qtet_get_rate; | ||
1040 | ice->set_rate = qtet_set_rate; | ||
1041 | ice->set_mclk = qtet_set_mclk; | ||
1042 | ice->set_spdif_clock = qtet_set_spdif_clock; | ||
1043 | ice->get_spdif_master_type = qtet_get_spdif_master_type; | ||
1044 | ice->ext_clock_names = ext_clock_names; | ||
1045 | ice->ext_clock_count = ARRAY_SIZE(ext_clock_names); | ||
1046 | /* since Qtet can detect correct SPDIF-in rate, all streams can be | ||
1047 | * limited to this specific rate */ | ||
1048 | ice->spdif.ops.open = ice->pro_open = qtet_spdif_in_open; | ||
1049 | ice->spec = spec; | ||
1050 | |||
1051 | /* Mute Off */ | ||
1052 | /* SCR Initialize*/ | ||
1053 | /* keep codec power down first */ | ||
1054 | set_scr(ice, SCR_PHP); | ||
1055 | udelay(1); | ||
1056 | /* codec power up */ | ||
1057 | set_scr(ice, SCR_PHP | SCR_CODEC_PDN); | ||
1058 | |||
1059 | /* MCR Initialize */ | ||
1060 | set_mcr(ice, 0); | ||
1061 | |||
1062 | /* CPLD Initialize */ | ||
1063 | set_cpld(ice, 0); | ||
1064 | |||
1065 | |||
1066 | ice->num_total_dacs = 2; | ||
1067 | ice->num_total_adcs = 2; | ||
1068 | |||
1069 | ice->akm = kcalloc(2, sizeof(struct snd_akm4xxx), GFP_KERNEL); | ||
1070 | ak = ice->akm; | ||
1071 | if (!ak) | ||
1072 | return -ENOMEM; | ||
1073 | /* only one codec with two chips */ | ||
1074 | ice->akm_codecs = 1; | ||
1075 | err = snd_ice1712_akm4xxx_init(ak, &akm_qtet_dac, NULL, ice); | ||
1076 | if (err < 0) | ||
1077 | return err; | ||
1078 | err = snd_ak4113_create(ice->card, | ||
1079 | qtet_ak4113_read, | ||
1080 | qtet_ak4113_write, | ||
1081 | ak4113_init_vals, | ||
1082 | ice, &spec->ak4113); | ||
1083 | if (err < 0) | ||
1084 | return err; | ||
1085 | /* callback for codecs rate setting */ | ||
1086 | spec->ak4113->change_callback = qtet_ak4113_change; | ||
1087 | spec->ak4113->change_callback_private = ice; | ||
1088 | /* AK41143 in Quartet can detect external rate correctly | ||
1089 | * (i.e. check_flags = 0) */ | ||
1090 | spec->ak4113->check_flags = 0; | ||
1091 | |||
1092 | proc_init(ice); | ||
1093 | |||
1094 | qtet_set_rate(ice, 44100); | ||
1095 | return 0; | ||
1096 | } | ||
1097 | |||
1098 | static unsigned char qtet_eeprom[] __devinitdata = { | ||
1099 | [ICE_EEP2_SYSCONF] = 0x28, /* clock 256(24MHz), mpu401, 1xADC, | ||
1100 | 1xDACs, SPDIF in */ | ||
1101 | [ICE_EEP2_ACLINK] = 0x80, /* I2S */ | ||
1102 | [ICE_EEP2_I2S] = 0x78, /* 96k, 24bit, 192k */ | ||
1103 | [ICE_EEP2_SPDIF] = 0xc3, /* out-en, out-int, in, out-ext */ | ||
1104 | [ICE_EEP2_GPIO_DIR] = 0x00, /* 0-7 inputs, switched to output | ||
1105 | only during output operations */ | ||
1106 | [ICE_EEP2_GPIO_DIR1] = 0xff, /* 8-15 outputs */ | ||
1107 | [ICE_EEP2_GPIO_DIR2] = 0x00, | ||
1108 | [ICE_EEP2_GPIO_MASK] = 0xff, /* changed only for OUT operations */ | ||
1109 | [ICE_EEP2_GPIO_MASK1] = 0x00, | ||
1110 | [ICE_EEP2_GPIO_MASK2] = 0xff, | ||
1111 | |||
1112 | [ICE_EEP2_GPIO_STATE] = 0x00, /* inputs */ | ||
1113 | [ICE_EEP2_GPIO_STATE1] = 0x7d, /* all 1, but GPIO_CPLD_RW | ||
1114 | and GPIO15 always zero */ | ||
1115 | [ICE_EEP2_GPIO_STATE2] = 0x00, /* inputs */ | ||
1116 | }; | ||
1117 | |||
1118 | /* entry point */ | ||
1119 | struct snd_ice1712_card_info snd_vt1724_qtet_cards[] __devinitdata = { | ||
1120 | { | ||
1121 | .subvendor = VT1724_SUBDEVICE_QTET, | ||
1122 | .name = "Infrasonic Quartet", | ||
1123 | .model = "quartet", | ||
1124 | .chip_init = qtet_init, | ||
1125 | .build_controls = qtet_add_controls, | ||
1126 | .eeprom_size = sizeof(qtet_eeprom), | ||
1127 | .eeprom_data = qtet_eeprom, | ||
1128 | }, | ||
1129 | { } /* terminator */ | ||
1130 | }; | ||
diff --git a/sound/pci/ice1712/quartet.h b/sound/pci/ice1712/quartet.h new file mode 100644 index 000000000000..80809b72439a --- /dev/null +++ b/sound/pci/ice1712/quartet.h | |||
@@ -0,0 +1,10 @@ | |||
1 | #ifndef __SOUND_QTET_H | ||
2 | #define __SOUND_QTET_H | ||
3 | |||
4 | #define QTET_DEVICE_DESC "{Infrasonic,Quartet}," | ||
5 | |||
6 | #define VT1724_SUBDEVICE_QTET 0x30305349 /* Infrasonic Quartet */ | ||
7 | |||
8 | extern struct snd_ice1712_card_info snd_vt1724_qtet_cards[]; | ||
9 | |||
10 | #endif /* __SOUND_QTET_H */ | ||
diff --git a/sound/pci/oxygen/Makefile b/sound/pci/oxygen/Makefile index 4ba07d42fd1d..389941cf6100 100644 --- a/sound/pci/oxygen/Makefile +++ b/sound/pci/oxygen/Makefile | |||
@@ -1,7 +1,8 @@ | |||
1 | snd-oxygen-lib-objs := oxygen_io.o oxygen_lib.o oxygen_mixer.o oxygen_pcm.o | 1 | snd-oxygen-lib-objs := oxygen_io.o oxygen_lib.o oxygen_mixer.o oxygen_pcm.o |
2 | snd-hifier-objs := hifier.o | 2 | snd-hifier-objs := hifier.o |
3 | snd-oxygen-objs := oxygen.o | 3 | snd-oxygen-objs := oxygen.o |
4 | snd-virtuoso-objs := virtuoso.o | 4 | snd-virtuoso-objs := virtuoso.o xonar_lib.o \ |
5 | xonar_pcm179x.o xonar_cs43xx.o xonar_hdmi.o | ||
5 | 6 | ||
6 | obj-$(CONFIG_SND_OXYGEN_LIB) += snd-oxygen-lib.o | 7 | obj-$(CONFIG_SND_OXYGEN_LIB) += snd-oxygen-lib.o |
7 | obj-$(CONFIG_SND_HIFIER) += snd-hifier.o | 8 | obj-$(CONFIG_SND_HIFIER) += snd-hifier.o |
diff --git a/sound/pci/oxygen/cs2000.h b/sound/pci/oxygen/cs2000.h new file mode 100644 index 000000000000..c3501bdb5edc --- /dev/null +++ b/sound/pci/oxygen/cs2000.h | |||
@@ -0,0 +1,83 @@ | |||
1 | #ifndef CS2000_H_INCLUDED | ||
2 | #define CS2000_H_INCLUDED | ||
3 | |||
4 | #define CS2000_DEV_ID 0x01 | ||
5 | #define CS2000_DEV_CTRL 0x02 | ||
6 | #define CS2000_DEV_CFG_1 0x03 | ||
7 | #define CS2000_DEV_CFG_2 0x04 | ||
8 | #define CS2000_GLOBAL_CFG 0x05 | ||
9 | #define CS2000_RATIO_0 0x06 /* 32 bits, big endian */ | ||
10 | #define CS2000_RATIO_1 0x0a | ||
11 | #define CS2000_RATIO_2 0x0e | ||
12 | #define CS2000_RATIO_3 0x12 | ||
13 | #define CS2000_FUN_CFG_1 0x16 | ||
14 | #define CS2000_FUN_CFG_2 0x17 | ||
15 | #define CS2000_FUN_CFG_3 0x1e | ||
16 | |||
17 | /* DEV_ID */ | ||
18 | #define CS2000_DEVICE_MASK 0xf8 | ||
19 | #define CS2000_REVISION_MASK 0x07 | ||
20 | |||
21 | /* DEV_CTRL */ | ||
22 | #define CS2000_UNLOCK 0x80 | ||
23 | #define CS2000_AUX_OUT_DIS 0x02 | ||
24 | #define CS2000_CLK_OUT_DIS 0x01 | ||
25 | |||
26 | /* DEV_CFG_1 */ | ||
27 | #define CS2000_R_MOD_SEL_MASK 0xe0 | ||
28 | #define CS2000_R_MOD_SEL_1 0x00 | ||
29 | #define CS2000_R_MOD_SEL_2 0x20 | ||
30 | #define CS2000_R_MOD_SEL_4 0x40 | ||
31 | #define CS2000_R_MOD_SEL_8 0x60 | ||
32 | #define CS2000_R_MOD_SEL_1_2 0x80 | ||
33 | #define CS2000_R_MOD_SEL_1_4 0xa0 | ||
34 | #define CS2000_R_MOD_SEL_1_8 0xc0 | ||
35 | #define CS2000_R_MOD_SEL_1_16 0xe0 | ||
36 | #define CS2000_R_SEL_MASK 0x18 | ||
37 | #define CS2000_R_SEL_SHIFT 3 | ||
38 | #define CS2000_AUX_OUT_SRC_MASK 0x06 | ||
39 | #define CS2000_AUX_OUT_SRC_REF_CLK 0x00 | ||
40 | #define CS2000_AUX_OUT_SRC_CLK_IN 0x02 | ||
41 | #define CS2000_AUX_OUT_SRC_CLK_OUT 0x04 | ||
42 | #define CS2000_AUX_OUT_SRC_PLL_LOCK 0x06 | ||
43 | #define CS2000_EN_DEV_CFG_1 0x01 | ||
44 | |||
45 | /* DEV_CFG_2 */ | ||
46 | #define CS2000_LOCK_CLK_MASK 0x06 | ||
47 | #define CS2000_LOCK_CLK_SHIFT 1 | ||
48 | #define CS2000_FRAC_N_SRC_MASK 0x01 | ||
49 | #define CS2000_FRAC_N_SRC_STATIC 0x00 | ||
50 | #define CS2000_FRAC_N_SRC_DYNAMIC 0x01 | ||
51 | |||
52 | /* GLOBAL_CFG */ | ||
53 | #define CS2000_FREEZE 0x08 | ||
54 | #define CS2000_EN_DEV_CFG_2 0x01 | ||
55 | |||
56 | /* FUN_CFG_1 */ | ||
57 | #define CS2000_CLK_SKIP_EN 0x80 | ||
58 | #define CS2000_AUX_LOCK_CFG_MASK 0x40 | ||
59 | #define CS2000_AUX_LOCK_CFG_PP_HIGH 0x00 | ||
60 | #define CS2000_AUX_LOCK_CFG_OD_LOW 0x40 | ||
61 | #define CS2000_REF_CLK_DIV_MASK 0x18 | ||
62 | #define CS2000_REF_CLK_DIV_4 0x00 | ||
63 | #define CS2000_REF_CLK_DIV_2 0x08 | ||
64 | #define CS2000_REF_CLK_DIV_1 0x10 | ||
65 | |||
66 | /* FUN_CFG_2 */ | ||
67 | #define CS2000_CLK_OUT_UNL 0x10 | ||
68 | #define CS2000_L_F_RATIO_CFG_MASK 0x08 | ||
69 | #define CS2000_L_F_RATIO_CFG_20_12 0x00 | ||
70 | #define CS2000_L_F_RATIO_CFG_12_20 0x08 | ||
71 | |||
72 | /* FUN_CFG_3 */ | ||
73 | #define CS2000_CLK_IN_BW_MASK 0x70 | ||
74 | #define CS2000_CLK_IN_BW_1 0x00 | ||
75 | #define CS2000_CLK_IN_BW_2 0x10 | ||
76 | #define CS2000_CLK_IN_BW_4 0x20 | ||
77 | #define CS2000_CLK_IN_BW_8 0x30 | ||
78 | #define CS2000_CLK_IN_BW_16 0x40 | ||
79 | #define CS2000_CLK_IN_BW_32 0x50 | ||
80 | #define CS2000_CLK_IN_BW_64 0x60 | ||
81 | #define CS2000_CLK_IN_BW_128 0x70 | ||
82 | |||
83 | #endif | ||
diff --git a/sound/pci/oxygen/hifier.c b/sound/pci/oxygen/hifier.c index 84ef13183419..e3c229b63311 100644 --- a/sound/pci/oxygen/hifier.c +++ b/sound/pci/oxygen/hifier.c | |||
@@ -17,6 +17,12 @@ | |||
17 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | 17 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
18 | */ | 18 | */ |
19 | 19 | ||
20 | /* | ||
21 | * CMI8788: | ||
22 | * | ||
23 | * SPI 0 -> AK4396 | ||
24 | */ | ||
25 | |||
20 | #include <linux/delay.h> | 26 | #include <linux/delay.h> |
21 | #include <linux/pci.h> | 27 | #include <linux/pci.h> |
22 | #include <sound/control.h> | 28 | #include <sound/control.h> |
@@ -51,23 +57,28 @@ static struct pci_device_id hifier_ids[] __devinitdata = { | |||
51 | MODULE_DEVICE_TABLE(pci, hifier_ids); | 57 | MODULE_DEVICE_TABLE(pci, hifier_ids); |
52 | 58 | ||
53 | struct hifier_data { | 59 | struct hifier_data { |
54 | u8 ak4396_ctl2; | 60 | u8 ak4396_regs[5]; |
55 | }; | 61 | }; |
56 | 62 | ||
57 | static void ak4396_write(struct oxygen *chip, u8 reg, u8 value) | 63 | static void ak4396_write(struct oxygen *chip, u8 reg, u8 value) |
58 | { | 64 | { |
65 | struct hifier_data *data = chip->model_data; | ||
66 | |||
59 | oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER | | 67 | oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER | |
60 | OXYGEN_SPI_DATA_LENGTH_2 | | 68 | OXYGEN_SPI_DATA_LENGTH_2 | |
61 | OXYGEN_SPI_CLOCK_160 | | 69 | OXYGEN_SPI_CLOCK_160 | |
62 | (0 << OXYGEN_SPI_CODEC_SHIFT) | | 70 | (0 << OXYGEN_SPI_CODEC_SHIFT) | |
63 | OXYGEN_SPI_CEN_LATCH_CLOCK_HI, | 71 | OXYGEN_SPI_CEN_LATCH_CLOCK_HI, |
64 | AK4396_WRITE | (reg << 8) | value); | 72 | AK4396_WRITE | (reg << 8) | value); |
73 | data->ak4396_regs[reg] = value; | ||
65 | } | 74 | } |
66 | 75 | ||
67 | static void update_ak4396_volume(struct oxygen *chip) | 76 | static void ak4396_write_cached(struct oxygen *chip, u8 reg, u8 value) |
68 | { | 77 | { |
69 | ak4396_write(chip, AK4396_LCH_ATT, chip->dac_volume[0]); | 78 | struct hifier_data *data = chip->model_data; |
70 | ak4396_write(chip, AK4396_RCH_ATT, chip->dac_volume[1]); | 79 | |
80 | if (value != data->ak4396_regs[reg]) | ||
81 | ak4396_write(chip, reg, value); | ||
71 | } | 82 | } |
72 | 83 | ||
73 | static void hifier_registers_init(struct oxygen *chip) | 84 | static void hifier_registers_init(struct oxygen *chip) |
@@ -75,16 +86,19 @@ static void hifier_registers_init(struct oxygen *chip) | |||
75 | struct hifier_data *data = chip->model_data; | 86 | struct hifier_data *data = chip->model_data; |
76 | 87 | ||
77 | ak4396_write(chip, AK4396_CONTROL_1, AK4396_DIF_24_MSB | AK4396_RSTN); | 88 | ak4396_write(chip, AK4396_CONTROL_1, AK4396_DIF_24_MSB | AK4396_RSTN); |
78 | ak4396_write(chip, AK4396_CONTROL_2, data->ak4396_ctl2); | 89 | ak4396_write(chip, AK4396_CONTROL_2, |
90 | data->ak4396_regs[AK4396_CONTROL_2]); | ||
79 | ak4396_write(chip, AK4396_CONTROL_3, AK4396_PCM); | 91 | ak4396_write(chip, AK4396_CONTROL_3, AK4396_PCM); |
80 | update_ak4396_volume(chip); | 92 | ak4396_write(chip, AK4396_LCH_ATT, chip->dac_volume[0]); |
93 | ak4396_write(chip, AK4396_RCH_ATT, chip->dac_volume[1]); | ||
81 | } | 94 | } |
82 | 95 | ||
83 | static void hifier_init(struct oxygen *chip) | 96 | static void hifier_init(struct oxygen *chip) |
84 | { | 97 | { |
85 | struct hifier_data *data = chip->model_data; | 98 | struct hifier_data *data = chip->model_data; |
86 | 99 | ||
87 | data->ak4396_ctl2 = AK4396_SMUTE | AK4396_DEM_OFF | AK4396_DFS_NORMAL; | 100 | data->ak4396_regs[AK4396_CONTROL_2] = |
101 | AK4396_SMUTE | AK4396_DEM_OFF | AK4396_DFS_NORMAL; | ||
88 | hifier_registers_init(chip); | 102 | hifier_registers_init(chip); |
89 | 103 | ||
90 | snd_component_add(chip->card, "AK4396"); | 104 | snd_component_add(chip->card, "AK4396"); |
@@ -106,20 +120,29 @@ static void set_ak4396_params(struct oxygen *chip, | |||
106 | struct hifier_data *data = chip->model_data; | 120 | struct hifier_data *data = chip->model_data; |
107 | u8 value; | 121 | u8 value; |
108 | 122 | ||
109 | value = data->ak4396_ctl2 & ~AK4396_DFS_MASK; | 123 | value = data->ak4396_regs[AK4396_CONTROL_2] & ~AK4396_DFS_MASK; |
110 | if (params_rate(params) <= 54000) | 124 | if (params_rate(params) <= 54000) |
111 | value |= AK4396_DFS_NORMAL; | 125 | value |= AK4396_DFS_NORMAL; |
112 | else if (params_rate(params) <= 108000) | 126 | else if (params_rate(params) <= 108000) |
113 | value |= AK4396_DFS_DOUBLE; | 127 | value |= AK4396_DFS_DOUBLE; |
114 | else | 128 | else |
115 | value |= AK4396_DFS_QUAD; | 129 | value |= AK4396_DFS_QUAD; |
116 | data->ak4396_ctl2 = value; | ||
117 | 130 | ||
118 | msleep(1); /* wait for the new MCLK to become stable */ | 131 | msleep(1); /* wait for the new MCLK to become stable */ |
119 | 132 | ||
120 | ak4396_write(chip, AK4396_CONTROL_1, AK4396_DIF_24_MSB); | 133 | if (value != data->ak4396_regs[AK4396_CONTROL_2]) { |
121 | ak4396_write(chip, AK4396_CONTROL_2, value); | 134 | ak4396_write(chip, AK4396_CONTROL_1, |
122 | ak4396_write(chip, AK4396_CONTROL_1, AK4396_DIF_24_MSB | AK4396_RSTN); | 135 | AK4396_DIF_24_MSB); |
136 | ak4396_write(chip, AK4396_CONTROL_2, value); | ||
137 | ak4396_write(chip, AK4396_CONTROL_1, | ||
138 | AK4396_DIF_24_MSB | AK4396_RSTN); | ||
139 | } | ||
140 | } | ||
141 | |||
142 | static void update_ak4396_volume(struct oxygen *chip) | ||
143 | { | ||
144 | ak4396_write_cached(chip, AK4396_LCH_ATT, chip->dac_volume[0]); | ||
145 | ak4396_write_cached(chip, AK4396_RCH_ATT, chip->dac_volume[1]); | ||
123 | } | 146 | } |
124 | 147 | ||
125 | static void update_ak4396_mute(struct oxygen *chip) | 148 | static void update_ak4396_mute(struct oxygen *chip) |
@@ -127,11 +150,10 @@ static void update_ak4396_mute(struct oxygen *chip) | |||
127 | struct hifier_data *data = chip->model_data; | 150 | struct hifier_data *data = chip->model_data; |
128 | u8 value; | 151 | u8 value; |
129 | 152 | ||
130 | value = data->ak4396_ctl2 & ~AK4396_SMUTE; | 153 | value = data->ak4396_regs[AK4396_CONTROL_2] & ~AK4396_SMUTE; |
131 | if (chip->dac_mute) | 154 | if (chip->dac_mute) |
132 | value |= AK4396_SMUTE; | 155 | value |= AK4396_SMUTE; |
133 | data->ak4396_ctl2 = value; | 156 | ak4396_write_cached(chip, AK4396_CONTROL_2, value); |
134 | ak4396_write(chip, AK4396_CONTROL_2, value); | ||
135 | } | 157 | } |
136 | 158 | ||
137 | static void set_cs5340_params(struct oxygen *chip, | 159 | static void set_cs5340_params(struct oxygen *chip, |
@@ -141,21 +163,14 @@ static void set_cs5340_params(struct oxygen *chip, | |||
141 | 163 | ||
142 | static const DECLARE_TLV_DB_LINEAR(ak4396_db_scale, TLV_DB_GAIN_MUTE, 0); | 164 | static const DECLARE_TLV_DB_LINEAR(ak4396_db_scale, TLV_DB_GAIN_MUTE, 0); |
143 | 165 | ||
144 | static int hifier_control_filter(struct snd_kcontrol_new *template) | ||
145 | { | ||
146 | if (!strcmp(template->name, "Stereo Upmixing")) | ||
147 | return 1; /* stereo only - we don't need upmixing */ | ||
148 | return 0; | ||
149 | } | ||
150 | |||
151 | static const struct oxygen_model model_hifier = { | 166 | static const struct oxygen_model model_hifier = { |
152 | .shortname = "C-Media CMI8787", | 167 | .shortname = "C-Media CMI8787", |
153 | .longname = "C-Media Oxygen HD Audio", | 168 | .longname = "C-Media Oxygen HD Audio", |
154 | .chip = "CMI8788", | 169 | .chip = "CMI8788", |
155 | .init = hifier_init, | 170 | .init = hifier_init, |
156 | .control_filter = hifier_control_filter, | ||
157 | .cleanup = hifier_cleanup, | 171 | .cleanup = hifier_cleanup, |
158 | .resume = hifier_resume, | 172 | .resume = hifier_resume, |
173 | .get_i2s_mclk = oxygen_default_i2s_mclk, | ||
159 | .set_dac_params = set_ak4396_params, | 174 | .set_dac_params = set_ak4396_params, |
160 | .set_adc_params = set_cs5340_params, | 175 | .set_adc_params = set_cs5340_params, |
161 | .update_dac_volume = update_ak4396_volume, | 176 | .update_dac_volume = update_ak4396_volume, |
diff --git a/sound/pci/oxygen/oxygen.c b/sound/pci/oxygen/oxygen.c index 72db4c39007f..acbedebcffd9 100644 --- a/sound/pci/oxygen/oxygen.c +++ b/sound/pci/oxygen/oxygen.c | |||
@@ -18,6 +18,8 @@ | |||
18 | */ | 18 | */ |
19 | 19 | ||
20 | /* | 20 | /* |
21 | * CMI8788: | ||
22 | * | ||
21 | * SPI 0 -> 1st AK4396 (front) | 23 | * SPI 0 -> 1st AK4396 (front) |
22 | * SPI 1 -> 2nd AK4396 (surround) | 24 | * SPI 1 -> 2nd AK4396 (surround) |
23 | * SPI 2 -> 3rd AK4396 (center/LFE) | 25 | * SPI 2 -> 3rd AK4396 (center/LFE) |
@@ -27,6 +29,10 @@ | |||
27 | * GPIO 0 -> DFS0 of AK5385 | 29 | * GPIO 0 -> DFS0 of AK5385 |
28 | * GPIO 1 -> DFS1 of AK5385 | 30 | * GPIO 1 -> DFS1 of AK5385 |
29 | * GPIO 8 -> enable headphone amplifier on HT-Omega models | 31 | * GPIO 8 -> enable headphone amplifier on HT-Omega models |
32 | * | ||
33 | * CM9780: | ||
34 | * | ||
35 | * GPO 0 -> route line-in (0) or AC97 output (1) to ADC input | ||
30 | */ | 36 | */ |
31 | 37 | ||
32 | #include <linux/delay.h> | 38 | #include <linux/delay.h> |
@@ -91,8 +97,8 @@ MODULE_DEVICE_TABLE(pci, oxygen_ids); | |||
91 | #define GPIO_CLARO_HP 0x0100 | 97 | #define GPIO_CLARO_HP 0x0100 |
92 | 98 | ||
93 | struct generic_data { | 99 | struct generic_data { |
94 | u8 ak4396_ctl2; | 100 | u8 ak4396_regs[4][5]; |
95 | u16 saved_wm8785_registers[2]; | 101 | u16 wm8785_regs[3]; |
96 | }; | 102 | }; |
97 | 103 | ||
98 | static void ak4396_write(struct oxygen *chip, unsigned int codec, | 104 | static void ak4396_write(struct oxygen *chip, unsigned int codec, |
@@ -102,12 +108,24 @@ static void ak4396_write(struct oxygen *chip, unsigned int codec, | |||
102 | static const u8 codec_spi_map[4] = { | 108 | static const u8 codec_spi_map[4] = { |
103 | 0, 1, 2, 4 | 109 | 0, 1, 2, 4 |
104 | }; | 110 | }; |
111 | struct generic_data *data = chip->model_data; | ||
112 | |||
105 | oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER | | 113 | oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER | |
106 | OXYGEN_SPI_DATA_LENGTH_2 | | 114 | OXYGEN_SPI_DATA_LENGTH_2 | |
107 | OXYGEN_SPI_CLOCK_160 | | 115 | OXYGEN_SPI_CLOCK_160 | |
108 | (codec_spi_map[codec] << OXYGEN_SPI_CODEC_SHIFT) | | 116 | (codec_spi_map[codec] << OXYGEN_SPI_CODEC_SHIFT) | |
109 | OXYGEN_SPI_CEN_LATCH_CLOCK_HI, | 117 | OXYGEN_SPI_CEN_LATCH_CLOCK_HI, |
110 | AK4396_WRITE | (reg << 8) | value); | 118 | AK4396_WRITE | (reg << 8) | value); |
119 | data->ak4396_regs[codec][reg] = value; | ||
120 | } | ||
121 | |||
122 | static void ak4396_write_cached(struct oxygen *chip, unsigned int codec, | ||
123 | u8 reg, u8 value) | ||
124 | { | ||
125 | struct generic_data *data = chip->model_data; | ||
126 | |||
127 | if (value != data->ak4396_regs[codec][reg]) | ||
128 | ak4396_write(chip, codec, reg, value); | ||
111 | } | 129 | } |
112 | 130 | ||
113 | static void wm8785_write(struct oxygen *chip, u8 reg, unsigned int value) | 131 | static void wm8785_write(struct oxygen *chip, u8 reg, unsigned int value) |
@@ -120,20 +138,8 @@ static void wm8785_write(struct oxygen *chip, u8 reg, unsigned int value) | |||
120 | (3 << OXYGEN_SPI_CODEC_SHIFT) | | 138 | (3 << OXYGEN_SPI_CODEC_SHIFT) | |
121 | OXYGEN_SPI_CEN_LATCH_CLOCK_LO, | 139 | OXYGEN_SPI_CEN_LATCH_CLOCK_LO, |
122 | (reg << 9) | value); | 140 | (reg << 9) | value); |
123 | if (reg < ARRAY_SIZE(data->saved_wm8785_registers)) | 141 | if (reg < ARRAY_SIZE(data->wm8785_regs)) |
124 | data->saved_wm8785_registers[reg] = value; | 142 | data->wm8785_regs[reg] = value; |
125 | } | ||
126 | |||
127 | static void update_ak4396_volume(struct oxygen *chip) | ||
128 | { | ||
129 | unsigned int i; | ||
130 | |||
131 | for (i = 0; i < 4; ++i) { | ||
132 | ak4396_write(chip, i, | ||
133 | AK4396_LCH_ATT, chip->dac_volume[i * 2]); | ||
134 | ak4396_write(chip, i, | ||
135 | AK4396_RCH_ATT, chip->dac_volume[i * 2 + 1]); | ||
136 | } | ||
137 | } | 143 | } |
138 | 144 | ||
139 | static void ak4396_registers_init(struct oxygen *chip) | 145 | static void ak4396_registers_init(struct oxygen *chip) |
@@ -142,21 +148,25 @@ static void ak4396_registers_init(struct oxygen *chip) | |||
142 | unsigned int i; | 148 | unsigned int i; |
143 | 149 | ||
144 | for (i = 0; i < 4; ++i) { | 150 | for (i = 0; i < 4; ++i) { |
145 | ak4396_write(chip, i, | 151 | ak4396_write(chip, i, AK4396_CONTROL_1, |
146 | AK4396_CONTROL_1, AK4396_DIF_24_MSB | AK4396_RSTN); | 152 | AK4396_DIF_24_MSB | AK4396_RSTN); |
147 | ak4396_write(chip, i, | 153 | ak4396_write(chip, i, AK4396_CONTROL_2, |
148 | AK4396_CONTROL_2, data->ak4396_ctl2); | 154 | data->ak4396_regs[0][AK4396_CONTROL_2]); |
149 | ak4396_write(chip, i, | 155 | ak4396_write(chip, i, AK4396_CONTROL_3, |
150 | AK4396_CONTROL_3, AK4396_PCM); | 156 | AK4396_PCM); |
157 | ak4396_write(chip, i, AK4396_LCH_ATT, | ||
158 | chip->dac_volume[i * 2]); | ||
159 | ak4396_write(chip, i, AK4396_RCH_ATT, | ||
160 | chip->dac_volume[i * 2 + 1]); | ||
151 | } | 161 | } |
152 | update_ak4396_volume(chip); | ||
153 | } | 162 | } |
154 | 163 | ||
155 | static void ak4396_init(struct oxygen *chip) | 164 | static void ak4396_init(struct oxygen *chip) |
156 | { | 165 | { |
157 | struct generic_data *data = chip->model_data; | 166 | struct generic_data *data = chip->model_data; |
158 | 167 | ||
159 | data->ak4396_ctl2 = AK4396_SMUTE | AK4396_DEM_OFF | AK4396_DFS_NORMAL; | 168 | data->ak4396_regs[0][AK4396_CONTROL_2] = |
169 | AK4396_SMUTE | AK4396_DEM_OFF | AK4396_DFS_NORMAL; | ||
160 | ak4396_registers_init(chip); | 170 | ak4396_registers_init(chip); |
161 | snd_component_add(chip->card, "AK4396"); | 171 | snd_component_add(chip->card, "AK4396"); |
162 | } | 172 | } |
@@ -173,17 +183,17 @@ static void wm8785_registers_init(struct oxygen *chip) | |||
173 | struct generic_data *data = chip->model_data; | 183 | struct generic_data *data = chip->model_data; |
174 | 184 | ||
175 | wm8785_write(chip, WM8785_R7, 0); | 185 | wm8785_write(chip, WM8785_R7, 0); |
176 | wm8785_write(chip, WM8785_R0, data->saved_wm8785_registers[0]); | 186 | wm8785_write(chip, WM8785_R0, data->wm8785_regs[0]); |
177 | wm8785_write(chip, WM8785_R1, data->saved_wm8785_registers[1]); | 187 | wm8785_write(chip, WM8785_R2, data->wm8785_regs[2]); |
178 | } | 188 | } |
179 | 189 | ||
180 | static void wm8785_init(struct oxygen *chip) | 190 | static void wm8785_init(struct oxygen *chip) |
181 | { | 191 | { |
182 | struct generic_data *data = chip->model_data; | 192 | struct generic_data *data = chip->model_data; |
183 | 193 | ||
184 | data->saved_wm8785_registers[0] = WM8785_MCR_SLAVE | | 194 | data->wm8785_regs[0] = |
185 | WM8785_OSR_SINGLE | WM8785_FORMAT_LJUST; | 195 | WM8785_MCR_SLAVE | WM8785_OSR_SINGLE | WM8785_FORMAT_LJUST; |
186 | data->saved_wm8785_registers[1] = WM8785_WL_24; | 196 | data->wm8785_regs[2] = WM8785_HPFR | WM8785_HPFL; |
187 | wm8785_registers_init(chip); | 197 | wm8785_registers_init(chip); |
188 | snd_component_add(chip->card, "WM8785"); | 198 | snd_component_add(chip->card, "WM8785"); |
189 | } | 199 | } |
@@ -264,24 +274,36 @@ static void set_ak4396_params(struct oxygen *chip, | |||
264 | unsigned int i; | 274 | unsigned int i; |
265 | u8 value; | 275 | u8 value; |
266 | 276 | ||
267 | value = data->ak4396_ctl2 & ~AK4396_DFS_MASK; | 277 | value = data->ak4396_regs[0][AK4396_CONTROL_2] & ~AK4396_DFS_MASK; |
268 | if (params_rate(params) <= 54000) | 278 | if (params_rate(params) <= 54000) |
269 | value |= AK4396_DFS_NORMAL; | 279 | value |= AK4396_DFS_NORMAL; |
270 | else if (params_rate(params) <= 108000) | 280 | else if (params_rate(params) <= 108000) |
271 | value |= AK4396_DFS_DOUBLE; | 281 | value |= AK4396_DFS_DOUBLE; |
272 | else | 282 | else |
273 | value |= AK4396_DFS_QUAD; | 283 | value |= AK4396_DFS_QUAD; |
274 | data->ak4396_ctl2 = value; | ||
275 | 284 | ||
276 | msleep(1); /* wait for the new MCLK to become stable */ | 285 | msleep(1); /* wait for the new MCLK to become stable */ |
277 | 286 | ||
287 | if (value != data->ak4396_regs[0][AK4396_CONTROL_2]) { | ||
288 | for (i = 0; i < 4; ++i) { | ||
289 | ak4396_write(chip, i, AK4396_CONTROL_1, | ||
290 | AK4396_DIF_24_MSB); | ||
291 | ak4396_write(chip, i, AK4396_CONTROL_2, value); | ||
292 | ak4396_write(chip, i, AK4396_CONTROL_1, | ||
293 | AK4396_DIF_24_MSB | AK4396_RSTN); | ||
294 | } | ||
295 | } | ||
296 | } | ||
297 | |||
298 | static void update_ak4396_volume(struct oxygen *chip) | ||
299 | { | ||
300 | unsigned int i; | ||
301 | |||
278 | for (i = 0; i < 4; ++i) { | 302 | for (i = 0; i < 4; ++i) { |
279 | ak4396_write(chip, i, | 303 | ak4396_write_cached(chip, i, AK4396_LCH_ATT, |
280 | AK4396_CONTROL_1, AK4396_DIF_24_MSB); | 304 | chip->dac_volume[i * 2]); |
281 | ak4396_write(chip, i, | 305 | ak4396_write_cached(chip, i, AK4396_RCH_ATT, |
282 | AK4396_CONTROL_2, value); | 306 | chip->dac_volume[i * 2 + 1]); |
283 | ak4396_write(chip, i, | ||
284 | AK4396_CONTROL_1, AK4396_DIF_24_MSB | AK4396_RSTN); | ||
285 | } | 307 | } |
286 | } | 308 | } |
287 | 309 | ||
@@ -291,21 +313,19 @@ static void update_ak4396_mute(struct oxygen *chip) | |||
291 | unsigned int i; | 313 | unsigned int i; |
292 | u8 value; | 314 | u8 value; |
293 | 315 | ||
294 | value = data->ak4396_ctl2 & ~AK4396_SMUTE; | 316 | value = data->ak4396_regs[0][AK4396_CONTROL_2] & ~AK4396_SMUTE; |
295 | if (chip->dac_mute) | 317 | if (chip->dac_mute) |
296 | value |= AK4396_SMUTE; | 318 | value |= AK4396_SMUTE; |
297 | data->ak4396_ctl2 = value; | ||
298 | for (i = 0; i < 4; ++i) | 319 | for (i = 0; i < 4; ++i) |
299 | ak4396_write(chip, i, AK4396_CONTROL_2, value); | 320 | ak4396_write_cached(chip, i, AK4396_CONTROL_2, value); |
300 | } | 321 | } |
301 | 322 | ||
302 | static void set_wm8785_params(struct oxygen *chip, | 323 | static void set_wm8785_params(struct oxygen *chip, |
303 | struct snd_pcm_hw_params *params) | 324 | struct snd_pcm_hw_params *params) |
304 | { | 325 | { |
326 | struct generic_data *data = chip->model_data; | ||
305 | unsigned int value; | 327 | unsigned int value; |
306 | 328 | ||
307 | wm8785_write(chip, WM8785_R7, 0); | ||
308 | |||
309 | value = WM8785_MCR_SLAVE | WM8785_FORMAT_LJUST; | 329 | value = WM8785_MCR_SLAVE | WM8785_FORMAT_LJUST; |
310 | if (params_rate(params) <= 48000) | 330 | if (params_rate(params) <= 48000) |
311 | value |= WM8785_OSR_SINGLE; | 331 | value |= WM8785_OSR_SINGLE; |
@@ -313,13 +333,11 @@ static void set_wm8785_params(struct oxygen *chip, | |||
313 | value |= WM8785_OSR_DOUBLE; | 333 | value |= WM8785_OSR_DOUBLE; |
314 | else | 334 | else |
315 | value |= WM8785_OSR_QUAD; | 335 | value |= WM8785_OSR_QUAD; |
316 | wm8785_write(chip, WM8785_R0, value); | 336 | if (value != data->wm8785_regs[0]) { |
317 | 337 | wm8785_write(chip, WM8785_R7, 0); | |
318 | if (snd_pcm_format_width(params_format(params)) <= 16) | 338 | wm8785_write(chip, WM8785_R0, value); |
319 | value = WM8785_WL_16; | 339 | wm8785_write(chip, WM8785_R2, data->wm8785_regs[2]); |
320 | else | 340 | } |
321 | value = WM8785_WL_24; | ||
322 | wm8785_write(chip, WM8785_R1, value); | ||
323 | } | 341 | } |
324 | 342 | ||
325 | static void set_ak5385_params(struct oxygen *chip, | 343 | static void set_ak5385_params(struct oxygen *chip, |
@@ -337,6 +355,134 @@ static void set_ak5385_params(struct oxygen *chip, | |||
337 | value, GPIO_AK5385_DFS_MASK); | 355 | value, GPIO_AK5385_DFS_MASK); |
338 | } | 356 | } |
339 | 357 | ||
358 | static int rolloff_info(struct snd_kcontrol *ctl, | ||
359 | struct snd_ctl_elem_info *info) | ||
360 | { | ||
361 | static const char *const names[2] = { | ||
362 | "Sharp Roll-off", "Slow Roll-off" | ||
363 | }; | ||
364 | |||
365 | info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; | ||
366 | info->count = 1; | ||
367 | info->value.enumerated.items = 2; | ||
368 | if (info->value.enumerated.item >= 2) | ||
369 | info->value.enumerated.item = 1; | ||
370 | strcpy(info->value.enumerated.name, names[info->value.enumerated.item]); | ||
371 | return 0; | ||
372 | } | ||
373 | |||
374 | static int rolloff_get(struct snd_kcontrol *ctl, | ||
375 | struct snd_ctl_elem_value *value) | ||
376 | { | ||
377 | struct oxygen *chip = ctl->private_data; | ||
378 | struct generic_data *data = chip->model_data; | ||
379 | |||
380 | value->value.enumerated.item[0] = | ||
381 | (data->ak4396_regs[0][AK4396_CONTROL_2] & AK4396_SLOW) != 0; | ||
382 | return 0; | ||
383 | } | ||
384 | |||
385 | static int rolloff_put(struct snd_kcontrol *ctl, | ||
386 | struct snd_ctl_elem_value *value) | ||
387 | { | ||
388 | struct oxygen *chip = ctl->private_data; | ||
389 | struct generic_data *data = chip->model_data; | ||
390 | unsigned int i; | ||
391 | int changed; | ||
392 | u8 reg; | ||
393 | |||
394 | mutex_lock(&chip->mutex); | ||
395 | reg = data->ak4396_regs[0][AK4396_CONTROL_2]; | ||
396 | if (value->value.enumerated.item[0]) | ||
397 | reg |= AK4396_SLOW; | ||
398 | else | ||
399 | reg &= ~AK4396_SLOW; | ||
400 | changed = reg != data->ak4396_regs[0][AK4396_CONTROL_2]; | ||
401 | if (changed) { | ||
402 | for (i = 0; i < 4; ++i) | ||
403 | ak4396_write(chip, i, AK4396_CONTROL_2, reg); | ||
404 | } | ||
405 | mutex_unlock(&chip->mutex); | ||
406 | return changed; | ||
407 | } | ||
408 | |||
409 | static const struct snd_kcontrol_new rolloff_control = { | ||
410 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
411 | .name = "DAC Filter Playback Enum", | ||
412 | .info = rolloff_info, | ||
413 | .get = rolloff_get, | ||
414 | .put = rolloff_put, | ||
415 | }; | ||
416 | |||
417 | static int hpf_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info) | ||
418 | { | ||
419 | static const char *const names[2] = { | ||
420 | "None", "High-pass Filter" | ||
421 | }; | ||
422 | |||
423 | info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; | ||
424 | info->count = 1; | ||
425 | info->value.enumerated.items = 2; | ||
426 | if (info->value.enumerated.item >= 2) | ||
427 | info->value.enumerated.item = 1; | ||
428 | strcpy(info->value.enumerated.name, names[info->value.enumerated.item]); | ||
429 | return 0; | ||
430 | } | ||
431 | |||
432 | static int hpf_get(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value) | ||
433 | { | ||
434 | struct oxygen *chip = ctl->private_data; | ||
435 | struct generic_data *data = chip->model_data; | ||
436 | |||
437 | value->value.enumerated.item[0] = | ||
438 | (data->wm8785_regs[WM8785_R2] & WM8785_HPFR) != 0; | ||
439 | return 0; | ||
440 | } | ||
441 | |||
442 | static int hpf_put(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value) | ||
443 | { | ||
444 | struct oxygen *chip = ctl->private_data; | ||
445 | struct generic_data *data = chip->model_data; | ||
446 | unsigned int reg; | ||
447 | int changed; | ||
448 | |||
449 | mutex_lock(&chip->mutex); | ||
450 | reg = data->wm8785_regs[WM8785_R2] & ~(WM8785_HPFR | WM8785_HPFL); | ||
451 | if (value->value.enumerated.item[0]) | ||
452 | reg |= WM8785_HPFR | WM8785_HPFL; | ||
453 | changed = reg != data->wm8785_regs[WM8785_R2]; | ||
454 | if (changed) | ||
455 | wm8785_write(chip, WM8785_R2, reg); | ||
456 | mutex_unlock(&chip->mutex); | ||
457 | return changed; | ||
458 | } | ||
459 | |||
460 | static const struct snd_kcontrol_new hpf_control = { | ||
461 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
462 | .name = "ADC Filter Capture Enum", | ||
463 | .info = hpf_info, | ||
464 | .get = hpf_get, | ||
465 | .put = hpf_put, | ||
466 | }; | ||
467 | |||
468 | static int generic_mixer_init(struct oxygen *chip) | ||
469 | { | ||
470 | return snd_ctl_add(chip->card, snd_ctl_new1(&rolloff_control, chip)); | ||
471 | } | ||
472 | |||
473 | static int generic_wm8785_mixer_init(struct oxygen *chip) | ||
474 | { | ||
475 | int err; | ||
476 | |||
477 | err = generic_mixer_init(chip); | ||
478 | if (err < 0) | ||
479 | return err; | ||
480 | err = snd_ctl_add(chip->card, snd_ctl_new1(&hpf_control, chip)); | ||
481 | if (err < 0) | ||
482 | return err; | ||
483 | return 0; | ||
484 | } | ||
485 | |||
340 | static const DECLARE_TLV_DB_LINEAR(ak4396_db_scale, TLV_DB_GAIN_MUTE, 0); | 486 | static const DECLARE_TLV_DB_LINEAR(ak4396_db_scale, TLV_DB_GAIN_MUTE, 0); |
341 | 487 | ||
342 | static const struct oxygen_model model_generic = { | 488 | static const struct oxygen_model model_generic = { |
@@ -344,8 +490,10 @@ static const struct oxygen_model model_generic = { | |||
344 | .longname = "C-Media Oxygen HD Audio", | 490 | .longname = "C-Media Oxygen HD Audio", |
345 | .chip = "CMI8788", | 491 | .chip = "CMI8788", |
346 | .init = generic_init, | 492 | .init = generic_init, |
493 | .mixer_init = generic_wm8785_mixer_init, | ||
347 | .cleanup = generic_cleanup, | 494 | .cleanup = generic_cleanup, |
348 | .resume = generic_resume, | 495 | .resume = generic_resume, |
496 | .get_i2s_mclk = oxygen_default_i2s_mclk, | ||
349 | .set_dac_params = set_ak4396_params, | 497 | .set_dac_params = set_ak4396_params, |
350 | .set_adc_params = set_wm8785_params, | 498 | .set_adc_params = set_wm8785_params, |
351 | .update_dac_volume = update_ak4396_volume, | 499 | .update_dac_volume = update_ak4396_volume, |
@@ -374,6 +522,7 @@ static int __devinit get_oxygen_model(struct oxygen *chip, | |||
374 | switch (id->driver_data) { | 522 | switch (id->driver_data) { |
375 | case MODEL_MERIDIAN: | 523 | case MODEL_MERIDIAN: |
376 | chip->model.init = meridian_init; | 524 | chip->model.init = meridian_init; |
525 | chip->model.mixer_init = generic_mixer_init; | ||
377 | chip->model.resume = meridian_resume; | 526 | chip->model.resume = meridian_resume; |
378 | chip->model.set_adc_params = set_ak5385_params; | 527 | chip->model.set_adc_params = set_ak5385_params; |
379 | chip->model.device_config = PLAYBACK_0_TO_I2S | | 528 | chip->model.device_config = PLAYBACK_0_TO_I2S | |
@@ -389,6 +538,7 @@ static int __devinit get_oxygen_model(struct oxygen *chip, | |||
389 | break; | 538 | break; |
390 | case MODEL_CLARO_HALO: | 539 | case MODEL_CLARO_HALO: |
391 | chip->model.init = claro_halo_init; | 540 | chip->model.init = claro_halo_init; |
541 | chip->model.mixer_init = generic_mixer_init; | ||
392 | chip->model.cleanup = claro_cleanup; | 542 | chip->model.cleanup = claro_cleanup; |
393 | chip->model.suspend = claro_suspend; | 543 | chip->model.suspend = claro_suspend; |
394 | chip->model.resume = claro_resume; | 544 | chip->model.resume = claro_resume; |
diff --git a/sound/pci/oxygen/oxygen.h b/sound/pci/oxygen/oxygen.h index bd615dbffadb..6147216af744 100644 --- a/sound/pci/oxygen/oxygen.h +++ b/sound/pci/oxygen/oxygen.h | |||
@@ -78,12 +78,15 @@ struct oxygen_model { | |||
78 | void (*resume)(struct oxygen *chip); | 78 | void (*resume)(struct oxygen *chip); |
79 | void (*pcm_hardware_filter)(unsigned int channel, | 79 | void (*pcm_hardware_filter)(unsigned int channel, |
80 | struct snd_pcm_hardware *hardware); | 80 | struct snd_pcm_hardware *hardware); |
81 | unsigned int (*get_i2s_mclk)(struct oxygen *chip, unsigned int channel, | ||
82 | struct snd_pcm_hw_params *hw_params); | ||
81 | void (*set_dac_params)(struct oxygen *chip, | 83 | void (*set_dac_params)(struct oxygen *chip, |
82 | struct snd_pcm_hw_params *params); | 84 | struct snd_pcm_hw_params *params); |
83 | void (*set_adc_params)(struct oxygen *chip, | 85 | void (*set_adc_params)(struct oxygen *chip, |
84 | struct snd_pcm_hw_params *params); | 86 | struct snd_pcm_hw_params *params); |
85 | void (*update_dac_volume)(struct oxygen *chip); | 87 | void (*update_dac_volume)(struct oxygen *chip); |
86 | void (*update_dac_mute)(struct oxygen *chip); | 88 | void (*update_dac_mute)(struct oxygen *chip); |
89 | void (*update_center_lfe_mix)(struct oxygen *chip, bool mixed); | ||
87 | void (*gpio_changed)(struct oxygen *chip); | 90 | void (*gpio_changed)(struct oxygen *chip); |
88 | void (*uart_input)(struct oxygen *chip); | 91 | void (*uart_input)(struct oxygen *chip); |
89 | void (*ac97_switch)(struct oxygen *chip, | 92 | void (*ac97_switch)(struct oxygen *chip, |
@@ -162,6 +165,8 @@ void oxygen_update_spdif_source(struct oxygen *chip); | |||
162 | /* oxygen_pcm.c */ | 165 | /* oxygen_pcm.c */ |
163 | 166 | ||
164 | int oxygen_pcm_init(struct oxygen *chip); | 167 | int oxygen_pcm_init(struct oxygen *chip); |
168 | unsigned int oxygen_default_i2s_mclk(struct oxygen *chip, unsigned int channel, | ||
169 | struct snd_pcm_hw_params *hw_params); | ||
165 | 170 | ||
166 | /* oxygen_io.c */ | 171 | /* oxygen_io.c */ |
167 | 172 | ||
diff --git a/sound/pci/oxygen/oxygen_lib.c b/sound/pci/oxygen/oxygen_lib.c index 9a8936e20744..9c5e6450eebb 100644 --- a/sound/pci/oxygen/oxygen_lib.c +++ b/sound/pci/oxygen/oxygen_lib.c | |||
@@ -278,7 +278,11 @@ oxygen_search_pci_id(struct oxygen *chip, const struct pci_device_id ids[]) | |||
278 | static void oxygen_restore_eeprom(struct oxygen *chip, | 278 | static void oxygen_restore_eeprom(struct oxygen *chip, |
279 | const struct pci_device_id *id) | 279 | const struct pci_device_id *id) |
280 | { | 280 | { |
281 | if (oxygen_read_eeprom(chip, 0) != OXYGEN_EEPROM_ID) { | 281 | u16 eeprom_id; |
282 | |||
283 | eeprom_id = oxygen_read_eeprom(chip, 0); | ||
284 | if (eeprom_id != OXYGEN_EEPROM_ID && | ||
285 | (eeprom_id != 0xffff || id->subdevice != 0x8788)) { | ||
282 | /* | 286 | /* |
283 | * This function gets called only when a known card model has | 287 | * This function gets called only when a known card model has |
284 | * been detected, i.e., we know there is a valid subsystem | 288 | * been detected, i.e., we know there is a valid subsystem |
@@ -303,6 +307,28 @@ static void oxygen_restore_eeprom(struct oxygen *chip, | |||
303 | } | 307 | } |
304 | } | 308 | } |
305 | 309 | ||
310 | static void pci_bridge_magic(void) | ||
311 | { | ||
312 | struct pci_dev *pci = NULL; | ||
313 | u32 tmp; | ||
314 | |||
315 | for (;;) { | ||
316 | /* If there is any Pericom PI7C9X110 PCI-E/PCI bridge ... */ | ||
317 | pci = pci_get_device(0x12d8, 0xe110, pci); | ||
318 | if (!pci) | ||
319 | break; | ||
320 | /* | ||
321 | * ... configure its secondary internal arbiter to park to | ||
322 | * the secondary port, instead of to the last master. | ||
323 | */ | ||
324 | if (!pci_read_config_dword(pci, 0x40, &tmp)) { | ||
325 | tmp |= 1; | ||
326 | pci_write_config_dword(pci, 0x40, tmp); | ||
327 | } | ||
328 | /* Why? Try asking C-Media. */ | ||
329 | } | ||
330 | } | ||
331 | |||
306 | static void oxygen_init(struct oxygen *chip) | 332 | static void oxygen_init(struct oxygen *chip) |
307 | { | 333 | { |
308 | unsigned int i; | 334 | unsigned int i; |
@@ -581,6 +607,7 @@ int oxygen_pci_probe(struct pci_dev *pci, int index, char *id, | |||
581 | snd_card_set_dev(card, &pci->dev); | 607 | snd_card_set_dev(card, &pci->dev); |
582 | card->private_free = oxygen_card_free; | 608 | card->private_free = oxygen_card_free; |
583 | 609 | ||
610 | pci_bridge_magic(); | ||
584 | oxygen_init(chip); | 611 | oxygen_init(chip); |
585 | chip->model.init(chip); | 612 | chip->model.init(chip); |
586 | 613 | ||
diff --git a/sound/pci/oxygen/oxygen_mixer.c b/sound/pci/oxygen/oxygen_mixer.c index 5401c547c4e3..f375b8a27862 100644 --- a/sound/pci/oxygen/oxygen_mixer.c +++ b/sound/pci/oxygen/oxygen_mixer.c | |||
@@ -99,11 +99,15 @@ static int dac_mute_put(struct snd_kcontrol *ctl, | |||
99 | 99 | ||
100 | static int upmix_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info) | 100 | static int upmix_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info) |
101 | { | 101 | { |
102 | static const char *const names[3] = { | 102 | static const char *const names[5] = { |
103 | "Front", "Front+Surround", "Front+Surround+Back" | 103 | "Front", |
104 | "Front+Surround", | ||
105 | "Front+Surround+Back", | ||
106 | "Front+Surround+Center/LFE", | ||
107 | "Front+Surround+Center/LFE+Back", | ||
104 | }; | 108 | }; |
105 | struct oxygen *chip = ctl->private_data; | 109 | struct oxygen *chip = ctl->private_data; |
106 | unsigned int count = 2 + (chip->model.dac_channels == 8); | 110 | unsigned int count = chip->model.update_center_lfe_mix ? 5 : 3; |
107 | 111 | ||
108 | info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; | 112 | info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; |
109 | info->count = 1; | 113 | info->count = 1; |
@@ -127,7 +131,7 @@ static int upmix_get(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value) | |||
127 | void oxygen_update_dac_routing(struct oxygen *chip) | 131 | void oxygen_update_dac_routing(struct oxygen *chip) |
128 | { | 132 | { |
129 | /* DAC 0: front, DAC 1: surround, DAC 2: center/LFE, DAC 3: back */ | 133 | /* DAC 0: front, DAC 1: surround, DAC 2: center/LFE, DAC 3: back */ |
130 | static const unsigned int reg_values[3] = { | 134 | static const unsigned int reg_values[5] = { |
131 | /* stereo -> front */ | 135 | /* stereo -> front */ |
132 | (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) | | 136 | (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) | |
133 | (1 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) | | 137 | (1 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) | |
@@ -143,6 +147,16 @@ void oxygen_update_dac_routing(struct oxygen *chip) | |||
143 | (0 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) | | 147 | (0 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) | |
144 | (2 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) | | 148 | (2 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) | |
145 | (0 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT), | 149 | (0 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT), |
150 | /* stereo -> front+surround+center/LFE */ | ||
151 | (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) | | ||
152 | (0 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) | | ||
153 | (0 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) | | ||
154 | (3 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT), | ||
155 | /* stereo -> front+surround+center/LFE+back */ | ||
156 | (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) | | ||
157 | (0 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) | | ||
158 | (0 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) | | ||
159 | (0 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT), | ||
146 | }; | 160 | }; |
147 | u8 channels; | 161 | u8 channels; |
148 | unsigned int reg_value; | 162 | unsigned int reg_value; |
@@ -167,22 +181,23 @@ void oxygen_update_dac_routing(struct oxygen *chip) | |||
167 | OXYGEN_PLAY_DAC1_SOURCE_MASK | | 181 | OXYGEN_PLAY_DAC1_SOURCE_MASK | |
168 | OXYGEN_PLAY_DAC2_SOURCE_MASK | | 182 | OXYGEN_PLAY_DAC2_SOURCE_MASK | |
169 | OXYGEN_PLAY_DAC3_SOURCE_MASK); | 183 | OXYGEN_PLAY_DAC3_SOURCE_MASK); |
184 | if (chip->model.update_center_lfe_mix) | ||
185 | chip->model.update_center_lfe_mix(chip, chip->dac_routing > 2); | ||
170 | } | 186 | } |
171 | 187 | ||
172 | static int upmix_put(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value) | 188 | static int upmix_put(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value) |
173 | { | 189 | { |
174 | struct oxygen *chip = ctl->private_data; | 190 | struct oxygen *chip = ctl->private_data; |
175 | unsigned int count = 2 + (chip->model.dac_channels == 8); | 191 | unsigned int count = chip->model.update_center_lfe_mix ? 5 : 3; |
176 | int changed; | 192 | int changed; |
177 | 193 | ||
194 | if (value->value.enumerated.item[0] >= count) | ||
195 | return -EINVAL; | ||
178 | mutex_lock(&chip->mutex); | 196 | mutex_lock(&chip->mutex); |
179 | changed = value->value.enumerated.item[0] != chip->dac_routing; | 197 | changed = value->value.enumerated.item[0] != chip->dac_routing; |
180 | if (changed) { | 198 | if (changed) { |
181 | chip->dac_routing = min(value->value.enumerated.item[0], | 199 | chip->dac_routing = value->value.enumerated.item[0]; |
182 | count - 1); | ||
183 | spin_lock_irq(&chip->reg_lock); | ||
184 | oxygen_update_dac_routing(chip); | 200 | oxygen_update_dac_routing(chip); |
185 | spin_unlock_irq(&chip->reg_lock); | ||
186 | } | 201 | } |
187 | mutex_unlock(&chip->mutex); | 202 | mutex_unlock(&chip->mutex); |
188 | return changed; | 203 | return changed; |
@@ -790,7 +805,7 @@ static const struct { | |||
790 | .controls = { | 805 | .controls = { |
791 | { | 806 | { |
792 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | 807 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
793 | .name = "Analog Input Monitor Switch", | 808 | .name = "Analog Input Monitor Playback Switch", |
794 | .info = snd_ctl_boolean_mono_info, | 809 | .info = snd_ctl_boolean_mono_info, |
795 | .get = monitor_get, | 810 | .get = monitor_get, |
796 | .put = monitor_put, | 811 | .put = monitor_put, |
@@ -798,7 +813,7 @@ static const struct { | |||
798 | }, | 813 | }, |
799 | { | 814 | { |
800 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | 815 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
801 | .name = "Analog Input Monitor Volume", | 816 | .name = "Analog Input Monitor Playback Volume", |
802 | .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | | 817 | .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | |
803 | SNDRV_CTL_ELEM_ACCESS_TLV_READ, | 818 | SNDRV_CTL_ELEM_ACCESS_TLV_READ, |
804 | .info = monitor_volume_info, | 819 | .info = monitor_volume_info, |
@@ -815,7 +830,7 @@ static const struct { | |||
815 | .controls = { | 830 | .controls = { |
816 | { | 831 | { |
817 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | 832 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
818 | .name = "Analog Input Monitor Switch", | 833 | .name = "Analog Input Monitor Playback Switch", |
819 | .info = snd_ctl_boolean_mono_info, | 834 | .info = snd_ctl_boolean_mono_info, |
820 | .get = monitor_get, | 835 | .get = monitor_get, |
821 | .put = monitor_put, | 836 | .put = monitor_put, |
@@ -823,7 +838,7 @@ static const struct { | |||
823 | }, | 838 | }, |
824 | { | 839 | { |
825 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | 840 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
826 | .name = "Analog Input Monitor Volume", | 841 | .name = "Analog Input Monitor Playback Volume", |
827 | .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | | 842 | .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | |
828 | SNDRV_CTL_ELEM_ACCESS_TLV_READ, | 843 | SNDRV_CTL_ELEM_ACCESS_TLV_READ, |
829 | .info = monitor_volume_info, | 844 | .info = monitor_volume_info, |
@@ -840,7 +855,7 @@ static const struct { | |||
840 | .controls = { | 855 | .controls = { |
841 | { | 856 | { |
842 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | 857 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
843 | .name = "Analog Input Monitor Switch", | 858 | .name = "Analog Input Monitor Playback Switch", |
844 | .index = 1, | 859 | .index = 1, |
845 | .info = snd_ctl_boolean_mono_info, | 860 | .info = snd_ctl_boolean_mono_info, |
846 | .get = monitor_get, | 861 | .get = monitor_get, |
@@ -849,7 +864,7 @@ static const struct { | |||
849 | }, | 864 | }, |
850 | { | 865 | { |
851 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | 866 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
852 | .name = "Analog Input Monitor Volume", | 867 | .name = "Analog Input Monitor Playback Volume", |
853 | .index = 1, | 868 | .index = 1, |
854 | .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | | 869 | .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | |
855 | SNDRV_CTL_ELEM_ACCESS_TLV_READ, | 870 | SNDRV_CTL_ELEM_ACCESS_TLV_READ, |
@@ -867,7 +882,7 @@ static const struct { | |||
867 | .controls = { | 882 | .controls = { |
868 | { | 883 | { |
869 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | 884 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
870 | .name = "Digital Input Monitor Switch", | 885 | .name = "Digital Input Monitor Playback Switch", |
871 | .info = snd_ctl_boolean_mono_info, | 886 | .info = snd_ctl_boolean_mono_info, |
872 | .get = monitor_get, | 887 | .get = monitor_get, |
873 | .put = monitor_put, | 888 | .put = monitor_put, |
@@ -875,7 +890,7 @@ static const struct { | |||
875 | }, | 890 | }, |
876 | { | 891 | { |
877 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | 892 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
878 | .name = "Digital Input Monitor Volume", | 893 | .name = "Digital Input Monitor Playback Volume", |
879 | .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | | 894 | .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | |
880 | SNDRV_CTL_ELEM_ACCESS_TLV_READ, | 895 | SNDRV_CTL_ELEM_ACCESS_TLV_READ, |
881 | .info = monitor_volume_info, | 896 | .info = monitor_volume_info, |
@@ -954,6 +969,9 @@ static int add_controls(struct oxygen *chip, | |||
954 | if (err == 1) | 969 | if (err == 1) |
955 | continue; | 970 | continue; |
956 | } | 971 | } |
972 | if (!strcmp(template.name, "Stereo Upmixing") && | ||
973 | chip->model.dac_channels == 2) | ||
974 | continue; | ||
957 | if (!strcmp(template.name, "Master Playback Volume") && | 975 | if (!strcmp(template.name, "Master Playback Volume") && |
958 | chip->model.dac_tlv) { | 976 | chip->model.dac_tlv) { |
959 | template.tlv.p = chip->model.dac_tlv; | 977 | template.tlv.p = chip->model.dac_tlv; |
diff --git a/sound/pci/oxygen/oxygen_pcm.c b/sound/pci/oxygen/oxygen_pcm.c index ef2345d82b86..9dff6954c397 100644 --- a/sound/pci/oxygen/oxygen_pcm.c +++ b/sound/pci/oxygen/oxygen_pcm.c | |||
@@ -271,13 +271,16 @@ static unsigned int oxygen_rate(struct snd_pcm_hw_params *hw_params) | |||
271 | } | 271 | } |
272 | } | 272 | } |
273 | 273 | ||
274 | static unsigned int oxygen_i2s_mclk(struct snd_pcm_hw_params *hw_params) | 274 | unsigned int oxygen_default_i2s_mclk(struct oxygen *chip, |
275 | unsigned int channel, | ||
276 | struct snd_pcm_hw_params *hw_params) | ||
275 | { | 277 | { |
276 | if (params_rate(hw_params) <= 96000) | 278 | if (params_rate(hw_params) <= 96000) |
277 | return OXYGEN_I2S_MCLK_256; | 279 | return OXYGEN_I2S_MCLK_256; |
278 | else | 280 | else |
279 | return OXYGEN_I2S_MCLK_128; | 281 | return OXYGEN_I2S_MCLK_128; |
280 | } | 282 | } |
283 | EXPORT_SYMBOL(oxygen_default_i2s_mclk); | ||
281 | 284 | ||
282 | static unsigned int oxygen_i2s_bits(struct snd_pcm_hw_params *hw_params) | 285 | static unsigned int oxygen_i2s_bits(struct snd_pcm_hw_params *hw_params) |
283 | { | 286 | { |
@@ -354,7 +357,7 @@ static int oxygen_rec_a_hw_params(struct snd_pcm_substream *substream, | |||
354 | OXYGEN_REC_FORMAT_A_MASK); | 357 | OXYGEN_REC_FORMAT_A_MASK); |
355 | oxygen_write16_masked(chip, OXYGEN_I2S_A_FORMAT, | 358 | oxygen_write16_masked(chip, OXYGEN_I2S_A_FORMAT, |
356 | oxygen_rate(hw_params) | | 359 | oxygen_rate(hw_params) | |
357 | oxygen_i2s_mclk(hw_params) | | 360 | chip->model.get_i2s_mclk(chip, PCM_A, hw_params) | |
358 | chip->model.adc_i2s_format | | 361 | chip->model.adc_i2s_format | |
359 | oxygen_i2s_bits(hw_params), | 362 | oxygen_i2s_bits(hw_params), |
360 | OXYGEN_I2S_RATE_MASK | | 363 | OXYGEN_I2S_RATE_MASK | |
@@ -390,7 +393,8 @@ static int oxygen_rec_b_hw_params(struct snd_pcm_substream *substream, | |||
390 | if (!is_ac97) | 393 | if (!is_ac97) |
391 | oxygen_write16_masked(chip, OXYGEN_I2S_B_FORMAT, | 394 | oxygen_write16_masked(chip, OXYGEN_I2S_B_FORMAT, |
392 | oxygen_rate(hw_params) | | 395 | oxygen_rate(hw_params) | |
393 | oxygen_i2s_mclk(hw_params) | | 396 | chip->model.get_i2s_mclk(chip, PCM_B, |
397 | hw_params) | | ||
394 | chip->model.adc_i2s_format | | 398 | chip->model.adc_i2s_format | |
395 | oxygen_i2s_bits(hw_params), | 399 | oxygen_i2s_bits(hw_params), |
396 | OXYGEN_I2S_RATE_MASK | | 400 | OXYGEN_I2S_RATE_MASK | |
@@ -435,6 +439,7 @@ static int oxygen_spdif_hw_params(struct snd_pcm_substream *substream, | |||
435 | if (err < 0) | 439 | if (err < 0) |
436 | return err; | 440 | return err; |
437 | 441 | ||
442 | mutex_lock(&chip->mutex); | ||
438 | spin_lock_irq(&chip->reg_lock); | 443 | spin_lock_irq(&chip->reg_lock); |
439 | oxygen_clear_bits32(chip, OXYGEN_SPDIF_CONTROL, | 444 | oxygen_clear_bits32(chip, OXYGEN_SPDIF_CONTROL, |
440 | OXYGEN_SPDIF_OUT_ENABLE); | 445 | OXYGEN_SPDIF_OUT_ENABLE); |
@@ -446,6 +451,7 @@ static int oxygen_spdif_hw_params(struct snd_pcm_substream *substream, | |||
446 | OXYGEN_SPDIF_OUT_RATE_MASK); | 451 | OXYGEN_SPDIF_OUT_RATE_MASK); |
447 | oxygen_update_spdif_source(chip); | 452 | oxygen_update_spdif_source(chip); |
448 | spin_unlock_irq(&chip->reg_lock); | 453 | spin_unlock_irq(&chip->reg_lock); |
454 | mutex_unlock(&chip->mutex); | ||
449 | return 0; | 455 | return 0; |
450 | } | 456 | } |
451 | 457 | ||
@@ -459,6 +465,7 @@ static int oxygen_multich_hw_params(struct snd_pcm_substream *substream, | |||
459 | if (err < 0) | 465 | if (err < 0) |
460 | return err; | 466 | return err; |
461 | 467 | ||
468 | mutex_lock(&chip->mutex); | ||
462 | spin_lock_irq(&chip->reg_lock); | 469 | spin_lock_irq(&chip->reg_lock); |
463 | oxygen_write8_masked(chip, OXYGEN_PLAY_CHANNELS, | 470 | oxygen_write8_masked(chip, OXYGEN_PLAY_CHANNELS, |
464 | oxygen_play_channels(hw_params), | 471 | oxygen_play_channels(hw_params), |
@@ -469,18 +476,18 @@ static int oxygen_multich_hw_params(struct snd_pcm_substream *substream, | |||
469 | oxygen_write16_masked(chip, OXYGEN_I2S_MULTICH_FORMAT, | 476 | oxygen_write16_masked(chip, OXYGEN_I2S_MULTICH_FORMAT, |
470 | oxygen_rate(hw_params) | | 477 | oxygen_rate(hw_params) | |
471 | chip->model.dac_i2s_format | | 478 | chip->model.dac_i2s_format | |
472 | oxygen_i2s_mclk(hw_params) | | 479 | chip->model.get_i2s_mclk(chip, PCM_MULTICH, |
480 | hw_params) | | ||
473 | oxygen_i2s_bits(hw_params), | 481 | oxygen_i2s_bits(hw_params), |
474 | OXYGEN_I2S_RATE_MASK | | 482 | OXYGEN_I2S_RATE_MASK | |
475 | OXYGEN_I2S_FORMAT_MASK | | 483 | OXYGEN_I2S_FORMAT_MASK | |
476 | OXYGEN_I2S_MCLK_MASK | | 484 | OXYGEN_I2S_MCLK_MASK | |
477 | OXYGEN_I2S_BITS_MASK); | 485 | OXYGEN_I2S_BITS_MASK); |
478 | oxygen_update_dac_routing(chip); | ||
479 | oxygen_update_spdif_source(chip); | 486 | oxygen_update_spdif_source(chip); |
480 | spin_unlock_irq(&chip->reg_lock); | 487 | spin_unlock_irq(&chip->reg_lock); |
481 | 488 | ||
482 | mutex_lock(&chip->mutex); | ||
483 | chip->model.set_dac_params(chip, hw_params); | 489 | chip->model.set_dac_params(chip, hw_params); |
490 | oxygen_update_dac_routing(chip); | ||
484 | mutex_unlock(&chip->mutex); | 491 | mutex_unlock(&chip->mutex); |
485 | return 0; | 492 | return 0; |
486 | } | 493 | } |
diff --git a/sound/pci/oxygen/virtuoso.c b/sound/pci/oxygen/virtuoso.c index 6ebcb6bdd712..6accaf9580b2 100644 --- a/sound/pci/oxygen/virtuoso.c +++ b/sound/pci/oxygen/virtuoso.c | |||
@@ -17,145 +17,12 @@ | |||
17 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | 17 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
18 | */ | 18 | */ |
19 | 19 | ||
20 | /* | ||
21 | * Xonar D2/D2X | ||
22 | * ------------ | ||
23 | * | ||
24 | * CMI8788: | ||
25 | * | ||
26 | * SPI 0 -> 1st PCM1796 (front) | ||
27 | * SPI 1 -> 2nd PCM1796 (surround) | ||
28 | * SPI 2 -> 3rd PCM1796 (center/LFE) | ||
29 | * SPI 4 -> 4th PCM1796 (back) | ||
30 | * | ||
31 | * GPIO 2 -> M0 of CS5381 | ||
32 | * GPIO 3 -> M1 of CS5381 | ||
33 | * GPIO 5 <- external power present (D2X only) | ||
34 | * GPIO 7 -> ALT | ||
35 | * GPIO 8 -> enable output to speakers | ||
36 | */ | ||
37 | |||
38 | /* | ||
39 | * Xonar D1/DX | ||
40 | * ----------- | ||
41 | * | ||
42 | * CMI8788: | ||
43 | * | ||
44 | * I²C <-> CS4398 (front) | ||
45 | * <-> CS4362A (surround, center/LFE, back) | ||
46 | * | ||
47 | * GPI 0 <- external power present (DX only) | ||
48 | * | ||
49 | * GPIO 0 -> enable output to speakers | ||
50 | * GPIO 1 -> enable front panel I/O | ||
51 | * GPIO 2 -> M0 of CS5361 | ||
52 | * GPIO 3 -> M1 of CS5361 | ||
53 | * GPIO 8 -> route input jack to line-in (0) or mic-in (1) | ||
54 | * | ||
55 | * CS4398: | ||
56 | * | ||
57 | * AD0 <- 1 | ||
58 | * AD1 <- 1 | ||
59 | * | ||
60 | * CS4362A: | ||
61 | * | ||
62 | * AD0 <- 0 | ||
63 | */ | ||
64 | |||
65 | /* | ||
66 | * Xonar HDAV1.3 (Deluxe) | ||
67 | * ---------------------- | ||
68 | * | ||
69 | * CMI8788: | ||
70 | * | ||
71 | * I²C <-> PCM1796 (front) | ||
72 | * | ||
73 | * GPI 0 <- external power present | ||
74 | * | ||
75 | * GPIO 0 -> enable output to speakers | ||
76 | * GPIO 2 -> M0 of CS5381 | ||
77 | * GPIO 3 -> M1 of CS5381 | ||
78 | * GPIO 8 -> route input jack to line-in (0) or mic-in (1) | ||
79 | * | ||
80 | * TXD -> HDMI controller | ||
81 | * RXD <- HDMI controller | ||
82 | * | ||
83 | * PCM1796 front: AD1,0 <- 0,0 | ||
84 | * | ||
85 | * no daughterboard | ||
86 | * ---------------- | ||
87 | * | ||
88 | * GPIO 4 <- 1 | ||
89 | * | ||
90 | * H6 daughterboard | ||
91 | * ---------------- | ||
92 | * | ||
93 | * GPIO 4 <- 0 | ||
94 | * GPIO 5 <- 0 | ||
95 | * | ||
96 | * I²C <-> PCM1796 (surround) | ||
97 | * <-> PCM1796 (center/LFE) | ||
98 | * <-> PCM1796 (back) | ||
99 | * | ||
100 | * PCM1796 surround: AD1,0 <- 0,1 | ||
101 | * PCM1796 center/LFE: AD1,0 <- 1,0 | ||
102 | * PCM1796 back: AD1,0 <- 1,1 | ||
103 | * | ||
104 | * unknown daughterboard | ||
105 | * --------------------- | ||
106 | * | ||
107 | * GPIO 4 <- 0 | ||
108 | * GPIO 5 <- 1 | ||
109 | * | ||
110 | * I²C <-> CS4362A (surround, center/LFE, back) | ||
111 | * | ||
112 | * CS4362A: AD0 <- 0 | ||
113 | */ | ||
114 | |||
115 | /* | ||
116 | * Xonar Essence ST (Deluxe)/STX | ||
117 | * ----------------------------- | ||
118 | * | ||
119 | * CMI8788: | ||
120 | * | ||
121 | * I²C <-> PCM1792A | ||
122 | * | ||
123 | * GPI 0 <- external power present | ||
124 | * | ||
125 | * GPIO 0 -> enable output to speakers | ||
126 | * GPIO 1 -> route HP to front panel (0) or rear jack (1) | ||
127 | * GPIO 2 -> M0 of CS5381 | ||
128 | * GPIO 3 -> M1 of CS5381 | ||
129 | * GPIO 7 -> route output to speaker jacks (0) or HP (1) | ||
130 | * GPIO 8 -> route input jack to line-in (0) or mic-in (1) | ||
131 | * | ||
132 | * PCM1792A: | ||
133 | * | ||
134 | * AD0 <- 0 | ||
135 | * | ||
136 | * H6 daughterboard | ||
137 | * ---------------- | ||
138 | * | ||
139 | * GPIO 4 <- 0 | ||
140 | * GPIO 5 <- 0 | ||
141 | */ | ||
142 | |||
143 | #include <linux/pci.h> | 20 | #include <linux/pci.h> |
144 | #include <linux/delay.h> | 21 | #include <linux/delay.h> |
145 | #include <linux/mutex.h> | ||
146 | #include <sound/ac97_codec.h> | ||
147 | #include <sound/asoundef.h> | ||
148 | #include <sound/control.h> | ||
149 | #include <sound/core.h> | 22 | #include <sound/core.h> |
150 | #include <sound/initval.h> | 23 | #include <sound/initval.h> |
151 | #include <sound/pcm.h> | 24 | #include <sound/pcm.h> |
152 | #include <sound/pcm_params.h> | 25 | #include "xonar.h" |
153 | #include <sound/tlv.h> | ||
154 | #include "oxygen.h" | ||
155 | #include "cm9780.h" | ||
156 | #include "pcm1796.h" | ||
157 | #include "cs4398.h" | ||
158 | #include "cs4362a.h" | ||
159 | 26 | ||
160 | MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>"); | 27 | MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>"); |
161 | MODULE_DESCRIPTION("Asus AVx00 driver"); | 28 | MODULE_DESCRIPTION("Asus AVx00 driver"); |
@@ -173,972 +40,28 @@ MODULE_PARM_DESC(id, "ID string"); | |||
173 | module_param_array(enable, bool, NULL, 0444); | 40 | module_param_array(enable, bool, NULL, 0444); |
174 | MODULE_PARM_DESC(enable, "enable card"); | 41 | MODULE_PARM_DESC(enable, "enable card"); |
175 | 42 | ||
176 | enum { | ||
177 | MODEL_D2, | ||
178 | MODEL_D2X, | ||
179 | MODEL_D1, | ||
180 | MODEL_DX, | ||
181 | MODEL_HDAV, /* without daughterboard */ | ||
182 | MODEL_HDAV_H6, /* with H6 daughterboard */ | ||
183 | MODEL_ST, | ||
184 | MODEL_ST_H6, | ||
185 | MODEL_STX, | ||
186 | }; | ||
187 | |||
188 | static struct pci_device_id xonar_ids[] __devinitdata = { | 43 | static struct pci_device_id xonar_ids[] __devinitdata = { |
189 | { OXYGEN_PCI_SUBID(0x1043, 0x8269), .driver_data = MODEL_D2 }, | 44 | { OXYGEN_PCI_SUBID(0x1043, 0x8269) }, |
190 | { OXYGEN_PCI_SUBID(0x1043, 0x8275), .driver_data = MODEL_DX }, | 45 | { OXYGEN_PCI_SUBID(0x1043, 0x8275) }, |
191 | { OXYGEN_PCI_SUBID(0x1043, 0x82b7), .driver_data = MODEL_D2X }, | 46 | { OXYGEN_PCI_SUBID(0x1043, 0x82b7) }, |
192 | { OXYGEN_PCI_SUBID(0x1043, 0x8314), .driver_data = MODEL_HDAV }, | 47 | { OXYGEN_PCI_SUBID(0x1043, 0x8314) }, |
193 | { OXYGEN_PCI_SUBID(0x1043, 0x8327), .driver_data = MODEL_DX }, | 48 | { OXYGEN_PCI_SUBID(0x1043, 0x8327) }, |
194 | { OXYGEN_PCI_SUBID(0x1043, 0x834f), .driver_data = MODEL_D1 }, | 49 | { OXYGEN_PCI_SUBID(0x1043, 0x834f) }, |
195 | { OXYGEN_PCI_SUBID(0x1043, 0x835c), .driver_data = MODEL_STX }, | 50 | { OXYGEN_PCI_SUBID(0x1043, 0x835c) }, |
196 | { OXYGEN_PCI_SUBID(0x1043, 0x835d), .driver_data = MODEL_ST }, | 51 | { OXYGEN_PCI_SUBID(0x1043, 0x835d) }, |
197 | { OXYGEN_PCI_SUBID_BROKEN_EEPROM }, | 52 | { OXYGEN_PCI_SUBID_BROKEN_EEPROM }, |
198 | { } | 53 | { } |
199 | }; | 54 | }; |
200 | MODULE_DEVICE_TABLE(pci, xonar_ids); | 55 | MODULE_DEVICE_TABLE(pci, xonar_ids); |
201 | 56 | ||
202 | |||
203 | #define GPIO_CS53x1_M_MASK 0x000c | ||
204 | #define GPIO_CS53x1_M_SINGLE 0x0000 | ||
205 | #define GPIO_CS53x1_M_DOUBLE 0x0004 | ||
206 | #define GPIO_CS53x1_M_QUAD 0x0008 | ||
207 | |||
208 | #define GPIO_D2X_EXT_POWER 0x0020 | ||
209 | #define GPIO_D2_ALT 0x0080 | ||
210 | #define GPIO_D2_OUTPUT_ENABLE 0x0100 | ||
211 | |||
212 | #define GPI_DX_EXT_POWER 0x01 | ||
213 | #define GPIO_DX_OUTPUT_ENABLE 0x0001 | ||
214 | #define GPIO_DX_FRONT_PANEL 0x0002 | ||
215 | #define GPIO_DX_INPUT_ROUTE 0x0100 | ||
216 | |||
217 | #define GPIO_DB_MASK 0x0030 | ||
218 | #define GPIO_DB_H6 0x0000 | ||
219 | #define GPIO_DB_XX 0x0020 | ||
220 | |||
221 | #define GPIO_ST_HP_REAR 0x0002 | ||
222 | #define GPIO_ST_HP 0x0080 | ||
223 | |||
224 | #define I2C_DEVICE_PCM1796(i) (0x98 + ((i) << 1)) /* 10011, ADx=i, /W=0 */ | ||
225 | #define I2C_DEVICE_CS4398 0x9e /* 10011, AD1=1, AD0=1, /W=0 */ | ||
226 | #define I2C_DEVICE_CS4362A 0x30 /* 001100, AD0=0, /W=0 */ | ||
227 | |||
228 | struct xonar_data { | ||
229 | unsigned int anti_pop_delay; | ||
230 | unsigned int dacs; | ||
231 | u16 output_enable_bit; | ||
232 | u8 ext_power_reg; | ||
233 | u8 ext_power_int_reg; | ||
234 | u8 ext_power_bit; | ||
235 | u8 has_power; | ||
236 | u8 pcm1796_oversampling; | ||
237 | u8 cs4398_fm; | ||
238 | u8 cs4362a_fm; | ||
239 | u8 hdmi_params[5]; | ||
240 | }; | ||
241 | |||
242 | static void xonar_gpio_changed(struct oxygen *chip); | ||
243 | |||
244 | static inline void pcm1796_write_spi(struct oxygen *chip, unsigned int codec, | ||
245 | u8 reg, u8 value) | ||
246 | { | ||
247 | /* maps ALSA channel pair number to SPI output */ | ||
248 | static const u8 codec_map[4] = { | ||
249 | 0, 1, 2, 4 | ||
250 | }; | ||
251 | oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER | | ||
252 | OXYGEN_SPI_DATA_LENGTH_2 | | ||
253 | OXYGEN_SPI_CLOCK_160 | | ||
254 | (codec_map[codec] << OXYGEN_SPI_CODEC_SHIFT) | | ||
255 | OXYGEN_SPI_CEN_LATCH_CLOCK_HI, | ||
256 | (reg << 8) | value); | ||
257 | } | ||
258 | |||
259 | static inline void pcm1796_write_i2c(struct oxygen *chip, unsigned int codec, | ||
260 | u8 reg, u8 value) | ||
261 | { | ||
262 | oxygen_write_i2c(chip, I2C_DEVICE_PCM1796(codec), reg, value); | ||
263 | } | ||
264 | |||
265 | static void pcm1796_write(struct oxygen *chip, unsigned int codec, | ||
266 | u8 reg, u8 value) | ||
267 | { | ||
268 | if ((chip->model.function_flags & OXYGEN_FUNCTION_2WIRE_SPI_MASK) == | ||
269 | OXYGEN_FUNCTION_SPI) | ||
270 | pcm1796_write_spi(chip, codec, reg, value); | ||
271 | else | ||
272 | pcm1796_write_i2c(chip, codec, reg, value); | ||
273 | } | ||
274 | |||
275 | static void cs4398_write(struct oxygen *chip, u8 reg, u8 value) | ||
276 | { | ||
277 | oxygen_write_i2c(chip, I2C_DEVICE_CS4398, reg, value); | ||
278 | } | ||
279 | |||
280 | static void cs4362a_write(struct oxygen *chip, u8 reg, u8 value) | ||
281 | { | ||
282 | oxygen_write_i2c(chip, I2C_DEVICE_CS4362A, reg, value); | ||
283 | } | ||
284 | |||
285 | static void hdmi_write_command(struct oxygen *chip, u8 command, | ||
286 | unsigned int count, const u8 *params) | ||
287 | { | ||
288 | unsigned int i; | ||
289 | u8 checksum; | ||
290 | |||
291 | oxygen_write_uart(chip, 0xfb); | ||
292 | oxygen_write_uart(chip, 0xef); | ||
293 | oxygen_write_uart(chip, command); | ||
294 | oxygen_write_uart(chip, count); | ||
295 | for (i = 0; i < count; ++i) | ||
296 | oxygen_write_uart(chip, params[i]); | ||
297 | checksum = 0xfb + 0xef + command + count; | ||
298 | for (i = 0; i < count; ++i) | ||
299 | checksum += params[i]; | ||
300 | oxygen_write_uart(chip, checksum); | ||
301 | } | ||
302 | |||
303 | static void xonar_enable_output(struct oxygen *chip) | ||
304 | { | ||
305 | struct xonar_data *data = chip->model_data; | ||
306 | |||
307 | msleep(data->anti_pop_delay); | ||
308 | oxygen_set_bits16(chip, OXYGEN_GPIO_DATA, data->output_enable_bit); | ||
309 | } | ||
310 | |||
311 | static void xonar_common_init(struct oxygen *chip) | ||
312 | { | ||
313 | struct xonar_data *data = chip->model_data; | ||
314 | |||
315 | if (data->ext_power_reg) { | ||
316 | oxygen_set_bits8(chip, data->ext_power_int_reg, | ||
317 | data->ext_power_bit); | ||
318 | chip->interrupt_mask |= OXYGEN_INT_GPIO; | ||
319 | chip->model.gpio_changed = xonar_gpio_changed; | ||
320 | data->has_power = !!(oxygen_read8(chip, data->ext_power_reg) | ||
321 | & data->ext_power_bit); | ||
322 | } | ||
323 | oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, | ||
324 | GPIO_CS53x1_M_MASK | data->output_enable_bit); | ||
325 | oxygen_write16_masked(chip, OXYGEN_GPIO_DATA, | ||
326 | GPIO_CS53x1_M_SINGLE, GPIO_CS53x1_M_MASK); | ||
327 | oxygen_ac97_set_bits(chip, 0, CM9780_JACK, CM9780_FMIC2MIC); | ||
328 | xonar_enable_output(chip); | ||
329 | } | ||
330 | |||
331 | static void update_pcm1796_volume(struct oxygen *chip) | ||
332 | { | ||
333 | struct xonar_data *data = chip->model_data; | ||
334 | unsigned int i; | ||
335 | |||
336 | for (i = 0; i < data->dacs; ++i) { | ||
337 | pcm1796_write(chip, i, 16, chip->dac_volume[i * 2]); | ||
338 | pcm1796_write(chip, i, 17, chip->dac_volume[i * 2 + 1]); | ||
339 | } | ||
340 | } | ||
341 | |||
342 | static void update_pcm1796_mute(struct oxygen *chip) | ||
343 | { | ||
344 | struct xonar_data *data = chip->model_data; | ||
345 | unsigned int i; | ||
346 | u8 value; | ||
347 | |||
348 | value = PCM1796_DMF_DISABLED | PCM1796_FMT_24_LJUST | PCM1796_ATLD; | ||
349 | if (chip->dac_mute) | ||
350 | value |= PCM1796_MUTE; | ||
351 | for (i = 0; i < data->dacs; ++i) | ||
352 | pcm1796_write(chip, i, 18, value); | ||
353 | } | ||
354 | |||
355 | static void pcm1796_init(struct oxygen *chip) | ||
356 | { | ||
357 | struct xonar_data *data = chip->model_data; | ||
358 | unsigned int i; | ||
359 | |||
360 | for (i = 0; i < data->dacs; ++i) { | ||
361 | pcm1796_write(chip, i, 19, PCM1796_FLT_SHARP | PCM1796_ATS_1); | ||
362 | pcm1796_write(chip, i, 20, data->pcm1796_oversampling); | ||
363 | pcm1796_write(chip, i, 21, 0); | ||
364 | } | ||
365 | update_pcm1796_mute(chip); /* set ATLD before ATL/ATR */ | ||
366 | update_pcm1796_volume(chip); | ||
367 | } | ||
368 | |||
369 | static void xonar_d2_init(struct oxygen *chip) | ||
370 | { | ||
371 | struct xonar_data *data = chip->model_data; | ||
372 | |||
373 | data->anti_pop_delay = 300; | ||
374 | data->dacs = 4; | ||
375 | data->output_enable_bit = GPIO_D2_OUTPUT_ENABLE; | ||
376 | data->pcm1796_oversampling = PCM1796_OS_64; | ||
377 | |||
378 | pcm1796_init(chip); | ||
379 | |||
380 | oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_D2_ALT); | ||
381 | oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, GPIO_D2_ALT); | ||
382 | |||
383 | xonar_common_init(chip); | ||
384 | |||
385 | snd_component_add(chip->card, "PCM1796"); | ||
386 | snd_component_add(chip->card, "CS5381"); | ||
387 | } | ||
388 | |||
389 | static void xonar_d2x_init(struct oxygen *chip) | ||
390 | { | ||
391 | struct xonar_data *data = chip->model_data; | ||
392 | |||
393 | data->ext_power_reg = OXYGEN_GPIO_DATA; | ||
394 | data->ext_power_int_reg = OXYGEN_GPIO_INTERRUPT_MASK; | ||
395 | data->ext_power_bit = GPIO_D2X_EXT_POWER; | ||
396 | oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_D2X_EXT_POWER); | ||
397 | |||
398 | xonar_d2_init(chip); | ||
399 | } | ||
400 | |||
401 | static void update_cs4362a_volumes(struct oxygen *chip) | ||
402 | { | ||
403 | u8 mute; | ||
404 | |||
405 | mute = chip->dac_mute ? CS4362A_MUTE : 0; | ||
406 | cs4362a_write(chip, 7, (127 - chip->dac_volume[2]) | mute); | ||
407 | cs4362a_write(chip, 8, (127 - chip->dac_volume[3]) | mute); | ||
408 | cs4362a_write(chip, 10, (127 - chip->dac_volume[4]) | mute); | ||
409 | cs4362a_write(chip, 11, (127 - chip->dac_volume[5]) | mute); | ||
410 | cs4362a_write(chip, 13, (127 - chip->dac_volume[6]) | mute); | ||
411 | cs4362a_write(chip, 14, (127 - chip->dac_volume[7]) | mute); | ||
412 | } | ||
413 | |||
414 | static void update_cs43xx_volume(struct oxygen *chip) | ||
415 | { | ||
416 | cs4398_write(chip, 5, (127 - chip->dac_volume[0]) * 2); | ||
417 | cs4398_write(chip, 6, (127 - chip->dac_volume[1]) * 2); | ||
418 | update_cs4362a_volumes(chip); | ||
419 | } | ||
420 | |||
421 | static void update_cs43xx_mute(struct oxygen *chip) | ||
422 | { | ||
423 | u8 reg; | ||
424 | |||
425 | reg = CS4398_MUTEP_LOW | CS4398_PAMUTE; | ||
426 | if (chip->dac_mute) | ||
427 | reg |= CS4398_MUTE_B | CS4398_MUTE_A; | ||
428 | cs4398_write(chip, 4, reg); | ||
429 | update_cs4362a_volumes(chip); | ||
430 | } | ||
431 | |||
432 | static void cs43xx_init(struct oxygen *chip) | ||
433 | { | ||
434 | struct xonar_data *data = chip->model_data; | ||
435 | |||
436 | /* set CPEN (control port mode) and power down */ | ||
437 | cs4398_write(chip, 8, CS4398_CPEN | CS4398_PDN); | ||
438 | cs4362a_write(chip, 0x01, CS4362A_PDN | CS4362A_CPEN); | ||
439 | /* configure */ | ||
440 | cs4398_write(chip, 2, data->cs4398_fm); | ||
441 | cs4398_write(chip, 3, CS4398_ATAPI_B_R | CS4398_ATAPI_A_L); | ||
442 | cs4398_write(chip, 7, CS4398_RMP_DN | CS4398_RMP_UP | | ||
443 | CS4398_ZERO_CROSS | CS4398_SOFT_RAMP); | ||
444 | cs4362a_write(chip, 0x02, CS4362A_DIF_LJUST); | ||
445 | cs4362a_write(chip, 0x03, CS4362A_MUTEC_6 | CS4362A_AMUTE | | ||
446 | CS4362A_RMP_UP | CS4362A_ZERO_CROSS | CS4362A_SOFT_RAMP); | ||
447 | cs4362a_write(chip, 0x04, CS4362A_RMP_DN | CS4362A_DEM_NONE); | ||
448 | cs4362a_write(chip, 0x05, 0); | ||
449 | cs4362a_write(chip, 0x06, data->cs4362a_fm); | ||
450 | cs4362a_write(chip, 0x09, data->cs4362a_fm); | ||
451 | cs4362a_write(chip, 0x0c, data->cs4362a_fm); | ||
452 | update_cs43xx_volume(chip); | ||
453 | update_cs43xx_mute(chip); | ||
454 | /* clear power down */ | ||
455 | cs4398_write(chip, 8, CS4398_CPEN); | ||
456 | cs4362a_write(chip, 0x01, CS4362A_CPEN); | ||
457 | } | ||
458 | |||
459 | static void xonar_d1_init(struct oxygen *chip) | ||
460 | { | ||
461 | struct xonar_data *data = chip->model_data; | ||
462 | |||
463 | data->anti_pop_delay = 800; | ||
464 | data->output_enable_bit = GPIO_DX_OUTPUT_ENABLE; | ||
465 | data->cs4398_fm = CS4398_FM_SINGLE | CS4398_DEM_NONE | CS4398_DIF_LJUST; | ||
466 | data->cs4362a_fm = CS4362A_FM_SINGLE | | ||
467 | CS4362A_ATAPI_B_R | CS4362A_ATAPI_A_L; | ||
468 | |||
469 | oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS, | ||
470 | OXYGEN_2WIRE_LENGTH_8 | | ||
471 | OXYGEN_2WIRE_INTERRUPT_MASK | | ||
472 | OXYGEN_2WIRE_SPEED_FAST); | ||
473 | |||
474 | cs43xx_init(chip); | ||
475 | |||
476 | oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, | ||
477 | GPIO_DX_FRONT_PANEL | GPIO_DX_INPUT_ROUTE); | ||
478 | oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, | ||
479 | GPIO_DX_FRONT_PANEL | GPIO_DX_INPUT_ROUTE); | ||
480 | |||
481 | xonar_common_init(chip); | ||
482 | |||
483 | snd_component_add(chip->card, "CS4398"); | ||
484 | snd_component_add(chip->card, "CS4362A"); | ||
485 | snd_component_add(chip->card, "CS5361"); | ||
486 | } | ||
487 | |||
488 | static void xonar_dx_init(struct oxygen *chip) | ||
489 | { | ||
490 | struct xonar_data *data = chip->model_data; | ||
491 | |||
492 | data->ext_power_reg = OXYGEN_GPI_DATA; | ||
493 | data->ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK; | ||
494 | data->ext_power_bit = GPI_DX_EXT_POWER; | ||
495 | |||
496 | xonar_d1_init(chip); | ||
497 | } | ||
498 | |||
499 | static void xonar_hdav_init(struct oxygen *chip) | ||
500 | { | ||
501 | struct xonar_data *data = chip->model_data; | ||
502 | u8 param; | ||
503 | |||
504 | oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS, | ||
505 | OXYGEN_2WIRE_LENGTH_8 | | ||
506 | OXYGEN_2WIRE_INTERRUPT_MASK | | ||
507 | OXYGEN_2WIRE_SPEED_FAST); | ||
508 | |||
509 | data->anti_pop_delay = 100; | ||
510 | data->dacs = chip->model.private_data == MODEL_HDAV_H6 ? 4 : 1; | ||
511 | data->output_enable_bit = GPIO_DX_OUTPUT_ENABLE; | ||
512 | data->ext_power_reg = OXYGEN_GPI_DATA; | ||
513 | data->ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK; | ||
514 | data->ext_power_bit = GPI_DX_EXT_POWER; | ||
515 | data->pcm1796_oversampling = PCM1796_OS_64; | ||
516 | |||
517 | pcm1796_init(chip); | ||
518 | |||
519 | oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DX_INPUT_ROUTE); | ||
520 | oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, GPIO_DX_INPUT_ROUTE); | ||
521 | |||
522 | oxygen_reset_uart(chip); | ||
523 | param = 0; | ||
524 | hdmi_write_command(chip, 0x61, 1, ¶m); | ||
525 | param = 1; | ||
526 | hdmi_write_command(chip, 0x74, 1, ¶m); | ||
527 | data->hdmi_params[1] = IEC958_AES3_CON_FS_48000; | ||
528 | data->hdmi_params[4] = 1; | ||
529 | hdmi_write_command(chip, 0x54, 5, data->hdmi_params); | ||
530 | |||
531 | xonar_common_init(chip); | ||
532 | |||
533 | snd_component_add(chip->card, "PCM1796"); | ||
534 | snd_component_add(chip->card, "CS5381"); | ||
535 | } | ||
536 | |||
537 | static void xonar_st_init(struct oxygen *chip) | ||
538 | { | ||
539 | struct xonar_data *data = chip->model_data; | ||
540 | |||
541 | oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS, | ||
542 | OXYGEN_2WIRE_LENGTH_8 | | ||
543 | OXYGEN_2WIRE_INTERRUPT_MASK | | ||
544 | OXYGEN_2WIRE_SPEED_FAST); | ||
545 | |||
546 | if (chip->model.private_data == MODEL_ST_H6) | ||
547 | chip->model.dac_channels = 8; | ||
548 | data->anti_pop_delay = 100; | ||
549 | data->dacs = chip->model.private_data == MODEL_ST_H6 ? 4 : 1; | ||
550 | data->output_enable_bit = GPIO_DX_OUTPUT_ENABLE; | ||
551 | data->pcm1796_oversampling = PCM1796_OS_64; | ||
552 | |||
553 | pcm1796_init(chip); | ||
554 | |||
555 | oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, | ||
556 | GPIO_DX_INPUT_ROUTE | GPIO_ST_HP_REAR | GPIO_ST_HP); | ||
557 | oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, | ||
558 | GPIO_DX_INPUT_ROUTE | GPIO_ST_HP_REAR | GPIO_ST_HP); | ||
559 | |||
560 | xonar_common_init(chip); | ||
561 | |||
562 | snd_component_add(chip->card, "PCM1792A"); | ||
563 | snd_component_add(chip->card, "CS5381"); | ||
564 | } | ||
565 | |||
566 | static void xonar_stx_init(struct oxygen *chip) | ||
567 | { | ||
568 | struct xonar_data *data = chip->model_data; | ||
569 | |||
570 | data->ext_power_reg = OXYGEN_GPI_DATA; | ||
571 | data->ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK; | ||
572 | data->ext_power_bit = GPI_DX_EXT_POWER; | ||
573 | |||
574 | xonar_st_init(chip); | ||
575 | } | ||
576 | |||
577 | static void xonar_disable_output(struct oxygen *chip) | ||
578 | { | ||
579 | struct xonar_data *data = chip->model_data; | ||
580 | |||
581 | oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, data->output_enable_bit); | ||
582 | } | ||
583 | |||
584 | static void xonar_d2_cleanup(struct oxygen *chip) | ||
585 | { | ||
586 | xonar_disable_output(chip); | ||
587 | } | ||
588 | |||
589 | static void xonar_d1_cleanup(struct oxygen *chip) | ||
590 | { | ||
591 | xonar_disable_output(chip); | ||
592 | cs4362a_write(chip, 0x01, CS4362A_PDN | CS4362A_CPEN); | ||
593 | oxygen_clear_bits8(chip, OXYGEN_FUNCTION, OXYGEN_FUNCTION_RESET_CODEC); | ||
594 | } | ||
595 | |||
596 | static void xonar_hdav_cleanup(struct oxygen *chip) | ||
597 | { | ||
598 | u8 param = 0; | ||
599 | |||
600 | hdmi_write_command(chip, 0x74, 1, ¶m); | ||
601 | xonar_disable_output(chip); | ||
602 | } | ||
603 | |||
604 | static void xonar_st_cleanup(struct oxygen *chip) | ||
605 | { | ||
606 | xonar_disable_output(chip); | ||
607 | } | ||
608 | |||
609 | static void xonar_d2_suspend(struct oxygen *chip) | ||
610 | { | ||
611 | xonar_d2_cleanup(chip); | ||
612 | } | ||
613 | |||
614 | static void xonar_d1_suspend(struct oxygen *chip) | ||
615 | { | ||
616 | xonar_d1_cleanup(chip); | ||
617 | } | ||
618 | |||
619 | static void xonar_hdav_suspend(struct oxygen *chip) | ||
620 | { | ||
621 | xonar_hdav_cleanup(chip); | ||
622 | msleep(2); | ||
623 | } | ||
624 | |||
625 | static void xonar_st_suspend(struct oxygen *chip) | ||
626 | { | ||
627 | xonar_st_cleanup(chip); | ||
628 | } | ||
629 | |||
630 | static void xonar_d2_resume(struct oxygen *chip) | ||
631 | { | ||
632 | pcm1796_init(chip); | ||
633 | xonar_enable_output(chip); | ||
634 | } | ||
635 | |||
636 | static void xonar_d1_resume(struct oxygen *chip) | ||
637 | { | ||
638 | oxygen_set_bits8(chip, OXYGEN_FUNCTION, OXYGEN_FUNCTION_RESET_CODEC); | ||
639 | msleep(1); | ||
640 | cs43xx_init(chip); | ||
641 | xonar_enable_output(chip); | ||
642 | } | ||
643 | |||
644 | static void xonar_hdav_resume(struct oxygen *chip) | ||
645 | { | ||
646 | struct xonar_data *data = chip->model_data; | ||
647 | u8 param; | ||
648 | |||
649 | oxygen_reset_uart(chip); | ||
650 | param = 0; | ||
651 | hdmi_write_command(chip, 0x61, 1, ¶m); | ||
652 | param = 1; | ||
653 | hdmi_write_command(chip, 0x74, 1, ¶m); | ||
654 | hdmi_write_command(chip, 0x54, 5, data->hdmi_params); | ||
655 | pcm1796_init(chip); | ||
656 | xonar_enable_output(chip); | ||
657 | } | ||
658 | |||
659 | static void xonar_st_resume(struct oxygen *chip) | ||
660 | { | ||
661 | pcm1796_init(chip); | ||
662 | xonar_enable_output(chip); | ||
663 | } | ||
664 | |||
665 | static void xonar_hdav_pcm_hardware_filter(unsigned int channel, | ||
666 | struct snd_pcm_hardware *hardware) | ||
667 | { | ||
668 | if (channel == PCM_MULTICH) { | ||
669 | hardware->rates = SNDRV_PCM_RATE_44100 | | ||
670 | SNDRV_PCM_RATE_48000 | | ||
671 | SNDRV_PCM_RATE_96000 | | ||
672 | SNDRV_PCM_RATE_192000; | ||
673 | hardware->rate_min = 44100; | ||
674 | } | ||
675 | } | ||
676 | |||
677 | static void set_pcm1796_params(struct oxygen *chip, | ||
678 | struct snd_pcm_hw_params *params) | ||
679 | { | ||
680 | struct xonar_data *data = chip->model_data; | ||
681 | unsigned int i; | ||
682 | |||
683 | data->pcm1796_oversampling = | ||
684 | params_rate(params) >= 96000 ? PCM1796_OS_32 : PCM1796_OS_64; | ||
685 | for (i = 0; i < data->dacs; ++i) | ||
686 | pcm1796_write(chip, i, 20, data->pcm1796_oversampling); | ||
687 | } | ||
688 | |||
689 | static void set_cs53x1_params(struct oxygen *chip, | ||
690 | struct snd_pcm_hw_params *params) | ||
691 | { | ||
692 | unsigned int value; | ||
693 | |||
694 | if (params_rate(params) <= 54000) | ||
695 | value = GPIO_CS53x1_M_SINGLE; | ||
696 | else if (params_rate(params) <= 108000) | ||
697 | value = GPIO_CS53x1_M_DOUBLE; | ||
698 | else | ||
699 | value = GPIO_CS53x1_M_QUAD; | ||
700 | oxygen_write16_masked(chip, OXYGEN_GPIO_DATA, | ||
701 | value, GPIO_CS53x1_M_MASK); | ||
702 | } | ||
703 | |||
704 | static void set_cs43xx_params(struct oxygen *chip, | ||
705 | struct snd_pcm_hw_params *params) | ||
706 | { | ||
707 | struct xonar_data *data = chip->model_data; | ||
708 | |||
709 | data->cs4398_fm = CS4398_DEM_NONE | CS4398_DIF_LJUST; | ||
710 | data->cs4362a_fm = CS4362A_ATAPI_B_R | CS4362A_ATAPI_A_L; | ||
711 | if (params_rate(params) <= 50000) { | ||
712 | data->cs4398_fm |= CS4398_FM_SINGLE; | ||
713 | data->cs4362a_fm |= CS4362A_FM_SINGLE; | ||
714 | } else if (params_rate(params) <= 100000) { | ||
715 | data->cs4398_fm |= CS4398_FM_DOUBLE; | ||
716 | data->cs4362a_fm |= CS4362A_FM_DOUBLE; | ||
717 | } else { | ||
718 | data->cs4398_fm |= CS4398_FM_QUAD; | ||
719 | data->cs4362a_fm |= CS4362A_FM_QUAD; | ||
720 | } | ||
721 | cs4398_write(chip, 2, data->cs4398_fm); | ||
722 | cs4362a_write(chip, 0x06, data->cs4362a_fm); | ||
723 | cs4362a_write(chip, 0x09, data->cs4362a_fm); | ||
724 | cs4362a_write(chip, 0x0c, data->cs4362a_fm); | ||
725 | } | ||
726 | |||
727 | static void set_hdmi_params(struct oxygen *chip, | ||
728 | struct snd_pcm_hw_params *params) | ||
729 | { | ||
730 | struct xonar_data *data = chip->model_data; | ||
731 | |||
732 | data->hdmi_params[0] = 0; /* 1 = non-audio */ | ||
733 | switch (params_rate(params)) { | ||
734 | case 44100: | ||
735 | data->hdmi_params[1] = IEC958_AES3_CON_FS_44100; | ||
736 | break; | ||
737 | case 48000: | ||
738 | data->hdmi_params[1] = IEC958_AES3_CON_FS_48000; | ||
739 | break; | ||
740 | default: /* 96000 */ | ||
741 | data->hdmi_params[1] = IEC958_AES3_CON_FS_96000; | ||
742 | break; | ||
743 | case 192000: | ||
744 | data->hdmi_params[1] = IEC958_AES3_CON_FS_192000; | ||
745 | break; | ||
746 | } | ||
747 | data->hdmi_params[2] = params_channels(params) / 2 - 1; | ||
748 | if (params_format(params) == SNDRV_PCM_FORMAT_S16_LE) | ||
749 | data->hdmi_params[3] = 0; | ||
750 | else | ||
751 | data->hdmi_params[3] = 0xc0; | ||
752 | data->hdmi_params[4] = 1; /* ? */ | ||
753 | hdmi_write_command(chip, 0x54, 5, data->hdmi_params); | ||
754 | } | ||
755 | |||
756 | static void set_hdav_params(struct oxygen *chip, | ||
757 | struct snd_pcm_hw_params *params) | ||
758 | { | ||
759 | set_pcm1796_params(chip, params); | ||
760 | set_hdmi_params(chip, params); | ||
761 | } | ||
762 | |||
763 | static void xonar_gpio_changed(struct oxygen *chip) | ||
764 | { | ||
765 | struct xonar_data *data = chip->model_data; | ||
766 | u8 has_power; | ||
767 | |||
768 | has_power = !!(oxygen_read8(chip, data->ext_power_reg) | ||
769 | & data->ext_power_bit); | ||
770 | if (has_power != data->has_power) { | ||
771 | data->has_power = has_power; | ||
772 | if (has_power) { | ||
773 | snd_printk(KERN_NOTICE "power restored\n"); | ||
774 | } else { | ||
775 | snd_printk(KERN_CRIT | ||
776 | "Hey! Don't unplug the power cable!\n"); | ||
777 | /* TODO: stop PCMs */ | ||
778 | } | ||
779 | } | ||
780 | } | ||
781 | |||
782 | static void xonar_hdav_uart_input(struct oxygen *chip) | ||
783 | { | ||
784 | if (chip->uart_input_count >= 2 && | ||
785 | chip->uart_input[chip->uart_input_count - 2] == 'O' && | ||
786 | chip->uart_input[chip->uart_input_count - 1] == 'K') { | ||
787 | printk(KERN_DEBUG "message from Xonar HDAV HDMI chip received:\n"); | ||
788 | print_hex_dump_bytes("", DUMP_PREFIX_OFFSET, | ||
789 | chip->uart_input, chip->uart_input_count); | ||
790 | chip->uart_input_count = 0; | ||
791 | } | ||
792 | } | ||
793 | |||
794 | static int gpio_bit_switch_get(struct snd_kcontrol *ctl, | ||
795 | struct snd_ctl_elem_value *value) | ||
796 | { | ||
797 | struct oxygen *chip = ctl->private_data; | ||
798 | u16 bit = ctl->private_value; | ||
799 | |||
800 | value->value.integer.value[0] = | ||
801 | !!(oxygen_read16(chip, OXYGEN_GPIO_DATA) & bit); | ||
802 | return 0; | ||
803 | } | ||
804 | |||
805 | static int gpio_bit_switch_put(struct snd_kcontrol *ctl, | ||
806 | struct snd_ctl_elem_value *value) | ||
807 | { | ||
808 | struct oxygen *chip = ctl->private_data; | ||
809 | u16 bit = ctl->private_value; | ||
810 | u16 old_bits, new_bits; | ||
811 | int changed; | ||
812 | |||
813 | spin_lock_irq(&chip->reg_lock); | ||
814 | old_bits = oxygen_read16(chip, OXYGEN_GPIO_DATA); | ||
815 | if (value->value.integer.value[0]) | ||
816 | new_bits = old_bits | bit; | ||
817 | else | ||
818 | new_bits = old_bits & ~bit; | ||
819 | changed = new_bits != old_bits; | ||
820 | if (changed) | ||
821 | oxygen_write16(chip, OXYGEN_GPIO_DATA, new_bits); | ||
822 | spin_unlock_irq(&chip->reg_lock); | ||
823 | return changed; | ||
824 | } | ||
825 | |||
826 | static const struct snd_kcontrol_new alt_switch = { | ||
827 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
828 | .name = "Analog Loopback Switch", | ||
829 | .info = snd_ctl_boolean_mono_info, | ||
830 | .get = gpio_bit_switch_get, | ||
831 | .put = gpio_bit_switch_put, | ||
832 | .private_value = GPIO_D2_ALT, | ||
833 | }; | ||
834 | |||
835 | static const struct snd_kcontrol_new front_panel_switch = { | ||
836 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
837 | .name = "Front Panel Switch", | ||
838 | .info = snd_ctl_boolean_mono_info, | ||
839 | .get = gpio_bit_switch_get, | ||
840 | .put = gpio_bit_switch_put, | ||
841 | .private_value = GPIO_DX_FRONT_PANEL, | ||
842 | }; | ||
843 | |||
844 | static int st_output_switch_info(struct snd_kcontrol *ctl, | ||
845 | struct snd_ctl_elem_info *info) | ||
846 | { | ||
847 | static const char *const names[3] = { | ||
848 | "Speakers", "Headphones", "FP Headphones" | ||
849 | }; | ||
850 | |||
851 | info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; | ||
852 | info->count = 1; | ||
853 | info->value.enumerated.items = 3; | ||
854 | if (info->value.enumerated.item >= 3) | ||
855 | info->value.enumerated.item = 2; | ||
856 | strcpy(info->value.enumerated.name, names[info->value.enumerated.item]); | ||
857 | return 0; | ||
858 | } | ||
859 | |||
860 | static int st_output_switch_get(struct snd_kcontrol *ctl, | ||
861 | struct snd_ctl_elem_value *value) | ||
862 | { | ||
863 | struct oxygen *chip = ctl->private_data; | ||
864 | u16 gpio; | ||
865 | |||
866 | gpio = oxygen_read16(chip, OXYGEN_GPIO_DATA); | ||
867 | if (!(gpio & GPIO_ST_HP)) | ||
868 | value->value.enumerated.item[0] = 0; | ||
869 | else if (gpio & GPIO_ST_HP_REAR) | ||
870 | value->value.enumerated.item[0] = 1; | ||
871 | else | ||
872 | value->value.enumerated.item[0] = 2; | ||
873 | return 0; | ||
874 | } | ||
875 | |||
876 | |||
877 | static int st_output_switch_put(struct snd_kcontrol *ctl, | ||
878 | struct snd_ctl_elem_value *value) | ||
879 | { | ||
880 | struct oxygen *chip = ctl->private_data; | ||
881 | u16 gpio_old, gpio; | ||
882 | |||
883 | mutex_lock(&chip->mutex); | ||
884 | gpio_old = oxygen_read16(chip, OXYGEN_GPIO_DATA); | ||
885 | gpio = gpio_old; | ||
886 | switch (value->value.enumerated.item[0]) { | ||
887 | case 0: | ||
888 | gpio &= ~(GPIO_ST_HP | GPIO_ST_HP_REAR); | ||
889 | break; | ||
890 | case 1: | ||
891 | gpio |= GPIO_ST_HP | GPIO_ST_HP_REAR; | ||
892 | break; | ||
893 | case 2: | ||
894 | gpio = (gpio | GPIO_ST_HP) & ~GPIO_ST_HP_REAR; | ||
895 | break; | ||
896 | } | ||
897 | oxygen_write16(chip, OXYGEN_GPIO_DATA, gpio); | ||
898 | mutex_unlock(&chip->mutex); | ||
899 | return gpio != gpio_old; | ||
900 | } | ||
901 | |||
902 | static const struct snd_kcontrol_new st_output_switch = { | ||
903 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
904 | .name = "Analog Output", | ||
905 | .info = st_output_switch_info, | ||
906 | .get = st_output_switch_get, | ||
907 | .put = st_output_switch_put, | ||
908 | }; | ||
909 | |||
910 | static void xonar_line_mic_ac97_switch(struct oxygen *chip, | ||
911 | unsigned int reg, unsigned int mute) | ||
912 | { | ||
913 | if (reg == AC97_LINE) { | ||
914 | spin_lock_irq(&chip->reg_lock); | ||
915 | oxygen_write16_masked(chip, OXYGEN_GPIO_DATA, | ||
916 | mute ? GPIO_DX_INPUT_ROUTE : 0, | ||
917 | GPIO_DX_INPUT_ROUTE); | ||
918 | spin_unlock_irq(&chip->reg_lock); | ||
919 | } | ||
920 | } | ||
921 | |||
922 | static const DECLARE_TLV_DB_SCALE(pcm1796_db_scale, -6000, 50, 0); | ||
923 | static const DECLARE_TLV_DB_SCALE(cs4362a_db_scale, -6000, 100, 0); | ||
924 | |||
925 | static int xonar_d2_control_filter(struct snd_kcontrol_new *template) | ||
926 | { | ||
927 | if (!strncmp(template->name, "CD Capture ", 11)) | ||
928 | /* CD in is actually connected to the video in pin */ | ||
929 | template->private_value ^= AC97_CD ^ AC97_VIDEO; | ||
930 | return 0; | ||
931 | } | ||
932 | |||
933 | static int xonar_d1_control_filter(struct snd_kcontrol_new *template) | ||
934 | { | ||
935 | if (!strncmp(template->name, "CD Capture ", 11)) | ||
936 | return 1; /* no CD input */ | ||
937 | return 0; | ||
938 | } | ||
939 | |||
940 | static int xonar_st_control_filter(struct snd_kcontrol_new *template) | ||
941 | { | ||
942 | if (!strncmp(template->name, "CD Capture ", 11)) | ||
943 | return 1; /* no CD input */ | ||
944 | if (!strcmp(template->name, "Stereo Upmixing")) | ||
945 | return 1; /* stereo only - we don't need upmixing */ | ||
946 | return 0; | ||
947 | } | ||
948 | |||
949 | static int xonar_d2_mixer_init(struct oxygen *chip) | ||
950 | { | ||
951 | return snd_ctl_add(chip->card, snd_ctl_new1(&alt_switch, chip)); | ||
952 | } | ||
953 | |||
954 | static int xonar_d1_mixer_init(struct oxygen *chip) | ||
955 | { | ||
956 | return snd_ctl_add(chip->card, snd_ctl_new1(&front_panel_switch, chip)); | ||
957 | } | ||
958 | |||
959 | static int xonar_st_mixer_init(struct oxygen *chip) | ||
960 | { | ||
961 | return snd_ctl_add(chip->card, snd_ctl_new1(&st_output_switch, chip)); | ||
962 | } | ||
963 | |||
964 | static const struct oxygen_model model_xonar_d2 = { | ||
965 | .longname = "Asus Virtuoso 200", | ||
966 | .chip = "AV200", | ||
967 | .init = xonar_d2_init, | ||
968 | .control_filter = xonar_d2_control_filter, | ||
969 | .mixer_init = xonar_d2_mixer_init, | ||
970 | .cleanup = xonar_d2_cleanup, | ||
971 | .suspend = xonar_d2_suspend, | ||
972 | .resume = xonar_d2_resume, | ||
973 | .set_dac_params = set_pcm1796_params, | ||
974 | .set_adc_params = set_cs53x1_params, | ||
975 | .update_dac_volume = update_pcm1796_volume, | ||
976 | .update_dac_mute = update_pcm1796_mute, | ||
977 | .dac_tlv = pcm1796_db_scale, | ||
978 | .model_data_size = sizeof(struct xonar_data), | ||
979 | .device_config = PLAYBACK_0_TO_I2S | | ||
980 | PLAYBACK_1_TO_SPDIF | | ||
981 | CAPTURE_0_FROM_I2S_2 | | ||
982 | CAPTURE_1_FROM_SPDIF | | ||
983 | MIDI_OUTPUT | | ||
984 | MIDI_INPUT, | ||
985 | .dac_channels = 8, | ||
986 | .dac_volume_min = 255 - 2*60, | ||
987 | .dac_volume_max = 255, | ||
988 | .misc_flags = OXYGEN_MISC_MIDI, | ||
989 | .function_flags = OXYGEN_FUNCTION_SPI | | ||
990 | OXYGEN_FUNCTION_ENABLE_SPI_4_5, | ||
991 | .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST, | ||
992 | .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST, | ||
993 | }; | ||
994 | |||
995 | static const struct oxygen_model model_xonar_d1 = { | ||
996 | .longname = "Asus Virtuoso 100", | ||
997 | .chip = "AV200", | ||
998 | .init = xonar_d1_init, | ||
999 | .control_filter = xonar_d1_control_filter, | ||
1000 | .mixer_init = xonar_d1_mixer_init, | ||
1001 | .cleanup = xonar_d1_cleanup, | ||
1002 | .suspend = xonar_d1_suspend, | ||
1003 | .resume = xonar_d1_resume, | ||
1004 | .set_dac_params = set_cs43xx_params, | ||
1005 | .set_adc_params = set_cs53x1_params, | ||
1006 | .update_dac_volume = update_cs43xx_volume, | ||
1007 | .update_dac_mute = update_cs43xx_mute, | ||
1008 | .ac97_switch = xonar_line_mic_ac97_switch, | ||
1009 | .dac_tlv = cs4362a_db_scale, | ||
1010 | .model_data_size = sizeof(struct xonar_data), | ||
1011 | .device_config = PLAYBACK_0_TO_I2S | | ||
1012 | PLAYBACK_1_TO_SPDIF | | ||
1013 | CAPTURE_0_FROM_I2S_2, | ||
1014 | .dac_channels = 8, | ||
1015 | .dac_volume_min = 127 - 60, | ||
1016 | .dac_volume_max = 127, | ||
1017 | .function_flags = OXYGEN_FUNCTION_2WIRE, | ||
1018 | .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST, | ||
1019 | .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST, | ||
1020 | }; | ||
1021 | |||
1022 | static const struct oxygen_model model_xonar_hdav = { | ||
1023 | .longname = "Asus Virtuoso 200", | ||
1024 | .chip = "AV200", | ||
1025 | .init = xonar_hdav_init, | ||
1026 | .cleanup = xonar_hdav_cleanup, | ||
1027 | .suspend = xonar_hdav_suspend, | ||
1028 | .resume = xonar_hdav_resume, | ||
1029 | .pcm_hardware_filter = xonar_hdav_pcm_hardware_filter, | ||
1030 | .set_dac_params = set_hdav_params, | ||
1031 | .set_adc_params = set_cs53x1_params, | ||
1032 | .update_dac_volume = update_pcm1796_volume, | ||
1033 | .update_dac_mute = update_pcm1796_mute, | ||
1034 | .uart_input = xonar_hdav_uart_input, | ||
1035 | .ac97_switch = xonar_line_mic_ac97_switch, | ||
1036 | .dac_tlv = pcm1796_db_scale, | ||
1037 | .model_data_size = sizeof(struct xonar_data), | ||
1038 | .device_config = PLAYBACK_0_TO_I2S | | ||
1039 | PLAYBACK_1_TO_SPDIF | | ||
1040 | CAPTURE_0_FROM_I2S_2 | | ||
1041 | CAPTURE_1_FROM_SPDIF, | ||
1042 | .dac_channels = 8, | ||
1043 | .dac_volume_min = 255 - 2*60, | ||
1044 | .dac_volume_max = 255, | ||
1045 | .misc_flags = OXYGEN_MISC_MIDI, | ||
1046 | .function_flags = OXYGEN_FUNCTION_2WIRE, | ||
1047 | .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST, | ||
1048 | .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST, | ||
1049 | }; | ||
1050 | |||
1051 | static const struct oxygen_model model_xonar_st = { | ||
1052 | .longname = "Asus Virtuoso 100", | ||
1053 | .chip = "AV200", | ||
1054 | .init = xonar_st_init, | ||
1055 | .control_filter = xonar_st_control_filter, | ||
1056 | .mixer_init = xonar_st_mixer_init, | ||
1057 | .cleanup = xonar_st_cleanup, | ||
1058 | .suspend = xonar_st_suspend, | ||
1059 | .resume = xonar_st_resume, | ||
1060 | .set_dac_params = set_pcm1796_params, | ||
1061 | .set_adc_params = set_cs53x1_params, | ||
1062 | .update_dac_volume = update_pcm1796_volume, | ||
1063 | .update_dac_mute = update_pcm1796_mute, | ||
1064 | .ac97_switch = xonar_line_mic_ac97_switch, | ||
1065 | .dac_tlv = pcm1796_db_scale, | ||
1066 | .model_data_size = sizeof(struct xonar_data), | ||
1067 | .device_config = PLAYBACK_0_TO_I2S | | ||
1068 | PLAYBACK_1_TO_SPDIF | | ||
1069 | CAPTURE_0_FROM_I2S_2, | ||
1070 | .dac_channels = 2, | ||
1071 | .dac_volume_min = 255 - 2*60, | ||
1072 | .dac_volume_max = 255, | ||
1073 | .function_flags = OXYGEN_FUNCTION_2WIRE, | ||
1074 | .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST, | ||
1075 | .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST, | ||
1076 | }; | ||
1077 | |||
1078 | static int __devinit get_xonar_model(struct oxygen *chip, | 57 | static int __devinit get_xonar_model(struct oxygen *chip, |
1079 | const struct pci_device_id *id) | 58 | const struct pci_device_id *id) |
1080 | { | 59 | { |
1081 | static const struct oxygen_model *const models[] = { | 60 | if (get_xonar_pcm179x_model(chip, id) >= 0) |
1082 | [MODEL_D1] = &model_xonar_d1, | 61 | return 0; |
1083 | [MODEL_DX] = &model_xonar_d1, | 62 | if (get_xonar_cs43xx_model(chip, id) >= 0) |
1084 | [MODEL_D2] = &model_xonar_d2, | 63 | return 0; |
1085 | [MODEL_D2X] = &model_xonar_d2, | 64 | return -EINVAL; |
1086 | [MODEL_HDAV] = &model_xonar_hdav, | ||
1087 | [MODEL_ST] = &model_xonar_st, | ||
1088 | [MODEL_STX] = &model_xonar_st, | ||
1089 | }; | ||
1090 | static const char *const names[] = { | ||
1091 | [MODEL_D1] = "Xonar D1", | ||
1092 | [MODEL_DX] = "Xonar DX", | ||
1093 | [MODEL_D2] = "Xonar D2", | ||
1094 | [MODEL_D2X] = "Xonar D2X", | ||
1095 | [MODEL_HDAV] = "Xonar HDAV1.3", | ||
1096 | [MODEL_HDAV_H6] = "Xonar HDAV1.3+H6", | ||
1097 | [MODEL_ST] = "Xonar Essence ST", | ||
1098 | [MODEL_ST_H6] = "Xonar Essence ST+H6", | ||
1099 | [MODEL_STX] = "Xonar Essence STX", | ||
1100 | }; | ||
1101 | unsigned int model = id->driver_data; | ||
1102 | |||
1103 | if (model >= ARRAY_SIZE(models) || !models[model]) | ||
1104 | return -EINVAL; | ||
1105 | chip->model = *models[model]; | ||
1106 | |||
1107 | switch (model) { | ||
1108 | case MODEL_D2X: | ||
1109 | chip->model.init = xonar_d2x_init; | ||
1110 | break; | ||
1111 | case MODEL_DX: | ||
1112 | chip->model.init = xonar_dx_init; | ||
1113 | break; | ||
1114 | case MODEL_HDAV: | ||
1115 | oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK); | ||
1116 | switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) & GPIO_DB_MASK) { | ||
1117 | case GPIO_DB_H6: | ||
1118 | model = MODEL_HDAV_H6; | ||
1119 | break; | ||
1120 | case GPIO_DB_XX: | ||
1121 | snd_printk(KERN_ERR "unknown daughterboard\n"); | ||
1122 | return -ENODEV; | ||
1123 | } | ||
1124 | break; | ||
1125 | case MODEL_ST: | ||
1126 | oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK); | ||
1127 | switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) & GPIO_DB_MASK) { | ||
1128 | case GPIO_DB_H6: | ||
1129 | model = MODEL_ST_H6; | ||
1130 | break; | ||
1131 | } | ||
1132 | break; | ||
1133 | case MODEL_STX: | ||
1134 | chip->model.init = xonar_stx_init; | ||
1135 | oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK); | ||
1136 | break; | ||
1137 | } | ||
1138 | |||
1139 | chip->model.shortname = names[model]; | ||
1140 | chip->model.private_data = model; | ||
1141 | return 0; | ||
1142 | } | 65 | } |
1143 | 66 | ||
1144 | static int __devinit xonar_probe(struct pci_dev *pci, | 67 | static int __devinit xonar_probe(struct pci_dev *pci, |
diff --git a/sound/pci/oxygen/xonar.h b/sound/pci/oxygen/xonar.h new file mode 100644 index 000000000000..89b3ed814d64 --- /dev/null +++ b/sound/pci/oxygen/xonar.h | |||
@@ -0,0 +1,50 @@ | |||
1 | #ifndef XONAR_H_INCLUDED | ||
2 | #define XONAR_H_INCLUDED | ||
3 | |||
4 | #include "oxygen.h" | ||
5 | |||
6 | struct xonar_generic { | ||
7 | unsigned int anti_pop_delay; | ||
8 | u16 output_enable_bit; | ||
9 | u8 ext_power_reg; | ||
10 | u8 ext_power_int_reg; | ||
11 | u8 ext_power_bit; | ||
12 | u8 has_power; | ||
13 | }; | ||
14 | |||
15 | struct xonar_hdmi { | ||
16 | u8 params[5]; | ||
17 | }; | ||
18 | |||
19 | /* generic helper functions */ | ||
20 | |||
21 | void xonar_enable_output(struct oxygen *chip); | ||
22 | void xonar_disable_output(struct oxygen *chip); | ||
23 | void xonar_init_ext_power(struct oxygen *chip); | ||
24 | void xonar_init_cs53x1(struct oxygen *chip); | ||
25 | void xonar_set_cs53x1_params(struct oxygen *chip, | ||
26 | struct snd_pcm_hw_params *params); | ||
27 | int xonar_gpio_bit_switch_get(struct snd_kcontrol *ctl, | ||
28 | struct snd_ctl_elem_value *value); | ||
29 | int xonar_gpio_bit_switch_put(struct snd_kcontrol *ctl, | ||
30 | struct snd_ctl_elem_value *value); | ||
31 | |||
32 | /* model-specific card drivers */ | ||
33 | |||
34 | int get_xonar_pcm179x_model(struct oxygen *chip, | ||
35 | const struct pci_device_id *id); | ||
36 | int get_xonar_cs43xx_model(struct oxygen *chip, | ||
37 | const struct pci_device_id *id); | ||
38 | |||
39 | /* HDMI helper functions */ | ||
40 | |||
41 | void xonar_hdmi_init(struct oxygen *chip, struct xonar_hdmi *data); | ||
42 | void xonar_hdmi_cleanup(struct oxygen *chip); | ||
43 | void xonar_hdmi_resume(struct oxygen *chip, struct xonar_hdmi *hdmi); | ||
44 | void xonar_hdmi_pcm_hardware_filter(unsigned int channel, | ||
45 | struct snd_pcm_hardware *hardware); | ||
46 | void xonar_set_hdmi_params(struct oxygen *chip, struct xonar_hdmi *hdmi, | ||
47 | struct snd_pcm_hw_params *params); | ||
48 | void xonar_hdmi_uart_input(struct oxygen *chip); | ||
49 | |||
50 | #endif | ||
diff --git a/sound/pci/oxygen/xonar_cs43xx.c b/sound/pci/oxygen/xonar_cs43xx.c new file mode 100644 index 000000000000..16c226bfcd2b --- /dev/null +++ b/sound/pci/oxygen/xonar_cs43xx.c | |||
@@ -0,0 +1,434 @@ | |||
1 | /* | ||
2 | * card driver for models with CS4398/CS4362A DACs (Xonar D1/DX) | ||
3 | * | ||
4 | * Copyright (c) Clemens Ladisch <clemens@ladisch.de> | ||
5 | * | ||
6 | * | ||
7 | * This driver is free software; you can redistribute it and/or modify | ||
8 | * it under the terms of the GNU General Public License, version 2. | ||
9 | * | ||
10 | * This driver is distributed in the hope that it will be useful, | ||
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
13 | * GNU General Public License for more details. | ||
14 | * | ||
15 | * You should have received a copy of the GNU General Public License | ||
16 | * along with this driver; if not, see <http://www.gnu.org/licenses/>. | ||
17 | */ | ||
18 | |||
19 | /* | ||
20 | * Xonar D1/DX | ||
21 | * ----------- | ||
22 | * | ||
23 | * CMI8788: | ||
24 | * | ||
25 | * I²C <-> CS4398 (front) | ||
26 | * <-> CS4362A (surround, center/LFE, back) | ||
27 | * | ||
28 | * GPI 0 <- external power present (DX only) | ||
29 | * | ||
30 | * GPIO 0 -> enable output to speakers | ||
31 | * GPIO 1 -> enable front panel I/O | ||
32 | * GPIO 2 -> M0 of CS5361 | ||
33 | * GPIO 3 -> M1 of CS5361 | ||
34 | * GPIO 8 -> route input jack to line-in (0) or mic-in (1) | ||
35 | * | ||
36 | * CS4398: | ||
37 | * | ||
38 | * AD0 <- 1 | ||
39 | * AD1 <- 1 | ||
40 | * | ||
41 | * CS4362A: | ||
42 | * | ||
43 | * AD0 <- 0 | ||
44 | * | ||
45 | * CM9780: | ||
46 | * | ||
47 | * GPO 0 -> route line-in (0) or AC97 output (1) to CS5361 input | ||
48 | */ | ||
49 | |||
50 | #include <linux/pci.h> | ||
51 | #include <linux/delay.h> | ||
52 | #include <sound/ac97_codec.h> | ||
53 | #include <sound/control.h> | ||
54 | #include <sound/core.h> | ||
55 | #include <sound/pcm.h> | ||
56 | #include <sound/pcm_params.h> | ||
57 | #include <sound/tlv.h> | ||
58 | #include "xonar.h" | ||
59 | #include "cs4398.h" | ||
60 | #include "cs4362a.h" | ||
61 | |||
62 | #define GPI_EXT_POWER 0x01 | ||
63 | #define GPIO_D1_OUTPUT_ENABLE 0x0001 | ||
64 | #define GPIO_D1_FRONT_PANEL 0x0002 | ||
65 | #define GPIO_D1_INPUT_ROUTE 0x0100 | ||
66 | |||
67 | #define I2C_DEVICE_CS4398 0x9e /* 10011, AD1=1, AD0=1, /W=0 */ | ||
68 | #define I2C_DEVICE_CS4362A 0x30 /* 001100, AD0=0, /W=0 */ | ||
69 | |||
70 | struct xonar_cs43xx { | ||
71 | struct xonar_generic generic; | ||
72 | u8 cs4398_regs[8]; | ||
73 | u8 cs4362a_regs[15]; | ||
74 | }; | ||
75 | |||
76 | static void cs4398_write(struct oxygen *chip, u8 reg, u8 value) | ||
77 | { | ||
78 | struct xonar_cs43xx *data = chip->model_data; | ||
79 | |||
80 | oxygen_write_i2c(chip, I2C_DEVICE_CS4398, reg, value); | ||
81 | if (reg < ARRAY_SIZE(data->cs4398_regs)) | ||
82 | data->cs4398_regs[reg] = value; | ||
83 | } | ||
84 | |||
85 | static void cs4398_write_cached(struct oxygen *chip, u8 reg, u8 value) | ||
86 | { | ||
87 | struct xonar_cs43xx *data = chip->model_data; | ||
88 | |||
89 | if (value != data->cs4398_regs[reg]) | ||
90 | cs4398_write(chip, reg, value); | ||
91 | } | ||
92 | |||
93 | static void cs4362a_write(struct oxygen *chip, u8 reg, u8 value) | ||
94 | { | ||
95 | struct xonar_cs43xx *data = chip->model_data; | ||
96 | |||
97 | oxygen_write_i2c(chip, I2C_DEVICE_CS4362A, reg, value); | ||
98 | if (reg < ARRAY_SIZE(data->cs4362a_regs)) | ||
99 | data->cs4362a_regs[reg] = value; | ||
100 | } | ||
101 | |||
102 | static void cs4362a_write_cached(struct oxygen *chip, u8 reg, u8 value) | ||
103 | { | ||
104 | struct xonar_cs43xx *data = chip->model_data; | ||
105 | |||
106 | if (value != data->cs4362a_regs[reg]) | ||
107 | cs4362a_write(chip, reg, value); | ||
108 | } | ||
109 | |||
110 | static void cs43xx_registers_init(struct oxygen *chip) | ||
111 | { | ||
112 | struct xonar_cs43xx *data = chip->model_data; | ||
113 | unsigned int i; | ||
114 | |||
115 | /* set CPEN (control port mode) and power down */ | ||
116 | cs4398_write(chip, 8, CS4398_CPEN | CS4398_PDN); | ||
117 | cs4362a_write(chip, 0x01, CS4362A_PDN | CS4362A_CPEN); | ||
118 | /* configure */ | ||
119 | cs4398_write(chip, 2, data->cs4398_regs[2]); | ||
120 | cs4398_write(chip, 3, CS4398_ATAPI_B_R | CS4398_ATAPI_A_L); | ||
121 | cs4398_write(chip, 4, data->cs4398_regs[4]); | ||
122 | cs4398_write(chip, 5, data->cs4398_regs[5]); | ||
123 | cs4398_write(chip, 6, data->cs4398_regs[6]); | ||
124 | cs4398_write(chip, 7, data->cs4398_regs[7]); | ||
125 | cs4362a_write(chip, 0x02, CS4362A_DIF_LJUST); | ||
126 | cs4362a_write(chip, 0x03, CS4362A_MUTEC_6 | CS4362A_AMUTE | | ||
127 | CS4362A_RMP_UP | CS4362A_ZERO_CROSS | CS4362A_SOFT_RAMP); | ||
128 | cs4362a_write(chip, 0x04, data->cs4362a_regs[0x04]); | ||
129 | cs4362a_write(chip, 0x05, 0); | ||
130 | for (i = 6; i <= 14; ++i) | ||
131 | cs4362a_write(chip, i, data->cs4362a_regs[i]); | ||
132 | /* clear power down */ | ||
133 | cs4398_write(chip, 8, CS4398_CPEN); | ||
134 | cs4362a_write(chip, 0x01, CS4362A_CPEN); | ||
135 | } | ||
136 | |||
137 | static void xonar_d1_init(struct oxygen *chip) | ||
138 | { | ||
139 | struct xonar_cs43xx *data = chip->model_data; | ||
140 | |||
141 | data->generic.anti_pop_delay = 800; | ||
142 | data->generic.output_enable_bit = GPIO_D1_OUTPUT_ENABLE; | ||
143 | data->cs4398_regs[2] = | ||
144 | CS4398_FM_SINGLE | CS4398_DEM_NONE | CS4398_DIF_LJUST; | ||
145 | data->cs4398_regs[4] = CS4398_MUTEP_LOW | | ||
146 | CS4398_MUTE_B | CS4398_MUTE_A | CS4398_PAMUTE; | ||
147 | data->cs4398_regs[5] = 60 * 2; | ||
148 | data->cs4398_regs[6] = 60 * 2; | ||
149 | data->cs4398_regs[7] = CS4398_RMP_DN | CS4398_RMP_UP | | ||
150 | CS4398_ZERO_CROSS | CS4398_SOFT_RAMP; | ||
151 | data->cs4362a_regs[4] = CS4362A_RMP_DN | CS4362A_DEM_NONE; | ||
152 | data->cs4362a_regs[6] = CS4362A_FM_SINGLE | | ||
153 | CS4362A_ATAPI_B_R | CS4362A_ATAPI_A_L; | ||
154 | data->cs4362a_regs[7] = 60 | CS4362A_MUTE; | ||
155 | data->cs4362a_regs[8] = 60 | CS4362A_MUTE; | ||
156 | data->cs4362a_regs[9] = data->cs4362a_regs[6]; | ||
157 | data->cs4362a_regs[10] = 60 | CS4362A_MUTE; | ||
158 | data->cs4362a_regs[11] = 60 | CS4362A_MUTE; | ||
159 | data->cs4362a_regs[12] = data->cs4362a_regs[6]; | ||
160 | data->cs4362a_regs[13] = 60 | CS4362A_MUTE; | ||
161 | data->cs4362a_regs[14] = 60 | CS4362A_MUTE; | ||
162 | |||
163 | oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS, | ||
164 | OXYGEN_2WIRE_LENGTH_8 | | ||
165 | OXYGEN_2WIRE_INTERRUPT_MASK | | ||
166 | OXYGEN_2WIRE_SPEED_FAST); | ||
167 | |||
168 | cs43xx_registers_init(chip); | ||
169 | |||
170 | oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, | ||
171 | GPIO_D1_FRONT_PANEL | GPIO_D1_INPUT_ROUTE); | ||
172 | oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, | ||
173 | GPIO_D1_FRONT_PANEL | GPIO_D1_INPUT_ROUTE); | ||
174 | |||
175 | xonar_init_cs53x1(chip); | ||
176 | xonar_enable_output(chip); | ||
177 | |||
178 | snd_component_add(chip->card, "CS4398"); | ||
179 | snd_component_add(chip->card, "CS4362A"); | ||
180 | snd_component_add(chip->card, "CS5361"); | ||
181 | } | ||
182 | |||
183 | static void xonar_dx_init(struct oxygen *chip) | ||
184 | { | ||
185 | struct xonar_cs43xx *data = chip->model_data; | ||
186 | |||
187 | data->generic.ext_power_reg = OXYGEN_GPI_DATA; | ||
188 | data->generic.ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK; | ||
189 | data->generic.ext_power_bit = GPI_EXT_POWER; | ||
190 | xonar_init_ext_power(chip); | ||
191 | xonar_d1_init(chip); | ||
192 | } | ||
193 | |||
194 | static void xonar_d1_cleanup(struct oxygen *chip) | ||
195 | { | ||
196 | xonar_disable_output(chip); | ||
197 | cs4362a_write(chip, 0x01, CS4362A_PDN | CS4362A_CPEN); | ||
198 | oxygen_clear_bits8(chip, OXYGEN_FUNCTION, OXYGEN_FUNCTION_RESET_CODEC); | ||
199 | } | ||
200 | |||
201 | static void xonar_d1_suspend(struct oxygen *chip) | ||
202 | { | ||
203 | xonar_d1_cleanup(chip); | ||
204 | } | ||
205 | |||
206 | static void xonar_d1_resume(struct oxygen *chip) | ||
207 | { | ||
208 | oxygen_set_bits8(chip, OXYGEN_FUNCTION, OXYGEN_FUNCTION_RESET_CODEC); | ||
209 | msleep(1); | ||
210 | cs43xx_registers_init(chip); | ||
211 | xonar_enable_output(chip); | ||
212 | } | ||
213 | |||
214 | static void set_cs43xx_params(struct oxygen *chip, | ||
215 | struct snd_pcm_hw_params *params) | ||
216 | { | ||
217 | struct xonar_cs43xx *data = chip->model_data; | ||
218 | u8 cs4398_fm, cs4362a_fm; | ||
219 | |||
220 | if (params_rate(params) <= 50000) { | ||
221 | cs4398_fm = CS4398_FM_SINGLE; | ||
222 | cs4362a_fm = CS4362A_FM_SINGLE; | ||
223 | } else if (params_rate(params) <= 100000) { | ||
224 | cs4398_fm = CS4398_FM_DOUBLE; | ||
225 | cs4362a_fm = CS4362A_FM_DOUBLE; | ||
226 | } else { | ||
227 | cs4398_fm = CS4398_FM_QUAD; | ||
228 | cs4362a_fm = CS4362A_FM_QUAD; | ||
229 | } | ||
230 | cs4398_fm |= CS4398_DEM_NONE | CS4398_DIF_LJUST; | ||
231 | cs4398_write_cached(chip, 2, cs4398_fm); | ||
232 | cs4362a_fm |= data->cs4362a_regs[6] & ~CS4362A_FM_MASK; | ||
233 | cs4362a_write_cached(chip, 6, cs4362a_fm); | ||
234 | cs4362a_write_cached(chip, 12, cs4362a_fm); | ||
235 | cs4362a_fm &= CS4362A_FM_MASK; | ||
236 | cs4362a_fm |= data->cs4362a_regs[9] & ~CS4362A_FM_MASK; | ||
237 | cs4362a_write_cached(chip, 9, cs4362a_fm); | ||
238 | } | ||
239 | |||
240 | static void update_cs4362a_volumes(struct oxygen *chip) | ||
241 | { | ||
242 | unsigned int i; | ||
243 | u8 mute; | ||
244 | |||
245 | mute = chip->dac_mute ? CS4362A_MUTE : 0; | ||
246 | for (i = 0; i < 6; ++i) | ||
247 | cs4362a_write_cached(chip, 7 + i + i / 2, | ||
248 | (127 - chip->dac_volume[2 + i]) | mute); | ||
249 | } | ||
250 | |||
251 | static void update_cs43xx_volume(struct oxygen *chip) | ||
252 | { | ||
253 | cs4398_write_cached(chip, 5, (127 - chip->dac_volume[0]) * 2); | ||
254 | cs4398_write_cached(chip, 6, (127 - chip->dac_volume[1]) * 2); | ||
255 | update_cs4362a_volumes(chip); | ||
256 | } | ||
257 | |||
258 | static void update_cs43xx_mute(struct oxygen *chip) | ||
259 | { | ||
260 | u8 reg; | ||
261 | |||
262 | reg = CS4398_MUTEP_LOW | CS4398_PAMUTE; | ||
263 | if (chip->dac_mute) | ||
264 | reg |= CS4398_MUTE_B | CS4398_MUTE_A; | ||
265 | cs4398_write_cached(chip, 4, reg); | ||
266 | update_cs4362a_volumes(chip); | ||
267 | } | ||
268 | |||
269 | static void update_cs43xx_center_lfe_mix(struct oxygen *chip, bool mixed) | ||
270 | { | ||
271 | struct xonar_cs43xx *data = chip->model_data; | ||
272 | u8 reg; | ||
273 | |||
274 | reg = data->cs4362a_regs[9] & ~CS4362A_ATAPI_MASK; | ||
275 | if (mixed) | ||
276 | reg |= CS4362A_ATAPI_B_LR | CS4362A_ATAPI_A_LR; | ||
277 | else | ||
278 | reg |= CS4362A_ATAPI_B_R | CS4362A_ATAPI_A_L; | ||
279 | cs4362a_write_cached(chip, 9, reg); | ||
280 | } | ||
281 | |||
282 | static const struct snd_kcontrol_new front_panel_switch = { | ||
283 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
284 | .name = "Front Panel Switch", | ||
285 | .info = snd_ctl_boolean_mono_info, | ||
286 | .get = xonar_gpio_bit_switch_get, | ||
287 | .put = xonar_gpio_bit_switch_put, | ||
288 | .private_value = GPIO_D1_FRONT_PANEL, | ||
289 | }; | ||
290 | |||
291 | static int rolloff_info(struct snd_kcontrol *ctl, | ||
292 | struct snd_ctl_elem_info *info) | ||
293 | { | ||
294 | static const char *const names[2] = { | ||
295 | "Fast Roll-off", "Slow Roll-off" | ||
296 | }; | ||
297 | |||
298 | info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; | ||
299 | info->count = 1; | ||
300 | info->value.enumerated.items = 2; | ||
301 | if (info->value.enumerated.item >= 2) | ||
302 | info->value.enumerated.item = 1; | ||
303 | strcpy(info->value.enumerated.name, names[info->value.enumerated.item]); | ||
304 | return 0; | ||
305 | } | ||
306 | |||
307 | static int rolloff_get(struct snd_kcontrol *ctl, | ||
308 | struct snd_ctl_elem_value *value) | ||
309 | { | ||
310 | struct oxygen *chip = ctl->private_data; | ||
311 | struct xonar_cs43xx *data = chip->model_data; | ||
312 | |||
313 | value->value.enumerated.item[0] = | ||
314 | (data->cs4398_regs[7] & CS4398_FILT_SEL) != 0; | ||
315 | return 0; | ||
316 | } | ||
317 | |||
318 | static int rolloff_put(struct snd_kcontrol *ctl, | ||
319 | struct snd_ctl_elem_value *value) | ||
320 | { | ||
321 | struct oxygen *chip = ctl->private_data; | ||
322 | struct xonar_cs43xx *data = chip->model_data; | ||
323 | int changed; | ||
324 | u8 reg; | ||
325 | |||
326 | mutex_lock(&chip->mutex); | ||
327 | reg = data->cs4398_regs[7]; | ||
328 | if (value->value.enumerated.item[0]) | ||
329 | reg |= CS4398_FILT_SEL; | ||
330 | else | ||
331 | reg &= ~CS4398_FILT_SEL; | ||
332 | changed = reg != data->cs4398_regs[7]; | ||
333 | if (changed) { | ||
334 | cs4398_write(chip, 7, reg); | ||
335 | if (reg & CS4398_FILT_SEL) | ||
336 | reg = data->cs4362a_regs[0x04] | CS4362A_FILT_SEL; | ||
337 | else | ||
338 | reg = data->cs4362a_regs[0x04] & ~CS4362A_FILT_SEL; | ||
339 | cs4362a_write(chip, 0x04, reg); | ||
340 | } | ||
341 | mutex_unlock(&chip->mutex); | ||
342 | return changed; | ||
343 | } | ||
344 | |||
345 | static const struct snd_kcontrol_new rolloff_control = { | ||
346 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
347 | .name = "DAC Filter Playback Enum", | ||
348 | .info = rolloff_info, | ||
349 | .get = rolloff_get, | ||
350 | .put = rolloff_put, | ||
351 | }; | ||
352 | |||
353 | static void xonar_d1_line_mic_ac97_switch(struct oxygen *chip, | ||
354 | unsigned int reg, unsigned int mute) | ||
355 | { | ||
356 | if (reg == AC97_LINE) { | ||
357 | spin_lock_irq(&chip->reg_lock); | ||
358 | oxygen_write16_masked(chip, OXYGEN_GPIO_DATA, | ||
359 | mute ? GPIO_D1_INPUT_ROUTE : 0, | ||
360 | GPIO_D1_INPUT_ROUTE); | ||
361 | spin_unlock_irq(&chip->reg_lock); | ||
362 | } | ||
363 | } | ||
364 | |||
365 | static const DECLARE_TLV_DB_SCALE(cs4362a_db_scale, -6000, 100, 0); | ||
366 | |||
367 | static int xonar_d1_control_filter(struct snd_kcontrol_new *template) | ||
368 | { | ||
369 | if (!strncmp(template->name, "CD Capture ", 11)) | ||
370 | return 1; /* no CD input */ | ||
371 | return 0; | ||
372 | } | ||
373 | |||
374 | static int xonar_d1_mixer_init(struct oxygen *chip) | ||
375 | { | ||
376 | int err; | ||
377 | |||
378 | err = snd_ctl_add(chip->card, snd_ctl_new1(&front_panel_switch, chip)); | ||
379 | if (err < 0) | ||
380 | return err; | ||
381 | err = snd_ctl_add(chip->card, snd_ctl_new1(&rolloff_control, chip)); | ||
382 | if (err < 0) | ||
383 | return err; | ||
384 | return 0; | ||
385 | } | ||
386 | |||
387 | static const struct oxygen_model model_xonar_d1 = { | ||
388 | .longname = "Asus Virtuoso 100", | ||
389 | .chip = "AV200", | ||
390 | .init = xonar_d1_init, | ||
391 | .control_filter = xonar_d1_control_filter, | ||
392 | .mixer_init = xonar_d1_mixer_init, | ||
393 | .cleanup = xonar_d1_cleanup, | ||
394 | .suspend = xonar_d1_suspend, | ||
395 | .resume = xonar_d1_resume, | ||
396 | .get_i2s_mclk = oxygen_default_i2s_mclk, | ||
397 | .set_dac_params = set_cs43xx_params, | ||
398 | .set_adc_params = xonar_set_cs53x1_params, | ||
399 | .update_dac_volume = update_cs43xx_volume, | ||
400 | .update_dac_mute = update_cs43xx_mute, | ||
401 | .update_center_lfe_mix = update_cs43xx_center_lfe_mix, | ||
402 | .ac97_switch = xonar_d1_line_mic_ac97_switch, | ||
403 | .dac_tlv = cs4362a_db_scale, | ||
404 | .model_data_size = sizeof(struct xonar_cs43xx), | ||
405 | .device_config = PLAYBACK_0_TO_I2S | | ||
406 | PLAYBACK_1_TO_SPDIF | | ||
407 | CAPTURE_0_FROM_I2S_2, | ||
408 | .dac_channels = 8, | ||
409 | .dac_volume_min = 127 - 60, | ||
410 | .dac_volume_max = 127, | ||
411 | .function_flags = OXYGEN_FUNCTION_2WIRE, | ||
412 | .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST, | ||
413 | .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST, | ||
414 | }; | ||
415 | |||
416 | int __devinit get_xonar_cs43xx_model(struct oxygen *chip, | ||
417 | const struct pci_device_id *id) | ||
418 | { | ||
419 | switch (id->subdevice) { | ||
420 | case 0x834f: | ||
421 | chip->model = model_xonar_d1; | ||
422 | chip->model.shortname = "Xonar D1"; | ||
423 | break; | ||
424 | case 0x8275: | ||
425 | case 0x8327: | ||
426 | chip->model = model_xonar_d1; | ||
427 | chip->model.shortname = "Xonar DX"; | ||
428 | chip->model.init = xonar_dx_init; | ||
429 | break; | ||
430 | default: | ||
431 | return -EINVAL; | ||
432 | } | ||
433 | return 0; | ||
434 | } | ||
diff --git a/sound/pci/oxygen/xonar_hdmi.c b/sound/pci/oxygen/xonar_hdmi.c new file mode 100644 index 000000000000..b12db1f1cea9 --- /dev/null +++ b/sound/pci/oxygen/xonar_hdmi.c | |||
@@ -0,0 +1,128 @@ | |||
1 | /* | ||
2 | * helper functions for HDMI models (Xonar HDAV1.3) | ||
3 | * | ||
4 | * Copyright (c) Clemens Ladisch <clemens@ladisch.de> | ||
5 | * | ||
6 | * | ||
7 | * This driver is free software; you can redistribute it and/or modify | ||
8 | * it under the terms of the GNU General Public License, version 2. | ||
9 | * | ||
10 | * This driver is distributed in the hope that it will be useful, | ||
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
13 | * GNU General Public License for more details. | ||
14 | * | ||
15 | * You should have received a copy of the GNU General Public License | ||
16 | * along with this driver; if not, see <http://www.gnu.org/licenses/>. | ||
17 | */ | ||
18 | |||
19 | #include <linux/pci.h> | ||
20 | #include <linux/delay.h> | ||
21 | #include <sound/asoundef.h> | ||
22 | #include <sound/control.h> | ||
23 | #include <sound/core.h> | ||
24 | #include <sound/pcm.h> | ||
25 | #include <sound/pcm_params.h> | ||
26 | #include <sound/tlv.h> | ||
27 | #include "xonar.h" | ||
28 | |||
29 | static void hdmi_write_command(struct oxygen *chip, u8 command, | ||
30 | unsigned int count, const u8 *params) | ||
31 | { | ||
32 | unsigned int i; | ||
33 | u8 checksum; | ||
34 | |||
35 | oxygen_write_uart(chip, 0xfb); | ||
36 | oxygen_write_uart(chip, 0xef); | ||
37 | oxygen_write_uart(chip, command); | ||
38 | oxygen_write_uart(chip, count); | ||
39 | for (i = 0; i < count; ++i) | ||
40 | oxygen_write_uart(chip, params[i]); | ||
41 | checksum = 0xfb + 0xef + command + count; | ||
42 | for (i = 0; i < count; ++i) | ||
43 | checksum += params[i]; | ||
44 | oxygen_write_uart(chip, checksum); | ||
45 | } | ||
46 | |||
47 | static void xonar_hdmi_init_commands(struct oxygen *chip, | ||
48 | struct xonar_hdmi *hdmi) | ||
49 | { | ||
50 | u8 param; | ||
51 | |||
52 | oxygen_reset_uart(chip); | ||
53 | param = 0; | ||
54 | hdmi_write_command(chip, 0x61, 1, ¶m); | ||
55 | param = 1; | ||
56 | hdmi_write_command(chip, 0x74, 1, ¶m); | ||
57 | hdmi_write_command(chip, 0x54, 5, hdmi->params); | ||
58 | } | ||
59 | |||
60 | void xonar_hdmi_init(struct oxygen *chip, struct xonar_hdmi *hdmi) | ||
61 | { | ||
62 | hdmi->params[1] = IEC958_AES3_CON_FS_48000; | ||
63 | hdmi->params[4] = 1; | ||
64 | xonar_hdmi_init_commands(chip, hdmi); | ||
65 | } | ||
66 | |||
67 | void xonar_hdmi_cleanup(struct oxygen *chip) | ||
68 | { | ||
69 | u8 param = 0; | ||
70 | |||
71 | hdmi_write_command(chip, 0x74, 1, ¶m); | ||
72 | } | ||
73 | |||
74 | void xonar_hdmi_resume(struct oxygen *chip, struct xonar_hdmi *hdmi) | ||
75 | { | ||
76 | xonar_hdmi_init_commands(chip, hdmi); | ||
77 | } | ||
78 | |||
79 | void xonar_hdmi_pcm_hardware_filter(unsigned int channel, | ||
80 | struct snd_pcm_hardware *hardware) | ||
81 | { | ||
82 | if (channel == PCM_MULTICH) { | ||
83 | hardware->rates = SNDRV_PCM_RATE_44100 | | ||
84 | SNDRV_PCM_RATE_48000 | | ||
85 | SNDRV_PCM_RATE_96000 | | ||
86 | SNDRV_PCM_RATE_192000; | ||
87 | hardware->rate_min = 44100; | ||
88 | } | ||
89 | } | ||
90 | |||
91 | void xonar_set_hdmi_params(struct oxygen *chip, struct xonar_hdmi *hdmi, | ||
92 | struct snd_pcm_hw_params *params) | ||
93 | { | ||
94 | hdmi->params[0] = 0; /* 1 = non-audio */ | ||
95 | switch (params_rate(params)) { | ||
96 | case 44100: | ||
97 | hdmi->params[1] = IEC958_AES3_CON_FS_44100; | ||
98 | break; | ||
99 | case 48000: | ||
100 | hdmi->params[1] = IEC958_AES3_CON_FS_48000; | ||
101 | break; | ||
102 | default: /* 96000 */ | ||
103 | hdmi->params[1] = IEC958_AES3_CON_FS_96000; | ||
104 | break; | ||
105 | case 192000: | ||
106 | hdmi->params[1] = IEC958_AES3_CON_FS_192000; | ||
107 | break; | ||
108 | } | ||
109 | hdmi->params[2] = params_channels(params) / 2 - 1; | ||
110 | if (params_format(params) == SNDRV_PCM_FORMAT_S16_LE) | ||
111 | hdmi->params[3] = 0; | ||
112 | else | ||
113 | hdmi->params[3] = 0xc0; | ||
114 | hdmi->params[4] = 1; /* ? */ | ||
115 | hdmi_write_command(chip, 0x54, 5, hdmi->params); | ||
116 | } | ||
117 | |||
118 | void xonar_hdmi_uart_input(struct oxygen *chip) | ||
119 | { | ||
120 | if (chip->uart_input_count >= 2 && | ||
121 | chip->uart_input[chip->uart_input_count - 2] == 'O' && | ||
122 | chip->uart_input[chip->uart_input_count - 1] == 'K') { | ||
123 | printk(KERN_DEBUG "message from HDMI chip received:\n"); | ||
124 | print_hex_dump_bytes("", DUMP_PREFIX_OFFSET, | ||
125 | chip->uart_input, chip->uart_input_count); | ||
126 | chip->uart_input_count = 0; | ||
127 | } | ||
128 | } | ||
diff --git a/sound/pci/oxygen/xonar_lib.c b/sound/pci/oxygen/xonar_lib.c new file mode 100644 index 000000000000..b3ff71316653 --- /dev/null +++ b/sound/pci/oxygen/xonar_lib.c | |||
@@ -0,0 +1,132 @@ | |||
1 | /* | ||
2 | * helper functions for Asus Xonar cards | ||
3 | * | ||
4 | * Copyright (c) Clemens Ladisch <clemens@ladisch.de> | ||
5 | * | ||
6 | * | ||
7 | * This driver is free software; you can redistribute it and/or modify | ||
8 | * it under the terms of the GNU General Public License, version 2. | ||
9 | * | ||
10 | * This driver is distributed in the hope that it will be useful, | ||
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
13 | * GNU General Public License for more details. | ||
14 | * | ||
15 | * You should have received a copy of the GNU General Public License | ||
16 | * along with this driver; if not, see <http://www.gnu.org/licenses/>. | ||
17 | */ | ||
18 | |||
19 | #include <linux/delay.h> | ||
20 | #include <sound/core.h> | ||
21 | #include <sound/control.h> | ||
22 | #include <sound/pcm.h> | ||
23 | #include <sound/pcm_params.h> | ||
24 | #include "xonar.h" | ||
25 | |||
26 | |||
27 | #define GPIO_CS53x1_M_MASK 0x000c | ||
28 | #define GPIO_CS53x1_M_SINGLE 0x0000 | ||
29 | #define GPIO_CS53x1_M_DOUBLE 0x0004 | ||
30 | #define GPIO_CS53x1_M_QUAD 0x0008 | ||
31 | |||
32 | |||
33 | void xonar_enable_output(struct oxygen *chip) | ||
34 | { | ||
35 | struct xonar_generic *data = chip->model_data; | ||
36 | |||
37 | oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, data->output_enable_bit); | ||
38 | msleep(data->anti_pop_delay); | ||
39 | oxygen_set_bits16(chip, OXYGEN_GPIO_DATA, data->output_enable_bit); | ||
40 | } | ||
41 | |||
42 | void xonar_disable_output(struct oxygen *chip) | ||
43 | { | ||
44 | struct xonar_generic *data = chip->model_data; | ||
45 | |||
46 | oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, data->output_enable_bit); | ||
47 | } | ||
48 | |||
49 | static void xonar_ext_power_gpio_changed(struct oxygen *chip) | ||
50 | { | ||
51 | struct xonar_generic *data = chip->model_data; | ||
52 | u8 has_power; | ||
53 | |||
54 | has_power = !!(oxygen_read8(chip, data->ext_power_reg) | ||
55 | & data->ext_power_bit); | ||
56 | if (has_power != data->has_power) { | ||
57 | data->has_power = has_power; | ||
58 | if (has_power) { | ||
59 | snd_printk(KERN_NOTICE "power restored\n"); | ||
60 | } else { | ||
61 | snd_printk(KERN_CRIT | ||
62 | "Hey! Don't unplug the power cable!\n"); | ||
63 | /* TODO: stop PCMs */ | ||
64 | } | ||
65 | } | ||
66 | } | ||
67 | |||
68 | void xonar_init_ext_power(struct oxygen *chip) | ||
69 | { | ||
70 | struct xonar_generic *data = chip->model_data; | ||
71 | |||
72 | oxygen_set_bits8(chip, data->ext_power_int_reg, | ||
73 | data->ext_power_bit); | ||
74 | chip->interrupt_mask |= OXYGEN_INT_GPIO; | ||
75 | chip->model.gpio_changed = xonar_ext_power_gpio_changed; | ||
76 | data->has_power = !!(oxygen_read8(chip, data->ext_power_reg) | ||
77 | & data->ext_power_bit); | ||
78 | } | ||
79 | |||
80 | void xonar_init_cs53x1(struct oxygen *chip) | ||
81 | { | ||
82 | oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_CS53x1_M_MASK); | ||
83 | oxygen_write16_masked(chip, OXYGEN_GPIO_DATA, | ||
84 | GPIO_CS53x1_M_SINGLE, GPIO_CS53x1_M_MASK); | ||
85 | } | ||
86 | |||
87 | void xonar_set_cs53x1_params(struct oxygen *chip, | ||
88 | struct snd_pcm_hw_params *params) | ||
89 | { | ||
90 | unsigned int value; | ||
91 | |||
92 | if (params_rate(params) <= 54000) | ||
93 | value = GPIO_CS53x1_M_SINGLE; | ||
94 | else if (params_rate(params) <= 108000) | ||
95 | value = GPIO_CS53x1_M_DOUBLE; | ||
96 | else | ||
97 | value = GPIO_CS53x1_M_QUAD; | ||
98 | oxygen_write16_masked(chip, OXYGEN_GPIO_DATA, | ||
99 | value, GPIO_CS53x1_M_MASK); | ||
100 | } | ||
101 | |||
102 | int xonar_gpio_bit_switch_get(struct snd_kcontrol *ctl, | ||
103 | struct snd_ctl_elem_value *value) | ||
104 | { | ||
105 | struct oxygen *chip = ctl->private_data; | ||
106 | u16 bit = ctl->private_value; | ||
107 | |||
108 | value->value.integer.value[0] = | ||
109 | !!(oxygen_read16(chip, OXYGEN_GPIO_DATA) & bit); | ||
110 | return 0; | ||
111 | } | ||
112 | |||
113 | int xonar_gpio_bit_switch_put(struct snd_kcontrol *ctl, | ||
114 | struct snd_ctl_elem_value *value) | ||
115 | { | ||
116 | struct oxygen *chip = ctl->private_data; | ||
117 | u16 bit = ctl->private_value; | ||
118 | u16 old_bits, new_bits; | ||
119 | int changed; | ||
120 | |||
121 | spin_lock_irq(&chip->reg_lock); | ||
122 | old_bits = oxygen_read16(chip, OXYGEN_GPIO_DATA); | ||
123 | if (value->value.integer.value[0]) | ||
124 | new_bits = old_bits | bit; | ||
125 | else | ||
126 | new_bits = old_bits & ~bit; | ||
127 | changed = new_bits != old_bits; | ||
128 | if (changed) | ||
129 | oxygen_write16(chip, OXYGEN_GPIO_DATA, new_bits); | ||
130 | spin_unlock_irq(&chip->reg_lock); | ||
131 | return changed; | ||
132 | } | ||
diff --git a/sound/pci/oxygen/xonar_pcm179x.c b/sound/pci/oxygen/xonar_pcm179x.c new file mode 100644 index 000000000000..ba18fb546b4f --- /dev/null +++ b/sound/pci/oxygen/xonar_pcm179x.c | |||
@@ -0,0 +1,1115 @@ | |||
1 | /* | ||
2 | * card driver for models with PCM1796 DACs (Xonar D2/D2X/HDAV1.3/ST/STX) | ||
3 | * | ||
4 | * Copyright (c) Clemens Ladisch <clemens@ladisch.de> | ||
5 | * | ||
6 | * | ||
7 | * This driver is free software; you can redistribute it and/or modify | ||
8 | * it under the terms of the GNU General Public License, version 2. | ||
9 | * | ||
10 | * This driver is distributed in the hope that it will be useful, | ||
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
13 | * GNU General Public License for more details. | ||
14 | * | ||
15 | * You should have received a copy of the GNU General Public License | ||
16 | * along with this driver; if not, see <http://www.gnu.org/licenses/>. | ||
17 | */ | ||
18 | |||
19 | /* | ||
20 | * Xonar D2/D2X | ||
21 | * ------------ | ||
22 | * | ||
23 | * CMI8788: | ||
24 | * | ||
25 | * SPI 0 -> 1st PCM1796 (front) | ||
26 | * SPI 1 -> 2nd PCM1796 (surround) | ||
27 | * SPI 2 -> 3rd PCM1796 (center/LFE) | ||
28 | * SPI 4 -> 4th PCM1796 (back) | ||
29 | * | ||
30 | * GPIO 2 -> M0 of CS5381 | ||
31 | * GPIO 3 -> M1 of CS5381 | ||
32 | * GPIO 5 <- external power present (D2X only) | ||
33 | * GPIO 7 -> ALT | ||
34 | * GPIO 8 -> enable output to speakers | ||
35 | * | ||
36 | * CM9780: | ||
37 | * | ||
38 | * GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input | ||
39 | */ | ||
40 | |||
41 | /* | ||
42 | * Xonar HDAV1.3 (Deluxe) | ||
43 | * ---------------------- | ||
44 | * | ||
45 | * CMI8788: | ||
46 | * | ||
47 | * I²C <-> PCM1796 (front) | ||
48 | * | ||
49 | * GPI 0 <- external power present | ||
50 | * | ||
51 | * GPIO 0 -> enable output to speakers | ||
52 | * GPIO 2 -> M0 of CS5381 | ||
53 | * GPIO 3 -> M1 of CS5381 | ||
54 | * GPIO 8 -> route input jack to line-in (0) or mic-in (1) | ||
55 | * | ||
56 | * TXD -> HDMI controller | ||
57 | * RXD <- HDMI controller | ||
58 | * | ||
59 | * PCM1796 front: AD1,0 <- 0,0 | ||
60 | * | ||
61 | * CM9780: | ||
62 | * | ||
63 | * GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input | ||
64 | * | ||
65 | * no daughterboard | ||
66 | * ---------------- | ||
67 | * | ||
68 | * GPIO 4 <- 1 | ||
69 | * | ||
70 | * H6 daughterboard | ||
71 | * ---------------- | ||
72 | * | ||
73 | * GPIO 4 <- 0 | ||
74 | * GPIO 5 <- 0 | ||
75 | * | ||
76 | * I²C <-> PCM1796 (surround) | ||
77 | * <-> PCM1796 (center/LFE) | ||
78 | * <-> PCM1796 (back) | ||
79 | * | ||
80 | * PCM1796 surround: AD1,0 <- 0,1 | ||
81 | * PCM1796 center/LFE: AD1,0 <- 1,0 | ||
82 | * PCM1796 back: AD1,0 <- 1,1 | ||
83 | * | ||
84 | * unknown daughterboard | ||
85 | * --------------------- | ||
86 | * | ||
87 | * GPIO 4 <- 0 | ||
88 | * GPIO 5 <- 1 | ||
89 | * | ||
90 | * I²C <-> CS4362A (surround, center/LFE, back) | ||
91 | * | ||
92 | * CS4362A: AD0 <- 0 | ||
93 | */ | ||
94 | |||
95 | /* | ||
96 | * Xonar Essence ST (Deluxe)/STX | ||
97 | * ----------------------------- | ||
98 | * | ||
99 | * CMI8788: | ||
100 | * | ||
101 | * I²C <-> PCM1792A | ||
102 | * <-> CS2000 (ST only) | ||
103 | * | ||
104 | * ADC1 MCLK -> REF_CLK of CS2000 (ST only) | ||
105 | * | ||
106 | * GPI 0 <- external power present (STX only) | ||
107 | * | ||
108 | * GPIO 0 -> enable output to speakers | ||
109 | * GPIO 1 -> route HP to front panel (0) or rear jack (1) | ||
110 | * GPIO 2 -> M0 of CS5381 | ||
111 | * GPIO 3 -> M1 of CS5381 | ||
112 | * GPIO 7 -> route output to speaker jacks (0) or HP (1) | ||
113 | * GPIO 8 -> route input jack to line-in (0) or mic-in (1) | ||
114 | * | ||
115 | * PCM1792A: | ||
116 | * | ||
117 | * AD1,0 <- 0,0 | ||
118 | * SCK <- CLK_OUT of CS2000 (ST only) | ||
119 | * | ||
120 | * CS2000: | ||
121 | * | ||
122 | * AD0 <- 0 | ||
123 | * | ||
124 | * CM9780: | ||
125 | * | ||
126 | * GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input | ||
127 | * | ||
128 | * H6 daughterboard | ||
129 | * ---------------- | ||
130 | * | ||
131 | * GPIO 4 <- 0 | ||
132 | * GPIO 5 <- 0 | ||
133 | */ | ||
134 | |||
135 | #include <linux/pci.h> | ||
136 | #include <linux/delay.h> | ||
137 | #include <linux/mutex.h> | ||
138 | #include <sound/ac97_codec.h> | ||
139 | #include <sound/control.h> | ||
140 | #include <sound/core.h> | ||
141 | #include <sound/pcm.h> | ||
142 | #include <sound/pcm_params.h> | ||
143 | #include <sound/tlv.h> | ||
144 | #include "xonar.h" | ||
145 | #include "cm9780.h" | ||
146 | #include "pcm1796.h" | ||
147 | #include "cs2000.h" | ||
148 | |||
149 | |||
150 | #define GPIO_D2X_EXT_POWER 0x0020 | ||
151 | #define GPIO_D2_ALT 0x0080 | ||
152 | #define GPIO_D2_OUTPUT_ENABLE 0x0100 | ||
153 | |||
154 | #define GPI_EXT_POWER 0x01 | ||
155 | #define GPIO_INPUT_ROUTE 0x0100 | ||
156 | |||
157 | #define GPIO_HDAV_OUTPUT_ENABLE 0x0001 | ||
158 | |||
159 | #define GPIO_DB_MASK 0x0030 | ||
160 | #define GPIO_DB_H6 0x0000 | ||
161 | |||
162 | #define GPIO_ST_OUTPUT_ENABLE 0x0001 | ||
163 | #define GPIO_ST_HP_REAR 0x0002 | ||
164 | #define GPIO_ST_HP 0x0080 | ||
165 | |||
166 | #define I2C_DEVICE_PCM1796(i) (0x98 + ((i) << 1)) /* 10011, ii, /W=0 */ | ||
167 | #define I2C_DEVICE_CS2000 0x9c /* 100111, 0, /W=0 */ | ||
168 | |||
169 | #define PCM1796_REG_BASE 16 | ||
170 | |||
171 | |||
172 | struct xonar_pcm179x { | ||
173 | struct xonar_generic generic; | ||
174 | unsigned int dacs; | ||
175 | u8 pcm1796_regs[4][5]; | ||
176 | unsigned int current_rate; | ||
177 | bool os_128; | ||
178 | bool hp_active; | ||
179 | s8 hp_gain_offset; | ||
180 | bool has_cs2000; | ||
181 | u8 cs2000_fun_cfg_1; | ||
182 | }; | ||
183 | |||
184 | struct xonar_hdav { | ||
185 | struct xonar_pcm179x pcm179x; | ||
186 | struct xonar_hdmi hdmi; | ||
187 | }; | ||
188 | |||
189 | |||
190 | static inline void pcm1796_write_spi(struct oxygen *chip, unsigned int codec, | ||
191 | u8 reg, u8 value) | ||
192 | { | ||
193 | /* maps ALSA channel pair number to SPI output */ | ||
194 | static const u8 codec_map[4] = { | ||
195 | 0, 1, 2, 4 | ||
196 | }; | ||
197 | oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER | | ||
198 | OXYGEN_SPI_DATA_LENGTH_2 | | ||
199 | OXYGEN_SPI_CLOCK_160 | | ||
200 | (codec_map[codec] << OXYGEN_SPI_CODEC_SHIFT) | | ||
201 | OXYGEN_SPI_CEN_LATCH_CLOCK_HI, | ||
202 | (reg << 8) | value); | ||
203 | } | ||
204 | |||
205 | static inline void pcm1796_write_i2c(struct oxygen *chip, unsigned int codec, | ||
206 | u8 reg, u8 value) | ||
207 | { | ||
208 | oxygen_write_i2c(chip, I2C_DEVICE_PCM1796(codec), reg, value); | ||
209 | } | ||
210 | |||
211 | static void pcm1796_write(struct oxygen *chip, unsigned int codec, | ||
212 | u8 reg, u8 value) | ||
213 | { | ||
214 | struct xonar_pcm179x *data = chip->model_data; | ||
215 | |||
216 | if ((chip->model.function_flags & OXYGEN_FUNCTION_2WIRE_SPI_MASK) == | ||
217 | OXYGEN_FUNCTION_SPI) | ||
218 | pcm1796_write_spi(chip, codec, reg, value); | ||
219 | else | ||
220 | pcm1796_write_i2c(chip, codec, reg, value); | ||
221 | if ((unsigned int)(reg - PCM1796_REG_BASE) | ||
222 | < ARRAY_SIZE(data->pcm1796_regs[codec])) | ||
223 | data->pcm1796_regs[codec][reg - PCM1796_REG_BASE] = value; | ||
224 | } | ||
225 | |||
226 | static void pcm1796_write_cached(struct oxygen *chip, unsigned int codec, | ||
227 | u8 reg, u8 value) | ||
228 | { | ||
229 | struct xonar_pcm179x *data = chip->model_data; | ||
230 | |||
231 | if (value != data->pcm1796_regs[codec][reg - PCM1796_REG_BASE]) | ||
232 | pcm1796_write(chip, codec, reg, value); | ||
233 | } | ||
234 | |||
235 | static void cs2000_write(struct oxygen *chip, u8 reg, u8 value) | ||
236 | { | ||
237 | struct xonar_pcm179x *data = chip->model_data; | ||
238 | |||
239 | oxygen_write_i2c(chip, I2C_DEVICE_CS2000, reg, value); | ||
240 | if (reg == CS2000_FUN_CFG_1) | ||
241 | data->cs2000_fun_cfg_1 = value; | ||
242 | } | ||
243 | |||
244 | static void cs2000_write_cached(struct oxygen *chip, u8 reg, u8 value) | ||
245 | { | ||
246 | struct xonar_pcm179x *data = chip->model_data; | ||
247 | |||
248 | if (reg != CS2000_FUN_CFG_1 || | ||
249 | value != data->cs2000_fun_cfg_1) | ||
250 | cs2000_write(chip, reg, value); | ||
251 | } | ||
252 | |||
253 | static void pcm1796_registers_init(struct oxygen *chip) | ||
254 | { | ||
255 | struct xonar_pcm179x *data = chip->model_data; | ||
256 | unsigned int i; | ||
257 | s8 gain_offset; | ||
258 | |||
259 | gain_offset = data->hp_active ? data->hp_gain_offset : 0; | ||
260 | for (i = 0; i < data->dacs; ++i) { | ||
261 | /* set ATLD before ATL/ATR */ | ||
262 | pcm1796_write(chip, i, 18, | ||
263 | data->pcm1796_regs[0][18 - PCM1796_REG_BASE]); | ||
264 | pcm1796_write(chip, i, 16, chip->dac_volume[i * 2] | ||
265 | + gain_offset); | ||
266 | pcm1796_write(chip, i, 17, chip->dac_volume[i * 2 + 1] | ||
267 | + gain_offset); | ||
268 | pcm1796_write(chip, i, 19, | ||
269 | data->pcm1796_regs[0][19 - PCM1796_REG_BASE]); | ||
270 | pcm1796_write(chip, i, 20, | ||
271 | data->pcm1796_regs[0][20 - PCM1796_REG_BASE]); | ||
272 | pcm1796_write(chip, i, 21, 0); | ||
273 | } | ||
274 | } | ||
275 | |||
276 | static void pcm1796_init(struct oxygen *chip) | ||
277 | { | ||
278 | struct xonar_pcm179x *data = chip->model_data; | ||
279 | |||
280 | data->pcm1796_regs[0][18 - PCM1796_REG_BASE] = PCM1796_MUTE | | ||
281 | PCM1796_DMF_DISABLED | PCM1796_FMT_24_LJUST | PCM1796_ATLD; | ||
282 | data->pcm1796_regs[0][19 - PCM1796_REG_BASE] = | ||
283 | PCM1796_FLT_SHARP | PCM1796_ATS_1; | ||
284 | data->pcm1796_regs[0][20 - PCM1796_REG_BASE] = PCM1796_OS_64; | ||
285 | pcm1796_registers_init(chip); | ||
286 | data->current_rate = 48000; | ||
287 | } | ||
288 | |||
289 | static void xonar_d2_init(struct oxygen *chip) | ||
290 | { | ||
291 | struct xonar_pcm179x *data = chip->model_data; | ||
292 | |||
293 | data->generic.anti_pop_delay = 300; | ||
294 | data->generic.output_enable_bit = GPIO_D2_OUTPUT_ENABLE; | ||
295 | data->dacs = 4; | ||
296 | |||
297 | pcm1796_init(chip); | ||
298 | |||
299 | oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_D2_ALT); | ||
300 | oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, GPIO_D2_ALT); | ||
301 | |||
302 | oxygen_ac97_set_bits(chip, 0, CM9780_JACK, CM9780_FMIC2MIC); | ||
303 | |||
304 | xonar_init_cs53x1(chip); | ||
305 | xonar_enable_output(chip); | ||
306 | |||
307 | snd_component_add(chip->card, "PCM1796"); | ||
308 | snd_component_add(chip->card, "CS5381"); | ||
309 | } | ||
310 | |||
311 | static void xonar_d2x_init(struct oxygen *chip) | ||
312 | { | ||
313 | struct xonar_pcm179x *data = chip->model_data; | ||
314 | |||
315 | data->generic.ext_power_reg = OXYGEN_GPIO_DATA; | ||
316 | data->generic.ext_power_int_reg = OXYGEN_GPIO_INTERRUPT_MASK; | ||
317 | data->generic.ext_power_bit = GPIO_D2X_EXT_POWER; | ||
318 | oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_D2X_EXT_POWER); | ||
319 | xonar_init_ext_power(chip); | ||
320 | xonar_d2_init(chip); | ||
321 | } | ||
322 | |||
323 | static void xonar_hdav_init(struct oxygen *chip) | ||
324 | { | ||
325 | struct xonar_hdav *data = chip->model_data; | ||
326 | |||
327 | oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS, | ||
328 | OXYGEN_2WIRE_LENGTH_8 | | ||
329 | OXYGEN_2WIRE_INTERRUPT_MASK | | ||
330 | OXYGEN_2WIRE_SPEED_FAST); | ||
331 | |||
332 | data->pcm179x.generic.anti_pop_delay = 100; | ||
333 | data->pcm179x.generic.output_enable_bit = GPIO_HDAV_OUTPUT_ENABLE; | ||
334 | data->pcm179x.generic.ext_power_reg = OXYGEN_GPI_DATA; | ||
335 | data->pcm179x.generic.ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK; | ||
336 | data->pcm179x.generic.ext_power_bit = GPI_EXT_POWER; | ||
337 | data->pcm179x.dacs = chip->model.private_data ? 4 : 1; | ||
338 | |||
339 | pcm1796_init(chip); | ||
340 | |||
341 | oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_INPUT_ROUTE); | ||
342 | oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, GPIO_INPUT_ROUTE); | ||
343 | |||
344 | xonar_init_cs53x1(chip); | ||
345 | xonar_init_ext_power(chip); | ||
346 | xonar_hdmi_init(chip, &data->hdmi); | ||
347 | xonar_enable_output(chip); | ||
348 | |||
349 | snd_component_add(chip->card, "PCM1796"); | ||
350 | snd_component_add(chip->card, "CS5381"); | ||
351 | } | ||
352 | |||
353 | static void xonar_st_init_i2c(struct oxygen *chip) | ||
354 | { | ||
355 | oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS, | ||
356 | OXYGEN_2WIRE_LENGTH_8 | | ||
357 | OXYGEN_2WIRE_INTERRUPT_MASK | | ||
358 | OXYGEN_2WIRE_SPEED_FAST); | ||
359 | } | ||
360 | |||
361 | static void xonar_st_init_common(struct oxygen *chip) | ||
362 | { | ||
363 | struct xonar_pcm179x *data = chip->model_data; | ||
364 | |||
365 | data->generic.anti_pop_delay = 100; | ||
366 | data->generic.output_enable_bit = GPIO_ST_OUTPUT_ENABLE; | ||
367 | data->dacs = chip->model.private_data ? 4 : 1; | ||
368 | data->hp_gain_offset = 2*-18; | ||
369 | |||
370 | pcm1796_init(chip); | ||
371 | |||
372 | oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, | ||
373 | GPIO_INPUT_ROUTE | GPIO_ST_HP_REAR | GPIO_ST_HP); | ||
374 | oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, | ||
375 | GPIO_INPUT_ROUTE | GPIO_ST_HP_REAR | GPIO_ST_HP); | ||
376 | |||
377 | xonar_init_cs53x1(chip); | ||
378 | xonar_enable_output(chip); | ||
379 | |||
380 | snd_component_add(chip->card, "PCM1792A"); | ||
381 | snd_component_add(chip->card, "CS5381"); | ||
382 | } | ||
383 | |||
384 | static void cs2000_registers_init(struct oxygen *chip) | ||
385 | { | ||
386 | struct xonar_pcm179x *data = chip->model_data; | ||
387 | |||
388 | cs2000_write(chip, CS2000_GLOBAL_CFG, CS2000_FREEZE); | ||
389 | cs2000_write(chip, CS2000_DEV_CTRL, 0); | ||
390 | cs2000_write(chip, CS2000_DEV_CFG_1, | ||
391 | CS2000_R_MOD_SEL_1 | | ||
392 | (0 << CS2000_R_SEL_SHIFT) | | ||
393 | CS2000_AUX_OUT_SRC_REF_CLK | | ||
394 | CS2000_EN_DEV_CFG_1); | ||
395 | cs2000_write(chip, CS2000_DEV_CFG_2, | ||
396 | (0 << CS2000_LOCK_CLK_SHIFT) | | ||
397 | CS2000_FRAC_N_SRC_STATIC); | ||
398 | cs2000_write(chip, CS2000_RATIO_0 + 0, 0x00); /* 1.0 */ | ||
399 | cs2000_write(chip, CS2000_RATIO_0 + 1, 0x10); | ||
400 | cs2000_write(chip, CS2000_RATIO_0 + 2, 0x00); | ||
401 | cs2000_write(chip, CS2000_RATIO_0 + 3, 0x00); | ||
402 | cs2000_write(chip, CS2000_FUN_CFG_1, data->cs2000_fun_cfg_1); | ||
403 | cs2000_write(chip, CS2000_FUN_CFG_2, 0); | ||
404 | cs2000_write(chip, CS2000_GLOBAL_CFG, CS2000_EN_DEV_CFG_2); | ||
405 | } | ||
406 | |||
407 | static void xonar_st_init(struct oxygen *chip) | ||
408 | { | ||
409 | struct xonar_pcm179x *data = chip->model_data; | ||
410 | |||
411 | data->has_cs2000 = 1; | ||
412 | data->cs2000_fun_cfg_1 = CS2000_REF_CLK_DIV_1; | ||
413 | |||
414 | oxygen_write16(chip, OXYGEN_I2S_A_FORMAT, | ||
415 | OXYGEN_RATE_48000 | OXYGEN_I2S_FORMAT_I2S | | ||
416 | OXYGEN_I2S_MCLK_128 | OXYGEN_I2S_BITS_16 | | ||
417 | OXYGEN_I2S_MASTER | OXYGEN_I2S_BCLK_64); | ||
418 | |||
419 | xonar_st_init_i2c(chip); | ||
420 | cs2000_registers_init(chip); | ||
421 | xonar_st_init_common(chip); | ||
422 | |||
423 | snd_component_add(chip->card, "CS2000"); | ||
424 | } | ||
425 | |||
426 | static void xonar_stx_init(struct oxygen *chip) | ||
427 | { | ||
428 | struct xonar_pcm179x *data = chip->model_data; | ||
429 | |||
430 | xonar_st_init_i2c(chip); | ||
431 | data->generic.ext_power_reg = OXYGEN_GPI_DATA; | ||
432 | data->generic.ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK; | ||
433 | data->generic.ext_power_bit = GPI_EXT_POWER; | ||
434 | xonar_init_ext_power(chip); | ||
435 | xonar_st_init_common(chip); | ||
436 | } | ||
437 | |||
438 | static void xonar_d2_cleanup(struct oxygen *chip) | ||
439 | { | ||
440 | xonar_disable_output(chip); | ||
441 | } | ||
442 | |||
443 | static void xonar_hdav_cleanup(struct oxygen *chip) | ||
444 | { | ||
445 | xonar_hdmi_cleanup(chip); | ||
446 | xonar_disable_output(chip); | ||
447 | msleep(2); | ||
448 | } | ||
449 | |||
450 | static void xonar_st_cleanup(struct oxygen *chip) | ||
451 | { | ||
452 | xonar_disable_output(chip); | ||
453 | } | ||
454 | |||
455 | static void xonar_d2_suspend(struct oxygen *chip) | ||
456 | { | ||
457 | xonar_d2_cleanup(chip); | ||
458 | } | ||
459 | |||
460 | static void xonar_hdav_suspend(struct oxygen *chip) | ||
461 | { | ||
462 | xonar_hdav_cleanup(chip); | ||
463 | } | ||
464 | |||
465 | static void xonar_st_suspend(struct oxygen *chip) | ||
466 | { | ||
467 | xonar_st_cleanup(chip); | ||
468 | } | ||
469 | |||
470 | static void xonar_d2_resume(struct oxygen *chip) | ||
471 | { | ||
472 | pcm1796_registers_init(chip); | ||
473 | xonar_enable_output(chip); | ||
474 | } | ||
475 | |||
476 | static void xonar_hdav_resume(struct oxygen *chip) | ||
477 | { | ||
478 | struct xonar_hdav *data = chip->model_data; | ||
479 | |||
480 | pcm1796_registers_init(chip); | ||
481 | xonar_hdmi_resume(chip, &data->hdmi); | ||
482 | xonar_enable_output(chip); | ||
483 | } | ||
484 | |||
485 | static void xonar_stx_resume(struct oxygen *chip) | ||
486 | { | ||
487 | pcm1796_registers_init(chip); | ||
488 | xonar_enable_output(chip); | ||
489 | } | ||
490 | |||
491 | static void xonar_st_resume(struct oxygen *chip) | ||
492 | { | ||
493 | cs2000_registers_init(chip); | ||
494 | xonar_stx_resume(chip); | ||
495 | } | ||
496 | |||
497 | static unsigned int mclk_from_rate(struct oxygen *chip, unsigned int rate) | ||
498 | { | ||
499 | struct xonar_pcm179x *data = chip->model_data; | ||
500 | |||
501 | if (rate <= 32000) | ||
502 | return OXYGEN_I2S_MCLK_512; | ||
503 | else if (rate <= 48000 && data->os_128) | ||
504 | return OXYGEN_I2S_MCLK_512; | ||
505 | else if (rate <= 96000) | ||
506 | return OXYGEN_I2S_MCLK_256; | ||
507 | else | ||
508 | return OXYGEN_I2S_MCLK_128; | ||
509 | } | ||
510 | |||
511 | static unsigned int get_pcm1796_i2s_mclk(struct oxygen *chip, | ||
512 | unsigned int channel, | ||
513 | struct snd_pcm_hw_params *params) | ||
514 | { | ||
515 | if (channel == PCM_MULTICH) | ||
516 | return mclk_from_rate(chip, params_rate(params)); | ||
517 | else | ||
518 | return oxygen_default_i2s_mclk(chip, channel, params); | ||
519 | } | ||
520 | |||
521 | static void update_pcm1796_oversampling(struct oxygen *chip) | ||
522 | { | ||
523 | struct xonar_pcm179x *data = chip->model_data; | ||
524 | unsigned int i; | ||
525 | u8 reg; | ||
526 | |||
527 | if (data->current_rate <= 32000) | ||
528 | reg = PCM1796_OS_128; | ||
529 | else if (data->current_rate <= 48000 && data->os_128) | ||
530 | reg = PCM1796_OS_128; | ||
531 | else if (data->current_rate <= 96000 || data->os_128) | ||
532 | reg = PCM1796_OS_64; | ||
533 | else | ||
534 | reg = PCM1796_OS_32; | ||
535 | for (i = 0; i < data->dacs; ++i) | ||
536 | pcm1796_write_cached(chip, i, 20, reg); | ||
537 | } | ||
538 | |||
539 | static void set_pcm1796_params(struct oxygen *chip, | ||
540 | struct snd_pcm_hw_params *params) | ||
541 | { | ||
542 | struct xonar_pcm179x *data = chip->model_data; | ||
543 | |||
544 | data->current_rate = params_rate(params); | ||
545 | update_pcm1796_oversampling(chip); | ||
546 | } | ||
547 | |||
548 | static void update_pcm1796_volume(struct oxygen *chip) | ||
549 | { | ||
550 | struct xonar_pcm179x *data = chip->model_data; | ||
551 | unsigned int i; | ||
552 | s8 gain_offset; | ||
553 | |||
554 | gain_offset = data->hp_active ? data->hp_gain_offset : 0; | ||
555 | for (i = 0; i < data->dacs; ++i) { | ||
556 | pcm1796_write_cached(chip, i, 16, chip->dac_volume[i * 2] | ||
557 | + gain_offset); | ||
558 | pcm1796_write_cached(chip, i, 17, chip->dac_volume[i * 2 + 1] | ||
559 | + gain_offset); | ||
560 | } | ||
561 | } | ||
562 | |||
563 | static void update_pcm1796_mute(struct oxygen *chip) | ||
564 | { | ||
565 | struct xonar_pcm179x *data = chip->model_data; | ||
566 | unsigned int i; | ||
567 | u8 value; | ||
568 | |||
569 | value = PCM1796_DMF_DISABLED | PCM1796_FMT_24_LJUST | PCM1796_ATLD; | ||
570 | if (chip->dac_mute) | ||
571 | value |= PCM1796_MUTE; | ||
572 | for (i = 0; i < data->dacs; ++i) | ||
573 | pcm1796_write_cached(chip, i, 18, value); | ||
574 | } | ||
575 | |||
576 | static void update_cs2000_rate(struct oxygen *chip, unsigned int rate) | ||
577 | { | ||
578 | struct xonar_pcm179x *data = chip->model_data; | ||
579 | u8 rate_mclk, reg; | ||
580 | |||
581 | switch (rate) { | ||
582 | /* XXX Why is the I2S A MCLK half the actual I2S MCLK? */ | ||
583 | case 32000: | ||
584 | rate_mclk = OXYGEN_RATE_32000 | OXYGEN_I2S_MCLK_256; | ||
585 | break; | ||
586 | case 44100: | ||
587 | if (data->os_128) | ||
588 | rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_256; | ||
589 | else | ||
590 | rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_128; | ||
591 | break; | ||
592 | default: /* 48000 */ | ||
593 | if (data->os_128) | ||
594 | rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_256; | ||
595 | else | ||
596 | rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_128; | ||
597 | break; | ||
598 | case 64000: | ||
599 | rate_mclk = OXYGEN_RATE_32000 | OXYGEN_I2S_MCLK_256; | ||
600 | break; | ||
601 | case 88200: | ||
602 | rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_256; | ||
603 | break; | ||
604 | case 96000: | ||
605 | rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_256; | ||
606 | break; | ||
607 | case 176400: | ||
608 | rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_256; | ||
609 | break; | ||
610 | case 192000: | ||
611 | rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_256; | ||
612 | break; | ||
613 | } | ||
614 | oxygen_write16_masked(chip, OXYGEN_I2S_A_FORMAT, rate_mclk, | ||
615 | OXYGEN_I2S_RATE_MASK | OXYGEN_I2S_MCLK_MASK); | ||
616 | if ((rate_mclk & OXYGEN_I2S_MCLK_MASK) <= OXYGEN_I2S_MCLK_128) | ||
617 | reg = CS2000_REF_CLK_DIV_1; | ||
618 | else | ||
619 | reg = CS2000_REF_CLK_DIV_2; | ||
620 | cs2000_write_cached(chip, CS2000_FUN_CFG_1, reg); | ||
621 | } | ||
622 | |||
623 | static void set_st_params(struct oxygen *chip, | ||
624 | struct snd_pcm_hw_params *params) | ||
625 | { | ||
626 | update_cs2000_rate(chip, params_rate(params)); | ||
627 | set_pcm1796_params(chip, params); | ||
628 | } | ||
629 | |||
630 | static void set_hdav_params(struct oxygen *chip, | ||
631 | struct snd_pcm_hw_params *params) | ||
632 | { | ||
633 | struct xonar_hdav *data = chip->model_data; | ||
634 | |||
635 | set_pcm1796_params(chip, params); | ||
636 | xonar_set_hdmi_params(chip, &data->hdmi, params); | ||
637 | } | ||
638 | |||
639 | static const struct snd_kcontrol_new alt_switch = { | ||
640 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
641 | .name = "Analog Loopback Switch", | ||
642 | .info = snd_ctl_boolean_mono_info, | ||
643 | .get = xonar_gpio_bit_switch_get, | ||
644 | .put = xonar_gpio_bit_switch_put, | ||
645 | .private_value = GPIO_D2_ALT, | ||
646 | }; | ||
647 | |||
648 | static int rolloff_info(struct snd_kcontrol *ctl, | ||
649 | struct snd_ctl_elem_info *info) | ||
650 | { | ||
651 | static const char *const names[2] = { | ||
652 | "Sharp Roll-off", "Slow Roll-off" | ||
653 | }; | ||
654 | |||
655 | info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; | ||
656 | info->count = 1; | ||
657 | info->value.enumerated.items = 2; | ||
658 | if (info->value.enumerated.item >= 2) | ||
659 | info->value.enumerated.item = 1; | ||
660 | strcpy(info->value.enumerated.name, names[info->value.enumerated.item]); | ||
661 | return 0; | ||
662 | } | ||
663 | |||
664 | static int rolloff_get(struct snd_kcontrol *ctl, | ||
665 | struct snd_ctl_elem_value *value) | ||
666 | { | ||
667 | struct oxygen *chip = ctl->private_data; | ||
668 | struct xonar_pcm179x *data = chip->model_data; | ||
669 | |||
670 | value->value.enumerated.item[0] = | ||
671 | (data->pcm1796_regs[0][19 - PCM1796_REG_BASE] & | ||
672 | PCM1796_FLT_MASK) != PCM1796_FLT_SHARP; | ||
673 | return 0; | ||
674 | } | ||
675 | |||
676 | static int rolloff_put(struct snd_kcontrol *ctl, | ||
677 | struct snd_ctl_elem_value *value) | ||
678 | { | ||
679 | struct oxygen *chip = ctl->private_data; | ||
680 | struct xonar_pcm179x *data = chip->model_data; | ||
681 | unsigned int i; | ||
682 | int changed; | ||
683 | u8 reg; | ||
684 | |||
685 | mutex_lock(&chip->mutex); | ||
686 | reg = data->pcm1796_regs[0][19 - PCM1796_REG_BASE]; | ||
687 | reg &= ~PCM1796_FLT_MASK; | ||
688 | if (!value->value.enumerated.item[0]) | ||
689 | reg |= PCM1796_FLT_SHARP; | ||
690 | else | ||
691 | reg |= PCM1796_FLT_SLOW; | ||
692 | changed = reg != data->pcm1796_regs[0][19 - PCM1796_REG_BASE]; | ||
693 | if (changed) { | ||
694 | for (i = 0; i < data->dacs; ++i) | ||
695 | pcm1796_write(chip, i, 19, reg); | ||
696 | } | ||
697 | mutex_unlock(&chip->mutex); | ||
698 | return changed; | ||
699 | } | ||
700 | |||
701 | static const struct snd_kcontrol_new rolloff_control = { | ||
702 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
703 | .name = "DAC Filter Playback Enum", | ||
704 | .info = rolloff_info, | ||
705 | .get = rolloff_get, | ||
706 | .put = rolloff_put, | ||
707 | }; | ||
708 | |||
709 | static int os_128_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info) | ||
710 | { | ||
711 | static const char *const names[2] = { "64x", "128x" }; | ||
712 | |||
713 | info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; | ||
714 | info->count = 1; | ||
715 | info->value.enumerated.items = 2; | ||
716 | if (info->value.enumerated.item >= 2) | ||
717 | info->value.enumerated.item = 1; | ||
718 | strcpy(info->value.enumerated.name, names[info->value.enumerated.item]); | ||
719 | return 0; | ||
720 | } | ||
721 | |||
722 | static int os_128_get(struct snd_kcontrol *ctl, | ||
723 | struct snd_ctl_elem_value *value) | ||
724 | { | ||
725 | struct oxygen *chip = ctl->private_data; | ||
726 | struct xonar_pcm179x *data = chip->model_data; | ||
727 | |||
728 | value->value.enumerated.item[0] = data->os_128; | ||
729 | return 0; | ||
730 | } | ||
731 | |||
732 | static int os_128_put(struct snd_kcontrol *ctl, | ||
733 | struct snd_ctl_elem_value *value) | ||
734 | { | ||
735 | struct oxygen *chip = ctl->private_data; | ||
736 | struct xonar_pcm179x *data = chip->model_data; | ||
737 | int changed; | ||
738 | |||
739 | mutex_lock(&chip->mutex); | ||
740 | changed = value->value.enumerated.item[0] != data->os_128; | ||
741 | if (changed) { | ||
742 | data->os_128 = value->value.enumerated.item[0]; | ||
743 | if (data->has_cs2000) | ||
744 | update_cs2000_rate(chip, data->current_rate); | ||
745 | oxygen_write16_masked(chip, OXYGEN_I2S_MULTICH_FORMAT, | ||
746 | mclk_from_rate(chip, data->current_rate), | ||
747 | OXYGEN_I2S_MCLK_MASK); | ||
748 | update_pcm1796_oversampling(chip); | ||
749 | } | ||
750 | mutex_unlock(&chip->mutex); | ||
751 | return changed; | ||
752 | } | ||
753 | |||
754 | static const struct snd_kcontrol_new os_128_control = { | ||
755 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
756 | .name = "DAC Oversampling Playback Enum", | ||
757 | .info = os_128_info, | ||
758 | .get = os_128_get, | ||
759 | .put = os_128_put, | ||
760 | }; | ||
761 | |||
762 | static int st_output_switch_info(struct snd_kcontrol *ctl, | ||
763 | struct snd_ctl_elem_info *info) | ||
764 | { | ||
765 | static const char *const names[3] = { | ||
766 | "Speakers", "Headphones", "FP Headphones" | ||
767 | }; | ||
768 | |||
769 | info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; | ||
770 | info->count = 1; | ||
771 | info->value.enumerated.items = 3; | ||
772 | if (info->value.enumerated.item >= 3) | ||
773 | info->value.enumerated.item = 2; | ||
774 | strcpy(info->value.enumerated.name, names[info->value.enumerated.item]); | ||
775 | return 0; | ||
776 | } | ||
777 | |||
778 | static int st_output_switch_get(struct snd_kcontrol *ctl, | ||
779 | struct snd_ctl_elem_value *value) | ||
780 | { | ||
781 | struct oxygen *chip = ctl->private_data; | ||
782 | u16 gpio; | ||
783 | |||
784 | gpio = oxygen_read16(chip, OXYGEN_GPIO_DATA); | ||
785 | if (!(gpio & GPIO_ST_HP)) | ||
786 | value->value.enumerated.item[0] = 0; | ||
787 | else if (gpio & GPIO_ST_HP_REAR) | ||
788 | value->value.enumerated.item[0] = 1; | ||
789 | else | ||
790 | value->value.enumerated.item[0] = 2; | ||
791 | return 0; | ||
792 | } | ||
793 | |||
794 | |||
795 | static int st_output_switch_put(struct snd_kcontrol *ctl, | ||
796 | struct snd_ctl_elem_value *value) | ||
797 | { | ||
798 | struct oxygen *chip = ctl->private_data; | ||
799 | struct xonar_pcm179x *data = chip->model_data; | ||
800 | u16 gpio_old, gpio; | ||
801 | |||
802 | mutex_lock(&chip->mutex); | ||
803 | gpio_old = oxygen_read16(chip, OXYGEN_GPIO_DATA); | ||
804 | gpio = gpio_old; | ||
805 | switch (value->value.enumerated.item[0]) { | ||
806 | case 0: | ||
807 | gpio &= ~(GPIO_ST_HP | GPIO_ST_HP_REAR); | ||
808 | break; | ||
809 | case 1: | ||
810 | gpio |= GPIO_ST_HP | GPIO_ST_HP_REAR; | ||
811 | break; | ||
812 | case 2: | ||
813 | gpio = (gpio | GPIO_ST_HP) & ~GPIO_ST_HP_REAR; | ||
814 | break; | ||
815 | } | ||
816 | oxygen_write16(chip, OXYGEN_GPIO_DATA, gpio); | ||
817 | data->hp_active = gpio & GPIO_ST_HP; | ||
818 | update_pcm1796_volume(chip); | ||
819 | mutex_unlock(&chip->mutex); | ||
820 | return gpio != gpio_old; | ||
821 | } | ||
822 | |||
823 | static int st_hp_volume_offset_info(struct snd_kcontrol *ctl, | ||
824 | struct snd_ctl_elem_info *info) | ||
825 | { | ||
826 | static const char *const names[3] = { | ||
827 | "< 64 ohms", "64-300 ohms", "300-600 ohms" | ||
828 | }; | ||
829 | |||
830 | info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; | ||
831 | info->count = 1; | ||
832 | info->value.enumerated.items = 3; | ||
833 | if (info->value.enumerated.item > 2) | ||
834 | info->value.enumerated.item = 2; | ||
835 | strcpy(info->value.enumerated.name, names[info->value.enumerated.item]); | ||
836 | return 0; | ||
837 | } | ||
838 | |||
839 | static int st_hp_volume_offset_get(struct snd_kcontrol *ctl, | ||
840 | struct snd_ctl_elem_value *value) | ||
841 | { | ||
842 | struct oxygen *chip = ctl->private_data; | ||
843 | struct xonar_pcm179x *data = chip->model_data; | ||
844 | |||
845 | mutex_lock(&chip->mutex); | ||
846 | if (data->hp_gain_offset < 2*-6) | ||
847 | value->value.enumerated.item[0] = 0; | ||
848 | else if (data->hp_gain_offset < 0) | ||
849 | value->value.enumerated.item[0] = 1; | ||
850 | else | ||
851 | value->value.enumerated.item[0] = 2; | ||
852 | mutex_unlock(&chip->mutex); | ||
853 | return 0; | ||
854 | } | ||
855 | |||
856 | |||
857 | static int st_hp_volume_offset_put(struct snd_kcontrol *ctl, | ||
858 | struct snd_ctl_elem_value *value) | ||
859 | { | ||
860 | static const s8 offsets[] = { 2*-18, 2*-6, 0 }; | ||
861 | struct oxygen *chip = ctl->private_data; | ||
862 | struct xonar_pcm179x *data = chip->model_data; | ||
863 | s8 offset; | ||
864 | int changed; | ||
865 | |||
866 | if (value->value.enumerated.item[0] > 2) | ||
867 | return -EINVAL; | ||
868 | offset = offsets[value->value.enumerated.item[0]]; | ||
869 | mutex_lock(&chip->mutex); | ||
870 | changed = offset != data->hp_gain_offset; | ||
871 | if (changed) { | ||
872 | data->hp_gain_offset = offset; | ||
873 | update_pcm1796_volume(chip); | ||
874 | } | ||
875 | mutex_unlock(&chip->mutex); | ||
876 | return changed; | ||
877 | } | ||
878 | |||
879 | static const struct snd_kcontrol_new st_controls[] = { | ||
880 | { | ||
881 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
882 | .name = "Analog Output", | ||
883 | .info = st_output_switch_info, | ||
884 | .get = st_output_switch_get, | ||
885 | .put = st_output_switch_put, | ||
886 | }, | ||
887 | { | ||
888 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
889 | .name = "Headphones Impedance Playback Enum", | ||
890 | .info = st_hp_volume_offset_info, | ||
891 | .get = st_hp_volume_offset_get, | ||
892 | .put = st_hp_volume_offset_put, | ||
893 | }, | ||
894 | }; | ||
895 | |||
896 | static void xonar_line_mic_ac97_switch(struct oxygen *chip, | ||
897 | unsigned int reg, unsigned int mute) | ||
898 | { | ||
899 | if (reg == AC97_LINE) { | ||
900 | spin_lock_irq(&chip->reg_lock); | ||
901 | oxygen_write16_masked(chip, OXYGEN_GPIO_DATA, | ||
902 | mute ? GPIO_INPUT_ROUTE : 0, | ||
903 | GPIO_INPUT_ROUTE); | ||
904 | spin_unlock_irq(&chip->reg_lock); | ||
905 | } | ||
906 | } | ||
907 | |||
908 | static const DECLARE_TLV_DB_SCALE(pcm1796_db_scale, -6000, 50, 0); | ||
909 | |||
910 | static int xonar_d2_control_filter(struct snd_kcontrol_new *template) | ||
911 | { | ||
912 | if (!strncmp(template->name, "CD Capture ", 11)) | ||
913 | /* CD in is actually connected to the video in pin */ | ||
914 | template->private_value ^= AC97_CD ^ AC97_VIDEO; | ||
915 | return 0; | ||
916 | } | ||
917 | |||
918 | static int xonar_st_control_filter(struct snd_kcontrol_new *template) | ||
919 | { | ||
920 | if (!strncmp(template->name, "CD Capture ", 11)) | ||
921 | return 1; /* no CD input */ | ||
922 | return 0; | ||
923 | } | ||
924 | |||
925 | static int add_pcm1796_controls(struct oxygen *chip) | ||
926 | { | ||
927 | int err; | ||
928 | |||
929 | err = snd_ctl_add(chip->card, snd_ctl_new1(&rolloff_control, chip)); | ||
930 | if (err < 0) | ||
931 | return err; | ||
932 | err = snd_ctl_add(chip->card, snd_ctl_new1(&os_128_control, chip)); | ||
933 | if (err < 0) | ||
934 | return err; | ||
935 | return 0; | ||
936 | } | ||
937 | |||
938 | static int xonar_d2_mixer_init(struct oxygen *chip) | ||
939 | { | ||
940 | int err; | ||
941 | |||
942 | err = snd_ctl_add(chip->card, snd_ctl_new1(&alt_switch, chip)); | ||
943 | if (err < 0) | ||
944 | return err; | ||
945 | err = add_pcm1796_controls(chip); | ||
946 | if (err < 0) | ||
947 | return err; | ||
948 | return 0; | ||
949 | } | ||
950 | |||
951 | static int xonar_hdav_mixer_init(struct oxygen *chip) | ||
952 | { | ||
953 | return add_pcm1796_controls(chip); | ||
954 | } | ||
955 | |||
956 | static int xonar_st_mixer_init(struct oxygen *chip) | ||
957 | { | ||
958 | unsigned int i; | ||
959 | int err; | ||
960 | |||
961 | for (i = 0; i < ARRAY_SIZE(st_controls); ++i) { | ||
962 | err = snd_ctl_add(chip->card, | ||
963 | snd_ctl_new1(&st_controls[i], chip)); | ||
964 | if (err < 0) | ||
965 | return err; | ||
966 | } | ||
967 | err = add_pcm1796_controls(chip); | ||
968 | if (err < 0) | ||
969 | return err; | ||
970 | return 0; | ||
971 | } | ||
972 | |||
973 | static const struct oxygen_model model_xonar_d2 = { | ||
974 | .longname = "Asus Virtuoso 200", | ||
975 | .chip = "AV200", | ||
976 | .init = xonar_d2_init, | ||
977 | .control_filter = xonar_d2_control_filter, | ||
978 | .mixer_init = xonar_d2_mixer_init, | ||
979 | .cleanup = xonar_d2_cleanup, | ||
980 | .suspend = xonar_d2_suspend, | ||
981 | .resume = xonar_d2_resume, | ||
982 | .get_i2s_mclk = get_pcm1796_i2s_mclk, | ||
983 | .set_dac_params = set_pcm1796_params, | ||
984 | .set_adc_params = xonar_set_cs53x1_params, | ||
985 | .update_dac_volume = update_pcm1796_volume, | ||
986 | .update_dac_mute = update_pcm1796_mute, | ||
987 | .dac_tlv = pcm1796_db_scale, | ||
988 | .model_data_size = sizeof(struct xonar_pcm179x), | ||
989 | .device_config = PLAYBACK_0_TO_I2S | | ||
990 | PLAYBACK_1_TO_SPDIF | | ||
991 | CAPTURE_0_FROM_I2S_2 | | ||
992 | CAPTURE_1_FROM_SPDIF | | ||
993 | MIDI_OUTPUT | | ||
994 | MIDI_INPUT, | ||
995 | .dac_channels = 8, | ||
996 | .dac_volume_min = 255 - 2*60, | ||
997 | .dac_volume_max = 255, | ||
998 | .misc_flags = OXYGEN_MISC_MIDI, | ||
999 | .function_flags = OXYGEN_FUNCTION_SPI | | ||
1000 | OXYGEN_FUNCTION_ENABLE_SPI_4_5, | ||
1001 | .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST, | ||
1002 | .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST, | ||
1003 | }; | ||
1004 | |||
1005 | static const struct oxygen_model model_xonar_hdav = { | ||
1006 | .longname = "Asus Virtuoso 200", | ||
1007 | .chip = "AV200", | ||
1008 | .init = xonar_hdav_init, | ||
1009 | .mixer_init = xonar_hdav_mixer_init, | ||
1010 | .cleanup = xonar_hdav_cleanup, | ||
1011 | .suspend = xonar_hdav_suspend, | ||
1012 | .resume = xonar_hdav_resume, | ||
1013 | .pcm_hardware_filter = xonar_hdmi_pcm_hardware_filter, | ||
1014 | .get_i2s_mclk = get_pcm1796_i2s_mclk, | ||
1015 | .set_dac_params = set_hdav_params, | ||
1016 | .set_adc_params = xonar_set_cs53x1_params, | ||
1017 | .update_dac_volume = update_pcm1796_volume, | ||
1018 | .update_dac_mute = update_pcm1796_mute, | ||
1019 | .uart_input = xonar_hdmi_uart_input, | ||
1020 | .ac97_switch = xonar_line_mic_ac97_switch, | ||
1021 | .dac_tlv = pcm1796_db_scale, | ||
1022 | .model_data_size = sizeof(struct xonar_hdav), | ||
1023 | .device_config = PLAYBACK_0_TO_I2S | | ||
1024 | PLAYBACK_1_TO_SPDIF | | ||
1025 | CAPTURE_0_FROM_I2S_2 | | ||
1026 | CAPTURE_1_FROM_SPDIF, | ||
1027 | .dac_channels = 8, | ||
1028 | .dac_volume_min = 255 - 2*60, | ||
1029 | .dac_volume_max = 255, | ||
1030 | .misc_flags = OXYGEN_MISC_MIDI, | ||
1031 | .function_flags = OXYGEN_FUNCTION_2WIRE, | ||
1032 | .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST, | ||
1033 | .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST, | ||
1034 | }; | ||
1035 | |||
1036 | static const struct oxygen_model model_xonar_st = { | ||
1037 | .longname = "Asus Virtuoso 100", | ||
1038 | .chip = "AV200", | ||
1039 | .init = xonar_st_init, | ||
1040 | .control_filter = xonar_st_control_filter, | ||
1041 | .mixer_init = xonar_st_mixer_init, | ||
1042 | .cleanup = xonar_st_cleanup, | ||
1043 | .suspend = xonar_st_suspend, | ||
1044 | .resume = xonar_st_resume, | ||
1045 | .get_i2s_mclk = get_pcm1796_i2s_mclk, | ||
1046 | .set_dac_params = set_st_params, | ||
1047 | .set_adc_params = xonar_set_cs53x1_params, | ||
1048 | .update_dac_volume = update_pcm1796_volume, | ||
1049 | .update_dac_mute = update_pcm1796_mute, | ||
1050 | .ac97_switch = xonar_line_mic_ac97_switch, | ||
1051 | .dac_tlv = pcm1796_db_scale, | ||
1052 | .model_data_size = sizeof(struct xonar_pcm179x), | ||
1053 | .device_config = PLAYBACK_0_TO_I2S | | ||
1054 | PLAYBACK_1_TO_SPDIF | | ||
1055 | CAPTURE_0_FROM_I2S_2, | ||
1056 | .dac_channels = 2, | ||
1057 | .dac_volume_min = 255 - 2*60, | ||
1058 | .dac_volume_max = 255, | ||
1059 | .function_flags = OXYGEN_FUNCTION_2WIRE, | ||
1060 | .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST, | ||
1061 | .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST, | ||
1062 | }; | ||
1063 | |||
1064 | int __devinit get_xonar_pcm179x_model(struct oxygen *chip, | ||
1065 | const struct pci_device_id *id) | ||
1066 | { | ||
1067 | switch (id->subdevice) { | ||
1068 | case 0x8269: | ||
1069 | chip->model = model_xonar_d2; | ||
1070 | chip->model.shortname = "Xonar D2"; | ||
1071 | break; | ||
1072 | case 0x82b7: | ||
1073 | chip->model = model_xonar_d2; | ||
1074 | chip->model.shortname = "Xonar D2X"; | ||
1075 | chip->model.init = xonar_d2x_init; | ||
1076 | break; | ||
1077 | case 0x8314: | ||
1078 | chip->model = model_xonar_hdav; | ||
1079 | oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK); | ||
1080 | switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) & GPIO_DB_MASK) { | ||
1081 | default: | ||
1082 | chip->model.shortname = "Xonar HDAV1.3"; | ||
1083 | break; | ||
1084 | case GPIO_DB_H6: | ||
1085 | chip->model.shortname = "Xonar HDAV1.3+H6"; | ||
1086 | chip->model.private_data = 1; | ||
1087 | break; | ||
1088 | } | ||
1089 | break; | ||
1090 | case 0x835d: | ||
1091 | chip->model = model_xonar_st; | ||
1092 | oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK); | ||
1093 | switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) & GPIO_DB_MASK) { | ||
1094 | default: | ||
1095 | chip->model.shortname = "Xonar ST"; | ||
1096 | break; | ||
1097 | case GPIO_DB_H6: | ||
1098 | chip->model.shortname = "Xonar ST+H6"; | ||
1099 | chip->model.dac_channels = 8; | ||
1100 | chip->model.private_data = 1; | ||
1101 | break; | ||
1102 | } | ||
1103 | break; | ||
1104 | case 0x835c: | ||
1105 | chip->model = model_xonar_st; | ||
1106 | chip->model.shortname = "Xonar STX"; | ||
1107 | chip->model.init = xonar_stx_init; | ||
1108 | chip->model.resume = xonar_stx_resume; | ||
1109 | chip->model.set_dac_params = set_pcm1796_params; | ||
1110 | break; | ||
1111 | default: | ||
1112 | return -EINVAL; | ||
1113 | } | ||
1114 | return 0; | ||
1115 | } | ||