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