arch/s390/include/asm/pci_io.h

   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 Map */
  12 #define ZPCI_IOMAP_SHIFT                48
  13 #define ZPCI_IOMAP_ADDR_BASE            0x8000000000000000UL
  14 #define ZPCI_IOMAP_ADDR_OFF_MASK        ((1UL << ZPCI_IOMAP_SHIFT) - 1)
  15 #define ZPCI_IOMAP_MAX_ENTRIES                                                  \
  16         ((ULONG_MAX - ZPCI_IOMAP_ADDR_BASE + 1) / (1UL << ZPCI_IOMAP_SHIFT))
  17 #define ZPCI_IOMAP_ADDR_IDX_MASK                                                \
  18         (~ZPCI_IOMAP_ADDR_OFF_MASK - ZPCI_IOMAP_ADDR_BASE)
  19
  20 struct zpci_iomap_entry {
  21         u32 fh;
  22         u8 bar;
  23         u16 count;
  24 };
  25
  26 extern struct zpci_iomap_entry *zpci_iomap_start;
  27
  28 #define ZPCI_ADDR(idx) (ZPCI_IOMAP_ADDR_BASE | ((u64) idx << ZPCI_IOMAP_SHIFT))
  29 #define ZPCI_IDX(addr)                                                          \
  30         (((__force u64) addr & ZPCI_IOMAP_ADDR_IDX_MASK) >> ZPCI_IOMAP_SHIFT)
  31 #define ZPCI_OFFSET(addr)                                                       \
  32         ((__force u64) addr & ZPCI_IOMAP_ADDR_OFF_MASK)
  33
  34 #define ZPCI_CREATE_REQ(handle, space, len)                                     \
  35         ((u64) handle << 32 | space << 16 | len)
  36
  37 #define zpci_read(LENGTH, RETTYPE)                                              \
  38 static inline RETTYPE zpci_read_##RETTYPE(const volatile void __iomem *addr)    \
  39 {                                                                               \
  40         struct zpci_iomap_entry *entry = &zpci_iomap_start[ZPCI_IDX(addr)];     \
  41         u64 req = ZPCI_CREATE_REQ(entry->fh, entry->bar, LENGTH);               \
  42         u64 data;                                                               \
  43         int rc;                                                                 \
  44                                                                                 \
  45         rc = zpci_load(&data, req, ZPCI_OFFSET(addr));                          \
  46         if (rc)                                                                 \
  47                 data = -1ULL;                                                   \
  48         return (RETTYPE) data;                                                  \
  49 }
  50
  51 #define zpci_write(LENGTH, VALTYPE)                                             \
  52 static inline void zpci_write_##VALTYPE(VALTYPE val,                            \
  53                                         const volatile void __iomem *addr)      \
  54 {                                                                               \
  55         struct zpci_iomap_entry *entry = &zpci_iomap_start[ZPCI_IDX(addr)];     \
  56         u64 req = ZPCI_CREATE_REQ(entry->fh, entry->bar, LENGTH);               \
  57         u64 data = (VALTYPE) val;                                               \
  58                                                                                 \
  59         zpci_store(data, req, ZPCI_OFFSET(addr));                               \
  60 }
  61
  62 zpci_read(8, u64)
  63 zpci_read(4, u32)
  64 zpci_read(2, u16)
  65 zpci_read(1, u8)
  66 zpci_write(8, u64)
  67 zpci_write(4, u32)
  68 zpci_write(2, u16)
  69 zpci_write(1, u8)
  70
  71 static inline int zpci_write_single(u64 req, const u64 *data, u64 offset, u8 len)
  72 {
  73         u64 val;
  74
  75         switch (len) {
  76         case 1:
  77                 val = (u64) *((u8 *) data);
  78                 break;
  79         case 2:
  80                 val = (u64) *((u16 *) data);
  81                 break;
  82         case 4:
  83                 val = (u64) *((u32 *) data);
  84                 break;
  85         case 8:
  86                 val = (u64) *((u64 *) data);
  87                 break;
  88         default:
  89                 val = 0;                /* let FW report error */
  90                 break;
  91         }
  92         return zpci_store(val, req, offset);
  93 }
  94
  95 static inline int zpci_read_single(u64 req, u64 *dst, u64 offset, u8 len)
  96 {
  97         u64 data;
  98         int cc;
  99
 100         cc = zpci_load(&data, req, offset);
 101         if (cc)
 102                 goto out;
 103
 104         switch (len) {
 105         case 1:
 106                 *((u8 *) dst) = (u8) data;
 107                 break;
 108         case 2:
 109                 *((u16 *) dst) = (u16) data;
 110                 break;
 111         case 4:
 112                 *((u32 *) dst) = (u32) data;
 113                 break;
 114         case 8:
 115                 *((u64 *) dst) = (u64) data;
 116                 break;
 117         }
 118 out:
 119         return cc;
 120 }
 121
 122 static inline int zpci_write_block(u64 req, const u64 *data, u64 offset)
 123 {
 124         return zpci_store_block(data, req, offset);
 125 }
 126
 127 static inline u8 zpci_get_max_write_size(u64 src, u64 dst, int len, int max)
 128 {
 129         int count = len > max ? max : len, size = 1;
 130
 131         while (!(src & 0x1) && !(dst & 0x1) && ((size << 1) <= count)) {
 132                 dst = dst >> 1;
 133                 src = src >> 1;
 134                 size = size << 1;
 135         }
 136         return size;
 137 }
 138
 139 static inline int zpci_memcpy_fromio(void *dst,
 140                                      const volatile void __iomem *src,
 141                                      unsigned long n)
 142 {
 143         struct zpci_iomap_entry *entry = &zpci_iomap_start[ZPCI_IDX(src)];
 144         u64 req, offset = ZPCI_OFFSET(src);
 145         int size, rc = 0;
 146
 147         while (n > 0) {
 148                 size = zpci_get_max_write_size((u64 __force) src,
 149                                                (u64) dst, n, 8);
 150                 req = ZPCI_CREATE_REQ(entry->fh, entry->bar, size);
 151                 rc = zpci_read_single(req, dst, offset, size);
 152                 if (rc)
 153                         break;
 154                 offset += size;
 155                 dst += size;
 156                 n -= size;
 157         }
 158         return rc;
 159 }
 160
 161 static inline int zpci_memcpy_toio(volatile void __iomem *dst,
 162                                    const void *src, unsigned long n)
 163 {
 164         struct zpci_iomap_entry *entry = &zpci_iomap_start[ZPCI_IDX(dst)];
 165         u64 req, offset = ZPCI_OFFSET(dst);
 166         int size, rc = 0;
 167
 168         if (!src)
 169                 return -EINVAL;
 170
 171         while (n > 0) {
 172                 size = zpci_get_max_write_size((u64 __force) dst,
 173                                                (u64) src, n, 128);
 174                 req = ZPCI_CREATE_REQ(entry->fh, entry->bar, size);
 175
 176                 if (size > 8) /* main path */
 177                         rc = zpci_write_block(req, src, offset);
 178                 else
 179                         rc = zpci_write_single(req, src, offset, size);
 180                 if (rc)
 181                         break;
 182                 offset += size;
 183                 src += 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 */