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 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
cap_rem_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
sla_op_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
adf_sysfs_rl_add(struct adf_accel_dev * accel_dev)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
adf_sysfs_rl_rm(struct adf_accel_dev * accel_dev)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