Training courses

Kernel and Embedded Linux

Bootlin training courses

Embedded Linux, kernel,
Yocto Project, Buildroot, real-time,
graphics, boot time, debugging...

Bootlin logo

Elixir Cross Referencer

Open Menu /contrib/ofed/libmlx4/mmio.h 
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
/* Licensed under the OpenIB.org BSD license (FreeBSD Variant) - See COPYING.md
 */
#ifndef MMIO_H
#define MMIO_H

#include <unistd.h>
#include <sys/syscall.h>
#ifdef __s390x__

static inline long mmio_writeb(const unsigned long mmio_addr,
			       const uint8_t val)
{
	return syscall(__NR_s390_pci_mmio_write, mmio_addr, &val, sizeof(val));
}

static inline long mmio_writew(const unsigned long mmio_addr,
			       const uint16_t val)
{
	return syscall(__NR_s390_pci_mmio_write, mmio_addr, &val, sizeof(val));
}

static inline long mmio_writel(const unsigned long mmio_addr,
			       const uint32_t val)
{
	return syscall(__NR_s390_pci_mmio_write, mmio_addr, &val, sizeof(val));
}

static inline long mmio_writeq(const unsigned long mmio_addr,
			       const uint64_t val)
{
	return syscall(__NR_s390_pci_mmio_write, mmio_addr, &val, sizeof(val));
}

static inline long mmio_write(const unsigned long mmio_addr,
			      const void *val,
			      const size_t length)
{
	return syscall(__NR_s390_pci_mmio_write, mmio_addr, val, length);
}

static inline long mmio_readb(const unsigned long mmio_addr, uint8_t *val)
{
	return syscall(__NR_s390_pci_mmio_read, mmio_addr, val, sizeof(*val));
}

static inline long mmio_readw(const unsigned long mmio_addr, uint16_t *val)
{
	return syscall(__NR_s390_pci_mmio_read, mmio_addr, val, sizeof(*val));
}

static inline long mmio_readl(const unsigned long mmio_addr, uint32_t *val)
{
	return syscall(__NR_s390_pci_mmio_read, mmio_addr, val, sizeof(*val));
}

static inline long mmio_readq(const unsigned long mmio_addr, uint64_t *val)
{
	return syscall(__NR_s390_pci_mmio_read, mmio_addr, val, sizeof(*val));
}

static inline long mmio_read(const unsigned long mmio_addr,
			     void *val,
			     const size_t length)
{
	return syscall(__NR_s390_pci_mmio_read, mmio_addr, val, length);
}

static inline void mlx4_bf_copy(unsigned long *dst,
				unsigned long *src,
				unsigned bytecnt)
{
	mmio_write((unsigned long)dst, src, bytecnt);
}

#else

#define mmio_writeb(addr, value) \
	(*((volatile uint8_t *)addr) = value)
#define mmio_writew(addr, value) \
	(*((volatile uint16_t *)addr) = value)
#define mmio_writel(addr, value) \
	(*((volatile uint32_t *)addr) = value)
#define mmio_writeq(addr, value) \
	(*((volatile uint64_t *)addr) = value)
#define mmio_write(addr, value, length) \
	memcpy(addr, value, length)

#define mmio_readb(addr, value) \
	(value = *((volatile uint8_t *)addr))
#define mmio_readw(addr, value) \
	(value = *((volatile uint16_t *)addr))
#define mmio_readl(addr, value) \
	(value = *((volatile uint32_t *)addr))
#define mmio_readq(addr, value) \
	(value = *((volatile uint64_t *)addr))
#define mmio_read(addr, value, length) \
	memcpy(value, addr, length)

/*
 * Avoid using memcpy() to copy to BlueFlame page, since memcpy()
 * implementations may use move-string-buffer assembler instructions,
 * which do not guarantee order of copying.
 */
static inline void mlx4_bf_copy(unsigned long *dst,
				unsigned long *src,
				unsigned bytecnt)
{
	while (bytecnt > 0) {
		*dst++ = *src++;
		*dst++ = *src++;
		bytecnt -= 2 * sizeof(long);
	}
}
#endif

#endif