1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Jack-detection handling for HD-audio
4 *
5 * Copyright (c) 2011 Takashi Iwai <tiwai@suse.de>
6 */
7
8#include <linux/init.h>
9#include <linux/slab.h>
10#include <linux/export.h>
11#include <sound/core.h>
12#include <sound/control.h>
13#include <sound/jack.h>
14#include <sound/hda_codec.h>
15#include "hda_local.h"
16#include "hda_auto_parser.h"
17#include "hda_jack.h"
18
19/**
20 * is_jack_detectable - Check whether the given pin is jack-detectable
21 * @codec: the HDA codec
22 * @nid: pin NID
23 *
24 * Check whether the given pin is capable to report the jack detection.
25 * The jack detection might not work by various reasons, e.g. the jack
26 * detection is prohibited in the codec level, the pin config has
27 * AC_DEFCFG_MISC_NO_PRESENCE bit, no unsol support, etc.
28 */
29bool is_jack_detectable(struct hda_codec *codec, hda_nid_t nid)
30{
31 if (codec->no_jack_detect)
32 return false;
33 if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_PRES_DETECT))
34 return false;
35 if (get_defcfg_misc(snd_hda_codec_get_pincfg(codec, nid)) &
36 AC_DEFCFG_MISC_NO_PRESENCE)
37 return false;
38 if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) &&
39 !codec->jackpoll_interval)
40 return false;
41 return true;
42}
43EXPORT_SYMBOL_GPL(is_jack_detectable);
44
45/* execute pin sense measurement */
46static u32 read_pin_sense(struct hda_codec *codec, hda_nid_t nid, int dev_id)
47{
48 u32 pincap;
49 u32 val;
50
51 if (!codec->no_trigger_sense) {
52 pincap = snd_hda_query_pin_caps(codec, nid);
53 if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */
54 snd_hda_codec_read(codec, nid, flags: 0,
55 AC_VERB_SET_PIN_SENSE, parm: 0);
56 }
57 val = snd_hda_codec_read(codec, nid, flags: 0,
58 AC_VERB_GET_PIN_SENSE, parm: dev_id);
59 if (codec->inv_jack_detect)
60 val ^= AC_PINSENSE_PRESENCE;
61 return val;
62}
63
64/**
65 * snd_hda_jack_tbl_get_mst - query the jack-table entry for the given NID
66 * @codec: the HDA codec
67 * @nid: pin NID to refer to
68 * @dev_id: pin device entry id
69 */
70struct hda_jack_tbl *
71snd_hda_jack_tbl_get_mst(struct hda_codec *codec, hda_nid_t nid, int dev_id)
72{
73 struct hda_jack_tbl *jack = codec->jacktbl.list;
74 int i;
75
76 if (!nid || !jack)
77 return NULL;
78 for (i = 0; i < codec->jacktbl.used; i++, jack++)
79 if (jack->nid == nid && jack->dev_id == dev_id)
80 return jack;
81 return NULL;
82}
83EXPORT_SYMBOL_GPL(snd_hda_jack_tbl_get_mst);
84
85/**
86 * snd_hda_jack_tbl_get_from_tag - query the jack-table entry for the given tag
87 * @codec: the HDA codec
88 * @tag: tag value to refer to
89 * @dev_id: pin device entry id
90 */
91struct hda_jack_tbl *
92snd_hda_jack_tbl_get_from_tag(struct hda_codec *codec,
93 unsigned char tag, int dev_id)
94{
95 struct hda_jack_tbl *jack = codec->jacktbl.list;
96 int i;
97
98 if (!tag || !jack)
99 return NULL;
100 for (i = 0; i < codec->jacktbl.used; i++, jack++)
101 if (jack->tag == tag && jack->dev_id == dev_id)
102 return jack;
103 return NULL;
104}
105EXPORT_SYMBOL_GPL(snd_hda_jack_tbl_get_from_tag);
106
107static struct hda_jack_tbl *
108any_jack_tbl_get_from_nid(struct hda_codec *codec, hda_nid_t nid)
109{
110 struct hda_jack_tbl *jack = codec->jacktbl.list;
111 int i;
112
113 if (!nid || !jack)
114 return NULL;
115 for (i = 0; i < codec->jacktbl.used; i++, jack++)
116 if (jack->nid == nid)
117 return jack;
118 return NULL;
119}
120
121/**
122 * snd_hda_jack_tbl_new - create a jack-table entry for the given NID
123 * @codec: the HDA codec
124 * @nid: pin NID to assign
125 * @dev_id: pin device entry id
126 */
127static struct hda_jack_tbl *
128snd_hda_jack_tbl_new(struct hda_codec *codec, hda_nid_t nid, int dev_id)
129{
130 struct hda_jack_tbl *jack =
131 snd_hda_jack_tbl_get_mst(codec, nid, dev_id);
132 struct hda_jack_tbl *existing_nid_jack =
133 any_jack_tbl_get_from_nid(codec, nid);
134
135 WARN_ON(dev_id != 0 && !codec->dp_mst);
136
137 if (jack)
138 return jack;
139 jack = snd_array_new(array: &codec->jacktbl);
140 if (!jack)
141 return NULL;
142 jack->nid = nid;
143 jack->dev_id = dev_id;
144 jack->jack_dirty = 1;
145 if (existing_nid_jack) {
146 jack->tag = existing_nid_jack->tag;
147
148 /*
149 * Copy jack_detect from existing_nid_jack to avoid
150 * snd_hda_jack_detect_enable_callback_mst() making multiple
151 * SET_UNSOLICITED_ENABLE calls on the same pin.
152 */
153 jack->jack_detect = existing_nid_jack->jack_detect;
154 } else {
155 jack->tag = codec->jacktbl.used;
156 }
157
158 return jack;
159}
160
161void snd_hda_jack_tbl_disconnect(struct hda_codec *codec)
162{
163 struct hda_jack_tbl *jack = codec->jacktbl.list;
164 int i;
165
166 for (i = 0; i < codec->jacktbl.used; i++, jack++) {
167 if (!codec->bus->shutdown && jack->jack)
168 snd_device_disconnect(card: codec->card, device_data: jack->jack);
169 }
170}
171
172void snd_hda_jack_tbl_clear(struct hda_codec *codec)
173{
174 struct hda_jack_tbl *jack = codec->jacktbl.list;
175 int i;
176
177 for (i = 0; i < codec->jacktbl.used; i++, jack++) {
178 struct hda_jack_callback *cb, *next;
179
180 /* free jack instances manually when clearing/reconfiguring */
181 if (!codec->bus->shutdown && jack->jack)
182 snd_device_free(card: codec->card, device_data: jack->jack);
183
184 for (cb = jack->callback; cb; cb = next) {
185 next = cb->next;
186 kfree(objp: cb);
187 }
188 }
189 snd_array_free(array: &codec->jacktbl);
190}
191
192#define get_jack_plug_state(sense) !!(sense & AC_PINSENSE_PRESENCE)
193
194/* update the cached value and notification flag if needed */
195static void jack_detect_update(struct hda_codec *codec,
196 struct hda_jack_tbl *jack)
197{
198 if (!jack->jack_dirty)
199 return;
200
201 if (jack->phantom_jack)
202 jack->pin_sense = AC_PINSENSE_PRESENCE;
203 else
204 jack->pin_sense = read_pin_sense(codec, nid: jack->nid,
205 dev_id: jack->dev_id);
206
207 /* A gating jack indicates the jack is invalid if gating is unplugged */
208 if (jack->gating_jack &&
209 !snd_hda_jack_detect_mst(codec, nid: jack->gating_jack, dev_id: jack->dev_id))
210 jack->pin_sense &= ~AC_PINSENSE_PRESENCE;
211
212 jack->jack_dirty = 0;
213
214 /* If a jack is gated by this one update it. */
215 if (jack->gated_jack) {
216 struct hda_jack_tbl *gated =
217 snd_hda_jack_tbl_get_mst(codec, jack->gated_jack,
218 jack->dev_id);
219 if (gated) {
220 gated->jack_dirty = 1;
221 jack_detect_update(codec, jack: gated);
222 }
223 }
224}
225
226/**
227 * snd_hda_jack_set_dirty_all - Mark all the cached as dirty
228 * @codec: the HDA codec
229 *
230 * This function sets the dirty flag to all entries of jack table.
231 * It's called from the resume path in hda_codec.c.
232 */
233void snd_hda_jack_set_dirty_all(struct hda_codec *codec)
234{
235 struct hda_jack_tbl *jack = codec->jacktbl.list;
236 int i;
237
238 for (i = 0; i < codec->jacktbl.used; i++, jack++)
239 if (jack->nid)
240 jack->jack_dirty = 1;
241}
242EXPORT_SYMBOL_GPL(snd_hda_jack_set_dirty_all);
243
244/**
245 * snd_hda_jack_pin_sense - execute pin sense measurement
246 * @codec: the CODEC to sense
247 * @nid: the pin NID to sense
248 * @dev_id: pin device entry id
249 *
250 * Execute necessary pin sense measurement and return its Presence Detect,
251 * Impedance, ELD Valid etc. status bits.
252 */
253u32 snd_hda_jack_pin_sense(struct hda_codec *codec, hda_nid_t nid, int dev_id)
254{
255 struct hda_jack_tbl *jack =
256 snd_hda_jack_tbl_get_mst(codec, nid, dev_id);
257 if (jack) {
258 jack_detect_update(codec, jack);
259 return jack->pin_sense;
260 }
261 return read_pin_sense(codec, nid, dev_id);
262}
263EXPORT_SYMBOL_GPL(snd_hda_jack_pin_sense);
264
265/**
266 * snd_hda_jack_detect_state_mst - query pin Presence Detect status
267 * @codec: the CODEC to sense
268 * @nid: the pin NID to sense
269 * @dev_id: pin device entry id
270 *
271 * Query and return the pin's Presence Detect status, as either
272 * HDA_JACK_NOT_PRESENT, HDA_JACK_PRESENT or HDA_JACK_PHANTOM.
273 */
274int snd_hda_jack_detect_state_mst(struct hda_codec *codec,
275 hda_nid_t nid, int dev_id)
276{
277 struct hda_jack_tbl *jack =
278 snd_hda_jack_tbl_get_mst(codec, nid, dev_id);
279 if (jack && jack->phantom_jack)
280 return HDA_JACK_PHANTOM;
281 else if (snd_hda_jack_pin_sense(codec, nid, dev_id) &
282 AC_PINSENSE_PRESENCE)
283 return HDA_JACK_PRESENT;
284 else
285 return HDA_JACK_NOT_PRESENT;
286}
287EXPORT_SYMBOL_GPL(snd_hda_jack_detect_state_mst);
288
289static struct hda_jack_callback *
290find_callback_from_list(struct hda_jack_tbl *jack,
291 hda_jack_callback_fn func)
292{
293 struct hda_jack_callback *cb;
294
295 if (!func)
296 return NULL;
297
298 for (cb = jack->callback; cb; cb = cb->next) {
299 if (cb->func == func)
300 return cb;
301 }
302
303 return NULL;
304}
305
306/**
307 * snd_hda_jack_detect_enable_callback_mst - enable the jack-detection
308 * @codec: the HDA codec
309 * @nid: pin NID to enable
310 * @func: callback function to register
311 * @dev_id: pin device entry id
312 *
313 * In the case of error, the return value will be a pointer embedded with
314 * errno. Check and handle the return value appropriately with standard
315 * macros such as @IS_ERR() and @PTR_ERR().
316 */
317struct hda_jack_callback *
318snd_hda_jack_detect_enable_callback_mst(struct hda_codec *codec, hda_nid_t nid,
319 int dev_id, hda_jack_callback_fn func)
320{
321 struct hda_jack_tbl *jack;
322 struct hda_jack_callback *callback = NULL;
323 int err;
324
325 jack = snd_hda_jack_tbl_new(codec, nid, dev_id);
326 if (!jack)
327 return ERR_PTR(error: -ENOMEM);
328
329 callback = find_callback_from_list(jack, func);
330
331 if (func && !callback) {
332 callback = kzalloc(sizeof(*callback), GFP_KERNEL);
333 if (!callback)
334 return ERR_PTR(error: -ENOMEM);
335 callback->func = func;
336 callback->nid = jack->nid;
337 callback->dev_id = jack->dev_id;
338 callback->next = jack->callback;
339 jack->callback = callback;
340 }
341
342 if (jack->jack_detect)
343 return callback; /* already registered */
344 jack->jack_detect = 1;
345 if (codec->jackpoll_interval > 0)
346 return callback; /* No unsol if we're polling instead */
347 err = snd_hda_codec_write_cache(codec, nid, flags: 0,
348 AC_VERB_SET_UNSOLICITED_ENABLE,
349 AC_USRSP_EN | jack->tag);
350 if (err < 0)
351 return ERR_PTR(error: err);
352 return callback;
353}
354EXPORT_SYMBOL_GPL(snd_hda_jack_detect_enable_callback_mst);
355
356/**
357 * snd_hda_jack_detect_enable - Enable the jack detection on the given pin
358 * @codec: the HDA codec
359 * @nid: pin NID to enable jack detection
360 * @dev_id: pin device entry id
361 *
362 * Enable the jack detection with the default callback. Returns zero if
363 * successful or a negative error code.
364 */
365int snd_hda_jack_detect_enable(struct hda_codec *codec, hda_nid_t nid,
366 int dev_id)
367{
368 return PTR_ERR_OR_ZERO(ptr: snd_hda_jack_detect_enable_callback_mst(codec,
369 nid,
370 dev_id,
371 NULL));
372}
373EXPORT_SYMBOL_GPL(snd_hda_jack_detect_enable);
374
375/**
376 * snd_hda_jack_set_gating_jack - Set gating jack.
377 * @codec: the HDA codec
378 * @gated_nid: gated pin NID
379 * @gating_nid: gating pin NID
380 *
381 * Indicates the gated jack is only valid when the gating jack is plugged.
382 */
383int snd_hda_jack_set_gating_jack(struct hda_codec *codec, hda_nid_t gated_nid,
384 hda_nid_t gating_nid)
385{
386 struct hda_jack_tbl *gated = snd_hda_jack_tbl_new(codec, nid: gated_nid, dev_id: 0);
387 struct hda_jack_tbl *gating =
388 snd_hda_jack_tbl_new(codec, nid: gating_nid, dev_id: 0);
389
390 WARN_ON(codec->dp_mst);
391
392 if (!gated || !gating)
393 return -EINVAL;
394
395 gated->gating_jack = gating_nid;
396 gating->gated_jack = gated_nid;
397
398 return 0;
399}
400EXPORT_SYMBOL_GPL(snd_hda_jack_set_gating_jack);
401
402/**
403 * snd_hda_jack_bind_keymap - bind keys generated from one NID to another jack.
404 * @codec: the HDA codec
405 * @key_nid: key event is generated by this pin NID
406 * @keymap: map of key type and key code
407 * @jack_nid: key reports to the jack of this pin NID
408 *
409 * This function is used in the case of key is generated from one NID while is
410 * reported to the jack of another NID.
411 */
412int snd_hda_jack_bind_keymap(struct hda_codec *codec, hda_nid_t key_nid,
413 const struct hda_jack_keymap *keymap,
414 hda_nid_t jack_nid)
415{
416 const struct hda_jack_keymap *map;
417 struct hda_jack_tbl *key_gen = snd_hda_jack_tbl_get(codec, nid: key_nid);
418 struct hda_jack_tbl *report_to = snd_hda_jack_tbl_get(codec, nid: jack_nid);
419
420 WARN_ON(codec->dp_mst);
421
422 if (!key_gen || !report_to || !report_to->jack)
423 return -EINVAL;
424
425 key_gen->key_report_jack = jack_nid;
426
427 if (keymap)
428 for (map = keymap; map->type; map++)
429 snd_jack_set_key(jack: report_to->jack, type: map->type, keytype: map->key);
430
431 return 0;
432}
433EXPORT_SYMBOL_GPL(snd_hda_jack_bind_keymap);
434
435/**
436 * snd_hda_jack_set_button_state - report button event to the hda_jack_tbl button_state.
437 * @codec: the HDA codec
438 * @jack_nid: the button event reports to the jack_tbl of this NID
439 * @button_state: the button event captured by codec
440 *
441 * Codec driver calls this function to report the button event.
442 */
443void snd_hda_jack_set_button_state(struct hda_codec *codec, hda_nid_t jack_nid,
444 int button_state)
445{
446 struct hda_jack_tbl *jack = snd_hda_jack_tbl_get(codec, nid: jack_nid);
447
448 if (!jack)
449 return;
450
451 if (jack->key_report_jack) {
452 struct hda_jack_tbl *report_to =
453 snd_hda_jack_tbl_get(codec, nid: jack->key_report_jack);
454
455 if (report_to) {
456 report_to->button_state = button_state;
457 return;
458 }
459 }
460
461 jack->button_state = button_state;
462}
463EXPORT_SYMBOL_GPL(snd_hda_jack_set_button_state);
464
465/**
466 * snd_hda_jack_report_sync - sync the states of all jacks and report if changed
467 * @codec: the HDA codec
468 */
469void snd_hda_jack_report_sync(struct hda_codec *codec)
470{
471 struct hda_jack_tbl *jack;
472 int i, state;
473
474 /* update all jacks at first */
475 jack = codec->jacktbl.list;
476 for (i = 0; i < codec->jacktbl.used; i++, jack++)
477 if (jack->nid)
478 jack_detect_update(codec, jack);
479
480 /* report the updated jacks; it's done after updating all jacks
481 * to make sure that all gating jacks properly have been set
482 */
483 jack = codec->jacktbl.list;
484 for (i = 0; i < codec->jacktbl.used; i++, jack++)
485 if (jack->nid) {
486 if (!jack->jack || jack->block_report)
487 continue;
488 state = jack->button_state;
489 if (get_jack_plug_state(jack->pin_sense))
490 state |= jack->type;
491 snd_jack_report(jack: jack->jack, status: state);
492 if (jack->button_state) {
493 snd_jack_report(jack: jack->jack,
494 status: state & ~jack->button_state);
495 jack->button_state = 0; /* button released */
496 }
497 }
498}
499EXPORT_SYMBOL_GPL(snd_hda_jack_report_sync);
500
501/* guess the jack type from the pin-config */
502static int get_input_jack_type(struct hda_codec *codec, hda_nid_t nid)
503{
504 unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
505 switch (get_defcfg_device(def_conf)) {
506 case AC_JACK_LINE_OUT:
507 case AC_JACK_SPEAKER:
508 return SND_JACK_LINEOUT;
509 case AC_JACK_HP_OUT:
510 return SND_JACK_HEADPHONE;
511 case AC_JACK_SPDIF_OUT:
512 case AC_JACK_DIG_OTHER_OUT:
513 return SND_JACK_AVOUT;
514 case AC_JACK_MIC_IN:
515 return SND_JACK_MICROPHONE;
516 default:
517 return SND_JACK_LINEIN;
518 }
519}
520
521static void hda_free_jack_priv(struct snd_jack *jack)
522{
523 struct hda_jack_tbl *jacks = jack->private_data;
524 jacks->nid = 0;
525 jacks->jack = NULL;
526}
527
528/**
529 * snd_hda_jack_add_kctl_mst - Add a kctl for the given pin
530 * @codec: the HDA codec
531 * @nid: pin NID to assign
532 * @dev_id : pin device entry id
533 * @name: string name for the jack
534 * @phantom_jack: flag to deal as a phantom jack
535 * @type: jack type bits to be reported, 0 for guessing from pincfg
536 * @keymap: optional jack / key mapping
537 *
538 * This assigns a jack-detection kctl to the given pin. The kcontrol
539 * will have the given name and index.
540 */
541int snd_hda_jack_add_kctl_mst(struct hda_codec *codec, hda_nid_t nid,
542 int dev_id, const char *name, bool phantom_jack,
543 int type, const struct hda_jack_keymap *keymap)
544{
545 struct hda_jack_tbl *jack;
546 const struct hda_jack_keymap *map;
547 int err, state, buttons;
548
549 jack = snd_hda_jack_tbl_new(codec, nid, dev_id);
550 if (!jack)
551 return 0;
552 if (jack->jack)
553 return 0; /* already created */
554
555 if (!type)
556 type = get_input_jack_type(codec, nid);
557
558 buttons = 0;
559 if (keymap) {
560 for (map = keymap; map->type; map++)
561 buttons |= map->type;
562 }
563
564 err = snd_jack_new(card: codec->card, id: name, type: type | buttons,
565 jack: &jack->jack, initial_kctl: true, phantom_jack);
566 if (err < 0)
567 return err;
568
569 jack->phantom_jack = !!phantom_jack;
570 jack->type = type;
571 jack->button_state = 0;
572 jack->jack->private_data = jack;
573 jack->jack->private_free = hda_free_jack_priv;
574 if (keymap) {
575 for (map = keymap; map->type; map++)
576 snd_jack_set_key(jack: jack->jack, type: map->type, keytype: map->key);
577 }
578
579 state = snd_hda_jack_detect_mst(codec, nid, dev_id);
580 snd_jack_report(jack: jack->jack, status: state ? jack->type : 0);
581
582 return 0;
583}
584EXPORT_SYMBOL_GPL(snd_hda_jack_add_kctl_mst);
585
586static int add_jack_kctl(struct hda_codec *codec, hda_nid_t nid,
587 const struct auto_pin_cfg *cfg,
588 const char *base_name)
589{
590 unsigned int def_conf, conn;
591 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
592 int err;
593 bool phantom_jack;
594
595 WARN_ON(codec->dp_mst);
596
597 if (!nid)
598 return 0;
599 def_conf = snd_hda_codec_get_pincfg(codec, nid);
600 conn = get_defcfg_connect(def_conf);
601 if (conn == AC_JACK_PORT_NONE)
602 return 0;
603 phantom_jack = (conn != AC_JACK_PORT_COMPLEX) ||
604 !is_jack_detectable(codec, nid);
605
606 if (base_name)
607 strscpy(name, base_name, sizeof(name));
608 else
609 snd_hda_get_pin_label(codec, nid, cfg, label: name, maxlen: sizeof(name), NULL);
610 if (phantom_jack)
611 /* Example final name: "Internal Mic Phantom Jack" */
612 strncat(name, " Phantom", sizeof(name) - strlen(name) - 1);
613 err = snd_hda_jack_add_kctl(codec, nid, name, phantom_jack, type: 0, NULL);
614 if (err < 0)
615 return err;
616
617 if (!phantom_jack)
618 return snd_hda_jack_detect_enable(codec, nid, 0);
619 return 0;
620}
621
622/**
623 * snd_hda_jack_add_kctls - Add kctls for all pins included in the given pincfg
624 * @codec: the HDA codec
625 * @cfg: pin config table to parse
626 */
627int snd_hda_jack_add_kctls(struct hda_codec *codec,
628 const struct auto_pin_cfg *cfg)
629{
630 const hda_nid_t *p;
631 int i, err;
632
633 for (i = 0; i < cfg->num_inputs; i++) {
634 /* If we have headphone mics; make sure they get the right name
635 before grabbed by output pins */
636 if (cfg->inputs[i].is_headphone_mic) {
637 if (auto_cfg_hp_outs(cfg) == 1)
638 err = add_jack_kctl(codec, nid: auto_cfg_hp_pins(cfg)[0],
639 cfg, base_name: "Headphone Mic");
640 else
641 err = add_jack_kctl(codec, nid: cfg->inputs[i].pin,
642 cfg, base_name: "Headphone Mic");
643 } else
644 err = add_jack_kctl(codec, nid: cfg->inputs[i].pin, cfg,
645 NULL);
646 if (err < 0)
647 return err;
648 }
649
650 for (i = 0, p = cfg->line_out_pins; i < cfg->line_outs; i++, p++) {
651 err = add_jack_kctl(codec, nid: *p, cfg, NULL);
652 if (err < 0)
653 return err;
654 }
655 for (i = 0, p = cfg->hp_pins; i < cfg->hp_outs; i++, p++) {
656 if (*p == *cfg->line_out_pins) /* might be duplicated */
657 break;
658 err = add_jack_kctl(codec, nid: *p, cfg, NULL);
659 if (err < 0)
660 return err;
661 }
662 for (i = 0, p = cfg->speaker_pins; i < cfg->speaker_outs; i++, p++) {
663 if (*p == *cfg->line_out_pins) /* might be duplicated */
664 break;
665 err = add_jack_kctl(codec, nid: *p, cfg, NULL);
666 if (err < 0)
667 return err;
668 }
669 for (i = 0, p = cfg->dig_out_pins; i < cfg->dig_outs; i++, p++) {
670 err = add_jack_kctl(codec, nid: *p, cfg, NULL);
671 if (err < 0)
672 return err;
673 }
674 err = add_jack_kctl(codec, nid: cfg->dig_in_pin, cfg, NULL);
675 if (err < 0)
676 return err;
677 err = add_jack_kctl(codec, nid: cfg->mono_out_pin, cfg, NULL);
678 if (err < 0)
679 return err;
680 return 0;
681}
682EXPORT_SYMBOL_GPL(snd_hda_jack_add_kctls);
683
684static void call_jack_callback(struct hda_codec *codec, unsigned int res,
685 struct hda_jack_tbl *jack)
686{
687 struct hda_jack_callback *cb;
688
689 for (cb = jack->callback; cb; cb = cb->next) {
690 cb->jack = jack;
691 cb->unsol_res = res;
692 cb->func(codec, cb);
693 }
694 if (jack->gated_jack) {
695 struct hda_jack_tbl *gated =
696 snd_hda_jack_tbl_get_mst(codec, jack->gated_jack,
697 jack->dev_id);
698 if (gated) {
699 for (cb = gated->callback; cb; cb = cb->next) {
700 cb->jack = gated;
701 cb->unsol_res = res;
702 cb->func(codec, cb);
703 }
704 }
705 }
706}
707
708/**
709 * snd_hda_jack_unsol_event - Handle an unsolicited event
710 * @codec: the HDA codec
711 * @res: the unsolicited event data
712 */
713void snd_hda_jack_unsol_event(struct hda_codec *codec, unsigned int res)
714{
715 struct hda_jack_tbl *event;
716 int tag = (res & AC_UNSOL_RES_TAG) >> AC_UNSOL_RES_TAG_SHIFT;
717
718 if (codec->dp_mst) {
719 int dev_entry =
720 (res & AC_UNSOL_RES_DE) >> AC_UNSOL_RES_DE_SHIFT;
721
722 event = snd_hda_jack_tbl_get_from_tag(codec, tag, dev_entry);
723 } else {
724 event = snd_hda_jack_tbl_get_from_tag(codec, tag, 0);
725 }
726 if (!event)
727 return;
728
729 if (event->key_report_jack) {
730 struct hda_jack_tbl *report_to =
731 snd_hda_jack_tbl_get_mst(codec, event->key_report_jack,
732 event->dev_id);
733 if (report_to)
734 report_to->jack_dirty = 1;
735 } else
736 event->jack_dirty = 1;
737
738 call_jack_callback(codec, res, jack: event);
739 snd_hda_jack_report_sync(codec);
740}
741EXPORT_SYMBOL_GPL(snd_hda_jack_unsol_event);
742
743/**
744 * snd_hda_jack_poll_all - Poll all jacks
745 * @codec: the HDA codec
746 *
747 * Poll all detectable jacks with dirty flag, update the status, call
748 * callbacks and call snd_hda_jack_report_sync() if any changes are found.
749 */
750void snd_hda_jack_poll_all(struct hda_codec *codec)
751{
752 struct hda_jack_tbl *jack = codec->jacktbl.list;
753 int i, changes = 0;
754
755 for (i = 0; i < codec->jacktbl.used; i++, jack++) {
756 unsigned int old_sense;
757 if (!jack->nid || !jack->jack_dirty || jack->phantom_jack)
758 continue;
759 old_sense = get_jack_plug_state(jack->pin_sense);
760 jack_detect_update(codec, jack);
761 if (old_sense == get_jack_plug_state(jack->pin_sense))
762 continue;
763 changes = 1;
764 call_jack_callback(codec, res: 0, jack);
765 }
766 if (changes)
767 snd_hda_jack_report_sync(codec);
768}
769EXPORT_SYMBOL_GPL(snd_hda_jack_poll_all);
770
771