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 (get_defcfg_misc(snd_hda_codec_get_pincfg(codec, nid)) &
  30              AC_DEFCFG_MISC_NO_PRESENCE)
  31                 return false;
  32         if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) &&
  33             !codec->jackpoll_interval)
  34                 return false;
  35         return true;
  36 }
  37 EXPORT_SYMBOL_GPL(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         u32 val;
  44
  45         if (!codec->no_trigger_sense) {
  46                 pincap = snd_hda_query_pin_caps(codec, nid);
  47                 if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */
  48                         snd_hda_codec_read(codec, nid, 0,
  49                                         AC_VERB_SET_PIN_SENSE, 0);
  50         }
  51         val = snd_hda_codec_read(codec, nid, 0,
  52                                   AC_VERB_GET_PIN_SENSE, 0);
  53         if (codec->inv_jack_detect)
  54                 val ^= AC_PINSENSE_PRESENCE;
  55         return val;
  56 }
  57
  58 /**
  59  * snd_hda_jack_tbl_get - query the jack-table entry for the given NID
  60  */
  61 struct hda_jack_tbl *
  62 snd_hda_jack_tbl_get(struct hda_codec *codec, hda_nid_t nid)
  63 {
  64         struct hda_jack_tbl *jack = codec->jacktbl.list;
  65         int i;
  66
  67         if (!nid || !jack)
  68                 return NULL;
  69         for (i = 0; i < codec->jacktbl.used; i++, jack++)
  70                 if (jack->nid == nid)
  71                         return jack;
  72         return NULL;
  73 }
  74 EXPORT_SYMBOL_GPL(snd_hda_jack_tbl_get);
  75
  76 /**
  77  * snd_hda_jack_tbl_get_from_tag - query the jack-table entry for the given tag
  78  */
  79 struct hda_jack_tbl *
  80 snd_hda_jack_tbl_get_from_tag(struct hda_codec *codec, unsigned char tag)
  81 {
  82         struct hda_jack_tbl *jack = codec->jacktbl.list;
  83         int i;
  84
  85         if (!tag || !jack)
  86                 return NULL;
  87         for (i = 0; i < codec->jacktbl.used; i++, jack++)
  88                 if (jack->tag == tag)
  89                         return jack;
  90         return NULL;
  91 }
  92 EXPORT_SYMBOL_GPL(snd_hda_jack_tbl_get_from_tag);
  93
  94 /**
  95  * snd_hda_jack_tbl_new - create a jack-table entry for the given NID
  96  */
  97 struct hda_jack_tbl *
  98 snd_hda_jack_tbl_new(struct hda_codec *codec, hda_nid_t nid)
  99 {
 100         struct hda_jack_tbl *jack = snd_hda_jack_tbl_get(codec, nid);
 101         if (jack)
 102                 return jack;
 103         jack = snd_array_new(&codec->jacktbl);
 104         if (!jack)
 105                 return NULL;
 106         jack->nid = nid;
 107         jack->jack_dirty = 1;
 108         jack->tag = codec->jacktbl.used;
 109         return jack;
 110 }
 111 EXPORT_SYMBOL_GPL(snd_hda_jack_tbl_new);
 112
 113 void snd_hda_jack_tbl_clear(struct hda_codec *codec)
 114 {
 115 #ifdef CONFIG_SND_HDA_INPUT_JACK
 116         /* free jack instances manually when clearing/reconfiguring */
 117         if (!codec->bus->shutdown && codec->jacktbl.list) {
 118                 struct hda_jack_tbl *jack = codec->jacktbl.list;
 119                 int i;
 120                 for (i = 0; i < codec->jacktbl.used; i++, jack++) {
 121                         if (jack->jack)
 122                                 snd_device_free(codec->bus->card, jack->jack);
 123                 }
 124         }
 125 #endif
 126         snd_array_free(&codec->jacktbl);
 127 }
 128
 129 #define get_jack_plug_state(sense) !!(sense & AC_PINSENSE_PRESENCE)
 130
 131 /* update the cached value and notification flag if needed */
 132 static void jack_detect_update(struct hda_codec *codec,
 133                                struct hda_jack_tbl *jack)
 134 {
 135         if (!jack->jack_dirty)
 136                 return;
 137
 138         if (jack->phantom_jack)
 139                 jack->pin_sense = AC_PINSENSE_PRESENCE;
 140         else
 141                 jack->pin_sense = read_pin_sense(codec, jack->nid);
 142
 143         /* A gating jack indicates the jack is invalid if gating is unplugged */
 144         if (jack->gating_jack && !snd_hda_jack_detect(codec, jack->gating_jack))
 145                 jack->pin_sense &= ~AC_PINSENSE_PRESENCE;
 146
 147         jack->jack_dirty = 0;
 148
 149         /* If a jack is gated by this one update it. */
 150         if (jack->gated_jack) {
 151                 struct hda_jack_tbl *gated =
 152                         snd_hda_jack_tbl_get(codec, jack->gated_jack);
 153                 if (gated) {
 154                         gated->jack_dirty = 1;
 155                         jack_detect_update(codec, gated);
 156                 }
 157         }
 158 }
 159
 160 /**
 161  * snd_hda_set_dirty_all - Mark all the cached as dirty
 162  *
 163  * This function sets the dirty flag to all entries of jack table.
 164  * It's called from the resume path in hda_codec.c.
 165  */
 166 void snd_hda_jack_set_dirty_all(struct hda_codec *codec)
 167 {
 168         struct hda_jack_tbl *jack = codec->jacktbl.list;
 169         int i;
 170
 171         for (i = 0; i < codec->jacktbl.used; i++, jack++)
 172                 if (jack->nid)
 173                         jack->jack_dirty = 1;
 174 }
 175 EXPORT_SYMBOL_GPL(snd_hda_jack_set_dirty_all);
 176
 177 /**
 178  * snd_hda_pin_sense - execute pin sense measurement
 179  * @codec: the CODEC to sense
 180  * @nid: the pin NID to sense
 181  *
 182  * Execute necessary pin sense measurement and return its Presence Detect,
 183  * Impedance, ELD Valid etc. status bits.
 184  */
 185 u32 snd_hda_pin_sense(struct hda_codec *codec, hda_nid_t nid)
 186 {
 187         struct hda_jack_tbl *jack = snd_hda_jack_tbl_get(codec, nid);
 188         if (jack) {
 189                 jack_detect_update(codec, jack);
 190                 return jack->pin_sense;
 191         }
 192         return read_pin_sense(codec, nid);
 193 }
 194 EXPORT_SYMBOL_GPL(snd_hda_pin_sense);
 195
 196 /**
 197  * snd_hda_jack_detect_state - query pin Presence Detect status
 198  * @codec: the CODEC to sense
 199  * @nid: the pin NID to sense
 200  *
 201  * Query and return the pin's Presence Detect status, as either
 202  * HDA_JACK_NOT_PRESENT, HDA_JACK_PRESENT or HDA_JACK_PHANTOM.
 203  */
 204 int snd_hda_jack_detect_state(struct hda_codec *codec, hda_nid_t nid)
 205 {
 206         struct hda_jack_tbl *jack = snd_hda_jack_tbl_get(codec, nid);
 207         if (jack && jack->phantom_jack)
 208                 return HDA_JACK_PHANTOM;
 209         else if (snd_hda_pin_sense(codec, nid) & AC_PINSENSE_PRESENCE)
 210                 return HDA_JACK_PRESENT;
 211         else
 212                 return HDA_JACK_NOT_PRESENT;
 213 }
 214 EXPORT_SYMBOL_GPL(snd_hda_jack_detect_state);
 215
 216 /**
 217  * snd_hda_jack_detect_enable - enable the jack-detection
 218  */
 219 int snd_hda_jack_detect_enable_callback(struct hda_codec *codec, hda_nid_t nid,
 220                                         hda_jack_callback cb)
 221 {
 222         struct hda_jack_tbl *jack = snd_hda_jack_tbl_new(codec, nid);
 223         if (!jack)
 224                 return -ENOMEM;
 225         if (jack->jack_detect)
 226                 return 0; /* already registered */
 227         jack->jack_detect = 1;
 228         if (cb)
 229                 jack->callback = cb;
 230         if (codec->jackpoll_interval > 0)
 231                 return 0; /* No unsol if we're polling instead */
 232         return snd_hda_codec_write_cache(codec, nid, 0,
 233                                          AC_VERB_SET_UNSOLICITED_ENABLE,
 234                                          AC_USRSP_EN | jack->tag);
 235 }
 236 EXPORT_SYMBOL_GPL(snd_hda_jack_detect_enable_callback);
 237
 238 int snd_hda_jack_detect_enable(struct hda_codec *codec, hda_nid_t nid)
 239 {
 240         return snd_hda_jack_detect_enable_callback(codec, nid, NULL);
 241 }
 242 EXPORT_SYMBOL_GPL(snd_hda_jack_detect_enable);
 243
 244 /**
 245  * snd_hda_jack_set_gating_jack - Set gating jack.
 246  *
 247  * Indicates the gated jack is only valid when the gating jack is plugged.
 248  */
 249 int snd_hda_jack_set_gating_jack(struct hda_codec *codec, hda_nid_t gated_nid,
 250                                  hda_nid_t gating_nid)
 251 {
 252         struct hda_jack_tbl *gated = snd_hda_jack_tbl_new(codec, gated_nid);
 253         struct hda_jack_tbl *gating = snd_hda_jack_tbl_new(codec, gating_nid);
 254
 255         if (!gated || !gating)
 256                 return -EINVAL;
 257
 258         gated->gating_jack = gating_nid;
 259         gating->gated_jack = gated_nid;
 260
 261         return 0;
 262 }
 263 EXPORT_SYMBOL_GPL(snd_hda_jack_set_gating_jack);
 264
 265 /**
 266  * snd_hda_jack_report_sync - sync the states of all jacks and report if changed
 267  */
 268 void snd_hda_jack_report_sync(struct hda_codec *codec)
 269 {
 270         struct hda_jack_tbl *jack;
 271         int i, state;
 272
 273         /* update all jacks at first */
 274         jack = codec->jacktbl.list;
 275         for (i = 0; i < codec->jacktbl.used; i++, jack++)
 276                 if (jack->nid)
 277                         jack_detect_update(codec, jack);
 278
 279         /* report the updated jacks; it's done after updating all jacks
 280          * to make sure that all gating jacks properly have been set
 281          */
 282         jack = codec->jacktbl.list;
 283         for (i = 0; i < codec->jacktbl.used; i++, jack++)
 284                 if (jack->nid) {
 285                         if (!jack->kctl || jack->block_report)
 286                                 continue;
 287                         state = get_jack_plug_state(jack->pin_sense);
 288                         snd_kctl_jack_report(codec->bus->card, jack->kctl, state);
 289 #ifdef CONFIG_SND_HDA_INPUT_JACK
 290                         if (jack->jack)
 291                                 snd_jack_report(jack->jack,
 292                                                 state ? jack->type : 0);
 293 #endif
 294                 }
 295 }
 296 EXPORT_SYMBOL_GPL(snd_hda_jack_report_sync);
 297
 298 #ifdef CONFIG_SND_HDA_INPUT_JACK
 299 /* guess the jack type from the pin-config */
 300 static int get_input_jack_type(struct hda_codec *codec, hda_nid_t nid)
 301 {
 302         unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
 303         switch (get_defcfg_device(def_conf)) {
 304         case AC_JACK_LINE_OUT:
 305         case AC_JACK_SPEAKER:
 306                 return SND_JACK_LINEOUT;
 307         case AC_JACK_HP_OUT:
 308                 return SND_JACK_HEADPHONE;
 309         case AC_JACK_SPDIF_OUT:
 310         case AC_JACK_DIG_OTHER_OUT:
 311                 return SND_JACK_AVOUT;
 312         case AC_JACK_MIC_IN:
 313                 return SND_JACK_MICROPHONE;
 314         default:
 315                 return SND_JACK_LINEIN;
 316         }
 317 }
 318
 319 static void hda_free_jack_priv(struct snd_jack *jack)
 320 {
 321         struct hda_jack_tbl *jacks = jack->private_data;
 322         jacks->nid = 0;
 323         jacks->jack = NULL;
 324 }
 325 #endif
 326
 327 /**
 328  * snd_hda_jack_add_kctl - Add a kctl for the given pin
 329  *
 330  * This assigns a jack-detection kctl to the given pin.  The kcontrol
 331  * will have the given name and index.
 332  */
 333 static int __snd_hda_jack_add_kctl(struct hda_codec *codec, hda_nid_t nid,
 334                           const char *name, int idx, bool phantom_jack)
 335 {
 336         struct hda_jack_tbl *jack;
 337         struct snd_kcontrol *kctl;
 338         int err, state;
 339
 340         jack = snd_hda_jack_tbl_new(codec, nid);
 341         if (!jack)
 342                 return 0;
 343         if (jack->kctl)
 344                 return 0; /* already created */
 345         kctl = snd_kctl_jack_new(name, idx, codec);
 346         if (!kctl)
 347                 return -ENOMEM;
 348         err = snd_hda_ctl_add(codec, nid, kctl);
 349         if (err < 0)
 350                 return err;
 351         jack->kctl = kctl;
 352         jack->phantom_jack = !!phantom_jack;
 353
 354         state = snd_hda_jack_detect(codec, nid);
 355         snd_kctl_jack_report(codec->bus->card, kctl, state);
 356 #ifdef CONFIG_SND_HDA_INPUT_JACK
 357         if (!phantom_jack) {
 358                 jack->type = get_input_jack_type(codec, nid);
 359                 err = snd_jack_new(codec->bus->card, name, jack->type,
 360                                    &jack->jack);
 361                 if (err < 0)
 362                         return err;
 363                 jack->jack->private_data = jack;
 364                 jack->jack->private_free = hda_free_jack_priv;
 365                 snd_jack_report(jack->jack, state ? jack->type : 0);
 366         }
 367 #endif
 368         return 0;
 369 }
 370
 371 int snd_hda_jack_add_kctl(struct hda_codec *codec, hda_nid_t nid,
 372                           const char *name, int idx)
 373 {
 374         return __snd_hda_jack_add_kctl(codec, nid, name, idx, false);
 375 }
 376 EXPORT_SYMBOL_GPL(snd_hda_jack_add_kctl);
 377
 378 /* get the unique index number for the given kctl name */
 379 static int get_unique_index(struct hda_codec *codec, const char *name, int idx)
 380 {
 381         struct hda_jack_tbl *jack;
 382         int i, len = strlen(name);
 383  again:
 384         jack = codec->jacktbl.list;
 385         for (i = 0; i < codec->jacktbl.used; i++, jack++) {
 386                 /* jack->kctl.id contains "XXX Jack" name string with index */
 387                 if (jack->kctl &&
 388                     !strncmp(name, jack->kctl->id.name, len) &&
 389                     !strcmp(" Jack", jack->kctl->id.name + len) &&
 390                     jack->kctl->id.index == idx) {
 391                         idx++;
 392                         goto again;
 393                 }
 394         }
 395         return idx;
 396 }
 397
 398 static int add_jack_kctl(struct hda_codec *codec, hda_nid_t nid,
 399                          const struct auto_pin_cfg *cfg,
 400                          const char *base_name)
 401 {
 402         unsigned int def_conf, conn;
 403         char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
 404         int idx, err;
 405         bool phantom_jack;
 406
 407         if (!nid)
 408                 return 0;
 409         def_conf = snd_hda_codec_get_pincfg(codec, nid);
 410         conn = get_defcfg_connect(def_conf);
 411         if (conn == AC_JACK_PORT_NONE)
 412                 return 0;
 413         phantom_jack = (conn != AC_JACK_PORT_COMPLEX) ||
 414                        !is_jack_detectable(codec, nid);
 415
 416         if (base_name) {
 417                 strlcpy(name, base_name, sizeof(name));
 418                 idx = 0;
 419         } else
 420                 snd_hda_get_pin_label(codec, nid, cfg, name, sizeof(name), &idx);
 421         if (phantom_jack)
 422                 /* Example final name: "Internal Mic Phantom Jack" */
 423                 strncat(name, " Phantom", sizeof(name) - strlen(name) - 1);
 424         idx = get_unique_index(codec, name, idx);
 425         err = __snd_hda_jack_add_kctl(codec, nid, name, idx, phantom_jack);
 426         if (err < 0)
 427                 return err;
 428
 429         if (!phantom_jack)
 430                 return snd_hda_jack_detect_enable(codec, nid);
 431         return 0;
 432 }
 433
 434 /**
 435  * snd_hda_jack_add_kctls - Add kctls for all pins included in the given pincfg
 436  */
 437 int snd_hda_jack_add_kctls(struct hda_codec *codec,
 438                            const struct auto_pin_cfg *cfg)
 439 {
 440         const hda_nid_t *p;
 441         int i, err;
 442
 443         for (i = 0; i < cfg->num_inputs; i++) {
 444                 /* If we have headphone mics; make sure they get the right name
 445                    before grabbed by output pins */
 446                 if (cfg->inputs[i].is_headphone_mic) {
 447                         if (auto_cfg_hp_outs(cfg) == 1)
 448                                 err = add_jack_kctl(codec, auto_cfg_hp_pins(cfg)[0],
 449                                                     cfg, "Headphone Mic");
 450                         else
 451                                 err = add_jack_kctl(codec, cfg->inputs[i].pin,
 452                                                     cfg, "Headphone Mic");
 453                 } else
 454                         err = add_jack_kctl(codec, cfg->inputs[i].pin, cfg,
 455                                             NULL);
 456                 if (err < 0)
 457                         return err;
 458         }
 459
 460         for (i = 0, p = cfg->line_out_pins; i < cfg->line_outs; i++, p++) {
 461                 err = add_jack_kctl(codec, *p, cfg, NULL);
 462                 if (err < 0)
 463                         return err;
 464         }
 465         for (i = 0, p = cfg->hp_pins; i < cfg->hp_outs; i++, p++) {
 466                 if (*p == *cfg->line_out_pins) /* might be duplicated */
 467                         break;
 468                 err = add_jack_kctl(codec, *p, cfg, NULL);
 469                 if (err < 0)
 470                         return err;
 471         }
 472         for (i = 0, p = cfg->speaker_pins; i < cfg->speaker_outs; i++, p++) {
 473                 if (*p == *cfg->line_out_pins) /* might be duplicated */
 474                         break;
 475                 err = add_jack_kctl(codec, *p, cfg, NULL);
 476                 if (err < 0)
 477                         return err;
 478         }
 479         for (i = 0, p = cfg->dig_out_pins; i < cfg->dig_outs; i++, p++) {
 480                 err = add_jack_kctl(codec, *p, cfg, NULL);
 481                 if (err < 0)
 482                         return err;
 483         }
 484         err = add_jack_kctl(codec, cfg->dig_in_pin, cfg, NULL);
 485         if (err < 0)
 486                 return err;
 487         err = add_jack_kctl(codec, cfg->mono_out_pin, cfg, NULL);
 488         if (err < 0)
 489                 return err;
 490         return 0;
 491 }
 492 EXPORT_SYMBOL_GPL(snd_hda_jack_add_kctls);
 493
 494 static void call_jack_callback(struct hda_codec *codec,
 495                                struct hda_jack_tbl *jack)
 496 {
 497         if (jack->callback)
 498                 jack->callback(codec, jack);
 499         if (jack->gated_jack) {
 500                 struct hda_jack_tbl *gated =
 501                         snd_hda_jack_tbl_get(codec, jack->gated_jack);
 502                 if (gated && gated->callback)
 503                         gated->callback(codec, gated);
 504         }
 505 }
 506
 507 void snd_hda_jack_unsol_event(struct hda_codec *codec, unsigned int res)
 508 {
 509         struct hda_jack_tbl *event;
 510         int tag = (res >> AC_UNSOL_RES_TAG_SHIFT) & 0x7f;
 511
 512         event = snd_hda_jack_tbl_get_from_tag(codec, tag);
 513         if (!event)
 514                 return;
 515         event->jack_dirty = 1;
 516
 517         call_jack_callback(codec, event);
 518         snd_hda_jack_report_sync(codec);
 519 }
 520 EXPORT_SYMBOL_GPL(snd_hda_jack_unsol_event);
 521
 522 void snd_hda_jack_poll_all(struct hda_codec *codec)
 523 {
 524         struct hda_jack_tbl *jack = codec->jacktbl.list;
 525         int i, changes = 0;
 526
 527         for (i = 0; i < codec->jacktbl.used; i++, jack++) {
 528                 unsigned int old_sense;
 529                 if (!jack->nid || !jack->jack_dirty || jack->phantom_jack)
 530                         continue;
 531                 old_sense = get_jack_plug_state(jack->pin_sense);
 532                 jack_detect_update(codec, jack);
 533                 if (old_sense == get_jack_plug_state(jack->pin_sense))
 534                         continue;
 535                 changes = 1;
 536                 call_jack_callback(codec, jack);
 537         }
 538         if (changes)
 539                 snd_hda_jack_report_sync(codec);
 540 }
 541 EXPORT_SYMBOL_GPL(snd_hda_jack_poll_all);
 542