[linux-2.6-block.git] / drivers / fpga / fpga-bridge.c

// SPDX-License-Identifier: GPL-2.0
/*
 * FPGA Bridge Framework Driver
 *
 *  Copyright (C) 2013-2016 Altera Corporation, All Rights Reserved.
 *  Copyright (C) 2017 Intel Corporation
 */
#include <linux/fpga/fpga-bridge.h>
#include <linux/idr.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of_platform.h>
#include <linux/slab.h>
#include <linux/spinlock.h>

static DEFINE_IDA(fpga_bridge_ida);
static struct class *fpga_bridge_class;

/* Lock for adding/removing bridges to linked lists*/
static spinlock_t bridge_list_lock;

static int fpga_bridge_of_node_match(struct device *dev, const void *data)
{
	return dev->of_node == data;
}

/**
 * fpga_bridge_enable - Enable transactions on the bridge
 *
 * @bridge: FPGA bridge
 *
 * Return: 0 for success, error code otherwise.
 */
int fpga_bridge_enable(struct fpga_bridge *bridge)
{
	dev_dbg(&bridge->dev, "enable\n");

	if (bridge->br_ops && bridge->br_ops->enable_set)
		return bridge->br_ops->enable_set(bridge, 1);

	return 0;
}
EXPORT_SYMBOL_GPL(fpga_bridge_enable);

/**
 * fpga_bridge_disable - Disable transactions on the bridge
 *
 * @bridge: FPGA bridge
 *
 * Return: 0 for success, error code otherwise.
 */
int fpga_bridge_disable(struct fpga_bridge *bridge)
{
	dev_dbg(&bridge->dev, "disable\n");

	if (bridge->br_ops && bridge->br_ops->enable_set)
		return bridge->br_ops->enable_set(bridge, 0);

	return 0;
}
EXPORT_SYMBOL_GPL(fpga_bridge_disable);

static struct fpga_bridge *__fpga_bridge_get(struct device *dev,
					     struct fpga_image_info *info)
{
	struct fpga_bridge *bridge;
	int ret = -ENODEV;

	bridge = to_fpga_bridge(dev);

	bridge->info = info;

	if (!mutex_trylock(&bridge->mutex)) {
		ret = -EBUSY;
		goto err_dev;
	}

	if (!try_module_get(dev->parent->driver->owner))
		goto err_ll_mod;

	dev_dbg(&bridge->dev, "get\n");

	return bridge;

err_ll_mod:
	mutex_unlock(&bridge->mutex);
err_dev:
	put_device(dev);
	return ERR_PTR(ret);
}

/**
 * of_fpga_bridge_get - get an exclusive reference to a fpga bridge
 *
 * @np: node pointer of a FPGA bridge
 * @info: fpga image specific information
 *
 * Return fpga_bridge struct if successful.
 * Return -EBUSY if someone already has a reference to the bridge.
 * Return -ENODEV if @np is not a FPGA Bridge.
 */
struct fpga_bridge *of_fpga_bridge_get(struct device_node *np,
				       struct fpga_image_info *info)
{
	struct device *dev;

	dev = class_find_device(fpga_bridge_class, NULL, np,
				fpga_bridge_of_node_match);
	if (!dev)
		return ERR_PTR(-ENODEV);

	return __fpga_bridge_get(dev, info);
}
EXPORT_SYMBOL_GPL(of_fpga_bridge_get);

static int fpga_bridge_dev_match(struct device *dev, const void *data)
{
	return dev->parent == data;
}

/**
 * fpga_bridge_get - get an exclusive reference to a fpga bridge
 * @dev:	parent device that fpga bridge was registered with
 * @info:	fpga manager info
 *
 * Given a device, get an exclusive reference to a fpga bridge.
 *
 * Return: fpga bridge struct or IS_ERR() condition containing error code.
 */
struct fpga_bridge *fpga_bridge_get(struct device *dev,
				    struct fpga_image_info *info)
{
	struct device *bridge_dev;

	bridge_dev = class_find_device(fpga_bridge_class, NULL, dev,
				       fpga_bridge_dev_match);
	if (!bridge_dev)
		return ERR_PTR(-ENODEV);

	return __fpga_bridge_get(bridge_dev, info);
}
EXPORT_SYMBOL_GPL(fpga_bridge_get);

/**
 * fpga_bridge_put - release a reference to a bridge
 *
 * @bridge: FPGA bridge
 */
void fpga_bridge_put(struct fpga_bridge *bridge)
{
	dev_dbg(&bridge->dev, "put\n");

	bridge->info = NULL;
	module_put(bridge->dev.parent->driver->owner);
	mutex_unlock(&bridge->mutex);
	put_device(&bridge->dev);
}
EXPORT_SYMBOL_GPL(fpga_bridge_put);

/**
 * fpga_bridges_enable - enable bridges in a list
 * @bridge_list: list of FPGA bridges
 *
 * Enable each bridge in the list.  If list is empty, do nothing.
 *
 * Return 0 for success or empty bridge list; return error code otherwise.
 */
int fpga_bridges_enable(struct list_head *bridge_list)
{
	struct fpga_bridge *bridge;
	int ret;

	list_for_each_entry(bridge, bridge_list, node) {
		ret = fpga_bridge_enable(bridge);
		if (ret)
			return ret;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(fpga_bridges_enable);

/**
 * fpga_bridges_disable - disable bridges in a list
 *
 * @bridge_list: list of FPGA bridges
 *
 * Disable each bridge in the list.  If list is empty, do nothing.
 *
 * Return 0 for success or empty bridge list; return error code otherwise.
 */
int fpga_bridges_disable(struct list_head *bridge_list)
{
	struct fpga_bridge *bridge;
	int ret;

	list_for_each_entry(bridge, bridge_list, node) {
		ret = fpga_bridge_disable(bridge);
		if (ret)
			return ret;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(fpga_bridges_disable);

/**
 * fpga_bridges_put - put bridges
 *
 * @bridge_list: list of FPGA bridges
 *
 * For each bridge in the list, put the bridge and remove it from the list.
 * If list is empty, do nothing.
 */
void fpga_bridges_put(struct list_head *bridge_list)
{
	struct fpga_bridge *bridge, *next;
	unsigned long flags;

	list_for_each_entry_safe(bridge, next, bridge_list, node) {
		fpga_bridge_put(bridge);

		spin_lock_irqsave(&bridge_list_lock, flags);
		list_del(&bridge->node);
		spin_unlock_irqrestore(&bridge_list_lock, flags);
	}
}
EXPORT_SYMBOL_GPL(fpga_bridges_put);

/**
 * of_fpga_bridge_get_to_list - get a bridge, add it to a list
 *
 * @np: node pointer of a FPGA bridge
 * @info: fpga image specific information
 * @bridge_list: list of FPGA bridges
 *
 * Get an exclusive reference to the bridge and and it to the list.
 *
 * Return 0 for success, error code from of_fpga_bridge_get() othewise.
 */
int of_fpga_bridge_get_to_list(struct device_node *np,
			       struct fpga_image_info *info,
			       struct list_head *bridge_list)
{
	struct fpga_bridge *bridge;
	unsigned long flags;

	bridge = of_fpga_bridge_get(np, info);
	if (IS_ERR(bridge))
		return PTR_ERR(bridge);

	spin_lock_irqsave(&bridge_list_lock, flags);
	list_add(&bridge->node, bridge_list);
	spin_unlock_irqrestore(&bridge_list_lock, flags);

	return 0;
}
EXPORT_SYMBOL_GPL(of_fpga_bridge_get_to_list);

/**
 * fpga_bridge_get_to_list - given device, get a bridge, add it to a list
 *
 * @dev: FPGA bridge device
 * @info: fpga image specific information
 * @bridge_list: list of FPGA bridges
 *
 * Get an exclusive reference to the bridge and and it to the list.
 *
 * Return 0 for success, error code from fpga_bridge_get() othewise.
 */
int fpga_bridge_get_to_list(struct device *dev,
			    struct fpga_image_info *info,
			    struct list_head *bridge_list)
{
	struct fpga_bridge *bridge;
	unsigned long flags;

	bridge = fpga_bridge_get(dev, info);
	if (IS_ERR(bridge))
		return PTR_ERR(bridge);

	spin_lock_irqsave(&bridge_list_lock, flags);
	list_add(&bridge->node, bridge_list);
	spin_unlock_irqrestore(&bridge_list_lock, flags);

	return 0;
}
EXPORT_SYMBOL_GPL(fpga_bridge_get_to_list);

static ssize_t name_show(struct device *dev,
			 struct device_attribute *attr, char *buf)
{
	struct fpga_bridge *bridge = to_fpga_bridge(dev);

	return sprintf(buf, "%s\n", bridge->name);
}

static ssize_t state_show(struct device *dev,
			  struct device_attribute *attr, char *buf)
{
	struct fpga_bridge *bridge = to_fpga_bridge(dev);
	int enable = 1;

	if (bridge->br_ops && bridge->br_ops->enable_show)
		enable = bridge->br_ops->enable_show(bridge);

	return sprintf(buf, "%s\n", enable ? "enabled" : "disabled");
}

static DEVICE_ATTR_RO(name);
static DEVICE_ATTR_RO(state);

static struct attribute *fpga_bridge_attrs[] = {
	&dev_attr_name.attr,
	&dev_attr_state.attr,
	NULL,
};
ATTRIBUTE_GROUPS(fpga_bridge);

/**
 * fpga_bridge_create - create and initialize a struct fpga_bridge
 * @dev:	FPGA bridge device from pdev
 * @name:	FPGA bridge name
 * @br_ops:	pointer to structure of fpga bridge ops
 * @priv:	FPGA bridge private data
 *
 * The caller of this function is responsible for freeing the bridge with
 * fpga_bridge_free().  Using devm_fpga_bridge_create() instead is recommended.
 *
 * Return: struct fpga_bridge or NULL
 */
struct fpga_bridge *fpga_bridge_create(struct device *dev, const char *name,
				       const struct fpga_bridge_ops *br_ops,
				       void *priv)
{
	struct fpga_bridge *bridge;
	int id, ret = 0;

	if (!name || !strlen(name)) {
		dev_err(dev, "Attempt to register with no name!\n");
		return NULL;
	}

	bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
	if (!bridge)
		return NULL;

	id = ida_simple_get(&fpga_bridge_ida, 0, 0, GFP_KERNEL);
	if (id < 0) {
		ret = id;
		goto error_kfree;
	}

	mutex_init(&bridge->mutex);
	INIT_LIST_HEAD(&bridge->node);

	bridge->name = name;
	bridge->br_ops = br_ops;
	bridge->priv = priv;

	device_initialize(&bridge->dev);
	bridge->dev.groups = br_ops->groups;
	bridge->dev.class = fpga_bridge_class;
	bridge->dev.parent = dev;
	bridge->dev.of_node = dev->of_node;
	bridge->dev.id = id;

	ret = dev_set_name(&bridge->dev, "br%d", id);
	if (ret)
		goto error_device;

	return bridge;

error_device:
	ida_simple_remove(&fpga_bridge_ida, id);
error_kfree:
	kfree(bridge);

	return NULL;
}
EXPORT_SYMBOL_GPL(fpga_bridge_create);

/**
 * fpga_bridge_free - free a fpga bridge created by fpga_bridge_create()
 * @bridge:	FPGA bridge struct
 */
void fpga_bridge_free(struct fpga_bridge *bridge)
{
	ida_simple_remove(&fpga_bridge_ida, bridge->dev.id);
	kfree(bridge);
}
EXPORT_SYMBOL_GPL(fpga_bridge_free);

static void devm_fpga_bridge_release(struct device *dev, void *res)
{
	struct fpga_bridge *bridge = *(struct fpga_bridge **)res;

	fpga_bridge_free(bridge);
}

/**
 * devm_fpga_bridge_create - create and init a managed struct fpga_bridge
 * @dev:	FPGA bridge device from pdev
 * @name:	FPGA bridge name
 * @br_ops:	pointer to structure of fpga bridge ops
 * @priv:	FPGA bridge private data
 *
 * This function is intended for use in a FPGA bridge driver's probe function.
 * After the bridge driver creates the struct with devm_fpga_bridge_create(), it
 * should register the bridge with fpga_bridge_register().  The bridge driver's
 * remove function should call fpga_bridge_unregister().  The bridge struct
 * allocated with this function will be freed automatically on driver detach.
 * This includes the case of a probe function returning error before calling
 * fpga_bridge_register(), the struct will still get cleaned up.
 *
 *  Return: struct fpga_bridge or NULL
 */
struct fpga_bridge
*devm_fpga_bridge_create(struct device *dev, const char *name,
			 const struct fpga_bridge_ops *br_ops, void *priv)
{
	struct fpga_bridge **ptr, *bridge;

	ptr = devres_alloc(devm_fpga_bridge_release, sizeof(*ptr), GFP_KERNEL);
	if (!ptr)
		return NULL;

	bridge = fpga_bridge_create(dev, name, br_ops, priv);
	if (!bridge) {
		devres_free(ptr);
	} else {
		*ptr = bridge;
		devres_add(dev, ptr);
	}

	return bridge;
}
EXPORT_SYMBOL_GPL(devm_fpga_bridge_create);

/**
 * fpga_bridge_register - register a FPGA bridge
 *
 * @bridge: FPGA bridge struct
 *
 * Return: 0 for success, error code otherwise.
 */
int fpga_bridge_register(struct fpga_bridge *bridge)
{
	struct device *dev = &bridge->dev;
	int ret;

	ret = device_add(dev);
	if (ret)
		return ret;

	of_platform_populate(dev->of_node, NULL, NULL, dev);

	dev_info(dev->parent, "fpga bridge [%s] registered\n", bridge->name);

	return 0;
}
EXPORT_SYMBOL_GPL(fpga_bridge_register);

/**
 * fpga_bridge_unregister - unregister a FPGA bridge
 *
 * @bridge: FPGA bridge struct
 *
 * This function is intended for use in a FPGA bridge driver's remove function.
 */
void fpga_bridge_unregister(struct fpga_bridge *bridge)
{
	/*
	 * If the low level driver provides a method for putting bridge into
	 * a desired state upon unregister, do it.
	 */
	if (bridge->br_ops && bridge->br_ops->fpga_bridge_remove)
		bridge->br_ops->fpga_bridge_remove(bridge);

	device_unregister(&bridge->dev);
}
EXPORT_SYMBOL_GPL(fpga_bridge_unregister);

static void fpga_bridge_dev_release(struct device *dev)
{
}

static int __init fpga_bridge_dev_init(void)
{
	spin_lock_init(&bridge_list_lock);

	fpga_bridge_class = class_create(THIS_MODULE, "fpga_bridge");
	if (IS_ERR(fpga_bridge_class))
		return PTR_ERR(fpga_bridge_class);

	fpga_bridge_class->dev_groups = fpga_bridge_groups;
	fpga_bridge_class->dev_release = fpga_bridge_dev_release;

	return 0;
}

static void __exit fpga_bridge_dev_exit(void)
{
	class_destroy(fpga_bridge_class);
	ida_destroy(&fpga_bridge_ida);
}

MODULE_DESCRIPTION("FPGA Bridge Driver");
MODULE_AUTHOR("Alan Tull <atull@kernel.org>");
MODULE_LICENSE("GPL v2");

subsys_initcall(fpga_bridge_dev_init);
module_exit(fpga_bridge_dev_exit);
Commit	Line	Data
473f01f7	1	// SPDX-License-Identifier: GPL-2.0
21aeda95 AT	2	/*
	3	* FPGA Bridge Framework Driver
	4	*
	5	* Copyright (C) 2013-2016 Altera Corporation, All Rights Reserved.
9c1c4b27	6	* Copyright (C) 2017 Intel Corporation
21aeda95 AT	7	*/
	8	#include <linux/fpga/fpga-bridge.h>
	9	#include <linux/idr.h>
	10	#include <linux/kernel.h>
	11	#include <linux/module.h>
	12	#include <linux/of_platform.h>
	13	#include <linux/slab.h>
	14	#include <linux/spinlock.h>
	15
	16	static DEFINE_IDA(fpga_bridge_ida);
	17	static struct class *fpga_bridge_class;
	18
	19	/* Lock for adding/removing bridges to linked lists*/
47910a49	20	static spinlock_t bridge_list_lock;
21aeda95 AT	21
	22	static int fpga_bridge_of_node_match(struct device dev, const void data)
	23	{
	24	return dev->of_node == data;
	25	}
	26
	27	/**
	28	* fpga_bridge_enable - Enable transactions on the bridge
	29	*
	30	* @bridge: FPGA bridge
	31	*
	32	* Return: 0 for success, error code otherwise.
	33	*/
	34	int fpga_bridge_enable(struct fpga_bridge *bridge)
	35	{
	36	dev_dbg(&bridge->dev, "enable\n");
	37
	38	if (bridge->br_ops && bridge->br_ops->enable_set)
	39	return bridge->br_ops->enable_set(bridge, 1);
	40
	41	return 0;
	42	}
	43	EXPORT_SYMBOL_GPL(fpga_bridge_enable);
	44
	45	/**
	46	* fpga_bridge_disable - Disable transactions on the bridge
	47	*
	48	* @bridge: FPGA bridge
	49	*
	50	* Return: 0 for success, error code otherwise.
	51	*/
	52	int fpga_bridge_disable(struct fpga_bridge *bridge)
	53	{
	54	dev_dbg(&bridge->dev, "disable\n");
	55
	56	if (bridge->br_ops && bridge->br_ops->enable_set)
	57	return bridge->br_ops->enable_set(bridge, 0);
	58
	59	return 0;
	60	}
	61	EXPORT_SYMBOL_GPL(fpga_bridge_disable);
	62
9c1c4b27 AT	63	static struct fpga_bridge __fpga_bridge_get(struct device dev,
9c1c4b27 AT	64	struct fpga_image_info *info)
21aeda95	65	{
21aeda95 AT	66	struct fpga_bridge *bridge;
	67	int ret = -ENODEV;
	68
21aeda95	69	bridge = to_fpga_bridge(dev);
21aeda95 AT	70
	71	bridge->info = info;
	72
	73	if (!mutex_trylock(&bridge->mutex)) {
	74	ret = -EBUSY;
	75	goto err_dev;
	76	}
	77
	78	if (!try_module_get(dev->parent->driver->owner))
	79	goto err_ll_mod;
	80
	81	dev_dbg(&bridge->dev, "get\n");
	82
	83	return bridge;
	84
	85	err_ll_mod:
	86	mutex_unlock(&bridge->mutex);
	87	err_dev:
	88	put_device(dev);
	89	return ERR_PTR(ret);
	90	}
9c1c4b27 AT	91
	92	/**
	93	* of_fpga_bridge_get - get an exclusive reference to a fpga bridge
	94	*
	95	* @np: node pointer of a FPGA bridge
	96	* @info: fpga image specific information
	97	*
	98	* Return fpga_bridge struct if successful.
	99	* Return -EBUSY if someone already has a reference to the bridge.
	100	* Return -ENODEV if @np is not a FPGA Bridge.
	101	*/
	102	struct fpga_bridge of_fpga_bridge_get(struct device_node np,
	103	struct fpga_image_info *info)
	104	{
	105	struct device *dev;
	106
	107	dev = class_find_device(fpga_bridge_class, NULL, np,
	108	fpga_bridge_of_node_match);
	109	if (!dev)
	110	return ERR_PTR(-ENODEV);
	111
	112	return __fpga_bridge_get(dev, info);
	113	}
21aeda95 AT	114	EXPORT_SYMBOL_GPL(of_fpga_bridge_get);
21aeda95 AT	115
9c1c4b27 AT	116	static int fpga_bridge_dev_match(struct device dev, const void data)
	117	{
	118	return dev->parent == data;
	119	}
	120
	121	/**
	122	* fpga_bridge_get - get an exclusive reference to a fpga bridge
	123	* @dev: parent device that fpga bridge was registered with
060ac5c8	124	* @info: fpga manager info
9c1c4b27 AT	125	*
	126	* Given a device, get an exclusive reference to a fpga bridge.
	127	*
b4d9a0e5	128	* Return: fpga bridge struct or IS_ERR() condition containing error code.
9c1c4b27 AT	129	*/
	130	struct fpga_bridge fpga_bridge_get(struct device dev,
	131	struct fpga_image_info *info)
	132	{
	133	struct device *bridge_dev;
	134
	135	bridge_dev = class_find_device(fpga_bridge_class, NULL, dev,
	136	fpga_bridge_dev_match);
	137	if (!bridge_dev)
	138	return ERR_PTR(-ENODEV);
	139
	140	return __fpga_bridge_get(bridge_dev, info);
	141	}
	142	EXPORT_SYMBOL_GPL(fpga_bridge_get);
	143
21aeda95 AT	144	/**
	145	* fpga_bridge_put - release a reference to a bridge
	146	*
	147	* @bridge: FPGA bridge
	148	*/
	149	void fpga_bridge_put(struct fpga_bridge *bridge)
	150	{
	151	dev_dbg(&bridge->dev, "put\n");
	152
	153	bridge->info = NULL;
	154	module_put(bridge->dev.parent->driver->owner);
	155	mutex_unlock(&bridge->mutex);
	156	put_device(&bridge->dev);
	157	}
	158	EXPORT_SYMBOL_GPL(fpga_bridge_put);
	159
	160	/**
	161	* fpga_bridges_enable - enable bridges in a list
	162	* @bridge_list: list of FPGA bridges
	163	*
	164	* Enable each bridge in the list. If list is empty, do nothing.
	165	*
	166	* Return 0 for success or empty bridge list; return error code otherwise.
	167	*/
	168	int fpga_bridges_enable(struct list_head *bridge_list)
	169	{
	170	struct fpga_bridge *bridge;
21aeda95 AT	171	int ret;
21aeda95 AT	172
c37235cc	173	list_for_each_entry(bridge, bridge_list, node) {
21aeda95 AT	174	ret = fpga_bridge_enable(bridge);
	175	if (ret)
	176	return ret;
	177	}
	178
	179	return 0;
	180	}
	181	EXPORT_SYMBOL_GPL(fpga_bridges_enable);
	182
	183	/**
	184	* fpga_bridges_disable - disable bridges in a list
	185	*
	186	* @bridge_list: list of FPGA bridges
	187	*
	188	* Disable each bridge in the list. If list is empty, do nothing.
	189	*
	190	* Return 0 for success or empty bridge list; return error code otherwise.
	191	*/
	192	int fpga_bridges_disable(struct list_head *bridge_list)
	193	{
	194	struct fpga_bridge *bridge;
21aeda95 AT	195	int ret;
21aeda95 AT	196
c37235cc	197	list_for_each_entry(bridge, bridge_list, node) {
21aeda95 AT	198	ret = fpga_bridge_disable(bridge);
	199	if (ret)
	200	return ret;
	201	}
	202
	203	return 0;
	204	}
	205	EXPORT_SYMBOL_GPL(fpga_bridges_disable);
	206
	207	/**
	208	* fpga_bridges_put - put bridges
	209	*
	210	* @bridge_list: list of FPGA bridges
	211	*
	212	* For each bridge in the list, put the bridge and remove it from the list.
	213	* If list is empty, do nothing.
	214	*/
	215	void fpga_bridges_put(struct list_head *bridge_list)
	216	{
c37235cc	217	struct fpga_bridge bridge, next;
21aeda95 AT	218	unsigned long flags;
21aeda95 AT	219
c37235cc	220	list_for_each_entry_safe(bridge, next, bridge_list, node) {
21aeda95 AT	221	fpga_bridge_put(bridge);
	222
	223	spin_lock_irqsave(&bridge_list_lock, flags);
	224	list_del(&bridge->node);
	225	spin_unlock_irqrestore(&bridge_list_lock, flags);
	226	}
	227	}
	228	EXPORT_SYMBOL_GPL(fpga_bridges_put);
	229
	230	/**
9c1c4b27	231	* of_fpga_bridge_get_to_list - get a bridge, add it to a list
21aeda95 AT	232	*
	233	* @np: node pointer of a FPGA bridge
	234	* @info: fpga image specific information
	235	* @bridge_list: list of FPGA bridges
	236	*
	237	* Get an exclusive reference to the bridge and and it to the list.
	238	*
	239	* Return 0 for success, error code from of_fpga_bridge_get() othewise.
	240	*/
9c1c4b27 AT	241	int of_fpga_bridge_get_to_list(struct device_node *np,
	242	struct fpga_image_info *info,
	243	struct list_head *bridge_list)
	244	{
	245	struct fpga_bridge *bridge;
	246	unsigned long flags;
	247
	248	bridge = of_fpga_bridge_get(np, info);
	249	if (IS_ERR(bridge))
	250	return PTR_ERR(bridge);
	251
	252	spin_lock_irqsave(&bridge_list_lock, flags);
	253	list_add(&bridge->node, bridge_list);
	254	spin_unlock_irqrestore(&bridge_list_lock, flags);
	255
	256	return 0;
	257	}
	258	EXPORT_SYMBOL_GPL(of_fpga_bridge_get_to_list);
	259
	260	/**
	261	* fpga_bridge_get_to_list - given device, get a bridge, add it to a list
	262	*
	263	* @dev: FPGA bridge device
	264	* @info: fpga image specific information
	265	* @bridge_list: list of FPGA bridges
	266	*
	267	* Get an exclusive reference to the bridge and and it to the list.
	268	*
	269	* Return 0 for success, error code from fpga_bridge_get() othewise.
	270	*/
	271	int fpga_bridge_get_to_list(struct device *dev,
21aeda95 AT	272	struct fpga_image_info *info,
	273	struct list_head *bridge_list)
	274	{
	275	struct fpga_bridge *bridge;
	276	unsigned long flags;
	277
9c1c4b27	278	bridge = fpga_bridge_get(dev, info);
21aeda95 AT	279	if (IS_ERR(bridge))
	280	return PTR_ERR(bridge);
	281
	282	spin_lock_irqsave(&bridge_list_lock, flags);
	283	list_add(&bridge->node, bridge_list);
	284	spin_unlock_irqrestore(&bridge_list_lock, flags);
	285
	286	return 0;
	287	}
	288	EXPORT_SYMBOL_GPL(fpga_bridge_get_to_list);
	289
	290	static ssize_t name_show(struct device *dev,
	291	struct device_attribute attr, char buf)
	292	{
	293	struct fpga_bridge *bridge = to_fpga_bridge(dev);
	294
	295	return sprintf(buf, "%s\n", bridge->name);
	296	}
	297
	298	static ssize_t state_show(struct device *dev,
	299	struct device_attribute attr, char buf)
	300	{
	301	struct fpga_bridge *bridge = to_fpga_bridge(dev);
	302	int enable = 1;
	303
	304	if (bridge->br_ops && bridge->br_ops->enable_show)
	305	enable = bridge->br_ops->enable_show(bridge);
	306
	307	return sprintf(buf, "%s\n", enable ? "enabled" : "disabled");
	308	}
	309
	310	static DEVICE_ATTR_RO(name);
	311	static DEVICE_ATTR_RO(state);
	312
	313	static struct attribute *fpga_bridge_attrs[] = {
	314	&dev_attr_name.attr,
	315	&dev_attr_state.attr,
	316	NULL,
	317	};
	318	ATTRIBUTE_GROUPS(fpga_bridge);
	319
	320	/**
371cd1b1	321	* fpga_bridge_create - create and initialize a struct fpga_bridge
21aeda95 AT	322	* @dev: FPGA bridge device from pdev
	323	* @name: FPGA bridge name
	324	* @br_ops: pointer to structure of fpga bridge ops
	325	* @priv: FPGA bridge private data
	326	*
213befe0 AT	327	* The caller of this function is responsible for freeing the bridge with
	328	* fpga_bridge_free(). Using devm_fpga_bridge_create() instead is recommended.
	329	*
371cd1b1	330	* Return: struct fpga_bridge or NULL
21aeda95	331	*/
371cd1b1 AT	332	struct fpga_bridge fpga_bridge_create(struct device dev, const char *name,
	333	const struct fpga_bridge_ops *br_ops,
	334	void *priv)
21aeda95 AT	335	{
	336	struct fpga_bridge *bridge;
	337	int id, ret = 0;
	338
	339	if (!name \|\| !strlen(name)) {
	340	dev_err(dev, "Attempt to register with no name!\n");
371cd1b1	341	return NULL;
21aeda95 AT	342	}
	343
	344	bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
	345	if (!bridge)
371cd1b1	346	return NULL;
21aeda95 AT	347
	348	id = ida_simple_get(&fpga_bridge_ida, 0, 0, GFP_KERNEL);
	349	if (id < 0) {
	350	ret = id;
	351	goto error_kfree;
	352	}
	353
	354	mutex_init(&bridge->mutex);
	355	INIT_LIST_HEAD(&bridge->node);
	356
	357	bridge->name = name;
	358	bridge->br_ops = br_ops;
	359	bridge->priv = priv;
	360
	361	device_initialize(&bridge->dev);
845089bb	362	bridge->dev.groups = br_ops->groups;
21aeda95 AT	363	bridge->dev.class = fpga_bridge_class;
	364	bridge->dev.parent = dev;
	365	bridge->dev.of_node = dev->of_node;
	366	bridge->dev.id = id;
21aeda95 AT	367
	368	ret = dev_set_name(&bridge->dev, "br%d", id);
	369	if (ret)
	370	goto error_device;
	371
371cd1b1	372	return bridge;
21aeda95 AT	373
	374	error_device:
	375	ida_simple_remove(&fpga_bridge_ida, id);
	376	error_kfree:
	377	kfree(bridge);
	378
371cd1b1 AT	379	return NULL;
	380	}
	381	EXPORT_SYMBOL_GPL(fpga_bridge_create);
	382
	383	/**
213befe0 AT	384	* fpga_bridge_free - free a fpga bridge created by fpga_bridge_create()
213befe0 AT	385	* @bridge: FPGA bridge struct
371cd1b1 AT	386	*/
	387	void fpga_bridge_free(struct fpga_bridge *bridge)
	388	{
	389	ida_simple_remove(&fpga_bridge_ida, bridge->dev.id);
	390	kfree(bridge);
	391	}
	392	EXPORT_SYMBOL_GPL(fpga_bridge_free);
	393
213befe0 AT	394	static void devm_fpga_bridge_release(struct device dev, void res)
	395	{
	396	struct fpga_bridge bridge = (struct fpga_bridge **)res;
	397
	398	fpga_bridge_free(bridge);
	399	}
	400
371cd1b1	401	/**
213befe0 AT	402	* devm_fpga_bridge_create - create and init a managed struct fpga_bridge
	403	* @dev: FPGA bridge device from pdev
	404	* @name: FPGA bridge name
	405	* @br_ops: pointer to structure of fpga bridge ops
	406	* @priv: FPGA bridge private data
	407	*
	408	* This function is intended for use in a FPGA bridge driver's probe function.
	409	* After the bridge driver creates the struct with devm_fpga_bridge_create(), it
	410	* should register the bridge with fpga_bridge_register(). The bridge driver's
	411	* remove function should call fpga_bridge_unregister(). The bridge struct
	412	* allocated with this function will be freed automatically on driver detach.
	413	* This includes the case of a probe function returning error before calling
	414	* fpga_bridge_register(), the struct will still get cleaned up.
	415	*
	416	* Return: struct fpga_bridge or NULL
	417	*/
	418	struct fpga_bridge
	419	devm_fpga_bridge_create(struct device dev, const char *name,
	420	const struct fpga_bridge_ops br_ops, void priv)
	421	{
	422	struct fpga_bridge *ptr, bridge;
	423
	424	ptr = devres_alloc(devm_fpga_bridge_release, sizeof(*ptr), GFP_KERNEL);
	425	if (!ptr)
	426	return NULL;
	427
	428	bridge = fpga_bridge_create(dev, name, br_ops, priv);
	429	if (!bridge) {
	430	devres_free(ptr);
	431	} else {
	432	*ptr = bridge;
	433	devres_add(dev, ptr);
	434	}
	435
	436	return bridge;
	437	}
	438	EXPORT_SYMBOL_GPL(devm_fpga_bridge_create);
	439
	440	/**
	441	* fpga_bridge_register - register a FPGA bridge
	442	*
	443	* @bridge: FPGA bridge struct
371cd1b1 AT	444	*
	445	* Return: 0 for success, error code otherwise.
	446	*/
	447	int fpga_bridge_register(struct fpga_bridge *bridge)
	448	{
	449	struct device *dev = &bridge->dev;
	450	int ret;
	451
	452	ret = device_add(dev);
	453	if (ret)
	454	return ret;
	455
	456	of_platform_populate(dev->of_node, NULL, NULL, dev);
	457
	458	dev_info(dev->parent, "fpga bridge [%s] registered\n", bridge->name);
	459
	460	return 0;
21aeda95 AT	461	}
	462	EXPORT_SYMBOL_GPL(fpga_bridge_register);
	463
	464	/**
213befe0 AT	465	* fpga_bridge_unregister - unregister a FPGA bridge
	466	*
	467	* @bridge: FPGA bridge struct
	468	*
	469	* This function is intended for use in a FPGA bridge driver's remove function.
21aeda95	470	*/
371cd1b1	471	void fpga_bridge_unregister(struct fpga_bridge *bridge)
21aeda95	472	{
21aeda95 AT	473	/*
	474	* If the low level driver provides a method for putting bridge into
	475	* a desired state upon unregister, do it.
	476	*/
	477	if (bridge->br_ops && bridge->br_ops->fpga_bridge_remove)
	478	bridge->br_ops->fpga_bridge_remove(bridge);
	479
	480	device_unregister(&bridge->dev);
	481	}
	482	EXPORT_SYMBOL_GPL(fpga_bridge_unregister);
	483
	484	static void fpga_bridge_dev_release(struct device *dev)
	485	{
21aeda95 AT	486	}
	487
	488	static int __init fpga_bridge_dev_init(void)
	489	{
	490	spin_lock_init(&bridge_list_lock);
	491
	492	fpga_bridge_class = class_create(THIS_MODULE, "fpga_bridge");
	493	if (IS_ERR(fpga_bridge_class))
	494	return PTR_ERR(fpga_bridge_class);
	495
	496	fpga_bridge_class->dev_groups = fpga_bridge_groups;
	497	fpga_bridge_class->dev_release = fpga_bridge_dev_release;
	498
	499	return 0;
	500	}
	501
	502	static void __exit fpga_bridge_dev_exit(void)
	503	{
	504	class_destroy(fpga_bridge_class);
	505	ida_destroy(&fpga_bridge_ida);
	506	}
	507
	508	MODULE_DESCRIPTION("FPGA Bridge Driver");
9c1c4b27	509	MODULE_AUTHOR("Alan Tull <atull@kernel.org>");
21aeda95 AT	510	MODULE_LICENSE("GPL v2");
	511
	512	subsys_initcall(fpga_bridge_dev_init);
	513	module_exit(fpga_bridge_dev_exit);