1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright(c) 2023 Advanced Micro Devices, Inc. */ 3 4 #include <linux/vfio.h> 5 #include <linux/vfio_pci_core.h> 6 7 #include "lm.h" 8 #include "vfio_dev.h" 9 10 struct pci_dev *pds_vfio_to_pci_dev(struct pds_vfio_pci_device *pds_vfio) 11 { 12 return pds_vfio->vfio_coredev.pdev; 13 } 14 15 struct device *pds_vfio_to_dev(struct pds_vfio_pci_device *pds_vfio) 16 { 17 return &pds_vfio_to_pci_dev(pds_vfio)->dev; 18 } 19 20 struct pds_vfio_pci_device *pds_vfio_pci_drvdata(struct pci_dev *pdev) 21 { 22 struct vfio_pci_core_device *core_device = dev_get_drvdata(&pdev->dev); 23 24 return container_of(core_device, struct pds_vfio_pci_device, 25 vfio_coredev); 26 } 27 28 static void pds_vfio_state_mutex_unlock(struct pds_vfio_pci_device *pds_vfio) 29 { 30 again: 31 spin_lock(&pds_vfio->reset_lock); 32 if (pds_vfio->deferred_reset) { 33 pds_vfio->deferred_reset = false; 34 if (pds_vfio->state == VFIO_DEVICE_STATE_ERROR) { 35 pds_vfio->state = VFIO_DEVICE_STATE_RUNNING; 36 pds_vfio_put_restore_file(pds_vfio); 37 pds_vfio_put_save_file(pds_vfio); 38 } 39 spin_unlock(&pds_vfio->reset_lock); 40 goto again; 41 } 42 mutex_unlock(&pds_vfio->state_mutex); 43 spin_unlock(&pds_vfio->reset_lock); 44 } 45 46 void pds_vfio_reset(struct pds_vfio_pci_device *pds_vfio) 47 { 48 spin_lock(&pds_vfio->reset_lock); 49 pds_vfio->deferred_reset = true; 50 if (!mutex_trylock(&pds_vfio->state_mutex)) { 51 spin_unlock(&pds_vfio->reset_lock); 52 return; 53 } 54 spin_unlock(&pds_vfio->reset_lock); 55 pds_vfio_state_mutex_unlock(pds_vfio); 56 } 57 58 static struct file * 59 pds_vfio_set_device_state(struct vfio_device *vdev, 60 enum vfio_device_mig_state new_state) 61 { 62 struct pds_vfio_pci_device *pds_vfio = 63 container_of(vdev, struct pds_vfio_pci_device, 64 vfio_coredev.vdev); 65 struct file *res = NULL; 66 67 mutex_lock(&pds_vfio->state_mutex); 68 while (new_state != pds_vfio->state) { 69 enum vfio_device_mig_state next_state; 70 71 int err = vfio_mig_get_next_state(vdev, pds_vfio->state, 72 new_state, &next_state); 73 if (err) { 74 res = ERR_PTR(err); 75 break; 76 } 77 78 res = pds_vfio_step_device_state_locked(pds_vfio, next_state); 79 if (IS_ERR(res)) 80 break; 81 82 pds_vfio->state = next_state; 83 84 if (WARN_ON(res && new_state != pds_vfio->state)) { 85 res = ERR_PTR(-EINVAL); 86 break; 87 } 88 } 89 pds_vfio_state_mutex_unlock(pds_vfio); 90 91 return res; 92 } 93 94 static int pds_vfio_get_device_state(struct vfio_device *vdev, 95 enum vfio_device_mig_state *current_state) 96 { 97 struct pds_vfio_pci_device *pds_vfio = 98 container_of(vdev, struct pds_vfio_pci_device, 99 vfio_coredev.vdev); 100 101 mutex_lock(&pds_vfio->state_mutex); 102 *current_state = pds_vfio->state; 103 pds_vfio_state_mutex_unlock(pds_vfio); 104 return 0; 105 } 106 107 static int pds_vfio_get_device_state_size(struct vfio_device *vdev, 108 unsigned long *stop_copy_length) 109 { 110 *stop_copy_length = PDS_LM_DEVICE_STATE_LENGTH; 111 return 0; 112 } 113 114 static const struct vfio_migration_ops pds_vfio_lm_ops = { 115 .migration_set_state = pds_vfio_set_device_state, 116 .migration_get_state = pds_vfio_get_device_state, 117 .migration_get_data_size = pds_vfio_get_device_state_size 118 }; 119 120 static int pds_vfio_init_device(struct vfio_device *vdev) 121 { 122 struct pds_vfio_pci_device *pds_vfio = 123 container_of(vdev, struct pds_vfio_pci_device, 124 vfio_coredev.vdev); 125 struct pci_dev *pdev = to_pci_dev(vdev->dev); 126 int err, vf_id, pci_id; 127 128 vf_id = pci_iov_vf_id(pdev); 129 if (vf_id < 0) 130 return vf_id; 131 132 err = vfio_pci_core_init_dev(vdev); 133 if (err) 134 return err; 135 136 pds_vfio->vf_id = vf_id; 137 138 vdev->migration_flags = VFIO_MIGRATION_STOP_COPY | VFIO_MIGRATION_P2P; 139 vdev->mig_ops = &pds_vfio_lm_ops; 140 141 pci_id = PCI_DEVID(pdev->bus->number, pdev->devfn); 142 dev_dbg(&pdev->dev, 143 "%s: PF %#04x VF %#04x vf_id %d domain %d pds_vfio %p\n", 144 __func__, pci_dev_id(pdev->physfn), pci_id, vf_id, 145 pci_domain_nr(pdev->bus), pds_vfio); 146 147 return 0; 148 } 149 150 static int pds_vfio_open_device(struct vfio_device *vdev) 151 { 152 struct pds_vfio_pci_device *pds_vfio = 153 container_of(vdev, struct pds_vfio_pci_device, 154 vfio_coredev.vdev); 155 int err; 156 157 err = vfio_pci_core_enable(&pds_vfio->vfio_coredev); 158 if (err) 159 return err; 160 161 mutex_init(&pds_vfio->state_mutex); 162 pds_vfio->state = VFIO_DEVICE_STATE_RUNNING; 163 164 vfio_pci_core_finish_enable(&pds_vfio->vfio_coredev); 165 166 return 0; 167 } 168 169 static void pds_vfio_close_device(struct vfio_device *vdev) 170 { 171 struct pds_vfio_pci_device *pds_vfio = 172 container_of(vdev, struct pds_vfio_pci_device, 173 vfio_coredev.vdev); 174 175 mutex_lock(&pds_vfio->state_mutex); 176 pds_vfio_put_restore_file(pds_vfio); 177 pds_vfio_put_save_file(pds_vfio); 178 mutex_unlock(&pds_vfio->state_mutex); 179 mutex_destroy(&pds_vfio->state_mutex); 180 vfio_pci_core_close_device(vdev); 181 } 182 183 static const struct vfio_device_ops pds_vfio_ops = { 184 .name = "pds-vfio", 185 .init = pds_vfio_init_device, 186 .release = vfio_pci_core_release_dev, 187 .open_device = pds_vfio_open_device, 188 .close_device = pds_vfio_close_device, 189 .ioctl = vfio_pci_core_ioctl, 190 .device_feature = vfio_pci_core_ioctl_feature, 191 .read = vfio_pci_core_read, 192 .write = vfio_pci_core_write, 193 .mmap = vfio_pci_core_mmap, 194 .request = vfio_pci_core_request, 195 .match = vfio_pci_core_match, 196 .bind_iommufd = vfio_iommufd_physical_bind, 197 .unbind_iommufd = vfio_iommufd_physical_unbind, 198 .attach_ioas = vfio_iommufd_physical_attach_ioas, 199 }; 200 201 const struct vfio_device_ops *pds_vfio_ops_info(void) 202 { 203 return &pds_vfio_ops; 204 } 205