linux/drivers/slimbus/core.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2011-2017, The Linux Foundation
 */

#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/idr.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/pm_runtime.h>
#include <linux/slimbus.h>
#include "slimbus.h"

static DEFINE_IDA(ctrl_ida);

static const struct slim_device_id *slim_match(const struct slim_device_id *id,
					       const struct slim_device *sbdev)
{ … }

static int slim_device_match(struct device *dev, const struct device_driver *drv)
{ … }

static void slim_device_update_status(struct slim_device *sbdev,
				      enum slim_device_status status)
{ … }

static int slim_device_probe(struct device *dev)
{ … }

static void slim_device_remove(struct device *dev)
{ … }

static int slim_device_uevent(const struct device *dev, struct kobj_uevent_env *env)
{ … }

const struct bus_type slimbus_bus = …;
EXPORT_SYMBOL_GPL(…);

/*
 * __slim_driver_register() - Client driver registration with SLIMbus
 *
 * @drv:Client driver to be associated with client-device.
 * @owner: owning module/driver
 *
 * This API will register the client driver with the SLIMbus
 * It is called from the driver's module-init function.
 */
int __slim_driver_register(struct slim_driver *drv, struct module *owner)
{ … }
EXPORT_SYMBOL_GPL(…);

/*
 * slim_driver_unregister() - Undo effect of slim_driver_register
 *
 * @drv: Client driver to be unregistered
 */
void slim_driver_unregister(struct slim_driver *drv)
{ … }
EXPORT_SYMBOL_GPL(…);

static void slim_dev_release(struct device *dev)
{ … }

static int slim_add_device(struct slim_controller *ctrl,
			   struct slim_device *sbdev,
			   struct device_node *node)
{ … }

static struct slim_device *slim_alloc_device(struct slim_controller *ctrl,
					     struct slim_eaddr *eaddr,
					     struct device_node *node)
{ … }

static void of_register_slim_devices(struct slim_controller *ctrl)
{ … }

/*
 * slim_register_controller() - Controller bring-up and registration.
 *
 * @ctrl: Controller to be registered.
 *
 * A controller is registered with the framework using this API.
 * If devices on a controller were registered before controller,
 * this will make sure that they get probed when controller is up
 */
int slim_register_controller(struct slim_controller *ctrl)
{ … }
EXPORT_SYMBOL_GPL(…);

/* slim_remove_device: Remove the effect of slim_add_device() */
static void slim_remove_device(struct slim_device *sbdev)
{ … }

static int slim_ctrl_remove_device(struct device *dev, void *null)
{ … }

/**
 * slim_unregister_controller() - Controller tear-down.
 *
 * @ctrl: Controller to tear-down.
 */
int slim_unregister_controller(struct slim_controller *ctrl)
{ … }
EXPORT_SYMBOL_GPL(…);

/**
 * slim_report_absent() - Controller calls this function when a device
 *	reports absent, OR when the device cannot be communicated with
 *
 * @sbdev: Device that cannot be reached, or sent report absent
 */
void slim_report_absent(struct slim_device *sbdev)
{ … }
EXPORT_SYMBOL_GPL(…);

static bool slim_eaddr_equal(struct slim_eaddr *a, struct slim_eaddr *b)
{ … }

static int slim_match_dev(struct device *dev, void *data)
{ … }

static struct slim_device *find_slim_device(struct slim_controller *ctrl,
					    struct slim_eaddr *eaddr)
{ … }

/**
 * slim_get_device() - get handle to a device.
 *
 * @ctrl: Controller on which this device will be added/queried
 * @e_addr: Enumeration address of the device to be queried
 *
 * Return: pointer to a device if it has already reported. Creates a new
 * device and returns pointer to it if the device has not yet enumerated.
 */
struct slim_device *slim_get_device(struct slim_controller *ctrl,
				    struct slim_eaddr *e_addr)
{ … }
EXPORT_SYMBOL_GPL(…);

static int of_slim_match_dev(struct device *dev, void *data)
{ … }

static struct slim_device *of_find_slim_device(struct slim_controller *ctrl,
					       struct device_node *np)
{ … }

/**
 * of_slim_get_device() - get handle to a device using dt node.
 *
 * @ctrl: Controller on which this device will be added/queried
 * @np: node pointer to device
 *
 * Return: pointer to a device if it has already reported. Creates a new
 * device and returns pointer to it if the device has not yet enumerated.
 */
struct slim_device *of_slim_get_device(struct slim_controller *ctrl,
				       struct device_node *np)
{ … }
EXPORT_SYMBOL_GPL(…);

static int slim_device_alloc_laddr(struct slim_device *sbdev,
				   bool report_present)
{ … }

/**
 * slim_device_report_present() - Report enumerated device.
 *
 * @ctrl: Controller with which device is enumerated.
 * @e_addr: Enumeration address of the device.
 * @laddr: Return logical address (if valid flag is false)
 *
 * Called by controller in response to REPORT_PRESENT. Framework will assign
 * a logical address to this enumeration address.
 * Function returns -EXFULL to indicate that all logical addresses are already
 * taken.
 */
int slim_device_report_present(struct slim_controller *ctrl,
			       struct slim_eaddr *e_addr, u8 *laddr)
{ … }
EXPORT_SYMBOL_GPL(…);

/**
 * slim_get_logical_addr() - get/allocate logical address of a SLIMbus device.
 *
 * @sbdev: client handle requesting the address.
 *
 * Return: zero if a logical address is valid or a new logical address
 * has been assigned. error code in case of error.
 */
int slim_get_logical_addr(struct slim_device *sbdev)
{ … }
EXPORT_SYMBOL_GPL(…);

static void __exit slimbus_exit(void)
{ … }
module_exit(slimbus_exit);

static int __init slimbus_init(void)
{ … }
postcore_initcall(slimbus_init);

MODULE_LICENSE(…) …;
MODULE_DESCRIPTION(…) …;