Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
iomap.c
Go to the documentation of this file.
1 /*
2  * iomap.c - Implement iomap interface for PA-RISC
3  * Copyright (c) 2004 Matthew Wilcox
4  */
5 
6 #include <linux/ioport.h>
7 #include <linux/pci.h>
8 #include <linux/export.h>
9 #include <asm/io.h>
10 
11 /*
12  * The iomap space on 32-bit PA-RISC is intended to look like this:
13  * 00000000-7fffffff virtual mapped IO
14  * 80000000-8fffffff ISA/EISA port space that can't be virtually mapped
15  * 90000000-9fffffff Dino port space
16  * a0000000-afffffff Astro port space
17  * b0000000-bfffffff PAT port space
18  * c0000000-cfffffff non-swapped memory IO
19  * f0000000-ffffffff legacy IO memory pointers
20  *
21  * For the moment, here's what it looks like:
22  * 80000000-8fffffff All ISA/EISA port space
23  * f0000000-ffffffff legacy IO memory pointers
24  *
25  * On 64-bit, everything is extended, so:
26  * 8000000000000000-8fffffffffffffff All ISA/EISA port space
27  * f000000000000000-ffffffffffffffff legacy IO memory pointers
28  */
29 
30 /*
31  * Technically, this should be 'if (VMALLOC_START < addr < VMALLOC_END),
32  * but that's slow and we know it'll be within the first 2GB.
33  */
34 #ifdef CONFIG_64BIT
35 #define INDIRECT_ADDR(addr) (((unsigned long)(addr) & 1UL<<63) != 0)
36 #define ADDR_TO_REGION(addr) (((unsigned long)addr >> 60) & 7)
37 #define IOPORT_MAP_BASE (8UL << 60)
38 #else
39 #define INDIRECT_ADDR(addr) (((unsigned long)(addr) & 1UL<<31) != 0)
40 #define ADDR_TO_REGION(addr) (((unsigned long)addr >> 28) & 7)
41 #define IOPORT_MAP_BASE (8UL << 28)
42 #endif
43 
44 struct iomap_ops {
45  unsigned int (*read8)(void __iomem *);
46  unsigned int (*read16)(void __iomem *);
47  unsigned int (*read16be)(void __iomem *);
48  unsigned int (*read32)(void __iomem *);
49  unsigned int (*read32be)(void __iomem *);
50  void (*write8)(u8, void __iomem *);
51  void (*write16)(u16, void __iomem *);
52  void (*write16be)(u16, void __iomem *);
53  void (*write32)(u32, void __iomem *);
54  void (*write32be)(u32, void __iomem *);
55  void (*read8r)(void __iomem *, void *, unsigned long);
56  void (*read16r)(void __iomem *, void *, unsigned long);
57  void (*read32r)(void __iomem *, void *, unsigned long);
58  void (*write8r)(void __iomem *, const void *, unsigned long);
59  void (*write16r)(void __iomem *, const void *, unsigned long);
60  void (*write32r)(void __iomem *, const void *, unsigned long);
61 };
62 
63 /* Generic ioport ops. To be replaced later by specific dino/elroy/wax code */
64 
65 #define ADDR2PORT(addr) ((unsigned long __force)(addr) & 0xffffff)
66 
67 static unsigned int ioport_read8(void __iomem *addr)
68 {
69  return inb(ADDR2PORT(addr));
70 }
71 
72 static unsigned int ioport_read16(void __iomem *addr)
73 {
74  return inw(ADDR2PORT(addr));
75 }
76 
77 static unsigned int ioport_read32(void __iomem *addr)
78 {
79  return inl(ADDR2PORT(addr));
80 }
81 
82 static void ioport_write8(u8 datum, void __iomem *addr)
83 {
84  outb(datum, ADDR2PORT(addr));
85 }
86 
87 static void ioport_write16(u16 datum, void __iomem *addr)
88 {
89  outw(datum, ADDR2PORT(addr));
90 }
91 
92 static void ioport_write32(u32 datum, void __iomem *addr)
93 {
94  outl(datum, ADDR2PORT(addr));
95 }
96 
97 static void ioport_read8r(void __iomem *addr, void *dst, unsigned long count)
98 {
99  insb(ADDR2PORT(addr), dst, count);
100 }
101 
102 static void ioport_read16r(void __iomem *addr, void *dst, unsigned long count)
103 {
104  insw(ADDR2PORT(addr), dst, count);
105 }
106 
107 static void ioport_read32r(void __iomem *addr, void *dst, unsigned long count)
108 {
109  insl(ADDR2PORT(addr), dst, count);
110 }
111 
112 static void ioport_write8r(void __iomem *addr, const void *s, unsigned long n)
113 {
114  outsb(ADDR2PORT(addr), s, n);
115 }
116 
117 static void ioport_write16r(void __iomem *addr, const void *s, unsigned long n)
118 {
119  outsw(ADDR2PORT(addr), s, n);
120 }
121 
122 static void ioport_write32r(void __iomem *addr, const void *s, unsigned long n)
123 {
124  outsl(ADDR2PORT(addr), s, n);
125 }
126 
127 static const struct iomap_ops ioport_ops = {
128  ioport_read8,
129  ioport_read16,
130  ioport_read16,
131  ioport_read32,
132  ioport_read32,
133  ioport_write8,
134  ioport_write16,
135  ioport_write16,
136  ioport_write32,
137  ioport_write32,
138  ioport_read8r,
139  ioport_read16r,
140  ioport_read32r,
141  ioport_write8r,
142  ioport_write16r,
143  ioport_write32r,
144 };
145 
146 /* Legacy I/O memory ops */
147 
148 static unsigned int iomem_read8(void __iomem *addr)
149 {
150  return readb(addr);
151 }
152 
153 static unsigned int iomem_read16(void __iomem *addr)
154 {
155  return readw(addr);
156 }
157 
158 static unsigned int iomem_read16be(void __iomem *addr)
159 {
160  return __raw_readw(addr);
161 }
162 
163 static unsigned int iomem_read32(void __iomem *addr)
164 {
165  return readl(addr);
166 }
167 
168 static unsigned int iomem_read32be(void __iomem *addr)
169 {
170  return __raw_readl(addr);
171 }
172 
173 static void iomem_write8(u8 datum, void __iomem *addr)
174 {
175  writeb(datum, addr);
176 }
177 
178 static void iomem_write16(u16 datum, void __iomem *addr)
179 {
180  writew(datum, addr);
181 }
182 
183 static void iomem_write16be(u16 datum, void __iomem *addr)
184 {
185  __raw_writew(datum, addr);
186 }
187 
188 static void iomem_write32(u32 datum, void __iomem *addr)
189 {
190  writel(datum, addr);
191 }
192 
193 static void iomem_write32be(u32 datum, void __iomem *addr)
194 {
195  __raw_writel(datum, addr);
196 }
197 
198 static void iomem_read8r(void __iomem *addr, void *dst, unsigned long count)
199 {
200  while (count--) {
201  *(u8 *)dst = __raw_readb(addr);
202  dst++;
203  }
204 }
205 
206 static void iomem_read16r(void __iomem *addr, void *dst, unsigned long count)
207 {
208  while (count--) {
209  *(u16 *)dst = __raw_readw(addr);
210  dst += 2;
211  }
212 }
213 
214 static void iomem_read32r(void __iomem *addr, void *dst, unsigned long count)
215 {
216  while (count--) {
217  *(u32 *)dst = __raw_readl(addr);
218  dst += 4;
219  }
220 }
221 
222 static void iomem_write8r(void __iomem *addr, const void *s, unsigned long n)
223 {
224  while (n--) {
225  __raw_writeb(*(u8 *)s, addr);
226  s++;
227  }
228 }
229 
230 static void iomem_write16r(void __iomem *addr, const void *s, unsigned long n)
231 {
232  while (n--) {
233  __raw_writew(*(u16 *)s, addr);
234  s += 2;
235  }
236 }
237 
238 static void iomem_write32r(void __iomem *addr, const void *s, unsigned long n)
239 {
240  while (n--) {
241  __raw_writel(*(u32 *)s, addr);
242  s += 4;
243  }
244 }
245 
246 static const struct iomap_ops iomem_ops = {
247  iomem_read8,
248  iomem_read16,
249  iomem_read16be,
250  iomem_read32,
251  iomem_read32be,
252  iomem_write8,
253  iomem_write16,
254  iomem_write16be,
255  iomem_write32,
256  iomem_write32be,
257  iomem_read8r,
258  iomem_read16r,
259  iomem_read32r,
260  iomem_write8r,
261  iomem_write16r,
262  iomem_write32r,
263 };
264 
265 static const struct iomap_ops *iomap_ops[8] = {
266  [0] = &ioport_ops,
267  [7] = &iomem_ops
268 };
269 
270 
271 unsigned int ioread8(void __iomem *addr)
272 {
273  if (unlikely(INDIRECT_ADDR(addr)))
274  return iomap_ops[ADDR_TO_REGION(addr)]->read8(addr);
275  return *((u8 *)addr);
276 }
277 
278 unsigned int ioread16(void __iomem *addr)
279 {
280  if (unlikely(INDIRECT_ADDR(addr)))
281  return iomap_ops[ADDR_TO_REGION(addr)]->read16(addr);
282  return le16_to_cpup((u16 *)addr);
283 }
284 
285 unsigned int ioread16be(void __iomem *addr)
286 {
287  if (unlikely(INDIRECT_ADDR(addr)))
288  return iomap_ops[ADDR_TO_REGION(addr)]->read16be(addr);
289  return *((u16 *)addr);
290 }
291 
292 unsigned int ioread32(void __iomem *addr)
293 {
294  if (unlikely(INDIRECT_ADDR(addr)))
295  return iomap_ops[ADDR_TO_REGION(addr)]->read32(addr);
296  return le32_to_cpup((u32 *)addr);
297 }
298 
299 unsigned int ioread32be(void __iomem *addr)
300 {
301  if (unlikely(INDIRECT_ADDR(addr)))
302  return iomap_ops[ADDR_TO_REGION(addr)]->read32be(addr);
303  return *((u32 *)addr);
304 }
305 
306 void iowrite8(u8 datum, void __iomem *addr)
307 {
308  if (unlikely(INDIRECT_ADDR(addr))) {
309  iomap_ops[ADDR_TO_REGION(addr)]->write8(datum, addr);
310  } else {
311  *((u8 *)addr) = datum;
312  }
313 }
314 
315 void iowrite16(u16 datum, void __iomem *addr)
316 {
317  if (unlikely(INDIRECT_ADDR(addr))) {
318  iomap_ops[ADDR_TO_REGION(addr)]->write16(datum, addr);
319  } else {
320  *((u16 *)addr) = cpu_to_le16(datum);
321  }
322 }
323 
324 void iowrite16be(u16 datum, void __iomem *addr)
325 {
326  if (unlikely(INDIRECT_ADDR(addr))) {
327  iomap_ops[ADDR_TO_REGION(addr)]->write16be(datum, addr);
328  } else {
329  *((u16 *)addr) = datum;
330  }
331 }
332 
333 void iowrite32(u32 datum, void __iomem *addr)
334 {
335  if (unlikely(INDIRECT_ADDR(addr))) {
336  iomap_ops[ADDR_TO_REGION(addr)]->write32(datum, addr);
337  } else {
338  *((u32 *)addr) = cpu_to_le32(datum);
339  }
340 }
341 
342 void iowrite32be(u32 datum, void __iomem *addr)
343 {
344  if (unlikely(INDIRECT_ADDR(addr))) {
345  iomap_ops[ADDR_TO_REGION(addr)]->write32be(datum, addr);
346  } else {
347  *((u32 *)addr) = datum;
348  }
349 }
350 
351 /* Repeating interfaces */
352 
353 void ioread8_rep(void __iomem *addr, void *dst, unsigned long count)
354 {
355  if (unlikely(INDIRECT_ADDR(addr))) {
356  iomap_ops[ADDR_TO_REGION(addr)]->read8r(addr, dst, count);
357  } else {
358  while (count--) {
359  *(u8 *)dst = *(u8 *)addr;
360  dst++;
361  }
362  }
363 }
364 
365 void ioread16_rep(void __iomem *addr, void *dst, unsigned long count)
366 {
367  if (unlikely(INDIRECT_ADDR(addr))) {
368  iomap_ops[ADDR_TO_REGION(addr)]->read16r(addr, dst, count);
369  } else {
370  while (count--) {
371  *(u16 *)dst = *(u16 *)addr;
372  dst += 2;
373  }
374  }
375 }
376 
377 void ioread32_rep(void __iomem *addr, void *dst, unsigned long count)
378 {
379  if (unlikely(INDIRECT_ADDR(addr))) {
380  iomap_ops[ADDR_TO_REGION(addr)]->read32r(addr, dst, count);
381  } else {
382  while (count--) {
383  *(u32 *)dst = *(u32 *)addr;
384  dst += 4;
385  }
386  }
387 }
388 
389 void iowrite8_rep(void __iomem *addr, const void *src, unsigned long count)
390 {
391  if (unlikely(INDIRECT_ADDR(addr))) {
392  iomap_ops[ADDR_TO_REGION(addr)]->write8r(addr, src, count);
393  } else {
394  while (count--) {
395  *(u8 *)addr = *(u8 *)src;
396  src++;
397  }
398  }
399 }
400 
401 void iowrite16_rep(void __iomem *addr, const void *src, unsigned long count)
402 {
403  if (unlikely(INDIRECT_ADDR(addr))) {
404  iomap_ops[ADDR_TO_REGION(addr)]->write16r(addr, src, count);
405  } else {
406  while (count--) {
407  *(u16 *)addr = *(u16 *)src;
408  src += 2;
409  }
410  }
411 }
412 
413 void iowrite32_rep(void __iomem *addr, const void *src, unsigned long count)
414 {
415  if (unlikely(INDIRECT_ADDR(addr))) {
416  iomap_ops[ADDR_TO_REGION(addr)]->write32r(addr, src, count);
417  } else {
418  while (count--) {
419  *(u32 *)addr = *(u32 *)src;
420  src += 4;
421  }
422  }
423 }
424 
425 /* Mapping interfaces */
426 
427 void __iomem *ioport_map(unsigned long port, unsigned int nr)
428 {
429  return (void __iomem *)(IOPORT_MAP_BASE | port);
430 }
431 
432 void ioport_unmap(void __iomem *addr)
433 {
434  if (!INDIRECT_ADDR(addr)) {
435  iounmap(addr);
436  }
437 }
438 
439 void pci_iounmap(struct pci_dev *dev, void __iomem * addr)
440 {
441  if (!INDIRECT_ADDR(addr)) {
442  iounmap(addr);
443  }
444 }
445