tree 358acf2c06e4daae7dea9a4007d382118ed49cbe
parent 496362d7e11947504b59e380605f96295a676385
author Nicholas Chin <nic.c3.14@gmail.com> 1717865144 -0600
committer Felix Held <felix-coreboot@felixheld.de> 1718015885 +0000

MAINTAINERS: Add Nicholas Chin for all Dell Latitudes

All of the Dell Latitudes from GM45 and until at least Haswell use a
derivative of the MEC5035 EC, and I have been actively working on
coreboot support for this EC and boards that use it. Rename the "E6400
MAINBOARD" section to "DELL LATITUDE" and add mb/dell/snb_ivb_latitude
and mb/dell/e7240 as additional paths.

Change-Id: I7ba46980bfc8569a85593e415f01cc83fe7d67d7
Signed-off-by: Nicholas Chin <nic.c3.14@gmail.com>
Reviewed-on: https://review.coreboot.org/c/coreboot/+/83008
Reviewed-by: Felix Singer <service+coreboot-gerrit@felixsinger.de>
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
