drivers/dma/idxd/sysfs.c

   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 }