1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * VFIO based AP device driver 4 * 5 * Copyright IBM Corp. 2018 6 * 7 * Author(s): Tony Krowiak <akrowiak@linux.ibm.com> 8 * Pierre Morel <pmorel@linux.ibm.com> 9 */ 10 11 #include <linux/module.h> 12 #include <linux/mod_devicetable.h> 13 #include <linux/slab.h> 14 #include <linux/string.h> 15 #include <asm/facility.h> 16 #include "vfio_ap_private.h" 17 #include "vfio_ap_debug.h" 18 19 #define VFIO_AP_ROOT_NAME "vfio_ap" 20 #define VFIO_AP_DEV_NAME "matrix" 21 #define AP_QUEUE_ASSIGNED "assigned" 22 #define AP_QUEUE_UNASSIGNED "unassigned" 23 #define AP_QUEUE_IN_USE "in use" 24 25 MODULE_AUTHOR("IBM Corporation"); 26 MODULE_DESCRIPTION("VFIO AP device driver, Copyright IBM Corp. 2018"); 27 MODULE_LICENSE("GPL v2"); 28 29 struct ap_matrix_dev *matrix_dev; 30 debug_info_t *vfio_ap_dbf_info; 31 32 /* Only type 10 adapters (CEX4 and later) are supported 33 * by the AP matrix device driver 34 */ 35 static struct ap_device_id ap_queue_ids[] = { 36 { .dev_type = AP_DEVICE_TYPE_CEX4, 37 .match_flags = AP_DEVICE_ID_MATCH_QUEUE_TYPE }, 38 { .dev_type = AP_DEVICE_TYPE_CEX5, 39 .match_flags = AP_DEVICE_ID_MATCH_QUEUE_TYPE }, 40 { .dev_type = AP_DEVICE_TYPE_CEX6, 41 .match_flags = AP_DEVICE_ID_MATCH_QUEUE_TYPE }, 42 { .dev_type = AP_DEVICE_TYPE_CEX7, 43 .match_flags = AP_DEVICE_ID_MATCH_QUEUE_TYPE }, 44 { .dev_type = AP_DEVICE_TYPE_CEX8, 45 .match_flags = AP_DEVICE_ID_MATCH_QUEUE_TYPE }, 46 { /* end of sibling */ }, 47 }; 48 49 static struct ap_matrix_mdev *vfio_ap_mdev_for_queue(struct vfio_ap_queue *q) 50 { 51 struct ap_matrix_mdev *matrix_mdev; 52 unsigned long apid = AP_QID_CARD(q->apqn); 53 unsigned long apqi = AP_QID_QUEUE(q->apqn); 54 55 list_for_each_entry(matrix_mdev, &matrix_dev->mdev_list, node) { 56 if (test_bit_inv(apid, matrix_mdev->matrix.apm) && 57 test_bit_inv(apqi, matrix_mdev->matrix.aqm)) 58 return matrix_mdev; 59 } 60 61 return NULL; 62 } 63 64 static ssize_t status_show(struct device *dev, 65 struct device_attribute *attr, 66 char *buf) 67 { 68 ssize_t nchars = 0; 69 struct vfio_ap_queue *q; 70 struct ap_matrix_mdev *matrix_mdev; 71 struct ap_device *apdev = to_ap_dev(dev); 72 73 mutex_lock(&matrix_dev->lock); 74 q = dev_get_drvdata(&apdev->device); 75 matrix_mdev = vfio_ap_mdev_for_queue(q); 76 77 if (matrix_mdev) { 78 if (matrix_mdev->kvm) 79 nchars = scnprintf(buf, PAGE_SIZE, "%s\n", 80 AP_QUEUE_IN_USE); 81 else 82 nchars = scnprintf(buf, PAGE_SIZE, "%s\n", 83 AP_QUEUE_ASSIGNED); 84 } else { 85 nchars = scnprintf(buf, PAGE_SIZE, "%s\n", 86 AP_QUEUE_UNASSIGNED); 87 } 88 89 mutex_unlock(&matrix_dev->lock); 90 91 return nchars; 92 } 93 94 static DEVICE_ATTR_RO(status); 95 96 static struct attribute *vfio_queue_attrs[] = { 97 &dev_attr_status.attr, 98 NULL, 99 }; 100 101 static const struct attribute_group vfio_queue_attr_group = { 102 .attrs = vfio_queue_attrs, 103 }; 104 105 /** 106 * vfio_ap_queue_dev_probe: Allocate a vfio_ap_queue structure and associate it 107 * with the device as driver_data. 108 * 109 * @apdev: the AP device being probed 110 * 111 * Return: returns 0 if the probe succeeded; otherwise, returns an error if 112 * storage could not be allocated for a vfio_ap_queue object or the 113 * sysfs 'status' attribute could not be created for the queue device. 114 */ 115 static int vfio_ap_queue_dev_probe(struct ap_device *apdev) 116 { 117 int ret; 118 struct vfio_ap_queue *q; 119 120 q = kzalloc(sizeof(*q), GFP_KERNEL); 121 if (!q) 122 return -ENOMEM; 123 124 mutex_lock(&matrix_dev->lock); 125 dev_set_drvdata(&apdev->device, q); 126 q->apqn = to_ap_queue(&apdev->device)->qid; 127 q->saved_isc = VFIO_AP_ISC_INVALID; 128 129 ret = sysfs_create_group(&apdev->device.kobj, &vfio_queue_attr_group); 130 if (ret) { 131 dev_set_drvdata(&apdev->device, NULL); 132 kfree(q); 133 } 134 135 mutex_unlock(&matrix_dev->lock); 136 137 return ret; 138 } 139 140 /** 141 * vfio_ap_queue_dev_remove: Free the associated vfio_ap_queue structure. 142 * 143 * @apdev: the AP device being removed 144 * 145 * Takes the matrix lock to avoid actions on this device while doing the remove. 146 */ 147 static void vfio_ap_queue_dev_remove(struct ap_device *apdev) 148 { 149 struct vfio_ap_queue *q; 150 151 mutex_lock(&matrix_dev->lock); 152 sysfs_remove_group(&apdev->device.kobj, &vfio_queue_attr_group); 153 q = dev_get_drvdata(&apdev->device); 154 vfio_ap_mdev_reset_queue(q, 1); 155 dev_set_drvdata(&apdev->device, NULL); 156 kfree(q); 157 mutex_unlock(&matrix_dev->lock); 158 } 159 160 static struct ap_driver vfio_ap_drv = { 161 .probe = vfio_ap_queue_dev_probe, 162 .remove = vfio_ap_queue_dev_remove, 163 .ids = ap_queue_ids, 164 }; 165 166 static void vfio_ap_matrix_dev_release(struct device *dev) 167 { 168 struct ap_matrix_dev *matrix_dev = dev_get_drvdata(dev); 169 170 kfree(matrix_dev); 171 } 172 173 static int matrix_bus_match(struct device *dev, struct device_driver *drv) 174 { 175 return 1; 176 } 177 178 static struct bus_type matrix_bus = { 179 .name = "matrix", 180 .match = &matrix_bus_match, 181 }; 182 183 static struct device_driver matrix_driver = { 184 .name = "vfio_ap", 185 .bus = &matrix_bus, 186 .suppress_bind_attrs = true, 187 }; 188 189 static int vfio_ap_matrix_dev_create(void) 190 { 191 int ret; 192 struct device *root_device; 193 194 root_device = root_device_register(VFIO_AP_ROOT_NAME); 195 if (IS_ERR(root_device)) 196 return PTR_ERR(root_device); 197 198 ret = bus_register(&matrix_bus); 199 if (ret) 200 goto bus_register_err; 201 202 matrix_dev = kzalloc(sizeof(*matrix_dev), GFP_KERNEL); 203 if (!matrix_dev) { 204 ret = -ENOMEM; 205 goto matrix_alloc_err; 206 } 207 208 /* Fill in config info via PQAP(QCI), if available */ 209 if (test_facility(12)) { 210 ret = ap_qci(&matrix_dev->info); 211 if (ret) 212 goto matrix_alloc_err; 213 } 214 215 mutex_init(&matrix_dev->lock); 216 INIT_LIST_HEAD(&matrix_dev->mdev_list); 217 218 dev_set_name(&matrix_dev->device, "%s", VFIO_AP_DEV_NAME); 219 matrix_dev->device.parent = root_device; 220 matrix_dev->device.bus = &matrix_bus; 221 matrix_dev->device.release = vfio_ap_matrix_dev_release; 222 matrix_dev->vfio_ap_drv = &vfio_ap_drv; 223 224 ret = device_register(&matrix_dev->device); 225 if (ret) 226 goto matrix_reg_err; 227 228 ret = driver_register(&matrix_driver); 229 if (ret) 230 goto matrix_drv_err; 231 232 return 0; 233 234 matrix_drv_err: 235 device_unregister(&matrix_dev->device); 236 matrix_reg_err: 237 put_device(&matrix_dev->device); 238 matrix_alloc_err: 239 bus_unregister(&matrix_bus); 240 bus_register_err: 241 root_device_unregister(root_device); 242 return ret; 243 } 244 245 static void vfio_ap_matrix_dev_destroy(void) 246 { 247 struct device *root_device = matrix_dev->device.parent; 248 249 driver_unregister(&matrix_driver); 250 device_unregister(&matrix_dev->device); 251 bus_unregister(&matrix_bus); 252 root_device_unregister(root_device); 253 } 254 255 static int __init vfio_ap_dbf_info_init(void) 256 { 257 vfio_ap_dbf_info = debug_register("vfio_ap", 1, 1, 258 DBF_MAX_SPRINTF_ARGS * sizeof(long)); 259 260 if (!vfio_ap_dbf_info) 261 return -ENOENT; 262 263 debug_register_view(vfio_ap_dbf_info, &debug_sprintf_view); 264 debug_set_level(vfio_ap_dbf_info, DBF_WARN); 265 266 return 0; 267 } 268 269 static int __init vfio_ap_init(void) 270 { 271 int ret; 272 273 ret = vfio_ap_dbf_info_init(); 274 if (ret) 275 return ret; 276 277 /* If there are no AP instructions, there is nothing to pass through. */ 278 if (!ap_instructions_available()) 279 return -ENODEV; 280 281 ret = vfio_ap_matrix_dev_create(); 282 if (ret) 283 return ret; 284 285 ret = ap_driver_register(&vfio_ap_drv, THIS_MODULE, VFIO_AP_DRV_NAME); 286 if (ret) { 287 vfio_ap_matrix_dev_destroy(); 288 return ret; 289 } 290 291 ret = vfio_ap_mdev_register(); 292 if (ret) { 293 ap_driver_unregister(&vfio_ap_drv); 294 vfio_ap_matrix_dev_destroy(); 295 296 return ret; 297 } 298 299 return 0; 300 } 301 302 static void __exit vfio_ap_exit(void) 303 { 304 vfio_ap_mdev_unregister(); 305 ap_driver_unregister(&vfio_ap_drv); 306 vfio_ap_matrix_dev_destroy(); 307 debug_unregister(vfio_ap_dbf_info); 308 } 309 310 module_init(vfio_ap_init); 311 module_exit(vfio_ap_exit); 312