mark arm* configs as sources

[packages/kernel.git] / kernel-pinebook-pro.patch

From 8149051c34bc3d4c55adc56d04ffb7f7a04c2fd9 Mon Sep 17 00:00:00 2001
From: Dan Johansen <strit@manjaro.org>
Date: Sun, 2 Jan 2022 16:45:28 +0100
Subject: [PATCH 1/2] Add megis extcon changes to fusb302

Signed-off-by: Dan Johansen <strit@manjaro.org>
---
 drivers/phy/rockchip/phy-rockchip-typec.c |  5 +++
 drivers/usb/typec/Kconfig                 |  7 ++++
 drivers/usb/typec/Makefile                |  1 +
 drivers/usb/typec/tcpm/fusb302.c          | 47 ++++++++++++++++-------
 drivers/usb/typec/tcpm/fusb302_reg.h      | 16 ++++----
 5 files changed, 53 insertions(+), 23 deletions(-)

diff --git a/drivers/phy/rockchip/phy-rockchip-typec.c b/drivers/phy/rockchip/phy-rockchip-typec.c
index d2bbdc96a167..fa10ee9a5794 100644
--- a/drivers/phy/rockchip/phy-rockchip-typec.c
+++ b/drivers/phy/rockchip/phy-rockchip-typec.c
@@ -350,6 +350,7 @@ struct usb3phy_reg {
  * struct rockchip_usb3phy_port_cfg - usb3-phy port configuration.
  * @reg: the base address for usb3-phy config.
  * @typec_conn_dir: the register of type-c connector direction.
+ * @typec_conn_dir_sel: the register of type-c connector direction source.
  * @usb3tousb2_en: the register of type-c force usb2 to usb2 enable.
  * @external_psm: the register of type-c phy external psm clock.
  * @pipe_status: the register of type-c phy pipe status.
@@ -360,6 +361,7 @@ struct usb3phy_reg {
 struct rockchip_usb3phy_port_cfg {
 	unsigned int reg;
 	struct usb3phy_reg typec_conn_dir;
+	struct usb3phy_reg typec_conn_dir_sel;
 	struct usb3phy_reg usb3tousb2_en;
 	struct usb3phy_reg external_psm;
 	struct usb3phy_reg pipe_status;
@@ -434,6 +436,7 @@ static const struct rockchip_usb3phy_port_cfg rk3399_usb3phy_port_cfgs[] = {
 	{
 		.reg = 0xff7c0000,
 		.typec_conn_dir	= { 0xe580, 0, 16 },
+		.typec_conn_dir_sel	= { 0xe580, 8, 16+8 },
 		.usb3tousb2_en	= { 0xe580, 3, 19 },
 		.external_psm	= { 0xe588, 14, 30 },
 		.pipe_status	= { 0xe5c0, 0, 0 },
@@ -444,6 +447,7 @@ static const struct rockchip_usb3phy_port_cfg rk3399_usb3phy_port_cfgs[] = {
 	{
 		.reg = 0xff800000,
 		.typec_conn_dir	= { 0xe58c, 0, 16 },
+		.typec_conn_dir_sel	= { 0xe58c, 8, 16+8 },
 		.usb3tousb2_en	= { 0xe58c, 3, 19 },
 		.external_psm	= { 0xe594, 14, 30 },
 		.pipe_status	= { 0xe5c0, 16, 16 },
@@ -739,6 +743,7 @@ static int tcphy_phy_init(struct rockchip_typec_phy *tcphy, u8 mode)
 
 	reset_control_deassert(tcphy->tcphy_rst);
 
+	property_enable(tcphy, &cfg->typec_conn_dir_sel, 0);
 	property_enable(tcphy, &cfg->typec_conn_dir, tcphy->flip);
 	tcphy_dp_aux_set_flip(tcphy);
 
diff --git a/drivers/usb/typec/Kconfig b/drivers/usb/typec/Kconfig
index ab480f38523a..01ecc5e590f1 100644
--- a/drivers/usb/typec/Kconfig
+++ b/drivers/usb/typec/Kconfig
@@ -88,6 +88,13 @@ config TYPEC_QCOM_PMIC
 	  If you choose to build this driver as a dynamically linked module, the
 	  module will be called wusb3801.ko.
 
+config TYPEC_EXTCON
+	tristate "Type-C switch/mux -> extcon interface bridge driver"
+	depends on USB_ROLE_SWITCH
+	help
+	  Say Y or M here if your system needs bridging between typec class
+	  and extcon interfaces.
+
 source "drivers/usb/typec/mux/Kconfig"
 
 source "drivers/usb/typec/altmodes/Kconfig"
diff --git a/drivers/usb/typec/Makefile b/drivers/usb/typec/Makefile
index a0adb8947a30..d9d829386b73 100644
--- a/drivers/usb/typec/Makefile
+++ b/drivers/usb/typec/Makefile
@@ -8,4 +8,5 @@ obj-$(CONFIG_TYPEC_TPS6598X)	+= tipd/
 obj-$(CONFIG_TYPEC_STUSB160X) 	+= stusb160x.o
 obj-$(CONFIG_TYPEC_RT1719)	+= rt1719.o
 obj-$(CONFIG_TYPEC_WUSB3801)	+= wusb3801.o
+obj-$(CONFIG_TYPEC_EXTCON)	+= typec-extcon.o
 obj-$(CONFIG_TYPEC)		+= mux/
diff --git a/drivers/usb/typec/tcpm/fusb302.c b/drivers/usb/typec/tcpm/fusb302.c
index 72f9001b0792..cb26793f90f8 100644
--- a/drivers/usb/typec/tcpm/fusb302.c
+++ b/drivers/usb/typec/tcpm/fusb302.c
@@ -440,6 +440,16 @@ static int tcpm_get_current_limit(struct tcpc_dev *dev)
 	int current_limit = 0;
 	unsigned long timeout;
 
+	/*
+	 * To avoid cycles in OF dependencies, we get extcon when necessary
+	 * outside of probe function.
+	 */
+	if (of_property_read_bool(chip->dev->of_node, "extcon") && !chip->extcon) {
+		chip->extcon = extcon_get_edev_by_phandle(chip->dev, 0);
+		if (IS_ERR(chip->extcon))
+			chip->extcon = NULL;
+	}
+
 	if (!chip->extcon)
 		return 0;
 
@@ -498,6 +508,7 @@ static int fusb302_set_toggling(struct fusb302_chip *chip,
 				enum toggling_mode mode)
 {
 	int ret = 0;
+	u8 reg;
 
 	/* first disable toggling */
 	ret = fusb302_i2c_clear_bits(chip, FUSB_REG_CONTROL2,
@@ -556,6 +567,12 @@ static int fusb302_set_toggling(struct fusb302_chip *chip,
 	} else {
 		/* Datasheet says vconn MUST be off when toggling */
 		WARN(chip->vconn_on, "Vconn is on during toggle start");
+
+		/* clear interrupts */
+                ret = fusb302_i2c_read(chip, FUSB_REG_INTERRUPT, &reg);
+		if (ret < 0)
+			return ret;
+
 		/* unmask TOGDONE interrupt */
 		ret = fusb302_i2c_clear_bits(chip, FUSB_REG_MASKA,
 					     FUSB_REG_MASKA_TOGDONE);
@@ -635,6 +652,14 @@ static int tcpm_set_cc(struct tcpc_dev *dev, enum typec_cc_status cc)
 		goto done;
 	}
 
+	/* adjust current for SRC */
+	ret = fusb302_set_src_current(chip, cc_src_current[cc]);
+	if (ret < 0) {
+		fusb302_log(chip, "cannot set src current %s, ret=%d",
+			    typec_cc_status_name[cc], ret);
+		goto done;
+	}
+
 	ret = fusb302_i2c_mask_write(chip, FUSB_REG_SWITCHES0,
 				     switches0_mask, switches0_data);
 	if (ret < 0) {
@@ -645,14 +670,6 @@ static int tcpm_set_cc(struct tcpc_dev *dev, enum typec_cc_status cc)
 	chip->cc1 = TYPEC_CC_OPEN;
 	chip->cc2 = TYPEC_CC_OPEN;
 
-	/* adjust current for SRC */
-	ret = fusb302_set_src_current(chip, cc_src_current[cc]);
-	if (ret < 0) {
-		fusb302_log(chip, "cannot set src current %s, ret=%d",
-			    typec_cc_status_name[cc], ret);
-		goto done;
-	}
-
 	/* enable/disable interrupts, BC_LVL for SNK and COMP_CHNG for SRC */
 	switch (cc) {
 	case TYPEC_CC_RP_DEF:
@@ -1528,14 +1545,16 @@ static void fusb302_irq_work(struct work_struct *work)
 		    "IRQ: 0x%02x, a: 0x%02x, b: 0x%02x, status0: 0x%02x",
 		    interrupt, interrupta, interruptb, status0);
 
-	if (interrupt & FUSB_REG_INTERRUPT_VBUSOK) {
-		vbus_present = !!(status0 & FUSB_REG_STATUS0_VBUSOK);
+	vbus_present = !!(status0 & FUSB_REG_STATUS0_VBUSOK);
+	if (interrupt & FUSB_REG_INTERRUPT_VBUSOK)
 		fusb302_log(chip, "IRQ: VBUS_OK, vbus=%s",
 			    vbus_present ? "On" : "Off");
-		if (vbus_present != chip->vbus_present) {
-			chip->vbus_present = vbus_present;
-			tcpm_vbus_change(chip->tcpm_port);
-		}
+	if (vbus_present != chip->vbus_present) {
+		chip->vbus_present = vbus_present;
+		if (!(interrupt & FUSB_REG_INTERRUPT_VBUSOK))
+		fusb302_log(chip, "IRQ: VBUS changed without interrupt, vbus=%s",
+			    vbus_present ? "On" : "Off");
+		tcpm_vbus_change(chip->tcpm_port);
 	}
 
 	if ((interrupta & FUSB_REG_INTERRUPTA_TOGDONE) && intr_togdone) {
diff --git a/drivers/usb/typec/tcpm/fusb302_reg.h b/drivers/usb/typec/tcpm/fusb302_reg.h
index edc0e4b0f1e6..f37d226c5027 100644
--- a/drivers/usb/typec/tcpm/fusb302_reg.h
+++ b/drivers/usb/typec/tcpm/fusb302_reg.h
@@ -27,14 +27,13 @@
 #define FUSB_REG_SWITCHES1_TXCC2_EN		BIT(1)
 #define FUSB_REG_SWITCHES1_TXCC1_EN		BIT(0)
 #define FUSB_REG_MEASURE			0x04
-#define FUSB_REG_MEASURE_MDAC5			BIT(7)
-#define FUSB_REG_MEASURE_MDAC4			BIT(6)
-#define FUSB_REG_MEASURE_MDAC3			BIT(5)
-#define FUSB_REG_MEASURE_MDAC2			BIT(4)
-#define FUSB_REG_MEASURE_MDAC1			BIT(3)
-#define FUSB_REG_MEASURE_MDAC0			BIT(2)
-#define FUSB_REG_MEASURE_VBUS			BIT(1)
-#define FUSB_REG_MEASURE_XXXX5			BIT(0)
+#define FUSB_REG_MEASURE_VBUS			BIT(6)
+#define FUSB_REG_MEASURE_MDAC5			BIT(5)
+#define FUSB_REG_MEASURE_MDAC4			BIT(4)
+#define FUSB_REG_MEASURE_MDAC3			BIT(3)
+#define FUSB_REG_MEASURE_MDAC2			BIT(2)
+#define FUSB_REG_MEASURE_MDAC1			BIT(1)
+#define FUSB_REG_MEASURE_MDAC0			BIT(0)
 #define FUSB_REG_CONTROL0			0x06
 #define FUSB_REG_CONTROL0_TX_FLUSH		BIT(6)
 #define FUSB_REG_CONTROL0_INT_MASK		BIT(5)
@@ -105,7 +104,6 @@
 #define FUSB_REG_STATUS0A_RX_SOFT_RESET		BIT(1)
 #define FUSB_REG_STATUS0A_RX_HARD_RESET		BIT(0)
 #define FUSB_REG_STATUS1A			0x3D
-#define FUSB_REG_STATUS1A_TOGSS			BIT(3)
 #define FUSB_REG_STATUS1A_TOGSS_RUNNING		0x0
 #define FUSB_REG_STATUS1A_TOGSS_SRC1		0x1
 #define FUSB_REG_STATUS1A_TOGSS_SRC2		0x2
-- 
2.34.1

From 6af2e6a2d59bd755234e5e15a47dfa669788143c Mon Sep 17 00:00:00 2001
From: Dan Johansen <strit@manjaro.org>
Date: Sun, 2 Jan 2022 16:47:40 +0100
Subject: [PATCH 2/2] usb: typec: Add megis typex to extcon bridge driver

Signed-off-by: Dan Johansen <strit@manjaro.org>
---
 drivers/usb/typec/typec-extcon.c | 337 +++++++++++++++++++++++++++++++
 1 file changed, 337 insertions(+)
 create mode 100644 drivers/usb/typec/typec-extcon.c

diff --git a/drivers/usb/typec/typec-extcon.c b/drivers/usb/typec/typec-extcon.c
new file mode 100644
index 000000000000..143ff2486f2f
--- /dev/null
+++ b/drivers/usb/typec/typec-extcon.c
@@ -0,0 +1,337 @@
+/*
+ * typec -> extcon bridge
+ * Copyright (c) 2021 Ondřej Jirman <megi@xff.cz>
+ *
+ * This driver bridges standard type-c interfaces to drivers that
+ * expect extcon interface.
+ */
+
+#include <linux/delay.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/power_supply.h>
+#include <linux/platform_device.h>
+#include <linux/usb/pd.h>
+#include <linux/usb/role.h>
+#include <linux/usb/typec.h>
+#include <linux/usb/typec_dp.h>
+#include <linux/usb/typec_mux.h>
+#include <linux/extcon-provider.h>
+
+struct typec_extcon {
+        struct device *dev;
+
+	/* consumers */
+	struct usb_role_switch *role_sw;
+        struct typec_switch_dev *sw;
+        struct typec_mux_dev *mux;
+
+	/* providers */
+	struct extcon_dev *extcon;
+	struct notifier_block extcon_nb;
+
+	/* cached state from typec controller */
+	enum usb_role role;
+	enum typec_orientation orientation;
+	struct typec_altmode alt;
+	unsigned long mode;
+	bool has_alt;
+	struct mutex lock;
+};
+
+static const unsigned int typec_extcon_cable[] = {
+	EXTCON_DISP_DP,
+
+	EXTCON_USB,
+	EXTCON_USB_HOST,
+
+	EXTCON_CHG_USB_SDP,
+	EXTCON_CHG_USB_CDP,
+	EXTCON_CHG_USB_DCP,
+	EXTCON_CHG_USB_ACA,
+
+	EXTCON_NONE,
+};
+
+static void typec_extcon_set_cable(struct typec_extcon *tce, int id, bool on,
+				   union extcon_property_value prop_ss,
+				   union extcon_property_value prop_or)
+{
+	union extcon_property_value cur_ss, cur_or;
+	bool prop_diff = false;
+	int ret;
+
+	ret = extcon_get_property(tce->extcon, id,
+				  EXTCON_PROP_USB_SS, &cur_ss);
+	if (ret || cur_ss.intval != prop_ss.intval)
+		prop_diff = true;
+
+	ret = extcon_get_property(tce->extcon, id,
+				  EXTCON_PROP_USB_TYPEC_POLARITY, &cur_or);
+	if (ret || cur_or.intval != prop_or.intval)
+		prop_diff = true;
+
+	if (!on && extcon_get_state(tce->extcon, id)) {
+		extcon_set_state_sync(tce->extcon, id, false);
+	} else if (on && (!extcon_get_state(tce->extcon, id) || prop_diff)) {
+		extcon_set_state(tce->extcon, id, true);
+		extcon_set_property(tce->extcon, id,
+				    EXTCON_PROP_USB_SS, prop_ss);
+		extcon_set_property(tce->extcon, id,
+				    EXTCON_PROP_USB_TYPEC_POLARITY, prop_or);
+		extcon_sync(tce->extcon, id);
+	}
+}
+
+static int typec_extcon_sync_extcon(struct typec_extcon *tce)
+{
+	union extcon_property_value prop_ss, prop_or;
+	bool has_dp = false;
+
+        mutex_lock(&tce->lock);
+
+	/* connector is disconnected */
+	if (tce->orientation == TYPEC_ORIENTATION_NONE) {
+		typec_extcon_set_cable(tce, EXTCON_USB, false, prop_ss, prop_or);
+		typec_extcon_set_cable(tce, EXTCON_USB_HOST, false, prop_ss, prop_or);
+		typec_extcon_set_cable(tce, EXTCON_DISP_DP, false, prop_ss, prop_or);
+
+		extcon_set_state_sync(tce->extcon, EXTCON_CHG_USB_SDP, false);
+		extcon_set_state_sync(tce->extcon, EXTCON_CHG_USB_DCP, false);
+		extcon_set_state_sync(tce->extcon, EXTCON_CHG_USB_CDP, false);
+		extcon_set_state_sync(tce->extcon, EXTCON_CHG_USB_ACA, false);
+
+                goto out_unlock;
+	}
+
+	prop_or.intval = tce->orientation == TYPEC_ORIENTATION_NORMAL ? 0 : 1;
+	prop_ss.intval = 0;
+
+	if (tce->has_alt && tce->alt.svid == USB_TYPEC_DP_SID) {
+		switch (tce->mode) {
+		case TYPEC_STATE_SAFE:
+			break;
+		case TYPEC_DP_STATE_C:
+		case TYPEC_DP_STATE_E:
+			has_dp = true;
+			break;
+		case TYPEC_DP_STATE_D:
+			has_dp = true;
+			fallthrough;
+		case TYPEC_STATE_USB:
+			prop_ss.intval = 1;
+			break;
+		default:
+			dev_err(tce->dev, "unhandled mux mode=%lu\n", tce->mode);
+			break;
+		}
+	}
+
+	typec_extcon_set_cable(tce, EXTCON_USB,
+			tce->role == USB_ROLE_DEVICE, prop_ss, prop_or);
+	typec_extcon_set_cable(tce, EXTCON_USB_HOST,
+			tce->role == USB_ROLE_HOST, prop_ss, prop_or);
+
+	typec_extcon_set_cable(tce, EXTCON_DISP_DP, has_dp, prop_ss, prop_or);
+
+out_unlock:
+	mutex_unlock(&tce->lock);
+	return 0;
+}
+
+static int typec_extcon_sw_set(struct typec_switch_dev *sw,
+			       enum typec_orientation orientation)
+{
+        struct typec_extcon *tce = typec_switch_get_drvdata(sw);
+
+	dev_dbg(tce->dev, "SW SET: orientation=%d\n", orientation);
+
+        mutex_lock(&tce->lock);
+	tce->orientation = orientation;
+        mutex_unlock(&tce->lock);
+
+	typec_extcon_sync_extcon(tce);
+
+        return 0;
+}
+
+static int typec_extcon_mux_set(struct typec_mux_dev *mux,
+				struct typec_mux_state *state)
+{
+        struct typec_extcon *tce = typec_mux_get_drvdata(mux);
+	struct typec_altmode *alt = state->alt;
+
+	dev_dbg(tce->dev, "MUX SET: state->mode=%lu\n", state->mode);
+	if (alt)
+		dev_dbg(tce->dev, "      ...alt: svid=%04hx mode=%d vdo=%08x active=%u\n",
+			alt->svid, alt->mode, alt->vdo, alt->active);
+
+        mutex_lock(&tce->lock);
+	tce->mode = state->mode;
+	tce->has_alt = alt != NULL;
+        if (alt)
+		tce->alt = *alt;
+	mutex_unlock(&tce->lock);
+
+	typec_extcon_sync_extcon(tce);
+
+        return 0;
+}
+
+static int typec_extcon_usb_set_role(struct usb_role_switch *sw,
+				     enum usb_role role)
+{
+        struct typec_extcon *tce = usb_role_switch_get_drvdata(sw);
+
+	dev_dbg(tce->dev, "ROLE SET: role=%d\n", role);
+
+        mutex_lock(&tce->lock);
+	tce->role = role;
+	mutex_unlock(&tce->lock);
+
+	typec_extcon_sync_extcon(tce);
+
+        return 0;
+}
+
+static int typec_extcon_notifier(struct notifier_block *nb,
+					 unsigned long action, void *data)
+{
+	struct typec_extcon *tce = container_of(nb, struct typec_extcon, extcon_nb);
+
+	bool sdp = extcon_get_state(tce->extcon, EXTCON_CHG_USB_SDP);
+	bool cdp = extcon_get_state(tce->extcon, EXTCON_CHG_USB_CDP);
+	bool dcp = extcon_get_state(tce->extcon, EXTCON_CHG_USB_DCP);
+	bool usb = extcon_get_state(tce->extcon, EXTCON_USB);
+	bool usb_host = extcon_get_state(tce->extcon, EXTCON_USB_HOST);
+	bool dp = extcon_get_state(tce->extcon, EXTCON_DISP_DP);
+
+	dev_info(tce->dev, "extcon changed sdp=%d cdp=%d dcp=%d usb=%d usb_host=%d dp=%d\n",
+		 sdp, cdp, dcp, usb, usb_host, dp);
+
+	return NOTIFY_OK;
+}
+
+static int typec_extcon_probe(struct platform_device *pdev)
+{
+        struct typec_switch_desc sw_desc = { };
+        struct typec_mux_desc mux_desc = { };
+        struct usb_role_switch_desc role_desc = { };
+        struct device *dev = &pdev->dev;
+        struct typec_extcon *tce;
+        int ret = 0;
+
+        tce = devm_kzalloc(dev, sizeof(*tce), GFP_KERNEL);
+        if (!tce)
+                return -ENOMEM;
+
+        tce->dev = &pdev->dev;
+	mutex_init(&tce->lock);
+	tce->mode = TYPEC_STATE_SAFE;
+
+	sw_desc.drvdata = tce;
+	sw_desc.fwnode = dev->fwnode;
+	sw_desc.set = typec_extcon_sw_set;
+
+	tce->sw = typec_switch_register(dev, &sw_desc);
+	if (IS_ERR(tce->sw))
+		return dev_err_probe(dev, PTR_ERR(tce->sw),
+				     "Error registering typec switch\n");
+
+	mux_desc.drvdata = tce;
+	mux_desc.fwnode = dev->fwnode;
+	mux_desc.set = typec_extcon_mux_set;
+
+	tce->mux = typec_mux_register(dev, &mux_desc);
+	if (IS_ERR(tce->mux)) {
+		ret = dev_err_probe(dev, PTR_ERR(tce->mux),
+				    "Error registering typec mux\n");
+		goto err_sw;
+	}
+
+	role_desc.driver_data = tce;
+	role_desc.fwnode = dev->fwnode;
+	role_desc.name = fwnode_get_name(dev->fwnode);
+	role_desc.set = typec_extcon_usb_set_role;
+
+	tce->role_sw = usb_role_switch_register(dev, &role_desc);
+	if (IS_ERR(tce->role_sw)) {
+		ret = dev_err_probe(dev, PTR_ERR(tce->role_sw),
+				    "Error registering USB role switch\n");
+		goto err_mux;
+	}
+
+	tce->extcon = devm_extcon_dev_allocate(dev, typec_extcon_cable);
+	if (IS_ERR(tce->extcon)) {
+		ret = PTR_ERR(tce->extcon);
+		goto err_role;
+	}
+
+	ret = devm_extcon_dev_register(dev, tce->extcon);
+	if (ret) {
+		ret = dev_err_probe(dev, ret, "failed to register extcon device\n");
+		goto err_role;
+	}
+
+	extcon_set_property_capability(tce->extcon, EXTCON_USB,
+				       EXTCON_PROP_USB_SS);
+	extcon_set_property_capability(tce->extcon, EXTCON_USB,
+				       EXTCON_PROP_USB_TYPEC_POLARITY);
+	extcon_set_property_capability(tce->extcon, EXTCON_USB_HOST,
+				       EXTCON_PROP_USB_SS);
+	extcon_set_property_capability(tce->extcon, EXTCON_USB_HOST,
+				       EXTCON_PROP_USB_TYPEC_POLARITY);
+	extcon_set_property_capability(tce->extcon, EXTCON_DISP_DP,
+				       EXTCON_PROP_USB_SS);
+	extcon_set_property_capability(tce->extcon, EXTCON_DISP_DP,
+				       EXTCON_PROP_USB_TYPEC_POLARITY);
+
+	tce->extcon_nb.notifier_call = typec_extcon_notifier;
+	ret = devm_extcon_register_notifier_all(dev, tce->extcon, &tce->extcon_nb);
+	if (ret) {
+		dev_err_probe(dev, ret, "Failed to register extcon notifier\n");
+		goto err_role;
+	}
+
+	return 0;
+
+err_role:
+	usb_role_switch_unregister(tce->role_sw);
+err_mux:
+	typec_mux_unregister(tce->mux);
+err_sw:
+	typec_switch_unregister(tce->sw);
+	return ret;
+}
+
+static int typec_extcon_remove(struct platform_device *pdev)
+{
+        struct typec_extcon *tce = platform_get_drvdata(pdev);
+
+	usb_role_switch_unregister(tce->role_sw);
+	typec_mux_unregister(tce->mux);
+	typec_switch_unregister(tce->sw);
+
+        return 0;
+}
+
+static struct of_device_id typec_extcon_of_match_table[] = {
+        { .compatible = "linux,typec-extcon-bridge" },
+        { },
+};
+MODULE_DEVICE_TABLE(of, typec_extcon_of_match_table);
+
+static struct platform_driver typec_extcon_driver = {
+        .driver = {
+                .name = "typec-extcon",
+                .of_match_table = typec_extcon_of_match_table,
+        },
+        .probe = typec_extcon_probe,
+        .remove = typec_extcon_remove,
+};
+
+module_platform_driver(typec_extcon_driver);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Ondrej Jirman <megous@megous.com>");
+MODULE_DESCRIPTION("typec -> extcon bridge driver");
-- 
2.34.1

From 4c839ce95766910235ff558b2959589c9068917c Mon Sep 17 00:00:00 2001
From: Dan Johansen <strit@manjaro.org>
Date: Sun, 2 Jan 2022 19:15:39 +0100
Subject: [PATCH] arm64: dts: rockchip: add typec extcon hack

Signed-off-by: Dan Johansen <strit@manjaro.org>
---
 .../boot/dts/rockchip/rk3399-pinebook-pro.dts | 31 +++++++++++++++++--
 1 file changed, 29 insertions(+), 2 deletions(-)

diff --git a/arch/arm64/boot/dts/rockchip/rk3399-pinebook-pro.dts b/arch/arm64/boot/dts/rockchip/rk3399-pinebook-pro.dts
index c2f021a1a18f..fc33e111bbee 100644
--- a/arch/arm64/boot/dts/rockchip/rk3399-pinebook-pro.dts
+++ b/arch/arm64/boot/dts/rockchip/rk3399-pinebook-pro.dts
@@ -384,6 +384,20 @@ mains_charger: dc-charger {
 		pinctrl-names = "default";
 		pinctrl-0 = <&dc_det_pin>;
 	};
+	
+    typec_extcon_bridge: typec-extcon {
+		compatible = "linux,typec-extcon-bridge";
+		usb-role-switch;
+		orientation-switch;
+		mode-switch;
+		svid = /bits/ 16 <0xff01>;
+	};
+};
+
+&cdn_dp {
+	status = "okay";
+	extcon = <&typec_extcon_bridge>;
+	phys = <&tcphy0_dp>;
 };
 
 &cpu_b0 {
@@ -705,6 +719,8 @@ fusb0: fusb30x@22 {
 		pinctrl-names = "default";
 		pinctrl-0 = <&fusb0_int_pin>;
 		vbus-supply = <&vbus_typec>;
+		extcon = <&typec_extcon_bridge>;
+		usb-role-switch = <&typec_extcon_bridge>;
 
 		connector {
 			compatible = "usb-c-connector";
@@ -713,10 +729,20 @@ connector {
 			op-sink-microwatt = <1000000>;
 			power-role = "dual";
 			sink-pdos =
-				<PDO_FIXED(5000, 2500, PDO_FIXED_USB_COMM)>;
+				<PDO_FIXED(5000, 2500, PDO_FIXED_USB_COMM | PDO_FIXED_DUAL_ROLE | PDO_FIXED_DATA_SWAP)>;
 			source-pdos =
-				<PDO_FIXED(5000, 1400, PDO_FIXED_USB_COMM)>;
+				<PDO_FIXED(5000, 1400, PDO_FIXED_USB_COMM | PDO_FIXED_DUAL_ROLE | PDO_FIXED_DATA_SWAP)>;
 			try-power-role = "sink";
+			
+			mode-switch = <&typec_extcon_bridge>;
+			orientation-switch = <&typec_extcon_bridge>;
+
+			altmodes {
+				dp {
+					svid = <0xff01>;
+					vdo = <0x0c0046>;
+				};
+			};
 
 			ports {
 				#address-cells = <1>;
@@ -984,6 +1010,7 @@ spiflash: flash@0 {
 };
 
 &tcphy0 {
+	extcon = <&typec_extcon_bridge>;
 	status = "okay";
 };
 
-- 
2.34.1

From: Hugh Cole-Baker <sigmaris@gmail.com>
Subject: [PATCH v2 1/3] drm/rockchip: define gamma registers for RK3399
Date: Tue, 19 Oct 2021 22:58:41 +0100

The VOP on RK3399 has a different approach from previous versions for
setting a gamma lookup table, using an update_gamma_lut register. As
this differs from RK3288, give RK3399 its own set of "common" register
definitions.

Signed-off-by: Hugh Cole-Baker <sigmaris@gmail.com>
---

Changes from v1: no changes in this patch

 drivers/gpu/drm/rockchip/rockchip_drm_vop.h |  2 ++
 drivers/gpu/drm/rockchip/rockchip_vop_reg.c | 24 +++++++++++++++++++--
 drivers/gpu/drm/rockchip/rockchip_vop_reg.h |  1 +
 3 files changed, 25 insertions(+), 2 deletions(-)

diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_vop.h b/drivers/gpu/drm/rockchip/rockchip_drm_vop.h
index 857d97cdc67c..14179e89bd21 100644
--- a/drivers/gpu/drm/rockchip/rockchip_drm_vop.h
+++ b/drivers/gpu/drm/rockchip/rockchip_drm_vop.h
@@ -99,6 +99,8 @@ struct vop_common {
 	struct vop_reg dither_down_en;
 	struct vop_reg dither_up;
 	struct vop_reg dsp_lut_en;
+	struct vop_reg update_gamma_lut;
+	struct vop_reg lut_buffer_index;
 	struct vop_reg gate_en;
 	struct vop_reg mmu_en;
 	struct vop_reg out_mode;
diff --git a/drivers/gpu/drm/rockchip/rockchip_vop_reg.c b/drivers/gpu/drm/rockchip/rockchip_vop_reg.c
index ca7cc82125cb..bfb7e130f09b 100644
--- a/drivers/gpu/drm/rockchip/rockchip_vop_reg.c
+++ b/drivers/gpu/drm/rockchip/rockchip_vop_reg.c
@@ -865,6 +865,24 @@ static const struct vop_output rk3399_output = {
 	.mipi_dual_channel_en = VOP_REG(RK3288_SYS_CTRL, 0x1, 3),
 };
 
+static const struct vop_common rk3399_common = {
+	.standby = VOP_REG_SYNC(RK3399_SYS_CTRL, 0x1, 22),
+	.gate_en = VOP_REG(RK3399_SYS_CTRL, 0x1, 23),
+	.mmu_en = VOP_REG(RK3399_SYS_CTRL, 0x1, 20),
+	.dither_down_sel = VOP_REG(RK3399_DSP_CTRL1, 0x1, 4),
+	.dither_down_mode = VOP_REG(RK3399_DSP_CTRL1, 0x1, 3),
+	.dither_down_en = VOP_REG(RK3399_DSP_CTRL1, 0x1, 2),
+	.pre_dither_down = VOP_REG(RK3399_DSP_CTRL1, 0x1, 1),
+	.dither_up = VOP_REG(RK3399_DSP_CTRL1, 0x1, 6),
+	.dsp_lut_en = VOP_REG(RK3399_DSP_CTRL1, 0x1, 0),
+	.update_gamma_lut = VOP_REG(RK3399_DSP_CTRL1, 0x1, 7),
+	.lut_buffer_index = VOP_REG(RK3399_DBG_POST_REG1, 0x1, 1),
+	.data_blank = VOP_REG(RK3399_DSP_CTRL0, 0x1, 19),
+	.dsp_blank = VOP_REG(RK3399_DSP_CTRL0, 0x3, 18),
+	.out_mode = VOP_REG(RK3399_DSP_CTRL0, 0xf, 0),
+	.cfg_done = VOP_REG_SYNC(RK3399_REG_CFG_DONE, 0x1, 0),
+};
+
 static const struct vop_yuv2yuv_phy rk3399_yuv2yuv_win01_data = {
 	.y2r_coefficients = {
 		VOP_REG(RK3399_WIN0_YUV2YUV_Y2R + 0, 0xffff, 0),
@@ -944,7 +962,7 @@ static const struct vop_data rk3399_vop_big = {
 	.version = VOP_VERSION(3, 5),
 	.feature = VOP_FEATURE_OUTPUT_RGB10,
 	.intr = &rk3366_vop_intr,
-	.common = &rk3288_common,
+	.common = &rk3399_common,
 	.modeset = &rk3288_modeset,
 	.output = &rk3399_output,
 	.afbc = &rk3399_vop_afbc,
@@ -952,6 +970,7 @@ static const struct vop_data rk3399_vop_big = {
 	.win = rk3399_vop_win_data,
 	.win_size = ARRAY_SIZE(rk3399_vop_win_data),
 	.win_yuv2yuv = rk3399_vop_big_win_yuv2yuv_data,
+	.lut_size = 1024,
 };
 
 static const struct vop_win_data rk3399_vop_lit_win_data[] = {
@@ -970,13 +989,14 @@ static const struct vop_win_yuv2yuv_data rk3399_vop_lit_win_yuv2yuv_data[] = {
 static const struct vop_data rk3399_vop_lit = {
 	.version = VOP_VERSION(3, 6),
 	.intr = &rk3366_vop_intr,
-	.common = &rk3288_common,
+	.common = &rk3399_common,
 	.modeset = &rk3288_modeset,
 	.output = &rk3399_output,
 	.misc = &rk3368_misc,
 	.win = rk3399_vop_lit_win_data,
 	.win_size = ARRAY_SIZE(rk3399_vop_lit_win_data),
 	.win_yuv2yuv = rk3399_vop_lit_win_yuv2yuv_data,
+	.lut_size = 256,
 };
 
 static const struct vop_win_data rk3228_vop_win_data[] = {
diff --git a/drivers/gpu/drm/rockchip/rockchip_vop_reg.h b/drivers/gpu/drm/rockchip/rockchip_vop_reg.h
index 0b3cd65ba5c1..406e981c75bd 100644
--- a/drivers/gpu/drm/rockchip/rockchip_vop_reg.h
+++ b/drivers/gpu/drm/rockchip/rockchip_vop_reg.h
@@ -628,6 +628,7 @@
 #define RK3399_YUV2YUV_WIN			0x02c0
 #define RK3399_YUV2YUV_POST			0x02c4
 #define RK3399_AUTO_GATING_EN			0x02cc
+#define RK3399_DBG_POST_REG1			0x036c
 #define RK3399_WIN0_CSC_COE			0x03a0
 #define RK3399_WIN1_CSC_COE			0x03c0
 #define RK3399_WIN2_CSC_COE			0x03e0

From: Hugh Cole-Baker <sigmaris@gmail.com>
Subject: [PATCH v2 2/3] drm/rockchip: support gamma control on RK3399
Date: Tue, 19 Oct 2021 22:58:42 +0100

The RK3399 has a 1024-entry gamma LUT with 10 bits per component on its
"big" VOP and a 256-entry, 8 bit per component LUT on the "little" VOP.
Compared to the RK3288, it no longer requires disabling gamma while
updating the LUT. On the RK3399, the LUT can be updated at any time as
the hardware has two LUT buffers, one can be written while the other is
in use. A swap of the buffers is triggered by writing 1 to the
update_gamma_lut register.

Signed-off-by: Hugh Cole-Baker <sigmaris@gmail.com>
---

Changes from v1: Moved the vop_crtc_gamma_set call to the end of
vop_crtc_atomic_enable after the clocks and CRTC are enabled.

 drivers/gpu/drm/rockchip/rockchip_drm_vop.c | 105 +++++++++++++-------
 1 file changed, 71 insertions(+), 34 deletions(-)

diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c
index ba9e14da41b4..e2c97f1b26da 100644
--- a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c
+++ b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c
@@ -9,6 +9,7 @@
 #include <linux/delay.h>
 #include <linux/iopoll.h>
 #include <linux/kernel.h>
+#include <linux/log2.h>
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
@@ -66,6 +67,9 @@
 #define VOP_REG_SET(vop, group, name, v) \
 		    vop_reg_set(vop, &vop->data->group->name, 0, ~0, v, #name)
 
+#define VOP_HAS_REG(vop, group, name) \
+		(!!(vop->data->group->name.mask))
+
 #define VOP_INTR_SET_TYPE(vop, name, type, v) \
 	do { \
 		int i, reg = 0, mask = 0; \
@@ -1204,17 +1208,22 @@ static bool vop_dsp_lut_is_enabled(struct vop *vop)
 	return vop_read_reg(vop, 0, &vop->data->common->dsp_lut_en);
 }
 
+static u32 vop_lut_buffer_index(struct vop *vop)
+{
+	return vop_read_reg(vop, 0, &vop->data->common->lut_buffer_index);
+}
+
 static void vop_crtc_write_gamma_lut(struct vop *vop, struct drm_crtc *crtc)
 {
 	struct drm_color_lut *lut = crtc->state->gamma_lut->data;
-	unsigned int i;
+	unsigned int i, bpc = ilog2(vop->data->lut_size);
 
 	for (i = 0; i < crtc->gamma_size; i++) {
 		u32 word;
 
-		word = (drm_color_lut_extract(lut[i].red, 10) << 20) |
-		       (drm_color_lut_extract(lut[i].green, 10) << 10) |
-			drm_color_lut_extract(lut[i].blue, 10);
+		word = (drm_color_lut_extract(lut[i].red, bpc) << (2 * bpc)) |
+		       (drm_color_lut_extract(lut[i].green, bpc) << bpc) |
+			drm_color_lut_extract(lut[i].blue, bpc);
 		writel(word, vop->lut_regs + i * 4);
 	}
 }
@@ -1224,38 +1233,66 @@ static void vop_crtc_gamma_set(struct vop *vop, struct drm_crtc *crtc,
 {
 	struct drm_crtc_state *state = crtc->state;
 	unsigned int idle;
+	u32 lut_idx, old_idx;
 	int ret;
 
 	if (!vop->lut_regs)
 		return;
-	/*
-	 * To disable gamma (gamma_lut is null) or to write
-	 * an update to the LUT, clear dsp_lut_en.
-	 */
-	spin_lock(&vop->reg_lock);
-	VOP_REG_SET(vop, common, dsp_lut_en, 0);
-	vop_cfg_done(vop);
-	spin_unlock(&vop->reg_lock);
 
-	/*
-	 * In order to write the LUT to the internal memory,
-	 * we need to first make sure the dsp_lut_en bit is cleared.
-	 */
-	ret = readx_poll_timeout(vop_dsp_lut_is_enabled, vop,
-				 idle, !idle, 5, 30 * 1000);
-	if (ret) {
-		DRM_DEV_ERROR(vop->dev, "display LUT RAM enable timeout!\n");
-		return;
-	}
+	if (!state->gamma_lut || !VOP_HAS_REG(vop, common, update_gamma_lut)) {
+		/*
+		 * To disable gamma (gamma_lut is null) or to write
+		 * an update to the LUT, clear dsp_lut_en.
+		 */
+		spin_lock(&vop->reg_lock);
+		VOP_REG_SET(vop, common, dsp_lut_en, 0);
+		vop_cfg_done(vop);
+		spin_unlock(&vop->reg_lock);
 
-	if (!state->gamma_lut)
-		return;
+		/*
+		 * In order to write the LUT to the internal memory,
+		 * we need to first make sure the dsp_lut_en bit is cleared.
+		 */
+		ret = readx_poll_timeout(vop_dsp_lut_is_enabled, vop,
+					 idle, !idle, 5, 30 * 1000);
+		if (ret) {
+			DRM_DEV_ERROR(vop->dev, "display LUT RAM enable timeout!\n");
+			return;
+		}
+
+		if (!state->gamma_lut)
+			return;
+	} else {
+		/*
+		 * On RK3399 the gamma LUT can updated without clearing dsp_lut_en,
+		 * by setting update_gamma_lut then waiting for lut_buffer_index change
+		 */
+		old_idx = vop_lut_buffer_index(vop);
+	}
 
 	spin_lock(&vop->reg_lock);
 	vop_crtc_write_gamma_lut(vop, crtc);
 	VOP_REG_SET(vop, common, dsp_lut_en, 1);
+	VOP_REG_SET(vop, common, update_gamma_lut, 1);
 	vop_cfg_done(vop);
 	spin_unlock(&vop->reg_lock);
+
+	if (VOP_HAS_REG(vop, common, update_gamma_lut)) {
+		ret = readx_poll_timeout(vop_lut_buffer_index, vop,
+					 lut_idx, lut_idx != old_idx, 5, 30 * 1000);
+		if (ret) {
+			DRM_DEV_ERROR(vop->dev, "gamma LUT update timeout!\n");
+			return;
+		}
+
+		/*
+		 * update_gamma_lut is auto cleared by HW, but write 0 to clear the bit
+		 * in our backup of the regs.
+		 */
+		spin_lock(&vop->reg_lock);
+		VOP_REG_SET(vop, common, update_gamma_lut, 0);
+		spin_unlock(&vop->reg_lock);
+	}
 }
 
 static void vop_crtc_atomic_begin(struct drm_crtc *crtc,
@@ -1305,14 +1342,6 @@ static void vop_crtc_atomic_enable(struct drm_crtc *crtc,
 		return;
 	}
 
-	/*
-	 * If we have a GAMMA LUT in the state, then let's make sure
-	 * it's updated. We might be coming out of suspend,
-	 * which means the LUT internal memory needs to be re-written.
-	 */
-	if (crtc->state->gamma_lut)
-		vop_crtc_gamma_set(vop, crtc, old_state);
-
 	mutex_lock(&vop->vop_lock);
 
 	WARN_ON(vop->event);
@@ -1403,6 +1432,14 @@ static void vop_crtc_atomic_enable(struct drm_crtc *crtc,
 
 	VOP_REG_SET(vop, common, standby, 0);
 	mutex_unlock(&vop->vop_lock);
+
+	/*
+	 * If we have a GAMMA LUT in the state, then let's make sure
+	 * it's updated. We might be coming out of suspend,
+	 * which means the LUT internal memory needs to be re-written.
+	 */
+	if (crtc->state->gamma_lut)
+		vop_crtc_gamma_set(vop, crtc, old_state);
 }
 
 static bool vop_fs_irq_is_pending(struct vop *vop)
@@ -2125,8 +2162,8 @@ static int vop_bind(struct device *dev, struct device *master, void *data)
 
 	res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
 	if (res) {
-		if (!vop_data->lut_size) {
-			DRM_DEV_ERROR(dev, "no gamma LUT size defined\n");
+		if (vop_data->lut_size != 1024 && vop_data->lut_size != 256) {
+			DRM_DEV_ERROR(dev, "unsupported gamma LUT size %d\n", vop_data->lut_size);
 			return -EINVAL;
 		}
 		vop->lut_regs = devm_ioremap_resource(dev, res);

From: Hugh Cole-Baker <sigmaris@gmail.com>
Subject: [PATCH v2 3/3] arm64: dts: rockchip: enable gamma control on RK3399
Date: Tue, 19 Oct 2021 22:58:43 +0100

Define the memory region on RK3399 VOPs containing the gamma LUT at
base+0x2000.

Signed-off-by: Hugh Cole-Baker <sigmaris@gmail.com>
---

Changes from v1: no changes in this patch

 arch/arm64/boot/dts/rockchip/rk3399.dtsi | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/arch/arm64/boot/dts/rockchip/rk3399.dtsi b/arch/arm64/boot/dts/rockchip/rk3399.dtsi
index 3871c7fd83b0..9cbf6ccdd256 100644
--- a/arch/arm64/boot/dts/rockchip/rk3399.dtsi
+++ b/arch/arm64/boot/dts/rockchip/rk3399.dtsi
@@ -1619,7 +1619,7 @@ i2s2: i2s@ff8a0000 {
 
 	vopl: vop@ff8f0000 {
 		compatible = "rockchip,rk3399-vop-lit";
-		reg = <0x0 0xff8f0000 0x0 0x3efc>;
+		reg = <0x0 0xff8f0000 0x0 0x2000>, <0x0 0xff8f2000 0x0 0x400>;
 		interrupts = <GIC_SPI 119 IRQ_TYPE_LEVEL_HIGH 0>;
 		assigned-clocks = <&cru ACLK_VOP1>, <&cru HCLK_VOP1>;
 		assigned-clock-rates = <400000000>, <100000000>;
@@ -1676,7 +1676,7 @@ vopl_mmu: iommu@ff8f3f00 {
 
 	vopb: vop@ff900000 {
 		compatible = "rockchip,rk3399-vop-big";
-		reg = <0x0 0xff900000 0x0 0x3efc>;
+		reg = <0x0 0xff900000 0x0 0x2000>, <0x0 0xff902000 0x0 0x1000>;
 		interrupts = <GIC_SPI 118 IRQ_TYPE_LEVEL_HIGH 0>;
 		assigned-clocks = <&cru ACLK_VOP0>, <&cru HCLK_VOP0>;
 		assigned-clock-rates = <400000000>, <100000000>;