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