io.h 18.3 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14
/* Generic I/O port emulation, based on MN10300 code
 *
 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public Licence
 * as published by the Free Software Foundation; either version
 * 2 of the Licence, or (at your option) any later version.
 */
#ifndef __ASM_GENERIC_IO_H
#define __ASM_GENERIC_IO_H

#include <asm/page.h> /* I/O is all done through memory accesses */
15
#include <linux/string.h> /* for memset() and memcpy() */
16 17 18 19 20 21
#include <linux/types.h>

#ifdef CONFIG_GENERIC_IOMAP
#include <asm-generic/iomap.h>
#endif

22 23
#include <asm-generic/pci_iomap.h>

24
#ifndef mmiowb
25
#define mmiowb() do {} while (0)
26
#endif
27 28

/*
29 30 31 32 33
 * __raw_{read,write}{b,w,l,q}() access memory in native endianness.
 *
 * On some architectures memory mapped IO needs to be accessed differently.
 * On the simple architectures, we just read/write the memory location
 * directly.
34
 */
35

36
#ifndef __raw_readb
37
#define __raw_readb __raw_readb
38 39
static inline u8 __raw_readb(const volatile void __iomem *addr)
{
40
	return *(const volatile u8 __force *)addr;
41
}
42
#endif
43

44
#ifndef __raw_readw
45
#define __raw_readw __raw_readw
46 47
static inline u16 __raw_readw(const volatile void __iomem *addr)
{
48
	return *(const volatile u16 __force *)addr;
49
}
50
#endif
51

52
#ifndef __raw_readl
53
#define __raw_readl __raw_readl
54 55
static inline u32 __raw_readl(const volatile void __iomem *addr)
{
56
	return *(const volatile u32 __force *)addr;
57
}
58
#endif
59

60 61 62 63
#ifdef CONFIG_64BIT
#ifndef __raw_readq
#define __raw_readq __raw_readq
static inline u64 __raw_readq(const volatile void __iomem *addr)
64
{
65
	return *(const volatile u64 __force *)addr;
66
}
67 68
#endif
#endif /* CONFIG_64BIT */
69

70
#ifndef __raw_writeb
71 72
#define __raw_writeb __raw_writeb
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 80
#define __raw_writew __raw_writew
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 88
#define __raw_writel __raw_writel
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 96 97
#ifndef __raw_writeq
#define __raw_writeq __raw_writeq
static inline void __raw_writeq(u64 value, volatile void __iomem *addr)
98
{
99
	*(volatile u64 __force *)addr = value;
100
}
Jan Glauber's avatar
Jan Glauber committed
101
#endif
102
#endif /* CONFIG_64BIT */
Jan Glauber's avatar
Jan Glauber committed
103

104 105 106 107
/*
 * {read,write}{b,w,l,q}() access little endian memory and return result in
 * native endianness.
 */
108

109 110 111
#ifndef readb
#define readb readb
static inline u8 readb(const volatile void __iomem *addr)
112
{
113
	return __raw_readb(addr);
114 115 116
}
#endif

117 118 119 120 121 122
#ifndef readw
#define readw readw
static inline u16 readw(const volatile void __iomem *addr)
{
	return __le16_to_cpu(__raw_readw(addr));
}
123 124
#endif

125 126 127
#ifndef readl
#define readl readl
static inline u32 readl(const volatile void __iomem *addr)
128
{
129
	return __le32_to_cpu(__raw_readl(addr));
130
}
131
#endif
132

133 134 135 136
#ifdef CONFIG_64BIT
#ifndef readq
#define readq readq
static inline u64 readq(const volatile void __iomem *addr)
137
{
138
	return __le64_to_cpu(__raw_readq(addr));
139
}
140 141
#endif
#endif /* CONFIG_64BIT */
142

143 144 145
#ifndef writeb
#define writeb writeb
static inline void writeb(u8 value, volatile void __iomem *addr)
146
{
147
	__raw_writeb(value, addr);
148
}
149
#endif
150

151 152 153
#ifndef writew
#define writew writew
static inline void writew(u16 value, volatile void __iomem *addr)
154
{
155
	__raw_writew(cpu_to_le16(value), addr);
156
}
157
#endif
158

159 160 161
#ifndef writel
#define writel writel
static inline void writel(u32 value, volatile void __iomem *addr)
162
{
163
	__raw_writel(__cpu_to_le32(value), addr);
164
}
165
#endif
166

167 168 169 170
#ifdef CONFIG_64BIT
#ifndef writeq
#define writeq writeq
static inline void writeq(u64 value, volatile void __iomem *addr)
171
{
172
	__raw_writeq(__cpu_to_le64(value), addr);
173
}
174 175
#endif
#endif /* CONFIG_64BIT */
176

177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193
/*
 * {read,write}{b,w,l,q}_relaxed() are like the regular version, but
 * are not guaranteed to provide ordering against spinlocks or memory
 * accesses.
 */
#ifndef readb_relaxed
#define readb_relaxed readb
#endif

#ifndef readw_relaxed
#define readw_relaxed readw
#endif

#ifndef readl_relaxed
#define readl_relaxed readl
#endif

194
#if defined(readq) && !defined(readq_relaxed)
195 196 197
#define readq_relaxed readq
#endif

198 199 200 201 202 203 204 205 206 207 208
#ifndef writeb_relaxed
#define writeb_relaxed writeb
#endif

#ifndef writew_relaxed
#define writew_relaxed writew
#endif

#ifndef writel_relaxed
#define writel_relaxed writel
#endif
209

210
#if defined(writeq) && !defined(writeq_relaxed)
211 212 213
#define writeq_relaxed writeq
#endif

214 215 216 217 218 219 220 221
/*
 * {read,write}s{b,w,l,q}() repeatedly access the same memory address in
 * native endianness in 8-, 16-, 32- or 64-bit chunks (@count times).
 */
#ifndef readsb
#define readsb readsb
static inline void readsb(const volatile void __iomem *addr, void *buffer,
			  unsigned int count)
222 223 224
{
	if (count) {
		u8 *buf = buffer;
225

226
		do {
227
			u8 x = __raw_readb(addr);
228 229 230 231
			*buf++ = x;
		} while (--count);
	}
}
232
#endif
233

234 235 236 237
#ifndef readsw
#define readsw readsw
static inline void readsw(const volatile void __iomem *addr, void *buffer,
			  unsigned int count)
238 239 240
{
	if (count) {
		u16 *buf = buffer;
241

242
		do {
243
			u16 x = __raw_readw(addr);
244 245 246 247
			*buf++ = x;
		} while (--count);
	}
}
248
#endif
249

250 251 252 253
#ifndef readsl
#define readsl readsl
static inline void readsl(const volatile void __iomem *addr, void *buffer,
			  unsigned int count)
254 255 256
{
	if (count) {
		u32 *buf = buffer;
257

258
		do {
259
			u32 x = __raw_readl(addr);
260 261 262 263
			*buf++ = x;
		} while (--count);
	}
}
264
#endif
265

266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
#ifdef CONFIG_64BIT
#ifndef readsq
#define readsq readsq
static inline void readsq(const volatile void __iomem *addr, void *buffer,
			  unsigned int count)
{
	if (count) {
		u64 *buf = buffer;

		do {
			u64 x = __raw_readq(addr);
			*buf++ = x;
		} while (--count);
	}
}
#endif
#endif /* CONFIG_64BIT */

#ifndef writesb
#define writesb writesb
static inline void writesb(volatile void __iomem *addr, const void *buffer,
			   unsigned int count)
288 289 290
{
	if (count) {
		const u8 *buf = buffer;
291

292
		do {
293
			__raw_writeb(*buf++, addr);
294 295 296
		} while (--count);
	}
}
297
#endif
298

299 300 301 302
#ifndef writesw
#define writesw writesw
static inline void writesw(volatile void __iomem *addr, const void *buffer,
			   unsigned int count)
303 304 305
{
	if (count) {
		const u16 *buf = buffer;
306

307
		do {
308
			__raw_writew(*buf++, addr);
309 310 311
		} while (--count);
	}
}
312
#endif
313

314 315 316 317
#ifndef writesl
#define writesl writesl
static inline void writesl(volatile void __iomem *addr, const void *buffer,
			   unsigned int count)
318 319 320
{
	if (count) {
		const u32 *buf = buffer;
321

322
		do {
323
			__raw_writel(*buf++, addr);
324 325 326
		} while (--count);
	}
}
327
#endif
328

329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344
#ifdef CONFIG_64BIT
#ifndef writesq
#define writesq writesq
static inline void writesq(volatile void __iomem *addr, const void *buffer,
			   unsigned int count)
{
	if (count) {
		const u64 *buf = buffer;

		do {
			__raw_writeq(*buf++, addr);
		} while (--count);
	}
}
#endif
#endif /* CONFIG_64BIT */
345

346 347 348 349
#ifndef PCI_IOBASE
#define PCI_IOBASE ((void __iomem *)0)
#endif

350 351 352
#ifndef IO_SPACE_LIMIT
#define IO_SPACE_LIMIT 0xffff
#endif
353

354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455
/*
 * {in,out}{b,w,l}() access little endian I/O. {in,out}{b,w,l}_p() can be
 * implemented on hardware that needs an additional delay for I/O accesses to
 * take effect.
 */

#ifndef inb
#define inb inb
static inline u8 inb(unsigned long addr)
{
	return readb(PCI_IOBASE + addr);
}
#endif

#ifndef inw
#define inw inw
static inline u16 inw(unsigned long addr)
{
	return readw(PCI_IOBASE + addr);
}
#endif

#ifndef inl
#define inl inl
static inline u32 inl(unsigned long addr)
{
	return readl(PCI_IOBASE + addr);
}
#endif

#ifndef outb
#define outb outb
static inline void outb(u8 value, unsigned long addr)
{
	writeb(value, PCI_IOBASE + addr);
}
#endif

#ifndef outw
#define outw outw
static inline void outw(u16 value, unsigned long addr)
{
	writew(value, PCI_IOBASE + addr);
}
#endif

#ifndef outl
#define outl outl
static inline void outl(u32 value, unsigned long addr)
{
	writel(value, PCI_IOBASE + addr);
}
#endif

#ifndef inb_p
#define inb_p inb_p
static inline u8 inb_p(unsigned long addr)
{
	return inb(addr);
}
#endif

#ifndef inw_p
#define inw_p inw_p
static inline u16 inw_p(unsigned long addr)
{
	return inw(addr);
}
#endif

#ifndef inl_p
#define inl_p inl_p
static inline u32 inl_p(unsigned long addr)
{
	return inl(addr);
}
#endif

#ifndef outb_p
#define outb_p outb_p
static inline void outb_p(u8 value, unsigned long addr)
{
	outb(value, addr);
}
#endif

#ifndef outw_p
#define outw_p outw_p
static inline void outw_p(u16 value, unsigned long addr)
{
	outw(value, addr);
}
#endif

#ifndef outl_p
#define outl_p outl_p
static inline void outl_p(u32 value, unsigned long addr)
{
	outl(value, addr);
}
#endif

456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562
/*
 * {in,out}s{b,w,l}{,_p}() are variants of the above that repeatedly access a
 * single I/O port multiple times.
 */

#ifndef insb
#define insb insb
static inline void insb(unsigned long addr, void *buffer, unsigned int count)
{
	readsb(PCI_IOBASE + addr, buffer, count);
}
#endif

#ifndef insw
#define insw insw
static inline void insw(unsigned long addr, void *buffer, unsigned int count)
{
	readsw(PCI_IOBASE + addr, buffer, count);
}
#endif

#ifndef insl
#define insl insl
static inline void insl(unsigned long addr, void *buffer, unsigned int count)
{
	readsl(PCI_IOBASE + addr, buffer, count);
}
#endif

#ifndef outsb
#define outsb outsb
static inline void outsb(unsigned long addr, const void *buffer,
			 unsigned int count)
{
	writesb(PCI_IOBASE + addr, buffer, count);
}
#endif

#ifndef outsw
#define outsw outsw
static inline void outsw(unsigned long addr, const void *buffer,
			 unsigned int count)
{
	writesw(PCI_IOBASE + addr, buffer, count);
}
#endif

#ifndef outsl
#define outsl outsl
static inline void outsl(unsigned long addr, const void *buffer,
			 unsigned int count)
{
	writesl(PCI_IOBASE + addr, buffer, count);
}
#endif

#ifndef insb_p
#define insb_p insb_p
static inline void insb_p(unsigned long addr, void *buffer, unsigned int count)
{
	insb(addr, buffer, count);
}
#endif

#ifndef insw_p
#define insw_p insw_p
static inline void insw_p(unsigned long addr, void *buffer, unsigned int count)
{
	insw(addr, buffer, count);
}
#endif

#ifndef insl_p
#define insl_p insl_p
static inline void insl_p(unsigned long addr, void *buffer, unsigned int count)
{
	insl(addr, buffer, count);
}
#endif

#ifndef outsb_p
#define outsb_p outsb_p
static inline void outsb_p(unsigned long addr, const void *buffer,
			   unsigned int count)
{
	outsb(addr, buffer, count);
}
#endif

#ifndef outsw_p
#define outsw_p outsw_p
static inline void outsw_p(unsigned long addr, const void *buffer,
			   unsigned int count)
{
	outsw(addr, buffer, count);
}
#endif

#ifndef outsl_p
#define outsl_p outsl_p
static inline void outsl_p(unsigned long addr, const void *buffer,
			   unsigned int count)
{
	outsl(addr, buffer, count);
}
#endif

563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642
#ifndef CONFIG_GENERIC_IOMAP
#ifndef ioread8
#define ioread8 ioread8
static inline u8 ioread8(const volatile void __iomem *addr)
{
	return readb(addr);
}
#endif

#ifndef ioread16
#define ioread16 ioread16
static inline u16 ioread16(const volatile void __iomem *addr)
{
	return readw(addr);
}
#endif

#ifndef ioread32
#define ioread32 ioread32
static inline u32 ioread32(const volatile void __iomem *addr)
{
	return readl(addr);
}
#endif

#ifndef iowrite8
#define iowrite8 iowrite8
static inline void iowrite8(u8 value, volatile void __iomem *addr)
{
	writeb(value, addr);
}
#endif

#ifndef iowrite16
#define iowrite16 iowrite16
static inline void iowrite16(u16 value, volatile void __iomem *addr)
{
	writew(value, addr);
}
#endif

#ifndef iowrite32
#define iowrite32 iowrite32
static inline void iowrite32(u32 value, volatile void __iomem *addr)
{
	writel(value, addr);
}
#endif

#ifndef ioread16be
#define ioread16be ioread16be
static inline u16 ioread16be(const volatile void __iomem *addr)
{
	return __be16_to_cpu(__raw_readw(addr));
}
#endif

#ifndef ioread32be
#define ioread32be ioread32be
static inline u32 ioread32be(const volatile void __iomem *addr)
{
	return __be32_to_cpu(__raw_readl(addr));
}
#endif

#ifndef iowrite16be
#define iowrite16be iowrite16be
static inline void iowrite16be(u16 value, void volatile __iomem *addr)
{
	__raw_writew(__cpu_to_be16(value), addr);
}
#endif

#ifndef iowrite32be
#define iowrite32be iowrite32be
static inline void iowrite32be(u32 value, volatile void __iomem *addr)
{
	__raw_writel(__cpu_to_be32(value), addr);
}
#endif
643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699

#ifndef ioread8_rep
#define ioread8_rep ioread8_rep
static inline void ioread8_rep(const volatile void __iomem *addr, void *buffer,
			       unsigned int count)
{
	readsb(addr, buffer, count);
}
#endif

#ifndef ioread16_rep
#define ioread16_rep ioread16_rep
static inline void ioread16_rep(const volatile void __iomem *addr,
				void *buffer, unsigned int count)
{
	readsw(addr, buffer, count);
}
#endif

#ifndef ioread32_rep
#define ioread32_rep ioread32_rep
static inline void ioread32_rep(const volatile void __iomem *addr,
				void *buffer, unsigned int count)
{
	readsl(addr, buffer, count);
}
#endif

#ifndef iowrite8_rep
#define iowrite8_rep iowrite8_rep
static inline void iowrite8_rep(volatile void __iomem *addr,
				const void *buffer,
				unsigned int count)
{
	writesb(addr, buffer, count);
}
#endif

#ifndef iowrite16_rep
#define iowrite16_rep iowrite16_rep
static inline void iowrite16_rep(volatile void __iomem *addr,
				 const void *buffer,
				 unsigned int count)
{
	writesw(addr, buffer, count);
}
#endif

#ifndef iowrite32_rep
#define iowrite32_rep iowrite32_rep
static inline void iowrite32_rep(volatile void __iomem *addr,
				 const void *buffer,
				 unsigned int count)
{
	writesl(addr, buffer, count);
}
#endif
700 701
#endif /* CONFIG_GENERIC_IOMAP */

702 703 704
#ifdef __KERNEL__

#include <linux/vmalloc.h>
705
#define __io_virt(x) ((void __force *)(x))
706 707 708

#ifndef CONFIG_GENERIC_IOMAP
struct pci_dev;
Jan Glauber's avatar
Jan Glauber committed
709 710 711
extern void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long max);

#ifndef pci_iounmap
712
#define pci_iounmap pci_iounmap
713 714 715
static inline void pci_iounmap(struct pci_dev *dev, void __iomem *p)
{
}
Jan Glauber's avatar
Jan Glauber committed
716
#endif
717 718 719 720 721 722
#endif /* CONFIG_GENERIC_IOMAP */

/*
 * Change virtual addresses to physical addresses and vv.
 * These are pretty trivial
 */
Jan Glauber's avatar
Jan Glauber committed
723
#ifndef virt_to_phys
724
#define virt_to_phys virt_to_phys
725 726 727 728
static inline unsigned long virt_to_phys(volatile void *address)
{
	return __pa((unsigned long)address);
}
729
#endif
730

731 732
#ifndef phys_to_virt
#define phys_to_virt phys_to_virt
733 734 735 736
static inline void *phys_to_virt(unsigned long address)
{
	return __va(address);
}
Jan Glauber's avatar
Jan Glauber committed
737
#endif
738

739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767
/**
 * DOC: ioremap() and ioremap_*() variants
 *
 * If you have an IOMMU your architecture is expected to have both ioremap()
 * and iounmap() implemented otherwise the asm-generic helpers will provide a
 * direct mapping.
 *
 * There are ioremap_*() call variants, if you have no IOMMU we naturally will
 * default to direct mapping for all of them, you can override these defaults.
 * If you have an IOMMU you are highly encouraged to provide your own
 * ioremap variant implementation as there currently is no safe architecture
 * agnostic default. To avoid possible improper behaviour default asm-generic
 * ioremap_*() variants all return NULL when an IOMMU is available. If you've
 * defined your own ioremap_*() variant you must then declare your own
 * ioremap_*() variant as defined to itself to avoid the default NULL return.
 */

#ifdef CONFIG_MMU

#ifndef ioremap_uc
#define ioremap_uc ioremap_uc
static inline void __iomem *ioremap_uc(phys_addr_t offset, size_t size)
{
	return NULL;
}
#endif

#else /* !CONFIG_MMU */

768 769
/*
 * Change "struct page" to physical address.
770 771 772
 *
 * This implementation is for the no-MMU case only... if you have an MMU
 * you'll need to provide your own definitions.
773
 */
774 775 776 777

#ifndef ioremap
#define ioremap ioremap
static inline void __iomem *ioremap(phys_addr_t offset, size_t size)
778
{
779
	return (void __iomem *)(unsigned long)offset;
780
}
781
#endif
782

783 784 785 786 787 788 789 790
#ifndef __ioremap
#define __ioremap __ioremap
static inline void __iomem *__ioremap(phys_addr_t offset, size_t size,
				      unsigned long flags)
{
	return ioremap(offset, size);
}
#endif
791 792

#ifndef ioremap_nocache
793 794 795 796 797
#define ioremap_nocache ioremap_nocache
static inline void __iomem *ioremap_nocache(phys_addr_t offset, size_t size)
{
	return ioremap(offset, size);
}
798 799
#endif

800 801 802 803 804 805 806 807
#ifndef ioremap_uc
#define ioremap_uc ioremap_uc
static inline void __iomem *ioremap_uc(phys_addr_t offset, size_t size)
{
	return ioremap_nocache(offset, size);
}
#endif

808
#ifndef ioremap_wc
809 810 811 812 813
#define ioremap_wc ioremap_wc
static inline void __iomem *ioremap_wc(phys_addr_t offset, size_t size)
{
	return ioremap_nocache(offset, size);
}
814 815
#endif

816 817 818 819 820 821 822 823
#ifndef ioremap_wt
#define ioremap_wt ioremap_wt
static inline void __iomem *ioremap_wt(phys_addr_t offset, size_t size)
{
	return ioremap_nocache(offset, size);
}
#endif

824 825
#ifndef iounmap
#define iounmap iounmap
826

827
static inline void iounmap(void __iomem *addr)
828 829
{
}
830
#endif
831
#endif /* CONFIG_MMU */
832

833
#ifdef CONFIG_HAS_IOPORT_MAP
834
#ifndef CONFIG_GENERIC_IOMAP
835 836
#ifndef ioport_map
#define ioport_map ioport_map
837 838
static inline void __iomem *ioport_map(unsigned long port, unsigned int nr)
{
839
	return PCI_IOBASE + (port & IO_SPACE_LIMIT);
840
}
841
#endif
842

843 844
#ifndef ioport_unmap
#define ioport_unmap ioport_unmap
845 846 847
static inline void ioport_unmap(void __iomem *p)
{
}
848
#endif
849 850 851 852
#else /* CONFIG_GENERIC_IOMAP */
extern void __iomem *ioport_map(unsigned long port, unsigned int nr);
extern void ioport_unmap(void __iomem *p);
#endif /* CONFIG_GENERIC_IOMAP */
853
#endif /* CONFIG_HAS_IOPORT_MAP */
854

855
#ifndef xlate_dev_kmem_ptr
856 857 858 859 860
#define xlate_dev_kmem_ptr xlate_dev_kmem_ptr
static inline void *xlate_dev_kmem_ptr(void *addr)
{
	return addr;
}
861
#endif
862

863
#ifndef xlate_dev_mem_ptr
864 865 866 867 868 869 870 871 872 873 874 875
#define xlate_dev_mem_ptr xlate_dev_mem_ptr
static inline void *xlate_dev_mem_ptr(phys_addr_t addr)
{
	return __va(addr);
}
#endif

#ifndef unxlate_dev_mem_ptr
#define unxlate_dev_mem_ptr unxlate_dev_mem_ptr
static inline void unxlate_dev_mem_ptr(phys_addr_t phys, void *addr)
{
}
876
#endif
877

878
#ifdef CONFIG_VIRT_TO_BUS
879
#ifndef virt_to_bus
880
static inline unsigned long virt_to_bus(void *address)
881
{
882
	return (unsigned long)address;
883 884 885 886
}

static inline void *bus_to_virt(unsigned long address)
{
887
	return (void *)address;
888 889
}
#endif
890
#endif
891

Jan Glauber's avatar
Jan Glauber committed
892
#ifndef memset_io
893 894 895 896 897 898
#define memset_io memset_io
static inline void memset_io(volatile void __iomem *addr, int value,
			     size_t size)
{
	memset(__io_virt(addr), value, size);
}
Jan Glauber's avatar
Jan Glauber committed
899 900 901
#endif

#ifndef memcpy_fromio
902 903 904 905 906 907 908
#define memcpy_fromio memcpy_fromio
static inline void memcpy_fromio(void *buffer,
				 const volatile void __iomem *addr,
				 size_t size)
{
	memcpy(buffer, __io_virt(addr), size);
}
Jan Glauber's avatar
Jan Glauber committed
909
#endif
910

Jan Glauber's avatar
Jan Glauber committed
911
#ifndef memcpy_toio
912 913 914 915 916 917
#define memcpy_toio memcpy_toio
static inline void memcpy_toio(volatile void __iomem *addr, const void *buffer,
			       size_t size)
{
	memcpy(__io_virt(addr), buffer, size);
}
Jan Glauber's avatar
Jan Glauber committed
918
#endif
919 920 921 922

#endif /* __KERNEL__ */

#endif /* __ASM_GENERIC_IO_H */