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
set_param_u(struct device * dev,enum rl_params param,u64 set)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
set_param_s(struct device * dev,enum rl_params param,int set)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
get_param_u(struct device * dev,enum rl_params param,u64 * get)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
get_param_s(struct device * dev,enum rl_params param)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
rp_show(struct device * dev,struct device_attribute * attr,char * buf)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
rp_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
id_show(struct device * dev,struct device_attribute * attr,char * buf)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
id_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
cir_show(struct device * dev,struct device_attribute * attr,char * buf)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
cir_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
pir_show(struct device * dev,struct device_attribute * attr,char * buf)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
pir_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
srv_show(struct device * dev,struct device_attribute * attr,char * buf)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
srv_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
cap_rem_show(struct device * dev,struct device_attribute * attr,char * buf)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
cap_rem_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
sla_op_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
adf_sysfs_rl_add(struct adf_accel_dev * accel_dev)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
adf_sysfs_rl_rm(struct adf_accel_dev * accel_dev)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