xref: /linux/sound/pci/hda/hda_beep.c (revision 79790b6818e96c58fe2bffee1b418c16e64e7b80)
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Digital Beep Input Interface for HD-audio codec
4  *
5  * Author: Matt Ranostay <matt.ranostay@konsulko.com>
6  * Copyright (c) 2008 Embedded Alley Solutions Inc
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 
17 enum {
18 	DIGBEEP_HZ_STEP = 46875,	/* 46.875 Hz */
19 	DIGBEEP_HZ_MIN = 93750,		/* 93.750 Hz */
20 	DIGBEEP_HZ_MAX = 12000000,	/* 12 KHz */
21 };
22 
23 /* generate or stop tone */
generate_tone(struct hda_beep * beep,int tone)24 static 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 
snd_hda_generate_beep(struct work_struct * work)44 static 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 /* (non-standard) Linear beep tone calculation for IDT/STAC codecs
54  *
55  * The tone frequency of beep generator on IDT/STAC codecs is
56  * defined from the 8bit tone parameter, in Hz,
57  *    freq = 48000 * (257 - tone) / 1024
58  * that is from 12kHz to 93.75Hz in steps of 46.875 Hz
59  */
beep_linear_tone(struct hda_beep * beep,int hz)60 static int beep_linear_tone(struct hda_beep *beep, int hz)
61 {
62 	if (hz <= 0)
63 		return 0;
64 	hz *= 1000; /* fixed point */
65 	hz = hz - DIGBEEP_HZ_MIN
66 		+ DIGBEEP_HZ_STEP / 2; /* round to nearest step */
67 	if (hz < 0)
68 		hz = 0; /* turn off PC beep*/
69 	else if (hz >= (DIGBEEP_HZ_MAX - DIGBEEP_HZ_MIN))
70 		hz = 1; /* max frequency */
71 	else {
72 		hz /= DIGBEEP_HZ_STEP;
73 		hz = 255 - hz;
74 	}
75 	return hz;
76 }
77 
78 /* HD-audio standard beep tone parameter calculation
79  *
80  * The tone frequency in Hz is calculated as
81  *   freq = 48000 / (tone * 4)
82  * from 47Hz to 12kHz
83  */
beep_standard_tone(struct hda_beep * beep,int hz)84 static int beep_standard_tone(struct hda_beep *beep, int hz)
85 {
86 	if (hz <= 0)
87 		return 0; /* disabled */
88 	hz = 12000 / hz;
89 	if (hz > 0xff)
90 		return 0xff;
91 	if (hz <= 0)
92 		return 1;
93 	return hz;
94 }
95 
snd_hda_beep_event(struct input_dev * dev,unsigned int type,unsigned int code,int hz)96 static 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 		fallthrough;
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 	/* schedule beep event */
117 	schedule_work(&beep->beep_work);
118 	return 0;
119 }
120 
turn_on_beep(struct hda_beep * beep)121 static void turn_on_beep(struct hda_beep *beep)
122 {
123 	if (beep->keep_power_at_enable)
124 		snd_hda_power_up_pm(beep->codec);
125 }
126 
turn_off_beep(struct hda_beep * beep)127 static void turn_off_beep(struct hda_beep *beep)
128 {
129 	cancel_work_sync(&beep->beep_work);
130 	if (beep->playing) {
131 		/* turn off beep */
132 		generate_tone(beep, 0);
133 	}
134 	if (beep->keep_power_at_enable)
135 		snd_hda_power_down_pm(beep->codec);
136 }
137 
138 /**
139  * snd_hda_enable_beep_device - Turn on/off beep sound
140  * @codec: the HDA codec
141  * @enable: flag to turn on/off
142  */
snd_hda_enable_beep_device(struct hda_codec * codec,int enable)143 int snd_hda_enable_beep_device(struct hda_codec *codec, int enable)
144 {
145 	struct hda_beep *beep = codec->beep;
146 	if (!beep)
147 		return 0;
148 	enable = !!enable;
149 	if (beep->enabled != enable) {
150 		beep->enabled = enable;
151 		if (enable)
152 			turn_on_beep(beep);
153 		else
154 			turn_off_beep(beep);
155 		return 1;
156 	}
157 	return 0;
158 }
159 EXPORT_SYMBOL_GPL(snd_hda_enable_beep_device);
160 
beep_dev_register(struct snd_device * device)161 static int beep_dev_register(struct snd_device *device)
162 {
163 	struct hda_beep *beep = device->device_data;
164 	int err;
165 
166 	err = input_register_device(beep->dev);
167 	if (!err)
168 		beep->registered = true;
169 	return err;
170 }
171 
beep_dev_disconnect(struct snd_device * device)172 static int beep_dev_disconnect(struct snd_device *device)
173 {
174 	struct hda_beep *beep = device->device_data;
175 
176 	if (beep->registered)
177 		input_unregister_device(beep->dev);
178 	else
179 		input_free_device(beep->dev);
180 	if (beep->enabled)
181 		turn_off_beep(beep);
182 	return 0;
183 }
184 
beep_dev_free(struct snd_device * device)185 static int beep_dev_free(struct snd_device *device)
186 {
187 	struct hda_beep *beep = device->device_data;
188 
189 	beep->codec->beep = NULL;
190 	kfree(beep);
191 	return 0;
192 }
193 
194 /**
195  * snd_hda_attach_beep_device - Attach a beep input device
196  * @codec: the HDA codec
197  * @nid: beep NID
198  *
199  * Attach a beep object to the given widget.  If beep hint is turned off
200  * explicitly or beep_mode of the codec is turned off, this doesn't nothing.
201  *
202  * Currently, only one beep device is allowed to each codec.
203  */
snd_hda_attach_beep_device(struct hda_codec * codec,int nid)204 int snd_hda_attach_beep_device(struct hda_codec *codec, int nid)
205 {
206 	static const struct snd_device_ops ops = {
207 		.dev_register = beep_dev_register,
208 		.dev_disconnect = beep_dev_disconnect,
209 		.dev_free = beep_dev_free,
210 	};
211 	struct input_dev *input_dev;
212 	struct hda_beep *beep;
213 	int err;
214 
215 	if (!snd_hda_get_bool_hint(codec, "beep"))
216 		return 0; /* disabled explicitly by hints */
217 	if (codec->beep_mode == HDA_BEEP_MODE_OFF)
218 		return 0; /* disabled by module option */
219 
220 	beep = kzalloc(sizeof(*beep), GFP_KERNEL);
221 	if (beep == NULL)
222 		return -ENOMEM;
223 	snprintf(beep->phys, sizeof(beep->phys),
224 		"card%d/codec#%d/beep0", codec->card->number, codec->addr);
225 	/* enable linear scale */
226 	snd_hda_codec_write_cache(codec, nid, 0,
227 		AC_VERB_SET_DIGI_CONVERT_2, 0x01);
228 
229 	beep->nid = nid;
230 	beep->codec = codec;
231 	codec->beep = beep;
232 
233 	INIT_WORK(&beep->beep_work, &snd_hda_generate_beep);
234 
235 	input_dev = input_allocate_device();
236 	if (!input_dev) {
237 		err = -ENOMEM;
238 		goto err_free;
239 	}
240 
241 	/* setup digital beep device */
242 	input_dev->name = "HDA Digital PCBeep";
243 	input_dev->phys = beep->phys;
244 	input_dev->id.bustype = BUS_PCI;
245 	input_dev->dev.parent = &codec->card->card_dev;
246 
247 	input_dev->id.vendor = codec->core.vendor_id >> 16;
248 	input_dev->id.product = codec->core.vendor_id & 0xffff;
249 	input_dev->id.version = 0x01;
250 
251 	input_dev->evbit[0] = BIT_MASK(EV_SND);
252 	input_dev->sndbit[0] = BIT_MASK(SND_BELL) | BIT_MASK(SND_TONE);
253 	input_dev->event = snd_hda_beep_event;
254 	input_set_drvdata(input_dev, beep);
255 
256 	beep->dev = input_dev;
257 
258 	err = snd_device_new(codec->card, SNDRV_DEV_JACK, beep, &ops);
259 	if (err < 0)
260 		goto err_input;
261 
262 	return 0;
263 
264  err_input:
265 	input_free_device(beep->dev);
266  err_free:
267 	kfree(beep);
268 	codec->beep = NULL;
269 	return err;
270 }
271 EXPORT_SYMBOL_GPL(snd_hda_attach_beep_device);
272 
273 /**
274  * snd_hda_detach_beep_device - Detach the beep device
275  * @codec: the HDA codec
276  */
snd_hda_detach_beep_device(struct hda_codec * codec)277 void snd_hda_detach_beep_device(struct hda_codec *codec)
278 {
279 	if (!codec->bus->shutdown && codec->beep)
280 		snd_device_free(codec->card, codec->beep);
281 }
282 EXPORT_SYMBOL_GPL(snd_hda_detach_beep_device);
283 
ctl_has_mute(struct snd_kcontrol * kcontrol)284 static bool ctl_has_mute(struct snd_kcontrol *kcontrol)
285 {
286 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
287 	return query_amp_caps(codec, get_amp_nid(kcontrol),
288 			      get_amp_direction(kcontrol)) & AC_AMPCAP_MUTE;
289 }
290 
291 /* get/put callbacks for beep mute mixer switches */
292 
293 /**
294  * snd_hda_mixer_amp_switch_get_beep - Get callback for beep controls
295  * @kcontrol: ctl element
296  * @ucontrol: pointer to get/store the data
297  */
snd_hda_mixer_amp_switch_get_beep(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)298 int snd_hda_mixer_amp_switch_get_beep(struct snd_kcontrol *kcontrol,
299 				      struct snd_ctl_elem_value *ucontrol)
300 {
301 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
302 	struct hda_beep *beep = codec->beep;
303 	int chs = get_amp_channels(kcontrol);
304 
305 	if (beep && (!beep->enabled || !ctl_has_mute(kcontrol))) {
306 		if (chs & 1)
307 			ucontrol->value.integer.value[0] = beep->enabled;
308 		if (chs & 2)
309 			ucontrol->value.integer.value[1] = beep->enabled;
310 		return 0;
311 	}
312 	return snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
313 }
314 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_get_beep);
315 
316 /**
317  * snd_hda_mixer_amp_switch_put_beep - Put callback for beep controls
318  * @kcontrol: ctl element
319  * @ucontrol: pointer to get/store the data
320  */
snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)321 int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
322 				      struct snd_ctl_elem_value *ucontrol)
323 {
324 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
325 	struct hda_beep *beep = codec->beep;
326 	if (beep) {
327 		u8 chs = get_amp_channels(kcontrol);
328 		int enable = 0;
329 		long *valp = ucontrol->value.integer.value;
330 		if (chs & 1) {
331 			enable |= *valp;
332 			valp++;
333 		}
334 		if (chs & 2)
335 			enable |= *valp;
336 		snd_hda_enable_beep_device(codec, enable);
337 	}
338 	if (!ctl_has_mute(kcontrol))
339 		return 0;
340 	return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
341 }
342 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_put_beep);
343