tree 3afb37d416abad2d906218bcac201041a0bbef1c
parent 23232827783e84aad794c525533edacc8d8750e6
author Matt DeVillier <matt.devillier@gmail.com> 1505167285 -0500
committer Felix Held <felix-coreboot@felixheld.de> 1684002993 +0000

mb/google/stout: Use board-specific PS2M HID/CID to enable multitouch

Use board-specific ASL for PS2-attached trackpad rather than the EC/SIO
default, so that Windows installs a multitouch-capable driver rather
than the standard PS2 mouse driver.

TEST=build/boot Win11 on google/stout, verify trackpad is multitouch
capable.

Change-Id: Id93bbe53f35b1e2c35e36d8175889786b9f5de8b
Signed-off-by: Matt DeVillier <matt.devillier@gmail.com>
Reviewed-on: https://review.coreboot.org/c/coreboot/+/75176
Reviewed-by: Felix Held <felix-coreboot@felixheld.de>
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
