Commit 3114b075 authored by Oleksij Rempel's avatar Oleksij Rempel Committed by Jakub Kicinski
Browse files

net: add framework to support Ethernet PSE and PDs devices 



This framework was create with intention to provide support for Ethernet PSE
(Power Sourcing Equipment) and PDs (Powered Device).

At current step this patch implements generic PSE support for PoDL (Power over
Data Lines 802.3bu) specification with reserving name space for PD devices as
well.

This framework can be extended to support 802.3af and 802.3at "Power via the
Media Dependent Interface" (or PoE/Power over Ethernet)

Signed-off-by: default avatarOleksij Rempel <o.rempel@pengutronix.de>
Reviewed-by: default avatarAndrew Lunn <andrew@lunn.ch>
Signed-off-by: default avatarJakub Kicinski <kuba@kernel.org>
parent e9554b31

drivers/net/Kconfig

+2 −0
Original line number Diff line number Diff line
@@ -500,6 +500,8 @@ config NET_SB1000 


source "drivers/net/phy/Kconfig"



source "drivers/net/pse-pd/Kconfig"



source "drivers/net/can/Kconfig"



source "drivers/net/mctp/Kconfig"

drivers/net/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -23,6 +23,7 @@ obj-$(CONFIG_NET) += loopback.o 
obj-$(CONFIG_NETDEV_LEGACY_INIT) += Space.o

obj-$(CONFIG_NETCONSOLE) += netconsole.o

obj-y += phy/

obj-y += pse-pd/

obj-y += mdio/

obj-y += pcs/

obj-$(CONFIG_RIONET) += rionet.o

drivers/net/pse-pd/Kconfig

0 → 100644
+11 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0-only

#

# Ethernet Power Sourcing Equipment drivers

#



menuconfig PSE_CONTROLLER

	bool "Ethernet Power Sourcing Equipment Support"

	help

	  Generic Power Sourcing Equipment Controller support.



	  If unsure, say no.

drivers/net/pse-pd/Makefile

0 → 100644
+4 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0-only

# Makefile for Linux PSE drivers



obj-$(CONFIG_PSE_CONTROLLER) += pse_core.o

drivers/net/pse-pd/pse_core.c

0 → 100644
+256 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

//

// Framework for Ethernet Power Sourcing Equipment

//

// Copyright (c) 2022 Pengutronix, Oleksij Rempel <kernel@pengutronix.de>

//



#include <linux/device.h>

#include <linux/of.h>

#include <linux/pse-pd/pse.h>



static DEFINE_MUTEX(pse_list_mutex);

static LIST_HEAD(pse_controller_list);



/**

 * struct pse_control - a PSE control

 * @pcdev: a pointer to the PSE controller device

 *         this PSE control belongs to

 * @list: list entry for the pcdev's PSE controller list

 * @id: ID of the PSE line in the PSE controller device

 * @refcnt: Number of gets of this pse_control

 */

struct pse_control {

	struct pse_controller_dev *pcdev;

	struct list_head list;

	unsigned int id;

	struct kref refcnt;

};



/**

 * of_pse_zero_xlate - dummy function for controllers with one only control

 * @pcdev: a pointer to the PSE controller device

 * @pse_spec: PSE line specifier as found in the device tree

 *

 * This static translation function is used by default if of_xlate in

 * :c:type:`pse_controller_dev` is not set. It is useful for all PSE

 * controllers with #pse-cells = <0>.

 */

static int of_pse_zero_xlate(struct pse_controller_dev *pcdev,

			     const struct of_phandle_args *pse_spec)

{

	return 0;

}



/**

 * of_pse_simple_xlate - translate pse_spec to the PSE line number

 * @pcdev: a pointer to the PSE controller device

 * @pse_spec: PSE line specifier as found in the device tree

 *

 * This static translation function is used by default if of_xlate in

 * :c:type:`pse_controller_dev` is not set. It is useful for all PSE

 * controllers with 1:1 mapping, where PSE lines can be indexed by number

 * without gaps.

 */

static int of_pse_simple_xlate(struct pse_controller_dev *pcdev,

			       const struct of_phandle_args *pse_spec)

{

	if (pse_spec->args[0] >= pcdev->nr_lines)

		return -EINVAL;



	return pse_spec->args[0];

}



/**

 * pse_controller_register - register a PSE controller device

 * @pcdev: a pointer to the initialized PSE controller device

 */

int pse_controller_register(struct pse_controller_dev *pcdev)

{

	if (!pcdev->of_xlate) {

		if (pcdev->of_pse_n_cells == 0)

			pcdev->of_xlate = of_pse_zero_xlate;

		else if (pcdev->of_pse_n_cells == 1)

			pcdev->of_xlate = of_pse_simple_xlate;

	}



	mutex_init(&pcdev->lock);

	INIT_LIST_HEAD(&pcdev->pse_control_head);



	mutex_lock(&pse_list_mutex);

	list_add(&pcdev->list, &pse_controller_list);

	mutex_unlock(&pse_list_mutex);



	return 0;

}

EXPORT_SYMBOL_GPL(pse_controller_register);



/**

 * pse_controller_unregister - unregister a PSE controller device

 * @pcdev: a pointer to the PSE controller device

 */

void pse_controller_unregister(struct pse_controller_dev *pcdev)

{

	mutex_lock(&pse_list_mutex);

	list_del(&pcdev->list);

	mutex_unlock(&pse_list_mutex);

}

EXPORT_SYMBOL_GPL(pse_controller_unregister);



static void devm_pse_controller_release(struct device *dev, void *res)

{

	pse_controller_unregister(*(struct pse_controller_dev **)res);

}



/**

 * devm_pse_controller_register - resource managed pse_controller_register()

 * @dev: device that is registering this PSE controller

 * @pcdev: a pointer to the initialized PSE controller device

 *

 * Managed pse_controller_register(). For PSE controllers registered by

 * this function, pse_controller_unregister() is automatically called on

 * driver detach. See pse_controller_register() for more information.

 */

int devm_pse_controller_register(struct device *dev,

				 struct pse_controller_dev *pcdev)

{

	struct pse_controller_dev **pcdevp;

	int ret;



	pcdevp = devres_alloc(devm_pse_controller_release, sizeof(*pcdevp),

			      GFP_KERNEL);

	if (!pcdevp)

		return -ENOMEM;



	ret = pse_controller_register(pcdev);

	if (ret) {

		devres_free(pcdevp);

		return ret;

	}



	*pcdevp = pcdev;

	devres_add(dev, pcdevp);



	return 0;

}

EXPORT_SYMBOL_GPL(devm_pse_controller_register);



/* PSE control section */



static void __pse_control_release(struct kref *kref)

{

	struct pse_control *psec = container_of(kref, struct pse_control,

						  refcnt);



	lockdep_assert_held(&pse_list_mutex);



	module_put(psec->pcdev->owner);



	list_del(&psec->list);

	kfree(psec);

}



static void __pse_control_put_internal(struct pse_control *psec)

{

	lockdep_assert_held(&pse_list_mutex);



	kref_put(&psec->refcnt, __pse_control_release);

}



/**

 * pse_control_put - free the PSE control

 * @psec: PSE control pointer

 */

void pse_control_put(struct pse_control *psec)

{

	if (IS_ERR_OR_NULL(psec))

		return;



	mutex_lock(&pse_list_mutex);

	__pse_control_put_internal(psec);

	mutex_unlock(&pse_list_mutex);

}

EXPORT_SYMBOL_GPL(pse_control_put);



static struct pse_control *

pse_control_get_internal(struct pse_controller_dev *pcdev, unsigned int index)

{

	struct pse_control *psec;



	lockdep_assert_held(&pse_list_mutex);



	list_for_each_entry(psec, &pcdev->pse_control_head, list) {

		if (psec->id == index) {

			kref_get(&psec->refcnt);

			return psec;

		}

	}



	psec = kzalloc(sizeof(*psec), GFP_KERNEL);

	if (!psec)

		return ERR_PTR(-ENOMEM);



	if (!try_module_get(pcdev->owner)) {

		kfree(psec);

		return ERR_PTR(-ENODEV);

	}



	psec->pcdev = pcdev;

	list_add(&psec->list, &pcdev->pse_control_head);

	psec->id = index;

	kref_init(&psec->refcnt);



	return psec;

}



struct pse_control *

of_pse_control_get(struct device_node *node)

{

	struct pse_controller_dev *r, *pcdev;

	struct of_phandle_args args;

	struct pse_control *psec;

	int psec_id;

	int ret;



	if (!node)

		return ERR_PTR(-EINVAL);



	ret = of_parse_phandle_with_args(node, "pses", "#pse-cells", 0, &args);

	if (ret)

		return ERR_PTR(ret);



	mutex_lock(&pse_list_mutex);

	pcdev = NULL;

	list_for_each_entry(r, &pse_controller_list, list) {

		if (args.np == r->dev->of_node) {

			pcdev = r;

			break;

		}

	}



	if (!pcdev) {

		psec = ERR_PTR(-EPROBE_DEFER);

		goto out;

	}



	if (WARN_ON(args.args_count != pcdev->of_pse_n_cells)) {

		psec = ERR_PTR(-EINVAL);

		goto out;

	}



	psec_id = pcdev->of_xlate(pcdev, &args);

	if (psec_id < 0) {

		psec = ERR_PTR(psec_id);

		goto out;

	}



	/* pse_list_mutex also protects the pcdev's pse_control list */

	psec = pse_control_get_internal(pcdev, psec_id);



out:

	mutex_unlock(&pse_list_mutex);

	of_node_put(args.np);



	return psec;

}

EXPORT_SYMBOL_GPL(of_pse_control_get);