ish: Trim down the release branchstabilize-wristpin-14469.59.B-ishstabilize-voshyr-14637.B-ishstabilize-quickfix-14695.187.B-ishstabilize-quickfix-14695.124.B-ishstabilize-quickfix-14526.91.B-ishstabilize-14695.85.B-ishstabilize-14695.107.B-ishstabilize-14682.B-ishstabilize-14633.B-ishstabilize-14616.B-ishstabilize-14589.B-ishstabilize-14588.98.B-ishstabilize-14588.14.B-ishstabilize-14588.123.B-ishstabilize-14536.B-ishstabilize-14532.B-ishstabilize-14528.B-ishstabilize-14526.89.B-ishstabilize-14526.84.B-ishstabilize-14526.73.B-ishstabilize-14526.67.B-ishstabilize-14526.57.B-ishstabilize-14498.B-ishstabilize-14496.B-ishstabilize-14477.B-ishstabilize-14469.9.B-ishstabilize-14469.8.B-ishstabilize-14469.58.B-ishstabilize-14469.41.B-ishstabilize-14442.B-ishstabilize-14438.B-ishstabilize-14411.B-ishstabilize-14396.B-ishstabilize-14395.B-ishstabilize-14388.62.B-ishstabilize-14388.61.B-ishstabilize-14388.52.B-ishstabilize-14385.B-ishstabilize-14345.B-ishstabilize-14336.B-ishstabilize-14333.B-ishrelease-R99-14469.B-ishrelease-R98-14388.B-ishrelease-R102-14695.B-ishrelease-R101-14588.B-ishrelease-R100-14526.B-ishfirmware-cherry-14454.B-ishfirmware-brya-14505.B-ishfirmware-brya-14505.71.B-ishfactory-kukui-14374.B-ishfactory-guybrush-14600.B-ishfactory-cherry-14455.B-ishfactory-brya-14517.B-ish

In the interest of making long-term branch maintenance incur as little
technical debt on us as possible, we should not maintain any files on
the branch we are not actually using.

This has the added effect of making it extremely clear when merging CLs
from the main branch when changes have the possibility to affect us.

The follow-on CL adds a convenience script to actually pull updates from
the main branch and generate a CL for the update.

BUG=b:204206272
BRANCH=ish
TEST=make BOARD=arcada_ish && make BOARD=drallion_ish

Signed-off-by: Jack Rosenthal <jrosenth@chromium.org>
Change-Id: I17e4694c38219b5a0823e0a3e55a28d1348f4b18
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/ec/+/3262038
Reviewed-by: Jett Rink <jettrink@chromium.org>
Reviewed-by: Tom Hughes <tomhughes@chromium.org>

1 files changed, 0 insertions, 797 deletions

diff --git a/common/i2c_hid_touchpad.c b/common/i2c_hid_touchpad.c
deleted file mode 100644
index 29122f83d6..0000000000
--- a/common/i2c_hid_touchpad.c
+++ /dev/null
@@ -1,797 +0,0 @@
-/* Copyright 2020 The Chromium OS Authors. All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "i2c_hid_touchpad.h"
-
-#include "console.h"
-#include "hwtimer.h"
-#include "util.h"
-
-/* 2 bytes for length + 1 byte for report ID */
-#define I2C_HID_HEADER_SIZE			3
-
-/* Report ID */
-#define REPORT_ID_TOUCH				0x01
-#define REPORT_ID_MOUSE				0x02
-#define REPORT_ID_DEVICE_CAPS			0x0A
-#define REPORT_ID_DEVICE_CERT			0x0B
-#define REPORT_ID_INPUT_MODE			0x0C
-#define REPORT_ID_REPORTING			0x0D
-
-#define INPUT_MODE_MOUSE			0x00
-#define INPUT_MODE_TOUCH			0x03
-
-/* VID/PID/FW version */
-#if !defined(I2C_HID_TOUCHPAD_VENDOR_ID) || \
-    !defined(I2C_HID_TOUCHPAD_PRODUCT_ID) || \
-    !defined(I2C_HID_TOUCHPAD_FW_VERSION)
-#error "Must define touchpad VID/PID/FW version"
-#endif
-/*
- * Touchpad properties
- *
- * Physical dimensions are in the unit of mms.
- */
-#if !defined(I2C_HID_TOUCHPAD_MAX_X) || \
-    !defined(I2C_HID_TOUCHPAD_MAX_Y) || \
-    !defined(I2C_HID_TOUCHPAD_MAX_PHYSICAL_X) || \
-    !defined(I2C_HID_TOUCHPAD_MAX_PHYSICAL_Y)
-#error "Must define finger maximum X/Y and physical dimensions"
-#endif
-/*
- * Maximum width/height of the contact (i.e., touch major/minor in Linux MT-B)
- *
- * According to the Linux's MT protocol, the max value of touch major/minor
- * should be sqrt(X^2+Y^2). However, this is rarely implemented by touchpads
- * in practice. Touchpads often output major/minor in custom units with very
- * different data ranges. It is therefore recommended for the user to check the
- * device's spec and set these values manually.
- */
-#if !defined(I2C_HID_TOUCHPAD_MAX_WIDTH) || \
-    !defined(I2C_HID_TOUCHPAD_MAX_HEIGHT) || \
-    !defined(I2C_HID_TOUCHPAD_MAX_PRESSURE)
-#error "Must define finger maximum width/height/pressure"
-#endif
-/*
- * The touchpad is expected to provide at least the horizontal/vertical status
- * for each contact (if one is wider than its height). This can be computed
- * simply as bool(WIDTH>HEIGHT).
- */
-#ifndef I2C_HID_TOUCHPAD_MAX_ORIENTATION
-#error "Must define finger maximum orientation value"
-#endif
-/*
- * Conversion factor between the finger movement and the mouse cursor movement.
- * This is a bit similar to the mouse CPI and is used by mouse reports only.
- */
-#if !defined(I2C_HID_TOUCHPAD_MOUSE_SCALE_X) || \
-    !defined(I2C_HID_TOUCHPAD_MOUSE_SCALE_Y)
-#error "Must define mouse horizontal/vertical scaling factors"
-#endif
-
-/* Helper bit-op macros */
-#define N_BITS(n) \
-( \
-		(n) < (1 << 1) ? 1 : \
-		(n) < (1 << 2) ? 2 : \
-		(n) < (1 << 3) ? 3 : \
-		(n) < (1 << 4) ? 4 : \
-		(n) < (1 << 5) ? 5 : \
-		(n) < (1 << 6) ? 6 : \
-		(n) < (1 << 7) ? 7 : \
-		(n) < (1 << 8) ? 8 : \
-		(n) < (1 << 9) ? 9 : \
-		(n) < (1 << 10) ? 10 : \
-		(n) < (1 << 11) ? 11 : \
-		(n) < (1 << 12) ? 12 : \
-		(n) < (1 << 13) ? 13 : \
-		(n) < (1 << 14) ? 14 : \
-		(n) < (1 << 15) ? 15 : \
-		16 \
-)
-/* We would need to pad some bits at the end of each finger struct to match
- * the allocation unit's boundary so the array indexing may work correctly.
- */
-#define N_VAR_BITS \
-( \
-		N_BITS(I2C_HID_TOUCHPAD_MAX_X) + \
-		N_BITS(I2C_HID_TOUCHPAD_MAX_Y) + \
-		N_BITS(I2C_HID_TOUCHPAD_MAX_WIDTH) + \
-		N_BITS(I2C_HID_TOUCHPAD_MAX_HEIGHT) + \
-		N_BITS(I2C_HID_TOUCHPAD_MAX_PRESSURE) + \
-		N_BITS(I2C_HID_TOUCHPAD_MAX_ORIENTATION) \
-)
-#define N_PADDING_BITS ((DIV_ROUND_UP(N_VAR_BITS, 8) * 8) - N_VAR_BITS)
-#define N_BITS_ORIENTATION \
-	(N_BITS(I2C_HID_TOUCHPAD_MAX_ORIENTATION) + N_PADDING_BITS)
-/* Structs for holding input report data
- *
- * These need to be modified in correspondence with the HID input report
- * descriptor below.
- *
- * The HID usage names differ from the Evdev event names in some cases. For
- * example, touch major/minor are put under width/height and orientation is
- * called azimuth.
- */
-struct finger {
-	/*
-	 * Whether a finger is intentional or not. This could be used to
-	 * identify unintended contacts or palms but is up to the OS
-	 * explanation.
-	 */
-	uint8_t confidence:1;
-	/*
-	 * Whether a finger is touching the surface (leaving/left finger gets
-	 * 0).
-	 */
-	uint8_t tip:1;
-	/*
-	 * Whether a finger is within the sensor range. For example, hovering
-	 * fingers would have tip=0 and inrange=1.
-	 */
-	uint8_t inrange:1;
-	/*
-	 * Contact id. This is like slot numbers in Linux MT-B.
-	 */
-	uint8_t id:5;
-	uint16_t x:N_BITS(I2C_HID_TOUCHPAD_MAX_X);
-	uint16_t y:N_BITS(I2C_HID_TOUCHPAD_MAX_Y);
-	uint16_t width:N_BITS(I2C_HID_TOUCHPAD_MAX_WIDTH);
-	uint16_t height:N_BITS(I2C_HID_TOUCHPAD_MAX_HEIGHT);
-	uint16_t pressure:N_BITS(I2C_HID_TOUCHPAD_MAX_PRESSURE);
-	uint16_t orientation:N_BITS_ORIENTATION;
-} __packed;
-
-struct touch_report {
-	uint8_t button:1;
-	uint8_t count:7;
-	uint16_t timestamp;
-	struct finger finger[I2C_HID_TOUCHPAD_MAX_FINGERS];
-} __packed;
-
-struct mouse_report {
-	uint8_t button1:1;
-	/* Windows expects at least two button usages in a mouse report. Many
-	 * touchpads on the Chromebook are a single clickable surface, so
-	 * button2 isn't used. That said, we may later report a button2 event if
-	 * necessary.
-	 */
-	uint8_t button2:1;
-	uint8_t unused:6;
-	int8_t x;
-	int8_t y;
-} __packed;
-
-/* HID input report descriptor
- *
- * For a complete reference, please see the following docs on usb.org
- *
- * 1. Device Class Definition for HID
- * 2. HID Usage Tables
- */
-static const uint8_t report_desc[] = {
-	/* Mouse Collection */
-	0x05, 0x01,			/* Usage Page (Generic Desktop) */
-	0x09, 0x02,			/* Usage (Mouse) */
-	0xA1, 0x01,			/* Collection (Application) */
-	0x85, REPORT_ID_MOUSE,		/* Report ID (Mouse) */
-	0x09, 0x01,			/*   Usage (Pointer) */
-	0xA1, 0x00,			/*   Collection (Physical) */
-	0x05, 0x09,			/*     Usage Page (Button) */
-	0x19, 0x01,			/*     Usage Minimum (Button 1) */
-	0x29, 0x02,			/*     Usage Maximum (Button 2) */
-	0x15, 0x00,			/*     Logical Minimum (0) */
-	0x25, 0x01,			/*     Logical Maximum (1) */
-	0x75, 0x01,			/*     Report Size (1) */
-	0x95, 0x02,			/*     Report Count (2) */
-	0x81, 0x02,			/*     Input (Data,Var,Abs) */
-	0x95, 0x06,			/*     Report Count (6) */
-	0x81, 0x03,			/*     Input (Cnst,Var,Abs) */
-	0x05, 0x01,			/*     Usage Page (Generic Desktop) */
-	0x09, 0x30,			/*     Usage (X) */
-	0x09, 0x31,			/*     Usage (Y) */
-	0x15, 0x81,			/*     Logical Minimum (-127) */
-	0x25, 0x7F,			/*     Logical Maximum (127) */
-	0x75, 0x08,			/*     Report Size (8) */
-	0x95, 0x02,			/*     Report Count (2) */
-	0x81, 0x06,			/*     Input (Data,Var,Rel) */
-	0xC0,				/*   End Collection */
-	0xC0,				/* End Collection */
-
-	/* Touchpad Collection */
-	0x05, 0x0D,			/* Usage Page (Digitizer) */
-	0x09, 0x05,			/* Usage (Touch Pad) */
-	0xA1, 0x01,			/* Collection (Application) */
-	0x85, REPORT_ID_TOUCH,		/*   Report ID (Touch) */
-
-	/* Button */
-	0x05, 0x09,			/*   Usage Page (Button) */
-	0x19, 0x01,			/*   Usage Minimum (0x01) */
-	0x29, 0x01,			/*   Usage Maximum (0x01) */
-	0x15, 0x00,			/*   Logical Minimum (0) */
-	0x25, 0x01,			/*   Logical Maximum (1) */
-	0x75, 0x01,			/*   Report Size (1) */
-	0x95, 0x01,			/*   Report Count (1) */
-	0x81, 0x02,			/*   Input (Data,Var,Abs) */
-
-	/* Contact count */
-	0x05, 0x0D,			/*   Usage Page (Digitizer) */
-	0x09, 0x54,			/*   Usage (Contact count) */
-	0x25, I2C_HID_TOUCHPAD_MAX_FINGERS,	/* Logical Max. (MAX_FINGERS) */
-	0x75, 0x07,			/*   Report Size (7) */
-	0x95, 0x01,			/*   Report Count (1) */
-	0x81, 0x02,			/*   Input (Data,Var,Abs) */
-
-	/* Scan time */
-	0x55, 0x0C,			/*   Unit Exponent (-4) */
-	0x66, 0x01, 0x10,		/*   Unit (Seconds) */
-	0x47, 0xFF, 0xFF, 0x00, 0x00,	/*   Physical Maximum (65535) */
-	0x27, 0xFF, 0xFF, 0x00, 0x00,	/*   Logical Maximum (65535) */
-	0x75, 0x10,			/*   Report Size (16) */
-	0x95, 0x01,			/*   Report Count (1) */
-	0x05, 0x0D,			/*   Usage Page (Digitizers) */
-	0x09, 0x56,			/*   Usage (Scan Time) */
-	0x81, 0x02,			/*   Input (Data,Var,Abs) */
-
-#define FINGER(FINGER_NUMBER)						       \
-	/* Finger FINGER_NUMBER */					       \
-	0x05, 0x0D,			/*   Usage Page (Digitizer) */         \
-	0x09, 0x22,			/*   Usage (Finger) */                 \
-	0xA1, 0x02,			/*   Collection (Logical) */           \
-	0x09, 0x47,			/*     Usage (Confidence) */           \
-	0x09, 0x42,			/*     Usage (Tip Switch) */           \
-	0x09, 0x32,			/*     Usage (In Range) */             \
-	0x15, 0x00,			/*     Logical Minimum (0) */          \
-	0x25, 0x01,			/*     Logical Maximum (1) */          \
-	0x75, 0x01,			/*     Report Size (1) */              \
-	0x95, 0x03,			/*     Report Count (3) */             \
-	0x81, 0x02,			/*     Input (Data,Var,Abs) */         \
-	0x09, 0x51,			/*     Usage (Contact identifier) */   \
-	0x25, 0x1F,			/*     Logical Maximum (31) */         \
-	0x75, 0x05,			/*     Report Size (5) */              \
-	0x95, 0x01,			/*     Report Count (1) */             \
-	0x81, 0x02,			/*     Input (Data,Var,Abs) */         \
-	0x05, 0x01,			/*     Usage Page (Generic Desktop) */ \
-	0x09, 0x30,			/*     Usage (X) */                    \
-	0x55, 0x0E,			/*     Unit Exponent (-2) */           \
-	0x65, 0x11,			/*     Unit (SI Linear, Length: cm) */ \
-	0x35, 0x00,			/*     Physical Minimum (0) */         \
-	0x46, I2C_HID_TOUCHPAD_MAX_PHYSICAL_X&0xff,			       \
-	      I2C_HID_TOUCHPAD_MAX_PHYSICAL_X>>8,			       \
-					/*     Physical Maximum */	       \
-	0x26, I2C_HID_TOUCHPAD_MAX_X&0xff, I2C_HID_TOUCHPAD_MAX_X>>8,	       \
-					/*     Logical Maximum */	       \
-	0x75, N_BITS(I2C_HID_TOUCHPAD_MAX_X),				       \
-					/*     Report Size */		       \
-	0x81, 0x02,			/*     Input (Data,Var,Abs) */         \
-	0x09, 0x31,			/*     Usage (Y) */                    \
-	0x46, I2C_HID_TOUCHPAD_MAX_PHYSICAL_Y&0xff,			       \
-	      I2C_HID_TOUCHPAD_MAX_PHYSICAL_Y>>8,			       \
-					/*     Physical Maximum */	       \
-	0x26, I2C_HID_TOUCHPAD_MAX_Y&0xff, I2C_HID_TOUCHPAD_MAX_Y>>8,	       \
-					/*     Logical Maximum */	       \
-	0x75, N_BITS(I2C_HID_TOUCHPAD_MAX_Y),				       \
-					/*     Report Size */		       \
-	0x81, 0x02,			/*     Input (Data,Var,Abs) */         \
-	0x05, 0x0D,			/*     Usage Page (Digitizer) */       \
-	0x09, 0x48,			/*     Usage (Width) */                \
-	0x26, I2C_HID_TOUCHPAD_MAX_WIDTH&0xff, I2C_HID_TOUCHPAD_MAX_WIDTH>>8,  \
-					/*     Logical Maximum */	       \
-	0x75, N_BITS(I2C_HID_TOUCHPAD_MAX_WIDTH),			       \
-					/*     Report Size */		       \
-	0x81, 0x02,			/*     Input (Data,Var,Abs) */         \
-	0x09, 0x49,			/*     Usage (Height) */               \
-	0x26, I2C_HID_TOUCHPAD_MAX_HEIGHT&0xff, I2C_HID_TOUCHPAD_MAX_HEIGHT>>8,\
-					/*     Logical Maximum */	       \
-	0x75, N_BITS(I2C_HID_TOUCHPAD_MAX_HEIGHT),			       \
-					/*     Report Size */		       \
-	0x81, 0x02,			/*     Input (Data,Var,Abs) */         \
-	0x09, 0x30,			/*     Usage (Tip pressure) */         \
-	0x26, I2C_HID_TOUCHPAD_MAX_PRESSURE&0xff,			       \
-	      I2C_HID_TOUCHPAD_MAX_PRESSURE>>8,				       \
-					/*     Logical Maximum */	       \
-	0x75, N_BITS(I2C_HID_TOUCHPAD_MAX_PRESSURE),			       \
-					/*     Report Size */		       \
-	0x81, 0x02,			/*     Input (Data,Var,Abs) */         \
-	0x09, 0x3f,			/*     Usage (Azimuth Orientation) */  \
-	0x16, 0x00, 0x00,		/*     Logical Minimum (0) */          \
-	0x26, I2C_HID_TOUCHPAD_MAX_ORIENTATION&0xff,			       \
-	      I2C_HID_TOUCHPAD_MAX_ORIENTATION>>8,			       \
-					/*     Logical Maximum */	       \
-	0x75, N_BITS_ORIENTATION,	/*     Report Size */		       \
-	0x81, 0x02,			/*     Input (Data,Var,Abs) */         \
-	0xC0,				/*   End Collection */
-
-	FINGER(1)
-	FINGER(2)
-	FINGER(3)
-	FINGER(4)
-	FINGER(5)
-
-#undef FINGER
-
-	0x05, 0x0D,			/*   Usage Page (Digitizer) */
-	0x85, REPORT_ID_DEVICE_CAPS,	/*   Report ID (Device Capabilities) */
-	0x09, 0x55,			/*   Usage (Contact Count Maximum) */
-	0x09, 0x59,			/*   Usage (Pad Type) */
-	0x75, 0x08,			/*   Report Size (8) */
-	0x95, 0x02,			/*   Report Count (2) */
-	0x25, 0x0F,			/*   Logical Maximum (15) */
-	0xB1, 0x02,			/*   Feature (Data,Var,Abs) */
-	0x06, 0x00, 0xFF,		/*   Usage Page (Vendor Defined) */
-	0x85, REPORT_ID_DEVICE_CERT,	/*   Report ID (Device Certification) */
-	0x09, 0xC5,			/*   Usage (Vendor Usage 0xC5) */
-	0x15, 0x00,			/*   Logical Minimum (0) */
-	0x26, 0xFF, 0x00,		/*   Logical Maximum (255) */
-	0x75, 0x08,			/*   Report Size (8) */
-	0x96, 0x00, 0x01,		/*   Report Count (256) */
-	0xB1, 0x02,			/*   Feature (Data,Var,Abs) */
-	0xC0,				/* End Collection */
-
-	/* Configuration Collection */
-	0x05, 0x0D,			/* Usage Page (Digitizer) */
-	0x09, 0x0E,			/* Usage (Configuration) */
-	0xA1, 0x01,			/* Collection (Application) */
-	0x85, REPORT_ID_INPUT_MODE,	/*   Report ID (Input Mode) */
-	0x09, 0x22,			/*   Usage (Finger) */
-	0xA1, 0x02,			/*   Collection (Logical) */
-	0x09, 0x52,			/*     Usage (Input Mode) */
-	0x15, 0x00,			/*     Logical Minimum (0) */
-	0x25, 0x0F,			/*     Logical Maximum (15) */
-	0x75, 0x08,			/*     Report Size (8) */
-	0x95, 0x01,			/*     Report Count (1) */
-	0xB1, 0x02,			/*     Feature (Data,Var,Abs) */
-	0xC0,				/*   End Collection */
-	0x09, 0x22,			/*   Usage (Finger) */
-	0xA1, 0x00,			/*   Collection (Physical) */
-	0x85, REPORT_ID_REPORTING,	/*     Report ID (Selective Reporting)*/
-	0x09, 0x57,			/*     Usage (Surface Switch) */
-	0x09, 0x58,			/*     Usage (Button Switch) */
-	0x75, 0x04,			/*     Report Size (4) */
-	0x95, 0x02,			/*     Report Count (2) */
-	0x25, 0x01,			/*     Logical Maximum (1) */
-	0xB1, 0x02,			/*     Feature (Data,Var,Abs) */
-	0xC0,				/*   End Collection */
-	0xC0,				/* End Collection */
-};
-
-static const uint8_t device_caps[] = {
-	I2C_HID_TOUCHPAD_MAX_FINGERS,	/* Contact Count Maximum */
-	0x00,				/* Pad Type: Depressible click-pad */
-};
-
-/* A 256-byte default blob for the 'device certification status' feature report
- * expected by Windows.
- */
-static const uint8_t device_cert[] = {
-	0xFC, 0x28, 0xFE, 0x84, 0x40, 0xCB, 0x9A, 0x87,
-	0x0D, 0xBE, 0x57, 0x3C, 0xB6, 0x70, 0x09, 0x88,
-	0x07, 0x97, 0x2D, 0x2B, 0xE3, 0x38, 0x34, 0xB6,
-	0x6C, 0xED, 0xB0, 0xF7, 0xE5, 0x9C, 0xF6, 0xC2,
-	0x2E, 0x84, 0x1B, 0xE8, 0xB4, 0x51, 0x78, 0x43,
-	0x1F, 0x28, 0x4B, 0x7C, 0x2D, 0x53, 0xAF, 0xFC,
-	0x47, 0x70, 0x1B, 0x59, 0x6F, 0x74, 0x43, 0xC4,
-	0xF3, 0x47, 0x18, 0x53, 0x1A, 0xA2, 0xA1, 0x71,
-	0xC7, 0x95, 0x0E, 0x31, 0x55, 0x21, 0xD3, 0xB5,
-	0x1E, 0xE9, 0x0C, 0xBA, 0xEC, 0xB8, 0x89, 0x19,
-	0x3E, 0xB3, 0xAF, 0x75, 0x81, 0x9D, 0x53, 0xB9,
-	0x41, 0x57, 0xF4, 0x6D, 0x39, 0x25, 0x29, 0x7C,
-	0x87, 0xD9, 0xB4, 0x98, 0x45, 0x7D, 0xA7, 0x26,
-	0x9C, 0x65, 0x3B, 0x85, 0x68, 0x89, 0xD7, 0x3B,
-	0xBD, 0xFF, 0x14, 0x67, 0xF2, 0x2B, 0xF0, 0x2A,
-	0x41, 0x54, 0xF0, 0xFD, 0x2C, 0x66, 0x7C, 0xF8,
-	0xC0, 0x8F, 0x33, 0x13, 0x03, 0xF1, 0xD3, 0xC1,
-	0x0B, 0x89, 0xD9, 0x1B, 0x62, 0xCD, 0x51, 0xB7,
-	0x80, 0xB8, 0xAF, 0x3A, 0x10, 0xC1, 0x8A, 0x5B,
-	0xE8, 0x8A, 0x56, 0xF0, 0x8C, 0xAA, 0xFA, 0x35,
-	0xE9, 0x42, 0xC4, 0xD8, 0x55, 0xC3, 0x38, 0xCC,
-	0x2B, 0x53, 0x5C, 0x69, 0x52, 0xD5, 0xC8, 0x73,
-	0x02, 0x38, 0x7C, 0x73, 0xB6, 0x41, 0xE7, 0xFF,
-	0x05, 0xD8, 0x2B, 0x79, 0x9A, 0xE2, 0x34, 0x60,
-	0x8F, 0xA3, 0x32, 0x1F, 0x09, 0x78, 0x62, 0xBC,
-	0x80, 0xE3, 0x0F, 0xBD, 0x65, 0x20, 0x08, 0x13,
-	0xC1, 0xE2, 0xEE, 0x53, 0x2D, 0x86, 0x7E, 0xA7,
-	0x5A, 0xC5, 0xD3, 0x7D, 0x98, 0xBE, 0x31, 0x48,
-	0x1F, 0xFB, 0xDA, 0xAF, 0xA2, 0xA8, 0x6A, 0x89,
-	0xD6, 0xBF, 0xF2, 0xD3, 0x32, 0x2A, 0x9A, 0xE4,
-	0xCF, 0x17, 0xB7, 0xB8, 0xF4, 0xE1, 0x33, 0x08,
-	0x24, 0x8B, 0xC4, 0x43, 0xA5, 0xE5, 0x24, 0xC2,
-};
-
-#define MAX_SIZEOF(a, b) (sizeof(a) > sizeof(b) ? sizeof(a) : sizeof(b))
-
-static struct i2c_hid_descriptor hid_desc = {
-	.wHIDDescLength = I2C_HID_DESC_LENGTH,
-	.bcdVersion = I2C_HID_BCD_VERSION,
-	.wReportDescLength = sizeof(report_desc),
-	.wReportDescRegister = I2C_HID_REPORT_DESC_REGISTER,
-	.wInputRegister = I2C_HID_INPUT_REPORT_REGISTER,
-	.wMaxInputLength = I2C_HID_HEADER_SIZE +
-			   MAX_SIZEOF(struct touch_report, struct mouse_report),
-	.wOutputRegister = 0,
-	.wMaxOutputLength = 0,
-	.wCommandRegister = I2C_HID_COMMAND_REGISTER,
-	.wDataRegister = I2C_HID_DATA_REGISTER,
-	.wVendorID = I2C_HID_TOUCHPAD_VENDOR_ID,
-	.wProductID = I2C_HID_TOUCHPAD_PRODUCT_ID,
-	.wVersionID = I2C_HID_TOUCHPAD_FW_VERSION,
-};
-
-/*
- * In I2C HID, the host would request for an input report immediately following
- * the protocol initialization. The device is required to respond with exactly
- * 2 empty bytes. Furthermore, some hosts may use a single byte SMBUS read to
- * check if the device exists on the specified I2C address.
- *
- * These variables record if such probing/initialization have been done before.
- */
-static bool pending_probe;
-static bool pending_reset;
-
-/* Reports (double buffered) */
-#define MAX_REPORT_CNT	2
-
-static struct touch_report touch_reports[MAX_REPORT_CNT];
-static struct mouse_report mouse_reports[MAX_REPORT_CNT];
-
-/* Current active report buffer index */
-static int report_active_index;
-
-/* Current input mode */
-static uint8_t input_mode;
-
-/*
- * TODO(b/151693566): Selectively report surface contact and button state in
- * input reports based on |reporting.surface_switch| and
- * |reporting.button_switch|, respectively.
- */
-struct selective_reporting {
-	uint8_t surface_switch:4;
-	uint8_t button_switch:4;
-} __packed;
-
-static struct selective_reporting reporting;
-
-/* Function declarations */
-static int i2c_hid_touchpad_command_process(size_t len, uint8_t *buffer,
-					    void (*send_response)(int len),
-					    uint8_t *data);
-
-static size_t fill_report(uint8_t *buffer, uint8_t report_id, const void *data,
-			  size_t data_len)
-{
-	size_t response_len = I2C_HID_HEADER_SIZE + data_len;
-
-	buffer[0] = response_len & 0xFF;
-	buffer[1] = (response_len >> 8) & 0xFF;
-	buffer[2] = report_id;
-	memcpy(buffer + I2C_HID_HEADER_SIZE, data, data_len);
-	return response_len;
-}
-
-/*
- * Extracts report data from |buffer| into |data| for reports from the host.
- *
- * |buffer| is expected to contain the values written to the command register
- * followed by the values written to the data register, upon receiving a
- * SET_REPORT command, in the following byte sequence format:
- *
- *   00 30 - command register address (0x3000)
- *   xx    - report type and ID
- *   03    - SET_REPORT
- *   00 30 - data register address (0x3000)
- *   xx xx - length
- *   xx    - report ID
- *   xx... - report data
- *
- * Note that command register and data register have the same address. Also,
- * any report ID >= 15 requires an extra byte after the SET_REPORT byte, which
- * is not supported here as we don't have any report ID >= 15.
- *
- * In summary, we expect |buffer| contains at least 10 bytes where the report
- * data starts at buffer[9]. If |buffer| contains the incorrect number bytes,
- * we ignore the report.
- */
-static void extract_report(size_t len, const uint8_t *buffer, void *data,
-			   size_t data_len)
-{
-	if (len != 9 + data_len) {
-		ccprints("I2C-HID: SET_REPORT buffer length mismatch");
-		return;
-	}
-	memcpy(data, buffer + 9, data_len);
-}
-
-void i2c_hid_touchpad_init(void)
-{
-	input_mode = INPUT_MODE_MOUSE;
-	reporting.surface_switch = 1;
-	reporting.button_switch = 1;
-	report_active_index = 0;
-
-	// Respond probing requests for now.
-	pending_probe = true;
-	pending_reset = false;
-}
-
-int i2c_hid_touchpad_process(unsigned int len, uint8_t *buffer,
-			     void (*send_response)(int len), uint8_t *data,
-			     int *reg, int *cmd)
-{
-	size_t response_len;
-
-	if (len == 0)
-		*reg = I2C_HID_INPUT_REPORT_REGISTER;
-	else
-		*reg = UINT16_FROM_BYTE_ARRAY_LE(buffer, 0);
-
-	*cmd = 0;
-	switch (*reg) {
-	case I2C_HID_HID_DESC_REGISTER:
-		memcpy(buffer, &hid_desc, sizeof(hid_desc));
-		send_response(sizeof(hid_desc));
-		break;
-	case I2C_HID_REPORT_DESC_REGISTER:
-		memcpy(buffer, &report_desc, sizeof(report_desc));
-		send_response(sizeof(report_desc));
-		break;
-	case I2C_HID_INPUT_REPORT_REGISTER:
-		// Single-byte read probing.
-		if (pending_probe) {
-			buffer[0] = 0;
-			send_response(1);
-			break;
-		}
-		// Reset protocol: 2 empty bytes.
-		if (pending_reset) {
-			pending_reset = false;
-			buffer[0] = 0;
-			buffer[1] = 0;
-			send_response(2);
-			break;
-		}
-		// Common input report requests.
-		if (input_mode == INPUT_MODE_TOUCH) {
-			response_len =
-				fill_report(buffer, REPORT_ID_TOUCH,
-					    &touch_reports[report_active_index],
-					    sizeof(struct touch_report));
-		} else {
-			response_len =
-				fill_report(buffer, REPORT_ID_MOUSE,
-					    &mouse_reports[report_active_index],
-					    sizeof(struct mouse_report));
-		}
-		send_response(response_len);
-		break;
-	case I2C_HID_COMMAND_REGISTER:
-		*cmd = i2c_hid_touchpad_command_process(len, buffer,
-						       send_response, data);
-		break;
-	default:
-		/* Unknown register has been received. */
-		return EC_ERROR_INVAL;
-	}
-	/* Unknown command has been received. */
-	if (*cmd < 0)
-		return EC_ERROR_INVAL;
-	return EC_SUCCESS;
-}
-
-static int i2c_hid_touchpad_command_process(size_t len, uint8_t *buffer,
-					    void (*send_response)(int len),
-					    uint8_t *data)
-{
-	uint8_t command = buffer[3] & 0x0F;
-	uint8_t power_state = buffer[2] & 0x03;
-	uint8_t report_id = buffer[2] & 0x0F;
-	size_t response_len;
-
-	switch (command) {
-	case I2C_HID_CMD_RESET:
-		i2c_hid_touchpad_init();
-		// Wait for the 2-bytes I2C read following the protocol reset.
-		pending_probe = false;
-		pending_reset = true;
-		break;
-	case I2C_HID_CMD_GET_REPORT:
-		switch (report_id) {
-		case REPORT_ID_TOUCH:
-			response_len =
-				fill_report(buffer, report_id,
-					    &touch_reports[report_active_index],
-					    sizeof(struct touch_report));
-			break;
-		case REPORT_ID_MOUSE:
-			response_len =
-				fill_report(buffer, report_id,
-					    &mouse_reports[report_active_index],
-					    sizeof(struct mouse_report));
-			break;
-		case REPORT_ID_DEVICE_CAPS:
-			response_len = fill_report(buffer, report_id,
-						   &device_caps,
-						   sizeof(device_caps));
-			break;
-		case REPORT_ID_DEVICE_CERT:
-			response_len = fill_report(buffer, report_id,
-						   &device_cert,
-						   sizeof(device_cert));
-			break;
-		case REPORT_ID_INPUT_MODE:
-			response_len = fill_report(buffer, report_id,
-						   &input_mode,
-						   sizeof(input_mode));
-			break;
-		case REPORT_ID_REPORTING:
-			response_len = fill_report(buffer, report_id,
-						   &reporting,
-						   sizeof(reporting));
-			break;
-		default:
-			response_len = 2;
-			buffer[0] = response_len;
-			buffer[1] = 0;
-			break;
-		}
-		send_response(response_len);
-		break;
-	case I2C_HID_CMD_SET_REPORT:
-		switch (report_id) {
-		case REPORT_ID_INPUT_MODE:
-			extract_report(len, buffer, &input_mode,
-				       sizeof(input_mode));
-			break;
-		case REPORT_ID_REPORTING:
-			extract_report(len, buffer, &reporting,
-				       sizeof(reporting));
-			break;
-		default:
-			break;
-		}
-		break;
-	case I2C_HID_CMD_SET_POWER:
-		/*
-		 * Return the power setting so the user can actually set the
-		 * touch controller's power state in board level.
-		 */
-		*data = power_state;
-		break;
-	default:
-		return -1;
-	}
-	return command;
-}
-
-void i2c_hid_compile_report(struct touchpad_event *event)
-{
-	/* Save report into back buffer */
-	struct touch_report *touch = &touch_reports[report_active_index ^ 1];
-	struct touch_report *touch_old = &touch_reports[report_active_index];
-	struct mouse_report *mouse = &mouse_reports[report_active_index ^ 1];
-	int contact_num = 0;
-
-	/* Touch report. */
-	memset(touch, 0, sizeof(struct touch_report));
-	for (int i = 0; i < I2C_HID_TOUCHPAD_MAX_FINGERS; i++) {
-		if (event->finger[i].valid) {
-			/*
-			 * Windows considers any contact with width or height
-			 * greater than 25mm to unintended, and expects the
-			 * confidence value to be cleared for such a contact.
-			 * We, however, haven't seen a touchpad that actually
-			 * forwards that information to us.
-			 *
-			 * TODO(b/151692377): Revisit this once we have met such
-			 * a device.
-			 */
-			touch->finger[i].confidence = 1;
-			touch->finger[i].tip = 1;
-			touch->finger[i].inrange = 1;
-			touch->finger[i].x = event->finger[i].x;
-			touch->finger[i].y = event->finger[i].y;
-			touch->finger[i].width = event->finger[i].width;
-			touch->finger[i].height = event->finger[i].height;
-			touch->finger[i].pressure = event->finger[i].pressure;
-			if (event->finger[i].is_palm)
-				touch->finger[i].pressure =
-						I2C_HID_TOUCHPAD_MAX_PRESSURE;
-			touch->finger[i].orientation =
-					event->finger[i].orientation;
-			contact_num++;
-		} else if (touch_old->finger[i].tip) {
-			/*
-			 * When the finger is leaving, we first clear the tip
-			 * bit while retaining the other values. We then clear
-			 * the other values at the next frame where the finger
-			 * has left.
-			 *
-			 * Setting tip to 0 implies that the finger is leaving
-			 * for both CrOS and Windows. A leaving finger would
-			 * never be re-considered by the OS.
-			 */
-
-			/*
-			 * First, copy old values from the previous report.
-			 *
-			 * This is suggested on Windows although no
-			 * obvious problem has been noticed by not doing
-			 * so.
-			 */
-			touch->finger[i] = touch_old->finger[i];
-
-			/*
-			 * Leaving finger is not a palm by definition.
-			 *
-			 * Not clearing the confidence bit is essential
-			 * for tap-to-click to work on Windows.
-			 */
-			touch->finger[i].confidence = 1;
-
-			/* Leaving finger doesn't exist. */
-			touch->finger[i].tip = 0;
-
-			/*
-			 * Assume that the leaving finger is not hovering
-			 * either. We would inject one single fake hovering
-			 * finger later if necessary.
-			 */
-			touch->finger[i].inrange = 0;
-
-			contact_num++;
-		}
-
-		/* id is like slot in Linux MT-B so it is fixed every time. */
-		touch->finger[i].id = i;
-	}
-
-	/* Check for hovering activity if there is no contact report. */
-	if (!contact_num) {
-		if (event->hover) {
-			/* Put a fake finger at slot #0 if hover is detected. */
-			touch->finger[0].inrange = 1;
-			touch->finger[0].x = I2C_HID_TOUCHPAD_MAX_X / 2;
-			touch->finger[0].y = I2C_HID_TOUCHPAD_MAX_Y / 2;
-			contact_num++;
-		} else if (!touch_old->finger[0].tip &&
-			   touch_old->finger[0].inrange) {
-			/* Clear the fake hovering finger for host. */
-			contact_num++;
-		}
-	}
-
-	/* Fill in finger counts and the button state. */
-	touch->count = I2C_HID_TOUCHPAD_MAX_FINGERS;
-	touch->button = event->button;
-
-	/*
-	 * Windows expects scan time to be in units of 100us.  As Windows
-	 * measures the delta of scan times between the first and the current
-	 * report, we simply report the __hw_clock_source_read() value (which
-	 * is in resolution of 1us) divided by 100 as the scan time.
-	 */
-	touch->timestamp = __hw_clock_source_read() / 100;
-
-	/* Mouse report. */
-	mouse->button1 = touch->button;
-	if (touch->finger[0].tip == 1 && touch_old->finger[0].tip == 1) {
-		/*
-		 * The relative X/Y movements in the mouse report are computed
-		 * based on the deltas of absolute X/Y positions between the
-		 * previous and current touch report. The computed deltas need
-		 * to be scaled for a smooth mouse movement.
-		 */
-		mouse->x = (touch->finger[0].x - touch_old->finger[0].x) /
-			   I2C_HID_TOUCHPAD_MOUSE_SCALE_X;
-		mouse->y = (touch->finger[0].y - touch_old->finger[0].y) /
-			   I2C_HID_TOUCHPAD_MOUSE_SCALE_Y;
-	} else {
-		mouse->x = 0;
-		mouse->y = 0;
-	}
-
-	/* Swap buffer */
-	report_active_index ^= 1;
-}