1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2020, 2022 Vladimir Kondratyev <[email protected]>
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 */
27
28 /*
29 * Elan I2C Touchpad driver. Based on Linux driver.
30 * https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/tree/drivers/input/mouse/elan_i2c_core.c
31 */
32
33 #include <sys/cdefs.h>
34 #include <sys/param.h>
35 #include <sys/bus.h>
36 #include <sys/endian.h>
37 #include <sys/kernel.h>
38 #include <sys/lock.h>
39 #include <sys/malloc.h>
40 #include <sys/module.h>
41 #include <sys/mutex.h>
42 #include <sys/sysctl.h>
43 #include <sys/systm.h>
44
45 #include <dev/evdev/evdev.h>
46 #include <dev/evdev/input.h>
47
48 #include <dev/iicbus/iic.h>
49 #include <dev/iicbus/iicbus.h>
50
51 #define HID_DEBUG_VAR ietp_debug
52 #include <dev/hid/hid.h>
53 #include <dev/hid/hidbus.h>
54 #include <dev/hid/hidquirk.h>
55
56 #ifdef HID_DEBUG
57 static SYSCTL_NODE(_hw_hid, OID_AUTO, ietp, CTLFLAG_RW, 0,
58 "Elantech Touchpad");
59 static int ietp_debug = 1;
60 SYSCTL_INT(_hw_hid_ietp, OID_AUTO, debug, CTLFLAG_RWTUN,
61 &ietp_debug, 1, "Debug level");
62 #endif
63
64 #define IETP_PATTERN 0x0100
65 #define IETP_UNIQUEID 0x0101
66 #define IETP_FW_VERSION 0x0102
67 #define IETP_IC_TYPE 0x0103
68 #define IETP_OSM_VERSION 0x0103
69 #define IETP_NSM_VERSION 0x0104
70 #define IETP_TRACENUM 0x0105
71 #define IETP_MAX_X_AXIS 0x0106
72 #define IETP_MAX_Y_AXIS 0x0107
73 #define IETP_RESOLUTION 0x0108
74 #define IETP_PRESSURE 0x010A
75
76 #define IETP_CONTROL 0x0300
77 #define IETP_CTRL_ABSOLUTE 0x0001
78 #define IETP_CTRL_STANDARD 0x0000
79
80 #define IETP_REPORT_LEN_LO 32
81 #define IETP_REPORT_LEN_HI 37
82 #define IETP_MAX_FINGERS 5
83
84 #define IETP_REPORT_ID_LO 0x5D
85 #define IETP_REPORT_ID_HI 0x60
86
87 #define IETP_TOUCH_INFO 1
88 #define IETP_FINGER_DATA 2
89 #define IETP_FINGER_DATA_LEN 5
90 #define IETP_HOVER_INFO 28
91 #define IETP_WH_DATA 31
92
93 #define IETP_TOUCH_LMB (1 << 0)
94 #define IETP_TOUCH_RMB (1 << 1)
95 #define IETP_TOUCH_MMB (1 << 2)
96
97 #define IETP_MAX_PRESSURE 255
98 #define IETP_FWIDTH_REDUCE 90
99 #define IETP_FINGER_MAX_WIDTH 15
100 #define IETP_PRESSURE_BASE 25
101
102 struct ietp_softc {
103 device_t dev;
104
105 struct evdev_dev *evdev;
106 uint8_t report_id;
107 hid_size_t report_len;
108
109 uint16_t product_id;
110 uint16_t ic_type;
111
112 int32_t pressure_base;
113 uint16_t max_x;
114 uint16_t max_y;
115 uint16_t trace_x;
116 uint16_t trace_y;
117 uint16_t res_x; /* dots per mm */
118 uint16_t res_y;
119 bool hi_precision;
120 bool is_clickpad;
121 bool has_3buttons;
122 };
123
124 static evdev_open_t ietp_ev_open;
125 static evdev_close_t ietp_ev_close;
126 static hid_intr_t ietp_intr;
127
128 static int ietp_probe(struct ietp_softc *);
129 static int ietp_attach(struct ietp_softc *);
130 static int ietp_detach(struct ietp_softc *);
131 static int32_t ietp_res2dpmm(uint8_t, bool);
132
133 static device_identify_t ietp_iic_identify;
134 static device_probe_t ietp_iic_probe;
135 static device_attach_t ietp_iic_attach;
136 static device_detach_t ietp_iic_detach;
137 static device_resume_t ietp_iic_resume;
138
139 static int ietp_iic_read_reg(device_t, uint16_t, size_t, void *);
140 static int ietp_iic_write_reg(device_t, uint16_t, uint16_t);
141 static int ietp_iic_set_absolute_mode(device_t, bool);
142
143 #define IETP_IIC_DEV(pnp) \
144 { HID_TLC(HUP_GENERIC_DESKTOP, HUG_MOUSE), HID_BUS(BUS_I2C), HID_PNP(pnp) }
145
146 static const struct hid_device_id ietp_iic_devs[] = {
147 IETP_IIC_DEV("ELAN0000"),
148 IETP_IIC_DEV("ELAN0100"),
149 IETP_IIC_DEV("ELAN0600"),
150 IETP_IIC_DEV("ELAN0601"),
151 IETP_IIC_DEV("ELAN0602"),
152 IETP_IIC_DEV("ELAN0603"),
153 IETP_IIC_DEV("ELAN0604"),
154 IETP_IIC_DEV("ELAN0605"),
155 IETP_IIC_DEV("ELAN0606"),
156 IETP_IIC_DEV("ELAN0607"),
157 IETP_IIC_DEV("ELAN0608"),
158 IETP_IIC_DEV("ELAN0609"),
159 IETP_IIC_DEV("ELAN060B"),
160 IETP_IIC_DEV("ELAN060C"),
161 IETP_IIC_DEV("ELAN060F"),
162 IETP_IIC_DEV("ELAN0610"),
163 IETP_IIC_DEV("ELAN0611"),
164 IETP_IIC_DEV("ELAN0612"),
165 IETP_IIC_DEV("ELAN0615"),
166 IETP_IIC_DEV("ELAN0616"),
167 IETP_IIC_DEV("ELAN0617"),
168 IETP_IIC_DEV("ELAN0618"),
169 IETP_IIC_DEV("ELAN0619"),
170 IETP_IIC_DEV("ELAN061A"),
171 IETP_IIC_DEV("ELAN061B"),
172 IETP_IIC_DEV("ELAN061C"),
173 IETP_IIC_DEV("ELAN061D"),
174 IETP_IIC_DEV("ELAN061E"),
175 IETP_IIC_DEV("ELAN061F"),
176 IETP_IIC_DEV("ELAN0620"),
177 IETP_IIC_DEV("ELAN0621"),
178 IETP_IIC_DEV("ELAN0622"),
179 IETP_IIC_DEV("ELAN0623"),
180 IETP_IIC_DEV("ELAN0624"),
181 IETP_IIC_DEV("ELAN0625"),
182 IETP_IIC_DEV("ELAN0626"),
183 IETP_IIC_DEV("ELAN0627"),
184 IETP_IIC_DEV("ELAN0628"),
185 IETP_IIC_DEV("ELAN0629"),
186 IETP_IIC_DEV("ELAN062A"),
187 IETP_IIC_DEV("ELAN062B"),
188 IETP_IIC_DEV("ELAN062C"),
189 IETP_IIC_DEV("ELAN062D"),
190 IETP_IIC_DEV("ELAN062E"), /* Lenovo V340 Whiskey Lake U */
191 IETP_IIC_DEV("ELAN062F"), /* Lenovo V340 Comet Lake U */
192 IETP_IIC_DEV("ELAN0631"),
193 IETP_IIC_DEV("ELAN0632"),
194 IETP_IIC_DEV("ELAN0633"), /* Lenovo S145 */
195 IETP_IIC_DEV("ELAN0634"), /* Lenovo V340 Ice lake */
196 IETP_IIC_DEV("ELAN0635"), /* Lenovo V1415-IIL */
197 IETP_IIC_DEV("ELAN0636"), /* Lenovo V1415-Dali */
198 IETP_IIC_DEV("ELAN0637"), /* Lenovo V1415-IGLR */
199 IETP_IIC_DEV("ELAN1000"),
200 };
201
202 static uint8_t const ietp_dummy_rdesc[] = {
203 0x05, HUP_GENERIC_DESKTOP, /* Usage Page (Generic Desktop Ctrls) */
204 0x09, HUG_MOUSE, /* Usage (Mouse) */
205 0xA1, 0x01, /* Collection (Application) */
206 0x09, 0x01, /* Usage (0x01) */
207 0x95, IETP_REPORT_LEN_LO, /* Report Count (IETP_REPORT_LEN_LO) */
208 0x75, 0x08, /* Report Size (8) */
209 0x81, 0x02, /* Input (Data,Var,Abs) */
210 0xC0, /* End Collection */
211 };
212
213 static const struct evdev_methods ietp_evdev_methods = {
214 .ev_open = &ietp_ev_open,
215 .ev_close = &ietp_ev_close,
216 };
217
218 static int
ietp_ev_open(struct evdev_dev * evdev)219 ietp_ev_open(struct evdev_dev *evdev)
220 {
221 return (hid_intr_start(evdev_get_softc(evdev)));
222 }
223
224 static int
ietp_ev_close(struct evdev_dev * evdev)225 ietp_ev_close(struct evdev_dev *evdev)
226 {
227 return (hid_intr_stop(evdev_get_softc(evdev)));
228 }
229
230 static int
ietp_probe(struct ietp_softc * sc)231 ietp_probe(struct ietp_softc *sc)
232 {
233 if (hidbus_find_child(device_get_parent(sc->dev),
234 HID_USAGE2(HUP_DIGITIZERS, HUD_TOUCHPAD)) != NULL) {
235 DPRINTFN(5, "Ignore HID-compatible touchpad on %s\n",
236 device_get_nameunit(device_get_parent(sc->dev)));
237 return (ENXIO);
238 }
239
240 device_set_desc(sc->dev, "Elan Touchpad");
241
242 return (BUS_PROBE_DEFAULT);
243 }
244
245 static int
ietp_attach(struct ietp_softc * sc)246 ietp_attach(struct ietp_softc *sc)
247 {
248 const struct hid_device_info *hw = hid_get_device_info(sc->dev);
249 void *d_ptr;
250 hid_size_t d_len;
251 int32_t minor, major;
252 int error;
253
254 sc->report_id = sc->hi_precision ?
255 IETP_REPORT_ID_HI : IETP_REPORT_ID_LO;
256 sc->report_len = sc->hi_precision ?
257 IETP_REPORT_LEN_HI : IETP_REPORT_LEN_LO;
258
259 /* Try to detect 3-rd button by relative mouse TLC */
260 if (!sc->is_clickpad) {
261 error = hid_get_report_descr(sc->dev, &d_ptr, &d_len);
262 if (error != 0) {
263 device_printf(sc->dev, "could not retrieve report "
264 "descriptor from device: %d\n", error);
265 return (ENXIO);
266 }
267 if (hidbus_locate(d_ptr, d_len, HID_USAGE2(HUP_BUTTON, 3),
268 hid_input, hidbus_get_index(sc->dev), 0, NULL, NULL, NULL,
269 NULL))
270 sc->has_3buttons = true;
271 }
272
273 sc->evdev = evdev_alloc();
274 evdev_set_name(sc->evdev, device_get_desc(sc->dev));
275 evdev_set_phys(sc->evdev, device_get_nameunit(sc->dev));
276 evdev_set_id(sc->evdev, hw->idBus, hw->idVendor, hw->idProduct,
277 hw->idVersion);
278 evdev_set_serial(sc->evdev, hw->serial);
279 evdev_set_methods(sc->evdev, sc->dev, &ietp_evdev_methods);
280 evdev_set_flag(sc->evdev, EVDEV_FLAG_MT_STCOMPAT);
281 evdev_set_flag(sc->evdev, EVDEV_FLAG_EXT_EPOCH); /* hidbus child */
282
283 evdev_support_event(sc->evdev, EV_SYN);
284 evdev_support_event(sc->evdev, EV_ABS);
285 evdev_support_event(sc->evdev, EV_KEY);
286 evdev_support_prop(sc->evdev, INPUT_PROP_POINTER);
287 evdev_support_key(sc->evdev, BTN_LEFT);
288 if (sc->is_clickpad) {
289 evdev_support_prop(sc->evdev, INPUT_PROP_BUTTONPAD);
290 } else {
291 evdev_support_key(sc->evdev, BTN_RIGHT);
292 if (sc->has_3buttons)
293 evdev_support_key(sc->evdev, BTN_MIDDLE);
294 }
295
296 major = IETP_FINGER_MAX_WIDTH * MAX(sc->trace_x, sc->trace_y);
297 minor = IETP_FINGER_MAX_WIDTH * MIN(sc->trace_x, sc->trace_y);
298
299 evdev_support_abs(sc->evdev, ABS_MT_SLOT,
300 0, IETP_MAX_FINGERS - 1, 0, 0, 0);
301 evdev_support_abs(sc->evdev, ABS_MT_TRACKING_ID,
302 -1, IETP_MAX_FINGERS - 1, 0, 0, 0);
303 evdev_support_abs(sc->evdev, ABS_MT_POSITION_X,
304 0, sc->max_x, 0, 0, sc->res_x);
305 evdev_support_abs(sc->evdev, ABS_MT_POSITION_Y,
306 0, sc->max_y, 0, 0, sc->res_y);
307 evdev_support_abs(sc->evdev, ABS_MT_PRESSURE,
308 0, IETP_MAX_PRESSURE, 0, 0, 0);
309 evdev_support_abs(sc->evdev, ABS_MT_ORIENTATION, 0, 1, 0, 0, 0);
310 evdev_support_abs(sc->evdev, ABS_MT_TOUCH_MAJOR, 0, major, 0, 0, 0);
311 evdev_support_abs(sc->evdev, ABS_MT_TOUCH_MINOR, 0, minor, 0, 0, 0);
312 evdev_support_abs(sc->evdev, ABS_DISTANCE, 0, 1, 0, 0, 0);
313
314 error = evdev_register(sc->evdev);
315 if (error != 0) {
316 ietp_detach(sc);
317 return (ENOMEM);
318 }
319
320 hidbus_set_intr(sc->dev, ietp_intr, sc);
321
322 device_printf(sc->dev, "[%d:%d], %s\n", sc->max_x, sc->max_y,
323 sc->is_clickpad ? "clickpad" :
324 sc->has_3buttons ? "3 buttons" : "2 buttons");
325
326 return (0);
327 }
328
329 static int
ietp_detach(struct ietp_softc * sc)330 ietp_detach(struct ietp_softc *sc)
331 {
332 evdev_free(sc->evdev);
333
334 return (0);
335 }
336
337 static void
ietp_intr(void * context,void * buf,hid_size_t len)338 ietp_intr(void *context, void *buf, hid_size_t len)
339 {
340 struct ietp_softc *sc = context;
341 union evdev_mt_slot slot_data;
342 uint8_t *report, *fdata;
343 int32_t finger;
344 int32_t x, y, w, h, wh;
345
346 /* we seem to get 0 length reports sometimes, ignore them */
347 if (len == 0)
348 return;
349 if (len != sc->report_len) {
350 DPRINTF("wrong report length (%d vs %d expected)", len, sc->report_len);
351 return;
352 }
353
354 report = buf;
355 if (*report != sc->report_id)
356 return;
357
358 evdev_push_key(sc->evdev, BTN_LEFT,
359 report[IETP_TOUCH_INFO] & IETP_TOUCH_LMB);
360 evdev_push_key(sc->evdev, BTN_MIDDLE,
361 report[IETP_TOUCH_INFO] & IETP_TOUCH_MMB);
362 evdev_push_key(sc->evdev, BTN_RIGHT,
363 report[IETP_TOUCH_INFO] & IETP_TOUCH_RMB);
364 evdev_push_abs(sc->evdev, ABS_DISTANCE,
365 (report[IETP_HOVER_INFO] & 0x40) >> 6);
366
367 for (finger = 0, fdata = report + IETP_FINGER_DATA;
368 finger < IETP_MAX_FINGERS;
369 finger++, fdata += IETP_FINGER_DATA_LEN) {
370 if ((report[IETP_TOUCH_INFO] & (1 << (finger + 3))) != 0) {
371 if (sc->hi_precision) {
372 x = fdata[0] << 8 | fdata[1];
373 y = fdata[2] << 8 | fdata[3];
374 wh = report[IETP_WH_DATA + finger];
375 } else {
376 x = (fdata[0] & 0xf0) << 4 | fdata[1];
377 y = (fdata[0] & 0x0f) << 8 | fdata[2];
378 wh = fdata[3];
379 }
380
381 if (x > sc->max_x || y > sc->max_y) {
382 DPRINTF("[%d] x=%d y=%d over max (%d, %d)",
383 finger, x, y, sc->max_x, sc->max_y);
384 continue;
385 }
386
387 /* Reduce trace size to not treat large finger as palm */
388 w = (wh & 0x0F) * (sc->trace_x - IETP_FWIDTH_REDUCE);
389 h = (wh >> 4) * (sc->trace_y - IETP_FWIDTH_REDUCE);
390
391 slot_data = (union evdev_mt_slot) {
392 .id = finger,
393 .x = x,
394 .y = sc->max_y - y,
395 .p = MIN((int32_t)fdata[4] + sc->pressure_base,
396 IETP_MAX_PRESSURE),
397 .ori = w > h ? 1 : 0,
398 .maj = MAX(w, h),
399 .min = MIN(w, h),
400 };
401 evdev_mt_push_slot(sc->evdev, finger, &slot_data);
402 } else {
403 evdev_push_abs(sc->evdev, ABS_MT_SLOT, finger);
404 evdev_push_abs(sc->evdev, ABS_MT_TRACKING_ID, -1);
405 }
406 }
407
408 evdev_sync(sc->evdev);
409 }
410
411 static int32_t
ietp_res2dpmm(uint8_t res,bool hi_precision)412 ietp_res2dpmm(uint8_t res, bool hi_precision)
413 {
414 int32_t dpi;
415
416 dpi = hi_precision ? 300 + res * 100 : 790 + res * 10;
417
418 return (dpi * 10 /254);
419 }
420
421 static void
ietp_iic_identify(driver_t * driver,device_t parent)422 ietp_iic_identify(driver_t *driver, device_t parent)
423 {
424 void *d_ptr;
425 hid_size_t d_len;
426 int isize;
427 uint8_t iid;
428
429 if (HIDBUS_LOOKUP_ID(parent, ietp_iic_devs) == NULL)
430 return;
431 if (hid_get_report_descr(parent, &d_ptr, &d_len) != 0)
432 return;
433
434 /*
435 * Some Elantech trackpads have a mangled HID report descriptor, which
436 * reads as having an incorrect input size (i.e. < IETP_REPORT_LEN_LO).
437 * If the input size is incorrect, load a dummy report descriptor.
438 */
439
440 isize = hid_report_size_max(d_ptr, d_len, hid_input, &iid);
441 if (isize >= IETP_REPORT_LEN_LO)
442 return;
443
444 hid_set_report_descr(parent, ietp_dummy_rdesc,
445 sizeof(ietp_dummy_rdesc));
446 }
447
448 static int
ietp_iic_probe(device_t dev)449 ietp_iic_probe(device_t dev)
450 {
451 struct ietp_softc *sc = device_get_softc(dev);
452 device_t iichid;
453 int error;
454
455 error = HIDBUS_LOOKUP_DRIVER_INFO(dev, ietp_iic_devs);
456 if (error != 0)
457 return (error);
458
459 iichid = device_get_parent(device_get_parent(dev));
460 if (device_get_devclass(iichid) != devclass_find("iichid"))
461 return (ENXIO);
462
463 sc->dev = dev;
464
465 return (ietp_probe(sc));
466 }
467
468 static int
ietp_iic_attach(device_t dev)469 ietp_iic_attach(device_t dev)
470 {
471 struct ietp_softc *sc = device_get_softc(dev);
472 uint16_t buf, reg;
473 uint8_t *buf8;
474 uint8_t pattern;
475
476 buf8 = (uint8_t *)&buf;
477
478 if (ietp_iic_read_reg(dev, IETP_UNIQUEID, sizeof(buf), &buf) != 0) {
479 device_printf(sc->dev, "failed reading product ID\n");
480 return (EIO);
481 }
482 sc->product_id = le16toh(buf);
483
484 if (ietp_iic_read_reg(dev, IETP_PATTERN, sizeof(buf), &buf) != 0) {
485 device_printf(sc->dev, "failed reading pattern\n");
486 return (EIO);
487 }
488 pattern = buf == 0xFFFF ? 0 : buf8[1];
489 sc->hi_precision = pattern >= 0x02;
490
491 reg = pattern >= 0x01 ? IETP_IC_TYPE : IETP_OSM_VERSION;
492 if (ietp_iic_read_reg(dev, reg, sizeof(buf), &buf) != 0) {
493 device_printf(sc->dev, "failed reading IC type\n");
494 return (EIO);
495 }
496 sc->ic_type = pattern >= 0x01 ? be16toh(buf) : buf8[1];
497
498 if (ietp_iic_read_reg(dev, IETP_NSM_VERSION, sizeof(buf), &buf) != 0) {
499 device_printf(sc->dev, "failed reading SM version\n");
500 return (EIO);
501 }
502 sc->is_clickpad = (buf8[0] & 0x10) != 0;
503
504 if (ietp_iic_set_absolute_mode(dev, true) != 0) {
505 device_printf(sc->dev, "failed to set absolute mode\n");
506 return (EIO);
507 }
508
509 if (ietp_iic_read_reg(dev, IETP_MAX_X_AXIS, sizeof(buf), &buf) != 0) {
510 device_printf(sc->dev, "failed reading max x\n");
511 return (EIO);
512 }
513 sc->max_x = le16toh(buf);
514
515 if (ietp_iic_read_reg(dev, IETP_MAX_Y_AXIS, sizeof(buf), &buf) != 0) {
516 device_printf(sc->dev, "failed reading max y\n");
517 return (EIO);
518 }
519 sc->max_y = le16toh(buf);
520
521 if (ietp_iic_read_reg(dev, IETP_TRACENUM, sizeof(buf), &buf) != 0) {
522 device_printf(sc->dev, "failed reading trace info\n");
523 return (EIO);
524 }
525 sc->trace_x = sc->max_x / buf8[0];
526 sc->trace_y = sc->max_y / buf8[1];
527
528 if (ietp_iic_read_reg(dev, IETP_PRESSURE, sizeof(buf), &buf) != 0) {
529 device_printf(sc->dev, "failed reading pressure format\n");
530 return (EIO);
531 }
532 sc->pressure_base = (buf8[0] & 0x10) ? 0 : IETP_PRESSURE_BASE;
533
534 if (ietp_iic_read_reg(dev, IETP_RESOLUTION, sizeof(buf), &buf) != 0) {
535 device_printf(sc->dev, "failed reading resolution\n");
536 return (EIO);
537 }
538 /* Conversion from internal format to dot per mm */
539 sc->res_x = ietp_res2dpmm(buf8[0], sc->hi_precision);
540 sc->res_y = ietp_res2dpmm(buf8[1], sc->hi_precision);
541
542 return (ietp_attach(sc));
543 }
544
545 static int
ietp_iic_detach(device_t dev)546 ietp_iic_detach(device_t dev)
547 {
548 struct ietp_softc *sc = device_get_softc(dev);
549
550 if (ietp_iic_set_absolute_mode(dev, false) != 0)
551 device_printf(dev, "failed setting standard mode\n");
552
553 return (ietp_detach(sc));
554 }
555
556 static int
ietp_iic_resume(device_t dev)557 ietp_iic_resume(device_t dev)
558 {
559 if (ietp_iic_set_absolute_mode(dev, true) != 0) {
560 device_printf(dev, "reset when resuming failed: \n");
561 return (EIO);
562 }
563
564 return (0);
565 }
566
567 static int
ietp_iic_set_absolute_mode(device_t dev,bool enable)568 ietp_iic_set_absolute_mode(device_t dev, bool enable)
569 {
570 struct ietp_softc *sc = device_get_softc(dev);
571 static const struct {
572 uint16_t ic_type;
573 uint16_t product_id;
574 } special_fw[] = {
575 { 0x0E, 0x05 }, { 0x0E, 0x06 }, { 0x0E, 0x07 }, { 0x0E, 0x09 },
576 { 0x0E, 0x13 }, { 0x08, 0x26 },
577 };
578 uint16_t val;
579 int i, error;
580 bool require_wakeup;
581
582 error = 0;
583
584 /*
585 * Some ASUS touchpads need to be powered on to enter absolute mode.
586 */
587 require_wakeup = false;
588 for (i = 0; i < nitems(special_fw); i++) {
589 if (sc->ic_type == special_fw[i].ic_type &&
590 sc->product_id == special_fw[i].product_id) {
591 require_wakeup = true;
592 break;
593 }
594 }
595
596 if (require_wakeup && hid_intr_start(dev) != 0) {
597 device_printf(dev, "failed writing poweron command\n");
598 return (EIO);
599 }
600
601 val = enable ? IETP_CTRL_ABSOLUTE : IETP_CTRL_STANDARD;
602 if (ietp_iic_write_reg(dev, IETP_CONTROL, val) != 0) {
603 device_printf(dev, "failed setting absolute mode\n");
604 error = EIO;
605 }
606
607 if (require_wakeup && hid_intr_stop(dev) != 0) {
608 device_printf(dev, "failed writing poweroff command\n");
609 error = EIO;
610 }
611
612 return (error);
613 }
614
615 static int
ietp_iic_read_reg(device_t dev,uint16_t reg,size_t len,void * val)616 ietp_iic_read_reg(device_t dev, uint16_t reg, size_t len, void *val)
617 {
618 device_t iichid = device_get_parent(device_get_parent(dev));
619 uint16_t addr = iicbus_get_addr(iichid) << 1;
620 uint8_t cmd[2] = { reg & 0xff, (reg >> 8) & 0xff };
621 struct iic_msg msgs[2] = {
622 { addr, IIC_M_WR | IIC_M_NOSTOP, sizeof(cmd), cmd },
623 { addr, IIC_M_RD, len, val },
624 };
625 struct iic_rdwr_data ird = { msgs, nitems(msgs) };
626 int error;
627
628 DPRINTF("Read reg 0x%04x with size %zu\n", reg, len);
629
630 error = hid_ioctl(dev, I2CRDWR, (uintptr_t)&ird);
631 if (error != 0)
632 return (error);
633
634 DPRINTF("Response: %*D\n", (int)len, val, " ");
635
636 return (0);
637 }
638
639 static int
ietp_iic_write_reg(device_t dev,uint16_t reg,uint16_t val)640 ietp_iic_write_reg(device_t dev, uint16_t reg, uint16_t val)
641 {
642 device_t iichid = device_get_parent(device_get_parent(dev));
643 uint16_t addr = iicbus_get_addr(iichid) << 1;
644 uint8_t cmd[4] = { reg & 0xff, (reg >> 8) & 0xff,
645 val & 0xff, (val >> 8) & 0xff };
646 struct iic_msg msgs[1] = {
647 { addr, IIC_M_WR, sizeof(cmd), cmd },
648 };
649 struct iic_rdwr_data ird = { msgs, nitems(msgs) };
650
651 DPRINTF("Write reg 0x%04x with value 0x%04x\n", reg, val);
652
653 return (hid_ioctl(dev, I2CRDWR, (uintptr_t)&ird));
654 }
655
656 static device_method_t ietp_methods[] = {
657 DEVMETHOD(device_identify, ietp_iic_identify),
658 DEVMETHOD(device_probe, ietp_iic_probe),
659 DEVMETHOD(device_attach, ietp_iic_attach),
660 DEVMETHOD(device_detach, ietp_iic_detach),
661 DEVMETHOD(device_resume, ietp_iic_resume),
662 DEVMETHOD_END
663 };
664
665 static driver_t ietp_driver = {
666 .name = "ietp",
667 .methods = ietp_methods,
668 .size = sizeof(struct ietp_softc),
669 };
670
671 DRIVER_MODULE(ietp, hidbus, ietp_driver, NULL, NULL);
672 MODULE_DEPEND(ietp, hidbus, 1, 1, 1);
673 MODULE_DEPEND(ietp, hid, 1, 1, 1);
674 MODULE_DEPEND(ietp, evdev, 1, 1, 1);
675 MODULE_VERSION(ietp, 1);
676 HID_PNP_INFO(ietp_iic_devs);
677