Merge tag 'dma-mapping-6.19-2025-12-05' of git://git.kernel.org/pub/scm/linux/kernel...

Pull dma-mapping updates from Marek Szyprowski:

 - More DMA mapping API refactoring to physical addresses as the primary
   interface instead of page+offset parameters.

   This time dma_map_ops callbacks are converted to physical addresses,
   what in turn results also in some simplification of architecture
   specific code (Leon Romanovsky and Jason Gunthorpe)

 - Clarify that dma_map_benchmark is not a kernel self-test, but
   standalone tool (Qinxin Xia)

* tag 'dma-mapping-6.19-2025-12-05' of git://git.kernel.org/pub/scm/linux/kernel/git/mszyprowski/linux:
  dma-mapping: remove unused map_page callback
  xen: swiotlb: Convert mapping routine to rely on physical address
  x86: Use physical address for DMA mapping
  sparc: Use physical address DMA mapping
  powerpc: Convert to physical address DMA mapping
  parisc: Convert DMA map_page to map_phys interface
  MIPS/jazzdma: Provide physical address directly
  alpha: Convert mapping routine to rely on physical address
  dma-mapping: remove unused mapping resource callbacks
  xen: swiotlb: Switch to physical address mapping callbacks
  ARM: dma-mapping: Switch to physical address mapping callbacks
  ARM: dma-mapping: Reduce struct page exposure in arch_sync_dma*()
  dma-mapping: convert dummy ops to physical address mapping
  dma-mapping: prepare dma_map_ops to conversion to physical address
  tools/dma: move dma_map_benchmark from selftests to tools/dma

diff --cc arch/powerpc/kernel/iommu.c
Simple merge

diff --cc arch/x86/kernel/amd_gart_64.c
Simple merge

diff --cc tools/dma/dma_map_benchmark.c
index 0000000000000000000000000000000000000000,5474a450863c33456ec2b74ca35221e234c4f921..dd0ed528e6dfc9f90c0f1be594098917ea03206b
mode 000000,100644..100644
--- /dev/null
--- 2/tools/dma/dma_map_benchmark.c
+++ b/tools/dma/dma_map_benchmark.c
@@@ -1,0 -1,127 +1,127 @@@
 -                      threads, seconds, node, dir[directions], granule);
+ // SPDX-License-Identifier: GPL-2.0-only
+ /*
+  * Copyright (C) 2020 HiSilicon Limited.
+  */
+ 
+ #include <fcntl.h>
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <string.h>
+ #include <unistd.h>
+ #include <sys/ioctl.h>
+ #include <sys/mman.h>
+ #include <linux/map_benchmark.h>
+ 
+ #define NSEC_PER_MSEC 1000000L
+ 
+ static char *directions[] = {
+       "BIDIRECTIONAL",
+       "TO_DEVICE",
+       "FROM_DEVICE",
+ };
+ 
+ int main(int argc, char **argv)
+ {
+       struct map_benchmark map;
+       int fd, opt;
+       /* default single thread, run 20 seconds on NUMA_NO_NODE */
+       int threads = 1, seconds = 20, node = -1;
+       /* default dma mask 32bit, bidirectional DMA */
+       int bits = 32, xdelay = 0, dir = DMA_MAP_BIDIRECTIONAL;
+       /* default granule 1 PAGESIZE */
+       int granule = 1;
+ 
+       int cmd = DMA_MAP_BENCHMARK;
+ 
+       while ((opt = getopt(argc, argv, "t:s:n:b:d:x:g:")) != -1) {
+               switch (opt) {
+               case 't':
+                       threads = atoi(optarg);
+                       break;
+               case 's':
+                       seconds = atoi(optarg);
+                       break;
+               case 'n':
+                       node = atoi(optarg);
+                       break;
+               case 'b':
+                       bits = atoi(optarg);
+                       break;
+               case 'd':
+                       dir = atoi(optarg);
+                       break;
+               case 'x':
+                       xdelay = atoi(optarg);
+                       break;
+               case 'g':
+                       granule = atoi(optarg);
+                       break;
+               default:
+                       return -1;
+               }
+       }
+ 
+       if (threads <= 0 || threads > DMA_MAP_MAX_THREADS) {
+               fprintf(stderr, "invalid number of threads, must be in 1-%d\n",
+                       DMA_MAP_MAX_THREADS);
+               exit(1);
+       }
+ 
+       if (seconds <= 0 || seconds > DMA_MAP_MAX_SECONDS) {
+               fprintf(stderr, "invalid number of seconds, must be in 1-%d\n",
+                       DMA_MAP_MAX_SECONDS);
+               exit(1);
+       }
+ 
+       if (xdelay < 0 || xdelay > DMA_MAP_MAX_TRANS_DELAY) {
+               fprintf(stderr, "invalid transmit delay, must be in 0-%ld\n",
+                       DMA_MAP_MAX_TRANS_DELAY);
+               exit(1);
+       }
+ 
+       /* suppose the mininum DMA zone is 1MB in the world */
+       if (bits < 20 || bits > 64) {
+               fprintf(stderr, "invalid dma mask bit, must be in 20-64\n");
+               exit(1);
+       }
+ 
+       if (dir != DMA_MAP_BIDIRECTIONAL && dir != DMA_MAP_TO_DEVICE &&
+                       dir != DMA_MAP_FROM_DEVICE) {
+               fprintf(stderr, "invalid dma direction\n");
+               exit(1);
+       }
+ 
+       if (granule < 1 || granule > 1024) {
+               fprintf(stderr, "invalid granule size\n");
+               exit(1);
+       }
+ 
+       fd = open("/sys/kernel/debug/dma_map_benchmark", O_RDWR);
+       if (fd == -1) {
+               perror("open");
+               exit(1);
+       }
+ 
+       memset(&map, 0, sizeof(map));
+       map.seconds = seconds;
+       map.threads = threads;
+       map.node = node;
+       map.dma_bits = bits;
+       map.dma_dir = dir;
+       map.dma_trans_ns = xdelay;
+       map.granule = granule;
+ 
+       if (ioctl(fd, cmd, &map)) {
+               perror("ioctl");
+               exit(1);
+       }
+ 
+       printf("dma mapping benchmark: threads:%d seconds:%d node:%d dir:%s granule: %d\n",
++                      threads, seconds, node, directions[dir], granule);
+       printf("average map latency(us):%.1f standard deviation:%.1f\n",
+                       map.avg_map_100ns/10.0, map.map_stddev/10.0);
+       printf("average unmap latency(us):%.1f standard deviation:%.1f\n",
+                       map.avg_unmap_100ns/10.0, map.unmap_stddev/10.0);
+ 
+       return 0;
+ }