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_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         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_HDA(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_HDA(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_HDA(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_HDA(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_HDA(snd_hda_pin_sense);
 195
 196 /**
 197  * snd_hda_jack_detect - 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.
 202  */
 203 int snd_hda_jack_detect(struct hda_codec *codec, hda_nid_t nid)
 204 {
 205         u32 sense = snd_hda_pin_sense(codec, nid);
 206         return get_jack_plug_state(sense);
 207 }
 208 EXPORT_SYMBOL_HDA(snd_hda_jack_detect);
 209
 210 /**
 211  * snd_hda_jack_detect_enable - enable the jack-detection
 212  */
 213 int snd_hda_jack_detect_enable_callback(struct hda_codec *codec, hda_nid_t nid,
 214                                         unsigned char action,
 215                                         hda_jack_callback cb)
 216 {
 217         struct hda_jack_tbl *jack = snd_hda_jack_tbl_new(codec, nid);
 218         if (!jack)
 219                 return -ENOMEM;
 220         if (jack->jack_detect)
 221                 return 0; /* already registered */
 222         jack->jack_detect = 1;
 223         if (action)
 224                 jack->action = action;
 225         if (cb)
 226                 jack->callback = cb;
 227         if (codec->jackpoll_interval > 0)
 228                 return 0; /* No unsol if we're polling instead */
 229         return snd_hda_codec_write_cache(codec, nid, 0,
 230                                          AC_VERB_SET_UNSOLICITED_ENABLE,
 231                                          AC_USRSP_EN | jack->tag);
 232 }
 233 EXPORT_SYMBOL_HDA(snd_hda_jack_detect_enable_callback);
 234
 235 int snd_hda_jack_detect_enable(struct hda_codec *codec, hda_nid_t nid,
 236                                unsigned char action)
 237 {
 238         return snd_hda_jack_detect_enable_callback(codec, nid, action, NULL);
 239 }
 240 EXPORT_SYMBOL_HDA(snd_hda_jack_detect_enable);
 241
 242 /**
 243  * snd_hda_jack_set_gating_jack - Set gating jack.
 244  *
 245  * Indicates the gated jack is only valid when the gating jack is plugged.
 246  */
 247 int snd_hda_jack_set_gating_jack(struct hda_codec *codec, hda_nid_t gated_nid,
 248                                  hda_nid_t gating_nid)
 249 {
 250         struct hda_jack_tbl *gated = snd_hda_jack_tbl_get(codec, gated_nid);
 251         struct hda_jack_tbl *gating = snd_hda_jack_tbl_get(codec, gating_nid);
 252
 253         if (!gated || !gating)
 254                 return -EINVAL;
 255
 256         gated->gating_jack = gating_nid;
 257         gating->gated_jack = gated_nid;
 258
 259         return 0;
 260 }
 261 EXPORT_SYMBOL_HDA(snd_hda_jack_set_gating_jack);
 262
 263 /**
 264  * snd_hda_jack_report_sync - sync the states of all jacks and report if changed
 265  */
 266 void snd_hda_jack_report_sync(struct hda_codec *codec)
 267 {
 268         struct hda_jack_tbl *jack;
 269         int i, state;
 270
 271         /* update all jacks at first */
 272         jack = codec->jacktbl.list;
 273         for (i = 0; i < codec->jacktbl.used; i++, jack++)
 274                 if (jack->nid)
 275                         jack_detect_update(codec, jack);
 276
 277         /* report the updated jacks; it's done after updating all jacks
 278          * to make sure that all gating jacks properly have been set
 279          */
 280         jack = codec->jacktbl.list;
 281         for (i = 0; i < codec->jacktbl.used; i++, jack++)
 282                 if (jack->nid) {
 283                         if (!jack->kctl)
 284                                 continue;
 285                         state = get_jack_plug_state(jack->pin_sense);
 286                         snd_kctl_jack_report(codec->bus->card, jack->kctl, state);
 287 #ifdef CONFIG_SND_HDA_INPUT_JACK
 288                         if (jack->jack)
 289                                 snd_jack_report(jack->jack,
 290                                                 state ? jack->type : 0);
 291 #endif
 292                 }
 293 }
 294 EXPORT_SYMBOL_HDA(snd_hda_jack_report_sync);
 295
 296 #ifdef CONFIG_SND_HDA_INPUT_JACK
 297 /* guess the jack type from the pin-config */
 298 static int get_input_jack_type(struct hda_codec *codec, hda_nid_t nid)
 299 {
 300         unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
 301         switch (get_defcfg_device(def_conf)) {
 302         case AC_JACK_LINE_OUT:
 303         case AC_JACK_SPEAKER:
 304                 return SND_JACK_LINEOUT;
 305         case AC_JACK_HP_OUT:
 306                 return SND_JACK_HEADPHONE;
 307         case AC_JACK_SPDIF_OUT:
 308         case AC_JACK_DIG_OTHER_OUT:
 309                 return SND_JACK_AVOUT;
 310         case AC_JACK_MIC_IN:
 311                 return SND_JACK_MICROPHONE;
 312         default:
 313                 return SND_JACK_LINEIN;
 314         }
 315 }
 316
 317 static void hda_free_jack_priv(struct snd_jack *jack)
 318 {
 319         struct hda_jack_tbl *jacks = jack->private_data;
 320         jacks->nid = 0;
 321         jacks->jack = NULL;
 322 }
 323 #endif
 324
 325 /**
 326  * snd_hda_jack_add_kctl - Add a kctl for the given pin
 327  *
 328  * This assigns a jack-detection kctl to the given pin.  The kcontrol
 329  * will have the given name and index.
 330  */
 331 static int __snd_hda_jack_add_kctl(struct hda_codec *codec, hda_nid_t nid,
 332                           const char *name, int idx, bool phantom_jack)
 333 {
 334         struct hda_jack_tbl *jack;
 335         struct snd_kcontrol *kctl;
 336         int err, state;
 337
 338         jack = snd_hda_jack_tbl_new(codec, nid);
 339         if (!jack)
 340                 return 0;
 341         if (jack->kctl)
 342                 return 0; /* already created */
 343         kctl = snd_kctl_jack_new(name, idx, codec);
 344         if (!kctl)
 345                 return -ENOMEM;
 346         err = snd_hda_ctl_add(codec, nid, kctl);
 347         if (err < 0)
 348                 return err;
 349         jack->kctl = kctl;
 350         jack->phantom_jack = !!phantom_jack;
 351
 352         state = snd_hda_jack_detect(codec, nid);
 353         snd_kctl_jack_report(codec->bus->card, kctl, state);
 354 #ifdef CONFIG_SND_HDA_INPUT_JACK
 355         if (!phantom_jack) {
 356                 jack->type = get_input_jack_type(codec, nid);
 357                 err = snd_jack_new(codec->bus->card, name, jack->type,
 358                                    &jack->jack);
 359                 if (err < 0)
 360                         return err;
 361                 jack->jack->private_data = jack;
 362                 jack->jack->private_free = hda_free_jack_priv;
 363                 snd_jack_report(jack->jack, state ? jack->type : 0);
 364         }
 365 #endif
 366         return 0;
 367 }
 368
 369 int snd_hda_jack_add_kctl(struct hda_codec *codec, hda_nid_t nid,
 370                           const char *name, int idx)
 371 {
 372         return __snd_hda_jack_add_kctl(codec, nid, name, idx, false);
 373 }
 374 EXPORT_SYMBOL_HDA(snd_hda_jack_add_kctl);
 375
 376 /* get the unique index number for the given kctl name */
 377 static int get_unique_index(struct hda_codec *codec, const char *name, int idx)
 378 {
 379         struct hda_jack_tbl *jack;
 380         int i, len = strlen(name);
 381  again:
 382         jack = codec->jacktbl.list;
 383         for (i = 0; i < codec->jacktbl.used; i++, jack++) {
 384                 /* jack->kctl.id contains "XXX Jack" name string with index */
 385                 if (jack->kctl &&
 386                     !strncmp(name, jack->kctl->id.name, len) &&
 387                     !strcmp(" Jack", jack->kctl->id.name + len) &&
 388                     jack->kctl->id.index == idx) {
 389                         idx++;
 390                         goto again;
 391                 }
 392         }
 393         return idx;
 394 }
 395
 396 static int add_jack_kctl(struct hda_codec *codec, hda_nid_t nid,
 397                          const struct auto_pin_cfg *cfg)
 398 {
 399         unsigned int def_conf, conn;
 400         char name[44];
 401         int idx, err;
 402         bool phantom_jack;
 403
 404         if (!nid)
 405                 return 0;
 406         def_conf = snd_hda_codec_get_pincfg(codec, nid);
 407         conn = get_defcfg_connect(def_conf);
 408         if (conn == AC_JACK_PORT_NONE)
 409                 return 0;
 410         phantom_jack = (conn != AC_JACK_PORT_COMPLEX) ||
 411                        !is_jack_detectable(codec, nid);
 412
 413         snd_hda_get_pin_label(codec, nid, cfg, name, sizeof(name), &idx);
 414         if (phantom_jack)
 415                 /* Example final name: "Internal Mic Phantom Jack" */
 416                 strncat(name, " Phantom", sizeof(name) - strlen(name) - 1);
 417         idx = get_unique_index(codec, name, idx);
 418         err = __snd_hda_jack_add_kctl(codec, nid, name, idx, phantom_jack);
 419         if (err < 0)
 420                 return err;
 421
 422         if (!phantom_jack)
 423                 return snd_hda_jack_detect_enable(codec, nid, 0);
 424         return 0;
 425 }
 426
 427 /**
 428  * snd_hda_jack_add_kctls - Add kctls for all pins included in the given pincfg
 429  */
 430 int snd_hda_jack_add_kctls(struct hda_codec *codec,
 431                            const struct auto_pin_cfg *cfg)
 432 {
 433         const hda_nid_t *p;
 434         int i, err;
 435
 436         for (i = 0, p = cfg->line_out_pins; i < cfg->line_outs; i++, p++) {
 437                 err = add_jack_kctl(codec, *p, cfg);
 438                 if (err < 0)
 439                         return err;
 440         }
 441         for (i = 0, p = cfg->hp_pins; i < cfg->hp_outs; i++, p++) {
 442                 if (*p == *cfg->line_out_pins) /* might be duplicated */
 443                         break;
 444                 err = add_jack_kctl(codec, *p, cfg);
 445                 if (err < 0)
 446                         return err;
 447         }
 448         for (i = 0, p = cfg->speaker_pins; i < cfg->speaker_outs; i++, p++) {
 449                 if (*p == *cfg->line_out_pins) /* might be duplicated */
 450                         break;
 451                 err = add_jack_kctl(codec, *p, cfg);
 452                 if (err < 0)
 453                         return err;
 454         }
 455         for (i = 0; i < cfg->num_inputs; i++) {
 456                 err = add_jack_kctl(codec, cfg->inputs[i].pin, cfg);
 457                 if (err < 0)
 458                         return err;
 459         }
 460         for (i = 0, p = cfg->dig_out_pins; i < cfg->dig_outs; i++, p++) {
 461                 err = add_jack_kctl(codec, *p, cfg);
 462                 if (err < 0)
 463                         return err;
 464         }
 465         err = add_jack_kctl(codec, cfg->dig_in_pin, cfg);
 466         if (err < 0)
 467                 return err;
 468         err = add_jack_kctl(codec, cfg->mono_out_pin, cfg);
 469         if (err < 0)
 470                 return err;
 471         return 0;
 472 }
 473 EXPORT_SYMBOL_HDA(snd_hda_jack_add_kctls);
 474
 475 static void call_jack_callback(struct hda_codec *codec,
 476                                struct hda_jack_tbl *jack)
 477 {
 478         if (jack->callback)
 479                 jack->callback(codec, jack);
 480         if (jack->gated_jack) {
 481                 struct hda_jack_tbl *gated =
 482                         snd_hda_jack_tbl_get(codec, jack->gated_jack);
 483                 if (gated && gated->callback)
 484                         gated->callback(codec, gated);
 485         }
 486 }
 487
 488 void snd_hda_jack_unsol_event(struct hda_codec *codec, unsigned int res)
 489 {
 490         struct hda_jack_tbl *event;
 491         int tag = (res >> AC_UNSOL_RES_TAG_SHIFT) & 0x7f;
 492
 493         event = snd_hda_jack_tbl_get_from_tag(codec, tag);
 494         if (!event)
 495                 return;
 496         event->jack_dirty = 1;
 497
 498         call_jack_callback(codec, event);
 499         snd_hda_jack_report_sync(codec);
 500 }
 501 EXPORT_SYMBOL_HDA(snd_hda_jack_unsol_event);
 502
 503 void snd_hda_jack_poll_all(struct hda_codec *codec)
 504 {
 505         struct hda_jack_tbl *jack = codec->jacktbl.list;
 506         int i, changes = 0;
 507
 508         for (i = 0; i < codec->jacktbl.used; i++, jack++) {
 509                 unsigned int old_sense;
 510                 if (!jack->nid || !jack->jack_dirty || jack->phantom_jack)
 511                         continue;
 512                 old_sense = get_jack_plug_state(jack->pin_sense);
 513                 jack_detect_update(codec, jack);
 514                 if (old_sense == get_jack_plug_state(jack->pin_sense))
 515                         continue;
 516                 changes = 1;
 517                 call_jack_callback(codec, jack);
 518         }
 519         if (changes)
 520                 snd_hda_jack_report_sync(codec);
 521 }
 522 EXPORT_SYMBOL_HDA(snd_hda_jack_poll_all);
 523