1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * debugfs attributes for Wilco EC
4  *
5  * Copyright 2019 Google LLC
6  *
7  * See Documentation/ABI/testing/debugfs-wilco-ec for usage.
8  */
9 
10 #include <linux/ctype.h>
11 #include <linux/debugfs.h>
12 #include <linux/fs.h>
13 #include <linux/module.h>
14 #include <linux/platform_data/wilco-ec.h>
15 #include <linux/platform_device.h>
16 
17 #define DRV_NAME "wilco-ec-debugfs"
18 
19 /* The raw bytes will take up more space when represented as a hex string */
20 #define FORMATTED_BUFFER_SIZE (EC_MAILBOX_DATA_SIZE * 4)
21 
22 struct wilco_ec_debugfs {
23 	struct wilco_ec_device *ec;
24 	struct dentry *dir;
25 	size_t response_size;
26 	u8 raw_data[EC_MAILBOX_DATA_SIZE];
27 	u8 formatted_data[FORMATTED_BUFFER_SIZE];
28 };
29 static struct wilco_ec_debugfs *debug_info;
30 
31 /**
32  * parse_hex_sentence() - Convert a ascii hex representation into byte array.
33  * @in: Input buffer of ascii.
34  * @isize: Length of input buffer.
35  * @out: Output buffer.
36  * @osize: Length of output buffer, e.g. max number of bytes to parse.
37  *
38  * An valid input is a series of ascii hexadecimal numbers, separated by spaces.
39  * An example valid input is
40  * "   00 f2 0    000076 6 0  ff"
41  *
42  * If an individual "word" within the hex sentence is longer than MAX_WORD_SIZE,
43  * then the sentence is illegal, and parsing will fail.
44  *
45  * Return: Number of bytes parsed, or negative error code on failure.
46  */
47 static int parse_hex_sentence(const char *in, int isize, u8 *out, int osize)
48 {
49 	int n_parsed = 0;
50 	int word_start = 0;
51 	int word_end;
52 	int word_len;
53 	/* Temp buffer for holding a "word" of chars that represents one byte */
54 	#define MAX_WORD_SIZE 16
55 	char tmp[MAX_WORD_SIZE + 1];
56 	u8 byte;
57 
58 	while (word_start < isize && n_parsed < osize) {
59 		/* Find the start of the next word */
60 		while (word_start < isize && isspace(in[word_start]))
61 			word_start++;
62 		 /* reached the end of the input before next word? */
63 		if (word_start >= isize)
64 			break;
65 
66 		/* Find the end of this word */
67 		word_end = word_start;
68 		while (word_end < isize && !isspace(in[word_end]))
69 			word_end++;
70 
71 		/* Copy to a tmp NULL terminated string */
72 		word_len = word_end - word_start;
73 		if (word_len > MAX_WORD_SIZE)
74 			return -EINVAL;
75 		memcpy(tmp, in + word_start, word_len);
76 		tmp[word_len] = '\0';
77 
78 		/*
79 		 * Convert from hex string, place in output. If fails to parse,
80 		 * just return -EINVAL because specific error code is only
81 		 * relevant for this one word, returning it would be confusing.
82 		 */
83 		if (kstrtou8(tmp, 16, &byte))
84 			return -EINVAL;
85 		out[n_parsed++] = byte;
86 
87 		word_start = word_end;
88 	}
89 	return n_parsed;
90 }
91 
92 /* The message type takes up two bytes*/
93 #define TYPE_AND_DATA_SIZE ((EC_MAILBOX_DATA_SIZE) + 2)
94 
95 static ssize_t raw_write(struct file *file, const char __user *user_buf,
96 			 size_t count, loff_t *ppos)
97 {
98 	char *buf = debug_info->formatted_data;
99 	struct wilco_ec_message msg;
100 	u8 request_data[TYPE_AND_DATA_SIZE];
101 	ssize_t kcount;
102 	int ret;
103 
104 	if (count > FORMATTED_BUFFER_SIZE)
105 		return -EINVAL;
106 
107 	kcount = simple_write_to_buffer(buf, FORMATTED_BUFFER_SIZE, ppos,
108 					user_buf, count);
109 	if (kcount < 0)
110 		return kcount;
111 
112 	ret = parse_hex_sentence(buf, kcount, request_data, TYPE_AND_DATA_SIZE);
113 	if (ret < 0)
114 		return ret;
115 	/* Need at least two bytes for message type and one byte of data */
116 	if (ret < 3)
117 		return -EINVAL;
118 
119 	msg.type = request_data[0] << 8 | request_data[1];
120 	msg.flags = 0;
121 	msg.request_data = request_data + 2;
122 	msg.request_size = ret - 2;
123 	memset(debug_info->raw_data, 0, sizeof(debug_info->raw_data));
124 	msg.response_data = debug_info->raw_data;
125 	msg.response_size = EC_MAILBOX_DATA_SIZE;
126 
127 	ret = wilco_ec_mailbox(debug_info->ec, &msg);
128 	if (ret < 0)
129 		return ret;
130 	debug_info->response_size = ret;
131 
132 	return count;
133 }
134 
135 static ssize_t raw_read(struct file *file, char __user *user_buf, size_t count,
136 			loff_t *ppos)
137 {
138 	int fmt_len = 0;
139 
140 	if (debug_info->response_size) {
141 		fmt_len = hex_dump_to_buffer(debug_info->raw_data,
142 					     debug_info->response_size,
143 					     16, 1, debug_info->formatted_data,
144 					     sizeof(debug_info->formatted_data),
145 					     true);
146 		/* Only return response the first time it is read */
147 		debug_info->response_size = 0;
148 	}
149 
150 	return simple_read_from_buffer(user_buf, count, ppos,
151 				       debug_info->formatted_data, fmt_len);
152 }
153 
154 static const struct file_operations fops_raw = {
155 	.owner = THIS_MODULE,
156 	.read = raw_read,
157 	.write = raw_write,
158 	.llseek = no_llseek,
159 };
160 
161 #define CMD_KB_CHROME		0x88
162 #define SUB_CMD_H1_GPIO		0x0A
163 
164 struct h1_gpio_status_request {
165 	u8 cmd;		/* Always CMD_KB_CHROME */
166 	u8 reserved;
167 	u8 sub_cmd;	/* Always SUB_CMD_H1_GPIO */
168 } __packed;
169 
170 struct hi_gpio_status_response {
171 	u8 status;	/* 0 if allowed */
172 	u8 val;		/* BIT(0)=ENTRY_TO_FACT_MODE, BIT(1)=SPI_CHROME_SEL */
173 } __packed;
174 
175 static int h1_gpio_get(void *arg, u64 *val)
176 {
177 	struct wilco_ec_device *ec = arg;
178 	struct h1_gpio_status_request rq;
179 	struct hi_gpio_status_response rs;
180 	struct wilco_ec_message msg;
181 	int ret;
182 
183 	memset(&rq, 0, sizeof(rq));
184 	rq.cmd = CMD_KB_CHROME;
185 	rq.sub_cmd = SUB_CMD_H1_GPIO;
186 
187 	memset(&msg, 0, sizeof(msg));
188 	msg.type = WILCO_EC_MSG_LEGACY;
189 	msg.request_data = &rq;
190 	msg.request_size = sizeof(rq);
191 	msg.response_data = &rs;
192 	msg.response_size = sizeof(rs);
193 	ret = wilco_ec_mailbox(ec, &msg);
194 	if (ret < 0)
195 		return ret;
196 	if (rs.status)
197 		return -EIO;
198 
199 	*val = rs.val;
200 
201 	return 0;
202 }
203 
204 DEFINE_DEBUGFS_ATTRIBUTE(fops_h1_gpio, h1_gpio_get, NULL, "0x%02llx\n");
205 
206 /**
207  * wilco_ec_debugfs_probe() - Create the debugfs node
208  * @pdev: The platform device, probably created in core.c
209  *
210  * Try to create a debugfs node. If it fails, then we don't want to change
211  * behavior at all, this is for debugging after all. Just fail silently.
212  *
213  * Return: 0 always.
214  */
215 static int wilco_ec_debugfs_probe(struct platform_device *pdev)
216 {
217 	struct wilco_ec_device *ec = dev_get_drvdata(pdev->dev.parent);
218 
219 	debug_info = devm_kzalloc(&pdev->dev, sizeof(*debug_info), GFP_KERNEL);
220 	if (!debug_info)
221 		return 0;
222 	debug_info->ec = ec;
223 	debug_info->dir = debugfs_create_dir("wilco_ec", NULL);
224 	if (!debug_info->dir)
225 		return 0;
226 	debugfs_create_file("raw", 0644, debug_info->dir, NULL, &fops_raw);
227 	debugfs_create_file("h1_gpio", 0444, debug_info->dir, ec,
228 			    &fops_h1_gpio);
229 
230 	return 0;
231 }
232 
233 static int wilco_ec_debugfs_remove(struct platform_device *pdev)
234 {
235 	debugfs_remove_recursive(debug_info->dir);
236 
237 	return 0;
238 }
239 
240 static struct platform_driver wilco_ec_debugfs_driver = {
241 	.driver = {
242 		.name = DRV_NAME,
243 	},
244 	.probe = wilco_ec_debugfs_probe,
245 	.remove = wilco_ec_debugfs_remove,
246 };
247 
248 module_platform_driver(wilco_ec_debugfs_driver);
249 
250 MODULE_ALIAS("platform:" DRV_NAME);
251 MODULE_AUTHOR("Nick Crews <ncrews@chromium.org>");
252 MODULE_LICENSE("GPL v2");
253 MODULE_DESCRIPTION("Wilco EC debugfs driver");
254