drivers/crypto/intel/qat/qat_common/adf_sysfs.c

   1 // SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0-only)
   2 /* Copyright(c) 2022 Intel Corporation */
   3 #include <linux/device.h>
   4 #include <linux/errno.h>
   5 #include <linux/pci.h>
   6 #include "adf_accel_devices.h"
   7 #include "adf_cfg.h"
   8 #include "adf_cfg_services.h"
   9 #include "adf_common_drv.h"
  10
  11 #define UNSET_RING_NUM -1
  12
  13 static const char * const state_operations[] = {
  14         [DEV_DOWN] = "down",
  15         [DEV_UP] = "up",
  16 };
  17
  18 static ssize_t state_show(struct device *dev, struct device_attribute *attr,
  19                           char *buf)
  20 {
  21         struct adf_accel_dev *accel_dev;
  22         char *state;
  23
  24         accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev));
  25         if (!accel_dev)
  26                 return -EINVAL;
  27
  28         state = adf_dev_started(accel_dev) ? "up" : "down";
  29         return sysfs_emit(buf, "%s\n", state);
  30 }
  31
  32 static ssize_t state_store(struct device *dev, struct device_attribute *attr,
  33                            const char *buf, size_t count)
  34 {
  35         struct adf_accel_dev *accel_dev;
  36         u32 accel_id;
  37         int ret;
  38
  39         accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev));
  40         if (!accel_dev)
  41                 return -EINVAL;
  42
  43         accel_id = accel_dev->accel_id;
  44
  45         if (adf_devmgr_in_reset(accel_dev) || adf_dev_in_use(accel_dev)) {
  46                 dev_info(dev, "Device qat_dev%d is busy\n", accel_id);
  47                 return -EBUSY;
  48         }
  49
  50         ret = sysfs_match_string(state_operations, buf);
  51         if (ret < 0)
  52                 return ret;
  53
  54         switch (ret) {
  55         case DEV_DOWN:
  56                 dev_info(dev, "Stopping device qat_dev%d\n", accel_id);
  57
  58                 if (!adf_dev_started(accel_dev)) {
  59                         dev_info(&GET_DEV(accel_dev), "Device qat_dev%d already down\n",
  60                                  accel_id);
  61
  62                         break;
  63                 }
  64
  65                 ret = adf_dev_down(accel_dev);
  66                 if (ret)
  67                         return ret;
  68
  69                 break;
  70         case DEV_UP:
  71                 dev_info(dev, "Starting device qat_dev%d\n", accel_id);
  72
  73                 ret = adf_dev_up(accel_dev, true);
  74                 if (ret == -EALREADY) {
  75                         break;
  76                 } else if (ret) {
  77                         dev_err(dev, "Failed to start device qat_dev%d\n",
  78                                 accel_id);
  79                         adf_dev_down(accel_dev);
  80                         return ret;
  81                 }
  82                 break;
  83         default:
  84                 return -EINVAL;
  85         }
  86
  87         return count;
  88 }
  89
  90 static ssize_t cfg_services_show(struct device *dev, struct device_attribute *attr,
  91                                  char *buf)
  92 {
  93         char services[ADF_CFG_MAX_VAL_LEN_IN_BYTES] = {0};
  94         struct adf_accel_dev *accel_dev;
  95         int ret;
  96
  97         accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev));
  98         if (!accel_dev)
  99                 return -EINVAL;
 100
 101         ret = adf_cfg_get_param_value(accel_dev, ADF_GENERAL_SEC,
 102                                       ADF_SERVICES_ENABLED, services);
 103         if (ret)
 104                 return ret;
 105
 106         return sysfs_emit(buf, "%s\n", services);
 107 }
 108
 109 static int adf_sysfs_update_dev_config(struct adf_accel_dev *accel_dev,
 110                                        const char *services)
 111 {
 112         return adf_cfg_add_key_value_param(accel_dev, ADF_GENERAL_SEC,
 113                                            ADF_SERVICES_ENABLED, services,
 114                                            ADF_STR);
 115 }
 116
 117 static ssize_t cfg_services_store(struct device *dev, struct device_attribute *attr,
 118                                   const char *buf, size_t count)
 119 {
 120         struct adf_hw_device_data *hw_data;
 121         struct adf_accel_dev *accel_dev;
 122         int ret;
 123
 124         ret = sysfs_match_string(adf_cfg_services, buf);
 125         if (ret < 0)
 126                 return ret;
 127
 128         accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev));
 129         if (!accel_dev)
 130                 return -EINVAL;
 131
 132         if (adf_dev_started(accel_dev)) {
 133                 dev_info(dev, "Device qat_dev%d must be down to reconfigure the service.\n",
 134                          accel_dev->accel_id);
 135                 return -EINVAL;
 136         }
 137
 138         ret = adf_sysfs_update_dev_config(accel_dev, adf_cfg_services[ret]);
 139         if (ret < 0)
 140                 return ret;
 141
 142         hw_data = GET_HW_DATA(accel_dev);
 143
 144         /* Update capabilities mask after change in configuration.
 145          * A call to this function is required as capabilities are, at the
 146          * moment, tied to configuration
 147          */
 148         hw_data->accel_capabilities_mask = hw_data->get_accel_cap(accel_dev);
 149         if (!hw_data->accel_capabilities_mask)
 150                 return -EINVAL;
 151
 152         return count;
 153 }
 154
 155 static ssize_t pm_idle_enabled_show(struct device *dev, struct device_attribute *attr,
 156                                     char *buf)
 157 {
 158         char pm_idle_enabled[ADF_CFG_MAX_VAL_LEN_IN_BYTES] = {};
 159         struct adf_accel_dev *accel_dev;
 160         int ret;
 161
 162         accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev));
 163         if (!accel_dev)
 164                 return -EINVAL;
 165
 166         ret = adf_cfg_get_param_value(accel_dev, ADF_GENERAL_SEC,
 167                                       ADF_PM_IDLE_SUPPORT, pm_idle_enabled);
 168         if (ret)
 169                 return sysfs_emit(buf, "1\n");
 170
 171         return sysfs_emit(buf, "%s\n", pm_idle_enabled);
 172 }
 173
 174 static ssize_t pm_idle_enabled_store(struct device *dev, struct device_attribute *attr,
 175                                      const char *buf, size_t count)
 176 {
 177         unsigned long pm_idle_enabled_cfg_val;
 178         struct adf_accel_dev *accel_dev;
 179         bool pm_idle_enabled;
 180         int ret;
 181
 182         ret = kstrtobool(buf, &pm_idle_enabled);
 183         if (ret)
 184                 return ret;
 185
 186         pm_idle_enabled_cfg_val = pm_idle_enabled;
 187         accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev));
 188         if (!accel_dev)
 189                 return -EINVAL;
 190
 191         if (adf_dev_started(accel_dev)) {
 192                 dev_info(dev, "Device qat_dev%d must be down to set pm_idle_enabled.\n",
 193                          accel_dev->accel_id);
 194                 return -EINVAL;
 195         }
 196
 197         ret = adf_cfg_add_key_value_param(accel_dev, ADF_GENERAL_SEC,
 198                                           ADF_PM_IDLE_SUPPORT, &pm_idle_enabled_cfg_val,
 199                                           ADF_DEC);
 200         if (ret)
 201                 return ret;
 202
 203         return count;
 204 }
 205 static DEVICE_ATTR_RW(pm_idle_enabled);
 206
 207 static ssize_t auto_reset_show(struct device *dev, struct device_attribute *attr,
 208                                char *buf)
 209 {
 210         char *auto_reset;
 211         struct adf_accel_dev *accel_dev;
 212
 213         accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev));
 214         if (!accel_dev)
 215                 return -EINVAL;
 216
 217         auto_reset = accel_dev->autoreset_on_error ? "on" : "off";
 218
 219         return sysfs_emit(buf, "%s\n", auto_reset);
 220 }
 221
 222 static ssize_t auto_reset_store(struct device *dev, struct device_attribute *attr,
 223                                 const char *buf, size_t count)
 224 {
 225         struct adf_accel_dev *accel_dev;
 226         bool enabled = false;
 227         int ret;
 228
 229         ret = kstrtobool(buf, &enabled);
 230         if (ret)
 231                 return ret;
 232
 233         accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev));
 234         if (!accel_dev)
 235                 return -EINVAL;
 236
 237         accel_dev->autoreset_on_error = enabled;
 238
 239         return count;
 240 }
 241 static DEVICE_ATTR_RW(auto_reset);
 242
 243 static DEVICE_ATTR_RW(state);
 244 static DEVICE_ATTR_RW(cfg_services);
 245
 246 static ssize_t rp2srv_show(struct device *dev, struct device_attribute *attr,
 247                            char *buf)
 248 {
 249         struct adf_hw_device_data *hw_data;
 250         struct adf_accel_dev *accel_dev;
 251         enum adf_cfg_service_type svc;
 252
 253         accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev));
 254         if (!accel_dev)
 255                 return -EINVAL;
 256
 257         hw_data = GET_HW_DATA(accel_dev);
 258
 259         if (accel_dev->sysfs.ring_num == UNSET_RING_NUM)
 260                 return -EINVAL;
 261
 262         down_read(&accel_dev->sysfs.lock);
 263         svc = GET_SRV_TYPE(accel_dev, accel_dev->sysfs.ring_num %
 264                                               hw_data->num_banks_per_vf);
 265         up_read(&accel_dev->sysfs.lock);
 266
 267         switch (svc) {
 268         case COMP:
 269                 return sysfs_emit(buf, "%s\n", ADF_CFG_DC);
 270         case SYM:
 271                 return sysfs_emit(buf, "%s\n", ADF_CFG_SYM);
 272         case ASYM:
 273                 return sysfs_emit(buf, "%s\n", ADF_CFG_ASYM);
 274         default:
 275                 break;
 276         }
 277         return -EINVAL;
 278 }
 279
 280 static ssize_t rp2srv_store(struct device *dev, struct device_attribute *attr,
 281                             const char *buf, size_t count)
 282 {
 283         struct adf_accel_dev *accel_dev;
 284         int num_rings, ret;
 285         unsigned int ring;
 286
 287         accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev));
 288         if (!accel_dev)
 289                 return -EINVAL;
 290
 291         ret = kstrtouint(buf, 10, &ring);
 292         if (ret)
 293                 return ret;
 294
 295         num_rings = GET_MAX_BANKS(accel_dev);
 296         if (ring >= num_rings) {
 297                 dev_err(&GET_DEV(accel_dev),
 298                         "Device does not support more than %u ring pairs\n",
 299                         num_rings);
 300                 return -EINVAL;
 301         }
 302
 303         down_write(&accel_dev->sysfs.lock);
 304         accel_dev->sysfs.ring_num = ring;
 305         up_write(&accel_dev->sysfs.lock);
 306
 307         return count;
 308 }
 309 static DEVICE_ATTR_RW(rp2srv);
 310
 311 static ssize_t num_rps_show(struct device *dev, struct device_attribute *attr,
 312                             char *buf)
 313 {
 314         struct adf_accel_dev *accel_dev;
 315
 316         accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev));
 317         if (!accel_dev)
 318                 return -EINVAL;
 319
 320         return sysfs_emit(buf, "%u\n", GET_MAX_BANKS(accel_dev));
 321 }
 322 static DEVICE_ATTR_RO(num_rps);
 323
 324 static struct attribute *qat_attrs[] = {
 325         &dev_attr_state.attr,
 326         &dev_attr_cfg_services.attr,
 327         &dev_attr_pm_idle_enabled.attr,
 328         &dev_attr_rp2srv.attr,
 329         &dev_attr_num_rps.attr,
 330         &dev_attr_auto_reset.attr,
 331         NULL,
 332 };
 333
 334 static struct attribute_group qat_group = {
 335         .attrs = qat_attrs,
 336         .name = "qat",
 337 };
 338
 339 int adf_sysfs_init(struct adf_accel_dev *accel_dev)
 340 {
 341         int ret;
 342
 343         ret = devm_device_add_group(&GET_DEV(accel_dev), &qat_group);
 344         if (ret) {
 345                 dev_err(&GET_DEV(accel_dev),
 346                         "Failed to create qat attribute group: %d\n", ret);
 347         }
 348
 349         accel_dev->sysfs.ring_num = UNSET_RING_NUM;
 350
 351         return ret;
 352 }
 353 EXPORT_SYMBOL_GPL(adf_sysfs_init);