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/init.h>
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
13/*
14 * Here comes the ppc64 implementation of the IOMAP
15 * interfaces.
16 */
17unsigned int ioread8(void __iomem *addr)
18{
19 return readb(addr);
20}
21unsigned int ioread16(void __iomem *addr)
22{
23 return readw(addr);
24}
25unsigned int ioread16be(void __iomem *addr)
26{
27 return in_be16(addr);
28}
29unsigned int ioread32(void __iomem *addr)
30{
31 return readl(addr);
32}
33unsigned int ioread32be(void __iomem *addr)
34{
35 return in_be32(addr);
36}
37EXPORT_SYMBOL(ioread8);
38EXPORT_SYMBOL(ioread16);
39EXPORT_SYMBOL(ioread16be);
40EXPORT_SYMBOL(ioread32);
41EXPORT_SYMBOL(ioread32be);
42
43void iowrite8(u8 val, void __iomem *addr)
44{
45 writeb(val, addr);
46}
47void iowrite16(u16 val, void __iomem *addr)
48{
49 writew(val, addr);
50}
51void iowrite16be(u16 val, void __iomem *addr)
52{
53 out_be16(addr, val);
54}
55void iowrite32(u32 val, void __iomem *addr)
56{
57 writel(val, addr);
58}
59void iowrite32be(u32 val, void __iomem *addr)
60{
61 out_be32(addr, val);
62}
63EXPORT_SYMBOL(iowrite8);
64EXPORT_SYMBOL(iowrite16);
65EXPORT_SYMBOL(iowrite16be);
66EXPORT_SYMBOL(iowrite32);
67EXPORT_SYMBOL(iowrite32be);
68
69/*
70 * These are the "repeat read/write" functions. Note the
71 * non-CPU byte order. We do things in "IO byteorder"
72 * here.
73 *
74 * FIXME! We could make these do EEH handling if we really
75 * wanted. Not clear if we do.
76 */
77void ioread8_rep(void __iomem *addr, void *dst, unsigned long count)
78{
79 _insb((u8 __iomem *) addr, dst, count);
80}
81void ioread16_rep(void __iomem *addr, void *dst, unsigned long count)
82{
83 _insw_ns((u16 __iomem *) addr, dst, count);
84}
85void ioread32_rep(void __iomem *addr, void *dst, unsigned long count)
86{
87 _insl_ns((u32 __iomem *) addr, dst, count);
88}
89EXPORT_SYMBOL(ioread8_rep);
90EXPORT_SYMBOL(ioread16_rep);
91EXPORT_SYMBOL(ioread32_rep);
92
93void iowrite8_rep(void __iomem *addr, const void *src, unsigned long count)
94{
95 _outsb((u8 __iomem *) addr, src, count);
96}
97void iowrite16_rep(void __iomem *addr, const void *src, unsigned long count)
98{
99 _outsw_ns((u16 __iomem *) addr, src, count);
100}
101void iowrite32_rep(void __iomem *addr, const void *src, unsigned long count)
102{
103 _outsl_ns((u32 __iomem *) addr, src, count);
104}
105EXPORT_SYMBOL(iowrite8_rep);
106EXPORT_SYMBOL(iowrite16_rep);
107EXPORT_SYMBOL(iowrite32_rep);
108
109void __iomem *ioport_map(unsigned long port, unsigned int len)
110{
111 return (void __iomem *) (port + _IO_BASE);
112}
113
114void ioport_unmap(void __iomem *addr)
115{
116 /* Nothing to do */
117}
118EXPORT_SYMBOL(ioport_map);
119EXPORT_SYMBOL(ioport_unmap);
120
121#ifdef CONFIG_PCI
122void pci_iounmap(struct pci_dev *dev, void __iomem *addr)
123{
124 if (isa_vaddr_is_ioport(addr))
125 return;
126 if (pcibios_vaddr_is_ioport(addr))
127 return;
128 iounmap(addr);
129}
130
131EXPORT_SYMBOL(pci_iounmap);
132#endif /* CONFIG_PCI */