2 * Jack abstraction layer
4 * Copyright 2008 Wolfson Microelectronics
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.
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.
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
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>
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 */
35 #ifdef CONFIG_SND_JACK_INPUT_DEV
36 static int jack_switch_types[SND_JACK_SWITCH_TYPES] = {
40 SW_JACK_PHYSICAL_INSERT,
44 #endif /* CONFIG_SND_JACK_INPUT_DEV */
46 static int snd_jack_dev_disconnect(struct snd_device *device)
48 #ifdef CONFIG_SND_JACK_INPUT_DEV
49 struct snd_jack *jack = device->device_data;
54 /* If the input device is registered with the input subsystem
55 * then we need to use a different deallocator. */
57 input_unregister_device(jack->input_dev);
59 input_free_device(jack->input_dev);
60 jack->input_dev = NULL;
61 #endif /* CONFIG_SND_JACK_INPUT_DEV */
65 static int snd_jack_dev_free(struct snd_device *device)
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;
71 down_write(&card->controls_rwsem);
72 list_for_each_entry_safe(jack_kctl, tmp_jack_kctl, &jack->kctl_list, list) {
73 list_del_init(&jack_kctl->list);
74 snd_ctl_remove(card, jack_kctl->kctl);
76 up_write(&card->controls_rwsem);
78 if (jack->private_free)
79 jack->private_free(jack);
81 snd_jack_dev_disconnect(device);
89 #ifdef CONFIG_SND_JACK_INPUT_DEV
90 static int snd_jack_dev_register(struct snd_device *device)
92 struct snd_jack *jack = device->device_data;
93 struct snd_card *card = device->card;
96 snprintf(jack->name, sizeof(jack->name), "%s %s",
97 card->shortname, jack->id);
102 jack->input_dev->name = jack->name;
104 /* Default to the sound card device. */
105 if (!jack->input_dev->dev.parent)
106 jack->input_dev->dev.parent = snd_card_get_device_link(card);
108 /* Add capabilities for any keys that are enabled */
109 for (i = 0; i < ARRAY_SIZE(jack->key); i++) {
110 int testbit = SND_JACK_BTN_0 >> i;
112 if (!(jack->type & testbit))
116 jack->key[i] = BTN_0 + i;
118 input_set_capability(jack->input_dev, EV_KEY, jack->key[i]);
121 err = input_register_device(jack->input_dev);
123 jack->registered = 1;
127 #endif /* CONFIG_SND_JACK_INPUT_DEV */
129 static void snd_jack_kctl_private_free(struct snd_kcontrol *kctl)
131 struct snd_jack_kctl *jack_kctl;
133 jack_kctl = kctl->private_data;
135 list_del(&jack_kctl->list);
140 static void snd_jack_kctl_add(struct snd_jack *jack, struct snd_jack_kctl *jack_kctl)
142 list_add_tail(&jack_kctl->list, &jack->kctl_list);
145 static struct snd_jack_kctl * snd_jack_kctl_new(struct snd_card *card, const char *name, unsigned int mask)
147 struct snd_kcontrol *kctl;
148 struct snd_jack_kctl *jack_kctl;
151 kctl = snd_kctl_jack_new(name, card);
155 err = snd_ctl_add(card, kctl);
159 jack_kctl = kzalloc(sizeof(*jack_kctl), GFP_KERNEL);
164 jack_kctl->kctl = kctl;
165 jack_kctl->mask_bits = mask;
167 kctl->private_data = jack_kctl;
168 kctl->private_free = snd_jack_kctl_private_free;
172 snd_ctl_free_one(kctl);
177 * snd_jack_add_new_kctl - Create a new snd_jack_kctl and add it to jack
178 * @jack: the jack instance which the kctl will attaching to
179 * @name: the name for the snd_kcontrol object
180 * @mask: a bitmask of enum snd_jack_type values that can be detected
181 * by this snd_jack_kctl object.
183 * Creates a new snd_kcontrol object and adds it to the jack kctl_list.
185 * Return: Zero if successful, or a negative error code on failure.
187 int snd_jack_add_new_kctl(struct snd_jack *jack, const char * name, int mask)
189 struct snd_jack_kctl *jack_kctl;
191 jack_kctl = snd_jack_kctl_new(jack->card, name, mask);
195 snd_jack_kctl_add(jack, jack_kctl);
198 EXPORT_SYMBOL(snd_jack_add_new_kctl);
201 * snd_jack_new - Create a new jack
202 * @card: the card instance
203 * @id: an identifying string for this jack
204 * @type: a bitmask of enum snd_jack_type values that can be detected by
206 * @jjack: Used to provide the allocated jack object to the caller.
207 * @initial_kctl: if true, create a kcontrol and add it to the jack list.
208 * @phantom_jack: Don't create a input device for phantom jacks.
210 * Creates a new jack object.
212 * Return: Zero if successful, or a negative error code on failure.
213 * On success @jjack will be initialised.
215 int snd_jack_new(struct snd_card *card, const char *id, int type,
216 struct snd_jack **jjack, bool initial_kctl, bool phantom_jack)
218 struct snd_jack *jack;
219 struct snd_jack_kctl *jack_kctl = NULL;
221 static struct snd_device_ops ops = {
222 .dev_free = snd_jack_dev_free,
223 #ifdef CONFIG_SND_JACK_INPUT_DEV
224 .dev_register = snd_jack_dev_register,
225 .dev_disconnect = snd_jack_dev_disconnect,
226 #endif /* CONFIG_SND_JACK_INPUT_DEV */
230 jack_kctl = snd_jack_kctl_new(card, id, type);
235 jack = kzalloc(sizeof(struct snd_jack), GFP_KERNEL);
239 jack->id = kstrdup(id, GFP_KERNEL);
240 if (jack->id == NULL) {
245 /* don't creat input device for phantom jack */
247 #ifdef CONFIG_SND_JACK_INPUT_DEV
250 jack->input_dev = input_allocate_device();
251 if (jack->input_dev == NULL) {
256 jack->input_dev->phys = "ALSA";
260 for (i = 0; i < SND_JACK_SWITCH_TYPES; i++)
262 input_set_capability(jack->input_dev, EV_SW,
263 jack_switch_types[i]);
265 #endif /* CONFIG_SND_JACK_INPUT_DEV */
268 err = snd_device_new(card, SNDRV_DEV_JACK, jack, &ops);
273 INIT_LIST_HEAD(&jack->kctl_list);
276 snd_jack_kctl_add(jack, jack_kctl);
283 #ifdef CONFIG_SND_JACK_INPUT_DEV
284 input_free_device(jack->input_dev);
290 EXPORT_SYMBOL(snd_jack_new);
292 #ifdef CONFIG_SND_JACK_INPUT_DEV
294 * snd_jack_set_parent - Set the parent device for a jack
296 * @jack: The jack to configure
297 * @parent: The device to set as parent for the jack.
299 * Set the parent for the jack devices in the device tree. This
300 * function is only valid prior to registration of the jack. If no
301 * parent is configured then the parent device will be the sound card.
303 void snd_jack_set_parent(struct snd_jack *jack, struct device *parent)
305 WARN_ON(jack->registered);
306 if (!jack->input_dev)
309 jack->input_dev->dev.parent = parent;
311 EXPORT_SYMBOL(snd_jack_set_parent);
314 * snd_jack_set_key - Set a key mapping on a jack
316 * @jack: The jack to configure
317 * @type: Jack report type for this key
318 * @keytype: Input layer key type to be reported
320 * Map a SND_JACK_BTN_ button type to an input layer key, allowing
321 * reporting of keys on accessories via the jack abstraction. If no
322 * mapping is provided but keys are enabled in the jack type then
323 * BTN_n numeric buttons will be reported.
325 * If jacks are not reporting via the input API this call will have no
328 * Note that this is intended to be use by simple devices with small
329 * numbers of keys that can be reported. It is also possible to
330 * access the input device directly - devices with complex input
331 * capabilities on accessories should consider doing this rather than
332 * using this abstraction.
334 * This function may only be called prior to registration of the jack.
336 * Return: Zero if successful, or a negative error code on failure.
338 int snd_jack_set_key(struct snd_jack *jack, enum snd_jack_types type,
341 int key = fls(SND_JACK_BTN_0) - fls(type);
343 WARN_ON(jack->registered);
345 if (!keytype || key >= ARRAY_SIZE(jack->key))
349 jack->key[key] = keytype;
352 EXPORT_SYMBOL(snd_jack_set_key);
353 #endif /* CONFIG_SND_JACK_INPUT_DEV */
356 * snd_jack_report - Report the current status of a jack
358 * @jack: The jack to report status for
359 * @status: The current status of the jack
361 void snd_jack_report(struct snd_jack *jack, int status)
363 struct snd_jack_kctl *jack_kctl;
364 #ifdef CONFIG_SND_JACK_INPUT_DEV
371 list_for_each_entry(jack_kctl, &jack->kctl_list, list)
372 snd_kctl_jack_report(jack->card, jack_kctl->kctl,
373 status & jack_kctl->mask_bits);
375 #ifdef CONFIG_SND_JACK_INPUT_DEV
376 if (!jack->input_dev)
379 for (i = 0; i < ARRAY_SIZE(jack->key); i++) {
380 int testbit = SND_JACK_BTN_0 >> i;
382 if (jack->type & testbit)
383 input_report_key(jack->input_dev, jack->key[i],
387 for (i = 0; i < ARRAY_SIZE(jack_switch_types); i++) {
388 int testbit = 1 << i;
389 if (jack->type & testbit)
390 input_report_switch(jack->input_dev,
391 jack_switch_types[i],
395 input_sync(jack->input_dev);
396 #endif /* CONFIG_SND_JACK_INPUT_DEV */
398 EXPORT_SYMBOL(snd_jack_report);