~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/core/jack.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *  Jack abstraction layer
  3  *
  4  *  Copyright 2008 Wolfson Microelectronics
  5  *
  6  *   This program is free software; you can redistribute it and/or modify
  7  *   it under the terms of the GNU General Public License as published by
  8  *   the Free Software Foundation; either version 2 of the License, or
  9  *   (at your option) any later version.
 10  *
 11  *   This program is distributed in the hope that it will be useful,
 12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 14  *   GNU General Public License for more details.
 15  *
 16  *   You should have received a copy of the GNU General Public License
 17  *   along with this program; if not, write to the Free Software
 18  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 19  *
 20  */
 21 
 22 #include <linux/input.h>
 23 #include <linux/slab.h>
 24 #include <linux/module.h>
 25 #include <sound/jack.h>
 26 #include <sound/core.h>
 27 #include <sound/control.h>
 28 
 29 struct snd_jack_kctl {
 30         struct snd_kcontrol *kctl;
 31         struct list_head list;  /* list of controls belong to the same jack */
 32         unsigned int mask_bits; /* only masked status bits are reported via kctl */
 33 };
 34 
 35 #ifdef CONFIG_SND_JACK_INPUT_DEV
 36 static int jack_switch_types[SND_JACK_SWITCH_TYPES] = {
 37         SW_HEADPHONE_INSERT,
 38         SW_MICROPHONE_INSERT,
 39         SW_LINEOUT_INSERT,
 40         SW_JACK_PHYSICAL_INSERT,
 41         SW_VIDEOOUT_INSERT,
 42         SW_LINEIN_INSERT,
 43 };
 44 #endif /* CONFIG_SND_JACK_INPUT_DEV */
 45 
 46 static int snd_jack_dev_disconnect(struct snd_device *device)
 47 {
 48 #ifdef CONFIG_SND_JACK_INPUT_DEV
 49         struct snd_jack *jack = device->device_data;
 50 
 51         if (!jack->input_dev)
 52                 return 0;
 53 
 54         /* If the input device is registered with the input subsystem
 55          * then we need to use a different deallocator. */
 56         if (jack->registered)
 57                 input_unregister_device(jack->input_dev);
 58         else
 59                 input_free_device(jack->input_dev);
 60         jack->input_dev = NULL;
 61 #endif /* CONFIG_SND_JACK_INPUT_DEV */
 62         return 0;
 63 }
 64 
 65 static int snd_jack_dev_free(struct snd_device *device)
 66 {
 67         struct snd_jack *jack = device->device_data;
 68         struct snd_card *card = device->card;
 69         struct snd_jack_kctl *jack_kctl, *tmp_jack_kctl;
 70 
 71         list_for_each_entry_safe(jack_kctl, tmp_jack_kctl, &jack->kctl_list, list) {
 72                 list_del_init(&jack_kctl->list);
 73                 snd_ctl_remove(card, jack_kctl->kctl);
 74         }
 75         if (jack->private_free)
 76                 jack->private_free(jack);
 77 
 78         snd_jack_dev_disconnect(device);
 79 
 80         kfree(jack->id);
 81         kfree(jack);
 82 
 83         return 0;
 84 }
 85 
 86 #ifdef CONFIG_SND_JACK_INPUT_DEV
 87 static int snd_jack_dev_register(struct snd_device *device)
 88 {
 89         struct snd_jack *jack = device->device_data;
 90         struct snd_card *card = device->card;
 91         int err, i;
 92 
 93         snprintf(jack->name, sizeof(jack->name), "%s %s",
 94                  card->shortname, jack->id);
 95 
 96         if (!jack->input_dev)
 97                 return 0;
 98 
 99         jack->input_dev->name = jack->name;
100 
101         /* Default to the sound card device. */
102         if (!jack->input_dev->dev.parent)
103                 jack->input_dev->dev.parent = snd_card_get_device_link(card);
104 
105         /* Add capabilities for any keys that are enabled */
106         for (i = 0; i < ARRAY_SIZE(jack->key); i++) {
107                 int testbit = SND_JACK_BTN_0 >> i;
108 
109                 if (!(jack->type & testbit))
110                         continue;
111 
112                 if (!jack->key[i])
113                         jack->key[i] = BTN_0 + i;
114 
115                 input_set_capability(jack->input_dev, EV_KEY, jack->key[i]);
116         }
117 
118         err = input_register_device(jack->input_dev);
119         if (err == 0)
120                 jack->registered = 1;
121 
122         return err;
123 }
124 #endif /* CONFIG_SND_JACK_INPUT_DEV */
125 
126 static void snd_jack_kctl_private_free(struct snd_kcontrol *kctl)
127 {
128         struct snd_jack_kctl *jack_kctl;
129 
130         jack_kctl = kctl->private_data;
131         if (jack_kctl) {
132                 list_del(&jack_kctl->list);
133                 kfree(jack_kctl);
134         }
135 }
136 
137 static void snd_jack_kctl_add(struct snd_jack *jack, struct snd_jack_kctl *jack_kctl)
138 {
139         list_add_tail(&jack_kctl->list, &jack->kctl_list);
140 }
141 
142 static struct snd_jack_kctl * snd_jack_kctl_new(struct snd_card *card, const char *name, unsigned int mask)
143 {
144         struct snd_kcontrol *kctl;
145         struct snd_jack_kctl *jack_kctl;
146         int err;
147 
148         kctl = snd_kctl_jack_new(name, card);
149         if (!kctl)
150                 return NULL;
151 
152         err = snd_ctl_add(card, kctl);
153         if (err < 0)
154                 return NULL;
155 
156         jack_kctl = kzalloc(sizeof(*jack_kctl), GFP_KERNEL);
157 
158         if (!jack_kctl)
159                 goto error;
160 
161         jack_kctl->kctl = kctl;
162         jack_kctl->mask_bits = mask;
163 
164         kctl->private_data = jack_kctl;
165         kctl->private_free = snd_jack_kctl_private_free;
166 
167         return jack_kctl;
168 error:
169         snd_ctl_free_one(kctl);
170         return NULL;
171 }
172 
173 /**
174  * snd_jack_add_new_kctl - Create a new snd_jack_kctl and add it to jack
175  * @jack:  the jack instance which the kctl will attaching to
176  * @name:  the name for the snd_kcontrol object
177  * @mask:  a bitmask of enum snd_jack_type values that can be detected
178  *         by this snd_jack_kctl object.
179  *
180  * Creates a new snd_kcontrol object and adds it to the jack kctl_list.
181  *
182  * Return: Zero if successful, or a negative error code on failure.
183  */
184 int snd_jack_add_new_kctl(struct snd_jack *jack, const char * name, int mask)
185 {
186         struct snd_jack_kctl *jack_kctl;
187 
188         jack_kctl = snd_jack_kctl_new(jack->card, name, mask);
189         if (!jack_kctl)
190                 return -ENOMEM;
191 
192         snd_jack_kctl_add(jack, jack_kctl);
193         return 0;
194 }
195 EXPORT_SYMBOL(snd_jack_add_new_kctl);
196 
197 /**
198  * snd_jack_new - Create a new jack
199  * @card:  the card instance
200  * @id:    an identifying string for this jack
201  * @type:  a bitmask of enum snd_jack_type values that can be detected by
202  *         this jack
203  * @jjack: Used to provide the allocated jack object to the caller.
204  * @initial_kctl: if true, create a kcontrol and add it to the jack list.
205  * @phantom_jack: Don't create a input device for phantom jacks.
206  *
207  * Creates a new jack object.
208  *
209  * Return: Zero if successful, or a negative error code on failure.
210  * On success @jjack will be initialised.
211  */
212 int snd_jack_new(struct snd_card *card, const char *id, int type,
213                  struct snd_jack **jjack, bool initial_kctl, bool phantom_jack)
214 {
215         struct snd_jack *jack;
216         struct snd_jack_kctl *jack_kctl = NULL;
217         int err;
218         static struct snd_device_ops ops = {
219                 .dev_free = snd_jack_dev_free,
220 #ifdef CONFIG_SND_JACK_INPUT_DEV
221                 .dev_register = snd_jack_dev_register,
222                 .dev_disconnect = snd_jack_dev_disconnect,
223 #endif /* CONFIG_SND_JACK_INPUT_DEV */
224         };
225 
226         if (initial_kctl) {
227                 jack_kctl = snd_jack_kctl_new(card, id, type);
228                 if (!jack_kctl)
229                         return -ENOMEM;
230         }
231 
232         jack = kzalloc(sizeof(struct snd_jack), GFP_KERNEL);
233         if (jack == NULL)
234                 return -ENOMEM;
235 
236         jack->id = kstrdup(id, GFP_KERNEL);
237 
238         /* don't creat input device for phantom jack */
239         if (!phantom_jack) {
240 #ifdef CONFIG_SND_JACK_INPUT_DEV
241                 int i;
242 
243                 jack->input_dev = input_allocate_device();
244                 if (jack->input_dev == NULL) {
245                         err = -ENOMEM;
246                         goto fail_input;
247                 }
248 
249                 jack->input_dev->phys = "ALSA";
250 
251                 jack->type = type;
252 
253                 for (i = 0; i < SND_JACK_SWITCH_TYPES; i++)
254                         if (type & (1 << i))
255                                 input_set_capability(jack->input_dev, EV_SW,
256                                                      jack_switch_types[i]);
257 
258 #endif /* CONFIG_SND_JACK_INPUT_DEV */
259         }
260 
261         err = snd_device_new(card, SNDRV_DEV_JACK, jack, &ops);
262         if (err < 0)
263                 goto fail_input;
264 
265         jack->card = card;
266         INIT_LIST_HEAD(&jack->kctl_list);
267 
268         if (initial_kctl)
269                 snd_jack_kctl_add(jack, jack_kctl);
270 
271         *jjack = jack;
272 
273         return 0;
274 
275 fail_input:
276 #ifdef CONFIG_SND_JACK_INPUT_DEV
277         input_free_device(jack->input_dev);
278 #endif
279         kfree(jack->id);
280         kfree(jack);
281         return err;
282 }
283 EXPORT_SYMBOL(snd_jack_new);
284 
285 #ifdef CONFIG_SND_JACK_INPUT_DEV
286 /**
287  * snd_jack_set_parent - Set the parent device for a jack
288  *
289  * @jack:   The jack to configure
290  * @parent: The device to set as parent for the jack.
291  *
292  * Set the parent for the jack devices in the device tree.  This
293  * function is only valid prior to registration of the jack.  If no
294  * parent is configured then the parent device will be the sound card.
295  */
296 void snd_jack_set_parent(struct snd_jack *jack, struct device *parent)
297 {
298         WARN_ON(jack->registered);
299         if (!jack->input_dev)
300                 return;
301 
302         jack->input_dev->dev.parent = parent;
303 }
304 EXPORT_SYMBOL(snd_jack_set_parent);
305 
306 /**
307  * snd_jack_set_key - Set a key mapping on a jack
308  *
309  * @jack:    The jack to configure
310  * @type:    Jack report type for this key
311  * @keytype: Input layer key type to be reported
312  *
313  * Map a SND_JACK_BTN_ button type to an input layer key, allowing
314  * reporting of keys on accessories via the jack abstraction.  If no
315  * mapping is provided but keys are enabled in the jack type then
316  * BTN_n numeric buttons will be reported.
317  *
318  * If jacks are not reporting via the input API this call will have no
319  * effect.
320  *
321  * Note that this is intended to be use by simple devices with small
322  * numbers of keys that can be reported.  It is also possible to
323  * access the input device directly - devices with complex input
324  * capabilities on accessories should consider doing this rather than
325  * using this abstraction.
326  *
327  * This function may only be called prior to registration of the jack.
328  *
329  * Return: Zero if successful, or a negative error code on failure.
330  */
331 int snd_jack_set_key(struct snd_jack *jack, enum snd_jack_types type,
332                      int keytype)
333 {
334         int key = fls(SND_JACK_BTN_0) - fls(type);
335 
336         WARN_ON(jack->registered);
337 
338         if (!keytype || key >= ARRAY_SIZE(jack->key))
339                 return -EINVAL;
340 
341         jack->type |= type;
342         jack->key[key] = keytype;
343         return 0;
344 }
345 EXPORT_SYMBOL(snd_jack_set_key);
346 #endif /* CONFIG_SND_JACK_INPUT_DEV */
347 
348 /**
349  * snd_jack_report - Report the current status of a jack
350  *
351  * @jack:   The jack to report status for
352  * @status: The current status of the jack
353  */
354 void snd_jack_report(struct snd_jack *jack, int status)
355 {
356         struct snd_jack_kctl *jack_kctl;
357 #ifdef CONFIG_SND_JACK_INPUT_DEV
358         int i;
359 #endif
360 
361         if (!jack)
362                 return;
363 
364         list_for_each_entry(jack_kctl, &jack->kctl_list, list)
365                 snd_kctl_jack_report(jack->card, jack_kctl->kctl,
366                                             status & jack_kctl->mask_bits);
367 
368 #ifdef CONFIG_SND_JACK_INPUT_DEV
369         if (!jack->input_dev)
370                 return;
371 
372         for (i = 0; i < ARRAY_SIZE(jack->key); i++) {
373                 int testbit = SND_JACK_BTN_0 >> i;
374 
375                 if (jack->type & testbit)
376                         input_report_key(jack->input_dev, jack->key[i],
377                                          status & testbit);
378         }
379 
380         for (i = 0; i < ARRAY_SIZE(jack_switch_types); i++) {
381                 int testbit = 1 << i;
382                 if (jack->type & testbit)
383                         input_report_switch(jack->input_dev,
384                                             jack_switch_types[i],
385                                             status & testbit);
386         }
387 
388         input_sync(jack->input_dev);
389 #endif /* CONFIG_SND_JACK_INPUT_DEV */
390 }
391 EXPORT_SYMBOL(snd_jack_report);
392 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp