1 // SPDX-License-Identifier: GPL-2.0-only
2 /***************************************************************************
3  *   Copyright (C) 2010-2012 by Bruno Prémont <bonbons@linux-vserver.org>  *
4  *                                                                         *
5  *   Based on Logitech G13 driver (v0.4)                                   *
6  *     Copyright (C) 2009 by Rick L. Vinyard, Jr. <rvinyard@cs.nmsu.edu>   *
7  *                                                                         *
8  ***************************************************************************/
9 
10 #include <linux/hid.h>
11 #include <linux/hid-debug.h>
12 
13 #include <linux/fb.h>
14 #include <linux/seq_file.h>
15 #include <linux/debugfs.h>
16 
17 #include <linux/module.h>
18 #include <linux/uaccess.h>
19 
20 #include "hid-picolcd.h"
21 
22 
23 static int picolcd_debug_reset_show(struct seq_file *f, void *p)
24 {
25 	if (picolcd_fbinfo((struct picolcd_data *)f->private))
26 		seq_printf(f, "all fb\n");
27 	else
28 		seq_printf(f, "all\n");
29 	return 0;
30 }
31 
32 static int picolcd_debug_reset_open(struct inode *inode, struct file *f)
33 {
34 	return single_open(f, picolcd_debug_reset_show, inode->i_private);
35 }
36 
37 static ssize_t picolcd_debug_reset_write(struct file *f, const char __user *user_buf,
38 		size_t count, loff_t *ppos)
39 {
40 	struct picolcd_data *data = ((struct seq_file *)f->private_data)->private;
41 	char buf[32];
42 	size_t cnt = min(count, sizeof(buf)-1);
43 	if (copy_from_user(buf, user_buf, cnt))
44 		return -EFAULT;
45 
46 	while (cnt > 0 && (buf[cnt-1] == ' ' || buf[cnt-1] == '\n'))
47 		cnt--;
48 	buf[cnt] = '\0';
49 	if (strcmp(buf, "all") == 0) {
50 		picolcd_reset(data->hdev);
51 		picolcd_fb_reset(data, 1);
52 	} else if (strcmp(buf, "fb") == 0) {
53 		picolcd_fb_reset(data, 1);
54 	} else {
55 		return -EINVAL;
56 	}
57 	return count;
58 }
59 
60 static const struct file_operations picolcd_debug_reset_fops = {
61 	.owner    = THIS_MODULE,
62 	.open     = picolcd_debug_reset_open,
63 	.read     = seq_read,
64 	.llseek   = seq_lseek,
65 	.write    = picolcd_debug_reset_write,
66 	.release  = single_release,
67 };
68 
69 /*
70  * The "eeprom" file
71  */
72 static ssize_t picolcd_debug_eeprom_read(struct file *f, char __user *u,
73 		size_t s, loff_t *off)
74 {
75 	struct picolcd_data *data = f->private_data;
76 	struct picolcd_pending *resp;
77 	u8 raw_data[3];
78 	ssize_t ret = -EIO;
79 
80 	if (s == 0)
81 		return -EINVAL;
82 	if (*off > 0x0ff)
83 		return 0;
84 
85 	/* prepare buffer with info about what we want to read (addr & len) */
86 	raw_data[0] = *off & 0xff;
87 	raw_data[1] = (*off >> 8) & 0xff;
88 	raw_data[2] = s < 20 ? s : 20;
89 	if (*off + raw_data[2] > 0xff)
90 		raw_data[2] = 0x100 - *off;
91 	resp = picolcd_send_and_wait(data->hdev, REPORT_EE_READ, raw_data,
92 			sizeof(raw_data));
93 	if (!resp)
94 		return -EIO;
95 
96 	if (resp->in_report && resp->in_report->id == REPORT_EE_DATA) {
97 		/* successful read :) */
98 		ret = resp->raw_data[2];
99 		if (ret > s)
100 			ret = s;
101 		if (copy_to_user(u, resp->raw_data+3, ret))
102 			ret = -EFAULT;
103 		else
104 			*off += ret;
105 	} /* anything else is some kind of IO error */
106 
107 	kfree(resp);
108 	return ret;
109 }
110 
111 static ssize_t picolcd_debug_eeprom_write(struct file *f, const char __user *u,
112 		size_t s, loff_t *off)
113 {
114 	struct picolcd_data *data = f->private_data;
115 	struct picolcd_pending *resp;
116 	ssize_t ret = -EIO;
117 	u8 raw_data[23];
118 
119 	if (s == 0)
120 		return -EINVAL;
121 	if (*off > 0x0ff)
122 		return -ENOSPC;
123 
124 	memset(raw_data, 0, sizeof(raw_data));
125 	raw_data[0] = *off & 0xff;
126 	raw_data[1] = (*off >> 8) & 0xff;
127 	raw_data[2] = min_t(size_t, 20, s);
128 	if (*off + raw_data[2] > 0xff)
129 		raw_data[2] = 0x100 - *off;
130 
131 	if (copy_from_user(raw_data+3, u, min((u8)20, raw_data[2])))
132 		return -EFAULT;
133 	resp = picolcd_send_and_wait(data->hdev, REPORT_EE_WRITE, raw_data,
134 			sizeof(raw_data));
135 
136 	if (!resp)
137 		return -EIO;
138 
139 	if (resp->in_report && resp->in_report->id == REPORT_EE_DATA) {
140 		/* check if written data matches */
141 		if (memcmp(raw_data, resp->raw_data, 3+raw_data[2]) == 0) {
142 			*off += raw_data[2];
143 			ret = raw_data[2];
144 		}
145 	}
146 	kfree(resp);
147 	return ret;
148 }
149 
150 /*
151  * Notes:
152  * - read/write happens in chunks of at most 20 bytes, it's up to userspace
153  *   to loop in order to get more data.
154  * - on write errors on otherwise correct write request the bytes
155  *   that should have been written are in undefined state.
156  */
157 static const struct file_operations picolcd_debug_eeprom_fops = {
158 	.owner    = THIS_MODULE,
159 	.open     = simple_open,
160 	.read     = picolcd_debug_eeprom_read,
161 	.write    = picolcd_debug_eeprom_write,
162 	.llseek   = generic_file_llseek,
163 };
164 
165 /*
166  * The "flash" file
167  */
168 /* record a flash address to buf (bounds check to be done by caller) */
169 static int _picolcd_flash_setaddr(struct picolcd_data *data, u8 *buf, long off)
170 {
171 	buf[0] = off & 0xff;
172 	buf[1] = (off >> 8) & 0xff;
173 	if (data->addr_sz == 3)
174 		buf[2] = (off >> 16) & 0xff;
175 	return data->addr_sz == 2 ? 2 : 3;
176 }
177 
178 /* read a given size of data (bounds check to be done by caller) */
179 static ssize_t _picolcd_flash_read(struct picolcd_data *data, int report_id,
180 		char __user *u, size_t s, loff_t *off)
181 {
182 	struct picolcd_pending *resp;
183 	u8 raw_data[4];
184 	ssize_t ret = 0;
185 	int len_off, err = -EIO;
186 
187 	while (s > 0) {
188 		err = -EIO;
189 		len_off = _picolcd_flash_setaddr(data, raw_data, *off);
190 		raw_data[len_off] = s > 32 ? 32 : s;
191 		resp = picolcd_send_and_wait(data->hdev, report_id, raw_data, len_off+1);
192 		if (!resp || !resp->in_report)
193 			goto skip;
194 		if (resp->in_report->id == REPORT_MEMORY ||
195 			resp->in_report->id == REPORT_BL_READ_MEMORY) {
196 			if (memcmp(raw_data, resp->raw_data, len_off+1) != 0)
197 				goto skip;
198 			if (copy_to_user(u+ret, resp->raw_data+len_off+1, raw_data[len_off])) {
199 				err = -EFAULT;
200 				goto skip;
201 			}
202 			*off += raw_data[len_off];
203 			s    -= raw_data[len_off];
204 			ret  += raw_data[len_off];
205 			err   = 0;
206 		}
207 skip:
208 		kfree(resp);
209 		if (err)
210 			return ret > 0 ? ret : err;
211 	}
212 	return ret;
213 }
214 
215 static ssize_t picolcd_debug_flash_read(struct file *f, char __user *u,
216 		size_t s, loff_t *off)
217 {
218 	struct picolcd_data *data = f->private_data;
219 
220 	if (s == 0)
221 		return -EINVAL;
222 	if (*off > 0x05fff)
223 		return 0;
224 	if (*off + s > 0x05fff)
225 		s = 0x06000 - *off;
226 
227 	if (data->status & PICOLCD_BOOTLOADER)
228 		return _picolcd_flash_read(data, REPORT_BL_READ_MEMORY, u, s, off);
229 	else
230 		return _picolcd_flash_read(data, REPORT_READ_MEMORY, u, s, off);
231 }
232 
233 /* erase block aligned to 64bytes boundary */
234 static ssize_t _picolcd_flash_erase64(struct picolcd_data *data, int report_id,
235 		loff_t *off)
236 {
237 	struct picolcd_pending *resp;
238 	u8 raw_data[3];
239 	int len_off;
240 	ssize_t ret = -EIO;
241 
242 	if (*off & 0x3f)
243 		return -EINVAL;
244 
245 	len_off = _picolcd_flash_setaddr(data, raw_data, *off);
246 	resp = picolcd_send_and_wait(data->hdev, report_id, raw_data, len_off);
247 	if (!resp || !resp->in_report)
248 		goto skip;
249 	if (resp->in_report->id == REPORT_MEMORY ||
250 		resp->in_report->id == REPORT_BL_ERASE_MEMORY) {
251 		if (memcmp(raw_data, resp->raw_data, len_off) != 0)
252 			goto skip;
253 		ret = 0;
254 	}
255 skip:
256 	kfree(resp);
257 	return ret;
258 }
259 
260 /* write a given size of data (bounds check to be done by caller) */
261 static ssize_t _picolcd_flash_write(struct picolcd_data *data, int report_id,
262 		const char __user *u, size_t s, loff_t *off)
263 {
264 	struct picolcd_pending *resp;
265 	u8 raw_data[36];
266 	ssize_t ret = 0;
267 	int len_off, err = -EIO;
268 
269 	while (s > 0) {
270 		err = -EIO;
271 		len_off = _picolcd_flash_setaddr(data, raw_data, *off);
272 		raw_data[len_off] = s > 32 ? 32 : s;
273 		if (copy_from_user(raw_data+len_off+1, u, raw_data[len_off])) {
274 			err = -EFAULT;
275 			break;
276 		}
277 		resp = picolcd_send_and_wait(data->hdev, report_id, raw_data,
278 				len_off+1+raw_data[len_off]);
279 		if (!resp || !resp->in_report)
280 			goto skip;
281 		if (resp->in_report->id == REPORT_MEMORY ||
282 			resp->in_report->id == REPORT_BL_WRITE_MEMORY) {
283 			if (memcmp(raw_data, resp->raw_data, len_off+1+raw_data[len_off]) != 0)
284 				goto skip;
285 			*off += raw_data[len_off];
286 			s    -= raw_data[len_off];
287 			ret  += raw_data[len_off];
288 			err   = 0;
289 		}
290 skip:
291 		kfree(resp);
292 		if (err)
293 			break;
294 	}
295 	return ret > 0 ? ret : err;
296 }
297 
298 static ssize_t picolcd_debug_flash_write(struct file *f, const char __user *u,
299 		size_t s, loff_t *off)
300 {
301 	struct picolcd_data *data = f->private_data;
302 	ssize_t err, ret = 0;
303 	int report_erase, report_write;
304 
305 	if (s == 0)
306 		return -EINVAL;
307 	if (*off > 0x5fff)
308 		return -ENOSPC;
309 	if (s & 0x3f)
310 		return -EINVAL;
311 	if (*off & 0x3f)
312 		return -EINVAL;
313 
314 	if (data->status & PICOLCD_BOOTLOADER) {
315 		report_erase = REPORT_BL_ERASE_MEMORY;
316 		report_write = REPORT_BL_WRITE_MEMORY;
317 	} else {
318 		report_erase = REPORT_ERASE_MEMORY;
319 		report_write = REPORT_WRITE_MEMORY;
320 	}
321 	mutex_lock(&data->mutex_flash);
322 	while (s > 0) {
323 		err = _picolcd_flash_erase64(data, report_erase, off);
324 		if (err)
325 			break;
326 		err = _picolcd_flash_write(data, report_write, u, 64, off);
327 		if (err < 0)
328 			break;
329 		ret += err;
330 		*off += err;
331 		s -= err;
332 		if (err != 64)
333 			break;
334 	}
335 	mutex_unlock(&data->mutex_flash);
336 	return ret > 0 ? ret : err;
337 }
338 
339 /*
340  * Notes:
341  * - concurrent writing is prevented by mutex and all writes must be
342  *   n*64 bytes and 64-byte aligned, each write being preceded by an
343  *   ERASE which erases a 64byte block.
344  *   If less than requested was written or an error is returned for an
345  *   otherwise correct write request the next 64-byte block which should
346  *   have been written is in undefined state (mostly: original, erased,
347  *   (half-)written with write error)
348  * - reading can happen without special restriction
349  */
350 static const struct file_operations picolcd_debug_flash_fops = {
351 	.owner    = THIS_MODULE,
352 	.open     = simple_open,
353 	.read     = picolcd_debug_flash_read,
354 	.write    = picolcd_debug_flash_write,
355 	.llseek   = generic_file_llseek,
356 };
357 
358 
359 /*
360  * Helper code for HID report level dumping/debugging
361  */
362 static const char * const error_codes[] = {
363 	"success", "parameter missing", "data_missing", "block readonly",
364 	"block not erasable", "block too big", "section overflow",
365 	"invalid command length", "invalid data length",
366 };
367 
368 static void dump_buff_as_hex(char *dst, size_t dst_sz, const u8 *data,
369 		const size_t data_len)
370 {
371 	int i, j;
372 	for (i = j = 0; i < data_len && j + 4 < dst_sz; i++) {
373 		dst[j++] = hex_asc[(data[i] >> 4) & 0x0f];
374 		dst[j++] = hex_asc[data[i] & 0x0f];
375 		dst[j++] = ' ';
376 	}
377 	dst[j]   = '\0';
378 	if (j > 0)
379 		dst[j-1] = '\n';
380 	if (i < data_len && j > 2)
381 		dst[j-2] = dst[j-3] = '.';
382 }
383 
384 void picolcd_debug_out_report(struct picolcd_data *data,
385 		struct hid_device *hdev, struct hid_report *report)
386 {
387 	u8 *raw_data;
388 	int raw_size = (report->size >> 3) + 1;
389 	char *buff;
390 #define BUFF_SZ 256
391 
392 	/* Avoid unnecessary overhead if debugfs is disabled */
393 	if (list_empty(&hdev->debug_list))
394 		return;
395 
396 	buff = kmalloc(BUFF_SZ, GFP_ATOMIC);
397 	if (!buff)
398 		return;
399 
400 	raw_data = hid_alloc_report_buf(report, GFP_ATOMIC);
401 	if (!raw_data) {
402 		kfree(buff);
403 		return;
404 	}
405 
406 	snprintf(buff, BUFF_SZ, "\nout report %d (size %d) =  ",
407 			report->id, raw_size);
408 	hid_debug_event(hdev, buff);
409 	raw_data[0] = report->id;
410 	hid_output_report(report, raw_data);
411 	dump_buff_as_hex(buff, BUFF_SZ, raw_data, raw_size);
412 	hid_debug_event(hdev, buff);
413 
414 	switch (report->id) {
415 	case REPORT_LED_STATE:
416 		/* 1 data byte with GPO state */
417 		snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
418 			"REPORT_LED_STATE", report->id, raw_size-1);
419 		hid_debug_event(hdev, buff);
420 		snprintf(buff, BUFF_SZ, "\tGPO state: 0x%02x\n", raw_data[1]);
421 		hid_debug_event(hdev, buff);
422 		break;
423 	case REPORT_BRIGHTNESS:
424 		/* 1 data byte with brightness */
425 		snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
426 			"REPORT_BRIGHTNESS", report->id, raw_size-1);
427 		hid_debug_event(hdev, buff);
428 		snprintf(buff, BUFF_SZ, "\tBrightness: 0x%02x\n", raw_data[1]);
429 		hid_debug_event(hdev, buff);
430 		break;
431 	case REPORT_CONTRAST:
432 		/* 1 data byte with contrast */
433 		snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
434 			"REPORT_CONTRAST", report->id, raw_size-1);
435 		hid_debug_event(hdev, buff);
436 		snprintf(buff, BUFF_SZ, "\tContrast: 0x%02x\n", raw_data[1]);
437 		hid_debug_event(hdev, buff);
438 		break;
439 	case REPORT_RESET:
440 		/* 2 data bytes with reset duration in ms */
441 		snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
442 			"REPORT_RESET", report->id, raw_size-1);
443 		hid_debug_event(hdev, buff);
444 		snprintf(buff, BUFF_SZ, "\tDuration: 0x%02x%02x (%dms)\n",
445 				raw_data[2], raw_data[1], raw_data[2] << 8 | raw_data[1]);
446 		hid_debug_event(hdev, buff);
447 		break;
448 	case REPORT_LCD_CMD:
449 		/* 63 data bytes with LCD commands */
450 		snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
451 			"REPORT_LCD_CMD", report->id, raw_size-1);
452 		hid_debug_event(hdev, buff);
453 		/* TODO: format decoding */
454 		break;
455 	case REPORT_LCD_DATA:
456 		/* 63 data bytes with LCD data */
457 		snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
458 			"REPORT_LCD_CMD", report->id, raw_size-1);
459 		/* TODO: format decoding */
460 		hid_debug_event(hdev, buff);
461 		break;
462 	case REPORT_LCD_CMD_DATA:
463 		/* 63 data bytes with LCD commands and data */
464 		snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
465 			"REPORT_LCD_CMD", report->id, raw_size-1);
466 		/* TODO: format decoding */
467 		hid_debug_event(hdev, buff);
468 		break;
469 	case REPORT_EE_READ:
470 		/* 3 data bytes with read area description */
471 		snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
472 			"REPORT_EE_READ", report->id, raw_size-1);
473 		hid_debug_event(hdev, buff);
474 		snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n",
475 				raw_data[2], raw_data[1]);
476 		hid_debug_event(hdev, buff);
477 		snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);
478 		hid_debug_event(hdev, buff);
479 		break;
480 	case REPORT_EE_WRITE:
481 		/* 3+1..20 data bytes with write area description */
482 		snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
483 			"REPORT_EE_WRITE", report->id, raw_size-1);
484 		hid_debug_event(hdev, buff);
485 		snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n",
486 				raw_data[2], raw_data[1]);
487 		hid_debug_event(hdev, buff);
488 		snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);
489 		hid_debug_event(hdev, buff);
490 		if (raw_data[3] == 0) {
491 			snprintf(buff, BUFF_SZ, "\tNo data\n");
492 		} else if (raw_data[3] + 4 <= raw_size) {
493 			snprintf(buff, BUFF_SZ, "\tData: ");
494 			hid_debug_event(hdev, buff);
495 			dump_buff_as_hex(buff, BUFF_SZ, raw_data+4, raw_data[3]);
496 		} else {
497 			snprintf(buff, BUFF_SZ, "\tData overflowed\n");
498 		}
499 		hid_debug_event(hdev, buff);
500 		break;
501 	case REPORT_ERASE_MEMORY:
502 	case REPORT_BL_ERASE_MEMORY:
503 		/* 3 data bytes with pointer inside erase block */
504 		snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
505 			"REPORT_ERASE_MEMORY", report->id, raw_size-1);
506 		hid_debug_event(hdev, buff);
507 		switch (data->addr_sz) {
508 		case 2:
509 			snprintf(buff, BUFF_SZ, "\tAddress inside 64 byte block: 0x%02x%02x\n",
510 					raw_data[2], raw_data[1]);
511 			break;
512 		case 3:
513 			snprintf(buff, BUFF_SZ, "\tAddress inside 64 byte block: 0x%02x%02x%02x\n",
514 					raw_data[3], raw_data[2], raw_data[1]);
515 			break;
516 		default:
517 			snprintf(buff, BUFF_SZ, "\tNot supported\n");
518 		}
519 		hid_debug_event(hdev, buff);
520 		break;
521 	case REPORT_READ_MEMORY:
522 	case REPORT_BL_READ_MEMORY:
523 		/* 4 data bytes with read area description */
524 		snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
525 			"REPORT_READ_MEMORY", report->id, raw_size-1);
526 		hid_debug_event(hdev, buff);
527 		switch (data->addr_sz) {
528 		case 2:
529 			snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n",
530 					raw_data[2], raw_data[1]);
531 			hid_debug_event(hdev, buff);
532 			snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);
533 			break;
534 		case 3:
535 			snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x%02x\n",
536 					raw_data[3], raw_data[2], raw_data[1]);
537 			hid_debug_event(hdev, buff);
538 			snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[4]);
539 			break;
540 		default:
541 			snprintf(buff, BUFF_SZ, "\tNot supported\n");
542 		}
543 		hid_debug_event(hdev, buff);
544 		break;
545 	case REPORT_WRITE_MEMORY:
546 	case REPORT_BL_WRITE_MEMORY:
547 		/* 4+1..32 data bytes with write adrea description */
548 		snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
549 			"REPORT_WRITE_MEMORY", report->id, raw_size-1);
550 		hid_debug_event(hdev, buff);
551 		switch (data->addr_sz) {
552 		case 2:
553 			snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n",
554 					raw_data[2], raw_data[1]);
555 			hid_debug_event(hdev, buff);
556 			snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);
557 			hid_debug_event(hdev, buff);
558 			if (raw_data[3] == 0) {
559 				snprintf(buff, BUFF_SZ, "\tNo data\n");
560 			} else if (raw_data[3] + 4 <= raw_size) {
561 				snprintf(buff, BUFF_SZ, "\tData: ");
562 				hid_debug_event(hdev, buff);
563 				dump_buff_as_hex(buff, BUFF_SZ, raw_data+4, raw_data[3]);
564 			} else {
565 				snprintf(buff, BUFF_SZ, "\tData overflowed\n");
566 			}
567 			break;
568 		case 3:
569 			snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x%02x\n",
570 					raw_data[3], raw_data[2], raw_data[1]);
571 			hid_debug_event(hdev, buff);
572 			snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[4]);
573 			hid_debug_event(hdev, buff);
574 			if (raw_data[4] == 0) {
575 				snprintf(buff, BUFF_SZ, "\tNo data\n");
576 			} else if (raw_data[4] + 5 <= raw_size) {
577 				snprintf(buff, BUFF_SZ, "\tData: ");
578 				hid_debug_event(hdev, buff);
579 				dump_buff_as_hex(buff, BUFF_SZ, raw_data+5, raw_data[4]);
580 			} else {
581 				snprintf(buff, BUFF_SZ, "\tData overflowed\n");
582 			}
583 			break;
584 		default:
585 			snprintf(buff, BUFF_SZ, "\tNot supported\n");
586 		}
587 		hid_debug_event(hdev, buff);
588 		break;
589 	case REPORT_SPLASH_RESTART:
590 		/* TODO */
591 		break;
592 	case REPORT_EXIT_KEYBOARD:
593 		snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
594 			"REPORT_EXIT_KEYBOARD", report->id, raw_size-1);
595 		hid_debug_event(hdev, buff);
596 		snprintf(buff, BUFF_SZ, "\tRestart delay: %dms (0x%02x%02x)\n",
597 				raw_data[1] | (raw_data[2] << 8),
598 				raw_data[2], raw_data[1]);
599 		hid_debug_event(hdev, buff);
600 		break;
601 	case REPORT_VERSION:
602 		snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
603 			"REPORT_VERSION", report->id, raw_size-1);
604 		hid_debug_event(hdev, buff);
605 		break;
606 	case REPORT_DEVID:
607 		snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
608 			"REPORT_DEVID", report->id, raw_size-1);
609 		hid_debug_event(hdev, buff);
610 		break;
611 	case REPORT_SPLASH_SIZE:
612 		snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
613 			"REPORT_SPLASH_SIZE", report->id, raw_size-1);
614 		hid_debug_event(hdev, buff);
615 		break;
616 	case REPORT_HOOK_VERSION:
617 		snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
618 			"REPORT_HOOK_VERSION", report->id, raw_size-1);
619 		hid_debug_event(hdev, buff);
620 		break;
621 	case REPORT_EXIT_FLASHER:
622 		snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
623 			"REPORT_VERSION", report->id, raw_size-1);
624 		hid_debug_event(hdev, buff);
625 		snprintf(buff, BUFF_SZ, "\tRestart delay: %dms (0x%02x%02x)\n",
626 				raw_data[1] | (raw_data[2] << 8),
627 				raw_data[2], raw_data[1]);
628 		hid_debug_event(hdev, buff);
629 		break;
630 	default:
631 		snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
632 			"<unknown>", report->id, raw_size-1);
633 		hid_debug_event(hdev, buff);
634 		break;
635 	}
636 	wake_up_interruptible(&hdev->debug_wait);
637 	kfree(raw_data);
638 	kfree(buff);
639 }
640 
641 void picolcd_debug_raw_event(struct picolcd_data *data,
642 		struct hid_device *hdev, struct hid_report *report,
643 		u8 *raw_data, int size)
644 {
645 	char *buff;
646 
647 #define BUFF_SZ 256
648 	/* Avoid unnecessary overhead if debugfs is disabled */
649 	if (list_empty(&hdev->debug_list))
650 		return;
651 
652 	buff = kmalloc(BUFF_SZ, GFP_ATOMIC);
653 	if (!buff)
654 		return;
655 
656 	switch (report->id) {
657 	case REPORT_ERROR_CODE:
658 		/* 2 data bytes with affected report and error code */
659 		snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
660 			"REPORT_ERROR_CODE", report->id, size-1);
661 		hid_debug_event(hdev, buff);
662 		if (raw_data[2] < ARRAY_SIZE(error_codes))
663 			snprintf(buff, BUFF_SZ, "\tError code 0x%02x (%s) in reply to report 0x%02x\n",
664 					raw_data[2], error_codes[raw_data[2]], raw_data[1]);
665 		else
666 			snprintf(buff, BUFF_SZ, "\tError code 0x%02x in reply to report 0x%02x\n",
667 					raw_data[2], raw_data[1]);
668 		hid_debug_event(hdev, buff);
669 		break;
670 	case REPORT_KEY_STATE:
671 		/* 2 data bytes with key state */
672 		snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
673 			"REPORT_KEY_STATE", report->id, size-1);
674 		hid_debug_event(hdev, buff);
675 		if (raw_data[1] == 0)
676 			snprintf(buff, BUFF_SZ, "\tNo key pressed\n");
677 		else if (raw_data[2] == 0)
678 			snprintf(buff, BUFF_SZ, "\tOne key pressed: 0x%02x (%d)\n",
679 					raw_data[1], raw_data[1]);
680 		else
681 			snprintf(buff, BUFF_SZ, "\tTwo keys pressed: 0x%02x (%d), 0x%02x (%d)\n",
682 					raw_data[1], raw_data[1], raw_data[2], raw_data[2]);
683 		hid_debug_event(hdev, buff);
684 		break;
685 	case REPORT_IR_DATA:
686 		/* Up to 20 byes of IR scancode data */
687 		snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
688 			"REPORT_IR_DATA", report->id, size-1);
689 		hid_debug_event(hdev, buff);
690 		if (raw_data[1] == 0) {
691 			snprintf(buff, BUFF_SZ, "\tUnexpectedly 0 data length\n");
692 			hid_debug_event(hdev, buff);
693 		} else if (raw_data[1] + 1 <= size) {
694 			snprintf(buff, BUFF_SZ, "\tData length: %d\n\tIR Data: ",
695 					raw_data[1]);
696 			hid_debug_event(hdev, buff);
697 			dump_buff_as_hex(buff, BUFF_SZ, raw_data+2, raw_data[1]);
698 			hid_debug_event(hdev, buff);
699 		} else {
700 			snprintf(buff, BUFF_SZ, "\tOverflowing data length: %d\n",
701 					raw_data[1]-1);
702 			hid_debug_event(hdev, buff);
703 		}
704 		break;
705 	case REPORT_EE_DATA:
706 		/* Data buffer in response to REPORT_EE_READ or REPORT_EE_WRITE */
707 		snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
708 			"REPORT_EE_DATA", report->id, size-1);
709 		hid_debug_event(hdev, buff);
710 		snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n",
711 				raw_data[2], raw_data[1]);
712 		hid_debug_event(hdev, buff);
713 		snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);
714 		hid_debug_event(hdev, buff);
715 		if (raw_data[3] == 0) {
716 			snprintf(buff, BUFF_SZ, "\tNo data\n");
717 			hid_debug_event(hdev, buff);
718 		} else if (raw_data[3] + 4 <= size) {
719 			snprintf(buff, BUFF_SZ, "\tData: ");
720 			hid_debug_event(hdev, buff);
721 			dump_buff_as_hex(buff, BUFF_SZ, raw_data+4, raw_data[3]);
722 			hid_debug_event(hdev, buff);
723 		} else {
724 			snprintf(buff, BUFF_SZ, "\tData overflowed\n");
725 			hid_debug_event(hdev, buff);
726 		}
727 		break;
728 	case REPORT_MEMORY:
729 		/* Data buffer in response to REPORT_READ_MEMORY or REPORT_WRITE_MEMORY */
730 		snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
731 			"REPORT_MEMORY", report->id, size-1);
732 		hid_debug_event(hdev, buff);
733 		switch (data->addr_sz) {
734 		case 2:
735 			snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n",
736 					raw_data[2], raw_data[1]);
737 			hid_debug_event(hdev, buff);
738 			snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);
739 			hid_debug_event(hdev, buff);
740 			if (raw_data[3] == 0) {
741 				snprintf(buff, BUFF_SZ, "\tNo data\n");
742 			} else if (raw_data[3] + 4 <= size) {
743 				snprintf(buff, BUFF_SZ, "\tData: ");
744 				hid_debug_event(hdev, buff);
745 				dump_buff_as_hex(buff, BUFF_SZ, raw_data+4, raw_data[3]);
746 			} else {
747 				snprintf(buff, BUFF_SZ, "\tData overflowed\n");
748 			}
749 			break;
750 		case 3:
751 			snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x%02x\n",
752 					raw_data[3], raw_data[2], raw_data[1]);
753 			hid_debug_event(hdev, buff);
754 			snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[4]);
755 			hid_debug_event(hdev, buff);
756 			if (raw_data[4] == 0) {
757 				snprintf(buff, BUFF_SZ, "\tNo data\n");
758 			} else if (raw_data[4] + 5 <= size) {
759 				snprintf(buff, BUFF_SZ, "\tData: ");
760 				hid_debug_event(hdev, buff);
761 				dump_buff_as_hex(buff, BUFF_SZ, raw_data+5, raw_data[4]);
762 			} else {
763 				snprintf(buff, BUFF_SZ, "\tData overflowed\n");
764 			}
765 			break;
766 		default:
767 			snprintf(buff, BUFF_SZ, "\tNot supported\n");
768 		}
769 		hid_debug_event(hdev, buff);
770 		break;
771 	case REPORT_VERSION:
772 		snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
773 			"REPORT_VERSION", report->id, size-1);
774 		hid_debug_event(hdev, buff);
775 		snprintf(buff, BUFF_SZ, "\tFirmware version: %d.%d\n",
776 				raw_data[2], raw_data[1]);
777 		hid_debug_event(hdev, buff);
778 		break;
779 	case REPORT_BL_ERASE_MEMORY:
780 		snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
781 			"REPORT_BL_ERASE_MEMORY", report->id, size-1);
782 		hid_debug_event(hdev, buff);
783 		/* TODO */
784 		break;
785 	case REPORT_BL_READ_MEMORY:
786 		snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
787 			"REPORT_BL_READ_MEMORY", report->id, size-1);
788 		hid_debug_event(hdev, buff);
789 		/* TODO */
790 		break;
791 	case REPORT_BL_WRITE_MEMORY:
792 		snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
793 			"REPORT_BL_WRITE_MEMORY", report->id, size-1);
794 		hid_debug_event(hdev, buff);
795 		/* TODO */
796 		break;
797 	case REPORT_DEVID:
798 		snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
799 			"REPORT_DEVID", report->id, size-1);
800 		hid_debug_event(hdev, buff);
801 		snprintf(buff, BUFF_SZ, "\tSerial: 0x%02x%02x%02x%02x\n",
802 				raw_data[1], raw_data[2], raw_data[3], raw_data[4]);
803 		hid_debug_event(hdev, buff);
804 		snprintf(buff, BUFF_SZ, "\tType: 0x%02x\n",
805 				raw_data[5]);
806 		hid_debug_event(hdev, buff);
807 		break;
808 	case REPORT_SPLASH_SIZE:
809 		snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
810 			"REPORT_SPLASH_SIZE", report->id, size-1);
811 		hid_debug_event(hdev, buff);
812 		snprintf(buff, BUFF_SZ, "\tTotal splash space: %d\n",
813 				(raw_data[2] << 8) | raw_data[1]);
814 		hid_debug_event(hdev, buff);
815 		snprintf(buff, BUFF_SZ, "\tUsed splash space: %d\n",
816 				(raw_data[4] << 8) | raw_data[3]);
817 		hid_debug_event(hdev, buff);
818 		break;
819 	case REPORT_HOOK_VERSION:
820 		snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
821 			"REPORT_HOOK_VERSION", report->id, size-1);
822 		hid_debug_event(hdev, buff);
823 		snprintf(buff, BUFF_SZ, "\tFirmware version: %d.%d\n",
824 				raw_data[1], raw_data[2]);
825 		hid_debug_event(hdev, buff);
826 		break;
827 	default:
828 		snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
829 			"<unknown>", report->id, size-1);
830 		hid_debug_event(hdev, buff);
831 		break;
832 	}
833 	wake_up_interruptible(&hdev->debug_wait);
834 	kfree(buff);
835 }
836 
837 void picolcd_init_devfs(struct picolcd_data *data,
838 		struct hid_report *eeprom_r, struct hid_report *eeprom_w,
839 		struct hid_report *flash_r, struct hid_report *flash_w,
840 		struct hid_report *reset)
841 {
842 	struct hid_device *hdev = data->hdev;
843 
844 	mutex_init(&data->mutex_flash);
845 
846 	/* reset */
847 	if (reset)
848 		data->debug_reset = debugfs_create_file("reset", 0600,
849 				hdev->debug_dir, data, &picolcd_debug_reset_fops);
850 
851 	/* eeprom */
852 	if (eeprom_r || eeprom_w)
853 		data->debug_eeprom = debugfs_create_file("eeprom",
854 			(eeprom_w ? S_IWUSR : 0) | (eeprom_r ? S_IRUSR : 0),
855 			hdev->debug_dir, data, &picolcd_debug_eeprom_fops);
856 
857 	/* flash */
858 	if (flash_r && flash_r->maxfield == 1 && flash_r->field[0]->report_size == 8)
859 		data->addr_sz = flash_r->field[0]->report_count - 1;
860 	else
861 		data->addr_sz = -1;
862 	if (data->addr_sz == 2 || data->addr_sz == 3) {
863 		data->debug_flash = debugfs_create_file("flash",
864 			(flash_w ? S_IWUSR : 0) | (flash_r ? S_IRUSR : 0),
865 			hdev->debug_dir, data, &picolcd_debug_flash_fops);
866 	} else if (flash_r || flash_w)
867 		hid_warn(hdev, "Unexpected FLASH access reports, please submit rdesc for review\n");
868 }
869 
870 void picolcd_exit_devfs(struct picolcd_data *data)
871 {
872 	struct dentry *dent;
873 
874 	dent = data->debug_reset;
875 	data->debug_reset = NULL;
876 	debugfs_remove(dent);
877 	dent = data->debug_eeprom;
878 	data->debug_eeprom = NULL;
879 	debugfs_remove(dent);
880 	dent = data->debug_flash;
881 	data->debug_flash = NULL;
882 	debugfs_remove(dent);
883 	mutex_destroy(&data->mutex_flash);
884 }
885 
886