1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * This is a driver for the keyboard, touchpad and USB port of the |
4 | * keyboard dock for the Asus TF103C 2-in-1 tablet. |
5 | * |
6 | * This keyboard dock has its own I2C attached embedded controller |
7 | * and the keyboard and touchpad are also connected over I2C, |
8 | * instead of using the usual USB connection. This means that the |
9 | * keyboard dock requires this special driver to function. |
10 | * |
11 | * Copyright (C) 2021 Hans de Goede <hdegoede@redhat.com> |
12 | */ |
13 | |
14 | #include <linux/acpi.h> |
15 | #include <linux/delay.h> |
16 | #include <linux/dmi.h> |
17 | #include <linux/gpio/consumer.h> |
18 | #include <linux/gpio/machine.h> |
19 | #include <linux/hid.h> |
20 | #include <linux/i2c.h> |
21 | #include <linux/input.h> |
22 | #include <linux/irq.h> |
23 | #include <linux/irqdomain.h> |
24 | #include <linux/mod_devicetable.h> |
25 | #include <linux/moduleparam.h> |
26 | #include <linux/module.h> |
27 | #include <linux/pm.h> |
28 | #include <linux/workqueue.h> |
29 | #include <asm/unaligned.h> |
30 | |
31 | static bool fnlock; |
32 | module_param(fnlock, bool, 0644); |
33 | MODULE_PARM_DESC(fnlock, |
34 | "By default the kbd toprow sends multimedia key presses. AltGr " |
35 | "can be pressed to change this to F1-F12. Set this to 1 to " |
36 | "change the default. Press AltGr + Esc to toggle at runtime." ); |
37 | |
38 | #define TF103C_DOCK_DEV_NAME "NPCE69A:00" |
39 | |
40 | #define TF103C_DOCK_HPD_DEBOUNCE msecs_to_jiffies(20) |
41 | |
42 | /*** Touchpad I2C device defines ***/ |
43 | #define TF103C_DOCK_TP_ADDR 0x15 |
44 | |
45 | /*** Keyboard I2C device defines **A*/ |
46 | #define TF103C_DOCK_KBD_ADDR 0x16 |
47 | |
48 | #define TF103C_DOCK_KBD_DATA_REG 0x73 |
49 | #define TF103C_DOCK_KBD_DATA_MIN_LENGTH 4 |
50 | #define TF103C_DOCK_KBD_DATA_MAX_LENGTH 11 |
51 | #define TF103C_DOCK_KBD_DATA_MODIFIERS 3 |
52 | #define TF103C_DOCK_KBD_DATA_KEYS 5 |
53 | #define TF103C_DOCK_KBD_CMD_REG 0x75 |
54 | |
55 | #define TF103C_DOCK_KBD_CMD_ENABLE 0x0800 |
56 | |
57 | /*** EC innterrupt data I2C device defines ***/ |
58 | #define TF103C_DOCK_INTR_ADDR 0x19 |
59 | #define TF103C_DOCK_INTR_DATA_REG 0x6a |
60 | |
61 | #define TF103C_DOCK_INTR_DATA1_OBF_MASK 0x01 |
62 | #define TF103C_DOCK_INTR_DATA1_KEY_MASK 0x04 |
63 | #define TF103C_DOCK_INTR_DATA1_KBC_MASK 0x08 |
64 | #define TF103C_DOCK_INTR_DATA1_AUX_MASK 0x20 |
65 | #define TF103C_DOCK_INTR_DATA1_SCI_MASK 0x40 |
66 | #define TF103C_DOCK_INTR_DATA1_SMI_MASK 0x80 |
67 | /* Special values for the OOB data on kbd_client / tp_client */ |
68 | #define TF103C_DOCK_INTR_DATA1_OOB_VALUE 0xc1 |
69 | #define TF103C_DOCK_INTR_DATA2_OOB_VALUE 0x04 |
70 | |
71 | #define TF103C_DOCK_SMI_AC_EVENT 0x31 |
72 | #define TF103C_DOCK_SMI_HANDSHAKING 0x50 |
73 | #define TF103C_DOCK_SMI_EC_WAKEUP 0x53 |
74 | #define TF103C_DOCK_SMI_BOOTBLOCK_RESET 0x5e |
75 | #define TF103C_DOCK_SMI_WATCHDOG_RESET 0x5f |
76 | #define TF103C_DOCK_SMI_ADAPTER_CHANGE 0x60 |
77 | #define TF103C_DOCK_SMI_DOCK_INSERT 0x61 |
78 | #define TF103C_DOCK_SMI_DOCK_REMOVE 0x62 |
79 | #define TF103C_DOCK_SMI_PAD_BL_CHANGE 0x63 |
80 | #define TF103C_DOCK_SMI_HID_STATUS_CHANGED 0x64 |
81 | #define TF103C_DOCK_SMI_HID_WAKEUP 0x65 |
82 | #define TF103C_DOCK_SMI_S3 0x83 |
83 | #define TF103C_DOCK_SMI_S5 0x85 |
84 | #define TF103C_DOCK_SMI_NOTIFY_SHUTDOWN 0x90 |
85 | #define TF103C_DOCK_SMI_RESUME 0x91 |
86 | |
87 | /*** EC (dockram) I2C device defines ***/ |
88 | #define TF103C_DOCK_EC_ADDR 0x1b |
89 | |
90 | #define TF103C_DOCK_EC_CMD_REG 0x0a |
91 | #define TF103C_DOCK_EC_CMD_LEN 9 |
92 | |
93 | enum { |
94 | TF103C_DOCK_FLAG_HID_OPEN, |
95 | }; |
96 | |
97 | struct tf103c_dock_data { |
98 | struct delayed_work hpd_work; |
99 | struct irq_chip tp_irqchip; |
100 | struct irq_domain *tp_irq_domain; |
101 | struct i2c_client *ec_client; |
102 | struct i2c_client *intr_client; |
103 | struct i2c_client *kbd_client; |
104 | struct i2c_client *tp_client; |
105 | struct gpio_desc *pwr_en; |
106 | struct gpio_desc *irq_gpio; |
107 | struct gpio_desc *hpd_gpio; |
108 | struct input_dev *input; |
109 | struct hid_device *hid; |
110 | unsigned long flags; |
111 | int board_rev; |
112 | int irq; |
113 | int hpd_irq; |
114 | int tp_irq; |
115 | int last_press_0x13; |
116 | int last_press_0x14; |
117 | bool enabled; |
118 | bool tp_enabled; |
119 | bool altgr_pressed; |
120 | bool esc_pressed; |
121 | bool filter_esc; |
122 | u8 kbd_buf[TF103C_DOCK_KBD_DATA_MAX_LENGTH]; |
123 | }; |
124 | |
125 | static struct gpiod_lookup_table tf103c_dock_gpios = { |
126 | .dev_id = "i2c-" TF103C_DOCK_DEV_NAME, |
127 | .table = { |
128 | GPIO_LOOKUP("INT33FC:00" , 55, "dock_pwr_en" , GPIO_ACTIVE_HIGH), |
129 | GPIO_LOOKUP("INT33FC:02" , 1, "dock_irq" , GPIO_ACTIVE_HIGH), |
130 | GPIO_LOOKUP("INT33FC:02" , 29, "dock_hpd" , GPIO_ACTIVE_HIGH), |
131 | GPIO_LOOKUP("gpio_crystalcove" , 2, "board_rev" , GPIO_ACTIVE_HIGH), |
132 | {} |
133 | }, |
134 | }; |
135 | |
136 | /* Byte 0 is the length of the rest of the packet */ |
137 | static const u8 tf103c_dock_enable_cmd[9] = { 8, 0x20, 0, 0, 0, 0, 0x20, 0, 0 }; |
138 | static const u8 tf103c_dock_usb_enable_cmd[9] = { 8, 0, 0, 0, 0, 0, 0, 0x40, 0 }; |
139 | static const u8 tf103c_dock_suspend_cmd[9] = { 8, 0, 0x20, 0, 0, 0x22, 0, 0, 0 }; |
140 | |
141 | /*** keyboard related code ***/ |
142 | |
143 | static u8 tf103c_dock_kbd_hid_desc[] = { |
144 | 0x05, 0x01, /* Usage Page (Desktop), */ |
145 | 0x09, 0x06, /* Usage (Keyboard), */ |
146 | 0xA1, 0x01, /* Collection (Application), */ |
147 | 0x85, 0x11, /* Report ID (17), */ |
148 | 0x95, 0x08, /* Report Count (8), */ |
149 | 0x75, 0x01, /* Report Size (1), */ |
150 | 0x15, 0x00, /* Logical Minimum (0), */ |
151 | 0x25, 0x01, /* Logical Maximum (1), */ |
152 | 0x05, 0x07, /* Usage Page (Keyboard), */ |
153 | 0x19, 0xE0, /* Usage Minimum (KB Leftcontrol), */ |
154 | 0x29, 0xE7, /* Usage Maximum (KB Right GUI), */ |
155 | 0x81, 0x02, /* Input (Variable), */ |
156 | 0x95, 0x01, /* Report Count (1), */ |
157 | 0x75, 0x08, /* Report Size (8), */ |
158 | 0x81, 0x01, /* Input (Constant), */ |
159 | 0x95, 0x06, /* Report Count (6), */ |
160 | 0x75, 0x08, /* Report Size (8), */ |
161 | 0x15, 0x00, /* Logical Minimum (0), */ |
162 | 0x26, 0xFF, 0x00, /* Logical Maximum (255), */ |
163 | 0x05, 0x07, /* Usage Page (Keyboard), */ |
164 | 0x19, 0x00, /* Usage Minimum (None), */ |
165 | 0x2A, 0xFF, 0x00, /* Usage Maximum (FFh), */ |
166 | 0x81, 0x00, /* Input, */ |
167 | 0xC0 /* End Collection */ |
168 | }; |
169 | |
170 | static int tf103c_dock_kbd_read(struct tf103c_dock_data *dock) |
171 | { |
172 | struct i2c_client *client = dock->kbd_client; |
173 | struct device *dev = &dock->ec_client->dev; |
174 | struct i2c_msg msgs[2]; |
175 | u8 reg[2]; |
176 | int ret; |
177 | |
178 | reg[0] = TF103C_DOCK_KBD_DATA_REG & 0xff; |
179 | reg[1] = TF103C_DOCK_KBD_DATA_REG >> 8; |
180 | |
181 | msgs[0].addr = client->addr; |
182 | msgs[0].flags = 0; |
183 | msgs[0].len = sizeof(reg); |
184 | msgs[0].buf = reg; |
185 | |
186 | msgs[1].addr = client->addr; |
187 | msgs[1].flags = I2C_M_RD; |
188 | msgs[1].len = TF103C_DOCK_KBD_DATA_MAX_LENGTH; |
189 | msgs[1].buf = dock->kbd_buf; |
190 | |
191 | ret = i2c_transfer(adap: client->adapter, msgs, ARRAY_SIZE(msgs)); |
192 | if (ret != ARRAY_SIZE(msgs)) { |
193 | dev_err(dev, "error %d reading kbd data\n" , ret); |
194 | return -EIO; |
195 | } |
196 | |
197 | return 0; |
198 | } |
199 | |
200 | static void tf103c_dock_kbd_write(struct tf103c_dock_data *dock, u16 cmd) |
201 | { |
202 | struct device *dev = &dock->ec_client->dev; |
203 | u8 buf[4]; |
204 | int ret; |
205 | |
206 | put_unaligned_le16(TF103C_DOCK_KBD_CMD_REG, p: &buf[0]); |
207 | put_unaligned_le16(val: cmd, p: &buf[2]); |
208 | |
209 | ret = i2c_master_send(client: dock->kbd_client, buf, count: sizeof(buf)); |
210 | if (ret != sizeof(buf)) |
211 | dev_err(dev, "error %d writing kbd cmd\n" , ret); |
212 | } |
213 | |
214 | /* HID ll_driver functions for forwarding input-reports from the kbd_client */ |
215 | static int tf103c_dock_hid_parse(struct hid_device *hid) |
216 | { |
217 | return hid_parse_report(hid, start: tf103c_dock_kbd_hid_desc, |
218 | size: sizeof(tf103c_dock_kbd_hid_desc)); |
219 | } |
220 | |
221 | static int tf103c_dock_hid_start(struct hid_device *hid) |
222 | { |
223 | return 0; |
224 | } |
225 | |
226 | static void tf103c_dock_hid_stop(struct hid_device *hid) |
227 | { |
228 | hid->claimed = 0; |
229 | } |
230 | |
231 | static int tf103c_dock_hid_open(struct hid_device *hid) |
232 | { |
233 | struct tf103c_dock_data *dock = hid->driver_data; |
234 | |
235 | set_bit(nr: TF103C_DOCK_FLAG_HID_OPEN, addr: &dock->flags); |
236 | return 0; |
237 | } |
238 | |
239 | static void tf103c_dock_hid_close(struct hid_device *hid) |
240 | { |
241 | struct tf103c_dock_data *dock = hid->driver_data; |
242 | |
243 | clear_bit(nr: TF103C_DOCK_FLAG_HID_OPEN, addr: &dock->flags); |
244 | } |
245 | |
246 | /* Mandatory, but not used */ |
247 | static int tf103c_dock_hid_raw_request(struct hid_device *hid, u8 reportnum, |
248 | u8 *buf, size_t len, u8 rtype, int reqtype) |
249 | { |
250 | return 0; |
251 | } |
252 | |
253 | static const struct hid_ll_driver tf103c_dock_hid_ll_driver = { |
254 | .parse = tf103c_dock_hid_parse, |
255 | .start = tf103c_dock_hid_start, |
256 | .stop = tf103c_dock_hid_stop, |
257 | .open = tf103c_dock_hid_open, |
258 | .close = tf103c_dock_hid_close, |
259 | .raw_request = tf103c_dock_hid_raw_request, |
260 | }; |
261 | |
262 | static const int tf103c_dock_toprow_codes[13][2] = { |
263 | /* Normal, AltGr pressed */ |
264 | { KEY_POWER, KEY_F1 }, |
265 | { KEY_RFKILL, KEY_F2 }, |
266 | { KEY_F21, KEY_F3 }, /* Touchpad toggle, userspace expects F21 */ |
267 | { KEY_BRIGHTNESSDOWN, KEY_F4 }, |
268 | { KEY_BRIGHTNESSUP, KEY_F5 }, |
269 | { KEY_CAMERA, KEY_F6 }, |
270 | { KEY_CONFIG, KEY_F7 }, |
271 | { KEY_PREVIOUSSONG, KEY_F8 }, |
272 | { KEY_PLAYPAUSE, KEY_F9 }, |
273 | { KEY_NEXTSONG, KEY_F10 }, |
274 | { KEY_MUTE, KEY_F11 }, |
275 | { KEY_VOLUMEDOWN, KEY_F12 }, |
276 | { KEY_VOLUMEUP, KEY_SYSRQ }, |
277 | }; |
278 | |
279 | static void tf103c_dock_report_toprow_kbd_hook(struct tf103c_dock_data *dock) |
280 | { |
281 | u8 *esc, *buf = dock->kbd_buf; |
282 | int size; |
283 | |
284 | /* |
285 | * Stop AltGr reports from getting reported on the "Asus TF103C Dock |
286 | * Keyboard" input_dev, since this gets used as "Fn" key for the toprow |
287 | * keys. Instead we report this on the "Asus TF103C Dock Top Row Keys" |
288 | * input_dev, when not used to modify the toprow keys. |
289 | */ |
290 | dock->altgr_pressed = buf[TF103C_DOCK_KBD_DATA_MODIFIERS] & 0x40; |
291 | buf[TF103C_DOCK_KBD_DATA_MODIFIERS] &= ~0x40; |
292 | |
293 | input_report_key(dev: dock->input, KEY_RIGHTALT, value: dock->altgr_pressed); |
294 | input_sync(dev: dock->input); |
295 | |
296 | /* Toggle fnlock on AltGr + Esc press */ |
297 | buf = buf + TF103C_DOCK_KBD_DATA_KEYS; |
298 | size = TF103C_DOCK_KBD_DATA_MAX_LENGTH - TF103C_DOCK_KBD_DATA_KEYS; |
299 | esc = memchr(p: buf, c: 0x29, size); |
300 | if (!dock->esc_pressed && esc) { |
301 | if (dock->altgr_pressed) { |
302 | fnlock = !fnlock; |
303 | dock->filter_esc = true; |
304 | } |
305 | } |
306 | if (esc && dock->filter_esc) |
307 | *esc = 0; |
308 | else |
309 | dock->filter_esc = false; |
310 | |
311 | dock->esc_pressed = esc != NULL; |
312 | } |
313 | |
314 | static void tf103c_dock_toprow_press(struct tf103c_dock_data *dock, int key_code) |
315 | { |
316 | /* |
317 | * Release AltGr before reporting the toprow key, so that userspace |
318 | * sees e.g. just KEY_SUSPEND and not AltGr + KEY_SUSPEND. |
319 | */ |
320 | if (dock->altgr_pressed) { |
321 | input_report_key(dev: dock->input, KEY_RIGHTALT, value: false); |
322 | input_sync(dev: dock->input); |
323 | } |
324 | |
325 | input_report_key(dev: dock->input, code: key_code, value: true); |
326 | input_sync(dev: dock->input); |
327 | } |
328 | |
329 | static void tf103c_dock_toprow_release(struct tf103c_dock_data *dock, int key_code) |
330 | { |
331 | input_report_key(dev: dock->input, code: key_code, value: false); |
332 | input_sync(dev: dock->input); |
333 | |
334 | if (dock->altgr_pressed) { |
335 | input_report_key(dev: dock->input, KEY_RIGHTALT, value: true); |
336 | input_sync(dev: dock->input); |
337 | } |
338 | } |
339 | |
340 | static void tf103c_dock_toprow_event(struct tf103c_dock_data *dock, |
341 | int toprow_index, int *last_press) |
342 | { |
343 | int key_code, fn = dock->altgr_pressed ^ fnlock; |
344 | |
345 | if (last_press && *last_press) { |
346 | tf103c_dock_toprow_release(dock, key_code: *last_press); |
347 | *last_press = 0; |
348 | } |
349 | |
350 | if (toprow_index < 0) |
351 | return; |
352 | |
353 | key_code = tf103c_dock_toprow_codes[toprow_index][fn]; |
354 | tf103c_dock_toprow_press(dock, key_code); |
355 | |
356 | if (last_press) |
357 | *last_press = key_code; |
358 | else |
359 | tf103c_dock_toprow_release(dock, key_code); |
360 | } |
361 | |
362 | /* |
363 | * The keyboard sends what appears to be standard I2C-HID input-reports, |
364 | * except that a 16 bit register address of where the I2C-HID format |
365 | * input-reports are stored must be send before reading it in a single |
366 | * (I2C repeated-start) I2C transaction. |
367 | * |
368 | * Its unknown how to get the HID descriptors but they are easy to reconstruct: |
369 | * |
370 | * Input report id 0x11 is 8 bytes long and contain standard USB HID intf-class, |
371 | * Boot Interface Subclass reports. |
372 | * Input report id 0x13 is 2 bytes long and sends Consumer Control events |
373 | * Input report id 0x14 is 1 byte long and sends System Control events |
374 | * |
375 | * However the top row keys (where a normal keyboard has F1-F12 + Print-Screen) |
376 | * are a mess, using a mix of the 0x13 and 0x14 input reports as well as EC SCI |
377 | * events; and these need special handling to allow actually sending F1-F12, |
378 | * since the Fn key on the keyboard only works on the cursor keys and the top |
379 | * row keys always send their special "Multimedia hotkey" codes. |
380 | * |
381 | * So only forward the 0x11 reports to HID and handle the top-row keys here. |
382 | */ |
383 | static void tf103c_dock_kbd_interrupt(struct tf103c_dock_data *dock) |
384 | { |
385 | struct device *dev = &dock->ec_client->dev; |
386 | u8 *buf = dock->kbd_buf; |
387 | int size; |
388 | |
389 | if (tf103c_dock_kbd_read(dock)) |
390 | return; |
391 | |
392 | size = buf[0] | buf[1] << 8; |
393 | if (size < TF103C_DOCK_KBD_DATA_MIN_LENGTH || |
394 | size > TF103C_DOCK_KBD_DATA_MAX_LENGTH) { |
395 | dev_err(dev, "error reported kbd pkt size %d is out of range %d-%d\n" , size, |
396 | TF103C_DOCK_KBD_DATA_MIN_LENGTH, |
397 | TF103C_DOCK_KBD_DATA_MAX_LENGTH); |
398 | return; |
399 | } |
400 | |
401 | switch (buf[2]) { |
402 | case 0x11: |
403 | if (size != 11) |
404 | break; |
405 | |
406 | tf103c_dock_report_toprow_kbd_hook(dock); |
407 | |
408 | if (test_bit(TF103C_DOCK_FLAG_HID_OPEN, &dock->flags)) |
409 | hid_input_report(hid: dock->hid, type: HID_INPUT_REPORT, data: buf + 2, size: size - 2, interrupt: 1); |
410 | return; |
411 | case 0x13: |
412 | if (size != 5) |
413 | break; |
414 | |
415 | switch (buf[3] | buf[4] << 8) { |
416 | case 0: |
417 | tf103c_dock_toprow_event(dock, toprow_index: -1, last_press: &dock->last_press_0x13); |
418 | return; |
419 | case 0x70: |
420 | tf103c_dock_toprow_event(dock, toprow_index: 3, last_press: &dock->last_press_0x13); |
421 | return; |
422 | case 0x6f: |
423 | tf103c_dock_toprow_event(dock, toprow_index: 4, last_press: &dock->last_press_0x13); |
424 | return; |
425 | case 0xb6: |
426 | tf103c_dock_toprow_event(dock, toprow_index: 7, last_press: &dock->last_press_0x13); |
427 | return; |
428 | case 0xcd: |
429 | tf103c_dock_toprow_event(dock, toprow_index: 8, last_press: &dock->last_press_0x13); |
430 | return; |
431 | case 0xb5: |
432 | tf103c_dock_toprow_event(dock, toprow_index: 9, last_press: &dock->last_press_0x13); |
433 | return; |
434 | case 0xe2: |
435 | tf103c_dock_toprow_event(dock, toprow_index: 10, last_press: &dock->last_press_0x13); |
436 | return; |
437 | case 0xea: |
438 | tf103c_dock_toprow_event(dock, toprow_index: 11, last_press: &dock->last_press_0x13); |
439 | return; |
440 | case 0xe9: |
441 | tf103c_dock_toprow_event(dock, toprow_index: 12, last_press: &dock->last_press_0x13); |
442 | return; |
443 | } |
444 | break; |
445 | case 0x14: |
446 | if (size != 4) |
447 | break; |
448 | |
449 | switch (buf[3]) { |
450 | case 0: |
451 | tf103c_dock_toprow_event(dock, toprow_index: -1, last_press: &dock->last_press_0x14); |
452 | return; |
453 | case 1: |
454 | tf103c_dock_toprow_event(dock, toprow_index: 0, last_press: &dock->last_press_0x14); |
455 | return; |
456 | } |
457 | break; |
458 | } |
459 | |
460 | dev_warn(dev, "warning unknown kbd data: %*ph\n" , size, buf); |
461 | } |
462 | |
463 | /*** touchpad related code ***/ |
464 | |
465 | static const struct property_entry tf103c_dock_touchpad_props[] = { |
466 | PROPERTY_ENTRY_BOOL("elan,clickpad" ), |
467 | { } |
468 | }; |
469 | |
470 | static const struct software_node tf103c_dock_touchpad_sw_node = { |
471 | .properties = tf103c_dock_touchpad_props, |
472 | }; |
473 | |
474 | /* |
475 | * tf103c_enable_touchpad() is only called from the threaded interrupt handler |
476 | * and tf103c_disable_touchpad() is only called after the irq is disabled, |
477 | * so no locking is necessary. |
478 | */ |
479 | static void tf103c_dock_enable_touchpad(struct tf103c_dock_data *dock) |
480 | { |
481 | struct i2c_board_info board_info = { }; |
482 | struct device *dev = &dock->ec_client->dev; |
483 | int ret; |
484 | |
485 | if (dock->tp_enabled) { |
486 | /* Happens after resume, the tp needs to be reinitialized */ |
487 | ret = device_reprobe(dev: &dock->tp_client->dev); |
488 | if (ret) |
489 | dev_err_probe(dev, err: ret, fmt: "reprobing tp-client\n" ); |
490 | return; |
491 | } |
492 | |
493 | strscpy(board_info.type, "elan_i2c" , I2C_NAME_SIZE); |
494 | board_info.addr = TF103C_DOCK_TP_ADDR; |
495 | board_info.dev_name = TF103C_DOCK_DEV_NAME "-tp" ; |
496 | board_info.irq = dock->tp_irq; |
497 | board_info.swnode = &tf103c_dock_touchpad_sw_node; |
498 | |
499 | dock->tp_client = i2c_new_client_device(adap: dock->ec_client->adapter, info: &board_info); |
500 | if (IS_ERR(ptr: dock->tp_client)) { |
501 | dev_err(dev, "error %ld creating tp client\n" , PTR_ERR(dock->tp_client)); |
502 | return; |
503 | } |
504 | |
505 | dock->tp_enabled = true; |
506 | } |
507 | |
508 | static void tf103c_dock_disable_touchpad(struct tf103c_dock_data *dock) |
509 | { |
510 | if (!dock->tp_enabled) |
511 | return; |
512 | |
513 | i2c_unregister_device(client: dock->tp_client); |
514 | |
515 | dock->tp_enabled = false; |
516 | } |
517 | |
518 | /*** interrupt handling code ***/ |
519 | static void tf103c_dock_ec_cmd(struct tf103c_dock_data *dock, const u8 *cmd) |
520 | { |
521 | struct device *dev = &dock->ec_client->dev; |
522 | int ret; |
523 | |
524 | ret = i2c_smbus_write_i2c_block_data(client: dock->ec_client, TF103C_DOCK_EC_CMD_REG, |
525 | TF103C_DOCK_EC_CMD_LEN, values: cmd); |
526 | if (ret) |
527 | dev_err(dev, "error %d sending %*ph cmd\n" , ret, |
528 | TF103C_DOCK_EC_CMD_LEN, cmd); |
529 | } |
530 | |
531 | static void tf103c_dock_sci(struct tf103c_dock_data *dock, u8 val) |
532 | { |
533 | struct device *dev = &dock->ec_client->dev; |
534 | |
535 | switch (val) { |
536 | case 2: |
537 | tf103c_dock_toprow_event(dock, toprow_index: 1, NULL); |
538 | return; |
539 | case 4: |
540 | tf103c_dock_toprow_event(dock, toprow_index: 2, NULL); |
541 | return; |
542 | case 8: |
543 | tf103c_dock_toprow_event(dock, toprow_index: 5, NULL); |
544 | return; |
545 | case 17: |
546 | tf103c_dock_toprow_event(dock, toprow_index: 6, NULL); |
547 | return; |
548 | } |
549 | |
550 | dev_warn(dev, "warning unknown SCI value: 0x%02x\n" , val); |
551 | } |
552 | |
553 | static void tf103c_dock_smi(struct tf103c_dock_data *dock, u8 val) |
554 | { |
555 | struct device *dev = &dock->ec_client->dev; |
556 | |
557 | switch (val) { |
558 | case TF103C_DOCK_SMI_EC_WAKEUP: |
559 | tf103c_dock_ec_cmd(dock, cmd: tf103c_dock_enable_cmd); |
560 | tf103c_dock_ec_cmd(dock, cmd: tf103c_dock_usb_enable_cmd); |
561 | tf103c_dock_kbd_write(dock, TF103C_DOCK_KBD_CMD_ENABLE); |
562 | break; |
563 | case TF103C_DOCK_SMI_PAD_BL_CHANGE: |
564 | /* There is no backlight, but the EC still sends this */ |
565 | break; |
566 | case TF103C_DOCK_SMI_HID_STATUS_CHANGED: |
567 | tf103c_dock_enable_touchpad(dock); |
568 | break; |
569 | default: |
570 | dev_warn(dev, "warning unknown SMI value: 0x%02x\n" , val); |
571 | break; |
572 | } |
573 | } |
574 | |
575 | static irqreturn_t tf103c_dock_irq(int irq, void *data) |
576 | { |
577 | struct tf103c_dock_data *dock = data; |
578 | struct device *dev = &dock->ec_client->dev; |
579 | u8 intr_data[8]; |
580 | int ret; |
581 | |
582 | ret = i2c_smbus_read_i2c_block_data(client: dock->intr_client, TF103C_DOCK_INTR_DATA_REG, |
583 | length: sizeof(intr_data), values: intr_data); |
584 | if (ret != sizeof(intr_data)) { |
585 | dev_err(dev, "error %d reading intr data\n" , ret); |
586 | return IRQ_NONE; |
587 | } |
588 | |
589 | if (!(intr_data[1] & TF103C_DOCK_INTR_DATA1_OBF_MASK)) |
590 | return IRQ_NONE; |
591 | |
592 | /* intr_data[0] is the length of the rest of the packet */ |
593 | if (intr_data[0] == 3 && intr_data[1] == TF103C_DOCK_INTR_DATA1_OOB_VALUE && |
594 | intr_data[2] == TF103C_DOCK_INTR_DATA2_OOB_VALUE) { |
595 | /* intr_data[3] seems to contain a HID input report id */ |
596 | switch (intr_data[3]) { |
597 | case 0x01: |
598 | handle_nested_irq(irq: dock->tp_irq); |
599 | break; |
600 | case 0x11: |
601 | case 0x13: |
602 | case 0x14: |
603 | tf103c_dock_kbd_interrupt(dock); |
604 | break; |
605 | default: |
606 | dev_warn(dev, "warning unknown intr_data[3]: 0x%02x\n" , intr_data[3]); |
607 | break; |
608 | } |
609 | return IRQ_HANDLED; |
610 | } |
611 | |
612 | if (intr_data[1] & TF103C_DOCK_INTR_DATA1_SCI_MASK) { |
613 | tf103c_dock_sci(dock, val: intr_data[2]); |
614 | return IRQ_HANDLED; |
615 | } |
616 | |
617 | if (intr_data[1] & TF103C_DOCK_INTR_DATA1_SMI_MASK) { |
618 | tf103c_dock_smi(dock, val: intr_data[2]); |
619 | return IRQ_HANDLED; |
620 | } |
621 | |
622 | dev_warn(dev, "warning unknown intr data: %*ph\n" , 8, intr_data); |
623 | return IRQ_NONE; |
624 | } |
625 | |
626 | /* |
627 | * tf103c_dock_[dis|en]able only run from hpd_work or at times when |
628 | * hpd_work cannot run (hpd_irq disabled), so no locking is necessary. |
629 | */ |
630 | static void tf103c_dock_enable(struct tf103c_dock_data *dock) |
631 | { |
632 | if (dock->enabled) |
633 | return; |
634 | |
635 | if (dock->board_rev != 2) |
636 | gpiod_set_value(desc: dock->pwr_en, value: 1); |
637 | |
638 | msleep(msecs: 500); |
639 | enable_irq(irq: dock->irq); |
640 | |
641 | dock->enabled = true; |
642 | } |
643 | |
644 | static void tf103c_dock_disable(struct tf103c_dock_data *dock) |
645 | { |
646 | if (!dock->enabled) |
647 | return; |
648 | |
649 | disable_irq(irq: dock->irq); |
650 | tf103c_dock_disable_touchpad(dock); |
651 | if (dock->board_rev != 2) |
652 | gpiod_set_value(desc: dock->pwr_en, value: 0); |
653 | |
654 | dock->enabled = false; |
655 | } |
656 | |
657 | static void tf103c_dock_hpd_work(struct work_struct *work) |
658 | { |
659 | struct tf103c_dock_data *dock = |
660 | container_of(work, struct tf103c_dock_data, hpd_work.work); |
661 | |
662 | if (gpiod_get_value(desc: dock->hpd_gpio)) |
663 | tf103c_dock_enable(dock); |
664 | else |
665 | tf103c_dock_disable(dock); |
666 | } |
667 | |
668 | static irqreturn_t tf103c_dock_hpd_irq(int irq, void *data) |
669 | { |
670 | struct tf103c_dock_data *dock = data; |
671 | |
672 | mod_delayed_work(wq: system_long_wq, dwork: &dock->hpd_work, TF103C_DOCK_HPD_DEBOUNCE); |
673 | return IRQ_HANDLED; |
674 | } |
675 | |
676 | static void tf103c_dock_start_hpd(struct tf103c_dock_data *dock) |
677 | { |
678 | enable_irq(irq: dock->hpd_irq); |
679 | /* Sync current HPD status */ |
680 | queue_delayed_work(wq: system_long_wq, dwork: &dock->hpd_work, TF103C_DOCK_HPD_DEBOUNCE); |
681 | } |
682 | |
683 | static void tf103c_dock_stop_hpd(struct tf103c_dock_data *dock) |
684 | { |
685 | disable_irq(irq: dock->hpd_irq); |
686 | cancel_delayed_work_sync(dwork: &dock->hpd_work); |
687 | } |
688 | |
689 | /*** probe ***/ |
690 | |
691 | static const struct dmi_system_id tf103c_dock_dmi_ids[] = { |
692 | { |
693 | .matches = { |
694 | DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC." ), |
695 | DMI_MATCH(DMI_PRODUCT_NAME, "TF103C" ), |
696 | }, |
697 | }, |
698 | { } |
699 | }; |
700 | |
701 | static void tf103c_dock_non_devm_cleanup(void *data) |
702 | { |
703 | struct tf103c_dock_data *dock = data; |
704 | |
705 | if (dock->tp_irq_domain) |
706 | irq_domain_remove(host: dock->tp_irq_domain); |
707 | |
708 | if (!IS_ERR_OR_NULL(ptr: dock->hid)) |
709 | hid_destroy_device(dock->hid); |
710 | |
711 | i2c_unregister_device(client: dock->kbd_client); |
712 | i2c_unregister_device(client: dock->intr_client); |
713 | gpiod_remove_lookup_table(table: &tf103c_dock_gpios); |
714 | } |
715 | |
716 | static int tf103c_dock_probe(struct i2c_client *client) |
717 | { |
718 | struct i2c_board_info board_info = { }; |
719 | struct device *dev = &client->dev; |
720 | struct gpio_desc *board_rev_gpio; |
721 | struct tf103c_dock_data *dock; |
722 | enum gpiod_flags flags; |
723 | int i, ret; |
724 | |
725 | /* GPIOs are hardcoded for the Asus TF103C, don't bind on other devs */ |
726 | if (!dmi_check_system(list: tf103c_dock_dmi_ids)) |
727 | return -ENODEV; |
728 | |
729 | dock = devm_kzalloc(dev, size: sizeof(*dock), GFP_KERNEL); |
730 | if (!dock) |
731 | return -ENOMEM; |
732 | |
733 | INIT_DELAYED_WORK(&dock->hpd_work, tf103c_dock_hpd_work); |
734 | |
735 | /* 1. Get GPIOs and their IRQs */ |
736 | gpiod_add_lookup_table(table: &tf103c_dock_gpios); |
737 | |
738 | ret = devm_add_action_or_reset(dev, tf103c_dock_non_devm_cleanup, dock); |
739 | if (ret) |
740 | return ret; |
741 | |
742 | /* |
743 | * The pin is configured as input by default, use ASIS because otherwise |
744 | * the gpio-crystalcove.c switches off the internal pull-down replacing |
745 | * it with a pull-up. |
746 | */ |
747 | board_rev_gpio = gpiod_get(dev, con_id: "board_rev" , flags: GPIOD_ASIS); |
748 | if (IS_ERR(ptr: board_rev_gpio)) |
749 | return dev_err_probe(dev, err: PTR_ERR(ptr: board_rev_gpio), fmt: "requesting board_rev GPIO\n" ); |
750 | dock->board_rev = gpiod_get_value_cansleep(desc: board_rev_gpio) + 1; |
751 | gpiod_put(desc: board_rev_gpio); |
752 | |
753 | /* |
754 | * The Android driver drives the dock-pwr-en pin high at probe for |
755 | * revision 2 boards and then never touches it again? |
756 | * This code has only been tested on a revision 1 board, so for now |
757 | * just mimick what Android does on revision 2 boards. |
758 | */ |
759 | flags = (dock->board_rev == 2) ? GPIOD_OUT_HIGH : GPIOD_OUT_LOW; |
760 | dock->pwr_en = devm_gpiod_get(dev, con_id: "dock_pwr_en" , flags); |
761 | if (IS_ERR(ptr: dock->pwr_en)) |
762 | return dev_err_probe(dev, err: PTR_ERR(ptr: dock->pwr_en), fmt: "requesting pwr_en GPIO\n" ); |
763 | |
764 | dock->irq_gpio = devm_gpiod_get(dev, con_id: "dock_irq" , flags: GPIOD_IN); |
765 | if (IS_ERR(ptr: dock->irq_gpio)) |
766 | return dev_err_probe(dev, err: PTR_ERR(ptr: dock->irq_gpio), fmt: "requesting IRQ GPIO\n" ); |
767 | |
768 | dock->irq = gpiod_to_irq(desc: dock->irq_gpio); |
769 | if (dock->irq < 0) |
770 | return dev_err_probe(dev, err: dock->irq, fmt: "getting dock IRQ" ); |
771 | |
772 | ret = devm_request_threaded_irq(dev, irq: dock->irq, NULL, thread_fn: tf103c_dock_irq, |
773 | IRQF_TRIGGER_LOW | IRQF_ONESHOT | IRQF_NO_AUTOEN, |
774 | devname: "dock_irq" , dev_id: dock); |
775 | if (ret) |
776 | return dev_err_probe(dev, err: ret, fmt: "requesting dock IRQ" ); |
777 | |
778 | dock->hpd_gpio = devm_gpiod_get(dev, con_id: "dock_hpd" , flags: GPIOD_IN); |
779 | if (IS_ERR(ptr: dock->hpd_gpio)) |
780 | return dev_err_probe(dev, err: PTR_ERR(ptr: dock->hpd_gpio), fmt: "requesting HPD GPIO\n" ); |
781 | |
782 | dock->hpd_irq = gpiod_to_irq(desc: dock->hpd_gpio); |
783 | if (dock->hpd_irq < 0) |
784 | return dev_err_probe(dev, err: dock->hpd_irq, fmt: "getting HPD IRQ" ); |
785 | |
786 | ret = devm_request_irq(dev, irq: dock->hpd_irq, handler: tf103c_dock_hpd_irq, |
787 | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_NO_AUTOEN, |
788 | devname: "dock_hpd" , dev_id: dock); |
789 | if (ret) |
790 | return ret; |
791 | |
792 | /* |
793 | * 2. Create I2C clients. The dock uses 4 different i2c addresses, |
794 | * the ACPI NPCE69A node being probed points to the EC address. |
795 | */ |
796 | dock->ec_client = client; |
797 | |
798 | strscpy(board_info.type, "tf103c-dock-intr" , I2C_NAME_SIZE); |
799 | board_info.addr = TF103C_DOCK_INTR_ADDR; |
800 | board_info.dev_name = TF103C_DOCK_DEV_NAME "-intr" ; |
801 | |
802 | dock->intr_client = i2c_new_client_device(adap: client->adapter, info: &board_info); |
803 | if (IS_ERR(ptr: dock->intr_client)) |
804 | return dev_err_probe(dev, err: PTR_ERR(ptr: dock->intr_client), fmt: "creating intr client\n" ); |
805 | |
806 | strscpy(board_info.type, "tf103c-dock-kbd" , I2C_NAME_SIZE); |
807 | board_info.addr = TF103C_DOCK_KBD_ADDR; |
808 | board_info.dev_name = TF103C_DOCK_DEV_NAME "-kbd" ; |
809 | |
810 | dock->kbd_client = i2c_new_client_device(adap: client->adapter, info: &board_info); |
811 | if (IS_ERR(ptr: dock->kbd_client)) |
812 | return dev_err_probe(dev, err: PTR_ERR(ptr: dock->kbd_client), fmt: "creating kbd client\n" ); |
813 | |
814 | /* 3. Create input_dev for the top row of the keyboard */ |
815 | dock->input = devm_input_allocate_device(dev); |
816 | if (!dock->input) |
817 | return -ENOMEM; |
818 | |
819 | dock->input->name = "Asus TF103C Dock Top Row Keys" ; |
820 | dock->input->phys = dev_name(dev); |
821 | dock->input->dev.parent = dev; |
822 | dock->input->id.bustype = BUS_I2C; |
823 | dock->input->id.vendor = /* USB_VENDOR_ID_ASUSTEK */ |
824 | dock->input->id.product = /* From TF-103-C */ |
825 | dock->input->id.version = 0x0100; /* 1.0 */ |
826 | |
827 | for (i = 0; i < ARRAY_SIZE(tf103c_dock_toprow_codes); i++) { |
828 | input_set_capability(dev: dock->input, EV_KEY, code: tf103c_dock_toprow_codes[i][0]); |
829 | input_set_capability(dev: dock->input, EV_KEY, code: tf103c_dock_toprow_codes[i][1]); |
830 | } |
831 | input_set_capability(dev: dock->input, EV_KEY, KEY_RIGHTALT); |
832 | |
833 | ret = input_register_device(dock->input); |
834 | if (ret) |
835 | return ret; |
836 | |
837 | /* 4. Create HID device for the keyboard */ |
838 | dock->hid = hid_allocate_device(); |
839 | if (IS_ERR(ptr: dock->hid)) |
840 | return dev_err_probe(dev, err: PTR_ERR(ptr: dock->hid), fmt: "allocating hid dev\n" ); |
841 | |
842 | dock->hid->driver_data = dock; |
843 | dock->hid->ll_driver = &tf103c_dock_hid_ll_driver; |
844 | dock->hid->dev.parent = &client->dev; |
845 | dock->hid->bus = BUS_I2C; |
846 | dock->hid->vendor = 0x0b05; /* USB_VENDOR_ID_ASUSTEK */ |
847 | dock->hid->product = 0x0103; /* From TF-103-C */ |
848 | dock->hid->version = 0x0100; /* 1.0 */ |
849 | strscpy(dock->hid->name, "Asus TF103C Dock Keyboard" , sizeof(dock->hid->name)); |
850 | strscpy(dock->hid->phys, dev_name(dev), sizeof(dock->hid->phys)); |
851 | |
852 | ret = hid_add_device(dock->hid); |
853 | if (ret) |
854 | return dev_err_probe(dev, err: ret, fmt: "adding hid dev\n" ); |
855 | |
856 | /* 5. Setup irqchip for touchpad IRQ pass-through */ |
857 | dock->tp_irqchip.name = KBUILD_MODNAME; |
858 | |
859 | dock->tp_irq_domain = irq_domain_add_linear(NULL, size: 1, ops: &irq_domain_simple_ops, NULL); |
860 | if (!dock->tp_irq_domain) |
861 | return -ENOMEM; |
862 | |
863 | dock->tp_irq = irq_create_mapping(host: dock->tp_irq_domain, hwirq: 0); |
864 | if (!dock->tp_irq) |
865 | return -ENOMEM; |
866 | |
867 | irq_set_chip_data(irq: dock->tp_irq, data: dock); |
868 | irq_set_chip_and_handler(irq: dock->tp_irq, chip: &dock->tp_irqchip, handle: handle_simple_irq); |
869 | irq_set_nested_thread(irq: dock->tp_irq, nest: true); |
870 | irq_set_noprobe(irq: dock->tp_irq); |
871 | |
872 | dev_info(dev, "Asus TF103C board-revision: %d\n" , dock->board_rev); |
873 | |
874 | tf103c_dock_start_hpd(dock); |
875 | |
876 | device_init_wakeup(dev, enable: true); |
877 | i2c_set_clientdata(client, data: dock); |
878 | return 0; |
879 | } |
880 | |
881 | static void tf103c_dock_remove(struct i2c_client *client) |
882 | { |
883 | struct tf103c_dock_data *dock = i2c_get_clientdata(client); |
884 | |
885 | tf103c_dock_stop_hpd(dock); |
886 | tf103c_dock_disable(dock); |
887 | } |
888 | |
889 | static int __maybe_unused tf103c_dock_suspend(struct device *dev) |
890 | { |
891 | struct tf103c_dock_data *dock = dev_get_drvdata(dev); |
892 | |
893 | tf103c_dock_stop_hpd(dock); |
894 | |
895 | if (dock->enabled) { |
896 | tf103c_dock_ec_cmd(dock, cmd: tf103c_dock_suspend_cmd); |
897 | |
898 | if (device_may_wakeup(dev)) |
899 | enable_irq_wake(irq: dock->irq); |
900 | } |
901 | |
902 | return 0; |
903 | } |
904 | |
905 | static int __maybe_unused tf103c_dock_resume(struct device *dev) |
906 | { |
907 | struct tf103c_dock_data *dock = dev_get_drvdata(dev); |
908 | |
909 | if (dock->enabled) { |
910 | if (device_may_wakeup(dev)) |
911 | disable_irq_wake(irq: dock->irq); |
912 | |
913 | /* Don't try to resume if the dock was unplugged during suspend */ |
914 | if (gpiod_get_value(desc: dock->hpd_gpio)) |
915 | tf103c_dock_ec_cmd(dock, cmd: tf103c_dock_enable_cmd); |
916 | } |
917 | |
918 | tf103c_dock_start_hpd(dock); |
919 | return 0; |
920 | } |
921 | |
922 | static SIMPLE_DEV_PM_OPS(tf103c_dock_pm_ops, tf103c_dock_suspend, tf103c_dock_resume); |
923 | |
924 | static const struct acpi_device_id tf103c_dock_acpi_match[] = { |
925 | {"NPCE69A" }, |
926 | { } |
927 | }; |
928 | MODULE_DEVICE_TABLE(acpi, tf103c_dock_acpi_match); |
929 | |
930 | static struct i2c_driver tf103c_dock_driver = { |
931 | .driver = { |
932 | .name = "asus-tf103c-dock" , |
933 | .pm = &tf103c_dock_pm_ops, |
934 | .acpi_match_table = tf103c_dock_acpi_match, |
935 | }, |
936 | .probe = tf103c_dock_probe, |
937 | .remove = tf103c_dock_remove, |
938 | }; |
939 | module_i2c_driver(tf103c_dock_driver); |
940 | |
941 | MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com" ); |
942 | MODULE_DESCRIPTION("X86 Android tablets DSDT fixups driver" ); |
943 | MODULE_LICENSE("GPL" ); |
944 | |