LXR linux/lib/iomap

   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 */
  19void __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}
  30EXPORT_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 */
  42void __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}
  51EXPORT_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 */
  63void __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
  79EXPORT_SYMBOL_GPL(__iowrite64_copy);
  80