/usr/src/sys/dev/pci/azalia.c

Bug Summary

File:	dev/pci/azalia.c
Warning:	line 2570, column 5 Value stored to 'cap' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name azalia.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -ffreestanding -mcmodel=kernel -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -target-feature -sse2 -target-feature -sse -target-feature -3dnow -target-feature -mmx -target-feature +save-args -target-feature +retpoline-external-thunk -disable-red-zone -no-implicit-float -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -nostdsysteminc -nobuiltininc -resource-dir /usr/local/llvm16/lib/clang/16 -I /usr/src/sys -I /usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -I /usr/src/sys/arch -I /usr/src/sys/dev/pci/drm/include -I /usr/src/sys/dev/pci/drm/include/uapi -I /usr/src/sys/dev/pci/drm/amd/include/asic_reg -I /usr/src/sys/dev/pci/drm/amd/include -I /usr/src/sys/dev/pci/drm/amd/amdgpu -I /usr/src/sys/dev/pci/drm/amd/display -I /usr/src/sys/dev/pci/drm/amd/display/include -I /usr/src/sys/dev/pci/drm/amd/display/dc -I /usr/src/sys/dev/pci/drm/amd/display/amdgpu_dm -I /usr/src/sys/dev/pci/drm/amd/pm/inc -I /usr/src/sys/dev/pci/drm/amd/pm/legacy-dpm -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu11 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu12 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu13 -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/inc -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/hwmgr -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/smumgr -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc/pmfw_if -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc/hw -I /usr/src/sys/dev/pci/drm/amd/display/dc/clk_mgr -I /usr/src/sys/dev/pci/drm/amd/display/modules/inc -I /usr/src/sys/dev/pci/drm/amd/display/modules/hdcp -I /usr/src/sys/dev/pci/drm/amd/display/dmub/inc -I /usr/src/sys/dev/pci/drm/i915 -D DDB -D DIAGNOSTIC -D KTRACE -D ACCOUNTING -D KMEMSTATS -D PTRACE -D POOL_DEBUG -D CRYPTO -D SYSVMSG -D SYSVSEM -D SYSVSHM -D UVM_SWAP_ENCRYPT -D FFS -D FFS2 -D FFS_SOFTUPDATES -D UFS_DIRHASH -D QUOTA -D EXT2FS -D MFS -D NFSCLIENT -D NFSSERVER -D CD9660 -D UDF -D MSDOSFS -D FIFO -D FUSE -D SOCKET_SPLICE -D TCP_ECN -D TCP_SIGNATURE -D INET6 -D IPSEC -D PPP_BSDCOMP -D PPP_DEFLATE -D PIPEX -D MROUTING -D MPLS -D BOOT_CONFIG -D USER_PCICONF -D APERTURE -D MTRR -D NTFS -D SUSPEND -D HIBERNATE -D PCIVERBOSE -D USBVERBOSE -D WSDISPLAY_COMPAT_USL -D WSDISPLAY_COMPAT_RAWKBD -D WSDISPLAY_DEFAULTSCREENS=6 -D X86EMU -D ONEWIREVERBOSE -D MULTIPROCESSOR -D MAXUSERS=80 -D _KERNEL -O2 -Wno-pointer-sign -Wno-address-of-packed-member -Wno-constant-conversion -Wno-unused-but-set-variable -Wno-gnu-folding-constant -fdebug-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -o /home/ben/Projects/scan/2024-01-11-110808-61670-1 -x c /usr/src/sys/dev/pci/azalia.c

1	/* $OpenBSD: azalia.c,v 1.285 2023/11/23 14:24:06 jsg Exp $ */
2	/* $NetBSD: azalia.c,v 1.20 2006/05/07 08:31:44 kent Exp $ */
3
4	/*-
5	* Copyright (c) 2005 The NetBSD Foundation, Inc.
6	* All rights reserved.
7	*
8	* This code is derived from software contributed to The NetBSD Foundation
9	* by TAMURA Kent
10	*
11	* Redistribution and use in source and binary forms, with or without
12	* modification, are permitted provided that the following conditions
13	* are met:
14	* 1. Redistributions of source code must retain the above copyright
15	* notice, this list of conditions and the following disclaimer.
16	* 2. Redistributions in binary form must reproduce the above copyright
17	* notice, this list of conditions and the following disclaimer in the
18	* documentation and/or other materials provided with the distribution.
19	*
20	* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21	* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22	* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30	* POSSIBILITY OF SUCH DAMAGE.
31	*/
32
33	/*
34	* High Definition Audio Specification
35	*
36	* http://www.intel.com/content/dam/www/public/us/en/documents/product-specifications/high-definition-audio-specification.pdf
37	*
38	*
39	* TO DO:
40	* - multiple codecs (needed?)
41	* - multiple streams (needed?)
42	*/
43
44	#include <sys/param.h>
45	#include <sys/fcntl.h>
46	#include <sys/device.h>
47	#include <sys/malloc.h>
48	#include <sys/systm.h>
49	#include <sys/timeout.h>
50	#include <dev/audio_if.h>
51	#include <dev/pci/pcidevs.h>
52	#include <dev/pci/pcivar.h>
53
54	#include <dev/pci/azalia.h>
55
56	typedef struct audio_params audio_params_t;
57
58	struct audio_format {
59	void *driver_data;
60	int32_t mode;
61	u_int encoding;
62	u_int precision;
63	u_int channels;
64
65	/**
66	* 0: frequency[0] is lower limit, and frequency[1] is higher limit.
67	* 1-16: frequency[0] to frequency[frequency_type-1] are valid.
68	*/
69	u_int frequency_type;
70
71	#define AUFMT_MAX_FREQUENCIES16 16
72	/**
73	* sampling rates
74	*/
75	u_int frequency[AUFMT_MAX_FREQUENCIES16];
76	};
77
78
79	#ifdef AZALIA_DEBUG
80	# define DPRINTFN(n,x)do {} while (0 ) do { if (az_debug > (n)) printf x; } while (0/CONSTCOND/)
81	int az_debug = 0;
82	#else
83	# define DPRINTFN(n,x)do {} while (0 ) do {} while (0/CONSTCOND/)
84	#endif
85
86
87	/* ----------------------------------------------------------------
88	* ICH6/ICH7 constant values
89	* ---------------------------------------------------------------- */
90
91	/* PCI registers */
92	#define ICH_PCI_HDBARL0x10 0x10
93	#define ICH_PCI_HDBARU0x14 0x14
94	#define ICH_PCI_HDCTL0x40 0x40
95	#define ICH_PCI_HDCTL_CLKDETCLR0x08 0x08
96	#define ICH_PCI_HDCTL_CLKDETEN0x04 0x04
97	#define ICH_PCI_HDCTL_CLKDETINV0x02 0x02
98	#define ICH_PCI_HDCTL_SIGNALMODE0x01 0x01
99	#define ICH_PCI_HDTCSEL0x44 0x44
100	#define ICH_PCI_HDTCSEL_MASK0x7 0x7
101	#define ICH_PCI_MMC0x62 0x62
102	#define ICH_PCI_MMC_ME0x1 0x1
103
104	/* internal types */
105
106	typedef struct {
107	bus_dmamap_t map;
108	caddr_t addr; /* kernel virtual address */
109	bus_dma_segment_t segments[1];
110	size_t size;
111	} azalia_dma_t;
112	#define AZALIA_DMA_DMAADDR(p)((p)->map->dm_segs[0].ds_addr) ((p)->map->dm_segs[0].ds_addr)
113
114	typedef struct {
115	struct azalia_t *az;
116	int regbase;
117	int number;
118	int dir; /* AUMODE_PLAY or AUMODE_RECORD */
119	uint32_t intr_bit;
120	azalia_dma_t bdlist;
121	azalia_dma_t buffer;
122	void (intr)(void);
123	void *intr_arg;
124	int bufsize;
125	uint16_t fmt;
126	int blk;
127	unsigned int swpos; /* position in the audio(4) layer */
128	} stream_t;
129	#define STR_READ_1(s, r)(((s)->az->iot)->read_1(((s)->az->ioh), ((s)-> regbase + HDA_SD_r))) \
130	bus_space_read_1((s)->az->iot, (s)->az->ioh, (s)->regbase + HDA_SD_##r)(((s)->az->iot)->read_1(((s)->az->ioh), ((s)-> regbase + HDA_SD_##r)))
131	#define STR_READ_2(s, r)(((s)->az->iot)->read_2(((s)->az->ioh), ((s)-> regbase + HDA_SD_r))) \
132	bus_space_read_2((s)->az->iot, (s)->az->ioh, (s)->regbase + HDA_SD_##r)(((s)->az->iot)->read_2(((s)->az->ioh), ((s)-> regbase + HDA_SD_##r)))
133	#define STR_READ_4(s, r)(((s)->az->iot)->read_4(((s)->az->ioh), ((s)-> regbase + HDA_SD_r))) \
134	bus_space_read_4((s)->az->iot, (s)->az->ioh, (s)->regbase + HDA_SD_##r)(((s)->az->iot)->read_4(((s)->az->ioh), ((s)-> regbase + HDA_SD_##r)))
135	#define STR_WRITE_1(s, r, v)(((s)->az->iot)->write_1(((s)->az->ioh), ((s)-> regbase + HDA_SD_r), (v))) \
136	bus_space_write_1((s)->az->iot, (s)->az->ioh, (s)->regbase + HDA_SD_##r, v)(((s)->az->iot)->write_1(((s)->az->ioh), ((s)-> regbase + HDA_SD_##r), (v)))
137	#define STR_WRITE_2(s, r, v)(((s)->az->iot)->write_2(((s)->az->ioh), ((s)-> regbase + HDA_SD_r), (v))) \
138	bus_space_write_2((s)->az->iot, (s)->az->ioh, (s)->regbase + HDA_SD_##r, v)(((s)->az->iot)->write_2(((s)->az->ioh), ((s)-> regbase + HDA_SD_##r), (v)))
139	#define STR_WRITE_4(s, r, v)(((s)->az->iot)->write_4(((s)->az->ioh), ((s)-> regbase + HDA_SD_r), (v))) \
140	bus_space_write_4((s)->az->iot, (s)->az->ioh, (s)->regbase + HDA_SD_##r, v)(((s)->az->iot)->write_4(((s)->az->ioh), ((s)-> regbase + HDA_SD_##r), (v)))
141
142	typedef struct azalia_t {
143	struct device dev;
144
145	pci_chipset_tag_t pc;
146	pcitag_t tag;
147	void *ih;
148	bus_space_tag_t iot;
149	bus_space_handle_t ioh;
150	bus_size_t map_size;
151	bus_dma_tag_t dmat;
152	pcireg_t pciid;
153	uint32_t subid;
154
155	codec_t *codecs;
156	int ncodecs; /* number of codecs */
157	int codecno; /* index of the using codec */
158	int detached; /* 1 if failed to initialize, 2 if
159	* azalia_pci_detach has run
160	*/
161	azalia_dma_t corb_dma;
162	int corb_entries;
163	uint8_t corbsize;
164	azalia_dma_t rirb_dma;
165	int rirb_entries;
166	uint8_t rirbsize;
167	int rirb_rp;
168	#define UNSOLQ_SIZE256 256
169	rirb_entry_t *unsolq;
170	int unsolq_wp;
171	int unsolq_rp;
172	int unsolq_kick;
173	struct timeout unsol_to;
174
175	int ok64;
176	int nistreams, nostreams, nbstreams;
177	stream_t pstream;
178	stream_t rstream;
179	} azalia_t;
180	#define XNAME(sc)((sc)->dev.dv_xname) ((sc)->dev.dv_xname)
181	#define AZ_READ_1(z, r)(((z)->iot)->read_1(((z)->ioh), (HDA_r))) bus_space_read_1((z)->iot, (z)->ioh, HDA_##r)(((z)->iot)->read_1(((z)->ioh), (HDA_##r)))
182	#define AZ_READ_2(z, r)(((z)->iot)->read_2(((z)->ioh), (HDA_r))) bus_space_read_2((z)->iot, (z)->ioh, HDA_##r)(((z)->iot)->read_2(((z)->ioh), (HDA_##r)))
183	#define AZ_READ_4(z, r)(((z)->iot)->read_4(((z)->ioh), (HDA_r))) bus_space_read_4((z)->iot, (z)->ioh, HDA_##r)(((z)->iot)->read_4(((z)->ioh), (HDA_##r)))
184	#define AZ_WRITE_1(z, r, v)(((z)->iot)->write_1(((z)->ioh), (HDA_r), (v))) bus_space_write_1((z)->iot, (z)->ioh, HDA_##r, v)(((z)->iot)->write_1(((z)->ioh), (HDA_##r), (v)))
185	#define AZ_WRITE_2(z, r, v)(((z)->iot)->write_2(((z)->ioh), (HDA_r), (v))) bus_space_write_2((z)->iot, (z)->ioh, HDA_##r, v)(((z)->iot)->write_2(((z)->ioh), (HDA_##r), (v)))
186	#define AZ_WRITE_4(z, r, v)(((z)->iot)->write_4(((z)->ioh), (HDA_r), (v))) bus_space_write_4((z)->iot, (z)->ioh, HDA_##r, v)(((z)->iot)->write_4(((z)->ioh), (HDA_##r), (v)))
187
188
189	/* prototypes */
190	uint8_t azalia_pci_read(pci_chipset_tag_t, pcitag_t, int);
191	void azalia_pci_write(pci_chipset_tag_t, pcitag_t, int, uint8_t);
192	int azalia_pci_match(struct device , void , void *);
193	void azalia_pci_attach(struct device , struct device , void *);
194	int azalia_pci_activate(struct device *, int);
195	int azalia_pci_detach(struct device *, int);
196	void azalia_configure_pci(azalia_t *);
197	int azalia_intr(void *);
198	void azalia_print_codec(codec_t *);
199	int azalia_reset(azalia_t *);
200	int azalia_get_ctrlr_caps(azalia_t *);
201	int azalia_init(azalia_t *, int);
202	int azalia_init_codecs(azalia_t *);
203	int azalia_init_streams(azalia_t *);
204	void azalia_shutdown(void *);
205	int azalia_halt_corb(azalia_t *);
206	int azalia_init_corb(azalia_t *, int);
207	int azalia_halt_rirb(azalia_t *);
208	int azalia_init_rirb(azalia_t *, int);
209	int azalia_set_command(azalia_t *, nid_t, int, uint32_t, uint32_t);
210	int azalia_get_response(azalia_t , uint32_t );
211	void azalia_rirb_kick_unsol_events(void *);
212	void azalia_rirb_intr(azalia_t *);
213	int azalia_alloc_dmamem(azalia_t , size_t, size_t, azalia_dma_t );
214	void azalia_free_dmamem(const azalia_t , azalia_dma_t);
215
216	int azalia_codec_init(codec_t *);
217	int azalia_codec_delete(codec_t *);
218	void azalia_codec_add_bits(codec_t *, int, uint32_t, int);
219	void azalia_codec_add_format(codec_t *, int, int, uint32_t, int32_t);
220	int azalia_codec_connect_stream(stream_t *);
221	int azalia_codec_disconnect_stream(stream_t *);
222	void azalia_codec_print_audiofunc(const codec_t *);
223	void azalia_codec_print_groups(const codec_t *);
224	int azalia_codec_find_defdac(codec_t *, int, int);
225	int azalia_codec_find_defadc(codec_t *, int, int);
226	int azalia_codec_find_defadc_sub(codec_t *, nid_t, int, int);
227	int azalia_codec_init_volgroups(codec_t *);
228	int azalia_codec_sort_pins(codec_t *);
229	int azalia_codec_select_micadc(codec_t *);
230	int azalia_codec_select_dacs(codec_t *);
231	int azalia_codec_select_spkrdac(codec_t *);
232	int azalia_codec_find_inputmixer(codec_t *);
233
234	int azalia_widget_init(widget_t , const codec_t , int);
235	int azalia_widget_label_widgets(codec_t *);
236	int azalia_widget_init_audio(widget_t , const codec_t );
237	int azalia_widget_init_pin(widget_t , const codec_t );
238	int azalia_widget_init_connection(widget_t , const codec_t );
239	int azalia_widget_check_conn(codec_t *, int, int);
240	int azalia_widget_sole_conn(codec_t *, nid_t);
241	void azalia_widget_print_widget(const widget_t , const codec_t );
242	void azalia_widget_print_audio(const widget_t , const char );
243	void azalia_widget_print_pin(const widget_t *);
244
245	int azalia_stream_init(stream_t , azalia_t , int, int, int);
246	int azalia_stream_reset(stream_t *);
247	int azalia_stream_start(stream_t *);
248	int azalia_stream_halt(stream_t *);
249	int azalia_stream_intr(stream_t *);
250
251	int azalia_open(void *, int);
252	void azalia_close(void *);
253	int azalia_set_params(void , int, int, audio_params_t ,
254	audio_params_t *);
255	unsigned int azalia_set_blksz(void *, int,
256	struct audio_params , struct audio_params , unsigned int);
257	unsigned int azalia_set_nblks(void *, int,
258	struct audio_params *, unsigned int, unsigned int);
259	int azalia_halt_output(void *);
260	int azalia_halt_input(void *);
261	int azalia_set_port(void , mixer_ctrl_t );
262	int azalia_get_port(void , mixer_ctrl_t );
263	int azalia_query_devinfo(void , mixer_devinfo_t );
264	void azalia_allocm(void , int, size_t, int, int);
265	void azalia_freem(void , void , int);
266	size_t azalia_round_buffersize(void *, int, size_t);
267	int azalia_trigger_output(void , void , void *, int,
268	void ()(void ), void , audio_params_t );
269	int azalia_trigger_input(void , void , void *, int,
270	void ()(void ), void , audio_params_t );
271
272	int azalia_params2fmt(const audio_params_t , uint16_t );
273
274	int azalia_match_format(codec_t , int, audio_params_t );
275	int azalia_set_params_sub(codec_t , int, audio_params_t );
276
277	int azalia_suspend(azalia_t *);
278	int azalia_resume(azalia_t *);
279	int azalia_resume_codec(codec_t *);
280
281	/* variables */
282	const struct cfattach azalia_ca = {
283	sizeof(azalia_t), azalia_pci_match, azalia_pci_attach,
284	azalia_pci_detach, azalia_pci_activate
285	};
286
287	struct cfdriver azalia_cd = {
288	NULL((void *)0), "azalia", DV_DULL, CD_SKIPHIBERNATE2
289	};
290
291	const struct audio_hw_if azalia_hw_if = {
292	.open = azalia_open,
293	.close = azalia_close,
294	.set_params = azalia_set_params,
295	.halt_output = azalia_halt_output,
296	.halt_input = azalia_halt_input,
297	.set_port = azalia_set_port,
298	.get_port = azalia_get_port,
299	.query_devinfo = azalia_query_devinfo,
300	.allocm = azalia_allocm,
301	.freem = azalia_freem,
302	.round_buffersize = azalia_round_buffersize,
303	.trigger_output = azalia_trigger_output,
304	.trigger_input = azalia_trigger_input,
305	.set_blksz = azalia_set_blksz,
306	.set_nblks = azalia_set_nblks,
307	};
308
309	static const char *pin_devices[16] = {
310	AudioNline"line", AudioNspeaker"spkr", AudioNheadphone"hp", AudioNcd"cd",
311	"SPDIF", "digital-out", "modem-line", "modem-handset",
312	"line-in", AudioNaux"aux", AudioNmicrophone"mic", "telephony",
313	"SPDIF-in", "digital-in", "beep", "other"};
314	static const char *wtypes[16] = {
315	"dac", "adc", "mix", "sel", "pin", "pow", "volume",
316	"beep", "wid08", "wid09", "wid0a", "wid0b", "wid0c",
317	"wid0d", "wid0e", "vendor"};
318	static const char *line_colors[16] = {
319	"unk", "blk", "gry", "blu", "grn", "red", "org", "yel",
320	"pur", "pnk", "0xa", "0xb", "0xc", "0xd", "wht", "oth"};
321
322	/* ================================================================
323	* PCI functions
324	* ================================================================ */
325
326	#define ATI_PCIE_SNOOP_REG0x42 0x42
327	#define ATI_PCIE_SNOOP_MASK0xf8 0xf8
328	#define ATI_PCIE_SNOOP_ENABLE0x02 0x02
329	#define NVIDIA_PCIE_SNOOP_REG0x4e 0x4e
330	#define NVIDIA_PCIE_SNOOP_MASK0xf0 0xf0
331	#define NVIDIA_PCIE_SNOOP_ENABLE0x0f 0x0f
332	#define NVIDIA_HDA_ISTR_COH_REG0x4d 0x4d
333	#define NVIDIA_HDA_OSTR_COH_REG0x4c 0x4c
334	#define NVIDIA_HDA_STR_COH_ENABLE0x01 0x01
335	#define INTEL_PCIE_NOSNOOP_REG0x79 0x79
336	#define INTEL_PCIE_NOSNOOP_MASK0xf7 0xf7
337	#define INTEL_PCIE_NOSNOOP_ENABLE0x08 0x08
338
339	uint8_t
340	azalia_pci_read(pci_chipset_tag_t pc, pcitag_t pa, int reg)
341	{
342	return (pci_conf_read(pc, pa, (reg & ~0x03)) >>
343	((reg & 0x03) * 8) & 0xff);
344	}
345
346	void
347	azalia_pci_write(pci_chipset_tag_t pc, pcitag_t pa, int reg, uint8_t val)
348	{
349	pcireg_t pcival;
350
351	pcival = pci_conf_read(pc, pa, (reg & ~0x03));
352	pcival &= ~(0xff << ((reg & 0x03) * 8));
353	pcival \|= (val << ((reg & 0x03) * 8));
354	pci_conf_write(pc, pa, (reg & ~0x03), pcival);
355	}
356
357	void
358	azalia_configure_pci(azalia_t *az)
359	{
360	pcireg_t v;
361	uint8_t reg;
362
363	/* enable back-to-back */
364	v = pci_conf_read(az->pc, az->tag, PCI_COMMAND_STATUS_REG0x04);
365	pci_conf_write(az->pc, az->tag, PCI_COMMAND_STATUS_REG0x04,
366	v \| PCI_COMMAND_BACKTOBACK_ENABLE0x00000200);
367
368	/* traffic class select */
369	v = pci_conf_read(az->pc, az->tag, ICH_PCI_HDTCSEL0x44);
370	pci_conf_write(az->pc, az->tag, ICH_PCI_HDTCSEL0x44,
371	v & ~(ICH_PCI_HDTCSEL_MASK0x7));
372
373	/* enable PCIe snoop */
374	switch (PCI_PRODUCT(az->pciid)(((az->pciid) >> 16) & 0xffff)) {
375	case PCI_PRODUCT_ATI_SB450_HDA0x437b:
376	case PCI_PRODUCT_ATI_SBX00_HDA0x4383:
377	case PCI_PRODUCT_AMD_15_6X_AUDIO0x157a:
378	case PCI_PRODUCT_AMD_17_HDA0x1457:
379	case PCI_PRODUCT_AMD_17_1X_HDA0x15e3:
380	case PCI_PRODUCT_AMD_17_3X_HDA0x1487:
381	case PCI_PRODUCT_AMD_HUDSON2_HDA0x780d:
382	reg = azalia_pci_read(az->pc, az->tag, ATI_PCIE_SNOOP_REG0x42);
383	reg &= ATI_PCIE_SNOOP_MASK0xf8;
384	reg \|= ATI_PCIE_SNOOP_ENABLE0x02;
385	azalia_pci_write(az->pc, az->tag, ATI_PCIE_SNOOP_REG0x42, reg);
386	break;
387	case PCI_PRODUCT_NVIDIA_MCP51_HDA0x026c:
388	case PCI_PRODUCT_NVIDIA_MCP55_HDA0x0371:
389	case PCI_PRODUCT_NVIDIA_MCP61_HDA_10x03e4:
390	case PCI_PRODUCT_NVIDIA_MCP61_HDA_20x03f0:
391	case PCI_PRODUCT_NVIDIA_MCP65_HDA_10x044a:
392	case PCI_PRODUCT_NVIDIA_MCP65_HDA_20x044b:
393	case PCI_PRODUCT_NVIDIA_MCP67_HDA_10x055c:
394	case PCI_PRODUCT_NVIDIA_MCP67_HDA_20x055d:
395	case PCI_PRODUCT_NVIDIA_MCP73_HDA_10x07fc:
396	case PCI_PRODUCT_NVIDIA_MCP73_HDA_20x07fd:
397	case PCI_PRODUCT_NVIDIA_MCP77_HDA_10x0774:
398	case PCI_PRODUCT_NVIDIA_MCP77_HDA_20x0775:
399	case PCI_PRODUCT_NVIDIA_MCP77_HDA_30x0776:
400	case PCI_PRODUCT_NVIDIA_MCP77_HDA_40x0777:
401	case PCI_PRODUCT_NVIDIA_MCP79_HDA_10x0ac0:
402	case PCI_PRODUCT_NVIDIA_MCP79_HDA_20x0ac1:
403	case PCI_PRODUCT_NVIDIA_MCP79_HDA_30x0ac2:
404	case PCI_PRODUCT_NVIDIA_MCP79_HDA_40x0ac3:
405	case PCI_PRODUCT_NVIDIA_MCP89_HDA_10x0d94:
406	case PCI_PRODUCT_NVIDIA_MCP89_HDA_20x0d95:
407	case PCI_PRODUCT_NVIDIA_MCP89_HDA_30x0d96:
408	case PCI_PRODUCT_NVIDIA_MCP89_HDA_40x0d97:
409	reg = azalia_pci_read(az->pc, az->tag,
410	NVIDIA_HDA_OSTR_COH_REG0x4c);
411	reg \|= NVIDIA_HDA_STR_COH_ENABLE0x01;
412	azalia_pci_write(az->pc, az->tag,
413	NVIDIA_HDA_OSTR_COH_REG0x4c, reg);
414
415	reg = azalia_pci_read(az->pc, az->tag,
416	NVIDIA_HDA_ISTR_COH_REG0x4d);
417	reg \|= NVIDIA_HDA_STR_COH_ENABLE0x01;
418	azalia_pci_write(az->pc, az->tag,
419	NVIDIA_HDA_ISTR_COH_REG0x4d, reg);
420
421	reg = azalia_pci_read(az->pc, az->tag,
422	NVIDIA_PCIE_SNOOP_REG0x4e);
423	reg &= NVIDIA_PCIE_SNOOP_MASK0xf0;
424	reg \|= NVIDIA_PCIE_SNOOP_ENABLE0x0f;
425	azalia_pci_write(az->pc, az->tag,
426	NVIDIA_PCIE_SNOOP_REG0x4e, reg);
427
428	reg = azalia_pci_read(az->pc, az->tag,
429	NVIDIA_PCIE_SNOOP_REG0x4e);
430	if ((reg & NVIDIA_PCIE_SNOOP_ENABLE0x0f) !=
431	NVIDIA_PCIE_SNOOP_ENABLE0x0f) {
432	printf(": could not enable PCIe cache snooping!\n");
433	}
434	break;
435	case PCI_PRODUCT_INTEL_82801FB_HDA0x2668:
436	case PCI_PRODUCT_INTEL_82801GB_HDA0x27d8:
437	case PCI_PRODUCT_INTEL_82801H_HDA0x284b:
438	case PCI_PRODUCT_INTEL_82801I_HDA0x293e:
439	case PCI_PRODUCT_INTEL_82801JI_HDA0x3a3e:
440	case PCI_PRODUCT_INTEL_82801JD_HDA0x3a6e:
441	case PCI_PRODUCT_INTEL_6321ESB_HDA0x269a:
442	case PCI_PRODUCT_INTEL_3400_HDA0x3b56:
443	case PCI_PRODUCT_INTEL_QS57_HDA0x3b57:
444	case PCI_PRODUCT_INTEL_6SERIES_HDA0x1c20:
445	case PCI_PRODUCT_INTEL_7SERIES_HDA0x1e20:
446	case PCI_PRODUCT_INTEL_8SERIES_HDA0x8c20:
447	case PCI_PRODUCT_INTEL_8SERIES_LP_HDA0x9c20:
448	case PCI_PRODUCT_INTEL_9SERIES_HDA0x8ca0:
449	case PCI_PRODUCT_INTEL_9SERIES_LP_HDA0x9ca0:
450	case PCI_PRODUCT_INTEL_100SERIES_HDA0xa170:
451	case PCI_PRODUCT_INTEL_100SERIES_H_HDA0xa171:
452	case PCI_PRODUCT_INTEL_100SERIES_LP_HDA0x9d70:
453	case PCI_PRODUCT_INTEL_200SERIES_HDA0xa2f0:
454	case PCI_PRODUCT_INTEL_200SERIES_U_HDA0x9d71:
455	case PCI_PRODUCT_INTEL_300SERIES_CAVS0xa348:
456	case PCI_PRODUCT_INTEL_300SERIES_U_HDA0x9dc8:
457	case PCI_PRODUCT_INTEL_400SERIES_CAVS0x06c8:
458	case PCI_PRODUCT_INTEL_400SERIES_LP_HDA0x02c8:
459	case PCI_PRODUCT_INTEL_495SERIES_LP_HDA0x34c8:
460	case PCI_PRODUCT_INTEL_500SERIES_HDA0x43c8:
461	case PCI_PRODUCT_INTEL_500SERIES_HDA_20xf0c8:
462	case PCI_PRODUCT_INTEL_500SERIES_LP_HDA0xa0c8:
463	case PCI_PRODUCT_INTEL_600SERIES_HDA0x7ad0:
464	case PCI_PRODUCT_INTEL_600SERIES_LP_HDA0x51c8:
465	case PCI_PRODUCT_INTEL_700SERIES_HDA0x7a50:
466	case PCI_PRODUCT_INTEL_700SERIES_LP_HDA0x51ca:
467	case PCI_PRODUCT_INTEL_C600_HDA0x1d20:
468	case PCI_PRODUCT_INTEL_C610_HDA_10x8d20:
469	case PCI_PRODUCT_INTEL_C610_HDA_20x8d21:
470	case PCI_PRODUCT_INTEL_C620_HDA_10xa1f0:
471	case PCI_PRODUCT_INTEL_C620_HDA_20xa270:
472	case PCI_PRODUCT_INTEL_APOLLOLAKE_HDA0x5a98:
473	case PCI_PRODUCT_INTEL_BAYTRAIL_HDA0x0f04:
474	case PCI_PRODUCT_INTEL_BSW_HDA0x2284:
475	case PCI_PRODUCT_INTEL_GLK_HDA0x3198:
476	case PCI_PRODUCT_INTEL_JSL_HDA0x4dc8:
477	case PCI_PRODUCT_INTEL_EHL_HDA0x4b58:
478	case PCI_PRODUCT_INTEL_ADL_N_HDA0x54c8:
479	reg = azalia_pci_read(az->pc, az->tag,
480	INTEL_PCIE_NOSNOOP_REG0x79);
481	reg &= INTEL_PCIE_NOSNOOP_MASK0xf7;
482	azalia_pci_write(az->pc, az->tag,
483	INTEL_PCIE_NOSNOOP_REG0x79, reg);
484	break;
485	}
486	}
487
488	const struct pci_matchid azalia_pci_devices[] = {
489	{ PCI_VENDOR_INTEL0x8086, PCI_PRODUCT_INTEL_200SERIES_U_HDA0x9d71 },
490	{ PCI_VENDOR_INTEL0x8086, PCI_PRODUCT_INTEL_300SERIES_CAVS0xa348 },
491	{ PCI_VENDOR_INTEL0x8086, PCI_PRODUCT_INTEL_300SERIES_U_HDA0x9dc8 },
492	{ PCI_VENDOR_INTEL0x8086, PCI_PRODUCT_INTEL_400SERIES_CAVS0x06c8 },
493	{ PCI_VENDOR_INTEL0x8086, PCI_PRODUCT_INTEL_400SERIES_LP_HDA0x02c8 },
494	{ PCI_VENDOR_INTEL0x8086, PCI_PRODUCT_INTEL_500SERIES_HDA0x43c8 },
495	{ PCI_VENDOR_INTEL0x8086, PCI_PRODUCT_INTEL_500SERIES_LP_HDA0xa0c8 },
496	{ PCI_VENDOR_INTEL0x8086, PCI_PRODUCT_INTEL_600SERIES_LP_HDA0x51c8 },
497	{ PCI_VENDOR_INTEL0x8086, PCI_PRODUCT_INTEL_700SERIES_LP_HDA0x51ca },
498	{ PCI_VENDOR_INTEL0x8086, PCI_PRODUCT_INTEL_APOLLOLAKE_HDA0x5a98 },
499	{ PCI_VENDOR_INTEL0x8086, PCI_PRODUCT_INTEL_GLK_HDA0x3198 },
500	{ PCI_VENDOR_INTEL0x8086, PCI_PRODUCT_INTEL_JSL_HDA0x4dc8 },
501	{ PCI_VENDOR_INTEL0x8086, PCI_PRODUCT_INTEL_EHL_HDA0x4b58 },
502	{ PCI_VENDOR_INTEL0x8086, PCI_PRODUCT_INTEL_ADL_N_HDA0x54c8 },
503	};
504
505	int
506	azalia_pci_match(struct device parent, void match, void *aux)
507	{
508	struct pci_attach_args *pa;
509
510	pa = aux;
511	if (PCI_CLASS(pa->pa_class)(((pa->pa_class) >> 24) & 0xff) == PCI_CLASS_MULTIMEDIA0x04
512	&& PCI_SUBCLASS(pa->pa_class)(((pa->pa_class) >> 16) & 0xff) == PCI_SUBCLASS_MULTIMEDIA_HDAUDIO0x03)
513	return 1;
514	return pci_matchbyid((struct pci_attach_args *)aux, azalia_pci_devices,
515	nitems(azalia_pci_devices)(sizeof((azalia_pci_devices)) / sizeof((azalia_pci_devices)[0 ])));
516	}
517
518	void
519	azalia_pci_attach(struct device parent, struct device self, void *aux)
520	{
521	azalia_t *sc;
522	struct pci_attach_args *pa;
523	pcireg_t v;
524	uint8_t reg;
525	pci_intr_handle_t ih;
526	const char *interrupt_str;
527
528	sc = (azalia_t*)self;
529	pa = aux;
530
531	sc->dmat = pa->pa_dmat;
532
533	pci_set_powerstate(pa->pa_pc, pa->pa_tag, PCI_PMCSR_STATE_D00x0000);
534
535	v = pci_conf_read(pa->pa_pc, pa->pa_tag, ICH_PCI_HDBARL0x10);
536	v &= PCI_MAPREG_TYPE_MASK0x00000001 \| PCI_MAPREG_MEM_TYPE_MASK0x00000006;
537	if (pci_mapreg_map(pa, ICH_PCI_HDBARL0x10, v, 0,
538	&sc->iot, &sc->ioh, NULL((void *)0), &sc->map_size, 0)) {
539	printf(": can't map device i/o space\n");
540	return;
541	}
542
543	sc->pc = pa->pa_pc;
544	sc->tag = pa->pa_tag;
545	sc->pciid = pa->pa_id;
546	sc->subid = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG0x2c);
547
548	azalia_configure_pci(sc);
549
550	/* disable MSI, use INTx instead */
551	if (PCI_VENDOR(sc->pciid)(((sc->pciid) >> 0) & 0xffff) == PCI_VENDOR_INTEL0x8086) {
552	reg = azalia_pci_read(sc->pc, sc->tag, ICH_PCI_MMC0x62);
553	reg &= ~(ICH_PCI_MMC_ME0x1);
554	azalia_pci_write(sc->pc, sc->tag, ICH_PCI_MMC0x62, reg);
555	}
556
557	/* disable MSI for AMD Summit Ridge/Raven Ridge HD Audio */
558	if (PCI_VENDOR(sc->pciid)(((sc->pciid) >> 0) & 0xffff) == PCI_VENDOR_AMD0x1022) {
559	switch (PCI_PRODUCT(sc->pciid)(((sc->pciid) >> 16) & 0xffff)) {
560	case PCI_PRODUCT_AMD_17_HDA0x1457:
561	case PCI_PRODUCT_AMD_17_1X_HDA0x15e3:
562	case PCI_PRODUCT_AMD_HUDSON2_HDA0x780d:
563	pa->pa_flags &= ~PCI_FLAGS_MSI_ENABLED0x20;
564	}
565	}
566
567	/* interrupt */
568	if (pci_intr_map_msi(pa, &ih) && pci_intr_map(pa, &ih)) {
569	printf(": can't map interrupt\n");
570	return;
571	}
572	interrupt_str = pci_intr_string(pa->pa_pc, ih);
573	sc->ih = pci_intr_establish(pa->pa_pc, ih, IPL_AUDIO0xb \| IPL_MPSAFE0x100,
574	azalia_intr, sc, sc->dev.dv_xname);
575	if (sc->ih == NULL((void *)0)) {
576	printf(": can't establish interrupt");
577	if (interrupt_str != NULL((void *)0))
578	printf(" at %s", interrupt_str);
579	printf("\n");
580	return;
581	}
582	printf(": %s\n", interrupt_str);
583
584	if (azalia_init(sc, 0))
585	goto err_exit;
586
587	if (azalia_init_codecs(sc))
588	goto err_exit;
589
590	if (azalia_init_streams(sc))
591	goto err_exit;
592
593	audio_attach_mi(&azalia_hw_if, sc, NULL((void *)0), &sc->dev);
594
595	return;
596
597	err_exit:
598	sc->detached = 1;
599	azalia_pci_detach(self, 0);
600	}
601
602	int
603	azalia_pci_activate(struct device *self, int act)
604	{
605	azalia_t sc = (azalia_t)self;
606	int rv = 0;
607
608	switch (act) {
609	case DVACT_SUSPEND3:
610	azalia_suspend(sc);
611	break;
612	case DVACT_POWERDOWN6:
613	azalia_shutdown(sc);
614	break;
615	case DVACT_RESUME4:
616	azalia_resume(sc);
617	rv = config_activate_children(self, act);
618	break;
619	default:
620	rv = config_activate_children(self, act);
621	break;
622	}
623	return (rv);
624	}
625
626	int
627	azalia_pci_detach(struct device *self, int flags)
628	{
629	azalia_t az = (azalia_t)self;
630	uint32_t gctl;
631	int i;
632
633	DPRINTF(("%s\n", __func__))do {} while (0 );
634
635	/*
636	* this function is called if the device could not be supported,
637	* in which case az->detached == 1. check if this function has
638	* already cleaned up.
639	*/
640	if (az->detached > 1)
641	return 0;
642
643	config_detach_children(self, flags);
644
645	/* disable unsolicited responses if soft detaching */
646	if (az->detached == 1) {
647	gctl = AZ_READ_4(az, GCTL)(((az)->iot)->read_4(((az)->ioh), (0x008)));
648	AZ_WRITE_4(az, GCTL, gctl &~(HDA_GCTL_UNSOL))(((az)->iot)->write_4(((az)->ioh), (0x008), (gctl & ~(0x00000100))));
649	}
650
651	timeout_del(&az->unsol_to);
652
653	DPRINTF(("%s: delete streams\n", __func__))do {} while (0 );
654	if (az->rstream.bdlist.addr != NULL((void *)0))
655	azalia_free_dmamem(az, &az->rstream.bdlist);
656	if (az->pstream.bdlist.addr != NULL((void *)0))
657	azalia_free_dmamem(az, &az->pstream.bdlist);
658
659	DPRINTF(("%s: delete codecs\n", __func__))do {} while (0 );
660	for (i = 0; i < az->ncodecs; i++) {
661	azalia_codec_delete(&az->codecs[i]);
662	}
663	az->ncodecs = 0;
664	if (az->codecs != NULL((void *)0)) {
665	free(az->codecs, M_DEVBUF2, 0);
666	az->codecs = NULL((void *)0);
667	}
668
669	DPRINTF(("%s: delete CORB and RIRB\n", __func__))do {} while (0 );
670	if (az->corb_dma.addr != NULL((void *)0))
671	azalia_free_dmamem(az, &az->corb_dma);
672	if (az->rirb_dma.addr != NULL((void *)0))
673	azalia_free_dmamem(az, &az->rirb_dma);
674	if (az->unsolq != NULL((void *)0)) {
675	free(az->unsolq, M_DEVBUF2, 0);
676	az->unsolq = NULL((void *)0);
677	}
678
679	/* disable interrupts if soft detaching */
680	if (az->detached == 1) {
681	DPRINTF(("%s: disable interrupts\n", __func__))do {} while (0 );
682	AZ_WRITE_4(az, INTCTL, 0)(((az)->iot)->write_4(((az)->ioh), (0x020), (0)));
683
684	DPRINTF(("%s: clear interrupts\n", __func__))do {} while (0 );
685	AZ_WRITE_4(az, INTSTS, HDA_INTSTS_CIS \| HDA_INTSTS_GIS)(((az)->iot)->write_4(((az)->ioh), (0x024), (0x40000000 \| 0x80000000)));
686	AZ_WRITE_2(az, STATESTS, HDA_STATESTS_SDIWAKE)(((az)->iot)->write_2(((az)->ioh), (0x00e), (0x7fff) ));
687	AZ_WRITE_1(az, RIRBSTS, HDA_RIRBSTS_RINTFL \| HDA_RIRBSTS_RIRBOIS)(((az)->iot)->write_1(((az)->ioh), (0x05d), (0x01 \| 0x04 )));
688	}
689
690	DPRINTF(("%s: delete PCI resources\n", __func__))do {} while (0 );
691	if (az->ih != NULL((void *)0)) {
692	pci_intr_disestablish(az->pc, az->ih);
693	az->ih = NULL((void *)0);
694	}
695	if (az->map_size != 0) {
696	bus_space_unmap(az->iot, az->ioh, az->map_size);
697	az->map_size = 0;
698	}
699
700	az->detached = 2;
701	return 0;
702	}
703
704	int
705	azalia_intr(void *v)
706	{
707	azalia_t *az = v;
708	uint32_t intsts;
709	int ret = 0;
710
711	mtx_enter(&audio_lock);
712	intsts = AZ_READ_4(az, INTSTS)(((az)->iot)->read_4(((az)->ioh), (0x024)));
713	if (intsts == 0 \|\| intsts == 0xffffffff) {
714	mtx_leave(&audio_lock);
715	return (ret);
716	}
717
718	AZ_WRITE_4(az, INTSTS, intsts)(((az)->iot)->write_4(((az)->ioh), (0x024), (intsts) ));
719
720	if (intsts & az->pstream.intr_bit) {
721	azalia_stream_intr(&az->pstream);
722	ret = 1;
723	}
724
725	if (intsts & az->rstream.intr_bit) {
726	azalia_stream_intr(&az->rstream);
727	ret = 1;
728	}
729
730	if ((intsts & HDA_INTSTS_CIS0x40000000) &&
731	(AZ_READ_1(az, RIRBCTL)(((az)->iot)->read_1(((az)->ioh), (0x05c))) & HDA_RIRBCTL_RINTCTL0x01) &&
732	(AZ_READ_1(az, RIRBSTS)(((az)->iot)->read_1(((az)->ioh), (0x05d))) & HDA_RIRBSTS_RINTFL0x01)) {
733	azalia_rirb_intr(az);
734	ret = 1;
735	}
736	mtx_leave(&audio_lock);
737	return (ret);
738	}
739
740	void
741	azalia_shutdown(void *v)
742	{
743	azalia_t az = (azalia_t )v;
744	uint32_t gctl;
745
746	if (az->detached)
747	return;
748
749	/* disable unsolicited response */
750	gctl = AZ_READ_4(az, GCTL)(((az)->iot)->read_4(((az)->ioh), (0x008)));
751	AZ_WRITE_4(az, GCTL, gctl & ~(HDA_GCTL_UNSOL))(((az)->iot)->write_4(((az)->ioh), (0x008), (gctl & ~(0x00000100))));
752
753	timeout_del(&az->unsol_to);
754
755	/* halt CORB/RIRB */
756	azalia_halt_corb(az);
757	azalia_halt_rirb(az);
758	}
759
760	/* ================================================================
761	* HDA controller functions
762	* ================================================================ */
763
764	void
765	azalia_print_codec(codec_t *codec)
766	{
767	const char *vendor;
768
769	if (codec->name == NULL((void *)0)) {
770	vendor = pci_findvendor(codec->vid >> 16);
771	if (vendor == NULL((void *)0))
772	printf("0x%04x/0x%04x",
773	codec->vid >> 16, codec->vid & 0xffff);
774	else
775	printf("%s/0x%04x", vendor, codec->vid & 0xffff);
776	} else
777	printf("%s", codec->name);
778	}
779
780	int
781	azalia_reset(azalia_t *az)
782	{
783	uint32_t gctl;
784	int i;
785
786	/* 4.2.2 Starting the High Definition Audio Controller */
787	DPRINTF(("%s: resetting\n", __func__))do {} while (0 );
788	gctl = AZ_READ_4(az, GCTL)(((az)->iot)->read_4(((az)->ioh), (0x008)));
789	AZ_WRITE_4(az, GCTL, gctl & ~HDA_GCTL_CRST)(((az)->iot)->write_4(((az)->ioh), (0x008), (gctl & ~0x00000001)));
790	for (i = 5000; i > 0; i--) {
791	DELAY(10)(*delay_func)(10);
792	if ((AZ_READ_4(az, GCTL)(((az)->iot)->read_4(((az)->ioh), (0x008))) & HDA_GCTL_CRST0x00000001) == 0)
793	break;
794	}
795	DPRINTF(("%s: reset counter = %d\n", __func__, i))do {} while (0 );
796	if (i == 0) {
797	DPRINTF(("%s: reset failure\n", XNAME(az)))do {} while (0 );
798	return(ETIMEDOUT60);
799	}
800	DELAY(1000)(*delay_func)(1000);
801	gctl = AZ_READ_4(az, GCTL)(((az)->iot)->read_4(((az)->ioh), (0x008)));
802	AZ_WRITE_4(az, GCTL, gctl \| HDA_GCTL_CRST)(((az)->iot)->write_4(((az)->ioh), (0x008), (gctl \| 0x00000001 )));
803	for (i = 5000; i > 0; i--) {
804	DELAY(10)(*delay_func)(10);
805	if (AZ_READ_4(az, GCTL)(((az)->iot)->read_4(((az)->ioh), (0x008))) & HDA_GCTL_CRST0x00000001)
806	break;
807	}
808	DPRINTF(("%s: reset counter = %d\n", __func__, i))do {} while (0 );
809	if (i == 0) {
810	DPRINTF(("%s: reset-exit failure\n", XNAME(az)))do {} while (0 );
811	return(ETIMEDOUT60);
812	}
813	DELAY(1000)(*delay_func)(1000);
814
815	return(0);
816	}
817
818	int
819	azalia_get_ctrlr_caps(azalia_t *az)
820	{
821	int i, n;
822	uint16_t gcap;
823	uint16_t statests;
824	uint8_t cap;
825
826	DPRINTF(("%s: host: High Definition Audio rev. %d.%d\n",do {} while (0 )
827	XNAME(az), AZ_READ_1(az, VMAJ), AZ_READ_1(az, VMIN)))do {} while (0 );
828	gcap = AZ_READ_2(az, GCAP)(((az)->iot)->read_2(((az)->ioh), (0x000)));
829	az->nistreams = HDA_GCAP_ISS(gcap)((gcap & 0x0f00) >> 8);
830	az->nostreams = HDA_GCAP_OSS(gcap)((gcap & 0xf000) >> 12);
831	az->nbstreams = HDA_GCAP_BSS(gcap)((gcap & 0x00f8) >> 3);
832	az->ok64 = (gcap & HDA_GCAP_64OK0x0001) != 0;
833	DPRINTF(("%s: host: %d output, %d input, and %d bidi streams\n",do {} while (0 )
834	XNAME(az), az->nostreams, az->nistreams, az->nbstreams))do {} while (0 );
835
836	/* 4.3 Codec discovery */
837	statests = AZ_READ_2(az, STATESTS)(((az)->iot)->read_2(((az)->ioh), (0x00e)));
838	for (i = 0, n = 0; i < HDA_MAX_CODECS15; i++) {
839	if ((statests >> i) & 1) {
840	DPRINTF(("%s: found a codec at #%d\n", XNAME(az), i))do {} while (0 );
841	n++;
842	}
843	}
844	az->ncodecs = n;
845	if (az->ncodecs < 1) {
846	printf("%s: no HD-Audio codecs\n", XNAME(az)((az)->dev.dv_xname));
847	return -1;
848	}
849	az->codecs = mallocarray(az->ncodecs, sizeof(codec_t), M_DEVBUF2,
850	M_NOWAIT0x0002 \| M_ZERO0x0008);
851	if (az->codecs == NULL((void *)0)) {
852	printf("%s: can't allocate memory for codecs\n", XNAME(az)((az)->dev.dv_xname));
853	return ENOMEM12;
854	}
855	for (i = 0, n = 0; n < az->ncodecs; i++) {
856	if ((statests >> i) & 1) {
857	az->codecs[n].address = i;
858	az->codecs[n++].az = az;
859	}
860	}
861
862	/* determine CORB size */
863	az->corbsize = AZ_READ_1(az, CORBSIZE)(((az)->iot)->read_1(((az)->ioh), (0x04e)));
864	cap = az->corbsize & HDA_CORBSIZE_CORBSZCAP_MASK0xf0;
865	az->corbsize &= ~HDA_CORBSIZE_CORBSIZE_MASK0x03;
866	if (cap & HDA_CORBSIZE_CORBSZCAP_2560x40) {
867	az->corb_entries = 256;
868	az->corbsize \|= HDA_CORBSIZE_CORBSIZE_2560x02;
869	} else if (cap & HDA_CORBSIZE_CORBSZCAP_160x20) {
870	az->corb_entries = 16;
871	az->corbsize \|= HDA_CORBSIZE_CORBSIZE_160x01;
872	} else if (cap & HDA_CORBSIZE_CORBSZCAP_20x10) {
873	az->corb_entries = 2;
874	az->corbsize \|= HDA_CORBSIZE_CORBSIZE_20x00;
875	} else {
876	printf("%s: invalid CORBSZCAP: 0x%2x\n", XNAME(az)((az)->dev.dv_xname), cap);
877	return(-1);
878	}
879
880	/* determine RIRB size */
881	az->rirbsize = AZ_READ_1(az, RIRBSIZE)(((az)->iot)->read_1(((az)->ioh), (0x05e)));
882	cap = az->rirbsize & HDA_RIRBSIZE_RIRBSZCAP_MASK0xf0;
883	az->rirbsize &= ~HDA_RIRBSIZE_RIRBSIZE_MASK0x03;
884	if (cap & HDA_RIRBSIZE_RIRBSZCAP_2560x40) {
885	az->rirb_entries = 256;
886	az->rirbsize \|= HDA_RIRBSIZE_RIRBSIZE_2560x02;
887	} else if (cap & HDA_RIRBSIZE_RIRBSZCAP_160x20) {
888	az->rirb_entries = 16;
889	az->rirbsize \|= HDA_RIRBSIZE_RIRBSIZE_160x01;
890	} else if (cap & HDA_RIRBSIZE_RIRBSZCAP_20x10) {
891	az->rirb_entries = 2;
892	az->rirbsize \|= HDA_RIRBSIZE_RIRBSIZE_20x00;
893	} else {
894	printf("%s: invalid RIRBSZCAP: 0x%2x\n", XNAME(az)((az)->dev.dv_xname), cap);
895	return(-1);
896	}
897
898	return(0);
899	}
900
901	int
902	azalia_init(azalia_t *az, int resuming)
903	{
904	int err;
905
906	err = azalia_reset(az);
907	if (err)
908	return(err);
909
910	if (!resuming) {
911	err = azalia_get_ctrlr_caps(az);
912	if (err)
913	return(err);
914	}
915
916	/* clear interrupt status */
917	AZ_WRITE_2(az, STATESTS, HDA_STATESTS_SDIWAKE)(((az)->iot)->write_2(((az)->ioh), (0x00e), (0x7fff) ));
918	AZ_WRITE_1(az, RIRBSTS, HDA_RIRBSTS_RINTFL \| HDA_RIRBSTS_RIRBOIS)(((az)->iot)->write_1(((az)->ioh), (0x05d), (0x01 \| 0x04 )));
919	AZ_WRITE_4(az, INTSTS, HDA_INTSTS_CIS \| HDA_INTSTS_GIS)(((az)->iot)->write_4(((az)->ioh), (0x024), (0x40000000 \| 0x80000000)));
920	AZ_WRITE_4(az, DPLBASE, 0)(((az)->iot)->write_4(((az)->ioh), (0x070), (0)));
921	AZ_WRITE_4(az, DPUBASE, 0)(((az)->iot)->write_4(((az)->ioh), (0x074), (0)));
922
923	/* 4.4.1 Command Outbound Ring Buffer */
924	err = azalia_init_corb(az, resuming);
925	if (err)
926	return(err);
927
928	/* 4.4.2 Response Inbound Ring Buffer */
929	err = azalia_init_rirb(az, resuming);
930	if (err)
931	return(err);
932
933	AZ_WRITE_4(az, INTCTL,(((az)->iot)->write_4(((az)->ioh), (0x020), ((((az)-> iot)->read_4(((az)->ioh), (0x020))) \| 0x40000000 \| 0x80000000 )))
934	AZ_READ_4(az, INTCTL) \| HDA_INTCTL_CIE \| HDA_INTCTL_GIE)(((az)->iot)->write_4(((az)->ioh), (0x020), ((((az)-> iot)->read_4(((az)->ioh), (0x020))) \| 0x40000000 \| 0x80000000 )));
935
936	return(0);
937	}
938
939	int
940	azalia_init_codecs(azalia_t *az)
941	{
942	codec_t *codec;
943	int c, i;
944
945	c = 0;
946	for (i = 0; i < az->ncodecs; i++) {
947	if (!azalia_codec_init(&az->codecs[i]))
948	c++;
949	}
950	if (c == 0) {
951	printf("%s: No codecs found\n", XNAME(az)((az)->dev.dv_xname));
952	return(1);
953	}
954
955	/* Use the first codec capable of analog I/O. If there are none,
956	* use the first codec capable of digital I/O. Skip HDMI codecs.
957	*/
958	c = -1;
959	for (i = 0; i < az->ncodecs; i++) {
960	codec = &az->codecs[i];
961	if ((codec->audiofunc < 0) \|\|
962	(codec->codec_type == AZ_CODEC_TYPE_HDMI2))
963	continue;
964	if (codec->codec_type == AZ_CODEC_TYPE_DIGITAL1) {
965	if (c < 0)
966	c = i;
967	} else {
968	c = i;
969	break;
970	}
971	}
972	az->codecno = c;
973	if (az->codecno < 0) {
974	printf("%s: no supported codecs\n", XNAME(az)((az)->dev.dv_xname));
975	return(1);
976	}
977
978	printf("%s: codecs: ", XNAME(az)((az)->dev.dv_xname));
979	for (i = 0; i < az->ncodecs; i++) {
980	azalia_print_codec(&az->codecs[i]);
981	if (i < az->ncodecs - 1)
982	printf(", ");
983	}
984	if (az->ncodecs > 1) {
985	printf(", using ");
986	azalia_print_codec(&az->codecs[az->codecno]);
987	}
988	printf("\n");
989
990	/* All codecs with audio are enabled, but only one will be used. */
991	for (i = 0; i < az->ncodecs; i++) {
992	codec = &az->codecs[i];
993	if (i != az->codecno) {
994	if (codec->audiofunc < 0)
995	continue;
996	azalia_comresp(codec, codec->audiofunc,
997	CORB_SET_POWER_STATE0x705, CORB_PS_D30x3, NULL((void *)0));
998	DELAY(100)(*delay_func)(100);
999	azalia_codec_delete(codec);
1000	}
1001	}
1002
1003	/* Enable unsolicited responses now that az->codecno is set. */
1004	AZ_WRITE_4(az, GCTL, AZ_READ_4(az, GCTL) \| HDA_GCTL_UNSOL)(((az)->iot)->write_4(((az)->ioh), (0x008), ((((az)-> iot)->read_4(((az)->ioh), (0x008))) \| 0x00000100)));
1005
1006	return(0);
1007	}
1008
1009	int
1010	azalia_init_streams(azalia_t *az)
1011	{
1012	int err;
1013
1014	/* Use stream#1 and #2. Don't use stream#0. */
1015	err = azalia_stream_init(&az->pstream, az, az->nistreams + 0,
1016	1, AUMODE_PLAY0x01);
1017	if (err)
1018	return(err);
1019	err = azalia_stream_init(&az->rstream, az, 0, 2, AUMODE_RECORD0x02);
1020	if (err)
1021	return(err);
1022
1023	return(0);
1024	}
1025
1026	int
1027	azalia_halt_corb(azalia_t *az)
1028	{
1029	uint8_t corbctl;
1030	codec_t *codec;
1031	int i;
1032
1033	corbctl = AZ_READ_1(az, CORBCTL)(((az)->iot)->read_1(((az)->ioh), (0x04c)));
1034	if (corbctl & HDA_CORBCTL_CORBRUN0x02) { /* running? */
1035	/* power off all codecs */
1036	for (i = 0; i < az->ncodecs; i++) {
1037	codec = &az->codecs[i];
1038	if (codec->audiofunc < 0)
1039	continue;
1040	azalia_comresp(codec, codec->audiofunc,
1041	CORB_SET_POWER_STATE0x705, CORB_PS_D30x3, NULL((void *)0));
1042	}
1043
1044	AZ_WRITE_1(az, CORBCTL, corbctl & ~HDA_CORBCTL_CORBRUN)(((az)->iot)->write_1(((az)->ioh), (0x04c), (corbctl & ~0x02)));
1045	for (i = 5000; i > 0; i--) {
1046	DELAY(10)(*delay_func)(10);
1047	corbctl = AZ_READ_1(az, CORBCTL)(((az)->iot)->read_1(((az)->ioh), (0x04c)));
1048	if ((corbctl & HDA_CORBCTL_CORBRUN0x02) == 0)
1049	break;
1050	}
1051	if (i == 0) {
1052	DPRINTF(("%s: CORB is running\n", XNAME(az)))do {} while (0 );
1053	return EBUSY16;
1054	}
1055	}
1056	return(0);
1057	}
1058
1059	int
1060	azalia_init_corb(azalia_t *az, int resuming)
1061	{
1062	int err, i;
1063	uint16_t corbrp, corbwp;
1064	uint8_t corbctl;
1065
1066	err = azalia_halt_corb(az);
1067	if (err)
1068	return(err);
1069
1070	if (!resuming) {
1071	err = azalia_alloc_dmamem(az,
1072	az->corb_entries * sizeof(corb_entry_t), 128,
1073	&az->corb_dma);
1074	if (err) {
1075	printf("%s: can't allocate CORB buffer\n", XNAME(az)((az)->dev.dv_xname));
1076	return(err);
1077	}
1078	DPRINTF(("%s: CORB allocation succeeded.\n", __func__))do {} while (0 );
1079	}
1080	timeout_set(&az->unsol_to, azalia_rirb_kick_unsol_events, az);
1081
1082	AZ_WRITE_4(az, CORBLBASE, (uint32_t)AZALIA_DMA_DMAADDR(&az->corb_dma))(((az)->iot)->write_4(((az)->ioh), (0x040), ((uint32_t )((&az->corb_dma)->map->dm_segs[0].ds_addr))));
1083	AZ_WRITE_4(az, CORBUBASE, PTR_UPPER32(AZALIA_DMA_DMAADDR(&az->corb_dma)))(((az)->iot)->write_4(((az)->ioh), (0x044), (((uint64_t )(((&az->corb_dma)->map->dm_segs[0].ds_addr)) >> 32))));
1084	AZ_WRITE_1(az, CORBSIZE, az->corbsize)(((az)->iot)->write_1(((az)->ioh), (0x04e), (az-> corbsize)));
1085
1086	/* reset CORBRP */
1087	corbrp = AZ_READ_2(az, CORBRP)(((az)->iot)->read_2(((az)->ioh), (0x04a)));
1088	AZ_WRITE_2(az, CORBRP, corbrp \| HDA_CORBRP_CORBRPRST)(((az)->iot)->write_2(((az)->ioh), (0x04a), (corbrp \| 0x8000)));
1089	AZ_WRITE_2(az, CORBRP, corbrp & ~HDA_CORBRP_CORBRPRST)(((az)->iot)->write_2(((az)->ioh), (0x04a), (corbrp & ~0x8000)));
1090	for (i = 5000; i > 0; i--) {
1091	DELAY(10)(*delay_func)(10);
1092	corbrp = AZ_READ_2(az, CORBRP)(((az)->iot)->read_2(((az)->ioh), (0x04a)));
1093	if ((corbrp & HDA_CORBRP_CORBRPRST0x8000) == 0)
1094	break;
1095	}
1096	if (i == 0) {
1097	DPRINTF(("%s: CORBRP reset failure\n", XNAME(az)))do {} while (0 );
1098	return -1;
1099	}
1100	DPRINTF(("%s: CORBWP=%d; size=%d\n", __func__,do {} while (0 )
1101	AZ_READ_2(az, CORBRP) & HDA_CORBRP_CORBRP, az->corb_entries))do {} while (0 );
1102
1103	/* clear CORBWP */
1104	corbwp = AZ_READ_2(az, CORBWP)(((az)->iot)->read_2(((az)->ioh), (0x048)));
1105	AZ_WRITE_2(az, CORBWP, corbwp & ~HDA_CORBWP_CORBWP)(((az)->iot)->write_2(((az)->ioh), (0x048), (corbwp & ~0x00ff)));
1106
1107	/* Run! */
1108	corbctl = AZ_READ_1(az, CORBCTL)(((az)->iot)->read_1(((az)->ioh), (0x04c)));
1109	AZ_WRITE_1(az, CORBCTL, corbctl \| HDA_CORBCTL_CORBRUN)(((az)->iot)->write_1(((az)->ioh), (0x04c), (corbctl \| 0x02)));
1110	return 0;
1111	}
1112
1113	int
1114	azalia_halt_rirb(azalia_t *az)
1115	{
1116	int i;
1117	uint8_t rirbctl;
1118
1119	rirbctl = AZ_READ_1(az, RIRBCTL)(((az)->iot)->read_1(((az)->ioh), (0x05c)));
1120	if (rirbctl & HDA_RIRBCTL_RIRBDMAEN0x02) { /* running? */
1121	AZ_WRITE_1(az, RIRBCTL, rirbctl & ~HDA_RIRBCTL_RIRBDMAEN)(((az)->iot)->write_1(((az)->ioh), (0x05c), (rirbctl & ~0x02)));
1122	for (i = 5000; i > 0; i--) {
1123	DELAY(10)(*delay_func)(10);
1124	rirbctl = AZ_READ_1(az, RIRBCTL)(((az)->iot)->read_1(((az)->ioh), (0x05c)));
1125	if ((rirbctl & HDA_RIRBCTL_RIRBDMAEN0x02) == 0)
1126	break;
1127	}
1128	if (i == 0) {
1129	DPRINTF(("%s: RIRB is running\n", XNAME(az)))do {} while (0 );
1130	return(EBUSY16);
1131	}
1132	}
1133	return(0);
1134	}
1135
1136	int
1137	azalia_init_rirb(azalia_t *az, int resuming)
1138	{
1139	int err, i;
1140	uint16_t rirbwp;
1141	uint8_t rirbctl;
1142
1143	err = azalia_halt_rirb(az);
1144	if (err)
1145	return(err);
1146
1147	if (!resuming) {
1148	err = azalia_alloc_dmamem(az,
1149	az->rirb_entries * sizeof(rirb_entry_t), 128,
1150	&az->rirb_dma);
1151	if (err) {
1152	printf("%s: can't allocate RIRB buffer\n", XNAME(az)((az)->dev.dv_xname));
1153	return err;
1154	}
1155	DPRINTF(("%s: RIRB allocation succeeded.\n", __func__))do {} while (0 );
1156
1157	/* setup the unsolicited response queue */
1158	az->unsolq = malloc(sizeof(rirb_entry_t) * UNSOLQ_SIZE256,
1159	M_DEVBUF2, M_NOWAIT0x0002 \| M_ZERO0x0008);
1160	if (az->unsolq == NULL((void *)0)) {
1161	DPRINTF(("%s: can't allocate unsolicited response queue.\n",do {} while (0 )
1162	XNAME(az)))do {} while (0 );
1163	azalia_free_dmamem(az, &az->rirb_dma);
1164	return ENOMEM12;
1165	}
1166	}
1167	AZ_WRITE_4(az, RIRBLBASE, (uint32_t)AZALIA_DMA_DMAADDR(&az->rirb_dma))(((az)->iot)->write_4(((az)->ioh), (0x050), ((uint32_t )((&az->rirb_dma)->map->dm_segs[0].ds_addr))));
1168	AZ_WRITE_4(az, RIRBUBASE, PTR_UPPER32(AZALIA_DMA_DMAADDR(&az->rirb_dma)))(((az)->iot)->write_4(((az)->ioh), (0x054), (((uint64_t )(((&az->rirb_dma)->map->dm_segs[0].ds_addr)) >> 32))));
1169	AZ_WRITE_1(az, RIRBSIZE, az->rirbsize)(((az)->iot)->write_1(((az)->ioh), (0x05e), (az-> rirbsize)));
1170
1171	/* reset the write pointer */
1172	rirbwp = AZ_READ_2(az, RIRBWP)(((az)->iot)->read_2(((az)->ioh), (0x058)));
1173	AZ_WRITE_2(az, RIRBWP, rirbwp \| HDA_RIRBWP_RIRBWPRST)(((az)->iot)->write_2(((az)->ioh), (0x058), (rirbwp \| 0x8000)));
1174
1175	/* clear the read pointer */
1176	az->rirb_rp = AZ_READ_2(az, RIRBWP)(((az)->iot)->read_2(((az)->ioh), (0x058))) & HDA_RIRBWP_RIRBWP0x00ff;
1177	DPRINTF(("%s: RIRBRP=%d, size=%d\n", __func__, az->rirb_rp,do {} while (0 )
1178	az->rirb_entries))do {} while (0 );
1179
1180	az->unsolq_rp = 0;
1181	az->unsolq_wp = 0;
1182	az->unsolq_kick = 0;
1183
1184	AZ_WRITE_2(az, RINTCNT, 1)(((az)->iot)->write_2(((az)->ioh), (0x05a), (1)));
1185
1186	/* Run! */
1187	rirbctl = AZ_READ_1(az, RIRBCTL)(((az)->iot)->read_1(((az)->ioh), (0x05c)));
1188	AZ_WRITE_1(az, RIRBCTL, rirbctl \|(((az)->iot)->write_1(((az)->ioh), (0x05c), (rirbctl \| 0x02 \| 0x01)))
1189	HDA_RIRBCTL_RIRBDMAEN \| HDA_RIRBCTL_RINTCTL)(((az)->iot)->write_1(((az)->ioh), (0x05c), (rirbctl \| 0x02 \| 0x01)));
1190	for (i = 5000; i > 0; i--) {
1191	DELAY(10)(*delay_func)(10);
1192	rirbctl = AZ_READ_1(az, RIRBCTL)(((az)->iot)->read_1(((az)->ioh), (0x05c)));
1193	if (rirbctl & HDA_RIRBCTL_RIRBDMAEN0x02)
1194	break;
1195	}
1196	if (i == 0) {
1197	DPRINTF(("%s: RIRB is not running\n", XNAME(az)))do {} while (0 );
1198	return(EBUSY16);
1199	}
1200
1201	return (0);
1202	}
1203
1204	int
1205	azalia_comresp(const codec_t *codec, nid_t nid, uint32_t control,
1206	uint32_t param, uint32_t* result)
1207	{
1208	int err;
1209
1210	mtx_enter(&audio_lock);
1211	err = azalia_set_command(codec->az, codec->address, nid, control,
1212	param);
1213	if (err)
1214	goto exit;
1215	err = azalia_get_response(codec->az, result);
1216	exit:
1217	mtx_leave(&audio_lock);
1218	return(err);
1219	}
1220
1221	int
1222	azalia_set_command(azalia_t *az, int caddr, nid_t nid, uint32_t control,
1223	uint32_t param)
1224	{
1225	corb_entry_t *corb;
1226	int wp;
1227	uint32_t verb;
1228	uint16_t corbwp;
1229
1230	if ((AZ_READ_1(az, CORBCTL)(((az)->iot)->read_1(((az)->ioh), (0x04c))) & HDA_CORBCTL_CORBRUN0x02) == 0) {
1231	printf("%s: CORB is not running.\n", XNAME(az)((az)->dev.dv_xname));
1232	return(-1);
1233	}
1234	verb = (caddr << 28) \| (nid << 20) \| (control << 8) \| param;
1235	corbwp = AZ_READ_2(az, CORBWP)(((az)->iot)->read_2(((az)->ioh), (0x048)));
1236	wp = corbwp & HDA_CORBWP_CORBWP0x00ff;
1237	corb = (corb_entry_t*)az->corb_dma.addr;
1238	if (++wp >= az->corb_entries)
1239	wp = 0;
1240	corb[wp] = verb;
1241
1242	AZ_WRITE_2(az, CORBWP, (corbwp & ~HDA_CORBWP_CORBWP) \| wp)(((az)->iot)->write_2(((az)->ioh), (0x048), ((corbwp & ~0x00ff) \| wp)));
1243
1244	return(0);
1245	}
1246
1247	int
1248	azalia_get_response(azalia_t az, uint32_t result)
1249	{
1250	const rirb_entry_t *rirb;
1251	int i;
1252	uint16_t wp;
1253
1254	if ((AZ_READ_1(az, RIRBCTL)(((az)->iot)->read_1(((az)->ioh), (0x05c))) & HDA_RIRBCTL_RIRBDMAEN0x02) == 0) {
1255	printf("%s: RIRB is not running.\n", XNAME(az)((az)->dev.dv_xname));
1256	return(-1);
1257	}
1258
1259	rirb = (rirb_entry_t*)az->rirb_dma.addr;
1260	i = 5000;
1261	for (;;) {
1262	while (i > 0) {
1263	wp = AZ_READ_2(az, RIRBWP)(((az)->iot)->read_2(((az)->ioh), (0x058))) & HDA_RIRBWP_RIRBWP0x00ff;
1264	if (az->rirb_rp != wp)
1265	break;
1266	DELAY(10)(*delay_func)(10);
1267	i--;
1268	}
1269	if (i == 0) {
1270	DPRINTF(("%s: RIRB time out\n", XNAME(az)))do {} while (0 );
1271	return(ETIMEDOUT60);
1272	}
1273	if (++az->rirb_rp >= az->rirb_entries)
1274	az->rirb_rp = 0;
1275	if (rirb[az->rirb_rp].resp_ex & RIRB_RESP_UNSOL(1 << 4)) {
1276	az->unsolq[az->unsolq_wp].resp = rirb[az->rirb_rp].resp;
1277	az->unsolq[az->unsolq_wp++].resp_ex = rirb[az->rirb_rp].resp_ex;
1278	az->unsolq_wp %= UNSOLQ_SIZE256;
1279	} else
1280	break;
1281	}
1282	if (result != NULL((void *)0))
1283	*result = rirb[az->rirb_rp].resp;
1284
1285	return(0);
1286	}
1287
1288	void
1289	azalia_rirb_kick_unsol_events(void *v)
1290	{
1291	azalia_t *az = v;
1292	int addr, tag;
1293
1294	if (az->unsolq_kick)
1295	return;
1296	az->unsolq_kick = 1;
1297	while (az->unsolq_rp != az->unsolq_wp) {
1298	addr = RIRB_RESP_CODEC(az->unsolq[az->unsolq_rp].resp_ex)((az->unsolq[az->unsolq_rp].resp_ex) & 0xf);
1299	tag = RIRB_UNSOL_TAG(az->unsolq[az->unsolq_rp].resp)((az->unsolq[az->unsolq_rp].resp) >> 26);
1300	DPRINTF(("%s: codec address=%d tag=%d\n", __func__, addr, tag))do {} while (0 );
1301
1302	az->unsolq_rp++;
1303	az->unsolq_rp %= UNSOLQ_SIZE256;
1304
1305	/* We only care about events on the using codec. */
1306	if (az->codecs[az->codecno].address == addr)
1307	azalia_unsol_event(&az->codecs[az->codecno], tag);
1308	}
1309	az->unsolq_kick = 0;
1310	}
1311
1312	void
1313	azalia_rirb_intr(azalia_t *az)
1314	{
1315	const rirb_entry_t *rirb;
1316	uint16_t wp;
1317	uint8_t rirbsts;
1318
1319	rirbsts = AZ_READ_1(az, RIRBSTS)(((az)->iot)->read_1(((az)->ioh), (0x05d)));
1320
1321	wp = AZ_READ_2(az, RIRBWP)(((az)->iot)->read_2(((az)->ioh), (0x058))) & HDA_RIRBWP_RIRBWP0x00ff;
1322	rirb = (rirb_entry_t*)az->rirb_dma.addr;
1323	while (az->rirb_rp != wp) {
1324	if (++az->rirb_rp >= az->rirb_entries)
1325	az->rirb_rp = 0;
1326	if (rirb[az->rirb_rp].resp_ex & RIRB_RESP_UNSOL(1 << 4)) {
1327	az->unsolq[az->unsolq_wp].resp = rirb[az->rirb_rp].resp;
1328	az->unsolq[az->unsolq_wp++].resp_ex = rirb[az->rirb_rp].resp_ex;
1329	az->unsolq_wp %= UNSOLQ_SIZE256;
1330	} else {
1331	DPRINTF(("%s: dropped solicited response\n", __func__))do {} while (0 );
1332	}
1333	}
1334	timeout_add_msec(&az->unsol_to, 1);
1335
1336	AZ_WRITE_1(az, RIRBSTS,(((az)->iot)->write_1(((az)->ioh), (0x05d), (rirbsts \| 0x04 \| 0x01)))
1337	rirbsts \| HDA_RIRBSTS_RIRBOIS \| HDA_RIRBSTS_RINTFL)(((az)->iot)->write_1(((az)->ioh), (0x05d), (rirbsts \| 0x04 \| 0x01)));
1338	}
1339
1340	int
1341	azalia_alloc_dmamem(azalia_t az, size_t size, size_t align, azalia_dma_t d)
1342	{
1343	int err;
1344	int nsegs;
1345
1346	d->size = size;
1347	err = bus_dmamem_alloc(az->dmat, size, align, 0, d->segments, 1,(*(az->dmat)->_dmamem_alloc)((az->dmat), (size), (align ), (0), (d->segments), (1), (&nsegs), (0x0001))
1348	&nsegs, BUS_DMA_NOWAIT)(*(az->dmat)->_dmamem_alloc)((az->dmat), (size), (align ), (0), (d->segments), (1), (&nsegs), (0x0001));
1349	if (err)
1350	return err;
1351	if (nsegs != 1)
1352	goto free;
1353	err = bus_dmamem_map(az->dmat, d->segments, 1, size,(*(az->dmat)->_dmamem_map)((az->dmat), (d->segments ), (1), (size), (&d->addr), (0x0001 \| 0x0004))
1354	&d->addr, BUS_DMA_NOWAIT \| BUS_DMA_COHERENT)(*(az->dmat)->_dmamem_map)((az->dmat), (d->segments ), (1), (size), (&d->addr), (0x0001 \| 0x0004));
1355	if (err)
1356	goto free;
1357	err = bus_dmamap_create(az->dmat, size, 1, size, 0,(*(az->dmat)->_dmamap_create)((az->dmat), (size), (1 ), (size), (0), (0x0001), (&d->map))
1358	BUS_DMA_NOWAIT, &d->map)(*(az->dmat)->_dmamap_create)((az->dmat), (size), (1 ), (size), (0), (0x0001), (&d->map));
1359	if (err)
1360	goto unmap;
1361	err = bus_dmamap_load(az->dmat, d->map, d->addr, size,((az->dmat)->_dmamap_load)((az->dmat), (d->map), (d->addr), (size), (((void )0)), (0x0001))
1362	NULL, BUS_DMA_NOWAIT)((az->dmat)->_dmamap_load)((az->dmat), (d->map), (d->addr), (size), (((void )0)), (0x0001));
1363	if (err)
1364	goto destroy;
1365
1366	if (!az->ok64 && PTR_UPPER32(AZALIA_DMA_DMAADDR(d))((uint64_t)(((d)->map->dm_segs[0].ds_addr)) >> 32 ) != 0) {
1367	azalia_free_dmamem(az, d);
1368	return -1;
1369	}
1370	return 0;
1371
1372	destroy:
1373	bus_dmamap_destroy(az->dmat, d->map)(*(az->dmat)->_dmamap_destroy)((az->dmat), (d->map ));
1374	unmap:
1375	bus_dmamem_unmap(az->dmat, d->addr, size)(*(az->dmat)->_dmamem_unmap)((az->dmat), (d->addr ), (size));
1376	free:
1377	bus_dmamem_free(az->dmat, d->segments, 1)(*(az->dmat)->_dmamem_free)((az->dmat), (d->segments ), (1));
1378	d->addr = NULL((void *)0);
1379	return err;
1380	}
1381
1382	void
1383	azalia_free_dmamem(const azalia_t az, azalia_dma_t d)
1384	{
1385	if (d->addr == NULL((void *)0))
1386	return;
1387	bus_dmamap_unload(az->dmat, d->map)(*(az->dmat)->_dmamap_unload)((az->dmat), (d->map ));
1388	bus_dmamap_destroy(az->dmat, d->map)(*(az->dmat)->_dmamap_destroy)((az->dmat), (d->map ));
1389	bus_dmamem_unmap(az->dmat, d->addr, d->size)(*(az->dmat)->_dmamem_unmap)((az->dmat), (d->addr ), (d->size));
1390	bus_dmamem_free(az->dmat, d->segments, 1)(*(az->dmat)->_dmamem_free)((az->dmat), (d->segments ), (1));
1391	d->addr = NULL((void *)0);
1392	}
1393
1394	int
1395	azalia_suspend(azalia_t *az)
1396	{
1397	int err;
1398
1399	if (az->detached)
1400	return 0;
1401
1402	/* disable unsolicited responses */
1403	AZ_WRITE_4(az, GCTL, AZ_READ_4(az, GCTL) & ~HDA_GCTL_UNSOL)(((az)->iot)->write_4(((az)->ioh), (0x008), ((((az)-> iot)->read_4(((az)->ioh), (0x008))) & ~0x00000100)) );
1404
1405	timeout_del(&az->unsol_to);
1406
1407	/* azalia_halt_{corb,rirb}() only fail if the {CORB,RIRB} can't
1408	* be stopped and azalia_init_{corb,rirb}(), which starts the
1409	* {CORB,RIRB}, first calls azalia_halt_{corb,rirb}(). If halt
1410	* fails, don't try to restart.
1411	*/
1412	err = azalia_halt_corb(az);
1413	if (err)
1414	goto corb_fail;
1415
1416	err = azalia_halt_rirb(az);
1417	if (err)
1418	goto rirb_fail;
1419
1420	/* stop interrupts and clear status registers */
1421	AZ_WRITE_4(az, INTCTL, 0)(((az)->iot)->write_4(((az)->ioh), (0x020), (0)));
1422	AZ_WRITE_4(az, INTSTS, HDA_INTSTS_CIS \| HDA_INTSTS_GIS)(((az)->iot)->write_4(((az)->ioh), (0x024), (0x40000000 \| 0x80000000)));
1423	AZ_WRITE_2(az, STATESTS, HDA_STATESTS_SDIWAKE)(((az)->iot)->write_2(((az)->ioh), (0x00e), (0x7fff) ));
1424	AZ_WRITE_1(az, RIRBSTS, HDA_RIRBSTS_RINTFL \| HDA_RIRBSTS_RIRBOIS)(((az)->iot)->write_1(((az)->ioh), (0x05d), (0x01 \| 0x04 )));
1425
1426	return 0;
1427
1428	rirb_fail:
1429	azalia_init_corb(az, 1);
1430	corb_fail:
1431	AZ_WRITE_4(az, GCTL, AZ_READ_4(az, GCTL) \| HDA_GCTL_UNSOL)(((az)->iot)->write_4(((az)->ioh), (0x008), ((((az)-> iot)->read_4(((az)->ioh), (0x008))) \| 0x00000100)));
1432
1433	return err;
1434	}
1435
1436	int
1437	azalia_resume_codec(codec_t *this)
1438	{
1439	widget_t *w;
1440	uint32_t result;
1441	int i, err;
1442
1443	err = azalia_comresp(this, this->audiofunc, CORB_SET_POWER_STATE0x705,
1444	CORB_PS_D00x0, &result);
1445	if (err) {
1446	DPRINTF(("%s: power audio func error: result=0x%8.8x\n",do {} while (0 )
1447	__func__, result))do {} while (0 );
1448	}
1449	DELAY(100)(*delay_func)(100);
1450
1451	if (this->qrks & AZ_QRK_DOLBY_ATMOS0x02000000)
1452	azalia_codec_init_dolby_atmos(this);
1453
1454	FOR_EACH_WIDGET(this, i)for (i = (this)->wstart; i < (this)->wend; i++) {
1455	w = &this->w[i];
1456	if (w->widgetcap & COP_AWCAP_POWER0x400) {
1457	azalia_comresp(this, w->nid, CORB_SET_POWER_STATE0x705,
1458	CORB_PS_D00x0, &result);
1459	DELAY(100)(*delay_func)(100);
1460	}
1461	if (w->type == COP_AWTYPE_PIN_COMPLEX0x4)
1462	azalia_widget_init_pin(w, this);
1463	if (this->qrks & AZ_QRK_WID_MASK0x00fff000)
1464	azalia_codec_widget_quirks(this, w->nid);
1465	}
1466
1467	if (this->qrks & AZ_QRK_GPIO_MASK0x00000fff) {
1468	err = azalia_codec_gpio_quirks(this);
1469	if (err)
1470	return err;
1471	}
1472
1473	return(0);
1474	}
1475
1476	int
1477	azalia_resume(azalia_t *az)
1478	{
1479	int err;
1480
1481	if (az->detached)
1482	return 0;
1483
1484	azalia_configure_pci(az);
1485
1486	/* is this necessary? */
1487	pci_conf_write(az->pc, az->tag, PCI_SUBSYS_ID_REG0x2c, az->subid);
1488
1489	err = azalia_init(az, 1);
1490	if (err)
1491	return err;
1492
1493	/* enable unsolicited responses on the controller */
1494	AZ_WRITE_4(az, GCTL, AZ_READ_4(az, GCTL) \| HDA_GCTL_UNSOL)(((az)->iot)->write_4(((az)->ioh), (0x008), ((((az)-> iot)->read_4(((az)->ioh), (0x008))) \| 0x00000100)));
1495
1496	err = azalia_resume_codec(&az->codecs[az->codecno]);
1497	if (err)
1498	return err;
1499
1500	err = azalia_codec_enable_unsol(&az->codecs[az->codecno]);
1501	if (err)
1502	return err;
1503
1504	return 0;
1505	}
1506
1507	/* ================================================================
1508	* HDA codec functions
1509	* ================================================================ */
1510
1511	int
1512	azalia_codec_init(codec_t *this)
1513	{
1514	widget_t *w;
1515	uint32_t rev, id, result;
1516	int err, addr, n, i, nspdif, nhdmi;
1517
1518	addr = this->address;
1519	/* codec vendor/device/revision */
1520	err = azalia_comresp(this, CORB_NID_ROOT0, CORB_GET_PARAMETER0xf00,
1521	COP_REVISION_ID0x02, &rev);
1522	if (err)
1523	return err;
1524	err = azalia_comresp(this, CORB_NID_ROOT0, CORB_GET_PARAMETER0xf00,
1525	COP_VENDOR_ID0x00, &id);
1526	if (err)
1527	return err;
1528	this->vid = id;
1529	this->subid = this->az->subid;
1530	azalia_codec_init_vtbl(this);
1531	DPRINTF(("%s: codec[%d] vid 0x%8.8x, subid 0x%8.8x, rev. %u.%u,",do {} while (0 )
1532	XNAME(this->az), addr, this->vid, this->subid,do {} while (0 )
1533	COP_RID_REVISION(rev), COP_RID_STEPPING(rev)))do {} while (0 );
1534	DPRINTF((" HDA version %u.%u\n",do {} while (0 )
1535	COP_RID_MAJ(rev), COP_RID_MIN(rev)))do {} while (0 );
1536
1537	/* identify function nodes */
1538	err = azalia_comresp(this, CORB_NID_ROOT0, CORB_GET_PARAMETER0xf00,
1539	COP_SUBORDINATE_NODE_COUNT0x04, &result);
1540	if (err)
1541	return err;
1542	this->nfunctions = COP_NSUBNODES(result)(result & 0x000000ff);
1543	if (COP_NSUBNODES(result)(result & 0x000000ff) <= 0) {
1544	DPRINTF(("%s: codec[%d]: No function groups\n",do {} while (0 )
1545	XNAME(this->az), addr))do {} while (0 );
1546	return -1;
1547	}
1548	/* iterate function nodes and find an audio function */
1549	n = COP_START_NID(result)((result & 0x00ff0000) >> 16);
1550	DPRINTF(("%s: nidstart=%d #functions=%d\n",do {} while (0 )
1551	XNAME(this->az), n, this->nfunctions))do {} while (0 );
1552	this->audiofunc = -1;
1553	for (i = 0; i < this->nfunctions; i++) {
1554	err = azalia_comresp(this, n + i, CORB_GET_PARAMETER0xf00,
1555	COP_FUNCTION_GROUP_TYPE0x05, &result);
1556	if (err)
1557	continue;
1558	DPRINTF(("%s: FTYPE result = 0x%8.8x\n", __func__, result))do {} while (0 );
1559	if (COP_FTYPE(result)(result & 0x000000ff) == COP_FTYPE_AUDIO0x01) {
1560	this->audiofunc = n + i;
1561	break; /* XXX multiple audio functions? */
1562	}
1563	}
1564	if (this->audiofunc < 0) {
1565	DPRINTF(("%s: codec[%d]: No audio function groups\n",do {} while (0 )
1566	XNAME(this->az), addr))do {} while (0 );
1567	return -1;
1568	}
1569
1570	/* power the audio function */
1571	azalia_comresp(this, this->audiofunc, CORB_SET_POWER_STATE0x705,
1572	CORB_PS_D00x0, &result);
1573	DELAY(100)(*delay_func)(100);
1574
1575	/* check widgets in the audio function */
1576	err = azalia_comresp(this, this->audiofunc, CORB_GET_PARAMETER0xf00,
1577	COP_SUBORDINATE_NODE_COUNT0x04, &result);
1578	if (err)
1579	return err;
1580	DPRINTF(("%s: There are %d widgets in the audio function.\n",do {} while (0 )
1581	__func__, COP_NSUBNODES(result)))do {} while (0 );
1582	this->wstart = COP_START_NID(result)((result & 0x00ff0000) >> 16);
1583	if (this->wstart < 2) {
1584	printf("%s: invalid node structure\n", XNAME(this->az)((this->az)->dev.dv_xname));
1585	return -1;
1586	}
1587	this->wend = this->wstart + COP_NSUBNODES(result)(result & 0x000000ff);
1588	this->w = mallocarray(this->wend, sizeof(widget_t), M_DEVBUF2,
1589	M_NOWAIT0x0002 \| M_ZERO0x0008);
1590	if (this->w == NULL((void *)0)) {
1591	printf("%s: out of memory\n", XNAME(this->az)((this->az)->dev.dv_xname));
1592	return ENOMEM12;
1593	}
1594
1595	if (this->qrks & AZ_QRK_DOLBY_ATMOS0x02000000)
1596	azalia_codec_init_dolby_atmos(this);
1597
1598	/* query the base parameters */
1599	azalia_comresp(this, this->audiofunc, CORB_GET_PARAMETER0xf00,
1600	COP_STREAM_FORMATS0x0b, &result);
1601	this->w[this->audiofunc].d.audio.encodings = result;
1602	azalia_comresp(this, this->audiofunc, CORB_GET_PARAMETER0xf00,
1603	COP_PCM0x0a, &result);
1604	this->w[this->audiofunc].d.audio.bits_rates = result;
1605	azalia_comresp(this, this->audiofunc, CORB_GET_PARAMETER0xf00,
1606	COP_INPUT_AMPCAP0x0d, &result);
1607	this->w[this->audiofunc].inamp_cap = result;
1608	azalia_comresp(this, this->audiofunc, CORB_GET_PARAMETER0xf00,
1609	COP_OUTPUT_AMPCAP0x12, &result);
1610	this->w[this->audiofunc].outamp_cap = result;
1611
1612	azalia_codec_print_audiofunc(this);
1613
1614	strlcpy(this->w[CORB_NID_ROOT0].name, "root",
1615	sizeof(this->w[CORB_NID_ROOT0].name));
1616	strlcpy(this->w[this->audiofunc].name, "hdaudio",
1617	sizeof(this->w[this->audiofunc].name));
1618	this->w[this->audiofunc].enable = 1;
1619
1620	FOR_EACH_WIDGET(this, i)for (i = (this)->wstart; i < (this)->wend; i++) {
1621	w = &this->w[i];
1622	err = azalia_widget_init(w, this, i);
1623	if (err)
1624	return err;
1625	err = azalia_widget_init_connection(w, this);
1626	if (err)
1627	return err;
1628
1629	azalia_widget_print_widget(w, this);
1630
1631	if (this->qrks & AZ_QRK_WID_MASK0x00fff000) {
1632	azalia_codec_widget_quirks(this, i);
1633	}
1634	}
1635
1636	this->na_dacs = this->na_dacs_d = 0;
1637	this->na_adcs = this->na_adcs_d = 0;
1638	this->speaker = this->speaker2 = this->spkr_dac =
1639	this->fhp = this->fhp_dac =
1640	this->mic = this->mic_adc = -1;
1641	this->nsense_pins = 0;
1642	this->nout_jacks = 0;
1643	nspdif = nhdmi = 0;
1644	FOR_EACH_WIDGET(this, i)for (i = (this)->wstart; i < (this)->wend; i++) {
1645	w = &this->w[i];
1646
1647	if (!w->enable)
1648	continue;
1649
1650	switch (w->type) {
1651
1652	case COP_AWTYPE_AUDIO_MIXER0x2:
1653	case COP_AWTYPE_AUDIO_SELECTOR0x3:
1654	if (!azalia_widget_check_conn(this, i, 0))
1655	w->enable = 0;
1656	break;
1657
1658	case COP_AWTYPE_AUDIO_OUTPUT0x0:
1659	if ((w->widgetcap & COP_AWCAP_DIGITAL0x200) == 0) {
1660	if (this->na_dacs < HDA_MAX_CHANNELS16)
1661	this->a_dacs[this->na_dacs++] = i;
1662	} else {
1663	if (this->na_dacs_d < HDA_MAX_CHANNELS16)
1664	this->a_dacs_d[this->na_dacs_d++] = i;
1665	}
1666	break;
1667
1668	case COP_AWTYPE_AUDIO_INPUT0x1:
1669	if ((w->widgetcap & COP_AWCAP_DIGITAL0x200) == 0) {
1670	if (this->na_adcs < HDA_MAX_CHANNELS16)
1671	this->a_adcs[this->na_adcs++] = i;
1672	} else {
1673	if (this->na_adcs_d < HDA_MAX_CHANNELS16)
1674	this->a_adcs_d[this->na_adcs_d++] = i;
1675	}
1676	break;
1677
1678	case COP_AWTYPE_PIN_COMPLEX0x4:
1679	switch (CORB_CD_PORT(w->d.pin.config)((w->d.pin.config >> 30) & 0x3)) {
1680	case CORB_CD_FIXED0x2:
1681	switch (w->d.pin.device) {
1682	case CORB_CD_SPEAKER0x1:
1683	if (this->speaker == -1) {
1684	this->speaker = i;
1685	} else if (w->d.pin.association <
1686	this->w[this->speaker].d.pin.association \|\|
1687	(w->d.pin.association ==
1688	this->w[this->speaker].d.pin.association &&
1689	w->d.pin.sequence <
1690	this->w[this->speaker].d.pin.sequence)) {
1691	this->speaker2 = this->speaker;
1692	this->speaker = i;
1693	} else {
1694	this->speaker2 = i;
1695	}
1696	if (this->speaker == i)
1697	this->spkr_dac =
1698	azalia_codec_find_defdac(this, i, 0);
1699	break;
1700	case CORB_CD_MICIN0xa:
1701	this->mic = i;
1702	this->mic_adc =
1703	azalia_codec_find_defadc(this, i, 0);
1704	break;
1705	}
1706	break;
1707	case CORB_CD_JACK0x0:
1708	if (w->d.pin.device == CORB_CD_LINEOUT0x0)
1709	this->nout_jacks++;
1710	else if (w->d.pin.device == CORB_CD_HEADPHONE0x2 &&
1711	CORB_CD_LOC_GEO(w->d.pin.config)((w->d.pin.config >> 24) & 0xf) ==
1712	CORB_CD_FRONT0x2) {
1713	this->fhp = i;
1714	this->fhp_dac =
1715	azalia_codec_find_defdac(this, i, 0);
1716	}
1717	if (this->nsense_pins >= HDA_MAX_SENSE_PINS16 \|\|
1718	!(w->d.pin.cap & COP_PINCAP_PRESENCE0x00000004))
1719	break;
1720	/* check override bit */
1721	err = azalia_comresp(this, i,
1722	CORB_GET_CONFIGURATION_DEFAULT0xf1c, 0, &result);
1723	if (err)
1724	break;
1725	if (!(CORB_CD_MISC(result)((result >> 8) & 0xf) & CORB_CD_PRESENCEOV0x1)) {
1726	this->sense_pins[this->nsense_pins++] = i;
1727	}
1728	break;
1729	}
1730	if ((w->d.pin.device == CORB_CD_DIGITALOUT0x5) &&
1731	(w->d.pin.cap & COP_PINCAP_HDMI0x00000080))
1732	nhdmi++;
1733	else if (w->d.pin.device == CORB_CD_SPDIFOUT0x4 \|\|
1734	w->d.pin.device == CORB_CD_SPDIFIN0xc)
1735	nspdif++;
1736	break;
1737	}
1738	}
1739	this->codec_type = AZ_CODEC_TYPE_ANALOG0;
1740	if ((this->na_dacs == 0) && (this->na_adcs == 0)) {
1741	this->codec_type = AZ_CODEC_TYPE_DIGITAL1;
1742	if (nspdif == 0 && nhdmi > 0)
1743	this->codec_type = AZ_CODEC_TYPE_HDMI2;
1744	}
1745
1746	/* make sure built-in mic is connected to an adc */
1747	if (this->mic != -1 && this->mic_adc == -1) {
1748	if (azalia_codec_select_micadc(this)) {
1749	DPRINTF(("%s: could not select mic adc\n", __func__))do {} while (0 );
1750	}
1751	}
1752
1753	err = azalia_codec_sort_pins(this);
1754	if (err)
1755	return err;
1756
1757	err = azalia_codec_find_inputmixer(this);
1758	if (err)
1759	return err;
1760
1761	/* If the codec can do multichannel, select different DACs for
1762	* the multichannel jack group. Also be sure to keep track of
1763	* which DAC the front headphone is connected to.
1764	*/
1765	if (this->na_dacs >= 3 && this->nopins >= 3) {
1766	err = azalia_codec_select_dacs(this);
1767	if (err)
1768	return err;
1769	}
1770
1771	err = azalia_codec_select_spkrdac(this);
1772	if (err)
1773	return err;
1774
1775	err = azalia_init_dacgroup(this);
1776	if (err)
1777	return err;
1778
1779	azalia_codec_print_groups(this);
1780
1781	err = azalia_widget_label_widgets(this);
1782	if (err)
1783	return err;
1784
1785	err = azalia_codec_construct_format(this, 0, 0);
1786	if (err)
1787	return err;
1788
1789	err = azalia_codec_init_volgroups(this);
1790	if (err)
1791	return err;
1792
1793	if (this->qrks & AZ_QRK_GPIO_MASK0x00000fff) {
1794	err = azalia_codec_gpio_quirks(this);
1795	if (err)
1796	return err;
1797	}
1798
1799	err = azalia_mixer_init(this);
1800	if (err)
1801	return err;
1802
1803	return 0;
1804	}
1805
1806	int
1807	azalia_codec_find_inputmixer(codec_t *this)
1808	{
1809	widget_t *w;
1810	int i, j;
1811
1812	this->input_mixer = -1;
1813
1814	FOR_EACH_WIDGET(this, i)for (i = (this)->wstart; i < (this)->wend; i++) {
1815	w = &this->w[i];
1816	if (w->type != COP_AWTYPE_AUDIO_MIXER0x2)
1817	continue;
1818
1819	/* can input from a pin */
1820	for (j = 0; j < this->nipins; j++) {
1821	if (azalia_codec_fnode(this, this->ipins[j].nid,
1822	w->nid, 0) != -1)
1823	break;
1824	}
1825	if (j == this->nipins)
1826	continue;
1827
1828	/* can output to a pin */
1829	for (j = 0; j < this->nopins; j++) {
1830	if (azalia_codec_fnode(this, w->nid,
1831	this->opins[j].nid, 0) != -1)
1832	break;
1833	}
1834	if (j == this->nopins)
1835	continue;
1836
1837	/* can output to an ADC */
1838	for (j = 0; j < this->na_adcs; j++) {
1839	if (azalia_codec_fnode(this, w->nid,
1840	this->a_adcs[j], 0) != -1)
1841	break;
1842	}
1843	if (j == this->na_adcs)
1844	continue;
1845
1846	this->input_mixer = i;
1847	break;
1848	}
1849	return(0);
1850	}
1851
1852	int
1853	azalia_codec_select_micadc(codec_t *this)
1854	{
1855	widget_t *w;
1856	int i, j, conv, err;
1857
1858	for (i = 0; i < this->na_adcs; i++) {
1859	if (azalia_codec_fnode(this, this->mic,
1860	this->a_adcs[i], 0) >= 0)
1861	break;
1862	}
1863	if (i >= this->na_adcs)
1864	return(-1);
1865	conv = this->a_adcs[i];
1866
1867	w = &this->w[conv];
1868	for (j = 0; j < 10; j++) {
1869	for (i = 0; i < w->nconnections; i++) {
1870	if (!azalia_widget_enabled(this, w->connections[i]))
1871	continue;
1872	if (azalia_codec_fnode(this, this->mic,
1873	w->connections[i], j + 1) >= 0) {
1874	break;
1875	}
1876	}
1877	if (i >= w->nconnections)
1878	return(-1);
1879	err = azalia_comresp(this, w->nid,
1880	CORB_SET_CONNECTION_SELECT_CONTROL0x701, i, 0);
1881	if (err)
1882	return(err);
1883	w->selected = i;
1884	if (w->connections[i] == this->mic) {
1885	this->mic_adc = conv;
1886	return(0);
1887	}
1888	w = &this->w[w->connections[i]];
1889	}
1890	return(-1);
1891	}
1892
1893	int
1894	azalia_codec_sort_pins(codec_t *this)
1895	{
1896	#define MAX_PINS 16
1897	const widget_t *w;
1898	struct io_pin opins[MAX_PINS], opins_d[MAX_PINS];
1899	struct io_pin ipins[MAX_PINS], ipins_d[MAX_PINS];
1900	int nopins, nopins_d, nipins, nipins_d;
1901	int prio, loc, add, nd, conv;
1902	int i, j, k;
1903
1904	nopins = nopins_d = nipins = nipins_d = 0;
1905
1906	FOR_EACH_WIDGET(this, i)for (i = (this)->wstart; i < (this)->wend; i++) {
1907	w = &this->w[i];
1908	if (!w->enable \|\| w->type != COP_AWTYPE_PIN_COMPLEX0x4)
1909	continue;
1910
1911	loc = 0;
1912	if (this->na_dacs >= 3 && this->nout_jacks < 3)
1913	loc = CORB_CD_LOC_GEO(w->d.pin.config)((w->d.pin.config >> 24) & 0xf);
1914
1915	prio = w->d.pin.association << 4 \| w->d.pin.sequence;
1916	conv = -1;
1917
1918	/* analog out */
1919	if ((w->d.pin.cap & COP_PINCAP_OUTPUT0x00000010) &&
1920	!(w->widgetcap & COP_AWCAP_DIGITAL0x200)) {
1921	add = nd = 0;
1922	conv = azalia_codec_find_defdac(this, w->nid, 0);
1923	switch(w->d.pin.device) {
1924	/* primary - output by default */
1925	case CORB_CD_SPEAKER0x1:
1926	if (w->nid == this->speaker \|\|
1927	w->nid == this->speaker2)
1928	break;
1929	/* FALLTHROUGH */
1930	case CORB_CD_HEADPHONE0x2:
1931	case CORB_CD_LINEOUT0x0:
1932	add = 1;
1933	break;
1934	/* secondary - input by default */
1935	case CORB_CD_MICIN0xa:
1936	if (w->nid == this->mic)
1937	break;
1938	/* FALLTHROUGH */
1939	case CORB_CD_LINEIN0x8:
1940	add = nd = 1;
1941	break;
1942	}
1943	if (add && nopins < MAX_PINS) {
1944	opins[nopins].nid = w->nid;
1945	opins[nopins].conv = conv;
1946	prio \|= (nd << 8) \| (loc << 9);
1947	opins[nopins].prio = prio;
1948	nopins++;
1949	}
1950	}
1951	/* digital out */
1952	if ((w->d.pin.cap & COP_PINCAP_OUTPUT0x00000010) &&
1953	(w->widgetcap & COP_AWCAP_DIGITAL0x200)) {
1954	conv = azalia_codec_find_defdac(this, w->nid, 0);
1955	switch(w->d.pin.device) {
1956	case CORB_CD_SPDIFOUT0x4:
1957	case CORB_CD_DIGITALOUT0x5:
1958	if (nopins_d < MAX_PINS) {
1959	opins_d[nopins_d].nid = w->nid;
1960	opins_d[nopins_d].conv = conv;
1961	opins_d[nopins_d].prio = prio;
1962	nopins_d++;
1963	}
1964	break;
1965	}
1966	}
1967	/* analog in */
1968	if ((w->d.pin.cap & COP_PINCAP_INPUT0x00000020) &&
1969	!(w->widgetcap & COP_AWCAP_DIGITAL0x200)) {
1970	add = nd = 0;
1971	conv = azalia_codec_find_defadc(this, w->nid, 0);
1972	switch(w->d.pin.device) {
1973	/* primary - input by default */
1974	case CORB_CD_MICIN0xa:
1975	case CORB_CD_LINEIN0x8:
1976	add = 1;
1977	break;
1978	/* secondary - output by default */
1979	case CORB_CD_SPEAKER0x1:
1980	if (w->nid == this->speaker \|\|
1981	w->nid == this->speaker2)
1982	break;
1983	/* FALLTHROUGH */
1984	case CORB_CD_HEADPHONE0x2:
1985	case CORB_CD_LINEOUT0x0:
1986	add = nd = 1;
1987	break;
1988	}
1989	if (add && nipins < MAX_PINS) {
1990	ipins[nipins].nid = w->nid;
1991	ipins[nipins].prio = prio \| (nd << 8);
1992	ipins[nipins].conv = conv;
1993	nipins++;
1994	}
1995	}
1996	/* digital in */
1997	if ((w->d.pin.cap & COP_PINCAP_INPUT0x00000020) &&
1998	(w->widgetcap & COP_AWCAP_DIGITAL0x200)) {
1999	conv = azalia_codec_find_defadc(this, w->nid, 0);
2000	switch(w->d.pin.device) {
2001	case CORB_CD_SPDIFIN0xc:
2002	case CORB_CD_DIGITALIN0xd:
2003	case CORB_CD_MICIN0xa:
2004	if (nipins_d < MAX_PINS) {
2005	ipins_d[nipins_d].nid = w->nid;
2006	ipins_d[nipins_d].prio = prio;
2007	ipins_d[nipins_d].conv = conv;
2008	nipins_d++;
2009	}
2010	break;
2011	}
2012	}
2013	}
2014
2015	this->opins = mallocarray(nopins, sizeof(struct io_pin), M_DEVBUF2,
2016	M_NOWAIT0x0002 \| M_ZERO0x0008);
2017	if (this->opins == NULL((void *)0))
2018	return(ENOMEM12);
2019	this->nopins = 0;
2020	for (i = 0; i < nopins; i++) {
2021	for (j = 0; j < this->nopins; j++)
2022	if (this->opins[j].prio > opins[i].prio)
2023	break;
2024	for (k = this->nopins; k > j; k--)
2025	this->opins[k] = this->opins[k - 1];
2026	if (j < nopins)
2027	this->opins[j] = opins[i];
2028	this->nopins++;
2029	if (this->nopins == nopins)
2030	break;
2031	}
2032
2033	this->opins_d = mallocarray(nopins_d, sizeof(struct io_pin), M_DEVBUF2,
2034	M_NOWAIT0x0002 \| M_ZERO0x0008);
2035	if (this->opins_d == NULL((void *)0))
2036	return(ENOMEM12);
2037	this->nopins_d = 0;
2038	for (i = 0; i < nopins_d; i++) {
2039	for (j = 0; j < this->nopins_d; j++)
2040	if (this->opins_d[j].prio > opins_d[i].prio)
2041	break;
2042	for (k = this->nopins_d; k > j; k--)
2043	this->opins_d[k] = this->opins_d[k - 1];
2044	if (j < nopins_d)
2045	this->opins_d[j] = opins_d[i];
2046	this->nopins_d++;
2047	if (this->nopins_d == nopins_d)
2048	break;
2049	}
2050
2051	this->ipins = mallocarray(nipins, sizeof(struct io_pin), M_DEVBUF2,
2052	M_NOWAIT0x0002 \| M_ZERO0x0008);
2053	if (this->ipins == NULL((void *)0))
2054	return(ENOMEM12);
2055	this->nipins = 0;
2056	for (i = 0; i < nipins; i++) {
2057	for (j = 0; j < this->nipins; j++)
2058	if (this->ipins[j].prio > ipins[i].prio)
2059	break;
2060	for (k = this->nipins; k > j; k--)
2061	this->ipins[k] = this->ipins[k - 1];
2062	if (j < nipins)
2063	this->ipins[j] = ipins[i];
2064	this->nipins++;
2065	if (this->nipins == nipins)
2066	break;
2067	}
2068
2069	this->ipins_d = mallocarray(nipins_d, sizeof(struct io_pin), M_DEVBUF2,
2070	M_NOWAIT0x0002 \| M_ZERO0x0008);
2071	if (this->ipins_d == NULL((void *)0))
2072	return(ENOMEM12);
2073	this->nipins_d = 0;
2074	for (i = 0; i < nipins_d; i++) {
2075	for (j = 0; j < this->nipins_d; j++)
2076	if (this->ipins_d[j].prio > ipins_d[i].prio)
2077	break;
2078	for (k = this->nipins_d; k > j; k--)
2079	this->ipins_d[k] = this->ipins_d[k - 1];
2080	if (j < nipins_d)
2081	this->ipins_d[j] = ipins_d[i];
2082	this->nipins_d++;
2083	if (this->nipins_d == nipins_d)
2084	break;
2085	}
2086
2087	#ifdef AZALIA_DEBUG
2088	printf("%s: analog out pins:", __func__);
2089	for (i = 0; i < this->nopins; i++)
2090	printf(" 0x%2.2x->0x%2.2x", this->opins[i].nid,
2091	this->opins[i].conv);
2092	printf("\n");
2093	printf("%s: digital out pins:", __func__);
2094	for (i = 0; i < this->nopins_d; i++)
2095	printf(" 0x%2.2x->0x%2.2x", this->opins_d[i].nid,
2096	this->opins_d[i].conv);
2097	printf("\n");
2098	printf("%s: analog in pins:", __func__);
2099	for (i = 0; i < this->nipins; i++)
2100	printf(" 0x%2.2x->0x%2.2x", this->ipins[i].nid,
2101	this->ipins[i].conv);
2102	printf("\n");
2103	printf("%s: digital in pins:", __func__);
2104	for (i = 0; i < this->nipins_d; i++)
2105	printf(" 0x%2.2x->0x%2.2x", this->ipins_d[i].nid,
2106	this->ipins_d[i].conv);
2107	printf("\n");
2108	#endif
2109
2110	return 0;
2111	#undef MAX_PINS
2112	}
2113
2114	int
2115	azalia_codec_select_dacs(codec_t *this)
2116	{
2117	widget_t *w;
2118	nid_t *convs;
2119	int nconv, conv;
2120	int i, j, k, err;
2121
2122	convs = mallocarray(this->na_dacs, sizeof(nid_t), M_DEVBUF2,
2123	M_NOWAIT0x0002 \| M_ZERO0x0008);
2124	if (convs == NULL((void *)0))
2125	return(ENOMEM12);
2126
2127	err = 0;
2128	nconv = 0;
2129	for (i = 0; i < this->nopins; i++) {
2130	w = &this->w[this->opins[i].nid];
2131
2132	conv = this->opins[i].conv;
2133	for (j = 0; j < nconv; j++) {
2134	if (conv == convs[j])
2135	break;
2136	}
2137	if (j == nconv) {
2138	convs[nconv++] = conv;
2139	if (w->nid == this->fhp)
2140	this->fhp_dac = conv;
2141	if (nconv >= this->na_dacs) {
2142	break;
2143	}
2144	} else {
2145	/* find a different dac */
2146	conv = -1;
2147	for (j = 0; j < w->nconnections; j++) {
2148	if (!azalia_widget_enabled(this,
2149	w->connections[j]))
2150	continue;
2151	conv = azalia_codec_find_defdac(this,
2152	w->connections[j], 1);
2153	if (conv == -1)
2154	continue;
2155	for (k = 0; k < nconv; k++) {
2156	if (conv == convs[k])
2157	break;
2158	}
2159	if (k == nconv)
2160	break;
2161	}
2162	if (j < w->nconnections && conv != -1) {
2163	err = azalia_comresp(this, w->nid,
2164	CORB_SET_CONNECTION_SELECT_CONTROL0x701, j, 0);
2165	if (err)
2166	break;
2167	w->selected = j;
2168	this->opins[i].conv = conv;
2169	if (w->nid == this->fhp)
2170	this->fhp_dac = conv;
2171	convs[nconv++] = conv;
2172	if (nconv >= this->na_dacs)
2173	break;
2174	}
2175	}
2176	}
2177
2178	free(convs, M_DEVBUF2, this->na_dacs * sizeof(nid_t));
2179	return(err);
2180	}
2181
2182	/* Connect the speaker to a DAC that no other output pin is connected
2183	* to by default. If that is not possible, connect to a DAC other
2184	* than the one the first output pin is connected to.
2185	*/
2186	int
2187	azalia_codec_select_spkrdac(codec_t *this)
2188	{
2189	widget_t *w;
2190	nid_t convs[HDA_MAX_CHANNELS16];
2191	int nconv, conv;
2192	int i, j, err, fspkr, conn;
2193
2194	nconv = fspkr = 0;
2195	for (i = 0; i < this->nopins; i++) {
2196	conv = this->opins[i].conv;
2197	for (j = 0; j < nconv; j++) {
2198	if (conv == convs[j])
2199	break;
2200	}
2201	if (j == nconv) {
2202	if (conv == this->spkr_dac)
2203	fspkr = 1;
2204	convs[nconv++] = conv;
2205	if (nconv == this->na_dacs)
2206	break;
2207	}
2208	}
2209
2210	if (fspkr) {
2211	conn = conv = -1;
2212	w = &this->w[this->speaker];
2213	for (i = 0; i < w->nconnections; i++) {
2214	conv = azalia_codec_find_defdac(this,
2215	w->connections[i], 1);
2216	for (j = 0; j < nconv; j++)
2217	if (conv == convs[j])
2218	break;
2219	if (j == nconv)
2220	break;
2221	}
2222	if (i < w->nconnections) {
2223	conn = i;
2224	} else {
2225	/* Couldn't get a unique DAC. Try to get a different
2226	* DAC than the first pin's DAC.
2227	*/
2228	if (this->spkr_dac == this->opins[0].conv) {
2229	/* If the speaker connection can't be changed,
2230	* change the first pin's connection.
2231	*/
2232	if (w->nconnections == 1)
2233	w = &this->w[this->opins[0].nid];
2234	for (j = 0; j < w->nconnections; j++) {
2235	conv = azalia_codec_find_defdac(this,
2236	w->connections[j], 1);
2237	if (conv != this->opins[0].conv) {
2238	conn = j;
2239	break;
2240	}
2241	}
2242	}
2243	}
2244	if (conn != -1 && conv != -1) {
2245	err = azalia_comresp(this, w->nid,
2246	CORB_SET_CONNECTION_SELECT_CONTROL0x701, conn, 0);
2247	if (err)
2248	return(err);
2249	w->selected = conn;
2250	if (w->nid == this->speaker)
2251	this->spkr_dac = conv;
2252	else
2253	this->opins[0].conv = conv;
2254	}
2255	}
2256
2257	/* If there is a speaker2, try to connect it to spkr_dac. */
2258	if (this->speaker2 != -1) {
2259	conn = conv = -1;
2260	w = &this->w[this->speaker2];
2261	for (i = 0; i < w->nconnections; i++) {
2262	conv = azalia_codec_find_defdac(this,
2263	w->connections[i], 1);
2264	if (this->qrks & AZ_QRK_ROUTE_SPKR2_DAC0x01000000) {
2265	if (conv != this->spkr_dac) {
2266	conn = i;
2267	break;
2268	}
2269	} else if (conv == this->spkr_dac) {
2270	conn = i;
2271	break;
2272	}
2273	}
2274	if (conn != -1) {
2275	err = azalia_comresp(this, w->nid,
2276	CORB_SET_CONNECTION_SELECT_CONTROL0x701, conn, 0);
2277	if (err)
2278	return(err);
2279	w->selected = conn;
2280	}
2281	}
2282
2283	return(0);
2284	}
2285
2286	int
2287	azalia_codec_find_defdac(codec_t *this, int index, int depth)
2288	{
2289	const widget_t *w;
2290	int i, ret;
2291
2292	w = &this->w[index];
2293	if (w->enable == 0)
2294	return -1;
2295
2296	if (w->type == COP_AWTYPE_AUDIO_OUTPUT0x0)
2297	return index;
2298
2299	if (depth > 0 &&
2300	(w->type == COP_AWTYPE_PIN_COMPLEX0x4 \|\|
2301	w->type == COP_AWTYPE_BEEP_GENERATOR0x7 \|\|
2302	w->type == COP_AWTYPE_AUDIO_INPUT0x1))
2303	return -1;
2304	if (++depth >= 10)
2305	return -1;
2306
2307	if (w->nconnections > 0) {
2308	/* by default, all mixer connections are active */
2309	if (w->type == COP_AWTYPE_AUDIO_MIXER0x2) {
2310	for (i = 0; i < w->nconnections; i++) {
2311	index = w->connections[i];
2312	if (!azalia_widget_enabled(this, index))
2313	continue;
2314	ret = azalia_codec_find_defdac(this, index,
2315	depth);
2316	if (ret >= 0)
2317	return ret;
2318	}
2319	/* 7.3.3.2 Connection Select Control
2320	* If an attempt is made to Set an index value greater than
2321	* the number of list entries (index is equal to or greater
2322	* than the Connection List Length property for the widget)
2323	* the behavior is not predictable.
2324	*/
2325
2326	/* negative index values are wrong too */
2327	} else if (w->selected >= 0 &&
2328	w->selected < sizeof(w->connections)) {
2329	index = w->connections[w->selected];
2330	if (VALID_WIDGET_NID(index, this)(index == (this)->audiofunc \|\| (index >= (this)->wstart && index < (this)->wend))) {
2331	ret = azalia_codec_find_defdac(this,
2332	index, depth);
2333	if (ret >= 0)
2334	return ret;
2335	}
2336	}
2337	}
2338
2339	return -1;
2340	}
2341
2342	int
2343	azalia_codec_find_defadc_sub(codec_t *this, nid_t node, int index, int depth)
2344	{
2345	const widget_t *w;
2346	int i, ret;
2347
2348	w = &this->w[index];
2349	if (w->nid == node) {
2350	return index;
2351	}
2352	/* back at the beginning or a bad end */
2353	if (depth > 0 &&
2354	(w->type == COP_AWTYPE_PIN_COMPLEX0x4 \|\|
2355	w->type == COP_AWTYPE_BEEP_GENERATOR0x7 \|\|
2356	w->type == COP_AWTYPE_AUDIO_OUTPUT0x0 \|\|
2357	w->type == COP_AWTYPE_AUDIO_INPUT0x1))
2358	return -1;
2359	if (++depth >= 10)
2360	return -1;
2361
2362	if (w->nconnections > 0) {
2363	/* by default, all mixer connections are active */
2364	if (w->type == COP_AWTYPE_AUDIO_MIXER0x2) {
2365	for (i = 0; i < w->nconnections; i++) {
2366	if (!azalia_widget_enabled(this, w->connections[i]))
2367	continue;
2368	ret = azalia_codec_find_defadc_sub(this, node,
2369	w->connections[i], depth);
2370	if (ret >= 0)
2371	return ret;
2372	}
2373	/* 7.3.3.2 Connection Select Control
2374	* If an attempt is made to Set an index value greater than
2375	* the number of list entries (index is equal to or greater
2376	* than the Connection List Length property for the widget)
2377	* the behavior is not predictable.
2378	*/
2379
2380	/* negative index values are wrong too */
2381	} else if (w->selected >= 0 &&
2382	w->selected < sizeof(w->connections)) {
2383	index = w->connections[w->selected];
2384	if (VALID_WIDGET_NID(index, this)(index == (this)->audiofunc \|\| (index >= (this)->wstart && index < (this)->wend))) {
2385	ret = azalia_codec_find_defadc_sub(this,
2386	node, index, depth);
2387	if (ret >= 0)
2388	return ret;
2389	}
2390	}
2391	}
2392	return -1;
2393	}
2394
2395	int
2396	azalia_codec_find_defadc(codec_t *this, int index, int depth)
2397	{
2398	int i, j, conv;
2399
2400	conv = -1;
2401	for (i = 0; i < this->na_adcs; i++) {
2402	j = azalia_codec_find_defadc_sub(this, index,
2403	this->a_adcs[i], 0);
2404	if (j >= 0) {
2405	conv = this->a_adcs[i];
2406	break;
2407	}
2408	}
2409	return(conv);
2410	}
2411
2412	int
2413	azalia_codec_init_volgroups(codec_t *this)
2414	{
2415	const widget_t *w;
2416	uint32_t cap, result;
2417	int i, j, dac, err;
2418
2419	j = 0;
2420	this->playvols.mask = 0;
2421	FOR_EACH_WIDGET(this, i)for (i = (this)->wstart; i < (this)->wend; i++) {
2422	w = &this->w[i];
2423	if (w->enable == 0)
2424	continue;
2425	if (w->mixer_class == AZ_CLASS_RECORD2)
2426	continue;
2427	if (!(w->widgetcap & COP_AWCAP_OUTAMP0x004))
2428	continue;
2429	if ((COP_AMPCAP_NUMSTEPS(w->outamp_cap)((w->outamp_cap >> 8) & 0x7f) == 0) &&
2430	!(w->outamp_cap & COP_AMPCAP_MUTE0x80000000))
2431	continue;
2432	this->playvols.mask \|= (1 << j);
2433	this->playvols.slaves[j++] = w->nid;
2434	if (j >= AZ_MAX_VOL_SLAVES16)
2435	break;
2436	}
2437	this->playvols.nslaves = j;
2438
2439	this->playvols.cur = 0;
2440	for (i = 0; i < this->playvols.nslaves; i++) {
2441	w = &this->w[this->playvols.slaves[i]];
2442	if (w->nid == this->input_mixer \|\|
2443	w->parent == this->input_mixer \|\|
2444	WIDGET_CHANNELS(w)((w)->widgetcap & 0x001 ? 2 : 1) < 2)
2445	continue;
2446	j = 0;
2447	/* azalia_codec_find_defdac only goes 10 connections deep.
2448	* Start the connection depth at 7 so it doesn't go more
2449	* than 3 connections deep.
2450	*/
2451	if (w->type == COP_AWTYPE_AUDIO_MIXER0x2 \|\|
2452	w->type == COP_AWTYPE_AUDIO_SELECTOR0x3)
2453	j = 7;
2454	dac = azalia_codec_find_defdac(this, w->nid, j);
2455	if (dac == -1)
2456	continue;
2457	if (dac != this->dacs.groups[this->dacs.cur].conv[0] &&
2458	dac != this->spkr_dac && dac != this->fhp_dac)
2459	continue;
2460	cap = w->outamp_cap;
2461	if ((cap & COP_AMPCAP_MUTE0x80000000) && COP_AMPCAP_NUMSTEPS(cap)((cap >> 8) & 0x7f)) {
2462	if (w->type == COP_AWTYPE_BEEP_GENERATOR0x7) {
2463	continue;
2464	} else if (w->type == COP_AWTYPE_PIN_COMPLEX0x4) {
2465	err = azalia_comresp(this, w->nid,
2466	CORB_GET_PIN_WIDGET_CONTROL0xf07, 0, &result);
2467	if (!err && (result & CORB_PWC_OUTPUT0x40))
2468	this->playvols.cur \|= (1 << i);
2469	} else
2470	this->playvols.cur \|= (1 << i);
2471	}
2472	}
2473	if (this->playvols.cur == 0) {
2474	for (i = 0; i < this->playvols.nslaves; i++) {
2475	w = &this->w[this->playvols.slaves[i]];
2476	j = 0;
2477	if (w->type == COP_AWTYPE_AUDIO_MIXER0x2 \|\|
2478	w->type == COP_AWTYPE_AUDIO_SELECTOR0x3)
2479	j = 7;
2480	dac = azalia_codec_find_defdac(this, w->nid, j);
2481	if (dac == -1)
2482	continue;
2483	if (dac != this->dacs.groups[this->dacs.cur].conv[0] &&
2484	dac != this->spkr_dac && dac != this->fhp_dac)
2485	continue;
2486	if (w->type == COP_AWTYPE_BEEP_GENERATOR0x7)
2487	continue;
2488	if (w->type == COP_AWTYPE_PIN_COMPLEX0x4) {
2489	err = azalia_comresp(this, w->nid,
2490	CORB_GET_PIN_WIDGET_CONTROL0xf07, 0, &result);
2491	if (!err && (result & CORB_PWC_OUTPUT0x40))
2492	this->playvols.cur \|= (1 << i);
2493	} else {
2494	this->playvols.cur \|= (1 << i);
2495	}
2496	}
2497	}
2498
2499	this->playvols.master = this->audiofunc;
2500	if (this->playvols.nslaves > 0) {
2501	FOR_EACH_WIDGET(this, i)for (i = (this)->wstart; i < (this)->wend; i++) {
2502	w = &this->w[i];
2503	if (w->type != COP_AWTYPE_VOLUME_KNOB0x6)
2504	continue;
2505	if (!COP_VKCAP_NUMSTEPS(w->d.volume.cap)(w->d.volume.cap & 0x7f))
2506	continue;
2507	this->playvols.master = w->nid;
2508	break;
2509	}
2510	}
2511
2512	j = 0;
2513	this->recvols.mask = 0;
2514	FOR_EACH_WIDGET(this, i)for (i = (this)->wstart; i < (this)->wend; i++) {
2515	w = &this->w[i];
2516	if (w->enable == 0)
2517	continue;
2518	if (w->type == COP_AWTYPE_AUDIO_INPUT0x1 \|\|
2519	w->type == COP_AWTYPE_PIN_COMPLEX0x4) {
2520	if (!(w->widgetcap & COP_AWCAP_INAMP0x002))
2521	continue;
2522	if ((COP_AMPCAP_NUMSTEPS(w->inamp_cap)((w->inamp_cap >> 8) & 0x7f) == 0) &&
2523	!(w->inamp_cap & COP_AMPCAP_MUTE0x80000000))
2524	continue;
2525	} else if (w->type == COP_AWTYPE_AUDIO_MIXER0x2 \|\|
2526	w->type == COP_AWTYPE_AUDIO_SELECTOR0x3) {
2527	if (w->mixer_class != AZ_CLASS_RECORD2)
2528	continue;
2529	if (!(w->widgetcap & COP_AWCAP_OUTAMP0x004))
2530	continue;
2531	if ((COP_AMPCAP_NUMSTEPS(w->outamp_cap)((w->outamp_cap >> 8) & 0x7f) == 0) &&
2532	!(w->outamp_cap & COP_AMPCAP_MUTE0x80000000))
2533	continue;
2534	} else {
2535	continue;
2536	}
2537	this->recvols.mask \|= (1 << j);
2538	this->recvols.slaves[j++] = w->nid;
2539	if (j >= AZ_MAX_VOL_SLAVES16)
2540	break;
2541	}
2542	this->recvols.nslaves = j;
2543
2544	this->recvols.cur = 0;
2545	for (i = 0; i < this->recvols.nslaves; i++) {
2546	w = &this->w[this->recvols.slaves[i]];
2547	cap = w->outamp_cap;
2548	if (w->type == COP_AWTYPE_AUDIO_INPUT0x1 \|\|
2549	w->type != COP_AWTYPE_PIN_COMPLEX0x4)
2550	cap = w->inamp_cap;
2551	else
2552	if (w->mixer_class != AZ_CLASS_RECORD2)
2553	continue;
2554	if ((cap & COP_AMPCAP_MUTE0x80000000) && COP_AMPCAP_NUMSTEPS(cap)((cap >> 8) & 0x7f)) {
2555	if (w->type == COP_AWTYPE_PIN_COMPLEX0x4) {
2556	err = azalia_comresp(this, w->nid,
2557	CORB_GET_PIN_WIDGET_CONTROL0xf07, 0, &result);
2558	if (!err && !(result & CORB_PWC_OUTPUT0x40))
2559	this->recvols.cur \|= (1 << i);
2560	} else
2561	this->recvols.cur \|= (1 << i);
2562	}
2563	}
2564	if (this->recvols.cur == 0) {
2565	for (i = 0; i < this->recvols.nslaves; i++) {
2566	w = &this->w[this->recvols.slaves[i]];
2567	cap = w->outamp_cap;
2568	if (w->type == COP_AWTYPE_AUDIO_INPUT0x1 \|\|
2569	w->type != COP_AWTYPE_PIN_COMPLEX0x4)
2570	cap = w->inamp_cap;
	Value stored to 'cap' is never read
2571	else
2572	if (w->mixer_class != AZ_CLASS_RECORD2)
2573	continue;
2574	if (w->type == COP_AWTYPE_PIN_COMPLEX0x4) {
2575	err = azalia_comresp(this, w->nid,
2576	CORB_GET_PIN_WIDGET_CONTROL0xf07, 0, &result);
2577	if (!err && !(result & CORB_PWC_OUTPUT0x40))
2578	this->recvols.cur \|= (1 << i);
2579	} else {
2580	this->recvols.cur \|= (1 << i);
2581	}
2582	}
2583	}
2584
2585	this->recvols.master = this->audiofunc;
2586
2587	return 0;
2588	}
2589
2590	int
2591	azalia_codec_delete(codec_t *this)
2592	{
2593	azalia_mixer_delete(this);
2594
2595	if (this->formats != NULL((void *)0)) {
2596	free(this->formats, M_DEVBUF2,
2597	this->nformats * sizeof(struct audio_format));
2598	this->formats = NULL((void *)0);
2599	}
2600	this->nformats = 0;
2601
2602	if (this->opins != NULL((void *)0)) {
2603	free(this->opins, M_DEVBUF2,
2604	this->nopins * sizeof(struct io_pin));
2605	this->opins = NULL((void *)0);
2606	}
2607	this->nopins = 0;
2608
2609	if (this->opins_d != NULL((void *)0)) {
2610	free(this->opins_d, M_DEVBUF2,
2611	this->nopins_d * sizeof(struct io_pin));
2612	this->opins_d = NULL((void *)0);
2613	}
2614	this->nopins_d = 0;
2615
2616	if (this->ipins != NULL((void *)0)) {
2617	free(this->ipins, M_DEVBUF2,
2618	this->nipins * sizeof(struct io_pin));
2619	this->ipins = NULL((void *)0);
2620	}
2621	this->nipins = 0;
2622
2623	if (this->ipins_d != NULL((void *)0)) {
2624	free(this->ipins_d, M_DEVBUF2,
2625	this->nipins_d * sizeof(struct io_pin));
2626	this->ipins_d = NULL((void *)0);
2627	}
2628	this->nipins_d = 0;
2629
2630	if (this->w != NULL((void *)0)) {
2631	free(this->w, M_DEVBUF2,
2632	this->wend * sizeof(widget_t));
2633	this->w = NULL((void *)0);
2634	}
2635
2636	return 0;
2637	}
2638
2639	int
2640	azalia_codec_construct_format(codec_t *this, int newdac, int newadc)
2641	{
2642	const convgroup_t *group;
2643	uint32_t bits_rates;
2644	int variation;
2645	int nbits, c, chan, i;
2646	nid_t nid;
2647
2648	variation = 0;
2649
2650	if (this->dacs.ngroups > 0 && newdac < this->dacs.ngroups &&
2651	newdac >= 0) {
2652	this->dacs.cur = newdac;
2653	group = &this->dacs.groups[this->dacs.cur];
2654	bits_rates = this->w[group->conv[0]].d.audio.bits_rates;
2655	nbits = 0;
2656	if (bits_rates & COP_PCM_B80x00010000)
2657	nbits++;
2658	if (bits_rates & COP_PCM_B160x00020000)
2659	nbits++;
2660	if (bits_rates & COP_PCM_B200x00040000)
2661	nbits++;
2662	if (bits_rates & COP_PCM_B240x00080000)
2663	nbits++;
2664	if ((bits_rates & COP_PCM_B320x00100000) &&
2665	!(this->w[group->conv[0]].widgetcap & COP_AWCAP_DIGITAL0x200))
2666	nbits++;
2667	if (nbits == 0) {
2668	printf("%s: invalid DAC PCM format: 0x%8.8x\n",
2669	XNAME(this->az)((this->az)->dev.dv_xname), bits_rates);
2670	return -1;
2671	}
2672	variation += group->nconv * nbits;
2673	}
2674
2675	if (this->adcs.ngroups > 0 && newadc < this->adcs.ngroups &&
2676	newadc >= 0) {
2677	this->adcs.cur = newadc;
2678	group = &this->adcs.groups[this->adcs.cur];
2679	bits_rates = this->w[group->conv[0]].d.audio.bits_rates;
2680	nbits = 0;
2681	if (bits_rates & COP_PCM_B80x00010000)
2682	nbits++;
2683	if (bits_rates & COP_PCM_B160x00020000)
2684	nbits++;
2685	if (bits_rates & COP_PCM_B200x00040000)
2686	nbits++;
2687	if (bits_rates & COP_PCM_B240x00080000)
2688	nbits++;
2689	if ((bits_rates & COP_PCM_B320x00100000) &&
2690	!(this->w[group->conv[0]].widgetcap & COP_AWCAP_DIGITAL0x200))
2691	nbits++;
2692	if (nbits == 0) {
2693	printf("%s: invalid ADC PCM format: 0x%8.8x\n",
2694	XNAME(this->az)((this->az)->dev.dv_xname), bits_rates);
2695	return -1;
2696	}
2697	variation += group->nconv * nbits;
2698	}
2699
2700	if (variation == 0) {
2701	DPRINTF(("%s: no converter groups\n", XNAME(this->az)))do {} while (0 );
2702	return -1;
2703	}
2704
2705	if (this->formats != NULL((void *)0))
2706	free(this->formats, M_DEVBUF2, 0);
2707	this->nformats = 0;
2708	this->formats = mallocarray(variation, sizeof(struct audio_format),
2709	M_DEVBUF2, M_NOWAIT0x0002 \| M_ZERO0x0008);
2710	if (this->formats == NULL((void *)0)) {
2711	printf("%s: out of memory in %s\n",
2712	XNAME(this->az)((this->az)->dev.dv_xname), __func__);
2713	return ENOMEM12;
2714	}
2715
2716	/* register formats for playback */
2717	if (this->dacs.ngroups > 0) {
2718	group = &this->dacs.groups[this->dacs.cur];
2719	for (c = 0; c < group->nconv; c++) {
2720	chan = 0;
2721	bits_rates = ~0;
2722	if (this->w[group->conv[0]].widgetcap &
2723	COP_AWCAP_DIGITAL0x200)
2724	bits_rates &= ~(COP_PCM_B320x00100000);
2725	for (i = 0; i <= c; i++) {
2726	nid = group->conv[i];
2727	chan += WIDGET_CHANNELS(&this->w[nid])((&this->w[nid])->widgetcap & 0x001 ? 2 : 1);
2728	bits_rates &= this->w[nid].d.audio.bits_rates;
2729	}
2730	azalia_codec_add_bits(this, chan, bits_rates,
2731	AUMODE_PLAY0x01);
2732	}
2733	}
2734
2735	/* register formats for recording */
2736	if (this->adcs.ngroups > 0) {
2737	group = &this->adcs.groups[this->adcs.cur];
2738	for (c = 0; c < group->nconv; c++) {
2739	chan = 0;
2740	bits_rates = ~0;
2741	if (this->w[group->conv[0]].widgetcap &
2742	COP_AWCAP_DIGITAL0x200)
2743	bits_rates &= ~(COP_PCM_B320x00100000);
2744	for (i = 0; i <= c; i++) {
2745	nid = group->conv[i];
2746	chan += WIDGET_CHANNELS(&this->w[nid])((&this->w[nid])->widgetcap & 0x001 ? 2 : 1);
2747	bits_rates &= this->w[nid].d.audio.bits_rates;
2748	}
2749	azalia_codec_add_bits(this, chan, bits_rates,
2750	AUMODE_RECORD0x02);
2751	}
2752	}
2753
2754	return 0;
2755	}
2756
2757	void
2758	azalia_codec_add_bits(codec_t *this, int chan, uint32_t bits_rates, int mode)
2759	{
2760	if (bits_rates & COP_PCM_B80x00010000)
2761	azalia_codec_add_format(this, chan, 8, bits_rates, mode);
2762	if (bits_rates & COP_PCM_B160x00020000)
2763	azalia_codec_add_format(this, chan, 16, bits_rates, mode);
2764	if (bits_rates & COP_PCM_B200x00040000)
2765	azalia_codec_add_format(this, chan, 20, bits_rates, mode);
2766	if (bits_rates & COP_PCM_B240x00080000)
2767	azalia_codec_add_format(this, chan, 24, bits_rates, mode);
2768	if (bits_rates & COP_PCM_B320x00100000)
2769	azalia_codec_add_format(this, chan, 32, bits_rates, mode);
2770	}
2771
2772	void
2773	azalia_codec_add_format(codec_t *this, int chan, int prec, uint32_t rates,
2774	int32_t mode)
2775	{
2776	struct audio_format *f;
2777
2778	f = &this->formats[this->nformats++];
2779	f->mode = mode;
2780	f->encoding = AUDIO_ENCODING_SLINEAR_LE6;
2781	if (prec == 8)
2782	f->encoding = AUDIO_ENCODING_ULINEAR_LE8;
2783	f->precision = prec;
2784	f->channels = chan;
2785	f->frequency_type = 0;
2786	if (rates & COP_PCM_R800x00000001)
2787	f->frequency[f->frequency_type++] = 8000;
2788	if (rates & COP_PCM_R1100x00000002)
2789	f->frequency[f->frequency_type++] = 11025;
2790	if (rates & COP_PCM_R1600x00000004)
2791	f->frequency[f->frequency_type++] = 16000;
2792	if (rates & COP_PCM_R2200x00000008)
2793	f->frequency[f->frequency_type++] = 22050;
2794	if (rates & COP_PCM_R3200x00000010)
2795	f->frequency[f->frequency_type++] = 32000;
2796	if (rates & COP_PCM_R4410x00000020)
2797	f->frequency[f->frequency_type++] = 44100;
2798	if (rates & COP_PCM_R4800x00000040)
2799	f->frequency[f->frequency_type++] = 48000;
2800	if (rates & COP_PCM_R8820x00000080)
2801	f->frequency[f->frequency_type++] = 88200;
2802	if (rates & COP_PCM_R9600x00000100)
2803	f->frequency[f->frequency_type++] = 96000;
2804	if (rates & COP_PCM_R17640x00000200)
2805	f->frequency[f->frequency_type++] = 176400;
2806	if (rates & COP_PCM_R19200x00000400)
2807	f->frequency[f->frequency_type++] = 192000;
2808	if (rates & COP_PCM_R38400x00000800)
2809	f->frequency[f->frequency_type++] = 384000;
2810	}
2811
2812	int
2813	azalia_codec_connect_stream(stream_t *this)
2814	{
2815	const codec_t *codec = &this->az->codecs[this->az->codecno];
2816	const convgroup_t *group;
2817	widget_t *w;
2818	uint32_t digital, stream_chan;
2819	int i, err, curchan, nchan, widchan;
2820
2821	err = 0;
2822	nchan = (this->fmt & HDA_SD_FMT_CHAN0x000f) + 1;
2823
2824	if (this->dir == AUMODE_RECORD0x02)
2825	group = &codec->adcs.groups[codec->adcs.cur];
2826	else
2827	group = &codec->dacs.groups[codec->dacs.cur];
2828
2829	curchan = 0;
2830	for (i = 0; i < group->nconv; i++) {
2831	w = &codec->w[group->conv[i]];
2832	widchan = WIDGET_CHANNELS(w)((w)->widgetcap & 0x001 ? 2 : 1);
2833
2834	stream_chan = (this->number << 4);
2835	if (curchan < nchan) {
2836	stream_chan \|= curchan;
2837	} else if (w->nid == codec->spkr_dac \|\|
2838	w->nid == codec->fhp_dac) {
2839	stream_chan \|= 0; /* first channel(s) */
2840	} else
2841	stream_chan = 0; /* idle stream */
2842
2843	if (stream_chan == 0) {
2844	DPRINTFN(0, ("%s: %2.2x is idle\n", __func__, w->nid))do {} while (0 );
2845	} else {
2846	DPRINTFN(0, ("%s: %2.2x on stream chan %d\n", __func__,do {} while (0 )
2847	w->nid, stream_chan & ~(this->number << 4)))do {} while (0 );
2848	}
2849
2850	err = azalia_comresp(codec, w->nid, CORB_SET_CONVERTER_FORMAT0x200,
2851	this->fmt, NULL((void *)0));
2852	if (err) {
2853	DPRINTF(("%s: nid %2.2x fmt %2.2x: %d\n",do {} while (0 )
2854	__func__, w->nid, this->fmt, err))do {} while (0 );
2855	break;
2856	}
2857	err = azalia_comresp(codec, w->nid,
2858	CORB_SET_CONVERTER_STREAM_CHANNEL0x706, stream_chan, NULL((void *)0));
2859	if (err) {
2860	DPRINTF(("%s: nid %2.2x chan %d: %d\n",do {} while (0 )
2861	__func__, w->nid, stream_chan, err))do {} while (0 );
2862	break;
2863	}
2864
2865	if (w->widgetcap & COP_AWCAP_DIGITAL0x200) {
2866	err = azalia_comresp(codec, w->nid,
2867	CORB_GET_DIGITAL_CONTROL0xf0d, 0, &digital);
2868	if (err) {
2869	DPRINTF(("%s: nid %2.2x get digital: %d\n",do {} while (0 )
2870	__func__, w->nid, err))do {} while (0 );
2871	break;
2872	}
2873	digital = (digital & 0xff) \| CORB_DCC_DIGEN0x01;
2874	err = azalia_comresp(codec, w->nid,
2875	CORB_SET_DIGITAL_CONTROL_L0x70d, digital, NULL((void *)0));
2876	if (err) {
2877	DPRINTF(("%s: nid %2.2x set digital: %d\n",do {} while (0 )
2878	__func__, w->nid, err))do {} while (0 );
2879	break;
2880	}
2881	}
2882	curchan += widchan;
2883	}
2884
2885	return err;
2886	}
2887
2888	int
2889	azalia_codec_disconnect_stream(stream_t *this)
2890	{
2891	const codec_t *codec = &this->az->codecs[this->az->codecno];
2892	const convgroup_t *group;
2893	uint32_t v;
2894	int i;
2895	nid_t nid;
2896
2897	if (this->dir == AUMODE_RECORD0x02)
2898	group = &codec->adcs.groups[codec->adcs.cur];
2899	else
2900	group = &codec->dacs.groups[codec->dacs.cur];
2901	for (i = 0; i < group->nconv; i++) {
2902	nid = group->conv[i];
2903	azalia_comresp(codec, nid, CORB_SET_CONVERTER_STREAM_CHANNEL0x706,
2904	0, NULL((void )0)); / stream#0 */
2905	if (codec->w[nid].widgetcap & COP_AWCAP_DIGITAL0x200) {
2906	/* disable S/PDIF */
2907	azalia_comresp(codec, nid, CORB_GET_DIGITAL_CONTROL0xf0d,
2908	0, &v);
2909	v = (v & ~CORB_DCC_DIGEN0x01) & 0xff;
2910	azalia_comresp(codec, nid, CORB_SET_DIGITAL_CONTROL_L0x70d,
2911	v, NULL((void *)0));
2912	}
2913	}
2914	return 0;
2915	}
2916
2917	/* ================================================================
2918	* HDA widget functions
2919	* ================================================================ */
2920
2921	int
2922	azalia_widget_init(widget_t this, const codec_t codec, nid_t nid)
2923	{
2924	uint32_t result;
2925	int err;
2926
2927	err = azalia_comresp(codec, nid, CORB_GET_PARAMETER0xf00,
2928	COP_AUDIO_WIDGET_CAP0x09, &result);
2929	if (err)
2930	return err;
2931	this->nid = nid;
2932	this->widgetcap = result;
2933	this->type = COP_AWCAP_TYPE(result)((result >> 20) & 0xf);
2934	if (this->widgetcap & COP_AWCAP_POWER0x400) {
2935	azalia_comresp(codec, nid, CORB_SET_POWER_STATE0x705, CORB_PS_D00x0,
2936	&result);
2937	DELAY(100)(*delay_func)(100);
2938	}
2939
2940	this->enable = 1;
2941	this->mixer_class = -1;
2942	this->parent = codec->audiofunc;
2943
2944	switch (this->type) {
2945	case COP_AWTYPE_AUDIO_OUTPUT0x0:
2946	/* FALLTHROUGH */
2947	case COP_AWTYPE_AUDIO_INPUT0x1:
2948	azalia_widget_init_audio(this, codec);
2949	break;
2950	case COP_AWTYPE_PIN_COMPLEX0x4:
2951	azalia_widget_init_pin(this, codec);
2952	break;
2953	case COP_AWTYPE_VOLUME_KNOB0x6:
2954	err = azalia_comresp(codec, this->nid, CORB_GET_PARAMETER0xf00,
2955	COP_VOLUME_KNOB_CAPABILITIES0x13, &result);
2956	if (err)
2957	return err;
2958	this->d.volume.cap = result;
2959	break;
2960	case COP_AWTYPE_POWER0x5:
2961	/* FALLTHROUGH */
2962	case COP_AWTYPE_VENDOR_DEFINED0xf:
2963	this->enable = 0;
2964	break;
2965	}
2966
2967	/* amplifier information */
2968	/* XXX (ab)use bits 24-30 to store the "control offset", which is
2969	* the number of steps, starting at 0, that have no effect. these
2970	* bits are reserved in HDA 1.0.
2971	*/
2972	if (this->widgetcap & COP_AWCAP_INAMP0x002) {
2973	if (this->widgetcap & COP_AWCAP_AMPOV0x008)
2974	azalia_comresp(codec, nid, CORB_GET_PARAMETER0xf00,
2975	COP_INPUT_AMPCAP0x0d, &this->inamp_cap);
2976	else
2977	this->inamp_cap = codec->w[codec->audiofunc].inamp_cap;
2978	this->inamp_cap &= ~(0x7f << 24);
2979	}
2980	if (this->widgetcap & COP_AWCAP_OUTAMP0x004) {
2981	if (this->widgetcap & COP_AWCAP_AMPOV0x008)
2982	azalia_comresp(codec, nid, CORB_GET_PARAMETER0xf00,
2983	COP_OUTPUT_AMPCAP0x12, &this->outamp_cap);
2984	else
2985	this->outamp_cap = codec->w[codec->audiofunc].outamp_cap;
2986	this->outamp_cap &= ~(0x7f << 24);
2987	}
2988	return 0;
2989	}
2990
2991	int
2992	azalia_widget_sole_conn(codec_t *this, nid_t nid)
2993	{
2994	int i, j, target, nconn, has_target;
2995
2996	/* connected to ADC */
2997	for (i = 0; i < this->adcs.ngroups; i++) {
2998	for (j = 0; j < this->adcs.groups[i].nconv; j++) {
2999	target = this->adcs.groups[i].conv[j];
3000	if (this->w[target].nconnections == 1 &&
3001	this->w[target].connections[0] == nid) {
3002	return target;
3003	}
3004	}
3005	}
3006	/* connected to DAC */
3007	for (i = 0; i < this->dacs.ngroups; i++) {
3008	for (j = 0; j < this->dacs.groups[i].nconv; j++) {
3009	target = this->dacs.groups[i].conv[j];
3010	if (this->w[target].nconnections == 1 &&
3011	this->w[target].connections[0] == nid) {
3012	return target;
3013	}
3014	}
3015	}
3016	/* connected to pin complex */
3017	target = -1;
3018	FOR_EACH_WIDGET(this, i)for (i = (this)->wstart; i < (this)->wend; i++) {
3019	if (this->w[i].type != COP_AWTYPE_PIN_COMPLEX0x4)
3020	continue;
3021	if (this->w[i].nconnections == 1 &&
3022	this->w[i].connections[0] == nid) {
3023	if (target != -1)
3024	return -1;
3025	target = i;
3026	} else {
3027	nconn = 0;
3028	has_target = 0;
3029	for (j = 0; j < this->w[i].nconnections; j++) {
3030	if (!this->w[this->w[i].connections[j]].enable)
3031	continue;
3032	nconn++;
3033	if (this->w[i].connections[j] == nid)
3034	has_target = 1;
3035	}
3036	if (has_target == 1) {
3037	if (nconn == 1) {
3038	if (target != -1)
3039	return -1;
3040	target = i;
3041	} else {
3042	/* not sole connection at least once */
3043	return -1;
3044	}
3045	}
3046	}
3047	}
3048	if (target != -1)
3049	return target;
3050
3051	return -1;
3052	}
3053
3054	int
3055	azalia_widget_label_widgets(codec_t *codec)
3056	{
3057	widget_t *w;
3058	convgroup_t *group;
3059	int types[16];
3060	int pins[16];
3061	int colors_used, use_colors, schan;
3062	int i, j;
3063
3064	bzero(&pins, sizeof(pins))__builtin_bzero((&pins), (sizeof(pins)));
3065	bzero(&types, sizeof(types))__builtin_bzero((&types), (sizeof(types)));
3066
3067	/* If codec has more than one line-out jack, check if the jacks
3068	* have unique colors. If so, use the colors in the mixer names.
3069	*/
3070	use_colors = 1;
3071	colors_used = 0;
3072	if (codec->nout_jacks < 2)
3073	use_colors = 0;
3074	for (i = 0; use_colors && i < codec->nopins; i++) {
3075	w = &codec->w[codec->opins[i].nid];
3076	if (w->d.pin.device != CORB_CD_LINEOUT0x0)
3077	continue;
3078	if (colors_used & (1 << w->d.pin.color))
3079	use_colors = 0;
3080	else
3081	colors_used \|= (1 << w->d.pin.color);
3082	}
3083
3084	FOR_EACH_WIDGET(codec, i)for (i = (codec)->wstart; i < (codec)->wend; i++) {
3085	w = &codec->w[i];
3086	/* default for disabled/unused widgets */
3087	snprintf(w->name, sizeof(w->name), "u-wid%2.2x", w->nid);
3088	if (w->enable == 0)
3089	continue;
3090	switch (w->type) {
3091	case COP_AWTYPE_PIN_COMPLEX0x4:
3092	pins[w->d.pin.device]++;
3093	if (use_colors && w->d.pin.device == CORB_CD_LINEOUT0x0) {
3094	snprintf(w->name, sizeof(w->name), "%s-%s",
3095	pin_devices[w->d.pin.device],
3096	line_colors[w->d.pin.color]);
3097	} else if (pins[w->d.pin.device] > 1) {
3098	snprintf(w->name, sizeof(w->name), "%s%d",
3099	pin_devices[w->d.pin.device],
3100	pins[w->d.pin.device]);
3101	} else {
3102	snprintf(w->name, sizeof(w->name), "%s",
3103	pin_devices[w->d.pin.device]);
3104	}
3105	break;
3106	case COP_AWTYPE_AUDIO_OUTPUT0x0:
3107	if (codec->dacs.ngroups < 1)
3108	break;
3109	group = &codec->dacs.groups[0];
3110	schan = 0;
3111	for (j = 0; j < group->nconv; j++) {
3112	if (w->nid == group->conv[j]) {
3113	snprintf(w->name, sizeof(w->name),
3114	"%s-%d:%d", wtypes[w->type], schan,
3115	schan + WIDGET_CHANNELS(w)((w)->widgetcap & 0x001 ? 2 : 1) - 1);
3116	}
3117	schan += WIDGET_CHANNELS(w)((w)->widgetcap & 0x001 ? 2 : 1);
3118	}
3119	if (codec->dacs.ngroups < 2)
3120	break;
3121	group = &codec->dacs.groups[1];
3122	schan = 0;
3123	for (j = 0; j < group->nconv; j++) {
3124	if (w->nid == group->conv[j]) {
3125	snprintf(w->name, sizeof(w->name),
3126	"dig-%s-%d:%d", wtypes[w->type],
3127	schan,
3128	schan + WIDGET_CHANNELS(w)((w)->widgetcap & 0x001 ? 2 : 1) - 1);
3129	}
3130	schan += WIDGET_CHANNELS(w)((w)->widgetcap & 0x001 ? 2 : 1);
3131	}
3132	break;
3133	case COP_AWTYPE_AUDIO_INPUT0x1:
3134	w->mixer_class = AZ_CLASS_RECORD2;
3135	if (codec->adcs.ngroups < 1)
3136	break;
3137	group = &codec->adcs.groups[0];
3138	schan = 0;
3139	for (j = 0; j < group->nconv; j++) {
3140	if (w->nid == group->conv[j]) {
3141	snprintf(w->name, sizeof(w->name),
3142	"%s-%d:%d", wtypes[w->type], schan,
3143	schan + WIDGET_CHANNELS(w)((w)->widgetcap & 0x001 ? 2 : 1) - 1);
3144	}
3145	schan += WIDGET_CHANNELS(w)((w)->widgetcap & 0x001 ? 2 : 1);
3146	}
3147	if (codec->adcs.ngroups < 2)
3148	break;
3149	group = &codec->adcs.groups[1];
3150	schan = 0;
3151	for (j = 0; j < group->nconv; j++) {
3152	if (w->nid == group->conv[j]) {
3153	snprintf(w->name, sizeof(w->name),
3154	"dig-%s-%d:%d", wtypes[w->type],
3155	schan,
3156	schan + WIDGET_CHANNELS(w)((w)->widgetcap & 0x001 ? 2 : 1) - 1);
3157	}
3158	schan += WIDGET_CHANNELS(w)((w)->widgetcap & 0x001 ? 2 : 1);
3159	}
3160	break;
3161	default:
3162	types[w->type]++;
3163	if (types[w->type] > 1)
3164	snprintf(w->name, sizeof(w->name), "%s%d",
3165	wtypes[w->type], types[w->type]);
3166	else
3167	snprintf(w->name, sizeof(w->name), "%s",
3168	wtypes[w->type]);
3169	break;
3170	}
3171	}
3172
3173	/* Mixers and selectors that connect to only one other widget are
3174	* functionally part of the widget they are connected to. Show that
3175	* relationship in the name.
3176	*/
3177	FOR_EACH_WIDGET(codec, i)for (i = (codec)->wstart; i < (codec)->wend; i++) {
3178	if (codec->w[i].type != COP_AWTYPE_AUDIO_MIXER0x2 &&
3179	codec->w[i].type != COP_AWTYPE_AUDIO_SELECTOR0x3)
3180	continue;
3181	if (codec->w[i].enable == 0)
3182	continue;
3183	j = azalia_widget_sole_conn(codec, i);
3184	if (j == -1) {
3185	/* Special case. A selector with outamp capabilities
3186	* and is connected to a single widget that has either
3187	* no input or no output capabilities. This widget
3188	* serves as the input or output amp for the widget
3189	* it is connected to.
3190	*/
3191	if (codec->w[i].type == COP_AWTYPE_AUDIO_SELECTOR0x3 &&
3192	(codec->w[i].widgetcap & COP_AWCAP_OUTAMP0x004) &&
3193	codec->w[i].nconnections == 1) {
3194	j = codec->w[i].connections[0];
3195	if (!azalia_widget_enabled(codec, j))
3196	continue;
3197	if (!(codec->w[j].widgetcap & COP_AWCAP_INAMP0x002))
3198	codec->w[i].mixer_class =
3199	AZ_CLASS_INPUT0;
3200	else if (!(codec->w[j].widgetcap & COP_AWCAP_OUTAMP0x004))
3201	codec->w[i].mixer_class =
3202	AZ_CLASS_OUTPUT1;
3203	else
3204	continue;
3205	}
3206	}
3207	if (j >= 0) {
3208	/* As part of a disabled widget, this widget
3209	* should be disabled as well.
3210	*/
3211	if (codec->w[j].enable == 0) {
3212	codec->w[i].enable = 0;
3213	snprintf(codec->w[i].name,
3214	sizeof(codec->w[i].name),
3215	"u-wid%2.2x", i);
3216	continue;
3217	}
3218	snprintf(codec->w[i].name, sizeof(codec->w[i].name),
3219	"%s", codec->w[j].name);
3220	if (codec->w[j].mixer_class == AZ_CLASS_RECORD2)
3221	codec->w[i].mixer_class = AZ_CLASS_RECORD2;
3222	codec->w[i].parent = j;
3223	}
3224	}
3225
3226	return 0;
3227	}
3228
3229	int
3230	azalia_widget_init_audio(widget_t this, const codec_t codec)
3231	{
3232	uint32_t result;
3233	int err;
3234
3235	/* check audio format */
3236	if (this->widgetcap & COP_AWCAP_FORMATOV0x010) {
3237	err = azalia_comresp(codec, this->nid, CORB_GET_PARAMETER0xf00,
3238	COP_STREAM_FORMATS0x0b, &result);
3239	if (err)
3240	return err;
3241	this->d.audio.encodings = result;
3242	if (result == 0) { /* quirk for CMI9880.
3243	* This must not occur usually... */
3244	this->d.audio.encodings =
3245	codec->w[codec->audiofunc].d.audio.encodings;
3246	this->d.audio.bits_rates =
3247	codec->w[codec->audiofunc].d.audio.bits_rates;
3248	} else {
3249	if ((result & COP_STREAM_FORMAT_PCM0x00000001) == 0) {
3250	printf("%s: %s: No PCM support: %x\n",
3251	XNAME(codec->az)((codec->az)->dev.dv_xname), this->name, result);
3252	return -1;
3253	}
3254	err = azalia_comresp(codec, this->nid,
3255	CORB_GET_PARAMETER0xf00, COP_PCM0x0a, &result);
3256	if (err)
3257	return err;
3258	this->d.audio.bits_rates = result;
3259	}
3260	} else {
3261	this->d.audio.encodings =
3262	codec->w[codec->audiofunc].d.audio.encodings;
3263	this->d.audio.bits_rates =
3264	codec->w[codec->audiofunc].d.audio.bits_rates;
3265	}
3266	return 0;
3267	}
3268
3269	int
3270	azalia_widget_init_pin(widget_t this, const codec_t codec)
3271	{
3272	uint32_t result, dir;
3273	int err;
3274
3275	err = azalia_comresp(codec, this->nid, CORB_GET_CONFIGURATION_DEFAULT0xf1c,
3276	0, &result);
3277	if (err)
3278	return err;
3279	this->d.pin.config = result;
3280	this->d.pin.sequence = CORB_CD_SEQUENCE(result)(result & 0x0000000f);
3281	this->d.pin.association = CORB_CD_ASSOCIATION(result)((result >> 4) & 0xf);
3282	this->d.pin.color = CORB_CD_COLOR(result)((result >> 12) & 0xf);
3283	this->d.pin.device = CORB_CD_DEVICE(result)((result >> 20) & 0xf);
3284
3285	err = azalia_comresp(codec, this->nid, CORB_GET_PARAMETER0xf00,
3286	COP_PINCAP0x0c, &result);
3287	if (err)
3288	return err;
3289	this->d.pin.cap = result;
3290
3291	dir = CORB_PWC_INPUT0x20;
3292	switch (this->d.pin.device) {
3293	case CORB_CD_LINEOUT0x0:
3294	case CORB_CD_SPEAKER0x1:
3295	case CORB_CD_HEADPHONE0x2:
3296	case CORB_CD_SPDIFOUT0x4:
3297	case CORB_CD_DIGITALOUT0x5:
3298	dir = CORB_PWC_OUTPUT0x40;
3299	break;
3300	}
3301
3302	if (dir == CORB_PWC_INPUT0x20 && !(this->d.pin.cap & COP_PINCAP_INPUT0x00000020))
3303	dir = CORB_PWC_OUTPUT0x40;
3304	if (dir == CORB_PWC_OUTPUT0x40 && !(this->d.pin.cap & COP_PINCAP_OUTPUT0x00000010))
3305	dir = CORB_PWC_INPUT0x20;
3306
3307	if (dir == CORB_PWC_INPUT0x20 && this->d.pin.device == CORB_CD_MICIN0xa) {
3308	if (COP_PINCAP_VREF(this->d.pin.cap)((this->d.pin.cap >> 8) & 0xff) & (1 << CORB_PWC_VREF_800x04))
3309	dir \|= CORB_PWC_VREF_800x04;
3310	else if (COP_PINCAP_VREF(this->d.pin.cap)((this->d.pin.cap >> 8) & 0xff) &
3311	(1 << CORB_PWC_VREF_500x01))
3312	dir \|= CORB_PWC_VREF_500x01;
3313	}
3314
3315	if ((codec->qrks & AZ_QRK_WID_OVREF500x00004000) && (dir == CORB_PWC_OUTPUT0x40))
3316	dir \|= CORB_PWC_VREF_500x01;
3317
3318	azalia_comresp(codec, this->nid, CORB_SET_PIN_WIDGET_CONTROL0x707,
3319	dir, NULL((void *)0));
3320
3321	if (this->d.pin.cap & COP_PINCAP_EAPD0x00010000) {
3322	err = azalia_comresp(codec, this->nid,
3323	CORB_GET_EAPD_BTL_ENABLE0xf0c, 0, &result);
3324	if (err)
3325	return err;
3326	result &= 0xff;
3327	result \|= CORB_EAPD_EAPD0x02;
3328	err = azalia_comresp(codec, this->nid,
3329	CORB_SET_EAPD_BTL_ENABLE0x70c, result, &result);
3330	if (err)
3331	return err;
3332	}
3333
3334	/* Disable unconnected pins */
3335	if (CORB_CD_PORT(this->d.pin.config)((this->d.pin.config >> 30) & 0x3) == CORB_CD_NONE0x1)
3336	this->enable = 0;
3337
3338	return 0;
3339	}
3340
3341	int
3342	azalia_widget_init_connection(widget_t this, const codec_t codec)
3343	{
3344	uint32_t result;
3345	int err;
3346	int i, j, k;
3347	int length, nconn, bits, conn, last;
3348
3349	this->selected = -1;
3350	if ((this->widgetcap & COP_AWCAP_CONNLIST0x100) == 0)
3351	return 0;
3352
3353	err = azalia_comresp(codec, this->nid, CORB_GET_PARAMETER0xf00,
3354	COP_CONNECTION_LIST_LENGTH0x0e, &result);
3355	if (err)
3356	return err;
3357
3358	bits = 8;
3359	if (result & COP_CLL_LONG0x00000080)
3360	bits = 16;
3361
3362	length = COP_CLL_LENGTH(result)(result & 0x0000007f);
3363	if (length == 0)
3364	return 0;
3365
3366	/*
3367	* 'length' is the number of entries, not the number of
3368	* connections. Find the number of connections, 'nconn', so
3369	* enough space can be allocated for the list of connected
3370	* nids.
3371	*/
3372	nconn = last = 0;
3373	for (i = 0; i < length;) {
3374	err = azalia_comresp(codec, this->nid,
3375	CORB_GET_CONNECTION_LIST_ENTRY0xf02, i, &result);
3376	if (err)
3377	return err;
3378	for (k = 0; i < length && (k < 32 / bits); k++) {
3379	conn = (result >> (k * bits)) & ((1 << bits) - 1);
3380	/* If high bit is set, this is the end of a continuous
3381	* list that started with the last connection.
3382	*/
3383	if ((nconn > 0) && (conn & (1 << (bits - 1))))
3384	nconn += (conn & ~(1 << (bits - 1))) - last;
3385	else
3386	nconn++;
3387	last = conn;
3388	i++;
3389	}
3390	}
3391
3392	this->connections = mallocarray(nconn, sizeof(nid_t), M_DEVBUF2, M_NOWAIT0x0002);
3393	if (this->connections == NULL((void *)0)) {
3394	printf("%s: out of memory\n", XNAME(codec->az)((codec->az)->dev.dv_xname));
3395	return ENOMEM12;
3396	}
3397	for (i = 0; i < nconn;) {
3398	err = azalia_comresp(codec, this->nid,
3399	CORB_GET_CONNECTION_LIST_ENTRY0xf02, i, &result);
3400	if (err)
3401	return err;
3402	for (k = 0; i < nconn && (k < 32 / bits); k++) {
3403	conn = (result >> (k * bits)) & ((1 << bits) - 1);
3404	/* If high bit is set, this is the end of a continuous
3405	* list that started with the last connection.
3406	*/
3407	if ((i > 0) && (conn & (1 << (bits - 1)))) {
3408	for (j = 1; i < nconn && j <= conn - last; j++)
3409	this->connections[i++] = last + j;
3410	} else {
3411	this->connections[i++] = conn;
3412	}
3413	last = conn;
3414	}
3415	}
3416	this->nconnections = nconn;
3417
3418	if (nconn > 0) {
3419	err = azalia_comresp(codec, this->nid,
3420	CORB_GET_CONNECTION_SELECT_CONTROL0xf01, 0, &result);
3421	if (err)
3422	return err;
3423	this->selected = CORB_CSC_INDEX(result)(result & 0xff);
3424	}
3425	return 0;
3426	}
3427
3428	int
3429	azalia_widget_check_conn(codec_t *codec, int index, int depth)
3430	{
3431	const widget_t *w;
3432	int i;
3433
3434	w = &codec->w[index];
3435
3436	if (w->type == COP_AWTYPE_BEEP_GENERATOR0x7)
3437	return 0;
3438
3439	if (depth > 0 &&
3440	(w->type == COP_AWTYPE_PIN_COMPLEX0x4 \|\|
3441	w->type == COP_AWTYPE_AUDIO_OUTPUT0x0 \|\|
3442	w->type == COP_AWTYPE_AUDIO_INPUT0x1)) {
3443	if (w->enable)
3444	return 1;
3445	else
3446	return 0;
3447	}
3448	if (++depth >= 10)
3449	return 0;
3450	for (i = 0; i < w->nconnections; i++) {
3451	if (!azalia_widget_enabled(codec, w->connections[i]))
3452	continue;
3453	if (azalia_widget_check_conn(codec, w->connections[i], depth))
3454	return 1;
3455	}
3456	return 0;
3457	}
3458
3459	#ifdef AZALIA_DEBUG
3460
3461	#define WIDGETCAP_BITS \
3462	"\20\014LRSWAP\013POWER\012DIGITAL" \
3463	"\011CONNLIST\010UNSOL\07PROC\06STRIPE\05FORMATOV\04AMPOV\03OUTAMP" \
3464	"\02INAMP\01STEREO"
3465
3466	#define PINCAP_BITS "\20\021EAPD\16VREF100\15VREF80" \
3467	"\13VREFGND\12VREF50\11VREFHIZ\07BALANCE\06INPUT" \
3468	"\05OUTPUT\04HEADPHONE\03PRESENCE\02TRIGGER\01IMPEDANCE"
3469
3470	#define ENCODING_BITS "\20\3AC3\2FLOAT32\1PCM"
3471
3472	#define BITSRATES_BITS "\20\x15""32bit\x14""24bit\x13""20bit" \
3473	"\x12""16bit\x11""8bit""\x0c""384kHz\x0b""192kHz\x0a""176.4kHz" \
3474	"\x09""96kHz\x08""88.2kHz\x07""48kHz\x06""44.1kHz\x05""32kHz\x04" \
3475	"22.05kHz\x03""16kHz\x02""11.025kHz\x01""8kHz"
3476
3477	static const char *pin_colors[16] = {
3478	"unknown", "black", "gray", "blue",
3479	"green", "red", "orange", "yellow",
3480	"purple", "pink", "col0a", "col0b",
3481	"col0c", "col0d", "white", "other"};
3482	static const char *pin_conn[4] = {
3483	"jack", "none", "fixed", "combined"};
3484	static const char *pin_conntype[16] = {
3485	"unknown", "1/8", "1/4", "atapi", "rca", "optical",
3486	"digital", "analog", "din", "xlr", "rj-11", "combination",
3487	"con0c", "con0d", "con0e", "other"};
3488	static const char *pin_geo[15] = {
3489	"n/a", "rear", "front", "left",
3490	"right", "top", "bottom", "spec0", "spec1", "spec2",
3491	"loc0a", "loc0b", "loc0c", "loc0d", "loc0f"};
3492	static const char *pin_chass[4] = {
3493	"external", "internal", "separate", "other"};
3494
3495	void
3496	azalia_codec_print_audiofunc(const codec_t *this)
3497	{
3498	uint32_t result;
3499
3500	azalia_widget_print_audio(&this->w[this->audiofunc], "\t");
3501
3502	result = this->w[this->audiofunc].inamp_cap;
3503	DPRINTF(("\tinamp: mute=%u size=%u steps=%u offset=%u\n",do {} while (0 )
3504	(result & COP_AMPCAP_MUTE) != 0, COP_AMPCAP_STEPSIZE(result),do {} while (0 )
3505	COP_AMPCAP_NUMSTEPS(result), COP_AMPCAP_OFFSET(result)))do {} while (0 );
3506	result = this->w[this->audiofunc].outamp_cap;
3507	DPRINTF(("\toutamp: mute=%u size=%u steps=%u offset=%u\n",do {} while (0 )
3508	(result & COP_AMPCAP_MUTE) != 0, COP_AMPCAP_STEPSIZE(result),do {} while (0 )
3509	COP_AMPCAP_NUMSTEPS(result), COP_AMPCAP_OFFSET(result)))do {} while (0 );
3510	azalia_comresp(this, this->audiofunc, CORB_GET_PARAMETER0xf00,
3511	COP_GPIO_COUNT0x11, &result);
3512	DPRINTF(("\tgpio: wake=%u unsol=%u gpis=%u gpos=%u gpios=%u\n",do {} while (0 )
3513	(result & COP_GPIO_WAKE) != 0, (result & COP_GPIO_UNSOL) != 0,do {} while (0 )
3514	COP_GPIO_GPIS(result), COP_GPIO_GPOS(result),do {} while (0 )
3515	COP_GPIO_GPIOS(result)))do {} while (0 );
3516	}
3517
3518	void
3519	azalia_codec_print_groups(const codec_t *this)
3520	{
3521	int i, n;
3522
3523	for (i = 0; i < this->dacs.ngroups; i++) {
3524	printf("%s: dacgroup[%d]:", XNAME(this->az)((this->az)->dev.dv_xname), i);
3525	for (n = 0; n < this->dacs.groups[i].nconv; n++) {
3526	printf(" %2.2x", this->dacs.groups[i].conv[n]);
3527	}
3528	printf("\n");
3529	}
3530	for (i = 0; i < this->adcs.ngroups; i++) {
3531	printf("%s: adcgroup[%d]:", XNAME(this->az)((this->az)->dev.dv_xname), i);
3532	for (n = 0; n < this->adcs.groups[i].nconv; n++) {
3533	printf(" %2.2x", this->adcs.groups[i].conv[n]);
3534	}
3535	printf("\n");
3536	}
3537	}
3538
3539	void
3540	azalia_widget_print_audio(const widget_t this, const char lead)
3541	{
3542	printf("%sencodings=%b\n", lead, this->d.audio.encodings,
3543	ENCODING_BITS);
3544	printf("%sPCM formats=%b\n", lead, this->d.audio.bits_rates,
3545	BITSRATES_BITS);
3546	}
3547
3548	void
3549	azalia_widget_print_widget(const widget_t w, const codec_t codec)
3550	{
3551	int i;
3552
3553	printf("%s: ", XNAME(codec->az)((codec->az)->dev.dv_xname));
3554	printf("%s%2.2x wcap=%b\n", w->type == COP_AWTYPE_PIN_COMPLEX0x4 ?
3555	pin_colors[w->d.pin.color] : wtypes[w->type],
3556	w->nid, w->widgetcap, WIDGETCAP_BITS);
3557	if (w->widgetcap & COP_AWCAP_FORMATOV0x010)
3558	azalia_widget_print_audio(w, "\t");
3559	if (w->type == COP_AWTYPE_PIN_COMPLEX0x4)
3560	azalia_widget_print_pin(w);
3561
3562	if (w->type == COP_AWTYPE_VOLUME_KNOB0x6)
3563	printf("\tdelta=%d steps=%d\n",
3564	!!(w->d.volume.cap & COP_VKCAP_DELTA0x00000080),
3565	COP_VKCAP_NUMSTEPS(w->d.volume.cap)(w->d.volume.cap & 0x7f));
3566
3567	if ((w->widgetcap & COP_AWCAP_INAMP0x002) &&
3568	(w->widgetcap & COP_AWCAP_AMPOV0x008))
3569	printf("\tinamp: mute=%u size=%u steps=%u offset=%u\n",
3570	(w->inamp_cap & COP_AMPCAP_MUTE0x80000000) != 0,
3571	COP_AMPCAP_STEPSIZE(w->inamp_cap)((w->inamp_cap >> 16) & 0x7f),
3572	COP_AMPCAP_NUMSTEPS(w->inamp_cap)((w->inamp_cap >> 8) & 0x7f),
3573	COP_AMPCAP_OFFSET(w->inamp_cap)(w->inamp_cap & 0x0000007f));
3574
3575	if ((w->widgetcap & COP_AWCAP_OUTAMP0x004) &&
3576	(w->widgetcap & COP_AWCAP_AMPOV0x008))
3577	printf("\toutamp: mute=%u size=%u steps=%u offset=%u\n",
3578	(w->outamp_cap & COP_AMPCAP_MUTE0x80000000) != 0,
3579	COP_AMPCAP_STEPSIZE(w->outamp_cap)((w->outamp_cap >> 16) & 0x7f),
3580	COP_AMPCAP_NUMSTEPS(w->outamp_cap)((w->outamp_cap >> 8) & 0x7f),
3581	COP_AMPCAP_OFFSET(w->outamp_cap)(w->outamp_cap & 0x0000007f));
3582
3583	if (w->nconnections > 0) {
3584	printf("\tconnections=0x%x", w->connections[0]);
3585	for (i = 1; i < w->nconnections; i++)
3586	printf(",0x%x", w->connections[i]);
3587	printf("; selected=0x%x\n", w->connections[w->selected]);
3588	}
3589	}
3590
3591	void
3592	azalia_widget_print_pin(const widget_t *this)
3593	{
3594	printf("\tcap=%b\n", this->d.pin.cap, PINCAP_BITS);
3595	printf("\t[%2.2d/%2.2d] ", CORB_CD_ASSOCIATION(this->d.pin.config)((this->d.pin.config >> 4) & 0xf),
3596	CORB_CD_SEQUENCE(this->d.pin.config)(this->d.pin.config & 0x0000000f));
3597	printf("color=%s ", pin_colors[CORB_CD_COLOR(this->d.pin.config)((this->d.pin.config >> 12) & 0xf)]);
3598	printf("device=%s ", pin_devices[CORB_CD_DEVICE(this->d.pin.config)((this->d.pin.config >> 20) & 0xf)]);
3599	printf("conn=%s ", pin_conn[CORB_CD_PORT(this->d.pin.config)((this->d.pin.config >> 30) & 0x3)]);
3600	printf("conntype=%s\n", pin_conntype[CORB_CD_CONNECTION(this->d.pin.config)((this->d.pin.config >> 16) & 0xf)]);
3601	printf("\tlocation=%s ", pin_geo[CORB_CD_LOC_GEO(this->d.pin.config)((this->d.pin.config >> 24) & 0xf)]);
3602	printf("chassis=%s ", pin_chass[CORB_CD_LOC_CHASS(this->d.pin.config)((this->d.pin.config >> 28) & 0x3)]);
3603	printf("special=");
3604	if (CORB_CD_LOC_GEO(this->d.pin.config)((this->d.pin.config >> 24) & 0xf) == CORB_CD_LOC_SPEC00x7) {
3605	if (CORB_CD_LOC_CHASS(this->d.pin.config)((this->d.pin.config >> 28) & 0x3) == CORB_CD_EXTERNAL0x0)
3606	printf("rear-panel");
3607	else if (CORB_CD_LOC_CHASS(this->d.pin.config)((this->d.pin.config >> 28) & 0x3) == CORB_CD_INTERNAL0x1)
3608	printf("riser");
3609	else if (CORB_CD_LOC_CHASS(this->d.pin.config)((this->d.pin.config >> 28) & 0x3) == CORB_CD_LOC_OTHER0x3)
3610	printf("mobile-lid-internal");
3611	} else if (CORB_CD_LOC_GEO(this->d.pin.config)((this->d.pin.config >> 24) & 0xf) == CORB_CD_LOC_SPEC10x8) {
3612	if (CORB_CD_LOC_CHASS(this->d.pin.config)((this->d.pin.config >> 28) & 0x3) == CORB_CD_EXTERNAL0x0)
3613	printf("drive-bay");
3614	else if (CORB_CD_LOC_CHASS(this->d.pin.config)((this->d.pin.config >> 28) & 0x3) == CORB_CD_INTERNAL0x1)
3615	printf("hdmi");
3616	else if (CORB_CD_LOC_CHASS(this->d.pin.config)((this->d.pin.config >> 28) & 0x3) == CORB_CD_LOC_OTHER0x3)
3617	printf("mobile-lid-external");
3618	} else if (CORB_CD_LOC_GEO(this->d.pin.config)((this->d.pin.config >> 24) & 0xf) == CORB_CD_LOC_SPEC20x9) {
3619	if (CORB_CD_LOC_CHASS(this->d.pin.config)((this->d.pin.config >> 28) & 0x3) == CORB_CD_INTERNAL0x1)
3620	printf("atapi");
3621	} else
3622	printf("none");
3623	printf("\n");
3624	}
3625
3626	#else /* AZALIA_DEBUG */
3627
3628	void
3629	azalia_codec_print_audiofunc(const codec_t *this) {}
3630
3631	void
3632	azalia_codec_print_groups(const codec_t *this) {}
3633
3634	void
3635	azalia_widget_print_audio(const widget_t this, const char lead) {}
3636
3637	void
3638	azalia_widget_print_widget(const widget_t w, const codec_t codec) {}
3639
3640	void
3641	azalia_widget_print_pin(const widget_t *this) {}
3642
3643	#endif /* AZALIA_DEBUG */
3644
3645	/* ================================================================
3646	* Stream functions
3647	* ================================================================ */
3648
3649	int
3650	azalia_stream_init(stream_t this, azalia_t az, int regindex, int strnum,
3651	int dir)
3652	{
3653	int err;
3654
3655	this->az = az;
3656	this->regbase = HDA_SD_BASE0x080 + regindex * HDA_SD_SIZE0x20;
3657	this->intr_bit = 1 << regindex;
3658	this->number = strnum;
3659	this->dir = dir;
3660
3661	/* setup BDL buffers */
3662	err = azalia_alloc_dmamem(az, sizeof(bdlist_entry_t) * HDA_BDL_MAX256,
3663	128, &this->bdlist);
3664	if (err) {
3665	printf("%s: can't allocate a BDL buffer\n", XNAME(az)((az)->dev.dv_xname));
3666	return err;
3667	}
3668	return 0;
3669	}
3670
3671	int
3672	azalia_stream_reset(stream_t *this)
3673	{
3674	int i;
3675	uint16_t ctl;
3676	uint8_t sts;
3677
3678	/* Make sure RUN bit is zero before resetting */
3679	ctl = STR_READ_2(this, CTL)(((this)->az->iot)->read_2(((this)->az->ioh), ( (this)->regbase + 0x00)));
3680	ctl &= ~HDA_SD_CTL_RUN0x0002;
3681	STR_WRITE_2(this, CTL, ctl)(((this)->az->iot)->write_2(((this)->az->ioh), ((this)->regbase + 0x00), (ctl)));
3682	DELAY(40)(*delay_func)(40);
3683
3684	/* Start reset and wait for chip to enter. */
3685	ctl = STR_READ_2(this, CTL)(((this)->az->iot)->read_2(((this)->az->ioh), ( (this)->regbase + 0x00)));
3686	STR_WRITE_2(this, CTL, ctl \| HDA_SD_CTL_SRST)(((this)->az->iot)->write_2(((this)->az->ioh), ((this)->regbase + 0x00), (ctl \| 0x0001)));
3687	for (i = 5000; i > 0; i--) {
3688	DELAY(10)(*delay_func)(10);
3689	ctl = STR_READ_2(this, CTL)(((this)->az->iot)->read_2(((this)->az->ioh), ( (this)->regbase + 0x00)));
3690	if (ctl & HDA_SD_CTL_SRST0x0001)
3691	break;
3692	}
3693	if (i == 0) {
3694	DPRINTF(("%s: stream reset failure 1\n", XNAME(this->az)))do {} while (0 );
3695	return -1;
3696	}
3697
3698	/* Clear reset and wait for chip to finish */
3699	STR_WRITE_2(this, CTL, ctl & ~HDA_SD_CTL_SRST)(((this)->az->iot)->write_2(((this)->az->ioh), ((this)->regbase + 0x00), (ctl & ~0x0001)));
3700	for (i = 5000; i > 0; i--) {
3701	DELAY(10)(*delay_func)(10);
3702	ctl = STR_READ_2(this, CTL)(((this)->az->iot)->read_2(((this)->az->ioh), ( (this)->regbase + 0x00)));
3703	if ((ctl & HDA_SD_CTL_SRST0x0001) == 0)
3704	break;
3705	}
3706	if (i == 0) {
3707	DPRINTF(("%s: stream reset failure 2\n", XNAME(this->az)))do {} while (0 );
3708	return -1;
3709	}
3710
3711	sts = STR_READ_1(this, STS)(((this)->az->iot)->read_1(((this)->az->ioh), ( (this)->regbase + 0x03)));
3712	sts \|= HDA_SD_STS_DESE0x10 \| HDA_SD_STS_FIFOE0x08 \| HDA_SD_STS_BCIS0x04;
3713	STR_WRITE_1(this, STS, sts)(((this)->az->iot)->write_1(((this)->az->ioh), ((this)->regbase + 0x03), (sts)));
3714
3715	return (0);
3716	}
3717
3718	int
3719	azalia_stream_start(stream_t *this)
3720	{
3721	bdlist_entry_t *bdlist;
3722	bus_addr_t dmaaddr, dmaend;
3723	int err, index;
3724	uint32_t intctl;
3725	uint8_t ctl2;
3726
3727	err = azalia_stream_reset(this);
3728	if (err) {
3729	DPRINTF(("%s: stream reset failed\n", "azalia"))do {} while (0 );
3730	return err;
3731	}
3732
3733	STR_WRITE_4(this, BDPL, 0)(((this)->az->iot)->write_4(((this)->az->ioh), ((this)->regbase + 0x18), (0)));
3734	STR_WRITE_4(this, BDPU, 0)(((this)->az->iot)->write_4(((this)->az->ioh), ((this)->regbase + 0x1c), (0)));
3735
3736	/* setup BDL */
3737	dmaaddr = AZALIA_DMA_DMAADDR(&this->buffer)((&this->buffer)->map->dm_segs[0].ds_addr);
3738	dmaend = dmaaddr + this->bufsize;
3739	bdlist = (bdlist_entry_t*)this->bdlist.addr;
3740	for (index = 0; index < HDA_BDL_MAX256; index++) {
3741	bdlist[index].low = htole32(dmaaddr)((__uint32_t)(dmaaddr));
3742	bdlist[index].high = htole32(PTR_UPPER32(dmaaddr))((__uint32_t)(((uint64_t)(dmaaddr) >> 32)));
3743	bdlist[index].length = htole32(this->blk)((__uint32_t)(this->blk));
3744	bdlist[index].flags = htole32(BDLIST_ENTRY_IOC)((__uint32_t)(0x00000001));
3745	dmaaddr += this->blk;
3746	if (dmaaddr >= dmaend) {
3747	index++;
3748	break;
3749	}
3750	}
3751
3752	DPRINTFN(1, ("%s: size=%d fmt=0x%4.4x index=%d\n",do {} while (0 )
3753	__func__, this->bufsize, this->fmt, index))do {} while (0 );
3754
3755	dmaaddr = AZALIA_DMA_DMAADDR(&this->bdlist)((&this->bdlist)->map->dm_segs[0].ds_addr);
3756	STR_WRITE_4(this, BDPL, dmaaddr)(((this)->az->iot)->write_4(((this)->az->ioh), ((this)->regbase + 0x18), (dmaaddr)));
3757	STR_WRITE_4(this, BDPU, PTR_UPPER32(dmaaddr))(((this)->az->iot)->write_4(((this)->az->ioh), ((this)->regbase + 0x1c), (((uint64_t)(dmaaddr) >> 32 ))));
3758	STR_WRITE_2(this, LVI, (index - 1) & HDA_SD_LVI_LVI)(((this)->az->iot)->write_2(((this)->az->ioh), ((this)->regbase + 0x0c), ((index - 1) & 0x00ff)));
3759	ctl2 = STR_READ_1(this, CTL2)(((this)->az->iot)->read_1(((this)->az->ioh), ( (this)->regbase + 0x02)));
3760	STR_WRITE_1(this, CTL2,(((this)->az->iot)->write_1(((this)->az->ioh), ((this)->regbase + 0x02), ((ctl2 & ~0xf0) \| (this-> number << 4))))
3761	(ctl2 & ~HDA_SD_CTL2_STRM) \| (this->number << HDA_SD_CTL2_STRM_SHIFT))(((this)->az->iot)->write_1(((this)->az->ioh), ((this)->regbase + 0x02), ((ctl2 & ~0xf0) \| (this-> number << 4))));
3762	STR_WRITE_4(this, CBL, this->bufsize)(((this)->az->iot)->write_4(((this)->az->ioh), ((this)->regbase + 0x08), (this->bufsize)));
3763	STR_WRITE_2(this, FMT, this->fmt)(((this)->az->iot)->write_2(((this)->az->ioh), ((this)->regbase + 0x12), (this->fmt)));
3764
3765	err = azalia_codec_connect_stream(this);
3766	if (err)
3767	return EINVAL22;
3768
3769	intctl = AZ_READ_4(this->az, INTCTL)(((this->az)->iot)->read_4(((this->az)->ioh), ( 0x020)));
3770	intctl \|= this->intr_bit;
3771	AZ_WRITE_4(this->az, INTCTL, intctl)(((this->az)->iot)->write_4(((this->az)->ioh), (0x020), (intctl)));
3772
3773	STR_WRITE_1(this, CTL, STR_READ_1(this, CTL) \|(((this)->az->iot)->write_1(((this)->az->ioh), ((this)->regbase + 0x00), ((((this)->az->iot)->read_1 (((this)->az->ioh), ((this)->regbase + 0x00))) \| 0x0010 \| 0x0008 \| 0x0004 \| 0x0002)))
3774	HDA_SD_CTL_DEIE \| HDA_SD_CTL_FEIE \| HDA_SD_CTL_IOCE \|(((this)->az->iot)->write_1(((this)->az->ioh), ((this)->regbase + 0x00), ((((this)->az->iot)->read_1 (((this)->az->ioh), ((this)->regbase + 0x00))) \| 0x0010 \| 0x0008 \| 0x0004 \| 0x0002)))
3775	HDA_SD_CTL_RUN)(((this)->az->iot)->write_1(((this)->az->ioh), ((this)->regbase + 0x00), ((((this)->az->iot)->read_1 (((this)->az->ioh), ((this)->regbase + 0x00))) \| 0x0010 \| 0x0008 \| 0x0004 \| 0x0002)));
3776	return (0);
3777	}
3778
3779	int
3780	azalia_stream_halt(stream_t *this)
3781	{
3782	uint16_t ctl;
3783
3784	ctl = STR_READ_2(this, CTL)(((this)->az->iot)->read_2(((this)->az->ioh), ( (this)->regbase + 0x00)));
3785	ctl &= ~(HDA_SD_CTL_DEIE0x0010 \| HDA_SD_CTL_FEIE0x0008 \| HDA_SD_CTL_IOCE0x0004 \| HDA_SD_CTL_RUN0x0002);
3786	STR_WRITE_2(this, CTL, ctl)(((this)->az->iot)->write_2(((this)->az->ioh), ((this)->regbase + 0x00), (ctl)));
3787	AZ_WRITE_4(this->az, INTCTL,(((this->az)->iot)->write_4(((this->az)->ioh), (0x020), ((((this->az)->iot)->read_4(((this->az) ->ioh), (0x020))) & ~this->intr_bit)))
3788	AZ_READ_4(this->az, INTCTL) & ~this->intr_bit)(((this->az)->iot)->write_4(((this->az)->ioh), (0x020), ((((this->az)->iot)->read_4(((this->az) ->ioh), (0x020))) & ~this->intr_bit)));
3789	azalia_codec_disconnect_stream(this);
3790
3791	return (0);
3792	}
3793
3794	#define HDA_SD_STS_BITS"\20\3BCIS\4FIFOE\5DESE\6FIFORDY" "\20\3BCIS\4FIFOE\5DESE\6FIFORDY"
3795
3796	int
3797	azalia_stream_intr(stream_t *this)
3798	{
3799	unsigned int lpib, fifos, hwpos, cnt;
3800	u_int8_t sts;
3801
3802	sts = STR_READ_1(this, STS)(((this)->az->iot)->read_1(((this)->az->ioh), ( (this)->regbase + 0x03)));
3803	STR_WRITE_1(this, STS, sts \|(((this)->az->iot)->write_1(((this)->az->ioh), ((this)->regbase + 0x03), (sts \| 0x10 \| 0x08 \| 0x04)))
3804	HDA_SD_STS_DESE \| HDA_SD_STS_FIFOE \| HDA_SD_STS_BCIS)(((this)->az->iot)->write_1(((this)->az->ioh), ((this)->regbase + 0x03), (sts \| 0x10 \| 0x08 \| 0x04)));
3805
3806	if (sts & (HDA_SD_STS_DESE0x10 \| HDA_SD_STS_FIFOE0x08))
3807	DPRINTF(("%s: stream %d: sts=%b\n", XNAME(this->az),do {} while (0 )
3808	this->number, sts, HDA_SD_STS_BITS))do {} while (0 );
3809
3810	if (sts & HDA_SD_STS_BCIS0x04) {
3811	lpib = STR_READ_4(this, LPIB)(((this)->az->iot)->read_4(((this)->az->ioh), ( (this)->regbase + 0x04)));
3812	fifos = STR_READ_2(this, FIFOS)(((this)->az->iot)->read_2(((this)->az->ioh), ( (this)->regbase + 0x10)));
3813	if (fifos & 1)
3814	fifos++;
3815	hwpos = lpib;
3816	if (this->dir == AUMODE_PLAY0x01)
3817	hwpos += fifos + 1;
3818	if (hwpos >= this->bufsize)
3819	hwpos -= this->bufsize;
3820	DPRINTFN(2, ("%s: stream %d, pos = %d -> %d, "do {} while (0 )
3821	"lpib = %u, fifos = %u\n", __func__,do {} while (0 )
3822	this->number, this->swpos, hwpos, lpib, fifos))do {} while (0 );
3823	cnt = 0;
3824	while (hwpos - this->swpos >= this->blk) {
3825	this->intr(this->intr_arg);
3826	this->swpos += this->blk;
3827	if (this->swpos == this->bufsize)
3828	this->swpos = 0;
3829	cnt++;
3830	}
3831	if (cnt != 1) {
3832	DPRINTF(("%s: stream %d: hwpos %u, %u intrs\n",do {} while (0 )
3833	__func__, this->number, this->swpos, cnt))do {} while (0 );
3834	}
3835	}
3836	return (1);
3837	}
3838
3839	/* ================================================================
3840	* MI audio entries
3841	* ================================================================ */
3842
3843	int
3844	azalia_open(void *v, int flags)
3845	{
3846	azalia_t *az;
3847	codec_t *codec;
3848
3849	DPRINTFN(1, ("%s: flags=0x%x\n", __func__, flags))do {} while (0 );
3850	az = v;
3851	codec = &az->codecs[az->codecno];
3852	if ((flags & FWRITE0x0002) && codec->dacs.ngroups == 0)
3853	return ENODEV19;
3854	if ((flags & FREAD0x0001) && codec->adcs.ngroups == 0)
3855	return ENODEV19;
3856	codec->running++;
3857	return 0;
3858	}
3859
3860	void
3861	azalia_close(void *v)
3862	{
3863	azalia_t *az;
3864	codec_t *codec;
3865
3866	DPRINTFN(1, ("%s\n", __func__))do {} while (0 );
3867	az = v;
3868	codec = &az->codecs[az->codecno];
3869	codec->running--;
3870	}
3871
3872	int
3873	azalia_match_format(codec_t codec, int mode, audio_params_t par)
3874	{
3875	int i;
3876
3877	DPRINTFN(1, ("%s: mode=%d, want: enc=%d, prec=%d, chans=%d\n", __func__,do {} while (0 )
3878	mode, par->encoding, par->precision, par->channels))do {} while (0 );
3879
3880	for (i = 0; i < codec->nformats; i++) {
3881	if (mode != codec->formats[i].mode)
3882	continue;
3883	if (par->encoding != codec->formats[i].encoding)
3884	continue;
3885	if (par->precision != codec->formats[i].precision)
3886	continue;
3887	if (par->channels != codec->formats[i].channels)
3888	continue;
3889	break;
3890	}
3891
3892	DPRINTFN(1, ("%s: return: enc=%d, prec=%d, chans=%d\n", __func__,do {} while (0 )
3893	codec->formats[i].encoding, codec->formats[i].precision,do {} while (0 )
3894	codec->formats[i].channels))do {} while (0 );
3895
3896	return (i);
3897	}
3898
3899	int
3900	azalia_set_params_sub(codec_t codec, int mode, audio_params_t par)
3901	{
3902	int i, j;
3903	uint ochan, oenc, opre;
3904	#ifdef AZALIA_DEBUG
3905	char *cmode = (mode == AUMODE_PLAY0x01) ? "play" : "record";
3906	#endif
3907
3908	ochan = par->channels;
3909	oenc = par->encoding;
3910	opre = par->precision;
3911
3912	if ((mode == AUMODE_PLAY0x01 && codec->dacs.ngroups == 0) \|\|
3913	(mode == AUMODE_RECORD0x02 && codec->adcs.ngroups == 0))
3914	return 0;
3915
3916	i = azalia_match_format(codec, mode, par);
3917	if (i == codec->nformats && (par->precision != 16 \|\| par->encoding !=
3918	AUDIO_ENCODING_SLINEAR_LE6)) {
3919	/* try with default encoding/precision */
3920	par->encoding = AUDIO_ENCODING_SLINEAR_LE6;
3921	par->precision = 16;
3922	i = azalia_match_format(codec, mode, par);
3923	}
3924	if (i == codec->nformats && par->channels != 2) {
3925	/* try with default channels */
3926	par->encoding = oenc;
3927	par->precision = opre;
3928	par->channels = 2;
3929	i = azalia_match_format(codec, mode, par);
3930	}
3931	/* try with default everything */
3932	if (i == codec->nformats) {
3933	par->encoding = AUDIO_ENCODING_SLINEAR_LE6;
3934	par->precision = 16;
3935	par->channels = 2;
3936	i = azalia_match_format(codec, mode, par);
3937	if (i == codec->nformats) {
3938	DPRINTF(("%s: can't find %s format %u/%u/%u\n",do {} while (0 )
3939	__func__, cmode, par->encoding,do {} while (0 )
3940	par->precision, par->channels))do {} while (0 );
3941	return EINVAL22;
3942	}
3943	}
3944	if (codec->formats[i].frequency_type == 0) {
3945	DPRINTF(("%s: matched %s format %d has 0 frequencies\n",do {} while (0 )
3946	__func__, cmode, i))do {} while (0 );
3947	return EINVAL22;
3948	}
3949
3950	for (j = 0; j < codec->formats[i].frequency_type; j++) {
3951	if (par->sample_rate != codec->formats[i].frequency[j])
3952	continue;
3953	break;
3954	}
3955	if (j == codec->formats[i].frequency_type) {
3956	/* try again with default */
3957	par->sample_rate = 48000;
3958	for (j = 0; j < codec->formats[i].frequency_type; j++) {
3959	if (par->sample_rate != codec->formats[i].frequency[j])
3960	continue;
3961	break;
3962	}
3963	if (j == codec->formats[i].frequency_type) {
3964	DPRINTF(("%s: can't find %s rate %lu\n",do {} while (0 )
3965	__func__, cmode, par->sample_rate))do {} while (0 );
3966	return EINVAL22;
3967	}
3968	}
3969	par->bps = AUDIO_BPS(par->precision)(par->precision) <= 8 ? 1 : ((par->precision) <= 16 ? 2 : 4);
3970	par->msb = 1;
3971
3972	return (0);
3973	}
3974
3975	int
3976	azalia_set_params(void v, int smode, int umode, audio_params_t p,
3977	audio_params_t *r)
3978	{
3979	azalia_t *az;
3980	codec_t *codec;
3981	int ret;
3982
3983	az = v;
3984	codec = &az->codecs[az->codecno];
3985	if (codec->nformats == 0) {
3986	DPRINTF(("%s: codec has no formats\n", __func__))do {} while (0 );
3987	return EINVAL22;
3988	}
3989
3990	if (smode & AUMODE_RECORD0x02 && r != NULL((void *)0)) {
3991	ret = azalia_set_params_sub(codec, AUMODE_RECORD0x02, r);
3992	if (ret)
3993	return (ret);
3994	}
3995
3996	if (smode & AUMODE_PLAY0x01 && p != NULL((void *)0)) {
3997	ret = azalia_set_params_sub(codec, AUMODE_PLAY0x01, p);
3998	if (ret)
3999	return (ret);
4000	}
4001
4002	return (0);
4003	}
4004
4005	unsigned int
4006	azalia_set_blksz(void *v, int mode,
4007	struct audio_params p, struct audio_params r, unsigned int blksz)
4008	{
4009	int mult;
4010
4011	/* must be multiple of 128 bytes */
4012	mult = audio_blksz_bytes(mode, p, r, 128);
4013
4014	blksz -= blksz % mult;
4015	if (blksz == 0)
4016	blksz = mult;
4017
4018	return blksz;
4019	}
4020
4021	unsigned int
4022	azalia_set_nblks(void *v, int mode,
4023	struct audio_params *params, unsigned int blksz, unsigned int nblks)
4024	{
4025	/* number of blocks must be <= HDA_BDL_MAX */
4026	if (nblks > HDA_BDL_MAX256)
4027	nblks = HDA_BDL_MAX256;
4028
4029	return nblks;
4030	}
4031
4032	int
4033	azalia_halt_output(void *v)
4034	{
4035	azalia_t *az;
4036
4037	DPRINTFN(1, ("%s\n", __func__))do {} while (0 );
4038	az = v;
4039	return azalia_stream_halt(&az->pstream);
4040	}
4041
4042	int
4043	azalia_halt_input(void *v)
4044	{
4045	azalia_t *az;
4046
4047	DPRINTFN(1, ("%s\n", __func__))do {} while (0 );
4048	az = v;
4049	return azalia_stream_halt(&az->rstream);
4050	}
4051
4052	int
4053	azalia_set_port(void v, mixer_ctrl_t mc)
4054	{
4055	azalia_t *az;
4056	codec_t *co;
4057	const mixer_item_t *m;
4058
4059	az = v;
4060	co = &az->codecs[az->codecno];
4061	if (mc->dev < 0 \|\| mc->dev >= co->nmixers)
4062	return EINVAL22;
4063
4064	m = &co->mixers[mc->dev];
4065	if (mc->type != m->devinfo.type)
4066	return EINVAL22;
4067
4068	return azalia_mixer_set(co, m->nid, m->target, mc);
4069	}
4070
4071	int
4072	azalia_get_port(void v, mixer_ctrl_t mc)
4073	{
4074	azalia_t *az;
4075	codec_t *co;
4076	const mixer_item_t *m;
4077
4078	az = v;
4079	co = &az->codecs[az->codecno];
4080	if (mc->dev < 0 \|\| mc->dev >= co->nmixers)
4081	return EINVAL22;
4082
4083	m = &co->mixers[mc->dev];
4084	mc->type = m->devinfo.type;
4085
4086	return azalia_mixer_get(co, m->nid, m->target, mc);
4087	}
4088
4089	int
4090	azalia_query_devinfo(void v, mixer_devinfo_t mdev)
4091	{
4092	azalia_t *az;
4093	const codec_t *co;
4094
4095	az = v;
4096	co = &az->codecs[az->codecno];
4097	if (mdev->index < 0 \|\| mdev->index >= co->nmixers)
4098	return ENXIO6;
4099	*mdev = co->mixers[mdev->index].devinfo;
4100	return 0;
4101	}
4102
4103	void *
4104	azalia_allocm(void *v, int dir, size_t size, int pool, int flags)
4105	{
4106	azalia_t *az;
4107	stream_t *stream;
4108	int err;
4109
4110	az = v;
4111	stream = dir == AUMODE_PLAY0x01 ? &az->pstream : &az->rstream;
4112	err = azalia_alloc_dmamem(az, size, 128, &stream->buffer);
4113	if (err) {
4114	printf("%s: allocm failed\n", az->dev.dv_xname);
4115	return NULL((void *)0);
4116	}
4117	return stream->buffer.addr;
4118	}
4119
4120	void
4121	azalia_freem(void v, void addr, int pool)
4122	{
4123	azalia_t *az;
4124	stream_t *stream;
4125
4126	az = v;
4127	if (addr == az->pstream.buffer.addr) {
4128	stream = &az->pstream;
4129	} else if (addr == az->rstream.buffer.addr) {
4130	stream = &az->rstream;
4131	} else {
4132	return;
4133	}
4134	azalia_free_dmamem(az, &stream->buffer);
4135	}
4136
4137	size_t
4138	azalia_round_buffersize(void *v, int dir, size_t size)
4139	{
4140	size &= ~0x7f; /* must be multiple of 128 */
4141	if (size <= 0)
4142	size = 128;
4143	return size;
4144	}
4145
4146	int
4147	azalia_trigger_output(void v, void start, void *end, int blk,
4148	void (intr)(void ), void arg, audio_params_t param)
4149	{
4150	azalia_t *az;
4151	int err;
4152	uint16_t fmt;
4153
4154	az = v;
4155
4156	if (az->codecs[az->codecno].dacs.ngroups == 0) {
4157	DPRINTF(("%s: can't play without a DAC\n", __func__))do {} while (0 );
4158	return ENXIO6;
4159	}
4160
4161	err = azalia_params2fmt(param, &fmt);
4162	if (err)
4163	return(EINVAL22);
4164
4165	az->pstream.bufsize = (caddr_t)end - (caddr_t)start;
4166	az->pstream.blk = blk;
4167	az->pstream.fmt = fmt;
4168	az->pstream.intr = intr;
4169	az->pstream.intr_arg = arg;
4170	az->pstream.swpos = 0;
4171
4172	return azalia_stream_start(&az->pstream);
4173	}
4174
4175	int
4176	azalia_trigger_input(void v, void start, void *end, int blk,
4177	void (intr)(void ), void arg, audio_params_t param)
4178	{
4179	azalia_t *az;
4180	int err;
4181	uint16_t fmt;
4182
4183	DPRINTFN(1, ("%s: this=%p start=%p end=%p blk=%d {enc=%u %uch %ubit %luHz}\n",do {} while (0 )
4184	__func__, v, start, end, blk, param->encoding, param->channels,do {} while (0 )
4185	param->precision, param->sample_rate))do {} while (0 );
4186
4187	az = v;
4188
4189	if (az->codecs[az->codecno].adcs.ngroups == 0) {
4190	DPRINTF(("%s: can't record without an ADC\n", __func__))do {} while (0 );
4191	return ENXIO6;
4192	}
4193
4194	err = azalia_params2fmt(param, &fmt);
4195	if (err)
4196	return(EINVAL22);
4197
4198	az->rstream.bufsize = (caddr_t)end - (caddr_t)start;
4199	az->rstream.blk = blk;
4200	az->rstream.fmt = fmt;
4201	az->rstream.intr = intr;
4202	az->rstream.intr_arg = arg;
4203	az->rstream.swpos = 0;
4204
4205	return azalia_stream_start(&az->rstream);
4206	}
4207
4208	/* --------------------------------
4209	* helpers for MI audio functions
4210	* -------------------------------- */
4211	int
4212	azalia_params2fmt(const audio_params_t param, uint16_t fmt)
4213	{
4214	uint16_t ret;
4215
4216	ret = 0;
4217	if (param->channels > HDA_MAX_CHANNELS16) {
4218	printf("%s: too many channels: %u\n", __func__,
4219	param->channels);
4220	return EINVAL22;
4221	}
4222
4223	DPRINTFN(1, ("%s: prec=%d, chan=%d, rate=%ld\n", __func__,do {} while (0 )
4224	param->precision, param->channels, param->sample_rate))do {} while (0 );
4225
4226	/* XXX: can channels be >2 ? */
4227	ret \|= param->channels - 1;
4228
4229	switch (param->precision) {
4230	case 8:
4231	ret \|= HDA_SD_FMT_BITS_8_160x0000;
4232	break;
4233	case 16:
4234	ret \|= HDA_SD_FMT_BITS_16_160x0010;
4235	break;
4236	case 20:
4237	ret \|= HDA_SD_FMT_BITS_20_320x0020;
4238	break;
4239	case 24:
4240	ret \|= HDA_SD_FMT_BITS_24_320x0030;
4241	break;
4242	case 32:
4243	ret \|= HDA_SD_FMT_BITS_32_320x0040;
4244	break;
4245	}
4246
4247	switch (param->sample_rate) {
4248	default:
4249	case 384000:
4250	printf("%s: invalid sample_rate: %lu\n", __func__,
4251	param->sample_rate);
4252	return EINVAL22;
4253	case 192000:
4254	ret \|= HDA_SD_FMT_BASE_480x0000 \| HDA_SD_FMT_MULT_X40x1800 \| HDA_SD_FMT_DIV_BY10x0000;
4255	break;
4256	case 176400:
4257	ret \|= HDA_SD_FMT_BASE_440x4000 \| HDA_SD_FMT_MULT_X40x1800 \| HDA_SD_FMT_DIV_BY10x0000;
4258	break;
4259	case 96000:
4260	ret \|= HDA_SD_FMT_BASE_480x0000 \| HDA_SD_FMT_MULT_X20x0800 \| HDA_SD_FMT_DIV_BY10x0000;
4261	break;
4262	case 88200:
4263	ret \|= HDA_SD_FMT_BASE_440x4000 \| HDA_SD_FMT_MULT_X20x0800 \| HDA_SD_FMT_DIV_BY10x0000;
4264	break;
4265	case 48000:
4266	ret \|= HDA_SD_FMT_BASE_480x0000 \| HDA_SD_FMT_MULT_X10x0000 \| HDA_SD_FMT_DIV_BY10x0000;
4267	break;
4268	case 44100:
4269	ret \|= HDA_SD_FMT_BASE_440x4000 \| HDA_SD_FMT_MULT_X10x0000 \| HDA_SD_FMT_DIV_BY10x0000;
4270	break;
4271	case 32000:
4272	ret \|= HDA_SD_FMT_BASE_480x0000 \| HDA_SD_FMT_MULT_X20x0800 \| HDA_SD_FMT_DIV_BY30x0200;
4273	break;
4274	case 22050:
4275	ret \|= HDA_SD_FMT_BASE_440x4000 \| HDA_SD_FMT_MULT_X10x0000 \| HDA_SD_FMT_DIV_BY20x0100;
4276	break;
4277	case 16000:
4278	ret \|= HDA_SD_FMT_BASE_480x0000 \| HDA_SD_FMT_MULT_X10x0000 \| HDA_SD_FMT_DIV_BY30x0200;
4279	break;
4280	case 11025:
4281	ret \|= HDA_SD_FMT_BASE_440x4000 \| HDA_SD_FMT_MULT_X10x0000 \| HDA_SD_FMT_DIV_BY40x0300;
4282	break;
4283	case 8000:
4284	ret \|= HDA_SD_FMT_BASE_480x0000 \| HDA_SD_FMT_MULT_X10x0000 \| HDA_SD_FMT_DIV_BY60x0500;
4285	break;
4286	}
4287	*fmt = ret;
4288	return 0;
4289	}