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 void __attribute__((weak)) __iowrite32_copy(void __iomem *to,
  20                                             const void *from,
  21                                             size_t count)
  22 {
  23         u32 __iomem *dst = to;
  24         const u32 *src = from;
  25         const u32 *end = src + count;
  26
  27         while (src < end)
  28                 __raw_writel(*src++, dst++);
  29 }
  30 EXPORT_SYMBOL_GPL(__iowrite32_copy);
  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 void __attribute__((weak)) __iowrite64_copy(void __iomem *to,
  64                                             const void *from,
  65                                             size_t count)
  66 {
  67 #ifdef CONFIG_64BIT
  68         u64 __iomem *dst = to;
  69         const u64 *src = from;
  70         const u64 *end = src + count;
  71
  72         while (src < end)
  73                 __raw_writeq(*src++, dst++);
  74 #else
  75         __iowrite32_copy(to, from, count * 2);
  76 #endif
  77 }
  78
  79 EXPORT_SYMBOL_GPL(__iowrite64_copy);