1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2006 Stephane E. Potvin <sepotvin@videotron.ca>
5 * Copyright (c) 2006 Ariff Abdullah <ariff@FreeBSD.org>
6 * Copyright (c) 2008-2012 Alexander Motin <mav@FreeBSD.org>
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * SUCH DAMAGE.
29 */
30
31 /*
32 * Intel High Definition Audio (CODEC) driver for FreeBSD.
33 */
34
35 #ifdef HAVE_KERNEL_OPTION_HEADERS
36 #include "opt_snd.h"
37 #endif
38
39 #include <dev/sound/pcm/sound.h>
40
41 #include <sys/ctype.h>
42
43 #include <dev/sound/pci/hda/hda_reg.h>
44 #include <dev/sound/pci/hda/hdac.h>
45
46 struct hdacc_fg {
47 device_t dev;
48 nid_t nid;
49 uint8_t type;
50 uint32_t subsystem_id;
51 };
52
53 struct hdacc_softc {
54 device_t dev;
55 struct mtx *lock;
56 nid_t cad;
57 device_t streams[2][16];
58 device_t tags[64];
59 int fgcnt;
60 struct hdacc_fg *fgs;
61 };
62
63 #define hdacc_lock(codec) snd_mtxlock((codec)->lock)
64 #define hdacc_unlock(codec) snd_mtxunlock((codec)->lock)
65 #define hdacc_lockassert(codec) snd_mtxassert((codec)->lock)
66
67 MALLOC_DEFINE(M_HDACC, "hdacc", "HDA CODEC");
68
69 /* CODECs */
70 static const struct {
71 uint32_t id;
72 uint16_t revid;
73 const char *name;
74 } hdacc_codecs[] = {
75 { HDA_CODEC_CS4206, 0, "Cirrus Logic CS4206" },
76 { HDA_CODEC_CS4207, 0, "Cirrus Logic CS4207" },
77 { HDA_CODEC_CS4208, 0, "Cirrus Logic CS4208" },
78 { HDA_CODEC_CS4210, 0, "Cirrus Logic CS4210" },
79 { HDA_CODEC_ALC215, 0, "Realtek ALC215" },
80 { HDA_CODEC_ALC221, 0, "Realtek ALC221" },
81 { HDA_CODEC_ALC222, 0, "Realtek ALC222" },
82 { HDA_CODEC_ALC225, 0, "Realtek ALC225" },
83 { HDA_CODEC_ALC230, 0, "Realtek ALC230" },
84 { HDA_CODEC_ALC231, 0, "Realtek ALC231" },
85 { HDA_CODEC_ALC233, 0, "Realtek ALC233" },
86 { HDA_CODEC_ALC234, 0, "Realtek ALC234" },
87 { HDA_CODEC_ALC235, 0, "Realtek ALC235" },
88 { HDA_CODEC_ALC236, 0, "Realtek ALC236" },
89 { HDA_CODEC_ALC245, 0, "Realtek ALC245" },
90 { HDA_CODEC_ALC255, 0, "Realtek ALC255" },
91 { HDA_CODEC_ALC256, 0, "Realtek ALC256" },
92 { HDA_CODEC_ALC257, 0, "Realtek ALC257" },
93 { HDA_CODEC_ALC260, 0, "Realtek ALC260" },
94 { HDA_CODEC_ALC262, 0, "Realtek ALC262" },
95 { HDA_CODEC_ALC267, 0, "Realtek ALC267" },
96 { HDA_CODEC_ALC268, 0, "Realtek ALC268" },
97 { HDA_CODEC_ALC269, 0, "Realtek ALC269" },
98 { HDA_CODEC_ALC270, 0, "Realtek ALC270" },
99 { HDA_CODEC_ALC272, 0, "Realtek ALC272" },
100 { HDA_CODEC_ALC273, 0, "Realtek ALC273" },
101 { HDA_CODEC_ALC274, 0, "Realtek ALC274" },
102 { HDA_CODEC_ALC275, 0, "Realtek ALC275" },
103 { HDA_CODEC_ALC276, 0, "Realtek ALC276" },
104 { HDA_CODEC_ALC292, 0, "Realtek ALC292" },
105 { HDA_CODEC_ALC295, 0, "Realtek ALC295" },
106 { HDA_CODEC_ALC280, 0, "Realtek ALC280" },
107 { HDA_CODEC_ALC282, 0, "Realtek ALC282" },
108 { HDA_CODEC_ALC283, 0, "Realtek ALC283" },
109 { HDA_CODEC_ALC284, 0, "Realtek ALC284" },
110 { HDA_CODEC_ALC285, 0, "Realtek ALC285" },
111 { HDA_CODEC_ALC286, 0, "Realtek ALC286" },
112 { HDA_CODEC_ALC288, 0, "Realtek ALC288" },
113 { HDA_CODEC_ALC289, 0, "Realtek ALC289" },
114 { HDA_CODEC_ALC290, 0, "Realtek ALC290" },
115 { HDA_CODEC_ALC292, 0, "Realtek ALC292" },
116 { HDA_CODEC_ALC293, 0, "Realtek ALC293" },
117 { HDA_CODEC_ALC294, 0, "Realtek ALC294" },
118 { HDA_CODEC_ALC295, 0, "Realtek ALC295" },
119 { HDA_CODEC_ALC298, 0, "Realtek ALC298" },
120 { HDA_CODEC_ALC299, 0, "Realtek ALC299" },
121 { HDA_CODEC_ALC300, 0, "Realtek ALC300" },
122 { HDA_CODEC_ALC623, 0, "Realtek ALC623" },
123 { HDA_CODEC_ALC660, 0, "Realtek ALC660-VD" },
124 { HDA_CODEC_ALC662, 0x0002, "Realtek ALC662 rev2" },
125 { HDA_CODEC_ALC662, 0x0101, "Realtek ALC662 rev1" },
126 { HDA_CODEC_ALC662, 0x0300, "Realtek ALC662 rev3" },
127 { HDA_CODEC_ALC662, 0, "Realtek ALC662" },
128 { HDA_CODEC_ALC663, 0, "Realtek ALC663" },
129 { HDA_CODEC_ALC665, 0, "Realtek ALC665" },
130 { HDA_CODEC_ALC670, 0, "Realtek ALC670" },
131 { HDA_CODEC_ALC671, 0, "Realtek ALC671" },
132 { HDA_CODEC_ALC680, 0, "Realtek ALC680" },
133 { HDA_CODEC_ALC700, 0, "Realtek ALC700" },
134 { HDA_CODEC_ALC701, 0, "Realtek ALC701" },
135 { HDA_CODEC_ALC703, 0, "Realtek ALC703" },
136 { HDA_CODEC_ALC861, 0x0340, "Realtek ALC660" },
137 { HDA_CODEC_ALC861, 0, "Realtek ALC861" },
138 { HDA_CODEC_ALC861VD, 0, "Realtek ALC861-VD" },
139 { HDA_CODEC_ALC880, 0, "Realtek ALC880" },
140 { HDA_CODEC_ALC882, 0, "Realtek ALC882" },
141 { HDA_CODEC_ALC883, 0, "Realtek ALC883" },
142 { HDA_CODEC_ALC885, 0x0101, "Realtek ALC889A" },
143 { HDA_CODEC_ALC885, 0x0103, "Realtek ALC889A" },
144 { HDA_CODEC_ALC885, 0, "Realtek ALC885" },
145 { HDA_CODEC_ALC887, 0, "Realtek ALC887" },
146 { HDA_CODEC_ALC888, 0x0101, "Realtek ALC1200" },
147 { HDA_CODEC_ALC888, 0, "Realtek ALC888" },
148 { HDA_CODEC_ALC889, 0, "Realtek ALC889" },
149 { HDA_CODEC_ALC892, 0, "Realtek ALC892" },
150 { HDA_CODEC_ALC897, 0, "Realtek ALC897" },
151 { HDA_CODEC_ALC898, 0, "Realtek ALC898" },
152 { HDA_CODEC_ALC899, 0, "Realtek ALC899" },
153 { HDA_CODEC_ALC1150, 0, "Realtek ALC1150" },
154 { HDA_CODEC_ALCS1200A, 0, "Realtek ALCS1200A" },
155 { HDA_CODEC_ALC1220_1, 0, "Realtek ALC1220" },
156 { HDA_CODEC_ALC1220, 0, "Realtek ALC1220" },
157 { HDA_CODEC_AD1882, 0, "Analog Devices AD1882" },
158 { HDA_CODEC_AD1882A, 0, "Analog Devices AD1882A" },
159 { HDA_CODEC_AD1883, 0, "Analog Devices AD1883" },
160 { HDA_CODEC_AD1884, 0, "Analog Devices AD1884" },
161 { HDA_CODEC_AD1884A, 0, "Analog Devices AD1884A" },
162 { HDA_CODEC_AD1981HD, 0, "Analog Devices AD1981HD" },
163 { HDA_CODEC_AD1983, 0, "Analog Devices AD1983" },
164 { HDA_CODEC_AD1984, 0, "Analog Devices AD1984" },
165 { HDA_CODEC_AD1984A, 0, "Analog Devices AD1984A" },
166 { HDA_CODEC_AD1984B, 0, "Analog Devices AD1984B" },
167 { HDA_CODEC_AD1986A, 0, "Analog Devices AD1986A" },
168 { HDA_CODEC_AD1987, 0, "Analog Devices AD1987" },
169 { HDA_CODEC_AD1988, 0, "Analog Devices AD1988A" },
170 { HDA_CODEC_AD1988B, 0, "Analog Devices AD1988B" },
171 { HDA_CODEC_AD1989A, 0, "Analog Devices AD1989A" },
172 { HDA_CODEC_AD1989B, 0, "Analog Devices AD1989B" },
173 { HDA_CODEC_CA0110, 0, "Creative CA0110-IBG" },
174 { HDA_CODEC_CA0110_2, 0, "Creative CA0110-IBG" },
175 { HDA_CODEC_CA0132, 0, "Creative CA0132" },
176 { HDA_CODEC_SB0880, 0, "Creative SB0880 X-Fi" },
177 { HDA_CODEC_CMI9880, 0, "CMedia CMI9880" },
178 { HDA_CODEC_CMI98802, 0, "CMedia CMI9880" },
179 { HDA_CODEC_CXD9872RDK, 0, "Sigmatel CXD9872RD/K" },
180 { HDA_CODEC_CXD9872AKD, 0, "Sigmatel CXD9872AKD" },
181 { HDA_CODEC_STAC9200D, 0, "Sigmatel STAC9200D" },
182 { HDA_CODEC_STAC9204X, 0, "Sigmatel STAC9204X" },
183 { HDA_CODEC_STAC9204D, 0, "Sigmatel STAC9204D" },
184 { HDA_CODEC_STAC9205X, 0, "Sigmatel STAC9205X" },
185 { HDA_CODEC_STAC9205D, 0, "Sigmatel STAC9205D" },
186 { HDA_CODEC_STAC9220, 0, "Sigmatel STAC9220" },
187 { HDA_CODEC_STAC9220_A1, 0, "Sigmatel STAC9220_A1" },
188 { HDA_CODEC_STAC9220_A2, 0, "Sigmatel STAC9220_A2" },
189 { HDA_CODEC_STAC9221, 0, "Sigmatel STAC9221" },
190 { HDA_CODEC_STAC9221_A2, 0, "Sigmatel STAC9221_A2" },
191 { HDA_CODEC_STAC9221D, 0, "Sigmatel STAC9221D" },
192 { HDA_CODEC_STAC922XD, 0, "Sigmatel STAC9220D/9223D" },
193 { HDA_CODEC_STAC9227X, 0, "Sigmatel STAC9227X" },
194 { HDA_CODEC_STAC9227D, 0, "Sigmatel STAC9227D" },
195 { HDA_CODEC_STAC9228X, 0, "Sigmatel STAC9228X" },
196 { HDA_CODEC_STAC9228D, 0, "Sigmatel STAC9228D" },
197 { HDA_CODEC_STAC9229X, 0, "Sigmatel STAC9229X" },
198 { HDA_CODEC_STAC9229D, 0, "Sigmatel STAC9229D" },
199 { HDA_CODEC_STAC9230X, 0, "Sigmatel STAC9230X" },
200 { HDA_CODEC_STAC9230D, 0, "Sigmatel STAC9230D" },
201 { HDA_CODEC_STAC9250, 0, "Sigmatel STAC9250" },
202 { HDA_CODEC_STAC9251, 0, "Sigmatel STAC9251" },
203 { HDA_CODEC_STAC9255, 0, "Sigmatel STAC9255" },
204 { HDA_CODEC_STAC9255D, 0, "Sigmatel STAC9255D" },
205 { HDA_CODEC_STAC9254, 0, "Sigmatel STAC9254" },
206 { HDA_CODEC_STAC9254D, 0, "Sigmatel STAC9254D" },
207 { HDA_CODEC_STAC9271X, 0, "Sigmatel STAC9271X" },
208 { HDA_CODEC_STAC9271D, 0, "Sigmatel STAC9271D" },
209 { HDA_CODEC_STAC9272X, 0, "Sigmatel STAC9272X" },
210 { HDA_CODEC_STAC9272D, 0, "Sigmatel STAC9272D" },
211 { HDA_CODEC_STAC9273X, 0, "Sigmatel STAC9273X" },
212 { HDA_CODEC_STAC9273D, 0, "Sigmatel STAC9273D" },
213 { HDA_CODEC_STAC9274, 0, "Sigmatel STAC9274" },
214 { HDA_CODEC_STAC9274D, 0, "Sigmatel STAC9274D" },
215 { HDA_CODEC_STAC9274X5NH, 0, "Sigmatel STAC9274X5NH" },
216 { HDA_CODEC_STAC9274D5NH, 0, "Sigmatel STAC9274D5NH" },
217 { HDA_CODEC_STAC9872AK, 0, "Sigmatel STAC9872AK" },
218 { HDA_CODEC_IDT92HD005, 0, "IDT 92HD005" },
219 { HDA_CODEC_IDT92HD005D, 0, "IDT 92HD005D" },
220 { HDA_CODEC_IDT92HD206X, 0, "IDT 92HD206X" },
221 { HDA_CODEC_IDT92HD206D, 0, "IDT 92HD206D" },
222 { HDA_CODEC_IDT92HD66B1X5, 0, "IDT 92HD66B1X5" },
223 { HDA_CODEC_IDT92HD66B2X5, 0, "IDT 92HD66B2X5" },
224 { HDA_CODEC_IDT92HD66B3X5, 0, "IDT 92HD66B3X5" },
225 { HDA_CODEC_IDT92HD66C1X5, 0, "IDT 92HD66C1X5" },
226 { HDA_CODEC_IDT92HD66C2X5, 0, "IDT 92HD66C2X5" },
227 { HDA_CODEC_IDT92HD66C3X5, 0, "IDT 92HD66C3X5" },
228 { HDA_CODEC_IDT92HD66B1X3, 0, "IDT 92HD66B1X3" },
229 { HDA_CODEC_IDT92HD66B2X3, 0, "IDT 92HD66B2X3" },
230 { HDA_CODEC_IDT92HD66B3X3, 0, "IDT 92HD66B3X3" },
231 { HDA_CODEC_IDT92HD66C1X3, 0, "IDT 92HD66C1X3" },
232 { HDA_CODEC_IDT92HD66C2X3, 0, "IDT 92HD66C2X3" },
233 { HDA_CODEC_IDT92HD66C3_65, 0, "IDT 92HD66C3_65" },
234 { HDA_CODEC_IDT92HD700X, 0, "IDT 92HD700X" },
235 { HDA_CODEC_IDT92HD700D, 0, "IDT 92HD700D" },
236 { HDA_CODEC_IDT92HD71B5, 0, "IDT 92HD71B5" },
237 { HDA_CODEC_IDT92HD71B5_2, 0, "IDT 92HD71B5" },
238 { HDA_CODEC_IDT92HD71B6, 0, "IDT 92HD71B6" },
239 { HDA_CODEC_IDT92HD71B6_2, 0, "IDT 92HD71B6" },
240 { HDA_CODEC_IDT92HD71B7, 0, "IDT 92HD71B7" },
241 { HDA_CODEC_IDT92HD71B7_2, 0, "IDT 92HD71B7" },
242 { HDA_CODEC_IDT92HD71B8, 0, "IDT 92HD71B8" },
243 { HDA_CODEC_IDT92HD71B8_2, 0, "IDT 92HD71B8" },
244 { HDA_CODEC_IDT92HD73C1, 0, "IDT 92HD73C1" },
245 { HDA_CODEC_IDT92HD73D1, 0, "IDT 92HD73D1" },
246 { HDA_CODEC_IDT92HD73E1, 0, "IDT 92HD73E1" },
247 { HDA_CODEC_IDT92HD75B3, 0, "IDT 92HD75B3" },
248 { HDA_CODEC_IDT92HD75BX, 0, "IDT 92HD75BX" },
249 { HDA_CODEC_IDT92HD81B1C, 0, "IDT 92HD81B1C" },
250 { HDA_CODEC_IDT92HD81B1X, 0, "IDT 92HD81B1X" },
251 { HDA_CODEC_IDT92HD83C1C, 0, "IDT 92HD83C1C" },
252 { HDA_CODEC_IDT92HD83C1X, 0, "IDT 92HD83C1X" },
253 { HDA_CODEC_IDT92HD87B1_3, 0, "IDT 92HD87B1/3" },
254 { HDA_CODEC_IDT92HD87B2_4, 0, "IDT 92HD87B2/4" },
255 { HDA_CODEC_IDT92HD89C3, 0, "IDT 92HD89C3" },
256 { HDA_CODEC_IDT92HD89C2, 0, "IDT 92HD89C2" },
257 { HDA_CODEC_IDT92HD89C1, 0, "IDT 92HD89C1" },
258 { HDA_CODEC_IDT92HD89B3, 0, "IDT 92HD89B3" },
259 { HDA_CODEC_IDT92HD89B2, 0, "IDT 92HD89B2" },
260 { HDA_CODEC_IDT92HD89B1, 0, "IDT 92HD89B1" },
261 { HDA_CODEC_IDT92HD89E3, 0, "IDT 92HD89E3" },
262 { HDA_CODEC_IDT92HD89E2, 0, "IDT 92HD89E2" },
263 { HDA_CODEC_IDT92HD89E1, 0, "IDT 92HD89E1" },
264 { HDA_CODEC_IDT92HD89D3, 0, "IDT 92HD89D3" },
265 { HDA_CODEC_IDT92HD89D2, 0, "IDT 92HD89D2" },
266 { HDA_CODEC_IDT92HD89D1, 0, "IDT 92HD89D1" },
267 { HDA_CODEC_IDT92HD89F3, 0, "IDT 92HD89F3" },
268 { HDA_CODEC_IDT92HD89F2, 0, "IDT 92HD89F2" },
269 { HDA_CODEC_IDT92HD89F1, 0, "IDT 92HD89F1" },
270 { HDA_CODEC_IDT92HD90BXX, 0, "IDT 92HD90BXX" },
271 { HDA_CODEC_IDT92HD91BXX, 0, "IDT 92HD91BXX" },
272 { HDA_CODEC_IDT92HD93BXX, 0, "IDT 92HD93BXX" },
273 { HDA_CODEC_IDT92HD95B, 0, "Tempo 92HD95B" },
274 { HDA_CODEC_IDT92HD98BXX, 0, "IDT 92HD98BXX" },
275 { HDA_CODEC_IDT92HD99BXX, 0, "IDT 92HD99BXX" },
276 { HDA_CODEC_CX20549, 0, "Conexant CX20549 (Venice)" },
277 { HDA_CODEC_CX20551, 0, "Conexant CX20551 (Waikiki)" },
278 { HDA_CODEC_CX20561, 0, "Conexant CX20561 (Hermosa)" },
279 { HDA_CODEC_CX20582, 0, "Conexant CX20582 (Pebble)" },
280 { HDA_CODEC_CX20583, 0, "Conexant CX20583 (Pebble HSF)" },
281 { HDA_CODEC_CX20584, 0, "Conexant CX20584" },
282 { HDA_CODEC_CX20585, 0, "Conexant CX20585" },
283 { HDA_CODEC_CX20588, 0, "Conexant CX20588" },
284 { HDA_CODEC_CX20590, 0, "Conexant CX20590" },
285 { HDA_CODEC_CX20631, 0, "Conexant CX20631" },
286 { HDA_CODEC_CX20632, 0, "Conexant CX20632" },
287 { HDA_CODEC_CX20641, 0, "Conexant CX20641" },
288 { HDA_CODEC_CX20642, 0, "Conexant CX20642" },
289 { HDA_CODEC_CX20651, 0, "Conexant CX20651" },
290 { HDA_CODEC_CX20652, 0, "Conexant CX20652" },
291 { HDA_CODEC_CX20664, 0, "Conexant CX20664" },
292 { HDA_CODEC_CX20665, 0, "Conexant CX20665" },
293 { HDA_CODEC_CX21722, 0, "Conexant CX21722" },
294 { HDA_CODEC_CX20722, 0, "Conexant CX20722" },
295 { HDA_CODEC_CX21724, 0, "Conexant CX21724" },
296 { HDA_CODEC_CX20724, 0, "Conexant CX20724" },
297 { HDA_CODEC_CX20751, 0, "Conexant CX20751/2" },
298 { HDA_CODEC_CX20751_2, 0, "Conexant CX20751/2" },
299 { HDA_CODEC_CX20753, 0, "Conexant CX20753/4" },
300 { HDA_CODEC_CX20755, 0, "Conexant CX20755" },
301 { HDA_CODEC_CX20756, 0, "Conexant CX20756" },
302 { HDA_CODEC_CX20757, 0, "Conexant CX20757" },
303 { HDA_CODEC_CX20952, 0, "Conexant CX20952" },
304 { HDA_CODEC_VT1708_8, 0, "VIA VT1708_8" },
305 { HDA_CODEC_VT1708_9, 0, "VIA VT1708_9" },
306 { HDA_CODEC_VT1708_A, 0, "VIA VT1708_A" },
307 { HDA_CODEC_VT1708_B, 0, "VIA VT1708_B" },
308 { HDA_CODEC_VT1709_0, 0, "VIA VT1709_0" },
309 { HDA_CODEC_VT1709_1, 0, "VIA VT1709_1" },
310 { HDA_CODEC_VT1709_2, 0, "VIA VT1709_2" },
311 { HDA_CODEC_VT1709_3, 0, "VIA VT1709_3" },
312 { HDA_CODEC_VT1709_4, 0, "VIA VT1709_4" },
313 { HDA_CODEC_VT1709_5, 0, "VIA VT1709_5" },
314 { HDA_CODEC_VT1709_6, 0, "VIA VT1709_6" },
315 { HDA_CODEC_VT1709_7, 0, "VIA VT1709_7" },
316 { HDA_CODEC_VT1708B_0, 0, "VIA VT1708B_0" },
317 { HDA_CODEC_VT1708B_1, 0, "VIA VT1708B_1" },
318 { HDA_CODEC_VT1708B_2, 0, "VIA VT1708B_2" },
319 { HDA_CODEC_VT1708B_3, 0, "VIA VT1708B_3" },
320 { HDA_CODEC_VT1708B_4, 0, "VIA VT1708B_4" },
321 { HDA_CODEC_VT1708B_5, 0, "VIA VT1708B_5" },
322 { HDA_CODEC_VT1708B_6, 0, "VIA VT1708B_6" },
323 { HDA_CODEC_VT1708B_7, 0, "VIA VT1708B_7" },
324 { HDA_CODEC_VT1708S_0, 0, "VIA VT1708S_0" },
325 { HDA_CODEC_VT1708S_1, 0, "VIA VT1708S_1" },
326 { HDA_CODEC_VT1708S_2, 0, "VIA VT1708S_2" },
327 { HDA_CODEC_VT1708S_3, 0, "VIA VT1708S_3" },
328 { HDA_CODEC_VT1708S_4, 0, "VIA VT1708S_4" },
329 { HDA_CODEC_VT1708S_5, 0, "VIA VT1708S_5" },
330 { HDA_CODEC_VT1708S_6, 0, "VIA VT1708S_6" },
331 { HDA_CODEC_VT1708S_7, 0, "VIA VT1708S_7" },
332 { HDA_CODEC_VT1702_0, 0, "VIA VT1702_0" },
333 { HDA_CODEC_VT1702_1, 0, "VIA VT1702_1" },
334 { HDA_CODEC_VT1702_2, 0, "VIA VT1702_2" },
335 { HDA_CODEC_VT1702_3, 0, "VIA VT1702_3" },
336 { HDA_CODEC_VT1702_4, 0, "VIA VT1702_4" },
337 { HDA_CODEC_VT1702_5, 0, "VIA VT1702_5" },
338 { HDA_CODEC_VT1702_6, 0, "VIA VT1702_6" },
339 { HDA_CODEC_VT1702_7, 0, "VIA VT1702_7" },
340 { HDA_CODEC_VT1716S_0, 0, "VIA VT1716S_0" },
341 { HDA_CODEC_VT1716S_1, 0, "VIA VT1716S_1" },
342 { HDA_CODEC_VT1718S_0, 0, "VIA VT1718S_0" },
343 { HDA_CODEC_VT1718S_1, 0, "VIA VT1718S_1" },
344 { HDA_CODEC_VT1802_0, 0, "VIA VT1802_0" },
345 { HDA_CODEC_VT1802_1, 0, "VIA VT1802_1" },
346 { HDA_CODEC_VT1812, 0, "VIA VT1812" },
347 { HDA_CODEC_VT1818S, 0, "VIA VT1818S" },
348 { HDA_CODEC_VT1828S, 0, "VIA VT1828S" },
349 { HDA_CODEC_VT2002P_0, 0, "VIA VT2002P_0" },
350 { HDA_CODEC_VT2002P_1, 0, "VIA VT2002P_1" },
351 { HDA_CODEC_VT2020, 0, "VIA VT2020" },
352 { HDA_CODEC_ATIRS600_1, 0, "ATI RS600" },
353 { HDA_CODEC_ATIRS600_2, 0, "ATI RS600" },
354 { HDA_CODEC_ATIRS690, 0, "ATI RS690/780" },
355 { HDA_CODEC_ATIR6XX, 0, "ATI R6xx" },
356 { HDA_CODEC_NVIDIAMCP67, 0, "NVIDIA MCP67" },
357 { HDA_CODEC_NVIDIAMCP73, 0, "NVIDIA MCP73" },
358 { HDA_CODEC_NVIDIAMCP78, 0, "NVIDIA MCP78" },
359 { HDA_CODEC_NVIDIAMCP78_2, 0, "NVIDIA MCP78" },
360 { HDA_CODEC_NVIDIAMCP78_3, 0, "NVIDIA MCP78" },
361 { HDA_CODEC_NVIDIAMCP78_4, 0, "NVIDIA MCP78" },
362 { HDA_CODEC_NVIDIAMCP7A, 0, "NVIDIA MCP7A" },
363 { HDA_CODEC_NVIDIAGM204, 0, "NVIDIA GM204" },
364 { HDA_CODEC_NVIDIAGT220, 0, "NVIDIA GT220" },
365 { HDA_CODEC_NVIDIAGT21X, 0, "NVIDIA GT21x" },
366 { HDA_CODEC_NVIDIAMCP89, 0, "NVIDIA MCP89" },
367 { HDA_CODEC_NVIDIAGT240, 0, "NVIDIA GT240" },
368 { HDA_CODEC_NVIDIAGTS450, 0, "NVIDIA GTS450" },
369 { HDA_CODEC_NVIDIAGT440, 0, "NVIDIA GT440" },
370 { HDA_CODEC_NVIDIAGTX550, 0, "NVIDIA GTX550" },
371 { HDA_CODEC_NVIDIAGTX570, 0, "NVIDIA GTX570" },
372 { HDA_CODEC_NVIDIATEGRA30, 0, "NVIDIA Tegra30" },
373 { HDA_CODEC_NVIDIATEGRA114, 0, "NVIDIA Tegra114" },
374 { HDA_CODEC_NVIDIATEGRA124, 0, "NVIDIA Tegra124" },
375 { HDA_CODEC_NVIDIATEGRA210, 0, "NVIDIA Tegra210" },
376 { HDA_CODEC_INTELIP, 0, "Intel Ibex Peak" },
377 { HDA_CODEC_INTELBL, 0, "Intel Bearlake" },
378 { HDA_CODEC_INTELCA, 0, "Intel Cantiga" },
379 { HDA_CODEC_INTELEL, 0, "Intel Eaglelake" },
380 { HDA_CODEC_INTELIP2, 0, "Intel Ibex Peak" },
381 { HDA_CODEC_INTELCPT, 0, "Intel Cougar Point" },
382 { HDA_CODEC_INTELPPT, 0, "Intel Panther Point" },
383 { HDA_CODEC_INTELHSW, 0, "Intel Haswell" },
384 { HDA_CODEC_INTELBDW, 0, "Intel Broadwell" },
385 { HDA_CODEC_INTELSKLK, 0, "Intel Skylake" },
386 { HDA_CODEC_INTELKBLK, 0, "Intel Kaby Lake" },
387 { HDA_CODEC_INTELJLK, 0, "Intel Jasper Lake" },
388 { HDA_CODEC_INTELELLK, 0, "Intel Elkhart Lake" },
389 { HDA_CODEC_INTELCT, 0, "Intel Cedar Trail" },
390 { HDA_CODEC_INTELVV2, 0, "Intel Valleyview2" },
391 { HDA_CODEC_INTELBR, 0, "Intel Braswell" },
392 { HDA_CODEC_INTELCL, 0, "Intel Crestline" },
393 { HDA_CODEC_INTELBXTN, 0, "Intel Broxton" },
394 { HDA_CODEC_INTELCNLK, 0, "Intel Cannon Lake" },
395 { HDA_CODEC_INTELGMLK, 0, "Intel Gemini Lake" },
396 { HDA_CODEC_INTELGMLK1, 0, "Intel Gemini Lake" },
397 { HDA_CODEC_INTELICLK, 0, "Intel Ice Lake" },
398 { HDA_CODEC_INTELTGLK, 0, "Intel Tiger Lake" },
399 { HDA_CODEC_INTELTGLKH, 0, "Intel Tiger Lake-H" },
400 { HDA_CODEC_INTELALLK, 0, "Intel Alder Lake" },
401 { HDA_CODEC_SII1390, 0, "Silicon Image SiI1390" },
402 { HDA_CODEC_SII1392, 0, "Silicon Image SiI1392" },
403 { HDA_CODEC_VMWARE, 0, "VMware" },
404 /* Unknown CODECs */
405 { HDA_CODEC_ADXXXX, 0, "Analog Devices" },
406 { HDA_CODEC_AGEREXXXX, 0, "Lucent/Agere Systems" },
407 { HDA_CODEC_ALCXXXX, 0, "Realtek" },
408 { HDA_CODEC_ATIXXXX, 0, "ATI" },
409 { HDA_CODEC_CAXXXX, 0, "Creative" },
410 { HDA_CODEC_CMIXXXX, 0, "CMedia" },
411 { HDA_CODEC_CMIXXXX2, 0, "CMedia" },
412 { HDA_CODEC_CSXXXX, 0, "Cirrus Logic" },
413 { HDA_CODEC_CXXXXX, 0, "Conexant" },
414 { HDA_CODEC_CHXXXX, 0, "Chrontel" },
415 { HDA_CODEC_IDTXXXX, 0, "IDT" },
416 { HDA_CODEC_INTELXXXX, 0, "Intel" },
417 { HDA_CODEC_MOTOXXXX, 0, "Motorola" },
418 { HDA_CODEC_NVIDIAXXXX, 0, "NVIDIA" },
419 { HDA_CODEC_SIIXXXX, 0, "Silicon Image" },
420 { HDA_CODEC_STACXXXX, 0, "Sigmatel" },
421 { HDA_CODEC_VMWAREXXXX, 0, "VMware" },
422 { HDA_CODEC_VTXXXX, 0, "VIA" },
423 };
424
425 static int
hdacc_suspend(device_t dev)426 hdacc_suspend(device_t dev)
427 {
428
429 HDA_BOOTHVERBOSE(
430 device_printf(dev, "Suspend...\n");
431 );
432 bus_generic_suspend(dev);
433 HDA_BOOTHVERBOSE(
434 device_printf(dev, "Suspend done\n");
435 );
436 return (0);
437 }
438
439 static int
hdacc_resume(device_t dev)440 hdacc_resume(device_t dev)
441 {
442
443 HDA_BOOTHVERBOSE(
444 device_printf(dev, "Resume...\n");
445 );
446 bus_generic_resume(dev);
447 HDA_BOOTHVERBOSE(
448 device_printf(dev, "Resume done\n");
449 );
450 return (0);
451 }
452
453 static int
hdacc_probe(device_t dev)454 hdacc_probe(device_t dev)
455 {
456 uint32_t id, revid;
457 char buf[128];
458 int i;
459
460 id = ((uint32_t)hda_get_vendor_id(dev) << 16) + hda_get_device_id(dev);
461 revid = ((uint32_t)hda_get_revision_id(dev) << 8) +
462 hda_get_stepping_id(dev);
463
464 for (i = 0; i < nitems(hdacc_codecs); i++) {
465 if (!HDA_DEV_MATCH(hdacc_codecs[i].id, id))
466 continue;
467 if (hdacc_codecs[i].revid != 0 &&
468 hdacc_codecs[i].revid != revid)
469 continue;
470 break;
471 }
472 if (i < nitems(hdacc_codecs)) {
473 if ((hdacc_codecs[i].id & 0xffff) != 0xffff)
474 strlcpy(buf, hdacc_codecs[i].name, sizeof(buf));
475 else
476 snprintf(buf, sizeof(buf), "%s (0x%04x)",
477 hdacc_codecs[i].name, hda_get_device_id(dev));
478 } else
479 snprintf(buf, sizeof(buf), "Generic (0x%04x)", id);
480 device_set_descf(dev, "%s HDA CODEC", buf);
481 return (BUS_PROBE_DEFAULT);
482 }
483
484 static int
hdacc_attach(device_t dev)485 hdacc_attach(device_t dev)
486 {
487 struct hdacc_softc *codec = device_get_softc(dev);
488 device_t child;
489 int cad = (intptr_t)device_get_ivars(dev);
490 uint32_t subnode;
491 int startnode;
492 int endnode;
493 int i, n;
494
495 codec->lock = HDAC_GET_MTX(device_get_parent(dev), dev);
496 codec->dev = dev;
497 codec->cad = cad;
498
499 hdacc_lock(codec);
500 subnode = hda_command(dev,
501 HDA_CMD_GET_PARAMETER(0, 0x0, HDA_PARAM_SUB_NODE_COUNT));
502 hdacc_unlock(codec);
503 if (subnode == HDA_INVALID)
504 return (EIO);
505 codec->fgcnt = HDA_PARAM_SUB_NODE_COUNT_TOTAL(subnode);
506 startnode = HDA_PARAM_SUB_NODE_COUNT_START(subnode);
507 endnode = startnode + codec->fgcnt;
508
509 HDA_BOOTHVERBOSE(
510 device_printf(dev,
511 "Root Node at nid=0: %d subnodes %d-%d\n",
512 HDA_PARAM_SUB_NODE_COUNT_TOTAL(subnode),
513 startnode, endnode - 1);
514 );
515
516 codec->fgs = malloc(sizeof(struct hdacc_fg) * codec->fgcnt,
517 M_HDACC, M_ZERO | M_WAITOK);
518 for (i = startnode, n = 0; i < endnode; i++, n++) {
519 codec->fgs[n].nid = i;
520 hdacc_lock(codec);
521 codec->fgs[n].type =
522 HDA_PARAM_FCT_GRP_TYPE_NODE_TYPE(hda_command(dev,
523 HDA_CMD_GET_PARAMETER(0, i, HDA_PARAM_FCT_GRP_TYPE)));
524 codec->fgs[n].subsystem_id = hda_command(dev,
525 HDA_CMD_GET_SUBSYSTEM_ID(0, i));
526 hdacc_unlock(codec);
527 codec->fgs[n].dev = child = device_add_child(dev, NULL, DEVICE_UNIT_ANY);
528 if (child == NULL) {
529 device_printf(dev, "Failed to add function device\n");
530 continue;
531 }
532 device_set_ivars(child, &codec->fgs[n]);
533 }
534
535 bus_attach_children(dev);
536
537 return (0);
538 }
539
540 static int
hdacc_detach(device_t dev)541 hdacc_detach(device_t dev)
542 {
543 struct hdacc_softc *codec = device_get_softc(dev);
544 int error;
545
546 if ((error = bus_generic_detach(dev)) != 0)
547 return (error);
548 free(codec->fgs, M_HDACC);
549 return (0);
550 }
551
552 static int
hdacc_child_location(device_t dev,device_t child,struct sbuf * sb)553 hdacc_child_location(device_t dev, device_t child, struct sbuf *sb)
554 {
555 struct hdacc_fg *fg = device_get_ivars(child);
556
557 sbuf_printf(sb, "nid=%d", fg->nid);
558 return (0);
559 }
560
561 static int
hdacc_child_pnpinfo_method(device_t dev,device_t child,struct sbuf * sb)562 hdacc_child_pnpinfo_method(device_t dev, device_t child, struct sbuf *sb)
563 {
564 struct hdacc_fg *fg = device_get_ivars(child);
565
566 sbuf_printf(sb, "type=0x%02x subsystem=0x%08x",
567 fg->type, fg->subsystem_id);
568 return (0);
569 }
570
571 static int
hdacc_print_child(device_t dev,device_t child)572 hdacc_print_child(device_t dev, device_t child)
573 {
574 struct hdacc_fg *fg = device_get_ivars(child);
575 int retval;
576
577 retval = bus_print_child_header(dev, child);
578 retval += printf(" at nid %d", fg->nid);
579 retval += bus_print_child_footer(dev, child);
580
581 return (retval);
582 }
583
584 static void
hdacc_probe_nomatch(device_t dev,device_t child)585 hdacc_probe_nomatch(device_t dev, device_t child)
586 {
587 struct hdacc_softc *codec = device_get_softc(dev);
588 struct hdacc_fg *fg = device_get_ivars(child);
589
590 device_printf(child, "<%s %s Function Group> at nid %d on %s "
591 "(no driver attached)\n",
592 device_get_desc(dev),
593 fg->type == HDA_PARAM_FCT_GRP_TYPE_NODE_TYPE_AUDIO ? "Audio" :
594 (fg->type == HDA_PARAM_FCT_GRP_TYPE_NODE_TYPE_MODEM ? "Modem" :
595 "Unknown"), fg->nid, device_get_nameunit(dev));
596 HDA_BOOTVERBOSE(
597 device_printf(dev, "Subsystem ID: 0x%08x\n",
598 hda_get_subsystem_id(dev));
599 );
600 HDA_BOOTHVERBOSE(
601 device_printf(dev, "Power down FG nid=%d to the D3 state...\n",
602 fg->nid);
603 );
604 hdacc_lock(codec);
605 hda_command(dev, HDA_CMD_SET_POWER_STATE(0,
606 fg->nid, HDA_CMD_POWER_STATE_D3));
607 hdacc_unlock(codec);
608 }
609
610 static int
hdacc_read_ivar(device_t dev,device_t child,int which,uintptr_t * result)611 hdacc_read_ivar(device_t dev, device_t child, int which, uintptr_t *result)
612 {
613 struct hdacc_fg *fg = device_get_ivars(child);
614
615 switch (which) {
616 case HDA_IVAR_NODE_ID:
617 *result = fg->nid;
618 break;
619 case HDA_IVAR_NODE_TYPE:
620 *result = fg->type;
621 break;
622 case HDA_IVAR_SUBSYSTEM_ID:
623 *result = fg->subsystem_id;
624 break;
625 default:
626 return(BUS_READ_IVAR(device_get_parent(dev), dev,
627 which, result));
628 }
629 return (0);
630 }
631
632 static struct mtx *
hdacc_get_mtx(device_t dev,device_t child)633 hdacc_get_mtx(device_t dev, device_t child)
634 {
635 struct hdacc_softc *codec = device_get_softc(dev);
636
637 return (codec->lock);
638 }
639
640 static uint32_t
hdacc_codec_command(device_t dev,device_t child,uint32_t verb)641 hdacc_codec_command(device_t dev, device_t child, uint32_t verb)
642 {
643
644 return (HDAC_CODEC_COMMAND(device_get_parent(dev), dev, verb));
645 }
646
647 static int
hdacc_stream_alloc(device_t dev,device_t child,int dir,int format,int stripe,uint32_t ** dmapos)648 hdacc_stream_alloc(device_t dev, device_t child, int dir, int format,
649 int stripe, uint32_t **dmapos)
650 {
651 struct hdacc_softc *codec = device_get_softc(dev);
652 int stream;
653
654 stream = HDAC_STREAM_ALLOC(device_get_parent(dev), dev,
655 dir, format, stripe, dmapos);
656 if (stream > 0)
657 codec->streams[dir][stream] = child;
658 return (stream);
659 }
660
661 static void
hdacc_stream_free(device_t dev,device_t child,int dir,int stream)662 hdacc_stream_free(device_t dev, device_t child, int dir, int stream)
663 {
664 struct hdacc_softc *codec = device_get_softc(dev);
665
666 codec->streams[dir][stream] = NULL;
667 HDAC_STREAM_FREE(device_get_parent(dev), dev, dir, stream);
668 }
669
670 static int
hdacc_stream_start(device_t dev,device_t child,int dir,int stream,bus_addr_t buf,int blksz,int blkcnt)671 hdacc_stream_start(device_t dev, device_t child, int dir, int stream,
672 bus_addr_t buf, int blksz, int blkcnt)
673 {
674
675 return (HDAC_STREAM_START(device_get_parent(dev), dev,
676 dir, stream, buf, blksz, blkcnt));
677 }
678
679 static void
hdacc_stream_stop(device_t dev,device_t child,int dir,int stream)680 hdacc_stream_stop(device_t dev, device_t child, int dir, int stream)
681 {
682
683 HDAC_STREAM_STOP(device_get_parent(dev), dev, dir, stream);
684 }
685
686 static void
hdacc_stream_reset(device_t dev,device_t child,int dir,int stream)687 hdacc_stream_reset(device_t dev, device_t child, int dir, int stream)
688 {
689
690 HDAC_STREAM_RESET(device_get_parent(dev), dev, dir, stream);
691 }
692
693 static uint32_t
hdacc_stream_getptr(device_t dev,device_t child,int dir,int stream)694 hdacc_stream_getptr(device_t dev, device_t child, int dir, int stream)
695 {
696
697 return (HDAC_STREAM_GETPTR(device_get_parent(dev), dev, dir, stream));
698 }
699
700 static void
hdacc_stream_intr(device_t dev,int dir,int stream)701 hdacc_stream_intr(device_t dev, int dir, int stream)
702 {
703 struct hdacc_softc *codec = device_get_softc(dev);
704 device_t child;
705
706 if ((child = codec->streams[dir][stream]) != NULL)
707 HDAC_STREAM_INTR(child, dir, stream);
708 }
709
710 static int
hdacc_unsol_alloc(device_t dev,device_t child,int wanted)711 hdacc_unsol_alloc(device_t dev, device_t child, int wanted)
712 {
713 struct hdacc_softc *codec = device_get_softc(dev);
714 int tag;
715
716 wanted &= 0x3f;
717 tag = wanted;
718 do {
719 if (codec->tags[tag] == NULL) {
720 codec->tags[tag] = child;
721 HDAC_UNSOL_ALLOC(device_get_parent(dev), dev, tag);
722 return (tag);
723 }
724 tag++;
725 tag &= 0x3f;
726 } while (tag != wanted);
727 return (-1);
728 }
729
730 static void
hdacc_unsol_free(device_t dev,device_t child,int tag)731 hdacc_unsol_free(device_t dev, device_t child, int tag)
732 {
733 struct hdacc_softc *codec = device_get_softc(dev);
734
735 KASSERT(tag >= 0 && tag <= 0x3f, ("Wrong tag value %d\n", tag));
736 codec->tags[tag] = NULL;
737 HDAC_UNSOL_FREE(device_get_parent(dev), dev, tag);
738 }
739
740 static void
hdacc_unsol_intr(device_t dev,uint32_t resp)741 hdacc_unsol_intr(device_t dev, uint32_t resp)
742 {
743 struct hdacc_softc *codec = device_get_softc(dev);
744 device_t child;
745 int tag;
746
747 tag = resp >> 26;
748 if ((child = codec->tags[tag]) != NULL)
749 HDAC_UNSOL_INTR(child, resp);
750 else
751 device_printf(codec->dev, "Unexpected unsolicited "
752 "response with tag %d: %08x\n", tag, resp);
753 }
754
755 static void
hdacc_pindump(device_t dev)756 hdacc_pindump(device_t dev)
757 {
758 device_t *devlist;
759 int devcount, i;
760
761 if (device_get_children(dev, &devlist, &devcount) != 0)
762 return;
763 for (i = 0; i < devcount; i++)
764 HDAC_PINDUMP(devlist[i]);
765 free(devlist, M_TEMP);
766 }
767
768 static device_method_t hdacc_methods[] = {
769 /* device interface */
770 DEVMETHOD(device_probe, hdacc_probe),
771 DEVMETHOD(device_attach, hdacc_attach),
772 DEVMETHOD(device_detach, hdacc_detach),
773 DEVMETHOD(device_suspend, hdacc_suspend),
774 DEVMETHOD(device_resume, hdacc_resume),
775 /* Bus interface */
776 DEVMETHOD(bus_child_location, hdacc_child_location),
777 DEVMETHOD(bus_child_pnpinfo, hdacc_child_pnpinfo_method),
778 DEVMETHOD(bus_print_child, hdacc_print_child),
779 DEVMETHOD(bus_probe_nomatch, hdacc_probe_nomatch),
780 DEVMETHOD(bus_read_ivar, hdacc_read_ivar),
781 DEVMETHOD(hdac_get_mtx, hdacc_get_mtx),
782 DEVMETHOD(hdac_codec_command, hdacc_codec_command),
783 DEVMETHOD(hdac_stream_alloc, hdacc_stream_alloc),
784 DEVMETHOD(hdac_stream_free, hdacc_stream_free),
785 DEVMETHOD(hdac_stream_start, hdacc_stream_start),
786 DEVMETHOD(hdac_stream_stop, hdacc_stream_stop),
787 DEVMETHOD(hdac_stream_reset, hdacc_stream_reset),
788 DEVMETHOD(hdac_stream_getptr, hdacc_stream_getptr),
789 DEVMETHOD(hdac_stream_intr, hdacc_stream_intr),
790 DEVMETHOD(hdac_unsol_alloc, hdacc_unsol_alloc),
791 DEVMETHOD(hdac_unsol_free, hdacc_unsol_free),
792 DEVMETHOD(hdac_unsol_intr, hdacc_unsol_intr),
793 DEVMETHOD(hdac_pindump, hdacc_pindump),
794 DEVMETHOD_END
795 };
796
797 static driver_t hdacc_driver = {
798 "hdacc",
799 hdacc_methods,
800 sizeof(struct hdacc_softc),
801 };
802
803 DRIVER_MODULE(snd_hda, hdac, hdacc_driver, NULL, NULL);
804