1 // SPDX-License-Identifier: GPL-2.0
3 * Physical device callbacks for vfio_ccw
5 * Copyright IBM Corp. 2017
7 * Author(s): Dong Jia Shi <bjsdjshi@linux.vnet.ibm.com>
8 * Xiao Feng Ren <renxiaof@linux.vnet.ibm.com>
11 #include <linux/vfio.h>
12 #include <linux/mdev.h>
14 #include "vfio_ccw_private.h"
16 static int vfio_ccw_mdev_reset(struct mdev_device *mdev)
18 struct vfio_ccw_private *private;
19 struct subchannel *sch;
22 private = dev_get_drvdata(mdev_parent_dev(mdev));
26 * In the cureent stage, some things like "no I/O running" and "no
27 * interrupt pending" are clear, but we are not sure what other state
28 * we need to care about.
29 * There are still a lot more instructions need to be handled. We
30 * should come back here later.
32 ret = vfio_ccw_sch_quiesce(sch);
36 ret = cio_enable_subchannel(sch, (u32)(unsigned long)sch);
38 private->state = VFIO_CCW_STATE_IDLE;
43 static int vfio_ccw_mdev_notifier(struct notifier_block *nb,
47 struct vfio_ccw_private *private =
48 container_of(nb, struct vfio_ccw_private, nb);
51 * Vendor drivers MUST unpin pages in response to an
54 if (action == VFIO_IOMMU_NOTIFY_DMA_UNMAP) {
55 struct vfio_iommu_type1_dma_unmap *unmap = data;
57 if (!cp_iova_pinned(&private->cp, unmap->iova))
60 if (vfio_ccw_mdev_reset(private->mdev))
63 cp_free(&private->cp);
70 static ssize_t name_show(struct kobject *kobj, struct device *dev, char *buf)
72 return sprintf(buf, "I/O subchannel (Non-QDIO)\n");
74 static MDEV_TYPE_ATTR_RO(name);
76 static ssize_t device_api_show(struct kobject *kobj, struct device *dev,
79 return sprintf(buf, "%s\n", VFIO_DEVICE_API_CCW_STRING);
81 static MDEV_TYPE_ATTR_RO(device_api);
83 static ssize_t available_instances_show(struct kobject *kobj,
84 struct device *dev, char *buf)
86 struct vfio_ccw_private *private = dev_get_drvdata(dev);
88 return sprintf(buf, "%d\n", atomic_read(&private->avail));
90 static MDEV_TYPE_ATTR_RO(available_instances);
92 static struct attribute *mdev_types_attrs[] = {
93 &mdev_type_attr_name.attr,
94 &mdev_type_attr_device_api.attr,
95 &mdev_type_attr_available_instances.attr,
99 static struct attribute_group mdev_type_group = {
101 .attrs = mdev_types_attrs,
104 static struct attribute_group *mdev_type_groups[] = {
109 static int vfio_ccw_mdev_create(struct kobject *kobj, struct mdev_device *mdev)
111 struct vfio_ccw_private *private =
112 dev_get_drvdata(mdev_parent_dev(mdev));
114 if (private->state == VFIO_CCW_STATE_NOT_OPER)
117 if (atomic_dec_if_positive(&private->avail) < 0)
120 private->mdev = mdev;
121 private->state = VFIO_CCW_STATE_IDLE;
126 static int vfio_ccw_mdev_remove(struct mdev_device *mdev)
128 struct vfio_ccw_private *private =
129 dev_get_drvdata(mdev_parent_dev(mdev));
131 if ((private->state != VFIO_CCW_STATE_NOT_OPER) &&
132 (private->state != VFIO_CCW_STATE_STANDBY)) {
133 if (!vfio_ccw_mdev_reset(mdev))
134 private->state = VFIO_CCW_STATE_STANDBY;
135 /* The state will be NOT_OPER on error. */
138 private->mdev = NULL;
139 atomic_inc(&private->avail);
144 static int vfio_ccw_mdev_open(struct mdev_device *mdev)
146 struct vfio_ccw_private *private =
147 dev_get_drvdata(mdev_parent_dev(mdev));
148 unsigned long events = VFIO_IOMMU_NOTIFY_DMA_UNMAP;
150 private->nb.notifier_call = vfio_ccw_mdev_notifier;
152 return vfio_register_notifier(mdev_dev(mdev), VFIO_IOMMU_NOTIFY,
153 &events, &private->nb);
156 static void vfio_ccw_mdev_release(struct mdev_device *mdev)
158 struct vfio_ccw_private *private =
159 dev_get_drvdata(mdev_parent_dev(mdev));
161 vfio_unregister_notifier(mdev_dev(mdev), VFIO_IOMMU_NOTIFY,
165 static ssize_t vfio_ccw_mdev_read(struct mdev_device *mdev,
170 struct vfio_ccw_private *private;
171 struct ccw_io_region *region;
173 if (*ppos + count > sizeof(*region))
176 private = dev_get_drvdata(mdev_parent_dev(mdev));
177 region = &private->io_region;
178 if (copy_to_user(buf, (void *)region + *ppos, count))
184 static ssize_t vfio_ccw_mdev_write(struct mdev_device *mdev,
185 const char __user *buf,
189 struct vfio_ccw_private *private;
190 struct ccw_io_region *region;
192 if (*ppos + count > sizeof(*region))
195 private = dev_get_drvdata(mdev_parent_dev(mdev));
196 if (private->state != VFIO_CCW_STATE_IDLE)
199 region = &private->io_region;
200 if (copy_from_user((void *)region + *ppos, buf, count))
203 vfio_ccw_fsm_event(private, VFIO_CCW_EVENT_IO_REQ);
204 if (region->ret_code != 0) {
205 private->state = VFIO_CCW_STATE_IDLE;
206 return region->ret_code;
212 static int vfio_ccw_mdev_get_device_info(struct vfio_device_info *info)
214 info->flags = VFIO_DEVICE_FLAGS_CCW | VFIO_DEVICE_FLAGS_RESET;
215 info->num_regions = VFIO_CCW_NUM_REGIONS;
216 info->num_irqs = VFIO_CCW_NUM_IRQS;
221 static int vfio_ccw_mdev_get_region_info(struct vfio_region_info *info,
225 switch (info->index) {
226 case VFIO_CCW_CONFIG_REGION_INDEX:
228 info->size = sizeof(struct ccw_io_region);
229 info->flags = VFIO_REGION_INFO_FLAG_READ
230 | VFIO_REGION_INFO_FLAG_WRITE;
237 static int vfio_ccw_mdev_get_irq_info(struct vfio_irq_info *info)
239 if (info->index != VFIO_CCW_IO_IRQ_INDEX)
243 info->flags = VFIO_IRQ_INFO_EVENTFD;
248 static int vfio_ccw_mdev_set_irqs(struct mdev_device *mdev,
252 struct vfio_ccw_private *private;
253 struct eventfd_ctx **ctx;
255 if (!(flags & VFIO_IRQ_SET_ACTION_TRIGGER))
258 private = dev_get_drvdata(mdev_parent_dev(mdev));
259 ctx = &private->io_trigger;
261 switch (flags & VFIO_IRQ_SET_DATA_TYPE_MASK) {
262 case VFIO_IRQ_SET_DATA_NONE:
265 eventfd_signal(*ctx, 1);
268 case VFIO_IRQ_SET_DATA_BOOL:
272 if (get_user(trigger, (uint8_t __user *)data))
276 eventfd_signal(*ctx, 1);
279 case VFIO_IRQ_SET_DATA_EVENTFD:
283 if (get_user(fd, (int32_t __user *)data))
288 eventfd_ctx_put(*ctx);
290 } else if (fd >= 0) {
291 struct eventfd_ctx *efdctx;
293 efdctx = eventfd_ctx_fdget(fd);
295 return PTR_ERR(efdctx);
298 eventfd_ctx_put(*ctx);
311 static ssize_t vfio_ccw_mdev_ioctl(struct mdev_device *mdev,
319 case VFIO_DEVICE_GET_INFO:
321 struct vfio_device_info info;
323 minsz = offsetofend(struct vfio_device_info, num_irqs);
325 if (copy_from_user(&info, (void __user *)arg, minsz))
328 if (info.argsz < minsz)
331 ret = vfio_ccw_mdev_get_device_info(&info);
335 return copy_to_user((void __user *)arg, &info, minsz);
337 case VFIO_DEVICE_GET_REGION_INFO:
339 struct vfio_region_info info;
341 void *cap_type = NULL;
343 minsz = offsetofend(struct vfio_region_info, offset);
345 if (copy_from_user(&info, (void __user *)arg, minsz))
348 if (info.argsz < minsz)
351 ret = vfio_ccw_mdev_get_region_info(&info, &cap_type_id,
356 return copy_to_user((void __user *)arg, &info, minsz);
358 case VFIO_DEVICE_GET_IRQ_INFO:
360 struct vfio_irq_info info;
362 minsz = offsetofend(struct vfio_irq_info, count);
364 if (copy_from_user(&info, (void __user *)arg, minsz))
367 if (info.argsz < minsz || info.index >= VFIO_CCW_NUM_IRQS)
370 ret = vfio_ccw_mdev_get_irq_info(&info);
374 if (info.count == -1)
377 return copy_to_user((void __user *)arg, &info, minsz);
379 case VFIO_DEVICE_SET_IRQS:
381 struct vfio_irq_set hdr;
385 minsz = offsetofend(struct vfio_irq_set, count);
387 if (copy_from_user(&hdr, (void __user *)arg, minsz))
390 ret = vfio_set_irqs_validate_and_prepare(&hdr, 1,
396 data = (void __user *)(arg + minsz);
397 return vfio_ccw_mdev_set_irqs(mdev, hdr.flags, data);
399 case VFIO_DEVICE_RESET:
400 return vfio_ccw_mdev_reset(mdev);
406 static const struct mdev_parent_ops vfio_ccw_mdev_ops = {
407 .owner = THIS_MODULE,
408 .supported_type_groups = mdev_type_groups,
409 .create = vfio_ccw_mdev_create,
410 .remove = vfio_ccw_mdev_remove,
411 .open = vfio_ccw_mdev_open,
412 .release = vfio_ccw_mdev_release,
413 .read = vfio_ccw_mdev_read,
414 .write = vfio_ccw_mdev_write,
415 .ioctl = vfio_ccw_mdev_ioctl,
418 int vfio_ccw_mdev_reg(struct subchannel *sch)
420 return mdev_register_device(&sch->dev, &vfio_ccw_mdev_ops);
423 void vfio_ccw_mdev_unreg(struct subchannel *sch)
425 mdev_unregister_device(&sch->dev);