1 /***************************************************************************
2 * Copyright (C) 2010-2012 by Bruno Prémont <bonbons@linux-vserver.org> *
4 * Based on Logitech G13 driver (v0.4) *
5 * Copyright (C) 2009 by Rick L. Vinyard, Jr. <rvinyard@cs.nmsu.edu> *
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. *
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. *
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 ***************************************************************************/
20 #include <linux/hid.h>
21 #include <linux/hid-debug.h>
22 #include "usbhid/usbhid.h"
23 #include <linux/usb.h>
26 #include <linux/seq_file.h>
27 #include <linux/debugfs.h>
29 #include <linux/module.h>
30 #include <linux/uaccess.h>
32 #include "hid-picolcd.h"
35 static int picolcd_debug_reset_show(struct seq_file
*f
, void *p
)
37 if (picolcd_fbinfo((struct picolcd_data
*)f
->private))
38 seq_printf(f
, "all fb\n");
40 seq_printf(f
, "all\n");
44 static int picolcd_debug_reset_open(struct inode
*inode
, struct file
*f
)
46 return single_open(f
, picolcd_debug_reset_show
, inode
->i_private
);
49 static ssize_t
picolcd_debug_reset_write(struct file
*f
, const char __user
*user_buf
,
50 size_t count
, loff_t
*ppos
)
52 struct picolcd_data
*data
= ((struct seq_file
*)f
->private_data
)->private;
54 size_t cnt
= min(count
, sizeof(buf
)-1);
55 if (copy_from_user(buf
, user_buf
, cnt
))
58 while (cnt
> 0 && (buf
[cnt
-1] == ' ' || buf
[cnt
-1] == '\n'))
61 if (strcmp(buf
, "all") == 0) {
62 picolcd_reset(data
->hdev
);
63 picolcd_fb_reset(data
, 1);
64 } else if (strcmp(buf
, "fb") == 0) {
65 picolcd_fb_reset(data
, 1);
72 static const struct file_operations picolcd_debug_reset_fops
= {
74 .open
= picolcd_debug_reset_open
,
77 .write
= picolcd_debug_reset_write
,
78 .release
= single_release
,
84 static ssize_t
picolcd_debug_eeprom_read(struct file
*f
, char __user
*u
,
85 size_t s
, loff_t
*off
)
87 struct picolcd_data
*data
= f
->private_data
;
88 struct picolcd_pending
*resp
;
97 /* prepare buffer with info about what we want to read (addr & len) */
98 raw_data
[0] = *off
& 0xff;
99 raw_data
[1] = (*off
>> 8) & 0xff;
100 raw_data
[2] = s
< 20 ? s
: 20;
101 if (*off
+ raw_data
[2] > 0xff)
102 raw_data
[2] = 0x100 - *off
;
103 resp
= picolcd_send_and_wait(data
->hdev
, REPORT_EE_READ
, raw_data
,
108 if (resp
->in_report
&& resp
->in_report
->id
== REPORT_EE_DATA
) {
109 /* successful read :) */
110 ret
= resp
->raw_data
[2];
113 if (copy_to_user(u
, resp
->raw_data
+3, ret
))
117 } /* anything else is some kind of IO error */
123 static ssize_t
picolcd_debug_eeprom_write(struct file
*f
, const char __user
*u
,
124 size_t s
, loff_t
*off
)
126 struct picolcd_data
*data
= f
->private_data
;
127 struct picolcd_pending
*resp
;
136 memset(raw_data
, 0, sizeof(raw_data
));
137 raw_data
[0] = *off
& 0xff;
138 raw_data
[1] = (*off
>> 8) & 0xff;
139 raw_data
[2] = min_t(size_t, 20, s
);
140 if (*off
+ raw_data
[2] > 0xff)
141 raw_data
[2] = 0x100 - *off
;
143 if (copy_from_user(raw_data
+3, u
, min((u8
)20, raw_data
[2])))
145 resp
= picolcd_send_and_wait(data
->hdev
, REPORT_EE_WRITE
, raw_data
,
151 if (resp
->in_report
&& resp
->in_report
->id
== REPORT_EE_DATA
) {
152 /* check if written data matches */
153 if (memcmp(raw_data
, resp
->raw_data
, 3+raw_data
[2]) == 0) {
164 * - read/write happens in chunks of at most 20 bytes, it's up to userspace
165 * to loop in order to get more data.
166 * - on write errors on otherwise correct write request the bytes
167 * that should have been written are in undefined state.
169 static const struct file_operations picolcd_debug_eeprom_fops
= {
170 .owner
= THIS_MODULE
,
172 .read
= picolcd_debug_eeprom_read
,
173 .write
= picolcd_debug_eeprom_write
,
174 .llseek
= generic_file_llseek
,
180 /* record a flash address to buf (bounds check to be done by caller) */
181 static int _picolcd_flash_setaddr(struct picolcd_data
*data
, u8
*buf
, long off
)
184 buf
[1] = (off
>> 8) & 0xff;
185 if (data
->addr_sz
== 3)
186 buf
[2] = (off
>> 16) & 0xff;
187 return data
->addr_sz
== 2 ? 2 : 3;
190 /* read a given size of data (bounds check to be done by caller) */
191 static ssize_t
_picolcd_flash_read(struct picolcd_data
*data
, int report_id
,
192 char __user
*u
, size_t s
, loff_t
*off
)
194 struct picolcd_pending
*resp
;
197 int len_off
, err
= -EIO
;
201 len_off
= _picolcd_flash_setaddr(data
, raw_data
, *off
);
202 raw_data
[len_off
] = s
> 32 ? 32 : s
;
203 resp
= picolcd_send_and_wait(data
->hdev
, report_id
, raw_data
, len_off
+1);
204 if (!resp
|| !resp
->in_report
)
206 if (resp
->in_report
->id
== REPORT_MEMORY
||
207 resp
->in_report
->id
== REPORT_BL_READ_MEMORY
) {
208 if (memcmp(raw_data
, resp
->raw_data
, len_off
+1) != 0)
210 if (copy_to_user(u
+ret
, resp
->raw_data
+len_off
+1, raw_data
[len_off
])) {
214 *off
+= raw_data
[len_off
];
215 s
-= raw_data
[len_off
];
216 ret
+= raw_data
[len_off
];
222 return ret
> 0 ? ret
: err
;
227 static ssize_t
picolcd_debug_flash_read(struct file
*f
, char __user
*u
,
228 size_t s
, loff_t
*off
)
230 struct picolcd_data
*data
= f
->private_data
;
236 if (*off
+ s
> 0x05fff)
239 if (data
->status
& PICOLCD_BOOTLOADER
)
240 return _picolcd_flash_read(data
, REPORT_BL_READ_MEMORY
, u
, s
, off
);
242 return _picolcd_flash_read(data
, REPORT_READ_MEMORY
, u
, s
, off
);
245 /* erase block aligned to 64bytes boundary */
246 static ssize_t
_picolcd_flash_erase64(struct picolcd_data
*data
, int report_id
,
249 struct picolcd_pending
*resp
;
257 len_off
= _picolcd_flash_setaddr(data
, raw_data
, *off
);
258 resp
= picolcd_send_and_wait(data
->hdev
, report_id
, raw_data
, len_off
);
259 if (!resp
|| !resp
->in_report
)
261 if (resp
->in_report
->id
== REPORT_MEMORY
||
262 resp
->in_report
->id
== REPORT_BL_ERASE_MEMORY
) {
263 if (memcmp(raw_data
, resp
->raw_data
, len_off
) != 0)
272 /* write a given size of data (bounds check to be done by caller) */
273 static ssize_t
_picolcd_flash_write(struct picolcd_data
*data
, int report_id
,
274 const char __user
*u
, size_t s
, loff_t
*off
)
276 struct picolcd_pending
*resp
;
279 int len_off
, err
= -EIO
;
283 len_off
= _picolcd_flash_setaddr(data
, raw_data
, *off
);
284 raw_data
[len_off
] = s
> 32 ? 32 : s
;
285 if (copy_from_user(raw_data
+len_off
+1, u
, raw_data
[len_off
])) {
289 resp
= picolcd_send_and_wait(data
->hdev
, report_id
, raw_data
,
290 len_off
+1+raw_data
[len_off
]);
291 if (!resp
|| !resp
->in_report
)
293 if (resp
->in_report
->id
== REPORT_MEMORY
||
294 resp
->in_report
->id
== REPORT_BL_WRITE_MEMORY
) {
295 if (memcmp(raw_data
, resp
->raw_data
, len_off
+1+raw_data
[len_off
]) != 0)
297 *off
+= raw_data
[len_off
];
298 s
-= raw_data
[len_off
];
299 ret
+= raw_data
[len_off
];
307 return ret
> 0 ? ret
: err
;
310 static ssize_t
picolcd_debug_flash_write(struct file
*f
, const char __user
*u
,
311 size_t s
, loff_t
*off
)
313 struct picolcd_data
*data
= f
->private_data
;
314 ssize_t err
, ret
= 0;
315 int report_erase
, report_write
;
326 if (data
->status
& PICOLCD_BOOTLOADER
) {
327 report_erase
= REPORT_BL_ERASE_MEMORY
;
328 report_write
= REPORT_BL_WRITE_MEMORY
;
330 report_erase
= REPORT_ERASE_MEMORY
;
331 report_write
= REPORT_WRITE_MEMORY
;
333 mutex_lock(&data
->mutex_flash
);
335 err
= _picolcd_flash_erase64(data
, report_erase
, off
);
338 err
= _picolcd_flash_write(data
, report_write
, u
, 64, off
);
347 mutex_unlock(&data
->mutex_flash
);
348 return ret
> 0 ? ret
: err
;
353 * - concurrent writing is prevented by mutex and all writes must be
354 * n*64 bytes and 64-byte aligned, each write being preceded by an
355 * ERASE which erases a 64byte block.
356 * If less than requested was written or an error is returned for an
357 * otherwise correct write request the next 64-byte block which should
358 * have been written is in undefined state (mostly: original, erased,
359 * (half-)written with write error)
360 * - reading can happen without special restriction
362 static const struct file_operations picolcd_debug_flash_fops
= {
363 .owner
= THIS_MODULE
,
365 .read
= picolcd_debug_flash_read
,
366 .write
= picolcd_debug_flash_write
,
367 .llseek
= generic_file_llseek
,
372 * Helper code for HID report level dumping/debugging
374 static const char * const error_codes
[] = {
375 "success", "parameter missing", "data_missing", "block readonly",
376 "block not erasable", "block too big", "section overflow",
377 "invalid command length", "invalid data length",
380 static void dump_buff_as_hex(char *dst
, size_t dst_sz
, const u8
*data
,
381 const size_t data_len
)
384 for (i
= j
= 0; i
< data_len
&& j
+ 4 < dst_sz
; i
++) {
385 dst
[j
++] = hex_asc
[(data
[i
] >> 4) & 0x0f];
386 dst
[j
++] = hex_asc
[data
[i
] & 0x0f];
392 if (i
< data_len
&& j
> 2)
393 dst
[j
-2] = dst
[j
-3] = '.';
396 void picolcd_debug_out_report(struct picolcd_data
*data
,
397 struct hid_device
*hdev
, struct hid_report
*report
)
400 int raw_size
= (report
->size
>> 3) + 1;
404 /* Avoid unnecessary overhead if debugfs is disabled */
405 if (list_empty(&hdev
->debug_list
))
408 buff
= kmalloc(BUFF_SZ
, GFP_ATOMIC
);
412 snprintf(buff
, BUFF_SZ
, "\nout report %d (size %d) = ",
413 report
->id
, raw_size
);
414 hid_debug_event(hdev
, buff
);
415 if (raw_size
+ 5 > sizeof(raw_data
)) {
417 hid_debug_event(hdev
, " TOO BIG\n");
420 raw_data
[0] = report
->id
;
421 hid_output_report(report
, raw_data
);
422 dump_buff_as_hex(buff
, BUFF_SZ
, raw_data
, raw_size
);
423 hid_debug_event(hdev
, buff
);
426 switch (report
->id
) {
427 case REPORT_LED_STATE
:
428 /* 1 data byte with GPO state */
429 snprintf(buff
, BUFF_SZ
, "out report %s (%d, size=%d)\n",
430 "REPORT_LED_STATE", report
->id
, raw_size
-1);
431 hid_debug_event(hdev
, buff
);
432 snprintf(buff
, BUFF_SZ
, "\tGPO state: 0x%02x\n", raw_data
[1]);
433 hid_debug_event(hdev
, buff
);
435 case REPORT_BRIGHTNESS
:
436 /* 1 data byte with brightness */
437 snprintf(buff
, BUFF_SZ
, "out report %s (%d, size=%d)\n",
438 "REPORT_BRIGHTNESS", report
->id
, raw_size
-1);
439 hid_debug_event(hdev
, buff
);
440 snprintf(buff
, BUFF_SZ
, "\tBrightness: 0x%02x\n", raw_data
[1]);
441 hid_debug_event(hdev
, buff
);
443 case REPORT_CONTRAST
:
444 /* 1 data byte with contrast */
445 snprintf(buff
, BUFF_SZ
, "out report %s (%d, size=%d)\n",
446 "REPORT_CONTRAST", report
->id
, raw_size
-1);
447 hid_debug_event(hdev
, buff
);
448 snprintf(buff
, BUFF_SZ
, "\tContrast: 0x%02x\n", raw_data
[1]);
449 hid_debug_event(hdev
, buff
);
452 /* 2 data bytes with reset duration in ms */
453 snprintf(buff
, BUFF_SZ
, "out report %s (%d, size=%d)\n",
454 "REPORT_RESET", report
->id
, raw_size
-1);
455 hid_debug_event(hdev
, buff
);
456 snprintf(buff
, BUFF_SZ
, "\tDuration: 0x%02x%02x (%dms)\n",
457 raw_data
[2], raw_data
[1], raw_data
[2] << 8 | raw_data
[1]);
458 hid_debug_event(hdev
, buff
);
461 /* 63 data bytes with LCD commands */
462 snprintf(buff
, BUFF_SZ
, "out report %s (%d, size=%d)\n",
463 "REPORT_LCD_CMD", report
->id
, raw_size
-1);
464 hid_debug_event(hdev
, buff
);
465 /* TODO: format decoding */
467 case REPORT_LCD_DATA
:
468 /* 63 data bytes with LCD data */
469 snprintf(buff
, BUFF_SZ
, "out report %s (%d, size=%d)\n",
470 "REPORT_LCD_CMD", report
->id
, raw_size
-1);
471 /* TODO: format decoding */
472 hid_debug_event(hdev
, buff
);
474 case REPORT_LCD_CMD_DATA
:
475 /* 63 data bytes with LCD commands and data */
476 snprintf(buff
, BUFF_SZ
, "out report %s (%d, size=%d)\n",
477 "REPORT_LCD_CMD", report
->id
, raw_size
-1);
478 /* TODO: format decoding */
479 hid_debug_event(hdev
, buff
);
482 /* 3 data bytes with read area description */
483 snprintf(buff
, BUFF_SZ
, "out report %s (%d, size=%d)\n",
484 "REPORT_EE_READ", report
->id
, raw_size
-1);
485 hid_debug_event(hdev
, buff
);
486 snprintf(buff
, BUFF_SZ
, "\tData address: 0x%02x%02x\n",
487 raw_data
[2], raw_data
[1]);
488 hid_debug_event(hdev
, buff
);
489 snprintf(buff
, BUFF_SZ
, "\tData length: %d\n", raw_data
[3]);
490 hid_debug_event(hdev
, buff
);
492 case REPORT_EE_WRITE
:
493 /* 3+1..20 data bytes with write area description */
494 snprintf(buff
, BUFF_SZ
, "out report %s (%d, size=%d)\n",
495 "REPORT_EE_WRITE", report
->id
, raw_size
-1);
496 hid_debug_event(hdev
, buff
);
497 snprintf(buff
, BUFF_SZ
, "\tData address: 0x%02x%02x\n",
498 raw_data
[2], raw_data
[1]);
499 hid_debug_event(hdev
, buff
);
500 snprintf(buff
, BUFF_SZ
, "\tData length: %d\n", raw_data
[3]);
501 hid_debug_event(hdev
, buff
);
502 if (raw_data
[3] == 0) {
503 snprintf(buff
, BUFF_SZ
, "\tNo data\n");
504 } else if (raw_data
[3] + 4 <= raw_size
) {
505 snprintf(buff
, BUFF_SZ
, "\tData: ");
506 hid_debug_event(hdev
, buff
);
507 dump_buff_as_hex(buff
, BUFF_SZ
, raw_data
+4, raw_data
[3]);
509 snprintf(buff
, BUFF_SZ
, "\tData overflowed\n");
511 hid_debug_event(hdev
, buff
);
513 case REPORT_ERASE_MEMORY
:
514 case REPORT_BL_ERASE_MEMORY
:
515 /* 3 data bytes with pointer inside erase block */
516 snprintf(buff
, BUFF_SZ
, "out report %s (%d, size=%d)\n",
517 "REPORT_ERASE_MEMORY", report
->id
, raw_size
-1);
518 hid_debug_event(hdev
, buff
);
519 switch (data
->addr_sz
) {
521 snprintf(buff
, BUFF_SZ
, "\tAddress inside 64 byte block: 0x%02x%02x\n",
522 raw_data
[2], raw_data
[1]);
525 snprintf(buff
, BUFF_SZ
, "\tAddress inside 64 byte block: 0x%02x%02x%02x\n",
526 raw_data
[3], raw_data
[2], raw_data
[1]);
529 snprintf(buff
, BUFF_SZ
, "\tNot supported\n");
531 hid_debug_event(hdev
, buff
);
533 case REPORT_READ_MEMORY
:
534 case REPORT_BL_READ_MEMORY
:
535 /* 4 data bytes with read area description */
536 snprintf(buff
, BUFF_SZ
, "out report %s (%d, size=%d)\n",
537 "REPORT_READ_MEMORY", report
->id
, raw_size
-1);
538 hid_debug_event(hdev
, buff
);
539 switch (data
->addr_sz
) {
541 snprintf(buff
, BUFF_SZ
, "\tData address: 0x%02x%02x\n",
542 raw_data
[2], raw_data
[1]);
543 hid_debug_event(hdev
, buff
);
544 snprintf(buff
, BUFF_SZ
, "\tData length: %d\n", raw_data
[3]);
547 snprintf(buff
, BUFF_SZ
, "\tData address: 0x%02x%02x%02x\n",
548 raw_data
[3], raw_data
[2], raw_data
[1]);
549 hid_debug_event(hdev
, buff
);
550 snprintf(buff
, BUFF_SZ
, "\tData length: %d\n", raw_data
[4]);
553 snprintf(buff
, BUFF_SZ
, "\tNot supported\n");
555 hid_debug_event(hdev
, buff
);
557 case REPORT_WRITE_MEMORY
:
558 case REPORT_BL_WRITE_MEMORY
:
559 /* 4+1..32 data bytes with write adrea description */
560 snprintf(buff
, BUFF_SZ
, "out report %s (%d, size=%d)\n",
561 "REPORT_WRITE_MEMORY", report
->id
, raw_size
-1);
562 hid_debug_event(hdev
, buff
);
563 switch (data
->addr_sz
) {
565 snprintf(buff
, BUFF_SZ
, "\tData address: 0x%02x%02x\n",
566 raw_data
[2], raw_data
[1]);
567 hid_debug_event(hdev
, buff
);
568 snprintf(buff
, BUFF_SZ
, "\tData length: %d\n", raw_data
[3]);
569 hid_debug_event(hdev
, buff
);
570 if (raw_data
[3] == 0) {
571 snprintf(buff
, BUFF_SZ
, "\tNo data\n");
572 } else if (raw_data
[3] + 4 <= raw_size
) {
573 snprintf(buff
, BUFF_SZ
, "\tData: ");
574 hid_debug_event(hdev
, buff
);
575 dump_buff_as_hex(buff
, BUFF_SZ
, raw_data
+4, raw_data
[3]);
577 snprintf(buff
, BUFF_SZ
, "\tData overflowed\n");
581 snprintf(buff
, BUFF_SZ
, "\tData address: 0x%02x%02x%02x\n",
582 raw_data
[3], raw_data
[2], raw_data
[1]);
583 hid_debug_event(hdev
, buff
);
584 snprintf(buff
, BUFF_SZ
, "\tData length: %d\n", raw_data
[4]);
585 hid_debug_event(hdev
, buff
);
586 if (raw_data
[4] == 0) {
587 snprintf(buff
, BUFF_SZ
, "\tNo data\n");
588 } else if (raw_data
[4] + 5 <= raw_size
) {
589 snprintf(buff
, BUFF_SZ
, "\tData: ");
590 hid_debug_event(hdev
, buff
);
591 dump_buff_as_hex(buff
, BUFF_SZ
, raw_data
+5, raw_data
[4]);
593 snprintf(buff
, BUFF_SZ
, "\tData overflowed\n");
597 snprintf(buff
, BUFF_SZ
, "\tNot supported\n");
599 hid_debug_event(hdev
, buff
);
601 case REPORT_SPLASH_RESTART
:
604 case REPORT_EXIT_KEYBOARD
:
605 snprintf(buff
, BUFF_SZ
, "out report %s (%d, size=%d)\n",
606 "REPORT_EXIT_KEYBOARD", report
->id
, raw_size
-1);
607 hid_debug_event(hdev
, buff
);
608 snprintf(buff
, BUFF_SZ
, "\tRestart delay: %dms (0x%02x%02x)\n",
609 raw_data
[1] | (raw_data
[2] << 8),
610 raw_data
[2], raw_data
[1]);
611 hid_debug_event(hdev
, buff
);
614 snprintf(buff
, BUFF_SZ
, "out report %s (%d, size=%d)\n",
615 "REPORT_VERSION", report
->id
, raw_size
-1);
616 hid_debug_event(hdev
, buff
);
619 snprintf(buff
, BUFF_SZ
, "out report %s (%d, size=%d)\n",
620 "REPORT_DEVID", report
->id
, raw_size
-1);
621 hid_debug_event(hdev
, buff
);
623 case REPORT_SPLASH_SIZE
:
624 snprintf(buff
, BUFF_SZ
, "out report %s (%d, size=%d)\n",
625 "REPORT_SPLASH_SIZE", report
->id
, raw_size
-1);
626 hid_debug_event(hdev
, buff
);
628 case REPORT_HOOK_VERSION
:
629 snprintf(buff
, BUFF_SZ
, "out report %s (%d, size=%d)\n",
630 "REPORT_HOOK_VERSION", report
->id
, raw_size
-1);
631 hid_debug_event(hdev
, buff
);
633 case REPORT_EXIT_FLASHER
:
634 snprintf(buff
, BUFF_SZ
, "out report %s (%d, size=%d)\n",
635 "REPORT_VERSION", report
->id
, raw_size
-1);
636 hid_debug_event(hdev
, buff
);
637 snprintf(buff
, BUFF_SZ
, "\tRestart delay: %dms (0x%02x%02x)\n",
638 raw_data
[1] | (raw_data
[2] << 8),
639 raw_data
[2], raw_data
[1]);
640 hid_debug_event(hdev
, buff
);
643 snprintf(buff
, BUFF_SZ
, "out report %s (%d, size=%d)\n",
644 "<unknown>", report
->id
, raw_size
-1);
645 hid_debug_event(hdev
, buff
);
648 wake_up_interruptible(&hdev
->debug_wait
);
652 void picolcd_debug_raw_event(struct picolcd_data
*data
,
653 struct hid_device
*hdev
, struct hid_report
*report
,
654 u8
*raw_data
, int size
)
659 /* Avoid unnecessary overhead if debugfs is disabled */
660 if (list_empty(&hdev
->debug_list
))
663 buff
= kmalloc(BUFF_SZ
, GFP_ATOMIC
);
667 switch (report
->id
) {
668 case REPORT_ERROR_CODE
:
669 /* 2 data bytes with affected report and error code */
670 snprintf(buff
, BUFF_SZ
, "report %s (%d, size=%d)\n",
671 "REPORT_ERROR_CODE", report
->id
, size
-1);
672 hid_debug_event(hdev
, buff
);
673 if (raw_data
[2] < ARRAY_SIZE(error_codes
))
674 snprintf(buff
, BUFF_SZ
, "\tError code 0x%02x (%s) in reply to report 0x%02x\n",
675 raw_data
[2], error_codes
[raw_data
[2]], raw_data
[1]);
677 snprintf(buff
, BUFF_SZ
, "\tError code 0x%02x in reply to report 0x%02x\n",
678 raw_data
[2], raw_data
[1]);
679 hid_debug_event(hdev
, buff
);
681 case REPORT_KEY_STATE
:
682 /* 2 data bytes with key state */
683 snprintf(buff
, BUFF_SZ
, "report %s (%d, size=%d)\n",
684 "REPORT_KEY_STATE", report
->id
, size
-1);
685 hid_debug_event(hdev
, buff
);
686 if (raw_data
[1] == 0)
687 snprintf(buff
, BUFF_SZ
, "\tNo key pressed\n");
688 else if (raw_data
[2] == 0)
689 snprintf(buff
, BUFF_SZ
, "\tOne key pressed: 0x%02x (%d)\n",
690 raw_data
[1], raw_data
[1]);
692 snprintf(buff
, BUFF_SZ
, "\tTwo keys pressed: 0x%02x (%d), 0x%02x (%d)\n",
693 raw_data
[1], raw_data
[1], raw_data
[2], raw_data
[2]);
694 hid_debug_event(hdev
, buff
);
697 /* Up to 20 byes of IR scancode data */
698 snprintf(buff
, BUFF_SZ
, "report %s (%d, size=%d)\n",
699 "REPORT_IR_DATA", report
->id
, size
-1);
700 hid_debug_event(hdev
, buff
);
701 if (raw_data
[1] == 0) {
702 snprintf(buff
, BUFF_SZ
, "\tUnexpectedly 0 data length\n");
703 hid_debug_event(hdev
, buff
);
704 } else if (raw_data
[1] + 1 <= size
) {
705 snprintf(buff
, BUFF_SZ
, "\tData length: %d\n\tIR Data: ",
707 hid_debug_event(hdev
, buff
);
708 dump_buff_as_hex(buff
, BUFF_SZ
, raw_data
+2, raw_data
[1]);
709 hid_debug_event(hdev
, buff
);
711 snprintf(buff
, BUFF_SZ
, "\tOverflowing data length: %d\n",
713 hid_debug_event(hdev
, buff
);
717 /* Data buffer in response to REPORT_EE_READ or REPORT_EE_WRITE */
718 snprintf(buff
, BUFF_SZ
, "report %s (%d, size=%d)\n",
719 "REPORT_EE_DATA", report
->id
, size
-1);
720 hid_debug_event(hdev
, buff
);
721 snprintf(buff
, BUFF_SZ
, "\tData address: 0x%02x%02x\n",
722 raw_data
[2], raw_data
[1]);
723 hid_debug_event(hdev
, buff
);
724 snprintf(buff
, BUFF_SZ
, "\tData length: %d\n", raw_data
[3]);
725 hid_debug_event(hdev
, buff
);
726 if (raw_data
[3] == 0) {
727 snprintf(buff
, BUFF_SZ
, "\tNo data\n");
728 hid_debug_event(hdev
, buff
);
729 } else if (raw_data
[3] + 4 <= size
) {
730 snprintf(buff
, BUFF_SZ
, "\tData: ");
731 hid_debug_event(hdev
, buff
);
732 dump_buff_as_hex(buff
, BUFF_SZ
, raw_data
+4, raw_data
[3]);
733 hid_debug_event(hdev
, buff
);
735 snprintf(buff
, BUFF_SZ
, "\tData overflowed\n");
736 hid_debug_event(hdev
, buff
);
740 /* Data buffer in response to REPORT_READ_MEMORY or REPORT_WRTIE_MEMORY */
741 snprintf(buff
, BUFF_SZ
, "report %s (%d, size=%d)\n",
742 "REPORT_MEMORY", report
->id
, size
-1);
743 hid_debug_event(hdev
, buff
);
744 switch (data
->addr_sz
) {
746 snprintf(buff
, BUFF_SZ
, "\tData address: 0x%02x%02x\n",
747 raw_data
[2], raw_data
[1]);
748 hid_debug_event(hdev
, buff
);
749 snprintf(buff
, BUFF_SZ
, "\tData length: %d\n", raw_data
[3]);
750 hid_debug_event(hdev
, buff
);
751 if (raw_data
[3] == 0) {
752 snprintf(buff
, BUFF_SZ
, "\tNo data\n");
753 } else if (raw_data
[3] + 4 <= size
) {
754 snprintf(buff
, BUFF_SZ
, "\tData: ");
755 hid_debug_event(hdev
, buff
);
756 dump_buff_as_hex(buff
, BUFF_SZ
, raw_data
+4, raw_data
[3]);
758 snprintf(buff
, BUFF_SZ
, "\tData overflowed\n");
762 snprintf(buff
, BUFF_SZ
, "\tData address: 0x%02x%02x%02x\n",
763 raw_data
[3], raw_data
[2], raw_data
[1]);
764 hid_debug_event(hdev
, buff
);
765 snprintf(buff
, BUFF_SZ
, "\tData length: %d\n", raw_data
[4]);
766 hid_debug_event(hdev
, buff
);
767 if (raw_data
[4] == 0) {
768 snprintf(buff
, BUFF_SZ
, "\tNo data\n");
769 } else if (raw_data
[4] + 5 <= size
) {
770 snprintf(buff
, BUFF_SZ
, "\tData: ");
771 hid_debug_event(hdev
, buff
);
772 dump_buff_as_hex(buff
, BUFF_SZ
, raw_data
+5, raw_data
[4]);
774 snprintf(buff
, BUFF_SZ
, "\tData overflowed\n");
778 snprintf(buff
, BUFF_SZ
, "\tNot supported\n");
780 hid_debug_event(hdev
, buff
);
783 snprintf(buff
, BUFF_SZ
, "report %s (%d, size=%d)\n",
784 "REPORT_VERSION", report
->id
, size
-1);
785 hid_debug_event(hdev
, buff
);
786 snprintf(buff
, BUFF_SZ
, "\tFirmware version: %d.%d\n",
787 raw_data
[2], raw_data
[1]);
788 hid_debug_event(hdev
, buff
);
790 case REPORT_BL_ERASE_MEMORY
:
791 snprintf(buff
, BUFF_SZ
, "report %s (%d, size=%d)\n",
792 "REPORT_BL_ERASE_MEMORY", report
->id
, size
-1);
793 hid_debug_event(hdev
, buff
);
796 case REPORT_BL_READ_MEMORY
:
797 snprintf(buff
, BUFF_SZ
, "report %s (%d, size=%d)\n",
798 "REPORT_BL_READ_MEMORY", report
->id
, size
-1);
799 hid_debug_event(hdev
, buff
);
802 case REPORT_BL_WRITE_MEMORY
:
803 snprintf(buff
, BUFF_SZ
, "report %s (%d, size=%d)\n",
804 "REPORT_BL_WRITE_MEMORY", report
->id
, size
-1);
805 hid_debug_event(hdev
, buff
);
809 snprintf(buff
, BUFF_SZ
, "report %s (%d, size=%d)\n",
810 "REPORT_DEVID", report
->id
, size
-1);
811 hid_debug_event(hdev
, buff
);
812 snprintf(buff
, BUFF_SZ
, "\tSerial: 0x%02x%02x%02x%02x\n",
813 raw_data
[1], raw_data
[2], raw_data
[3], raw_data
[4]);
814 hid_debug_event(hdev
, buff
);
815 snprintf(buff
, BUFF_SZ
, "\tType: 0x%02x\n",
817 hid_debug_event(hdev
, buff
);
819 case REPORT_SPLASH_SIZE
:
820 snprintf(buff
, BUFF_SZ
, "report %s (%d, size=%d)\n",
821 "REPORT_SPLASH_SIZE", report
->id
, size
-1);
822 hid_debug_event(hdev
, buff
);
823 snprintf(buff
, BUFF_SZ
, "\tTotal splash space: %d\n",
824 (raw_data
[2] << 8) | raw_data
[1]);
825 hid_debug_event(hdev
, buff
);
826 snprintf(buff
, BUFF_SZ
, "\tUsed splash space: %d\n",
827 (raw_data
[4] << 8) | raw_data
[3]);
828 hid_debug_event(hdev
, buff
);
830 case REPORT_HOOK_VERSION
:
831 snprintf(buff
, BUFF_SZ
, "report %s (%d, size=%d)\n",
832 "REPORT_HOOK_VERSION", report
->id
, size
-1);
833 hid_debug_event(hdev
, buff
);
834 snprintf(buff
, BUFF_SZ
, "\tFirmware version: %d.%d\n",
835 raw_data
[1], raw_data
[2]);
836 hid_debug_event(hdev
, buff
);
839 snprintf(buff
, BUFF_SZ
, "report %s (%d, size=%d)\n",
840 "<unknown>", report
->id
, size
-1);
841 hid_debug_event(hdev
, buff
);
844 wake_up_interruptible(&hdev
->debug_wait
);
848 void picolcd_init_devfs(struct picolcd_data
*data
,
849 struct hid_report
*eeprom_r
, struct hid_report
*eeprom_w
,
850 struct hid_report
*flash_r
, struct hid_report
*flash_w
,
851 struct hid_report
*reset
)
853 struct hid_device
*hdev
= data
->hdev
;
855 mutex_init(&data
->mutex_flash
);
859 data
->debug_reset
= debugfs_create_file("reset", 0600,
860 hdev
->debug_dir
, data
, &picolcd_debug_reset_fops
);
863 if (eeprom_r
|| eeprom_w
)
864 data
->debug_eeprom
= debugfs_create_file("eeprom",
865 (eeprom_w
? S_IWUSR
: 0) | (eeprom_r
? S_IRUSR
: 0),
866 hdev
->debug_dir
, data
, &picolcd_debug_eeprom_fops
);
869 if (flash_r
&& flash_r
->maxfield
== 1 && flash_r
->field
[0]->report_size
== 8)
870 data
->addr_sz
= flash_r
->field
[0]->report_count
- 1;
873 if (data
->addr_sz
== 2 || data
->addr_sz
== 3) {
874 data
->debug_flash
= debugfs_create_file("flash",
875 (flash_w
? S_IWUSR
: 0) | (flash_r
? S_IRUSR
: 0),
876 hdev
->debug_dir
, data
, &picolcd_debug_flash_fops
);
877 } else if (flash_r
|| flash_w
)
878 hid_warn(hdev
, "Unexpected FLASH access reports, please submit rdesc for review\n");
881 void picolcd_exit_devfs(struct picolcd_data
*data
)
885 dent
= data
->debug_reset
;
886 data
->debug_reset
= NULL
;
888 debugfs_remove(dent
);
889 dent
= data
->debug_eeprom
;
890 data
->debug_eeprom
= NULL
;
892 debugfs_remove(dent
);
893 dent
= data
->debug_flash
;
894 data
->debug_flash
= NULL
;
896 debugfs_remove(dent
);
897 mutex_destroy(&data
->mutex_flash
);