// SPDX-License-Identifier: GPL-2.0/** * Device connections * * Copyright (C) 2018 Intel Corporation * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com> */ #include <linux/device.h>#include <linux/property.h> static DEFINE_MUTEX(devcon_lock);static LIST_HEAD(devcon_list); static void *fwnode_graph_devcon_match(struct fwnode_handle *fwnode, const char *con_id,			  void *data, devcon_match_fn_t match){	struct device_connection con = { .id = con_id };	struct fwnode_handle *ep;	void *ret; 	fwnode_graph_for_each_endpoint(fwnode, ep) {		con.fwnode = fwnode_graph_get_remote_port_parent(ep);		if (!fwnode_device_is_available(con.fwnode))			continue; 		ret = match(&con, -1, data);		fwnode_handle_put(con.fwnode);		if (ret) {			fwnode_handle_put(ep);			return ret;		}	}	return NULL;} static void *fwnode_devcon_match(struct fwnode_handle *fwnode, const char *con_id,		    void *data, devcon_match_fn_t match){	struct device_connection con = { };	void *ret;	int i; 	for (i = 0; ; i++) {		con.fwnode = fwnode_find_reference(fwnode, con_id, i);		if (IS_ERR(con.fwnode))			break; 		ret = match(&con, -1, data);		fwnode_handle_put(con.fwnode);		if (ret)			return ret;	} 	return NULL;} /** * fwnode_connection_find_match - Find connection from a device node * @fwnode: Device node with the connection * @con_id: Identifier for the connection * @data: Data for the match function * @match: Function to check and convert the connection description * * Find a connection with unique identifier @con_id between @fwnode and another * device node. @match will be used to convert the connection description to * data the caller is expecting to be returned. */void *fwnode_connection_find_match(struct fwnode_handle *fwnode,				   const char *con_id, void *data,				   devcon_match_fn_t match){	void *ret; 	if (!fwnode || !match)		return NULL; 	ret = fwnode_graph_devcon_match(fwnode, con_id, data, match);	if (ret)		return ret; 	return fwnode_devcon_match(fwnode, con_id, data, match);}EXPORT_SYMBOL_GPL(fwnode_connection_find_match); /** * device_connection_find_match - Find physical connection to a device * @dev: Device with the connection * @con_id: Identifier for the connection * @data: Data for the match function * @match: Function to check and convert the connection description * * Find a connection with unique identifier @con_id between @dev and another * device. @match will be used to convert the connection description to data the * caller is expecting to be returned. */void *device_connection_find_match(struct device *dev, const char *con_id,				   void *data, devcon_match_fn_t match){	struct fwnode_handle *fwnode = dev_fwnode(dev);	const char *devname = dev_name(dev);	struct device_connection *con;	void *ret = NULL;	int ep; 	if (!match)		return NULL; 	ret = fwnode_connection_find_match(fwnode, con_id, data, match);	if (ret)		return ret; 	mutex_lock(&devcon_lock); 	list_for_each_entry(con, &devcon_list, list) {		ep = match_string(con->endpoint, 2, devname);		if (ep < 0)			continue; 		if (con_id && strcmp(con->id, con_id))			continue; 		ret = match(con, !ep, data);		if (ret)			break;	} 	mutex_unlock(&devcon_lock); 	return ret;}EXPORT_SYMBOL_GPL(device_connection_find_match); extern struct bus_type platform_bus_type;extern struct bus_type pci_bus_type;extern struct bus_type i2c_bus_type;extern struct bus_type spi_bus_type; static struct bus_type *generic_match_buses[] = {	&platform_bus_type,#ifdef CONFIG_PCI	&pci_bus_type,#endif#ifdef CONFIG_I2C	&i2c_bus_type,#endif#ifdef CONFIG_SPI_MASTER	&spi_bus_type,#endif	NULL,}; static void *device_connection_fwnode_match(struct device_connection *con){	struct bus_type *bus;	struct device *dev; 	for (bus = generic_match_buses[0]; bus; bus++) {		dev = bus_find_device_by_fwnode(bus, con->fwnode);		if (dev && !strncmp(dev_name(dev), con->id, strlen(con->id)))			return dev; 		put_device(dev);	}	return NULL;} /* This tries to find the device from the most common bus types by name. */static void *generic_match(struct device_connection *con, int ep, void *data){	struct bus_type *bus;	struct device *dev; 	if (con->fwnode)		return device_connection_fwnode_match(con); 	for (bus = generic_match_buses[0]; bus; bus++) {		dev = bus_find_device_by_name(bus, NULL, con->endpoint[ep]);		if (dev)			return dev;	} 	/*	 * We only get called if a connection was found, tell the caller to	 * wait for the other device to show up.	 */	return ERR_PTR(-EPROBE_DEFER);} /** * device_connection_find - Find two devices connected together * @dev: Device with the connection * @con_id: Identifier for the connection * * Find a connection with unique identifier @con_id between @dev and * another device. On success returns handle to the device that is connected * to @dev, with the reference count for the found device incremented. Returns * NULL if no matching connection was found, or ERR_PTR(-EPROBE_DEFER) when a * connection was found but the other device has not been enumerated yet. */struct device *device_connection_find(struct device *dev, const char *con_id){	return device_connection_find_match(dev, con_id, NULL, generic_match);}EXPORT_SYMBOL_GPL(device_connection_find); /** * device_connection_add - Register a connection description * @con: The connection description to be registered */void device_connection_add(struct device_connection *con){	mutex_lock(&devcon_lock);	list_add_tail(&con->list, &devcon_list);	mutex_unlock(&devcon_lock);}EXPORT_SYMBOL_GPL(device_connection_add); /** * device_connections_remove - Unregister connection description * @con: The connection description to be unregistered */void device_connection_remove(struct device_connection *con){	mutex_lock(&devcon_lock);	list_del(&con->list);	mutex_unlock(&devcon_lock);}EXPORT_SYMBOL_GPL(device_connection_remove);