drivers/crypto/qat/qat_common/adf_dev_mgr.c

   1 // SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0-only)
   2 /* Copyright(c) 2014 - 2020 Intel Corporation */
   3 #include <linux/mutex.h>
   4 #include <linux/list.h>
   5 #include "adf_cfg.h"
   6 #include "adf_common_drv.h"
   7
   8 static LIST_HEAD(accel_table);
   9 static LIST_HEAD(vfs_table);
  10 static DEFINE_MUTEX(table_lock);
  11 static u32 num_devices;
  12 static u8 id_map[ADF_MAX_DEVICES];
  13
  14 struct vf_id_map {
  15         u32 bdf;
  16         u32 id;
  17         u32 fake_id;
  18         bool attached;
  19         struct list_head list;
  20 };
  21
  22 static int adf_get_vf_id(struct adf_accel_dev *vf)
  23 {
  24         return ((7 * (PCI_SLOT(accel_to_pci_dev(vf)->devfn) - 1)) +
  25                 PCI_FUNC(accel_to_pci_dev(vf)->devfn) +
  26                 (PCI_SLOT(accel_to_pci_dev(vf)->devfn) - 1));
  27 }
  28
  29 static int adf_get_vf_num(struct adf_accel_dev *vf)
  30 {
  31         return (accel_to_pci_dev(vf)->bus->number << 8) | adf_get_vf_id(vf);
  32 }
  33
  34 static struct vf_id_map *adf_find_vf(u32 bdf)
  35 {
  36         struct list_head *itr;
  37
  38         list_for_each(itr, &vfs_table) {
  39                 struct vf_id_map *ptr =
  40                         list_entry(itr, struct vf_id_map, list);
  41
  42                 if (ptr->bdf == bdf)
  43                         return ptr;
  44         }
  45         return NULL;
  46 }
  47
  48 static int adf_get_vf_real_id(u32 fake)
  49 {
  50         struct list_head *itr;
  51
  52         list_for_each(itr, &vfs_table) {
  53                 struct vf_id_map *ptr =
  54                         list_entry(itr, struct vf_id_map, list);
  55                 if (ptr->fake_id == fake)
  56                         return ptr->id;
  57         }
  58         return -1;
  59 }
  60
  61 /**
  62  * adf_clean_vf_map() - Cleans VF id mapings
  63  *
  64  * Function cleans internal ids for virtual functions.
  65  * @vf: flag indicating whether mappings is cleaned
  66  *      for vfs only or for vfs and pfs
  67  */
  68 void adf_clean_vf_map(bool vf)
  69 {
  70         struct vf_id_map *map;
  71         struct list_head *ptr, *tmp;
  72
  73         mutex_lock(&table_lock);
  74         list_for_each_safe(ptr, tmp, &vfs_table) {
  75                 map = list_entry(ptr, struct vf_id_map, list);
  76                 if (map->bdf != -1) {
  77                         id_map[map->id] = 0;
  78                         num_devices--;
  79                 }
  80
  81                 if (vf && map->bdf == -1)
  82                         continue;
  83
  84                 list_del(ptr);
  85                 kfree(map);
  86         }
  87         mutex_unlock(&table_lock);
  88 }
  89 EXPORT_SYMBOL_GPL(adf_clean_vf_map);
  90
  91 /**
  92  * adf_devmgr_update_class_index() - Update internal index
  93  * @hw_data:  Pointer to internal device data.
  94  *
  95  * Function updates internal dev index for VFs
  96  */
  97 void adf_devmgr_update_class_index(struct adf_hw_device_data *hw_data)
  98 {
  99         struct adf_hw_device_class *class = hw_data->dev_class;
 100         struct list_head *itr;
 101         int i = 0;
 102
 103         list_for_each(itr, &accel_table) {
 104                 struct adf_accel_dev *ptr =
 105                                 list_entry(itr, struct adf_accel_dev, list);
 106
 107                 if (ptr->hw_device->dev_class == class)
 108                         ptr->hw_device->instance_id = i++;
 109
 110                 if (i == class->instances)
 111                         break;
 112         }
 113 }
 114 EXPORT_SYMBOL_GPL(adf_devmgr_update_class_index);
 115
 116 static unsigned int adf_find_free_id(void)
 117 {
 118         unsigned int i;
 119
 120         for (i = 0; i < ADF_MAX_DEVICES; i++) {
 121                 if (!id_map[i]) {
 122                         id_map[i] = 1;
 123                         return i;
 124                 }
 125         }
 126         return ADF_MAX_DEVICES + 1;
 127 }
 128
 129 /**
 130  * adf_devmgr_add_dev() - Add accel_dev to the acceleration framework
 131  * @accel_dev:  Pointer to acceleration device.
 132  * @pf:         Corresponding PF if the accel_dev is a VF
 133  *
 134  * Function adds acceleration device to the acceleration framework.
 135  * To be used by QAT device specific drivers.
 136  *
 137  * Return: 0 on success, error code otherwise.
 138  */
 139 int adf_devmgr_add_dev(struct adf_accel_dev *accel_dev,
 140                        struct adf_accel_dev *pf)
 141 {
 142         struct list_head *itr;
 143         int ret = 0;
 144
 145         if (num_devices == ADF_MAX_DEVICES) {
 146                 dev_err(&GET_DEV(accel_dev), "Only support up to %d devices\n",
 147                         ADF_MAX_DEVICES);
 148                 return -EFAULT;
 149         }
 150
 151         mutex_lock(&table_lock);
 152         atomic_set(&accel_dev->ref_count, 0);
 153
 154         /* PF on host or VF on guest */
 155         if (!accel_dev->is_vf || (accel_dev->is_vf && !pf)) {
 156                 struct vf_id_map *map;
 157
 158                 list_for_each(itr, &accel_table) {
 159                         struct adf_accel_dev *ptr =
 160                                 list_entry(itr, struct adf_accel_dev, list);
 161
 162                         if (ptr == accel_dev) {
 163                                 ret = -EEXIST;
 164                                 goto unlock;
 165                         }
 166                 }
 167
 168                 list_add_tail(&accel_dev->list, &accel_table);
 169                 accel_dev->accel_id = adf_find_free_id();
 170                 if (accel_dev->accel_id > ADF_MAX_DEVICES) {
 171                         ret = -EFAULT;
 172                         goto unlock;
 173                 }
 174                 num_devices++;
 175                 map = kzalloc(sizeof(*map), GFP_KERNEL);
 176                 if (!map) {
 177                         ret = -ENOMEM;
 178                         goto unlock;
 179                 }
 180                 map->bdf = ~0;
 181                 map->id = accel_dev->accel_id;
 182                 map->fake_id = map->id;
 183                 map->attached = true;
 184                 list_add_tail(&map->list, &vfs_table);
 185         } else if (accel_dev->is_vf && pf) {
 186                 /* VF on host */
 187                 struct vf_id_map *map;
 188
 189                 map = adf_find_vf(adf_get_vf_num(accel_dev));
 190                 if (map) {
 191                         struct vf_id_map *next;
 192
 193                         accel_dev->accel_id = map->id;
 194                         list_add_tail(&accel_dev->list, &accel_table);
 195                         map->fake_id++;
 196                         map->attached = true;
 197                         next = list_next_entry(map, list);
 198                         while (next && &next->list != &vfs_table) {
 199                                 next->fake_id++;
 200                                 next = list_next_entry(next, list);
 201                         }
 202
 203                         ret = 0;
 204                         goto unlock;
 205                 }
 206
 207                 map = kzalloc(sizeof(*map), GFP_KERNEL);
 208                 if (!map) {
 209                         ret = -ENOMEM;
 210                         goto unlock;
 211                 }
 212                 accel_dev->accel_id = adf_find_free_id();
 213                 if (accel_dev->accel_id > ADF_MAX_DEVICES) {
 214                         kfree(map);
 215                         ret = -EFAULT;
 216                         goto unlock;
 217                 }
 218                 num_devices++;
 219                 list_add_tail(&accel_dev->list, &accel_table);
 220                 map->bdf = adf_get_vf_num(accel_dev);
 221                 map->id = accel_dev->accel_id;
 222                 map->fake_id = map->id;
 223                 map->attached = true;
 224                 list_add_tail(&map->list, &vfs_table);
 225         }
 226 unlock:
 227         mutex_unlock(&table_lock);
 228         return ret;
 229 }
 230 EXPORT_SYMBOL_GPL(adf_devmgr_add_dev);
 231
 232 struct list_head *adf_devmgr_get_head(void)
 233 {
 234         return &accel_table;
 235 }
 236
 237 /**
 238  * adf_devmgr_rm_dev() - Remove accel_dev from the acceleration framework.
 239  * @accel_dev:  Pointer to acceleration device.
 240  * @pf:         Corresponding PF if the accel_dev is a VF
 241  *
 242  * Function removes acceleration device from the acceleration framework.
 243  * To be used by QAT device specific drivers.
 244  *
 245  * Return: void
 246  */
 247 void adf_devmgr_rm_dev(struct adf_accel_dev *accel_dev,
 248                        struct adf_accel_dev *pf)
 249 {
 250         mutex_lock(&table_lock);
 251         if (!accel_dev->is_vf || (accel_dev->is_vf && !pf)) {
 252                 id_map[accel_dev->accel_id] = 0;
 253                 num_devices--;
 254         } else if (accel_dev->is_vf && pf) {
 255                 struct vf_id_map *map, *next;
 256
 257                 map = adf_find_vf(adf_get_vf_num(accel_dev));
 258                 if (!map) {
 259                         dev_err(&GET_DEV(accel_dev), "Failed to find VF map\n");
 260                         goto unlock;
 261                 }
 262                 map->fake_id--;
 263                 map->attached = false;
 264                 next = list_next_entry(map, list);
 265                 while (next && &next->list != &vfs_table) {
 266                         next->fake_id--;
 267                         next = list_next_entry(next, list);
 268                 }
 269         }
 270 unlock:
 271         list_del(&accel_dev->list);
 272         mutex_unlock(&table_lock);
 273 }
 274 EXPORT_SYMBOL_GPL(adf_devmgr_rm_dev);
 275
 276 struct adf_accel_dev *adf_devmgr_get_first(void)
 277 {
 278         struct adf_accel_dev *dev = NULL;
 279
 280         if (!list_empty(&accel_table))
 281                 dev = list_first_entry(&accel_table, struct adf_accel_dev,
 282                                        list);
 283         return dev;
 284 }
 285
 286 /**
 287  * adf_devmgr_pci_to_accel_dev() - Get accel_dev associated with the pci_dev.
 288  * @pci_dev:  Pointer to pci device.
 289  *
 290  * Function returns acceleration device associated with the given pci device.
 291  * To be used by QAT device specific drivers.
 292  *
 293  * Return: pointer to accel_dev or NULL if not found.
 294  */
 295 struct adf_accel_dev *adf_devmgr_pci_to_accel_dev(struct pci_dev *pci_dev)
 296 {
 297         struct list_head *itr;
 298
 299         mutex_lock(&table_lock);
 300         list_for_each(itr, &accel_table) {
 301                 struct adf_accel_dev *ptr =
 302                                 list_entry(itr, struct adf_accel_dev, list);
 303
 304                 if (ptr->accel_pci_dev.pci_dev == pci_dev) {
 305                         mutex_unlock(&table_lock);
 306                         return ptr;
 307                 }
 308         }
 309         mutex_unlock(&table_lock);
 310         return NULL;
 311 }
 312 EXPORT_SYMBOL_GPL(adf_devmgr_pci_to_accel_dev);
 313
 314 struct adf_accel_dev *adf_devmgr_get_dev_by_id(u32 id)
 315 {
 316         struct list_head *itr;
 317         int real_id;
 318
 319         mutex_lock(&table_lock);
 320         real_id = adf_get_vf_real_id(id);
 321         if (real_id < 0)
 322                 goto unlock;
 323
 324         id = real_id;
 325
 326         list_for_each(itr, &accel_table) {
 327                 struct adf_accel_dev *ptr =
 328                                 list_entry(itr, struct adf_accel_dev, list);
 329                 if (ptr->accel_id == id) {
 330                         mutex_unlock(&table_lock);
 331                         return ptr;
 332                 }
 333         }
 334 unlock:
 335         mutex_unlock(&table_lock);
 336         return NULL;
 337 }
 338
 339 int adf_devmgr_verify_id(u32 id)
 340 {
 341         if (id == ADF_CFG_ALL_DEVICES)
 342                 return 0;
 343
 344         if (adf_devmgr_get_dev_by_id(id))
 345                 return 0;
 346
 347         return -ENODEV;
 348 }
 349
 350 static int adf_get_num_dettached_vfs(void)
 351 {
 352         struct list_head *itr;
 353         int vfs = 0;
 354
 355         mutex_lock(&table_lock);
 356         list_for_each(itr, &vfs_table) {
 357                 struct vf_id_map *ptr =
 358                         list_entry(itr, struct vf_id_map, list);
 359                 if (ptr->bdf != ~0 && !ptr->attached)
 360                         vfs++;
 361         }
 362         mutex_unlock(&table_lock);
 363         return vfs;
 364 }
 365
 366 void adf_devmgr_get_num_dev(u32 *num)
 367 {
 368         *num = num_devices - adf_get_num_dettached_vfs();
 369 }
 370
 371 /**
 372  * adf_dev_in_use() - Check whether accel_dev is currently in use
 373  * @accel_dev: Pointer to acceleration device.
 374  *
 375  * To be used by QAT device specific drivers.
 376  *
 377  * Return: 1 when device is in use, 0 otherwise.
 378  */
 379 int adf_dev_in_use(struct adf_accel_dev *accel_dev)
 380 {
 381         return atomic_read(&accel_dev->ref_count) != 0;
 382 }
 383 EXPORT_SYMBOL_GPL(adf_dev_in_use);
 384
 385 /**
 386  * adf_dev_get() - Increment accel_dev reference count
 387  * @accel_dev: Pointer to acceleration device.
 388  *
 389  * Increment the accel_dev refcount and if this is the first time
 390  * incrementing it during this period the accel_dev is in use,
 391  * increment the module refcount too.
 392  * To be used by QAT device specific drivers.
 393  *
 394  * Return: 0 when successful, EFAULT when fail to bump module refcount
 395  */
 396 int adf_dev_get(struct adf_accel_dev *accel_dev)
 397 {
 398         if (atomic_add_return(1, &accel_dev->ref_count) == 1)
 399                 if (!try_module_get(accel_dev->owner))
 400                         return -EFAULT;
 401         return 0;
 402 }
 403 EXPORT_SYMBOL_GPL(adf_dev_get);
 404
 405 /**
 406  * adf_dev_put() - Decrement accel_dev reference count
 407  * @accel_dev: Pointer to acceleration device.
 408  *
 409  * Decrement the accel_dev refcount and if this is the last time
 410  * decrementing it during this period the accel_dev is in use,
 411  * decrement the module refcount too.
 412  * To be used by QAT device specific drivers.
 413  *
 414  * Return: void
 415  */
 416 void adf_dev_put(struct adf_accel_dev *accel_dev)
 417 {
 418         if (atomic_sub_return(1, &accel_dev->ref_count) == 0)
 419                 module_put(accel_dev->owner);
 420 }
 421 EXPORT_SYMBOL_GPL(adf_dev_put);
 422
 423 /**
 424  * adf_devmgr_in_reset() - Check whether device is in reset
 425  * @accel_dev: Pointer to acceleration device.
 426  *
 427  * To be used by QAT device specific drivers.
 428  *
 429  * Return: 1 when the device is being reset, 0 otherwise.
 430  */
 431 int adf_devmgr_in_reset(struct adf_accel_dev *accel_dev)
 432 {
 433         return test_bit(ADF_STATUS_RESTARTING, &accel_dev->status);
 434 }
 435 EXPORT_SYMBOL_GPL(adf_devmgr_in_reset);
 436
 437 /**
 438  * adf_dev_started() - Check whether device has started
 439  * @accel_dev: Pointer to acceleration device.
 440  *
 441  * To be used by QAT device specific drivers.
 442  *
 443  * Return: 1 when the device has started, 0 otherwise
 444  */
 445 int adf_dev_started(struct adf_accel_dev *accel_dev)
 446 {
 447         return test_bit(ADF_STATUS_STARTED, &accel_dev->status);
 448 }
 449 EXPORT_SYMBOL_GPL(adf_dev_started);