1
2
3
4
5
6
7
8
9#include <linux/input.h>
10#include <linux/slab.h>
11#include <linux/workqueue.h>
12#include <linux/export.h>
13#include <sound/core.h>
14#include "hda_beep.h"
15#include "hda_local.h"
16
17enum {
18 DIGBEEP_HZ_STEP = 46875,
19 DIGBEEP_HZ_MIN = 93750,
20 DIGBEEP_HZ_MAX = 12000000,
21};
22
23
24static void generate_tone(struct hda_beep *beep, int tone)
25{
26 struct hda_codec *codec = beep->codec;
27
28 if (tone && !beep->playing) {
29 snd_hda_power_up(codec);
30 if (beep->power_hook)
31 beep->power_hook(beep, true);
32 beep->playing = 1;
33 }
34 snd_hda_codec_write(codec, beep->nid, 0,
35 AC_VERB_SET_BEEP_CONTROL, tone);
36 if (!tone && beep->playing) {
37 beep->playing = 0;
38 if (beep->power_hook)
39 beep->power_hook(beep, false);
40 snd_hda_power_down(codec);
41 }
42}
43
44static void snd_hda_generate_beep(struct work_struct *work)
45{
46 struct hda_beep *beep =
47 container_of(work, struct hda_beep, beep_work);
48
49 if (beep->enabled)
50 generate_tone(beep, beep->tone);
51}
52
53
54
55
56
57
58
59
60static int beep_linear_tone(struct hda_beep *beep, int hz)
61{
62 if (hz <= 0)
63 return 0;
64 hz *= 1000;
65 hz = hz - DIGBEEP_HZ_MIN
66 + DIGBEEP_HZ_STEP / 2;
67 if (hz < 0)
68 hz = 0;
69 else if (hz >= (DIGBEEP_HZ_MAX - DIGBEEP_HZ_MIN))
70 hz = 1;
71 else {
72 hz /= DIGBEEP_HZ_STEP;
73 hz = 255 - hz;
74 }
75 return hz;
76}
77
78
79
80
81
82
83
84static int beep_standard_tone(struct hda_beep *beep, int hz)
85{
86 if (hz <= 0)
87 return 0;
88 hz = 12000 / hz;
89 if (hz > 0xff)
90 return 0xff;
91 if (hz <= 0)
92 return 1;
93 return hz;
94}
95
96static int snd_hda_beep_event(struct input_dev *dev, unsigned int type,
97 unsigned int code, int hz)
98{
99 struct hda_beep *beep = input_get_drvdata(dev);
100
101 switch (code) {
102 case SND_BELL:
103 if (hz)
104 hz = 1000;
105
106 case SND_TONE:
107 if (beep->linear_tone)
108 beep->tone = beep_linear_tone(beep, hz);
109 else
110 beep->tone = beep_standard_tone(beep, hz);
111 break;
112 default:
113 return -1;
114 }
115
116
117 schedule_work(&beep->beep_work);
118 return 0;
119}
120
121static void turn_off_beep(struct hda_beep *beep)
122{
123 cancel_work_sync(&beep->beep_work);
124 if (beep->playing) {
125
126 generate_tone(beep, 0);
127 }
128}
129
130static void snd_hda_do_detach(struct hda_beep *beep)
131{
132 if (beep->registered)
133 input_unregister_device(beep->dev);
134 else
135 input_free_device(beep->dev);
136 beep->dev = NULL;
137 turn_off_beep(beep);
138}
139
140static int snd_hda_do_attach(struct hda_beep *beep)
141{
142 struct input_dev *input_dev;
143 struct hda_codec *codec = beep->codec;
144
145 input_dev = input_allocate_device();
146 if (!input_dev)
147 return -ENOMEM;
148
149
150 input_dev->name = "HDA Digital PCBeep";
151 input_dev->phys = beep->phys;
152 input_dev->id.bustype = BUS_PCI;
153 input_dev->dev.parent = &codec->card->card_dev;
154
155 input_dev->id.vendor = codec->core.vendor_id >> 16;
156 input_dev->id.product = codec->core.vendor_id & 0xffff;
157 input_dev->id.version = 0x01;
158
159 input_dev->evbit[0] = BIT_MASK(EV_SND);
160 input_dev->sndbit[0] = BIT_MASK(SND_BELL) | BIT_MASK(SND_TONE);
161 input_dev->event = snd_hda_beep_event;
162 input_set_drvdata(input_dev, beep);
163
164 beep->dev = input_dev;
165 return 0;
166}
167
168
169
170
171
172
173int snd_hda_enable_beep_device(struct hda_codec *codec, int enable)
174{
175 struct hda_beep *beep = codec->beep;
176 if (!beep)
177 return 0;
178 enable = !!enable;
179 if (beep->enabled != enable) {
180 beep->enabled = enable;
181 if (!enable)
182 turn_off_beep(beep);
183 return 1;
184 }
185 return 0;
186}
187EXPORT_SYMBOL_GPL(snd_hda_enable_beep_device);
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203int snd_hda_attach_beep_device(struct hda_codec *codec, int nid)
204{
205 struct hda_beep *beep;
206 int err;
207
208 if (!snd_hda_get_bool_hint(codec, "beep"))
209 return 0;
210 if (codec->beep_mode == HDA_BEEP_MODE_OFF)
211 return 0;
212
213 beep = kzalloc(sizeof(*beep), GFP_KERNEL);
214 if (beep == NULL)
215 return -ENOMEM;
216 snprintf(beep->phys, sizeof(beep->phys),
217 "card%d/codec#%d/beep0", codec->card->number, codec->addr);
218
219 snd_hda_codec_write_cache(codec, nid, 0,
220 AC_VERB_SET_DIGI_CONVERT_2, 0x01);
221
222 beep->nid = nid;
223 beep->codec = codec;
224 codec->beep = beep;
225
226 INIT_WORK(&beep->beep_work, &snd_hda_generate_beep);
227 mutex_init(&beep->mutex);
228
229 err = snd_hda_do_attach(beep);
230 if (err < 0) {
231 kfree(beep);
232 codec->beep = NULL;
233 return err;
234 }
235
236 return 0;
237}
238EXPORT_SYMBOL_GPL(snd_hda_attach_beep_device);
239
240
241
242
243
244void snd_hda_detach_beep_device(struct hda_codec *codec)
245{
246 struct hda_beep *beep = codec->beep;
247 if (beep) {
248 if (beep->dev)
249 snd_hda_do_detach(beep);
250 codec->beep = NULL;
251 kfree(beep);
252 }
253}
254EXPORT_SYMBOL_GPL(snd_hda_detach_beep_device);
255
256
257
258
259
260int snd_hda_register_beep_device(struct hda_codec *codec)
261{
262 struct hda_beep *beep = codec->beep;
263 int err;
264
265 if (!beep || !beep->dev)
266 return 0;
267
268 err = input_register_device(beep->dev);
269 if (err < 0) {
270 codec_err(codec, "hda_beep: unable to register input device\n");
271 input_free_device(beep->dev);
272 codec->beep = NULL;
273 kfree(beep);
274 return err;
275 }
276 beep->registered = true;
277 return 0;
278}
279EXPORT_SYMBOL_GPL(snd_hda_register_beep_device);
280
281static bool ctl_has_mute(struct snd_kcontrol *kcontrol)
282{
283 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
284 return query_amp_caps(codec, get_amp_nid(kcontrol),
285 get_amp_direction(kcontrol)) & AC_AMPCAP_MUTE;
286}
287
288
289
290
291
292
293
294
295int snd_hda_mixer_amp_switch_get_beep(struct snd_kcontrol *kcontrol,
296 struct snd_ctl_elem_value *ucontrol)
297{
298 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
299 struct hda_beep *beep = codec->beep;
300 if (beep && (!beep->enabled || !ctl_has_mute(kcontrol))) {
301 ucontrol->value.integer.value[0] =
302 ucontrol->value.integer.value[1] = beep->enabled;
303 return 0;
304 }
305 return snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
306}
307EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_get_beep);
308
309
310
311
312
313
314int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
315 struct snd_ctl_elem_value *ucontrol)
316{
317 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
318 struct hda_beep *beep = codec->beep;
319 if (beep) {
320 u8 chs = get_amp_channels(kcontrol);
321 int enable = 0;
322 long *valp = ucontrol->value.integer.value;
323 if (chs & 1) {
324 enable |= *valp;
325 valp++;
326 }
327 if (chs & 2)
328 enable |= *valp;
329 snd_hda_enable_beep_device(codec, enable);
330 }
331 if (!ctl_has_mute(kcontrol))
332 return 0;
333 return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
334}
335EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_put_beep);
336