[thirdparty/kernel/linux.git] / drivers / mfd / sec-core.c

// SPDX-License-Identifier: GPL-2.0+
//
// Copyright (c) 2012 Samsung Electronics Co., Ltd
//              http://www.samsung.com

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/i2c.h>
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/pm_runtime.h>
#include <linux/mutex.h>
#include <linux/mfd/core.h>
#include <linux/mfd/samsung/core.h>
#include <linux/mfd/samsung/irq.h>
#include <linux/mfd/samsung/s2mpa01.h>
#include <linux/mfd/samsung/s2mps11.h>
#include <linux/mfd/samsung/s2mps13.h>
#include <linux/mfd/samsung/s2mps14.h>
#include <linux/mfd/samsung/s2mps15.h>
#include <linux/mfd/samsung/s2mpu02.h>
#include <linux/mfd/samsung/s5m8763.h>
#include <linux/mfd/samsung/s5m8767.h>
#include <linux/regmap.h>

static const struct mfd_cell s5m8751_devs[] = {
	{
		.name = "s5m8751-pmic",
	}, {
		.name = "s5m-charger",
	}, {
		.name = "s5m8751-codec",
	},
};

static const struct mfd_cell s5m8763_devs[] = {
	{
		.name = "s5m8763-pmic",
	}, {
		.name = "s5m-rtc",
	}, {
		.name = "s5m-charger",
	},
};

static const struct mfd_cell s5m8767_devs[] = {
	{
		.name = "s5m8767-pmic",
	}, {
		.name = "s5m-rtc",
	}, {
		.name = "s5m8767-clk",
		.of_compatible = "samsung,s5m8767-clk",
	}
};

static const struct mfd_cell s2mps11_devs[] = {
	{
		.name = "s2mps11-regulator",
	}, {
		.name = "s2mps14-rtc",
	}, {
		.name = "s2mps11-clk",
		.of_compatible = "samsung,s2mps11-clk",
	}
};

static const struct mfd_cell s2mps13_devs[] = {
	{ .name = "s2mps13-regulator", },
	{ .name = "s2mps13-rtc", },
	{
		.name = "s2mps13-clk",
		.of_compatible = "samsung,s2mps13-clk",
	},
};

static const struct mfd_cell s2mps14_devs[] = {
	{
		.name = "s2mps14-regulator",
	}, {
		.name = "s2mps14-rtc",
	}, {
		.name = "s2mps14-clk",
		.of_compatible = "samsung,s2mps14-clk",
	}
};

static const struct mfd_cell s2mps15_devs[] = {
	{
		.name = "s2mps15-regulator",
	}, {
		.name = "s2mps15-rtc",
	}, {
		.name = "s2mps13-clk",
		.of_compatible = "samsung,s2mps13-clk",
	},
};

static const struct mfd_cell s2mpa01_devs[] = {
	{
		.name = "s2mpa01-pmic",
	},
};

static const struct mfd_cell s2mpu02_devs[] = {
	{
		.name = "s2mpu02-regulator",
	},
};

#ifdef CONFIG_OF
static const struct of_device_id sec_dt_match[] = {
	{	.compatible = "samsung,s5m8767-pmic",
		.data = (void *)S5M8767X,
	}, {
		.compatible = "samsung,s2mps11-pmic",
		.data = (void *)S2MPS11X,
	}, {
		.compatible = "samsung,s2mps13-pmic",
		.data = (void *)S2MPS13X,
	}, {
		.compatible = "samsung,s2mps14-pmic",
		.data = (void *)S2MPS14X,
	}, {
		.compatible = "samsung,s2mps15-pmic",
		.data = (void *)S2MPS15X,
	}, {
		.compatible = "samsung,s2mpa01-pmic",
		.data = (void *)S2MPA01,
	}, {
		.compatible = "samsung,s2mpu02-pmic",
		.data = (void *)S2MPU02,
	}, {
		/* Sentinel */
	},
};
MODULE_DEVICE_TABLE(of, sec_dt_match);
#endif

static bool s2mpa01_volatile(struct device *dev, unsigned int reg)
{
	switch (reg) {
	case S2MPA01_REG_INT1M:
	case S2MPA01_REG_INT2M:
	case S2MPA01_REG_INT3M:
		return false;
	default:
		return true;
	}
}

static bool s2mps11_volatile(struct device *dev, unsigned int reg)
{
	switch (reg) {
	case S2MPS11_REG_INT1M:
	case S2MPS11_REG_INT2M:
	case S2MPS11_REG_INT3M:
		return false;
	default:
		return true;
	}
}

static bool s2mpu02_volatile(struct device *dev, unsigned int reg)
{
	switch (reg) {
	case S2MPU02_REG_INT1M:
	case S2MPU02_REG_INT2M:
	case S2MPU02_REG_INT3M:
		return false;
	default:
		return true;
	}
}

static bool s5m8763_volatile(struct device *dev, unsigned int reg)
{
	switch (reg) {
	case S5M8763_REG_IRQM1:
	case S5M8763_REG_IRQM2:
	case S5M8763_REG_IRQM3:
	case S5M8763_REG_IRQM4:
		return false;
	default:
		return true;
	}
}

static const struct regmap_config sec_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,
};

static const struct regmap_config s2mpa01_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,

	.max_register = S2MPA01_REG_LDO_OVCB4,
	.volatile_reg = s2mpa01_volatile,
	.cache_type = REGCACHE_FLAT,
};

static const struct regmap_config s2mps11_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,

	.max_register = S2MPS11_REG_L38CTRL,
	.volatile_reg = s2mps11_volatile,
	.cache_type = REGCACHE_FLAT,
};

static const struct regmap_config s2mps13_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,

	.max_register = S2MPS13_REG_LDODSCH5,
	.volatile_reg = s2mps11_volatile,
	.cache_type = REGCACHE_FLAT,
};

static const struct regmap_config s2mps14_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,

	.max_register = S2MPS14_REG_LDODSCH3,
	.volatile_reg = s2mps11_volatile,
	.cache_type = REGCACHE_FLAT,
};

static const struct regmap_config s2mps15_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,

	.max_register = S2MPS15_REG_LDODSCH4,
	.volatile_reg = s2mps11_volatile,
	.cache_type = REGCACHE_FLAT,
};

static const struct regmap_config s2mpu02_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,

	.max_register = S2MPU02_REG_DVSDATA,
	.volatile_reg = s2mpu02_volatile,
	.cache_type = REGCACHE_FLAT,
};

static const struct regmap_config s5m8763_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,

	.max_register = S5M8763_REG_LBCNFG2,
	.volatile_reg = s5m8763_volatile,
	.cache_type = REGCACHE_FLAT,
};

static const struct regmap_config s5m8767_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,

	.max_register = S5M8767_REG_LDO28CTRL,
	.volatile_reg = s2mps11_volatile,
	.cache_type = REGCACHE_FLAT,
};

static void sec_pmic_dump_rev(struct sec_pmic_dev *sec_pmic)
{
	unsigned int val;

	/* For each device type, the REG_ID is always the first register */
	if (!regmap_read(sec_pmic->regmap_pmic, S2MPS11_REG_ID, &val))
		dev_dbg(sec_pmic->dev, "Revision: 0x%x\n", val);
}

static void sec_pmic_configure(struct sec_pmic_dev *sec_pmic)
{
	int err;

	if (sec_pmic->device_type != S2MPS13X)
		return;

	if (sec_pmic->pdata->disable_wrstbi) {
		/*
		 * If WRSTBI pin is pulled down this feature must be disabled
		 * because each Suspend to RAM will trigger buck voltage reset
		 * to default values.
		 */
		err = regmap_update_bits(sec_pmic->regmap_pmic,
					 S2MPS13_REG_WRSTBI,
					 S2MPS13_REG_WRSTBI_MASK, 0x0);
		if (err)
			dev_warn(sec_pmic->dev,
				 "Cannot initialize WRSTBI config: %d\n",
				 err);
	}
}

#ifdef CONFIG_OF
/*
 * Only the common platform data elements for s5m8767 are parsed here from the
 * device tree. Other sub-modules of s5m8767 such as pmic, rtc , charger and
 * others have to parse their own platform data elements from device tree.
 *
 * The s5m8767 platform data structure is instantiated here and the drivers for
 * the sub-modules need not instantiate another instance while parsing their
 * platform data.
 */
static struct sec_platform_data *sec_pmic_i2c_parse_dt_pdata(
					struct device *dev)
{
	struct sec_platform_data *pd;

	pd = devm_kzalloc(dev, sizeof(*pd), GFP_KERNEL);
	if (!pd)
		return ERR_PTR(-ENOMEM);

	/*
	 * ToDo: the 'wakeup' member in the platform data is more of a linux
	 * specfic information. Hence, there is no binding for that yet and
	 * not parsed here.
	 */

	pd->manual_poweroff = of_property_read_bool(dev->of_node,
						"samsung,s2mps11-acokb-ground");
	pd->disable_wrstbi = of_property_read_bool(dev->of_node,
						"samsung,s2mps11-wrstbi-ground");
	return pd;
}
#else
static struct sec_platform_data *sec_pmic_i2c_parse_dt_pdata(
					struct device *dev)
{
	return NULL;
}
#endif

static inline unsigned long sec_i2c_get_driver_data(struct i2c_client *i2c,
						const struct i2c_device_id *id)
{
#ifdef CONFIG_OF
	if (i2c->dev.of_node) {
		const struct of_device_id *match;

		match = of_match_node(sec_dt_match, i2c->dev.of_node);
		return (unsigned long)match->data;
	}
#endif
	return id->driver_data;
}

static int sec_pmic_probe(struct i2c_client *i2c,
			    const struct i2c_device_id *id)
{
	struct sec_platform_data *pdata = dev_get_platdata(&i2c->dev);
	const struct regmap_config *regmap;
	const struct mfd_cell *sec_devs;
	struct sec_pmic_dev *sec_pmic;
	unsigned long device_type;
	int ret, num_sec_devs;

	sec_pmic = devm_kzalloc(&i2c->dev, sizeof(struct sec_pmic_dev),
				GFP_KERNEL);
	if (sec_pmic == NULL)
		return -ENOMEM;

	i2c_set_clientdata(i2c, sec_pmic);
	sec_pmic->dev = &i2c->dev;
	sec_pmic->i2c = i2c;
	sec_pmic->irq = i2c->irq;
	device_type = sec_i2c_get_driver_data(i2c, id);

	if (sec_pmic->dev->of_node) {
		pdata = sec_pmic_i2c_parse_dt_pdata(sec_pmic->dev);
		if (IS_ERR(pdata)) {
			ret = PTR_ERR(pdata);
			return ret;
		}
		pdata->device_type = device_type;
	}
	if (pdata) {
		sec_pmic->device_type = pdata->device_type;
		sec_pmic->irq_base = pdata->irq_base;
		sec_pmic->wakeup = pdata->wakeup;
		sec_pmic->pdata = pdata;
	}

	switch (sec_pmic->device_type) {
	case S2MPA01:
		regmap = &s2mpa01_regmap_config;
		break;
	case S2MPS11X:
		regmap = &s2mps11_regmap_config;
		break;
	case S2MPS13X:
		regmap = &s2mps13_regmap_config;
		break;
	case S2MPS14X:
		regmap = &s2mps14_regmap_config;
		break;
	case S2MPS15X:
		regmap = &s2mps15_regmap_config;
		break;
	case S5M8763X:
		regmap = &s5m8763_regmap_config;
		break;
	case S5M8767X:
		regmap = &s5m8767_regmap_config;
		break;
	case S2MPU02:
		regmap = &s2mpu02_regmap_config;
		break;
	default:
		regmap = &sec_regmap_config;
		break;
	}

	sec_pmic->regmap_pmic = devm_regmap_init_i2c(i2c, regmap);
	if (IS_ERR(sec_pmic->regmap_pmic)) {
		ret = PTR_ERR(sec_pmic->regmap_pmic);
		dev_err(&i2c->dev, "Failed to allocate register map: %d\n",
			ret);
		return ret;
	}

	if (pdata && pdata->cfg_pmic_irq)
		pdata->cfg_pmic_irq();

	sec_irq_init(sec_pmic);

	pm_runtime_set_active(sec_pmic->dev);

	switch (sec_pmic->device_type) {
	case S5M8751X:
		sec_devs = s5m8751_devs;
		num_sec_devs = ARRAY_SIZE(s5m8751_devs);
		break;
	case S5M8763X:
		sec_devs = s5m8763_devs;
		num_sec_devs = ARRAY_SIZE(s5m8763_devs);
		break;
	case S5M8767X:
		sec_devs = s5m8767_devs;
		num_sec_devs = ARRAY_SIZE(s5m8767_devs);
		break;
	case S2MPA01:
		sec_devs = s2mpa01_devs;
		num_sec_devs = ARRAY_SIZE(s2mpa01_devs);
		break;
	case S2MPS11X:
		sec_devs = s2mps11_devs;
		num_sec_devs = ARRAY_SIZE(s2mps11_devs);
		break;
	case S2MPS13X:
		sec_devs = s2mps13_devs;
		num_sec_devs = ARRAY_SIZE(s2mps13_devs);
		break;
	case S2MPS14X:
		sec_devs = s2mps14_devs;
		num_sec_devs = ARRAY_SIZE(s2mps14_devs);
		break;
	case S2MPS15X:
		sec_devs = s2mps15_devs;
		num_sec_devs = ARRAY_SIZE(s2mps15_devs);
		break;
	case S2MPU02:
		sec_devs = s2mpu02_devs;
		num_sec_devs = ARRAY_SIZE(s2mpu02_devs);
		break;
	default:
		/* If this happens the probe function is problem */
		BUG();
	}
	ret = devm_mfd_add_devices(sec_pmic->dev, -1, sec_devs, num_sec_devs,
				   NULL, 0, NULL);
	if (ret)
		return ret;

	device_init_wakeup(sec_pmic->dev, sec_pmic->wakeup);
	sec_pmic_configure(sec_pmic);
	sec_pmic_dump_rev(sec_pmic);

	return ret;
}

static void sec_pmic_shutdown(struct i2c_client *i2c)
{
	struct sec_pmic_dev *sec_pmic = i2c_get_clientdata(i2c);
	unsigned int reg, mask;

	if (!sec_pmic->pdata->manual_poweroff)
		return;

	switch (sec_pmic->device_type) {
	case S2MPS11X:
		reg = S2MPS11_REG_CTRL1;
		mask = S2MPS11_CTRL1_PWRHOLD_MASK;
		break;
	default:
		/*
		 * Currently only one board with S2MPS11 needs this, so just
		 * ignore the rest.
		 */
		dev_warn(sec_pmic->dev,
			"Unsupported device %lu for manual power off\n",
			sec_pmic->device_type);
		return;
	}

	regmap_update_bits(sec_pmic->regmap_pmic, reg, mask, 0);
}

#ifdef CONFIG_PM_SLEEP
static int sec_pmic_suspend(struct device *dev)
{
	struct i2c_client *i2c = to_i2c_client(dev);
	struct sec_pmic_dev *sec_pmic = i2c_get_clientdata(i2c);

	if (device_may_wakeup(dev))
		enable_irq_wake(sec_pmic->irq);
	/*
	 * PMIC IRQ must be disabled during suspend for RTC alarm
	 * to work properly.
	 * When device is woken up from suspend, an
	 * interrupt occurs before resuming I2C bus controller.
	 * The interrupt is handled by regmap_irq_thread which tries
	 * to read RTC registers. This read fails (I2C is still
	 * suspended) and RTC Alarm interrupt is disabled.
	 */
	disable_irq(sec_pmic->irq);

	return 0;
}

static int sec_pmic_resume(struct device *dev)
{
	struct i2c_client *i2c = to_i2c_client(dev);
	struct sec_pmic_dev *sec_pmic = i2c_get_clientdata(i2c);

	if (device_may_wakeup(dev))
		disable_irq_wake(sec_pmic->irq);
	enable_irq(sec_pmic->irq);

	return 0;
}
#endif /* CONFIG_PM_SLEEP */

static SIMPLE_DEV_PM_OPS(sec_pmic_pm_ops, sec_pmic_suspend, sec_pmic_resume);

static const struct i2c_device_id sec_pmic_id[] = {
	{ "sec_pmic", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, sec_pmic_id);

static struct i2c_driver sec_pmic_driver = {
	.driver = {
		   .name = "sec_pmic",
		   .pm = &sec_pmic_pm_ops,
		   .of_match_table = of_match_ptr(sec_dt_match),
	},
	.probe = sec_pmic_probe,
	.shutdown = sec_pmic_shutdown,
	.id_table = sec_pmic_id,
};

static int __init sec_pmic_init(void)
{
	return i2c_add_driver(&sec_pmic_driver);
}

subsys_initcall(sec_pmic_init);

static void __exit sec_pmic_exit(void)
{
	i2c_del_driver(&sec_pmic_driver);
}
module_exit(sec_pmic_exit);

MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
MODULE_DESCRIPTION("Core support for the S5M MFD");
MODULE_LICENSE("GPL");
Commit	Line	Data
39b27ad9 KK	1	// SPDX-License-Identifier: GPL-2.0+
	2	//
	3	// Copyright (c) 2012 Samsung Electronics Co., Ltd
	4	// http://www.samsung.com
0f5f7078 SK	5
	6	#include <linux/module.h>
	7	#include <linux/moduleparam.h>
	8	#include <linux/init.h>
	9	#include <linux/err.h>
	10	#include <linux/slab.h>
	11	#include <linux/i2c.h>
1c5a099b	12	#include <linux/of.h>
26aec009	13	#include <linux/of_irq.h>
0f5f7078 SK	14	#include <linux/interrupt.h>
	15	#include <linux/pm_runtime.h>
	16	#include <linux/mutex.h>
	17	#include <linux/mfd/core.h>
54227bcf SK	18	#include <linux/mfd/samsung/core.h>
54227bcf SK	19	#include <linux/mfd/samsung/irq.h>
ce24991e	20	#include <linux/mfd/samsung/s2mpa01.h>
25f311fa	21	#include <linux/mfd/samsung/s2mps11.h>
76b9840b	22	#include <linux/mfd/samsung/s2mps13.h>
dc691966	23	#include <linux/mfd/samsung/s2mps14.h>
9e4808d2	24	#include <linux/mfd/samsung/s2mps15.h>
00e2573d	25	#include <linux/mfd/samsung/s2mpu02.h>
25f311fa MB	26	#include <linux/mfd/samsung/s5m8763.h>
25f311fa MB	27	#include <linux/mfd/samsung/s5m8767.h>
0f5f7078 SK	28	#include <linux/regmap.h>
0f5f7078 SK	29
5ac98553	30	static const struct mfd_cell s5m8751_devs[] = {
88a1cfd6 SK	31	{
	32	.name = "s5m8751-pmic",
	33	}, {
	34	.name = "s5m-charger",
	35	}, {
	36	.name = "s5m8751-codec",
	37	},
	38	};
	39
5ac98553	40	static const struct mfd_cell s5m8763_devs[] = {
88a1cfd6 SK	41	{
	42	.name = "s5m8763-pmic",
	43	}, {
	44	.name = "s5m-rtc",
	45	}, {
	46	.name = "s5m-charger",
	47	},
	48	};
	49
5ac98553	50	static const struct mfd_cell s5m8767_devs[] = {
0f5f7078 SK	51	{
	52	.name = "s5m8767-pmic",
	53	}, {
	54	.name = "s5m-rtc",
39fed00f TB	55	}, {
39fed00f TB	56	.name = "s5m8767-clk",
53c31b34	57	.of_compatible = "samsung,s5m8767-clk",
39fed00f	58	}
0f5f7078 SK	59	};
0f5f7078 SK	60
5ac98553	61	static const struct mfd_cell s2mps11_devs[] = {
9b6d1343	62	{
2fadbbf0	63	.name = "s2mps11-regulator",
eea2e596 KK	64	}, {
eea2e596 KK	65	.name = "s2mps14-rtc",
3134bcae YSB	66	}, {
3134bcae YSB	67	.name = "s2mps11-clk",
53c31b34	68	.of_compatible = "samsung,s2mps11-clk",
3134bcae	69	}
9b6d1343 SK	70	};
9b6d1343 SK	71
3bc2ee91	72	static const struct mfd_cell s2mps13_devs[] = {
2fadbbf0	73	{ .name = "s2mps13-regulator", },
3bc2ee91 CC	74	{ .name = "s2mps13-rtc", },
	75	{
	76	.name = "s2mps13-clk",
	77	.of_compatible = "samsung,s2mps13-clk",
	78	},
	79	};
	80
dc691966 KK	81	static const struct mfd_cell s2mps14_devs[] = {
dc691966 KK	82	{
2fadbbf0	83	.name = "s2mps14-regulator",
dc691966 KK	84	}, {
	85	.name = "s2mps14-rtc",
	86	}, {
	87	.name = "s2mps14-clk",
53c31b34	88	.of_compatible = "samsung,s2mps14-clk",
dc691966 KK	89	}
	90	};
	91
9e4808d2 TA	92	static const struct mfd_cell s2mps15_devs[] = {
	93	{
	94	.name = "s2mps15-regulator",
	95	}, {
	96	.name = "s2mps15-rtc",
	97	}, {
	98	.name = "s2mps13-clk",
	99	.of_compatible = "samsung,s2mps13-clk",
	100	},
	101	};
	102
ce24991e SK	103	static const struct mfd_cell s2mpa01_devs[] = {
	104	{
	105	.name = "s2mpa01-pmic",
	106	},
	107	};
	108
54e8827d	109	static const struct mfd_cell s2mpu02_devs[] = {
54e8827d	110	{
2fadbbf0	111	.name = "s2mpu02-regulator",
644a3746	112	},
54e8827d CC	113	};
54e8827d CC	114
26aec009	115	#ifdef CONFIG_OF
df20b7c5	116	static const struct of_device_id sec_dt_match[] = {
26aec009 ADK	117	{ .compatible = "samsung,s5m8767-pmic",
26aec009 ADK	118	.data = (void *)S5M8767X,
ce24991e SK	119	}, {
ce24991e SK	120	.compatible = "samsung,s2mps11-pmic",
aa32acad	121	.data = (void *)S2MPS11X,
3bc2ee91 CC	122	}, {
	123	.compatible = "samsung,s2mps13-pmic",
	124	.data = (void *)S2MPS13X,
ce24991e SK	125	}, {
ce24991e SK	126	.compatible = "samsung,s2mps14-pmic",
dc691966	127	.data = (void *)S2MPS14X,
9e4808d2 TA	128	}, {
	129	.compatible = "samsung,s2mps15-pmic",
	130	.data = (void *)S2MPS15X,
ce24991e SK	131	}, {
	132	.compatible = "samsung,s2mpa01-pmic",
	133	.data = (void *)S2MPA01,
54e8827d CC	134	}, {
	135	.compatible = "samsung,s2mpu02-pmic",
	136	.data = (void *)S2MPU02,
ce24991e SK	137	}, {
ce24991e SK	138	/* Sentinel */
dc691966	139	},
26aec009	140	};
fe8166c9	141	MODULE_DEVICE_TABLE(of, sec_dt_match);
26aec009 ADK	142	#endif
26aec009 ADK	143
ce24991e SK	144	static bool s2mpa01_volatile(struct device *dev, unsigned int reg)
	145	{
	146	switch (reg) {
	147	case S2MPA01_REG_INT1M:
	148	case S2MPA01_REG_INT2M:
	149	case S2MPA01_REG_INT3M:
	150	return false;
	151	default:
	152	return true;
	153	}
	154	}
	155
6b845ba9 MB	156	static bool s2mps11_volatile(struct device *dev, unsigned int reg)
	157	{
	158	switch (reg) {
	159	case S2MPS11_REG_INT1M:
	160	case S2MPS11_REG_INT2M:
	161	case S2MPS11_REG_INT3M:
	162	return false;
	163	default:
	164	return true;
	165	}
	166	}
	167
00e2573d CC	168	static bool s2mpu02_volatile(struct device *dev, unsigned int reg)
	169	{
	170	switch (reg) {
	171	case S2MPU02_REG_INT1M:
	172	case S2MPU02_REG_INT2M:
	173	case S2MPU02_REG_INT3M:
	174	return false;
	175	default:
	176	return true;
	177	}
	178	}
	179
6b845ba9 MB	180	static bool s5m8763_volatile(struct device *dev, unsigned int reg)
	181	{
	182	switch (reg) {
	183	case S5M8763_REG_IRQM1:
	184	case S5M8763_REG_IRQM2:
	185	case S5M8763_REG_IRQM3:
	186	case S5M8763_REG_IRQM4:
	187	return false;
	188	default:
	189	return true;
	190	}
	191	}
	192
a30fffb0	193	static const struct regmap_config sec_regmap_config = {
0f5f7078 SK	194	.reg_bits = 8,
	195	.val_bits = 8,
	196	};
	197
ce24991e SK	198	static const struct regmap_config s2mpa01_regmap_config = {
	199	.reg_bits = 8,
	200	.val_bits = 8,
	201
	202	.max_register = S2MPA01_REG_LDO_OVCB4,
	203	.volatile_reg = s2mpa01_volatile,
	204	.cache_type = REGCACHE_FLAT,
	205	};
	206
a30fffb0	207	static const struct regmap_config s2mps11_regmap_config = {
25f311fa MB	208	.reg_bits = 8,
	209	.val_bits = 8,
	210
	211	.max_register = S2MPS11_REG_L38CTRL,
6b845ba9 MB	212	.volatile_reg = s2mps11_volatile,
6b845ba9 MB	213	.cache_type = REGCACHE_FLAT,
25f311fa MB	214	};
25f311fa MB	215
76b9840b CC	216	static const struct regmap_config s2mps13_regmap_config = {
	217	.reg_bits = 8,
	218	.val_bits = 8,
	219
	220	.max_register = S2MPS13_REG_LDODSCH5,
	221	.volatile_reg = s2mps11_volatile,
	222	.cache_type = REGCACHE_FLAT,
	223	};
	224
dc691966 KK	225	static const struct regmap_config s2mps14_regmap_config = {
	226	.reg_bits = 8,
	227	.val_bits = 8,
	228
	229	.max_register = S2MPS14_REG_LDODSCH3,
	230	.volatile_reg = s2mps11_volatile,
	231	.cache_type = REGCACHE_FLAT,
	232	};
	233
9e4808d2 TA	234	static const struct regmap_config s2mps15_regmap_config = {
	235	.reg_bits = 8,
	236	.val_bits = 8,
	237
	238	.max_register = S2MPS15_REG_LDODSCH4,
	239	.volatile_reg = s2mps11_volatile,
	240	.cache_type = REGCACHE_FLAT,
	241	};
	242
00e2573d CC	243	static const struct regmap_config s2mpu02_regmap_config = {
	244	.reg_bits = 8,
	245	.val_bits = 8,
	246
	247	.max_register = S2MPU02_REG_DVSDATA,
	248	.volatile_reg = s2mpu02_volatile,
	249	.cache_type = REGCACHE_FLAT,
	250	};
	251
a30fffb0	252	static const struct regmap_config s5m8763_regmap_config = {
25f311fa MB	253	.reg_bits = 8,
	254	.val_bits = 8,
	255
	256	.max_register = S5M8763_REG_LBCNFG2,
6b845ba9 MB	257	.volatile_reg = s5m8763_volatile,
6b845ba9 MB	258	.cache_type = REGCACHE_FLAT,
25f311fa MB	259	};
25f311fa MB	260
a30fffb0	261	static const struct regmap_config s5m8767_regmap_config = {
25f311fa MB	262	.reg_bits = 8,
	263	.val_bits = 8,
	264
	265	.max_register = S5M8767_REG_LDO28CTRL,
6b845ba9 MB	266	.volatile_reg = s2mps11_volatile,
6b845ba9 MB	267	.cache_type = REGCACHE_FLAT,
25f311fa	268	};
26aec009	269
c2c9f1fe KK	270	static void sec_pmic_dump_rev(struct sec_pmic_dev *sec_pmic)
	271	{
	272	unsigned int val;
	273
	274	/* For each device type, the REG_ID is always the first register */
	275	if (!regmap_read(sec_pmic->regmap_pmic, S2MPS11_REG_ID, &val))
	276	dev_dbg(sec_pmic->dev, "Revision: 0x%x\n", val);
	277	}
	278
8a97d428 KK	279	static void sec_pmic_configure(struct sec_pmic_dev *sec_pmic)
	280	{
	281	int err;
	282
	283	if (sec_pmic->device_type != S2MPS13X)
	284	return;
	285
	286	if (sec_pmic->pdata->disable_wrstbi) {
	287	/*
	288	* If WRSTBI pin is pulled down this feature must be disabled
	289	* because each Suspend to RAM will trigger buck voltage reset
	290	* to default values.
	291	*/
	292	err = regmap_update_bits(sec_pmic->regmap_pmic,
	293	S2MPS13_REG_WRSTBI,
	294	S2MPS13_REG_WRSTBI_MASK, 0x0);
	295	if (err)
	296	dev_warn(sec_pmic->dev,
	297	"Cannot initialize WRSTBI config: %d\n",
	298	err);
	299	}
	300	}
	301
26aec009 ADK	302	#ifdef CONFIG_OF
	303	/*
	304	* Only the common platform data elements for s5m8767 are parsed here from the
	305	* device tree. Other sub-modules of s5m8767 such as pmic, rtc , charger and
	306	* others have to parse their own platform data elements from device tree.
	307	*
	308	* The s5m8767 platform data structure is instantiated here and the drivers for
	309	* the sub-modules need not instantiate another instance while parsing their
	310	* platform data.
	311	*/
	312	static struct sec_platform_data *sec_pmic_i2c_parse_dt_pdata(
	313	struct device *dev)
	314	{
	315	struct sec_platform_data *pd;
	316
	317	pd = devm_kzalloc(dev, sizeof(*pd), GFP_KERNEL);
82a00c49	318	if (!pd)
26aec009	319	return ERR_PTR(-ENOMEM);
26aec009 ADK	320
	321	/*
	322	* ToDo: the 'wakeup' member in the platform data is more of a linux
	323	* specfic information. Hence, there is no binding for that yet and
	324	* not parsed here.
	325	*/
	326
d785334a KK	327	pd->manual_poweroff = of_property_read_bool(dev->of_node,
d785334a KK	328	"samsung,s2mps11-acokb-ground");
8a97d428 KK	329	pd->disable_wrstbi = of_property_read_bool(dev->of_node,
8a97d428 KK	330	"samsung,s2mps11-wrstbi-ground");
26aec009 ADK	331	return pd;
	332	}
	333	#else
197bf856	334	static struct sec_platform_data *sec_pmic_i2c_parse_dt_pdata(
26aec009 ADK	335	struct device *dev)
26aec009 ADK	336	{
005718c0	337	return NULL;
26aec009 ADK	338	}
	339	#endif
	340
8f695de5	341	static inline unsigned long sec_i2c_get_driver_data(struct i2c_client *i2c,
26aec009 ADK	342	const struct i2c_device_id *id)
	343	{
	344	#ifdef CONFIG_OF
	345	if (i2c->dev.of_node) {
	346	const struct of_device_id *match;
b6c1cb4d	347
26aec009	348	match = of_match_node(sec_dt_match, i2c->dev.of_node);
8f695de5	349	return (unsigned long)match->data;
26aec009 ADK	350	}
26aec009 ADK	351	#endif
8f695de5	352	return id->driver_data;
26aec009 ADK	353	}
26aec009 ADK	354
63063bfb	355	static int sec_pmic_probe(struct i2c_client *i2c,
0f5f7078 SK	356	const struct i2c_device_id *id)
0f5f7078 SK	357	{
334a41ce	358	struct sec_platform_data *pdata = dev_get_platdata(&i2c->dev);
e349c910	359	const struct regmap_config *regmap;
54e8827d	360	const struct mfd_cell *sec_devs;
63063bfb	361	struct sec_pmic_dev *sec_pmic;
9549b5ff	362	unsigned long device_type;
54e8827d	363	int ret, num_sec_devs;
0f5f7078	364
63063bfb	365	sec_pmic = devm_kzalloc(&i2c->dev, sizeof(struct sec_pmic_dev),
621210e2	366	GFP_KERNEL);
63063bfb	367	if (sec_pmic == NULL)
0f5f7078 SK	368	return -ENOMEM;
0f5f7078 SK	369
63063bfb SK	370	i2c_set_clientdata(i2c, sec_pmic);
	371	sec_pmic->dev = &i2c->dev;
	372	sec_pmic->i2c = i2c;
	373	sec_pmic->irq = i2c->irq;
9549b5ff	374	device_type = sec_i2c_get_driver_data(i2c, id);
26aec009 ADK	375
	376	if (sec_pmic->dev->of_node) {
	377	pdata = sec_pmic_i2c_parse_dt_pdata(sec_pmic->dev);
	378	if (IS_ERR(pdata)) {
	379	ret = PTR_ERR(pdata);
	380	return ret;
	381	}
9549b5ff	382	pdata->device_type = device_type;
26aec009	383	}
0f5f7078	384	if (pdata) {
63063bfb	385	sec_pmic->device_type = pdata->device_type;
63063bfb SK	386	sec_pmic->irq_base = pdata->irq_base;
63063bfb SK	387	sec_pmic->wakeup = pdata->wakeup;
26aec009	388	sec_pmic->pdata = pdata;
0f5f7078 SK	389	}
0f5f7078 SK	390
25f311fa	391	switch (sec_pmic->device_type) {
ce24991e SK	392	case S2MPA01:
	393	regmap = &s2mpa01_regmap_config;
	394	break;
25f311fa MB	395	case S2MPS11X:
25f311fa MB	396	regmap = &s2mps11_regmap_config;
dc691966	397	break;
76b9840b CC	398	case S2MPS13X:
	399	regmap = &s2mps13_regmap_config;
	400	break;
dc691966 KK	401	case S2MPS14X:
dc691966 KK	402	regmap = &s2mps14_regmap_config;
25f311fa	403	break;
9e4808d2 TA	404	case S2MPS15X:
	405	regmap = &s2mps15_regmap_config;
	406	break;
25f311fa MB	407	case S5M8763X:
	408	regmap = &s5m8763_regmap_config;
	409	break;
	410	case S5M8767X:
	411	regmap = &s5m8767_regmap_config;
	412	break;
00e2573d CC	413	case S2MPU02:
	414	regmap = &s2mpu02_regmap_config;
	415	break;
25f311fa MB	416	default:
	417	regmap = &sec_regmap_config;
	418	break;
	419	}
	420
3e1e4a5f KK	421	sec_pmic->regmap_pmic = devm_regmap_init_i2c(i2c, regmap);
	422	if (IS_ERR(sec_pmic->regmap_pmic)) {
	423	ret = PTR_ERR(sec_pmic->regmap_pmic);
0f5f7078	424	dev_err(&i2c->dev, "Failed to allocate register map: %d\n",
61a2af30	425	ret);
1092e1c7	426	return ret;
0f5f7078 SK	427	}
0f5f7078 SK	428
c3ebb30a	429	if (pdata && pdata->cfg_pmic_irq)
0f5f7078 SK	430	pdata->cfg_pmic_irq();
0f5f7078 SK	431
63063bfb	432	sec_irq_init(sec_pmic);
0f5f7078	433
63063bfb	434	pm_runtime_set_active(sec_pmic->dev);
0f5f7078	435
63063bfb	436	switch (sec_pmic->device_type) {
88a1cfd6	437	case S5M8751X:
54e8827d CC	438	sec_devs = s5m8751_devs;
54e8827d CC	439	num_sec_devs = ARRAY_SIZE(s5m8751_devs);
88a1cfd6 SK	440	break;
88a1cfd6 SK	441	case S5M8763X:
54e8827d CC	442	sec_devs = s5m8763_devs;
54e8827d CC	443	num_sec_devs = ARRAY_SIZE(s5m8763_devs);
88a1cfd6 SK	444	break;
88a1cfd6 SK	445	case S5M8767X:
54e8827d CC	446	sec_devs = s5m8767_devs;
54e8827d CC	447	num_sec_devs = ARRAY_SIZE(s5m8767_devs);
88a1cfd6	448	break;
ce24991e	449	case S2MPA01:
54e8827d CC	450	sec_devs = s2mpa01_devs;
54e8827d CC	451	num_sec_devs = ARRAY_SIZE(s2mpa01_devs);
ce24991e	452	break;
9b6d1343	453	case S2MPS11X:
54e8827d CC	454	sec_devs = s2mps11_devs;
54e8827d CC	455	num_sec_devs = ARRAY_SIZE(s2mps11_devs);
9b6d1343	456	break;
3bc2ee91 CC	457	case S2MPS13X:
	458	sec_devs = s2mps13_devs;
	459	num_sec_devs = ARRAY_SIZE(s2mps13_devs);
	460	break;
dc691966	461	case S2MPS14X:
54e8827d CC	462	sec_devs = s2mps14_devs;
	463	num_sec_devs = ARRAY_SIZE(s2mps14_devs);
	464	break;
9e4808d2 TA	465	case S2MPS15X:
	466	sec_devs = s2mps15_devs;
	467	num_sec_devs = ARRAY_SIZE(s2mps15_devs);
	468	break;
54e8827d CC	469	case S2MPU02:
	470	sec_devs = s2mpu02_devs;
	471	num_sec_devs = ARRAY_SIZE(s2mpu02_devs);
dc691966	472	break;
88a1cfd6 SK	473	default:
	474	/* If this happens the probe function is problem */
	475	BUG();
	476	}
3dc6f4aa LD	477	ret = devm_mfd_add_devices(sec_pmic->dev, -1, sec_devs, num_sec_devs,
3dc6f4aa LD	478	NULL, 0, NULL);
15447a46	479	if (ret)
3dc6f4aa	480	return ret;
0f5f7078	481
f6d6daaf	482	device_init_wakeup(sec_pmic->dev, sec_pmic->wakeup);
8a97d428	483	sec_pmic_configure(sec_pmic);
c2c9f1fe	484	sec_pmic_dump_rev(sec_pmic);
f6d6daaf	485
0f5f7078	486	return ret;
0f5f7078 SK	487	}
0f5f7078 SK	488
d785334a KK	489	static void sec_pmic_shutdown(struct i2c_client *i2c)
	490	{
	491	struct sec_pmic_dev *sec_pmic = i2c_get_clientdata(i2c);
	492	unsigned int reg, mask;
	493
	494	if (!sec_pmic->pdata->manual_poweroff)
	495	return;
	496
	497	switch (sec_pmic->device_type) {
	498	case S2MPS11X:
	499	reg = S2MPS11_REG_CTRL1;
	500	mask = S2MPS11_CTRL1_PWRHOLD_MASK;
	501	break;
	502	default:
	503	/*
	504	* Currently only one board with S2MPS11 needs this, so just
	505	* ignore the rest.
	506	*/
	507	dev_warn(sec_pmic->dev,
	508	"Unsupported device %lu for manual power off\n",
	509	sec_pmic->device_type);
	510	return;
	511	}
	512
	513	regmap_update_bits(sec_pmic->regmap_pmic, reg, mask, 0);
	514	}
	515
8321bbf8	516	#ifdef CONFIG_PM_SLEEP
f6d6daaf KK	517	static int sec_pmic_suspend(struct device *dev)
f6d6daaf KK	518	{
1b5420e1	519	struct i2c_client *i2c = to_i2c_client(dev);
f6d6daaf KK	520	struct sec_pmic_dev *sec_pmic = i2c_get_clientdata(i2c);
f6d6daaf KK	521
360d15d6	522	if (device_may_wakeup(dev))
f6d6daaf	523	enable_irq_wake(sec_pmic->irq);
360d15d6 KK	524	/*
	525	* PMIC IRQ must be disabled during suspend for RTC alarm
	526	* to work properly.
	527	* When device is woken up from suspend, an
	528	* interrupt occurs before resuming I2C bus controller.
	529	* The interrupt is handled by regmap_irq_thread which tries
	530	* to read RTC registers. This read fails (I2C is still
	531	* suspended) and RTC Alarm interrupt is disabled.
	532	*/
	533	disable_irq(sec_pmic->irq);
f6d6daaf KK	534
	535	return 0;
	536	}
	537
	538	static int sec_pmic_resume(struct device *dev)
	539	{
1b5420e1	540	struct i2c_client *i2c = to_i2c_client(dev);
f6d6daaf KK	541	struct sec_pmic_dev *sec_pmic = i2c_get_clientdata(i2c);
f6d6daaf KK	542
360d15d6	543	if (device_may_wakeup(dev))
f6d6daaf	544	disable_irq_wake(sec_pmic->irq);
360d15d6	545	enable_irq(sec_pmic->irq);
f6d6daaf KK	546
	547	return 0;
	548	}
8321bbf8	549	#endif /* CONFIG_PM_SLEEP */
f6d6daaf KK	550
	551	static SIMPLE_DEV_PM_OPS(sec_pmic_pm_ops, sec_pmic_suspend, sec_pmic_resume);
	552
63063bfb SK	553	static const struct i2c_device_id sec_pmic_id[] = {
63063bfb SK	554	{ "sec_pmic", 0 },
0f5f7078 SK	555	{ }
0f5f7078 SK	556	};
63063bfb	557	MODULE_DEVICE_TABLE(i2c, sec_pmic_id);
0f5f7078	558
63063bfb	559	static struct i2c_driver sec_pmic_driver = {
0f5f7078	560	.driver = {
63063bfb	561	.name = "sec_pmic",
f6d6daaf	562	.pm = &sec_pmic_pm_ops,
26aec009	563	.of_match_table = of_match_ptr(sec_dt_match),
0f5f7078	564	},
63063bfb	565	.probe = sec_pmic_probe,
d785334a	566	.shutdown = sec_pmic_shutdown,
63063bfb	567	.id_table = sec_pmic_id,
0f5f7078 SK	568	};
0f5f7078 SK	569
63063bfb	570	static int __init sec_pmic_init(void)
0f5f7078	571	{
63063bfb	572	return i2c_add_driver(&sec_pmic_driver);
0f5f7078 SK	573	}
0f5f7078 SK	574
63063bfb	575	subsys_initcall(sec_pmic_init);
0f5f7078	576
63063bfb	577	static void __exit sec_pmic_exit(void)
0f5f7078	578	{
63063bfb	579	i2c_del_driver(&sec_pmic_driver);
0f5f7078	580	}
63063bfb	581	module_exit(sec_pmic_exit);
0f5f7078 SK	582
	583	MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
	584	MODULE_DESCRIPTION("Core support for the S5M MFD");
	585	MODULE_LICENSE("GPL");