Line data    Source code

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