drivers/fpga/fpga-bridge.c

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