Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Jack abstraction layer
4 *
5 * Copyright 2008 Wolfson Microelectronics
6 */
7
8#include <linux/input.h>
9#include <linux/slab.h>
10#include <linux/module.h>
11#include <sound/jack.h>
12#include <sound/core.h>
13#include <sound/control.h>
14
15struct snd_jack_kctl {
16 struct snd_kcontrol *kctl;
17 struct list_head list; /* list of controls belong to the same jack */
18 unsigned int mask_bits; /* only masked status bits are reported via kctl */
19};
20
21#ifdef CONFIG_SND_JACK_INPUT_DEV
22static const int jack_switch_types[SND_JACK_SWITCH_TYPES] = {
23 SW_HEADPHONE_INSERT,
24 SW_MICROPHONE_INSERT,
25 SW_LINEOUT_INSERT,
26 SW_JACK_PHYSICAL_INSERT,
27 SW_VIDEOOUT_INSERT,
28 SW_LINEIN_INSERT,
29};
30#endif /* CONFIG_SND_JACK_INPUT_DEV */
31
32static int snd_jack_dev_disconnect(struct snd_device *device)
33{
34#ifdef CONFIG_SND_JACK_INPUT_DEV
35 struct snd_jack *jack = device->device_data;
36
37 if (!jack->input_dev)
38 return 0;
39
40 /* If the input device is registered with the input subsystem
41 * then we need to use a different deallocator. */
42 if (jack->registered)
43 input_unregister_device(jack->input_dev);
44 else
45 input_free_device(jack->input_dev);
46 jack->input_dev = NULL;
47#endif /* CONFIG_SND_JACK_INPUT_DEV */
48 return 0;
49}
50
51static int snd_jack_dev_free(struct snd_device *device)
52{
53 struct snd_jack *jack = device->device_data;
54 struct snd_card *card = device->card;
55 struct snd_jack_kctl *jack_kctl, *tmp_jack_kctl;
56
57 list_for_each_entry_safe(jack_kctl, tmp_jack_kctl, &jack->kctl_list, list) {
58 list_del_init(&jack_kctl->list);
59 snd_ctl_remove(card, jack_kctl->kctl);
60 }
61 if (jack->private_free)
62 jack->private_free(jack);
63
64 snd_jack_dev_disconnect(device);
65
66 kfree(jack->id);
67 kfree(jack);
68
69 return 0;
70}
71
72#ifdef CONFIG_SND_JACK_INPUT_DEV
73static int snd_jack_dev_register(struct snd_device *device)
74{
75 struct snd_jack *jack = device->device_data;
76 struct snd_card *card = device->card;
77 int err, i;
78
79 snprintf(jack->name, sizeof(jack->name), "%s %s",
80 card->shortname, jack->id);
81
82 if (!jack->input_dev)
83 return 0;
84
85 jack->input_dev->name = jack->name;
86
87 /* Default to the sound card device. */
88 if (!jack->input_dev->dev.parent)
89 jack->input_dev->dev.parent = snd_card_get_device_link(card);
90
91 /* Add capabilities for any keys that are enabled */
92 for (i = 0; i < ARRAY_SIZE(jack->key); i++) {
93 int testbit = SND_JACK_BTN_0 >> i;
94
95 if (!(jack->type & testbit))
96 continue;
97
98 if (!jack->key[i])
99 jack->key[i] = BTN_0 + i;
100
101 input_set_capability(jack->input_dev, EV_KEY, jack->key[i]);
102 }
103
104 err = input_register_device(jack->input_dev);
105 if (err == 0)
106 jack->registered = 1;
107
108 return err;
109}
110#endif /* CONFIG_SND_JACK_INPUT_DEV */
111
112static void snd_jack_kctl_private_free(struct snd_kcontrol *kctl)
113{
114 struct snd_jack_kctl *jack_kctl;
115
116 jack_kctl = kctl->private_data;
117 if (jack_kctl) {
118 list_del(&jack_kctl->list);
119 kfree(jack_kctl);
120 }
121}
122
123static void snd_jack_kctl_add(struct snd_jack *jack, struct snd_jack_kctl *jack_kctl)
124{
125 list_add_tail(&jack_kctl->list, &jack->kctl_list);
126}
127
128static struct snd_jack_kctl * snd_jack_kctl_new(struct snd_card *card, const char *name, unsigned int mask)
129{
130 struct snd_kcontrol *kctl;
131 struct snd_jack_kctl *jack_kctl;
132 int err;
133
134 kctl = snd_kctl_jack_new(name, card);
135 if (!kctl)
136 return NULL;
137
138 err = snd_ctl_add(card, kctl);
139 if (err < 0)
140 return NULL;
141
142 jack_kctl = kzalloc(sizeof(*jack_kctl), GFP_KERNEL);
143
144 if (!jack_kctl)
145 goto error;
146
147 jack_kctl->kctl = kctl;
148 jack_kctl->mask_bits = mask;
149
150 kctl->private_data = jack_kctl;
151 kctl->private_free = snd_jack_kctl_private_free;
152
153 return jack_kctl;
154error:
155 snd_ctl_free_one(kctl);
156 return NULL;
157}
158
159/**
160 * snd_jack_add_new_kctl - Create a new snd_jack_kctl and add it to jack
161 * @jack: the jack instance which the kctl will attaching to
162 * @name: the name for the snd_kcontrol object
163 * @mask: a bitmask of enum snd_jack_type values that can be detected
164 * by this snd_jack_kctl object.
165 *
166 * Creates a new snd_kcontrol object and adds it to the jack kctl_list.
167 *
168 * Return: Zero if successful, or a negative error code on failure.
169 */
170int snd_jack_add_new_kctl(struct snd_jack *jack, const char * name, int mask)
171{
172 struct snd_jack_kctl *jack_kctl;
173
174 jack_kctl = snd_jack_kctl_new(jack->card, name, mask);
175 if (!jack_kctl)
176 return -ENOMEM;
177
178 snd_jack_kctl_add(jack, jack_kctl);
179 return 0;
180}
181EXPORT_SYMBOL(snd_jack_add_new_kctl);
182
183/**
184 * snd_jack_new - Create a new jack
185 * @card: the card instance
186 * @id: an identifying string for this jack
187 * @type: a bitmask of enum snd_jack_type values that can be detected by
188 * this jack
189 * @jjack: Used to provide the allocated jack object to the caller.
190 * @initial_kctl: if true, create a kcontrol and add it to the jack list.
191 * @phantom_jack: Don't create a input device for phantom jacks.
192 *
193 * Creates a new jack object.
194 *
195 * Return: Zero if successful, or a negative error code on failure.
196 * On success @jjack will be initialised.
197 */
198int snd_jack_new(struct snd_card *card, const char *id, int type,
199 struct snd_jack **jjack, bool initial_kctl, bool phantom_jack)
200{
201 struct snd_jack *jack;
202 struct snd_jack_kctl *jack_kctl = NULL;
203 int err;
204 static const struct snd_device_ops ops = {
205 .dev_free = snd_jack_dev_free,
206#ifdef CONFIG_SND_JACK_INPUT_DEV
207 .dev_register = snd_jack_dev_register,
208 .dev_disconnect = snd_jack_dev_disconnect,
209#endif /* CONFIG_SND_JACK_INPUT_DEV */
210 };
211
212 if (initial_kctl) {
213 jack_kctl = snd_jack_kctl_new(card, id, type);
214 if (!jack_kctl)
215 return -ENOMEM;
216 }
217
218 jack = kzalloc(sizeof(struct snd_jack), GFP_KERNEL);
219 if (jack == NULL)
220 return -ENOMEM;
221
222 jack->id = kstrdup(id, GFP_KERNEL);
223
224 /* don't creat input device for phantom jack */
225 if (!phantom_jack) {
226#ifdef CONFIG_SND_JACK_INPUT_DEV
227 int i;
228
229 jack->input_dev = input_allocate_device();
230 if (jack->input_dev == NULL) {
231 err = -ENOMEM;
232 goto fail_input;
233 }
234
235 jack->input_dev->phys = "ALSA";
236
237 jack->type = type;
238
239 for (i = 0; i < SND_JACK_SWITCH_TYPES; i++)
240 if (type & (1 << i))
241 input_set_capability(jack->input_dev, EV_SW,
242 jack_switch_types[i]);
243
244#endif /* CONFIG_SND_JACK_INPUT_DEV */
245 }
246
247 err = snd_device_new(card, SNDRV_DEV_JACK, jack, &ops);
248 if (err < 0)
249 goto fail_input;
250
251 jack->card = card;
252 INIT_LIST_HEAD(&jack->kctl_list);
253
254 if (initial_kctl)
255 snd_jack_kctl_add(jack, jack_kctl);
256
257 *jjack = jack;
258
259 return 0;
260
261fail_input:
262#ifdef CONFIG_SND_JACK_INPUT_DEV
263 input_free_device(jack->input_dev);
264#endif
265 kfree(jack->id);
266 kfree(jack);
267 return err;
268}
269EXPORT_SYMBOL(snd_jack_new);
270
271#ifdef CONFIG_SND_JACK_INPUT_DEV
272/**
273 * snd_jack_set_parent - Set the parent device for a jack
274 *
275 * @jack: The jack to configure
276 * @parent: The device to set as parent for the jack.
277 *
278 * Set the parent for the jack devices in the device tree. This
279 * function is only valid prior to registration of the jack. If no
280 * parent is configured then the parent device will be the sound card.
281 */
282void snd_jack_set_parent(struct snd_jack *jack, struct device *parent)
283{
284 WARN_ON(jack->registered);
285 if (!jack->input_dev)
286 return;
287
288 jack->input_dev->dev.parent = parent;
289}
290EXPORT_SYMBOL(snd_jack_set_parent);
291
292/**
293 * snd_jack_set_key - Set a key mapping on a jack
294 *
295 * @jack: The jack to configure
296 * @type: Jack report type for this key
297 * @keytype: Input layer key type to be reported
298 *
299 * Map a SND_JACK_BTN_* button type to an input layer key, allowing
300 * reporting of keys on accessories via the jack abstraction. If no
301 * mapping is provided but keys are enabled in the jack type then
302 * BTN_n numeric buttons will be reported.
303 *
304 * If jacks are not reporting via the input API this call will have no
305 * effect.
306 *
307 * Note that this is intended to be use by simple devices with small
308 * numbers of keys that can be reported. It is also possible to
309 * access the input device directly - devices with complex input
310 * capabilities on accessories should consider doing this rather than
311 * using this abstraction.
312 *
313 * This function may only be called prior to registration of the jack.
314 *
315 * Return: Zero if successful, or a negative error code on failure.
316 */
317int snd_jack_set_key(struct snd_jack *jack, enum snd_jack_types type,
318 int keytype)
319{
320 int key = fls(SND_JACK_BTN_0) - fls(type);
321
322 WARN_ON(jack->registered);
323
324 if (!keytype || key >= ARRAY_SIZE(jack->key))
325 return -EINVAL;
326
327 jack->type |= type;
328 jack->key[key] = keytype;
329 return 0;
330}
331EXPORT_SYMBOL(snd_jack_set_key);
332#endif /* CONFIG_SND_JACK_INPUT_DEV */
333
334/**
335 * snd_jack_report - Report the current status of a jack
336 *
337 * @jack: The jack to report status for
338 * @status: The current status of the jack
339 */
340void snd_jack_report(struct snd_jack *jack, int status)
341{
342 struct snd_jack_kctl *jack_kctl;
343#ifdef CONFIG_SND_JACK_INPUT_DEV
344 int i;
345#endif
346
347 if (!jack)
348 return;
349
350 list_for_each_entry(jack_kctl, &jack->kctl_list, list)
351 snd_kctl_jack_report(jack->card, jack_kctl->kctl,
352 status & jack_kctl->mask_bits);
353
354#ifdef CONFIG_SND_JACK_INPUT_DEV
355 if (!jack->input_dev)
356 return;
357
358 for (i = 0; i < ARRAY_SIZE(jack->key); i++) {
359 int testbit = SND_JACK_BTN_0 >> i;
360
361 if (jack->type & testbit)
362 input_report_key(jack->input_dev, jack->key[i],
363 status & testbit);
364 }
365
366 for (i = 0; i < ARRAY_SIZE(jack_switch_types); i++) {
367 int testbit = 1 << i;
368 if (jack->type & testbit)
369 input_report_switch(jack->input_dev,
370 jack_switch_types[i],
371 status & testbit);
372 }
373
374 input_sync(jack->input_dev);
375#endif /* CONFIG_SND_JACK_INPUT_DEV */
376}
377EXPORT_SYMBOL(snd_jack_report);
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Jack abstraction layer
4 *
5 * Copyright 2008 Wolfson Microelectronics
6 */
7
8#include <linux/input.h>
9#include <linux/slab.h>
10#include <linux/module.h>
11#include <linux/ctype.h>
12#include <linux/mm.h>
13#include <linux/debugfs.h>
14#include <sound/jack.h>
15#include <sound/core.h>
16#include <sound/control.h>
17
18struct snd_jack_kctl {
19 struct snd_kcontrol *kctl;
20 struct list_head list; /* list of controls belong to the same jack */
21 unsigned int mask_bits; /* only masked status bits are reported via kctl */
22 struct snd_jack *jack; /* pointer to struct snd_jack */
23 bool sw_inject_enable; /* allow to inject plug event via debugfs */
24#ifdef CONFIG_SND_JACK_INJECTION_DEBUG
25 struct dentry *jack_debugfs_root; /* jack_kctl debugfs root */
26#endif
27};
28
29#ifdef CONFIG_SND_JACK_INPUT_DEV
30static const int jack_switch_types[SND_JACK_SWITCH_TYPES] = {
31 SW_HEADPHONE_INSERT,
32 SW_MICROPHONE_INSERT,
33 SW_LINEOUT_INSERT,
34 SW_JACK_PHYSICAL_INSERT,
35 SW_VIDEOOUT_INSERT,
36 SW_LINEIN_INSERT,
37};
38#endif /* CONFIG_SND_JACK_INPUT_DEV */
39
40static int snd_jack_dev_disconnect(struct snd_device *device)
41{
42#ifdef CONFIG_SND_JACK_INPUT_DEV
43 struct snd_jack *jack = device->device_data;
44
45 mutex_lock(&jack->input_dev_lock);
46 if (!jack->input_dev) {
47 mutex_unlock(&jack->input_dev_lock);
48 return 0;
49 }
50
51 /* If the input device is registered with the input subsystem
52 * then we need to use a different deallocator. */
53 if (jack->registered)
54 input_unregister_device(jack->input_dev);
55 else
56 input_free_device(jack->input_dev);
57 jack->input_dev = NULL;
58 mutex_unlock(&jack->input_dev_lock);
59#endif /* CONFIG_SND_JACK_INPUT_DEV */
60 return 0;
61}
62
63static int snd_jack_dev_free(struct snd_device *device)
64{
65 struct snd_jack *jack = device->device_data;
66 struct snd_card *card = device->card;
67 struct snd_jack_kctl *jack_kctl, *tmp_jack_kctl;
68
69 down_write(&card->controls_rwsem);
70 list_for_each_entry_safe(jack_kctl, tmp_jack_kctl, &jack->kctl_list, list) {
71 list_del_init(&jack_kctl->list);
72 snd_ctl_remove(card, jack_kctl->kctl);
73 }
74 up_write(&card->controls_rwsem);
75
76 if (jack->private_free)
77 jack->private_free(jack);
78
79 snd_jack_dev_disconnect(device);
80
81 kfree(jack->id);
82 kfree(jack);
83
84 return 0;
85}
86
87#ifdef CONFIG_SND_JACK_INPUT_DEV
88static int snd_jack_dev_register(struct snd_device *device)
89{
90 struct snd_jack *jack = device->device_data;
91 struct snd_card *card = device->card;
92 int err, i;
93
94 snprintf(jack->name, sizeof(jack->name), "%s %s",
95 card->shortname, jack->id);
96
97 mutex_lock(&jack->input_dev_lock);
98 if (!jack->input_dev) {
99 mutex_unlock(&jack->input_dev_lock);
100 return 0;
101 }
102
103 jack->input_dev->name = jack->name;
104
105 /* Default to the sound card device. */
106 if (!jack->input_dev->dev.parent)
107 jack->input_dev->dev.parent = snd_card_get_device_link(card);
108
109 /* Add capabilities for any keys that are enabled */
110 for (i = 0; i < ARRAY_SIZE(jack->key); i++) {
111 int testbit = SND_JACK_BTN_0 >> i;
112
113 if (!(jack->type & testbit))
114 continue;
115
116 if (!jack->key[i])
117 jack->key[i] = BTN_0 + i;
118
119 input_set_capability(jack->input_dev, EV_KEY, jack->key[i]);
120 }
121
122 err = input_register_device(jack->input_dev);
123 if (err == 0)
124 jack->registered = 1;
125
126 mutex_unlock(&jack->input_dev_lock);
127 return err;
128}
129#endif /* CONFIG_SND_JACK_INPUT_DEV */
130
131#ifdef CONFIG_SND_JACK_INJECTION_DEBUG
132static void snd_jack_inject_report(struct snd_jack_kctl *jack_kctl, int status)
133{
134 struct snd_jack *jack;
135#ifdef CONFIG_SND_JACK_INPUT_DEV
136 int i;
137#endif
138 if (!jack_kctl)
139 return;
140
141 jack = jack_kctl->jack;
142
143 if (jack_kctl->sw_inject_enable)
144 snd_kctl_jack_report(jack->card, jack_kctl->kctl,
145 status & jack_kctl->mask_bits);
146
147#ifdef CONFIG_SND_JACK_INPUT_DEV
148 if (!jack->input_dev)
149 return;
150
151 for (i = 0; i < ARRAY_SIZE(jack->key); i++) {
152 int testbit = ((SND_JACK_BTN_0 >> i) & jack_kctl->mask_bits);
153
154 if (jack->type & testbit)
155 input_report_key(jack->input_dev, jack->key[i],
156 status & testbit);
157 }
158
159 for (i = 0; i < ARRAY_SIZE(jack_switch_types); i++) {
160 int testbit = ((1 << i) & jack_kctl->mask_bits);
161
162 if (jack->type & testbit)
163 input_report_switch(jack->input_dev,
164 jack_switch_types[i],
165 status & testbit);
166 }
167
168 input_sync(jack->input_dev);
169#endif /* CONFIG_SND_JACK_INPUT_DEV */
170}
171
172static ssize_t sw_inject_enable_read(struct file *file,
173 char __user *to, size_t count, loff_t *ppos)
174{
175 struct snd_jack_kctl *jack_kctl = file->private_data;
176 int len, ret;
177 char buf[128];
178
179 len = scnprintf(buf, sizeof(buf), "%s: %s\t\t%s: %i\n", "Jack", jack_kctl->kctl->id.name,
180 "Inject Enabled", jack_kctl->sw_inject_enable);
181 ret = simple_read_from_buffer(to, count, ppos, buf, len);
182
183 return ret;
184}
185
186static ssize_t sw_inject_enable_write(struct file *file,
187 const char __user *from, size_t count, loff_t *ppos)
188{
189 struct snd_jack_kctl *jack_kctl = file->private_data;
190 int ret, err;
191 unsigned long enable;
192 char buf[8] = { 0 };
193
194 ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, from, count);
195 err = kstrtoul(buf, 0, &enable);
196 if (err)
197 return err;
198
199 if (jack_kctl->sw_inject_enable == (!!enable))
200 return ret;
201
202 jack_kctl->sw_inject_enable = !!enable;
203
204 if (!jack_kctl->sw_inject_enable)
205 snd_jack_report(jack_kctl->jack, jack_kctl->jack->hw_status_cache);
206
207 return ret;
208}
209
210static ssize_t jackin_inject_write(struct file *file,
211 const char __user *from, size_t count, loff_t *ppos)
212{
213 struct snd_jack_kctl *jack_kctl = file->private_data;
214 int ret, err;
215 unsigned long enable;
216 char buf[8] = { 0 };
217
218 if (!jack_kctl->sw_inject_enable)
219 return -EINVAL;
220
221 ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, from, count);
222 err = kstrtoul(buf, 0, &enable);
223 if (err)
224 return err;
225
226 snd_jack_inject_report(jack_kctl, !!enable ? jack_kctl->mask_bits : 0);
227
228 return ret;
229}
230
231static ssize_t jack_kctl_id_read(struct file *file,
232 char __user *to, size_t count, loff_t *ppos)
233{
234 struct snd_jack_kctl *jack_kctl = file->private_data;
235 char buf[64];
236 int len, ret;
237
238 len = scnprintf(buf, sizeof(buf), "%s\n", jack_kctl->kctl->id.name);
239 ret = simple_read_from_buffer(to, count, ppos, buf, len);
240
241 return ret;
242}
243
244/* the bit definition is aligned with snd_jack_types in jack.h */
245static const char * const jack_events_name[] = {
246 "HEADPHONE(0x0001)", "MICROPHONE(0x0002)", "LINEOUT(0x0004)",
247 "MECHANICAL(0x0008)", "VIDEOOUT(0x0010)", "LINEIN(0x0020)",
248 "", "", "", "BTN_5(0x0200)", "BTN_4(0x0400)", "BTN_3(0x0800)",
249 "BTN_2(0x1000)", "BTN_1(0x2000)", "BTN_0(0x4000)", "",
250};
251
252/* the recommended buffer size is 256 */
253static int parse_mask_bits(unsigned int mask_bits, char *buf, size_t buf_size)
254{
255 int i;
256
257 scnprintf(buf, buf_size, "0x%04x", mask_bits);
258
259 for (i = 0; i < ARRAY_SIZE(jack_events_name); i++)
260 if (mask_bits & (1 << i)) {
261 strlcat(buf, " ", buf_size);
262 strlcat(buf, jack_events_name[i], buf_size);
263 }
264 strlcat(buf, "\n", buf_size);
265
266 return strlen(buf);
267}
268
269static ssize_t jack_kctl_mask_bits_read(struct file *file,
270 char __user *to, size_t count, loff_t *ppos)
271{
272 struct snd_jack_kctl *jack_kctl = file->private_data;
273 char buf[256];
274 int len, ret;
275
276 len = parse_mask_bits(jack_kctl->mask_bits, buf, sizeof(buf));
277 ret = simple_read_from_buffer(to, count, ppos, buf, len);
278
279 return ret;
280}
281
282static ssize_t jack_kctl_status_read(struct file *file,
283 char __user *to, size_t count, loff_t *ppos)
284{
285 struct snd_jack_kctl *jack_kctl = file->private_data;
286 char buf[16];
287 int len, ret;
288
289 len = scnprintf(buf, sizeof(buf), "%s\n", jack_kctl->kctl->private_value ?
290 "Plugged" : "Unplugged");
291 ret = simple_read_from_buffer(to, count, ppos, buf, len);
292
293 return ret;
294}
295
296#ifdef CONFIG_SND_JACK_INPUT_DEV
297static ssize_t jack_type_read(struct file *file,
298 char __user *to, size_t count, loff_t *ppos)
299{
300 struct snd_jack_kctl *jack_kctl = file->private_data;
301 char buf[256];
302 int len, ret;
303
304 len = parse_mask_bits(jack_kctl->jack->type, buf, sizeof(buf));
305 ret = simple_read_from_buffer(to, count, ppos, buf, len);
306
307 return ret;
308}
309
310static const struct file_operations jack_type_fops = {
311 .open = simple_open,
312 .read = jack_type_read,
313 .llseek = default_llseek,
314};
315#endif
316
317static const struct file_operations sw_inject_enable_fops = {
318 .open = simple_open,
319 .read = sw_inject_enable_read,
320 .write = sw_inject_enable_write,
321 .llseek = default_llseek,
322};
323
324static const struct file_operations jackin_inject_fops = {
325 .open = simple_open,
326 .write = jackin_inject_write,
327 .llseek = default_llseek,
328};
329
330static const struct file_operations jack_kctl_id_fops = {
331 .open = simple_open,
332 .read = jack_kctl_id_read,
333 .llseek = default_llseek,
334};
335
336static const struct file_operations jack_kctl_mask_bits_fops = {
337 .open = simple_open,
338 .read = jack_kctl_mask_bits_read,
339 .llseek = default_llseek,
340};
341
342static const struct file_operations jack_kctl_status_fops = {
343 .open = simple_open,
344 .read = jack_kctl_status_read,
345 .llseek = default_llseek,
346};
347
348static int snd_jack_debugfs_add_inject_node(struct snd_jack *jack,
349 struct snd_jack_kctl *jack_kctl)
350{
351 char *tname;
352 int i;
353
354 /* Don't create injection interface for Phantom jacks */
355 if (strstr(jack_kctl->kctl->id.name, "Phantom"))
356 return 0;
357
358 tname = kstrdup(jack_kctl->kctl->id.name, GFP_KERNEL);
359 if (!tname)
360 return -ENOMEM;
361
362 /* replace the chars which are not suitable for folder's name with _ */
363 for (i = 0; tname[i]; i++)
364 if (!isalnum(tname[i]))
365 tname[i] = '_';
366
367 jack_kctl->jack_debugfs_root = debugfs_create_dir(tname, jack->card->debugfs_root);
368 kfree(tname);
369
370 debugfs_create_file("sw_inject_enable", 0644, jack_kctl->jack_debugfs_root, jack_kctl,
371 &sw_inject_enable_fops);
372
373 debugfs_create_file("jackin_inject", 0200, jack_kctl->jack_debugfs_root, jack_kctl,
374 &jackin_inject_fops);
375
376 debugfs_create_file("kctl_id", 0444, jack_kctl->jack_debugfs_root, jack_kctl,
377 &jack_kctl_id_fops);
378
379 debugfs_create_file("mask_bits", 0444, jack_kctl->jack_debugfs_root, jack_kctl,
380 &jack_kctl_mask_bits_fops);
381
382 debugfs_create_file("status", 0444, jack_kctl->jack_debugfs_root, jack_kctl,
383 &jack_kctl_status_fops);
384
385#ifdef CONFIG_SND_JACK_INPUT_DEV
386 debugfs_create_file("type", 0444, jack_kctl->jack_debugfs_root, jack_kctl,
387 &jack_type_fops);
388#endif
389 return 0;
390}
391
392static void snd_jack_debugfs_clear_inject_node(struct snd_jack_kctl *jack_kctl)
393{
394 debugfs_remove(jack_kctl->jack_debugfs_root);
395 jack_kctl->jack_debugfs_root = NULL;
396}
397#else /* CONFIG_SND_JACK_INJECTION_DEBUG */
398static int snd_jack_debugfs_add_inject_node(struct snd_jack *jack,
399 struct snd_jack_kctl *jack_kctl)
400{
401 return 0;
402}
403
404static void snd_jack_debugfs_clear_inject_node(struct snd_jack_kctl *jack_kctl)
405{
406}
407#endif /* CONFIG_SND_JACK_INJECTION_DEBUG */
408
409static void snd_jack_kctl_private_free(struct snd_kcontrol *kctl)
410{
411 struct snd_jack_kctl *jack_kctl;
412
413 jack_kctl = kctl->private_data;
414 if (jack_kctl) {
415 snd_jack_debugfs_clear_inject_node(jack_kctl);
416 list_del(&jack_kctl->list);
417 kfree(jack_kctl);
418 }
419}
420
421static void snd_jack_kctl_add(struct snd_jack *jack, struct snd_jack_kctl *jack_kctl)
422{
423 jack_kctl->jack = jack;
424 list_add_tail(&jack_kctl->list, &jack->kctl_list);
425 snd_jack_debugfs_add_inject_node(jack, jack_kctl);
426}
427
428static struct snd_jack_kctl * snd_jack_kctl_new(struct snd_card *card, const char *name, unsigned int mask)
429{
430 struct snd_kcontrol *kctl;
431 struct snd_jack_kctl *jack_kctl;
432 int err;
433
434 kctl = snd_kctl_jack_new(name, card);
435 if (!kctl)
436 return NULL;
437
438 err = snd_ctl_add(card, kctl);
439 if (err < 0)
440 return NULL;
441
442 jack_kctl = kzalloc(sizeof(*jack_kctl), GFP_KERNEL);
443
444 if (!jack_kctl)
445 goto error;
446
447 jack_kctl->kctl = kctl;
448 jack_kctl->mask_bits = mask;
449
450 kctl->private_data = jack_kctl;
451 kctl->private_free = snd_jack_kctl_private_free;
452
453 return jack_kctl;
454error:
455 snd_ctl_free_one(kctl);
456 return NULL;
457}
458
459/**
460 * snd_jack_add_new_kctl - Create a new snd_jack_kctl and add it to jack
461 * @jack: the jack instance which the kctl will attaching to
462 * @name: the name for the snd_kcontrol object
463 * @mask: a bitmask of enum snd_jack_type values that can be detected
464 * by this snd_jack_kctl object.
465 *
466 * Creates a new snd_kcontrol object and adds it to the jack kctl_list.
467 *
468 * Return: Zero if successful, or a negative error code on failure.
469 */
470int snd_jack_add_new_kctl(struct snd_jack *jack, const char * name, int mask)
471{
472 struct snd_jack_kctl *jack_kctl;
473
474 jack_kctl = snd_jack_kctl_new(jack->card, name, mask);
475 if (!jack_kctl)
476 return -ENOMEM;
477
478 snd_jack_kctl_add(jack, jack_kctl);
479 return 0;
480}
481EXPORT_SYMBOL(snd_jack_add_new_kctl);
482
483/**
484 * snd_jack_new - Create a new jack
485 * @card: the card instance
486 * @id: an identifying string for this jack
487 * @type: a bitmask of enum snd_jack_type values that can be detected by
488 * this jack
489 * @jjack: Used to provide the allocated jack object to the caller.
490 * @initial_kctl: if true, create a kcontrol and add it to the jack list.
491 * @phantom_jack: Don't create a input device for phantom jacks.
492 *
493 * Creates a new jack object.
494 *
495 * Return: Zero if successful, or a negative error code on failure.
496 * On success @jjack will be initialised.
497 */
498int snd_jack_new(struct snd_card *card, const char *id, int type,
499 struct snd_jack **jjack, bool initial_kctl, bool phantom_jack)
500{
501 struct snd_jack *jack;
502 struct snd_jack_kctl *jack_kctl = NULL;
503 int err;
504 static const struct snd_device_ops ops = {
505 .dev_free = snd_jack_dev_free,
506#ifdef CONFIG_SND_JACK_INPUT_DEV
507 .dev_register = snd_jack_dev_register,
508 .dev_disconnect = snd_jack_dev_disconnect,
509#endif /* CONFIG_SND_JACK_INPUT_DEV */
510 };
511
512 if (initial_kctl) {
513 jack_kctl = snd_jack_kctl_new(card, id, type);
514 if (!jack_kctl)
515 return -ENOMEM;
516 }
517
518 jack = kzalloc(sizeof(struct snd_jack), GFP_KERNEL);
519 if (jack == NULL)
520 return -ENOMEM;
521
522 jack->id = kstrdup(id, GFP_KERNEL);
523 if (jack->id == NULL) {
524 kfree(jack);
525 return -ENOMEM;
526 }
527
528#ifdef CONFIG_SND_JACK_INPUT_DEV
529 mutex_init(&jack->input_dev_lock);
530
531 /* don't create input device for phantom jack */
532 if (!phantom_jack) {
533 int i;
534
535 jack->input_dev = input_allocate_device();
536 if (jack->input_dev == NULL) {
537 err = -ENOMEM;
538 goto fail_input;
539 }
540
541 jack->input_dev->phys = "ALSA";
542
543 jack->type = type;
544
545 for (i = 0; i < SND_JACK_SWITCH_TYPES; i++)
546 if (type & (1 << i))
547 input_set_capability(jack->input_dev, EV_SW,
548 jack_switch_types[i]);
549
550 }
551#endif /* CONFIG_SND_JACK_INPUT_DEV */
552
553 err = snd_device_new(card, SNDRV_DEV_JACK, jack, &ops);
554 if (err < 0)
555 goto fail_input;
556
557 jack->card = card;
558 INIT_LIST_HEAD(&jack->kctl_list);
559
560 if (initial_kctl)
561 snd_jack_kctl_add(jack, jack_kctl);
562
563 *jjack = jack;
564
565 return 0;
566
567fail_input:
568#ifdef CONFIG_SND_JACK_INPUT_DEV
569 input_free_device(jack->input_dev);
570#endif
571 kfree(jack->id);
572 kfree(jack);
573 return err;
574}
575EXPORT_SYMBOL(snd_jack_new);
576
577#ifdef CONFIG_SND_JACK_INPUT_DEV
578/**
579 * snd_jack_set_parent - Set the parent device for a jack
580 *
581 * @jack: The jack to configure
582 * @parent: The device to set as parent for the jack.
583 *
584 * Set the parent for the jack devices in the device tree. This
585 * function is only valid prior to registration of the jack. If no
586 * parent is configured then the parent device will be the sound card.
587 */
588void snd_jack_set_parent(struct snd_jack *jack, struct device *parent)
589{
590 WARN_ON(jack->registered);
591 mutex_lock(&jack->input_dev_lock);
592 if (!jack->input_dev) {
593 mutex_unlock(&jack->input_dev_lock);
594 return;
595 }
596
597 jack->input_dev->dev.parent = parent;
598 mutex_unlock(&jack->input_dev_lock);
599}
600EXPORT_SYMBOL(snd_jack_set_parent);
601
602/**
603 * snd_jack_set_key - Set a key mapping on a jack
604 *
605 * @jack: The jack to configure
606 * @type: Jack report type for this key
607 * @keytype: Input layer key type to be reported
608 *
609 * Map a SND_JACK_BTN_* button type to an input layer key, allowing
610 * reporting of keys on accessories via the jack abstraction. If no
611 * mapping is provided but keys are enabled in the jack type then
612 * BTN_n numeric buttons will be reported.
613 *
614 * If jacks are not reporting via the input API this call will have no
615 * effect.
616 *
617 * Note that this is intended to be use by simple devices with small
618 * numbers of keys that can be reported. It is also possible to
619 * access the input device directly - devices with complex input
620 * capabilities on accessories should consider doing this rather than
621 * using this abstraction.
622 *
623 * This function may only be called prior to registration of the jack.
624 *
625 * Return: Zero if successful, or a negative error code on failure.
626 */
627int snd_jack_set_key(struct snd_jack *jack, enum snd_jack_types type,
628 int keytype)
629{
630 int key = fls(SND_JACK_BTN_0) - fls(type);
631
632 WARN_ON(jack->registered);
633
634 if (!keytype || key >= ARRAY_SIZE(jack->key))
635 return -EINVAL;
636
637 jack->type |= type;
638 jack->key[key] = keytype;
639 return 0;
640}
641EXPORT_SYMBOL(snd_jack_set_key);
642#endif /* CONFIG_SND_JACK_INPUT_DEV */
643
644/**
645 * snd_jack_report - Report the current status of a jack
646 * Note: This function uses mutexes and should be called from a
647 * context which can sleep (such as a workqueue).
648 *
649 * @jack: The jack to report status for
650 * @status: The current status of the jack
651 */
652void snd_jack_report(struct snd_jack *jack, int status)
653{
654 struct snd_jack_kctl *jack_kctl;
655 unsigned int mask_bits = 0;
656#ifdef CONFIG_SND_JACK_INPUT_DEV
657 int i;
658#endif
659
660 if (!jack)
661 return;
662
663 jack->hw_status_cache = status;
664
665 list_for_each_entry(jack_kctl, &jack->kctl_list, list)
666 if (jack_kctl->sw_inject_enable)
667 mask_bits |= jack_kctl->mask_bits;
668 else
669 snd_kctl_jack_report(jack->card, jack_kctl->kctl,
670 status & jack_kctl->mask_bits);
671
672#ifdef CONFIG_SND_JACK_INPUT_DEV
673 mutex_lock(&jack->input_dev_lock);
674 if (!jack->input_dev) {
675 mutex_unlock(&jack->input_dev_lock);
676 return;
677 }
678
679 for (i = 0; i < ARRAY_SIZE(jack->key); i++) {
680 int testbit = ((SND_JACK_BTN_0 >> i) & ~mask_bits);
681
682 if (jack->type & testbit)
683 input_report_key(jack->input_dev, jack->key[i],
684 status & testbit);
685 }
686
687 for (i = 0; i < ARRAY_SIZE(jack_switch_types); i++) {
688 int testbit = ((1 << i) & ~mask_bits);
689
690 if (jack->type & testbit)
691 input_report_switch(jack->input_dev,
692 jack_switch_types[i],
693 status & testbit);
694 }
695
696 input_sync(jack->input_dev);
697 mutex_unlock(&jack->input_dev_lock);
698#endif /* CONFIG_SND_JACK_INPUT_DEV */
699}
700EXPORT_SYMBOL(snd_jack_report);