Unverified Commit 3f925cd6 authored by Bjorn Helgaas's avatar Bjorn Helgaas Committed by Krzysztof Wilczyński
Browse files

PCI/pwrctrl: Rename pwrctrl functions and structures 

Rename pwrctrl functions and structures from "pwrctl" to "pwrctrl" to match
the similar file renames.

Link: https://lore.kernel.org/r/20241115214428.2061153-3-helgaas@kernel.org


Signed-off-by: default avatarBjorn Helgaas <bhelgaas@google.com>
Signed-off-by: default avatarKrzysztof Wilczyński <kwilczynski@kernel.org>
Acked-by: default avatarKrzysztof Wilczyński <kw@linux.com>
parent b88cbaaa

drivers/pci/bus.c

+13 −12
Original line number Diff line number Diff line
@@ -322,10 +322,10 @@ void __weak pcibios_resource_survey_bus(struct pci_bus *bus) { } 
void __weak pcibios_bus_add_device(struct pci_dev *pdev) { }



/*

 * Create pwrctl devices (if required) for the PCI devices to handle the power

 * Create pwrctrl devices (if required) for the PCI devices to handle the power

 * state.

 */

static void pci_pwrctl_create_devices(struct pci_dev *dev)

static void pci_pwrctrl_create_devices(struct pci_dev *dev)

{

	struct device_node *np = dev_of_node(&dev->dev);

	struct device *parent = &dev->dev;
@@ -337,23 +337,24 @@ static void pci_pwrctl_create_devices(struct pci_dev *dev) 
	 */

	if (np && pci_is_bridge(dev)) {

		/*

		 * Now look for the child PCI device nodes and create pwrctl

		 * devices for them. The pwrctl device drivers will manage the

		 * Now look for the child PCI device nodes and create pwrctrl

		 * devices for them. The pwrctrl device drivers will manage the

		 * power state of the devices.

		 */

		for_each_available_child_of_node_scoped(np, child) {

			/*

			 * First check whether the pwrctl device really needs to

			 * be created or not. This is decided based on at least

			 * one of the power supplies being defined in the

			 * devicetree node of the device.

			 * First check whether the pwrctrl device really

			 * needs to be created or not. This is decided

			 * based on at least one of the power supplies

			 * being defined in the devicetree node of the

			 * device.

			 */

			if (!of_pci_supply_present(child)) {

				pci_dbg(dev, "skipping OF node: %s\n", child->name);

				return;

			}



			/* Now create the pwrctl device */

			/* Now create the pwrctrl device */

			pdev = of_platform_device_create(child, NULL, parent);

			if (!pdev)

				pci_err(dev, "failed to create OF node: %s\n", child->name);
@@ -385,12 +386,12 @@ void pci_bus_add_device(struct pci_dev *dev) 
	pci_proc_attach_device(dev);

	pci_bridge_d3_update(dev);



	pci_pwrctl_create_devices(dev);

	pci_pwrctrl_create_devices(dev);



	/*

	 * If the PCI device is associated with a pwrctl device with a

	 * If the PCI device is associated with a pwrctrl device with a

	 * power supply, create a device link between the PCI device and

	 * pwrctl device.  This ensures that pwrctl drivers are probed

	 * pwrctrl device.  This ensures that pwrctrl drivers are probed

	 * before PCI client drivers.

	 */

	pdev = of_find_device_by_node(dn);

drivers/pci/pwrctrl/core.c

+39 −38
Original line number Diff line number Diff line
@@ -11,13 +11,13 @@ 
#include <linux/property.h>

#include <linux/slab.h>



static int pci_pwrctl_notify(struct notifier_block *nb, unsigned long action,

static int pci_pwrctrl_notify(struct notifier_block *nb, unsigned long action,

			      void *data)

{

	struct pci_pwrctl *pwrctl = container_of(nb, struct pci_pwrctl, nb);

	struct pci_pwrctrl *pwrctrl = container_of(nb, struct pci_pwrctrl, nb);

	struct device *dev = data;



	if (dev_fwnode(dev) != dev_fwnode(pwrctl->dev))

	if (dev_fwnode(dev) != dev_fwnode(pwrctrl->dev))

		return NOTIFY_DONE;



	switch (action) {
@@ -40,31 +40,32 @@ static int pci_pwrctl_notify(struct notifier_block *nb, unsigned long action, 


static void rescan_work_func(struct work_struct *work)

{

	struct pci_pwrctl *pwrctl = container_of(work, struct pci_pwrctl, work);

	struct pci_pwrctrl *pwrctrl = container_of(work,

						   struct pci_pwrctrl, work);



	pci_lock_rescan_remove();

	pci_rescan_bus(to_pci_dev(pwrctl->dev->parent)->bus);

	pci_rescan_bus(to_pci_dev(pwrctrl->dev->parent)->bus);

	pci_unlock_rescan_remove();

}



/**

 * pci_pwrctl_init() - Initialize the PCI power control context struct

 * pci_pwrctrl_init() - Initialize the PCI power control context struct

 *

 * @pwrctl: PCI power control data

 * @pwrctrl: PCI power control data

 * @dev: Parent device

 */

void pci_pwrctl_init(struct pci_pwrctl *pwrctl, struct device *dev)

void pci_pwrctrl_init(struct pci_pwrctrl *pwrctrl, struct device *dev)

{

	pwrctl->dev = dev;

	INIT_WORK(&pwrctl->work, rescan_work_func);

	pwrctrl->dev = dev;

	INIT_WORK(&pwrctrl->work, rescan_work_func);

}

EXPORT_SYMBOL_GPL(pci_pwrctl_init);

EXPORT_SYMBOL_GPL(pci_pwrctrl_init);



/**

 * pci_pwrctl_device_set_ready() - Notify the pwrctl subsystem that the PCI

 * pci_pwrctrl_device_set_ready() - Notify the pwrctrl subsystem that the PCI

 * device is powered-up and ready to be detected.

 *

 * @pwrctl: PCI power control data.

 * @pwrctrl: PCI power control data.

 *

 * Returns:

 * 0 on success, negative error number on error.
@@ -74,31 +75,31 @@ EXPORT_SYMBOL_GPL(pci_pwrctl_init); 
 * that the bus rescan was successfully started. The device will get bound to

 * its PCI driver asynchronously.

 */

int pci_pwrctl_device_set_ready(struct pci_pwrctl *pwrctl)

int pci_pwrctrl_device_set_ready(struct pci_pwrctrl *pwrctrl)

{

	int ret;



	if (!pwrctl->dev)

	if (!pwrctrl->dev)

		return -ENODEV;



	pwrctl->nb.notifier_call = pci_pwrctl_notify;

	ret = bus_register_notifier(&pci_bus_type, &pwrctl->nb);

	pwrctrl->nb.notifier_call = pci_pwrctrl_notify;

	ret = bus_register_notifier(&pci_bus_type, &pwrctrl->nb);

	if (ret)

		return ret;



	schedule_work(&pwrctl->work);

	schedule_work(&pwrctrl->work);



	return 0;

}

EXPORT_SYMBOL_GPL(pci_pwrctl_device_set_ready);

EXPORT_SYMBOL_GPL(pci_pwrctrl_device_set_ready);



/**

 * pci_pwrctl_device_unset_ready() - Notify the pwrctl subsystem that the PCI

 * pci_pwrctrl_device_unset_ready() - Notify the pwrctrl subsystem that the PCI

 * device is about to be powered-down.

 *

 * @pwrctl: PCI power control data.

 * @pwrctrl: PCI power control data.

 */

void pci_pwrctl_device_unset_ready(struct pci_pwrctl *pwrctl)

void pci_pwrctrl_device_unset_ready(struct pci_pwrctrl *pwrctrl)

{

	/*

	 * We don't have to delete the link here. Typically, this function
@@ -106,41 +107,41 @@ void pci_pwrctl_device_unset_ready(struct pci_pwrctl *pwrctl) 
	 * it is being detached then the child PCI device must have already

	 * been unbound too or the device core wouldn't let us unbind.

	 */

	bus_unregister_notifier(&pci_bus_type, &pwrctl->nb);

	bus_unregister_notifier(&pci_bus_type, &pwrctrl->nb);

}

EXPORT_SYMBOL_GPL(pci_pwrctl_device_unset_ready);

EXPORT_SYMBOL_GPL(pci_pwrctrl_device_unset_ready);



static void devm_pci_pwrctl_device_unset_ready(void *data)

static void devm_pci_pwrctrl_device_unset_ready(void *data)

{

	struct pci_pwrctl *pwrctl = data;

	struct pci_pwrctrl *pwrctrl = data;



	pci_pwrctl_device_unset_ready(pwrctl);

	pci_pwrctrl_device_unset_ready(pwrctrl);

}



/**

 * devm_pci_pwrctl_device_set_ready - Managed variant of

 * pci_pwrctl_device_set_ready().

 * devm_pci_pwrctrl_device_set_ready - Managed variant of

 * pci_pwrctrl_device_set_ready().

 *

 * @dev: Device managing this pwrctl provider.

 * @pwrctl: PCI power control data.

 * @dev: Device managing this pwrctrl provider.

 * @pwrctrl: PCI power control data.

 *

 * Returns:

 * 0 on success, negative error number on error.

 */

int devm_pci_pwrctl_device_set_ready(struct device *dev,

				     struct pci_pwrctl *pwrctl)

int devm_pci_pwrctrl_device_set_ready(struct device *dev,

				      struct pci_pwrctrl *pwrctrl)

{

	int ret;



	ret = pci_pwrctl_device_set_ready(pwrctl);

	ret = pci_pwrctrl_device_set_ready(pwrctrl);

	if (ret)

		return ret;



	return devm_add_action_or_reset(dev,

					devm_pci_pwrctl_device_unset_ready,

					pwrctl);

					devm_pci_pwrctrl_device_unset_ready,

					pwrctrl);

}

EXPORT_SYMBOL_GPL(devm_pci_pwrctl_device_set_ready);

EXPORT_SYMBOL_GPL(devm_pci_pwrctrl_device_set_ready);



MODULE_AUTHOR("Bartosz Golaszewski <bartosz.golaszewski@linaro.org>");

MODULE_DESCRIPTION("PCI Device Power Control core driver");

drivers/pci/pwrctrl/pci-pwrctrl-pwrseq.c

+16 −16
Original line number Diff line number Diff line
@@ -13,21 +13,21 @@ 
#include <linux/slab.h>

#include <linux/types.h>



struct pci_pwrctl_pwrseq_data {

	struct pci_pwrctl ctx;

struct pci_pwrctrl_pwrseq_data {

	struct pci_pwrctrl ctx;

	struct pwrseq_desc *pwrseq;

};



static void devm_pci_pwrctl_pwrseq_power_off(void *data)

static void devm_pci_pwrctrl_pwrseq_power_off(void *data)

{

	struct pwrseq_desc *pwrseq = data;



	pwrseq_power_off(pwrseq);

}



static int pci_pwrctl_pwrseq_probe(struct platform_device *pdev)

static int pci_pwrctrl_pwrseq_probe(struct platform_device *pdev)

{

	struct pci_pwrctl_pwrseq_data *data;

	struct pci_pwrctrl_pwrseq_data *data;

	struct device *dev = &pdev->dev;

	int ret;
@@ -45,22 +45,22 @@ static int pci_pwrctl_pwrseq_probe(struct platform_device *pdev) 
		return dev_err_probe(dev, ret,

				     "Failed to power-on the device\n");



	ret = devm_add_action_or_reset(dev, devm_pci_pwrctl_pwrseq_power_off,

	ret = devm_add_action_or_reset(dev, devm_pci_pwrctrl_pwrseq_power_off,

				       data->pwrseq);

	if (ret)

		return ret;



	pci_pwrctl_init(&data->ctx, dev);

	pci_pwrctrl_init(&data->ctx, dev);



	ret = devm_pci_pwrctl_device_set_ready(dev, &data->ctx);

	ret = devm_pci_pwrctrl_device_set_ready(dev, &data->ctx);

	if (ret)

		return dev_err_probe(dev, ret,

				     "Failed to register the pwrctl wrapper\n");

				     "Failed to register the pwrctrl wrapper\n");



	return 0;

}



static const struct of_device_id pci_pwrctl_pwrseq_of_match[] = {

static const struct of_device_id pci_pwrctrl_pwrseq_of_match[] = {

	{

		/* ATH11K in QCA6390 package. */

		.compatible = "pci17cb,1101",
@@ -78,16 +78,16 @@ static const struct of_device_id pci_pwrctl_pwrseq_of_match[] = { 
	},

	{ }

};

MODULE_DEVICE_TABLE(of, pci_pwrctl_pwrseq_of_match);

MODULE_DEVICE_TABLE(of, pci_pwrctrl_pwrseq_of_match);



static struct platform_driver pci_pwrctl_pwrseq_driver = {

static struct platform_driver pci_pwrctrl_pwrseq_driver = {

	.driver = {

		.name = "pci-pwrctl-pwrseq",

		.of_match_table = pci_pwrctl_pwrseq_of_match,

		.name = "pci-pwrctrl-pwrseq",

		.of_match_table = pci_pwrctrl_pwrseq_of_match,

	},

	.probe = pci_pwrctl_pwrseq_probe,

	.probe = pci_pwrctrl_pwrseq_probe,

};

module_platform_driver(pci_pwrctl_pwrseq_driver);

module_platform_driver(pci_pwrctrl_pwrseq_driver);



MODULE_AUTHOR("Bartosz Golaszewski <bartosz.golaszewski@linaro.org>");

MODULE_DESCRIPTION("Generic PCI Power Control module for power sequenced devices");

drivers/pci/remove.c

+2 −2
Original line number Diff line number Diff line
@@ -17,7 +17,7 @@ static void pci_free_resources(struct pci_dev *dev) 
	}

}



static void pci_pwrctl_unregister(struct device *dev)

static void pci_pwrctrl_unregister(struct device *dev)

{

	struct platform_device *pdev;
@@ -34,7 +34,7 @@ static void pci_stop_dev(struct pci_dev *dev) 
	pci_pme_active(dev, false);



	if (pci_dev_is_added(dev)) {

		pci_pwrctl_unregister(&dev->dev);

		pci_pwrctrl_unregister(&dev->dev);

		device_release_driver(&dev->dev);

		pci_proc_detach_device(dev);

		pci_remove_sysfs_dev_files(dev);

include/linux/pci-pwrctrl.h

+11 −11
Original line number Diff line number Diff line
@@ -3,8 +3,8 @@ 
 * Copyright (C) 2024 Linaro Ltd.

 */



#ifndef __PCI_PWRCTL_H__

#define __PCI_PWRCTL_H__

#ifndef __PCI_PWRCTRL_H__

#define __PCI_PWRCTRL_H__



#include <linux/notifier.h>

#include <linux/workqueue.h>
@@ -29,14 +29,14 @@ struct device_link; 
 */



/**

 * struct pci_pwrctl - PCI device power control context.

 * struct pci_pwrctrl - PCI device power control context.

 * @dev: Address of the power controlling device.

 *

 * An object of this type must be allocated by the PCI power control device and

 * passed to the pwrctl subsystem to trigger a bus rescan and setup a device

 * passed to the pwrctrl subsystem to trigger a bus rescan and setup a device

 * link with the device once it's up.

 */

struct pci_pwrctl {

struct pci_pwrctrl {

	struct device *dev;



	/* Private: don't use. */
@@ -45,10 +45,10 @@ struct pci_pwrctl { 
	struct work_struct work;

};



void pci_pwrctl_init(struct pci_pwrctl *pwrctl, struct device *dev);

int pci_pwrctl_device_set_ready(struct pci_pwrctl *pwrctl);

void pci_pwrctl_device_unset_ready(struct pci_pwrctl *pwrctl);

int devm_pci_pwrctl_device_set_ready(struct device *dev,

				     struct pci_pwrctl *pwrctl);

void pci_pwrctrl_init(struct pci_pwrctrl *pwrctrl, struct device *dev);

int pci_pwrctrl_device_set_ready(struct pci_pwrctrl *pwrctrl);

void pci_pwrctrl_device_unset_ready(struct pci_pwrctrl *pwrctrl);

int devm_pci_pwrctrl_device_set_ready(struct device *dev,

				     struct pci_pwrctrl *pwrctrl);



#endif /* __PCI_PWRCTL_H__ */
 
#endif /* __PCI_PWRCTRL_H__ */