1 // SPDX-License-Identifier: GPL-2.0+
2 // Debug logs for the ChromeOS EC
4 // Copyright (C) 2015 Google, Inc.
6 #include <linux/circ_buf.h>
7 #include <linux/debugfs.h>
8 #include <linux/delay.h>
10 #include <linux/mod_devicetable.h>
11 #include <linux/module.h>
12 #include <linux/mutex.h>
13 #include <linux/platform_data/cros_ec_commands.h>
14 #include <linux/platform_data/cros_ec_proto.h>
15 #include <linux/platform_device.h>
16 #include <linux/poll.h>
17 #include <linux/sched.h>
18 #include <linux/slab.h>
19 #include <linux/wait.h>
21 #define DRV_NAME "cros-ec-debugfs"
24 #define LOG_SIZE (1 << LOG_SHIFT)
25 #define LOG_POLL_SEC 10
27 #define CIRC_ADD(idx, size, value) (((idx) + (value)) & ((size) - 1))
29 static unsigned int log_poll_period_ms
= LOG_POLL_SEC
* MSEC_PER_SEC
;
30 module_param(log_poll_period_ms
, uint
, 0644);
31 MODULE_PARM_DESC(log_poll_period_ms
, "EC log polling period(ms)");
33 /* waitqueue for log readers */
34 static DECLARE_WAIT_QUEUE_HEAD(cros_ec_debugfs_log_wq
);
37 * struct cros_ec_debugfs - EC debugging information.
39 * @ec: EC device this debugfs information belongs to
40 * @dir: dentry for debugfs files
41 * @log_buffer: circular buffer for console log information
42 * @read_msg: preallocated EC command and buffer to read console log
43 * @log_mutex: mutex to protect circular buffer
44 * @log_poll_work: recurring task to poll EC for new console log data
45 * @panicinfo_blob: panicinfo debugfs blob
46 * @notifier_panic: notifier_block to let kernel to flush buffered log
49 struct cros_ec_debugfs
{
50 struct cros_ec_dev
*ec
;
53 struct circ_buf log_buffer
;
54 struct cros_ec_command
*read_msg
;
55 struct mutex log_mutex
;
56 struct delayed_work log_poll_work
;
58 struct debugfs_blob_wrapper panicinfo_blob
;
59 struct notifier_block notifier_panic
;
63 * We need to make sure that the EC log buffer on the UART is large enough,
64 * so that it is unlikely enough to overlow within log_poll_period_ms.
66 static void cros_ec_console_log_work(struct work_struct
*__work
)
68 struct cros_ec_debugfs
*debug_info
=
69 container_of(to_delayed_work(__work
),
70 struct cros_ec_debugfs
,
72 struct cros_ec_dev
*ec
= debug_info
->ec
;
73 struct circ_buf
*cb
= &debug_info
->log_buffer
;
74 struct cros_ec_command snapshot_msg
= {
75 .command
= EC_CMD_CONSOLE_SNAPSHOT
+ ec
->cmd_offset
,
78 struct ec_params_console_read_v1
*read_params
=
79 (struct ec_params_console_read_v1
*)debug_info
->read_msg
->data
;
80 uint8_t *ec_buffer
= (uint8_t *)debug_info
->read_msg
->data
;
85 ret
= cros_ec_cmd_xfer_status(ec
->ec_dev
, &snapshot_msg
);
89 /* Loop until we have read everything, or there's an error. */
90 mutex_lock(&debug_info
->log_mutex
);
91 buf_space
= CIRC_SPACE(cb
->head
, cb
->tail
, LOG_SIZE
);
95 dev_info_once(ec
->dev
,
96 "Some logs may have been dropped...\n");
100 memset(read_params
, '\0', sizeof(*read_params
));
101 read_params
->subcmd
= CONSOLE_READ_RECENT
;
102 ret
= cros_ec_cmd_xfer_status(ec
->ec_dev
,
103 debug_info
->read_msg
);
107 /* If the buffer is empty, we're done here. */
108 if (ret
== 0 || ec_buffer
[0] == '\0')
112 while (idx
< ret
&& ec_buffer
[idx
] != '\0' && buf_space
> 0) {
113 cb
->buf
[cb
->head
] = ec_buffer
[idx
];
114 cb
->head
= CIRC_ADD(cb
->head
, LOG_SIZE
, 1);
119 wake_up(&cros_ec_debugfs_log_wq
);
122 mutex_unlock(&debug_info
->log_mutex
);
125 schedule_delayed_work(&debug_info
->log_poll_work
,
126 msecs_to_jiffies(log_poll_period_ms
));
129 static int cros_ec_console_log_open(struct inode
*inode
, struct file
*file
)
131 file
->private_data
= inode
->i_private
;
133 return stream_open(inode
, file
);
136 static ssize_t
cros_ec_console_log_read(struct file
*file
, char __user
*buf
,
137 size_t count
, loff_t
*ppos
)
139 struct cros_ec_debugfs
*debug_info
= file
->private_data
;
140 struct circ_buf
*cb
= &debug_info
->log_buffer
;
143 mutex_lock(&debug_info
->log_mutex
);
145 while (!CIRC_CNT(cb
->head
, cb
->tail
, LOG_SIZE
)) {
146 if (file
->f_flags
& O_NONBLOCK
) {
151 mutex_unlock(&debug_info
->log_mutex
);
153 ret
= wait_event_interruptible(cros_ec_debugfs_log_wq
,
154 CIRC_CNT(cb
->head
, cb
->tail
, LOG_SIZE
));
158 mutex_lock(&debug_info
->log_mutex
);
161 /* Only copy until the end of the circular buffer, and let userspace
162 * retry to get the rest of the data.
164 ret
= min_t(size_t, CIRC_CNT_TO_END(cb
->head
, cb
->tail
, LOG_SIZE
),
167 if (copy_to_user(buf
, cb
->buf
+ cb
->tail
, ret
)) {
172 cb
->tail
= CIRC_ADD(cb
->tail
, LOG_SIZE
, ret
);
175 mutex_unlock(&debug_info
->log_mutex
);
179 static __poll_t
cros_ec_console_log_poll(struct file
*file
,
182 struct cros_ec_debugfs
*debug_info
= file
->private_data
;
185 poll_wait(file
, &cros_ec_debugfs_log_wq
, wait
);
187 mutex_lock(&debug_info
->log_mutex
);
188 if (CIRC_CNT(debug_info
->log_buffer
.head
,
189 debug_info
->log_buffer
.tail
,
191 mask
|= EPOLLIN
| EPOLLRDNORM
;
192 mutex_unlock(&debug_info
->log_mutex
);
197 static int cros_ec_console_log_release(struct inode
*inode
, struct file
*file
)
202 static ssize_t
cros_ec_pdinfo_read(struct file
*file
,
203 char __user
*user_buf
,
207 char read_buf
[EC_USB_PD_MAX_PORTS
* 40], *p
= read_buf
;
208 struct cros_ec_debugfs
*debug_info
= file
->private_data
;
209 struct cros_ec_device
*ec_dev
= debug_info
->ec
->ec_dev
;
211 struct cros_ec_command msg
;
213 struct ec_response_usb_pd_control_v1 resp
;
214 struct ec_params_usb_pd_control params
;
217 struct cros_ec_command
*msg
;
218 struct ec_response_usb_pd_control_v1
*resp
;
219 struct ec_params_usb_pd_control
*params
;
223 params
= (struct ec_params_usb_pd_control
*)msg
->data
;
224 resp
= (struct ec_response_usb_pd_control_v1
*)msg
->data
;
226 msg
->command
= EC_CMD_USB_PD_CONTROL
;
228 msg
->insize
= sizeof(*resp
);
229 msg
->outsize
= sizeof(*params
);
232 * Read status from all PD ports until failure, typically caused
233 * by attempting to read status on a port that doesn't exist.
235 for (i
= 0; i
< EC_USB_PD_MAX_PORTS
; ++i
) {
241 if (cros_ec_cmd_xfer_status(ec_dev
, msg
) < 0)
244 p
+= scnprintf(p
, sizeof(read_buf
) + read_buf
- p
,
245 "p%d: %s en:%.2x role:%.2x pol:%.2x\n", i
,
246 resp
->state
, resp
->enabled
, resp
->role
,
250 return simple_read_from_buffer(user_buf
, count
, ppos
,
251 read_buf
, p
- read_buf
);
254 static bool cros_ec_uptime_is_supported(struct cros_ec_device
*ec_dev
)
257 struct cros_ec_command cmd
;
258 struct ec_response_uptime_info resp
;
262 msg
.cmd
.command
= EC_CMD_GET_UPTIME_INFO
;
263 msg
.cmd
.insize
= sizeof(msg
.resp
);
265 ret
= cros_ec_cmd_xfer_status(ec_dev
, &msg
.cmd
);
266 if (ret
== -EPROTO
&& msg
.cmd
.result
== EC_RES_INVALID_COMMAND
)
269 /* Other errors maybe a transient error, do not rule about support. */
273 static ssize_t
cros_ec_uptime_read(struct file
*file
, char __user
*user_buf
,
274 size_t count
, loff_t
*ppos
)
276 struct cros_ec_debugfs
*debug_info
= file
->private_data
;
277 struct cros_ec_device
*ec_dev
= debug_info
->ec
->ec_dev
;
279 struct cros_ec_command cmd
;
280 struct ec_response_uptime_info resp
;
282 struct ec_response_uptime_info
*resp
;
286 resp
= (struct ec_response_uptime_info
*)&msg
.resp
;
288 msg
.cmd
.command
= EC_CMD_GET_UPTIME_INFO
;
289 msg
.cmd
.insize
= sizeof(*resp
);
291 ret
= cros_ec_cmd_xfer_status(ec_dev
, &msg
.cmd
);
295 ret
= scnprintf(read_buf
, sizeof(read_buf
), "%u\n",
296 resp
->time_since_ec_boot_ms
);
298 return simple_read_from_buffer(user_buf
, count
, ppos
, read_buf
, ret
);
301 static const struct file_operations cros_ec_console_log_fops
= {
302 .owner
= THIS_MODULE
,
303 .open
= cros_ec_console_log_open
,
304 .read
= cros_ec_console_log_read
,
305 .poll
= cros_ec_console_log_poll
,
306 .release
= cros_ec_console_log_release
,
309 static const struct file_operations cros_ec_pdinfo_fops
= {
310 .owner
= THIS_MODULE
,
312 .read
= cros_ec_pdinfo_read
,
313 .llseek
= default_llseek
,
316 static const struct file_operations cros_ec_uptime_fops
= {
317 .owner
= THIS_MODULE
,
319 .read
= cros_ec_uptime_read
,
320 .llseek
= default_llseek
,
323 static int ec_read_version_supported(struct cros_ec_dev
*ec
)
325 struct ec_params_get_cmd_versions_v1
*params
;
326 struct ec_response_get_cmd_versions
*response
;
329 struct cros_ec_command
*msg
;
331 msg
= kzalloc(sizeof(*msg
) + max(sizeof(*params
), sizeof(*response
)),
337 msg
->command
= EC_CMD_GET_CMD_VERSIONS
+ ec
->cmd_offset
;
338 msg
->outsize
= sizeof(*params
);
339 msg
->insize
= sizeof(*response
);
341 params
= (struct ec_params_get_cmd_versions_v1
*)msg
->data
;
342 params
->cmd
= EC_CMD_CONSOLE_READ
;
343 response
= (struct ec_response_get_cmd_versions
*)msg
->data
;
345 ret
= cros_ec_cmd_xfer_status(ec
->ec_dev
, msg
) >= 0 &&
346 response
->version_mask
& EC_VER_MASK(1);
353 static int cros_ec_create_console_log(struct cros_ec_debugfs
*debug_info
)
355 struct cros_ec_dev
*ec
= debug_info
->ec
;
357 int read_params_size
;
358 int read_response_size
;
361 * If the console log feature is not supported return silently and
362 * don't create the console_log entry.
364 if (!ec_read_version_supported(ec
))
367 buf
= devm_kzalloc(ec
->dev
, LOG_SIZE
, GFP_KERNEL
);
371 read_params_size
= sizeof(struct ec_params_console_read_v1
);
372 read_response_size
= ec
->ec_dev
->max_response
;
373 debug_info
->read_msg
= devm_kzalloc(ec
->dev
,
374 sizeof(*debug_info
->read_msg
) +
375 max(read_params_size
, read_response_size
), GFP_KERNEL
);
376 if (!debug_info
->read_msg
)
379 debug_info
->read_msg
->version
= 1;
380 debug_info
->read_msg
->command
= EC_CMD_CONSOLE_READ
+ ec
->cmd_offset
;
381 debug_info
->read_msg
->outsize
= read_params_size
;
382 debug_info
->read_msg
->insize
= read_response_size
;
384 debug_info
->log_buffer
.buf
= buf
;
385 debug_info
->log_buffer
.head
= 0;
386 debug_info
->log_buffer
.tail
= 0;
388 mutex_init(&debug_info
->log_mutex
);
390 debugfs_create_file("console_log", S_IFREG
| 0444, debug_info
->dir
,
391 debug_info
, &cros_ec_console_log_fops
);
393 INIT_DELAYED_WORK(&debug_info
->log_poll_work
,
394 cros_ec_console_log_work
);
395 schedule_delayed_work(&debug_info
->log_poll_work
, 0);
400 static void cros_ec_cleanup_console_log(struct cros_ec_debugfs
*debug_info
)
402 if (debug_info
->log_buffer
.buf
) {
403 cancel_delayed_work_sync(&debug_info
->log_poll_work
);
404 mutex_destroy(&debug_info
->log_mutex
);
409 * Returns the size of the panicinfo data fetched from the EC
411 static int cros_ec_get_panicinfo(struct cros_ec_device
*ec_dev
, uint8_t *data
,
415 struct cros_ec_command
*msg
;
417 if (!data
|| data_size
<= 0 || data_size
> ec_dev
->max_response
)
420 msg
= kzalloc(sizeof(*msg
) + data_size
, GFP_KERNEL
);
424 msg
->command
= EC_CMD_GET_PANIC_INFO
;
425 msg
->insize
= data_size
;
427 ret
= cros_ec_cmd_xfer_status(ec_dev
, msg
);
431 memcpy(data
, msg
->data
, data_size
);
438 static int cros_ec_create_panicinfo(struct cros_ec_debugfs
*debug_info
)
440 struct cros_ec_device
*ec_dev
= debug_info
->ec
->ec_dev
;
444 data
= devm_kzalloc(debug_info
->ec
->dev
, ec_dev
->max_response
,
449 ret
= cros_ec_get_panicinfo(ec_dev
, data
, ec_dev
->max_response
);
459 debug_info
->panicinfo_blob
.data
= data
;
460 debug_info
->panicinfo_blob
.size
= ret
;
462 debugfs_create_blob("panicinfo", 0444, debug_info
->dir
,
463 &debug_info
->panicinfo_blob
);
468 devm_kfree(debug_info
->ec
->dev
, data
);
472 static int cros_ec_debugfs_panic_event(struct notifier_block
*nb
,
473 unsigned long queued_during_suspend
, void *_notify
)
475 struct cros_ec_debugfs
*debug_info
=
476 container_of(nb
, struct cros_ec_debugfs
, notifier_panic
);
478 if (debug_info
->log_buffer
.buf
) {
479 /* Force log poll work to run immediately */
480 mod_delayed_work(debug_info
->log_poll_work
.wq
, &debug_info
->log_poll_work
, 0);
481 /* Block until log poll work finishes */
482 flush_delayed_work(&debug_info
->log_poll_work
);
488 static int cros_ec_debugfs_probe(struct platform_device
*pd
)
490 struct cros_ec_dev
*ec
= dev_get_drvdata(pd
->dev
.parent
);
491 struct cros_ec_platform
*ec_platform
= dev_get_platdata(ec
->dev
);
492 const char *name
= ec_platform
->ec_name
;
493 struct cros_ec_debugfs
*debug_info
;
496 debug_info
= devm_kzalloc(ec
->dev
, sizeof(*debug_info
), GFP_KERNEL
);
501 debug_info
->dir
= debugfs_create_dir(name
, NULL
);
503 ret
= cros_ec_create_panicinfo(debug_info
);
507 ret
= cros_ec_create_console_log(debug_info
);
511 debugfs_create_file("pdinfo", 0444, debug_info
->dir
, debug_info
,
512 &cros_ec_pdinfo_fops
);
514 if (cros_ec_uptime_is_supported(ec
->ec_dev
))
515 debugfs_create_file("uptime", 0444, debug_info
->dir
, debug_info
,
516 &cros_ec_uptime_fops
);
518 debugfs_create_x32("last_resume_result", 0444, debug_info
->dir
,
519 &ec
->ec_dev
->last_resume_result
);
521 debugfs_create_u16("suspend_timeout_ms", 0664, debug_info
->dir
,
522 &ec
->ec_dev
->suspend_timeout_ms
);
524 debug_info
->notifier_panic
.notifier_call
= cros_ec_debugfs_panic_event
;
525 ret
= blocking_notifier_chain_register(&ec
->ec_dev
->panic_notifier
,
526 &debug_info
->notifier_panic
);
530 ec
->debug_info
= debug_info
;
532 dev_set_drvdata(&pd
->dev
, ec
);
537 debugfs_remove_recursive(debug_info
->dir
);
541 static void cros_ec_debugfs_remove(struct platform_device
*pd
)
543 struct cros_ec_dev
*ec
= dev_get_drvdata(pd
->dev
.parent
);
545 debugfs_remove_recursive(ec
->debug_info
->dir
);
546 cros_ec_cleanup_console_log(ec
->debug_info
);
549 static int __maybe_unused
cros_ec_debugfs_suspend(struct device
*dev
)
551 struct cros_ec_dev
*ec
= dev_get_drvdata(dev
);
553 if (ec
->debug_info
->log_buffer
.buf
)
554 cancel_delayed_work_sync(&ec
->debug_info
->log_poll_work
);
559 static int __maybe_unused
cros_ec_debugfs_resume(struct device
*dev
)
561 struct cros_ec_dev
*ec
= dev_get_drvdata(dev
);
563 if (ec
->debug_info
->log_buffer
.buf
)
564 schedule_delayed_work(&ec
->debug_info
->log_poll_work
, 0);
569 static SIMPLE_DEV_PM_OPS(cros_ec_debugfs_pm_ops
,
570 cros_ec_debugfs_suspend
, cros_ec_debugfs_resume
);
572 static const struct platform_device_id cros_ec_debugfs_id
[] = {
576 MODULE_DEVICE_TABLE(platform
, cros_ec_debugfs_id
);
578 static struct platform_driver cros_ec_debugfs_driver
= {
581 .pm
= &cros_ec_debugfs_pm_ops
,
582 .probe_type
= PROBE_PREFER_ASYNCHRONOUS
,
584 .probe
= cros_ec_debugfs_probe
,
585 .remove
= cros_ec_debugfs_remove
,
586 .id_table
= cros_ec_debugfs_id
,
589 module_platform_driver(cros_ec_debugfs_driver
);
591 MODULE_LICENSE("GPL");
592 MODULE_DESCRIPTION("Debug logs for ChromeOS EC");