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

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* Copyright(c) 2023 Intel Corporation */
   3
   4 #define dev_fmt(fmt) "RateLimiting: " fmt
   5
   6 #include <linux/dev_printk.h>
   7 #include <linux/pci.h>
   8 #include <linux/sysfs.h>
   9 #include <linux/types.h>
  10
  11 #include "adf_common_drv.h"
  12 #include "adf_rl.h"
  13 #include "adf_sysfs_rl.h"
  14
  15 #define GET_RL_STRUCT(accel_dev) ((accel_dev)->rate_limiting->user_input)
  16
  17 enum rl_ops {
  18         ADD,
  19         UPDATE,
  20         RM,
  21         RM_ALL,
  22         GET,
  23 };
  24
  25 enum rl_params {
  26         RP_MASK,
  27         ID,
  28         CIR,
  29         PIR,
  30         SRV,
  31         CAP_REM_SRV,
  32 };
  33
  34 static const char *const rl_services[] = {
  35         [ADF_SVC_ASYM] = "asym",
  36         [ADF_SVC_SYM] = "sym",
  37         [ADF_SVC_DC] = "dc",
  38 };
  39
  40 static const char *const rl_operations[] = {
  41         [ADD] = "add",
  42         [UPDATE] = "update",
  43         [RM] = "rm",
  44         [RM_ALL] = "rm_all",
  45         [GET] = "get",
  46 };
  47
  48 static int set_param_u(struct device *dev, enum rl_params param, u64 set)
  49 {
  50         struct adf_rl_interface_data *data;
  51         struct adf_accel_dev *accel_dev;
  52         int ret = 0;
  53
  54         accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev));
  55         if (!accel_dev)
  56                 return -EINVAL;
  57
  58         data = &GET_RL_STRUCT(accel_dev);
  59
  60         down_write(&data->lock);
  61         switch (param) {
  62         case RP_MASK:
  63                 data->input.rp_mask = set;
  64                 break;
  65         case CIR:
  66                 data->input.cir = set;
  67                 break;
  68         case PIR:
  69                 data->input.pir = set;
  70                 break;
  71         case SRV:
  72                 data->input.srv = set;
  73                 break;
  74         case CAP_REM_SRV:
  75                 data->cap_rem_srv = set;
  76                 break;
  77         default:
  78                 ret = -EINVAL;
  79                 break;
  80         }
  81         up_write(&data->lock);
  82
  83         return ret;
  84 }
  85
  86 static int set_param_s(struct device *dev, enum rl_params param, int set)
  87 {
  88         struct adf_rl_interface_data *data;
  89         struct adf_accel_dev *accel_dev;
  90
  91         accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev));
  92         if (!accel_dev || param != ID)
  93                 return -EINVAL;
  94
  95         data = &GET_RL_STRUCT(accel_dev);
  96
  97         down_write(&data->lock);
  98         data->input.sla_id = set;
  99         up_write(&data->lock);
 100
 101         return 0;
 102 }
 103
 104 static int get_param_u(struct device *dev, enum rl_params param, u64 *get)
 105 {
 106         struct adf_rl_interface_data *data;
 107         struct adf_accel_dev *accel_dev;
 108         int ret = 0;
 109
 110         accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev));
 111         if (!accel_dev)
 112                 return -EINVAL;
 113
 114         data = &GET_RL_STRUCT(accel_dev);
 115
 116         down_read(&data->lock);
 117         switch (param) {
 118         case RP_MASK:
 119                 *get = data->input.rp_mask;
 120                 break;
 121         case CIR:
 122                 *get = data->input.cir;
 123                 break;
 124         case PIR:
 125                 *get = data->input.pir;
 126                 break;
 127         case SRV:
 128                 *get = data->input.srv;
 129                 break;
 130         default:
 131                 ret = -EINVAL;
 132         }
 133         up_read(&data->lock);
 134
 135         return ret;
 136 }
 137
 138 static int get_param_s(struct device *dev, enum rl_params param)
 139 {
 140         struct adf_rl_interface_data *data;
 141         struct adf_accel_dev *accel_dev;
 142         int ret = 0;
 143
 144         accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev));
 145         if (!accel_dev)
 146                 return -EINVAL;
 147
 148         data = &GET_RL_STRUCT(accel_dev);
 149
 150         down_read(&data->lock);
 151         if (param == ID)
 152                 ret = data->input.sla_id;
 153         up_read(&data->lock);
 154
 155         return ret;
 156 }
 157
 158 static ssize_t rp_show(struct device *dev, struct device_attribute *attr,
 159                        char *buf)
 160 {
 161         int ret;
 162         u64 get;
 163
 164         ret = get_param_u(dev, RP_MASK, &get);
 165         if (ret)
 166                 return ret;
 167
 168         return sysfs_emit(buf, "%#llx\n", get);
 169 }
 170
 171 static ssize_t rp_store(struct device *dev, struct device_attribute *attr,
 172                         const char *buf, size_t count)
 173 {
 174         int err;
 175         u64 val;
 176
 177         err = kstrtou64(buf, 16, &val);
 178         if (err)
 179                 return err;
 180
 181         err = set_param_u(dev, RP_MASK, val);
 182         if (err)
 183                 return err;
 184
 185         return count;
 186 }
 187 static DEVICE_ATTR_RW(rp);
 188
 189 static ssize_t id_show(struct device *dev, struct device_attribute *attr,
 190                        char *buf)
 191 {
 192         return sysfs_emit(buf, "%d\n", get_param_s(dev, ID));
 193 }
 194
 195 static ssize_t id_store(struct device *dev, struct device_attribute *attr,
 196                         const char *buf, size_t count)
 197 {
 198         int err;
 199         int val;
 200
 201         err = kstrtoint(buf, 10, &val);
 202         if (err)
 203                 return err;
 204
 205         err = set_param_s(dev, ID, val);
 206         if (err)
 207                 return err;
 208
 209         return count;
 210 }
 211 static DEVICE_ATTR_RW(id);
 212
 213 static ssize_t cir_show(struct device *dev, struct device_attribute *attr,
 214                         char *buf)
 215 {
 216         int ret;
 217         u64 get;
 218
 219         ret = get_param_u(dev, CIR, &get);
 220         if (ret)
 221                 return ret;
 222
 223         return sysfs_emit(buf, "%llu\n", get);
 224 }
 225
 226 static ssize_t cir_store(struct device *dev, struct device_attribute *attr,
 227                          const char *buf, size_t count)
 228 {
 229         unsigned int val;
 230         int err;
 231
 232         err = kstrtouint(buf, 10, &val);
 233         if (err)
 234                 return err;
 235
 236         err = set_param_u(dev, CIR, val);
 237         if (err)
 238                 return err;
 239
 240         return count;
 241 }
 242 static DEVICE_ATTR_RW(cir);
 243
 244 static ssize_t pir_show(struct device *dev, struct device_attribute *attr,
 245                         char *buf)
 246 {
 247         int ret;
 248         u64 get;
 249
 250         ret = get_param_u(dev, PIR, &get);
 251         if (ret)
 252                 return ret;
 253
 254         return sysfs_emit(buf, "%llu\n", get);
 255 }
 256
 257 static ssize_t pir_store(struct device *dev, struct device_attribute *attr,
 258                          const char *buf, size_t count)
 259 {
 260         unsigned int val;
 261         int err;
 262
 263         err = kstrtouint(buf, 10, &val);
 264         if (err)
 265                 return err;
 266
 267         err = set_param_u(dev, PIR, val);
 268         if (err)
 269                 return err;
 270
 271         return count;
 272 }
 273 static DEVICE_ATTR_RW(pir);
 274
 275 static ssize_t srv_show(struct device *dev, struct device_attribute *attr,
 276                         char *buf)
 277 {
 278         int ret;
 279         u64 get;
 280
 281         ret = get_param_u(dev, SRV, &get);
 282         if (ret)
 283                 return ret;
 284
 285         if (get == ADF_SVC_NONE)
 286                 return -EINVAL;
 287
 288         return sysfs_emit(buf, "%s\n", rl_services[get]);
 289 }
 290
 291 static ssize_t srv_store(struct device *dev, struct device_attribute *attr,
 292                          const char *buf, size_t count)
 293 {
 294         unsigned int val;
 295         int ret;
 296
 297         ret = sysfs_match_string(rl_services, buf);
 298         if (ret < 0)
 299                 return ret;
 300
 301         val = ret;
 302         ret = set_param_u(dev, SRV, val);
 303         if (ret)
 304                 return ret;
 305
 306         return count;
 307 }
 308 static DEVICE_ATTR_RW(srv);
 309
 310 static ssize_t cap_rem_show(struct device *dev, struct device_attribute *attr,
 311                             char *buf)
 312 {
 313         struct adf_rl_interface_data *data;
 314         struct adf_accel_dev *accel_dev;
 315         int ret, rem_cap;
 316
 317         accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev));
 318         if (!accel_dev)
 319                 return -EINVAL;
 320
 321         data = &GET_RL_STRUCT(accel_dev);
 322
 323         down_read(&data->lock);
 324         rem_cap = adf_rl_get_capability_remaining(accel_dev, data->cap_rem_srv,
 325                                                   RL_SLA_EMPTY_ID);
 326         up_read(&data->lock);
 327         if (rem_cap < 0)
 328                 return rem_cap;
 329
 330         ret = sysfs_emit(buf, "%u\n", rem_cap);
 331
 332         return ret;
 333 }
 334
 335 static ssize_t cap_rem_store(struct device *dev, struct device_attribute *attr,
 336                              const char *buf, size_t count)
 337 {
 338         unsigned int val;
 339         int ret;
 340
 341         ret = sysfs_match_string(rl_services, buf);
 342         if (ret < 0)
 343                 return ret;
 344
 345         val = ret;
 346         ret = set_param_u(dev, CAP_REM_SRV, val);
 347         if (ret)
 348                 return ret;
 349
 350         return count;
 351 }
 352 static DEVICE_ATTR_RW(cap_rem);
 353
 354 static ssize_t sla_op_store(struct device *dev, struct device_attribute *attr,
 355                             const char *buf, size_t count)
 356 {
 357         struct adf_rl_interface_data *data;
 358         struct adf_accel_dev *accel_dev;
 359         int ret;
 360
 361         accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev));
 362         if (!accel_dev)
 363                 return -EINVAL;
 364
 365         data = &GET_RL_STRUCT(accel_dev);
 366
 367         ret = sysfs_match_string(rl_operations, buf);
 368         if (ret < 0)
 369                 return ret;
 370
 371         down_write(&data->lock);
 372         switch (ret) {
 373         case ADD:
 374                 data->input.parent_id = RL_PARENT_DEFAULT_ID;
 375                 data->input.type = RL_LEAF;
 376                 data->input.sla_id = 0;
 377                 ret = adf_rl_add_sla(accel_dev, &data->input);
 378                 if (ret)
 379                         goto err_free_lock;
 380                 break;
 381         case UPDATE:
 382                 ret = adf_rl_update_sla(accel_dev, &data->input);
 383                 if (ret)
 384                         goto err_free_lock;
 385                 break;
 386         case RM:
 387                 ret = adf_rl_remove_sla(accel_dev, data->input.sla_id);
 388                 if (ret)
 389                         goto err_free_lock;
 390                 break;
 391         case RM_ALL:
 392                 adf_rl_remove_sla_all(accel_dev, false);
 393                 break;
 394         case GET:
 395                 ret = adf_rl_get_sla(accel_dev, &data->input);
 396                 if (ret)
 397                         goto err_free_lock;
 398                 break;
 399         default:
 400                 ret = -EINVAL;
 401                 goto err_free_lock;
 402         }
 403         up_write(&data->lock);
 404
 405         return count;
 406
 407 err_free_lock:
 408         up_write(&data->lock);
 409
 410         return ret;
 411 }
 412 static DEVICE_ATTR_WO(sla_op);
 413
 414 static struct attribute *qat_rl_attrs[] = {
 415         &dev_attr_rp.attr,
 416         &dev_attr_id.attr,
 417         &dev_attr_cir.attr,
 418         &dev_attr_pir.attr,
 419         &dev_attr_srv.attr,
 420         &dev_attr_cap_rem.attr,
 421         &dev_attr_sla_op.attr,
 422         NULL,
 423 };
 424
 425 static struct attribute_group qat_rl_group = {
 426         .attrs = qat_rl_attrs,
 427         .name = "qat_rl",
 428 };
 429
 430 int adf_sysfs_rl_add(struct adf_accel_dev *accel_dev)
 431 {
 432         struct adf_rl_interface_data *data;
 433         int ret;
 434
 435         data = &GET_RL_STRUCT(accel_dev);
 436
 437         ret = device_add_group(&GET_DEV(accel_dev), &qat_rl_group);
 438         if (ret)
 439                 dev_err(&GET_DEV(accel_dev),
 440                         "Failed to create qat_rl attribute group\n");
 441
 442         data->cap_rem_srv = ADF_SVC_NONE;
 443         data->input.srv = ADF_SVC_NONE;
 444         data->sysfs_added = true;
 445
 446         return ret;
 447 }
 448
 449 void adf_sysfs_rl_rm(struct adf_accel_dev *accel_dev)
 450 {
 451         struct adf_rl_interface_data *data;
 452
 453         data = &GET_RL_STRUCT(accel_dev);
 454         if (!data->sysfs_added)
 455                 return;
 456
 457         device_remove_group(&GET_DEV(accel_dev), &qat_rl_group);
 458         data->sysfs_added = false;
 459 }