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

Directory: arch/parisc/include/asm
/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _ASM_IO_H

#define _ASM_IO_H

#include <linux/types.h>
#include <asm/pgtable.h>


#define virt_to_phys(a) ((unsigned long)__pa(a))

#define phys_to_virt(a) __va(a)

#define virt_to_bus virt_to_phys

#define bus_to_virt phys_to_virt



static inline unsigned long isa_bus_to_virt(unsigned long addr) {
	BUG();
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Kyle McMartin 18 100.00% 1 100.00%
Total 18 100.00% 1 100.00%



static inline unsigned long isa_virt_to_bus(void *addr) {
	BUG();
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Kyle McMartin 18 100.00% 1 100.00%
Total 18 100.00% 1 100.00%

/*
 * Memory mapped I/O
 *
 * readX()/writeX() do byteswapping and take an ioremapped address
 * __raw_readX()/__raw_writeX() don't byteswap and take an ioremapped address.
 * gsc_*() don't byteswap and operate on physical addresses;
 *   eg dev->hpa or 0xfee00000.
 */



static inline unsigned char gsc_readb(unsigned long addr)
{
	long flags;
	unsigned char ret;

	__asm__ __volatile__(
        "       rsm     %3,%0\n"
        "       ldbx    0(%2),%1\n"
        "       mtsm    %0\n"
        : "=&r" (flags), "=r" (ret) : "r" (addr), "i" (PSW_SM_D) );

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Matthew Wilcox 24 96.00% 2 66.67%
Helge Deller 1 4.00% 1 33.33%
Total 25 100.00% 3 100.00%



static inline unsigned short gsc_readw(unsigned long addr)
{
	long flags;
	unsigned short ret;

	__asm__ __volatile__(
        "       rsm     %3,%0\n"
        "       ldhx    0(%2),%1\n"
        "       mtsm    %0\n"
        : "=&r" (flags), "=r" (ret) : "r" (addr), "i" (PSW_SM_D) );

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Matthew Wilcox 24 96.00% 2 66.67%
Helge Deller 1 4.00% 1 33.33%
Total 25 100.00% 3 100.00%



static inline unsigned int gsc_readl(unsigned long addr)
{
	u32 ret;

	__asm__ __volatile__(
        "       ldwax   0(%1),%0\n"
        : "=r" (ret) : "r" (addr) );

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Matthew Wilcox 21 100.00% 2 100.00%
Total 21 100.00% 2 100.00%



static inline unsigned long long gsc_readq(unsigned long addr)
{
	unsigned long long ret;

#ifdef CONFIG_64BIT
	__asm__ __volatile__(
        "       ldda    0(%1),%0\n"
        :  "=r" (ret) : "r" (addr) );
#else
	/* two reads may have side effects.. */
	ret = ((u64) gsc_readl(addr)) << 32;
	ret |= gsc_readl(addr+4);
#endif
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Matthew Wilcox 54 98.18% 2 66.67%
Helge Deller 1 1.82% 1 33.33%
Total 55 100.00% 3 100.00%



static inline void gsc_writeb(unsigned char val, unsigned long addr)
{
	long flags;
	__asm__ __volatile__(
        "       rsm     %3,%0\n"
        "       stbs    %1,0(%2)\n"
        "       mtsm    %0\n"
        : "=&r" (flags) :  "r" (val), "r" (addr), "i" (PSW_SM_D) );
}

Contributors
Person Tokens Prop Commits CommitProp
Matthew Wilcox 20 95.24% 2 66.67%
Helge Deller 1 4.76% 1 33.33%
Total 21 100.00% 3 100.00%



static inline void gsc_writew(unsigned short val, unsigned long addr)
{
	long flags;
	__asm__ __volatile__(
        "       rsm     %3,%0\n"
        "       sths    %1,0(%2)\n"
        "       mtsm    %0\n"
        : "=&r" (flags) :  "r" (val), "r" (addr), "i" (PSW_SM_D) );
}

Contributors
Person Tokens Prop Commits CommitProp
Matthew Wilcox 20 95.24% 2 66.67%
Helge Deller 1 4.76% 1 33.33%
Total 21 100.00% 3 100.00%



static inline void gsc_writel(unsigned int val, unsigned long addr)
{
	__asm__ __volatile__(
        "       stwas   %0,0(%1)\n"
        : :  "r" (val), "r" (addr) );
}

Contributors
Person Tokens Prop Commits CommitProp
Matthew Wilcox 18 100.00% 2 100.00%
Total 18 100.00% 2 100.00%



static inline void gsc_writeq(unsigned long long val, unsigned long addr)
{
#ifdef CONFIG_64BIT
	__asm__ __volatile__(
        "       stda    %0,0(%1)\n"
        : :  "r" (val), "r" (addr) );
#else
	/* two writes may have side effects.. */
	gsc_writel(val >> 32, addr);
	gsc_writel(val, addr+4);
#endif
}

Contributors
Person Tokens Prop Commits CommitProp
Matthew Wilcox 44 97.78% 2 66.67%
Helge Deller 1 2.22% 1 33.33%
Total 45 100.00% 3 100.00%

/*
 * The standard PCI ioremap interfaces
 */

extern void __iomem * __ioremap(unsigned long offset, unsigned long size, unsigned long flags);

/* Most machines react poorly to I/O-space being cacheable... Instead let's
 * define ioremap() in terms of ioremap_nocache().
 */


static inline void __iomem * ioremap(unsigned long offset, unsigned long size)
{
	return __ioremap(offset, size, _PAGE_NO_CACHE);
}
Contributors
Person Tokens Prop Commits CommitProp
Matthew Wilcox 25 92.59% 1 33.33%
Kyle McMartin 1 3.70% 1 33.33%
Adrian Bunk 1 3.70% 1 33.33%
Total 27 100.00% 3 100.00%


#define ioremap_nocache(off, sz)	ioremap((off), (sz))

#define ioremap_wc			ioremap_nocache

#define ioremap_uc			ioremap_nocache

extern void iounmap(const volatile void __iomem *addr);



static inline unsigned char __raw_readb(const volatile void __iomem *addr)
{
	return (*(volatile unsigned char __force *) (addr));
}
Contributors
Person Tokens Prop Commits CommitProp
Matthew Wilcox 30 100.00% 2 100.00%
Total 30 100.00% 2 100.00%



static inline unsigned short __raw_readw(const volatile void __iomem *addr)
{
	return *(volatile unsigned short __force *) addr;
}
Contributors
Person Tokens Prop Commits CommitProp
Matthew Wilcox 26 100.00% 2 100.00%
Total 26 100.00% 2 100.00%



static inline unsigned int __raw_readl(const volatile void __iomem *addr)
{
	return *(volatile unsigned int __force *) addr;
}
Contributors
Person Tokens Prop Commits CommitProp
Matthew Wilcox 26 100.00% 2 100.00%
Total 26 100.00% 2 100.00%



static inline unsigned long long __raw_readq(const volatile void __iomem *addr)
{
	return *(volatile unsigned long long __force *) addr;
}

Contributors
Person Tokens Prop Commits CommitProp
Matthew Wilcox 28 100.00% 2 100.00%
Total 28 100.00% 2 100.00%



static inline void __raw_writeb(unsigned char b, volatile void __iomem *addr)
{
	*(volatile unsigned char __force *) addr = b;
}
Contributors
Person Tokens Prop Commits CommitProp
Matthew Wilcox 29 100.00% 1 100.00%
Total 29 100.00% 1 100.00%



static inline void __raw_writew(unsigned short b, volatile void __iomem *addr)
{
	*(volatile unsigned short __force *) addr = b;
}
Contributors
Person Tokens Prop Commits CommitProp
Matthew Wilcox 29 100.00% 1 100.00%
Total 29 100.00% 1 100.00%



static inline void __raw_writel(unsigned int b, volatile void __iomem *addr)
{
	*(volatile unsigned int __force *) addr = b;
}
Contributors
Person Tokens Prop Commits CommitProp
Matthew Wilcox 29 100.00% 1 100.00%
Total 29 100.00% 1 100.00%



static inline void __raw_writeq(unsigned long long b, volatile void __iomem *addr)
{
	*(volatile unsigned long long __force *) addr = b;
}

Contributors
Person Tokens Prop Commits CommitProp
Matthew Wilcox 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%



static inline unsigned char readb(const volatile void __iomem *addr)
{
	return __raw_readb(addr);
}
Contributors
Person Tokens Prop Commits CommitProp
Kyle McMartin 17 80.95% 1 50.00%
Matthew Wilcox 4 19.05% 1 50.00%
Total 21 100.00% 2 100.00%



static inline unsigned short readw(const volatile void __iomem *addr)
{
	return le16_to_cpu(__raw_readw(addr));
}
Contributors
Person Tokens Prop Commits CommitProp
Kyle McMartin 20 83.33% 1 50.00%
Matthew Wilcox 4 16.67% 1 50.00%
Total 24 100.00% 2 100.00%



static inline unsigned int readl(const volatile void __iomem *addr)
{
	return le32_to_cpu(__raw_readl(addr));
}
Contributors
Person Tokens Prop Commits CommitProp
Kyle McMartin 20 83.33% 1 50.00%
Matthew Wilcox 4 16.67% 1 50.00%
Total 24 100.00% 2 100.00%



static inline unsigned long long readq(const volatile void __iomem *addr)
{
	return le64_to_cpu(__raw_readq(addr));
}

Contributors
Person Tokens Prop Commits CommitProp
Kyle McMartin 21 84.00% 1 50.00%
Matthew Wilcox 4 16.00% 1 50.00%
Total 25 100.00% 2 100.00%



static inline void writeb(unsigned char b, volatile void __iomem *addr)
{
	__raw_writeb(b, addr);
}
Contributors
Person Tokens Prop Commits CommitProp
Kyle McMartin 18 75.00% 1 50.00%
Matthew Wilcox 6 25.00% 1 50.00%
Total 24 100.00% 2 100.00%



static inline void writew(unsigned short w, volatile void __iomem *addr)
{
	__raw_writew(cpu_to_le16(w), addr);
}
Contributors
Person Tokens Prop Commits CommitProp
Kyle McMartin 22 81.48% 1 50.00%
Matthew Wilcox 5 18.52% 1 50.00%
Total 27 100.00% 2 100.00%



static inline void writel(unsigned int l, volatile void __iomem *addr)
{
	__raw_writel(cpu_to_le32(l), addr);
}
Contributors
Person Tokens Prop Commits CommitProp
Kyle McMartin 22 81.48% 1 50.00%
Matthew Wilcox 5 18.52% 1 50.00%
Total 27 100.00% 2 100.00%



static inline void writeq(unsigned long long q, volatile void __iomem *addr)
{
	__raw_writeq(cpu_to_le64(q), addr);
}

Contributors
Person Tokens Prop Commits CommitProp
Kyle McMartin 23 82.14% 1 50.00%
Matthew Wilcox 5 17.86% 1 50.00%
Total 28 100.00% 2 100.00%


#define	readb	readb

#define	readw	readw

#define	readl	readl

#define readq	readq

#define writeb	writeb

#define writew	writew

#define writel	writel

#define writeq	writeq


#define readb_relaxed(addr)	readb(addr)

#define readw_relaxed(addr)	readw(addr)

#define readl_relaxed(addr)	readl(addr)

#define readq_relaxed(addr)	readq(addr)

#define writeb_relaxed(b, addr)	writeb(b, addr)

#define writew_relaxed(w, addr)	writew(w, addr)

#define writel_relaxed(l, addr)	writel(l, addr)

#define writeq_relaxed(q, addr)	writeq(q, addr)


#define mmiowb() do { } while (0)

void memset_io(volatile void __iomem *addr, unsigned char val, int count);
void memcpy_fromio(void *dst, const volatile void __iomem *src, int count);
void memcpy_toio(volatile void __iomem *dst, const void *src, int count);

/* Port-space IO */


#define inb_p inb

#define inw_p inw

#define inl_p inl

#define outb_p outb

#define outw_p outw

#define outl_p outl

extern unsigned char eisa_in8(unsigned short port);
extern unsigned short eisa_in16(unsigned short port);
extern unsigned int eisa_in32(unsigned short port);
extern void eisa_out8(unsigned char data, unsigned short port);
extern void eisa_out16(unsigned short data, unsigned short port);
extern void eisa_out32(unsigned int data, unsigned short port);

#if defined(CONFIG_PCI)
extern unsigned char inb(int addr);
extern unsigned short inw(int addr);
extern unsigned int inl(int addr);

extern void outb(unsigned char b, int addr);
extern void outw(unsigned short b, int addr);
extern void outl(unsigned int b, int addr);
#elif defined(CONFIG_EISA)

#define inb eisa_in8

#define inw eisa_in16

#define inl eisa_in32

#define outb eisa_out8

#define outw eisa_out16

#define outl eisa_out32
#else


static inline char inb(unsigned long addr)
{
	BUG();
	return -1;
}

Contributors
Person Tokens Prop Commits CommitProp
Matthew Wilcox 18 100.00% 1 100.00%
Total 18 100.00% 1 100.00%



static inline short inw(unsigned long addr)
{
	BUG();
	return -1;
}

Contributors
Person Tokens Prop Commits CommitProp
Matthew Wilcox 18 100.00% 1 100.00%
Total 18 100.00% 1 100.00%



static inline int inl(unsigned long addr)
{
	BUG();
	return -1;
}

Contributors
Person Tokens Prop Commits CommitProp
Matthew Wilcox 18 100.00% 1 100.00%
Total 18 100.00% 1 100.00%


#define outb(x, y)	BUG()

#define outw(x, y)	BUG()

#define outl(x, y)	BUG()
#endif

/*
 * String versions of in/out ops:
 */
extern void insb (unsigned long port, void *dst, unsigned long count);
extern void insw (unsigned long port, void *dst, unsigned long count);
extern void insl (unsigned long port, void *dst, unsigned long count);
extern void outsb (unsigned long port, const void *src, unsigned long count);
extern void outsw (unsigned long port, const void *src, unsigned long count);
extern void outsl (unsigned long port, const void *src, unsigned long count);


/* IO Port space is :      BBiiii   where BB is HBA number. */

#define IO_SPACE_LIMIT 0x00ffffff

/* PA machines have an MM I/O space from 0xf0000000-0xffffffff in 32
 * bit mode and from 0xfffffffff0000000-0xfffffffffffffff in 64 bit
 * mode (essentially just sign extending.  This macro takes in a 32
 * bit I/O address (still with the leading f) and outputs the correct
 * value for either 32 or 64 bit mode */

#define F_EXTEND(x) ((unsigned long)((x) | (0xffffffff00000000ULL)))

#include <asm-generic/iomap.h>

/*
 * Convert a physical pointer to a virtual kernel pointer for /dev/mem
 * access
 */

#define xlate_dev_mem_ptr(p)	__va(p)

/*
 * Convert a virtual cached pointer to an uncached pointer
 */

#define xlate_dev_kmem_ptr(p)	p

#endif
Overall Contributors
Person Tokens Prop Commits CommitProp
Matthew Wilcox 944 68.41% 5 26.32%
Kyle McMartin 238 17.25% 4 21.05%
Linus Torvalds (pre-git) 98 7.10% 1 5.26%
Will Deacon 36 2.61% 1 5.26%
Andrew Morton 28 2.03% 1 5.26%
Jes Sorensen 16 1.16% 1 5.26%
Guenter Roeck 8 0.58% 1 5.26%
Helge Deller 6 0.43% 2 10.53%
Jesse Barnes 4 0.29% 1 5.26%
Greg Kroah-Hartman 1 0.07% 1 5.26%
Adrian Bunk 1 0.07% 1 5.26%
Total 1380 100.00% 19 100.00%
Directory: arch/parisc/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
Kyle McMartin	18	100.00%	1	100.00%
Total	18	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.14 arch/parisc/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

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
