[GitHub/mt8127/android_kernel_alcatel_ttab.git] / sound / pci / hda / hda_jack.c

/*
 * Jack-detection handling for HD-audio
 *
 * Copyright (c) 2011 Takashi Iwai <tiwai@suse.de>
 *
 * This driver is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */

#include <linux/init.h>
#include <linux/slab.h>
#include <linux/export.h>
#include <sound/core.h>
#include <sound/control.h>
#include <sound/jack.h>
#include "hda_codec.h"
#include "hda_local.h"
#include "hda_auto_parser.h"
#include "hda_jack.h"

bool is_jack_detectable(struct hda_codec *codec, hda_nid_t nid)
{
	if (codec->no_jack_detect)
		return false;
	if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_PRES_DETECT))
		return false;
	if (get_defcfg_misc(snd_hda_codec_get_pincfg(codec, nid)) &
	     AC_DEFCFG_MISC_NO_PRESENCE)
		return false;
	if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP))
		return false;
	return true;
}
EXPORT_SYMBOL_HDA(is_jack_detectable);

/* execute pin sense measurement */
static u32 read_pin_sense(struct hda_codec *codec, hda_nid_t nid)
{
	u32 pincap;

	if (!codec->no_trigger_sense) {
		pincap = snd_hda_query_pin_caps(codec, nid);
		if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */
			snd_hda_codec_read(codec, nid, 0,
					AC_VERB_SET_PIN_SENSE, 0);
	}
	return snd_hda_codec_read(codec, nid, 0,
				  AC_VERB_GET_PIN_SENSE, 0);
}

/**
 * snd_hda_jack_tbl_get - query the jack-table entry for the given NID
 */
struct hda_jack_tbl *
snd_hda_jack_tbl_get(struct hda_codec *codec, hda_nid_t nid)
{
	struct hda_jack_tbl *jack = codec->jacktbl.list;
	int i;

	if (!nid || !jack)
		return NULL;
	for (i = 0; i < codec->jacktbl.used; i++, jack++)
		if (jack->nid == nid)
			return jack;
	return NULL;
}
EXPORT_SYMBOL_HDA(snd_hda_jack_tbl_get);

/**
 * snd_hda_jack_tbl_get_from_tag - query the jack-table entry for the given tag
 */
struct hda_jack_tbl *
snd_hda_jack_tbl_get_from_tag(struct hda_codec *codec, unsigned char tag)
{
	struct hda_jack_tbl *jack = codec->jacktbl.list;
	int i;

	if (!tag || !jack)
		return NULL;
	for (i = 0; i < codec->jacktbl.used; i++, jack++)
		if (jack->tag == tag)
			return jack;
	return NULL;
}
EXPORT_SYMBOL_HDA(snd_hda_jack_tbl_get_from_tag);

/**
 * snd_hda_jack_tbl_new - create a jack-table entry for the given NID
 */
struct hda_jack_tbl *
snd_hda_jack_tbl_new(struct hda_codec *codec, hda_nid_t nid)
{
	struct hda_jack_tbl *jack = snd_hda_jack_tbl_get(codec, nid);
	if (jack)
		return jack;
	snd_array_init(&codec->jacktbl, sizeof(*jack), 16);
	jack = snd_array_new(&codec->jacktbl);
	if (!jack)
		return NULL;
	jack->nid = nid;
	jack->jack_dirty = 1;
	jack->tag = codec->jacktbl.used;
	return jack;
}
EXPORT_SYMBOL_HDA(snd_hda_jack_tbl_new);

void snd_hda_jack_tbl_clear(struct hda_codec *codec)
{
#ifdef CONFIG_SND_HDA_INPUT_JACK
	/* free jack instances manually when clearing/reconfiguring */
	if (!codec->bus->shutdown && codec->jacktbl.list) {
		struct hda_jack_tbl *jack = codec->jacktbl.list;
		int i;
		for (i = 0; i < codec->jacktbl.used; i++, jack++) {
			if (jack->jack)
				snd_device_free(codec->bus->card, jack->jack);
		}
	}
#endif
	snd_array_free(&codec->jacktbl);
}

/* update the cached value and notification flag if needed */
static void jack_detect_update(struct hda_codec *codec,
			       struct hda_jack_tbl *jack)
{
	if (!jack->jack_dirty)
		return;

	if (jack->phantom_jack)
		jack->pin_sense = AC_PINSENSE_PRESENCE;
	else
		jack->pin_sense = read_pin_sense(codec, jack->nid);

	jack->jack_dirty = 0;
}

/**
 * snd_hda_set_dirty_all - Mark all the cached as dirty
 *
 * This function sets the dirty flag to all entries of jack table.
 * It's called from the resume path in hda_codec.c.
 */
void snd_hda_jack_set_dirty_all(struct hda_codec *codec)
{
	struct hda_jack_tbl *jack = codec->jacktbl.list;
	int i;

	for (i = 0; i < codec->jacktbl.used; i++, jack++)
		if (jack->nid)
			jack->jack_dirty = 1;
}
EXPORT_SYMBOL_HDA(snd_hda_jack_set_dirty_all);

/**
 * snd_hda_pin_sense - execute pin sense measurement
 * @codec: the CODEC to sense
 * @nid: the pin NID to sense
 *
 * Execute necessary pin sense measurement and return its Presence Detect,
 * Impedance, ELD Valid etc. status bits.
 */
u32 snd_hda_pin_sense(struct hda_codec *codec, hda_nid_t nid)
{
	struct hda_jack_tbl *jack = snd_hda_jack_tbl_get(codec, nid);
	if (jack) {
		jack_detect_update(codec, jack);
		return jack->pin_sense;
	}
	return read_pin_sense(codec, nid);
}
EXPORT_SYMBOL_HDA(snd_hda_pin_sense);

#define get_jack_plug_state(sense) !!(sense & AC_PINSENSE_PRESENCE)

/**
 * snd_hda_jack_detect - query pin Presence Detect status
 * @codec: the CODEC to sense
 * @nid: the pin NID to sense
 *
 * Query and return the pin's Presence Detect status.
 */
int snd_hda_jack_detect(struct hda_codec *codec, hda_nid_t nid)
{
	u32 sense = snd_hda_pin_sense(codec, nid);
	return get_jack_plug_state(sense);
}
EXPORT_SYMBOL_HDA(snd_hda_jack_detect);

/**
 * snd_hda_jack_detect_enable - enable the jack-detection
 */
int snd_hda_jack_detect_enable_callback(struct hda_codec *codec, hda_nid_t nid,
					unsigned char action,
					hda_jack_callback cb)
{
	struct hda_jack_tbl *jack = snd_hda_jack_tbl_new(codec, nid);
	if (!jack)
		return -ENOMEM;
	if (jack->jack_detect)
		return 0; /* already registered */
	jack->jack_detect = 1;
	if (action)
		jack->action = action;
	if (cb)
		jack->callback = cb;
	return snd_hda_codec_write_cache(codec, nid, 0,
					 AC_VERB_SET_UNSOLICITED_ENABLE,
					 AC_USRSP_EN | jack->tag);
}
EXPORT_SYMBOL_HDA(snd_hda_jack_detect_enable_callback);

int snd_hda_jack_detect_enable(struct hda_codec *codec, hda_nid_t nid,
			       unsigned char action)
{
	return snd_hda_jack_detect_enable_callback(codec, nid, action, NULL);
}
EXPORT_SYMBOL_HDA(snd_hda_jack_detect_enable);

/**
 * snd_hda_jack_report_sync - sync the states of all jacks and report if changed
 */
void snd_hda_jack_report_sync(struct hda_codec *codec)
{
	struct hda_jack_tbl *jack = codec->jacktbl.list;
	int i, state;

	for (i = 0; i < codec->jacktbl.used; i++, jack++)
		if (jack->nid) {
			jack_detect_update(codec, jack);
			if (!jack->kctl)
				continue;
			state = get_jack_plug_state(jack->pin_sense);
			snd_kctl_jack_report(codec->bus->card, jack->kctl, state);
#ifdef CONFIG_SND_HDA_INPUT_JACK
			if (jack->jack)
				snd_jack_report(jack->jack,
						state ? jack->type : 0);
#endif
		}
}
EXPORT_SYMBOL_HDA(snd_hda_jack_report_sync);

#ifdef CONFIG_SND_HDA_INPUT_JACK
/* guess the jack type from the pin-config */
static int get_input_jack_type(struct hda_codec *codec, hda_nid_t nid)
{
	unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
	switch (get_defcfg_device(def_conf)) {
	case AC_JACK_LINE_OUT:
	case AC_JACK_SPEAKER:
		return SND_JACK_LINEOUT;
	case AC_JACK_HP_OUT:
		return SND_JACK_HEADPHONE;
	case AC_JACK_SPDIF_OUT:
	case AC_JACK_DIG_OTHER_OUT:
		return SND_JACK_AVOUT;
	case AC_JACK_MIC_IN:
		return SND_JACK_MICROPHONE;
	default:
		return SND_JACK_LINEIN;
	}
}

static void hda_free_jack_priv(struct snd_jack *jack)
{
	struct hda_jack_tbl *jacks = jack->private_data;
	jacks->nid = 0;
	jacks->jack = NULL;
}
#endif

/**
 * snd_hda_jack_add_kctl - Add a kctl for the given pin
 *
 * This assigns a jack-detection kctl to the given pin.  The kcontrol
 * will have the given name and index.
 */
static int __snd_hda_jack_add_kctl(struct hda_codec *codec, hda_nid_t nid,
			  const char *name, int idx, bool phantom_jack)
{
	struct hda_jack_tbl *jack;
	struct snd_kcontrol *kctl;
	int err, state;

	jack = snd_hda_jack_tbl_new(codec, nid);
	if (!jack)
		return 0;
	if (jack->kctl)
		return 0; /* already created */
	kctl = snd_kctl_jack_new(name, idx, codec);
	if (!kctl)
		return -ENOMEM;
	err = snd_hda_ctl_add(codec, nid, kctl);
	if (err < 0)
		return err;
	jack->kctl = kctl;
	jack->phantom_jack = !!phantom_jack;

	state = snd_hda_jack_detect(codec, nid);
	snd_kctl_jack_report(codec->bus->card, kctl, state);
#ifdef CONFIG_SND_HDA_INPUT_JACK
	if (!phantom_jack) {
		jack->type = get_input_jack_type(codec, nid);
		err = snd_jack_new(codec->bus->card, name, jack->type,
				   &jack->jack);
		if (err < 0)
			return err;
		jack->jack->private_data = jack;
		jack->jack->private_free = hda_free_jack_priv;
		snd_jack_report(jack->jack, state ? jack->type : 0);
	}
#endif
	return 0;
}

int snd_hda_jack_add_kctl(struct hda_codec *codec, hda_nid_t nid,
			  const char *name, int idx)
{
	return __snd_hda_jack_add_kctl(codec, nid, name, idx, false);
}
EXPORT_SYMBOL_HDA(snd_hda_jack_add_kctl);

/* get the unique index number for the given kctl name */
static int get_unique_index(struct hda_codec *codec, const char *name, int idx)
{
	struct hda_jack_tbl *jack;
	int i, len = strlen(name);
 again:
	jack = codec->jacktbl.list;
	for (i = 0; i < codec->jacktbl.used; i++, jack++) {
		/* jack->kctl.id contains "XXX Jack" name string with index */
		if (jack->kctl &&
		    !strncmp(name, jack->kctl->id.name, len) &&
		    !strcmp(" Jack", jack->kctl->id.name + len) &&
		    jack->kctl->id.index == idx) {
			idx++;
			goto again;
		}
	}
	return idx;
}

static int add_jack_kctl(struct hda_codec *codec, hda_nid_t nid,
			 const struct auto_pin_cfg *cfg)
{
	unsigned int def_conf, conn;
	char name[44];
	int idx, err;
	bool phantom_jack;

	if (!nid)
		return 0;
	def_conf = snd_hda_codec_get_pincfg(codec, nid);
	conn = get_defcfg_connect(def_conf);
	if (conn == AC_JACK_PORT_NONE)
		return 0;
	phantom_jack = (conn != AC_JACK_PORT_COMPLEX) ||
		       !is_jack_detectable(codec, nid);

	snd_hda_get_pin_label(codec, nid, cfg, name, sizeof(name), &idx);
	if (phantom_jack)
		/* Example final name: "Internal Mic Phantom Jack" */
		strncat(name, " Phantom", sizeof(name) - strlen(name) - 1);
	idx = get_unique_index(codec, name, idx);
	err = __snd_hda_jack_add_kctl(codec, nid, name, idx, phantom_jack);
	if (err < 0)
		return err;

	if (!phantom_jack)
		return snd_hda_jack_detect_enable(codec, nid, 0);
	return 0;
}

/**
 * snd_hda_jack_add_kctls - Add kctls for all pins included in the given pincfg
 */
int snd_hda_jack_add_kctls(struct hda_codec *codec,
			   const struct auto_pin_cfg *cfg)
{
	const hda_nid_t *p;
	int i, err;

	for (i = 0, p = cfg->line_out_pins; i < cfg->line_outs; i++, p++) {
		err = add_jack_kctl(codec, *p, cfg);
		if (err < 0)
			return err;
	}
	for (i = 0, p = cfg->hp_pins; i < cfg->hp_outs; i++, p++) {
		if (*p == *cfg->line_out_pins) /* might be duplicated */
			break;
		err = add_jack_kctl(codec, *p, cfg);
		if (err < 0)
			return err;
	}
	for (i = 0, p = cfg->speaker_pins; i < cfg->speaker_outs; i++, p++) {
		if (*p == *cfg->line_out_pins) /* might be duplicated */
			break;
		err = add_jack_kctl(codec, *p, cfg);
		if (err < 0)
			return err;
	}
	for (i = 0; i < cfg->num_inputs; i++) {
		err = add_jack_kctl(codec, cfg->inputs[i].pin, cfg);
		if (err < 0)
			return err;
	}
	for (i = 0, p = cfg->dig_out_pins; i < cfg->dig_outs; i++, p++) {
		err = add_jack_kctl(codec, *p, cfg);
		if (err < 0)
			return err;
	}
	err = add_jack_kctl(codec, cfg->dig_in_pin, cfg);
	if (err < 0)
		return err;
	err = add_jack_kctl(codec, cfg->mono_out_pin, cfg);
	if (err < 0)
		return err;
	return 0;
}
EXPORT_SYMBOL_HDA(snd_hda_jack_add_kctls);

void snd_hda_jack_unsol_event(struct hda_codec *codec, unsigned int res)
{
	struct hda_jack_tbl *event;
	int tag = (res >> AC_UNSOL_RES_TAG_SHIFT) & 0x7f;

	event = snd_hda_jack_tbl_get_from_tag(codec, tag);
	if (!event)
		return;
	event->jack_dirty = 1;

	if (event->callback)
		event->callback(codec, event);

	snd_hda_jack_report_sync(codec);
}
EXPORT_SYMBOL_HDA(snd_hda_jack_unsol_event);
Commit	Line	Data
1835a0f9 TI	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>
bf815bf0	14	#include <linux/export.h>
1835a0f9	15	#include <sound/core.h>
01a61e12	16	#include <sound/control.h>
aad37dbd	17	#include <sound/jack.h>
1835a0f9 TI	18	#include "hda_codec.h"
1835a0f9 TI	19	#include "hda_local.h"
128bc4ba	20	#include "hda_auto_parser.h"
1835a0f9 TI	21	#include "hda_jack.h"
1835a0f9 TI	22
a9c74173 TI	23	bool is_jack_detectable(struct hda_codec *codec, hda_nid_t nid)
a9c74173 TI	24	{
71b1e9e4 TI	25	if (codec->no_jack_detect)
71b1e9e4 TI	26	return false;
a9c74173 TI	27	if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_PRES_DETECT))
a9c74173 TI	28	return false;
5fe8e1e6 DH	29	if (get_defcfg_misc(snd_hda_codec_get_pincfg(codec, nid)) &
5fe8e1e6 DH	30	AC_DEFCFG_MISC_NO_PRESENCE)
a9c74173 TI	31	return false;
	32	if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP))
	33	return false;
	34	return true;
	35	}
	36	EXPORT_SYMBOL_HDA(is_jack_detectable);
	37
1835a0f9 TI	38	/* execute pin sense measurement */
	39	static u32 read_pin_sense(struct hda_codec *codec, hda_nid_t nid)
	40	{
	41	u32 pincap;
	42
	43	if (!codec->no_trigger_sense) {
	44	pincap = snd_hda_query_pin_caps(codec, nid);
	45	if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */
	46	snd_hda_codec_read(codec, nid, 0,
	47	AC_VERB_SET_PIN_SENSE, 0);
	48	}
	49	return snd_hda_codec_read(codec, nid, 0,
	50	AC_VERB_GET_PIN_SENSE, 0);
	51	}
	52
	53	/**
	54	* snd_hda_jack_tbl_get - query the jack-table entry for the given NID
	55	*/
	56	struct hda_jack_tbl *
	57	snd_hda_jack_tbl_get(struct hda_codec *codec, hda_nid_t nid)
	58	{
	59	struct hda_jack_tbl *jack = codec->jacktbl.list;
	60	int i;
	61
	62	if (!nid \|\| !jack)
	63	return NULL;
	64	for (i = 0; i < codec->jacktbl.used; i++, jack++)
	65	if (jack->nid == nid)
	66	return jack;
	67	return NULL;
	68	}
	69	EXPORT_SYMBOL_HDA(snd_hda_jack_tbl_get);
	70
3a93897e TI	71	/**
	72	* snd_hda_jack_tbl_get_from_tag - query the jack-table entry for the given tag
	73	*/
	74	struct hda_jack_tbl *
	75	snd_hda_jack_tbl_get_from_tag(struct hda_codec *codec, unsigned char tag)
	76	{
	77	struct hda_jack_tbl *jack = codec->jacktbl.list;
	78	int i;
	79
	80	if (!tag \|\| !jack)
	81	return NULL;
	82	for (i = 0; i < codec->jacktbl.used; i++, jack++)
	83	if (jack->tag == tag)
	84	return jack;
	85	return NULL;
	86	}
	87	EXPORT_SYMBOL_HDA(snd_hda_jack_tbl_get_from_tag);
	88
1835a0f9 TI	89	/**
	90	* snd_hda_jack_tbl_new - create a jack-table entry for the given NID
	91	*/
	92	struct hda_jack_tbl *
	93	snd_hda_jack_tbl_new(struct hda_codec *codec, hda_nid_t nid)
	94	{
	95	struct hda_jack_tbl *jack = snd_hda_jack_tbl_get(codec, nid);
	96	if (jack)
	97	return jack;
	98	snd_array_init(&codec->jacktbl, sizeof(*jack), 16);
	99	jack = snd_array_new(&codec->jacktbl);
	100	if (!jack)
	101	return NULL;
	102	jack->nid = nid;
	103	jack->jack_dirty = 1;
3a93897e	104	jack->tag = codec->jacktbl.used;
1835a0f9 TI	105	return jack;
1835a0f9 TI	106	}
d1cb6200	107	EXPORT_SYMBOL_HDA(snd_hda_jack_tbl_new);
1835a0f9 TI	108
	109	void snd_hda_jack_tbl_clear(struct hda_codec *codec)
	110	{
31ef2257 TI	111	#ifdef CONFIG_SND_HDA_INPUT_JACK
	112	/* free jack instances manually when clearing/reconfiguring */
	113	if (!codec->bus->shutdown && codec->jacktbl.list) {
	114	struct hda_jack_tbl *jack = codec->jacktbl.list;
	115	int i;
	116	for (i = 0; i < codec->jacktbl.used; i++, jack++) {
	117	if (jack->jack)
	118	snd_device_free(codec->bus->card, jack->jack);
	119	}
	120	}
	121	#endif
1835a0f9 TI	122	snd_array_free(&codec->jacktbl);
	123	}
	124
	125	/* update the cached value and notification flag if needed */
	126	static void jack_detect_update(struct hda_codec *codec,
	127	struct hda_jack_tbl *jack)
	128	{
80c8bfbe DH	129	if (!jack->jack_dirty)
	130	return;
	131
	132	if (jack->phantom_jack)
	133	jack->pin_sense = AC_PINSENSE_PRESENCE;
	134	else
35be544a	135	jack->pin_sense = read_pin_sense(codec, jack->nid);
80c8bfbe DH	136
80c8bfbe DH	137	jack->jack_dirty = 0;
1835a0f9 TI	138	}
	139
	140	/**
	141	* snd_hda_set_dirty_all - Mark all the cached as dirty
	142	*
	143	* This function sets the dirty flag to all entries of jack table.
	144	* It's called from the resume path in hda_codec.c.
	145	*/
	146	void snd_hda_jack_set_dirty_all(struct hda_codec *codec)
	147	{
	148	struct hda_jack_tbl *jack = codec->jacktbl.list;
	149	int i;
	150
	151	for (i = 0; i < codec->jacktbl.used; i++, jack++)
	152	if (jack->nid)
	153	jack->jack_dirty = 1;
	154	}
	155	EXPORT_SYMBOL_HDA(snd_hda_jack_set_dirty_all);
	156
	157	/**
	158	* snd_hda_pin_sense - execute pin sense measurement
	159	* @codec: the CODEC to sense
	160	* @nid: the pin NID to sense
	161	*
	162	* Execute necessary pin sense measurement and return its Presence Detect,
	163	* Impedance, ELD Valid etc. status bits.
	164	*/
	165	u32 snd_hda_pin_sense(struct hda_codec *codec, hda_nid_t nid)
	166	{
	167	struct hda_jack_tbl *jack = snd_hda_jack_tbl_get(codec, nid);
	168	if (jack) {
	169	jack_detect_update(codec, jack);
	170	return jack->pin_sense;
	171	}
	172	return read_pin_sense(codec, nid);
	173	}
	174	EXPORT_SYMBOL_HDA(snd_hda_pin_sense);
	175
35be544a TI	176	#define get_jack_plug_state(sense) !!(sense & AC_PINSENSE_PRESENCE)
35be544a TI	177
1835a0f9 TI	178	/**
	179	* snd_hda_jack_detect - query pin Presence Detect status
	180	* @codec: the CODEC to sense
	181	* @nid: the pin NID to sense
	182	*
	183	* Query and return the pin's Presence Detect status.
	184	*/
	185	int snd_hda_jack_detect(struct hda_codec *codec, hda_nid_t nid)
	186	{
	187	u32 sense = snd_hda_pin_sense(codec, nid);
35be544a	188	return get_jack_plug_state(sense);
1835a0f9 TI	189	}
	190	EXPORT_SYMBOL_HDA(snd_hda_jack_detect);
	191
	192	/**
	193	* snd_hda_jack_detect_enable - enable the jack-detection
	194	*/
954df2a9 DH	195	int snd_hda_jack_detect_enable_callback(struct hda_codec *codec, hda_nid_t nid,
	196	unsigned char action,
	197	hda_jack_callback cb)
1835a0f9 TI	198	{
	199	struct hda_jack_tbl *jack = snd_hda_jack_tbl_new(codec, nid);
	200	if (!jack)
	201	return -ENOMEM;
3a93897e	202	if (jack->jack_detect)
01a61e12	203	return 0; /* already registered */
3a93897e TI	204	jack->jack_detect = 1;
	205	if (action)
	206	jack->action = action;
954df2a9 DH	207	if (cb)
954df2a9 DH	208	jack->callback = cb;
1835a0f9 TI	209	return snd_hda_codec_write_cache(codec, nid, 0,
1835a0f9 TI	210	AC_VERB_SET_UNSOLICITED_ENABLE,
3a93897e	211	AC_USRSP_EN \| jack->tag);
1835a0f9	212	}
954df2a9 DH	213	EXPORT_SYMBOL_HDA(snd_hda_jack_detect_enable_callback);
	214
	215	int snd_hda_jack_detect_enable(struct hda_codec *codec, hda_nid_t nid,
	216	unsigned char action)
	217	{
	218	return snd_hda_jack_detect_enable_callback(codec, nid, action, NULL);
	219	}
1835a0f9	220	EXPORT_SYMBOL_HDA(snd_hda_jack_detect_enable);
01a61e12	221
01a61e12 TI	222	/**
	223	* snd_hda_jack_report_sync - sync the states of all jacks and report if changed
	224	*/
	225	void snd_hda_jack_report_sync(struct hda_codec *codec)
	226	{
	227	struct hda_jack_tbl *jack = codec->jacktbl.list;
35be544a	228	int i, state;
01a61e12 TI	229
	230	for (i = 0; i < codec->jacktbl.used; i++, jack++)
	231	if (jack->nid) {
	232	jack_detect_update(codec, jack);
cfc7c9d3 TI	233	if (!jack->kctl)
cfc7c9d3 TI	234	continue;
35be544a	235	state = get_jack_plug_state(jack->pin_sense);
aad37dbd	236	snd_kctl_jack_report(codec->bus->card, jack->kctl, state);
31ef2257 TI	237	#ifdef CONFIG_SND_HDA_INPUT_JACK
	238	if (jack->jack)
	239	snd_jack_report(jack->jack,
	240	state ? jack->type : 0);
	241	#endif
01a61e12 TI	242	}
	243	}
	244	EXPORT_SYMBOL_HDA(snd_hda_jack_report_sync);
	245
31ef2257 TI	246	#ifdef CONFIG_SND_HDA_INPUT_JACK
	247	/* guess the jack type from the pin-config */
	248	static int get_input_jack_type(struct hda_codec *codec, hda_nid_t nid)
	249	{
	250	unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
	251	switch (get_defcfg_device(def_conf)) {
	252	case AC_JACK_LINE_OUT:
	253	case AC_JACK_SPEAKER:
	254	return SND_JACK_LINEOUT;
	255	case AC_JACK_HP_OUT:
	256	return SND_JACK_HEADPHONE;
	257	case AC_JACK_SPDIF_OUT:
	258	case AC_JACK_DIG_OTHER_OUT:
	259	return SND_JACK_AVOUT;
	260	case AC_JACK_MIC_IN:
	261	return SND_JACK_MICROPHONE;
	262	default:
	263	return SND_JACK_LINEIN;
	264	}
	265	}
	266
	267	static void hda_free_jack_priv(struct snd_jack *jack)
	268	{
	269	struct hda_jack_tbl *jacks = jack->private_data;
	270	jacks->nid = 0;
	271	jacks->jack = NULL;
	272	}
	273	#endif
	274
01a61e12 TI	275	/**
	276	* snd_hda_jack_add_kctl - Add a kctl for the given pin
	277	*
	278	* This assigns a jack-detection kctl to the given pin. The kcontrol
	279	* will have the given name and index.
	280	*/
80c8bfbe DH	281	static int __snd_hda_jack_add_kctl(struct hda_codec *codec, hda_nid_t nid,
80c8bfbe DH	282	const char *name, int idx, bool phantom_jack)
01a61e12 TI	283	{
	284	struct hda_jack_tbl *jack;
	285	struct snd_kcontrol *kctl;
31ef2257	286	int err, state;
01a61e12	287
3a93897e	288	jack = snd_hda_jack_tbl_new(codec, nid);
01a61e12 TI	289	if (!jack)
	290	return 0;
	291	if (jack->kctl)
	292	return 0; /* already created */
35be544a	293	kctl = snd_kctl_jack_new(name, idx, codec);
01a61e12 TI	294	if (!kctl)
01a61e12 TI	295	return -ENOMEM;
31ef2257 TI	296	err = snd_hda_ctl_add(codec, nid, kctl);
	297	if (err < 0)
	298	return err;
01a61e12	299	jack->kctl = kctl;
80c8bfbe DH	300	jack->phantom_jack = !!phantom_jack;
80c8bfbe DH	301
31ef2257 TI	302	state = snd_hda_jack_detect(codec, nid);
	303	snd_kctl_jack_report(codec->bus->card, kctl, state);
	304	#ifdef CONFIG_SND_HDA_INPUT_JACK
80c8bfbe DH	305	if (!phantom_jack) {
	306	jack->type = get_input_jack_type(codec, nid);
	307	err = snd_jack_new(codec->bus->card, name, jack->type,
	308	&jack->jack);
	309	if (err < 0)
	310	return err;
	311	jack->jack->private_data = jack;
	312	jack->jack->private_free = hda_free_jack_priv;
	313	snd_jack_report(jack->jack, state ? jack->type : 0);
	314	}
31ef2257	315	#endif
01a61e12 TI	316	return 0;
01a61e12 TI	317	}
80c8bfbe DH	318
	319	int snd_hda_jack_add_kctl(struct hda_codec *codec, hda_nid_t nid,
	320	const char *name, int idx)
	321	{
	322	return __snd_hda_jack_add_kctl(codec, nid, name, idx, false);
	323	}
d1cb6200	324	EXPORT_SYMBOL_HDA(snd_hda_jack_add_kctl);
01a61e12	325
f46c3296 TI	326	/* get the unique index number for the given kctl name */
	327	static int get_unique_index(struct hda_codec codec, const char name, int idx)
	328	{
	329	struct hda_jack_tbl *jack;
	330	int i, len = strlen(name);
	331	again:
	332	jack = codec->jacktbl.list;
	333	for (i = 0; i < codec->jacktbl.used; i++, jack++) {
	334	/* jack->kctl.id contains "XXX Jack" name string with index */
	335	if (jack->kctl &&
	336	!strncmp(name, jack->kctl->id.name, len) &&
	337	!strcmp(" Jack", jack->kctl->id.name + len) &&
	338	jack->kctl->id.index == idx) {
	339	idx++;
	340	goto again;
	341	}
	342	}
	343	return idx;
	344	}
	345
201e06ff	346	static int add_jack_kctl(struct hda_codec *codec, hda_nid_t nid,
f46c3296	347	const struct auto_pin_cfg *cfg)
01a61e12	348	{
3a93897e	349	unsigned int def_conf, conn;
201e06ff TI	350	char name[44];
201e06ff TI	351	int idx, err;
80c8bfbe	352	bool phantom_jack;
3a93897e	353
01a61e12 TI	354	if (!nid)
01a61e12 TI	355	return 0;
3a93897e TI	356	def_conf = snd_hda_codec_get_pincfg(codec, nid);
3a93897e TI	357	conn = get_defcfg_connect(def_conf);
80c8bfbe	358	if (conn == AC_JACK_PORT_NONE)
3a93897e	359	return 0;
80c8bfbe DH	360	phantom_jack = (conn != AC_JACK_PORT_COMPLEX) \|\|
80c8bfbe DH	361	!is_jack_detectable(codec, nid);
3a93897e	362
201e06ff	363	snd_hda_get_pin_label(codec, nid, cfg, name, sizeof(name), &idx);
80c8bfbe DH	364	if (phantom_jack)
	365	/* Example final name: "Internal Mic Phantom Jack" */
	366	strncat(name, " Phantom", sizeof(name) - strlen(name) - 1);
f46c3296	367	idx = get_unique_index(codec, name, idx);
80c8bfbe	368	err = __snd_hda_jack_add_kctl(codec, nid, name, idx, phantom_jack);
3a93897e TI	369	if (err < 0)
3a93897e TI	370	return err;
80c8bfbe DH	371
	372	if (!phantom_jack)
	373	return snd_hda_jack_detect_enable(codec, nid, 0);
	374	return 0;
01a61e12 TI	375	}
	376
	377	/**
	378	* snd_hda_jack_add_kctls - Add kctls for all pins included in the given pincfg
01a61e12 TI	379	*/
	380	int snd_hda_jack_add_kctls(struct hda_codec *codec,
	381	const struct auto_pin_cfg *cfg)
	382	{
	383	const hda_nid_t *p;
f46c3296	384	int i, err;
01a61e12 TI	385
01a61e12 TI	386	for (i = 0, p = cfg->line_out_pins; i < cfg->line_outs; i++, p++) {
f46c3296	387	err = add_jack_kctl(codec, *p, cfg);
01a61e12 TI	388	if (err < 0)
	389	return err;
	390	}
	391	for (i = 0, p = cfg->hp_pins; i < cfg->hp_outs; i++, p++) {
	392	if (p == cfg->line_out_pins) /* might be duplicated */
	393	break;
f46c3296	394	err = add_jack_kctl(codec, *p, cfg);
01a61e12 TI	395	if (err < 0)
	396	return err;
	397	}
	398	for (i = 0, p = cfg->speaker_pins; i < cfg->speaker_outs; i++, p++) {
	399	if (p == cfg->line_out_pins) /* might be duplicated */
	400	break;
f46c3296	401	err = add_jack_kctl(codec, *p, cfg);
01a61e12 TI	402	if (err < 0)
	403	return err;
	404	}
	405	for (i = 0; i < cfg->num_inputs; i++) {
f46c3296	406	err = add_jack_kctl(codec, cfg->inputs[i].pin, cfg);
01a61e12 TI	407	if (err < 0)
	408	return err;
	409	}
	410	for (i = 0, p = cfg->dig_out_pins; i < cfg->dig_outs; i++, p++) {
f46c3296	411	err = add_jack_kctl(codec, *p, cfg);
01a61e12 TI	412	if (err < 0)
	413	return err;
	414	}
f46c3296	415	err = add_jack_kctl(codec, cfg->dig_in_pin, cfg);
01a61e12 TI	416	if (err < 0)
01a61e12 TI	417	return err;
f46c3296	418	err = add_jack_kctl(codec, cfg->mono_out_pin, cfg);
01a61e12 TI	419	if (err < 0)
	420	return err;
	421	return 0;
	422	}
	423	EXPORT_SYMBOL_HDA(snd_hda_jack_add_kctls);
954df2a9 DH	424
	425	void snd_hda_jack_unsol_event(struct hda_codec *codec, unsigned int res)
	426	{
	427	struct hda_jack_tbl *event;
	428	int tag = (res >> AC_UNSOL_RES_TAG_SHIFT) & 0x7f;
	429
	430	event = snd_hda_jack_tbl_get_from_tag(codec, tag);
	431	if (!event)
	432	return;
	433	event->jack_dirty = 1;
	434
	435	if (event->callback)
	436	event->callback(codec, event);
	437
	438	snd_hda_jack_report_sync(codec);
	439	}
	440	EXPORT_SYMBOL_HDA(snd_hda_jack_unsol_event);
	441