1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright 2015 IBM Corp. 4 */ 5 6 #include <linux/kernel.h> 7 #include <linux/module.h> 8 #include <linux/platform_device.h> 9 #include <linux/slab.h> 10 #include <linux/of_address.h> 11 #include <linux/of_platform.h> 12 13 #include "cxl.h" 14 15 16 static const __be32 *read_prop_string(const struct device_node *np, 17 const char *prop_name) 18 { 19 const __be32 *prop; 20 21 prop = of_get_property(np, prop_name, NULL); 22 if (cxl_verbose && prop) 23 pr_info("%s: %s\n", prop_name, (char *) prop); 24 return prop; 25 } 26 27 static const __be32 *read_prop_dword(const struct device_node *np, 28 const char *prop_name, u32 *val) 29 { 30 const __be32 *prop; 31 32 prop = of_get_property(np, prop_name, NULL); 33 if (prop) 34 *val = be32_to_cpu(prop[0]); 35 if (cxl_verbose && prop) 36 pr_info("%s: %#x (%u)\n", prop_name, *val, *val); 37 return prop; 38 } 39 40 static const __be64 *read_prop64_dword(const struct device_node *np, 41 const char *prop_name, u64 *val) 42 { 43 const __be64 *prop; 44 45 prop = of_get_property(np, prop_name, NULL); 46 if (prop) 47 *val = be64_to_cpu(prop[0]); 48 if (cxl_verbose && prop) 49 pr_info("%s: %#llx (%llu)\n", prop_name, *val, *val); 50 return prop; 51 } 52 53 54 static int read_handle(struct device_node *np, u64 *handle) 55 { 56 const __be32 *prop; 57 u64 size; 58 59 /* Get address and size of the node */ 60 prop = of_get_address(np, 0, &size, NULL); 61 if (size) 62 return -EINVAL; 63 64 /* Helper to read a big number; size is in cells (not bytes) */ 65 *handle = of_read_number(prop, of_n_addr_cells(np)); 66 return 0; 67 } 68 69 static int read_phys_addr(struct device_node *np, char *prop_name, 70 struct cxl_afu *afu) 71 { 72 int i, len, entry_size, naddr, nsize, type; 73 u64 addr, size; 74 const __be32 *prop; 75 76 naddr = of_n_addr_cells(np); 77 nsize = of_n_size_cells(np); 78 79 prop = of_get_property(np, prop_name, &len); 80 if (prop) { 81 entry_size = naddr + nsize; 82 for (i = 0; i < (len / 4); i += entry_size, prop += entry_size) { 83 type = be32_to_cpu(prop[0]); 84 addr = of_read_number(prop, naddr); 85 size = of_read_number(&prop[naddr], nsize); 86 switch (type) { 87 case 0: /* unit address */ 88 afu->guest->handle = addr; 89 break; 90 case 1: /* p2 area */ 91 afu->guest->p2n_phys += addr; 92 afu->guest->p2n_size = size; 93 break; 94 case 2: /* problem state area */ 95 afu->psn_phys += addr; 96 afu->adapter->ps_size = size; 97 break; 98 default: 99 pr_err("Invalid address type %d found in %s property of AFU\n", 100 type, prop_name); 101 return -EINVAL; 102 } 103 if (cxl_verbose) 104 pr_info("%s: %#x %#llx (size %#llx)\n", 105 prop_name, type, addr, size); 106 } 107 } 108 return 0; 109 } 110 111 static int read_vpd(struct cxl *adapter, struct cxl_afu *afu) 112 { 113 char vpd[256]; 114 int rc; 115 size_t len = sizeof(vpd); 116 117 memset(vpd, 0, len); 118 119 if (adapter) 120 rc = cxl_guest_read_adapter_vpd(adapter, vpd, len); 121 else 122 rc = cxl_guest_read_afu_vpd(afu, vpd, len); 123 124 if (rc > 0) { 125 cxl_dump_debug_buffer(vpd, rc); 126 rc = 0; 127 } 128 return rc; 129 } 130 131 int cxl_of_read_afu_handle(struct cxl_afu *afu, struct device_node *afu_np) 132 { 133 if (read_handle(afu_np, &afu->guest->handle)) 134 return -EINVAL; 135 pr_devel("AFU handle: 0x%.16llx\n", afu->guest->handle); 136 137 return 0; 138 } 139 140 int cxl_of_read_afu_properties(struct cxl_afu *afu, struct device_node *np) 141 { 142 int i, len, rc; 143 char *p; 144 const __be32 *prop; 145 u16 device_id, vendor_id; 146 u32 val = 0, class_code; 147 148 /* Properties are read in the same order as listed in PAPR */ 149 150 if (cxl_verbose) { 151 pr_info("Dump of the 'ibm,coherent-platform-function' node properties:\n"); 152 153 prop = of_get_property(np, "compatible", &len); 154 i = 0; 155 while (i < len) { 156 p = (char *) prop + i; 157 pr_info("compatible: %s\n", p); 158 i += strlen(p) + 1; 159 } 160 read_prop_string(np, "name"); 161 } 162 163 rc = read_phys_addr(np, "reg", afu); 164 if (rc) 165 return rc; 166 167 rc = read_phys_addr(np, "assigned-addresses", afu); 168 if (rc) 169 return rc; 170 171 if (afu->psn_phys == 0) 172 afu->psa = false; 173 else 174 afu->psa = true; 175 176 if (cxl_verbose) { 177 read_prop_string(np, "ibm,loc-code"); 178 read_prop_string(np, "device_type"); 179 } 180 181 read_prop_dword(np, "ibm,#processes", &afu->max_procs_virtualised); 182 183 if (cxl_verbose) { 184 read_prop_dword(np, "ibm,scratchpad-size", &val); 185 read_prop_dword(np, "ibm,programmable", &val); 186 read_prop_string(np, "ibm,phandle"); 187 read_vpd(NULL, afu); 188 } 189 190 read_prop_dword(np, "ibm,max-ints-per-process", &afu->guest->max_ints); 191 afu->irqs_max = afu->guest->max_ints; 192 193 prop = read_prop_dword(np, "ibm,min-ints-per-process", &afu->pp_irqs); 194 if (prop) { 195 /* One extra interrupt for the PSL interrupt is already 196 * included. Remove it now to keep only AFU interrupts and 197 * match the native case. 198 */ 199 afu->pp_irqs--; 200 } 201 202 if (cxl_verbose) { 203 read_prop_dword(np, "ibm,max-ints", &val); 204 read_prop_dword(np, "ibm,vpd-size", &val); 205 } 206 207 read_prop64_dword(np, "ibm,error-buffer-size", &afu->eb_len); 208 afu->eb_offset = 0; 209 210 if (cxl_verbose) 211 read_prop_dword(np, "ibm,config-record-type", &val); 212 213 read_prop64_dword(np, "ibm,config-record-size", &afu->crs_len); 214 afu->crs_offset = 0; 215 216 read_prop_dword(np, "ibm,#config-records", &afu->crs_num); 217 218 if (cxl_verbose) { 219 for (i = 0; i < afu->crs_num; i++) { 220 rc = cxl_ops->afu_cr_read16(afu, i, PCI_DEVICE_ID, 221 &device_id); 222 if (!rc) 223 pr_info("record %d - device-id: %#x\n", 224 i, device_id); 225 rc = cxl_ops->afu_cr_read16(afu, i, PCI_VENDOR_ID, 226 &vendor_id); 227 if (!rc) 228 pr_info("record %d - vendor-id: %#x\n", 229 i, vendor_id); 230 rc = cxl_ops->afu_cr_read32(afu, i, PCI_CLASS_REVISION, 231 &class_code); 232 if (!rc) { 233 class_code >>= 8; 234 pr_info("record %d - class-code: %#x\n", 235 i, class_code); 236 } 237 } 238 239 read_prop_dword(np, "ibm,function-number", &val); 240 read_prop_dword(np, "ibm,privileged-function", &val); 241 read_prop_dword(np, "vendor-id", &val); 242 read_prop_dword(np, "device-id", &val); 243 read_prop_dword(np, "revision-id", &val); 244 read_prop_dword(np, "class-code", &val); 245 read_prop_dword(np, "subsystem-vendor-id", &val); 246 read_prop_dword(np, "subsystem-id", &val); 247 } 248 /* 249 * if "ibm,process-mmio" doesn't exist then per-process mmio is 250 * not supported 251 */ 252 val = 0; 253 prop = read_prop_dword(np, "ibm,process-mmio", &val); 254 if (prop && val == 1) 255 afu->pp_psa = true; 256 else 257 afu->pp_psa = false; 258 259 if (cxl_verbose) { 260 read_prop_dword(np, "ibm,supports-aur", &val); 261 read_prop_dword(np, "ibm,supports-csrp", &val); 262 read_prop_dword(np, "ibm,supports-prr", &val); 263 } 264 265 prop = read_prop_dword(np, "ibm,function-error-interrupt", &val); 266 if (prop) 267 afu->serr_hwirq = val; 268 269 pr_devel("AFU handle: %#llx\n", afu->guest->handle); 270 pr_devel("p2n_phys: %#llx (size %#llx)\n", 271 afu->guest->p2n_phys, afu->guest->p2n_size); 272 pr_devel("psn_phys: %#llx (size %#llx)\n", 273 afu->psn_phys, afu->adapter->ps_size); 274 pr_devel("Max number of processes virtualised=%i\n", 275 afu->max_procs_virtualised); 276 pr_devel("Per-process irqs min=%i, max=%i\n", afu->pp_irqs, 277 afu->irqs_max); 278 pr_devel("Slice error interrupt=%#lx\n", afu->serr_hwirq); 279 280 return 0; 281 } 282 283 static int read_adapter_irq_config(struct cxl *adapter, struct device_node *np) 284 { 285 const __be32 *ranges; 286 int len, nranges, i; 287 struct irq_avail *cur; 288 289 ranges = of_get_property(np, "interrupt-ranges", &len); 290 if (ranges == NULL || len < (2 * sizeof(int))) 291 return -EINVAL; 292 293 /* 294 * encoded array of two cells per entry, each cell encoded as 295 * with encode-int 296 */ 297 nranges = len / (2 * sizeof(int)); 298 if (nranges == 0 || (nranges * 2 * sizeof(int)) != len) 299 return -EINVAL; 300 301 adapter->guest->irq_avail = kcalloc(nranges, sizeof(struct irq_avail), 302 GFP_KERNEL); 303 if (adapter->guest->irq_avail == NULL) 304 return -ENOMEM; 305 306 adapter->guest->irq_base_offset = be32_to_cpu(ranges[0]); 307 for (i = 0; i < nranges; i++) { 308 cur = &adapter->guest->irq_avail[i]; 309 cur->offset = be32_to_cpu(ranges[i * 2]); 310 cur->range = be32_to_cpu(ranges[i * 2 + 1]); 311 cur->bitmap = bitmap_zalloc(cur->range, GFP_KERNEL); 312 if (cur->bitmap == NULL) 313 goto err; 314 if (cur->offset < adapter->guest->irq_base_offset) 315 adapter->guest->irq_base_offset = cur->offset; 316 if (cxl_verbose) 317 pr_info("available IRQ range: %#lx-%#lx (%lu)\n", 318 cur->offset, cur->offset + cur->range - 1, 319 cur->range); 320 } 321 adapter->guest->irq_nranges = nranges; 322 spin_lock_init(&adapter->guest->irq_alloc_lock); 323 324 return 0; 325 err: 326 for (i--; i >= 0; i--) { 327 cur = &adapter->guest->irq_avail[i]; 328 bitmap_free(cur->bitmap); 329 } 330 kfree(adapter->guest->irq_avail); 331 adapter->guest->irq_avail = NULL; 332 return -ENOMEM; 333 } 334 335 int cxl_of_read_adapter_handle(struct cxl *adapter, struct device_node *np) 336 { 337 if (read_handle(np, &adapter->guest->handle)) 338 return -EINVAL; 339 pr_devel("Adapter handle: 0x%.16llx\n", adapter->guest->handle); 340 341 return 0; 342 } 343 344 int cxl_of_read_adapter_properties(struct cxl *adapter, struct device_node *np) 345 { 346 int rc, len, naddr, i; 347 char *p; 348 const __be32 *prop; 349 u32 val = 0; 350 351 /* Properties are read in the same order as listed in PAPR */ 352 353 naddr = of_n_addr_cells(np); 354 355 if (cxl_verbose) { 356 pr_info("Dump of the 'ibm,coherent-platform-facility' node properties:\n"); 357 358 read_prop_dword(np, "#address-cells", &val); 359 read_prop_dword(np, "#size-cells", &val); 360 361 prop = of_get_property(np, "compatible", &len); 362 i = 0; 363 while (i < len) { 364 p = (char *) prop + i; 365 pr_info("compatible: %s\n", p); 366 i += strlen(p) + 1; 367 } 368 read_prop_string(np, "name"); 369 read_prop_string(np, "model"); 370 371 prop = of_get_property(np, "reg", NULL); 372 if (prop) { 373 pr_info("reg: addr:%#llx size:%#x\n", 374 of_read_number(prop, naddr), 375 be32_to_cpu(prop[naddr])); 376 } 377 378 read_prop_string(np, "ibm,loc-code"); 379 } 380 381 if ((rc = read_adapter_irq_config(adapter, np))) 382 return rc; 383 384 if (cxl_verbose) { 385 read_prop_string(np, "device_type"); 386 read_prop_string(np, "ibm,phandle"); 387 } 388 389 prop = read_prop_dword(np, "ibm,caia-version", &val); 390 if (prop) { 391 adapter->caia_major = (val & 0xFF00) >> 8; 392 adapter->caia_minor = val & 0xFF; 393 } 394 395 prop = read_prop_dword(np, "ibm,psl-revision", &val); 396 if (prop) 397 adapter->psl_rev = val; 398 399 prop = read_prop_string(np, "status"); 400 if (prop) { 401 adapter->guest->status = kasprintf(GFP_KERNEL, "%s", (char *) prop); 402 if (adapter->guest->status == NULL) 403 return -ENOMEM; 404 } 405 406 prop = read_prop_dword(np, "vendor-id", &val); 407 if (prop) 408 adapter->guest->vendor = val; 409 410 prop = read_prop_dword(np, "device-id", &val); 411 if (prop) 412 adapter->guest->device = val; 413 414 if (cxl_verbose) { 415 read_prop_dword(np, "ibm,privileged-facility", &val); 416 read_prop_dword(np, "revision-id", &val); 417 read_prop_dword(np, "class-code", &val); 418 } 419 420 prop = read_prop_dword(np, "subsystem-vendor-id", &val); 421 if (prop) 422 adapter->guest->subsystem_vendor = val; 423 424 prop = read_prop_dword(np, "subsystem-id", &val); 425 if (prop) 426 adapter->guest->subsystem = val; 427 428 if (cxl_verbose) 429 read_vpd(adapter, NULL); 430 431 return 0; 432 } 433 434 static int cxl_of_remove(struct platform_device *pdev) 435 { 436 struct cxl *adapter; 437 int afu; 438 439 adapter = dev_get_drvdata(&pdev->dev); 440 for (afu = 0; afu < adapter->slices; afu++) 441 cxl_guest_remove_afu(adapter->afu[afu]); 442 443 cxl_guest_remove_adapter(adapter); 444 return 0; 445 } 446 447 static void cxl_of_shutdown(struct platform_device *pdev) 448 { 449 cxl_of_remove(pdev); 450 } 451 452 int cxl_of_probe(struct platform_device *pdev) 453 { 454 struct device_node *np = NULL; 455 struct device_node *afu_np = NULL; 456 struct cxl *adapter = NULL; 457 int ret; 458 int slice = 0, slice_ok = 0; 459 460 pr_devel("in %s\n", __func__); 461 462 np = pdev->dev.of_node; 463 if (np == NULL) 464 return -ENODEV; 465 466 /* init adapter */ 467 adapter = cxl_guest_init_adapter(np, pdev); 468 if (IS_ERR(adapter)) { 469 dev_err(&pdev->dev, "guest_init_adapter failed: %li\n", PTR_ERR(adapter)); 470 return PTR_ERR(adapter); 471 } 472 473 /* init afu */ 474 for_each_child_of_node(np, afu_np) { 475 if ((ret = cxl_guest_init_afu(adapter, slice, afu_np))) 476 dev_err(&pdev->dev, "AFU %i failed to initialise: %i\n", 477 slice, ret); 478 else 479 slice_ok++; 480 slice++; 481 } 482 483 if (slice_ok == 0) { 484 dev_info(&pdev->dev, "No active AFU"); 485 adapter->slices = 0; 486 } 487 488 return 0; 489 } 490 491 static const struct of_device_id cxl_of_match[] = { 492 { .compatible = "ibm,coherent-platform-facility",}, 493 {}, 494 }; 495 MODULE_DEVICE_TABLE(of, cxl_of_match); 496 497 struct platform_driver cxl_of_driver = { 498 .driver = { 499 .name = "cxl_of", 500 .of_match_table = cxl_of_match, 501 .owner = THIS_MODULE 502 }, 503 .probe = cxl_of_probe, 504 .remove = cxl_of_remove, 505 .shutdown = cxl_of_shutdown, 506 }; 507