1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
23 */
24
25 #include <sys/audio/audio_driver.h>
26 #include <sys/note.h>
27 #include <sys/beep.h>
28 #include <sys/pci.h>
29 #include "audiohd.h"
30
31 #define DRVNAME "audiohd"
32
33 /*
34 * Module linkage routines for the kernel
35 */
36 static int audiohd_attach(dev_info_t *, ddi_attach_cmd_t);
37 static int audiohd_detach(dev_info_t *, ddi_detach_cmd_t);
38 static int audiohd_quiesce(dev_info_t *);
39 static int audiohd_resume(audiohd_state_t *);
40 static int audiohd_suspend(audiohd_state_t *);
41
42 /*
43 * Local routines
44 */
45 static int audiohd_init_state(audiohd_state_t *, dev_info_t *);
46 static int audiohd_init_pci(audiohd_state_t *, ddi_device_acc_attr_t *);
47 static void audiohd_fini_pci(audiohd_state_t *);
48 static int audiohd_reset_controller(audiohd_state_t *);
49 static int audiohd_init_controller(audiohd_state_t *);
50 static void audiohd_fini_controller(audiohd_state_t *);
51 static void audiohd_stop_dma(audiohd_state_t *);
52 static void audiohd_disable_intr(audiohd_state_t *);
53 static int audiohd_create_codec(audiohd_state_t *);
54 static void audiohd_build_path(audiohd_state_t *);
55 static void audiohd_destroy_codec(audiohd_state_t *);
56 static int audiohd_alloc_dma_mem(audiohd_state_t *, audiohd_dma_t *,
57 size_t, ddi_dma_attr_t *, uint_t);
58 static void audiohd_finish_output_path(hda_codec_t *);
59 static uint32_t audioha_codec_verb_get(void *, uint8_t,
60 uint8_t, uint16_t, uint8_t);
61 static uint32_t audioha_codec_4bit_verb_get(void *, uint8_t,
62 uint8_t, uint16_t, uint16_t);
63 static int audiohd_reinit_hda(audiohd_state_t *);
64 static int audiohd_response_from_codec(audiohd_state_t *,
65 uint32_t *, uint32_t *);
66 static void audiohd_restore_codec_gpio(audiohd_state_t *);
67 static void audiohd_change_speaker_state(audiohd_state_t *, int);
68 static int audiohd_allocate_port(audiohd_state_t *);
69 static void audiohd_free_port(audiohd_state_t *);
70 static void audiohd_restore_path(audiohd_state_t *);
71 static void audiohd_create_controls(audiohd_state_t *);
72 static void audiohd_get_channels(audiohd_state_t *);
73 static void audiohd_init_path(audiohd_state_t *);
74 static void audiohd_del_controls(audiohd_state_t *);
75 static void audiohd_destroy(audiohd_state_t *);
76 static void audiohd_beep_on(void *);
77 static void audiohd_beep_off(void *);
78 static void audiohd_beep_freq(void *, int);
79 static wid_t audiohd_find_beep(hda_codec_t *, wid_t, int);
80 static void audiohd_build_beep_path(hda_codec_t *);
81 static void audiohd_build_beep_amp(hda_codec_t *);
82 static void audiohd_finish_beep_path(hda_codec_t *);
83 static void audiohd_do_set_beep_volume(audiohd_state_t *,
84 audiohd_path_t *, uint64_t);
85 static void audiohd_set_beep_volume(audiohd_state_t *);
86 static int audiohd_set_beep(void *, uint64_t);
87 static void audiohd_pin_sense(audiohd_state_t *, uint32_t, uint32_t);
88
89 static int audiohd_beep;
90 static int audiohd_beep_divider;
91 static int audiohd_beep_vol = 1;
92
93 /* Warlock annotation */
94 _NOTE(SCHEME_PROTECTS_DATA("unshared data", audiohd_beep))
95 _NOTE(SCHEME_PROTECTS_DATA("unshared data", audiohd_beep_divider))
96 _NOTE(SCHEME_PROTECTS_DATA("unshared data", audiohd_beep_vol))
97
98 static ddi_device_acc_attr_t hda_dev_accattr = {
99 DDI_DEVICE_ATTR_V0,
100 DDI_STRUCTURE_LE_ACC,
101 DDI_STRICTORDER_ACC
102 };
103
104 static const char *audiohd_dtypes[] = {
105 AUDIO_PORT_LINEOUT,
106 AUDIO_PORT_SPEAKER,
107 AUDIO_PORT_HEADPHONES,
108 AUDIO_PORT_CD,
109 AUDIO_PORT_SPDIFOUT,
110 AUDIO_PORT_DIGOUT,
111 AUDIO_PORT_MODEM,
112 AUDIO_PORT_HANDSET,
113 AUDIO_PORT_LINEIN,
114 AUDIO_PORT_AUX1IN,
115 AUDIO_PORT_MIC,
116 AUDIO_PORT_PHONE,
117 AUDIO_PORT_SPDIFIN,
118 AUDIO_PORT_DIGIN,
119 AUDIO_PORT_STEREOMIX,
120 AUDIO_PORT_NONE, /* reserved port, don't use */
121 AUDIO_PORT_OTHER,
122 NULL,
123 };
124
125 static audiohd_codec_info_t audiohd_codecs[] = {
126 {0x1002aa01, "ATI R600 HDMI", 0x0},
127 {0x10134206, "Cirrus CS4206", 0x0},
128 {0x10de0002, "nVidia MCP78 HDMI", 0x0},
129 {0x10de0003, "nVidia MCP78 HDMI", 0x0},
130 {0x10de0006, "nVidia MCP78 HDMI", 0x0},
131 {0x10de0007, "nVidia MCP7A HDMI", 0x0},
132 {0x10ec0260, "Realtek ALC260", (NO_GPIO)},
133 {0x10ec0262, "Realtek ALC262", (NO_GPIO | EN_PIN_BEEP)},
134 {0x10ec0268, "Realtek ALC268", 0x0},
135 {0x10ec0272, "Realtek ALC272", 0x0},
136 {0x10ec0662, "Realtek ALC662", 0x0},
137 {0x10ec0663, "Realtek ALC663", 0x0},
138 {0x10ec0861, "Realtek ALC861", 0x0},
139 {0x10ec0862, "Realtek ALC862", 0x0},
140 {0x10ec0880, "Realtek ALC880", 0x0},
141 {0x10ec0882, "Realtek ALC882", 0x0},
142 {0x10ec0883, "Realtek ALC883", 0x0},
143 {0x10ec0885, "Realtek ALC885", 0x0},
144 {0x10ec0888, "Realtek ALC888", (NO_SPDIF)},
145 {0x111d7603, "Integrated Devices 92HD75B3X5", (NO_MIXER)},
146 {0x111d7608, "Integrated Devices 92HD75B2X5", (NO_MIXER)},
147 {0x111d76b2, "Integrated Devices 92HD71B7X", (NO_MIXER)},
148 {0x11d4194a, "Analog Devices AD1984A", 0x0},
149 {0x11d41981, "Analog Devices AD1981", (NO_MIXER)},
150 {0x11d41983, "Analog Devices AD1983", 0x0},
151 {0x11d41984, "Analog Devices AD1984", 0x0},
152 {0x11d41986, "Analog Devices AD1986A", 0x0},
153 {0x11d41988, "Analog Devices AD1988A", 0x0},
154 {0x11d4198b, "Analog Devices AD1988B", 0x0},
155 {0x13f69880, "CMedia CMI19880", 0x0},
156 {0x14f15045, "Conexant CX20549", (NO_MIXER)},
157 {0x14f15051, "Conexant CX20561", 0x0},
158 {0x434d4980, "CMedia CMI19880", 0x0},
159 {0x80862802, "Intel HDMI", 0x0},
160 {0x83847610, "Sigmatel STAC9230XN", 0x0},
161 {0x83847611, "Sigmatel STAC9230DN", 0x0},
162 {0x83847612, "Sigmatel STAC9230XT", 0x0},
163 {0x83847613, "Sigmatel STAC9230DT", 0x0},
164 {0x83847614, "Sigmatel STAC9229X", 0x0},
165 {0x83847615, "Sigmatel STAC9229D", 0x0},
166 {0x83847616, "Sigmatel STAC9228X", 0x0},
167 {0x83847617, "Sigmatel STAC9228D", 0x0},
168 {0x83847618, "Sigmatel STAC9227X", 0x0},
169 {0x83847619, "Sigmatel STAC9227D", 0x0},
170 {0x83847620, "Sigmatel STAC9274", 0x0},
171 {0x83847621, "Sigmatel STAC9274D", 0x0},
172 {0x83847622, "Sigmatel STAC9273X", 0x0},
173 {0x83847623, "Sigmatel STAC9273D", 0x0},
174 {0x83847624, "Sigmatel STAC9272X", 0x0},
175 {0x83847625, "Sigmatel STAC9272D", 0x0},
176 {0x83847626, "Sigmatel STAC9271X", 0x0},
177 {0x83847627, "Sigmatel STAC9271D", 0x0},
178 {0x83847628, "Sigmatel STAC9274X5NH", 0x0},
179 {0x83847629, "Sigmatel STAC9274D5NH", 0x0},
180 {0x83847662, "Sigmatel STAC9872AK", 0x0},
181 {0x83847664, "Sigmatel STAC9872K", 0x0},
182 {0x83847680, "Sigmatel STAC9221A1", 0x0},
183 {0x83847680, "Sigmatel STAC9221A1", 0x0},
184 {0x83847681, "Sigmatel STAC9220D", 0x0},
185 {0x83847682, "Sigmatel STAC9221", 0x0},
186 {0x83847683, "Sigmatel STAC9221D", 0x0},
187 {0x83847690, "Sigmatel STAC9200", 0x0},
188 {0x838476a0, "Sigmatel STAC9205", 0x0},
189 {0x838476a1, "Sigmatel STAC9205D", 0x0},
190 {0x838476a2, "Sigmatel STAC9204", 0x0},
191 {0x838476a3, "Sigmatel STAC9204D", 0x0},
192 {0x838476a4, "Sigmatel STAC9255", 0x0},
193 {0x838476a5, "Sigmatel STAC9255D", 0x0},
194 {0x838476a6, "Sigmatel STAC9254", 0x0},
195 {0x838476a7, "Sigmatel STAC9254D", 0x0},
196 {0x83847880, "Sigmatel STAC9220A1", 0x0},
197 {0x83847882, "Sigmatel STAC9220A2", 0x0},
198 {0x0, "Unknown 0x00000000", 0x0},
199 };
200
201 static void
202 audiohd_set_chipset_info(audiohd_state_t *statep)
203 {
204 uint32_t devid;
205 const char *name;
206 const char *vers;
207
208 devid = pci_config_get16(statep->hda_pci_handle, PCI_CONF_VENID);
209 devid <<= 16;
210 devid |= pci_config_get16(statep->hda_pci_handle, PCI_CONF_DEVID);
211 statep->devid = devid;
212
213 name = AUDIOHD_DEV_CONFIG;
214 vers = AUDIOHD_DEV_VERSION;
215
216 switch (devid) {
217 case 0x1002437b:
218 name = "ATI HD Audio";
219 vers = "SB450";
220 break;
221 case 0x10024383:
222 name = "ATI HD Audio";
223 vers = "SB600";
224 break;
225 case 0x10029442:
226 name = "ATI HD Audio";
227 vers = "Radeon HD 4850";
228 break;
229 case 0x1002aa30:
230 name = "ATI HD Audio";
231 vers = "HD 48x0";
232 break;
233 case 0x1002aa38:
234 name = "ATI HD Audio";
235 vers = "Radeon HD 4670";
236 break;
237 case 0x10de026c:
238 name = "NVIDIA HD Audio";
239 vers = "MCP51";
240 break;
241 case 0x10de0371:
242 name = "NVIDIA HD Audio";
243 vers = "MCP55";
244 break;
245 case 0x10de03e4:
246 name = "NVIDIA HD Audio";
247 vers = "MCP61";
248 break;
249 case 0x10de03f0:
250 name = "NVIDIA HD Audio";
251 vers = "MCP61A";
252 break;
253 case 0x10de044a:
254 name = "NVIDIA HD Audio";
255 vers = "MCP65";
256 break;
257 case 0x10de055c:
258 name = "NVIDIA HD Audio";
259 vers = "MCP67";
260 break;
261 case 0x10de0774:
262 name = "NVIDIA HD Audio";
263 vers = "MCP78S";
264 break;
265 case 0x10de0ac0:
266 name = "NVIDIA HD Audio";
267 vers = "MCP79";
268 break;
269 case 0x11063288:
270 name = "VIA HD Audio";
271 vers = "HDA";
272 break;
273 case 0x80862668:
274 name = "Intel HD Audio";
275 vers = "ICH6";
276 break;
277 case 0x808627d8:
278 name = "Intel HD Audio";
279 vers = "ICH7";
280 break;
281 case 0x8086284b:
282 name = "Intel HD Audio";
283 vers = "ICH8";
284 break;
285 case 0x8086293e:
286 name = "Intel HD Audio";
287 vers = "ICH9";
288 break;
289 case 0x80863a3e:
290 name = "Intel HD Audio";
291 vers = "ICH10";
292 break;
293 case 0x80863b56:
294 name = "Intel HD Audio";
295 vers = "PCH";
296 break;
297 }
298 /* set device information */
299 audio_dev_set_description(statep->adev, name);
300 audio_dev_set_version(statep->adev, vers);
301 }
302
303 static int
304 audiohd_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
305 {
306 audiohd_state_t *statep;
307 int instance;
308
309 instance = ddi_get_instance(dip);
310 switch (cmd) {
311 case DDI_ATTACH:
312 break;
313
314 case DDI_RESUME:
315 statep = ddi_get_driver_private(dip);
316 ASSERT(statep != NULL);
317 return (audiohd_resume(statep));
318
319 default:
320 return (DDI_FAILURE);
321 }
322
323 /* allocate the soft state structure */
324 statep = kmem_zalloc(sizeof (*statep), KM_SLEEP);
325 ddi_set_driver_private(dip, statep);
326
327 mutex_init(&statep->hda_mutex, NULL, MUTEX_DRIVER, 0);
328 mutex_enter(&statep->hda_mutex);
329
330 /* interrupt cookie and initialize mutex */
331 if (audiohd_init_state(statep, dip) != DDI_SUCCESS) {
332 audio_dev_warn(NULL, "audiohd_init_state failed");
333 goto error;
334 }
335
336 /* Set PCI command register to enable bus master and memeory I/O */
337 if (audiohd_init_pci(statep, &hda_dev_accattr) != DDI_SUCCESS) {
338 audio_dev_warn(statep->adev,
339 "couldn't init pci regs");
340 goto error;
341 }
342
343 audiohd_set_chipset_info(statep);
344
345 if (audiohd_init_controller(statep) != DDI_SUCCESS) {
346 audio_dev_warn(statep->adev,
347 "couldn't init controller");
348 goto error;
349 }
350
351 if (audiohd_create_codec(statep) != DDI_SUCCESS) {
352 audio_dev_warn(statep->adev,
353 "couldn't create codec");
354 goto error;
355 }
356
357 audiohd_build_path(statep);
358
359 audiohd_get_channels(statep);
360 if (audiohd_allocate_port(statep) != DDI_SUCCESS) {
361 audio_dev_warn(statep->adev, "allocate port failure");
362 goto error;
363 }
364 audiohd_init_path(statep);
365 /* set up kernel statistics */
366 if ((statep->hda_ksp = kstat_create(DRVNAME, instance,
367 DRVNAME, "controller", KSTAT_TYPE_INTR, 1,
368 KSTAT_FLAG_PERSISTENT)) != NULL) {
369 kstat_install(statep->hda_ksp);
370 }
371
372 /* disable interrupts and clear interrupt status */
373 audiohd_disable_intr(statep);
374
375 /*
376 * Register audio controls.
377 */
378 audiohd_create_controls(statep);
379
380 if (audio_dev_register(statep->adev) != DDI_SUCCESS) {
381 audio_dev_warn(statep->adev,
382 "unable to register with framework");
383 goto error;
384 }
385 ddi_report_dev(dip);
386
387 mutex_exit(&statep->hda_mutex);
388 return (DDI_SUCCESS);
389 error:
390 mutex_exit(&statep->hda_mutex);
391 audiohd_destroy(statep);
392 return (DDI_FAILURE);
393 }
394
395 static int
396 audiohd_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
397 {
398 audiohd_state_t *statep;
399
400 statep = ddi_get_driver_private(dip);
401 ASSERT(statep != NULL);
402
403 switch (cmd) {
404 case DDI_DETACH:
405 break;
406
407 case DDI_SUSPEND:
408 return (audiohd_suspend(statep));
409
410 default:
411 return (DDI_FAILURE);
412 }
413 if (audio_dev_unregister(statep->adev) != DDI_SUCCESS)
414 return (DDI_FAILURE);
415
416 if (audiohd_beep)
417 (void) beep_fini();
418 audiohd_destroy(statep);
419 return (DDI_SUCCESS);
420 }
421
422 static struct dev_ops audiohd_dev_ops = {
423 DEVO_REV, /* rev */
424 0, /* refcnt */
425 NULL, /* getinfo */
426 nulldev, /* identify */
427 nulldev, /* probe */
428 audiohd_attach, /* attach */
429 audiohd_detach, /* detach */
430 nodev, /* reset */
431 NULL, /* cb_ops */
432 NULL, /* bus_ops */
433 NULL, /* power */
434 audiohd_quiesce, /* quiesce */
435 };
436
437 static struct modldrv audiohd_modldrv = {
438 &mod_driverops, /* drv_modops */
439 "AudioHD", /* linkinfo */
440 &audiohd_dev_ops, /* dev_ops */
441 };
442
443 static struct modlinkage modlinkage = {
444 MODREV_1,
445 { &audiohd_modldrv, NULL }
446 };
447
448 int
449 _init(void)
450 {
451 int rv;
452
453 audio_init_ops(&audiohd_dev_ops, DRVNAME);
454 if ((rv = mod_install(&modlinkage)) != 0) {
455 audio_fini_ops(&audiohd_dev_ops);
456 }
457 return (rv);
458 }
459
460 int
461 _fini(void)
462 {
463 int rv;
464
465 if ((rv = mod_remove(&modlinkage)) == 0) {
466 audio_fini_ops(&audiohd_dev_ops);
467 }
468 return (rv);
469 }
470
471 int
472 _info(struct modinfo *modinfop)
473 {
474 return (mod_info(&modlinkage, modinfop));
475 }
476
477 /*
478 * Audio routines
479 */
480
481 static int
482 audiohd_engine_format(void *arg)
483 {
484 audiohd_port_t *port = arg;
485 audiohd_state_t *statep = port->statep;
486
487 switch (statep->sample_bit_depth) {
488 case AUDIOHD_BIT_DEPTH24:
489 return (AUDIO_FORMAT_S32_LE);
490 case AUDIOHD_BIT_DEPTH16:
491 default:
492 return (AUDIO_FORMAT_S16_LE);
493 }
494 }
495
496 static int
497 audiohd_engine_channels(void *arg)
498 {
499 audiohd_port_t *port = arg;
500
501 return (port->nchan);
502 }
503
504 static int
505 audiohd_engine_rate(void *arg)
506 {
507 audiohd_port_t *port = arg;
508 audiohd_state_t *statep = port->statep;
509
510 return (statep->sample_rate);
511 }
512 static void
513 audiohd_free_path(audiohd_state_t *statep)
514 {
515 audiohd_path_t *path;
516 int i;
517
518 for (i = 0; i < statep->pathnum; i++) {
519 if (statep->path[i]) {
520 path = statep->path[i];
521 kmem_free(path, sizeof (audiohd_path_t));
522 }
523 }
524 }
525 static void
526 audiohd_destroy(audiohd_state_t *statep)
527 {
528 mutex_enter(&statep->hda_mutex);
529 audiohd_stop_dma(statep);
530 if (statep->hda_ksp)
531 kstat_delete(statep->hda_ksp);
532 audiohd_free_port(statep);
533 audiohd_free_path(statep);
534 audiohd_destroy_codec(statep);
535 audiohd_del_controls(statep);
536 audiohd_fini_controller(statep);
537 audiohd_fini_pci(statep);
538 mutex_exit(&statep->hda_mutex);
539 mutex_destroy(&statep->hda_mutex);
540 if (statep->adev)
541 audio_dev_free(statep->adev);
542 kmem_free(statep, sizeof (*statep));
543 }
544 /*
545 * get the max channels the hardware supported
546 */
547 static void
548 audiohd_get_channels(audiohd_state_t *statep)
549 {
550 int i;
551 uint8_t maxp, assoc;
552
553 maxp = 2;
554 for (i = 0; i < AUDIOHD_MAX_ASSOC; i++) {
555 if (maxp < statep->chann[i]) {
556 maxp = statep->chann[i];
557 assoc = i;
558 }
559 }
560 statep->pchan = maxp;
561 statep->assoc = assoc;
562 /* for record, support stereo so far */
563 statep->rchan = 2;
564 }
565 static void
566 audiohd_init_play_path(audiohd_path_t *path)
567 {
568 int i;
569 uint32_t ctrl;
570 uint8_t ctrl8;
571 uint8_t nchann;
572 audiohd_widget_t *widget;
573 audiohd_pin_t *pin;
574 wid_t wid;
575 audiohd_pin_color_t color;
576
577 audiohd_state_t *statep = path->statep;
578 hda_codec_t *codec = path->codec;
579
580 /* enable SPDIF output */
581 for (i = 0; i < path->pin_nums; i++) {
582 wid = path->pin_wid[i];
583 widget = codec->widget[wid];
584 pin = (audiohd_pin_t *)widget->priv;
585 if (pin->device == DTYPE_SPDIF_OUT) {
586 ctrl = audioha_codec_verb_get(
587 statep,
588 codec->index,
589 path->adda_wid,
590 AUDIOHDC_VERB_GET_SPDIF_CTL,
591 0);
592 ctrl |= AUDIOHD_SPDIF_ON;
593 ctrl8 = ctrl &
594 AUDIOHD_SPDIF_MASK;
595 (void) audioha_codec_verb_get(
596 statep,
597 codec->index,
598 path->adda_wid,
599 AUDIOHDC_VERB_SET_SPDIF_LCL,
600 ctrl8);
601 /*
602 * We find that on intel ICH10 chipset with codec
603 * ALC888, audio is scratchy if we set the tag on the
604 * SPDIF path. So we just return here without setting
605 * the tag for the path as a workaround.
606 */
607 if (codec->codec_info->flags & NO_SPDIF)
608 return;
609 }
610 }
611 wid = path->pin_wid[0];
612 widget = codec->widget[wid];
613 pin = (audiohd_pin_t *)widget->priv;
614
615 /* two channels supported */
616 if (pin->device == DTYPE_SPEAKER ||
617 pin->device == DTYPE_HP_OUT ||
618 pin->assoc != statep->assoc) {
619 (void) audioha_codec_verb_get(
620 statep,
621 codec->index,
622 path->adda_wid,
623 AUDIOHDC_VERB_SET_STREAM_CHANN,
624 statep->port[PORT_DAC]->index <<
625 AUDIOHD_PLAY_TAG_OFF);
626 (void) audioha_codec_4bit_verb_get(
627 statep,
628 codec->index,
629 path->adda_wid,
630 AUDIOHDC_VERB_SET_CONV_FMT,
631 statep->port[PORT_DAC]->format << 4 |
632 statep->pchan - 1);
633 /* multichannel supported */
634 } else {
635 color = (pin->config >> AUDIOHD_PIN_CLR_OFF) &
636 AUDIOHD_PIN_CLR_MASK;
637 switch (color) {
638 case AUDIOHD_PIN_BLACK:
639 nchann = statep->pchan - 2;
640 break;
641 case AUDIOHD_PIN_ORANGE:
642 nchann = 2;
643 break;
644 case AUDIOHD_PIN_GREY:
645 nchann = 4;
646 break;
647 case AUDIOHD_PIN_GREEN:
648 nchann = 0;
649 break;
650 default:
651 nchann = 0;
652 break;
653 }
654 (void) audioha_codec_verb_get(statep,
655 codec->index,
656 path->adda_wid,
657 AUDIOHDC_VERB_SET_STREAM_CHANN,
658 statep->port[PORT_DAC]->index <<
659 AUDIOHD_PLAY_TAG_OFF |
660 nchann);
661 (void) audioha_codec_4bit_verb_get(
662 statep,
663 codec->index,
664 path->adda_wid,
665 AUDIOHDC_VERB_SET_CONV_FMT,
666 statep->port[PORT_DAC]->format << 4 |
667 statep->pchan - 1);
668 }
669 }
670 static void
671 audiohd_init_record_path(audiohd_path_t *path)
672 {
673 audiohd_state_t *statep = path->statep;
674 hda_codec_t *codec = path->codec;
675 int i;
676 wid_t wid;
677 audiohd_pin_t *pin;
678 audiohd_widget_t *widget;
679
680 for (i = 0; i < path->pin_nums; i++) {
681 wid = path->pin_wid[i];
682 widget = codec->widget[wid];
683 pin = (audiohd_pin_t *)widget->priv;
684 /*
685 * Since there is no SPDIF input device available for test,
686 * we will use this code in the future to support SPDIF input
687 */
688 #if 0
689 if (pin->device == DTYPE_SPDIF_IN) {
690 ctrl = audioha_codec_verb_get(
691 statep,
692 codec->index,
693 path->adda_wid,
694 AUDIOHDC_VERB_GET_SPDIF_CTL,
695 0);
696 ctrl |= AUDIOHD_SPDIF_ON;
697 ctrl8 = ctrl &
698 AUDIOHD_SPDIF_MASK;
699 (void) audioha_codec_verb_get(
700 statep,
701 codec->index,
702 path->adda_wid,
703 AUDIOHDC_VERB_SET_SPDIF_LCL,
704 ctrl8);
705 statep->inmask |= (1U << DTYPE_SPDIF_IN);
706 }
707 #endif
708 if (pin->device == DTYPE_MIC_IN) {
709 if (((pin->config >>
710 AUDIOHD_PIN_CONTP_OFF) &
711 AUDIOHD_PIN_CONTP_MASK) ==
712 AUDIOHD_PIN_CON_FIXED)
713 statep->port[PORT_ADC]->index = path->tag;
714 }
715 if ((pin->device == DTYPE_LINE_IN) ||
716 (pin->device == DTYPE_CD) ||
717 (pin->device == DTYPE_MIC_IN)) {
718 statep->inmask |= (1U << pin->device);
719 }
720 }
721 (void) audioha_codec_verb_get(statep,
722 codec->index,
723 path->adda_wid,
724 AUDIOHDC_VERB_SET_STREAM_CHANN,
725 path->tag <<
726 AUDIOHD_REC_TAG_OFF);
727 (void) audioha_codec_4bit_verb_get(statep,
728 codec->index,
729 path->adda_wid,
730 AUDIOHDC_VERB_SET_CONV_FMT,
731 statep->port[PORT_ADC]->format << 4 | statep->rchan - 1);
732 }
733
734 static void
735 audiohd_init_path(audiohd_state_t *statep)
736 {
737 int i;
738 audiohd_path_t *path;
739
740 for (i = 0; i < statep->pathnum; i++) {
741 path = statep->path[i];
742 if (!path)
743 continue;
744 switch (path->path_type) {
745 case PLAY:
746 audiohd_init_play_path(path);
747 break;
748 case RECORD:
749 audiohd_init_record_path(path);
750 break;
751 default:
752 break;
753 }
754 }
755 statep->in_port = 0;
756 }
757
758 static int
759 audiohd_reset_port(audiohd_port_t *port)
760 {
761 uint16_t regbase;
762 audiohd_state_t *statep;
763 uint8_t bTmp;
764 int i;
765
766 regbase = port->regoff;
767 statep = port->statep;
768
769 bTmp = AUDIOHD_REG_GET8(regbase + AUDIOHD_SDREG_OFFSET_CTL);
770 /* stop stream */
771 bTmp &= ~AUDIOHD_REG_RIRBSIZE;
772 AUDIOHD_REG_SET8(regbase + AUDIOHD_SDREG_OFFSET_CTL, bTmp);
773
774 /* wait 40us for stream to stop as HD spec */
775 drv_usecwait(40);
776
777 /* reset stream */
778 bTmp |= AUDIOHDR_SD_CTL_SRST;
779 AUDIOHD_REG_SET8(regbase + AUDIOHD_SDREG_OFFSET_CTL, bTmp);
780
781 for (i = 0; i < AUDIOHD_RETRY_TIMES; i++) {
782 /* Empirical testing time, which works well */
783 drv_usecwait(50);
784 bTmp = AUDIOHD_REG_GET8(regbase + AUDIOHD_SDREG_OFFSET_CTL);
785 bTmp &= AUDIOHDR_SD_CTL_SRST;
786 if (bTmp)
787 break;
788 }
789
790 if (!bTmp) {
791 audio_dev_warn(statep->adev, "Failed to reset stream %d",
792 port->index);
793 return (EIO);
794 }
795
796 /* Empirical testing time, which works well */
797 drv_usecwait(300);
798
799 /* exit reset stream */
800 bTmp &= ~AUDIOHDR_SD_CTL_SRST;
801 AUDIOHD_REG_SET8(regbase + AUDIOHD_SDREG_OFFSET_CTL, bTmp);
802
803 for (i = 0; i < AUDIOHD_RETRY_TIMES; i++) {
804 /* Empircal testing time */
805 drv_usecwait(50);
806 bTmp = AUDIOHD_REG_GET8(regbase + AUDIOHD_SDREG_OFFSET_CTL);
807 bTmp &= AUDIOHDR_SD_CTL_SRST;
808 if (!bTmp)
809 break;
810 }
811
812 if (bTmp) {
813 audio_dev_warn(statep->adev,
814 "Failed to exit reset state for"
815 " stream %d, bTmp=0x%02x", port->index, bTmp);
816 return (EIO);
817 }
818
819 AUDIOHD_REG_SET32(regbase + AUDIOHD_SDREG_OFFSET_BDLPL,
820 (uint32_t)port->bdl_paddr);
821 AUDIOHD_REG_SET32(regbase + AUDIOHD_SDREG_OFFSET_BDLPU,
822 (uint32_t)(port->bdl_paddr >> 32));
823 AUDIOHD_REG_SET16(regbase + AUDIOHD_SDREG_OFFSET_LVI,
824 AUDIOHD_BDLE_NUMS - 1);
825 AUDIOHD_REG_SET32(regbase + AUDIOHD_SDREG_OFFSET_CBL, port->bufsize);
826
827 AUDIOHD_REG_SET16(regbase + AUDIOHD_SDREG_OFFSET_FORMAT,
828 port->format << 4 | port->nchan - 1);
829
830 /* clear status */
831 AUDIOHD_REG_SET8(regbase + AUDIOHD_SDREG_OFFSET_STS,
832 AUDIOHDR_SD_STS_BCIS | AUDIOHDR_SD_STS_FIFOE |
833 AUDIOHDR_SD_STS_DESE);
834
835 /* set stream tag */
836 AUDIOHD_REG_SET8(regbase + AUDIOHD_SDREG_OFFSET_CTL +
837 AUDIOHD_PLAY_CTL_OFF,
838 (port->index) << AUDIOHD_PLAY_TAG_OFF);
839
840 return (0);
841 }
842
843 static int
844 audiohd_engine_open(void *arg, int flag, unsigned *nframes, caddr_t *bufp)
845 {
846 audiohd_port_t *port = arg;
847 audiohd_state_t *statep = port->statep;
848
849 _NOTE(ARGUNUSED(flag));
850
851 mutex_enter(&statep->hda_mutex);
852 port->count = 0;
853 port->curpos = 0;
854 *nframes = port->nframes;
855 *bufp = port->samp_kaddr;
856 mutex_exit(&statep->hda_mutex);
857
858 return (0);
859 }
860
861 static int
862 audiohd_engine_start(void *arg)
863 {
864 audiohd_port_t *port = arg;
865 audiohd_state_t *statep = port->statep;
866 int rv;
867
868 mutex_enter(&statep->hda_mutex);
869
870 if ((rv = audiohd_reset_port(port)) != 0) {
871 mutex_exit(&statep->hda_mutex);
872 return (rv);
873 }
874 /* Start DMA */
875 AUDIOHD_REG_SET8(port->regoff + AUDIOHD_SDREG_OFFSET_CTL,
876 AUDIOHDR_SD_CTL_SRUN);
877
878 mutex_exit(&statep->hda_mutex);
879 return (0);
880 }
881
882 static void
883 audiohd_engine_stop(void *arg)
884 {
885 audiohd_port_t *port = arg;
886 audiohd_state_t *statep = port->statep;
887
888 mutex_enter(&statep->hda_mutex);
889 AUDIOHD_REG_SET8(port->regoff + AUDIOHD_SDREG_OFFSET_CTL, 0);
890 mutex_exit(&statep->hda_mutex);
891 }
892
893 static void
894 audiohd_update_port(audiohd_port_t *port)
895 {
896 uint32_t pos, len;
897 audiohd_state_t *statep = port->statep;
898 int i, ret;
899 uint32_t status, resp = 0, respex = 0;
900 uint8_t rirbsts;
901
902 pos = AUDIOHD_REG_GET32(port->regoff + AUDIOHD_SDREG_OFFSET_LPIB);
903 /* Convert the position into a frame count */
904 pos /= (port->nchan * statep->sample_packed_bytes);
905
906 ASSERT(pos <= port->nframes);
907 if (pos >= port->curpos) {
908 len = (pos - port->curpos);
909 } else {
910 len = pos + port->nframes - port->curpos;
911 }
912
913 ASSERT(len <= port->nframes);
914 port->curpos = pos;
915 port->count += len;
916
917 /*
918 * Check unsolicited response from pins, maybe something plugged in or
919 * out of the jack.
920 */
921 status = AUDIOHD_REG_GET32(AUDIOHD_REG_INTSTS);
922 if (status == 0) {
923 /* No pending interrupt we should take care */
924 return;
925 }
926
927 if (status & AUDIOHD_CIS_MASK) {
928 /* Clear the unsolicited response interrupt */
929 rirbsts = AUDIOHD_REG_GET8(AUDIOHD_REG_RIRBSTS);
930 AUDIOHD_REG_SET8(AUDIOHD_REG_RIRBSTS, rirbsts);
931
932 /*
933 * We have to wait and try several times to make sure the
934 * unsolicited response is generated by our pins.
935 * we need to make it work for audiohd spec 0.9, which is
936 * just a draft version and requires more time to wait.
937 */
938 for (i = 0; i < AUDIOHD_TEST_TIMES; i++) {
939 ret = audiohd_response_from_codec(statep, &resp,
940 &respex);
941 if ((ret == DDI_SUCCESS) &&
942 (respex & AUDIOHD_RIRB_UR_MASK)) {
943 /*
944 * A pin may generate more than one ur rirb,
945 * we only need handle one of them, and clear
946 * the other ones
947 */
948 statep->hda_rirb_rp =
949 AUDIOHD_REG_GET16(AUDIOHD_REG_RIRBWP) &
950 AUDIOHD_RIRB_WPMASK;
951 audiohd_pin_sense(statep, resp, respex);
952 break;
953 }
954 }
955 }
956 }
957
958 static uint64_t
959 audiohd_engine_count(void *arg)
960 {
961 audiohd_port_t *port = arg;
962 audiohd_state_t *statep = port->statep;
963 uint64_t val;
964
965 mutex_enter(&statep->hda_mutex);
966 audiohd_update_port(port);
967 val = port->count;
968 mutex_exit(&statep->hda_mutex);
969 return (val);
970 }
971
972 static void
973 audiohd_engine_close(void *arg)
974 {
975 _NOTE(ARGUNUSED(arg));
976 }
977
978 static void
979 audiohd_engine_sync(void *arg, unsigned nframes)
980 {
981 audiohd_port_t *port = arg;
982
983 _NOTE(ARGUNUSED(nframes));
984
985 (void) ddi_dma_sync(port->samp_dmah, 0, 0, port->sync_dir);
986
987 }
988
989 audio_engine_ops_t audiohd_engine_ops = {
990 AUDIO_ENGINE_VERSION, /* version number */
991 audiohd_engine_open,
992 audiohd_engine_close,
993 audiohd_engine_start,
994 audiohd_engine_stop,
995 audiohd_engine_count,
996 audiohd_engine_format,
997 audiohd_engine_channels,
998 audiohd_engine_rate,
999 audiohd_engine_sync,
1000 NULL,
1001 NULL,
1002 NULL
1003 };
1004
1005 static int
1006 audiohd_get_control(void *arg, uint64_t *val)
1007 {
1008 audiohd_ctrl_t *ac = arg;
1009 audiohd_state_t *statep = ac->statep;
1010
1011 mutex_enter(&statep->hda_mutex);
1012 *val = ac->val;
1013 mutex_exit(&statep->hda_mutex);
1014
1015 return (0);
1016 }
1017
1018 static void
1019 audiohd_do_set_pin_volume(audiohd_state_t *statep, audiohd_path_t *path,
1020 uint64_t val)
1021 {
1022 uint8_t l, r;
1023 uint_t tmp;
1024 int gain;
1025
1026 if (path->mute_wid && val == 0) {
1027 (void) audioha_codec_4bit_verb_get(
1028 statep,
1029 path->codec->index,
1030 path->mute_wid,
1031 AUDIOHDC_VERB_SET_AMP_MUTE,
1032 path->mute_dir |
1033 AUDIOHDC_AMP_SET_LNR |
1034 AUDIOHDC_AMP_SET_MUTE);
1035 return;
1036 }
1037
1038 l = (val & 0xff00) >> 8;
1039 r = (val & 0xff);
1040 tmp = l * path->gain_bits / 100;
1041 (void) audioha_codec_4bit_verb_get(statep,
1042 path->codec->index,
1043 path->gain_wid,
1044 AUDIOHDC_VERB_SET_AMP_MUTE,
1045 AUDIOHDC_AMP_SET_LEFT | path->gain_dir |
1046 tmp);
1047 tmp = r * path->gain_bits / 100;
1048 (void) audioha_codec_4bit_verb_get(statep,
1049 path->codec->index,
1050 path->gain_wid,
1051 AUDIOHDC_VERB_SET_AMP_MUTE,
1052 AUDIOHDC_AMP_SET_RIGHT | path->gain_dir |
1053 tmp);
1054
1055 if (path->mute_wid && path->mute_wid != path->gain_wid) {
1056 gain = AUDIOHDC_GAIN_MAX;
1057 (void) audioha_codec_4bit_verb_get(
1058 statep,
1059 path->codec->index,
1060 path->mute_wid,
1061 AUDIOHDC_VERB_SET_AMP_MUTE,
1062 path->mute_dir |
1063 AUDIOHDC_AMP_SET_LEFT |
1064 gain);
1065 (void) audioha_codec_4bit_verb_get(
1066 statep,
1067 path->codec->index,
1068 path->mute_wid,
1069 AUDIOHDC_VERB_SET_AMP_MUTE,
1070 path->mute_dir |
1071 AUDIOHDC_AMP_SET_RIGHT |
1072 gain);
1073 }
1074 }
1075
1076 static void
1077 audiohd_set_pin_volume(audiohd_state_t *statep, audiohda_device_type_t type)
1078 {
1079 int i, j;
1080 audiohd_path_t *path;
1081 audiohd_widget_t *widget;
1082 wid_t wid;
1083 audiohd_pin_t *pin;
1084 hda_codec_t *codec;
1085 uint64_t val;
1086 audiohd_ctrl_t control;
1087
1088 switch (type) {
1089 case DTYPE_SPEAKER:
1090 control = statep->ctrls[CTL_SPEAKER];
1091 if (control.ctrl == NULL)
1092 return;
1093 val = control.val;
1094 break;
1095 case DTYPE_HP_OUT:
1096 control = statep->ctrls[CTL_HEADPHONE];
1097 if (control.ctrl == NULL)
1098 return;
1099 val = control.val;
1100 break;
1101 case DTYPE_LINEOUT:
1102 control = statep->ctrls[CTL_FRONT];
1103 if (control.ctrl == NULL)
1104 return;
1105 val = control.val;
1106 break;
1107 case DTYPE_CD:
1108 control = statep->ctrls[CTL_CD];
1109 if (control.ctrl == NULL)
1110 return;
1111 val = control.val;
1112 break;
1113 case DTYPE_LINE_IN:
1114 control = statep->ctrls[CTL_LINEIN];
1115 if (control.ctrl == NULL)
1116 return;
1117 val = control.val;
1118 break;
1119 case DTYPE_MIC_IN:
1120 control = statep->ctrls[CTL_MIC];
1121 if (control.ctrl == NULL)
1122 return;
1123 val = control.val;
1124 break;
1125 }
1126
1127 for (i = 0; i < statep->pathnum; i++) {
1128 if ((path = statep->path[i]) == NULL)
1129 continue;
1130
1131 codec = path->codec;
1132 for (j = 0; j < path->pin_nums; j++) {
1133 wid = path->pin_wid[j];
1134 widget = codec->widget[wid];
1135 pin = (audiohd_pin_t *)widget->priv;
1136 if ((pin->device == type) && path->gain_wid) {
1137 audiohd_do_set_pin_volume(statep, path, val);
1138 }
1139 }
1140 }
1141 }
1142
1143
1144 static void
1145 audiohd_set_pin_volume_by_color(audiohd_state_t *statep,
1146 audiohd_pin_color_t color)
1147 {
1148 int i, j;
1149 audiohd_path_t *path;
1150 audiohd_widget_t *widget;
1151 wid_t wid;
1152 audiohd_pin_t *pin;
1153 hda_codec_t *codec;
1154 uint8_t l, r;
1155 uint64_t val;
1156 audiohd_pin_color_t clr;
1157 audiohd_ctrl_t control;
1158
1159 switch (color) {
1160 case AUDIOHD_PIN_GREEN:
1161 control = statep->ctrls[CTL_FRONT];
1162 if (control.ctrl == NULL)
1163 return;
1164 val = control.val;
1165 break;
1166 case AUDIOHD_PIN_BLACK:
1167 control = statep->ctrls[CTL_REAR];
1168 if (control.ctrl == NULL)
1169 return;
1170 val = control.val;
1171 break;
1172 case AUDIOHD_PIN_ORANGE:
1173 control = statep->ctrls[CTL_CENTER];
1174 if (control.ctrl == NULL)
1175 return;
1176 l = control.val;
1177 control = statep->ctrls[CTL_LFE];
1178 if (control.ctrl == NULL)
1179 return;
1180 r = control.val;
1181 val = (l << 8) | r;
1182 break;
1183 case AUDIOHD_PIN_GREY:
1184 control = statep->ctrls[CTL_SURROUND];
1185 if (control.ctrl == NULL)
1186 return;
1187 val = control.val;
1188 break;
1189 }
1190
1191 for (i = 0; i < statep->pathnum; i++) {
1192 path = statep->path[i];
1193 if (!path)
1194 continue;
1195 codec = path->codec;
1196 for (j = 0; j < path->pin_nums; j++) {
1197 wid = path->pin_wid[j];
1198 widget = codec->widget[wid];
1199 pin = (audiohd_pin_t *)widget->priv;
1200 clr = (pin->config >> AUDIOHD_PIN_CLR_OFF) &
1201 AUDIOHD_PIN_CLR_MASK;
1202 if ((clr == color) && path->gain_wid) {
1203 audiohd_do_set_pin_volume(statep, path, val);
1204 }
1205 }
1206 }
1207 }
1208
1209 static int
1210 audiohd_set_input_pin(audiohd_state_t *statep)
1211 {
1212 uint64_t val;
1213 hda_codec_t *codec;
1214 audiohd_pin_t *pin;
1215 audiohd_path_t *path;
1216 audiohd_widget_t *widget, *w;
1217 int i, j;
1218 wid_t wid, pin_wid = 0;
1219 uint32_t set_val;
1220
1221 val = statep->ctrls[CTL_RECSRC].val;
1222 set_val = ddi_ffs(val & 0xffff) - 1;
1223 for (i = 0; i < statep->pathnum; i++) {
1224 if ((path = statep->path[i]) == NULL ||
1225 path->path_type != RECORD)
1226 continue;
1227
1228 switch (set_val) {
1229 case DTYPE_LINE_IN:
1230 case DTYPE_MIC_IN:
1231 case DTYPE_CD:
1232 for (j = 0; j < path->pin_nums; j++) {
1233 wid = path->pin_wid[j];
1234 widget = path->codec->widget[wid];
1235 pin = (audiohd_pin_t *)widget->priv;
1236
1237 if ((1U << pin->device) == val) {
1238 AUDIOHD_ENABLE_PIN_IN(statep,
1239 path->codec->index, pin->wid);
1240 pin_wid = pin->wid;
1241 codec = path->codec;
1242 statep->in_port = pin->device;
1243 } else if (statep->in_port == pin->device) {
1244 AUDIOHD_DISABLE_PIN_IN(statep,
1245 path->codec->index, pin->wid);
1246 }
1247 }
1248 break;
1249 default:
1250 break;
1251 }
1252 }
1253
1254 if (pin_wid == 0)
1255 return (DDI_SUCCESS);
1256
1257 w = codec->widget[pin_wid];
1258 pin = (audiohd_pin_t *)w->priv;
1259 w = codec->widget[pin->adc_wid];
1260 path = (audiohd_path_t *)w->priv;
1261
1262 /*
1263 * If there is a real selector in this input path,
1264 * we select the right one input for the selector.
1265 */
1266 if (path->sum_wid) {
1267 w = codec->widget[path->sum_wid];
1268 if (w->type == WTYPE_AUDIO_SEL) {
1269 for (i = 0; i < path->pin_nums; i++) {
1270 if (path->pin_wid[i] == pin->wid) {
1271 (void) audioha_codec_verb_get(
1272 statep, codec->index, path->sum_wid,
1273 AUDIOHDC_VERB_SET_CONN_SEL,
1274 path->sum_selconn[i]);
1275 break;
1276 }
1277 }
1278 }
1279 }
1280
1281 return (DDI_SUCCESS);
1282 }
1283
1284 static void
1285 audiohd_set_pin_monitor_gain(hda_codec_t *codec, audiohd_state_t *statep,
1286 uint_t caddr, audiohd_pin_t *pin, uint64_t gain)
1287 {
1288 int i, k;
1289 uint_t ltmp, rtmp;
1290 audiohd_widget_t *widget;
1291 uint8_t l, r;
1292
1293 l = (gain & 0xff00) >> 8;
1294 r = (gain & 0xff);
1295
1296 for (k = 0; k < pin->num; k++) {
1297 ltmp = l * pin->mg_gain[k] / 100;
1298 rtmp = r * pin->mg_gain[k] / 100;
1299 widget = codec->widget[pin->mg_wid[k]];
1300 if (pin->mg_dir[k] == AUDIOHDC_AMP_SET_OUTPUT) {
1301 (void) audioha_codec_4bit_verb_get(
1302 statep,
1303 caddr,
1304 pin->mg_wid[k],
1305 AUDIOHDC_VERB_SET_AMP_MUTE,
1306 AUDIOHDC_AMP_SET_LEFT|
1307 pin->mg_dir[k] | ltmp);
1308 (void) audioha_codec_4bit_verb_get(
1309 statep,
1310 caddr,
1311 pin->mg_wid[k],
1312 AUDIOHDC_VERB_SET_AMP_MUTE,
1313 AUDIOHDC_AMP_SET_RIGHT|
1314 pin->mg_dir[k] | rtmp);
1315 } else if (pin->mg_dir[k] == AUDIOHDC_AMP_SET_INPUT) {
1316 for (i = 0; i < widget->used; i++) {
1317 (void) audioha_codec_4bit_verb_get(
1318 statep,
1319 caddr,
1320 pin->mg_wid[k],
1321 AUDIOHDC_VERB_SET_AMP_MUTE,
1322 AUDIOHDC_AMP_SET_RIGHT|
1323 widget->monitor_path_next[i]<<
1324 AUDIOHDC_AMP_SET_INDEX_OFFSET |
1325 pin->mg_dir[k] | rtmp);
1326 (void) audioha_codec_4bit_verb_get(
1327 statep,
1328 caddr,
1329 pin->mg_wid[k],
1330 AUDIOHDC_VERB_SET_AMP_MUTE,
1331 AUDIOHDC_AMP_SET_LEFT|
1332 widget->monitor_path_next[i]<<
1333 AUDIOHDC_AMP_SET_INDEX_OFFSET |
1334 pin->mg_dir[k] | ltmp);
1335 }
1336 }
1337 }
1338 }
1339
1340 static void
1341 audiohd_set_monitor_gain(audiohd_state_t *statep)
1342 {
1343 int i, j;
1344 audiohd_path_t *path;
1345 uint_t caddr;
1346 audiohd_widget_t *w;
1347 wid_t wid;
1348 audiohd_pin_t *pin;
1349 audiohd_ctrl_t ctrl;
1350 uint64_t val;
1351
1352 ctrl = statep->ctrls[CTL_MONGAIN];
1353 val = ctrl.val;
1354
1355 for (i = 0; i < statep->pathnum; i++) {
1356 path = statep->path[i];
1357 if (path == NULL || path->path_type != PLAY)
1358 continue;
1359 caddr = path->codec->index;
1360 for (j = 0; j < path->pin_nums; j++) {
1361 wid = path->pin_wid[j];
1362 w = path->codec->widget[wid];
1363 pin = (audiohd_pin_t *)w->priv;
1364 audiohd_set_pin_monitor_gain(path->codec, statep,
1365 caddr, pin, val);
1366 }
1367 }
1368
1369 }
1370
1371 static void
1372 audiohd_set_beep_volume(audiohd_state_t *statep)
1373 {
1374 int i;
1375 audiohd_path_t *path;
1376 hda_codec_t *codec;
1377 uint64_t val;
1378 uint_t tmp;
1379 audiohd_ctrl_t control;
1380 uint32_t vid;
1381
1382 control = statep->ctrls[CTL_BEEP];
1383 val = control.val;
1384 for (i = 0; i < statep->pathnum; i++) {
1385 path = statep->path[i];
1386 if (!path || path->path_type != BEEP)
1387 continue;
1388 codec = path->codec;
1389 vid = codec->vid;
1390 vid = vid >> 16;
1391
1392 switch (vid) {
1393 case AUDIOHD_VID_SIGMATEL:
1394 /*
1395 * Sigmatel HD codec specific operation.
1396 * There is a workaround,
1397 * Due to Sigmatel HD codec hardware problem,
1398 * which it can't mute beep when volume is 0.
1399 * So add global value audiohd_beep_vol,
1400 * Set freq to 0 when volume is 0.
1401 */
1402 tmp = val * path->gain_bits / 100;
1403 if (tmp == 0) {
1404 audiohd_beep_vol = 0;
1405 } else {
1406 audiohd_beep_vol = tmp;
1407 (void) audioha_codec_verb_get(
1408 statep,
1409 codec->index,
1410 path->beep_wid,
1411 AUDIOHDC_VERB_SET_BEEP_VOL,
1412 tmp);
1413 }
1414 break;
1415
1416 default:
1417 /* Common operation based on audiohd spec */
1418 audiohd_do_set_beep_volume(statep, path, val);
1419 break;
1420 }
1421 }
1422 }
1423
1424 static void
1425 audiohd_do_set_beep_volume(audiohd_state_t *statep, audiohd_path_t *path,
1426 uint64_t val)
1427 {
1428 uint8_t l, r;
1429 uint_t tmp;
1430 int gain;
1431
1432 if (val == 0) {
1433 (void) audioha_codec_4bit_verb_get(
1434 statep,
1435 path->codec->index,
1436 path->mute_wid,
1437 AUDIOHDC_VERB_SET_AMP_MUTE,
1438 path->mute_dir |
1439 AUDIOHDC_AMP_SET_LNR |
1440 AUDIOHDC_AMP_SET_MUTE);
1441 return;
1442 }
1443
1444 r = (val & 0xff);
1445 l = r;
1446
1447 tmp = l * path->gain_bits / 100;
1448 (void) audioha_codec_4bit_verb_get(statep,
1449 path->codec->index,
1450 path->gain_wid,
1451 AUDIOHDC_VERB_SET_AMP_MUTE,
1452 AUDIOHDC_AMP_SET_LEFT | path->gain_dir |
1453 tmp);
1454 tmp = r * path->gain_bits / 100;
1455 (void) audioha_codec_4bit_verb_get(statep,
1456 path->codec->index,
1457 path->gain_wid,
1458 AUDIOHDC_VERB_SET_AMP_MUTE,
1459 AUDIOHDC_AMP_SET_RIGHT | path->gain_dir |
1460 tmp);
1461 if (path->mute_wid != path->gain_wid) {
1462 gain = AUDIOHDC_GAIN_MAX;
1463 (void) audioha_codec_4bit_verb_get(
1464 statep,
1465 path->codec->index,
1466 path->mute_wid,
1467 AUDIOHDC_VERB_SET_AMP_MUTE,
1468 path->mute_dir |
1469 AUDIOHDC_AMP_SET_LEFT |
1470 gain);
1471 (void) audioha_codec_4bit_verb_get(
1472 statep,
1473 path->codec->index,
1474 path->mute_wid,
1475 AUDIOHDC_VERB_SET_AMP_MUTE,
1476 path->mute_dir |
1477 AUDIOHDC_AMP_SET_RIGHT |
1478 gain);
1479 }
1480 }
1481
1482 static void
1483 audiohd_configure_output(audiohd_state_t *statep)
1484 {
1485 audiohd_set_pin_volume(statep, DTYPE_LINEOUT);
1486 audiohd_set_pin_volume(statep, DTYPE_SPEAKER);
1487 audiohd_set_pin_volume(statep, DTYPE_HP_OUT);
1488
1489 audiohd_set_pin_volume_by_color(statep, AUDIOHD_PIN_GREEN);
1490 audiohd_set_pin_volume_by_color(statep, AUDIOHD_PIN_BLACK);
1491 audiohd_set_pin_volume_by_color(statep, AUDIOHD_PIN_GREY);
1492 audiohd_set_pin_volume_by_color(statep, AUDIOHD_PIN_ORANGE);
1493 }
1494
1495 static void
1496 audiohd_configure_input(audiohd_state_t *statep)
1497 {
1498 (void) audiohd_set_input_pin(statep);
1499 audiohd_set_monitor_gain(statep);
1500 audiohd_set_pin_volume(statep, DTYPE_LINE_IN);
1501 audiohd_set_pin_volume(statep, DTYPE_CD);
1502 audiohd_set_pin_volume(statep, DTYPE_MIC_IN);
1503 }
1504
1505 static int
1506 audiohd_set_recsrc(void *arg, uint64_t val)
1507 {
1508 audiohd_ctrl_t *pc = arg;
1509 audiohd_state_t *statep = pc->statep;
1510
1511 if (val & ~(statep->inmask))
1512 return (EINVAL);
1513
1514 mutex_enter(&statep->hda_mutex);
1515 pc->val = val;
1516 audiohd_configure_input(statep);
1517 mutex_exit(&statep->hda_mutex);
1518 return (0);
1519 }
1520
1521 static int
1522 audiohd_set_rear(void *arg, uint64_t val)
1523 {
1524 audiohd_ctrl_t *pc = arg;
1525 audiohd_state_t *statep = pc->statep;
1526 AUDIOHD_CHECK_2CHANNELS_VOLUME(val);
1527
1528 mutex_enter(&statep->hda_mutex);
1529 pc->val = val;
1530 audiohd_set_pin_volume_by_color(statep, AUDIOHD_PIN_BLACK);
1531 mutex_exit(&statep->hda_mutex);
1532
1533 return (0);
1534 }
1535
1536 static int
1537 audiohd_set_center(void *arg, uint64_t val)
1538 {
1539 audiohd_ctrl_t *pc = arg;
1540 audiohd_state_t *statep = pc->statep;
1541 AUDIOHD_CHECK_CHANNEL_VOLUME(val);
1542
1543 mutex_enter(&statep->hda_mutex);
1544 pc->val = val;
1545 audiohd_set_pin_volume_by_color(statep, AUDIOHD_PIN_ORANGE);
1546 mutex_exit(&statep->hda_mutex);
1547
1548 return (0);
1549 }
1550
1551 static int
1552 audiohd_set_surround(void *arg, uint64_t val)
1553 {
1554 audiohd_ctrl_t *pc = arg;
1555 audiohd_state_t *statep = pc->statep;
1556 AUDIOHD_CHECK_2CHANNELS_VOLUME(val);
1557
1558 mutex_enter(&statep->hda_mutex);
1559 pc->val = val;
1560 audiohd_set_pin_volume_by_color(statep, AUDIOHD_PIN_GREY);
1561 mutex_exit(&statep->hda_mutex);
1562
1563 return (0);
1564 }
1565
1566 static int
1567 audiohd_set_lfe(void *arg, uint64_t val)
1568 {
1569 audiohd_ctrl_t *pc = arg;
1570 audiohd_state_t *statep = pc->statep;
1571 AUDIOHD_CHECK_CHANNEL_VOLUME(val);
1572
1573 mutex_enter(&statep->hda_mutex);
1574 pc->val = val;
1575 audiohd_set_pin_volume_by_color(statep, AUDIOHD_PIN_ORANGE);
1576 mutex_exit(&statep->hda_mutex);
1577
1578 return (0);
1579 }
1580 static int
1581 audiohd_set_speaker(void *arg, uint64_t val)
1582 {
1583 audiohd_ctrl_t *pc = arg;
1584 audiohd_state_t *statep = pc->statep;
1585 AUDIOHD_CHECK_2CHANNELS_VOLUME(val);
1586
1587 mutex_enter(&statep->hda_mutex);
1588 pc->val = val;
1589 audiohd_set_pin_volume(statep, DTYPE_SPEAKER);
1590 mutex_exit(&statep->hda_mutex);
1591
1592 return (0);
1593 }
1594 static int
1595 audiohd_set_front(void *arg, uint64_t val)
1596 {
1597 audiohd_ctrl_t *pc = arg;
1598 audiohd_state_t *statep = pc->statep;
1599 AUDIOHD_CHECK_2CHANNELS_VOLUME(val);
1600
1601 mutex_enter(&statep->hda_mutex);
1602 pc->val = val;
1603 audiohd_set_pin_volume_by_color(statep, AUDIOHD_PIN_GREEN);
1604 mutex_exit(&statep->hda_mutex);
1605
1606 return (0);
1607 }
1608
1609 static int
1610 audiohd_set_headphone(void *arg, uint64_t val)
1611 {
1612 audiohd_ctrl_t *pc = arg;
1613 audiohd_state_t *statep = pc->statep;
1614 AUDIOHD_CHECK_2CHANNELS_VOLUME(val);
1615
1616 mutex_enter(&statep->hda_mutex);
1617 pc->val = val;
1618 audiohd_set_pin_volume(statep, DTYPE_HP_OUT);
1619 mutex_exit(&statep->hda_mutex);
1620
1621 return (0);
1622 }
1623
1624 static int
1625 audiohd_set_linein(void *arg, uint64_t val)
1626 {
1627 audiohd_ctrl_t *pc = arg;
1628 audiohd_state_t *statep = pc->statep;
1629 AUDIOHD_CHECK_2CHANNELS_VOLUME(val);
1630
1631 mutex_enter(&statep->hda_mutex);
1632 pc->val = val;
1633 audiohd_set_pin_volume(statep, DTYPE_LINE_IN);
1634 mutex_exit(&statep->hda_mutex);
1635
1636 return (0);
1637 }
1638
1639 static int
1640 audiohd_set_loopback(void *arg, uint64_t val)
1641 {
1642 audiohd_ctrl_t *pc = arg;
1643 audiohd_state_t *statep = pc->statep;
1644 audiohd_path_t *path = NULL;
1645 audiohd_widget_t *widget = NULL;
1646 audiohd_pin_t *pin = NULL;
1647 wid_t wid;
1648 uint32_t pinctrl;
1649 int i, j;
1650
1651 mutex_enter(&statep->hda_mutex);
1652 pc->val = val;
1653
1654 for (i = 0; i < statep->pathnum; i++) {
1655 path = statep->path[i];
1656 if (path == NULL || path->path_type != LOOPBACK)
1657 continue;
1658
1659 for (j = 0; j < path->pin_nums; j++) {
1660 wid = path->pin_wid[j];
1661 widget = path->codec->widget[wid];
1662 pin = (audiohd_pin_t *)widget->priv;
1663
1664 if (val == 1) {
1665 /* Turn on loopback recording */
1666 pinctrl = audioha_codec_verb_get(statep,
1667 path->codec->index, wid,
1668 AUDIOHDC_VERB_GET_PIN_CTRL, 0);
1669 (void) audioha_codec_verb_get(statep,
1670 path->codec->index, wid,
1671 AUDIOHDC_VERB_SET_PIN_CTRL,
1672 pinctrl | AUDIOHD_PIN_OUT_ENABLE);
1673
1674 if (pin->cap & AUDIOHD_EXT_AMP_MASK) {
1675 (void) audioha_codec_verb_get(statep,
1676 path->codec->index,
1677 wid, AUDIOHDC_VERB_SET_EAPD,
1678 AUDIOHD_EXT_AMP_ENABLE);
1679 }
1680
1681 } else {
1682 /* Turn off loopback recording */
1683 if (pin->device == DTYPE_LINE_IN) {
1684 pinctrl = audioha_codec_verb_get(statep,
1685 path->codec->index, wid,
1686 AUDIOHDC_VERB_GET_PIN_CTRL, 0);
1687 (void) audioha_codec_verb_get(statep,
1688 path->codec->index, wid,
1689 AUDIOHDC_VERB_SET_PIN_CTRL,
1690 pinctrl & ~AUDIOHD_PIN_OUT_ENABLE);
1691 }
1692 }
1693
1694 }
1695 }
1696 mutex_exit(&statep->hda_mutex);
1697
1698 return (0);
1699 }
1700
1701 static int
1702 audiohd_set_mic(void *arg, uint64_t val)
1703 {
1704 audiohd_ctrl_t *pc = arg;
1705 audiohd_state_t *statep = pc->statep;
1706 AUDIOHD_CHECK_2CHANNELS_VOLUME(val);
1707
1708 mutex_enter(&statep->hda_mutex);
1709 pc->val = val;
1710 audiohd_set_pin_volume(statep, DTYPE_MIC_IN);
1711 mutex_exit(&statep->hda_mutex);
1712
1713 return (0);
1714 }
1715
1716 static int
1717 audiohd_set_cd(void *arg, uint64_t val)
1718 {
1719 audiohd_ctrl_t *pc = arg;
1720 audiohd_state_t *statep = pc->statep;
1721 AUDIOHD_CHECK_2CHANNELS_VOLUME(val);
1722
1723 mutex_enter(&statep->hda_mutex);
1724 pc->val = val;
1725 audiohd_set_pin_volume(statep, DTYPE_CD);
1726 mutex_exit(&statep->hda_mutex);
1727
1728 return (0);
1729 }
1730
1731 static int
1732 audiohd_set_mongain(void *arg, uint64_t val)
1733 {
1734 audiohd_ctrl_t *pc = arg;
1735 audiohd_state_t *statep = pc->statep;
1736 AUDIOHD_CHECK_2CHANNELS_VOLUME(val);
1737
1738 mutex_enter(&statep->hda_mutex);
1739 pc->val = val;
1740 audiohd_set_monitor_gain(statep);
1741 mutex_exit(&statep->hda_mutex);
1742
1743 return (0);
1744 }
1745
1746 static int
1747 audiohd_set_beep(void *arg, uint64_t val)
1748 {
1749 audiohd_ctrl_t *pc = arg;
1750 audiohd_state_t *statep = pc->statep;
1751 AUDIOHD_CHECK_CHANNEL_VOLUME(val);
1752
1753 mutex_enter(&statep->hda_mutex);
1754 pc->val = val;
1755 audiohd_set_beep_volume(statep);
1756 mutex_exit(&statep->hda_mutex);
1757
1758 return (0);
1759 }
1760
1761 #define PLAYCTL (AUDIO_CTRL_FLAG_RW | AUDIO_CTRL_FLAG_PLAY)
1762 #define RECCTL (AUDIO_CTRL_FLAG_RW | AUDIO_CTRL_FLAG_REC)
1763 #define MONCTL (AUDIO_CTRL_FLAG_RW | AUDIO_CTRL_FLAG_MONITOR)
1764 #define PCMVOL (PLAYCTL | AUDIO_CTRL_FLAG_PCMVOL)
1765 #define MONVOL (MONCTL | AUDIO_CTRL_FLAG_MONVOL)
1766 #define MAINVOL (PLAYCTL | AUDIO_CTRL_FLAG_MAINVOL)
1767 #define RECVOL (RECCTL | AUDIO_CTRL_FLAG_RECVOL)
1768
1769 static void
1770 audiohd_del_controls(audiohd_state_t *statep)
1771 {
1772 int i;
1773 for (i = 0; i < CTL_MAX; i++) {
1774 audiohd_ctrl_t *ac = &statep->ctrls[i];
1775 if (ac->ctrl != NULL) {
1776 audio_dev_del_control(ac->ctrl);
1777 ac->ctrl = NULL;
1778 }
1779 }
1780 }
1781
1782 static void
1783 audiohd_create_mono(audiohd_state_t *statep, int ctl,
1784 const char *id, int flags, int defval, audio_ctrl_wr_t fn)
1785 {
1786 audiohd_ctrl_t *ac;
1787 audio_ctrl_desc_t desc;
1788
1789 bzero(&desc, sizeof (desc));
1790
1791 ac = &statep->ctrls[ctl];
1792 ac->statep = statep;
1793 ac->num = ctl;
1794
1795 desc.acd_name = id;
1796 desc.acd_type = AUDIO_CTRL_TYPE_MONO;
1797 desc.acd_minvalue = 0;
1798 desc.acd_maxvalue = 100;
1799 desc.acd_flags = flags;
1800
1801 ac->val = defval;
1802 ac->ctrl = audio_dev_add_control(statep->adev, &desc,
1803 audiohd_get_control, fn, ac);
1804 }
1805
1806 static void
1807 audiohd_create_stereo(audiohd_state_t *statep, int ctl,
1808 const char *id, int flags, int defval, audio_ctrl_wr_t fn)
1809 {
1810 audiohd_ctrl_t *ac;
1811 audio_ctrl_desc_t desc;
1812
1813 bzero(&desc, sizeof (desc));
1814
1815 ac = &statep->ctrls[ctl];
1816 ac->statep = statep;
1817 ac->num = ctl;
1818
1819 desc.acd_name = id;
1820 desc.acd_type = AUDIO_CTRL_TYPE_STEREO;
1821 desc.acd_minvalue = 0;
1822 desc.acd_maxvalue = 100;
1823 desc.acd_flags = flags;
1824
1825 ac->val = (defval << 8) | defval;
1826 ac->ctrl = audio_dev_add_control(statep->adev, &desc,
1827 audiohd_get_control, fn, ac);
1828 }
1829
1830 static void
1831 audiohd_create_bool(audiohd_state_t *statep, int ctl,
1832 const char *id, int defval, audio_ctrl_wr_t fn)
1833 {
1834 audiohd_ctrl_t *ac;
1835 audio_ctrl_desc_t desc;
1836
1837 bzero(&desc, sizeof (desc));
1838
1839 ac = &statep->ctrls[ctl];
1840 ac->statep = statep;
1841 ac->num = ctl;
1842
1843 desc.acd_name = id;
1844 desc.acd_type = AUDIO_CTRL_TYPE_BOOLEAN;
1845 desc.acd_minvalue = 0;
1846 desc.acd_maxvalue = 1;
1847 desc.acd_flags = RECCTL;
1848
1849 ac->val = defval;
1850 ac->ctrl = audio_dev_add_control(statep->adev, &desc,
1851 audiohd_get_control, fn, ac);
1852 }
1853
1854 static void
1855 audiohd_create_recsrc(audiohd_state_t *statep)
1856 {
1857 audiohd_ctrl_t *ac;
1858 audio_ctrl_desc_t desc;
1859
1860 bzero(&desc, sizeof (desc));
1861
1862 ac = &statep->ctrls[CTL_RECSRC];
1863 ac->statep = statep;
1864 ac->num = CTL_RECSRC;
1865
1866 desc.acd_name = AUDIO_CTRL_ID_RECSRC;
1867 desc.acd_type = AUDIO_CTRL_TYPE_ENUM;
1868 desc.acd_flags = RECVOL;
1869 desc.acd_minvalue = statep->inmask;
1870 desc.acd_maxvalue = statep->inmask;
1871 for (int i = 0; audiohd_dtypes[i]; i++) {
1872 desc.acd_enum[i] = audiohd_dtypes[i];
1873 }
1874
1875 ac->val = (1U << DTYPE_MIC_IN);
1876 ac->ctrl = audio_dev_add_control(statep->adev, &desc,
1877 audiohd_get_control, audiohd_set_recsrc, ac);
1878 }
1879
1880 static void
1881 audiohd_create_controls(audiohd_state_t *statep)
1882 {
1883 wid_t wid;
1884 audiohd_widget_t *widget;
1885 audiohd_path_t *path;
1886 hda_codec_t *codec;
1887 audiohd_pin_t *pin;
1888 audiohd_pin_color_t color;
1889 int i, j;
1890
1891 /*
1892 * We always use soft volume control to adjust PCM volume.
1893 */
1894 audio_dev_add_soft_volume(statep->adev);
1895
1896 /* Allocate other controls */
1897 for (i = 0; i < statep->pathnum; i++) {
1898 path = statep->path[i];
1899 if (path == NULL)
1900 continue;
1901 codec = path->codec;
1902
1903 for (j = 0; j < path->pin_nums; j++) {
1904 wid = path->pin_wid[j];
1905 widget = codec->widget[wid];
1906 pin = (audiohd_pin_t *)widget->priv;
1907 color = (pin->config >> AUDIOHD_PIN_CLR_OFF) &
1908 AUDIOHD_PIN_CLR_MASK;
1909 if (color == AUDIOHD_PIN_GREEN) {
1910 audiohd_create_stereo(statep, CTL_FRONT,
1911 AUDIO_CTRL_ID_FRONT, MAINVOL, 75,
1912 audiohd_set_front);
1913 } else if (color == AUDIOHD_PIN_BLACK &&
1914 pin->device != DTYPE_HP_OUT &&
1915 pin->device != DTYPE_MIC_IN) {
1916 audiohd_create_stereo(statep, CTL_REAR,
1917 AUDIO_CTRL_ID_REAR, MAINVOL, 75,
1918 audiohd_set_rear);
1919 } else if (color == AUDIOHD_PIN_ORANGE) {
1920 audiohd_create_mono(statep, CTL_CENTER,
1921 AUDIO_CTRL_ID_CENTER, MAINVOL, 75,
1922 audiohd_set_center);
1923 audiohd_create_mono(statep, CTL_LFE,
1924 AUDIO_CTRL_ID_LFE, MAINVOL, 75,
1925 audiohd_set_lfe);
1926 } else if (color == AUDIOHD_PIN_GREY) {
1927 audiohd_create_stereo(statep, CTL_SURROUND,
1928 AUDIO_CTRL_ID_SURROUND, MAINVOL, 75,
1929 audiohd_set_surround);
1930 }
1931 if (pin->device == DTYPE_SPEAKER) {
1932 audiohd_create_stereo(statep, CTL_SPEAKER,
1933 AUDIO_CTRL_ID_SPEAKER, MAINVOL, 75,
1934 audiohd_set_speaker);
1935 } else if (pin->device == DTYPE_HP_OUT) {
1936 audiohd_create_stereo(statep, CTL_HEADPHONE,
1937 AUDIO_CTRL_ID_HEADPHONE, MAINVOL, 75,
1938 audiohd_set_headphone);
1939 } else if (pin->device == DTYPE_LINE_IN) {
1940 audiohd_create_stereo(statep, CTL_LINEIN,
1941 AUDIO_CTRL_ID_LINEIN, RECVOL, 50,
1942 audiohd_set_linein);
1943 } else if (pin->device == DTYPE_MIC_IN) {
1944 audiohd_create_stereo(statep, CTL_MIC,
1945 AUDIO_CTRL_ID_MIC, RECVOL, 50,
1946 audiohd_set_mic);
1947 } else if (pin->device == DTYPE_CD) {
1948 audiohd_create_stereo(statep, CTL_CD,
1949 AUDIO_CTRL_ID_CD, RECVOL, 50,
1950 audiohd_set_cd);
1951 }
1952 }
1953
1954 if (path->path_type == BEEP) {
1955 widget = codec->widget[path->beep_wid];
1956 if (widget->type == WTYPE_BEEP &&
1957 path->gain_wid != 0) {
1958 audiohd_create_mono(statep, CTL_BEEP,
1959 AUDIO_CTRL_ID_BEEP, AUDIO_CTRL_FLAG_RW, 75,
1960 audiohd_set_beep);
1961 continue;
1962 }
1963 }
1964 }
1965
1966 if (statep->monitor_supported) {
1967 audiohd_create_stereo(statep, CTL_MONGAIN,
1968 AUDIO_CTRL_ID_MONGAIN, MONVOL, 0,
1969 audiohd_set_mongain);
1970 }
1971
1972 if (statep->loopback_supported) {
1973 audiohd_create_bool(statep, CTL_LOOP, AUDIO_CTRL_ID_LOOPBACK,
1974 0, audiohd_set_loopback);
1975 }
1976
1977 audiohd_create_recsrc(statep);
1978 audiohd_configure_output(statep);
1979 audiohd_configure_input(statep);
1980 }
1981
1982 /*
1983 * quiesce(9E) entry point.
1984 *
1985 * This function is called when the system is single-threaded at high
1986 * PIL with preemption disabled. Therefore, this function must not be
1987 * blocked.
1988 *
1989 * This function returns DDI_SUCCESS on success, or DDI_FAILURE on failure.
1990 * DDI_FAILURE indicates an error condition and should almost never happen.
1991 */
1992 static int
1993 audiohd_quiesce(dev_info_t *dip)
1994 {
1995 audiohd_state_t *statep;
1996
1997 statep = ddi_get_driver_private(dip);
1998
1999 mutex_enter(&statep->hda_mutex);
2000 audiohd_stop_dma(statep);
2001 mutex_exit(&statep->hda_mutex);
2002
2003 return (DDI_SUCCESS);
2004 }
2005
2006 static void
2007 audiohd_beep_on(void *arg)
2008 {
2009 hda_codec_t *codec = ((audiohd_widget_t *)arg)->codec;
2010 audiohd_state_t *statep = codec->statep;
2011 int caddr = codec->index;
2012 wid_t wid = ((audiohd_widget_t *)arg)->wid_wid;
2013
2014 mutex_enter(&statep->hda_mutex);
2015 (void) audioha_codec_verb_get(statep, caddr, wid,
2016 AUDIOHDC_VERB_SET_BEEP_GEN, audiohd_beep_divider);
2017 mutex_exit(&statep->hda_mutex);
2018 }
2019
2020 static void
2021 audiohd_beep_off(void *arg)
2022 {
2023 hda_codec_t *codec = ((audiohd_widget_t *)arg)->codec;
2024 audiohd_state_t *statep = codec->statep;
2025 int caddr = codec->index;
2026 wid_t wid = ((audiohd_widget_t *)arg)->wid_wid;
2027
2028 mutex_enter(&statep->hda_mutex);
2029 (void) audioha_codec_verb_get(statep, caddr, wid,
2030 AUDIOHDC_VERB_SET_BEEP_GEN, AUDIOHDC_MUTE_BEEP_GEN);
2031 mutex_exit(&statep->hda_mutex);
2032 }
2033
2034 static void
2035 audiohd_beep_freq(void *arg, int freq)
2036 {
2037 hda_codec_t *codec = ((audiohd_widget_t *)arg)->codec;
2038 audiohd_state_t *statep = codec->statep;
2039 uint32_t vid = codec->vid >> 16;
2040 int divider;
2041
2042 _NOTE(ARGUNUSED(arg));
2043 if (freq == 0) {
2044 divider = 0;
2045 } else {
2046 if (freq > AUDIOHDC_MAX_BEEP_GEN)
2047 freq = AUDIOHDC_MAX_BEEP_GEN;
2048 else if (freq < AUDIOHDC_MIX_BEEP_GEN)
2049 freq = AUDIOHDC_MIX_BEEP_GEN;
2050
2051 switch (vid) {
2052 case AUDIOHD_VID_SIGMATEL:
2053 /*
2054 * Sigmatel HD codec specification:
2055 * frequency = 48000 * (257 - Divider) / 1024
2056 */
2057 divider = 257 - freq * 1024 / AUDIOHDC_SAMPR48000;
2058 break;
2059 default:
2060 divider = AUDIOHDC_SAMPR48000 / freq;
2061 break;
2062 }
2063 }
2064
2065 if (audiohd_beep_vol == 0)
2066 divider = 0;
2067
2068 mutex_enter(&statep->hda_mutex);
2069 audiohd_beep_divider = divider;
2070 mutex_exit(&statep->hda_mutex);
2071 }
2072
2073 /*
2074 * audiohd_init_state()
2075 *
2076 * Description
2077 * This routine initailizes soft state of driver instance,
2078 * also, it requests an interrupt cookie and initializes
2079 * mutex for soft state.
2080 */
2081 /*ARGSUSED*/
2082 static int
2083 audiohd_init_state(audiohd_state_t *statep, dev_info_t *dip)
2084 {
2085 audio_dev_t *adev;
2086
2087 statep->hda_dip = dip;
2088 statep->hda_rirb_rp = 0;
2089
2090 if ((adev = audio_dev_alloc(dip, 0)) == NULL) {
2091 audio_dev_warn(NULL, "unable to allocate audio dev");
2092 return (DDI_FAILURE);
2093 }
2094 statep->adev = adev;
2095
2096 /* set device information */
2097 audio_dev_set_description(adev, AUDIOHD_DEV_CONFIG);
2098 audio_dev_set_version(adev, AUDIOHD_DEV_VERSION);
2099
2100 return (DDI_SUCCESS);
2101 } /* audiohd_init_state() */
2102
2103 /*
2104 * audiohd_init_pci()
2105 *
2106 * Description
2107 * enable driver to access PCI configure space and memory
2108 * I/O space.
2109 */
2110 static int
2111 audiohd_init_pci(audiohd_state_t *statep, ddi_device_acc_attr_t *acc_attr)
2112 {
2113 uint16_t cmdreg;
2114 uint16_t vid;
2115 uint8_t cTmp;
2116 dev_info_t *dip = statep->hda_dip;
2117 audio_dev_t *adev = statep->adev;
2118
2119 if (pci_config_setup(dip, &statep->hda_pci_handle) == DDI_FAILURE) {
2120 audio_dev_warn(adev,
2121 "pci config mapping failed");
2122 return (DDI_FAILURE);
2123 }
2124
2125 if (ddi_regs_map_setup(dip, 1, &statep->hda_reg_base, 0,
2126 0, acc_attr, &statep->hda_reg_handle) != DDI_SUCCESS) {
2127 audio_dev_warn(adev,
2128 "memory I/O mapping failed");
2129 return (DDI_FAILURE);
2130 }
2131
2132 /*
2133 * HD audio control uses memory I/O only, enable it here.
2134 */
2135 cmdreg = pci_config_get16(statep->hda_pci_handle, PCI_CONF_COMM);
2136 pci_config_put16(statep->hda_pci_handle, PCI_CONF_COMM,
2137 cmdreg | PCI_COMM_MAE | PCI_COMM_ME);
2138
2139 vid = pci_config_get16(statep->hda_pci_handle, PCI_CONF_VENID);
2140 switch (vid) {
2141 case AUDIOHD_VID_INTEL:
2142 /*
2143 * Currently, Intel (G)MCH and ICHx chipsets support PCI
2144 * Express QoS. It implemenets two VCs(virtual channels)
2145 * and allows OS software to map 8 traffic classes to the
2146 * two VCs. Some BIOSes initialize HD audio hardware to
2147 * use TC7 (traffic class 7) and to map TC7 to VC1 as Intel
2148 * recommended. However, solaris doesn't support PCI express
2149 * QoS yet. As a result, this driver can not work for those
2150 * hardware without touching PCI express control registers.
2151 * Here, we set TCSEL to 0 so as to use TC0/VC0 (VC0 is
2152 * always enabled and TC0 is always mapped to VC0) for all
2153 * Intel HD audio controllers.
2154 */
2155 cTmp = pci_config_get8(statep->hda_pci_handle,
2156 AUDIOHD_INTEL_PCI_TCSEL);
2157 pci_config_put8(statep->hda_pci_handle,
2158 AUDIOHD_INTEL_PCI_TCSEL, (cTmp & AUDIOHD_INTEL_TCS_MASK));
2159 break;
2160 case AUDIOHD_VID_ATI:
2161 /*
2162 * Refer to ATI SB450 datesheet. We set snoop for SB450
2163 * like hardware.
2164 */
2165 cTmp = pci_config_get8(statep->hda_pci_handle,
2166 AUDIOHD_ATI_PCI_MISC2);
2167 pci_config_put8(statep->hda_pci_handle, AUDIOHD_ATI_PCI_MISC2,
2168 (cTmp & AUDIOHD_ATI_MISC2_MASK) | AUDIOHD_ATI_MISC2_SNOOP);
2169 break;
2170 case AUDIOHD_VID_NVIDIA:
2171 /*
2172 * Refer to the datasheet, we set snoop for NVIDIA
2173 * like hardware
2174 */
2175 cTmp = pci_config_get8(statep->hda_pci_handle,
2176 AUDIOHD_CORB_SIZE_OFF);
2177 pci_config_put8(statep->hda_pci_handle, AUDIOHD_CORB_SIZE_OFF,
2178 cTmp | AUDIOHD_NVIDIA_SNOOP);
2179 break;
2180 default:
2181 break;
2182 }
2183
2184 return (DDI_SUCCESS);
2185 } /* audiohd_init_pci() */
2186
2187
2188 /*
2189 * audiohd_fini_pci()
2190 *
2191 * Description
2192 * Release mapping for PCI configure space.
2193 */
2194 static void
2195 audiohd_fini_pci(audiohd_state_t *statep)
2196 {
2197 if (statep->hda_reg_handle != NULL) {
2198 ddi_regs_map_free(&statep->hda_reg_handle);
2199 }
2200
2201 if (statep->hda_pci_handle != NULL) {
2202 pci_config_teardown(&statep->hda_pci_handle);
2203 }
2204
2205 } /* audiohd_fini_pci() */
2206
2207 /*
2208 * audiohd_stop_dma()
2209 *
2210 * Description
2211 * Stop all DMA behaviors of controllers, for command I/O
2212 * and each audio stream.
2213 */
2214 static void
2215 audiohd_stop_dma(audiohd_state_t *statep)
2216 {
2217 int i;
2218 uint_t base;
2219 uint8_t bTmp;
2220
2221 AUDIOHD_REG_SET8(AUDIOHD_REG_CORBCTL, 0);
2222 AUDIOHD_REG_SET8(AUDIOHD_REG_RIRBCTL, 0);
2223
2224 base = AUDIOHD_REG_SD_BASE;
2225 for (i = 0; i < statep->hda_streams_nums; i++) {
2226 bTmp = AUDIOHD_REG_GET8(base + AUDIOHD_SDREG_OFFSET_CTL);
2227
2228 /* for input/output stream, it is the same */
2229 bTmp &= ~AUDIOHDR_RIRBCTL_DMARUN;
2230
2231 AUDIOHD_REG_SET8(base + AUDIOHD_SDREG_OFFSET_CTL, bTmp);
2232 base += AUDIOHD_REG_SD_LEN;
2233 }
2234
2235 /* wait 40us for stream DMA to stop */
2236 drv_usecwait(40);
2237
2238 } /* audiohd_stop_dma() */
2239
2240 /*
2241 * audiohd_reset_controller()
2242 *
2243 * Description:
2244 * This routine is just used to reset controller and
2245 * CODEC as well by HW reset bit in global control
2246 * register of HD controller.
2247 */
2248 static int
2249 audiohd_reset_controller(audiohd_state_t *statep)
2250 {
2251 int i;
2252 uint16_t sTmp;
2253 uint32_t gctl;
2254
2255 /* Reset Status register but preserve the first bit */
2256 sTmp = AUDIOHD_REG_GET16(AUDIOHD_REG_STATESTS);
2257 AUDIOHD_REG_SET16(AUDIOHD_REG_STATESTS, sTmp & 0x8000);
2258
2259 /* reset controller */
2260 gctl = AUDIOHD_REG_GET32(AUDIOHD_REG_GCTL);
2261 gctl &= ~AUDIOHDR_GCTL_CRST;
2262 AUDIOHD_REG_SET32(AUDIOHD_REG_GCTL, gctl); /* entering reset state */
2263 for (i = 0; i < AUDIOHD_RETRY_TIMES; i++) {
2264 /* Empirical testing time: 150 */
2265 drv_usecwait(150);
2266 gctl = AUDIOHD_REG_GET32(AUDIOHD_REG_GCTL);
2267 if ((gctl & AUDIOHDR_GCTL_CRST) == 0)
2268 break;
2269 }
2270
2271 if ((gctl & AUDIOHDR_GCTL_CRST) != 0) {
2272 audio_dev_warn(statep->adev,
2273 "failed to enter reset state");
2274 return (DDI_FAILURE);
2275 }
2276
2277 /* Empirical testing time:300 */
2278 drv_usecwait(300);
2279
2280 /* exit reset state */
2281 AUDIOHD_REG_SET32(AUDIOHD_REG_GCTL, gctl | AUDIOHDR_GCTL_CRST);
2282
2283 for (i = 0; i < AUDIOHD_RETRY_TIMES; i++) {
2284 /* Empirical testing time: 150, which works well */
2285 drv_usecwait(150);
2286 gctl = AUDIOHD_REG_GET32(AUDIOHD_REG_GCTL);
2287 if (gctl & AUDIOHDR_GCTL_CRST)
2288 break;
2289 }
2290
2291 if ((gctl & AUDIOHDR_GCTL_CRST) == 0) {
2292 audio_dev_warn(statep->adev,
2293 "failed to exit reset state");
2294 return (DDI_FAILURE);
2295 }
2296
2297 /* HD spec requires to wait 250us at least. we use 500us */
2298 drv_usecwait(500);
2299
2300 /* enable unsolicited response */
2301 AUDIOHD_REG_SET32(AUDIOHD_REG_GCTL,
2302 gctl | AUDIOHDR_GCTL_URESPE);
2303
2304 return (DDI_SUCCESS);
2305
2306 } /* audiohd_reset_controller() */
2307
2308 /*
2309 * audiohd_alloc_dma_mem()
2310 *
2311 * Description:
2312 * This is an utility routine. It is used to allocate DMA
2313 * memory.
2314 */
2315 static int
2316 audiohd_alloc_dma_mem(audiohd_state_t *statep, audiohd_dma_t *pdma,
2317 size_t memsize, ddi_dma_attr_t *dma_attr_p, uint_t dma_flags)
2318 {
2319 ddi_dma_cookie_t cookie;
2320 uint_t count;
2321 dev_info_t *dip = statep->hda_dip;
2322 audio_dev_t *ahandle = statep->adev;
2323
2324 if (ddi_dma_alloc_handle(dip, dma_attr_p, DDI_DMA_SLEEP,
2325 NULL, &pdma->ad_dmahdl) != DDI_SUCCESS) {
2326 audio_dev_warn(ahandle,
2327 "ddi_dma_alloc_handle failed");
2328 return (DDI_FAILURE);
2329 }
2330
2331 if (ddi_dma_mem_alloc(pdma->ad_dmahdl, memsize, &hda_dev_accattr,
2332 dma_flags & (DDI_DMA_CONSISTENT | DDI_DMA_STREAMING),
2333 DDI_DMA_SLEEP, NULL,
2334 (caddr_t *)&pdma->ad_vaddr, &pdma->ad_real_sz,
2335 &pdma->ad_acchdl) != DDI_SUCCESS) {
2336 audio_dev_warn(ahandle,
2337 "ddi_dma_mem_alloc failed");
2338 return (DDI_FAILURE);
2339 }
2340
2341 if (ddi_dma_addr_bind_handle(pdma->ad_dmahdl, NULL,
2342 (caddr_t)pdma->ad_vaddr, pdma->ad_real_sz, dma_flags,
2343 DDI_DMA_SLEEP, NULL, &cookie, &count) != DDI_DMA_MAPPED) {
2344 audio_dev_warn(ahandle,
2345 "ddi_dma_addr_bind_handle failed");
2346 return (DDI_FAILURE);
2347 }
2348
2349 pdma->ad_paddr = (uint64_t)(cookie.dmac_laddress);
2350 pdma->ad_req_sz = memsize;
2351
2352 return (DDI_SUCCESS);
2353 } /* audiohd_alloc_dma_mem() */
2354
2355 /*
2356 * audiohd_release_dma_mem()
2357 *
2358 * Description:
2359 * Release DMA memory.
2360 */
2361
2362 static void
2363 audiohd_release_dma_mem(audiohd_dma_t *pdma)
2364 {
2365 if (pdma->ad_dmahdl != NULL) {
2366 (void) ddi_dma_unbind_handle(pdma->ad_dmahdl);
2367 }
2368
2369 if (pdma->ad_acchdl != NULL) {
2370 ddi_dma_mem_free(&pdma->ad_acchdl);
2371 pdma->ad_acchdl = NULL;
2372 }
2373
2374 if (pdma->ad_dmahdl != NULL) {
2375 ddi_dma_free_handle(&pdma->ad_dmahdl);
2376 pdma->ad_dmahdl = NULL;
2377 }
2378
2379 } /* audiohd_release_dma_mem() */
2380
2381 /*
2382 * audiohd_reinit_hda()
2383 *
2384 * Description:
2385 * This routine is used to re-initialize HD controller and codec.
2386 */
2387 static int
2388 audiohd_reinit_hda(audiohd_state_t *statep)
2389 {
2390 uint64_t addr;
2391
2392 /* set PCI configure space in case it's not restored OK */
2393 (void) audiohd_init_pci(statep, &hda_dev_accattr);
2394
2395 /* reset controller */
2396 if (audiohd_reset_controller(statep) != DDI_SUCCESS)
2397 return (DDI_FAILURE);
2398 AUDIOHD_REG_SET32(AUDIOHD_REG_SYNC, 0); /* needn't sync stream */
2399
2400 /* Initialize controller RIRB */
2401 addr = statep->hda_dma_rirb.ad_paddr;
2402 AUDIOHD_REG_SET32(AUDIOHD_REG_RIRBLBASE, (uint32_t)addr);
2403 AUDIOHD_REG_SET32(AUDIOHD_REG_RIRBUBASE,
2404 (uint32_t)(addr >> 32));
2405 AUDIOHD_REG_SET16(AUDIOHD_REG_RIRBWP, AUDIOHDR_RIRBWP_RESET);
2406 AUDIOHD_REG_SET8(AUDIOHD_REG_RIRBSIZE, AUDIOHDR_RIRBSZ_256);
2407 AUDIOHD_REG_SET8(AUDIOHD_REG_RIRBCTL, AUDIOHDR_RIRBCTL_DMARUN |
2408 AUDIOHDR_RIRBCTL_RINTCTL);
2409
2410 /* Initialize controller CORB */
2411 addr = statep->hda_dma_corb.ad_paddr;
2412 AUDIOHD_REG_SET16(AUDIOHD_REG_CORBRP, AUDIOHDR_CORBRP_RESET);
2413 AUDIOHD_REG_SET32(AUDIOHD_REG_CORBLBASE, (uint32_t)addr);
2414 AUDIOHD_REG_SET32(AUDIOHD_REG_CORBUBASE,
2415 (uint32_t)(addr >> 32));
2416 AUDIOHD_REG_SET8(AUDIOHD_REG_CORBSIZE, AUDIOHDR_CORBSZ_256);
2417 AUDIOHD_REG_SET16(AUDIOHD_REG_CORBWP, 0);
2418 AUDIOHD_REG_SET16(AUDIOHD_REG_CORBRP, 0);
2419 AUDIOHD_REG_SET8(AUDIOHD_REG_CORBCTL, AUDIOHDR_CORBCTL_DMARUN);
2420
2421 audiohd_restore_codec_gpio(statep);
2422 audiohd_restore_path(statep);
2423 audiohd_init_path(statep);
2424
2425 return (DDI_SUCCESS);
2426 } /* audiohd_reinit_hda */
2427
2428 /*
2429 * audiohd_init_controller()
2430 *
2431 * Description:
2432 * This routine is used to initialize HD controller. It
2433 * allocates DMA memory for CORB/RIRB, buffer descriptor
2434 * list and cylic data buffer for both play and record
2435 * stream.
2436 */
2437 static int
2438 audiohd_init_controller(audiohd_state_t *statep)
2439 {
2440 uint64_t addr;
2441 uint16_t gcap;
2442 int retval;
2443
2444 ddi_dma_attr_t dma_attr = {
2445 DMA_ATTR_V0, /* version */
2446 0, /* addr_lo */
2447 0xffffffffffffffffULL, /* addr_hi */
2448 0x00000000ffffffffULL, /* count_max */
2449 128, /* 128-byte alignment as HD spec */
2450 0xfff, /* burstsize */
2451 1, /* minxfer */
2452 0xffffffff, /* maxxfer */
2453 0xffffffff, /* seg */
2454 1, /* sgllen */
2455 1, /* granular */
2456 0 /* flags */
2457 };
2458
2459 gcap = AUDIOHD_REG_GET16(AUDIOHD_REG_GCAP);
2460
2461 /*
2462 * If the device doesn't support 64-bit DMA, we should not
2463 * allocate DMA memory from 4G above
2464 */
2465 if ((gcap & AUDIOHDR_GCAP_64OK) == 0)
2466 dma_attr.dma_attr_addr_hi = 0xffffffffUL;
2467
2468 statep->hda_input_streams = (gcap & AUDIOHDR_GCAP_INSTREAMS) >>
2469 AUDIOHD_INSTR_NUM_OFF;
2470 statep->hda_output_streams = (gcap & AUDIOHDR_GCAP_OUTSTREAMS) >>
2471 AUDIOHD_OUTSTR_NUM_OFF;
2472 statep->hda_streams_nums = statep->hda_input_streams +
2473 statep->hda_output_streams;
2474
2475 statep->hda_record_regbase = AUDIOHD_REG_SD_BASE;
2476 statep->hda_play_regbase = AUDIOHD_REG_SD_BASE + AUDIOHD_REG_SD_LEN *
2477 statep->hda_input_streams;
2478
2479 /* stop all dma before starting to reset controller */
2480 audiohd_stop_dma(statep);
2481
2482 if (audiohd_reset_controller(statep) != DDI_SUCCESS)
2483 return (DDI_FAILURE);
2484
2485 /* check codec */
2486 statep->hda_codec_mask = AUDIOHD_REG_GET16(AUDIOHD_REG_STATESTS);
2487 if (!statep->hda_codec_mask) {
2488 audio_dev_warn(statep->adev,
2489 "no codec exists");
2490 return (DDI_FAILURE);
2491 }
2492
2493 /* allocate DMA for CORB */
2494 retval = audiohd_alloc_dma_mem(statep, &statep->hda_dma_corb,
2495 AUDIOHD_CDBIO_CORB_LEN, &dma_attr,
2496 DDI_DMA_WRITE | DDI_DMA_STREAMING);
2497 if (retval != DDI_SUCCESS) {
2498 audio_dev_warn(statep->adev,
2499 "failed to alloc DMA for CORB");
2500 return (DDI_FAILURE);
2501 }
2502
2503 /* allocate DMA for RIRB */
2504 retval = audiohd_alloc_dma_mem(statep, &statep->hda_dma_rirb,
2505 AUDIOHD_CDBIO_RIRB_LEN, &dma_attr,
2506 DDI_DMA_READ | DDI_DMA_STREAMING);
2507 if (retval != DDI_SUCCESS) {
2508 audio_dev_warn(statep->adev,
2509 "failed to alloc DMA for RIRB");
2510 return (DDI_FAILURE);
2511 }
2512
2513 AUDIOHD_REG_SET32(AUDIOHD_REG_SYNC, 0); /* needn't sync stream */
2514
2515 /* Initialize RIRB */
2516 addr = statep->hda_dma_rirb.ad_paddr;
2517 AUDIOHD_REG_SET32(AUDIOHD_REG_RIRBLBASE, (uint32_t)addr);
2518 AUDIOHD_REG_SET32(AUDIOHD_REG_RIRBUBASE, (uint32_t)(addr >> 32));
2519 AUDIOHD_REG_SET16(AUDIOHD_REG_RIRBWP, AUDIOHDR_RIRBWP_RESET);
2520 AUDIOHD_REG_SET8(AUDIOHD_REG_RIRBSIZE, AUDIOHDR_RIRBSZ_256);
2521 AUDIOHD_REG_SET8(AUDIOHD_REG_RIRBCTL, AUDIOHDR_RIRBCTL_DMARUN |
2522 AUDIOHDR_RIRBCTL_RINTCTL);
2523
2524 /* initialize CORB */
2525 addr = statep->hda_dma_corb.ad_paddr;
2526 AUDIOHD_REG_SET16(AUDIOHD_REG_CORBRP, AUDIOHDR_CORBRP_RESET);
2527 AUDIOHD_REG_SET32(AUDIOHD_REG_CORBLBASE, (uint32_t)addr);
2528 AUDIOHD_REG_SET32(AUDIOHD_REG_CORBUBASE, (uint32_t)(addr >> 32));
2529 AUDIOHD_REG_SET8(AUDIOHD_REG_CORBSIZE, AUDIOHDR_CORBSZ_256);
2530 AUDIOHD_REG_SET16(AUDIOHD_REG_CORBWP, 0);
2531 AUDIOHD_REG_SET16(AUDIOHD_REG_CORBRP, 0);
2532 AUDIOHD_REG_SET8(AUDIOHD_REG_CORBCTL, AUDIOHDR_CORBCTL_DMARUN);
2533
2534 return (DDI_SUCCESS);
2535 } /* audiohd_init_controller() */
2536
2537 /*
2538 * audiohd_fini_controller()
2539 *
2540 * Description:
2541 * Releases DMA memory allocated in audiohd_init_controller()
2542 */
2543 static void
2544 audiohd_fini_controller(audiohd_state_t *statep)
2545 {
2546 audiohd_release_dma_mem(&statep->hda_dma_rirb);
2547 audiohd_release_dma_mem(&statep->hda_dma_corb);
2548
2549 } /* audiohd_fini_controller() */
2550
2551 /*
2552 * audiohd_get_conns_from_entry()
2553 *
2554 * Description:
2555 * Get connection list from every entry for a widget
2556 */
2557 static void
2558 audiohd_get_conns_from_entry(hda_codec_t *codec, audiohd_widget_t *widget,
2559 uint32_t entry, audiohd_entry_prop_t *prop)
2560 {
2561 int i, k, num;
2562 wid_t input_wid;
2563
2564 for (i = 0; i < prop->conns_per_entry &&
2565 widget->nconns < prop->conn_len;
2566 i++, entry >>= prop->bits_per_conn) {
2567 ASSERT(widget->nconns < AUDIOHD_MAX_CONN);
2568 input_wid = entry & prop->mask_wid;
2569 if (entry & prop->mask_range) {
2570 if (widget->nconns == 0) {
2571 if (input_wid < codec->first_wid ||
2572 (input_wid > codec->last_wid)) {
2573 break;
2574 }
2575 widget->avail_conn[widget->nconns++] =
2576 input_wid;
2577 } else {
2578 for (k = widget->avail_conn[widget->nconns-1] +
2579 1; k <= input_wid; k++) {
2580 ASSERT(widget->nconns <
2581 AUDIOHD_MAX_CONN);
2582 if (k < codec->first_wid ||
2583 (k > codec->last_wid)) {
2584 break;
2585 } else {
2586 num = widget->nconns;
2587 widget->avail_conn[num] = k;
2588 widget->nconns++;
2589 }
2590 }
2591 }
2592 } else {
2593 if ((codec->first_wid <= input_wid) && (input_wid <=
2594 codec->last_wid))
2595 widget->avail_conn[widget->nconns++] =
2596 input_wid;
2597 }
2598 }
2599 }
2600
2601 /*
2602 * audiohd_get_conns()
2603 *
2604 * Description:
2605 * Get all connection list for a widget. The connection list is used for
2606 * build output path, input path, and monitor path
2607 */
2608 static void
2609 audiohd_get_conns(hda_codec_t *codec, wid_t wid)
2610 {
2611 audiohd_state_t *statep = codec->statep;
2612 audiohd_widget_t *widget = codec->widget[wid];
2613 uint8_t caddr = codec->index;
2614 uint32_t entry;
2615 audiohd_entry_prop_t prop;
2616 wid_t input_wid;
2617 int i;
2618
2619 prop.conn_len = audioha_codec_verb_get(statep, caddr, wid,
2620 AUDIOHDC_VERB_GET_PARAM, AUDIOHDC_PAR_CONNLIST_LEN);
2621
2622 if (prop.conn_len & AUDIOHD_FORM_MASK) {
2623 prop.conns_per_entry = 2;
2624 prop.bits_per_conn = 16;
2625 prop.mask_range = 0x00008000;
2626 prop.mask_wid = 0x00007fff;
2627 } else {
2628 prop.conns_per_entry = 4;
2629 prop.bits_per_conn = 8;
2630 prop.mask_range = 0x00000080;
2631 prop.mask_wid = 0x0000007f;
2632 }
2633 prop.conn_len &= AUDIOHD_LEN_MASK;
2634
2635 /*
2636 * This should not happen since the ConnectionList bit of
2637 * widget capabilities already told us that this widget
2638 * has a connection list
2639 */
2640 if (prop.conn_len == 0) {
2641 widget->nconns = 0;
2642 audio_dev_warn(statep->adev,
2643 "node %d has 0 connections", wid);
2644 return;
2645 }
2646
2647 if (prop.conn_len == 1) {
2648 entry = audioha_codec_verb_get(statep, caddr,
2649 wid, AUDIOHDC_VERB_GET_CONN_LIST_ENT, 0);
2650 input_wid = entry & prop.mask_wid;
2651 if ((input_wid < codec->first_wid) ||
2652 (input_wid > codec->last_wid)) {
2653 return;
2654 }
2655 widget->avail_conn[0] = input_wid;
2656 widget->nconns = 1;
2657 return;
2658 }
2659 widget->nconns = 0;
2660 for (i = 0; i < prop.conn_len; i += prop.conns_per_entry) {
2661 entry = audioha_codec_verb_get(statep, caddr, wid,
2662 AUDIOHDC_VERB_GET_CONN_LIST_ENT, i);
2663 audiohd_get_conns_from_entry(codec, widget, entry, &prop);
2664 }
2665 }
2666
2667 /*
2668 * Read PinCapabilities & default configuration
2669 */
2670 static void
2671 audiohd_get_pin_config(audiohd_widget_t *widget)
2672 {
2673 hda_codec_t *codec = widget->codec;
2674 audiohd_state_t *statep = codec->statep;
2675 audiohd_pin_t *pin, *prev, *p;
2676
2677 int caddr = codec->index;
2678 wid_t wid = widget->wid_wid;
2679 uint32_t cap, config, pinctrl;
2680 uint8_t urctrl, vrefbits;
2681
2682 cap = audioha_codec_verb_get(statep, caddr, wid,
2683 AUDIOHDC_VERB_GET_PARAM, AUDIOHDC_PAR_PIN_CAP);
2684 config = audioha_codec_verb_get(statep, caddr,
2685 wid, AUDIOHDC_VERB_GET_DEFAULT_CONF, 0);
2686 pinctrl = audioha_codec_verb_get(statep, caddr,
2687 wid, AUDIOHDC_VERB_GET_PIN_CTRL, 0);
2688
2689 pin = (audiohd_pin_t *)kmem_zalloc(sizeof (audiohd_pin_t), KM_SLEEP);
2690 widget->priv = pin;
2691
2692 /*
2693 * If the pin has no physical connection for port,
2694 * we won't link it to pin linkage list ???
2695 */
2696 if (((config >> AUDIOHD_PIN_CON_STEP) & AUDIOHD_PIN_CON_MASK) == 0x1) {
2697 pin->no_phys_conn = 1;
2698 }
2699
2700 /* bit 4:3 are reserved, read-modify-write is needed */
2701 pin->ctrl = pinctrl & AUDIOHD_PIN_IO_MASK;
2702 pin->wid = wid;
2703 pin->cap = cap;
2704 pin->config = config;
2705 pin->num = 0;
2706 pin->finish = 0;
2707
2708 vrefbits = (cap >> AUDIOHD_PIN_VREF_OFF) & AUDIOHD_PIN_VREF_MASK;
2709 if (vrefbits & AUDIOHD_PIN_VREF_L1)
2710 pin->vrefvalue = 0x5;
2711 else if (vrefbits & AUDIOHD_PIN_VREF_L2)
2712 pin->vrefvalue = 0x4;
2713 else if (vrefbits & AUDIOHD_PIN_VREF_L3)
2714 pin->vrefvalue = 0x2;
2715 else
2716 pin->vrefvalue = 0x1;
2717
2718 pin->seq = config & AUDIOHD_PIN_SEQ_MASK;
2719 pin->assoc = (config & AUDIOHD_PIN_ASO_MASK) >> AUDIOHD_PIN_ASO_OFF;
2720 pin->device = (config & AUDIOHD_PIN_DEV_MASK) >> AUDIOHD_PIN_DEV_OFF;
2721
2722 /* enable the unsolicited response of the pin */
2723 if ((widget->widget_cap & AUDIOHD_URCAP_MASK) &&
2724 (pin->cap & AUDIOHD_DTCCAP_MASK) &&
2725 ((pin->device == DTYPE_LINEOUT) ||
2726 (pin->device == DTYPE_SPDIF_OUT) ||
2727 (pin->device == DTYPE_HP_OUT) ||
2728 (pin->device == DTYPE_MIC_IN))) {
2729 urctrl = (uint8_t)(1 << (AUDIOHD_UR_ENABLE_OFF - 1));
2730 urctrl |= (wid & AUDIOHD_UR_TAG_MASK);
2731 (void) audioha_codec_verb_get(statep, caddr,
2732 wid, AUDIOHDC_VERB_SET_UNS_ENABLE, urctrl);
2733 }
2734 /* accommodate all the pins in a link list sorted by assoc and seq */
2735 if (codec->first_pin == NULL) {
2736 codec->first_pin = pin;
2737 } else {
2738 prev = NULL;
2739 p = codec->first_pin;
2740 while (p) {
2741 if (p->assoc > pin->assoc)
2742 break;
2743 if ((p->assoc == pin->assoc) &&
2744 (p->seq > pin->seq))
2745 break;
2746 prev = p;
2747 p = p->next;
2748 }
2749 if (prev) {
2750 pin->next = prev->next;
2751 prev->next = pin;
2752 } else {
2753 pin->next = codec->first_pin;
2754 codec->first_pin = pin;
2755 }
2756 }
2757
2758 } /* audiohd_get_pin_config() */
2759
2760 /*
2761 * audiohd_create_widgets()
2762 *
2763 * Description:
2764 * All widgets are created and stored in an array of codec
2765 */
2766 static int
2767 audiohd_create_widgets(hda_codec_t *codec)
2768 {
2769 audiohd_widget_t *widget;
2770 audiohd_state_t *statep = codec->statep;
2771 wid_t wid;
2772 uint32_t type, widcap;
2773 int caddr = codec->index;
2774
2775 for (wid = codec->first_wid;
2776 wid <= codec->last_wid; wid++) {
2777 widget = (audiohd_widget_t *)
2778 kmem_zalloc(sizeof (audiohd_widget_t), KM_SLEEP);
2779 codec->widget[wid] = widget;
2780 widget->codec = codec;
2781 widget->output_path_next = AUDIOHD_NULL_CONN;
2782 widget->input_path_next = AUDIOHD_NULL_CONN;
2783 widget->beep_path_next = AUDIOHD_NULL_CONN;
2784 widget->loopback_path_next = AUDIOHD_NULL_CONN;
2785
2786 widcap = audioha_codec_verb_get(statep, caddr, wid,
2787 AUDIOHDC_VERB_GET_PARAM, AUDIOHDC_PAR_AUDIO_WID_CAP);
2788 type = AUDIOHD_WIDCAP_TO_WIDTYPE(widcap);
2789 widget->wid_wid = wid;
2790 widget->type = type;
2791 widget->widget_cap = widcap;
2792 widget->finish = 0;
2793 widget->used = 0;
2794
2795 /* if there's connection list */
2796 if (widcap & AUDIOHD_WIDCAP_CONNLIST) {
2797 audiohd_get_conns(codec, wid);
2798 }
2799
2800 /* if power control, power it up to D0 state */
2801 if (widcap & AUDIOHD_WIDCAP_PWRCTRL) {
2802 (void) audioha_codec_verb_get(statep, caddr, wid,
2803 AUDIOHDC_VERB_SET_POWER_STATE, 0);
2804 }
2805
2806 /*
2807 * if this widget has format override, we read it.
2808 * Otherwise, it uses the format of audio function.
2809 */
2810 if (widcap & AUDIOHD_WIDCAP_FMT_OVRIDE) {
2811 widget->pcm_format =
2812 audioha_codec_verb_get(statep, caddr, wid,
2813 AUDIOHDC_VERB_GET_PARAM, AUDIOHDC_PAR_PCM);
2814 } else {
2815 widget->pcm_format = codec->pcm_format;
2816 }
2817
2818 /*
2819 * Input amplifier. Has the widget input amplifier ?
2820 */
2821 if (widcap & AUDIOHD_WIDCAP_INAMP) {
2822 /*
2823 * if overrided bit is 0, use the default
2824 * amplifier of audio function as HD spec.
2825 * Otherwise, we read it.
2826 */
2827 if ((widcap & AUDIOHD_WIDCAP_AMP_OVRIDE) == 0)
2828 widget->inamp_cap = codec->inamp_cap;
2829 else
2830 widget->inamp_cap =
2831 audioha_codec_verb_get(statep, caddr, wid,
2832 AUDIOHDC_VERB_GET_PARAM,
2833 AUDIOHDC_PAR_INAMP_CAP);
2834 } else {
2835 widget->inamp_cap = 0;
2836 }
2837
2838 /*
2839 * output amplifier. Has this widget output amplifier ?
2840 */
2841 if (widcap & AUDIOHD_WIDCAP_OUTAMP) {
2842 if ((widcap & AUDIOHD_WIDCAP_AMP_OVRIDE) == 0)
2843 widget->outamp_cap = codec->outamp_cap;
2844 else
2845 widget->outamp_cap =
2846 audioha_codec_verb_get(statep, caddr, wid,
2847 AUDIOHDC_VERB_GET_PARAM,
2848 AUDIOHDC_PAR_OUTAMP_CAP);
2849 } else {
2850 widget->outamp_cap = 0;
2851 }
2852
2853 switch (type) {
2854 case WTYPE_AUDIO_OUT:
2855 case WTYPE_AUDIO_IN:
2856 case WTYPE_AUDIO_MIX:
2857 case WTYPE_AUDIO_SEL:
2858 case WTYPE_VENDOR:
2859 case WTYPE_POWER:
2860 case WTYPE_VOL_KNOB:
2861 break;
2862 case WTYPE_PIN:
2863 /*
2864 * Some codec(like ALC262) don't provide beep widget,
2865 * it only has input Pin to connect an external beep
2866 * (maybe in motherboard or elsewhere). So we open
2867 * all PINs here in order to enable external beep
2868 * source.
2869 */
2870 if ((codec->codec_info->flags & EN_PIN_BEEP) == 0) {
2871 (void) audioha_codec_4bit_verb_get(statep,
2872 caddr, widget->wid_wid,
2873 AUDIOHDC_VERB_SET_AMP_MUTE,
2874 AUDIOHDC_AMP_SET_LR_OUTPUT |
2875 AUDIOHDC_GAIN_MAX);
2876 }
2877
2878 audiohd_get_pin_config(widget);
2879 break;
2880 case WTYPE_BEEP:
2881 /*
2882 * Get the audiohd_beep_switch value from audiohd.conf,
2883 * which is for turning on/off widget beep.
2884 */
2885 audiohd_beep = ddi_prop_get_int(DDI_DEV_T_ANY,
2886 statep->hda_dip,
2887 DDI_PROP_DONTPASS, "audiohd_beep", 1);
2888
2889 if (audiohd_beep) {
2890 (void) beep_fini();
2891 (void) beep_init((void *) widget,
2892 audiohd_beep_on,
2893 audiohd_beep_off,
2894 audiohd_beep_freq);
2895 }
2896 break;
2897 default:
2898 break;
2899 }
2900 }
2901
2902 return (DDI_SUCCESS);
2903
2904 } /* audiohd_create_widgets() */
2905
2906 /*
2907 * audiohd_destroy_widgets()
2908 */
2909 static void
2910 audiohd_destroy_widgets(hda_codec_t *codec)
2911 {
2912 for (int i = 0; i < AUDIOHD_MAX_WIDGET; i++) {
2913 if (codec->widget[i]) {
2914 kmem_free(codec->widget[i], sizeof (audiohd_widget_t));
2915 codec->widget[i] = NULL;
2916 }
2917 }
2918
2919 } /* audiohd_destroy_widgets() */
2920
2921 /*
2922 * audiohd_create_codec()
2923 *
2924 * Description:
2925 * Searching for supported CODEC. If find, allocate memory
2926 * to hold codec structure.
2927 */
2928 static int
2929 audiohd_create_codec(audiohd_state_t *statep)
2930 {
2931 hda_codec_t *codec;
2932 uint32_t mask, type;
2933 uint32_t nums;
2934 uint32_t i, j, len;
2935 wid_t wid;
2936 char buf[128];
2937 int rate, bits;
2938 dev_info_t *dip = statep->hda_dip;
2939
2940
2941 mask = statep->hda_codec_mask;
2942 ASSERT(mask != 0);
2943
2944 for (i = 0; i < AUDIOHD_CODEC_MAX; i++) {
2945 if ((mask & (1 << i)) == 0)
2946 continue;
2947 codec = (hda_codec_t *)kmem_zalloc(
2948 sizeof (hda_codec_t), KM_SLEEP);
2949 codec->index = i;
2950 codec->vid = audioha_codec_verb_get(statep, i,
2951 AUDIOHDC_NODE_ROOT, AUDIOHDC_VERB_GET_PARAM,
2952 AUDIOHDC_PAR_VENDOR_ID);
2953 if (codec->vid == (uint32_t)(-1)) {
2954 kmem_free(codec, sizeof (hda_codec_t));
2955 continue;
2956 }
2957
2958 codec->revid =
2959 audioha_codec_verb_get(statep, i,
2960 AUDIOHDC_NODE_ROOT, AUDIOHDC_VERB_GET_PARAM,
2961 AUDIOHDC_PAR_REV_ID);
2962
2963 nums = audioha_codec_verb_get(statep,
2964 i, AUDIOHDC_NODE_ROOT,
2965 AUDIOHDC_VERB_GET_PARAM, AUDIOHDC_PAR_NODE_COUNT);
2966 if (nums == (uint32_t)(-1)) {
2967 kmem_free(codec, sizeof (hda_codec_t));
2968 continue;
2969 }
2970 wid = (nums >> AUDIOHD_CODEC_STR_OFF) & AUDIOHD_CODEC_STR_MASK;
2971 nums = nums & AUDIOHD_CODEC_NUM_MASK;
2972
2973 /*
2974 * Assume that each codec has just one audio function group
2975 */
2976 for (j = 0; j < nums; j++, wid++) {
2977 type = audioha_codec_verb_get(statep, i, wid,
2978 AUDIOHDC_VERB_GET_PARAM,
2979 AUDIOHDC_PAR_FUNCTION_TYPE);
2980 if ((type & AUDIOHD_CODEC_TYPE_MASK) ==
2981 AUDIOHDC_AUDIO_FUNC_GROUP) {
2982 codec->wid_afg = wid;
2983 break;
2984 }
2985 }
2986
2987 if (codec->wid_afg == 0) {
2988 kmem_free(codec, sizeof (hda_codec_t));
2989 continue;
2990 }
2991
2992 ASSERT(codec->wid_afg == wid);
2993
2994 len = sizeof (audiohd_codecs) / sizeof (audiohd_codec_info_t);
2995 for (j = 0; j < len-1; j++) {
2996 if (audiohd_codecs[j].devid == codec->vid) {
2997 codec->codec_info = &(audiohd_codecs[j]);
2998 break;
2999 }
3000 }
3001
3002 if (codec->codec_info == NULL) {
3003 codec->codec_info = &(audiohd_codecs[len-1]);
3004 (void) snprintf(buf, sizeof (buf),
3005 "Unknown HD codec: 0x%x", codec->vid);
3006 } else {
3007 (void) snprintf(buf, sizeof (buf), "HD codec: %s",
3008 codec->codec_info->buf);
3009 }
3010 audio_dev_add_info(statep->adev, buf);
3011
3012 /* work around for Sony VAIO laptop with specific codec */
3013 if ((codec->codec_info->flags & NO_GPIO) == 0) {
3014 /*
3015 * GPIO controls which are laptop specific workarounds
3016 * and might be changed. Some laptops use GPIO,
3017 * so we need to enable and set the GPIO correctly.
3018 */
3019 (void) audioha_codec_verb_get(statep, i, wid,
3020 AUDIOHDC_VERB_SET_GPIO_MASK, AUDIOHDC_GPIO_ENABLE);
3021 (void) audioha_codec_verb_get(statep, i, wid,
3022 AUDIOHDC_VERB_SET_UNSOL_ENABLE_MASK,
3023 AUDIOHDC_GPIO_ENABLE);
3024 (void) audioha_codec_verb_get(statep, i, wid,
3025 AUDIOHDC_VERB_SET_GPIO_DIREC, AUDIOHDC_GPIO_DIRECT);
3026 (void) audioha_codec_verb_get(statep, i, wid,
3027 AUDIOHDC_VERB_SET_GPIO_STCK,
3028 AUDIOHDC_GPIO_DATA_CTRL);
3029 (void) audioha_codec_verb_get(statep, i, wid,
3030 AUDIOHDC_VERB_SET_GPIO_DATA,
3031 AUDIOHDC_GPIO_STCK_CTRL);
3032 }
3033
3034 /* power-up audio function group */
3035 (void) audioha_codec_verb_get(statep, i, wid,
3036 AUDIOHDC_VERB_SET_POWER_STATE, AUDIOHD_PW_D0);
3037
3038 /* subsystem id is attached to funtion group */
3039 codec->outamp_cap = audioha_codec_verb_get(statep, i, wid,
3040 AUDIOHDC_VERB_GET_PARAM, AUDIOHDC_PAR_OUTAMP_CAP);
3041 codec->inamp_cap = audioha_codec_verb_get(statep, i, wid,
3042 AUDIOHDC_VERB_GET_PARAM, AUDIOHDC_PAR_INAMP_CAP);
3043 codec->stream_format = audioha_codec_verb_get(statep, i, wid,
3044 AUDIOHDC_VERB_GET_PARAM, AUDIOHDC_PAR_STREAM);
3045 codec->pcm_format = audioha_codec_verb_get(statep, i, wid,
3046 AUDIOHDC_VERB_GET_PARAM, AUDIOHDC_PAR_PCM);
3047
3048 statep->sample_rate = 48000;
3049 rate = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
3050 DDI_PROP_DONTPASS, "sample-rate", 48000);
3051 if (rate == 192000 &&
3052 (codec->pcm_format & AUDIOHD_SAMP_RATE192)) {
3053 statep->sample_rate = 192000;
3054 } else if (rate == 96000 &&
3055 (codec->pcm_format & AUDIOHD_SAMP_RATE96)) {
3056 statep->sample_rate = 96000;
3057 } else {
3058 statep->sample_rate = 48000;
3059 }
3060
3061 statep->sample_bit_depth = AUDIOHD_BIT_DEPTH16;
3062 bits = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
3063 DDI_PROP_DONTPASS, "sample-bits", 16);
3064 if (bits == 24 &&
3065 (codec->pcm_format & AUDIOHD_BIT_DEPTH24)) {
3066 statep->sample_bit_depth = AUDIOHD_BIT_DEPTH24;
3067 } else {
3068 statep->sample_bit_depth = AUDIOHD_BIT_DEPTH16;
3069 }
3070
3071 nums = audioha_codec_verb_get(statep, i, wid,
3072 AUDIOHDC_VERB_GET_PARAM,
3073 AUDIOHDC_PAR_NODE_COUNT);
3074 wid = (nums >> AUDIOHD_CODEC_STR_OFF) & AUDIOHD_CODEC_STR_MASK;
3075 nums = nums & AUDIOHD_CODEC_NUM_MASK;
3076 codec->first_wid = wid;
3077 codec->last_wid = wid + nums;
3078 codec->nnodes = nums;
3079
3080 /*
3081 * We output the codec information to syslog
3082 */
3083 statep->codec[i] = codec;
3084 codec->statep = statep;
3085 (void) audiohd_create_widgets(codec);
3086 }
3087
3088 return (DDI_SUCCESS);
3089
3090 } /* audiohd_create_codec() */
3091
3092 /*
3093 * audiohd_destroy_codec()
3094 *
3095 * Description:
3096 * destroy codec structure, and release its memory
3097 */
3098 static void
3099 audiohd_destroy_codec(audiohd_state_t *statep)
3100 {
3101 int i;
3102 audiohd_pin_t *pin, *npin;
3103
3104 for (i = 0; i < AUDIOHD_CODEC_MAX; i++) {
3105 if (statep->codec[i]) {
3106 audiohd_destroy_widgets(statep->codec[i]);
3107 /*
3108 * free pins
3109 */
3110 pin = statep->codec[i]->first_pin;
3111 while (pin) {
3112 npin = pin;
3113 pin = pin->next;
3114 kmem_free(npin, sizeof (audiohd_pin_t));
3115 }
3116
3117 kmem_free(statep->codec[i], sizeof (hda_codec_t));
3118 statep->codec[i] = NULL;
3119 }
3120 }
3121 } /* audiohd_destroy_codec() */
3122
3123 /*
3124 * audiohd_find_dac()
3125 * Description:
3126 * Find a dac for a output path. Then the play data can be sent to the out
3127 * put pin through the output path.
3128 *
3129 * Arguments:
3130 * hda_codec_t *codec where the dac widget exists
3131 * wid_t wid the no. of a widget
3132 * int mixer whether the path need mixer or not
3133 * int *mixernum the total of mixer in the output path
3134 * int exclusive an exclusive path or share path
3135 * int depth the depth of search
3136 *
3137 * Return:
3138 * 1) wid of the first shared widget in the path from
3139 * pin to DAC if exclusive is 0;
3140 * 2) wid of DAC widget;
3141 * 3) 0 if no path
3142 */
3143 static wid_t
3144 audiohd_find_dac(hda_codec_t *codec, wid_t wid,
3145 int mixer, int *mixernum,
3146 int exclusive, int depth)
3147 {
3148 audiohd_widget_t *widget = codec->widget[wid];
3149 wid_t wdac = (uint32_t)(DDI_FAILURE);
3150 wid_t retval;
3151
3152 if (depth > AUDIOHD_MAX_DEPTH)
3153 return (uint32_t)(DDI_FAILURE);
3154
3155 if (widget == NULL)
3156 return (uint32_t)(DDI_FAILURE);
3157
3158 /*
3159 * If exclusive is true, we try to find a path which doesn't
3160 * share any widget with other paths.
3161 */
3162 if (exclusive) {
3163 if (widget->path_flags & AUDIOHD_PATH_DAC)
3164 return (uint32_t)(DDI_FAILURE);
3165 } else {
3166 if (widget->path_flags & AUDIOHD_PATH_DAC)
3167 return (wid);
3168 }
3169
3170 switch (widget->type) {
3171 case WTYPE_AUDIO_OUT:
3172 /* We need mixer widget, but the the mixer num is 0, failed */
3173 if (mixer && !*mixernum)
3174 return (uint32_t)(DDI_FAILURE);
3175 widget->path_flags |= AUDIOHD_PATH_DAC;
3176 widget->out_weight++;
3177 wdac = widget->wid_wid;
3178 break;
3179
3180 case WTYPE_AUDIO_MIX:
3181 (*mixernum)++;
3182 /* FALLTHRU */
3183 case WTYPE_AUDIO_SEL:
3184 for (int i = 0; i < widget->nconns; i++) {
3185 retval = audiohd_find_dac(codec,
3186 widget->avail_conn[i],
3187 mixer, mixernum,
3188 exclusive, depth + 1);
3189 if (retval != (uint32_t)DDI_FAILURE) {
3190 if (widget->output_path_next ==
3191 AUDIOHD_NULL_CONN) {
3192 widget->output_path_next = i;
3193 wdac = retval;
3194 }
3195 widget->path_flags |= AUDIOHD_PATH_DAC;
3196 widget->out_weight++;
3197
3198 /* return when found a path */
3199 return (wdac);
3200 }
3201 }
3202 default:
3203 break;
3204 }
3205
3206 return (wdac);
3207 } /* audiohd_find_dac() */
3208
3209 /*
3210 * audiohd_do_build_output_path()
3211 *
3212 * Description:
3213 * Search an output path for each pin in the codec.
3214 * Arguments:
3215 * hda_codec_t *codec where the output path exists
3216 * int mixer whether the path needs mixer widget
3217 * int *mnum total of mixer widget in the path
3218 * int exclusive an exclusive path or shared path
3219 * int depth search depth
3220 */
3221 static void
3222 audiohd_do_build_output_path(hda_codec_t *codec, int mixer, int *mnum,
3223 int exclusive, int depth)
3224 {
3225 audiohd_pin_t *pin;
3226 audiohd_widget_t *widget, *wdac;
3227 audiohd_path_t *path;
3228 wid_t wid;
3229 audiohd_state_t *statep;
3230 int i;
3231
3232 statep = codec->statep;
3233
3234 for (pin = codec->first_pin; pin; pin = pin->next) {
3235 if ((pin->cap & AUDIOHD_PIN_CAP_MASK) == 0)
3236 continue;
3237 if ((pin->config & AUDIOHD_PIN_CONF_MASK) ==
3238 AUDIOHD_PIN_NO_CONN)
3239 continue;
3240 if ((pin->device != DTYPE_LINEOUT) &&
3241 (pin->device != DTYPE_SPEAKER) &&
3242 (pin->device != DTYPE_SPDIF_OUT) &&
3243 (pin->device != DTYPE_HP_OUT))
3244 continue;
3245 if (pin->finish)
3246 continue;
3247 widget = codec->widget[pin->wid];
3248
3249 widget->inamp_cap = 0;
3250 for (i = 0; i < widget->nconns; i++) {
3251 /*
3252 * If a dac found, the return value is the wid of the
3253 * widget on the path, or the return value is
3254 * DDI_FAILURE
3255 */
3256 wid = audiohd_find_dac(codec,
3257 widget->avail_conn[i], mixer, mnum, exclusive,
3258 depth);
3259 /*
3260 * A dac was not found
3261 */
3262 if (wid == (wid_t)DDI_FAILURE)
3263 continue;
3264 if (pin->device != DTYPE_SPEAKER &&
3265 pin->device != DTYPE_HP_OUT)
3266 statep->chann[pin->assoc] += 2;
3267 path = (audiohd_path_t *)
3268 kmem_zalloc(sizeof (audiohd_path_t),
3269 KM_SLEEP);
3270 path->adda_wid = wid;
3271 path->pin_wid[0] = widget->wid_wid;
3272 path->pin_nums = 1;
3273 path->path_type = PLAY;
3274 path->codec = codec;
3275 path->statep = statep;
3276 wdac = codec->widget[wid];
3277 wdac->priv = path;
3278 pin->dac_wid = wid;
3279 pin->finish = 1;
3280 widget->path_flags |= AUDIOHD_PATH_DAC;
3281 widget->out_weight++;
3282 widget->output_path_next = i;
3283 statep->path[statep->pathnum++] = path;
3284 break;
3285 }
3286 }
3287
3288 } /* audiohd_do_build_output_path() */
3289
3290 /*
3291 * audiohd_build_output_path()
3292 *
3293 * Description:
3294 * Build the output path in the codec for every pin.
3295 * First we try to search output path with mixer widget exclusively
3296 * Then we try to search shared output path with mixer widget.
3297 * Then we try to search output path without mixer widget exclusively.
3298 * At last we try to search shared ouput path for the remained pins
3299 */
3300 static void
3301 audiohd_build_output_path(hda_codec_t *codec)
3302 {
3303 int mnum = 0;
3304 uint8_t mixer_allow = 1;
3305
3306 /*
3307 * Work around for laptops which have IDT or AD audio chipset, such as
3308 * HP mini 1000 laptop, Dell Lattitude 6400, Lenovo T60, Lenove R61e.
3309 * We don't allow mixer widget on such path, which leads to speaker
3310 * loud hiss noise.
3311 */
3312 if (codec->codec_info->flags & NO_MIXER)
3313 mixer_allow = 0;
3314
3315 /* search an exclusive mixer widget path. This is preferred */
3316 audiohd_do_build_output_path(codec, mixer_allow, &mnum, 1, 0);
3317
3318 /* search a shared mixer widget path for the remained pins */
3319 audiohd_do_build_output_path(codec, mixer_allow, &mnum, 0, 0);
3320
3321 /* search an exclusive widget path without mixer for the remained pin */
3322 audiohd_do_build_output_path(codec, 0, &mnum, 1, 0);
3323
3324 /* search a shared widget path without mixer for the remained pin */
3325 audiohd_do_build_output_path(codec, 0, &mnum, 0, 0);
3326
3327 } /* audiohd_build_output_path */
3328
3329 /*
3330 * audiohd_build_output_amp
3331 *
3332 * Description:
3333 * Find the gain control and mute control widget
3334 */
3335 static void
3336 audiohd_build_output_amp(hda_codec_t *codec)
3337 {
3338 audiohd_path_t *path;
3339 audiohd_widget_t *w, *widget, *wpin, *wdac;
3340 audiohd_pin_t *pin;
3341 wid_t wid, next;
3342 int weight;
3343 int i, j;
3344 uint32_t gain;
3345
3346 for (i = 0; i < codec->statep->pathnum; i++) {
3347 path = codec->statep->path[i];
3348 if (path == NULL || path->path_type != PLAY ||
3349 path->codec != codec)
3350 continue;
3351 for (j = 0; j < path->pin_nums; j++) {
3352 wid = path->pin_wid[j];
3353 wpin = codec->widget[wid];
3354 pin = (audiohd_pin_t *)wpin->priv;
3355 weight = wpin->out_weight;
3356
3357 /*
3358 * search a node which can mute this pin while
3359 * the mute functionality doesn't effect other
3360 * pins.
3361 */
3362 widget = wpin;
3363 while (widget) {
3364 if (widget->outamp_cap &
3365 AUDIOHDC_AMP_CAP_MUTE_CAP) {
3366 pin->mute_wid = widget->wid_wid;
3367 pin->mute_dir = AUDIOHDC_AMP_SET_OUTPUT;
3368 break;
3369 }
3370 if (widget->inamp_cap &
3371 AUDIOHDC_AMP_CAP_MUTE_CAP) {
3372 pin->mute_wid = widget->wid_wid;
3373 pin->mute_dir = AUDIOHDC_AMP_SET_INPUT;
3374 break;
3375 }
3376 next = widget->output_path_next;
3377 if (next == AUDIOHD_NULL_CONN)
3378 break;
3379 wid = widget->avail_conn[next];
3380 widget = codec->widget[wid];
3381 if (widget && widget->out_weight != weight)
3382 break;
3383 }
3384
3385 /*
3386 * We select the wid which has maxium gain range in
3387 * the output path. Meanwhile, the gain controlling
3388 * of this node doesn't effect other pins if this
3389 * output stream has multiple pins.
3390 */
3391 gain = 0;
3392 widget = wpin;
3393 while (widget) {
3394 gain = (widget->outamp_cap &
3395 AUDIOHDC_AMP_CAP_STEP_NUMS);
3396 if (gain && gain > pin->gain_bits) {
3397 pin->gain_dir = AUDIOHDC_AMP_SET_OUTPUT;
3398 pin->gain_bits = gain;
3399 pin->gain_wid = widget->wid_wid;
3400 }
3401 gain = widget->inamp_cap &
3402 AUDIOHDC_AMP_CAP_STEP_NUMS;
3403 if (gain && gain > pin->gain_bits) {
3404 pin->gain_dir = AUDIOHDC_AMP_SET_INPUT;
3405 pin->gain_bits = gain;
3406 pin->gain_wid = widget->wid_wid;
3407 }
3408 next = widget->output_path_next;
3409 if (next == AUDIOHD_NULL_CONN)
3410 break;
3411 wid = widget->avail_conn[next];
3412 widget = codec->widget[wid];
3413 if (widget && widget->out_weight != weight)
3414 break;
3415 }
3416 pin->gain_bits >>= AUDIOHD_GAIN_OFF;
3417 }
3418
3419 /*
3420 * if this stream has multiple pins, we try to find
3421 * a mute & gain-controlling nodes which can effect
3422 * all output pins of this stream to be used for the
3423 * whole stream
3424 */
3425 if (path->pin_nums == 1) {
3426 path->mute_wid = pin->mute_wid;
3427 path->mute_dir = pin->mute_dir;
3428 path->gain_wid = pin->gain_wid;
3429 path->gain_dir = pin->gain_dir;
3430 path->gain_bits = pin->gain_bits;
3431 } else {
3432 wdac = codec->widget[path->adda_wid];
3433 weight = wdac->out_weight;
3434 wid = path->pin_wid[0];
3435 w = codec->widget[wid];
3436 while (w && w->out_weight != weight) {
3437 wid = w->avail_conn[w->output_path_next];
3438 w = codec->widget[wid];
3439 }
3440
3441 /* find mute controlling node for this stream */
3442 widget = w;
3443 while (widget) {
3444 if (widget->outamp_cap &
3445 AUDIOHDC_AMP_CAP_MUTE_CAP) {
3446 path->mute_wid = widget->wid_wid;
3447 path->mute_dir =
3448 AUDIOHDC_AMP_SET_OUTPUT;
3449 break;
3450 }
3451 if (widget->inamp_cap &
3452 AUDIOHDC_AMP_CAP_MUTE_CAP) {
3453 path->mute_wid = widget->wid_wid;
3454 path->mute_dir =
3455 AUDIOHDC_AMP_SET_INPUT;
3456 break;
3457 }
3458 next = widget->output_path_next;
3459 if (next == AUDIOHD_NULL_CONN)
3460 break;
3461 wid = widget->avail_conn[next];
3462 widget = codec->widget[wid];
3463 }
3464
3465 /* find volume controlling node for this stream */
3466 gain = 0;
3467 widget = w;
3468 while (widget) {
3469 gain = (widget->outamp_cap &
3470 AUDIOHDC_AMP_CAP_STEP_NUMS);
3471 if (gain && gain > pin->gain_bits) {
3472 path->gain_dir =
3473 AUDIOHDC_AMP_SET_OUTPUT;
3474 path->gain_bits = gain;
3475 path->gain_wid = widget->wid_wid;
3476 }
3477 gain = widget->inamp_cap &
3478 AUDIOHDC_AMP_CAP_STEP_NUMS;
3479 if (gain && (gain > pin->gain_bits) &&
3480 (widget->type != WTYPE_AUDIO_MIX)) {
3481 path->gain_dir =
3482 AUDIOHDC_AMP_SET_INPUT;
3483 path->gain_bits = gain;
3484 path->gain_wid = widget->wid_wid;
3485 }
3486 next = widget->output_path_next;
3487 if (next == AUDIOHD_NULL_CONN)
3488 break;
3489 wid = widget->avail_conn[next];
3490 widget = codec->widget[wid];
3491 }
3492 path->gain_bits >>= AUDIOHD_GAIN_OFF;
3493 }
3494
3495 }
3496
3497 } /* audiohd_build_output_amp */
3498
3499 /*
3500 * audiohd_finish_output_path()
3501 *
3502 * Description:
3503 * Enable the widgets on the output path
3504 */
3505 static void
3506 audiohd_finish_output_path(hda_codec_t *codec)
3507 {
3508 audiohd_state_t *statep = codec->statep;
3509 audiohd_path_t *path;
3510 audiohd_widget_t *widget;
3511 audiohd_pin_t *pin;
3512 uint_t caddr = codec->index;
3513 wid_t wid, next;
3514 int i, j;
3515
3516 for (i = 0; i < codec->statep->pathnum; i++) {
3517 path = codec->statep->path[i];
3518 if (!path || path->path_type != PLAY || path->codec != codec)
3519 continue;
3520 for (j = 0; j < path->pin_nums; j++) {
3521 wid = path->pin_wid[j];
3522 widget = codec->widget[wid];
3523 pin = (audiohd_pin_t *)widget->priv;
3524 {
3525 uint32_t lTmp;
3526
3527 lTmp = audioha_codec_verb_get(statep, caddr, wid,
3528 AUDIOHDC_VERB_GET_PIN_CTRL, 0);
3529 (void) audioha_codec_verb_get(statep, caddr, wid,
3530 AUDIOHDC_VERB_SET_PIN_CTRL, (lTmp |
3531 pin->vrefvalue |
3532 AUDIOHDC_PIN_CONTROL_OUT_ENABLE |
3533 AUDIOHDC_PIN_CONTROL_HP_ENABLE) &
3534 ~ AUDIOHDC_PIN_CONTROL_IN_ENABLE);
3535 }
3536 /* If this pin has external amplifier, enable it */
3537 if (pin->cap & AUDIOHD_EXT_AMP_MASK)
3538 (void) audioha_codec_verb_get(statep, caddr,
3539 wid, AUDIOHDC_VERB_SET_EAPD,
3540 AUDIOHD_EXT_AMP_ENABLE);
3541
3542 if (widget->outamp_cap) {
3543 (void) audioha_codec_4bit_verb_get(statep,
3544 caddr, wid, AUDIOHDC_VERB_SET_AMP_MUTE,
3545 AUDIOHDC_AMP_SET_LR_OUTPUT |
3546 AUDIOHDC_GAIN_MAX);
3547 }
3548
3549 (void) audioha_codec_verb_get(statep, caddr, wid,
3550 AUDIOHDC_VERB_SET_CONN_SEL,
3551 widget->output_path_next);
3552
3553 wid = widget->avail_conn[widget->output_path_next];
3554 widget = codec->widget[wid];
3555
3556 while (widget) {
3557 /*
3558 * Set all amplifiers in this path to
3559 * the maximum volume and unmute them.
3560 */
3561 if (widget->outamp_cap) {
3562 (void) audioha_codec_4bit_verb_get(
3563 statep, caddr,
3564 wid, AUDIOHDC_VERB_SET_AMP_MUTE,
3565 AUDIOHDC_AMP_SET_LR_OUTPUT |
3566 AUDIOHDC_GAIN_MAX);
3567 }
3568 if (widget->inamp_cap) {
3569 (void) audioha_codec_4bit_verb_get(
3570 statep, caddr,
3571 wid, AUDIOHDC_VERB_SET_AMP_MUTE,
3572 AUDIOHDC_AMP_SET_LR_INPUT |
3573 AUDIOHDC_GAIN_MAX |
3574 (widget->output_path_next <<
3575 AUDIOHDC_AMP_SET_INDEX_OFFSET));
3576 }
3577
3578 next = widget->output_path_next;
3579 if (next == AUDIOHD_NULL_CONN)
3580 break;
3581 /*
3582 * Accoding to HD spec, mixer doesn't support
3583 * "select connection"
3584 */
3585 if ((widget->type == WTYPE_AUDIO_SEL) &&
3586 (widget->nconns > 1))
3587 (void) audioha_codec_verb_get(statep,
3588 caddr, wid,
3589 AUDIOHDC_VERB_SET_CONN_SEL,
3590 widget->output_path_next);
3591
3592 wid = widget->avail_conn[next];
3593 widget = codec->widget[wid];
3594 }
3595 }
3596 }
3597 } /* audiohd_finish_output_path() */
3598
3599 /*
3600 * audiohd_find_input_pins()
3601 *
3602 * Description:
3603 * Here we consider a mixer/selector with multi-input as a real sum
3604 * widget. Only the first real mixer/selector widget is permitted in
3605 * an input path(recording path). If there are more mixers/selectors
3606 * execept the first one, only the first input/connection of those
3607 * widgets will be used by our driver, that means, we ignore other
3608 * inputs of those mixers/selectors.
3609 */
3610 static int
3611 audiohd_find_input_pins(hda_codec_t *codec, wid_t wid, int allowmixer,
3612 int depth, audiohd_path_t *path)
3613 {
3614 audiohd_widget_t *widget = codec->widget[wid];
3615 audiohd_pin_t *pin;
3616 audiohd_state_t *statep = codec->statep;
3617 uint_t caddr = codec->index;
3618 int retval = -1;
3619 int num, i;
3620 uint32_t pinctrl;
3621
3622 if (depth > AUDIOHD_MAX_DEPTH)
3623 return (uint32_t)(DDI_FAILURE);
3624 if (widget == NULL)
3625 return (uint32_t)(DDI_FAILURE);
3626
3627 /* we don't share widgets */
3628 if (widget->path_flags & AUDIOHD_PATH_ADC ||
3629 widget->path_flags & AUDIOHD_PATH_DAC)
3630 return (uint32_t)(DDI_FAILURE);
3631
3632 switch (widget->type) {
3633 case WTYPE_PIN:
3634 pin = (audiohd_pin_t *)widget->priv;
3635 if (pin->no_phys_conn)
3636 return (uint32_t)(DDI_FAILURE);
3637 /* enable the pins' input capability */
3638 pinctrl = audioha_codec_verb_get(statep, caddr, wid,
3639 AUDIOHDC_VERB_GET_PIN_CTRL, 0);
3640 (void) audioha_codec_verb_get(statep, caddr, wid,
3641 AUDIOHDC_VERB_SET_PIN_CTRL,
3642 pinctrl | AUDIOHD_PIN_IN_ENABLE);
3643 if (pin->cap & AUDIOHD_EXT_AMP_MASK) {
3644 (void) audioha_codec_verb_get(statep, caddr,
3645 wid, AUDIOHDC_VERB_SET_EAPD,
3646 AUDIOHD_EXT_AMP_ENABLE);
3647 }
3648 switch (pin->device) {
3649 case DTYPE_CD:
3650 case DTYPE_LINE_IN:
3651 case DTYPE_MIC_IN:
3652 case DTYPE_AUX:
3653 widget->path_flags |= AUDIOHD_PATH_ADC;
3654 widget->in_weight++;
3655 path->pin_wid[path->pin_nums++] = wid;
3656 pin->adc_wid = path->adda_wid;
3657 return (DDI_SUCCESS);
3658 }
3659 break;
3660 case WTYPE_AUDIO_MIX:
3661 case WTYPE_AUDIO_SEL:
3662 /*
3663 * If the sum widget has only one input, we don't
3664 * consider it as a real sum widget.
3665 */
3666 if (widget->nconns == 1) {
3667 widget->input_path_next = 0;
3668 retval = audiohd_find_input_pins(codec,
3669 widget->avail_conn[0],
3670 allowmixer, depth + 1, path);
3671 if (retval == DDI_SUCCESS) {
3672 widget->path_flags |= AUDIOHD_PATH_ADC;
3673 widget->in_weight++;
3674 }
3675 break;
3676 }
3677
3678 if (allowmixer) {
3679 /*
3680 * This is a real sum widget, we will reject
3681 * other real sum widget when we find more in
3682 * the following path-searching.
3683 */
3684 for (int i = 0; i < widget->nconns; i++) {
3685 retval = audiohd_find_input_pins(codec,
3686 widget->avail_conn[i], 0, depth + 1,
3687 path);
3688 if (retval == DDI_SUCCESS) {
3689 widget->input_path_next = i;
3690 widget->in_weight++;
3691 num = path->pin_nums - 1;
3692 path->sum_selconn[num] = i;
3693 path->sum_wid = wid;
3694 widget->path_flags |=
3695 AUDIOHD_PATH_ADC;
3696 }
3697 }
3698
3699 /* return SUCCESS if we found at least one input path */
3700 if (path->pin_nums > 0)
3701 retval = DDI_SUCCESS;
3702 } else {
3703 /*
3704 * We had already found a real sum before this one since
3705 * allowmixer is 0.
3706 */
3707 for (i = 0; i < widget->nconns; i++) {
3708 retval = audiohd_find_input_pins(codec,
3709 widget->avail_conn[i], 0, depth + 1,
3710 path);
3711 if (retval == DDI_SUCCESS) {
3712 widget->input_path_next = i;
3713 widget->path_flags |= AUDIOHD_PATH_ADC;
3714 widget->in_weight++;
3715 break;
3716 }
3717 }
3718 }
3719 break;
3720 default:
3721 break;
3722 }
3723
3724 return (retval);
3725 } /* audiohd_find_input_pins */
3726
3727 /*
3728 * audiohd_build_input_path()
3729 *
3730 * Description:
3731 * Find input path for the codec
3732 */
3733 static void
3734 audiohd_build_input_path(hda_codec_t *codec)
3735 {
3736 audiohd_widget_t *widget;
3737 audiohd_path_t *path = NULL;
3738 wid_t wid;
3739 int i;
3740 int retval;
3741 uint8_t rtag = 0;
3742 audiohd_state_t *statep = codec->statep;
3743
3744 for (wid = codec->first_wid; wid <= codec->last_wid; wid++) {
3745
3746 widget = codec->widget[wid];
3747
3748 /* check if it is an ADC widget */
3749 if (widget == NULL || widget->type != WTYPE_AUDIO_IN)
3750 continue;
3751
3752 if (path == NULL)
3753 path = kmem_zalloc(sizeof (audiohd_path_t),
3754 KM_SLEEP);
3755 else
3756 bzero(path, sizeof (audiohd_port_t));
3757
3758 path->adda_wid = wid;
3759
3760 /*
3761 * Is there any ADC widget which has more than one input ??
3762 * I don't believe. Anyway, we carefully deal with this. But
3763 * if hardware vendors embed a selector in a ADC, we just use
3764 * the first available input, which has connection to input pin
3765 * widget. Because selector cannot perform mixer functionality,
3766 * and we just permit one selector or mixer in a recording path,
3767 * if we use the selector embedded in ADC,we cannot use possible
3768 * mixer during path searching.
3769 */
3770 for (i = 0; i < widget->nconns; i++) {
3771 retval = audiohd_find_input_pins(codec,
3772 widget->avail_conn[i], 1, 0, path);
3773 if (retval == DDI_SUCCESS) {
3774 path->codec = codec;
3775 path->statep = statep;
3776 path->path_type = RECORD;
3777 path->tag = ++rtag;
3778 codec->nistream++;
3779 statep->path[statep->pathnum++] = path;
3780 widget->input_path_next = i;
3781 widget->priv = path;
3782 path = NULL;
3783 break;
3784 }
3785 }
3786 }
3787 if (path)
3788 kmem_free(path, sizeof (audiohd_path_t));
3789 } /* audiohd_build_input_path */
3790
3791 /*
3792 * audiohd_build_input_amp()
3793 *
3794 * Description:
3795 * Find gain and mute control widgets on the input path
3796 */
3797 static void
3798 audiohd_build_input_amp(hda_codec_t *codec)
3799 {
3800 audiohd_path_t *path;
3801 audiohd_widget_t *wsum, *wadc, *w;
3802 audiohd_pin_t *pin;
3803 uint_t gain;
3804 wid_t wid, next;
3805 int i, j;
3806 int weight;
3807
3808 for (i = 0; i < codec->statep->pathnum; i++) {
3809 path = codec->statep->path[i];
3810 if (path == NULL || path->path_type != RECORD ||
3811 path->codec != codec)
3812 continue;
3813
3814 wid = path->adda_wid;
3815 wadc = path->codec->widget[wid];
3816 weight = wadc->in_weight;
3817
3818 /*
3819 * Search node which has mute functionality for
3820 * the whole input path
3821 */
3822 w = wadc;
3823 while (w) {
3824 if (w->outamp_cap & AUDIOHDC_AMP_CAP_MUTE_CAP) {
3825 path->mute_wid = w->wid_wid;
3826 path->mute_dir = AUDIOHDC_AMP_SET_OUTPUT;
3827 break;
3828 }
3829 if ((w->inamp_cap & AUDIOHDC_AMP_CAP_MUTE_CAP) &&
3830 (w->wid_wid != path->sum_wid)) {
3831 path->mute_wid = w->wid_wid;
3832 path->mute_dir = AUDIOHDC_AMP_SET_INPUT;
3833 break;
3834 }
3835
3836 next = w->input_path_next;
3837 if (next == AUDIOHD_NULL_CONN)
3838 break;
3839 wid = w->avail_conn[next];
3840 w = path->codec->widget[wid];
3841 if (w && w->in_weight != weight)
3842 break;
3843 }
3844
3845 /*
3846 * Search a node for amplifier adjusting for the whole
3847 * input path
3848 */
3849 w = wadc;
3850 gain = 0;
3851 while (w) {
3852 gain = (w->outamp_cap & AUDIOHDC_AMP_CAP_STEP_NUMS);
3853 if (gain && gain > path->gain_bits) {
3854 path->gain_dir = AUDIOHDC_AMP_SET_OUTPUT;
3855 path->gain_bits = gain;
3856 path->gain_wid = w->wid_wid;
3857 }
3858 gain = w->inamp_cap & AUDIOHDC_AMP_CAP_STEP_NUMS;
3859 if (gain && (gain > path->gain_bits) &&
3860 (w->wid_wid != path->sum_wid)) {
3861 path->gain_dir = AUDIOHDC_AMP_SET_INPUT;
3862 path->gain_bits = gain;
3863 path->gain_wid = w->wid_wid;
3864 }
3865
3866 next = w->input_path_next;
3867 if (next == AUDIOHD_NULL_CONN)
3868 break;
3869 wid = w->avail_conn[next];
3870 w = path->codec->widget[wid];
3871 }
3872 path->gain_bits >>= AUDIOHD_GAIN_OFF;
3873
3874 /*
3875 * If the input path has one pin only, the mute/amp
3876 * controlling is shared by the whole path and pin
3877 */
3878 if (path->pin_nums == 1) {
3879 wid = path->pin_wid[0];
3880 w = path->codec->widget[wid];
3881 pin = (audiohd_pin_t *)w->priv;
3882 pin->gain_dir = path->gain_dir;
3883 pin->gain_bits = path->gain_bits;
3884 pin->gain_wid = path->gain_wid;
3885 pin->mute_wid = path->mute_wid;
3886 pin->mute_dir = path->mute_dir;
3887 continue;
3888 }
3889
3890 /*
3891 * For multi-pin device, there must be a selector
3892 * or mixer along the input path, and the sum_wid
3893 * is the widget's node id.
3894 */
3895 wid = path->sum_wid;
3896 wsum = path->codec->widget[wid]; /* sum widget */
3897
3898 for (j = 0; j < path->pin_nums; j++) {
3899 wid = path->pin_wid[j];
3900 w = path->codec->widget[wid];
3901 pin = (audiohd_pin_t *)w->priv;
3902
3903 /* find node for mute */
3904 if (wsum->inamp_cap & AUDIOHDC_AMP_CAP_MUTE_CAP) {
3905 pin->mute_wid = wsum->wid_wid;
3906 pin->mute_dir = AUDIOHDC_AMP_SET_INPUT;
3907 } else {
3908 wid = wsum->avail_conn[path->sum_selconn[i]];
3909 w = path->codec->widget[wid];
3910 while (w) {
3911 if (w->outamp_cap &
3912 AUDIOHDC_AMP_CAP_MUTE_CAP) {
3913 pin->mute_wid = w->wid_wid;
3914 pin->mute_dir =
3915 AUDIOHDC_AMP_SET_OUTPUT;
3916 break;
3917 }
3918 if (w->inamp_cap &
3919 AUDIOHDC_AMP_CAP_MUTE_CAP) {
3920 pin->mute_wid = w->wid_wid;
3921 pin->mute_dir =
3922 AUDIOHDC_AMP_SET_INPUT;
3923 break;
3924 }
3925
3926 next = w->input_path_next;
3927 if (next == AUDIOHD_NULL_CONN)
3928 break;
3929 wid = w->avail_conn[next];
3930 w = path->codec->widget[wid];
3931 }
3932 }
3933
3934 /* find node for amp controlling */
3935 gain = (wsum->inamp_cap & AUDIOHDC_AMP_CAP_STEP_NUMS);
3936 wid = wsum->avail_conn[path->sum_selconn[i]];
3937 w = path->codec->widget[wid];
3938 while (w) {
3939 gain = (w->outamp_cap &
3940 AUDIOHDC_AMP_CAP_STEP_NUMS);
3941 if (gain && gain > pin->gain_bits) {
3942 pin->gain_dir = AUDIOHDC_AMP_SET_OUTPUT;
3943 pin->gain_bits = gain;
3944 pin->gain_wid = w->wid_wid;
3945 }
3946 gain = w->inamp_cap &
3947 AUDIOHDC_AMP_CAP_STEP_NUMS;
3948 if (gain && (gain > pin->gain_bits)) {
3949 pin->gain_dir = AUDIOHDC_AMP_SET_INPUT;
3950 pin->gain_bits = gain;
3951 pin->gain_wid = w->wid_wid;
3952 }
3953
3954 next = w->input_path_next;
3955 if (next == AUDIOHD_NULL_CONN)
3956 break;
3957 wid = w->avail_conn[next];
3958 w = path->codec->widget[wid];
3959 }
3960 pin->gain_bits >>= AUDIOHD_GAIN_OFF;
3961 }
3962 }
3963 } /* audiohd_build_input_amp() */
3964
3965 /*
3966 * audiohd_finish_input_path()
3967 *
3968 * Description:
3969 * Enable the widgets on the input path
3970 */
3971 static void
3972 audiohd_finish_input_path(hda_codec_t *codec)
3973 {
3974 audiohd_state_t *statep = codec->statep;
3975 audiohd_path_t *path;
3976 audiohd_widget_t *w, *wsum;
3977 uint_t caddr = codec->index;
3978 wid_t wid;
3979 int i, j;
3980
3981 for (i = 0; i < codec->statep->pathnum; i++) {
3982 path = codec->statep->path[i];
3983 if (path == NULL || path->path_type != RECORD ||
3984 path->codec != codec)
3985 continue;
3986 wid = path->adda_wid;
3987 w = path->codec->widget[wid];
3988 while (w && (w->wid_wid != path->sum_wid) &&
3989 (w->type != WTYPE_PIN)) {
3990 if ((w->type == WTYPE_AUDIO_SEL) && (w->nconns > 1))
3991 (void) audioha_codec_verb_get(statep, caddr,
3992 w->wid_wid, AUDIOHDC_VERB_SET_CONN_SEL,
3993 w->input_path_next);
3994
3995 if (w->outamp_cap) {
3996 (void) audioha_codec_4bit_verb_get(statep,
3997 caddr,
3998 w->wid_wid, AUDIOHDC_VERB_SET_AMP_MUTE,
3999 AUDIOHDC_AMP_SET_LR_OUTPUT |
4000 AUDIOHDC_GAIN_MAX);
4001 }
4002
4003 if (w->inamp_cap) {
4004 (void) audioha_codec_4bit_verb_get(statep,
4005 caddr,
4006 w->wid_wid, AUDIOHDC_VERB_SET_AMP_MUTE,
4007 AUDIOHDC_AMP_SET_LR_INPUT |
4008 AUDIOHDC_GAIN_MAX |
4009 (w->input_path_next <<
4010 AUDIOHDC_AMP_SET_INDEX_OFFSET));
4011 }
4012
4013 wid = w->avail_conn[w->input_path_next];
4014 w = path->codec->widget[wid];
4015 }
4016
4017 /*
4018 * After exiting from the above loop, the widget pointed
4019 * by w can be a pin widget or select/mixer widget. If it
4020 * is a pin widget, we already finish "select connection"
4021 * operation for the whole path.
4022 */
4023 if (w && w->type == WTYPE_PIN)
4024 continue;
4025
4026 /*
4027 * deal with multi-pin input devices.
4028 */
4029 wid = path->sum_wid;
4030 wsum = path->codec->widget[wid];
4031 if (wsum == NULL)
4032 continue;
4033 if (wsum->outamp_cap) {
4034 (void) audioha_codec_4bit_verb_get(statep,
4035 caddr,
4036 wsum->wid_wid, AUDIOHDC_VERB_SET_AMP_MUTE,
4037 AUDIOHDC_AMP_SET_LR_OUTPUT |
4038 AUDIOHDC_GAIN_MAX);
4039 }
4040
4041 for (j = 0; j < path->pin_nums; j++) {
4042 if (wsum->inamp_cap) {
4043 (void) audioha_codec_4bit_verb_get(statep,
4044 caddr,
4045 wsum->wid_wid, AUDIOHDC_VERB_SET_AMP_MUTE,
4046 AUDIOHDC_AMP_SET_LR_INPUT |
4047 AUDIOHDC_GAIN_MAX |
4048 (path->sum_selconn[j] <<
4049 AUDIOHDC_AMP_SET_INDEX_OFFSET));
4050 }
4051 if (wsum->type == WTYPE_AUDIO_SEL) {
4052 (void) audioha_codec_verb_get(statep, caddr,
4053 wsum->wid_wid,
4054 AUDIOHDC_VERB_SET_CONN_SEL,
4055 path->sum_selconn[j]);
4056 }
4057
4058 wid = wsum->avail_conn[path->sum_selconn[j]];
4059 w = path->codec->widget[wid];
4060 while (w && w->type != WTYPE_PIN) {
4061 if ((w->type != WTYPE_AUDIO_MIX) &&
4062 (w->nconns > 1))
4063 (void) audioha_codec_verb_get(statep,
4064 caddr, w->wid_wid,
4065 AUDIOHDC_VERB_SET_CONN_SEL,
4066 w->input_path_next);
4067
4068 if (w->outamp_cap) {
4069 (void) audioha_codec_4bit_verb_get(
4070 statep,
4071 caddr,
4072 w->wid_wid,
4073 AUDIOHDC_VERB_SET_AMP_MUTE,
4074 AUDIOHDC_AMP_SET_LR_OUTPUT |
4075 AUDIOHDC_GAIN_MAX);
4076 }
4077
4078 if (w->inamp_cap) {
4079 (void) audioha_codec_4bit_verb_get(
4080 statep,
4081 caddr,
4082 w->wid_wid,
4083 AUDIOHDC_VERB_SET_AMP_MUTE,
4084 AUDIOHDC_AMP_SET_LR_INPUT |
4085 AUDIOHDC_GAIN_MAX |
4086 (w->input_path_next <<
4087 AUDIOHDC_AMP_SET_INDEX_OFFSET));
4088 }
4089 wid = w->avail_conn[w->input_path_next];
4090 w = path->codec->widget[wid];
4091 }
4092 }
4093 } /* end of istream loop */
4094 } /* audiohd_finish_input_path */
4095
4096 /*
4097 * audiohd_find_inpin_for_monitor()
4098 *
4099 * Description:
4100 * Find input pin for monitor path.
4101 *
4102 * Arguments:
4103 * hda_codec_t *codec where the monitor path exists
4104 * wid_t id no. of widget being searched
4105 * int mixer share or not
4106 */
4107 static int
4108 audiohd_find_inpin_for_monitor(hda_codec_t *codec, wid_t id, int mixer)
4109 {
4110 wid_t wid;
4111 audiohd_widget_t *widget, *w;
4112 audiohd_pin_t *pin;
4113 int i, find = 0;
4114
4115 wid = id;
4116 widget = codec->widget[wid];
4117 if (widget == NULL)
4118 return (uint32_t)(DDI_FAILURE);
4119
4120 if (widget->type == WTYPE_PIN) {
4121 pin = (audiohd_pin_t *)widget->priv;
4122 if (pin->no_phys_conn)
4123 return (uint32_t)(DDI_FAILURE);
4124 switch (pin->device) {
4125 case DTYPE_SPDIF_IN:
4126 case DTYPE_CD:
4127 case DTYPE_LINE_IN:
4128 case DTYPE_MIC_IN:
4129 case DTYPE_AUX:
4130 widget->path_flags |= AUDIOHD_PATH_MON;
4131 return (DDI_SUCCESS);
4132 default:
4133 return (uint32_t)(DDI_FAILURE);
4134 }
4135 }
4136 /* the widget has been visited and can't be directed to input pin */
4137 if (widget->path_flags & AUDIOHD_PATH_NOMON) {
4138 return (uint32_t)(DDI_FAILURE);
4139 }
4140 /* the widget has been used by the monitor path, and we can share it */
4141 if (widget->path_flags & AUDIOHD_PATH_MON) {
4142 if (mixer)
4143 return (DDI_SUCCESS);
4144 else
4145 return (uint32_t)(DDI_FAILURE);
4146 }
4147 switch (widget->type) {
4148 case WTYPE_AUDIO_MIX:
4149 for (i = 0; i < widget->nconns; i++) {
4150 if (widget->output_path_next == i)
4151 continue;
4152 if (audiohd_find_inpin_for_monitor(codec,
4153 widget->avail_conn[i], mixer) ==
4154 DDI_SUCCESS) {
4155 w = widget;
4156 w->monitor_path_next[w->used++] = i;
4157 w->path_flags |= AUDIOHD_PATH_MON;
4158 find = 1;
4159 }
4160 }
4161 break;
4162 case WTYPE_AUDIO_SEL:
4163 for (i = 0; i < widget->nconns; i++) {
4164 if (widget->output_path_next == i)
4165 continue;
4166 if (audiohd_find_inpin_for_monitor(codec,
4167 widget->avail_conn[i], mixer) ==
4168 DDI_SUCCESS) {
4169 widget->monitor_path_next[0] = i;
4170 widget->path_flags |= AUDIOHD_PATH_MON;
4171 find = 1;
4172 break;
4173 }
4174 }
4175 break;
4176 default:
4177 break;
4178 }
4179 if (!find) {
4180 widget->path_flags |= AUDIOHD_PATH_NOMON;
4181 return (uint32_t)(DDI_FAILURE);
4182 }
4183 else
4184 return (DDI_SUCCESS);
4185 } /* audiohd_find_inpin_for_monitor */
4186
4187 /*
4188 * audiohd_build_monitor_path()
4189 *
4190 * Description:
4191 * The functionality of mixer is to mix inputs, such as CD-IN, MIC,
4192 * Line-in, etc, with DAC outputs, so as to minitor what is being
4193 * recorded and implement "What you hear is what you get". However,
4194 * this functionality are really hardware-dependent: the inputs
4195 * must be directed to MIXER if they can be directed to ADC as
4196 * recording sources.
4197 */
4198 static void
4199 audiohd_build_monitor_path(hda_codec_t *codec)
4200 {
4201 audiohd_path_t *path;
4202 audiohd_widget_t *widget, *w;
4203 audiohd_state_t *statep = codec->statep;
4204 wid_t wid, next;
4205 int i, j, k, l, find;
4206 int mixernum = 0;
4207
4208 for (i = 0; i < statep->pathnum; i++) {
4209 path = statep->path[i];
4210 if (path == NULL || path->codec != codec ||
4211 path->path_type != PLAY)
4212 continue;
4213 for (j = 0; j < path->pin_nums; j++) {
4214 wid = path->pin_wid[j];
4215 widget = codec->widget[wid];
4216 l = 0;
4217 while (widget) {
4218 while (widget &&
4219 ((widget->type != WTYPE_AUDIO_MIX) ||
4220 (widget->nconns < 2))) {
4221 next = widget->output_path_next;
4222 if (next == AUDIOHD_NULL_CONN)
4223 break;
4224 wid = widget->avail_conn[next];
4225 widget = codec->widget[wid];
4226 }
4227
4228 /*
4229 * No mixer in this output path, we cannot build
4230 * mixer path for this path, skip it,
4231 * and continue for next output path.
4232 */
4233 if (widget == NULL ||
4234 widget->output_path_next ==
4235 AUDIOHD_NULL_CONN) {
4236 break;
4237 }
4238 mixernum++;
4239 for (k = 0; k < widget->nconns; k++) {
4240
4241 /*
4242 * this connection must be routined
4243 * to DAC instead of an input pin
4244 * widget, we needn't waste time for
4245 * it
4246 */
4247 if (widget->output_path_next == k)
4248 continue;
4249 find = 0;
4250 if (audiohd_find_inpin_for_monitor(
4251 codec,
4252 widget->avail_conn[k], 0) ==
4253 DDI_SUCCESS) {
4254 path->mon_wid[j][l] = wid;
4255 w = widget;
4256 w->monitor_path_next[w->used++]
4257 = k;
4258 w->path_flags |=
4259 AUDIOHD_PATH_MON;
4260 find = 1;
4261 } else if (
4262 audiohd_find_inpin_for_monitor(
4263 codec,
4264 widget->avail_conn[k], 1) ==
4265 DDI_SUCCESS) {
4266 path->mon_wid[j][l] = wid;
4267 w = widget;
4268 w->monitor_path_next[w->used++]
4269 = k;
4270 w->path_flags |=
4271 AUDIOHD_PATH_MON;
4272 find = 1;
4273 }
4274
4275 }
4276
4277 /*
4278 * we needn't check widget->output_path_next
4279 * here since this widget is a selector or
4280 * mixer, it cannot be NULL connection.
4281 */
4282 if (!find) {
4283 path->mon_wid[j][l] = 0;
4284 widget->path_flags |=
4285 AUDIOHD_PATH_NOMON;
4286 }
4287 next = widget->output_path_next;
4288 wid = widget->avail_conn[next];
4289 widget = codec->widget[wid];
4290 l++;
4291 }
4292 path->maxmixer[j] = l;
4293 }
4294
4295 }
4296 if (mixernum == 0)
4297 statep->monitor_supported = B_FALSE;
4298 else
4299 statep->monitor_supported = B_TRUE;
4300 } /* audiohd_build_monitor_path */
4301
4302 /*
4303 * audiohd_do_finish_monitor_path
4304 *
4305 * Description:
4306 * Enable the widgets on the monitor path
4307 */
4308 static void
4309 audiohd_do_finish_monitor_path(hda_codec_t *codec, audiohd_widget_t *wgt)
4310 {
4311 uint_t caddr = codec->index;
4312 audiohd_widget_t *widget = wgt;
4313 audiohd_widget_t *w;
4314 audiohd_state_t *statep = codec->statep;
4315 wid_t wid;
4316 int i;
4317 int share = 0;
4318
4319 if (!widget || widget->finish)
4320 return;
4321 if (widget->path_flags & AUDIOHD_PATH_ADC)
4322 share = 1;
4323 if ((widget->outamp_cap) && !share)
4324 (void) audioha_codec_4bit_verb_get(statep, caddr,
4325 widget->wid_wid, AUDIOHDC_VERB_SET_AMP_MUTE,
4326 AUDIOHDC_AMP_SET_LR_OUTPUT | AUDIOHDC_GAIN_MAX);
4327 if ((widget->inamp_cap) && !share) {
4328 for (i = 0; i < widget->used; i++) {
4329 (void) audioha_codec_4bit_verb_get(statep, caddr,
4330 widget->wid_wid, AUDIOHDC_VERB_SET_AMP_MUTE,
4331 AUDIOHDC_AMP_SET_LR_INPUT | AUDIOHDC_GAIN_MAX |
4332 (widget->monitor_path_next[i]
4333 << AUDIOHDC_AMP_SET_INDEX_OFFSET));
4334 }
4335 }
4336 if ((widget->type == WTYPE_AUDIO_SEL) && (widget->nconns > 1) &&
4337 !share) {
4338 (void) audioha_codec_verb_get(statep, caddr, widget->wid_wid,
4339 AUDIOHDC_VERB_SET_CONN_SEL, widget->monitor_path_next[0]);
4340 }
4341 widget->finish = 1;
4342 if (widget->used == 0)
4343 return;
4344 if (widget->used > 0) {
4345 for (i = 0; i < widget->used; i++) {
4346 wid = widget->avail_conn[widget->monitor_path_next[i]];
4347 w = codec->widget[wid];
4348 audiohd_do_finish_monitor_path(codec, w);
4349 }
4350 }
4351 } /* audiohd_do_finish_monitor_path */
4352
4353 /*
4354 * audiohd_finish_monitor_path
4355 *
4356 * Description:
4357 * Enable the monitor path for every ostream path
4358 */
4359 static void
4360 audiohd_finish_monitor_path(hda_codec_t *codec)
4361 {
4362 audiohd_path_t *path;
4363 audiohd_widget_t *widget;
4364 audiohd_state_t *statep = codec->statep;
4365 wid_t wid;
4366 int i, j, k;
4367
4368 for (i = 0; i < statep->pathnum; i++) {
4369 path = statep->path[i];
4370 if (!path || path->codec != codec || path->path_type != PLAY)
4371 continue;
4372 for (j = 0; j < path->pin_nums; j++) {
4373 for (k = 0; k < path->maxmixer[j]; k++) {
4374 wid = path->mon_wid[j][k];
4375 if (wid == 0) {
4376 continue;
4377 }
4378 widget = codec->widget[wid];
4379 audiohd_do_finish_monitor_path(codec, widget);
4380 }
4381 }
4382 }
4383 } /* audiohd_finish_monitor_path */
4384
4385 /*
4386 * audiohd_do_build_monit_amp()
4387 *
4388 * Description:
4389 * Search for the gain control widget for the monitor path
4390 */
4391 static void
4392 audiohd_do_build_monitor_amp(hda_codec_t *codec, audiohd_pin_t *pin,
4393 audiohd_widget_t *widget)
4394 {
4395 audiohd_widget_t *w = widget;
4396 uint32_t gain;
4397 int i;
4398 wid_t wid;
4399
4400 if (!w ||
4401 (w->type == WTYPE_PIN) ||
4402 !w->used ||
4403 (pin->num == AUDIOHD_MAX_CONN) ||
4404 (w->path_flags & AUDIOHD_PATH_ADC))
4405 return;
4406 if (!(w->path_flags & AUDIOHD_PATH_DAC)) {
4407 gain = w->outamp_cap & AUDIOHDC_AMP_CAP_STEP_NUMS;
4408 if (gain) {
4409 pin->mg_dir[pin->num] = AUDIOHDC_AMP_SET_OUTPUT;
4410 pin->mg_gain[pin->num] = gain;
4411 pin->mg_wid[pin->num] = w->wid_wid;
4412 pin->mg_gain[pin->num] >>= AUDIOHD_GAIN_OFF;
4413 pin->num++;
4414 return;
4415 }
4416 gain = w->inamp_cap & AUDIOHDC_AMP_CAP_STEP_NUMS;
4417 if (gain) {
4418 pin->mg_dir[pin->num] = AUDIOHDC_AMP_SET_INPUT;
4419 pin->mg_gain[pin->num] = gain;
4420 pin->mg_wid[pin->num] = w->wid_wid;
4421 pin->mg_gain[pin->num] >>= AUDIOHD_GAIN_OFF;
4422 pin->num++;
4423 return;
4424 }
4425 }
4426 for (i = 0; i < w->used; i++) {
4427 wid = w->avail_conn[w->monitor_path_next[i]];
4428 audiohd_do_build_monitor_amp(codec, pin, codec->widget[wid]);
4429 }
4430
4431
4432 } /* audiohd_do_build_monitor_amp() */
4433
4434 /*
4435 * audiohd_build_monitor_amp()
4436 *
4437 * Description:
4438 * Search gain control widget for every ostream monitor
4439 */
4440 static void
4441 audiohd_build_monitor_amp(hda_codec_t *codec)
4442 {
4443 audiohd_path_t *path;
4444 audiohd_widget_t *widget, *w;
4445 audiohd_state_t *statep = codec->statep;
4446 audiohd_pin_t *pin;
4447 wid_t wid, id;
4448 int i, j, k;
4449
4450 for (i = 0; i < statep->pathnum; i++) {
4451 path = statep->path[i];
4452 if (!path || path->codec != codec || path->path_type != PLAY)
4453 continue;
4454 for (j = 0; j < path->pin_nums; j++) {
4455 id = path->pin_wid[j];
4456 w = codec->widget[id];
4457 pin = (audiohd_pin_t *)(w->priv);
4458 for (k = 0; k < path->maxmixer[j]; k++) {
4459 wid = path->mon_wid[j][k];
4460 if (!wid)
4461 continue;
4462 widget = codec->widget[wid];
4463 audiohd_do_build_monitor_amp(codec, pin,
4464 widget);
4465 }
4466 }
4467 }
4468 }
4469
4470 /*
4471 * audiohd_find_beep()
4472 * Description:
4473 * Find a beep for a beep path. Then the play data can be sent to the out
4474 * put pin through the beep path.
4475 *
4476 * Arguments:
4477 * hda_codec_t *codec where the beep widget exists
4478 * wid_t wid the no. of a widget
4479 * int depth the depth of search
4480 *
4481 * Return:
4482 * 1) wid of Beep widget;
4483 * 2) 0 if no path
4484 */
4485 static wid_t
4486 audiohd_find_beep(hda_codec_t *codec, wid_t wid, int depth)
4487 {
4488 audiohd_widget_t *widget = codec->widget[wid];
4489 wid_t wbeep = (uint32_t)(DDI_FAILURE);
4490 wid_t retval;
4491
4492 if (depth > AUDIOHD_MAX_DEPTH)
4493 return (uint32_t)(DDI_FAILURE);
4494
4495 if (widget == NULL)
4496 return (uint32_t)(DDI_FAILURE);
4497
4498 switch (widget->type) {
4499 case WTYPE_BEEP:
4500 widget->path_flags |= AUDIOHD_PATH_BEEP;
4501 wbeep = widget->wid_wid;
4502 break;
4503 case WTYPE_AUDIO_MIX:
4504 case WTYPE_AUDIO_SEL:
4505 for (int i = 0; i < widget->nconns; i++) {
4506 retval = audiohd_find_beep(codec,
4507 widget->avail_conn[i], depth + 1);
4508 if (retval == DDI_SUCCESS) {
4509 if (widget->output_path_next !=
4510 AUDIOHD_NULL_CONN)
4511 continue;
4512 widget->beep_path_next = i;
4513 wbeep = retval;
4514 widget->path_flags |= AUDIOHD_PATH_BEEP;
4515 return (wbeep);
4516 }
4517 }
4518 break;
4519 default:
4520 break;
4521 }
4522
4523 return (wbeep);
4524 } /* audiohd_find_beep() */
4525
4526 /*
4527 * audiohd_build_beep_path()
4528 *
4529 * Description:
4530 * Search an beep path for each pin in the codec.
4531 * Arguments:
4532 * hda_codec_t *codec where the beep path exists
4533 */
4534 static void
4535 audiohd_build_beep_path(hda_codec_t *codec)
4536 {
4537 audiohd_pin_t *pin;
4538 audiohd_widget_t *widget;
4539 audiohd_path_t *path;
4540 wid_t wid;
4541 audiohd_state_t *statep;
4542 int i;
4543 boolean_t beeppath = B_FALSE;
4544
4545 statep = codec->statep;
4546
4547 for (pin = codec->first_pin; pin; pin = pin->next) {
4548 if ((pin->cap & AUDIOHD_PIN_CAP_MASK) == 0)
4549 continue;
4550 if ((pin->config & AUDIOHD_PIN_CONF_MASK) ==
4551 AUDIOHD_PIN_NO_CONN)
4552 continue;
4553 if ((pin->device != DTYPE_LINEOUT) &&
4554 (pin->device != DTYPE_SPEAKER) &&
4555 (pin->device != DTYPE_SPDIF_OUT) &&
4556 (pin->device != DTYPE_HP_OUT))
4557 continue;
4558 widget = codec->widget[pin->wid];
4559
4560 widget->inamp_cap = 0;
4561 for (i = 0; i < widget->nconns; i++) {
4562 /*
4563 * If a beep found, the return value is the wid of the
4564 * widget on the path, or the return value is
4565 * DDI_FAILURE
4566 */
4567 wid = audiohd_find_beep(codec,
4568 widget->avail_conn[i], 0);
4569 /*
4570 * A beep was not found
4571 */
4572 if (wid == (wid_t)DDI_FAILURE)
4573 continue;
4574 if (widget->output_path_next != AUDIOHD_NULL_CONN)
4575 continue;
4576 path = (audiohd_path_t *)
4577 kmem_zalloc(sizeof (audiohd_path_t),
4578 KM_SLEEP);
4579 path->beep_wid = wid;
4580 path->pin_wid[0] = widget->wid_wid;
4581 path->pin_nums = 1;
4582 path->path_type = BEEP;
4583 beeppath = 1;
4584 path->codec = codec;
4585 path->statep = statep;
4586 widget->path_flags |= AUDIOHD_PATH_BEEP;
4587 widget->beep_path_next = i;
4588 statep->path[statep->pathnum++] = path;
4589 break;
4590 }
4591 }
4592
4593 if (!beeppath) {
4594 for (int i = 0; i < AUDIOHD_CODEC_MAX; i++) {
4595 codec = statep->codec[i];
4596 if (codec == NULL)
4597 continue;
4598 for (wid = codec->first_wid; wid <= codec->last_wid;
4599 wid++) {
4600 widget = codec->widget[wid];
4601
4602 if (widget->type == WTYPE_BEEP) {
4603 path = (audiohd_path_t *)
4604 kmem_zalloc(sizeof (audiohd_path_t),
4605 KM_SLEEP);
4606 path->beep_wid = wid;
4607 path->pin_nums = 0;
4608 path->path_type = BEEP;
4609 beeppath = 1;
4610 path->codec = codec;
4611 path->statep = statep;
4612 widget->path_flags |= AUDIOHD_PATH_BEEP;
4613 statep->path[statep->pathnum++] = path;
4614 break;
4615 }
4616 }
4617 }
4618 }
4619 } /* audiohd_build_beep_path() */
4620
4621 /*
4622 * audiohd_build_beep_amp
4623 *
4624 * Description:
4625 * Find the gain control and mute control widget
4626 */
4627 static void
4628 audiohd_build_beep_amp(hda_codec_t *codec)
4629 {
4630 audiohd_path_t *path;
4631 audiohd_widget_t *widget, *wpin, *wbeep;
4632 wid_t wid, next;
4633 int i, j;
4634 uint32_t gain;
4635
4636 for (i = 0; i < codec->statep->pathnum; i++) {
4637 path = codec->statep->path[i];
4638 if (path == NULL || path->path_type != BEEP ||
4639 path->codec != codec)
4640 continue;
4641 if (path->pin_nums == 0) {
4642 path->mute_wid = path->beep_wid;
4643 path->mute_dir = AUDIOHDC_AMP_SET_OUTPUT;
4644 wbeep = codec->widget[path->beep_wid];
4645 gain = (wbeep->outamp_cap &
4646 AUDIOHDC_AMP_CAP_STEP_NUMS);
4647 if (gain) {
4648 path->gain_dir = AUDIOHDC_AMP_SET_OUTPUT;
4649 path->gain_bits = gain;
4650 path->gain_wid = path->beep_wid;
4651 }
4652 path->gain_bits >>= AUDIOHD_GAIN_OFF;
4653 break;
4654 }
4655 for (j = 0; j < path->pin_nums; j++) {
4656 wid = path->pin_wid[j];
4657 wpin = codec->widget[wid];
4658 wbeep = codec->widget[path->beep_wid];
4659
4660 widget = wpin;
4661 while (widget) {
4662 if (widget->out_weight == 0 &&
4663 widget->outamp_cap &
4664 AUDIOHDC_AMP_CAP_MUTE_CAP) {
4665 path->mute_wid = widget->wid_wid;
4666 path->mute_dir =
4667 AUDIOHDC_AMP_SET_OUTPUT;
4668 break;
4669 }
4670 next = widget->beep_path_next;
4671 if (next == AUDIOHD_NULL_CONN)
4672 break;
4673 wid = widget->avail_conn[next];
4674 widget = codec->widget[wid];
4675 }
4676
4677 gain = 0;
4678 widget = wpin;
4679 while (widget) {
4680 if (widget->out_weight == 0 &&
4681 widget->outamp_cap &
4682 AUDIOHDC_AMP_CAP_STEP_NUMS) {
4683 gain = (widget->outamp_cap &
4684 AUDIOHDC_AMP_CAP_STEP_NUMS);
4685 if (gain && gain > path->gain_bits) {
4686 path->gain_dir =
4687 AUDIOHDC_AMP_SET_OUTPUT;
4688 path->gain_bits = gain;
4689 path->gain_wid =
4690 widget->wid_wid;
4691 }
4692 }
4693 next = widget->beep_path_next;
4694 if (next == AUDIOHD_NULL_CONN)
4695 break;
4696 wid = widget->avail_conn[next];
4697 widget = codec->widget[wid];
4698 }
4699 path->gain_bits >>= AUDIOHD_GAIN_OFF;
4700 }
4701 }
4702 } /* audiohd_build_beep_amp */
4703
4704 /*
4705 * audiohd_finish_beep_path()
4706 *
4707 * Description:
4708 * Enable the widgets on the beep path
4709 */
4710 static void
4711 audiohd_finish_beep_path(hda_codec_t *codec)
4712 {
4713 audiohd_state_t *statep = codec->statep;
4714 audiohd_path_t *path;
4715 audiohd_widget_t *widget;
4716 uint_t caddr = codec->index;
4717 wid_t wid, next;
4718 int i, j;
4719
4720 for (i = 0; i < codec->statep->pathnum; i++) {
4721 path = codec->statep->path[i];
4722 if (!path || path->path_type != BEEP || path->codec != codec)
4723 continue;
4724 if (path->pin_nums == 0) {
4725 widget = codec->widget[path->beep_wid];
4726 if (widget->outamp_cap) {
4727 (void) audioha_codec_4bit_verb_get(
4728 statep, caddr,
4729 path->beep_wid, AUDIOHDC_VERB_SET_AMP_MUTE,
4730 AUDIOHDC_AMP_SET_LR_OUTPUT |
4731 AUDIOHDC_GAIN_MAX);
4732 }
4733 if (widget->inamp_cap) {
4734 (void) audioha_codec_4bit_verb_get(
4735 statep, caddr,
4736 path->beep_wid, AUDIOHDC_VERB_SET_AMP_MUTE,
4737 AUDIOHDC_AMP_SET_LR_INPUT |
4738 AUDIOHDC_GAIN_MAX |
4739 (widget->beep_path_next <<
4740 AUDIOHDC_AMP_SET_INDEX_OFFSET));
4741 }
4742 continue;
4743 }
4744
4745 for (j = 0; j < path->pin_nums; j++) {
4746 wid = path->pin_wid[j];
4747 widget = codec->widget[wid];
4748
4749 (void) audioha_codec_verb_get(statep, caddr, wid,
4750 AUDIOHDC_VERB_SET_CONN_SEL, widget->beep_path_next);
4751
4752 wid = widget->avail_conn[widget->beep_path_next];
4753 widget = codec->widget[wid];
4754
4755 while (widget) {
4756 /*
4757 * Set all amplifiers in this path to
4758 * the maximum volume and unmute them.
4759 */
4760 if (widget->out_weight != 0)
4761 continue;
4762 if (widget->outamp_cap) {
4763 (void) audioha_codec_4bit_verb_get(
4764 statep, caddr,
4765 wid, AUDIOHDC_VERB_SET_AMP_MUTE,
4766 AUDIOHDC_AMP_SET_LR_OUTPUT |
4767 AUDIOHDC_GAIN_MAX);
4768 }
4769 if (widget->inamp_cap) {
4770 (void) audioha_codec_4bit_verb_get(
4771 statep, caddr,
4772 wid, AUDIOHDC_VERB_SET_AMP_MUTE,
4773 AUDIOHDC_AMP_SET_LR_INPUT |
4774 AUDIOHDC_GAIN_MAX |
4775 (widget->beep_path_next <<
4776 AUDIOHDC_AMP_SET_INDEX_OFFSET));
4777 }
4778
4779 next = widget->beep_path_next;
4780 if (next == AUDIOHD_NULL_CONN)
4781 break;
4782 /*
4783 * Accoding to HD spec, mixer doesn't support
4784 * "select connection"
4785 */
4786 if ((widget->type != WTYPE_AUDIO_MIX) &&
4787 (widget->nconns > 1))
4788 (void) audioha_codec_verb_get(statep,
4789 caddr, wid,
4790 AUDIOHDC_VERB_SET_CONN_SEL,
4791 widget->beep_path_next);
4792
4793 wid = widget->avail_conn[next];
4794 widget = codec->widget[wid];
4795 }
4796 }
4797 }
4798 } /* audiohd_finish_beep_path */
4799
4800 static int
4801 audiohd_find_output_pins(hda_codec_t *codec, wid_t wid, int depth,
4802 audiohd_path_t *path)
4803 {
4804 audiohd_widget_t *widget = codec->widget[wid];
4805 audiohd_pin_t *pin = NULL;
4806 int num, retval = (DDI_FAILURE);
4807
4808 if (depth > AUDIOHD_MAX_DEPTH)
4809 return (retval);
4810 if (widget == NULL)
4811 return (retval);
4812
4813 switch (widget->type) {
4814 case WTYPE_PIN:
4815 pin = (audiohd_pin_t *)widget->priv;
4816 if (pin->no_phys_conn)
4817 return (DDI_FAILURE);
4818
4819 switch (pin->device) {
4820 case DTYPE_LINE_IN:
4821 /* Connection between line-in and output pins */
4822 path->pin_wid[path->pin_nums++] = wid;
4823 break;
4824 case DTYPE_LINEOUT:
4825 case DTYPE_HP_OUT:
4826 case DTYPE_SPDIF_OUT:
4827 widget->path_flags |= AUDIOHD_PATH_LOOPBACK;
4828 widget->in_weight++;
4829 pin->adc_wid = path->adda_wid;
4830 path->pin_wid[path->pin_nums++] = wid;
4831 retval = (DDI_SUCCESS);
4832 break;
4833 default:
4834 break;
4835 }
4836 break;
4837 case WTYPE_AUDIO_MIX:
4838 case WTYPE_AUDIO_SEL:
4839 /*
4840 * If the sum widget has only one input, we don't
4841 * consider it as a real sum widget.
4842 */
4843 if (widget->nconns == 1) {
4844 widget->loopback_path_next = 0;
4845 retval = audiohd_find_output_pins(codec,
4846 widget->avail_conn[0], depth + 1, path);
4847 if (retval == (DDI_SUCCESS)) {
4848 widget->path_flags |= AUDIOHD_PATH_LOOPBACK;
4849 widget->in_weight++;
4850 }
4851 break;
4852 }
4853
4854 for (int i = 0; i < widget->nconns; i++) {
4855 retval = audiohd_find_output_pins(codec,
4856 widget->avail_conn[i], depth + 1, path);
4857 if (retval == (DDI_SUCCESS)) {
4858 widget->loopback_path_next = i;
4859 widget->in_weight++;
4860 num = path->pin_nums - 1;
4861 path->sum_selconn[num] = i;
4862 path->sum_wid = wid;
4863 widget->path_flags |= AUDIOHD_PATH_LOOPBACK;
4864 break;
4865 }
4866 }
4867 break;
4868 default:
4869 break;
4870 }
4871
4872 return (retval);
4873 }
4874
4875 static void
4876 audiohd_build_loopback_path(hda_codec_t *codec)
4877 {
4878 audiohd_state_t *statep = codec->statep;
4879 audiohd_widget_t *widget;
4880 audiohd_path_t *path = NULL;
4881 wid_t wid;
4882 int i, retval;
4883 uint8_t rtag = 0;
4884
4885 for (wid = codec->first_wid; wid <= codec->last_wid; wid++) {
4886 widget = codec->widget[wid];
4887
4888 /* check if it is an ADC widget */
4889 if (widget == NULL || widget->type != WTYPE_AUDIO_IN)
4890 continue;
4891
4892 if (path == NULL)
4893 path = kmem_zalloc(sizeof (audiohd_path_t), KM_SLEEP);
4894 else
4895 bzero(path, sizeof (audiohd_port_t));
4896 path->adda_wid = wid;
4897
4898 for (i = 0; i < widget->nconns; i++) {
4899 retval = audiohd_find_output_pins(codec,
4900 widget->avail_conn[i], 0, path);
4901 if (retval == (DDI_SUCCESS)) {
4902 path->codec = codec;
4903 path->statep = statep;
4904 path->path_type = LOOPBACK;
4905 path->tag = ++rtag;
4906 codec->nistream++;
4907 statep->path[statep->pathnum++] = path;
4908 widget->loopback_path_next = i;
4909 widget->priv = path;
4910 path = NULL;
4911 statep->loopback_supported = B_TRUE;
4912 break;
4913 }
4914 }
4915 }
4916
4917
4918 if (path)
4919 kmem_free(path, sizeof (audiohd_path_t));
4920 } /* audiohd_build_loopback_path() */
4921
4922 /*
4923 * audiohd_build_path()
4924 *
4925 * Description:
4926 * Here we build the output, input, monitor path.
4927 * And also enable the path in default.
4928 * Search for the gain and mute control for the path
4929 */
4930 static void
4931 audiohd_build_path(audiohd_state_t *statep)
4932 {
4933 int i;
4934
4935 for (i = 0; i < AUDIOHD_CODEC_MAX; i++) {
4936 if (statep->codec[i]) {
4937 audiohd_build_output_path(statep->codec[i]);
4938 audiohd_build_output_amp(statep->codec[i]);
4939 audiohd_finish_output_path(statep->codec[i]);
4940
4941 audiohd_build_input_path(statep->codec[i]);
4942 audiohd_build_input_amp(statep->codec[i]);
4943 audiohd_finish_input_path(statep->codec[i]);
4944
4945 audiohd_build_monitor_path(statep->codec[i]);
4946 audiohd_build_monitor_amp(statep->codec[i]);
4947 audiohd_finish_monitor_path(statep->codec[i]);
4948
4949 audiohd_build_beep_path(statep->codec[i]);
4950 audiohd_build_beep_amp(statep->codec[i]);
4951 audiohd_finish_beep_path(statep->codec[i]);
4952
4953 audiohd_build_loopback_path(statep->codec[i]);
4954 }
4955 }
4956 } /* audiohd_build_path */
4957
4958 /*
4959 * audiohd_allocate_port()
4960 */
4961 static int
4962 audiohd_allocate_port(audiohd_state_t *statep)
4963 {
4964 int i, j;
4965 audiohd_port_t *port;
4966 int dir;
4967 unsigned caps;
4968 int rc;
4969 audio_dev_t *adev;
4970 dev_info_t *dip;
4971 ddi_dma_cookie_t cookie;
4972 uint_t count;
4973 uint64_t buf_phys_addr;
4974 sd_bdle_t *entry;
4975 uint16_t gcap;
4976 size_t real_size;
4977
4978 adev = statep->adev;
4979 dip = statep->hda_dip;
4980
4981 ddi_dma_attr_t dma_attr = {
4982 DMA_ATTR_V0, /* version */
4983 0, /* addr_lo */
4984 0xffffffffffffffffULL, /* addr_hi */
4985 0x00000000ffffffffULL, /* count_max */
4986 128, /* 128-byte alignment as HD spec */
4987 0xfff, /* burstsize */
4988 1, /* minxfer */
4989 0xffffffff, /* maxxfer */
4990 0xffffffff, /* seg */
4991 1, /* sgllen */
4992 1, /* granular */
4993 0 /* flags */
4994 };
4995
4996 gcap = AUDIOHD_REG_GET16(AUDIOHD_REG_GCAP);
4997 if ((gcap & AUDIOHDR_GCAP_64OK) == 0)
4998 dma_attr.dma_attr_addr_hi = 0xffffffffUL;
4999
5000 for (i = 0; i < PORT_MAX; i++) {
5001 port = kmem_zalloc(sizeof (*port), KM_SLEEP);
5002 statep->port[i] = port;
5003 port->statep = statep;
5004 switch (i) {
5005 case PORT_ADC:
5006 dir = DDI_DMA_READ | DDI_DMA_CONSISTENT;
5007 caps = ENGINE_INPUT_CAP;
5008 port->sync_dir = DDI_DMA_SYNC_FORKERNEL;
5009 port->nchan = statep->rchan;
5010 port->index = 1;
5011 port->regoff = AUDIOHD_REG_SD_BASE;
5012 break;
5013 case PORT_DAC:
5014 dir = DDI_DMA_WRITE | DDI_DMA_CONSISTENT;
5015 caps = ENGINE_OUTPUT_CAP;
5016 port->sync_dir = DDI_DMA_SYNC_FORDEV;
5017 port->nchan = statep->pchan;
5018 port->index = statep->hda_input_streams + 1;
5019 port->regoff = AUDIOHD_REG_SD_BASE +
5020 AUDIOHD_REG_SD_LEN *
5021 statep->hda_input_streams;
5022 break;
5023 default:
5024 return (DDI_FAILURE);
5025 }
5026
5027 switch (statep->sample_rate) {
5028 case 192000:
5029 port->format = 0x18 << 4;
5030 break;
5031 case 96000:
5032 port->format = 0x08 << 4;
5033 break;
5034 case 48000:
5035 default: /* 48kHz is default */
5036 port->format = 0x00;
5037 break;
5038 }
5039
5040 switch (statep->sample_bit_depth) {
5041 case AUDIOHD_BIT_DEPTH24:
5042 port->format |= 0x3;
5043 statep->sample_packed_bytes = 4;
5044 break;
5045 case AUDIOHD_BIT_DEPTH16:
5046 default: /* 16 bits is default */
5047 port->format |= 0x1;
5048 statep->sample_packed_bytes = 2;
5049 break;
5050 }
5051
5052 port->nframes = 1024 * AUDIOHD_BDLE_NUMS *
5053 statep->sample_rate / 48000;
5054 port->fragsize = 1024 * port->nchan *
5055 statep->sample_packed_bytes *
5056 statep->sample_rate / 48000;
5057 port->bufsize = port->nframes * port->nchan *
5058 statep->sample_packed_bytes;
5059
5060 /* allocate dma handle */
5061 rc = ddi_dma_alloc_handle(dip, &dma_attr, DDI_DMA_SLEEP,
5062 NULL, &port->samp_dmah);
5063 if (rc != DDI_SUCCESS) {
5064 audio_dev_warn(adev, "ddi_dma_alloc_handle failed: %d",
5065 rc);
5066 return (DDI_FAILURE);
5067 }
5068
5069 /*
5070 * Warning: please be noted that allocating the dma memory
5071 * with the flag IOMEM_DATA_UNCACHED is a hack due
5072 * to an incorrect cache synchronization on NVidia MCP79
5073 * chipset which causes the audio distortion problem,
5074 * and that it should be fixed later. There should be
5075 * no reason you have to allocate UNCACHED memory. In
5076 * complex architectures with nested IO caches,
5077 * reliance on this flag might lead to failure.
5078 */
5079 rc = ddi_dma_mem_alloc(port->samp_dmah, port->bufsize,
5080 &hda_dev_accattr, DDI_DMA_CONSISTENT | IOMEM_DATA_UNCACHED,
5081 DDI_DMA_SLEEP, NULL, &port->samp_kaddr,
5082 &real_size, &port->samp_acch);
5083 if (rc == DDI_FAILURE) {
5084 if (ddi_dma_mem_alloc(port->samp_dmah, port->bufsize,
5085 &hda_dev_accattr, DDI_DMA_CONSISTENT,
5086 DDI_DMA_SLEEP, NULL,
5087 &port->samp_kaddr, &real_size,
5088 &port->samp_acch) != DDI_SUCCESS) {
5089 audio_dev_warn(adev,
5090 "ddi_dma_mem_alloc failed");
5091 return (DDI_FAILURE);
5092 }
5093 }
5094
5095 /* bind DMA buffer */
5096 rc = ddi_dma_addr_bind_handle(port->samp_dmah, NULL,
5097 port->samp_kaddr, real_size, dir,
5098 DDI_DMA_SLEEP, NULL, &cookie, &count);
5099 if ((rc != DDI_DMA_MAPPED) || (count != 1)) {
5100 audio_dev_warn(adev,
5101 "ddi_dma_addr_bind_handle failed: %d", rc);
5102 return (DDI_FAILURE);
5103 }
5104 port->samp_paddr = (uint64_t)cookie.dmac_laddress;
5105
5106 /*
5107 * now, from here we allocate DMA
5108 * memory for buffer descriptor list.
5109 * we allocate adjacent DMA memory for all DMA engines.
5110 */
5111 rc = ddi_dma_alloc_handle(dip, &dma_attr, DDI_DMA_SLEEP,
5112 NULL, &port->bdl_dmah);
5113 if (rc != DDI_SUCCESS) {
5114 audio_dev_warn(adev,
5115 "ddi_dma_alloc_handle(bdlist) failed");
5116 return (DDI_FAILURE);
5117 }
5118
5119 /*
5120 * we allocate all buffer descriptors lists in continuous
5121 * dma memory.
5122 */
5123 port->bdl_size = sizeof (sd_bdle_t) * AUDIOHD_BDLE_NUMS;
5124 rc = ddi_dma_mem_alloc(port->bdl_dmah, port->bdl_size,
5125 &hda_dev_accattr, DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, NULL,
5126 &port->bdl_kaddr, &real_size, &port->bdl_acch);
5127 if (rc != DDI_SUCCESS) {
5128 audio_dev_warn(adev,
5129 "ddi_dma_mem_alloc(bdlist) failed");
5130 return (DDI_FAILURE);
5131 }
5132
5133 rc = ddi_dma_addr_bind_handle(port->bdl_dmah, NULL,
5134 port->bdl_kaddr,
5135 real_size, DDI_DMA_WRITE | DDI_DMA_CONSISTENT,
5136 DDI_DMA_SLEEP,
5137 NULL, &cookie, &count);
5138 if ((rc != DDI_DMA_MAPPED) || (count != 1)) {
5139 audio_dev_warn(adev, "addr_bind_handle failed");
5140 return (DDI_FAILURE);
5141 }
5142 port->bdl_paddr = (uint64_t)cookie.dmac_laddress;
5143
5144 entry = (sd_bdle_t *)port->bdl_kaddr;
5145 buf_phys_addr = port->samp_paddr;
5146
5147 for (j = 0; j < AUDIOHD_BDLE_NUMS; j++) {
5148 entry->sbde_addr = buf_phys_addr;
5149 entry->sbde_len = port->fragsize;
5150 entry->sbde_ioc = 1;
5151 buf_phys_addr += port->fragsize;
5152 entry++;
5153 }
5154 (void) ddi_dma_sync(port->bdl_dmah, 0, sizeof (sd_bdle_t) *
5155 AUDIOHD_BDLE_NUMS, DDI_DMA_SYNC_FORDEV);
5156 port->curpos = 0;
5157
5158 port->engine = audio_engine_alloc(&audiohd_engine_ops, caps);
5159 if (port->engine == NULL) {
5160 return (DDI_FAILURE);
5161 }
5162
5163 audio_engine_set_private(port->engine, port);
5164 audio_dev_add_engine(adev, port->engine);
5165 }
5166
5167 return (DDI_SUCCESS);
5168 }
5169
5170 static void
5171 audiohd_free_port(audiohd_state_t *statep)
5172 {
5173 int i;
5174 audiohd_port_t *port;
5175
5176 for (i = 0; i < PORT_MAX; i++) {
5177 port = statep->port[i];
5178 if (port == NULL)
5179 continue;
5180 if (port->engine) {
5181 audio_dev_remove_engine(statep->adev,
5182 port->engine);
5183 audio_engine_free(port->engine);
5184 }
5185 if (port->samp_dmah) {
5186 (void) ddi_dma_unbind_handle(port->samp_dmah);
5187 }
5188 if (port->samp_acch) {
5189 ddi_dma_mem_free(&port->samp_acch);
5190 }
5191 if (port->samp_dmah) {
5192 ddi_dma_free_handle(&port->samp_dmah);
5193 }
5194 if (port->bdl_dmah) {
5195 (void) ddi_dma_unbind_handle(port->bdl_dmah);
5196 }
5197 if (port->bdl_acch) {
5198 ddi_dma_mem_free(&port->bdl_acch);
5199 }
5200 if (port->bdl_dmah) {
5201 ddi_dma_free_handle(&port->bdl_dmah);
5202 }
5203
5204 kmem_free(port, sizeof (audiohd_port_t));
5205 }
5206 }
5207
5208 /*
5209 * audiohd_change_widget_power_state(audiohd_state_t *statep, int state)
5210 * Description:
5211 * This routine is used to change the widget power betwen D0 and D2.
5212 * D0 is fully on; D2 allows the lowest possible power consuming state
5213 * from which it can return to the fully on state: D0.
5214 */
5215 static void
5216 audiohd_change_widget_power_state(audiohd_state_t *statep, int state)
5217 {
5218 int i;
5219 wid_t wid;
5220 hda_codec_t *codec;
5221 audiohd_widget_t *widget;
5222
5223 for (i = 0; i < AUDIOHD_CODEC_MAX; i++) {
5224 codec = statep->codec[i];
5225 if (codec == NULL)
5226 continue;
5227 for (wid = codec->first_wid; wid <= codec->last_wid;
5228 wid++) {
5229 widget = codec->widget[wid];
5230 if (widget->widget_cap &
5231 AUDIOHD_WIDCAP_PWRCTRL) {
5232 (void) audioha_codec_verb_get(statep,
5233 codec->index, wid,
5234 AUDIOHDC_VERB_SET_POWER_STATE,
5235 state);
5236 }
5237 }
5238 }
5239 }
5240 /*
5241 * audiohd_restore_path()
5242 * Description:
5243 * This routine is used to restore the path on the codec.
5244 */
5245 static void
5246 audiohd_restore_path(audiohd_state_t *statep)
5247 {
5248 int i;
5249 hda_codec_t *codec;
5250
5251 for (i = 0; i < AUDIOHD_CODEC_MAX; i++) {
5252 codec = statep->codec[i];
5253 if (codec == NULL)
5254 continue;
5255 audiohd_finish_output_path(statep->codec[i]);
5256 audiohd_finish_input_path(statep->codec[i]);
5257 audiohd_finish_monitor_path(statep->codec[i]);
5258 audiohd_finish_beep_path(statep->codec[i]);
5259 }
5260 }
5261
5262 /*
5263 * audiohd_reset_pins_ur_cap()
5264 * Description:
5265 * Enable the unsolicited response of the pins which have the unsolicited
5266 * response capability
5267 */
5268 static void
5269 audiohd_reset_pins_ur_cap(audiohd_state_t *statep)
5270 {
5271 hda_codec_t *codec;
5272 audiohd_pin_t *pin;
5273 audiohd_widget_t *widget;
5274 uint32_t urctrl;
5275 int i;
5276
5277 for (i = 0; i < AUDIOHD_CODEC_MAX; i++) {
5278 codec = statep->codec[i];
5279 if (codec == NULL)
5280 continue;
5281 pin = codec->first_pin;
5282 while (pin) {
5283 /* enable the unsolicited response of the pin */
5284 widget = codec->widget[pin->wid];
5285 if ((widget->widget_cap &
5286 (AUDIOHD_URCAP_MASK) &&
5287 (pin->cap & AUDIOHD_DTCCAP_MASK)) &&
5288 ((pin->device == DTYPE_LINEOUT) ||
5289 (pin->device == DTYPE_SPDIF_OUT) ||
5290 (pin->device == DTYPE_HP_OUT) ||
5291 (pin->device == DTYPE_MIC_IN))) {
5292 urctrl = (uint8_t)(1 <<
5293 (AUDIOHD_UR_ENABLE_OFF - 1));
5294 urctrl |= (pin->wid & AUDIOHD_UR_TAG_MASK);
5295 (void) audioha_codec_verb_get(statep,
5296 codec->index,
5297 pin->wid,
5298 AUDIOHDC_VERB_SET_UNS_ENABLE, urctrl);
5299 }
5300 pin = pin->next;
5301 }
5302 }
5303 }
5304 static void
5305 audiohd_restore_codec_gpio(audiohd_state_t *statep)
5306 {
5307 int i;
5308 wid_t wid;
5309 hda_codec_t *codec;
5310
5311 for (i = 0; i < AUDIOHD_CODEC_MAX; i++) {
5312 codec = statep->codec[i];
5313 if (codec == NULL)
5314 continue;
5315 wid = codec->wid_afg;
5316
5317 /* power-up audio function group */
5318 (void) audioha_codec_verb_get(statep, i, wid,
5319 AUDIOHDC_VERB_SET_POWER_STATE, AUDIOHD_PW_D0);
5320
5321 /* work around for Sony VAIO laptop with specific codec */
5322 if ((codec->codec_info->flags & NO_GPIO) == 0) {
5323 /*
5324 * GPIO controls which are laptop specific workarounds
5325 * and might be changed. Some laptops use GPIO,
5326 * so we need to enable and set the GPIO correctly.
5327 */
5328 (void) audioha_codec_verb_get(statep, i, wid,
5329 AUDIOHDC_VERB_SET_GPIO_MASK, AUDIOHDC_GPIO_ENABLE);
5330 (void) audioha_codec_verb_get(statep, i, wid,
5331 AUDIOHDC_VERB_SET_GPIO_DIREC, AUDIOHDC_GPIO_DIRECT);
5332 (void) audioha_codec_verb_get(statep, i, wid,
5333 AUDIOHDC_VERB_SET_GPIO_STCK,
5334 AUDIOHDC_GPIO_DATA_CTRL);
5335 (void) audioha_codec_verb_get(statep, i, wid,
5336 AUDIOHDC_VERB_SET_GPIO_DATA,
5337 AUDIOHDC_GPIO_STCK_CTRL);
5338 }
5339 }
5340 }
5341 /*
5342 * audiohd_resume()
5343 */
5344 static int
5345 audiohd_resume(audiohd_state_t *statep)
5346 {
5347 uint8_t rirbsts;
5348
5349 mutex_enter(&statep->hda_mutex);
5350 statep->suspended = B_FALSE;
5351 /* Restore the hda state */
5352 if (audiohd_reinit_hda(statep) == DDI_FAILURE) {
5353 audio_dev_warn(statep->adev,
5354 "hda reinit failed");
5355 mutex_exit(&statep->hda_mutex);
5356 return (DDI_FAILURE);
5357 }
5358 /* reset to enable the capability of unsolicited response for pin */
5359 audiohd_reset_pins_ur_cap(statep);
5360 /* clear the unsolicited response interrupt */
5361 rirbsts = AUDIOHD_REG_GET8(AUDIOHD_REG_RIRBSTS);
5362 AUDIOHD_REG_SET8(AUDIOHD_REG_RIRBSTS, rirbsts);
5363 /* set widget power to D0 */
5364 audiohd_change_widget_power_state(statep, AUDIOHD_PW_D0);
5365
5366 audiohd_configure_output(statep);
5367 audiohd_configure_input(statep);
5368 mutex_exit(&statep->hda_mutex);
5369
5370 audio_dev_resume(statep->adev);
5371
5372 return (DDI_SUCCESS);
5373 } /* audiohd_resume */
5374
5375 /*
5376 * audiohd_suspend()
5377 */
5378 static int
5379 audiohd_suspend(audiohd_state_t *statep)
5380 {
5381 audio_dev_suspend(statep->adev);
5382
5383 mutex_enter(&statep->hda_mutex);
5384 statep->suspended = B_TRUE;
5385
5386 /* set widget power to D2 */
5387 audiohd_change_widget_power_state(statep, AUDIOHD_PW_D2);
5388 /* Disable h/w */
5389 audiohd_stop_dma(statep);
5390 audiohd_fini_pci(statep);
5391 mutex_exit(&statep->hda_mutex);
5392
5393 return (DDI_SUCCESS);
5394 } /* audiohd_suspend */
5395
5396 /*
5397 * audiohd_disable_pin()
5398 */
5399 static void
5400 audiohd_disable_pin(audiohd_state_t *statep, int caddr, wid_t wid)
5401 {
5402 uint32_t tmp;
5403
5404 tmp = audioha_codec_verb_get(statep, caddr, wid,
5405 AUDIOHDC_VERB_GET_PIN_CTRL, 0);
5406 if (tmp == AUDIOHD_CODEC_FAILURE)
5407 return;
5408 tmp = audioha_codec_verb_get(statep, caddr, wid,
5409 AUDIOHDC_VERB_SET_PIN_CTRL,
5410 (tmp & ~AUDIOHDC_PIN_CONTROL_OUT_ENABLE));
5411 }
5412
5413 /*
5414 * audiohd_enable_pin()
5415 */
5416 static void
5417 audiohd_enable_pin(audiohd_state_t *statep, int caddr, wid_t wid)
5418 {
5419 uint32_t tmp;
5420
5421 tmp = audioha_codec_verb_get(statep, caddr, wid,
5422 AUDIOHDC_VERB_GET_PIN_CTRL, 0);
5423 if (tmp == AUDIOHD_CODEC_FAILURE)
5424 return;
5425 tmp = audioha_codec_verb_get(statep, caddr, wid,
5426 AUDIOHDC_VERB_SET_PIN_CTRL,
5427 tmp | AUDIOHDC_PIN_CONTROL_OUT_ENABLE |
5428 AUDIOHDC_PIN_CONTROL_HP_ENABLE);
5429 }
5430
5431 /*
5432 * audiohd_change_speaker_state()
5433 */
5434 static void
5435 audiohd_change_speaker_state(audiohd_state_t *statep, int on)
5436 {
5437 audiohd_path_t *path;
5438 audiohd_widget_t *widget;
5439 audiohd_pin_t *pin;
5440 int i, j;
5441 wid_t wid;
5442
5443 for (i = 0; i < statep->pathnum; i++) {
5444 path = statep->path[i];
5445 if (!path || path->path_type != PLAY)
5446 continue;
5447 if (on) {
5448 for (j = 0; j < path->pin_nums; j++) {
5449 wid = path->pin_wid[j];
5450 widget = path->codec->widget[wid];
5451 pin = (audiohd_pin_t *)widget->priv;
5452 if (pin->device == DTYPE_SPEAKER) {
5453 audiohd_enable_pin(statep,
5454 path->codec->index,
5455 pin->wid);
5456 }
5457 }
5458
5459 } else {
5460 for (j = 0; j < path->pin_nums; j++) {
5461 wid = path->pin_wid[j];
5462 widget = path->codec->widget[wid];
5463 pin = (audiohd_pin_t *)widget->priv;
5464 if (pin->device == DTYPE_SPEAKER) {
5465 audiohd_disable_pin(statep,
5466 path->codec->index,
5467 pin->wid);
5468 }
5469 }
5470 }
5471 }
5472 }
5473 /*
5474 * audiohd_select_mic()
5475 *
5476 * Description:
5477 * This function is used for the recording path which has a selector
5478 * as the sumwidget. We select the external MIC if it is plugged into the
5479 * MIC jack, otherwise the internal integrated MIC is selected.
5480 */
5481 static void
5482 audiohd_select_mic(audiohd_state_t *statep, uint8_t index,
5483 uint8_t id, int select)
5484 {
5485 hda_codec_t *codec;
5486 audiohd_path_t *path;
5487 audiohd_widget_t *widget, *sumwgt = NULL;
5488 audiohd_pin_t *pin;
5489 int i, j;
5490 wid_t wid;
5491
5492 codec = statep->codec[index];
5493 if (codec == NULL)
5494 return;
5495
5496 for (i = 0; i < statep->pathnum; i++) {
5497 path = statep->path[i];
5498 if (path->codec != codec || path->path_type != RECORD)
5499 continue;
5500 sumwgt = codec->widget[path->sum_wid];
5501
5502 for (j = 0; j < path->pin_nums; j++) {
5503 wid = path->pin_wid[j];
5504 widget = codec->widget[wid];
5505 pin = (audiohd_pin_t *)widget->priv;
5506
5507 if (pin->device != DTYPE_MIC_IN)
5508 continue;
5509
5510 if (sumwgt != NULL &&
5511 sumwgt->type == WTYPE_AUDIO_SEL) {
5512 /* Have a selector to choose input pin */
5513
5514 if (select && pin->wid == id &&
5515 (((pin->config >>
5516 AUDIOHD_PIN_CONTP_OFF) &
5517 AUDIOHD_PIN_CONTP_MASK) ==
5518 AUDIOHD_PIN_CON_JACK)) {
5519 (void) audioha_codec_verb_get(
5520 statep,
5521 index,
5522 path->sum_wid,
5523 AUDIOHDC_VERB_SET_CONN_SEL,
5524 path->sum_selconn[j]);
5525 statep->port[PORT_ADC]->index =
5526 path->tag;
5527 return;
5528 } else if (!select && pin->wid != id &&
5529 (((pin->config >>
5530 AUDIOHD_PIN_CONTP_OFF) &
5531 AUDIOHD_PIN_CONTP_MASK) ==
5532 AUDIOHD_PIN_CON_FIXED)) {
5533 (void) audioha_codec_verb_get(
5534 statep,
5535 index,
5536 path->sum_wid,
5537 AUDIOHDC_VERB_SET_CONN_SEL,
5538 path->sum_selconn[j]);
5539 statep->port[PORT_ADC]->index =
5540 path->tag;
5541 return;
5542 }
5543 } else {
5544 /*
5545 * No selector widget in the path,
5546 * mute unselected input pin
5547 */
5548
5549 /* Open all input pin, and then mute others */
5550 audiohd_set_pin_volume(statep, DTYPE_MIC_IN);
5551
5552 if (select == 1) {
5553 /* Select external mic, mute internal */
5554 if (wid != id) {
5555 (void)
5556 audioha_codec_4bit_verb_get(
5557 statep, path->codec->index,
5558 wid,
5559 AUDIOHDC_VERB_SET_AMP_MUTE,
5560 path->mute_dir |
5561 AUDIOHDC_AMP_SET_LNR |
5562 AUDIOHDC_AMP_SET_MUTE);
5563 }
5564 } else {
5565 /* Select internal mic, mute external */
5566 if (wid == id) {
5567 (void)
5568 audioha_codec_4bit_verb_get(
5569 statep, path->codec->index,
5570 wid,
5571 AUDIOHDC_VERB_SET_AMP_MUTE,
5572 path->mute_dir |
5573 AUDIOHDC_AMP_SET_LNR |
5574 AUDIOHDC_AMP_SET_MUTE);
5575 }
5576 }
5577 }
5578 }
5579 }
5580
5581 /*
5582 * If the input istream > 1, we should set the record stream tag
5583 * respectively. All the input streams sharing one tag may make the
5584 * record sound distorted.
5585 */
5586 if (codec->nistream > 1) {
5587 for (i = 0; i < statep->pathnum; i++) {
5588 path = statep->path[i];
5589 if (!path || path->path_type != RECORD)
5590 continue;
5591 for (j = 0; j < path->pin_nums; j++) {
5592 wid = path->pin_wid[j];
5593 widget = codec->widget[wid];
5594 if (widget == NULL)
5595 return;
5596 pin = (audiohd_pin_t *)widget->priv;
5597 if (select &&
5598 pin->device == DTYPE_MIC_IN &&
5599 pin->wid == id &&
5600 (((pin->config >>
5601 AUDIOHD_PIN_CONTP_OFF) &
5602 AUDIOHD_PIN_CONTP_MASK) ==
5603 AUDIOHD_PIN_CON_JACK)) {
5604 statep->port[PORT_ADC]->index =
5605 path->tag;
5606 return;
5607 } else if (!select &&
5608 pin->device == DTYPE_MIC_IN &&
5609 (((pin->config >>
5610 AUDIOHD_PIN_CONTP_OFF) &
5611 AUDIOHD_PIN_CONTP_MASK) ==
5612 AUDIOHD_PIN_CON_FIXED)) {
5613 statep->port[PORT_ADC]->index =
5614 path->tag;
5615 return;
5616 }
5617 }
5618 }
5619 }
5620 }
5621 /*
5622 * audiohd_pin_sense()
5623 *
5624 * Description
5625 *
5626 * When the earphone is plugged into the jack associtated with the pin
5627 * complex, we disable the built in speaker. When the earphone is plugged
5628 * out of the jack, we enable the built in speaker.
5629 */
5630 static void
5631 audiohd_pin_sense(audiohd_state_t *statep, uint32_t resp, uint32_t respex)
5632 {
5633 uint8_t index;
5634 uint8_t id;
5635 uint32_t rs;
5636 audiohd_widget_t *widget;
5637 audiohd_pin_t *pin;
5638 hda_codec_t *codec;
5639
5640 index = respex & AUDIOHD_RIRB_CODEC_MASK;
5641 id = resp >> (AUDIOHD_RIRB_WID_OFF - 1);
5642
5643 codec = statep->codec[index];
5644 if (codec == NULL)
5645 return;
5646 widget = codec->widget[id];
5647 if (widget == NULL)
5648 return;
5649
5650 rs = audioha_codec_verb_get(statep, index, id,
5651 AUDIOHDC_VERB_GET_PIN_SENSE, 0);
5652 if (rs & AUDIOHD_PIN_PRES_MASK) {
5653 /* A MIC is plugged in, we select the MIC as input */
5654 if ((widget->type == WTYPE_PIN) &&
5655 (pin = (audiohd_pin_t *)widget->priv) &&
5656 (pin->device == DTYPE_MIC_IN)) {
5657 audiohd_select_mic(statep, index, id, 1);
5658 return;
5659 }
5660 /* output pin is plugged */
5661 audiohd_change_speaker_state(statep, AUDIOHD_SP_OFF);
5662 } else {
5663 /*
5664 * A MIC is unplugged, we select the built in MIC
5665 * as input.
5666 */
5667 if ((widget->type == WTYPE_PIN) &&
5668 (pin = (audiohd_pin_t *)widget->priv) &&
5669 (pin->device == DTYPE_MIC_IN)) {
5670 audiohd_select_mic(statep, index, id, 0);
5671 return;
5672 }
5673 /* output pin is unplugged */
5674 audiohd_change_speaker_state(statep, AUDIOHD_SP_ON);
5675 }
5676
5677 }
5678
5679 /*
5680 * audiohd_disable_intr()
5681 *
5682 * Description:
5683 * Disable all possible interrupts.
5684 */
5685 static void
5686 audiohd_disable_intr(audiohd_state_t *statep)
5687 {
5688 int i;
5689 uint32_t base;
5690
5691 AUDIOHD_REG_SET32(AUDIOHD_REG_INTCTL, 0);
5692 base = AUDIOHD_REG_SD_BASE;
5693 for (i = 0; i < statep->hda_streams_nums; i++) {
5694 AUDIOHD_REG_SET8(base + AUDIOHD_SDREG_OFFSET_STS,
5695 AUDIOHDR_SD_STS_INTRS);
5696 base += AUDIOHD_REG_SD_LEN;
5697 }
5698 AUDIOHD_REG_SET32(AUDIOHD_REG_INTSTS, (uint32_t)(-1));
5699
5700 } /* audiohd_disable_intr() */
5701
5702
5703 /*
5704 * audiohd_12bit_verb_to_codec()
5705 *
5706 * Description:
5707 *
5708 */
5709 static int
5710 audiohd_12bit_verb_to_codec(audiohd_state_t *statep, uint8_t caddr,
5711 uint8_t wid,
5712 uint16_t cmd, uint8_t param)
5713 {
5714 uint32_t verb;
5715 uint16_t wptr;
5716 uint16_t rptr;
5717
5718 ASSERT((cmd & AUDIOHDC_12BIT_VERB_MASK) == 0);
5719
5720 wptr = AUDIOHD_REG_GET16(AUDIOHD_REG_CORBWP) & AUDIOHD_CMDIO_ENT_MASK;
5721 rptr = AUDIOHD_REG_GET16(AUDIOHD_REG_CORBRP) & AUDIOHD_CMDIO_ENT_MASK;
5722
5723 wptr++;
5724 wptr &= AUDIOHD_CMDIO_ENT_MASK;
5725
5726 /* overflow */
5727 if (wptr == rptr) {
5728 return (DDI_FAILURE);
5729 }
5730
5731 verb = (caddr & 0x0f) << AUDIOHD_VERB_ADDR_OFF;
5732 verb |= wid << AUDIOHD_VERB_NID_OFF;
5733 verb |= cmd << AUDIOHD_VERB_CMD_OFF;
5734 verb |= param;
5735
5736 *((uint32_t *)(statep->hda_dma_corb.ad_vaddr) + wptr) = verb;
5737 (void) ddi_dma_sync(statep->hda_dma_corb.ad_dmahdl, 0,
5738 sizeof (sd_bdle_t) * AUDIOHD_BDLE_NUMS, DDI_DMA_SYNC_FORDEV);
5739 AUDIOHD_REG_SET16(AUDIOHD_REG_CORBWP, wptr);
5740
5741 return (DDI_SUCCESS);
5742
5743 } /* audiohd_12bit_verb_to_codec() */
5744
5745 /*
5746 * audiohd_4bit_verb_to_codec()
5747 *
5748 * Description:
5749 *
5750 */
5751 static int
5752 audiohd_4bit_verb_to_codec(audiohd_state_t *statep, uint8_t caddr,
5753 uint8_t wid,
5754 uint32_t cmd, uint16_t param)
5755 {
5756 uint32_t verb;
5757 uint16_t wptr;
5758 uint16_t rptr;
5759
5760 ASSERT((cmd & AUDIOHDC_4BIT_VERB_MASK) == 0);
5761
5762 wptr = AUDIOHD_REG_GET16(AUDIOHD_REG_CORBWP) & AUDIOHD_CMDIO_ENT_MASK;
5763 rptr = AUDIOHD_REG_GET16(AUDIOHD_REG_CORBRP) & AUDIOHD_CMDIO_ENT_MASK;
5764
5765 wptr++;
5766 wptr &= AUDIOHD_CMDIO_ENT_MASK;
5767
5768 /* overflow */
5769 if (wptr == rptr) {
5770 return (DDI_FAILURE);
5771 }
5772
5773 verb = (caddr & 0x0f) << AUDIOHD_VERB_ADDR_OFF;
5774 verb |= wid << AUDIOHD_VERB_NID_OFF;
5775 verb |= cmd << AUDIOHD_VERB_CMD16_OFF;
5776 verb |= param;
5777
5778 *((uint32_t *)(statep->hda_dma_corb.ad_vaddr) + wptr) = verb;
5779 AUDIOHD_REG_SET16(AUDIOHD_REG_CORBWP, wptr);
5780
5781 return (DDI_SUCCESS);
5782
5783 } /* audiohd_4bit_verb_to_codec() */
5784
5785 /*
5786 * audiohd_response_from_codec()
5787 *
5788 * Description:
5789 *
5790 */
5791 static int
5792 audiohd_response_from_codec(audiohd_state_t *statep, uint32_t *resp,
5793 uint32_t *respex)
5794 {
5795 uint16_t wptr;
5796 uint16_t rptr;
5797 uint32_t *lp;
5798
5799 wptr = AUDIOHD_REG_GET16(AUDIOHD_REG_RIRBWP) & 0x00ff;
5800 rptr = statep->hda_rirb_rp;
5801
5802 if (rptr == wptr) {
5803 return (DDI_FAILURE);
5804 }
5805
5806 rptr++;
5807 rptr &= AUDIOHD_RING_MAX_SIZE;
5808
5809 lp = (uint32_t *)(statep->hda_dma_rirb.ad_vaddr) + (rptr << 1);
5810 *resp = *(lp);
5811 *respex = *(lp + 1);
5812
5813 statep->hda_rirb_rp = rptr;
5814
5815 return (DDI_SUCCESS);
5816
5817 } /* audiohd_response_from_codec() */
5818
5819
5820 /*
5821 * audioha_codec_verb_get()
5822 */
5823 static uint32_t
5824 audioha_codec_verb_get(void *arg, uint8_t caddr, uint8_t wid,
5825 uint16_t verb,
5826 uint8_t param)
5827 {
5828 audiohd_state_t *statep = (audiohd_state_t *)arg;
5829 uint32_t resp;
5830 uint32_t respex;
5831 int ret;
5832 int i;
5833
5834 ret = audiohd_12bit_verb_to_codec(statep, caddr, wid, verb, param);
5835 if (ret != DDI_SUCCESS) {
5836 return (uint32_t)(-1);
5837 }
5838
5839 /*
5840 * Empirical testing times. 50 times is enough for audiohd spec 1.0.
5841 * But we need to make it work for audiohd spec 0.9, which is just a
5842 * draft version and requires more time to wait.
5843 */
5844 for (i = 0; i < 500; i++) {
5845 ret = audiohd_response_from_codec(statep, &resp, &respex);
5846 if (((respex & AUDIOHD_BDLE_RIRB_SDI) == caddr) &&
5847 ((respex & AUDIOHD_BDLE_RIRB_UNSOLICIT) == 0) &&
5848 (ret == DDI_SUCCESS))
5849 break;
5850 /* Empirical testing time, which works well */
5851 drv_usecwait(30);
5852 }
5853
5854 if (ret == DDI_SUCCESS) {
5855 return (resp);
5856 }
5857
5858 if (wid != AUDIOHDC_NODE_ROOT && param != AUDIOHDC_PAR_VENDOR_ID) {
5859 audio_dev_warn(statep->adev, "timeout when get "
5860 "response from codec: wid=%d, verb=0x%04x, param=0x%04x",
5861 wid, verb, param);
5862 }
5863
5864 return ((uint32_t)(-1));
5865
5866 } /* audioha_codec_verb_get() */
5867
5868
5869 /*
5870 * audioha_codec_4bit_verb_get()
5871 */
5872 static uint32_t
5873 audioha_codec_4bit_verb_get(void *arg, uint8_t caddr, uint8_t wid,
5874 uint16_t verb, uint16_t param)
5875 {
5876 audiohd_state_t *statep = (audiohd_state_t *)arg;
5877 uint32_t resp;
5878 uint32_t respex;
5879 int ret;
5880 int i;
5881
5882 ret = audiohd_4bit_verb_to_codec(statep, caddr, wid, verb, param);
5883 if (ret != DDI_SUCCESS) {
5884 return (uint32_t)(-1);
5885 }
5886
5887 for (i = 0; i < 500; i++) {
5888 ret = audiohd_response_from_codec(statep, &resp, &respex);
5889 if (((respex & AUDIOHD_BDLE_RIRB_SDI) == caddr) &&
5890 ((respex & AUDIOHD_BDLE_RIRB_UNSOLICIT) == 0) &&
5891 (ret == DDI_SUCCESS))
5892 break;
5893 /* Empirical testing time, which works well */
5894 drv_usecwait(30);
5895 }
5896
5897 if (ret == DDI_SUCCESS) {
5898 return (resp);
5899 }
5900
5901 audio_dev_warn(statep->adev, "timeout when get "
5902 "response from codec: wid=%d, verb=0x%04x, param=0x%04x",
5903 wid, verb, param);
5904
5905 return ((uint32_t)(-1));
5906
5907 } /* audioha_codec_4bit_verb_get() */