[mirror_ubuntu-bionic-kernel.git] / drivers / iio / adc / axp20x_adc.c

/* ADC driver for AXP20X and AXP22X PMICs
 *
 * Copyright (c) 2016 Free Electrons NextThing Co.
 *	Quentin Schulz <quentin.schulz@free-electrons.com>
 *
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License version 2 as published by the
 * Free Software Foundation.
 */

#include <linux/completion.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/regmap.h>
#include <linux/thermal.h>

#include <linux/iio/iio.h>
#include <linux/iio/driver.h>
#include <linux/iio/machine.h>
#include <linux/mfd/axp20x.h>

#define AXP20X_ADC_EN1_MASK			GENMASK(7, 0)

#define AXP20X_ADC_EN2_MASK			(GENMASK(3, 2) | BIT(7))
#define AXP22X_ADC_EN1_MASK			(GENMASK(7, 5) | BIT(0))

#define AXP20X_GPIO10_IN_RANGE_GPIO0		BIT(0)
#define AXP20X_GPIO10_IN_RANGE_GPIO1		BIT(1)
#define AXP20X_GPIO10_IN_RANGE_GPIO0_VAL(x)	((x) & BIT(0))
#define AXP20X_GPIO10_IN_RANGE_GPIO1_VAL(x)	(((x) & BIT(0)) << 1)

#define AXP20X_ADC_RATE_MASK			GENMASK(7, 6)
#define AXP20X_ADC_RATE_HZ(x)			((ilog2((x) / 25) << 6) & AXP20X_ADC_RATE_MASK)
#define AXP22X_ADC_RATE_HZ(x)			((ilog2((x) / 100) << 6) & AXP20X_ADC_RATE_MASK)

#define AXP20X_ADC_CHANNEL(_channel, _name, _type, _reg)	\
	{							\
		.type = _type,					\
		.indexed = 1,					\
		.channel = _channel,				\
		.address = _reg,				\
		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |	\
				      BIT(IIO_CHAN_INFO_SCALE),	\
		.datasheet_name = _name,			\
	}

#define AXP20X_ADC_CHANNEL_OFFSET(_channel, _name, _type, _reg) \
	{							\
		.type = _type,					\
		.indexed = 1,					\
		.channel = _channel,				\
		.address = _reg,				\
		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |	\
				      BIT(IIO_CHAN_INFO_SCALE) |\
				      BIT(IIO_CHAN_INFO_OFFSET),\
		.datasheet_name = _name,			\
	}

struct axp_data;

struct axp20x_adc_iio {
	struct regmap		*regmap;
	struct axp_data		*data;
};

enum axp20x_adc_channel_v {
	AXP20X_ACIN_V = 0,
	AXP20X_VBUS_V,
	AXP20X_TS_IN,
	AXP20X_GPIO0_V,
	AXP20X_GPIO1_V,
	AXP20X_IPSOUT_V,
	AXP20X_BATT_V,
};

enum axp20x_adc_channel_i {
	AXP20X_ACIN_I = 0,
	AXP20X_VBUS_I,
	AXP20X_BATT_CHRG_I,
	AXP20X_BATT_DISCHRG_I,
};

enum axp22x_adc_channel_v {
	AXP22X_TS_IN = 0,
	AXP22X_BATT_V,
};

enum axp22x_adc_channel_i {
	AXP22X_BATT_CHRG_I = 1,
	AXP22X_BATT_DISCHRG_I,
};

static struct iio_map axp20x_maps[] = {
	{
		.consumer_dev_name = "axp20x-usb-power-supply",
		.consumer_channel = "vbus_v",
		.adc_channel_label = "vbus_v",
	}, {
		.consumer_dev_name = "axp20x-usb-power-supply",
		.consumer_channel = "vbus_i",
		.adc_channel_label = "vbus_i",
	}, {
		.consumer_dev_name = "axp20x-ac-power-supply",
		.consumer_channel = "acin_v",
		.adc_channel_label = "acin_v",
	}, {
		.consumer_dev_name = "axp20x-ac-power-supply",
		.consumer_channel = "acin_i",
		.adc_channel_label = "acin_i",
	}, {
		.consumer_dev_name = "axp20x-battery-power-supply",
		.consumer_channel = "batt_v",
		.adc_channel_label = "batt_v",
	}, {
		.consumer_dev_name = "axp20x-battery-power-supply",
		.consumer_channel = "batt_chrg_i",
		.adc_channel_label = "batt_chrg_i",
	}, {
		.consumer_dev_name = "axp20x-battery-power-supply",
		.consumer_channel = "batt_dischrg_i",
		.adc_channel_label = "batt_dischrg_i",
	}, { /* sentinel */ }
};

static struct iio_map axp22x_maps[] = {
	{
		.consumer_dev_name = "axp20x-battery-power-supply",
		.consumer_channel = "batt_v",
		.adc_channel_label = "batt_v",
	}, {
		.consumer_dev_name = "axp20x-battery-power-supply",
		.consumer_channel = "batt_chrg_i",
		.adc_channel_label = "batt_chrg_i",
	}, {
		.consumer_dev_name = "axp20x-battery-power-supply",
		.consumer_channel = "batt_dischrg_i",
		.adc_channel_label = "batt_dischrg_i",
	}, { /* sentinel */ }
};

/*
 * Channels are mapped by physical system. Their channels share the same index.
 * i.e. acin_i is in_current0_raw and acin_v is in_voltage0_raw.
 * The only exception is for the battery. batt_v will be in_voltage6_raw and
 * charge current in_current6_raw and discharge current will be in_current7_raw.
 */
static const struct iio_chan_spec axp20x_adc_channels[] = {
	AXP20X_ADC_CHANNEL(AXP20X_ACIN_V, "acin_v", IIO_VOLTAGE,
			   AXP20X_ACIN_V_ADC_H),
	AXP20X_ADC_CHANNEL(AXP20X_ACIN_I, "acin_i", IIO_CURRENT,
			   AXP20X_ACIN_I_ADC_H),
	AXP20X_ADC_CHANNEL(AXP20X_VBUS_V, "vbus_v", IIO_VOLTAGE,
			   AXP20X_VBUS_V_ADC_H),
	AXP20X_ADC_CHANNEL(AXP20X_VBUS_I, "vbus_i", IIO_CURRENT,
			   AXP20X_VBUS_I_ADC_H),
	{
		.type = IIO_TEMP,
		.address = AXP20X_TEMP_ADC_H,
		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
				      BIT(IIO_CHAN_INFO_SCALE) |
				      BIT(IIO_CHAN_INFO_OFFSET),
		.datasheet_name = "pmic_temp",
	},
	AXP20X_ADC_CHANNEL_OFFSET(AXP20X_GPIO0_V, "gpio0_v", IIO_VOLTAGE,
				  AXP20X_GPIO0_V_ADC_H),
	AXP20X_ADC_CHANNEL_OFFSET(AXP20X_GPIO1_V, "gpio1_v", IIO_VOLTAGE,
				  AXP20X_GPIO1_V_ADC_H),
	AXP20X_ADC_CHANNEL(AXP20X_IPSOUT_V, "ipsout_v", IIO_VOLTAGE,
			   AXP20X_IPSOUT_V_HIGH_H),
	AXP20X_ADC_CHANNEL(AXP20X_BATT_V, "batt_v", IIO_VOLTAGE,
			   AXP20X_BATT_V_H),
	AXP20X_ADC_CHANNEL(AXP20X_BATT_CHRG_I, "batt_chrg_i", IIO_CURRENT,
			   AXP20X_BATT_CHRG_I_H),
	AXP20X_ADC_CHANNEL(AXP20X_BATT_DISCHRG_I, "batt_dischrg_i", IIO_CURRENT,
			   AXP20X_BATT_DISCHRG_I_H),
};

static const struct iio_chan_spec axp22x_adc_channels[] = {
	{
		.type = IIO_TEMP,
		.address = AXP22X_PMIC_TEMP_H,
		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
				      BIT(IIO_CHAN_INFO_SCALE) |
				      BIT(IIO_CHAN_INFO_OFFSET),
		.datasheet_name = "pmic_temp",
	},
	AXP20X_ADC_CHANNEL(AXP22X_BATT_V, "batt_v", IIO_VOLTAGE,
			   AXP20X_BATT_V_H),
	AXP20X_ADC_CHANNEL(AXP22X_BATT_CHRG_I, "batt_chrg_i", IIO_CURRENT,
			   AXP20X_BATT_CHRG_I_H),
	AXP20X_ADC_CHANNEL(AXP22X_BATT_DISCHRG_I, "batt_dischrg_i", IIO_CURRENT,
			   AXP20X_BATT_DISCHRG_I_H),
};

static int axp20x_adc_raw(struct iio_dev *indio_dev,
			  struct iio_chan_spec const *chan, int *val)
{
	struct axp20x_adc_iio *info = iio_priv(indio_dev);
	int size = 12;

	/*
	 * N.B.:  Unlike the Chinese datasheets tell, the charging current is
	 * stored on 12 bits, not 13 bits. Only discharging current is on 13
	 * bits.
	 */
	if (chan->type == IIO_CURRENT && chan->channel == AXP20X_BATT_DISCHRG_I)
		size = 13;
	else
		size = 12;

	*val = axp20x_read_variable_width(info->regmap, chan->address, size);
	if (*val < 0)
		return *val;

	return IIO_VAL_INT;
}

static int axp22x_adc_raw(struct iio_dev *indio_dev,
			  struct iio_chan_spec const *chan, int *val)
{
	struct axp20x_adc_iio *info = iio_priv(indio_dev);
	int size;

	/*
	 * N.B.: Unlike the Chinese datasheets tell, the charging current is
	 * stored on 12 bits, not 13 bits. Only discharging current is on 13
	 * bits.
	 */
	if (chan->type == IIO_CURRENT && chan->channel == AXP22X_BATT_DISCHRG_I)
		size = 13;
	else
		size = 12;

	*val = axp20x_read_variable_width(info->regmap, chan->address, size);
	if (*val < 0)
		return *val;

	return IIO_VAL_INT;
}

static int axp20x_adc_scale_voltage(int channel, int *val, int *val2)
{
	switch (channel) {
	case AXP20X_ACIN_V:
	case AXP20X_VBUS_V:
		*val = 1;
		*val2 = 700000;
		return IIO_VAL_INT_PLUS_MICRO;

	case AXP20X_GPIO0_V:
	case AXP20X_GPIO1_V:
		*val = 0;
		*val2 = 500000;
		return IIO_VAL_INT_PLUS_MICRO;

	case AXP20X_BATT_V:
		*val = 1;
		*val2 = 100000;
		return IIO_VAL_INT_PLUS_MICRO;

	case AXP20X_IPSOUT_V:
		*val = 1;
		*val2 = 400000;
		return IIO_VAL_INT_PLUS_MICRO;

	default:
		return -EINVAL;
	}
}

static int axp20x_adc_scale_current(int channel, int *val, int *val2)
{
	switch (channel) {
	case AXP20X_ACIN_I:
		*val = 0;
		*val2 = 625000;
		return IIO_VAL_INT_PLUS_MICRO;

	case AXP20X_VBUS_I:
		*val = 0;
		*val2 = 375000;
		return IIO_VAL_INT_PLUS_MICRO;

	case AXP20X_BATT_DISCHRG_I:
	case AXP20X_BATT_CHRG_I:
		*val = 0;
		*val2 = 500000;
		return IIO_VAL_INT_PLUS_MICRO;

	default:
		return -EINVAL;
	}
}

static int axp20x_adc_scale(struct iio_chan_spec const *chan, int *val,
			    int *val2)
{
	switch (chan->type) {
	case IIO_VOLTAGE:
		return axp20x_adc_scale_voltage(chan->channel, val, val2);

	case IIO_CURRENT:
		return axp20x_adc_scale_current(chan->channel, val, val2);

	case IIO_TEMP:
		*val = 100;
		return IIO_VAL_INT;

	default:
		return -EINVAL;
	}
}

static int axp22x_adc_scale(struct iio_chan_spec const *chan, int *val,
			    int *val2)
{
	switch (chan->type) {
	case IIO_VOLTAGE:
		if (chan->channel != AXP22X_BATT_V)
			return -EINVAL;

		*val = 1;
		*val2 = 100000;
		return IIO_VAL_INT_PLUS_MICRO;

	case IIO_CURRENT:
		*val = 0;
		*val2 = 500000;
		return IIO_VAL_INT_PLUS_MICRO;

	case IIO_TEMP:
		*val = 100;
		return IIO_VAL_INT;

	default:
		return -EINVAL;
	}
}

static int axp20x_adc_offset_voltage(struct iio_dev *indio_dev, int channel,
				     int *val)
{
	struct axp20x_adc_iio *info = iio_priv(indio_dev);
	int ret;

	ret = regmap_read(info->regmap, AXP20X_GPIO10_IN_RANGE, val);
	if (ret < 0)
		return ret;

	switch (channel) {
	case AXP20X_GPIO0_V:
		*val &= AXP20X_GPIO10_IN_RANGE_GPIO0;
		break;

	case AXP20X_GPIO1_V:
		*val &= AXP20X_GPIO10_IN_RANGE_GPIO1;
		break;

	default:
		return -EINVAL;
	}

	*val = !!(*val) * 700000;

	return IIO_VAL_INT;
}

static int axp20x_adc_offset(struct iio_dev *indio_dev,
			     struct iio_chan_spec const *chan, int *val)
{
	switch (chan->type) {
	case IIO_VOLTAGE:
		return axp20x_adc_offset_voltage(indio_dev, chan->channel, val);

	case IIO_TEMP:
		*val = -1447;
		return IIO_VAL_INT;

	default:
		return -EINVAL;
	}
}

static int axp20x_read_raw(struct iio_dev *indio_dev,
			   struct iio_chan_spec const *chan, int *val,
			   int *val2, long mask)
{
	switch (mask) {
	case IIO_CHAN_INFO_OFFSET:
		return axp20x_adc_offset(indio_dev, chan, val);

	case IIO_CHAN_INFO_SCALE:
		return axp20x_adc_scale(chan, val, val2);

	case IIO_CHAN_INFO_RAW:
		return axp20x_adc_raw(indio_dev, chan, val);

	default:
		return -EINVAL;
	}
}

static int axp22x_read_raw(struct iio_dev *indio_dev,
			   struct iio_chan_spec const *chan, int *val,
			   int *val2, long mask)
{
	switch (mask) {
	case IIO_CHAN_INFO_OFFSET:
		*val = -2677;
		return IIO_VAL_INT;

	case IIO_CHAN_INFO_SCALE:
		return axp22x_adc_scale(chan, val, val2);

	case IIO_CHAN_INFO_RAW:
		return axp22x_adc_raw(indio_dev, chan, val);

	default:
		return -EINVAL;
	}
}

static int axp20x_write_raw(struct iio_dev *indio_dev,
			    struct iio_chan_spec const *chan, int val, int val2,
			    long mask)
{
	struct axp20x_adc_iio *info = iio_priv(indio_dev);
	unsigned int reg, regval;

	/*
	 * The AXP20X PMIC allows the user to choose between 0V and 0.7V offsets
	 * for (independently) GPIO0 and GPIO1 when in ADC mode.
	 */
	if (mask != IIO_CHAN_INFO_OFFSET)
		return -EINVAL;

	if (val != 0 && val != 700000)
		return -EINVAL;

	switch (chan->channel) {
	case AXP20X_GPIO0_V:
		reg = AXP20X_GPIO10_IN_RANGE_GPIO0;
		regval = AXP20X_GPIO10_IN_RANGE_GPIO0_VAL(!!val);
		break;

	case AXP20X_GPIO1_V:
		reg = AXP20X_GPIO10_IN_RANGE_GPIO1;
		regval = AXP20X_GPIO10_IN_RANGE_GPIO1_VAL(!!val);
		break;

	default:
		return -EINVAL;
	}

	return regmap_update_bits(info->regmap, AXP20X_GPIO10_IN_RANGE, reg,
				  regval);
}

static const struct iio_info axp20x_adc_iio_info = {
	.read_raw = axp20x_read_raw,
	.write_raw = axp20x_write_raw,
	.driver_module = THIS_MODULE,
};

static const struct iio_info axp22x_adc_iio_info = {
	.read_raw = axp22x_read_raw,
	.driver_module = THIS_MODULE,
};

static int axp20x_adc_rate(int rate)
{
	return AXP20X_ADC_RATE_HZ(rate);
}

static int axp22x_adc_rate(int rate)
{
	return AXP22X_ADC_RATE_HZ(rate);
}

struct axp_data {
	const struct iio_info		*iio_info;
	int				num_channels;
	struct iio_chan_spec const	*channels;
	unsigned long			adc_en1_mask;
	int				(*adc_rate)(int rate);
	bool				adc_en2;
	struct iio_map			*maps;
};

static const struct axp_data axp20x_data = {
	.iio_info = &axp20x_adc_iio_info,
	.num_channels = ARRAY_SIZE(axp20x_adc_channels),
	.channels = axp20x_adc_channels,
	.adc_en1_mask = AXP20X_ADC_EN1_MASK,
	.adc_rate = axp20x_adc_rate,
	.adc_en2 = true,
	.maps = axp20x_maps,
};

static const struct axp_data axp22x_data = {
	.iio_info = &axp22x_adc_iio_info,
	.num_channels = ARRAY_SIZE(axp22x_adc_channels),
	.channels = axp22x_adc_channels,
	.adc_en1_mask = AXP22X_ADC_EN1_MASK,
	.adc_rate = axp22x_adc_rate,
	.adc_en2 = false,
	.maps = axp22x_maps,
};

static const struct platform_device_id axp20x_adc_id_match[] = {
	{ .name = "axp20x-adc", .driver_data = (kernel_ulong_t)&axp20x_data, },
	{ .name = "axp22x-adc", .driver_data = (kernel_ulong_t)&axp22x_data, },
	{ /* sentinel */ },
};
MODULE_DEVICE_TABLE(platform, axp20x_adc_id_match);

static int axp20x_probe(struct platform_device *pdev)
{
	struct axp20x_adc_iio *info;
	struct iio_dev *indio_dev;
	struct axp20x_dev *axp20x_dev;
	int ret;

	axp20x_dev = dev_get_drvdata(pdev->dev.parent);

	indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*info));
	if (!indio_dev)
		return -ENOMEM;

	info = iio_priv(indio_dev);
	platform_set_drvdata(pdev, indio_dev);

	info->regmap = axp20x_dev->regmap;
	indio_dev->dev.parent = &pdev->dev;
	indio_dev->dev.of_node = pdev->dev.of_node;
	indio_dev->modes = INDIO_DIRECT_MODE;

	info->data = (struct axp_data *)platform_get_device_id(pdev)->driver_data;

	indio_dev->name = platform_get_device_id(pdev)->name;
	indio_dev->info = info->data->iio_info;
	indio_dev->num_channels = info->data->num_channels;
	indio_dev->channels = info->data->channels;

	/* Enable the ADCs on IP */
	regmap_write(info->regmap, AXP20X_ADC_EN1, info->data->adc_en1_mask);

	if (info->data->adc_en2)
		/* Enable GPIO0/1 and internal temperature ADCs */
		regmap_update_bits(info->regmap, AXP20X_ADC_EN2,
				   AXP20X_ADC_EN2_MASK, AXP20X_ADC_EN2_MASK);

	/* Configure ADCs rate */
	regmap_update_bits(info->regmap, AXP20X_ADC_RATE, AXP20X_ADC_RATE_MASK,
			   info->data->adc_rate(100));

	ret = iio_map_array_register(indio_dev, info->data->maps);
	if (ret < 0) {
		dev_err(&pdev->dev, "failed to register IIO maps: %d\n", ret);
		goto fail_map;
	}

	ret = iio_device_register(indio_dev);
	if (ret < 0) {
		dev_err(&pdev->dev, "could not register the device\n");
		goto fail_register;
	}

	return 0;

fail_register:
	iio_map_array_unregister(indio_dev);

fail_map:
	regmap_write(info->regmap, AXP20X_ADC_EN1, 0);

	if (info->data->adc_en2)
		regmap_write(info->regmap, AXP20X_ADC_EN2, 0);

	return ret;
}

static int axp20x_remove(struct platform_device *pdev)
{
	struct iio_dev *indio_dev = platform_get_drvdata(pdev);
	struct axp20x_adc_iio *info = iio_priv(indio_dev);

	iio_device_unregister(indio_dev);
	iio_map_array_unregister(indio_dev);

	regmap_write(info->regmap, AXP20X_ADC_EN1, 0);

	if (info->data->adc_en2)
		regmap_write(info->regmap, AXP20X_ADC_EN2, 0);

	return 0;
}

static struct platform_driver axp20x_adc_driver = {
	.driver = {
		.name = "axp20x-adc",
	},
	.id_table = axp20x_adc_id_match,
	.probe = axp20x_probe,
	.remove = axp20x_remove,
};

module_platform_driver(axp20x_adc_driver);

MODULE_DESCRIPTION("ADC driver for AXP20X and AXP22X PMICs");
MODULE_AUTHOR("Quentin Schulz <quentin.schulz@free-electrons.com>");
MODULE_LICENSE("GPL");
Commit	Line	Data
0e34d5de QS	1	/* ADC driver for AXP20X and AXP22X PMICs
	2	*
	3	* Copyright (c) 2016 Free Electrons NextThing Co.
	4	* Quentin Schulz <quentin.schulz@free-electrons.com>
	5	*
	6	* This program is free software; you can redistribute it and/or modify it under
	7	* the terms of the GNU General Public License version 2 as published by the
	8	* Free Software Foundation.
	9	*/
	10
	11	#include <linux/completion.h>
	12	#include <linux/interrupt.h>
	13	#include <linux/io.h>
	14	#include <linux/module.h>
	15	#include <linux/of.h>
	16	#include <linux/of_device.h>
	17	#include <linux/platform_device.h>
	18	#include <linux/pm_runtime.h>
	19	#include <linux/regmap.h>
	20	#include <linux/thermal.h>
	21
	22	#include <linux/iio/iio.h>
	23	#include <linux/iio/driver.h>
	24	#include <linux/iio/machine.h>
	25	#include <linux/mfd/axp20x.h>
	26
	27	#define AXP20X_ADC_EN1_MASK GENMASK(7, 0)
	28
	29	#define AXP20X_ADC_EN2_MASK (GENMASK(3, 2) \| BIT(7))
	30	#define AXP22X_ADC_EN1_MASK (GENMASK(7, 5) \| BIT(0))
	31
	32	#define AXP20X_GPIO10_IN_RANGE_GPIO0 BIT(0)
	33	#define AXP20X_GPIO10_IN_RANGE_GPIO1 BIT(1)
	34	#define AXP20X_GPIO10_IN_RANGE_GPIO0_VAL(x) ((x) & BIT(0))
	35	#define AXP20X_GPIO10_IN_RANGE_GPIO1_VAL(x) (((x) & BIT(0)) << 1)
	36
	37	#define AXP20X_ADC_RATE_MASK GENMASK(7, 6)
	38	#define AXP20X_ADC_RATE_HZ(x) ((ilog2((x) / 25) << 6) & AXP20X_ADC_RATE_MASK)
	39	#define AXP22X_ADC_RATE_HZ(x) ((ilog2((x) / 100) << 6) & AXP20X_ADC_RATE_MASK)
	40
	41	#define AXP20X_ADC_CHANNEL(_channel, _name, _type, _reg) \
	42	{ \
	43	.type = _type, \
	44	.indexed = 1, \
	45	.channel = _channel, \
	46	.address = _reg, \
	47	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) \| \
	48	BIT(IIO_CHAN_INFO_SCALE), \
	49	.datasheet_name = _name, \
	50	}
	51
	52	#define AXP20X_ADC_CHANNEL_OFFSET(_channel, _name, _type, _reg) \
	53	{ \
	54	.type = _type, \
	55	.indexed = 1, \
	56	.channel = _channel, \
	57	.address = _reg, \
	58	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) \| \
	59	BIT(IIO_CHAN_INFO_SCALE) \|\
	60	BIT(IIO_CHAN_INFO_OFFSET),\
	61	.datasheet_name = _name, \
	62	}
	63
	64	struct axp_data;
65
66	struct axp20x_adc_iio {
67	struct regmap *regmap;
68	struct axp_data *data;
69	};
70
71	enum axp20x_adc_channel_v {
72	AXP20X_ACIN_V = 0,
73	AXP20X_VBUS_V,
74	AXP20X_TS_IN,
75	AXP20X_GPIO0_V,
76	AXP20X_GPIO1_V,
77	AXP20X_IPSOUT_V,
78	AXP20X_BATT_V,
79	};
80
81	enum axp20x_adc_channel_i {
82	AXP20X_ACIN_I = 0,
83	AXP20X_VBUS_I,
84	AXP20X_BATT_CHRG_I,
85	AXP20X_BATT_DISCHRG_I,
86	};
87
88	enum axp22x_adc_channel_v {
89	AXP22X_TS_IN = 0,
90	AXP22X_BATT_V,
91	};
92
93	enum axp22x_adc_channel_i {
94	AXP22X_BATT_CHRG_I = 1,
95	AXP22X_BATT_DISCHRG_I,
96	};
97
98	static struct iio_map axp20x_maps[] = {
99	{
100	.consumer_dev_name = "axp20x-usb-power-supply",
101	.consumer_channel = "vbus_v",
102	.adc_channel_label = "vbus_v",
103	}, {
104	.consumer_dev_name = "axp20x-usb-power-supply",
105	.consumer_channel = "vbus_i",
106	.adc_channel_label = "vbus_i",
107	}, {
108	.consumer_dev_name = "axp20x-ac-power-supply",
109	.consumer_channel = "acin_v",
110	.adc_channel_label = "acin_v",
111	}, {
112	.consumer_dev_name = "axp20x-ac-power-supply",
113	.consumer_channel = "acin_i",
114	.adc_channel_label = "acin_i",
115	}, {
116	.consumer_dev_name = "axp20x-battery-power-supply",
117	.consumer_channel = "batt_v",
118	.adc_channel_label = "batt_v",
119	}, {
120	.consumer_dev_name = "axp20x-battery-power-supply",
121	.consumer_channel = "batt_chrg_i",
122	.adc_channel_label = "batt_chrg_i",
123	}, {
124	.consumer_dev_name = "axp20x-battery-power-supply",
125	.consumer_channel = "batt_dischrg_i",
126	.adc_channel_label = "batt_dischrg_i",
127	}, { /* sentinel */ }
128	};
129
130	static struct iio_map axp22x_maps[] = {
131	{
132	.consumer_dev_name = "axp20x-battery-power-supply",
133	.consumer_channel = "batt_v",
134	.adc_channel_label = "batt_v",
135	}, {
136	.consumer_dev_name = "axp20x-battery-power-supply",
137	.consumer_channel = "batt_chrg_i",
138	.adc_channel_label = "batt_chrg_i",
139	}, {
140	.consumer_dev_name = "axp20x-battery-power-supply",
141	.consumer_channel = "batt_dischrg_i",
142	.adc_channel_label = "batt_dischrg_i",
143	}, { /* sentinel */ }
144	};
145
146	/*
147	* Channels are mapped by physical system. Their channels share the same index.
148	* i.e. acin_i is in_current0_raw and acin_v is in_voltage0_raw.
149	* The only exception is for the battery. batt_v will be in_voltage6_raw and
150	* charge current in_current6_raw and discharge current will be in_current7_raw.
151	*/
152	static const struct iio_chan_spec axp20x_adc_channels[] = {
153	AXP20X_ADC_CHANNEL(AXP20X_ACIN_V, "acin_v", IIO_VOLTAGE,
154	AXP20X_ACIN_V_ADC_H),
155	AXP20X_ADC_CHANNEL(AXP20X_ACIN_I, "acin_i", IIO_CURRENT,
156	AXP20X_ACIN_I_ADC_H),
157	AXP20X_ADC_CHANNEL(AXP20X_VBUS_V, "vbus_v", IIO_VOLTAGE,
158	AXP20X_VBUS_V_ADC_H),
159	AXP20X_ADC_CHANNEL(AXP20X_VBUS_I, "vbus_i", IIO_CURRENT,
160	AXP20X_VBUS_I_ADC_H),
161	{
162	.type = IIO_TEMP,
163	.address = AXP20X_TEMP_ADC_H,
164	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) \|
165	BIT(IIO_CHAN_INFO_SCALE) \|
166	BIT(IIO_CHAN_INFO_OFFSET),
167	.datasheet_name = "pmic_temp",
168	},
169	AXP20X_ADC_CHANNEL_OFFSET(AXP20X_GPIO0_V, "gpio0_v", IIO_VOLTAGE,
170	AXP20X_GPIO0_V_ADC_H),
171	AXP20X_ADC_CHANNEL_OFFSET(AXP20X_GPIO1_V, "gpio1_v", IIO_VOLTAGE,
172	AXP20X_GPIO1_V_ADC_H),
173	AXP20X_ADC_CHANNEL(AXP20X_IPSOUT_V, "ipsout_v", IIO_VOLTAGE,
174	AXP20X_IPSOUT_V_HIGH_H),
175	AXP20X_ADC_CHANNEL(AXP20X_BATT_V, "batt_v", IIO_VOLTAGE,
176	AXP20X_BATT_V_H),
177	AXP20X_ADC_CHANNEL(AXP20X_BATT_CHRG_I, "batt_chrg_i", IIO_CURRENT,
178	AXP20X_BATT_CHRG_I_H),
179	AXP20X_ADC_CHANNEL(AXP20X_BATT_DISCHRG_I, "batt_dischrg_i", IIO_CURRENT,
180	AXP20X_BATT_DISCHRG_I_H),
181	};
182
183	static const struct iio_chan_spec axp22x_adc_channels[] = {
184	{
185	.type = IIO_TEMP,
186	.address = AXP22X_PMIC_TEMP_H,
187	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) \|
188	BIT(IIO_CHAN_INFO_SCALE) \|
189	BIT(IIO_CHAN_INFO_OFFSET),
190	.datasheet_name = "pmic_temp",
191	},
192	AXP20X_ADC_CHANNEL(AXP22X_BATT_V, "batt_v", IIO_VOLTAGE,
193	AXP20X_BATT_V_H),
194	AXP20X_ADC_CHANNEL(AXP22X_BATT_CHRG_I, "batt_chrg_i", IIO_CURRENT,
195	AXP20X_BATT_CHRG_I_H),
196	AXP20X_ADC_CHANNEL(AXP22X_BATT_DISCHRG_I, "batt_dischrg_i", IIO_CURRENT,
197	AXP20X_BATT_DISCHRG_I_H),
198	};
199
200	static int axp20x_adc_raw(struct iio_dev *indio_dev,
201	struct iio_chan_spec const chan, int val)
202	{
203	struct axp20x_adc_iio *info = iio_priv(indio_dev);
204	int size = 12;
205
206	/*
207	* N.B.: Unlike the Chinese datasheets tell, the charging current is
208	* stored on 12 bits, not 13 bits. Only discharging current is on 13
209	* bits.
210	*/
211	if (chan->type == IIO_CURRENT && chan->channel == AXP20X_BATT_DISCHRG_I)
212	size = 13;
213	else
214	size = 12;
215
216	*val = axp20x_read_variable_width(info->regmap, chan->address, size);
217	if (*val < 0)
218	return *val;
219
220	return IIO_VAL_INT;
221	}
222
223	static int axp22x_adc_raw(struct iio_dev *indio_dev,
224	struct iio_chan_spec const chan, int val)
225	{
226	struct axp20x_adc_iio *info = iio_priv(indio_dev);
227	int size;
228
229	/*
230	* N.B.: Unlike the Chinese datasheets tell, the charging current is
231	* stored on 12 bits, not 13 bits. Only discharging current is on 13
232	* bits.
233	*/
234	if (chan->type == IIO_CURRENT && chan->channel == AXP22X_BATT_DISCHRG_I)
235	size = 13;
236	else
237	size = 12;
238
239	*val = axp20x_read_variable_width(info->regmap, chan->address, size);
240	if (*val < 0)
241	return *val;
242
243	return IIO_VAL_INT;
244	}
245
246	static int axp20x_adc_scale_voltage(int channel, int val, int val2)
247	{
248	switch (channel) {
249	case AXP20X_ACIN_V:
250	case AXP20X_VBUS_V:
251	*val = 1;
252	*val2 = 700000;
253	return IIO_VAL_INT_PLUS_MICRO;
254
255	case AXP20X_GPIO0_V:
256	case AXP20X_GPIO1_V:
257	*val = 0;
258	*val2 = 500000;
259	return IIO_VAL_INT_PLUS_MICRO;
260
261	case AXP20X_BATT_V:
262	*val = 1;
263	*val2 = 100000;
264	return IIO_VAL_INT_PLUS_MICRO;
265
266	case AXP20X_IPSOUT_V:
267	*val = 1;
268	*val2 = 400000;
269	return IIO_VAL_INT_PLUS_MICRO;
270
271	default:
272	return -EINVAL;
273	}
274	}
275
276	static int axp20x_adc_scale_current(int channel, int val, int val2)
277	{
278	switch (channel) {
279	case AXP20X_ACIN_I:
280	*val = 0;
281	*val2 = 625000;
282	return IIO_VAL_INT_PLUS_MICRO;
283
284	case AXP20X_VBUS_I:
285	*val = 0;
286	*val2 = 375000;
287	return IIO_VAL_INT_PLUS_MICRO;
288
289	case AXP20X_BATT_DISCHRG_I:
290	case AXP20X_BATT_CHRG_I:
291	*val = 0;
292	*val2 = 500000;
293	return IIO_VAL_INT_PLUS_MICRO;
294
295	default:
296	return -EINVAL;
297	}
298	}
299
300	static int axp20x_adc_scale(struct iio_chan_spec const chan, int val,
301	int *val2)
302	{
303	switch (chan->type) {
304	case IIO_VOLTAGE:
305	return axp20x_adc_scale_voltage(chan->channel, val, val2);
306
307	case IIO_CURRENT:
308	return axp20x_adc_scale_current(chan->channel, val, val2);
309
310	case IIO_TEMP:
311	*val = 100;
312	return IIO_VAL_INT;
313
314	default:
315	return -EINVAL;
316	}
317	}
318
319	static int axp22x_adc_scale(struct iio_chan_spec const chan, int val,
320	int *val2)
321	{
322	switch (chan->type) {
323	case IIO_VOLTAGE:
324	if (chan->channel != AXP22X_BATT_V)
325	return -EINVAL;
326
327	*val = 1;
328	*val2 = 100000;
329	return IIO_VAL_INT_PLUS_MICRO;
330
331	case IIO_CURRENT:
332	*val = 0;
333	*val2 = 500000;
334	return IIO_VAL_INT_PLUS_MICRO;
335
336	case IIO_TEMP:
337	*val = 100;
338	return IIO_VAL_INT;
339
340	default:
341	return -EINVAL;
342	}
343	}
344
345	static int axp20x_adc_offset_voltage(struct iio_dev *indio_dev, int channel,
346	int *val)
347	{
348	struct axp20x_adc_iio *info = iio_priv(indio_dev);
349	int ret;
350
351	ret = regmap_read(info->regmap, AXP20X_GPIO10_IN_RANGE, val);
352	if (ret < 0)
353	return ret;
354
355	switch (channel) {
356	case AXP20X_GPIO0_V:
357	*val &= AXP20X_GPIO10_IN_RANGE_GPIO0;
358	break;
359
360	case AXP20X_GPIO1_V:
361	*val &= AXP20X_GPIO10_IN_RANGE_GPIO1;
362	break;
363
364	default:
365	return -EINVAL;
366	}
367
368	val = !!(val) * 700000;
369
370	return IIO_VAL_INT;
371	}
372
373	static int axp20x_adc_offset(struct iio_dev *indio_dev,
374	struct iio_chan_spec const chan, int val)
375	{
376	switch (chan->type) {
377	case IIO_VOLTAGE:
378	return axp20x_adc_offset_voltage(indio_dev, chan->channel, val);
379
380	case IIO_TEMP:
381	*val = -1447;
382	return IIO_VAL_INT;
383
384	default:
385	return -EINVAL;
386	}
387	}
388
389	static int axp20x_read_raw(struct iio_dev *indio_dev,
390	struct iio_chan_spec const chan, int val,
391	int *val2, long mask)
392	{
393	switch (mask) {
394	case IIO_CHAN_INFO_OFFSET:
395	return axp20x_adc_offset(indio_dev, chan, val);
396
397	case IIO_CHAN_INFO_SCALE:
398	return axp20x_adc_scale(chan, val, val2);
399
400	case IIO_CHAN_INFO_RAW:
401	return axp20x_adc_raw(indio_dev, chan, val);
402
403	default:
404	return -EINVAL;
405	}
406	}
407
408	static int axp22x_read_raw(struct iio_dev *indio_dev,
409	struct iio_chan_spec const chan, int val,
410	int *val2, long mask)
411	{
412	switch (mask) {
413	case IIO_CHAN_INFO_OFFSET:
414	*val = -2677;
415	return IIO_VAL_INT;
416
417	case IIO_CHAN_INFO_SCALE:
418	return axp22x_adc_scale(chan, val, val2);
419
420	case IIO_CHAN_INFO_RAW:
421	return axp22x_adc_raw(indio_dev, chan, val);
422
423	default:
424	return -EINVAL;
425	}
426	}
427
428	static int axp20x_write_raw(struct iio_dev *indio_dev,
429	struct iio_chan_spec const *chan, int val, int val2,
430	long mask)
431	{
432	struct axp20x_adc_iio *info = iio_priv(indio_dev);
433	unsigned int reg, regval;
434
435	/*
436	* The AXP20X PMIC allows the user to choose between 0V and 0.7V offsets
437	* for (independently) GPIO0 and GPIO1 when in ADC mode.
438	*/
439	if (mask != IIO_CHAN_INFO_OFFSET)
440	return -EINVAL;
441
442	if (val != 0 && val != 700000)
443	return -EINVAL;
444
445	switch (chan->channel) {
446	case AXP20X_GPIO0_V:
447	reg = AXP20X_GPIO10_IN_RANGE_GPIO0;
448	regval = AXP20X_GPIO10_IN_RANGE_GPIO0_VAL(!!val);
449	break;
450
451	case AXP20X_GPIO1_V:
452	reg = AXP20X_GPIO10_IN_RANGE_GPIO1;
453	regval = AXP20X_GPIO10_IN_RANGE_GPIO1_VAL(!!val);
454	break;
455
456	default:
457	return -EINVAL;
458	}
459
460	return regmap_update_bits(info->regmap, AXP20X_GPIO10_IN_RANGE, reg,
461	regval);
462	}
463
464	static const struct iio_info axp20x_adc_iio_info = {
465	.read_raw = axp20x_read_raw,
466	.write_raw = axp20x_write_raw,
467	.driver_module = THIS_MODULE,
468	};
469
470	static const struct iio_info axp22x_adc_iio_info = {
471	.read_raw = axp22x_read_raw,
472	.driver_module = THIS_MODULE,
473	};
474
475	static int axp20x_adc_rate(int rate)
476	{
477	return AXP20X_ADC_RATE_HZ(rate);
478	}
479
480	static int axp22x_adc_rate(int rate)
481	{
482	return AXP22X_ADC_RATE_HZ(rate);
483	}
484
485	struct axp_data {
486	const struct iio_info *iio_info;
487	int num_channels;
488	struct iio_chan_spec const *channels;
489	unsigned long adc_en1_mask;
490	int (*adc_rate)(int rate);
491	bool adc_en2;
492	struct iio_map *maps;
493	};
494
495	static const struct axp_data axp20x_data = {
496	.iio_info = &axp20x_adc_iio_info,
497	.num_channels = ARRAY_SIZE(axp20x_adc_channels),
498	.channels = axp20x_adc_channels,
499	.adc_en1_mask = AXP20X_ADC_EN1_MASK,
500	.adc_rate = axp20x_adc_rate,
501	.adc_en2 = true,
502	.maps = axp20x_maps,
503	};
504
505	static const struct axp_data axp22x_data = {
506	.iio_info = &axp22x_adc_iio_info,
507	.num_channels = ARRAY_SIZE(axp22x_adc_channels),
508	.channels = axp22x_adc_channels,
509	.adc_en1_mask = AXP22X_ADC_EN1_MASK,
510	.adc_rate = axp22x_adc_rate,
511	.adc_en2 = false,
512	.maps = axp22x_maps,
513	};
514
515	static const struct platform_device_id axp20x_adc_id_match[] = {
516	{ .name = "axp20x-adc", .driver_data = (kernel_ulong_t)&axp20x_data, },
517	{ .name = "axp22x-adc", .driver_data = (kernel_ulong_t)&axp22x_data, },
518	{ /* sentinel */ },
519	};
520	MODULE_DEVICE_TABLE(platform, axp20x_adc_id_match);
521
522	static int axp20x_probe(struct platform_device *pdev)
523	{
524	struct axp20x_adc_iio *info;
525	struct iio_dev *indio_dev;
526	struct axp20x_dev *axp20x_dev;
527	int ret;
528
529	axp20x_dev = dev_get_drvdata(pdev->dev.parent);
530
531	indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*info));
532	if (!indio_dev)
533	return -ENOMEM;
534
535	info = iio_priv(indio_dev);
536	platform_set_drvdata(pdev, indio_dev);
537
538	info->regmap = axp20x_dev->regmap;
539	indio_dev->dev.parent = &pdev->dev;
540	indio_dev->dev.of_node = pdev->dev.of_node;
541	indio_dev->modes = INDIO_DIRECT_MODE;
542
543	info->data = (struct axp_data *)platform_get_device_id(pdev)->driver_data;
544
545	indio_dev->name = platform_get_device_id(pdev)->name;
546	indio_dev->info = info->data->iio_info;
547	indio_dev->num_channels = info->data->num_channels;
548	indio_dev->channels = info->data->channels;
549
550	/* Enable the ADCs on IP */
551	regmap_write(info->regmap, AXP20X_ADC_EN1, info->data->adc_en1_mask);
552
553	if (info->data->adc_en2)
554	/* Enable GPIO0/1 and internal temperature ADCs */
555	regmap_update_bits(info->regmap, AXP20X_ADC_EN2,
556	AXP20X_ADC_EN2_MASK, AXP20X_ADC_EN2_MASK);
557
558	/* Configure ADCs rate */
559	regmap_update_bits(info->regmap, AXP20X_ADC_RATE, AXP20X_ADC_RATE_MASK,
560	info->data->adc_rate(100));
561
562	ret = iio_map_array_register(indio_dev, info->data->maps);
563	if (ret < 0) {
564	dev_err(&pdev->dev, "failed to register IIO maps: %d\n", ret);
565	goto fail_map;
566	}
567
568	ret = iio_device_register(indio_dev);
569	if (ret < 0) {
570	dev_err(&pdev->dev, "could not register the device\n");
571	goto fail_register;
572	}
573
574	return 0;
575
576	fail_register:
577	iio_map_array_unregister(indio_dev);
578
579	fail_map:
580	regmap_write(info->regmap, AXP20X_ADC_EN1, 0);
581
582	if (info->data->adc_en2)
583	regmap_write(info->regmap, AXP20X_ADC_EN2, 0);
584
585	return ret;
586	}
587
588	static int axp20x_remove(struct platform_device *pdev)
589	{
590	struct iio_dev *indio_dev = platform_get_drvdata(pdev);
591	struct axp20x_adc_iio *info = iio_priv(indio_dev);
592
593	iio_device_unregister(indio_dev);
594	iio_map_array_unregister(indio_dev);
595
596	regmap_write(info->regmap, AXP20X_ADC_EN1, 0);
597
598	if (info->data->adc_en2)
599	regmap_write(info->regmap, AXP20X_ADC_EN2, 0);
600
601	return 0;
602	}
603
604	static struct platform_driver axp20x_adc_driver = {
605	.driver = {
606	.name = "axp20x-adc",
607	},
608	.id_table = axp20x_adc_id_match,
609	.probe = axp20x_probe,
610	.remove = axp20x_remove,
611	};
612
613	module_platform_driver(axp20x_adc_driver);
614
615	MODULE_DESCRIPTION("ADC driver for AXP20X and AXP22X PMICs");
616	MODULE_AUTHOR("Quentin Schulz <quentin.schulz@free-electrons.com>");
617	MODULE_LICENSE("GPL");