1 // SPDX-License-Identifier: GPL-2.0-only
2 /***************************************************************************
3 * Copyright (C) 2010-2012 by Bruno Prémont <bonbons@linux-vserver.org> *
5 * Based on Logitech G13 driver (v0.4) *
6 * Copyright (C) 2009 by Rick L. Vinyard, Jr. <rvinyard@cs.nmsu.edu> *
8 ***************************************************************************/
10 #include <linux/hid.h>
11 #include <linux/hid-debug.h>
12 #include <linux/input.h>
16 #include <linux/vmalloc.h>
18 #include <linux/completion.h>
19 #include <linux/uaccess.h>
20 #include <linux/module.h>
21 #include <linux/string.h>
23 #include "hid-picolcd.h"
28 * The PicoLCD has an IR receiver header, a built-in keypad with 5 keys
29 * and header for 4x4 key matrix. The built-in keys are part of the matrix.
31 static const unsigned short def_keymap
[PICOLCD_KEYS
] = {
32 KEY_RESERVED
, /* none */
33 KEY_BACK
, /* col 4 + row 1 */
34 KEY_HOMEPAGE
, /* col 3 + row 1 */
35 KEY_RESERVED
, /* col 2 + row 1 */
36 KEY_RESERVED
, /* col 1 + row 1 */
37 KEY_SCROLLUP
, /* col 4 + row 2 */
38 KEY_OK
, /* col 3 + row 2 */
39 KEY_SCROLLDOWN
, /* col 2 + row 2 */
40 KEY_RESERVED
, /* col 1 + row 2 */
41 KEY_RESERVED
, /* col 4 + row 3 */
42 KEY_RESERVED
, /* col 3 + row 3 */
43 KEY_RESERVED
, /* col 2 + row 3 */
44 KEY_RESERVED
, /* col 1 + row 3 */
45 KEY_RESERVED
, /* col 4 + row 4 */
46 KEY_RESERVED
, /* col 3 + row 4 */
47 KEY_RESERVED
, /* col 2 + row 4 */
48 KEY_RESERVED
, /* col 1 + row 4 */
52 /* Find a given report */
53 struct hid_report
*picolcd_report(int id
, struct hid_device
*hdev
, int dir
)
55 struct list_head
*feature_report_list
= &hdev
->report_enum
[dir
].report_list
;
56 struct hid_report
*report
= NULL
;
58 list_for_each_entry(report
, feature_report_list
, list
) {
62 hid_warn(hdev
, "No report with id 0x%x found\n", id
);
66 /* Submit a report and wait for a reply from device - if device fades away
67 * or does not respond in time, return NULL */
68 struct picolcd_pending
*picolcd_send_and_wait(struct hid_device
*hdev
,
69 int report_id
, const u8
*raw_data
, int size
)
71 struct picolcd_data
*data
= hid_get_drvdata(hdev
);
72 struct picolcd_pending
*work
;
73 struct hid_report
*report
= picolcd_out_report(report_id
, hdev
);
79 if (data
->status
& PICOLCD_FAILED
)
81 work
= kzalloc(sizeof(*work
), GFP_KERNEL
);
85 init_completion(&work
->ready
);
86 work
->out_report
= report
;
87 work
->in_report
= NULL
;
90 mutex_lock(&data
->mutex
);
91 spin_lock_irqsave(&data
->lock
, flags
);
92 for (i
= k
= 0; i
< report
->maxfield
; i
++)
93 for (j
= 0; j
< report
->field
[i
]->report_count
; j
++) {
94 hid_set_field(report
->field
[i
], j
, k
< size
? raw_data
[k
] : 0);
97 if (data
->status
& PICOLCD_FAILED
) {
101 data
->pending
= work
;
102 hid_hw_request(data
->hdev
, report
, HID_REQ_SET_REPORT
);
103 spin_unlock_irqrestore(&data
->lock
, flags
);
104 wait_for_completion_interruptible_timeout(&work
->ready
, HZ
*2);
105 spin_lock_irqsave(&data
->lock
, flags
);
106 data
->pending
= NULL
;
108 spin_unlock_irqrestore(&data
->lock
, flags
);
109 mutex_unlock(&data
->mutex
);
116 static int picolcd_raw_keypad(struct picolcd_data
*data
,
117 struct hid_report
*report
, u8
*raw_data
, int size
)
121 * First and second data bytes list currently pressed keys,
122 * 0x00 means no key and at most 2 keys may be pressed at same time
126 /* determine newly pressed keys */
127 for (i
= 0; i
< size
; i
++) {
128 unsigned int key_code
;
129 if (raw_data
[i
] == 0)
131 for (j
= 0; j
< sizeof(data
->pressed_keys
); j
++)
132 if (data
->pressed_keys
[j
] == raw_data
[i
])
133 goto key_already_down
;
134 for (j
= 0; j
< sizeof(data
->pressed_keys
); j
++)
135 if (data
->pressed_keys
[j
] == 0) {
136 data
->pressed_keys
[j
] = raw_data
[i
];
139 input_event(data
->input_keys
, EV_MSC
, MSC_SCAN
, raw_data
[i
]);
140 if (raw_data
[i
] < PICOLCD_KEYS
)
141 key_code
= data
->keycode
[raw_data
[i
]];
143 key_code
= KEY_UNKNOWN
;
144 if (key_code
!= KEY_UNKNOWN
) {
145 dbg_hid(PICOLCD_NAME
" got key press for %u:%d",
146 raw_data
[i
], key_code
);
147 input_report_key(data
->input_keys
, key_code
, 1);
149 input_sync(data
->input_keys
);
154 /* determine newly released keys */
155 for (j
= 0; j
< sizeof(data
->pressed_keys
); j
++) {
156 unsigned int key_code
;
157 if (data
->pressed_keys
[j
] == 0)
159 for (i
= 0; i
< size
; i
++)
160 if (data
->pressed_keys
[j
] == raw_data
[i
])
162 input_event(data
->input_keys
, EV_MSC
, MSC_SCAN
, data
->pressed_keys
[j
]);
163 if (data
->pressed_keys
[j
] < PICOLCD_KEYS
)
164 key_code
= data
->keycode
[data
->pressed_keys
[j
]];
166 key_code
= KEY_UNKNOWN
;
167 if (key_code
!= KEY_UNKNOWN
) {
168 dbg_hid(PICOLCD_NAME
" got key release for %u:%d",
169 data
->pressed_keys
[j
], key_code
);
170 input_report_key(data
->input_keys
, key_code
, 0);
172 input_sync(data
->input_keys
);
173 data
->pressed_keys
[j
] = 0;
180 static int picolcd_check_version(struct hid_device
*hdev
)
182 struct picolcd_data
*data
= hid_get_drvdata(hdev
);
183 struct picolcd_pending
*verinfo
;
189 verinfo
= picolcd_send_and_wait(hdev
, REPORT_VERSION
, NULL
, 0);
191 hid_err(hdev
, "no version response from PicoLCD\n");
195 if (verinfo
->raw_size
== 2) {
196 data
->version
[0] = verinfo
->raw_data
[1];
197 data
->version
[1] = verinfo
->raw_data
[0];
198 if (data
->status
& PICOLCD_BOOTLOADER
) {
199 hid_info(hdev
, "PicoLCD, bootloader version %d.%d\n",
200 verinfo
->raw_data
[1], verinfo
->raw_data
[0]);
202 hid_info(hdev
, "PicoLCD, firmware version %d.%d\n",
203 verinfo
->raw_data
[1], verinfo
->raw_data
[0]);
206 hid_err(hdev
, "confused, got unexpected version response from PicoLCD\n");
214 * Reset our device and wait for answer to VERSION request
216 int picolcd_reset(struct hid_device
*hdev
)
218 struct picolcd_data
*data
= hid_get_drvdata(hdev
);
219 struct hid_report
*report
= picolcd_out_report(REPORT_RESET
, hdev
);
223 if (!data
|| !report
|| report
->maxfield
!= 1)
226 spin_lock_irqsave(&data
->lock
, flags
);
227 if (hdev
->product
== USB_DEVICE_ID_PICOLCD_BOOTLOADER
)
228 data
->status
|= PICOLCD_BOOTLOADER
;
230 /* perform the reset */
231 hid_set_field(report
->field
[0], 0, 1);
232 if (data
->status
& PICOLCD_FAILED
) {
233 spin_unlock_irqrestore(&data
->lock
, flags
);
236 hid_hw_request(hdev
, report
, HID_REQ_SET_REPORT
);
237 spin_unlock_irqrestore(&data
->lock
, flags
);
239 error
= picolcd_check_version(hdev
);
243 picolcd_resume_lcd(data
);
244 picolcd_resume_backlight(data
);
245 picolcd_fb_refresh(data
);
246 picolcd_leds_set(data
);
251 * The "operation_mode" sysfs attribute
253 static ssize_t
picolcd_operation_mode_show(struct device
*dev
,
254 struct device_attribute
*attr
, char *buf
)
256 struct picolcd_data
*data
= dev_get_drvdata(dev
);
258 if (data
->status
& PICOLCD_BOOTLOADER
)
259 return sysfs_emit(buf
, "[bootloader] lcd\n");
261 return sysfs_emit(buf
, "bootloader [lcd]\n");
264 static ssize_t
picolcd_operation_mode_store(struct device
*dev
,
265 struct device_attribute
*attr
, const char *buf
, size_t count
)
267 struct picolcd_data
*data
= dev_get_drvdata(dev
);
268 struct hid_report
*report
= NULL
;
269 int timeout
= data
->opmode_delay
;
272 if (sysfs_streq(buf
, "lcd")) {
273 if (data
->status
& PICOLCD_BOOTLOADER
)
274 report
= picolcd_out_report(REPORT_EXIT_FLASHER
, data
->hdev
);
275 } else if (sysfs_streq(buf
, "bootloader")) {
276 if (!(data
->status
& PICOLCD_BOOTLOADER
))
277 report
= picolcd_out_report(REPORT_EXIT_KEYBOARD
, data
->hdev
);
282 if (!report
|| report
->maxfield
!= 1)
285 spin_lock_irqsave(&data
->lock
, flags
);
286 hid_set_field(report
->field
[0], 0, timeout
& 0xff);
287 hid_set_field(report
->field
[0], 1, (timeout
>> 8) & 0xff);
288 hid_hw_request(data
->hdev
, report
, HID_REQ_SET_REPORT
);
289 spin_unlock_irqrestore(&data
->lock
, flags
);
293 static DEVICE_ATTR(operation_mode
, 0644, picolcd_operation_mode_show
,
294 picolcd_operation_mode_store
);
297 * The "operation_mode_delay" sysfs attribute
299 static ssize_t
picolcd_operation_mode_delay_show(struct device
*dev
,
300 struct device_attribute
*attr
, char *buf
)
302 struct picolcd_data
*data
= dev_get_drvdata(dev
);
304 return sysfs_emit(buf
, "%hu\n", data
->opmode_delay
);
307 static ssize_t
picolcd_operation_mode_delay_store(struct device
*dev
,
308 struct device_attribute
*attr
, const char *buf
, size_t count
)
310 struct picolcd_data
*data
= dev_get_drvdata(dev
);
312 if (sscanf(buf
, "%u", &u
) != 1)
317 data
->opmode_delay
= u
;
321 static DEVICE_ATTR(operation_mode_delay
, 0644, picolcd_operation_mode_delay_show
,
322 picolcd_operation_mode_delay_store
);
325 * Handle raw report as sent by device
327 static int picolcd_raw_event(struct hid_device
*hdev
,
328 struct hid_report
*report
, u8
*raw_data
, int size
)
330 struct picolcd_data
*data
= hid_get_drvdata(hdev
);
337 hid_warn(hdev
, "invalid size value (%d) for picolcd raw event (%d)\n",
342 if (report
->id
== REPORT_KEY_STATE
) {
343 if (data
->input_keys
)
344 picolcd_raw_keypad(data
, report
, raw_data
+1, size
-1);
345 } else if (report
->id
== REPORT_IR_DATA
) {
346 picolcd_raw_cir(data
, report
, raw_data
+1, size
-1);
348 spin_lock_irqsave(&data
->lock
, flags
);
350 * We let the caller of picolcd_send_and_wait() check if the
351 * report we got is one of the expected ones or not.
354 memcpy(data
->pending
->raw_data
, raw_data
+1, size
-1);
355 data
->pending
->raw_size
= size
-1;
356 data
->pending
->in_report
= report
;
357 complete(&data
->pending
->ready
);
359 spin_unlock_irqrestore(&data
->lock
, flags
);
362 picolcd_debug_raw_event(data
, hdev
, report
, raw_data
, size
);
367 static int picolcd_suspend(struct hid_device
*hdev
, pm_message_t message
)
369 if (PMSG_IS_AUTO(message
))
372 picolcd_suspend_backlight(hid_get_drvdata(hdev
));
373 dbg_hid(PICOLCD_NAME
" device ready for suspend\n");
377 static int picolcd_resume(struct hid_device
*hdev
)
380 ret
= picolcd_resume_backlight(hid_get_drvdata(hdev
));
382 dbg_hid(PICOLCD_NAME
" restoring backlight failed: %d\n", ret
);
386 static int picolcd_reset_resume(struct hid_device
*hdev
)
389 ret
= picolcd_reset(hdev
);
391 dbg_hid(PICOLCD_NAME
" resetting our device failed: %d\n", ret
);
392 ret
= picolcd_fb_reset(hid_get_drvdata(hdev
), 0);
394 dbg_hid(PICOLCD_NAME
" restoring framebuffer content failed: %d\n", ret
);
395 ret
= picolcd_resume_lcd(hid_get_drvdata(hdev
));
397 dbg_hid(PICOLCD_NAME
" restoring lcd failed: %d\n", ret
);
398 ret
= picolcd_resume_backlight(hid_get_drvdata(hdev
));
400 dbg_hid(PICOLCD_NAME
" restoring backlight failed: %d\n", ret
);
401 picolcd_leds_set(hid_get_drvdata(hdev
));
406 /* initialize keypad input device */
407 static int picolcd_init_keys(struct picolcd_data
*data
,
408 struct hid_report
*report
)
410 struct hid_device
*hdev
= data
->hdev
;
411 struct input_dev
*idev
;
416 if (report
->maxfield
!= 1 || report
->field
[0]->report_count
!= 2 ||
417 report
->field
[0]->report_size
!= 8) {
418 hid_err(hdev
, "unsupported KEY_STATE report\n");
422 idev
= input_allocate_device();
424 hid_err(hdev
, "failed to allocate input device\n");
427 input_set_drvdata(idev
, hdev
);
428 memcpy(data
->keycode
, def_keymap
, sizeof(def_keymap
));
429 idev
->name
= hdev
->name
;
430 idev
->phys
= hdev
->phys
;
431 idev
->uniq
= hdev
->uniq
;
432 idev
->id
.bustype
= hdev
->bus
;
433 idev
->id
.vendor
= hdev
->vendor
;
434 idev
->id
.product
= hdev
->product
;
435 idev
->id
.version
= hdev
->version
;
436 idev
->dev
.parent
= &hdev
->dev
;
437 idev
->keycode
= &data
->keycode
;
438 idev
->keycodemax
= PICOLCD_KEYS
;
439 idev
->keycodesize
= sizeof(data
->keycode
[0]);
440 input_set_capability(idev
, EV_MSC
, MSC_SCAN
);
441 set_bit(EV_REP
, idev
->evbit
);
442 for (i
= 0; i
< PICOLCD_KEYS
; i
++)
443 input_set_capability(idev
, EV_KEY
, data
->keycode
[i
]);
444 error
= input_register_device(idev
);
446 hid_err(hdev
, "error registering the input device\n");
447 input_free_device(idev
);
450 data
->input_keys
= idev
;
454 static void picolcd_exit_keys(struct picolcd_data
*data
)
456 struct input_dev
*idev
= data
->input_keys
;
458 data
->input_keys
= NULL
;
460 input_unregister_device(idev
);
463 static int picolcd_probe_lcd(struct hid_device
*hdev
, struct picolcd_data
*data
)
467 /* Setup keypad input device */
468 error
= picolcd_init_keys(data
, picolcd_in_report(REPORT_KEY_STATE
, hdev
));
472 /* Setup CIR input device */
473 error
= picolcd_init_cir(data
, picolcd_in_report(REPORT_IR_DATA
, hdev
));
477 /* Setup lcd class device */
478 error
= picolcd_init_lcd(data
, picolcd_out_report(REPORT_CONTRAST
, hdev
));
482 /* Setup backlight class device */
483 error
= picolcd_init_backlight(data
, picolcd_out_report(REPORT_BRIGHTNESS
, hdev
));
487 /* Set up the framebuffer device */
488 error
= picolcd_init_framebuffer(data
);
492 /* Setup the LED class devices */
493 error
= picolcd_init_leds(data
, picolcd_out_report(REPORT_LED_STATE
, hdev
));
497 picolcd_init_devfs(data
, picolcd_out_report(REPORT_EE_READ
, hdev
),
498 picolcd_out_report(REPORT_EE_WRITE
, hdev
),
499 picolcd_out_report(REPORT_READ_MEMORY
, hdev
),
500 picolcd_out_report(REPORT_WRITE_MEMORY
, hdev
),
501 picolcd_out_report(REPORT_RESET
, hdev
));
504 picolcd_exit_leds(data
);
505 picolcd_exit_framebuffer(data
);
506 picolcd_exit_backlight(data
);
507 picolcd_exit_lcd(data
);
508 picolcd_exit_cir(data
);
509 picolcd_exit_keys(data
);
513 static int picolcd_probe_bootloader(struct hid_device
*hdev
, struct picolcd_data
*data
)
515 picolcd_init_devfs(data
, NULL
, NULL
,
516 picolcd_out_report(REPORT_BL_READ_MEMORY
, hdev
),
517 picolcd_out_report(REPORT_BL_WRITE_MEMORY
, hdev
), NULL
);
521 static int picolcd_probe(struct hid_device
*hdev
,
522 const struct hid_device_id
*id
)
524 struct picolcd_data
*data
;
527 dbg_hid(PICOLCD_NAME
" hardware probe...\n");
530 * Let's allocate the picolcd data structure, set some reasonable
531 * defaults, and associate it with the device
533 data
= kzalloc(sizeof(struct picolcd_data
), GFP_KERNEL
);
535 hid_err(hdev
, "can't allocate space for Minibox PicoLCD device data\n");
539 spin_lock_init(&data
->lock
);
540 mutex_init(&data
->mutex
);
542 data
->opmode_delay
= 5000;
543 if (hdev
->product
== USB_DEVICE_ID_PICOLCD_BOOTLOADER
)
544 data
->status
|= PICOLCD_BOOTLOADER
;
545 hid_set_drvdata(hdev
, data
);
547 /* Parse the device reports and start it up */
548 error
= hid_parse(hdev
);
550 hid_err(hdev
, "device report parse failed\n");
551 goto err_cleanup_data
;
554 error
= hid_hw_start(hdev
, 0);
556 hid_err(hdev
, "hardware start failed\n");
557 goto err_cleanup_data
;
560 error
= hid_hw_open(hdev
);
562 hid_err(hdev
, "failed to open input interrupt pipe for key and IR events\n");
563 goto err_cleanup_hid_hw
;
566 error
= device_create_file(&hdev
->dev
, &dev_attr_operation_mode_delay
);
568 hid_err(hdev
, "failed to create sysfs attributes\n");
569 goto err_cleanup_hid_ll
;
572 error
= device_create_file(&hdev
->dev
, &dev_attr_operation_mode
);
574 hid_err(hdev
, "failed to create sysfs attributes\n");
575 goto err_cleanup_sysfs1
;
578 if (data
->status
& PICOLCD_BOOTLOADER
)
579 error
= picolcd_probe_bootloader(hdev
, data
);
581 error
= picolcd_probe_lcd(hdev
, data
);
583 goto err_cleanup_sysfs2
;
585 dbg_hid(PICOLCD_NAME
" activated and initialized\n");
589 device_remove_file(&hdev
->dev
, &dev_attr_operation_mode
);
591 device_remove_file(&hdev
->dev
, &dev_attr_operation_mode_delay
);
601 static void picolcd_remove(struct hid_device
*hdev
)
603 struct picolcd_data
*data
= hid_get_drvdata(hdev
);
606 dbg_hid(PICOLCD_NAME
" hardware remove...\n");
607 spin_lock_irqsave(&data
->lock
, flags
);
608 data
->status
|= PICOLCD_FAILED
;
609 spin_unlock_irqrestore(&data
->lock
, flags
);
611 picolcd_exit_devfs(data
);
612 device_remove_file(&hdev
->dev
, &dev_attr_operation_mode
);
613 device_remove_file(&hdev
->dev
, &dev_attr_operation_mode_delay
);
617 /* Shortcut potential pending reply that will never arrive */
618 spin_lock_irqsave(&data
->lock
, flags
);
620 complete(&data
->pending
->ready
);
621 spin_unlock_irqrestore(&data
->lock
, flags
);
624 picolcd_exit_leds(data
);
625 /* Clean up the framebuffer */
626 picolcd_exit_framebuffer(data
);
627 picolcd_exit_backlight(data
);
628 picolcd_exit_lcd(data
);
630 picolcd_exit_cir(data
);
631 picolcd_exit_keys(data
);
633 mutex_destroy(&data
->mutex
);
634 /* Finally, clean up the picolcd data itself */
638 static const struct hid_device_id picolcd_devices
[] = {
639 { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP
, USB_DEVICE_ID_PICOLCD
) },
640 { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP
, USB_DEVICE_ID_PICOLCD_BOOTLOADER
) },
643 MODULE_DEVICE_TABLE(hid
, picolcd_devices
);
645 static struct hid_driver picolcd_driver
= {
646 .name
= "hid-picolcd",
647 .id_table
= picolcd_devices
,
648 .probe
= picolcd_probe
,
649 .remove
= picolcd_remove
,
650 .raw_event
= picolcd_raw_event
,
652 .suspend
= picolcd_suspend
,
653 .resume
= picolcd_resume
,
654 .reset_resume
= picolcd_reset_resume
,
657 module_hid_driver(picolcd_driver
);
659 MODULE_DESCRIPTION("Minibox graphics PicoLCD Driver");
660 MODULE_LICENSE("GPL v2");