[deliverable/linux.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(struct hda_codec *codec, hda_nid_t nid,
			       unsigned char action)
{
	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;
	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);

/**
 * 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);
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	*/
	195	int snd_hda_jack_detect_enable(struct hda_codec *codec, hda_nid_t nid,
3a93897e	196	unsigned char action)
1835a0f9 TI	197	{
	198	struct hda_jack_tbl *jack = snd_hda_jack_tbl_new(codec, nid);
	199	if (!jack)
	200	return -ENOMEM;
3a93897e	201	if (jack->jack_detect)
01a61e12	202	return 0; /* already registered */
3a93897e TI	203	jack->jack_detect = 1;
	204	if (action)
	205	jack->action = action;
1835a0f9 TI	206	return snd_hda_codec_write_cache(codec, nid, 0,
1835a0f9 TI	207	AC_VERB_SET_UNSOLICITED_ENABLE,
3a93897e	208	AC_USRSP_EN \| jack->tag);
1835a0f9 TI	209	}
1835a0f9 TI	210	EXPORT_SYMBOL_HDA(snd_hda_jack_detect_enable);
01a61e12	211
01a61e12 TI	212	/**
	213	* snd_hda_jack_report_sync - sync the states of all jacks and report if changed
	214	*/
	215	void snd_hda_jack_report_sync(struct hda_codec *codec)
	216	{
	217	struct hda_jack_tbl *jack = codec->jacktbl.list;
35be544a	218	int i, state;
01a61e12 TI	219
	220	for (i = 0; i < codec->jacktbl.used; i++, jack++)
	221	if (jack->nid) {
	222	jack_detect_update(codec, jack);
cfc7c9d3 TI	223	if (!jack->kctl)
cfc7c9d3 TI	224	continue;
35be544a	225	state = get_jack_plug_state(jack->pin_sense);
aad37dbd	226	snd_kctl_jack_report(codec->bus->card, jack->kctl, state);
31ef2257 TI	227	#ifdef CONFIG_SND_HDA_INPUT_JACK
	228	if (jack->jack)
	229	snd_jack_report(jack->jack,
	230	state ? jack->type : 0);
	231	#endif
01a61e12 TI	232	}
	233	}
	234	EXPORT_SYMBOL_HDA(snd_hda_jack_report_sync);
	235
31ef2257 TI	236	#ifdef CONFIG_SND_HDA_INPUT_JACK
	237	/* guess the jack type from the pin-config */
	238	static int get_input_jack_type(struct hda_codec *codec, hda_nid_t nid)
	239	{
	240	unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
	241	switch (get_defcfg_device(def_conf)) {
	242	case AC_JACK_LINE_OUT:
	243	case AC_JACK_SPEAKER:
	244	return SND_JACK_LINEOUT;
	245	case AC_JACK_HP_OUT:
	246	return SND_JACK_HEADPHONE;
	247	case AC_JACK_SPDIF_OUT:
	248	case AC_JACK_DIG_OTHER_OUT:
	249	return SND_JACK_AVOUT;
	250	case AC_JACK_MIC_IN:
	251	return SND_JACK_MICROPHONE;
	252	default:
	253	return SND_JACK_LINEIN;
	254	}
	255	}
	256
	257	static void hda_free_jack_priv(struct snd_jack *jack)
	258	{
	259	struct hda_jack_tbl *jacks = jack->private_data;
	260	jacks->nid = 0;
	261	jacks->jack = NULL;
	262	}
	263	#endif
	264
01a61e12 TI	265	/**
	266	* snd_hda_jack_add_kctl - Add a kctl for the given pin
	267	*
	268	* This assigns a jack-detection kctl to the given pin. The kcontrol
	269	* will have the given name and index.
	270	*/
80c8bfbe DH	271	static int __snd_hda_jack_add_kctl(struct hda_codec *codec, hda_nid_t nid,
80c8bfbe DH	272	const char *name, int idx, bool phantom_jack)
01a61e12 TI	273	{
	274	struct hda_jack_tbl *jack;
	275	struct snd_kcontrol *kctl;
31ef2257	276	int err, state;
01a61e12	277
3a93897e	278	jack = snd_hda_jack_tbl_new(codec, nid);
01a61e12 TI	279	if (!jack)
	280	return 0;
	281	if (jack->kctl)
	282	return 0; /* already created */
35be544a	283	kctl = snd_kctl_jack_new(name, idx, codec);
01a61e12 TI	284	if (!kctl)
01a61e12 TI	285	return -ENOMEM;
31ef2257 TI	286	err = snd_hda_ctl_add(codec, nid, kctl);
	287	if (err < 0)
	288	return err;
01a61e12	289	jack->kctl = kctl;
80c8bfbe DH	290	jack->phantom_jack = !!phantom_jack;
80c8bfbe DH	291
31ef2257 TI	292	state = snd_hda_jack_detect(codec, nid);
	293	snd_kctl_jack_report(codec->bus->card, kctl, state);
	294	#ifdef CONFIG_SND_HDA_INPUT_JACK
80c8bfbe DH	295	if (!phantom_jack) {
	296	jack->type = get_input_jack_type(codec, nid);
	297	err = snd_jack_new(codec->bus->card, name, jack->type,
	298	&jack->jack);
	299	if (err < 0)
	300	return err;
	301	jack->jack->private_data = jack;
	302	jack->jack->private_free = hda_free_jack_priv;
	303	snd_jack_report(jack->jack, state ? jack->type : 0);
	304	}
31ef2257	305	#endif
01a61e12 TI	306	return 0;
01a61e12 TI	307	}
80c8bfbe DH	308
	309	int snd_hda_jack_add_kctl(struct hda_codec *codec, hda_nid_t nid,
	310	const char *name, int idx)
	311	{
	312	return __snd_hda_jack_add_kctl(codec, nid, name, idx, false);
	313	}
d1cb6200	314	EXPORT_SYMBOL_HDA(snd_hda_jack_add_kctl);
01a61e12	315
f46c3296 TI	316	/* get the unique index number for the given kctl name */
	317	static int get_unique_index(struct hda_codec codec, const char name, int idx)
	318	{
	319	struct hda_jack_tbl *jack;
	320	int i, len = strlen(name);
	321	again:
	322	jack = codec->jacktbl.list;
	323	for (i = 0; i < codec->jacktbl.used; i++, jack++) {
	324	/* jack->kctl.id contains "XXX Jack" name string with index */
	325	if (jack->kctl &&
	326	!strncmp(name, jack->kctl->id.name, len) &&
	327	!strcmp(" Jack", jack->kctl->id.name + len) &&
	328	jack->kctl->id.index == idx) {
	329	idx++;
	330	goto again;
	331	}
	332	}
	333	return idx;
	334	}
	335
201e06ff	336	static int add_jack_kctl(struct hda_codec *codec, hda_nid_t nid,
f46c3296	337	const struct auto_pin_cfg *cfg)
01a61e12	338	{
3a93897e	339	unsigned int def_conf, conn;
201e06ff TI	340	char name[44];
201e06ff TI	341	int idx, err;
80c8bfbe	342	bool phantom_jack;
3a93897e	343
01a61e12 TI	344	if (!nid)
01a61e12 TI	345	return 0;
3a93897e TI	346	def_conf = snd_hda_codec_get_pincfg(codec, nid);
3a93897e TI	347	conn = get_defcfg_connect(def_conf);
80c8bfbe	348	if (conn == AC_JACK_PORT_NONE)
3a93897e	349	return 0;
80c8bfbe DH	350	phantom_jack = (conn != AC_JACK_PORT_COMPLEX) \|\|
80c8bfbe DH	351	!is_jack_detectable(codec, nid);
3a93897e	352
201e06ff	353	snd_hda_get_pin_label(codec, nid, cfg, name, sizeof(name), &idx);
80c8bfbe DH	354	if (phantom_jack)
	355	/* Example final name: "Internal Mic Phantom Jack" */
	356	strncat(name, " Phantom", sizeof(name) - strlen(name) - 1);
f46c3296	357	idx = get_unique_index(codec, name, idx);
80c8bfbe	358	err = __snd_hda_jack_add_kctl(codec, nid, name, idx, phantom_jack);
3a93897e TI	359	if (err < 0)
3a93897e TI	360	return err;
80c8bfbe DH	361
	362	if (!phantom_jack)
	363	return snd_hda_jack_detect_enable(codec, nid, 0);
	364	return 0;
01a61e12 TI	365	}
	366
	367	/**
	368	* snd_hda_jack_add_kctls - Add kctls for all pins included in the given pincfg
01a61e12 TI	369	*/
	370	int snd_hda_jack_add_kctls(struct hda_codec *codec,
	371	const struct auto_pin_cfg *cfg)
	372	{
	373	const hda_nid_t *p;
f46c3296	374	int i, err;
01a61e12 TI	375
01a61e12 TI	376	for (i = 0, p = cfg->line_out_pins; i < cfg->line_outs; i++, p++) {
f46c3296	377	err = add_jack_kctl(codec, *p, cfg);
01a61e12 TI	378	if (err < 0)
	379	return err;
	380	}
	381	for (i = 0, p = cfg->hp_pins; i < cfg->hp_outs; i++, p++) {
	382	if (p == cfg->line_out_pins) /* might be duplicated */
	383	break;
f46c3296	384	err = add_jack_kctl(codec, *p, cfg);
01a61e12 TI	385	if (err < 0)
	386	return err;
	387	}
	388	for (i = 0, p = cfg->speaker_pins; i < cfg->speaker_outs; i++, p++) {
	389	if (p == cfg->line_out_pins) /* might be duplicated */
	390	break;
f46c3296	391	err = add_jack_kctl(codec, *p, cfg);
01a61e12 TI	392	if (err < 0)
	393	return err;
	394	}
	395	for (i = 0; i < cfg->num_inputs; i++) {
f46c3296	396	err = add_jack_kctl(codec, cfg->inputs[i].pin, cfg);
01a61e12 TI	397	if (err < 0)
	398	return err;
	399	}
	400	for (i = 0, p = cfg->dig_out_pins; i < cfg->dig_outs; i++, p++) {
f46c3296	401	err = add_jack_kctl(codec, *p, cfg);
01a61e12 TI	402	if (err < 0)
	403	return err;
	404	}
f46c3296	405	err = add_jack_kctl(codec, cfg->dig_in_pin, cfg);
01a61e12 TI	406	if (err < 0)
01a61e12 TI	407	return err;
f46c3296	408	err = add_jack_kctl(codec, cfg->mono_out_pin, cfg);
01a61e12 TI	409	if (err < 0)
	410	return err;
	411	return 0;
	412	}
	413	EXPORT_SYMBOL_HDA(snd_hda_jack_add_kctls);