2 * s390 vfio-pci interfaces
4 * Copyright 2020 IBM Corp.
5 * Author(s): Matthew Rosato <mjrosato@linux.ibm.com>
7 * This work is licensed under the terms of the GNU GPL, version 2 or (at
8 * your option) any later version. See the COPYING file in the top-level
12 #include <sys/ioctl.h>
13 #include <linux/vfio.h>
14 #include <linux/vfio_zdev.h>
16 #include "qemu/osdep.h"
18 #include "hw/s390x/s390-pci-bus.h"
19 #include "hw/s390x/s390-pci-clp.h"
20 #include "hw/s390x/s390-pci-vfio.h"
21 #include "hw/vfio/pci.h"
22 #include "hw/vfio/vfio-common.h"
25 * Get the current DMA available count from vfio. Returns true if vfio is
26 * limiting DMA requests, false otherwise. The current available count read
27 * from vfio is returned in avail.
29 bool s390_pci_update_dma_avail(int fd
, unsigned int *avail
)
31 g_autofree
struct vfio_iommu_type1_info
*info
;
36 argsz
= sizeof(struct vfio_iommu_type1_info
);
37 info
= g_malloc0(argsz
);
40 * If the specified argsz is not large enough to contain all capabilities
41 * it will be updated upon return from the ioctl. Retry until we have
42 * a big enough buffer to hold the entire capability chain.
47 if (ioctl(fd
, VFIO_IOMMU_GET_INFO
, info
)) {
51 if (info
->argsz
> argsz
) {
53 info
= g_realloc(info
, argsz
);
57 /* If the capability exists, update with the current value */
58 return vfio_get_info_dma_avail(info
, avail
);
61 S390PCIDMACount
*s390_pci_start_dma_count(S390pciState
*s
,
62 S390PCIBusDevice
*pbdev
)
66 VFIOPCIDevice
*vpdev
= container_of(pbdev
->pdev
, VFIOPCIDevice
, pdev
);
71 id
= vpdev
->vbasedev
.group
->container
->fd
;
73 if (!s390_pci_update_dma_avail(id
, &avail
)) {
77 QTAILQ_FOREACH(cnt
, &s
->zpci_dma_limit
, link
) {
84 cnt
= g_new0(S390PCIDMACount
, 1);
88 QTAILQ_INSERT_TAIL(&s
->zpci_dma_limit
, cnt
, link
);
92 void s390_pci_end_dma_count(S390pciState
*s
, S390PCIDMACount
*cnt
)
97 if (cnt
->users
== 0) {
98 QTAILQ_REMOVE(&s
->zpci_dma_limit
, cnt
, link
);
102 static void s390_pci_read_base(S390PCIBusDevice
*pbdev
,
103 struct vfio_device_info
*info
)
105 struct vfio_info_cap_header
*hdr
;
106 struct vfio_device_info_cap_zpci_base
*cap
;
107 VFIOPCIDevice
*vpci
= container_of(pbdev
->pdev
, VFIOPCIDevice
, pdev
);
109 hdr
= vfio_get_device_info_cap(info
, VFIO_DEVICE_INFO_CAP_ZPCI_BASE
);
111 /* If capability not provided, just leave the defaults in place */
113 trace_s390_pci_clp_cap(vpci
->vbasedev
.name
,
114 VFIO_DEVICE_INFO_CAP_ZPCI_BASE
);
119 pbdev
->zpci_fn
.sdma
= cap
->start_dma
;
120 pbdev
->zpci_fn
.edma
= cap
->end_dma
;
121 pbdev
->zpci_fn
.pchid
= cap
->pchid
;
122 pbdev
->zpci_fn
.vfn
= cap
->vfn
;
123 pbdev
->zpci_fn
.pfgid
= cap
->gid
;
124 /* The following values remain 0 until we support other FMB formats */
125 pbdev
->zpci_fn
.fmbl
= 0;
126 pbdev
->zpci_fn
.pft
= 0;
129 static void s390_pci_read_group(S390PCIBusDevice
*pbdev
,
130 struct vfio_device_info
*info
)
132 struct vfio_info_cap_header
*hdr
;
133 struct vfio_device_info_cap_zpci_group
*cap
;
134 ClpRspQueryPciGrp
*resgrp
;
135 VFIOPCIDevice
*vpci
= container_of(pbdev
->pdev
, VFIOPCIDevice
, pdev
);
137 hdr
= vfio_get_device_info_cap(info
, VFIO_DEVICE_INFO_CAP_ZPCI_GROUP
);
139 /* If capability not provided, just use the default group */
141 trace_s390_pci_clp_cap(vpci
->vbasedev
.name
,
142 VFIO_DEVICE_INFO_CAP_ZPCI_GROUP
);
143 pbdev
->zpci_fn
.pfgid
= ZPCI_DEFAULT_FN_GRP
;
144 pbdev
->pci_group
= s390_group_find(ZPCI_DEFAULT_FN_GRP
);
149 /* See if the PCI group is already defined, create if not */
150 pbdev
->pci_group
= s390_group_find(pbdev
->zpci_fn
.pfgid
);
152 if (!pbdev
->pci_group
) {
153 pbdev
->pci_group
= s390_group_create(pbdev
->zpci_fn
.pfgid
);
155 resgrp
= &pbdev
->pci_group
->zpci_group
;
156 if (cap
->flags
& VFIO_DEVICE_INFO_ZPCI_FLAG_REFRESH
) {
159 resgrp
->dasm
= cap
->dasm
;
160 resgrp
->msia
= cap
->msi_addr
;
161 resgrp
->mui
= cap
->mui
;
162 resgrp
->i
= cap
->noi
;
163 resgrp
->maxstbl
= cap
->maxstbl
;
164 resgrp
->version
= cap
->version
;
168 static void s390_pci_read_util(S390PCIBusDevice
*pbdev
,
169 struct vfio_device_info
*info
)
171 struct vfio_info_cap_header
*hdr
;
172 struct vfio_device_info_cap_zpci_util
*cap
;
173 VFIOPCIDevice
*vpci
= container_of(pbdev
->pdev
, VFIOPCIDevice
, pdev
);
175 hdr
= vfio_get_device_info_cap(info
, VFIO_DEVICE_INFO_CAP_ZPCI_UTIL
);
177 /* If capability not provided, just leave the defaults in place */
179 trace_s390_pci_clp_cap(vpci
->vbasedev
.name
,
180 VFIO_DEVICE_INFO_CAP_ZPCI_UTIL
);
185 if (cap
->size
> CLP_UTIL_STR_LEN
) {
186 trace_s390_pci_clp_cap_size(vpci
->vbasedev
.name
, cap
->size
,
187 VFIO_DEVICE_INFO_CAP_ZPCI_UTIL
);
191 pbdev
->zpci_fn
.flags
|= CLP_RSP_QPCI_MASK_UTIL
;
192 memcpy(pbdev
->zpci_fn
.util_str
, cap
->util_str
, CLP_UTIL_STR_LEN
);
195 static void s390_pci_read_pfip(S390PCIBusDevice
*pbdev
,
196 struct vfio_device_info
*info
)
198 struct vfio_info_cap_header
*hdr
;
199 struct vfio_device_info_cap_zpci_pfip
*cap
;
200 VFIOPCIDevice
*vpci
= container_of(pbdev
->pdev
, VFIOPCIDevice
, pdev
);
202 hdr
= vfio_get_device_info_cap(info
, VFIO_DEVICE_INFO_CAP_ZPCI_PFIP
);
204 /* If capability not provided, just leave the defaults in place */
206 trace_s390_pci_clp_cap(vpci
->vbasedev
.name
,
207 VFIO_DEVICE_INFO_CAP_ZPCI_PFIP
);
212 if (cap
->size
> CLP_PFIP_NR_SEGMENTS
) {
213 trace_s390_pci_clp_cap_size(vpci
->vbasedev
.name
, cap
->size
,
214 VFIO_DEVICE_INFO_CAP_ZPCI_PFIP
);
218 memcpy(pbdev
->zpci_fn
.pfip
, cap
->pfip
, CLP_PFIP_NR_SEGMENTS
);
222 * This function will issue the VFIO_DEVICE_GET_INFO ioctl and look for
223 * capabilities that contain information about CLP features provided by the
225 * On entry, defaults have already been placed into the guest CLP response
226 * buffers. On exit, defaults will have been overwritten for any CLP features
227 * found in the capability chain; defaults will remain for any CLP features not
228 * found in the chain.
230 void s390_pci_get_clp_info(S390PCIBusDevice
*pbdev
)
232 g_autofree
struct vfio_device_info
*info
;
233 VFIOPCIDevice
*vfio_pci
;
237 argsz
= sizeof(*info
);
238 info
= g_malloc0(argsz
);
240 vfio_pci
= container_of(pbdev
->pdev
, VFIOPCIDevice
, pdev
);
241 fd
= vfio_pci
->vbasedev
.fd
;
244 * If the specified argsz is not large enough to contain all capabilities
245 * it will be updated upon return from the ioctl. Retry until we have
246 * a big enough buffer to hold the entire capability chain. On error,
247 * just exit and rely on CLP defaults.
252 if (ioctl(fd
, VFIO_DEVICE_GET_INFO
, info
)) {
253 trace_s390_pci_clp_dev_info(vfio_pci
->vbasedev
.name
);
257 if (info
->argsz
> argsz
) {
259 info
= g_realloc(info
, argsz
);
264 * Find the CLP features provided and fill in the guest CLP responses.
265 * Always call s390_pci_read_base first as information from this could
266 * determine which function group is used in s390_pci_read_group.
267 * For any feature not found, the default values will remain in the CLP
270 s390_pci_read_base(pbdev
, info
);
271 s390_pci_read_group(pbdev
, info
);
272 s390_pci_read_util(pbdev
, info
);
273 s390_pci_read_pfip(pbdev
, info
);