From: Heikki Krogerus <heikki.krogerus@linux.intel.com>
To: Gary Yang <gary.yang@cixtech.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>,
Rob Herring <robh@kernel.org>,
Krzysztof Kozlowski <krzk+dt@kernel.org>,
Conor Dooley <conor+dt@kernel.org>,
Fugang Duan <fugang.duan@cixtech.com>,
linux-usb@vger.kernel.org, devicetree@vger.kernel.org,
linux-kernel@vger.kernel.org, cix-kernel-upstream@cixtech.com
Subject: Re: [PATCH v6 2/2] usb: typec: add CIX Type-C PD controller driver
Date: Fri, 20 Nov 2026 15:15:11 +0100 [thread overview]
Message-ID: <awBV78XLu_Z-rd0_@black.igk.intel.com> (raw)
In-Reply-To: <20261118051313.3634833-3-gary.yang@cixtech.com>
On Wed, Nov 18, 2026 at 01:13:13PM +0800, Gary Yang wrote:
> Add a Type-C PD controller driver for CIX platforms. The Realtek
> RTS5453H is the first supported device.
>
> The controller runs the Type-C and PD state machines in its firmware.
> The register addresses are agreed between CIX and the controller vendor
> and are configured into that firmware, so the host interface is not
> specific to the RTS5453H: further register-compatible controllers can be
> supported by the same driver, each with its own compatible string. The
> host reads the decoded port status from the data status register (0x5F)
> and acknowledges port and HPD events through the data control register
> (0x50). The driver translates that into Type-C class notifications and
> drives the platform PHY's orientation switch and mode mux for the
> DisplayPort alternate mode, and the platform USB role switch for the
> negotiated data role.
>
> Signed-off-by: Gary Yang <gary.yang@cixtech.com>
> ---
> MAINTAINERS | 7 +
> drivers/usb/typec/Kconfig | 13 +
> drivers/usb/typec/Makefile | 1 +
> drivers/usb/typec/cix_pd.c | 774 +++++++++++++++++++++++++++++++++++++
> 4 files changed, 795 insertions(+)
> create mode 100644 drivers/usb/typec/cix_pd.c
>
> diff --git a/MAINTAINERS b/MAINTAINERS
> index 93abbb315065..bd99313bf91d 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -6522,6 +6522,13 @@ M: Satish Kharat <satishkh@cisco.com>
> S: Supported
> F: drivers/infiniband/hw/usnic/
>
> +CIX USB TYPE-C PD CONTROLLER
> +M: Gary Yang <gary.yang@cixtech.com>
> +L: linux-usb@vger.kernel.org
> +S: Maintained
> +F: Documentation/devicetree/bindings/usb/realtek,rts5453h.yaml
> +F: drivers/usb/typec/cix_pd.c
> +
> CLANG CONTEXT ANALYSIS
> M: Marco Elver <elver@google.com>
> R: Bart Van Assche <bvanassche@acm.org>
> diff --git a/drivers/usb/typec/Kconfig b/drivers/usb/typec/Kconfig
> index 2f80c2792dbd..4d62f5deeeba 100644
> --- a/drivers/usb/typec/Kconfig
> +++ b/drivers/usb/typec/Kconfig
> @@ -110,6 +110,19 @@ config TYPEC_WUSB3801
> If you choose to build this driver as a dynamically linked module, the
> module will be called wusb3801.ko.
>
> +config TYPEC_CIX_PD
> + tristate "CIX Type-C PD controller driver"
> + depends on I2C
> + depends on USB_ROLE_SWITCH
> + depends on ARCH_CIX || COMPILE_TEST
> + select REGMAP_I2C
> + help
> + Say Y or M here if your system has a CIX Type-C PD controller.
> + This driver currently supports the Realtek RTS5453H controller.
> +
> + If you choose to build this driver as a dynamically linked module, the
> + module will be called cix_pd.ko.
> +
> 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 8a6a1c663eb6..bb3f3139fd7e 100644
> --- a/drivers/usb/typec/Makefile
> +++ b/drivers/usb/typec/Makefile
> @@ -11,4 +11,5 @@ obj-$(CONFIG_TYPEC_HD3SS3220) += hd3ss3220.o
> obj-$(CONFIG_TYPEC_STUSB160X) += stusb160x.o
> obj-$(CONFIG_TYPEC_RT1719) += rt1719.o
> obj-$(CONFIG_TYPEC_WUSB3801) += wusb3801.o
> +obj-$(CONFIG_TYPEC_CIX_PD) += cix_pd.o
> obj-$(CONFIG_TYPEC) += mux/
> diff --git a/drivers/usb/typec/cix_pd.c b/drivers/usb/typec/cix_pd.c
> new file mode 100644
> index 000000000000..4855c04489f9
> --- /dev/null
> +++ b/drivers/usb/typec/cix_pd.c
> @@ -0,0 +1,774 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Copyright 2025 Cix Technology Group Co., Ltd.
> + *
> + * Driver for the CIX Type-C PD controller.
> + */
> +
> +#include <linux/bits.h>
> +#include <linux/device.h>
> +#include <linux/err.h>
> +#include <linux/errno.h>
> +#include <linux/i2c.h>
> +#include <linux/interrupt.h>
> +#include <linux/module.h>
> +#include <linux/of.h>
> +#include <linux/regmap.h>
> +#include <linux/string.h>
> +#include <linux/usb/role.h>
> +#include <linux/usb/typec.h>
> +#include <linux/usb/typec_altmode.h>
> +#include <linux/usb/typec_dp.h>
> +#include <linux/usb/typec_mux.h>
> +
> +#define RTS_DATA_CONTROL 0x50
> +#define I2C_INT_ACK_BIT BIT(2)
> +#define HPD_IRQ_ACK BIT(5)
> +#define RTS_DATA_STATUS 0x5F
> +/* byte 1 */
> +#define CONNECTION_ORIENTATION BIT(1)
> +#define USB2_CONNECTION BIT(4)
> +#define USB3_2_CONNECTION BIT(5)
> +#define USB_DATA_ROLE BIT(7)
> +/* byte 2 */
> +#define DP_CONNECTION BIT(0)
> +#define DP_SOURCE_SINK BIT(1)
> +#define DEBUG_ACCESSORY_ATTACHED BIT(4)
> +#define HPD_IRQ BIT(6)
> +#define HPD_STATE BIT(7)
> +/* byte 3 */
> +#define POWER_SOURCE BIT(0)
> +#define POWER_SINK BIT(1)
> +#define POWER_MASK 3
> +
> +#define DATA_STATUS_COUNT 6
Please align those definitions properly.
Sorry, I failed to notice this, and a few other things below in v5.
> +struct cix_pd {
> + struct device *dev;
> + struct regmap *regmap;
> + struct mutex lock; /* device lock */
> + int id;
> + u8 data_status[DATA_STATUS_COUNT];
> + u8 prev_status[DATA_STATUS_COUNT];
> + bool status_valid;
> + struct typec_displayport_data dp_data;
> + struct typec_mux_state state;
> + struct typec_capability caps;
> + struct typec_mux *mux;
> + struct usb_role_switch *role_sw;
> + struct typec_altmode *port_altmode;
> + struct typec_altmode *partner_altmode;
> + struct typec_port *port;
> + enum usb_role role;
> + enum typec_orientation orientation;
> + unsigned long mode;
> + u32 hpd_status;
> + struct typec_partner *partner;
> + struct typec_partner_desc desc;
> +};
> +
> +static int cix_pd_block_read(struct cix_pd *rts, u8 reg, void *val, size_t len)
> +{
> + return regmap_bulk_read(rts->regmap, reg, val, len);
> +}
> +
> +static int cix_pd_block_write(struct cix_pd *rts, u8 reg,
> + const void *val, size_t len)
> +{
> + return regmap_bulk_write(rts->regmap, reg, val, len);
> +}
> +
> +static const struct regmap_config cix_pd_regmap_config = {
> + .reg_bits = 8,
> + .val_bits = 8,
> + .max_register = 0x7F,
> +};
> +
> +static const char *const dp_only_mode = "Alt Mode:DP";
> +static const char *const dp_usb_mode = "Alt Mode:DP + USB";
> +static const char *const usb_mode = "Alt Mode:USB";
> +
> +static const char *const power_source = "power source";
> +static const char *const power_sink = "power sink";
> +
> +static const char *const orientation_normal = "orientation normal";
> +static const char *const orientation_reverse = "orientation reverse";
> +
> +static const char *const data_host = "usb host";
> +static const char *const data_device = "usb device";
> +
> +static const char *cix_pd_pwr_role_str(const struct cix_pd *rts)
> +{
> + switch (rts->data_status[3] & POWER_MASK) {
> + case POWER_SOURCE:
> + return power_source;
> + case POWER_SINK:
> + return power_sink;
> + default:
> + return "unknown";
> + }
> +}
> +
> +/*
> + * The controller negotiates the DisplayPort alternate mode autonomously,
> + * so the capabilities below describe the fixed set supported by the
> + * platform DP output: a receptacle exposing DFP_D with pin assignments
> + * C, D and E.
> + */
> +#define CIX_PD_DP_PIN_ASSIGN (BIT(DP_PIN_ASSIGN_C) | BIT(DP_PIN_ASSIGN_D) | \
> + BIT(DP_PIN_ASSIGN_E))
> +
> +static const struct typec_altmode_desc cix_pd_dp_port_altmode = {
> + .svid = USB_TYPEC_DP_SID,
> + .mode = USB_TYPEC_DP_MODE,
> + .vdo = DP_CAP_DFP_D | DP_CAP_RECEPTACLE |
> + (CIX_PD_DP_PIN_ASSIGN << 8),
> +};
> +
> +static const struct typec_altmode_desc cix_pd_dp_partner_altmode = {
> + .svid = USB_TYPEC_DP_SID,
> + .mode = USB_TYPEC_DP_MODE,
> + .vdo = DP_CAP_UFP_D | DP_CAP_RECEPTACLE |
> + (CIX_PD_DP_PIN_ASSIGN << 16),
> + .mode_selection = true,
> +};
> +
> +/*
> + * typec_altmode_update_active() takes a reference to the alternate mode
> + * driver's module when the mode is activated and drops it when the mode is
> + * deactivated, but only while a driver is bound. Report the mode as active
> + * only after a driver has bound: activating it earlier would make the later
> + * deactivation drop a reference that was never taken. The port state, which
> + * is what drives the DisplayPort output on this platform, is programmed
> + * through the mux regardless.
> + *
> + * The mode device lock keeps the check consistent with driver binding and
> + * with typec_remove(), which reports the mode inactive when a driver
> + * unbinds.
> + */
> +static void cix_pd_altmode_set_active(struct cix_pd *typec, bool active)
> +{
> + struct typec_altmode *alt = typec->partner_altmode;
> + struct device *alt_dev;
> +
> + if (!alt)
> + return;
> +
> + alt_dev = &alt->dev;
> + device_lock(alt_dev);
> + if (!active || device_is_bound(alt_dev))
> + typec_altmode_update_active(alt, active);
> + device_unlock(alt_dev);
> +}
> +
> +static int cix_pd_typec_port_update(struct cix_pd *typec, bool force)
> +{
> + struct typec_displayport_data *dp_data = &typec->dp_data;
> + enum typec_orientation orientation;
> + enum usb_role role;
> + bool usb2, usb3, dp, connected, dev_role;
> + int ret, err;
> +
> + usb2 = typec->data_status[1] & USB2_CONNECTION;
> + usb3 = typec->data_status[1] & USB3_2_CONNECTION;
> + dp = typec->data_status[2] & DP_CONNECTION;
> +
> + /*
> + * Debug accessories are not supported, so they are reported as
> + * disconnected instead of being passed on to the framework.
> + */
> + if (typec->data_status[2] & DEBUG_ACCESSORY_ATTACHED) {
> + dev_err(typec->dev,
> + "debug accessory mode not supported, try another usb cable\n");
> + connected = false;
> + } else {
> + connected = usb2 || usb3 || dp;
> + }
> +
> + if (!connected)
> + orientation = TYPEC_ORIENTATION_NONE;
> + else if (typec->data_status[1] & CONNECTION_ORIENTATION)
> + orientation = TYPEC_ORIENTATION_REVERSE;
> + else
> + orientation = TYPEC_ORIENTATION_NORMAL;
> +
> + /*
> + * The controller keeps reporting the same orientation when a sibling
> + * port raises the shared interrupt, and the Type-C class emits an
> + * event for every call, so the switch is only programmed again when
> + * the orientation changed or after system resume.
> + */
> + if (force || typec->orientation != orientation) {
> + ret = typec_set_orientation(typec->port, orientation);
> + if (ret)
> + return ret;
> + typec->orientation = orientation;
> + }
> +
> + /*
> + * The controller reports the data role whenever a cable is attached,
> + * including DisplayPort-only configurations where no USB data role is
> + * available. Keep the port's data role in sync independently of the
> + * USB role switch.
> + */
> + dev_role = typec->data_status[1] & USB_DATA_ROLE;
> + if (connected)
> + typec_set_data_role(typec->port,
> + dev_role ? TYPEC_DEVICE : TYPEC_HOST);
> +
> + if (!connected || !(usb2 || usb3))
> + role = USB_ROLE_NONE;
> + else if (dev_role)
> + role = USB_ROLE_DEVICE;
> + else
> + role = USB_ROLE_HOST;
> +
> + if (force || typec->role != role) {
> + err = 0;
> + if (typec->role_sw) {
> + err = usb_role_switch_set_role(typec->role_sw, role);
> + if (err)
> + dev_err(typec->dev,
> + "typec port(%d): failed to set USB role: %d\n",
> + typec->id, err);
> + }
> +
> + /* Only cache the role once the switch accepted it. */
> + if (!err)
> + typec->role = role;
> + }
> +
> + if ((typec->data_status[3] & POWER_MASK) == POWER_SOURCE) {
> + typec_set_pwr_role(typec->port, TYPEC_SOURCE);
> + } else if ((typec->data_status[3] & POWER_MASK) == POWER_SINK) {
> + typec_set_pwr_role(typec->port, TYPEC_SINK);
> + } else {
> + dev_dbg(typec->dev, "typec port(%d): unknown power state %d\n",
> + typec->id, typec->data_status[3]);
> + }
> +
> + if (!connected) {
> + if (typec->partner_altmode) {
> + cix_pd_altmode_set_active(typec, false);
> + typec_unregister_altmode(typec->partner_altmode);
> + typec->partner_altmode = NULL;
> + }
> + if (typec->partner) {
> + typec_unregister_partner(typec->partner);
> + typec->partner = NULL;
> + }
> + } else {
> + if (!typec->partner) {
> + typec->partner = typec_register_partner(typec->port,
> + &typec->desc);
> + if (IS_ERR(typec->partner)) {
> + dev_err(typec->dev,
> + "typec port(%d): failed to register partner: %ld\n",
> + typec->id, PTR_ERR(typec->partner));
> + typec->partner = NULL;
> + }
> + }
> +
> + if (typec->partner_altmode && !dp) {
> + cix_pd_altmode_set_active(typec, false);
> + typec_unregister_altmode(typec->partner_altmode);
> + typec->partner_altmode = NULL;
> + }
> +
> + if (typec->partner && dp && !typec->partner_altmode) {
> + typec->partner_altmode =
> + typec_partner_register_altmode(typec->partner,
> + &cix_pd_dp_partner_altmode);
> + if (IS_ERR(typec->partner_altmode)) {
> + dev_err(typec->dev,
> + "typec port(%d): failed to register DP altmode: %ld\n",
> + typec->id,
> + PTR_ERR(typec->partner_altmode));
> + typec->partner_altmode = NULL;
> + }
> + }
> +
> + if (typec->partner_altmode)
> + cix_pd_altmode_set_active(typec, true);
> + }
> +
> + dp_data->status = 0;
> + typec->state.data = NULL;
> + typec->state.alt = NULL;
> +
> + /*
> + * Only pass a DisplayPort state to the mux when the partner's
> + * alternate mode was registered successfully.
> + */
> + if (connected && dp && typec->partner_altmode) {
> + dp_data->status = DP_STATUS_ENABLED;
> + if (typec->data_status[2] & HPD_STATE)
> + dp_data->status |= DP_STATUS_HPD_STATE;
> + if (typec->data_status[2] & HPD_IRQ)
> + dp_data->status |= DP_STATUS_IRQ_HPD;
> +
> + typec->state.data = dp_data;
> + typec->state.alt = typec->port_altmode;
> + typec->state.mode = usb3 ? TYPEC_DP_STATE_D :
> + TYPEC_DP_STATE_E;
> + } else if (connected && (usb2 || usb3)) {
> + typec->state.mode = TYPEC_STATE_USB;
> + } else {
> + typec->state.mode = TYPEC_STATE_SAFE;
> + }
> +
> + ret = typec_mux_set(typec->mux, &typec->state);
> + if (ret)
> + return ret;
> +
> + if (typec->mode == typec->state.mode &&
> + typec->hpd_status == dp_data->status)
> + return 0;
> +
> + if (typec->state.mode == TYPEC_DP_STATE_D)
> + dev_dbg(typec->dev,
> + "typec port(%d): alt mode(%s) orientation(%s), usb_data_role(%s), power role(%s), hpd_state(%d)\n",
> + typec->id, dp_usb_mode,
> + orientation == TYPEC_ORIENTATION_REVERSE ?
> + orientation_reverse : orientation_normal,
> + role == USB_ROLE_DEVICE ? data_device : data_host,
> + cix_pd_pwr_role_str(typec),
> + (int)(dp_data->status & DP_STATUS_HPD_STATE));
> + else if (typec->state.mode == TYPEC_DP_STATE_E)
> + dev_dbg(typec->dev,
> + "typec port(%d): alt mode(%s) orientation(%s), power role(%s), hpd_state(%d)\n",
> + typec->id, dp_only_mode,
> + orientation == TYPEC_ORIENTATION_REVERSE ?
> + orientation_reverse : orientation_normal,
> + cix_pd_pwr_role_str(typec),
> + (int)(dp_data->status & DP_STATUS_HPD_STATE));
> + else if (typec->state.mode == TYPEC_STATE_USB)
> + dev_dbg(typec->dev,
> + "typec port(%d): alt mode(%s) orientation(%s), power role(%s), usb_data_role(%s)\n",
> + typec->id, usb_mode,
> + orientation == TYPEC_ORIENTATION_REVERSE ?
> + orientation_reverse : orientation_normal,
> + cix_pd_pwr_role_str(typec),
> + role == USB_ROLE_DEVICE ? data_device : data_host);
> + else if (typec->state.mode == TYPEC_STATE_SAFE)
> + dev_dbg(typec->dev, "typec port(%d): disconnect state\n",
> + typec->id);
> +
> + typec->mode = typec->state.mode;
> + typec->hpd_status = dp_data->status;
> +
> + return 0;
> +}
> +
> +static void cix_pd_typec_init_state(struct cix_pd *typec)
> +{
> + typec->state.alt = NULL;
> + typec->state.mode = TYPEC_STATE_SAFE;
> + typec->state.data = NULL;
> + typec->partner = NULL;
> + typec->desc.accessory = TYPEC_ACCESSORY_NONE;
> + /*
> + * The data status registers only report the source/sink state, not
> + * whether USB PD is being used, so the partner is not advertised as
> + * PD capable.
> + */
> + typec->desc.usb_pd = 0;
> +}
> +
> +/*
> + * Returns 1 when the reported port state changed or an HPD interrupt was
> + * handled, 0 when there was nothing to report, and a negative error code when
> + * the controller could not be accessed.
> + */
> +static int cix_pd_event_handler(struct cix_pd *rts, bool clear_irq, bool force)
> +{
> + int ret, err = 0;
> + bool hpd_irq, changed;
> + u8 data_control[3] = {0};
> +
> + mutex_lock(&rts->lock);
guard(mutex)(&arts->lock)
> + if (clear_irq) {
> + data_control[0] = 2;
> + data_control[1] = I2C_INT_ACK_BIT;
> + data_control[2] = 0;
> +
> + ret = cix_pd_block_write(rts, RTS_DATA_CONTROL, data_control, 3);
> + if (ret)
> + goto i2c_err;
> + }
> +
> + ret = cix_pd_block_read(rts, RTS_DATA_STATUS, rts->data_status, 6);
> + if (ret)
> + goto i2c_err;
> +
> + dev_dbg(rts->dev,
> + "typec port(%d): data status = 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n",
> + rts->id, rts->data_status[0], rts->data_status[1],
> + rts->data_status[2], rts->data_status[3], rts->data_status[4],
> + rts->data_status[5]);
> +
> + hpd_irq = rts->data_status[2] & HPD_IRQ;
> +
> + /*
> + * HPD_IRQ is an event bit which stays set until it is acknowledged
> + * below, so it is excluded from the comparison: the acknowledged
> + * status would otherwise look different on the next read. Byte 0 and
> + * bytes 4..5 are not decoded, so a change in them is not a port
> + * event either.
> + */
> + changed = !rts->status_valid ||
> + rts->data_status[1] != rts->prev_status[1] ||
> + (rts->data_status[2] & ~HPD_IRQ) !=
> + (rts->prev_status[2] & ~HPD_IRQ) ||
> + rts->data_status[3] != rts->prev_status[3];
> +
> + memcpy(rts->prev_status, rts->data_status, DATA_STATUS_COUNT);
> + rts->status_valid = true;
> +
> + /*
> + * Reprogram the port only when one of the decoded bits changed, when
> + * an HPD interrupt arrived, or when the caller forces a refresh after
> + * system resume. The ports share one interrupt line, so a sibling's
> + * interrupt must not re-report an unchanged orientation and power
> + * role to the Type-C class.
> + */
> + if (changed || hpd_irq || force) {
> + err = cix_pd_typec_port_update(rts, force);
> + if (err) {
> + /*
> + * Invalidate the cached status so that the update is
> + * retried on the next interrupt or on system resume
> + * instead of being lost with the acknowledged event.
> + */
> + rts->status_valid = false;
> + dev_err(rts->dev,
> + "typec port(%d): failed to update port: %d\n",
> + rts->id, err);
> + }
> + }
> +
> + if (hpd_irq) {
> + data_control[0] = 2;
> + data_control[1] = 0;
> + data_control[2] = HPD_IRQ_ACK;
> + ret = cix_pd_block_write(rts, RTS_DATA_CONTROL, data_control, 3);
> + if (ret)
> + goto i2c_err;
> + }
> +
> + mutex_unlock(&rts->lock);
> + return (changed || hpd_irq) ? 1 : 0;
> +
> +i2c_err:
> + /*
> + * Report the controller as unresponsive so the IRQ handler can tell
> + * the interrupt core that this instance did not handle the event.
> + */
> + dev_err(rts->dev, "typec port(%d): i2c transfer error = %d\n",
> + rts->id, ret);
> + mutex_unlock(&rts->lock);
> + return -ESHUTDOWN;
Why not return ret?
> +}
> +
> +static int cix_pd_typec_parse_port_props(struct typec_capability *cap,
> + struct fwnode_handle *fwnode,
> + struct device *dev)
> +{
> + int ret;
> +
> + memset(cap, 0, sizeof(*cap));
> + ret = typec_get_fw_cap(cap, fwnode);
> + if (ret) {
> + /*
> + * typec_get_fw_cap() stores a borrowed reference without
> + * taking it, so it must not be dropped by the caller.
> + */
> + cap->fwnode = NULL;
> + return dev_err_probe(dev, ret,
> + "failed to parse connector properties\n");
> + }
> +
> + cap->fwnode = fwnode_handle_get(fwnode);
> + cap->orientation_aware = true;
> + /* Alternate modes are entered and exited by the controller firmware. */
> + cap->no_mode_control = true;
> +
> + return 0;
> +}
> +
> +static int cix_pd_typec_get_handles(struct cix_pd *typec,
> + struct fwnode_handle *fwnode,
> + struct device *dev)
> +{
> + int ret;
> +
> + typec->mux = fwnode_typec_mux_get(fwnode);
> + if (IS_ERR(typec->mux))
> + return dev_err_probe(dev, PTR_ERR(typec->mux),
> + "failed to get mux\n");
> +
> + typec->role_sw = fwnode_usb_role_switch_get(fwnode);
> + if (IS_ERR(typec->role_sw)) {
> + ret = PTR_ERR(typec->role_sw);
> + typec->role_sw = NULL;
> + typec_mux_put(typec->mux);
> + typec->mux = NULL;
> + return dev_err_probe(dev, ret,
> + "failed to get USB role switch\n");
> + }
> +
> + if (!typec->mux)
> + dev_dbg(dev, "mux not found\n");
> +
> + return 0;
> +}
> +
> +static void cix_pd_unregister_ports(struct cix_pd *typec)
> +{
> + if (!IS_ERR_OR_NULL(typec->port)) {
> + typec->state.alt = NULL;
> + typec->state.mode = TYPEC_STATE_SAFE;
> + typec->state.data = NULL;
> + usb_role_switch_set_role(typec->role_sw, USB_ROLE_NONE);
> + typec_set_orientation(typec->port, TYPEC_ORIENTATION_NONE);
> + typec_mux_set(typec->mux, &typec->state);
> +
> + if (typec->partner_altmode)
> + cix_pd_altmode_set_active(typec, false);
> + typec_unregister_altmode(typec->partner_altmode);
> + typec->partner_altmode = NULL;
> + typec_unregister_partner(typec->partner);
> + typec->partner = NULL;
> + typec_unregister_altmode(typec->port_altmode);
> + typec->port_altmode = NULL;
> +
> + typec_unregister_port(typec->port);
> + typec->port = NULL;
> + }
> +
> + usb_role_switch_put(typec->role_sw);
> + typec->role_sw = NULL;
> + typec_mux_put(typec->mux);
> + typec->mux = NULL;
> + fwnode_handle_put(typec->caps.fwnode);
> + typec->caps.fwnode = NULL;
> +}
> +
> +static irqreturn_t cix_pd_irq_handle(int irq, void *data)
> +{
> + struct cix_pd *rts = data;
> + int ret;
> +
> + /*
> + * The Type-C ports of this platform are wired to one shared,
> + * level-triggered interrupt line and the controller has no
> + * per-instance pending bit, so the interrupt is attributed by
> + * comparing the port status with the previously reported one. The
> + * controller interrupt is acknowledged in any case, but an unchanged
> + * status is reported as IRQ_NONE: if a sibling keeps the shared line
> + * asserted without ever clearing its interrupt, the spurious
> + * interrupt detector can then eventually disable the line instead of
> + * leaving the system in an interrupt storm.
> + */
> + ret = cix_pd_event_handler(rts, true, false);
> + return ret > 0 ? IRQ_HANDLED : IRQ_NONE;
> +}
> +
> +static int cix_pd_init_ports(struct cix_pd *typec)
> +{
> + struct device *dev = typec->dev;
> + struct typec_altmode_desc desc = cix_pd_dp_port_altmode;
> + struct fwnode_handle *fwnode;
> + int ret;
> +
> + fwnode = device_get_named_child_node(dev, "connector");
> + if (!fwnode)
> + return dev_err_probe(dev, -ENODEV, "no connector node found\n");
> +
> + ret = cix_pd_typec_get_handles(typec, fwnode, dev);
> + if (ret)
> + goto out_put_fwnode;
> +
> + ret = cix_pd_typec_parse_port_props(&typec->caps, fwnode, dev);
> + if (ret)
> + goto out_unregister_ports;
> +
> + typec->port = typec_register_port(dev, &typec->caps);
> + if (IS_ERR(typec->port)) {
> + ret = PTR_ERR(typec->port);
> + typec->port = NULL;
> + dev_err_probe(dev, ret, "failed to register port\n");
> + goto out_unregister_ports;
> + }
> +
> + desc.roles = typec->caps.data;
> + typec->port_altmode = typec_port_register_altmode(typec->port, &desc);
> + if (IS_ERR(typec->port_altmode)) {
> + ret = PTR_ERR(typec->port_altmode);
> + typec->port_altmode = NULL;
> + dev_err_probe(dev, ret, "failed to register DP altmode\n");
> + goto out_unregister_ports;
> + }
> +
> + fwnode_handle_put(fwnode);
> +
> + return 0;
> +
> +out_unregister_ports:
> + cix_pd_unregister_ports(typec);
> +out_put_fwnode:
> + fwnode_handle_put(fwnode);
> + return ret;
> +}
> +
> +static int cix_pd_probe(struct i2c_client *client)
> +{
> + struct cix_pd *rts;
> + int ret;
> +
> + rts = devm_kzalloc(&client->dev, sizeof(*rts), GFP_KERNEL);
> + if (!rts)
> + return -ENOMEM;
> +
> + rts->dev = &client->dev;
> + mutex_init(&rts->lock);
> + cix_pd_typec_init_state(rts);
> +
> + if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
> + return dev_err_probe(&client->dev, -ENODEV,
> + "i2c check functionality failed\n");
> +
> + rts->regmap = devm_regmap_init_i2c(client, &cix_pd_regmap_config);
> + if (IS_ERR(rts->regmap))
> + return dev_err_probe(&client->dev, PTR_ERR(rts->regmap),
> + "failed to init regmap\n");
> +
> + i2c_set_clientdata(client, rts);
> + rts->id = client->addr;
> +
> + ret = cix_pd_init_ports(rts);
> + if (ret)
> + return ret;
> +
> + /*
> + * Acknowledge any interrupt the controller raised before the IRQ was
> + * requested, so the shared line is not left asserted by this instance,
> + * and program the port state once so that the switch and the mux are
> + * in a known state even when no cable is attached.
> + */
> + ret = cix_pd_event_handler(rts, true, true);
> + if (ret < 0) {
> + dev_err(&client->dev, "failed to read initial status: %d\n", ret);
> + if (ret == -ESHUTDOWN)
> + ret = -EIO;
I don't think ret can now be anything else but -ESHUTDOWN here, right?
If so, the condition is not necessary.
> + goto err_unregister_ports;
> + }
> +
> + if (client->irq > 0) {
> + ret = request_threaded_irq(client->irq, NULL, cix_pd_irq_handle,
> + IRQF_SHARED | IRQF_ONESHOT,
> + dev_name(&client->dev), rts);
> + if (ret) {
> + dev_err(&client->dev, "failed to request irq: %d\n", ret);
> + goto err_unregister_ports;
> + }
> + }
> +
> + return 0;
> +
> +err_unregister_ports:
> + cix_pd_unregister_ports(rts);
> + return ret;
> +}
> +
> +static void cix_pd_remove(struct i2c_client *client)
> +{
> + struct cix_pd *rts = i2c_get_clientdata(client);
> +
> + if (client->irq > 0)
> + free_irq(client->irq, rts);
> +
> + cix_pd_unregister_ports(rts);
> +}
> +
> +static const struct of_device_id cix_pd_of_match[] = {
> + { .compatible = "realtek,rts5453h", },
> + {}
> +};
> +MODULE_DEVICE_TABLE(of, cix_pd_of_match);
> +
> +static const struct i2c_device_id cix_pd_id[] = {
> + { .name = "rts5453h" },
> + {}
> +};
> +MODULE_DEVICE_TABLE(i2c, cix_pd_id);
> +
> +static int __maybe_unused cix_pd_suspend(struct device *dev)
> +{
> + struct i2c_client *client = to_i2c_client(dev);
> +
> + /*
> + * The controller is not accessible once the parent I2C adapter is
> + * suspended, so keep the interrupt masked for the whole sleep. The line
> + * is level-triggered and shared by the ports: left enabled, a cable
> + * event would loop in the handler, which could not acknowledge the
> + * controller before ->resume(). The parent adapter is still alive here
> + * because children are suspended first, so disable_irq() can safely
> + * wait for an in-flight handler to finish.
> + */
> + if (client->irq > 0)
> + disable_irq(client->irq);
> +
> + return 0;
> +}
> +
> +static int __maybe_unused cix_pd_resume(struct device *dev)
> +{
> + struct i2c_client *client = to_i2c_client(dev);
> + struct cix_pd *rts = i2c_get_clientdata(client);
> + int ret;
> +
> + /*
> + * Read the status the controller kept while the system was asleep and
> + * acknowledge it. The parent I2C adapter is always resumed before this
> + * device, and the interrupt is still masked.
> + */
> + ret = cix_pd_event_handler(rts, true, true);
> +
> + if (client->irq > 0)
> + enable_irq(client->irq);
> +
> + if (ret < 0) {
> + dev_err(dev, "failed to refresh status: %d\n", ret);
> + return ret == -ESHUTDOWN ? -EIO : ret;
Ditto.
> + }
> +
> + return 0;
> +}
> +
> +static const struct dev_pm_ops cix_pd_pm_ops = {
> + .suspend = pm_sleep_ptr(cix_pd_suspend),
> + .resume = pm_sleep_ptr(cix_pd_resume),
> + .freeze = pm_sleep_ptr(cix_pd_suspend),
> + .thaw = pm_sleep_ptr(cix_pd_resume),
> + .poweroff = pm_sleep_ptr(cix_pd_suspend),
> + .restore = pm_sleep_ptr(cix_pd_resume),
> +};
> +
> +static struct i2c_driver cix_pd_i2c_driver = {
> + .driver = {
> + .name = "rts5453h",
> + .of_match_table = cix_pd_of_match,
> + .pm = pm_ptr(&cix_pd_pm_ops),
> + },
> + .id_table = cix_pd_id,
> + .probe = cix_pd_probe,
> + .remove = cix_pd_remove,
> +};
> +
> +module_i2c_driver(cix_pd_i2c_driver);
> +MODULE_DESCRIPTION("CIX Type-C PD controller driver");
> +MODULE_AUTHOR("Chao Zeng <Chao.Zeng@cixtech.com>");
> +MODULE_AUTHOR("Gary Yang <gary.yang@cixtech.com>");
> +MODULE_LICENSE("GPL");
> --
> 2.50.1
--
heikki
prev parent reply other threads:[~2026-11-20 14:15 UTC|newest]
Thread overview: 4+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-18 5:13 [PATCH v6 0/2] usb: typec: add CIX Type-C PD controller driver Gary Yang
2026-11-18 5:13 ` [PATCH v6 1/2] dt-bindings: usb: add Realtek RTS5453H Type-C port controller Gary Yang
2026-11-18 5:13 ` [PATCH v6 2/2] usb: typec: add CIX Type-C PD controller driver Gary Yang
2026-11-20 14:15 ` Heikki Krogerus [this message]
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=awBV78XLu_Z-rd0_@black.igk.intel.com \
--to=heikki.krogerus@linux.intel.com \
--cc=cix-kernel-upstream@cixtech.com \
--cc=conor+dt@kernel.org \
--cc=devicetree@vger.kernel.org \
--cc=fugang.duan@cixtech.com \
--cc=gary.yang@cixtech.com \
--cc=gregkh@linuxfoundation.org \
--cc=krzk+dt@kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-usb@vger.kernel.org \
--cc=robh@kernel.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox