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