1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef _ASM_S390_PCI_IO_H 3 #define _ASM_S390_PCI_IO_H 4 5 #ifdef CONFIG_PCI 6 7 #include <linux/kernel.h> 8 #include <linux/slab.h> 9 #include <asm/pci_insn.h> 10 11 /* I/O size constraints */ 12 #define ZPCI_MAX_READ_SIZE 8 13 #define ZPCI_MAX_WRITE_SIZE 128 14 #define ZPCI_BOUNDARY_SIZE (1 << 12) 15 #define ZPCI_BOUNDARY_MASK (ZPCI_BOUNDARY_SIZE - 1) 16 17 /* I/O Map */ 18 #define ZPCI_IOMAP_SHIFT 48 19 #define ZPCI_IOMAP_ADDR_SHIFT 62 20 #define ZPCI_IOMAP_ADDR_BASE (1UL << ZPCI_IOMAP_ADDR_SHIFT) 21 #define ZPCI_IOMAP_ADDR_OFF_MASK ((1UL << ZPCI_IOMAP_SHIFT) - 1) 22 #define ZPCI_IOMAP_MAX_ENTRIES \ 23 (1UL << (ZPCI_IOMAP_ADDR_SHIFT - ZPCI_IOMAP_SHIFT)) 24 #define ZPCI_IOMAP_ADDR_IDX_MASK \ 25 ((ZPCI_IOMAP_ADDR_BASE - 1) & ~ZPCI_IOMAP_ADDR_OFF_MASK) 26 27 struct zpci_iomap_entry { 28 u32 fh; 29 u8 bar; 30 u16 count; 31 }; 32 33 extern struct zpci_iomap_entry *zpci_iomap_start; 34 35 #define ZPCI_ADDR(idx) (ZPCI_IOMAP_ADDR_BASE | ((u64) idx << ZPCI_IOMAP_SHIFT)) 36 #define ZPCI_IDX(addr) \ 37 (((__force u64) addr & ZPCI_IOMAP_ADDR_IDX_MASK) >> ZPCI_IOMAP_SHIFT) 38 #define ZPCI_OFFSET(addr) \ 39 ((__force u64) addr & ZPCI_IOMAP_ADDR_OFF_MASK) 40 41 #define ZPCI_CREATE_REQ(handle, space, len) \ 42 ((u64) handle << 32 | space << 16 | len) 43 44 #define zpci_read(LENGTH, RETTYPE) \ 45 static inline RETTYPE zpci_read_##RETTYPE(const volatile void __iomem *addr) \ 46 { \ 47 u64 data; \ 48 int rc; \ 49 \ 50 rc = zpci_load(&data, addr, LENGTH); \ 51 if (rc) \ 52 data = -1ULL; \ 53 return (RETTYPE) data; \ 54 } 55 56 #define zpci_write(LENGTH, VALTYPE) \ 57 static inline void zpci_write_##VALTYPE(VALTYPE val, \ 58 const volatile void __iomem *addr) \ 59 { \ 60 u64 data = (VALTYPE) val; \ 61 \ 62 zpci_store(addr, data, LENGTH); \ 63 } 64 65 zpci_read(8, u64) 66 zpci_read(4, u32) 67 zpci_read(2, u16) 68 zpci_read(1, u8) 69 zpci_write(8, u64) 70 zpci_write(4, u32) 71 zpci_write(2, u16) 72 zpci_write(1, u8) 73 74 static inline int zpci_write_single(volatile void __iomem *dst, const void *src, 75 unsigned long len) 76 { 77 u64 val; 78 79 switch (len) { 80 case 1: 81 val = (u64) *((u8 *) src); 82 break; 83 case 2: 84 val = (u64) *((u16 *) src); 85 break; 86 case 4: 87 val = (u64) *((u32 *) src); 88 break; 89 case 8: 90 val = (u64) *((u64 *) src); 91 break; 92 default: 93 val = 0; /* let FW report error */ 94 break; 95 } 96 return zpci_store(dst, val, len); 97 } 98 99 static inline int zpci_read_single(void *dst, const volatile void __iomem *src, 100 unsigned long len) 101 { 102 u64 data; 103 int cc; 104 105 cc = zpci_load(&data, src, len); 106 if (cc) 107 goto out; 108 109 switch (len) { 110 case 1: 111 *((u8 *) dst) = (u8) data; 112 break; 113 case 2: 114 *((u16 *) dst) = (u16) data; 115 break; 116 case 4: 117 *((u32 *) dst) = (u32) data; 118 break; 119 case 8: 120 *((u64 *) dst) = (u64) data; 121 break; 122 } 123 out: 124 return cc; 125 } 126 127 int zpci_write_block(volatile void __iomem *dst, const void *src, 128 unsigned long len); 129 130 static inline int zpci_get_max_io_size(u64 src, u64 dst, int len, int max) 131 { 132 int offset = dst & ZPCI_BOUNDARY_MASK; 133 int size; 134 135 size = min3(len, ZPCI_BOUNDARY_SIZE - offset, max); 136 if (IS_ALIGNED(src, 8) && IS_ALIGNED(dst, 8) && IS_ALIGNED(size, 8)) 137 return size; 138 139 if (size >= 8) 140 return 8; 141 return rounddown_pow_of_two(size); 142 } 143 144 static inline int zpci_memcpy_fromio(void *dst, 145 const volatile void __iomem *src, 146 unsigned long n) 147 { 148 int size, rc = 0; 149 150 while (n > 0) { 151 size = zpci_get_max_io_size((u64 __force) src, 152 (u64) dst, n, 153 ZPCI_MAX_READ_SIZE); 154 rc = zpci_read_single(dst, src, size); 155 if (rc) 156 break; 157 src += size; 158 dst += size; 159 n -= size; 160 } 161 return rc; 162 } 163 164 static inline int zpci_memcpy_toio(volatile void __iomem *dst, 165 const void *src, unsigned long n) 166 { 167 int size, rc = 0; 168 169 if (!src) 170 return -EINVAL; 171 172 while (n > 0) { 173 size = zpci_get_max_io_size((u64 __force) dst, 174 (u64) src, n, 175 ZPCI_MAX_WRITE_SIZE); 176 if (size > 8) /* main path */ 177 rc = zpci_write_block(dst, src, size); 178 else 179 rc = zpci_write_single(dst, src, size); 180 if (rc) 181 break; 182 src += size; 183 dst += size; 184 n -= size; 185 } 186 return rc; 187 } 188 189 static inline int zpci_memset_io(volatile void __iomem *dst, 190 unsigned char val, size_t count) 191 { 192 u8 *src = kmalloc(count, GFP_KERNEL); 193 int rc; 194 195 if (src == NULL) 196 return -ENOMEM; 197 memset(src, val, count); 198 199 rc = zpci_memcpy_toio(dst, src, count); 200 kfree(src); 201 return rc; 202 } 203 204 #endif /* CONFIG_PCI */ 205 206 #endif /* _ASM_S390_PCI_IO_H */ 207