sound/pci/hda/hda_jack.c

   1 /*
   2  * Jack-detection handling for HD-audio
   3  *
   4  * Copyright (c) 2011 Takashi Iwai <tiwai@suse.de>
   5  *
   6  * This driver is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  */
  11
  12 #include <linux/init.h>
  13 #include <linux/slab.h>
  14 #include <linux/export.h>
  15 #include <sound/core.h>
  16 #include <sound/control.h>
  17 #include <sound/jack.h>
  18 #include "hda_codec.h"
  19 #include "hda_local.h"
  20 #include "hda_auto_parser.h"
  21 #include "hda_jack.h"
  22
  23 bool is_jack_detectable(struct hda_codec *codec, hda_nid_t nid)
  24 {
  25         if (codec->no_jack_detect)
  26                 return false;
  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
  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
  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
  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;
 105         jack->tag = codec->jacktbl.used;
 106         return jack;
 107 }
 108 EXPORT_SYMBOL_HDA(snd_hda_jack_tbl_new);
 109
 110 void snd_hda_jack_tbl_clear(struct hda_codec *codec)
 111 {
 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
 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 {
 130         if (!jack->jack_dirty)
 131                 return;
 132
 133         if (jack->phantom_jack)
 134                 jack->pin_sense = AC_PINSENSE_PRESENCE;
 135         else
 136                 jack->pin_sense = read_pin_sense(codec, jack->nid);
 137
 138         jack->jack_dirty = 0;
 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
 177 #define get_jack_plug_state(sense) !!(sense & AC_PINSENSE_PRESENCE)
 178
 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);
 189         return get_jack_plug_state(sense);
 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,
 197                                unsigned char action)
 198 {
 199         struct hda_jack_tbl *jack = snd_hda_jack_tbl_new(codec, nid);
 200         if (!jack)
 201                 return -ENOMEM;
 202         if (jack->jack_detect)
 203                 return 0; /* already registered */
 204         jack->jack_detect = 1;
 205         if (action)
 206                 jack->action = action;
 207         return snd_hda_codec_write_cache(codec, nid, 0,
 208                                          AC_VERB_SET_UNSOLICITED_ENABLE,
 209                                          AC_USRSP_EN | jack->tag);
 210 }
 211 EXPORT_SYMBOL_HDA(snd_hda_jack_detect_enable);
 212
 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;
 219         int i, state;
 220
 221         for (i = 0; i < codec->jacktbl.used; i++, jack++)
 222                 if (jack->nid) {
 223                         jack_detect_update(codec, jack);
 224                         if (!jack->kctl)
 225                                 continue;
 226                         state = get_jack_plug_state(jack->pin_sense);
 227                         snd_kctl_jack_report(codec->bus->card, jack->kctl, state);
 228 #ifdef CONFIG_SND_HDA_INPUT_JACK
 229                         if (jack->jack)
 230                                 snd_jack_report(jack->jack,
 231                                                 state ? jack->type : 0);
 232 #endif
 233                 }
 234 }
 235 EXPORT_SYMBOL_HDA(snd_hda_jack_report_sync);
 236
 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
 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  */
 272 static int __snd_hda_jack_add_kctl(struct hda_codec *codec, hda_nid_t nid,
 273                           const char *name, int idx, bool phantom_jack)
 274 {
 275         struct hda_jack_tbl *jack;
 276         struct snd_kcontrol *kctl;
 277         int err, state;
 278
 279         jack = snd_hda_jack_tbl_new(codec, nid);
 280         if (!jack)
 281                 return 0;
 282         if (jack->kctl)
 283                 return 0; /* already created */
 284         kctl = snd_kctl_jack_new(name, idx, codec);
 285         if (!kctl)
 286                 return -ENOMEM;
 287         err = snd_hda_ctl_add(codec, nid, kctl);
 288         if (err < 0)
 289                 return err;
 290         jack->kctl = kctl;
 291         jack->phantom_jack = !!phantom_jack;
 292
 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
 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         }
 306 #endif
 307         return 0;
 308 }
 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 }
 315 EXPORT_SYMBOL_HDA(snd_hda_jack_add_kctl);
 316
 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
 337 static int add_jack_kctl(struct hda_codec *codec, hda_nid_t nid,
 338                          const struct auto_pin_cfg *cfg)
 339 {
 340         unsigned int def_conf, conn;
 341         char name[44];
 342         int idx, err;
 343         bool phantom_jack;
 344
 345         if (!nid)
 346                 return 0;
 347         def_conf = snd_hda_codec_get_pincfg(codec, nid);
 348         conn = get_defcfg_connect(def_conf);
 349         if (conn == AC_JACK_PORT_NONE)
 350                 return 0;
 351         phantom_jack = (conn != AC_JACK_PORT_COMPLEX) ||
 352                        !is_jack_detectable(codec, nid);
 353
 354         snd_hda_get_pin_label(codec, nid, cfg, name, sizeof(name), &idx);
 355         if (phantom_jack)
 356                 /* Example final name: "Internal Mic Phantom Jack" */
 357                 strncat(name, " Phantom", sizeof(name) - strlen(name) - 1);
 358         idx = get_unique_index(codec, name, idx);
 359         err = __snd_hda_jack_add_kctl(codec, nid, name, idx, phantom_jack);
 360         if (err < 0)
 361                 return err;
 362
 363         if (!phantom_jack)
 364                 return snd_hda_jack_detect_enable(codec, nid, 0);
 365         return 0;
 366 }
 367
 368 /**
 369  * snd_hda_jack_add_kctls - Add kctls for all pins included in the given pincfg
 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;
 375         int i, err;
 376
 377         for (i = 0, p = cfg->line_out_pins; i < cfg->line_outs; i++, p++) {
 378                 err = add_jack_kctl(codec, *p, cfg);
 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;
 385                 err = add_jack_kctl(codec, *p, cfg);
 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;
 392                 err = add_jack_kctl(codec, *p, cfg);
 393                 if (err < 0)
 394                         return err;
 395         }
 396         for (i = 0; i < cfg->num_inputs; i++) {
 397                 err = add_jack_kctl(codec, cfg->inputs[i].pin, cfg);
 398                 if (err < 0)
 399                         return err;
 400         }
 401         for (i = 0, p = cfg->dig_out_pins; i < cfg->dig_outs; i++, p++) {
 402                 err = add_jack_kctl(codec, *p, cfg);
 403                 if (err < 0)
 404                         return err;
 405         }
 406         err = add_jack_kctl(codec, cfg->dig_in_pin, cfg);
 407         if (err < 0)
 408                 return err;
 409         err = add_jack_kctl(codec, cfg->mono_out_pin, cfg);
 410         if (err < 0)
 411                 return err;
 412         return 0;
 413 }
 414 EXPORT_SYMBOL_HDA(snd_hda_jack_add_kctls);