1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright(c) 2019 Intel Corporation. All rights rsvd. */ 3 #include <linux/init.h> 4 #include <linux/kernel.h> 5 #include <linux/module.h> 6 #include <linux/pci.h> 7 #include <linux/device.h> 8 #include <linux/io-64-nonatomic-lo-hi.h> 9 #include <uapi/linux/idxd.h> 10 #include "registers.h" 11 #include "idxd.h" 12 13 static char *idxd_wq_type_names[] = { 14 [IDXD_WQT_NONE] = "none", 15 [IDXD_WQT_KERNEL] = "kernel", 16 [IDXD_WQT_USER] = "user", 17 }; 18 19 static void idxd_conf_device_release(struct device *dev) 20 { 21 dev_dbg(dev, "%s for %s\n", __func__, dev_name(dev)); 22 } 23 24 static struct device_type idxd_group_device_type = { 25 .name = "group", 26 .release = idxd_conf_device_release, 27 }; 28 29 static struct device_type idxd_wq_device_type = { 30 .name = "wq", 31 .release = idxd_conf_device_release, 32 }; 33 34 static struct device_type idxd_engine_device_type = { 35 .name = "engine", 36 .release = idxd_conf_device_release, 37 }; 38 39 static struct device_type dsa_device_type = { 40 .name = "dsa", 41 .release = idxd_conf_device_release, 42 }; 43 44 static inline bool is_dsa_dev(struct device *dev) 45 { 46 return dev ? dev->type == &dsa_device_type : false; 47 } 48 49 static inline bool is_idxd_dev(struct device *dev) 50 { 51 return is_dsa_dev(dev); 52 } 53 54 static inline bool is_idxd_wq_dev(struct device *dev) 55 { 56 return dev ? dev->type == &idxd_wq_device_type : false; 57 } 58 59 static inline bool is_idxd_wq_dmaengine(struct idxd_wq *wq) 60 { 61 if (wq->type == IDXD_WQT_KERNEL && 62 strcmp(wq->name, "dmaengine") == 0) 63 return true; 64 return false; 65 } 66 67 static inline bool is_idxd_wq_cdev(struct idxd_wq *wq) 68 { 69 return wq->type == IDXD_WQT_USER; 70 } 71 72 static int idxd_config_bus_match(struct device *dev, 73 struct device_driver *drv) 74 { 75 int matched = 0; 76 77 if (is_idxd_dev(dev)) { 78 struct idxd_device *idxd = confdev_to_idxd(dev); 79 80 if (idxd->state != IDXD_DEV_CONF_READY) 81 return 0; 82 matched = 1; 83 } else if (is_idxd_wq_dev(dev)) { 84 struct idxd_wq *wq = confdev_to_wq(dev); 85 struct idxd_device *idxd = wq->idxd; 86 87 if (idxd->state < IDXD_DEV_CONF_READY) 88 return 0; 89 90 if (wq->state != IDXD_WQ_DISABLED) { 91 dev_dbg(dev, "%s not disabled\n", dev_name(dev)); 92 return 0; 93 } 94 matched = 1; 95 } 96 97 if (matched) 98 dev_dbg(dev, "%s matched\n", dev_name(dev)); 99 100 return matched; 101 } 102 103 static int idxd_config_bus_probe(struct device *dev) 104 { 105 int rc; 106 unsigned long flags; 107 108 dev_dbg(dev, "%s called\n", __func__); 109 110 if (is_idxd_dev(dev)) { 111 struct idxd_device *idxd = confdev_to_idxd(dev); 112 113 if (idxd->state != IDXD_DEV_CONF_READY) { 114 dev_warn(dev, "Device not ready for config\n"); 115 return -EBUSY; 116 } 117 118 if (!try_module_get(THIS_MODULE)) 119 return -ENXIO; 120 121 spin_lock_irqsave(&idxd->dev_lock, flags); 122 123 /* Perform IDXD configuration and enabling */ 124 rc = idxd_device_config(idxd); 125 if (rc < 0) { 126 spin_unlock_irqrestore(&idxd->dev_lock, flags); 127 module_put(THIS_MODULE); 128 dev_warn(dev, "Device config failed: %d\n", rc); 129 return rc; 130 } 131 132 /* start device */ 133 rc = idxd_device_enable(idxd); 134 if (rc < 0) { 135 spin_unlock_irqrestore(&idxd->dev_lock, flags); 136 module_put(THIS_MODULE); 137 dev_warn(dev, "Device enable failed: %d\n", rc); 138 return rc; 139 } 140 141 spin_unlock_irqrestore(&idxd->dev_lock, flags); 142 dev_info(dev, "Device %s enabled\n", dev_name(dev)); 143 144 rc = idxd_register_dma_device(idxd); 145 if (rc < 0) { 146 spin_unlock_irqrestore(&idxd->dev_lock, flags); 147 module_put(THIS_MODULE); 148 dev_dbg(dev, "Failed to register dmaengine device\n"); 149 return rc; 150 } 151 return 0; 152 } else if (is_idxd_wq_dev(dev)) { 153 struct idxd_wq *wq = confdev_to_wq(dev); 154 struct idxd_device *idxd = wq->idxd; 155 156 mutex_lock(&wq->wq_lock); 157 158 if (idxd->state != IDXD_DEV_ENABLED) { 159 mutex_unlock(&wq->wq_lock); 160 dev_warn(dev, "Enabling while device not enabled.\n"); 161 return -EPERM; 162 } 163 164 if (wq->state != IDXD_WQ_DISABLED) { 165 mutex_unlock(&wq->wq_lock); 166 dev_warn(dev, "WQ %d already enabled.\n", wq->id); 167 return -EBUSY; 168 } 169 170 if (!wq->group) { 171 mutex_unlock(&wq->wq_lock); 172 dev_warn(dev, "WQ not attached to group.\n"); 173 return -EINVAL; 174 } 175 176 if (strlen(wq->name) == 0) { 177 mutex_unlock(&wq->wq_lock); 178 dev_warn(dev, "WQ name not set.\n"); 179 return -EINVAL; 180 } 181 182 rc = idxd_wq_alloc_resources(wq); 183 if (rc < 0) { 184 mutex_unlock(&wq->wq_lock); 185 dev_warn(dev, "WQ resource alloc failed\n"); 186 return rc; 187 } 188 189 spin_lock_irqsave(&idxd->dev_lock, flags); 190 rc = idxd_device_config(idxd); 191 if (rc < 0) { 192 spin_unlock_irqrestore(&idxd->dev_lock, flags); 193 mutex_unlock(&wq->wq_lock); 194 dev_warn(dev, "Writing WQ %d config failed: %d\n", 195 wq->id, rc); 196 return rc; 197 } 198 199 rc = idxd_wq_enable(wq); 200 if (rc < 0) { 201 spin_unlock_irqrestore(&idxd->dev_lock, flags); 202 mutex_unlock(&wq->wq_lock); 203 dev_warn(dev, "WQ %d enabling failed: %d\n", 204 wq->id, rc); 205 return rc; 206 } 207 spin_unlock_irqrestore(&idxd->dev_lock, flags); 208 209 rc = idxd_wq_map_portal(wq); 210 if (rc < 0) { 211 dev_warn(dev, "wq portal mapping failed: %d\n", rc); 212 rc = idxd_wq_disable(wq); 213 if (rc < 0) 214 dev_warn(dev, "IDXD wq disable failed\n"); 215 spin_unlock_irqrestore(&idxd->dev_lock, flags); 216 mutex_unlock(&wq->wq_lock); 217 return rc; 218 } 219 220 wq->client_count = 0; 221 222 dev_info(dev, "wq %s enabled\n", dev_name(&wq->conf_dev)); 223 224 if (is_idxd_wq_dmaengine(wq)) { 225 rc = idxd_register_dma_channel(wq); 226 if (rc < 0) { 227 dev_dbg(dev, "DMA channel register failed\n"); 228 mutex_unlock(&wq->wq_lock); 229 return rc; 230 } 231 } else if (is_idxd_wq_cdev(wq)) { 232 rc = idxd_wq_add_cdev(wq); 233 if (rc < 0) { 234 dev_dbg(dev, "Cdev creation failed\n"); 235 mutex_unlock(&wq->wq_lock); 236 return rc; 237 } 238 } 239 240 mutex_unlock(&wq->wq_lock); 241 return 0; 242 } 243 244 return -ENODEV; 245 } 246 247 static void disable_wq(struct idxd_wq *wq) 248 { 249 struct idxd_device *idxd = wq->idxd; 250 struct device *dev = &idxd->pdev->dev; 251 unsigned long flags; 252 int rc; 253 254 mutex_lock(&wq->wq_lock); 255 dev_dbg(dev, "%s removing WQ %s\n", __func__, dev_name(&wq->conf_dev)); 256 if (wq->state == IDXD_WQ_DISABLED) { 257 mutex_unlock(&wq->wq_lock); 258 return; 259 } 260 261 if (is_idxd_wq_dmaengine(wq)) 262 idxd_unregister_dma_channel(wq); 263 else if (is_idxd_wq_cdev(wq)) 264 idxd_wq_del_cdev(wq); 265 266 if (idxd_wq_refcount(wq)) 267 dev_warn(dev, "Clients has claim on wq %d: %d\n", 268 wq->id, idxd_wq_refcount(wq)); 269 270 idxd_wq_unmap_portal(wq); 271 272 spin_lock_irqsave(&idxd->dev_lock, flags); 273 rc = idxd_wq_disable(wq); 274 spin_unlock_irqrestore(&idxd->dev_lock, flags); 275 276 idxd_wq_free_resources(wq); 277 wq->client_count = 0; 278 mutex_unlock(&wq->wq_lock); 279 280 if (rc < 0) 281 dev_warn(dev, "Failed to disable %s: %d\n", 282 dev_name(&wq->conf_dev), rc); 283 else 284 dev_info(dev, "wq %s disabled\n", dev_name(&wq->conf_dev)); 285 } 286 287 static int idxd_config_bus_remove(struct device *dev) 288 { 289 int rc; 290 unsigned long flags; 291 292 dev_dbg(dev, "%s called for %s\n", __func__, dev_name(dev)); 293 294 /* disable workqueue here */ 295 if (is_idxd_wq_dev(dev)) { 296 struct idxd_wq *wq = confdev_to_wq(dev); 297 298 disable_wq(wq); 299 } else if (is_idxd_dev(dev)) { 300 struct idxd_device *idxd = confdev_to_idxd(dev); 301 int i; 302 303 dev_dbg(dev, "%s removing dev %s\n", __func__, 304 dev_name(&idxd->conf_dev)); 305 for (i = 0; i < idxd->max_wqs; i++) { 306 struct idxd_wq *wq = &idxd->wqs[i]; 307 308 if (wq->state == IDXD_WQ_DISABLED) 309 continue; 310 dev_warn(dev, "Active wq %d on disable %s.\n", i, 311 dev_name(&idxd->conf_dev)); 312 device_release_driver(&wq->conf_dev); 313 } 314 315 idxd_unregister_dma_device(idxd); 316 spin_lock_irqsave(&idxd->dev_lock, flags); 317 rc = idxd_device_disable(idxd); 318 spin_unlock_irqrestore(&idxd->dev_lock, flags); 319 module_put(THIS_MODULE); 320 if (rc < 0) 321 dev_warn(dev, "Device disable failed\n"); 322 else 323 dev_info(dev, "Device %s disabled\n", dev_name(dev)); 324 325 } 326 327 return 0; 328 } 329 330 static void idxd_config_bus_shutdown(struct device *dev) 331 { 332 dev_dbg(dev, "%s called\n", __func__); 333 } 334 335 struct bus_type dsa_bus_type = { 336 .name = "dsa", 337 .match = idxd_config_bus_match, 338 .probe = idxd_config_bus_probe, 339 .remove = idxd_config_bus_remove, 340 .shutdown = idxd_config_bus_shutdown, 341 }; 342 343 static struct bus_type *idxd_bus_types[] = { 344 &dsa_bus_type 345 }; 346 347 static struct idxd_device_driver dsa_drv = { 348 .drv = { 349 .name = "dsa", 350 .bus = &dsa_bus_type, 351 .owner = THIS_MODULE, 352 .mod_name = KBUILD_MODNAME, 353 }, 354 }; 355 356 static struct idxd_device_driver *idxd_drvs[] = { 357 &dsa_drv 358 }; 359 360 struct bus_type *idxd_get_bus_type(struct idxd_device *idxd) 361 { 362 return idxd_bus_types[idxd->type]; 363 } 364 365 static struct device_type *idxd_get_device_type(struct idxd_device *idxd) 366 { 367 if (idxd->type == IDXD_TYPE_DSA) 368 return &dsa_device_type; 369 else 370 return NULL; 371 } 372 373 /* IDXD generic driver setup */ 374 int idxd_register_driver(void) 375 { 376 int i, rc; 377 378 for (i = 0; i < IDXD_TYPE_MAX; i++) { 379 rc = driver_register(&idxd_drvs[i]->drv); 380 if (rc < 0) 381 goto drv_fail; 382 } 383 384 return 0; 385 386 drv_fail: 387 for (; i > 0; i--) 388 driver_unregister(&idxd_drvs[i]->drv); 389 return rc; 390 } 391 392 void idxd_unregister_driver(void) 393 { 394 int i; 395 396 for (i = 0; i < IDXD_TYPE_MAX; i++) 397 driver_unregister(&idxd_drvs[i]->drv); 398 } 399 400 /* IDXD engine attributes */ 401 static ssize_t engine_group_id_show(struct device *dev, 402 struct device_attribute *attr, char *buf) 403 { 404 struct idxd_engine *engine = 405 container_of(dev, struct idxd_engine, conf_dev); 406 407 if (engine->group) 408 return sprintf(buf, "%d\n", engine->group->id); 409 else 410 return sprintf(buf, "%d\n", -1); 411 } 412 413 static ssize_t engine_group_id_store(struct device *dev, 414 struct device_attribute *attr, 415 const char *buf, size_t count) 416 { 417 struct idxd_engine *engine = 418 container_of(dev, struct idxd_engine, conf_dev); 419 struct idxd_device *idxd = engine->idxd; 420 long id; 421 int rc; 422 struct idxd_group *prevg, *group; 423 424 rc = kstrtol(buf, 10, &id); 425 if (rc < 0) 426 return -EINVAL; 427 428 if (!test_bit(IDXD_FLAG_CONFIGURABLE, &idxd->flags)) 429 return -EPERM; 430 431 if (id > idxd->max_groups - 1 || id < -1) 432 return -EINVAL; 433 434 if (id == -1) { 435 if (engine->group) { 436 engine->group->num_engines--; 437 engine->group = NULL; 438 } 439 return count; 440 } 441 442 group = &idxd->groups[id]; 443 prevg = engine->group; 444 445 if (prevg) 446 prevg->num_engines--; 447 engine->group = &idxd->groups[id]; 448 engine->group->num_engines++; 449 450 return count; 451 } 452 453 static struct device_attribute dev_attr_engine_group = 454 __ATTR(group_id, 0644, engine_group_id_show, 455 engine_group_id_store); 456 457 static struct attribute *idxd_engine_attributes[] = { 458 &dev_attr_engine_group.attr, 459 NULL, 460 }; 461 462 static const struct attribute_group idxd_engine_attribute_group = { 463 .attrs = idxd_engine_attributes, 464 }; 465 466 static const struct attribute_group *idxd_engine_attribute_groups[] = { 467 &idxd_engine_attribute_group, 468 NULL, 469 }; 470 471 /* Group attributes */ 472 473 static void idxd_set_free_tokens(struct idxd_device *idxd) 474 { 475 int i, tokens; 476 477 for (i = 0, tokens = 0; i < idxd->max_groups; i++) { 478 struct idxd_group *g = &idxd->groups[i]; 479 480 tokens += g->tokens_reserved; 481 } 482 483 idxd->nr_tokens = idxd->max_tokens - tokens; 484 } 485 486 static ssize_t group_tokens_reserved_show(struct device *dev, 487 struct device_attribute *attr, 488 char *buf) 489 { 490 struct idxd_group *group = 491 container_of(dev, struct idxd_group, conf_dev); 492 493 return sprintf(buf, "%u\n", group->tokens_reserved); 494 } 495 496 static ssize_t group_tokens_reserved_store(struct device *dev, 497 struct device_attribute *attr, 498 const char *buf, size_t count) 499 { 500 struct idxd_group *group = 501 container_of(dev, struct idxd_group, conf_dev); 502 struct idxd_device *idxd = group->idxd; 503 unsigned long val; 504 int rc; 505 506 rc = kstrtoul(buf, 10, &val); 507 if (rc < 0) 508 return -EINVAL; 509 510 if (!test_bit(IDXD_FLAG_CONFIGURABLE, &idxd->flags)) 511 return -EPERM; 512 513 if (idxd->state == IDXD_DEV_ENABLED) 514 return -EPERM; 515 516 if (idxd->token_limit == 0) 517 return -EPERM; 518 519 if (val > idxd->max_tokens) 520 return -EINVAL; 521 522 if (val > idxd->nr_tokens + group->tokens_reserved) 523 return -EINVAL; 524 525 group->tokens_reserved = val; 526 idxd_set_free_tokens(idxd); 527 return count; 528 } 529 530 static struct device_attribute dev_attr_group_tokens_reserved = 531 __ATTR(tokens_reserved, 0644, group_tokens_reserved_show, 532 group_tokens_reserved_store); 533 534 static ssize_t group_tokens_allowed_show(struct device *dev, 535 struct device_attribute *attr, 536 char *buf) 537 { 538 struct idxd_group *group = 539 container_of(dev, struct idxd_group, conf_dev); 540 541 return sprintf(buf, "%u\n", group->tokens_allowed); 542 } 543 544 static ssize_t group_tokens_allowed_store(struct device *dev, 545 struct device_attribute *attr, 546 const char *buf, size_t count) 547 { 548 struct idxd_group *group = 549 container_of(dev, struct idxd_group, conf_dev); 550 struct idxd_device *idxd = group->idxd; 551 unsigned long val; 552 int rc; 553 554 rc = kstrtoul(buf, 10, &val); 555 if (rc < 0) 556 return -EINVAL; 557 558 if (!test_bit(IDXD_FLAG_CONFIGURABLE, &idxd->flags)) 559 return -EPERM; 560 561 if (idxd->state == IDXD_DEV_ENABLED) 562 return -EPERM; 563 564 if (idxd->token_limit == 0) 565 return -EPERM; 566 if (val < 4 * group->num_engines || 567 val > group->tokens_reserved + idxd->nr_tokens) 568 return -EINVAL; 569 570 group->tokens_allowed = val; 571 return count; 572 } 573 574 static struct device_attribute dev_attr_group_tokens_allowed = 575 __ATTR(tokens_allowed, 0644, group_tokens_allowed_show, 576 group_tokens_allowed_store); 577 578 static ssize_t group_use_token_limit_show(struct device *dev, 579 struct device_attribute *attr, 580 char *buf) 581 { 582 struct idxd_group *group = 583 container_of(dev, struct idxd_group, conf_dev); 584 585 return sprintf(buf, "%u\n", group->use_token_limit); 586 } 587 588 static ssize_t group_use_token_limit_store(struct device *dev, 589 struct device_attribute *attr, 590 const char *buf, size_t count) 591 { 592 struct idxd_group *group = 593 container_of(dev, struct idxd_group, conf_dev); 594 struct idxd_device *idxd = group->idxd; 595 unsigned long val; 596 int rc; 597 598 rc = kstrtoul(buf, 10, &val); 599 if (rc < 0) 600 return -EINVAL; 601 602 if (!test_bit(IDXD_FLAG_CONFIGURABLE, &idxd->flags)) 603 return -EPERM; 604 605 if (idxd->state == IDXD_DEV_ENABLED) 606 return -EPERM; 607 608 if (idxd->token_limit == 0) 609 return -EPERM; 610 611 group->use_token_limit = !!val; 612 return count; 613 } 614 615 static struct device_attribute dev_attr_group_use_token_limit = 616 __ATTR(use_token_limit, 0644, group_use_token_limit_show, 617 group_use_token_limit_store); 618 619 static ssize_t group_engines_show(struct device *dev, 620 struct device_attribute *attr, char *buf) 621 { 622 struct idxd_group *group = 623 container_of(dev, struct idxd_group, conf_dev); 624 int i, rc = 0; 625 char *tmp = buf; 626 struct idxd_device *idxd = group->idxd; 627 628 for (i = 0; i < idxd->max_engines; i++) { 629 struct idxd_engine *engine = &idxd->engines[i]; 630 631 if (!engine->group) 632 continue; 633 634 if (engine->group->id == group->id) 635 rc += sprintf(tmp + rc, "engine%d.%d ", 636 idxd->id, engine->id); 637 } 638 639 rc--; 640 rc += sprintf(tmp + rc, "\n"); 641 642 return rc; 643 } 644 645 static struct device_attribute dev_attr_group_engines = 646 __ATTR(engines, 0444, group_engines_show, NULL); 647 648 static ssize_t group_work_queues_show(struct device *dev, 649 struct device_attribute *attr, char *buf) 650 { 651 struct idxd_group *group = 652 container_of(dev, struct idxd_group, conf_dev); 653 int i, rc = 0; 654 char *tmp = buf; 655 struct idxd_device *idxd = group->idxd; 656 657 for (i = 0; i < idxd->max_wqs; i++) { 658 struct idxd_wq *wq = &idxd->wqs[i]; 659 660 if (!wq->group) 661 continue; 662 663 if (wq->group->id == group->id) 664 rc += sprintf(tmp + rc, "wq%d.%d ", 665 idxd->id, wq->id); 666 } 667 668 rc--; 669 rc += sprintf(tmp + rc, "\n"); 670 671 return rc; 672 } 673 674 static struct device_attribute dev_attr_group_work_queues = 675 __ATTR(work_queues, 0444, group_work_queues_show, NULL); 676 677 static ssize_t group_traffic_class_a_show(struct device *dev, 678 struct device_attribute *attr, 679 char *buf) 680 { 681 struct idxd_group *group = 682 container_of(dev, struct idxd_group, conf_dev); 683 684 return sprintf(buf, "%d\n", group->tc_a); 685 } 686 687 static ssize_t group_traffic_class_a_store(struct device *dev, 688 struct device_attribute *attr, 689 const char *buf, size_t count) 690 { 691 struct idxd_group *group = 692 container_of(dev, struct idxd_group, conf_dev); 693 struct idxd_device *idxd = group->idxd; 694 long val; 695 int rc; 696 697 rc = kstrtol(buf, 10, &val); 698 if (rc < 0) 699 return -EINVAL; 700 701 if (!test_bit(IDXD_FLAG_CONFIGURABLE, &idxd->flags)) 702 return -EPERM; 703 704 if (idxd->state == IDXD_DEV_ENABLED) 705 return -EPERM; 706 707 if (val < 0 || val > 7) 708 return -EINVAL; 709 710 group->tc_a = val; 711 return count; 712 } 713 714 static struct device_attribute dev_attr_group_traffic_class_a = 715 __ATTR(traffic_class_a, 0644, group_traffic_class_a_show, 716 group_traffic_class_a_store); 717 718 static ssize_t group_traffic_class_b_show(struct device *dev, 719 struct device_attribute *attr, 720 char *buf) 721 { 722 struct idxd_group *group = 723 container_of(dev, struct idxd_group, conf_dev); 724 725 return sprintf(buf, "%d\n", group->tc_b); 726 } 727 728 static ssize_t group_traffic_class_b_store(struct device *dev, 729 struct device_attribute *attr, 730 const char *buf, size_t count) 731 { 732 struct idxd_group *group = 733 container_of(dev, struct idxd_group, conf_dev); 734 struct idxd_device *idxd = group->idxd; 735 long val; 736 int rc; 737 738 rc = kstrtol(buf, 10, &val); 739 if (rc < 0) 740 return -EINVAL; 741 742 if (!test_bit(IDXD_FLAG_CONFIGURABLE, &idxd->flags)) 743 return -EPERM; 744 745 if (idxd->state == IDXD_DEV_ENABLED) 746 return -EPERM; 747 748 if (val < 0 || val > 7) 749 return -EINVAL; 750 751 group->tc_b = val; 752 return count; 753 } 754 755 static struct device_attribute dev_attr_group_traffic_class_b = 756 __ATTR(traffic_class_b, 0644, group_traffic_class_b_show, 757 group_traffic_class_b_store); 758 759 static struct attribute *idxd_group_attributes[] = { 760 &dev_attr_group_work_queues.attr, 761 &dev_attr_group_engines.attr, 762 &dev_attr_group_use_token_limit.attr, 763 &dev_attr_group_tokens_allowed.attr, 764 &dev_attr_group_tokens_reserved.attr, 765 &dev_attr_group_traffic_class_a.attr, 766 &dev_attr_group_traffic_class_b.attr, 767 NULL, 768 }; 769 770 static const struct attribute_group idxd_group_attribute_group = { 771 .attrs = idxd_group_attributes, 772 }; 773 774 static const struct attribute_group *idxd_group_attribute_groups[] = { 775 &idxd_group_attribute_group, 776 NULL, 777 }; 778 779 /* IDXD work queue attribs */ 780 static ssize_t wq_clients_show(struct device *dev, 781 struct device_attribute *attr, char *buf) 782 { 783 struct idxd_wq *wq = container_of(dev, struct idxd_wq, conf_dev); 784 785 return sprintf(buf, "%d\n", wq->client_count); 786 } 787 788 static struct device_attribute dev_attr_wq_clients = 789 __ATTR(clients, 0444, wq_clients_show, NULL); 790 791 static ssize_t wq_state_show(struct device *dev, 792 struct device_attribute *attr, char *buf) 793 { 794 struct idxd_wq *wq = container_of(dev, struct idxd_wq, conf_dev); 795 796 switch (wq->state) { 797 case IDXD_WQ_DISABLED: 798 return sprintf(buf, "disabled\n"); 799 case IDXD_WQ_ENABLED: 800 return sprintf(buf, "enabled\n"); 801 } 802 803 return sprintf(buf, "unknown\n"); 804 } 805 806 static struct device_attribute dev_attr_wq_state = 807 __ATTR(state, 0444, wq_state_show, NULL); 808 809 static ssize_t wq_group_id_show(struct device *dev, 810 struct device_attribute *attr, char *buf) 811 { 812 struct idxd_wq *wq = container_of(dev, struct idxd_wq, conf_dev); 813 814 if (wq->group) 815 return sprintf(buf, "%u\n", wq->group->id); 816 else 817 return sprintf(buf, "-1\n"); 818 } 819 820 static ssize_t wq_group_id_store(struct device *dev, 821 struct device_attribute *attr, 822 const char *buf, size_t count) 823 { 824 struct idxd_wq *wq = container_of(dev, struct idxd_wq, conf_dev); 825 struct idxd_device *idxd = wq->idxd; 826 long id; 827 int rc; 828 struct idxd_group *prevg, *group; 829 830 rc = kstrtol(buf, 10, &id); 831 if (rc < 0) 832 return -EINVAL; 833 834 if (!test_bit(IDXD_FLAG_CONFIGURABLE, &idxd->flags)) 835 return -EPERM; 836 837 if (wq->state != IDXD_WQ_DISABLED) 838 return -EPERM; 839 840 if (id > idxd->max_groups - 1 || id < -1) 841 return -EINVAL; 842 843 if (id == -1) { 844 if (wq->group) { 845 wq->group->num_wqs--; 846 wq->group = NULL; 847 } 848 return count; 849 } 850 851 group = &idxd->groups[id]; 852 prevg = wq->group; 853 854 if (prevg) 855 prevg->num_wqs--; 856 wq->group = group; 857 group->num_wqs++; 858 return count; 859 } 860 861 static struct device_attribute dev_attr_wq_group_id = 862 __ATTR(group_id, 0644, wq_group_id_show, wq_group_id_store); 863 864 static ssize_t wq_mode_show(struct device *dev, struct device_attribute *attr, 865 char *buf) 866 { 867 struct idxd_wq *wq = container_of(dev, struct idxd_wq, conf_dev); 868 869 return sprintf(buf, "%s\n", 870 wq_dedicated(wq) ? "dedicated" : "shared"); 871 } 872 873 static ssize_t wq_mode_store(struct device *dev, 874 struct device_attribute *attr, const char *buf, 875 size_t count) 876 { 877 struct idxd_wq *wq = container_of(dev, struct idxd_wq, conf_dev); 878 struct idxd_device *idxd = wq->idxd; 879 880 if (!test_bit(IDXD_FLAG_CONFIGURABLE, &idxd->flags)) 881 return -EPERM; 882 883 if (wq->state != IDXD_WQ_DISABLED) 884 return -EPERM; 885 886 if (sysfs_streq(buf, "dedicated")) { 887 set_bit(WQ_FLAG_DEDICATED, &wq->flags); 888 wq->threshold = 0; 889 } else { 890 return -EINVAL; 891 } 892 893 return count; 894 } 895 896 static struct device_attribute dev_attr_wq_mode = 897 __ATTR(mode, 0644, wq_mode_show, wq_mode_store); 898 899 static ssize_t wq_size_show(struct device *dev, struct device_attribute *attr, 900 char *buf) 901 { 902 struct idxd_wq *wq = container_of(dev, struct idxd_wq, conf_dev); 903 904 return sprintf(buf, "%u\n", wq->size); 905 } 906 907 static int total_claimed_wq_size(struct idxd_device *idxd) 908 { 909 int i; 910 int wq_size = 0; 911 912 for (i = 0; i < idxd->max_wqs; i++) { 913 struct idxd_wq *wq = &idxd->wqs[i]; 914 915 wq_size += wq->size; 916 } 917 918 return wq_size; 919 } 920 921 static ssize_t wq_size_store(struct device *dev, 922 struct device_attribute *attr, const char *buf, 923 size_t count) 924 { 925 struct idxd_wq *wq = container_of(dev, struct idxd_wq, conf_dev); 926 unsigned long size; 927 struct idxd_device *idxd = wq->idxd; 928 int rc; 929 930 rc = kstrtoul(buf, 10, &size); 931 if (rc < 0) 932 return -EINVAL; 933 934 if (!test_bit(IDXD_FLAG_CONFIGURABLE, &idxd->flags)) 935 return -EPERM; 936 937 if (wq->state != IDXD_WQ_DISABLED) 938 return -EPERM; 939 940 if (size + total_claimed_wq_size(idxd) - wq->size > idxd->max_wq_size) 941 return -EINVAL; 942 943 wq->size = size; 944 return count; 945 } 946 947 static struct device_attribute dev_attr_wq_size = 948 __ATTR(size, 0644, wq_size_show, wq_size_store); 949 950 static ssize_t wq_priority_show(struct device *dev, 951 struct device_attribute *attr, char *buf) 952 { 953 struct idxd_wq *wq = container_of(dev, struct idxd_wq, conf_dev); 954 955 return sprintf(buf, "%u\n", wq->priority); 956 } 957 958 static ssize_t wq_priority_store(struct device *dev, 959 struct device_attribute *attr, 960 const char *buf, size_t count) 961 { 962 struct idxd_wq *wq = container_of(dev, struct idxd_wq, conf_dev); 963 unsigned long prio; 964 struct idxd_device *idxd = wq->idxd; 965 int rc; 966 967 rc = kstrtoul(buf, 10, &prio); 968 if (rc < 0) 969 return -EINVAL; 970 971 if (!test_bit(IDXD_FLAG_CONFIGURABLE, &idxd->flags)) 972 return -EPERM; 973 974 if (wq->state != IDXD_WQ_DISABLED) 975 return -EPERM; 976 977 if (prio > IDXD_MAX_PRIORITY) 978 return -EINVAL; 979 980 wq->priority = prio; 981 return count; 982 } 983 984 static struct device_attribute dev_attr_wq_priority = 985 __ATTR(priority, 0644, wq_priority_show, wq_priority_store); 986 987 static ssize_t wq_type_show(struct device *dev, 988 struct device_attribute *attr, char *buf) 989 { 990 struct idxd_wq *wq = container_of(dev, struct idxd_wq, conf_dev); 991 992 switch (wq->type) { 993 case IDXD_WQT_KERNEL: 994 return sprintf(buf, "%s\n", 995 idxd_wq_type_names[IDXD_WQT_KERNEL]); 996 case IDXD_WQT_USER: 997 return sprintf(buf, "%s\n", 998 idxd_wq_type_names[IDXD_WQT_USER]); 999 case IDXD_WQT_NONE: 1000 default: 1001 return sprintf(buf, "%s\n", 1002 idxd_wq_type_names[IDXD_WQT_NONE]); 1003 } 1004 1005 return -EINVAL; 1006 } 1007 1008 static ssize_t wq_type_store(struct device *dev, 1009 struct device_attribute *attr, const char *buf, 1010 size_t count) 1011 { 1012 struct idxd_wq *wq = container_of(dev, struct idxd_wq, conf_dev); 1013 enum idxd_wq_type old_type; 1014 1015 if (wq->state != IDXD_WQ_DISABLED) 1016 return -EPERM; 1017 1018 old_type = wq->type; 1019 if (sysfs_streq(buf, idxd_wq_type_names[IDXD_WQT_NONE])) 1020 wq->type = IDXD_WQT_NONE; 1021 else if (sysfs_streq(buf, idxd_wq_type_names[IDXD_WQT_KERNEL])) 1022 wq->type = IDXD_WQT_KERNEL; 1023 else if (sysfs_streq(buf, idxd_wq_type_names[IDXD_WQT_USER])) 1024 wq->type = IDXD_WQT_USER; 1025 else 1026 return -EINVAL; 1027 1028 /* If we are changing queue type, clear the name */ 1029 if (wq->type != old_type) 1030 memset(wq->name, 0, WQ_NAME_SIZE + 1); 1031 1032 return count; 1033 } 1034 1035 static struct device_attribute dev_attr_wq_type = 1036 __ATTR(type, 0644, wq_type_show, wq_type_store); 1037 1038 static ssize_t wq_name_show(struct device *dev, 1039 struct device_attribute *attr, char *buf) 1040 { 1041 struct idxd_wq *wq = container_of(dev, struct idxd_wq, conf_dev); 1042 1043 return sprintf(buf, "%s\n", wq->name); 1044 } 1045 1046 static ssize_t wq_name_store(struct device *dev, 1047 struct device_attribute *attr, const char *buf, 1048 size_t count) 1049 { 1050 struct idxd_wq *wq = container_of(dev, struct idxd_wq, conf_dev); 1051 1052 if (wq->state != IDXD_WQ_DISABLED) 1053 return -EPERM; 1054 1055 if (strlen(buf) > WQ_NAME_SIZE || strlen(buf) == 0) 1056 return -EINVAL; 1057 1058 memset(wq->name, 0, WQ_NAME_SIZE + 1); 1059 strncpy(wq->name, buf, WQ_NAME_SIZE); 1060 strreplace(wq->name, '\n', '\0'); 1061 return count; 1062 } 1063 1064 static struct device_attribute dev_attr_wq_name = 1065 __ATTR(name, 0644, wq_name_show, wq_name_store); 1066 1067 static ssize_t wq_cdev_minor_show(struct device *dev, 1068 struct device_attribute *attr, char *buf) 1069 { 1070 struct idxd_wq *wq = container_of(dev, struct idxd_wq, conf_dev); 1071 1072 return sprintf(buf, "%d\n", wq->idxd_cdev.minor); 1073 } 1074 1075 static struct device_attribute dev_attr_wq_cdev_minor = 1076 __ATTR(cdev_minor, 0444, wq_cdev_minor_show, NULL); 1077 1078 static struct attribute *idxd_wq_attributes[] = { 1079 &dev_attr_wq_clients.attr, 1080 &dev_attr_wq_state.attr, 1081 &dev_attr_wq_group_id.attr, 1082 &dev_attr_wq_mode.attr, 1083 &dev_attr_wq_size.attr, 1084 &dev_attr_wq_priority.attr, 1085 &dev_attr_wq_type.attr, 1086 &dev_attr_wq_name.attr, 1087 &dev_attr_wq_cdev_minor.attr, 1088 NULL, 1089 }; 1090 1091 static const struct attribute_group idxd_wq_attribute_group = { 1092 .attrs = idxd_wq_attributes, 1093 }; 1094 1095 static const struct attribute_group *idxd_wq_attribute_groups[] = { 1096 &idxd_wq_attribute_group, 1097 NULL, 1098 }; 1099 1100 /* IDXD device attribs */ 1101 static ssize_t max_work_queues_size_show(struct device *dev, 1102 struct device_attribute *attr, 1103 char *buf) 1104 { 1105 struct idxd_device *idxd = 1106 container_of(dev, struct idxd_device, conf_dev); 1107 1108 return sprintf(buf, "%u\n", idxd->max_wq_size); 1109 } 1110 static DEVICE_ATTR_RO(max_work_queues_size); 1111 1112 static ssize_t max_groups_show(struct device *dev, 1113 struct device_attribute *attr, char *buf) 1114 { 1115 struct idxd_device *idxd = 1116 container_of(dev, struct idxd_device, conf_dev); 1117 1118 return sprintf(buf, "%u\n", idxd->max_groups); 1119 } 1120 static DEVICE_ATTR_RO(max_groups); 1121 1122 static ssize_t max_work_queues_show(struct device *dev, 1123 struct device_attribute *attr, char *buf) 1124 { 1125 struct idxd_device *idxd = 1126 container_of(dev, struct idxd_device, conf_dev); 1127 1128 return sprintf(buf, "%u\n", idxd->max_wqs); 1129 } 1130 static DEVICE_ATTR_RO(max_work_queues); 1131 1132 static ssize_t max_engines_show(struct device *dev, 1133 struct device_attribute *attr, char *buf) 1134 { 1135 struct idxd_device *idxd = 1136 container_of(dev, struct idxd_device, conf_dev); 1137 1138 return sprintf(buf, "%u\n", idxd->max_engines); 1139 } 1140 static DEVICE_ATTR_RO(max_engines); 1141 1142 static ssize_t numa_node_show(struct device *dev, 1143 struct device_attribute *attr, char *buf) 1144 { 1145 struct idxd_device *idxd = 1146 container_of(dev, struct idxd_device, conf_dev); 1147 1148 return sprintf(buf, "%d\n", dev_to_node(&idxd->pdev->dev)); 1149 } 1150 static DEVICE_ATTR_RO(numa_node); 1151 1152 static ssize_t max_batch_size_show(struct device *dev, 1153 struct device_attribute *attr, char *buf) 1154 { 1155 struct idxd_device *idxd = 1156 container_of(dev, struct idxd_device, conf_dev); 1157 1158 return sprintf(buf, "%u\n", idxd->max_batch_size); 1159 } 1160 static DEVICE_ATTR_RO(max_batch_size); 1161 1162 static ssize_t max_transfer_size_show(struct device *dev, 1163 struct device_attribute *attr, 1164 char *buf) 1165 { 1166 struct idxd_device *idxd = 1167 container_of(dev, struct idxd_device, conf_dev); 1168 1169 return sprintf(buf, "%llu\n", idxd->max_xfer_bytes); 1170 } 1171 static DEVICE_ATTR_RO(max_transfer_size); 1172 1173 static ssize_t op_cap_show(struct device *dev, 1174 struct device_attribute *attr, char *buf) 1175 { 1176 struct idxd_device *idxd = 1177 container_of(dev, struct idxd_device, conf_dev); 1178 1179 return sprintf(buf, "%#llx\n", idxd->hw.opcap.bits[0]); 1180 } 1181 static DEVICE_ATTR_RO(op_cap); 1182 1183 static ssize_t configurable_show(struct device *dev, 1184 struct device_attribute *attr, char *buf) 1185 { 1186 struct idxd_device *idxd = 1187 container_of(dev, struct idxd_device, conf_dev); 1188 1189 return sprintf(buf, "%u\n", 1190 test_bit(IDXD_FLAG_CONFIGURABLE, &idxd->flags)); 1191 } 1192 static DEVICE_ATTR_RO(configurable); 1193 1194 static ssize_t clients_show(struct device *dev, 1195 struct device_attribute *attr, char *buf) 1196 { 1197 struct idxd_device *idxd = 1198 container_of(dev, struct idxd_device, conf_dev); 1199 unsigned long flags; 1200 int count = 0, i; 1201 1202 spin_lock_irqsave(&idxd->dev_lock, flags); 1203 for (i = 0; i < idxd->max_wqs; i++) { 1204 struct idxd_wq *wq = &idxd->wqs[i]; 1205 1206 count += wq->client_count; 1207 } 1208 spin_unlock_irqrestore(&idxd->dev_lock, flags); 1209 1210 return sprintf(buf, "%d\n", count); 1211 } 1212 static DEVICE_ATTR_RO(clients); 1213 1214 static ssize_t state_show(struct device *dev, 1215 struct device_attribute *attr, char *buf) 1216 { 1217 struct idxd_device *idxd = 1218 container_of(dev, struct idxd_device, conf_dev); 1219 1220 switch (idxd->state) { 1221 case IDXD_DEV_DISABLED: 1222 case IDXD_DEV_CONF_READY: 1223 return sprintf(buf, "disabled\n"); 1224 case IDXD_DEV_ENABLED: 1225 return sprintf(buf, "enabled\n"); 1226 case IDXD_DEV_HALTED: 1227 return sprintf(buf, "halted\n"); 1228 } 1229 1230 return sprintf(buf, "unknown\n"); 1231 } 1232 static DEVICE_ATTR_RO(state); 1233 1234 static ssize_t errors_show(struct device *dev, 1235 struct device_attribute *attr, char *buf) 1236 { 1237 struct idxd_device *idxd = 1238 container_of(dev, struct idxd_device, conf_dev); 1239 int i, out = 0; 1240 unsigned long flags; 1241 1242 spin_lock_irqsave(&idxd->dev_lock, flags); 1243 for (i = 0; i < 4; i++) 1244 out += sprintf(buf + out, "%#018llx ", idxd->sw_err.bits[i]); 1245 spin_unlock_irqrestore(&idxd->dev_lock, flags); 1246 out--; 1247 out += sprintf(buf + out, "\n"); 1248 return out; 1249 } 1250 static DEVICE_ATTR_RO(errors); 1251 1252 static ssize_t max_tokens_show(struct device *dev, 1253 struct device_attribute *attr, char *buf) 1254 { 1255 struct idxd_device *idxd = 1256 container_of(dev, struct idxd_device, conf_dev); 1257 1258 return sprintf(buf, "%u\n", idxd->max_tokens); 1259 } 1260 static DEVICE_ATTR_RO(max_tokens); 1261 1262 static ssize_t token_limit_show(struct device *dev, 1263 struct device_attribute *attr, char *buf) 1264 { 1265 struct idxd_device *idxd = 1266 container_of(dev, struct idxd_device, conf_dev); 1267 1268 return sprintf(buf, "%u\n", idxd->token_limit); 1269 } 1270 1271 static ssize_t token_limit_store(struct device *dev, 1272 struct device_attribute *attr, 1273 const char *buf, size_t count) 1274 { 1275 struct idxd_device *idxd = 1276 container_of(dev, struct idxd_device, conf_dev); 1277 unsigned long val; 1278 int rc; 1279 1280 rc = kstrtoul(buf, 10, &val); 1281 if (rc < 0) 1282 return -EINVAL; 1283 1284 if (idxd->state == IDXD_DEV_ENABLED) 1285 return -EPERM; 1286 1287 if (!test_bit(IDXD_FLAG_CONFIGURABLE, &idxd->flags)) 1288 return -EPERM; 1289 1290 if (!idxd->hw.group_cap.token_limit) 1291 return -EPERM; 1292 1293 if (val > idxd->hw.group_cap.total_tokens) 1294 return -EINVAL; 1295 1296 idxd->token_limit = val; 1297 return count; 1298 } 1299 static DEVICE_ATTR_RW(token_limit); 1300 1301 static ssize_t cdev_major_show(struct device *dev, 1302 struct device_attribute *attr, char *buf) 1303 { 1304 struct idxd_device *idxd = 1305 container_of(dev, struct idxd_device, conf_dev); 1306 1307 return sprintf(buf, "%u\n", idxd->major); 1308 } 1309 static DEVICE_ATTR_RO(cdev_major); 1310 1311 static struct attribute *idxd_device_attributes[] = { 1312 &dev_attr_max_groups.attr, 1313 &dev_attr_max_work_queues.attr, 1314 &dev_attr_max_work_queues_size.attr, 1315 &dev_attr_max_engines.attr, 1316 &dev_attr_numa_node.attr, 1317 &dev_attr_max_batch_size.attr, 1318 &dev_attr_max_transfer_size.attr, 1319 &dev_attr_op_cap.attr, 1320 &dev_attr_configurable.attr, 1321 &dev_attr_clients.attr, 1322 &dev_attr_state.attr, 1323 &dev_attr_errors.attr, 1324 &dev_attr_max_tokens.attr, 1325 &dev_attr_token_limit.attr, 1326 &dev_attr_cdev_major.attr, 1327 NULL, 1328 }; 1329 1330 static const struct attribute_group idxd_device_attribute_group = { 1331 .attrs = idxd_device_attributes, 1332 }; 1333 1334 static const struct attribute_group *idxd_attribute_groups[] = { 1335 &idxd_device_attribute_group, 1336 NULL, 1337 }; 1338 1339 static int idxd_setup_engine_sysfs(struct idxd_device *idxd) 1340 { 1341 struct device *dev = &idxd->pdev->dev; 1342 int i, rc; 1343 1344 for (i = 0; i < idxd->max_engines; i++) { 1345 struct idxd_engine *engine = &idxd->engines[i]; 1346 1347 engine->conf_dev.parent = &idxd->conf_dev; 1348 dev_set_name(&engine->conf_dev, "engine%d.%d", 1349 idxd->id, engine->id); 1350 engine->conf_dev.bus = idxd_get_bus_type(idxd); 1351 engine->conf_dev.groups = idxd_engine_attribute_groups; 1352 engine->conf_dev.type = &idxd_engine_device_type; 1353 dev_dbg(dev, "Engine device register: %s\n", 1354 dev_name(&engine->conf_dev)); 1355 rc = device_register(&engine->conf_dev); 1356 if (rc < 0) { 1357 put_device(&engine->conf_dev); 1358 goto cleanup; 1359 } 1360 } 1361 1362 return 0; 1363 1364 cleanup: 1365 while (i--) { 1366 struct idxd_engine *engine = &idxd->engines[i]; 1367 1368 device_unregister(&engine->conf_dev); 1369 } 1370 return rc; 1371 } 1372 1373 static int idxd_setup_group_sysfs(struct idxd_device *idxd) 1374 { 1375 struct device *dev = &idxd->pdev->dev; 1376 int i, rc; 1377 1378 for (i = 0; i < idxd->max_groups; i++) { 1379 struct idxd_group *group = &idxd->groups[i]; 1380 1381 group->conf_dev.parent = &idxd->conf_dev; 1382 dev_set_name(&group->conf_dev, "group%d.%d", 1383 idxd->id, group->id); 1384 group->conf_dev.bus = idxd_get_bus_type(idxd); 1385 group->conf_dev.groups = idxd_group_attribute_groups; 1386 group->conf_dev.type = &idxd_group_device_type; 1387 dev_dbg(dev, "Group device register: %s\n", 1388 dev_name(&group->conf_dev)); 1389 rc = device_register(&group->conf_dev); 1390 if (rc < 0) { 1391 put_device(&group->conf_dev); 1392 goto cleanup; 1393 } 1394 } 1395 1396 return 0; 1397 1398 cleanup: 1399 while (i--) { 1400 struct idxd_group *group = &idxd->groups[i]; 1401 1402 device_unregister(&group->conf_dev); 1403 } 1404 return rc; 1405 } 1406 1407 static int idxd_setup_wq_sysfs(struct idxd_device *idxd) 1408 { 1409 struct device *dev = &idxd->pdev->dev; 1410 int i, rc; 1411 1412 for (i = 0; i < idxd->max_wqs; i++) { 1413 struct idxd_wq *wq = &idxd->wqs[i]; 1414 1415 wq->conf_dev.parent = &idxd->conf_dev; 1416 dev_set_name(&wq->conf_dev, "wq%d.%d", idxd->id, wq->id); 1417 wq->conf_dev.bus = idxd_get_bus_type(idxd); 1418 wq->conf_dev.groups = idxd_wq_attribute_groups; 1419 wq->conf_dev.type = &idxd_wq_device_type; 1420 dev_dbg(dev, "WQ device register: %s\n", 1421 dev_name(&wq->conf_dev)); 1422 rc = device_register(&wq->conf_dev); 1423 if (rc < 0) { 1424 put_device(&wq->conf_dev); 1425 goto cleanup; 1426 } 1427 } 1428 1429 return 0; 1430 1431 cleanup: 1432 while (i--) { 1433 struct idxd_wq *wq = &idxd->wqs[i]; 1434 1435 device_unregister(&wq->conf_dev); 1436 } 1437 return rc; 1438 } 1439 1440 static int idxd_setup_device_sysfs(struct idxd_device *idxd) 1441 { 1442 struct device *dev = &idxd->pdev->dev; 1443 int rc; 1444 char devname[IDXD_NAME_SIZE]; 1445 1446 sprintf(devname, "%s%d", idxd_get_dev_name(idxd), idxd->id); 1447 idxd->conf_dev.parent = dev; 1448 dev_set_name(&idxd->conf_dev, "%s", devname); 1449 idxd->conf_dev.bus = idxd_get_bus_type(idxd); 1450 idxd->conf_dev.groups = idxd_attribute_groups; 1451 idxd->conf_dev.type = idxd_get_device_type(idxd); 1452 1453 dev_dbg(dev, "IDXD device register: %s\n", dev_name(&idxd->conf_dev)); 1454 rc = device_register(&idxd->conf_dev); 1455 if (rc < 0) { 1456 put_device(&idxd->conf_dev); 1457 return rc; 1458 } 1459 1460 return 0; 1461 } 1462 1463 int idxd_setup_sysfs(struct idxd_device *idxd) 1464 { 1465 struct device *dev = &idxd->pdev->dev; 1466 int rc; 1467 1468 rc = idxd_setup_device_sysfs(idxd); 1469 if (rc < 0) { 1470 dev_dbg(dev, "Device sysfs registering failed: %d\n", rc); 1471 return rc; 1472 } 1473 1474 rc = idxd_setup_wq_sysfs(idxd); 1475 if (rc < 0) { 1476 /* unregister conf dev */ 1477 dev_dbg(dev, "Work Queue sysfs registering failed: %d\n", rc); 1478 return rc; 1479 } 1480 1481 rc = idxd_setup_group_sysfs(idxd); 1482 if (rc < 0) { 1483 /* unregister conf dev */ 1484 dev_dbg(dev, "Group sysfs registering failed: %d\n", rc); 1485 return rc; 1486 } 1487 1488 rc = idxd_setup_engine_sysfs(idxd); 1489 if (rc < 0) { 1490 /* unregister conf dev */ 1491 dev_dbg(dev, "Engine sysfs registering failed: %d\n", rc); 1492 return rc; 1493 } 1494 1495 return 0; 1496 } 1497 1498 void idxd_cleanup_sysfs(struct idxd_device *idxd) 1499 { 1500 int i; 1501 1502 for (i = 0; i < idxd->max_wqs; i++) { 1503 struct idxd_wq *wq = &idxd->wqs[i]; 1504 1505 device_unregister(&wq->conf_dev); 1506 } 1507 1508 for (i = 0; i < idxd->max_engines; i++) { 1509 struct idxd_engine *engine = &idxd->engines[i]; 1510 1511 device_unregister(&engine->conf_dev); 1512 } 1513 1514 for (i = 0; i < idxd->max_groups; i++) { 1515 struct idxd_group *group = &idxd->groups[i]; 1516 1517 device_unregister(&group->conf_dev); 1518 } 1519 1520 device_unregister(&idxd->conf_dev); 1521 } 1522 1523 int idxd_register_bus_type(void) 1524 { 1525 int i, rc; 1526 1527 for (i = 0; i < IDXD_TYPE_MAX; i++) { 1528 rc = bus_register(idxd_bus_types[i]); 1529 if (rc < 0) 1530 goto bus_err; 1531 } 1532 1533 return 0; 1534 1535 bus_err: 1536 for (; i > 0; i--) 1537 bus_unregister(idxd_bus_types[i]); 1538 return rc; 1539 } 1540 1541 void idxd_unregister_bus_type(void) 1542 { 1543 int i; 1544 1545 for (i = 0; i < IDXD_TYPE_MAX; i++) 1546 bus_unregister(idxd_bus_types[i]); 1547 } 1548