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) 4Front Technologies 1996-2008.
23 *
24 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
25 * Use is subject to license terms.
26 */
27
28 #include <sys/types.h>
29 #include <sys/list.h>
30 #include <sys/sysmacros.h>
31 #include <sys/ddi.h>
32 #include <sys/sunddi.h>
33 #include <sys/audio/audio_driver.h>
34 #include <sys/audio/ac97.h>
35 #include <sys/note.h>
36 #include "ac97_impl.h"
37
38 /*
39 * This is the initial value for many controls. This is
40 * a 75% level.
41 */
42 #define INIT_VAL_MAIN 75
43 #define INIT_VAL_ST ((75 << 8) | 75)
44 #define INIT_VAL_MN 75
45 #define INIT_IGAIN_ST ((50 << 8) | 50)
46 #define INIT_IGAIN_MN 50
47
48 /*
49 * In AC'97 v2.3, the registers are carved up as follows:
50 *
51 * Audio Base Registers: 0x00 - 0x26
52 * Audio Extended Registers: 0x28 - 0x3A
53 * Modem Extended Registers: 0x3C - 0x58
54 * Vendor Reserved Registers: 0x5A - 0x5F
55 * Page Registers: 0x60 - 0x6F
56 * Vendor Reserved Registers: 0x70 - 0x7A
57 * Vendor ID Registers: 0x7C - 0x7F
58 *
59 * We only need to shadow the normal audio registers by default.
60 * TBD: Handling of codec-specific registers in vendor reserved space.
61 * We cannot necessarily meaningfully shadow them.
62 */
63 #define LAST_SHADOW_REG 0x3A
64 #define NUM_SHADOW ((LAST_SHADOW_REG / sizeof (uint16_t)) + 1)
65 #define SHADOW(ac, reg) ((ac)->shadow[((reg) / sizeof (uint16_t))])
66
67 /*
68 * Record source selection.
69 */
70 #define INPUT_MIC 0
71 #define INPUT_CD 1
72 #define INPUT_VIDEO 2
73 #define INPUT_AUXIN 3
74 #define INPUT_LINEIN 4
75 #define INPUT_STEREOMIX 5
76 #define INPUT_MONOMIX 6
77 #define INPUT_PHONE 7
78
79 static const char *ac_insrcs[] = {
80 AUDIO_PORT_MIC,
81 AUDIO_PORT_CD,
82 AUDIO_PORT_VIDEO,
83 AUDIO_PORT_AUX1IN,
84 AUDIO_PORT_LINEIN,
85 AUDIO_PORT_STEREOMIX,
86 AUDIO_PORT_MONOMIX,
87 AUDIO_PORT_PHONE,
88 NULL,
89 };
90
91 /*
92 * Per audio device state structure
93 */
94 struct ac97 {
95 dev_info_t *dip; /* DDI device instance */
96 audio_dev_t *d;
97 void *private; /* drivers devc */
98 ac97_rd_t rd; /* drivers port read routine */
99 ac97_wr_t wr; /* drivers port write routine */
100 char name[128]; /* driver instance name */
101 uint8_t nchan;
102
103 uint16_t shadow[NUM_SHADOW];
104
105 uint32_t flags;
106 #define AC97_FLAG_AMPLIFIER (1 << 0) /* ext. amp on by default */
107 #define AC97_FLAG_MICBOOST (1 << 1) /* micboost on by default */
108 #define AC97_FLAG_SPEAKER (1 << 2) /* mono out on by default */
109
110 #define AC97_FLAG_AUX_HP (1 << 4) /* possible uses for AUX_OUT */
111 #define AC97_FLAG_AUX_4CH (1 << 5)
112 #define AC97_FLAG_AUX_LVL (1 << 6)
113 #define AC97_FLAG_SPEAKER_OK (1 << 7) /* expose mono out */
114 #define AC97_FLAG_NO_HEADPHONE (1 << 8) /* do not expose headphone */
115 #define AC97_FLAG_NO_CDROM (1 << 9) /* do not expose CDROM */
116 #define AC97_FLAG_NO_PHONE (1 << 10) /* do not expose phone in */
117 #define AC97_FLAG_NO_VIDEO (1 << 11) /* do not expose video in */
118 #define AC97_FLAG_NO_AUXIN (1 << 12) /* do not expose aux in */
119 #define AC97_FLAG_NO_AUXOUT (1 << 13) /* do not expose aux out */
120 #define AC97_FLAG_NO_LINEIN (1 << 14) /* do not expose linein */
121 #define AC97_FLAG_NO_MIC (1 << 15) /* do not expose mic */
122
123 uint32_t vid; /* Vendor ID for CODEC */
124 uint16_t caps;
125
126 void (*codec_init)(ac97_t *);
127 void (*codec_reset)(ac97_t *);
128
129 list_t ctrls;
130
131 uint64_t inputs;
132
133 };
134
135 struct modlmisc ac97_modlmisc = {
136 &mod_miscops,
137 "Audio Codec '97 Support"
138 };
139
140 struct modlinkage ac97_modlinkage = {
141 MODREV_1,
142 { &ac97_modlmisc, NULL }
143 };
144
145 int
_init(void)146 _init(void)
147 {
148 return (mod_install(&ac97_modlinkage));
149 }
150
151 int
_fini(void)152 _fini(void)
153 {
154 return (mod_install(&ac97_modlinkage));
155 }
156
157 int
_info(struct modinfo * modinfop)158 _info(struct modinfo *modinfop)
159 {
160 return (mod_info(&ac97_modlinkage, modinfop));
161 }
162
163
164 #if 0
165 /*
166 * The following table, and the code to scale it, works in percentages.
167 * This may be convenient for humans, but it would be faster if the table
168 * entries were rescaled to 256. (Division by 100 is painful. Divison by
169 * 256 is trivial.)
170 */
171 static const char ac97_val_cvt[101] = {
172 0, 0, 3, 7, 10, 13, 16, 19,
173 21, 23, 26, 28, 30, 32, 34, 35,
174 37, 39, 40, 42, 43, 45, 46, 47,
175 49, 50, 51, 52, 53, 55, 56, 57,
176 58, 59, 60, 61, 62, 63, 64, 65,
177 65, 66, 67, 68, 69, 70, 70, 71,
178 72, 73, 73, 74, 75, 75, 76, 77,
179 77, 78, 79, 79, 80, 81, 81, 82,
180 82, 83, 84, 84, 85, 85, 86, 86,
181 87, 87, 88, 88, 89, 89, 90, 90,
182 91, 91, 92, 92, 93, 93, 94, 94,
183 95, 95, 96, 96, 96, 97, 97, 98,
184 98, 98, 99, 99, 100
185 };
186 #endif
187
188 /*
189 * This code has three main functions. All related to converting
190 * a standard controls value to hardware specific values. All
191 * Standard passed in values are 0-100 as in percent.
192 *
193 * First it takes a value passed in as volume or gain and
194 * converts to attenuation or gain correspondingly. Since this is
195 * what the hardware needs.
196 *
197 * Second it adjusts the value passed in to compensate for the none
198 * linear nature of human hearing, sound loudness, sensitivity. It
199 * converts the linear value to a logarithmic value. This gives users
200 * the perception that the controls are linear.
201 *
202 * Third it converts the value to the number of bits that a hardware
203 * register needs to be.
204 *
205 * On input the following are supplied:
206 * left - The gain or volume in percent for left channel.
207 * right - The gain or volume in percent for right channel.
208 * bits - The number of bits the hardware needs. If this value
209 * is negetive then right and left are gain else they
210 * are volume.
211 *
212 * On return the following is returned:
213 *
214 * bit: 15 8 7 0
215 * ----------------------------------
216 * | left channel | right channel |
217 * ----------------------------------
218 * ( each channel is "bits" wide )
219 */
220 uint16_t
ac_val_scale(int left,int right,int bits)221 ac_val_scale(int left, int right, int bits)
222 {
223 ASSERT(left <= 100);
224 ASSERT(right <= 100);
225
226 if (bits < 0) { /* This is gain not ATTN */
227 left = 100 - left;
228 right = 100 - right;
229 bits = -bits;
230 }
231
232 #if 0
233 /*
234 * 4Front's code used a table to smooth the transitions
235 * somewhat. Without this change, the volume levels adjusted
236 * near the top of the table seem to have less effect. Its
237 * hard to notice a volume change from 100 to 95, without the
238 * val_cvt table, for example. However, the scaling has an
239 * ugly side effect, which is at the default volumes (75%), we
240 * wind up having the level set too high for some
241 * codec/amplifier combinations.
242 *
243 * Legacy Sun code didn't have this table, and some
244 * qualitative testing shows that it isn't really necessary.
245 */
246 left = 100 - ac97_val_cvt[left];
247 right = 100 - ac97_val_cvt[right];
248 #else
249 left = 100 - left;
250 right = 100 - right;
251 #endif
252 return (((left * ((1 << bits) - 1) / 100) << 8) |
253 (right * ((1 << bits) - 1) / 100));
254 }
255
256 uint16_t
ac_mono_scale(int val,int bits)257 ac_mono_scale(int val, int bits)
258 {
259 ASSERT(val <= 100);
260
261 if (bits < 0) { /* This is gain not ATTN */
262 bits = -bits;
263 } else {
264 val = 100 - val; /* convert to attenuation */
265 }
266 return (val * ((1 << bits) - 1) / 100);
267 }
268
269 audio_dev_t *
ac_get_dev(ac97_t * ac)270 ac_get_dev(ac97_t *ac)
271 {
272 return (ac->d);
273 }
274
275 int
ac_get_prop(ac97_t * ac,char * prop,int defval)276 ac_get_prop(ac97_t *ac, char *prop, int defval)
277 {
278 int rv;
279
280 rv = ddi_prop_get_int(DDI_DEV_T_ANY, ac->dip, DDI_PROP_DONTPASS,
281 prop, defval);
282 return (rv);
283 }
284
285 /*
286 * This calls the Hardware drivers access write routine
287 * to write to a device register.
288 */
289 #define WR(r, v) (ac)->wr((ac)->private, (r), (v))
290 #define RD(r) (ac)->rd((ac)->private, (r))
291
292 /*
293 * Probe routines for optional controls
294 *
295 * These routines each probe one aspect of hardware
296 * for controls presents.
297 * If the control is present these routines should
298 * return none zero.
299 */
300
301 /*
302 * Is the named register implemented? This routine saves and
303 * restores the original value, and relies on the fact that the
304 * registers (if implemented) will have at least one bit that acts
305 * as a mute (0x8000, 0x8080), so we can probe "silently".
306 *
307 * The probe logic is suggested by the AC'97 2.3 spec. (Unimplemented
308 * registers are required to return zero to facilitate this sort of
309 * detection.)
310 */
311 static int
ac_probe_reg(ac97_t * ac,uint8_t reg)312 ac_probe_reg(ac97_t *ac, uint8_t reg)
313 {
314 uint16_t val;
315 int rv = 0;
316
317 /* get the original value */
318 val = RD(reg);
319 WR(reg, 0xffff);
320 if (RD(reg) != 0) {
321 rv = 1;
322 }
323 /* restore the original value */
324 WR(reg, val);
325 return (rv);
326 }
327
328 /*
329 * Does this device have bass/treble controls?
330 */
331 static int
ac_probe_tone(ac97_t * ac)332 ac_probe_tone(ac97_t *ac)
333 {
334 /* Bass/Treble contols present */
335 if (ac->caps & RR_BASS_TREBLE)
336 return (1);
337 else
338 return (0);
339 }
340
341 /*
342 * If there is a loudness switch?
343 */
344 static int
ac_probe_loud(ac97_t * ac)345 ac_probe_loud(ac97_t *ac)
346 {
347 /* loudness contol present */
348 if (ac->caps & RR_LOUDNESS_SUPPORT)
349 return (1);
350 else
351 return (0);
352 }
353
354 /*
355 * Does this device have a mono-mic input volume control?
356 */
357 static int
ac_probe_mmic(ac97_t * ac)358 ac_probe_mmic(ac97_t *ac)
359 {
360 /* mono mic present */
361 if (ac->caps & RR_DEDICATED_MIC)
362 return (1);
363 else
364 return (0);
365 }
366
367 /*
368 * Does this device have a simulated stereo switch?
369 */
370 static int
ac_probe_stsim(ac97_t * ac)371 ac_probe_stsim(ac97_t *ac)
372 {
373 /* simulated stereocontol present */
374 if (ac->caps & RR_PSEUDO_STEREO)
375 return (1);
376 else
377 return (0);
378 }
379
380 /*
381 * Does this device have a PC beeper input volume control?
382 */
383 static int
ac_probe_pcbeep(ac97_t * ac)384 ac_probe_pcbeep(ac97_t *ac)
385 {
386 return (ac_probe_reg(ac, AC97_PC_BEEP_REGISTER));
387 }
388
389 /*
390 * Does this device have AUX output port volume control?
391 */
392 static int
ac_probe_rear(ac97_t * ac)393 ac_probe_rear(ac97_t *ac)
394 {
395 if (ac->flags & AC97_FLAG_AUX_4CH)
396 return (1);
397 else
398 return (0);
399
400 }
401
402 /*
403 * Does this device have a mic?
404 */
405 static int
ac_probe_mic(ac97_t * ac)406 ac_probe_mic(ac97_t *ac)
407 {
408 if ((!(ac->flags & AC97_FLAG_NO_MIC)) &&
409 (ac_probe_reg(ac, AC97_MIC_VOLUME_REGISTER))) {
410 ac->inputs |= (1U << INPUT_MIC);
411 return (1);
412 }
413 return (0);
414 }
415
416 /*
417 * If this device has an AUX output port is it used for headphones?
418 */
419 static int
ac_probe_headphone(ac97_t * ac)420 ac_probe_headphone(ac97_t *ac)
421 {
422 /* headphone control present */
423 if ((ac->flags & AC97_FLAG_AUX_HP) &&
424 !(ac->flags & AC97_FLAG_NO_HEADPHONE)) {
425 return (1);
426 }
427 return (0);
428 }
429
430 /*
431 * Does this device have AUX output port volume control?
432 */
433 static int
ac_probe_auxout(ac97_t * ac)434 ac_probe_auxout(ac97_t *ac)
435 {
436 /* ALT PCM control present */
437 if ((ac->flags & AC97_FLAG_AUX_LVL) &&
438 !(ac->flags & AC97_FLAG_NO_AUXOUT)) {
439 return (1);
440 }
441 return (0);
442 }
443
444 /*
445 * Does this device have an AUX input port volume control?
446 */
447 static int
ac_probe_auxin(ac97_t * ac)448 ac_probe_auxin(ac97_t *ac)
449 {
450 if ((!(ac->flags & AC97_FLAG_NO_AUXIN)) &&
451 (ac_probe_reg(ac, AC97_AUX_VOLUME_REGISTER))) {
452 ac->inputs |= (1U << INPUT_AUXIN);
453 return (1);
454 }
455 return (0);
456 }
457
458 /*
459 * Does this device have a phone input port with a volume control?
460 */
461 static int
ac_probe_phone(ac97_t * ac)462 ac_probe_phone(ac97_t *ac)
463 {
464 if ((!(ac->flags & AC97_FLAG_NO_PHONE)) &&
465 (ac_probe_reg(ac, AC97_PHONE_VOLUME_REGISTER))) {
466 ac->inputs |= (1U << INPUT_PHONE);
467 return (1);
468 }
469 return (0);
470 }
471
472 /*
473 * Does this device have a mono output port with volume control?
474 */
475 static int
ac_probe_mono(ac97_t * ac)476 ac_probe_mono(ac97_t *ac)
477 {
478 if (!(ac->flags & AC97_FLAG_SPEAKER_OK)) {
479 return (0);
480 }
481 if (ac_probe_reg(ac, AC97_MONO_MASTER_VOLUME_REGISTER)) {
482 return (1);
483 }
484 return (0);
485 }
486
487 /*
488 * Does this device have a line input port with volume control?
489 */
490 static int
ac_probe_linein(ac97_t * ac)491 ac_probe_linein(ac97_t *ac)
492 {
493 if ((!(ac->flags & AC97_FLAG_NO_LINEIN)) &&
494 (ac_probe_reg(ac, AC97_LINE_IN_VOLUME_REGISTER))) {
495 ac->inputs |= (1U << INPUT_LINEIN);
496 return (1);
497 }
498 return (0);
499 }
500
501 /*
502 * Does this device have a cdrom input port with volume control?
503 */
504 static int
ac_probe_cdrom(ac97_t * ac)505 ac_probe_cdrom(ac97_t *ac)
506 {
507 if ((!(ac->flags & AC97_FLAG_NO_CDROM)) &&
508 (ac_probe_reg(ac, AC97_CD_VOLUME_REGISTER))) {
509 ac->inputs |= (1U << INPUT_CD);
510 return (1);
511 }
512 return (0);
513 }
514
515 /*
516 * Does this device have a video input port with volume control?
517 */
518 static int
ac_probe_video(ac97_t * ac)519 ac_probe_video(ac97_t *ac)
520 {
521 if ((!(ac->flags & AC97_FLAG_NO_VIDEO)) &&
522 (ac_probe_reg(ac, AC97_VIDEO_VOLUME_REGISTER))) {
523 ac->inputs |= (1U << INPUT_VIDEO);
524 return (1);
525 }
526 return (0);
527 }
528
529 /*
530 * Does this device have a 3D sound enhancement?
531 */
532 static int
ac_probe_3d(ac97_t * ac)533 ac_probe_3d(ac97_t *ac)
534 {
535 /* 3D control present */
536 if (ac->caps & RR_3D_STEREO_ENHANCE_MASK)
537 return (1);
538 else
539 return (0);
540 }
541
542 static int
ac_probe_3d_impl(ac97_t * ac,uint16_t mask)543 ac_probe_3d_impl(ac97_t *ac, uint16_t mask)
544 {
545 int rv = 0;
546 uint16_t val;
547
548 if ((ac->caps & RR_3D_STEREO_ENHANCE_MASK) == 0)
549 return (0);
550
551 /* get the original value */
552 val = RD(AC97_THREE_D_CONTROL_REGISTER);
553 WR(AC97_THREE_D_CONTROL_REGISTER, mask);
554 if ((RD(AC97_THREE_D_CONTROL_REGISTER) & mask) != 0) {
555 rv = 1;
556 }
557 /* restore the original value */
558 WR(AC97_THREE_D_CONTROL_REGISTER, val);
559 return (rv);
560 }
561
562 static int
ac_probe_3d_depth(ac97_t * ac)563 ac_probe_3d_depth(ac97_t *ac)
564 {
565 return (ac_probe_3d_impl(ac, TDCR_DEPTH_MASK));
566 }
567
568 static int
ac_probe_3d_center(ac97_t * ac)569 ac_probe_3d_center(ac97_t *ac)
570 {
571 return (ac_probe_3d_impl(ac, TDCR_CENTER_MASK));
572 }
573
574 /*
575 * Does this device have a center output port with volume control?
576 */
577 static int
ac_probe_center(ac97_t * ac)578 ac_probe_center(ac97_t *ac)
579 {
580 uint16_t val;
581
582 val = RD(AC97_EXTENDED_AUDIO_REGISTER);
583
584 /* center volume present */
585 if (val & EAR_CDAC)
586 return (1);
587 else
588 return (0);
589 }
590
591 /*
592 * Does this device have a LFE (Sub-woofer) output port with
593 * a volume control?
594 */
595 static int
ac_probe_lfe(ac97_t * ac)596 ac_probe_lfe(ac97_t *ac)
597 {
598 uint16_t val;
599
600 val = RD(AC97_EXTENDED_AUDIO_REGISTER);
601
602 /* We have LFE control */
603 if (val & EAR_LDAC)
604 return (1);
605 else
606 return (0);
607
608 }
609
610 /*
611 * Are we a multichannel codec?
612 */
613 static int
ac_probe_front(ac97_t * ac)614 ac_probe_front(ac97_t *ac)
615 {
616 uint16_t val;
617
618 val = RD(AC97_EXTENDED_AUDIO_REGISTER);
619
620 /* Are any of the Surround, Center, or LFE dacs present? */
621 if (val & (EAR_SDAC | EAR_CDAC | EAR_LDAC))
622 return (1);
623 else
624 return (0);
625 }
626
627 static int
ac_probe_lineout(ac97_t * ac)628 ac_probe_lineout(ac97_t *ac)
629 {
630 /* if not multichannel, then use "lineout" instead of "front" label */
631 return (!ac_probe_front(ac));
632 }
633
634 static const char *ac_mics[] = {
635 AUDIO_PORT_MIC1,
636 AUDIO_PORT_MIC2,
637 NULL,
638 };
639
640 static const char *ac_monos[] = {
641 AUDIO_PORT_MONOMIX,
642 AUDIO_PORT_MIC,
643 NULL
644 };
645
646 /*
647 * This calls the Hardware drivers access write routine
648 * to write to a device register.
649 */
650 void
ac_wr(ac97_t * ac,uint8_t reg,uint16_t val)651 ac_wr(ac97_t *ac, uint8_t reg, uint16_t val)
652 {
653 if ((reg < LAST_SHADOW_REG) && (reg > 0)) {
654 SHADOW(ac, reg) = val;
655 }
656
657 ac->wr(ac->private, reg, val);
658 }
659
660 /*
661 * This obtains the shadowed value of a register. If the register is
662 * out of range, zero is returned.
663 *
664 * To read a hardware register, use the RD() macro above.
665 */
666 uint16_t
ac_rd(ac97_t * ac,uint8_t reg)667 ac_rd(ac97_t *ac, uint8_t reg)
668 {
669 if ((reg < LAST_SHADOW_REG) && (reg > 0)) {
670 return (SHADOW(ac, reg));
671 }
672 return (ac->rd(ac->private, reg));
673 }
674
675 /*
676 * This calls the hardware driver's access read/write routine
677 * to set bits in a device register.
678 */
679 void
ac_set(ac97_t * ac,uint8_t reg,uint16_t val)680 ac_set(ac97_t *ac, uint8_t reg, uint16_t val)
681 {
682 ac_wr(ac, reg, ac->rd(ac->private, reg) | val);
683 }
684
685 /*
686 * This calls the hardware driver's access read/write routine
687 * to clear bits in a device register.
688 */
689 void
ac_clr(ac97_t * ac,uint8_t reg,uint16_t val)690 ac_clr(ac97_t *ac, uint8_t reg, uint16_t val)
691 {
692 ac_wr(ac, reg, ac->rd(ac->private, reg) & ~val);
693 }
694
695 /*
696 * Look for a control attached to this device based
697 * on its control number.
698 *
699 * If this control number is found the per controls state
700 * structure is returned.
701 */
702 ac97_ctrl_t *
ac97_control_find(ac97_t * ac,const char * name)703 ac97_control_find(ac97_t *ac, const char *name)
704 {
705 ac97_ctrl_t *ctrl;
706 list_t *l = &ac->ctrls;
707
708 /* Validate that ctrlnum is real and usable */
709 for (ctrl = list_head(l); ctrl; ctrl = list_next(l, ctrl)) {
710 if (strcmp(ctrl->actrl_name, name) == 0) {
711 return (ctrl);
712 }
713 }
714 return (NULL);
715 }
716
717 /*
718 * This will update all the codec registers from the shadow table.
719 */
720 static void
ac_restore(ac97_t * ac)721 ac_restore(ac97_t *ac)
722 {
723 /*
724 * If we are restoring previous settings, just reload from the
725 * shadowed settings.
726 */
727 for (int i = 2; i < LAST_SHADOW_REG; i += sizeof (uint16_t)) {
728 ac->wr(ac->private, i, SHADOW(ac, i));
729 }
730 }
731
732 /*
733 * This will update all the hardware controls to the initial values at
734 * start of day.
735 */
736 static void
ac_init_values(ac97_t * ac)737 ac_init_values(ac97_t *ac)
738 {
739 ac97_ctrl_t *ctrl;
740
741 for (ctrl = list_head(&ac->ctrls); ctrl;
742 ctrl = list_next(&ac->ctrls, ctrl)) {
743 ctrl->actrl_value = ctrl->actrl_initval;
744 ctrl->actrl_write_fn(ctrl, ctrl->actrl_initval);
745 }
746 }
747
748 /*
749 * Select the input source for recording. This is the set routine
750 * for the control AUDIO_CONTROL_INPUTS.
751 */
752 static void
ac_insrc_set(ac97_ctrl_t * ctrl,uint64_t value)753 ac_insrc_set(ac97_ctrl_t *ctrl, uint64_t value)
754 {
755 ac97_t *ac = ctrl->actrl_ac97;
756 uint16_t set_val;
757
758 set_val = ddi_ffs(value & 0xffff);
759 if ((set_val > 0) && (set_val <= 8)) {
760 set_val--;
761 ac_wr(ac, AC97_RECORD_SELECT_CTRL_REGISTER,
762 set_val | (set_val << 8));
763 }
764 }
765
766 static void
ac_gpr_toggle(ac97_ctrl_t * ctrl,int bit,uint64_t onoff)767 ac_gpr_toggle(ac97_ctrl_t *ctrl, int bit, uint64_t onoff)
768 {
769 ac97_t *ac = ctrl->actrl_ac97;
770 uint16_t v;
771
772 v = SHADOW(ac, AC97_GENERAL_PURPOSE_REGISTER);
773 if (onoff) {
774 v |= bit;
775 } else {
776 v &= ~bit;
777 }
778 ac_wr(ac, AC97_GENERAL_PURPOSE_REGISTER, v);
779 }
780
781 static void
ac_3donoff_set(ac97_ctrl_t * ctrl,uint64_t value)782 ac_3donoff_set(ac97_ctrl_t *ctrl, uint64_t value)
783 {
784 ac_gpr_toggle(ctrl, GPR_3D_STEREO_ENHANCE, value);
785 }
786
787 static void
ac_loudness_set(ac97_ctrl_t * ctrl,uint64_t value)788 ac_loudness_set(ac97_ctrl_t *ctrl, uint64_t value)
789 {
790 ac_gpr_toggle(ctrl, GPR_BASS_BOOST, value);
791 }
792
793 static void
ac_loopback_set(ac97_ctrl_t * ctrl,uint64_t value)794 ac_loopback_set(ac97_ctrl_t *ctrl, uint64_t value)
795 {
796 ac_gpr_toggle(ctrl, GPR_LPBK, value);
797 }
798
799 /*
800 * This will set simulated stereo control to on or off.
801 */
802 static void
ac_stsim_set(ac97_ctrl_t * ctrl,uint64_t value)803 ac_stsim_set(ac97_ctrl_t *ctrl, uint64_t value)
804 {
805 ac_gpr_toggle(ctrl, GPR_ST, value);
806 }
807
808 /*
809 * This will set mic select control to mic1=0 or mic2=1.
810 */
811 static void
ac_selmic_set(ac97_ctrl_t * ctrl,uint64_t value)812 ac_selmic_set(ac97_ctrl_t *ctrl, uint64_t value)
813 {
814 ac_gpr_toggle(ctrl, GPR_MS_MIC2, value & 2);
815 }
816
817 /*
818 * This will set mono source select control to mix=0 or mic=1.
819 */
820 static void
ac_monosrc_set(ac97_ctrl_t * ctrl,uint64_t value)821 ac_monosrc_set(ac97_ctrl_t *ctrl, uint64_t value)
822 {
823 ac_gpr_toggle(ctrl, GPR_MONO_MIC_IN, value & 2);
824 }
825
826 static void
ac_stereo_set(ac97_ctrl_t * ctrl,uint64_t value,uint8_t reg)827 ac_stereo_set(ac97_ctrl_t *ctrl, uint64_t value, uint8_t reg)
828 {
829 ac97_t *ac = ctrl->actrl_ac97;
830 uint8_t left, right;
831 uint16_t mute;
832
833 left = (value >> 8) & 0xff;
834 right = value & 0xff;
835 mute = value ? 0 : ctrl->actrl_muteable;
836
837 ac_wr(ac, reg, ac_val_scale(left, right, ctrl->actrl_bits) | mute);
838 }
839
840 static void
ac_mono_set(ac97_ctrl_t * ctrl,uint64_t value,uint8_t reg,int shift)841 ac_mono_set(ac97_ctrl_t *ctrl, uint64_t value, uint8_t reg, int shift)
842 {
843 ac97_t *ac = ctrl->actrl_ac97;
844 uint8_t val;
845 uint16_t mute, v;
846 uint16_t mask;
847
848 val = value & 0xff;
849 mute = val ? 0 : ctrl->actrl_muteable;
850
851 mask = ctrl->actrl_muteable |
852 (((1 << ABS(ctrl->actrl_bits)) - 1) << shift);
853
854 v = SHADOW(ac, reg);
855 v &= ~mask; /* clear all of our bits, preserve others */
856
857 /* now set the mute bit, and volume bits */
858 v |= mute;
859 v |= (ac_mono_scale(val, ctrl->actrl_bits) << shift);
860
861 ac_wr(ac, reg, v);
862 }
863
864 static void
ac97_master_set(ac97_ctrl_t * ctrl,uint64_t value)865 ac97_master_set(ac97_ctrl_t *ctrl, uint64_t value)
866 {
867 value = value | (value << 8);
868 ac_stereo_set(ctrl, value, AC97_PCM_OUT_VOLUME_REGISTER);
869 }
870
871 static void
ac97_lineout_set(ac97_ctrl_t * ctrl,uint64_t value)872 ac97_lineout_set(ac97_ctrl_t *ctrl, uint64_t value)
873 {
874 ac_stereo_set(ctrl, value, AC97_MASTER_VOLUME_REGISTER);
875 }
876
877 static void
ac97_surround_set(ac97_ctrl_t * ctrl,uint64_t value)878 ac97_surround_set(ac97_ctrl_t *ctrl, uint64_t value)
879 {
880 ac_stereo_set(ctrl, value, AC97_EXTENDED_LRS_VOLUME_REGISTER);
881 }
882
883 static void
ac97_aux1out_set(ac97_ctrl_t * ctrl,uint64_t value)884 ac97_aux1out_set(ac97_ctrl_t *ctrl, uint64_t value)
885 {
886 ac_stereo_set(ctrl, value, AC97_HEADPHONE_VOLUME_REGISTER);
887 }
888
889 static void
ac97_headphone_set(ac97_ctrl_t * ctrl,uint64_t value)890 ac97_headphone_set(ac97_ctrl_t *ctrl, uint64_t value)
891 {
892 ac_stereo_set(ctrl, value, AC97_HEADPHONE_VOLUME_REGISTER);
893 }
894
895 static void
ac_cd_set(ac97_ctrl_t * ctrl,uint64_t value)896 ac_cd_set(ac97_ctrl_t *ctrl, uint64_t value)
897 {
898 ac_stereo_set(ctrl, value, AC97_CD_VOLUME_REGISTER);
899 }
900
901 static void
ac_video_set(ac97_ctrl_t * ctrl,uint64_t value)902 ac_video_set(ac97_ctrl_t *ctrl, uint64_t value)
903 {
904 ac_stereo_set(ctrl, value, AC97_VIDEO_VOLUME_REGISTER);
905 }
906
907 static void
ac_auxin_set(ac97_ctrl_t * ctrl,uint64_t value)908 ac_auxin_set(ac97_ctrl_t *ctrl, uint64_t value)
909 {
910 ac_stereo_set(ctrl, value, AC97_AUX_VOLUME_REGISTER);
911 }
912
913 static void
ac_linein_set(ac97_ctrl_t * ctrl,uint64_t value)914 ac_linein_set(ac97_ctrl_t *ctrl, uint64_t value)
915 {
916 ac_stereo_set(ctrl, value, AC97_LINE_IN_VOLUME_REGISTER);
917 }
918
919 /*
920 * This will set mono mic gain control.
921 */
922 static void
ac_monomic_set(ac97_ctrl_t * ctrl,uint64_t value)923 ac_monomic_set(ac97_ctrl_t *ctrl, uint64_t value)
924 {
925 ac_mono_set(ctrl, value, AC97_RECORD_GAIN_MIC_REGISTER, 0);
926 }
927
928 static void
ac_phone_set(ac97_ctrl_t * ctrl,uint64_t value)929 ac_phone_set(ac97_ctrl_t *ctrl, uint64_t value)
930 {
931 ac_mono_set(ctrl, value, AC97_PHONE_VOLUME_REGISTER, 0);
932 }
933
934 static void
ac_mic_set(ac97_ctrl_t * ctrl,uint64_t value)935 ac_mic_set(ac97_ctrl_t *ctrl, uint64_t value)
936 {
937 ac_mono_set(ctrl, value, AC97_MIC_VOLUME_REGISTER, 0);
938 }
939
940 static void
ac_speaker_set(ac97_ctrl_t * ctrl,uint64_t value)941 ac_speaker_set(ac97_ctrl_t *ctrl, uint64_t value)
942 {
943 ac_mono_set(ctrl, value, AC97_MONO_MASTER_VOLUME_REGISTER, 0);
944 }
945
946 static void
ac_pcbeep_set(ac97_ctrl_t * ctrl,uint64_t value)947 ac_pcbeep_set(ac97_ctrl_t *ctrl, uint64_t value)
948 {
949 ac_mono_set(ctrl, value, AC97_PC_BEEP_REGISTER, 1);
950 }
951
952 static void
ac_recgain_set(ac97_ctrl_t * ctrl,uint64_t value)953 ac_recgain_set(ac97_ctrl_t *ctrl, uint64_t value)
954 {
955 ac_stereo_set(ctrl, value, AC97_RECORD_GAIN_REGISTER);
956 }
957
958 static void
ac_center_set(ac97_ctrl_t * ctrl,uint64_t value)959 ac_center_set(ac97_ctrl_t *ctrl, uint64_t value)
960 {
961 ac_mono_set(ctrl, value, AC97_EXTENDED_C_LFE_VOLUME_REGISTER, 0);
962 }
963
964 static void
ac_lfe_set(ac97_ctrl_t * ctrl,uint64_t value)965 ac_lfe_set(ac97_ctrl_t *ctrl, uint64_t value)
966 {
967 ac_mono_set(ctrl, value, AC97_EXTENDED_C_LFE_VOLUME_REGISTER, 8);
968 }
969
970 static void
ac_bass_set(ac97_ctrl_t * ctrl,uint64_t value)971 ac_bass_set(ac97_ctrl_t *ctrl, uint64_t value)
972 {
973 ac_mono_set(ctrl, value, AC97_MASTER_TONE_CONTROL_REGISTER, 8);
974 }
975
976 static void
ac_treble_set(ac97_ctrl_t * ctrl,uint64_t value)977 ac_treble_set(ac97_ctrl_t *ctrl, uint64_t value)
978 {
979 ac_mono_set(ctrl, value, AC97_MASTER_TONE_CONTROL_REGISTER, 0);
980 }
981
982 static void
ac_3ddepth_set(ac97_ctrl_t * ctrl,uint64_t value)983 ac_3ddepth_set(ac97_ctrl_t *ctrl, uint64_t value)
984 {
985 /*
986 * XXX: This is all wrong... 3D depth/center cannot necessarily
987 * be scaled, because the technology in use may vary. We
988 * need more information about each of the options available
989 * to do the right thing.
990 */
991 ac_mono_set(ctrl, value, AC97_THREE_D_CONTROL_REGISTER, 0);
992 }
993
994 static void
ac_3dcent_set(ac97_ctrl_t * ctrl,uint64_t value)995 ac_3dcent_set(ac97_ctrl_t *ctrl, uint64_t value)
996 {
997 /*
998 * XXX: This is all wrong... 3D depth/center cannot necessarily
999 * be scaled, because the technology in use may vary. We
1000 * need more information about each of the options available
1001 * to do the right thing.
1002 */
1003 ac_mono_set(ctrl, value, AC97_THREE_D_CONTROL_REGISTER, 8);
1004 }
1005
1006 static void
ac97_micboost_set(ac97_ctrl_t * ctrl,uint64_t value)1007 ac97_micboost_set(ac97_ctrl_t *ctrl, uint64_t value)
1008 {
1009 ac97_t *ac = ctrl->actrl_ac97;
1010 uint16_t v;
1011
1012 v = SHADOW(ac, AC97_MIC_VOLUME_REGISTER);
1013 if (value) {
1014 v |= MICVR_20dB_BOOST;
1015 } else {
1016 v &= ~MICVR_20dB_BOOST;
1017 }
1018 ac_wr(ac, AC97_MIC_VOLUME_REGISTER, v);
1019 }
1020
1021 /*
1022 * This will return the stored value for any control that has been set.
1023 * Note this does not return the actual hardware value from a port. But
1024 * instead returns the cached value from the last write to the hardware
1025 * port.
1026 *
1027 * arg - This control structure for this control.
1028 * value - This is a pointer to the location to put the
1029 * controls value.
1030 *
1031 * On success zero is returned.
1032 */
1033 int
ac97_control_get(ac97_ctrl_t * ctrl,uint64_t * value)1034 ac97_control_get(ac97_ctrl_t *ctrl, uint64_t *value)
1035 {
1036 *value = ctrl->actrl_value;
1037
1038 return (0);
1039 }
1040
1041 int
ac97_control_set(ac97_ctrl_t * ctrl,uint64_t value)1042 ac97_control_set(ac97_ctrl_t *ctrl, uint64_t value)
1043 {
1044 uint8_t v1, v2;
1045
1046 /* a bit of quick checking */
1047 switch (ctrl->actrl_type) {
1048 case AUDIO_CTRL_TYPE_STEREO:
1049 v1 = (value >> 8) & 0xff;
1050 v2 = value & 0xff;
1051 if ((v1 < ctrl->actrl_minval) || (v1 > ctrl->actrl_maxval) ||
1052 (v2 < ctrl->actrl_minval) || (v2 > ctrl->actrl_maxval) ||
1053 (value > 0xffff)) {
1054 return (EINVAL);
1055 }
1056 break;
1057
1058 case AUDIO_CTRL_TYPE_ENUM:
1059 if ((value & ~ctrl->actrl_minval) !=
1060 (ctrl->actrl_maxval & ~ctrl->actrl_minval)) {
1061 return (EINVAL);
1062 }
1063 break;
1064
1065 case AUDIO_CTRL_TYPE_MONO:
1066 case AUDIO_CTRL_TYPE_BOOLEAN:
1067 if ((value < ctrl->actrl_minval) ||
1068 (value > ctrl->actrl_maxval)) {
1069 return (EINVAL);
1070 }
1071 break;
1072 }
1073
1074 ctrl->actrl_value = value;
1075 ctrl->actrl_write_fn(ctrl, value);
1076
1077 return (0);
1078 }
1079
1080 static int
ac_get_value(void * arg,uint64_t * value)1081 ac_get_value(void *arg, uint64_t *value)
1082 {
1083 return (ac97_control_get(arg, value));
1084 }
1085
1086 static int
ac_set_value(void * arg,uint64_t value)1087 ac_set_value(void *arg, uint64_t value)
1088 {
1089 return (ac97_control_set(arg, value));
1090 }
1091
1092 /*
1093 * Reset the analog codec hardware
1094 *
1095 * Reset all analog AC97 hardware, input ADC's, output DAC's and MIXER.
1096 * Wait a resonable amount of time for hardware to become ready.
1097 */
1098 static void
ac_analog_reset(ac97_t * ac)1099 ac_analog_reset(ac97_t *ac)
1100 {
1101 uint16_t tmp;
1102 int wait = 1000; /* delay for up to 1s */
1103
1104 /* Clear stale data and resync register accesses */
1105 tmp = RD(AC97_POWERDOWN_CTRL_STAT_REGISTER);
1106
1107 /* reset the codec */
1108 WR(AC97_RESET_REGISTER, 0);
1109 tmp = RD(AC97_RESET_REGISTER);
1110
1111 /* power up */
1112 WR(AC97_POWERDOWN_CTRL_STAT_REGISTER, 0);
1113
1114 /* Wait for ADC/DAC/MIXER to become ready */
1115 while (wait--) {
1116 /* 1 msec delay */
1117 drv_usecwait(1000);
1118
1119 /* If all ready - end delay */
1120 tmp = RD(AC97_POWERDOWN_CTRL_STAT_REGISTER);
1121 SHADOW(ac, AC97_POWERDOWN_CTRL_STAT_REGISTER) = tmp;
1122 if ((tmp & PCSR_POWERD_UP) == PCSR_POWERD_UP) {
1123 return;
1124 }
1125 }
1126
1127 audio_dev_warn(ac->d, "AC'97 analog power up timed out");
1128 }
1129
1130 /*
1131 * This is the internal hardware reset routine.
1132 * It has no locking and we must be locked before it is
1133 * called!
1134 *
1135 * This will reset and re-initialize the device.
1136 * It has two modes of operation that affect how it handles
1137 * all controls.
1138 *
1139 * It re-initializes the device and reloads values with
1140 * last updated versions.
1141 */
1142 static void
ac_hw_reset(ac97_t * ac)1143 ac_hw_reset(ac97_t *ac)
1144 {
1145 /*
1146 * Fully Power up the device
1147 */
1148 if (ac->flags & AC97_FLAG_AMPLIFIER) {
1149 /* power up - external amp powerd up */
1150 ac_wr(ac, AC97_POWERDOWN_CTRL_STAT_REGISTER, 0);
1151 } else {
1152 /* power up - external amp powered down */
1153 ac_wr(ac, AC97_POWERDOWN_CTRL_STAT_REGISTER, PCSR_EAPD);
1154 }
1155
1156 ac_wr(ac, AC97_GENERAL_PURPOSE_REGISTER, 0);
1157
1158 switch (ac->vid) {
1159 case AC97_CODEC_STAC9708:
1160 #if 0
1161 /* non-inverted phase */
1162 /* ac_rd(ac, AC97_VENDOR_REGISTER_11) & ~0x8); */
1163 #endif
1164 WR(AC97_VENDOR_REGISTER_11, 8);
1165 break;
1166
1167 case AC97_CODEC_AD1886:
1168 /* jack sense */
1169 WR(AC97_VENDOR_REGISTER_13,
1170 (RD(AC97_VENDOR_REGISTER_13) & ~0xEF) | 0x10);
1171 break;
1172
1173 case AC97_CODEC_AD1888:
1174 WR(AC97_VENDOR_REGISTER_15, 0xC420);
1175 #if 0
1176 /* GED: This looks fishy to me, so I'm nuking it for now */
1177 /* headphone/aux volume (?) */
1178 ac_wr(ac, AC97_HEADPHONE_VOLUME_REGISTER, 0x0808);
1179 #endif
1180 break;
1181
1182 case AC97_CODEC_AD1980:
1183 #if 0
1184 /* set jacksense to mute line if headphone is plugged */
1185 WR(AC97_VENDOR_REGISTER_13,
1186 (RD(AC97_VENDOR_REGISTER_13) & ~0xe00) | 0x400);
1187 #endif
1188 WR(AC97_VENDOR_REGISTER_15, 0xC420);
1189 break;
1190
1191 case AC97_CODEC_AD1985:
1192 WR(AC97_VENDOR_REGISTER_15, 0xC420);
1193 break;
1194
1195 case AC97_CODEC_WM9704:
1196 /* enable I2S */
1197 WR(AC97_VENDOR_REGISTER_01, RD(AC97_VENDOR_REGISTER_01) | 0x80);
1198 break;
1199
1200 case AC97_CODEC_VT1612A:
1201 case AC97_CODEC_VT1617A:
1202 case AC97_CODEC_VT1616:
1203 /* Turn on Center, Surround, and LFE DACs */
1204 ac_clr(ac, AC97_EXTENDED_AUDIO_STAT_CTRL_REGISTER,
1205 EASCR_PRI | EASCR_PRJ | EASCR_PRK);
1206 WR(AC97_VENDOR_REGISTER_01, 0x0230);
1207 break;
1208
1209 case AC97_CODEC_YMF753:
1210 /* set TX8 + 3AWE */
1211 WR(AC97_VENDOR_REGISTER_07, RD(AC97_VENDOR_REGISTER_07) | 0x9);
1212 break;
1213
1214 default:
1215 break;
1216 }
1217
1218 /* call codec specific reset hook */
1219 if (ac->codec_reset != NULL) {
1220 ac->codec_reset(ac);
1221 }
1222
1223 /* Turn off variable sampling rate support */
1224 ac_clr(ac, AC97_EXTENDED_AUDIO_STAT_CTRL_REGISTER, EASCR_VRA);
1225 }
1226
1227 /*
1228 * This will reset and re-initialize the device. It is still incumbent
1229 * on the caller (or the audio framework) to replay control settings!
1230 */
1231 void
ac97_reset(ac97_t * ac)1232 ac97_reset(ac97_t *ac)
1233 {
1234 ac_analog_reset(ac);
1235 ac_hw_reset(ac);
1236 ac_restore(ac);
1237 }
1238
1239 /*
1240 * Return the number of channels supported by this codec.
1241 */
1242 int
ac97_num_channels(ac97_t * ac)1243 ac97_num_channels(ac97_t *ac)
1244 {
1245 return (ac->nchan);
1246 }
1247
1248 /*
1249 * Register a control -- if it fails, it will generate a message to
1250 * syslog, but the driver muddles on. (Failure to register a control
1251 * should never occur, but is generally benign if it happens.)
1252 */
1253 void
ac97_control_register(ac97_ctrl_t * ctrl)1254 ac97_control_register(ac97_ctrl_t *ctrl)
1255 {
1256 ac97_t *ac = ctrl->actrl_ac97;
1257 ASSERT(ac->d != NULL);
1258
1259 ctrl->actrl_suppress = B_FALSE;
1260
1261 /* Register control with framework */
1262 ctrl->actrl_ctrl = audio_dev_add_control(ac->d, &ctrl->actrl_desc,
1263 ac_get_value, ac_set_value, ctrl);
1264 if (ctrl->actrl_ctrl == NULL) {
1265 audio_dev_warn(ac->d, "AC97 %s alloc failed",
1266 ctrl->actrl_name);
1267 }
1268 }
1269
1270 void
ac97_control_unregister(ac97_ctrl_t * ctrl)1271 ac97_control_unregister(ac97_ctrl_t *ctrl)
1272 {
1273 ctrl->actrl_suppress = B_TRUE;
1274
1275 if (ctrl->actrl_ctrl != NULL) {
1276 audio_dev_del_control(ctrl->actrl_ctrl);
1277 ctrl->actrl_ctrl = NULL;
1278 }
1279 }
1280
1281 const char *
ac97_control_name(ac97_ctrl_t * ctrl)1282 ac97_control_name(ac97_ctrl_t *ctrl)
1283 {
1284 return (ctrl->actrl_name);
1285 }
1286
1287 const audio_ctrl_desc_t *
ac97_control_desc(ac97_ctrl_t * ctrl)1288 ac97_control_desc(ac97_ctrl_t *ctrl)
1289 {
1290 return (&ctrl->actrl_desc);
1291 }
1292
1293 void
ac97_register_controls(ac97_t * ac)1294 ac97_register_controls(ac97_t *ac)
1295 {
1296 ac97_ctrl_t *ctrl;
1297
1298 for (ctrl = list_head(&ac->ctrls); ctrl;
1299 ctrl = list_next(&ac->ctrls, ctrl)) {
1300 if (ctrl->actrl_suppress)
1301 continue;
1302 ac97_control_register(ctrl);
1303 }
1304 }
1305
1306 void
ac97_walk_controls(ac97_t * ac,ac97_ctrl_walk_t walker,void * arg)1307 ac97_walk_controls(ac97_t *ac, ac97_ctrl_walk_t walker, void *arg)
1308 {
1309 ac97_ctrl_t *ctrl;
1310
1311 for (ctrl = list_head(&ac->ctrls); ctrl;
1312 ctrl = list_next(&ac->ctrls, ctrl)) {
1313 if (!(*walker)(ctrl, arg)) {
1314 break;
1315 }
1316 }
1317 }
1318
1319 void
ac_add_control(ac97_t * ac,ac97_ctrl_probe_t * cpt)1320 ac_add_control(ac97_t *ac, ac97_ctrl_probe_t *cpt)
1321 {
1322 ac97_ctrl_t *ctrl;
1323 boolean_t is_new;
1324
1325 ASSERT(ac);
1326 ASSERT(ac->d);
1327
1328 ctrl = ac97_control_find(ac, cpt->cp_name);
1329 if (ctrl != NULL) {
1330 is_new = B_FALSE;
1331 } else {
1332 ctrl = kmem_zalloc(sizeof (ac97_ctrl_t), KM_SLEEP);
1333 is_new = B_TRUE;
1334 }
1335 ctrl->actrl_ac97 = ac;
1336 ctrl->actrl_minval = cpt->cp_minval;
1337 ctrl->actrl_maxval = cpt->cp_maxval;
1338 ctrl->actrl_type = cpt->cp_type;
1339 ctrl->actrl_name = cpt->cp_name;
1340 ctrl->actrl_flags = cpt->cp_flags;
1341 if (cpt->cp_enum) {
1342 for (int e = 0; e < 64; e++) {
1343 if (cpt->cp_enum[e] == NULL)
1344 break;
1345 ctrl->actrl_enum[e] = cpt->cp_enum[e];
1346 }
1347 }
1348
1349 /*
1350 * Warning for extended controls this field gets changed
1351 * by audio_dev_add_control() to be a unique value.
1352 */
1353 ctrl->actrl_initval = cpt->cp_initval;
1354 ctrl->actrl_muteable = cpt->cp_muteable;
1355 ctrl->actrl_write_fn = cpt->cp_write_fn;
1356 ctrl->actrl_bits = cpt->cp_bits;
1357
1358 /*
1359 * Not that it can not be referenced until it is in the
1360 * list. So again by adding to the list last we avoid the need
1361 * for locks.
1362 */
1363 if (is_new)
1364 list_insert_tail(&ac->ctrls, ctrl);
1365 }
1366
1367 /*
1368 * De-Register and free up a control
1369 */
1370 void
ac97_control_remove(ac97_ctrl_t * ctrl)1371 ac97_control_remove(ac97_ctrl_t *ctrl)
1372 {
1373 ac97_t *ac = ctrl->actrl_ac97;
1374
1375 list_remove(&ac->ctrls, ctrl);
1376
1377 if (ctrl->actrl_ctrl != NULL)
1378 audio_dev_del_control(ctrl->actrl_ctrl);
1379 kmem_free(ctrl, sizeof (ac97_ctrl_t));
1380 }
1381
1382 /*
1383 * This is the master list of all controls known and handled by
1384 * the AC97 framework. This is the list used to probe, allocate
1385 * and configure controls. If a control is not in this list it
1386 * will not be handled. If a control is in this list but does not
1387 * have a probe routine then it will always be included. If a
1388 * control in list has a probe routine then it must return true
1389 * for that control to be included.
1390 */
1391
1392 #define MONCTL (AC97_FLAGS | AUDIO_CTRL_FLAG_MONITOR)
1393 #define PLAYCTL (AC97_FLAGS | AUDIO_CTRL_FLAG_PLAY)
1394 #define RECCTL (AC97_FLAGS | AUDIO_CTRL_FLAG_REC)
1395 #define T3DCTL (AC97_FLAGS | AUDIO_CTRL_FLAG_3D)
1396 #define TONECTL (AC97_FLAGS | AUDIO_CTRL_FLAG_TONE)
1397 #define MAINVOL (PLAYCTL | AUDIO_CTRL_FLAG_MAINVOL)
1398 #define PCMVOL (PLAYCTL | AUDIO_CTRL_FLAG_PCMVOL)
1399 #define RECVOL (RECCTL | AUDIO_CTRL_FLAG_RECVOL)
1400 #define MONVOL (MONCTL | AUDIO_CTRL_FLAG_MONVOL)
1401
1402 ac97_ctrl_probe_t ctrl_probe_tbl[] = {
1403
1404 /* Master PCM Volume */
1405 {AUDIO_CTRL_ID_VOLUME, INIT_VAL_MAIN, 0, 100, AUDIO_CTRL_TYPE_MONO,
1406 PCMVOL, PCMOVR_MUTE, ac97_master_set, NULL, 5},
1407
1408 /* LINE out volume */
1409 {AUDIO_CTRL_ID_LINEOUT, INIT_VAL_ST, 0, 100, AUDIO_CTRL_TYPE_STEREO,
1410 MAINVOL, 0x8080, ac97_lineout_set, ac_probe_lineout, 6},
1411
1412 /* Front volume */
1413 {AUDIO_CTRL_ID_FRONT, INIT_VAL_ST, 0, 100, AUDIO_CTRL_TYPE_STEREO,
1414 MAINVOL, 0x8080, ac97_lineout_set, ac_probe_front, 6},
1415
1416 /* 4CH out volume (has one of three possible uses, first use) */
1417 {AUDIO_CTRL_ID_SURROUND, INIT_VAL_ST, 0, 100, AUDIO_CTRL_TYPE_STEREO,
1418 MAINVOL, 0x8080, ac97_surround_set, ac_probe_rear, 6},
1419
1420 /* ALT out volume (has one of three possible uses, second use) */
1421 {AUDIO_CTRL_ID_HEADPHONE, INIT_VAL_ST, 0, 100, AUDIO_CTRL_TYPE_STEREO,
1422 MAINVOL, 0x8080, ac97_headphone_set, ac_probe_headphone, 6},
1423
1424 /* ALT out volume (has one of three possible uses, third use) */
1425 {AUDIO_CTRL_ID_AUX1OUT, INIT_VAL_ST, 0, 100, AUDIO_CTRL_TYPE_STEREO,
1426 MAINVOL, 0x8080, ac97_aux1out_set, ac_probe_auxout, 6},
1427
1428 /* center out volume */
1429 {AUDIO_CTRL_ID_CENTER, INIT_VAL_MN, 0, 100, AUDIO_CTRL_TYPE_MONO,
1430 MAINVOL, EXLFEVR_CENTER_MUTE, ac_center_set, ac_probe_center, 6},
1431
1432 /* LFE out volume (sub-woofer) */
1433 {AUDIO_CTRL_ID_LFE, INIT_VAL_MN, 0, 100, AUDIO_CTRL_TYPE_MONO,
1434 MAINVOL, EXLFEVR_LFE_MUTE, ac_lfe_set, ac_probe_lfe, 6},
1435
1436 /* MONO out volume */
1437 {AUDIO_CTRL_ID_SPEAKER, INIT_VAL_MN, 0, 100, AUDIO_CTRL_TYPE_MONO,
1438 MAINVOL, MMVR_MUTE, ac_speaker_set, ac_probe_mono, 6},
1439
1440 /* Record in GAIN */
1441 {AUDIO_CTRL_ID_RECGAIN, INIT_IGAIN_ST, 0, 100, AUDIO_CTRL_TYPE_STEREO,
1442 RECVOL, RGR_MUTE, ac_recgain_set, NULL, -4},
1443
1444 /* MIC in volume */
1445 {AUDIO_CTRL_ID_MIC, 0, 0, 100, AUDIO_CTRL_TYPE_STEREO,
1446 MONVOL, MICVR_MUTE, ac_mic_set, ac_probe_mic, 5},
1447
1448 /* LINE in volume */
1449 {AUDIO_CTRL_ID_LINEIN, 0, 0, 100, AUDIO_CTRL_TYPE_STEREO,
1450 MONVOL, LIVR_MUTE, ac_linein_set, ac_probe_linein, 5},
1451
1452 /* CD in volume */
1453 {AUDIO_CTRL_ID_CD, 0, 0, 100, AUDIO_CTRL_TYPE_STEREO,
1454 MONVOL, CDVR_MUTE, ac_cd_set, ac_probe_cdrom, 5},
1455
1456 /* VIDEO in volume */
1457 {AUDIO_CTRL_ID_VIDEO, 0, 0, 100, AUDIO_CTRL_TYPE_STEREO,
1458 MONVOL, VIDVR_MUTE, ac_video_set, ac_probe_video, 5},
1459
1460 /* AUX in volume */
1461 {AUDIO_CTRL_ID_AUX1IN, 0, 0, 100, AUDIO_CTRL_TYPE_STEREO,
1462 MONVOL, AUXVR_MUTE, ac_auxin_set, ac_probe_auxin, 5},
1463
1464 /* PHONE in volume */
1465 {AUDIO_CTRL_ID_PHONE, 0, 0, 100, AUDIO_CTRL_TYPE_MONO,
1466 MONVOL, PVR_MUTE, ac_phone_set, ac_probe_phone, 5},
1467
1468 /* PC BEEPER in volume (motherboard speaker pins) */
1469 {AUDIO_CTRL_ID_BEEP, INIT_VAL_MN, 0, 100, AUDIO_CTRL_TYPE_MONO,
1470 AC97_RW, PCBR_MUTE, ac_pcbeep_set, ac_probe_pcbeep, 4},
1471
1472 /* BASS out level (note, zero is hardware bypass) */
1473 {AUDIO_CTRL_ID_BASS, 0, 0, 100, AUDIO_CTRL_TYPE_MONO,
1474 TONECTL, 0, ac_bass_set, ac_probe_tone, 4},
1475
1476 /* TREBLE out level (note, zero is hardware bypass) */
1477 {AUDIO_CTRL_ID_TREBLE, 0, 0, 100, AUDIO_CTRL_TYPE_MONO,
1478 TONECTL, 0, ac_treble_set, ac_probe_tone, 4},
1479
1480 /* Loudness on/off switch */
1481 {AUDIO_CTRL_ID_LOUDNESS, 0, 0, 1, AUDIO_CTRL_TYPE_BOOLEAN,
1482 TONECTL, 0, ac_loudness_set, ac_probe_loud, 0},
1483
1484 /* 3D depth out level */
1485 {AUDIO_CTRL_ID_3DDEPTH, 0, 0, 100, AUDIO_CTRL_TYPE_MONO,
1486 T3DCTL, 0, ac_3ddepth_set, ac_probe_3d_depth, 4},
1487
1488 /* 3D center out level */
1489 {AUDIO_CTRL_ID_3DCENT, 0, 0, 100, AUDIO_CTRL_TYPE_MONO,
1490 T3DCTL, 0, ac_3dcent_set, ac_probe_3d_center, 4},
1491
1492 /* 3D enhance on/off switch */
1493 {AUDIO_CTRL_ID_3DENHANCE, 0, 0, 1, AUDIO_CTRL_TYPE_BOOLEAN,
1494 T3DCTL, 0, ac_3donoff_set, ac_probe_3d, 0},
1495
1496 /* MIC BOOST switch */
1497 {AUDIO_CTRL_ID_MICBOOST, 0, 0, 1, AUDIO_CTRL_TYPE_BOOLEAN,
1498 RECCTL, 0, ac97_micboost_set, ac_probe_mic, 0},
1499
1500 /* Loopback on/off switch */
1501 {AUDIO_CTRL_ID_LOOPBACK, 0, 0, 1, AUDIO_CTRL_TYPE_BOOLEAN,
1502 AC97_RW, 0, ac_loopback_set, NULL, 0},
1503
1504 /*
1505 * The following selectors *must* come after the others, as they rely
1506 * on the probe results of other controls.
1507 */
1508 /* record src select (only one port at a time) */
1509 {AUDIO_CTRL_ID_RECSRC, (1U << INPUT_MIC), 0, 0, AUDIO_CTRL_TYPE_ENUM,
1510 RECCTL, 0, ac_insrc_set, NULL, 0, ac_insrcs},
1511
1512 /* Start of non-standard private controls */
1513
1514 /* Simulated stereo on/off switch */
1515 {AUDIO_CTRL_ID_STEREOSIM, 0, 0, 1, AUDIO_CTRL_TYPE_BOOLEAN,
1516 AC97_RW, 0, ac_stsim_set, ac_probe_stsim, 0},
1517
1518 /* mono MIC GAIN */
1519 {AUDIO_CTRL_ID_MICGAIN, INIT_IGAIN_MN, 0, 100, AUDIO_CTRL_TYPE_MONO,
1520 RECCTL, RGMR_MUTE, ac_monomic_set, ac_probe_mmic, -4},
1521
1522 /* MIC select switch 0=mic1 1=mic2 */
1523 {AUDIO_CTRL_ID_MICSRC, 1, 3, 3, AUDIO_CTRL_TYPE_ENUM,
1524 RECCTL, 0, ac_selmic_set, ac_probe_mic, 0, ac_mics},
1525
1526 /* MONO out src select 0=mix 1=mic */
1527 {AUDIO_CTRL_ID_SPKSRC, 1, 3, 3, AUDIO_CTRL_TYPE_ENUM,
1528 AC97_RW, 0, ac_monosrc_set, ac_probe_mono, 0, ac_monos},
1529
1530 {NULL}
1531 };
1532
1533 /*
1534 * Probe all possible controls and register existing
1535 * ones and set initial values
1536 *
1537 * Returns zero on success
1538 */
1539 static void
ac_probeinit_ctrls(ac97_t * ac,int vol_bits,int enh_bits)1540 ac_probeinit_ctrls(ac97_t *ac, int vol_bits, int enh_bits)
1541 {
1542 ac97_ctrl_probe_t *cpt;
1543 ac97_ctrl_probe_t my_cpt;
1544
1545 ASSERT(ac);
1546
1547 /*
1548 * Set some ports which are always present.
1549 */
1550 ac->inputs = (1U << INPUT_STEREOMIX) | (1U << INPUT_MONOMIX);
1551 for (cpt = &ctrl_probe_tbl[0]; cpt->cp_name != NULL; cpt++) {
1552 bcopy(cpt, &my_cpt, sizeof (my_cpt));
1553
1554 if (strcmp(my_cpt.cp_name, AUDIO_CTRL_ID_RECSRC) == 0) {
1555 my_cpt.cp_minval |= ac->inputs;
1556 my_cpt.cp_maxval |= ac->inputs;
1557 }
1558
1559 if (strcmp(my_cpt.cp_name, AUDIO_CTRL_ID_MICBOOST) == 0) {
1560 if (ac->flags & AC97_FLAG_MICBOOST)
1561 my_cpt.cp_initval = 1;
1562 }
1563
1564 if ((strcmp(my_cpt.cp_name, AUDIO_CTRL_ID_FRONT) == 0) ||
1565 (strcmp(my_cpt.cp_name, AUDIO_CTRL_ID_HEADPHONE) == 0) ||
1566 (strcmp(my_cpt.cp_name, AUDIO_CTRL_ID_SURROUND) == 0) ||
1567 (strcmp(my_cpt.cp_name, AUDIO_CTRL_ID_SPEAKER) == 0)) {
1568 my_cpt.cp_bits = vol_bits;
1569 }
1570
1571 if ((strcmp(my_cpt.cp_name, AUDIO_CTRL_ID_3DDEPTH) == 0) ||
1572 (strcmp(my_cpt.cp_name, AUDIO_CTRL_ID_3DCENT) == 0)) {
1573 my_cpt.cp_bits = enh_bits;
1574 }
1575
1576 if (!my_cpt.cp_probe || my_cpt.cp_probe(ac)) {
1577 ac_add_control(ac, &my_cpt);
1578 }
1579 }
1580
1581 if (ac->codec_init != NULL) {
1582 ac->codec_init(ac);
1583 }
1584 }
1585
1586 /*
1587 * Allocate an AC97 instance for use by a hardware driver.
1588 *
1589 * returns an allocated and initialize ac97 structure.
1590 */
1591 ac97_t *
ac97_alloc(dev_info_t * dip,ac97_rd_t rd,ac97_wr_t wr,void * priv)1592 ac97_alloc(dev_info_t *dip, ac97_rd_t rd, ac97_wr_t wr, void *priv)
1593 {
1594 ac97_t *ac;
1595
1596 ac = kmem_zalloc(sizeof (ac97_t), KM_SLEEP);
1597 ac->dip = dip;
1598 ac->rd = rd;
1599 ac->wr = wr;
1600 ac->private = priv;
1601
1602 list_create(&ac->ctrls, sizeof (struct ac97_ctrl),
1603 offsetof(struct ac97_ctrl, actrl_linkage));
1604
1605 #define PROP_FLAG(prop, flag, def) \
1606 if (ddi_prop_get_int(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, \
1607 (prop), (def))) { \
1608 ac->flags |= (flag); \
1609 } else { \
1610 ac->flags &= ~(flag); \
1611 }
1612
1613 /*
1614 * Engage the external amplifier by default, suppress with
1615 * a property of the form "ac97-amplifier=0".
1616 */
1617 PROP_FLAG(AC97_PROP_AMPLIFIER, AC97_FLAG_AMPLIFIER, 1);
1618
1619 /*
1620 * We cannot necessarily know if the headphone jack is present
1621 * or not. There's a technique to probe the codec for
1622 * headphone support, but many vendors seem to simply hang the
1623 * headphone jack on the line out circuit, and have some kind
1624 * of jack sense detection to enable or disable it by default.
1625 * None of this is visible in the AC'97 registers.
1626 *
1627 * We cannot do much about it, but what we can do is offer users
1628 * a way to suppress the option for a headphone port. Users and
1629 * administrators can then set a flag in the driver.conf to suppress
1630 * the option from display.
1631 *
1632 * It turns out that this problem exists for other signals as
1633 * well.
1634 */
1635 PROP_FLAG(AC97_PROP_NO_HEADPHONE, AC97_FLAG_NO_HEADPHONE, 0);
1636 PROP_FLAG(AC97_PROP_NO_AUXOUT, AC97_FLAG_NO_AUXOUT, 0);
1637 PROP_FLAG(AC97_PROP_NO_CDROM, AC97_FLAG_NO_CDROM, 0);
1638 PROP_FLAG(AC97_PROP_NO_AUXIN, AC97_FLAG_NO_AUXIN, 0);
1639 PROP_FLAG(AC97_PROP_NO_VIDEO, AC97_FLAG_NO_VIDEO, 0);
1640 PROP_FLAG(AC97_PROP_NO_LINEIN, AC97_FLAG_NO_LINEIN, 0);
1641 PROP_FLAG(AC97_PROP_NO_MIC, AC97_FLAG_NO_MIC, 0);
1642
1643 /*
1644 * Most SPARC systems use the AC97 monoaural output for the
1645 * built-in speaker. On these systems, we want to expose and
1646 * enable the built-in speaker by default.
1647 *
1648 * On most x86 systems, the mono output is not connected to
1649 * anything -- the AC'97 spec makes it pretty clear that the
1650 * output was actually intended for use with speaker phones.
1651 * So on those systems, we really don't want to activate the
1652 * speaker -- we don't even want to expose it's presence
1653 * normally.
1654 *
1655 * However, there could be an exception to the rule here. To
1656 * facilitate this, we allow for the presence of the property
1657 * to indicate that the speaker should be exposed. Whether it
1658 * is enabled by default or not depends on the value of the
1659 * property. (Generally on SPARC, we enable by default. On
1660 * other systems we do not.)
1661 */
1662 #ifdef __sparc
1663 ac->flags |= AC97_FLAG_SPEAKER_OK;
1664 PROP_FLAG(AC97_PROP_SPEAKER, AC97_FLAG_SPEAKER, 1);
1665 #else
1666 if (ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
1667 AC97_PROP_SPEAKER)) {
1668 ac->flags |= AC97_FLAG_SPEAKER_OK;
1669 PROP_FLAG(AC97_PROP_SPEAKER, AC97_FLAG_SPEAKER, 0);
1670 }
1671 #endif
1672
1673 /*
1674 * Enable microphone boost (20dB normally) by default?
1675 */
1676 PROP_FLAG(AC97_PROP_MICBOOST, AC97_FLAG_MICBOOST, 0);
1677
1678 return (ac);
1679 }
1680 /*
1681 * Allocate an AC97 instance for use by a hardware driver.
1682 *
1683 * returns an allocated and initialize ac97 structure.
1684 */
1685 ac97_t *
ac97_allocate(audio_dev_t * adev,dev_info_t * dip,ac97_rd_t rd,ac97_wr_t wr,void * priv)1686 ac97_allocate(audio_dev_t *adev, dev_info_t *dip, ac97_rd_t rd, ac97_wr_t wr,
1687 void *priv)
1688 {
1689 ac97_t *ac;
1690
1691 ac = ac97_alloc(dip, rd, wr, priv);
1692 if (ac != NULL) {
1693 ac->d = adev;
1694 }
1695 return (ac);
1696 }
1697
1698 /*
1699 * Free an AC97 instance.
1700 */
1701 void
ac97_free(ac97_t * ac)1702 ac97_free(ac97_t *ac)
1703 {
1704 ac97_ctrl_t *ctrl;
1705
1706 /* Clear out any controls that are still attached */
1707 while ((ctrl = list_head(&ac->ctrls)) != NULL) {
1708 ac97_control_remove(ctrl);
1709 }
1710
1711 list_destroy(&ac->ctrls);
1712 kmem_free(ac, sizeof (ac97_t));
1713 }
1714
1715 static struct vendor {
1716 unsigned id;
1717 const char *name;
1718 } vendors[] = {
1719 { AC97_VENDOR_ADS, "Analog Devices" },
1720 { AC97_VENDOR_AKM, "Asahi Kasei" },
1721 { AC97_VENDOR_ALC, "Realtek" },
1722 { AC97_VENDOR_ALG, "Avance Logic" },
1723 { AC97_VENDOR_CMI, "C-Media" },
1724 { AC97_VENDOR_CRY, "Cirrus Logic" },
1725 { AC97_VENDOR_CXT, "Conexant" },
1726 { AC97_VENDOR_EMC, "eMicro" },
1727 { AC97_VENDOR_ESS, "ESS Technology" },
1728 { AC97_VENDOR_EV, "Ectiva" },
1729 { AC97_VENDOR_HRS, "Intersil" },
1730 { AC97_VENDOR_ICE, "ICEnsemble" },
1731 { AC97_VENDOR_ITE, "ITE, Inc." },
1732 { AC97_VENDOR_NSC, "National Semiconductor" },
1733 { AC97_VENDOR_PSC, "Philips Semiconductor" },
1734 { AC97_VENDOR_SIL, "Silicon Laboratories" },
1735 { AC97_VENDOR_ST, "SigmaTel" },
1736 { AC97_VENDOR_TRA, "TriTech", },
1737 { AC97_VENDOR_TXN, "Texas Instruments", },
1738 { AC97_VENDOR_VIA, "VIA Technologies" },
1739 { AC97_VENDOR_WML, "Wolfson" },
1740 { AC97_VENDOR_YMH, "Yamaha" },
1741 { 0, NULL },
1742 };
1743
1744 static struct codec {
1745 unsigned id;
1746 const char *name;
1747 int enh_bits;
1748 void (*init)(ac97_t *ac);
1749 void (*reset)(ac97_t *ac);
1750 } codecs[] = {
1751 { AC97_CODEC_AK4540, "AK4540" },
1752 { AC97_CODEC_STAC9700, "STAC9700" },
1753 { AC97_CODEC_STAC9701, "STAC9701" },
1754 { AC97_CODEC_STAC9701_2, "STAC9701" },
1755 { AC97_CODEC_STAC9704, "STAC9704" },
1756 { AC97_CODEC_STAC9705, "STAC9705" },
1757 { AC97_CODEC_STAC9721, "STAC9721" },
1758 { AC97_CODEC_STAC9708, "STAC9708", 2 },
1759 { AC97_CODEC_STAC9744, "STAC9744" },
1760 { AC97_CODEC_STAC9750, "STAC9750", 3 },
1761 { AC97_CODEC_STAC9752, "STAC9752", 3 },
1762 { AC97_CODEC_STAC9756, "STAC9756", 3 },
1763 { AC97_CODEC_STAC9758, "STAC9758", 3 },
1764 { AC97_CODEC_STAC9766, "STAC9766", 3 },
1765 { AC97_CODEC_TR28028, "TR28028" },
1766 { AC97_CODEC_TR28028_2, "TR28028" },
1767 { AC97_CODEC_TR28023, "TR28023" },
1768 { AC97_CODEC_TR28023_2, "TR28023" },
1769 { AC97_CODEC_EM28028, "EM28028" },
1770 { AC97_CODEC_CX20468, "CX20468" },
1771 { AC97_CODEC_CX20468_2, "CX20468" },
1772 { AC97_CODEC_CX20468_21, "CX20468-21" },
1773 { AC97_CODEC_CS4297, "CS4297" },
1774 { AC97_CODEC_CS4297A, "CS4297A" },
1775 { AC97_CODEC_CS4294, "CS4294" },
1776 { AC97_CODEC_CS4299, "CS4299" },
1777 { AC97_CODEC_CS4202, "CS4202" },
1778 { AC97_CODEC_CS4205, "CS4205" },
1779 { AC97_CODEC_AD1819B, "AD1819B" },
1780 { AC97_CODEC_AD1881, "AD1881" },
1781 { AC97_CODEC_AD1881A, "AD1881A" },
1782 { AC97_CODEC_AD1885, "AD1885" },
1783 { AC97_CODEC_AD1886, "AD1886" },
1784 { AC97_CODEC_AD1887, "AD1887" },
1785 { AC97_CODEC_AD1888, "AD1888" },
1786 { AC97_CODEC_AD1980, "AD1980" },
1787 { AC97_CODEC_AD1981, "AD1981" }, /* no data sheet */
1788 { AC97_CODEC_AD1981A, "AD1981A", 0, ad1981a_init },
1789 { AC97_CODEC_AD1981B, "AD1981B", 0, ad1981b_init },
1790 { AC97_CODEC_AD1985, "AD1985" },
1791 { AC97_CODEC_WM9701A, "WM9701A" },
1792 { AC97_CODEC_WM9703, "WM9703" },
1793 { AC97_CODEC_WM9704, "WM9704" },
1794 { AC97_CODEC_ES1921, "ES1921" },
1795 { AC97_CODEC_ICE1232, "ICE1232/VT1611A" },
1796 { AC97_CODEC_LM4550, "LM4550" },
1797 { AC97_CODEC_VT1612A, "VT1612A" },
1798 { AC97_CODEC_VT1616, "VT1616" },
1799 { AC97_CODEC_VT1616A, "VT1616A" },
1800 { AC97_CODEC_VT1617A, "VT1617A" },
1801 { AC97_CODEC_VT1618, "VT1618" },
1802 { AC97_CODEC_ALC100, "ALC100", 2 },
1803 { AC97_CODEC_ALC200P, "ALC200P", 2 },
1804 { AC97_CODEC_ALC202, "ALC202", 2 },
1805 { AC97_CODEC_ALC203, "ALC203", 2 },
1806 { AC97_CODEC_ALC250, "ALC250", 2 },
1807 { AC97_CODEC_ALC250_2, "ALC250", 2 },
1808 { AC97_CODEC_ALC650, "ALC650", 2, alc650_init },
1809 { AC97_CODEC_ALC655, "ALC655", 2, alc650_init },
1810 { AC97_CODEC_ALC658, "ALC658", 2, alc650_init },
1811 { AC97_CODEC_ALC850, "ALC850", 2, alc850_init },
1812 { AC97_CODEC_EV1938, "EV1938" },
1813 { AC97_CODEC_CMI9738, "CMI9738", 0, cmi9738_init },
1814 { AC97_CODEC_CMI9739, "CMI9739", 0, cmi9739_init },
1815 { AC97_CODEC_CMI9780, "CMI9780" },
1816 { AC97_CODEC_CMI9761, "CMI9761A", 0, cmi9761_init },
1817 { AC97_CODEC_CMI9761_2, "CMI9761B", 0, cmi9761_init },
1818 { AC97_CODEC_CMI9761_3, "CMI9761A+", 0, cmi9761_init },
1819 { AC97_CODEC_YMF743, "YMF743" },
1820 { AC97_CODEC_YMF753, "YMF753" },
1821 { 0, NULL }
1822 };
1823
1824 void
ac97_probe_controls(ac97_t * ac)1825 ac97_probe_controls(ac97_t *ac)
1826 {
1827 uint32_t vid1, vid2;
1828 uint16_t ear;
1829 const char *name = NULL;
1830 const char *vendor = NULL;
1831 int enh_bits;
1832 int vol_bits;
1833 uint32_t flags;
1834 char nmbuf[128];
1835 char buf[128];
1836
1837 /* This is only valid when used with new style ac97_allocate(). */
1838 ASSERT(ac->d);
1839
1840 ac_analog_reset(ac);
1841
1842 vid1 = RD(AC97_VENDOR_ID1_REGISTER);
1843 vid2 = RD(AC97_VENDOR_ID2_REGISTER);
1844
1845 if (vid1 == 0xffff) {
1846 audio_dev_warn(ac->d, "AC'97 codec unresponsive");
1847 return;
1848 }
1849
1850 ac->vid = (vid1 << 16) | vid2;
1851
1852 /*
1853 * Find out kind of codec we have and set any special case
1854 * settings needed.
1855 */
1856 for (int i = 0; codecs[i].id; i++) {
1857 if (ac->vid == codecs[i].id) {
1858 name = codecs[i].name;
1859 enh_bits = codecs[i].enh_bits;
1860 ac->codec_init = codecs[i].init;
1861 break;
1862 }
1863 }
1864 for (int i = 0; vendors[i].id; i++) {
1865 if ((ac->vid & 0xffffff00) == vendors[i].id) {
1866 vendor = vendors[i].name;
1867 break;
1868 }
1869 }
1870 if (name == NULL) {
1871 (void) snprintf(nmbuf, sizeof (nmbuf), "0x%04x%04x",
1872 vid1, vid2);
1873 name = nmbuf;
1874 }
1875 if (vendor == NULL) {
1876 vendor = "Unknown";
1877 }
1878
1879 /*
1880 * Populate the initial shadow table.
1881 */
1882 for (int i = 0; i < LAST_SHADOW_REG; i += sizeof (uint16_t)) {
1883 SHADOW(ac, i) = RD(i);
1884 }
1885
1886 ac->caps = RD(AC97_RESET_REGISTER);
1887
1888 enh_bits = 4;
1889 vol_bits = 6;
1890 flags = 0;
1891
1892 /* detect the bit width of the master volume controls */
1893 WR(AC97_MASTER_VOLUME_REGISTER, 0x20);
1894 if ((RD(AC97_MASTER_VOLUME_REGISTER) & 0x1f) == 0x1f) {
1895 vol_bits = 5;
1896 }
1897
1898 /*
1899 * AC'97 2.3 spec indicates three possible uses for AUX_OUT
1900 * (aka LNLVL_OUT aka HP_OUT). We have to figure out which one
1901 * is in use.
1902 */
1903 if (ac->caps & RR_HEADPHONE_SUPPORT) {
1904 /* it looks like it is probably headphones */
1905 if (ac_probe_reg(ac, AC97_HEADPHONE_VOLUME_REGISTER)) {
1906 /* it is implemented */
1907 ac->flags |= AC97_FLAG_AUX_HP;
1908 }
1909 }
1910
1911 /* Read EAR just once. */
1912 ear = RD(AC97_EXTENDED_AUDIO_REGISTER);
1913
1914 /*
1915 * If not a headphone, is it 4CH_OUT (surround?)
1916 */
1917 if ((!(ac->flags & AC97_FLAG_AUX_HP)) && (ear & EAR_SDAC)) {
1918 if (ac_probe_reg(ac, AC97_EXTENDED_LRS_VOLUME_REGISTER)) {
1919 ac->flags |= AC97_FLAG_AUX_4CH;
1920 }
1921 }
1922
1923 /*
1924 * If neither, then maybe its an auxiliary line level output?
1925 */
1926 if (!(ac->flags & (AC97_FLAG_AUX_HP | AC97_FLAG_AUX_4CH))) {
1927 if (ac_probe_reg(ac, AC97_HEADPHONE_VOLUME_REGISTER)) {
1928 ac->flags |= AC97_FLAG_AUX_LVL;
1929 }
1930 }
1931
1932 /*
1933 * How many channels?
1934 */
1935 ac->nchan = 2;
1936 if (ear & EAR_SDAC) {
1937 ac->nchan += 2;
1938 }
1939 if (ear & EAR_CDAC) {
1940 ac->nchan++;
1941 }
1942 if (ear & EAR_LDAC) {
1943 ac->nchan++;
1944 }
1945
1946 ac->flags |= flags;
1947 (void) snprintf(ac->name, sizeof (ac->name), "%s %s", vendor, name);
1948
1949 (void) snprintf(buf, sizeof (buf), "AC'97 codec: %s", ac->name);
1950 audio_dev_add_info(ac->d, buf);
1951
1952 cmn_err(CE_CONT,
1953 "?%s#%d: AC'97 codec id %s (%x, %d channels, caps %x)\n",
1954 ddi_driver_name(ac->dip), ddi_get_instance(ac->dip),
1955 ac->name, ac->vid, ac->nchan, ac->caps);
1956
1957 /*
1958 * Probe and register all known controls with framework
1959 */
1960 ac_probeinit_ctrls(ac, vol_bits, enh_bits);
1961
1962 ac_hw_reset(ac);
1963 ac_init_values(ac);
1964 }
1965
1966 /*
1967 * Init the actual hardware related to a previously allocated instance
1968 * of an AC97 device. This is a legacy function and should not be
1969 * used in new code.
1970 *
1971 * Return zero on success.
1972 */
1973 int
ac97_init(ac97_t * ac,struct audio_dev * d)1974 ac97_init(ac97_t *ac, struct audio_dev *d)
1975 {
1976 /* Make sure we aren't using this with new style ac97_allocate(). */
1977 ASSERT(ac->d == NULL);
1978
1979 /* Save audio framework instance structure */
1980 ac->d = d;
1981
1982 ac97_probe_controls(ac);
1983 ac97_register_controls(ac);
1984
1985 return (0);
1986 }
1987