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 } 602