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