drivers/usb_c/ppc/nxp_nx20p3483.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /*
  * Copyright 2023 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */

 #include <zephyr/device.h>
 #include <zephyr/logging/log.h>
 #include <zephyr/drivers/gpio.h>
 #include <zephyr/drivers/i2c.h>
 #include <zephyr/shell/shell.h>
 #include <zephyr/drivers/usb_c/usbc_ppc.h>

 #include "nxp_nx20p3483_priv.h"

 #define DT_DRV_COMPAT nxp_nx20p3483
 LOG_MODULE_REGISTER(nxp_nx20p3483, CONFIG_USBC_PPC_LOG_LEVEL);

 #ifdef CONFIG_USBC_PPC_NX20P3483_DUMP_FULL_REG_NAMES
 static const char *const nx20p3483_reg_names[] = {
 	"Device ID           ", "Device Status       ", "Switch Control      ",
 	"Switch Status       ", "Interrupt 1         ", "Interrupt 2         ",
 	"Interrupt 1 Mask    ", "Interrupt 2 Mask    ", "OVLO Threshold      ",
 	"HV SRC OCP Threshold", "5V SRC OCP Threshold", "Device Control      ",
 };
 #endif

 /* Driver structures */

 struct nx20p3483_cfg {
 	/** Device address on I2C bus */
 	const struct i2c_dt_spec bus;
 	/** GPIO used as interrupt request */
 	const struct gpio_dt_spec irq_gpio;

 	/** Overvoltage protection threshold for sink role */
 	int snk_ovp_thresh;
 	/** Boolean value whether to use high-voltage source if true or 5V source if false */
 	bool src_use_hv;
 	/** Overcurrent protection threshold for 5V source role */
 	int src_5v_ocp_thresh;
 	/** Overcurrent protection threshold for HV source role */
 	int src_hv_ocp_thresh;
 };

 struct nx20p3483_data {
 	/** Device structure to get from data structure */
 	const struct device *dev;
 	/** Interrupt request callback object */
 	struct gpio_callback irq_cb;
 	/** Workqueue object for handling interrupts */
 	struct k_work irq_work;

 	/** Callback used to notify about PPC events, like overcurrent or short */
 	usbc_ppc_event_cb_t event_cb;
 	/** Data sent as parameter to the callback */
 	void *event_cb_data;
 };

 /* Helper functions */

 static int read_reg(const struct device *dev, uint8_t reg, uint8_t *value)
 {
 	const struct nx20p3483_cfg *cfg = dev->config;
 	int ret;

 	ret = i2c_reg_read_byte(cfg->bus.bus, cfg->bus.addr, reg, value);
 	if (ret != 0) {
 		LOG_ERR("Error reading reg %02x: %d", reg, ret);
 		return ret;
 	}

 	return 0;
 }

 static int write_reg(const struct device *dev, uint8_t reg, uint8_t value)
 {
 	const struct nx20p3483_cfg *cfg = dev->config;
 	int ret;

 	ret = i2c_reg_write_byte(cfg->bus.bus, cfg->bus.addr, reg, value);
 	if (ret != 0) {
 		LOG_ERR("Error writing reg %02x: %d", reg, ret);
 		return ret;
 	}

 	return 0;
 }

 static int nx20p3483_set_snk_ovp_limit(const struct device *dev, uint8_t u_thresh)
 {
 	int ret;

 	if (u_thresh < NX20P3483_I_THRESHOLD_0_400 || u_thresh > NX20P3483_I_THRESHOLD_3_400) {
 		return -EINVAL;
 	}

 	ret = write_reg(dev, NX20P3483_REG_OVLO_THRESHOLD, u_thresh);
 	if (ret != 0) {
 		LOG_ERR("Couldn't set SNK OVP: %d", ret);
 		return ret;
 	}

 	LOG_DBG("Set SNK OVP: %d", u_thresh);
 	return 0;
 }

 /* API functions */

 int nx20p3483_is_dead_battery_mode(const struct device *dev)
 {
 	uint8_t sts_reg;
 	int ret;

 	ret = read_reg(dev, NX20P3483_REG_DEVICE_STATUS, &sts_reg);
 	if (ret != 0) {
 		return ret;
 	}

 	return ((sts_reg & NX20P3483_REG_DEVICE_STATUS_MODE_MASK) == NX20P3483_MODE_DEAD_BATTERY);
 }

 int nx20p3483_exit_dead_battery_mode(const struct device *dev)
 {
 	uint8_t ctrl_reg;
 	int ret;

 	ret = read_reg(dev, NX20P3483_REG_DEVICE_CTRL, &ctrl_reg);
 	if (ret != 0) {
 		return ret;
 	}

 	ctrl_reg |= NX20P3483_REG_DEVICE_CTRL_DB_EXIT;
 	ret = write_reg(dev, NX20P3483_REG_DEVICE_CTRL, ctrl_reg);
 	if (ret != 0) {
 		return ret;
 	}

 	return 0;
 }

 static int nx20p3483_is_vbus_source(const struct device *dev)
 {
 	uint8_t sts_reg;
 	int ret;

 	ret = read_reg(dev, NX20P3483_REG_SWITCH_STATUS, &sts_reg);
 	if (ret != 0) {
 		return ret;
 	}

 	return !!(sts_reg &
 		  (NX20P3483_REG_SWITCH_STATUS_5VSRC | NX20P3483_REG_SWITCH_STATUS_HVSRC));
 }

 static int nx20p3483_is_vbus_sink(const struct device *dev)
 {
 	uint8_t sts_reg;
 	int ret;

 	ret = read_reg(dev, NX20P3483_REG_SWITCH_STATUS, &sts_reg);
 	if (ret != 0) {
 		return ret;
 	}

 	return !!(sts_reg & NX20P3483_REG_SWITCH_STATUS_HVSNK);
 }

 static int nx20p3483_set_vbus_sink(const struct device *dev, bool enable)
 {
 	const struct nx20p3483_cfg *cfg = dev->config;

 	/*
 	 * The nx20p3483 is enabled by external GPIO signal, however enabling it sets the
 	 * overvoltage threshold to the highest possible value. Due to that, the threshold has
 	 * to be set here again. Must be called after enabling the path by the external signal.
 	 */
 	return nx20p3483_set_snk_ovp_limit(dev, cfg->snk_ovp_thresh);
 }

 static int nx20p3483_set_vbus_discharge(const struct device *dev, bool enable)
 {
 	uint8_t ctrl_reg;
 	int ret;

 	ret = read_reg(dev, NX20P3483_REG_DEVICE_CTRL, &ctrl_reg);
 	if (ret != 0) {
 		return ret;
 	}

 	if (enable) {
 		ctrl_reg |= NX20P3483_REG_DEVICE_CTRL_VBUSDIS_EN;
 	} else {
 		ctrl_reg &= ~NX20P3483_REG_DEVICE_CTRL_VBUSDIS_EN;
 	}

 	ret = write_reg(dev, NX20P3483_REG_DEVICE_CTRL, ctrl_reg);

 	return ret;
 }

 static int nx20p3483_set_event_handler(const struct device *dev, usbc_ppc_event_cb_t handler,
 				       void *handler_data)
 {
 	struct nx20p3483_data *data = dev->data;

 	data->event_cb = handler;
 	data->event_cb_data = handler_data;

 	return 0;
 }

 static int nx20p3483_dump_regs(const struct device *dev)
 {
 	const struct nx20p3483_cfg *cfg = dev->config;
 	uint8_t val;

 	LOG_INF("NX20P alert: %d", gpio_pin_get(cfg->irq_gpio.port, cfg->irq_gpio.pin));
 	LOG_INF("PPC %s:%s registers:", cfg->bus.bus->name, dev->name);
 	for (int a = 0; a <= NX20P3483_REG_DEVICE_CTRL; a++) {
 		i2c_reg_read_byte(cfg->bus.bus, cfg->bus.addr, a, &val);

 #ifdef CONFIG_USBC_PPC_NX20P3483_DUMP_FULL_REG_NAMES
 		LOG_INF("- [%s] = 0x%02x", nx20p3483_reg_names[a], val);
 #else
 		LOG_INF("- [%02x] = 0x%02x", a, val);
 #endif
 	}

 	return 0;
 }

 static struct usbc_ppc_driver_api nx20p3483_driver_api = {
 	.is_dead_battery_mode = nx20p3483_is_dead_battery_mode,
 	.exit_dead_battery_mode = nx20p3483_exit_dead_battery_mode,
 	.is_vbus_source = nx20p3483_is_vbus_source,
 	.is_vbus_sink = nx20p3483_is_vbus_sink,
 	.set_snk_ctrl = nx20p3483_set_vbus_sink,
 	.set_vbus_discharge = nx20p3483_set_vbus_discharge,
 	.set_event_handler = nx20p3483_set_event_handler,
 	.dump_regs = nx20p3483_dump_regs,
 };

 static int nx20p3483_set_src_ovc_limit(const struct device *dev, uint8_t i_thresh_5v,
 				       uint8_t i_thresh_hv)
 {
 	int ret;

 	if (i_thresh_5v < NX20P3483_I_THRESHOLD_0_400 ||
 	    i_thresh_5v > NX20P3483_I_THRESHOLD_3_400) {
 		LOG_ERR("Invalid SRC 5V ovc threshold: %d", i_thresh_5v);
 		return -EINVAL;
 	}

 	if (i_thresh_hv < NX20P3483_I_THRESHOLD_0_400 ||
 	    i_thresh_hv > NX20P3483_I_THRESHOLD_3_400) {
 		LOG_ERR("Invalid SRC HV ovc threshold: %d", i_thresh_hv);
 		return -EINVAL;
 	}

 	ret = write_reg(dev, NX20P3483_REG_5V_SRC_OCP_THRESHOLD, i_thresh_5v);
 	if (ret != 0) {
 		return ret;
 	}

 	ret = write_reg(dev, NX20P3483_REG_HV_SRC_OCP_THRESHOLD, i_thresh_hv);
 	if (ret != 0) {
 		return ret;
 	}

 	LOG_DBG("Set SRC OVC 5V: %d, HV: %d", i_thresh_5v, i_thresh_hv);
 	return 0;
 }

 static void nx20p3483_send_event(const struct device *dev, enum usbc_ppc_event ev)
 {
 	struct nx20p3483_data *data = dev->data;

 	if (data->event_cb != NULL) {
 		data->event_cb(dev, data->event_cb_data, ev);
 	}
 }

 static void nx20p3483_irq_handler(const struct device *port, struct gpio_callback *cb,
 				  gpio_port_pins_t pins)
 {
 	struct nx20p3483_data *data = CONTAINER_OF(cb, struct nx20p3483_data, irq_cb);

 	k_work_submit(&data->irq_work);
 }

 static void nx20p3483_irq_worker(struct k_work *work)
 {
 	struct nx20p3483_data *data = CONTAINER_OF(work, struct nx20p3483_data, irq_work);
 	const struct device *dev = data->dev;
 	uint8_t irq1, irq2;
 	int ret;

 	ret = read_reg(dev, NX20P3483_REG_INT1, &irq1);
 	if (ret != 0) {
 		LOG_ERR("Couldn't read irq1");
 		return;
 	}

 	ret = read_reg(dev, NX20P3483_REG_INT2, &irq2);
 	if (ret != 0) {
 		LOG_ERR("Couldn't read irq2");
 		return;
 	}

 	if (data->event_cb == NULL) {
 		LOG_DBG("No callback set: %02x %02x", irq1, irq1);
 	}

 	/* Generic alerts */
 	if (irq1 & NX20P3483_REG_INT1_DBEXIT_ERR) {
 		LOG_INF("PPC dead battery exit failed");
 		nx20p3483_send_event(dev, USBC_PPC_EVENT_DEAD_BATTERY_ERROR);
 	}

 	if (irq1 & NX20P3483_REG_INT1_OTP) {
 		LOG_INF("PPC over temperature");
 		nx20p3483_send_event(dev, USBC_PPC_EVENT_OVER_TEMPERATURE);
 	}

 	if (irq1 & NX20P3483_REG_INT2_EN_ERR) {
 		LOG_INF("PPC source and sink enabled");
 		nx20p3483_send_event(dev, USBC_PPC_EVENT_BOTH_SNKSRC_ENABLED);
 	}

 	/* Source */
 	if (irq1 & NX20P3483_REG_INT1_OV_5VSRC || irq2 & NX20P3483_REG_INT2_OV_HVSRC) {
 		LOG_INF("PPC source overvoltage");
 		nx20p3483_send_event(dev, USBC_PPC_EVENT_SRC_OVERVOLTAGE);
 	}

 	if (irq1 & NX20P3483_REG_INT1_RCP_5VSRC || irq2 & NX20P3483_REG_INT2_RCP_HVSRC) {
 		LOG_INF("PPC source reverse current");
 		nx20p3483_send_event(dev, USBC_PPC_EVENT_SRC_REVERSE_CURRENT);
 	}

 	if (irq1 & NX20P3483_REG_INT1_OC_5VSRC || irq2 & NX20P3483_REG_INT2_OC_HVSRC) {
 		LOG_INF("PPC source overcurrent");
 		nx20p3483_send_event(dev, USBC_PPC_EVENT_SRC_OVERCURRENT);
 	}

 	if (irq1 & NX20P3483_REG_INT1_SC_5VSRC || irq2 & NX20P3483_REG_INT2_SC_HVSRC) {
 		LOG_INF("PPC source short");
 		nx20p3483_send_event(dev, USBC_PPC_EVENT_SRC_SHORT);
 	}

 	/* Sink */
 	if (irq2 & NX20P3483_REG_INT2_RCP_HVSNK) {
 		LOG_INF("PPC sink reverse current");
 		nx20p3483_send_event(dev, USBC_PPC_EVENT_SNK_REVERSE_CURRENT);
 	}

 	if (irq2 & NX20P3483_REG_INT2_SC_HVSNK) {
 		LOG_INF("PPC sink short");
 		nx20p3483_send_event(dev, USBC_PPC_EVENT_SNK_SHORT);
 	}

 	if (irq2 & NX20P3483_REG_INT2_OV_HVSNK) {
 		LOG_INF("PPC sink overvoltage");
 		nx20p3483_send_event(dev, USBC_PPC_EVENT_SNK_OVERVOLTAGE);
 	}
 }

 static int nx20p3483_dev_init(const struct device *dev)
 {
 	const struct nx20p3483_cfg *cfg = dev->config;
 	struct nx20p3483_data *data = dev->data;
 	uint8_t reg;
 	int ret;

 	LOG_INF("Initializing PPC");

 	/* Initialize irq */
 	ret = gpio_pin_configure(cfg->irq_gpio.port, cfg->irq_gpio.pin, GPIO_INPUT | GPIO_PULL_UP);
 	if (ret != 0) {
 		return ret;
 	}

 	ret = gpio_pin_interrupt_configure(cfg->irq_gpio.port, cfg->irq_gpio.pin,
 					   GPIO_INT_EDGE_FALLING);
 	if (ret != 0) {
 		return ret;
 	}

 	gpio_init_callback(&data->irq_cb, nx20p3483_irq_handler, BIT(cfg->irq_gpio.pin));
 	ret = gpio_add_callback(cfg->irq_gpio.port, &data->irq_cb);
 	if (ret != 0) {
 		return ret;
 	}

 	/* Initialize work_q */
 	k_work_init(&data->irq_work, nx20p3483_irq_worker);
 	k_work_submit(&data->irq_work);

 	/* If src_use_hv, select the HV src path but do not enable it yet */
 	read_reg(dev, NX20P3483_REG_SWITCH_CTRL, &reg);
 	if (cfg->src_use_hv) {
 		reg |= NX20P3483_REG_SWITCH_CTRL_SRC;
 	} else {
 		reg &= ~NX20P3483_REG_SWITCH_CTRL_SRC;
 	}

 	write_reg(dev, NX20P3483_REG_SWITCH_CTRL, reg);

 	/* Set limits */
 	ret = nx20p3483_set_snk_ovp_limit(dev, cfg->snk_ovp_thresh);
 	if (ret != 0) {
 		return ret;
 	}

 	ret = nx20p3483_set_src_ovc_limit(dev, cfg->src_5v_ocp_thresh, cfg->src_hv_ocp_thresh);
 	if (ret != 0) {
 		return ret;
 	}

 	return 0;
 }

 #define NX20P3483_DRIVER_CFG_INIT(node)                                                            \
 	{                                                                                          \
 		.bus = I2C_DT_SPEC_GET(node), .irq_gpio = GPIO_DT_SPEC_GET(node, irq_gpios),       \
 		.snk_ovp_thresh = DT_PROP(node, snk_ovp), .src_use_hv = DT_PROP(node, src_hv),     \
 		.src_5v_ocp_thresh = DT_PROP(node, src_5v_ocp),                                    \
 		.src_hv_ocp_thresh = DT_PROP(node, src_hv_ocp),                                    \
 	}

 #define NX20P3483_DRIVER_CFG_ASSERTS(node)                                                         \
 	BUILD_ASSERT(DT_PROP(node, snk_ovp) >= NX20P3483_U_THRESHOLD_6_0 &&                        \
 			     DT_PROP(node, snk_ovp) <= NX20P3483_U_THRESHOLD_23_0,                 \
 		     "Invalid overvoltage threshold");                                             \
 	BUILD_ASSERT(DT_PROP(node, src_5v_ocp) >= NX20P3483_I_THRESHOLD_0_400 &&                   \
 			     DT_PROP(node, src_5v_ocp) <= NX20P3483_I_THRESHOLD_3_400,             \
 		     "Invalid overcurrent threshold");                                             \
 	BUILD_ASSERT(DT_PROP(node, src_hv_ocp) >= NX20P3483_I_THRESHOLD_0_400 &&                   \
 			     DT_PROP(node, src_hv_ocp) <= NX20P3483_I_THRESHOLD_3_400,             \
 		     "Invalid overcurrent threshold");

 #define NX20P3483_DRIVER_DATA_INIT(node)                                                           \
 	{                                                                                          \
 		.dev = DEVICE_DT_GET(node),                                                        \
 	}

 #define NX20P3483_DRIVER_INIT(inst)                                                                \
 	static struct nx20p3483_data drv_data_nx20p3483##inst =                                    \
 		NX20P3483_DRIVER_DATA_INIT(DT_DRV_INST(inst));                                     \
 	NX20P3483_DRIVER_CFG_ASSERTS(DT_DRV_INST(inst));                                           \
 	static struct nx20p3483_cfg drv_cfg_nx20p3483##inst =                                      \
 		NX20P3483_DRIVER_CFG_INIT(DT_DRV_INST(inst));                                      \
 	DEVICE_DT_INST_DEFINE(inst, &nx20p3483_dev_init, NULL, &drv_data_nx20p3483##inst,          \
 			      &drv_cfg_nx20p3483##inst, POST_KERNEL,                               \
 			      CONFIG_USBC_PPC_INIT_PRIORITY, &nx20p3483_driver_api);

 DT_INST_FOREACH_STATUS_OKAY(NX20P3483_DRIVER_INIT)
	/*
	* Copyright 2023 Google LLC
	* SPDX-License-Identifier: Apache-2.0
	*/

	#include <zephyr/device.h>
	#include <zephyr/logging/log.h>
	#include <zephyr/drivers/gpio.h>
	#include <zephyr/drivers/i2c.h>
	#include <zephyr/shell/shell.h>
	#include <zephyr/drivers/usb_c/usbc_ppc.h>

	#include "nxp_nx20p3483_priv.h"

	#define DT_DRV_COMPAT nxp_nx20p3483
	LOG_MODULE_REGISTER(nxp_nx20p3483, CONFIG_USBC_PPC_LOG_LEVEL);

	#ifdef CONFIG_USBC_PPC_NX20P3483_DUMP_FULL_REG_NAMES
	static const char *const nx20p3483_reg_names[] = {
	"Device ID ", "Device Status ", "Switch Control ",
	"Switch Status ", "Interrupt 1 ", "Interrupt 2 ",
	"Interrupt 1 Mask ", "Interrupt 2 Mask ", "OVLO Threshold ",
	"HV SRC OCP Threshold", "5V SRC OCP Threshold", "Device Control ",
	};
	#endif

	/* Driver structures */

	struct nx20p3483_cfg {
	/** Device address on I2C bus */
	const struct i2c_dt_spec bus;
	/** GPIO used as interrupt request */
	const struct gpio_dt_spec irq_gpio;

	/** Overvoltage protection threshold for sink role */
	int snk_ovp_thresh;
	/** Boolean value whether to use high-voltage source if true or 5V source if false */
	bool src_use_hv;
	/** Overcurrent protection threshold for 5V source role */
	int src_5v_ocp_thresh;
	/** Overcurrent protection threshold for HV source role */
	int src_hv_ocp_thresh;
	};

	struct nx20p3483_data {
	/** Device structure to get from data structure */
	const struct device *dev;
	/** Interrupt request callback object */
	struct gpio_callback irq_cb;
	/** Workqueue object for handling interrupts */
	struct k_work irq_work;

	/** Callback used to notify about PPC events, like overcurrent or short */
	usbc_ppc_event_cb_t event_cb;
	/** Data sent as parameter to the callback */
	void *event_cb_data;
	};

	/* Helper functions */

	static int read_reg(const struct device dev, uint8_t reg, uint8_t value)
	{
	const struct nx20p3483_cfg *cfg = dev->config;
	int ret;

	ret = i2c_reg_read_byte(cfg->bus.bus, cfg->bus.addr, reg, value);
	if (ret != 0) {
	LOG_ERR("Error reading reg %02x: %d", reg, ret);
	return ret;
	}

	return 0;
	}

	static int write_reg(const struct device *dev, uint8_t reg, uint8_t value)
	{
	const struct nx20p3483_cfg *cfg = dev->config;
	int ret;

	ret = i2c_reg_write_byte(cfg->bus.bus, cfg->bus.addr, reg, value);
	if (ret != 0) {
	LOG_ERR("Error writing reg %02x: %d", reg, ret);
	return ret;
	}

	return 0;
	}

	static int nx20p3483_set_snk_ovp_limit(const struct device *dev, uint8_t u_thresh)
	{
	int ret;

	if (u_thresh < NX20P3483_I_THRESHOLD_0_400 \|\| u_thresh > NX20P3483_I_THRESHOLD_3_400) {
	return -EINVAL;
	}

	ret = write_reg(dev, NX20P3483_REG_OVLO_THRESHOLD, u_thresh);
	if (ret != 0) {
	LOG_ERR("Couldn't set SNK OVP: %d", ret);
	return ret;
	}

	LOG_DBG("Set SNK OVP: %d", u_thresh);
	return 0;
	}

	/* API functions */

	int nx20p3483_is_dead_battery_mode(const struct device *dev)
	{
	uint8_t sts_reg;
	int ret;

	ret = read_reg(dev, NX20P3483_REG_DEVICE_STATUS, &sts_reg);
	if (ret != 0) {
	return ret;
	}

	return ((sts_reg & NX20P3483_REG_DEVICE_STATUS_MODE_MASK) == NX20P3483_MODE_DEAD_BATTERY);
	}

	int nx20p3483_exit_dead_battery_mode(const struct device *dev)
	{
	uint8_t ctrl_reg;
	int ret;

	ret = read_reg(dev, NX20P3483_REG_DEVICE_CTRL, &ctrl_reg);
	if (ret != 0) {
	return ret;
	}

	ctrl_reg \|= NX20P3483_REG_DEVICE_CTRL_DB_EXIT;
	ret = write_reg(dev, NX20P3483_REG_DEVICE_CTRL, ctrl_reg);
	if (ret != 0) {
	return ret;
	}

	return 0;
	}

	static int nx20p3483_is_vbus_source(const struct device *dev)
	{
	uint8_t sts_reg;
	int ret;

	ret = read_reg(dev, NX20P3483_REG_SWITCH_STATUS, &sts_reg);
	if (ret != 0) {
	return ret;
	}

	return !!(sts_reg &
	(NX20P3483_REG_SWITCH_STATUS_5VSRC \| NX20P3483_REG_SWITCH_STATUS_HVSRC));
	}

	static int nx20p3483_is_vbus_sink(const struct device *dev)
	{
	uint8_t sts_reg;
	int ret;

	ret = read_reg(dev, NX20P3483_REG_SWITCH_STATUS, &sts_reg);
	if (ret != 0) {
	return ret;
	}

	return !!(sts_reg & NX20P3483_REG_SWITCH_STATUS_HVSNK);
	}

	static int nx20p3483_set_vbus_sink(const struct device *dev, bool enable)
	{
	const struct nx20p3483_cfg *cfg = dev->config;

	/*
	* The nx20p3483 is enabled by external GPIO signal, however enabling it sets the
	* overvoltage threshold to the highest possible value. Due to that, the threshold has
	* to be set here again. Must be called after enabling the path by the external signal.
	*/
	return nx20p3483_set_snk_ovp_limit(dev, cfg->snk_ovp_thresh);
	}

	static int nx20p3483_set_vbus_discharge(const struct device *dev, bool enable)
	{
	uint8_t ctrl_reg;
	int ret;

	ret = read_reg(dev, NX20P3483_REG_DEVICE_CTRL, &ctrl_reg);
	if (ret != 0) {
	return ret;
	}

	if (enable) {
	ctrl_reg \|= NX20P3483_REG_DEVICE_CTRL_VBUSDIS_EN;
	} else {
	ctrl_reg &= ~NX20P3483_REG_DEVICE_CTRL_VBUSDIS_EN;
	}

	ret = write_reg(dev, NX20P3483_REG_DEVICE_CTRL, ctrl_reg);

	return ret;
	}

	static int nx20p3483_set_event_handler(const struct device *dev, usbc_ppc_event_cb_t handler,
	void *handler_data)
	{
	struct nx20p3483_data *data = dev->data;

	data->event_cb = handler;
	data->event_cb_data = handler_data;

	return 0;
	}

	static int nx20p3483_dump_regs(const struct device *dev)
	{
	const struct nx20p3483_cfg *cfg = dev->config;
	uint8_t val;

	LOG_INF("NX20P alert: %d", gpio_pin_get(cfg->irq_gpio.port, cfg->irq_gpio.pin));
	LOG_INF("PPC %s:%s registers:", cfg->bus.bus->name, dev->name);
	for (int a = 0; a <= NX20P3483_REG_DEVICE_CTRL; a++) {
	i2c_reg_read_byte(cfg->bus.bus, cfg->bus.addr, a, &val);

	#ifdef CONFIG_USBC_PPC_NX20P3483_DUMP_FULL_REG_NAMES
	LOG_INF("- [%s] = 0x%02x", nx20p3483_reg_names[a], val);
	#else
	LOG_INF("- [%02x] = 0x%02x", a, val);
	#endif
	}

	return 0;
	}

	static struct usbc_ppc_driver_api nx20p3483_driver_api = {
	.is_dead_battery_mode = nx20p3483_is_dead_battery_mode,
	.exit_dead_battery_mode = nx20p3483_exit_dead_battery_mode,
	.is_vbus_source = nx20p3483_is_vbus_source,
	.is_vbus_sink = nx20p3483_is_vbus_sink,
	.set_snk_ctrl = nx20p3483_set_vbus_sink,
	.set_vbus_discharge = nx20p3483_set_vbus_discharge,
	.set_event_handler = nx20p3483_set_event_handler,
	.dump_regs = nx20p3483_dump_regs,
	};

	static int nx20p3483_set_src_ovc_limit(const struct device *dev, uint8_t i_thresh_5v,
	uint8_t i_thresh_hv)
	{
	int ret;

	if (i_thresh_5v < NX20P3483_I_THRESHOLD_0_400 \|\|
	i_thresh_5v > NX20P3483_I_THRESHOLD_3_400) {
	LOG_ERR("Invalid SRC 5V ovc threshold: %d", i_thresh_5v);
	return -EINVAL;
	}

	if (i_thresh_hv < NX20P3483_I_THRESHOLD_0_400 \|\|
	i_thresh_hv > NX20P3483_I_THRESHOLD_3_400) {
	LOG_ERR("Invalid SRC HV ovc threshold: %d", i_thresh_hv);
	return -EINVAL;
	}

	ret = write_reg(dev, NX20P3483_REG_5V_SRC_OCP_THRESHOLD, i_thresh_5v);
	if (ret != 0) {
	return ret;
	}

	ret = write_reg(dev, NX20P3483_REG_HV_SRC_OCP_THRESHOLD, i_thresh_hv);
	if (ret != 0) {
	return ret;
	}

	LOG_DBG("Set SRC OVC 5V: %d, HV: %d", i_thresh_5v, i_thresh_hv);
	return 0;
	}

	static void nx20p3483_send_event(const struct device *dev, enum usbc_ppc_event ev)
	{
	struct nx20p3483_data *data = dev->data;

	if (data->event_cb != NULL) {
	data->event_cb(dev, data->event_cb_data, ev);
	}
	}

	static void nx20p3483_irq_handler(const struct device port, struct gpio_callback cb,
	gpio_port_pins_t pins)
	{
	struct nx20p3483_data *data = CONTAINER_OF(cb, struct nx20p3483_data, irq_cb);

	k_work_submit(&data->irq_work);
	}

	static void nx20p3483_irq_worker(struct k_work *work)
	{
	struct nx20p3483_data *data = CONTAINER_OF(work, struct nx20p3483_data, irq_work);
	const struct device *dev = data->dev;
	uint8_t irq1, irq2;
	int ret;

	ret = read_reg(dev, NX20P3483_REG_INT1, &irq1);
	if (ret != 0) {
	LOG_ERR("Couldn't read irq1");
	return;
	}

	ret = read_reg(dev, NX20P3483_REG_INT2, &irq2);
	if (ret != 0) {
	LOG_ERR("Couldn't read irq2");
	return;
	}

	if (data->event_cb == NULL) {
	LOG_DBG("No callback set: %02x %02x", irq1, irq1);
	}

	/* Generic alerts */
	if (irq1 & NX20P3483_REG_INT1_DBEXIT_ERR) {
	LOG_INF("PPC dead battery exit failed");
	nx20p3483_send_event(dev, USBC_PPC_EVENT_DEAD_BATTERY_ERROR);
	}

	if (irq1 & NX20P3483_REG_INT1_OTP) {
	LOG_INF("PPC over temperature");
	nx20p3483_send_event(dev, USBC_PPC_EVENT_OVER_TEMPERATURE);
	}

	if (irq1 & NX20P3483_REG_INT2_EN_ERR) {
	LOG_INF("PPC source and sink enabled");
	nx20p3483_send_event(dev, USBC_PPC_EVENT_BOTH_SNKSRC_ENABLED);
	}

	/* Source */
	if (irq1 & NX20P3483_REG_INT1_OV_5VSRC \|\| irq2 & NX20P3483_REG_INT2_OV_HVSRC) {
	LOG_INF("PPC source overvoltage");
	nx20p3483_send_event(dev, USBC_PPC_EVENT_SRC_OVERVOLTAGE);
	}

	if (irq1 & NX20P3483_REG_INT1_RCP_5VSRC \|\| irq2 & NX20P3483_REG_INT2_RCP_HVSRC) {
	LOG_INF("PPC source reverse current");
	nx20p3483_send_event(dev, USBC_PPC_EVENT_SRC_REVERSE_CURRENT);
	}

	if (irq1 & NX20P3483_REG_INT1_OC_5VSRC \|\| irq2 & NX20P3483_REG_INT2_OC_HVSRC) {
	LOG_INF("PPC source overcurrent");
	nx20p3483_send_event(dev, USBC_PPC_EVENT_SRC_OVERCURRENT);
	}

	if (irq1 & NX20P3483_REG_INT1_SC_5VSRC \|\| irq2 & NX20P3483_REG_INT2_SC_HVSRC) {
	LOG_INF("PPC source short");
	nx20p3483_send_event(dev, USBC_PPC_EVENT_SRC_SHORT);
	}

	/* Sink */
	if (irq2 & NX20P3483_REG_INT2_RCP_HVSNK) {
	LOG_INF("PPC sink reverse current");
	nx20p3483_send_event(dev, USBC_PPC_EVENT_SNK_REVERSE_CURRENT);
	}

	if (irq2 & NX20P3483_REG_INT2_SC_HVSNK) {
	LOG_INF("PPC sink short");
	nx20p3483_send_event(dev, USBC_PPC_EVENT_SNK_SHORT);
	}

	if (irq2 & NX20P3483_REG_INT2_OV_HVSNK) {
	LOG_INF("PPC sink overvoltage");
	nx20p3483_send_event(dev, USBC_PPC_EVENT_SNK_OVERVOLTAGE);
	}
	}

	static int nx20p3483_dev_init(const struct device *dev)
	{
	const struct nx20p3483_cfg *cfg = dev->config;
	struct nx20p3483_data *data = dev->data;
	uint8_t reg;
	int ret;

	LOG_INF("Initializing PPC");

	/* Initialize irq */
	ret = gpio_pin_configure(cfg->irq_gpio.port, cfg->irq_gpio.pin, GPIO_INPUT \| GPIO_PULL_UP);
	if (ret != 0) {
	return ret;
	}

	ret = gpio_pin_interrupt_configure(cfg->irq_gpio.port, cfg->irq_gpio.pin,
	GPIO_INT_EDGE_FALLING);
	if (ret != 0) {
	return ret;
	}

	gpio_init_callback(&data->irq_cb, nx20p3483_irq_handler, BIT(cfg->irq_gpio.pin));
	ret = gpio_add_callback(cfg->irq_gpio.port, &data->irq_cb);
	if (ret != 0) {
	return ret;
	}

	/* Initialize work_q */
	k_work_init(&data->irq_work, nx20p3483_irq_worker);
	k_work_submit(&data->irq_work);

	/* If src_use_hv, select the HV src path but do not enable it yet */
	read_reg(dev, NX20P3483_REG_SWITCH_CTRL, &reg);
	if (cfg->src_use_hv) {
	reg \|= NX20P3483_REG_SWITCH_CTRL_SRC;
	} else {
	reg &= ~NX20P3483_REG_SWITCH_CTRL_SRC;
	}

	write_reg(dev, NX20P3483_REG_SWITCH_CTRL, reg);

	/* Set limits */
	ret = nx20p3483_set_snk_ovp_limit(dev, cfg->snk_ovp_thresh);
	if (ret != 0) {
	return ret;
	}

	ret = nx20p3483_set_src_ovc_limit(dev, cfg->src_5v_ocp_thresh, cfg->src_hv_ocp_thresh);
	if (ret != 0) {
	return ret;
	}

	return 0;
	}

	#define NX20P3483_DRIVER_CFG_INIT(node) \
	{ \
	.bus = I2C_DT_SPEC_GET(node), .irq_gpio = GPIO_DT_SPEC_GET(node, irq_gpios), \
	.snk_ovp_thresh = DT_PROP(node, snk_ovp), .src_use_hv = DT_PROP(node, src_hv), \
	.src_5v_ocp_thresh = DT_PROP(node, src_5v_ocp), \
	.src_hv_ocp_thresh = DT_PROP(node, src_hv_ocp), \
	}

	#define NX20P3483_DRIVER_CFG_ASSERTS(node) \
	BUILD_ASSERT(DT_PROP(node, snk_ovp) >= NX20P3483_U_THRESHOLD_6_0 && \
	DT_PROP(node, snk_ovp) <= NX20P3483_U_THRESHOLD_23_0, \
	"Invalid overvoltage threshold"); \
	BUILD_ASSERT(DT_PROP(node, src_5v_ocp) >= NX20P3483_I_THRESHOLD_0_400 && \
	DT_PROP(node, src_5v_ocp) <= NX20P3483_I_THRESHOLD_3_400, \
	"Invalid overcurrent threshold"); \
	BUILD_ASSERT(DT_PROP(node, src_hv_ocp) >= NX20P3483_I_THRESHOLD_0_400 && \
	DT_PROP(node, src_hv_ocp) <= NX20P3483_I_THRESHOLD_3_400, \
	"Invalid overcurrent threshold");

	#define NX20P3483_DRIVER_DATA_INIT(node) \
	{ \
	.dev = DEVICE_DT_GET(node), \
	}

	#define NX20P3483_DRIVER_INIT(inst) \
	static struct nx20p3483_data drv_data_nx20p3483##inst = \
	NX20P3483_DRIVER_DATA_INIT(DT_DRV_INST(inst)); \
	NX20P3483_DRIVER_CFG_ASSERTS(DT_DRV_INST(inst)); \
	static struct nx20p3483_cfg drv_cfg_nx20p3483##inst = \
	NX20P3483_DRIVER_CFG_INIT(DT_DRV_INST(inst)); \
	DEVICE_DT_INST_DEFINE(inst, &nx20p3483_dev_init, NULL, &drv_data_nx20p3483##inst, \
	&drv_cfg_nx20p3483##inst, POST_KERNEL, \
	CONFIG_USBC_PPC_INIT_PRIORITY, &nx20p3483_driver_api);

	DT_INST_FOREACH_STATUS_OKAY(NX20P3483_DRIVER_INIT)