From patchwork Mon Apr 6 15:58:04 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Kamel BOUHARA X-Patchwork-Id: 202350 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH, MAILING_LIST_MULTI, SIGNED_OFF_BY, SPF_HELO_NONE, SPF_PASS, URIBL_BLOCKED, USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3060FC2BB54 for ; Mon, 6 Apr 2020 15:58:38 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id F0965248EA for ; Mon, 6 Apr 2020 15:58:37 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729180AbgDFP63 (ORCPT ); Mon, 6 Apr 2020 11:58:29 -0400 Received: from relay1-d.mail.gandi.net ([217.70.183.193]:39715 "EHLO relay1-d.mail.gandi.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728817AbgDFP62 (ORCPT ); Mon, 6 Apr 2020 11:58:28 -0400 X-Originating-IP: 78.193.40.249 Received: from localhost (unknown [78.193.40.249]) (Authenticated sender: kamel.bouhara@bootlin.com) by relay1-d.mail.gandi.net (Postfix) with ESMTPSA id C8941240004; Mon, 6 Apr 2020 15:58:24 +0000 (UTC) From: Kamel Bouhara To: Dmitry Torokhov , William Breathitt Gray , Rob Herring , Mark Rutland Cc: Nicolas Ferre , Alexandre Belloni , Ludovic Desroches , linux-arm-kernel@lists.infradead.org, Thomas Petazzoni , linux-input@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-iio@vger.kernel.org, Kamel Bouhara Subject: [PATCH 1/3] counter: add an inkernel API Date: Mon, 6 Apr 2020 17:58:04 +0200 Message-Id: <20200406155806.1295169-2-kamel.bouhara@bootlin.com> X-Mailer: git-send-email 2.25.0 In-Reply-To: <20200406155806.1295169-1-kamel.bouhara@bootlin.com> References: <20200406155806.1295169-1-kamel.bouhara@bootlin.com> MIME-Version: 1.0 Sender: devicetree-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org Currently, counter devices are exposed directly to user-space through a sysfs interface. However, there are situations where it might makes sense for another kernel driver to use a counter handled by the counter subsystem. An example is the implementation of an input driver for a rotary encoder that is connected to hardware counters handled by the counter subsystem. This is very much like what happens with IIO subsystem, where ADC channels are directly accessible by user-space through sysfs, or can be used through the IIO in-kernel API by other kernel drivers, such as the adc-keys input keyboard driver. The proposed API is fairly simple: - devm_counter_get() allows a driver to get a reference to a counter device. From a Device Tree point of view, a counter-phandle property allows to indicate which counter device should be used. devm_counter_get() returns a reference to the counter_device structure. - counter_count_get() and counter_count_set() allow respectively to read and set a count value. - counter_function_get() and counter_function_set() allow to read and set the current count function. - counter_action_get() and counter_action_set allow to read and set the current count action/synapse. Signed-off-by: Kamel Bouhara --- drivers/counter/counter.c | 213 ++++++++++++++++++++++++++++++++++++++ include/linux/counter.h | 27 +++++ 2 files changed, 240 insertions(+) diff --git a/drivers/counter/counter.c b/drivers/counter/counter.c index 6a683d086008..f81d2d1dbca7 100644 --- a/drivers/counter/counter.c +++ b/drivers/counter/counter.c @@ -19,6 +19,7 @@ #include #include #include +#include const char *const counter_count_direction_str[2] = { [COUNTER_COUNT_DIRECTION_FORWARD] = "forward", @@ -1460,6 +1461,218 @@ static int devm_counter_match(struct device *dev, void *res, void *data) return *r == data; } +static int match(struct device *dev, const void *data) +{ + return (dev->of_node == data) && + (dev->type == &counter_device_type); +} + +/* Internal counter request function */ +static struct counter_device *counter_get(struct device *dev) +{ + struct device_node *np; + struct device *counter_dev; + struct counter_device_state *counter_ds; + struct counter_device *counter; + + /* Try DT lookup */ + np = of_parse_phandle(dev->of_node, "counter", 0); + if (!np) { + dev_dbg(dev, + "Looking up from device tree %pOF failed\n", np); + return ERR_PTR(-ENODEV); + } + + counter_dev = bus_find_device(&counter_bus_type, NULL, np, match); + of_node_put(np); + if (!counter_dev) + return ERR_PTR(-EPROBE_DEFER); + + counter_ds = to_counter_device_state(counter_dev); + + counter = dev_get_drvdata(&counter_ds->dev); + if (!counter) + return ERR_PTR(-ENODEV); + + /* Check if device is already owned otherwise set the busy bit */ + if (test_and_set_bit(COUNTER_BUSY_BIT_POS, &counter->flags)) { + pr_info("counter is busy\n"); + return ERR_PTR(-EBUSY); + } + + pr_info("counter acquired\n"); + get_device(&counter_ds->dev); + + return counter; +} + +static void devm_counter_release(struct device *dev, void *res) +{ + struct counter_device *counter = *(struct counter_device **)res; + + if (!counter) + return; + clear_bit(COUNTER_BUSY_BIT_POS, &counter->flags); + put_device(&counter->device_state->dev); +} + +/* + * devm_counter_get - Obtain an exclusive access to a counter. + * @dev: device for counter "consumer" + * + * Returns a struct counter_device matching the counter producer, or + * IS_ERR() condition containing errno. + * + */ +struct counter_device *devm_counter_get(struct device *dev) +{ + struct counter_device **ptr, *counter; + + ptr = devres_alloc(devm_counter_release, sizeof(*ptr), GFP_KERNEL); + if (!ptr) + return ERR_PTR(-ENOMEM); + + counter = counter_get(dev); + if (IS_ERR(counter)) { + devres_free(ptr); + return counter; + } + + *ptr = counter; + devres_add(dev, ptr); + + return counter; +} +EXPORT_SYMBOL_GPL(devm_counter_get); + +/* + * counter_action_get - get counter synapse mode + * @counter: counter device to operate with + * @action: pointer to store the current counter synapse mode + * returns: + * 0 on success, error code on failure. + */ +int counter_action_get(struct counter_device *counter, int *mode) +{ + struct counter_synapse *synapse = counter->counts->synapses; + size_t action_index; + int err; + + err = counter->ops->action_get(counter, counter->counts, synapse, + &action_index); + if (err) + return err; + + *mode = synapse->actions_list[action_index]; + + return 0; +} +EXPORT_SYMBOL_GPL(counter_action_get); + +/* + * counter_action_set - set counter device synapse + * @counter: counter device to operate with + * @action: enum of the synapse mode + * returns: + * 0 on success, error code on failure. + */ +int counter_action_set(struct counter_device *counter, + enum counter_synapse_action action) +{ + struct counter_synapse *synapse = counter->counts->synapses; + const size_t num_actions = synapse->num_actions; + size_t action_index; + + /* Find requested action mode */ + for (action_index = 0; action_index < num_actions; action_index++) { + if (action == synapse->actions_list[action_index]) + break; + } + + if (action_index >= num_actions) + return -EINVAL; + + return counter->ops->action_set(counter, counter->counts, synapse, + action_index); +} +EXPORT_SYMBOL_GPL(counter_action_set); + +/* + * counter_function_get - get the count function + * @counter: pointer to counter device to operate with + * @mode: pointer to store the current counter function mode + * returns: + * 0 on success, error code on failure. + */ +int counter_function_get(struct counter_device *counter, int *mode) +{ + size_t func_index; + int err; + + err = counter->ops->function_get(counter, counter->counts, + &func_index); + if (err) + return err; + + *mode = counter->counts->functions_list[func_index]; + + return 0; +} +EXPORT_SYMBOL_GPL(counter_function_get); + +/* + * counter_function_set - set a count function + * @counter: pointer to a counter device to operate with + * @function: enum of the function mode + * returns: + * 0 on success, error code on failure. + */ +int counter_function_set(struct counter_device *counter, + enum counter_count_function function) +{ + const size_t num_functions = counter->counts->num_functions; + size_t func_index; + + for (func_index = 0; func_index < num_functions; func_index++) { + if (function == counter->counts->functions_list[func_index]) + break; + } + + if (func_index >= num_functions) + return -EINVAL; + + return counter->ops->function_set(counter, counter->counts, func_index); +} +EXPORT_SYMBOL_GPL(counter_function_set); + +/* + * counter_count_set - set a count value + * @counter: pointer to the counter device to operate with + * @val: count value to write into the counter + * @len: length of the value written to the counter + * returns: + * bytes length of the value on success, error code on failure. + */ +size_t counter_count_set(struct counter_device *counter, + unsigned long val, size_t len) +{ + return counter->ops->count_write(counter, counter->counts, val); +} +EXPORT_SYMBOL_GPL(counter_count_set); + +/* + * counter_count_get - read the count value + * @counter: pointer to the counter device to operate with + * @val: pointer to store the count value + * returns: + * 0 on success, error code on failure. + */ +int counter_count_get(struct counter_device *counter, unsigned long *val) +{ + return counter->ops->count_read(counter, counter->counts, val); +} +EXPORT_SYMBOL_GPL(counter_count_get); + /** * devm_counter_unregister - Resource-managed counter_unregister * @dev: device this counter_device belongs to diff --git a/include/linux/counter.h b/include/linux/counter.h index 9dbd5df4cd34..81f63479be55 100644 --- a/include/linux/counter.h +++ b/include/linux/counter.h @@ -10,6 +10,8 @@ #include #include +#define COUNTER_BUSY_BIT_POS 1 + enum counter_count_direction { COUNTER_COUNT_DIRECTION_FORWARD = 0, COUNTER_COUNT_DIRECTION_BACKWARD @@ -290,6 +292,15 @@ struct counter_device_state { const struct attribute_group **groups; }; +/** + * to_counter_device_state - Returns a &struct counter_device_state + * from the &struct device embedded in it. + * + * @d:pointer to &struct device + */ +#define to_counter_device_state(d) \ + container_of(d, struct counter_device_state, dev) + enum counter_signal_value { COUNTER_SIGNAL_LOW = 0, COUNTER_SIGNAL_HIGH @@ -424,6 +435,7 @@ struct counter_device_enum_ext { * @num_counts: number of Counts specified in @counts * @ext: optional array of Counter device extensions * @num_ext: number of Counter device extensions specified in @ext + * @flags: internal device flags including a busy flag. * @priv: optional private data supplied by driver */ struct counter_device { @@ -440,6 +452,7 @@ struct counter_device { const struct counter_device_ext *ext; size_t num_ext; + unsigned long flags; void *priv; }; @@ -450,5 +463,19 @@ int devm_counter_register(struct device *dev, struct counter_device *const counter); void devm_counter_unregister(struct device *dev, struct counter_device *const counter); +/* inkernel interface */ +int __must_check counter_count_get(struct counter_device *counter, + unsigned long *val); +size_t __must_check counter_count_set(struct counter_device *counter, + unsigned long val, size_t len); +int __must_check counter_function_get(struct counter_device *counter, + int *mode); +int __must_check counter_function_set(struct counter_device *counter, + enum counter_count_function function); +int __must_check counter_action_get(struct counter_device *counter, + int *mode); +int __must_check counter_action_set(struct counter_device *counter, + enum counter_synapse_action action); +struct counter_device *__must_check devm_counter_get(struct device *dev); #endif /* _COUNTER_H_ */ From patchwork Mon Apr 6 15:58:06 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Kamel BOUHARA X-Patchwork-Id: 202351 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH, MAILING_LIST_MULTI, SIGNED_OFF_BY, SPF_HELO_NONE, SPF_PASS, URIBL_BLOCKED, USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3D246C2BB1D for ; Mon, 6 Apr 2020 15:58:35 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 17A76248FB for ; Mon, 6 Apr 2020 15:58:35 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729229AbgDFP6b (ORCPT ); Mon, 6 Apr 2020 11:58:31 -0400 Received: from relay1-d.mail.gandi.net ([217.70.183.193]:17995 "EHLO relay1-d.mail.gandi.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1729202AbgDFP6a (ORCPT ); Mon, 6 Apr 2020 11:58:30 -0400 X-Originating-IP: 78.193.40.249 Received: from localhost (unknown [78.193.40.249]) (Authenticated sender: kamel.bouhara@bootlin.com) by relay1-d.mail.gandi.net (Postfix) with ESMTPSA id 0936F240012; Mon, 6 Apr 2020 15:58:27 +0000 (UTC) From: Kamel Bouhara To: Dmitry Torokhov , William Breathitt Gray , Rob Herring , Mark Rutland Cc: Nicolas Ferre , Alexandre Belloni , Ludovic Desroches , linux-arm-kernel@lists.infradead.org, Thomas Petazzoni , linux-input@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-iio@vger.kernel.org, Kamel Bouhara Subject: [PATCH 3/3] Input: add a rotary encoders based on counter devices Date: Mon, 6 Apr 2020 17:58:06 +0200 Message-Id: <20200406155806.1295169-4-kamel.bouhara@bootlin.com> X-Mailer: git-send-email 2.25.0 In-Reply-To: <20200406155806.1295169-1-kamel.bouhara@bootlin.com> References: <20200406155806.1295169-1-kamel.bouhara@bootlin.com> MIME-Version: 1.0 Sender: devicetree-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org This add support for rotary encoders that use the counter subsystem to expose an input device. Signed-off-by: Kamel Bouhara --- drivers/input/misc/Kconfig | 9 ++ drivers/input/misc/Makefile | 1 + drivers/input/misc/rotary_encoder_counter.c | 152 ++++++++++++++++++++ 3 files changed, 162 insertions(+) create mode 100644 drivers/input/misc/rotary_encoder_counter.c diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig index 7e2e658d551c..b91b4257e337 100644 --- a/drivers/input/misc/Kconfig +++ b/drivers/input/misc/Kconfig @@ -619,6 +619,15 @@ config INPUT_GPIO_ROTARY_ENCODER To compile this driver as a module, choose M here: the module will be called rotary_encoder. +config INPUT_COUNTER_ROTARY_ENCODER + tristate "Rotary encoders connected to counter devices" + depends on COUNTER || COMPILE_TEST + help + Say Y here to add support for rotary encoders connected to counter devices. + + To compile this driver as a module, choose M here: the + module will be called rotary_encoder_counter. + config INPUT_RB532_BUTTON tristate "Mikrotik Routerboard 532 button interface" depends on MIKROTIK_RB532 diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile index 8fd187f314bd..74bbe6d400a3 100644 --- a/drivers/input/misc/Makefile +++ b/drivers/input/misc/Makefile @@ -68,6 +68,7 @@ obj-$(CONFIG_INPUT_REGULATOR_HAPTIC) += regulator-haptic.o obj-$(CONFIG_INPUT_RETU_PWRBUTTON) += retu-pwrbutton.o obj-$(CONFIG_INPUT_AXP20X_PEK) += axp20x-pek.o obj-$(CONFIG_INPUT_GPIO_ROTARY_ENCODER) += rotary_encoder.o +obj-$(CONFIG_INPUT_COUNTER_ROTARY_ENCODER) += rotary_encoder_counter.o obj-$(CONFIG_INPUT_RK805_PWRKEY) += rk805-pwrkey.o obj-$(CONFIG_INPUT_SC27XX_VIBRA) += sc27xx-vibra.o obj-$(CONFIG_INPUT_SGI_BTNS) += sgi_btns.o diff --git a/drivers/input/misc/rotary_encoder_counter.c b/drivers/input/misc/rotary_encoder_counter.c new file mode 100644 index 000000000000..20017308f4f3 --- /dev/null +++ b/drivers/input/misc/rotary_encoder_counter.c @@ -0,0 +1,152 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * A rotary encoder driver using the generic counter interface. + * + * Author: Kamel Bouhara + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define MAX_STEPS 24 + +struct rotary_encoder { + struct input_dev *input; + u32 steps; + u32 axis; + bool relative_axis; + bool rollover; + long last_pos; + struct counter_device *counter; +}; + +static void rotary_encoder_poll(struct input_dev *input) +{ + struct rotary_encoder *encoder = input_get_drvdata(input); + long rotary_pos; + int ret; + + ret = counter_count_get(encoder->counter, &rotary_pos); + if (ret) + return; + + if (encoder->relative_axis) { + input_report_rel(encoder->input, encoder->axis, + rotary_pos - encoder->last_pos); + } else { + if (encoder->rollover) + rotary_pos %= encoder->steps; + input_report_abs(encoder->input, encoder->axis, rotary_pos); + } + + encoder->last_pos = rotary_pos; + input_sync(encoder->input); +} + +static int rotary_encoder_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct counter_device *counter; + struct rotary_encoder *encoder; + struct input_dev *input; + int qdec_mode; + u32 poll_interval; + int err; + + encoder = devm_kzalloc(dev, sizeof(struct rotary_encoder), GFP_KERNEL); + if (!encoder) + return -ENOMEM; + + encoder->rollover = + device_property_read_bool(dev, "rollover"); + + device_property_read_u32(dev, "steps", &encoder->steps); + + device_property_read_u32(dev, "linux-axis", &encoder->axis); + + encoder->relative_axis = + device_property_read_bool(dev, "relative-axis"); + + counter = devm_counter_get(dev); + if (IS_ERR(counter)) + return PTR_ERR(counter); + + if (device_property_read_u32(dev, "qdec-mode", &qdec_mode)) { + dev_err(dev, "Invalid or missing quadrature mode\n"); + return -EINVAL; + } + + err = counter_function_set(counter, qdec_mode); + if (err) { + dev_err(dev, "Failed to set quadrature mode %d\n", + qdec_mode); + return err; + } + + input = devm_input_allocate_device(dev); + if (!input) + return -ENOMEM; + + input_set_drvdata(input, encoder); + encoder->input = input; + encoder->counter = counter; + encoder->steps = (!encoder->steps) ? MAX_STEPS : encoder->steps; + input->name = pdev->name; + input->id.bustype = BUS_HOST; + input->dev.parent = dev; + + if (encoder->relative_axis) + input_set_capability(input, EV_REL, encoder->axis); + else + input_set_abs_params(input, encoder->axis, 0, + encoder->steps, 0, 1); + + err = input_setup_polling(input, rotary_encoder_poll); + if (err) + return err; + + if (!device_property_read_u32(dev, "poll-interval", + &poll_interval)) + input_set_poll_interval(input, poll_interval); + + err = input_register_device(input); + if (err) { + dev_err(dev, "failed to register device, err=%d\n", err); + return err; + } + + platform_set_drvdata(pdev, encoder); + + return 0; +} + +#ifdef CONFIG_OF +static const struct of_device_id rotary_encoder_of_match[] = { + { .compatible = "rotary-encoder-counter", }, + { /* sentinel */ }, +}; +MODULE_DEVICE_TABLE(of, rotary_encoder_of_match); +#endif + +static struct platform_driver rotary_encoder_driver = { + .probe = rotary_encoder_probe, + .driver = { + .name = "rotary-encoder-counter", + .of_match_table = of_match_ptr(rotary_encoder_of_match), + } +}; +module_platform_driver(rotary_encoder_driver); + +MODULE_DESCRIPTION("Counter rotary encoder driver"); +MODULE_AUTHOR("Kamel Bouhara "); +MODULE_LICENSE("GPL v2");