xref: /linux/drivers/vfio/pci/nvgrace-gpu/main.c (revision d163d60258c755845cbc9cfe0e45fca71e649488)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (c) 2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved
4  */
5 
6 #include <linux/sizes.h>
7 #include <linux/vfio_pci_core.h>
8 
9 /*
10  * The device memory usable to the workloads running in the VM is cached
11  * and showcased as a 64b device BAR (comprising of BAR4 and BAR5 region)
12  * to the VM and is represented as usemem.
13  * Moreover, the VM GPU device driver needs a non-cacheable region to
14  * support the MIG feature. This region is also exposed as a 64b BAR
15  * (comprising of BAR2 and BAR3 region) and represented as resmem.
16  */
17 #define RESMEM_REGION_INDEX VFIO_PCI_BAR2_REGION_INDEX
18 #define USEMEM_REGION_INDEX VFIO_PCI_BAR4_REGION_INDEX
19 
20 /* Memory size expected as non cached and reserved by the VM driver */
21 #define RESMEM_SIZE SZ_1G
22 
23 /* A hardwired and constant ABI value between the GPU FW and VFIO driver. */
24 #define MEMBLK_SIZE SZ_512M
25 
26 /*
27  * The state of the two device memory region - resmem and usemem - is
28  * saved as struct mem_region.
29  */
30 struct mem_region {
31 	phys_addr_t memphys;    /* Base physical address of the region */
32 	size_t memlength;       /* Region size */
33 	size_t bar_size;        /* Reported region BAR size */
34 	__le64 bar_val;         /* Emulated BAR offset registers */
35 	union {
36 		void *memaddr;
37 		void __iomem *ioaddr;
38 	};                      /* Base virtual address of the region */
39 };
40 
41 struct nvgrace_gpu_pci_core_device {
42 	struct vfio_pci_core_device core_device;
43 	/* Cached and usable memory for the VM. */
44 	struct mem_region usemem;
45 	/* Non cached memory carved out from the end of device memory */
46 	struct mem_region resmem;
47 	/* Lock to control device memory kernel mapping */
48 	struct mutex remap_lock;
49 };
50 
51 static void nvgrace_gpu_init_fake_bar_emu_regs(struct vfio_device *core_vdev)
52 {
53 	struct nvgrace_gpu_pci_core_device *nvdev =
54 		container_of(core_vdev, struct nvgrace_gpu_pci_core_device,
55 			     core_device.vdev);
56 
57 	nvdev->resmem.bar_val = 0;
58 	nvdev->usemem.bar_val = 0;
59 }
60 
61 /* Choose the structure corresponding to the fake BAR with a given index. */
62 static struct mem_region *
63 nvgrace_gpu_memregion(int index,
64 		      struct nvgrace_gpu_pci_core_device *nvdev)
65 {
66 	if (index == USEMEM_REGION_INDEX)
67 		return &nvdev->usemem;
68 
69 	if (index == RESMEM_REGION_INDEX)
70 		return &nvdev->resmem;
71 
72 	return NULL;
73 }
74 
75 static int nvgrace_gpu_open_device(struct vfio_device *core_vdev)
76 {
77 	struct vfio_pci_core_device *vdev =
78 		container_of(core_vdev, struct vfio_pci_core_device, vdev);
79 	struct nvgrace_gpu_pci_core_device *nvdev =
80 		container_of(core_vdev, struct nvgrace_gpu_pci_core_device,
81 			     core_device.vdev);
82 	int ret;
83 
84 	ret = vfio_pci_core_enable(vdev);
85 	if (ret)
86 		return ret;
87 
88 	if (nvdev->usemem.memlength) {
89 		nvgrace_gpu_init_fake_bar_emu_regs(core_vdev);
90 		mutex_init(&nvdev->remap_lock);
91 	}
92 
93 	vfio_pci_core_finish_enable(vdev);
94 
95 	return 0;
96 }
97 
98 static void nvgrace_gpu_close_device(struct vfio_device *core_vdev)
99 {
100 	struct nvgrace_gpu_pci_core_device *nvdev =
101 		container_of(core_vdev, struct nvgrace_gpu_pci_core_device,
102 			     core_device.vdev);
103 
104 	/* Unmap the mapping to the device memory cached region */
105 	if (nvdev->usemem.memaddr) {
106 		memunmap(nvdev->usemem.memaddr);
107 		nvdev->usemem.memaddr = NULL;
108 	}
109 
110 	/* Unmap the mapping to the device memory non-cached region */
111 	if (nvdev->resmem.ioaddr) {
112 		iounmap(nvdev->resmem.ioaddr);
113 		nvdev->resmem.ioaddr = NULL;
114 	}
115 
116 	mutex_destroy(&nvdev->remap_lock);
117 
118 	vfio_pci_core_close_device(core_vdev);
119 }
120 
121 static int nvgrace_gpu_mmap(struct vfio_device *core_vdev,
122 			    struct vm_area_struct *vma)
123 {
124 	struct nvgrace_gpu_pci_core_device *nvdev =
125 		container_of(core_vdev, struct nvgrace_gpu_pci_core_device,
126 			     core_device.vdev);
127 	struct mem_region *memregion;
128 	unsigned long start_pfn;
129 	u64 req_len, pgoff, end;
130 	unsigned int index;
131 	int ret = 0;
132 
133 	index = vma->vm_pgoff >> (VFIO_PCI_OFFSET_SHIFT - PAGE_SHIFT);
134 
135 	memregion = nvgrace_gpu_memregion(index, nvdev);
136 	if (!memregion)
137 		return vfio_pci_core_mmap(core_vdev, vma);
138 
139 	/*
140 	 * Request to mmap the BAR. Map to the CPU accessible memory on the
141 	 * GPU using the memory information gathered from the system ACPI
142 	 * tables.
143 	 */
144 	pgoff = vma->vm_pgoff &
145 		((1U << (VFIO_PCI_OFFSET_SHIFT - PAGE_SHIFT)) - 1);
146 
147 	if (check_sub_overflow(vma->vm_end, vma->vm_start, &req_len) ||
148 	    check_add_overflow(PHYS_PFN(memregion->memphys), pgoff, &start_pfn) ||
149 	    check_add_overflow(PFN_PHYS(pgoff), req_len, &end))
150 		return -EOVERFLOW;
151 
152 	/*
153 	 * Check that the mapping request does not go beyond available device
154 	 * memory size
155 	 */
156 	if (end > memregion->memlength)
157 		return -EINVAL;
158 
159 	/*
160 	 * The carved out region of the device memory needs the NORMAL_NC
161 	 * property. Communicate as such to the hypervisor.
162 	 */
163 	if (index == RESMEM_REGION_INDEX) {
164 		/*
165 		 * The nvgrace-gpu module has no issues with uncontained
166 		 * failures on NORMAL_NC accesses. VM_ALLOW_ANY_UNCACHED is
167 		 * set to communicate to the KVM to S2 map as NORMAL_NC.
168 		 * This opens up guest usage of NORMAL_NC for this mapping.
169 		 */
170 		vm_flags_set(vma, VM_ALLOW_ANY_UNCACHED);
171 
172 		vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
173 	}
174 
175 	/*
176 	 * Perform a PFN map to the memory and back the device BAR by the
177 	 * GPU memory.
178 	 *
179 	 * The available GPU memory size may not be power-of-2 aligned. The
180 	 * remainder is only backed by vfio_device_ops read/write handlers.
181 	 *
182 	 * During device reset, the GPU is safely disconnected to the CPU
183 	 * and access to the BAR will be immediately returned preventing
184 	 * machine check.
185 	 */
186 	ret = remap_pfn_range(vma, vma->vm_start, start_pfn,
187 			      req_len, vma->vm_page_prot);
188 	if (ret)
189 		return ret;
190 
191 	vma->vm_pgoff = start_pfn;
192 
193 	return 0;
194 }
195 
196 static long
197 nvgrace_gpu_ioctl_get_region_info(struct vfio_device *core_vdev,
198 				  unsigned long arg)
199 {
200 	struct nvgrace_gpu_pci_core_device *nvdev =
201 		container_of(core_vdev, struct nvgrace_gpu_pci_core_device,
202 			     core_device.vdev);
203 	unsigned long minsz = offsetofend(struct vfio_region_info, offset);
204 	struct vfio_info_cap caps = { .buf = NULL, .size = 0 };
205 	struct vfio_region_info_cap_sparse_mmap *sparse;
206 	struct vfio_region_info info;
207 	struct mem_region *memregion;
208 	u32 size;
209 	int ret;
210 
211 	if (copy_from_user(&info, (void __user *)arg, minsz))
212 		return -EFAULT;
213 
214 	if (info.argsz < minsz)
215 		return -EINVAL;
216 
217 	/*
218 	 * Request to determine the BAR region information. Send the
219 	 * GPU memory information.
220 	 */
221 	memregion = nvgrace_gpu_memregion(info.index, nvdev);
222 	if (!memregion)
223 		return vfio_pci_core_ioctl(core_vdev,
224 					   VFIO_DEVICE_GET_REGION_INFO, arg);
225 
226 	size = struct_size(sparse, areas, 1);
227 
228 	/*
229 	 * Setup for sparse mapping for the device memory. Only the
230 	 * available device memory on the hardware is shown as a
231 	 * mappable region.
232 	 */
233 	sparse = kzalloc(size, GFP_KERNEL);
234 	if (!sparse)
235 		return -ENOMEM;
236 
237 	sparse->nr_areas = 1;
238 	sparse->areas[0].offset = 0;
239 	sparse->areas[0].size = memregion->memlength;
240 	sparse->header.id = VFIO_REGION_INFO_CAP_SPARSE_MMAP;
241 	sparse->header.version = 1;
242 
243 	ret = vfio_info_add_capability(&caps, &sparse->header, size);
244 	kfree(sparse);
245 	if (ret)
246 		return ret;
247 
248 	info.offset = VFIO_PCI_INDEX_TO_OFFSET(info.index);
249 	/*
250 	 * The region memory size may not be power-of-2 aligned.
251 	 * Given that the memory  as a BAR and may not be
252 	 * aligned, roundup to the next power-of-2.
253 	 */
254 	info.size = memregion->bar_size;
255 	info.flags = VFIO_REGION_INFO_FLAG_READ |
256 		     VFIO_REGION_INFO_FLAG_WRITE |
257 		     VFIO_REGION_INFO_FLAG_MMAP;
258 
259 	if (caps.size) {
260 		info.flags |= VFIO_REGION_INFO_FLAG_CAPS;
261 		if (info.argsz < sizeof(info) + caps.size) {
262 			info.argsz = sizeof(info) + caps.size;
263 			info.cap_offset = 0;
264 		} else {
265 			vfio_info_cap_shift(&caps, sizeof(info));
266 			if (copy_to_user((void __user *)arg +
267 					 sizeof(info), caps.buf,
268 					 caps.size)) {
269 				kfree(caps.buf);
270 				return -EFAULT;
271 			}
272 			info.cap_offset = sizeof(info);
273 		}
274 		kfree(caps.buf);
275 	}
276 	return copy_to_user((void __user *)arg, &info, minsz) ?
277 			    -EFAULT : 0;
278 }
279 
280 static long nvgrace_gpu_ioctl(struct vfio_device *core_vdev,
281 			      unsigned int cmd, unsigned long arg)
282 {
283 	switch (cmd) {
284 	case VFIO_DEVICE_GET_REGION_INFO:
285 		return nvgrace_gpu_ioctl_get_region_info(core_vdev, arg);
286 	case VFIO_DEVICE_IOEVENTFD:
287 		return -ENOTTY;
288 	case VFIO_DEVICE_RESET:
289 		nvgrace_gpu_init_fake_bar_emu_regs(core_vdev);
290 		fallthrough;
291 	default:
292 		return vfio_pci_core_ioctl(core_vdev, cmd, arg);
293 	}
294 }
295 
296 static __le64
297 nvgrace_gpu_get_read_value(size_t bar_size, u64 flags, __le64 val64)
298 {
299 	u64 tmp_val;
300 
301 	tmp_val = le64_to_cpu(val64);
302 	tmp_val &= ~(bar_size - 1);
303 	tmp_val |= flags;
304 
305 	return cpu_to_le64(tmp_val);
306 }
307 
308 /*
309  * Both the usable (usemem) and the reserved (resmem) device memory region
310  * are exposed as a 64b fake device BARs in the VM. These fake BARs must
311  * respond to the accesses on their respective PCI config space offsets.
312  *
313  * resmem BAR owns PCI_BASE_ADDRESS_2 & PCI_BASE_ADDRESS_3.
314  * usemem BAR owns PCI_BASE_ADDRESS_4 & PCI_BASE_ADDRESS_5.
315  */
316 static ssize_t
317 nvgrace_gpu_read_config_emu(struct vfio_device *core_vdev,
318 			    char __user *buf, size_t count, loff_t *ppos)
319 {
320 	struct nvgrace_gpu_pci_core_device *nvdev =
321 		container_of(core_vdev, struct nvgrace_gpu_pci_core_device,
322 			     core_device.vdev);
323 	u64 pos = *ppos & VFIO_PCI_OFFSET_MASK;
324 	struct mem_region *memregion = NULL;
325 	__le64 val64;
326 	size_t register_offset;
327 	loff_t copy_offset;
328 	size_t copy_count;
329 	int ret;
330 
331 	ret = vfio_pci_core_read(core_vdev, buf, count, ppos);
332 	if (ret < 0)
333 		return ret;
334 
335 	if (vfio_pci_core_range_intersect_range(pos, count, PCI_BASE_ADDRESS_2,
336 						sizeof(val64),
337 						&copy_offset, &copy_count,
338 						&register_offset))
339 		memregion = nvgrace_gpu_memregion(RESMEM_REGION_INDEX, nvdev);
340 	else if (vfio_pci_core_range_intersect_range(pos, count,
341 						     PCI_BASE_ADDRESS_4,
342 						     sizeof(val64),
343 						     &copy_offset, &copy_count,
344 						     &register_offset))
345 		memregion = nvgrace_gpu_memregion(USEMEM_REGION_INDEX, nvdev);
346 
347 	if (memregion) {
348 		val64 = nvgrace_gpu_get_read_value(memregion->bar_size,
349 						   PCI_BASE_ADDRESS_MEM_TYPE_64 |
350 						   PCI_BASE_ADDRESS_MEM_PREFETCH,
351 						   memregion->bar_val);
352 		if (copy_to_user(buf + copy_offset,
353 				 (void *)&val64 + register_offset, copy_count)) {
354 			/*
355 			 * The position has been incremented in
356 			 * vfio_pci_core_read. Reset the offset back to the
357 			 * starting position.
358 			 */
359 			*ppos -= count;
360 			return -EFAULT;
361 		}
362 	}
363 
364 	return count;
365 }
366 
367 static ssize_t
368 nvgrace_gpu_write_config_emu(struct vfio_device *core_vdev,
369 			     const char __user *buf, size_t count, loff_t *ppos)
370 {
371 	struct nvgrace_gpu_pci_core_device *nvdev =
372 		container_of(core_vdev, struct nvgrace_gpu_pci_core_device,
373 			     core_device.vdev);
374 	u64 pos = *ppos & VFIO_PCI_OFFSET_MASK;
375 	struct mem_region *memregion = NULL;
376 	size_t register_offset;
377 	loff_t copy_offset;
378 	size_t copy_count;
379 
380 	if (vfio_pci_core_range_intersect_range(pos, count, PCI_BASE_ADDRESS_2,
381 						sizeof(u64), &copy_offset,
382 						&copy_count, &register_offset))
383 		memregion = nvgrace_gpu_memregion(RESMEM_REGION_INDEX, nvdev);
384 	else if (vfio_pci_core_range_intersect_range(pos, count, PCI_BASE_ADDRESS_4,
385 						     sizeof(u64), &copy_offset,
386 						     &copy_count, &register_offset))
387 		memregion = nvgrace_gpu_memregion(USEMEM_REGION_INDEX, nvdev);
388 
389 	if (memregion) {
390 		if (copy_from_user((void *)&memregion->bar_val + register_offset,
391 				   buf + copy_offset, copy_count))
392 			return -EFAULT;
393 		*ppos += copy_count;
394 		return copy_count;
395 	}
396 
397 	return vfio_pci_core_write(core_vdev, buf, count, ppos);
398 }
399 
400 /*
401  * Ad hoc map the device memory in the module kernel VA space. Primarily needed
402  * as vfio does not require the userspace driver to only perform accesses through
403  * mmaps of the vfio-pci BAR regions and such accesses should be supported using
404  * vfio_device_ops read/write implementations.
405  *
406  * The usemem region is cacheable memory and hence is memremaped.
407  * The resmem region is non-cached and is mapped using ioremap_wc (NORMAL_NC).
408  */
409 static int
410 nvgrace_gpu_map_device_mem(int index,
411 			   struct nvgrace_gpu_pci_core_device *nvdev)
412 {
413 	struct mem_region *memregion;
414 	int ret = 0;
415 
416 	memregion = nvgrace_gpu_memregion(index, nvdev);
417 	if (!memregion)
418 		return -EINVAL;
419 
420 	mutex_lock(&nvdev->remap_lock);
421 
422 	if (memregion->memaddr)
423 		goto unlock;
424 
425 	if (index == USEMEM_REGION_INDEX)
426 		memregion->memaddr = memremap(memregion->memphys,
427 					      memregion->memlength,
428 					      MEMREMAP_WB);
429 	else
430 		memregion->ioaddr = ioremap_wc(memregion->memphys,
431 					       memregion->memlength);
432 
433 	if (!memregion->memaddr)
434 		ret = -ENOMEM;
435 
436 unlock:
437 	mutex_unlock(&nvdev->remap_lock);
438 
439 	return ret;
440 }
441 
442 /*
443  * Read the data from the device memory (mapped either through ioremap
444  * or memremap) into the user buffer.
445  */
446 static int
447 nvgrace_gpu_map_and_read(struct nvgrace_gpu_pci_core_device *nvdev,
448 			 char __user *buf, size_t mem_count, loff_t *ppos)
449 {
450 	unsigned int index = VFIO_PCI_OFFSET_TO_INDEX(*ppos);
451 	u64 offset = *ppos & VFIO_PCI_OFFSET_MASK;
452 	int ret;
453 
454 	if (!mem_count)
455 		return 0;
456 
457 	/*
458 	 * Handle read on the BAR regions. Map to the target device memory
459 	 * physical address and copy to the request read buffer.
460 	 */
461 	ret = nvgrace_gpu_map_device_mem(index, nvdev);
462 	if (ret)
463 		return ret;
464 
465 	if (index == USEMEM_REGION_INDEX) {
466 		if (copy_to_user(buf,
467 				 (u8 *)nvdev->usemem.memaddr + offset,
468 				 mem_count))
469 			ret = -EFAULT;
470 	} else {
471 		/*
472 		 * The hardware ensures that the system does not crash when
473 		 * the device memory is accessed with the memory enable
474 		 * turned off. It synthesizes ~0 on such read. So there is
475 		 * no need to check or support the disablement/enablement of
476 		 * BAR through PCI_COMMAND config space register. Pass
477 		 * test_mem flag as false.
478 		 */
479 		ret = vfio_pci_core_do_io_rw(&nvdev->core_device, false,
480 					     nvdev->resmem.ioaddr,
481 					     buf, offset, mem_count,
482 					     0, 0, false);
483 	}
484 
485 	return ret;
486 }
487 
488 /*
489  * Read count bytes from the device memory at an offset. The actual device
490  * memory size (available) may not be a power-of-2. So the driver fakes
491  * the size to a power-of-2 (reported) when exposing to a user space driver.
492  *
493  * Reads starting beyond the reported size generate -EINVAL; reads extending
494  * beyond the actual device size is filled with ~0; reads extending beyond
495  * the reported size are truncated.
496  */
497 static ssize_t
498 nvgrace_gpu_read_mem(struct nvgrace_gpu_pci_core_device *nvdev,
499 		     char __user *buf, size_t count, loff_t *ppos)
500 {
501 	u64 offset = *ppos & VFIO_PCI_OFFSET_MASK;
502 	unsigned int index = VFIO_PCI_OFFSET_TO_INDEX(*ppos);
503 	struct mem_region *memregion;
504 	size_t mem_count, i;
505 	u8 val = 0xFF;
506 	int ret;
507 
508 	/* No need to do NULL check as caller does. */
509 	memregion = nvgrace_gpu_memregion(index, nvdev);
510 
511 	if (offset >= memregion->bar_size)
512 		return -EINVAL;
513 
514 	/* Clip short the read request beyond reported BAR size */
515 	count = min(count, memregion->bar_size - (size_t)offset);
516 
517 	/*
518 	 * Determine how many bytes to be actually read from the device memory.
519 	 * Read request beyond the actual device memory size is filled with ~0,
520 	 * while those beyond the actual reported size is skipped.
521 	 */
522 	if (offset >= memregion->memlength)
523 		mem_count = 0;
524 	else
525 		mem_count = min(count, memregion->memlength - (size_t)offset);
526 
527 	ret = nvgrace_gpu_map_and_read(nvdev, buf, mem_count, ppos);
528 	if (ret)
529 		return ret;
530 
531 	/*
532 	 * Only the device memory present on the hardware is mapped, which may
533 	 * not be power-of-2 aligned. A read to an offset beyond the device memory
534 	 * size is filled with ~0.
535 	 */
536 	for (i = mem_count; i < count; i++) {
537 		ret = put_user(val, (unsigned char __user *)(buf + i));
538 		if (ret)
539 			return ret;
540 	}
541 
542 	*ppos += count;
543 	return count;
544 }
545 
546 static ssize_t
547 nvgrace_gpu_read(struct vfio_device *core_vdev,
548 		 char __user *buf, size_t count, loff_t *ppos)
549 {
550 	unsigned int index = VFIO_PCI_OFFSET_TO_INDEX(*ppos);
551 	struct nvgrace_gpu_pci_core_device *nvdev =
552 		container_of(core_vdev, struct nvgrace_gpu_pci_core_device,
553 			     core_device.vdev);
554 
555 	if (nvgrace_gpu_memregion(index, nvdev))
556 		return nvgrace_gpu_read_mem(nvdev, buf, count, ppos);
557 
558 	if (index == VFIO_PCI_CONFIG_REGION_INDEX)
559 		return nvgrace_gpu_read_config_emu(core_vdev, buf, count, ppos);
560 
561 	return vfio_pci_core_read(core_vdev, buf, count, ppos);
562 }
563 
564 /*
565  * Write the data to the device memory (mapped either through ioremap
566  * or memremap) from the user buffer.
567  */
568 static int
569 nvgrace_gpu_map_and_write(struct nvgrace_gpu_pci_core_device *nvdev,
570 			  const char __user *buf, size_t mem_count,
571 			  loff_t *ppos)
572 {
573 	unsigned int index = VFIO_PCI_OFFSET_TO_INDEX(*ppos);
574 	loff_t pos = *ppos & VFIO_PCI_OFFSET_MASK;
575 	int ret;
576 
577 	if (!mem_count)
578 		return 0;
579 
580 	ret = nvgrace_gpu_map_device_mem(index, nvdev);
581 	if (ret)
582 		return ret;
583 
584 	if (index == USEMEM_REGION_INDEX) {
585 		if (copy_from_user((u8 *)nvdev->usemem.memaddr + pos,
586 				   buf, mem_count))
587 			return -EFAULT;
588 	} else {
589 		/*
590 		 * The hardware ensures that the system does not crash when
591 		 * the device memory is accessed with the memory enable
592 		 * turned off. It drops such writes. So there is no need to
593 		 * check or support the disablement/enablement of BAR
594 		 * through PCI_COMMAND config space register. Pass test_mem
595 		 * flag as false.
596 		 */
597 		ret = vfio_pci_core_do_io_rw(&nvdev->core_device, false,
598 					     nvdev->resmem.ioaddr,
599 					     (char __user *)buf, pos, mem_count,
600 					     0, 0, true);
601 	}
602 
603 	return ret;
604 }
605 
606 /*
607  * Write count bytes to the device memory at a given offset. The actual device
608  * memory size (available) may not be a power-of-2. So the driver fakes the
609  * size to a power-of-2 (reported) when exposing to a user space driver.
610  *
611  * Writes extending beyond the reported size are truncated; writes starting
612  * beyond the reported size generate -EINVAL.
613  */
614 static ssize_t
615 nvgrace_gpu_write_mem(struct nvgrace_gpu_pci_core_device *nvdev,
616 		      size_t count, loff_t *ppos, const char __user *buf)
617 {
618 	unsigned int index = VFIO_PCI_OFFSET_TO_INDEX(*ppos);
619 	u64 offset = *ppos & VFIO_PCI_OFFSET_MASK;
620 	struct mem_region *memregion;
621 	size_t mem_count;
622 	int ret = 0;
623 
624 	/* No need to do NULL check as caller does. */
625 	memregion = nvgrace_gpu_memregion(index, nvdev);
626 
627 	if (offset >= memregion->bar_size)
628 		return -EINVAL;
629 
630 	/* Clip short the write request beyond reported BAR size */
631 	count = min(count, memregion->bar_size - (size_t)offset);
632 
633 	/*
634 	 * Determine how many bytes to be actually written to the device memory.
635 	 * Do not write to the offset beyond available size.
636 	 */
637 	if (offset >= memregion->memlength)
638 		goto exitfn;
639 
640 	/*
641 	 * Only the device memory present on the hardware is mapped, which may
642 	 * not be power-of-2 aligned. Drop access outside the available device
643 	 * memory on the hardware.
644 	 */
645 	mem_count = min(count, memregion->memlength - (size_t)offset);
646 
647 	ret = nvgrace_gpu_map_and_write(nvdev, buf, mem_count, ppos);
648 	if (ret)
649 		return ret;
650 
651 exitfn:
652 	*ppos += count;
653 	return count;
654 }
655 
656 static ssize_t
657 nvgrace_gpu_write(struct vfio_device *core_vdev,
658 		  const char __user *buf, size_t count, loff_t *ppos)
659 {
660 	struct nvgrace_gpu_pci_core_device *nvdev =
661 		container_of(core_vdev, struct nvgrace_gpu_pci_core_device,
662 			     core_device.vdev);
663 	unsigned int index = VFIO_PCI_OFFSET_TO_INDEX(*ppos);
664 
665 	if (nvgrace_gpu_memregion(index, nvdev))
666 		return nvgrace_gpu_write_mem(nvdev, count, ppos, buf);
667 
668 	if (index == VFIO_PCI_CONFIG_REGION_INDEX)
669 		return nvgrace_gpu_write_config_emu(core_vdev, buf, count, ppos);
670 
671 	return vfio_pci_core_write(core_vdev, buf, count, ppos);
672 }
673 
674 static const struct vfio_device_ops nvgrace_gpu_pci_ops = {
675 	.name		= "nvgrace-gpu-vfio-pci",
676 	.init		= vfio_pci_core_init_dev,
677 	.release	= vfio_pci_core_release_dev,
678 	.open_device	= nvgrace_gpu_open_device,
679 	.close_device	= nvgrace_gpu_close_device,
680 	.ioctl		= nvgrace_gpu_ioctl,
681 	.device_feature	= vfio_pci_core_ioctl_feature,
682 	.read		= nvgrace_gpu_read,
683 	.write		= nvgrace_gpu_write,
684 	.mmap		= nvgrace_gpu_mmap,
685 	.request	= vfio_pci_core_request,
686 	.match		= vfio_pci_core_match,
687 	.bind_iommufd	= vfio_iommufd_physical_bind,
688 	.unbind_iommufd	= vfio_iommufd_physical_unbind,
689 	.attach_ioas	= vfio_iommufd_physical_attach_ioas,
690 	.detach_ioas	= vfio_iommufd_physical_detach_ioas,
691 };
692 
693 static const struct vfio_device_ops nvgrace_gpu_pci_core_ops = {
694 	.name		= "nvgrace-gpu-vfio-pci-core",
695 	.init		= vfio_pci_core_init_dev,
696 	.release	= vfio_pci_core_release_dev,
697 	.open_device	= nvgrace_gpu_open_device,
698 	.close_device	= vfio_pci_core_close_device,
699 	.ioctl		= vfio_pci_core_ioctl,
700 	.device_feature	= vfio_pci_core_ioctl_feature,
701 	.read		= vfio_pci_core_read,
702 	.write		= vfio_pci_core_write,
703 	.mmap		= vfio_pci_core_mmap,
704 	.request	= vfio_pci_core_request,
705 	.match		= vfio_pci_core_match,
706 	.bind_iommufd	= vfio_iommufd_physical_bind,
707 	.unbind_iommufd	= vfio_iommufd_physical_unbind,
708 	.attach_ioas	= vfio_iommufd_physical_attach_ioas,
709 	.detach_ioas	= vfio_iommufd_physical_detach_ioas,
710 };
711 
712 static int
713 nvgrace_gpu_fetch_memory_property(struct pci_dev *pdev,
714 				  u64 *pmemphys, u64 *pmemlength)
715 {
716 	int ret;
717 
718 	/*
719 	 * The memory information is present in the system ACPI tables as DSD
720 	 * properties nvidia,gpu-mem-base-pa and nvidia,gpu-mem-size.
721 	 */
722 	ret = device_property_read_u64(&pdev->dev, "nvidia,gpu-mem-base-pa",
723 				       pmemphys);
724 	if (ret)
725 		return ret;
726 
727 	if (*pmemphys > type_max(phys_addr_t))
728 		return -EOVERFLOW;
729 
730 	ret = device_property_read_u64(&pdev->dev, "nvidia,gpu-mem-size",
731 				       pmemlength);
732 	if (ret)
733 		return ret;
734 
735 	if (*pmemlength > type_max(size_t))
736 		return -EOVERFLOW;
737 
738 	/*
739 	 * If the C2C link is not up due to an error, the coherent device
740 	 * memory size is returned as 0. Fail in such case.
741 	 */
742 	if (*pmemlength == 0)
743 		return -ENOMEM;
744 
745 	return ret;
746 }
747 
748 static int
749 nvgrace_gpu_init_nvdev_struct(struct pci_dev *pdev,
750 			      struct nvgrace_gpu_pci_core_device *nvdev,
751 			      u64 memphys, u64 memlength)
752 {
753 	int ret = 0;
754 
755 	/*
756 	 * The VM GPU device driver needs a non-cacheable region to support
757 	 * the MIG feature. Since the device memory is mapped as NORMAL cached,
758 	 * carve out a region from the end with a different NORMAL_NC
759 	 * property (called as reserved memory and represented as resmem). This
760 	 * region then is exposed as a 64b BAR (region 2 and 3) to the VM, while
761 	 * exposing the rest (termed as usable memory and represented using usemem)
762 	 * as cacheable 64b BAR (region 4 and 5).
763 	 *
764 	 *               devmem (memlength)
765 	 * |-------------------------------------------------|
766 	 * |                                           |
767 	 * usemem.memphys                              resmem.memphys
768 	 */
769 	nvdev->usemem.memphys = memphys;
770 
771 	/*
772 	 * The device memory exposed to the VM is added to the kernel by the
773 	 * VM driver module in chunks of memory block size. Only the usable
774 	 * memory (usemem) is added to the kernel for usage by the VM
775 	 * workloads. Make the usable memory size memblock aligned.
776 	 */
777 	if (check_sub_overflow(memlength, RESMEM_SIZE,
778 			       &nvdev->usemem.memlength)) {
779 		ret = -EOVERFLOW;
780 		goto done;
781 	}
782 
783 	/*
784 	 * The USEMEM part of the device memory has to be MEMBLK_SIZE
785 	 * aligned. This is a hardwired ABI value between the GPU FW and
786 	 * VFIO driver. The VM device driver is also aware of it and make
787 	 * use of the value for its calculation to determine USEMEM size.
788 	 */
789 	nvdev->usemem.memlength = round_down(nvdev->usemem.memlength,
790 					     MEMBLK_SIZE);
791 	if (nvdev->usemem.memlength == 0) {
792 		ret = -EINVAL;
793 		goto done;
794 	}
795 
796 	if ((check_add_overflow(nvdev->usemem.memphys,
797 				nvdev->usemem.memlength,
798 				&nvdev->resmem.memphys)) ||
799 	    (check_sub_overflow(memlength, nvdev->usemem.memlength,
800 				&nvdev->resmem.memlength))) {
801 		ret = -EOVERFLOW;
802 		goto done;
803 	}
804 
805 	/*
806 	 * The memory regions are exposed as BARs. Calculate and save
807 	 * the BAR size for them.
808 	 */
809 	nvdev->usemem.bar_size = roundup_pow_of_two(nvdev->usemem.memlength);
810 	nvdev->resmem.bar_size = roundup_pow_of_two(nvdev->resmem.memlength);
811 done:
812 	return ret;
813 }
814 
815 static int nvgrace_gpu_probe(struct pci_dev *pdev,
816 			     const struct pci_device_id *id)
817 {
818 	const struct vfio_device_ops *ops = &nvgrace_gpu_pci_core_ops;
819 	struct nvgrace_gpu_pci_core_device *nvdev;
820 	u64 memphys, memlength;
821 	int ret;
822 
823 	ret = nvgrace_gpu_fetch_memory_property(pdev, &memphys, &memlength);
824 	if (!ret)
825 		ops = &nvgrace_gpu_pci_ops;
826 
827 	nvdev = vfio_alloc_device(nvgrace_gpu_pci_core_device, core_device.vdev,
828 				  &pdev->dev, ops);
829 	if (IS_ERR(nvdev))
830 		return PTR_ERR(nvdev);
831 
832 	dev_set_drvdata(&pdev->dev, &nvdev->core_device);
833 
834 	if (ops == &nvgrace_gpu_pci_ops) {
835 		/*
836 		 * Device memory properties are identified in the host ACPI
837 		 * table. Set the nvgrace_gpu_pci_core_device structure.
838 		 */
839 		ret = nvgrace_gpu_init_nvdev_struct(pdev, nvdev,
840 						    memphys, memlength);
841 		if (ret)
842 			goto out_put_vdev;
843 	}
844 
845 	ret = vfio_pci_core_register_device(&nvdev->core_device);
846 	if (ret)
847 		goto out_put_vdev;
848 
849 	return ret;
850 
851 out_put_vdev:
852 	vfio_put_device(&nvdev->core_device.vdev);
853 	return ret;
854 }
855 
856 static void nvgrace_gpu_remove(struct pci_dev *pdev)
857 {
858 	struct vfio_pci_core_device *core_device = dev_get_drvdata(&pdev->dev);
859 
860 	vfio_pci_core_unregister_device(core_device);
861 	vfio_put_device(&core_device->vdev);
862 }
863 
864 static const struct pci_device_id nvgrace_gpu_vfio_pci_table[] = {
865 	/* GH200 120GB */
866 	{ PCI_DRIVER_OVERRIDE_DEVICE_VFIO(PCI_VENDOR_ID_NVIDIA, 0x2342) },
867 	/* GH200 480GB */
868 	{ PCI_DRIVER_OVERRIDE_DEVICE_VFIO(PCI_VENDOR_ID_NVIDIA, 0x2345) },
869 	{}
870 };
871 
872 MODULE_DEVICE_TABLE(pci, nvgrace_gpu_vfio_pci_table);
873 
874 static struct pci_driver nvgrace_gpu_vfio_pci_driver = {
875 	.name = KBUILD_MODNAME,
876 	.id_table = nvgrace_gpu_vfio_pci_table,
877 	.probe = nvgrace_gpu_probe,
878 	.remove = nvgrace_gpu_remove,
879 	.err_handler = &vfio_pci_core_err_handlers,
880 	.driver_managed_dma = true,
881 };
882 
883 module_pci_driver(nvgrace_gpu_vfio_pci_driver);
884 
885 MODULE_LICENSE("GPL");
886 MODULE_AUTHOR("Ankit Agrawal <ankita@nvidia.com>");
887 MODULE_AUTHOR("Aniket Agashe <aniketa@nvidia.com>");
888 MODULE_DESCRIPTION("VFIO NVGRACE GPU PF - User Level driver for NVIDIA devices with CPU coherently accessible device memory");
889