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