[linux-2.6-block.git] / drivers / hwmon / mc13783-adc.c

/*
 * Driver for the ADC on Freescale Semiconductor MC13783 and MC13892 PMICs.
 *
 * Copyright 2004-2007 Freescale Semiconductor, Inc. All Rights Reserved.
 * Copyright (C) 2009 Sascha Hauer, Pengutronix
 *
 * 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; either version 2
 * of the License, or (at your option) any later version.
 * 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.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 51
 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <linux/mfd/mc13xxx.h>
#include <linux/platform_device.h>
#include <linux/hwmon-sysfs.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/hwmon.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/err.h>

#define DRIVER_NAME	"mc13783-adc"

/* platform device id driver data */
#define MC13783_ADC_16CHANS	1
#define MC13783_ADC_BPDIV2	2

struct mc13783_adc_priv {
	struct mc13xxx *mc13xxx;
	struct device *hwmon_dev;
	char name[PLATFORM_NAME_SIZE];
};

static ssize_t mc13783_adc_show_name(struct device *dev, struct device_attribute
			      *devattr, char *buf)
{
	struct mc13783_adc_priv *priv = dev_get_drvdata(dev);

	return sprintf(buf, "%s\n", priv->name);
}

static int mc13783_adc_read(struct device *dev,
		struct device_attribute *devattr, unsigned int *val)
{
	struct mc13783_adc_priv *priv = dev_get_drvdata(dev);
	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
	unsigned int channel = attr->index;
	unsigned int sample[4];
	int ret;

	ret = mc13xxx_adc_do_conversion(priv->mc13xxx,
			MC13XXX_ADC_MODE_MULT_CHAN,
			channel, 0, 0, sample);
	if (ret)
		return ret;

	channel &= 0x7;

	*val = (sample[channel % 4] >> (channel > 3 ? 14 : 2)) & 0x3ff;

	return 0;
}

static ssize_t mc13783_adc_read_bp(struct device *dev,
		struct device_attribute *devattr, char *buf)
{
	unsigned val;
	struct platform_device *pdev = to_platform_device(dev);
	kernel_ulong_t driver_data = platform_get_device_id(pdev)->driver_data;
	int ret = mc13783_adc_read(dev, devattr, &val);

	if (ret)
		return ret;

	if (driver_data & MC13783_ADC_BPDIV2)
		val = DIV_ROUND_CLOSEST(val * 9, 2);
	else
		/*
		 * BP (channel 2) reports with offset 2.4V to the actual value
		 * to fit the input range of the ADC.  unit = 2.25mV = 9/4 mV.
		 */
		val = DIV_ROUND_CLOSEST(val * 9, 4) + 2400;

	return sprintf(buf, "%u\n", val);
}

static ssize_t mc13783_adc_read_gp(struct device *dev,
		struct device_attribute *devattr, char *buf)
{
	unsigned val;
	int ret = mc13783_adc_read(dev, devattr, &val);

	if (ret)
		return ret;

	/*
	 * input range is [0, 2.3V], val has 10 bits, so each bit
	 * is worth 9/4 mV.
	 */
	val = DIV_ROUND_CLOSEST(val * 9, 4);

	return sprintf(buf, "%u\n", val);
}

static DEVICE_ATTR(name, S_IRUGO, mc13783_adc_show_name, NULL);
static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, mc13783_adc_read_bp, NULL, 2);
static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, mc13783_adc_read_gp, NULL, 5);
static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, mc13783_adc_read_gp, NULL, 6);
static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, mc13783_adc_read_gp, NULL, 7);
static SENSOR_DEVICE_ATTR(in8_input, S_IRUGO, mc13783_adc_read_gp, NULL, 8);
static SENSOR_DEVICE_ATTR(in9_input, S_IRUGO, mc13783_adc_read_gp, NULL, 9);
static SENSOR_DEVICE_ATTR(in10_input, S_IRUGO, mc13783_adc_read_gp, NULL, 10);
static SENSOR_DEVICE_ATTR(in11_input, S_IRUGO, mc13783_adc_read_gp, NULL, 11);
static SENSOR_DEVICE_ATTR(in12_input, S_IRUGO, mc13783_adc_read_gp, NULL, 12);
static SENSOR_DEVICE_ATTR(in13_input, S_IRUGO, mc13783_adc_read_gp, NULL, 13);
static SENSOR_DEVICE_ATTR(in14_input, S_IRUGO, mc13783_adc_read_gp, NULL, 14);
static SENSOR_DEVICE_ATTR(in15_input, S_IRUGO, mc13783_adc_read_gp, NULL, 15);

static struct attribute *mc13783_attr_base[] = {
	&dev_attr_name.attr,
	&sensor_dev_attr_in2_input.dev_attr.attr,
	&sensor_dev_attr_in5_input.dev_attr.attr,
	&sensor_dev_attr_in6_input.dev_attr.attr,
	&sensor_dev_attr_in7_input.dev_attr.attr,
	NULL
};

static const struct attribute_group mc13783_group_base = {
	.attrs = mc13783_attr_base,
};

/* these are only used if MC13783_ADC_16CHANS is provided in driver data */
static struct attribute *mc13783_attr_16chans[] = {
	&sensor_dev_attr_in8_input.dev_attr.attr,
	&sensor_dev_attr_in9_input.dev_attr.attr,
	&sensor_dev_attr_in10_input.dev_attr.attr,
	&sensor_dev_attr_in11_input.dev_attr.attr,
	NULL
};

static const struct attribute_group mc13783_group_16chans = {
	.attrs = mc13783_attr_16chans,
};

/* last four channels may be occupied by the touchscreen */
static struct attribute *mc13783_attr_ts[] = {
	&sensor_dev_attr_in12_input.dev_attr.attr,
	&sensor_dev_attr_in13_input.dev_attr.attr,
	&sensor_dev_attr_in14_input.dev_attr.attr,
	&sensor_dev_attr_in15_input.dev_attr.attr,
	NULL
};

static const struct attribute_group mc13783_group_ts = {
	.attrs = mc13783_attr_ts,
};

static int mc13783_adc_use_touchscreen(struct platform_device *pdev)
{
	struct mc13783_adc_priv *priv = platform_get_drvdata(pdev);
	unsigned flags = mc13xxx_get_flags(priv->mc13xxx);

	return flags & MC13XXX_USE_TOUCHSCREEN;
}

static int __init mc13783_adc_probe(struct platform_device *pdev)
{
	struct mc13783_adc_priv *priv;
	int ret;
	const struct platform_device_id *id = platform_get_device_id(pdev);
	char *dash;

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

	priv->mc13xxx = dev_get_drvdata(pdev->dev.parent);
	snprintf(priv->name, ARRAY_SIZE(priv->name), "%s", id->name);
	dash = strchr(priv->name, '-');
	if (dash)
		*dash = '\0';

	platform_set_drvdata(pdev, priv);

	/* Register sysfs hooks */
	ret = sysfs_create_group(&pdev->dev.kobj, &mc13783_group_base);
	if (ret)
		return ret;

	if (id->driver_data & MC13783_ADC_16CHANS) {
		ret = sysfs_create_group(&pdev->dev.kobj,
				&mc13783_group_16chans);
		if (ret)
			goto out_err_create_16chans;
	}

	if (!mc13783_adc_use_touchscreen(pdev)) {
		ret = sysfs_create_group(&pdev->dev.kobj, &mc13783_group_ts);
		if (ret)
			goto out_err_create_ts;
	}

	priv->hwmon_dev = hwmon_device_register(&pdev->dev);
	if (IS_ERR(priv->hwmon_dev)) {
		ret = PTR_ERR(priv->hwmon_dev);
		dev_err(&pdev->dev,
				"hwmon_device_register failed with %d.\n", ret);
		goto out_err_register;
	}

	return 0;

out_err_register:

	if (!mc13783_adc_use_touchscreen(pdev))
		sysfs_remove_group(&pdev->dev.kobj, &mc13783_group_ts);
out_err_create_ts:

	if (id->driver_data & MC13783_ADC_16CHANS)
		sysfs_remove_group(&pdev->dev.kobj, &mc13783_group_16chans);
out_err_create_16chans:

	sysfs_remove_group(&pdev->dev.kobj, &mc13783_group_base);
	return ret;
}

static int mc13783_adc_remove(struct platform_device *pdev)
{
	struct mc13783_adc_priv *priv = platform_get_drvdata(pdev);
	kernel_ulong_t driver_data = platform_get_device_id(pdev)->driver_data;

	hwmon_device_unregister(priv->hwmon_dev);

	if (!mc13783_adc_use_touchscreen(pdev))
		sysfs_remove_group(&pdev->dev.kobj, &mc13783_group_ts);

	if (driver_data & MC13783_ADC_16CHANS)
		sysfs_remove_group(&pdev->dev.kobj, &mc13783_group_16chans);

	sysfs_remove_group(&pdev->dev.kobj, &mc13783_group_base);

	return 0;
}

static const struct platform_device_id mc13783_adc_idtable[] = {
	{
		.name = "mc13783-adc",
		.driver_data = MC13783_ADC_16CHANS,
	}, {
		.name = "mc13892-adc",
		.driver_data = MC13783_ADC_BPDIV2,
	}, {
		/* sentinel */
	}
};
MODULE_DEVICE_TABLE(platform, mc13783_adc_idtable);

static struct platform_driver mc13783_adc_driver = {
	.remove		= mc13783_adc_remove,
	.driver		= {
		.name	= DRIVER_NAME,
	},
	.id_table	= mc13783_adc_idtable,
};

module_platform_driver_probe(mc13783_adc_driver, mc13783_adc_probe);

MODULE_DESCRIPTION("MC13783 ADC driver");
MODULE_AUTHOR("Luotao Fu <l.fu@pengutronix.de>");
MODULE_LICENSE("GPL");
Commit	Line	Data
93ee0a75	1	/*
0c273215	2	* Driver for the ADC on Freescale Semiconductor MC13783 and MC13892 PMICs.
93ee0a75 LF	3	*
	4	* Copyright 2004-2007 Freescale Semiconductor, Inc. All Rights Reserved.
	5	* Copyright (C) 2009 Sascha Hauer, Pengutronix
	6	*
	7	* This program is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU General Public License
	9	* as published by the Free Software Foundation; either version 2
	10	* of the License, or (at your option) any later version.
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License along with
	17	* this program; if not, write to the Free Software Foundation, Inc., 51
	18	* Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	19	*/
	20
0c273215	21	#include <linux/mfd/mc13xxx.h>
93ee0a75 LF	22	#include <linux/platform_device.h>
	23	#include <linux/hwmon-sysfs.h>
	24	#include <linux/kernel.h>
	25	#include <linux/module.h>
	26	#include <linux/hwmon.h>
5a0e3ad6	27	#include <linux/slab.h>
93ee0a75 LF	28	#include <linux/init.h>
	29	#include <linux/err.h>
	30
0c273215 UKK	31	#define DRIVER_NAME "mc13783-adc"
	32
	33	/* platform device id driver data */
	34	#define MC13783_ADC_16CHANS 1
	35	#define MC13783_ADC_BPDIV2 2
93ee0a75 LF	36
93ee0a75 LF	37	struct mc13783_adc_priv {
613c27ab	38	struct mc13xxx *mc13xxx;
93ee0a75	39	struct device *hwmon_dev;
ae02e741	40	char name[PLATFORM_NAME_SIZE];
93ee0a75 LF	41	};
	42
	43	static ssize_t mc13783_adc_show_name(struct device *dev, struct device_attribute
	44	devattr, char buf)
	45	{
0c273215 UKK	46	struct mc13783_adc_priv *priv = dev_get_drvdata(dev);
	47
	48	return sprintf(buf, "%s\n", priv->name);
93ee0a75 LF	49	}
	50
	51	static int mc13783_adc_read(struct device *dev,
	52	struct device_attribute devattr, unsigned int val)
	53	{
0c273215	54	struct mc13783_adc_priv *priv = dev_get_drvdata(dev);
93ee0a75 LF	55	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
	56	unsigned int channel = attr->index;
	57	unsigned int sample[4];
	58	int ret;
	59
613c27ab UKK	60	ret = mc13xxx_adc_do_conversion(priv->mc13xxx,
613c27ab UKK	61	MC13XXX_ADC_MODE_MULT_CHAN,
1039d762	62	channel, 0, 0, sample);
93ee0a75 LF	63	if (ret)
	64	return ret;
	65
	66	channel &= 0x7;
	67
	68	*val = (sample[channel % 4] >> (channel > 3 ? 14 : 2)) & 0x3ff;
	69
	70	return 0;
	71	}
	72
	73	static ssize_t mc13783_adc_read_bp(struct device *dev,
	74	struct device_attribute devattr, char buf)
	75	{
	76	unsigned val;
0c273215 UKK	77	struct platform_device *pdev = to_platform_device(dev);
0c273215 UKK	78	kernel_ulong_t driver_data = platform_get_device_id(pdev)->driver_data;
93ee0a75 LF	79	int ret = mc13783_adc_read(dev, devattr, &val);
	80
	81	if (ret)
	82	return ret;
	83
0c273215 UKK	84	if (driver_data & MC13783_ADC_BPDIV2)
	85	val = DIV_ROUND_CLOSEST(val * 9, 2);
	86	else
	87	/*
	88	* BP (channel 2) reports with offset 2.4V to the actual value
	89	* to fit the input range of the ADC. unit = 2.25mV = 9/4 mV.
	90	*/
	91	val = DIV_ROUND_CLOSEST(val * 9, 4) + 2400;
93ee0a75 LF	92
	93	return sprintf(buf, "%u\n", val);
	94	}
	95
	96	static ssize_t mc13783_adc_read_gp(struct device *dev,
	97	struct device_attribute devattr, char buf)
	98	{
	99	unsigned val;
	100	int ret = mc13783_adc_read(dev, devattr, &val);
	101
	102	if (ret)
	103	return ret;
	104
	105	/*
	106	* input range is [0, 2.3V], val has 10 bits, so each bit
	107	* is worth 9/4 mV.
	108	*/
	109	val = DIV_ROUND_CLOSEST(val * 9, 4);
	110
	111	return sprintf(buf, "%u\n", val);
	112	}
	113
	114	static DEVICE_ATTR(name, S_IRUGO, mc13783_adc_show_name, NULL);
	115	static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, mc13783_adc_read_bp, NULL, 2);
	116	static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, mc13783_adc_read_gp, NULL, 5);
	117	static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, mc13783_adc_read_gp, NULL, 6);
	118	static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, mc13783_adc_read_gp, NULL, 7);
	119	static SENSOR_DEVICE_ATTR(in8_input, S_IRUGO, mc13783_adc_read_gp, NULL, 8);
	120	static SENSOR_DEVICE_ATTR(in9_input, S_IRUGO, mc13783_adc_read_gp, NULL, 9);
	121	static SENSOR_DEVICE_ATTR(in10_input, S_IRUGO, mc13783_adc_read_gp, NULL, 10);
	122	static SENSOR_DEVICE_ATTR(in11_input, S_IRUGO, mc13783_adc_read_gp, NULL, 11);
	123	static SENSOR_DEVICE_ATTR(in12_input, S_IRUGO, mc13783_adc_read_gp, NULL, 12);
	124	static SENSOR_DEVICE_ATTR(in13_input, S_IRUGO, mc13783_adc_read_gp, NULL, 13);
	125	static SENSOR_DEVICE_ATTR(in14_input, S_IRUGO, mc13783_adc_read_gp, NULL, 14);
	126	static SENSOR_DEVICE_ATTR(in15_input, S_IRUGO, mc13783_adc_read_gp, NULL, 15);
	127
0c273215	128	static struct attribute *mc13783_attr_base[] = {
93ee0a75 LF	129	&dev_attr_name.attr,
	130	&sensor_dev_attr_in2_input.dev_attr.attr,
	131	&sensor_dev_attr_in5_input.dev_attr.attr,
	132	&sensor_dev_attr_in6_input.dev_attr.attr,
	133	&sensor_dev_attr_in7_input.dev_attr.attr,
0c273215 UKK	134	NULL
	135	};
	136
	137	static const struct attribute_group mc13783_group_base = {
	138	.attrs = mc13783_attr_base,
	139	};
	140
	141	/* these are only used if MC13783_ADC_16CHANS is provided in driver data */
	142	static struct attribute *mc13783_attr_16chans[] = {
93ee0a75 LF	143	&sensor_dev_attr_in8_input.dev_attr.attr,
	144	&sensor_dev_attr_in9_input.dev_attr.attr,
	145	&sensor_dev_attr_in10_input.dev_attr.attr,
	146	&sensor_dev_attr_in11_input.dev_attr.attr,
	147	NULL
	148	};
	149
0c273215 UKK	150	static const struct attribute_group mc13783_group_16chans = {
0c273215 UKK	151	.attrs = mc13783_attr_16chans,
93ee0a75 LF	152	};
	153
	154	/* last four channels may be occupied by the touchscreen */
	155	static struct attribute *mc13783_attr_ts[] = {
	156	&sensor_dev_attr_in12_input.dev_attr.attr,
	157	&sensor_dev_attr_in13_input.dev_attr.attr,
	158	&sensor_dev_attr_in14_input.dev_attr.attr,
	159	&sensor_dev_attr_in15_input.dev_attr.attr,
	160	NULL
	161	};
	162
	163	static const struct attribute_group mc13783_group_ts = {
	164	.attrs = mc13783_attr_ts,
	165	};
	166
eaf06ee2 UKK	167	static int mc13783_adc_use_touchscreen(struct platform_device *pdev)
	168	{
	169	struct mc13783_adc_priv *priv = platform_get_drvdata(pdev);
613c27ab	170	unsigned flags = mc13xxx_get_flags(priv->mc13xxx);
eaf06ee2	171
613c27ab	172	return flags & MC13XXX_USE_TOUCHSCREEN;
eaf06ee2 UKK	173	}
eaf06ee2 UKK	174
93ee0a75 LF	175	static int __init mc13783_adc_probe(struct platform_device *pdev)
	176	{
	177	struct mc13783_adc_priv *priv;
	178	int ret;
0c273215 UKK	179	const struct platform_device_id *id = platform_get_device_id(pdev);
0c273215 UKK	180	char *dash;
93ee0a75	181
ed2e073b	182	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
93ee0a75 LF	183	if (!priv)
	184	return -ENOMEM;
	185
613c27ab	186	priv->mc13xxx = dev_get_drvdata(pdev->dev.parent);
0c273215 UKK	187	snprintf(priv->name, ARRAY_SIZE(priv->name), "%s", id->name);
	188	dash = strchr(priv->name, '-');
	189	if (dash)
	190	*dash = '\0';
93ee0a75 LF	191
	192	platform_set_drvdata(pdev, priv);
	193
	194	/* Register sysfs hooks */
0c273215	195	ret = sysfs_create_group(&pdev->dev.kobj, &mc13783_group_base);
93ee0a75	196	if (ret)
ed2e073b	197	return ret;
0c273215 UKK	198
	199	if (id->driver_data & MC13783_ADC_16CHANS) {
	200	ret = sysfs_create_group(&pdev->dev.kobj,
	201	&mc13783_group_16chans);
	202	if (ret)
	203	goto out_err_create_16chans;
	204	}
93ee0a75	205
eaf06ee2	206	if (!mc13783_adc_use_touchscreen(pdev)) {
93ee0a75 LF	207	ret = sysfs_create_group(&pdev->dev.kobj, &mc13783_group_ts);
93ee0a75 LF	208	if (ret)
0c273215	209	goto out_err_create_ts;
eaf06ee2	210	}
93ee0a75 LF	211
	212	priv->hwmon_dev = hwmon_device_register(&pdev->dev);
	213	if (IS_ERR(priv->hwmon_dev)) {
	214	ret = PTR_ERR(priv->hwmon_dev);
	215	dev_err(&pdev->dev,
	216	"hwmon_device_register failed with %d.\n", ret);
	217	goto out_err_register;
	218	}
	219
93ee0a75 LF	220	return 0;
	221
	222	out_err_register:
	223
eaf06ee2	224	if (!mc13783_adc_use_touchscreen(pdev))
93ee0a75	225	sysfs_remove_group(&pdev->dev.kobj, &mc13783_group_ts);
0c273215	226	out_err_create_ts:
93ee0a75	227
0c273215 UKK	228	if (id->driver_data & MC13783_ADC_16CHANS)
	229	sysfs_remove_group(&pdev->dev.kobj, &mc13783_group_16chans);
	230	out_err_create_16chans:
	231
	232	sysfs_remove_group(&pdev->dev.kobj, &mc13783_group_base);
93ee0a75 LF	233	return ret;
	234	}
	235
281dfd0b	236	static int mc13783_adc_remove(struct platform_device *pdev)
93ee0a75 LF	237	{
93ee0a75 LF	238	struct mc13783_adc_priv *priv = platform_get_drvdata(pdev);
0c273215	239	kernel_ulong_t driver_data = platform_get_device_id(pdev)->driver_data;
93ee0a75 LF	240
	241	hwmon_device_unregister(priv->hwmon_dev);
	242
eaf06ee2	243	if (!mc13783_adc_use_touchscreen(pdev))
93ee0a75 LF	244	sysfs_remove_group(&pdev->dev.kobj, &mc13783_group_ts);
93ee0a75 LF	245
0c273215 UKK	246	if (driver_data & MC13783_ADC_16CHANS)
	247	sysfs_remove_group(&pdev->dev.kobj, &mc13783_group_16chans);
	248
	249	sysfs_remove_group(&pdev->dev.kobj, &mc13783_group_base);
93ee0a75	250
93ee0a75 LF	251	return 0;
	252	}
	253
0c273215 UKK	254	static const struct platform_device_id mc13783_adc_idtable[] = {
	255	{
	256	.name = "mc13783-adc",
	257	.driver_data = MC13783_ADC_16CHANS,
	258	}, {
	259	.name = "mc13892-adc",
	260	.driver_data = MC13783_ADC_BPDIV2,
	261	}, {
	262	/* sentinel */
	263	}
	264	};
	265	MODULE_DEVICE_TABLE(platform, mc13783_adc_idtable);
	266
93ee0a75	267	static struct platform_driver mc13783_adc_driver = {
9e5e9b7a	268	.remove = mc13783_adc_remove,
93ee0a75	269	.driver = {
0c273215	270	.name = DRIVER_NAME,
93ee0a75	271	},
0c273215	272	.id_table = mc13783_adc_idtable,
93ee0a75 LF	273	};
93ee0a75 LF	274
f40fb63e	275	module_platform_driver_probe(mc13783_adc_driver, mc13783_adc_probe);
93ee0a75 LF	276
	277	MODULE_DESCRIPTION("MC13783 ADC driver");
	278	MODULE_AUTHOR("Luotao Fu <l.fu@pengutronix.de>");
	279	MODULE_LICENSE("GPL");