1 // SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0-only) 2 /* Copyright(c) 2014 - 2020 Intel Corporation */ 3 4 #include <crypto/algapi.h> 5 #include <linux/module.h> 6 #include <linux/mutex.h> 7 #include <linux/slab.h> 8 #include <linux/fs.h> 9 #include <linux/bitops.h> 10 #include <linux/pci.h> 11 #include <linux/cdev.h> 12 #include <linux/uaccess.h> 13 14 #include "adf_accel_devices.h" 15 #include "adf_common_drv.h" 16 #include "adf_cfg.h" 17 #include "adf_cfg_common.h" 18 #include "adf_cfg_user.h" 19 20 #define ADF_CFG_MAX_SECTION 512 21 #define ADF_CFG_MAX_KEY_VAL 256 22 23 #define DEVICE_NAME "qat_adf_ctl" 24 25 static DEFINE_MUTEX(adf_ctl_lock); 26 static long adf_ctl_ioctl(struct file *fp, unsigned int cmd, unsigned long arg); 27 28 static const struct file_operations adf_ctl_ops = { 29 .owner = THIS_MODULE, 30 .unlocked_ioctl = adf_ctl_ioctl, 31 .compat_ioctl = compat_ptr_ioctl, 32 }; 33 34 static const struct class adf_ctl_class = { 35 .name = DEVICE_NAME, 36 }; 37 38 struct adf_ctl_drv_info { 39 unsigned int major; 40 struct cdev drv_cdev; 41 }; 42 43 static struct adf_ctl_drv_info adf_ctl_drv; 44 45 static void adf_chr_drv_destroy(void) 46 { 47 device_destroy(&adf_ctl_class, MKDEV(adf_ctl_drv.major, 0)); 48 cdev_del(&adf_ctl_drv.drv_cdev); 49 class_unregister(&adf_ctl_class); 50 unregister_chrdev_region(MKDEV(adf_ctl_drv.major, 0), 1); 51 } 52 53 static int adf_chr_drv_create(void) 54 { 55 dev_t dev_id; 56 struct device *drv_device; 57 int ret; 58 59 if (alloc_chrdev_region(&dev_id, 0, 1, DEVICE_NAME)) { 60 pr_err("QAT: unable to allocate chrdev region\n"); 61 return -EFAULT; 62 } 63 64 ret = class_register(&adf_ctl_class); 65 if (ret) 66 goto err_chrdev_unreg; 67 68 adf_ctl_drv.major = MAJOR(dev_id); 69 cdev_init(&adf_ctl_drv.drv_cdev, &adf_ctl_ops); 70 if (cdev_add(&adf_ctl_drv.drv_cdev, dev_id, 1)) { 71 pr_err("QAT: cdev add failed\n"); 72 goto err_class_destr; 73 } 74 75 drv_device = device_create(&adf_ctl_class, NULL, 76 MKDEV(adf_ctl_drv.major, 0), 77 NULL, DEVICE_NAME); 78 if (IS_ERR(drv_device)) { 79 pr_err("QAT: failed to create device\n"); 80 goto err_cdev_del; 81 } 82 return 0; 83 err_cdev_del: 84 cdev_del(&adf_ctl_drv.drv_cdev); 85 err_class_destr: 86 class_unregister(&adf_ctl_class); 87 err_chrdev_unreg: 88 unregister_chrdev_region(dev_id, 1); 89 return -EFAULT; 90 } 91 92 static int adf_ctl_alloc_resources(struct adf_user_cfg_ctl_data **ctl_data, 93 unsigned long arg) 94 { 95 struct adf_user_cfg_ctl_data *cfg_data; 96 97 cfg_data = kzalloc(sizeof(*cfg_data), GFP_KERNEL); 98 if (!cfg_data) 99 return -ENOMEM; 100 101 /* Initialize device id to NO DEVICE as 0 is a valid device id */ 102 cfg_data->device_id = ADF_CFG_NO_DEVICE; 103 104 if (copy_from_user(cfg_data, (void __user *)arg, sizeof(*cfg_data))) { 105 pr_err("QAT: failed to copy from user cfg_data.\n"); 106 kfree(cfg_data); 107 return -EIO; 108 } 109 110 *ctl_data = cfg_data; 111 return 0; 112 } 113 114 static int adf_add_key_value_data(struct adf_accel_dev *accel_dev, 115 const char *section, 116 const struct adf_user_cfg_key_val *key_val) 117 { 118 if (key_val->type == ADF_HEX) { 119 long *ptr = (long *)key_val->val; 120 long val = *ptr; 121 122 if (adf_cfg_add_key_value_param(accel_dev, section, 123 key_val->key, (void *)val, 124 key_val->type)) { 125 dev_err(&GET_DEV(accel_dev), 126 "failed to add hex keyvalue.\n"); 127 return -EFAULT; 128 } 129 } else { 130 if (adf_cfg_add_key_value_param(accel_dev, section, 131 key_val->key, key_val->val, 132 key_val->type)) { 133 dev_err(&GET_DEV(accel_dev), 134 "failed to add keyvalue.\n"); 135 return -EFAULT; 136 } 137 } 138 return 0; 139 } 140 141 static int adf_copy_key_value_data(struct adf_accel_dev *accel_dev, 142 struct adf_user_cfg_ctl_data *ctl_data) 143 { 144 struct adf_user_cfg_key_val key_val; 145 struct adf_user_cfg_key_val *params_head; 146 struct adf_user_cfg_section section, *section_head; 147 int i, j; 148 149 section_head = ctl_data->config_section; 150 151 for (i = 0; section_head && i < ADF_CFG_MAX_SECTION; i++) { 152 if (copy_from_user(§ion, (void __user *)section_head, 153 sizeof(*section_head))) { 154 dev_err(&GET_DEV(accel_dev), 155 "failed to copy section info\n"); 156 goto out_err; 157 } 158 159 if (adf_cfg_section_add(accel_dev, section.name)) { 160 dev_err(&GET_DEV(accel_dev), 161 "failed to add section.\n"); 162 goto out_err; 163 } 164 165 params_head = section.params; 166 167 for (j = 0; params_head && j < ADF_CFG_MAX_KEY_VAL; j++) { 168 if (copy_from_user(&key_val, (void __user *)params_head, 169 sizeof(key_val))) { 170 dev_err(&GET_DEV(accel_dev), 171 "Failed to copy keyvalue.\n"); 172 goto out_err; 173 } 174 if (adf_add_key_value_data(accel_dev, section.name, 175 &key_val)) { 176 goto out_err; 177 } 178 params_head = key_val.next; 179 } 180 section_head = section.next; 181 } 182 return 0; 183 out_err: 184 adf_cfg_del_all(accel_dev); 185 return -EFAULT; 186 } 187 188 static int adf_ctl_ioctl_dev_config(struct file *fp, unsigned int cmd, 189 unsigned long arg) 190 { 191 int ret; 192 struct adf_user_cfg_ctl_data *ctl_data; 193 struct adf_accel_dev *accel_dev; 194 195 ret = adf_ctl_alloc_resources(&ctl_data, arg); 196 if (ret) 197 return ret; 198 199 accel_dev = adf_devmgr_get_dev_by_id(ctl_data->device_id); 200 if (!accel_dev) { 201 ret = -EFAULT; 202 goto out; 203 } 204 205 if (adf_dev_started(accel_dev)) { 206 ret = -EFAULT; 207 goto out; 208 } 209 210 if (adf_copy_key_value_data(accel_dev, ctl_data)) { 211 ret = -EFAULT; 212 goto out; 213 } 214 set_bit(ADF_STATUS_CONFIGURED, &accel_dev->status); 215 out: 216 kfree(ctl_data); 217 return ret; 218 } 219 220 static int adf_ctl_is_device_in_use(int id) 221 { 222 struct adf_accel_dev *dev; 223 224 list_for_each_entry(dev, adf_devmgr_get_head(), list) { 225 if (id == dev->accel_id || id == ADF_CFG_ALL_DEVICES) { 226 if (adf_devmgr_in_reset(dev) || adf_dev_in_use(dev)) { 227 dev_info(&GET_DEV(dev), 228 "device qat_dev%d is busy\n", 229 dev->accel_id); 230 return -EBUSY; 231 } 232 } 233 } 234 return 0; 235 } 236 237 static void adf_ctl_stop_devices(u32 id) 238 { 239 struct adf_accel_dev *accel_dev; 240 241 list_for_each_entry(accel_dev, adf_devmgr_get_head(), list) { 242 if (id == accel_dev->accel_id || id == ADF_CFG_ALL_DEVICES) { 243 if (!adf_dev_started(accel_dev)) 244 continue; 245 246 /* First stop all VFs */ 247 if (!accel_dev->is_vf) 248 continue; 249 250 adf_dev_down(accel_dev); 251 } 252 } 253 254 list_for_each_entry(accel_dev, adf_devmgr_get_head(), list) { 255 if (id == accel_dev->accel_id || id == ADF_CFG_ALL_DEVICES) { 256 if (!adf_dev_started(accel_dev)) 257 continue; 258 259 adf_dev_down(accel_dev); 260 } 261 } 262 } 263 264 static int adf_ctl_ioctl_dev_stop(struct file *fp, unsigned int cmd, 265 unsigned long arg) 266 { 267 int ret; 268 struct adf_user_cfg_ctl_data *ctl_data; 269 270 ret = adf_ctl_alloc_resources(&ctl_data, arg); 271 if (ret) 272 return ret; 273 274 if (adf_devmgr_verify_id(ctl_data->device_id)) { 275 pr_err("QAT: Device %d not found\n", ctl_data->device_id); 276 ret = -ENODEV; 277 goto out; 278 } 279 280 ret = adf_ctl_is_device_in_use(ctl_data->device_id); 281 if (ret) 282 goto out; 283 284 if (ctl_data->device_id == ADF_CFG_ALL_DEVICES) 285 pr_info("QAT: Stopping all acceleration devices.\n"); 286 else 287 pr_info("QAT: Stopping acceleration device qat_dev%d.\n", 288 ctl_data->device_id); 289 290 adf_ctl_stop_devices(ctl_data->device_id); 291 292 out: 293 kfree(ctl_data); 294 return ret; 295 } 296 297 static int adf_ctl_ioctl_dev_start(struct file *fp, unsigned int cmd, 298 unsigned long arg) 299 { 300 int ret; 301 struct adf_user_cfg_ctl_data *ctl_data; 302 struct adf_accel_dev *accel_dev; 303 304 ret = adf_ctl_alloc_resources(&ctl_data, arg); 305 if (ret) 306 return ret; 307 308 ret = -ENODEV; 309 accel_dev = adf_devmgr_get_dev_by_id(ctl_data->device_id); 310 if (!accel_dev) 311 goto out; 312 313 dev_info(&GET_DEV(accel_dev), 314 "Starting acceleration device qat_dev%d.\n", 315 ctl_data->device_id); 316 317 ret = adf_dev_up(accel_dev, false); 318 319 if (ret) { 320 dev_err(&GET_DEV(accel_dev), "Failed to start qat_dev%d\n", 321 ctl_data->device_id); 322 adf_dev_down(accel_dev); 323 } 324 out: 325 kfree(ctl_data); 326 return ret; 327 } 328 329 static int adf_ctl_ioctl_get_num_devices(struct file *fp, unsigned int cmd, 330 unsigned long arg) 331 { 332 u32 num_devices = 0; 333 334 adf_devmgr_get_num_dev(&num_devices); 335 if (copy_to_user((void __user *)arg, &num_devices, sizeof(num_devices))) 336 return -EFAULT; 337 338 return 0; 339 } 340 341 static int adf_ctl_ioctl_get_status(struct file *fp, unsigned int cmd, 342 unsigned long arg) 343 { 344 struct adf_hw_device_data *hw_data; 345 struct adf_dev_status_info dev_info; 346 struct adf_accel_dev *accel_dev; 347 348 if (copy_from_user(&dev_info, (void __user *)arg, 349 sizeof(struct adf_dev_status_info))) { 350 pr_err("QAT: failed to copy from user.\n"); 351 return -EFAULT; 352 } 353 354 accel_dev = adf_devmgr_get_dev_by_id(dev_info.accel_id); 355 if (!accel_dev) 356 return -ENODEV; 357 358 hw_data = accel_dev->hw_device; 359 dev_info.state = adf_dev_started(accel_dev) ? DEV_UP : DEV_DOWN; 360 dev_info.num_ae = hw_data->get_num_aes(hw_data); 361 dev_info.num_accel = hw_data->get_num_accels(hw_data); 362 dev_info.num_logical_accel = hw_data->num_logical_accel; 363 dev_info.banks_per_accel = hw_data->num_banks 364 / hw_data->num_logical_accel; 365 strscpy(dev_info.name, hw_data->dev_class->name, sizeof(dev_info.name)); 366 dev_info.instance_id = hw_data->instance_id; 367 dev_info.type = hw_data->dev_class->type; 368 dev_info.bus = accel_to_pci_dev(accel_dev)->bus->number; 369 dev_info.dev = PCI_SLOT(accel_to_pci_dev(accel_dev)->devfn); 370 dev_info.fun = PCI_FUNC(accel_to_pci_dev(accel_dev)->devfn); 371 372 if (copy_to_user((void __user *)arg, &dev_info, 373 sizeof(struct adf_dev_status_info))) { 374 dev_err(&GET_DEV(accel_dev), "failed to copy status.\n"); 375 return -EFAULT; 376 } 377 return 0; 378 } 379 380 static long adf_ctl_ioctl(struct file *fp, unsigned int cmd, unsigned long arg) 381 { 382 int ret; 383 384 if (mutex_lock_interruptible(&adf_ctl_lock)) 385 return -EFAULT; 386 387 switch (cmd) { 388 case IOCTL_CONFIG_SYS_RESOURCE_PARAMETERS: 389 ret = adf_ctl_ioctl_dev_config(fp, cmd, arg); 390 break; 391 392 case IOCTL_STOP_ACCEL_DEV: 393 ret = adf_ctl_ioctl_dev_stop(fp, cmd, arg); 394 break; 395 396 case IOCTL_START_ACCEL_DEV: 397 ret = adf_ctl_ioctl_dev_start(fp, cmd, arg); 398 break; 399 400 case IOCTL_GET_NUM_DEVICES: 401 ret = adf_ctl_ioctl_get_num_devices(fp, cmd, arg); 402 break; 403 404 case IOCTL_STATUS_ACCEL_DEV: 405 ret = adf_ctl_ioctl_get_status(fp, cmd, arg); 406 break; 407 default: 408 pr_err_ratelimited("QAT: Invalid ioctl %d\n", cmd); 409 ret = -EFAULT; 410 break; 411 } 412 mutex_unlock(&adf_ctl_lock); 413 return ret; 414 } 415 416 static int __init adf_register_ctl_device_driver(void) 417 { 418 if (adf_chr_drv_create()) 419 goto err_chr_dev; 420 421 if (adf_init_misc_wq()) 422 goto err_misc_wq; 423 424 if (adf_init_aer()) 425 goto err_aer; 426 427 if (adf_init_pf_wq()) 428 goto err_pf_wq; 429 430 if (adf_init_vf_wq()) 431 goto err_vf_wq; 432 433 if (qat_crypto_register()) 434 goto err_crypto_register; 435 436 if (qat_compression_register()) 437 goto err_compression_register; 438 439 return 0; 440 441 err_compression_register: 442 qat_crypto_unregister(); 443 err_crypto_register: 444 adf_exit_vf_wq(); 445 err_vf_wq: 446 adf_exit_pf_wq(); 447 err_pf_wq: 448 adf_exit_aer(); 449 err_aer: 450 adf_exit_misc_wq(); 451 err_misc_wq: 452 adf_chr_drv_destroy(); 453 err_chr_dev: 454 mutex_destroy(&adf_ctl_lock); 455 return -EFAULT; 456 } 457 458 static void __exit adf_unregister_ctl_device_driver(void) 459 { 460 adf_chr_drv_destroy(); 461 adf_exit_misc_wq(); 462 adf_exit_aer(); 463 adf_exit_vf_wq(); 464 adf_exit_pf_wq(); 465 qat_crypto_unregister(); 466 qat_compression_unregister(); 467 adf_clean_vf_map(false); 468 mutex_destroy(&adf_ctl_lock); 469 } 470 471 module_init(adf_register_ctl_device_driver); 472 module_exit(adf_unregister_ctl_device_driver); 473 MODULE_LICENSE("Dual BSD/GPL"); 474 MODULE_AUTHOR("Intel"); 475 MODULE_DESCRIPTION("Intel(R) QuickAssist Technology"); 476 MODULE_ALIAS_CRYPTO("intel_qat"); 477 MODULE_VERSION(ADF_DRV_VERSION); 478 MODULE_IMPORT_NS(CRYPTO_INTERNAL); 479