drivers/power/supply/nx30p6093.c - kernel/msm-4.9 - Gitiles

 /* Copyright (c) 2017 The Linux Foundation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 and
  * only version 2 as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  */

 #define pr_fmt(fmt)	"%s: " fmt, __func__

 #include <linux/alarmtimer.h>
 #include <linux/debugfs.h>
 #include <linux/device.h>
 #include <linux/errno.h>
 #include <linux/i2c.h>
 #include <linux/module.h>
 #include <linux/mutex.h>
 #include <linux/of.h>
 #include <linux/of_gpio.h>
 #include <linux/platform_device.h>
 #include <linux/pm_wakeup.h>
 #include <linux/power_supply.h>
 #include <linux/regmap.h>
 #include <linux/rtc.h>

 #define NX30P6093_ID_REG			0x0
 #define NX30P6093_VENDOR_ID_MASK		GENMASK(7, 3)
 #define NX30P6093_VENDOR_ID_SHIFT		3
 #define NX30P6093_VERSION_ID_MASK		GENMASK(2, 0)

 #define NX30P6093_ENABLE_REG			0x01
 #define NX30P6093_DETECT_EN			BIT(6)

 #define NX30P6093_STATUS_REG			0x02
 #define NX30P6093_PWRON_STS			BIT(7)
 #define NX30P6093_IMPEDANCE_MASK		GENMASK(6, 5)
 #define NX30P6093_IMPEDANCE_SHIFT		5
 #define NX30P6093_IMPEDANCE_GOOD_VAL		1
 #define NX30P6093_IMPEDANCE_BAD_VAL		3

 #define NX30P6093_INTR_MASK_REG			0x04
 #define NX30P6093_OVER_TAG_STS_INTR_MASK	BIT(6)
 #define NX30P6093_TMR_OUT_STS_INTR_MASK		BIT(5)

 #define NX30P6093_VIN_ISOURCE_REG		0x06
 #define NX30P6093_VIN_ISOURCE_MASK		GENMASK(3, 0)

 #define NX30P6093_ISOURCE_TIMING_REG		0x07
 #define NX30P6093_ISOURCE_TDET_MASK		GENMASK(7, 4)
 #define NX30P6093_ISOURCE_TDET_SHIFT		4
 #define NX30P6093_ISOURCE_TDUTY_MASK		GENMASK(3, 0)

 #define NX30P6093_VIN_VOLTAGE_TAG_REG		0x09
 #define NX30P6093_VIN_VOLTAGE_TAG_MASK	GENMASK(7, 0)

 #define NX30P6093_SLEW_RATE_TUNE_REG		0x0f

 /* short duration is 5sec and long duration is 5hrs */
 #define NX30P6093_LONG_WAKEUP_SEC		18000
 #define NX30P6093_SHORT_WAKEUP_MS		5000

 /* Default Tduty = 5mins when always-on detection is configured */
 #define NX30P6093_ISOURCE_ALWAYS_ON_TDUTY_MS	300000

 /* configuration data */
 #define NX30P6093_VIN_ISOURCE_VAL		0xd
 #define NX30P6093_VIN_VOLTAGE_TAG_VAL		0xad
 #define NX30P6093_ISOURCE_TDET_VAL		0x5
 #define NX30P6093_ISOURCE_TDUTY_VAL		0x0
 #define NX30P6093_ISOURCE_TDET_MS		10

 struct nx30p6093_info {
 	struct device		*dev;
 	struct regmap		*regmap;
 	struct power_supply	*usb_psy;
 	struct alarm		alarm_timer;
 	struct delayed_work	config_impedance_detect;
 	struct mutex		lock;
 	struct dentry		*debugfs;
 	u8			tduty_val;
 	int			irq;

 	/* status data */
 	bool			irq_waiting;
 	bool			high_impedance;
 	bool			detection_on;
 	bool			always_on;
 	bool			use_alarm;
 	bool			suspended;

 	/* timer configuration */
 	u64			long_wakeup_ms;
 	u64			short_wakeup_ms;
 };

 static const int nx30p6093_tduty_ms[] = {0, 10, 20, 50, 100, 200, 500, 1000,
 					 2000, 3000, 6000, 12000, 30000, 60000,
 					 120000, 300000};

 static const struct regmap_config nx30p6093_regmap_config = {
 	.reg_bits	= 8,
 	.val_bits	= 8,
 	.max_register	= NX30P6093_SLEW_RATE_TUNE_REG,
 };

 static int nx30p6093_dump_regs(struct nx30p6093_info *info)
 {
 	unsigned int val;
 	int i, rc = 0;

 	for (i = 0; i <= NX30P6093_SLEW_RATE_TUNE_REG; ++i) {
 		rc = regmap_read(info->regmap, i, &val);
 		if (rc < 0)
 			return rc;
 		pr_debug("NX30P6093(0x%02x) = 0x%02x\n", i, (uint8_t)val);
 	}

 	return rc;
 }

 static inline void nx30p6093_config_alarm(struct nx30p6093_info *info,
 			u64 wakeup_ms)
 {
 	if (!info->use_alarm)
 		return;

 	alarm_start_relative(&info->alarm_timer, ms_to_ktime(wakeup_ms));
 }

 static int nx30p6093_impedance_detect(struct nx30p6093_info *info, bool enable)
 {
 	int rc = 0;

 	if (enable == info->detection_on)
 		return rc;

 	rc = regmap_update_bits(info->regmap, NX30P6093_ENABLE_REG,
 				NX30P6093_DETECT_EN,
 				enable ? NX30P6093_DETECT_EN : 0);
 	if (rc < 0) {
 		pr_err("failed to %s VIN impedance detection, rc=%d\n",
 			enable ? "enable" : "disable", rc);
 		return rc;
 	}

 	/* wait for 3ms for HW activation and enters detection standby mode */
 	usleep_range(3000, 3100);

 	/* config Isource to VIN */
 	rc = regmap_update_bits(info->regmap, NX30P6093_VIN_ISOURCE_REG,
 				NX30P6093_VIN_ISOURCE_MASK,
 				enable ? NX30P6093_VIN_ISOURCE_VAL : 0);
 	if (rc < 0) {
 		pr_err("failed to configure Vin Isource register, rc=%d\n", rc);
 		return rc;
 	}

 	info->detection_on = enable;
 	nx30p6093_dump_regs(info);

 	return rc;
 }

 static int nx30p6093_read_impedance_status(struct nx30p6093_info *info)
 {
 	union power_supply_propval psp_val;
 	unsigned int val;
 	u8 impedance;
 	int rc;

 	/* Read status register */
 	rc = regmap_read(info->regmap, NX30P6093_STATUS_REG, &val);
 	if (rc < 0) {
 		pr_err("failed to read status register, rc=%d\n", rc);
 		return rc;
 	}

 	if (val & NX30P6093_PWRON_STS) {
 		/* VBUS present */
 		return rc;
 	}

 	impedance = (val & NX30P6093_IMPEDANCE_MASK)
 			>> NX30P6093_IMPEDANCE_SHIFT;
 	if (impedance == NX30P6093_IMPEDANCE_GOOD_VAL && info->high_impedance) {
 		info->high_impedance = false;

 		/* enable the type-C CC detection */
 		psp_val.intval = 0;
 		rc = power_supply_set_property(info->usb_psy,
 					POWER_SUPPLY_PROP_MOISTURE_DETECTED,
 					&psp_val);
 	} else if (impedance == NX30P6093_IMPEDANCE_BAD_VAL) {
 		info->high_impedance = true;

 		/* disable the type-C CC detection */
 		psp_val.intval = 1;
 		rc = power_supply_set_property(info->usb_psy,
 					POWER_SUPPLY_PROP_MOISTURE_DETECTED,
 					&psp_val);
 	}

 	return rc;
 }

 static irqreturn_t nx30p6093_irq_handler(int irq, void *data)
 {
 	struct nx30p6093_info *info = data;

 	mutex_lock(&info->lock);

 	info->irq_waiting = true;
 	if (info->suspended) {
 		pr_debug("IRQ triggered before device-resume\n");
 		disable_irq_nosync(irq);
 		mutex_unlock(&info->lock);
 		return IRQ_HANDLED;
 	}
 	info->irq_waiting = false;
 	mutex_unlock(&info->lock);

 	nx30p6093_read_impedance_status(info);

 	if (info->high_impedance) {
 		disable_irq_nosync(irq);
 		/* set up next detection event */
 		nx30p6093_config_alarm(info,
 				NX30P6093_ISOURCE_ALWAYS_ON_TDUTY_MS);
 	}

 	return IRQ_HANDLED;
 }

 static int nx30p6093_trigger_impedance_detect(struct nx30p6093_info *info)
 {
 	int rc;

 	if (!info->always_on) {
 		rc = nx30p6093_impedance_detect(info, true);
 		if (rc < 0) {
 			pr_err("start impedance detection failed, rc=%d\n", rc);
 			return rc;
 		}

 		/* wait for the detection complete(Tdet time). */
 		usleep_range(NX30P6093_ISOURCE_TDET_MS * USEC_PER_MSEC,
 			     NX30P6093_ISOURCE_TDET_MS * USEC_PER_MSEC + 100);
 	}

 	/* Read and process the detection result. */
 	rc = nx30p6093_read_impedance_status(info);
 	if (rc < 0)
 		pr_err("impedance status read failed, rc=%d\n", rc);

 	if (!info->always_on) {
 		rc = nx30p6093_impedance_detect(info, false);
 		if (rc < 0)
 			pr_err("stop impedance detection failed, rc=%d\n", rc);
 	}

 	return rc;
 }

 static void nx30p6093_config_impedance_detect(struct work_struct *work)
 {
 	struct nx30p6093_info *info = container_of(work, struct nx30p6093_info,
 						config_impedance_detect.work);
 	u64 wakeup_ms = 0;

 	mutex_lock(&info->lock);
 	if (info->suspended) {
 		/*
 		 * Defer the work as the device is still in suspend state and
 		 * not yet resumed.
 		 */
 		schedule_delayed_work(&info->config_impedance_detect,
 				msecs_to_jiffies(500));
 		mutex_unlock(&info->lock);
 		return;
 	}

 	nx30p6093_trigger_impedance_detect(info);

 	if (info->always_on) {
 		if (info->high_impedance) {
 			/*
 			 * Bad impedance is not cleared yet.
 			 * Set up a next detection event.
 			 */
 			nx30p6093_config_alarm(info,
 					NX30P6093_ISOURCE_ALWAYS_ON_TDUTY_MS);
 		} else {
 			/* Bad impedance is cleared. Enable detection IRQ */
 			enable_irq(info->irq);
 		}
 	} else {
 		wakeup_ms = info->high_impedance ? info->short_wakeup_ms
 						 : info->long_wakeup_ms;

 		/* Set up a next detection event */
 		nx30p6093_config_alarm(info, wakeup_ms);
 	}

 	mutex_unlock(&info->lock);
 	pm_relax(info->dev);
 }

 static enum alarmtimer_restart
 	nx30p6093_process_alarm_event(struct alarm *alarm, ktime_t now)
 {
 	struct nx30p6093_info *info = container_of(alarm, struct nx30p6093_info,
 						alarm_timer);
 	union power_supply_propval val;
 	int rc;

 	/* Read USB plugged-in */
 	rc = power_supply_get_property(info->usb_psy, POWER_SUPPLY_PROP_PRESENT,
 				       &val);
 	if (rc < 0) {
 		pr_err("read usb present failed, rc=%d\n", rc);
 		return ALARMTIMER_RESTART;
 	}

 	if (val.intval) {
 		/*
 		 * usb present - skip impedance detection and set up
 		 * next detection event.
 		 */
 		nx30p6093_config_alarm(info, info->long_wakeup_ms);
 	} else {
 		pm_stay_awake(info->dev);
 		schedule_delayed_work(&info->config_impedance_detect, 0);
 	}

 	return ALARMTIMER_NORESTART;
 }

 static int nx30p6093_init_config(struct nx30p6093_info *info)
 {
 	int rc;
 	u8 val;

 	/* Enable OVER_TAG_STATUS interrupt if always-on detection enabled */
 	rc = regmap_write(info->regmap, NX30P6093_INTR_MASK_REG,
 			  info->always_on ? NX30P6093_OVER_TAG_STS_INTR_MASK
 					  : 0);
 	if (rc < 0) {
 		pr_err("failed to enable timer out status interrupt, rc=%d\n",
 			rc);
 		return rc;
 	}

 	/* config Isource timing (Default: 10ms) */
 	val = NX30P6093_ISOURCE_TDET_VAL << NX30P6093_ISOURCE_TDET_SHIFT;
 	rc = regmap_update_bits(info->regmap, NX30P6093_ISOURCE_TIMING_REG,
 				NX30P6093_ISOURCE_TDET_MASK, val);
 	if (rc < 0) {
 		pr_err("failed to configure Isource timing, rc=%d\n", rc);
 		return rc;
 	}

 	/*
 	 * config Isource Tduty timing;
 	 * Default value:
 	 *	1) One shot - if Periodic detection enabled
 	 *	2) 5 mins   - if Always-on detection enabled
 	 */
 	rc = regmap_update_bits(info->regmap, NX30P6093_ISOURCE_TIMING_REG,
 				NX30P6093_ISOURCE_TDUTY_MASK,
 				info->always_on ? info->tduty_val
 					: NX30P6093_ISOURCE_TDUTY_VAL);
 	if (rc < 0) {
 		pr_err("failed to configure Isource Tduty timing, rc=%d\n", rc);
 		return rc;
 	}

 	/* config VIN voltage tag (Default: 0xad) */
 	rc = regmap_update_bits(info->regmap, NX30P6093_VIN_VOLTAGE_TAG_REG,
 				NX30P6093_VIN_VOLTAGE_TAG_MASK,
 				NX30P6093_VIN_VOLTAGE_TAG_VAL);
 	if (rc < 0) {
 		pr_err("failed to configure Vin voltage tag register, rc=%d\n",
 			rc);
 		return rc;
 	}

 	return 0;
 }

 static int nx30p6093_dt_init(struct i2c_client *client,
 			struct nx30p6093_info *info)
 {
 	struct device_node *of_node = client->dev.of_node;
 	int i, tduty_ms;
 	u32 long_wakeup_sec, short_wakeup_ms;

 	if (of_property_read_bool(of_node, "nxp,always-on-detect")) {
 		info->always_on = true;
 		tduty_ms = NX30P6093_ISOURCE_ALWAYS_ON_TDUTY_MS;
 		of_property_read_u32(of_node, "nxp,always-on-tduty-ms",
 				     &tduty_ms);
 		for (i = 0; i < ARRAY_SIZE(nx30p6093_tduty_ms); i++) {
 			if (tduty_ms <= nx30p6093_tduty_ms[i]) {
 				info->tduty_val = (uint8_t)i;
 				break;
 			}
 		}

 		if (!info->tduty_val) {
 			pr_err("invalid nxp,always-on-tduty-ms = %d\n",
 				tduty_ms);
 			return -EINVAL;
 		}
 	} else {
 		long_wakeup_sec = NX30P6093_LONG_WAKEUP_SEC;
 		short_wakeup_ms = NX30P6093_SHORT_WAKEUP_MS;

 		of_property_read_u32(of_node, "nxp,long-wakeup-sec",
 				  &long_wakeup_sec);
 		of_property_read_u32(of_node, "nxp,short-wakeup-ms",
 				  &short_wakeup_ms);
 		if (!long_wakeup_sec || !short_wakeup_ms) {
 			pr_err("Invalid wakeup timings are configured\n");
 			return -EINVAL;
 		}

 		info->long_wakeup_ms = long_wakeup_sec * MSEC_PER_SEC;
 		info->short_wakeup_ms = short_wakeup_ms;
 	}

 	return 0;
 }

 static int nx30p6093_trigger_detect(struct seq_file *file, void *data)
 {
 	struct nx30p6093_info *info = file->private;

 	if (info->always_on)
 		return 0;

 	mutex_lock(&info->lock);
 	nx30p6093_trigger_impedance_detect(info);
 	seq_printf(file, "%s impedance detected\n",
 		   info->high_impedance ? "BAD" : "GOOD");
 	mutex_unlock(&info->lock);

 	return 0;
 }

 static int nx30p6093_trigger_detect_open(struct inode *inode, struct file *file)
 {
 	return single_open(file, nx30p6093_trigger_detect, inode->i_private);
 }

 static const struct file_operations nx30p6093_trigger_detect_fops = {
 	.owner		= THIS_MODULE,
 	.open		= nx30p6093_trigger_detect_open,
 	.read		= seq_read,
 	.llseek		= seq_lseek,
 	.release	= single_release,
 };

 static void nx30p6093_debugfs_init(struct nx30p6093_info *info)
 {
 	struct dentry *temp;

 	/* debugfs */
 	info->debugfs = debugfs_create_dir("nx30p6093", NULL);
 	if (!info->debugfs) {
 		pr_err("Couldn't create debug dir\n");
 		return;
 	}

 	temp = debugfs_create_file("trigger_detection", 0644, info->debugfs,
 				info, &nx30p6093_trigger_detect_fops);
 	if (IS_ERR_OR_NULL(temp)) {
 		pr_err("debugfs_nx30p6093_reg_addr_fops debugfs file creation failed\n");
 		debugfs_remove_recursive(info->debugfs);
 	}
 }

 #if CONFIG_PM
 static int nx30p6093_suspend(struct device *dev)
 {
 	struct i2c_client *client = to_i2c_client(dev);
 	struct nx30p6093_info *info = i2c_get_clientdata(client);

 	cancel_delayed_work_sync(&info->config_impedance_detect);

 	mutex_lock(&info->lock);
 	info->suspended = true;
 	mutex_unlock(&info->lock);

 	return 0;
 }

 static int nx30p6093_suspend_noirq(struct device *dev)
 {
 	struct i2c_client *client = to_i2c_client(dev);
 	struct nx30p6093_info *info = i2c_get_clientdata(client);

 	if (info->irq_waiting) {
 		pr_err_ratelimited("Aborting suspend, an interrupt was detected while suspending\n");
 		return -EBUSY;
 	}
 	return 0;
 }

 static int nx30p6093_resume(struct device *dev)
 {
 	struct i2c_client *client = to_i2c_client(dev);
 	struct nx30p6093_info *info = i2c_get_clientdata(client);

 	mutex_lock(&info->lock);
 	info->suspended = false;
 	if (info->irq_waiting) {
 		mutex_unlock(&info->lock);
 		nx30p6093_irq_handler(client->irq, info);
 		enable_irq(client->irq);
 	} else {
 		mutex_unlock(&info->lock);
 	}

 	return 0;
 }
 #else
 static int nx30p6093_suspend(struct device *dev)
 {
 	return 0;
 }

 static int nx30p6093_resume(struct device *dev)
 {
 	return 0;
 }
 #endif

 static const struct dev_pm_ops nx30p6093_pm_ops = {
 	.suspend	= nx30p6093_suspend,
 	.suspend_noirq	= nx30p6093_suspend_noirq,
 	.resume		= nx30p6093_resume,
 };

 static int nx30p6093_probe(struct i2c_client *client,
 		const struct i2c_device_id *id)
 {
 	struct nx30p6093_info *info;
 	unsigned int val;
 	int vendor_id, version_id, rc = 0;

 	info = devm_kzalloc(&client->dev, sizeof(*info), GFP_KERNEL);
 	if (!info)
 		return -ENOMEM;

 	info->dev = &client->dev;
 	info->regmap = devm_regmap_init_i2c(client, &nx30p6093_regmap_config);
 	if (IS_ERR(info->regmap)) {
 		pr_err("Error in allocating regmap, rc=%ld\n",
 			PTR_ERR(info->regmap));
 		return PTR_ERR(info->regmap);
 	}

 	rc = regmap_read(info->regmap, NX30P6093_ID_REG, &val);
 	if (rc < 0) {
 		pr_err("Unable to identify NX30P6093, rc=%d\n", rc);
 		return rc;
 	}
 	vendor_id = (val & NX30P6093_VENDOR_ID_MASK)
 			  >> NX30P6093_VENDOR_ID_SHIFT;
 	version_id = val & NX30P6093_VERSION_ID_MASK;

 	info->usb_psy = power_supply_get_by_name("usb");
 	if (!info->usb_psy) {
 		pr_err("USB psy not found\n");
 		return -EPROBE_DEFER;
 	}

 	i2c_set_clientdata(client, info);
 	mutex_init(&info->lock);
 	INIT_DELAYED_WORK(&info->config_impedance_detect,
 			  nx30p6093_config_impedance_detect);

 	rc = nx30p6093_dt_init(client, info);
 	if (rc < 0) {
 		pr_err("device tree parsing failed, rc=%d\n", rc);
 		return rc;
 	}

 	rc = nx30p6093_init_config(info);
 	if (rc < 0) {
 		pr_err("initial configuration programming failed, rc=%d\n", rc);
 		return rc;
 	}

 	if (alarmtimer_get_rtcdev()) {
 		/* Initialize alarm timer */
 		info->use_alarm = true;
 		alarm_init(&info->alarm_timer, ALARM_BOOTTIME,
 				nx30p6093_process_alarm_event);
 	} else {
 		pr_err("alarm initialization failed\n");
 		return -ENODEV;
 	}

 	if (info->always_on) {
 		/* Moisture detect irq configuration */
 		if (client->irq) {
 			info->irq = client->irq;
 			rc = devm_request_threaded_irq(&client->dev,
 					client->irq, NULL,
 					nx30p6093_irq_handler,
 					IRQF_ONESHOT | IRQF_TRIGGER_FALLING,
 					client->name, info);
 			if (rc < 0) {
 				pr_err("Failed Moisture detect irq(%d) request, rc=%d\n",
 					client->irq, rc);
 				return rc;
 			}
 			enable_irq_wake(client->irq);
 		} else {
 			pr_err("Moisture detect irq not defined\n");
 			return -EINVAL;
 		}

 		nx30p6093_impedance_detect(info, true);
 	} else {
 		/* Run impedance detection for first time */
 		pm_stay_awake(info->dev);
 		schedule_delayed_work(&info->config_impedance_detect, 0);
 	}

 	nx30p6093_debugfs_init(info);

 	if (info->always_on)
 		pr_info("NXP NX30P6093 Vendor(%d), Version(%d), configured to Always-on detection\n",
 			vendor_id, version_id);
 	else
 		pr_info("NXP NX30P6093 Vendor(%d), Version(%d), configured to periodic detection with Short_wakeup = %llu ms and Long_wakeup = %llu sec\n",
 			vendor_id, version_id, info->short_wakeup_ms,
 			info->long_wakeup_ms / MSEC_PER_SEC);

 	return 0;
 }

 static int nx30p6093_remove(struct i2c_client *client)
 {
 	struct nx30p6093_info *info = i2c_get_clientdata(client);

 	debugfs_remove_recursive(info->debugfs);
 	cancel_delayed_work_sync(&info->config_impedance_detect);

 	if (info->use_alarm)
 		alarm_cancel(&info->alarm_timer);

 	return 0;
 }

 static const struct of_device_id nx30p6093_table[] = {
 	{ .compatible = "nxp,nx30p6093" },
 	{ },
 };
 MODULE_DEVICE_TABLE(of, nx30p6093_table);

 static const struct i2c_device_id nx30p6093_id[] = {
 	{"nx30p6093", -1},
 	{ },
 };
 MODULE_DEVICE_TABLE(i2c, nx30p6093_id);

 static struct i2c_driver nx30p6093_driver = {
 	.driver = {
 		.name = "nxp,nx30p6093",
 		.owner = THIS_MODULE,
 		.of_match_table = nx30p6093_table,
 		.pm = &nx30p6093_pm_ops,
 	},
 	.probe = nx30p6093_probe,
 	.remove = nx30p6093_remove,
 	.id_table = nx30p6093_id,
 };
 module_i2c_driver(nx30p6093_driver);

 MODULE_DESCRIPTION("NX30P6093 driver");
 MODULE_LICENSE("GPL v2");
	/* Copyright (c) 2017 The Linux Foundation. All rights reserved.
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License version 2 and
	* only version 2 as published by the Free Software Foundation.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*/

	#define pr_fmt(fmt) "%s: " fmt, __func__

	#include <linux/alarmtimer.h>
	#include <linux/debugfs.h>
	#include <linux/device.h>
	#include <linux/errno.h>
	#include <linux/i2c.h>
	#include <linux/module.h>
	#include <linux/mutex.h>
	#include <linux/of.h>
	#include <linux/of_gpio.h>
	#include <linux/platform_device.h>
	#include <linux/pm_wakeup.h>
	#include <linux/power_supply.h>
	#include <linux/regmap.h>
	#include <linux/rtc.h>

	#define NX30P6093_ID_REG 0x0
	#define NX30P6093_VENDOR_ID_MASK GENMASK(7, 3)
	#define NX30P6093_VENDOR_ID_SHIFT 3
	#define NX30P6093_VERSION_ID_MASK GENMASK(2, 0)

	#define NX30P6093_ENABLE_REG 0x01
	#define NX30P6093_DETECT_EN BIT(6)

	#define NX30P6093_STATUS_REG 0x02
	#define NX30P6093_PWRON_STS BIT(7)
	#define NX30P6093_IMPEDANCE_MASK GENMASK(6, 5)
	#define NX30P6093_IMPEDANCE_SHIFT 5
	#define NX30P6093_IMPEDANCE_GOOD_VAL 1
	#define NX30P6093_IMPEDANCE_BAD_VAL 3

	#define NX30P6093_INTR_MASK_REG 0x04
	#define NX30P6093_OVER_TAG_STS_INTR_MASK BIT(6)
	#define NX30P6093_TMR_OUT_STS_INTR_MASK BIT(5)

	#define NX30P6093_VIN_ISOURCE_REG 0x06
	#define NX30P6093_VIN_ISOURCE_MASK GENMASK(3, 0)

	#define NX30P6093_ISOURCE_TIMING_REG 0x07
	#define NX30P6093_ISOURCE_TDET_MASK GENMASK(7, 4)
	#define NX30P6093_ISOURCE_TDET_SHIFT 4
	#define NX30P6093_ISOURCE_TDUTY_MASK GENMASK(3, 0)

	#define NX30P6093_VIN_VOLTAGE_TAG_REG 0x09
	#define NX30P6093_VIN_VOLTAGE_TAG_MASK GENMASK(7, 0)

	#define NX30P6093_SLEW_RATE_TUNE_REG 0x0f

	/* short duration is 5sec and long duration is 5hrs */
	#define NX30P6093_LONG_WAKEUP_SEC 18000
	#define NX30P6093_SHORT_WAKEUP_MS 5000

	/* Default Tduty = 5mins when always-on detection is configured */
	#define NX30P6093_ISOURCE_ALWAYS_ON_TDUTY_MS 300000

	/* configuration data */
	#define NX30P6093_VIN_ISOURCE_VAL 0xd
	#define NX30P6093_VIN_VOLTAGE_TAG_VAL 0xad
	#define NX30P6093_ISOURCE_TDET_VAL 0x5
	#define NX30P6093_ISOURCE_TDUTY_VAL 0x0
	#define NX30P6093_ISOURCE_TDET_MS 10

	struct nx30p6093_info {
	struct device *dev;
	struct regmap *regmap;
	struct power_supply *usb_psy;
	struct alarm alarm_timer;
	struct delayed_work config_impedance_detect;
	struct mutex lock;
	struct dentry *debugfs;
	u8 tduty_val;
	int irq;

	/* status data */
	bool irq_waiting;
	bool high_impedance;
	bool detection_on;
	bool always_on;
	bool use_alarm;
	bool suspended;

	/* timer configuration */
	u64 long_wakeup_ms;
	u64 short_wakeup_ms;
	};

	static const int nx30p6093_tduty_ms[] = {0, 10, 20, 50, 100, 200, 500, 1000,
	2000, 3000, 6000, 12000, 30000, 60000,
	120000, 300000};

	static const struct regmap_config nx30p6093_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,
	.max_register = NX30P6093_SLEW_RATE_TUNE_REG,
	};

	static int nx30p6093_dump_regs(struct nx30p6093_info *info)
	{
	unsigned int val;
	int i, rc = 0;

	for (i = 0; i <= NX30P6093_SLEW_RATE_TUNE_REG; ++i) {
	rc = regmap_read(info->regmap, i, &val);
	if (rc < 0)
	return rc;
	pr_debug("NX30P6093(0x%02x) = 0x%02x\n", i, (uint8_t)val);
	}

	return rc;
	}

	static inline void nx30p6093_config_alarm(struct nx30p6093_info *info,
	u64 wakeup_ms)
	{
	if (!info->use_alarm)
	return;

	alarm_start_relative(&info->alarm_timer, ms_to_ktime(wakeup_ms));
	}

	static int nx30p6093_impedance_detect(struct nx30p6093_info *info, bool enable)
	{
	int rc = 0;

	if (enable == info->detection_on)
	return rc;

	rc = regmap_update_bits(info->regmap, NX30P6093_ENABLE_REG,
	NX30P6093_DETECT_EN,
	enable ? NX30P6093_DETECT_EN : 0);
	if (rc < 0) {
	pr_err("failed to %s VIN impedance detection, rc=%d\n",
	enable ? "enable" : "disable", rc);
	return rc;
	}

	/* wait for 3ms for HW activation and enters detection standby mode */
	usleep_range(3000, 3100);

	/* config Isource to VIN */
	rc = regmap_update_bits(info->regmap, NX30P6093_VIN_ISOURCE_REG,
	NX30P6093_VIN_ISOURCE_MASK,
	enable ? NX30P6093_VIN_ISOURCE_VAL : 0);
	if (rc < 0) {
	pr_err("failed to configure Vin Isource register, rc=%d\n", rc);
	return rc;
	}

	info->detection_on = enable;
	nx30p6093_dump_regs(info);

	return rc;
	}

	static int nx30p6093_read_impedance_status(struct nx30p6093_info *info)
	{
	union power_supply_propval psp_val;
	unsigned int val;
	u8 impedance;
	int rc;

	/* Read status register */
	rc = regmap_read(info->regmap, NX30P6093_STATUS_REG, &val);
	if (rc < 0) {
	pr_err("failed to read status register, rc=%d\n", rc);
	return rc;
	}

	if (val & NX30P6093_PWRON_STS) {
	/* VBUS present */
	return rc;
	}

	impedance = (val & NX30P6093_IMPEDANCE_MASK)
	>> NX30P6093_IMPEDANCE_SHIFT;
	if (impedance == NX30P6093_IMPEDANCE_GOOD_VAL && info->high_impedance) {
	info->high_impedance = false;

	/* enable the type-C CC detection */
	psp_val.intval = 0;
	rc = power_supply_set_property(info->usb_psy,
	POWER_SUPPLY_PROP_MOISTURE_DETECTED,
	&psp_val);
	} else if (impedance == NX30P6093_IMPEDANCE_BAD_VAL) {
	info->high_impedance = true;

	/* disable the type-C CC detection */
	psp_val.intval = 1;
	rc = power_supply_set_property(info->usb_psy,
	POWER_SUPPLY_PROP_MOISTURE_DETECTED,
	&psp_val);
	}

	return rc;
	}

	static irqreturn_t nx30p6093_irq_handler(int irq, void *data)
	{
	struct nx30p6093_info *info = data;

	mutex_lock(&info->lock);

	info->irq_waiting = true;
	if (info->suspended) {
	pr_debug("IRQ triggered before device-resume\n");
	disable_irq_nosync(irq);
	mutex_unlock(&info->lock);
	return IRQ_HANDLED;
	}
	info->irq_waiting = false;
	mutex_unlock(&info->lock);

	nx30p6093_read_impedance_status(info);

	if (info->high_impedance) {
	disable_irq_nosync(irq);
	/* set up next detection event */
	nx30p6093_config_alarm(info,
	NX30P6093_ISOURCE_ALWAYS_ON_TDUTY_MS);
	}

	return IRQ_HANDLED;
	}

	static int nx30p6093_trigger_impedance_detect(struct nx30p6093_info *info)
	{
	int rc;

	if (!info->always_on) {
	rc = nx30p6093_impedance_detect(info, true);
	if (rc < 0) {
	pr_err("start impedance detection failed, rc=%d\n", rc);
	return rc;
	}

	/* wait for the detection complete(Tdet time). */
	usleep_range(NX30P6093_ISOURCE_TDET_MS * USEC_PER_MSEC,
	NX30P6093_ISOURCE_TDET_MS * USEC_PER_MSEC + 100);
	}

	/* Read and process the detection result. */
	rc = nx30p6093_read_impedance_status(info);
	if (rc < 0)
	pr_err("impedance status read failed, rc=%d\n", rc);

	if (!info->always_on) {
	rc = nx30p6093_impedance_detect(info, false);
	if (rc < 0)
	pr_err("stop impedance detection failed, rc=%d\n", rc);
	}

	return rc;
	}

	static void nx30p6093_config_impedance_detect(struct work_struct *work)
	{
	struct nx30p6093_info *info = container_of(work, struct nx30p6093_info,
	config_impedance_detect.work);
	u64 wakeup_ms = 0;

	mutex_lock(&info->lock);
	if (info->suspended) {
	/*
	* Defer the work as the device is still in suspend state and
	* not yet resumed.
	*/
	schedule_delayed_work(&info->config_impedance_detect,
	msecs_to_jiffies(500));
	mutex_unlock(&info->lock);
	return;
	}

	nx30p6093_trigger_impedance_detect(info);

	if (info->always_on) {
	if (info->high_impedance) {
	/*
	* Bad impedance is not cleared yet.
	* Set up a next detection event.
	*/
	nx30p6093_config_alarm(info,
	NX30P6093_ISOURCE_ALWAYS_ON_TDUTY_MS);
	} else {
	/* Bad impedance is cleared. Enable detection IRQ */
	enable_irq(info->irq);
	}
	} else {
	wakeup_ms = info->high_impedance ? info->short_wakeup_ms
	: info->long_wakeup_ms;

	/* Set up a next detection event */
	nx30p6093_config_alarm(info, wakeup_ms);
	}

	mutex_unlock(&info->lock);
	pm_relax(info->dev);
	}

	static enum alarmtimer_restart
	nx30p6093_process_alarm_event(struct alarm *alarm, ktime_t now)
	{
	struct nx30p6093_info *info = container_of(alarm, struct nx30p6093_info,
	alarm_timer);
	union power_supply_propval val;
	int rc;

	/* Read USB plugged-in */
	rc = power_supply_get_property(info->usb_psy, POWER_SUPPLY_PROP_PRESENT,
	&val);
	if (rc < 0) {
	pr_err("read usb present failed, rc=%d\n", rc);
	return ALARMTIMER_RESTART;
	}

	if (val.intval) {
	/*
	* usb present - skip impedance detection and set up
	* next detection event.
	*/
	nx30p6093_config_alarm(info, info->long_wakeup_ms);
	} else {
	pm_stay_awake(info->dev);
	schedule_delayed_work(&info->config_impedance_detect, 0);
	}

	return ALARMTIMER_NORESTART;
	}

	static int nx30p6093_init_config(struct nx30p6093_info *info)
	{
	int rc;
	u8 val;

	/* Enable OVER_TAG_STATUS interrupt if always-on detection enabled */
	rc = regmap_write(info->regmap, NX30P6093_INTR_MASK_REG,
	info->always_on ? NX30P6093_OVER_TAG_STS_INTR_MASK
	: 0);
	if (rc < 0) {
	pr_err("failed to enable timer out status interrupt, rc=%d\n",
	rc);
	return rc;
	}

	/* config Isource timing (Default: 10ms) */
	val = NX30P6093_ISOURCE_TDET_VAL << NX30P6093_ISOURCE_TDET_SHIFT;
	rc = regmap_update_bits(info->regmap, NX30P6093_ISOURCE_TIMING_REG,
	NX30P6093_ISOURCE_TDET_MASK, val);
	if (rc < 0) {
	pr_err("failed to configure Isource timing, rc=%d\n", rc);
	return rc;
	}

	/*
	* config Isource Tduty timing;
	* Default value:
	* 1) One shot - if Periodic detection enabled
	* 2) 5 mins - if Always-on detection enabled
	*/
	rc = regmap_update_bits(info->regmap, NX30P6093_ISOURCE_TIMING_REG,
	NX30P6093_ISOURCE_TDUTY_MASK,
	info->always_on ? info->tduty_val
	: NX30P6093_ISOURCE_TDUTY_VAL);
	if (rc < 0) {
	pr_err("failed to configure Isource Tduty timing, rc=%d\n", rc);
	return rc;
	}

	/* config VIN voltage tag (Default: 0xad) */
	rc = regmap_update_bits(info->regmap, NX30P6093_VIN_VOLTAGE_TAG_REG,
	NX30P6093_VIN_VOLTAGE_TAG_MASK,
	NX30P6093_VIN_VOLTAGE_TAG_VAL);
	if (rc < 0) {
	pr_err("failed to configure Vin voltage tag register, rc=%d\n",
	rc);
	return rc;
	}

	return 0;
	}

	static int nx30p6093_dt_init(struct i2c_client *client,
	struct nx30p6093_info *info)
	{
	struct device_node *of_node = client->dev.of_node;
	int i, tduty_ms;
	u32 long_wakeup_sec, short_wakeup_ms;

	if (of_property_read_bool(of_node, "nxp,always-on-detect")) {
	info->always_on = true;
	tduty_ms = NX30P6093_ISOURCE_ALWAYS_ON_TDUTY_MS;
	of_property_read_u32(of_node, "nxp,always-on-tduty-ms",
	&tduty_ms);
	for (i = 0; i < ARRAY_SIZE(nx30p6093_tduty_ms); i++) {
	if (tduty_ms <= nx30p6093_tduty_ms[i]) {
	info->tduty_val = (uint8_t)i;
	break;
	}
	}

	if (!info->tduty_val) {
	pr_err("invalid nxp,always-on-tduty-ms = %d\n",
	tduty_ms);
	return -EINVAL;
	}
	} else {
	long_wakeup_sec = NX30P6093_LONG_WAKEUP_SEC;
	short_wakeup_ms = NX30P6093_SHORT_WAKEUP_MS;

	of_property_read_u32(of_node, "nxp,long-wakeup-sec",
	&long_wakeup_sec);
	of_property_read_u32(of_node, "nxp,short-wakeup-ms",
	&short_wakeup_ms);
	if (!long_wakeup_sec \|\| !short_wakeup_ms) {
	pr_err("Invalid wakeup timings are configured\n");
	return -EINVAL;
	}

	info->long_wakeup_ms = long_wakeup_sec * MSEC_PER_SEC;
	info->short_wakeup_ms = short_wakeup_ms;
	}

	return 0;
	}

	static int nx30p6093_trigger_detect(struct seq_file file, void data)
	{
	struct nx30p6093_info *info = file->private;

	if (info->always_on)
	return 0;

	mutex_lock(&info->lock);
	nx30p6093_trigger_impedance_detect(info);
	seq_printf(file, "%s impedance detected\n",
	info->high_impedance ? "BAD" : "GOOD");
	mutex_unlock(&info->lock);

	return 0;
	}

	static int nx30p6093_trigger_detect_open(struct inode inode, struct file file)
	{
	return single_open(file, nx30p6093_trigger_detect, inode->i_private);
	}

	static const struct file_operations nx30p6093_trigger_detect_fops = {
	.owner = THIS_MODULE,
	.open = nx30p6093_trigger_detect_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
	};

	static void nx30p6093_debugfs_init(struct nx30p6093_info *info)
	{
	struct dentry *temp;

	/* debugfs */
	info->debugfs = debugfs_create_dir("nx30p6093", NULL);
	if (!info->debugfs) {
	pr_err("Couldn't create debug dir\n");
	return;
	}

	temp = debugfs_create_file("trigger_detection", 0644, info->debugfs,
	info, &nx30p6093_trigger_detect_fops);
	if (IS_ERR_OR_NULL(temp)) {
	pr_err("debugfs_nx30p6093_reg_addr_fops debugfs file creation failed\n");
	debugfs_remove_recursive(info->debugfs);
	}
	}

	#if CONFIG_PM
	static int nx30p6093_suspend(struct device *dev)
	{
	struct i2c_client *client = to_i2c_client(dev);
	struct nx30p6093_info *info = i2c_get_clientdata(client);

	cancel_delayed_work_sync(&info->config_impedance_detect);

	mutex_lock(&info->lock);
	info->suspended = true;
	mutex_unlock(&info->lock);

	return 0;
	}

	static int nx30p6093_suspend_noirq(struct device *dev)
	{
	struct i2c_client *client = to_i2c_client(dev);
	struct nx30p6093_info *info = i2c_get_clientdata(client);

	if (info->irq_waiting) {
	pr_err_ratelimited("Aborting suspend, an interrupt was detected while suspending\n");
	return -EBUSY;
	}
	return 0;
	}

	static int nx30p6093_resume(struct device *dev)
	{
	struct i2c_client *client = to_i2c_client(dev);
	struct nx30p6093_info *info = i2c_get_clientdata(client);

	mutex_lock(&info->lock);
	info->suspended = false;
	if (info->irq_waiting) {
	mutex_unlock(&info->lock);
	nx30p6093_irq_handler(client->irq, info);
	enable_irq(client->irq);
	} else {
	mutex_unlock(&info->lock);
	}

	return 0;
	}
	#else
	static int nx30p6093_suspend(struct device *dev)
	{
	return 0;
	}

	static int nx30p6093_resume(struct device *dev)
	{
	return 0;
	}
	#endif

	static const struct dev_pm_ops nx30p6093_pm_ops = {
	.suspend = nx30p6093_suspend,
	.suspend_noirq = nx30p6093_suspend_noirq,
	.resume = nx30p6093_resume,
	};

	static int nx30p6093_probe(struct i2c_client *client,
	const struct i2c_device_id *id)
	{
	struct nx30p6093_info *info;
	unsigned int val;
	int vendor_id, version_id, rc = 0;

	info = devm_kzalloc(&client->dev, sizeof(*info), GFP_KERNEL);
	if (!info)
	return -ENOMEM;

	info->dev = &client->dev;
	info->regmap = devm_regmap_init_i2c(client, &nx30p6093_regmap_config);
	if (IS_ERR(info->regmap)) {
	pr_err("Error in allocating regmap, rc=%ld\n",
	PTR_ERR(info->regmap));
	return PTR_ERR(info->regmap);
	}

	rc = regmap_read(info->regmap, NX30P6093_ID_REG, &val);
	if (rc < 0) {
	pr_err("Unable to identify NX30P6093, rc=%d\n", rc);
	return rc;
	}
	vendor_id = (val & NX30P6093_VENDOR_ID_MASK)
	>> NX30P6093_VENDOR_ID_SHIFT;
	version_id = val & NX30P6093_VERSION_ID_MASK;

	info->usb_psy = power_supply_get_by_name("usb");
	if (!info->usb_psy) {
	pr_err("USB psy not found\n");
	return -EPROBE_DEFER;
	}

	i2c_set_clientdata(client, info);
	mutex_init(&info->lock);
	INIT_DELAYED_WORK(&info->config_impedance_detect,
	nx30p6093_config_impedance_detect);

	rc = nx30p6093_dt_init(client, info);
	if (rc < 0) {
	pr_err("device tree parsing failed, rc=%d\n", rc);
	return rc;
	}

	rc = nx30p6093_init_config(info);
	if (rc < 0) {
	pr_err("initial configuration programming failed, rc=%d\n", rc);
	return rc;
	}

	if (alarmtimer_get_rtcdev()) {
	/* Initialize alarm timer */
	info->use_alarm = true;
	alarm_init(&info->alarm_timer, ALARM_BOOTTIME,
	nx30p6093_process_alarm_event);
	} else {
	pr_err("alarm initialization failed\n");
	return -ENODEV;
	}

	if (info->always_on) {
	/* Moisture detect irq configuration */
	if (client->irq) {
	info->irq = client->irq;
	rc = devm_request_threaded_irq(&client->dev,
	client->irq, NULL,
	nx30p6093_irq_handler,
	IRQF_ONESHOT \| IRQF_TRIGGER_FALLING,
	client->name, info);
	if (rc < 0) {
	pr_err("Failed Moisture detect irq(%d) request, rc=%d\n",
	client->irq, rc);
	return rc;
	}
	enable_irq_wake(client->irq);
	} else {
	pr_err("Moisture detect irq not defined\n");
	return -EINVAL;
	}

	nx30p6093_impedance_detect(info, true);
	} else {
	/* Run impedance detection for first time */
	pm_stay_awake(info->dev);
	schedule_delayed_work(&info->config_impedance_detect, 0);
	}

	nx30p6093_debugfs_init(info);

	if (info->always_on)
	pr_info("NXP NX30P6093 Vendor(%d), Version(%d), configured to Always-on detection\n",
	vendor_id, version_id);
	else
	pr_info("NXP NX30P6093 Vendor(%d), Version(%d), configured to periodic detection with Short_wakeup = %llu ms and Long_wakeup = %llu sec\n",
	vendor_id, version_id, info->short_wakeup_ms,
	info->long_wakeup_ms / MSEC_PER_SEC);

	return 0;
	}

	static int nx30p6093_remove(struct i2c_client *client)
	{
	struct nx30p6093_info *info = i2c_get_clientdata(client);

	debugfs_remove_recursive(info->debugfs);
	cancel_delayed_work_sync(&info->config_impedance_detect);

	if (info->use_alarm)
	alarm_cancel(&info->alarm_timer);

	return 0;
	}

	static const struct of_device_id nx30p6093_table[] = {
	{ .compatible = "nxp,nx30p6093" },
	{ },
	};
	MODULE_DEVICE_TABLE(of, nx30p6093_table);

	static const struct i2c_device_id nx30p6093_id[] = {
	{"nx30p6093", -1},
	{ },
	};
	MODULE_DEVICE_TABLE(i2c, nx30p6093_id);

	static struct i2c_driver nx30p6093_driver = {
	.driver = {
	.name = "nxp,nx30p6093",
	.owner = THIS_MODULE,
	.of_match_table = nx30p6093_table,
	.pm = &nx30p6093_pm_ops,
	},
	.probe = nx30p6093_probe,
	.remove = nx30p6093_remove,
	.id_table = nx30p6093_id,
	};
	module_i2c_driver(nx30p6093_driver);

	MODULE_DESCRIPTION("NX30P6093 driver");
	MODULE_LICENSE("GPL v2");