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 } 460