treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 206
[muen/linux.git] / arch / powerpc / platforms / powernv / npu-dma.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * This file implements the DMA operations for NVLink devices. The NPU
4  * devices all point to the same iommu table as the parent PCI device.
5  *
6  * Copyright Alistair Popple, IBM Corporation 2015.
7  */
8
9 #include <linux/mmu_notifier.h>
10 #include <linux/mmu_context.h>
11 #include <linux/of.h>
12 #include <linux/pci.h>
13 #include <linux/memblock.h>
14 #include <linux/sizes.h>
15
16 #include <asm/debugfs.h>
17 #include <asm/powernv.h>
18 #include <asm/opal.h>
19
20 #include "pci.h"
21
22 /*
23  * spinlock to protect initialisation of an npu_context for a particular
24  * mm_struct.
25  */
26 static DEFINE_SPINLOCK(npu_context_lock);
27
28 static struct pci_dev *get_pci_dev(struct device_node *dn)
29 {
30         struct pci_dn *pdn = PCI_DN(dn);
31
32         return pci_get_domain_bus_and_slot(pci_domain_nr(pdn->phb->bus),
33                                            pdn->busno, pdn->devfn);
34 }
35
36 /* Given a NPU device get the associated PCI device. */
37 struct pci_dev *pnv_pci_get_gpu_dev(struct pci_dev *npdev)
38 {
39         struct device_node *dn;
40         struct pci_dev *gpdev;
41
42         if (WARN_ON(!npdev))
43                 return NULL;
44
45         if (WARN_ON(!npdev->dev.of_node))
46                 return NULL;
47
48         /* Get assoicated PCI device */
49         dn = of_parse_phandle(npdev->dev.of_node, "ibm,gpu", 0);
50         if (!dn)
51                 return NULL;
52
53         gpdev = get_pci_dev(dn);
54         of_node_put(dn);
55
56         return gpdev;
57 }
58 EXPORT_SYMBOL(pnv_pci_get_gpu_dev);
59
60 /* Given the real PCI device get a linked NPU device. */
61 struct pci_dev *pnv_pci_get_npu_dev(struct pci_dev *gpdev, int index)
62 {
63         struct device_node *dn;
64         struct pci_dev *npdev;
65
66         if (WARN_ON(!gpdev))
67                 return NULL;
68
69         /* Not all PCI devices have device-tree nodes */
70         if (!gpdev->dev.of_node)
71                 return NULL;
72
73         /* Get assoicated PCI device */
74         dn = of_parse_phandle(gpdev->dev.of_node, "ibm,npu", index);
75         if (!dn)
76                 return NULL;
77
78         npdev = get_pci_dev(dn);
79         of_node_put(dn);
80
81         return npdev;
82 }
83 EXPORT_SYMBOL(pnv_pci_get_npu_dev);
84
85 /*
86  * Returns the PE assoicated with the PCI device of the given
87  * NPU. Returns the linked pci device if pci_dev != NULL.
88  */
89 static struct pnv_ioda_pe *get_gpu_pci_dev_and_pe(struct pnv_ioda_pe *npe,
90                                                   struct pci_dev **gpdev)
91 {
92         struct pnv_phb *phb;
93         struct pci_controller *hose;
94         struct pci_dev *pdev;
95         struct pnv_ioda_pe *pe;
96         struct pci_dn *pdn;
97
98         pdev = pnv_pci_get_gpu_dev(npe->pdev);
99         if (!pdev)
100                 return NULL;
101
102         pdn = pci_get_pdn(pdev);
103         if (WARN_ON(!pdn || pdn->pe_number == IODA_INVALID_PE))
104                 return NULL;
105
106         hose = pci_bus_to_host(pdev->bus);
107         phb = hose->private_data;
108         pe = &phb->ioda.pe_array[pdn->pe_number];
109
110         if (gpdev)
111                 *gpdev = pdev;
112
113         return pe;
114 }
115
116 static long pnv_npu_unset_window(struct iommu_table_group *table_group,
117                 int num);
118
119 static long pnv_npu_set_window(struct iommu_table_group *table_group, int num,
120                 struct iommu_table *tbl)
121 {
122         struct pnv_ioda_pe *npe = container_of(table_group, struct pnv_ioda_pe,
123                         table_group);
124         struct pnv_phb *phb = npe->phb;
125         int64_t rc;
126         const unsigned long size = tbl->it_indirect_levels ?
127                 tbl->it_level_size : tbl->it_size;
128         const __u64 start_addr = tbl->it_offset << tbl->it_page_shift;
129         const __u64 win_size = tbl->it_size << tbl->it_page_shift;
130         int num2 = (num == 0) ? 1 : 0;
131
132         /* NPU has just one TVE so if there is another table, remove it first */
133         if (npe->table_group.tables[num2])
134                 pnv_npu_unset_window(&npe->table_group, num2);
135
136         pe_info(npe, "Setting up window %llx..%llx pg=%lx\n",
137                         start_addr, start_addr + win_size - 1,
138                         IOMMU_PAGE_SIZE(tbl));
139
140         rc = opal_pci_map_pe_dma_window(phb->opal_id,
141                         npe->pe_number,
142                         npe->pe_number,
143                         tbl->it_indirect_levels + 1,
144                         __pa(tbl->it_base),
145                         size << 3,
146                         IOMMU_PAGE_SIZE(tbl));
147         if (rc) {
148                 pe_err(npe, "Failed to configure TCE table, err %lld\n", rc);
149                 return rc;
150         }
151         pnv_pci_ioda2_tce_invalidate_entire(phb, false);
152
153         /* Add the table to the list so its TCE cache will get invalidated */
154         pnv_pci_link_table_and_group(phb->hose->node, num,
155                         tbl, &npe->table_group);
156
157         return 0;
158 }
159
160 static long pnv_npu_unset_window(struct iommu_table_group *table_group, int num)
161 {
162         struct pnv_ioda_pe *npe = container_of(table_group, struct pnv_ioda_pe,
163                         table_group);
164         struct pnv_phb *phb = npe->phb;
165         int64_t rc;
166
167         if (!npe->table_group.tables[num])
168                 return 0;
169
170         pe_info(npe, "Removing DMA window\n");
171
172         rc = opal_pci_map_pe_dma_window(phb->opal_id, npe->pe_number,
173                         npe->pe_number,
174                         0/* levels */, 0/* table address */,
175                         0/* table size */, 0/* page size */);
176         if (rc) {
177                 pe_err(npe, "Unmapping failed, ret = %lld\n", rc);
178                 return rc;
179         }
180         pnv_pci_ioda2_tce_invalidate_entire(phb, false);
181
182         pnv_pci_unlink_table_and_group(npe->table_group.tables[num],
183                         &npe->table_group);
184
185         return 0;
186 }
187
188 /*
189  * Enables 32 bit DMA on NPU.
190  */
191 static void pnv_npu_dma_set_32(struct pnv_ioda_pe *npe)
192 {
193         struct pci_dev *gpdev;
194         struct pnv_ioda_pe *gpe;
195         int64_t rc;
196
197         /*
198          * Find the assoicated PCI devices and get the dma window
199          * information from there.
200          */
201         if (!npe->pdev || !(npe->flags & PNV_IODA_PE_DEV))
202                 return;
203
204         gpe = get_gpu_pci_dev_and_pe(npe, &gpdev);
205         if (!gpe)
206                 return;
207
208         rc = pnv_npu_set_window(&npe->table_group, 0,
209                         gpe->table_group.tables[0]);
210
211         /*
212          * NVLink devices use the same TCE table configuration as
213          * their parent device so drivers shouldn't be doing DMA
214          * operations directly on these devices.
215          */
216         set_dma_ops(&npe->pdev->dev, &dma_dummy_ops);
217 }
218
219 /*
220  * Enables bypass mode on the NPU. The NPU only supports one
221  * window per link, so bypass needs to be explicitly enabled or
222  * disabled. Unlike for a PHB3 bypass and non-bypass modes can't be
223  * active at the same time.
224  */
225 static int pnv_npu_dma_set_bypass(struct pnv_ioda_pe *npe)
226 {
227         struct pnv_phb *phb = npe->phb;
228         int64_t rc = 0;
229         phys_addr_t top = memblock_end_of_DRAM();
230
231         if (phb->type != PNV_PHB_NPU_NVLINK || !npe->pdev)
232                 return -EINVAL;
233
234         rc = pnv_npu_unset_window(&npe->table_group, 0);
235         if (rc != OPAL_SUCCESS)
236                 return rc;
237
238         /* Enable the bypass window */
239
240         top = roundup_pow_of_two(top);
241         dev_info(&npe->pdev->dev, "Enabling bypass for PE %x\n",
242                         npe->pe_number);
243         rc = opal_pci_map_pe_dma_window_real(phb->opal_id,
244                         npe->pe_number, npe->pe_number,
245                         0 /* bypass base */, top);
246
247         if (rc == OPAL_SUCCESS)
248                 pnv_pci_ioda2_tce_invalidate_entire(phb, false);
249
250         return rc;
251 }
252
253 void pnv_npu_try_dma_set_bypass(struct pci_dev *gpdev, bool bypass)
254 {
255         int i;
256         struct pnv_phb *phb;
257         struct pci_dn *pdn;
258         struct pnv_ioda_pe *npe;
259         struct pci_dev *npdev;
260
261         for (i = 0; ; ++i) {
262                 npdev = pnv_pci_get_npu_dev(gpdev, i);
263
264                 if (!npdev)
265                         break;
266
267                 pdn = pci_get_pdn(npdev);
268                 if (WARN_ON(!pdn || pdn->pe_number == IODA_INVALID_PE))
269                         return;
270
271                 phb = pci_bus_to_host(npdev->bus)->private_data;
272
273                 /* We only do bypass if it's enabled on the linked device */
274                 npe = &phb->ioda.pe_array[pdn->pe_number];
275
276                 if (bypass) {
277                         dev_info(&npdev->dev,
278                                         "Using 64-bit DMA iommu bypass\n");
279                         pnv_npu_dma_set_bypass(npe);
280                 } else {
281                         dev_info(&npdev->dev, "Using 32-bit DMA via iommu\n");
282                         pnv_npu_dma_set_32(npe);
283                 }
284         }
285 }
286
287 #ifdef CONFIG_IOMMU_API
288 /* Switch ownership from platform code to external user (e.g. VFIO) */
289 static void pnv_npu_take_ownership(struct iommu_table_group *table_group)
290 {
291         struct pnv_ioda_pe *npe = container_of(table_group, struct pnv_ioda_pe,
292                         table_group);
293         struct pnv_phb *phb = npe->phb;
294         int64_t rc;
295         struct pci_dev *gpdev = NULL;
296
297         /*
298          * Note: NPU has just a single TVE in the hardware which means that
299          * while used by the kernel, it can have either 32bit window or
300          * DMA bypass but never both. So we deconfigure 32bit window only
301          * if it was enabled at the moment of ownership change.
302          */
303         if (npe->table_group.tables[0]) {
304                 pnv_npu_unset_window(&npe->table_group, 0);
305                 return;
306         }
307
308         /* Disable bypass */
309         rc = opal_pci_map_pe_dma_window_real(phb->opal_id,
310                         npe->pe_number, npe->pe_number,
311                         0 /* bypass base */, 0);
312         if (rc) {
313                 pe_err(npe, "Failed to disable bypass, err %lld\n", rc);
314                 return;
315         }
316         pnv_pci_ioda2_tce_invalidate_entire(npe->phb, false);
317
318         get_gpu_pci_dev_and_pe(npe, &gpdev);
319         if (gpdev)
320                 pnv_npu2_unmap_lpar_dev(gpdev);
321 }
322
323 static void pnv_npu_release_ownership(struct iommu_table_group *table_group)
324 {
325         struct pnv_ioda_pe *npe = container_of(table_group, struct pnv_ioda_pe,
326                         table_group);
327         struct pci_dev *gpdev = NULL;
328
329         get_gpu_pci_dev_and_pe(npe, &gpdev);
330         if (gpdev)
331                 pnv_npu2_map_lpar_dev(gpdev, 0, MSR_DR | MSR_PR | MSR_HV);
332 }
333
334 static struct iommu_table_group_ops pnv_pci_npu_ops = {
335         .set_window = pnv_npu_set_window,
336         .unset_window = pnv_npu_unset_window,
337         .take_ownership = pnv_npu_take_ownership,
338         .release_ownership = pnv_npu_release_ownership,
339 };
340 #endif /* !CONFIG_IOMMU_API */
341
342 /*
343  * NPU2 ATS
344  */
345 /* Maximum possible number of ATSD MMIO registers per NPU */
346 #define NV_NMMU_ATSD_REGS 8
347 #define NV_NPU_MAX_PE_NUM       16
348
349 /*
350  * A compound NPU IOMMU group which might consist of 1 GPU + 2xNPUs (POWER8) or
351  * up to 3 x (GPU + 2xNPUs) (POWER9).
352  */
353 struct npu_comp {
354         struct iommu_table_group table_group;
355         int pe_num;
356         struct pnv_ioda_pe *pe[NV_NPU_MAX_PE_NUM];
357 };
358
359 /* An NPU descriptor, valid for POWER9 only */
360 struct npu {
361         int index;
362         __be64 *mmio_atsd_regs[NV_NMMU_ATSD_REGS];
363         unsigned int mmio_atsd_count;
364
365         /* Bitmask for MMIO register usage */
366         unsigned long mmio_atsd_usage;
367
368         /* Do we need to explicitly flush the nest mmu? */
369         bool nmmu_flush;
370
371         struct npu_comp npucomp;
372 };
373
374 #ifdef CONFIG_IOMMU_API
375 static long pnv_npu_peers_create_table_userspace(
376                 struct iommu_table_group *table_group,
377                 int num, __u32 page_shift, __u64 window_size, __u32 levels,
378                 struct iommu_table **ptbl)
379 {
380         struct npu_comp *npucomp = container_of(table_group, struct npu_comp,
381                         table_group);
382
383         if (!npucomp->pe_num || !npucomp->pe[0] ||
384                         !npucomp->pe[0]->table_group.ops ||
385                         !npucomp->pe[0]->table_group.ops->create_table)
386                 return -EFAULT;
387
388         return npucomp->pe[0]->table_group.ops->create_table(
389                         &npucomp->pe[0]->table_group, num, page_shift,
390                         window_size, levels, ptbl);
391 }
392
393 static long pnv_npu_peers_set_window(struct iommu_table_group *table_group,
394                 int num, struct iommu_table *tbl)
395 {
396         int i, j;
397         long ret = 0;
398         struct npu_comp *npucomp = container_of(table_group, struct npu_comp,
399                         table_group);
400
401         for (i = 0; i < npucomp->pe_num; ++i) {
402                 struct pnv_ioda_pe *pe = npucomp->pe[i];
403
404                 if (!pe->table_group.ops->set_window)
405                         continue;
406
407                 ret = pe->table_group.ops->set_window(&pe->table_group,
408                                 num, tbl);
409                 if (ret)
410                         break;
411         }
412
413         if (ret) {
414                 for (j = 0; j < i; ++j) {
415                         struct pnv_ioda_pe *pe = npucomp->pe[j];
416
417                         if (!pe->table_group.ops->unset_window)
418                                 continue;
419
420                         ret = pe->table_group.ops->unset_window(
421                                         &pe->table_group, num);
422                         if (ret)
423                                 break;
424                 }
425         } else {
426                 table_group->tables[num] = iommu_tce_table_get(tbl);
427         }
428
429         return ret;
430 }
431
432 static long pnv_npu_peers_unset_window(struct iommu_table_group *table_group,
433                 int num)
434 {
435         int i, j;
436         long ret = 0;
437         struct npu_comp *npucomp = container_of(table_group, struct npu_comp,
438                         table_group);
439
440         for (i = 0; i < npucomp->pe_num; ++i) {
441                 struct pnv_ioda_pe *pe = npucomp->pe[i];
442
443                 WARN_ON(npucomp->table_group.tables[num] !=
444                                 table_group->tables[num]);
445                 if (!npucomp->table_group.tables[num])
446                         continue;
447
448                 if (!pe->table_group.ops->unset_window)
449                         continue;
450
451                 ret = pe->table_group.ops->unset_window(&pe->table_group, num);
452                 if (ret)
453                         break;
454         }
455
456         if (ret) {
457                 for (j = 0; j < i; ++j) {
458                         struct pnv_ioda_pe *pe = npucomp->pe[j];
459
460                         if (!npucomp->table_group.tables[num])
461                                 continue;
462
463                         if (!pe->table_group.ops->set_window)
464                                 continue;
465
466                         ret = pe->table_group.ops->set_window(&pe->table_group,
467                                         num, table_group->tables[num]);
468                         if (ret)
469                                 break;
470                 }
471         } else if (table_group->tables[num]) {
472                 iommu_tce_table_put(table_group->tables[num]);
473                 table_group->tables[num] = NULL;
474         }
475
476         return ret;
477 }
478
479 static void pnv_npu_peers_take_ownership(struct iommu_table_group *table_group)
480 {
481         int i;
482         struct npu_comp *npucomp = container_of(table_group, struct npu_comp,
483                         table_group);
484
485         for (i = 0; i < npucomp->pe_num; ++i) {
486                 struct pnv_ioda_pe *pe = npucomp->pe[i];
487
488                 if (!pe->table_group.ops->take_ownership)
489                         continue;
490                 pe->table_group.ops->take_ownership(&pe->table_group);
491         }
492 }
493
494 static void pnv_npu_peers_release_ownership(
495                 struct iommu_table_group *table_group)
496 {
497         int i;
498         struct npu_comp *npucomp = container_of(table_group, struct npu_comp,
499                         table_group);
500
501         for (i = 0; i < npucomp->pe_num; ++i) {
502                 struct pnv_ioda_pe *pe = npucomp->pe[i];
503
504                 if (!pe->table_group.ops->release_ownership)
505                         continue;
506                 pe->table_group.ops->release_ownership(&pe->table_group);
507         }
508 }
509
510 static struct iommu_table_group_ops pnv_npu_peers_ops = {
511         .get_table_size = pnv_pci_ioda2_get_table_size,
512         .create_table = pnv_npu_peers_create_table_userspace,
513         .set_window = pnv_npu_peers_set_window,
514         .unset_window = pnv_npu_peers_unset_window,
515         .take_ownership = pnv_npu_peers_take_ownership,
516         .release_ownership = pnv_npu_peers_release_ownership,
517 };
518
519 static void pnv_comp_attach_table_group(struct npu_comp *npucomp,
520                 struct pnv_ioda_pe *pe)
521 {
522         if (WARN_ON(npucomp->pe_num == NV_NPU_MAX_PE_NUM))
523                 return;
524
525         npucomp->pe[npucomp->pe_num] = pe;
526         ++npucomp->pe_num;
527 }
528
529 struct iommu_table_group *pnv_try_setup_npu_table_group(struct pnv_ioda_pe *pe)
530 {
531         struct iommu_table_group *table_group;
532         struct npu_comp *npucomp;
533         struct pci_dev *gpdev = NULL;
534         struct pci_controller *hose;
535         struct pci_dev *npdev = NULL;
536
537         list_for_each_entry(gpdev, &pe->pbus->devices, bus_list) {
538                 npdev = pnv_pci_get_npu_dev(gpdev, 0);
539                 if (npdev)
540                         break;
541         }
542
543         if (!npdev)
544                 /* It is not an NPU attached device, skip */
545                 return NULL;
546
547         hose = pci_bus_to_host(npdev->bus);
548
549         if (hose->npu) {
550                 table_group = &hose->npu->npucomp.table_group;
551
552                 if (!table_group->group) {
553                         table_group->ops = &pnv_npu_peers_ops;
554                         iommu_register_group(table_group,
555                                         hose->global_number,
556                                         pe->pe_number);
557                 }
558         } else {
559                 /* Create a group for 1 GPU and attached NPUs for POWER8 */
560                 pe->npucomp = kzalloc(sizeof(*pe->npucomp), GFP_KERNEL);
561                 table_group = &pe->npucomp->table_group;
562                 table_group->ops = &pnv_npu_peers_ops;
563                 iommu_register_group(table_group, hose->global_number,
564                                 pe->pe_number);
565         }
566
567         /* Steal capabilities from a GPU PE */
568         table_group->max_dynamic_windows_supported =
569                 pe->table_group.max_dynamic_windows_supported;
570         table_group->tce32_start = pe->table_group.tce32_start;
571         table_group->tce32_size = pe->table_group.tce32_size;
572         table_group->max_levels = pe->table_group.max_levels;
573         if (!table_group->pgsizes)
574                 table_group->pgsizes = pe->table_group.pgsizes;
575
576         npucomp = container_of(table_group, struct npu_comp, table_group);
577         pnv_comp_attach_table_group(npucomp, pe);
578
579         return table_group;
580 }
581
582 struct iommu_table_group *pnv_npu_compound_attach(struct pnv_ioda_pe *pe)
583 {
584         struct iommu_table_group *table_group;
585         struct npu_comp *npucomp;
586         struct pci_dev *gpdev = NULL;
587         struct pci_dev *npdev;
588         struct pnv_ioda_pe *gpe = get_gpu_pci_dev_and_pe(pe, &gpdev);
589
590         WARN_ON(!(pe->flags & PNV_IODA_PE_DEV));
591         if (!gpe)
592                 return NULL;
593
594         /*
595          * IODA2 bridges get this set up from pci_controller_ops::setup_bridge
596          * but NPU bridges do not have this hook defined so we do it here.
597          * We do not setup other table group parameters as they won't be used
598          * anyway - NVLink bridges are subordinate PEs.
599          */
600         pe->table_group.ops = &pnv_pci_npu_ops;
601
602         table_group = iommu_group_get_iommudata(
603                         iommu_group_get(&gpdev->dev));
604
605         /*
606          * On P9 NPU PHB and PCI PHB support different page sizes,
607          * keep only matching. We expect here that NVLink bridge PE pgsizes is
608          * initialized by the caller.
609          */
610         table_group->pgsizes &= pe->table_group.pgsizes;
611         npucomp = container_of(table_group, struct npu_comp, table_group);
612         pnv_comp_attach_table_group(npucomp, pe);
613
614         list_for_each_entry(npdev, &pe->phb->hose->bus->devices, bus_list) {
615                 struct pci_dev *gpdevtmp = pnv_pci_get_gpu_dev(npdev);
616
617                 if (gpdevtmp != gpdev)
618                         continue;
619
620                 iommu_add_device(table_group, &npdev->dev);
621         }
622
623         return table_group;
624 }
625 #endif /* CONFIG_IOMMU_API */
626
627 /* Maximum number of nvlinks per npu */
628 #define NV_MAX_LINKS 6
629
630 /* Maximum index of npu2 hosts in the system. Always < NV_MAX_NPUS */
631 static int max_npu2_index;
632
633 struct npu_context {
634         struct mm_struct *mm;
635         struct pci_dev *npdev[NV_MAX_NPUS][NV_MAX_LINKS];
636         struct mmu_notifier mn;
637         struct kref kref;
638         bool nmmu_flush;
639
640         /* Callback to stop translation requests on a given GPU */
641         void (*release_cb)(struct npu_context *context, void *priv);
642
643         /*
644          * Private pointer passed to the above callback for usage by
645          * device drivers.
646          */
647         void *priv;
648 };
649
650 struct mmio_atsd_reg {
651         struct npu *npu;
652         int reg;
653 };
654
655 /*
656  * Find a free MMIO ATSD register and mark it in use. Return -ENOSPC
657  * if none are available.
658  */
659 static int get_mmio_atsd_reg(struct npu *npu)
660 {
661         int i;
662
663         for (i = 0; i < npu->mmio_atsd_count; i++) {
664                 if (!test_bit(i, &npu->mmio_atsd_usage))
665                         if (!test_and_set_bit_lock(i, &npu->mmio_atsd_usage))
666                                 return i;
667         }
668
669         return -ENOSPC;
670 }
671
672 static void put_mmio_atsd_reg(struct npu *npu, int reg)
673 {
674         clear_bit_unlock(reg, &npu->mmio_atsd_usage);
675 }
676
677 /* MMIO ATSD register offsets */
678 #define XTS_ATSD_LAUNCH 0
679 #define XTS_ATSD_AVA    1
680 #define XTS_ATSD_STAT   2
681
682 static unsigned long get_atsd_launch_val(unsigned long pid, unsigned long psize)
683 {
684         unsigned long launch = 0;
685
686         if (psize == MMU_PAGE_COUNT) {
687                 /* IS set to invalidate entire matching PID */
688                 launch |= PPC_BIT(12);
689         } else {
690                 /* AP set to invalidate region of psize */
691                 launch |= (u64)mmu_get_ap(psize) << PPC_BITLSHIFT(17);
692         }
693
694         /* PRS set to process-scoped */
695         launch |= PPC_BIT(13);
696
697         /* PID */
698         launch |= pid << PPC_BITLSHIFT(38);
699
700         /* Leave "No flush" (bit 39) 0 so every ATSD performs a flush */
701
702         return launch;
703 }
704
705 static void mmio_atsd_regs_write(struct mmio_atsd_reg
706                         mmio_atsd_reg[NV_MAX_NPUS], unsigned long offset,
707                         unsigned long val)
708 {
709         struct npu *npu;
710         int i, reg;
711
712         for (i = 0; i <= max_npu2_index; i++) {
713                 reg = mmio_atsd_reg[i].reg;
714                 if (reg < 0)
715                         continue;
716
717                 npu = mmio_atsd_reg[i].npu;
718                 __raw_writeq_be(val, npu->mmio_atsd_regs[reg] + offset);
719         }
720 }
721
722 static void mmio_invalidate_pid(struct mmio_atsd_reg mmio_atsd_reg[NV_MAX_NPUS],
723                                 unsigned long pid)
724 {
725         unsigned long launch = get_atsd_launch_val(pid, MMU_PAGE_COUNT);
726
727         /* Invalidating the entire process doesn't use a va */
728         mmio_atsd_regs_write(mmio_atsd_reg, XTS_ATSD_LAUNCH, launch);
729 }
730
731 static void mmio_invalidate_range(struct mmio_atsd_reg
732                         mmio_atsd_reg[NV_MAX_NPUS], unsigned long pid,
733                         unsigned long start, unsigned long psize)
734 {
735         unsigned long launch = get_atsd_launch_val(pid, psize);
736
737         /* Write all VAs first */
738         mmio_atsd_regs_write(mmio_atsd_reg, XTS_ATSD_AVA, start);
739
740         /* Issue one barrier for all address writes */
741         eieio();
742
743         /* Launch */
744         mmio_atsd_regs_write(mmio_atsd_reg, XTS_ATSD_LAUNCH, launch);
745 }
746
747 #define mn_to_npu_context(x) container_of(x, struct npu_context, mn)
748
749 static void mmio_invalidate_wait(
750         struct mmio_atsd_reg mmio_atsd_reg[NV_MAX_NPUS])
751 {
752         struct npu *npu;
753         int i, reg;
754
755         /* Wait for all invalidations to complete */
756         for (i = 0; i <= max_npu2_index; i++) {
757                 if (mmio_atsd_reg[i].reg < 0)
758                         continue;
759
760                 /* Wait for completion */
761                 npu = mmio_atsd_reg[i].npu;
762                 reg = mmio_atsd_reg[i].reg;
763                 while (__raw_readq(npu->mmio_atsd_regs[reg] + XTS_ATSD_STAT))
764                         cpu_relax();
765         }
766 }
767
768 /*
769  * Acquires all the address translation shootdown (ATSD) registers required to
770  * launch an ATSD on all links this npu_context is active on.
771  */
772 static void acquire_atsd_reg(struct npu_context *npu_context,
773                         struct mmio_atsd_reg mmio_atsd_reg[NV_MAX_NPUS])
774 {
775         int i, j;
776         struct npu *npu;
777         struct pci_dev *npdev;
778
779         for (i = 0; i <= max_npu2_index; i++) {
780                 mmio_atsd_reg[i].reg = -1;
781                 for (j = 0; j < NV_MAX_LINKS; j++) {
782                         /*
783                          * There are no ordering requirements with respect to
784                          * the setup of struct npu_context, but to ensure
785                          * consistent behaviour we need to ensure npdev[][] is
786                          * only read once.
787                          */
788                         npdev = READ_ONCE(npu_context->npdev[i][j]);
789                         if (!npdev)
790                                 continue;
791
792                         npu = pci_bus_to_host(npdev->bus)->npu;
793                         if (!npu)
794                                 continue;
795
796                         mmio_atsd_reg[i].npu = npu;
797                         mmio_atsd_reg[i].reg = get_mmio_atsd_reg(npu);
798                         while (mmio_atsd_reg[i].reg < 0) {
799                                 mmio_atsd_reg[i].reg = get_mmio_atsd_reg(npu);
800                                 cpu_relax();
801                         }
802                         break;
803                 }
804         }
805 }
806
807 /*
808  * Release previously acquired ATSD registers. To avoid deadlocks the registers
809  * must be released in the same order they were acquired above in
810  * acquire_atsd_reg.
811  */
812 static void release_atsd_reg(struct mmio_atsd_reg mmio_atsd_reg[NV_MAX_NPUS])
813 {
814         int i;
815
816         for (i = 0; i <= max_npu2_index; i++) {
817                 /*
818                  * We can't rely on npu_context->npdev[][] being the same here
819                  * as when acquire_atsd_reg() was called, hence we use the
820                  * values stored in mmio_atsd_reg during the acquire phase
821                  * rather than re-reading npdev[][].
822                  */
823                 if (mmio_atsd_reg[i].reg < 0)
824                         continue;
825
826                 put_mmio_atsd_reg(mmio_atsd_reg[i].npu, mmio_atsd_reg[i].reg);
827         }
828 }
829
830 /*
831  * Invalidate a virtual address range
832  */
833 static void mmio_invalidate(struct npu_context *npu_context,
834                         unsigned long start, unsigned long size)
835 {
836         struct mmio_atsd_reg mmio_atsd_reg[NV_MAX_NPUS];
837         unsigned long pid = npu_context->mm->context.id;
838         unsigned long atsd_start = 0;
839         unsigned long end = start + size - 1;
840         int atsd_psize = MMU_PAGE_COUNT;
841
842         /*
843          * Convert the input range into one of the supported sizes. If the range
844          * doesn't fit, use the next larger supported size. Invalidation latency
845          * is high, so over-invalidation is preferred to issuing multiple
846          * invalidates.
847          *
848          * A 4K page size isn't supported by NPU/GPU ATS, so that case is
849          * ignored.
850          */
851         if (size == SZ_64K) {
852                 atsd_start = start;
853                 atsd_psize = MMU_PAGE_64K;
854         } else if (ALIGN_DOWN(start, SZ_2M) == ALIGN_DOWN(end, SZ_2M)) {
855                 atsd_start = ALIGN_DOWN(start, SZ_2M);
856                 atsd_psize = MMU_PAGE_2M;
857         } else if (ALIGN_DOWN(start, SZ_1G) == ALIGN_DOWN(end, SZ_1G)) {
858                 atsd_start = ALIGN_DOWN(start, SZ_1G);
859                 atsd_psize = MMU_PAGE_1G;
860         }
861
862         if (npu_context->nmmu_flush)
863                 /*
864                  * Unfortunately the nest mmu does not support flushing specific
865                  * addresses so we have to flush the whole mm once before
866                  * shooting down the GPU translation.
867                  */
868                 flush_all_mm(npu_context->mm);
869
870         /*
871          * Loop over all the NPUs this process is active on and launch
872          * an invalidate.
873          */
874         acquire_atsd_reg(npu_context, mmio_atsd_reg);
875
876         if (atsd_psize == MMU_PAGE_COUNT)
877                 mmio_invalidate_pid(mmio_atsd_reg, pid);
878         else
879                 mmio_invalidate_range(mmio_atsd_reg, pid, atsd_start,
880                                         atsd_psize);
881
882         mmio_invalidate_wait(mmio_atsd_reg);
883
884         /*
885          * The GPU requires two flush ATSDs to ensure all entries have been
886          * flushed. We use PID 0 as it will never be used for a process on the
887          * GPU.
888          */
889         mmio_invalidate_pid(mmio_atsd_reg, 0);
890         mmio_invalidate_wait(mmio_atsd_reg);
891         mmio_invalidate_pid(mmio_atsd_reg, 0);
892         mmio_invalidate_wait(mmio_atsd_reg);
893
894         release_atsd_reg(mmio_atsd_reg);
895 }
896
897 static void pnv_npu2_mn_release(struct mmu_notifier *mn,
898                                 struct mm_struct *mm)
899 {
900         struct npu_context *npu_context = mn_to_npu_context(mn);
901
902         /* Call into device driver to stop requests to the NMMU */
903         if (npu_context->release_cb)
904                 npu_context->release_cb(npu_context, npu_context->priv);
905
906         /*
907          * There should be no more translation requests for this PID, but we
908          * need to ensure any entries for it are removed from the TLB.
909          */
910         mmio_invalidate(npu_context, 0, ~0UL);
911 }
912
913 static void pnv_npu2_mn_invalidate_range(struct mmu_notifier *mn,
914                                         struct mm_struct *mm,
915                                         unsigned long start, unsigned long end)
916 {
917         struct npu_context *npu_context = mn_to_npu_context(mn);
918         mmio_invalidate(npu_context, start, end - start);
919 }
920
921 static const struct mmu_notifier_ops nv_nmmu_notifier_ops = {
922         .release = pnv_npu2_mn_release,
923         .invalidate_range = pnv_npu2_mn_invalidate_range,
924 };
925
926 /*
927  * Call into OPAL to setup the nmmu context for the current task in
928  * the NPU. This must be called to setup the context tables before the
929  * GPU issues ATRs. pdev should be a pointed to PCIe GPU device.
930  *
931  * A release callback should be registered to allow a device driver to
932  * be notified that it should not launch any new translation requests
933  * as the final TLB invalidate is about to occur.
934  *
935  * Returns an error if there no contexts are currently available or a
936  * npu_context which should be passed to pnv_npu2_handle_fault().
937  *
938  * mmap_sem must be held in write mode and must not be called from interrupt
939  * context.
940  */
941 struct npu_context *pnv_npu2_init_context(struct pci_dev *gpdev,
942                         unsigned long flags,
943                         void (*cb)(struct npu_context *, void *),
944                         void *priv)
945 {
946         int rc;
947         u32 nvlink_index;
948         struct device_node *nvlink_dn;
949         struct mm_struct *mm = current->mm;
950         struct npu *npu;
951         struct npu_context *npu_context;
952         struct pci_controller *hose;
953
954         /*
955          * At present we don't support GPUs connected to multiple NPUs and I'm
956          * not sure the hardware does either.
957          */
958         struct pci_dev *npdev = pnv_pci_get_npu_dev(gpdev, 0);
959
960         if (!npdev)
961                 /* No nvlink associated with this GPU device */
962                 return ERR_PTR(-ENODEV);
963
964         /* We only support DR/PR/HV in pnv_npu2_map_lpar_dev() */
965         if (flags & ~(MSR_DR | MSR_PR | MSR_HV))
966                 return ERR_PTR(-EINVAL);
967
968         nvlink_dn = of_parse_phandle(npdev->dev.of_node, "ibm,nvlink", 0);
969         if (WARN_ON(of_property_read_u32(nvlink_dn, "ibm,npu-link-index",
970                                                         &nvlink_index)))
971                 return ERR_PTR(-ENODEV);
972
973         if (!mm || mm->context.id == 0) {
974                 /*
975                  * Kernel thread contexts are not supported and context id 0 is
976                  * reserved on the GPU.
977                  */
978                 return ERR_PTR(-EINVAL);
979         }
980
981         hose = pci_bus_to_host(npdev->bus);
982         npu = hose->npu;
983         if (!npu)
984                 return ERR_PTR(-ENODEV);
985
986         /*
987          * We store the npu pci device so we can more easily get at the
988          * associated npus.
989          */
990         spin_lock(&npu_context_lock);
991         npu_context = mm->context.npu_context;
992         if (npu_context) {
993                 if (npu_context->release_cb != cb ||
994                         npu_context->priv != priv) {
995                         spin_unlock(&npu_context_lock);
996                         return ERR_PTR(-EINVAL);
997                 }
998
999                 WARN_ON(!kref_get_unless_zero(&npu_context->kref));
1000         }
1001         spin_unlock(&npu_context_lock);
1002
1003         if (!npu_context) {
1004                 /*
1005                  * We can set up these fields without holding the
1006                  * npu_context_lock as the npu_context hasn't been returned to
1007                  * the caller meaning it can't be destroyed. Parallel allocation
1008                  * is protected against by mmap_sem.
1009                  */
1010                 rc = -ENOMEM;
1011                 npu_context = kzalloc(sizeof(struct npu_context), GFP_KERNEL);
1012                 if (npu_context) {
1013                         kref_init(&npu_context->kref);
1014                         npu_context->mm = mm;
1015                         npu_context->mn.ops = &nv_nmmu_notifier_ops;
1016                         rc = __mmu_notifier_register(&npu_context->mn, mm);
1017                 }
1018
1019                 if (rc) {
1020                         kfree(npu_context);
1021                         return ERR_PTR(rc);
1022                 }
1023
1024                 mm->context.npu_context = npu_context;
1025         }
1026
1027         npu_context->release_cb = cb;
1028         npu_context->priv = priv;
1029
1030         /*
1031          * npdev is a pci_dev pointer setup by the PCI code. We assign it to
1032          * npdev[][] to indicate to the mmu notifiers that an invalidation
1033          * should also be sent over this nvlink. The notifiers don't use any
1034          * other fields in npu_context, so we just need to ensure that when they
1035          * deference npu_context->npdev[][] it is either a valid pointer or
1036          * NULL.
1037          */
1038         WRITE_ONCE(npu_context->npdev[npu->index][nvlink_index], npdev);
1039
1040         if (!npu->nmmu_flush) {
1041                 /*
1042                  * If we're not explicitly flushing ourselves we need to mark
1043                  * the thread for global flushes
1044                  */
1045                 npu_context->nmmu_flush = false;
1046                 mm_context_add_copro(mm);
1047         } else
1048                 npu_context->nmmu_flush = true;
1049
1050         return npu_context;
1051 }
1052 EXPORT_SYMBOL(pnv_npu2_init_context);
1053
1054 static void pnv_npu2_release_context(struct kref *kref)
1055 {
1056         struct npu_context *npu_context =
1057                 container_of(kref, struct npu_context, kref);
1058
1059         if (!npu_context->nmmu_flush)
1060                 mm_context_remove_copro(npu_context->mm);
1061
1062         npu_context->mm->context.npu_context = NULL;
1063 }
1064
1065 /*
1066  * Destroy a context on the given GPU. May free the npu_context if it is no
1067  * longer active on any GPUs. Must not be called from interrupt context.
1068  */
1069 void pnv_npu2_destroy_context(struct npu_context *npu_context,
1070                         struct pci_dev *gpdev)
1071 {
1072         int removed;
1073         struct npu *npu;
1074         struct pci_dev *npdev = pnv_pci_get_npu_dev(gpdev, 0);
1075         struct device_node *nvlink_dn;
1076         u32 nvlink_index;
1077         struct pci_controller *hose;
1078
1079         if (WARN_ON(!npdev))
1080                 return;
1081
1082         hose = pci_bus_to_host(npdev->bus);
1083         npu = hose->npu;
1084         if (!npu)
1085                 return;
1086         nvlink_dn = of_parse_phandle(npdev->dev.of_node, "ibm,nvlink", 0);
1087         if (WARN_ON(of_property_read_u32(nvlink_dn, "ibm,npu-link-index",
1088                                                         &nvlink_index)))
1089                 return;
1090         WRITE_ONCE(npu_context->npdev[npu->index][nvlink_index], NULL);
1091         spin_lock(&npu_context_lock);
1092         removed = kref_put(&npu_context->kref, pnv_npu2_release_context);
1093         spin_unlock(&npu_context_lock);
1094
1095         /*
1096          * We need to do this outside of pnv_npu2_release_context so that it is
1097          * outside the spinlock as mmu_notifier_destroy uses SRCU.
1098          */
1099         if (removed) {
1100                 mmu_notifier_unregister(&npu_context->mn,
1101                                         npu_context->mm);
1102
1103                 kfree(npu_context);
1104         }
1105
1106 }
1107 EXPORT_SYMBOL(pnv_npu2_destroy_context);
1108
1109 /*
1110  * Assumes mmap_sem is held for the contexts associated mm.
1111  */
1112 int pnv_npu2_handle_fault(struct npu_context *context, uintptr_t *ea,
1113                         unsigned long *flags, unsigned long *status, int count)
1114 {
1115         u64 rc = 0, result = 0;
1116         int i, is_write;
1117         struct page *page[1];
1118         const char __user *u;
1119         char c;
1120
1121         /* mmap_sem should be held so the struct_mm must be present */
1122         struct mm_struct *mm = context->mm;
1123
1124         WARN_ON(!rwsem_is_locked(&mm->mmap_sem));
1125
1126         for (i = 0; i < count; i++) {
1127                 is_write = flags[i] & NPU2_WRITE;
1128                 rc = get_user_pages_remote(NULL, mm, ea[i], 1,
1129                                         is_write ? FOLL_WRITE : 0,
1130                                         page, NULL, NULL);
1131
1132                 if (rc != 1) {
1133                         status[i] = rc;
1134                         result = -EFAULT;
1135                         continue;
1136                 }
1137
1138                 /* Make sure partition scoped tree gets a pte */
1139                 u = page_address(page[0]);
1140                 if (__get_user(c, u))
1141                         result = -EFAULT;
1142
1143                 status[i] = 0;
1144                 put_page(page[0]);
1145         }
1146
1147         return result;
1148 }
1149 EXPORT_SYMBOL(pnv_npu2_handle_fault);
1150
1151 int pnv_npu2_init(struct pci_controller *hose)
1152 {
1153         unsigned int i;
1154         u64 mmio_atsd;
1155         static int npu_index;
1156         struct npu *npu;
1157         int ret;
1158
1159         npu = kzalloc(sizeof(*npu), GFP_KERNEL);
1160         if (!npu)
1161                 return -ENOMEM;
1162
1163         npu->nmmu_flush = of_property_read_bool(hose->dn, "ibm,nmmu-flush");
1164
1165         for (i = 0; i < ARRAY_SIZE(npu->mmio_atsd_regs) &&
1166                         !of_property_read_u64_index(hose->dn, "ibm,mmio-atsd",
1167                                 i, &mmio_atsd); i++)
1168                 npu->mmio_atsd_regs[i] = ioremap(mmio_atsd, 32);
1169
1170         pr_info("NPU%d: Found %d MMIO ATSD registers", hose->global_number, i);
1171         npu->mmio_atsd_count = i;
1172         npu->mmio_atsd_usage = 0;
1173         npu_index++;
1174         if (WARN_ON(npu_index >= NV_MAX_NPUS)) {
1175                 ret = -ENOSPC;
1176                 goto fail_exit;
1177         }
1178         max_npu2_index = npu_index;
1179         npu->index = npu_index;
1180         hose->npu = npu;
1181
1182         return 0;
1183
1184 fail_exit:
1185         for (i = 0; i < npu->mmio_atsd_count; ++i)
1186                 iounmap(npu->mmio_atsd_regs[i]);
1187
1188         kfree(npu);
1189
1190         return ret;
1191 }
1192
1193 int pnv_npu2_map_lpar_dev(struct pci_dev *gpdev, unsigned int lparid,
1194                 unsigned long msr)
1195 {
1196         int ret;
1197         struct pci_dev *npdev = pnv_pci_get_npu_dev(gpdev, 0);
1198         struct pci_controller *hose;
1199         struct pnv_phb *nphb;
1200
1201         if (!npdev)
1202                 return -ENODEV;
1203
1204         hose = pci_bus_to_host(npdev->bus);
1205         nphb = hose->private_data;
1206
1207         dev_dbg(&gpdev->dev, "Map LPAR opalid=%llu lparid=%u\n",
1208                         nphb->opal_id, lparid);
1209         /*
1210          * Currently we only support radix and non-zero LPCR only makes sense
1211          * for hash tables so skiboot expects the LPCR parameter to be a zero.
1212          */
1213         ret = opal_npu_map_lpar(nphb->opal_id, pci_dev_id(gpdev), lparid,
1214                                 0 /* LPCR bits */);
1215         if (ret) {
1216                 dev_err(&gpdev->dev, "Error %d mapping device to LPAR\n", ret);
1217                 return ret;
1218         }
1219
1220         dev_dbg(&gpdev->dev, "init context opalid=%llu msr=%lx\n",
1221                         nphb->opal_id, msr);
1222         ret = opal_npu_init_context(nphb->opal_id, 0/*__unused*/, msr,
1223                                     pci_dev_id(gpdev));
1224         if (ret < 0)
1225                 dev_err(&gpdev->dev, "Failed to init context: %d\n", ret);
1226         else
1227                 ret = 0;
1228
1229         return 0;
1230 }
1231 EXPORT_SYMBOL_GPL(pnv_npu2_map_lpar_dev);
1232
1233 void pnv_npu2_map_lpar(struct pnv_ioda_pe *gpe, unsigned long msr)
1234 {
1235         struct pci_dev *gpdev;
1236
1237         list_for_each_entry(gpdev, &gpe->pbus->devices, bus_list)
1238                 pnv_npu2_map_lpar_dev(gpdev, 0, msr);
1239 }
1240
1241 int pnv_npu2_unmap_lpar_dev(struct pci_dev *gpdev)
1242 {
1243         int ret;
1244         struct pci_dev *npdev = pnv_pci_get_npu_dev(gpdev, 0);
1245         struct pci_controller *hose;
1246         struct pnv_phb *nphb;
1247
1248         if (!npdev)
1249                 return -ENODEV;
1250
1251         hose = pci_bus_to_host(npdev->bus);
1252         nphb = hose->private_data;
1253
1254         dev_dbg(&gpdev->dev, "destroy context opalid=%llu\n",
1255                         nphb->opal_id);
1256         ret = opal_npu_destroy_context(nphb->opal_id, 0/*__unused*/,
1257                                        pci_dev_id(gpdev));
1258         if (ret < 0) {
1259                 dev_err(&gpdev->dev, "Failed to destroy context: %d\n", ret);
1260                 return ret;
1261         }
1262
1263         /* Set LPID to 0 anyway, just to be safe */
1264         dev_dbg(&gpdev->dev, "Map LPAR opalid=%llu lparid=0\n", nphb->opal_id);
1265         ret = opal_npu_map_lpar(nphb->opal_id, pci_dev_id(gpdev), 0 /*LPID*/,
1266                                 0 /* LPCR bits */);
1267         if (ret)
1268                 dev_err(&gpdev->dev, "Error %d mapping device to LPAR\n", ret);
1269
1270         return ret;
1271 }
1272 EXPORT_SYMBOL_GPL(pnv_npu2_unmap_lpar_dev);