projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
HID: wacom: OLEDs control over sysfs for Intuos4
[deliverable/linux.git] / drivers / hid / hid-wacom.c
CommitLineData
ca2dcd40
BN		 1/*
2 * Bluetooth Wacom Tablet support
3 *
4 * Copyright (c) 1999 Andreas Gal
5 * Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
6 * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
7 * Copyright (c) 2006-2007 Jiri Kosina
8 * Copyright (c) 2007 Paul Walmsley
9 * Copyright (c) 2008 Jiri Slaby <jirislaby@gmail.com>
10 * Copyright (c) 2006 Andrew Zabolotny <zap@homelink.ru>
11 * Copyright (c) 2009 Bastien Nocera <hadess@hadess.net>
78761ff9 12 * Copyright (c) 2011 Przemysław Firszt <przemo@firszt.eu>
ca2dcd40
BN		 13 */
14
15/*
16 * This program is free software; you can redistribute it and/or modify it
17 * under the terms of the GNU General Public License as published by the Free
18 * Software Foundation; either version 2 of the License, or (at your option)
19 * any later version.
20 */
21
4291ee30
JP		 22#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
23
ca2dcd40
BN		 24#include <linux/device.h>
25#include <linux/hid.h>
26#include <linux/module.h>
d13f5454 27#include <linux/leds.h>
5a0e3ad6 28#include <linux/slab.h>
59d2334a 29#include <linux/power_supply.h>
ca2dcd40
BN		 30
31#include "hid-ids.h"
32
6245bde2
PF		 33#define PAD_DEVICE_ID 0x0F
34
d13f5454 35#define WAC_CMD_LED_CONTROL 0x20
e3c399ee
PF		 36#define WAC_CMD_ICON_START_STOP 0x21
37#define WAC_CMD_ICON_TRANSFER 0x26
d13f5454 38
ca2dcd40
BN		 39struct wacom_data {
40 __u16 tool;
6245bde2 41 __u16 butstate;
7e503a37 42 __u8 whlstate;
78761ff9 43 __u8 features;
2470900b
PF		 44 __u32 id;
45 __u32 serial;
20a3ce7e 46 unsigned char high_speed;
e31e3832
PF		 47 __u8 battery_capacity;
48 __u8 power_raw;
49 __u8 ps_connected;
59d2334a
PF		 50 struct power_supply battery;
51 struct power_supply ac;
d13f5454
PF		 52 __u8 led_selector;
53 struct led_classdev *leds[4];
ca2dcd40
BN		 54};
55
e31e3832
PF		 56/*percent of battery capacity for Graphire
57 8th value means AC online and show 100% capacity */
58static unsigned short batcap_gr[8] = { 1, 15, 25, 35, 50, 70, 100, 100 };
4202f1de
PF		 59/*percent of battery capacity for Intuos4 WL, AC has a separate bit*/
60static unsigned short batcap_i4[8] = { 1, 15, 30, 45, 60, 70, 85, 100 };
59d2334a
PF		 61
62static enum power_supply_property wacom_battery_props[] = {
63 POWER_SUPPLY_PROP_PRESENT,
73db8813
JF		 64 POWER_SUPPLY_PROP_CAPACITY,
65 POWER_SUPPLY_PROP_SCOPE,
59d2334a
PF		 66};
67
68static enum power_supply_property wacom_ac_props[] = {
69 POWER_SUPPLY_PROP_PRESENT,
73db8813
JF		 70 POWER_SUPPLY_PROP_ONLINE,
71 POWER_SUPPLY_PROP_SCOPE,
59d2334a
PF		 72};
73
e3c399ee
PF		 74static void wacom_scramble(__u8 *image)
75{
76 __u16 mask;
77 __u16 s1;
78 __u16 s2;
79 __u16 r1 ;
80 __u16 r2 ;
81 __u16 r;
82 __u8 buf[256];
83 int i, w, x, y, z;
84
85 for (x = 0; x < 32; x++) {
86 for (y = 0; y < 8; y++)
87 buf[(8 * x) + (7 - y)] = image[(8 * x) + y];
88 }
89
90 /* Change 76543210 into GECA6420 as required by Intuos4 WL
91 * HGFEDCBA HFDB7531
92 */
93 for (x = 0; x < 4; x++) {
94 for (y = 0; y < 4; y++) {
95 for (z = 0; z < 8; z++) {
96 mask = 0x0001;
97 r1 = 0;
98 r2 = 0;
99 i = (x << 6) + (y << 4) + z;
100 s1 = buf[i];
101 s2 = buf[i+8];
102 for (w = 0; w < 8; w++) {
103 r1 |= (s1 & mask);
104 r2 |= (s2 & mask);
105 s1 <<= 1;
106 s2 <<= 1;
107 mask <<= 2;
108 }
109 r = r1 | (r2 << 1);
110 i = (x << 6) + (y << 4) + (z << 1);
111 image[i] = 0xFF & r;
112 image[i+1] = (0xFF00 & r) >> 8;
113 }
114 }
115 }
116}
117
118static void wacom_set_image(struct hid_device *hdev, const char *image,
119 __u8 icon_no)
120{
121 __u8 rep_data[68];
122 __u8 p[256];
123 int ret, i, j;
124
125 for (i = 0; i < 256; i++)
126 p[i] = image[i];
127
128 rep_data[0] = WAC_CMD_ICON_START_STOP;
129 rep_data[1] = 0;
130 ret = hdev->hid_output_raw_report(hdev, rep_data, 2,
131 HID_FEATURE_REPORT);
132 if (ret < 0)
133 goto err;
134
135 rep_data[0] = WAC_CMD_ICON_TRANSFER;
136 rep_data[1] = icon_no & 0x07;
137
138 wacom_scramble(p);
139
140 for (i = 0; i < 4; i++) {
141 for (j = 0; j < 64; j++)
142 rep_data[j + 3] = p[(i << 6) + j];
143
144 rep_data[2] = i;
145 ret = hdev->hid_output_raw_report(hdev, rep_data, 67,
146 HID_FEATURE_REPORT);
147 }
148
149 rep_data[0] = WAC_CMD_ICON_START_STOP;
150 rep_data[1] = 0;
151
152 ret = hdev->hid_output_raw_report(hdev, rep_data, 2,
153 HID_FEATURE_REPORT);
154
155err:
156 return;
157}
158
d13f5454
PF		 159static void wacom_leds_set_brightness(struct led_classdev *led_dev,
160 enum led_brightness value)
161{
162 struct device *dev = led_dev->dev->parent;
163 struct hid_device *hdev;
164 struct wacom_data *wdata;
165 unsigned char *buf;
166 __u8 led = 0;
167 int i;
168
169 hdev = container_of(dev, struct hid_device, dev);
170 wdata = hid_get_drvdata(hdev);
171 for (i = 0; i < 4; ++i) {
172 if (wdata->leds[i] == led_dev)
173 wdata->led_selector = i;
174 }
175
176 led = wdata->led_selector | 0x04;
177 buf = kzalloc(9, GFP_KERNEL);
178 if (buf) {
179 buf[0] = WAC_CMD_LED_CONTROL;
180 buf[1] = led;
530a76c1
PF		 181 buf[2] = value >> 2;
182 buf[3] = value;
e3c399ee
PF		 183 /* use fixed brightness for OLEDs */
184 buf[4] = 0x08;
d13f5454
PF		 185 hdev->hid_output_raw_report(hdev, buf, 9, HID_FEATURE_REPORT);
186 kfree(buf);
187 }
188
189 return;
190}
191
192static enum led_brightness wacom_leds_get_brightness(struct led_classdev *led_dev)
193{
194 struct wacom_data *wdata;
195 struct device *dev = led_dev->dev->parent;
196 int value = 0;
197 int i;
198
199 wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));
200
201 for (i = 0; i < 4; ++i) {
202 if (wdata->leds[i] == led_dev) {
203 value = wdata->leds[i]->brightness;
204 break;
205 }
206 }
207
208 return value;
209}
210
211
212static int wacom_initialize_leds(struct hid_device *hdev)
213{
214 struct wacom_data *wdata = hid_get_drvdata(hdev);
215 struct led_classdev *led;
216 struct device *dev = &hdev->dev;
217 size_t namesz = strlen(dev_name(dev)) + 12;
218 char *name;
219 int i, ret;
220
221 wdata->led_selector = 0;
222
223 for (i = 0; i < 4; i++) {
224 led = kzalloc(sizeof(struct led_classdev) + namesz, GFP_KERNEL);
225 if (!led) {
226 hid_warn(hdev,
227 "can't allocate memory for LED selector\n");
228 ret = -ENOMEM;
229 goto err;
230 }
231
232 name = (void *)&led[1];
233 snprintf(name, namesz, "%s:selector:%d", dev_name(dev), i);
234 led->name = name;
235 led->brightness = 0;
236 led->max_brightness = 127;
237 led->brightness_get = wacom_leds_get_brightness;
238 led->brightness_set = wacom_leds_set_brightness;
239
240 wdata->leds[i] = led;
241
242 ret = led_classdev_register(dev, wdata->leds[i]);
243
244 if (ret) {
245 wdata->leds[i] = NULL;
246 kfree(led);
247 hid_warn(hdev, "can't register LED\n");
248 goto err;
249 }
250 }
251
252err:
253 return ret;
254}
255
256static void wacom_destroy_leds(struct hid_device *hdev)
257{
258 struct wacom_data *wdata = hid_get_drvdata(hdev);
259 struct led_classdev *led;
260 int i;
261
262 for (i = 0; i < 4; ++i) {
263 if (wdata->leds[i]) {
264 led = wdata->leds[i];
265 wdata->leds[i] = NULL;
266 led_classdev_unregister(led);
267 kfree(led);
268 }
269 }
270
271}
272
59d2334a
PF		 273static int wacom_battery_get_property(struct power_supply *psy,
274 enum power_supply_property psp,
275 union power_supply_propval *val)
276{
277 struct wacom_data *wdata = container_of(psy,
278 struct wacom_data, battery);
59d2334a
PF		 279 int ret = 0;
280
281 switch (psp) {
282 case POWER_SUPPLY_PROP_PRESENT:
283 val->intval = 1;
284 break;
73db8813
JF		 285 case POWER_SUPPLY_PROP_SCOPE:
286 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
287 break;
59d2334a 288 case POWER_SUPPLY_PROP_CAPACITY:
e31e3832 289 val->intval = wdata->battery_capacity;
59d2334a
PF		 290 break;
291 default:
292 ret = -EINVAL;
293 break;
294 }
295 return ret;
296}
297
298static int wacom_ac_get_property(struct power_supply *psy,
299 enum power_supply_property psp,
300 union power_supply_propval *val)
301{
302 struct wacom_data *wdata = container_of(psy, struct wacom_data, ac);
59d2334a
PF		 303 int ret = 0;
304
305 switch (psp) {
306 case POWER_SUPPLY_PROP_PRESENT:
307 /* fall through */
308 case POWER_SUPPLY_PROP_ONLINE:
e31e3832 309 val->intval = wdata->ps_connected;
59d2334a 310 break;
73db8813
JF		 311 case POWER_SUPPLY_PROP_SCOPE:
312 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
313 break;
59d2334a
PF		 314 default:
315 ret = -EINVAL;
316 break;
317 }
318 return ret;
319}
59d2334a 320
be4925b0 321static void wacom_set_features(struct hid_device *hdev, u8 speed)
06c7c313 322{
20a3ce7e 323 struct wacom_data *wdata = hid_get_drvdata(hdev);
06c7c313 324 int limit, ret;
d70a2ffe 325 __u8 rep_data[2];
06c7c313 326
d70a2ffe
PF		 327 switch (hdev->product) {
328 case USB_DEVICE_ID_WACOM_GRAPHIRE_BLUETOOTH:
329 rep_data[0] = 0x03 ; rep_data[1] = 0x00;
06c7c313
PF		 330 limit = 3;
331 do {
332 ret = hdev->hid_output_raw_report(hdev, rep_data, 2,
333 HID_FEATURE_REPORT);
334 } while (ret < 0 && limit-- > 0);
335
20a3ce7e 336 if (ret >= 0) {
d70a2ffe
PF		 337 if (speed == 0)
338 rep_data[0] = 0x05;
339 else
340 rep_data[0] = 0x06;
341
342 rep_data[1] = 0x00;
343 limit = 3;
344 do {
345 ret = hdev->hid_output_raw_report(hdev,
346 rep_data, 2, HID_FEATURE_REPORT);
347 } while (ret < 0 && limit-- > 0);
348
349 if (ret >= 0) {
350 wdata->high_speed = speed;
351 return;
352 }
20a3ce7e 353 }
d70a2ffe
PF		 354
355 /*
356 * Note that if the raw queries fail, it's not a hard failure
357 * and it is safe to continue
358 */
359 hid_warn(hdev, "failed to poke device, command %d, err %d\n",
360 rep_data[0], ret);
361 break;
362 case USB_DEVICE_ID_WACOM_INTUOS4_BLUETOOTH:
363 if (speed == 1)
364 wdata->features &= ~0x20;
365 else
366 wdata->features |= 0x20;
367
368 rep_data[0] = 0x03;
369 rep_data[1] = wdata->features;
370
371 ret = hdev->hid_output_raw_report(hdev, rep_data, 2,
372 HID_FEATURE_REPORT);
373 if (ret >= 0)
374 wdata->high_speed = speed;
375 break;
06c7c313
PF		 376 }
377
06c7c313
PF		 378 return;
379}
380
20a3ce7e
PF		 381static ssize_t wacom_show_speed(struct device *dev,
382 struct device_attribute
383 *attr, char *buf)
384{
385 struct wacom_data *wdata = dev_get_drvdata(dev);
386
387 return snprintf(buf, PAGE_SIZE, "%i\n", wdata->high_speed);
388}
389
390static ssize_t wacom_store_speed(struct device *dev,
391 struct device_attribute *attr,
392 const char *buf, size_t count)
393{
394 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
395 int new_speed;
396
397 if (sscanf(buf, "%1d", &new_speed ) != 1)
398 return -EINVAL;
399
400 if (new_speed == 0 || new_speed == 1) {
d70a2ffe 401 wacom_set_features(hdev, new_speed);
20a3ce7e
PF		 402 return strnlen(buf, PAGE_SIZE);
403 } else
404 return -EINVAL;
405}
406
edd2126a 407static DEVICE_ATTR(speed, S_IRUGO | S_IWUSR | S_IWGRP,
20a3ce7e
PF		 408 wacom_show_speed, wacom_store_speed);
409
e3c399ee
PF		 410#define WACOM_STORE(OLED_ID) \
411static ssize_t wacom_oled##OLED_ID##_store(struct device *dev, \
412 struct device_attribute *attr, \
413 const char *buf, size_t count) \
414{ \
415 struct hid_device *hdev = container_of(dev, struct hid_device, \
416 dev); \
417 \
418 if (count != 256) \
419 return -EINVAL; \
420 \
421 wacom_set_image(hdev, buf, OLED_ID); \
422 \
423 return count; \
424} \
425 \
426static DEVICE_ATTR(oled##OLED_ID##_img, S_IWUSR | S_IWGRP, NULL, \
427 wacom_oled##OLED_ID##_store)
428
429WACOM_STORE(0);
430WACOM_STORE(1);
431WACOM_STORE(2);
432WACOM_STORE(3);
433WACOM_STORE(4);
434WACOM_STORE(5);
435WACOM_STORE(6);
436WACOM_STORE(7);
437
f6b7efc1
PF		 438static int wacom_gr_parse_report(struct hid_device *hdev,
439 struct wacom_data *wdata,
440 struct input_dev *input, unsigned char *data)
ca2dcd40 441{
ca2dcd40
BN		 442 int tool, x, y, rw;
443
ca2dcd40 444 tool = 0;
ca2dcd40
BN		 445 /* Get X & Y positions */
446 x = le16_to_cpu(*(__le16 *) &data[2]);
447 y = le16_to_cpu(*(__le16 *) &data[4]);
448
449 /* Get current tool identifier */
450 if (data[1] & 0x90) { /* If pen is in the in/active area */
451 switch ((data[1] >> 5) & 3) {
452 case 0: /* Pen */
453 tool = BTN_TOOL_PEN;
454 break;
455
456 case 1: /* Rubber */
457 tool = BTN_TOOL_RUBBER;
458 break;
459
460 case 2: /* Mouse with wheel */
461 case 3: /* Mouse without wheel */
462 tool = BTN_TOOL_MOUSE;
463 break;
464 }
465
466 /* Reset tool if out of active tablet area */
467 if (!(data[1] & 0x10))
468 tool = 0;
469 }
470
471 /* If tool changed, notify input subsystem */
472 if (wdata->tool != tool) {
473 if (wdata->tool) {
474 /* Completely reset old tool state */
475 if (wdata->tool == BTN_TOOL_MOUSE) {
476 input_report_key(input, BTN_LEFT, 0);
477 input_report_key(input, BTN_RIGHT, 0);
478 input_report_key(input, BTN_MIDDLE, 0);
479 input_report_abs(input, ABS_DISTANCE,
987a6c02 480 input_abs_get_max(input, ABS_DISTANCE));
ca2dcd40
BN		 481 } else {
482 input_report_key(input, BTN_TOUCH, 0);
483 input_report_key(input, BTN_STYLUS, 0);
484 input_report_key(input, BTN_STYLUS2, 0);
485 input_report_abs(input, ABS_PRESSURE, 0);
486 }
487 input_report_key(input, wdata->tool, 0);
488 input_sync(input);
489 }
490 wdata->tool = tool;
491 if (tool)
492 input_report_key(input, tool, 1);
493 }
494
495 if (tool) {
496 input_report_abs(input, ABS_X, x);
497 input_report_abs(input, ABS_Y, y);
498
499 switch ((data[1] >> 5) & 3) {
500 case 2: /* Mouse with wheel */
501 input_report_key(input, BTN_MIDDLE, data[1] & 0x04);
502 rw = (data[6] & 0x01) ? -1 :
503 (data[6] & 0x02) ? 1 : 0;
504 input_report_rel(input, REL_WHEEL, rw);
505 /* fall through */
506
507 case 3: /* Mouse without wheel */
508 input_report_key(input, BTN_LEFT, data[1] & 0x01);
509 input_report_key(input, BTN_RIGHT, data[1] & 0x02);
510 /* Compute distance between mouse and tablet */
511 rw = 44 - (data[6] >> 2);
512 if (rw < 0)
513 rw = 0;
514 else if (rw > 31)
515 rw = 31;
516 input_report_abs(input, ABS_DISTANCE, rw);
517 break;
518
519 default:
520 input_report_abs(input, ABS_PRESSURE,
521 data[6] | (((__u16) (data[1] & 0x08)) << 5));
522 input_report_key(input, BTN_TOUCH, data[1] & 0x01);
523 input_report_key(input, BTN_STYLUS, data[1] & 0x02);
524 input_report_key(input, BTN_STYLUS2, (tool == BTN_TOOL_PEN) && data[1] & 0x04);
525 break;
526 }
527
528 input_sync(input);
529 }
530
531 /* Report the state of the two buttons at the top of the tablet
532 * as two extra fingerpad keys (buttons 4 & 5). */
533 rw = data[7] & 0x03;
534 if (rw != wdata->butstate) {
535 wdata->butstate = rw;
536 input_report_key(input, BTN_0, rw & 0x02);
537 input_report_key(input, BTN_1, rw & 0x01);
0e253fdb 538 input_report_key(input, BTN_TOOL_FINGER, 0xf0);
ca2dcd40
BN		 539 input_event(input, EV_MSC, MSC_SERIAL, 0xf0);
540 input_sync(input);
541 }
542
e31e3832 543 /* Store current battery capacity and power supply state*/
59d2334a 544 rw = (data[7] >> 2 & 0x07);
e31e3832
PF		 545 if (rw != wdata->power_raw) {
546 wdata->power_raw = rw;
547 wdata->battery_capacity = batcap_gr[rw];
548 if (rw == 7)
549 wdata->ps_connected = 1;
550 else
551 wdata->ps_connected = 0;
552 }
ca2dcd40
BN		 553 return 1;
554}
78761ff9 555
6245bde2
PF		 556static void wacom_i4_parse_button_report(struct wacom_data *wdata,
557 struct input_dev *input, unsigned char *data)
558{
559 __u16 new_butstate;
7e503a37
PF		 560 __u8 new_whlstate;
561 __u8 sync = 0;
562
563 new_whlstate = data[1];
564 if (new_whlstate != wdata->whlstate) {
565 wdata->whlstate = new_whlstate;
566 if (new_whlstate & 0x80) {
567 input_report_key(input, BTN_TOUCH, 1);
568 input_report_abs(input, ABS_WHEEL, (new_whlstate & 0x7f));
569 input_report_key(input, BTN_TOOL_FINGER, 1);
570 } else {
571 input_report_key(input, BTN_TOUCH, 0);
572 input_report_abs(input, ABS_WHEEL, 0);
573 input_report_key(input, BTN_TOOL_FINGER, 0);
574 }
575 sync = 1;
576 }
6245bde2
PF		 577
578 new_butstate = (data[3] << 1) | (data[2] & 0x01);
579 if (new_butstate != wdata->butstate) {
580 wdata->butstate = new_butstate;
581 input_report_key(input, BTN_0, new_butstate & 0x001);
582 input_report_key(input, BTN_1, new_butstate & 0x002);
583 input_report_key(input, BTN_2, new_butstate & 0x004);
584 input_report_key(input, BTN_3, new_butstate & 0x008);
585 input_report_key(input, BTN_4, new_butstate & 0x010);
586 input_report_key(input, BTN_5, new_butstate & 0x020);
587 input_report_key(input, BTN_6, new_butstate & 0x040);
588 input_report_key(input, BTN_7, new_butstate & 0x080);
589 input_report_key(input, BTN_8, new_butstate & 0x100);
590 input_report_key(input, BTN_TOOL_FINGER, 1);
7e503a37
PF		 591 sync = 1;
592 }
593
594 if (sync) {
6245bde2
PF		 595 input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
596 input_event(input, EV_MSC, MSC_SERIAL, 0xffffffff);
597 input_sync(input);
598 }
599}
600
78761ff9
PF		 601static void wacom_i4_parse_pen_report(struct wacom_data *wdata,
602 struct input_dev *input, unsigned char *data)
603{
604 __u16 x, y, pressure;
e0829e9c 605 __u8 distance;
c653daba 606 __u8 tilt_x, tilt_y;
78761ff9
PF		 607
608 switch (data[1]) {
609 case 0x80: /* Out of proximity report */
78761ff9
PF		 610 input_report_key(input, BTN_TOUCH, 0);
611 input_report_abs(input, ABS_PRESSURE, 0);
693f45bb
PF		 612 input_report_key(input, BTN_STYLUS, 0);
613 input_report_key(input, BTN_STYLUS2, 0);
78761ff9 614 input_report_key(input, wdata->tool, 0);
2470900b
PF		 615 input_report_abs(input, ABS_MISC, 0);
616 input_event(input, EV_MSC, MSC_SERIAL, wdata->serial);
32db737f 617 wdata->tool = 0;
78761ff9
PF		 618 input_sync(input);
619 break;
620 case 0xC2: /* Tool report */
2470900b 621 wdata->id = ((data[2] << 4) | (data[3] >> 4) |
78761ff9 622 ((data[7] & 0x0f) << 20) |
2470900b
PF		 623 ((data[8] & 0xf0) << 12));
624 wdata->serial = ((data[3] & 0x0f) << 28) +
625 (data[4] << 20) + (data[5] << 12) +
626 (data[6] << 4) + (data[7] >> 4);
78761ff9 627
2470900b
PF		 628 switch (wdata->id) {
629 case 0x100802:
78761ff9
PF		 630 wdata->tool = BTN_TOOL_PEN;
631 break;
2470900b 632 case 0x10080A:
78761ff9
PF		 633 wdata->tool = BTN_TOOL_RUBBER;
634 break;
635 }
636 break;
637 default: /* Position/pressure report */
638 x = data[2] << 9 | data[3] << 1 | ((data[9] & 0x02) >> 1);
639 y = data[4] << 9 | data[5] << 1 | (data[9] & 0x01);
640 pressure = (data[6] << 3) | ((data[7] & 0xC0) >> 5)
641 | (data[1] & 0x01);
e0829e9c 642 distance = (data[9] >> 2) & 0x3f;
c653daba
PF		 643 tilt_x = ((data[7] << 1) & 0x7e) | (data[8] >> 7);
644 tilt_y = data[8] & 0x7f;
78761ff9
PF		 645
646 input_report_key(input, BTN_TOUCH, pressure > 1);
647
648 input_report_key(input, BTN_STYLUS, data[1] & 0x02);
649 input_report_key(input, BTN_STYLUS2, data[1] & 0x04);
650 input_report_key(input, wdata->tool, 1);
651 input_report_abs(input, ABS_X, x);
652 input_report_abs(input, ABS_Y, y);
653 input_report_abs(input, ABS_PRESSURE, pressure);
e0829e9c 654 input_report_abs(input, ABS_DISTANCE, distance);
c653daba
PF		 655 input_report_abs(input, ABS_TILT_X, tilt_x);
656 input_report_abs(input, ABS_TILT_Y, tilt_y);
2470900b
PF		 657 input_report_abs(input, ABS_MISC, wdata->id);
658 input_event(input, EV_MSC, MSC_SERIAL, wdata->serial);
659 input_report_key(input, wdata->tool, 1);
78761ff9
PF		 660 input_sync(input);
661 break;
662 }
663
664 return;
665}
666
667static void wacom_i4_parse_report(struct hid_device *hdev,
668 struct wacom_data *wdata,
669 struct input_dev *input, unsigned char *data)
670{
671 switch (data[0]) {
672 case 0x00: /* Empty report */
673 break;
674 case 0x02: /* Pen report */
675 wacom_i4_parse_pen_report(wdata, input, data);
676 break;
677 case 0x03: /* Features Report */
678 wdata->features = data[2];
679 break;
680 case 0x0C: /* Button report */
6245bde2 681 wacom_i4_parse_button_report(wdata, input, data);
78761ff9
PF		 682 break;
683 default:
684 hid_err(hdev, "Unknown report: %d,%d\n", data[0], data[1]);
685 break;
686 }
687}
688
f6b7efc1
PF		 689static int wacom_raw_event(struct hid_device *hdev, struct hid_report *report,
690 u8 *raw_data, int size)
691{
692 struct wacom_data *wdata = hid_get_drvdata(hdev);
693 struct hid_input *hidinput;
694 struct input_dev *input;
695 unsigned char *data = (unsigned char *) raw_data;
78761ff9 696 int i;
4202f1de 697 __u8 power_raw;
f6b7efc1
PF		 698
699 if (!(hdev->claimed & HID_CLAIMED_INPUT))
700 return 0;
701
702 hidinput = list_entry(hdev->inputs.next, struct hid_input, list);
703 input = hidinput->input;
704
78761ff9
PF		 705 switch (hdev->product) {
706 case USB_DEVICE_ID_WACOM_GRAPHIRE_BLUETOOTH:
163a6ae1
PF		 707 if (data[0] == 0x03) {
708 return wacom_gr_parse_report(hdev, wdata, input, data);
709 } else {
710 hid_err(hdev, "Unknown report: %d,%d size:%d\n",
711 data[0], data[1], size);
712 return 0;
713 }
78761ff9
PF		 714 break;
715 case USB_DEVICE_ID_WACOM_INTUOS4_BLUETOOTH:
716 i = 1;
717
718 switch (data[0]) {
719 case 0x04:
720 wacom_i4_parse_report(hdev, wdata, input, data + i);
721 i += 10;
722 /* fall through */
723 case 0x03:
724 wacom_i4_parse_report(hdev, wdata, input, data + i);
725 i += 10;
726 wacom_i4_parse_report(hdev, wdata, input, data + i);
4202f1de
PF		 727 power_raw = data[i+10];
728 if (power_raw != wdata->power_raw) {
729 wdata->power_raw = power_raw;
730 wdata->battery_capacity = batcap_i4[power_raw & 0x07];
731 wdata->ps_connected = power_raw & 0x08;
732 }
733
78761ff9
PF		 734 break;
735 default:
736 hid_err(hdev, "Unknown report: %d,%d size:%d\n",
737 data[0], data[1], size);
738 return 0;
739 }
740 }
741 return 1;
f6b7efc1 742}
ca2dcd40 743
3797ef6b
DH		 744static int wacom_input_mapped(struct hid_device *hdev, struct hid_input *hi,
745 struct hid_field *field, struct hid_usage *usage, unsigned long **bit,
746 int *max)
747{
748 struct input_dev *input = hi->input;
749
f6f12427
JK		 750 __set_bit(INPUT_PROP_POINTER, input->propbit);
751
3797ef6b
DH		 752 /* Basics */
753 input->evbit[0] |= BIT(EV_KEY) | BIT(EV_ABS) | BIT(EV_REL);
754
755 __set_bit(REL_WHEEL, input->relbit);
756
757 __set_bit(BTN_TOOL_PEN, input->keybit);
758 __set_bit(BTN_TOUCH, input->keybit);
759 __set_bit(BTN_STYLUS, input->keybit);
760 __set_bit(BTN_STYLUS2, input->keybit);
761 __set_bit(BTN_LEFT, input->keybit);
762 __set_bit(BTN_RIGHT, input->keybit);
763 __set_bit(BTN_MIDDLE, input->keybit);
764
765 /* Pad */
9a911da8 766 input_set_capability(input, EV_MSC, MSC_SERIAL);
3797ef6b
DH		 767
768 __set_bit(BTN_0, input->keybit);
769 __set_bit(BTN_1, input->keybit);
770 __set_bit(BTN_TOOL_FINGER, input->keybit);
771
772 /* Distance, rubber and mouse */
773 __set_bit(BTN_TOOL_RUBBER, input->keybit);
774 __set_bit(BTN_TOOL_MOUSE, input->keybit);
775
78761ff9
PF		 776 switch (hdev->product) {
777 case USB_DEVICE_ID_WACOM_GRAPHIRE_BLUETOOTH:
778 input_set_abs_params(input, ABS_X, 0, 16704, 4, 0);
779 input_set_abs_params(input, ABS_Y, 0, 12064, 4, 0);
780 input_set_abs_params(input, ABS_PRESSURE, 0, 511, 0, 0);
781 input_set_abs_params(input, ABS_DISTANCE, 0, 32, 0, 0);
782 break;
783 case USB_DEVICE_ID_WACOM_INTUOS4_BLUETOOTH:
7e503a37 784 __set_bit(ABS_WHEEL, input->absbit);
2c653e6b 785 __set_bit(ABS_MISC, input->absbit);
6245bde2
PF		 786 __set_bit(BTN_2, input->keybit);
787 __set_bit(BTN_3, input->keybit);
788 __set_bit(BTN_4, input->keybit);
789 __set_bit(BTN_5, input->keybit);
790 __set_bit(BTN_6, input->keybit);
791 __set_bit(BTN_7, input->keybit);
792 __set_bit(BTN_8, input->keybit);
7e503a37 793 input_set_abs_params(input, ABS_WHEEL, 0, 71, 0, 0);
78761ff9
PF		 794 input_set_abs_params(input, ABS_X, 0, 40640, 4, 0);
795 input_set_abs_params(input, ABS_Y, 0, 25400, 4, 0);
796 input_set_abs_params(input, ABS_PRESSURE, 0, 2047, 0, 0);
e0829e9c 797 input_set_abs_params(input, ABS_DISTANCE, 0, 63, 0, 0);
c653daba
PF		 798 input_set_abs_params(input, ABS_TILT_X, 0, 127, 0, 0);
799 input_set_abs_params(input, ABS_TILT_Y, 0, 127, 0, 0);
78761ff9
PF		 800 break;
801 }
3797ef6b
DH		 802
803 return 0;
804}
805
ca2dcd40
BN		 806static int wacom_probe(struct hid_device *hdev,
807 const struct hid_device_id *id)
808{
ca2dcd40
BN		 809 struct wacom_data *wdata;
810 int ret;
811
812 wdata = kzalloc(sizeof(*wdata), GFP_KERNEL);
813 if (wdata == NULL) {
4291ee30 814 hid_err(hdev, "can't alloc wacom descriptor\n");
ca2dcd40
BN		 815 return -ENOMEM;
816 }
817
818 hid_set_drvdata(hdev, wdata);
819
46a709b9 820 /* Parse the HID report now */
ca2dcd40
BN		 821 ret = hid_parse(hdev);
822 if (ret) {
4291ee30 823 hid_err(hdev, "parse failed\n");
ca2dcd40
BN		 824 goto err_free;
825 }
826
827 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
828 if (ret) {
4291ee30 829 hid_err(hdev, "hw start failed\n");
ca2dcd40
BN		 830 goto err_free;
831 }
832
20a3ce7e
PF		 833 ret = device_create_file(&hdev->dev, &dev_attr_speed);
834 if (ret)
4291ee30
JP		 835 hid_warn(hdev,
836 "can't create sysfs speed attribute err: %d\n", ret);
342f31e8 837
e3c399ee
PF		 838#define OLED_INIT(OLED_ID) \
839 do { \
840 ret = device_create_file(&hdev->dev, \
841 &dev_attr_oled##OLED_ID##_img); \
842 if (ret) \
843 hid_warn(hdev, \
844 "can't create sysfs oled attribute, err: %d\n", ret);\
845 } while (0)
846
847OLED_INIT(0);
848OLED_INIT(1);
849OLED_INIT(2);
850OLED_INIT(3);
851OLED_INIT(4);
852OLED_INIT(5);
853OLED_INIT(6);
854OLED_INIT(7);
855
d70a2ffe
PF		 856 wdata->features = 0;
857 wacom_set_features(hdev, 1);
858
859 if (hdev->product == USB_DEVICE_ID_WACOM_INTUOS4_BLUETOOTH) {
a72c5ddb 860 sprintf(hdev->name, "%s", "Wacom Intuos4 WL");
d13f5454
PF		 861 ret = wacom_initialize_leds(hdev);
862 if (ret) {
863 hid_warn(hdev,
864 "can't create led attribute, err: %d\n", ret);
865 goto destroy_leds;
866 }
78761ff9 867 }
46a709b9 868
59d2334a
PF		 869 wdata->battery.properties = wacom_battery_props;
870 wdata->battery.num_properties = ARRAY_SIZE(wacom_battery_props);
871 wdata->battery.get_property = wacom_battery_get_property;
872 wdata->battery.name = "wacom_battery";
873 wdata->battery.type = POWER_SUPPLY_TYPE_BATTERY;
874 wdata->battery.use_for_apm = 0;
46a709b9 875
35b4c01e 876
59d2334a
PF		 877 ret = power_supply_register(&hdev->dev, &wdata->battery);
878 if (ret) {
4291ee30
JP		 879 hid_warn(hdev, "can't create sysfs battery attribute, err: %d\n",
880 ret);
dde58cfc 881 goto err_battery;
59d2334a
PF		 882 }
883
d7cb3dbd
PF		 884 power_supply_powers(&wdata->battery, &hdev->dev);
885
59d2334a
PF		 886 wdata->ac.properties = wacom_ac_props;
887 wdata->ac.num_properties = ARRAY_SIZE(wacom_ac_props);
888 wdata->ac.get_property = wacom_ac_get_property;
889 wdata->ac.name = "wacom_ac";
890 wdata->ac.type = POWER_SUPPLY_TYPE_MAINS;
891 wdata->ac.use_for_apm = 0;
892
893 ret = power_supply_register(&hdev->dev, &wdata->ac);
894 if (ret) {
4291ee30
JP		 895 hid_warn(hdev,
896 "can't create ac battery attribute, err: %d\n", ret);
dde58cfc 897 goto err_ac;
59d2334a 898 }
d7cb3dbd
PF		 899
900 power_supply_powers(&wdata->ac, &hdev->dev);
ca2dcd40 901 return 0;
987a6c02 902
dde58cfc
DH		 903err_ac:
904 power_supply_unregister(&wdata->battery);
905err_battery:
906 device_remove_file(&hdev->dev, &dev_attr_speed);
907 hid_hw_stop(hdev);
d13f5454
PF		 908destroy_leds:
909 wacom_destroy_leds(hdev);
ca2dcd40
BN		 910err_free:
911 kfree(wdata);
912 return ret;
913}
914
915static void wacom_remove(struct hid_device *hdev)
916{
59d2334a 917 struct wacom_data *wdata = hid_get_drvdata(hdev);
d13f5454
PF		 918
919 wacom_destroy_leds(hdev);
e3c399ee
PF		 920 device_remove_file(&hdev->dev, &dev_attr_oled0_img);
921 device_remove_file(&hdev->dev, &dev_attr_oled1_img);
922 device_remove_file(&hdev->dev, &dev_attr_oled2_img);
923 device_remove_file(&hdev->dev, &dev_attr_oled3_img);
924 device_remove_file(&hdev->dev, &dev_attr_oled4_img);
925 device_remove_file(&hdev->dev, &dev_attr_oled5_img);
926 device_remove_file(&hdev->dev, &dev_attr_oled6_img);
927 device_remove_file(&hdev->dev, &dev_attr_oled7_img);
9086617e 928 device_remove_file(&hdev->dev, &dev_attr_speed);
ca2dcd40 929 hid_hw_stop(hdev);
59d2334a 930
59d2334a
PF		 931 power_supply_unregister(&wdata->battery);
932 power_supply_unregister(&wdata->ac);
ca2dcd40
BN		 933 kfree(hid_get_drvdata(hdev));
934}
935
936static const struct hid_device_id wacom_devices[] = {
937 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE_BLUETOOTH) },
78761ff9 938 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS4_BLUETOOTH) },
d5e0a06f 939
ca2dcd40
BN		 940 { }
941};
942MODULE_DEVICE_TABLE(hid, wacom_devices);
943
944static struct hid_driver wacom_driver = {
945 .name = "wacom",
946 .id_table = wacom_devices,
947 .probe = wacom_probe,
948 .remove = wacom_remove,
949 .raw_event = wacom_raw_event,
3797ef6b 950 .input_mapped = wacom_input_mapped,
ca2dcd40
BN		 951};
952
a24f423b 953static int __init wacom_init(void)
ca2dcd40
BN		 954{
955 int ret;
956
957 ret = hid_register_driver(&wacom_driver);
958 if (ret)
4291ee30 959 pr_err("can't register wacom driver\n");
ca2dcd40
BN		 960 return ret;
961}
962
a24f423b 963static void __exit wacom_exit(void)
ca2dcd40
BN		 964{
965 hid_unregister_driver(&wacom_driver);
966}
967
968module_init(wacom_init);
969module_exit(wacom_exit);
1fa2f722 970MODULE_DESCRIPTION("Driver for Wacom Graphire Bluetooth and Wacom Intuos4 WL");
ca2dcd40 971MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.284043 seconds and 5 git commands to generate.