drivers/fpga/fpga-bridge.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * FPGA Bridge Framework Driver
   4  *
   5  *  Copyright (C) 2013-2016 Altera Corporation, All Rights Reserved.
   6  *  Copyright (C) 2017 Intel Corporation
   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 const struct class fpga_bridge_class;
  18
  19 /* Lock for adding/removing bridges to linked lists*/
  20 static DEFINE_SPINLOCK(bridge_list_lock);
  21
  22 /**
  23  * fpga_bridge_enable - Enable transactions on the bridge
  24  *
  25  * @bridge: FPGA bridge
  26  *
  27  * Return: 0 for success, error code otherwise.
  28  */
  29 int fpga_bridge_enable(struct fpga_bridge *bridge)
  30 {
  31         dev_dbg(&bridge->dev, "enable\n");
  32
  33         if (bridge->br_ops->enable_set)
  34                 return bridge->br_ops->enable_set(bridge, 1);
  35
  36         return 0;
  37 }
  38 EXPORT_SYMBOL_GPL(fpga_bridge_enable);
  39
  40 /**
  41  * fpga_bridge_disable - Disable transactions on the bridge
  42  *
  43  * @bridge: FPGA bridge
  44  *
  45  * Return: 0 for success, error code otherwise.
  46  */
  47 int fpga_bridge_disable(struct fpga_bridge *bridge)
  48 {
  49         dev_dbg(&bridge->dev, "disable\n");
  50
  51         if (bridge->br_ops->enable_set)
  52                 return bridge->br_ops->enable_set(bridge, 0);
  53
  54         return 0;
  55 }
  56 EXPORT_SYMBOL_GPL(fpga_bridge_disable);
  57
  58 static struct fpga_bridge *__fpga_bridge_get(struct device *bridge_dev,
  59                                              struct fpga_image_info *info)
  60 {
  61         struct fpga_bridge *bridge;
  62
  63         bridge = to_fpga_bridge(bridge_dev);
  64
  65         bridge->info = info;
  66
  67         if (!mutex_trylock(&bridge->mutex))
  68                 return ERR_PTR(-EBUSY);
  69
  70         if (!try_module_get(bridge->br_ops_owner)) {
  71                 mutex_unlock(&bridge->mutex);
  72                 return ERR_PTR(-ENODEV);
  73         }
  74
  75         dev_dbg(&bridge->dev, "get\n");
  76
  77         return bridge;
  78 }
  79
  80 /**
  81  * of_fpga_bridge_get - get an exclusive reference to an fpga bridge
  82  *
  83  * @np: node pointer of an FPGA bridge.
  84  * @info: fpga image specific information.
  85  *
  86  * Return:
  87  * * fpga_bridge struct pointer if successful.
  88  * * -EBUSY if someone already has a reference to the bridge.
  89  * * -ENODEV if @np is not an FPGA Bridge or can't take parent driver refcount.
  90  */
  91 struct fpga_bridge *of_fpga_bridge_get(struct device_node *np,
  92                                        struct fpga_image_info *info)
  93 {
  94         struct fpga_bridge *bridge;
  95         struct device *bridge_dev;
  96
  97         bridge_dev = class_find_device_by_of_node(&fpga_bridge_class, np);
  98         if (!bridge_dev)
  99                 return ERR_PTR(-ENODEV);
 100
 101         bridge = __fpga_bridge_get(bridge_dev, info);
 102         if (IS_ERR(bridge))
 103                 put_device(bridge_dev);
 104
 105         return bridge;
 106 }
 107 EXPORT_SYMBOL_GPL(of_fpga_bridge_get);
 108
 109 static int fpga_bridge_dev_match(struct device *dev, const void *data)
 110 {
 111         return dev->parent == data;
 112 }
 113
 114 /**
 115  * fpga_bridge_get - get an exclusive reference to an fpga bridge
 116  * @dev:        parent device that fpga bridge was registered with
 117  * @info:       fpga image specific information
 118  *
 119  * Given a device, get an exclusive reference to an fpga bridge.
 120  *
 121  * Return: fpga bridge struct or IS_ERR() condition containing error code.
 122  */
 123 struct fpga_bridge *fpga_bridge_get(struct device *dev,
 124                                     struct fpga_image_info *info)
 125 {
 126         struct fpga_bridge *bridge;
 127         struct device *bridge_dev;
 128
 129         bridge_dev = class_find_device(&fpga_bridge_class, NULL, dev,
 130                                        fpga_bridge_dev_match);
 131         if (!bridge_dev)
 132                 return ERR_PTR(-ENODEV);
 133
 134         bridge = __fpga_bridge_get(bridge_dev, info);
 135         if (IS_ERR(bridge))
 136                 put_device(bridge_dev);
 137
 138         return bridge;
 139 }
 140 EXPORT_SYMBOL_GPL(fpga_bridge_get);
 141
 142 /**
 143  * fpga_bridge_put - release a reference to a bridge
 144  *
 145  * @bridge: FPGA bridge
 146  */
 147 void fpga_bridge_put(struct fpga_bridge *bridge)
 148 {
 149         dev_dbg(&bridge->dev, "put\n");
 150
 151         bridge->info = NULL;
 152         module_put(bridge->br_ops_owner);
 153         mutex_unlock(&bridge->mutex);
 154         put_device(&bridge->dev);
 155 }
 156 EXPORT_SYMBOL_GPL(fpga_bridge_put);
 157
 158 /**
 159  * fpga_bridges_enable - enable bridges in a list
 160  * @bridge_list: list of FPGA bridges
 161  *
 162  * Enable each bridge in the list. If list is empty, do nothing.
 163  *
 164  * Return: 0 for success or empty bridge list or an error code otherwise.
 165  */
 166 int fpga_bridges_enable(struct list_head *bridge_list)
 167 {
 168         struct fpga_bridge *bridge;
 169         int ret;
 170
 171         list_for_each_entry(bridge, bridge_list, node) {
 172                 ret = fpga_bridge_enable(bridge);
 173                 if (ret)
 174                         return ret;
 175         }
 176
 177         return 0;
 178 }
 179 EXPORT_SYMBOL_GPL(fpga_bridges_enable);
 180
 181 /**
 182  * fpga_bridges_disable - disable bridges in a list
 183  *
 184  * @bridge_list: list of FPGA bridges
 185  *
 186  * Disable each bridge in the list. If list is empty, do nothing.
 187  *
 188  * Return: 0 for success or empty bridge list or an error code otherwise.
 189  */
 190 int fpga_bridges_disable(struct list_head *bridge_list)
 191 {
 192         struct fpga_bridge *bridge;
 193         int ret;
 194
 195         list_for_each_entry(bridge, bridge_list, node) {
 196                 ret = fpga_bridge_disable(bridge);
 197                 if (ret)
 198                         return ret;
 199         }
 200
 201         return 0;
 202 }
 203 EXPORT_SYMBOL_GPL(fpga_bridges_disable);
 204
 205 /**
 206  * fpga_bridges_put - put bridges
 207  *
 208  * @bridge_list: list of FPGA bridges
 209  *
 210  * For each bridge in the list, put the bridge and remove it from the list.
 211  * If list is empty, do nothing.
 212  */
 213 void fpga_bridges_put(struct list_head *bridge_list)
 214 {
 215         struct fpga_bridge *bridge, *next;
 216         unsigned long flags;
 217
 218         list_for_each_entry_safe(bridge, next, bridge_list, node) {
 219                 fpga_bridge_put(bridge);
 220
 221                 spin_lock_irqsave(&bridge_list_lock, flags);
 222                 list_del(&bridge->node);
 223                 spin_unlock_irqrestore(&bridge_list_lock, flags);
 224         }
 225 }
 226 EXPORT_SYMBOL_GPL(fpga_bridges_put);
 227
 228 /**
 229  * of_fpga_bridge_get_to_list - get a bridge, add it to a list
 230  *
 231  * @np: node pointer of an FPGA bridge
 232  * @info: fpga image specific information
 233  * @bridge_list: list of FPGA bridges
 234  *
 235  * Get an exclusive reference to the bridge and it to the list.
 236  *
 237  * Return: 0 for success, error code from of_fpga_bridge_get() otherwise.
 238  */
 239 int of_fpga_bridge_get_to_list(struct device_node *np,
 240                                struct fpga_image_info *info,
 241                                struct list_head *bridge_list)
 242 {
 243         struct fpga_bridge *bridge;
 244         unsigned long flags;
 245
 246         bridge = of_fpga_bridge_get(np, info);
 247         if (IS_ERR(bridge))
 248                 return PTR_ERR(bridge);
 249
 250         spin_lock_irqsave(&bridge_list_lock, flags);
 251         list_add(&bridge->node, bridge_list);
 252         spin_unlock_irqrestore(&bridge_list_lock, flags);
 253
 254         return 0;
 255 }
 256 EXPORT_SYMBOL_GPL(of_fpga_bridge_get_to_list);
 257
 258 /**
 259  * fpga_bridge_get_to_list - given device, get a bridge, add it to a list
 260  *
 261  * @dev: FPGA bridge device
 262  * @info: fpga image specific information
 263  * @bridge_list: list of FPGA bridges
 264  *
 265  * Get an exclusive reference to the bridge and it to the list.
 266  *
 267  * Return: 0 for success, error code from fpga_bridge_get() otherwise.
 268  */
 269 int fpga_bridge_get_to_list(struct device *dev,
 270                             struct fpga_image_info *info,
 271                             struct list_head *bridge_list)
 272 {
 273         struct fpga_bridge *bridge;
 274         unsigned long flags;
 275
 276         bridge = fpga_bridge_get(dev, info);
 277         if (IS_ERR(bridge))
 278                 return PTR_ERR(bridge);
 279
 280         spin_lock_irqsave(&bridge_list_lock, flags);
 281         list_add(&bridge->node, bridge_list);
 282         spin_unlock_irqrestore(&bridge_list_lock, flags);
 283
 284         return 0;
 285 }
 286 EXPORT_SYMBOL_GPL(fpga_bridge_get_to_list);
 287
 288 static ssize_t name_show(struct device *dev,
 289                          struct device_attribute *attr, char *buf)
 290 {
 291         struct fpga_bridge *bridge = to_fpga_bridge(dev);
 292
 293         return sprintf(buf, "%s\n", bridge->name);
 294 }
 295
 296 static ssize_t state_show(struct device *dev,
 297                           struct device_attribute *attr, char *buf)
 298 {
 299         struct fpga_bridge *bridge = to_fpga_bridge(dev);
 300         int state = 1;
 301
 302         if (bridge->br_ops->enable_show) {
 303                 state = bridge->br_ops->enable_show(bridge);
 304                 if (state < 0)
 305                         return state;
 306         }
 307
 308         return sysfs_emit(buf, "%s\n", state ? "enabled" : "disabled");
 309 }
 310
 311 static DEVICE_ATTR_RO(name);
 312 static DEVICE_ATTR_RO(state);
 313
 314 static struct attribute *fpga_bridge_attrs[] = {
 315         &dev_attr_name.attr,
 316         &dev_attr_state.attr,
 317         NULL,
 318 };
 319 ATTRIBUTE_GROUPS(fpga_bridge);
 320
 321 /**
 322  * __fpga_bridge_register - create and register an FPGA Bridge device
 323  * @parent:     FPGA bridge device from pdev
 324  * @name:       FPGA bridge name
 325  * @br_ops:     pointer to structure of fpga bridge ops
 326  * @priv:       FPGA bridge private data
 327  * @owner:      owner module containing the br_ops
 328  *
 329  * Return: struct fpga_bridge pointer or ERR_PTR()
 330  */
 331 struct fpga_bridge *
 332 __fpga_bridge_register(struct device *parent, const char *name,
 333                        const struct fpga_bridge_ops *br_ops,
 334                        void *priv, struct module *owner)
 335 {
 336         struct fpga_bridge *bridge;
 337         int id, ret;
 338
 339         if (!br_ops) {
 340                 dev_err(parent, "Attempt to register without fpga_bridge_ops\n");
 341                 return ERR_PTR(-EINVAL);
 342         }
 343
 344         if (!name || !strlen(name)) {
 345                 dev_err(parent, "Attempt to register with no name!\n");
 346                 return ERR_PTR(-EINVAL);
 347         }
 348
 349         bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
 350         if (!bridge)
 351                 return ERR_PTR(-ENOMEM);
 352
 353         id = ida_alloc(&fpga_bridge_ida, GFP_KERNEL);
 354         if (id < 0) {
 355                 ret = id;
 356                 goto error_kfree;
 357         }
 358
 359         mutex_init(&bridge->mutex);
 360         INIT_LIST_HEAD(&bridge->node);
 361
 362         bridge->name = name;
 363         bridge->br_ops = br_ops;
 364         bridge->br_ops_owner = owner;
 365         bridge->priv = priv;
 366
 367         bridge->dev.groups = br_ops->groups;
 368         bridge->dev.class = &fpga_bridge_class;
 369         bridge->dev.parent = parent;
 370         bridge->dev.of_node = parent->of_node;
 371         bridge->dev.id = id;
 372
 373         ret = dev_set_name(&bridge->dev, "br%d", id);
 374         if (ret)
 375                 goto error_device;
 376
 377         ret = device_register(&bridge->dev);
 378         if (ret) {
 379                 put_device(&bridge->dev);
 380                 return ERR_PTR(ret);
 381         }
 382
 383         of_platform_populate(bridge->dev.of_node, NULL, NULL, &bridge->dev);
 384
 385         return bridge;
 386
 387 error_device:
 388         ida_free(&fpga_bridge_ida, id);
 389 error_kfree:
 390         kfree(bridge);
 391
 392         return ERR_PTR(ret);
 393 }
 394 EXPORT_SYMBOL_GPL(__fpga_bridge_register);
 395
 396 /**
 397  * fpga_bridge_unregister - unregister an FPGA bridge
 398  *
 399  * @bridge: FPGA bridge struct
 400  *
 401  * This function is intended for use in an FPGA bridge driver's remove function.
 402  */
 403 void fpga_bridge_unregister(struct fpga_bridge *bridge)
 404 {
 405         /*
 406          * If the low level driver provides a method for putting bridge into
 407          * a desired state upon unregister, do it.
 408          */
 409         if (bridge->br_ops->fpga_bridge_remove)
 410                 bridge->br_ops->fpga_bridge_remove(bridge);
 411
 412         device_unregister(&bridge->dev);
 413 }
 414 EXPORT_SYMBOL_GPL(fpga_bridge_unregister);
 415
 416 static void fpga_bridge_dev_release(struct device *dev)
 417 {
 418         struct fpga_bridge *bridge = to_fpga_bridge(dev);
 419
 420         ida_free(&fpga_bridge_ida, bridge->dev.id);
 421         kfree(bridge);
 422 }
 423
 424 static const struct class fpga_bridge_class = {
 425         .name = "fpga_bridge",
 426         .dev_groups = fpga_bridge_groups,
 427         .dev_release = fpga_bridge_dev_release,
 428 };
 429
 430 static int __init fpga_bridge_dev_init(void)
 431 {
 432         return class_register(&fpga_bridge_class);
 433 }
 434
 435 static void __exit fpga_bridge_dev_exit(void)
 436 {
 437         class_unregister(&fpga_bridge_class);
 438         ida_destroy(&fpga_bridge_ida);
 439 }
 440
 441 MODULE_DESCRIPTION("FPGA Bridge Driver");
 442 MODULE_AUTHOR("Alan Tull <atull@kernel.org>");
 443 MODULE_LICENSE("GPL v2");
 444
 445 subsys_initcall(fpga_bridge_dev_init);
 446 module_exit(fpga_bridge_dev_exit);