Release 4.14 arch/ia64/include/asm/io.h

Directory: arch/ia64/include/asm
/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _ASM_IA64_IO_H

#define _ASM_IA64_IO_H

/*
 * This file contains the definitions for the emulated IO instructions
 * inb/inw/inl/outb/outw/outl and the "string versions" of the same
 * (insb/insw/insl/outsb/outsw/outsl). You can also use "pausing"
 * versions of the single-IO instructions (inb_p/inw_p/..).
 *
 * This file is not meant to be obfuscating: it's just complicated to
 * (a) handle it all in a way that makes gcc able to optimize it as
 * well as possible and (b) trying to avoid writing the same thing
 * over and over again with slight variations and possibly making a
 * mistake somewhere.
 *
 * Copyright (C) 1998-2003 Hewlett-Packard Co
 *      David Mosberger-Tang <davidm@hpl.hp.com>
 * Copyright (C) 1999 Asit Mallick <asit.k.mallick@intel.com>
 * Copyright (C) 1999 Don Dugger <don.dugger@intel.com>
 */

#include <asm/unaligned.h>
#include <asm/early_ioremap.h>

/* We don't use IO slowdowns on the ia64, but.. */

#define __SLOW_DOWN_IO	do { } while (0)

#define SLOW_DOWN_IO	do { } while (0)


#define __IA64_UNCACHED_OFFSET	RGN_BASE(RGN_UNCACHED)

/*
 * The legacy I/O space defined by the ia64 architecture supports only 65536 ports, but
 * large machines may have multiple other I/O spaces so we can't place any a priori limit
 * on IO_SPACE_LIMIT.  These additional spaces are described in ACPI.
 */

#define IO_SPACE_LIMIT		0xffffffffffffffffUL


#define MAX_IO_SPACES_BITS		8

#define MAX_IO_SPACES			(1UL << MAX_IO_SPACES_BITS)

#define IO_SPACE_BITS			24

#define IO_SPACE_SIZE			(1UL << IO_SPACE_BITS)


#define IO_SPACE_NR(port)		((port) >> IO_SPACE_BITS)

#define IO_SPACE_BASE(space)		((space) << IO_SPACE_BITS)

#define IO_SPACE_PORT(port)		((port) & (IO_SPACE_SIZE - 1))


#define IO_SPACE_SPARSE_ENCODING(p)	((((p) >> 2) << 12) | ((p) & 0xfff))


struct io_space {
	
unsigned long mmio_base;	/* base in MMIO space */
	
int sparse;
};

extern struct io_space io_space[];
extern unsigned int num_io_spaces;

# ifdef __KERNEL__

/*
 * All MMIO iomem cookies are in region 6; anything less is a PIO cookie:
 *      0xCxxxxxxxxxxxxxxx      MMIO cookie (return from ioremap)
 *      0x000000001SPPPPPP      PIO cookie (S=space number, P..P=port)
 *
 * ioread/writeX() uses the leading 1 in PIO cookies (PIO_OFFSET) to catch
 * code that uses bare port numbers without the prerequisite pci_iomap().
 */

#define PIO_OFFSET		(1UL << (MAX_IO_SPACES_BITS + IO_SPACE_BITS))

#define PIO_MASK		(PIO_OFFSET - 1)

#define PIO_RESERVED		__IA64_UNCACHED_OFFSET

#define HAVE_ARCH_PIO_SIZE

#include <asm/intrinsics.h>
#include <asm/machvec.h>
#include <asm/page.h>
#include <asm-generic/iomap.h>

/*
 * Change virtual addresses to physical addresses and vv.
 */

static inline unsigned long

virt_to_phys (volatile void *address)
{
	return (unsigned long) address - PAGE_OFFSET;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds (pre-git) 22 100.00% 1 100.00%
Total 22 100.00% 1 100.00%


static inline void*

phys_to_virt (unsigned long address)
{
	return (void *) (address + PAGE_OFFSET);
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds (pre-git) 23 100.00% 1 100.00%
Total 23 100.00% 1 100.00%


#define ARCH_HAS_VALID_PHYS_ADDR_RANGE
extern u64 kern_mem_attribute (unsigned long phys_addr, unsigned long size);
extern int valid_phys_addr_range (phys_addr_t addr, size_t count); /* efi.c */
extern int valid_mmap_phys_addr_range (unsigned long pfn, size_t count);

/*
 * The following two macros are deprecated and scheduled for removal.
 * Please use the PCI-DMA interface defined in <asm/pci.h> instead.
 */

#define bus_to_virt	phys_to_virt

#define virt_to_bus	virt_to_phys

#define page_to_bus	page_to_phys

# endif /* KERNEL */

/*
 * Memory fence w/accept.  This should never be used in code that is
 * not IA-64 specific.
 */

#define __ia64_mf_a()	ia64_mfa()

/**
 * ___ia64_mmiowb - I/O write barrier
 *
 * Ensure ordering of I/O space writes.  This will make sure that writes
 * following the barrier will arrive after all previous writes.  For most
 * ia64 platforms, this is a simple 'mf.a' instruction.
 *
 * See Documentation/driver-api/device-io.rst for more information.
 */


static inline void ___ia64_mmiowb(void)
{
	ia64_mfa();
}

Contributors
Person Tokens Prop Commits CommitProp
Jesse Barnes 12 100.00% 2 100.00%
Total 12 100.00% 2 100.00%


static inline void*

__ia64_mk_io_addr (unsigned long port)
{
	struct io_space *space;
	unsigned long offset;

	space = &io_space[IO_SPACE_NR(port)];
	port = IO_SPACE_PORT(port);
	if (space->sparse)
		offset = IO_SPACE_SPARSE_ENCODING(port);
	else
		offset = port;

	return (void *) (space->mmio_base | offset);
}

Contributors
Person Tokens Prop Commits CommitProp
Björn Helgaas 44 62.86% 1 33.33%
Linus Torvalds (pre-git) 26 37.14% 2 66.67%
Total 70 100.00% 3 100.00%


#define __ia64_inb	___ia64_inb

#define __ia64_inw	___ia64_inw

#define __ia64_inl	___ia64_inl

#define __ia64_outb	___ia64_outb

#define __ia64_outw	___ia64_outw

#define __ia64_outl	___ia64_outl

#define __ia64_readb	___ia64_readb

#define __ia64_readw	___ia64_readw

#define __ia64_readl	___ia64_readl

#define __ia64_readq	___ia64_readq

#define __ia64_readb_relaxed	___ia64_readb

#define __ia64_readw_relaxed	___ia64_readw

#define __ia64_readl_relaxed	___ia64_readl

#define __ia64_readq_relaxed	___ia64_readq

#define __ia64_writeb	___ia64_writeb

#define __ia64_writew	___ia64_writew

#define __ia64_writel	___ia64_writel

#define __ia64_writeq	___ia64_writeq

#define __ia64_mmiowb	___ia64_mmiowb

/*
 * For the in/out routines, we need to do "mf.a" _after_ doing the I/O access to ensure
 * that the access has completed before executing other I/O accesses.  Since we're doing
 * the accesses through an uncachable (UC) translation, the CPU will execute them in
 * program order.  However, we still need to tell the compiler not to shuffle them around
 * during optimization, which is why we use "volatile" pointers.
 */


static inline unsigned int

___ia64_inb (unsigned long port)
{
	volatile unsigned char *addr = __ia64_mk_io_addr(port);
	unsigned char ret;

	ret = *addr;
	__ia64_mf_a();
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds (pre-git) 37 97.37% 2 66.67%
David Mosberger-Tang 1 2.63% 1 33.33%
Total 38 100.00% 3 100.00%


static inline unsigned int

___ia64_inw (unsigned long port)
{
	volatile unsigned short *addr = __ia64_mk_io_addr(port);
	unsigned short ret;

	ret = *addr;
	__ia64_mf_a();
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds (pre-git) 37 97.37% 2 66.67%
David Mosberger-Tang 1 2.63% 1 33.33%
Total 38 100.00% 3 100.00%


static inline unsigned int

___ia64_inl (unsigned long port)
{
	volatile unsigned int *addr = __ia64_mk_io_addr(port);
	unsigned int ret;

	ret = *addr;
	__ia64_mf_a();
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds (pre-git) 37 97.37% 2 66.67%
David Mosberger-Tang 1 2.63% 1 33.33%
Total 38 100.00% 3 100.00%


static inline void

___ia64_outb (unsigned char val, unsigned long port)
{
	volatile unsigned char *addr = __ia64_mk_io_addr(port);

	*addr = val;
	__ia64_mf_a();
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds (pre-git) 33 97.06% 3 75.00%
David Mosberger-Tang 1 2.94% 1 25.00%
Total 34 100.00% 4 100.00%


static inline void

___ia64_outw (unsigned short val, unsigned long port)
{
	volatile unsigned short *addr = __ia64_mk_io_addr(port);

	*addr = val;
	__ia64_mf_a();
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds (pre-git) 33 97.06% 3 75.00%
David Mosberger-Tang 1 2.94% 1 25.00%
Total 34 100.00% 4 100.00%


static inline void

___ia64_outl (unsigned int val, unsigned long port)
{
	volatile unsigned int *addr = __ia64_mk_io_addr(port);

	*addr = val;
	__ia64_mf_a();
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds (pre-git) 33 97.06% 3 75.00%
David Mosberger-Tang 1 2.94% 1 25.00%
Total 34 100.00% 4 100.00%


static inline void

__insb (unsigned long port, void *dst, unsigned long count)
{
	unsigned char *dp = dst;

	while (count--)
		*dp++ = platform_inb(port);
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds (pre-git) 40 100.00% 3 100.00%
Total 40 100.00% 3 100.00%


static inline void

__insw (unsigned long port, void *dst, unsigned long count)
{
	unsigned short *dp = dst;

	while (count--)
		put_unaligned(platform_inw(port), dp++);
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds (pre-git) 36 85.71% 3 75.00%
James Bottomley 6 14.29% 1 25.00%
Total 42 100.00% 4 100.00%


static inline void

__insl (unsigned long port, void *dst, unsigned long count)
{
	unsigned int *dp = dst;

	while (count--)
		put_unaligned(platform_inl(port), dp++);
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds (pre-git) 36 85.71% 3 75.00%
James Bottomley 6 14.29% 1 25.00%
Total 42 100.00% 4 100.00%


static inline void

__outsb (unsigned long port, const void *src, unsigned long count)
{
	const unsigned char *sp = src;

	while (count--)
		platform_outb(*sp++, port);
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds (pre-git) 42 100.00% 3 100.00%
Total 42 100.00% 3 100.00%


static inline void

__outsw (unsigned long port, const void *src, unsigned long count)
{
	const unsigned short *sp = src;

	while (count--)
		platform_outw(get_unaligned(sp++), port);
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds (pre-git) 41 93.18% 3 75.00%
James Bottomley 3 6.82% 1 25.00%
Total 44 100.00% 4 100.00%


static inline void

__outsl (unsigned long port, const void *src, unsigned long count)
{
	const unsigned int *sp = src;

	while (count--)
		platform_outl(get_unaligned(sp++), port);
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds (pre-git) 40 90.91% 3 60.00%
James Bottomley 3 6.82% 1 20.00%
David Mosberger-Tang 1 2.27% 1 20.00%
Total 44 100.00% 5 100.00%

/*
 * Unfortunately, some platforms are broken and do not follow the IA-64 architecture
 * specification regarding legacy I/O support.  Thus, we have to make these operations
 * platform dependent...
 */

#define __inb		platform_inb

#define __inw		platform_inw

#define __inl		platform_inl

#define __outb		platform_outb

#define __outw		platform_outw

#define __outl		platform_outl

#define __mmiowb	platform_mmiowb


#define inb(p)		__inb(p)

#define inw(p)		__inw(p)

#define inl(p)		__inl(p)

#define insb(p,d,c)	__insb(p,d,c)

#define insw(p,d,c)	__insw(p,d,c)

#define insl(p,d,c)	__insl(p,d,c)

#define outb(v,p)	__outb(v,p)

#define outw(v,p)	__outw(v,p)

#define outl(v,p)	__outl(v,p)

#define outsb(p,s,c)	__outsb(p,s,c)

#define outsw(p,s,c)	__outsw(p,s,c)

#define outsl(p,s,c)	__outsl(p,s,c)

#define mmiowb()	__mmiowb()

/*
 * The address passed to these functions are ioremap()ped already.
 *
 * We need these to be machine vectors since some platforms don't provide
 * DMA coherence via PIO reads (PCI drivers and the spec imply that this is
 * a good idea).  Writes are ok though for all existing ia64 platforms (and
 * hopefully it'll stay that way).
 */

static inline unsigned char

___ia64_readb (const volatile void __iomem *addr)
{
	return *(volatile unsigned char __force *)addr;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds (pre-git) 21 80.77% 3 60.00%
David Mosberger-Tang 5 19.23% 2 40.00%
Total 26 100.00% 5 100.00%


static inline unsigned short

___ia64_readw (const volatile void __iomem *addr)
{
	return *(volatile unsigned short __force *)addr;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds (pre-git) 21 80.77% 3 60.00%
David Mosberger-Tang 5 19.23% 2 40.00%
Total 26 100.00% 5 100.00%


static inline unsigned int

___ia64_readl (const volatile void __iomem *addr)
{
	return *(volatile unsigned int __force *) addr;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds (pre-git) 21 80.77% 3 60.00%
David Mosberger-Tang 5 19.23% 2 40.00%
Total 26 100.00% 5 100.00%


static inline unsigned long

___ia64_readq (const volatile void __iomem *addr)
{
	return *(volatile unsigned long __force *) addr;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds (pre-git) 21 80.77% 3 60.00%
David Mosberger-Tang 5 19.23% 2 40.00%
Total 26 100.00% 5 100.00%


static inline void

__writeb (unsigned char val, volatile void __iomem *addr)
{
	*(volatile unsigned char __force *) addr = val;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds (pre-git) 26 89.66% 3 75.00%
David Mosberger-Tang 3 10.34% 1 25.00%
Total 29 100.00% 4 100.00%


static inline void

__writew (unsigned short val, volatile void __iomem *addr)
{
	*(volatile unsigned short __force *) addr = val;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds (pre-git) 26 89.66% 3 75.00%
David Mosberger-Tang 3 10.34% 1 25.00%
Total 29 100.00% 4 100.00%


static inline void

__writel (unsigned int val, volatile void __iomem *addr)
{
	*(volatile unsigned int __force *) addr = val;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds (pre-git) 26 89.66% 3 75.00%
David Mosberger-Tang 3 10.34% 1 25.00%
Total 29 100.00% 4 100.00%


static inline void

__writeq (unsigned long val, volatile void __iomem *addr)
{
	*(volatile unsigned long __force *) addr = val;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds (pre-git) 26 89.66% 3 75.00%
David Mosberger-Tang 3 10.34% 1 25.00%
Total 29 100.00% 4 100.00%


#define __readb		platform_readb

#define __readw		platform_readw

#define __readl		platform_readl

#define __readq		platform_readq

#define __readb_relaxed	platform_readb_relaxed

#define __readw_relaxed	platform_readw_relaxed

#define __readl_relaxed	platform_readl_relaxed

#define __readq_relaxed	platform_readq_relaxed


#define readb(a)	__readb((a))

#define readw(a)	__readw((a))

#define readl(a)	__readl((a))

#define readq(a)	__readq((a))

#define readb_relaxed(a)	__readb_relaxed((a))

#define readw_relaxed(a)	__readw_relaxed((a))

#define readl_relaxed(a)	__readl_relaxed((a))

#define readq_relaxed(a)	__readq_relaxed((a))

#define __raw_readb	readb

#define __raw_readw	readw

#define __raw_readl	readl

#define __raw_readq	readq

#define __raw_readb_relaxed	readb_relaxed

#define __raw_readw_relaxed	readw_relaxed

#define __raw_readl_relaxed	readl_relaxed

#define __raw_readq_relaxed	readq_relaxed

#define writeb(v,a)	__writeb((v), (a))

#define writew(v,a)	__writew((v), (a))

#define writel(v,a)	__writel((v), (a))

#define writeq(v,a)	__writeq((v), (a))

#define writeb_relaxed(v,a)	__writeb((v), (a))

#define writew_relaxed(v,a)	__writew((v), (a))

#define writel_relaxed(v,a)	__writel((v), (a))

#define writeq_relaxed(v,a)	__writeq((v), (a))

#define __raw_writeb	writeb

#define __raw_writew	writew

#define __raw_writel	writel

#define __raw_writeq	writeq

#ifndef inb_p

# define inb_p		inb
#endif
#ifndef inw_p

# define inw_p		inw
#endif
#ifndef inl_p

# define inl_p		inl
#endif

#ifndef outb_p

# define outb_p		outb
#endif
#ifndef outw_p

# define outw_p		outw
#endif
#ifndef outl_p

# define outl_p		outl
#endif

# ifdef __KERNEL__

extern void __iomem * ioremap(unsigned long offset, unsigned long size);
extern void __iomem * ioremap_nocache (unsigned long offset, unsigned long size);
extern void iounmap (volatile void __iomem *addr);


static inline void __iomem * ioremap_cache (unsigned long phys_addr, unsigned long size)
{
	return ioremap(phys_addr, size);
}
Contributors
Person Tokens Prop Commits CommitProp
Len Brown 25 100.00% 1 100.00%
Total 25 100.00% 1 100.00%


#define ioremap_cache ioremap_cache

#define ioremap_uc ioremap_nocache


/*
 * String version of IO memory access ops:
 */
extern void memcpy_fromio(void *dst, const volatile void __iomem *src, long n);
extern void memcpy_toio(volatile void __iomem *dst, const void *src, long n);
extern void memset_io(volatile void __iomem *s, int c, long n);

# endif /* __KERNEL__ */

#endif /* _ASM_IA64_IO_H */
Overall Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds (pre-git) 1008 61.50% 5 12.50%
David Mosberger-Tang 208 12.69% 6 15.00%
Björn Helgaas 182 11.10% 8 20.00%
Andrew Morton 72 4.39% 1 2.50%
Jesse Barnes 42 2.56% 3 7.50%
Will Deacon 36 2.20% 1 2.50%
Len Brown 25 1.53% 1 2.50%
James Bottomley 21 1.28% 1 2.50%
Matthew Wilcox 15 0.92% 1 2.50%
Linus Torvalds 7 0.43% 2 5.00%
Dan J Williams 4 0.24% 1 2.50%
Luis R. Rodriguez 4 0.24% 1 2.50%
Suresh B. Siddha 3 0.18% 1 2.50%
Aron Griffis 3 0.18% 1 2.50%
Ard Biesheuvel 3 0.18% 1 2.50%
Mauro Carvalho Chehab 1 0.06% 1 2.50%
Cyril Chemparathy 1 0.06% 1 2.50%
John Keller 1 0.06% 1 2.50%
Greg Kroah-Hartman 1 0.06% 1 2.50%
Lennert Buytenhek 1 0.06% 1 2.50%
Peter Chubb 1 0.06% 1 2.50%
Total 1639 100.00% 40 100.00%
Directory: arch/ia64/include/asm

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.
Person	Tokens	Prop	Commits	CommitProp
Linus Torvalds (pre-git)	22	100.00%	1	100.00%
Total	22	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.14 arch/ia64/include/asm/io.h

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
