Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0+
2 : : /*
3 : : * HID driver for gaming keys on Logitech gaming keyboards (such as the G15)
4 : : *
5 : : * Copyright (c) 2019 Hans de Goede <hdegoede@redhat.com>
6 : : */
7 : :
8 : : #include <linux/device.h>
9 : : #include <linux/hid.h>
10 : : #include <linux/module.h>
11 : : #include <linux/random.h>
12 : : #include <linux/sched.h>
13 : : #include <linux/usb.h>
14 : : #include <linux/wait.h>
15 : :
16 : : #include "hid-ids.h"
17 : :
18 : : #define LG_G15_TRANSFER_BUF_SIZE 20
19 : :
20 : : #define LG_G15_FEATURE_REPORT 0x02
21 : :
22 : : #define LG_G510_FEATURE_M_KEYS_LEDS 0x04
23 : : #define LG_G510_FEATURE_BACKLIGHT_RGB 0x05
24 : : #define LG_G510_FEATURE_POWER_ON_RGB 0x06
25 : :
26 : : enum lg_g15_model {
27 : : LG_G15,
28 : : LG_G15_V2,
29 : : LG_G510,
30 : : LG_G510_USB_AUDIO,
31 : : };
32 : :
33 : : enum lg_g15_led_type {
34 : : LG_G15_KBD_BRIGHTNESS,
35 : : LG_G15_LCD_BRIGHTNESS,
36 : : LG_G15_BRIGHTNESS_MAX,
37 : : LG_G15_MACRO_PRESET1 = 2,
38 : : LG_G15_MACRO_PRESET2,
39 : : LG_G15_MACRO_PRESET3,
40 : : LG_G15_MACRO_RECORD,
41 : : LG_G15_LED_MAX
42 : : };
43 : :
44 : : struct lg_g15_led {
45 : : struct led_classdev cdev;
46 : : enum led_brightness brightness;
47 : : enum lg_g15_led_type led;
48 : : u8 red, green, blue;
49 : : };
50 : :
51 : : struct lg_g15_data {
52 : : /* Must be first for proper dma alignment */
53 : : u8 transfer_buf[LG_G15_TRANSFER_BUF_SIZE];
54 : : /* Protects the transfer_buf and led brightness */
55 : : struct mutex mutex;
56 : : struct work_struct work;
57 : : struct input_dev *input;
58 : : struct hid_device *hdev;
59 : : enum lg_g15_model model;
60 : : struct lg_g15_led leds[LG_G15_LED_MAX];
61 : : bool game_mode_enabled;
62 : : };
63 : :
64 : : /******** G15 and G15 v2 LED functions ********/
65 : :
66 : 0 : static int lg_g15_update_led_brightness(struct lg_g15_data *g15)
67 : : {
68 : 0 : int ret;
69 : :
70 : 0 : ret = hid_hw_raw_request(g15->hdev, LG_G15_FEATURE_REPORT,
71 [ # # ]: 0 : g15->transfer_buf, 4,
72 : : HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
73 [ # # ]: 0 : if (ret != 4) {
74 : 0 : hid_err(g15->hdev, "Error getting LED brightness: %d\n", ret);
75 [ # # ]: 0 : return (ret < 0) ? ret : -EIO;
76 : : }
77 : :
78 : 0 : g15->leds[LG_G15_KBD_BRIGHTNESS].brightness = g15->transfer_buf[1];
79 : 0 : g15->leds[LG_G15_LCD_BRIGHTNESS].brightness = g15->transfer_buf[2];
80 : :
81 : 0 : g15->leds[LG_G15_MACRO_PRESET1].brightness =
82 : 0 : !(g15->transfer_buf[3] & 0x01);
83 : 0 : g15->leds[LG_G15_MACRO_PRESET2].brightness =
84 : 0 : !(g15->transfer_buf[3] & 0x02);
85 : 0 : g15->leds[LG_G15_MACRO_PRESET3].brightness =
86 : 0 : !(g15->transfer_buf[3] & 0x04);
87 : 0 : g15->leds[LG_G15_MACRO_RECORD].brightness =
88 : 0 : !(g15->transfer_buf[3] & 0x08);
89 : :
90 : 0 : return 0;
91 : : }
92 : :
93 : 0 : static enum led_brightness lg_g15_led_get(struct led_classdev *led_cdev)
94 : : {
95 : 0 : struct lg_g15_led *g15_led =
96 : 0 : container_of(led_cdev, struct lg_g15_led, cdev);
97 : 0 : struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent);
98 : 0 : enum led_brightness brightness;
99 : :
100 : 0 : mutex_lock(&g15->mutex);
101 : 0 : lg_g15_update_led_brightness(g15);
102 : 0 : brightness = g15->leds[g15_led->led].brightness;
103 : 0 : mutex_unlock(&g15->mutex);
104 : :
105 : 0 : return brightness;
106 : : }
107 : :
108 : 0 : static int lg_g15_led_set(struct led_classdev *led_cdev,
109 : : enum led_brightness brightness)
110 : : {
111 : 0 : struct lg_g15_led *g15_led =
112 : 0 : container_of(led_cdev, struct lg_g15_led, cdev);
113 [ # # ]: 0 : struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent);
114 : 0 : u8 val, mask = 0;
115 : 0 : int i, ret;
116 : :
117 : : /* Ignore LED off on unregister / keyboard unplug */
118 [ # # ]: 0 : if (led_cdev->flags & LED_UNREGISTERING)
119 : : return 0;
120 : :
121 : 0 : mutex_lock(&g15->mutex);
122 : :
123 : 0 : g15->transfer_buf[0] = LG_G15_FEATURE_REPORT;
124 : 0 : g15->transfer_buf[3] = 0;
125 : :
126 [ # # ]: 0 : if (g15_led->led < LG_G15_BRIGHTNESS_MAX) {
127 : 0 : g15->transfer_buf[1] = g15_led->led + 1;
128 : 0 : g15->transfer_buf[2] = brightness << (g15_led->led * 4);
129 : : } else {
130 [ # # ]: 0 : for (i = LG_G15_MACRO_PRESET1; i < LG_G15_LED_MAX; i++) {
131 [ # # ]: 0 : if (i == g15_led->led)
132 : 0 : val = brightness;
133 : : else
134 : 0 : val = g15->leds[i].brightness;
135 : :
136 [ # # ]: 0 : if (val)
137 : 0 : mask |= 1 << (i - LG_G15_MACRO_PRESET1);
138 : : }
139 : :
140 : 0 : g15->transfer_buf[1] = 0x04;
141 : 0 : g15->transfer_buf[2] = ~mask;
142 : : }
143 : :
144 : 0 : ret = hid_hw_raw_request(g15->hdev, LG_G15_FEATURE_REPORT,
145 [ # # ]: 0 : g15->transfer_buf, 4,
146 : : HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
147 [ # # ]: 0 : if (ret == 4) {
148 : : /* Success */
149 : 0 : g15_led->brightness = brightness;
150 : 0 : ret = 0;
151 : : } else {
152 : 0 : hid_err(g15->hdev, "Error setting LED brightness: %d\n", ret);
153 [ # # ]: 0 : ret = (ret < 0) ? ret : -EIO;
154 : : }
155 : :
156 : 0 : mutex_unlock(&g15->mutex);
157 : :
158 : 0 : return ret;
159 : : }
160 : :
161 : 0 : static void lg_g15_leds_changed_work(struct work_struct *work)
162 : : {
163 : 0 : struct lg_g15_data *g15 = container_of(work, struct lg_g15_data, work);
164 : 0 : enum led_brightness old_brightness[LG_G15_BRIGHTNESS_MAX];
165 : 0 : enum led_brightness brightness[LG_G15_BRIGHTNESS_MAX];
166 : 0 : int i, ret;
167 : :
168 : 0 : mutex_lock(&g15->mutex);
169 : 0 : for (i = 0; i < LG_G15_BRIGHTNESS_MAX; i++)
170 : : old_brightness[i] = g15->leds[i].brightness;
171 : :
172 : 0 : ret = lg_g15_update_led_brightness(g15);
173 : :
174 : 0 : for (i = 0; i < LG_G15_BRIGHTNESS_MAX; i++)
175 : : brightness[i] = g15->leds[i].brightness;
176 : 0 : mutex_unlock(&g15->mutex);
177 : :
178 : 0 : if (ret)
179 : 0 : return;
180 : :
181 : : for (i = 0; i < LG_G15_BRIGHTNESS_MAX; i++) {
182 : : if (brightness[i] == old_brightness[i])
183 : : continue;
184 : :
185 : : led_classdev_notify_brightness_hw_changed(&g15->leds[i].cdev,
186 : : brightness[i]);
187 : : }
188 : : }
189 : :
190 : : /******** G510 LED functions ********/
191 : :
192 : 0 : static int lg_g510_get_initial_led_brightness(struct lg_g15_data *g15, int i)
193 : : {
194 : 0 : int ret, high;
195 : :
196 : 0 : ret = hid_hw_raw_request(g15->hdev, LG_G510_FEATURE_BACKLIGHT_RGB + i,
197 [ # # ]: 0 : g15->transfer_buf, 4,
198 : : HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
199 [ # # ]: 0 : if (ret != 4) {
200 : 0 : hid_err(g15->hdev, "Error getting LED brightness: %d\n", ret);
201 [ # # ]: 0 : return (ret < 0) ? ret : -EIO;
202 : : }
203 : :
204 : 0 : high = max3(g15->transfer_buf[1], g15->transfer_buf[2],
205 : : g15->transfer_buf[3]);
206 : :
207 [ # # ]: 0 : if (high) {
208 : 0 : g15->leds[i].red =
209 [ # # ]: 0 : DIV_ROUND_CLOSEST(g15->transfer_buf[1] * 255, high);
210 : 0 : g15->leds[i].green =
211 [ # # ]: 0 : DIV_ROUND_CLOSEST(g15->transfer_buf[2] * 255, high);
212 : 0 : g15->leds[i].blue =
213 [ # # ]: 0 : DIV_ROUND_CLOSEST(g15->transfer_buf[3] * 255, high);
214 : 0 : g15->leds[i].brightness = high;
215 : : } else {
216 : 0 : g15->leds[i].red = 255;
217 : 0 : g15->leds[i].green = 255;
218 : 0 : g15->leds[i].blue = 255;
219 : 0 : g15->leds[i].brightness = 0;
220 : : }
221 : :
222 : : return 0;
223 : : }
224 : :
225 : : /* Must be called with g15->mutex locked */
226 : 0 : static int lg_g510_kbd_led_write(struct lg_g15_data *g15,
227 : : struct lg_g15_led *g15_led,
228 : : enum led_brightness brightness)
229 : : {
230 : 0 : int ret;
231 : :
232 : 0 : g15->transfer_buf[0] = 5 + g15_led->led;
233 : 0 : g15->transfer_buf[1] =
234 : 0 : DIV_ROUND_CLOSEST(g15_led->red * brightness, 255);
235 : 0 : g15->transfer_buf[2] =
236 : 0 : DIV_ROUND_CLOSEST(g15_led->green * brightness, 255);
237 : 0 : g15->transfer_buf[3] =
238 : 0 : DIV_ROUND_CLOSEST(g15_led->blue * brightness, 255);
239 : :
240 : 0 : ret = hid_hw_raw_request(g15->hdev,
241 : 0 : LG_G510_FEATURE_BACKLIGHT_RGB + g15_led->led,
242 [ # # ]: 0 : g15->transfer_buf, 4,
243 : : HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
244 [ # # ]: 0 : if (ret == 4) {
245 : : /* Success */
246 : 0 : g15_led->brightness = brightness;
247 : 0 : ret = 0;
248 : : } else {
249 : 0 : hid_err(g15->hdev, "Error setting LED brightness: %d\n", ret);
250 [ # # ]: 0 : ret = (ret < 0) ? ret : -EIO;
251 : : }
252 : :
253 : 0 : return ret;
254 : : }
255 : :
256 : 0 : static int lg_g510_kbd_led_set(struct led_classdev *led_cdev,
257 : : enum led_brightness brightness)
258 : : {
259 : 0 : struct lg_g15_led *g15_led =
260 : 0 : container_of(led_cdev, struct lg_g15_led, cdev);
261 [ # # ]: 0 : struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent);
262 : 0 : int ret;
263 : :
264 : : /* Ignore LED off on unregister / keyboard unplug */
265 [ # # ]: 0 : if (led_cdev->flags & LED_UNREGISTERING)
266 : : return 0;
267 : :
268 : 0 : mutex_lock(&g15->mutex);
269 : 0 : ret = lg_g510_kbd_led_write(g15, g15_led, brightness);
270 : 0 : mutex_unlock(&g15->mutex);
271 : :
272 : 0 : return ret;
273 : : }
274 : :
275 : 0 : static enum led_brightness lg_g510_kbd_led_get(struct led_classdev *led_cdev)
276 : : {
277 : 0 : struct lg_g15_led *g15_led =
278 : 0 : container_of(led_cdev, struct lg_g15_led, cdev);
279 : :
280 : 0 : return g15_led->brightness;
281 : : }
282 : :
283 : 0 : static ssize_t color_store(struct device *dev, struct device_attribute *attr,
284 : : const char *buf, size_t count)
285 : : {
286 [ # # ]: 0 : struct led_classdev *led_cdev = dev_get_drvdata(dev);
287 : 0 : struct lg_g15_led *g15_led =
288 : 0 : container_of(led_cdev, struct lg_g15_led, cdev);
289 : 0 : struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent);
290 : 0 : unsigned long value;
291 : 0 : int ret;
292 : :
293 [ # # # # : 0 : if (count < 7 || (count == 8 && buf[7] != '\n') || count > 8)
# # # # ]
294 : : return -EINVAL;
295 : :
296 [ # # ]: 0 : if (buf[0] != '#')
297 : : return -EINVAL;
298 : :
299 : 0 : ret = kstrtoul(buf + 1, 16, &value);
300 [ # # ]: 0 : if (ret)
301 : 0 : return ret;
302 : :
303 : 0 : mutex_lock(&g15->mutex);
304 : 0 : g15_led->red = (value & 0xff0000) >> 16;
305 : 0 : g15_led->green = (value & 0x00ff00) >> 8;
306 : 0 : g15_led->blue = (value & 0x0000ff);
307 : 0 : ret = lg_g510_kbd_led_write(g15, g15_led, g15_led->brightness);
308 : 0 : mutex_unlock(&g15->mutex);
309 : :
310 [ # # ]: 0 : return (ret < 0) ? ret : count;
311 : : }
312 : :
313 : 0 : static ssize_t color_show(struct device *dev, struct device_attribute *attr,
314 : : char *buf)
315 : : {
316 : 0 : struct led_classdev *led_cdev = dev_get_drvdata(dev);
317 : 0 : struct lg_g15_led *g15_led =
318 : 0 : container_of(led_cdev, struct lg_g15_led, cdev);
319 : 0 : struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent);
320 : 0 : ssize_t ret;
321 : :
322 : 0 : mutex_lock(&g15->mutex);
323 : 0 : ret = sprintf(buf, "#%02x%02x%02x\n",
324 : 0 : g15_led->red, g15_led->green, g15_led->blue);
325 : 0 : mutex_unlock(&g15->mutex);
326 : :
327 : 0 : return ret;
328 : : }
329 : :
330 : : static DEVICE_ATTR_RW(color);
331 : :
332 : : static struct attribute *lg_g510_kbd_led_attrs[] = {
333 : : &dev_attr_color.attr,
334 : : NULL,
335 : : };
336 : :
337 : : static const struct attribute_group lg_g510_kbd_led_group = {
338 : : .attrs = lg_g510_kbd_led_attrs,
339 : : };
340 : :
341 : : static const struct attribute_group *lg_g510_kbd_led_groups[] = {
342 : : &lg_g510_kbd_led_group,
343 : : NULL,
344 : : };
345 : :
346 : 0 : static void lg_g510_leds_sync_work(struct work_struct *work)
347 : : {
348 : 0 : struct lg_g15_data *g15 = container_of(work, struct lg_g15_data, work);
349 : :
350 : 0 : mutex_lock(&g15->mutex);
351 : 0 : lg_g510_kbd_led_write(g15, &g15->leds[LG_G15_KBD_BRIGHTNESS],
352 : : g15->leds[LG_G15_KBD_BRIGHTNESS].brightness);
353 : 0 : mutex_unlock(&g15->mutex);
354 : 0 : }
355 : :
356 : 0 : static int lg_g510_update_mkey_led_brightness(struct lg_g15_data *g15)
357 : : {
358 : 0 : int ret;
359 : :
360 : 0 : ret = hid_hw_raw_request(g15->hdev, LG_G510_FEATURE_M_KEYS_LEDS,
361 [ # # ]: 0 : g15->transfer_buf, 2,
362 : : HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
363 [ # # ]: 0 : if (ret != 2) {
364 : 0 : hid_err(g15->hdev, "Error getting LED brightness: %d\n", ret);
365 : 0 : ret = (ret < 0) ? ret : -EIO;
366 : : }
367 : :
368 : 0 : g15->leds[LG_G15_MACRO_PRESET1].brightness =
369 : 0 : !!(g15->transfer_buf[1] & 0x80);
370 : 0 : g15->leds[LG_G15_MACRO_PRESET2].brightness =
371 : 0 : !!(g15->transfer_buf[1] & 0x40);
372 : 0 : g15->leds[LG_G15_MACRO_PRESET3].brightness =
373 : 0 : !!(g15->transfer_buf[1] & 0x20);
374 : 0 : g15->leds[LG_G15_MACRO_RECORD].brightness =
375 : 0 : !!(g15->transfer_buf[1] & 0x10);
376 : :
377 : 0 : return 0;
378 : : }
379 : :
380 : 0 : static enum led_brightness lg_g510_mkey_led_get(struct led_classdev *led_cdev)
381 : : {
382 : 0 : struct lg_g15_led *g15_led =
383 : 0 : container_of(led_cdev, struct lg_g15_led, cdev);
384 : 0 : struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent);
385 : 0 : enum led_brightness brightness;
386 : :
387 : 0 : mutex_lock(&g15->mutex);
388 : 0 : lg_g510_update_mkey_led_brightness(g15);
389 : 0 : brightness = g15->leds[g15_led->led].brightness;
390 : 0 : mutex_unlock(&g15->mutex);
391 : :
392 : 0 : return brightness;
393 : : }
394 : :
395 : 0 : static int lg_g510_mkey_led_set(struct led_classdev *led_cdev,
396 : : enum led_brightness brightness)
397 : : {
398 : 0 : struct lg_g15_led *g15_led =
399 : 0 : container_of(led_cdev, struct lg_g15_led, cdev);
400 [ # # ]: 0 : struct lg_g15_data *g15 = dev_get_drvdata(led_cdev->dev->parent);
401 : 0 : u8 val, mask = 0;
402 : 0 : int i, ret;
403 : :
404 : : /* Ignore LED off on unregister / keyboard unplug */
405 [ # # ]: 0 : if (led_cdev->flags & LED_UNREGISTERING)
406 : : return 0;
407 : :
408 : 0 : mutex_lock(&g15->mutex);
409 : :
410 [ # # ]: 0 : for (i = LG_G15_MACRO_PRESET1; i < LG_G15_LED_MAX; i++) {
411 [ # # ]: 0 : if (i == g15_led->led)
412 : 0 : val = brightness;
413 : : else
414 : 0 : val = g15->leds[i].brightness;
415 : :
416 [ # # ]: 0 : if (val)
417 : 0 : mask |= 0x80 >> (i - LG_G15_MACRO_PRESET1);
418 : : }
419 : :
420 : 0 : g15->transfer_buf[0] = LG_G510_FEATURE_M_KEYS_LEDS;
421 : 0 : g15->transfer_buf[1] = mask;
422 : :
423 : 0 : ret = hid_hw_raw_request(g15->hdev, LG_G510_FEATURE_M_KEYS_LEDS,
424 [ # # ]: 0 : g15->transfer_buf, 2,
425 : : HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
426 [ # # ]: 0 : if (ret == 2) {
427 : : /* Success */
428 : 0 : g15_led->brightness = brightness;
429 : 0 : ret = 0;
430 : : } else {
431 : 0 : hid_err(g15->hdev, "Error setting LED brightness: %d\n", ret);
432 [ # # ]: 0 : ret = (ret < 0) ? ret : -EIO;
433 : : }
434 : :
435 : 0 : mutex_unlock(&g15->mutex);
436 : :
437 : 0 : return ret;
438 : : }
439 : :
440 : : /******** Generic LED functions ********/
441 : 0 : static int lg_g15_get_initial_led_brightness(struct lg_g15_data *g15)
442 : : {
443 : 0 : int ret;
444 : :
445 [ # # # ]: 0 : switch (g15->model) {
446 : 0 : case LG_G15:
447 : : case LG_G15_V2:
448 : 0 : return lg_g15_update_led_brightness(g15);
449 : 0 : case LG_G510:
450 : : case LG_G510_USB_AUDIO:
451 : 0 : ret = lg_g510_get_initial_led_brightness(g15, 0);
452 [ # # ]: 0 : if (ret)
453 : : return ret;
454 : :
455 : 0 : ret = lg_g510_get_initial_led_brightness(g15, 1);
456 [ # # ]: 0 : if (ret)
457 : : return ret;
458 : :
459 : 0 : return lg_g510_update_mkey_led_brightness(g15);
460 : : }
461 : : return -EINVAL; /* Never reached */
462 : : }
463 : :
464 : : /******** Input functions ********/
465 : :
466 : : /* On the G15 Mark I Logitech has been quite creative with which bit is what */
467 : : static int lg_g15_event(struct lg_g15_data *g15, u8 *data, int size)
468 : : {
469 : : int i, val;
470 : :
471 : : /* G1 - G6 */
472 : : for (i = 0; i < 6; i++) {
473 : : val = data[i + 1] & (1 << i);
474 : : input_report_key(g15->input, KEY_MACRO1 + i, val);
475 : : }
476 : : /* G7 - G12 */
477 : : for (i = 0; i < 6; i++) {
478 : : val = data[i + 2] & (1 << i);
479 : : input_report_key(g15->input, KEY_MACRO7 + i, val);
480 : : }
481 : : /* G13 - G17 */
482 : : for (i = 0; i < 5; i++) {
483 : : val = data[i + 1] & (4 << i);
484 : : input_report_key(g15->input, KEY_MACRO13 + i, val);
485 : : }
486 : : /* G18 */
487 : : input_report_key(g15->input, KEY_MACRO18, data[8] & 0x40);
488 : :
489 : : /* M1 - M3 */
490 : : for (i = 0; i < 3; i++) {
491 : : val = data[i + 6] & (1 << i);
492 : : input_report_key(g15->input, KEY_MACRO_PRESET1 + i, val);
493 : : }
494 : : /* MR */
495 : : input_report_key(g15->input, KEY_MACRO_RECORD_START, data[7] & 0x40);
496 : :
497 : : /* Most left (round) button below the LCD */
498 : : input_report_key(g15->input, KEY_KBD_LCD_MENU1, data[8] & 0x80);
499 : : /* 4 other buttons below the LCD */
500 : : for (i = 0; i < 4; i++) {
501 : : val = data[i + 2] & 0x80;
502 : : input_report_key(g15->input, KEY_KBD_LCD_MENU2 + i, val);
503 : : }
504 : :
505 : : /* Backlight cycle button pressed? */
506 : : if (data[1] & 0x80)
507 : : schedule_work(&g15->work);
508 : :
509 : : input_sync(g15->input);
510 : : return 0;
511 : : }
512 : :
513 : : static int lg_g15_v2_event(struct lg_g15_data *g15, u8 *data, int size)
514 : : {
515 : : int i, val;
516 : :
517 : : /* G1 - G6 */
518 : : for (i = 0; i < 6; i++) {
519 : : val = data[1] & (1 << i);
520 : : input_report_key(g15->input, KEY_MACRO1 + i, val);
521 : : }
522 : :
523 : : /* M1 - M3 + MR */
524 : : input_report_key(g15->input, KEY_MACRO_PRESET1, data[1] & 0x40);
525 : : input_report_key(g15->input, KEY_MACRO_PRESET2, data[1] & 0x80);
526 : : input_report_key(g15->input, KEY_MACRO_PRESET3, data[2] & 0x20);
527 : : input_report_key(g15->input, KEY_MACRO_RECORD_START, data[2] & 0x40);
528 : :
529 : : /* Round button to the left of the LCD */
530 : : input_report_key(g15->input, KEY_KBD_LCD_MENU1, data[2] & 0x80);
531 : : /* 4 buttons below the LCD */
532 : : for (i = 0; i < 4; i++) {
533 : : val = data[2] & (2 << i);
534 : : input_report_key(g15->input, KEY_KBD_LCD_MENU2 + i, val);
535 : : }
536 : :
537 : : /* Backlight cycle button pressed? */
538 : : if (data[2] & 0x01)
539 : : schedule_work(&g15->work);
540 : :
541 : : input_sync(g15->input);
542 : : return 0;
543 : : }
544 : :
545 : : static int lg_g510_event(struct lg_g15_data *g15, u8 *data, int size)
546 : : {
547 : : bool game_mode_enabled;
548 : : int i, val;
549 : :
550 : : /* G1 - G18 */
551 : : for (i = 0; i < 18; i++) {
552 : : val = data[i / 8 + 1] & (1 << (i % 8));
553 : : input_report_key(g15->input, KEY_MACRO1 + i, val);
554 : : }
555 : :
556 : : /* Game mode on/off slider */
557 : : game_mode_enabled = data[3] & 0x04;
558 : : if (game_mode_enabled != g15->game_mode_enabled) {
559 : : if (game_mode_enabled)
560 : : hid_info(g15->hdev, "Game Mode enabled, Windows (super) key is disabled\n");
561 : : else
562 : : hid_info(g15->hdev, "Game Mode disabled\n");
563 : : g15->game_mode_enabled = game_mode_enabled;
564 : : }
565 : :
566 : : /* M1 - M3 */
567 : : for (i = 0; i < 3; i++) {
568 : : val = data[3] & (0x10 << i);
569 : : input_report_key(g15->input, KEY_MACRO_PRESET1 + i, val);
570 : : }
571 : : /* MR */
572 : : input_report_key(g15->input, KEY_MACRO_RECORD_START, data[3] & 0x80);
573 : :
574 : : /* LCD menu keys */
575 : : for (i = 0; i < 5; i++) {
576 : : val = data[4] & (1 << i);
577 : : input_report_key(g15->input, KEY_KBD_LCD_MENU1 + i, val);
578 : : }
579 : :
580 : : /* Headphone Mute */
581 : : input_report_key(g15->input, KEY_MUTE, data[4] & 0x20);
582 : : /* Microphone Mute */
583 : : input_report_key(g15->input, KEY_F20, data[4] & 0x40);
584 : :
585 : : input_sync(g15->input);
586 : : return 0;
587 : : }
588 : :
589 : 0 : static int lg_g510_leds_event(struct lg_g15_data *g15, u8 *data, int size)
590 : : {
591 : 0 : bool backlight_disabled;
592 : :
593 : : /*
594 : : * The G510 ignores backlight updates when the backlight is turned off
595 : : * through the light toggle button on the keyboard, to work around this
596 : : * we queue a workitem to sync values when the backlight is turned on.
597 : : */
598 : 0 : backlight_disabled = data[1] & 0x04;
599 : 0 : if (!backlight_disabled)
600 : 0 : schedule_work(&g15->work);
601 : :
602 : 0 : return 0;
603 : : }
604 : :
605 : 0 : static int lg_g15_raw_event(struct hid_device *hdev, struct hid_report *report,
606 : : u8 *data, int size)
607 : : {
608 [ # # ]: 0 : struct lg_g15_data *g15 = hid_get_drvdata(hdev);
609 : :
610 [ # # ]: 0 : if (!g15)
611 : : return 0;
612 : :
613 [ # # # # ]: 0 : switch (g15->model) {
614 : 0 : case LG_G15:
615 [ # # # # ]: 0 : if (data[0] == 0x02 && size == 9)
616 : 0 : return lg_g15_event(g15, data, size);
617 : : break;
618 : 0 : case LG_G15_V2:
619 [ # # # # ]: 0 : if (data[0] == 0x02 && size == 5)
620 : 0 : return lg_g15_v2_event(g15, data, size);
621 : : break;
622 : 0 : case LG_G510:
623 : : case LG_G510_USB_AUDIO:
624 [ # # # # ]: 0 : if (data[0] == 0x03 && size == 5)
625 : 0 : return lg_g510_event(g15, data, size);
626 [ # # # # ]: 0 : if (data[0] == 0x04 && size == 2)
627 [ # # ]: 0 : return lg_g510_leds_event(g15, data, size);
628 : : break;
629 : : }
630 : :
631 : : return 0;
632 : : }
633 : :
634 : 0 : static int lg_g15_input_open(struct input_dev *dev)
635 : : {
636 : 0 : struct hid_device *hdev = input_get_drvdata(dev);
637 : :
638 : 0 : return hid_hw_open(hdev);
639 : : }
640 : :
641 : 0 : static void lg_g15_input_close(struct input_dev *dev)
642 : : {
643 : 0 : struct hid_device *hdev = input_get_drvdata(dev);
644 : :
645 : 0 : hid_hw_close(hdev);
646 : 0 : }
647 : :
648 : 0 : static int lg_g15_register_led(struct lg_g15_data *g15, int i)
649 : : {
650 : 0 : const char * const led_names[] = {
651 : : "g15::kbd_backlight",
652 : : "g15::lcd_backlight",
653 : : "g15::macro_preset1",
654 : : "g15::macro_preset2",
655 : : "g15::macro_preset3",
656 : : "g15::macro_record",
657 : : };
658 : :
659 : 0 : g15->leds[i].led = i;
660 : 0 : g15->leds[i].cdev.name = led_names[i];
661 : :
662 [ # # # ]: 0 : switch (g15->model) {
663 : 0 : case LG_G15:
664 : : case LG_G15_V2:
665 : 0 : g15->leds[i].cdev.brightness_set_blocking = lg_g15_led_set;
666 : 0 : g15->leds[i].cdev.brightness_get = lg_g15_led_get;
667 [ # # ]: 0 : if (i < LG_G15_BRIGHTNESS_MAX) {
668 : 0 : g15->leds[i].cdev.flags = LED_BRIGHT_HW_CHANGED;
669 : 0 : g15->leds[i].cdev.max_brightness = 2;
670 : : } else {
671 : 0 : g15->leds[i].cdev.max_brightness = 1;
672 : : }
673 : : break;
674 : 0 : case LG_G510:
675 : : case LG_G510_USB_AUDIO:
676 [ # # # ]: 0 : switch (i) {
677 : 0 : case LG_G15_LCD_BRIGHTNESS:
678 : : /*
679 : : * The G510 does not have a separate LCD brightness,
680 : : * but it does have a separate power-on (reset) value.
681 : : */
682 : 0 : g15->leds[i].cdev.name = "g15::power_on_backlight_val";
683 : : /* fall through */
684 : 0 : case LG_G15_KBD_BRIGHTNESS:
685 : 0 : g15->leds[i].cdev.brightness_set_blocking =
686 : : lg_g510_kbd_led_set;
687 : 0 : g15->leds[i].cdev.brightness_get =
688 : : lg_g510_kbd_led_get;
689 : 0 : g15->leds[i].cdev.max_brightness = 255;
690 : 0 : g15->leds[i].cdev.groups = lg_g510_kbd_led_groups;
691 : 0 : break;
692 : 0 : default:
693 : 0 : g15->leds[i].cdev.brightness_set_blocking =
694 : : lg_g510_mkey_led_set;
695 : 0 : g15->leds[i].cdev.brightness_get =
696 : : lg_g510_mkey_led_get;
697 : 0 : g15->leds[i].cdev.max_brightness = 1;
698 : : }
699 : : break;
700 : : }
701 : :
702 : 0 : return devm_led_classdev_register(&g15->hdev->dev, &g15->leds[i].cdev);
703 : : }
704 : :
705 : 0 : static int lg_g15_probe(struct hid_device *hdev, const struct hid_device_id *id)
706 : : {
707 : 0 : u8 gkeys_settings_output_report = 0;
708 : 0 : u8 gkeys_settings_feature_report = 0;
709 : 0 : struct hid_report_enum *rep_enum;
710 : 0 : unsigned int connect_mask = 0;
711 : 0 : bool has_ff000000 = false;
712 : 0 : struct lg_g15_data *g15;
713 : 0 : struct input_dev *input;
714 : 0 : struct hid_report *rep;
715 : 0 : int ret, i, gkeys = 0;
716 : :
717 : 0 : hdev->quirks |= HID_QUIRK_INPUT_PER_APP;
718 : :
719 : 0 : ret = hid_parse(hdev);
720 [ # # ]: 0 : if (ret)
721 : : return ret;
722 : :
723 : : /*
724 : : * Some models have multiple interfaces, we want the interface with
725 : : * with the f000.0000 application input report.
726 : : */
727 : 0 : rep_enum = &hdev->report_enum[HID_INPUT_REPORT];
728 [ # # ]: 0 : list_for_each_entry(rep, &rep_enum->report_list, list) {
729 [ # # ]: 0 : if (rep->application == 0xff000000)
730 : 0 : has_ff000000 = true;
731 : : }
732 [ # # ]: 0 : if (!has_ff000000)
733 : 0 : return hid_hw_start(hdev, HID_CONNECT_DEFAULT);
734 : :
735 : 0 : g15 = devm_kzalloc(&hdev->dev, sizeof(*g15), GFP_KERNEL);
736 [ # # ]: 0 : if (!g15)
737 : : return -ENOMEM;
738 : :
739 : 0 : mutex_init(&g15->mutex);
740 : :
741 : 0 : input = devm_input_allocate_device(&hdev->dev);
742 [ # # ]: 0 : if (!input)
743 : : return -ENOMEM;
744 : :
745 : 0 : g15->hdev = hdev;
746 : 0 : g15->model = id->driver_data;
747 [ # # # # ]: 0 : hid_set_drvdata(hdev, (void *)g15);
748 : :
749 [ # # # # ]: 0 : switch (g15->model) {
750 : 0 : case LG_G15:
751 : 0 : INIT_WORK(&g15->work, lg_g15_leds_changed_work);
752 : : /*
753 : : * The G15 and G15 v2 use a separate usb-device (on a builtin
754 : : * hub) which emulates a keyboard for the F1 - F12 emulation
755 : : * on the G-keys, which we disable, rendering the emulated kbd
756 : : * non-functional, so we do not let hid-input connect.
757 : : */
758 : 0 : connect_mask = HID_CONNECT_HIDRAW;
759 : 0 : gkeys_settings_output_report = 0x02;
760 : 0 : gkeys = 18;
761 : 0 : break;
762 : 0 : case LG_G15_V2:
763 : 0 : INIT_WORK(&g15->work, lg_g15_leds_changed_work);
764 : 0 : connect_mask = HID_CONNECT_HIDRAW;
765 : 0 : gkeys_settings_output_report = 0x02;
766 : 0 : gkeys = 6;
767 : 0 : break;
768 : 0 : case LG_G510:
769 : : case LG_G510_USB_AUDIO:
770 : 0 : INIT_WORK(&g15->work, lg_g510_leds_sync_work);
771 : 0 : connect_mask = HID_CONNECT_HIDINPUT | HID_CONNECT_HIDRAW;
772 : 0 : gkeys_settings_feature_report = 0x01;
773 : 0 : gkeys = 18;
774 : 0 : break;
775 : : }
776 : :
777 : 0 : ret = hid_hw_start(hdev, connect_mask);
778 [ # # ]: 0 : if (ret)
779 : : return ret;
780 : :
781 : : /* Tell the keyboard to stop sending F1-F12 + 1-6 for G1 - G18 */
782 [ # # ]: 0 : if (gkeys_settings_output_report) {
783 : 0 : g15->transfer_buf[0] = gkeys_settings_output_report;
784 : 0 : memset(g15->transfer_buf + 1, 0, gkeys);
785 : : /*
786 : : * The kbd ignores our output report if we do not queue
787 : : * an URB on the USB input endpoint first...
788 : : */
789 : 0 : ret = hid_hw_open(hdev);
790 [ # # ]: 0 : if (ret)
791 : 0 : goto error_hw_stop;
792 [ # # ]: 0 : ret = hid_hw_output_report(hdev, g15->transfer_buf, gkeys + 1);
793 : 0 : hid_hw_close(hdev);
794 : : }
795 : :
796 [ # # ]: 0 : if (gkeys_settings_feature_report) {
797 : 0 : g15->transfer_buf[0] = gkeys_settings_feature_report;
798 : 0 : memset(g15->transfer_buf + 1, 0, gkeys);
799 : 0 : ret = hid_hw_raw_request(g15->hdev,
800 : : gkeys_settings_feature_report,
801 : 0 : g15->transfer_buf, gkeys + 1,
802 : : HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
803 : : }
804 : :
805 [ # # ]: 0 : if (ret < 0) {
806 : 0 : hid_err(hdev, "Error disabling keyboard emulation for the G-keys\n");
807 : 0 : goto error_hw_stop;
808 : : }
809 : :
810 : : /* Get initial brightness levels */
811 : 0 : ret = lg_g15_get_initial_led_brightness(g15);
812 [ # # ]: 0 : if (ret)
813 : 0 : goto error_hw_stop;
814 : :
815 : : /* Setup and register input device */
816 : 0 : input->name = "Logitech Gaming Keyboard Gaming Keys";
817 : 0 : input->phys = hdev->phys;
818 : 0 : input->uniq = hdev->uniq;
819 : 0 : input->id.bustype = hdev->bus;
820 : 0 : input->id.vendor = hdev->vendor;
821 : 0 : input->id.product = hdev->product;
822 : 0 : input->id.version = hdev->version;
823 : 0 : input->dev.parent = &hdev->dev;
824 : 0 : input->open = lg_g15_input_open;
825 : 0 : input->close = lg_g15_input_close;
826 : :
827 : : /* G-keys */
828 [ # # ]: 0 : for (i = 0; i < gkeys; i++)
829 : 0 : input_set_capability(input, EV_KEY, KEY_MACRO1 + i);
830 : :
831 : : /* M1 - M3 and MR keys */
832 [ # # ]: 0 : for (i = 0; i < 3; i++)
833 : 0 : input_set_capability(input, EV_KEY, KEY_MACRO_PRESET1 + i);
834 : 0 : input_set_capability(input, EV_KEY, KEY_MACRO_RECORD_START);
835 : :
836 : : /* Keys below the LCD, intended for controlling a menu on the LCD */
837 [ # # ]: 0 : for (i = 0; i < 5; i++)
838 : 0 : input_set_capability(input, EV_KEY, KEY_KBD_LCD_MENU1 + i);
839 : :
840 : : /*
841 : : * On the G510 only report headphone and mic mute keys when *not* using
842 : : * the builtin USB audio device. When the builtin audio is used these
843 : : * keys directly toggle mute (and the LEDs) on/off.
844 : : */
845 [ # # ]: 0 : if (g15->model == LG_G510) {
846 : 0 : input_set_capability(input, EV_KEY, KEY_MUTE);
847 : : /* Userspace expects F20 for micmute */
848 : 0 : input_set_capability(input, EV_KEY, KEY_F20);
849 : : }
850 : :
851 : 0 : g15->input = input;
852 : 0 : input_set_drvdata(input, hdev);
853 : :
854 : 0 : ret = input_register_device(input);
855 [ # # ]: 0 : if (ret)
856 : 0 : goto error_hw_stop;
857 : :
858 : : /* Register LED devices */
859 [ # # ]: 0 : for (i = 0; i < LG_G15_LED_MAX; i++) {
860 : 0 : ret = lg_g15_register_led(g15, i);
861 [ # # ]: 0 : if (ret)
862 : 0 : goto error_hw_stop;
863 : : }
864 : :
865 : : return 0;
866 : :
867 : 0 : error_hw_stop:
868 : 0 : hid_hw_stop(hdev);
869 : 0 : return ret;
870 : : }
871 : :
872 : : static const struct hid_device_id lg_g15_devices[] = {
873 : : { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
874 : : USB_DEVICE_ID_LOGITECH_G15_LCD),
875 : : .driver_data = LG_G15 },
876 : : { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
877 : : USB_DEVICE_ID_LOGITECH_G15_V2_LCD),
878 : : .driver_data = LG_G15_V2 },
879 : : /* G510 without a headset plugged in */
880 : : { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
881 : : USB_DEVICE_ID_LOGITECH_G510),
882 : : .driver_data = LG_G510 },
883 : : /* G510 with headset plugged in / with extra USB audio interface */
884 : : { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
885 : : USB_DEVICE_ID_LOGITECH_G510_USB_AUDIO),
886 : : .driver_data = LG_G510_USB_AUDIO },
887 : : { }
888 : : };
889 : : MODULE_DEVICE_TABLE(hid, lg_g15_devices);
890 : :
891 : : static struct hid_driver lg_g15_driver = {
892 : : .name = "lg-g15",
893 : : .id_table = lg_g15_devices,
894 : : .raw_event = lg_g15_raw_event,
895 : : .probe = lg_g15_probe,
896 : : };
897 : 30 : module_hid_driver(lg_g15_driver);
898 : :
899 : : MODULE_LICENSE("GPL");
|
