root/drivers/crypto/qat/qat_common/adf_cfg.c

DEFINITIONS

1. qat_dev_cfg_start
2. qat_dev_cfg_show
3. qat_dev_cfg_next
4. qat_dev_cfg_stop
5. qat_dev_cfg_open
6. adf_cfg_dev_add
7. adf_cfg_del_all
8. adf_cfg_dev_remove
9. adf_cfg_keyval_add
10. adf_cfg_keyval_del_all
11. adf_cfg_section_del_all
12. adf_cfg_key_value_find
13. adf_cfg_sec_find
14. adf_cfg_key_val_get
15. adf_cfg_add_key_value_param
16. adf_cfg_section_add
17. adf_cfg_get_param_value

   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/slab.h>
  49 #include <linux/list.h>
  50 #include <linux/seq_file.h>
  51 #include "adf_accel_devices.h"
  52 #include "adf_cfg.h"
  53 #include "adf_common_drv.h"
  54 
  55 static DEFINE_MUTEX(qat_cfg_read_lock);
  56 
  57 static void *qat_dev_cfg_start(struct seq_file *sfile, loff_t *pos)
  58 {
  59         struct adf_cfg_device_data *dev_cfg = sfile->private;
  60 
  61         mutex_lock(&qat_cfg_read_lock);
  62         return seq_list_start(&dev_cfg->sec_list, *pos);
  63 }
  64 
  65 static int qat_dev_cfg_show(struct seq_file *sfile, void *v)
  66 {
  67         struct list_head *list;
  68         struct adf_cfg_section *sec =
  69                                 list_entry(v, struct adf_cfg_section, list);
  70 
  71         seq_printf(sfile, "[%s]\n", sec->name);
  72         list_for_each(list, &sec->param_head) {
  73                 struct adf_cfg_key_val *ptr =
  74                         list_entry(list, struct adf_cfg_key_val, list);
  75                 seq_printf(sfile, "%s = %s\n", ptr->key, ptr->val);
  76         }
  77         return 0;
  78 }
  79 
  80 static void *qat_dev_cfg_next(struct seq_file *sfile, void *v, loff_t *pos)
  81 {
  82         struct adf_cfg_device_data *dev_cfg = sfile->private;
  83 
  84         return seq_list_next(v, &dev_cfg->sec_list, pos);
  85 }
  86 
  87 static void qat_dev_cfg_stop(struct seq_file *sfile, void *v)
  88 {
  89         mutex_unlock(&qat_cfg_read_lock);
  90 }
  91 
  92 static const struct seq_operations qat_dev_cfg_sops = {
  93         .start = qat_dev_cfg_start,
  94         .next = qat_dev_cfg_next,
  95         .stop = qat_dev_cfg_stop,
  96         .show = qat_dev_cfg_show
  97 };
  98 
  99 static int qat_dev_cfg_open(struct inode *inode, struct file *file)
 100 {
 101         int ret = seq_open(file, &qat_dev_cfg_sops);
 102 
 103         if (!ret) {
 104                 struct seq_file *seq_f = file->private_data;
 105 
 106                 seq_f->private = inode->i_private;
 107         }
 108         return ret;
 109 }
 110 
 111 static const struct file_operations qat_dev_cfg_fops = {
 112         .open = qat_dev_cfg_open,
 113         .read = seq_read,
 114         .llseek = seq_lseek,
 115         .release = seq_release
 116 };
 117 
 118 /**
 119  * adf_cfg_dev_add() - Create an acceleration device configuration table.
 120  * @accel_dev:  Pointer to acceleration device.
 121  *
 122  * Function creates a configuration table for the given acceleration device.
 123  * The table stores device specific config values.
 124  * To be used by QAT device specific drivers.
 125  *
 126  * Return: 0 on success, error code otherwise.
 127  */
 128 int adf_cfg_dev_add(struct adf_accel_dev *accel_dev)
 129 {
 130         struct adf_cfg_device_data *dev_cfg_data;
 131 
 132         dev_cfg_data = kzalloc(sizeof(*dev_cfg_data), GFP_KERNEL);
 133         if (!dev_cfg_data)
 134                 return -ENOMEM;
 135         INIT_LIST_HEAD(&dev_cfg_data->sec_list);
 136         init_rwsem(&dev_cfg_data->lock);
 137         accel_dev->cfg = dev_cfg_data;
 138 
 139         /* accel_dev->debugfs_dir should always be non-NULL here */
 140         dev_cfg_data->debug = debugfs_create_file("dev_cfg", S_IRUSR,
 141                                                   accel_dev->debugfs_dir,
 142                                                   dev_cfg_data,
 143                                                   &qat_dev_cfg_fops);
 144         return 0;
 145 }
 146 EXPORT_SYMBOL_GPL(adf_cfg_dev_add);
 147 
 148 static void adf_cfg_section_del_all(struct list_head *head);
 149 
 150 void adf_cfg_del_all(struct adf_accel_dev *accel_dev)
 151 {
 152         struct adf_cfg_device_data *dev_cfg_data = accel_dev->cfg;
 153 
 154         down_write(&dev_cfg_data->lock);
 155         adf_cfg_section_del_all(&dev_cfg_data->sec_list);
 156         up_write(&dev_cfg_data->lock);
 157         clear_bit(ADF_STATUS_CONFIGURED, &accel_dev->status);
 158 }
 159 
 160 /**
 161  * adf_cfg_dev_remove() - Clears acceleration device configuration table.
 162  * @accel_dev:  Pointer to acceleration device.
 163  *
 164  * Function removes configuration table from the given acceleration device
 165  * and frees all allocated memory.
 166  * To be used by QAT device specific drivers.
 167  *
 168  * Return: void
 169  */
 170 void adf_cfg_dev_remove(struct adf_accel_dev *accel_dev)
 171 {
 172         struct adf_cfg_device_data *dev_cfg_data = accel_dev->cfg;
 173 
 174         if (!dev_cfg_data)
 175                 return;
 176 
 177         down_write(&dev_cfg_data->lock);
 178         adf_cfg_section_del_all(&dev_cfg_data->sec_list);
 179         up_write(&dev_cfg_data->lock);
 180         debugfs_remove(dev_cfg_data->debug);
 181         kfree(dev_cfg_data);
 182         accel_dev->cfg = NULL;
 183 }
 184 EXPORT_SYMBOL_GPL(adf_cfg_dev_remove);
 185 
 186 static void adf_cfg_keyval_add(struct adf_cfg_key_val *new,
 187                                struct adf_cfg_section *sec)
 188 {
 189         list_add_tail(&new->list, &sec->param_head);
 190 }
 191 
 192 static void adf_cfg_keyval_del_all(struct list_head *head)
 193 {
 194         struct list_head *list_ptr, *tmp;
 195 
 196         list_for_each_prev_safe(list_ptr, tmp, head) {
 197                 struct adf_cfg_key_val *ptr =
 198                         list_entry(list_ptr, struct adf_cfg_key_val, list);
 199                 list_del(list_ptr);
 200                 kfree(ptr);
 201         }
 202 }
 203 
 204 static void adf_cfg_section_del_all(struct list_head *head)
 205 {
 206         struct adf_cfg_section *ptr;
 207         struct list_head *list, *tmp;
 208 
 209         list_for_each_prev_safe(list, tmp, head) {
 210                 ptr = list_entry(list, struct adf_cfg_section, list);
 211                 adf_cfg_keyval_del_all(&ptr->param_head);
 212                 list_del(list);
 213                 kfree(ptr);
 214         }
 215 }
 216 
 217 static struct adf_cfg_key_val *adf_cfg_key_value_find(struct adf_cfg_section *s,
 218                                                       const char *key)
 219 {
 220         struct list_head *list;
 221 
 222         list_for_each(list, &s->param_head) {
 223                 struct adf_cfg_key_val *ptr =
 224                         list_entry(list, struct adf_cfg_key_val, list);
 225                 if (!strcmp(ptr->key, key))
 226                         return ptr;
 227         }
 228         return NULL;
 229 }
 230 
 231 static struct adf_cfg_section *adf_cfg_sec_find(struct adf_accel_dev *accel_dev,
 232                                                 const char *sec_name)
 233 {
 234         struct adf_cfg_device_data *cfg = accel_dev->cfg;
 235         struct list_head *list;
 236 
 237         list_for_each(list, &cfg->sec_list) {
 238                 struct adf_cfg_section *ptr =
 239                         list_entry(list, struct adf_cfg_section, list);
 240                 if (!strcmp(ptr->name, sec_name))
 241                         return ptr;
 242         }
 243         return NULL;
 244 }
 245 
 246 static int adf_cfg_key_val_get(struct adf_accel_dev *accel_dev,
 247                                const char *sec_name,
 248                                const char *key_name,
 249                                char *val)
 250 {
 251         struct adf_cfg_section *sec = adf_cfg_sec_find(accel_dev, sec_name);
 252         struct adf_cfg_key_val *keyval = NULL;
 253 
 254         if (sec)
 255                 keyval = adf_cfg_key_value_find(sec, key_name);
 256         if (keyval) {
 257                 memcpy(val, keyval->val, ADF_CFG_MAX_VAL_LEN_IN_BYTES);
 258                 return 0;
 259         }
 260         return -1;
 261 }
 262 
 263 /**
 264  * adf_cfg_add_key_value_param() - Add key-value config entry to config table.
 265  * @accel_dev:  Pointer to acceleration device.
 266  * @section_name: Name of the section where the param will be added
 267  * @key: The key string
 268  * @val: Value pain for the given @key
 269  * @type: Type - string, int or address
 270  *
 271  * Function adds configuration key - value entry in the appropriate section
 272  * in the given acceleration device
 273  * To be used by QAT device specific drivers.
 274  *
 275  * Return: 0 on success, error code otherwise.
 276  */
 277 int adf_cfg_add_key_value_param(struct adf_accel_dev *accel_dev,
 278                                 const char *section_name,
 279                                 const char *key, const void *val,
 280                                 enum adf_cfg_val_type type)
 281 {
 282         struct adf_cfg_device_data *cfg = accel_dev->cfg;
 283         struct adf_cfg_key_val *key_val;
 284         struct adf_cfg_section *section = adf_cfg_sec_find(accel_dev,
 285                                                            section_name);
 286         if (!section)
 287                 return -EFAULT;
 288 
 289         key_val = kzalloc(sizeof(*key_val), GFP_KERNEL);
 290         if (!key_val)
 291                 return -ENOMEM;
 292 
 293         INIT_LIST_HEAD(&key_val->list);
 294         strlcpy(key_val->key, key, sizeof(key_val->key));
 295 
 296         if (type == ADF_DEC) {
 297                 snprintf(key_val->val, ADF_CFG_MAX_VAL_LEN_IN_BYTES,
 298                          "%ld", (*((long *)val)));
 299         } else if (type == ADF_STR) {
 300                 strlcpy(key_val->val, (char *)val, sizeof(key_val->val));
 301         } else if (type == ADF_HEX) {
 302                 snprintf(key_val->val, ADF_CFG_MAX_VAL_LEN_IN_BYTES,
 303                          "0x%lx", (unsigned long)val);
 304         } else {
 305                 dev_err(&GET_DEV(accel_dev), "Unknown type given.\n");
 306                 kfree(key_val);
 307                 return -1;
 308         }
 309         key_val->type = type;
 310         down_write(&cfg->lock);
 311         adf_cfg_keyval_add(key_val, section);
 312         up_write(&cfg->lock);
 313         return 0;
 314 }
 315 EXPORT_SYMBOL_GPL(adf_cfg_add_key_value_param);
 316 
 317 /**
 318  * adf_cfg_section_add() - Add config section entry to config table.
 319  * @accel_dev:  Pointer to acceleration device.
 320  * @name: Name of the section
 321  *
 322  * Function adds configuration section where key - value entries
 323  * will be stored.
 324  * To be used by QAT device specific drivers.
 325  *
 326  * Return: 0 on success, error code otherwise.
 327  */
 328 int adf_cfg_section_add(struct adf_accel_dev *accel_dev, const char *name)
 329 {
 330         struct adf_cfg_device_data *cfg = accel_dev->cfg;
 331         struct adf_cfg_section *sec = adf_cfg_sec_find(accel_dev, name);
 332 
 333         if (sec)
 334                 return 0;
 335 
 336         sec = kzalloc(sizeof(*sec), GFP_KERNEL);
 337         if (!sec)
 338                 return -ENOMEM;
 339 
 340         strlcpy(sec->name, name, sizeof(sec->name));
 341         INIT_LIST_HEAD(&sec->param_head);
 342         down_write(&cfg->lock);
 343         list_add_tail(&sec->list, &cfg->sec_list);
 344         up_write(&cfg->lock);
 345         return 0;
 346 }
 347 EXPORT_SYMBOL_GPL(adf_cfg_section_add);
 348 
 349 int adf_cfg_get_param_value(struct adf_accel_dev *accel_dev,
 350                             const char *section, const char *name,
 351                             char *value)
 352 {
 353         struct adf_cfg_device_data *cfg = accel_dev->cfg;
 354         int ret;
 355 
 356         down_read(&cfg->lock);
 357         ret = adf_cfg_key_val_get(accel_dev, section, name, value);
 358         up_read(&cfg->lock);
 359         return ret;
 360 }