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 (!codec->ignore_misc_bit && 30 (get_defcfg_misc(snd_hda_codec_get_pincfg(codec, nid)) & 31 AC_DEFCFG_MISC_NO_PRESENCE)) 32 return false; 33 if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP)) 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 44 if (!codec->no_trigger_sense) { 45 pincap = snd_hda_query_pin_caps(codec, nid); 46 if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */ 47 snd_hda_codec_read(codec, nid, 0, 48 AC_VERB_SET_PIN_SENSE, 0); 49 } 50 return snd_hda_codec_read(codec, nid, 0, 51 AC_VERB_GET_PIN_SENSE, 0); 52 } 53 54 /** 55 * snd_hda_jack_tbl_get - query the jack-table entry for the given NID 56 */ 57 struct hda_jack_tbl * 58 snd_hda_jack_tbl_get(struct hda_codec *codec, hda_nid_t nid) 59 { 60 struct hda_jack_tbl *jack = codec->jacktbl.list; 61 int i; 62 63 if (!nid || !jack) 64 return NULL; 65 for (i = 0; i < codec->jacktbl.used; i++, jack++) 66 if (jack->nid == nid) 67 return jack; 68 return NULL; 69 } 70 EXPORT_SYMBOL_HDA(snd_hda_jack_tbl_get); 71 72 /** 73 * snd_hda_jack_tbl_get_from_tag - query the jack-table entry for the given tag 74 */ 75 struct hda_jack_tbl * 76 snd_hda_jack_tbl_get_from_tag(struct hda_codec *codec, unsigned char tag) 77 { 78 struct hda_jack_tbl *jack = codec->jacktbl.list; 79 int i; 80 81 if (!tag || !jack) 82 return NULL; 83 for (i = 0; i < codec->jacktbl.used; i++, jack++) 84 if (jack->tag == tag) 85 return jack; 86 return NULL; 87 } 88 EXPORT_SYMBOL_HDA(snd_hda_jack_tbl_get_from_tag); 89 90 /** 91 * snd_hda_jack_tbl_new - create a jack-table entry for the given NID 92 */ 93 struct hda_jack_tbl * 94 snd_hda_jack_tbl_new(struct hda_codec *codec, hda_nid_t nid) 95 { 96 struct hda_jack_tbl *jack = snd_hda_jack_tbl_get(codec, nid); 97 if (jack) 98 return jack; 99 snd_array_init(&codec->jacktbl, sizeof(*jack), 16); 100 jack = snd_array_new(&codec->jacktbl); 101 if (!jack) 102 return NULL; 103 jack->nid = nid; 104 jack->jack_dirty = 1; 105 jack->tag = codec->jacktbl.used; 106 return jack; 107 } 108 EXPORT_SYMBOL_HDA(snd_hda_jack_tbl_new); 109 110 void snd_hda_jack_tbl_clear(struct hda_codec *codec) 111 { 112 #ifdef CONFIG_SND_HDA_INPUT_JACK 113 /* free jack instances manually when clearing/reconfiguring */ 114 if (!codec->bus->shutdown && codec->jacktbl.list) { 115 struct hda_jack_tbl *jack = codec->jacktbl.list; 116 int i; 117 for (i = 0; i < codec->jacktbl.used; i++, jack++) { 118 if (jack->jack) 119 snd_device_free(codec->bus->card, jack->jack); 120 } 121 } 122 #endif 123 snd_array_free(&codec->jacktbl); 124 } 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 || !jack->jack_detect) { 131 jack->pin_sense = read_pin_sense(codec, jack->nid); 132 jack->jack_dirty = 0; 133 } 134 } 135 136 /** 137 * snd_hda_set_dirty_all - Mark all the cached as dirty 138 * 139 * This function sets the dirty flag to all entries of jack table. 140 * It's called from the resume path in hda_codec.c. 141 */ 142 void snd_hda_jack_set_dirty_all(struct hda_codec *codec) 143 { 144 struct hda_jack_tbl *jack = codec->jacktbl.list; 145 int i; 146 147 for (i = 0; i < codec->jacktbl.used; i++, jack++) 148 if (jack->nid) 149 jack->jack_dirty = 1; 150 } 151 EXPORT_SYMBOL_HDA(snd_hda_jack_set_dirty_all); 152 153 /** 154 * snd_hda_pin_sense - execute pin sense measurement 155 * @codec: the CODEC to sense 156 * @nid: the pin NID to sense 157 * 158 * Execute necessary pin sense measurement and return its Presence Detect, 159 * Impedance, ELD Valid etc. status bits. 160 */ 161 u32 snd_hda_pin_sense(struct hda_codec *codec, hda_nid_t nid) 162 { 163 struct hda_jack_tbl *jack = snd_hda_jack_tbl_get(codec, nid); 164 if (jack) { 165 jack_detect_update(codec, jack); 166 return jack->pin_sense; 167 } 168 return read_pin_sense(codec, nid); 169 } 170 EXPORT_SYMBOL_HDA(snd_hda_pin_sense); 171 172 #define get_jack_plug_state(sense) !!(sense & AC_PINSENSE_PRESENCE) 173 174 /** 175 * snd_hda_jack_detect - query pin Presence Detect status 176 * @codec: the CODEC to sense 177 * @nid: the pin NID to sense 178 * 179 * Query and return the pin's Presence Detect status. 180 */ 181 int snd_hda_jack_detect(struct hda_codec *codec, hda_nid_t nid) 182 { 183 u32 sense = snd_hda_pin_sense(codec, nid); 184 return get_jack_plug_state(sense); 185 } 186 EXPORT_SYMBOL_HDA(snd_hda_jack_detect); 187 188 /** 189 * snd_hda_jack_detect_enable - enable the jack-detection 190 */ 191 int snd_hda_jack_detect_enable(struct hda_codec *codec, hda_nid_t nid, 192 unsigned char action) 193 { 194 struct hda_jack_tbl *jack = snd_hda_jack_tbl_new(codec, nid); 195 if (!jack) 196 return -ENOMEM; 197 if (jack->jack_detect) 198 return 0; /* already registered */ 199 jack->jack_detect = 1; 200 if (action) 201 jack->action = action; 202 return snd_hda_codec_write_cache(codec, nid, 0, 203 AC_VERB_SET_UNSOLICITED_ENABLE, 204 AC_USRSP_EN | jack->tag); 205 } 206 EXPORT_SYMBOL_HDA(snd_hda_jack_detect_enable); 207 208 /** 209 * snd_hda_jack_report_sync - sync the states of all jacks and report if changed 210 */ 211 void snd_hda_jack_report_sync(struct hda_codec *codec) 212 { 213 struct hda_jack_tbl *jack = codec->jacktbl.list; 214 int i, state; 215 216 for (i = 0; i < codec->jacktbl.used; i++, jack++) 217 if (jack->nid) { 218 jack_detect_update(codec, jack); 219 if (!jack->kctl) 220 continue; 221 state = get_jack_plug_state(jack->pin_sense); 222 snd_kctl_jack_report(codec->bus->card, jack->kctl, state); 223 #ifdef CONFIG_SND_HDA_INPUT_JACK 224 if (jack->jack) 225 snd_jack_report(jack->jack, 226 state ? jack->type : 0); 227 #endif 228 } 229 } 230 EXPORT_SYMBOL_HDA(snd_hda_jack_report_sync); 231 232 #ifdef CONFIG_SND_HDA_INPUT_JACK 233 /* guess the jack type from the pin-config */ 234 static int get_input_jack_type(struct hda_codec *codec, hda_nid_t nid) 235 { 236 unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid); 237 switch (get_defcfg_device(def_conf)) { 238 case AC_JACK_LINE_OUT: 239 case AC_JACK_SPEAKER: 240 return SND_JACK_LINEOUT; 241 case AC_JACK_HP_OUT: 242 return SND_JACK_HEADPHONE; 243 case AC_JACK_SPDIF_OUT: 244 case AC_JACK_DIG_OTHER_OUT: 245 return SND_JACK_AVOUT; 246 case AC_JACK_MIC_IN: 247 return SND_JACK_MICROPHONE; 248 default: 249 return SND_JACK_LINEIN; 250 } 251 } 252 253 static void hda_free_jack_priv(struct snd_jack *jack) 254 { 255 struct hda_jack_tbl *jacks = jack->private_data; 256 jacks->nid = 0; 257 jacks->jack = NULL; 258 } 259 #endif 260 261 /** 262 * snd_hda_jack_add_kctl - Add a kctl for the given pin 263 * 264 * This assigns a jack-detection kctl to the given pin. The kcontrol 265 * will have the given name and index. 266 */ 267 int snd_hda_jack_add_kctl(struct hda_codec *codec, hda_nid_t nid, 268 const char *name, int idx) 269 { 270 struct hda_jack_tbl *jack; 271 struct snd_kcontrol *kctl; 272 int err, state; 273 274 jack = snd_hda_jack_tbl_new(codec, nid); 275 if (!jack) 276 return 0; 277 if (jack->kctl) 278 return 0; /* already created */ 279 kctl = snd_kctl_jack_new(name, idx, codec); 280 if (!kctl) 281 return -ENOMEM; 282 err = snd_hda_ctl_add(codec, nid, kctl); 283 if (err < 0) 284 return err; 285 jack->kctl = kctl; 286 state = snd_hda_jack_detect(codec, nid); 287 snd_kctl_jack_report(codec->bus->card, kctl, state); 288 #ifdef CONFIG_SND_HDA_INPUT_JACK 289 jack->type = get_input_jack_type(codec, nid); 290 err = snd_jack_new(codec->bus->card, name, jack->type, &jack->jack); 291 if (err < 0) 292 return err; 293 jack->jack->private_data = jack; 294 jack->jack->private_free = hda_free_jack_priv; 295 snd_jack_report(jack->jack, state ? jack->type : 0); 296 #endif 297 return 0; 298 } 299 EXPORT_SYMBOL_HDA(snd_hda_jack_add_kctl); 300 301 static int add_jack_kctl(struct hda_codec *codec, hda_nid_t nid, 302 const struct auto_pin_cfg *cfg, 303 char *lastname, int *lastidx) 304 { 305 unsigned int def_conf, conn; 306 char name[44]; 307 int idx, err; 308 309 if (!nid) 310 return 0; 311 if (!is_jack_detectable(codec, nid)) 312 return 0; 313 def_conf = snd_hda_codec_get_pincfg(codec, nid); 314 conn = get_defcfg_connect(def_conf); 315 if (conn != AC_JACK_PORT_COMPLEX) 316 return 0; 317 318 snd_hda_get_pin_label(codec, nid, cfg, name, sizeof(name), &idx); 319 if (!strcmp(name, lastname) && idx == *lastidx) 320 idx++; 321 strncpy(lastname, name, 44); 322 *lastidx = idx; 323 err = snd_hda_jack_add_kctl(codec, nid, name, idx); 324 if (err < 0) 325 return err; 326 return snd_hda_jack_detect_enable(codec, nid, 0); 327 } 328 329 /** 330 * snd_hda_jack_add_kctls - Add kctls for all pins included in the given pincfg 331 */ 332 int snd_hda_jack_add_kctls(struct hda_codec *codec, 333 const struct auto_pin_cfg *cfg) 334 { 335 const hda_nid_t *p; 336 int i, err, lastidx = 0; 337 char lastname[44] = ""; 338 339 for (i = 0, p = cfg->line_out_pins; i < cfg->line_outs; i++, p++) { 340 err = add_jack_kctl(codec, *p, cfg, lastname, &lastidx); 341 if (err < 0) 342 return err; 343 } 344 for (i = 0, p = cfg->hp_pins; i < cfg->hp_outs; i++, p++) { 345 if (*p == *cfg->line_out_pins) /* might be duplicated */ 346 break; 347 err = add_jack_kctl(codec, *p, cfg, lastname, &lastidx); 348 if (err < 0) 349 return err; 350 } 351 for (i = 0, p = cfg->speaker_pins; i < cfg->speaker_outs; i++, p++) { 352 if (*p == *cfg->line_out_pins) /* might be duplicated */ 353 break; 354 err = add_jack_kctl(codec, *p, cfg, lastname, &lastidx); 355 if (err < 0) 356 return err; 357 } 358 for (i = 0; i < cfg->num_inputs; i++) { 359 err = add_jack_kctl(codec, cfg->inputs[i].pin, cfg, lastname, &lastidx); 360 if (err < 0) 361 return err; 362 } 363 for (i = 0, p = cfg->dig_out_pins; i < cfg->dig_outs; i++, p++) { 364 err = add_jack_kctl(codec, *p, cfg, lastname, &lastidx); 365 if (err < 0) 366 return err; 367 } 368 err = add_jack_kctl(codec, cfg->dig_in_pin, cfg, lastname, &lastidx); 369 if (err < 0) 370 return err; 371 err = add_jack_kctl(codec, cfg->mono_out_pin, cfg, lastname, &lastidx); 372 if (err < 0) 373 return err; 374 return 0; 375 } 376 EXPORT_SYMBOL_HDA(snd_hda_jack_add_kctls); 377