// SPDX-License-Identifier: GPL-2.0

/*

* drivers/base/core.c - core driver model code (device registration, etc)

*

* Copyright (c) 2002-3 Patrick Mochel

* Copyright (c) 2002-3 Open Source Development Labs

* Copyright (c) 2006 Greg Kroah-Hartman <gregkh@suse.de>

* Copyright (c) 2006 Novell, Inc.

*/

#include <linux/acpi.h>

#include <linux/blkdev.h>

#include <linux/cleanup.h>

#include <linux/cpufreq.h>

#include <linux/device.h>

#include <linux/dma-map-ops.h> /* for dma_default_coherent */

#include <linux/err.h>

#include <linux/fwnode.h>

#include <linux/init.h>

#include <linux/kdev_t.h>

#include <linux/kstrtox.h>

#include <linux/module.h>

#include <linux/mutex.h>

#include <linux/netdevice.h>

#include <linux/notifier.h>

#include <linux/of.h>

#include <linux/of_device.h>

#include <linux/pm_runtime.h>

#include <linux/sched/mm.h>

#include <linux/sched/signal.h>

#include <linux/slab.h>

#include <linux/string_helpers.h>

#include <linux/swiotlb.h>

#include <linux/sysfs.h>

#include "base.h"

#include "physical_location.h"

#include "power/power.h"

/* Device links support. */

static LIST_HEAD(deferred_sync);

static unsigned int defer_sync_state_count = 1;

static DEFINE_MUTEX(fwnode_link_lock);

static bool fw_devlink_is_permissive(void);

static void __fw_devlink_link_to_consumers(struct device *dev);

static bool fw_devlink_drv_reg_done;

static bool fw_devlink_best_effort;

static struct workqueue_struct *device_link_wq;

/**

* __fwnode_link_add - Create a link between two fwnode_handles.

* @con: Consumer end of the link.

* @sup: Supplier end of the link.

* @flags: Link flags.

*

* Create a fwnode link between fwnode handles @con and @sup. The fwnode link

* represents the detail that the firmware lists @sup fwnode as supplying a

* resource to @con.

*

* The driver core will use the fwnode link to create a device link between the

* two device objects corresponding to @con and @sup when they are created. The

* driver core will automatically delete the fwnode link between @con and @sup

* after doing that.

*

* Attempts to create duplicate links between the same pair of fwnode handles

* are ignored and there is no reference counting.

*/

static int __fwnode_link_add(struct fwnode_handle *con,

struct fwnode_handle *sup, u8 flags)

{

struct fwnode_link *link;

list_for_each_entry(link, &sup->consumers, s_hook)

if (link->consumer == con) {

link->flags |= flags;

return 0;

}

link = kzalloc_obj(*link);

if (!link)

return -ENOMEM;

link->supplier = sup;

INIT_LIST_HEAD(&link->s_hook);

link->consumer = con;

INIT_LIST_HEAD(&link->c_hook);

link->flags = flags;

list_add(&link->s_hook, &sup->consumers);

list_add(&link->c_hook, &con->suppliers);

pr_debug("%pfwf Linked as a fwnode consumer to %pfwf\n",

con, sup);

return 0;

}

int fwnode_link_add(struct fwnode_handle *con, struct fwnode_handle *sup,

u8 flags)

{

guard(mutex)(&fwnode_link_lock);

return __fwnode_link_add(con, sup, flags);

}

/**

* __fwnode_link_del - Delete a link between two fwnode_handles.

* @link: the fwnode_link to be deleted

*

* The fwnode_link_lock needs to be held when this function is called.

*/

static void __fwnode_link_del(struct fwnode_link *link)

{

pr_debug("%pfwf Dropping the fwnode link to %pfwf\n",

link->consumer, link->supplier);

list_del(&link->s_hook);

list_del(&link->c_hook);

kfree(link);

}

/**

* __fwnode_link_cycle - Mark a fwnode link as being part of a cycle.

* @link: the fwnode_link to be marked

*

* The fwnode_link_lock needs to be held when this function is called.

*/

static void __fwnode_link_cycle(struct fwnode_link *link)

{

pr_debug("%pfwf: cycle: depends on %pfwf\n",

link->consumer, link->supplier);

link->flags |= FWLINK_FLAG_CYCLE;

}

/**

* fwnode_links_purge_suppliers - Delete all supplier links of fwnode_handle.

* @fwnode: fwnode whose supplier links need to be deleted

*

* Deletes all supplier links connecting directly to @fwnode.

*/

static void fwnode_links_purge_suppliers(struct fwnode_handle *fwnode)

{

struct fwnode_link *link, *tmp;

guard(mutex)(&fwnode_link_lock);

list_for_each_entry_safe(link, tmp, &fwnode->suppliers, c_hook)

__fwnode_link_del(link);

}

/**

* fwnode_links_purge_consumers - Delete all consumer links of fwnode_handle.

* @fwnode: fwnode whose consumer links need to be deleted

*

* Deletes all consumer links connecting directly to @fwnode.

*/

static void fwnode_links_purge_consumers(struct fwnode_handle *fwnode)

{

struct fwnode_link *link, *tmp;

guard(mutex)(&fwnode_link_lock);

list_for_each_entry_safe(link, tmp, &fwnode->consumers, s_hook)

__fwnode_link_del(link);

}

/**

* fwnode_links_purge - Delete all links connected to a fwnode_handle.

* @fwnode: fwnode whose links needs to be deleted

*

* Deletes all links connecting directly to a fwnode.

*/

void fwnode_links_purge(struct fwnode_handle *fwnode)

{

fwnode_links_purge_suppliers(fwnode);

fwnode_links_purge_consumers(fwnode);

}

void fw_devlink_purge_absent_suppliers(struct fwnode_handle *fwnode)

{

struct fwnode_handle *child;

/* Don't purge consumer links of an added child */

if (fwnode->dev)

return;

fwnode_set_flag(fwnode, FWNODE_FLAG_NOT_DEVICE);

fwnode_links_purge_consumers(fwnode);

fwnode_for_each_available_child_node(fwnode, child)

fw_devlink_purge_absent_suppliers(child);

}

EXPORT_SYMBOL_GPL(fw_devlink_purge_absent_suppliers);

/**

* __fwnode_links_move_consumers - Move consumer from @from to @to fwnode_handle

* @from: move consumers away from this fwnode

* @to: move consumers to this fwnode

*

* Move all consumer links from @from fwnode to @to fwnode.

*/

static void __fwnode_links_move_consumers(struct fwnode_handle *from,

struct fwnode_handle *to)

{

struct fwnode_link *link, *tmp;

list_for_each_entry_safe(link, tmp, &from->consumers, s_hook) {

__fwnode_link_add(link->consumer, to, link->flags);

__fwnode_link_del(link);

}

}

/**

* __fw_devlink_pickup_dangling_consumers - Pick up dangling consumers

* @fwnode: fwnode from which to pick up dangling consumers

* @new_sup: fwnode of new supplier

*

* If the @fwnode has a corresponding struct device and the device supports

* probing (that is, added to a bus), then we want to let fw_devlink create

* MANAGED device links to this device, so leave @fwnode and its descendant's

* fwnode links alone.

*

* Otherwise, move its consumers to the new supplier @new_sup.

*/

static void __fw_devlink_pickup_dangling_consumers(struct fwnode_handle *fwnode,

struct fwnode_handle *new_sup)

{

struct fwnode_handle *child;

if (fwnode->dev && fwnode->dev->bus)

return;

fwnode_set_flag(fwnode, FWNODE_FLAG_NOT_DEVICE);

__fwnode_links_move_consumers(fwnode, new_sup);

fwnode_for_each_available_child_node(fwnode, child)

__fw_devlink_pickup_dangling_consumers(child, new_sup);

}

static void fw_devlink_pickup_dangling_consumers(struct device *dev)

{

struct fwnode_handle *child;

guard(mutex)(&fwnode_link_lock);

fwnode_for_each_available_child_node(dev->fwnode, child)

__fw_devlink_pickup_dangling_consumers(child, dev->fwnode);

__fw_devlink_link_to_consumers(dev);

}

/**

* fw_devlink_refresh_fwnode - Recheck the tree under this firmware node

* @fwnode: The fwnode under which the fwnode tree has changed

*

* This function is mainly meant to adjust the supplier/consumer dependencies

* after a fwnode tree overlay has occurred.

*/

void fw_devlink_refresh_fwnode(struct fwnode_handle *fwnode)

{

struct device *dev;

/*

* Find the closest ancestor fwnode that has been converted to a device

* that can bind to a driver (bus device).

*/

fwnode_handle_get(fwnode);

do {

if (fwnode_test_flag(fwnode, FWNODE_FLAG_NOT_DEVICE))

continue;

dev = get_dev_from_fwnode(fwnode);

if (!dev)

continue;

if (dev->bus)

break;

put_device(dev);

} while ((fwnode = fwnode_get_next_parent(fwnode)));

/*

* If none of the ancestor fwnodes have (yet) been converted to a device

* that can bind to a driver, there's nothing to fix up.

*/

if (!fwnode)

return;

WARN(device_is_bound(dev) && dev->links.status != DL_DEV_DRIVER_BOUND,

"Don't multithread overlaying and probing the same device!\n");

/*

* If the device has already bound to a driver, then we need to redo

* some of the work that was done after the device was bound to a

* driver. If the device hasn't bound to a driver, running things too

* soon would incorrectly pick up consumers that it shouldn't.

*/

if (dev->links.status == DL_DEV_DRIVER_BOUND) {

fw_devlink_pickup_dangling_consumers(dev);

/*

* Some of dangling consumers could have been put previously in

* the deferred probe list due to the unavailability of their

* suppliers. Those consumers have been picked up and some of

* their suppliers links have been updated. Time to re-try their

* probe sequence.

*/

driver_deferred_probe_trigger();

}

put_device(dev);

fwnode_handle_put(fwnode);

}

static DEFINE_MUTEX(device_links_lock);

DEFINE_STATIC_SRCU(device_links_srcu);

static inline void device_links_write_lock(void)

{

mutex_lock(&device_links_lock);

}

static inline void device_links_write_unlock(void)

{

mutex_unlock(&device_links_lock);

}

int device_links_read_lock(void) __acquires(&device_links_srcu)

{

return srcu_read_lock(&device_links_srcu);

}

void device_links_read_unlock(int idx) __releases(&device_links_srcu)

{

srcu_read_unlock(&device_links_srcu, idx);

}

int device_links_read_lock_held(void)

{

return srcu_read_lock_held(&device_links_srcu);

}

static void device_link_synchronize_removal(void)

{

synchronize_srcu(&device_links_srcu);

}

static void device_link_remove_from_lists(struct device_link *link)

{

list_del_rcu(&link->s_node);

list_del_rcu(&link->c_node);

}

static bool device_is_ancestor(struct device *dev, struct device *target)

{

while (target->parent) {

target = target->parent;

if (dev == target)

return true;

}

return false;

}

#define DL_MARKER_FLAGS (DL_FLAG_INFERRED | \

DL_FLAG_CYCLE | \

DL_FLAG_MANAGED)

bool device_link_flag_is_sync_state_only(u32 flags)

{

return (flags & ~DL_MARKER_FLAGS) == DL_FLAG_SYNC_STATE_ONLY;

}

/**

* device_is_dependent - Check if one device depends on another one

* @dev: Device to check dependencies for.

* @target: Device to check against.

*

* Check if @target depends on @dev or any device dependent on it (its child or

* its consumer etc). Return 1 if that is the case or 0 otherwise.

*/

static int device_is_dependent(struct device *dev, void *target)

{

struct device_link *link;

int ret;

/*

* The "ancestors" check is needed to catch the case when the target

* device has not been completely initialized yet and it is still

* missing from the list of children of its parent device.

*/

if (dev == target || device_is_ancestor(dev, target))

return 1;

ret = device_for_each_child(dev, target, device_is_dependent);

if (ret)

return ret;

list_for_each_entry(link, &dev->links.consumers, s_node) {

if (device_link_flag_is_sync_state_only(link->flags))

continue;

if (link->consumer == target)

return 1;

ret = device_is_dependent(link->consumer, target);

if (ret)

break;

}

return ret;

}

static void device_link_init_status(struct device_link *link,

struct device *consumer,

struct device *supplier)

{

switch (supplier->links.status) {

case DL_DEV_PROBING:

switch (consumer->links.status) {

case DL_DEV_PROBING:

/*

* A consumer driver can create a link to a supplier

* that has not completed its probing yet as long as it

* knows that the supplier is already functional (for

* example, it has just acquired some resources from the

* supplier).

*/

link->status = DL_STATE_CONSUMER_PROBE;

break;

default:

link->status = DL_STATE_DORMANT;

break;

}

break;

case DL_DEV_DRIVER_BOUND:

switch (consumer->links.status) {

case DL_DEV_PROBING:

link->status = DL_STATE_CONSUMER_PROBE;

break;

case DL_DEV_DRIVER_BOUND:

link->status = DL_STATE_ACTIVE;

break;

default:

link->status = DL_STATE_AVAILABLE;

break;

}

break;

case DL_DEV_UNBINDING:

link->status = DL_STATE_SUPPLIER_UNBIND;

break;

default:

link->status = DL_STATE_DORMANT;

break;

}

}

static int device_reorder_to_tail(struct device *dev, void *not_used)

{

struct device_link *link;

/*

* Devices that have not been registered yet will be put to the ends

* of the lists during the registration, so skip them here.

*/

if (device_is_registered(dev))

devices_kset_move_last(dev);

if (device_pm_initialized(dev))

device_pm_move_last(dev);

device_for_each_child(dev, NULL, device_reorder_to_tail);

list_for_each_entry(link, &dev->links.consumers, s_node) {

if (device_link_flag_is_sync_state_only(link->flags))

continue;

device_reorder_to_tail(link->consumer, NULL);

}

return 0;

}

/**

* device_pm_move_to_tail - Move set of devices to the end of device lists

* @dev: Device to move

*

* This is a device_reorder_to_tail() wrapper taking the requisite locks.

*

* It moves the @dev along with all of its children and all of its consumers

* to the ends of the device_kset and dpm_list, recursively.

*/

void device_pm_move_to_tail(struct device *dev)

{

int idx;

idx = device_links_read_lock();

device_pm_lock();

device_reorder_to_tail(dev, NULL);

device_pm_unlock();

device_links_read_unlock(idx);

}

#define to_devlink(dev) container_of((dev), struct device_link, link_dev)

static ssize_t status_show(struct device *dev,

const struct device_attribute *attr, char *buf)

{

const char *output;

switch (to_devlink(dev)->status) {

case DL_STATE_NONE:

output = "not tracked";

break;

case DL_STATE_DORMANT:

output = "dormant";

break;

case DL_STATE_AVAILABLE:

output = "available";

break;

case DL_STATE_CONSUMER_PROBE:

output = "consumer probing";

break;

case DL_STATE_ACTIVE:

output = "active";

break;

case DL_STATE_SUPPLIER_UNBIND:

output = "supplier unbinding";

break;

default:

output = "unknown";

break;

}

return sysfs_emit(buf, "%s\n", output);

}

static const DEVICE_ATTR_RO(status);

static ssize_t auto_remove_on_show(struct device *dev,

const struct device_attribute *attr, char *buf)

{

struct device_link *link = to_devlink(dev);

const char *output;

if (device_link_test(link, DL_FLAG_AUTOREMOVE_SUPPLIER))

output = "supplier unbind";

else if (device_link_test(link, DL_FLAG_AUTOREMOVE_CONSUMER))

output = "consumer unbind";

else

output = "never";

return sysfs_emit(buf, "%s\n", output);

}

static const DEVICE_ATTR_RO(auto_remove_on);

static ssize_t runtime_pm_show(struct device *dev,

const struct device_attribute *attr, char *buf)

{

struct device_link *link = to_devlink(dev);

return sysfs_emit(buf, "%d\n", device_link_test(link, DL_FLAG_PM_RUNTIME));

}

static const DEVICE_ATTR_RO(runtime_pm);

static ssize_t sync_state_only_show(struct device *dev,

const struct device_attribute *attr, char *buf)

{

struct device_link *link = to_devlink(dev);

return sysfs_emit(buf, "%d\n", device_link_test(link, DL_FLAG_SYNC_STATE_ONLY));

}

static const DEVICE_ATTR_RO(sync_state_only);

static const struct attribute *const devlink_attrs[] = {

&dev_attr_status.attr,

&dev_attr_auto_remove_on.attr,

&dev_attr_runtime_pm.attr,

&dev_attr_sync_state_only.attr,

NULL,

};

ATTRIBUTE_GROUPS(devlink);

static void device_link_release_fn(struct work_struct *work)

{

struct device_link *link = container_of(work, struct device_link, rm_work);

/* Ensure that all references to the link object have been dropped. */

device_link_synchronize_removal();

pm_runtime_release_supplier(link);

/*

* If supplier_preactivated is set, the link has been dropped between

* the pm_runtime_get_suppliers() and pm_runtime_put_suppliers() calls

* in __driver_probe_device(). In that case, drop the supplier's

* PM-runtime usage counter to remove the reference taken by

* pm_runtime_get_suppliers().

*/

if (link->supplier_preactivated)

pm_runtime_put_noidle(link->supplier);

pm_request_idle(link->supplier);

put_device(link->consumer);

put_device(link->supplier);

kfree(link);

}

static void devlink_dev_release(struct device *dev)

{

struct device_link *link = to_devlink(dev);

INIT_WORK(&link->rm_work, device_link_release_fn);

/*

* It may take a while to complete this work because of the SRCU

* synchronization in device_link_release_fn() and if the consumer or

* supplier devices get deleted when it runs, so put it into the

* dedicated workqueue.

*/

queue_work(device_link_wq, &link->rm_work);

}

/**

* device_link_wait_removal - Wait for ongoing devlink removal jobs to terminate

*/

void device_link_wait_removal(void)

{

/*

* devlink removal jobs are queued in the dedicated work queue.

* To be sure that all removal jobs are terminated, ensure that any

* scheduled work has run to completion.

*/

flush_workqueue(device_link_wq);

}

EXPORT_SYMBOL_GPL(device_link_wait_removal);

static const struct class devlink_class = {

.name = "devlink",

.dev_groups = devlink_groups,

.dev_release = devlink_dev_release,

};

static int devlink_add_symlinks(struct device *dev)

{

char *buf_con __free(kfree) = NULL, *buf_sup __free(kfree) = NULL;

int ret;

struct device_link *link = to_devlink(dev);

struct device *sup = link->supplier;

struct device *con = link->consumer;

ret = sysfs_create_link(&link->link_dev.kobj, &sup->kobj, "supplier");

if (ret)

goto out;

ret = sysfs_create_link(&link->link_dev.kobj, &con->kobj, "consumer");

if (ret)

goto err_con;

buf_con = kasprintf(GFP_KERNEL, "consumer:%s:%s", dev_bus_name(con), dev_name(con));

if (!buf_con) {

ret = -ENOMEM;

goto err_con_dev;

}

ret = sysfs_create_link(&sup->kobj, &link->link_dev.kobj, buf_con);

if (ret)

goto err_con_dev;

buf_sup = kasprintf(GFP_KERNEL, "supplier:%s:%s", dev_bus_name(sup), dev_name(sup));

if (!buf_sup) {

ret = -ENOMEM;

goto err_sup_dev;

}

ret = sysfs_create_link(&con->kobj, &link->link_dev.kobj, buf_sup);

if (ret)

goto err_sup_dev;

goto out;

err_sup_dev:

sysfs_remove_link(&sup->kobj, buf_con);

err_con_dev:

sysfs_remove_link(&link->link_dev.kobj, "consumer");

err_con:

sysfs_remove_link(&link->link_dev.kobj, "supplier");

out:

return ret;

}

static void devlink_remove_symlinks(struct device *dev)

{

char *buf_con __free(kfree) = NULL, *buf_sup __free(kfree) = NULL;

struct device_link *link = to_devlink(dev);

struct device *sup = link->supplier;

struct device *con = link->consumer;

sysfs_remove_link(&link->link_dev.kobj, "consumer");

sysfs_remove_link(&link->link_dev.kobj, "supplier");

if (device_is_registered(con)) {

buf_sup = kasprintf(GFP_KERNEL, "supplier:%s:%s", dev_bus_name(sup), dev_name(sup));

if (!buf_sup)

goto out;

sysfs_remove_link(&con->kobj, buf_sup);

}

buf_con = kasprintf(GFP_KERNEL, "consumer:%s:%s", dev_bus_name(con), dev_name(con));

if (!buf_con)

goto out;

sysfs_remove_link(&sup->kobj, buf_con);

return;

out:

WARN(1, "Unable to properly free device link symlinks!\n");

}

static struct class_interface devlink_class_intf = {

.class = &devlink_class,

.add_dev = devlink_add_symlinks,

.remove_dev = devlink_remove_symlinks,

};

static int __init devlink_class_init(void)

{

int ret;

ret = class_register(&devlink_class);

if (ret)

return ret;

ret = class_interface_register(&devlink_class_intf);

if (ret)

class_unregister(&devlink_class);

return ret;

}

postcore_initcall(devlink_class_init);

#define DL_MANAGED_LINK_FLAGS (DL_FLAG_AUTOREMOVE_CONSUMER | \

DL_FLAG_AUTOREMOVE_SUPPLIER | \

DL_FLAG_AUTOPROBE_CONSUMER | \

DL_FLAG_SYNC_STATE_ONLY | \

DL_FLAG_INFERRED | \

DL_FLAG_CYCLE)

#define DL_ADD_VALID_FLAGS (DL_MANAGED_LINK_FLAGS | DL_FLAG_STATELESS | \

DL_FLAG_PM_RUNTIME | DL_FLAG_RPM_ACTIVE)

/**

* device_link_add - Create a link between two devices.

* @consumer: Consumer end of the link.

* @supplier: Supplier end of the link.

* @flags: Link flags.

*

* Return: On success, a device_link struct will be returned.

* On error or invalid flag settings, NULL will be returned.

*

* The caller is responsible for the proper synchronization of the link creation

* with runtime PM. First, setting the DL_FLAG_PM_RUNTIME flag will cause the

* runtime PM framework to take the link into account. Second, if the

* DL_FLAG_RPM_ACTIVE flag is set in addition to it, the supplier devices will

* be forced into the active meta state and reference-counted upon the creation

* of the link. If DL_FLAG_PM_RUNTIME is not set, DL_FLAG_RPM_ACTIVE will be

* ignored.

*

* If DL_FLAG_STATELESS is set in @flags, the caller of this function is

* expected to release the link returned by it directly with the help of either

* device_link_del() or device_link_remove().

*

* If that flag is not set, however, the caller of this function is handing the

* management of the link over to the driver core entirely and its return value

* can only be used to check whether or not the link is present. In that case,

* the DL_FLAG_AUTOREMOVE_CONSUMER and DL_FLAG_AUTOREMOVE_SUPPLIER device link

* flags can be used to indicate to the driver core when the link can be safely

* deleted. Namely, setting one of them in @flags indicates to the driver core

* that the link is not going to be used (by the given caller of this function)

* after unbinding the consumer or supplier driver, respectively, from its

* device, so the link can be deleted at that point. If none of them is set,

* the link will be maintained until one of the devices pointed to by it (either

* the consumer or the supplier) is unregistered.

*

* Also, if DL_FLAG_STATELESS, DL_FLAG_AUTOREMOVE_CONSUMER and

* DL_FLAG_AUTOREMOVE_SUPPLIER are not set in @flags (that is, a persistent

* managed device link is being added), the DL_FLAG_AUTOPROBE_CONSUMER flag can

* be used to request the driver core to automatically probe for a consumer

* driver after successfully binding a driver to the supplier device.

*

* The combination of DL_FLAG_STATELESS and one of DL_FLAG_AUTOREMOVE_CONSUMER,

* DL_FLAG_AUTOREMOVE_SUPPLIER, or DL_FLAG_AUTOPROBE_CONSUMER set in @flags at

* the same time is invalid and will cause NULL to be returned upfront.

* However, if a device link between the given @consumer and @supplier pair

* exists already when this function is called for them, the existing link will

* be returned regardless of its current type and status (the link's flags may

* be modified then). The caller of this function is then expected to treat

* the link as though it has just been created, so (in particular) if

* DL_FLAG_STATELESS was passed in @flags, the link needs to be released

* explicitly when not needed any more (as stated above).

*

* A side effect of the link creation is re-ordering of dpm_list and the

* devices_kset list by moving the consumer device and all devices depending

* on it to the ends of these lists (that does not happen to devices that have

* not been registered when this function is called).

*

* The supplier device is required to be registered when this function is called

* and NULL will be returned if that is not the case. The consumer device need

* not be registered, however.

*/

struct device_link *device_link_add(struct device *consumer,

struct device *supplier, u32 flags)

{

struct device_link *link;

if (!consumer || !supplier || consumer == supplier ||

flags & ~DL_ADD_VALID_FLAGS ||

(flags & DL_FLAG_STATELESS && flags & DL_MANAGED_LINK_FLAGS) ||

(flags & DL_FLAG_AUTOPROBE_CONSUMER &&

flags & (DL_FLAG_AUTOREMOVE_CONSUMER |

DL_FLAG_AUTOREMOVE_SUPPLIER)))

return NULL;

if (flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) {

if (pm_runtime_get_sync(supplier) < 0) {

pm_runtime_put_noidle(supplier);

return NULL;

}

}

if (!(flags & DL_FLAG_STATELESS))

flags |= DL_FLAG_MANAGED;

if (flags & DL_FLAG_SYNC_STATE_ONLY &&

!device_link_flag_is_sync_state_only(flags))

return NULL;

device_links_write_lock();

device_pm_lock();

/*

* If the supplier has not been fully registered yet or there is a

* reverse (non-SYNC_STATE_ONLY) dependency between the consumer and

* the supplier already in the graph, return NULL. If the link is a

* SYNC_STATE_ONLY link, we don't check for reverse dependencies

* because it only affects sync_state() callbacks.

*/

if (!device_pm_initialized(supplier)

|| (!(flags & DL_FLAG_SYNC_STATE_ONLY) &&

device_is_dependent(consumer, supplier))) {

link = NULL;

goto out;

}

/*

* SYNC_STATE_ONLY links are useless once a consumer device has probed.

* So, only create it if the consumer hasn't probed yet.

*/

if (flags & DL_FLAG_SYNC_STATE_ONLY &&

consumer->links.status != DL_DEV_NO_DRIVER &&

consumer->links.status != DL_DEV_PROBING) {

link = NULL;

goto out;

}

/*

* DL_FLAG_AUTOREMOVE_SUPPLIER indicates that the link will be needed

* longer than for DL_FLAG_AUTOREMOVE_CONSUMER and setting them both

* together doesn't make sense, so prefer DL_FLAG_AUTOREMOVE_SUPPLIER.

*/

if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER)

flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER;

list_for_each_entry(link, &supplier->links.consumers, s_node) {

if (link->consumer != consumer)

continue;

if (device_link_test(link, DL_FLAG_INFERRED) &&

!(flags & DL_FLAG_INFERRED))

link->flags &= ~DL_FLAG_INFERRED;

if (flags & DL_FLAG_PM_RUNTIME) {

if (!device_link_test(link, DL_FLAG_PM_RUNTIME)) {

pm_runtime_new_link(consumer);

link->flags |= DL_FLAG_PM_RUNTIME;

}

if (flags & DL_FLAG_RPM_ACTIVE)

refcount_inc(&link->rpm_active);

}

if (flags & DL_FLAG_STATELESS) {

kref_get(&link->kref);

if (device_link_test(link, DL_FLAG_SYNC_STATE_ONLY) &&

!device_link_test(link, DL_FLAG_STATELESS)) {

link->flags |= DL_FLAG_STATELESS;

goto reorder;

} else {

link->flags |= DL_FLAG_STATELESS;

goto out;

}

}

/*

* If the life time of the link following from the new flags is

* longer than indicated by the flags of the existing link,

* update the existing link to stay around longer.

*/

if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) {

if (device_link_test(link, DL_FLAG_AUTOREMOVE_CONSUMER)) {

link->flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER;

link->flags |= DL_FLAG_AUTOREMOVE_SUPPLIER;

}

} else if (!(flags & DL_FLAG_AUTOREMOVE_CONSUMER)) {

link->flags &= ~(DL_FLAG_AUTOREMOVE_CONSUMER |

DL_FLAG_AUTOREMOVE_SUPPLIER);

}

if (!device_link_test(link, DL_FLAG_MANAGED)) {

kref_get(&link->kref);

link->flags |= DL_FLAG_MANAGED;

device_link_init_status(link, consumer, supplier);

}

if (device_link_test(link, DL_FLAG_SYNC_STATE_ONLY) &&

!(flags & DL_FLAG_SYNC_STATE_ONLY)) {

link->flags &= ~DL_FLAG_SYNC_STATE_ONLY;

goto reorder;

}

goto out;

}

link = kzalloc_obj(*link);

if (!link)

goto out;

refcount_set(&link->rpm_active, 1);

get_device(supplier);

link->supplier = supplier;

INIT_LIST_HEAD(&link->s_node);

get_device(consumer);

link->consumer = consumer;

INIT_LIST_HEAD(&link->c_node);

link->flags = flags;

kref_init(&link->kref);

link->link_dev.class = &devlink_class;

device_set_pm_not_required(&link->link_dev);

dev_set_name(&link->link_dev, "%s:%s--%s:%s",

dev_bus_name(supplier), dev_name(supplier),

dev_bus_name(consumer), dev_name(consumer));

if (device_register(&link->link_dev)) {

put_device(&link->link_dev);

link = NULL;

goto out;

}

if (flags & DL_FLAG_PM_RUNTIME) {

if (flags & DL_FLAG_RPM_ACTIVE)

refcount_inc(&link->rpm_active);

pm_runtime_new_link(consumer);

}

/* Determine the initial link state. */

if (flags & DL_FLAG_STATELESS)

link->status = DL_STATE_NONE;

else

device_link_init_status(link, consumer, supplier);

/*

* Some callers expect the link creation during consumer driver probe to

* resume the supplier even without DL_FLAG_RPM_ACTIVE.

*/

if (link->status == DL_STATE_CONSUMER_PROBE &&

flags & DL_FLAG_PM_RUNTIME)

pm_runtime_resume(supplier);

list_add_tail_rcu(&link->s_node, &supplier->links.consumers);

list_add_tail_rcu(&link->c_node, &consumer->links.suppliers);

if (flags & DL_FLAG_SYNC_STATE_ONLY) {

dev_dbg(consumer,

"Linked as a sync state only consumer to %s\n",

dev_name(supplier));

goto out;

}

reorder:

/*

* Move the consumer and all of the devices depending on it to the end

* of dpm_list and the devices_kset list.

*

* It is necessary to hold dpm_list locked throughout all that or else

* we may end up suspending with a wrong ordering of it.

*/

device_reorder_to_tail(consumer, NULL);

dev_dbg(consumer, "Linked as a consumer to %s\n", dev_name(supplier));

out:

device_pm_unlock();

device_links_write_unlock();

if ((flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) && !link)

pm_runtime_put(supplier);

return link;

}

EXPORT_SYMBOL_GPL(device_link_add);

static void __device_link_del(struct kref *kref)