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