Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * ppc64 "iomap" interface implementation.
4 *
5 * (C) Copyright 2004 Linus Torvalds
6 */
7#include <linux/pci.h>
8#include <linux/mm.h>
9#include <linux/export.h>
10#include <asm/io.h>
11#include <asm/pci-bridge.h>
12#include <asm/isa-bridge.h>
13
14/*
15 * Here comes the ppc64 implementation of the IOMAP
16 * interfaces.
17 */
18unsigned int ioread8(const void __iomem *addr)
19{
20 return readb(addr);
21}
22unsigned int ioread16(const void __iomem *addr)
23{
24 return readw(addr);
25}
26unsigned int ioread16be(const void __iomem *addr)
27{
28 return readw_be(addr);
29}
30unsigned int ioread32(const void __iomem *addr)
31{
32 return readl(addr);
33}
34unsigned int ioread32be(const void __iomem *addr)
35{
36 return readl_be(addr);
37}
38EXPORT_SYMBOL(ioread8);
39EXPORT_SYMBOL(ioread16);
40EXPORT_SYMBOL(ioread16be);
41EXPORT_SYMBOL(ioread32);
42EXPORT_SYMBOL(ioread32be);
43#ifdef __powerpc64__
44u64 ioread64(const void __iomem *addr)
45{
46 return readq(addr);
47}
48u64 ioread64_lo_hi(const void __iomem *addr)
49{
50 return readq(addr);
51}
52u64 ioread64_hi_lo(const void __iomem *addr)
53{
54 return readq(addr);
55}
56u64 ioread64be(const void __iomem *addr)
57{
58 return readq_be(addr);
59}
60u64 ioread64be_lo_hi(const void __iomem *addr)
61{
62 return readq_be(addr);
63}
64u64 ioread64be_hi_lo(const void __iomem *addr)
65{
66 return readq_be(addr);
67}
68EXPORT_SYMBOL(ioread64);
69EXPORT_SYMBOL(ioread64_lo_hi);
70EXPORT_SYMBOL(ioread64_hi_lo);
71EXPORT_SYMBOL(ioread64be);
72EXPORT_SYMBOL(ioread64be_lo_hi);
73EXPORT_SYMBOL(ioread64be_hi_lo);
74#endif /* __powerpc64__ */
75
76void iowrite8(u8 val, void __iomem *addr)
77{
78 writeb(val, addr);
79}
80void iowrite16(u16 val, void __iomem *addr)
81{
82 writew(val, addr);
83}
84void iowrite16be(u16 val, void __iomem *addr)
85{
86 writew_be(val, addr);
87}
88void iowrite32(u32 val, void __iomem *addr)
89{
90 writel(val, addr);
91}
92void iowrite32be(u32 val, void __iomem *addr)
93{
94 writel_be(val, addr);
95}
96EXPORT_SYMBOL(iowrite8);
97EXPORT_SYMBOL(iowrite16);
98EXPORT_SYMBOL(iowrite16be);
99EXPORT_SYMBOL(iowrite32);
100EXPORT_SYMBOL(iowrite32be);
101#ifdef __powerpc64__
102void iowrite64(u64 val, void __iomem *addr)
103{
104 writeq(val, addr);
105}
106void iowrite64_lo_hi(u64 val, void __iomem *addr)
107{
108 writeq(val, addr);
109}
110void iowrite64_hi_lo(u64 val, void __iomem *addr)
111{
112 writeq(val, addr);
113}
114void iowrite64be(u64 val, void __iomem *addr)
115{
116 writeq_be(val, addr);
117}
118void iowrite64be_lo_hi(u64 val, void __iomem *addr)
119{
120 writeq_be(val, addr);
121}
122void iowrite64be_hi_lo(u64 val, void __iomem *addr)
123{
124 writeq_be(val, addr);
125}
126EXPORT_SYMBOL(iowrite64);
127EXPORT_SYMBOL(iowrite64_lo_hi);
128EXPORT_SYMBOL(iowrite64_hi_lo);
129EXPORT_SYMBOL(iowrite64be);
130EXPORT_SYMBOL(iowrite64be_lo_hi);
131EXPORT_SYMBOL(iowrite64be_hi_lo);
132#endif /* __powerpc64__ */
133
134/*
135 * These are the "repeat read/write" functions. Note the
136 * non-CPU byte order. We do things in "IO byteorder"
137 * here.
138 *
139 * FIXME! We could make these do EEH handling if we really
140 * wanted. Not clear if we do.
141 */
142void ioread8_rep(const void __iomem *addr, void *dst, unsigned long count)
143{
144 readsb(addr, dst, count);
145}
146void ioread16_rep(const void __iomem *addr, void *dst, unsigned long count)
147{
148 readsw(addr, dst, count);
149}
150void ioread32_rep(const void __iomem *addr, void *dst, unsigned long count)
151{
152 readsl(addr, dst, count);
153}
154EXPORT_SYMBOL(ioread8_rep);
155EXPORT_SYMBOL(ioread16_rep);
156EXPORT_SYMBOL(ioread32_rep);
157
158void iowrite8_rep(void __iomem *addr, const void *src, unsigned long count)
159{
160 writesb(addr, src, count);
161}
162void iowrite16_rep(void __iomem *addr, const void *src, unsigned long count)
163{
164 writesw(addr, src, count);
165}
166void iowrite32_rep(void __iomem *addr, const void *src, unsigned long count)
167{
168 writesl(addr, src, count);
169}
170EXPORT_SYMBOL(iowrite8_rep);
171EXPORT_SYMBOL(iowrite16_rep);
172EXPORT_SYMBOL(iowrite32_rep);
173
174void __iomem *ioport_map(unsigned long port, unsigned int len)
175{
176 return (void __iomem *) (port + _IO_BASE);
177}
178
179void ioport_unmap(void __iomem *addr)
180{
181 /* Nothing to do */
182}
183EXPORT_SYMBOL(ioport_map);
184EXPORT_SYMBOL(ioport_unmap);
185
186#ifdef CONFIG_PCI
187void pci_iounmap(struct pci_dev *dev, void __iomem *addr)
188{
189 if (isa_vaddr_is_ioport(addr))
190 return;
191 if (pcibios_vaddr_is_ioport(addr))
192 return;
193 iounmap(addr);
194}
195
196EXPORT_SYMBOL(pci_iounmap);
197#endif /* CONFIG_PCI */
1/*
2 * ppc64 "iomap" interface implementation.
3 *
4 * (C) Copyright 2004 Linus Torvalds
5 */
6#include <linux/pci.h>
7#include <linux/mm.h>
8#include <linux/export.h>
9#include <asm/io.h>
10#include <asm/pci-bridge.h>
11
12/*
13 * Here comes the ppc64 implementation of the IOMAP
14 * interfaces.
15 */
16unsigned int ioread8(void __iomem *addr)
17{
18 return readb(addr);
19}
20unsigned int ioread16(void __iomem *addr)
21{
22 return readw(addr);
23}
24unsigned int ioread16be(void __iomem *addr)
25{
26 return readw_be(addr);
27}
28unsigned int ioread32(void __iomem *addr)
29{
30 return readl(addr);
31}
32unsigned int ioread32be(void __iomem *addr)
33{
34 return readl_be(addr);
35}
36EXPORT_SYMBOL(ioread8);
37EXPORT_SYMBOL(ioread16);
38EXPORT_SYMBOL(ioread16be);
39EXPORT_SYMBOL(ioread32);
40EXPORT_SYMBOL(ioread32be);
41
42void iowrite8(u8 val, void __iomem *addr)
43{
44 writeb(val, addr);
45}
46void iowrite16(u16 val, void __iomem *addr)
47{
48 writew(val, addr);
49}
50void iowrite16be(u16 val, void __iomem *addr)
51{
52 writew_be(val, addr);
53}
54void iowrite32(u32 val, void __iomem *addr)
55{
56 writel(val, addr);
57}
58void iowrite32be(u32 val, void __iomem *addr)
59{
60 writel_be(val, addr);
61}
62EXPORT_SYMBOL(iowrite8);
63EXPORT_SYMBOL(iowrite16);
64EXPORT_SYMBOL(iowrite16be);
65EXPORT_SYMBOL(iowrite32);
66EXPORT_SYMBOL(iowrite32be);
67
68/*
69 * These are the "repeat read/write" functions. Note the
70 * non-CPU byte order. We do things in "IO byteorder"
71 * here.
72 *
73 * FIXME! We could make these do EEH handling if we really
74 * wanted. Not clear if we do.
75 */
76void ioread8_rep(void __iomem *addr, void *dst, unsigned long count)
77{
78 readsb(addr, dst, count);
79}
80void ioread16_rep(void __iomem *addr, void *dst, unsigned long count)
81{
82 readsw(addr, dst, count);
83}
84void ioread32_rep(void __iomem *addr, void *dst, unsigned long count)
85{
86 readsl(addr, dst, count);
87}
88EXPORT_SYMBOL(ioread8_rep);
89EXPORT_SYMBOL(ioread16_rep);
90EXPORT_SYMBOL(ioread32_rep);
91
92void iowrite8_rep(void __iomem *addr, const void *src, unsigned long count)
93{
94 writesb(addr, src, count);
95}
96void iowrite16_rep(void __iomem *addr, const void *src, unsigned long count)
97{
98 writesw(addr, src, count);
99}
100void iowrite32_rep(void __iomem *addr, const void *src, unsigned long count)
101{
102 writesl(addr, src, count);
103}
104EXPORT_SYMBOL(iowrite8_rep);
105EXPORT_SYMBOL(iowrite16_rep);
106EXPORT_SYMBOL(iowrite32_rep);
107
108void __iomem *ioport_map(unsigned long port, unsigned int len)
109{
110 return (void __iomem *) (port + _IO_BASE);
111}
112
113void ioport_unmap(void __iomem *addr)
114{
115 /* Nothing to do */
116}
117EXPORT_SYMBOL(ioport_map);
118EXPORT_SYMBOL(ioport_unmap);
119
120#ifdef CONFIG_PCI
121void pci_iounmap(struct pci_dev *dev, void __iomem *addr)
122{
123 if (isa_vaddr_is_ioport(addr))
124 return;
125 if (pcibios_vaddr_is_ioport(addr))
126 return;
127 iounmap(addr);
128}
129
130EXPORT_SYMBOL(pci_iounmap);
131#endif /* CONFIG_PCI */