Re: [PATCH v2 20/28] net: wan: Add framer framework support

Le 26/07/2023 à 17:02, Herve Codina a écrit :

A framer is a component in charge of an E1/T1 line interface. Connected usually to a TDM bus, it converts TDM frames to/from E1/T1 frames. It also provides information related to the E1/T1 line.

The framer framework provides a set of APIs for the framer drivers (framer provider) to create/destroy a framer and APIs for the framer users (framer consumer) to obtain a reference to the framer, and use the framer.

This basic implementation provides a framer abstraction for:

• power on/off the framer
• get the framer status (line state)
• be notified on framer status changes
• get/set the framer configuration

Signed-off-by: Herve Codina herve.codina@bootlin.com

Reviewed-by: Christophe Leroy christophe.leroy@csgroup.eu

---

drivers/net/wan/Kconfig | 2 + drivers/net/wan/Makefile | 2 + drivers/net/wan/framer/Kconfig | 19 + drivers/net/wan/framer/Makefile | 6 + drivers/net/wan/framer/framer-core.c | 935 +++++++++++++++++++++++++ include/linux/framer/framer-provider.h | 194 +++++ include/linux/framer/framer.h | 215 ++++++ 7 files changed, 1373 insertions(+) create mode 100644 drivers/net/wan/framer/Kconfig create mode 100644 drivers/net/wan/framer/Makefile create mode 100644 drivers/net/wan/framer/framer-core.c create mode 100644 include/linux/framer/framer-provider.h create mode 100644 include/linux/framer/framer.h

diff --git a/drivers/net/wan/Kconfig b/drivers/net/wan/Kconfig index 8de99f4b647b..31ab2136cdf1 100644 --- a/drivers/net/wan/Kconfig +++ b/drivers/net/wan/Kconfig @@ -95,6 +95,8 @@ config HDLC_X25 comment "X.25/LAPB support is disabled" depends on HDLC && (LAPB!=m || HDLC!=m) && LAPB!=y

+source "drivers/net/wan/framer/Kconfig"

• config PCI200SYN tristate "Goramo PCI200SYN support" depends on HDLC && PCI

diff --git a/drivers/net/wan/Makefile b/drivers/net/wan/Makefile index f338f4830626..00e9b7ee1e01 100644 --- a/drivers/net/wan/Makefile +++ b/drivers/net/wan/Makefile @@ -14,6 +14,8 @@ obj-$(CONFIG_HDLC_FR) += hdlc_fr.o obj-$(CONFIG_HDLC_PPP) += hdlc_ppp.o obj-$(CONFIG_HDLC_X25) += hdlc_x25.o

+obj-y += framer/

• obj-$(CONFIG_FARSYNC) += farsync.o

  obj-$(CONFIG_LAPBETHER) += lapbether.o

diff --git a/drivers/net/wan/framer/Kconfig b/drivers/net/wan/framer/Kconfig new file mode 100644 index 000000000000..96ef1e7ba8eb --- /dev/null +++ b/drivers/net/wan/framer/Kconfig @@ -0,0 +1,19 @@ +# SPDX-License-Identifier: GPL-2.0-only +# +# FRAMER +#

+menu "Framer Subsystem"

+config GENERIC_FRAMER

• bool "Framer Core"
• help

•  Generic Framer support.
  

•  This framework is designed to provide a generic interface for framer
  

•  devices present in the kernel. This layer will have the generic
  

•  API by which framer drivers can create framer using the framer
  

•  framework and framer users can obtain reference to the framer.
  

•  All the users of this framework should select this config.
  

+endmenu diff --git a/drivers/net/wan/framer/Makefile b/drivers/net/wan/framer/Makefile new file mode 100644 index 000000000000..78dbd8e563d0 --- /dev/null +++ b/drivers/net/wan/framer/Makefile @@ -0,0 +1,6 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# Makefile for the framer drivers. +#

+obj-$(CONFIG_GENERIC_FRAMER) += framer-core.o diff --git a/drivers/net/wan/framer/framer-core.c b/drivers/net/wan/framer/framer-core.c new file mode 100644 index 000000000000..ef93b7d74fd1 --- /dev/null +++ b/drivers/net/wan/framer/framer-core.c @@ -0,0 +1,935 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/*

• • Generic Framer framework.
• • Copyright 2023 CS GROUP France
• • Author: Herve Codina herve.codina@bootlin.com
• */

+#include <linux/device.h> +#include <linux/framer/framer.h> +#include <linux/framer/framer-provider.h> +#include <linux/idr.h> +#include <linux/module.h> +#include <linux/notifier.h> +#include <linux/of.h> +#include <linux/pm_runtime.h> +#include <linux/regulator/consumer.h> +#include <linux/slab.h>

+static struct class *framer_class; +static DEFINE_MUTEX(framer_provider_mutex); +static LIST_HEAD(framer_provider_list); +static DEFINE_IDA(framer_ida);

+#define dev_to_framer(a) (container_of((a), struct framer, dev))

+int framer_pm_runtime_get(struct framer *framer) +{

• int ret;
• if (!framer)

• return 0;
  

• if (!pm_runtime_enabled(&framer->dev))

• return -EOPNOTSUPP;
  

• ret = pm_runtime_get(&framer->dev);
• if (ret < 0 && ret != -EINPROGRESS)

• pm_runtime_put_noidle(&framer->dev);
  

• return ret;

+} +EXPORT_SYMBOL_GPL(framer_pm_runtime_get);

+int framer_pm_runtime_get_sync(struct framer *framer) +{

• int ret;
• if (!framer)

• return 0;
  

• if (!pm_runtime_enabled(&framer->dev))

• return -EOPNOTSUPP;
  

• ret = pm_runtime_get_sync(&framer->dev);
• if (ret < 0)

• pm_runtime_put_sync(&framer->dev);
  

• return ret;

+} +EXPORT_SYMBOL_GPL(framer_pm_runtime_get_sync);

+int framer_pm_runtime_put(struct framer *framer) +{

• if (!framer)

• return 0;
  

• if (!pm_runtime_enabled(&framer->dev))

• return -EOPNOTSUPP;
  

• return pm_runtime_put(&framer->dev);

+} +EXPORT_SYMBOL_GPL(framer_pm_runtime_put);

+int framer_pm_runtime_put_sync(struct framer *framer) +{

• if (!framer)

• return 0;
  

• if (!pm_runtime_enabled(&framer->dev))

• return -EOPNOTSUPP;
  

• return pm_runtime_put_sync(&framer->dev);

+} +EXPORT_SYMBOL_GPL(framer_pm_runtime_put_sync);

+/**

• • framer_init - framer internal initialization before framer operation
• • @framer: the framer returned by framer_get()
• • Used to allow framer's driver to perform framer internal initialization,
• • such as PLL block powering, clock initialization or anything that's
• • is required by the framer to perform the start of operation.
• • Must be called before framer_power_on().
• • Return: %0 if successful, a negative error code otherwise
• */

+int framer_init(struct framer *framer) +{

• bool start_polling = false;
• int ret;
• if (!framer)

• return 0;
  

• ret = framer_pm_runtime_get_sync(framer);
• if (ret < 0 && ret != -EOPNOTSUPP)

• return ret;
  

• ret = 0; /* Override possible ret == -EOPNOTSUPP */
• mutex_lock(&framer->mutex);
• if (framer->power_count > framer->init_count)

• dev_warn(&framer->dev, "framer_power_on was called before framer init\n");
  

• if (framer->init_count == 0) {

• if (framer->ops->init) {
  

• 	ret = framer->ops->init(framer);
  

• 	if (ret < 0) {
  

• 		dev_err(&framer->dev, "framer init failed --> %d\n", ret);
  

• 		goto out;
  

• 	}
  

• }
  

• if (framer->ops->flags & FRAMER_FLAG_POLL_STATUS)
  

• 	start_polling = true;
  

• }
• ++framer->init_count;

+out:

• mutex_unlock(&framer->mutex);
• if (!ret && start_polling) {

• ret = framer_get_status(framer, &framer->prev_status);
  

• if (ret < 0) {
  

• 	dev_warn(&framer->dev, "framer get status failed --> %d\n", ret);
  

• 	/* Will be retried on polling_work */
  

• 	ret = 0;
  

• }
  

• queue_delayed_work(system_power_efficient_wq, &framer->polling_work, 1 * HZ);
  

• }
• framer_pm_runtime_put(framer);
• return ret;

+} +EXPORT_SYMBOL_GPL(framer_init);

+/**

• • framer_exit - Framer internal un-initialization
• • @framer: the framer returned by framer_get()
• • Must be called after framer_power_off().
• */

+int framer_exit(struct framer *framer) +{

• int ret;
• if (!framer)

• return 0;
  

• ret = framer_pm_runtime_get_sync(framer);
• if (ret < 0 && ret != -EOPNOTSUPP)

• return ret;
  

• ret = 0; /* Override possible ret == -EOPNOTSUPP */
• mutex_lock(&framer->mutex);
• --framer->init_count;
• if (framer->init_count == 0) {

• if (framer->ops->flags & FRAMER_FLAG_POLL_STATUS) {
  

• 	mutex_unlock(&framer->mutex);
  

• 	cancel_delayed_work_sync(&framer->polling_work);
  

• 	mutex_lock(&framer->mutex);
  

• }
  

• if (framer->ops->exit)
  

• 	framer->ops->exit(framer);
  

• }
• mutex_unlock(&framer->mutex);
• framer_pm_runtime_put(framer);
• return ret;

+} +EXPORT_SYMBOL_GPL(framer_exit);

+/**

• • framer_power_on - Enable the framer and enter proper operation
• • @framer: the framer returned by framer_get()
• • Must be called after framer_init().
• • Return: %0 if successful, a negative error code otherwise
• */

+int framer_power_on(struct framer *framer) +{

• int ret = 0;
• if (!framer)

• goto out;
  

• if (framer->pwr) {

• ret = regulator_enable(framer->pwr);
  

• if (ret)
  

• 	goto out;
  

• }
• ret = framer_pm_runtime_get_sync(framer);
• if (ret < 0 && ret != -EOPNOTSUPP)

• goto err_pm_sync;
  

• ret = 0; /* Override possible ret == -EOPNOTSUPP */
• mutex_lock(&framer->mutex);
• if (framer->power_count == 0 && framer->ops->power_on) {

• ret = framer->ops->power_on(framer);
  

• if (ret < 0) {
  

• 	dev_err(&framer->dev, "framer poweron failed --> %d\n", ret);
  

• 	goto err_pwr_on;
  

• }
  

• }
• ++framer->power_count;
• mutex_unlock(&framer->mutex);
• return 0;

+err_pwr_on:

• mutex_unlock(&framer->mutex);
• framer_pm_runtime_put_sync(framer);

+err_pm_sync:

• if (framer->pwr)

• regulator_disable(framer->pwr);
  

+out:

• return ret;

+} +EXPORT_SYMBOL_GPL(framer_power_on);

+/**

• • framer_power_off - Disable the framer.
• • @framer: the framer returned by framer_get()
• • Must be called before framer_exit().
• • Return: %0 if successful, a negative error code otherwise
• */

+int framer_power_off(struct framer *framer) +{

• int ret;
• if (!framer)

• return 0;
  

• mutex_lock(&framer->mutex);
• if (framer->power_count == 1 && framer->ops->power_off) {

• ret =  framer->ops->power_off(framer);
  

• if (ret < 0) {
  

• 	dev_err(&framer->dev, "framer poweroff failed --> %d\n", ret);
  

• 	mutex_unlock(&framer->mutex);
  

• 	return ret;
  

• }
  

• }
• --framer->power_count;
• mutex_unlock(&framer->mutex);
• framer_pm_runtime_put(framer);
• if (framer->pwr)

• regulator_disable(framer->pwr);
  

• return 0;

+} +EXPORT_SYMBOL_GPL(framer_power_off);

+/**

• • framer_get_status() - Gets the framer status
• • @framer: the framer returned by framer_get()
• • @status: the status to retrieve
• • Used to get the framer status. framer_init() must have been called
• • on the framer.
• • Return: %0 if successful, a negative error code otherwise
• */

+int framer_get_status(struct framer *framer, struct framer_status *status) +{

• int ret;
• if (!framer)

• return -EINVAL;
  

• if (!framer->ops->get_status)

• return -EOPNOTSUPP;
  

• /* Be sure to have known values (struct padding and future extensions) */
• memset(status, 0, sizeof(*status));
• mutex_lock(&framer->mutex);
• ret = framer->ops->get_status(framer, status);
• mutex_unlock(&framer->mutex);
• return ret;

+} +EXPORT_SYMBOL_GPL(framer_get_status);

+/**

• • framer_set_config() - Sets the framer configuration
• • @framer: the framer returned by framer_get()
• • @config: the configuration to set
• • Used to set the framer configuration. framer_init() must have been called
• • on the framer.
• • Return: %0 if successful, a negative error code otherwise
• */

+int framer_set_config(struct framer *framer, const struct framer_config *config) +{

• int ret;
• if (!framer)

• return -EINVAL;
  

• if (!framer->ops->set_config)

• return -EOPNOTSUPP;
  

• mutex_lock(&framer->mutex);
• ret = framer->ops->set_config(framer, config);
• mutex_unlock(&framer->mutex);
• return ret;

+} +EXPORT_SYMBOL_GPL(framer_set_config);

+/**

• • framer_get_config() - Gets the framer configuration
• • @framer: the framer returned by framer_get()
• • @config: the configuration to retrieve
• • Used to get the framer configuration. framer_init() must have been called
• • on the framer.
• • Return: %0 if successful, a negative error code otherwise
• */

+int framer_get_config(struct framer *framer, struct framer_config *config) +{

• int ret;
• if (!framer)

• return -EINVAL;
  

• if (!framer->ops->get_config)

• return -EOPNOTSUPP;
  

• mutex_lock(&framer->mutex);
• ret = framer->ops->get_config(framer, config);
• mutex_unlock(&framer->mutex);
• return ret;

+} +EXPORT_SYMBOL_GPL(framer_get_config);

+static void framer_polling_work(struct work_struct *work) +{

• struct framer *framer = container_of(work, struct framer, polling_work.work);
• struct framer_status status;
• int ret;
• ret = framer_get_status(framer, &status);
• if (ret) {

• dev_err(&framer->dev, "polling, get status failed (%d)\n", ret);
  

• goto end;
  

• }
• if (memcmp(&framer->prev_status, &status, sizeof(status))) {

• blocking_notifier_call_chain(&framer->notifier_list,
  

• 			     FRAMER_EVENT_STATUS, NULL);
  

• memcpy(&framer->prev_status, &status, sizeof(status));
  

• }

+end:

• /* Re-schedule task in 1 sec */
• queue_delayed_work(system_power_efficient_wq, &framer->polling_work, 1 * HZ);

+}

+/**

• • framer_notifier_register() - Registers a notifier
• • @framer: the framer returned by framer_get()
• • @nb: the notifier block to register
• • Used to register a notifier block on framer events. framer_init() must have
• • been called on the framer.
• • The available framer events are present in enum framer_events.
• • Return: %0 if successful, a negative error code otherwise
• */

+int framer_notifier_register(struct framer *framer, struct notifier_block *nb) +{

• if (!framer)

• return 0;
  

• return blocking_notifier_chain_register(&framer->notifier_list, nb);

+} +EXPORT_SYMBOL_GPL(framer_notifier_register);

+/**

• • framer_notifier_unregister() - Unregisters a notifier
• • @framer: the framer returned by framer_get()
• • @nb: the notifier block to unregister
• • Used to unregister a notifier block. framer_init() must have
• • been called on the framer.
• • Return: %0 if successful, a negative error code otherwise
• */

+int framer_notifier_unregister(struct framer *framer, struct notifier_block *nb) +{

• if (!framer)

• return -EINVAL;
  

• return blocking_notifier_chain_unregister(&framer->notifier_list, nb);

+} +EXPORT_SYMBOL_GPL(framer_atomic_notifier_unregister);

+static struct framer_provider *framer_provider_of_lookup(const struct device_node *node) +{

• struct framer_provider *framer_provider;
• list_for_each_entry(framer_provider, &framer_provider_list, list) {

• if (device_match_of_node(framer_provider->dev, node))
  

• 	return framer_provider;
  

• }
• return ERR_PTR(-EPROBE_DEFER);

+}

+static struct framer *framer_of_get_from_provider(struct of_phandle_args *args) +{

• struct framer_provider *framer_provider;
• struct framer *framer;
• mutex_lock(&framer_provider_mutex);
• framer_provider = framer_provider_of_lookup(args->np);
• if (IS_ERR(framer_provider) || !try_module_get(framer_provider->owner)) {

• framer = ERR_PTR(-EPROBE_DEFER);
  

• goto end;
  

• }
• framer = framer_provider->of_xlate(framer_provider->dev, args);
• module_put(framer_provider->owner);

+end:

• mutex_unlock(&framer_provider_mutex);
• return framer;

+}

+static struct framer *framer_of_get_byphandle(struct device_node *np, const char *propname,

• 			      int index)
  

+{

• struct of_phandle_args args;
• struct framer *framer;
• int ret;
• ret = of_parse_phandle_with_args(np, propname, "#framer-cells", index, &args);
• if (ret)

• return ERR_PTR(-ENODEV);
  

• if (!of_device_is_available(args.np)) {

• framer = ERR_PTR(-ENODEV);
  

• goto out_node_put;
  

• }
• framer = framer_of_get_from_provider(&args);

+out_node_put:

• of_node_put(args.np);
• return framer;

+}

+static struct framer *framer_of_get_byparent(struct device_node *np, int index) +{

• struct of_phandle_args args;
• struct framer *framer;
• args.np = of_get_parent(np);
• args.args_count = 1;
• args.args[0] = index;
• while (args.np) {

• framer = framer_of_get_from_provider(&args);
  

• if (IS_ERR(framer) && PTR_ERR(framer) != -EPROBE_DEFER) {
  

• 	args.np = of_get_next_parent(args.np);
  

• 	continue;
  

• }
  

• of_node_put(args.np);
  

• return framer;
  

• }
• return ERR_PTR(-ENODEV);

+}

+/**

• • framer_get() - lookup and obtain a reference to a framer.
• • @dev: device that requests the framer
• • @con_id: name of the framer from device's point of view
• • Returns the framer driver, after getting a refcount to it; or
• • -ENODEV if there is no such framer. The caller is responsible for
• • calling framer_put() to release that count.
• */

+struct framer *framer_get(struct device *dev, const char *con_id) +{

• struct framer *framer = ERR_PTR(-ENODEV);
• struct device_link *link;
• int ret;
• if (dev->of_node) {

• if (con_id)
  

• 	framer = framer_of_get_byphandle(dev->of_node, con_id, 0);
  

• else
  

• 	framer = framer_of_get_byparent(dev->of_node, 0);
  

• }
• if (IS_ERR(framer))

• return framer;
  

• get_device(&framer->dev);
• if (!try_module_get(framer->ops->owner)) {

• ret = -EPROBE_DEFER;
  

• goto err_put_device;
  

• }
• link = device_link_add(dev, &framer->dev, DL_FLAG_STATELESS);
• if (!link) {

• dev_err(dev, "failed to create device_link to %s\n", dev_name(&framer->dev));
  

• ret = -EPROBE_DEFER;
  

• goto err_module_put;
  

• }
• return framer;

+err_module_put:

• module_put(framer->ops->owner);

+err_put_device:

• put_device(&framer->dev);
• return ERR_PTR(ret);

+} +EXPORT_SYMBOL_GPL(framer_get);

+/**

• • framer_put() - release the framer
• • @dev: device that wants to release this framer
• • @framer: the framer returned by framer_get()
• • Releases a refcount the caller received from framer_get().
• */

+void framer_put(struct device *dev, struct framer *framer) +{

• if (!framer || IS_ERR(framer))

• return;
  

• device_link_remove(dev, &framer->dev);
• module_put(framer->ops->owner);
• put_device(&framer->dev);

+} +EXPORT_SYMBOL_GPL(framer_put);

+static void devm_framer_put(struct device *dev, void *res) +{

• struct framer *framer = *(struct framer **)res;
• framer_put(dev, framer);

+}

+/**

• • devm_framer_get() - lookup and obtain a reference to a framer.
• • @dev: device that requests this framer
• • @con_id: name of the framer from device's point of view
• • Gets the framer using framer_get(), and associates a device with it using
• • devres. On driver detach, framer_put() function is invoked on the devres
• • data, then, devres data is freed.
• */

+struct framer *devm_framer_get(struct device *dev, const char *con_id) +{

• struct framer **ptr, *framer;
• ptr = devres_alloc(devm_framer_put, sizeof(*ptr), GFP_KERNEL);
• if (!ptr)

• return ERR_PTR(-ENOMEM);
  

• framer = framer_get(dev, con_id);
• if (!IS_ERR(framer)) {

• *ptr = framer;
  

• devres_add(dev, ptr);
  

• } else {

• devres_free(ptr);
  

• return framer;
  

• }
• return framer;

+} +EXPORT_SYMBOL_GPL(devm_framer_get);

+/**

• • devm_framer_optional_get() - lookup and obtain a reference to an optional
• • framer.
• • @dev: device that requests this framer
• • @con_id: name of the framer from device's point of view
• • Same as devm_framer_get() except that if the framer does not exist, it is not
• • considered an error and -ENODEV will not be returned. Instead the NULL framer
• • is returned, which can be passed to other framer consumer calls.
• */

+struct framer *devm_framer_optional_get(struct device *dev, const char *con_id) +{

• struct framer *framer = devm_framer_get(dev, con_id);
• if (PTR_ERR(framer) == -ENODEV)

• framer = NULL;
  

• return framer;

+} +EXPORT_SYMBOL_GPL(devm_framer_optional_get);

+static void framer_notify_status_work(struct work_struct *work) +{

• struct framer *framer = container_of(work, struct framer, notify_status_work);
• blocking_notifier_call_chain(&framer->notifier_list, FRAMER_EVENT_STATUS, NULL);

+}

+void framer_notify_status_change(struct framer *framer) +{

• if (!framer)

• return;
  

• /* Can be called from atomic context -> just schedule a task to call

• * blocking notifiers
  

• */
  

• queue_work(system_power_efficient_wq, &framer->notify_status_work);

+} +EXPORT_SYMBOL_GPL(framer_notify_status_change);

+/**

• • framer_create() - create a new framer
• • @dev: device that is creating the new framer
• • @node: device node of the framer. default to dev->of_node.
• • @ops: function pointers for performing framer operations
• • Called to create a framer using framer framework.
• */

+struct framer *framer_create(struct device *dev, struct device_node *node,

• 	     const struct framer_ops *ops)
  

+{

• int ret;
• int id;
• struct framer *framer;
• if (WARN_ON(!dev))

• return ERR_PTR(-EINVAL);
  

• /* get_status() is mandatory if the provider ask for polling status */
• if (WARN_ON((ops->flags & FRAMER_FLAG_POLL_STATUS) && !ops->get_status))

• return ERR_PTR(-EINVAL);
  

• framer = kzalloc(sizeof(*framer), GFP_KERNEL);
• if (!framer)

• return ERR_PTR(-ENOMEM);
  

• id = ida_simple_get(&framer_ida, 0, 0, GFP_KERNEL);
• if (id < 0) {

• dev_err(dev, "unable to get id\n");
  

• ret = id;
  

• goto free_framer;
  

• }
• device_initialize(&framer->dev);
• mutex_init(&framer->mutex);
• INIT_WORK(&framer->notify_status_work, framer_notify_status_work);
• INIT_DELAYED_WORK(&framer->polling_work, framer_polling_work);
• BLOCKING_INIT_NOTIFIER_HEAD(&framer->notifier_list);
• framer->dev.class = framer_class;
• framer->dev.parent = dev;
• framer->dev.of_node = node ? node : dev->of_node;
• framer->id = id;
• framer->ops = ops;
• ret = dev_set_name(&framer->dev, "framer-%s.%d", dev_name(dev), id);
• if (ret)

• goto put_dev;
  

• /* framer-supply */
• framer->pwr = regulator_get_optional(&framer->dev, "framer");
• if (IS_ERR(framer->pwr)) {

• ret = PTR_ERR(framer->pwr);
  

• if (ret == -EPROBE_DEFER)
  

• 	goto put_dev;
  

• framer->pwr = NULL;
  

• }
• ret = device_add(&framer->dev);
• if (ret)

• goto put_dev;
  

• if (pm_runtime_enabled(dev)) {

• pm_runtime_enable(&framer->dev);
  

• pm_runtime_no_callbacks(&framer->dev);
  

• }
• return framer;

+put_dev:

• put_device(&framer->dev); /* calls framer_release() which frees resources */
• return ERR_PTR(ret);

+free_framer:

• kfree(framer);
• return ERR_PTR(ret);

+} +EXPORT_SYMBOL_GPL(framer_create);

+/**

• • framer_destroy() - destroy the framer
• • @framer: the framer to be destroyed
• • Called to destroy the framer.
• */

+void framer_destroy(struct framer *framer) +{

• /* polling_work should already be stopped but if framer_exit() was not

• * called (bug), here it's the last time to do that ...
  

• */
  

• cancel_delayed_work_sync(&framer->polling_work);
• cancel_work_sync(&framer->notify_status_work);
• pm_runtime_disable(&framer->dev);
• device_unregister(&framer->dev); /* calls framer_release() which frees resources */

+} +EXPORT_SYMBOL_GPL(framer_destroy);

+static void devm_framer_destroy(struct device *dev, void *res) +{

• struct framer *framer = *(struct framer **)res;
• framer_destroy(framer);

+}

+/**

• • devm_framer_create() - create a new framer
• • @dev: device that is creating the new framer
• • @node: device node of the framer
• • @ops: function pointers for performing framer operations
• • Creates a new framer device adding it to the framer class.
• • While at that, it also associates the device with the framer using devres.
• • On driver detach, release function is invoked on the devres data,
• • then, devres data is freed.
• */

+struct framer *devm_framer_create(struct device *dev, struct device_node *node,

• 		  const struct framer_ops *ops)
  

+{

• struct framer **ptr, *framer;
• ptr = devres_alloc(devm_framer_destroy, sizeof(*ptr), GFP_KERNEL);
• if (!ptr)

• return ERR_PTR(-ENOMEM);
  

• framer = framer_create(dev, node, ops);
• if (!IS_ERR(framer)) {

• *ptr = framer;
  

• devres_add(dev, ptr);
  

• } else {

• devres_free(ptr);
  

• }
• return framer;

+} +EXPORT_SYMBOL_GPL(devm_framer_create);

+/**

• • framer_provider_simple_of_xlate() - returns the framer instance from framer provider
• • @dev: the framer provider device
• • @args: of_phandle_args (not used here)
• • Intended to be used by framer provider for the common case where #framer-cells is
• • 0. For other cases where #framer-cells is greater than '0', the framer provider
• • should provide a custom of_xlate function that reads the *args* and returns
• • the appropriate framer.
• */

+struct framer *framer_provider_simple_of_xlate(struct device *dev, struct of_phandle_args *args) +{

• struct framer *framer;
• struct class_dev_iter iter;
• class_dev_iter_init(&iter, framer_class, NULL, NULL);
• while ((dev = class_dev_iter_next(&iter))) {

• framer = dev_to_framer(dev);
  

• if (args->np != framer->dev.of_node)
  

• 	continue;
  

• class_dev_iter_exit(&iter);
  

• return framer;
  

• }
• class_dev_iter_exit(&iter);
• return ERR_PTR(-ENODEV);

+} +EXPORT_SYMBOL_GPL(framer_simple_of_xlate);

+/**

• • __framer_provider_of_register() - create/register framer provider with the framework
• • @dev: struct device of the framer provider
• • @owner: the module owner containing of_xlate
• • @of_xlate: function pointer to obtain framer instance from framer provider
• • Creates struct framer_provider from dev and of_xlate function pointer.
• • This is used in the case of dt boot for finding the framer instance from
• • framer provider.
• */

+struct framer_provider * +__framer_provider_of_register(struct device *dev, struct module *owner,

• 	      struct framer *(*of_xlate)(struct device *dev,
  

• 					 struct of_phandle_args *args))
  

+{

• struct framer_provider *framer_provider;
• framer_provider = kzalloc(sizeof(*framer_provider), GFP_KERNEL);
• if (!framer_provider)

• return ERR_PTR(-ENOMEM);
  

• framer_provider->dev = dev;
• framer_provider->owner = owner;
• framer_provider->of_xlate = of_xlate;
• of_node_get(framer_provider->dev->of_node);
• mutex_lock(&framer_provider_mutex);
• list_add_tail(&framer_provider->list, &framer_provider_list);
• mutex_unlock(&framer_provider_mutex);
• return framer_provider;

+} +EXPORT_SYMBOL_GPL(__framer_provider_of_register);

+/**

• • framer_provider_of_unregister() - unregister framer provider from the framework
• • @framer_provider: framer provider returned by framer_provider_of_register()
• • Removes the framer_provider created using framer_provider_of_register().
• */

+void framer_provider_of_unregister(struct framer_provider *framer_provider) +{

• if (IS_ERR(framer_provider))

• return;
  

• mutex_lock(&framer_provider_mutex);
• list_del(&framer_provider->list);
• of_node_put(framer_provider->dev->of_node);
• kfree(framer_provider);
• mutex_unlock(&framer_provider_mutex);

+} +EXPORT_SYMBOL_GPL(of_framer_provider_unregister);

+static void devm_framer_provider_of_unregister(struct device *dev, void *res) +{

• struct framer_provider *framer_provider = *(struct framer_provider **)res;
• framer_provider_of_unregister(framer_provider);

+}

+/**

• • __devm_framer_provider_of_register() - create/register framer provider with
• • the framework
• • @dev: struct device of the framer provider
• • @owner: the module owner containing of_xlate
• • @of_xlate: function pointer to obtain framer instance from framer provider
• • Creates struct framer_provider from dev and of_xlate function pointer.
• • This is used in the case of dt boot for finding the framer instance from
• • framer provider. While at that, it also associates the device with the
• • framer provider using devres. On driver detach, release function is invoked
• • on the devres data, then, devres data is freed.
• */

+struct framer_provider * +__devm_framer_provider_of_register(struct device *dev, struct module *owner,

• 		   struct framer *(*of_xlate)(struct device *dev,
  

• 					      struct of_phandle_args *args))
  

+{

• struct framer_provider **ptr, *framer_provider;
• ptr = devres_alloc(devm_framer_provider_of_unregister, sizeof(*ptr), GFP_KERNEL);
• if (!ptr)

• return ERR_PTR(-ENOMEM);
  

• framer_provider = __framer_provider_of_register(dev, owner, of_xlate);
• if (!IS_ERR(framer_provider)) {

• *ptr = framer_provider;
  

• devres_add(dev, ptr);
  

• } else {

• devres_free(ptr);
  

• }
• return framer_provider;

+} +EXPORT_SYMBOL_GPL(__devm_framer_provider_of_register);

+/**

• • framer_release() - release the framer
• • @dev: the dev member within framer
• • When the last reference to the device is removed, it is called
• • from the embedded kobject as release method.
• */

+static void framer_release(struct device *dev) +{

• struct framer *framer;
• framer = dev_to_framer(dev);
• regulator_put(framer->pwr);
• ida_simple_remove(&framer_ida, framer->id);
• kfree(framer);

+}

+static int __init framer_core_init(void) +{

• framer_class = class_create("framer");
• if (IS_ERR(framer_class)) {

• pr_err("failed to create framer class (%pe)\n", framer_class);
  

• return PTR_ERR(framer_class);
  

• }
• framer_class->dev_release = framer_release;
• return 0;

+} +device_initcall(framer_core_init); diff --git a/include/linux/framer/framer-provider.h b/include/linux/framer/framer-provider.h new file mode 100644 index 000000000000..941a343c3ba7 --- /dev/null +++ b/include/linux/framer/framer-provider.h @@ -0,0 +1,194 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/*

• • Generic framer profider header file
• • Copyright 2023 CS GROUP France
• • Author: Herve Codina herve.codina@bootlin.com
• */

+#ifndef __DRIVERS_PROVIDER_FRAMER_H +#define __DRIVERS_PROVIDER_FRAMER_H

+#include <linux/export.h> +#include <linux/framer/framer.h> +#include <linux/types.h>

+#define FRAMER_FLAG_POLL_STATUS BIT(0)

+/**

• • struct framer_ops - set of function pointers for performing framer operations
• • @init: operation to be performed for initializing the framer
• • @exit: operation to be performed while exiting
• • @power_on: powering on the framer
• • @power_off: powering off the framer
• • @flags: OR-ed flags (FRAMER_FLAG_*) to ask for core functionality

• •      - @FRAMER_FLAG_POLL_STATUS:
    

• •        Ask the core to perfom a polling to get the framer status and
    

• •        notify consumers on change.
    

• •        The framer should call @framer_notify_status_change() when it
    

• •        detects a status change. This is usally done using interrutps.
    

• •        If the framer cannot detect this change, it can ask the core for
    

• •        a status polling. The core will call @get_status() periodically
    

• •        and, on change detected, it will notify the consumer.
    

• •        the @get_status()
    

• • @owner: the module owner containing the ops
• */

+struct framer_ops {

• int (*init)(struct framer *framer);
• void (*exit)(struct framer *framer);
• int (*power_on)(struct framer *framer);
• int (*power_off)(struct framer *framer);
• /**

• * @get_status:
  

• *
  

• * Optional.
  

• *
  

• * Used to get the framer status. framer_init() must have
  

• * been called on the framer.
  

• *
  

• * Returns: 0 if successful, an negative error code otherwise
  

• */
  

• int (*get_status)(struct framer *framer, struct framer_status *status);
• /**

• * @set_config:
  

• *
  

• * Optional.
  

• *
  

• * Used to set the framer configuration. framer_init() must have
  

• * been called on the framer.
  

• *
  

• * Returns: 0 if successful, an negative error code otherwise
  

• */
  

• int (*set_config)(struct framer *framer, const struct framer_config *config);
• /**

• * @get_config:
  

• *
  

• * Optional.
  

• *
  

• * Used to get the framer configuration. framer_init() must have
  

• * been called on the framer.
  

• *
  

• * Returns: 0 if successful, an negative error code otherwise
  

• */
  

• int (*get_config)(struct framer *framer, struct framer_config *config);
• u32 flags;
• struct module *owner;

+};

+/**

• • struct framer_provider - represents the framer provider
• • @dev: framer provider device
• • @children: can be used to override the default (dev->of_node) child node
• • @owner: the module owner having of_xlate
• • @list: to maintain a linked list of framer providers
• • @of_xlate: function pointer to obtain framer instance from framer pointer
• */

+struct framer_provider {

• struct device *dev;
• struct module *owner;
• struct list_head list;
• struct framer * (*of_xlate)(struct device *dev,

• 		    struct of_phandle_args *args);
  

+};

+static inline void framer_set_drvdata(struct framer *framer, void *data) +{

• dev_set_drvdata(&framer->dev, data);

+}

+static inline void *framer_get_drvdata(struct framer *framer) +{

• return dev_get_drvdata(&framer->dev);

+}

+#if IS_ENABLED(CONFIG_GENERIC_FRAMER)

+/* Create and destroy a framer */ +struct framer *framer_create(struct device *dev, struct device_node *node,

• 	     const struct framer_ops *ops);
  

+void framer_destroy(struct framer *framer);

+/* devm version */ +struct framer *devm_framer_create(struct device *dev, struct device_node *node,

• 		  const struct framer_ops *ops);
  

+struct framer *framer_provider_simple_of_xlate(struct device *dev,

• 			       struct of_phandle_args *args);
  

+struct framer_provider * +__framer_provider_of_register(struct device *dev, struct module *owner,

• 	      struct framer *(*of_xlate)(struct device *dev,
  

• 					 struct of_phandle_args *args));
  

+void framer_provider_of_unregister(struct framer_provider *framer_provider);

+struct framer_provider * +__devm_framer_provider_of_register(struct device *dev, struct module *owner,

• 		   struct framer *(*of_xlate)(struct device *dev,
  

• 					      struct of_phandle_args *args));
  

+void framer_notify_status_change(struct framer *framer);

+#else /* IS_ENABLED(CONFIG_GENERIC_FRAMER) */

+static inline struct framer *framer_create(struct device *dev, struct device_node *node,

• 			   const struct framer_ops *ops)
  

+{

• return ERR_PTR(-ENOSYS);

+}

+static inline void framer_destroy(struct framer *framer) +{ +}

+/* devm version */ +static inline struct framer *devm_framer_create(struct device *dev, struct device_node *node,

• 				const struct framer_ops *ops)
  

+{

• return ERR_PTR(-ENOSYS);

+}

+static inline struct framer *framer_provider_simple_of_xlate(struct device *dev,

• 					     struct of_phandle_args *args)
  

+{

• return ERR_PTR(-ENOSYS);

+}

+static inline struct framer_provider * +__framer_provider_of_register(struct device *dev, struct module *owner,

• 	      struct framer *(*of_xlate)(struct device *dev,
  

• 					 struct of_phandle_args *args))
  

+{

• return ERR_PTR(-ENOSYS);

+}

+void framer_provider_of_unregister(struct framer_provider *framer_provider) +{ +}

+static inline struct framer_provider * +__devm_framer_provider_of_register(struct device *dev, struct module *owner,

• 		   struct framer *(*of_xlate)(struct device *dev,
  

• 					      struct of_phandle_args *args))
  

+{

• return ERR_PTR(-ENOSYS);

+}

+void framer_notify_status_change(struct framer *framer) +{ +}

+#endif /* IS_ENABLED(CONFIG_GENERIC_FRAMER) */

+#define framer_provider_of_register(dev, xlate) \

• __framer_provider_of_register((dev), THIS_MODULE, (xlate))

+#define devm_framer_provider_of_register(dev, xlate) \

• __devm_framer_provider_of_register((dev), THIS_MODULE, (xlate))

+#endif /* __DRIVERS_PROVIDER_FRAMER_H */ diff --git a/include/linux/framer/framer.h b/include/linux/framer/framer.h new file mode 100644 index 000000000000..b735027f6801 --- /dev/null +++ b/include/linux/framer/framer.h @@ -0,0 +1,215 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/*

• • Generic framer header file
• • Copyright 2023 CS GROUP France
• • Author: Herve Codina herve.codina@bootlin.com
• */

+#ifndef __DRIVERS_FRAMER_H +#define __DRIVERS_FRAMER_H

+#include <linux/err.h> +#include <linux/mutex.h> +#include <linux/notifier.h> +#include <linux/of.h> +#include <linux/device.h> +#include <linux/workqueue.h>

+/**

• • enum framer_iface - Framer interface
• */

+enum framer_iface {

• FRAMER_IFACE_E1, /* E1 interface */
• FRAMER_IFACE_T1, /* T1 interface */

+};

+/**

• • enum framer_clock_mode - Framer clock mode
• */

+enum framer_clock_type {

• FRAMER_CLOCK_EXT, /* External clock */
• FRAMER_CLOCK_INT, /* Internal clock */

+};

+/**

• • struct framer_configuration - Framer configuration
• • @line_iface: Framer line interface
• • @clock_mode: Framer clock type
• • @clock_rate: Framer clock rate
• */

+struct framer_config {

• enum framer_iface iface;
• enum framer_clock_type clock_type;
• unsigned long line_clock_rate;

+};

+/**

• • struct framer_status - Framer status
• • @link_is_on: Framer link state. true, the link is on, false, the link is off.
• */

+struct framer_status {

• bool link_is_on;

+};

+/**

• • framer_event - event available for notification
• */

+enum framer_event {

• FRAMER_EVENT_STATUS, /* Event notified on framer_status changes */

+};

+/**

• • struct framer - represents the framer device
• • @dev: framer device
• • @id: id of the framer device
• • @ops: function pointers for performing framer operations
• • @mutex: mutex to protect framer_ops
• • @init_count: used to protect when the framer is used by multiple consumers
• • @power_count: used to protect when the framer is used by multiple consumers
• • @pwr: power regulator associated with the framer
• • @polling_task: polling task used if framer notifier operations are not provided
• • @polling_notifier_list: notifier list used by the polling task
• • @prev_status: previous read status used by the polling task to detect changes
• */

+struct framer {

• struct device dev;
• int id;
• const struct framer_ops *ops;
• struct mutex mutex; /* Protect framer */
• int init_count;
• int power_count;
• struct regulator *pwr;
• struct work_struct notify_status_work;
• struct blocking_notifier_head notifier_list;
• struct delayed_work polling_work;
• struct framer_status prev_status;

+};

+#if IS_ENABLED(CONFIG_GENERIC_FRAMER) +int framer_pm_runtime_get(struct framer *framer); +int framer_pm_runtime_get_sync(struct framer *framer); +int framer_pm_runtime_put(struct framer *framer); +int framer_pm_runtime_put_sync(struct framer *framer); +int framer_init(struct framer *framer); +int framer_exit(struct framer *framer); +int framer_power_on(struct framer *framer); +int framer_power_off(struct framer *framer); +int framer_get_status(struct framer *framer, struct framer_status *status); +int framer_get_config(struct framer *framer, struct framer_config *config); +int framer_set_config(struct framer *framer, const struct framer_config *config); +int framer_notifier_register(struct framer *framer, struct notifier_block *nb); +int framer_notifier_unregister(struct framer *framer, struct notifier_block *nb);

+struct framer *framer_get(struct device *dev, const char *con_id); +void framer_put(struct device *dev, struct framer *framer);

+struct framer *devm_framer_get(struct device *dev, const char *con_id); +struct framer *devm_framer_optional_get(struct device *dev, const char *con_id); +#else +static inline int framer_pm_runtime_get(struct framer *framer) +{

• if (!framer)

• return 0;
  

• return -ENOSYS;

+}

+static inline int framer_pm_runtime_get_sync(struct framer *framer) +{

• if (!framer)

• return 0;
  

• return -ENOSYS;

+}

+static inline int framer_pm_runtime_put(struct framer *framer) +{

• if (!framer)

• return 0;
  

• return -ENOSYS;

+}

+static inline int framer_pm_runtime_put_sync(struct framer *framer) +{

• if (!framer)

• return 0;
  

• return -ENOSYS;

+}

+static inline int framer_init(struct framer *framer) +{

• if (!framer)

• return 0;
  

• return -ENOSYS;

+}

+static inline int framer_exit(struct framer *framer) +{

• if (!framer)

• return 0;
  

• return -ENOSYS;

+}

+static inline int framer_power_on(struct framer *framer) +{

• if (!framer)

• return 0;
  

• return -ENOSYS;

+}

+static inline int framer_power_off(struct framer *framer) +{

• if (!framer)

• return 0;
  

• return -ENOSYS;

+}

+static inline int framer_get_status(struct framer *framer, struct framer_status *status) +{

• return -ENOSYS;

+}

+static inline int framer_get_config(struct framer *framer, struct framer_config *config) +{

• return -ENOSYS;

+}

+static inline int framer_set_config(struct framer *framer, const struct framer_config *config) +{

• if (!framer)

• return 0;
  

• return -ENOSYS;

+}

+static inline int framer_notifier_register(struct framer *framer,

• 			   struct notifier_block *nb)
  

+{

• if (!framer)

• return 0;
  

• return -ENOSYS;

+}

+static inline int framer_notifier_unregister(struct framer *framer,

• 			     struct notifier_block *nb)
  

+{

• if (!framer)

• return 0;
  

• return -ENOSYS;

+}

+static inline struct framer *devm_framer_get(struct device *dev, const char *con_id) +{

• return ERR_PTR(-ENOSYS);

+}

+static inline struct framer *devm_framer_optional_get(struct device *dev, const char *con_id) +{

• return NULL;

+}

+#endif

+#endif /* __DRIVERS_FRAMER_H */