projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/gerg/m68knommu
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / hid / hid-picolcd_debugfs.c
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[70];
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 snprintf(buff, BUFF_SZ, "\nout report %d (size %d) = ",
411 report->id, raw_size);
412 hid_debug_event(hdev, buff);
413 if (raw_size + 5 > sizeof(raw_data)) {
414 kfree(buff);
415 hid_debug_event(hdev, " TOO BIG\n");
416 return;
417 } else {
418 raw_data[0] = report->id;
419 hid_output_report(report, raw_data);
420 dump_buff_as_hex(buff, BUFF_SZ, raw_data, raw_size);
421 hid_debug_event(hdev, buff);
422 }
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(buff);
648 }
649
650 void picolcd_debug_raw_event(struct picolcd_data *data,
651 struct hid_device *hdev, struct hid_report *report,
652 u8 *raw_data, int size)
653 {
654 char *buff;
655
656 #define BUFF_SZ 256
657 /* Avoid unnecessary overhead if debugfs is disabled */
658 if (list_empty(&hdev->debug_list))
659 return;
660
661 buff = kmalloc(BUFF_SZ, GFP_ATOMIC);
662 if (!buff)
663 return;
664
665 switch (report->id) {
666 case REPORT_ERROR_CODE:
667 /* 2 data bytes with affected report and error code */
668 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
669 "REPORT_ERROR_CODE", report->id, size-1);
670 hid_debug_event(hdev, buff);
671 if (raw_data[2] < ARRAY_SIZE(error_codes))
672 snprintf(buff, BUFF_SZ, "\tError code 0x%02x (%s) in reply to report 0x%02x\n",
673 raw_data[2], error_codes[raw_data[2]], raw_data[1]);
674 else
675 snprintf(buff, BUFF_SZ, "\tError code 0x%02x in reply to report 0x%02x\n",
676 raw_data[2], raw_data[1]);
677 hid_debug_event(hdev, buff);
678 break;
679 case REPORT_KEY_STATE:
680 /* 2 data bytes with key state */
681 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
682 "REPORT_KEY_STATE", report->id, size-1);
683 hid_debug_event(hdev, buff);
684 if (raw_data[1] == 0)
685 snprintf(buff, BUFF_SZ, "\tNo key pressed\n");
686 else if (raw_data[2] == 0)
687 snprintf(buff, BUFF_SZ, "\tOne key pressed: 0x%02x (%d)\n",
688 raw_data[1], raw_data[1]);
689 else
690 snprintf(buff, BUFF_SZ, "\tTwo keys pressed: 0x%02x (%d), 0x%02x (%d)\n",
691 raw_data[1], raw_data[1], raw_data[2], raw_data[2]);
692 hid_debug_event(hdev, buff);
693 break;
694 case REPORT_IR_DATA:
695 /* Up to 20 byes of IR scancode data */
696 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
697 "REPORT_IR_DATA", report->id, size-1);
698 hid_debug_event(hdev, buff);
699 if (raw_data[1] == 0) {
700 snprintf(buff, BUFF_SZ, "\tUnexpectedly 0 data length\n");
701 hid_debug_event(hdev, buff);
702 } else if (raw_data[1] + 1 <= size) {
703 snprintf(buff, BUFF_SZ, "\tData length: %d\n\tIR Data: ",
704 raw_data[1]);
705 hid_debug_event(hdev, buff);
706 dump_buff_as_hex(buff, BUFF_SZ, raw_data+2, raw_data[1]);
707 hid_debug_event(hdev, buff);
708 } else {
709 snprintf(buff, BUFF_SZ, "\tOverflowing data length: %d\n",
710 raw_data[1]-1);
711 hid_debug_event(hdev, buff);
712 }
713 break;
714 case REPORT_EE_DATA:
715 /* Data buffer in response to REPORT_EE_READ or REPORT_EE_WRITE */
716 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
717 "REPORT_EE_DATA", report->id, size-1);
718 hid_debug_event(hdev, buff);
719 snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n",
720 raw_data[2], raw_data[1]);
721 hid_debug_event(hdev, buff);
722 snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);
723 hid_debug_event(hdev, buff);
724 if (raw_data[3] == 0) {
725 snprintf(buff, BUFF_SZ, "\tNo data\n");
726 hid_debug_event(hdev, buff);
727 } else if (raw_data[3] + 4 <= size) {
728 snprintf(buff, BUFF_SZ, "\tData: ");
729 hid_debug_event(hdev, buff);
730 dump_buff_as_hex(buff, BUFF_SZ, raw_data+4, raw_data[3]);
731 hid_debug_event(hdev, buff);
732 } else {
733 snprintf(buff, BUFF_SZ, "\tData overflowed\n");
734 hid_debug_event(hdev, buff);
735 }
736 break;
737 case REPORT_MEMORY:
738 /* Data buffer in response to REPORT_READ_MEMORY or REPORT_WRTIE_MEMORY */
739 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
740 "REPORT_MEMORY", report->id, size-1);
741 hid_debug_event(hdev, buff);
742 switch (data->addr_sz) {
743 case 2:
744 snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n",
745 raw_data[2], raw_data[1]);
746 hid_debug_event(hdev, buff);
747 snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);
748 hid_debug_event(hdev, buff);
749 if (raw_data[3] == 0) {
750 snprintf(buff, BUFF_SZ, "\tNo data\n");
751 } else if (raw_data[3] + 4 <= size) {
752 snprintf(buff, BUFF_SZ, "\tData: ");
753 hid_debug_event(hdev, buff);
754 dump_buff_as_hex(buff, BUFF_SZ, raw_data+4, raw_data[3]);
755 } else {
756 snprintf(buff, BUFF_SZ, "\tData overflowed\n");
757 }
758 break;
759 case 3:
760 snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x%02x\n",
761 raw_data[3], raw_data[2], raw_data[1]);
762 hid_debug_event(hdev, buff);
763 snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[4]);
764 hid_debug_event(hdev, buff);
765 if (raw_data[4] == 0) {
766 snprintf(buff, BUFF_SZ, "\tNo data\n");
767 } else if (raw_data[4] + 5 <= size) {
768 snprintf(buff, BUFF_SZ, "\tData: ");
769 hid_debug_event(hdev, buff);
770 dump_buff_as_hex(buff, BUFF_SZ, raw_data+5, raw_data[4]);
771 } else {
772 snprintf(buff, BUFF_SZ, "\tData overflowed\n");
773 }
774 break;
775 default:
776 snprintf(buff, BUFF_SZ, "\tNot supported\n");
777 }
778 hid_debug_event(hdev, buff);
779 break;
780 case REPORT_VERSION:
781 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
782 "REPORT_VERSION", report->id, size-1);
783 hid_debug_event(hdev, buff);
784 snprintf(buff, BUFF_SZ, "\tFirmware version: %d.%d\n",
785 raw_data[2], raw_data[1]);
786 hid_debug_event(hdev, buff);
787 break;
788 case REPORT_BL_ERASE_MEMORY:
789 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
790 "REPORT_BL_ERASE_MEMORY", report->id, size-1);
791 hid_debug_event(hdev, buff);
792 /* TODO */
793 break;
794 case REPORT_BL_READ_MEMORY:
795 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
796 "REPORT_BL_READ_MEMORY", report->id, size-1);
797 hid_debug_event(hdev, buff);
798 /* TODO */
799 break;
800 case REPORT_BL_WRITE_MEMORY:
801 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
802 "REPORT_BL_WRITE_MEMORY", report->id, size-1);
803 hid_debug_event(hdev, buff);
804 /* TODO */
805 break;
806 case REPORT_DEVID:
807 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
808 "REPORT_DEVID", report->id, size-1);
809 hid_debug_event(hdev, buff);
810 snprintf(buff, BUFF_SZ, "\tSerial: 0x%02x%02x%02x%02x\n",
811 raw_data[1], raw_data[2], raw_data[3], raw_data[4]);
812 hid_debug_event(hdev, buff);
813 snprintf(buff, BUFF_SZ, "\tType: 0x%02x\n",
814 raw_data[5]);
815 hid_debug_event(hdev, buff);
816 break;
817 case REPORT_SPLASH_SIZE:
818 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
819 "REPORT_SPLASH_SIZE", report->id, size-1);
820 hid_debug_event(hdev, buff);
821 snprintf(buff, BUFF_SZ, "\tTotal splash space: %d\n",
822 (raw_data[2] << 8) | raw_data[1]);
823 hid_debug_event(hdev, buff);
824 snprintf(buff, BUFF_SZ, "\tUsed splash space: %d\n",
825 (raw_data[4] << 8) | raw_data[3]);
826 hid_debug_event(hdev, buff);
827 break;
828 case REPORT_HOOK_VERSION:
829 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
830 "REPORT_HOOK_VERSION", report->id, size-1);
831 hid_debug_event(hdev, buff);
832 snprintf(buff, BUFF_SZ, "\tFirmware version: %d.%d\n",
833 raw_data[1], raw_data[2]);
834 hid_debug_event(hdev, buff);
835 break;
836 default:
837 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
838 "<unknown>", report->id, size-1);
839 hid_debug_event(hdev, buff);
840 break;
841 }
842 wake_up_interruptible(&hdev->debug_wait);
843 kfree(buff);
844 }
845
846 void picolcd_init_devfs(struct picolcd_data *data,
847 struct hid_report *eeprom_r, struct hid_report *eeprom_w,
848 struct hid_report *flash_r, struct hid_report *flash_w,
849 struct hid_report *reset)
850 {
851 struct hid_device *hdev = data->hdev;
852
853 mutex_init(&data->mutex_flash);
854
855 /* reset */
856 if (reset)
857 data->debug_reset = debugfs_create_file("reset", 0600,
858 hdev->debug_dir, data, &picolcd_debug_reset_fops);
859
860 /* eeprom */
861 if (eeprom_r || eeprom_w)
862 data->debug_eeprom = debugfs_create_file("eeprom",
863 (eeprom_w ? S_IWUSR : 0) | (eeprom_r ? S_IRUSR : 0),
864 hdev->debug_dir, data, &picolcd_debug_eeprom_fops);
865
866 /* flash */
867 if (flash_r && flash_r->maxfield == 1 && flash_r->field[0]->report_size == 8)
868 data->addr_sz = flash_r->field[0]->report_count - 1;
869 else
870 data->addr_sz = -1;
871 if (data->addr_sz == 2 || data->addr_sz == 3) {
872 data->debug_flash = debugfs_create_file("flash",
873 (flash_w ? S_IWUSR : 0) | (flash_r ? S_IRUSR : 0),
874 hdev->debug_dir, data, &picolcd_debug_flash_fops);
875 } else if (flash_r || flash_w)
876 hid_warn(hdev, "Unexpected FLASH access reports, please submit rdesc for review\n");
877 }
878
879 void picolcd_exit_devfs(struct picolcd_data *data)
880 {
881 struct dentry *dent;
882
883 dent = data->debug_reset;
884 data->debug_reset = NULL;
885 if (dent)
886 debugfs_remove(dent);
887 dent = data->debug_eeprom;
888 data->debug_eeprom = NULL;
889 if (dent)
890 debugfs_remove(dent);
891 dent = data->debug_flash;
892 data->debug_flash = NULL;
893 if (dent)
894 debugfs_remove(dent);
895 mutex_destroy(&data->mutex_flash);
896 }
897
kernel source for telekom puls (alcatel/mediatek)