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