// 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 const 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 an fpga region * @region: FPGA Region struct * * Caller should call fpga_region_put() when done with region. * * Return: * * fpga_region struct if successful. * * -EBUSY if someone already has a reference to the region. * * -ENODEV if can't take parent driver module refcount. */ 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(region->ops_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(region->ops_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_register_full - create and register an FPGA Region device * @parent: device parent * @info: parameters for FPGA Region * @owner: module containing the get_bridges function * * Return: struct fpga_region or ERR_PTR() */ struct fpga_region * __fpga_region_register_full(struct device *parent, const struct fpga_region_info *info, struct module *owner) { struct fpga_region *region; int id, ret = 0; if (!info) { dev_err(parent, "Attempt to register without required info structure\n"); return ERR_PTR(-EINVAL); } region = kzalloc(sizeof(*region), GFP_KERNEL); if (!region) return ERR_PTR(-ENOMEM); id = ida_alloc(&fpga_region_ida, GFP_KERNEL); if (id < 0) { ret = id; goto err_free; } region->mgr = info->mgr; region->compat_id = info->compat_id; region->priv = info->priv; region->get_bridges = info->get_bridges; region->ops_owner = owner; mutex_init(®ion->mutex); INIT_LIST_HEAD(®ion->bridge_list); region->dev.class = &fpga_region_class; region->dev.parent = parent; region->dev.of_node = parent->of_node; region->dev.id = id; ret = dev_set_name(®ion->dev, "region%d", id); if (ret) goto err_remove; ret = device_register(®ion->dev); if (ret) { put_device(®ion->dev); return ERR_PTR(ret); } return region; err_remove: ida_free(&fpga_region_ida, id); err_free: kfree(region); return ERR_PTR(ret); } EXPORT_SYMBOL_GPL(__fpga_region_register_full); /** * __fpga_region_register - create and register an FPGA Region device * @parent: device parent * @mgr: manager that programs this region * @get_bridges: optional function to get bridges to a list * @owner: module containing the get_bridges function * * This simple version of the register function should be sufficient for most users. * The fpga_region_register_full() function is available for users that need to * pass additional, optional parameters. * * Return: struct fpga_region or ERR_PTR() */ struct fpga_region * __fpga_region_register(struct device *parent, struct fpga_manager *mgr, int (*get_bridges)(struct fpga_region *), struct module *owner) { struct fpga_region_info info = { 0 }; info.mgr = mgr; info.get_bridges = get_bridges; return __fpga_region_register_full(parent, &info, owner); } EXPORT_SYMBOL_GPL(__fpga_region_register); /** * fpga_region_unregister - unregister an FPGA region * @region: FPGA region * * This function is intended for use in an 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) { struct fpga_region *region = to_fpga_region(dev); ida_free(&fpga_region_ida, region->dev.id); kfree(region); } static const struct class fpga_region_class = { .name = "fpga_region", .dev_groups = fpga_region_groups, .dev_release = fpga_region_dev_release, }; /** * fpga_region_init - creates the fpga_region class. * * Return: 0 on success or ERR_PTR() on error. */ static int __init fpga_region_init(void) { return class_register(&fpga_region_class); } static void __exit fpga_region_exit(void) { class_unregister(&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");