1b4d0d230SThomas Gleixner /* SPDX-License-Identifier: GPL-2.0-or-later */ 2739d875dSDavid Howells /* Generic I/O port emulation. 33f7e212dSArnd Bergmann * 43f7e212dSArnd Bergmann * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved. 53f7e212dSArnd Bergmann * Written by David Howells (dhowells@redhat.com) 63f7e212dSArnd Bergmann */ 73f7e212dSArnd Bergmann #ifndef __ASM_GENERIC_IO_H 83f7e212dSArnd Bergmann #define __ASM_GENERIC_IO_H 93f7e212dSArnd Bergmann 103f7e212dSArnd Bergmann #include <asm/page.h> /* I/O is all done through memory accesses */ 119216efafSThierry Reding #include <linux/string.h> /* for memset() and memcpy() */ 123f7e212dSArnd Bergmann #include <linux/types.h> 1321003197SSai Prakash Ranjan #include <linux/instruction_pointer.h> 143f7e212dSArnd Bergmann 153f7e212dSArnd Bergmann #ifdef CONFIG_GENERIC_IOMAP 163f7e212dSArnd Bergmann #include <asm-generic/iomap.h> 173f7e212dSArnd Bergmann #endif 183f7e212dSArnd Bergmann 1960ca1e5aSWill Deacon #include <asm/mmiowb.h> 2066eab4dfSMichael S. Tsirkin #include <asm-generic/pci_iomap.h> 2166eab4dfSMichael S. Tsirkin 2264e2c673SSinan Kaya #ifndef __io_br 2364e2c673SSinan Kaya #define __io_br() barrier() 2464e2c673SSinan Kaya #endif 2564e2c673SSinan Kaya 2664e2c673SSinan Kaya /* prevent prefetching of coherent DMA data ahead of a dma-complete */ 2764e2c673SSinan Kaya #ifndef __io_ar 2864e2c673SSinan Kaya #ifdef rmb 29abbbbc83SWill Deacon #define __io_ar(v) rmb() 3064e2c673SSinan Kaya #else 31abbbbc83SWill Deacon #define __io_ar(v) barrier() 3264e2c673SSinan Kaya #endif 3364e2c673SSinan Kaya #endif 3464e2c673SSinan Kaya 3564e2c673SSinan Kaya /* flush writes to coherent DMA data before possibly triggering a DMA read */ 3664e2c673SSinan Kaya #ifndef __io_bw 3764e2c673SSinan Kaya #ifdef wmb 3864e2c673SSinan Kaya #define __io_bw() wmb() 3964e2c673SSinan Kaya #else 4064e2c673SSinan Kaya #define __io_bw() barrier() 4164e2c673SSinan Kaya #endif 4264e2c673SSinan Kaya #endif 4364e2c673SSinan Kaya 4464e2c673SSinan Kaya /* serialize device access against a spin_unlock, usually handled there. */ 4564e2c673SSinan Kaya #ifndef __io_aw 4660ca1e5aSWill Deacon #define __io_aw() mmiowb_set_pending() 4764e2c673SSinan Kaya #endif 4864e2c673SSinan Kaya 4964e2c673SSinan Kaya #ifndef __io_pbw 5064e2c673SSinan Kaya #define __io_pbw() __io_bw() 5164e2c673SSinan Kaya #endif 5264e2c673SSinan Kaya 5364e2c673SSinan Kaya #ifndef __io_paw 5464e2c673SSinan Kaya #define __io_paw() __io_aw() 5564e2c673SSinan Kaya #endif 5664e2c673SSinan Kaya 5764e2c673SSinan Kaya #ifndef __io_pbr 5864e2c673SSinan Kaya #define __io_pbr() __io_br() 5964e2c673SSinan Kaya #endif 6064e2c673SSinan Kaya 6164e2c673SSinan Kaya #ifndef __io_par 62abbbbc83SWill Deacon #define __io_par(v) __io_ar(v) 6364e2c673SSinan Kaya #endif 6464e2c673SSinan Kaya 6521003197SSai Prakash Ranjan /* 6621003197SSai Prakash Ranjan * "__DISABLE_TRACE_MMIO__" flag can be used to disable MMIO tracing for 6721003197SSai Prakash Ranjan * specific kernel drivers in case of excessive/unwanted logging. 6821003197SSai Prakash Ranjan * 6921003197SSai Prakash Ranjan * Usage: Add a #define flag at the beginning of the driver file. 7021003197SSai Prakash Ranjan * Ex: #define __DISABLE_TRACE_MMIO__ 7121003197SSai Prakash Ranjan * #include <...> 7221003197SSai Prakash Ranjan * ... 7321003197SSai Prakash Ranjan */ 7421003197SSai Prakash Ranjan #if IS_ENABLED(CONFIG_TRACE_MMIO_ACCESS) && !(defined(__DISABLE_TRACE_MMIO__)) 7521003197SSai Prakash Ranjan #include <linux/tracepoint-defs.h> 7621003197SSai Prakash Ranjan 7721003197SSai Prakash Ranjan DECLARE_TRACEPOINT(rwmmio_write); 7821003197SSai Prakash Ranjan DECLARE_TRACEPOINT(rwmmio_post_write); 7921003197SSai Prakash Ranjan DECLARE_TRACEPOINT(rwmmio_read); 8021003197SSai Prakash Ranjan DECLARE_TRACEPOINT(rwmmio_post_read); 8121003197SSai Prakash Ranjan 8221003197SSai Prakash Ranjan void log_write_mmio(u64 val, u8 width, volatile void __iomem *addr, 835e5ff73cSSai Prakash Ranjan unsigned long caller_addr, unsigned long caller_addr0); 8421003197SSai Prakash Ranjan void log_post_write_mmio(u64 val, u8 width, volatile void __iomem *addr, 855e5ff73cSSai Prakash Ranjan unsigned long caller_addr, unsigned long caller_addr0); 8621003197SSai Prakash Ranjan void log_read_mmio(u8 width, const volatile void __iomem *addr, 875e5ff73cSSai Prakash Ranjan unsigned long caller_addr, unsigned long caller_addr0); 8821003197SSai Prakash Ranjan void log_post_read_mmio(u64 val, u8 width, const volatile void __iomem *addr, 895e5ff73cSSai Prakash Ranjan unsigned long caller_addr, unsigned long caller_addr0); 9021003197SSai Prakash Ranjan 9121003197SSai Prakash Ranjan #else 9221003197SSai Prakash Ranjan 9321003197SSai Prakash Ranjan static inline void log_write_mmio(u64 val, u8 width, volatile void __iomem *addr, 945e5ff73cSSai Prakash Ranjan unsigned long caller_addr, unsigned long caller_addr0) {} 9521003197SSai Prakash Ranjan static inline void log_post_write_mmio(u64 val, u8 width, volatile void __iomem *addr, 965e5ff73cSSai Prakash Ranjan unsigned long caller_addr, unsigned long caller_addr0) {} 9721003197SSai Prakash Ranjan static inline void log_read_mmio(u8 width, const volatile void __iomem *addr, 985e5ff73cSSai Prakash Ranjan unsigned long caller_addr, unsigned long caller_addr0) {} 9921003197SSai Prakash Ranjan static inline void log_post_read_mmio(u64 val, u8 width, const volatile void __iomem *addr, 1005e5ff73cSSai Prakash Ranjan unsigned long caller_addr, unsigned long caller_addr0) {} 10121003197SSai Prakash Ranjan 10221003197SSai Prakash Ranjan #endif /* CONFIG_TRACE_MMIO_ACCESS */ 10364e2c673SSinan Kaya 1043f7e212dSArnd Bergmann /* 1059216efafSThierry Reding * __raw_{read,write}{b,w,l,q}() access memory in native endianness. 1069216efafSThierry Reding * 1079216efafSThierry Reding * On some architectures memory mapped IO needs to be accessed differently. 1089216efafSThierry Reding * On the simple architectures, we just read/write the memory location 1099216efafSThierry Reding * directly. 1103f7e212dSArnd Bergmann */ 1119216efafSThierry Reding 11235dbc0e0SMike Frysinger #ifndef __raw_readb 1139216efafSThierry Reding #define __raw_readb __raw_readb 1143f7e212dSArnd Bergmann static inline u8 __raw_readb(const volatile void __iomem *addr) 1153f7e212dSArnd Bergmann { 1163f7e212dSArnd Bergmann return *(const volatile u8 __force *)addr; 1173f7e212dSArnd Bergmann } 11835dbc0e0SMike Frysinger #endif 1193f7e212dSArnd Bergmann 12035dbc0e0SMike Frysinger #ifndef __raw_readw 1219216efafSThierry Reding #define __raw_readw __raw_readw 1223f7e212dSArnd Bergmann static inline u16 __raw_readw(const volatile void __iomem *addr) 1233f7e212dSArnd Bergmann { 1243f7e212dSArnd Bergmann return *(const volatile u16 __force *)addr; 1253f7e212dSArnd Bergmann } 12635dbc0e0SMike Frysinger #endif 1273f7e212dSArnd Bergmann 12835dbc0e0SMike Frysinger #ifndef __raw_readl 1299216efafSThierry Reding #define __raw_readl __raw_readl 1303f7e212dSArnd Bergmann static inline u32 __raw_readl(const volatile void __iomem *addr) 1313f7e212dSArnd Bergmann { 1323f7e212dSArnd Bergmann return *(const volatile u32 __force *)addr; 1333f7e212dSArnd Bergmann } 13435dbc0e0SMike Frysinger #endif 1353f7e212dSArnd Bergmann 1363f7e212dSArnd Bergmann #ifdef CONFIG_64BIT 137cd248341SJan Glauber #ifndef __raw_readq 1389216efafSThierry Reding #define __raw_readq __raw_readq 1393f7e212dSArnd Bergmann static inline u64 __raw_readq(const volatile void __iomem *addr) 1403f7e212dSArnd Bergmann { 1413f7e212dSArnd Bergmann return *(const volatile u64 __force *)addr; 1423f7e212dSArnd Bergmann } 143cd248341SJan Glauber #endif 1449216efafSThierry Reding #endif /* CONFIG_64BIT */ 145cd248341SJan Glauber 1469216efafSThierry Reding #ifndef __raw_writeb 1479216efafSThierry Reding #define __raw_writeb __raw_writeb 1489216efafSThierry Reding static inline void __raw_writeb(u8 value, volatile void __iomem *addr) 1499216efafSThierry Reding { 1509216efafSThierry Reding *(volatile u8 __force *)addr = value; 1519216efafSThierry Reding } 1529216efafSThierry Reding #endif 1539216efafSThierry Reding 1549216efafSThierry Reding #ifndef __raw_writew 1559216efafSThierry Reding #define __raw_writew __raw_writew 1569216efafSThierry Reding static inline void __raw_writew(u16 value, volatile void __iomem *addr) 1579216efafSThierry Reding { 1589216efafSThierry Reding *(volatile u16 __force *)addr = value; 1599216efafSThierry Reding } 1609216efafSThierry Reding #endif 1619216efafSThierry Reding 1629216efafSThierry Reding #ifndef __raw_writel 1639216efafSThierry Reding #define __raw_writel __raw_writel 1649216efafSThierry Reding static inline void __raw_writel(u32 value, volatile void __iomem *addr) 1659216efafSThierry Reding { 1669216efafSThierry Reding *(volatile u32 __force *)addr = value; 1679216efafSThierry Reding } 1689216efafSThierry Reding #endif 1699216efafSThierry Reding 1709216efafSThierry Reding #ifdef CONFIG_64BIT 1719216efafSThierry Reding #ifndef __raw_writeq 1729216efafSThierry Reding #define __raw_writeq __raw_writeq 1739216efafSThierry Reding static inline void __raw_writeq(u64 value, volatile void __iomem *addr) 1749216efafSThierry Reding { 1759216efafSThierry Reding *(volatile u64 __force *)addr = value; 1769216efafSThierry Reding } 1779216efafSThierry Reding #endif 1789216efafSThierry Reding #endif /* CONFIG_64BIT */ 1799216efafSThierry Reding 1809216efafSThierry Reding /* 1819216efafSThierry Reding * {read,write}{b,w,l,q}() access little endian memory and return result in 1829216efafSThierry Reding * native endianness. 1839216efafSThierry Reding */ 1849216efafSThierry Reding 1859216efafSThierry Reding #ifndef readb 1869216efafSThierry Reding #define readb readb 1879216efafSThierry Reding static inline u8 readb(const volatile void __iomem *addr) 1889216efafSThierry Reding { 189032d59e1SSinan Kaya u8 val; 190032d59e1SSinan Kaya 1915e5ff73cSSai Prakash Ranjan log_read_mmio(8, addr, _THIS_IP_, _RET_IP_); 192032d59e1SSinan Kaya __io_br(); 193032d59e1SSinan Kaya val = __raw_readb(addr); 194abbbbc83SWill Deacon __io_ar(val); 1955e5ff73cSSai Prakash Ranjan log_post_read_mmio(val, 8, addr, _THIS_IP_, _RET_IP_); 196032d59e1SSinan Kaya return val; 1979216efafSThierry Reding } 1989216efafSThierry Reding #endif 1999216efafSThierry Reding 2009216efafSThierry Reding #ifndef readw 2019216efafSThierry Reding #define readw readw 2029216efafSThierry Reding static inline u16 readw(const volatile void __iomem *addr) 2039216efafSThierry Reding { 204032d59e1SSinan Kaya u16 val; 205032d59e1SSinan Kaya 2065e5ff73cSSai Prakash Ranjan log_read_mmio(16, addr, _THIS_IP_, _RET_IP_); 207032d59e1SSinan Kaya __io_br(); 208c1d55d50SStafford Horne val = __le16_to_cpu((__le16 __force)__raw_readw(addr)); 209abbbbc83SWill Deacon __io_ar(val); 2105e5ff73cSSai Prakash Ranjan log_post_read_mmio(val, 16, addr, _THIS_IP_, _RET_IP_); 211032d59e1SSinan Kaya return val; 2129216efafSThierry Reding } 2139216efafSThierry Reding #endif 2149216efafSThierry Reding 2159216efafSThierry Reding #ifndef readl 2169216efafSThierry Reding #define readl readl 2179216efafSThierry Reding static inline u32 readl(const volatile void __iomem *addr) 2189216efafSThierry Reding { 219032d59e1SSinan Kaya u32 val; 220032d59e1SSinan Kaya 2215e5ff73cSSai Prakash Ranjan log_read_mmio(32, addr, _THIS_IP_, _RET_IP_); 222032d59e1SSinan Kaya __io_br(); 223c1d55d50SStafford Horne val = __le32_to_cpu((__le32 __force)__raw_readl(addr)); 224abbbbc83SWill Deacon __io_ar(val); 2255e5ff73cSSai Prakash Ranjan log_post_read_mmio(val, 32, addr, _THIS_IP_, _RET_IP_); 226032d59e1SSinan Kaya return val; 2279216efafSThierry Reding } 2289216efafSThierry Reding #endif 2299216efafSThierry Reding 2309216efafSThierry Reding #ifdef CONFIG_64BIT 2319216efafSThierry Reding #ifndef readq 2327292e7e0SHeiko Carstens #define readq readq 2337292e7e0SHeiko Carstens static inline u64 readq(const volatile void __iomem *addr) 2347292e7e0SHeiko Carstens { 235032d59e1SSinan Kaya u64 val; 236032d59e1SSinan Kaya 2375e5ff73cSSai Prakash Ranjan log_read_mmio(64, addr, _THIS_IP_, _RET_IP_); 238032d59e1SSinan Kaya __io_br(); 239d564fa1fSVladimir Oltean val = __le64_to_cpu((__le64 __force)__raw_readq(addr)); 240abbbbc83SWill Deacon __io_ar(val); 2415e5ff73cSSai Prakash Ranjan log_post_read_mmio(val, 64, addr, _THIS_IP_, _RET_IP_); 242032d59e1SSinan Kaya return val; 2437292e7e0SHeiko Carstens } 2443f7e212dSArnd Bergmann #endif 245cd248341SJan Glauber #endif /* CONFIG_64BIT */ 246cd248341SJan Glauber 2479216efafSThierry Reding #ifndef writeb 2489216efafSThierry Reding #define writeb writeb 2499216efafSThierry Reding static inline void writeb(u8 value, volatile void __iomem *addr) 2509216efafSThierry Reding { 2515e5ff73cSSai Prakash Ranjan log_write_mmio(value, 8, addr, _THIS_IP_, _RET_IP_); 252755bd04aSSinan Kaya __io_bw(); 2539216efafSThierry Reding __raw_writeb(value, addr); 254755bd04aSSinan Kaya __io_aw(); 2555e5ff73cSSai Prakash Ranjan log_post_write_mmio(value, 8, addr, _THIS_IP_, _RET_IP_); 2569216efafSThierry Reding } 2577dc59bddSGuanXuetao #endif 2587dc59bddSGuanXuetao 2599216efafSThierry Reding #ifndef writew 2609216efafSThierry Reding #define writew writew 2619216efafSThierry Reding static inline void writew(u16 value, volatile void __iomem *addr) 2623f7e212dSArnd Bergmann { 2635e5ff73cSSai Prakash Ranjan log_write_mmio(value, 16, addr, _THIS_IP_, _RET_IP_); 264755bd04aSSinan Kaya __io_bw(); 265c1d55d50SStafford Horne __raw_writew((u16 __force)cpu_to_le16(value), addr); 266755bd04aSSinan Kaya __io_aw(); 2675e5ff73cSSai Prakash Ranjan log_post_write_mmio(value, 16, addr, _THIS_IP_, _RET_IP_); 2683f7e212dSArnd Bergmann } 2699216efafSThierry Reding #endif 2703f7e212dSArnd Bergmann 2719216efafSThierry Reding #ifndef writel 2729216efafSThierry Reding #define writel writel 2739216efafSThierry Reding static inline void writel(u32 value, volatile void __iomem *addr) 2743f7e212dSArnd Bergmann { 2755e5ff73cSSai Prakash Ranjan log_write_mmio(value, 32, addr, _THIS_IP_, _RET_IP_); 276755bd04aSSinan Kaya __io_bw(); 277c1d55d50SStafford Horne __raw_writel((u32 __force)__cpu_to_le32(value), addr); 278755bd04aSSinan Kaya __io_aw(); 2795e5ff73cSSai Prakash Ranjan log_post_write_mmio(value, 32, addr, _THIS_IP_, _RET_IP_); 2803f7e212dSArnd Bergmann } 2819216efafSThierry Reding #endif 2823f7e212dSArnd Bergmann 2839216efafSThierry Reding #ifdef CONFIG_64BIT 2849216efafSThierry Reding #ifndef writeq 2859216efafSThierry Reding #define writeq writeq 2869216efafSThierry Reding static inline void writeq(u64 value, volatile void __iomem *addr) 2873f7e212dSArnd Bergmann { 2885e5ff73cSSai Prakash Ranjan log_write_mmio(value, 64, addr, _THIS_IP_, _RET_IP_); 289755bd04aSSinan Kaya __io_bw(); 290d564fa1fSVladimir Oltean __raw_writeq((u64 __force)__cpu_to_le64(value), addr); 291755bd04aSSinan Kaya __io_aw(); 2925e5ff73cSSai Prakash Ranjan log_post_write_mmio(value, 64, addr, _THIS_IP_, _RET_IP_); 2933f7e212dSArnd Bergmann } 2949216efafSThierry Reding #endif 2959216efafSThierry Reding #endif /* CONFIG_64BIT */ 2963f7e212dSArnd Bergmann 2979ab3a7a0SThierry Reding /* 2981c8d2969SArnd Bergmann * {read,write}{b,w,l,q}_relaxed() are like the regular version, but 2991c8d2969SArnd Bergmann * are not guaranteed to provide ordering against spinlocks or memory 3001c8d2969SArnd Bergmann * accesses. 3011c8d2969SArnd Bergmann */ 3021c8d2969SArnd Bergmann #ifndef readb_relaxed 3038875c554SSinan Kaya #define readb_relaxed readb_relaxed 3048875c554SSinan Kaya static inline u8 readb_relaxed(const volatile void __iomem *addr) 3058875c554SSinan Kaya { 30621003197SSai Prakash Ranjan u8 val; 30721003197SSai Prakash Ranjan 3085e5ff73cSSai Prakash Ranjan log_read_mmio(8, addr, _THIS_IP_, _RET_IP_); 30921003197SSai Prakash Ranjan val = __raw_readb(addr); 3105e5ff73cSSai Prakash Ranjan log_post_read_mmio(val, 8, addr, _THIS_IP_, _RET_IP_); 31121003197SSai Prakash Ranjan return val; 3128875c554SSinan Kaya } 3131c8d2969SArnd Bergmann #endif 3141c8d2969SArnd Bergmann 3151c8d2969SArnd Bergmann #ifndef readw_relaxed 3168875c554SSinan Kaya #define readw_relaxed readw_relaxed 3178875c554SSinan Kaya static inline u16 readw_relaxed(const volatile void __iomem *addr) 3188875c554SSinan Kaya { 31921003197SSai Prakash Ranjan u16 val; 32021003197SSai Prakash Ranjan 3215e5ff73cSSai Prakash Ranjan log_read_mmio(16, addr, _THIS_IP_, _RET_IP_); 32205d3855bSVladimir Oltean val = __le16_to_cpu((__le16 __force)__raw_readw(addr)); 3235e5ff73cSSai Prakash Ranjan log_post_read_mmio(val, 16, addr, _THIS_IP_, _RET_IP_); 32421003197SSai Prakash Ranjan return val; 3258875c554SSinan Kaya } 3261c8d2969SArnd Bergmann #endif 3271c8d2969SArnd Bergmann 3281c8d2969SArnd Bergmann #ifndef readl_relaxed 3298875c554SSinan Kaya #define readl_relaxed readl_relaxed 3308875c554SSinan Kaya static inline u32 readl_relaxed(const volatile void __iomem *addr) 3318875c554SSinan Kaya { 33221003197SSai Prakash Ranjan u32 val; 33321003197SSai Prakash Ranjan 3345e5ff73cSSai Prakash Ranjan log_read_mmio(32, addr, _THIS_IP_, _RET_IP_); 33505d3855bSVladimir Oltean val = __le32_to_cpu((__le32 __force)__raw_readl(addr)); 3365e5ff73cSSai Prakash Ranjan log_post_read_mmio(val, 32, addr, _THIS_IP_, _RET_IP_); 33721003197SSai Prakash Ranjan return val; 3388875c554SSinan Kaya } 3391c8d2969SArnd Bergmann #endif 3401c8d2969SArnd Bergmann 341e511267bSRobin Murphy #if defined(readq) && !defined(readq_relaxed) 3428875c554SSinan Kaya #define readq_relaxed readq_relaxed 3438875c554SSinan Kaya static inline u64 readq_relaxed(const volatile void __iomem *addr) 3448875c554SSinan Kaya { 34521003197SSai Prakash Ranjan u64 val; 34621003197SSai Prakash Ranjan 3475e5ff73cSSai Prakash Ranjan log_read_mmio(64, addr, _THIS_IP_, _RET_IP_); 34805d3855bSVladimir Oltean val = __le64_to_cpu((__le64 __force)__raw_readq(addr)); 3495e5ff73cSSai Prakash Ranjan log_post_read_mmio(val, 64, addr, _THIS_IP_, _RET_IP_); 35021003197SSai Prakash Ranjan return val; 3518875c554SSinan Kaya } 3529439eb3aSWill Deacon #endif 3533f7e212dSArnd Bergmann 3541c8d2969SArnd Bergmann #ifndef writeb_relaxed 355a71e7c44SSinan Kaya #define writeb_relaxed writeb_relaxed 356a71e7c44SSinan Kaya static inline void writeb_relaxed(u8 value, volatile void __iomem *addr) 357a71e7c44SSinan Kaya { 3585e5ff73cSSai Prakash Ranjan log_write_mmio(value, 8, addr, _THIS_IP_, _RET_IP_); 359a71e7c44SSinan Kaya __raw_writeb(value, addr); 3605e5ff73cSSai Prakash Ranjan log_post_write_mmio(value, 8, addr, _THIS_IP_, _RET_IP_); 361a71e7c44SSinan Kaya } 3621c8d2969SArnd Bergmann #endif 3631c8d2969SArnd Bergmann 3641c8d2969SArnd Bergmann #ifndef writew_relaxed 365a71e7c44SSinan Kaya #define writew_relaxed writew_relaxed 366a71e7c44SSinan Kaya static inline void writew_relaxed(u16 value, volatile void __iomem *addr) 367a71e7c44SSinan Kaya { 3685e5ff73cSSai Prakash Ranjan log_write_mmio(value, 16, addr, _THIS_IP_, _RET_IP_); 36905d3855bSVladimir Oltean __raw_writew((u16 __force)cpu_to_le16(value), addr); 3705e5ff73cSSai Prakash Ranjan log_post_write_mmio(value, 16, addr, _THIS_IP_, _RET_IP_); 371a71e7c44SSinan Kaya } 3721c8d2969SArnd Bergmann #endif 3731c8d2969SArnd Bergmann 3741c8d2969SArnd Bergmann #ifndef writel_relaxed 375a71e7c44SSinan Kaya #define writel_relaxed writel_relaxed 376a71e7c44SSinan Kaya static inline void writel_relaxed(u32 value, volatile void __iomem *addr) 377a71e7c44SSinan Kaya { 3785e5ff73cSSai Prakash Ranjan log_write_mmio(value, 32, addr, _THIS_IP_, _RET_IP_); 37905d3855bSVladimir Oltean __raw_writel((u32 __force)__cpu_to_le32(value), addr); 3805e5ff73cSSai Prakash Ranjan log_post_write_mmio(value, 32, addr, _THIS_IP_, _RET_IP_); 381a71e7c44SSinan Kaya } 3821c8d2969SArnd Bergmann #endif 3831c8d2969SArnd Bergmann 384e511267bSRobin Murphy #if defined(writeq) && !defined(writeq_relaxed) 385a71e7c44SSinan Kaya #define writeq_relaxed writeq_relaxed 386a71e7c44SSinan Kaya static inline void writeq_relaxed(u64 value, volatile void __iomem *addr) 387a71e7c44SSinan Kaya { 3885e5ff73cSSai Prakash Ranjan log_write_mmio(value, 64, addr, _THIS_IP_, _RET_IP_); 38905d3855bSVladimir Oltean __raw_writeq((u64 __force)__cpu_to_le64(value), addr); 3905e5ff73cSSai Prakash Ranjan log_post_write_mmio(value, 64, addr, _THIS_IP_, _RET_IP_); 391a71e7c44SSinan Kaya } 3921c8d2969SArnd Bergmann #endif 3931c8d2969SArnd Bergmann 3941c8d2969SArnd Bergmann /* 3959ab3a7a0SThierry Reding * {read,write}s{b,w,l,q}() repeatedly access the same memory address in 3969ab3a7a0SThierry Reding * native endianness in 8-, 16-, 32- or 64-bit chunks (@count times). 3979ab3a7a0SThierry Reding */ 3989ab3a7a0SThierry Reding #ifndef readsb 3999ab3a7a0SThierry Reding #define readsb readsb 4009ab3a7a0SThierry Reding static inline void readsb(const volatile void __iomem *addr, void *buffer, 4019ab3a7a0SThierry Reding unsigned int count) 4023f7e212dSArnd Bergmann { 4033f7e212dSArnd Bergmann if (count) { 4043f7e212dSArnd Bergmann u8 *buf = buffer; 4059ab3a7a0SThierry Reding 4063f7e212dSArnd Bergmann do { 4079ab3a7a0SThierry Reding u8 x = __raw_readb(addr); 4083f7e212dSArnd Bergmann *buf++ = x; 4093f7e212dSArnd Bergmann } while (--count); 4103f7e212dSArnd Bergmann } 4113f7e212dSArnd Bergmann } 41235dbc0e0SMike Frysinger #endif 4133f7e212dSArnd Bergmann 4149ab3a7a0SThierry Reding #ifndef readsw 4159ab3a7a0SThierry Reding #define readsw readsw 4169ab3a7a0SThierry Reding static inline void readsw(const volatile void __iomem *addr, void *buffer, 4179ab3a7a0SThierry Reding unsigned int count) 4183f7e212dSArnd Bergmann { 4193f7e212dSArnd Bergmann if (count) { 4203f7e212dSArnd Bergmann u16 *buf = buffer; 4219ab3a7a0SThierry Reding 4223f7e212dSArnd Bergmann do { 4239ab3a7a0SThierry Reding u16 x = __raw_readw(addr); 4243f7e212dSArnd Bergmann *buf++ = x; 4253f7e212dSArnd Bergmann } while (--count); 4263f7e212dSArnd Bergmann } 4273f7e212dSArnd Bergmann } 42835dbc0e0SMike Frysinger #endif 4293f7e212dSArnd Bergmann 4309ab3a7a0SThierry Reding #ifndef readsl 4319ab3a7a0SThierry Reding #define readsl readsl 4329ab3a7a0SThierry Reding static inline void readsl(const volatile void __iomem *addr, void *buffer, 4339ab3a7a0SThierry Reding unsigned int count) 4343f7e212dSArnd Bergmann { 4353f7e212dSArnd Bergmann if (count) { 4363f7e212dSArnd Bergmann u32 *buf = buffer; 4379ab3a7a0SThierry Reding 4383f7e212dSArnd Bergmann do { 4399ab3a7a0SThierry Reding u32 x = __raw_readl(addr); 4403f7e212dSArnd Bergmann *buf++ = x; 4413f7e212dSArnd Bergmann } while (--count); 4423f7e212dSArnd Bergmann } 4433f7e212dSArnd Bergmann } 44435dbc0e0SMike Frysinger #endif 4453f7e212dSArnd Bergmann 4469ab3a7a0SThierry Reding #ifdef CONFIG_64BIT 4479ab3a7a0SThierry Reding #ifndef readsq 4489ab3a7a0SThierry Reding #define readsq readsq 4499ab3a7a0SThierry Reding static inline void readsq(const volatile void __iomem *addr, void *buffer, 4509ab3a7a0SThierry Reding unsigned int count) 4519ab3a7a0SThierry Reding { 4529ab3a7a0SThierry Reding if (count) { 4539ab3a7a0SThierry Reding u64 *buf = buffer; 4549ab3a7a0SThierry Reding 4559ab3a7a0SThierry Reding do { 4569ab3a7a0SThierry Reding u64 x = __raw_readq(addr); 4579ab3a7a0SThierry Reding *buf++ = x; 4589ab3a7a0SThierry Reding } while (--count); 4599ab3a7a0SThierry Reding } 4609ab3a7a0SThierry Reding } 4619ab3a7a0SThierry Reding #endif 4629ab3a7a0SThierry Reding #endif /* CONFIG_64BIT */ 4639ab3a7a0SThierry Reding 4649ab3a7a0SThierry Reding #ifndef writesb 4659ab3a7a0SThierry Reding #define writesb writesb 4669ab3a7a0SThierry Reding static inline void writesb(volatile void __iomem *addr, const void *buffer, 4679ab3a7a0SThierry Reding unsigned int count) 4683f7e212dSArnd Bergmann { 4693f7e212dSArnd Bergmann if (count) { 4703f7e212dSArnd Bergmann const u8 *buf = buffer; 4719ab3a7a0SThierry Reding 4723f7e212dSArnd Bergmann do { 4739ab3a7a0SThierry Reding __raw_writeb(*buf++, addr); 4743f7e212dSArnd Bergmann } while (--count); 4753f7e212dSArnd Bergmann } 4763f7e212dSArnd Bergmann } 47735dbc0e0SMike Frysinger #endif 4783f7e212dSArnd Bergmann 4799ab3a7a0SThierry Reding #ifndef writesw 4809ab3a7a0SThierry Reding #define writesw writesw 4819ab3a7a0SThierry Reding static inline void writesw(volatile void __iomem *addr, const void *buffer, 4829ab3a7a0SThierry Reding unsigned int count) 4833f7e212dSArnd Bergmann { 4843f7e212dSArnd Bergmann if (count) { 4853f7e212dSArnd Bergmann const u16 *buf = buffer; 4869ab3a7a0SThierry Reding 4873f7e212dSArnd Bergmann do { 4889ab3a7a0SThierry Reding __raw_writew(*buf++, addr); 4893f7e212dSArnd Bergmann } while (--count); 4903f7e212dSArnd Bergmann } 4913f7e212dSArnd Bergmann } 49235dbc0e0SMike Frysinger #endif 4933f7e212dSArnd Bergmann 4949ab3a7a0SThierry Reding #ifndef writesl 4959ab3a7a0SThierry Reding #define writesl writesl 4969ab3a7a0SThierry Reding static inline void writesl(volatile void __iomem *addr, const void *buffer, 4979ab3a7a0SThierry Reding unsigned int count) 4983f7e212dSArnd Bergmann { 4993f7e212dSArnd Bergmann if (count) { 5003f7e212dSArnd Bergmann const u32 *buf = buffer; 5019ab3a7a0SThierry Reding 5023f7e212dSArnd Bergmann do { 5039ab3a7a0SThierry Reding __raw_writel(*buf++, addr); 5043f7e212dSArnd Bergmann } while (--count); 5053f7e212dSArnd Bergmann } 5063f7e212dSArnd Bergmann } 50735dbc0e0SMike Frysinger #endif 5083f7e212dSArnd Bergmann 5099ab3a7a0SThierry Reding #ifdef CONFIG_64BIT 5109ab3a7a0SThierry Reding #ifndef writesq 5119ab3a7a0SThierry Reding #define writesq writesq 5129ab3a7a0SThierry Reding static inline void writesq(volatile void __iomem *addr, const void *buffer, 5139ab3a7a0SThierry Reding unsigned int count) 5149ab3a7a0SThierry Reding { 5159ab3a7a0SThierry Reding if (count) { 5169ab3a7a0SThierry Reding const u64 *buf = buffer; 5173f7e212dSArnd Bergmann 5189ab3a7a0SThierry Reding do { 5199ab3a7a0SThierry Reding __raw_writeq(*buf++, addr); 5209ab3a7a0SThierry Reding } while (--count); 5219ab3a7a0SThierry Reding } 5229ab3a7a0SThierry Reding } 5239ab3a7a0SThierry Reding #endif 5249ab3a7a0SThierry Reding #endif /* CONFIG_64BIT */ 5253f7e212dSArnd Bergmann 5269216efafSThierry Reding #ifndef PCI_IOBASE 5279216efafSThierry Reding #define PCI_IOBASE ((void __iomem *)0) 5289216efafSThierry Reding #endif 5299216efafSThierry Reding 5307dc59bddSGuanXuetao #ifndef IO_SPACE_LIMIT 5317dc59bddSGuanXuetao #define IO_SPACE_LIMIT 0xffff 5327dc59bddSGuanXuetao #endif 5333f7e212dSArnd Bergmann 5349216efafSThierry Reding /* 5359216efafSThierry Reding * {in,out}{b,w,l}() access little endian I/O. {in,out}{b,w,l}_p() can be 5369216efafSThierry Reding * implemented on hardware that needs an additional delay for I/O accesses to 5379216efafSThierry Reding * take effect. 5389216efafSThierry Reding */ 5399216efafSThierry Reding 540f009c89dSJohn Garry #if !defined(inb) && !defined(_inb) 541f009c89dSJohn Garry #define _inb _inb 542214ba358SStafford Horne static inline u8 _inb(unsigned long addr) 5439216efafSThierry Reding { 54487fe2d54SSinan Kaya u8 val; 54587fe2d54SSinan Kaya 54687fe2d54SSinan Kaya __io_pbr(); 54787fe2d54SSinan Kaya val = __raw_readb(PCI_IOBASE + addr); 548abbbbc83SWill Deacon __io_par(val); 54987fe2d54SSinan Kaya return val; 5509216efafSThierry Reding } 5519216efafSThierry Reding #endif 5529216efafSThierry Reding 553f009c89dSJohn Garry #if !defined(inw) && !defined(_inw) 554f009c89dSJohn Garry #define _inw _inw 555f009c89dSJohn Garry static inline u16 _inw(unsigned long addr) 5569216efafSThierry Reding { 55787fe2d54SSinan Kaya u16 val; 55887fe2d54SSinan Kaya 55987fe2d54SSinan Kaya __io_pbr(); 560c1d55d50SStafford Horne val = __le16_to_cpu((__le16 __force)__raw_readw(PCI_IOBASE + addr)); 561abbbbc83SWill Deacon __io_par(val); 56287fe2d54SSinan Kaya return val; 5639216efafSThierry Reding } 5649216efafSThierry Reding #endif 5659216efafSThierry Reding 566f009c89dSJohn Garry #if !defined(inl) && !defined(_inl) 567f009c89dSJohn Garry #define _inl _inl 568214ba358SStafford Horne static inline u32 _inl(unsigned long addr) 5699216efafSThierry Reding { 57087fe2d54SSinan Kaya u32 val; 57187fe2d54SSinan Kaya 57287fe2d54SSinan Kaya __io_pbr(); 573c1d55d50SStafford Horne val = __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + addr)); 574abbbbc83SWill Deacon __io_par(val); 57587fe2d54SSinan Kaya return val; 5769216efafSThierry Reding } 5779216efafSThierry Reding #endif 5789216efafSThierry Reding 579f009c89dSJohn Garry #if !defined(outb) && !defined(_outb) 580f009c89dSJohn Garry #define _outb _outb 581f009c89dSJohn Garry static inline void _outb(u8 value, unsigned long addr) 5829216efafSThierry Reding { 583a7851aa5SSinan Kaya __io_pbw(); 584a7851aa5SSinan Kaya __raw_writeb(value, PCI_IOBASE + addr); 585a7851aa5SSinan Kaya __io_paw(); 5869216efafSThierry Reding } 5879216efafSThierry Reding #endif 5889216efafSThierry Reding 589f009c89dSJohn Garry #if !defined(outw) && !defined(_outw) 590f009c89dSJohn Garry #define _outw _outw 591f009c89dSJohn Garry static inline void _outw(u16 value, unsigned long addr) 5929216efafSThierry Reding { 593a7851aa5SSinan Kaya __io_pbw(); 594c1d55d50SStafford Horne __raw_writew((u16 __force)cpu_to_le16(value), PCI_IOBASE + addr); 595a7851aa5SSinan Kaya __io_paw(); 5969216efafSThierry Reding } 5979216efafSThierry Reding #endif 5989216efafSThierry Reding 599f009c89dSJohn Garry #if !defined(outl) && !defined(_outl) 600f009c89dSJohn Garry #define _outl _outl 601f009c89dSJohn Garry static inline void _outl(u32 value, unsigned long addr) 6029216efafSThierry Reding { 603a7851aa5SSinan Kaya __io_pbw(); 604c1d55d50SStafford Horne __raw_writel((u32 __force)cpu_to_le32(value), PCI_IOBASE + addr); 605a7851aa5SSinan Kaya __io_paw(); 6069216efafSThierry Reding } 6079216efafSThierry Reding #endif 6089216efafSThierry Reding 609f009c89dSJohn Garry #include <linux/logic_pio.h> 610f009c89dSJohn Garry 611f009c89dSJohn Garry #ifndef inb 612f009c89dSJohn Garry #define inb _inb 613f009c89dSJohn Garry #endif 614f009c89dSJohn Garry 615f009c89dSJohn Garry #ifndef inw 616f009c89dSJohn Garry #define inw _inw 617f009c89dSJohn Garry #endif 618f009c89dSJohn Garry 619f009c89dSJohn Garry #ifndef inl 620f009c89dSJohn Garry #define inl _inl 621f009c89dSJohn Garry #endif 622f009c89dSJohn Garry 623f009c89dSJohn Garry #ifndef outb 624f009c89dSJohn Garry #define outb _outb 625f009c89dSJohn Garry #endif 626f009c89dSJohn Garry 627f009c89dSJohn Garry #ifndef outw 628f009c89dSJohn Garry #define outw _outw 629f009c89dSJohn Garry #endif 630f009c89dSJohn Garry 631f009c89dSJohn Garry #ifndef outl 632f009c89dSJohn Garry #define outl _outl 633f009c89dSJohn Garry #endif 634f009c89dSJohn Garry 6359216efafSThierry Reding #ifndef inb_p 6369216efafSThierry Reding #define inb_p inb_p 6379216efafSThierry Reding static inline u8 inb_p(unsigned long addr) 6389216efafSThierry Reding { 6399216efafSThierry Reding return inb(addr); 6409216efafSThierry Reding } 6419216efafSThierry Reding #endif 6429216efafSThierry Reding 6439216efafSThierry Reding #ifndef inw_p 6449216efafSThierry Reding #define inw_p inw_p 6459216efafSThierry Reding static inline u16 inw_p(unsigned long addr) 6469216efafSThierry Reding { 6479216efafSThierry Reding return inw(addr); 6489216efafSThierry Reding } 6499216efafSThierry Reding #endif 6509216efafSThierry Reding 6519216efafSThierry Reding #ifndef inl_p 6529216efafSThierry Reding #define inl_p inl_p 6539216efafSThierry Reding static inline u32 inl_p(unsigned long addr) 6549216efafSThierry Reding { 6559216efafSThierry Reding return inl(addr); 6569216efafSThierry Reding } 6579216efafSThierry Reding #endif 6589216efafSThierry Reding 6599216efafSThierry Reding #ifndef outb_p 6609216efafSThierry Reding #define outb_p outb_p 6619216efafSThierry Reding static inline void outb_p(u8 value, unsigned long addr) 6629216efafSThierry Reding { 6639216efafSThierry Reding outb(value, addr); 6649216efafSThierry Reding } 6659216efafSThierry Reding #endif 6669216efafSThierry Reding 6679216efafSThierry Reding #ifndef outw_p 6689216efafSThierry Reding #define outw_p outw_p 6699216efafSThierry Reding static inline void outw_p(u16 value, unsigned long addr) 6709216efafSThierry Reding { 6719216efafSThierry Reding outw(value, addr); 6729216efafSThierry Reding } 6739216efafSThierry Reding #endif 6749216efafSThierry Reding 6759216efafSThierry Reding #ifndef outl_p 6769216efafSThierry Reding #define outl_p outl_p 6779216efafSThierry Reding static inline void outl_p(u32 value, unsigned long addr) 6789216efafSThierry Reding { 6799216efafSThierry Reding outl(value, addr); 6809216efafSThierry Reding } 6819216efafSThierry Reding #endif 6829216efafSThierry Reding 6839ab3a7a0SThierry Reding /* 6849ab3a7a0SThierry Reding * {in,out}s{b,w,l}{,_p}() are variants of the above that repeatedly access a 6859ab3a7a0SThierry Reding * single I/O port multiple times. 6869ab3a7a0SThierry Reding */ 6879ab3a7a0SThierry Reding 6889ab3a7a0SThierry Reding #ifndef insb 6899ab3a7a0SThierry Reding #define insb insb 6909ab3a7a0SThierry Reding static inline void insb(unsigned long addr, void *buffer, unsigned int count) 6919ab3a7a0SThierry Reding { 6929ab3a7a0SThierry Reding readsb(PCI_IOBASE + addr, buffer, count); 6939ab3a7a0SThierry Reding } 6949ab3a7a0SThierry Reding #endif 6959ab3a7a0SThierry Reding 6969ab3a7a0SThierry Reding #ifndef insw 6979ab3a7a0SThierry Reding #define insw insw 6989ab3a7a0SThierry Reding static inline void insw(unsigned long addr, void *buffer, unsigned int count) 6999ab3a7a0SThierry Reding { 7009ab3a7a0SThierry Reding readsw(PCI_IOBASE + addr, buffer, count); 7019ab3a7a0SThierry Reding } 7029ab3a7a0SThierry Reding #endif 7039ab3a7a0SThierry Reding 7049ab3a7a0SThierry Reding #ifndef insl 7059ab3a7a0SThierry Reding #define insl insl 7069ab3a7a0SThierry Reding static inline void insl(unsigned long addr, void *buffer, unsigned int count) 7079ab3a7a0SThierry Reding { 7089ab3a7a0SThierry Reding readsl(PCI_IOBASE + addr, buffer, count); 7099ab3a7a0SThierry Reding } 7109ab3a7a0SThierry Reding #endif 7119ab3a7a0SThierry Reding 7129ab3a7a0SThierry Reding #ifndef outsb 7139ab3a7a0SThierry Reding #define outsb outsb 7149ab3a7a0SThierry Reding static inline void outsb(unsigned long addr, const void *buffer, 7159ab3a7a0SThierry Reding unsigned int count) 7169ab3a7a0SThierry Reding { 7179ab3a7a0SThierry Reding writesb(PCI_IOBASE + addr, buffer, count); 7189ab3a7a0SThierry Reding } 7199ab3a7a0SThierry Reding #endif 7209ab3a7a0SThierry Reding 7219ab3a7a0SThierry Reding #ifndef outsw 7229ab3a7a0SThierry Reding #define outsw outsw 7239ab3a7a0SThierry Reding static inline void outsw(unsigned long addr, const void *buffer, 7249ab3a7a0SThierry Reding unsigned int count) 7259ab3a7a0SThierry Reding { 7269ab3a7a0SThierry Reding writesw(PCI_IOBASE + addr, buffer, count); 7279ab3a7a0SThierry Reding } 7289ab3a7a0SThierry Reding #endif 7299ab3a7a0SThierry Reding 7309ab3a7a0SThierry Reding #ifndef outsl 7319ab3a7a0SThierry Reding #define outsl outsl 7329ab3a7a0SThierry Reding static inline void outsl(unsigned long addr, const void *buffer, 7339ab3a7a0SThierry Reding unsigned int count) 7349ab3a7a0SThierry Reding { 7359ab3a7a0SThierry Reding writesl(PCI_IOBASE + addr, buffer, count); 7369ab3a7a0SThierry Reding } 7379ab3a7a0SThierry Reding #endif 7389ab3a7a0SThierry Reding 7399ab3a7a0SThierry Reding #ifndef insb_p 7409ab3a7a0SThierry Reding #define insb_p insb_p 7419ab3a7a0SThierry Reding static inline void insb_p(unsigned long addr, void *buffer, unsigned int count) 7429ab3a7a0SThierry Reding { 7439ab3a7a0SThierry Reding insb(addr, buffer, count); 7449ab3a7a0SThierry Reding } 7459ab3a7a0SThierry Reding #endif 7469ab3a7a0SThierry Reding 7479ab3a7a0SThierry Reding #ifndef insw_p 7489ab3a7a0SThierry Reding #define insw_p insw_p 7499ab3a7a0SThierry Reding static inline void insw_p(unsigned long addr, void *buffer, unsigned int count) 7509ab3a7a0SThierry Reding { 7519ab3a7a0SThierry Reding insw(addr, buffer, count); 7529ab3a7a0SThierry Reding } 7539ab3a7a0SThierry Reding #endif 7549ab3a7a0SThierry Reding 7559ab3a7a0SThierry Reding #ifndef insl_p 7569ab3a7a0SThierry Reding #define insl_p insl_p 7579ab3a7a0SThierry Reding static inline void insl_p(unsigned long addr, void *buffer, unsigned int count) 7589ab3a7a0SThierry Reding { 7599ab3a7a0SThierry Reding insl(addr, buffer, count); 7609ab3a7a0SThierry Reding } 7619ab3a7a0SThierry Reding #endif 7629ab3a7a0SThierry Reding 7639ab3a7a0SThierry Reding #ifndef outsb_p 7649ab3a7a0SThierry Reding #define outsb_p outsb_p 7659ab3a7a0SThierry Reding static inline void outsb_p(unsigned long addr, const void *buffer, 7669ab3a7a0SThierry Reding unsigned int count) 7679ab3a7a0SThierry Reding { 7689ab3a7a0SThierry Reding outsb(addr, buffer, count); 7699ab3a7a0SThierry Reding } 7709ab3a7a0SThierry Reding #endif 7719ab3a7a0SThierry Reding 7729ab3a7a0SThierry Reding #ifndef outsw_p 7739ab3a7a0SThierry Reding #define outsw_p outsw_p 7749ab3a7a0SThierry Reding static inline void outsw_p(unsigned long addr, const void *buffer, 7759ab3a7a0SThierry Reding unsigned int count) 7769ab3a7a0SThierry Reding { 7779ab3a7a0SThierry Reding outsw(addr, buffer, count); 7789ab3a7a0SThierry Reding } 7799ab3a7a0SThierry Reding #endif 7809ab3a7a0SThierry Reding 7819ab3a7a0SThierry Reding #ifndef outsl_p 7829ab3a7a0SThierry Reding #define outsl_p outsl_p 7839ab3a7a0SThierry Reding static inline void outsl_p(unsigned long addr, const void *buffer, 7849ab3a7a0SThierry Reding unsigned int count) 7859ab3a7a0SThierry Reding { 7869ab3a7a0SThierry Reding outsl(addr, buffer, count); 7879ab3a7a0SThierry Reding } 7889ab3a7a0SThierry Reding #endif 7899ab3a7a0SThierry Reding 7909216efafSThierry Reding #ifndef CONFIG_GENERIC_IOMAP 7919216efafSThierry Reding #ifndef ioread8 7929216efafSThierry Reding #define ioread8 ioread8 7939216efafSThierry Reding static inline u8 ioread8(const volatile void __iomem *addr) 7949216efafSThierry Reding { 7959216efafSThierry Reding return readb(addr); 7969216efafSThierry Reding } 7979216efafSThierry Reding #endif 7989216efafSThierry Reding 7999216efafSThierry Reding #ifndef ioread16 8009216efafSThierry Reding #define ioread16 ioread16 8019216efafSThierry Reding static inline u16 ioread16(const volatile void __iomem *addr) 8029216efafSThierry Reding { 8039216efafSThierry Reding return readw(addr); 8049216efafSThierry Reding } 8059216efafSThierry Reding #endif 8069216efafSThierry Reding 8079216efafSThierry Reding #ifndef ioread32 8089216efafSThierry Reding #define ioread32 ioread32 8099216efafSThierry Reding static inline u32 ioread32(const volatile void __iomem *addr) 8109216efafSThierry Reding { 8119216efafSThierry Reding return readl(addr); 8129216efafSThierry Reding } 8139216efafSThierry Reding #endif 8149216efafSThierry Reding 8159e44fb18SHoria Geantă #ifdef CONFIG_64BIT 8169e44fb18SHoria Geantă #ifndef ioread64 8179e44fb18SHoria Geantă #define ioread64 ioread64 8189e44fb18SHoria Geantă static inline u64 ioread64(const volatile void __iomem *addr) 8199e44fb18SHoria Geantă { 8209e44fb18SHoria Geantă return readq(addr); 8219e44fb18SHoria Geantă } 8229e44fb18SHoria Geantă #endif 8239e44fb18SHoria Geantă #endif /* CONFIG_64BIT */ 8249e44fb18SHoria Geantă 8259216efafSThierry Reding #ifndef iowrite8 8269216efafSThierry Reding #define iowrite8 iowrite8 8279216efafSThierry Reding static inline void iowrite8(u8 value, volatile void __iomem *addr) 8289216efafSThierry Reding { 8299216efafSThierry Reding writeb(value, addr); 8309216efafSThierry Reding } 8319216efafSThierry Reding #endif 8329216efafSThierry Reding 8339216efafSThierry Reding #ifndef iowrite16 8349216efafSThierry Reding #define iowrite16 iowrite16 8359216efafSThierry Reding static inline void iowrite16(u16 value, volatile void __iomem *addr) 8369216efafSThierry Reding { 8379216efafSThierry Reding writew(value, addr); 8389216efafSThierry Reding } 8399216efafSThierry Reding #endif 8409216efafSThierry Reding 8419216efafSThierry Reding #ifndef iowrite32 8429216efafSThierry Reding #define iowrite32 iowrite32 8439216efafSThierry Reding static inline void iowrite32(u32 value, volatile void __iomem *addr) 8449216efafSThierry Reding { 8459216efafSThierry Reding writel(value, addr); 8469216efafSThierry Reding } 8479216efafSThierry Reding #endif 8489216efafSThierry Reding 8499e44fb18SHoria Geantă #ifdef CONFIG_64BIT 8509e44fb18SHoria Geantă #ifndef iowrite64 8519e44fb18SHoria Geantă #define iowrite64 iowrite64 8529e44fb18SHoria Geantă static inline void iowrite64(u64 value, volatile void __iomem *addr) 8539e44fb18SHoria Geantă { 8549e44fb18SHoria Geantă writeq(value, addr); 8559e44fb18SHoria Geantă } 8569e44fb18SHoria Geantă #endif 8579e44fb18SHoria Geantă #endif /* CONFIG_64BIT */ 8589e44fb18SHoria Geantă 8599216efafSThierry Reding #ifndef ioread16be 8609216efafSThierry Reding #define ioread16be ioread16be 8619216efafSThierry Reding static inline u16 ioread16be(const volatile void __iomem *addr) 8629216efafSThierry Reding { 8637a1aedbaSHoria Geantă return swab16(readw(addr)); 8649216efafSThierry Reding } 8659216efafSThierry Reding #endif 8669216efafSThierry Reding 8679216efafSThierry Reding #ifndef ioread32be 8689216efafSThierry Reding #define ioread32be ioread32be 8699216efafSThierry Reding static inline u32 ioread32be(const volatile void __iomem *addr) 8709216efafSThierry Reding { 8717a1aedbaSHoria Geantă return swab32(readl(addr)); 8729216efafSThierry Reding } 8739216efafSThierry Reding #endif 8749216efafSThierry Reding 8759e44fb18SHoria Geantă #ifdef CONFIG_64BIT 8769e44fb18SHoria Geantă #ifndef ioread64be 8779e44fb18SHoria Geantă #define ioread64be ioread64be 8789e44fb18SHoria Geantă static inline u64 ioread64be(const volatile void __iomem *addr) 8799e44fb18SHoria Geantă { 8809e44fb18SHoria Geantă return swab64(readq(addr)); 8819e44fb18SHoria Geantă } 8829e44fb18SHoria Geantă #endif 8839e44fb18SHoria Geantă #endif /* CONFIG_64BIT */ 8849e44fb18SHoria Geantă 8859216efafSThierry Reding #ifndef iowrite16be 8869216efafSThierry Reding #define iowrite16be iowrite16be 8879216efafSThierry Reding static inline void iowrite16be(u16 value, void volatile __iomem *addr) 8889216efafSThierry Reding { 8897a1aedbaSHoria Geantă writew(swab16(value), addr); 8909216efafSThierry Reding } 8919216efafSThierry Reding #endif 8929216efafSThierry Reding 8939216efafSThierry Reding #ifndef iowrite32be 8949216efafSThierry Reding #define iowrite32be iowrite32be 8959216efafSThierry Reding static inline void iowrite32be(u32 value, volatile void __iomem *addr) 8969216efafSThierry Reding { 8977a1aedbaSHoria Geantă writel(swab32(value), addr); 8989216efafSThierry Reding } 8999216efafSThierry Reding #endif 9009ab3a7a0SThierry Reding 9019e44fb18SHoria Geantă #ifdef CONFIG_64BIT 9029e44fb18SHoria Geantă #ifndef iowrite64be 9039e44fb18SHoria Geantă #define iowrite64be iowrite64be 9049e44fb18SHoria Geantă static inline void iowrite64be(u64 value, volatile void __iomem *addr) 9059e44fb18SHoria Geantă { 9069e44fb18SHoria Geantă writeq(swab64(value), addr); 9079e44fb18SHoria Geantă } 9089e44fb18SHoria Geantă #endif 9099e44fb18SHoria Geantă #endif /* CONFIG_64BIT */ 9109e44fb18SHoria Geantă 9119ab3a7a0SThierry Reding #ifndef ioread8_rep 9129ab3a7a0SThierry Reding #define ioread8_rep ioread8_rep 9139ab3a7a0SThierry Reding static inline void ioread8_rep(const volatile void __iomem *addr, void *buffer, 9149ab3a7a0SThierry Reding unsigned int count) 9159ab3a7a0SThierry Reding { 9169ab3a7a0SThierry Reding readsb(addr, buffer, count); 9179ab3a7a0SThierry Reding } 9189ab3a7a0SThierry Reding #endif 9199ab3a7a0SThierry Reding 9209ab3a7a0SThierry Reding #ifndef ioread16_rep 9219ab3a7a0SThierry Reding #define ioread16_rep ioread16_rep 9229ab3a7a0SThierry Reding static inline void ioread16_rep(const volatile void __iomem *addr, 9239ab3a7a0SThierry Reding void *buffer, unsigned int count) 9249ab3a7a0SThierry Reding { 9259ab3a7a0SThierry Reding readsw(addr, buffer, count); 9269ab3a7a0SThierry Reding } 9279ab3a7a0SThierry Reding #endif 9289ab3a7a0SThierry Reding 9299ab3a7a0SThierry Reding #ifndef ioread32_rep 9309ab3a7a0SThierry Reding #define ioread32_rep ioread32_rep 9319ab3a7a0SThierry Reding static inline void ioread32_rep(const volatile void __iomem *addr, 9329ab3a7a0SThierry Reding void *buffer, unsigned int count) 9339ab3a7a0SThierry Reding { 9349ab3a7a0SThierry Reding readsl(addr, buffer, count); 9359ab3a7a0SThierry Reding } 9369ab3a7a0SThierry Reding #endif 9379ab3a7a0SThierry Reding 9389e44fb18SHoria Geantă #ifdef CONFIG_64BIT 9399e44fb18SHoria Geantă #ifndef ioread64_rep 9409e44fb18SHoria Geantă #define ioread64_rep ioread64_rep 9419e44fb18SHoria Geantă static inline void ioread64_rep(const volatile void __iomem *addr, 9429e44fb18SHoria Geantă void *buffer, unsigned int count) 9439e44fb18SHoria Geantă { 9449e44fb18SHoria Geantă readsq(addr, buffer, count); 9459e44fb18SHoria Geantă } 9469e44fb18SHoria Geantă #endif 9479e44fb18SHoria Geantă #endif /* CONFIG_64BIT */ 9489e44fb18SHoria Geantă 9499ab3a7a0SThierry Reding #ifndef iowrite8_rep 9509ab3a7a0SThierry Reding #define iowrite8_rep iowrite8_rep 9519ab3a7a0SThierry Reding static inline void iowrite8_rep(volatile void __iomem *addr, 9529ab3a7a0SThierry Reding const void *buffer, 9539ab3a7a0SThierry Reding unsigned int count) 9549ab3a7a0SThierry Reding { 9559ab3a7a0SThierry Reding writesb(addr, buffer, count); 9569ab3a7a0SThierry Reding } 9579ab3a7a0SThierry Reding #endif 9589ab3a7a0SThierry Reding 9599ab3a7a0SThierry Reding #ifndef iowrite16_rep 9609ab3a7a0SThierry Reding #define iowrite16_rep iowrite16_rep 9619ab3a7a0SThierry Reding static inline void iowrite16_rep(volatile void __iomem *addr, 9629ab3a7a0SThierry Reding const void *buffer, 9639ab3a7a0SThierry Reding unsigned int count) 9649ab3a7a0SThierry Reding { 9659ab3a7a0SThierry Reding writesw(addr, buffer, count); 9669ab3a7a0SThierry Reding } 9679ab3a7a0SThierry Reding #endif 9689ab3a7a0SThierry Reding 9699ab3a7a0SThierry Reding #ifndef iowrite32_rep 9709ab3a7a0SThierry Reding #define iowrite32_rep iowrite32_rep 9719ab3a7a0SThierry Reding static inline void iowrite32_rep(volatile void __iomem *addr, 9729ab3a7a0SThierry Reding const void *buffer, 9739ab3a7a0SThierry Reding unsigned int count) 9749ab3a7a0SThierry Reding { 9759ab3a7a0SThierry Reding writesl(addr, buffer, count); 9769ab3a7a0SThierry Reding } 9779ab3a7a0SThierry Reding #endif 9789e44fb18SHoria Geantă 9799e44fb18SHoria Geantă #ifdef CONFIG_64BIT 9809e44fb18SHoria Geantă #ifndef iowrite64_rep 9819e44fb18SHoria Geantă #define iowrite64_rep iowrite64_rep 9829e44fb18SHoria Geantă static inline void iowrite64_rep(volatile void __iomem *addr, 9839e44fb18SHoria Geantă const void *buffer, 9849e44fb18SHoria Geantă unsigned int count) 9859e44fb18SHoria Geantă { 9869e44fb18SHoria Geantă writesq(addr, buffer, count); 9879e44fb18SHoria Geantă } 9889e44fb18SHoria Geantă #endif 9899e44fb18SHoria Geantă #endif /* CONFIG_64BIT */ 9909216efafSThierry Reding #endif /* CONFIG_GENERIC_IOMAP */ 9919216efafSThierry Reding 9923f7e212dSArnd Bergmann #ifdef __KERNEL__ 9933f7e212dSArnd Bergmann 9943f7e212dSArnd Bergmann #include <linux/vmalloc.h> 9953f7e212dSArnd Bergmann #define __io_virt(x) ((void __force *)(x)) 9963f7e212dSArnd Bergmann 9973f7e212dSArnd Bergmann /* 9983f7e212dSArnd Bergmann * Change virtual addresses to physical addresses and vv. 9993f7e212dSArnd Bergmann * These are pretty trivial 10003f7e212dSArnd Bergmann */ 1001cd248341SJan Glauber #ifndef virt_to_phys 10029216efafSThierry Reding #define virt_to_phys virt_to_phys 10033f7e212dSArnd Bergmann static inline unsigned long virt_to_phys(volatile void *address) 10043f7e212dSArnd Bergmann { 10053f7e212dSArnd Bergmann return __pa((unsigned long)address); 10063f7e212dSArnd Bergmann } 10079216efafSThierry Reding #endif 10083f7e212dSArnd Bergmann 10099216efafSThierry Reding #ifndef phys_to_virt 10109216efafSThierry Reding #define phys_to_virt phys_to_virt 10113f7e212dSArnd Bergmann static inline void *phys_to_virt(unsigned long address) 10123f7e212dSArnd Bergmann { 10133f7e212dSArnd Bergmann return __va(address); 10143f7e212dSArnd Bergmann } 1015cd248341SJan Glauber #endif 10163f7e212dSArnd Bergmann 10178c7ea50cSLuis R. Rodriguez /** 10188c7ea50cSLuis R. Rodriguez * DOC: ioremap() and ioremap_*() variants 10198c7ea50cSLuis R. Rodriguez * 102097c9801aSChristoph Hellwig * Architectures with an MMU are expected to provide ioremap() and iounmap() 102180b0ca98SChristoph Hellwig * themselves or rely on GENERIC_IOREMAP. For NOMMU architectures we provide 102280b0ca98SChristoph Hellwig * a default nop-op implementation that expect that the physical address used 102380b0ca98SChristoph Hellwig * for MMIO are already marked as uncached, and can be used as kernel virtual 102480b0ca98SChristoph Hellwig * addresses. 10258c7ea50cSLuis R. Rodriguez * 102697c9801aSChristoph Hellwig * ioremap_wc() and ioremap_wt() can provide more relaxed caching attributes 102797c9801aSChristoph Hellwig * for specific drivers if the architecture choses to implement them. If they 10287c566bb5SHector Martin * are not implemented we fall back to plain ioremap. Conversely, ioremap_np() 10297c566bb5SHector Martin * can provide stricter non-posted write semantics if the architecture 10307c566bb5SHector Martin * implements them. 10318c7ea50cSLuis R. Rodriguez */ 1032e9713395SChristoph Hellwig #ifndef CONFIG_MMU 10339216efafSThierry Reding #ifndef ioremap 10349216efafSThierry Reding #define ioremap ioremap 10359216efafSThierry Reding static inline void __iomem *ioremap(phys_addr_t offset, size_t size) 10363f7e212dSArnd Bergmann { 10373f7e212dSArnd Bergmann return (void __iomem *)(unsigned long)offset; 10383f7e212dSArnd Bergmann } 10399216efafSThierry Reding #endif 10403f7e212dSArnd Bergmann 1041b3ada9d0SGreentime Hu #ifndef iounmap 1042b3ada9d0SGreentime Hu #define iounmap iounmap 10432fbc3499SAdam Borowski static inline void iounmap(volatile void __iomem *addr) 1044b3ada9d0SGreentime Hu { 1045b3ada9d0SGreentime Hu } 1046b3ada9d0SGreentime Hu #endif 104780b0ca98SChristoph Hellwig #elif defined(CONFIG_GENERIC_IOREMAP) 1048ca5999fdSMike Rapoport #include <linux/pgtable.h> 104980b0ca98SChristoph Hellwig 105018e780b4SKefeng Wang /* 105118e780b4SKefeng Wang * Arch code can implement the following two hooks when using GENERIC_IOREMAP 105218e780b4SKefeng Wang * ioremap_allowed() return a bool, 105318e780b4SKefeng Wang * - true means continue to remap 105418e780b4SKefeng Wang * - false means skip remap and return directly 105518e780b4SKefeng Wang * iounmap_allowed() return a bool, 105618e780b4SKefeng Wang * - true means continue to vunmap 105718e780b4SKefeng Wang * - false means skip vunmap and return directly 105818e780b4SKefeng Wang */ 105918e780b4SKefeng Wang #ifndef ioremap_allowed 106018e780b4SKefeng Wang #define ioremap_allowed ioremap_allowed 106118e780b4SKefeng Wang static inline bool ioremap_allowed(phys_addr_t phys_addr, size_t size, 106218e780b4SKefeng Wang unsigned long prot) 106318e780b4SKefeng Wang { 106418e780b4SKefeng Wang return true; 106518e780b4SKefeng Wang } 106618e780b4SKefeng Wang #endif 106718e780b4SKefeng Wang 106818e780b4SKefeng Wang #ifndef iounmap_allowed 106918e780b4SKefeng Wang #define iounmap_allowed iounmap_allowed 107018e780b4SKefeng Wang static inline bool iounmap_allowed(void *addr) 107118e780b4SKefeng Wang { 107218e780b4SKefeng Wang return true; 107318e780b4SKefeng Wang } 107418e780b4SKefeng Wang #endif 107518e780b4SKefeng Wang 10767613366aSChristophe Leroy void __iomem *generic_ioremap_prot(phys_addr_t phys_addr, size_t size, 10777613366aSChristophe Leroy pgprot_t prot); 10787613366aSChristophe Leroy 1079abc5992bSKefeng Wang void __iomem *ioremap_prot(phys_addr_t phys_addr, size_t size, 1080abc5992bSKefeng Wang unsigned long prot); 108180b0ca98SChristoph Hellwig void iounmap(volatile void __iomem *addr); 10827613366aSChristophe Leroy void generic_iounmap(volatile void __iomem *addr); 108380b0ca98SChristoph Hellwig 1084*dfdc6ba9SBaoquan He #ifndef ioremap 1085*dfdc6ba9SBaoquan He #define ioremap ioremap 108680b0ca98SChristoph Hellwig static inline void __iomem *ioremap(phys_addr_t addr, size_t size) 108780b0ca98SChristoph Hellwig { 108880b0ca98SChristoph Hellwig /* _PAGE_IOREMAP needs to be supplied by the architecture */ 108980b0ca98SChristoph Hellwig return ioremap_prot(addr, size, _PAGE_IOREMAP); 109080b0ca98SChristoph Hellwig } 1091*dfdc6ba9SBaoquan He #endif 109280b0ca98SChristoph Hellwig #endif /* !CONFIG_MMU || CONFIG_GENERIC_IOREMAP */ 109397c9801aSChristoph Hellwig 10943f7e212dSArnd Bergmann #ifndef ioremap_wc 1095d092a870SChristoph Hellwig #define ioremap_wc ioremap 10963f7e212dSArnd Bergmann #endif 10973f7e212dSArnd Bergmann 1098d838270eSToshi Kani #ifndef ioremap_wt 1099d092a870SChristoph Hellwig #define ioremap_wt ioremap 1100d838270eSToshi Kani #endif 1101d838270eSToshi Kani 1102e9713395SChristoph Hellwig /* 1103e9713395SChristoph Hellwig * ioremap_uc is special in that we do require an explicit architecture 1104e9713395SChristoph Hellwig * implementation. In general you do not want to use this function in a 1105e9713395SChristoph Hellwig * driver and use plain ioremap, which is uncached by default. Similarly 1106e9713395SChristoph Hellwig * architectures should not implement it unless they have a very good 1107e9713395SChristoph Hellwig * reason. 1108e9713395SChristoph Hellwig */ 1109e9713395SChristoph Hellwig #ifndef ioremap_uc 1110e9713395SChristoph Hellwig #define ioremap_uc ioremap_uc 1111e9713395SChristoph Hellwig static inline void __iomem *ioremap_uc(phys_addr_t offset, size_t size) 1112e9713395SChristoph Hellwig { 1113e9713395SChristoph Hellwig return NULL; 1114e9713395SChristoph Hellwig } 1115ea962928SHector Martin #endif 11167c566bb5SHector Martin 11177c566bb5SHector Martin /* 11187c566bb5SHector Martin * ioremap_np needs an explicit architecture implementation, as it 11197c566bb5SHector Martin * requests stronger semantics than regular ioremap(). Portable drivers 11207c566bb5SHector Martin * should instead use one of the higher-level abstractions, like 11217c566bb5SHector Martin * devm_ioremap_resource(), to choose the correct variant for any given 11227c566bb5SHector Martin * device and bus. Portable drivers with a good reason to want non-posted 11237c566bb5SHector Martin * write semantics should always provide an ioremap() fallback in case 11247c566bb5SHector Martin * ioremap_np() is not available. 11257c566bb5SHector Martin */ 11267c566bb5SHector Martin #ifndef ioremap_np 11277c566bb5SHector Martin #define ioremap_np ioremap_np 11287c566bb5SHector Martin static inline void __iomem *ioremap_np(phys_addr_t offset, size_t size) 11297c566bb5SHector Martin { 11307c566bb5SHector Martin return NULL; 11317c566bb5SHector Martin } 11327c566bb5SHector Martin #endif 11337c566bb5SHector Martin 1134ce816fa8SUwe Kleine-König #ifdef CONFIG_HAS_IOPORT_MAP 11353f7e212dSArnd Bergmann #ifndef CONFIG_GENERIC_IOMAP 11369216efafSThierry Reding #ifndef ioport_map 11379216efafSThierry Reding #define ioport_map ioport_map 11383f7e212dSArnd Bergmann static inline void __iomem *ioport_map(unsigned long port, unsigned int nr) 11393f7e212dSArnd Bergmann { 1140500dd232SAndrew Murray port &= IO_SPACE_LIMIT; 1141500dd232SAndrew Murray return (port > MMIO_UPPER_LIMIT) ? NULL : PCI_IOBASE + port; 11423f7e212dSArnd Bergmann } 1143316e8d79SLinus Torvalds #define ARCH_HAS_GENERIC_IOPORT_MAP 11449216efafSThierry Reding #endif 11453f7e212dSArnd Bergmann 11469216efafSThierry Reding #ifndef ioport_unmap 11479216efafSThierry Reding #define ioport_unmap ioport_unmap 11483f7e212dSArnd Bergmann static inline void ioport_unmap(void __iomem *p) 11493f7e212dSArnd Bergmann { 11503f7e212dSArnd Bergmann } 11519216efafSThierry Reding #endif 11523f7e212dSArnd Bergmann #else /* CONFIG_GENERIC_IOMAP */ 11533f7e212dSArnd Bergmann extern void __iomem *ioport_map(unsigned long port, unsigned int nr); 11543f7e212dSArnd Bergmann extern void ioport_unmap(void __iomem *p); 11553f7e212dSArnd Bergmann #endif /* CONFIG_GENERIC_IOMAP */ 1156ce816fa8SUwe Kleine-König #endif /* CONFIG_HAS_IOPORT_MAP */ 11573f7e212dSArnd Bergmann 1158f5810e5cSLorenzo Pieralisi #ifndef CONFIG_GENERIC_IOMAP 1159f5810e5cSLorenzo Pieralisi #ifndef pci_iounmap 1160316e8d79SLinus Torvalds #define ARCH_WANTS_GENERIC_PCI_IOUNMAP 1161f5810e5cSLorenzo Pieralisi #endif 1162316e8d79SLinus Torvalds #endif 1163f5810e5cSLorenzo Pieralisi 1164576ebd74SMichael Holzheu #ifndef xlate_dev_mem_ptr 11659216efafSThierry Reding #define xlate_dev_mem_ptr xlate_dev_mem_ptr 11669216efafSThierry Reding static inline void *xlate_dev_mem_ptr(phys_addr_t addr) 11679216efafSThierry Reding { 11689216efafSThierry Reding return __va(addr); 11699216efafSThierry Reding } 11709216efafSThierry Reding #endif 11719216efafSThierry Reding 11729216efafSThierry Reding #ifndef unxlate_dev_mem_ptr 11739216efafSThierry Reding #define unxlate_dev_mem_ptr unxlate_dev_mem_ptr 11749216efafSThierry Reding static inline void unxlate_dev_mem_ptr(phys_addr_t phys, void *addr) 11759216efafSThierry Reding { 11769216efafSThierry Reding } 1177576ebd74SMichael Holzheu #endif 11783f7e212dSArnd Bergmann 1179cd248341SJan Glauber #ifndef memset_io 11809216efafSThierry Reding #define memset_io memset_io 1181c2327da0SAndy Shevchenko /** 1182c2327da0SAndy Shevchenko * memset_io Set a range of I/O memory to a constant value 1183c2327da0SAndy Shevchenko * @addr: The beginning of the I/O-memory range to set 1184c2327da0SAndy Shevchenko * @val: The value to set the memory to 1185c2327da0SAndy Shevchenko * @count: The number of bytes to set 1186c2327da0SAndy Shevchenko * 1187c2327da0SAndy Shevchenko * Set a range of I/O memory to a given value. 1188c2327da0SAndy Shevchenko */ 11899216efafSThierry Reding static inline void memset_io(volatile void __iomem *addr, int value, 11909216efafSThierry Reding size_t size) 11919216efafSThierry Reding { 11929216efafSThierry Reding memset(__io_virt(addr), value, size); 11939216efafSThierry Reding } 1194cd248341SJan Glauber #endif 1195cd248341SJan Glauber 1196cd248341SJan Glauber #ifndef memcpy_fromio 11979216efafSThierry Reding #define memcpy_fromio memcpy_fromio 1198c2327da0SAndy Shevchenko /** 1199c2327da0SAndy Shevchenko * memcpy_fromio Copy a block of data from I/O memory 1200c2327da0SAndy Shevchenko * @dst: The (RAM) destination for the copy 1201c2327da0SAndy Shevchenko * @src: The (I/O memory) source for the data 1202c2327da0SAndy Shevchenko * @count: The number of bytes to copy 1203c2327da0SAndy Shevchenko * 1204c2327da0SAndy Shevchenko * Copy a block of data from I/O memory. 1205c2327da0SAndy Shevchenko */ 12069216efafSThierry Reding static inline void memcpy_fromio(void *buffer, 12079216efafSThierry Reding const volatile void __iomem *addr, 12089216efafSThierry Reding size_t size) 12099216efafSThierry Reding { 12109216efafSThierry Reding memcpy(buffer, __io_virt(addr), size); 12119216efafSThierry Reding } 1212cd248341SJan Glauber #endif 12139216efafSThierry Reding 1214cd248341SJan Glauber #ifndef memcpy_toio 12159216efafSThierry Reding #define memcpy_toio memcpy_toio 1216c2327da0SAndy Shevchenko /** 1217c2327da0SAndy Shevchenko * memcpy_toio Copy a block of data into I/O memory 1218c2327da0SAndy Shevchenko * @dst: The (I/O memory) destination for the copy 1219c2327da0SAndy Shevchenko * @src: The (RAM) source for the data 1220c2327da0SAndy Shevchenko * @count: The number of bytes to copy 1221c2327da0SAndy Shevchenko * 1222c2327da0SAndy Shevchenko * Copy a block of data to I/O memory. 1223c2327da0SAndy Shevchenko */ 12249216efafSThierry Reding static inline void memcpy_toio(volatile void __iomem *addr, const void *buffer, 12259216efafSThierry Reding size_t size) 12269216efafSThierry Reding { 12279216efafSThierry Reding memcpy(__io_virt(addr), buffer, size); 12289216efafSThierry Reding } 1229cd248341SJan Glauber #endif 12303f7e212dSArnd Bergmann 1231527701edSPalmer Dabbelt extern int devmem_is_allowed(unsigned long pfn); 1232527701edSPalmer Dabbelt 12333f7e212dSArnd Bergmann #endif /* __KERNEL__ */ 12343f7e212dSArnd Bergmann 12353f7e212dSArnd Bergmann #endif /* __ASM_GENERIC_IO_H */ 1236