Loading...
1/* SPDX-License-Identifier: GPL-2.0 */
2#ifndef __SPARC_IO_H
3#define __SPARC_IO_H
4
5#include <linux/kernel.h>
6#include <linux/ioport.h> /* struct resource */
7
8#define IO_SPACE_LIMIT 0xffffffff
9
10#define memset_io(d,c,sz) _memset_io(d,c,sz)
11#define memcpy_fromio(d,s,sz) _memcpy_fromio(d,s,sz)
12#define memcpy_toio(d,s,sz) _memcpy_toio(d,s,sz)
13
14#include <asm-generic/io.h>
15
16static inline void _memset_io(volatile void __iomem *dst,
17 int c, __kernel_size_t n)
18{
19 volatile void __iomem *d = dst;
20
21 while (n--) {
22 writeb(c, d);
23 d++;
24 }
25}
26
27static inline void _memcpy_fromio(void *dst, const volatile void __iomem *src,
28 __kernel_size_t n)
29{
30 char *d = dst;
31
32 while (n--) {
33 char tmp = readb(src);
34 *d++ = tmp;
35 src++;
36 }
37}
38
39static inline void _memcpy_toio(volatile void __iomem *dst, const void *src,
40 __kernel_size_t n)
41{
42 const char *s = src;
43 volatile void __iomem *d = dst;
44
45 while (n--) {
46 char tmp = *s++;
47 writeb(tmp, d);
48 d++;
49 }
50}
51
52/*
53 * SBus accessors.
54 *
55 * SBus has only one, memory mapped, I/O space.
56 * We do not need to flip bytes for SBus of course.
57 */
58static inline u8 sbus_readb(const volatile void __iomem *addr)
59{
60 return *(__force volatile u8 *)addr;
61}
62
63static inline u16 sbus_readw(const volatile void __iomem *addr)
64{
65 return *(__force volatile u16 *)addr;
66}
67
68static inline u32 sbus_readl(const volatile void __iomem *addr)
69{
70 return *(__force volatile u32 *)addr;
71}
72
73static inline void sbus_writeb(u8 b, volatile void __iomem *addr)
74{
75 *(__force volatile u8 *)addr = b;
76}
77
78static inline void sbus_writew(u16 w, volatile void __iomem *addr)
79{
80 *(__force volatile u16 *)addr = w;
81}
82
83static inline void sbus_writel(u32 l, volatile void __iomem *addr)
84{
85 *(__force volatile u32 *)addr = l;
86}
87
88static inline void sbus_memset_io(volatile void __iomem *__dst, int c,
89 __kernel_size_t n)
90{
91 while(n--) {
92 sbus_writeb(c, __dst);
93 __dst++;
94 }
95}
96
97static inline void sbus_memcpy_fromio(void *dst,
98 const volatile void __iomem *src,
99 __kernel_size_t n)
100{
101 char *d = dst;
102
103 while (n--) {
104 char tmp = sbus_readb(src);
105 *d++ = tmp;
106 src++;
107 }
108}
109
110static inline void sbus_memcpy_toio(volatile void __iomem *dst,
111 const void *src,
112 __kernel_size_t n)
113{
114 const char *s = src;
115 volatile void __iomem *d = dst;
116
117 while (n--) {
118 char tmp = *s++;
119 sbus_writeb(tmp, d);
120 d++;
121 }
122}
123
124#ifdef __KERNEL__
125
126/*
127 * Bus number may be embedded in the higher bits of the physical address.
128 * This is why we have no bus number argument to ioremap().
129 */
130void iounmap(volatile void __iomem *addr);
131/* Create a virtual mapping cookie for an IO port range */
132void __iomem *ioport_map(unsigned long port, unsigned int nr);
133void ioport_unmap(void __iomem *);
134
135/* Create a virtual mapping cookie for a PCI BAR (memory or IO) */
136struct pci_dev;
137void pci_iounmap(struct pci_dev *dev, void __iomem *);
138
139static inline int sbus_can_dma_64bit(void)
140{
141 return 0; /* actually, sparc_cpu_model==sun4d */
142}
143static inline int sbus_can_burst64(void)
144{
145 return 0; /* actually, sparc_cpu_model==sun4d */
146}
147struct device;
148void sbus_set_sbus64(struct device *, int);
149
150#endif
151
152#define __ARCH_HAS_NO_PAGE_ZERO_MAPPED 1
153
154
155#endif /* !(__SPARC_IO_H) */
1/* SPDX-License-Identifier: GPL-2.0 */
2#ifndef __SPARC_IO_H
3#define __SPARC_IO_H
4
5#include <linux/kernel.h>
6#include <linux/ioport.h> /* struct resource */
7
8#define IO_SPACE_LIMIT 0xffffffff
9
10#define memset_io(d,c,sz) _memset_io(d,c,sz)
11#define memcpy_fromio(d,s,sz) _memcpy_fromio(d,s,sz)
12#define memcpy_toio(d,s,sz) _memcpy_toio(d,s,sz)
13
14/*
15 * Bus number may be embedded in the higher bits of the physical address.
16 * This is why we have no bus number argument to ioremap().
17 */
18void __iomem *ioremap(phys_addr_t offset, size_t size);
19void iounmap(volatile void __iomem *addr);
20
21#include <asm-generic/io.h>
22
23static inline void _memset_io(volatile void __iomem *dst,
24 int c, __kernel_size_t n)
25{
26 volatile void __iomem *d = dst;
27
28 while (n--) {
29 writeb(c, d);
30 d++;
31 }
32}
33
34static inline void _memcpy_fromio(void *dst, const volatile void __iomem *src,
35 __kernel_size_t n)
36{
37 char *d = dst;
38
39 while (n--) {
40 char tmp = readb(src);
41 *d++ = tmp;
42 src++;
43 }
44}
45
46static inline void _memcpy_toio(volatile void __iomem *dst, const void *src,
47 __kernel_size_t n)
48{
49 const char *s = src;
50 volatile void __iomem *d = dst;
51
52 while (n--) {
53 char tmp = *s++;
54 writeb(tmp, d);
55 d++;
56 }
57}
58
59/*
60 * SBus accessors.
61 *
62 * SBus has only one, memory mapped, I/O space.
63 * We do not need to flip bytes for SBus of course.
64 */
65static inline u8 sbus_readb(const volatile void __iomem *addr)
66{
67 return *(__force volatile u8 *)addr;
68}
69
70static inline u16 sbus_readw(const volatile void __iomem *addr)
71{
72 return *(__force volatile u16 *)addr;
73}
74
75static inline u32 sbus_readl(const volatile void __iomem *addr)
76{
77 return *(__force volatile u32 *)addr;
78}
79
80static inline void sbus_writeb(u8 b, volatile void __iomem *addr)
81{
82 *(__force volatile u8 *)addr = b;
83}
84
85static inline void sbus_writew(u16 w, volatile void __iomem *addr)
86{
87 *(__force volatile u16 *)addr = w;
88}
89
90static inline void sbus_writel(u32 l, volatile void __iomem *addr)
91{
92 *(__force volatile u32 *)addr = l;
93}
94
95static inline void sbus_memset_io(volatile void __iomem *__dst, int c,
96 __kernel_size_t n)
97{
98 while(n--) {
99 sbus_writeb(c, __dst);
100 __dst++;
101 }
102}
103
104static inline void sbus_memcpy_fromio(void *dst,
105 const volatile void __iomem *src,
106 __kernel_size_t n)
107{
108 char *d = dst;
109
110 while (n--) {
111 char tmp = sbus_readb(src);
112 *d++ = tmp;
113 src++;
114 }
115}
116
117static inline void sbus_memcpy_toio(volatile void __iomem *dst,
118 const void *src,
119 __kernel_size_t n)
120{
121 const char *s = src;
122 volatile void __iomem *d = dst;
123
124 while (n--) {
125 char tmp = *s++;
126 sbus_writeb(tmp, d);
127 d++;
128 }
129}
130
131/* Create a virtual mapping cookie for an IO port range */
132void __iomem *ioport_map(unsigned long port, unsigned int nr);
133void ioport_unmap(void __iomem *);
134
135/* Create a virtual mapping cookie for a PCI BAR (memory or IO) */
136struct pci_dev;
137void pci_iounmap(struct pci_dev *dev, void __iomem *);
138
139static inline int sbus_can_dma_64bit(void)
140{
141 return 0; /* actually, sparc_cpu_model==sun4d */
142}
143static inline int sbus_can_burst64(void)
144{
145 return 0; /* actually, sparc_cpu_model==sun4d */
146}
147struct device;
148void sbus_set_sbus64(struct device *, int);
149
150#define __ARCH_HAS_NO_PAGE_ZERO_MAPPED 1
151
152
153#endif /* !(__SPARC_IO_H) */