arch/s390/include/asm/pci_io.h

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