1 /***************************************************************************
2 * Copyright (C) 2010 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 <linux/input.h>
24 #include "usbhid/usbhid.h"
25 #include <linux/usb.h>
27 #include <linux/seq_file.h>
28 #include <linux/debugfs.h>
30 #include <linux/completion.h>
32 #define PICOLCD_NAME "PicoLCD (graphic)"
35 #define REPORT_ERROR_CODE 0x10 /* LCD: IN[16] */
36 #define ERR_SUCCESS 0x00
37 #define ERR_PARAMETER_MISSING 0x01
38 #define ERR_DATA_MISSING 0x02
39 #define ERR_BLOCK_READ_ONLY 0x03
40 #define ERR_BLOCK_NOT_ERASABLE 0x04
41 #define ERR_BLOCK_TOO_BIG 0x05
42 #define ERR_SECTION_OVERFLOW 0x06
43 #define ERR_INVALID_CMD_LEN 0x07
44 #define ERR_INVALID_DATA_LEN 0x08
45 #define REPORT_KEY_STATE 0x11 /* LCD: IN[2] */
46 #define REPORT_IR_DATA 0x21 /* LCD: IN[63] */
47 #define REPORT_EE_DATA 0x32 /* LCD: IN[63] */
48 #define REPORT_MEMORY 0x41 /* LCD: IN[63] */
49 #define REPORT_LED_STATE 0x81 /* LCD: OUT[1] */
50 #define REPORT_BRIGHTNESS 0x91 /* LCD: OUT[1] */
51 #define REPORT_CONTRAST 0x92 /* LCD: OUT[1] */
52 #define REPORT_RESET 0x93 /* LCD: OUT[2] */
53 #define REPORT_LCD_CMD 0x94 /* LCD: OUT[63] */
54 #define REPORT_LCD_DATA 0x95 /* LCD: OUT[63] */
55 #define REPORT_LCD_CMD_DATA 0x96 /* LCD: OUT[63] */
56 #define REPORT_EE_READ 0xa3 /* LCD: OUT[63] */
57 #define REPORT_EE_WRITE 0xa4 /* LCD: OUT[63] */
58 #define REPORT_ERASE_MEMORY 0xb2 /* LCD: OUT[2] */
59 #define REPORT_READ_MEMORY 0xb3 /* LCD: OUT[3] */
60 #define REPORT_WRITE_MEMORY 0xb4 /* LCD: OUT[63] */
61 #define REPORT_SPLASH_RESTART 0xc1 /* LCD: OUT[1] */
62 #define REPORT_EXIT_KEYBOARD 0xef /* LCD: OUT[2] */
63 #define REPORT_VERSION 0xf1 /* LCD: IN[2],OUT[1] Bootloader: IN[2],OUT[1] */
64 #define REPORT_BL_ERASE_MEMORY 0xf2 /* Bootloader: IN[36],OUT[4] */
65 #define REPORT_BL_READ_MEMORY 0xf3 /* Bootloader: IN[36],OUT[4] */
66 #define REPORT_BL_WRITE_MEMORY 0xf4 /* Bootloader: IN[36],OUT[36] */
67 #define REPORT_DEVID 0xf5 /* LCD: IN[5], OUT[1] Bootloader: IN[5],OUT[1] */
68 #define REPORT_SPLASH_SIZE 0xf6 /* LCD: IN[4], OUT[1] */
69 #define REPORT_HOOK_VERSION 0xf7 /* LCD: IN[2], OUT[1] */
70 #define REPORT_EXIT_FLASHER 0xff /* Bootloader: OUT[2] */
74 * The PicoLCD has an IR receiver header, a built-in keypad with 5 keys
75 * and header for 4x4 key matrix. The built-in keys are part of the matrix.
77 static const unsigned short def_keymap[] = {
78 KEY_RESERVED, /* none */
79 KEY_BACK, /* col 4 + row 1 */
80 KEY_HOMEPAGE, /* col 3 + row 1 */
81 KEY_RESERVED, /* col 2 + row 1 */
82 KEY_RESERVED, /* col 1 + row 1 */
83 KEY_SCROLLUP, /* col 4 + row 2 */
84 KEY_OK, /* col 3 + row 2 */
85 KEY_SCROLLDOWN, /* col 2 + row 2 */
86 KEY_RESERVED, /* col 1 + row 2 */
87 KEY_RESERVED, /* col 4 + row 3 */
88 KEY_RESERVED, /* col 3 + row 3 */
89 KEY_RESERVED, /* col 2 + row 3 */
90 KEY_RESERVED, /* col 1 + row 3 */
91 KEY_RESERVED, /* col 4 + row 4 */
92 KEY_RESERVED, /* col 3 + row 4 */
93 KEY_RESERVED, /* col 2 + row 4 */
94 KEY_RESERVED, /* col 1 + row 4 */
96 #define PICOLCD_KEYS ARRAY_SIZE(def_keymap)
98 /* Description of in-progress IO operation, used for operations
99 * that trigger response from device */
100 struct picolcd_pending {
101 struct hid_report *out_report;
102 struct hid_report *in_report;
103 struct completion ready;
108 /* Per device data structure */
109 struct picolcd_data {
110 struct hid_device *hdev;
111 #ifdef CONFIG_DEBUG_FS
117 struct input_dev *input_keys;
118 struct input_dev *input_cir;
119 unsigned short keycode[PICOLCD_KEYS];
121 /* Housekeeping stuff */
124 struct picolcd_pending *pending;
126 #define PICOLCD_BOOTLOADER 1
127 #define PICOLCD_FAILED 2
131 /* Find a given report */
132 #define picolcd_in_report(id, dev) picolcd_report(id, dev, HID_INPUT_REPORT)
133 #define picolcd_out_report(id, dev) picolcd_report(id, dev, HID_OUTPUT_REPORT)
135 static struct hid_report *picolcd_report(int id, struct hid_device *hdev, int dir)
137 struct list_head *feature_report_list = &hdev->report_enum[dir].report_list;
138 struct hid_report *report = NULL;
140 list_for_each_entry(report, feature_report_list, list) {
141 if (report->id == id)
144 dev_warn(&hdev->dev, "No report with id 0x%x found\n", id);
148 #ifdef CONFIG_DEBUG_FS
149 static void picolcd_debug_out_report(struct picolcd_data *data,
150 struct hid_device *hdev, struct hid_report *report);
151 #define usbhid_submit_report(a, b, c) \
153 picolcd_debug_out_report(hid_get_drvdata(a), a, b); \
154 usbhid_submit_report(a, b, c); \
158 /* Submit a report and wait for a reply from device - if device fades away
159 * or does not respond in time, return NULL */
160 static struct picolcd_pending *picolcd_send_and_wait(struct hid_device *hdev,
161 int report_id, const u8 *raw_data, int size)
163 struct picolcd_data *data = hid_get_drvdata(hdev);
164 struct picolcd_pending *work;
165 struct hid_report *report = picolcd_out_report(report_id, hdev);
169 if (!report || !data)
171 if (data->status & PICOLCD_FAILED)
173 work = kzalloc(sizeof(*work), GFP_KERNEL);
177 init_completion(&work->ready);
178 work->out_report = report;
179 work->in_report = NULL;
182 mutex_lock(&data->mutex);
183 spin_lock_irqsave(&data->lock, flags);
184 for (i = k = 0; i < report->maxfield; i++)
185 for (j = 0; j < report->field[i]->report_count; j++) {
186 hid_set_field(report->field[i], j, k < size ? raw_data[k] : 0);
189 data->pending = work;
190 usbhid_submit_report(data->hdev, report, USB_DIR_OUT);
191 spin_unlock_irqrestore(&data->lock, flags);
192 wait_for_completion_interruptible_timeout(&work->ready, HZ*2);
193 spin_lock_irqsave(&data->lock, flags);
194 data->pending = NULL;
195 spin_unlock_irqrestore(&data->lock, flags);
196 mutex_unlock(&data->mutex);
203 static int picolcd_raw_keypad(struct picolcd_data *data,
204 struct hid_report *report, u8 *raw_data, int size)
208 * First and second data bytes list currently pressed keys,
209 * 0x00 means no key and at most 2 keys may be pressed at same time
213 /* determine newly pressed keys */
214 for (i = 0; i < size; i++) {
215 unsigned int key_code;
216 if (raw_data[i] == 0)
218 for (j = 0; j < sizeof(data->pressed_keys); j++)
219 if (data->pressed_keys[j] == raw_data[i])
220 goto key_already_down;
221 for (j = 0; j < sizeof(data->pressed_keys); j++)
222 if (data->pressed_keys[j] == 0) {
223 data->pressed_keys[j] = raw_data[i];
226 input_event(data->input_keys, EV_MSC, MSC_SCAN, raw_data[i]);
227 if (raw_data[i] < PICOLCD_KEYS)
228 key_code = data->keycode[raw_data[i]];
230 key_code = KEY_UNKNOWN;
231 if (key_code != KEY_UNKNOWN) {
232 dbg_hid(PICOLCD_NAME " got key press for %u:%d",
233 raw_data[i], key_code);
234 input_report_key(data->input_keys, key_code, 1);
236 input_sync(data->input_keys);
241 /* determine newly released keys */
242 for (j = 0; j < sizeof(data->pressed_keys); j++) {
243 unsigned int key_code;
244 if (data->pressed_keys[j] == 0)
246 for (i = 0; i < size; i++)
247 if (data->pressed_keys[j] == raw_data[i])
249 input_event(data->input_keys, EV_MSC, MSC_SCAN, data->pressed_keys[j]);
250 if (data->pressed_keys[j] < PICOLCD_KEYS)
251 key_code = data->keycode[data->pressed_keys[j]];
253 key_code = KEY_UNKNOWN;
254 if (key_code != KEY_UNKNOWN) {
255 dbg_hid(PICOLCD_NAME " got key release for %u:%d",
256 data->pressed_keys[j], key_code);
257 input_report_key(data->input_keys, key_code, 0);
259 input_sync(data->input_keys);
260 data->pressed_keys[j] = 0;
267 static int picolcd_raw_cir(struct picolcd_data *data,
268 struct hid_report *report, u8 *raw_data, int size)
270 /* Need understanding of CIR data format to implement ... */
274 static int picolcd_check_version(struct hid_device *hdev)
276 struct picolcd_data *data = hid_get_drvdata(hdev);
277 struct picolcd_pending *verinfo;
283 verinfo = picolcd_send_and_wait(hdev, REPORT_VERSION, NULL, 0);
285 dev_err(&hdev->dev, "no version response from PicoLCD");
289 if (verinfo->raw_size == 2) {
290 if (data->status & PICOLCD_BOOTLOADER) {
291 dev_info(&hdev->dev, "PicoLCD, bootloader version %d.%d\n",
292 verinfo->raw_data[0], verinfo->raw_data[1]);
293 data->version[0] = verinfo->raw_data[0];
294 data->version[1] = verinfo->raw_data[1];
296 dev_info(&hdev->dev, "PicoLCD, firmware version %d.%d\n",
297 verinfo->raw_data[1], verinfo->raw_data[0]);
298 data->version[0] = verinfo->raw_data[1];
299 data->version[1] = verinfo->raw_data[0];
302 dev_err(&hdev->dev, "confused, got unexpected version response from PicoLCD\n");
310 * Reset our device and wait for answer to VERSION request
312 static int picolcd_reset(struct hid_device *hdev)
314 struct picolcd_data *data = hid_get_drvdata(hdev);
315 struct hid_report *report = picolcd_out_report(REPORT_RESET, hdev);
318 if (!data || !report || report->maxfield != 1)
321 spin_lock_irqsave(&data->lock, flags);
322 if (hdev->product == USB_DEVICE_ID_PICOLCD_BOOTLOADER)
323 data->status |= PICOLCD_BOOTLOADER;
325 /* perform the reset */
326 hid_set_field(report->field[0], 0, 1);
327 usbhid_submit_report(hdev, report, USB_DIR_OUT);
328 spin_unlock_irqrestore(&data->lock, flags);
330 return picolcd_check_version(hdev);
334 * The "operation_mode" sysfs attribute
336 static ssize_t picolcd_operation_mode_show(struct device *dev,
337 struct device_attribute *attr, char *buf)
339 struct picolcd_data *data = dev_get_drvdata(dev);
341 if (data->status & PICOLCD_BOOTLOADER)
342 return snprintf(buf, PAGE_SIZE, "[bootloader] lcd\n");
344 return snprintf(buf, PAGE_SIZE, "bootloader [lcd]\n");
347 static ssize_t picolcd_operation_mode_store(struct device *dev,
348 struct device_attribute *attr, const char *buf, size_t count)
350 struct picolcd_data *data = dev_get_drvdata(dev);
351 struct hid_report *report = NULL;
357 if (cnt >= 3 && strncmp("lcd", buf, 3) == 0) {
358 if (data->status & PICOLCD_BOOTLOADER)
359 report = picolcd_out_report(REPORT_EXIT_FLASHER, data->hdev);
362 } else if (cnt >= 10 && strncmp("bootloader", buf, 10) == 0) {
363 if (!(data->status & PICOLCD_BOOTLOADER))
364 report = picolcd_out_report(REPORT_EXIT_KEYBOARD, data->hdev);
371 while (cnt > 0 && (*buf == ' ' || *buf == '\t')) {
375 while (cnt > 0 && (buf[cnt-1] == '\n' || buf[cnt-1] == '\r'))
378 if (sscanf(buf, "%u", &u) != 1)
386 spin_lock_irqsave(&data->lock, flags);
387 hid_set_field(report->field[0], 0, timeout & 0xff);
388 hid_set_field(report->field[0], 1, (timeout >> 8) & 0xff);
389 usbhid_submit_report(data->hdev, report, USB_DIR_OUT);
390 spin_unlock_irqrestore(&data->lock, flags);
394 static DEVICE_ATTR(operation_mode, 0644, picolcd_operation_mode_show,
395 picolcd_operation_mode_store);
398 #ifdef CONFIG_DEBUG_FS
400 * Helper code for HID report level dumping/debugging
402 static const char *error_codes[] = {
403 "success", "parameter missing", "data_missing", "block readonly",
404 "block not erasable", "block too big", "section overflow",
405 "invalid command length", "invalid data length",
408 static void dump_buff_as_hex(char *dst, size_t dst_sz, const u8 *data,
409 const size_t data_len)
412 for (i = j = 0; i < data_len && j + 3 < dst_sz; i++) {
413 dst[j++] = hex_asc[(data[i] >> 4) & 0x0f];
414 dst[j++] = hex_asc[data[i] & 0x0f];
424 static void picolcd_debug_out_report(struct picolcd_data *data,
425 struct hid_device *hdev, struct hid_report *report)
428 int raw_size = (report->size >> 3) + 1;
432 /* Avoid unnecessary overhead if debugfs is disabled */
433 if (!hdev->debug_events)
436 buff = kmalloc(BUFF_SZ, GFP_ATOMIC);
440 snprintf(buff, BUFF_SZ, "\nout report %d (size %d) = ",
441 report->id, raw_size);
442 hid_debug_event(hdev, buff);
443 if (raw_size + 5 > sizeof(raw_data)) {
444 hid_debug_event(hdev, " TOO BIG\n");
447 raw_data[0] = report->id;
448 hid_output_report(report, raw_data);
449 dump_buff_as_hex(buff, BUFF_SZ, raw_data, raw_size);
450 hid_debug_event(hdev, buff);
453 switch (report->id) {
454 case REPORT_LED_STATE:
455 /* 1 data byte with GPO state */
456 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
457 "REPORT_LED_STATE", report->id, raw_size-1);
458 hid_debug_event(hdev, buff);
459 snprintf(buff, BUFF_SZ, "\tGPO state: 0x%02x\n", raw_data[1]);
460 hid_debug_event(hdev, buff);
462 case REPORT_BRIGHTNESS:
463 /* 1 data byte with brightness */
464 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
465 "REPORT_BRIGHTNESS", report->id, raw_size-1);
466 hid_debug_event(hdev, buff);
467 snprintf(buff, BUFF_SZ, "\tBrightness: 0x%02x\n", raw_data[1]);
468 hid_debug_event(hdev, buff);
470 case REPORT_CONTRAST:
471 /* 1 data byte with contrast */
472 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
473 "REPORT_CONTRAST", report->id, raw_size-1);
474 hid_debug_event(hdev, buff);
475 snprintf(buff, BUFF_SZ, "\tContrast: 0x%02x\n", raw_data[1]);
476 hid_debug_event(hdev, buff);
479 /* 2 data bytes with reset duration in ms */
480 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
481 "REPORT_RESET", report->id, raw_size-1);
482 hid_debug_event(hdev, buff);
483 snprintf(buff, BUFF_SZ, "\tDuration: 0x%02x%02x (%dms)\n",
484 raw_data[2], raw_data[1], raw_data[2] << 8 | raw_data[1]);
485 hid_debug_event(hdev, buff);
488 /* 63 data bytes with LCD commands */
489 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
490 "REPORT_LCD_CMD", report->id, raw_size-1);
491 hid_debug_event(hdev, buff);
492 /* TODO: format decoding */
494 case REPORT_LCD_DATA:
495 /* 63 data bytes with LCD data */
496 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
497 "REPORT_LCD_CMD", report->id, raw_size-1);
498 /* TODO: format decoding */
499 hid_debug_event(hdev, buff);
501 case REPORT_LCD_CMD_DATA:
502 /* 63 data bytes with LCD commands and data */
503 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
504 "REPORT_LCD_CMD", report->id, raw_size-1);
505 /* TODO: format decoding */
506 hid_debug_event(hdev, buff);
509 /* 3 data bytes with read area description */
510 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
511 "REPORT_EE_READ", report->id, raw_size-1);
512 hid_debug_event(hdev, buff);
513 snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n",
514 raw_data[2], raw_data[1]);
515 hid_debug_event(hdev, buff);
516 snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);
517 hid_debug_event(hdev, buff);
519 case REPORT_EE_WRITE:
520 /* 3+1..20 data bytes with write area description */
521 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
522 "REPORT_EE_WRITE", report->id, raw_size-1);
523 hid_debug_event(hdev, buff);
524 snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n",
525 raw_data[2], raw_data[1]);
526 hid_debug_event(hdev, buff);
527 snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);
528 hid_debug_event(hdev, buff);
529 if (raw_data[3] == 0) {
530 snprintf(buff, BUFF_SZ, "\tNo data\n");
531 } else if (raw_data[3] + 4 <= raw_size) {
532 snprintf(buff, BUFF_SZ, "\tData: ");
533 hid_debug_event(hdev, buff);
534 dump_buff_as_hex(buff, BUFF_SZ, raw_data+4, raw_data[3]);
536 snprintf(buff, BUFF_SZ, "\tData overflowed\n");
538 hid_debug_event(hdev, buff);
540 case REPORT_ERASE_MEMORY:
541 case REPORT_BL_ERASE_MEMORY:
542 /* 3 data bytes with pointer inside erase block */
543 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
544 "REPORT_ERASE_MEMORY", report->id, raw_size-1);
545 hid_debug_event(hdev, buff);
546 switch (data->addr_sz) {
548 snprintf(buff, BUFF_SZ, "\tAddress inside 64 byte block: 0x%02x%02x\n",
549 raw_data[2], raw_data[1]);
552 snprintf(buff, BUFF_SZ, "\tAddress inside 64 byte block: 0x%02x%02x%02x\n",
553 raw_data[3], raw_data[2], raw_data[1]);
556 snprintf(buff, BUFF_SZ, "\tNot supported\n");
558 hid_debug_event(hdev, buff);
560 case REPORT_READ_MEMORY:
561 case REPORT_BL_READ_MEMORY:
562 /* 4 data bytes with read area description */
563 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
564 "REPORT_READ_MEMORY", report->id, raw_size-1);
565 hid_debug_event(hdev, buff);
566 switch (data->addr_sz) {
568 snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n",
569 raw_data[2], raw_data[1]);
570 hid_debug_event(hdev, buff);
571 snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);
574 snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x%02x\n",
575 raw_data[3], raw_data[2], raw_data[1]);
576 hid_debug_event(hdev, buff);
577 snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[4]);
580 snprintf(buff, BUFF_SZ, "\tNot supported\n");
582 hid_debug_event(hdev, buff);
584 case REPORT_WRITE_MEMORY:
585 case REPORT_BL_WRITE_MEMORY:
586 /* 4+1..32 data bytes with write adrea description */
587 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
588 "REPORT_WRITE_MEMORY", report->id, raw_size-1);
589 hid_debug_event(hdev, buff);
590 switch (data->addr_sz) {
592 snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n",
593 raw_data[2], raw_data[1]);
594 hid_debug_event(hdev, buff);
595 snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);
596 hid_debug_event(hdev, buff);
597 if (raw_data[3] == 0) {
598 snprintf(buff, BUFF_SZ, "\tNo data\n");
599 } else if (raw_data[3] + 4 <= raw_size) {
600 snprintf(buff, BUFF_SZ, "\tData: ");
601 hid_debug_event(hdev, buff);
602 dump_buff_as_hex(buff, BUFF_SZ, raw_data+4, raw_data[3]);
604 snprintf(buff, BUFF_SZ, "\tData overflowed\n");
608 snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x%02x\n",
609 raw_data[3], raw_data[2], raw_data[1]);
610 hid_debug_event(hdev, buff);
611 snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[4]);
612 hid_debug_event(hdev, buff);
613 if (raw_data[4] == 0) {
614 snprintf(buff, BUFF_SZ, "\tNo data\n");
615 } else if (raw_data[4] + 5 <= raw_size) {
616 snprintf(buff, BUFF_SZ, "\tData: ");
617 hid_debug_event(hdev, buff);
618 dump_buff_as_hex(buff, BUFF_SZ, raw_data+5, raw_data[4]);
620 snprintf(buff, BUFF_SZ, "\tData overflowed\n");
624 snprintf(buff, BUFF_SZ, "\tNot supported\n");
626 hid_debug_event(hdev, buff);
628 case REPORT_SPLASH_RESTART:
631 case REPORT_EXIT_KEYBOARD:
632 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
633 "REPORT_EXIT_KEYBOARD", 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);
641 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
642 "REPORT_VERSION", report->id, raw_size-1);
643 hid_debug_event(hdev, buff);
646 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
647 "REPORT_DEVID", report->id, raw_size-1);
648 hid_debug_event(hdev, buff);
650 case REPORT_SPLASH_SIZE:
651 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
652 "REPORT_SPLASH_SIZE", report->id, raw_size-1);
653 hid_debug_event(hdev, buff);
655 case REPORT_HOOK_VERSION:
656 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
657 "REPORT_HOOK_VERSION", report->id, raw_size-1);
658 hid_debug_event(hdev, buff);
660 case REPORT_EXIT_FLASHER:
661 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
662 "REPORT_VERSION", report->id, raw_size-1);
663 hid_debug_event(hdev, buff);
664 snprintf(buff, BUFF_SZ, "\tRestart delay: %dms (0x%02x%02x)\n",
665 raw_data[1] | (raw_data[2] << 8),
666 raw_data[2], raw_data[1]);
667 hid_debug_event(hdev, buff);
670 snprintf(buff, BUFF_SZ, "out report %s (%d, size=%d)\n",
671 "<unknown>", report->id, raw_size-1);
672 hid_debug_event(hdev, buff);
675 wake_up_interruptible(&hdev->debug_wait);
679 static void picolcd_debug_raw_event(struct picolcd_data *data,
680 struct hid_device *hdev, struct hid_report *report,
681 u8 *raw_data, int size)
686 /* Avoid unnecessary overhead if debugfs is disabled */
687 if (!hdev->debug_events)
690 buff = kmalloc(BUFF_SZ, GFP_ATOMIC);
694 switch (report->id) {
695 case REPORT_ERROR_CODE:
696 /* 2 data bytes with affected report and error code */
697 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
698 "REPORT_ERROR_CODE", report->id, size-1);
699 hid_debug_event(hdev, buff);
700 if (raw_data[2] < ARRAY_SIZE(error_codes))
701 snprintf(buff, BUFF_SZ, "\tError code 0x%02x (%s) in reply to report 0x%02x\n",
702 raw_data[2], error_codes[raw_data[2]], raw_data[1]);
704 snprintf(buff, BUFF_SZ, "\tError code 0x%02x in reply to report 0x%02x\n",
705 raw_data[2], raw_data[1]);
706 hid_debug_event(hdev, buff);
708 case REPORT_KEY_STATE:
709 /* 2 data bytes with key state */
710 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
711 "REPORT_KEY_STATE", report->id, size-1);
712 hid_debug_event(hdev, buff);
713 if (raw_data[1] == 0)
714 snprintf(buff, BUFF_SZ, "\tNo key pressed\n");
715 else if (raw_data[2] == 0)
716 snprintf(buff, BUFF_SZ, "\tOne key pressed: 0x%02x (%d)\n",
717 raw_data[1], raw_data[1]);
719 snprintf(buff, BUFF_SZ, "\tTwo keys pressed: 0x%02x (%d), 0x%02x (%d)\n",
720 raw_data[1], raw_data[1], raw_data[2], raw_data[2]);
721 hid_debug_event(hdev, buff);
724 /* Up to 20 byes of IR scancode data */
725 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
726 "REPORT_IR_DATA", report->id, size-1);
727 hid_debug_event(hdev, buff);
728 if (raw_data[1] == 0) {
729 snprintf(buff, BUFF_SZ, "\tUnexpectedly 0 data length\n");
730 hid_debug_event(hdev, buff);
731 } else if (raw_data[1] + 1 <= size) {
732 snprintf(buff, BUFF_SZ, "\tData length: %d\n\tIR Data: ",
734 hid_debug_event(hdev, buff);
735 dump_buff_as_hex(buff, BUFF_SZ, raw_data+2, raw_data[1]-1);
736 hid_debug_event(hdev, buff);
738 snprintf(buff, BUFF_SZ, "\tOverflowing data length: %d\n",
740 hid_debug_event(hdev, buff);
744 /* Data buffer in response to REPORT_EE_READ or REPORT_EE_WRITE */
745 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
746 "REPORT_EE_DATA", report->id, size-1);
747 hid_debug_event(hdev, buff);
748 snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n",
749 raw_data[2], raw_data[1]);
750 hid_debug_event(hdev, buff);
751 snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);
752 hid_debug_event(hdev, buff);
753 if (raw_data[3] == 0) {
754 snprintf(buff, BUFF_SZ, "\tNo data\n");
755 hid_debug_event(hdev, buff);
756 } else if (raw_data[3] + 4 <= size) {
757 snprintf(buff, BUFF_SZ, "\tData: ");
758 hid_debug_event(hdev, buff);
759 dump_buff_as_hex(buff, BUFF_SZ, raw_data+4, raw_data[3]);
760 hid_debug_event(hdev, buff);
762 snprintf(buff, BUFF_SZ, "\tData overflowed\n");
763 hid_debug_event(hdev, buff);
767 /* Data buffer in response to REPORT_READ_MEMORY or REPORT_WRTIE_MEMORY */
768 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
769 "REPORT_MEMORY", report->id, size-1);
770 hid_debug_event(hdev, buff);
771 switch (data->addr_sz) {
773 snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x\n",
774 raw_data[2], raw_data[1]);
775 hid_debug_event(hdev, buff);
776 snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[3]);
777 hid_debug_event(hdev, buff);
778 if (raw_data[3] == 0) {
779 snprintf(buff, BUFF_SZ, "\tNo data\n");
780 } else if (raw_data[3] + 4 <= size) {
781 snprintf(buff, BUFF_SZ, "\tData: ");
782 hid_debug_event(hdev, buff);
783 dump_buff_as_hex(buff, BUFF_SZ, raw_data+4, raw_data[3]);
785 snprintf(buff, BUFF_SZ, "\tData overflowed\n");
789 snprintf(buff, BUFF_SZ, "\tData address: 0x%02x%02x%02x\n",
790 raw_data[3], raw_data[2], raw_data[1]);
791 hid_debug_event(hdev, buff);
792 snprintf(buff, BUFF_SZ, "\tData length: %d\n", raw_data[4]);
793 hid_debug_event(hdev, buff);
794 if (raw_data[4] == 0) {
795 snprintf(buff, BUFF_SZ, "\tNo data\n");
796 } else if (raw_data[4] + 5 <= size) {
797 snprintf(buff, BUFF_SZ, "\tData: ");
798 hid_debug_event(hdev, buff);
799 dump_buff_as_hex(buff, BUFF_SZ, raw_data+5, raw_data[4]);
801 snprintf(buff, BUFF_SZ, "\tData overflowed\n");
805 snprintf(buff, BUFF_SZ, "\tNot supported\n");
807 hid_debug_event(hdev, buff);
810 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
811 "REPORT_VERSION", report->id, size-1);
812 hid_debug_event(hdev, buff);
813 snprintf(buff, BUFF_SZ, "\tFirmware version: %d.%d\n",
814 raw_data[2], raw_data[1]);
815 hid_debug_event(hdev, buff);
817 case REPORT_BL_ERASE_MEMORY:
818 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
819 "REPORT_BL_ERASE_MEMORY", report->id, size-1);
820 hid_debug_event(hdev, buff);
823 case REPORT_BL_READ_MEMORY:
824 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
825 "REPORT_BL_READ_MEMORY", report->id, size-1);
826 hid_debug_event(hdev, buff);
829 case REPORT_BL_WRITE_MEMORY:
830 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
831 "REPORT_BL_WRITE_MEMORY", report->id, size-1);
832 hid_debug_event(hdev, buff);
836 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
837 "REPORT_DEVID", report->id, size-1);
838 hid_debug_event(hdev, buff);
839 snprintf(buff, BUFF_SZ, "\tSerial: 0x%02x%02x%02x%02x\n",
840 raw_data[1], raw_data[2], raw_data[3], raw_data[4]);
841 hid_debug_event(hdev, buff);
842 snprintf(buff, BUFF_SZ, "\tType: 0x%02x\n",
844 hid_debug_event(hdev, buff);
846 case REPORT_SPLASH_SIZE:
847 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
848 "REPORT_SPLASH_SIZE", report->id, size-1);
849 hid_debug_event(hdev, buff);
850 snprintf(buff, BUFF_SZ, "\tTotal splash space: %d\n",
851 (raw_data[2] << 8) | raw_data[1]);
852 hid_debug_event(hdev, buff);
853 snprintf(buff, BUFF_SZ, "\tUsed splash space: %d\n",
854 (raw_data[4] << 8) | raw_data[3]);
855 hid_debug_event(hdev, buff);
857 case REPORT_HOOK_VERSION:
858 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
859 "REPORT_HOOK_VERSION", report->id, size-1);
860 hid_debug_event(hdev, buff);
861 snprintf(buff, BUFF_SZ, "\tFirmware version: %d.%d\n",
862 raw_data[1], raw_data[2]);
863 hid_debug_event(hdev, buff);
866 snprintf(buff, BUFF_SZ, "report %s (%d, size=%d)\n",
867 "<unknown>", report->id, size-1);
868 hid_debug_event(hdev, buff);
871 wake_up_interruptible(&hdev->debug_wait);
875 #define picolcd_debug_raw_event(data, hdev, report, raw_data, size)
879 * Handle raw report as sent by device
881 static int picolcd_raw_event(struct hid_device *hdev,
882 struct hid_report *report, u8 *raw_data, int size)
884 struct picolcd_data *data = hid_get_drvdata(hdev);
891 if (report->id == REPORT_KEY_STATE) {
892 if (data->input_keys)
893 ret = picolcd_raw_keypad(data, report, raw_data+1, size-1);
894 } else if (report->id == REPORT_IR_DATA) {
896 ret = picolcd_raw_cir(data, report, raw_data+1, size-1);
898 spin_lock_irqsave(&data->lock, flags);
900 * We let the caller of picolcd_send_and_wait() check if the
901 * report we got is one of the expected ones or not.
904 memcpy(data->pending->raw_data, raw_data+1, size-1);
905 data->pending->raw_size = size-1;
906 data->pending->in_report = report;
907 complete(&data->pending->ready);
909 spin_unlock_irqrestore(&data->lock, flags);
912 picolcd_debug_raw_event(data, hdev, report, raw_data, size);
916 /* initialize keypad input device */
917 static int picolcd_init_keys(struct picolcd_data *data,
918 struct hid_report *report)
920 struct hid_device *hdev = data->hdev;
921 struct input_dev *idev;
926 if (report->maxfield != 1 || report->field[0]->report_count != 2 ||
927 report->field[0]->report_size != 8) {
928 dev_err(&hdev->dev, "unsupported KEY_STATE report");
932 idev = input_allocate_device();
934 dev_err(&hdev->dev, "failed to allocate input device");
937 input_set_drvdata(idev, hdev);
938 memcpy(data->keycode, def_keymap, sizeof(def_keymap));
939 idev->name = hdev->name;
940 idev->phys = hdev->phys;
941 idev->uniq = hdev->uniq;
942 idev->id.bustype = hdev->bus;
943 idev->id.vendor = hdev->vendor;
944 idev->id.product = hdev->product;
945 idev->id.version = hdev->version;
946 idev->dev.parent = hdev->dev.parent;
947 idev->keycode = &data->keycode;
948 idev->keycodemax = PICOLCD_KEYS;
949 idev->keycodesize = sizeof(data->keycode[0]);
950 input_set_capability(idev, EV_MSC, MSC_SCAN);
951 set_bit(EV_REP, idev->evbit);
952 for (i = 0; i < PICOLCD_KEYS; i++)
953 input_set_capability(idev, EV_KEY, data->keycode[i]);
954 error = input_register_device(idev);
956 dev_err(&hdev->dev, "error registering the input device");
957 input_free_device(idev);
960 data->input_keys = idev;
964 static void picolcd_exit_keys(struct picolcd_data *data)
966 struct input_dev *idev = data->input_keys;
968 data->input_keys = NULL;
970 input_unregister_device(idev);
973 /* initialize CIR input device */
974 static inline int picolcd_init_cir(struct picolcd_data *data, struct hid_report *report)
976 /* support not implemented yet */
980 static inline void picolcd_exit_cir(struct picolcd_data *data)
984 static int picolcd_probe_lcd(struct hid_device *hdev, struct picolcd_data *data)
986 struct hid_report *report;
989 error = picolcd_check_version(hdev);
993 if (data->version[0] != 0 && data->version[1] != 3)
994 dev_info(&hdev->dev, "Device with untested firmware revision, "
995 "please submit /sys/kernel/debug/hid/%s/rdesc for this device.\n",
996 dev_name(&hdev->dev));
998 /* Setup keypad input device */
999 error = picolcd_init_keys(data, picolcd_in_report(REPORT_KEY_STATE, hdev));
1003 /* Setup CIR input device */
1004 error = picolcd_init_cir(data, picolcd_in_report(REPORT_IR_DATA, hdev));
1008 #ifdef CONFIG_DEBUG_FS
1009 report = picolcd_out_report(REPORT_READ_MEMORY, hdev);
1010 if (report && report->maxfield == 1 && report->field[0]->report_size == 8)
1011 data->addr_sz = report->field[0]->report_count - 1;
1017 picolcd_exit_cir(data);
1018 picolcd_exit_keys(data);
1022 static int picolcd_probe_bootloader(struct hid_device *hdev, struct picolcd_data *data)
1024 struct hid_report *report;
1027 error = picolcd_check_version(hdev);
1031 if (data->version[0] != 1 && data->version[1] != 0)
1032 dev_info(&hdev->dev, "Device with untested bootloader revision, "
1033 "please submit /sys/kernel/debug/hid/%s/rdesc for this device.\n",
1034 dev_name(&hdev->dev));
1036 #ifdef CONFIG_DEBUG_FS
1037 report = picolcd_out_report(REPORT_BL_READ_MEMORY, hdev);
1038 if (report && report->maxfield == 1 && report->field[0]->report_size == 8)
1039 data->addr_sz = report->field[0]->report_count - 1;
1046 static int picolcd_probe(struct hid_device *hdev,
1047 const struct hid_device_id *id)
1049 struct picolcd_data *data;
1050 int error = -ENOMEM;
1052 dbg_hid(PICOLCD_NAME " hardware probe...\n");
1055 * Let's allocate the picolcd data structure, set some reasonable
1056 * defaults, and associate it with the device
1058 data = kzalloc(sizeof(struct picolcd_data), GFP_KERNEL);
1060 dev_err(&hdev->dev, "can't allocate space for Minibox PicoLCD device data\n");
1062 goto err_no_cleanup;
1065 spin_lock_init(&data->lock);
1066 mutex_init(&data->mutex);
1068 if (hdev->product == USB_DEVICE_ID_PICOLCD_BOOTLOADER)
1069 data->status |= PICOLCD_BOOTLOADER;
1070 hid_set_drvdata(hdev, data);
1072 /* Parse the device reports and start it up */
1073 error = hid_parse(hdev);
1075 dev_err(&hdev->dev, "device report parse failed\n");
1076 goto err_cleanup_data;
1079 /* We don't use hidinput but hid_hw_start() fails if nothing is
1080 * claimed. So spoof claimed input. */
1081 hdev->claimed = HID_CLAIMED_INPUT;
1082 error = hid_hw_start(hdev, 0);
1085 dev_err(&hdev->dev, "hardware start failed\n");
1086 goto err_cleanup_data;
1089 error = hdev->ll_driver->open(hdev);
1091 dev_err(&hdev->dev, "failed to open input interrupt pipe for key and IR events\n");
1092 goto err_cleanup_hid_hw;
1095 error = device_create_file(&hdev->dev, &dev_attr_operation_mode);
1097 dev_err(&hdev->dev, "failed to create sysfs attributes\n");
1098 goto err_cleanup_hid_ll;
1101 if (data->status & PICOLCD_BOOTLOADER)
1102 error = picolcd_probe_bootloader(hdev, data);
1104 error = picolcd_probe_lcd(hdev, data);
1106 goto err_cleanup_sysfs;
1108 dbg_hid(PICOLCD_NAME " activated and initialized\n");
1112 device_remove_file(&hdev->dev, &dev_attr_operation_mode);
1114 hdev->ll_driver->close(hdev);
1120 hid_set_drvdata(hdev, NULL);
1125 static void picolcd_remove(struct hid_device *hdev)
1127 struct picolcd_data *data = hid_get_drvdata(hdev);
1128 unsigned long flags;
1130 dbg_hid(PICOLCD_NAME " hardware remove...\n");
1131 spin_lock_irqsave(&data->lock, flags);
1132 data->status |= PICOLCD_FAILED;
1133 spin_unlock_irqrestore(&data->lock, flags);
1135 device_remove_file(&hdev->dev, &dev_attr_operation_mode);
1136 hdev->ll_driver->close(hdev);
1138 hid_set_drvdata(hdev, NULL);
1140 /* Shortcut potential pending reply that will never arrive */
1141 spin_lock_irqsave(&data->lock, flags);
1143 complete(&data->pending->ready);
1144 spin_unlock_irqrestore(&data->lock, flags);
1147 picolcd_exit_cir(data);
1148 picolcd_exit_keys(data);
1150 mutex_destroy(&data->mutex);
1151 /* Finally, clean up the picolcd data itself */
1155 static const struct hid_device_id picolcd_devices[] = {
1156 { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICOLCD) },
1157 { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICOLCD_BOOTLOADER) },
1160 MODULE_DEVICE_TABLE(hid, picolcd_devices);
1162 static struct hid_driver picolcd_driver = {
1163 .name = "hid-picolcd",
1164 .id_table = picolcd_devices,
1165 .probe = picolcd_probe,
1166 .remove = picolcd_remove,
1167 .raw_event = picolcd_raw_event,
1170 static int __init picolcd_init(void)
1172 return hid_register_driver(&picolcd_driver);
1175 static void __exit picolcd_exit(void)
1177 hid_unregister_driver(&picolcd_driver);
1180 module_init(picolcd_init);
1181 module_exit(picolcd_exit);
1182 MODULE_DESCRIPTION("Minibox graphics PicoLCD Driver");
1183 MODULE_LICENSE("GPL v2");