linux-imx

// SPDX-License-Identifier: GPL-2.0

/*

 * driver.c - centralized device driver management

 *

 * Copyright (c) 2002-3 Patrick Mochel

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

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

 * Copyright (c) 2007 Novell Inc.

 */

​

#include <linux/device.h>

#include <linux/module.h>

#include <linux/errno.h>

#include <linux/slab.h>

#include <linux/string.h>

#include <linux/sysfs.h>

#include "base.h"

​

static struct device *next_device(struct klist_iter *i)

{

    struct klist_node *n = klist_next(i);

    struct device *dev = NULL;

    struct device_private *dev_prv;

​

    if (n) {

        dev_prv = to_device_private_driver(n);

        dev = dev_prv->device;

    }

    return dev;

}

​

/**

 * driver_for_each_device - Iterator for devices bound to a driver.

 * @drv: Driver we're iterating.

 * @start: Device to begin with

 * @data: Data to pass to the callback.

 * @fn: Function to call for each device.

 *

 * Iterate over the @drv's list of devices calling @fn for each one.

 */

int driver_for_each_device(struct device_driver *drv, struct device *start,

               void *data, int (*fn)(struct device *, void *))

{

    struct klist_iter i;

    struct device *dev;

    int error = 0;

​

    if (!drv)

        return -EINVAL;

​

    klist_iter_init_node(&drv->p->klist_devices, &i,

                 start ? &start->p->knode_driver : NULL);

    while (!error && (dev = next_device(&i)))

        error = fn(dev, data);

    klist_iter_exit(&i);

    return error;

}

EXPORT_SYMBOL_GPL(driver_for_each_device);

​

/**

 * driver_find_device - device iterator for locating a particular device.

 * @drv: The device's driver

 * @start: Device to begin with

 * @data: Data to pass to match function

 * @match: Callback function to check device

 *

 * This is similar to the driver_for_each_device() function above, but

 * it returns a reference to a device that is 'found' for later use, as

 * determined by the @match callback.

 *

 * The callback should return 0 if the device doesn't match and non-zero

 * if it does.  If the callback returns non-zero, this function will

 * return to the caller and not iterate over any more devices.

 */

struct device *driver_find_device(struct device_driver *drv,

                  struct device *start, void *data,

                  int (*match)(struct device *dev, void *data))

{

    struct klist_iter i;

    struct device *dev;

​

    if (!drv || !drv->p)

        return NULL;

​

    klist_iter_init_node(&drv->p->klist_devices, &i,

                 (start ? &start->p->knode_driver : NULL));

    while ((dev = next_device(&i)))

        if (match(dev, data) && get_device(dev))

            break;

    klist_iter_exit(&i);

    return dev;

}