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         snd_array_init(&codec->jacktbl, sizeof(*jack), 16);
  99         jack = snd_array_new(&codec->jacktbl);
 100         if (!jack)
 101                 return NULL;
 102         jack->nid = nid;
 103         jack->jack_dirty = 1;
 104         jack->tag = codec->jacktbl.used;
 105         return jack;
 106 }
 107 EXPORT_SYMBOL_HDA(snd_hda_jack_tbl_new);
 108
 109 void snd_hda_jack_tbl_clear(struct hda_codec *codec)
 110 {
 111 #ifdef CONFIG_SND_HDA_INPUT_JACK
 112         /* free jack instances manually when clearing/reconfiguring */
 113         if (!codec->bus->shutdown && codec->jacktbl.list) {
 114                 struct hda_jack_tbl *jack = codec->jacktbl.list;
 115                 int i;
 116                 for (i = 0; i < codec->jacktbl.used; i++, jack++) {
 117                         if (jack->jack)
 118                                 snd_device_free(codec->bus->card, jack->jack);
 119                 }
 120         }
 121 #endif
 122         snd_array_free(&codec->jacktbl);
 123 }
 124
 125 /* update the cached value and notification flag if needed */
 126 static void jack_detect_update(struct hda_codec *codec,
 127                                struct hda_jack_tbl *jack)
 128 {
 129         if (!jack->jack_dirty)
 130                 return;
 131
 132         if (jack->phantom_jack)
 133                 jack->pin_sense = AC_PINSENSE_PRESENCE;
 134         else
 135                 jack->pin_sense = read_pin_sense(codec, jack->nid);
 136
 137         jack->jack_dirty = 0;
 138 }
 139
 140 /**
 141  * snd_hda_set_dirty_all - Mark all the cached as dirty
 142  *
 143  * This function sets the dirty flag to all entries of jack table.
 144  * It's called from the resume path in hda_codec.c.
 145  */
 146 void snd_hda_jack_set_dirty_all(struct hda_codec *codec)
 147 {
 148         struct hda_jack_tbl *jack = codec->jacktbl.list;
 149         int i;
 150
 151         for (i = 0; i < codec->jacktbl.used; i++, jack++)
 152                 if (jack->nid)
 153                         jack->jack_dirty = 1;
 154 }
 155 EXPORT_SYMBOL_HDA(snd_hda_jack_set_dirty_all);
 156
 157 /**
 158  * snd_hda_pin_sense - execute pin sense measurement
 159  * @codec: the CODEC to sense
 160  * @nid: the pin NID to sense
 161  *
 162  * Execute necessary pin sense measurement and return its Presence Detect,
 163  * Impedance, ELD Valid etc. status bits.
 164  */
 165 u32 snd_hda_pin_sense(struct hda_codec *codec, hda_nid_t nid)
 166 {
 167         struct hda_jack_tbl *jack = snd_hda_jack_tbl_get(codec, nid);
 168         if (jack) {
 169                 jack_detect_update(codec, jack);
 170                 return jack->pin_sense;
 171         }
 172         return read_pin_sense(codec, nid);
 173 }
 174 EXPORT_SYMBOL_HDA(snd_hda_pin_sense);
 175
 176 #define get_jack_plug_state(sense) !!(sense & AC_PINSENSE_PRESENCE)
 177
 178 /**
 179  * snd_hda_jack_detect - query pin Presence Detect status
 180  * @codec: the CODEC to sense
 181  * @nid: the pin NID to sense
 182  *
 183  * Query and return the pin's Presence Detect status.
 184  */
 185 int snd_hda_jack_detect(struct hda_codec *codec, hda_nid_t nid)
 186 {
 187         u32 sense = snd_hda_pin_sense(codec, nid);
 188         return get_jack_plug_state(sense);
 189 }
 190 EXPORT_SYMBOL_HDA(snd_hda_jack_detect);
 191
 192 /**
 193  * snd_hda_jack_detect_enable - enable the jack-detection
 194  */
 195 int snd_hda_jack_detect_enable_callback(struct hda_codec *codec, hda_nid_t nid,
 196                                         unsigned char action,
 197                                         hda_jack_callback cb)
 198 {
 199         struct hda_jack_tbl *jack = snd_hda_jack_tbl_new(codec, nid);
 200         if (!jack)
 201                 return -ENOMEM;
 202         if (jack->jack_detect)
 203                 return 0; /* already registered */
 204         jack->jack_detect = 1;
 205         if (action)
 206                 jack->action = action;
 207         if (cb)
 208                 jack->callback = cb;
 209         return snd_hda_codec_write_cache(codec, nid, 0,
 210                                          AC_VERB_SET_UNSOLICITED_ENABLE,
 211                                          AC_USRSP_EN | jack->tag);
 212 }
 213 EXPORT_SYMBOL_HDA(snd_hda_jack_detect_enable_callback);
 214
 215 int snd_hda_jack_detect_enable(struct hda_codec *codec, hda_nid_t nid,
 216                                unsigned char action)
 217 {
 218         return snd_hda_jack_detect_enable_callback(codec, nid, action, NULL);
 219 }
 220 EXPORT_SYMBOL_HDA(snd_hda_jack_detect_enable);
 221
 222 /**
 223  * snd_hda_jack_report_sync - sync the states of all jacks and report if changed
 224  */
 225 void snd_hda_jack_report_sync(struct hda_codec *codec)
 226 {
 227         struct hda_jack_tbl *jack = codec->jacktbl.list;
 228         int i, state;
 229
 230         for (i = 0; i < codec->jacktbl.used; i++, jack++)
 231                 if (jack->nid) {
 232                         jack_detect_update(codec, jack);
 233                         if (!jack->kctl)
 234                                 continue;
 235                         state = get_jack_plug_state(jack->pin_sense);
 236                         snd_kctl_jack_report(codec->bus->card, jack->kctl, state);
 237 #ifdef CONFIG_SND_HDA_INPUT_JACK
 238                         if (jack->jack)
 239                                 snd_jack_report(jack->jack,
 240                                                 state ? jack->type : 0);
 241 #endif
 242                 }
 243 }
 244 EXPORT_SYMBOL_HDA(snd_hda_jack_report_sync);
 245
 246 #ifdef CONFIG_SND_HDA_INPUT_JACK
 247 /* guess the jack type from the pin-config */
 248 static int get_input_jack_type(struct hda_codec *codec, hda_nid_t nid)
 249 {
 250         unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
 251         switch (get_defcfg_device(def_conf)) {
 252         case AC_JACK_LINE_OUT:
 253         case AC_JACK_SPEAKER:
 254                 return SND_JACK_LINEOUT;
 255         case AC_JACK_HP_OUT:
 256                 return SND_JACK_HEADPHONE;
 257         case AC_JACK_SPDIF_OUT:
 258         case AC_JACK_DIG_OTHER_OUT:
 259                 return SND_JACK_AVOUT;
 260         case AC_JACK_MIC_IN:
 261                 return SND_JACK_MICROPHONE;
 262         default:
 263                 return SND_JACK_LINEIN;
 264         }
 265 }
 266
 267 static void hda_free_jack_priv(struct snd_jack *jack)
 268 {
 269         struct hda_jack_tbl *jacks = jack->private_data;
 270         jacks->nid = 0;
 271         jacks->jack = NULL;
 272 }
 273 #endif
 274
 275 /**
 276  * snd_hda_jack_add_kctl - Add a kctl for the given pin
 277  *
 278  * This assigns a jack-detection kctl to the given pin.  The kcontrol
 279  * will have the given name and index.
 280  */
 281 static int __snd_hda_jack_add_kctl(struct hda_codec *codec, hda_nid_t nid,
 282                           const char *name, int idx, bool phantom_jack)
 283 {
 284         struct hda_jack_tbl *jack;
 285         struct snd_kcontrol *kctl;
 286         int err, state;
 287
 288         jack = snd_hda_jack_tbl_new(codec, nid);
 289         if (!jack)
 290                 return 0;
 291         if (jack->kctl)
 292                 return 0; /* already created */
 293         kctl = snd_kctl_jack_new(name, idx, codec);
 294         if (!kctl)
 295                 return -ENOMEM;
 296         err = snd_hda_ctl_add(codec, nid, kctl);
 297         if (err < 0)
 298                 return err;
 299         jack->kctl = kctl;
 300         jack->phantom_jack = !!phantom_jack;
 301
 302         state = snd_hda_jack_detect(codec, nid);
 303         snd_kctl_jack_report(codec->bus->card, kctl, state);
 304 #ifdef CONFIG_SND_HDA_INPUT_JACK
 305         if (!phantom_jack) {
 306                 jack->type = get_input_jack_type(codec, nid);
 307                 err = snd_jack_new(codec->bus->card, name, jack->type,
 308                                    &jack->jack);
 309                 if (err < 0)
 310                         return err;
 311                 jack->jack->private_data = jack;
 312                 jack->jack->private_free = hda_free_jack_priv;
 313                 snd_jack_report(jack->jack, state ? jack->type : 0);
 314         }
 315 #endif
 316         return 0;
 317 }
 318
 319 int snd_hda_jack_add_kctl(struct hda_codec *codec, hda_nid_t nid,
 320                           const char *name, int idx)
 321 {
 322         return __snd_hda_jack_add_kctl(codec, nid, name, idx, false);
 323 }
 324 EXPORT_SYMBOL_HDA(snd_hda_jack_add_kctl);
 325
 326 /* get the unique index number for the given kctl name */
 327 static int get_unique_index(struct hda_codec *codec, const char *name, int idx)
 328 {
 329         struct hda_jack_tbl *jack;
 330         int i, len = strlen(name);
 331  again:
 332         jack = codec->jacktbl.list;
 333         for (i = 0; i < codec->jacktbl.used; i++, jack++) {
 334                 /* jack->kctl.id contains "XXX Jack" name string with index */
 335                 if (jack->kctl &&
 336                     !strncmp(name, jack->kctl->id.name, len) &&
 337                     !strcmp(" Jack", jack->kctl->id.name + len) &&
 338                     jack->kctl->id.index == idx) {
 339                         idx++;
 340                         goto again;
 341                 }
 342         }
 343         return idx;
 344 }
 345
 346 static int add_jack_kctl(struct hda_codec *codec, hda_nid_t nid,
 347                          const struct auto_pin_cfg *cfg)
 348 {
 349         unsigned int def_conf, conn;
 350         char name[44];
 351         int idx, err;
 352         bool phantom_jack;
 353
 354         if (!nid)
 355                 return 0;
 356         def_conf = snd_hda_codec_get_pincfg(codec, nid);
 357         conn = get_defcfg_connect(def_conf);
 358         if (conn == AC_JACK_PORT_NONE)
 359                 return 0;
 360         phantom_jack = (conn != AC_JACK_PORT_COMPLEX) ||
 361                        !is_jack_detectable(codec, nid);
 362
 363         snd_hda_get_pin_label(codec, nid, cfg, name, sizeof(name), &idx);
 364         if (phantom_jack)
 365                 /* Example final name: "Internal Mic Phantom Jack" */
 366                 strncat(name, " Phantom", sizeof(name) - strlen(name) - 1);
 367         idx = get_unique_index(codec, name, idx);
 368         err = __snd_hda_jack_add_kctl(codec, nid, name, idx, phantom_jack);
 369         if (err < 0)
 370                 return err;
 371
 372         if (!phantom_jack)
 373                 return snd_hda_jack_detect_enable(codec, nid, 0);
 374         return 0;
 375 }
 376
 377 /**
 378  * snd_hda_jack_add_kctls - Add kctls for all pins included in the given pincfg
 379  */
 380 int snd_hda_jack_add_kctls(struct hda_codec *codec,
 381                            const struct auto_pin_cfg *cfg)
 382 {
 383         const hda_nid_t *p;
 384         int i, err;
 385
 386         for (i = 0, p = cfg->line_out_pins; i < cfg->line_outs; i++, p++) {
 387                 err = add_jack_kctl(codec, *p, cfg);
 388                 if (err < 0)
 389                         return err;
 390         }
 391         for (i = 0, p = cfg->hp_pins; i < cfg->hp_outs; i++, p++) {
 392                 if (*p == *cfg->line_out_pins) /* might be duplicated */
 393                         break;
 394                 err = add_jack_kctl(codec, *p, cfg);
 395                 if (err < 0)
 396                         return err;
 397         }
 398         for (i = 0, p = cfg->speaker_pins; i < cfg->speaker_outs; i++, p++) {
 399                 if (*p == *cfg->line_out_pins) /* might be duplicated */
 400                         break;
 401                 err = add_jack_kctl(codec, *p, cfg);
 402                 if (err < 0)
 403                         return err;
 404         }
 405         for (i = 0; i < cfg->num_inputs; i++) {
 406                 err = add_jack_kctl(codec, cfg->inputs[i].pin, cfg);
 407                 if (err < 0)
 408                         return err;
 409         }
 410         for (i = 0, p = cfg->dig_out_pins; i < cfg->dig_outs; i++, p++) {
 411                 err = add_jack_kctl(codec, *p, cfg);
 412                 if (err < 0)
 413                         return err;
 414         }
 415         err = add_jack_kctl(codec, cfg->dig_in_pin, cfg);
 416         if (err < 0)
 417                 return err;
 418         err = add_jack_kctl(codec, cfg->mono_out_pin, cfg);
 419         if (err < 0)
 420                 return err;
 421         return 0;
 422 }
 423 EXPORT_SYMBOL_HDA(snd_hda_jack_add_kctls);
 424
 425 void snd_hda_jack_unsol_event(struct hda_codec *codec, unsigned int res)
 426 {
 427         struct hda_jack_tbl *event;
 428         int tag = (res >> AC_UNSOL_RES_TAG_SHIFT) & 0x7f;
 429
 430         event = snd_hda_jack_tbl_get_from_tag(codec, tag);
 431         if (!event)
 432                 return;
 433         event->jack_dirty = 1;
 434
 435         if (event->callback)
 436                 event->callback(codec, event);
 437
 438         snd_hda_jack_report_sync(codec);
 439 }
 440 EXPORT_SYMBOL_HDA(snd_hda_jack_unsol_event);
 441