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