misc: hisi_hikey_usb: Driver to support onboard USB gpio hub on Hikey960

The HiKey960 has a fairly complex USB configuration due to it
needing to support a USB-C port for host/device mode and multiple
USB-A ports in host mode, all using a single USB controller.

See schematics here:
  https://github.com/96boards/documentation/raw/master/consumer/hikey/hikey960/hardware-docs/HiKey960_Schematics.pdf

This driver acts as a usb-role-switch intermediary, intercepting
the role switch notifications from the tcpm code, and passing
them on to the dwc3 core.

In doing so, it also controls the onboard hub and power gpios in
order to properly route the data lines between the USB-C port
and the onboard hub to the USB-A ports.

Signed-off-by: Yu Chen <chenyu56@huawei.com>
[jstultz: Major rework to make the driver a usb-role-switch
          intermediary]
Signed-off-by: John Stultz <john.stultz@linaro.org>
Signed-off-by: Mauro Carvalho Chehab <mchehab+huawei@kernel.org>
Link: https://lore.kernel.org/r/c263f72e1d803c18c45a69ce2c333e79a7ed89ff.1599717402.git.mchehab+huawei@kernel.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/MAINTAINERS b/MAINTAINERS
index e4647c84c987e5498c60db9bc1f44602b3befb89..8cc25820dd8e1e26bed28d380a10d1990af4af9c 100644 (file)
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -7861,6 +7861,13 @@ W:       http://www.hisilicon.com
 F:     Documentation/devicetree/bindings/net/hisilicon*.txt
 F:     drivers/net/ethernet/hisilicon/
 
+HIKEY960 ONBOARD USB GPIO HUB DRIVER
+M:     John Stultz <john.stultz@linaro.org>
+L:     linux-kernel@vger.kernel.org
+S:     Maintained
+F:     drivers/misc/hisi_hikey_usb.c
+F:     Documentation/devicetree/bindings/misc/hisilicon-hikey-usb.yaml
+
 HISILICON PMU DRIVER
 M:     Shaokun Zhang <zhangshaokun@hisilicon.com>
 S:     Supported

diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index ce136d685d1457de8cc58f1872a636cea542b790..cb5944a5fce58d45ca48d56b8ec507bbc4ee24d5 100644 (file)
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -456,6 +456,15 @@ config PVPANIC
          a paravirtualized device provided by QEMU; it lets a virtual machine
          (guest) communicate panic events to the host.
 
+config HISI_HIKEY_USB
+       tristate "USB GPIO Hub on HiSilicon Hikey960 Platform"
+       depends on (OF && GPIOLIB) || COMPILE_TEST
+       help
+         If you say yes here this adds support for the on-board USB GPIO hub
+         found on the HiKey960, which is necessary to support switching
+         between the dual-role USB-C port and the USB-A host ports using only
+         one USB controller.
+
 source "drivers/misc/c2port/Kconfig"
 source "drivers/misc/eeprom/Kconfig"
 source "drivers/misc/cb710/Kconfig"

diff --git a/drivers/misc/Makefile b/drivers/misc/Makefile
index c7bd01ac62917f57566d5e7e81e7e71d6ac23c0a..2521359e8ef7b5f82498dba5c4329495b12ca98c 100644 (file)
--- a/drivers/misc/Makefile
+++ b/drivers/misc/Makefile
@@ -57,3 +57,4 @@ obj-$(CONFIG_PVPANIC)         += pvpanic.o
 obj-$(CONFIG_HABANA_AI)                += habanalabs/
 obj-$(CONFIG_UACCE)            += uacce/
 obj-$(CONFIG_XILINX_SDFEC)     += xilinx_sdfec.o
+obj-$(CONFIG_HISI_HIKEY_USB)   += hisi_hikey_usb.o

diff --git a/drivers/misc/hisi_hikey_usb.c b/drivers/misc/hisi_hikey_usb.c
new file mode 100644 (file)
index 0000000..3a98a89
--- /dev/null
+++ b/drivers/misc/hisi_hikey_usb.c
@@ -0,0 +1,205 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Support for usb functionality of Hikey series boards
+ * based on Hisilicon Kirin Soc.
+ *
+ * Copyright (C) 2017-2018 Hilisicon Electronics Co., Ltd.
+ *             http://www.huawei.com
+ *
+ * Authors: Yu Chen <chenyu56@huawei.com>
+ */
+
+#include <linux/gpio/consumer.h>
+#include <linux/kernel.h>
+#include <linux/mod_devicetable.h>
+#include <linux/module.h>
+#include <linux/notifier.h>
+#include <linux/platform_device.h>
+#include <linux/property.h>
+#include <linux/slab.h>
+#include <linux/usb/role.h>
+
+#define DEVICE_DRIVER_NAME "hisi_hikey_usb"
+
+#define HUB_VBUS_POWER_ON 1
+#define HUB_VBUS_POWER_OFF 0
+#define USB_SWITCH_TO_HUB 1
+#define USB_SWITCH_TO_TYPEC 0
+#define TYPEC_VBUS_POWER_ON 1
+#define TYPEC_VBUS_POWER_OFF 0
+
+struct hisi_hikey_usb {
+       struct gpio_desc *otg_switch;
+       struct gpio_desc *typec_vbus;
+       struct gpio_desc *hub_vbus;
+
+       struct usb_role_switch *hub_role_sw;
+
+       struct usb_role_switch *dev_role_sw;
+       enum usb_role role;
+
+       struct mutex lock;
+       struct work_struct work;
+
+       struct notifier_block nb;
+};
+
+static void hub_power_ctrl(struct hisi_hikey_usb *hisi_hikey_usb, int value)
+{
+       gpiod_set_value_cansleep(hisi_hikey_usb->hub_vbus, value);
+}
+
+static void usb_switch_ctrl(struct hisi_hikey_usb *hisi_hikey_usb,
+                           int switch_to)
+{
+       gpiod_set_value_cansleep(hisi_hikey_usb->otg_switch, switch_to);
+}
+
+static void usb_typec_power_ctrl(struct hisi_hikey_usb *hisi_hikey_usb,
+                                int value)
+{
+       gpiod_set_value_cansleep(hisi_hikey_usb->typec_vbus, value);
+}
+
+
+
+static void relay_set_role_switch(struct work_struct *work)
+{
+       struct hisi_hikey_usb *hisi_hikey_usb = container_of(work,
+                                                       struct hisi_hikey_usb,
+                                                       work);
+       struct usb_role_switch *sw;
+       enum usb_role role;
+
+       if (!hisi_hikey_usb || !hisi_hikey_usb->dev_role_sw)
+               return;
+
+       mutex_lock(&hisi_hikey_usb->lock);
+       switch (hisi_hikey_usb->role) {
+       case USB_ROLE_NONE:
+               usb_typec_power_ctrl(hisi_hikey_usb, TYPEC_VBUS_POWER_OFF);
+               usb_switch_ctrl(hisi_hikey_usb, USB_SWITCH_TO_HUB);
+               hub_power_ctrl(hisi_hikey_usb, HUB_VBUS_POWER_ON);
+               break;
+       case USB_ROLE_HOST:
+               hub_power_ctrl(hisi_hikey_usb, HUB_VBUS_POWER_OFF);
+               usb_switch_ctrl(hisi_hikey_usb, USB_SWITCH_TO_TYPEC);
+               usb_typec_power_ctrl(hisi_hikey_usb, TYPEC_VBUS_POWER_ON);
+               break;
+       case USB_ROLE_DEVICE:
+               hub_power_ctrl(hisi_hikey_usb, HUB_VBUS_POWER_OFF);
+               usb_typec_power_ctrl(hisi_hikey_usb, TYPEC_VBUS_POWER_OFF);
+               usb_switch_ctrl(hisi_hikey_usb, USB_SWITCH_TO_TYPEC);
+               break;
+       default:
+               break;
+       }
+       sw = hisi_hikey_usb->dev_role_sw;
+       role = hisi_hikey_usb->role;
+       mutex_unlock(&hisi_hikey_usb->lock);
+
+       usb_role_switch_set_role(sw, role);
+}
+
+static int hub_usb_role_switch_set(struct usb_role_switch *sw, enum usb_role role)
+{
+       struct hisi_hikey_usb *hisi_hikey_usb = usb_role_switch_get_drvdata(sw);
+
+       if (!hisi_hikey_usb || !hisi_hikey_usb->dev_role_sw)
+               return -EINVAL;
+
+       mutex_lock(&hisi_hikey_usb->lock);
+       hisi_hikey_usb->role = role;
+       mutex_unlock(&hisi_hikey_usb->lock);
+
+       schedule_work(&hisi_hikey_usb->work);
+
+       return 0;
+}
+
+static int hisi_hikey_usb_probe(struct platform_device *pdev)
+{
+       struct device *dev = &pdev->dev;
+       struct hisi_hikey_usb *hisi_hikey_usb;
+       struct usb_role_switch_desc hub_role_switch = {NULL};
+
+       hisi_hikey_usb = devm_kzalloc(dev, sizeof(*hisi_hikey_usb), GFP_KERNEL);
+       if (!hisi_hikey_usb)
+               return -ENOMEM;
+
+       hisi_hikey_usb->typec_vbus = devm_gpiod_get(dev, "typec-vbus",
+                                                   GPIOD_OUT_LOW);
+       if (IS_ERR(hisi_hikey_usb->typec_vbus))
+               return PTR_ERR(hisi_hikey_usb->typec_vbus);
+
+       hisi_hikey_usb->otg_switch = devm_gpiod_get(dev, "otg-switch",
+                                                   GPIOD_OUT_HIGH);
+       if (IS_ERR(hisi_hikey_usb->otg_switch))
+               return PTR_ERR(hisi_hikey_usb->otg_switch);
+
+       /* hub-vdd33-en is optional */
+       hisi_hikey_usb->hub_vbus = devm_gpiod_get_optional(dev, "hub-vdd33-en",
+                                                          GPIOD_OUT_HIGH);
+       if (IS_ERR(hisi_hikey_usb->hub_vbus))
+               return PTR_ERR(hisi_hikey_usb->hub_vbus);
+
+       hisi_hikey_usb->dev_role_sw = usb_role_switch_get(dev);
+       if (!hisi_hikey_usb->dev_role_sw)
+               return -EPROBE_DEFER;
+       if (IS_ERR(hisi_hikey_usb->dev_role_sw))
+               return PTR_ERR(hisi_hikey_usb->dev_role_sw);
+
+
+       INIT_WORK(&hisi_hikey_usb->work, relay_set_role_switch);
+       mutex_init(&hisi_hikey_usb->lock);
+
+       hub_role_switch.fwnode = dev_fwnode(dev);
+       hub_role_switch.set = hub_usb_role_switch_set;
+       hub_role_switch.driver_data = hisi_hikey_usb;
+
+       hisi_hikey_usb->hub_role_sw = usb_role_switch_register(dev,
+                                                       &hub_role_switch);
+
+       if (IS_ERR(hisi_hikey_usb->hub_role_sw)) {
+               usb_role_switch_put(hisi_hikey_usb->dev_role_sw);
+               return PTR_ERR(hisi_hikey_usb->hub_role_sw);
+       }
+
+       platform_set_drvdata(pdev, hisi_hikey_usb);
+
+       return 0;
+}
+
+static int  hisi_hikey_usb_remove(struct platform_device *pdev)
+{
+       struct hisi_hikey_usb *hisi_hikey_usb = platform_get_drvdata(pdev);
+
+       if (hisi_hikey_usb->hub_role_sw)
+               usb_role_switch_unregister(hisi_hikey_usb->hub_role_sw);
+
+       if (hisi_hikey_usb->dev_role_sw)
+               usb_role_switch_put(hisi_hikey_usb->dev_role_sw);
+
+       return 0;
+}
+
+static const struct of_device_id id_table_hisi_hikey_usb[] = {
+       {.compatible = "hisilicon,gpio_hubv1"},
+       {}
+};
+MODULE_DEVICE_TABLE(of, id_table_hisi_hikey_usb);
+
+static struct platform_driver hisi_hikey_usb_driver = {
+       .probe = hisi_hikey_usb_probe,
+       .remove = hisi_hikey_usb_remove,
+       .driver = {
+               .name = DEVICE_DRIVER_NAME,
+               .of_match_table = id_table_hisi_hikey_usb,
+       },
+};
+
+module_platform_driver(hisi_hikey_usb_driver);
+
+MODULE_AUTHOR("Yu Chen <chenyu56@huawei.com>");
+MODULE_DESCRIPTION("Driver Support for USB functionality of Hikey");
+MODULE_LICENSE("GPL v2");