drivers/cdx/cdx.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * CDX bus driver.
   4  *
   5  * Copyright (C) 2022-2023, Advanced Micro Devices, Inc.
   6  */
   7
   8 /*
   9  * Architecture Overview
  10  * =====================
  11  * CDX is a Hardware Architecture designed for AMD FPGA devices. It
  12  * consists of sophisticated mechanism for interaction between FPGA,
  13  * Firmware and the APUs (Application CPUs).
  14  *
  15  * Firmware resides on RPU (Realtime CPUs) which interacts with
  16  * the FPGA program manager and the APUs. The RPU provides memory-mapped
  17  * interface (RPU if) which is used to communicate with APUs.
  18  *
  19  * The diagram below shows an overview of the CDX architecture:
  20  *
  21  *          +--------------------------------------+
  22  *          |    Application CPUs (APU)            |
  23  *          |                                      |
  24  *          |                    CDX device drivers|
  25  *          |     Linux OS                |        |
  26  *          |                        CDX bus       |
  27  *          |                             |        |
  28  *          |                     CDX controller   |
  29  *          |                             |        |
  30  *          +-----------------------------|--------+
  31  *                                        | (discover, config,
  32  *                                        |  reset, rescan)
  33  *                                        |
  34  *          +------------------------| RPU if |----+
  35  *          |                             |        |
  36  *          |                             V        |
  37  *          |          Realtime CPUs (RPU)         |
  38  *          |                                      |
  39  *          +--------------------------------------+
  40  *                                |
  41  *          +---------------------|----------------+
  42  *          |  FPGA               |                |
  43  *          |      +-----------------------+       |
  44  *          |      |           |           |       |
  45  *          | +-------+    +-------+   +-------+   |
  46  *          | | dev 1 |    | dev 2 |   | dev 3 |   |
  47  *          | +-------+    +-------+   +-------+   |
  48  *          +--------------------------------------+
  49  *
  50  * The RPU firmware extracts the device information from the loaded FPGA
  51  * image and implements a mechanism that allows the APU drivers to
  52  * enumerate such devices (device personality and resource details) via
  53  * a dedicated communication channel. RPU mediates operations such as
  54  * discover, reset and rescan of the FPGA devices for the APU. This is
  55  * done using memory mapped interface provided by the RPU to APU.
  56  */
  57
  58 #include <linux/init.h>
  59 #include <linux/kernel.h>
  60 #include <linux/of.h>
  61 #include <linux/of_device.h>
  62 #include <linux/of_platform.h>
  63 #include <linux/platform_device.h>
  64 #include <linux/slab.h>
  65 #include <linux/mm.h>
  66 #include <linux/idr.h>
  67 #include <linux/cdx/cdx_bus.h>
  68 #include <linux/iommu.h>
  69 #include <linux/dma-map-ops.h>
  70 #include <linux/debugfs.h>
  71 #include "cdx.h"
  72
  73 /* Default DMA mask for devices on a CDX bus */
  74 #define CDX_DEFAULT_DMA_MASK    (~0ULL)
  75 #define MAX_CDX_CONTROLLERS 16
  76
  77 /* IDA for CDX controllers registered with the CDX bus */
  78 static DEFINE_IDA(cdx_controller_ida);
  79 /* Lock to protect controller ops */
  80 static DEFINE_MUTEX(cdx_controller_lock);
  81 /* Debugfs dir for cdx bus */
  82 static struct dentry *cdx_debugfs_dir;
  83
  84 static char *compat_node_name = "xlnx,versal-net-cdx";
  85
  86 static void cdx_destroy_res_attr(struct cdx_device *cdx_dev, int num);
  87
  88 /**
  89  * cdx_dev_reset - Reset a CDX device
  90  * @dev: CDX device
  91  *
  92  * Return: -errno on failure, 0 on success.
  93  */
  94 int cdx_dev_reset(struct device *dev)
  95 {
  96         struct cdx_device *cdx_dev = to_cdx_device(dev);
  97         struct cdx_controller *cdx = cdx_dev->cdx;
  98         struct cdx_device_config dev_config = {0};
  99         struct cdx_driver *cdx_drv;
 100         int ret;
 101
 102         cdx_drv = to_cdx_driver(dev->driver);
 103         /* Notify driver that device is being reset */
 104         if (cdx_drv && cdx_drv->reset_prepare)
 105                 cdx_drv->reset_prepare(cdx_dev);
 106
 107         dev_config.type = CDX_DEV_RESET_CONF;
 108         ret = cdx->ops->dev_configure(cdx, cdx_dev->bus_num,
 109                                       cdx_dev->dev_num, &dev_config);
 110         if (ret)
 111                 dev_err(dev, "cdx device reset failed\n");
 112
 113         /* Notify driver that device reset is complete */
 114         if (cdx_drv && cdx_drv->reset_done)
 115                 cdx_drv->reset_done(cdx_dev);
 116
 117         return ret;
 118 }
 119 EXPORT_SYMBOL_GPL(cdx_dev_reset);
 120
 121 /**
 122  * reset_cdx_device - Reset a CDX device
 123  * @dev: CDX device
 124  * @data: This is always passed as NULL, and is not used in this API,
 125  *    but is required here as the device_for_each_child() API expects
 126  *    the passed function to have this as an argument.
 127  *
 128  * Return: -errno on failure, 0 on success.
 129  */
 130 static int reset_cdx_device(struct device *dev, void *data)
 131 {
 132         return cdx_dev_reset(dev);
 133 }
 134
 135 /**
 136  * cdx_unregister_device - Unregister a CDX device
 137  * @dev: CDX device
 138  * @data: This is always passed as NULL, and is not used in this API,
 139  *        but is required here as the bus_for_each_dev() API expects
 140  *        the passed function (cdx_unregister_device) to have this
 141  *        as an argument.
 142  *
 143  * Return: 0 on success.
 144  */
 145 static int cdx_unregister_device(struct device *dev,
 146                                  void *data)
 147 {
 148         struct cdx_device *cdx_dev = to_cdx_device(dev);
 149         struct cdx_controller *cdx = cdx_dev->cdx;
 150
 151         if (cdx_dev->is_bus) {
 152                 device_for_each_child(dev, NULL, cdx_unregister_device);
 153                 if (cdx_dev->enabled && cdx->ops->bus_disable)
 154                         cdx->ops->bus_disable(cdx, cdx_dev->bus_num);
 155         } else {
 156                 cdx_destroy_res_attr(cdx_dev, MAX_CDX_DEV_RESOURCES);
 157                 debugfs_remove_recursive(cdx_dev->debugfs_dir);
 158                 kfree(cdx_dev->driver_override);
 159                 cdx_dev->driver_override = NULL;
 160         }
 161
 162         /*
 163          * Do not free cdx_dev here as it would be freed in
 164          * cdx_device_release() called from within put_device().
 165          */
 166         device_del(&cdx_dev->dev);
 167         put_device(&cdx_dev->dev);
 168
 169         return 0;
 170 }
 171
 172 static void cdx_unregister_devices(struct bus_type *bus)
 173 {
 174         /* Reset all the devices attached to cdx bus */
 175         bus_for_each_dev(bus, NULL, NULL, cdx_unregister_device);
 176 }
 177
 178 /**
 179  * cdx_match_one_device - Tell if a CDX device structure has a matching
 180  *                        CDX device id structure
 181  * @id: single CDX device id structure to match
 182  * @dev: the CDX device structure to match against
 183  *
 184  * Return: matching cdx_device_id structure or NULL if there is no match.
 185  */
 186 static inline const struct cdx_device_id *
 187 cdx_match_one_device(const struct cdx_device_id *id,
 188                      const struct cdx_device *dev)
 189 {
 190         /* Use vendor ID and device ID for matching */
 191         if ((id->vendor == CDX_ANY_ID || id->vendor == dev->vendor) &&
 192             (id->device == CDX_ANY_ID || id->device == dev->device) &&
 193             (id->subvendor == CDX_ANY_ID || id->subvendor == dev->subsystem_vendor) &&
 194             (id->subdevice == CDX_ANY_ID || id->subdevice == dev->subsystem_device) &&
 195             !((id->class ^ dev->class) & id->class_mask))
 196                 return id;
 197         return NULL;
 198 }
 199
 200 /**
 201  * cdx_match_id - See if a CDX device matches a given cdx_id table
 202  * @ids: array of CDX device ID structures to search in
 203  * @dev: the CDX device structure to match against.
 204  *
 205  * Used by a driver to check whether a CDX device is in its list of
 206  * supported devices. Returns the matching cdx_device_id structure or
 207  * NULL if there is no match.
 208  *
 209  * Return: matching cdx_device_id structure or NULL if there is no match.
 210  */
 211 static inline const struct cdx_device_id *
 212 cdx_match_id(const struct cdx_device_id *ids, struct cdx_device *dev)
 213 {
 214         if (ids) {
 215                 while (ids->vendor || ids->device) {
 216                         if (cdx_match_one_device(ids, dev))
 217                                 return ids;
 218                         ids++;
 219                 }
 220         }
 221         return NULL;
 222 }
 223
 224 int cdx_set_master(struct cdx_device *cdx_dev)
 225 {
 226         struct cdx_controller *cdx = cdx_dev->cdx;
 227         struct cdx_device_config dev_config;
 228         int ret = -EOPNOTSUPP;
 229
 230         dev_config.type = CDX_DEV_BUS_MASTER_CONF;
 231         dev_config.bus_master_enable = true;
 232         if (cdx->ops->dev_configure)
 233                 ret = cdx->ops->dev_configure(cdx, cdx_dev->bus_num,
 234                                               cdx_dev->dev_num, &dev_config);
 235
 236         return ret;
 237 }
 238 EXPORT_SYMBOL_GPL(cdx_set_master);
 239
 240 int cdx_clear_master(struct cdx_device *cdx_dev)
 241 {
 242         struct cdx_controller *cdx = cdx_dev->cdx;
 243         struct cdx_device_config dev_config;
 244         int ret = -EOPNOTSUPP;
 245
 246         dev_config.type = CDX_DEV_BUS_MASTER_CONF;
 247         dev_config.bus_master_enable = false;
 248         if (cdx->ops->dev_configure)
 249                 ret = cdx->ops->dev_configure(cdx, cdx_dev->bus_num,
 250                                               cdx_dev->dev_num, &dev_config);
 251
 252         return ret;
 253 }
 254 EXPORT_SYMBOL_GPL(cdx_clear_master);
 255
 256 /**
 257  * cdx_bus_match - device to driver matching callback
 258  * @dev: the cdx device to match against
 259  * @drv: the device driver to search for matching cdx device
 260  * structures
 261  *
 262  * Return: true on success, false otherwise.
 263  */
 264 static int cdx_bus_match(struct device *dev, struct device_driver *drv)
 265 {
 266         struct cdx_device *cdx_dev = to_cdx_device(dev);
 267         struct cdx_driver *cdx_drv = to_cdx_driver(drv);
 268         const struct cdx_device_id *found_id = NULL;
 269         const struct cdx_device_id *ids;
 270
 271         if (cdx_dev->is_bus)
 272                 return false;
 273
 274         ids = cdx_drv->match_id_table;
 275
 276         /* When driver_override is set, only bind to the matching driver */
 277         if (cdx_dev->driver_override && strcmp(cdx_dev->driver_override, drv->name))
 278                 return false;
 279
 280         found_id = cdx_match_id(ids, cdx_dev);
 281         if (!found_id)
 282                 return false;
 283
 284         do {
 285                 /*
 286                  * In case override_only was set, enforce driver_override
 287                  * matching.
 288                  */
 289                 if (!found_id->override_only)
 290                         return true;
 291                 if (cdx_dev->driver_override)
 292                         return true;
 293
 294                 ids = found_id + 1;
 295                 found_id = cdx_match_id(ids, cdx_dev);
 296         } while (found_id);
 297
 298         return false;
 299 }
 300
 301 static int cdx_probe(struct device *dev)
 302 {
 303         struct cdx_driver *cdx_drv = to_cdx_driver(dev->driver);
 304         struct cdx_device *cdx_dev = to_cdx_device(dev);
 305         int error;
 306
 307         error = cdx_drv->probe(cdx_dev);
 308         if (error) {
 309                 dev_err_probe(dev, error, "%s failed\n", __func__);
 310                 return error;
 311         }
 312
 313         return 0;
 314 }
 315
 316 static void cdx_remove(struct device *dev)
 317 {
 318         struct cdx_driver *cdx_drv = to_cdx_driver(dev->driver);
 319         struct cdx_device *cdx_dev = to_cdx_device(dev);
 320
 321         if (cdx_drv && cdx_drv->remove)
 322                 cdx_drv->remove(cdx_dev);
 323 }
 324
 325 static void cdx_shutdown(struct device *dev)
 326 {
 327         struct cdx_driver *cdx_drv = to_cdx_driver(dev->driver);
 328         struct cdx_device *cdx_dev = to_cdx_device(dev);
 329
 330         if (cdx_drv && cdx_drv->shutdown)
 331                 cdx_drv->shutdown(cdx_dev);
 332 }
 333
 334 static int cdx_dma_configure(struct device *dev)
 335 {
 336         struct cdx_driver *cdx_drv = to_cdx_driver(dev->driver);
 337         struct cdx_device *cdx_dev = to_cdx_device(dev);
 338         struct cdx_controller *cdx = cdx_dev->cdx;
 339         u32 input_id = cdx_dev->req_id;
 340         int ret;
 341
 342         ret = of_dma_configure_id(dev, cdx->dev->of_node, 0, &input_id);
 343         if (ret && ret != -EPROBE_DEFER) {
 344                 dev_err(dev, "of_dma_configure_id() failed\n");
 345                 return ret;
 346         }
 347
 348         if (!ret && !cdx_drv->driver_managed_dma) {
 349                 ret = iommu_device_use_default_domain(dev);
 350                 if (ret)
 351                         arch_teardown_dma_ops(dev);
 352         }
 353
 354         return 0;
 355 }
 356
 357 static void cdx_dma_cleanup(struct device *dev)
 358 {
 359         struct cdx_driver *cdx_drv = to_cdx_driver(dev->driver);
 360
 361         if (!cdx_drv->driver_managed_dma)
 362                 iommu_device_unuse_default_domain(dev);
 363 }
 364
 365 /* show configuration fields */
 366 #define cdx_config_attr(field, format_string)   \
 367 static ssize_t  \
 368 field##_show(struct device *dev, struct device_attribute *attr, char *buf)      \
 369 {       \
 370         struct cdx_device *cdx_dev = to_cdx_device(dev);        \
 371         return sysfs_emit(buf, format_string, cdx_dev->field);  \
 372 }       \
 373 static DEVICE_ATTR_RO(field)
 374
 375 cdx_config_attr(vendor, "0x%04x\n");
 376 cdx_config_attr(device, "0x%04x\n");
 377 cdx_config_attr(subsystem_vendor, "0x%04x\n");
 378 cdx_config_attr(subsystem_device, "0x%04x\n");
 379 cdx_config_attr(revision, "0x%02x\n");
 380 cdx_config_attr(class, "0x%06x\n");
 381
 382 static ssize_t remove_store(struct device *dev,
 383                             struct device_attribute *attr,
 384                             const char *buf, size_t count)
 385 {
 386         bool val;
 387
 388         if (kstrtobool(buf, &val) < 0)
 389                 return -EINVAL;
 390
 391         if (!val)
 392                 return -EINVAL;
 393
 394         if (device_remove_file_self(dev, attr)) {
 395                 int ret;
 396
 397                 ret = cdx_unregister_device(dev, NULL);
 398                 if (ret)
 399                         return ret;
 400         }
 401
 402         return count;
 403 }
 404 static DEVICE_ATTR_WO(remove);
 405
 406 static ssize_t reset_store(struct device *dev, struct device_attribute *attr,
 407                            const char *buf, size_t count)
 408 {
 409         struct cdx_device *cdx_dev = to_cdx_device(dev);
 410         bool val;
 411         int ret;
 412
 413         if (kstrtobool(buf, &val) < 0)
 414                 return -EINVAL;
 415
 416         if (!val)
 417                 return -EINVAL;
 418
 419         if (cdx_dev->is_bus)
 420                 /* Reset all the devices attached to cdx bus */
 421                 ret = device_for_each_child(dev, NULL, reset_cdx_device);
 422         else
 423                 ret = cdx_dev_reset(dev);
 424
 425         return ret < 0 ? ret : count;
 426 }
 427 static DEVICE_ATTR_WO(reset);
 428
 429 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
 430                              char *buf)
 431 {
 432         struct cdx_device *cdx_dev = to_cdx_device(dev);
 433
 434         return sprintf(buf, "cdx:v%04Xd%04Xsv%04Xsd%04Xc%06X\n", cdx_dev->vendor,
 435                         cdx_dev->device, cdx_dev->subsystem_vendor, cdx_dev->subsystem_device,
 436                         cdx_dev->class);
 437 }
 438 static DEVICE_ATTR_RO(modalias);
 439
 440 static ssize_t driver_override_store(struct device *dev,
 441                                      struct device_attribute *attr,
 442                                      const char *buf, size_t count)
 443 {
 444         struct cdx_device *cdx_dev = to_cdx_device(dev);
 445         int ret;
 446
 447         if (WARN_ON(dev->bus != &cdx_bus_type))
 448                 return -EINVAL;
 449
 450         ret = driver_set_override(dev, &cdx_dev->driver_override, buf, count);
 451         if (ret)
 452                 return ret;
 453
 454         return count;
 455 }
 456
 457 static ssize_t driver_override_show(struct device *dev,
 458                                     struct device_attribute *attr, char *buf)
 459 {
 460         struct cdx_device *cdx_dev = to_cdx_device(dev);
 461
 462         return sysfs_emit(buf, "%s\n", cdx_dev->driver_override);
 463 }
 464 static DEVICE_ATTR_RW(driver_override);
 465
 466 static ssize_t enable_store(struct device *dev, struct device_attribute *attr,
 467                             const char *buf, size_t count)
 468 {
 469         struct cdx_device *cdx_dev = to_cdx_device(dev);
 470         struct cdx_controller *cdx = cdx_dev->cdx;
 471         bool enable;
 472         int ret;
 473
 474         if (kstrtobool(buf, &enable) < 0)
 475                 return -EINVAL;
 476
 477         if (enable == cdx_dev->enabled)
 478                 return count;
 479
 480         if (enable && cdx->ops->bus_enable)
 481                 ret = cdx->ops->bus_enable(cdx, cdx_dev->bus_num);
 482         else if (!enable && cdx->ops->bus_disable)
 483                 ret = cdx->ops->bus_disable(cdx, cdx_dev->bus_num);
 484         else
 485                 ret = -EOPNOTSUPP;
 486
 487         if (!ret)
 488                 cdx_dev->enabled = enable;
 489
 490         return ret < 0 ? ret : count;
 491 }
 492
 493 static ssize_t enable_show(struct device *dev, struct device_attribute *attr, char *buf)
 494 {
 495         struct cdx_device *cdx_dev = to_cdx_device(dev);
 496
 497         return sysfs_emit(buf, "%u\n", cdx_dev->enabled);
 498 }
 499 static DEVICE_ATTR_RW(enable);
 500
 501 static umode_t cdx_dev_attrs_are_visible(struct kobject *kobj, struct attribute *a, int n)
 502 {
 503         struct device *dev = kobj_to_dev(kobj);
 504         struct cdx_device *cdx_dev;
 505
 506         cdx_dev = to_cdx_device(dev);
 507         if (!cdx_dev->is_bus)
 508                 return a->mode;
 509
 510         return 0;
 511 }
 512
 513 static umode_t cdx_bus_attrs_are_visible(struct kobject *kobj, struct attribute *a, int n)
 514 {
 515         struct device *dev = kobj_to_dev(kobj);
 516         struct cdx_device *cdx_dev;
 517
 518         cdx_dev = to_cdx_device(dev);
 519         if (cdx_dev->is_bus)
 520                 return a->mode;
 521
 522         return 0;
 523 }
 524
 525 static struct attribute *cdx_dev_attrs[] = {
 526         &dev_attr_remove.attr,
 527         &dev_attr_reset.attr,
 528         &dev_attr_vendor.attr,
 529         &dev_attr_device.attr,
 530         &dev_attr_subsystem_vendor.attr,
 531         &dev_attr_subsystem_device.attr,
 532         &dev_attr_class.attr,
 533         &dev_attr_revision.attr,
 534         &dev_attr_modalias.attr,
 535         &dev_attr_driver_override.attr,
 536         NULL,
 537 };
 538
 539 static const struct attribute_group cdx_dev_group = {
 540         .attrs = cdx_dev_attrs,
 541         .is_visible = cdx_dev_attrs_are_visible,
 542 };
 543
 544 static struct attribute *cdx_bus_dev_attrs[] = {
 545         &dev_attr_enable.attr,
 546         &dev_attr_reset.attr,
 547         NULL,
 548 };
 549
 550 static const struct attribute_group cdx_bus_dev_group = {
 551         .attrs = cdx_bus_dev_attrs,
 552         .is_visible = cdx_bus_attrs_are_visible,
 553 };
 554
 555 static const struct attribute_group *cdx_dev_groups[] = {
 556         &cdx_dev_group,
 557         &cdx_bus_dev_group,
 558         NULL,
 559 };
 560
 561 static int cdx_debug_resource_show(struct seq_file *s, void *data)
 562 {
 563         struct cdx_device *cdx_dev = s->private;
 564         int i;
 565
 566         for (i = 0; i < MAX_CDX_DEV_RESOURCES; i++) {
 567                 struct resource *res =  &cdx_dev->res[i];
 568
 569                 seq_printf(s, "%pr\n", res);
 570         }
 571
 572         return 0;
 573 }
 574 DEFINE_SHOW_ATTRIBUTE(cdx_debug_resource);
 575
 576 static void cdx_device_debugfs_init(struct cdx_device *cdx_dev)
 577 {
 578         cdx_dev->debugfs_dir = debugfs_create_dir(dev_name(&cdx_dev->dev), cdx_debugfs_dir);
 579         if (IS_ERR(cdx_dev->debugfs_dir))
 580                 return;
 581
 582         debugfs_create_file("resource", 0444, cdx_dev->debugfs_dir, cdx_dev,
 583                             &cdx_debug_resource_fops);
 584 }
 585
 586 static ssize_t rescan_store(const struct bus_type *bus,
 587                             const char *buf, size_t count)
 588 {
 589         struct cdx_controller *cdx;
 590         struct platform_device *pd;
 591         struct device_node *np;
 592         bool val;
 593
 594         if (kstrtobool(buf, &val) < 0)
 595                 return -EINVAL;
 596
 597         if (!val)
 598                 return -EINVAL;
 599
 600         mutex_lock(&cdx_controller_lock);
 601
 602         /* Unregister all the devices on the bus */
 603         cdx_unregister_devices(&cdx_bus_type);
 604
 605         /* Rescan all the devices */
 606         for_each_compatible_node(np, NULL, compat_node_name) {
 607                 pd = of_find_device_by_node(np);
 608                 if (!pd) {
 609                         of_node_put(np);
 610                         count = -EINVAL;
 611                         goto unlock;
 612                 }
 613
 614                 cdx = platform_get_drvdata(pd);
 615                 if (cdx && cdx->controller_registered && cdx->ops->scan)
 616                         cdx->ops->scan(cdx);
 617
 618                 put_device(&pd->dev);
 619         }
 620
 621 unlock:
 622         mutex_unlock(&cdx_controller_lock);
 623
 624         return count;
 625 }
 626 static BUS_ATTR_WO(rescan);
 627
 628 static struct attribute *cdx_bus_attrs[] = {
 629         &bus_attr_rescan.attr,
 630         NULL,
 631 };
 632 ATTRIBUTE_GROUPS(cdx_bus);
 633
 634 struct bus_type cdx_bus_type = {
 635         .name           = "cdx",
 636         .match          = cdx_bus_match,
 637         .probe          = cdx_probe,
 638         .remove         = cdx_remove,
 639         .shutdown       = cdx_shutdown,
 640         .dma_configure  = cdx_dma_configure,
 641         .dma_cleanup    = cdx_dma_cleanup,
 642         .bus_groups     = cdx_bus_groups,
 643         .dev_groups     = cdx_dev_groups,
 644 };
 645 EXPORT_SYMBOL_GPL(cdx_bus_type);
 646
 647 int __cdx_driver_register(struct cdx_driver *cdx_driver,
 648                           struct module *owner)
 649 {
 650         int error;
 651
 652         cdx_driver->driver.owner = owner;
 653         cdx_driver->driver.bus = &cdx_bus_type;
 654
 655         error = driver_register(&cdx_driver->driver);
 656         if (error) {
 657                 pr_err("driver_register() failed for %s: %d\n",
 658                        cdx_driver->driver.name, error);
 659                 return error;
 660         }
 661
 662         return 0;
 663 }
 664 EXPORT_SYMBOL_GPL(__cdx_driver_register);
 665
 666 void cdx_driver_unregister(struct cdx_driver *cdx_driver)
 667 {
 668         driver_unregister(&cdx_driver->driver);
 669 }
 670 EXPORT_SYMBOL_GPL(cdx_driver_unregister);
 671
 672 static void cdx_device_release(struct device *dev)
 673 {
 674         struct cdx_device *cdx_dev = to_cdx_device(dev);
 675
 676         kfree(cdx_dev);
 677 }
 678
 679 static const struct vm_operations_struct cdx_phys_vm_ops = {
 680 #ifdef CONFIG_HAVE_IOREMAP_PROT
 681         .access = generic_access_phys,
 682 #endif
 683 };
 684
 685 /**
 686  * cdx_mmap_resource - map a CDX resource into user memory space
 687  * @fp: File pointer. Not used in this function, but required where
 688  *      this API is registered as a callback.
 689  * @kobj: kobject for mapping
 690  * @attr: struct bin_attribute for the file being mapped
 691  * @vma: struct vm_area_struct passed into the mmap
 692  *
 693  * Use the regular CDX mapping routines to map a CDX resource into userspace.
 694  *
 695  * Return: true on success, false otherwise.
 696  */
 697 static int cdx_mmap_resource(struct file *fp, struct kobject *kobj,
 698                              struct bin_attribute *attr,
 699                              struct vm_area_struct *vma)
 700 {
 701         struct cdx_device *cdx_dev = to_cdx_device(kobj_to_dev(kobj));
 702         int num = (unsigned long)attr->private;
 703         struct resource *res;
 704         unsigned long size;
 705
 706         res = &cdx_dev->res[num];
 707         if (iomem_is_exclusive(res->start))
 708                 return -EINVAL;
 709
 710         /* Make sure the caller is mapping a valid resource for this device */
 711         size = ((cdx_resource_len(cdx_dev, num) - 1) >> PAGE_SHIFT) + 1;
 712         if (vma->vm_pgoff + vma_pages(vma) > size)
 713                 return -EINVAL;
 714
 715         /*
 716          * Map memory region and vm->vm_pgoff is expected to be an
 717          * offset within that region.
 718          */
 719         vma->vm_page_prot = pgprot_device(vma->vm_page_prot);
 720         vma->vm_pgoff += (cdx_resource_start(cdx_dev, num) >> PAGE_SHIFT);
 721         vma->vm_ops = &cdx_phys_vm_ops;
 722         return io_remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff,
 723                                   vma->vm_end - vma->vm_start,
 724                                   vma->vm_page_prot);
 725 }
 726
 727 static void cdx_destroy_res_attr(struct cdx_device *cdx_dev, int num)
 728 {
 729         int i;
 730
 731         /* removing the bin attributes */
 732         for (i = 0; i < num; i++) {
 733                 struct bin_attribute *res_attr;
 734
 735                 res_attr = cdx_dev->res_attr[i];
 736                 if (res_attr) {
 737                         sysfs_remove_bin_file(&cdx_dev->dev.kobj, res_attr);
 738                         kfree(res_attr);
 739                 }
 740         }
 741 }
 742
 743 #define CDX_RES_ATTR_NAME_LEN   10
 744 static int cdx_create_res_attr(struct cdx_device *cdx_dev, int num)
 745 {
 746         struct bin_attribute *res_attr;
 747         char *res_attr_name;
 748         int ret;
 749
 750         res_attr = kzalloc(sizeof(*res_attr) + CDX_RES_ATTR_NAME_LEN, GFP_ATOMIC);
 751         if (!res_attr)
 752                 return -ENOMEM;
 753
 754         res_attr_name = (char *)(res_attr + 1);
 755
 756         sysfs_bin_attr_init(res_attr);
 757
 758         cdx_dev->res_attr[num] = res_attr;
 759         sprintf(res_attr_name, "resource%d", num);
 760
 761         res_attr->mmap = cdx_mmap_resource;
 762         res_attr->attr.name = res_attr_name;
 763         res_attr->attr.mode = 0600;
 764         res_attr->size = cdx_resource_len(cdx_dev, num);
 765         res_attr->private = (void *)(unsigned long)num;
 766         ret = sysfs_create_bin_file(&cdx_dev->dev.kobj, res_attr);
 767         if (ret)
 768                 kfree(res_attr);
 769
 770         return ret;
 771 }
 772
 773 int cdx_device_add(struct cdx_dev_params *dev_params)
 774 {
 775         struct cdx_controller *cdx = dev_params->cdx;
 776         struct cdx_device *cdx_dev;
 777         int ret, i;
 778
 779         cdx_dev = kzalloc(sizeof(*cdx_dev), GFP_KERNEL);
 780         if (!cdx_dev)
 781                 return -ENOMEM;
 782
 783         /* Populate resource */
 784         memcpy(cdx_dev->res, dev_params->res, sizeof(struct resource) *
 785                 dev_params->res_count);
 786         cdx_dev->res_count = dev_params->res_count;
 787
 788         /* Populate CDX dev params */
 789         cdx_dev->req_id = dev_params->req_id;
 790         cdx_dev->vendor = dev_params->vendor;
 791         cdx_dev->device = dev_params->device;
 792         cdx_dev->subsystem_vendor = dev_params->subsys_vendor;
 793         cdx_dev->subsystem_device = dev_params->subsys_device;
 794         cdx_dev->class = dev_params->class;
 795         cdx_dev->revision = dev_params->revision;
 796         cdx_dev->bus_num = dev_params->bus_num;
 797         cdx_dev->dev_num = dev_params->dev_num;
 798         cdx_dev->cdx = dev_params->cdx;
 799         cdx_dev->dma_mask = CDX_DEFAULT_DMA_MASK;
 800
 801         /* Initialize generic device */
 802         device_initialize(&cdx_dev->dev);
 803         cdx_dev->dev.parent = dev_params->parent;
 804         cdx_dev->dev.bus = &cdx_bus_type;
 805         cdx_dev->dev.dma_mask = &cdx_dev->dma_mask;
 806         cdx_dev->dev.release = cdx_device_release;
 807
 808         /* Set Name */
 809         dev_set_name(&cdx_dev->dev, "cdx-%02x:%02x",
 810                      ((cdx->id << CDX_CONTROLLER_ID_SHIFT) | (cdx_dev->bus_num & CDX_BUS_NUM_MASK)),
 811                      cdx_dev->dev_num);
 812
 813         ret = device_add(&cdx_dev->dev);
 814         if (ret) {
 815                 dev_err(&cdx_dev->dev,
 816                         "cdx device add failed: %d", ret);
 817                 goto fail;
 818         }
 819
 820         /* Create resource<N> attributes */
 821         for (i = 0; i < MAX_CDX_DEV_RESOURCES; i++) {
 822                 if (cdx_resource_flags(cdx_dev, i) & IORESOURCE_MEM) {
 823                         /* skip empty resources */
 824                         if (!cdx_resource_len(cdx_dev, i))
 825                                 continue;
 826
 827                         ret = cdx_create_res_attr(cdx_dev, i);
 828                         if (ret != 0) {
 829                                 dev_err(&cdx_dev->dev,
 830                                         "cdx device resource<%d> file creation failed: %d", i, ret);
 831                                 goto resource_create_fail;
 832                         }
 833                 }
 834         }
 835
 836         cdx_device_debugfs_init(cdx_dev);
 837
 838         return 0;
 839 resource_create_fail:
 840         cdx_destroy_res_attr(cdx_dev, i);
 841         device_del(&cdx_dev->dev);
 842 fail:
 843         /*
 844          * Do not free cdx_dev here as it would be freed in
 845          * cdx_device_release() called from put_device().
 846          */
 847         put_device(&cdx_dev->dev);
 848
 849         return ret;
 850 }
 851 EXPORT_SYMBOL_NS_GPL(cdx_device_add, CDX_BUS_CONTROLLER);
 852
 853 struct device *cdx_bus_add(struct cdx_controller *cdx, u8 bus_num)
 854 {
 855         struct cdx_device *cdx_dev;
 856         int ret;
 857
 858         cdx_dev = kzalloc(sizeof(*cdx_dev), GFP_KERNEL);
 859         if (!cdx_dev)
 860                 return NULL;
 861
 862         device_initialize(&cdx_dev->dev);
 863         cdx_dev->cdx = cdx;
 864
 865         cdx_dev->dev.parent = cdx->dev;
 866         cdx_dev->dev.bus = &cdx_bus_type;
 867         cdx_dev->dev.release = cdx_device_release;
 868         cdx_dev->is_bus = true;
 869         cdx_dev->bus_num = bus_num;
 870
 871         dev_set_name(&cdx_dev->dev, "cdx-%02x",
 872                      ((cdx->id << CDX_CONTROLLER_ID_SHIFT) | (bus_num & CDX_BUS_NUM_MASK)));
 873
 874         ret = device_add(&cdx_dev->dev);
 875         if (ret) {
 876                 dev_err(&cdx_dev->dev, "cdx bus device add failed: %d\n", ret);
 877                 goto device_add_fail;
 878         }
 879
 880         if (cdx->ops->bus_enable) {
 881                 ret = cdx->ops->bus_enable(cdx, bus_num);
 882                 if (ret && ret != -EALREADY) {
 883                         dev_err(cdx->dev, "cdx bus enable failed: %d\n", ret);
 884                         goto bus_enable_fail;
 885                 }
 886         }
 887
 888         cdx_dev->enabled = true;
 889         return &cdx_dev->dev;
 890
 891 bus_enable_fail:
 892         device_del(&cdx_dev->dev);
 893 device_add_fail:
 894         put_device(&cdx_dev->dev);
 895
 896         return NULL;
 897 }
 898 EXPORT_SYMBOL_NS_GPL(cdx_bus_add, CDX_BUS_CONTROLLER);
 899
 900 int cdx_register_controller(struct cdx_controller *cdx)
 901 {
 902         int ret;
 903
 904         ret = ida_alloc_range(&cdx_controller_ida, 0,  MAX_CDX_CONTROLLERS - 1, GFP_KERNEL);
 905         if (ret < 0) {
 906                 dev_err(cdx->dev,
 907                         "No free index available. Maximum controllers already registered\n");
 908                 cdx->id = (u8)MAX_CDX_CONTROLLERS;
 909                 return ret;
 910         }
 911
 912         mutex_lock(&cdx_controller_lock);
 913         cdx->id = ret;
 914
 915         /* Scan all the devices */
 916         if (cdx->ops->scan)
 917                 cdx->ops->scan(cdx);
 918         cdx->controller_registered = true;
 919         mutex_unlock(&cdx_controller_lock);
 920
 921         return 0;
 922 }
 923 EXPORT_SYMBOL_NS_GPL(cdx_register_controller, CDX_BUS_CONTROLLER);
 924
 925 void cdx_unregister_controller(struct cdx_controller *cdx)
 926 {
 927         if (cdx->id >= MAX_CDX_CONTROLLERS)
 928                 return;
 929
 930         mutex_lock(&cdx_controller_lock);
 931
 932         cdx->controller_registered = false;
 933         device_for_each_child(cdx->dev, NULL, cdx_unregister_device);
 934         ida_free(&cdx_controller_ida, cdx->id);
 935
 936         mutex_unlock(&cdx_controller_lock);
 937 }
 938 EXPORT_SYMBOL_NS_GPL(cdx_unregister_controller, CDX_BUS_CONTROLLER);
 939
 940 static int __init cdx_bus_init(void)
 941 {
 942         int ret;
 943
 944         ret = bus_register(&cdx_bus_type);
 945         if (!ret)
 946                 cdx_debugfs_dir = debugfs_create_dir(cdx_bus_type.name, NULL);
 947
 948         return ret;
 949 }
 950 postcore_initcall(cdx_bus_init);