Commit a77fc111 authored by Linus Walleij's avatar Linus Walleij Committed by Jonathan Cameron
Browse files

mfd: Switch the AB8500 GPADC to IIO 



The AB8500 GPADC driver is indeed a "general purpose ADC" driver,
and while the IIO subsystem did not exist when the driver was
first merged, it is never too late to clean things up and move it
to the right place.

Nowadays IIO provides the right abstractions and interfaces to
do generic ADC work in the kernel.

We have to cut a bunch of debugfs luggage to make this transition
swift, but all these files to is read out the raw values of the
ADC and the IIO subsystem already has a standard sysfs ABI for
doing exactly this: no debugfs is needed.

Acked-by: default avatarLee Jones <lee.jones@linaro.org>
Signed-off-by: default avatarLinus Walleij <linus.walleij@linaro.org>
Signed-off-by: default avatarJonathan Cameron <Jonathan.Cameron@huawei.com>
parent 07063bbf

drivers/mfd/Kconfig

+0 −7
Original line number Diff line number Diff line
@@ -1210,13 +1210,6 @@ config AB8500_DEBUG 
	  Select this option if you want debug information using the debug

	  filesystem, debugfs.



config AB8500_GPADC

	bool "ST-Ericsson AB8500 GPADC driver"

	depends on AB8500_CORE && REGULATOR_AB8500

	default y

	help

	  AB8500 GPADC driver used to convert Acc and battery/ac/usb voltage



config MFD_DB8500_PRCMU

	bool "ST-Ericsson DB8500 Power Reset Control Management Unit"

	depends on UX500_SOC_DB8500

drivers/mfd/Makefile

+0 −1
Original line number Diff line number Diff line
@@ -177,7 +177,6 @@ obj-$(CONFIG_ABX500_CORE) += abx500-core.o 
obj-$(CONFIG_AB3100_CORE)	+= ab3100-core.o

obj-$(CONFIG_AB3100_OTP)	+= ab3100-otp.o

obj-$(CONFIG_AB8500_DEBUG)	+= ab8500-debugfs.o

obj-$(CONFIG_AB8500_GPADC)	+= ab8500-gpadc.o

obj-$(CONFIG_MFD_DB8500_PRCMU)	+= db8500-prcmu.o

# ab8500-core need to come after db8500-prcmu (which provides the channel)

obj-$(CONFIG_AB8500_CORE)	+= ab8500-core.o ab8500-sysctrl.o

drivers/mfd/ab8500-debugfs.c

+0 −715
Original line number Diff line number Diff line
@@ -84,7 +84,6 @@ 


#include <linux/mfd/abx500.h>

#include <linux/mfd/abx500/ab8500.h>

#include <linux/mfd/abx500/ab8500-gpadc.h>



#ifdef CONFIG_DEBUG_FS

#include <linux/string.h>
@@ -103,11 +102,6 @@ static int num_irqs; 
static struct device_attribute **dev_attr;

static char **event_name;



static u8 avg_sample = SAMPLE_16;

static u8 trig_edge = RISING_EDGE;

static u8 conv_type = ADC_SW;

static u8 trig_timer;



/**

 * struct ab8500_reg_range

 * @first: the first address of the range
@@ -152,7 +146,6 @@ static struct hwreg_cfg hwreg_cfg = { 
};



#define AB8500_NAME_STRING "ab8500"

#define AB8500_ADC_NAME_STRING "gpadc"

#define AB8500_NUM_BANKS AB8500_DEBUG_FIELD_LAST



#define AB8500_REV_REG 0x80
@@ -1646,633 +1639,6 @@ report_write_failure: 


DEFINE_SHOW_ATTRIBUTE(ab8500_modem);



static int ab8500_gpadc_bat_ctrl_show(struct seq_file *s, void *p)

{

	int bat_ctrl_raw;

	int bat_ctrl_convert;

	struct ab8500_gpadc *gpadc;



	gpadc = ab8500_gpadc_get("ab8500-gpadc.0");

	bat_ctrl_raw = ab8500_gpadc_read_raw(gpadc, BAT_CTRL,

		avg_sample, trig_edge, trig_timer, conv_type);

	bat_ctrl_convert = ab8500_gpadc_ad_to_voltage(gpadc,

		BAT_CTRL, bat_ctrl_raw);



	seq_printf(s, "%d,0x%X\n", bat_ctrl_convert, bat_ctrl_raw);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_bat_ctrl);



static int ab8500_gpadc_btemp_ball_show(struct seq_file *s, void *p)

{

	int btemp_ball_raw;

	int btemp_ball_convert;

	struct ab8500_gpadc *gpadc;



	gpadc = ab8500_gpadc_get("ab8500-gpadc.0");

	btemp_ball_raw = ab8500_gpadc_read_raw(gpadc, BTEMP_BALL,

		avg_sample, trig_edge, trig_timer, conv_type);

	btemp_ball_convert = ab8500_gpadc_ad_to_voltage(gpadc, BTEMP_BALL,

		btemp_ball_raw);



	seq_printf(s, "%d,0x%X\n", btemp_ball_convert, btemp_ball_raw);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_btemp_ball);



static int ab8500_gpadc_main_charger_v_show(struct seq_file *s, void *p)

{

	int main_charger_v_raw;

	int main_charger_v_convert;

	struct ab8500_gpadc *gpadc;



	gpadc = ab8500_gpadc_get("ab8500-gpadc.0");

	main_charger_v_raw = ab8500_gpadc_read_raw(gpadc, MAIN_CHARGER_V,

		avg_sample, trig_edge, trig_timer, conv_type);

	main_charger_v_convert = ab8500_gpadc_ad_to_voltage(gpadc,

		MAIN_CHARGER_V, main_charger_v_raw);



	seq_printf(s, "%d,0x%X\n", main_charger_v_convert, main_charger_v_raw);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_main_charger_v);



static int ab8500_gpadc_acc_detect1_show(struct seq_file *s, void *p)

{

	int acc_detect1_raw;

	int acc_detect1_convert;

	struct ab8500_gpadc *gpadc;



	gpadc = ab8500_gpadc_get("ab8500-gpadc.0");

	acc_detect1_raw = ab8500_gpadc_read_raw(gpadc, ACC_DETECT1,

		avg_sample, trig_edge, trig_timer, conv_type);

	acc_detect1_convert = ab8500_gpadc_ad_to_voltage(gpadc, ACC_DETECT1,

		acc_detect1_raw);



	seq_printf(s, "%d,0x%X\n", acc_detect1_convert, acc_detect1_raw);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_acc_detect1);



static int ab8500_gpadc_acc_detect2_show(struct seq_file *s, void *p)

{

	int acc_detect2_raw;

	int acc_detect2_convert;

	struct ab8500_gpadc *gpadc;



	gpadc = ab8500_gpadc_get("ab8500-gpadc.0");

	acc_detect2_raw = ab8500_gpadc_read_raw(gpadc, ACC_DETECT2,

		avg_sample, trig_edge, trig_timer, conv_type);

	acc_detect2_convert = ab8500_gpadc_ad_to_voltage(gpadc,

		ACC_DETECT2, acc_detect2_raw);



	seq_printf(s, "%d,0x%X\n", acc_detect2_convert, acc_detect2_raw);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_acc_detect2);



static int ab8500_gpadc_aux1_show(struct seq_file *s, void *p)

{

	int aux1_raw;

	int aux1_convert;

	struct ab8500_gpadc *gpadc;



	gpadc = ab8500_gpadc_get("ab8500-gpadc.0");

	aux1_raw = ab8500_gpadc_read_raw(gpadc, ADC_AUX1,

		avg_sample, trig_edge, trig_timer, conv_type);

	aux1_convert = ab8500_gpadc_ad_to_voltage(gpadc, ADC_AUX1,

		aux1_raw);



	seq_printf(s, "%d,0x%X\n", aux1_convert, aux1_raw);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_aux1);



static int ab8500_gpadc_aux2_show(struct seq_file *s, void *p)

{

	int aux2_raw;

	int aux2_convert;

	struct ab8500_gpadc *gpadc;



	gpadc = ab8500_gpadc_get("ab8500-gpadc.0");

	aux2_raw = ab8500_gpadc_read_raw(gpadc, ADC_AUX2,

		avg_sample, trig_edge, trig_timer, conv_type);

	aux2_convert = ab8500_gpadc_ad_to_voltage(gpadc, ADC_AUX2,

		aux2_raw);



	seq_printf(s, "%d,0x%X\n", aux2_convert, aux2_raw);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_aux2);



static int ab8500_gpadc_main_bat_v_show(struct seq_file *s, void *p)

{

	int main_bat_v_raw;

	int main_bat_v_convert;

	struct ab8500_gpadc *gpadc;



	gpadc = ab8500_gpadc_get("ab8500-gpadc.0");

	main_bat_v_raw = ab8500_gpadc_read_raw(gpadc, MAIN_BAT_V,

		avg_sample, trig_edge, trig_timer, conv_type);

	main_bat_v_convert = ab8500_gpadc_ad_to_voltage(gpadc, MAIN_BAT_V,

		main_bat_v_raw);



	seq_printf(s, "%d,0x%X\n", main_bat_v_convert, main_bat_v_raw);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_main_bat_v);



static int ab8500_gpadc_vbus_v_show(struct seq_file *s, void *p)

{

	int vbus_v_raw;

	int vbus_v_convert;

	struct ab8500_gpadc *gpadc;



	gpadc = ab8500_gpadc_get("ab8500-gpadc.0");

	vbus_v_raw =  ab8500_gpadc_read_raw(gpadc, VBUS_V,

		avg_sample, trig_edge, trig_timer, conv_type);

	vbus_v_convert = ab8500_gpadc_ad_to_voltage(gpadc, VBUS_V,

		vbus_v_raw);



	seq_printf(s, "%d,0x%X\n", vbus_v_convert, vbus_v_raw);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_vbus_v);



static int ab8500_gpadc_main_charger_c_show(struct seq_file *s, void *p)

{

	int main_charger_c_raw;

	int main_charger_c_convert;

	struct ab8500_gpadc *gpadc;



	gpadc = ab8500_gpadc_get("ab8500-gpadc.0");

	main_charger_c_raw = ab8500_gpadc_read_raw(gpadc, MAIN_CHARGER_C,

		avg_sample, trig_edge, trig_timer, conv_type);

	main_charger_c_convert = ab8500_gpadc_ad_to_voltage(gpadc,

		MAIN_CHARGER_C, main_charger_c_raw);



	seq_printf(s, "%d,0x%X\n", main_charger_c_convert, main_charger_c_raw);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_main_charger_c);



static int ab8500_gpadc_usb_charger_c_show(struct seq_file *s, void *p)

{

	int usb_charger_c_raw;

	int usb_charger_c_convert;

	struct ab8500_gpadc *gpadc;



	gpadc = ab8500_gpadc_get("ab8500-gpadc.0");

	usb_charger_c_raw = ab8500_gpadc_read_raw(gpadc, USB_CHARGER_C,

		avg_sample, trig_edge, trig_timer, conv_type);

	usb_charger_c_convert = ab8500_gpadc_ad_to_voltage(gpadc,

		USB_CHARGER_C, usb_charger_c_raw);



	seq_printf(s, "%d,0x%X\n", usb_charger_c_convert, usb_charger_c_raw);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_usb_charger_c);



static int ab8500_gpadc_bk_bat_v_show(struct seq_file *s, void *p)

{

	int bk_bat_v_raw;

	int bk_bat_v_convert;

	struct ab8500_gpadc *gpadc;



	gpadc = ab8500_gpadc_get("ab8500-gpadc.0");

	bk_bat_v_raw = ab8500_gpadc_read_raw(gpadc, BK_BAT_V,

		avg_sample, trig_edge, trig_timer, conv_type);

	bk_bat_v_convert = ab8500_gpadc_ad_to_voltage(gpadc,

		BK_BAT_V, bk_bat_v_raw);



	seq_printf(s, "%d,0x%X\n", bk_bat_v_convert, bk_bat_v_raw);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_bk_bat_v);



static int ab8500_gpadc_die_temp_show(struct seq_file *s, void *p)

{

	int die_temp_raw;

	int die_temp_convert;

	struct ab8500_gpadc *gpadc;



	gpadc = ab8500_gpadc_get("ab8500-gpadc.0");

	die_temp_raw = ab8500_gpadc_read_raw(gpadc, DIE_TEMP,

		avg_sample, trig_edge, trig_timer, conv_type);

	die_temp_convert = ab8500_gpadc_ad_to_voltage(gpadc, DIE_TEMP,

		die_temp_raw);



	seq_printf(s, "%d,0x%X\n", die_temp_convert, die_temp_raw);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_die_temp);



static int ab8500_gpadc_usb_id_show(struct seq_file *s, void *p)

{

	int usb_id_raw;

	int usb_id_convert;

	struct ab8500_gpadc *gpadc;



	gpadc = ab8500_gpadc_get("ab8500-gpadc.0");

	usb_id_raw = ab8500_gpadc_read_raw(gpadc, USB_ID,

		avg_sample, trig_edge, trig_timer, conv_type);

	usb_id_convert = ab8500_gpadc_ad_to_voltage(gpadc, USB_ID,

		usb_id_raw);



	seq_printf(s, "%d,0x%X\n", usb_id_convert, usb_id_raw);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_usb_id);



static int ab8540_gpadc_xtal_temp_show(struct seq_file *s, void *p)

{

	int xtal_temp_raw;

	int xtal_temp_convert;

	struct ab8500_gpadc *gpadc;



	gpadc = ab8500_gpadc_get("ab8500-gpadc.0");

	xtal_temp_raw = ab8500_gpadc_read_raw(gpadc, XTAL_TEMP,

		avg_sample, trig_edge, trig_timer, conv_type);

	xtal_temp_convert = ab8500_gpadc_ad_to_voltage(gpadc, XTAL_TEMP,

		xtal_temp_raw);



	seq_printf(s, "%d,0x%X\n", xtal_temp_convert, xtal_temp_raw);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_xtal_temp);



static int ab8540_gpadc_vbat_true_meas_show(struct seq_file *s, void *p)

{

	int vbat_true_meas_raw;

	int vbat_true_meas_convert;

	struct ab8500_gpadc *gpadc;



	gpadc = ab8500_gpadc_get("ab8500-gpadc.0");

	vbat_true_meas_raw = ab8500_gpadc_read_raw(gpadc, VBAT_TRUE_MEAS,

		avg_sample, trig_edge, trig_timer, conv_type);

	vbat_true_meas_convert =

		ab8500_gpadc_ad_to_voltage(gpadc, VBAT_TRUE_MEAS,

					   vbat_true_meas_raw);



	seq_printf(s, "%d,0x%X\n", vbat_true_meas_convert, vbat_true_meas_raw);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_vbat_true_meas);



static int ab8540_gpadc_bat_ctrl_and_ibat_show(struct seq_file *s, void *p)

{

	int bat_ctrl_raw;

	int bat_ctrl_convert;

	int ibat_raw;

	int ibat_convert;

	struct ab8500_gpadc *gpadc;



	gpadc = ab8500_gpadc_get("ab8500-gpadc.0");

	bat_ctrl_raw = ab8500_gpadc_double_read_raw(gpadc, BAT_CTRL_AND_IBAT,

		avg_sample, trig_edge, trig_timer, conv_type, &ibat_raw);



	bat_ctrl_convert = ab8500_gpadc_ad_to_voltage(gpadc, BAT_CTRL,

		bat_ctrl_raw);

	ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,

		ibat_raw);



	seq_printf(s,

		   "%d,0x%X\n"

		   "%d,0x%X\n",

		   bat_ctrl_convert, bat_ctrl_raw,

		   ibat_convert, ibat_raw);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_bat_ctrl_and_ibat);



static int ab8540_gpadc_vbat_meas_and_ibat_show(struct seq_file *s, void *p)

{

	int vbat_meas_raw;

	int vbat_meas_convert;

	int ibat_raw;

	int ibat_convert;

	struct ab8500_gpadc *gpadc;



	gpadc = ab8500_gpadc_get("ab8500-gpadc.0");

	vbat_meas_raw = ab8500_gpadc_double_read_raw(gpadc, VBAT_MEAS_AND_IBAT,

		avg_sample, trig_edge, trig_timer, conv_type, &ibat_raw);

	vbat_meas_convert = ab8500_gpadc_ad_to_voltage(gpadc, MAIN_BAT_V,

		vbat_meas_raw);

	ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,

		ibat_raw);



	seq_printf(s,

		   "%d,0x%X\n"

		   "%d,0x%X\n",

		   vbat_meas_convert, vbat_meas_raw,

		   ibat_convert, ibat_raw);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_vbat_meas_and_ibat);



static int ab8540_gpadc_vbat_true_meas_and_ibat_show(struct seq_file *s, void *p)

{

	int vbat_true_meas_raw;

	int vbat_true_meas_convert;

	int ibat_raw;

	int ibat_convert;

	struct ab8500_gpadc *gpadc;



	gpadc = ab8500_gpadc_get("ab8500-gpadc.0");

	vbat_true_meas_raw = ab8500_gpadc_double_read_raw(gpadc,

			VBAT_TRUE_MEAS_AND_IBAT, avg_sample, trig_edge,

			trig_timer, conv_type, &ibat_raw);

	vbat_true_meas_convert = ab8500_gpadc_ad_to_voltage(gpadc,

			VBAT_TRUE_MEAS, vbat_true_meas_raw);

	ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,

		ibat_raw);



	seq_printf(s,

		   "%d,0x%X\n"

		   "%d,0x%X\n",

		   vbat_true_meas_convert, vbat_true_meas_raw,

		   ibat_convert, ibat_raw);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_vbat_true_meas_and_ibat);



static int ab8540_gpadc_bat_temp_and_ibat_show(struct seq_file *s, void *p)

{

	int bat_temp_raw;

	int bat_temp_convert;

	int ibat_raw;

	int ibat_convert;

	struct ab8500_gpadc *gpadc;



	gpadc = ab8500_gpadc_get("ab8500-gpadc.0");

	bat_temp_raw = ab8500_gpadc_double_read_raw(gpadc, BAT_TEMP_AND_IBAT,

		avg_sample, trig_edge, trig_timer, conv_type, &ibat_raw);

	bat_temp_convert = ab8500_gpadc_ad_to_voltage(gpadc, BTEMP_BALL,

		bat_temp_raw);

	ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,

		ibat_raw);



	seq_printf(s,

		   "%d,0x%X\n"

		   "%d,0x%X\n",

		   bat_temp_convert, bat_temp_raw,

		   ibat_convert, ibat_raw);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_bat_temp_and_ibat);



static int ab8540_gpadc_otp_calib_show(struct seq_file *s, void *p)

{

	struct ab8500_gpadc *gpadc;

	u16 vmain_l, vmain_h, btemp_l, btemp_h;

	u16 vbat_l, vbat_h, ibat_l, ibat_h;



	gpadc = ab8500_gpadc_get("ab8500-gpadc.0");

	ab8540_gpadc_get_otp(gpadc, &vmain_l, &vmain_h, &btemp_l, &btemp_h,

			&vbat_l, &vbat_h, &ibat_l, &ibat_h);

	seq_printf(s,

		   "VMAIN_L:0x%X\n"

		   "VMAIN_H:0x%X\n"

		   "BTEMP_L:0x%X\n"

		   "BTEMP_H:0x%X\n"

		   "VBAT_L:0x%X\n"

		   "VBAT_H:0x%X\n"

		   "IBAT_L:0x%X\n"

		   "IBAT_H:0x%X\n",

		   vmain_l, vmain_h, btemp_l, btemp_h,

		   vbat_l, vbat_h, ibat_l, ibat_h);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_otp_calib);



static int ab8500_gpadc_avg_sample_print(struct seq_file *s, void *p)

{

	seq_printf(s, "%d\n", avg_sample);



	return 0;

}



static int ab8500_gpadc_avg_sample_open(struct inode *inode, struct file *file)

{

	return single_open(file, ab8500_gpadc_avg_sample_print,

		inode->i_private);

}



static ssize_t ab8500_gpadc_avg_sample_write(struct file *file,

	const char __user *user_buf,

	size_t count, loff_t *ppos)

{

	struct device *dev = ((struct seq_file *)(file->private_data))->private;

	unsigned long user_avg_sample;

	int err;



	err = kstrtoul_from_user(user_buf, count, 0, &user_avg_sample);

	if (err)

		return err;



	if ((user_avg_sample == SAMPLE_1) || (user_avg_sample == SAMPLE_4)

			|| (user_avg_sample == SAMPLE_8)

			|| (user_avg_sample == SAMPLE_16)) {

		avg_sample = (u8) user_avg_sample;

	} else {

		dev_err(dev,

			"debugfs err input: should be egal to 1, 4, 8 or 16\n");

		return -EINVAL;

	}



	return count;

}



static const struct file_operations ab8500_gpadc_avg_sample_fops = {

	.open = ab8500_gpadc_avg_sample_open,

	.read = seq_read,

	.write = ab8500_gpadc_avg_sample_write,

	.llseek = seq_lseek,

	.release = single_release,

	.owner = THIS_MODULE,

};



static int ab8500_gpadc_trig_edge_print(struct seq_file *s, void *p)

{

	seq_printf(s, "%d\n", trig_edge);



	return 0;

}



static int ab8500_gpadc_trig_edge_open(struct inode *inode, struct file *file)

{

	return single_open(file, ab8500_gpadc_trig_edge_print,

		inode->i_private);

}



static ssize_t ab8500_gpadc_trig_edge_write(struct file *file,

	const char __user *user_buf,

	size_t count, loff_t *ppos)

{

	struct device *dev = ((struct seq_file *)(file->private_data))->private;

	unsigned long user_trig_edge;

	int err;



	err = kstrtoul_from_user(user_buf, count, 0, &user_trig_edge);

	if (err)

		return err;



	if ((user_trig_edge == RISING_EDGE)

			|| (user_trig_edge == FALLING_EDGE)) {

		trig_edge = (u8) user_trig_edge;

	} else {

		dev_err(dev, "Wrong input:\n"

			"Enter 0. Rising edge\n"

			"Enter 1. Falling edge\n");

		return -EINVAL;

	}



	return count;

}



static const struct file_operations ab8500_gpadc_trig_edge_fops = {

	.open = ab8500_gpadc_trig_edge_open,

	.read = seq_read,

	.write = ab8500_gpadc_trig_edge_write,

	.llseek = seq_lseek,

	.release = single_release,

	.owner = THIS_MODULE,

};



static int ab8500_gpadc_trig_timer_print(struct seq_file *s, void *p)

{

	seq_printf(s, "%d\n", trig_timer);



	return 0;

}



static int ab8500_gpadc_trig_timer_open(struct inode *inode, struct file *file)

{

	return single_open(file, ab8500_gpadc_trig_timer_print,

		inode->i_private);

}



static ssize_t ab8500_gpadc_trig_timer_write(struct file *file,

	const char __user *user_buf,

	size_t count, loff_t *ppos)

{

	struct device *dev = ((struct seq_file *)(file->private_data))->private;

	unsigned long user_trig_timer;

	int err;



	err = kstrtoul_from_user(user_buf, count, 0, &user_trig_timer);

	if (err)

		return err;



	if (user_trig_timer & ~0xFF) {

		dev_err(dev,

			"debugfs error input: should be between 0 to 255\n");

		return -EINVAL;

	}



	trig_timer = (u8) user_trig_timer;



	return count;

}



static const struct file_operations ab8500_gpadc_trig_timer_fops = {

	.open = ab8500_gpadc_trig_timer_open,

	.read = seq_read,

	.write = ab8500_gpadc_trig_timer_write,

	.llseek = seq_lseek,

	.release = single_release,

	.owner = THIS_MODULE,

};



static int ab8500_gpadc_conv_type_print(struct seq_file *s, void *p)

{

	seq_printf(s, "%d\n", conv_type);



	return 0;

}



static int ab8500_gpadc_conv_type_open(struct inode *inode, struct file *file)

{

	return single_open(file, ab8500_gpadc_conv_type_print,

		inode->i_private);

}



static ssize_t ab8500_gpadc_conv_type_write(struct file *file,

	const char __user *user_buf,

	size_t count, loff_t *ppos)

{

	struct device *dev = ((struct seq_file *)(file->private_data))->private;

	unsigned long user_conv_type;

	int err;



	err = kstrtoul_from_user(user_buf, count, 0, &user_conv_type);

	if (err)

		return err;



	if ((user_conv_type == ADC_SW)

			|| (user_conv_type == ADC_HW)) {

		conv_type = (u8) user_conv_type;

	} else {

		dev_err(dev, "Wrong input:\n"

			"Enter 0. ADC SW conversion\n"

			"Enter 1. ADC HW conversion\n");

		return -EINVAL;

	}



	return count;

}



static const struct file_operations ab8500_gpadc_conv_type_fops = {

	.open = ab8500_gpadc_conv_type_open,

	.read = seq_read,

	.write = ab8500_gpadc_conv_type_write,

	.llseek = seq_lseek,

	.release = single_release,

	.owner = THIS_MODULE,

};



/*

 * return length of an ASCII numerical value, 0 is string is not a

 * numerical value.
@@ -2647,7 +2013,6 @@ static const struct file_operations ab8500_hwreg_fops = { 
static int ab8500_debug_probe(struct platform_device *plf)

{

	struct dentry *ab8500_dir;

	struct dentry *ab8500_gpadc_dir;

	struct ab8500 *ab8500;

	struct resource *res;
@@ -2689,9 +2054,6 @@ static int ab8500_debug_probe(struct platform_device *plf) 


	ab8500_dir = debugfs_create_dir(AB8500_NAME_STRING, NULL);



	ab8500_gpadc_dir = debugfs_create_dir(AB8500_ADC_NAME_STRING,

					      ab8500_dir);



	debugfs_create_file("all-bank-registers", S_IRUGO, ab8500_dir,

			    &plf->dev, &ab8500_bank_registers_fops);

	debugfs_create_file("all-banks", S_IRUGO, ab8500_dir,
@@ -2727,83 +2089,6 @@ static int ab8500_debug_probe(struct platform_device *plf) 
			    &plf->dev, &ab8500_hwreg_fops);

	debugfs_create_file("all-modem-registers", (S_IRUGO | S_IWUSR | S_IWGRP),

			    ab8500_dir, &plf->dev, &ab8500_modem_fops);

	debugfs_create_file("bat_ctrl", (S_IRUGO | S_IWUSR | S_IWGRP),

			    ab8500_gpadc_dir, &plf->dev,

			    &ab8500_gpadc_bat_ctrl_fops);

	debugfs_create_file("btemp_ball", (S_IRUGO | S_IWUSR | S_IWGRP),

			    ab8500_gpadc_dir, &plf->dev,

			    &ab8500_gpadc_btemp_ball_fops);

	debugfs_create_file("main_charger_v", (S_IRUGO | S_IWUSR | S_IWGRP),

			    ab8500_gpadc_dir, &plf->dev,

			    &ab8500_gpadc_main_charger_v_fops);

	debugfs_create_file("acc_detect1", (S_IRUGO | S_IWUSR | S_IWGRP),

			    ab8500_gpadc_dir, &plf->dev,

			    &ab8500_gpadc_acc_detect1_fops);

	debugfs_create_file("acc_detect2", (S_IRUGO | S_IWUSR | S_IWGRP),

			    ab8500_gpadc_dir, &plf->dev,

			    &ab8500_gpadc_acc_detect2_fops);

	debugfs_create_file("adc_aux1", (S_IRUGO | S_IWUSR | S_IWGRP),

			    ab8500_gpadc_dir, &plf->dev,

			    &ab8500_gpadc_aux1_fops);

	debugfs_create_file("adc_aux2", (S_IRUGO | S_IWUSR | S_IWGRP),

			    ab8500_gpadc_dir, &plf->dev,

			    &ab8500_gpadc_aux2_fops);

	debugfs_create_file("main_bat_v", (S_IRUGO | S_IWUSR | S_IWGRP),

			    ab8500_gpadc_dir, &plf->dev,

			    &ab8500_gpadc_main_bat_v_fops);

	debugfs_create_file("vbus_v", (S_IRUGO | S_IWUSR | S_IWGRP),

			    ab8500_gpadc_dir, &plf->dev,

			    &ab8500_gpadc_vbus_v_fops);

	debugfs_create_file("main_charger_c", (S_IRUGO | S_IWUSR | S_IWGRP),

			    ab8500_gpadc_dir, &plf->dev,

			    &ab8500_gpadc_main_charger_c_fops);

	debugfs_create_file("usb_charger_c", (S_IRUGO | S_IWUSR | S_IWGRP),

			    ab8500_gpadc_dir, &plf->dev,

			    &ab8500_gpadc_usb_charger_c_fops);

	debugfs_create_file("bk_bat_v", (S_IRUGO | S_IWUSR | S_IWGRP),

			    ab8500_gpadc_dir, &plf->dev,

			    &ab8500_gpadc_bk_bat_v_fops);

	debugfs_create_file("die_temp", (S_IRUGO | S_IWUSR | S_IWGRP),

			    ab8500_gpadc_dir, &plf->dev,

			    &ab8500_gpadc_die_temp_fops);

	debugfs_create_file("usb_id", (S_IRUGO | S_IWUSR | S_IWGRP),

			    ab8500_gpadc_dir, &plf->dev,

			    &ab8500_gpadc_usb_id_fops);

	if (is_ab8540(ab8500)) {

		debugfs_create_file("xtal_temp", (S_IRUGO | S_IWUSR | S_IWGRP),

				    ab8500_gpadc_dir, &plf->dev,

				    &ab8540_gpadc_xtal_temp_fops);

		debugfs_create_file("vbattruemeas", (S_IRUGO | S_IWUSR | S_IWGRP),

				    ab8500_gpadc_dir, &plf->dev,

				    &ab8540_gpadc_vbat_true_meas_fops);

		debugfs_create_file("batctrl_and_ibat", (S_IRUGO | S_IWUGO),

				    ab8500_gpadc_dir, &plf->dev,

				    &ab8540_gpadc_bat_ctrl_and_ibat_fops);

		debugfs_create_file("vbatmeas_and_ibat", (S_IRUGO | S_IWUGO),

				    ab8500_gpadc_dir, &plf->dev,

				    &ab8540_gpadc_vbat_meas_and_ibat_fops);

		debugfs_create_file("vbattruemeas_and_ibat", (S_IRUGO | S_IWUGO),

				    ab8500_gpadc_dir, &plf->dev,

				    &ab8540_gpadc_vbat_true_meas_and_ibat_fops);

		debugfs_create_file("battemp_and_ibat", (S_IRUGO | S_IWUGO),

				    ab8500_gpadc_dir, &plf->dev,

				    &ab8540_gpadc_bat_temp_and_ibat_fops);

		debugfs_create_file("otp_calib", (S_IRUGO | S_IWUSR | S_IWGRP),

				    ab8500_gpadc_dir, &plf->dev,

				    &ab8540_gpadc_otp_calib_fops);

	}

	debugfs_create_file("avg_sample", (S_IRUGO | S_IWUSR | S_IWGRP),

			    ab8500_gpadc_dir, &plf->dev,

			    &ab8500_gpadc_avg_sample_fops);

	debugfs_create_file("trig_edge", (S_IRUGO | S_IWUSR | S_IWGRP),

			    ab8500_gpadc_dir, &plf->dev,

			    &ab8500_gpadc_trig_edge_fops);

	debugfs_create_file("trig_timer", (S_IRUGO | S_IWUSR | S_IWGRP),

			    ab8500_gpadc_dir, &plf->dev,

			    &ab8500_gpadc_trig_timer_fops);

	debugfs_create_file("conv_type", (S_IRUGO | S_IWUSR | S_IWGRP),

			    ab8500_gpadc_dir, &plf->dev,

			    &ab8500_gpadc_conv_type_fops);



	return 0;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE