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
 23enum 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
 46enum cnv_fields {
 47	CNV_ERR_COUNT,
 48	CNV_LATEST_ERR,
 49	CNV_FIELDS_COUNT
 50};
 51
 52static const char * const cnv_field_names[CNV_FIELDS_COUNT] = {
 53	[CNV_ERR_COUNT] = "Total Errors",
 54	[CNV_LATEST_ERR] = "Last Error",
 55};
 56
 57static 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
 67struct ae_cnv_errors {
 68	u16 ae;
 69	u16 err_cnt;
 70	u16 latest_err;
 71	bool is_comp_ae;
 72};
 73
 74struct cnv_err_stats {
 75	u16 ae_count;
 76	struct ae_cnv_errors ae_cnv_errors[];
 77};
 78
 79static 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
 93static 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
106static 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
119static void qat_cnv_errors_seq_stop(struct seq_file *sfile, void *v)
120{
121}
122
123static 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
154static 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 */
173static 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
224static 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
246static 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
256static 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
264static 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
273static const struct file_operations qat_cnv_no_comp_fops = {
274	.owner = THIS_MODULE,
275	.read = no_comp_file_read,
276};
277
278void 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
296void 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}