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