Branch data     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                 :            :         u32 __iomem *dst = to;
      24                 :            :         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                 :            :         u32 *dst = to;
      45                 :            :         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                 :            :         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                 :          0 :         __iowrite32_copy(to, from, count * 2);
      76                 :            : #endif
      77                 :          0 : }
      78                 :            : 
      79                 :            : EXPORT_SYMBOL_GPL(__iowrite64_copy);