[linux-2.6-block.git] / drivers / power / supply / axp20x_ac_power.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * AXP20X and AXP22X PMICs' ACIN power supply driver
 *
 * Copyright (C) 2016 Free Electrons
 *	Quentin Schulz <quentin.schulz@free-electrons.com>
 */

#include <linux/device.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/mfd/axp20x.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/platform_device.h>
#include <linux/pm.h>
#include <linux/power_supply.h>
#include <linux/regmap.h>
#include <linux/slab.h>
#include <linux/iio/consumer.h>

#define AXP20X_PWR_STATUS_ACIN_PRESENT	BIT(7)
#define AXP20X_PWR_STATUS_ACIN_AVAIL	BIT(6)

#define AXP813_ACIN_PATH_SEL		BIT(7)
#define AXP813_ACIN_PATH_SEL_TO_BIT(x)	(!!(x) << 7)

#define AXP813_VHOLD_MASK		GENMASK(5, 3)
#define AXP813_VHOLD_UV_TO_BIT(x)	((((x) / 100000) - 40) << 3)
#define AXP813_VHOLD_REG_TO_UV(x)	\
	(((((x) & AXP813_VHOLD_MASK) >> 3) + 40) * 100000)

#define AXP813_CURR_LIMIT_MASK		GENMASK(2, 0)
#define AXP813_CURR_LIMIT_UA_TO_BIT(x)	(((x) / 500000) - 3)
#define AXP813_CURR_LIMIT_REG_TO_UA(x)	\
	((((x) & AXP813_CURR_LIMIT_MASK) + 3) * 500000)

#define DRVNAME "axp20x-ac-power-supply"

struct axp20x_ac_power {
	struct regmap *regmap;
	struct power_supply *supply;
	struct iio_channel *acin_v;
	struct iio_channel *acin_i;
	bool has_acin_path_sel;
	unsigned int num_irqs;
	unsigned int irqs[];
};

static irqreturn_t axp20x_ac_power_irq(int irq, void *devid)
{
	struct axp20x_ac_power *power = devid;

	power_supply_changed(power->supply);

	return IRQ_HANDLED;
}

static int axp20x_ac_power_get_property(struct power_supply *psy,
					enum power_supply_property psp,
					union power_supply_propval *val)
{
	struct axp20x_ac_power *power = power_supply_get_drvdata(psy);
	int ret, reg;

	switch (psp) {
	case POWER_SUPPLY_PROP_HEALTH:
		ret = regmap_read(power->regmap, AXP20X_PWR_INPUT_STATUS, &reg);
		if (ret)
			return ret;

		if (reg & AXP20X_PWR_STATUS_ACIN_PRESENT) {
			val->intval = POWER_SUPPLY_HEALTH_GOOD;
			return 0;
		}

		val->intval = POWER_SUPPLY_HEALTH_UNKNOWN;
		return 0;

	case POWER_SUPPLY_PROP_PRESENT:
		ret = regmap_read(power->regmap, AXP20X_PWR_INPUT_STATUS, &reg);
		if (ret)
			return ret;

		val->intval = !!(reg & AXP20X_PWR_STATUS_ACIN_PRESENT);
		return 0;

	case POWER_SUPPLY_PROP_ONLINE:
		ret = regmap_read(power->regmap, AXP20X_PWR_INPUT_STATUS, &reg);
		if (ret)
			return ret;

		val->intval = !!(reg & AXP20X_PWR_STATUS_ACIN_AVAIL);

		/* ACIN_PATH_SEL disables ACIN even if ACIN_AVAIL is set. */
		if (val->intval && power->has_acin_path_sel) {
			ret = regmap_read(power->regmap, AXP813_ACIN_PATH_CTRL,
					  &reg);
			if (ret)
				return ret;

			val->intval = !!(reg & AXP813_ACIN_PATH_SEL);
		}

		return 0;

	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
		ret = iio_read_channel_processed(power->acin_v, &val->intval);
		if (ret)
			return ret;

		/* IIO framework gives mV but Power Supply framework gives uV */
		val->intval *= 1000;

		return 0;

	case POWER_SUPPLY_PROP_CURRENT_NOW:
		ret = iio_read_channel_processed(power->acin_i, &val->intval);
		if (ret)
			return ret;

		/* IIO framework gives mA but Power Supply framework gives uA */
		val->intval *= 1000;

		return 0;

	case POWER_SUPPLY_PROP_VOLTAGE_MIN:
		ret = regmap_read(power->regmap, AXP813_ACIN_PATH_CTRL, &reg);
		if (ret)
			return ret;

		val->intval = AXP813_VHOLD_REG_TO_UV(reg);

		return 0;

	case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
		ret = regmap_read(power->regmap, AXP813_ACIN_PATH_CTRL, &reg);
		if (ret)
			return ret;

		val->intval = AXP813_CURR_LIMIT_REG_TO_UA(reg);
		/* AXP813 datasheet defines values 11x as 4000mA */
		if (val->intval > 4000000)
			val->intval = 4000000;

		return 0;

	default:
		return -EINVAL;
	}

	return -EINVAL;
}

static int axp813_ac_power_set_property(struct power_supply *psy,
					enum power_supply_property psp,
					const union power_supply_propval *val)
{
	struct axp20x_ac_power *power = power_supply_get_drvdata(psy);

	switch (psp) {
	case POWER_SUPPLY_PROP_ONLINE:
		return regmap_update_bits(power->regmap, AXP813_ACIN_PATH_CTRL,
					  AXP813_ACIN_PATH_SEL,
					  AXP813_ACIN_PATH_SEL_TO_BIT(val->intval));

	case POWER_SUPPLY_PROP_VOLTAGE_MIN:
		if (val->intval < 4000000 || val->intval > 4700000)
			return -EINVAL;

		return regmap_update_bits(power->regmap, AXP813_ACIN_PATH_CTRL,
					  AXP813_VHOLD_MASK,
					  AXP813_VHOLD_UV_TO_BIT(val->intval));

	case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
		if (val->intval < 1500000 || val->intval > 4000000)
			return -EINVAL;

		return regmap_update_bits(power->regmap, AXP813_ACIN_PATH_CTRL,
					  AXP813_CURR_LIMIT_MASK,
					  AXP813_CURR_LIMIT_UA_TO_BIT(val->intval));

	default:
		return -EINVAL;
	}

	return -EINVAL;
}

static int axp813_ac_power_prop_writeable(struct power_supply *psy,
					  enum power_supply_property psp)
{
	return psp == POWER_SUPPLY_PROP_ONLINE ||
	       psp == POWER_SUPPLY_PROP_VOLTAGE_MIN ||
	       psp == POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT;
}

static enum power_supply_property axp20x_ac_power_properties[] = {
	POWER_SUPPLY_PROP_HEALTH,
	POWER_SUPPLY_PROP_PRESENT,
	POWER_SUPPLY_PROP_ONLINE,
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	POWER_SUPPLY_PROP_CURRENT_NOW,
};

static enum power_supply_property axp22x_ac_power_properties[] = {
	POWER_SUPPLY_PROP_HEALTH,
	POWER_SUPPLY_PROP_PRESENT,
	POWER_SUPPLY_PROP_ONLINE,
};

static enum power_supply_property axp813_ac_power_properties[] = {
	POWER_SUPPLY_PROP_HEALTH,
	POWER_SUPPLY_PROP_PRESENT,
	POWER_SUPPLY_PROP_ONLINE,
	POWER_SUPPLY_PROP_VOLTAGE_MIN,
	POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
};

static const struct power_supply_desc axp20x_ac_power_desc = {
	.name = "axp20x-ac",
	.type = POWER_SUPPLY_TYPE_MAINS,
	.properties = axp20x_ac_power_properties,
	.num_properties = ARRAY_SIZE(axp20x_ac_power_properties),
	.get_property = axp20x_ac_power_get_property,
};

static const struct power_supply_desc axp22x_ac_power_desc = {
	.name = "axp22x-ac",
	.type = POWER_SUPPLY_TYPE_MAINS,
	.properties = axp22x_ac_power_properties,
	.num_properties = ARRAY_SIZE(axp22x_ac_power_properties),
	.get_property = axp20x_ac_power_get_property,
};

static const struct power_supply_desc axp813_ac_power_desc = {
	.name = "axp813-ac",
	.type = POWER_SUPPLY_TYPE_MAINS,
	.properties = axp813_ac_power_properties,
	.num_properties = ARRAY_SIZE(axp813_ac_power_properties),
	.property_is_writeable = axp813_ac_power_prop_writeable,
	.get_property = axp20x_ac_power_get_property,
	.set_property = axp813_ac_power_set_property,
};

static const char * const axp20x_irq_names[] = {
	"ACIN_PLUGIN",
	"ACIN_REMOVAL",
};

struct axp_data {
	const struct power_supply_desc	*power_desc;
	const char * const		*irq_names;
	unsigned int			num_irq_names;
	bool				acin_adc;
	bool				acin_path_sel;
};

static const struct axp_data axp20x_data = {
	.power_desc	= &axp20x_ac_power_desc,
	.irq_names	= axp20x_irq_names,
	.num_irq_names	= ARRAY_SIZE(axp20x_irq_names),
	.acin_adc	= true,
	.acin_path_sel	= false,
};

static const struct axp_data axp22x_data = {
	.power_desc	= &axp22x_ac_power_desc,
	.irq_names	= axp20x_irq_names,
	.num_irq_names	= ARRAY_SIZE(axp20x_irq_names),
	.acin_adc	= false,
	.acin_path_sel	= false,
};

static const struct axp_data axp813_data = {
	.power_desc	= &axp813_ac_power_desc,
	.irq_names	= axp20x_irq_names,
	.num_irq_names	= ARRAY_SIZE(axp20x_irq_names),
	.acin_adc	= false,
	.acin_path_sel	= true,
};

#ifdef CONFIG_PM_SLEEP
static int axp20x_ac_power_suspend(struct device *dev)
{
	struct axp20x_ac_power *power = dev_get_drvdata(dev);
	int i = 0;

	/*
	 * Allow wake via ACIN_PLUGIN only.
	 *
	 * As nested threaded IRQs are not automatically disabled during
	 * suspend, we must explicitly disable the remainder of the IRQs.
	 */
	if (device_may_wakeup(&power->supply->dev))
		enable_irq_wake(power->irqs[i++]);
	while (i < power->num_irqs)
		disable_irq(power->irqs[i++]);

	return 0;
}

static int axp20x_ac_power_resume(struct device *dev)
{
	struct axp20x_ac_power *power = dev_get_drvdata(dev);
	int i = 0;

	if (device_may_wakeup(&power->supply->dev))
		disable_irq_wake(power->irqs[i++]);
	while (i < power->num_irqs)
		enable_irq(power->irqs[i++]);

	return 0;
}
#endif

static SIMPLE_DEV_PM_OPS(axp20x_ac_power_pm_ops, axp20x_ac_power_suspend,
						 axp20x_ac_power_resume);

static int axp20x_ac_power_probe(struct platform_device *pdev)
{
	struct axp20x_dev *axp20x = dev_get_drvdata(pdev->dev.parent);
	struct power_supply_config psy_cfg = {};
	struct axp20x_ac_power *power;
	const struct axp_data *axp_data;
	int i, irq, ret;

	if (!of_device_is_available(pdev->dev.of_node))
		return -ENODEV;

	if (!axp20x) {
		dev_err(&pdev->dev, "Parent drvdata not set\n");
		return -EINVAL;
	}

	axp_data = of_device_get_match_data(&pdev->dev);

	power = devm_kzalloc(&pdev->dev,
			     struct_size(power, irqs, axp_data->num_irq_names),
			     GFP_KERNEL);
	if (!power)
		return -ENOMEM;

	if (axp_data->acin_adc) {
		power->acin_v = devm_iio_channel_get(&pdev->dev, "acin_v");
		if (IS_ERR(power->acin_v)) {
			if (PTR_ERR(power->acin_v) == -ENODEV)
				return -EPROBE_DEFER;
			return PTR_ERR(power->acin_v);
		}

		power->acin_i = devm_iio_channel_get(&pdev->dev, "acin_i");
		if (IS_ERR(power->acin_i)) {
			if (PTR_ERR(power->acin_i) == -ENODEV)
				return -EPROBE_DEFER;
			return PTR_ERR(power->acin_i);
		}
	}

	power->regmap = dev_get_regmap(pdev->dev.parent, NULL);
	power->has_acin_path_sel = axp_data->acin_path_sel;
	power->num_irqs = axp_data->num_irq_names;

	platform_set_drvdata(pdev, power);

	psy_cfg.of_node = pdev->dev.of_node;
	psy_cfg.drv_data = power;

	power->supply = devm_power_supply_register(&pdev->dev,
						   axp_data->power_desc,
						   &psy_cfg);
	if (IS_ERR(power->supply))
		return PTR_ERR(power->supply);

	/* Request irqs after registering, as irqs may trigger immediately */
	for (i = 0; i < axp_data->num_irq_names; i++) {
		irq = platform_get_irq_byname(pdev, axp_data->irq_names[i]);
		if (irq < 0) {
			dev_err(&pdev->dev, "No IRQ for %s: %d\n",
				axp_data->irq_names[i], irq);
			return irq;
		}
		power->irqs[i] = regmap_irq_get_virq(axp20x->regmap_irqc, irq);
		ret = devm_request_any_context_irq(&pdev->dev, power->irqs[i],
						   axp20x_ac_power_irq, 0,
						   DRVNAME, power);
		if (ret < 0) {
			dev_err(&pdev->dev, "Error requesting %s IRQ: %d\n",
				axp_data->irq_names[i], ret);
			return ret;
		}
	}

	return 0;
}

static const struct of_device_id axp20x_ac_power_match[] = {
	{
		.compatible = "x-powers,axp202-ac-power-supply",
		.data = &axp20x_data,
	}, {
		.compatible = "x-powers,axp221-ac-power-supply",
		.data = &axp22x_data,
	}, {
		.compatible = "x-powers,axp813-ac-power-supply",
		.data = &axp813_data,
	}, { /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, axp20x_ac_power_match);

static struct platform_driver axp20x_ac_power_driver = {
	.probe = axp20x_ac_power_probe,
	.driver = {
		.name		= DRVNAME,
		.of_match_table	= axp20x_ac_power_match,
		.pm		= &axp20x_ac_power_pm_ops,
	},
};

module_platform_driver(axp20x_ac_power_driver);

MODULE_AUTHOR("Quentin Schulz <quentin.schulz@free-electrons.com>");
MODULE_DESCRIPTION("AXP20X and AXP22X PMICs' AC power supply driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
744cc304 QS	2	/*
	3	* AXP20X and AXP22X PMICs' ACIN power supply driver
	4	*
	5	* Copyright (C) 2016 Free Electrons
	6	* Quentin Schulz <quentin.schulz@free-electrons.com>
744cc304 QS	7	*/
	8
	9	#include <linux/device.h>
	10	#include <linux/init.h>
	11	#include <linux/interrupt.h>
	12	#include <linux/kernel.h>
	13	#include <linux/mfd/axp20x.h>
	14	#include <linux/module.h>
	15	#include <linux/of.h>
	16	#include <linux/of_device.h>
	17	#include <linux/platform_device.h>
ca4c77bb	18	#include <linux/pm.h>
744cc304 QS	19	#include <linux/power_supply.h>
	20	#include <linux/regmap.h>
	21	#include <linux/slab.h>
	22	#include <linux/iio/consumer.h>
	23
	24	#define AXP20X_PWR_STATUS_ACIN_PRESENT BIT(7)
	25	#define AXP20X_PWR_STATUS_ACIN_AVAIL BIT(6)
	26
1c51aad8	27	#define AXP813_ACIN_PATH_SEL BIT(7)
ddfec18b	28	#define AXP813_ACIN_PATH_SEL_TO_BIT(x) (!!(x) << 7)
1c51aad8	29
7693b564 OL	30	#define AXP813_VHOLD_MASK GENMASK(5, 3)
	31	#define AXP813_VHOLD_UV_TO_BIT(x) ((((x) / 100000) - 40) << 3)
	32	#define AXP813_VHOLD_REG_TO_UV(x) \
	33	(((((x) & AXP813_VHOLD_MASK) >> 3) + 40) * 100000)
	34
	35	#define AXP813_CURR_LIMIT_MASK GENMASK(2, 0)
	36	#define AXP813_CURR_LIMIT_UA_TO_BIT(x) (((x) / 500000) - 3)
	37	#define AXP813_CURR_LIMIT_REG_TO_UA(x) \
	38	((((x) & AXP813_CURR_LIMIT_MASK) + 3) * 500000)
	39
744cc304 QS	40	#define DRVNAME "axp20x-ac-power-supply"
	41
	42	struct axp20x_ac_power {
	43	struct regmap *regmap;
	44	struct power_supply *supply;
	45	struct iio_channel *acin_v;
	46	struct iio_channel *acin_i;
1c51aad8	47	bool has_acin_path_sel;
ca4c77bb SH	48	unsigned int num_irqs;
ca4c77bb SH	49	unsigned int irqs[];
744cc304 QS	50	};
	51
	52	static irqreturn_t axp20x_ac_power_irq(int irq, void *devid)
	53	{
	54	struct axp20x_ac_power *power = devid;
	55
	56	power_supply_changed(power->supply);
	57
	58	return IRQ_HANDLED;
	59	}
	60
	61	static int axp20x_ac_power_get_property(struct power_supply *psy,
	62	enum power_supply_property psp,
	63	union power_supply_propval *val)
	64	{
	65	struct axp20x_ac_power *power = power_supply_get_drvdata(psy);
	66	int ret, reg;
	67
	68	switch (psp) {
	69	case POWER_SUPPLY_PROP_HEALTH:
	70	ret = regmap_read(power->regmap, AXP20X_PWR_INPUT_STATUS, &reg);
	71	if (ret)
	72	return ret;
	73
	74	if (reg & AXP20X_PWR_STATUS_ACIN_PRESENT) {
	75	val->intval = POWER_SUPPLY_HEALTH_GOOD;
	76	return 0;
	77	}
	78
	79	val->intval = POWER_SUPPLY_HEALTH_UNKNOWN;
	80	return 0;
	81
	82	case POWER_SUPPLY_PROP_PRESENT:
	83	ret = regmap_read(power->regmap, AXP20X_PWR_INPUT_STATUS, &reg);
	84	if (ret)
	85	return ret;
	86
	87	val->intval = !!(reg & AXP20X_PWR_STATUS_ACIN_PRESENT);
	88	return 0;
	89
	90	case POWER_SUPPLY_PROP_ONLINE:
	91	ret = regmap_read(power->regmap, AXP20X_PWR_INPUT_STATUS, &reg);
	92	if (ret)
	93	return ret;
	94
	95	val->intval = !!(reg & AXP20X_PWR_STATUS_ACIN_AVAIL);
1c51aad8 SH	96
	97	/* ACIN_PATH_SEL disables ACIN even if ACIN_AVAIL is set. */
	98	if (val->intval && power->has_acin_path_sel) {
	99	ret = regmap_read(power->regmap, AXP813_ACIN_PATH_CTRL,
	100	&reg);
	101	if (ret)
	102	return ret;
	103
	104	val->intval = !!(reg & AXP813_ACIN_PATH_SEL);
	105	}
	106
744cc304 QS	107	return 0;
	108
	109	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
	110	ret = iio_read_channel_processed(power->acin_v, &val->intval);
	111	if (ret)
	112	return ret;
	113
	114	/* IIO framework gives mV but Power Supply framework gives uV */
	115	val->intval *= 1000;
	116
	117	return 0;
	118
	119	case POWER_SUPPLY_PROP_CURRENT_NOW:
	120	ret = iio_read_channel_processed(power->acin_i, &val->intval);
	121	if (ret)
	122	return ret;
	123
	124	/* IIO framework gives mA but Power Supply framework gives uA */
	125	val->intval *= 1000;
	126
	127	return 0;
	128
7693b564 OL	129	case POWER_SUPPLY_PROP_VOLTAGE_MIN:
	130	ret = regmap_read(power->regmap, AXP813_ACIN_PATH_CTRL, &reg);
	131	if (ret)
	132	return ret;
	133
	134	val->intval = AXP813_VHOLD_REG_TO_UV(reg);
	135
	136	return 0;
	137
	138	case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
	139	ret = regmap_read(power->regmap, AXP813_ACIN_PATH_CTRL, &reg);
	140	if (ret)
	141	return ret;
	142
	143	val->intval = AXP813_CURR_LIMIT_REG_TO_UA(reg);
	144	/* AXP813 datasheet defines values 11x as 4000mA */
	145	if (val->intval > 4000000)
	146	val->intval = 4000000;
	147
	148	return 0;
	149
	150	default:
	151	return -EINVAL;
	152	}
	153
	154	return -EINVAL;
	155	}
	156
	157	static int axp813_ac_power_set_property(struct power_supply *psy,
	158	enum power_supply_property psp,
	159	const union power_supply_propval *val)
	160	{
	161	struct axp20x_ac_power *power = power_supply_get_drvdata(psy);
	162
	163	switch (psp) {
ddfec18b SH	164	case POWER_SUPPLY_PROP_ONLINE:
	165	return regmap_update_bits(power->regmap, AXP813_ACIN_PATH_CTRL,
	166	AXP813_ACIN_PATH_SEL,
	167	AXP813_ACIN_PATH_SEL_TO_BIT(val->intval));
	168
7693b564 OL	169	case POWER_SUPPLY_PROP_VOLTAGE_MIN:
	170	if (val->intval < 4000000 \|\| val->intval > 4700000)
	171	return -EINVAL;
	172
	173	return regmap_update_bits(power->regmap, AXP813_ACIN_PATH_CTRL,
	174	AXP813_VHOLD_MASK,
	175	AXP813_VHOLD_UV_TO_BIT(val->intval));
	176
	177	case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
	178	if (val->intval < 1500000 \|\| val->intval > 4000000)
	179	return -EINVAL;
	180
	181	return regmap_update_bits(power->regmap, AXP813_ACIN_PATH_CTRL,
	182	AXP813_CURR_LIMIT_MASK,
	183	AXP813_CURR_LIMIT_UA_TO_BIT(val->intval));
	184
744cc304 QS	185	default:
	186	return -EINVAL;
	187	}
	188
	189	return -EINVAL;
	190	}
	191
7693b564 OL	192	static int axp813_ac_power_prop_writeable(struct power_supply *psy,
	193	enum power_supply_property psp)
	194	{
ddfec18b SH	195	return psp == POWER_SUPPLY_PROP_ONLINE \|\|
ddfec18b SH	196	psp == POWER_SUPPLY_PROP_VOLTAGE_MIN \|\|
7693b564 OL	197	psp == POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT;
	198	}
	199
744cc304 QS	200	static enum power_supply_property axp20x_ac_power_properties[] = {
	201	POWER_SUPPLY_PROP_HEALTH,
	202	POWER_SUPPLY_PROP_PRESENT,
	203	POWER_SUPPLY_PROP_ONLINE,
	204	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	205	POWER_SUPPLY_PROP_CURRENT_NOW,
	206	};
	207
	208	static enum power_supply_property axp22x_ac_power_properties[] = {
	209	POWER_SUPPLY_PROP_HEALTH,
	210	POWER_SUPPLY_PROP_PRESENT,
	211	POWER_SUPPLY_PROP_ONLINE,
	212	};
	213
7693b564 OL	214	static enum power_supply_property axp813_ac_power_properties[] = {
	215	POWER_SUPPLY_PROP_HEALTH,
	216	POWER_SUPPLY_PROP_PRESENT,
	217	POWER_SUPPLY_PROP_ONLINE,
	218	POWER_SUPPLY_PROP_VOLTAGE_MIN,
	219	POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
	220	};
	221
744cc304 QS	222	static const struct power_supply_desc axp20x_ac_power_desc = {
	223	.name = "axp20x-ac",
	224	.type = POWER_SUPPLY_TYPE_MAINS,
	225	.properties = axp20x_ac_power_properties,
	226	.num_properties = ARRAY_SIZE(axp20x_ac_power_properties),
	227	.get_property = axp20x_ac_power_get_property,
	228	};
	229
	230	static const struct power_supply_desc axp22x_ac_power_desc = {
	231	.name = "axp22x-ac",
	232	.type = POWER_SUPPLY_TYPE_MAINS,
	233	.properties = axp22x_ac_power_properties,
	234	.num_properties = ARRAY_SIZE(axp22x_ac_power_properties),
	235	.get_property = axp20x_ac_power_get_property,
	236	};
	237
7693b564 OL	238	static const struct power_supply_desc axp813_ac_power_desc = {
	239	.name = "axp813-ac",
	240	.type = POWER_SUPPLY_TYPE_MAINS,
	241	.properties = axp813_ac_power_properties,
	242	.num_properties = ARRAY_SIZE(axp813_ac_power_properties),
	243	.property_is_writeable = axp813_ac_power_prop_writeable,
	244	.get_property = axp20x_ac_power_get_property,
	245	.set_property = axp813_ac_power_set_property,
	246	};
	247
ca4c77bb SH	248	static const char * const axp20x_irq_names[] = {
	249	"ACIN_PLUGIN",
	250	"ACIN_REMOVAL",
	251	};
	252
744cc304 QS	253	struct axp_data {
744cc304 QS	254	const struct power_supply_desc *power_desc;
ca4c77bb SH	255	const char * const *irq_names;
ca4c77bb SH	256	unsigned int num_irq_names;
744cc304	257	bool acin_adc;
1c51aad8	258	bool acin_path_sel;
744cc304 QS	259	};
	260
	261	static const struct axp_data axp20x_data = {
1c51aad8	262	.power_desc = &axp20x_ac_power_desc,
ca4c77bb SH	263	.irq_names = axp20x_irq_names,
ca4c77bb SH	264	.num_irq_names = ARRAY_SIZE(axp20x_irq_names),
1c51aad8 SH	265	.acin_adc = true,
1c51aad8 SH	266	.acin_path_sel = false,
744cc304 QS	267	};
	268
	269	static const struct axp_data axp22x_data = {
1c51aad8	270	.power_desc = &axp22x_ac_power_desc,
ca4c77bb SH	271	.irq_names = axp20x_irq_names,
ca4c77bb SH	272	.num_irq_names = ARRAY_SIZE(axp20x_irq_names),
1c51aad8 SH	273	.acin_adc = false,
1c51aad8 SH	274	.acin_path_sel = false,
744cc304 QS	275	};
744cc304 QS	276
7693b564	277	static const struct axp_data axp813_data = {
1c51aad8	278	.power_desc = &axp813_ac_power_desc,
ca4c77bb SH	279	.irq_names = axp20x_irq_names,
ca4c77bb SH	280	.num_irq_names = ARRAY_SIZE(axp20x_irq_names),
1c51aad8 SH	281	.acin_adc = false,
1c51aad8 SH	282	.acin_path_sel = true,
7693b564 OL	283	};
7693b564 OL	284
ca4c77bb SH	285	#ifdef CONFIG_PM_SLEEP
	286	static int axp20x_ac_power_suspend(struct device *dev)
	287	{
	288	struct axp20x_ac_power *power = dev_get_drvdata(dev);
	289	int i = 0;
	290
	291	/*
	292	* Allow wake via ACIN_PLUGIN only.
	293	*
	294	* As nested threaded IRQs are not automatically disabled during
	295	* suspend, we must explicitly disable the remainder of the IRQs.
	296	*/
	297	if (device_may_wakeup(&power->supply->dev))
	298	enable_irq_wake(power->irqs[i++]);
	299	while (i < power->num_irqs)
	300	disable_irq(power->irqs[i++]);
	301
	302	return 0;
	303	}
	304
	305	static int axp20x_ac_power_resume(struct device *dev)
	306	{
	307	struct axp20x_ac_power *power = dev_get_drvdata(dev);
	308	int i = 0;
	309
	310	if (device_may_wakeup(&power->supply->dev))
	311	disable_irq_wake(power->irqs[i++]);
	312	while (i < power->num_irqs)
	313	enable_irq(power->irqs[i++]);
	314
	315	return 0;
	316	}
	317	#endif
	318
	319	static SIMPLE_DEV_PM_OPS(axp20x_ac_power_pm_ops, axp20x_ac_power_suspend,
	320	axp20x_ac_power_resume);
	321
744cc304 QS	322	static int axp20x_ac_power_probe(struct platform_device *pdev)
	323	{
	324	struct axp20x_dev *axp20x = dev_get_drvdata(pdev->dev.parent);
	325	struct power_supply_config psy_cfg = {};
	326	struct axp20x_ac_power *power;
a488ca6e	327	const struct axp_data *axp_data;
744cc304 QS	328	int i, irq, ret;
	329
	330	if (!of_device_is_available(pdev->dev.of_node))
	331	return -ENODEV;
	332
	333	if (!axp20x) {
	334	dev_err(&pdev->dev, "Parent drvdata not set\n");
	335	return -EINVAL;
	336	}
	337
ca4c77bb SH	338	axp_data = of_device_get_match_data(&pdev->dev);
	339
	340	power = devm_kzalloc(&pdev->dev,
	341	struct_size(power, irqs, axp_data->num_irq_names),
	342	GFP_KERNEL);
744cc304 QS	343	if (!power)
	344	return -ENOMEM;
	345
744cc304 QS	346	if (axp_data->acin_adc) {
	347	power->acin_v = devm_iio_channel_get(&pdev->dev, "acin_v");
	348	if (IS_ERR(power->acin_v)) {
	349	if (PTR_ERR(power->acin_v) == -ENODEV)
	350	return -EPROBE_DEFER;
	351	return PTR_ERR(power->acin_v);
	352	}
	353
	354	power->acin_i = devm_iio_channel_get(&pdev->dev, "acin_i");
	355	if (IS_ERR(power->acin_i)) {
	356	if (PTR_ERR(power->acin_i) == -ENODEV)
	357	return -EPROBE_DEFER;
	358	return PTR_ERR(power->acin_i);
	359	}
	360	}
	361
	362	power->regmap = dev_get_regmap(pdev->dev.parent, NULL);
1c51aad8	363	power->has_acin_path_sel = axp_data->acin_path_sel;
ca4c77bb	364	power->num_irqs = axp_data->num_irq_names;
744cc304 QS	365
	366	platform_set_drvdata(pdev, power);
	367
	368	psy_cfg.of_node = pdev->dev.of_node;
	369	psy_cfg.drv_data = power;
	370
	371	power->supply = devm_power_supply_register(&pdev->dev,
	372	axp_data->power_desc,
	373	&psy_cfg);
	374	if (IS_ERR(power->supply))
	375	return PTR_ERR(power->supply);
	376
	377	/* Request irqs after registering, as irqs may trigger immediately */
ca4c77bb SH	378	for (i = 0; i < axp_data->num_irq_names; i++) {
ca4c77bb SH	379	irq = platform_get_irq_byname(pdev, axp_data->irq_names[i]);
744cc304	380	if (irq < 0) {
ca4c77bb SH	381	dev_err(&pdev->dev, "No IRQ for %s: %d\n",
	382	axp_data->irq_names[i], irq);
	383	return irq;
744cc304	384	}
ca4c77bb SH	385	power->irqs[i] = regmap_irq_get_virq(axp20x->regmap_irqc, irq);
ca4c77bb SH	386	ret = devm_request_any_context_irq(&pdev->dev, power->irqs[i],
744cc304 QS	387	axp20x_ac_power_irq, 0,
744cc304 QS	388	DRVNAME, power);
ca4c77bb SH	389	if (ret < 0) {
	390	dev_err(&pdev->dev, "Error requesting %s IRQ: %d\n",
	391	axp_data->irq_names[i], ret);
	392	return ret;
	393	}
744cc304 QS	394	}
	395
	396	return 0;
	397	}
	398
	399	static const struct of_device_id axp20x_ac_power_match[] = {
	400	{
	401	.compatible = "x-powers,axp202-ac-power-supply",
a488ca6e	402	.data = &axp20x_data,
744cc304 QS	403	}, {
744cc304 QS	404	.compatible = "x-powers,axp221-ac-power-supply",
a488ca6e	405	.data = &axp22x_data,
7693b564 OL	406	}, {
	407	.compatible = "x-powers,axp813-ac-power-supply",
	408	.data = &axp813_data,
744cc304 QS	409	}, { /* sentinel */ }
	410	};
	411	MODULE_DEVICE_TABLE(of, axp20x_ac_power_match);
	412
	413	static struct platform_driver axp20x_ac_power_driver = {
	414	.probe = axp20x_ac_power_probe,
	415	.driver = {
ca4c77bb SH	416	.name = DRVNAME,
	417	.of_match_table = axp20x_ac_power_match,
	418	.pm = &axp20x_ac_power_pm_ops,
744cc304 QS	419	},
	420	};
	421
	422	module_platform_driver(axp20x_ac_power_driver);
	423
	424	MODULE_AUTHOR("Quentin Schulz <quentin.schulz@free-electrons.com>");
	425	MODULE_DESCRIPTION("AXP20X and AXP22X PMICs' AC power supply driver");
	426	MODULE_LICENSE("GPL");