1
2
3
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
16static 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
27static 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
40static 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
54static int read_handle(struct device_node *np, u64 *handle)
55{
56 const __be32 *prop;
57 u64 size;
58
59
60 prop = of_get_address(np, 0, &size, NULL);
61 if (size)
62 return -EINVAL;
63
64
65 *handle = of_read_number(prop, of_n_addr_cells(np));
66 return 0;
67}
68
69static 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:
88 afu->guest->handle = addr;
89 break;
90 case 1:
91 afu->guest->p2n_phys += addr;
92 afu->guest->p2n_size = size;
93 break;
94 case 2:
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
111static 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
131int 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
140int 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
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
196
197
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
250
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
283static 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
295
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 = kcalloc(BITS_TO_LONGS(cur->range),
312 sizeof(*cur->bitmap), GFP_KERNEL);
313 if (cur->bitmap == NULL)
314 goto err;
315 if (cur->offset < adapter->guest->irq_base_offset)
316 adapter->guest->irq_base_offset = cur->offset;
317 if (cxl_verbose)
318 pr_info("available IRQ range: %#lx-%#lx (%lu)\n",
319 cur->offset, cur->offset + cur->range - 1,
320 cur->range);
321 }
322 adapter->guest->irq_nranges = nranges;
323 spin_lock_init(&adapter->guest->irq_alloc_lock);
324
325 return 0;
326err:
327 for (i--; i >= 0; i--) {
328 cur = &adapter->guest->irq_avail[i];
329 kfree(cur->bitmap);
330 }
331 kfree(adapter->guest->irq_avail);
332 adapter->guest->irq_avail = NULL;
333 return -ENOMEM;
334}
335
336int cxl_of_read_adapter_handle(struct cxl *adapter, struct device_node *np)
337{
338 if (read_handle(np, &adapter->guest->handle))
339 return -EINVAL;
340 pr_devel("Adapter handle: 0x%.16llx\n", adapter->guest->handle);
341
342 return 0;
343}
344
345int cxl_of_read_adapter_properties(struct cxl *adapter, struct device_node *np)
346{
347 int rc, len, naddr, i;
348 char *p;
349 const __be32 *prop;
350 u32 val = 0;
351
352
353
354 naddr = of_n_addr_cells(np);
355
356 if (cxl_verbose) {
357 pr_info("Dump of the 'ibm,coherent-platform-facility' node properties:\n");
358
359 read_prop_dword(np, "#address-cells", &val);
360 read_prop_dword(np, "#size-cells", &val);
361
362 prop = of_get_property(np, "compatible", &len);
363 i = 0;
364 while (i < len) {
365 p = (char *) prop + i;
366 pr_info("compatible: %s\n", p);
367 i += strlen(p) + 1;
368 }
369 read_prop_string(np, "name");
370 read_prop_string(np, "model");
371
372 prop = of_get_property(np, "reg", NULL);
373 if (prop) {
374 pr_info("reg: addr:%#llx size:%#x\n",
375 of_read_number(prop, naddr),
376 be32_to_cpu(prop[naddr]));
377 }
378
379 read_prop_string(np, "ibm,loc-code");
380 }
381
382 if ((rc = read_adapter_irq_config(adapter, np)))
383 return rc;
384
385 if (cxl_verbose) {
386 read_prop_string(np, "device_type");
387 read_prop_string(np, "ibm,phandle");
388 }
389
390 prop = read_prop_dword(np, "ibm,caia-version", &val);
391 if (prop) {
392 adapter->caia_major = (val & 0xFF00) >> 8;
393 adapter->caia_minor = val & 0xFF;
394 }
395
396 prop = read_prop_dword(np, "ibm,psl-revision", &val);
397 if (prop)
398 adapter->psl_rev = val;
399
400 prop = read_prop_string(np, "status");
401 if (prop) {
402 adapter->guest->status = kasprintf(GFP_KERNEL, "%s", (char *) prop);
403 if (adapter->guest->status == NULL)
404 return -ENOMEM;
405 }
406
407 prop = read_prop_dword(np, "vendor-id", &val);
408 if (prop)
409 adapter->guest->vendor = val;
410
411 prop = read_prop_dword(np, "device-id", &val);
412 if (prop)
413 adapter->guest->device = val;
414
415 if (cxl_verbose) {
416 read_prop_dword(np, "ibm,privileged-facility", &val);
417 read_prop_dword(np, "revision-id", &val);
418 read_prop_dword(np, "class-code", &val);
419 }
420
421 prop = read_prop_dword(np, "subsystem-vendor-id", &val);
422 if (prop)
423 adapter->guest->subsystem_vendor = val;
424
425 prop = read_prop_dword(np, "subsystem-id", &val);
426 if (prop)
427 adapter->guest->subsystem = val;
428
429 if (cxl_verbose)
430 read_vpd(adapter, NULL);
431
432 return 0;
433}
434
435static int cxl_of_remove(struct platform_device *pdev)
436{
437 struct cxl *adapter;
438 int afu;
439
440 adapter = dev_get_drvdata(&pdev->dev);
441 for (afu = 0; afu < adapter->slices; afu++)
442 cxl_guest_remove_afu(adapter->afu[afu]);
443
444 cxl_guest_remove_adapter(adapter);
445 return 0;
446}
447
448static void cxl_of_shutdown(struct platform_device *pdev)
449{
450 cxl_of_remove(pdev);
451}
452
453int cxl_of_probe(struct platform_device *pdev)
454{
455 struct device_node *np = NULL;
456 struct device_node *afu_np = NULL;
457 struct cxl *adapter = NULL;
458 int ret;
459 int slice = 0, slice_ok = 0;
460
461 pr_devel("in %s\n", __func__);
462
463 np = pdev->dev.of_node;
464 if (np == NULL)
465 return -ENODEV;
466
467
468 adapter = cxl_guest_init_adapter(np, pdev);
469 if (IS_ERR(adapter)) {
470 dev_err(&pdev->dev, "guest_init_adapter failed: %li\n", PTR_ERR(adapter));
471 return PTR_ERR(adapter);
472 }
473
474
475 for_each_child_of_node(np, afu_np) {
476 if ((ret = cxl_guest_init_afu(adapter, slice, afu_np)))
477 dev_err(&pdev->dev, "AFU %i failed to initialise: %i\n",
478 slice, ret);
479 else
480 slice_ok++;
481 slice++;
482 }
483
484 if (slice_ok == 0) {
485 dev_info(&pdev->dev, "No active AFU");
486 adapter->slices = 0;
487 }
488
489 return 0;
490}
491
492static const struct of_device_id cxl_of_match[] = {
493 { .compatible = "ibm,coherent-platform-facility",},
494 {},
495};
496MODULE_DEVICE_TABLE(of, cxl_of_match);
497
498struct platform_driver cxl_of_driver = {
499 .driver = {
500 .name = "cxl_of",
501 .of_match_table = cxl_of_match,
502 .owner = THIS_MODULE
503 },
504 .probe = cxl_of_probe,
505 .remove = cxl_of_remove,
506 .shutdown = cxl_of_shutdown,
507};
508
