Merge branch 'uaccess' into fixes
[sfrench/cifs-2.6.git] / sound / pci / hda / hda_beep.c
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 */
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
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  */
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  */
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
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                 /* fallthru */
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
121 static void turn_off_beep(struct hda_beep *beep)
122 {
123         cancel_work_sync(&beep->beep_work);
124         if (beep->playing) {
125                 /* turn off beep */
126                 generate_tone(beep, 0);
127         }
128 }
129
130 /**
131  * snd_hda_enable_beep_device - Turn on/off beep sound
132  * @codec: the HDA codec
133  * @enable: flag to turn on/off
134  */
135 int snd_hda_enable_beep_device(struct hda_codec *codec, int enable)
136 {
137         struct hda_beep *beep = codec->beep;
138         if (!beep)
139                 return 0;
140         enable = !!enable;
141         if (beep->enabled != enable) {
142                 beep->enabled = enable;
143                 if (!enable)
144                         turn_off_beep(beep);
145                 return 1;
146         }
147         return 0;
148 }
149 EXPORT_SYMBOL_GPL(snd_hda_enable_beep_device);
150
151 static int beep_dev_register(struct snd_device *device)
152 {
153         struct hda_beep *beep = device->device_data;
154         int err;
155
156         err = input_register_device(beep->dev);
157         if (!err)
158                 beep->registered = true;
159         return err;
160 }
161
162 static int beep_dev_disconnect(struct snd_device *device)
163 {
164         struct hda_beep *beep = device->device_data;
165
166         if (beep->registered)
167                 input_unregister_device(beep->dev);
168         else
169                 input_free_device(beep->dev);
170         turn_off_beep(beep);
171         return 0;
172 }
173
174 static int beep_dev_free(struct snd_device *device)
175 {
176         struct hda_beep *beep = device->device_data;
177
178         beep->codec->beep = NULL;
179         kfree(beep);
180         return 0;
181 }
182
183 /**
184  * snd_hda_attach_beep_device - Attach a beep input device
185  * @codec: the HDA codec
186  * @nid: beep NID
187  *
188  * Attach a beep object to the given widget.  If beep hint is turned off
189  * explicitly or beep_mode of the codec is turned off, this doesn't nothing.
190  *
191  * Currently, only one beep device is allowed to each codec.
192  */
193 int snd_hda_attach_beep_device(struct hda_codec *codec, int nid)
194 {
195         static const struct snd_device_ops ops = {
196                 .dev_register = beep_dev_register,
197                 .dev_disconnect = beep_dev_disconnect,
198                 .dev_free = beep_dev_free,
199         };
200         struct input_dev *input_dev;
201         struct hda_beep *beep;
202         int err;
203
204         if (!snd_hda_get_bool_hint(codec, "beep"))
205                 return 0; /* disabled explicitly by hints */
206         if (codec->beep_mode == HDA_BEEP_MODE_OFF)
207                 return 0; /* disabled by module option */
208
209         beep = kzalloc(sizeof(*beep), GFP_KERNEL);
210         if (beep == NULL)
211                 return -ENOMEM;
212         snprintf(beep->phys, sizeof(beep->phys),
213                 "card%d/codec#%d/beep0", codec->card->number, codec->addr);
214         /* enable linear scale */
215         snd_hda_codec_write_cache(codec, nid, 0,
216                 AC_VERB_SET_DIGI_CONVERT_2, 0x01);
217
218         beep->nid = nid;
219         beep->codec = codec;
220         codec->beep = beep;
221
222         INIT_WORK(&beep->beep_work, &snd_hda_generate_beep);
223         mutex_init(&beep->mutex);
224
225         input_dev = input_allocate_device();
226         if (!input_dev) {
227                 err = -ENOMEM;
228                 goto err_free;
229         }
230
231         /* setup digital beep device */
232         input_dev->name = "HDA Digital PCBeep";
233         input_dev->phys = beep->phys;
234         input_dev->id.bustype = BUS_PCI;
235         input_dev->dev.parent = &codec->card->card_dev;
236
237         input_dev->id.vendor = codec->core.vendor_id >> 16;
238         input_dev->id.product = codec->core.vendor_id & 0xffff;
239         input_dev->id.version = 0x01;
240
241         input_dev->evbit[0] = BIT_MASK(EV_SND);
242         input_dev->sndbit[0] = BIT_MASK(SND_BELL) | BIT_MASK(SND_TONE);
243         input_dev->event = snd_hda_beep_event;
244         input_set_drvdata(input_dev, beep);
245
246         beep->dev = input_dev;
247
248         err = snd_device_new(codec->card, SNDRV_DEV_JACK, beep, &ops);
249         if (err < 0)
250                 goto err_input;
251
252         return 0;
253
254  err_input:
255         input_free_device(beep->dev);
256  err_free:
257         kfree(beep);
258         codec->beep = NULL;
259         return err;
260 }
261 EXPORT_SYMBOL_GPL(snd_hda_attach_beep_device);
262
263 /**
264  * snd_hda_detach_beep_device - Detach the beep device
265  * @codec: the HDA codec
266  */
267 void snd_hda_detach_beep_device(struct hda_codec *codec)
268 {
269         if (!codec->bus->shutdown && codec->beep)
270                 snd_device_free(codec->card, codec->beep);
271 }
272 EXPORT_SYMBOL_GPL(snd_hda_detach_beep_device);
273
274 static bool ctl_has_mute(struct snd_kcontrol *kcontrol)
275 {
276         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
277         return query_amp_caps(codec, get_amp_nid(kcontrol),
278                               get_amp_direction(kcontrol)) & AC_AMPCAP_MUTE;
279 }
280
281 /* get/put callbacks for beep mute mixer switches */
282
283 /**
284  * snd_hda_mixer_amp_switch_get_beep - Get callback for beep controls
285  * @kcontrol: ctl element
286  * @ucontrol: pointer to get/store the data
287  */
288 int snd_hda_mixer_amp_switch_get_beep(struct snd_kcontrol *kcontrol,
289                                       struct snd_ctl_elem_value *ucontrol)
290 {
291         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
292         struct hda_beep *beep = codec->beep;
293         int chs = get_amp_channels(kcontrol);
294
295         if (beep && (!beep->enabled || !ctl_has_mute(kcontrol))) {
296                 if (chs & 1)
297                         ucontrol->value.integer.value[0] = beep->enabled;
298                 if (chs & 2)
299                         ucontrol->value.integer.value[1] = beep->enabled;
300                 return 0;
301         }
302         return snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
303 }
304 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_get_beep);
305
306 /**
307  * snd_hda_mixer_amp_switch_put_beep - Put callback for beep controls
308  * @kcontrol: ctl element
309  * @ucontrol: pointer to get/store the data
310  */
311 int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
312                                       struct snd_ctl_elem_value *ucontrol)
313 {
314         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
315         struct hda_beep *beep = codec->beep;
316         if (beep) {
317                 u8 chs = get_amp_channels(kcontrol);
318                 int enable = 0;
319                 long *valp = ucontrol->value.integer.value;
320                 if (chs & 1) {
321                         enable |= *valp;
322                         valp++;
323                 }
324                 if (chs & 2)
325                         enable |= *valp;
326                 snd_hda_enable_beep_device(codec, enable);
327         }
328         if (!ctl_has_mute(kcontrol))
329                 return 0;
330         return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
331 }
332 EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_put_beep);