1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
2 /*
3  * Copyright (C) 2012-2014, 2018-2020 Intel Corporation
4  * Copyright (C) 2013-2015 Intel Mobile Communications GmbH
5  * Copyright (C) 2016-2017 Intel Deutschland GmbH
6  */
7 #include "api/commands.h"
8 #include "debugfs.h"
9 #include "dbg.h"
10 #include <linux/seq_file.h>
11 
12 #define FWRT_DEBUGFS_OPEN_WRAPPER(name, buflen, argtype)		\
13 struct dbgfs_##name##_data {						\
14 	argtype *arg;							\
15 	bool read_done;							\
16 	ssize_t rlen;							\
17 	char rbuf[buflen];						\
18 };									\
19 static int _iwl_dbgfs_##name##_open(struct inode *inode,		\
20 				    struct file *file)			\
21 {									\
22 	struct dbgfs_##name##_data *data;				\
23 									\
24 	data = kzalloc(sizeof(*data), GFP_KERNEL);			\
25 	if (!data)							\
26 		return -ENOMEM;						\
27 									\
28 	data->read_done = false;					\
29 	data->arg = inode->i_private;					\
30 	file->private_data = data;					\
31 									\
32 	return 0;							\
33 }
34 
35 #define FWRT_DEBUGFS_READ_WRAPPER(name)					\
36 static ssize_t _iwl_dbgfs_##name##_read(struct file *file,		\
37 					char __user *user_buf,		\
38 					size_t count, loff_t *ppos)	\
39 {									\
40 	struct dbgfs_##name##_data *data = file->private_data;		\
41 									\
42 	if (!data->read_done) {						\
43 		data->read_done = true;					\
44 		data->rlen = iwl_dbgfs_##name##_read(data->arg,		\
45 						     sizeof(data->rbuf),\
46 						     data->rbuf);	\
47 	}								\
48 									\
49 	if (data->rlen < 0)						\
50 		return data->rlen;					\
51 	return simple_read_from_buffer(user_buf, count, ppos,		\
52 				       data->rbuf, data->rlen);		\
53 }
54 
55 static int _iwl_dbgfs_release(struct inode *inode, struct file *file)
56 {
57 	kfree(file->private_data);
58 
59 	return 0;
60 }
61 
62 #define _FWRT_DEBUGFS_READ_FILE_OPS(name, buflen, argtype)		\
63 FWRT_DEBUGFS_OPEN_WRAPPER(name, buflen, argtype)			\
64 FWRT_DEBUGFS_READ_WRAPPER(name)						\
65 static const struct file_operations iwl_dbgfs_##name##_ops = {		\
66 	.read = _iwl_dbgfs_##name##_read,				\
67 	.open = _iwl_dbgfs_##name##_open,				\
68 	.llseek = generic_file_llseek,					\
69 	.release = _iwl_dbgfs_release,					\
70 }
71 
72 #define FWRT_DEBUGFS_WRITE_WRAPPER(name, buflen, argtype)		\
73 static ssize_t _iwl_dbgfs_##name##_write(struct file *file,		\
74 					 const char __user *user_buf,	\
75 					 size_t count, loff_t *ppos)	\
76 {									\
77 	argtype *arg =							\
78 		((struct dbgfs_##name##_data *)file->private_data)->arg;\
79 	char buf[buflen] = {};						\
80 	size_t buf_size = min(count, sizeof(buf) -  1);			\
81 									\
82 	if (copy_from_user(buf, user_buf, buf_size))			\
83 		return -EFAULT;						\
84 									\
85 	return iwl_dbgfs_##name##_write(arg, buf, buf_size);		\
86 }
87 
88 #define _FWRT_DEBUGFS_READ_WRITE_FILE_OPS(name, buflen, argtype)	\
89 FWRT_DEBUGFS_OPEN_WRAPPER(name, buflen, argtype)			\
90 FWRT_DEBUGFS_WRITE_WRAPPER(name, buflen, argtype)			\
91 FWRT_DEBUGFS_READ_WRAPPER(name)						\
92 static const struct file_operations iwl_dbgfs_##name##_ops = {		\
93 	.write = _iwl_dbgfs_##name##_write,				\
94 	.read = _iwl_dbgfs_##name##_read,				\
95 	.open = _iwl_dbgfs_##name##_open,				\
96 	.llseek = generic_file_llseek,					\
97 	.release = _iwl_dbgfs_release,					\
98 }
99 
100 #define _FWRT_DEBUGFS_WRITE_FILE_OPS(name, buflen, argtype)		\
101 FWRT_DEBUGFS_OPEN_WRAPPER(name, buflen, argtype)			\
102 FWRT_DEBUGFS_WRITE_WRAPPER(name, buflen, argtype)			\
103 static const struct file_operations iwl_dbgfs_##name##_ops = {		\
104 	.write = _iwl_dbgfs_##name##_write,				\
105 	.open = _iwl_dbgfs_##name##_open,				\
106 	.llseek = generic_file_llseek,					\
107 	.release = _iwl_dbgfs_release,					\
108 }
109 
110 #define FWRT_DEBUGFS_READ_FILE_OPS(name, bufsz)				\
111 	_FWRT_DEBUGFS_READ_FILE_OPS(name, bufsz, struct iwl_fw_runtime)
112 
113 #define FWRT_DEBUGFS_WRITE_FILE_OPS(name, bufsz)			\
114 	_FWRT_DEBUGFS_WRITE_FILE_OPS(name, bufsz, struct iwl_fw_runtime)
115 
116 #define FWRT_DEBUGFS_READ_WRITE_FILE_OPS(name, bufsz)			\
117 	_FWRT_DEBUGFS_READ_WRITE_FILE_OPS(name, bufsz, struct iwl_fw_runtime)
118 
119 #define FWRT_DEBUGFS_ADD_FILE_ALIAS(alias, name, parent, mode) do {	\
120 	debugfs_create_file(alias, mode, parent, fwrt,			\
121 			    &iwl_dbgfs_##name##_ops);			\
122 	} while (0)
123 #define FWRT_DEBUGFS_ADD_FILE(name, parent, mode) \
124 	FWRT_DEBUGFS_ADD_FILE_ALIAS(#name, name, parent, mode)
125 
126 static int iwl_fw_send_timestamp_marker_cmd(struct iwl_fw_runtime *fwrt)
127 {
128 	struct iwl_mvm_marker marker = {
129 		.dw_len = sizeof(struct iwl_mvm_marker) / 4,
130 		.marker_id = MARKER_ID_SYNC_CLOCK,
131 
132 		/* the real timestamp is taken from the ftrace clock
133 		 * this is for finding the match between fw and kernel logs
134 		 */
135 		.timestamp = cpu_to_le64(fwrt->timestamp.seq++),
136 	};
137 
138 	struct iwl_host_cmd hcmd = {
139 		.id = MARKER_CMD,
140 		.flags = CMD_ASYNC,
141 		.data[0] = &marker,
142 		.len[0] = sizeof(marker),
143 	};
144 
145 	return iwl_trans_send_cmd(fwrt->trans, &hcmd);
146 }
147 
148 static int iwl_dbgfs_enabled_severities_write(struct iwl_fw_runtime *fwrt,
149 					      char *buf, size_t count)
150 {
151 	struct iwl_dbg_host_event_cfg_cmd event_cfg;
152 	struct iwl_host_cmd hcmd = {
153 		.id = WIDE_ID(DEBUG_GROUP, HOST_EVENT_CFG),
154 		.flags = CMD_ASYNC,
155 		.data[0] = &event_cfg,
156 		.len[0] = sizeof(event_cfg),
157 	};
158 	u32 enabled_severities;
159 	int ret = kstrtou32(buf, 10, &enabled_severities);
160 
161 	if (ret < 0)
162 		return ret;
163 
164 	event_cfg.enabled_severities = cpu_to_le32(enabled_severities);
165 
166 	ret = iwl_trans_send_cmd(fwrt->trans, &hcmd);
167 	IWL_INFO(fwrt,
168 		 "sent host event cfg with enabled_severities: %u, ret: %d\n",
169 		 enabled_severities, ret);
170 
171 	return ret ?: count;
172 }
173 
174 FWRT_DEBUGFS_WRITE_FILE_OPS(enabled_severities, 16);
175 
176 static void iwl_fw_timestamp_marker_wk(struct work_struct *work)
177 {
178 	int ret;
179 	struct iwl_fw_runtime *fwrt =
180 		container_of(work, struct iwl_fw_runtime, timestamp.wk.work);
181 	unsigned long delay = fwrt->timestamp.delay;
182 
183 	ret = iwl_fw_send_timestamp_marker_cmd(fwrt);
184 	if (!ret && delay)
185 		schedule_delayed_work(&fwrt->timestamp.wk,
186 				      round_jiffies_relative(delay));
187 	else
188 		IWL_INFO(fwrt,
189 			 "stopping timestamp_marker, ret: %d, delay: %u\n",
190 			 ret, jiffies_to_msecs(delay) / 1000);
191 }
192 
193 void iwl_fw_trigger_timestamp(struct iwl_fw_runtime *fwrt, u32 delay)
194 {
195 	IWL_INFO(fwrt,
196 		 "starting timestamp_marker trigger with delay: %us\n",
197 		 delay);
198 
199 	iwl_fw_cancel_timestamp(fwrt);
200 
201 	fwrt->timestamp.delay = msecs_to_jiffies(delay * 1000);
202 
203 	schedule_delayed_work(&fwrt->timestamp.wk,
204 			      round_jiffies_relative(fwrt->timestamp.delay));
205 }
206 
207 static ssize_t iwl_dbgfs_timestamp_marker_write(struct iwl_fw_runtime *fwrt,
208 						char *buf, size_t count)
209 {
210 	int ret;
211 	u32 delay;
212 
213 	ret = kstrtou32(buf, 10, &delay);
214 	if (ret < 0)
215 		return ret;
216 
217 	iwl_fw_trigger_timestamp(fwrt, delay);
218 
219 	return count;
220 }
221 
222 static ssize_t iwl_dbgfs_timestamp_marker_read(struct iwl_fw_runtime *fwrt,
223 					       size_t size, char *buf)
224 {
225 	u32 delay_secs = jiffies_to_msecs(fwrt->timestamp.delay) / 1000;
226 
227 	return scnprintf(buf, size, "%d\n", delay_secs);
228 }
229 
230 FWRT_DEBUGFS_READ_WRITE_FILE_OPS(timestamp_marker, 16);
231 
232 struct hcmd_write_data {
233 	__be32 cmd_id;
234 	__be32 flags;
235 	__be16 length;
236 	u8 data[];
237 } __packed;
238 
239 static ssize_t iwl_dbgfs_send_hcmd_write(struct iwl_fw_runtime *fwrt, char *buf,
240 					 size_t count)
241 {
242 	size_t header_size = (sizeof(u32) * 2 + sizeof(u16)) * 2;
243 	size_t data_size = (count - 1) / 2;
244 	int ret;
245 	struct hcmd_write_data *data;
246 	struct iwl_host_cmd hcmd = {
247 		.len = { 0, },
248 		.data = { NULL, },
249 	};
250 
251 	if (fwrt->ops && fwrt->ops->fw_running &&
252 	    !fwrt->ops->fw_running(fwrt->ops_ctx))
253 		return -EIO;
254 
255 	if (count < header_size + 1 || count > 1024 * 4)
256 		return -EINVAL;
257 
258 	data = kmalloc(data_size, GFP_KERNEL);
259 	if (!data)
260 		return -ENOMEM;
261 
262 	ret = hex2bin((u8 *)data, buf, data_size);
263 	if (ret)
264 		goto out;
265 
266 	hcmd.id = be32_to_cpu(data->cmd_id);
267 	hcmd.flags = be32_to_cpu(data->flags);
268 	hcmd.len[0] = be16_to_cpu(data->length);
269 	hcmd.data[0] = data->data;
270 
271 	if (count != header_size + hcmd.len[0] * 2 + 1) {
272 		IWL_ERR(fwrt,
273 			"host command data size does not match header length\n");
274 		ret = -EINVAL;
275 		goto out;
276 	}
277 
278 	if (fwrt->ops && fwrt->ops->send_hcmd)
279 		ret = fwrt->ops->send_hcmd(fwrt->ops_ctx, &hcmd);
280 	else
281 		ret = -EPERM;
282 
283 	if (ret < 0)
284 		goto out;
285 
286 	if (hcmd.flags & CMD_WANT_SKB)
287 		iwl_free_resp(&hcmd);
288 out:
289 	kfree(data);
290 	return ret ?: count;
291 }
292 
293 FWRT_DEBUGFS_WRITE_FILE_OPS(send_hcmd, 512);
294 
295 static ssize_t iwl_dbgfs_fw_dbg_domain_read(struct iwl_fw_runtime *fwrt,
296 					    size_t size, char *buf)
297 {
298 	return scnprintf(buf, size, "0x%08x\n",
299 			 fwrt->trans->dbg.domains_bitmap);
300 }
301 
302 FWRT_DEBUGFS_READ_FILE_OPS(fw_dbg_domain, 20);
303 
304 struct iwl_dbgfs_fw_info_priv {
305 	struct iwl_fw_runtime *fwrt;
306 };
307 
308 struct iwl_dbgfs_fw_info_state {
309 	loff_t pos;
310 };
311 
312 static void *iwl_dbgfs_fw_info_seq_next(struct seq_file *seq,
313 					void *v, loff_t *pos)
314 {
315 	struct iwl_dbgfs_fw_info_state *state = v;
316 	struct iwl_dbgfs_fw_info_priv *priv = seq->private;
317 	const struct iwl_fw *fw = priv->fwrt->fw;
318 
319 	*pos = ++state->pos;
320 	if (*pos >= fw->ucode_capa.n_cmd_versions)
321 		return NULL;
322 
323 	return state;
324 }
325 
326 static void iwl_dbgfs_fw_info_seq_stop(struct seq_file *seq,
327 				       void *v)
328 {
329 	kfree(v);
330 }
331 
332 static void *iwl_dbgfs_fw_info_seq_start(struct seq_file *seq, loff_t *pos)
333 {
334 	struct iwl_dbgfs_fw_info_priv *priv = seq->private;
335 	const struct iwl_fw *fw = priv->fwrt->fw;
336 	struct iwl_dbgfs_fw_info_state *state;
337 
338 	if (*pos >= fw->ucode_capa.n_cmd_versions)
339 		return NULL;
340 
341 	state = kzalloc(sizeof(*state), GFP_KERNEL);
342 	if (!state)
343 		return NULL;
344 	state->pos = *pos;
345 	return state;
346 };
347 
348 static int iwl_dbgfs_fw_info_seq_show(struct seq_file *seq, void *v)
349 {
350 	struct iwl_dbgfs_fw_info_state *state = v;
351 	struct iwl_dbgfs_fw_info_priv *priv = seq->private;
352 	const struct iwl_fw *fw = priv->fwrt->fw;
353 	const struct iwl_fw_cmd_version *ver;
354 	u32 cmd_id;
355 
356 	if (!state->pos)
357 		seq_puts(seq, "fw_api_ver:\n");
358 
359 	ver = &fw->ucode_capa.cmd_versions[state->pos];
360 
361 	cmd_id = WIDE_ID(ver->group, ver->cmd);
362 
363 	seq_printf(seq, "  0x%04x:\n", cmd_id);
364 	seq_printf(seq, "    name: %s\n",
365 		   iwl_get_cmd_string(priv->fwrt->trans, cmd_id));
366 	seq_printf(seq, "    cmd_ver: %d\n", ver->cmd_ver);
367 	seq_printf(seq, "    notif_ver: %d\n", ver->notif_ver);
368 	return 0;
369 }
370 
371 static const struct seq_operations iwl_dbgfs_info_seq_ops = {
372 	.start = iwl_dbgfs_fw_info_seq_start,
373 	.next = iwl_dbgfs_fw_info_seq_next,
374 	.stop = iwl_dbgfs_fw_info_seq_stop,
375 	.show = iwl_dbgfs_fw_info_seq_show,
376 };
377 
378 static int iwl_dbgfs_fw_info_open(struct inode *inode, struct file *filp)
379 {
380 	struct iwl_dbgfs_fw_info_priv *priv;
381 
382 	priv = __seq_open_private(filp, &iwl_dbgfs_info_seq_ops,
383 				  sizeof(*priv));
384 
385 	if (!priv)
386 		return -ENOMEM;
387 
388 	priv->fwrt = inode->i_private;
389 	return 0;
390 }
391 
392 static const struct file_operations iwl_dbgfs_fw_info_ops = {
393 	.owner = THIS_MODULE,
394 	.open = iwl_dbgfs_fw_info_open,
395 	.read = seq_read,
396 	.llseek = seq_lseek,
397 	.release = seq_release_private,
398 };
399 
400 void iwl_fwrt_dbgfs_register(struct iwl_fw_runtime *fwrt,
401 			    struct dentry *dbgfs_dir)
402 {
403 	INIT_DELAYED_WORK(&fwrt->timestamp.wk, iwl_fw_timestamp_marker_wk);
404 	FWRT_DEBUGFS_ADD_FILE(timestamp_marker, dbgfs_dir, 0200);
405 	FWRT_DEBUGFS_ADD_FILE(fw_info, dbgfs_dir, 0200);
406 	FWRT_DEBUGFS_ADD_FILE(send_hcmd, dbgfs_dir, 0200);
407 	FWRT_DEBUGFS_ADD_FILE(enabled_severities, dbgfs_dir, 0200);
408 	FWRT_DEBUGFS_ADD_FILE(fw_dbg_domain, dbgfs_dir, 0400);
409 }
410