Linux 6.7-rc7
[linux-modified.git] / drivers / misc / cxl / of.c
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 };