adf_heartbeat_dbgfs.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/* Copyright(c) 2023 Intel Corporation */
  3
  4#include <linux/debugfs.h>
  5#include <linux/errno.h>
  6#include <linux/export.h>
  7#include <linux/fs.h>
  8#include <linux/kernel.h>
  9#include <linux/kstrtox.h>
 10#include <linux/types.h>
 11#include "adf_admin.h"
 12#include "adf_cfg.h"
 13#include "adf_common_drv.h"
 14#include "adf_heartbeat.h"
 15#include "adf_heartbeat_dbgfs.h"
 16
 17#define HB_OK 0
 18#define HB_ERROR -1
 19#define HB_STATUS_MAX_STRLEN 4
 20#define HB_STATS_MAX_STRLEN 16
 21
 22static ssize_t adf_hb_stats_read(struct file *file, char __user *user_buffer,
 23				 size_t count, loff_t *ppos)
 24{
 25	char buf[HB_STATS_MAX_STRLEN];
 26	unsigned int *value;
 27	int len;
 28
 29	if (*ppos > 0)
 30		return 0;
 31
 32	value = file->private_data;
 33	len = scnprintf(buf, sizeof(buf), "%u\n", *value);
 34
 35	return simple_read_from_buffer(user_buffer, count, ppos, buf, len + 1);
 36}
 37
 38static const struct file_operations adf_hb_stats_fops = {
 39	.owner = THIS_MODULE,
 40	.open = simple_open,
 41	.read = adf_hb_stats_read,
 42};
 43
 44static ssize_t adf_hb_status_read(struct file *file, char __user *user_buf,
 45				  size_t count, loff_t *ppos)
 46{
 47	enum adf_device_heartbeat_status hb_status;
 48	char ret_str[HB_STATUS_MAX_STRLEN];
 49	struct adf_accel_dev *accel_dev;
 50	int ret_code;
 51	size_t len;
 52
 53	if (*ppos > 0)
 54		return 0;
 55
 56	accel_dev = file->private_data;
 57	ret_code = HB_OK;
 58
 59	adf_heartbeat_status(accel_dev, &hb_status);
 60
 61	if (hb_status != HB_DEV_ALIVE)
 62		ret_code = HB_ERROR;
 63
 64	len = scnprintf(ret_str, sizeof(ret_str), "%d\n", ret_code);
 65
 66	return simple_read_from_buffer(user_buf, count, ppos, ret_str, len + 1);
 67}
 68
 69static const struct file_operations adf_hb_status_fops = {
 70	.owner = THIS_MODULE,
 71	.open = simple_open,
 72	.read = adf_hb_status_read,
 73};
 74
 75static ssize_t adf_hb_cfg_read(struct file *file, char __user *user_buf,
 76			       size_t count, loff_t *ppos)
 77{
 78	char timer_str[ADF_CFG_MAX_VAL_LEN_IN_BYTES];
 79	struct adf_accel_dev *accel_dev;
 80	unsigned int timer_ms;
 81	int len;
 82
 83	if (*ppos > 0)
 84		return 0;
 85
 86	accel_dev = file->private_data;
 87	timer_ms = accel_dev->heartbeat->hb_timer;
 88	len = scnprintf(timer_str, sizeof(timer_str), "%u\n", timer_ms);
 89
 90	return simple_read_from_buffer(user_buf, count, ppos, timer_str,
 91				       len + 1);
 92}
 93
 94static ssize_t adf_hb_cfg_write(struct file *file, const char __user *user_buf,
 95				size_t count, loff_t *ppos)
 96{
 97	char input_str[ADF_CFG_MAX_VAL_LEN_IN_BYTES] = { };
 98	struct adf_accel_dev *accel_dev;
 99	int ret, written_chars;
100	unsigned int timer_ms;
101	u32 ticks;
102
103	accel_dev = file->private_data;
104	timer_ms = ADF_CFG_HB_TIMER_DEFAULT_MS;
105
106	/* last byte left as string termination */
107	if (count > sizeof(input_str) - 1)
108		return -EINVAL;
109
110	written_chars = simple_write_to_buffer(input_str, sizeof(input_str) - 1,
111					       ppos, user_buf, count);
112	if (written_chars > 0) {
113		ret = kstrtouint(input_str, 10, &timer_ms);
114		if (ret) {
115			dev_err(&GET_DEV(accel_dev),
116				"heartbeat_cfg: Invalid value\n");
117			return ret;
118		}
119
120		if (timer_ms < ADF_CFG_HB_TIMER_MIN_MS) {
121			dev_err(&GET_DEV(accel_dev),
122				"heartbeat_cfg: Invalid value\n");
123			return -EINVAL;
124		}
125
126		/*
127		 * On 4xxx devices adf_timer is responsible for HB updates and
128		 * its period is fixed to 200ms
129		 */
130		if (accel_dev->timer)
131			timer_ms = ADF_CFG_HB_TIMER_MIN_MS;
132
133		ret = adf_heartbeat_save_cfg_param(accel_dev, timer_ms);
134		if (ret)
135			return ret;
136
137		ret = adf_heartbeat_ms_to_ticks(accel_dev, timer_ms, &ticks);
138		if (ret)
139			return ret;
140
141		ret = adf_send_admin_hb_timer(accel_dev, ticks);
142		if (ret)
143			return ret;
144
145		accel_dev->heartbeat->hb_timer = timer_ms;
146	}
147
148	return written_chars;
149}
150
151static const struct file_operations adf_hb_cfg_fops = {
152	.owner = THIS_MODULE,
153	.open = simple_open,
154	.read = adf_hb_cfg_read,
155	.write = adf_hb_cfg_write,
156};
157
158static ssize_t adf_hb_error_inject_write(struct file *file,
159					 const char __user *user_buf,
160					 size_t count, loff_t *ppos)
161{
162	struct adf_accel_dev *accel_dev = file->private_data;
163	char buf[3];
164	int ret;
165
166	/* last byte left as string termination */
167	if (*ppos != 0 || count != 2)
168		return -EINVAL;
169
170	if (copy_from_user(buf, user_buf, count))
171		return -EFAULT;
172	buf[count] = '\0';
173
174	if (buf[0] != '1')
175		return -EINVAL;
176
177	ret = adf_heartbeat_inject_error(accel_dev);
178	if (ret) {
179		dev_err(&GET_DEV(accel_dev),
180			"Heartbeat error injection failed with status %d\n",
181			ret);
182		return ret;
183	}
184
185	dev_info(&GET_DEV(accel_dev), "Heartbeat error injection enabled\n");
186
187	return count;
188}
189
190static const struct file_operations adf_hb_error_inject_fops = {
191	.owner = THIS_MODULE,
192	.open = simple_open,
193	.write = adf_hb_error_inject_write,
194};
195
196void adf_heartbeat_dbgfs_add(struct adf_accel_dev *accel_dev)
197{
198	struct adf_heartbeat *hb = accel_dev->heartbeat;
199
200	if (!hb)
201		return;
202
203	hb->dbgfs.base_dir = debugfs_create_dir("heartbeat", accel_dev->debugfs_dir);
204	hb->dbgfs.status = debugfs_create_file("status", 0400, hb->dbgfs.base_dir,
205					       accel_dev, &adf_hb_status_fops);
206	hb->dbgfs.sent = debugfs_create_file("queries_sent", 0400, hb->dbgfs.base_dir,
207					     &hb->hb_sent_counter, &adf_hb_stats_fops);
208	hb->dbgfs.failed = debugfs_create_file("queries_failed", 0400, hb->dbgfs.base_dir,
209					       &hb->hb_failed_counter, &adf_hb_stats_fops);
210	hb->dbgfs.cfg = debugfs_create_file("config", 0600, hb->dbgfs.base_dir,
211					    accel_dev, &adf_hb_cfg_fops);
212
213	if (IS_ENABLED(CONFIG_CRYPTO_DEV_QAT_ERROR_INJECTION)) {
214		struct dentry *inject_error __maybe_unused;
215
216		inject_error = debugfs_create_file("inject_error", 0200,
217						   hb->dbgfs.base_dir, accel_dev,
218						   &adf_hb_error_inject_fops);
219#ifdef CONFIG_CRYPTO_DEV_QAT_ERROR_INJECTION
220		hb->dbgfs.inject_error = inject_error;
221#endif
222	}
223}
224EXPORT_SYMBOL_GPL(adf_heartbeat_dbgfs_add);
225
226void adf_heartbeat_dbgfs_rm(struct adf_accel_dev *accel_dev)
227{
228	struct adf_heartbeat *hb = accel_dev->heartbeat;
229
230	if (!hb)
231		return;
232
233	debugfs_remove(hb->dbgfs.status);
234	hb->dbgfs.status = NULL;
235	debugfs_remove(hb->dbgfs.sent);
236	hb->dbgfs.sent = NULL;
237	debugfs_remove(hb->dbgfs.failed);
238	hb->dbgfs.failed = NULL;
239	debugfs_remove(hb->dbgfs.cfg);
240	hb->dbgfs.cfg = NULL;
241#ifdef CONFIG_CRYPTO_DEV_QAT_ERROR_INJECTION
242	debugfs_remove(hb->dbgfs.inject_error);
243	hb->dbgfs.inject_error = NULL;
244#endif
245	debugfs_remove(hb->dbgfs.base_dir);
246	hb->dbgfs.base_dir = NULL;
247}
248EXPORT_SYMBOL_GPL(adf_heartbeat_dbgfs_rm);