Input: keyboard - imx_sc: Add i.MX system controller key support

i.MX8QXP is an ARMv8 SoC which has a Cortex-M4 system controller
inside, the system controller is in charge of controlling power,
clock and scu key etc..

Adds i.MX system controller key driver support, Linux kernel has
to communicate with system controller via MU (message unit) IPC
to get scu key's status.

Signed-off-by: Anson Huang <Anson.Huang@nxp.com>
Reviewed-by: Rob Herring <robh@kernel.org>
Link: https://lore.kernel.org/r/1570412509-7893-2-git-send-email-Anson.Huang@nxp.com
Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>

diff --git a/Documentation/devicetree/bindings/arm/freescale/fsl,scu.txt b/Documentation/devicetree/bindings/arm/freescale/fsl,scu.txt
index a575e42f7fecc1a60e3dda93ccb2544e13590406..e57eaff077383aaf72fd0d071b1c6c5d8d67930e 100644 (file)
--- a/Documentation/devicetree/bindings/arm/freescale/fsl,scu.txt
+++ b/Documentation/devicetree/bindings/arm/freescale/fsl,scu.txt
@@ -155,6 +155,15 @@ Required properties:
 Optional properties:
 - timeout-sec: contains the watchdog timeout in seconds.
 
+SCU key bindings based on SCU Message Protocol
+------------------------------------------------------------
+
+Required properties:
+- compatible: should be:
+              "fsl,imx8qxp-sc-key"
+              followed by "fsl,imx-sc-key";
+- linux,keycodes: See Documentation/devicetree/bindings/input/keys.txt
+
 Example (imx8qxp):
 -------------
 aliases {
@@ -218,6 +227,11 @@ firmware {
                        compatible = "fsl,imx8qxp-sc-rtc";
                };
 
+               scu_key: scu-key {
+                       compatible = "fsl,imx8qxp-sc-key", "fsl,imx-sc-key";
+                       linux,keycodes = <KEY_POWER>;
+               };
+
                watchdog {
                        compatible = "fsl,imx8qxp-sc-wdt", "fsl,imx-sc-wdt";
                        timeout-sec = <60>;

diff --git a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig
index 2e6d2887eec1f823f0ffab58afe3a902f63b2ad2..a716a90de683c83d0e1f41283492e36255b60f6e 100644 (file)
--- a/drivers/input/keyboard/Kconfig
+++ b/drivers/input/keyboard/Kconfig
@@ -469,6 +469,16 @@ config KEYBOARD_IMX
          To compile this driver as a module, choose M here: the
          module will be called imx_keypad.
 
+config KEYBOARD_IMX_SC_KEY
+       tristate "IMX SCU Key Driver"
+       depends on IMX_SCU
+       help
+         This is the system controller key driver for NXP i.MX SoCs with
+         system controller inside.
+
+         To compile this driver as a module, choose M here: the
+         module will be called imx_sc_key.
+
 config KEYBOARD_NEWTON
        tristate "Newton keyboard"
        select SERIO

diff --git a/drivers/input/keyboard/Makefile b/drivers/input/keyboard/Makefile
index 9510325c0c5d666546b41126675282f34edeafa0..f5b17524adf2d882a31320e728e751f15d408f91 100644 (file)
--- a/drivers/input/keyboard/Makefile
+++ b/drivers/input/keyboard/Makefile
@@ -29,6 +29,7 @@ obj-$(CONFIG_KEYBOARD_HIL)            += hil_kbd.o
 obj-$(CONFIG_KEYBOARD_HIL_OLD)         += hilkbd.o
 obj-$(CONFIG_KEYBOARD_IPAQ_MICRO)      += ipaq-micro-keys.o
 obj-$(CONFIG_KEYBOARD_IMX)             += imx_keypad.o
+obj-$(CONFIG_KEYBOARD_IMX_SC_KEY)      += imx_sc_key.o
 obj-$(CONFIG_KEYBOARD_HP6XX)           += jornada680_kbd.o
 obj-$(CONFIG_KEYBOARD_HP7XX)           += jornada720_kbd.o
 obj-$(CONFIG_KEYBOARD_LKKBD)           += lkkbd.o

diff --git a/drivers/input/keyboard/imx_sc_key.c b/drivers/input/keyboard/imx_sc_key.c
new file mode 100644 (file)
index 0000000..dd57daa
--- /dev/null
+++ b/drivers/input/keyboard/imx_sc_key.c
@@ -0,0 +1,187 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright 2019 NXP.
+ */
+
+#include <linux/err.h>
+#include <linux/device.h>
+#include <linux/firmware/imx/sci.h>
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/jiffies.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/property.h>
+
+#define DEBOUNCE_TIME                          30
+#define REPEAT_INTERVAL                                60
+
+#define SC_IRQ_BUTTON                          1
+#define SC_IRQ_GROUP_WAKE                      3
+
+#define IMX_SC_MISC_FUNC_GET_BUTTON_STATUS     18
+
+struct imx_key_drv_data {
+       u32 keycode;
+       bool keystate;  /* true: pressed, false: released */
+       struct delayed_work check_work;
+       struct input_dev *input;
+       struct imx_sc_ipc *key_ipc_handle;
+       struct notifier_block key_notifier;
+};
+
+struct imx_sc_msg_key {
+       struct imx_sc_rpc_msg hdr;
+       u8 state;
+};
+
+static int imx_sc_key_notify(struct notifier_block *nb,
+                            unsigned long event, void *group)
+{
+       struct imx_key_drv_data *priv =
+                                container_of(nb,
+                                             struct imx_key_drv_data,
+                                             key_notifier);
+
+       if ((event & SC_IRQ_BUTTON) && (*(u8 *)group == SC_IRQ_GROUP_WAKE)) {
+               schedule_delayed_work(&priv->check_work,
+                                     msecs_to_jiffies(DEBOUNCE_TIME));
+               pm_wakeup_event(priv->input->dev.parent, 0);
+       }
+
+       return 0;
+}
+
+static void imx_sc_check_for_events(struct work_struct *work)
+{
+       struct imx_key_drv_data *priv =
+                                container_of(work,
+                                             struct imx_key_drv_data,
+                                             check_work.work);
+       struct input_dev *input = priv->input;
+       struct imx_sc_msg_key msg;
+       struct imx_sc_rpc_msg *hdr = &msg.hdr;
+       bool state;
+       int error;
+
+       hdr->ver = IMX_SC_RPC_VERSION;
+       hdr->svc = IMX_SC_RPC_SVC_MISC;
+       hdr->func = IMX_SC_MISC_FUNC_GET_BUTTON_STATUS;
+       hdr->size = 1;
+
+       error = imx_scu_call_rpc(priv->key_ipc_handle, &msg, true);
+       if (error) {
+               dev_err(&input->dev, "read imx sc key failed, error %d\n", error);
+               return;
+       }
+
+       state = (bool)msg.state;
+
+       if (state ^ priv->keystate) {
+               priv->keystate = state;
+               input_event(input, EV_KEY, priv->keycode, state);
+               input_sync(input);
+               if (!priv->keystate)
+                       pm_relax(priv->input->dev.parent);
+       }
+
+       if (state)
+               schedule_delayed_work(&priv->check_work,
+                                     msecs_to_jiffies(REPEAT_INTERVAL));
+}
+
+static int imx_sc_key_probe(struct platform_device *pdev)
+{
+       struct imx_key_drv_data *priv;
+       struct input_dev *input;
+       int error;
+
+       priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
+       if (!priv)
+               return -ENOMEM;
+
+       error = imx_scu_get_handle(&priv->key_ipc_handle);
+       if (error)
+               return error;
+
+       if (device_property_read_u32(&pdev->dev, "linux,keycodes",
+                                    &priv->keycode)) {
+               dev_err(&pdev->dev, "missing linux,keycodes property\n");
+               return -EINVAL;
+       }
+
+       INIT_DELAYED_WORK(&priv->check_work, imx_sc_check_for_events);
+
+       input = devm_input_allocate_device(&pdev->dev);
+       if (!input) {
+               dev_err(&pdev->dev, "failed to allocate the input device\n");
+               return -ENOMEM;
+       }
+
+       input->name = pdev->name;
+       input->phys = "imx-sc-key/input0";
+       input->id.bustype = BUS_HOST;
+
+       input_set_capability(input, EV_KEY, priv->keycode);
+
+       error = input_register_device(input);
+       if (error) {
+               dev_err(&pdev->dev, "failed to register input device\n");
+               return error;
+       }
+
+       priv->input = input;
+       platform_set_drvdata(pdev, priv);
+
+       error = imx_scu_irq_group_enable(SC_IRQ_GROUP_WAKE, SC_IRQ_BUTTON,
+                                        true);
+       if (error) {
+               dev_err(&pdev->dev, "failed to enable scu group irq\n");
+               return error;
+       }
+
+       priv->key_notifier.notifier_call = imx_sc_key_notify;
+       error = imx_scu_irq_register_notifier(&priv->key_notifier);
+       if (error) {
+               imx_scu_irq_group_enable(SC_IRQ_GROUP_WAKE, SC_IRQ_BUTTON,
+                                        false);
+               dev_err(&pdev->dev, "failed to register scu notifier\n");
+               return error;
+       }
+
+       return 0;
+}
+
+static int imx_sc_key_remove(struct platform_device *pdev)
+{
+       struct imx_key_drv_data *priv = platform_get_drvdata(pdev);
+
+       imx_scu_irq_group_enable(SC_IRQ_GROUP_WAKE, SC_IRQ_BUTTON, false);
+       imx_scu_irq_unregister_notifier(&priv->key_notifier);
+       cancel_delayed_work_sync(&priv->check_work);
+
+       return 0;
+}
+
+static const struct of_device_id imx_sc_key_ids[] = {
+       { .compatible = "fsl,imx-sc-key" },
+       { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, imx_sc_key_ids);
+
+static struct platform_driver imx_sc_key_driver = {
+       .driver = {
+               .name = "imx-sc-key",
+               .of_match_table = imx_sc_key_ids,
+       },
+       .probe = imx_sc_key_probe,
+       .remove = imx_sc_key_remove,
+};
+module_platform_driver(imx_sc_key_driver);
+
+MODULE_AUTHOR("Anson Huang <Anson.Huang@nxp.com>");
+MODULE_DESCRIPTION("i.MX System Controller Key Driver");
+MODULE_LICENSE("GPL v2");