Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit a26033a1 authored by Rafael J. Wysocki's avatar Rafael J. Wysocki
Browse files

Merge branch 'ib-mfd-iio-3.19' of... 

Merge branch 'ib-mfd-iio-3.19' of git://git.kernel.org/pub/scm/linux/kernel/git/lee/mfd into acpi-pmic

Pull MFD changes that the ACPI PMIC changes depend on from Lee Jones.
parents 5d01410f 8019f696

drivers/iio/adc/Kconfig

+8 −0
Original line number Diff line number Diff line
@@ -127,6 +127,14 @@ config AT91_ADC 
	help

	  Say yes here to build support for Atmel AT91 ADC.



config AXP288_ADC

	tristate "X-Powers AXP288 ADC driver"

	depends on MFD_AXP20X

	help

	  Say yes here to have support for X-Powers power management IC (PMIC) ADC

	  device. Depending on platform configuration, this general purpose ADC can

	  be used for sampling sensors such as thermal resistors.



config EXYNOS_ADC

	tristate "Exynos ADC driver support"

	depends on ARCH_EXYNOS || ARCH_S3C24XX || ARCH_S3C64XX || (OF && COMPILE_TEST)

drivers/iio/adc/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -14,6 +14,7 @@ obj-$(CONFIG_AD7793) += ad7793.o 
obj-$(CONFIG_AD7887) += ad7887.o

obj-$(CONFIG_AD799X) += ad799x.o

obj-$(CONFIG_AT91_ADC) += at91_adc.o

obj-$(CONFIG_AXP288_ADC) += axp288_adc.o

obj-$(CONFIG_EXYNOS_ADC) += exynos_adc.o

obj-$(CONFIG_LP8788_ADC) += lp8788_adc.o

obj-$(CONFIG_MAX1027) += max1027.o

drivers/iio/adc/axp288_adc.c

0 → 100644
+261 −0
Original line number Diff line number Diff line 
/*

 * axp288_adc.c - X-Powers AXP288 PMIC ADC Driver

 *

 * Copyright (C) 2014 Intel Corporation

 *

 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; version 2 of the License.

 *

 * 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.

 *

 */



#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/device.h>

#include <linux/regmap.h>

#include <linux/mfd/axp20x.h>

#include <linux/platform_device.h>



#include <linux/iio/iio.h>

#include <linux/iio/machine.h>

#include <linux/iio/driver.h>



#define AXP288_ADC_EN_MASK		0xF1

#define AXP288_ADC_TS_PIN_GPADC		0xF2

#define AXP288_ADC_TS_PIN_ON		0xF3



enum axp288_adc_id {

	AXP288_ADC_TS,

	AXP288_ADC_PMIC,

	AXP288_ADC_GP,

	AXP288_ADC_BATT_CHRG_I,

	AXP288_ADC_BATT_DISCHRG_I,

	AXP288_ADC_BATT_V,

	AXP288_ADC_NR_CHAN,

};



struct axp288_adc_info {

	int irq;

	struct regmap *regmap;

};



static const struct iio_chan_spec const axp288_adc_channels[] = {

	{

		.indexed = 1,

		.type = IIO_TEMP,

		.channel = 0,

		.address = AXP288_TS_ADC_H,

		.datasheet_name = "TS_PIN",

	}, {

		.indexed = 1,

		.type = IIO_TEMP,

		.channel = 1,

		.address = AXP288_PMIC_ADC_H,

		.datasheet_name = "PMIC_TEMP",

	}, {

		.indexed = 1,

		.type = IIO_TEMP,

		.channel = 2,

		.address = AXP288_GP_ADC_H,

		.datasheet_name = "GPADC",

	}, {

		.indexed = 1,

		.type = IIO_CURRENT,

		.channel = 3,

		.address = AXP20X_BATT_CHRG_I_H,

		.datasheet_name = "BATT_CHG_I",

		.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),

	}, {

		.indexed = 1,

		.type = IIO_CURRENT,

		.channel = 4,

		.address = AXP20X_BATT_DISCHRG_I_H,

		.datasheet_name = "BATT_DISCHRG_I",

		.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),

	}, {

		.indexed = 1,

		.type = IIO_VOLTAGE,

		.channel = 5,

		.address = AXP20X_BATT_V_H,

		.datasheet_name = "BATT_V",

		.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),

	},

};



#define AXP288_ADC_MAP(_adc_channel_label, _consumer_dev_name,	\

		_consumer_channel)				\

	{							\

		.adc_channel_label = _adc_channel_label,	\

		.consumer_dev_name = _consumer_dev_name,	\

		.consumer_channel = _consumer_channel,		\

	}



/* for consumer drivers */

static struct iio_map axp288_adc_default_maps[] = {

	AXP288_ADC_MAP("TS_PIN", "axp288-batt", "axp288-batt-temp"),

	AXP288_ADC_MAP("PMIC_TEMP", "axp288-pmic", "axp288-pmic-temp"),

	AXP288_ADC_MAP("GPADC", "axp288-gpadc", "axp288-system-temp"),

	AXP288_ADC_MAP("BATT_CHG_I", "axp288-chrg", "axp288-chrg-curr"),

	AXP288_ADC_MAP("BATT_DISCHRG_I", "axp288-chrg", "axp288-chrg-d-curr"),

	AXP288_ADC_MAP("BATT_V", "axp288-batt", "axp288-batt-volt"),

	{},

};



static int axp288_adc_read_channel(int *val, unsigned long address,

				struct regmap *regmap)

{

	u8 buf[2];



	if (regmap_bulk_read(regmap, address, buf, 2))

		return -EIO;

	*val = (buf[0] << 4) + ((buf[1] >> 4) & 0x0F);



	return IIO_VAL_INT;

}



static int axp288_adc_set_ts(struct regmap *regmap, unsigned int mode,

				unsigned long address)

{

	/* channels other than GPADC do not need to switch TS pin */

	if (address != AXP288_GP_ADC_H)

		return 0;



	return regmap_write(regmap, AXP288_ADC_TS_PIN_CTRL, mode);

}



static int axp288_adc_read_raw(struct iio_dev *indio_dev,

			struct iio_chan_spec const *chan,

			int *val, int *val2, long mask)

{

	int ret;

	struct axp288_adc_info *info = iio_priv(indio_dev);



	mutex_lock(&indio_dev->mlock);

	switch (mask) {

	case IIO_CHAN_INFO_RAW:

		if (axp288_adc_set_ts(info->regmap, AXP288_ADC_TS_PIN_GPADC,

					chan->address)) {

			dev_err(&indio_dev->dev, "GPADC mode\n");

			ret = -EINVAL;

			break;

		}

		ret = axp288_adc_read_channel(val, chan->address, info->regmap);

		if (axp288_adc_set_ts(info->regmap, AXP288_ADC_TS_PIN_ON,

						chan->address))

			dev_err(&indio_dev->dev, "TS pin restore\n");

		break;

	case IIO_CHAN_INFO_PROCESSED:

		ret = axp288_adc_read_channel(val, chan->address, info->regmap);

		break;

	default:

		ret = -EINVAL;

	}

	mutex_unlock(&indio_dev->mlock);



	return ret;

}



static int axp288_adc_set_state(struct regmap *regmap)

{

	/* ADC should be always enabled for internal FG to function */

	if (regmap_write(regmap, AXP288_ADC_TS_PIN_CTRL, AXP288_ADC_TS_PIN_ON))

		return -EIO;



	return regmap_write(regmap, AXP20X_ADC_EN1, AXP288_ADC_EN_MASK);

}



static const struct iio_info axp288_adc_iio_info = {

	.read_raw = &axp288_adc_read_raw,

	.driver_module = THIS_MODULE,

};



static int axp288_adc_probe(struct platform_device *pdev)

{

	int ret;

	struct axp288_adc_info *info;

	struct iio_dev *indio_dev;

	struct axp20x_dev *axp20x = 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);

	info->irq = platform_get_irq(pdev, 0);

	if (info->irq < 0) {

		dev_err(&pdev->dev, "no irq resource?\n");

		return info->irq;

	}

	platform_set_drvdata(pdev, indio_dev);

	info->regmap = axp20x->regmap;

	/*

	 * Set ADC to enabled state at all time, including system suspend.

	 * otherwise internal fuel gauge functionality may be affected.

	 */

	ret = axp288_adc_set_state(axp20x->regmap);

	if (ret) {

		dev_err(&pdev->dev, "unable to enable ADC device\n");

		return ret;

	}



	indio_dev->dev.parent = &pdev->dev;

	indio_dev->name = pdev->name;

	indio_dev->channels = axp288_adc_channels;

	indio_dev->num_channels = ARRAY_SIZE(axp288_adc_channels);

	indio_dev->info = &axp288_adc_iio_info;

	indio_dev->modes = INDIO_DIRECT_MODE;

	ret = iio_map_array_register(indio_dev, axp288_adc_default_maps);

	if (ret < 0)

		return ret;



	ret = iio_device_register(indio_dev);

	if (ret < 0) {

		dev_err(&pdev->dev, "unable to register iio device\n");

		goto err_array_unregister;

	}

	return 0;



err_array_unregister:

	iio_map_array_unregister(indio_dev);



	return ret;

}



static int axp288_adc_remove(struct platform_device *pdev)

{

	struct iio_dev *indio_dev = platform_get_drvdata(pdev);



	iio_device_unregister(indio_dev);

	iio_map_array_unregister(indio_dev);



	return 0;

}



static struct platform_device_id axp288_adc_id_table[] = {

	{ .name = "axp288_adc" },

	{},

};



static struct platform_driver axp288_adc_driver = {

	.probe = axp288_adc_probe,

	.remove = axp288_adc_remove,

	.id_table = axp288_adc_id_table,

	.driver = {

		.name = "axp288_adc",

	},

};



MODULE_DEVICE_TABLE(platform, axp288_adc_id_table);



module_platform_driver(axp288_adc_driver);



MODULE_AUTHOR("Jacob Pan <jacob.jun.pan@linux.intel.com>");

MODULE_DESCRIPTION("X-Powers AXP288 ADC Driver");

MODULE_LICENSE("GPL");

drivers/mfd/Kconfig

+2 −1
Original line number Diff line number Diff line
@@ -74,7 +74,8 @@ config MFD_AXP20X 
	select REGMAP_IRQ

	depends on I2C=y

	help

	  If you say Y here you get support for the X-Powers AXP202 and AXP209.

	  If you say Y here you get support for the X-Powers AXP202, AXP209 and

	  AXP288 power management IC (PMIC).

	  This driver include only the core APIs. You have to select individual

	  components like regulators or the PEK (Power Enable Key) under the

	  corresponding menus.

drivers/mfd/axp20x.c

+306 −55
Original line number Diff line number Diff line 
/*

 * axp20x.c - MFD core driver for the X-Powers AXP202 and AXP209

 * axp20x.c - MFD core driver for the X-Powers' Power Management ICs

 *

 * AXP20x comprises an adaptive USB-Compatible PWM charger, 2 BUCK DC-DC

 * converters, 5 LDOs, multiple 12-bit ADCs of voltage, current and temperature

 * as well as 4 configurable GPIOs.

 * AXP20x typically comprises an adaptive USB-Compatible PWM charger, BUCK DC-DC

 * converters, LDOs, multiple 12-bit ADCs of voltage, current and temperature

 * as well as configurable GPIOs.

 *

 * Author: Carlo Caione <carlo@caione.org>

 *
@@ -25,9 +25,16 @@ 
#include <linux/mfd/core.h>

#include <linux/of_device.h>

#include <linux/of_irq.h>

#include <linux/acpi.h>



#define AXP20X_OFF	0x80



static const char const *axp20x_model_names[] = {

	"AXP202",

	"AXP209",

	"AXP288",

};



static const struct regmap_range axp20x_writeable_ranges[] = {

	regmap_reg_range(AXP20X_DATACACHE(0), AXP20X_IRQ5_STATE),

	regmap_reg_range(AXP20X_DCDC_MODE, AXP20X_FG_RES),
@@ -47,6 +54,25 @@ static const struct regmap_access_table axp20x_volatile_table = { 
	.n_yes_ranges	= ARRAY_SIZE(axp20x_volatile_ranges),

};



static const struct regmap_range axp288_writeable_ranges[] = {

	regmap_reg_range(AXP20X_DATACACHE(0), AXP20X_IRQ6_STATE),

	regmap_reg_range(AXP20X_DCDC_MODE, AXP288_FG_TUNE5),

};



static const struct regmap_range axp288_volatile_ranges[] = {

	regmap_reg_range(AXP20X_IRQ1_EN, AXP20X_IPSOUT_V_HIGH_L),

};



static const struct regmap_access_table axp288_writeable_table = {

	.yes_ranges	= axp288_writeable_ranges,

	.n_yes_ranges	= ARRAY_SIZE(axp288_writeable_ranges),

};



static const struct regmap_access_table axp288_volatile_table = {

	.yes_ranges	= axp288_volatile_ranges,

	.n_yes_ranges	= ARRAY_SIZE(axp288_volatile_ranges),

};



static struct resource axp20x_pek_resources[] = {

	{

		.name	= "PEK_DBR",
@@ -61,6 +87,39 @@ static struct resource axp20x_pek_resources[] = { 
	},

};



static struct resource axp288_battery_resources[] = {

	{

		.start = AXP288_IRQ_QWBTU,

		.end   = AXP288_IRQ_QWBTU,

		.flags = IORESOURCE_IRQ,

	},

	{

		.start = AXP288_IRQ_WBTU,

		.end   = AXP288_IRQ_WBTU,

		.flags = IORESOURCE_IRQ,

	},

	{

		.start = AXP288_IRQ_QWBTO,

		.end   = AXP288_IRQ_QWBTO,

		.flags = IORESOURCE_IRQ,

	},

	{

		.start = AXP288_IRQ_WBTO,

		.end   = AXP288_IRQ_WBTO,

		.flags = IORESOURCE_IRQ,

	},

	{

		.start = AXP288_IRQ_WL2,

		.end   = AXP288_IRQ_WL2,

		.flags = IORESOURCE_IRQ,

	},

	{

		.start = AXP288_IRQ_WL1,

		.end   = AXP288_IRQ_WL1,

		.flags = IORESOURCE_IRQ,

	},

};



static const struct regmap_config axp20x_regmap_config = {

	.reg_bits	= 8,

	.val_bits	= 8,
@@ -70,47 +129,96 @@ static const struct regmap_config axp20x_regmap_config = { 
	.cache_type	= REGCACHE_RBTREE,

};



#define AXP20X_IRQ(_irq, _off, _mask) \

	[AXP20X_IRQ_##_irq] = { .reg_offset = (_off), .mask = BIT(_mask) }

static const struct regmap_config axp288_regmap_config = {

	.reg_bits	= 8,

	.val_bits	= 8,

	.wr_table	= &axp288_writeable_table,

	.volatile_table	= &axp288_volatile_table,

	.max_register	= AXP288_FG_TUNE5,

	.cache_type	= REGCACHE_RBTREE,

};



#define INIT_REGMAP_IRQ(_variant, _irq, _off, _mask)			\

	[_variant##_IRQ_##_irq] = { .reg_offset = (_off), .mask = BIT(_mask) }



static const struct regmap_irq axp20x_regmap_irqs[] = {

	AXP20X_IRQ(ACIN_OVER_V,		0, 7),

	AXP20X_IRQ(ACIN_PLUGIN,		0, 6),

	AXP20X_IRQ(ACIN_REMOVAL,	0, 5),

	AXP20X_IRQ(VBUS_OVER_V,		0, 4),

	AXP20X_IRQ(VBUS_PLUGIN,		0, 3),

	AXP20X_IRQ(VBUS_REMOVAL,	0, 2),

	AXP20X_IRQ(VBUS_V_LOW,		0, 1),

	AXP20X_IRQ(BATT_PLUGIN,		1, 7),

	AXP20X_IRQ(BATT_REMOVAL,	1, 6),

	AXP20X_IRQ(BATT_ENT_ACT_MODE,	1, 5),

	AXP20X_IRQ(BATT_EXIT_ACT_MODE,	1, 4),

	AXP20X_IRQ(CHARG,		1, 3),

	AXP20X_IRQ(CHARG_DONE,		1, 2),

	AXP20X_IRQ(BATT_TEMP_HIGH,	1, 1),

	AXP20X_IRQ(BATT_TEMP_LOW,	1, 0),

	AXP20X_IRQ(DIE_TEMP_HIGH,	2, 7),

	AXP20X_IRQ(CHARG_I_LOW,		2, 6),

	AXP20X_IRQ(DCDC1_V_LONG,	2, 5),

	AXP20X_IRQ(DCDC2_V_LONG,	2, 4),

	AXP20X_IRQ(DCDC3_V_LONG,	2, 3),

	AXP20X_IRQ(PEK_SHORT,		2, 1),

	AXP20X_IRQ(PEK_LONG,		2, 0),

	AXP20X_IRQ(N_OE_PWR_ON,		3, 7),

	AXP20X_IRQ(N_OE_PWR_OFF,	3, 6),

	AXP20X_IRQ(VBUS_VALID,		3, 5),

	AXP20X_IRQ(VBUS_NOT_VALID,	3, 4),

	AXP20X_IRQ(VBUS_SESS_VALID,	3, 3),

	AXP20X_IRQ(VBUS_SESS_END,	3, 2),

	AXP20X_IRQ(LOW_PWR_LVL1,	3, 1),

	AXP20X_IRQ(LOW_PWR_LVL2,	3, 0),

	AXP20X_IRQ(TIMER,		4, 7),

	AXP20X_IRQ(PEK_RIS_EDGE,	4, 6),

	AXP20X_IRQ(PEK_FAL_EDGE,	4, 5),

	AXP20X_IRQ(GPIO3_INPUT,		4, 3),

	AXP20X_IRQ(GPIO2_INPUT,		4, 2),

	AXP20X_IRQ(GPIO1_INPUT,		4, 1),

	AXP20X_IRQ(GPIO0_INPUT,		4, 0),

	INIT_REGMAP_IRQ(AXP20X, ACIN_OVER_V,		0, 7),

	INIT_REGMAP_IRQ(AXP20X, ACIN_PLUGIN,		0, 6),

	INIT_REGMAP_IRQ(AXP20X, ACIN_REMOVAL,	        0, 5),

	INIT_REGMAP_IRQ(AXP20X, VBUS_OVER_V,		0, 4),

	INIT_REGMAP_IRQ(AXP20X, VBUS_PLUGIN,		0, 3),

	INIT_REGMAP_IRQ(AXP20X, VBUS_REMOVAL,	        0, 2),

	INIT_REGMAP_IRQ(AXP20X, VBUS_V_LOW,		0, 1),

	INIT_REGMAP_IRQ(AXP20X, BATT_PLUGIN,		1, 7),

	INIT_REGMAP_IRQ(AXP20X, BATT_REMOVAL,	        1, 6),

	INIT_REGMAP_IRQ(AXP20X, BATT_ENT_ACT_MODE,	1, 5),

	INIT_REGMAP_IRQ(AXP20X, BATT_EXIT_ACT_MODE,	1, 4),

	INIT_REGMAP_IRQ(AXP20X, CHARG,		        1, 3),

	INIT_REGMAP_IRQ(AXP20X, CHARG_DONE,		1, 2),

	INIT_REGMAP_IRQ(AXP20X, BATT_TEMP_HIGH,	        1, 1),

	INIT_REGMAP_IRQ(AXP20X, BATT_TEMP_LOW,	        1, 0),

	INIT_REGMAP_IRQ(AXP20X, DIE_TEMP_HIGH,	        2, 7),

	INIT_REGMAP_IRQ(AXP20X, CHARG_I_LOW,		2, 6),

	INIT_REGMAP_IRQ(AXP20X, DCDC1_V_LONG,	        2, 5),

	INIT_REGMAP_IRQ(AXP20X, DCDC2_V_LONG,	        2, 4),

	INIT_REGMAP_IRQ(AXP20X, DCDC3_V_LONG,	        2, 3),

	INIT_REGMAP_IRQ(AXP20X, PEK_SHORT,		2, 1),

	INIT_REGMAP_IRQ(AXP20X, PEK_LONG,		2, 0),

	INIT_REGMAP_IRQ(AXP20X, N_OE_PWR_ON,		3, 7),

	INIT_REGMAP_IRQ(AXP20X, N_OE_PWR_OFF,	        3, 6),

	INIT_REGMAP_IRQ(AXP20X, VBUS_VALID,		3, 5),

	INIT_REGMAP_IRQ(AXP20X, VBUS_NOT_VALID,	        3, 4),

	INIT_REGMAP_IRQ(AXP20X, VBUS_SESS_VALID,	3, 3),

	INIT_REGMAP_IRQ(AXP20X, VBUS_SESS_END,	        3, 2),

	INIT_REGMAP_IRQ(AXP20X, LOW_PWR_LVL1,	        3, 1),

	INIT_REGMAP_IRQ(AXP20X, LOW_PWR_LVL2,	        3, 0),

	INIT_REGMAP_IRQ(AXP20X, TIMER,		        4, 7),

	INIT_REGMAP_IRQ(AXP20X, PEK_RIS_EDGE,	        4, 6),

	INIT_REGMAP_IRQ(AXP20X, PEK_FAL_EDGE,	        4, 5),

	INIT_REGMAP_IRQ(AXP20X, GPIO3_INPUT,		4, 3),

	INIT_REGMAP_IRQ(AXP20X, GPIO2_INPUT,		4, 2),

	INIT_REGMAP_IRQ(AXP20X, GPIO1_INPUT,		4, 1),

	INIT_REGMAP_IRQ(AXP20X, GPIO0_INPUT,		4, 0),

};



/* some IRQs are compatible with axp20x models */

static const struct regmap_irq axp288_regmap_irqs[] = {

	INIT_REGMAP_IRQ(AXP288, VBUS_FALL,              0, 2),

	INIT_REGMAP_IRQ(AXP288, VBUS_RISE,              0, 3),

	INIT_REGMAP_IRQ(AXP288, OV,                     0, 4),



	INIT_REGMAP_IRQ(AXP288, DONE,                   1, 2),

	INIT_REGMAP_IRQ(AXP288, CHARGING,               1, 3),

	INIT_REGMAP_IRQ(AXP288, SAFE_QUIT,              1, 4),

	INIT_REGMAP_IRQ(AXP288, SAFE_ENTER,             1, 5),

	INIT_REGMAP_IRQ(AXP288, ABSENT,                 1, 6),

	INIT_REGMAP_IRQ(AXP288, APPEND,                 1, 7),



	INIT_REGMAP_IRQ(AXP288, QWBTU,                  2, 0),

	INIT_REGMAP_IRQ(AXP288, WBTU,                   2, 1),

	INIT_REGMAP_IRQ(AXP288, QWBTO,                  2, 2),

	INIT_REGMAP_IRQ(AXP288, WBTO,                   2, 3),

	INIT_REGMAP_IRQ(AXP288, QCBTU,                  2, 4),

	INIT_REGMAP_IRQ(AXP288, CBTU,                   2, 5),

	INIT_REGMAP_IRQ(AXP288, QCBTO,                  2, 6),

	INIT_REGMAP_IRQ(AXP288, CBTO,                   2, 7),



	INIT_REGMAP_IRQ(AXP288, WL2,                    3, 0),

	INIT_REGMAP_IRQ(AXP288, WL1,                    3, 1),

	INIT_REGMAP_IRQ(AXP288, GPADC,                  3, 2),

	INIT_REGMAP_IRQ(AXP288, OT,                     3, 7),



	INIT_REGMAP_IRQ(AXP288, GPIO0,                  4, 0),

	INIT_REGMAP_IRQ(AXP288, GPIO1,                  4, 1),

	INIT_REGMAP_IRQ(AXP288, POKO,                   4, 2),

	INIT_REGMAP_IRQ(AXP288, POKL,                   4, 3),

	INIT_REGMAP_IRQ(AXP288, POKS,                   4, 4),

	INIT_REGMAP_IRQ(AXP288, POKN,                   4, 5),

	INIT_REGMAP_IRQ(AXP288, POKP,                   4, 6),

	INIT_REGMAP_IRQ(AXP288, TIMER,                  4, 7),



	INIT_REGMAP_IRQ(AXP288, MV_CHNG,                5, 0),

	INIT_REGMAP_IRQ(AXP288, BC_USB_CHNG,            5, 1),

};



static const struct of_device_id axp20x_of_match[] = {
@@ -128,16 +236,39 @@ static const struct i2c_device_id axp20x_i2c_id[] = { 
};

MODULE_DEVICE_TABLE(i2c, axp20x_i2c_id);



static struct acpi_device_id axp20x_acpi_match[] = {

	{

		.id = "INT33F4",

		.driver_data = AXP288_ID,

	},

	{ },

};

MODULE_DEVICE_TABLE(acpi, axp20x_acpi_match);



static const struct regmap_irq_chip axp20x_regmap_irq_chip = {

	.name			= "axp20x_irq_chip",

	.status_base		= AXP20X_IRQ1_STATE,

	.ack_base		= AXP20X_IRQ1_STATE,

	.mask_base		= AXP20X_IRQ1_EN,

	.num_regs		= 5,

	.mask_invert		= true,

	.init_ack_masked	= true,

	.irqs			= axp20x_regmap_irqs,

	.num_irqs		= ARRAY_SIZE(axp20x_regmap_irqs),

	.num_regs		= 5,



};



static const struct regmap_irq_chip axp288_regmap_irq_chip = {

	.name			= "axp288_irq_chip",

	.status_base		= AXP20X_IRQ1_STATE,

	.ack_base		= AXP20X_IRQ1_STATE,

	.mask_base		= AXP20X_IRQ1_EN,

	.mask_invert		= true,

	.init_ack_masked	= true,

	.irqs			= axp288_regmap_irqs,

	.num_irqs		= ARRAY_SIZE(axp288_regmap_irqs),

	.num_regs		= 6,



};



static struct mfd_cell axp20x_cells[] = {
@@ -150,36 +281,155 @@ static struct mfd_cell axp20x_cells[] = { 
	},

};



static struct resource axp288_adc_resources[] = {

	{

		.name  = "GPADC",

		.start = AXP288_IRQ_GPADC,

		.end   = AXP288_IRQ_GPADC,

		.flags = IORESOURCE_IRQ,

	},

};



static struct resource axp288_charger_resources[] = {

	{

		.start = AXP288_IRQ_OV,

		.end   = AXP288_IRQ_OV,

		.flags = IORESOURCE_IRQ,

	},

	{

		.start = AXP288_IRQ_DONE,

		.end   = AXP288_IRQ_DONE,

		.flags = IORESOURCE_IRQ,

	},

	{

		.start = AXP288_IRQ_CHARGING,

		.end   = AXP288_IRQ_CHARGING,

		.flags = IORESOURCE_IRQ,

	},

	{

		.start = AXP288_IRQ_SAFE_QUIT,

		.end   = AXP288_IRQ_SAFE_QUIT,

		.flags = IORESOURCE_IRQ,

	},

	{

		.start = AXP288_IRQ_SAFE_ENTER,

		.end   = AXP288_IRQ_SAFE_ENTER,

		.flags = IORESOURCE_IRQ,

	},

	{

		.start = AXP288_IRQ_QCBTU,

		.end   = AXP288_IRQ_QCBTU,

		.flags = IORESOURCE_IRQ,

	},

	{

		.start = AXP288_IRQ_CBTU,

		.end   = AXP288_IRQ_CBTU,

		.flags = IORESOURCE_IRQ,

	},

	{

		.start = AXP288_IRQ_QCBTO,

		.end   = AXP288_IRQ_QCBTO,

		.flags = IORESOURCE_IRQ,

	},

	{

		.start = AXP288_IRQ_CBTO,

		.end   = AXP288_IRQ_CBTO,

		.flags = IORESOURCE_IRQ,

	},

};



static struct mfd_cell axp288_cells[] = {

	{

		.name = "axp288_adc",

		.num_resources = ARRAY_SIZE(axp288_adc_resources),

		.resources = axp288_adc_resources,

	},

	{

		.name = "axp288_charger",

		.num_resources = ARRAY_SIZE(axp288_charger_resources),

		.resources = axp288_charger_resources,

	},

	{

		.name = "axp288_battery",

		.num_resources = ARRAY_SIZE(axp288_battery_resources),

		.resources = axp288_battery_resources,

	},

};



static struct axp20x_dev *axp20x_pm_power_off;

static void axp20x_power_off(void)

{

	if (axp20x_pm_power_off->variant == AXP288_ID)

		return;



	regmap_write(axp20x_pm_power_off->regmap, AXP20X_OFF_CTRL,

		     AXP20X_OFF);

}



static int axp20x_match_device(struct axp20x_dev *axp20x, struct device *dev)

{

	const struct acpi_device_id *acpi_id;

	const struct of_device_id *of_id;



	if (dev->of_node) {

		of_id = of_match_device(axp20x_of_match, dev);

		if (!of_id) {

			dev_err(dev, "Unable to match OF ID\n");

			return -ENODEV;

		}

		axp20x->variant = (long) of_id->data;

	} else {

		acpi_id = acpi_match_device(dev->driver->acpi_match_table, dev);

		if (!acpi_id || !acpi_id->driver_data) {

			dev_err(dev, "Unable to match ACPI ID and data\n");

			return -ENODEV;

		}

		axp20x->variant = (long) acpi_id->driver_data;

	}



	switch (axp20x->variant) {

	case AXP202_ID:

	case AXP209_ID:

		axp20x->nr_cells = ARRAY_SIZE(axp20x_cells);

		axp20x->cells = axp20x_cells;

		axp20x->regmap_cfg = &axp20x_regmap_config;

		axp20x->regmap_irq_chip = &axp20x_regmap_irq_chip;

		break;

	case AXP288_ID:

		axp20x->cells = axp288_cells;

		axp20x->nr_cells = ARRAY_SIZE(axp288_cells);

		axp20x->regmap_cfg = &axp288_regmap_config;

		axp20x->regmap_irq_chip = &axp288_regmap_irq_chip;

		break;

	default:

		dev_err(dev, "unsupported AXP20X ID %lu\n", axp20x->variant);

		return -EINVAL;

	}

	dev_info(dev, "AXP20x variant %s found\n",

		axp20x_model_names[axp20x->variant]);



	return 0;

}



static int axp20x_i2c_probe(struct i2c_client *i2c,

			 const struct i2c_device_id *id)

{

	struct axp20x_dev *axp20x;

	const struct of_device_id *of_id;

	int ret;



	axp20x = devm_kzalloc(&i2c->dev, sizeof(*axp20x), GFP_KERNEL);

	if (!axp20x)

		return -ENOMEM;



	of_id = of_match_device(axp20x_of_match, &i2c->dev);

	if (!of_id) {

		dev_err(&i2c->dev, "Unable to setup AXP20X data\n");

		return -ENODEV;

	}

	axp20x->variant = (long) of_id->data;

	ret = axp20x_match_device(axp20x, &i2c->dev);

	if (ret)

		return ret;



	axp20x->i2c_client = i2c;

	axp20x->dev = &i2c->dev;

	dev_set_drvdata(axp20x->dev, axp20x);



	axp20x->regmap = devm_regmap_init_i2c(i2c, &axp20x_regmap_config);

	axp20x->regmap = devm_regmap_init_i2c(i2c, axp20x->regmap_cfg);

	if (IS_ERR(axp20x->regmap)) {

		ret = PTR_ERR(axp20x->regmap);

		dev_err(&i2c->dev, "regmap init failed: %d\n", ret);
@@ -188,15 +438,15 @@ static int axp20x_i2c_probe(struct i2c_client *i2c, 


	ret = regmap_add_irq_chip(axp20x->regmap, i2c->irq,

				  IRQF_ONESHOT | IRQF_SHARED, -1,

				  &axp20x_regmap_irq_chip,

				  axp20x->regmap_irq_chip,

				  &axp20x->regmap_irqc);

	if (ret) {

		dev_err(&i2c->dev, "failed to add irq chip: %d\n", ret);

		return ret;

	}



	ret = mfd_add_devices(axp20x->dev, -1, axp20x_cells,

			      ARRAY_SIZE(axp20x_cells), NULL, 0, NULL);

	ret = mfd_add_devices(axp20x->dev, -1, axp20x->cells,

			axp20x->nr_cells, NULL, 0, NULL);



	if (ret) {

		dev_err(&i2c->dev, "failed to add MFD devices: %d\n", ret);
@@ -234,6 +484,7 @@ static struct i2c_driver axp20x_i2c_driver = { 
		.name	= "axp20x",

		.owner	= THIS_MODULE,

		.of_match_table	= of_match_ptr(axp20x_of_match),

		.acpi_match_table = ACPI_PTR(axp20x_acpi_match),

	},

	.probe		= axp20x_i2c_probe,

	.remove		= axp20x_i2c_remove,