![Moritz Fischer](/assets/img/avatar_default.png)
Clean up an outdated comment claiming FPGA regions implement devicetree support for reprogramming FPGAs. Signed-off-by: Moritz Fischer <mdf@kernel.org>
349 lines
8.4 KiB
C
349 lines
8.4 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* FPGA Region - Support for FPGA programming under Linux
|
|
*
|
|
* Copyright (C) 2013-2016 Altera Corporation
|
|
* Copyright (C) 2017 Intel Corporation
|
|
*/
|
|
#include <linux/fpga/fpga-bridge.h>
|
|
#include <linux/fpga/fpga-mgr.h>
|
|
#include <linux/fpga/fpga-region.h>
|
|
#include <linux/idr.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/list.h>
|
|
#include <linux/module.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/spinlock.h>
|
|
|
|
static DEFINE_IDA(fpga_region_ida);
|
|
static struct class *fpga_region_class;
|
|
|
|
struct fpga_region *fpga_region_class_find(
|
|
struct device *start, const void *data,
|
|
int (*match)(struct device *, const void *))
|
|
{
|
|
struct device *dev;
|
|
|
|
dev = class_find_device(fpga_region_class, start, data, match);
|
|
if (!dev)
|
|
return NULL;
|
|
|
|
return to_fpga_region(dev);
|
|
}
|
|
EXPORT_SYMBOL_GPL(fpga_region_class_find);
|
|
|
|
/**
|
|
* fpga_region_get - get an exclusive reference to a fpga region
|
|
* @region: FPGA Region struct
|
|
*
|
|
* Caller should call fpga_region_put() when done with region.
|
|
*
|
|
* Return fpga_region struct if successful.
|
|
* Return -EBUSY if someone already has a reference to the region.
|
|
* Return -ENODEV if @np is not a FPGA Region.
|
|
*/
|
|
static struct fpga_region *fpga_region_get(struct fpga_region *region)
|
|
{
|
|
struct device *dev = ®ion->dev;
|
|
|
|
if (!mutex_trylock(®ion->mutex)) {
|
|
dev_dbg(dev, "%s: FPGA Region already in use\n", __func__);
|
|
return ERR_PTR(-EBUSY);
|
|
}
|
|
|
|
get_device(dev);
|
|
if (!try_module_get(dev->parent->driver->owner)) {
|
|
put_device(dev);
|
|
mutex_unlock(®ion->mutex);
|
|
return ERR_PTR(-ENODEV);
|
|
}
|
|
|
|
dev_dbg(dev, "get\n");
|
|
|
|
return region;
|
|
}
|
|
|
|
/**
|
|
* fpga_region_put - release a reference to a region
|
|
*
|
|
* @region: FPGA region
|
|
*/
|
|
static void fpga_region_put(struct fpga_region *region)
|
|
{
|
|
struct device *dev = ®ion->dev;
|
|
|
|
dev_dbg(dev, "put\n");
|
|
|
|
module_put(dev->parent->driver->owner);
|
|
put_device(dev);
|
|
mutex_unlock(®ion->mutex);
|
|
}
|
|
|
|
/**
|
|
* fpga_region_program_fpga - program FPGA
|
|
*
|
|
* @region: FPGA region
|
|
*
|
|
* Program an FPGA using fpga image info (region->info).
|
|
* If the region has a get_bridges function, the exclusive reference for the
|
|
* bridges will be held if programming succeeds. This is intended to prevent
|
|
* reprogramming the region until the caller considers it safe to do so.
|
|
* The caller will need to call fpga_bridges_put() before attempting to
|
|
* reprogram the region.
|
|
*
|
|
* Return 0 for success or negative error code.
|
|
*/
|
|
int fpga_region_program_fpga(struct fpga_region *region)
|
|
{
|
|
struct device *dev = ®ion->dev;
|
|
struct fpga_image_info *info = region->info;
|
|
int ret;
|
|
|
|
region = fpga_region_get(region);
|
|
if (IS_ERR(region)) {
|
|
dev_err(dev, "failed to get FPGA region\n");
|
|
return PTR_ERR(region);
|
|
}
|
|
|
|
ret = fpga_mgr_lock(region->mgr);
|
|
if (ret) {
|
|
dev_err(dev, "FPGA manager is busy\n");
|
|
goto err_put_region;
|
|
}
|
|
|
|
/*
|
|
* In some cases, we already have a list of bridges in the
|
|
* fpga region struct. Or we don't have any bridges.
|
|
*/
|
|
if (region->get_bridges) {
|
|
ret = region->get_bridges(region);
|
|
if (ret) {
|
|
dev_err(dev, "failed to get fpga region bridges\n");
|
|
goto err_unlock_mgr;
|
|
}
|
|
}
|
|
|
|
ret = fpga_bridges_disable(®ion->bridge_list);
|
|
if (ret) {
|
|
dev_err(dev, "failed to disable bridges\n");
|
|
goto err_put_br;
|
|
}
|
|
|
|
ret = fpga_mgr_load(region->mgr, info);
|
|
if (ret) {
|
|
dev_err(dev, "failed to load FPGA image\n");
|
|
goto err_put_br;
|
|
}
|
|
|
|
ret = fpga_bridges_enable(®ion->bridge_list);
|
|
if (ret) {
|
|
dev_err(dev, "failed to enable region bridges\n");
|
|
goto err_put_br;
|
|
}
|
|
|
|
fpga_mgr_unlock(region->mgr);
|
|
fpga_region_put(region);
|
|
|
|
return 0;
|
|
|
|
err_put_br:
|
|
if (region->get_bridges)
|
|
fpga_bridges_put(®ion->bridge_list);
|
|
err_unlock_mgr:
|
|
fpga_mgr_unlock(region->mgr);
|
|
err_put_region:
|
|
fpga_region_put(region);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(fpga_region_program_fpga);
|
|
|
|
static ssize_t compat_id_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct fpga_region *region = to_fpga_region(dev);
|
|
|
|
if (!region->compat_id)
|
|
return -ENOENT;
|
|
|
|
return sprintf(buf, "%016llx%016llx\n",
|
|
(unsigned long long)region->compat_id->id_h,
|
|
(unsigned long long)region->compat_id->id_l);
|
|
}
|
|
|
|
static DEVICE_ATTR_RO(compat_id);
|
|
|
|
static struct attribute *fpga_region_attrs[] = {
|
|
&dev_attr_compat_id.attr,
|
|
NULL,
|
|
};
|
|
ATTRIBUTE_GROUPS(fpga_region);
|
|
|
|
/**
|
|
* fpga_region_create - alloc and init a struct fpga_region
|
|
* @dev: device parent
|
|
* @mgr: manager that programs this region
|
|
* @get_bridges: optional function to get bridges to a list
|
|
*
|
|
* The caller of this function is responsible for freeing the resulting region
|
|
* struct with fpga_region_free(). Using devm_fpga_region_create() instead is
|
|
* recommended.
|
|
*
|
|
* Return: struct fpga_region or NULL
|
|
*/
|
|
struct fpga_region
|
|
*fpga_region_create(struct device *dev,
|
|
struct fpga_manager *mgr,
|
|
int (*get_bridges)(struct fpga_region *))
|
|
{
|
|
struct fpga_region *region;
|
|
int id, ret = 0;
|
|
|
|
region = kzalloc(sizeof(*region), GFP_KERNEL);
|
|
if (!region)
|
|
return NULL;
|
|
|
|
id = ida_simple_get(&fpga_region_ida, 0, 0, GFP_KERNEL);
|
|
if (id < 0)
|
|
goto err_free;
|
|
|
|
region->mgr = mgr;
|
|
region->get_bridges = get_bridges;
|
|
mutex_init(®ion->mutex);
|
|
INIT_LIST_HEAD(®ion->bridge_list);
|
|
|
|
device_initialize(®ion->dev);
|
|
region->dev.class = fpga_region_class;
|
|
region->dev.parent = dev;
|
|
region->dev.of_node = dev->of_node;
|
|
region->dev.id = id;
|
|
|
|
ret = dev_set_name(®ion->dev, "region%d", id);
|
|
if (ret)
|
|
goto err_remove;
|
|
|
|
return region;
|
|
|
|
err_remove:
|
|
ida_simple_remove(&fpga_region_ida, id);
|
|
err_free:
|
|
kfree(region);
|
|
|
|
return NULL;
|
|
}
|
|
EXPORT_SYMBOL_GPL(fpga_region_create);
|
|
|
|
/**
|
|
* fpga_region_free - free a FPGA region created by fpga_region_create()
|
|
* @region: FPGA region
|
|
*/
|
|
void fpga_region_free(struct fpga_region *region)
|
|
{
|
|
ida_simple_remove(&fpga_region_ida, region->dev.id);
|
|
kfree(region);
|
|
}
|
|
EXPORT_SYMBOL_GPL(fpga_region_free);
|
|
|
|
static void devm_fpga_region_release(struct device *dev, void *res)
|
|
{
|
|
struct fpga_region *region = *(struct fpga_region **)res;
|
|
|
|
fpga_region_free(region);
|
|
}
|
|
|
|
/**
|
|
* devm_fpga_region_create - create and initialize a managed FPGA region struct
|
|
* @dev: device parent
|
|
* @mgr: manager that programs this region
|
|
* @get_bridges: optional function to get bridges to a list
|
|
*
|
|
* This function is intended for use in a FPGA region driver's probe function.
|
|
* After the region driver creates the region struct with
|
|
* devm_fpga_region_create(), it should register it with fpga_region_register().
|
|
* The region driver's remove function should call fpga_region_unregister().
|
|
* The region 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_region_register(), the struct will still get cleaned up.
|
|
*
|
|
* Return: struct fpga_region or NULL
|
|
*/
|
|
struct fpga_region
|
|
*devm_fpga_region_create(struct device *dev,
|
|
struct fpga_manager *mgr,
|
|
int (*get_bridges)(struct fpga_region *))
|
|
{
|
|
struct fpga_region **ptr, *region;
|
|
|
|
ptr = devres_alloc(devm_fpga_region_release, sizeof(*ptr), GFP_KERNEL);
|
|
if (!ptr)
|
|
return NULL;
|
|
|
|
region = fpga_region_create(dev, mgr, get_bridges);
|
|
if (!region) {
|
|
devres_free(ptr);
|
|
} else {
|
|
*ptr = region;
|
|
devres_add(dev, ptr);
|
|
}
|
|
|
|
return region;
|
|
}
|
|
EXPORT_SYMBOL_GPL(devm_fpga_region_create);
|
|
|
|
/**
|
|
* fpga_region_register - register a FPGA region
|
|
* @region: FPGA region
|
|
*
|
|
* Return: 0 or -errno
|
|
*/
|
|
int fpga_region_register(struct fpga_region *region)
|
|
{
|
|
return device_add(®ion->dev);
|
|
}
|
|
EXPORT_SYMBOL_GPL(fpga_region_register);
|
|
|
|
/**
|
|
* fpga_region_unregister - unregister a FPGA region
|
|
* @region: FPGA region
|
|
*
|
|
* This function is intended for use in a FPGA region driver's remove function.
|
|
*/
|
|
void fpga_region_unregister(struct fpga_region *region)
|
|
{
|
|
device_unregister(®ion->dev);
|
|
}
|
|
EXPORT_SYMBOL_GPL(fpga_region_unregister);
|
|
|
|
static void fpga_region_dev_release(struct device *dev)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* fpga_region_init - init function for fpga_region class
|
|
* Creates the fpga_region class and registers a reconfig notifier.
|
|
*/
|
|
static int __init fpga_region_init(void)
|
|
{
|
|
fpga_region_class = class_create(THIS_MODULE, "fpga_region");
|
|
if (IS_ERR(fpga_region_class))
|
|
return PTR_ERR(fpga_region_class);
|
|
|
|
fpga_region_class->dev_groups = fpga_region_groups;
|
|
fpga_region_class->dev_release = fpga_region_dev_release;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void __exit fpga_region_exit(void)
|
|
{
|
|
class_destroy(fpga_region_class);
|
|
ida_destroy(&fpga_region_ida);
|
|
}
|
|
|
|
subsys_initcall(fpga_region_init);
|
|
module_exit(fpga_region_exit);
|
|
|
|
MODULE_DESCRIPTION("FPGA Region");
|
|
MODULE_AUTHOR("Alan Tull <atull@kernel.org>");
|
|
MODULE_LICENSE("GPL v2");
|