root/arch/s390/include/asm/pci.h

/* [<][>][^][v][top][bottom][index][help] */

INCLUDED FROM

DEFINITIONS

This source file includes following definitions.
  1. zdev_enabled
  2. zpci_use_mio
  3. zpci_event_error
  4. zpci_event_availability
  5. zpci_rescan
  6. zpci_init_slot
  7. zpci_exit_slot
  8. to_zpci
  9. __pcibus_to_node
  10. cpumask_of_pcibus
   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef __ASM_S390_PCI_H
   3 #define __ASM_S390_PCI_H
   4 
   5 /* must be set before including pci_clp.h */
   6 #define PCI_BAR_COUNT   6
   7 
   8 #include <linux/pci.h>
   9 #include <linux/mutex.h>
  10 #include <linux/iommu.h>
  11 #include <asm-generic/pci.h>
  12 #include <asm/pci_clp.h>
  13 #include <asm/pci_debug.h>
  14 #include <asm/sclp.h>
  15 
  16 #define PCIBIOS_MIN_IO          0x1000
  17 #define PCIBIOS_MIN_MEM         0x10000000
  18 
  19 #define pcibios_assign_all_busses()     (0)
  20 
  21 void __iomem *pci_iomap(struct pci_dev *, int, unsigned long);
  22 void pci_iounmap(struct pci_dev *, void __iomem *);
  23 int pci_domain_nr(struct pci_bus *);
  24 int pci_proc_domain(struct pci_bus *);
  25 
  26 #define ZPCI_BUS_NR                     0       /* default bus number */
  27 #define ZPCI_DEVFN                      0       /* default device number */
  28 
  29 #define ZPCI_NR_DMA_SPACES              1
  30 #define ZPCI_NR_DEVICES                 CONFIG_PCI_NR_FUNCTIONS
  31 
  32 /* PCI Function Controls */
  33 #define ZPCI_FC_FN_ENABLED              0x80
  34 #define ZPCI_FC_ERROR                   0x40
  35 #define ZPCI_FC_BLOCKED                 0x20
  36 #define ZPCI_FC_DMA_ENABLED             0x10
  37 
  38 #define ZPCI_FMB_DMA_COUNTER_VALID      (1 << 23)
  39 
  40 struct zpci_fmb_fmt0 {
  41         u64 dma_rbytes;
  42         u64 dma_wbytes;
  43 };
  44 
  45 struct zpci_fmb_fmt1 {
  46         u64 rx_bytes;
  47         u64 rx_packets;
  48         u64 tx_bytes;
  49         u64 tx_packets;
  50 };
  51 
  52 struct zpci_fmb_fmt2 {
  53         u64 consumed_work_units;
  54         u64 max_work_units;
  55 };
  56 
  57 struct zpci_fmb_fmt3 {
  58         u64 tx_bytes;
  59 };
  60 
  61 struct zpci_fmb {
  62         u32 format      : 8;
  63         u32 fmt_ind     : 24;
  64         u32 samples;
  65         u64 last_update;
  66         /* common counters */
  67         u64 ld_ops;
  68         u64 st_ops;
  69         u64 stb_ops;
  70         u64 rpcit_ops;
  71         /* format specific counters */
  72         union {
  73                 struct zpci_fmb_fmt0 fmt0;
  74                 struct zpci_fmb_fmt1 fmt1;
  75                 struct zpci_fmb_fmt2 fmt2;
  76                 struct zpci_fmb_fmt3 fmt3;
  77         };
  78 } __packed __aligned(128);
  79 
  80 enum zpci_state {
  81         ZPCI_FN_STATE_STANDBY = 0,
  82         ZPCI_FN_STATE_CONFIGURED = 1,
  83         ZPCI_FN_STATE_RESERVED = 2,
  84         ZPCI_FN_STATE_ONLINE = 3,
  85 };
  86 
  87 struct zpci_bar_struct {
  88         struct resource *res;           /* bus resource */
  89         void __iomem    *mio_wb;
  90         void __iomem    *mio_wt;
  91         u32             val;            /* bar start & 3 flag bits */
  92         u16             map_idx;        /* index into bar mapping array */
  93         u8              size;           /* order 2 exponent */
  94 };
  95 
  96 struct s390_domain;
  97 
  98 /* Private data per function */
  99 struct zpci_dev {
 100         struct pci_bus  *bus;
 101         struct list_head entry;         /* list of all zpci_devices, needed for hotplug, etc. */
 102 
 103         enum zpci_state state;
 104         u32             fid;            /* function ID, used by sclp */
 105         u32             fh;             /* function handle, used by insn's */
 106         u16             vfn;            /* virtual function number */
 107         u16             pchid;          /* physical channel ID */
 108         u8              pfgid;          /* function group ID */
 109         u8              pft;            /* pci function type */
 110         u16             domain;
 111 
 112         struct mutex lock;
 113         u8 pfip[CLP_PFIP_NR_SEGMENTS];  /* pci function internal path */
 114         u32 uid;                        /* user defined id */
 115         u8 util_str[CLP_UTIL_STR_LEN];  /* utility string */
 116 
 117         /* IRQ stuff */
 118         u64             msi_addr;       /* MSI address */
 119         unsigned int    max_msi;        /* maximum number of MSI's */
 120         unsigned int    msi_first_bit;
 121         unsigned int    msi_nr_irqs;
 122         struct airq_iv *aibv;           /* adapter interrupt bit vector */
 123         unsigned long   aisb;           /* number of the summary bit */
 124 
 125         /* DMA stuff */
 126         unsigned long   *dma_table;
 127         spinlock_t      dma_table_lock;
 128         int             tlb_refresh;
 129 
 130         spinlock_t      iommu_bitmap_lock;
 131         unsigned long   *iommu_bitmap;
 132         unsigned long   *lazy_bitmap;
 133         unsigned long   iommu_size;
 134         unsigned long   iommu_pages;
 135         unsigned int    next_bit;
 136 
 137         struct iommu_device iommu_dev;  /* IOMMU core handle */
 138 
 139         char res_name[16];
 140         bool mio_capable;
 141         struct zpci_bar_struct bars[PCI_BAR_COUNT];
 142 
 143         u64             start_dma;      /* Start of available DMA addresses */
 144         u64             end_dma;        /* End of available DMA addresses */
 145         u64             dma_mask;       /* DMA address space mask */
 146 
 147         /* Function measurement block */
 148         struct zpci_fmb *fmb;
 149         u16             fmb_update;     /* update interval */
 150         u16             fmb_length;
 151         /* software counters */
 152         atomic64_t allocated_pages;
 153         atomic64_t mapped_pages;
 154         atomic64_t unmapped_pages;
 155 
 156         enum pci_bus_speed max_bus_speed;
 157 
 158         struct dentry   *debugfs_dev;
 159 
 160         struct s390_domain *s390_domain; /* s390 IOMMU domain data */
 161 };
 162 
 163 static inline bool zdev_enabled(struct zpci_dev *zdev)
 164 {
 165         return (zdev->fh & (1UL << 31)) ? true : false;
 166 }
 167 
 168 extern const struct attribute_group *zpci_attr_groups[];
 169 extern unsigned int s390_pci_force_floating __initdata;
 170 
 171 /* -----------------------------------------------------------------------------
 172   Prototypes
 173 ----------------------------------------------------------------------------- */
 174 /* Base stuff */
 175 int zpci_create_device(struct zpci_dev *);
 176 void zpci_remove_device(struct zpci_dev *zdev);
 177 int zpci_enable_device(struct zpci_dev *);
 178 int zpci_disable_device(struct zpci_dev *);
 179 int zpci_register_ioat(struct zpci_dev *, u8, u64, u64, u64);
 180 int zpci_unregister_ioat(struct zpci_dev *, u8);
 181 void zpci_remove_reserved_devices(void);
 182 
 183 /* CLP */
 184 int clp_scan_pci_devices(void);
 185 int clp_rescan_pci_devices(void);
 186 int clp_rescan_pci_devices_simple(u32 *fid);
 187 int clp_add_pci_device(u32, u32, int);
 188 int clp_enable_fh(struct zpci_dev *, u8);
 189 int clp_disable_fh(struct zpci_dev *);
 190 int clp_get_state(u32 fid, enum zpci_state *state);
 191 
 192 /* IOMMU Interface */
 193 int zpci_init_iommu(struct zpci_dev *zdev);
 194 void zpci_destroy_iommu(struct zpci_dev *zdev);
 195 
 196 #ifdef CONFIG_PCI
 197 static inline bool zpci_use_mio(struct zpci_dev *zdev)
 198 {
 199         return static_branch_likely(&have_mio) && zdev->mio_capable;
 200 }
 201 
 202 /* Error handling and recovery */
 203 void zpci_event_error(void *);
 204 void zpci_event_availability(void *);
 205 void zpci_rescan(void);
 206 bool zpci_is_enabled(void);
 207 #else /* CONFIG_PCI */
 208 static inline void zpci_event_error(void *e) {}
 209 static inline void zpci_event_availability(void *e) {}
 210 static inline void zpci_rescan(void) {}
 211 #endif /* CONFIG_PCI */
 212 
 213 #ifdef CONFIG_HOTPLUG_PCI_S390
 214 int zpci_init_slot(struct zpci_dev *);
 215 void zpci_exit_slot(struct zpci_dev *);
 216 #else /* CONFIG_HOTPLUG_PCI_S390 */
 217 static inline int zpci_init_slot(struct zpci_dev *zdev)
 218 {
 219         return 0;
 220 }
 221 static inline void zpci_exit_slot(struct zpci_dev *zdev) {}
 222 #endif /* CONFIG_HOTPLUG_PCI_S390 */
 223 
 224 /* Helpers */
 225 static inline struct zpci_dev *to_zpci(struct pci_dev *pdev)
 226 {
 227         return pdev->sysdata;
 228 }
 229 
 230 struct zpci_dev *get_zdev_by_fid(u32);
 231 
 232 /* DMA */
 233 int zpci_dma_init(void);
 234 void zpci_dma_exit(void);
 235 
 236 int __init zpci_irq_init(void);
 237 void __init zpci_irq_exit(void);
 238 
 239 /* FMB */
 240 int zpci_fmb_enable_device(struct zpci_dev *);
 241 int zpci_fmb_disable_device(struct zpci_dev *);
 242 
 243 /* Debug */
 244 int zpci_debug_init(void);
 245 void zpci_debug_exit(void);
 246 void zpci_debug_init_device(struct zpci_dev *, const char *);
 247 void zpci_debug_exit_device(struct zpci_dev *);
 248 void zpci_debug_info(struct zpci_dev *, struct seq_file *);
 249 
 250 /* Error reporting */
 251 int zpci_report_error(struct pci_dev *, struct zpci_report_error_header *);
 252 
 253 #ifdef CONFIG_NUMA
 254 
 255 /* Returns the node based on PCI bus */
 256 static inline int __pcibus_to_node(const struct pci_bus *bus)
 257 {
 258         return NUMA_NO_NODE;
 259 }
 260 
 261 static inline const struct cpumask *
 262 cpumask_of_pcibus(const struct pci_bus *bus)
 263 {
 264         return cpu_online_mask;
 265 }
 266 
 267 #endif /* CONFIG_NUMA */
 268 
 269 #endif
/* [<][>][^][v][top][bottom][index][help] */