ASoC: SDCA: Add ability to connect SDCA jacks to ASoC jacks

Add handling for the ASoC jack API to SDCA to allow user-space to be
hooked up normally.

Signed-off-by: Charles Keepax <ckeepax@opensource.cirrus.com>
Link: https://patch.msgid.link/20251215153650.3913117-3-ckeepax@opensource.cirrus.com
Reviewed-by: Bard Liao <yung-chuan.liao@linux.intel.com>
Signed-off-by: Mark Brown <broonie@kernel.org>

diff --git a/include/sound/sdca_jack.h b/include/sound/sdca_jack.h
index 9fad5f22cbb9e7a9b80c6ec1abf5a46e1dfdcec9..3ec22046d3ebc2e1f04fe7e25e2dd322482c4c0d 100644 (file)
--- a/include/sound/sdca_jack.h
+++ b/include/sound/sdca_jack.h
@@ -12,16 +12,21 @@
 
 struct sdca_interrupt;
 struct snd_kcontrol;
+struct snd_soc_jack;
 
 /**
  * struct jack_state - Jack state structure to keep data between interrupts
  * @kctl: Pointer to the ALSA control attached to this jack
+ * @jack: Pointer to the ASoC jack struct for this jack
  */
 struct jack_state {
        struct snd_kcontrol *kctl;
+       struct snd_soc_jack *jack;
 };
 
 int sdca_jack_alloc_state(struct sdca_interrupt *interrupt);
 int sdca_jack_process(struct sdca_interrupt *interrupt);
+int sdca_jack_set_jack(struct sdca_interrupt_info *info, struct snd_soc_jack *jack);
+int sdca_jack_report(struct sdca_interrupt *interrupt);
 
 #endif // __SDCA_JACK_H__

diff --git a/sound/soc/sdca/sdca_jack.c b/sound/soc/sdca/sdca_jack.c
index 83b2b9cc81f00fbfa919deaf9d482634988a2077..5b9cf69cbcd6b62e59bfa664a165c82d7426a8c7 100644 (file)
--- a/sound/soc/sdca/sdca_jack.c
+++ b/sound/soc/sdca/sdca_jack.c
@@ -17,11 +17,13 @@
 #include <linux/rwsem.h>
 #include <sound/asound.h>
 #include <sound/control.h>
+#include <sound/jack.h>
 #include <sound/sdca.h>
 #include <sound/sdca_function.h>
 #include <sound/sdca_interrupts.h>
 #include <sound/sdca_jack.h>
 #include <sound/soc-component.h>
+#include <sound/soc-jack.h>
 #include <sound/soc.h>
 
 /**
@@ -114,7 +116,7 @@ int sdca_jack_process(struct sdca_interrupt *interrupt)
 
        snd_ctl_notify(card->snd_card, SNDRV_CTL_EVENT_MASK_VALUE, &kctl->id);
 
-       return 0;
+       return sdca_jack_report(interrupt);
 }
 EXPORT_SYMBOL_NS_GPL(sdca_jack_process, "SND_SOC_SDCA");
 
@@ -138,3 +140,105 @@ int sdca_jack_alloc_state(struct sdca_interrupt *interrupt)
        return 0;
 }
 EXPORT_SYMBOL_NS_GPL(sdca_jack_alloc_state, "SND_SOC_SDCA");
+
+/**
+ * sdca_jack_set_jack - attach an ASoC jack to SDCA
+ * @info: SDCA interrupt information.
+ * @jack: ASoC jack to be attached.
+ *
+ * Return: Zero on success or a negative error code.
+ */
+int sdca_jack_set_jack(struct sdca_interrupt_info *info, struct snd_soc_jack *jack)
+{
+       int i, ret;
+
+       guard(mutex)(&info->irq_lock);
+
+       for (i = 0; i < SDCA_MAX_INTERRUPTS; i++) {
+               struct sdca_interrupt *interrupt = &info->irqs[i];
+               struct sdca_control *control = interrupt->control;
+               struct sdca_entity *entity = interrupt->entity;
+               struct jack_state *jack_state;
+
+               if (!interrupt->irq)
+                       continue;
+
+               switch (SDCA_CTL_TYPE(entity->type, control->sel)) {
+               case SDCA_CTL_TYPE_S(GE, DETECTED_MODE):
+                       jack_state = interrupt->priv;
+                       jack_state->jack = jack;
+
+                       /* Report initial state in case IRQ was already handled */
+                       ret = sdca_jack_report(interrupt);
+                       if (ret)
+                               return ret;
+                       break;
+               default:
+                       break;
+               }
+       }
+
+       return 0;
+}
+EXPORT_SYMBOL_NS_GPL(sdca_jack_set_jack, "SND_SOC_SDCA");
+
+int sdca_jack_report(struct sdca_interrupt *interrupt)
+{
+       struct jack_state *jack_state = interrupt->priv;
+       struct sdca_control_range *range;
+       enum sdca_terminal_type type;
+       unsigned int report = 0;
+       unsigned int reg, val;
+       int ret;
+
+       reg = SDW_SDCA_CTL(interrupt->function->desc->adr, interrupt->entity->id,
+                          SDCA_CTL_GE_SELECTED_MODE, 0);
+
+       ret = regmap_read(interrupt->function_regmap, reg, &val);
+       if (ret) {
+               dev_err(interrupt->dev, "failed to read selected mode: %d\n", ret);
+               return ret;
+       }
+
+       range = sdca_selector_find_range(interrupt->dev, interrupt->entity,
+                                        SDCA_CTL_GE_SELECTED_MODE,
+                                        SDCA_SELECTED_MODE_NCOLS, 0);
+       if (!range)
+               return -EINVAL;
+
+       type = sdca_range_search(range, SDCA_SELECTED_MODE_INDEX,
+                                val, SDCA_SELECTED_MODE_TERM_TYPE);
+
+       switch (type) {
+       case SDCA_TERM_TYPE_LINEIN_STEREO:
+       case SDCA_TERM_TYPE_LINEIN_FRONT_LR:
+       case SDCA_TERM_TYPE_LINEIN_CENTER_LFE:
+       case SDCA_TERM_TYPE_LINEIN_SURROUND_LR:
+       case SDCA_TERM_TYPE_LINEIN_REAR_LR:
+               report = SND_JACK_LINEIN;
+               break;
+       case SDCA_TERM_TYPE_LINEOUT_STEREO:
+       case SDCA_TERM_TYPE_LINEOUT_FRONT_LR:
+       case SDCA_TERM_TYPE_LINEOUT_CENTER_LFE:
+       case SDCA_TERM_TYPE_LINEOUT_SURROUND_LR:
+       case SDCA_TERM_TYPE_LINEOUT_REAR_LR:
+               report = SND_JACK_LINEOUT;
+               break;
+       case SDCA_TERM_TYPE_MIC_JACK:
+               report = SND_JACK_MICROPHONE;
+               break;
+       case SDCA_TERM_TYPE_HEADPHONE_JACK:
+               report = SND_JACK_HEADPHONE;
+               break;
+       case SDCA_TERM_TYPE_HEADSET_JACK:
+               report = SND_JACK_HEADSET;
+               break;
+       default:
+               break;
+       }
+
+       snd_soc_jack_report(jack_state->jack, report, 0xFFFF);
+
+       return 0;
+}
+EXPORT_SYMBOL_NS_GPL(sdca_jack_report, "SND_SOC_SDCA");