1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Copyright(c) 2023 Intel Corporation */
3
4 #include <linux/bitfield.h>
5 #include <linux/debugfs.h>
6 #include <linux/kernel.h>
7
8 #include "adf_accel_devices.h"
9 #include "adf_admin.h"
10 #include "adf_common_drv.h"
11 #include "adf_cnv_dbgfs.h"
12 #include "qat_compression.h"
13
14 #define CNV_DEBUGFS_FILENAME "cnv_errors"
15 #define CNV_MIN_PADDING 16
16
17 #define CNV_ERR_INFO_MASK GENMASK(11, 0)
18 #define CNV_ERR_TYPE_MASK GENMASK(15, 12)
19 #define CNV_SLICE_ERR_MASK GENMASK(7, 0)
20 #define CNV_SLICE_ERR_SIGN_BIT_INDEX 7
21 #define CNV_DELTA_ERR_SIGN_BIT_INDEX 11
22
23 enum cnv_error_type {
24 CNV_ERR_TYPE_NONE,
25 CNV_ERR_TYPE_CHECKSUM,
26 CNV_ERR_TYPE_DECOMP_PRODUCED_LENGTH,
27 CNV_ERR_TYPE_DECOMPRESSION,
28 CNV_ERR_TYPE_TRANSLATION,
29 CNV_ERR_TYPE_DECOMP_CONSUMED_LENGTH,
30 CNV_ERR_TYPE_UNKNOWN,
31 CNV_ERR_TYPES_COUNT
32 };
33
34 #define CNV_ERROR_TYPE_GET(latest_err) \
35 min_t(u16, u16_get_bits(latest_err, CNV_ERR_TYPE_MASK), CNV_ERR_TYPE_UNKNOWN)
36
37 #define CNV_GET_DELTA_ERR_INFO(latest_error) \
38 sign_extend32(latest_error, CNV_DELTA_ERR_SIGN_BIT_INDEX)
39
40 #define CNV_GET_SLICE_ERR_INFO(latest_error) \
41 sign_extend32(latest_error, CNV_SLICE_ERR_SIGN_BIT_INDEX)
42
43 #define CNV_GET_DEFAULT_ERR_INFO(latest_error) \
44 u16_get_bits(latest_error, CNV_ERR_INFO_MASK)
45
46 enum cnv_fields {
47 CNV_ERR_COUNT,
48 CNV_LATEST_ERR,
49 CNV_FIELDS_COUNT
50 };
51
52 static const char * const cnv_field_names[CNV_FIELDS_COUNT] = {
53 [CNV_ERR_COUNT] = "Total Errors",
54 [CNV_LATEST_ERR] = "Last Error",
55 };
56
57 static const char * const cnv_error_names[CNV_ERR_TYPES_COUNT] = {
58 [CNV_ERR_TYPE_NONE] = "No Error",
59 [CNV_ERR_TYPE_CHECKSUM] = "Checksum Error",
60 [CNV_ERR_TYPE_DECOMP_PRODUCED_LENGTH] = "Length Error-P",
61 [CNV_ERR_TYPE_DECOMPRESSION] = "Decomp Error",
62 [CNV_ERR_TYPE_TRANSLATION] = "Xlat Error",
63 [CNV_ERR_TYPE_DECOMP_CONSUMED_LENGTH] = "Length Error-C",
64 [CNV_ERR_TYPE_UNKNOWN] = "Unknown Error",
65 };
66
67 struct ae_cnv_errors {
68 u16 ae;
69 u16 err_cnt;
70 u16 latest_err;
71 bool is_comp_ae;
72 };
73
74 struct cnv_err_stats {
75 u16 ae_count;
76 struct ae_cnv_errors ae_cnv_errors[];
77 };
78
get_err_info(u8 error_type,u16 latest)79 static s16 get_err_info(u8 error_type, u16 latest)
80 {
81 switch (error_type) {
82 case CNV_ERR_TYPE_DECOMP_PRODUCED_LENGTH:
83 case CNV_ERR_TYPE_DECOMP_CONSUMED_LENGTH:
84 return CNV_GET_DELTA_ERR_INFO(latest);
85 case CNV_ERR_TYPE_DECOMPRESSION:
86 case CNV_ERR_TYPE_TRANSLATION:
87 return CNV_GET_SLICE_ERR_INFO(latest);
88 default:
89 return CNV_GET_DEFAULT_ERR_INFO(latest);
90 }
91 }
92
qat_cnv_errors_seq_start(struct seq_file * sfile,loff_t * pos)93 static void *qat_cnv_errors_seq_start(struct seq_file *sfile, loff_t *pos)
94 {
95 struct cnv_err_stats *err_stats = sfile->private;
96
97 if (*pos == 0)
98 return SEQ_START_TOKEN;
99
100 if (*pos > err_stats->ae_count)
101 return NULL;
102
103 return &err_stats->ae_cnv_errors[*pos - 1];
104 }
105
qat_cnv_errors_seq_next(struct seq_file * sfile,void * v,loff_t * pos)106 static void *qat_cnv_errors_seq_next(struct seq_file *sfile, void *v,
107 loff_t *pos)
108 {
109 struct cnv_err_stats *err_stats = sfile->private;
110
111 (*pos)++;
112
113 if (*pos > err_stats->ae_count)
114 return NULL;
115
116 return &err_stats->ae_cnv_errors[*pos - 1];
117 }
118
qat_cnv_errors_seq_stop(struct seq_file * sfile,void * v)119 static void qat_cnv_errors_seq_stop(struct seq_file *sfile, void *v)
120 {
121 }
122
qat_cnv_errors_seq_show(struct seq_file * sfile,void * v)123 static int qat_cnv_errors_seq_show(struct seq_file *sfile, void *v)
124 {
125 struct ae_cnv_errors *ae_errors;
126 unsigned int i;
127 s16 err_info;
128 u8 err_type;
129
130 if (v == SEQ_START_TOKEN) {
131 seq_puts(sfile, "AE ");
132 for (i = 0; i < CNV_FIELDS_COUNT; ++i)
133 seq_printf(sfile, " %*s", CNV_MIN_PADDING,
134 cnv_field_names[i]);
135 } else {
136 ae_errors = v;
137
138 if (!ae_errors->is_comp_ae)
139 return 0;
140
141 err_type = CNV_ERROR_TYPE_GET(ae_errors->latest_err);
142 err_info = get_err_info(err_type, ae_errors->latest_err);
143
144 seq_printf(sfile, "%d:", ae_errors->ae);
145 seq_printf(sfile, " %*d", CNV_MIN_PADDING, ae_errors->err_cnt);
146 seq_printf(sfile, "%*s [%d]", CNV_MIN_PADDING,
147 cnv_error_names[err_type], err_info);
148 }
149 seq_putc(sfile, '\n');
150
151 return 0;
152 }
153
154 static const struct seq_operations qat_cnv_errors_sops = {
155 .start = qat_cnv_errors_seq_start,
156 .next = qat_cnv_errors_seq_next,
157 .stop = qat_cnv_errors_seq_stop,
158 .show = qat_cnv_errors_seq_show,
159 };
160
161 /**
162 * cnv_err_stats_alloc() - Get CNV stats for the provided device.
163 * @accel_dev: Pointer to a QAT acceleration device
164 *
165 * Allocates and populates table of CNV errors statistics for each non-admin AE
166 * available through the supplied acceleration device. The caller becomes the
167 * owner of such memory and is responsible for the deallocation through a call
168 * to kfree().
169 *
170 * Returns: a pointer to a dynamically allocated struct cnv_err_stats on success
171 * or a negative value on error.
172 */
cnv_err_stats_alloc(struct adf_accel_dev * accel_dev)173 static struct cnv_err_stats *cnv_err_stats_alloc(struct adf_accel_dev *accel_dev)
174 {
175 struct adf_hw_device_data *hw_data = GET_HW_DATA(accel_dev);
176 struct cnv_err_stats *err_stats;
177 unsigned long ae_count;
178 unsigned long ae_mask;
179 size_t err_stats_size;
180 unsigned long ae;
181 unsigned int i;
182 u16 latest_err;
183 u16 err_cnt;
184 int ret;
185
186 if (!adf_dev_started(accel_dev)) {
187 dev_err(&GET_DEV(accel_dev), "QAT Device not started\n");
188 return ERR_PTR(-EBUSY);
189 }
190
191 /* Ignore the admin AEs */
192 ae_mask = hw_data->ae_mask & ~hw_data->admin_ae_mask;
193 ae_count = hweight_long(ae_mask);
194 if (unlikely(!ae_count))
195 return ERR_PTR(-EINVAL);
196
197 err_stats_size = struct_size(err_stats, ae_cnv_errors, ae_count);
198 err_stats = kmalloc(err_stats_size, GFP_KERNEL);
199 if (!err_stats)
200 return ERR_PTR(-ENOMEM);
201
202 err_stats->ae_count = ae_count;
203
204 i = 0;
205 for_each_set_bit(ae, &ae_mask, GET_MAX_ACCELENGINES(accel_dev)) {
206 ret = adf_get_cnv_stats(accel_dev, ae, &err_cnt, &latest_err);
207 if (ret) {
208 dev_dbg(&GET_DEV(accel_dev),
209 "Failed to get CNV stats for ae %ld, [%d].\n",
210 ae, ret);
211 err_stats->ae_cnv_errors[i++].is_comp_ae = false;
212 continue;
213 }
214 err_stats->ae_cnv_errors[i].is_comp_ae = true;
215 err_stats->ae_cnv_errors[i].latest_err = latest_err;
216 err_stats->ae_cnv_errors[i].err_cnt = err_cnt;
217 err_stats->ae_cnv_errors[i].ae = ae;
218 i++;
219 }
220
221 return err_stats;
222 }
223
qat_cnv_errors_file_open(struct inode * inode,struct file * file)224 static int qat_cnv_errors_file_open(struct inode *inode, struct file *file)
225 {
226 struct adf_accel_dev *accel_dev = inode->i_private;
227 struct seq_file *cnv_errors_seq_file;
228 struct cnv_err_stats *cnv_err_stats;
229 int ret;
230
231 cnv_err_stats = cnv_err_stats_alloc(accel_dev);
232 if (IS_ERR(cnv_err_stats))
233 return PTR_ERR(cnv_err_stats);
234
235 ret = seq_open(file, &qat_cnv_errors_sops);
236 if (unlikely(ret)) {
237 kfree(cnv_err_stats);
238 return ret;
239 }
240
241 cnv_errors_seq_file = file->private_data;
242 cnv_errors_seq_file->private = cnv_err_stats;
243 return ret;
244 }
245
qat_cnv_errors_file_release(struct inode * inode,struct file * file)246 static int qat_cnv_errors_file_release(struct inode *inode, struct file *file)
247 {
248 struct seq_file *cnv_errors_seq_file = file->private_data;
249
250 kfree(cnv_errors_seq_file->private);
251 cnv_errors_seq_file->private = NULL;
252
253 return seq_release(inode, file);
254 }
255
256 static const struct file_operations qat_cnv_fops = {
257 .owner = THIS_MODULE,
258 .open = qat_cnv_errors_file_open,
259 .read = seq_read,
260 .llseek = seq_lseek,
261 .release = qat_cnv_errors_file_release,
262 };
263
no_comp_file_read(struct file * f,char __user * buf,size_t count,loff_t * pos)264 static ssize_t no_comp_file_read(struct file *f, char __user *buf, size_t count,
265 loff_t *pos)
266 {
267 char *file_msg = "No engine configured for comp\n";
268
269 return simple_read_from_buffer(buf, count, pos, file_msg,
270 strlen(file_msg));
271 }
272
273 static const struct file_operations qat_cnv_no_comp_fops = {
274 .owner = THIS_MODULE,
275 .read = no_comp_file_read,
276 };
277
adf_cnv_dbgfs_add(struct adf_accel_dev * accel_dev)278 void adf_cnv_dbgfs_add(struct adf_accel_dev *accel_dev)
279 {
280 const struct file_operations *fops;
281 void *data;
282
283 if (adf_hw_dev_has_compression(accel_dev)) {
284 fops = &qat_cnv_fops;
285 data = accel_dev;
286 } else {
287 fops = &qat_cnv_no_comp_fops;
288 data = NULL;
289 }
290
291 accel_dev->cnv_dbgfile = debugfs_create_file(CNV_DEBUGFS_FILENAME, 0400,
292 accel_dev->debugfs_dir,
293 data, fops);
294 }
295
adf_cnv_dbgfs_rm(struct adf_accel_dev * accel_dev)296 void adf_cnv_dbgfs_rm(struct adf_accel_dev *accel_dev)
297 {
298 debugfs_remove(accel_dev->cnv_dbgfile);
299 accel_dev->cnv_dbgfile = NULL;
300 }
301