From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.16]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B8075480342; Tue, 21 Jul 2026 10:27:19 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=198.175.65.16 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784629642; cv=none; b=WOT+SUk9mbnAlgLDwsqeH/gEJja+uyng2T7M0v7rTtGmQkXynde7iCtgBHHmlTXr25fNSdfEiMcIYVABKXSdjzj5nb/F0T1sVSnkLSdSpucGEHtR3yEHf/76GoDGJEDiZQIUPSEbHPxLzN/cclaoUUQKMuOUgGpwKfAbEqHc8aQ= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784629642; c=relaxed/simple; bh=HMOU6A/c3kOw1PrqIyXoVZMeAqTKUWE0C7TNkqCK7EQ=; h=Date:From:To:Cc:Subject:Message-ID:References:MIME-Version: Content-Type:Content-Disposition:In-Reply-To; b=WhbodZUaeSjrQ6sDzJnKdsrObG8lXVbSXCuoqsB5S0i6ld3ZucSyjWixsHKOmCFmwBIpUkY9CBhzWhbs78+AiBVT8s8M6GkbLNyCgXrCxrrfd14bWQ0aqZGVOjrpAWpPktjqK5n9qbTWyELW++208aUvxVSjWrwtRAmPtdoezb4= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.intel.com; spf=pass smtp.mailfrom=intel.com; dkim=pass (2048-bit key) header.d=intel.com header.i=@intel.com header.b=b0s2x/c2; arc=none smtp.client-ip=198.175.65.16 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.intel.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=intel.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=intel.com header.i=@intel.com header.b="b0s2x/c2" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1784629640; x=1816165640; h=date:from:to:cc:subject:message-id:references: mime-version:in-reply-to; bh=HMOU6A/c3kOw1PrqIyXoVZMeAqTKUWE0C7TNkqCK7EQ=; b=b0s2x/c2hEeUkPQgDM52An46qUPG65xELGQK2i0hkTRzK7/8Q99PrV6+ hYGb9OGLCUMNXIl0eetCGlBLq4cIwXpv1DunuA4WktgO+vqjPRROHrM6i ozxrRAasyjOiAUrXZEDOOS7Loaympy24Q9OAvB36LIWKVxb/Y8TJNNx7s sKyWcCnP/kpOonNYKQKA0qsbWdbpUZM4f9L6Xz0VAQPG71y1gz75cjyp8 rC2kzxPnMEMJsi7cW5I2/uUmA3T3TziZ/QZwQT2viVEoTTZwU4yLXIIgw expt07Jr4SORdHD75zKMrXg3ncMoEk41MH2xB4PK6OxMs0Fd7p1iJV0js w==; X-CSE-ConnectionGUID: f5RhuTrlRwCma7aYz55JRg== X-CSE-MsgGUID: JyPZfrS7Sc2T3A0jH1xcPA== X-IronPort-AV: E=McAfee;i="6800,10657,11852"; a="85424207" X-IronPort-AV: E=Sophos;i="6.25,176,1779174000"; d="scan'208";a="85424207" Received: from fmviesa007.fm.intel.com ([10.60.135.147]) by orvoesa108.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 21 Jul 2026 03:27:19 -0700 X-CSE-ConnectionGUID: 5caZlWW2Qi+675Wx5TzAMA== X-CSE-MsgGUID: 3Yu9rMkaQmuXdbmAm2mwsw== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.25,176,1779174000"; d="scan'208";a="254321819" Received: from black.igk.intel.com ([10.91.253.5]) by fmviesa007.fm.intel.com with ESMTP; 21 Jul 2026 03:27:16 -0700 Received: by black.igk.intel.com (Postfix, from userid 1008) id EEC8595; Tue, 21 Jul 2026 12:27:14 +0200 (CEST) Date: Tue, 21 Jul 2026 13:27:13 +0300 From: Heikki Krogerus To: Hongyang Zhao Cc: Greg Kroah-Hartman , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Liam Girdwood , Mark Brown , Roger Shimizu , linux-usb@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org Subject: Re: [PATCH 2/3] usb: typec: Add Hynetek HUSB320 Type-C controller driver Message-ID: References: <20260720-husb320-v1-0-4a1e259d7dc8@163.com> <20260720-husb320-v1-2-4a1e259d7dc8@163.com> Precedence: bulk X-Mailing-List: devicetree@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20260720-husb320-v1-2-4a1e259d7dc8@163.com> On Mon, Jul 20, 2026 at 04:17:12PM +0800, Hongyang Zhao wrote: > The HUSB320 is an autonomous Configuration Channel controller which > supports fixed source or sink operation and dual-role ports without USB > Power Delivery. > > Add a Type-C class driver for attach and detach detection, orientation > and Rp current reporting, platform VBUS control, USB role switching, > Try.SRC and Try.SNK, and audio and debug accessories. > > Signed-off-by: Hongyang Zhao Acked-by: Heikki Krogerus > --- > drivers/usb/typec/Kconfig | 12 + > drivers/usb/typec/Makefile | 1 + > drivers/usb/typec/husb320.c | 1177 +++++++++++++++++++++++++++++++++++++++++++ > 3 files changed, 1190 insertions(+) > > diff --git a/drivers/usb/typec/Kconfig b/drivers/usb/typec/Kconfig > index 2f80c2792dbd..22ef8bacacf7 100644 > --- a/drivers/usb/typec/Kconfig > +++ b/drivers/usb/typec/Kconfig > @@ -88,6 +88,18 @@ config TYPEC_HD3SS3220 > If you choose to build this driver as a dynamically linked module, the > module will be called hd3ss3220.ko. > > +config TYPEC_HUSB320 > + tristate "Hynetek HUSB320 Type-C controller driver" > + depends on I2C > + depends on USB_ROLE_SWITCH || !USB_ROLE_SWITCH > + select REGMAP_I2C > + help > + Say Y or M here if your system has a Hynetek HUSB320 autonomous > + USB Type-C controller. > + > + If you choose to build this driver as a dynamically linked module, the > + module will be called husb320.ko. > + > config TYPEC_STUSB160X > tristate "STMicroelectronics STUSB160x Type-C controller driver" > depends on USB_ROLE_SWITCH || !USB_ROLE_SWITCH > diff --git a/drivers/usb/typec/Makefile b/drivers/usb/typec/Makefile > index 8a6a1c663eb6..1b61c34d6e66 100644 > --- a/drivers/usb/typec/Makefile > +++ b/drivers/usb/typec/Makefile > @@ -8,6 +8,7 @@ obj-$(CONFIG_TYPEC_UCSI) += ucsi/ > obj-$(CONFIG_TYPEC_TPS6598X) += tipd/ > obj-$(CONFIG_TYPEC_ANX7411) += anx7411.o > obj-$(CONFIG_TYPEC_HD3SS3220) += hd3ss3220.o > +obj-$(CONFIG_TYPEC_HUSB320) += husb320.o > obj-$(CONFIG_TYPEC_STUSB160X) += stusb160x.o > obj-$(CONFIG_TYPEC_RT1719) += rt1719.o > obj-$(CONFIG_TYPEC_WUSB3801) += wusb3801.o > diff --git a/drivers/usb/typec/husb320.c b/drivers/usb/typec/husb320.c > new file mode 100644 > index 000000000000..fd9f949d9b52 > --- /dev/null > +++ b/drivers/usb/typec/husb320.c > @@ -0,0 +1,1177 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* > + * Hynetek HUSB320 USB Type-C controller driver > + * > + * Copyright (C) 2026 Hongyang Zhao > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#define HUSB320_REG_DEVICE_ID 0x01 > +#define HUSB320_REG_DEVICE_TYPE 0x02 > +#define HUSB320_REG_PORT_ROLE 0x03 > +#define HUSB320_REG_CONTROL 0x04 > +#define HUSB320_REG_CONTROL1 0x05 > +#define HUSB320_REG_MANUAL 0x09 > +#define HUSB320_REG_RESET 0x0a > +#define HUSB320_REG_MASK 0x0e > +#define HUSB320_REG_MASK1 0x0f > +#define HUSB320_REG_STATUS 0x11 > +#define HUSB320_REG_TYPE 0x13 > +#define HUSB320_REG_INTERRUPT 0x14 > +#define HUSB320_REG_INTERRUPT1 0x15 > + > +#define HUSB320_DEVICE_ID_VERSION GENMASK(7, 4) > +#define HUSB320_DEVICE_ID_REVISION GENMASK(3, 0) > +#define HUSB320_DEVICE_ID_VERSION_1 1 > +#define HUSB320_DEVICE_TYPE 0x03 > + > +#define HUSB320_PORT_ROLE_TRY GENMASK(5, 4) > +#define HUSB320_PORT_ROLE_MODE GENMASK(2, 0) > +#define HUSB320_PORT_ROLE_SOURCE BIT(0) > +#define HUSB320_PORT_ROLE_SINK BIT(1) > +#define HUSB320_PORT_ROLE_DRP BIT(2) > +#define HUSB320_TRY_NONE 0 > +#define HUSB320_TRY_SINK 1 > +#define HUSB320_TRY_SOURCE 2 > + > +#define HUSB320_CONTROL_HOST_CURRENT GENMASK(2, 1) > +#define HUSB320_CONTROL_INT_MASK BIT(0) > +#define HUSB320_HOST_CURRENT_DEFAULT 1 > +#define HUSB320_HOST_CURRENT_1_5A 2 > +#define HUSB320_HOST_CURRENT_3_0A 3 > + > +#define HUSB320_CONTROL1_ENABLE BIT(3) > + > +#define HUSB320_MANUAL_ERROR_RECOVERY BIT(0) > + > +#define HUSB320_RESET_SW BIT(0) > + > +/* The datasheet defines the fault mask, but reserves the matching IRQ bit. */ > +#define HUSB320_MASK_FAULT BIT(5) > +#define HUSB320_MASK_AUTOSINK BIT(3) > +#define HUSB320_MASK1_FORCE GENMASK(2, 1) > + > +#define HUSB320_STATUS_ORIENTATION GENMASK(5, 4) > +#define HUSB320_STATUS_ORIENTATION_CC1 1 > +#define HUSB320_STATUS_ORIENTATION_CC2 2 > +#define HUSB320_STATUS_CURRENT GENMASK(2, 1) > +#define HUSB320_STATUS_ATTACHED BIT(0) > + > +#define HUSB320_TYPE_DEBUG_SOURCE BIT(6) > +#define HUSB320_TYPE_DEBUG_SINK BIT(5) > +#define HUSB320_TYPE_SINK BIT(4) > +#define HUSB320_TYPE_SOURCE BIT(3) > +#define HUSB320_TYPE_AUDIO_VBUS BIT(1) > +#define HUSB320_TYPE_AUDIO BIT(0) > + > +#define HUSB320_INT_ORIENTATION BIT(6) > +#define HUSB320_INT_VBUS_CHANGE BIT(4) > +#define HUSB320_INT_AUTOSINK BIT(3) > +#define HUSB320_INT_CURRENT_CHANGE BIT(2) > +#define HUSB320_INT_DETACH BIT(1) > +#define HUSB320_INT_ATTACH BIT(0) > +#define HUSB320_INT_VALID (HUSB320_INT_ORIENTATION | \ > + HUSB320_INT_VBUS_CHANGE | \ > + HUSB320_INT_AUTOSINK | \ > + HUSB320_INT_CURRENT_CHANGE | \ > + HUSB320_INT_DETACH | \ > + HUSB320_INT_ATTACH) > +#define HUSB320_INT1_VALID GENMASK(2, 1) > + > +enum husb320_state { > + HUSB320_STATE_UNATTACHED, > + HUSB320_STATE_SOURCE, > + HUSB320_STATE_SINK, > + HUSB320_STATE_DEBUG_SOURCE, > + HUSB320_STATE_DEBUG_SINK, > + HUSB320_STATE_AUDIO, > +}; > + > +struct husb320 { > + struct device *dev; > + struct regmap *regmap; > + struct gpio_desc *enable_gpio; > + struct regulator *vbus; > + struct usb_role_switch *role_sw; > + struct typec_capability cap; > + struct typec_port *port; > + struct typec_partner *partner; > + struct fwnode_handle *connector; > + /* Serializes controller access and Type-C state updates. */ > + struct mutex lock; > + enum typec_port_type port_type; > + enum typec_role preferred_role; > + enum typec_pwr_opmode source_opmode; > + enum husb320_state state; > + enum usb_role usb_role; > + int connector_mode; > + bool has_data; > + bool mode_valid; > + bool shutting_down; > + bool state_valid; > + bool vbus_on; > +}; > + > +static const struct regmap_config husb320_regmap_config = { > + .reg_bits = 8, > + .val_bits = 8, > + .max_register = HUSB320_REG_INTERRUPT1, > +}; > + > +static enum typec_role husb320_default_power_role(struct husb320 *husb) > +{ > + switch (husb->port_type) { > + case TYPEC_PORT_SRC: > + return TYPEC_SOURCE; > + case TYPEC_PORT_SNK: > + return TYPEC_SINK; > + case TYPEC_PORT_DRP: > + default: > + if (husb->preferred_role == TYPEC_SOURCE) > + return TYPEC_SOURCE; > + > + return TYPEC_SINK; > + } > +} > + > +static enum typec_data_role husb320_default_data_role(struct husb320 *husb) > +{ > + switch (husb->cap.data) { > + case TYPEC_PORT_DFP: > + return TYPEC_HOST; > + case TYPEC_PORT_UFP: > + return TYPEC_DEVICE; > + case TYPEC_PORT_DRD: > + default: > + return husb320_default_power_role(husb) == TYPEC_SOURCE ? > + TYPEC_HOST : TYPEC_DEVICE; > + } > +} > + > +static void husb320_set_unattached_roles(struct husb320 *husb) > +{ > + enum typec_role power_role = husb320_default_power_role(husb); > + > + typec_set_pwr_role(husb->port, power_role); > + if (husb->has_data) > + typec_set_data_role(husb->port, > + husb320_default_data_role(husb)); > + typec_set_pwr_opmode(husb->port, > + power_role == TYPEC_SOURCE ? > + husb->source_opmode : TYPEC_PWR_MODE_USB); > +} > + > +static int husb320_set_vbus(struct husb320 *husb, bool enable) > +{ > + int ret; > + > + if (!husb->vbus || husb->vbus_on == enable) > + return 0; > + > + if (enable) > + ret = regulator_enable(husb->vbus); > + else > + ret = regulator_disable(husb->vbus); > + if (ret) > + return ret; > + > + husb->vbus_on = enable; > + > + return 0; > +} > + > +static int husb320_set_mode(struct husb320 *husb, int mode) > +{ > + int ret; > + > + if (husb->mode_valid && husb->connector_mode == mode) > + return 0; > + > + ret = typec_set_mode(husb->port, mode); > + if (ret) > + return ret; > + > + husb->connector_mode = mode; > + husb->mode_valid = true; > + > + return 0; > +} > + > +static void husb320_unregister_partner(struct husb320 *husb) > +{ > + if (!husb->partner) > + return; > + > + typec_unregister_partner(husb->partner); > + husb->partner = NULL; > +} > + > +static int husb320_register_partner(struct husb320 *husb, > + enum typec_accessory accessory) > +{ > + struct typec_partner_desc desc = { > + .accessory = accessory, > + .usb_pd = false, > + }; > + > + if (husb->partner) > + return 0; > + > + husb->partner = typec_register_partner(husb->port, &desc); > + if (IS_ERR(husb->partner)) { > + int ret = PTR_ERR(husb->partner); > + > + husb->partner = NULL; > + return ret; > + } > + > + return 0; > +} > + > +static int husb320_disconnect(struct husb320 *husb) > +{ > + int err = 0; > + int ret; > + > + ret = husb320_set_vbus(husb, false); > + if (ret) > + err = ret; > + > + ret = usb_role_switch_set_role(husb->role_sw, USB_ROLE_NONE); > + if (ret) { > + if (!err) > + err = ret; > + } else { > + husb->usb_role = USB_ROLE_NONE; > + } > + > + ret = husb320_set_mode(husb, TYPEC_STATE_SAFE); > + if (ret && !err) > + err = ret; > + > + husb320_unregister_partner(husb); > + > + if (typec_get_orientation(husb->port) != TYPEC_ORIENTATION_NONE) { > + ret = typec_set_orientation(husb->port, TYPEC_ORIENTATION_NONE); > + if (ret && !err) > + err = ret; > + } > + > + husb320_set_unattached_roles(husb); > + > + husb->state = HUSB320_STATE_UNATTACHED; > + husb->state_valid = !err; > + > + return err; > +} > + > +static int husb320_hw_disable(struct husb320 *husb); > + > +static void husb320_error_recovery(struct husb320 *husb) > +{ > + int cleanup_ret; > + int disable_ret; > + int recovery_ret; > + > + cleanup_ret = husb320_disconnect(husb); > + recovery_ret = regmap_write(husb->regmap, HUSB320_REG_MANUAL, > + HUSB320_MANUAL_ERROR_RECOVERY); > + if (cleanup_ret) > + dev_err_ratelimited(husb->dev, > + "failed to clean up port: %d\n", cleanup_ret); > + if (recovery_ret) > + dev_err_ratelimited(husb->dev, > + "failed to start error recovery: %d\n", > + recovery_ret); > + > + if (!cleanup_ret && !recovery_ret) > + return; > + > + husb->shutting_down = true; > + disable_ret = husb320_hw_disable(husb); > + if (disable_ret) > + dev_err_ratelimited(husb->dev, > + "failed to disable controller: %d\n", > + disable_ret); > +} > + > +static enum typec_pwr_opmode husb320_sink_opmode(unsigned int status) > +{ > + switch (FIELD_GET(HUSB320_STATUS_CURRENT, status)) { > + case 2: > + return TYPEC_PWR_MODE_1_5A; > + case 3: > + return TYPEC_PWR_MODE_3_0A; > + case 0: > + case 1: > + default: > + return TYPEC_PWR_MODE_USB; > + } > +} > + > +static enum typec_role husb320_state_power_role(enum husb320_state state) > +{ > + switch (state) { > + case HUSB320_STATE_SOURCE: > + case HUSB320_STATE_DEBUG_SOURCE: > + case HUSB320_STATE_AUDIO: > + return TYPEC_SOURCE; > + case HUSB320_STATE_SINK: > + case HUSB320_STATE_DEBUG_SINK: > + case HUSB320_STATE_UNATTACHED: > + default: > + return TYPEC_SINK; > + } > +} > + > +static enum typec_accessory husb320_state_accessory(enum husb320_state state) > +{ > + switch (state) { > + case HUSB320_STATE_DEBUG_SOURCE: > + case HUSB320_STATE_DEBUG_SINK: > + return TYPEC_ACCESSORY_DEBUG; > + case HUSB320_STATE_AUDIO: > + return TYPEC_ACCESSORY_AUDIO; > + default: > + return TYPEC_ACCESSORY_NONE; > + } > +} > + > +static enum usb_role husb320_state_usb_role(struct husb320 *husb, > + enum husb320_state state) > +{ > + if (!husb->has_data) > + return USB_ROLE_NONE; > + > + if ((state == HUSB320_STATE_SOURCE || > + state == HUSB320_STATE_DEBUG_SOURCE) && > + husb->cap.data != TYPEC_PORT_UFP) > + return USB_ROLE_HOST; > + > + if ((state == HUSB320_STATE_SINK || > + state == HUSB320_STATE_DEBUG_SINK) && > + husb->cap.data != TYPEC_PORT_DFP) > + return USB_ROLE_DEVICE; > + > + return USB_ROLE_NONE; > +} > + > +static int husb320_state_mode(enum husb320_state state) > +{ > + switch (state) { > + case HUSB320_STATE_DEBUG_SOURCE: > + case HUSB320_STATE_DEBUG_SINK: > + return TYPEC_MODE_DEBUG; > + case HUSB320_STATE_AUDIO: > + return TYPEC_MODE_AUDIO; > + case HUSB320_STATE_SOURCE: > + case HUSB320_STATE_SINK: > + return TYPEC_STATE_USB; > + case HUSB320_STATE_UNATTACHED: > + default: > + return TYPEC_STATE_SAFE; > + } > +} > + > +static int husb320_apply_state(struct husb320 *husb, > + enum husb320_state state, > + enum typec_orientation orientation, > + unsigned int status) > +{ > + enum typec_accessory accessory = husb320_state_accessory(state); > + enum usb_role usb_role = husb320_state_usb_role(husb, state); > + enum typec_pwr_opmode opmode; > + enum typec_role power_role; > + int ret; > + > + if (state == HUSB320_STATE_UNATTACHED && husb->state_valid && > + husb->state == HUSB320_STATE_UNATTACHED && !husb->partner && > + !husb->vbus_on && > + husb->usb_role == USB_ROLE_NONE) > + return 0; > + > + if (state == HUSB320_STATE_UNATTACHED) > + return husb320_disconnect(husb); > + > + if (state != husb->state && > + (!husb->state_valid || > + husb->state != HUSB320_STATE_UNATTACHED)) { > + ret = husb320_disconnect(husb); > + if (ret) > + return ret; > + } > + > + if (typec_get_orientation(husb->port) != orientation) { > + ret = typec_set_orientation(husb->port, orientation); > + if (ret) > + return ret; > + } > + > + /* Accessory states do not request the platform VBUS supply. */ > + ret = husb320_set_vbus(husb, state == HUSB320_STATE_SOURCE); > + if (ret) > + return ret; > + > + if (usb_role != husb->usb_role) { > + ret = usb_role_switch_set_role(husb->role_sw, usb_role); > + if (ret) > + return ret; > + husb->usb_role = usb_role; > + } > + > + ret = husb320_set_mode(husb, husb320_state_mode(state)); > + if (ret) > + return ret; > + > + power_role = husb320_state_power_role(state); > + opmode = state == HUSB320_STATE_SINK ? > + husb320_sink_opmode(status) : > + (power_role == TYPEC_SOURCE ? husb->source_opmode : > + TYPEC_PWR_MODE_USB); > + > + if (usb_role == USB_ROLE_HOST) > + typec_set_data_role(husb->port, TYPEC_HOST); > + else if (usb_role == USB_ROLE_DEVICE) > + typec_set_data_role(husb->port, TYPEC_DEVICE); > + typec_set_pwr_role(husb->port, power_role); > + typec_set_pwr_opmode(husb->port, opmode); > + > + ret = husb320_register_partner(husb, accessory); > + if (ret) { > + husb->state_valid = false; > + dev_err_ratelimited(husb->dev, > + "failed to register partner: %d\n", ret); > + return ret; > + } > + > + husb->state = state; > + husb->state_valid = true; > + > + return 0; > +} > + > +static enum typec_orientation husb320_get_orientation(unsigned int status) > +{ > + switch (FIELD_GET(HUSB320_STATUS_ORIENTATION, status)) { > + case HUSB320_STATUS_ORIENTATION_CC1: > + return TYPEC_ORIENTATION_NORMAL; > + case HUSB320_STATUS_ORIENTATION_CC2: > + return TYPEC_ORIENTATION_REVERSE; > + default: > + return TYPEC_ORIENTATION_NONE; > + } > +} > + > +static enum husb320_state husb320_get_state(unsigned int status, > + unsigned int type) > +{ > + if (!(status & HUSB320_STATUS_ATTACHED)) > + return HUSB320_STATE_UNATTACHED; > + > + if (type & HUSB320_TYPE_DEBUG_SOURCE) > + return HUSB320_STATE_DEBUG_SOURCE; > + if (type & HUSB320_TYPE_DEBUG_SINK) > + return HUSB320_STATE_DEBUG_SINK; > + if (type & HUSB320_TYPE_SINK) > + return HUSB320_STATE_SINK; > + if (type & HUSB320_TYPE_SOURCE) > + return HUSB320_STATE_SOURCE; > + if (type & (HUSB320_TYPE_AUDIO_VBUS | HUSB320_TYPE_AUDIO)) > + return HUSB320_STATE_AUDIO; > + > + return HUSB320_STATE_UNATTACHED; > +} > + > +static int husb320_update_state(struct husb320 *husb) > +{ > + enum typec_orientation orientation; > + enum husb320_state state; > + unsigned int status; > + unsigned int type; > + int ret; > + > + ret = regmap_read(husb->regmap, HUSB320_REG_STATUS, &status); > + if (ret) > + return ret; > + > + ret = regmap_read(husb->regmap, HUSB320_REG_TYPE, &type); > + if (ret) > + return ret; > + > + state = husb320_get_state(status, type); > + orientation = state == HUSB320_STATE_UNATTACHED ? > + TYPEC_ORIENTATION_NONE : husb320_get_orientation(status); > + > + ret = husb320_apply_state(husb, state, orientation, status); > + if (!ret) > + dev_dbg(husb->dev, "status=%#x type=%#x state=%u\n", > + status, type, state); > + > + return ret; > +} > + > +static irqreturn_t husb320_irq_thread(int irq, void *data) > +{ > + struct husb320 *husb = data; > + unsigned int interrupt; > + unsigned int interrupt1; > + int disable_ret; > + int ret; > + > + mutex_lock(&husb->lock); > + if (husb->shutting_down) { > + disable_irq_nosync(irq); > + mutex_unlock(&husb->lock); > + return IRQ_HANDLED; > + } > + > + ret = regmap_read(husb->regmap, HUSB320_REG_INTERRUPT, &interrupt); > + if (ret) > + goto err; > + > + ret = regmap_read(husb->regmap, HUSB320_REG_INTERRUPT1, &interrupt1); > + if (ret) > + goto err; > + > + interrupt &= HUSB320_INT_VALID; > + interrupt1 &= HUSB320_INT1_VALID; > + if (!interrupt && !interrupt1) { > + mutex_unlock(&husb->lock); > + return IRQ_NONE; > + } > + > + if (interrupt) { > + ret = regmap_write(husb->regmap, HUSB320_REG_INTERRUPT, > + interrupt); > + if (ret) > + goto err; > + } > + > + if (interrupt1) { > + ret = regmap_write(husb->regmap, HUSB320_REG_INTERRUPT1, > + interrupt1); > + if (ret) > + goto err; > + } > + > + if (interrupt & HUSB320_INT_DETACH) { > + ret = husb320_disconnect(husb); > + if (ret) > + dev_err_ratelimited(husb->dev, > + "failed to disconnect port: %d\n", > + ret); > + } > + > + ret = husb320_update_state(husb); > + if (ret) { > + dev_err_ratelimited(husb->dev, > + "failed to update port state: %d\n", ret); > + husb320_error_recovery(husb); > + } > + > + mutex_unlock(&husb->lock); > + > + return IRQ_HANDLED; > + > +err: > + dev_err_ratelimited(husb->dev, "failed to service interrupt: %d\n", > + ret); > + husb->shutting_down = true; > + husb320_error_recovery(husb); > + disable_ret = husb320_hw_disable(husb); > + if (disable_ret) > + dev_err_ratelimited(husb->dev, > + "failed to disable controller: %d\n", > + disable_ret); > + disable_irq_nosync(irq); > + mutex_unlock(&husb->lock); > + > + return IRQ_HANDLED; > +} > + > +static unsigned int husb320_port_role(enum typec_port_type type) > +{ > + switch (type) { > + case TYPEC_PORT_SRC: > + return HUSB320_PORT_ROLE_SOURCE; > + case TYPEC_PORT_SNK: > + return HUSB320_PORT_ROLE_SINK; > + case TYPEC_PORT_DRP: > + default: > + return HUSB320_PORT_ROLE_DRP; > + } > +} > + > +static unsigned int husb320_try_role(int role) > +{ > + switch (role) { > + case TYPEC_SINK: > + return HUSB320_TRY_SINK; > + case TYPEC_SOURCE: > + return HUSB320_TRY_SOURCE; > + case TYPEC_NO_PREFERRED_ROLE: > + default: > + return HUSB320_TRY_NONE; > + } > +} > + > +static int husb320_port_type_set(struct typec_port *port, > + enum typec_port_type type) > +{ > + struct husb320 *husb = typec_get_drvdata(port); > + unsigned int port_role; > + int ret; > + > + mutex_lock(&husb->lock); > + if (husb->shutting_down) { > + ret = -ESHUTDOWN; > + goto out_unlock; > + } > + > + port_role = husb320_port_role(type); > + if (type == TYPEC_PORT_DRP) > + port_role |= FIELD_PREP(HUSB320_PORT_ROLE_TRY, > + husb320_try_role(husb->preferred_role)); > + > + ret = husb320_disconnect(husb); > + if (ret) { > + husb320_error_recovery(husb); > + goto out_unlock; > + } > + > + ret = regmap_update_bits(husb->regmap, HUSB320_REG_PORT_ROLE, > + HUSB320_PORT_ROLE_TRY | > + HUSB320_PORT_ROLE_MODE, > + port_role); > + if (ret) { > + husb320_error_recovery(husb); > + goto out_unlock; > + } > + > + husb->port_type = type; > + husb320_set_unattached_roles(husb); > +out_unlock: > + mutex_unlock(&husb->lock); > + > + return ret; > +} > + > +static int husb320_try_role_set(struct typec_port *port, int role) > +{ > + struct husb320 *husb = typec_get_drvdata(port); > + int ret; > + > + mutex_lock(&husb->lock); > + if (husb->shutting_down) { > + ret = -ESHUTDOWN; > + goto out_unlock; > + } > + > + if (husb->port_type == TYPEC_PORT_DRP) > + ret = regmap_update_bits(husb->regmap, HUSB320_REG_PORT_ROLE, > + HUSB320_PORT_ROLE_TRY, > + FIELD_PREP(HUSB320_PORT_ROLE_TRY, > + husb320_try_role(role))); > + else > + ret = 0; > + if (!ret) > + husb->preferred_role = role; > +out_unlock: > + mutex_unlock(&husb->lock); > + > + return ret; > +} > + > +static const struct typec_operations husb320_typec_ops = { > + .port_type_set = husb320_port_type_set, > + .try_role = husb320_try_role_set, > +}; > + > +static unsigned int husb320_host_current(enum typec_pwr_opmode opmode) > +{ > + switch (opmode) { > + case TYPEC_PWR_MODE_1_5A: > + return HUSB320_HOST_CURRENT_1_5A; > + case TYPEC_PWR_MODE_3_0A: > + return HUSB320_HOST_CURRENT_3_0A; > + case TYPEC_PWR_MODE_USB: > + default: > + return HUSB320_HOST_CURRENT_DEFAULT; > + } > +} > + > +static int husb320_hw_init(struct husb320 *husb) > +{ > + unsigned int port_role; > + unsigned int control; > + int ret; > + > + ret = regmap_update_bits(husb->regmap, HUSB320_REG_RESET, > + HUSB320_RESET_SW, HUSB320_RESET_SW); > + if (ret) > + return ret; > + > + /* Wait for stable status and I2C access after the soft reset. */ > + msleep(100); > + > + control = HUSB320_CONTROL_INT_MASK | > + FIELD_PREP(HUSB320_CONTROL_HOST_CURRENT, > + husb320_host_current(husb->source_opmode)); > + ret = regmap_update_bits(husb->regmap, HUSB320_REG_CONTROL, > + HUSB320_CONTROL_INT_MASK | > + HUSB320_CONTROL_HOST_CURRENT, > + control); > + if (ret) > + return ret; > + > + port_role = husb320_port_role(husb->port_type); > + if (husb->port_type == TYPEC_PORT_DRP) > + port_role |= FIELD_PREP(HUSB320_PORT_ROLE_TRY, > + husb320_try_role(husb->preferred_role)); > + ret = regmap_update_bits(husb->regmap, HUSB320_REG_PORT_ROLE, > + HUSB320_PORT_ROLE_TRY | > + HUSB320_PORT_ROLE_MODE, > + port_role); > + if (ret) > + return ret; > + > + ret = regmap_write(husb->regmap, HUSB320_REG_MASK, > + HUSB320_MASK_FAULT | HUSB320_MASK_AUTOSINK); > + if (ret) > + return ret; > + > + ret = regmap_write(husb->regmap, HUSB320_REG_MASK1, > + HUSB320_MASK1_FORCE); > + if (ret) > + return ret; > + > + ret = regmap_update_bits(husb->regmap, HUSB320_REG_CONTROL1, > + HUSB320_CONTROL1_ENABLE, > + HUSB320_CONTROL1_ENABLE); > + if (ret) > + return ret; > + > + ret = regmap_write(husb->regmap, HUSB320_REG_INTERRUPT, > + HUSB320_INT_VALID); > + if (ret) > + return ret; > + > + return regmap_write(husb->regmap, HUSB320_REG_INTERRUPT1, > + HUSB320_INT1_VALID); > +} > + > +static int husb320_hw_disable(struct husb320 *husb) > +{ > + int err = 0; > + int ret; > + > + ret = regmap_update_bits(husb->regmap, HUSB320_REG_CONTROL, > + HUSB320_CONTROL_INT_MASK, > + HUSB320_CONTROL_INT_MASK); > + if (ret) > + err = ret; > + > + ret = regmap_update_bits(husb->regmap, HUSB320_REG_CONTROL1, > + HUSB320_CONTROL1_ENABLE, 0); > + if (ret && !err) > + err = ret; > + > + return err; > +} > + > +static int husb320_set_sink_mode(struct husb320 *husb) > +{ > + int ret; > + > + ret = regmap_update_bits(husb->regmap, HUSB320_REG_CONTROL, > + HUSB320_CONTROL_INT_MASK, > + HUSB320_CONTROL_INT_MASK); > + if (ret) > + return ret; > + > + ret = regmap_update_bits(husb->regmap, HUSB320_REG_PORT_ROLE, > + HUSB320_PORT_ROLE_TRY | > + HUSB320_PORT_ROLE_MODE, > + HUSB320_PORT_ROLE_SINK); > + if (ret) > + return ret; > + > + return regmap_update_bits(husb->regmap, HUSB320_REG_CONTROL1, > + HUSB320_CONTROL1_ENABLE, > + HUSB320_CONTROL1_ENABLE); > +} > + > +static int husb320_parse_connector(struct husb320 *husb) > +{ > + const char *opmode; > + int ret; > + > + husb->connector = device_get_named_child_node(husb->dev, "connector"); > + if (!husb->connector) > + return -ENODEV; > + > + /* The connector is parsed as a fwnode and is not populated as a device. */ > + fw_devlink_purge_absent_suppliers(husb->connector); > + > + ret = typec_get_fw_cap(&husb->cap, husb->connector); > + if (ret) > + return ret; > + > + ret = fwnode_property_read_string(husb->connector, > + "typec-power-opmode", &opmode); > + if (ret) > + return ret; > + > + ret = typec_find_pwr_opmode(opmode); > + if (ret < 0) > + return ret; > + if (ret == TYPEC_PWR_MODE_PD) > + return -EINVAL; > + > + husb->source_opmode = ret; > + husb->has_data = fwnode_property_present(husb->connector, "data-role"); > + if (husb->has_data && > + ((husb->cap.type == TYPEC_PORT_SRC && > + husb->cap.data != TYPEC_PORT_DFP) || > + (husb->cap.type == TYPEC_PORT_SNK && > + husb->cap.data != TYPEC_PORT_UFP) || > + (husb->cap.type == TYPEC_PORT_DRP && > + husb->cap.data != TYPEC_PORT_DRD))) { > + return dev_err_probe(husb->dev, -EINVAL, > + "power and data roles do not match\n"); > + } else if (!husb->has_data) { > + if (husb->cap.type == TYPEC_PORT_SNK) > + husb->cap.data = TYPEC_PORT_UFP; > + else if (husb->cap.type == TYPEC_PORT_DRP) > + husb->cap.data = TYPEC_PORT_DRD; > + } > + > + husb->cap.revision = USB_TYPEC_REV_2_0; > + husb->cap.accessory[0] = TYPEC_ACCESSORY_AUDIO; > + husb->cap.accessory[1] = TYPEC_ACCESSORY_DEBUG; > + husb->cap.orientation_aware = true; > + husb->cap.driver_data = husb; > + husb->cap.ops = &husb320_typec_ops; > + husb->port_type = husb->cap.type; > + husb->preferred_role = husb->cap.prefer_role; > + > + return 0; > +} > + > +static int husb320_get_role_switch(struct husb320 *husb) > +{ > + int ret; > + > + if (!husb->has_data) > + return 0; > + > + husb->role_sw = fwnode_usb_role_switch_get(husb->connector); > + if (IS_ERR(husb->role_sw)) { > + ret = PTR_ERR(husb->role_sw); > + husb->role_sw = NULL; > + if (ret == -ENODEV && husb->cap.data != TYPEC_PORT_DRD) > + return 0; > + > + return dev_err_probe(husb->dev, ret, > + "failed to get USB role switch\n"); > + } > + > + if (!husb->role_sw && husb->cap.data == TYPEC_PORT_DRD) > + return dev_err_probe(husb->dev, -ENODEV, > + "USB data role has no role switch\n"); > + > + return 0; > +} > + > +static int husb320_get_vbus(struct husb320 *husb) > +{ > + struct device_node *node = to_of_node(husb->connector); > + > + if (node) > + husb->vbus = devm_of_regulator_get_optional(husb->dev, node, "vbus"); > + else > + husb->vbus = devm_regulator_get_optional(husb->dev, "vbus"); > + > + if (IS_ERR(husb->vbus)) { > + int ret = PTR_ERR(husb->vbus); > + > + husb->vbus = NULL; > + if (ret != -ENODEV) > + return dev_err_probe(husb->dev, ret, > + "failed to get VBUS supply\n"); > + } > + > + if (husb->cap.type != TYPEC_PORT_SNK && !husb->vbus) > + return dev_err_probe(husb->dev, -ENODEV, > + "source-capable port requires VBUS supply\n"); > + > + return 0; > +} > + > +static void husb320_disable(void *data) > +{ > + struct husb320 *husb = data; > + > + gpiod_set_value_cansleep(husb->enable_gpio, 0); > +} > + > +static int husb320_power_on(struct husb320 *husb) > +{ > + bool needs_delay = false; > + int ret; > + > + ret = devm_regulator_get_enable_optional(husb->dev, "vdd"); > + if (ret == -ENODEV) { > + ret = 0; > + } else if (ret) { > + return dev_err_probe(husb->dev, ret, > + "failed to enable VDD supply\n"); > + } else { > + needs_delay = true; > + } > + > + husb->enable_gpio = devm_gpiod_get_optional(husb->dev, "enable", > + GPIOD_OUT_HIGH); > + if (IS_ERR(husb->enable_gpio)) > + return dev_err_probe(husb->dev, PTR_ERR(husb->enable_gpio), > + "failed to enable controller\n"); > + > + if (husb->enable_gpio) { > + ret = devm_add_action_or_reset(husb->dev, husb320_disable, husb); > + if (ret) > + return ret; > + needs_delay = true; > + } > + > + /* Wait for the controller to become I2C-accessible after power-on. */ > + if (needs_delay) > + msleep(100); > + > + return 0; > +} > + > +static int husb320_check_device(struct husb320 *husb) > +{ > + unsigned int device_id; > + unsigned int device_type; > + int ret; > + > + ret = regmap_read(husb->regmap, HUSB320_REG_DEVICE_ID, &device_id); > + if (ret) > + return dev_err_probe(husb->dev, ret, > + "failed to read device ID\n"); > + > + ret = regmap_read(husb->regmap, HUSB320_REG_DEVICE_TYPE, &device_type); > + if (ret) > + return dev_err_probe(husb->dev, ret, > + "failed to read device type\n"); > + > + if (FIELD_GET(HUSB320_DEVICE_ID_VERSION, device_id) != > + HUSB320_DEVICE_ID_VERSION_1 || > + device_type != HUSB320_DEVICE_TYPE) > + return dev_err_probe(husb->dev, -ENODEV, > + "unsupported device ID %#x type %#x\n", > + device_id, device_type); > + > + dev_dbg(husb->dev, "version %lu revision %lu\n", > + FIELD_GET(HUSB320_DEVICE_ID_VERSION, device_id), > + FIELD_GET(HUSB320_DEVICE_ID_REVISION, device_id)); > + > + return 0; > +} > + > +static int husb320_probe(struct i2c_client *client) > +{ > + struct device *dev = &client->dev; > + struct husb320 *husb; > + int ret; > + > + husb = devm_kzalloc(dev, sizeof(*husb), GFP_KERNEL); > + if (!husb) > + return -ENOMEM; > + > + husb->dev = dev; > + husb->state = HUSB320_STATE_UNATTACHED; > + husb->usb_role = USB_ROLE_NONE; > + mutex_init(&husb->lock); > + i2c_set_clientdata(client, husb); > + > + ret = husb320_power_on(husb); > + if (ret) > + return ret; > + > + husb->regmap = devm_regmap_init_i2c(client, &husb320_regmap_config); > + if (IS_ERR(husb->regmap)) > + return dev_err_probe(dev, PTR_ERR(husb->regmap), > + "failed to initialize regmap\n"); > + > + ret = husb320_check_device(husb); > + if (ret) > + return ret; > + > + if (client->irq <= 0) > + return dev_err_probe(dev, client->irq ?: -EINVAL, > + "missing interrupt\n"); > + > + ret = husb320_parse_connector(husb); > + if (ret) > + goto err_put_connector; > + > + ret = husb320_get_role_switch(husb); > + if (ret) > + goto err_put_connector; > + > + ret = husb320_get_vbus(husb); > + if (ret) > + goto err_put_role; > + > + ret = husb320_hw_init(husb); > + if (ret) > + goto err_hw_disable; > + > + husb->port = typec_register_port(dev, &husb->cap); > + if (IS_ERR(husb->port)) { > + ret = PTR_ERR(husb->port); > + goto err_hw_disable; > + } > + > + ret = devm_request_threaded_irq(dev, client->irq, NULL, > + husb320_irq_thread, IRQF_ONESHOT, > + dev_name(dev), husb); > + if (ret) > + goto err_unregister_port; > + > + mutex_lock(&husb->lock); > + ret = husb320_update_state(husb); > + mutex_unlock(&husb->lock); > + if (ret) > + goto err_free_irq; > + > + ret = regmap_update_bits(husb->regmap, HUSB320_REG_CONTROL, > + HUSB320_CONTROL_INT_MASK, 0); > + if (ret) > + goto err_free_irq; > + > + return 0; > + > +err_free_irq: > + mutex_lock(&husb->lock); > + husb->shutting_down = true; > + mutex_unlock(&husb->lock); > + devm_free_irq(dev, client->irq, husb); > +err_unregister_port: > + mutex_lock(&husb->lock); > + husb->shutting_down = true; > + husb320_disconnect(husb); > + mutex_unlock(&husb->lock); > + typec_unregister_port(husb->port); > +err_hw_disable: > + husb320_hw_disable(husb); > +err_put_role: > + usb_role_switch_put(husb->role_sw); > +err_put_connector: > + fwnode_handle_put(husb->connector); > + > + return ret; > +} > + > +static void husb320_remove(struct i2c_client *client) > +{ > + struct husb320 *husb = i2c_get_clientdata(client); > + int ret; > + > + mutex_lock(&husb->lock); > + husb->shutting_down = true; > + ret = regmap_update_bits(husb->regmap, HUSB320_REG_CONTROL, > + HUSB320_CONTROL_INT_MASK, > + HUSB320_CONTROL_INT_MASK); > + mutex_unlock(&husb->lock); > + if (ret) > + dev_err(husb->dev, "failed to mask interrupts: %d\n", ret); > + > + devm_free_irq(husb->dev, client->irq, husb); > + > + mutex_lock(&husb->lock); > + ret = husb320_disconnect(husb); > + if (ret) > + dev_err(husb->dev, "failed to disconnect port: %d\n", ret); > + ret = husb320_hw_disable(husb); > + if (ret) > + dev_err(husb->dev, "failed to disable controller: %d\n", ret); > + mutex_unlock(&husb->lock); > + > + typec_unregister_port(husb->port); > + usb_role_switch_put(husb->role_sw); > + fwnode_handle_put(husb->connector); > +} > + > +static void husb320_shutdown(struct i2c_client *client) > +{ > + struct husb320 *husb = i2c_get_clientdata(client); > + int ret; > + > + mutex_lock(&husb->lock); > + husb->shutting_down = true; > + ret = regmap_update_bits(husb->regmap, HUSB320_REG_CONTROL, > + HUSB320_CONTROL_INT_MASK, > + HUSB320_CONTROL_INT_MASK); > + mutex_unlock(&husb->lock); > + if (ret) > + dev_err(husb->dev, "failed to mask interrupts: %d\n", ret); > + > + disable_irq(client->irq); > + > + mutex_lock(&husb->lock); > + ret = husb320_disconnect(husb); > + if (ret) { > + dev_err(husb->dev, "failed to disconnect port: %d\n", ret); > + } else if (husb->cap.type != TYPEC_PORT_SRC) { > + ret = husb320_set_sink_mode(husb); > + if (!ret) > + goto out_unlock; > + > + dev_err(husb->dev, "failed to configure shutdown mode: %d\n", ret); > + } > + > + ret = husb320_hw_disable(husb); > + if (ret) > + dev_err(husb->dev, "failed to disable controller: %d\n", ret); > + > +out_unlock: > + mutex_unlock(&husb->lock); > +} > + > +static const struct of_device_id husb320_of_match[] = { > + { .compatible = "hynetek,husb320" }, > + { } > +}; > +MODULE_DEVICE_TABLE(of, husb320_of_match); > + > +static struct i2c_driver husb320_driver = { > + .driver = { > + .name = "husb320", > + .of_match_table = husb320_of_match, > + }, > + .probe = husb320_probe, > + .remove = husb320_remove, > + .shutdown = husb320_shutdown, > +}; > +module_i2c_driver(husb320_driver); > + > +MODULE_AUTHOR("Hongyang Zhao "); > +MODULE_DESCRIPTION("Hynetek HUSB320 USB Type-C controller driver"); > +MODULE_LICENSE("GPL"); > > -- > 2.43.0 -- heikki