Re: [PATCHv2 2/2] usb: typec: anx7688: Add driver for ANX7688 USB-C HDMI bridge

Heikki Krogerus
2024-03-12T14:12:59Z

Hi Pavel,

I'm sorry to keep you waiting.

On Fri, Feb 23, 2024 at 10:28:49PM +0100, Pavel Machek wrote:
> From: Ondrej Jirman <megi@xff.cz>
>
> This is driver for ANX7688 USB-C HDMI, with flashing and debugging
> features removed. ANX7688 is rather criticial piece on PinePhone,
> there's no display and no battery charging without it.
>
> There's likely more work to be done here, but having basic support
> in mainline is needed to be able to work on the other stuff
> (networking, cameras, power management).
>
> Signed-off-by: Ondrej Jirman <megi@xff.cz>
> Co-developed-by: Martijn Braam <martijn@brixit.nl>
> Co-developed-by: Samuel Holland <samuel@sholland.org>
> Signed-off-by: Pavel Machek <pavel@ucw.cz>
>
> ---
>
> v2: Fix checkpatch stuff. Some cleanups, adapt to dts format in 1/2.
>
> diff --git a/drivers/usb/typec/Kconfig b/drivers/usb/typec/Kconfig
> index 2f80c2792dbd..c9043ae61546 100644
> --- a/drivers/usb/typec/Kconfig
> +++ b/drivers/usb/typec/Kconfig
> @@ -64,6 +64,17 @@ config TYPEC_ANX7411
> If you choose to build this driver as a dynamically linked module, the
> module will be called anx7411.ko.
>
> +config TYPEC_ANX7688
> + tristate "Analogix ANX7688 Type-C DRP Port controller and mux driver"
> + depends on I2C
> + depends on USB_ROLE_SWITCH
> + help
> + Say Y or M here if your system has Analogix ANX7688 Type-C Bridge
> + controller driver.
> +
> + If you choose to build this driver as a dynamically linked module, the
> + module will be called anx7688.ko.
> +
> config TYPEC_RT1719
> tristate "Richtek RT1719 Sink Only 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 7a368fea61bc..3f8ff94ad294 100644
> --- a/drivers/usb/typec/Makefile
> +++ b/drivers/usb/typec/Makefile
> @@ -7,6 +7,7 @@ obj-$(CONFIG_TYPEC_TCPM) += tcpm/
> obj-$(CONFIG_TYPEC_UCSI) += ucsi/
> obj-$(CONFIG_TYPEC_TPS6598X) += tipd/
> obj-$(CONFIG_TYPEC_ANX7411) += anx7411.o
> +obj-$(CONFIG_TYPEC_ANX7688) += anx7688.o
> obj-$(CONFIG_TYPEC_HD3SS3220) += hd3ss3220.o
> obj-$(CONFIG_TYPEC_STUSB160X) += stusb160x.o
> obj-$(CONFIG_TYPEC_RT1719) += rt1719.o
> diff --git a/drivers/usb/typec/anx7688.c b/drivers/usb/typec/anx7688.c
> new file mode 100644
> index 000000000000..14d033bbc0c7
> --- /dev/null
> +++ b/drivers/usb/typec/anx7688.c
> @@ -0,0 +1,1927 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * ANX7688 USB-C HDMI bridge/PD driver
> + *
> + * Warning, this driver is somewhat PinePhone specific.
> + *
> + * How this works:
> + * - this driver allows to program firmware into ANX7688 EEPROM, and
> + * initialize it
> + * - it then communicates with the firmware running on the OCM (on-chip
> + * microcontroller)
> + * - it detects whether there is cable plugged in or not and powers
> + * up or down the ANX7688 based on that
> + * - when the cable is connected the firmware on the OCM will handle
> + * the detection of the nature of the device on the other end
> + * of the USB-C cable
> + * - this driver then communicates with the USB phy to let it swap
> + * data roles accordingly
> + * - it also enables VBUS and VCONN regulators as appropriate
> + * - USB phy driver (Allwinner) needs to know whether to switch to
> + * device or host mode, or whether to turn off
> + * - when the firmware detects SRC.1.5A or SRC.3.0A via CC pins
> + * or something else via PD, it notifies this driver via software
> + * interrupt and this driver will determine how to update the TypeC
> + * port status and what input current limit is appropriate
> + * - input current limit determination happens 500ms after cable
> + * insertion or hard reset (delay is necessary to determine whether
> + * the remote end is PD capable or not)
> + * - this driver tells to the PMIC driver that the input current limit
> + * needs to be changed
> + * - this driver also monitors PMIC status and re-sets the input current
> + * limit if it changes for some reason (due to PMIC internal decision
> + * making) (this is disabled for now)
> + *
> + * ANX7688 FW behavior as observed:
> + *
> + * - DO NOT SET MORE THAN 1 SINK CAPABILITY! Firmware will ignore what
> + * you set and send hardcoded PDO_BATT 5-21V 30W message!
> + *
> + * Product brief:
> + * https://www.analogix.com/en/system/files/AA-002281-PB-6-ANX7688_Product_Brief_0.pdf
> + * Development notes:
> + * https://xnux.eu/devices/feature/anx7688.html
> + */
> +
> +#include <linux/debugfs.h>
> +#include <linux/delay.h>
> +#include <linux/extcon-provider.h>
> +#include <linux/firmware.h>
> +#include <linux/gpio/consumer.h>
> +#include <linux/i2c.h>
> +#include <linux/interrupt.h>
> +#include <linux/irqreturn.h>
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/of_irq.h>
> +#include <linux/power_supply.h>
> +#include <linux/regulator/consumer.h>
> +#include <linux/usb/pd.h>
> +#include <linux/usb/role.h>
> +#include <linux/usb/typec.h>
> +
> +/* firmware regs */
> +
> +#define ANX7688_REG_VBUS_OFF_DELAY_TIME 0x22
> +#define ANX7688_REG_FEATURE_CTRL 0x27
> +#define ANX7688_REG_EEPROM_LOAD_STATUS1 0x11
> +#define ANX7688_REG_EEPROM_LOAD_STATUS0 0x12
> +#define ANX7688_REG_FW_VERSION1 0x15
> +#define ANX7688_REG_FW_VERSION0 0x16
> +
> +#define ANX7688_EEPROM_FW_LOADED 0x01
> +
> +#define ANX7688_REG_STATUS_INT_MASK 0x17
> +#define ANX7688_REG_STATUS_INT 0x28
> +#define ANX7688_IRQS_RECEIVED_MSG BIT(0)
> +#define ANX7688_IRQS_RECEIVED_ACK BIT(1)
> +#define ANX7688_IRQS_VCONN_CHANGE BIT(2)
> +#define ANX7688_IRQS_VBUS_CHANGE BIT(3)
> +#define ANX7688_IRQS_CC_STATUS_CHANGE BIT(4)
> +#define ANX7688_IRQS_DATA_ROLE_CHANGE BIT(5)
> +
> +#define ANX7688_REG_STATUS 0x29
> +#define ANX7688_VCONN_STATUS BIT(2) /* 0 = off 1 = on */
> +#define ANX7688_VBUS_STATUS BIT(3) /* 0 = off 1 = on */
> +#define ANX7688_DATA_ROLE_STATUS BIT(5) /* 0 = device 1 = host */
> +
> +#define ANX7688_REG_CC_STATUS 0x2a
> +#define ANX7688_REG_TRY_UFP_TIMER 0x23
> +#define ANX7688_REG_TIME_CTRL 0x24
> +
> +#define ANX7688_REG_MAX_VOLTAGE 0x1b
> +#define ANX7688_REG_MAX_POWER 0x1c
> +#define ANX7688_REG_MIN_POWER 0x1d
> +#define ANX7688_REG_MAX_VOLTAGE_STATUS 0x1e
> +#define ANX7688_REG_MAX_POWER_STATUS 0x1f
> +
> +#define ANX7688_SOFT_INT_MASK 0x7f
> +
> +/* tcpc regs */
> +
> +#define ANX7688_TCPC_REG_VENDOR_ID0 0x00
> +#define ANX7688_TCPC_REG_VENDOR_ID1 0x01
> +#define ANX7688_TCPC_REG_ALERT0 0x10
> +#define ANX7688_TCPC_REG_ALERT1 0x11
> +#define ANX7688_TCPC_REG_ALERT_MASK0 0x12
> +#define ANX7688_TCPC_REG_ALERT_MASK1 0x13
> +#define ANX7688_TCPC_REG_INTERFACE_SEND 0x30
> +#define ANX7688_TCPC_REG_INTERFACE_RECV 0x51
> +
> +/* hw regs */
> +
> +#define ANX7688_REG_IRQ_EXT_SOURCE0 0x3e
> +#define ANX7688_REG_IRQ_EXT_SOURCE1 0x4e
> +#define ANX7688_REG_IRQ_EXT_SOURCE2 0x4f
> +#define ANX7688_REG_IRQ_EXT_MASK0 0x3b
> +#define ANX7688_REG_IRQ_EXT_MASK1 0x3c
> +#define ANX7688_REG_IRQ_EXT_MASK2 0x3d
> +#define ANX7688_REG_IRQ_SOURCE0 0x54
> +#define ANX7688_REG_IRQ_SOURCE1 0x55
> +#define ANX7688_REG_IRQ_SOURCE2 0x56
> +#define ANX7688_REG_IRQ_MASK0 0x57
> +#define ANX7688_REG_IRQ_MASK1 0x58
> +#define ANX7688_REG_IRQ_MASK2 0x59
> +
> +#define ANX7688_IRQ2_SOFT_INT BIT(2)
> +
> +#define ANX7688_REG_USBC_RESET_CTRL 0x05
> +#define ANX7688_USBC_RESET_CTRL_OCM_RESET BIT(4)
> +
> +/* ocm messages */
> +
> +#define ANX7688_OCM_MSG_PWR_SRC_CAP 0x00
> +#define ANX7688_OCM_MSG_PWR_SNK_CAP 0x01
> +#define ANX7688_OCM_MSG_DP_SNK_IDENTITY 0x02
> +#define ANX7688_OCM_MSG_SVID 0x03
> +#define ANX7688_OCM_MSG_GET_DP_SNK_CAP 0x04
> +#define ANX7688_OCM_MSG_ACCEPT 0x05
> +#define ANX7688_OCM_MSG_REJECT 0x06
> +#define ANX7688_OCM_MSG_PSWAP_REQ 0x10
> +#define ANX7688_OCM_MSG_DSWAP_REQ 0x11
> +#define ANX7688_OCM_MSG_GOTO_MIN_REQ 0x12
> +#define ANX7688_OCM_MSG_VCONN_SWAP_REQ 0x13
> +#define ANX7688_OCM_MSG_VDM 0x14
> +#define ANX7688_OCM_MSG_DP_SNK_CFG 0x15
> +#define ANX7688_OCM_MSG_PWR_OBJ_REQ 0x16
> +#define ANX7688_OCM_MSG_PD_STATUS_REQ 0x17
> +#define ANX7688_OCM_MSG_DP_ALT_ENTER 0x19
> +#define ANX7688_OCM_MSG_DP_ALT_EXIT 0x1a
> +#define ANX7688_OCM_MSG_GET_SNK_CAP 0x1b
> +#define ANX7688_OCM_MSG_RESPONSE_TO_REQ 0xf0
> +#define ANX7688_OCM_MSG_SOFT_RST 0xf1
> +#define ANX7688_OCM_MSG_HARD_RST 0xf2
> +#define ANX7688_OCM_MSG_RESTART 0xf3
> +
> +static const char * const anx7688_supply_names[] = {
> + "avdd33",
> + "avdd18",
> + "dvdd18",
> + "avdd10",
> + "dvdd10",
> + "i2c",
> + "hdmi-vt",
> +
> + "vconn", // power for VCONN1/VCONN2 switches
> + "vbus", // vbus power
> +};
> +
> +#define ANX7688_NUM_SUPPLIES ARRAY_SIZE(anx7688_supply_names)
> +#define ANX7688_NUM_ALWAYS_ON_SUPPLIES (ANX7688_NUM_SUPPLIES - 1)
> +
> +#define ANX7688_I2C_INDEX (ANX7688_NUM_SUPPLIES - 4)
> +#define ANX7688_VCONN_INDEX (ANX7688_NUM_SUPPLIES - 2)
> +#define ANX7688_VBUS_INDEX (ANX7688_NUM_SUPPLIES - 1)
> +
> +enum {
> + ANX7688_F_POWERED,
> + ANX7688_F_CONNECTED,
> + ANX7688_F_FW_FAILED,
> + ANX7688_F_PWRSUPPLY_CHANGE,
> + ANX7688_F_CURRENT_UPDATE,
> +};
> +
> +struct anx7688 {
> + struct device *dev;
> + struct i2c_client *client;
> + struct i2c_client *client_tcpc;
> + struct regulator_bulk_data supplies[ANX7688_NUM_SUPPLIES];
> + struct power_supply *vbus_in_supply;
> + struct notifier_block vbus_in_nb;
> + int input_current_limit; // mA
> + struct gpio_desc *gpio_enable;
> + struct gpio_desc *gpio_reset;
> + struct gpio_desc *gpio_cabledet;
> +
> + uint32_t src_caps[8];

Use u32 instead of uint32_t.

> + unsigned int n_src_caps;
> +
> + uint32_t snk_caps[8];

Ditto.

> + unsigned int n_snk_caps;
> +
> + unsigned long flags[1];
> +
> + struct delayed_work work;
> + struct timer_list work_timer;
> +
> + struct mutex lock;
> + bool vbus_on, vconn_on;
> + bool pd_capable;
> + int pd_current_limit; // mA
> + ktime_t current_update_deadline;
> +
> + struct typec_port *port;
> + struct typec_partner *partner;
> + struct usb_pd_identity partner_identity;
> + struct usb_role_switch *role_sw;
> + int pwr_role, data_role;
> +
> + struct dentry *debug_root;
> +
> + /* for debug */
> + int last_status;
> + int last_cc_status;
> + int last_dp_state;
> + int last_bc_result;
> +
> + /* for HDMI HPD */
> + struct extcon_dev *extcon;
> + int last_extcon_state;
> +};
> +
> +static const unsigned int anx7688_extcon_cable[] = {
> + EXTCON_DISP_HDMI,
> + EXTCON_NONE,
> +};
> +
> +static int anx7688_reg_read(struct anx7688 *anx7688, u8 reg_addr)
> +{
> + int ret;
> +
> + ret = i2c_smbus_read_byte_data(anx7688->client, reg_addr);
> + if (ret < 0)
> + dev_err(anx7688->dev, "i2c read failed at 0x%x (%d)\n",
> + reg_addr, ret);

dev_dbg instead.

> +
> + return ret;
> +}
> +
> +static int anx7688_reg_write(struct anx7688 *anx7688, u8 reg_addr, u8 value)
> +{
> + int ret;
> +
> + ret = i2c_smbus_write_byte_data(anx7688->client, reg_addr, value);
> + if (ret < 0)
> + dev_err(anx7688->dev, "i2c write failed at 0x%x (%d)\n",
> + reg_addr, ret);

Ditto.

> +
> + return ret;
> +}
> +
> +static int anx7688_reg_update_bits(struct anx7688 *anx7688, u8 reg_addr,
> + u8 mask, u8 value)
> +{
> + int ret;
> +
> + ret = anx7688_reg_read(anx7688, reg_addr);
> + if (ret < 0)
> + return ret;
> +
> + ret &= ~mask;
> + ret |= value;
> +
> + return anx7688_reg_write(anx7688, reg_addr, ret);
> +}
> +
> +static int anx7688_tcpc_reg_read(struct anx7688 *anx7688, u8 reg_addr)
> +{
> + int ret;
> +
> + ret = i2c_smbus_read_byte_data(anx7688->client_tcpc, reg_addr);
> + if (ret < 0)
> + dev_err(anx7688->dev, "tcpc i2c read failed at 0x%x (%d)\n",
> + reg_addr, ret);

Ditto.

> +
> + return ret;
> +}
> +
> +static int anx7688_tcpc_reg_write(struct anx7688 *anx7688, u8 reg_addr, u8 value)
> +{
> + int ret;
> +
> + ret = i2c_smbus_write_byte_data(anx7688->client_tcpc, reg_addr, value);
> + if (ret < 0)
> + dev_err(anx7688->dev, "tcpc i2c write failed at 0x%x (%d)\n",
> + reg_addr, ret);

Ditto.

> +
> + return ret;
> +}
> +
> +static void anx7688_power_enable(struct anx7688 *anx7688)
> +{
> + gpiod_set_value(anx7688->gpio_reset, 1);
> + gpiod_set_value(anx7688->gpio_enable, 1);
> +
> + /* wait for power to stabilize and release reset */
> + msleep(10);

So is it okay that the sleep may take up to 20ms?

> + gpiod_set_value(anx7688->gpio_reset, 0);
> + udelay(2);

Use usleep_range() instead.

> + dev_dbg(anx7688->dev, "power enabled\n");
> +
> + set_bit(ANX7688_F_POWERED, anx7688->flags);
> +}
> +
> +static void anx7688_power_disable(struct anx7688 *anx7688)
> +{
> + gpiod_set_value(anx7688->gpio_reset, 1);
> + msleep(5);

The same question here, is it a problem if the sleep ends up taking
20ms?

> + gpiod_set_value(anx7688->gpio_enable, 0);
> +
> + dev_dbg(anx7688->dev, "power disabled\n");
> +
> + clear_bit(ANX7688_F_POWERED, anx7688->flags);
> +}
> +
> +static int anx7688_send_ocm_message(struct anx7688 *anx7688, int cmd,
> + const u8 *data, int data_len)
> +{
> + int ret = 0, i;
> + u8 pkt[32];
> +
> + if (data_len > sizeof(pkt) - 3) {
> + dev_dbg(anx7688->dev,
> + "invalid ocm message length cmd=0x%02x len=%d\n",
> + cmd, data_len);
> + return -EINVAL;
> + }
> +
> + // prepare pd packet
> + pkt[0] = data_len + 1;
> + pkt[1] = cmd;
> + if (data_len > 0)
> + memcpy(pkt + 2, data, data_len);
> + pkt[2 + data_len] = 0;
> + for (i = 0; i < data_len + 2; i++)
> + pkt[data_len + 2] -= pkt[i];
> +
> + dev_dbg(anx7688->dev, "send pd packet cmd=0x%02x %*ph\n",
> + cmd, data_len + 3, pkt);
> +
> + ret = anx7688_tcpc_reg_read(anx7688, ANX7688_TCPC_REG_INTERFACE_SEND);
> + if (ret) {
> + dev_err(anx7688->dev,
> + "failed to send pd packet (tx buffer full)\n");

One line should be enought for that one.

> + return -EBUSY;
> + }
> +
> + ret = i2c_smbus_write_i2c_block_data(anx7688->client_tcpc,
> + ANX7688_TCPC_REG_INTERFACE_SEND,
> + data_len + 3, pkt);
> + if (ret < 0)
> + dev_err(anx7688->dev,
> + "failed to send pd packet (err=%d)\n", ret);

Ditto.

> + // wait until the message is processed (30ms max)
> + for (i = 0; i < 300; i++) {
> + ret = anx7688_tcpc_reg_read(anx7688, ANX7688_TCPC_REG_INTERFACE_SEND);
> + if (ret <= 0)
> + return ret;
> +
> + udelay(100);
> + }
> +
> + dev_err(anx7688->dev, "timeout waiting for the message queue flush\n");

Maybe dev_dbg for this too.

> + return -ETIMEDOUT;
> +}
> +
> +static int anx7688_connect(struct anx7688 *anx7688)
> +{
> + struct typec_partner_desc desc = {};
> + int ret, i;
> + u8 fw[2];
> + const u8 dp_snk_identity[16] = {
> + 0x00, 0x00, 0x00, 0xec, /* id header */
> + 0x00, 0x00, 0x00, 0x00, /* cert stat */
> + 0x00, 0x00, 0x00, 0x00, /* product type */
> + 0x39, 0x00, 0x00, 0x51 /* alt mode adapter */
> + };
> + const u8 svid[4] = {
> + 0x00, 0x00, 0x01, 0xff,
> + };
> + u32 caps[8];
> +
> + dev_dbg(anx7688->dev, "cable inserted\n");
> +
> + anx7688->last_status = -1;
> + anx7688->last_cc_status = -1;
> + anx7688->last_dp_state = -1;
> +
> + msleep(10);
> + anx7688_power_enable(anx7688);
> +
> + ret = regulator_enable(anx7688->supplies[ANX7688_VCONN_INDEX].consumer);
> + if (ret) {
> + dev_err(anx7688->dev, "failed to enable vconn\n");
> + goto err_poweroff;
> + }
> + anx7688->vconn_on = true;
> +
> + /* wait till the firmware is loaded (typically ~30ms) */
> + for (i = 0; i < 100; i++) {
> + ret = anx7688_reg_read(anx7688, ANX7688_REG_EEPROM_LOAD_STATUS0);
> +
> + if (ret >= 0 && (ret & ANX7688_EEPROM_FW_LOADED) == ANX7688_EEPROM_FW_LOADED) {
> + dev_dbg(anx7688->dev, "eeprom0 = 0x%02x\n", ret);
> + dev_info(anx7688->dev, "fw loaded after %d ms\n", i * 10);

Debugging information. Use dev_dbg.

> + goto fw_loaded;
> + }
> +
> + msleep(5);
> + }
> +
> + set_bit(ANX7688_F_FW_FAILED, anx7688->flags);
> + dev_err(anx7688->dev, "boot firmware load failed (you may need to flash FW to anx7688 first)\n");
> + ret = -ETIMEDOUT;
> + goto err_vconoff;
> +
> +fw_loaded:

This label looks a bit messy to me. You could also move that firmware
loading wait to its own function.

> + ret = i2c_smbus_read_i2c_block_data(anx7688->client,
> + ANX7688_REG_FW_VERSION1, 2, fw);
> + if (ret < 0) {
> + dev_err(anx7688->dev, "failed to read firmware version\n");
> + goto err_vconoff;
> + }
> +
> + dev_info(anx7688->dev, "OCM firmware loaded (version 0x%04x)\n",
> + fw[1] | fw[0] << 8);

deb_dbg.

> + /* Unmask interrupts */
> + ret = anx7688_reg_write(anx7688, ANX7688_REG_STATUS_INT, 0);
> + if (ret)
> + goto err_vconoff;
> +
> + ret = anx7688_reg_write(anx7688, ANX7688_REG_STATUS_INT_MASK, ~ANX7688_SOFT_INT_MASK);
> + if (ret)
> + goto err_vconoff;
> +
> + ret = anx7688_reg_write(anx7688, ANX7688_REG_IRQ_EXT_SOURCE2, 0xff);
> + if (ret)
> + goto err_vconoff;
> +
> + ret = anx7688_reg_write(anx7688, ANX7688_REG_IRQ_EXT_MASK2, (u8)~ANX7688_IRQ2_SOFT_INT);
> + if (ret)
> + goto err_vconoff;
> +
> + /* time to turn off vbus after cc disconnect (unit is 4 ms) */
> + ret = anx7688_reg_write(anx7688, ANX7688_REG_VBUS_OFF_DELAY_TIME, 100 / 4);
> + if (ret)
> + goto err_vconoff;
> +
> + /* 300ms (unit is 2 ms) */
> + ret = anx7688_reg_write(anx7688, ANX7688_REG_TRY_UFP_TIMER, 300 / 2);
> + if (ret)
> + goto err_vconoff;
> +
> + /* maximum voltage in 100 mV units */
> + ret = anx7688_reg_write(anx7688, ANX7688_REG_MAX_VOLTAGE, 50); /* 5 V */
> + if (ret)
> + goto err_vconoff;
> +
> + /* min/max power in 500 mW units */
> + ret = anx7688_reg_write(anx7688, ANX7688_REG_MAX_POWER, 15 * 2); /* 15 W */
> + if (ret)
> + goto err_vconoff;
> +
> + ret = anx7688_reg_write(anx7688, ANX7688_REG_MIN_POWER, 1); /* 0.5 W */
> + if (ret)
> + goto err_vconoff;
> +
> + /* auto_pd, try.src, try.sink, goto safe 5V */
> + ret = anx7688_reg_write(anx7688, ANX7688_REG_FEATURE_CTRL, 0x1e & ~BIT(2)); // disable try_src
> + if (ret)
> + goto err_vconoff;
> +
> + for (i = 0; i < anx7688->n_src_caps; i++)
> + caps[i] = cpu_to_le32(anx7688->src_caps[i]);
> + ret = anx7688_send_ocm_message(anx7688, ANX7688_OCM_MSG_PWR_SRC_CAP,
> + (u8 *)&caps, 4 * anx7688->n_src_caps);
> + if (ret)
> + goto err_vconoff;
> +
> + for (i = 0; i < anx7688->n_snk_caps; i++)
> + caps[i] = cpu_to_le32(anx7688->snk_caps[i]);
> + ret = anx7688_send_ocm_message(anx7688, ANX7688_OCM_MSG_PWR_SNK_CAP,
> + (u8 *)&caps, 4 * anx7688->n_snk_caps);
> + if (ret)
> + goto err_vconoff;
> +
> + /* Send DP SNK identity */
> + ret = anx7688_send_ocm_message(anx7688, ANX7688_OCM_MSG_DP_SNK_IDENTITY,
> + dp_snk_identity, sizeof(dp_snk_identity));
> + if (ret)
> + goto err_vconoff;
> +
> + ret = anx7688_send_ocm_message(anx7688, ANX7688_OCM_MSG_SVID,
> + svid, sizeof(svid));
> + if (ret)
> + goto err_vconoff;
> +
> + dev_dbg(anx7688->dev, "OCM configuration completed\n");
> +
> + desc.accessory = TYPEC_ACCESSORY_NONE;
> +
> + typec_unregister_partner(anx7688->partner);
> +
> + anx7688->partner = typec_register_partner(anx7688->port, &desc);
> + if (IS_ERR(anx7688->partner)) {
> + ret = PTR_ERR(anx7688->partner);
> + goto err_vconoff;
> + }
> +
> + // after this deadline passes we'll check if device is pd_capable and
> + // set up the current limit accordingly
> + anx7688->current_update_deadline = ktime_add_ms(ktime_get(), 3000);
> +
> + set_bit(ANX7688_F_CONNECTED, anx7688->flags);
> + return 0;
> +
> +err_vconoff:
> + regulator_disable(anx7688->supplies[ANX7688_VCONN_INDEX].consumer);
> + anx7688->vconn_on = false;
> +err_poweroff:
> + anx7688_power_disable(anx7688);
> + dev_err(anx7688->dev, "OCM configuration failed\n");
> + return ret;
> +}
> +
> +static void anx7688_set_hdmi_hpd(struct anx7688 *anx7688, int state)
> +{
> + if (!anx7688->extcon)
> + return;
> +
> + if (anx7688->last_extcon_state != state) {
> + extcon_set_state_sync(anx7688->extcon, EXTCON_DISP_HDMI, state);
> + anx7688->last_extcon_state = state;
> + }
> +}
> +
> +static void anx7688_disconnect(struct anx7688 *anx7688)
> +{
> + union power_supply_propval val = {0,};
> + struct device *dev = anx7688->dev;
> + int ret;
> +
> + dev_dbg(dev, "cable removed\n");
> +
> + anx7688->current_update_deadline = 0;
> +
> + anx7688_set_hdmi_hpd(anx7688, 0);
> +
> + if (anx7688->vconn_on) {
> + regulator_disable(anx7688->supplies[ANX7688_VCONN_INDEX].consumer);
> + anx7688->vconn_on = false;
> + }
> +
> + if (anx7688->vbus_on) {
> + regulator_disable(anx7688->supplies[ANX7688_VBUS_INDEX].consumer);
> + anx7688->vbus_on = false;
> + }
> +
> + anx7688_power_disable(anx7688);
> +
> + anx7688->pd_capable = false;
> +
> + typec_unregister_partner(anx7688->partner);
> + anx7688->partner = NULL;
> +
> + anx7688->pwr_role = TYPEC_SINK;
> + anx7688->data_role = TYPEC_DEVICE;
> + typec_set_pwr_role(anx7688->port, anx7688->pwr_role);
> + typec_set_data_role(anx7688->port, anx7688->data_role);
> + typec_set_pwr_opmode(anx7688->port, TYPEC_PWR_MODE_USB);
> + typec_set_vconn_role(anx7688->port, TYPEC_SINK);
> +
> + usb_role_switch_set_role(anx7688->role_sw, USB_ROLE_NONE);
> +
> + val.intval = 500 * 1000;
> + dev_dbg(dev, "setting vbus_in current limit to %d mA\n", val.intval);
> + ret = power_supply_set_property(anx7688->vbus_in_supply,
> + POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
> + &val);
> + if (ret)
> + dev_err(dev, "failed to set vbus_in current to %d mA\n",
> + val.intval / 1000);
> +
> + val.intval = 0;
> + dev_dbg(dev, "disabling vbus_in power path\n");
> + ret = power_supply_set_property(anx7688->vbus_in_supply,
> + POWER_SUPPLY_PROP_ONLINE,
> + &val);
> + if (ret)
> + dev_err(dev, "failed to offline vbus_in\n");
> +
> + dev_dbg(dev, "enabling USB BC 1.2 detection\n");
> +
> + clear_bit(ANX7688_F_CONNECTED, anx7688->flags);
> +}
> +
> +static void anx7688_handle_cable_change(struct anx7688 *anx7688)
> +{
> + int cabledet;
> + bool connected;
> +
> + connected = test_bit(ANX7688_F_CONNECTED, anx7688->flags);
> + cabledet = gpiod_get_value(anx7688->gpio_cabledet);
> +
> + if (cabledet && !connected)
> + anx7688_connect(anx7688);
> + else if (!cabledet && connected)
> + anx7688_disconnect(anx7688);
> +}
> +
> +static irqreturn_t anx7688_irq_plug_handler(int irq, void *data)
> +{
> + struct anx7688 *anx7688 = data;
> +
> + dev_dbg(anx7688->dev, "plug irq (cd=%d)\n",
> + gpiod_get_value(anx7688->gpio_cabledet));
> +
> + /*
> + * After each cabledet change the scheduled work timer is reset
> + * to fire in ~10ms. So the work is done only after the cabledet
> + * is stable for ~10ms.
> + */
> + schedule_delayed_work(&anx7688->work, msecs_to_jiffies(10));
> +
> + return IRQ_HANDLED;
> +}
> +
> +enum {
> + CMD_SUCCESS,
> + CMD_REJECT,
> + CMD_FAIL,
> + CMD_BUSY,
> +};
> +
> +static const char * const anx7688_cmd_statuses[] = {
> + "SUCCESS",
> + "REJECT",
> + "FAIL",
> + "BUSY",
> +};
> +
> +static int anx7688_handle_pd_message_response(struct anx7688 *anx7688,
> + u8 to_cmd, u8 resp)
> +{
> + const char *status = resp <= CMD_BUSY ? anx7688_cmd_statuses[resp] : "UNKNOWN";
> +
> + switch (to_cmd) {
> + case ANX7688_OCM_MSG_PSWAP_REQ:
> + dev_info(anx7688->dev, "received response to PSWAP_REQ (%s)\n", status);
> + break;
> +
> + case ANX7688_OCM_MSG_DSWAP_REQ:
> + dev_info(anx7688->dev, "received response to DSWAP_REQ (%s)\n", status);
> + break;
> +
> + case ANX7688_OCM_MSG_VCONN_SWAP_REQ:
> + dev_info(anx7688->dev, "received response to VCONN_SWAP_REQ (%s)\n", status);
> + break;
> +
> + case ANX7688_OCM_MSG_PWR_OBJ_REQ:
> + dev_info(anx7688->dev, "received response to PWR_OBJ_REQ (%s)\n", status);
> + break;
> +
> + case ANX7688_OCM_MSG_VDM:
> + dev_info(anx7688->dev, "received response to VDM (%s)\n", status);
> + break;
> +
> + case ANX7688_OCM_MSG_GOTO_MIN_REQ:
> + dev_info(anx7688->dev, "received response to GOTO_MIN_REQ (%s)\n", status);
> + break;
> +
> + case ANX7688_OCM_MSG_GET_SNK_CAP:
> + dev_info(anx7688->dev, "received response to GET_SNK_CAP (%s)\n", status);
> + break;
> +
> + default:
> + dev_info(anx7688->dev, "received response to unknown request (%s)\n", status);
> + break;
> + }
> +
> + return 0;
> +}

Noise. Drop this whole function. If you need this kind of information,
then please consider trace points, or just use some debugfs trick like
what we have in drivers/usb/typec/tcpm/tcpm.c and few other drivers.

> +static int anx7688_handle_pd_message(struct anx7688 *anx7688,
> + u8 cmd, u8 *msg, unsigned int len)
> +{
> + struct device *dev = anx7688->dev;
> + union power_supply_propval psy_val = {0,};
> + uint32_t *pdos = (uint32_t *)msg;

u32

> + int ret, i, rdo_max_v, rdo_max_p;
> + uint32_t pdo, rdo;

u32

> + switch (cmd) {
> + case ANX7688_OCM_MSG_PWR_SRC_CAP:
> + dev_info(anx7688->dev, "received SRC_CAP\n");

Noise.

> +
> + if (len % 4 != 0) {
> + dev_warn(anx7688->dev, "received invalid sized PDO array\n");
> + break;
> + }
> +
> + /* the partner is PD capable */
> + anx7688->pd_capable = true;
> +
> + for (i = 0; i < len / 4; i++) {
> + pdo = le32_to_cpu(pdos[i]);
> +
> + if (pdo_type(pdo) == PDO_TYPE_FIXED) {
> + unsigned int voltage = pdo_fixed_voltage(pdo);
> + unsigned int max_curr = pdo_max_current(pdo);
> +
> + dev_info(anx7688->dev, "SRC_CAP PDO_FIXED (%umV %umA)\n", voltage, max_curr);

Noise.

> + } else if (pdo_type(pdo) == PDO_TYPE_BATT) {
> + unsigned int min_volt = pdo_min_voltage(pdo);
> + unsigned int max_volt = pdo_max_voltage(pdo);
> + unsigned int max_pow = pdo_max_power(pdo);
> +
> + dev_info(anx7688->dev, "SRC_CAP PDO_BATT (%umV-%umV %umW)\n", min_volt, max_volt, max_pow);

Noise. That line also really should be split in two.

I'm stopping my review here. This driver is too noisy. All dev_info
calls need to be dropped. If the driver is working correctly then it
needs to quiet.

Most of those prints are useful for debugging only, so I think similar
debugfs log like the one tcpm.c uses could be a good idea for them
since you already use debugfs in this driver in any case.

thanks,

> + } else if (pdo_type(pdo) == PDO_TYPE_VAR) {
> + unsigned int min_volt = pdo_min_voltage(pdo);
> + unsigned int max_volt = pdo_max_voltage(pdo);
> + unsigned int max_curr = pdo_max_current(pdo);
> +
> + dev_info(anx7688->dev, "SRC_CAP PDO_VAR (%umV-%umV %umA)\n", min_volt, max_volt, max_curr);
> + } else {
> + dev_info(anx7688->dev, "SRC_CAP PDO_APDO (0x%08X)\n", pdo);
> + }
> + }
> +
> + /* when auto_pd mode is enabled, the FW has already set
> + * RDO_MAX_VOLTAGE and RDO_MAX_POWER for the RDO it sent to the
> + * partner based on the received SOURCE_CAPs. This does not
> + * mean, the request was acked, but we can't do better here than
> + * calculate the current_limit to set later and hope for the best.
> + */
> + rdo_max_v = anx7688_reg_read(anx7688, ANX7688_REG_MAX_VOLTAGE_STATUS);
> + if (rdo_max_v < 0)
> + return rdo_max_v;
> + if (rdo_max_v == 0)
> + return -EINVAL;
> +
> + rdo_max_p = anx7688_reg_read(anx7688, ANX7688_REG_MAX_POWER_STATUS);
> + if (rdo_max_p < 0)
> + return rdo_max_p;
> +
> + anx7688->pd_current_limit = rdo_max_p * 5000 / rdo_max_v;
> +
> + dev_dbg(anx7688->dev, "RDO max voltage = %dmV, max power = %dmW, PD current limit = %dmA\n",
> + rdo_max_v * 100, rdo_max_p * 500, anx7688->pd_current_limit);
> +
> + // update current limit sooner, now that we have PD negotiation result
> + anx7688->current_update_deadline = ktime_add_ms(ktime_get(), 500);
> + break;
> +
> + case ANX7688_OCM_MSG_PWR_SNK_CAP:
> + dev_info(anx7688->dev, "received SNK_CAP\n");
> +
> + if (len % 4 != 0) {
> + dev_warn(anx7688->dev, "received invalid sized PDO array\n");
> + break;
> + }
> +
> + for (i = 0; i < len / 4; i++) {
> + pdo = le32_to_cpu(pdos[i]);
> +
> + if (pdo_type(pdo) == PDO_TYPE_FIXED) {
> + unsigned int voltage = pdo_fixed_voltage(pdo);
> + unsigned int max_curr = pdo_max_current(pdo);
> +
> + dev_info(anx7688->dev, "SNK_CAP PDO_FIXED (%umV %umA)\n", voltage, max_curr);
> + } else if (pdo_type(pdo) == PDO_TYPE_BATT) {
> + unsigned int min_volt = pdo_min_voltage(pdo);
> + unsigned int max_volt = pdo_max_voltage(pdo);
> + unsigned int max_pow = pdo_max_power(pdo);
> +
> + dev_info(anx7688->dev, "SNK_CAP PDO_BATT (%umV-%umV %umW)\n", min_volt, max_volt, max_pow);
> + } else if (pdo_type(pdo) == PDO_TYPE_VAR) {
> + unsigned int min_volt = pdo_min_voltage(pdo);
> + unsigned int max_volt = pdo_max_voltage(pdo);
> + unsigned int max_curr = pdo_max_current(pdo);
> +
> + dev_info(anx7688->dev, "SNK_CAP PDO_VAR (%umV-%umV %umA)\n", min_volt, max_volt, max_curr);
> + } else {
> + dev_info(anx7688->dev, "SNK_CAP PDO_APDO (0x%08X)\n", pdo);
> + }
> + }
> +
> + break;
> +
> + case ANX7688_OCM_MSG_PWR_OBJ_REQ:
> + dev_info(anx7688->dev, "received PWR_OBJ_REQ\n");
> +
> + anx7688->pd_capable = true;
> +
> + if (len != 4) {
> + dev_warn(anx7688->dev, "received invalid sized RDO\n");
> + break;
> + }
> +
> + rdo = le32_to_cpu(pdos[0]);
> +
> + if (rdo_index(rdo) >= 1 && rdo_index(rdo) <= anx7688->n_src_caps) {
> + unsigned int rdo_op_curr = rdo_op_current(rdo);
> + unsigned int rdo_max_curr = rdo_max_current(rdo);
> + unsigned int rdo_idx = rdo_index(rdo) - 1;
> + unsigned int pdo_volt, pdo_max_curr;
> +
> + pdo = anx7688->src_caps[rdo_idx];
> + pdo_volt = pdo_fixed_voltage(pdo);
> + pdo_max_curr = pdo_max_current(pdo);
> +
> + dev_info(anx7688->dev, "RDO (idx=%d op=%umA max=%umA)\n",
> + rdo_idx, rdo_op_curr, rdo_max_curr);
> +
> + dev_info(anx7688->dev, "PDO_FIXED (%umV %umA)\n",
> + pdo_volt, pdo_max_curr);
> +
> + // We could check the req and respond with accept/reject
> + // but we're using auto_pd feature, so the FW will do
> + // this for us
> + } else {
> + dev_info(anx7688->dev, "PWR_OBJ RDO index out of range (RDO = 0x%08X)\n", rdo);
> + }
> +
> + break;
> +
> + case ANX7688_OCM_MSG_ACCEPT:
> + dev_info(anx7688->dev, "received ACCEPT\n");
> + break;
> +
> + case ANX7688_OCM_MSG_REJECT:
> + dev_info(anx7688->dev, "received REJECT\n");
> + break;
> +
> + case ANX7688_OCM_MSG_RESPONSE_TO_REQ:
> + if (len < 2) {
> + dev_warn(anx7688->dev, "received short RESPONSE_TO_REQ\n");
> + break;
> + }
> +
> + anx7688_handle_pd_message_response(anx7688, msg[0], msg[1]);
> + break;
> +
> + case ANX7688_OCM_MSG_SOFT_RST:
> + dev_info(anx7688->dev, "received SOFT_RST\n");
> + break;
> +
> + case ANX7688_OCM_MSG_HARD_RST:
> + if (anx7688->pd_capable) {
> + dev_info(anx7688->dev, "received HARD_RST\n");
> +
> + // stop drawing power from VBUS
> + psy_val.intval = 0;
> + dev_dbg(dev, "disabling vbus_in power path\n");
> + ret = power_supply_set_property(anx7688->vbus_in_supply,
> + POWER_SUPPLY_PROP_ONLINE,
> + &psy_val);
> + if (ret)
> + dev_err(anx7688->dev, "failed to offline vbus_in\n");
> +
> + // wait till the dust settles
> + anx7688->current_update_deadline = ktime_add_ms(ktime_get(), 3000);
> + } else {
> + dev_dbg(anx7688->dev, "received HARD_RST, idiot firmware is bored\n");
> + }
> +
> + break;
> +
> + case ANX7688_OCM_MSG_RESTART:
> + dev_info(anx7688->dev, "received RESTART\n");
> + break;
> +
> + case ANX7688_OCM_MSG_PSWAP_REQ:
> + dev_info(anx7688->dev, "received PSWAP_REQ\n");
> + break;
> +
> + case ANX7688_OCM_MSG_DSWAP_REQ:
> + dev_info(anx7688->dev, "received DSWAP_REQ\n");
> + break;
> +
> + case ANX7688_OCM_MSG_VCONN_SWAP_REQ:
> + dev_info(anx7688->dev, "received VCONN_SWAP_REQ\n");
> + break;
> +
> + case ANX7688_OCM_MSG_DP_ALT_ENTER:
> + dev_info(anx7688->dev, "received DP_ALT_ENTER\n");
> + break;
> +
> + case ANX7688_OCM_MSG_DP_ALT_EXIT:
> + dev_info(anx7688->dev, "received DP_ALT_EXIT\n");
> + break;
> +
> + case ANX7688_OCM_MSG_DP_SNK_IDENTITY:
> + dev_info(anx7688->dev, "received DP_SNK_IDENTITY\n");
> + break;
> +
> + case ANX7688_OCM_MSG_SVID:
> + dev_info(anx7688->dev, "received SVID\n");
> + break;
> +
> + case ANX7688_OCM_MSG_VDM:
> + dev_info(anx7688->dev, "received VDM\n");
> + break;
> +
> + case ANX7688_OCM_MSG_GOTO_MIN_REQ:
> + dev_info(anx7688->dev, "received GOTO_MIN_REQ\n");
> + break;
> +
> + case ANX7688_OCM_MSG_PD_STATUS_REQ:
> + dev_info(anx7688->dev, "received PD_STATUS_REQ\n");
> + break;
> +
> + case ANX7688_OCM_MSG_GET_DP_SNK_CAP:
> + dev_info(anx7688->dev, "received GET_DP_SNK_CAP\n");
> + break;
> +
> + case ANX7688_OCM_MSG_DP_SNK_CFG:
> + dev_info(anx7688->dev, "received DP_SNK_CFG\n");
> + break;
> +
> + default:
> + dev_info(anx7688->dev, "received unknown message 0x%02x\n", cmd);
> + break;
> + }
> +
> + return 0;
> +}
> +
> +static int anx7688_receive_msg(struct anx7688 *anx7688)
> +{
> + u8 pkt[32], checksum = 0;
> + int i, ret;
> +
> + ret = i2c_smbus_read_i2c_block_data(anx7688->client_tcpc,
> + ANX7688_TCPC_REG_INTERFACE_RECV,
> + 32, pkt);
> + if (ret < 0) {
> + dev_err(anx7688->dev, "failed to read pd msg\n");
> + return ret;
> + }
> +
> + ret = anx7688_tcpc_reg_write(anx7688, ANX7688_TCPC_REG_INTERFACE_RECV, 0);
> + if (ret)
> + dev_warn(anx7688->dev, "failed to clear recv FIFO\n");
> +
> + if (pkt[0] == 0 || pkt[0] > sizeof(pkt) - 2) {
> + dev_err(anx7688->dev, "received invalid pd message: %*ph\n",
> + (int)sizeof(pkt), pkt);
> + return -EINVAL;
> + }
> +
> + dev_dbg(anx7688->dev, "recv ocm message cmd=0x%02x %*ph\n",
> + pkt[1], pkt[0] + 2, pkt);
> +
> + for (i = 0; i < pkt[0] + 2; i++)
> + checksum += pkt[i];
> +
> + if (checksum != 0) {
> + dev_err(anx7688->dev, "bad checksum on received message\n");
> + return -EINVAL;
> + }
> +
> + anx7688_handle_pd_message(anx7688, pkt[1], pkt + 2, pkt[0] - 1);
> + return 0;
> +}
> +
> +static const char *anx7688_cc_status_string(unsigned int v)
> +{
> + switch (v) {
> + case 0: return "SRC.Open";
> + case 1: return "SRC.Rd";
> + case 2: return "SRC.Ra";
> + case 4: return "SNK.Default";
> + case 8: return "SNK.Power1.5";
> + case 12: return "SNK.Power3.0";
> + default: return "UNK";
> + }
> +}
> +
> +static int anx7688_update_status(struct anx7688 *anx7688)
> +{
> + struct device *dev = anx7688->dev;
> + bool vbus_on, vconn_on, dr_dfp;
> + int status, cc_status, dp_state, dp_substate, ret;
> +
> + status = anx7688_reg_read(anx7688, ANX7688_REG_STATUS);
> + if (status < 0)
> + return status;
> +
> + cc_status = anx7688_reg_read(anx7688, ANX7688_REG_CC_STATUS);
> + if (cc_status < 0)
> + return cc_status;
> +
> + dp_state = anx7688_tcpc_reg_read(anx7688, 0x87);
> + if (dp_state < 0)
> + return dp_state;
> +
> + dp_substate = anx7688_tcpc_reg_read(anx7688, 0x88);
> + if (dp_substate < 0)
> + return dp_substate;
> +
> + anx7688_set_hdmi_hpd(anx7688, dp_state >= 3);
> +
> + dp_state = (dp_state << 8) | dp_substate;
> +
> + if (anx7688->last_status == -1 || anx7688->last_status != status) {
> + anx7688->last_status = status;
> + dev_dbg(dev, "status changed to 0x%02x\n", status);
> + }
> +
> + if (anx7688->last_cc_status == -1 || anx7688->last_cc_status != cc_status) {
> + anx7688->last_cc_status = cc_status;
> + dev_dbg(dev, "cc_status changed to CC1 = %s CC2 = %s\n",
> + anx7688_cc_status_string(cc_status & 0xf),
> + anx7688_cc_status_string((cc_status >> 4) & 0xf));
> + }
> +
> + if (anx7688->last_dp_state == -1 || anx7688->last_dp_state != dp_state) {
> + anx7688->last_dp_state = dp_state;
> + dev_dbg(dev, "DP state changed to 0x%04x\n", dp_state);
> + }
> +
> + vbus_on = !!(status & ANX7688_VBUS_STATUS);
> + vconn_on = !!(status & ANX7688_VCONN_STATUS);
> + dr_dfp = !!(status & ANX7688_DATA_ROLE_STATUS);
> +
> + if (anx7688->vbus_on != vbus_on) {
> + dev_dbg(anx7688->dev, "POWER role change to %s\n",
> + vbus_on ? "SOURCE" : "SINK");
> +
> + if (vbus_on) {
> + ret = regulator_enable(anx7688->supplies[ANX7688_VBUS_INDEX].consumer);
> + if (ret) {
> + dev_err(anx7688->dev, "failed to enable vbus\n");
> + return ret;
> + }
> + } else {
> + ret = regulator_disable(anx7688->supplies[ANX7688_VBUS_INDEX].consumer);
> + if (ret) {
> + dev_err(anx7688->dev, "failed to disable vbus\n");
> + return ret;
> + }
> + }
> +
> + anx7688->pwr_role = vbus_on ? TYPEC_SOURCE : TYPEC_SINK;
> + typec_set_pwr_role(anx7688->port, anx7688->pwr_role);
> + anx7688->vbus_on = vbus_on;
> + }
> +
> + if (anx7688->vconn_on != vconn_on) {
> + dev_dbg(anx7688->dev, "VCONN role change to %s\n",
> + vconn_on ? "SOURCE" : "SINK");
> +
> + if (vconn_on) {
> + ret = regulator_enable(anx7688->supplies[ANX7688_VCONN_INDEX].consumer);
> + if (ret) {
> + dev_err(anx7688->dev, "failed to enable vconn\n");
> + return ret;
> + }
> + } else {
> + ret = regulator_disable(anx7688->supplies[ANX7688_VCONN_INDEX].consumer);
> + if (ret) {
> + dev_err(anx7688->dev, "failed to disable vconn\n");
> + return ret;
> + }
> + }
> +
> + typec_set_vconn_role(anx7688->port, vconn_on ? TYPEC_SOURCE : TYPEC_SINK);
> + anx7688->vconn_on = vconn_on;
> + }
> +
> + anx7688->data_role = dr_dfp ? TYPEC_HOST : TYPEC_DEVICE;
> + typec_set_data_role(anx7688->port, anx7688->data_role);
> +
> + if (usb_role_switch_get_role(anx7688->role_sw) !=
> + (dr_dfp ? USB_ROLE_HOST : USB_ROLE_DEVICE)) {
> + dev_dbg(anx7688->dev, "DATA role change requested to %s\n",
> + dr_dfp ? "DFP" : "UFP");
> +
> + ret = usb_role_switch_set_role(anx7688->role_sw,
> + dr_dfp ? USB_ROLE_HOST : USB_ROLE_DEVICE);
> + if (ret)
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +static irqreturn_t anx7688_irq_status_handler(int irq, void *data)
> +{
> + struct anx7688 *anx7688 = data;
> + struct device *dev = anx7688->dev;
> + int tcpc_status, ext2_status, soft_status;
> +
> + mutex_lock(&anx7688->lock);
> +
> + if (!test_bit(ANX7688_F_CONNECTED, anx7688->flags)) {
> + dev_dbg(dev, "spurious status irq\n");
> + /*
> + * anx chip should be disabled and power off, nothing
> + * more to do
> + */
> + goto out_unlock;
> + }
> +
> + // clear tcpc interrupt
> + tcpc_status = anx7688_tcpc_reg_read(anx7688, ANX7688_TCPC_REG_ALERT0);
> + if (tcpc_status > 0)
> + anx7688_tcpc_reg_write(anx7688, ANX7688_TCPC_REG_ALERT0, tcpc_status);
> +
> + ext2_status = anx7688_reg_read(anx7688, ANX7688_REG_IRQ_EXT_SOURCE2);
> + if (ext2_status & ANX7688_IRQ2_SOFT_INT) {
> + soft_status = anx7688_reg_read(anx7688, ANX7688_REG_STATUS_INT);
> + anx7688_reg_write(anx7688, ANX7688_REG_STATUS_INT, 0);
> +
> + if (soft_status > 0) {
> + soft_status &= ANX7688_SOFT_INT_MASK;
> +
> + if (soft_status & ANX7688_IRQS_RECEIVED_MSG)
> + anx7688_receive_msg(anx7688);
> +
> + if (soft_status & (ANX7688_IRQS_CC_STATUS_CHANGE |
> + ANX7688_IRQS_VBUS_CHANGE |
> + ANX7688_IRQS_VCONN_CHANGE |
> + ANX7688_IRQS_DATA_ROLE_CHANGE)) {
> + anx7688_update_status(anx7688);
> + }
> + }
> +
> + anx7688_reg_write(anx7688, ANX7688_REG_IRQ_EXT_SOURCE2, ANX7688_IRQ2_SOFT_INT);
> + }
> +
> +out_unlock:
> + mutex_unlock(&anx7688->lock);
> +
> + return IRQ_HANDLED;
> +}
> +
> +static int anx7688_dr_set(struct typec_port *port, enum typec_data_role role)
> +{
> + struct anx7688 *anx7688 = typec_get_drvdata(port);
> + int ret = 0;
> +
> + dev_info(anx7688->dev, "data role set %d\n", role);
> +
> + if (anx7688->data_role != role) {
> + mutex_lock(&anx7688->lock);
> + ret = anx7688_send_ocm_message(anx7688, ANX7688_OCM_MSG_DSWAP_REQ, 0, 0);
> + mutex_unlock(&anx7688->lock);
> + }
> +
> + return ret;
> +}
> +
> +static int anx7688_pr_set(struct typec_port *port, enum typec_role role)
> +{
> + struct anx7688 *anx7688 = typec_get_drvdata(port);
> + int ret = 0;
> +
> + dev_info(anx7688->dev, "power role set %d\n", role);
> +
> + if (anx7688->pwr_role != role) {
> + mutex_lock(&anx7688->lock);
> + ret = anx7688_send_ocm_message(anx7688, ANX7688_OCM_MSG_PSWAP_REQ, 0, 0);
> + mutex_unlock(&anx7688->lock);
> + }
> +
> + return ret;
> +}
> +
> +/*
> + * Calls to the EEPROM functions need to be taken under the anx7688 lock.
> + */
> +static int anx7688_eeprom_set_address(struct anx7688 *anx7688, u16 addr)
> +{
> + int ret;
> +
> + ret = anx7688_reg_write(anx7688, 0xe0, (addr >> 8) & 0xff);
> + if (ret < 0)
> + return ret;
> +
> + return anx7688_reg_write(anx7688, 0xe1, addr & 0xff);
> +}
> +
> +static int anx7688_eeprom_wait_done(struct anx7688 *anx7688)
> +{
> + ktime_t timeout;
> + int ret;
> +
> + // wait for read to be done
> + timeout = ktime_add_us(ktime_get(), 50000);
> + while (true) {
> + ret = anx7688_reg_read(anx7688, 0xe2);
> + if (ret < 0)
> + return ret;
> +
> + if (ret & BIT(3))
> + return 0;
> +
> + if (ktime_after(ktime_get(), timeout)) {
> + dev_err(anx7688->dev, "timeout waiting for eeprom\n");
> + return -ETIMEDOUT;
> + }
> + }
> +}
> +
> +/* wait for internal FSM of EEPROM to be in a state ready for
> + * programming/reading
> + */
> +static int anx7688_eeprom_wait_ready(struct anx7688 *anx7688)
> +{
> + ktime_t timeout;
> + int ret;
> +
> + // wait until eeprom is ready
> + timeout = ktime_add_us(ktime_get(), 1000000);
> + while (true) {
> + ret = anx7688_reg_read(anx7688, 0x7f);
> + if (ret < 0)
> + return ret;
> +
> + if ((ret & 0x0f) == 7)
> + return 0;
> +
> + if (ktime_after(ktime_get(), timeout)) {
> + dev_err(anx7688->dev, "timeout waiting for eeprom to initialize\n");
> + return -ETIMEDOUT;
> + }
> +
> + msleep(5);
> + }
> +}
> +
> +static int anx7688_eeprom_read(struct anx7688 *anx7688, unsigned int addr, u8 buf[16])
> +{
> + int ret;
> +
> + ret = anx7688_eeprom_set_address(anx7688, addr);
> + if (ret)
> + return ret;
> +
> + // initiate read
> + ret = anx7688_reg_write(anx7688, 0xe2, 0x06);
> + if (ret < 0)
> + return ret;
> +
> + ret = anx7688_eeprom_wait_done(anx7688);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_read_i2c_block_data(anx7688->client, 0xd0, 16, buf);
> + if (ret < 0) {
> + dev_err(anx7688->dev,
> + "failed to read eeprom data (err=%d)\n", ret);
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +static const struct typec_operations anx7688_typec_ops = {
> + .dr_set = anx7688_dr_set,
> + .pr_set = anx7688_pr_set,
> +};
> +
> +/*
> + * This function has to work when the ANX7688 is active, and when
> + * it is powered down. It power cycles the chip and asserts the OCM
> + * reset, to prevent OCM FW interfering with EEPROM reading.
> + *
> + * After reading EEPROM, the reconnection is scheduled.
> + */
> +static int anx7688_firmware_show(struct seq_file *s, void *data)
> +{
> + struct anx7688 *anx7688 = s->private;
> + unsigned int addr;
> + u8 buf[16];
> + int ret;
> +
> + mutex_lock(&anx7688->lock);
> +
> + if (test_bit(ANX7688_F_CONNECTED, anx7688->flags))
> + anx7688_disconnect(anx7688);
> +
> + msleep(20);
> +
> + anx7688_power_enable(anx7688);
> +
> + ret = anx7688_reg_update_bits(anx7688, ANX7688_REG_USBC_RESET_CTRL,
> + ANX7688_USBC_RESET_CTRL_OCM_RESET,
> + ANX7688_USBC_RESET_CTRL_OCM_RESET);
> + if (ret < 0)
> + goto out_powerdown;
> +
> + ret = anx7688_eeprom_wait_ready(anx7688);
> + if (ret)
> + goto out_powerdown;
> +
> + msleep(10);
> +
> + for (addr = 0x10; addr < 0x10000; addr += 16) {
> + // set address
> + ret = anx7688_eeprom_read(anx7688, addr, buf);
> + if (ret < 0)
> + goto out_powerdown;
> +
> + seq_write(s, buf, sizeof(buf));
> + }
> +
> +out_powerdown:
> + anx7688_power_disable(anx7688);
> + schedule_delayed_work(&anx7688->work, 0);
> + mutex_unlock(&anx7688->lock);
> +
> + return ret;
> +}
> +DEFINE_SHOW_ATTRIBUTE(anx7688_firmware);
> +
> +static int anx7688_regs_show(struct seq_file *s, void *data)
> +{
> + struct anx7688 *anx7688 = s->private;
> + u8 buf[16];
> + unsigned int i, addr;
> + int ret = -ENODEV;
> +
> + mutex_lock(&anx7688->lock);
> +
> + if (!test_bit(ANX7688_F_POWERED, anx7688->flags))
> + goto out_unlock;
> +
> + for (addr = 0; addr < 256; addr += 16) {
> + ret = i2c_smbus_read_i2c_block_data(anx7688->client, addr,
> + sizeof(buf), buf);
> + if (ret < 0) {
> + dev_err(anx7688->dev,
> + "failed to read registers (err=%d)\n", ret);
> + goto out_unlock;
> + }
> +
> + for (i = 0; i < 16; i++)
> + seq_printf(s, "50%02x: %02x\n", addr + i, buf[i]);
> + }
> +
> + for (addr = 0; addr < 256; addr += 16) {
> + ret = i2c_smbus_read_i2c_block_data(anx7688->client_tcpc, addr,
> + sizeof(buf), buf);
> + if (ret < 0) {
> + dev_err(anx7688->dev,
> + "failed to read registers (err=%d)\n", ret);
> + goto out_unlock;
> + }
> +
> + for (i = 0; i < 16; i++)
> + seq_printf(s, "58%02x: %02x\n", addr + i, buf[i]);
> + }
> +
> +out_unlock:
> + mutex_unlock(&anx7688->lock);
> +
> + return ret;
> +}
> +DEFINE_SHOW_ATTRIBUTE(anx7688_regs);
> +
> +static int anx7688_status_show(struct seq_file *s, void *data)
> +{
> + struct anx7688 *anx7688 = s->private;
> +
> + mutex_lock(&anx7688->lock);
> +
> + seq_puts(s, "not much\n");
> +
> + mutex_unlock(&anx7688->lock);
> +
> + return 0;
> +}
> +DEFINE_SHOW_ATTRIBUTE(anx7688_status);
> +
> +/*
> + * This is just a 1s watchdog checking the state if cabledet pin.
> + */
> +static void anx7688_cabledet_timer_fn(struct timer_list *t)
> +{
> + struct anx7688 *anx7688 = from_timer(anx7688, t, work_timer);
> +
> + schedule_delayed_work(&anx7688->work, 0);
> + mod_timer(t, jiffies + msecs_to_jiffies(1000));
> +}
> +
> +static void anx7688_handle_vbus_in_notify(struct anx7688 *anx7688)
> +{
> + union power_supply_propval psy_val = {0,};
> + struct device *dev = anx7688->dev;
> + int ret;
> +
> + ret = power_supply_get_property(anx7688->vbus_in_supply,
> + POWER_SUPPLY_PROP_USB_TYPE,
> + &psy_val);
> + if (ret) {
> + dev_err(dev, "failed to get USB BC1.2 result\n");
> + return;
> + }
> +
> + if (anx7688->last_bc_result == psy_val.intval)
> + return;
> +
> + anx7688->last_bc_result = psy_val.intval;
> +
> + switch (psy_val.intval) {
> + case POWER_SUPPLY_USB_TYPE_DCP:
> + case POWER_SUPPLY_USB_TYPE_CDP:
> + dev_dbg(dev, "BC 1.2 result: DCP or CDP\n");
> + break;
> + case POWER_SUPPLY_USB_TYPE_SDP:
> + default:
> + dev_dbg(dev, "BC 1.2 result: SDP\n");
> + break;
> + }
> +}
> +
> +static int anx7688_cc_status(unsigned int v)
> +{
> + switch (v) {
> + case 0: return -1;
> + case 1: return -1;
> + case 2: return -1;
> + case 4: return TYPEC_PWR_MODE_USB;
> + case 8: return TYPEC_PWR_MODE_1_5A;
> + case 12: return TYPEC_PWR_MODE_3_0A;
> + default: return -1;
> + }
> +}
> +
> +static const char *anx7688_get_power_mode_name(enum typec_pwr_opmode mode)
> +{
> + switch (mode) {
> + case TYPEC_PWR_MODE_USB: return "USB";
> + case TYPEC_PWR_MODE_1_5A: return "1.5A";
> + case TYPEC_PWR_MODE_3_0A: return "3.0A";
> + case TYPEC_PWR_MODE_PD: return "PD";
> + default: return "Unknown";
> + }
> +}
> +
> +/*
> + * This is called after 500ms after connection when the PD contract should have
> + * been negotiated. We should inspect CC pins or PD status here and decide what
> + * input current limit to set.
> + */
> +static void anx7688_handle_current_update(struct anx7688 *anx7688)
> +{
> + unsigned int cc_status = anx7688->last_cc_status;
> + union power_supply_propval val = {0,};
> + struct device *dev = anx7688->dev;
> + int pwr_mode, ret, current_limit = 0;
> +
> + if (anx7688->pd_capable) {
> + pwr_mode = TYPEC_PWR_MODE_PD;
> + } else if (cc_status < 0) {
> + pwr_mode = TYPEC_PWR_MODE_USB;
> + } else {
> + pwr_mode = anx7688_cc_status(cc_status & 0xf);
> + if (pwr_mode < 0)
> + pwr_mode = anx7688_cc_status((cc_status >> 4) & 0xf);
> + if (pwr_mode < 0)
> + pwr_mode = TYPEC_PWR_MODE_USB;
> + }
> +
> + if (pwr_mode == TYPEC_PWR_MODE_1_5A)
> + current_limit = 1500;
> + else if (pwr_mode == TYPEC_PWR_MODE_3_0A)
> + current_limit = 3000;
> + else if (pwr_mode == TYPEC_PWR_MODE_PD)
> + current_limit = anx7688->pd_current_limit;
> +
> + anx7688->input_current_limit = current_limit;
> +
> + dev_info(anx7688->dev, "updating power mode to %s, current limit %dmA (0 => BC1.2)\n",
> + anx7688_get_power_mode_name(pwr_mode), current_limit);
> +
> + if (current_limit) {
> + /*
> + * Disable BC1.2 detection, because we'll be setting
> + * a current limit determined by USB-PD
> + */
> + dev_dbg(dev, "disabling USB BC 1.2 detection\n");
> +
> + val.intval = current_limit * 1000;
> + dev_dbg(dev, "setting vbus_in current limit to %d mA\n", current_limit);
> + ret = power_supply_set_property(anx7688->vbus_in_supply,
> + POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
> + &val);
> + if (ret)
> + dev_err(dev, "failed to set vbus_in current to %d mA\n",
> + current_limit);
> + }
> + /*
> + * else use the result of BC1.2 detection performed by PMIC.
> + */
> +
> + /* Turn on VBUS power path inside PMIC. */
> + val.intval = 1;
> + dev_dbg(dev, "enabling vbus_in power path\n");
> + ret = power_supply_set_property(anx7688->vbus_in_supply,
> + POWER_SUPPLY_PROP_ONLINE,
> + &val);
> + if (ret)
> + dev_err(anx7688->dev, "failed to enable vbus_in\n");
> +
> + typec_set_pwr_opmode(anx7688->port, pwr_mode);
> +}
> +
> +static int anx7688_vbus_in_notify(struct notifier_block *nb,
> + unsigned long val, void *v)
> +{
> + struct anx7688 *anx7688 = container_of(nb, struct anx7688, vbus_in_nb);
> + struct power_supply *psy = v;
> +
> + /* atomic context */
> + if (val == PSY_EVENT_PROP_CHANGED && psy == anx7688->vbus_in_supply) {
> + set_bit(ANX7688_F_PWRSUPPLY_CHANGE, anx7688->flags);
> + schedule_delayed_work(&anx7688->work, 0);
> + }
> +
> + return NOTIFY_OK;
> +}
> +
> +static void anx7688_work(struct work_struct *work)
> +{
> + struct anx7688 *anx7688 = container_of(work, struct anx7688, work.work);
> +
> + if (test_bit(ANX7688_F_FW_FAILED, anx7688->flags))
> + return;
> +
> + mutex_lock(&anx7688->lock);
> +
> + if (test_and_clear_bit(ANX7688_F_PWRSUPPLY_CHANGE, anx7688->flags))
> + anx7688_handle_vbus_in_notify(anx7688);
> +
> + anx7688_handle_cable_change(anx7688);
> +
> + if (test_bit(ANX7688_F_CONNECTED, anx7688->flags)) {
> + /*
> + * We check status periodically outside of interrupt, just to
> + * be sure we didn't miss any status interrupts
> + */
> + anx7688_update_status(anx7688);
> +
> + if (anx7688->current_update_deadline &&
> + ktime_after(ktime_get(), anx7688->current_update_deadline)) {
> + anx7688->current_update_deadline = 0;
> + anx7688_handle_current_update(anx7688);
> + }
> + }
> +
> + mutex_unlock(&anx7688->lock);
> +}
> +
> +static int anx7688_parse_connector(struct device *dev, struct anx7688 *anx7688, struct typec_capability *cap)
> +{
> + struct fwnode_handle *fwnode;
> + const char *buf;
> + int ret;
> +
> + fwnode = device_get_named_child_node(dev, "connector");
> + if (!fwnode)
> + return -EINVAL;
> +
> + ret = fwnode_property_read_string(fwnode, "power-role", &buf);
> + if (ret) {
> + dev_err(dev, "power-role not found: %d\n", ret);
> + return ret;
> + }
> +
> + ret = typec_find_port_power_role(buf);
> + if (ret < 0)
> + return ret;
> + cap->type = ret;
> +
> + ret = fwnode_property_read_string(fwnode, "data-role", &buf);
> + if (ret) {
> + dev_err(dev, "data-role not found: %d\n", ret);
> + return ret;
> + }
> +
> + ret = typec_find_port_data_role(buf);
> + if (ret < 0)
> + return ret;
> + cap->data = ret;
> +
> + ret = fwnode_property_read_string(fwnode, "try-power-role", &buf);
> + if (ret) {
> + dev_err(dev, "try-power-role not found: %d\n", ret);
> + return ret;
> + }
> +
> + ret = typec_find_power_role(buf);
> + if (ret < 0)
> + return ret;
> + cap->prefer_role = ret;
> +
> + /* Get source pdos */
> + ret = fwnode_property_count_u32(fwnode, "source-pdos");
> + if (ret <= 0)
> + return -EINVAL;
> +
> + anx7688->n_src_caps = min_t(u8, ret, ARRAY_SIZE(anx7688->src_caps));
> + ret = fwnode_property_read_u32_array(fwnode, "source-pdos",
> + anx7688->src_caps,
> + anx7688->n_src_caps);
> + if (ret < 0) {
> + dev_err(dev, "source cap validate failed: %d\n", ret);
> + return -EINVAL;
> + }
> +
> + ret = fwnode_property_count_u32(fwnode, "sink-pdos");
> + if (ret <= 0)
> + return -EINVAL;
> +
> + anx7688->n_snk_caps = min_t(u8, ret, ARRAY_SIZE(anx7688->snk_caps));
> + ret = fwnode_property_read_u32_array(fwnode, "sink-pdos",
> + anx7688->snk_caps,
> + anx7688->n_snk_caps);
> + if (ret < 0) {
> + dev_err(dev, "sink cap validate failed: %d\n", ret);
> + return -EINVAL;
> + }
> +
> + return 0;
> +}
> +
> +static int anx7688_i2c_probe(struct i2c_client *client)
> +{
> + struct anx7688 *anx7688;
> + struct device *dev = &client->dev;
> + struct typec_capability typec_cap = { };
> + int i, vid_h, vid_l;
> + int irq_cabledet;
> + int ret = 0;
> +
> + anx7688 = devm_kzalloc(dev, sizeof(*anx7688), GFP_KERNEL);
> + if (!anx7688)
> + return -ENOMEM;
> +
> + i2c_set_clientdata(client, anx7688);
> + anx7688->client = client;
> + anx7688->dev = &client->dev;
> + mutex_init(&anx7688->lock);
> + INIT_DELAYED_WORK(&anx7688->work, anx7688_work);
> + anx7688->last_extcon_state = -1;
> +
> + ret = anx7688_parse_connector(dev, anx7688, &typec_cap);
> + if (ret < 0) {
> + dev_err(dev, "failed to parse connector from DT\n");
> + return ret;
> + }
> +
> + for (i = 0; i < ANX7688_NUM_SUPPLIES; i++)
> + anx7688->supplies[i].supply = anx7688_supply_names[i];
> + ret = devm_regulator_bulk_get(dev, ANX7688_NUM_SUPPLIES,
> + anx7688->supplies);
> + if (ret)
> + return ret;
> +
> + anx7688->vbus_in_supply =
> + devm_power_supply_get_by_phandle(dev, "vbus-in-supply");
> + if (IS_ERR(anx7688->vbus_in_supply)) {
> + dev_err(dev, "Couldn't get the VBUS power supply\n");
> + return PTR_ERR(anx7688->vbus_in_supply);
> + }
> +
> + if (!anx7688->vbus_in_supply)
> + return -EPROBE_DEFER;
> +
> + anx7688->gpio_enable = devm_gpiod_get(dev, "enable", GPIOD_OUT_LOW);
> + if (IS_ERR(anx7688->gpio_enable)) {
> + dev_err(dev, "Could not get enable gpio\n");
> + return PTR_ERR(anx7688->gpio_enable);
> + }
> +
> + anx7688->gpio_reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
> + if (IS_ERR(anx7688->gpio_reset)) {
> + dev_err(dev, "Could not get reset gpio\n");
> + return PTR_ERR(anx7688->gpio_reset);
> + }
> +
> + anx7688->gpio_cabledet = devm_gpiod_get(dev, "cabledet", GPIOD_IN);
> + if (IS_ERR(anx7688->gpio_cabledet)) {
> + dev_err(dev, "Could not get cabledet gpio\n");
> + return PTR_ERR(anx7688->gpio_cabledet);
> + }
> +
> + irq_cabledet = gpiod_to_irq(anx7688->gpio_cabledet);
> + if (irq_cabledet < 0) {
> + dev_err(dev, "Could not get cabledet irq\n");
> + return irq_cabledet;
> + }
> +
> + // Initialize extcon device
> + anx7688->extcon = devm_extcon_dev_allocate(dev, anx7688_extcon_cable);
> + if (IS_ERR(anx7688->extcon))
> + return -ENOMEM;
> +
> + ret = devm_extcon_dev_register(dev, anx7688->extcon);
> + if (ret) {
> + dev_err(dev, "failed to register extcon device\n");
> + return ret;
> + }
> +
> + // Register the TCPC i2c interface as second interface (0x58)
> + anx7688->client_tcpc = i2c_new_dummy_device(client->adapter, 0x2c);
> + if (IS_ERR(anx7688->client_tcpc)) {
> + dev_err(dev, "Could not register tcpc i2c client\n");
> + return PTR_ERR(anx7688->client_tcpc);
> + }
> + i2c_set_clientdata(anx7688->client_tcpc, anx7688);
> +
> + // powerup and probe the ANX chip
> +
> + ret = regulator_bulk_enable(ANX7688_NUM_ALWAYS_ON_SUPPLIES,
> + anx7688->supplies);
> + if (ret) {
> + dev_err(dev, "Could not enable regulators\n");
> + goto err_dummy_dev;
> + }
> +
> + msleep(10);
> +
> + anx7688_power_enable(anx7688);
> +
> + vid_l = anx7688_tcpc_reg_read(anx7688, ANX7688_TCPC_REG_VENDOR_ID0);
> + vid_h = anx7688_tcpc_reg_read(anx7688, ANX7688_TCPC_REG_VENDOR_ID1);
> + if (vid_l < 0 || vid_h < 0) {
> + ret = vid_l < 0 ? vid_l : vid_h;
> + anx7688_power_disable(anx7688);
> + goto err_disable_reg;
> + }
> +
> + dev_info(dev, "Vendor id 0x%04x\n", vid_l | vid_h << 8);
> +
> + anx7688_power_disable(anx7688);
> +
> + anx7688->role_sw = usb_role_switch_get(dev);
> + if (IS_ERR(anx7688->role_sw)) {
> + dev_err(dev, "Could not get role switch\n");
> + ret = PTR_ERR(anx7688->role_sw);
> + goto err_disable_reg;
> + }
> +
> + // setup a typec port device
> + typec_cap.revision = USB_TYPEC_REV_1_2;
> + typec_cap.pd_revision = 0x200;
> + ret = -EINVAL;
> + if (typec_cap.type != TYPEC_PORT_DRP)
> + goto err_disable_reg;
> + if (typec_cap.data != TYPEC_PORT_DRD)
> + goto err_disable_reg;
> + typec_cap.driver_data = anx7688;
> + typec_cap.ops = &anx7688_typec_ops;
> +
> + anx7688->port = typec_register_port(dev, &typec_cap);
> + if (IS_ERR(anx7688->port)) {
> + dev_err(dev, "Could not register type-c port\n");
> + ret = PTR_ERR(anx7688->port);
> + goto err_role_sw;
> + }
> +
> + anx7688->pwr_role = TYPEC_SINK;
> + anx7688->data_role = TYPEC_DEVICE;
> + typec_set_pwr_role(anx7688->port, anx7688->pwr_role);
> + typec_set_data_role(anx7688->port, anx7688->data_role);
> + typec_set_pwr_opmode(anx7688->port, TYPEC_PWR_MODE_USB);
> + typec_set_vconn_role(anx7688->port, TYPEC_SINK);
> +
> + // make sure BC1.2 detection in PMIC is enabled
> + anx7688->last_bc_result = -1;
> +
> + dev_dbg(dev, "enabling USB BC 1.2 detection\n");
> +
> + ret = devm_request_irq(dev, irq_cabledet, anx7688_irq_plug_handler,
> + IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
> + "anx7688-cabledet", anx7688);
> + if (ret < 0) {
> + dev_err(dev, "Could not request cabledet irq (%d)\n", ret);
> + goto err_cport;
> + }
> +
> + ret = devm_request_threaded_irq(dev, client->irq,
> + NULL, anx7688_irq_status_handler,
> + IRQF_ONESHOT, NULL, anx7688);
> + if (ret < 0) {
> + dev_err(dev, "Could not request irq (%d)\n", ret);
> + goto err_cport;
> + }
> +
> + anx7688->vbus_in_nb.notifier_call = anx7688_vbus_in_notify;
> + anx7688->vbus_in_nb.priority = 0;
> + ret = power_supply_reg_notifier(&anx7688->vbus_in_nb);
> + if (ret)
> + goto err_cport;
> +
> + anx7688->debug_root = debugfs_create_dir("anx7688", NULL);
> + debugfs_create_file("firmware", 0444, anx7688->debug_root, anx7688,
> + &anx7688_firmware_fops);
> + debugfs_create_file("regs", 0444, anx7688->debug_root, anx7688,
> + &anx7688_regs_fops);
> + debugfs_create_file("status", 0444, anx7688->debug_root, anx7688,
> + &anx7688_status_fops);
> +
> + schedule_delayed_work(&anx7688->work, msecs_to_jiffies(10));
> +
> + timer_setup(&anx7688->work_timer, anx7688_cabledet_timer_fn, 0);
> + mod_timer(&anx7688->work_timer, jiffies + msecs_to_jiffies(1000));
> + return 0;
> +
> +err_cport:
> + typec_unregister_port(anx7688->port);
> +err_role_sw:
> + usb_role_switch_put(anx7688->role_sw);
> +err_disable_reg:
> + regulator_bulk_disable(ANX7688_NUM_ALWAYS_ON_SUPPLIES, anx7688->supplies);
> +err_dummy_dev:
> + i2c_unregister_device(anx7688->client_tcpc);
> + return ret;
> +}
> +
> +static void anx7688_i2c_remove(struct i2c_client *client)
> +{
> + struct anx7688 *anx7688 = i2c_get_clientdata(client);
> +
> + mutex_lock(&anx7688->lock);
> +
> + power_supply_unreg_notifier(&anx7688->vbus_in_nb);
> +
> + del_timer_sync(&anx7688->work_timer);
> +
> + cancel_delayed_work_sync(&anx7688->work);
> +
> + if (test_bit(ANX7688_F_CONNECTED, anx7688->flags))
> + anx7688_disconnect(anx7688);
> +
> + typec_unregister_partner(anx7688->partner);
> + typec_unregister_port(anx7688->port);
> + usb_role_switch_put(anx7688->role_sw);
> +
> + regulator_bulk_disable(ANX7688_NUM_ALWAYS_ON_SUPPLIES, anx7688->supplies);
> + i2c_unregister_device(anx7688->client_tcpc);
> +
> + debugfs_remove(anx7688->debug_root);
> +
> + mutex_unlock(&anx7688->lock);
> +}
> +
> +static int __maybe_unused anx7688_suspend(struct device *dev)
> +{
> + struct anx7688 *anx7688 = i2c_get_clientdata(to_i2c_client(dev));
> +
> + del_timer_sync(&anx7688->work_timer);
> + cancel_delayed_work_sync(&anx7688->work);
> +
> + regulator_disable(anx7688->supplies[ANX7688_I2C_INDEX].consumer);
> +
> + return 0;
> +}
> +
> +static int __maybe_unused anx7688_resume(struct device *dev)
> +{
> + struct anx7688 *anx7688 = i2c_get_clientdata(to_i2c_client(dev));
> + int ret;
> +
> + ret = regulator_enable(anx7688->supplies[ANX7688_I2C_INDEX].consumer);
> + if (ret)
> + dev_warn(anx7688->dev,
> + "failed to enable I2C regulator (%d)\n", ret);
> +
> + // check status right after resume, since it could have changed during
> + // sleep
> + schedule_delayed_work(&anx7688->work, msecs_to_jiffies(50));
> + mod_timer(&anx7688->work_timer, jiffies + msecs_to_jiffies(1000));
> +
> + return 0;
> +}
> +
> +static const struct dev_pm_ops anx7688_pm_ops = {
> + SET_SYSTEM_SLEEP_PM_OPS(anx7688_suspend, anx7688_resume)
> +};
> +
> +static const struct i2c_device_id anx7688_ids[] = {
> + { "anx7688", 0 },
> + { }
> +};
> +MODULE_DEVICE_TABLE(i2c, anx7688_ids);
> +
> +static const struct of_device_id anx7688_of_match_table[] = {
> + { .compatible = "analogix,anx7688" },
> + { },
> +};
> +MODULE_DEVICE_TABLE(of, anx7688_of_match_table);
> +
> +static struct i2c_driver anx7688_driver = {
> + .driver = {
> + .name = "anx7688",
> + .of_match_table = anx7688_of_match_table,
> + .pm = &anx7688_pm_ops,
> + },
> + .probe = anx7688_i2c_probe,
> + .remove = anx7688_i2c_remove,
> + .id_table = anx7688_ids,
> +};
> +
> +module_i2c_driver(anx7688_driver);
> +
> +MODULE_LICENSE("GPL");
> +MODULE_AUTHOR("Martijn Braam <martijn@brixit.nl>");
> +MODULE_AUTHOR("Ondrej Jirman <megi@xff.cz>");
> +MODULE_DESCRIPTION("Analogix ANX7688 USB-C DisplayPort bridge");
>
>
> --
> People of Russia, stop Putin before his war on Ukraine escalates.

--
heikki