cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

iomap_copy.c (2226B)

      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);