drivers/fpga/fpga-bridge.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * FPGA Bridge Framework Driver
0004  *
0005  *  Copyright (C) 2013-2016 Altera Corporation, All Rights Reserved.
0006  *  Copyright (C) 2017 Intel Corporation
0007  */
0008 #include <linux/fpga/fpga-bridge.h>
0009 #include <linux/idr.h>
0010 #include <linux/kernel.h>
0011 #include <linux/module.h>
0012 #include <linux/of_platform.h>
0013 #include <linux/slab.h>
0014 #include <linux/spinlock.h>
0015
0016 static DEFINE_IDA(fpga_bridge_ida);
0017 static struct class *fpga_bridge_class;
0018
0019 /* Lock for adding/removing bridges to linked lists*/
0020 static DEFINE_SPINLOCK(bridge_list_lock);
0021
0022 /**
0023  * fpga_bridge_enable - Enable transactions on the bridge
0024  *
0025  * @bridge: FPGA bridge
0026  *
0027  * Return: 0 for success, error code otherwise.
0028  */
0029 int fpga_bridge_enable(struct fpga_bridge *bridge)
0030 {
0031     dev_dbg(&bridge->dev, "enable\n");
0032
0033     if (bridge->br_ops && bridge->br_ops->enable_set)
0034         return bridge->br_ops->enable_set(bridge, 1);
0035
0036     return 0;
0037 }
0038 EXPORT_SYMBOL_GPL(fpga_bridge_enable);
0039
0040 /**
0041  * fpga_bridge_disable - Disable transactions on the bridge
0042  *
0043  * @bridge: FPGA bridge
0044  *
0045  * Return: 0 for success, error code otherwise.
0046  */
0047 int fpga_bridge_disable(struct fpga_bridge *bridge)
0048 {
0049     dev_dbg(&bridge->dev, "disable\n");
0050
0051     if (bridge->br_ops && bridge->br_ops->enable_set)
0052         return bridge->br_ops->enable_set(bridge, 0);
0053
0054     return 0;
0055 }
0056 EXPORT_SYMBOL_GPL(fpga_bridge_disable);
0057
0058 static struct fpga_bridge *__fpga_bridge_get(struct device *dev,
0059                          struct fpga_image_info *info)
0060 {
0061     struct fpga_bridge *bridge;
0062     int ret = -ENODEV;
0063
0064     bridge = to_fpga_bridge(dev);
0065
0066     bridge->info = info;
0067
0068     if (!mutex_trylock(&bridge->mutex)) {
0069         ret = -EBUSY;
0070         goto err_dev;
0071     }
0072
0073     if (!try_module_get(dev->parent->driver->owner))
0074         goto err_ll_mod;
0075
0076     dev_dbg(&bridge->dev, "get\n");
0077
0078     return bridge;
0079
0080 err_ll_mod:
0081     mutex_unlock(&bridge->mutex);
0082 err_dev:
0083     put_device(dev);
0084     return ERR_PTR(ret);
0085 }
0086
0087 /**
0088  * of_fpga_bridge_get - get an exclusive reference to an fpga bridge
0089  *
0090  * @np: node pointer of an FPGA bridge
0091  * @info: fpga image specific information
0092  *
0093  * Return fpga_bridge struct if successful.
0094  * Return -EBUSY if someone already has a reference to the bridge.
0095  * Return -ENODEV if @np is not an FPGA Bridge.
0096  */
0097 struct fpga_bridge *of_fpga_bridge_get(struct device_node *np,
0098                        struct fpga_image_info *info)
0099 {
0100     struct device *dev;
0101
0102     dev = class_find_device_by_of_node(fpga_bridge_class, np);
0103     if (!dev)
0104         return ERR_PTR(-ENODEV);
0105
0106     return __fpga_bridge_get(dev, info);
0107 }
0108 EXPORT_SYMBOL_GPL(of_fpga_bridge_get);
0109
0110 static int fpga_bridge_dev_match(struct device *dev, const void *data)
0111 {
0112     return dev->parent == data;
0113 }
0114
0115 /**
0116  * fpga_bridge_get - get an exclusive reference to an fpga bridge
0117  * @dev:    parent device that fpga bridge was registered with
0118  * @info:   fpga manager info
0119  *
0120  * Given a device, get an exclusive reference to an fpga bridge.
0121  *
0122  * Return: fpga bridge struct or IS_ERR() condition containing error code.
0123  */
0124 struct fpga_bridge *fpga_bridge_get(struct device *dev,
0125                     struct fpga_image_info *info)
0126 {
0127     struct device *bridge_dev;
0128
0129     bridge_dev = class_find_device(fpga_bridge_class, NULL, dev,
0130                        fpga_bridge_dev_match);
0131     if (!bridge_dev)
0132         return ERR_PTR(-ENODEV);
0133
0134     return __fpga_bridge_get(bridge_dev, info);
0135 }
0136 EXPORT_SYMBOL_GPL(fpga_bridge_get);
0137
0138 /**
0139  * fpga_bridge_put - release a reference to a bridge
0140  *
0141  * @bridge: FPGA bridge
0142  */
0143 void fpga_bridge_put(struct fpga_bridge *bridge)
0144 {
0145     dev_dbg(&bridge->dev, "put\n");
0146
0147     bridge->info = NULL;
0148     module_put(bridge->dev.parent->driver->owner);
0149     mutex_unlock(&bridge->mutex);
0150     put_device(&bridge->dev);
0151 }
0152 EXPORT_SYMBOL_GPL(fpga_bridge_put);
0153
0154 /**
0155  * fpga_bridges_enable - enable bridges in a list
0156  * @bridge_list: list of FPGA bridges
0157  *
0158  * Enable each bridge in the list.  If list is empty, do nothing.
0159  *
0160  * Return 0 for success or empty bridge list; return error code otherwise.
0161  */
0162 int fpga_bridges_enable(struct list_head *bridge_list)
0163 {
0164     struct fpga_bridge *bridge;
0165     int ret;
0166
0167     list_for_each_entry(bridge, bridge_list, node) {
0168         ret = fpga_bridge_enable(bridge);
0169         if (ret)
0170             return ret;
0171     }
0172
0173     return 0;
0174 }
0175 EXPORT_SYMBOL_GPL(fpga_bridges_enable);
0176
0177 /**
0178  * fpga_bridges_disable - disable bridges in a list
0179  *
0180  * @bridge_list: list of FPGA bridges
0181  *
0182  * Disable each bridge in the list.  If list is empty, do nothing.
0183  *
0184  * Return 0 for success or empty bridge list; return error code otherwise.
0185  */
0186 int fpga_bridges_disable(struct list_head *bridge_list)
0187 {
0188     struct fpga_bridge *bridge;
0189     int ret;
0190
0191     list_for_each_entry(bridge, bridge_list, node) {
0192         ret = fpga_bridge_disable(bridge);
0193         if (ret)
0194             return ret;
0195     }
0196
0197     return 0;
0198 }
0199 EXPORT_SYMBOL_GPL(fpga_bridges_disable);
0200
0201 /**
0202  * fpga_bridges_put - put bridges
0203  *
0204  * @bridge_list: list of FPGA bridges
0205  *
0206  * For each bridge in the list, put the bridge and remove it from the list.
0207  * If list is empty, do nothing.
0208  */
0209 void fpga_bridges_put(struct list_head *bridge_list)
0210 {
0211     struct fpga_bridge *bridge, *next;
0212     unsigned long flags;
0213
0214     list_for_each_entry_safe(bridge, next, bridge_list, node) {
0215         fpga_bridge_put(bridge);
0216
0217         spin_lock_irqsave(&bridge_list_lock, flags);
0218         list_del(&bridge->node);
0219         spin_unlock_irqrestore(&bridge_list_lock, flags);
0220     }
0221 }
0222 EXPORT_SYMBOL_GPL(fpga_bridges_put);
0223
0224 /**
0225  * of_fpga_bridge_get_to_list - get a bridge, add it to a list
0226  *
0227  * @np: node pointer of an FPGA bridge
0228  * @info: fpga image specific information
0229  * @bridge_list: list of FPGA bridges
0230  *
0231  * Get an exclusive reference to the bridge and it to the list.
0232  *
0233  * Return 0 for success, error code from of_fpga_bridge_get() otherwise.
0234  */
0235 int of_fpga_bridge_get_to_list(struct device_node *np,
0236                    struct fpga_image_info *info,
0237                    struct list_head *bridge_list)
0238 {
0239     struct fpga_bridge *bridge;
0240     unsigned long flags;
0241
0242     bridge = of_fpga_bridge_get(np, info);
0243     if (IS_ERR(bridge))
0244         return PTR_ERR(bridge);
0245
0246     spin_lock_irqsave(&bridge_list_lock, flags);
0247     list_add(&bridge->node, bridge_list);
0248     spin_unlock_irqrestore(&bridge_list_lock, flags);
0249
0250     return 0;
0251 }
0252 EXPORT_SYMBOL_GPL(of_fpga_bridge_get_to_list);
0253
0254 /**
0255  * fpga_bridge_get_to_list - given device, get a bridge, add it to a list
0256  *
0257  * @dev: FPGA bridge device
0258  * @info: fpga image specific information
0259  * @bridge_list: list of FPGA bridges
0260  *
0261  * Get an exclusive reference to the bridge and it to the list.
0262  *
0263  * Return 0 for success, error code from fpga_bridge_get() otherwise.
0264  */
0265 int fpga_bridge_get_to_list(struct device *dev,
0266                 struct fpga_image_info *info,
0267                 struct list_head *bridge_list)
0268 {
0269     struct fpga_bridge *bridge;
0270     unsigned long flags;
0271
0272     bridge = fpga_bridge_get(dev, info);
0273     if (IS_ERR(bridge))
0274         return PTR_ERR(bridge);
0275
0276     spin_lock_irqsave(&bridge_list_lock, flags);
0277     list_add(&bridge->node, bridge_list);
0278     spin_unlock_irqrestore(&bridge_list_lock, flags);
0279
0280     return 0;
0281 }
0282 EXPORT_SYMBOL_GPL(fpga_bridge_get_to_list);
0283
0284 static ssize_t name_show(struct device *dev,
0285              struct device_attribute *attr, char *buf)
0286 {
0287     struct fpga_bridge *bridge = to_fpga_bridge(dev);
0288
0289     return sprintf(buf, "%s\n", bridge->name);
0290 }
0291
0292 static ssize_t state_show(struct device *dev,
0293               struct device_attribute *attr, char *buf)
0294 {
0295     struct fpga_bridge *bridge = to_fpga_bridge(dev);
0296     int enable = 1;
0297
0298     if (bridge->br_ops && bridge->br_ops->enable_show)
0299         enable = bridge->br_ops->enable_show(bridge);
0300
0301     return sprintf(buf, "%s\n", enable ? "enabled" : "disabled");
0302 }
0303
0304 static DEVICE_ATTR_RO(name);
0305 static DEVICE_ATTR_RO(state);
0306
0307 static struct attribute *fpga_bridge_attrs[] = {
0308     &dev_attr_name.attr,
0309     &dev_attr_state.attr,
0310     NULL,
0311 };
0312 ATTRIBUTE_GROUPS(fpga_bridge);
0313
0314 /**
0315  * fpga_bridge_register - create and register an FPGA Bridge device
0316  * @parent: FPGA bridge device from pdev
0317  * @name:   FPGA bridge name
0318  * @br_ops: pointer to structure of fpga bridge ops
0319  * @priv:   FPGA bridge private data
0320  *
0321  * Return: struct fpga_bridge pointer or ERR_PTR()
0322  */
0323 struct fpga_bridge *
0324 fpga_bridge_register(struct device *parent, const char *name,
0325              const struct fpga_bridge_ops *br_ops,
0326              void *priv)
0327 {
0328     struct fpga_bridge *bridge;
0329     int id, ret;
0330
0331     if (!br_ops) {
0332         dev_err(parent, "Attempt to register without fpga_bridge_ops\n");
0333         return ERR_PTR(-EINVAL);
0334     }
0335
0336     if (!name || !strlen(name)) {
0337         dev_err(parent, "Attempt to register with no name!\n");
0338         return ERR_PTR(-EINVAL);
0339     }
0340
0341     bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
0342     if (!bridge)
0343         return ERR_PTR(-ENOMEM);
0344
0345     id = ida_alloc(&fpga_bridge_ida, GFP_KERNEL);
0346     if (id < 0) {
0347         ret = id;
0348         goto error_kfree;
0349     }
0350
0351     mutex_init(&bridge->mutex);
0352     INIT_LIST_HEAD(&bridge->node);
0353
0354     bridge->name = name;
0355     bridge->br_ops = br_ops;
0356     bridge->priv = priv;
0357
0358     bridge->dev.groups = br_ops->groups;
0359     bridge->dev.class = fpga_bridge_class;
0360     bridge->dev.parent = parent;
0361     bridge->dev.of_node = parent->of_node;
0362     bridge->dev.id = id;
0363     of_platform_populate(bridge->dev.of_node, NULL, NULL, &bridge->dev);
0364
0365     ret = dev_set_name(&bridge->dev, "br%d", id);
0366     if (ret)
0367         goto error_device;
0368
0369     ret = device_register(&bridge->dev);
0370     if (ret) {
0371         put_device(&bridge->dev);
0372         return ERR_PTR(ret);
0373     }
0374
0375     return bridge;
0376
0377 error_device:
0378     ida_free(&fpga_bridge_ida, id);
0379 error_kfree:
0380     kfree(bridge);
0381
0382     return ERR_PTR(ret);
0383 }
0384 EXPORT_SYMBOL_GPL(fpga_bridge_register);
0385
0386 /**
0387  * fpga_bridge_unregister - unregister an FPGA bridge
0388  *
0389  * @bridge: FPGA bridge struct
0390  *
0391  * This function is intended for use in an FPGA bridge driver's remove function.
0392  */
0393 void fpga_bridge_unregister(struct fpga_bridge *bridge)
0394 {
0395     /*
0396      * If the low level driver provides a method for putting bridge into
0397      * a desired state upon unregister, do it.
0398      */
0399     if (bridge->br_ops && bridge->br_ops->fpga_bridge_remove)
0400         bridge->br_ops->fpga_bridge_remove(bridge);
0401
0402     device_unregister(&bridge->dev);
0403 }
0404 EXPORT_SYMBOL_GPL(fpga_bridge_unregister);
0405
0406 static void fpga_bridge_dev_release(struct device *dev)
0407 {
0408     struct fpga_bridge *bridge = to_fpga_bridge(dev);
0409
0410     ida_free(&fpga_bridge_ida, bridge->dev.id);
0411     kfree(bridge);
0412 }
0413
0414 static int __init fpga_bridge_dev_init(void)
0415 {
0416     fpga_bridge_class = class_create(THIS_MODULE, "fpga_bridge");
0417     if (IS_ERR(fpga_bridge_class))
0418         return PTR_ERR(fpga_bridge_class);
0419
0420     fpga_bridge_class->dev_groups = fpga_bridge_groups;
0421     fpga_bridge_class->dev_release = fpga_bridge_dev_release;
0422
0423     return 0;
0424 }
0425
0426 static void __exit fpga_bridge_dev_exit(void)
0427 {
0428     class_destroy(fpga_bridge_class);
0429     ida_destroy(&fpga_bridge_ida);
0430 }
0431
0432 MODULE_DESCRIPTION("FPGA Bridge Driver");
0433 MODULE_AUTHOR("Alan Tull <atull@kernel.org>");
0434 MODULE_LICENSE("GPL v2");
0435
0436 subsys_initcall(fpga_bridge_dev_init);
0437 module_exit(fpga_bridge_dev_exit);