2 * Copyright (c) 2016 Masaki Ota <masaki.ota@jp.alps.com>
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License as published by the Free
6 * Software Foundation; either version 2 of the License, or (at your option)
10 #include <linux/kernel.h>
11 #include <linux/hid.h>
12 #include <linux/input.h>
13 #include <linux/input/mt.h>
14 #include <linux/module.h>
15 #include <asm/unaligned.h>
18 /* ALPS Device Product ID */
19 #define HID_PRODUCT_ID_T3_BTNLESS 0xD0C0
20 #define HID_PRODUCT_ID_COSMO 0x1202
21 #define HID_PRODUCT_ID_U1_PTP_1 0x1207
22 #define HID_PRODUCT_ID_U1 0x1209
23 #define HID_PRODUCT_ID_U1_PTP_2 0x120A
24 #define HID_PRODUCT_ID_U1_DUAL 0x120B
25 #define HID_PRODUCT_ID_T4_BTNLESS 0x120C
27 #define DEV_SINGLEPOINT 0x01
28 #define DEV_DUALPOINT 0x02
30 #define U1_MOUSE_REPORT_ID 0x01 /* Mouse data ReportID */
31 #define U1_ABSOLUTE_REPORT_ID 0x03 /* Absolute data ReportID */
32 #define U1_FEATURE_REPORT_ID 0x05 /* Feature ReportID */
33 #define U1_SP_ABSOLUTE_REPORT_ID 0x06 /* Feature ReportID */
35 #define U1_FEATURE_REPORT_LEN 0x08 /* Feature Report Length */
36 #define U1_FEATURE_REPORT_LEN_ALL 0x0A
37 #define U1_CMD_REGISTER_READ 0xD1
38 #define U1_CMD_REGISTER_WRITE 0xD2
40 #define U1_DEVTYPE_SP_SUPPORT 0x10 /* SP Support */
41 #define U1_DISABLE_DEV 0x01
42 #define U1_TP_ABS_MODE 0x02
43 #define U1_SP_ABS_MODE 0x80
45 #define ADDRESS_U1_DEV_CTRL_1 0x00800040
46 #define ADDRESS_U1_DEVICE_TYP 0x00800043
47 #define ADDRESS_U1_NUM_SENS_X 0x00800047
48 #define ADDRESS_U1_NUM_SENS_Y 0x00800048
49 #define ADDRESS_U1_PITCH_SENS_X 0x00800049
50 #define ADDRESS_U1_PITCH_SENS_Y 0x0080004A
51 #define ADDRESS_U1_RESO_DWN_ABS 0x0080004E
52 #define ADDRESS_U1_PAD_BTN 0x00800052
53 #define ADDRESS_U1_SP_BTN 0x0080009F
60 * @input: pointer to the kernel input device
61 * @input2: pointer to the kernel input2 device
62 * @hdev: pointer to the struct hid_device
64 * @dev_ctrl: device control parameter
65 * @dev_type: device type
66 * @sen_line_num_x: number of sensor line of X
67 * @sen_line_num_y: number of sensor line of Y
68 * @pitch_x: sensor pitch of X
69 * @pitch_y: sensor pitch of Y
70 * @resolution: resolution
71 * @btn_info: button information
72 * @x_active_len_mm: active area length of X (mm)
73 * @y_active_len_mm: active area length of Y (mm)
74 * @x_max: maximum x coordinate value
75 * @y_max: maximum y coordinate value
76 * @btn_cnt: number of buttons
77 * @sp_btn_cnt: number of stick buttons
80 struct input_dev
*input
;
81 struct input_dev
*input2
;
82 struct hid_device
*hdev
;
101 static struct u1_dev
*priv
;
103 static int u1_read_write_register(struct hid_device
*hdev
, u32 address
,
104 u8
*read_val
, u8 write_val
, bool read_flag
)
111 input
= kzalloc(sizeof(u8
)*U1_FEATURE_REPORT_LEN
, GFP_KERNEL
);
115 readbuf
= kzalloc(sizeof(u8
)*U1_FEATURE_REPORT_LEN
, GFP_KERNEL
);
121 input
[0] = U1_FEATURE_REPORT_ID
;
123 input
[1] = U1_CMD_REGISTER_READ
;
126 input
[1] = U1_CMD_REGISTER_WRITE
;
127 input
[6] = write_val
;
130 put_unaligned_le32(address
, input
+ 2);
132 /* Calculate the checksum */
133 check_sum
= U1_FEATURE_REPORT_LEN_ALL
;
134 for (i
= 0; i
< U1_FEATURE_REPORT_LEN
- 1; i
++)
135 check_sum
+= input
[i
];
137 input
[7] = check_sum
;
138 ret
= hid_hw_raw_request(hdev
, U1_FEATURE_REPORT_ID
, input
,
139 sizeof(u8
)*U1_FEATURE_REPORT_LEN
, HID_FEATURE_REPORT
,
143 dev_err(&hdev
->dev
, "failed to read command (%d)\n", ret
);
148 ret
= hid_hw_raw_request(hdev
, U1_FEATURE_REPORT_ID
, readbuf
,
149 sizeof(u8
)*U1_FEATURE_REPORT_LEN
,
150 HID_FEATURE_REPORT
, HID_REQ_GET_REPORT
);
153 dev_err(&hdev
->dev
, "failed read register (%d)\n", ret
);
157 *read_val
= readbuf
[6];
170 static int alps_raw_event(struct hid_device
*hdev
,
171 struct hid_report
*report
, u8
*data
, int size
)
173 int x
[MAX_TOUCHES
], y
[MAX_TOUCHES
], z
[MAX_TOUCHES
];
174 int i
, left
, right
, middle
;
175 short sp_x
, sp_y
, sp_z
;
176 struct u1_dev
*hdata
= hid_get_drvdata(hdev
);
179 case U1_MOUSE_REPORT_ID
:
181 case U1_FEATURE_REPORT_ID
:
183 case U1_ABSOLUTE_REPORT_ID
:
184 for (i
= 0; i
< MAX_TOUCHES
; i
++) {
185 x
[i
] = (data
[3+(5*i
)] | (data
[4+(5*i
)] << 8));
186 y
[i
] = (data
[5+(5*i
)] | (data
[6+(5*i
)] << 8));
187 z
[i
] = data
[7+(5*i
)] & 0x7F;
188 left
= data
[1] & 0x1;
189 right
= (data
[1] & 0x2) >> 1;
190 middle
= (data
[1] & 0x4) >> 2;
192 input_mt_slot(hdata
->input
, i
);
195 input_mt_report_slot_state(hdata
->input
,
198 input_mt_report_slot_state(hdata
->input
,
203 input_event(hdata
->input
, EV_ABS
,
204 ABS_MT_POSITION_X
, x
[i
]);
205 input_event(hdata
->input
, EV_ABS
,
206 ABS_MT_POSITION_Y
, y
[i
]);
207 input_event(hdata
->input
, EV_ABS
,
208 ABS_MT_PRESSURE
, z
[i
]);
211 input_mt_sync_frame(hdata
->input
);
212 input_sync(hdata
->input
);
214 input_event(hdata
->input
, EV_KEY
, BTN_LEFT
, left
);
215 input_event(hdata
->input
, EV_KEY
, BTN_RIGHT
, right
);
216 input_event(hdata
->input
, EV_KEY
, BTN_MIDDLE
, middle
);
220 case U1_SP_ABSOLUTE_REPORT_ID
:
221 sp_x
= (data
[2] | (data
[3] << 8));
222 sp_y
= (data
[4] | (data
[5] << 8));
223 sp_z
= (data
[6] | data
[7]) & 0x7FFF;
224 left
= data
[1] & 0x1;
225 right
= (data
[1] & 0x2) >> 1;
226 middle
= (data
[1] & 0x4) >> 2;
231 input_event(priv
->input2
, EV_REL
, REL_X
, sp_x
);
232 input_event(priv
->input2
, EV_REL
, REL_Y
, sp_y
);
234 input_event(priv
->input2
, EV_KEY
, BTN_LEFT
, left
);
235 input_event(priv
->input2
, EV_KEY
, BTN_RIGHT
, right
);
236 input_event(priv
->input2
, EV_KEY
, BTN_MIDDLE
, middle
);
238 input_sync(priv
->input2
);
247 static int alps_post_reset(struct hid_device
*hdev
)
249 return u1_read_write_register(hdev
, ADDRESS_U1_DEV_CTRL_1
,
250 NULL
, U1_TP_ABS_MODE
, false);
253 static int alps_post_resume(struct hid_device
*hdev
)
255 return u1_read_write_register(hdev
, ADDRESS_U1_DEV_CTRL_1
,
256 NULL
, U1_TP_ABS_MODE
, false);
258 #endif /* CONFIG_PM */
260 static int alps_input_configured(struct hid_device
*hdev
, struct hid_input
*hi
)
262 struct u1_dev
*data
= hid_get_drvdata(hdev
);
263 struct input_dev
*input
= hi
->input
, *input2
;
264 struct u1_dev devInfo
;
268 /* Check device product ID */
269 switch (hdev
->product
) {
270 case HID_PRODUCT_ID_U1
:
271 case HID_PRODUCT_ID_U1_DUAL
:
279 hid_dbg(hdev
, "Opening low level driver\n");
280 ret
= hid_hw_open(hdev
);
284 /* Allow incoming hid reports */
285 hid_device_io_start(hdev
);
287 /* Device initialization */
288 ret
= u1_read_write_register(hdev
, ADDRESS_U1_DEV_CTRL_1
,
289 &devInfo
.dev_ctrl
, 0, true);
291 dev_err(&hdev
->dev
, "failed U1_DEV_CTRL_1 (%d)\n", ret
);
295 devInfo
.dev_ctrl
&= ~U1_DISABLE_DEV
;
296 devInfo
.dev_ctrl
|= U1_TP_ABS_MODE
;
297 ret
= u1_read_write_register(hdev
, ADDRESS_U1_DEV_CTRL_1
,
298 NULL
, devInfo
.dev_ctrl
, false);
300 dev_err(&hdev
->dev
, "failed to change TP mode (%d)\n", ret
);
304 ret
= u1_read_write_register(hdev
, ADDRESS_U1_NUM_SENS_X
,
305 &devInfo
.sen_line_num_x
, 0, true);
307 dev_err(&hdev
->dev
, "failed U1_NUM_SENS_X (%d)\n", ret
);
311 ret
= u1_read_write_register(hdev
, ADDRESS_U1_NUM_SENS_Y
,
312 &devInfo
.sen_line_num_y
, 0, true);
314 dev_err(&hdev
->dev
, "failed U1_NUM_SENS_Y (%d)\n", ret
);
318 ret
= u1_read_write_register(hdev
, ADDRESS_U1_PITCH_SENS_X
,
319 &devInfo
.pitch_x
, 0, true);
321 dev_err(&hdev
->dev
, "failed U1_PITCH_SENS_X (%d)\n", ret
);
325 ret
= u1_read_write_register(hdev
, ADDRESS_U1_PITCH_SENS_Y
,
326 &devInfo
.pitch_y
, 0, true);
328 dev_err(&hdev
->dev
, "failed U1_PITCH_SENS_Y (%d)\n", ret
);
332 ret
= u1_read_write_register(hdev
, ADDRESS_U1_RESO_DWN_ABS
,
333 &devInfo
.resolution
, 0, true);
335 dev_err(&hdev
->dev
, "failed U1_RESO_DWN_ABS (%d)\n", ret
);
339 ret
= u1_read_write_register(hdev
, ADDRESS_U1_PAD_BTN
,
340 &devInfo
.btn_info
, 0, true);
342 dev_err(&hdev
->dev
, "failed U1_PAD_BTN (%d)\n", ret
);
346 /* Check StickPointer device */
347 ret
= u1_read_write_register(hdev
, ADDRESS_U1_DEVICE_TYP
,
348 &devInfo
.dev_type
, 0, true);
350 dev_err(&hdev
->dev
, "failed U1_DEVICE_TYP (%d)\n", ret
);
354 devInfo
.x_active_len_mm
=
355 (devInfo
.pitch_x
* (devInfo
.sen_line_num_x
- 1)) / 10;
356 devInfo
.y_active_len_mm
=
357 (devInfo
.pitch_y
* (devInfo
.sen_line_num_y
- 1)) / 10;
360 (devInfo
.resolution
<< 2) * (devInfo
.sen_line_num_x
- 1);
362 (devInfo
.resolution
<< 2) * (devInfo
.sen_line_num_y
- 1);
364 __set_bit(EV_ABS
, input
->evbit
);
365 input_set_abs_params(input
, ABS_MT_POSITION_X
, 1, devInfo
.x_max
, 0, 0);
366 input_set_abs_params(input
, ABS_MT_POSITION_Y
, 1, devInfo
.y_max
, 0, 0);
368 if (devInfo
.x_active_len_mm
&& devInfo
.y_active_len_mm
) {
369 res_x
= (devInfo
.x_max
- 1) / devInfo
.x_active_len_mm
;
370 res_y
= (devInfo
.y_max
- 1) / devInfo
.y_active_len_mm
;
372 input_abs_set_res(input
, ABS_MT_POSITION_X
, res_x
);
373 input_abs_set_res(input
, ABS_MT_POSITION_Y
, res_y
);
376 input_set_abs_params(input
, ABS_MT_PRESSURE
, 0, 64, 0, 0);
378 input_mt_init_slots(input
, MAX_TOUCHES
, INPUT_MT_POINTER
);
380 __set_bit(EV_KEY
, input
->evbit
);
381 if ((devInfo
.btn_info
& 0x0F) == (devInfo
.btn_info
& 0xF0) >> 4) {
382 devInfo
.btn_cnt
= (devInfo
.btn_info
& 0x0F);
386 __set_bit(INPUT_PROP_BUTTONPAD
, input
->propbit
);
389 for (i
= 0; i
< devInfo
.btn_cnt
; i
++)
390 __set_bit(BTN_LEFT
+ i
, input
->keybit
);
393 /* Stick device initialization */
394 if (devInfo
.dev_type
& U1_DEVTYPE_SP_SUPPORT
) {
396 priv
= kzalloc(sizeof(struct u1_dev
), GFP_KERNEL
);
398 hid_device_io_stop(hdev
);
403 input2
= input_allocate_device();
405 input_free_device(input2
);
409 priv
->input2
= input2
;
411 devInfo
.dev_ctrl
|= U1_SP_ABS_MODE
;
412 ret
= u1_read_write_register(hdev
, ADDRESS_U1_DEV_CTRL_1
,
413 NULL
, devInfo
.dev_ctrl
, false);
415 dev_err(&hdev
->dev
, "failed SP mode (%d)\n", ret
);
416 input_free_device(input2
);
420 ret
= u1_read_write_register(hdev
, ADDRESS_U1_SP_BTN
,
421 &devInfo
.sp_btn_info
, 0, true);
423 dev_err(&hdev
->dev
, "failed U1_SP_BTN (%d)\n", ret
);
424 input_free_device(input2
);
428 input2
->phys
= input
->phys
;
429 input2
->name
= "DualPoint Stick";
430 input2
->id
.bustype
= BUS_I2C
;
431 input2
->id
.vendor
= input
->id
.vendor
;
432 input2
->id
.product
= input
->id
.product
;
433 input2
->id
.version
= input
->id
.version
;
434 input2
->dev
.parent
= input
->dev
.parent
;
436 __set_bit(EV_KEY
, input2
->evbit
);
437 devInfo
.sp_btn_cnt
= (devInfo
.sp_btn_info
& 0x0F);
438 for (i
= 0; i
< devInfo
.sp_btn_cnt
; i
++)
439 __set_bit(BTN_LEFT
+ i
, input2
->keybit
);
441 __set_bit(EV_REL
, input2
->evbit
);
442 __set_bit(REL_X
, input2
->relbit
);
443 __set_bit(REL_Y
, input2
->relbit
);
444 __set_bit(INPUT_PROP_POINTER
, input2
->propbit
);
445 __set_bit(INPUT_PROP_POINTING_STICK
, input2
->propbit
);
447 if (input_register_device(priv
->input2
)) {
448 input_free_device(input2
);
454 hid_device_io_stop(hdev
);
459 static int alps_input_mapping(struct hid_device
*hdev
,
460 struct hid_input
*hi
, struct hid_field
*field
,
461 struct hid_usage
*usage
, unsigned long **bit
, int *max
)
466 static int alps_probe(struct hid_device
*hdev
, const struct hid_device_id
*id
)
468 struct u1_dev
*data
= NULL
;
471 data
= devm_kzalloc(&hdev
->dev
, sizeof(struct u1_dev
), GFP_KERNEL
);
476 hid_set_drvdata(hdev
, data
);
478 hdev
->quirks
|= HID_QUIRK_NO_INIT_REPORTS
;
480 ret
= hid_parse(hdev
);
482 hid_err(hdev
, "parse failed\n");
486 ret
= hid_hw_start(hdev
, HID_CONNECT_DEFAULT
);
488 hid_err(hdev
, "hw start failed\n");
495 static void alps_remove(struct hid_device
*hdev
)
501 static const struct hid_device_id alps_id
[] = {
502 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_ANY
,
503 USB_VENDOR_ID_ALPS_JP
, HID_ANY_ID
) },
506 MODULE_DEVICE_TABLE(hid
, alps_id
);
508 static struct hid_driver alps_driver
= {
512 .remove
= alps_remove
,
513 .raw_event
= alps_raw_event
,
514 .input_mapping
= alps_input_mapping
,
515 .input_configured
= alps_input_configured
,
517 .resume
= alps_post_resume
,
518 .reset_resume
= alps_post_reset
,
522 module_hid_driver(alps_driver
);
524 MODULE_AUTHOR("Masaki Ota <masaki.ota@jp.alps.com>");
525 MODULE_DESCRIPTION("ALPS HID driver");
526 MODULE_LICENSE("GPL");