/* Elan HID-over-I2C touchpad on the Braswell LPSS I2C bus. * * The HP Chromebook 11 G5 EE (setzer) wires its touchpad to LPSS I2C6 at * 0xD1327000, slave address 0x15. The LPSS I2C functions are hidden from * PCI in ACPI mode, so the driver scans the two firmware BAR windows for * DesignWare component types instead of enumerating PCI. * * The report line is a GPIO we have no driver for, so the input register is * polled. A read with no pending report returns a zero length immediately. * Reading the register back-to-back stalls the device: 25 ms (40 Hz) is the * rate it keeps up with, and the pointer still moves smoothly. * * Init follows Linux's elan_i2c: reset, consume the 2-byte reset * acknowledgement, read the HID descriptor and the max-X/Y commands, select * absolute mode (0x0300) and wake the device (0x0800). * * Report decoding is Elan-specific; the contact behaviour (pointer deltas, * taps, the physical-button latch and two-finger scrolling) lives in * touchpad_gesture.c so another touchpad driver can reuse it. */ #include "touchpad.h" #include "touchpad_gesture.h" #include "i2c.h" #include "io.h" #include "paging.h" #include "timer.h" #define TP_ADDR 0x15 #define TP_CTRL_MAX 16 #define TP_CTRL_STEP 0x1000u #define TP_HID_DESC_REG 0x0001 #define TP_HID_DESC_LEN 30 #define TP_CMD_REG 0x0005 #define TP_CMD_RESET 0x0100 #define TP_CMD_WAKE 0x0800 #define TP_MODE_REG 0x0300 #define TP_MODE_ABS 0x0001 #define TP_DW_COMP_TYPE 0x44570140u #define TP_REPORT_ID 0x5d #define TP_MAX_X_REG 0x0106 #define TP_MAX_Y_REG 0x0107 #define TP_ABS_MAX 4095 #define TP_MAX_INPUT 64 #define TP_POLL_MS 25 static unsigned int tp_base; static unsigned int tp_addr = TP_ADDR; static int tp_present; static unsigned int tp_in_reg = 0x0003; static unsigned int tp_max_in = 34; static unsigned int tp_cmd_reg = TP_CMD_REG; static unsigned short tp_vendor; static unsigned short tp_product; static int tp_max_x = TP_ABS_MAX; static int tp_max_y = TP_ABS_MAX; static const char *tp_err; static unsigned int tp_err_val; static struct tpg_state tp_gesture; static int tp_last_buttons; static unsigned int tp_next_poll; /* Last report, for the `touchpad` status command. */ static int tp_stat_fingers, tp_stat_f1, tp_stat_x, tp_stat_y; static void put_dec(unsigned int v); static const char *rc_name(void); static void put_hex16(unsigned int v) { static const char hex[] = "0123456789ABCDEF"; io_putchar(hex[(v >> 12) & 0xf]); io_putchar(hex[(v >> 8) & 0xf]); io_putchar(hex[(v >> 4) & 0xf]); io_putchar(hex[v & 0xf]); } static void print_summary(void) { io_putstr("touchpad: elan "); put_hex16(tp_vendor); io_putchar(':'); put_hex16(tp_product); io_putstr(" i2c 0x"); io_puthex(tp_base); io_putstr(" addr 0x"); io_puthex(tp_addr); io_putstr(" max "); put_dec((unsigned int)tp_max_x); io_putchar('x'); put_dec((unsigned int)tp_max_y); io_putchar('\n'); } static void print_status(void) { unsigned int opts = tpg_options(&tp_gesture); print_summary(); io_putstr("touchpad: rightclick "); io_putstr(rc_name()); io_putstr(" tapclick "); io_putstr((opts & TPG_TAPCLICK) ? "on" : "off"); io_putstr(" scroll "); io_putstr((opts & TPG_SCROLL) ? "on" : "off"); if (opts & TPG_SCROLL) { io_putchar(' '); io_putstr((opts & TPG_SCROLL_INVERT) ? "traditional" : "natural"); } io_putstr(" corner x>="); put_dec((unsigned int)(tp_max_x * TPG_CORNER_X_PCT / 100)); io_putstr(" y<="); put_dec((unsigned int)(tp_max_y * TPG_CORNER_Y_PCT / 100)); io_putchar('\n'); io_putstr("touchpad: last f="); put_dec((unsigned int)tp_stat_fingers); if (tp_stat_f1) { io_putstr(" x="); put_dec((unsigned int)tp_stat_x); io_putstr(" y="); put_dec((unsigned int)tp_stat_y); } io_putstr(" taps left="); put_dec(tp_gesture.taps_left); io_putstr(" right="); put_dec(tp_gesture.taps_right); io_putchar('\n'); } static void msleep(unsigned int ms) { unsigned int t0 = get_ticks_ms(); while (get_ticks_ms() - t0 < ms) ; } static unsigned int get16(const unsigned char *p) { return (unsigned int)p[0] | ((unsigned int)p[1] << 8); } static void put_dec(unsigned int v) { char buf[11]; unsigned int i = 0; if (!v) { io_putchar('0'); return; } while (v) { buf[i++] = (char)('0' + v % 10); v /= 10; } while (i) io_putchar(buf[--i]); } /* Match one whitespace-delimited word at s (end or space after it). */ static int word_is(const char *s, const char *word) { while (*word) { if (*s != *word) return 0; s++; word++; } return *s == '\0' || *s == ' '; } static const char *skip_spaces(const char *s) { while (*s == ' ') s++; return s; } static unsigned int word_len(const char *s) { unsigned int n = 0; while (s[n] && s[n] != ' ') n++; return n; } static const char *rc_name(void) { unsigned int m = tpg_options(&tp_gesture) & (TPG_RIGHT_TAP | TPG_RIGHT_CORNER); if (m == TPG_RIGHT_TAP) return "tap"; if (m == TPG_RIGHT_CORNER) return "corner"; if (m == (TPG_RIGHT_TAP | TPG_RIGHT_CORNER)) return "both"; return "off"; } static int hid_read_reg(unsigned int addr, unsigned int reg, unsigned char *buf, unsigned int len) { unsigned char r[2]; r[0] = (unsigned char)(reg & 0xff); r[1] = (unsigned char)(reg >> 8); if (i2c_dw_transfer(tp_base, addr, r, 2, buf, len) == 0) return 0; /* Some devices do not answer the combined write+read (repeated * start). Retry with a STOP between the register address and the * data read. */ if (i2c_dw_transfer(tp_base, addr, r, 2, 0, 0) != 0) return -1; return i2c_dw_transfer(tp_base, addr, 0, 0, buf, len); } static int hid_write_reg(unsigned int addr, unsigned int reg, unsigned int val) { unsigned char b[4]; b[0] = (unsigned char)(reg & 0xff); b[1] = (unsigned char)(reg >> 8); b[2] = (unsigned char)(val & 0xff); b[3] = (unsigned char)(val >> 8); return i2c_dw_transfer(tp_base, addr, b, 4, 0, 0); } /* Native Elan max-coordinate commands (the same read-cmd path Linux * elan_i2c uses). They give the corner zone a physical frame instead of * assuming the full 12-bit range; on failure keep the 4095 fallback. */ static void query_limits(void) { unsigned char v[2]; if (hid_read_reg(tp_addr, TP_MAX_X_REG, v, 2) == 0) { unsigned int m = get16(v) & 0x0fff; if (m >= 256) tp_max_x = (int)m; } if (hid_read_reg(tp_addr, TP_MAX_Y_REG, v, 2) == 0) { unsigned int m = get16(v) & 0x0fff; if (m >= 256) tp_max_y = (int)m; } } static int probe_controller(unsigned int base) { unsigned char desc[TP_HID_DESC_LEN + 2]; unsigned char ack[2]; unsigned int off, len, ver; if (!i2c_dw_present(base)) return 0; if (i2c_dw_init(base) != 0) { tp_err = "i2c init failed"; return 0; } tp_base = base; /* The Elan address is fixed; a plain read is a harmless ACK check. */ if (i2c_dw_transfer(base, TP_ADDR, 0, 0, ack, 1) != 0) { tp_err = "no device at 0x15"; return 0; } /* Reset first and consume the acknowledgement, then read the HID * descriptor. The descriptor read is prefixed with two status * bytes and the 2-byte length, so accept either offset. */ hid_write_reg(TP_ADDR, TP_CMD_REG, TP_CMD_RESET); msleep(150); (void)i2c_dw_transfer(base, TP_ADDR, 0, 0, ack, 2); if (hid_read_reg(TP_ADDR, TP_HID_DESC_REG, desc, sizeof(desc)) != 0) { tp_err = "descriptor read failed"; tp_err_val = i2c_last_abort; return 0; } off = 0; if (get16(desc + 0) != TP_HID_DESC_LEN || get16(desc + 2) != 0x0100) { if (get16(desc + 2) == TP_HID_DESC_LEN && get16(desc + 4) == 0x0100) off = 2; } len = get16(desc + off); ver = get16(desc + off + 2); if (len != TP_HID_DESC_LEN || ver != 0x0100) { tp_err = "bad hid descriptor"; return 0; } tp_in_reg = get16(desc + off + 8); tp_max_in = get16(desc + off + 10); tp_cmd_reg = get16(desc + off + 16); tp_vendor = (unsigned short)get16(desc + off + 20); tp_product = (unsigned short)get16(desc + off + 22); if (tp_max_in < 12 || tp_max_in > TP_MAX_INPUT) tp_max_in = 34; /* Absolute reporting, then wake: after the reset the Elan stays * quiet until the host selects a mode. */ hid_write_reg(TP_ADDR, TP_MODE_REG, TP_MODE_ABS); msleep(40); hid_write_reg(TP_ADDR, tp_cmd_reg, TP_CMD_WAKE); msleep(60); /* Query the limits with the device awake (Linux reads them after * initialize()/wake and before enabling reports). */ query_limits(); tpg_init(&tp_gesture, tp_max_x, tp_max_y, 2); tp_present = 1; tp_err = 0; print_summary(); return 1; } int touchpad_init(void) { /* The ACPI _CRS address for the LPSS I2C blocks is 0x9132xxxx on * coreboot, but this firmware maps them at 0xD132xxxx. Both * windows are scanned; page 7 (I2C6) is tried first. */ static const unsigned int ranges[2] = { 0x91320000u, 0xd1320000u }; unsigned int r, k; if (tp_present) return 1; for (r = 0; r < 2; r++) { for (k = 0; k < TP_CTRL_MAX; k++) { unsigned int i = (k + 7) % TP_CTRL_MAX; unsigned int base = ranges[r] + i * TP_CTRL_STEP; paging_map_mmio(base, 0x1000); /* A block left in functional reset keeps its * register file but never clocks the I2C FSM. */ i2c_dw_reset_release(base); if (probe_controller(base)) return 1; } } return 0; } int touchpad_present(void) { return tp_present; } unsigned int touchpad_addr(void) { return tp_addr; } unsigned short touchpad_vendor(void) { return tp_vendor; } unsigned short touchpad_product(void) { return tp_product; } int touchpad_poll(int *buttons, int *dx, int *dy, int *scroll) { unsigned char buf[TP_MAX_INPUT]; unsigned int now, b; struct tpg_result res; *buttons = 0; *dx = 0; *dy = 0; *scroll = 0; if (!tp_present) return 0; now = get_ticks_ms(); /* The synthetic tap press is released by time, whether or not a new * report arrives (the finger is already up). */ tpg_tick(&tp_gesture, now, &res); if (res.buttons != (unsigned int)tp_last_buttons) { tp_last_buttons = (int)res.buttons; *buttons = res.buttons; return 1; } if ((int)(now - tp_next_poll) < 0) return 0; tp_next_poll = now + TP_POLL_MS; if (hid_read_reg(tp_addr, tp_in_reg, buf, tp_max_in) != 0) return 0; /* The addressed read returns two status bytes, the 2-byte length * and then the report, so locate the 0x5D report ID instead of * trusting a fixed offset. Layout after it (Linux hid-elan.c): * touch info (f5..f1 at bits 7..3, clickpad at bit 0), then 5 * bytes per *active* finger (packed): x11:8/y11:9, x7:0, y7:0, * size, pressure. */ for (b = 0; b < 6 && b + 6 < tp_max_in; b++) if (buf[b] == TP_REPORT_ID) break; if (b >= 6 || b + 6 >= tp_max_in) return 0; { struct tpg_frame f; unsigned int ti = buf[b + 1]; unsigned int off = b + 2; unsigned int i, n = 0; f.count = 0; f.mask = 0; f.button = ti & 0x01; f.now_ms = now; for (i = 0; i < 5; i++) { if (!(ti & (0x08u << i))) continue; f.count++; if (n < TPG_CONTACTS && off + 4 < tp_max_in) { unsigned int xh = buf[off]; f.contact[n].x = ((int)(xh & 0xf0) << 4) | buf[off + 1]; f.contact[n].y = ((int)(xh & 0x0f) << 8) | buf[off + 2]; f.mask |= 1u << n; n++; } off += 5; } tp_stat_fingers = (int)f.count; tp_stat_f1 = (f.mask & 1u) != 0; if (f.mask & 1u) { tp_stat_x = f.contact[0].x; tp_stat_y = f.contact[0].y; } tpg_frame(&tp_gesture, &f, &res); } *buttons = res.buttons; *dx = res.dx; *dy = res.dy; *scroll = res.scroll; if (res.buttons != (unsigned int)tp_last_buttons) { tp_last_buttons = (int)res.buttons; return 1; } return res.dx || res.dy || res.scroll; } void program_touchpad_main(const char *arg) { if (!tp_present) { io_putstr("touchpad: absent ("); io_putstr(tp_err ? tp_err : "unknown"); if (tp_err_val) { io_putstr(" ab="); io_puthex(tp_err_val); } io_putstr(")\n"); return; } arg = arg ? skip_spaces(arg) : 0; if (!arg || !*arg) { print_status(); return; } while (*arg) { unsigned int opts = tpg_options(&tp_gesture); if (word_is(arg, "rightclick")) { const char *v = skip_spaces(arg + 10); if (!*v) { io_putstr("touchpad: rightclick "); io_putstr(rc_name()); io_putchar('\n'); return; } opts &= ~(TPG_RIGHT_TAP | TPG_RIGHT_CORNER); if (word_is(v, "off")) { /* keep both bits clear */ } else if (word_is(v, "tap")) { opts |= TPG_RIGHT_TAP; } else if (word_is(v, "corner")) { opts |= TPG_RIGHT_CORNER; } else if (word_is(v, "both")) { opts |= TPG_RIGHT_TAP | TPG_RIGHT_CORNER; } else { io_putstr("touchpad: rightclick off|tap|corner|both\n"); return; } tpg_set_options(&tp_gesture, opts); io_putstr("touchpad: rightclick "); io_putstr(rc_name()); io_putchar('\n'); arg = skip_spaces(v + word_len(v)); } else if (word_is(arg, "tapclick")) { const char *v = skip_spaces(arg + 8); if (!*v) { io_putstr("touchpad: tapclick "); io_putstr((opts & TPG_TAPCLICK) ? "on" : "off"); io_putchar('\n'); return; } if (word_is(v, "on")) opts |= TPG_TAPCLICK; else if (word_is(v, "off")) opts &= ~TPG_TAPCLICK; else { io_putstr("touchpad: tapclick on|off\n"); return; } tpg_set_options(&tp_gesture, opts); io_putstr("touchpad: tapclick "); io_putstr((opts & TPG_TAPCLICK) ? "on" : "off"); io_putchar('\n'); arg = skip_spaces(v + word_len(v)); } else if (word_is(arg, "scroll")) { const char *v = skip_spaces(arg + 6); if (!*v) { io_putstr("touchpad: scroll "); io_putstr((opts & TPG_SCROLL) ? "on" : "off"); if (opts & TPG_SCROLL) { io_putchar(' '); io_putstr((opts & TPG_SCROLL_INVERT) ? "traditional" : "natural"); } io_putchar('\n'); return; } if (word_is(v, "on")) { opts |= TPG_SCROLL; } else if (word_is(v, "off")) { opts &= ~TPG_SCROLL; } else if (word_is(v, "natural")) { opts |= TPG_SCROLL; opts &= ~TPG_SCROLL_INVERT; } else if (word_is(v, "traditional")) { opts |= TPG_SCROLL; opts |= TPG_SCROLL_INVERT; } else { io_putstr("touchpad: scroll on|off|natural|traditional\n"); return; } tpg_set_options(&tp_gesture, opts); io_putstr("touchpad: scroll "); io_putstr((opts & TPG_SCROLL) ? "on" : "off"); if (opts & TPG_SCROLL) { io_putchar(' '); io_putstr((opts & TPG_SCROLL_INVERT) ? "traditional" : "natural"); } io_putchar('\n'); arg = skip_spaces(v + word_len(v)); } else { io_putstr("touchpad: usage: touchpad [rightclick off|tap|corner|both | tapclick on|off | scroll on|off|natural|traditional]\n"); return; } } }