Merge tag 'pci-v4.17-changes' of git://git.kernel.org/pub/scm/linux/kernel/git/helgaa...
[muen/linux.git] / include / asm-generic / io.h
1 /* Generic I/O port emulation.
2  *
3  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
4  * Written by David Howells (dhowells@redhat.com)
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public Licence
8  * as published by the Free Software Foundation; either version
9  * 2 of the Licence, or (at your option) any later version.
10  */
11 #ifndef __ASM_GENERIC_IO_H
12 #define __ASM_GENERIC_IO_H
13
14 #include <asm/page.h> /* I/O is all done through memory accesses */
15 #include <linux/string.h> /* for memset() and memcpy() */
16 #include <linux/types.h>
17
18 #ifdef CONFIG_GENERIC_IOMAP
19 #include <asm-generic/iomap.h>
20 #endif
21
22 #include <asm-generic/pci_iomap.h>
23
24 #ifndef mmiowb
25 #define mmiowb() do {} while (0)
26 #endif
27
28 /*
29  * __raw_{read,write}{b,w,l,q}() access memory in native endianness.
30  *
31  * On some architectures memory mapped IO needs to be accessed differently.
32  * On the simple architectures, we just read/write the memory location
33  * directly.
34  */
35
36 #ifndef __raw_readb
37 #define __raw_readb __raw_readb
38 static inline u8 __raw_readb(const volatile void __iomem *addr)
39 {
40         return *(const volatile u8 __force *)addr;
41 }
42 #endif
43
44 #ifndef __raw_readw
45 #define __raw_readw __raw_readw
46 static inline u16 __raw_readw(const volatile void __iomem *addr)
47 {
48         return *(const volatile u16 __force *)addr;
49 }
50 #endif
51
52 #ifndef __raw_readl
53 #define __raw_readl __raw_readl
54 static inline u32 __raw_readl(const volatile void __iomem *addr)
55 {
56         return *(const volatile u32 __force *)addr;
57 }
58 #endif
59
60 #ifdef CONFIG_64BIT
61 #ifndef __raw_readq
62 #define __raw_readq __raw_readq
63 static inline u64 __raw_readq(const volatile void __iomem *addr)
64 {
65         return *(const volatile u64 __force *)addr;
66 }
67 #endif
68 #endif /* CONFIG_64BIT */
69
70 #ifndef __raw_writeb
71 #define __raw_writeb __raw_writeb
72 static inline void __raw_writeb(u8 value, volatile void __iomem *addr)
73 {
74         *(volatile u8 __force *)addr = value;
75 }
76 #endif
77
78 #ifndef __raw_writew
79 #define __raw_writew __raw_writew
80 static inline void __raw_writew(u16 value, volatile void __iomem *addr)
81 {
82         *(volatile u16 __force *)addr = value;
83 }
84 #endif
85
86 #ifndef __raw_writel
87 #define __raw_writel __raw_writel
88 static inline void __raw_writel(u32 value, volatile void __iomem *addr)
89 {
90         *(volatile u32 __force *)addr = value;
91 }
92 #endif
93
94 #ifdef CONFIG_64BIT
95 #ifndef __raw_writeq
96 #define __raw_writeq __raw_writeq
97 static inline void __raw_writeq(u64 value, volatile void __iomem *addr)
98 {
99         *(volatile u64 __force *)addr = value;
100 }
101 #endif
102 #endif /* CONFIG_64BIT */
103
104 /*
105  * {read,write}{b,w,l,q}() access little endian memory and return result in
106  * native endianness.
107  */
108
109 #ifndef readb
110 #define readb readb
111 static inline u8 readb(const volatile void __iomem *addr)
112 {
113         return __raw_readb(addr);
114 }
115 #endif
116
117 #ifndef readw
118 #define readw readw
119 static inline u16 readw(const volatile void __iomem *addr)
120 {
121         return __le16_to_cpu(__raw_readw(addr));
122 }
123 #endif
124
125 #ifndef readl
126 #define readl readl
127 static inline u32 readl(const volatile void __iomem *addr)
128 {
129         return __le32_to_cpu(__raw_readl(addr));
130 }
131 #endif
132
133 #ifdef CONFIG_64BIT
134 #ifndef readq
135 #define readq readq
136 static inline u64 readq(const volatile void __iomem *addr)
137 {
138         return __le64_to_cpu(__raw_readq(addr));
139 }
140 #endif
141 #endif /* CONFIG_64BIT */
142
143 #ifndef writeb
144 #define writeb writeb
145 static inline void writeb(u8 value, volatile void __iomem *addr)
146 {
147         __raw_writeb(value, addr);
148 }
149 #endif
150
151 #ifndef writew
152 #define writew writew
153 static inline void writew(u16 value, volatile void __iomem *addr)
154 {
155         __raw_writew(cpu_to_le16(value), addr);
156 }
157 #endif
158
159 #ifndef writel
160 #define writel writel
161 static inline void writel(u32 value, volatile void __iomem *addr)
162 {
163         __raw_writel(__cpu_to_le32(value), addr);
164 }
165 #endif
166
167 #ifdef CONFIG_64BIT
168 #ifndef writeq
169 #define writeq writeq
170 static inline void writeq(u64 value, volatile void __iomem *addr)
171 {
172         __raw_writeq(__cpu_to_le64(value), addr);
173 }
174 #endif
175 #endif /* CONFIG_64BIT */
176
177 /*
178  * {read,write}{b,w,l,q}_relaxed() are like the regular version, but
179  * are not guaranteed to provide ordering against spinlocks or memory
180  * accesses.
181  */
182 #ifndef readb_relaxed
183 #define readb_relaxed readb
184 #endif
185
186 #ifndef readw_relaxed
187 #define readw_relaxed readw
188 #endif
189
190 #ifndef readl_relaxed
191 #define readl_relaxed readl
192 #endif
193
194 #if defined(readq) && !defined(readq_relaxed)
195 #define readq_relaxed readq
196 #endif
197
198 #ifndef writeb_relaxed
199 #define writeb_relaxed writeb
200 #endif
201
202 #ifndef writew_relaxed
203 #define writew_relaxed writew
204 #endif
205
206 #ifndef writel_relaxed
207 #define writel_relaxed writel
208 #endif
209
210 #if defined(writeq) && !defined(writeq_relaxed)
211 #define writeq_relaxed writeq
212 #endif
213
214 /*
215  * {read,write}s{b,w,l,q}() repeatedly access the same memory address in
216  * native endianness in 8-, 16-, 32- or 64-bit chunks (@count times).
217  */
218 #ifndef readsb
219 #define readsb readsb
220 static inline void readsb(const volatile void __iomem *addr, void *buffer,
221                           unsigned int count)
222 {
223         if (count) {
224                 u8 *buf = buffer;
225
226                 do {
227                         u8 x = __raw_readb(addr);
228                         *buf++ = x;
229                 } while (--count);
230         }
231 }
232 #endif
233
234 #ifndef readsw
235 #define readsw readsw
236 static inline void readsw(const volatile void __iomem *addr, void *buffer,
237                           unsigned int count)
238 {
239         if (count) {
240                 u16 *buf = buffer;
241
242                 do {
243                         u16 x = __raw_readw(addr);
244                         *buf++ = x;
245                 } while (--count);
246         }
247 }
248 #endif
249
250 #ifndef readsl
251 #define readsl readsl
252 static inline void readsl(const volatile void __iomem *addr, void *buffer,
253                           unsigned int count)
254 {
255         if (count) {
256                 u32 *buf = buffer;
257
258                 do {
259                         u32 x = __raw_readl(addr);
260                         *buf++ = x;
261                 } while (--count);
262         }
263 }
264 #endif
265
266 #ifdef CONFIG_64BIT
267 #ifndef readsq
268 #define readsq readsq
269 static inline void readsq(const volatile void __iomem *addr, void *buffer,
270                           unsigned int count)
271 {
272         if (count) {
273                 u64 *buf = buffer;
274
275                 do {
276                         u64 x = __raw_readq(addr);
277                         *buf++ = x;
278                 } while (--count);
279         }
280 }
281 #endif
282 #endif /* CONFIG_64BIT */
283
284 #ifndef writesb
285 #define writesb writesb
286 static inline void writesb(volatile void __iomem *addr, const void *buffer,
287                            unsigned int count)
288 {
289         if (count) {
290                 const u8 *buf = buffer;
291
292                 do {
293                         __raw_writeb(*buf++, addr);
294                 } while (--count);
295         }
296 }
297 #endif
298
299 #ifndef writesw
300 #define writesw writesw
301 static inline void writesw(volatile void __iomem *addr, const void *buffer,
302                            unsigned int count)
303 {
304         if (count) {
305                 const u16 *buf = buffer;
306
307                 do {
308                         __raw_writew(*buf++, addr);
309                 } while (--count);
310         }
311 }
312 #endif
313
314 #ifndef writesl
315 #define writesl writesl
316 static inline void writesl(volatile void __iomem *addr, const void *buffer,
317                            unsigned int count)
318 {
319         if (count) {
320                 const u32 *buf = buffer;
321
322                 do {
323                         __raw_writel(*buf++, addr);
324                 } while (--count);
325         }
326 }
327 #endif
328
329 #ifdef CONFIG_64BIT
330 #ifndef writesq
331 #define writesq writesq
332 static inline void writesq(volatile void __iomem *addr, const void *buffer,
333                            unsigned int count)
334 {
335         if (count) {
336                 const u64 *buf = buffer;
337
338                 do {
339                         __raw_writeq(*buf++, addr);
340                 } while (--count);
341         }
342 }
343 #endif
344 #endif /* CONFIG_64BIT */
345
346 #ifndef PCI_IOBASE
347 #define PCI_IOBASE ((void __iomem *)0)
348 #endif
349
350 #ifndef IO_SPACE_LIMIT
351 #define IO_SPACE_LIMIT 0xffff
352 #endif
353
354 #include <linux/logic_pio.h>
355
356 /*
357  * {in,out}{b,w,l}() access little endian I/O. {in,out}{b,w,l}_p() can be
358  * implemented on hardware that needs an additional delay for I/O accesses to
359  * take effect.
360  */
361
362 #ifndef inb
363 #define inb inb
364 static inline u8 inb(unsigned long addr)
365 {
366         return readb(PCI_IOBASE + addr);
367 }
368 #endif
369
370 #ifndef inw
371 #define inw inw
372 static inline u16 inw(unsigned long addr)
373 {
374         return readw(PCI_IOBASE + addr);
375 }
376 #endif
377
378 #ifndef inl
379 #define inl inl
380 static inline u32 inl(unsigned long addr)
381 {
382         return readl(PCI_IOBASE + addr);
383 }
384 #endif
385
386 #ifndef outb
387 #define outb outb
388 static inline void outb(u8 value, unsigned long addr)
389 {
390         writeb(value, PCI_IOBASE + addr);
391 }
392 #endif
393
394 #ifndef outw
395 #define outw outw
396 static inline void outw(u16 value, unsigned long addr)
397 {
398         writew(value, PCI_IOBASE + addr);
399 }
400 #endif
401
402 #ifndef outl
403 #define outl outl
404 static inline void outl(u32 value, unsigned long addr)
405 {
406         writel(value, PCI_IOBASE + addr);
407 }
408 #endif
409
410 #ifndef inb_p
411 #define inb_p inb_p
412 static inline u8 inb_p(unsigned long addr)
413 {
414         return inb(addr);
415 }
416 #endif
417
418 #ifndef inw_p
419 #define inw_p inw_p
420 static inline u16 inw_p(unsigned long addr)
421 {
422         return inw(addr);
423 }
424 #endif
425
426 #ifndef inl_p
427 #define inl_p inl_p
428 static inline u32 inl_p(unsigned long addr)
429 {
430         return inl(addr);
431 }
432 #endif
433
434 #ifndef outb_p
435 #define outb_p outb_p
436 static inline void outb_p(u8 value, unsigned long addr)
437 {
438         outb(value, addr);
439 }
440 #endif
441
442 #ifndef outw_p
443 #define outw_p outw_p
444 static inline void outw_p(u16 value, unsigned long addr)
445 {
446         outw(value, addr);
447 }
448 #endif
449
450 #ifndef outl_p
451 #define outl_p outl_p
452 static inline void outl_p(u32 value, unsigned long addr)
453 {
454         outl(value, addr);
455 }
456 #endif
457
458 /*
459  * {in,out}s{b,w,l}{,_p}() are variants of the above that repeatedly access a
460  * single I/O port multiple times.
461  */
462
463 #ifndef insb
464 #define insb insb
465 static inline void insb(unsigned long addr, void *buffer, unsigned int count)
466 {
467         readsb(PCI_IOBASE + addr, buffer, count);
468 }
469 #endif
470
471 #ifndef insw
472 #define insw insw
473 static inline void insw(unsigned long addr, void *buffer, unsigned int count)
474 {
475         readsw(PCI_IOBASE + addr, buffer, count);
476 }
477 #endif
478
479 #ifndef insl
480 #define insl insl
481 static inline void insl(unsigned long addr, void *buffer, unsigned int count)
482 {
483         readsl(PCI_IOBASE + addr, buffer, count);
484 }
485 #endif
486
487 #ifndef outsb
488 #define outsb outsb
489 static inline void outsb(unsigned long addr, const void *buffer,
490                          unsigned int count)
491 {
492         writesb(PCI_IOBASE + addr, buffer, count);
493 }
494 #endif
495
496 #ifndef outsw
497 #define outsw outsw
498 static inline void outsw(unsigned long addr, const void *buffer,
499                          unsigned int count)
500 {
501         writesw(PCI_IOBASE + addr, buffer, count);
502 }
503 #endif
504
505 #ifndef outsl
506 #define outsl outsl
507 static inline void outsl(unsigned long addr, const void *buffer,
508                          unsigned int count)
509 {
510         writesl(PCI_IOBASE + addr, buffer, count);
511 }
512 #endif
513
514 #ifndef insb_p
515 #define insb_p insb_p
516 static inline void insb_p(unsigned long addr, void *buffer, unsigned int count)
517 {
518         insb(addr, buffer, count);
519 }
520 #endif
521
522 #ifndef insw_p
523 #define insw_p insw_p
524 static inline void insw_p(unsigned long addr, void *buffer, unsigned int count)
525 {
526         insw(addr, buffer, count);
527 }
528 #endif
529
530 #ifndef insl_p
531 #define insl_p insl_p
532 static inline void insl_p(unsigned long addr, void *buffer, unsigned int count)
533 {
534         insl(addr, buffer, count);
535 }
536 #endif
537
538 #ifndef outsb_p
539 #define outsb_p outsb_p
540 static inline void outsb_p(unsigned long addr, const void *buffer,
541                            unsigned int count)
542 {
543         outsb(addr, buffer, count);
544 }
545 #endif
546
547 #ifndef outsw_p
548 #define outsw_p outsw_p
549 static inline void outsw_p(unsigned long addr, const void *buffer,
550                            unsigned int count)
551 {
552         outsw(addr, buffer, count);
553 }
554 #endif
555
556 #ifndef outsl_p
557 #define outsl_p outsl_p
558 static inline void outsl_p(unsigned long addr, const void *buffer,
559                            unsigned int count)
560 {
561         outsl(addr, buffer, count);
562 }
563 #endif
564
565 #ifndef CONFIG_GENERIC_IOMAP
566 #ifndef ioread8
567 #define ioread8 ioread8
568 static inline u8 ioread8(const volatile void __iomem *addr)
569 {
570         return readb(addr);
571 }
572 #endif
573
574 #ifndef ioread16
575 #define ioread16 ioread16
576 static inline u16 ioread16(const volatile void __iomem *addr)
577 {
578         return readw(addr);
579 }
580 #endif
581
582 #ifndef ioread32
583 #define ioread32 ioread32
584 static inline u32 ioread32(const volatile void __iomem *addr)
585 {
586         return readl(addr);
587 }
588 #endif
589
590 #ifdef CONFIG_64BIT
591 #ifndef ioread64
592 #define ioread64 ioread64
593 static inline u64 ioread64(const volatile void __iomem *addr)
594 {
595         return readq(addr);
596 }
597 #endif
598 #endif /* CONFIG_64BIT */
599
600 #ifndef iowrite8
601 #define iowrite8 iowrite8
602 static inline void iowrite8(u8 value, volatile void __iomem *addr)
603 {
604         writeb(value, addr);
605 }
606 #endif
607
608 #ifndef iowrite16
609 #define iowrite16 iowrite16
610 static inline void iowrite16(u16 value, volatile void __iomem *addr)
611 {
612         writew(value, addr);
613 }
614 #endif
615
616 #ifndef iowrite32
617 #define iowrite32 iowrite32
618 static inline void iowrite32(u32 value, volatile void __iomem *addr)
619 {
620         writel(value, addr);
621 }
622 #endif
623
624 #ifdef CONFIG_64BIT
625 #ifndef iowrite64
626 #define iowrite64 iowrite64
627 static inline void iowrite64(u64 value, volatile void __iomem *addr)
628 {
629         writeq(value, addr);
630 }
631 #endif
632 #endif /* CONFIG_64BIT */
633
634 #ifndef ioread16be
635 #define ioread16be ioread16be
636 static inline u16 ioread16be(const volatile void __iomem *addr)
637 {
638         return swab16(readw(addr));
639 }
640 #endif
641
642 #ifndef ioread32be
643 #define ioread32be ioread32be
644 static inline u32 ioread32be(const volatile void __iomem *addr)
645 {
646         return swab32(readl(addr));
647 }
648 #endif
649
650 #ifdef CONFIG_64BIT
651 #ifndef ioread64be
652 #define ioread64be ioread64be
653 static inline u64 ioread64be(const volatile void __iomem *addr)
654 {
655         return swab64(readq(addr));
656 }
657 #endif
658 #endif /* CONFIG_64BIT */
659
660 #ifndef iowrite16be
661 #define iowrite16be iowrite16be
662 static inline void iowrite16be(u16 value, void volatile __iomem *addr)
663 {
664         writew(swab16(value), addr);
665 }
666 #endif
667
668 #ifndef iowrite32be
669 #define iowrite32be iowrite32be
670 static inline void iowrite32be(u32 value, volatile void __iomem *addr)
671 {
672         writel(swab32(value), addr);
673 }
674 #endif
675
676 #ifdef CONFIG_64BIT
677 #ifndef iowrite64be
678 #define iowrite64be iowrite64be
679 static inline void iowrite64be(u64 value, volatile void __iomem *addr)
680 {
681         writeq(swab64(value), addr);
682 }
683 #endif
684 #endif /* CONFIG_64BIT */
685
686 #ifndef ioread8_rep
687 #define ioread8_rep ioread8_rep
688 static inline void ioread8_rep(const volatile void __iomem *addr, void *buffer,
689                                unsigned int count)
690 {
691         readsb(addr, buffer, count);
692 }
693 #endif
694
695 #ifndef ioread16_rep
696 #define ioread16_rep ioread16_rep
697 static inline void ioread16_rep(const volatile void __iomem *addr,
698                                 void *buffer, unsigned int count)
699 {
700         readsw(addr, buffer, count);
701 }
702 #endif
703
704 #ifndef ioread32_rep
705 #define ioread32_rep ioread32_rep
706 static inline void ioread32_rep(const volatile void __iomem *addr,
707                                 void *buffer, unsigned int count)
708 {
709         readsl(addr, buffer, count);
710 }
711 #endif
712
713 #ifdef CONFIG_64BIT
714 #ifndef ioread64_rep
715 #define ioread64_rep ioread64_rep
716 static inline void ioread64_rep(const volatile void __iomem *addr,
717                                 void *buffer, unsigned int count)
718 {
719         readsq(addr, buffer, count);
720 }
721 #endif
722 #endif /* CONFIG_64BIT */
723
724 #ifndef iowrite8_rep
725 #define iowrite8_rep iowrite8_rep
726 static inline void iowrite8_rep(volatile void __iomem *addr,
727                                 const void *buffer,
728                                 unsigned int count)
729 {
730         writesb(addr, buffer, count);
731 }
732 #endif
733
734 #ifndef iowrite16_rep
735 #define iowrite16_rep iowrite16_rep
736 static inline void iowrite16_rep(volatile void __iomem *addr,
737                                  const void *buffer,
738                                  unsigned int count)
739 {
740         writesw(addr, buffer, count);
741 }
742 #endif
743
744 #ifndef iowrite32_rep
745 #define iowrite32_rep iowrite32_rep
746 static inline void iowrite32_rep(volatile void __iomem *addr,
747                                  const void *buffer,
748                                  unsigned int count)
749 {
750         writesl(addr, buffer, count);
751 }
752 #endif
753
754 #ifdef CONFIG_64BIT
755 #ifndef iowrite64_rep
756 #define iowrite64_rep iowrite64_rep
757 static inline void iowrite64_rep(volatile void __iomem *addr,
758                                  const void *buffer,
759                                  unsigned int count)
760 {
761         writesq(addr, buffer, count);
762 }
763 #endif
764 #endif /* CONFIG_64BIT */
765 #endif /* CONFIG_GENERIC_IOMAP */
766
767 #ifdef __KERNEL__
768
769 #include <linux/vmalloc.h>
770 #define __io_virt(x) ((void __force *)(x))
771
772 #ifndef CONFIG_GENERIC_IOMAP
773 struct pci_dev;
774 extern void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long max);
775
776 #ifndef pci_iounmap
777 #define pci_iounmap pci_iounmap
778 static inline void pci_iounmap(struct pci_dev *dev, void __iomem *p)
779 {
780 }
781 #endif
782 #endif /* CONFIG_GENERIC_IOMAP */
783
784 /*
785  * Change virtual addresses to physical addresses and vv.
786  * These are pretty trivial
787  */
788 #ifndef virt_to_phys
789 #define virt_to_phys virt_to_phys
790 static inline unsigned long virt_to_phys(volatile void *address)
791 {
792         return __pa((unsigned long)address);
793 }
794 #endif
795
796 #ifndef phys_to_virt
797 #define phys_to_virt phys_to_virt
798 static inline void *phys_to_virt(unsigned long address)
799 {
800         return __va(address);
801 }
802 #endif
803
804 /**
805  * DOC: ioremap() and ioremap_*() variants
806  *
807  * If you have an IOMMU your architecture is expected to have both ioremap()
808  * and iounmap() implemented otherwise the asm-generic helpers will provide a
809  * direct mapping.
810  *
811  * There are ioremap_*() call variants, if you have no IOMMU we naturally will
812  * default to direct mapping for all of them, you can override these defaults.
813  * If you have an IOMMU you are highly encouraged to provide your own
814  * ioremap variant implementation as there currently is no safe architecture
815  * agnostic default. To avoid possible improper behaviour default asm-generic
816  * ioremap_*() variants all return NULL when an IOMMU is available. If you've
817  * defined your own ioremap_*() variant you must then declare your own
818  * ioremap_*() variant as defined to itself to avoid the default NULL return.
819  */
820
821 #ifdef CONFIG_MMU
822
823 #ifndef ioremap_uc
824 #define ioremap_uc ioremap_uc
825 static inline void __iomem *ioremap_uc(phys_addr_t offset, size_t size)
826 {
827         return NULL;
828 }
829 #endif
830
831 #else /* !CONFIG_MMU */
832
833 /*
834  * Change "struct page" to physical address.
835  *
836  * This implementation is for the no-MMU case only... if you have an MMU
837  * you'll need to provide your own definitions.
838  */
839
840 #ifndef ioremap
841 #define ioremap ioremap
842 static inline void __iomem *ioremap(phys_addr_t offset, size_t size)
843 {
844         return (void __iomem *)(unsigned long)offset;
845 }
846 #endif
847
848 #ifndef __ioremap
849 #define __ioremap __ioremap
850 static inline void __iomem *__ioremap(phys_addr_t offset, size_t size,
851                                       unsigned long flags)
852 {
853         return ioremap(offset, size);
854 }
855 #endif
856
857 #ifndef iounmap
858 #define iounmap iounmap
859
860 static inline void iounmap(void __iomem *addr)
861 {
862 }
863 #endif
864 #endif /* CONFIG_MMU */
865 #ifndef ioremap_nocache
866 void __iomem *ioremap(phys_addr_t phys_addr, size_t size);
867 #define ioremap_nocache ioremap_nocache
868 static inline void __iomem *ioremap_nocache(phys_addr_t offset, size_t size)
869 {
870         return ioremap(offset, size);
871 }
872 #endif
873
874 #ifndef ioremap_uc
875 #define ioremap_uc ioremap_uc
876 static inline void __iomem *ioremap_uc(phys_addr_t offset, size_t size)
877 {
878         return ioremap_nocache(offset, size);
879 }
880 #endif
881
882 #ifndef ioremap_wc
883 #define ioremap_wc ioremap_wc
884 static inline void __iomem *ioremap_wc(phys_addr_t offset, size_t size)
885 {
886         return ioremap_nocache(offset, size);
887 }
888 #endif
889
890 #ifndef ioremap_wt
891 #define ioremap_wt ioremap_wt
892 static inline void __iomem *ioremap_wt(phys_addr_t offset, size_t size)
893 {
894         return ioremap_nocache(offset, size);
895 }
896 #endif
897
898 #ifdef CONFIG_HAS_IOPORT_MAP
899 #ifndef CONFIG_GENERIC_IOMAP
900 #ifndef ioport_map
901 #define ioport_map ioport_map
902 static inline void __iomem *ioport_map(unsigned long port, unsigned int nr)
903 {
904         return PCI_IOBASE + (port & MMIO_UPPER_LIMIT);
905 }
906 #endif
907
908 #ifndef ioport_unmap
909 #define ioport_unmap ioport_unmap
910 static inline void ioport_unmap(void __iomem *p)
911 {
912 }
913 #endif
914 #else /* CONFIG_GENERIC_IOMAP */
915 extern void __iomem *ioport_map(unsigned long port, unsigned int nr);
916 extern void ioport_unmap(void __iomem *p);
917 #endif /* CONFIG_GENERIC_IOMAP */
918 #endif /* CONFIG_HAS_IOPORT_MAP */
919
920 /*
921  * Convert a virtual cached pointer to an uncached pointer
922  */
923 #ifndef xlate_dev_kmem_ptr
924 #define xlate_dev_kmem_ptr xlate_dev_kmem_ptr
925 static inline void *xlate_dev_kmem_ptr(void *addr)
926 {
927         return addr;
928 }
929 #endif
930
931 #ifndef xlate_dev_mem_ptr
932 #define xlate_dev_mem_ptr xlate_dev_mem_ptr
933 static inline void *xlate_dev_mem_ptr(phys_addr_t addr)
934 {
935         return __va(addr);
936 }
937 #endif
938
939 #ifndef unxlate_dev_mem_ptr
940 #define unxlate_dev_mem_ptr unxlate_dev_mem_ptr
941 static inline void unxlate_dev_mem_ptr(phys_addr_t phys, void *addr)
942 {
943 }
944 #endif
945
946 #ifdef CONFIG_VIRT_TO_BUS
947 #ifndef virt_to_bus
948 static inline unsigned long virt_to_bus(void *address)
949 {
950         return (unsigned long)address;
951 }
952
953 static inline void *bus_to_virt(unsigned long address)
954 {
955         return (void *)address;
956 }
957 #endif
958 #endif
959
960 #ifndef memset_io
961 #define memset_io memset_io
962 /**
963  * memset_io    Set a range of I/O memory to a constant value
964  * @addr:       The beginning of the I/O-memory range to set
965  * @val:        The value to set the memory to
966  * @count:      The number of bytes to set
967  *
968  * Set a range of I/O memory to a given value.
969  */
970 static inline void memset_io(volatile void __iomem *addr, int value,
971                              size_t size)
972 {
973         memset(__io_virt(addr), value, size);
974 }
975 #endif
976
977 #ifndef memcpy_fromio
978 #define memcpy_fromio memcpy_fromio
979 /**
980  * memcpy_fromio        Copy a block of data from I/O memory
981  * @dst:                The (RAM) destination for the copy
982  * @src:                The (I/O memory) source for the data
983  * @count:              The number of bytes to copy
984  *
985  * Copy a block of data from I/O memory.
986  */
987 static inline void memcpy_fromio(void *buffer,
988                                  const volatile void __iomem *addr,
989                                  size_t size)
990 {
991         memcpy(buffer, __io_virt(addr), size);
992 }
993 #endif
994
995 #ifndef memcpy_toio
996 #define memcpy_toio memcpy_toio
997 /**
998  * memcpy_toio          Copy a block of data into I/O memory
999  * @dst:                The (I/O memory) destination for the copy
1000  * @src:                The (RAM) source for the data
1001  * @count:              The number of bytes to copy
1002  *
1003  * Copy a block of data to I/O memory.
1004  */
1005 static inline void memcpy_toio(volatile void __iomem *addr, const void *buffer,
1006                                size_t size)
1007 {
1008         memcpy(__io_virt(addr), buffer, size);
1009 }
1010 #endif
1011
1012 #endif /* __KERNEL__ */
1013
1014 #endif /* __ASM_GENERIC_IO_H */