drivers/misc/cxl/sysfs.c

   1 /*
   2  * Copyright 2014 IBM Corp.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version
   7  * 2 of the License, or (at your option) any later version.
   8  */
   9
  10 #include <linux/kernel.h>
  11 #include <linux/device.h>
  12 #include <linux/sysfs.h>
  13 #include <linux/pci_regs.h>
  14
  15 #include "cxl.h"
  16
  17 #define to_afu_chardev_m(d) dev_get_drvdata(d)
  18
  19 /*********  Adapter attributes  **********************************************/
  20
  21 static ssize_t caia_version_show(struct device *device,
  22                                  struct device_attribute *attr,
  23                                  char *buf)
  24 {
  25         struct cxl *adapter = to_cxl_adapter(device);
  26
  27         return scnprintf(buf, PAGE_SIZE, "%i.%i\n", adapter->caia_major,
  28                          adapter->caia_minor);
  29 }
  30
  31 static ssize_t psl_revision_show(struct device *device,
  32                                  struct device_attribute *attr,
  33                                  char *buf)
  34 {
  35         struct cxl *adapter = to_cxl_adapter(device);
  36
  37         return scnprintf(buf, PAGE_SIZE, "%i\n", adapter->psl_rev);
  38 }
  39
  40 static ssize_t base_image_show(struct device *device,
  41                                struct device_attribute *attr,
  42                                char *buf)
  43 {
  44         struct cxl *adapter = to_cxl_adapter(device);
  45
  46         return scnprintf(buf, PAGE_SIZE, "%i\n", adapter->base_image);
  47 }
  48
  49 static ssize_t image_loaded_show(struct device *device,
  50                                  struct device_attribute *attr,
  51                                  char *buf)
  52 {
  53         struct cxl *adapter = to_cxl_adapter(device);
  54
  55         if (adapter->user_image_loaded)
  56                 return scnprintf(buf, PAGE_SIZE, "user\n");
  57         return scnprintf(buf, PAGE_SIZE, "factory\n");
  58 }
  59
  60 static ssize_t reset_adapter_store(struct device *device,
  61                                    struct device_attribute *attr,
  62                                    const char *buf, size_t count)
  63 {
  64         struct cxl *adapter = to_cxl_adapter(device);
  65         int rc;
  66         int val;
  67
  68         rc = sscanf(buf, "%i", &val);
  69         if ((rc != 1) || (val != 1))
  70                 return -EINVAL;
  71
  72         if ((rc = cxl_reset(adapter)))
  73                 return rc;
  74         return count;
  75 }
  76
  77 static ssize_t load_image_on_perst_show(struct device *device,
  78                                  struct device_attribute *attr,
  79                                  char *buf)
  80 {
  81         struct cxl *adapter = to_cxl_adapter(device);
  82
  83         if (!adapter->perst_loads_image)
  84                 return scnprintf(buf, PAGE_SIZE, "none\n");
  85
  86         if (adapter->perst_select_user)
  87                 return scnprintf(buf, PAGE_SIZE, "user\n");
  88         return scnprintf(buf, PAGE_SIZE, "factory\n");
  89 }
  90
  91 static ssize_t load_image_on_perst_store(struct device *device,
  92                                  struct device_attribute *attr,
  93                                  const char *buf, size_t count)
  94 {
  95         struct cxl *adapter = to_cxl_adapter(device);
  96         int rc;
  97
  98         if (!strncmp(buf, "none", 4))
  99                 adapter->perst_loads_image = false;
 100         else if (!strncmp(buf, "user", 4)) {
 101                 adapter->perst_select_user = true;
 102                 adapter->perst_loads_image = true;
 103         } else if (!strncmp(buf, "factory", 7)) {
 104                 adapter->perst_select_user = false;
 105                 adapter->perst_loads_image = true;
 106         } else
 107                 return -EINVAL;
 108
 109         if ((rc = cxl_update_image_control(adapter)))
 110                 return rc;
 111
 112         return count;
 113 }
 114
 115 static struct device_attribute adapter_attrs[] = {
 116         __ATTR_RO(caia_version),
 117         __ATTR_RO(psl_revision),
 118         __ATTR_RO(base_image),
 119         __ATTR_RO(image_loaded),
 120         __ATTR_RW(load_image_on_perst),
 121         __ATTR(reset, S_IWUSR, NULL, reset_adapter_store),
 122 };
 123
 124
 125 /*********  AFU master specific attributes  **********************************/
 126
 127 static ssize_t mmio_size_show_master(struct device *device,
 128                                      struct device_attribute *attr,
 129                                      char *buf)
 130 {
 131         struct cxl_afu *afu = to_afu_chardev_m(device);
 132
 133         return scnprintf(buf, PAGE_SIZE, "%llu\n", afu->adapter->ps_size);
 134 }
 135
 136 static ssize_t pp_mmio_off_show(struct device *device,
 137                                 struct device_attribute *attr,
 138                                 char *buf)
 139 {
 140         struct cxl_afu *afu = to_afu_chardev_m(device);
 141
 142         return scnprintf(buf, PAGE_SIZE, "%llu\n", afu->pp_offset);
 143 }
 144
 145 static ssize_t pp_mmio_len_show(struct device *device,
 146                                 struct device_attribute *attr,
 147                                 char *buf)
 148 {
 149         struct cxl_afu *afu = to_afu_chardev_m(device);
 150
 151         return scnprintf(buf, PAGE_SIZE, "%llu\n", afu->pp_size);
 152 }
 153
 154 static struct device_attribute afu_master_attrs[] = {
 155         __ATTR(mmio_size, S_IRUGO, mmio_size_show_master, NULL),
 156         __ATTR_RO(pp_mmio_off),
 157         __ATTR_RO(pp_mmio_len),
 158 };
 159
 160
 161 /*********  AFU attributes  **************************************************/
 162
 163 static ssize_t mmio_size_show(struct device *device,
 164                               struct device_attribute *attr,
 165                               char *buf)
 166 {
 167         struct cxl_afu *afu = to_cxl_afu(device);
 168
 169         if (afu->pp_size)
 170                 return scnprintf(buf, PAGE_SIZE, "%llu\n", afu->pp_size);
 171         return scnprintf(buf, PAGE_SIZE, "%llu\n", afu->adapter->ps_size);
 172 }
 173
 174 static ssize_t reset_store_afu(struct device *device,
 175                                struct device_attribute *attr,
 176                                const char *buf, size_t count)
 177 {
 178         struct cxl_afu *afu = to_cxl_afu(device);
 179         int rc;
 180
 181         /* Not safe to reset if it is currently in use */
 182         mutex_lock(&afu->contexts_lock);
 183         if (!idr_is_empty(&afu->contexts_idr)) {
 184                 rc = -EBUSY;
 185                 goto err;
 186         }
 187
 188         if ((rc = cxl_afu_reset(afu)))
 189                 goto err;
 190
 191         rc = count;
 192 err:
 193         mutex_unlock(&afu->contexts_lock);
 194         return rc;
 195 }
 196
 197 static ssize_t irqs_min_show(struct device *device,
 198                              struct device_attribute *attr,
 199                              char *buf)
 200 {
 201         struct cxl_afu *afu = to_cxl_afu(device);
 202
 203         return scnprintf(buf, PAGE_SIZE, "%i\n", afu->pp_irqs);
 204 }
 205
 206 static ssize_t irqs_max_show(struct device *device,
 207                                   struct device_attribute *attr,
 208                                   char *buf)
 209 {
 210         struct cxl_afu *afu = to_cxl_afu(device);
 211
 212         return scnprintf(buf, PAGE_SIZE, "%i\n", afu->irqs_max);
 213 }
 214
 215 static ssize_t irqs_max_store(struct device *device,
 216                                   struct device_attribute *attr,
 217                                   const char *buf, size_t count)
 218 {
 219         struct cxl_afu *afu = to_cxl_afu(device);
 220         ssize_t ret;
 221         int irqs_max;
 222
 223         ret = sscanf(buf, "%i", &irqs_max);
 224         if (ret != 1)
 225                 return -EINVAL;
 226
 227         if (irqs_max < afu->pp_irqs)
 228                 return -EINVAL;
 229
 230         if (irqs_max > afu->adapter->user_irqs)
 231                 return -EINVAL;
 232
 233         afu->irqs_max = irqs_max;
 234         return count;
 235 }
 236
 237 static ssize_t modes_supported_show(struct device *device,
 238                                     struct device_attribute *attr, char *buf)
 239 {
 240         struct cxl_afu *afu = to_cxl_afu(device);
 241         char *p = buf, *end = buf + PAGE_SIZE;
 242
 243         if (afu->modes_supported & CXL_MODE_DEDICATED)
 244                 p += scnprintf(p, end - p, "dedicated_process\n");
 245         if (afu->modes_supported & CXL_MODE_DIRECTED)
 246                 p += scnprintf(p, end - p, "afu_directed\n");
 247         return (p - buf);
 248 }
 249
 250 static ssize_t prefault_mode_show(struct device *device,
 251                                   struct device_attribute *attr,
 252                                   char *buf)
 253 {
 254         struct cxl_afu *afu = to_cxl_afu(device);
 255
 256         switch (afu->prefault_mode) {
 257         case CXL_PREFAULT_WED:
 258                 return scnprintf(buf, PAGE_SIZE, "work_element_descriptor\n");
 259         case CXL_PREFAULT_ALL:
 260                 return scnprintf(buf, PAGE_SIZE, "all\n");
 261         default:
 262                 return scnprintf(buf, PAGE_SIZE, "none\n");
 263         }
 264 }
 265
 266 static ssize_t prefault_mode_store(struct device *device,
 267                           struct device_attribute *attr,
 268                           const char *buf, size_t count)
 269 {
 270         struct cxl_afu *afu = to_cxl_afu(device);
 271         enum prefault_modes mode = -1;
 272
 273         if (!strncmp(buf, "work_element_descriptor", 23))
 274                 mode = CXL_PREFAULT_WED;
 275         if (!strncmp(buf, "all", 3))
 276                 mode = CXL_PREFAULT_ALL;
 277         if (!strncmp(buf, "none", 4))
 278                 mode = CXL_PREFAULT_NONE;
 279
 280         if (mode == -1)
 281                 return -EINVAL;
 282
 283         afu->prefault_mode = mode;
 284         return count;
 285 }
 286
 287 static ssize_t mode_show(struct device *device,
 288                          struct device_attribute *attr,
 289                          char *buf)
 290 {
 291         struct cxl_afu *afu = to_cxl_afu(device);
 292
 293         if (afu->current_mode == CXL_MODE_DEDICATED)
 294                 return scnprintf(buf, PAGE_SIZE, "dedicated_process\n");
 295         if (afu->current_mode == CXL_MODE_DIRECTED)
 296                 return scnprintf(buf, PAGE_SIZE, "afu_directed\n");
 297         return scnprintf(buf, PAGE_SIZE, "none\n");
 298 }
 299
 300 static ssize_t mode_store(struct device *device, struct device_attribute *attr,
 301                           const char *buf, size_t count)
 302 {
 303         struct cxl_afu *afu = to_cxl_afu(device);
 304         int old_mode, mode = -1;
 305         int rc = -EBUSY;
 306
 307         /* can't change this if we have a user */
 308         mutex_lock(&afu->contexts_lock);
 309         if (!idr_is_empty(&afu->contexts_idr))
 310                 goto err;
 311
 312         if (!strncmp(buf, "dedicated_process", 17))
 313                 mode = CXL_MODE_DEDICATED;
 314         if (!strncmp(buf, "afu_directed", 12))
 315                 mode = CXL_MODE_DIRECTED;
 316         if (!strncmp(buf, "none", 4))
 317                 mode = 0;
 318
 319         if (mode == -1) {
 320                 rc = -EINVAL;
 321                 goto err;
 322         }
 323
 324         /*
 325          * cxl_afu_deactivate_mode needs to be done outside the lock, prevent
 326          * other contexts coming in before we are ready:
 327          */
 328         old_mode = afu->current_mode;
 329         afu->current_mode = 0;
 330         afu->num_procs = 0;
 331
 332         mutex_unlock(&afu->contexts_lock);
 333
 334         if ((rc = _cxl_afu_deactivate_mode(afu, old_mode)))
 335                 return rc;
 336         if ((rc = cxl_afu_activate_mode(afu, mode)))
 337                 return rc;
 338
 339         return count;
 340 err:
 341         mutex_unlock(&afu->contexts_lock);
 342         return rc;
 343 }
 344
 345 static ssize_t api_version_show(struct device *device,
 346                                 struct device_attribute *attr,
 347                                 char *buf)
 348 {
 349         return scnprintf(buf, PAGE_SIZE, "%i\n", CXL_API_VERSION);
 350 }
 351
 352 static ssize_t api_version_compatible_show(struct device *device,
 353                                            struct device_attribute *attr,
 354                                            char *buf)
 355 {
 356         return scnprintf(buf, PAGE_SIZE, "%i\n", CXL_API_VERSION_COMPATIBLE);
 357 }
 358
 359 static struct device_attribute afu_attrs[] = {
 360         __ATTR_RO(mmio_size),
 361         __ATTR_RO(irqs_min),
 362         __ATTR_RW(irqs_max),
 363         __ATTR_RO(modes_supported),
 364         __ATTR_RW(mode),
 365         __ATTR_RW(prefault_mode),
 366         __ATTR_RO(api_version),
 367         __ATTR_RO(api_version_compatible),
 368         __ATTR(reset, S_IWUSR, NULL, reset_store_afu),
 369 };
 370
 371 int cxl_sysfs_adapter_add(struct cxl *adapter)
 372 {
 373         int i, rc;
 374
 375         for (i = 0; i < ARRAY_SIZE(adapter_attrs); i++) {
 376                 if ((rc = device_create_file(&adapter->dev, &adapter_attrs[i])))
 377                         goto err;
 378         }
 379         return 0;
 380 err:
 381         for (i--; i >= 0; i--)
 382                 device_remove_file(&adapter->dev, &adapter_attrs[i]);
 383         return rc;
 384 }
 385 void cxl_sysfs_adapter_remove(struct cxl *adapter)
 386 {
 387         int i;
 388
 389         for (i = 0; i < ARRAY_SIZE(adapter_attrs); i++)
 390                 device_remove_file(&adapter->dev, &adapter_attrs[i]);
 391 }
 392
 393 struct afu_config_record {
 394         struct kobject kobj;
 395         struct bin_attribute config_attr;
 396         struct list_head list;
 397         int cr;
 398         u16 device;
 399         u16 vendor;
 400         u32 class;
 401 };
 402
 403 #define to_cr(obj) container_of(obj, struct afu_config_record, kobj)
 404
 405 static ssize_t vendor_show(struct kobject *kobj,
 406                            struct kobj_attribute *attr, char *buf)
 407 {
 408         struct afu_config_record *cr = to_cr(kobj);
 409
 410         return scnprintf(buf, PAGE_SIZE, "0x%.4x\n", cr->vendor);
 411 }
 412
 413 static ssize_t device_show(struct kobject *kobj,
 414                            struct kobj_attribute *attr, char *buf)
 415 {
 416         struct afu_config_record *cr = to_cr(kobj);
 417
 418         return scnprintf(buf, PAGE_SIZE, "0x%.4x\n", cr->device);
 419 }
 420
 421 static ssize_t class_show(struct kobject *kobj,
 422                           struct kobj_attribute *attr, char *buf)
 423 {
 424         struct afu_config_record *cr = to_cr(kobj);
 425
 426         return scnprintf(buf, PAGE_SIZE, "0x%.6x\n", cr->class);
 427 }
 428
 429 static ssize_t afu_read_config(struct file *filp, struct kobject *kobj,
 430                                struct bin_attribute *bin_attr, char *buf,
 431                                loff_t off, size_t count)
 432 {
 433         struct afu_config_record *cr = to_cr(kobj);
 434         struct cxl_afu *afu = to_cxl_afu(container_of(kobj->parent, struct device, kobj));
 435
 436         u64 i, j, val, size = afu->crs_len;
 437
 438         if (off > size)
 439                 return 0;
 440         if (off + count > size)
 441                 count = size - off;
 442
 443         for (i = 0; i < count;) {
 444                 val = cxl_afu_cr_read64(afu, cr->cr, off & ~0x7);
 445                 for (j = off & 0x7; j < 8 && i < count; i++, j++, off++)
 446                         buf[i] = (val >> (j * 8)) & 0xff;
 447         }
 448
 449         return count;
 450 }
 451
 452 static struct kobj_attribute vendor_attribute =
 453         __ATTR_RO(vendor);
 454 static struct kobj_attribute device_attribute =
 455         __ATTR_RO(device);
 456 static struct kobj_attribute class_attribute =
 457         __ATTR_RO(class);
 458
 459 static struct attribute *afu_cr_attrs[] = {
 460         &vendor_attribute.attr,
 461         &device_attribute.attr,
 462         &class_attribute.attr,
 463         NULL,
 464 };
 465
 466 static void release_afu_config_record(struct kobject *kobj)
 467 {
 468         struct afu_config_record *cr = to_cr(kobj);
 469
 470         kfree(cr);
 471 }
 472
 473 static struct kobj_type afu_config_record_type = {
 474         .sysfs_ops = &kobj_sysfs_ops,
 475         .release = release_afu_config_record,
 476         .default_attrs = afu_cr_attrs,
 477 };
 478
 479 static struct afu_config_record *cxl_sysfs_afu_new_cr(struct cxl_afu *afu, int cr_idx)
 480 {
 481         struct afu_config_record *cr;
 482         int rc;
 483
 484         cr = kzalloc(sizeof(struct afu_config_record), GFP_KERNEL);
 485         if (!cr)
 486                 return ERR_PTR(-ENOMEM);
 487
 488         cr->cr = cr_idx;
 489         cr->device = cxl_afu_cr_read16(afu, cr_idx, PCI_DEVICE_ID);
 490         cr->vendor = cxl_afu_cr_read16(afu, cr_idx, PCI_VENDOR_ID);
 491         cr->class = cxl_afu_cr_read32(afu, cr_idx, PCI_CLASS_REVISION) >> 8;
 492
 493         /*
 494          * Export raw AFU PCIe like config record. For now this is read only by
 495          * root - we can expand that later to be readable by non-root and maybe
 496          * even writable provided we have a good use-case. Once we suport
 497          * exposing AFUs through a virtual PHB they will get that for free from
 498          * Linux' PCI infrastructure, but until then it's not clear that we
 499          * need it for anything since the main use case is just identifying
 500          * AFUs, which can be done via the vendor, device and class attributes.
 501          */
 502         sysfs_bin_attr_init(&cr->config_attr);
 503         cr->config_attr.attr.name = "config";
 504         cr->config_attr.attr.mode = S_IRUSR;
 505         cr->config_attr.size = afu->crs_len;
 506         cr->config_attr.read = afu_read_config;
 507
 508         rc = kobject_init_and_add(&cr->kobj, &afu_config_record_type,
 509                                   &afu->dev.kobj, "cr%i", cr->cr);
 510         if (rc)
 511                 goto err;
 512
 513         rc = sysfs_create_bin_file(&cr->kobj, &cr->config_attr);
 514         if (rc)
 515                 goto err1;
 516
 517         rc = kobject_uevent(&cr->kobj, KOBJ_ADD);
 518         if (rc)
 519                 goto err2;
 520
 521         return cr;
 522 err2:
 523         sysfs_remove_bin_file(&cr->kobj, &cr->config_attr);
 524 err1:
 525         kobject_put(&cr->kobj);
 526         return ERR_PTR(rc);
 527 err:
 528         kfree(cr);
 529         return ERR_PTR(rc);
 530 }
 531
 532 void cxl_sysfs_afu_remove(struct cxl_afu *afu)
 533 {
 534         struct afu_config_record *cr, *tmp;
 535         int i;
 536
 537         for (i = 0; i < ARRAY_SIZE(afu_attrs); i++)
 538                 device_remove_file(&afu->dev, &afu_attrs[i]);
 539
 540         list_for_each_entry_safe(cr, tmp, &afu->crs, list) {
 541                 sysfs_remove_bin_file(&cr->kobj, &cr->config_attr);
 542                 kobject_put(&cr->kobj);
 543         }
 544 }
 545
 546 int cxl_sysfs_afu_add(struct cxl_afu *afu)
 547 {
 548         struct afu_config_record *cr;
 549         int i, rc;
 550
 551         INIT_LIST_HEAD(&afu->crs);
 552
 553         for (i = 0; i < ARRAY_SIZE(afu_attrs); i++) {
 554                 if ((rc = device_create_file(&afu->dev, &afu_attrs[i])))
 555                         goto err;
 556         }
 557
 558         for (i = 0; i < afu->crs_num; i++) {
 559                 cr = cxl_sysfs_afu_new_cr(afu, i);
 560                 if (IS_ERR(cr)) {
 561                         rc = PTR_ERR(cr);
 562                         goto err1;
 563                 }
 564                 list_add(&cr->list, &afu->crs);
 565         }
 566
 567         return 0;
 568
 569 err1:
 570         cxl_sysfs_afu_remove(afu);
 571         return rc;
 572 err:
 573         for (i--; i >= 0; i--)
 574                 device_remove_file(&afu->dev, &afu_attrs[i]);
 575         return rc;
 576 }
 577
 578 int cxl_sysfs_afu_m_add(struct cxl_afu *afu)
 579 {
 580         int i, rc;
 581
 582         for (i = 0; i < ARRAY_SIZE(afu_master_attrs); i++) {
 583                 if ((rc = device_create_file(afu->chardev_m, &afu_master_attrs[i])))
 584                         goto err;
 585         }
 586
 587         return 0;
 588
 589 err:
 590         for (i--; i >= 0; i--)
 591                 device_remove_file(afu->chardev_m, &afu_master_attrs[i]);
 592         return rc;
 593 }
 594
 595 void cxl_sysfs_afu_m_remove(struct cxl_afu *afu)
 596 {
 597         int i;
 598
 599         for (i = 0; i < ARRAY_SIZE(afu_master_attrs); i++)
 600                 device_remove_file(afu->chardev_m, &afu_master_attrs[i]);
 601 }