drivers/usb/typec/mux/it5205.c

// SPDX-License-Identifier: GPL-2.0
/*
 * ITE IT5205 Type-C USB alternate mode passive mux
 *
 * Copyright (c) 2020 MediaTek Inc.
 * Copyright (c) 2024 Collabora Ltd.
 *                    AngeloGioacchino Del Regno <angelogioacchino.delregno@collabora.com>
 *
 */

#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of_platform.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>
#include <linux/regulator/consumer.h>
#include <linux/usb/tcpm.h>
#include <linux/usb/typec.h>
#include <linux/usb/typec_dp.h>
#include <linux/usb/typec_mux.h>

#define IT5205_REG_CHIP_ID(x)	(0x4 + (x))
#define IT5205FN_CHIP_ID	0x35323035 /* "5205" */

/* MUX power down register */
#define IT5205_REG_MUXPDR        0x10
#define IT5205_MUX_POWER_DOWN    BIT(0)

/* MUX control register */
#define IT5205_REG_MUXCR         0x11
#define IT5205_POLARITY_INVERTED BIT(4)
#define IT5205_DP_USB_CTRL_MASK  GENMASK(3, 0)
#define IT5205_DP                0x0f
#define IT5205_DP_USB            0x03
#define IT5205_USB               0x07

/* Vref Select Register */
#define IT5205_REG_VSR            0x10
#define IT5205_VREF_SELECT_MASK   GENMASK(5, 4)
#define IT5205_VREF_SELECT_3_3V   0x00
#define IT5205_VREF_SELECT_OFF    0x20

/* CSBU Over Voltage Protection Register */
#define IT5205_REG_CSBUOVPSR      0x1e
#define IT5205_OVP_SELECT_MASK    GENMASK(5, 4)
#define IT5205_OVP_3_90V          0x00
#define IT5205_OVP_3_68V          0x10
#define IT5205_OVP_3_62V          0x20
#define IT5205_OVP_3_57V          0x30

/* CSBU Switch Register */
#define IT5205_REG_CSBUSR         0x22
#define IT5205_CSBUSR_SWITCH      BIT(0)

/* Interrupt Switch Register */
#define IT5205_REG_ISR            0x25
#define IT5205_ISR_CSBU_MASK      BIT(4)
#define IT5205_ISR_CSBU_OVP       BIT(0)

struct it5205 {
	struct i2c_client *client;
	struct regmap *regmap;
	struct typec_switch_dev *sw;
	struct typec_mux_dev *mux;
};

static int it5205_switch_set(struct typec_switch_dev *sw, enum typec_orientation orientation)
{
	struct it5205 *it = typec_switch_get_drvdata(sw);

	switch (orientation) {
	case TYPEC_ORIENTATION_NORMAL:
		regmap_update_bits(it->regmap, IT5205_REG_MUXCR,
				   IT5205_POLARITY_INVERTED, 0);
		break;
	case TYPEC_ORIENTATION_REVERSE:
		regmap_update_bits(it->regmap, IT5205_REG_MUXCR,
				   IT5205_POLARITY_INVERTED, IT5205_POLARITY_INVERTED);
		break;
	case TYPEC_ORIENTATION_NONE:
		fallthrough;
	default:
		regmap_write(it->regmap, IT5205_REG_MUXCR, 0);
		break;
	}

	return 0;
}

static int it5205_mux_set(struct typec_mux_dev *mux, struct typec_mux_state *state)
{
	struct it5205 *it = typec_mux_get_drvdata(mux);
	u8 val;

	if (state->mode >= TYPEC_STATE_MODAL &&
	    state->alt->svid != USB_TYPEC_DP_SID)
		return -EINVAL;

	switch (state->mode) {
	case TYPEC_STATE_USB:
		val = IT5205_USB;
		break;
	case TYPEC_DP_STATE_C:
		fallthrough;
	case TYPEC_DP_STATE_E:
		val = IT5205_DP;
		break;
	case TYPEC_DP_STATE_D:
		val = IT5205_DP_USB;
		break;
	case TYPEC_STATE_SAFE:
		fallthrough;
	default:
		val = 0;
		break;
	}

	return regmap_update_bits(it->regmap, IT5205_REG_MUXCR,
				  IT5205_DP_USB_CTRL_MASK, val);
}

static irqreturn_t it5205_irq_handler(int irq, void *data)
{
	struct it5205 *it = data;
	int ret;
	u32 val;

	ret = regmap_read(it->regmap, IT5205_REG_ISR, &val);
	if (ret)
		return IRQ_NONE;

	if (val & IT5205_ISR_CSBU_OVP) {
		dev_warn(&it->client->dev, "Overvoltage detected!\n");

		/* Reset CSBU */
		regmap_update_bits(it->regmap, IT5205_REG_CSBUSR,
				   IT5205_CSBUSR_SWITCH, 0);
		regmap_update_bits(it->regmap, IT5205_REG_CSBUSR,
				   IT5205_CSBUSR_SWITCH, IT5205_CSBUSR_SWITCH);
	}

	return IRQ_HANDLED;
}

static void it5205_enable_ovp(struct it5205 *it)
{
	/* Select Vref 3.3v */
	regmap_update_bits(it->regmap, IT5205_REG_VSR,
			   IT5205_VREF_SELECT_MASK, IT5205_VREF_SELECT_3_3V);

	/* Trigger OVP at 3.68V */
	regmap_update_bits(it->regmap, IT5205_REG_CSBUOVPSR,
			   IT5205_OVP_SELECT_MASK, IT5205_OVP_3_68V);

	/* Unmask OVP interrupt */
	regmap_update_bits(it->regmap, IT5205_REG_ISR,
			   IT5205_ISR_CSBU_MASK, 0);

	/* Enable CSBU Interrupt */
	regmap_update_bits(it->regmap, IT5205_REG_CSBUSR,
			   IT5205_CSBUSR_SWITCH, IT5205_CSBUSR_SWITCH);
}

static const struct regmap_config it5205_regmap = {
	.max_register = 0x2f,
	.reg_bits = 8,
	.val_bits = 8,
};

static int it5205_probe(struct i2c_client *client)
{
	struct typec_switch_desc sw_desc = { };
	struct typec_mux_desc mux_desc = { };
	struct device *dev = &client->dev;
	struct it5205 *it;
	u32 val, chipid = 0;
	int i, ret;

	it = devm_kzalloc(dev, sizeof(*it), GFP_KERNEL);
	if (!it)
		return -ENOMEM;

	ret = devm_regulator_get_enable(dev, "vcc");
	if (ret)
		return dev_err_probe(dev, ret, "Failed to get regulator\n");

	it->client = client;

	it->regmap = devm_regmap_init_i2c(client, &it5205_regmap);
	if (IS_ERR(it->regmap))
		return dev_err_probe(dev, PTR_ERR(it->regmap),
				     "Failed to init regmap\n");

	/* IT5205 needs a long time to power up after enabling regulator */
	msleep(50);

	/* Unset poweroff bit */
	ret = regmap_write(it->regmap, IT5205_REG_MUXPDR, 0);
	if (ret)
		return dev_err_probe(dev, ret, "Failed to set power on\n");

	/* Read the 32 bits ChipID */
	for (i = 3; i >= 0; i--) {
		ret = regmap_read(it->regmap, IT5205_REG_CHIP_ID(i), &val);
		if (ret)
			return ret;

		chipid |= val << (i * 8);
	}

	if (chipid != IT5205FN_CHIP_ID)
		return dev_err_probe(dev, -EINVAL,
				     "Unknown ChipID 0x%x\n", chipid);

	/* Initialize as USB mode with default (non-inverted) polarity */
	ret = regmap_write(it->regmap, IT5205_REG_MUXCR, IT5205_USB);
	if (ret)
		return dev_err_probe(dev, ret, "Cannot set mode to USB\n");

	sw_desc.drvdata = it;
	sw_desc.fwnode = dev_fwnode(dev);
	sw_desc.set = it5205_switch_set;

	it->sw = typec_switch_register(dev, &sw_desc);
	if (IS_ERR(it->sw))
		return dev_err_probe(dev, PTR_ERR(it->sw),
				     "failed to register typec switch\n");

	mux_desc.drvdata = it;
	mux_desc.fwnode = dev_fwnode(dev);
	mux_desc.set = it5205_mux_set;

	it->mux = typec_mux_register(dev, &mux_desc);
	if (IS_ERR(it->mux)) {
		typec_switch_unregister(it->sw);
		return dev_err_probe(dev, PTR_ERR(it->mux),
				     "failed to register typec mux\n");
	}

	i2c_set_clientdata(client, it);

	if (of_property_read_bool(dev->of_node, "ite,ovp-enable") && client->irq) {
		it5205_enable_ovp(it);

		ret = devm_request_threaded_irq(dev, client->irq, NULL,
						it5205_irq_handler,
						IRQF_ONESHOT, dev_name(dev), it);
		if (ret) {
			typec_mux_unregister(it->mux);
			typec_switch_unregister(it->sw);
			return dev_err_probe(dev, ret, "Failed to request irq\n");
		}
	}

	return 0;
}

static void it5205_remove(struct i2c_client *client)
{
	struct it5205 *it = i2c_get_clientdata(client);

	typec_mux_unregister(it->mux);
	typec_switch_unregister(it->sw);
}

static const struct i2c_device_id it5205_table[] = {
	{ "it5205" },
	{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(i2c, it5205_table);

static const struct of_device_id it5205_of_table[] = {
	{ .compatible = "ite,it5205" },
	{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, it5205_of_table);

static struct i2c_driver it5205_driver = {
	.driver = {
		.name = "it5205",
		.of_match_table = it5205_of_table,
	},
	.probe = it5205_probe,
	.remove = it5205_remove,
	.id_table = it5205_table,
};
module_i2c_driver(it5205_driver);

MODULE_AUTHOR("Tianping Fang <tianping.fang@mediatek.com>");
MODULE_AUTHOR("AngeloGioacchino Del Regno <angelogioacchino.delregno@collabora.com>");
MODULE_DESCRIPTION("ITE IT5205 alternate mode passive MUX driver");
MODULE_LICENSE("GPL");