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 ret, 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 ret = sysfs_emit(buf, "%u\n", rem_cap); 340 341 return ret; 342 } 343 344 static ssize_t cap_rem_store(struct device *dev, struct device_attribute *attr, 345 const char *buf, size_t count) 346 { 347 unsigned int val; 348 int ret; 349 350 ret = sysfs_match_string(rl_services, buf); 351 if (ret < 0) 352 return ret; 353 354 val = ret; 355 ret = set_param_u(dev, CAP_REM_SRV, val); 356 if (ret) 357 return ret; 358 359 return count; 360 } 361 static DEVICE_ATTR_RW(cap_rem); 362 363 static ssize_t sla_op_store(struct device *dev, struct device_attribute *attr, 364 const char *buf, size_t count) 365 { 366 struct adf_rl_interface_data *data; 367 struct adf_accel_dev *accel_dev; 368 int ret; 369 370 accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev)); 371 if (!accel_dev) 372 return -EINVAL; 373 374 data = &GET_RL_STRUCT(accel_dev); 375 376 ret = sysfs_match_string(rl_operations, buf); 377 if (ret < 0) 378 return ret; 379 380 down_write(&data->lock); 381 switch (ret) { 382 case ADD: 383 data->input.parent_id = RL_PARENT_DEFAULT_ID; 384 data->input.type = RL_LEAF; 385 data->input.sla_id = 0; 386 ret = adf_rl_add_sla(accel_dev, &data->input); 387 if (ret) 388 goto err_free_lock; 389 break; 390 case UPDATE: 391 ret = adf_rl_update_sla(accel_dev, &data->input); 392 if (ret) 393 goto err_free_lock; 394 break; 395 case RM: 396 ret = adf_rl_remove_sla(accel_dev, data->input.sla_id); 397 if (ret) 398 goto err_free_lock; 399 break; 400 case RM_ALL: 401 adf_rl_remove_sla_all(accel_dev, false); 402 break; 403 case GET: 404 ret = adf_rl_get_sla(accel_dev, &data->input); 405 if (ret) 406 goto err_free_lock; 407 break; 408 default: 409 ret = -EINVAL; 410 goto err_free_lock; 411 } 412 up_write(&data->lock); 413 414 return count; 415 416 err_free_lock: 417 up_write(&data->lock); 418 419 return ret; 420 } 421 static DEVICE_ATTR_WO(sla_op); 422 423 static struct attribute *qat_rl_attrs[] = { 424 &dev_attr_rp.attr, 425 &dev_attr_id.attr, 426 &dev_attr_cir.attr, 427 &dev_attr_pir.attr, 428 &dev_attr_srv.attr, 429 &dev_attr_cap_rem.attr, 430 &dev_attr_sla_op.attr, 431 NULL, 432 }; 433 434 static struct attribute_group qat_rl_group = { 435 .attrs = qat_rl_attrs, 436 .name = "qat_rl", 437 }; 438 439 int adf_sysfs_rl_add(struct adf_accel_dev *accel_dev) 440 { 441 struct adf_rl_interface_data *data; 442 int ret; 443 444 data = &GET_RL_STRUCT(accel_dev); 445 446 ret = device_add_group(&GET_DEV(accel_dev), &qat_rl_group); 447 if (ret) 448 dev_err(&GET_DEV(accel_dev), 449 "Failed to create qat_rl attribute group\n"); 450 451 data->cap_rem_srv = SVC_BASE_COUNT; 452 data->input.srv = SVC_BASE_COUNT; 453 data->sysfs_added = true; 454 455 return ret; 456 } 457 458 void adf_sysfs_rl_rm(struct adf_accel_dev *accel_dev) 459 { 460 struct adf_rl_interface_data *data; 461 462 data = &GET_RL_STRUCT(accel_dev); 463 if (!data->sysfs_added) 464 return; 465 466 device_remove_group(&GET_DEV(accel_dev), &qat_rl_group); 467 data->sysfs_added = false; 468 } 469