Commit 394a0150 authored by William Breathitt Gray's avatar William Breathitt Gray Committed by Jonathan Cameron
Browse files

counter: Rename counter_count_function to counter_function 



The phrase "Counter Count function" is verbose and unintentionally
implies that function is a Count extension. This patch adjusts the
Counter subsystem code to use the more direct "Counter function" phrase
to make the intent of this code clearer.

Cc: Jarkko Nikula <jarkko.nikula@linux.intel.com>
Cc: Patrick Havelange <patrick.havelange@essensium.com>
Cc: Oleksij Rempel <o.rempel@pengutronix.de>
Cc: Kamel Bouhara <kamel.bouhara@bootlin.com>
Cc: Maxime Coquelin <mcoquelin.stm32@gmail.com>
Cc: Alexandre Torgue <alexandre.torgue@st.com>
Cc: David Lechner <david@lechnology.com>
Acked-by: default avatarSyed Nayyar Waris <syednwaris@gmail.com>
Reviewed-by: default avatarFabrice Gasnier <fabrice.gasnier@foss.st.com>
Signed-off-by: default avatarWilliam Breathitt Gray <vilhelm.gray@gmail.com>
Link: https://lore.kernel.org/r/8268c54d6f42075a19bb08151a37831e22652499.1627990337.git.vilhelm.gray@gmail.com


Signed-off-by: default avatarJonathan Cameron <Jonathan.Cameron@huawei.com>
parent 493b938a

drivers/counter/104-quad-8.c

+5 −5
Original line number Diff line number Diff line
@@ -194,11 +194,11 @@ enum quad8_count_function { 
	QUAD8_COUNT_FUNCTION_QUADRATURE_X4

};



static const enum counter_count_function quad8_count_functions_list[] = {

	[QUAD8_COUNT_FUNCTION_PULSE_DIRECTION] = COUNTER_COUNT_FUNCTION_PULSE_DIRECTION,

	[QUAD8_COUNT_FUNCTION_QUADRATURE_X1] = COUNTER_COUNT_FUNCTION_QUADRATURE_X1_A,

	[QUAD8_COUNT_FUNCTION_QUADRATURE_X2] = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A,

	[QUAD8_COUNT_FUNCTION_QUADRATURE_X4] = COUNTER_COUNT_FUNCTION_QUADRATURE_X4

static const enum counter_function quad8_count_functions_list[] = {

	[QUAD8_COUNT_FUNCTION_PULSE_DIRECTION] = COUNTER_FUNCTION_PULSE_DIRECTION,

	[QUAD8_COUNT_FUNCTION_QUADRATURE_X1] = COUNTER_FUNCTION_QUADRATURE_X1_A,

	[QUAD8_COUNT_FUNCTION_QUADRATURE_X2] = COUNTER_FUNCTION_QUADRATURE_X2_A,

	[QUAD8_COUNT_FUNCTION_QUADRATURE_X4] = COUNTER_FUNCTION_QUADRATURE_X4

};



static int quad8_function_get(struct counter_device *counter,

drivers/counter/counter.c

+19 −19
Original line number Diff line number Diff line
@@ -744,15 +744,15 @@ static ssize_t counter_count_store(struct device *dev, 
	return len;

}



static const char *const counter_count_function_str[] = {

	[COUNTER_COUNT_FUNCTION_INCREASE] = "increase",

	[COUNTER_COUNT_FUNCTION_DECREASE] = "decrease",

	[COUNTER_COUNT_FUNCTION_PULSE_DIRECTION] = "pulse-direction",

	[COUNTER_COUNT_FUNCTION_QUADRATURE_X1_A] = "quadrature x1 a",

	[COUNTER_COUNT_FUNCTION_QUADRATURE_X1_B] = "quadrature x1 b",

	[COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A] = "quadrature x2 a",

	[COUNTER_COUNT_FUNCTION_QUADRATURE_X2_B] = "quadrature x2 b",

	[COUNTER_COUNT_FUNCTION_QUADRATURE_X4] = "quadrature x4"

static const char *const counter_function_str[] = {

	[COUNTER_FUNCTION_INCREASE] = "increase",

	[COUNTER_FUNCTION_DECREASE] = "decrease",

	[COUNTER_FUNCTION_PULSE_DIRECTION] = "pulse-direction",

	[COUNTER_FUNCTION_QUADRATURE_X1_A] = "quadrature x1 a",

	[COUNTER_FUNCTION_QUADRATURE_X1_B] = "quadrature x1 b",

	[COUNTER_FUNCTION_QUADRATURE_X2_A] = "quadrature x2 a",

	[COUNTER_FUNCTION_QUADRATURE_X2_B] = "quadrature x2 b",

	[COUNTER_FUNCTION_QUADRATURE_X4] = "quadrature x4"

};



static ssize_t counter_function_show(struct device *dev,
@@ -764,7 +764,7 @@ static ssize_t counter_function_show(struct device *dev, 
	const struct counter_count_unit *const component = devattr->component;

	struct counter_count *const count = component->count;

	size_t func_index;

	enum counter_count_function function;

	enum counter_function function;



	err = counter->ops->function_get(counter, count, &func_index);

	if (err)
@@ -773,7 +773,7 @@ static ssize_t counter_function_show(struct device *dev, 
	count->function = func_index;



	function = count->functions_list[func_index];

	return sprintf(buf, "%s\n", counter_count_function_str[function]);

	return sprintf(buf, "%s\n", counter_function_str[function]);

}



static ssize_t counter_function_store(struct device *dev,
@@ -785,14 +785,14 @@ static ssize_t counter_function_store(struct device *dev, 
	struct counter_count *const count = component->count;

	const size_t num_functions = count->num_functions;

	size_t func_index;

	enum counter_count_function function;

	enum counter_function function;

	int err;

	struct counter_device *const counter = dev_get_drvdata(dev);



	/* Find requested Count function mode */

	for (func_index = 0; func_index < num_functions; func_index++) {

		function = count->functions_list[func_index];

		if (sysfs_streq(buf, counter_count_function_str[function]))

		if (sysfs_streq(buf, counter_function_str[function]))

			break;

	}

	/* Return error if requested Count function mode not found */
@@ -880,25 +880,25 @@ static int counter_count_ext_register( 
}



struct counter_func_avail_unit {

	const enum counter_count_function *functions_list;

	const enum counter_function *functions_list;

	size_t num_functions;

};



static ssize_t counter_count_function_available_show(struct device *dev,

static ssize_t counter_function_available_show(struct device *dev,

	struct device_attribute *attr, char *buf)

{

	const struct counter_device_attr *const devattr = to_counter_attr(attr);

	const struct counter_func_avail_unit *const component = devattr->component;

	const enum counter_count_function *const func_list = component->functions_list;

	const enum counter_function *const func_list = component->functions_list;

	const size_t num_functions = component->num_functions;

	size_t i;

	enum counter_count_function function;

	enum counter_function function;

	ssize_t len = 0;



	for (i = 0; i < num_functions; i++) {

		function = func_list[i];

		len += sprintf(buf + len, "%s\n",

			       counter_count_function_str[function]);

			       counter_function_str[function]);

	}



	return len;
@@ -968,7 +968,7 @@ static int counter_count_attributes_create( 
	parm.group = group;

	parm.prefix = "";

	parm.name = "function_available";

	parm.show = counter_count_function_available_show;

	parm.show = counter_function_available_show;

	parm.store = NULL;

	parm.component = avail_comp;

	err = counter_attribute_create(&parm);

drivers/counter/ftm-quaddec.c

+2 −3
Original line number Diff line number Diff line
@@ -171,9 +171,8 @@ enum ftm_quaddec_count_function { 
	FTM_QUADDEC_COUNT_ENCODER_MODE_1,

};



static const enum counter_count_function ftm_quaddec_count_functions[] = {

	[FTM_QUADDEC_COUNT_ENCODER_MODE_1] =

	COUNTER_COUNT_FUNCTION_QUADRATURE_X4

static const enum counter_function ftm_quaddec_count_functions[] = {

	[FTM_QUADDEC_COUNT_ENCODER_MODE_1] = COUNTER_FUNCTION_QUADRATURE_X4

};



static int ftm_quaddec_count_read(struct counter_device *counter,

drivers/counter/intel-qep.c

+2 −2
Original line number Diff line number Diff line
@@ -126,8 +126,8 @@ static int intel_qep_count_read(struct counter_device *counter, 
	return 0;

}



static const enum counter_count_function intel_qep_count_functions[] = {

	COUNTER_COUNT_FUNCTION_QUADRATURE_X4,

static const enum counter_function intel_qep_count_functions[] = {

	COUNTER_FUNCTION_QUADRATURE_X4,

};



static int intel_qep_function_get(struct counter_device *counter,

drivers/counter/interrupt-cnt.c

+2 −2
Original line number Diff line number Diff line
@@ -115,8 +115,8 @@ static int interrupt_cnt_write(struct counter_device *counter, 
	return 0;

}



static const enum counter_count_function interrupt_cnt_functions[] = {

	COUNTER_COUNT_FUNCTION_INCREASE,

static const enum counter_function interrupt_cnt_functions[] = {

	COUNTER_FUNCTION_INCREASE,

};



static int interrupt_cnt_function_get(struct counter_device *counter,