1/*
2 * Jack-detection handling for HD-audio
3 *
4 * Copyright (c) 2011 Takashi Iwai <tiwai@suse.de>
5 *
6 * This driver 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
12#include <linux/init.h>
13#include <linux/slab.h>
14#include <linux/export.h>
15#include <sound/core.h>
16#include <sound/control.h>
17#include <sound/jack.h>
18#include "hda_codec.h"
19#include "hda_local.h"
20#include "hda_auto_parser.h"
21#include "hda_jack.h"
22
23/**
24 * is_jack_detectable - Check whether the given pin is jack-detectable
25 * @codec: the HDA codec
26 * @nid: pin NID
27 *
28 * Check whether the given pin is capable to report the jack detection.
29 * The jack detection might not work by various reasons, e.g. the jack
30 * detection is prohibited in the codec level, the pin config has
31 * AC_DEFCFG_MISC_NO_PRESENCE bit, no unsol support, etc.
32 */
33bool is_jack_detectable(struct hda_codec *codec, hda_nid_t nid)
34{
35	if (codec->no_jack_detect)
36		return false;
37	if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_PRES_DETECT))
38		return false;
39	if (get_defcfg_misc(snd_hda_codec_get_pincfg(codec, nid)) &
40	     AC_DEFCFG_MISC_NO_PRESENCE)
41		return false;
42	if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) &&
43	    !codec->jackpoll_interval)
44		return false;
45	return true;
46}
47EXPORT_SYMBOL_GPL(is_jack_detectable);
48
49/* execute pin sense measurement */
50static u32 read_pin_sense(struct hda_codec *codec, hda_nid_t nid)
51{
52	u32 pincap;
53	u32 val;
54
55	if (!codec->no_trigger_sense) {
56		pincap = snd_hda_query_pin_caps(codec, nid);
57		if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */
58			snd_hda_codec_read(codec, nid, 0,
59					AC_VERB_SET_PIN_SENSE, 0);
60	}
61	val = snd_hda_codec_read(codec, nid, 0,
62				  AC_VERB_GET_PIN_SENSE, 0);
63	if (codec->inv_jack_detect)
64		val ^= AC_PINSENSE_PRESENCE;
65	return val;
66}
67
68/**
69 * snd_hda_jack_tbl_get - query the jack-table entry for the given NID
70 * @codec: the HDA codec
71 * @nid: pin NID to refer to
72 */
73struct hda_jack_tbl *
74snd_hda_jack_tbl_get(struct hda_codec *codec, hda_nid_t nid)
75{
76	struct hda_jack_tbl *jack = codec->jacktbl.list;
77	int i;
78
79	if (!nid || !jack)
80		return NULL;
81	for (i = 0; i < codec->jacktbl.used; i++, jack++)
82		if (jack->nid == nid)
83			return jack;
84	return NULL;
85}
86EXPORT_SYMBOL_GPL(snd_hda_jack_tbl_get);
87
88/**
89 * snd_hda_jack_tbl_get_from_tag - query the jack-table entry for the given tag
90 * @codec: the HDA codec
91 * @tag: tag value to refer to
92 */
93struct hda_jack_tbl *
94snd_hda_jack_tbl_get_from_tag(struct hda_codec *codec, unsigned char tag)
95{
96	struct hda_jack_tbl *jack = codec->jacktbl.list;
97	int i;
98
99	if (!tag || !jack)
100		return NULL;
101	for (i = 0; i < codec->jacktbl.used; i++, jack++)
102		if (jack->tag == tag)
103			return jack;
104	return NULL;
105}
106EXPORT_SYMBOL_GPL(snd_hda_jack_tbl_get_from_tag);
107
108/**
109 * snd_hda_jack_tbl_new - create a jack-table entry for the given NID
110 * @codec: the HDA codec
111 * @nid: pin NID to assign
112 */
113static struct hda_jack_tbl *
114snd_hda_jack_tbl_new(struct hda_codec *codec, hda_nid_t nid)
115{
116	struct hda_jack_tbl *jack = snd_hda_jack_tbl_get(codec, nid);
117	if (jack)
118		return jack;
119	jack = snd_array_new(&codec->jacktbl);
120	if (!jack)
121		return NULL;
122	jack->nid = nid;
123	jack->jack_dirty = 1;
124	jack->tag = codec->jacktbl.used;
125	return jack;
126}
127
128void snd_hda_jack_tbl_clear(struct hda_codec *codec)
129{
130	struct hda_jack_tbl *jack = codec->jacktbl.list;
131	int i;
132
133	for (i = 0; i < codec->jacktbl.used; i++, jack++) {
134		struct hda_jack_callback *cb, *next;
135#ifdef CONFIG_SND_HDA_INPUT_JACK
136		/* free jack instances manually when clearing/reconfiguring */
137		if (!codec->bus->shutdown && jack->jack)
138			snd_device_free(codec->card, jack->jack);
139#endif
140		for (cb = jack->callback; cb; cb = next) {
141			next = cb->next;
142			kfree(cb);
143		}
144	}
145	snd_array_free(&codec->jacktbl);
146}
147
148#define get_jack_plug_state(sense) !!(sense & AC_PINSENSE_PRESENCE)
149
150/* update the cached value and notification flag if needed */
151static void jack_detect_update(struct hda_codec *codec,
152			       struct hda_jack_tbl *jack)
153{
154	if (!jack->jack_dirty)
155		return;
156
157	if (jack->phantom_jack)
158		jack->pin_sense = AC_PINSENSE_PRESENCE;
159	else
160		jack->pin_sense = read_pin_sense(codec, jack->nid);
161
162	/* A gating jack indicates the jack is invalid if gating is unplugged */
163	if (jack->gating_jack && !snd_hda_jack_detect(codec, jack->gating_jack))
164		jack->pin_sense &= ~AC_PINSENSE_PRESENCE;
165
166	jack->jack_dirty = 0;
167
168	/* If a jack is gated by this one update it. */
169	if (jack->gated_jack) {
170		struct hda_jack_tbl *gated =
171			snd_hda_jack_tbl_get(codec, jack->gated_jack);
172		if (gated) {
173			gated->jack_dirty = 1;
174			jack_detect_update(codec, gated);
175		}
176	}
177}
178
179/**
180 * snd_hda_set_dirty_all - Mark all the cached as dirty
181 * @codec: the HDA codec
182 *
183 * This function sets the dirty flag to all entries of jack table.
184 * It's called from the resume path in hda_codec.c.
185 */
186void snd_hda_jack_set_dirty_all(struct hda_codec *codec)
187{
188	struct hda_jack_tbl *jack = codec->jacktbl.list;
189	int i;
190
191	for (i = 0; i < codec->jacktbl.used; i++, jack++)
192		if (jack->nid)
193			jack->jack_dirty = 1;
194}
195EXPORT_SYMBOL_GPL(snd_hda_jack_set_dirty_all);
196
197/**
198 * snd_hda_pin_sense - execute pin sense measurement
199 * @codec: the CODEC to sense
200 * @nid: the pin NID to sense
201 *
202 * Execute necessary pin sense measurement and return its Presence Detect,
203 * Impedance, ELD Valid etc. status bits.
204 */
205u32 snd_hda_pin_sense(struct hda_codec *codec, hda_nid_t nid)
206{
207	struct hda_jack_tbl *jack = snd_hda_jack_tbl_get(codec, nid);
208	if (jack) {
209		jack_detect_update(codec, jack);
210		return jack->pin_sense;
211	}
212	return read_pin_sense(codec, nid);
213}
214EXPORT_SYMBOL_GPL(snd_hda_pin_sense);
215
216/**
217 * snd_hda_jack_detect_state - query pin Presence Detect status
218 * @codec: the CODEC to sense
219 * @nid: the pin NID to sense
220 *
221 * Query and return the pin's Presence Detect status, as either
222 * HDA_JACK_NOT_PRESENT, HDA_JACK_PRESENT or HDA_JACK_PHANTOM.
223 */
224int snd_hda_jack_detect_state(struct hda_codec *codec, hda_nid_t nid)
225{
226	struct hda_jack_tbl *jack = snd_hda_jack_tbl_get(codec, nid);
227	if (jack && jack->phantom_jack)
228		return HDA_JACK_PHANTOM;
229	else if (snd_hda_pin_sense(codec, nid) & AC_PINSENSE_PRESENCE)
230		return HDA_JACK_PRESENT;
231	else
232		return HDA_JACK_NOT_PRESENT;
233}
234EXPORT_SYMBOL_GPL(snd_hda_jack_detect_state);
235
236/**
237 * snd_hda_jack_detect_enable - enable the jack-detection
238 * @codec: the HDA codec
239 * @nid: pin NID to enable
240 * @func: callback function to register
241 *
242 * In the case of error, the return value will be a pointer embedded with
243 * errno.  Check and handle the return value appropriately with standard
244 * macros such as @IS_ERR() and @PTR_ERR().
245 */
246struct hda_jack_callback *
247snd_hda_jack_detect_enable_callback(struct hda_codec *codec, hda_nid_t nid,
248				    hda_jack_callback_fn func)
249{
250	struct hda_jack_tbl *jack;
251	struct hda_jack_callback *callback = NULL;
252	int err;
253
254	jack = snd_hda_jack_tbl_new(codec, nid);
255	if (!jack)
256		return ERR_PTR(-ENOMEM);
257	if (func) {
258		callback = kzalloc(sizeof(*callback), GFP_KERNEL);
259		if (!callback)
260			return ERR_PTR(-ENOMEM);
261		callback->func = func;
262		callback->nid = jack->nid;
263		callback->next = jack->callback;
264		jack->callback = callback;
265	}
266
267	if (jack->jack_detect)
268		return callback; /* already registered */
269	jack->jack_detect = 1;
270	if (codec->jackpoll_interval > 0)
271		return callback; /* No unsol if we're polling instead */
272	err = snd_hda_codec_write_cache(codec, nid, 0,
273					 AC_VERB_SET_UNSOLICITED_ENABLE,
274					 AC_USRSP_EN | jack->tag);
275	if (err < 0)
276		return ERR_PTR(err);
277	return callback;
278}
279EXPORT_SYMBOL_GPL(snd_hda_jack_detect_enable_callback);
280
281/**
282 * snd_hda_jack_detect_enable - Enable the jack detection on the given pin
283 * @codec: the HDA codec
284 * @nid: pin NID to enable jack detection
285 *
286 * Enable the jack detection with the default callback.  Returns zero if
287 * successful or a negative error code.
288 */
289int snd_hda_jack_detect_enable(struct hda_codec *codec, hda_nid_t nid)
290{
291	return PTR_ERR_OR_ZERO(snd_hda_jack_detect_enable_callback(codec, nid, NULL));
292}
293EXPORT_SYMBOL_GPL(snd_hda_jack_detect_enable);
294
295/**
296 * snd_hda_jack_set_gating_jack - Set gating jack.
297 * @codec: the HDA codec
298 * @gated_nid: gated pin NID
299 * @gating_nid: gating pin NID
300 *
301 * Indicates the gated jack is only valid when the gating jack is plugged.
302 */
303int snd_hda_jack_set_gating_jack(struct hda_codec *codec, hda_nid_t gated_nid,
304				 hda_nid_t gating_nid)
305{
306	struct hda_jack_tbl *gated = snd_hda_jack_tbl_new(codec, gated_nid);
307	struct hda_jack_tbl *gating = snd_hda_jack_tbl_new(codec, gating_nid);
308
309	if (!gated || !gating)
310		return -EINVAL;
311
312	gated->gating_jack = gating_nid;
313	gating->gated_jack = gated_nid;
314
315	return 0;
316}
317EXPORT_SYMBOL_GPL(snd_hda_jack_set_gating_jack);
318
319/**
320 * snd_hda_jack_report_sync - sync the states of all jacks and report if changed
321 * @codec: the HDA codec
322 */
323void snd_hda_jack_report_sync(struct hda_codec *codec)
324{
325	struct hda_jack_tbl *jack;
326	int i, state;
327
328	/* update all jacks at first */
329	jack = codec->jacktbl.list;
330	for (i = 0; i < codec->jacktbl.used; i++, jack++)
331		if (jack->nid)
332			jack_detect_update(codec, jack);
333
334	/* report the updated jacks; it's done after updating all jacks
335	 * to make sure that all gating jacks properly have been set
336	 */
337	jack = codec->jacktbl.list;
338	for (i = 0; i < codec->jacktbl.used; i++, jack++)
339		if (jack->nid) {
340			if (!jack->kctl || jack->block_report)
341				continue;
342			state = get_jack_plug_state(jack->pin_sense);
343			snd_kctl_jack_report(codec->card, jack->kctl, state);
344#ifdef CONFIG_SND_HDA_INPUT_JACK
345			if (jack->jack)
346				snd_jack_report(jack->jack,
347						state ? jack->type : 0);
348#endif
349		}
350}
351EXPORT_SYMBOL_GPL(snd_hda_jack_report_sync);
352
353#ifdef CONFIG_SND_HDA_INPUT_JACK
354/* guess the jack type from the pin-config */
355static int get_input_jack_type(struct hda_codec *codec, hda_nid_t nid)
356{
357	unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
358	switch (get_defcfg_device(def_conf)) {
359	case AC_JACK_LINE_OUT:
360	case AC_JACK_SPEAKER:
361		return SND_JACK_LINEOUT;
362	case AC_JACK_HP_OUT:
363		return SND_JACK_HEADPHONE;
364	case AC_JACK_SPDIF_OUT:
365	case AC_JACK_DIG_OTHER_OUT:
366		return SND_JACK_AVOUT;
367	case AC_JACK_MIC_IN:
368		return SND_JACK_MICROPHONE;
369	default:
370		return SND_JACK_LINEIN;
371	}
372}
373
374static void hda_free_jack_priv(struct snd_jack *jack)
375{
376	struct hda_jack_tbl *jacks = jack->private_data;
377	jacks->nid = 0;
378	jacks->jack = NULL;
379}
380#endif
381
382/**
383 * snd_hda_jack_add_kctl - Add a kctl for the given pin
384 * @codec: the HDA codec
385 * @nid: pin NID to assign
386 * @name: string name for the jack
387 * @idx: index number for the jack
388 * @phantom_jack: flag to deal as a phantom jack
389 *
390 * This assigns a jack-detection kctl to the given pin.  The kcontrol
391 * will have the given name and index.
392 */
393static int __snd_hda_jack_add_kctl(struct hda_codec *codec, hda_nid_t nid,
394			  const char *name, int idx, bool phantom_jack)
395{
396	struct hda_jack_tbl *jack;
397	struct snd_kcontrol *kctl;
398	int err, state;
399
400	jack = snd_hda_jack_tbl_new(codec, nid);
401	if (!jack)
402		return 0;
403	if (jack->kctl)
404		return 0; /* already created */
405	kctl = snd_kctl_jack_new(name, idx, codec);
406	if (!kctl)
407		return -ENOMEM;
408	err = snd_hda_ctl_add(codec, nid, kctl);
409	if (err < 0)
410		return err;
411	jack->kctl = kctl;
412	jack->phantom_jack = !!phantom_jack;
413
414	state = snd_hda_jack_detect(codec, nid);
415	snd_kctl_jack_report(codec->card, kctl, state);
416#ifdef CONFIG_SND_HDA_INPUT_JACK
417	if (!phantom_jack) {
418		jack->type = get_input_jack_type(codec, nid);
419		err = snd_jack_new(codec->card, name, jack->type,
420				   &jack->jack);
421		if (err < 0)
422			return err;
423		jack->jack->private_data = jack;
424		jack->jack->private_free = hda_free_jack_priv;
425		snd_jack_report(jack->jack, state ? jack->type : 0);
426	}
427#endif
428	return 0;
429}
430
431/**
432 * snd_hda_jack_add_kctl - Add a jack kctl for the given pin
433 * @codec: the HDA codec
434 * @nid: pin NID
435 * @name: the name string for the jack ctl
436 * @idx: the ctl index for the jack ctl
437 *
438 * This is a simple helper calling __snd_hda_jack_add_kctl().
439 */
440int snd_hda_jack_add_kctl(struct hda_codec *codec, hda_nid_t nid,
441			  const char *name, int idx)
442{
443	return __snd_hda_jack_add_kctl(codec, nid, name, idx, false);
444}
445EXPORT_SYMBOL_GPL(snd_hda_jack_add_kctl);
446
447/* get the unique index number for the given kctl name */
448static int get_unique_index(struct hda_codec *codec, const char *name, int idx)
449{
450	struct hda_jack_tbl *jack;
451	int i, len = strlen(name);
452 again:
453	jack = codec->jacktbl.list;
454	for (i = 0; i < codec->jacktbl.used; i++, jack++) {
455		/* jack->kctl.id contains "XXX Jack" name string with index */
456		if (jack->kctl &&
457		    !strncmp(name, jack->kctl->id.name, len) &&
458		    !strcmp(" Jack", jack->kctl->id.name + len) &&
459		    jack->kctl->id.index == idx) {
460			idx++;
461			goto again;
462		}
463	}
464	return idx;
465}
466
467static int add_jack_kctl(struct hda_codec *codec, hda_nid_t nid,
468			 const struct auto_pin_cfg *cfg,
469			 const char *base_name)
470{
471	unsigned int def_conf, conn;
472	char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
473	int idx, err;
474	bool phantom_jack;
475
476	if (!nid)
477		return 0;
478	def_conf = snd_hda_codec_get_pincfg(codec, nid);
479	conn = get_defcfg_connect(def_conf);
480	if (conn == AC_JACK_PORT_NONE)
481		return 0;
482	phantom_jack = (conn != AC_JACK_PORT_COMPLEX) ||
483		       !is_jack_detectable(codec, nid);
484
485	if (base_name) {
486		strlcpy(name, base_name, sizeof(name));
487		idx = 0;
488	} else
489		snd_hda_get_pin_label(codec, nid, cfg, name, sizeof(name), &idx);
490	if (phantom_jack)
491		/* Example final name: "Internal Mic Phantom Jack" */
492		strncat(name, " Phantom", sizeof(name) - strlen(name) - 1);
493	idx = get_unique_index(codec, name, idx);
494	err = __snd_hda_jack_add_kctl(codec, nid, name, idx, phantom_jack);
495	if (err < 0)
496		return err;
497
498	if (!phantom_jack)
499		return snd_hda_jack_detect_enable(codec, nid);
500	return 0;
501}
502
503/**
504 * snd_hda_jack_add_kctls - Add kctls for all pins included in the given pincfg
505 * @codec: the HDA codec
506 * @cfg: pin config table to parse
507 */
508int snd_hda_jack_add_kctls(struct hda_codec *codec,
509			   const struct auto_pin_cfg *cfg)
510{
511	const hda_nid_t *p;
512	int i, err;
513
514	for (i = 0; i < cfg->num_inputs; i++) {
515		/* If we have headphone mics; make sure they get the right name
516		   before grabbed by output pins */
517		if (cfg->inputs[i].is_headphone_mic) {
518			if (auto_cfg_hp_outs(cfg) == 1)
519				err = add_jack_kctl(codec, auto_cfg_hp_pins(cfg)[0],
520						    cfg, "Headphone Mic");
521			else
522				err = add_jack_kctl(codec, cfg->inputs[i].pin,
523						    cfg, "Headphone Mic");
524		} else
525			err = add_jack_kctl(codec, cfg->inputs[i].pin, cfg,
526					    NULL);
527		if (err < 0)
528			return err;
529	}
530
531	for (i = 0, p = cfg->line_out_pins; i < cfg->line_outs; i++, p++) {
532		err = add_jack_kctl(codec, *p, cfg, NULL);
533		if (err < 0)
534			return err;
535	}
536	for (i = 0, p = cfg->hp_pins; i < cfg->hp_outs; i++, p++) {
537		if (*p == *cfg->line_out_pins) /* might be duplicated */
538			break;
539		err = add_jack_kctl(codec, *p, cfg, NULL);
540		if (err < 0)
541			return err;
542	}
543	for (i = 0, p = cfg->speaker_pins; i < cfg->speaker_outs; i++, p++) {
544		if (*p == *cfg->line_out_pins) /* might be duplicated */
545			break;
546		err = add_jack_kctl(codec, *p, cfg, NULL);
547		if (err < 0)
548			return err;
549	}
550	for (i = 0, p = cfg->dig_out_pins; i < cfg->dig_outs; i++, p++) {
551		err = add_jack_kctl(codec, *p, cfg, NULL);
552		if (err < 0)
553			return err;
554	}
555	err = add_jack_kctl(codec, cfg->dig_in_pin, cfg, NULL);
556	if (err < 0)
557		return err;
558	err = add_jack_kctl(codec, cfg->mono_out_pin, cfg, NULL);
559	if (err < 0)
560		return err;
561	return 0;
562}
563EXPORT_SYMBOL_GPL(snd_hda_jack_add_kctls);
564
565static void call_jack_callback(struct hda_codec *codec,
566			       struct hda_jack_tbl *jack)
567{
568	struct hda_jack_callback *cb;
569
570	for (cb = jack->callback; cb; cb = cb->next)
571		cb->func(codec, cb);
572	if (jack->gated_jack) {
573		struct hda_jack_tbl *gated =
574			snd_hda_jack_tbl_get(codec, jack->gated_jack);
575		if (gated) {
576			for (cb = gated->callback; cb; cb = cb->next)
577				cb->func(codec, cb);
578		}
579	}
580}
581
582/**
583 * snd_hda_jack_unsol_event - Handle an unsolicited event
584 * @codec: the HDA codec
585 * @res: the unsolicited event data
586 */
587void snd_hda_jack_unsol_event(struct hda_codec *codec, unsigned int res)
588{
589	struct hda_jack_tbl *event;
590	int tag = (res >> AC_UNSOL_RES_TAG_SHIFT) & 0x7f;
591
592	event = snd_hda_jack_tbl_get_from_tag(codec, tag);
593	if (!event)
594		return;
595	event->jack_dirty = 1;
596
597	call_jack_callback(codec, event);
598	snd_hda_jack_report_sync(codec);
599}
600EXPORT_SYMBOL_GPL(snd_hda_jack_unsol_event);
601
602/**
603 * snd_hda_jack_poll_all - Poll all jacks
604 * @codec: the HDA codec
605 *
606 * Poll all detectable jacks with dirty flag, update the status, call
607 * callbacks and call snd_hda_jack_report_sync() if any changes are found.
608 */
609void snd_hda_jack_poll_all(struct hda_codec *codec)
610{
611	struct hda_jack_tbl *jack = codec->jacktbl.list;
612	int i, changes = 0;
613
614	for (i = 0; i < codec->jacktbl.used; i++, jack++) {
615		unsigned int old_sense;
616		if (!jack->nid || !jack->jack_dirty || jack->phantom_jack)
617			continue;
618		old_sense = get_jack_plug_state(jack->pin_sense);
619		jack_detect_update(codec, jack);
620		if (old_sense == get_jack_plug_state(jack->pin_sense))
621			continue;
622		changes = 1;
623		call_jack_callback(codec, jack);
624	}
625	if (changes)
626		snd_hda_jack_report_sync(codec);
627}
628EXPORT_SYMBOL_GPL(snd_hda_jack_poll_all);
629
630