lib/iomap_copy.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright 2006 PathScale, Inc.  All Rights Reserved.
   4  */
   5
   6 #include <linux/export.h>
   7 #include <linux/io.h>
   8
   9 /**
  10  * __iowrite32_copy - copy data to MMIO space, in 32-bit units
  11  * @to: destination, in MMIO space (must be 32-bit aligned)
  12  * @from: source (must be 32-bit aligned)
  13  * @count: number of 32-bit quantities to copy
  14  *
  15  * Copy data from kernel space to MMIO space, in units of 32 bits at a
  16  * time.  Order of access is not guaranteed, nor is a memory barrier
  17  * performed afterwards.
  18  */
  19 #ifndef __iowrite32_copy
  20 void __iowrite32_copy(void __iomem *to, const void *from, size_t count)
  21 {
  22         u32 __iomem *dst = to;
  23         const u32 *src = from;
  24         const u32 *end = src + count;
  25
  26         while (src < end)
  27                 __raw_writel(*src++, dst++);
  28 }
  29 EXPORT_SYMBOL_GPL(__iowrite32_copy);
  30 #endif
  31
  32 /**
  33  * __ioread32_copy - copy data from MMIO space, in 32-bit units
  34  * @to: destination (must be 32-bit aligned)
  35  * @from: source, in MMIO space (must be 32-bit aligned)
  36  * @count: number of 32-bit quantities to copy
  37  *
  38  * Copy data from MMIO space to kernel space, in units of 32 bits at a
  39  * time.  Order of access is not guaranteed, nor is a memory barrier
  40  * performed afterwards.
  41  */
  42 void __ioread32_copy(void *to, const void __iomem *from, size_t count)
  43 {
  44         u32 *dst = to;
  45         const u32 __iomem *src = from;
  46         const u32 __iomem *end = src + count;
  47
  48         while (src < end)
  49                 *dst++ = __raw_readl(src++);
  50 }
  51 EXPORT_SYMBOL_GPL(__ioread32_copy);
  52
  53 /**
  54  * __iowrite64_copy - copy data to MMIO space, in 64-bit or 32-bit units
  55  * @to: destination, in MMIO space (must be 64-bit aligned)
  56  * @from: source (must be 64-bit aligned)
  57  * @count: number of 64-bit quantities to copy
  58  *
  59  * Copy data from kernel space to MMIO space, in units of 32 or 64 bits at a
  60  * time.  Order of access is not guaranteed, nor is a memory barrier
  61  * performed afterwards.
  62  */
  63 #ifndef __iowrite64_copy
  64 void __iowrite64_copy(void __iomem *to, const void *from, size_t count)
  65 {
  66 #ifdef CONFIG_64BIT
  67         u64 __iomem *dst = to;
  68         const u64 *src = from;
  69         const u64 *end = src + count;
  70
  71         while (src < end)
  72                 __raw_writeq(*src++, dst++);
  73 #else
  74         __iowrite32_copy(to, from, count * 2);
  75 #endif
  76 }
  77 EXPORT_SYMBOL_GPL(__iowrite64_copy);
  78 #endif