ASoC: SDCA: Add HID button IRQ

Now full support for the UMP buffers is available, it is possible to
read the SDCA HID descriptors from the device and pass them to
user-space. Add a helper function to process HID events from an SDCA
device.

Reviewed-by: Bard Liao <yung-chuan.liao@linux.intel.com>
Signed-off-by: Charles Keepax <ckeepax@opensource.cirrus.com>
Reviewed-by: Pierre-Louis Bossart <pierre-louis.bossart@linux.dev>
Link: https://patch.msgid.link/20251020155512.353774-20-ckeepax@opensource.cirrus.com
Signed-off-by: Mark Brown <broonie@kernel.org>

diff --git a/include/sound/sdca_hid.h b/include/sound/sdca_hid.h
index 3a155835e035ee26d65579062f2fc5b7f79261a2..18bebbe428c9f70a97af5eac4f12c9df9a212bae 100644 (file)
--- a/include/sound/sdca_hid.h
+++ b/include/sound/sdca_hid.h
@@ -8,13 +8,17 @@
 #ifndef __SDCA_HID_H__
 #define __SDCA_HID_H__
 
-#include <linux/types.h>
-#include <linux/hid.h>
+struct device;
+struct sdw_slave;
+
+struct sdca_entity;
+struct sdca_interrupt;
 
 #if IS_ENABLED(CONFIG_SND_SOC_SDCA_HID)
 
 int sdca_add_hid_device(struct device *dev, struct sdw_slave *sdw,
                        struct sdca_entity *entity);
+int sdca_hid_process_report(struct sdca_interrupt *interrupt);
 
 #else
 
@@ -24,6 +28,11 @@ static inline int sdca_add_hid_device(struct device *dev, struct sdw_slave *sdw,
        return 0;
 }
 
+static inline int sdca_hid_process_report(struct sdca_interrupt *interrupt)
+{
+       return 0;
+}
+
 #endif
 
 #endif /* __SDCA_HID_H__ */

diff --git a/sound/soc/sdca/sdca_hid.c b/sound/soc/sdca/sdca_hid.c
index 53dad1a524d4b4f6d97a819ddcce6940a192b33c..ad53207b0d62b706e6829c192202560ce422e1a0 100644 (file)
--- a/sound/soc/sdca/sdca_hid.c
+++ b/sound/soc/sdca/sdca_hid.c
@@ -10,6 +10,7 @@
 #include <linux/cleanup.h>
 #include <linux/device.h>
 #include <linux/dev_printk.h>
+#include <linux/hid.h>
 #include <linux/module.h>
 #include <linux/property.h>
 #include <linux/soundwire/sdw.h>
@@ -17,6 +18,8 @@
 #include <sound/sdca.h>
 #include <sound/sdca_function.h>
 #include <sound/sdca_hid.h>
+#include <sound/sdca_interrupts.h>
+#include <sound/sdca_ump.h>
 
 static int sdwhid_parse(struct hid_device *hid)
 {
@@ -121,5 +124,48 @@ int sdca_add_hid_device(struct device *dev, struct sdw_slave *sdw,
 }
 EXPORT_SYMBOL_NS(sdca_add_hid_device, "SND_SOC_SDCA");
 
+/**
+ * sdca_hid_process_report - read a HID event from the device and report
+ * @interrupt: Pointer to the SDCA interrupt information structure.
+ *
+ * Return: Zero on success, and a negative error code on failure.
+ */
+int sdca_hid_process_report(struct sdca_interrupt *interrupt)
+{
+       struct device *dev = interrupt->dev;
+       struct hid_device *hid = interrupt->entity->hide.hid;
+       void *val __free(kfree) = NULL;
+       int len, ret;
+
+       ret = sdca_ump_get_owner_host(dev, interrupt->function_regmap,
+                                     interrupt->function, interrupt->entity,
+                                     interrupt->control);
+       if (ret)
+               return ret;
+
+       len = sdca_ump_read_message(dev, interrupt->device_regmap,
+                                   interrupt->function_regmap,
+                                   interrupt->function, interrupt->entity,
+                                   SDCA_CTL_HIDE_HIDTX_MESSAGEOFFSET,
+                                   SDCA_CTL_HIDE_HIDTX_MESSAGELENGTH, &val);
+       if (len < 0)
+               return len;
+
+       ret = sdca_ump_set_owner_device(dev, interrupt->function_regmap,
+                                       interrupt->function, interrupt->entity,
+                                       interrupt->control);
+       if (ret)
+               return ret;
+
+       ret = hid_input_report(hid, HID_INPUT_REPORT, val, len, true);
+       if (ret < 0) {
+               dev_err(dev, "failed to report hid event: %d\n", ret);
+               return ret;
+       }
+
+       return 0;
+}
+EXPORT_SYMBOL_NS(sdca_hid_process_report, "SND_SOC_SDCA");
+
 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_DESCRIPTION("SDCA HID library");

diff --git a/sound/soc/sdca/sdca_interrupts.c b/sound/soc/sdca/sdca_interrupts.c
index 51342b8aacae91e0158e92bd47827555d671bf25..5176460416bbe8a636e16b40fb7c1bf69a3e3aa4 100644 (file)
--- a/sound/soc/sdca/sdca_interrupts.c
+++ b/sound/soc/sdca/sdca_interrupts.c
@@ -20,6 +20,7 @@
 #include <sound/sdca.h>
 #include <sound/sdca_fdl.h>
 #include <sound/sdca_function.h>
+#include <sound/sdca_hid.h>
 #include <sound/sdca_interrupts.h>
 #include <sound/sdca_ump.h>
 #include <sound/soc-component.h>
@@ -247,6 +248,29 @@ error:
        return irqret;
 }
 
+static irqreturn_t hid_handler(int irq, void *data)
+{
+       struct sdca_interrupt *interrupt = data;
+       struct device *dev = interrupt->dev;
+       irqreturn_t irqret = IRQ_NONE;
+       int ret;
+
+       ret = pm_runtime_get_sync(dev);
+       if (ret < 0) {
+               dev_err(dev, "failed to resume for hid: %d\n", ret);
+               goto error;
+       }
+
+       ret = sdca_hid_process_report(interrupt);
+       if (ret)
+               goto error;
+
+       irqret = IRQ_HANDLED;
+error:
+       pm_runtime_put(dev);
+       return irqret;
+}
+
 static irqreturn_t fdl_owner_handler(int irq, void *data)
 {
        struct sdca_interrupt *interrupt = data;
@@ -528,6 +552,10 @@ int sdca_irq_populate(struct sdca_function_data *function,
                                        handler = fdl_owner_handler;
                                }
                                break;
+                       case SDCA_ENTITY_TYPE_HIDE:
+                               if (control->sel == SDCA_CTL_HIDE_HIDTX_CURRENTOWNER)
+                                       handler = hid_handler;
+                               break;
                        default:
                                break;
                        }