kernel/drivers/crypto/qat/qat_common/adf_dev_mgr.c

   1 /*
   2   This file is provided under a dual BSD/GPLv2 license.  When using or
   3   redistributing this file, you may do so under either license.
   4
   5   GPL LICENSE SUMMARY
   6   Copyright(c) 2014 Intel Corporation.
   7   This program is free software; you can redistribute it and/or modify
   8   it under the terms of version 2 of the GNU General Public License as
   9   published by the Free Software Foundation.
  10
  11   This program is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14   General Public License for more details.
  15
  16   Contact Information:
  17   qat-linux@intel.com
  18
  19   BSD LICENSE
  20   Copyright(c) 2014 Intel Corporation.
  21   Redistribution and use in source and binary forms, with or without
  22   modification, are permitted provided that the following conditions
  23   are met:
  24
  25     * Redistributions of source code must retain the above copyright
  26       notice, this list of conditions and the following disclaimer.
  27     * Redistributions in binary form must reproduce the above copyright
  28       notice, this list of conditions and the following disclaimer in
  29       the documentation and/or other materials provided with the
  30       distribution.
  31     * Neither the name of Intel Corporation nor the names of its
  32       contributors may be used to endorse or promote products derived
  33       from this software without specific prior written permission.
  34
  35   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  36   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  37   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  38   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  39   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  42   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  43   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  44   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  45   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  46 */
  47 #include <linux/mutex.h>
  48 #include <linux/list.h>
  49 #include "adf_cfg.h"
  50 #include "adf_common_drv.h"
  51
  52 static LIST_HEAD(accel_table);
  53 static LIST_HEAD(vfs_table);
  54 static DEFINE_MUTEX(table_lock);
  55 static uint32_t num_devices;
  56
  57 struct vf_id_map {
  58         u32 bdf;
  59         u32 id;
  60         u32 fake_id;
  61         bool attached;
  62         struct list_head list;
  63 };
  64
  65 static int adf_get_vf_id(struct adf_accel_dev *vf)
  66 {
  67         return ((7 * (PCI_SLOT(accel_to_pci_dev(vf)->devfn) - 1)) +
  68                 PCI_FUNC(accel_to_pci_dev(vf)->devfn) +
  69                 (PCI_SLOT(accel_to_pci_dev(vf)->devfn) - 1));
  70 }
  71
  72 static int adf_get_vf_num(struct adf_accel_dev *vf)
  73 {
  74         return (accel_to_pci_dev(vf)->bus->number << 8) | adf_get_vf_id(vf);
  75 }
  76
  77 static struct vf_id_map *adf_find_vf(u32 bdf)
  78 {
  79         struct list_head *itr;
  80
  81         list_for_each(itr, &vfs_table) {
  82                 struct vf_id_map *ptr =
  83                         list_entry(itr, struct vf_id_map, list);
  84
  85                 if (ptr->bdf == bdf)
  86                         return ptr;
  87         }
  88         return NULL;
  89 }
  90
  91 static int adf_get_vf_real_id(u32 fake)
  92 {
  93         struct list_head *itr;
  94
  95         list_for_each(itr, &vfs_table) {
  96                 struct vf_id_map *ptr =
  97                         list_entry(itr, struct vf_id_map, list);
  98                 if (ptr->fake_id == fake)
  99                         return ptr->id;
 100         }
 101         return -1;
 102 }
 103
 104 /**
 105  * adf_clean_vf_map() - Cleans VF id mapings
 106  *
 107  * Function cleans internal ids for virtual functions.
 108  * @vf: flag indicating whether mappings is cleaned
 109  *      for vfs only or for vfs and pfs
 110  */
 111 void adf_clean_vf_map(bool vf)
 112 {
 113         struct vf_id_map *map;
 114         struct list_head *ptr, *tmp;
 115
 116         mutex_lock(&table_lock);
 117         list_for_each_safe(ptr, tmp, &vfs_table) {
 118                 map = list_entry(ptr, struct vf_id_map, list);
 119                 if (map->bdf != -1)
 120                         num_devices--;
 121
 122                 if (vf && map->bdf == -1)
 123                         continue;
 124
 125                 list_del(ptr);
 126                 kfree(map);
 127         }
 128         mutex_unlock(&table_lock);
 129 }
 130 EXPORT_SYMBOL_GPL(adf_clean_vf_map);
 131
 132 /**
 133  * adf_devmgr_update_class_index() - Update internal index
 134  * @hw_data:  Pointer to internal device data.
 135  *
 136  * Function updates internal dev index for VFs
 137  */
 138 void adf_devmgr_update_class_index(struct adf_hw_device_data *hw_data)
 139 {
 140         struct adf_hw_device_class *class = hw_data->dev_class;
 141         struct list_head *itr;
 142         int i = 0;
 143
 144         list_for_each(itr, &accel_table) {
 145                 struct adf_accel_dev *ptr =
 146                                 list_entry(itr, struct adf_accel_dev, list);
 147
 148                 if (ptr->hw_device->dev_class == class)
 149                         ptr->hw_device->instance_id = i++;
 150
 151                 if (i == class->instances)
 152                                 break;
 153         }
 154 }
 155 EXPORT_SYMBOL_GPL(adf_devmgr_update_class_index);
 156
 157 /**
 158  * adf_devmgr_add_dev() - Add accel_dev to the acceleration framework
 159  * @accel_dev:  Pointer to acceleration device.
 160  * @pf:         Corresponding PF if the accel_dev is a VF
 161  *
 162  * Function adds acceleration device to the acceleration framework.
 163  * To be used by QAT device specific drivers.
 164  *
 165  * Return: 0 on success, error code otherwise.
 166  */
 167 int adf_devmgr_add_dev(struct adf_accel_dev *accel_dev,
 168                        struct adf_accel_dev *pf)
 169 {
 170         struct list_head *itr;
 171         int ret = 0;
 172
 173         if (num_devices == ADF_MAX_DEVICES) {
 174                 dev_err(&GET_DEV(accel_dev), "Only support up to %d devices\n",
 175                         ADF_MAX_DEVICES);
 176                 return -EFAULT;
 177         }
 178
 179         mutex_lock(&table_lock);
 180         atomic_set(&accel_dev->ref_count, 0);
 181
 182         /* PF on host or VF on guest */
 183         if (!accel_dev->is_vf || (accel_dev->is_vf && !pf)) {
 184                 struct vf_id_map *map;
 185
 186                 list_for_each(itr, &accel_table) {
 187                         struct adf_accel_dev *ptr =
 188                                 list_entry(itr, struct adf_accel_dev, list);
 189
 190                         if (ptr == accel_dev) {
 191                                 ret = -EEXIST;
 192                                 goto unlock;
 193                         }
 194                 }
 195
 196                 list_add_tail(&accel_dev->list, &accel_table);
 197                 accel_dev->accel_id = num_devices++;
 198
 199                 map = kzalloc(sizeof(*map), GFP_KERNEL);
 200                 if (!map) {
 201                         ret = -ENOMEM;
 202                         goto unlock;
 203                 }
 204                 map->bdf = ~0;
 205                 map->id = accel_dev->accel_id;
 206                 map->fake_id = map->id;
 207                 map->attached = true;
 208                 list_add_tail(&map->list, &vfs_table);
 209         } else if (accel_dev->is_vf && pf) {
 210                 /* VF on host */
 211                 struct adf_accel_vf_info *vf_info;
 212                 struct vf_id_map *map;
 213
 214                 vf_info = pf->pf.vf_info + adf_get_vf_id(accel_dev);
 215
 216                 map = adf_find_vf(adf_get_vf_num(accel_dev));
 217                 if (map) {
 218                         struct vf_id_map *next;
 219
 220                         accel_dev->accel_id = map->id;
 221                         list_add_tail(&accel_dev->list, &accel_table);
 222                         map->fake_id++;
 223                         map->attached = true;
 224                         next = list_next_entry(map, list);
 225                         while (next && &next->list != &vfs_table) {
 226                                 next->fake_id++;
 227                                 next = list_next_entry(next, list);
 228                         }
 229
 230                         ret = 0;
 231                         goto unlock;
 232                 }
 233
 234                 map = kzalloc(sizeof(*map), GFP_KERNEL);
 235                 if (!map) {
 236                         ret = -ENOMEM;
 237                         goto unlock;
 238                 }
 239
 240                 accel_dev->accel_id = num_devices++;
 241                 list_add_tail(&accel_dev->list, &accel_table);
 242                 map->bdf = adf_get_vf_num(accel_dev);
 243                 map->id = accel_dev->accel_id;
 244                 map->fake_id = map->id;
 245                 map->attached = true;
 246                 list_add_tail(&map->list, &vfs_table);
 247         }
 248 unlock:
 249         mutex_unlock(&table_lock);
 250         return ret;
 251 }
 252 EXPORT_SYMBOL_GPL(adf_devmgr_add_dev);
 253
 254 struct list_head *adf_devmgr_get_head(void)
 255 {
 256         return &accel_table;
 257 }
 258
 259 /**
 260  * adf_devmgr_rm_dev() - Remove accel_dev from the acceleration framework.
 261  * @accel_dev:  Pointer to acceleration device.
 262  * @pf:         Corresponding PF if the accel_dev is a VF
 263  *
 264  * Function removes acceleration device from the acceleration framework.
 265  * To be used by QAT device specific drivers.
 266  *
 267  * Return: void
 268  */
 269 void adf_devmgr_rm_dev(struct adf_accel_dev *accel_dev,
 270                        struct adf_accel_dev *pf)
 271 {
 272         mutex_lock(&table_lock);
 273         if (!accel_dev->is_vf || (accel_dev->is_vf && !pf)) {
 274                 num_devices--;
 275         } else if (accel_dev->is_vf && pf) {
 276                 struct vf_id_map *map, *next;
 277
 278                 map = adf_find_vf(adf_get_vf_num(accel_dev));
 279                 if (!map) {
 280                         dev_err(&GET_DEV(accel_dev), "Failed to find VF map\n");
 281                         goto unlock;
 282                 }
 283                 map->fake_id--;
 284                 map->attached = false;
 285                 next = list_next_entry(map, list);
 286                 while (next && &next->list != &vfs_table) {
 287                         next->fake_id--;
 288                         next = list_next_entry(next, list);
 289                 }
 290         }
 291 unlock:
 292         list_del(&accel_dev->list);
 293         mutex_unlock(&table_lock);
 294 }
 295 EXPORT_SYMBOL_GPL(adf_devmgr_rm_dev);
 296
 297 struct adf_accel_dev *adf_devmgr_get_first(void)
 298 {
 299         struct adf_accel_dev *dev = NULL;
 300
 301         if (!list_empty(&accel_table))
 302                 dev = list_first_entry(&accel_table, struct adf_accel_dev,
 303                                        list);
 304         return dev;
 305 }
 306
 307 /**
 308  * adf_devmgr_pci_to_accel_dev() - Get accel_dev associated with the pci_dev.
 309  * @accel_dev:  Pointer to pci device.
 310  *
 311  * Function returns acceleration device associated with the given pci device.
 312  * To be used by QAT device specific drivers.
 313  *
 314  * Return: pointer to accel_dev or NULL if not found.
 315  */
 316 struct adf_accel_dev *adf_devmgr_pci_to_accel_dev(struct pci_dev *pci_dev)
 317 {
 318         struct list_head *itr;
 319
 320         mutex_lock(&table_lock);
 321         list_for_each(itr, &accel_table) {
 322                 struct adf_accel_dev *ptr =
 323                                 list_entry(itr, struct adf_accel_dev, list);
 324
 325                 if (ptr->accel_pci_dev.pci_dev == pci_dev) {
 326                         mutex_unlock(&table_lock);
 327                         return ptr;
 328                 }
 329         }
 330         mutex_unlock(&table_lock);
 331         return NULL;
 332 }
 333 EXPORT_SYMBOL_GPL(adf_devmgr_pci_to_accel_dev);
 334
 335 struct adf_accel_dev *adf_devmgr_get_dev_by_id(uint32_t id)
 336 {
 337         struct list_head *itr;
 338         int real_id;
 339
 340         mutex_lock(&table_lock);
 341         real_id = adf_get_vf_real_id(id);
 342         if (real_id < 0)
 343                 goto unlock;
 344
 345         id = real_id;
 346
 347         list_for_each(itr, &accel_table) {
 348                 struct adf_accel_dev *ptr =
 349                                 list_entry(itr, struct adf_accel_dev, list);
 350                 if (ptr->accel_id == id) {
 351                         mutex_unlock(&table_lock);
 352                         return ptr;
 353                 }
 354         }
 355 unlock:
 356         mutex_unlock(&table_lock);
 357         return NULL;
 358 }
 359
 360 int adf_devmgr_verify_id(uint32_t id)
 361 {
 362         if (id == ADF_CFG_ALL_DEVICES)
 363                 return 0;
 364
 365         if (adf_devmgr_get_dev_by_id(id))
 366                 return 0;
 367
 368         return -ENODEV;
 369 }
 370
 371 static int adf_get_num_dettached_vfs(void)
 372 {
 373         struct list_head *itr;
 374         int vfs = 0;
 375
 376         mutex_lock(&table_lock);
 377         list_for_each(itr, &vfs_table) {
 378                 struct vf_id_map *ptr =
 379                         list_entry(itr, struct vf_id_map, list);
 380                 if (ptr->bdf != ~0 && !ptr->attached)
 381                         vfs++;
 382         }
 383         mutex_unlock(&table_lock);
 384         return vfs;
 385 }
 386
 387 void adf_devmgr_get_num_dev(uint32_t *num)
 388 {
 389         *num = num_devices - adf_get_num_dettached_vfs();
 390 }
 391
 392 /**
 393  * adf_dev_in_use() - Check whether accel_dev is currently in use
 394  * @accel_dev: Pointer to acceleration device.
 395  *
 396  * To be used by QAT device specific drivers.
 397  *
 398  * Return: 1 when device is in use, 0 otherwise.
 399  */
 400 int adf_dev_in_use(struct adf_accel_dev *accel_dev)
 401 {
 402         return atomic_read(&accel_dev->ref_count) != 0;
 403 }
 404 EXPORT_SYMBOL_GPL(adf_dev_in_use);
 405
 406 /**
 407  * adf_dev_get() - Increment accel_dev reference count
 408  * @accel_dev: Pointer to acceleration device.
 409  *
 410  * Increment the accel_dev refcount and if this is the first time
 411  * incrementing it during this period the accel_dev is in use,
 412  * increment the module refcount too.
 413  * To be used by QAT device specific drivers.
 414  *
 415  * Return: 0 when successful, EFAULT when fail to bump module refcount
 416  */
 417 int adf_dev_get(struct adf_accel_dev *accel_dev)
 418 {
 419         if (atomic_add_return(1, &accel_dev->ref_count) == 1)
 420                 if (!try_module_get(accel_dev->owner))
 421                         return -EFAULT;
 422         return 0;
 423 }
 424 EXPORT_SYMBOL_GPL(adf_dev_get);
 425
 426 /**
 427  * adf_dev_put() - Decrement accel_dev reference count
 428  * @accel_dev: Pointer to acceleration device.
 429  *
 430  * Decrement the accel_dev refcount and if this is the last time
 431  * decrementing it during this period the accel_dev is in use,
 432  * decrement the module refcount too.
 433  * To be used by QAT device specific drivers.
 434  *
 435  * Return: void
 436  */
 437 void adf_dev_put(struct adf_accel_dev *accel_dev)
 438 {
 439         if (atomic_sub_return(1, &accel_dev->ref_count) == 0)
 440                 module_put(accel_dev->owner);
 441 }
 442 EXPORT_SYMBOL_GPL(adf_dev_put);
 443
 444 /**
 445  * adf_devmgr_in_reset() - Check whether device is in reset
 446  * @accel_dev: Pointer to acceleration device.
 447  *
 448  * To be used by QAT device specific drivers.
 449  *
 450  * Return: 1 when the device is being reset, 0 otherwise.
 451  */
 452 int adf_devmgr_in_reset(struct adf_accel_dev *accel_dev)
 453 {
 454         return test_bit(ADF_STATUS_RESTARTING, &accel_dev->status);
 455 }
 456 EXPORT_SYMBOL_GPL(adf_devmgr_in_reset);
 457
 458 /**
 459  * adf_dev_started() - Check whether device has started
 460  * @accel_dev: Pointer to acceleration device.
 461  *
 462  * To be used by QAT device specific drivers.
 463  *
 464  * Return: 1 when the device has started, 0 otherwise
 465  */
 466 int adf_dev_started(struct adf_accel_dev *accel_dev)
 467 {
 468         return test_bit(ADF_STATUS_STARTED, &accel_dev->status);
 469 }
 470 EXPORT_SYMBOL_GPL(adf_dev_started);