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