2011-10-28 04:12:46 +08:00
|
|
|
/*
|
|
|
|
* 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>
|
2011-11-16 21:28:33 +08:00
|
|
|
#include <linux/export.h>
|
2011-10-28 04:12:46 +08:00
|
|
|
#include <sound/core.h>
|
2011-10-28 06:03:22 +08:00
|
|
|
#include <sound/control.h>
|
2011-11-02 15:54:51 +08:00
|
|
|
#include <sound/jack.h>
|
2011-10-28 04:12:46 +08:00
|
|
|
#include "hda_codec.h"
|
|
|
|
#include "hda_local.h"
|
2012-05-07 23:42:31 +08:00
|
|
|
#include "hda_auto_parser.h"
|
2011-10-28 04:12:46 +08:00
|
|
|
#include "hda_jack.h"
|
|
|
|
|
2014-10-29 23:03:58 +08:00
|
|
|
/**
|
|
|
|
* is_jack_detectable - Check whether the given pin is jack-detectable
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @nid: pin NID
|
|
|
|
*
|
|
|
|
* Check whether the given pin is capable to report the jack detection.
|
|
|
|
* The jack detection might not work by various reasons, e.g. the jack
|
|
|
|
* detection is prohibited in the codec level, the pin config has
|
|
|
|
* AC_DEFCFG_MISC_NO_PRESENCE bit, no unsol support, etc.
|
|
|
|
*/
|
2012-02-13 18:41:42 +08:00
|
|
|
bool is_jack_detectable(struct hda_codec *codec, hda_nid_t nid)
|
|
|
|
{
|
2012-02-13 18:55:02 +08:00
|
|
|
if (codec->no_jack_detect)
|
|
|
|
return false;
|
2012-02-13 18:41:42 +08:00
|
|
|
if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_PRES_DETECT))
|
|
|
|
return false;
|
2012-09-07 13:25:44 +08:00
|
|
|
if (get_defcfg_misc(snd_hda_codec_get_pincfg(codec, nid)) &
|
|
|
|
AC_DEFCFG_MISC_NO_PRESENCE)
|
2012-02-13 18:41:42 +08:00
|
|
|
return false;
|
2013-01-07 19:11:33 +08:00
|
|
|
if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) &&
|
|
|
|
!codec->jackpoll_interval)
|
2012-02-13 18:41:42 +08:00
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
2013-12-18 14:45:52 +08:00
|
|
|
EXPORT_SYMBOL_GPL(is_jack_detectable);
|
2012-02-13 18:41:42 +08:00
|
|
|
|
2011-10-28 04:12:46 +08:00
|
|
|
/* execute pin sense measurement */
|
|
|
|
static u32 read_pin_sense(struct hda_codec *codec, hda_nid_t nid)
|
|
|
|
{
|
|
|
|
u32 pincap;
|
2012-12-21 22:31:41 +08:00
|
|
|
u32 val;
|
2011-10-28 04:12:46 +08:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
2012-12-21 22:31:41 +08:00
|
|
|
val = snd_hda_codec_read(codec, nid, 0,
|
2011-10-28 04:12:46 +08:00
|
|
|
AC_VERB_GET_PIN_SENSE, 0);
|
2012-12-21 22:31:41 +08:00
|
|
|
if (codec->inv_jack_detect)
|
|
|
|
val ^= AC_PINSENSE_PRESENCE;
|
|
|
|
return val;
|
2011-10-28 04:12:46 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_hda_jack_tbl_get - query the jack-table entry for the given NID
|
2014-10-29 22:06:01 +08:00
|
|
|
* @codec: the HDA codec
|
|
|
|
* @nid: pin NID to refer to
|
2011-10-28 04:12:46 +08:00
|
|
|
*/
|
|
|
|
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;
|
|
|
|
}
|
2013-12-18 14:45:52 +08:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_jack_tbl_get);
|
2011-10-28 04:12:46 +08:00
|
|
|
|
2011-10-28 07:16:55 +08:00
|
|
|
/**
|
|
|
|
* snd_hda_jack_tbl_get_from_tag - query the jack-table entry for the given tag
|
2014-10-29 22:06:01 +08:00
|
|
|
* @codec: the HDA codec
|
|
|
|
* @tag: tag value to refer to
|
2011-10-28 07:16:55 +08:00
|
|
|
*/
|
|
|
|
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;
|
|
|
|
}
|
2013-12-18 14:45:52 +08:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_jack_tbl_get_from_tag);
|
2011-10-28 07:16:55 +08:00
|
|
|
|
2011-10-28 04:12:46 +08:00
|
|
|
/**
|
|
|
|
* snd_hda_jack_tbl_new - create a jack-table entry for the given NID
|
2014-10-29 22:06:01 +08:00
|
|
|
* @codec: the HDA codec
|
|
|
|
* @nid: pin NID to assign
|
2011-10-28 04:12:46 +08:00
|
|
|
*/
|
2014-09-11 20:22:03 +08:00
|
|
|
static struct hda_jack_tbl *
|
2011-10-28 04:12:46 +08:00
|
|
|
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;
|
|
|
|
jack = snd_array_new(&codec->jacktbl);
|
|
|
|
if (!jack)
|
|
|
|
return NULL;
|
|
|
|
jack->nid = nid;
|
|
|
|
jack->jack_dirty = 1;
|
2011-10-28 07:16:55 +08:00
|
|
|
jack->tag = codec->jacktbl.used;
|
2011-10-28 04:12:46 +08:00
|
|
|
return jack;
|
|
|
|
}
|
|
|
|
|
|
|
|
void snd_hda_jack_tbl_clear(struct hda_codec *codec)
|
|
|
|
{
|
2014-09-11 21:22:46 +08:00
|
|
|
struct hda_jack_tbl *jack = codec->jacktbl.list;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < codec->jacktbl.used; i++, jack++) {
|
|
|
|
struct hda_jack_callback *cb, *next;
|
2015-04-27 21:20:59 +08:00
|
|
|
|
2014-09-11 21:22:46 +08:00
|
|
|
/* free jack instances manually when clearing/reconfiguring */
|
|
|
|
if (!codec->bus->shutdown && jack->jack)
|
2015-02-27 23:09:22 +08:00
|
|
|
snd_device_free(codec->card, jack->jack);
|
2015-04-27 21:20:59 +08:00
|
|
|
|
2014-09-11 21:22:46 +08:00
|
|
|
for (cb = jack->callback; cb; cb = next) {
|
|
|
|
next = cb->next;
|
|
|
|
kfree(cb);
|
2011-12-02 00:41:36 +08:00
|
|
|
}
|
|
|
|
}
|
2011-10-28 04:12:46 +08:00
|
|
|
snd_array_free(&codec->jacktbl);
|
|
|
|
}
|
|
|
|
|
2012-11-20 02:48:07 +08:00
|
|
|
#define get_jack_plug_state(sense) !!(sense & AC_PINSENSE_PRESENCE)
|
|
|
|
|
2011-10-28 04:12:46 +08:00
|
|
|
/* update the cached value and notification flag if needed */
|
|
|
|
static void jack_detect_update(struct hda_codec *codec,
|
|
|
|
struct hda_jack_tbl *jack)
|
|
|
|
{
|
2012-06-04 15:33:51 +08:00
|
|
|
if (!jack->jack_dirty)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (jack->phantom_jack)
|
|
|
|
jack->pin_sense = AC_PINSENSE_PRESENCE;
|
|
|
|
else
|
2011-11-02 15:36:06 +08:00
|
|
|
jack->pin_sense = read_pin_sense(codec, jack->nid);
|
2012-06-04 15:33:51 +08:00
|
|
|
|
2012-11-20 02:48:07 +08:00
|
|
|
/* A gating jack indicates the jack is invalid if gating is unplugged */
|
|
|
|
if (jack->gating_jack && !snd_hda_jack_detect(codec, jack->gating_jack))
|
|
|
|
jack->pin_sense &= ~AC_PINSENSE_PRESENCE;
|
|
|
|
|
2012-06-04 15:33:51 +08:00
|
|
|
jack->jack_dirty = 0;
|
2012-11-20 02:48:07 +08:00
|
|
|
|
|
|
|
/* If a jack is gated by this one update it. */
|
|
|
|
if (jack->gated_jack) {
|
|
|
|
struct hda_jack_tbl *gated =
|
|
|
|
snd_hda_jack_tbl_get(codec, jack->gated_jack);
|
|
|
|
if (gated) {
|
|
|
|
gated->jack_dirty = 1;
|
|
|
|
jack_detect_update(codec, gated);
|
|
|
|
}
|
|
|
|
}
|
2011-10-28 04:12:46 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_hda_set_dirty_all - Mark all the cached as dirty
|
2014-10-29 22:06:01 +08:00
|
|
|
* @codec: the HDA codec
|
2011-10-28 04:12:46 +08:00
|
|
|
*
|
|
|
|
* 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;
|
|
|
|
}
|
2013-12-18 14:45:52 +08:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_jack_set_dirty_all);
|
2011-10-28 04:12:46 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
}
|
2013-12-18 14:45:52 +08:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_pin_sense);
|
2011-10-28 04:12:46 +08:00
|
|
|
|
|
|
|
/**
|
ALSA: hda - Add snd_hda_jack_detect_state() helper function
snd_hda_jack_detect() function returns a boolean value for a jack
plugged in or not, but it also returns always true when the
corresponding pin is phantom (i.e. fixed). This is OK in most cases,
but it makes the generic parser misbehaving about the auto-mute or
auto-mic switching, e.g. when one of headphone pins is a fixed.
Namely, the driver decides whether to mute the speaker or not, just
depending on the headphone plug state: if one of the headphone jacks
is seen as active, then the speaker is muted. Thus this will result
always in the muted speaker output.
So, the problem is the function returns a boolean, after all, although
we need to think of "phantom" jack. Now a new function,
snd_hda_jack_detect_state() is introduced to return these tristates.
The generic parser uses this function for checking the headphone or
mic jack states.
Meanwhile, the behavior of snd_hda_jack_detect() is kept as is, for
keeping compatibility in other driver codes.
Acked-by: David Henningsson <david.henningsson@canonical.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2013-07-19 22:59:46 +08:00
|
|
|
* snd_hda_jack_detect_state - query pin Presence Detect status
|
2011-10-28 04:12:46 +08:00
|
|
|
* @codec: the CODEC to sense
|
|
|
|
* @nid: the pin NID to sense
|
|
|
|
*
|
ALSA: hda - Add snd_hda_jack_detect_state() helper function
snd_hda_jack_detect() function returns a boolean value for a jack
plugged in or not, but it also returns always true when the
corresponding pin is phantom (i.e. fixed). This is OK in most cases,
but it makes the generic parser misbehaving about the auto-mute or
auto-mic switching, e.g. when one of headphone pins is a fixed.
Namely, the driver decides whether to mute the speaker or not, just
depending on the headphone plug state: if one of the headphone jacks
is seen as active, then the speaker is muted. Thus this will result
always in the muted speaker output.
So, the problem is the function returns a boolean, after all, although
we need to think of "phantom" jack. Now a new function,
snd_hda_jack_detect_state() is introduced to return these tristates.
The generic parser uses this function for checking the headphone or
mic jack states.
Meanwhile, the behavior of snd_hda_jack_detect() is kept as is, for
keeping compatibility in other driver codes.
Acked-by: David Henningsson <david.henningsson@canonical.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2013-07-19 22:59:46 +08:00
|
|
|
* Query and return the pin's Presence Detect status, as either
|
|
|
|
* HDA_JACK_NOT_PRESENT, HDA_JACK_PRESENT or HDA_JACK_PHANTOM.
|
2011-10-28 04:12:46 +08:00
|
|
|
*/
|
ALSA: hda - Add snd_hda_jack_detect_state() helper function
snd_hda_jack_detect() function returns a boolean value for a jack
plugged in or not, but it also returns always true when the
corresponding pin is phantom (i.e. fixed). This is OK in most cases,
but it makes the generic parser misbehaving about the auto-mute or
auto-mic switching, e.g. when one of headphone pins is a fixed.
Namely, the driver decides whether to mute the speaker or not, just
depending on the headphone plug state: if one of the headphone jacks
is seen as active, then the speaker is muted. Thus this will result
always in the muted speaker output.
So, the problem is the function returns a boolean, after all, although
we need to think of "phantom" jack. Now a new function,
snd_hda_jack_detect_state() is introduced to return these tristates.
The generic parser uses this function for checking the headphone or
mic jack states.
Meanwhile, the behavior of snd_hda_jack_detect() is kept as is, for
keeping compatibility in other driver codes.
Acked-by: David Henningsson <david.henningsson@canonical.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2013-07-19 22:59:46 +08:00
|
|
|
int snd_hda_jack_detect_state(struct hda_codec *codec, hda_nid_t nid)
|
2011-10-28 04:12:46 +08:00
|
|
|
{
|
ALSA: hda - Add snd_hda_jack_detect_state() helper function
snd_hda_jack_detect() function returns a boolean value for a jack
plugged in or not, but it also returns always true when the
corresponding pin is phantom (i.e. fixed). This is OK in most cases,
but it makes the generic parser misbehaving about the auto-mute or
auto-mic switching, e.g. when one of headphone pins is a fixed.
Namely, the driver decides whether to mute the speaker or not, just
depending on the headphone plug state: if one of the headphone jacks
is seen as active, then the speaker is muted. Thus this will result
always in the muted speaker output.
So, the problem is the function returns a boolean, after all, although
we need to think of "phantom" jack. Now a new function,
snd_hda_jack_detect_state() is introduced to return these tristates.
The generic parser uses this function for checking the headphone or
mic jack states.
Meanwhile, the behavior of snd_hda_jack_detect() is kept as is, for
keeping compatibility in other driver codes.
Acked-by: David Henningsson <david.henningsson@canonical.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2013-07-19 22:59:46 +08:00
|
|
|
struct hda_jack_tbl *jack = snd_hda_jack_tbl_get(codec, nid);
|
|
|
|
if (jack && jack->phantom_jack)
|
|
|
|
return HDA_JACK_PHANTOM;
|
|
|
|
else if (snd_hda_pin_sense(codec, nid) & AC_PINSENSE_PRESENCE)
|
|
|
|
return HDA_JACK_PRESENT;
|
|
|
|
else
|
|
|
|
return HDA_JACK_NOT_PRESENT;
|
2011-10-28 04:12:46 +08:00
|
|
|
}
|
2013-12-18 14:45:52 +08:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_jack_detect_state);
|
2011-10-28 04:12:46 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_hda_jack_detect_enable - enable the jack-detection
|
2014-10-29 22:06:01 +08:00
|
|
|
* @codec: the HDA codec
|
|
|
|
* @nid: pin NID to enable
|
|
|
|
* @func: callback function to register
|
2014-09-11 20:39:09 +08:00
|
|
|
*
|
|
|
|
* In the case of error, the return value will be a pointer embedded with
|
|
|
|
* errno. Check and handle the return value appropriately with standard
|
|
|
|
* macros such as @IS_ERR() and @PTR_ERR().
|
2011-10-28 04:12:46 +08:00
|
|
|
*/
|
2014-09-11 21:22:46 +08:00
|
|
|
struct hda_jack_callback *
|
2014-09-11 20:39:09 +08:00
|
|
|
snd_hda_jack_detect_enable_callback(struct hda_codec *codec, hda_nid_t nid,
|
2014-09-11 21:22:46 +08:00
|
|
|
hda_jack_callback_fn func)
|
2011-10-28 04:12:46 +08:00
|
|
|
{
|
2014-09-11 21:22:46 +08:00
|
|
|
struct hda_jack_tbl *jack;
|
|
|
|
struct hda_jack_callback *callback = NULL;
|
2014-09-11 20:39:09 +08:00
|
|
|
int err;
|
|
|
|
|
2014-09-11 21:22:46 +08:00
|
|
|
jack = snd_hda_jack_tbl_new(codec, nid);
|
2011-10-28 04:12:46 +08:00
|
|
|
if (!jack)
|
2014-09-11 20:39:09 +08:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2014-09-11 21:22:46 +08:00
|
|
|
if (func) {
|
|
|
|
callback = kzalloc(sizeof(*callback), GFP_KERNEL);
|
|
|
|
if (!callback)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
callback->func = func;
|
|
|
|
callback->tbl = jack;
|
|
|
|
callback->next = jack->callback;
|
|
|
|
jack->callback = callback;
|
|
|
|
}
|
|
|
|
|
2011-10-28 07:16:55 +08:00
|
|
|
if (jack->jack_detect)
|
2014-09-11 21:22:46 +08:00
|
|
|
return callback; /* already registered */
|
2011-10-28 07:16:55 +08:00
|
|
|
jack->jack_detect = 1;
|
2012-10-17 20:45:05 +08:00
|
|
|
if (codec->jackpoll_interval > 0)
|
2014-09-11 21:22:46 +08:00
|
|
|
return callback; /* No unsol if we're polling instead */
|
2014-09-11 20:39:09 +08:00
|
|
|
err = snd_hda_codec_write_cache(codec, nid, 0,
|
2011-10-28 04:12:46 +08:00
|
|
|
AC_VERB_SET_UNSOLICITED_ENABLE,
|
2011-10-28 07:16:55 +08:00
|
|
|
AC_USRSP_EN | jack->tag);
|
2014-09-11 20:39:09 +08:00
|
|
|
if (err < 0)
|
|
|
|
return ERR_PTR(err);
|
2014-09-11 21:22:46 +08:00
|
|
|
return callback;
|
2011-10-28 04:12:46 +08:00
|
|
|
}
|
2013-12-18 14:45:52 +08:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_jack_detect_enable_callback);
|
2012-09-25 17:30:59 +08:00
|
|
|
|
2014-10-29 23:03:58 +08:00
|
|
|
/**
|
|
|
|
* snd_hda_jack_detect_enable - Enable the jack detection on the given pin
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @nid: pin NID to enable jack detection
|
|
|
|
*
|
|
|
|
* Enable the jack detection with the default callback. Returns zero if
|
|
|
|
* successful or a negative error code.
|
|
|
|
*/
|
2014-09-11 20:06:53 +08:00
|
|
|
int snd_hda_jack_detect_enable(struct hda_codec *codec, hda_nid_t nid)
|
2012-09-25 17:30:59 +08:00
|
|
|
{
|
2014-09-11 20:39:09 +08:00
|
|
|
return PTR_ERR_OR_ZERO(snd_hda_jack_detect_enable_callback(codec, nid, NULL));
|
2012-09-25 17:30:59 +08:00
|
|
|
}
|
2013-12-18 14:45:52 +08:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_jack_detect_enable);
|
2011-10-28 06:03:22 +08:00
|
|
|
|
2012-11-20 02:48:07 +08:00
|
|
|
/**
|
|
|
|
* snd_hda_jack_set_gating_jack - Set gating jack.
|
2014-10-29 22:06:01 +08:00
|
|
|
* @codec: the HDA codec
|
|
|
|
* @gated_nid: gated pin NID
|
|
|
|
* @gating_nid: gating pin NID
|
2012-11-20 02:48:07 +08:00
|
|
|
*
|
|
|
|
* Indicates the gated jack is only valid when the gating jack is plugged.
|
|
|
|
*/
|
|
|
|
int snd_hda_jack_set_gating_jack(struct hda_codec *codec, hda_nid_t gated_nid,
|
|
|
|
hda_nid_t gating_nid)
|
|
|
|
{
|
2013-08-05 16:38:42 +08:00
|
|
|
struct hda_jack_tbl *gated = snd_hda_jack_tbl_new(codec, gated_nid);
|
|
|
|
struct hda_jack_tbl *gating = snd_hda_jack_tbl_new(codec, gating_nid);
|
2012-11-20 02:48:07 +08:00
|
|
|
|
|
|
|
if (!gated || !gating)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
gated->gating_jack = gating_nid;
|
|
|
|
gating->gated_jack = gated_nid;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2013-12-18 14:45:52 +08:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_jack_set_gating_jack);
|
2012-11-20 02:48:07 +08:00
|
|
|
|
2011-10-28 06:03:22 +08:00
|
|
|
/**
|
|
|
|
* snd_hda_jack_report_sync - sync the states of all jacks and report if changed
|
2014-10-29 22:06:01 +08:00
|
|
|
* @codec: the HDA codec
|
2011-10-28 06:03:22 +08:00
|
|
|
*/
|
|
|
|
void snd_hda_jack_report_sync(struct hda_codec *codec)
|
|
|
|
{
|
2012-11-20 02:48:07 +08:00
|
|
|
struct hda_jack_tbl *jack;
|
2011-11-02 15:36:06 +08:00
|
|
|
int i, state;
|
2011-10-28 06:03:22 +08:00
|
|
|
|
2012-11-20 02:48:07 +08:00
|
|
|
/* update all jacks at first */
|
|
|
|
jack = codec->jacktbl.list;
|
2011-10-28 06:03:22 +08:00
|
|
|
for (i = 0; i < codec->jacktbl.used; i++, jack++)
|
2012-11-20 02:48:07 +08:00
|
|
|
if (jack->nid)
|
2011-10-28 06:03:22 +08:00
|
|
|
jack_detect_update(codec, jack);
|
2012-11-20 02:48:07 +08:00
|
|
|
|
|
|
|
/* report the updated jacks; it's done after updating all jacks
|
|
|
|
* to make sure that all gating jacks properly have been set
|
|
|
|
*/
|
|
|
|
jack = codec->jacktbl.list;
|
|
|
|
for (i = 0; i < codec->jacktbl.used; i++, jack++)
|
|
|
|
if (jack->nid) {
|
2015-04-27 21:20:59 +08:00
|
|
|
if (!jack->jack || jack->block_report)
|
2011-11-12 00:53:03 +08:00
|
|
|
continue;
|
2011-11-02 15:36:06 +08:00
|
|
|
state = get_jack_plug_state(jack->pin_sense);
|
2015-04-27 21:20:59 +08:00
|
|
|
snd_jack_report(jack->jack,
|
|
|
|
state ? jack->type : 0);
|
2011-10-28 06:03:22 +08:00
|
|
|
}
|
|
|
|
}
|
2013-12-18 14:45:52 +08:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_jack_report_sync);
|
2011-10-28 06:03:22 +08:00
|
|
|
|
2011-12-02 00:41:36 +08:00
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
2011-10-28 06:03:22 +08:00
|
|
|
/**
|
|
|
|
* snd_hda_jack_add_kctl - Add a kctl for the given pin
|
2014-10-29 22:06:01 +08:00
|
|
|
* @codec: the HDA codec
|
|
|
|
* @nid: pin NID to assign
|
|
|
|
* @name: string name for the jack
|
|
|
|
* @phantom_jack: flag to deal as a phantom jack
|
2011-10-28 06:03:22 +08:00
|
|
|
*
|
|
|
|
* This assigns a jack-detection kctl to the given pin. The kcontrol
|
|
|
|
* will have the given name and index.
|
|
|
|
*/
|
2012-06-04 15:33:51 +08:00
|
|
|
static int __snd_hda_jack_add_kctl(struct hda_codec *codec, hda_nid_t nid,
|
2015-04-27 21:20:59 +08:00
|
|
|
const char *name, bool phantom_jack)
|
2011-10-28 06:03:22 +08:00
|
|
|
{
|
|
|
|
struct hda_jack_tbl *jack;
|
2015-04-27 21:20:59 +08:00
|
|
|
int err, state, type;
|
2011-10-28 06:03:22 +08:00
|
|
|
|
2011-10-28 07:16:55 +08:00
|
|
|
jack = snd_hda_jack_tbl_new(codec, nid);
|
2011-10-28 06:03:22 +08:00
|
|
|
if (!jack)
|
|
|
|
return 0;
|
2015-04-27 21:20:59 +08:00
|
|
|
if (jack->jack)
|
2011-10-28 06:03:22 +08:00
|
|
|
return 0; /* already created */
|
2015-04-27 21:20:59 +08:00
|
|
|
|
|
|
|
type = get_input_jack_type(codec, nid);
|
|
|
|
err = snd_jack_new(codec->card, name, type,
|
|
|
|
&jack->jack, true, phantom_jack);
|
2011-12-02 00:41:36 +08:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2012-06-04 15:33:51 +08:00
|
|
|
|
2015-04-27 21:20:59 +08:00
|
|
|
jack->phantom_jack = !!phantom_jack;
|
|
|
|
jack->type = type;
|
|
|
|
jack->jack->private_data = jack;
|
|
|
|
jack->jack->private_free = hda_free_jack_priv;
|
2011-12-02 00:41:36 +08:00
|
|
|
state = snd_hda_jack_detect(codec, nid);
|
2015-04-27 21:20:59 +08:00
|
|
|
snd_jack_report(jack->jack, state ? jack->type : 0);
|
|
|
|
|
2011-10-28 06:03:22 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2012-06-04 15:33:51 +08:00
|
|
|
|
2014-10-29 23:03:58 +08:00
|
|
|
/**
|
|
|
|
* snd_hda_jack_add_kctl - Add a jack kctl for the given pin
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @nid: pin NID
|
|
|
|
* @name: the name string for the jack ctl
|
|
|
|
*
|
|
|
|
* This is a simple helper calling __snd_hda_jack_add_kctl().
|
|
|
|
*/
|
2012-06-04 15:33:51 +08:00
|
|
|
int snd_hda_jack_add_kctl(struct hda_codec *codec, hda_nid_t nid,
|
2015-04-27 21:20:59 +08:00
|
|
|
const char *name)
|
2012-06-04 15:33:51 +08:00
|
|
|
{
|
2015-04-27 21:20:59 +08:00
|
|
|
return __snd_hda_jack_add_kctl(codec, nid, name, false);
|
2012-06-04 15:33:51 +08:00
|
|
|
}
|
2013-12-18 14:45:52 +08:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_jack_add_kctl);
|
2011-10-28 06:03:22 +08:00
|
|
|
|
2011-11-16 22:33:26 +08:00
|
|
|
static int add_jack_kctl(struct hda_codec *codec, hda_nid_t nid,
|
2013-04-11 17:30:30 +08:00
|
|
|
const struct auto_pin_cfg *cfg,
|
|
|
|
const char *base_name)
|
2011-10-28 06:03:22 +08:00
|
|
|
{
|
2011-10-28 07:16:55 +08:00
|
|
|
unsigned int def_conf, conn;
|
2013-06-28 17:56:49 +08:00
|
|
|
char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
|
2015-04-27 21:20:59 +08:00
|
|
|
int err;
|
2012-06-04 15:33:51 +08:00
|
|
|
bool phantom_jack;
|
2011-10-28 07:16:55 +08:00
|
|
|
|
2011-10-28 06:03:22 +08:00
|
|
|
if (!nid)
|
|
|
|
return 0;
|
2011-10-28 07:16:55 +08:00
|
|
|
def_conf = snd_hda_codec_get_pincfg(codec, nid);
|
|
|
|
conn = get_defcfg_connect(def_conf);
|
2012-06-04 15:33:51 +08:00
|
|
|
if (conn == AC_JACK_PORT_NONE)
|
2011-10-28 07:16:55 +08:00
|
|
|
return 0;
|
2012-06-04 15:33:51 +08:00
|
|
|
phantom_jack = (conn != AC_JACK_PORT_COMPLEX) ||
|
|
|
|
!is_jack_detectable(codec, nid);
|
2011-10-28 07:16:55 +08:00
|
|
|
|
2015-04-27 21:20:59 +08:00
|
|
|
if (base_name)
|
2013-04-11 17:30:30 +08:00
|
|
|
strlcpy(name, base_name, sizeof(name));
|
2015-04-27 21:20:59 +08:00
|
|
|
else
|
|
|
|
snd_hda_get_pin_label(codec, nid, cfg, name, sizeof(name), NULL);
|
2012-06-04 15:33:51 +08:00
|
|
|
if (phantom_jack)
|
|
|
|
/* Example final name: "Internal Mic Phantom Jack" */
|
|
|
|
strncat(name, " Phantom", sizeof(name) - strlen(name) - 1);
|
2015-04-27 21:20:59 +08:00
|
|
|
err = __snd_hda_jack_add_kctl(codec, nid, name, phantom_jack);
|
2011-10-28 07:16:55 +08:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2012-06-04 15:33:51 +08:00
|
|
|
|
|
|
|
if (!phantom_jack)
|
2014-09-11 20:06:53 +08:00
|
|
|
return snd_hda_jack_detect_enable(codec, nid);
|
2012-06-04 15:33:51 +08:00
|
|
|
return 0;
|
2011-10-28 06:03:22 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_hda_jack_add_kctls - Add kctls for all pins included in the given pincfg
|
2014-10-29 22:06:01 +08:00
|
|
|
* @codec: the HDA codec
|
|
|
|
* @cfg: pin config table to parse
|
2011-10-28 06:03:22 +08:00
|
|
|
*/
|
|
|
|
int snd_hda_jack_add_kctls(struct hda_codec *codec,
|
|
|
|
const struct auto_pin_cfg *cfg)
|
|
|
|
{
|
|
|
|
const hda_nid_t *p;
|
2012-07-17 22:48:27 +08:00
|
|
|
int i, err;
|
2011-10-28 06:03:22 +08:00
|
|
|
|
2013-04-11 17:30:30 +08:00
|
|
|
for (i = 0; i < cfg->num_inputs; i++) {
|
|
|
|
/* If we have headphone mics; make sure they get the right name
|
|
|
|
before grabbed by output pins */
|
|
|
|
if (cfg->inputs[i].is_headphone_mic) {
|
|
|
|
if (auto_cfg_hp_outs(cfg) == 1)
|
|
|
|
err = add_jack_kctl(codec, auto_cfg_hp_pins(cfg)[0],
|
|
|
|
cfg, "Headphone Mic");
|
|
|
|
else
|
|
|
|
err = add_jack_kctl(codec, cfg->inputs[i].pin,
|
|
|
|
cfg, "Headphone Mic");
|
|
|
|
} else
|
|
|
|
err = add_jack_kctl(codec, cfg->inputs[i].pin, cfg,
|
|
|
|
NULL);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2011-10-28 06:03:22 +08:00
|
|
|
for (i = 0, p = cfg->line_out_pins; i < cfg->line_outs; i++, p++) {
|
2013-04-11 17:30:30 +08:00
|
|
|
err = add_jack_kctl(codec, *p, cfg, NULL);
|
2011-10-28 06:03:22 +08:00
|
|
|
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;
|
2013-04-11 17:30:30 +08:00
|
|
|
err = add_jack_kctl(codec, *p, cfg, NULL);
|
2011-10-28 06:03:22 +08:00
|
|
|
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;
|
2013-04-11 17:30:30 +08:00
|
|
|
err = add_jack_kctl(codec, *p, cfg, NULL);
|
2011-10-28 06:03:22 +08:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
for (i = 0, p = cfg->dig_out_pins; i < cfg->dig_outs; i++, p++) {
|
2013-04-11 17:30:30 +08:00
|
|
|
err = add_jack_kctl(codec, *p, cfg, NULL);
|
2011-10-28 06:03:22 +08:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
}
|
2013-04-11 17:30:30 +08:00
|
|
|
err = add_jack_kctl(codec, cfg->dig_in_pin, cfg, NULL);
|
2011-10-28 06:03:22 +08:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2013-04-11 17:30:30 +08:00
|
|
|
err = add_jack_kctl(codec, cfg->mono_out_pin, cfg, NULL);
|
2011-10-28 06:03:22 +08:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
return 0;
|
|
|
|
}
|
2013-12-18 14:45:52 +08:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_jack_add_kctls);
|
2012-09-25 17:30:59 +08:00
|
|
|
|
2012-11-20 02:48:07 +08:00
|
|
|
static void call_jack_callback(struct hda_codec *codec,
|
|
|
|
struct hda_jack_tbl *jack)
|
|
|
|
{
|
2014-09-11 21:22:46 +08:00
|
|
|
struct hda_jack_callback *cb;
|
|
|
|
|
|
|
|
for (cb = jack->callback; cb; cb = cb->next)
|
|
|
|
cb->func(codec, cb);
|
2012-11-20 02:48:07 +08:00
|
|
|
if (jack->gated_jack) {
|
|
|
|
struct hda_jack_tbl *gated =
|
|
|
|
snd_hda_jack_tbl_get(codec, jack->gated_jack);
|
2014-09-11 21:22:46 +08:00
|
|
|
if (gated) {
|
|
|
|
for (cb = gated->callback; cb; cb = cb->next)
|
|
|
|
cb->func(codec, cb);
|
|
|
|
}
|
2012-11-20 02:48:07 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-29 23:03:58 +08:00
|
|
|
/**
|
|
|
|
* snd_hda_jack_unsol_event - Handle an unsolicited event
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @res: the unsolicited event data
|
|
|
|
*/
|
2012-09-25 17:30:59 +08:00
|
|
|
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;
|
|
|
|
|
2012-11-20 02:48:07 +08:00
|
|
|
call_jack_callback(codec, event);
|
2012-09-25 17:30:59 +08:00
|
|
|
snd_hda_jack_report_sync(codec);
|
|
|
|
}
|
2013-12-18 14:45:52 +08:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_jack_unsol_event);
|
2012-09-25 17:30:59 +08:00
|
|
|
|
2014-10-29 23:03:58 +08:00
|
|
|
/**
|
|
|
|
* snd_hda_jack_poll_all - Poll all jacks
|
|
|
|
* @codec: the HDA codec
|
|
|
|
*
|
|
|
|
* Poll all detectable jacks with dirty flag, update the status, call
|
|
|
|
* callbacks and call snd_hda_jack_report_sync() if any changes are found.
|
|
|
|
*/
|
2012-10-09 21:04:21 +08:00
|
|
|
void snd_hda_jack_poll_all(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct hda_jack_tbl *jack = codec->jacktbl.list;
|
|
|
|
int i, changes = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < codec->jacktbl.used; i++, jack++) {
|
|
|
|
unsigned int old_sense;
|
|
|
|
if (!jack->nid || !jack->jack_dirty || jack->phantom_jack)
|
|
|
|
continue;
|
|
|
|
old_sense = get_jack_plug_state(jack->pin_sense);
|
|
|
|
jack_detect_update(codec, jack);
|
|
|
|
if (old_sense == get_jack_plug_state(jack->pin_sense))
|
|
|
|
continue;
|
|
|
|
changes = 1;
|
2012-11-20 02:48:07 +08:00
|
|
|
call_jack_callback(codec, jack);
|
2012-10-09 21:04:21 +08:00
|
|
|
}
|
|
|
|
if (changes)
|
|
|
|
snd_hda_jack_report_sync(codec);
|
|
|
|
}
|
2013-12-18 14:45:52 +08:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_jack_poll_all);
|
2012-10-09 21:04:21 +08:00
|
|
|
|