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 ssize_t afu_eb_read(struct file *filp, struct kobject *kobj, 360 struct bin_attribute *bin_attr, char *buf, 361 loff_t off, size_t count) 362 { 363 struct cxl_afu *afu = to_cxl_afu(container_of(kobj, 364 struct device, kobj)); 365 366 return cxl_afu_read_err_buffer(afu, buf, off, count); 367 } 368 369 static struct device_attribute afu_attrs[] = { 370 __ATTR_RO(mmio_size), 371 __ATTR_RO(irqs_min), 372 __ATTR_RW(irqs_max), 373 __ATTR_RO(modes_supported), 374 __ATTR_RW(mode), 375 __ATTR_RW(prefault_mode), 376 __ATTR_RO(api_version), 377 __ATTR_RO(api_version_compatible), 378 __ATTR(reset, S_IWUSR, NULL, reset_store_afu), 379 }; 380 381 int cxl_sysfs_adapter_add(struct cxl *adapter) 382 { 383 int i, rc; 384 385 for (i = 0; i < ARRAY_SIZE(adapter_attrs); i++) { 386 if ((rc = device_create_file(&adapter->dev, &adapter_attrs[i]))) 387 goto err; 388 } 389 return 0; 390 err: 391 for (i--; i >= 0; i--) 392 device_remove_file(&adapter->dev, &adapter_attrs[i]); 393 return rc; 394 } 395 void cxl_sysfs_adapter_remove(struct cxl *adapter) 396 { 397 int i; 398 399 for (i = 0; i < ARRAY_SIZE(adapter_attrs); i++) 400 device_remove_file(&adapter->dev, &adapter_attrs[i]); 401 } 402 403 struct afu_config_record { 404 struct kobject kobj; 405 struct bin_attribute config_attr; 406 struct list_head list; 407 int cr; 408 u16 device; 409 u16 vendor; 410 u32 class; 411 }; 412 413 #define to_cr(obj) container_of(obj, struct afu_config_record, kobj) 414 415 static ssize_t vendor_show(struct kobject *kobj, 416 struct kobj_attribute *attr, char *buf) 417 { 418 struct afu_config_record *cr = to_cr(kobj); 419 420 return scnprintf(buf, PAGE_SIZE, "0x%.4x\n", cr->vendor); 421 } 422 423 static ssize_t device_show(struct kobject *kobj, 424 struct kobj_attribute *attr, char *buf) 425 { 426 struct afu_config_record *cr = to_cr(kobj); 427 428 return scnprintf(buf, PAGE_SIZE, "0x%.4x\n", cr->device); 429 } 430 431 static ssize_t class_show(struct kobject *kobj, 432 struct kobj_attribute *attr, char *buf) 433 { 434 struct afu_config_record *cr = to_cr(kobj); 435 436 return scnprintf(buf, PAGE_SIZE, "0x%.6x\n", cr->class); 437 } 438 439 static ssize_t afu_read_config(struct file *filp, struct kobject *kobj, 440 struct bin_attribute *bin_attr, char *buf, 441 loff_t off, size_t count) 442 { 443 struct afu_config_record *cr = to_cr(kobj); 444 struct cxl_afu *afu = to_cxl_afu(container_of(kobj->parent, struct device, kobj)); 445 446 u64 i, j, val; 447 448 for (i = 0; i < count;) { 449 val = cxl_afu_cr_read64(afu, cr->cr, off & ~0x7); 450 for (j = off & 0x7; j < 8 && i < count; i++, j++, off++) 451 buf[i] = (val >> (j * 8)) & 0xff; 452 } 453 454 return count; 455 } 456 457 static struct kobj_attribute vendor_attribute = 458 __ATTR_RO(vendor); 459 static struct kobj_attribute device_attribute = 460 __ATTR_RO(device); 461 static struct kobj_attribute class_attribute = 462 __ATTR_RO(class); 463 464 static struct attribute *afu_cr_attrs[] = { 465 &vendor_attribute.attr, 466 &device_attribute.attr, 467 &class_attribute.attr, 468 NULL, 469 }; 470 471 static void release_afu_config_record(struct kobject *kobj) 472 { 473 struct afu_config_record *cr = to_cr(kobj); 474 475 kfree(cr); 476 } 477 478 static struct kobj_type afu_config_record_type = { 479 .sysfs_ops = &kobj_sysfs_ops, 480 .release = release_afu_config_record, 481 .default_attrs = afu_cr_attrs, 482 }; 483 484 static struct afu_config_record *cxl_sysfs_afu_new_cr(struct cxl_afu *afu, int cr_idx) 485 { 486 struct afu_config_record *cr; 487 int rc; 488 489 cr = kzalloc(sizeof(struct afu_config_record), GFP_KERNEL); 490 if (!cr) 491 return ERR_PTR(-ENOMEM); 492 493 cr->cr = cr_idx; 494 cr->device = cxl_afu_cr_read16(afu, cr_idx, PCI_DEVICE_ID); 495 cr->vendor = cxl_afu_cr_read16(afu, cr_idx, PCI_VENDOR_ID); 496 cr->class = cxl_afu_cr_read32(afu, cr_idx, PCI_CLASS_REVISION) >> 8; 497 498 /* 499 * Export raw AFU PCIe like config record. For now this is read only by 500 * root - we can expand that later to be readable by non-root and maybe 501 * even writable provided we have a good use-case. Once we suport 502 * exposing AFUs through a virtual PHB they will get that for free from 503 * Linux' PCI infrastructure, but until then it's not clear that we 504 * need it for anything since the main use case is just identifying 505 * AFUs, which can be done via the vendor, device and class attributes. 506 */ 507 sysfs_bin_attr_init(&cr->config_attr); 508 cr->config_attr.attr.name = "config"; 509 cr->config_attr.attr.mode = S_IRUSR; 510 cr->config_attr.size = afu->crs_len; 511 cr->config_attr.read = afu_read_config; 512 513 rc = kobject_init_and_add(&cr->kobj, &afu_config_record_type, 514 &afu->dev.kobj, "cr%i", cr->cr); 515 if (rc) 516 goto err; 517 518 rc = sysfs_create_bin_file(&cr->kobj, &cr->config_attr); 519 if (rc) 520 goto err1; 521 522 rc = kobject_uevent(&cr->kobj, KOBJ_ADD); 523 if (rc) 524 goto err2; 525 526 return cr; 527 err2: 528 sysfs_remove_bin_file(&cr->kobj, &cr->config_attr); 529 err1: 530 kobject_put(&cr->kobj); 531 return ERR_PTR(rc); 532 err: 533 kfree(cr); 534 return ERR_PTR(rc); 535 } 536 537 void cxl_sysfs_afu_remove(struct cxl_afu *afu) 538 { 539 struct afu_config_record *cr, *tmp; 540 int i; 541 542 /* remove the err buffer bin attribute */ 543 if (afu->eb_len) 544 device_remove_bin_file(&afu->dev, &afu->attr_eb); 545 546 for (i = 0; i < ARRAY_SIZE(afu_attrs); i++) 547 device_remove_file(&afu->dev, &afu_attrs[i]); 548 549 list_for_each_entry_safe(cr, tmp, &afu->crs, list) { 550 sysfs_remove_bin_file(&cr->kobj, &cr->config_attr); 551 kobject_put(&cr->kobj); 552 } 553 } 554 555 int cxl_sysfs_afu_add(struct cxl_afu *afu) 556 { 557 struct afu_config_record *cr; 558 int i, rc; 559 560 INIT_LIST_HEAD(&afu->crs); 561 562 for (i = 0; i < ARRAY_SIZE(afu_attrs); i++) { 563 if ((rc = device_create_file(&afu->dev, &afu_attrs[i]))) 564 goto err; 565 } 566 567 /* conditionally create the add the binary file for error info buffer */ 568 if (afu->eb_len) { 569 afu->attr_eb.attr.name = "afu_err_buff"; 570 afu->attr_eb.attr.mode = S_IRUGO; 571 afu->attr_eb.size = afu->eb_len; 572 afu->attr_eb.read = afu_eb_read; 573 574 rc = device_create_bin_file(&afu->dev, &afu->attr_eb); 575 if (rc) { 576 dev_err(&afu->dev, 577 "Unable to create eb attr for the afu. Err(%d)\n", 578 rc); 579 goto err; 580 } 581 } 582 583 for (i = 0; i < afu->crs_num; i++) { 584 cr = cxl_sysfs_afu_new_cr(afu, i); 585 if (IS_ERR(cr)) { 586 rc = PTR_ERR(cr); 587 goto err1; 588 } 589 list_add(&cr->list, &afu->crs); 590 } 591 592 return 0; 593 594 err1: 595 cxl_sysfs_afu_remove(afu); 596 return rc; 597 err: 598 /* reset the eb_len as we havent created the bin attr */ 599 afu->eb_len = 0; 600 601 for (i--; i >= 0; i--) 602 device_remove_file(&afu->dev, &afu_attrs[i]); 603 return rc; 604 } 605 606 int cxl_sysfs_afu_m_add(struct cxl_afu *afu) 607 { 608 int i, rc; 609 610 for (i = 0; i < ARRAY_SIZE(afu_master_attrs); i++) { 611 if ((rc = device_create_file(afu->chardev_m, &afu_master_attrs[i]))) 612 goto err; 613 } 614 615 return 0; 616 617 err: 618 for (i--; i >= 0; i--) 619 device_remove_file(afu->chardev_m, &afu_master_attrs[i]); 620 return rc; 621 } 622 623 void cxl_sysfs_afu_m_remove(struct cxl_afu *afu) 624 { 625 int i; 626 627 for (i = 0; i < ARRAY_SIZE(afu_master_attrs); i++) 628 device_remove_file(afu->chardev_m, &afu_master_attrs[i]); 629 } 630