Cyan: Added Clamshell/Tablet mode support

Enabled lid angle calculation. Clamshell/Tablet mode is decided by lid angle.
Accelerometers are set to be active in S3 also.
Trackpad is enabled/disabled by GPIO TP_INT_DISABLE.
Keyboard scan and trackpad are enabled in clamshell mode and disabled in
tablet mode.
Removed enable_keyboard() since keyboard is enabled in clamshell S0 and
S3.

BUG=chrome-os-partner:41353
TEST=Verify in clamshell mode, system can be waken up from S3 by keyboard/trackpad;
And not tablet mode.
BRANCH=None

Change-Id: Ic5fb5a562e8426288eae2fb9815a213fe5033955
Signed-off-by: li feng <li1.feng@intel.com>
Signed-off-by: Shamile Khan <shamile.khan@intel.com>
Reviewed-on: https://chromium-review.googlesource.com/287341
Reviewed-by: Shawn N <shawnn@chromium.org>

1 files changed, 79 insertions, 82 deletions

diff --git a/common/lid_angle.c b/common/lid_angle.c
index eb6f6c94b5..f6091f4349 100644
--- a/common/lid_angle.c
+++ b/common/lid_angle.c
@@ -12,6 +12,8 @@
 #include "keyboard_scan.h"
 #include "lid_angle.h"
 #include "lid_switch.h"
+#include "math_util.h"
+#include "motion_lid.h"
 #include "motion_sense.h"
 
 /* Console output macros */
@@ -20,21 +22,22 @@
 
 /*
  * Define the number of previous lid angle measurements to keep for determining
- * whether to enable or disable key scanning. Note, that in order to change
- * the state of key scanning, all stored measurements of the lid angle buffer
- * must be in the specified range.
+ * whether to enable or disable peripherals that are only needed for laptop
+ * mode. These incude keyboard and trackpad. Note, that in order to change the
+ * enable/disable state of these peripherals, all stored measurements of the
+ * lid angle buffer must be in the specified range.
  */
-#define KEY_SCAN_LID_ANGLE_BUFFER_SIZE 4
+#define LID_ANGLE_BUFFER_SIZE 4
 
 /*
- * Define two variables to determine if keyboard scanning should be enabled
- * or disabled in S3 based on the current lid angle. Note, the lid angle is
- * bound to [0, 360]. Here are two angles, defined such that we segregate the
- * lid angle space into two regions. The first region is the region in which
- * we enable keyboard scanning in S3 and is when the lid angle CCW of the
- * small_angle and CW of the large_angle. The second region is the region in
- * which we disable keyboard scanning in S3 and is when the lid angle is CCW
- * of the large_angle and CW of the small_angle.
+ * Define two variables to determine if wake source peripherals that are only
+ * applicable for laptop mode should be enabled or disabled in S3 based on the
+ * current lid angle. Note, the lid angle is bound to [0, 360]. Here are two
+ * angles, defined such that we segregate the lid angle space into two regions.
+ * The first region is the region in which we enable peripherals in S3 and is
+ * when the lid angle CCW of the small_angle and CW of the large_angle. The
+ * second region is the region in which we disable peripherals in S3 and is when
+ * the lid angle is CCW of the large_angle and CW of the small_angle.
  *
  * Note, the most sensical values are small_angle = 0 and large_angle = 180,
  * but, the angle measurement is not perfect, and we know that if the angle is
@@ -42,128 +45,122 @@
  * small_angle is set to a small positive value to make sure we don't swap modes
  * when the lid is open all the way but is measuring a small positive value.
  */
-static int kb_wake_large_angle = 180;
-static const int kb_wake_small_angle = 13;
+static int wake_large_angle = 180;
+static const int wake_small_angle = 13;
 
-/* Define hysteresis value to add stability to the keyboard scanning flag. */
-#define KB_DIS_HYSTERESIS_DEG  2
+/* Define hysteresis value to add stability to the flags. */
+#define LID_ANGLE_HYSTERESIS_DEG  2
 
-/* Define max and min values for kb_wake_large_angle. */
-#define KB_DIS_MIN_LARGE_ANGLE 0
-#define KB_DIS_MAX_LARGE_ANGLE 360
+/* Define max and min values for wake_large_angle. */
+#define LID_ANGLE_MIN_LARGE_ANGLE 0
+#define LID_ANGLE_MAX_LARGE_ANGLE 360
 
 /**
- * Determine if given angle is in region to accept keyboard presses.
+ * Determine if given angle is in region to enable peripherals.
  *
  * @param ang Some lid angle in degrees [0, 360]
  *
  * @return true/false
  */
-static int lid_in_range_to_accept_keys(int ang)
+static int lid_in_range_to_enable_peripherals(int ang)
 {
 	/*
-	 * If the keyboard wake large angle is min or max, then this
-	 * function should return false or true respectively, independent of
-	 * input angle.
+	 * If the wake large angle is min or max, then this function should
+	 * return false or true respectively, independent of input angle.
 	 */
-	if (kb_wake_large_angle == KB_DIS_MIN_LARGE_ANGLE)
+	if (wake_large_angle == LID_ANGLE_MIN_LARGE_ANGLE)
 		return 0;
-	else if (kb_wake_large_angle == KB_DIS_MAX_LARGE_ANGLE)
+	else if (wake_large_angle == LID_ANGLE_MAX_LARGE_ANGLE)
 		return 1;
 
-	return  (ang >= (kb_wake_small_angle + KB_DIS_HYSTERESIS_DEG)) &&
-		(ang <= (kb_wake_large_angle - KB_DIS_HYSTERESIS_DEG));
+	return  (ang >= (wake_small_angle + LID_ANGLE_HYSTERESIS_DEG)) &&
+		(ang <= (wake_large_angle - LID_ANGLE_HYSTERESIS_DEG));
 }
 
 /**
- * Determine if given angle is in region to ignore keyboard presses.
+ * Determine if given angle is in region to ignore peripherals.
  *
  * @param ang Some lid angle in degrees [0, 360]
  *
  * @return true/false
  */
-static int lid_in_range_to_ignore_keys(int ang)
+static int lid_in_range_to_ignore_peripherals(int ang)
 {
 	/*
-	 * If the keyboard wake large angle is min or max, then this
-	 * function should return true or false respectively, independent of
-	 * input angle.
+	 * If the wake large angle is min or max, then this function should
+	 * return true or false respectively, independent of input angle.
 	 */
-	if (kb_wake_large_angle == KB_DIS_MIN_LARGE_ANGLE)
+	if (wake_large_angle == LID_ANGLE_MIN_LARGE_ANGLE)
 		return 1;
-	else if (kb_wake_large_angle == KB_DIS_MAX_LARGE_ANGLE)
+	else if (wake_large_angle == LID_ANGLE_MAX_LARGE_ANGLE)
 		return 0;
 
-	return  (ang <= (kb_wake_small_angle - KB_DIS_HYSTERESIS_DEG)) ||
-		(ang >= (kb_wake_large_angle + KB_DIS_HYSTERESIS_DEG));
+	return  (ang <= (wake_small_angle - LID_ANGLE_HYSTERESIS_DEG)) ||
+		(ang >= (wake_large_angle + LID_ANGLE_HYSTERESIS_DEG));
 }
 
 
-int lid_angle_get_kb_wake_angle(void)
+int lid_angle_get_wake_angle(void)
 {
-	return kb_wake_large_angle;
+	return wake_large_angle;
 }
 
-void lid_angle_set_kb_wake_angle(int ang)
+void lid_angle_set_wake_angle(int ang)
 {
-	if (ang < KB_DIS_MIN_LARGE_ANGLE)
-		ang = KB_DIS_MIN_LARGE_ANGLE;
-	else if (ang > KB_DIS_MAX_LARGE_ANGLE)
-		ang = KB_DIS_MAX_LARGE_ANGLE;
+	if (ang < LID_ANGLE_MIN_LARGE_ANGLE)
+		ang = LID_ANGLE_MIN_LARGE_ANGLE;
+	else if (ang > LID_ANGLE_MAX_LARGE_ANGLE)
+		ang = LID_ANGLE_MAX_LARGE_ANGLE;
 
-	kb_wake_large_angle = ang;
+	wake_large_angle = ang;
 }
 
-void lidangle_keyscan_update(int lid_ang)
+void lid_angle_update(int lid_ang)
 {
-	static int lidangle_buffer[KEY_SCAN_LID_ANGLE_BUFFER_SIZE];
+	static int lidangle_buffer[LID_ANGLE_BUFFER_SIZE];
 	static int index;
-
 	int i;
-	int keys_accept = 1, keys_ignore = 1;
+	int accept = 1, ignore = 1;
 
 	/* Record most recent lid angle in circular buffer. */
 	lidangle_buffer[index] = lid_ang;
-	index = (index == KEY_SCAN_LID_ANGLE_BUFFER_SIZE-1) ? 0 : index+1;
+	index = (index == LID_ANGLE_BUFFER_SIZE-1) ? 0 : index+1;
 
 	/*
-	 * Any time the chipset is off, manage whether or not keyboard scanning
-	 * is enabled based on lid angle history.
+	 * Manage whether or not peripherals are enabled based on lid angle
+	 * history.
 	 */
-	if (!chipset_in_state(CHIPSET_STATE_ON)) {
-		for (i = 0; i < KEY_SCAN_LID_ANGLE_BUFFER_SIZE; i++) {
-			/*
-			 * If any lid angle samples are unreliable, then
-			 * don't change keyboard scanning state.
-			 */
-			if (lidangle_buffer[i] == LID_ANGLE_UNRELIABLE)
-				return;
-
-			/*
-			 * Force all elements of the lid angle buffer to be
-			 * in range of one of the conditions in order to change
-			 * to the corresponding key scanning state.
-			 */
-			if (!lid_in_range_to_accept_keys(lidangle_buffer[i]))
-				keys_accept = 0;
-			if (!lid_in_range_to_ignore_keys(lidangle_buffer[i]))
-				keys_ignore = 0;
-		}
-
-		/* Enable or disable keyboard scanning as necessary. */
-		if (keys_accept)
-			keyboard_scan_enable(1, KB_SCAN_DISABLE_LID_ANGLE);
-		else if (keys_ignore && !keys_accept)
-			keyboard_scan_enable(0, KB_SCAN_DISABLE_LID_ANGLE);
+	for (i = 0; i < LID_ANGLE_BUFFER_SIZE; i++) {
+		/*
+		 * If any lid angle samples are unreliable, then
+		 * don't change peripheral state.
+		 */
+		if (lidangle_buffer[i] == LID_ANGLE_UNRELIABLE)
+			return;
+
+		/*
+		 * Force all elements of the lid angle buffer to be
+		 * in range of one of the conditions in order to change
+		 * to the corresponding peripheral state.
+		 */
+		if (!lid_in_range_to_enable_peripherals(lidangle_buffer[i]))
+			accept = 0;
+		if (!lid_in_range_to_ignore_peripherals(lidangle_buffer[i]))
+			ignore = 0;
 	}
+
+	/* Enable or disable peripherals as necessary. */
+	if (accept)
+		lid_angle_peripheral_enable(1);
+	else if (ignore && !accept)
+		lid_angle_peripheral_enable(0);
 }
 
-static void enable_keyboard(void)
+static void enable_peripherals(void)
 {
 	/*
-	 * Make sure lid angle is not disabling keyboard scanning when AP is
-	 * running.
+	 * Make sure lid angle is not disabling peripherals when AP is running.
 	 */
-	keyboard_scan_enable(1, KB_SCAN_DISABLE_LID_ANGLE);
+	lid_angle_peripheral_enable(1);
 }
-DECLARE_HOOK(HOOK_CHIPSET_RESUME, enable_keyboard, HOOK_PRIO_DEFAULT);
+DECLARE_HOOK(HOOK_CHIPSET_RESUME, enable_peripherals, HOOK_PRIO_DEFAULT);