1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
|
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* HD audio interface patch for Senary HDA audio codec
*
* Initially based on sound/pci/hda/patch_conexant.c
*/
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <sound/core.h>
#include <sound/jack.h>
#include <sound/hda_codec.h>
#include "hda_local.h"
#include "hda_auto_parser.h"
#include "hda_beep.h"
#include "hda_jack.h"
#include "hda_generic.h"
struct senary_spec {
struct hda_gen_spec gen;
/* extra EAPD pins */
unsigned int num_eapds;
hda_nid_t eapds[4];
hda_nid_t mute_led_eapd;
unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */
int mute_led_polarity;
unsigned int gpio_led;
unsigned int gpio_mute_led_mask;
unsigned int gpio_mic_led_mask;
};
#ifdef CONFIG_SND_HDA_INPUT_BEEP
/* additional beep mixers; private_value will be overwritten */
static const struct snd_kcontrol_new senary_beep_mixer[] = {
HDA_CODEC_VOLUME_MONO("Beep Playback Volume", 0, 1, 0, HDA_OUTPUT),
HDA_CODEC_MUTE_BEEP_MONO("Beep Playback Switch", 0, 1, 0, HDA_OUTPUT),
};
static int set_beep_amp(struct senary_spec *spec, hda_nid_t nid,
int idx, int dir)
{
struct snd_kcontrol_new *knew;
unsigned int beep_amp = HDA_COMPOSE_AMP_VAL(nid, 1, idx, dir);
int i;
spec->gen.beep_nid = nid;
for (i = 0; i < ARRAY_SIZE(senary_beep_mixer); i++) {
knew = snd_hda_gen_add_kctl(&spec->gen, NULL,
&senary_beep_mixer[i]);
if (!knew)
return -ENOMEM;
knew->private_value = beep_amp;
}
return 0;
}
static int senary_auto_parse_beep(struct hda_codec *codec)
{
struct senary_spec *spec = codec->spec;
hda_nid_t nid;
for_each_hda_codec_node(nid, codec)
if ((get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_BEEP) &&
(get_wcaps(codec, nid) & (AC_WCAP_OUT_AMP | AC_WCAP_AMP_OVRD)))
return set_beep_amp(spec, nid, 0, HDA_OUTPUT);
return 0;
}
#else
#define senary_auto_parse_beep(codec) 0
#endif
/* parse EAPDs */
static void senary_auto_parse_eapd(struct hda_codec *codec)
{
struct senary_spec *spec = codec->spec;
hda_nid_t nid;
for_each_hda_codec_node(nid, codec) {
if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
continue;
if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD))
continue;
spec->eapds[spec->num_eapds++] = nid;
if (spec->num_eapds >= ARRAY_SIZE(spec->eapds))
break;
}
}
static void senary_auto_turn_eapd(struct hda_codec *codec, int num_pins,
const hda_nid_t *pins, bool on)
{
int i;
for (i = 0; i < num_pins; i++) {
if (snd_hda_query_pin_caps(codec, pins[i]) & AC_PINCAP_EAPD)
snd_hda_codec_write(codec, pins[i], 0,
AC_VERB_SET_EAPD_BTLENABLE,
on ? 0x02 : 0);
}
}
/* turn on/off EAPD according to Master switch */
static void senary_auto_vmaster_hook(void *private_data, int enabled)
{
struct hda_codec *codec = private_data;
struct senary_spec *spec = codec->spec;
senary_auto_turn_eapd(codec, spec->num_eapds, spec->eapds, enabled);
}
static void senary_init_gpio_led(struct hda_codec *codec)
{
struct senary_spec *spec = codec->spec;
unsigned int mask = spec->gpio_mute_led_mask | spec->gpio_mic_led_mask;
if (mask) {
snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_MASK,
mask);
snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DIRECTION,
mask);
snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
spec->gpio_led);
}
}
static int senary_auto_init(struct hda_codec *codec)
{
snd_hda_gen_init(codec);
senary_init_gpio_led(codec);
snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
return 0;
}
static void senary_auto_shutdown(struct hda_codec *codec)
{
struct senary_spec *spec = codec->spec;
/* Turn the problematic codec into D3 to avoid spurious noises
* from the internal speaker during (and after) reboot
*/
senary_auto_turn_eapd(codec, spec->num_eapds, spec->eapds, false);
}
static void senary_auto_free(struct hda_codec *codec)
{
senary_auto_shutdown(codec);
snd_hda_gen_free(codec);
}
static int senary_auto_suspend(struct hda_codec *codec)
{
senary_auto_shutdown(codec);
return 0;
}
static const struct hda_codec_ops senary_auto_patch_ops = {
.build_controls = snd_hda_gen_build_controls,
.build_pcms = snd_hda_gen_build_pcms,
.init = senary_auto_init,
.free = senary_auto_free,
.unsol_event = snd_hda_jack_unsol_event,
.suspend = senary_auto_suspend,
.check_power_status = snd_hda_gen_check_power_status,
};
static int patch_senary_auto(struct hda_codec *codec)
{
struct senary_spec *spec;
int err;
codec_info(codec, "%s: BIOS auto-probing.\n", codec->core.chip_name);
spec = kzalloc(sizeof(*spec), GFP_KERNEL);
if (!spec)
return -ENOMEM;
snd_hda_gen_spec_init(&spec->gen);
codec->spec = spec;
codec->patch_ops = senary_auto_patch_ops;
senary_auto_parse_eapd(codec);
spec->gen.own_eapd_ctl = 1;
if (!spec->gen.vmaster_mute.hook)
spec->gen.vmaster_mute.hook = senary_auto_vmaster_hook;
snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
err = snd_hda_parse_pin_defcfg(codec, &spec->gen.autocfg, NULL,
spec->parse_flags);
if (err < 0)
goto error;
err = senary_auto_parse_beep(codec);
if (err < 0)
goto error;
err = snd_hda_gen_parse_auto_config(codec, &spec->gen.autocfg);
if (err < 0)
goto error;
/* Some laptops with Senary chips show stalls in S3 resume,
* which falls into the single-cmd mode.
* Better to make reset, then.
*/
if (!codec->bus->core.sync_write) {
codec_info(codec,
"Enable sync_write for stable communication\n");
codec->bus->core.sync_write = 1;
codec->bus->allow_bus_reset = 1;
}
snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
return 0;
error:
senary_auto_free(codec);
return err;
}
/*
*/
static const struct hda_device_id snd_hda_id_senary[] = {
HDA_CODEC_ENTRY(0x1fa86186, "SN6186", patch_senary_auto),
{} /* terminator */
};
MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_senary);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Senarytech HD-audio codec");
static struct hda_codec_driver senary_driver = {
.id = snd_hda_id_senary,
};
module_hda_codec_driver(senary_driver);
|
