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