xref: /linux/sound/soc/soc-jack.c (revision 4413e16d9d21673bb5048a2e542f1aaa00015c2e)
1 /*
2  * soc-jack.c  --  ALSA SoC jack handling
3  *
4  * Copyright 2008 Wolfson Microelectronics PLC.
5  *
6  * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
7  *
8  *  This program is free software; you can redistribute  it and/or modify it
9  *  under  the terms of  the GNU General  Public License as published by the
10  *  Free Software Foundation;  either version 2 of the  License, or (at your
11  *  option) any later version.
12  */
13 
14 #include <sound/jack.h>
15 #include <sound/soc.h>
16 #include <linux/gpio.h>
17 #include <linux/interrupt.h>
18 #include <linux/workqueue.h>
19 #include <linux/delay.h>
20 #include <linux/export.h>
21 #include <trace/events/asoc.h>
22 
23 /**
24  * snd_soc_jack_new - Create a new jack
25  * @card:  ASoC card
26  * @id:    an identifying string for this jack
27  * @type:  a bitmask of enum snd_jack_type values that can be detected by
28  *         this jack
29  * @jack:  structure to use for the jack
30  *
31  * Creates a new jack object.
32  *
33  * Returns zero if successful, or a negative error code on failure.
34  * On success jack will be initialised.
35  */
36 int snd_soc_jack_new(struct snd_soc_codec *codec, const char *id, int type,
37 		     struct snd_soc_jack *jack)
38 {
39 	mutex_init(&jack->mutex);
40 	jack->codec = codec;
41 	INIT_LIST_HEAD(&jack->pins);
42 	INIT_LIST_HEAD(&jack->jack_zones);
43 	BLOCKING_INIT_NOTIFIER_HEAD(&jack->notifier);
44 
45 	return snd_jack_new(codec->card->snd_card, id, type, &jack->jack);
46 }
47 EXPORT_SYMBOL_GPL(snd_soc_jack_new);
48 
49 /**
50  * snd_soc_jack_report - Report the current status for a jack
51  *
52  * @jack:   the jack
53  * @status: a bitmask of enum snd_jack_type values that are currently detected.
54  * @mask:   a bitmask of enum snd_jack_type values that being reported.
55  *
56  * If configured using snd_soc_jack_add_pins() then the associated
57  * DAPM pins will be enabled or disabled as appropriate and DAPM
58  * synchronised.
59  *
60  * Note: This function uses mutexes and should be called from a
61  * context which can sleep (such as a workqueue).
62  */
63 void snd_soc_jack_report(struct snd_soc_jack *jack, int status, int mask)
64 {
65 	struct snd_soc_codec *codec;
66 	struct snd_soc_dapm_context *dapm;
67 	struct snd_soc_jack_pin *pin;
68 	int enable;
69 	int oldstatus;
70 
71 	trace_snd_soc_jack_report(jack, mask, status);
72 
73 	if (!jack)
74 		return;
75 
76 	codec = jack->codec;
77 	dapm =  &codec->dapm;
78 
79 	mutex_lock(&jack->mutex);
80 
81 	oldstatus = jack->status;
82 
83 	jack->status &= ~mask;
84 	jack->status |= status & mask;
85 
86 	/* The DAPM sync is expensive enough to be worth skipping.
87 	 * However, empty mask means pin synchronization is desired. */
88 	if (mask && (jack->status == oldstatus))
89 		goto out;
90 
91 	trace_snd_soc_jack_notify(jack, status);
92 
93 	list_for_each_entry(pin, &jack->pins, list) {
94 		enable = pin->mask & jack->status;
95 
96 		if (pin->invert)
97 			enable = !enable;
98 
99 		if (enable)
100 			snd_soc_dapm_enable_pin(dapm, pin->pin);
101 		else
102 			snd_soc_dapm_disable_pin(dapm, pin->pin);
103 	}
104 
105 	/* Report before the DAPM sync to help users updating micbias status */
106 	blocking_notifier_call_chain(&jack->notifier, jack->status, jack);
107 
108 	snd_soc_dapm_sync(dapm);
109 
110 	snd_jack_report(jack->jack, jack->status);
111 
112 out:
113 	mutex_unlock(&jack->mutex);
114 }
115 EXPORT_SYMBOL_GPL(snd_soc_jack_report);
116 
117 /**
118  * snd_soc_jack_add_zones - Associate voltage zones with jack
119  *
120  * @jack:  ASoC jack
121  * @count: Number of zones
122  * @zone:  Array of zones
123  *
124  * After this function has been called the zones specified in the
125  * array will be associated with the jack.
126  */
127 int snd_soc_jack_add_zones(struct snd_soc_jack *jack, int count,
128 			  struct snd_soc_jack_zone *zones)
129 {
130 	int i;
131 
132 	for (i = 0; i < count; i++) {
133 		INIT_LIST_HEAD(&zones[i].list);
134 		list_add(&(zones[i].list), &jack->jack_zones);
135 	}
136 	return 0;
137 }
138 EXPORT_SYMBOL_GPL(snd_soc_jack_add_zones);
139 
140 /**
141  * snd_soc_jack_get_type - Based on the mic bias value, this function returns
142  * the type of jack from the zones delcared in the jack type
143  *
144  * @micbias_voltage:  mic bias voltage at adc channel when jack is plugged in
145  *
146  * Based on the mic bias value passed, this function helps identify
147  * the type of jack from the already delcared jack zones
148  */
149 int snd_soc_jack_get_type(struct snd_soc_jack *jack, int micbias_voltage)
150 {
151 	struct snd_soc_jack_zone *zone;
152 
153 	list_for_each_entry(zone, &jack->jack_zones, list) {
154 		if (micbias_voltage >= zone->min_mv &&
155 			micbias_voltage < zone->max_mv)
156 				return zone->jack_type;
157 	}
158 	return 0;
159 }
160 EXPORT_SYMBOL_GPL(snd_soc_jack_get_type);
161 
162 /**
163  * snd_soc_jack_add_pins - Associate DAPM pins with an ASoC jack
164  *
165  * @jack:  ASoC jack
166  * @count: Number of pins
167  * @pins:  Array of pins
168  *
169  * After this function has been called the DAPM pins specified in the
170  * pins array will have their status updated to reflect the current
171  * state of the jack whenever the jack status is updated.
172  */
173 int snd_soc_jack_add_pins(struct snd_soc_jack *jack, int count,
174 			  struct snd_soc_jack_pin *pins)
175 {
176 	int i;
177 
178 	for (i = 0; i < count; i++) {
179 		if (!pins[i].pin) {
180 			printk(KERN_ERR "No name for pin %d\n", i);
181 			return -EINVAL;
182 		}
183 		if (!pins[i].mask) {
184 			printk(KERN_ERR "No mask for pin %d (%s)\n", i,
185 			       pins[i].pin);
186 			return -EINVAL;
187 		}
188 
189 		INIT_LIST_HEAD(&pins[i].list);
190 		list_add(&(pins[i].list), &jack->pins);
191 	}
192 
193 	snd_soc_dapm_new_widgets(&jack->codec->card->dapm);
194 
195 	/* Update to reflect the last reported status; canned jack
196 	 * implementations are likely to set their state before the
197 	 * card has an opportunity to associate pins.
198 	 */
199 	snd_soc_jack_report(jack, 0, 0);
200 
201 	return 0;
202 }
203 EXPORT_SYMBOL_GPL(snd_soc_jack_add_pins);
204 
205 /**
206  * snd_soc_jack_notifier_register - Register a notifier for jack status
207  *
208  * @jack:  ASoC jack
209  * @nb:    Notifier block to register
210  *
211  * Register for notification of the current status of the jack.  Note
212  * that it is not possible to report additional jack events in the
213  * callback from the notifier, this is intended to support
214  * applications such as enabling electrical detection only when a
215  * mechanical detection event has occurred.
216  */
217 void snd_soc_jack_notifier_register(struct snd_soc_jack *jack,
218 				    struct notifier_block *nb)
219 {
220 	blocking_notifier_chain_register(&jack->notifier, nb);
221 }
222 EXPORT_SYMBOL_GPL(snd_soc_jack_notifier_register);
223 
224 /**
225  * snd_soc_jack_notifier_unregister - Unregister a notifier for jack status
226  *
227  * @jack:  ASoC jack
228  * @nb:    Notifier block to unregister
229  *
230  * Stop notifying for status changes.
231  */
232 void snd_soc_jack_notifier_unregister(struct snd_soc_jack *jack,
233 				      struct notifier_block *nb)
234 {
235 	blocking_notifier_chain_unregister(&jack->notifier, nb);
236 }
237 EXPORT_SYMBOL_GPL(snd_soc_jack_notifier_unregister);
238 
239 #ifdef CONFIG_GPIOLIB
240 /* gpio detect */
241 static void snd_soc_jack_gpio_detect(struct snd_soc_jack_gpio *gpio)
242 {
243 	struct snd_soc_jack *jack = gpio->jack;
244 	int enable;
245 	int report;
246 
247 	enable = gpio_get_value_cansleep(gpio->gpio);
248 	if (gpio->invert)
249 		enable = !enable;
250 
251 	if (enable)
252 		report = gpio->report;
253 	else
254 		report = 0;
255 
256 	if (gpio->jack_status_check)
257 		report = gpio->jack_status_check();
258 
259 	snd_soc_jack_report(jack, report, gpio->report);
260 }
261 
262 /* irq handler for gpio pin */
263 static irqreturn_t gpio_handler(int irq, void *data)
264 {
265 	struct snd_soc_jack_gpio *gpio = data;
266 	struct device *dev = gpio->jack->codec->card->dev;
267 
268 	trace_snd_soc_jack_irq(gpio->name);
269 
270 	if (device_may_wakeup(dev))
271 		pm_wakeup_event(dev, gpio->debounce_time + 50);
272 
273 	schedule_delayed_work(&gpio->work,
274 			      msecs_to_jiffies(gpio->debounce_time));
275 
276 	return IRQ_HANDLED;
277 }
278 
279 /* gpio work */
280 static void gpio_work(struct work_struct *work)
281 {
282 	struct snd_soc_jack_gpio *gpio;
283 
284 	gpio = container_of(work, struct snd_soc_jack_gpio, work.work);
285 	snd_soc_jack_gpio_detect(gpio);
286 }
287 
288 /**
289  * snd_soc_jack_add_gpios - Associate GPIO pins with an ASoC jack
290  *
291  * @jack:  ASoC jack
292  * @count: number of pins
293  * @gpios: array of gpio pins
294  *
295  * This function will request gpio, set data direction and request irq
296  * for each gpio in the array.
297  */
298 int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
299 			struct snd_soc_jack_gpio *gpios)
300 {
301 	int i, ret;
302 
303 	for (i = 0; i < count; i++) {
304 		if (!gpio_is_valid(gpios[i].gpio)) {
305 			printk(KERN_ERR "Invalid gpio %d\n",
306 				gpios[i].gpio);
307 			ret = -EINVAL;
308 			goto undo;
309 		}
310 		if (!gpios[i].name) {
311 			printk(KERN_ERR "No name for gpio %d\n",
312 				gpios[i].gpio);
313 			ret = -EINVAL;
314 			goto undo;
315 		}
316 
317 		ret = gpio_request(gpios[i].gpio, gpios[i].name);
318 		if (ret)
319 			goto undo;
320 
321 		ret = gpio_direction_input(gpios[i].gpio);
322 		if (ret)
323 			goto err;
324 
325 		INIT_DELAYED_WORK(&gpios[i].work, gpio_work);
326 		gpios[i].jack = jack;
327 
328 		ret = request_any_context_irq(gpio_to_irq(gpios[i].gpio),
329 					      gpio_handler,
330 					      IRQF_TRIGGER_RISING |
331 					      IRQF_TRIGGER_FALLING,
332 					      gpios[i].name,
333 					      &gpios[i]);
334 		if (ret < 0)
335 			goto err;
336 
337 		if (gpios[i].wake) {
338 			ret = irq_set_irq_wake(gpio_to_irq(gpios[i].gpio), 1);
339 			if (ret != 0)
340 				printk(KERN_ERR
341 				  "Failed to mark GPIO %d as wake source: %d\n",
342 					gpios[i].gpio, ret);
343 		}
344 
345 		/* Expose GPIO value over sysfs for diagnostic purposes */
346 		gpio_export(gpios[i].gpio, false);
347 
348 		/* Update initial jack status */
349 		snd_soc_jack_gpio_detect(&gpios[i]);
350 	}
351 
352 	return 0;
353 
354 err:
355 	gpio_free(gpios[i].gpio);
356 undo:
357 	snd_soc_jack_free_gpios(jack, i, gpios);
358 
359 	return ret;
360 }
361 EXPORT_SYMBOL_GPL(snd_soc_jack_add_gpios);
362 
363 /**
364  * snd_soc_jack_free_gpios - Release GPIO pins' resources of an ASoC jack
365  *
366  * @jack:  ASoC jack
367  * @count: number of pins
368  * @gpios: array of gpio pins
369  *
370  * Release gpio and irq resources for gpio pins associated with an ASoC jack.
371  */
372 void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
373 			struct snd_soc_jack_gpio *gpios)
374 {
375 	int i;
376 
377 	for (i = 0; i < count; i++) {
378 		gpio_unexport(gpios[i].gpio);
379 		free_irq(gpio_to_irq(gpios[i].gpio), &gpios[i]);
380 		cancel_delayed_work_sync(&gpios[i].work);
381 		gpio_free(gpios[i].gpio);
382 		gpios[i].jack = NULL;
383 	}
384 }
385 EXPORT_SYMBOL_GPL(snd_soc_jack_free_gpios);
386 #endif	/* CONFIG_GPIOLIB */
387