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, const struct device_driver *drv) 266 { 267 struct cdx_device *cdx_dev = to_cdx_device(dev); 268 const 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 struct cdx_controller *cdx = cdx_dev->cdx; 342 343 if (cdx_dev->is_bus && cdx_dev->enabled && cdx->ops->bus_disable) 344 cdx->ops->bus_disable(cdx, cdx_dev->bus_num); 345 if (cdx_drv && cdx_drv->shutdown) 346 cdx_drv->shutdown(cdx_dev); 347 } 348 349 static int cdx_dma_configure(struct device *dev) 350 { 351 struct cdx_driver *cdx_drv = to_cdx_driver(dev->driver); 352 struct cdx_device *cdx_dev = to_cdx_device(dev); 353 struct cdx_controller *cdx = cdx_dev->cdx; 354 u32 input_id = cdx_dev->req_id; 355 int ret; 356 357 ret = of_dma_configure_id(dev, cdx->dev->of_node, 0, &input_id); 358 if (ret && ret != -EPROBE_DEFER) { 359 dev_err(dev, "of_dma_configure_id() failed\n"); 360 return ret; 361 } 362 363 if (!ret && !cdx_drv->driver_managed_dma) { 364 ret = iommu_device_use_default_domain(dev); 365 if (ret) 366 arch_teardown_dma_ops(dev); 367 } 368 369 return 0; 370 } 371 372 static void cdx_dma_cleanup(struct device *dev) 373 { 374 struct cdx_driver *cdx_drv = to_cdx_driver(dev->driver); 375 376 if (!cdx_drv->driver_managed_dma) 377 iommu_device_unuse_default_domain(dev); 378 } 379 380 /* show configuration fields */ 381 #define cdx_config_attr(field, format_string) \ 382 static ssize_t \ 383 field##_show(struct device *dev, struct device_attribute *attr, char *buf) \ 384 { \ 385 struct cdx_device *cdx_dev = to_cdx_device(dev); \ 386 return sysfs_emit(buf, format_string, cdx_dev->field); \ 387 } \ 388 static DEVICE_ATTR_RO(field) 389 390 cdx_config_attr(vendor, "0x%04x\n"); 391 cdx_config_attr(device, "0x%04x\n"); 392 cdx_config_attr(subsystem_vendor, "0x%04x\n"); 393 cdx_config_attr(subsystem_device, "0x%04x\n"); 394 cdx_config_attr(revision, "0x%02x\n"); 395 cdx_config_attr(class, "0x%06x\n"); 396 397 static ssize_t remove_store(struct device *dev, 398 struct device_attribute *attr, 399 const char *buf, size_t count) 400 { 401 bool val; 402 403 if (kstrtobool(buf, &val) < 0) 404 return -EINVAL; 405 406 if (!val) 407 return -EINVAL; 408 409 if (device_remove_file_self(dev, attr)) { 410 int ret; 411 412 ret = cdx_unregister_device(dev, NULL); 413 if (ret) 414 return ret; 415 } 416 417 return count; 418 } 419 static DEVICE_ATTR_WO(remove); 420 421 static ssize_t reset_store(struct device *dev, struct device_attribute *attr, 422 const char *buf, size_t count) 423 { 424 struct cdx_device *cdx_dev = to_cdx_device(dev); 425 bool val; 426 int ret; 427 428 if (kstrtobool(buf, &val) < 0) 429 return -EINVAL; 430 431 if (!val) 432 return -EINVAL; 433 434 if (cdx_dev->is_bus) 435 /* Reset all the devices attached to cdx bus */ 436 ret = device_for_each_child(dev, NULL, reset_cdx_device); 437 else 438 ret = cdx_dev_reset(dev); 439 440 return ret < 0 ? ret : count; 441 } 442 static DEVICE_ATTR_WO(reset); 443 444 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, 445 char *buf) 446 { 447 struct cdx_device *cdx_dev = to_cdx_device(dev); 448 449 return sprintf(buf, "cdx:v%04Xd%04Xsv%04Xsd%04Xc%06X\n", cdx_dev->vendor, 450 cdx_dev->device, cdx_dev->subsystem_vendor, cdx_dev->subsystem_device, 451 cdx_dev->class); 452 } 453 static DEVICE_ATTR_RO(modalias); 454 455 static ssize_t driver_override_store(struct device *dev, 456 struct device_attribute *attr, 457 const char *buf, size_t count) 458 { 459 struct cdx_device *cdx_dev = to_cdx_device(dev); 460 int ret; 461 462 if (WARN_ON(dev->bus != &cdx_bus_type)) 463 return -EINVAL; 464 465 ret = driver_set_override(dev, &cdx_dev->driver_override, buf, count); 466 if (ret) 467 return ret; 468 469 return count; 470 } 471 472 static ssize_t driver_override_show(struct device *dev, 473 struct device_attribute *attr, char *buf) 474 { 475 struct cdx_device *cdx_dev = to_cdx_device(dev); 476 477 return sysfs_emit(buf, "%s\n", cdx_dev->driver_override); 478 } 479 static DEVICE_ATTR_RW(driver_override); 480 481 static ssize_t enable_store(struct device *dev, struct device_attribute *attr, 482 const char *buf, size_t count) 483 { 484 struct cdx_device *cdx_dev = to_cdx_device(dev); 485 struct cdx_controller *cdx = cdx_dev->cdx; 486 bool enable; 487 int ret; 488 489 if (kstrtobool(buf, &enable) < 0) 490 return -EINVAL; 491 492 if (enable == cdx_dev->enabled) 493 return count; 494 495 if (enable && cdx->ops->bus_enable) 496 ret = cdx->ops->bus_enable(cdx, cdx_dev->bus_num); 497 else if (!enable && cdx->ops->bus_disable) 498 ret = cdx->ops->bus_disable(cdx, cdx_dev->bus_num); 499 else 500 ret = -EOPNOTSUPP; 501 502 if (!ret) 503 cdx_dev->enabled = enable; 504 505 return ret < 0 ? ret : count; 506 } 507 508 static ssize_t enable_show(struct device *dev, struct device_attribute *attr, char *buf) 509 { 510 struct cdx_device *cdx_dev = to_cdx_device(dev); 511 512 return sysfs_emit(buf, "%u\n", cdx_dev->enabled); 513 } 514 static DEVICE_ATTR_RW(enable); 515 516 static umode_t cdx_dev_attrs_are_visible(struct kobject *kobj, struct attribute *a, int n) 517 { 518 struct device *dev = kobj_to_dev(kobj); 519 struct cdx_device *cdx_dev; 520 521 cdx_dev = to_cdx_device(dev); 522 if (!cdx_dev->is_bus) 523 return a->mode; 524 525 return 0; 526 } 527 528 static umode_t cdx_bus_attrs_are_visible(struct kobject *kobj, struct attribute *a, int n) 529 { 530 struct device *dev = kobj_to_dev(kobj); 531 struct cdx_device *cdx_dev; 532 533 cdx_dev = to_cdx_device(dev); 534 if (cdx_dev->is_bus) 535 return a->mode; 536 537 return 0; 538 } 539 540 static struct attribute *cdx_dev_attrs[] = { 541 &dev_attr_remove.attr, 542 &dev_attr_reset.attr, 543 &dev_attr_vendor.attr, 544 &dev_attr_device.attr, 545 &dev_attr_subsystem_vendor.attr, 546 &dev_attr_subsystem_device.attr, 547 &dev_attr_class.attr, 548 &dev_attr_revision.attr, 549 &dev_attr_modalias.attr, 550 &dev_attr_driver_override.attr, 551 NULL, 552 }; 553 554 static const struct attribute_group cdx_dev_group = { 555 .attrs = cdx_dev_attrs, 556 .is_visible = cdx_dev_attrs_are_visible, 557 }; 558 559 static struct attribute *cdx_bus_dev_attrs[] = { 560 &dev_attr_enable.attr, 561 &dev_attr_reset.attr, 562 NULL, 563 }; 564 565 static const struct attribute_group cdx_bus_dev_group = { 566 .attrs = cdx_bus_dev_attrs, 567 .is_visible = cdx_bus_attrs_are_visible, 568 }; 569 570 static const struct attribute_group *cdx_dev_groups[] = { 571 &cdx_dev_group, 572 &cdx_bus_dev_group, 573 NULL, 574 }; 575 576 static int cdx_debug_resource_show(struct seq_file *s, void *data) 577 { 578 struct cdx_device *cdx_dev = s->private; 579 int i; 580 581 for (i = 0; i < MAX_CDX_DEV_RESOURCES; i++) { 582 struct resource *res = &cdx_dev->res[i]; 583 584 seq_printf(s, "%pr\n", res); 585 } 586 587 return 0; 588 } 589 DEFINE_SHOW_ATTRIBUTE(cdx_debug_resource); 590 591 static void cdx_device_debugfs_init(struct cdx_device *cdx_dev) 592 { 593 cdx_dev->debugfs_dir = debugfs_create_dir(dev_name(&cdx_dev->dev), cdx_debugfs_dir); 594 if (IS_ERR(cdx_dev->debugfs_dir)) 595 return; 596 597 debugfs_create_file("resource", 0444, cdx_dev->debugfs_dir, cdx_dev, 598 &cdx_debug_resource_fops); 599 } 600 601 static ssize_t rescan_store(const struct bus_type *bus, 602 const char *buf, size_t count) 603 { 604 struct cdx_controller *cdx; 605 struct platform_device *pd; 606 struct device_node *np; 607 bool val; 608 609 if (kstrtobool(buf, &val) < 0) 610 return -EINVAL; 611 612 if (!val) 613 return -EINVAL; 614 615 mutex_lock(&cdx_controller_lock); 616 617 /* Unregister all the devices on the bus */ 618 cdx_unregister_devices(&cdx_bus_type); 619 620 /* Rescan all the devices */ 621 for_each_compatible_node(np, NULL, compat_node_name) { 622 pd = of_find_device_by_node(np); 623 if (!pd) { 624 of_node_put(np); 625 count = -EINVAL; 626 goto unlock; 627 } 628 629 cdx = platform_get_drvdata(pd); 630 if (cdx && cdx->controller_registered && cdx->ops->scan) 631 cdx->ops->scan(cdx); 632 633 put_device(&pd->dev); 634 } 635 636 unlock: 637 mutex_unlock(&cdx_controller_lock); 638 639 return count; 640 } 641 static BUS_ATTR_WO(rescan); 642 643 static struct attribute *cdx_bus_attrs[] = { 644 &bus_attr_rescan.attr, 645 NULL, 646 }; 647 ATTRIBUTE_GROUPS(cdx_bus); 648 649 struct bus_type cdx_bus_type = { 650 .name = "cdx", 651 .match = cdx_bus_match, 652 .probe = cdx_probe, 653 .remove = cdx_remove, 654 .shutdown = cdx_shutdown, 655 .dma_configure = cdx_dma_configure, 656 .dma_cleanup = cdx_dma_cleanup, 657 .bus_groups = cdx_bus_groups, 658 .dev_groups = cdx_dev_groups, 659 }; 660 EXPORT_SYMBOL_GPL(cdx_bus_type); 661 662 int __cdx_driver_register(struct cdx_driver *cdx_driver, 663 struct module *owner) 664 { 665 int error; 666 667 cdx_driver->driver.owner = owner; 668 cdx_driver->driver.bus = &cdx_bus_type; 669 670 error = driver_register(&cdx_driver->driver); 671 if (error) { 672 pr_err("driver_register() failed for %s: %d\n", 673 cdx_driver->driver.name, error); 674 return error; 675 } 676 677 return 0; 678 } 679 EXPORT_SYMBOL_GPL(__cdx_driver_register); 680 681 void cdx_driver_unregister(struct cdx_driver *cdx_driver) 682 { 683 driver_unregister(&cdx_driver->driver); 684 } 685 EXPORT_SYMBOL_GPL(cdx_driver_unregister); 686 687 static void cdx_device_release(struct device *dev) 688 { 689 struct cdx_device *cdx_dev = to_cdx_device(dev); 690 691 kfree(cdx_dev); 692 } 693 694 static const struct vm_operations_struct cdx_phys_vm_ops = { 695 #ifdef CONFIG_HAVE_IOREMAP_PROT 696 .access = generic_access_phys, 697 #endif 698 }; 699 700 /** 701 * cdx_mmap_resource - map a CDX resource into user memory space 702 * @fp: File pointer. Not used in this function, but required where 703 * this API is registered as a callback. 704 * @kobj: kobject for mapping 705 * @attr: struct bin_attribute for the file being mapped 706 * @vma: struct vm_area_struct passed into the mmap 707 * 708 * Use the regular CDX mapping routines to map a CDX resource into userspace. 709 * 710 * Return: true on success, false otherwise. 711 */ 712 static int cdx_mmap_resource(struct file *fp, struct kobject *kobj, 713 const struct bin_attribute *attr, 714 struct vm_area_struct *vma) 715 { 716 struct cdx_device *cdx_dev = to_cdx_device(kobj_to_dev(kobj)); 717 int num = (unsigned long)attr->private; 718 struct resource *res; 719 unsigned long size; 720 721 res = &cdx_dev->res[num]; 722 if (iomem_is_exclusive(res->start)) 723 return -EINVAL; 724 725 /* Make sure the caller is mapping a valid resource for this device */ 726 size = ((cdx_resource_len(cdx_dev, num) - 1) >> PAGE_SHIFT) + 1; 727 if (vma->vm_pgoff + vma_pages(vma) > size) 728 return -EINVAL; 729 730 /* 731 * Map memory region and vm->vm_pgoff is expected to be an 732 * offset within that region. 733 */ 734 vma->vm_page_prot = pgprot_device(vma->vm_page_prot); 735 vma->vm_pgoff += (cdx_resource_start(cdx_dev, num) >> PAGE_SHIFT); 736 vma->vm_ops = &cdx_phys_vm_ops; 737 return io_remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff, 738 vma->vm_end - vma->vm_start, 739 vma->vm_page_prot); 740 } 741 742 static void cdx_destroy_res_attr(struct cdx_device *cdx_dev, int num) 743 { 744 int i; 745 746 /* removing the bin attributes */ 747 for (i = 0; i < num; i++) { 748 struct bin_attribute *res_attr; 749 750 res_attr = cdx_dev->res_attr[i]; 751 if (res_attr) { 752 sysfs_remove_bin_file(&cdx_dev->dev.kobj, res_attr); 753 kfree(res_attr); 754 } 755 } 756 } 757 758 #define CDX_RES_ATTR_NAME_LEN 10 759 static int cdx_create_res_attr(struct cdx_device *cdx_dev, int num) 760 { 761 struct bin_attribute *res_attr; 762 char *res_attr_name; 763 int ret; 764 765 res_attr = kzalloc(sizeof(*res_attr) + CDX_RES_ATTR_NAME_LEN, GFP_ATOMIC); 766 if (!res_attr) 767 return -ENOMEM; 768 769 res_attr_name = (char *)(res_attr + 1); 770 771 sysfs_bin_attr_init(res_attr); 772 773 cdx_dev->res_attr[num] = res_attr; 774 sprintf(res_attr_name, "resource%d", num); 775 776 res_attr->mmap = cdx_mmap_resource; 777 res_attr->attr.name = res_attr_name; 778 res_attr->attr.mode = 0600; 779 res_attr->size = cdx_resource_len(cdx_dev, num); 780 res_attr->private = (void *)(unsigned long)num; 781 ret = sysfs_create_bin_file(&cdx_dev->dev.kobj, res_attr); 782 if (ret) 783 kfree(res_attr); 784 785 return ret; 786 } 787 788 int cdx_device_add(struct cdx_dev_params *dev_params) 789 { 790 struct cdx_controller *cdx = dev_params->cdx; 791 struct cdx_device *cdx_dev; 792 int ret, i; 793 794 cdx_dev = kzalloc(sizeof(*cdx_dev), GFP_KERNEL); 795 if (!cdx_dev) 796 return -ENOMEM; 797 798 /* Populate resource */ 799 memcpy(cdx_dev->res, dev_params->res, sizeof(struct resource) * 800 dev_params->res_count); 801 cdx_dev->res_count = dev_params->res_count; 802 803 /* Populate CDX dev params */ 804 cdx_dev->req_id = dev_params->req_id; 805 cdx_dev->msi_dev_id = dev_params->msi_dev_id; 806 cdx_dev->vendor = dev_params->vendor; 807 cdx_dev->device = dev_params->device; 808 cdx_dev->subsystem_vendor = dev_params->subsys_vendor; 809 cdx_dev->subsystem_device = dev_params->subsys_device; 810 cdx_dev->class = dev_params->class; 811 cdx_dev->revision = dev_params->revision; 812 cdx_dev->bus_num = dev_params->bus_num; 813 cdx_dev->dev_num = dev_params->dev_num; 814 cdx_dev->cdx = dev_params->cdx; 815 cdx_dev->dma_mask = CDX_DEFAULT_DMA_MASK; 816 817 /* Initialize generic device */ 818 device_initialize(&cdx_dev->dev); 819 cdx_dev->dev.parent = dev_params->parent; 820 cdx_dev->dev.bus = &cdx_bus_type; 821 cdx_dev->dev.dma_mask = &cdx_dev->dma_mask; 822 cdx_dev->dev.release = cdx_device_release; 823 cdx_dev->msi_write_pending = false; 824 mutex_init(&cdx_dev->irqchip_lock); 825 826 /* Set Name */ 827 dev_set_name(&cdx_dev->dev, "cdx-%02x:%02x", 828 ((cdx->id << CDX_CONTROLLER_ID_SHIFT) | (cdx_dev->bus_num & CDX_BUS_NUM_MASK)), 829 cdx_dev->dev_num); 830 831 if (cdx->msi_domain) { 832 cdx_dev->num_msi = dev_params->num_msi; 833 dev_set_msi_domain(&cdx_dev->dev, cdx->msi_domain); 834 } 835 836 ret = device_add(&cdx_dev->dev); 837 if (ret) { 838 dev_err(&cdx_dev->dev, 839 "cdx device add failed: %d", ret); 840 goto fail; 841 } 842 843 /* Create resource<N> attributes */ 844 for (i = 0; i < MAX_CDX_DEV_RESOURCES; i++) { 845 if (cdx_resource_flags(cdx_dev, i) & IORESOURCE_MEM) { 846 /* skip empty resources */ 847 if (!cdx_resource_len(cdx_dev, i)) 848 continue; 849 850 ret = cdx_create_res_attr(cdx_dev, i); 851 if (ret != 0) { 852 dev_err(&cdx_dev->dev, 853 "cdx device resource<%d> file creation failed: %d", i, ret); 854 goto resource_create_fail; 855 } 856 } 857 } 858 859 cdx_device_debugfs_init(cdx_dev); 860 861 return 0; 862 resource_create_fail: 863 cdx_destroy_res_attr(cdx_dev, i); 864 device_del(&cdx_dev->dev); 865 fail: 866 /* 867 * Do not free cdx_dev here as it would be freed in 868 * cdx_device_release() called from put_device(). 869 */ 870 put_device(&cdx_dev->dev); 871 872 return ret; 873 } 874 EXPORT_SYMBOL_NS_GPL(cdx_device_add, "CDX_BUS_CONTROLLER"); 875 876 struct device *cdx_bus_add(struct cdx_controller *cdx, u8 bus_num) 877 { 878 struct cdx_device *cdx_dev; 879 int ret; 880 881 cdx_dev = kzalloc(sizeof(*cdx_dev), GFP_KERNEL); 882 if (!cdx_dev) 883 return NULL; 884 885 device_initialize(&cdx_dev->dev); 886 cdx_dev->cdx = cdx; 887 888 cdx_dev->dev.parent = cdx->dev; 889 cdx_dev->dev.bus = &cdx_bus_type; 890 cdx_dev->dev.release = cdx_device_release; 891 cdx_dev->is_bus = true; 892 cdx_dev->bus_num = bus_num; 893 894 dev_set_name(&cdx_dev->dev, "cdx-%02x", 895 ((cdx->id << CDX_CONTROLLER_ID_SHIFT) | (bus_num & CDX_BUS_NUM_MASK))); 896 897 ret = device_add(&cdx_dev->dev); 898 if (ret) { 899 dev_err(&cdx_dev->dev, "cdx bus device add failed: %d\n", ret); 900 goto device_add_fail; 901 } 902 903 if (cdx->ops->bus_enable) { 904 ret = cdx->ops->bus_enable(cdx, bus_num); 905 if (ret && ret != -EALREADY) { 906 dev_err(cdx->dev, "cdx bus enable failed: %d\n", ret); 907 goto bus_enable_fail; 908 } 909 } 910 911 cdx_dev->enabled = true; 912 return &cdx_dev->dev; 913 914 bus_enable_fail: 915 device_del(&cdx_dev->dev); 916 device_add_fail: 917 put_device(&cdx_dev->dev); 918 919 return NULL; 920 } 921 EXPORT_SYMBOL_NS_GPL(cdx_bus_add, "CDX_BUS_CONTROLLER"); 922 923 int cdx_register_controller(struct cdx_controller *cdx) 924 { 925 int ret; 926 927 ret = ida_alloc_range(&cdx_controller_ida, 0, MAX_CDX_CONTROLLERS - 1, GFP_KERNEL); 928 if (ret < 0) { 929 dev_err(cdx->dev, 930 "No free index available. Maximum controllers already registered\n"); 931 cdx->id = (u8)MAX_CDX_CONTROLLERS; 932 return ret; 933 } 934 935 mutex_lock(&cdx_controller_lock); 936 cdx->id = ret; 937 938 /* Scan all the devices */ 939 if (cdx->ops->scan) 940 cdx->ops->scan(cdx); 941 cdx->controller_registered = true; 942 mutex_unlock(&cdx_controller_lock); 943 944 return 0; 945 } 946 EXPORT_SYMBOL_NS_GPL(cdx_register_controller, "CDX_BUS_CONTROLLER"); 947 948 void cdx_unregister_controller(struct cdx_controller *cdx) 949 { 950 if (cdx->id >= MAX_CDX_CONTROLLERS) 951 return; 952 953 mutex_lock(&cdx_controller_lock); 954 955 cdx->controller_registered = false; 956 device_for_each_child(cdx->dev, NULL, cdx_unregister_device); 957 ida_free(&cdx_controller_ida, cdx->id); 958 959 mutex_unlock(&cdx_controller_lock); 960 } 961 EXPORT_SYMBOL_NS_GPL(cdx_unregister_controller, "CDX_BUS_CONTROLLER"); 962 963 static int __init cdx_bus_init(void) 964 { 965 int ret; 966 967 ret = bus_register(&cdx_bus_type); 968 if (!ret) 969 cdx_debugfs_dir = debugfs_create_dir(cdx_bus_type.name, NULL); 970 971 return ret; 972 } 973 postcore_initcall(cdx_bus_init); 974